ZGlmZiAtLWdpdCBhLy5tYWlsbWFwIGIvLm1haWxtYXAKaW5kZXggNTgxZmQzOS4uMWViYTI4YSAxMDA2NDQKLS0tIGEvLm1haWxtYXAKKysrIGIvLm1haWxtYXAKQEAgLTIzLDYgKzIzLDcgQEAKIEFybmF1ZCBQYXRhcmQgPGFybmF1ZC5wYXRhcmRAcnRwLW5ldC5vcmc+CiBBcm5kIEJlcmdtYW5uIDxhcm5kQGFybmRiLmRlPgogQXhlbCBEeWtzIDx4bEB4bHNpZ25lZC5uZXQ+CitBeGVsIExpbiA8YXhlbC5saW5AZ21haWwuY29tPgogQmVuIEdhcmRuZXIgPGJnYXJkbmVyQHdhYnRlYy5jb20+CiBCZW4gTSBDYWhpbGwgPGJlbi5tLmNhaGlsbEBpbnRlbC5jb20+CiBCasO2cm4gU3RlaW5icmluayA8Qi5TdGVpbmJyaW5rQGdteC5kZT4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vQUJJL3N0YWJsZS90aGVybWFsLW5vdGlmaWNhdGlvbiBiL0RvY3VtZW50YXRpb24vQUJJL3N0YWJsZS90aGVybWFsLW5vdGlmaWNhdGlvbgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45NzIzZThiCi0tLSAvZGV2L251bGwKKysrIGIvRG9jdW1lbnRhdGlvbi9BQkkvc3RhYmxlL3RoZXJtYWwtbm90aWZpY2F0aW9uCkBAIC0wLDAgKzEsNCBAQAorV2hhdDoJCUEgbm90aWZpY2F0aW9uIG1lY2hhbmlzbSBmb3IgdGhlcm1hbCByZWxhdGVkIGV2ZW50cworRGVzY3JpcHRpb246CisJVGhpcyBpbnRlcmZhY2UgZW5hYmxlcyBub3RpZmljYXRpb24gZm9yIHRoZXJtYWwgcmVsYXRlZCBldmVudHMuCisJVGhlIG5vdGlmaWNhdGlvbiBpcyBpbiB0aGUgZm9ybSBvZiBhIG5ldGxpbmsgZXZlbnQuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5c2ZzLXBsYXRmb3JtLWF0OTEgYi9Eb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5c2ZzLXBsYXRmb3JtLWF0OTEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNGNjNmE4NgotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMtcGxhdGZvcm0tYXQ5MQpAQCAtMCwwICsxLDI1IEBACitXaGF0OgkJL3N5cy9kZXZpY2VzL3BsYXRmb3JtL2F0OTFfY2FuL25ldC88aWZhY2U+L21iMF9pZAorRGF0ZToJCUphbnVhcnkgMjAxMQorS2VybmVsVmVyc2lvbjoJMi42LjM4CitDb250YWN0OglNYXJjIEtsZWluZS1CdWRkZSA8a2VybmVsQHBlbmd1dHJvbml4LmRlPgorRGVzY3JpcHRpb246CisJCVZhbHVlIHJlcHJlc2VudGluZyB0aGUgY2FuX2lkIG9mIG1haWxib3ggMC4KKworCQlEZWZhdWx0OiAweDdmZiAoc3RhbmRhcmQgZnJhbWUpCisKKwkJRHVlIHRvIGEgY2hpcCBidWcgKGVycmF0YSA1MC4yLjYuMyAmIDUwLjMuNS4zIGluCisJCSJBVDkxU0FNOTI2MyBQcmVsaW1pbmFyeSA2MjQ5SC1BVEFSTS0yNy1KdWwtMDkiKSB0aGUKKwkJY29udGVudHMgb2YgbWFpbGJveCAwIG1heSBiZSBzZW5kIHVuZGVyIGNlcnRhaW4KKwkJY29uZGl0aW9ucyAoZXZlbiBpZiBkaXNhYmxlZCBvciBpbiByeCBtb2RlKS4KKworCQlUaGUgd29ya2Fyb3VuZCBpbiB0aGUgZXJyYXRhIHN1Z2dlc3RzIG5vdCB0byB1c2UgdGhlCisJCW1haWxib3ggYW5kIGxvYWQgaXQgd2l0aCBhbiB1bnVzZWQgaWRlbnRpZmllci4KKworCQlJbiBvcmRlciB0byB1c2UgYW4gZXh0ZW5kZWQgY2FuX2lkIGFkZCB0aGUKKwkJQ0FOX0VGRl9GTEFHICgweDgwMDAwMDAwVSkgdG8gdGhlIGNhbl9pZC4gRXhhbXBsZToKKworCQktIHN0YW5kYXJkIGlkIDB4N2ZmOgorCQllY2hvIDB4N2ZmICAgICAgPiAvc3lzL2NsYXNzL25ldC9jYW4wL21iMF9pZAorCisJCS0gZXh0ZW5kZWQgaWQgMHgxZmZmZmZmZjoKKwkJZWNobyAweDlmZmZmZmZmID4gL3N5cy9jbGFzcy9uZXQvY2FuMC9tYjBfaWQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vRG9jQm9vay84MDIxMS50bXBsIGIvRG9jdW1lbnRhdGlvbi9Eb2NCb29rLzgwMjExLnRtcGwKaW5kZXggMDM2NDFhMC4uODkwNjY0OCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rLzgwMjExLnRtcGwKKysrIGIvRG9jdW1lbnRhdGlvbi9Eb2NCb29rLzgwMjExLnRtcGwKQEAgLTI2OCwxMCArMjY4LDYgQEAKICFGaW5jbHVkZS9uZXQvbWFjODAyMTEuaCBpZWVlODAyMTFfb3BzCiAhRmluY2x1ZGUvbmV0L21hYzgwMjExLmggaWVlZTgwMjExX2FsbG9jX2h3CiAhRmluY2x1ZGUvbmV0L21hYzgwMjExLmggaWVlZTgwMjExX3JlZ2lzdGVyX2h3Ci0hRmluY2x1ZGUvbmV0L21hYzgwMjExLmggaWVlZTgwMjExX2dldF90eF9sZWRfbmFtZQotIUZpbmNsdWRlL25ldC9tYWM4MDIxMS5oIGllZWU4MDIxMV9nZXRfcnhfbGVkX25hbWUKLSFGaW5jbHVkZS9uZXQvbWFjODAyMTEuaCBpZWVlODAyMTFfZ2V0X2Fzc29jX2xlZF9uYW1lCi0hRmluY2x1ZGUvbmV0L21hYzgwMjExLmggaWVlZTgwMjExX2dldF9yYWRpb19sZWRfbmFtZQogIUZpbmNsdWRlL25ldC9tYWM4MDIxMS5oIGllZWU4MDIxMV91bnJlZ2lzdGVyX2h3CiAhRmluY2x1ZGUvbmV0L21hYzgwMjExLmggaWVlZTgwMjExX2ZyZWVfaHcKICAgICAgIDwvY2hhcHRlcj4KQEAgLTM4Miw2ICszNzgsMjMgQEAKICAgICAgICAgPC9wYXJhPgogICAgICAgPC9wYXJ0aW50cm8+CiAKKyAgICAgIDxjaGFwdGVyIGlkPSJsZWQtc3VwcG9ydCI+CisgICAgICAgIDx0aXRsZT5MRUQgc3VwcG9ydDwvdGl0bGU+CisgICAgICAgIDxwYXJhPgorICAgICAgICAgTWFjODAyMTEgc3VwcG9ydHMgdmFyaW91cyB3YXlzIG9mIGJsaW5raW5nIExFRHMuIFdoZXJldmVyIHBvc3NpYmxlLAorICAgICAgICAgZGV2aWNlIExFRHMgc2hvdWxkIGJlIGV4cG9zZWQgYXMgTEVEIGNsYXNzIGRldmljZXMgYW5kIGhvb2tlZCB1cCB0bworICAgICAgICAgdGhlIGFwcHJvcHJpYXRlIHRyaWdnZXIsIHdoaWNoIHdpbGwgdGhlbiBiZSB0cmlnZ2VyZWQgYXBwcm9wcmlhdGVseQorICAgICAgICAgYnkgbWFjODAyMTEuCisgICAgICAgIDwvcGFyYT4KKyFGaW5jbHVkZS9uZXQvbWFjODAyMTEuaCBpZWVlODAyMTFfZ2V0X3R4X2xlZF9uYW1lCishRmluY2x1ZGUvbmV0L21hYzgwMjExLmggaWVlZTgwMjExX2dldF9yeF9sZWRfbmFtZQorIUZpbmNsdWRlL25ldC9tYWM4MDIxMS5oIGllZWU4MDIxMV9nZXRfYXNzb2NfbGVkX25hbWUKKyFGaW5jbHVkZS9uZXQvbWFjODAyMTEuaCBpZWVlODAyMTFfZ2V0X3JhZGlvX2xlZF9uYW1lCishRmluY2x1ZGUvbmV0L21hYzgwMjExLmggaWVlZTgwMjExX3RwdF9ibGluaworIUZpbmNsdWRlL25ldC9tYWM4MDIxMS5oIGllZWU4MDIxMV90cHRfbGVkX3RyaWdnZXJfZmxhZ3MKKyFGaW5jbHVkZS9uZXQvbWFjODAyMTEuaCBpZWVlODAyMTFfY3JlYXRlX3RwdF9sZWRfdHJpZ2dlcgorICAgICAgPC9jaGFwdGVyPgorCiAgICAgICA8Y2hhcHRlciBpZD0iaGFyZHdhcmUtY3J5cHRvLW9mZmxvYWQiPgogICAgICAgICA8dGl0bGU+SGFyZHdhcmUgY3J5cHRvIGFjY2VsZXJhdGlvbjwvdGl0bGU+CiAhUGluY2x1ZGUvbmV0L21hYzgwMjExLmggSGFyZHdhcmUgY3J5cHRvIGFjY2VsZXJhdGlvbgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL2RldmljZS1kcml2ZXJzLnRtcGwgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svZGV2aWNlLWRyaXZlcnMudG1wbAppbmRleCAzNTQ0N2UwLi4zNmY2M2Q0IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svZGV2aWNlLWRyaXZlcnMudG1wbAorKysgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svZGV2aWNlLWRyaXZlcnMudG1wbApAQCAtMjE3LDggKzIxNyw4IEBACiAgIDxjaGFwdGVyIGlkPSJ1YXJ0MTZ4NTAiPgogICAgICA8dGl0bGU+MTZ4NTAgVUFSVCBEcml2ZXI8L3RpdGxlPgogIUlpbmNsdWRlL2xpbnV4L3NlcmlhbF9jb3JlLmgKLSFFZHJpdmVycy9zZXJpYWwvc2VyaWFsX2NvcmUuYwotIUVkcml2ZXJzL3NlcmlhbC84MjUwLmMKKyFFZHJpdmVycy90dHkvc2VyaWFsL3NlcmlhbF9jb3JlLmMKKyFFZHJpdmVycy90dHkvc2VyaWFsLzgyNTAuYwogICA8L2NoYXB0ZXI+CiAKICAgPGNoYXB0ZXIgaWQ9ImZiZGV2Ij4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vRG9jQm9vay9kdmIvZHZiYXBpLnhtbCBiL0RvY3VtZW50YXRpb24vRG9jQm9vay9kdmIvZHZiYXBpLnhtbAppbmRleCBlM2E5N2ZkLi5hZDg2NzhkIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svZHZiL2R2YmFwaS54bWwKKysrIGIvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL2R2Yi9kdmJhcGkueG1sCkBAIC0yOCw3ICsyOCw3IEBACiAJPGhvbGRlcj5Db252ZXJnZW5jZSBHbWJIPC9ob2xkZXI+CiA8L2NvcHlyaWdodD4KIDxjb3B5cmlnaHQ+Ci0JPHllYXI+MjAwOS0yMDEwPC95ZWFyPgorCTx5ZWFyPjIwMDktMjAxMTwveWVhcj4KIAk8aG9sZGVyPk1hdXJvIENhcnZhbGhvIENoZWhhYjwvaG9sZGVyPgogPC9jb3B5cmlnaHQ+CiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vRG9jQm9vay9tZWRpYS50bXBsIGIvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL21lZGlhLnRtcGwKaW5kZXggZjExMDQ4ZC4uYTk5MDg4YSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL21lZGlhLnRtcGwKKysrIGIvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL21lZGlhLnRtcGwKQEAgLTI4LDcgKzI4LDcgQEAKIDx0aXRsZT5MSU5VWCBNRURJQSBJTkZSQVNUUlVDVFVSRSBBUEk8L3RpdGxlPgogCiA8Y29weXJpZ2h0PgotCTx5ZWFyPjIwMDktMjAxMDwveWVhcj4KKwk8eWVhcj4yMDA5LTIwMTE8L3llYXI+CiAJPGhvbGRlcj5MaW51eFRWIERldmVsb3BlcnM8L2hvbGRlcj4KIDwvY29weXJpZ2h0PgogCkBAIC04Niw3ICs4Niw3IEBACiA8L2F1dGhvcj4KIDwvYXV0aG9yZ3JvdXA+CiA8Y29weXJpZ2h0PgotCTx5ZWFyPjIwMDktMjAxMDwveWVhcj4KKwk8eWVhcj4yMDA5LTIwMTE8L3llYXI+CiAJPGhvbGRlcj5NYXVybyBDYXJ2YWxobyBDaGVoYWI8L2hvbGRlcj4KIDwvY29weXJpZ2h0PgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdjRsL2Rldi1yZHMueG1sIGIvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3Y0bC9kZXYtcmRzLnhtbAppbmRleCAzNjBkMjczLi4yNDI3ZjU0IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdjRsL2Rldi1yZHMueG1sCisrKyBiL0RvY3VtZW50YXRpb24vRG9jQm9vay92NGwvZGV2LXJkcy54bWwKQEAgLTc1LDYgKzc1LDcgQEAKICAgPC9zZWN0aW9uPgogCiAgIDxzZWN0aW9uPgorICAgIDx0aXRsZT5SRFMgZGF0YXN0cnVjdHVyZXM8L3RpdGxlPgogICAgIDx0YWJsZSBmcmFtZT0ibm9uZSIgcGd3aWRlPSIxIiBpZD0idjRsMi1yZHMtZGF0YSI+CiAgICAgICA8dGl0bGU+c3RydWN0CiA8c3RydWN0bmFtZT52NGwyX3Jkc19kYXRhPC9zdHJ1Y3RuYW1lPjwvdGl0bGU+CkBAIC0xMjksMTAgKzEzMCwxMSBAQAogCiAgICAgPHRhYmxlIGZyYW1lPSJub25lIiBwZ3dpZGU9IjEiIGlkPSJ2NGwyLXJkcy1ibG9jay1jb2RlcyI+CiAgICAgICA8dGl0bGU+QmxvY2sgZGVmaW5lczwvdGl0bGU+Ci0gICAgICA8dGdyb3VwIGNvbHM9IjMiPgorICAgICAgPHRncm91cCBjb2xzPSI0Ij4KIAk8Y29sc3BlYyBjb2xuYW1lPSJjMSIgY29sd2lkdGg9IjEqIiAvPgogCTxjb2xzcGVjIGNvbG5hbWU9ImMyIiBjb2x3aWR0aD0iMSoiIC8+Ci0JPGNvbHNwZWMgY29sbmFtZT0iYzMiIGNvbHdpZHRoPSI1KiIgLz4KKwk8Y29sc3BlYyBjb2xuYW1lPSJjMyIgY29sd2lkdGg9IjEqIiAvPgorCTxjb2xzcGVjIGNvbG5hbWU9ImM0IiBjb2x3aWR0aD0iNSoiIC8+CiAJPHRib2R5IHZhbGlnbj0idG9wIj4KIAkgIDxyb3c+CiAJICAgIDxlbnRyeT5WNEwyX1JEU19CTE9DS19NU0s8L2VudHJ5PgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3Y0bC92NGwyLnhtbCBiL0RvY3VtZW50YXRpb24vRG9jQm9vay92NGwvdjRsMi54bWwKaW5kZXggODM5ZTkzZS4uOTI4OGFmOSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9Eb2NCb29rL3Y0bC92NGwyLnhtbAorKysgYi9Eb2N1bWVudGF0aW9uL0RvY0Jvb2svdjRsL3Y0bDIueG1sCkBAIC0xMDAsNiArMTAwLDcgQEAKICAgICAgIDx5ZWFyPjIwMDg8L3llYXI+CiAgICAgICA8eWVhcj4yMDA5PC95ZWFyPgogICAgICAgPHllYXI+MjAxMDwveWVhcj4KKyAgICAgIDx5ZWFyPjIwMTE8L3llYXI+CiAgICAgICA8aG9sZGVyPkJpbGwgRGlya3MsIE1pY2hhZWwgSC4gU2NoaW1laywgSGFucyBWZXJrdWlsLCBNYXJ0aW4KIFJ1YmxpLCBBbmR5IFdhbGxzLCBNdXJhbGlkaGFyYW4gS2FyaWNoZXJpLCBNYXVybyBDYXJ2YWxobyBDaGVoYWI8L2hvbGRlcj4KICAgICA8L2NvcHlyaWdodD4KQEAgLTM4MSw3ICszODIsNyBAQAogPC9wYXJ0aW5mbz4KIAogPHRpdGxlPlZpZGVvIGZvciBMaW51eCBUd28gQVBJIFNwZWNpZmljYXRpb248L3RpdGxlPgotIDxzdWJ0aXRsZT5SZXZpc2lvbiAyLjYuMzM8L3N1YnRpdGxlPgorIDxzdWJ0aXRsZT5SZXZpc2lvbiAyLjYuMzg8L3N1YnRpdGxlPgogCiAgIDxjaGFwdGVyIGlkPSJjb21tb24iPgogICAgICZzdWItY29tbW9uOwpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9JUE1JLnR4dCBiL0RvY3VtZW50YXRpb24vSVBNSS50eHQKaW5kZXggNjlkZDI5ZS4uYjJiZWExNSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9JUE1JLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL0lQTUkudHh0CkBAIC01MzMsNiArNTMzLDMzIEBACiBPdGhlciBQaWVjZXMKIC0tLS0tLS0tLS0tLQogCitHZXQgdGhlIGRldGFpbGVkIGluZm8gcmVsYXRlZCB3aXRoIHRoZSBJUE1JIGRldmljZQorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworU29tZSB1c2VycyBuZWVkIG1vcmUgZGV0YWlsZWQgaW5mb3JtYXRpb24gYWJvdXQgYSBkZXZpY2UsIGxpa2Ugd2hlcmUKK3RoZSBhZGRyZXNzIGNhbWUgZnJvbSBvciB0aGUgcmF3IGJhc2UgZGV2aWNlIGZvciB0aGUgSVBNSSBpbnRlcmZhY2UuCitZb3UgY2FuIHVzZSB0aGUgSVBNSSBzbWlfd2F0Y2hlciB0byBjYXRjaCB0aGUgSVBNSSBpbnRlcmZhY2VzIGFzIHRoZXkKK2NvbWUgb3IgZ28sIGFuZCB0byBncmFiIHRoZSBpbmZvcm1hdGlvbiwgeW91IGNhbiB1c2UgdGhlIGZ1bmN0aW9uCitpcG1pX2dldF9zbWlfaW5mbygpLCB3aGljaCByZXR1cm5zIHRoZSBmb2xsb3dpbmcgc3RydWN0dXJlOgorCitzdHJ1Y3QgaXBtaV9zbWlfaW5mbyB7CisJZW51bSBpcG1pX2FkZHJfc3JjIGFkZHJfc3JjOworCXN0cnVjdCBkZXZpY2UgKmRldjsKKwl1bmlvbiB7CisJCXN0cnVjdCB7CisJCQl2b2lkICphY3BpX2hhbmRsZTsKKwkJfSBhY3BpX2luZm87CisJfSBhZGRyX2luZm87Cit9OworCitDdXJyZW50bHkgc3BlY2lhbCBpbmZvIGZvciBvbmx5IGZvciBTSV9BQ1BJIGFkZHJlc3Mgc291cmNlcyBpcworcmV0dXJuZWQuICBPdGhlcnMgbWF5IGJlIGFkZGVkIGFzIG5lY2Vzc2FyeS4KKworTm90ZSB0aGF0IHRoZSBkZXYgcG9pbnRlciBpcyBpbmNsdWRlZCBpbiB0aGUgYWJvdmUgc3RydWN0dXJlLCBhbmQKK2Fzc3VtaW5nIGlwbWlfc21pX2dldF9pbmZvIHJldHVybnMgc3VjY2VzcywgeW91IG11c3QgY2FsbCBwdXRfZGV2aWNlCitvbiB0aGUgZGV2IHBvaW50ZXIuCisKKwogV2F0Y2hkb2cKIC0tLS0tLS0tCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vYWNwaS9hcGVpL291dHB1dF9mb3JtYXQudHh0IGIvRG9jdW1lbnRhdGlvbi9hY3BpL2FwZWkvb3V0cHV0X2Zvcm1hdC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTE0Njk1MgotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRpb24vYWNwaS9hcGVpL291dHB1dF9mb3JtYXQudHh0CkBAIC0wLDAgKzEsMTIyIEBACisgICAgICAgICAgICAgICAgICAgICBBUEVJIG91dHB1dCBmb3JtYXQKKyAgICAgICAgICAgICAgICAgICAgIH5+fn5+fn5+fn5+fn5+fn5+fgorCitBUEVJIHVzZXMgcHJpbnRrIGFzIGhhcmR3YXJlIGVycm9yIHJlcG9ydGluZyBpbnRlcmZhY2UsIHRoZSBvdXRwdXQKK2Zvcm1hdCBpcyBhcyBmb2xsb3cuCisKKzxlcnJvciByZWNvcmQ+IDo9CitBUEVJIGdlbmVyaWMgaGFyZHdhcmUgZXJyb3Igc3RhdHVzCitzZXZlcml0eTogPGludGVnZXI+LCA8c2V2ZXJpdHkgc3RyaW5nPgorc2VjdGlvbjogPGludGVnZXI+LCBzZXZlcml0eTogPGludGVnZXI+LCA8c2V2ZXJpdHkgc3RyaW5nPgorZmxhZ3M6IDxpbnRlZ2VyPgorPHNlY3Rpb24gZmxhZ3Mgc3RyaW5ncz4KK2ZydV9pZDogPHV1aWQgc3RyaW5nPgorZnJ1X3RleHQ6IDxzdHJpbmc+CitzZWN0aW9uX3R5cGU6IDxzZWN0aW9uIHR5cGUgc3RyaW5nPgorPHNlY3Rpb24gZGF0YT4KKworPHNldmVyaXR5IHN0cmluZz4qIDo9IHJlY292ZXJhYmxlIHwgZmF0YWwgfCBjb3JyZWN0ZWQgfCBpbmZvCisKKzxzZWN0aW9uIGZsYWdzIHN0cmluZ3M+IyA6PQorW3ByaW1hcnldWywgY29udGFpbm1lbnQgd2FybmluZ11bLCByZXNldF1bLCB0aHJlc2hvbGQgZXhjZWVkZWRdXAorWywgcmVzb3VyY2Ugbm90IGFjY2Vzc2libGVdWywgbGF0ZW50IGVycm9yXQorCis8c2VjdGlvbiB0eXBlIHN0cmluZz4gOj0gZ2VuZXJpYyBwcm9jZXNzb3IgZXJyb3IgfCBtZW1vcnkgZXJyb3IgfCBcCitQQ0llIGVycm9yIHwgdW5rbm93biwgPHV1aWQgc3RyaW5nPgorCis8c2VjdGlvbiBkYXRhPiA6PQorPGdlbmVyaWMgcHJvY2Vzc29yIHNlY3Rpb24gZGF0YT4gfCA8bWVtb3J5IHNlY3Rpb24gZGF0YT4gfCBcCis8cGNpZSBzZWN0aW9uIGRhdGE+IHwgPG51bGw+CisKKzxnZW5lcmljIHByb2Nlc3NvciBzZWN0aW9uIGRhdGE+IDo9CitbcHJvY2Vzc29yX3R5cGU6IDxpbnRlZ2VyPiwgPHByb2MgdHlwZSBzdHJpbmc+XQorW3Byb2Nlc3Nvcl9pc2E6IDxpbnRlZ2VyPiwgPHByb2MgaXNhIHN0cmluZz5dCitbZXJyb3JfdHlwZTogPGludGVnZXI+Cis8cHJvYyBlcnJvciB0eXBlIHN0cmluZ3M+XQorW29wZXJhdGlvbjogPGludGVnZXI+LCA8cHJvYyBvcGVyYXRpb24gc3RyaW5nPl0KK1tmbGFnczogPGludGVnZXI+Cis8cHJvYyBmbGFncyBzdHJpbmdzPl0KK1tsZXZlbDogPGludGVnZXI+XQorW3ZlcnNpb25faW5mbzogPGludGVnZXI+XQorW3Byb2Nlc3Nvcl9pZDogPGludGVnZXI+XQorW3RhcmdldF9hZGRyZXNzOiA8aW50ZWdlcj5dCitbcmVxdWVzdG9yX2lkOiA8aW50ZWdlcj5dCitbcmVzcG9uZGVyX2lkOiA8aW50ZWdlcj5dCitbSVA6IDxpbnRlZ2VyPl0KKworPHByb2MgdHlwZSBzdHJpbmc+KiA6PSBJQTMyL1g2NCB8IElBNjQKKworPHByb2MgaXNhIHN0cmluZz4qIDo9IElBMzIgfCBJQTY0IHwgWDY0CisKKzxwcm9jZXNzb3IgZXJyb3IgdHlwZSBzdHJpbmdzPiMgOj0KK1tjYWNoZSBlcnJvcl1bLCBUTEIgZXJyb3JdWywgYnVzIGVycm9yXVssIG1pY3JvLWFyY2hpdGVjdHVyYWwgZXJyb3JdCisKKzxwcm9jIG9wZXJhdGlvbiBzdHJpbmc+KiA6PSB1bmtub3duIG9yIGdlbmVyaWMgfCBkYXRhIHJlYWQgfCBkYXRhIHdyaXRlIHwgXAoraW5zdHJ1Y3Rpb24gZXhlY3V0aW9uCisKKzxwcm9jIGZsYWdzIHN0cmluZ3M+IyA6PQorW3Jlc3RhcnRhYmxlXVssIHByZWNpc2UgSVBdWywgb3ZlcmZsb3ddWywgY29ycmVjdGVkXQorCis8bWVtb3J5IHNlY3Rpb24gZGF0YT4gOj0KK1tlcnJvcl9zdGF0dXM6IDxpbnRlZ2VyPl0KK1twaHlzaWNhbF9hZGRyZXNzOiA8aW50ZWdlcj5dCitbcGh5c2ljYWxfYWRkcmVzc19tYXNrOiA8aW50ZWdlcj5dCitbbm9kZTogPGludGVnZXI+XQorW2NhcmQ6IDxpbnRlZ2VyPl0KK1ttb2R1bGU6IDxpbnRlZ2VyPl0KK1tiYW5rOiA8aW50ZWdlcj5dCitbZGV2aWNlOiA8aW50ZWdlcj5dCitbcm93OiA8aW50ZWdlcj5dCitbY29sdW1uOiA8aW50ZWdlcj5dCitbYml0X3Bvc2l0aW9uOiA8aW50ZWdlcj5dCitbcmVxdWVzdG9yX2lkOiA8aW50ZWdlcj5dCitbcmVzcG9uZGVyX2lkOiA8aW50ZWdlcj5dCitbdGFyZ2V0X2lkOiA8aW50ZWdlcj5dCitbZXJyb3JfdHlwZTogPGludGVnZXI+LCA8bWVtIGVycm9yIHR5cGUgc3RyaW5nPl0KKworPG1lbSBlcnJvciB0eXBlIHN0cmluZz4qIDo9Cit1bmtub3duIHwgbm8gZXJyb3IgfCBzaW5nbGUtYml0IEVDQyB8IG11bHRpLWJpdCBFQ0MgfCBcCitzaW5nbGUtc3ltYm9sIGNoaXBraWxsIEVDQyB8IG11bHRpLXN5bWJvbCBjaGlwa2lsbCBFQ0MgfCBtYXN0ZXIgYWJvcnQgfCBcCit0YXJnZXQgYWJvcnQgfCBwYXJpdHkgZXJyb3IgfCB3YXRjaGRvZyB0aW1lb3V0IHwgaW52YWxpZCBhZGRyZXNzIHwgXAorbWlycm9yIEJyb2tlbiB8IG1lbW9yeSBzcGFyaW5nIHwgc2NydWIgY29ycmVjdGVkIGVycm9yIHwgXAorc2NydWIgdW5jb3JyZWN0ZWQgZXJyb3IKKworPHBjaWUgc2VjdGlvbiBkYXRhPiA6PQorW3BvcnRfdHlwZTogPGludGVnZXI+LCA8cGNpZSBwb3J0IHR5cGUgc3RyaW5nPl0KK1t2ZXJzaW9uOiA8aW50ZWdlcj4uPGludGVnZXI+XQorW2NvbW1hbmQ6IDxpbnRlZ2VyPiwgc3RhdHVzOiA8aW50ZWdlcj5dCitbZGV2aWNlX2lkOiA8aW50ZWdlcj46PGludGVnZXI+OjxpbnRlZ2VyPi48aW50ZWdlcj4KK3Nsb3Q6IDxpbnRlZ2VyPgorc2Vjb25kYXJ5X2J1czogPGludGVnZXI+Cit2ZW5kb3JfaWQ6IDxpbnRlZ2VyPiwgZGV2aWNlX2lkOiA8aW50ZWdlcj4KK2NsYXNzX2NvZGU6IDxpbnRlZ2VyPl0KK1tzZXJpYWwgbnVtYmVyOiA8aW50ZWdlcj4sIDxpbnRlZ2VyPl0KK1ticmlkZ2U6IHNlY29uZGFyeV9zdGF0dXM6IDxpbnRlZ2VyPiwgY29udHJvbDogPGludGVnZXI+XQorCis8cGNpZSBwb3J0IHR5cGUgc3RyaW5nPiogOj0gUENJZSBlbmQgcG9pbnQgfCBsZWdhY3kgUENJIGVuZCBwb2ludCB8IFwKK3Vua25vd24gfCB1bmtub3duIHwgcm9vdCBwb3J0IHwgdXBzdHJlYW0gc3dpdGNoIHBvcnQgfCBcCitkb3duc3RyZWFtIHN3aXRjaCBwb3J0IHwgUENJZSB0byBQQ0kvUENJLVggYnJpZGdlIHwgXAorUENJL1BDSS1YIHRvIFBDSWUgYnJpZGdlIHwgcm9vdCBjb21wbGV4IGludGVncmF0ZWQgZW5kcG9pbnQgZGV2aWNlIHwgXAorcm9vdCBjb21wbGV4IGV2ZW50IGNvbGxlY3RvcgorCitXaGVyZSwgW10gZGVzaWduYXRlIGNvcnJlc3BvbmRpbmcgY29udGVudCBpcyBvcHRpb25hbAorCitBbGwgPGZpZWxkIHN0cmluZz4gZGVzY3JpcHRpb24gd2l0aCAqIGhhcyB0aGUgZm9sbG93aW5nIGZvcm1hdDoKKworZmllbGQ6IDxpbnRlZ2VyPiwgPGZpZWxkIHN0cmluZz4KKworV2hlcmUgdmFsdWUgb2YgPGludGVnZXI+IHNob3VsZCBiZSB0aGUgcG9zaXRpb24gb2YgInN0cmluZyIgaW4gPGZpZWxkCitzdHJpbmc+IGRlc2NyaXB0aW9uLiBPdGhlcndpc2UsIDxmaWVsZCBzdHJpbmc+IHdpbGwgYmUgInVua25vd24iLgorCitBbGwgPGZpZWxkIHN0cmluZ3M+IGRlc2NyaXB0aW9uIHdpdGggIyBoYXMgdGhlIGZvbGxvd2luZyBmb3JtYXQ6CisKK2ZpZWxkOiA8aW50ZWdlcj4KKzxmaWVsZCBzdHJpbmdzPgorCitXaGVyZSBlYWNoIHN0cmluZyBpbiA8ZmllbGRzIHN0cmluZ3M+IGNvcnJlc3BvbmRpbmcgdG8gb25lIHNldCBiaXQgb2YKKzxpbnRlZ2VyPi4gVGhlIGJpdCBwb3NpdGlvbiBpcyB0aGUgcG9zaXRpb24gb2YgInN0cmluZyIgaW4gPGZpZWxkCitzdHJpbmdzPiBkZXNjcmlwdGlvbi4KKworRm9yIG1vcmUgZGV0YWlsZWQgZXhwbGFuYXRpb24gb2YgZXZlcnkgZmllbGQsIHBsZWFzZSByZWZlciB0byBVRUZJCitzcGVjaWZpY2F0aW9uIHZlcnNpb24gMi4zIG9yIGxhdGVyLCBzZWN0aW9uIEFwcGVuZGl4IE46IENvbW1vbgorUGxhdGZvcm0gRXJyb3IgUmVjb3JkLgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9hcm0vQm9vdGluZyBiL0RvY3VtZW50YXRpb24vYXJtL0Jvb3RpbmcKaW5kZXggNzY4NTAyOS4uNGU2ODZhMiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9hcm0vQm9vdGluZworKysgYi9Eb2N1bWVudGF0aW9uL2FybS9Cb290aW5nCkBAIC02NSwxMyArNjUsMTkgQEAKIFRoZSBib290IGxvYWRlciBtdXN0IHVsdGltYXRlbHkgYmUgYWJsZSB0byBwcm92aWRlIGEgTUFDSF9UWVBFX3h4eAogdmFsdWUgdG8gdGhlIGtlcm5lbC4gKHNlZSBsaW51eC9hcmNoL2FybS90b29scy9tYWNoLXR5cGVzKS4KIAotCi00LiBTZXR1cCB0aGUga2VybmVsIHRhZ2dlZCBsaXN0Ci0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis0LiBTZXR1cCBib290IGRhdGEKKy0tLS0tLS0tLS0tLS0tLS0tLQogCiBFeGlzdGluZyBib290IGxvYWRlcnM6CQlPUFRJT05BTCwgSElHSExZIFJFQ09NTUVOREVECiBOZXcgYm9vdCBsb2FkZXJzOgkJTUFOREFUT1JZCiAKK1RoZSBib290IGxvYWRlciBtdXN0IHByb3ZpZGUgZWl0aGVyIGEgdGFnZ2VkIGxpc3Qgb3IgYSBkdGIgaW1hZ2UgZm9yCitwYXNzaW5nIGNvbmZpZ3VyYXRpb24gZGF0YSB0byB0aGUga2VybmVsLiAgVGhlIHBoeXNpY2FsIGFkZHJlc3Mgb2YgdGhlCitib290IGRhdGEgaXMgcGFzc2VkIHRvIHRoZSBrZXJuZWwgaW4gcmVnaXN0ZXIgcjIuCisKKzRhLiBTZXR1cCB0aGUga2VybmVsIHRhZ2dlZCBsaXN0CistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCiBUaGUgYm9vdCBsb2FkZXIgbXVzdCBjcmVhdGUgYW5kIGluaXRpYWxpc2UgdGhlIGtlcm5lbCB0YWdnZWQgbGlzdC4KIEEgdmFsaWQgdGFnZ2VkIGxpc3Qgc3RhcnRzIHdpdGggQVRBR19DT1JFIGFuZCBlbmRzIHdpdGggQVRBR19OT05FLgogVGhlIEFUQUdfQ09SRSB0YWcgbWF5IG9yIG1heSBub3QgYmUgZW1wdHkuICBBbiBlbXB0eSBBVEFHX0NPUkUgdGFnCkBAIC0xMDEsNiArMTA3LDI0IEBACiB0aGUga2VybmVsIGRlY29tcHJlc3NvciBub3IgaW5pdHJkICdib290cCcgcHJvZ3JhbSB3aWxsIG92ZXJ3cml0ZQogaXQuICBUaGUgcmVjb21tZW5kZWQgcGxhY2VtZW50IGlzIGluIHRoZSBmaXJzdCAxNktpQiBvZiBSQU0uCiAKKzRiLiBTZXR1cCB0aGUgZGV2aWNlIHRyZWUKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworVGhlIGJvb3QgbG9hZGVyIG11c3QgbG9hZCBhIGRldmljZSB0cmVlIGltYWdlIChkdGIpIGludG8gc3lzdGVtIHJhbQorYXQgYSA2NGJpdCBhbGlnbmVkIGFkZHJlc3MgYW5kIGluaXRpYWxpemUgaXQgd2l0aCB0aGUgYm9vdCBkYXRhLiAgVGhlCitkdGIgZm9ybWF0IGlzIGRvY3VtZW50ZWQgaW4gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2Jvb3Rpbmctd2l0aG91dC1vZi50eHQuCitUaGUga2VybmVsIHdpbGwgbG9vayBmb3IgdGhlIGR0YiBtYWdpYyB2YWx1ZSBvZiAweGQwMGRmZWVkIGF0IHRoZSBkdGIKK3BoeXNpY2FsIGFkZHJlc3MgdG8gZGV0ZXJtaW5lIGlmIGEgZHRiIGhhcyBiZWVuIHBhc3NlZCBpbnN0ZWFkIG9mIGEKK3RhZ2dlZCBsaXN0LgorCitUaGUgYm9vdCBsb2FkZXIgbXVzdCBwYXNzIGF0IGEgbWluaW11bSB0aGUgc2l6ZSBhbmQgbG9jYXRpb24gb2YgdGhlCitzeXN0ZW0gbWVtb3J5LCBhbmQgdGhlIHJvb3QgZmlsZXN5c3RlbSBsb2NhdGlvbi4gIFRoZSBkdGIgbXVzdCBiZQorcGxhY2VkIGluIGEgcmVnaW9uIG9mIG1lbW9yeSB3aGVyZSB0aGUga2VybmVsIGRlY29tcHJlc3NvciB3aWxsIG5vdAorb3ZlcndyaXRlIGl0LiAgVGhlIHJlY29tbWVuZGVkIHBsYWNlbWVudCBpcyBpbiB0aGUgZmlyc3QgMTZLaUIgb2YgUkFNCit3aXRoIHRoZSBjYXZlYXQgdGhhdCBpdCBtYXkgbm90IGJlIGxvY2F0ZWQgYXQgcGh5c2ljYWwgYWRkcmVzcyAwIHNpbmNlCit0aGUga2VybmVsIGludGVycHJldHMgYSB2YWx1ZSBvZiAwIGluIHIyIHRvIG1lYW4gbmVpdGhlciBhIHRhZ2dlZCBsaXN0Citub3IgYSBkdGIgd2VyZSBwYXNzZWQuCisKIDUuIENhbGxpbmcgdGhlIGtlcm5lbCBpbWFnZQogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKQEAgLTEyNSw3ICsxNDksOCBAQAogLSBDUFUgcmVnaXN0ZXIgc2V0dGluZ3MKICAgcjAgPSAwLAogICByMSA9IG1hY2hpbmUgdHlwZSBudW1iZXIgZGlzY292ZXJlZCBpbiAoMykgYWJvdmUuCi0gIHIyID0gcGh5c2ljYWwgYWRkcmVzcyBvZiB0YWdnZWQgbGlzdCBpbiBzeXN0ZW0gUkFNLgorICByMiA9IHBoeXNpY2FsIGFkZHJlc3Mgb2YgdGFnZ2VkIGxpc3QgaW4gc3lzdGVtIFJBTSwgb3IKKyAgICAgICBwaHlzaWNhbCBhZGRyZXNzIG9mIGRldmljZSB0cmVlIGJsb2NrIChkdGIpIGluIHN5c3RlbSBSQU0KIAogLSBDUFUgbW9kZQogICBBbGwgZm9ybXMgb2YgaW50ZXJydXB0cyBtdXN0IGJlIGRpc2FibGVkIChJUlFzIGFuZCBGSVFzKQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kZXZpY2UtbWFwcGVyL2RtLWNyeXB0LnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNlLW1hcHBlci9kbS1jcnlwdC50eHQKaW5kZXggZGRlYjc0OS4uNmI1YzQyZCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9kZXZpY2UtbWFwcGVyL2RtLWNyeXB0LnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2RldmljZS1tYXBwZXIvZG0tY3J5cHQudHh0CkBAIC04LDcgKzgsNyBAQAogCiA8Y2lwaGVyPgogICAgIEVuY3J5cHRpb24gY2lwaGVyIGFuZCBhbiBvcHRpb25hbCBJViBnZW5lcmF0aW9uIG1vZGUuCi0gICAgKEluIGZvcm1hdCBjaXBoZXItY2hhaW5tb2RlLWl2b3B0czppdm1vZGUpLgorICAgIChJbiBmb3JtYXQgY2lwaGVyWzprZXljb3VudF0tY2hhaW5tb2RlLWl2b3B0czppdm1vZGUpLgogICAgIEV4YW1wbGVzOgogICAgICAgIGRlcwogICAgICAgIGFlcy1jYmMtZXNzaXY6c2hhMjU2CkBAIC0yMCw2ICsyMCwxMSBAQAogICAgIEtleSB1c2VkIGZvciBlbmNyeXB0aW9uLiBJdCBpcyBlbmNvZGVkIGFzIGEgaGV4YWRlY2ltYWwgbnVtYmVyLgogICAgIFlvdSBjYW4gb25seSB1c2Uga2V5IHNpemVzIHRoYXQgYXJlIHZhbGlkIGZvciB0aGUgc2VsZWN0ZWQgY2lwaGVyLgogCis8a2V5Y291bnQ+CisgICAgTXVsdGkta2V5IGNvbXBhdGliaWxpdHkgbW9kZS4gWW91IGNhbiBkZWZpbmUgPGtleWNvdW50PiBrZXlzIGFuZAorICAgIHRoZW4gc2VjdG9ycyBhcmUgZW5jcnlwdGVkIGFjY29yZGluZyB0byB0aGVpciBvZmZzZXRzIChzZWN0b3IgMCB1c2VzIGtleTA7CisgICAgc2VjdG9yIDEgdXNlcyBrZXkxIGV0Yy4pLiAgPGtleWNvdW50PiBtdXN0IGJlIGEgcG93ZXIgb2YgdHdvLgorCiA8aXZfb2Zmc2V0PgogICAgIFRoZSBJViBvZmZzZXQgaXMgYSBzZWN0b3IgY291bnQgdGhhdCBpcyBhZGRlZCB0byB0aGUgc2VjdG9yIG51bWJlcgogICAgIGJlZm9yZSBjcmVhdGluZyB0aGUgSVYuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZS1tYXBwZXIvZG0tcmFpZC50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZS1tYXBwZXIvZG0tcmFpZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzNiNmI3MAotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNlLW1hcHBlci9kbS1yYWlkLnR4dApAQCAtMCwwICsxLDcwIEBACitEZXZpY2UtbWFwcGVyIFJBSUQgKGRtLXJhaWQpIGlzIGEgYnJpZGdlIGZyb20gRE0gdG8gTUQuICBJdAorcHJvdmlkZXMgYSB3YXkgdG8gdXNlIGRldmljZS1tYXBwZXIgaW50ZXJmYWNlcyB0byBhY2Nlc3MgdGhlIE1EIFJBSUQKK2RyaXZlcnMuCisKK0FzIHdpdGggYWxsIGRldmljZS1tYXBwZXIgdGFyZ2V0cywgdGhlIG5vbWluYWwgcHVibGljIGludGVyZmFjZXMgYXJlIHRoZQorY29uc3RydWN0b3IgKENUUikgdGFibGVzIGFuZCB0aGUgc3RhdHVzIG91dHB1dHMgKGJvdGggU1RBVFVTVFlQRV9JTkZPCithbmQgU1RBVFVTVFlQRV9UQUJMRSkuICBUaGUgQ1RSIHRhYmxlIGxvb2tzIGxpa2UgdGhlIGZvbGxvd2luZzoKKworMTogPHM+IDxsPiByYWlkIFwKKzI6ICAgICAgPHJhaWRfdHlwZT4gPCNyYWlkX3BhcmFtcz4gPHJhaWRfcGFyYW1zPiBcCiszOiAgICAgIDwjcmFpZF9kZXZzPiA8bWV0YV9kZXYxPiA8ZGV2MT4gLi4gPG1ldGFfZGV2Tj4gPGRldk4+CisKK0xpbmUgMSBjb250YWlucyB0aGUgc3RhbmRhcmQgZmlyc3QgdGhyZWUgYXJndW1lbnRzIHRvIGFueSBkZXZpY2UtbWFwcGVyCit0YXJnZXQgLSB0aGUgc3RhcnQsIGxlbmd0aCwgYW5kIHRhcmdldCB0eXBlIGZpZWxkcy4gIFRoZSB0YXJnZXQgdHlwZSBpbgordGhpcyBjYXNlIGlzICJyYWlkIi4KKworTGluZSAyIGNvbnRhaW5zIHRoZSBhcmd1bWVudHMgdGhhdCBkZWZpbmUgdGhlIHBhcnRpY3VsYXIgcmFpZAordHlwZS9wZXJzb25hbGl0eS9sZXZlbCwgdGhlIHJlcXVpcmVkIGFyZ3VtZW50cyBmb3IgdGhhdCByYWlkIHR5cGUsIGFuZAorYW55IG9wdGlvbmFsIGFyZ3VtZW50cy4gIFBvc3NpYmxlIHJhaWQgdHlwZXMgaW5jbHVkZTogcmFpZDQsIHJhaWQ1X2xhLAorcmFpZDVfbHMsIHJhaWQ1X3JzLCByYWlkNl96ciwgcmFpZDZfbnIsIGFuZCByYWlkNl9uYy4gIChyYWlkMSBpcworcGxhbm5lZCBmb3IgdGhlIGZ1dHVyZS4pICBUaGUgbGlzdCBvZiByZXF1aXJlZCBhbmQgb3B0aW9uYWwgcGFyYW1ldGVycworaXMgdGhlIHNhbWUgZm9yIGFsbCB0aGUgY3VycmVudCByYWlkIHR5cGVzLiAgVGhlIHJlcXVpcmVkIHBhcmFtZXRlcnMgYXJlCitwb3NpdGlvbmFsLCB3aGlsZSB0aGUgb3B0aW9uYWwgcGFyYW1ldGVycyBhcmUgZ2l2ZW4gYXMga2V5L3ZhbHVlIHBhaXJzLgorVGhlIHBvc3NpYmxlIHBhcmFtZXRlcnMgYXJlIGFzIGZvbGxvd3M6CisgPGNodW5rX3NpemU+ICAgICAgICAgICBDaHVuayBzaXplIGluIHNlY3RvcnMuCisgW1tub11zeW5jXSAgICAgICAgICAgICBGb3JjZS9QcmV2ZW50IFJBSUQgaW5pdGlhbGl6YXRpb24KKyBbcmVidWlsZCA8aWR4Pl0gICAgICAgIFJlYnVpbGQgdGhlIGRyaXZlIGluZGljYXRlZCBieSB0aGUgaW5kZXgKKyBbZGFlbW9uX3NsZWVwIDxtcz5dICAgIFRpbWUgYmV0d2VlbiBiaXRtYXAgZGFlbW9uIHdvcmsgdG8gY2xlYXIgYml0cworIFttaW5fcmVjb3ZlcnlfcmF0ZSA8a0Ivc2VjL2Rpc2s+XSAgICAgIFRocm90dGxlIFJBSUQgaW5pdGlhbGl6YXRpb24KKyBbbWF4X3JlY292ZXJ5X3JhdGUgPGtCL3NlYy9kaXNrPl0gICAgICBUaHJvdHRsZSBSQUlEIGluaXRpYWxpemF0aW9uCisgW21heF93cml0ZV9iZWhpbmQgPHNlY3RvcnM+XSAgICAgICAgICAgU2VlICctd3JpdGUtYmVoaW5kPScgKG1hbiBtZGFkbSkKKyBbc3RyaXBlX2NhY2hlIDxzZWN0b3JzPl0gICAgICAgICAgICAgICBTdHJpcGUgY2FjaGUgc2l6ZSBmb3IgaGlnaGVyIFJBSURzCisKK0xpbmUgMyBjb250YWlucyB0aGUgbGlzdCBvZiBkZXZpY2VzIHRoYXQgY29tcG9zZSB0aGUgYXJyYXkgaW4KK21ldGFkYXRhL2RhdGEgZGV2aWNlIHBhaXJzLiAgSWYgdGhlIG1ldGFkYXRhIGlzIHN0b3JlZCBzZXBhcmF0ZWx5LCBhICctJworaXMgZ2l2ZW4gZm9yIHRoZSBtZXRhZGF0YSBkZXZpY2UgcG9zaXRpb24uICBJZiBhIGRyaXZlIGhhcyBmYWlsZWQgb3IgaXMKK21pc3NpbmcgYXQgY3JlYXRpb24gdGltZSwgYSAnLScgY2FuIGJlIGdpdmVuIGZvciBib3RoIHRoZSBtZXRhZGF0YSBhbmQKK2RhdGEgZHJpdmVzIGZvciBhIGdpdmVuIHBvc2l0aW9uLgorCitOQi4gQ3VycmVudGx5IGFsbCBtZXRhZGF0YSBkZXZpY2VzIG11c3QgYmUgc3BlY2lmaWVkIGFzICctJy4KKworRXhhbXBsZXM6CisjIFJBSUQ0IC0gNCBkYXRhIGRyaXZlcywgMSBwYXJpdHkKKyMgTm8gbWV0YWRhdGEgZGV2aWNlcyBzcGVjaWZpZWQgdG8gaG9sZCBzdXBlcmJsb2NrL2JpdG1hcCBpbmZvCisjIENodW5rIHNpemUgb2YgMU1pQgorIyAoTGluZXMgc2VwYXJhdGVkIGZvciBlYXN5IHJlYWRpbmcpCiswIDE5NjA4OTM2NDggcmFpZCBcCisgICAgICAgIHJhaWQ0IDEgMjA0OCBcCisgICAgICAgIDUgLSA4OjE3IC0gODozMyAtIDg6NDkgLSA4OjY1IC0gODo4MQorCisjIFJBSUQ0IC0gNCBkYXRhIGRyaXZlcywgMSBwYXJpdHkgKG5vIG1ldGFkYXRhIGRldmljZXMpCisjIENodW5rIHNpemUgb2YgMU1pQiwgZm9yY2UgUkFJRCBpbml0aWFsaXphdGlvbiwKKyMgICAgICAgbWluIHJlY292ZXJ5IHJhdGUgYXQgMjAga2lCL3NlYy9kaXNrCiswIDE5NjA4OTM2NDggcmFpZCBcCisgICAgICAgIHJhaWQ0IDQgMjA0OCBtaW5fcmVjb3ZlcnlfcmF0ZSAyMCBzeW5jXAorICAgICAgICA1IC0gODoxNyAtIDg6MzMgLSA4OjQ5IC0gODo2NSAtIDg6ODEKKworUGVyZm9ybWluZyBhICdkbXNldHVwIHRhYmxlJyBzaG91bGQgZGlzcGxheSB0aGUgQ1RSIHRhYmxlIHVzZWQgdG8KK2NvbnN0cnVjdCB0aGUgbWFwcGluZyAod2l0aCBwb3NzaWJsZSByZW9yZGVyaW5nIG9mIG9wdGlvbmFsCitwYXJhbWV0ZXJzKS4KKworUGVyZm9ybWluZyBhICdkbXNldHVwIHN0YXR1cycgd2lsbCB5aWVsZCBpbmZvcm1hdGlvbiBvbiB0aGUgc3RhdGUgYW5kCitoZWFsdGggb2YgdGhlIGFycmF5LiAgVGhlIG91dHB1dCBpcyBhcyBmb2xsb3dzOgorMTogPHM+IDxsPiByYWlkIFwKKzI6ICAgICAgPHJhaWRfdHlwZT4gPCNkZXZpY2VzPiA8MSBoZWFsdGggY2hhciBmb3IgZWFjaCBkZXY+IDxyZXN5bmNfcmF0aW8+CisKK0xpbmUgMSBpcyBzdGFuZGFyZCBETSBvdXRwdXQuICBMaW5lIDIgaXMgYmVzdCBzaG93biBieSBleGFtcGxlOgorICAgICAgICAwIDE5NjA4OTM2NDggcmFpZCByYWlkNCA1IEFBQUFBIDIvNDkwMjIxNTY4CitIZXJlIHdlIGNhbiBzZWUgdGhlIFJBSUQgdHlwZSBpcyByYWlkNCwgdGhlcmUgYXJlIDUgZGV2aWNlcyAtIGFsbCBvZgord2hpY2ggYXJlICdBJ2xpdmUsIGFuZCB0aGUgYXJyYXkgaXMgMi80OTAyMjE1NjggY29tcGxldGUgd2l0aCByZWNvdmVyeS4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL3NhdGEudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2F0YS9mc2wtc2F0YS50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL3NhdGEudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvYXRhL2ZzbC1zYXRhLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9lZXByb20udHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2VlcHJvbS50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZWVwcm9tLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2VlcHJvbS50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsLzh4eHhfZ3Bpby50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvZ3Bpby84eHh4X2dwaW8udHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC84eHh4X2dwaW8udHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvZ3Bpby84eHh4X2dwaW8udHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2dwaW8vZ3Bpby50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvZ3Bpby9ncGlvLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9ncGlvL2dwaW8udHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvZ3Bpby9ncGlvLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9ncGlvL2xlZC50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvZ3Bpby9sZWQudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2dwaW8vbGVkLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2dwaW8vbGVkLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvaTJjLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvZnNsLWkyYy50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2kyYy50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9pMmMvZnNsLWkyYy50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvbWFydmVsbC50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvbWFydmVsbC50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvbWFydmVsbC50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9tYXJ2ZWxsLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvZXNkaGMudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL21tYy9mc2wtZXNkaGMudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9lc2RoYy50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9tbWMvZnNsLWVzZGhjLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9tbWMtc3BpLXNsb3QudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL21tYy9tbWMtc3BpLXNsb3QudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL21tYy1zcGktc2xvdC50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9tbWMvbW1jLXNwaS1zbG90LnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvdXBtLW5hbmQudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL210ZC9mc2wtdXBtLW5hbmQudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC91cG0tbmFuZC50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9tdGQvZnNsLXVwbS1uYW5kLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9tdGQtcGh5c21hcC50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvbXRkL210ZC1waHlzbWFwLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9tdGQtcGh5c21hcC50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9tdGQvbXRkLXBoeXNtYXAudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9jYW4udHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL25ldC9jYW4vbXBjNXh4eC1tc2Nhbi50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2Nhbi50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9uZXQvY2FuL21wYzV4eHgtbXNjYW4udHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2Nhbi9zamExMDAwLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9uZXQvY2FuL3NqYTEwMDAudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2Nhbi9zamExMDAwLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL25ldC9jYW4vc2phMTAwMC50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL3RzZWMudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL25ldC9mc2wtdHNlYy1waHkudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC90c2VjLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL25ldC9mc2wtdHNlYy1waHkudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2dwaW8vbWRpby50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvbmV0L21kaW8tZ3Bpby50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZ3Bpby9tZGlvLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL25ldC9tZGlvLWdwaW8udHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL3BoeS50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvbmV0L3BoeS50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvcGh5LnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL25ldC9waHkudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC84M3h4LTUxMngtcGNpLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wY2kvODN4eC01MTJ4LXBjaS50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsLzgzeHgtNTEyeC1wY2kudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcGNpLzgzeHgtNTEyeC1wY2kudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzLzR4eC9jcG0udHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvNHh4L2NwbS50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvNHh4L2NwbS50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjLzR4eC9jcG0udHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzLzR4eC9lbWFjLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjLzR4eC9lbWFjLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy80eHgvZW1hYy50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjLzR4eC9lbWFjLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy80eHgvbmRmYy50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy80eHgvbmRmYy50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvNHh4L25kZmMudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy80eHgvbmRmYy50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvNHh4L3BwYzQ0MHNwZS1hZG1hLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjLzR4eC9wcGM0NDBzcGUtYWRtYS50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvNHh4L3BwYzQ0MHNwZS1hZG1hLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvNHh4L3BwYzQ0MHNwZS1hZG1hLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy80eHgvcmVib290LnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjLzR4eC9yZWJvb3QudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzLzR4eC9yZWJvb3QudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy80eHgvcmVib290LnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvYm9hcmQudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL2JvYXJkLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvYm9hcmQudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvYm9hcmQudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9jcG1fcWUvY3BtLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9jcG1fcWUvY3BtLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvY3BtX3FlL2NwbS50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9jcG1fcWUvY3BtLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvY3BtX3FlL2NwbS9icmcudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL2NwbV9xZS9jcG0vYnJnLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvY3BtX3FlL2NwbS9icmcudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvY3BtX3FlL2NwbS9icmcudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9jcG1fcWUvY3BtL2kyYy50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvY3BtX3FlL2NwbS9pMmMudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9jcG1fcWUvY3BtL2kyYy50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9jcG1fcWUvY3BtL2kyYy50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2NwbV9xZS9jcG0vcGljLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9jcG1fcWUvY3BtL3BpYy50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2NwbV9xZS9jcG0vcGljLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL2NwbV9xZS9jcG0vcGljLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvY3BtX3FlL2NwbS91c2IudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL2NwbV9xZS9jcG0vdXNiLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvY3BtX3FlL2NwbS91c2IudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvY3BtX3FlL2NwbS91c2IudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9jcG1fcWUvZ3Bpby50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvY3BtX3FlL2dwaW8udHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9jcG1fcWUvZ3Bpby50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9jcG1fcWUvZ3Bpby50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2NwbV9xZS9uZXR3b3JrLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9jcG1fcWUvbmV0d29yay50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2NwbV9xZS9uZXR3b3JrLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL2NwbV9xZS9uZXR3b3JrLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvY3BtX3FlL3FlLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9jcG1fcWUvcWUudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9jcG1fcWUvcWUudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvY3BtX3FlL3FlLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvY3BtX3FlL3FlL2Zpcm13YXJlLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9jcG1fcWUvcWUvZmlybXdhcmUudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9jcG1fcWUvcWUvZmlybXdhcmUudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvY3BtX3FlL3FlL2Zpcm13YXJlLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvY3BtX3FlL3FlL3Bhcl9pby50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvY3BtX3FlL3FlL3Bhcl9pby50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2NwbV9xZS9xZS9wYXJfaW8udHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvY3BtX3FlL3FlL3Bhcl9pby50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2NwbV9xZS9xZS9waW5jZmcudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL2NwbV9xZS9xZS9waW5jZmcudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9jcG1fcWUvcWUvcGluY2ZnLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL2NwbV9xZS9xZS9waW5jZmcudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9jcG1fcWUvcWUvdWNjLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9jcG1fcWUvcWUvdWNjLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvY3BtX3FlL3FlL3VjYy50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9jcG1fcWUvcWUvdWNjLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvY3BtX3FlL3FlL3VzYi50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvY3BtX3FlL3FlL3VzYi50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2NwbV9xZS9xZS91c2IudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvY3BtX3FlL3FlL3VzYi50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2NwbV9xZS9zZXJpYWwudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL2NwbV9xZS9zZXJpYWwudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9jcG1fcWUvc2VyaWFsLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL2NwbV9xZS9zZXJpYWwudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9kaXUudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL2RpdS50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2RpdS50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9kaXUudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9kbWEudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL2RtYS50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2RtYS50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9kbWEudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2VjbS50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvZWNtLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9lY20udHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvZWNtLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvZ3RtLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9ndG0udHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9ndG0udHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvZ3RtLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvZ3V0cy50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvZ3V0cy50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2d1dHMudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvZ3V0cy50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL2xiYy50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvbGJjLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvbGJjLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL2xiYy50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL21jbS50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvbWNtLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvbWNtLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL21jbS50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL21jdS1tcGM4MzQ5ZW1pdHgudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL21jdS1tcGM4MzQ5ZW1pdHgudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9tY3UtbXBjODM0OWVtaXR4LnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL21jdS1tcGM4MzQ5ZW1pdHgudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9tcGM1MTIxLXBzYy50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvbXBjNTEyMS1wc2MudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9tcGM1MTIxLXBzYy50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9tcGM1MTIxLXBzYy50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL21wYzUyMDAudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL21wYzUyMDAudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9tcGM1MjAwLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL21wYzUyMDAudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9tcGljLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9tcGljLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvbXBpYy50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL2ZzbC9tcGljLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvbXNpLXBpYy50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvbXNpLXBpYy50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL21zaS1waWMudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvbXNpLXBpYy50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL3BtYy50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvcG1jLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvcG1jLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL3BtYy50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL3NlYy50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvc2VjLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvc2VjLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL3NlYy50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL3NzaS50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9mc2wvc3NpLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvc3NpLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvZnNsL3NzaS50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvbmludGVuZG8vZ2FtZWN1YmUudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvbmludGVuZG8vZ2FtZWN1YmUudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL25pbnRlbmRvL2dhbWVjdWJlLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3Bvd2VycGMvbmludGVuZG8vZ2FtZWN1YmUudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL25pbnRlbmRvL3dpaS50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvcG93ZXJwYy9uaW50ZW5kby93aWkudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL25pbnRlbmRvL3dpaS50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9wb3dlcnBjL25pbnRlbmRvL3dpaS50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL3NwaS50eHQgYi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3Mvc3BpL2ZzbC1zcGkudHh0CnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBEb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL2ZzbC9zcGkudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3Mvc3BpL2ZzbC1zcGkudHh0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3Bvd2VycGMvZHRzLWJpbmRpbmdzL3NwaS1idXMudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3NwaS9zcGktYnVzLnR4dApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9zcGktYnVzLnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3NwaS9zcGktYnVzLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy9mc2wvdXNiLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy91c2IvZnNsLXVzYi50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvZnNsL3VzYi50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy91c2IvZnNsLXVzYi50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvdXNiLWVoY2kudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3VzYi91c2ItZWhjaS50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MvdXNiLWVoY2kudHh0CnJlbmFtZSB0byBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvdXNiL3VzYi1laGNpLnR4dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2R0cy1iaW5kaW5ncy94aWxpbngudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3hpbGlueC50eHQKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIERvY3VtZW50YXRpb24vcG93ZXJwYy9kdHMtYmluZGluZ3MveGlsaW54LnR4dApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL3hpbGlueC50eHQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9ib290aW5nLXdpdGhvdXQtb2YudHh0IGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2Jvb3Rpbmctd2l0aG91dC1vZi50eHQKc2ltaWxhcml0eSBpbmRleCA5MCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9wb3dlcnBjL2Jvb3Rpbmctd2l0aG91dC1vZi50eHQKcmVuYW1lIHRvIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9ib290aW5nLXdpdGhvdXQtb2YudHh0CmluZGV4IDc0MDBkNzUuLjkzODFhMTQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vcG93ZXJwYy9ib290aW5nLXdpdGhvdXQtb2YudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9ib290aW5nLXdpdGhvdXQtb2YudHh0CkBAIC0xMyw3ICsxMyw3IEBACiAKICAgSSAtIEludHJvZHVjdGlvbgogICAgIDEpIEVudHJ5IHBvaW50IGZvciBhcmNoL3Bvd2VycGMKLSAgICAyKSBCb2FyZCBzdXBwb3J0CisgICAgMikgRW50cnkgcG9pbnQgZm9yIGFyY2gvYXJtCiAKICAgSUkgLSBUaGUgRFQgYmxvY2sgZm9ybWF0CiAgICAgMSkgSGVhZGVyCkBAIC00MSwxMyArNDEsNiBAQAogICBWSSAtIFN5c3RlbS1vbi1hLWNoaXAgZGV2aWNlcyBhbmQgbm9kZXMKICAgICAxKSBEZWZpbmluZyBjaGlsZCBub2RlcyBvZiBhbiBTT0MKICAgICAyKSBSZXByZXNlbnRpbmcgZGV2aWNlcyB3aXRob3V0IGEgY3VycmVudCBPRiBzcGVjaWZpY2F0aW9uCi0gICAgICBhKSBQSFkgbm9kZXMKLSAgICAgIGIpIEludGVycnVwdCBjb250cm9sbGVycwotICAgICAgYykgNHh4L0F4b24gRU1BQyBldGhlcm5ldCBub2RlcwotICAgICAgZCkgWGlsaW54IElQIGNvcmVzCi0gICAgICBlKSBVU0IgRUhDSSBjb250cm9sbGVycwotICAgICAgZikgTURJTyBvbiBHUElPcwotICAgICAgZykgU1BJIGJ1c3NlcwogCiAgIFZJSSAtIFNwZWNpZnlpbmcgaW50ZXJydXB0IGluZm9ybWF0aW9uIGZvciBkZXZpY2VzCiAgICAgMSkgaW50ZXJydXB0cyBwcm9wZXJ0eQpAQCAtMTIzLDcgKzExNiw3IEBACiBJIC0gSW50cm9kdWN0aW9uCiA9PT09PT09PT09PT09PT09CiAKLUR1cmluZyB0aGUgcmVjZW50IGRldmVsb3BtZW50IG9mIHRoZSBMaW51eC9wcGM2NCBrZXJuZWwsIGFuZCBtb3JlCitEdXJpbmcgdGhlIGRldmVsb3BtZW50IG9mIHRoZSBMaW51eC9wcGM2NCBrZXJuZWwsIGFuZCBtb3JlCiBzcGVjaWZpY2FsbHksIHRoZSBhZGRpdGlvbiBvZiBuZXcgcGxhdGZvcm0gdHlwZXMgb3V0c2lkZSBvZiB0aGUgb2xkCiBJQk0gcFNlcmllcy9pU2VyaWVzIHBhaXIsIGl0IHdhcyBkZWNpZGVkIHRvIGVuZm9yY2Ugc29tZSBzdHJpY3QgcnVsZXMKIHJlZ2FyZGluZyB0aGUga2VybmVsIGVudHJ5IGFuZCBib290bG9hZGVyIDwtPiBrZXJuZWwgaW50ZXJmYWNlcywgaW4KQEAgLTE0Niw3ICsxMzksNyBAQAogY3JlYXRlIGEgbm9kZSBmb3IgZXZlcnkgUENJIGRldmljZSBpbiB0aGUgc3lzdGVtLiBJdCBpcyBhIHJlcXVpcmVtZW50CiB0byBoYXZlIGEgbm9kZSBmb3IgUENJIGhvc3QgYnJpZGdlcyBpbiBvcmRlciB0byBwcm92aWRlIGludGVycnVwdAogcm91dGluZyBpbmZvcm1hdGlvbnMgYW5kIG1lbW9yeS9JTyByYW5nZXMsIGFtb25nIG90aGVycy4gSXQgaXMgYWxzbwotcmVjb21tZW5kZWQgdG8gZGVmaW5lIG5vZGVzIGZvciBvbiBjaGlwIGRldmljZXMgYW5kIG90aGVyIGJ1c3NlcyB0aGF0CityZWNvbW1lbmRlZCB0byBkZWZpbmUgbm9kZXMgZm9yIG9uIGNoaXAgZGV2aWNlcyBhbmQgb3RoZXIgYnVzZXMgdGhhdAogZG9uJ3Qgc3BlY2lmaWNhbGx5IGZpdCBpbiBhbiBleGlzdGluZyBPRiBzcGVjaWZpY2F0aW9uLiBUaGlzIGNyZWF0ZXMgYQogZ3JlYXQgZmxleGliaWxpdHkgaW4gdGhlIHdheSB0aGUga2VybmVsIGNhbiB0aGVuIHByb2JlIHRob3NlIGFuZCBtYXRjaAogZHJpdmVycyB0byBkZXZpY2UsIHdpdGhvdXQgaGF2aW5nIHRvIGhhcmQgY29kZSBhbGwgc29ydHMgb2YgdGFibGVzLiBJdApAQCAtMTU4LDcgKzE1MSw3IEBACiAxKSBFbnRyeSBwb2ludCBmb3IgYXJjaC9wb3dlcnBjCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKLSAgIFRoZXJlIGlzIG9uZSBhbmQgb25lIHNpbmdsZSBlbnRyeSBwb2ludCB0byB0aGUga2VybmVsLCBhdCB0aGUgc3RhcnQKKyAgIFRoZXJlIGlzIG9uZSBzaW5nbGUgZW50cnkgcG9pbnQgdG8gdGhlIGtlcm5lbCwgYXQgdGhlIHN0YXJ0CiAgICBvZiB0aGUga2VybmVsIGltYWdlLiBUaGF0IGVudHJ5IHBvaW50IHN1cHBvcnRzIHR3byBjYWxsaW5nCiAgICBjb252ZW50aW9uczoKIApAQCAtMjEwLDEyICsyMDMsNiBAQAogICAgICAgICB3aXRoIGFsbCBDUFVzLiBUaGUgd2F5IHRvIGRvIHRoYXQgd2l0aCBtZXRob2QgYikgd2lsbCBiZQogICAgICAgICBkZXNjcmliZWQgaW4gYSBsYXRlciByZXZpc2lvbiBvZiB0aGlzIGRvY3VtZW50LgogCi0KLTIpIEJvYXJkIHN1cHBvcnQKLS0tLS0tLS0tLS0tLS0tLS0KLQotNjQtYml0IGtlcm5lbHM6Ci0KICAgIEJvYXJkIHN1cHBvcnRzIChwbGF0Zm9ybXMpIGFyZSBub3QgZXhjbHVzaXZlIGNvbmZpZyBvcHRpb25zLiBBbgogICAgYXJiaXRyYXJ5IHNldCBvZiBib2FyZCBzdXBwb3J0cyBjYW4gYmUgYnVpbHQgaW4gYSBzaW5nbGUga2VybmVsCiAgICBpbWFnZS4gVGhlIGtlcm5lbCB3aWxsICJrbm93IiB3aGF0IHNldCBvZiBmdW5jdGlvbnMgdG8gdXNlIGZvciBhCkBAIC0yMzQsNDcgKzIyMSw0OSBAQAogICAgICAgICBjb250YWluaW5nIHRoZSB2YXJpb3VzIGNhbGxiYWNrcyB0aGF0IHRoZSBnZW5lcmljIGNvZGUgd2lsbAogICAgICAgICB1c2UgdG8gZ2V0IHRvIHlvdXIgcGxhdGZvcm0gc3BlY2lmaWMgY29kZQogCi0gICAgICAgIGMpIEFkZCBhIHJlZmVyZW5jZSB0byB5b3VyICJwcGNfbWQiIHN0cnVjdHVyZSBpbiB0aGUKLSAgICAgICAgIm1hY2hpbmVzIiB0YWJsZSBpbiBhcmNoL3Bvd2VycGMva2VybmVsL3NldHVwXzY0LmMgaWYgeW91IGFyZQotICAgICAgICBhIDY0LWJpdCBwbGF0Zm9ybS4KLQotICAgICAgICBkKSByZXF1ZXN0IGFuZCBnZXQgYXNzaWduZWQgYSBwbGF0Zm9ybSBudW1iZXIgKHNlZSBQTEFURk9STV8qCi0gICAgICAgIGNvbnN0YW50cyBpbiBhcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcHJvY2Vzc29yLmgKLQotMzItYml0IGVtYmVkZGVkIGtlcm5lbHM6Ci0KLSAgQ3VycmVudGx5LCBib2FyZCBzdXBwb3J0IGlzIGVzc2VudGlhbGx5IGFuIGV4Y2x1c2l2ZSBjb25maWcgb3B0aW9uLgotICBUaGUga2VybmVsIGlzIGNvbmZpZ3VyZWQgZm9yIGEgc2luZ2xlIHBsYXRmb3JtLiAgUGFydCBvZiB0aGUgcmVhc29uCi0gIGZvciB0aGlzIGlzIHRvIGtlZXAga2VybmVscyBvbiBlbWJlZGRlZCBzeXN0ZW1zIHNtYWxsIGFuZCBlZmZpY2llbnQ7Ci0gIHBhcnQgb2YgdGhpcyBpcyBkdWUgdG8gdGhlIGZhY3QgdGhlIGNvZGUgaXMgYWxyZWFkeSB0aGF0IHdheS4gSW4gdGhlCi0gIGZ1dHVyZSwgYSBrZXJuZWwgbWF5IHN1cHBvcnQgbXVsdGlwbGUgcGxhdGZvcm1zLCBidXQgb25seSBpZiB0aGUKKyAgQSBrZXJuZWwgaW1hZ2UgbWF5IHN1cHBvcnQgbXVsdGlwbGUgcGxhdGZvcm1zLCBidXQgb25seSBpZiB0aGUKICAgcGxhdGZvcm1zIGZlYXR1cmUgdGhlIHNhbWUgY29yZSBhcmNoaXRlY3R1cmUuICBBIHNpbmdsZSBrZXJuZWwgYnVpbGQKICAgY2Fubm90IHN1cHBvcnQgYm90aCBjb25maWd1cmF0aW9ucyB3aXRoIEJvb2sgRSBhbmQgY29uZmlndXJhdGlvbnMKICAgd2l0aCBjbGFzc2ljIFBvd2VycGMgYXJjaGl0ZWN0dXJlcy4KIAotICAzMi1iaXQgZW1iZWRkZWQgcGxhdGZvcm1zIHRoYXQgYXJlIG1vdmVkIGludG8gYXJjaC9wb3dlcnBjIHVzaW5nIGEKLSAgZmxhdHRlbmVkIGRldmljZSB0cmVlIHNob3VsZCBhZG9wdCB0aGUgbWVyZ2VkIHRyZWUgcHJhY3RpY2Ugb2YKLSAgc2V0dGluZyBwcGNfbWQgdXAgZHluYW1pY2FsbHksIGV2ZW4gdGhvdWdoIHRoZSBrZXJuZWwgaXMgY3VycmVudGx5Ci0gIGJ1aWx0IHdpdGggc3VwcG9ydCBmb3Igb25seSBhIHNpbmdsZSBwbGF0Zm9ybSBhdCBhIHRpbWUuICBUaGlzIGFsbG93cwotICB1bmlmaWNhdGlvbiBvZiB0aGUgc2V0dXAgY29kZSwgYW5kIHdpbGwgbWFrZSBpdCBlYXNpZXIgdG8gZ28gdG8gYQotICBtdWx0aXBsZS1wbGF0Zm9ybS1zdXBwb3J0IG1vZGVsIGluIHRoZSBmdXR1cmUuCisyKSBFbnRyeSBwb2ludCBmb3IgYXJjaC9hcm0KKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCi1OT1RFOiBJIGJlbGlldmUgdGhlIGFib3ZlIHdpbGwgYmUgdHJ1ZSBvbmNlIEJlbidzIGRvbmUgd2l0aCB0aGUgbWVyZ2UKLW9mIHRoZSBib290IHNlcXVlbmNlcy4uLi4gc29tZW9uZSBzcGVhayB1cCBpZiB0aGlzIGlzIHdyb25nIQorICAgVGhlcmUgaXMgb25lIHNpbmdsZSBlbnRyeSBwb2ludCB0byB0aGUga2VybmVsLCBhdCB0aGUgc3RhcnQKKyAgIG9mIHRoZSBrZXJuZWwgaW1hZ2UuIFRoYXQgZW50cnkgcG9pbnQgc3VwcG9ydHMgdHdvIGNhbGxpbmcKKyAgIGNvbnZlbnRpb25zLiAgQSBzdW1tYXJ5IG9mIHRoZSBpbnRlcmZhY2UgaXMgZGVzY3JpYmVkIGhlcmUuICBBIGZ1bGwKKyAgIGRlc2NyaXB0aW9uIG9mIHRoZSBib290IHJlcXVpcmVtZW50cyBpcyBkb2N1bWVudGVkIGluCisgICBEb2N1bWVudGF0aW9uL2FybS9Cb290aW5nCiAKLSAgVG8gYWRkIGEgMzItYml0IGVtYmVkZGVkIHBsYXRmb3JtIHN1cHBvcnQsIGZvbGxvdyB0aGUgaW5zdHJ1Y3Rpb25zCi0gIGZvciA2NC1iaXQgcGxhdGZvcm1zIGFib3ZlLCB3aXRoIHRoZSBleGNlcHRpb24gdGhhdCB0aGUgS2NvbmZpZwotICBvcHRpb24gc2hvdWxkIGJlIHNldCB1cCBzdWNoIHRoYXQgdGhlIGtlcm5lbCBidWlsZHMgZXhjbHVzaXZlbHkgZm9yCi0gIHRoZSBwbGF0Zm9ybSBzZWxlY3RlZC4gIFRoZSBwcm9jZXNzb3IgdHlwZSBmb3IgdGhlIHBsYXRmb3JtIHNob3VsZAotICBlbmFibGUgYW5vdGhlciBjb25maWcgb3B0aW9uIHRvIHNlbGVjdCB0aGUgc3BlY2lmaWMgYm9hcmQKLSAgc3VwcG9ydGVkLgorICAgICAgICBhKSBBVEFHUyBpbnRlcmZhY2UuICBNaW5pbWFsIGluZm9ybWF0aW9uIGlzIHBhc3NlZCBmcm9tIGZpcm13YXJlCisgICAgICAgIHRvIHRoZSBrZXJuZWwgd2l0aCBhIHRhZ2dlZCBsaXN0IG9mIHByZWRlZmluZWQgcGFyYW1ldGVycy4KIAotTk9URTogSWYgQmVuIGRvZXNuJ3QgbWVyZ2UgdGhlIHNldHVwIGZpbGVzLCBtYXkgbmVlZCB0byBjaGFuZ2UgdGhpcyB0bwotcG9pbnQgdG8gc2V0dXBfMzIuYworICAgICAgICAgICAgICAgIHIwIDogMAogCisgICAgICAgICAgICAgICAgcjEgOiBNYWNoaW5lIHR5cGUgbnVtYmVyCiAKLSAgIEkgd2lsbCBkZXNjcmliZSBsYXRlciB0aGUgYm9vdCBwcm9jZXNzIGFuZCB2YXJpb3VzIGNhbGxiYWNrcyB0aGF0Ci0gICB5b3VyIHBsYXRmb3JtIHNob3VsZCBpbXBsZW1lbnQuCisgICAgICAgICAgICAgICAgcjIgOiBQaHlzaWNhbCBhZGRyZXNzIG9mIHRhZ2dlZCBsaXN0IGluIHN5c3RlbSBSQU0KKworICAgICAgICBiKSBFbnRyeSB3aXRoIGEgZmxhdHRlbmVkIGRldmljZS10cmVlIGJsb2NrLiAgRmlybXdhcmUgbG9hZHMgdGhlCisgICAgICAgIHBoeXNpY2FsIGFkZHJlc3Mgb2YgdGhlIGZsYXR0ZW5lZCBkZXZpY2UgdHJlZSBibG9jayAoZHRiKSBpbnRvIHIyLAorICAgICAgICByMSBpcyBub3QgdXNlZCwgYnV0IGl0IGlzIGNvbnNpZGVyZWQgZ29vZCBwcmFjdGlzZSB0byB1c2UgYSB2YWxpZAorICAgICAgICBtYWNoaW5lIG51bWJlciBhcyBkZXNjcmliZWQgaW4gRG9jdW1lbnRhdGlvbi9hcm0vQm9vdGluZy4KKworICAgICAgICAgICAgICAgIHIwIDogMAorCisgICAgICAgICAgICAgICAgcjEgOiBWYWxpZCBtYWNoaW5lIHR5cGUgbnVtYmVyLiAgV2hlbiB1c2luZyBhIGRldmljZSB0cmVlLAorICAgICAgICAgICAgICAgIGEgc2luZ2xlIG1hY2hpbmUgdHlwZSBudW1iZXIgd2lsbCBvZnRlbiBiZSBhc3NpZ25lZCB0bworICAgICAgICAgICAgICAgIHJlcHJlc2VudCBhIGNsYXNzIG9yIGZhbWlseSBvZiBTb0NzLgorCisgICAgICAgICAgICAgICAgcjIgOiBwaHlzaWNhbCBwb2ludGVyIHRvIHRoZSBkZXZpY2UtdHJlZSBibG9jaworICAgICAgICAgICAgICAgIChkZWZpbmVkIGluIGNoYXB0ZXIgSUkpIGluIFJBTS4gIERldmljZSB0cmVlIGNhbiBiZSBsb2NhdGVkCisgICAgICAgICAgICAgICAgYW55d2hlcmUgaW4gc3lzdGVtIFJBTSwgYnV0IGl0IHNob3VsZCBiZSBhbGlnbmVkIG9uIGEgMzIgYml0CisgICAgICAgICAgICAgICAgYm91bmRhcnkuCisKKyAgIFRoZSBrZXJuZWwgd2lsbCBkaWZmZXJlbnRpYXRlIGJldHdlZW4gQVRBR1MgYW5kIGRldmljZSB0cmVlIGJvb3RpbmcgYnkKKyAgIHJlYWRpbmcgdGhlIG1lbW9yeSBwb2ludGVkIHRvIGJ5IHIxIGFuZCBsb29raW5nIGZvciBlaXRoZXIgdGhlIGZsYXR0ZW5lZAorICAgZGV2aWNlIHRyZWUgYmxvY2sgbWFnaWMgdmFsdWUgKDB4ZDAwZGZlZWQpIG9yIHRoZSBBVEFHX0NPUkUgdmFsdWUgYXQKKyAgIG9mZnNldCAweDQgZnJvbSByMiAoMHg1NDQxMDAwMSkuCiAKIAogSUkgLSBUaGUgRFQgYmxvY2sgZm9ybWF0CkBAIC0zMDAsOCArMjg5LDggQEAKIDEpIEhlYWRlcgogLS0tLS0tLS0tCiAKLSAgIFRoZSBrZXJuZWwgaXMgZW50ZXJlZCB3aXRoIHIzIHBvaW50aW5nIHRvIGFuIGFyZWEgb2YgbWVtb3J5IHRoYXQgaXMKLSAgIHJvdWdobHkgZGVzY3JpYmVkIGluIGFyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9wcm9tLmggYnkgdGhlIHN0cnVjdHVyZQorICAgVGhlIGtlcm5lbCBpcyBwYXNzZWQgdGhlIHBoeXNpY2FsIGFkZHJlc3MgcG9pbnRpbmcgdG8gYW4gYXJlYSBvZiBtZW1vcnkKKyAgIHRoYXQgaXMgcm91Z2hseSBkZXNjcmliZWQgaW4gaW5jbHVkZS9saW51eC9vZl9mZHQuaCBieSB0aGUgc3RydWN0dXJlCiAgICBib290X3BhcmFtX2hlYWRlcjoKIAogc3RydWN0IGJvb3RfcGFyYW1faGVhZGVyIHsKQEAgLTMzOSw3ICszMjgsNyBAQAogICAgQWxsIHZhbHVlcyBpbiB0aGlzIGhlYWRlciBhcmUgaW4gYmlnIGVuZGlhbiBmb3JtYXQsIHRoZSB2YXJpb3VzCiAgICBmaWVsZHMgaW4gdGhpcyBoZWFkZXIgYXJlIGRlZmluZWQgbW9yZSBwcmVjaXNlbHkgYmVsb3cuIEFsbAogICAgIm9mZnNldCIgdmFsdWVzIGFyZSBpbiBieXRlcyBmcm9tIHRoZSBzdGFydCBvZiB0aGUgaGVhZGVyOyB0aGF0IGlzCi0gICBmcm9tIHRoZSB2YWx1ZSBvZiByMy4KKyAgIGZyb20gdGhlIHBoeXNpY2FsIGJhc2UgYWRkcmVzcyBvZiB0aGUgZGV2aWNlIHRyZWUgYmxvY2suCiAKICAgIC0gbWFnaWMKIApAQCAtNDM3LDcgKzQyNiw3IEBACiAKIAogICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotICAgICAgIHIzIC0+IHwgIHN0cnVjdCBib290X3BhcmFtX2hlYWRlciAgfAorICAgICBiYXNlIC0+IHwgIHN0cnVjdCBib290X3BhcmFtX2hlYWRlciAgfAogICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogICAgICAgICAgICAgIHwgICAgICAoYWxpZ25tZW50IGdhcCkgKCopICAgfAogICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpAQCAtNDU3LDcgKzQ0Niw3IEBACiAgICAgICAtLS0tLT4gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgICAgICB8CiAgICAgICB8Ci0gICAgICAtLS0gKHIzICsgdG90YWxzaXplKQorICAgICAgLS0tIChiYXNlICsgdG90YWxzaXplKQogCiAgICgqKSBUaGUgYWxpZ25tZW50IGdhcHMgYXJlIG5vdCBuZWNlc3NhcmlseSBwcmVzZW50OyB0aGVpciBwcmVzZW5jZQogICAgICAgYW5kIHNpemUgYXJlIGRlcGVuZGVudCBvbiB0aGUgdmFyaW91cyBhbGlnbm1lbnQgcmVxdWlyZW1lbnRzIG9mCkBAIC01MDAsNyArNDg5LDcgQEAKIHRoZSBkZXZpY2UtdHJlZS4gTW9yZSBkZXRhaWxzIGFib3V0IHRoZSBhY3R1YWwgZm9ybWF0IG9mIHRoZXNlIHdpbGwgYmUKIGJlbG93LgogCi1UaGUga2VybmVsIHBvd2VycGMgZ2VuZXJpYyBjb2RlIGRvZXMgbm90IG1ha2UgYW55IGZvcm1hbCB1c2Ugb2YgdGhlCitUaGUga2VybmVsIGdlbmVyaWMgY29kZSBkb2VzIG5vdCBtYWtlIGFueSBmb3JtYWwgdXNlIG9mIHRoZQogdW5pdCBhZGRyZXNzICh0aG91Z2ggc29tZSBib2FyZCBzdXBwb3J0IGNvZGUgbWF5IGRvKSBzbyB0aGUgb25seSByZWFsCiByZXF1aXJlbWVudCBoZXJlIGZvciB0aGUgdW5pdCBhZGRyZXNzIGlzIHRvIGVuc3VyZSB1bmlxdWVuZXNzIG9mCiB0aGUgbm9kZSB1bml0IG5hbWUgYXQgYSBnaXZlbiBsZXZlbCBvZiB0aGUgdHJlZS4gTm9kZXMgd2l0aCBubyBub3Rpb24KQEAgLTUxOCwyMCArNTA3LDIxIEBACiAKIEV2ZXJ5IG5vZGUgd2hpY2ggYWN0dWFsbHkgcmVwcmVzZW50cyBhbiBhY3R1YWwgZGV2aWNlICh0aGF0IGlzLCBhIG5vZGUKIHdoaWNoIGlzbid0IG9ubHkgYSB2aXJ0dWFsICJjb250YWluZXIiIGZvciBtb3JlIG5vZGVzLCBsaWtlICIvY3B1cyIKLWlzKSBpcyBhbHNvIHJlcXVpcmVkIHRvIGhhdmUgYSAiZGV2aWNlX3R5cGUiIHByb3BlcnR5IGluZGljYXRpbmcgdGhlCi10eXBlIG9mIG5vZGUgLgoraXMpIGlzIGFsc28gcmVxdWlyZWQgdG8gaGF2ZSBhICJjb21wYXRpYmxlIiBwcm9wZXJ0eSBpbmRpY2F0aW5nIHRoZQorc3BlY2lmaWMgaGFyZHdhcmUgYW5kIGFuIG9wdGlvbmFsIGxpc3Qgb2YgZGV2aWNlcyBpdCBpcyBmdWxseQorYmFja3dhcmRzIGNvbXBhdGlibGUgd2l0aC4KIAogRmluYWxseSwgZXZlcnkgbm9kZSB0aGF0IGNhbiBiZSByZWZlcmVuY2VkIGZyb20gYSBwcm9wZXJ0eSBpbiBhbm90aGVyCi1ub2RlIGlzIHJlcXVpcmVkIHRvIGhhdmUgYSAibGludXgscGhhbmRsZSIgcHJvcGVydHkuIFJlYWwgb3BlbgotZmlybXdhcmUgaW1wbGVtZW50YXRpb25zIHByb3ZpZGUgYSB1bmlxdWUgInBoYW5kbGUiIHZhbHVlIGZvciBldmVyeQotbm9kZSB0aGF0IHRoZSAicHJvbV9pbml0KCkiIHRyYW1wb2xpbmUgY29kZSB0dXJucyBpbnRvCi0ibGludXgscGhhbmRsZSIgcHJvcGVydGllcy4gSG93ZXZlciwgdGhpcyBpcyBtYWRlIG9wdGlvbmFsIGlmIHRoZQotZmxhdHRlbmVkIGRldmljZSB0cmVlIGlzIHVzZWQgZGlyZWN0bHkuIEFuIGV4YW1wbGUgb2YgYSBub2RlCitub2RlIGlzIHJlcXVpcmVkIHRvIGhhdmUgZWl0aGVyIGEgInBoYW5kbGUiIG9yIGEgImxpbnV4LHBoYW5kbGUiCitwcm9wZXJ0eS4gUmVhbCBPcGVuIEZpcm13YXJlIGltcGxlbWVudGF0aW9ucyBwcm92aWRlIGEgdW5pcXVlCisicGhhbmRsZSIgdmFsdWUgZm9yIGV2ZXJ5IG5vZGUgdGhhdCB0aGUgInByb21faW5pdCgpIiB0cmFtcG9saW5lIGNvZGUKK3R1cm5zIGludG8gImxpbnV4LHBoYW5kbGUiIHByb3BlcnRpZXMuIEhvd2V2ZXIsIHRoaXMgaXMgbWFkZSBvcHRpb25hbAoraWYgdGhlIGZsYXR0ZW5lZCBkZXZpY2UgdHJlZSBpcyB1c2VkIGRpcmVjdGx5LiBBbiBleGFtcGxlIG9mIGEgbm9kZQogcmVmZXJlbmNpbmcgYW5vdGhlciBub2RlIHZpYSAicGhhbmRsZSIgaXMgd2hlbiBsYXlpbmcgb3V0IHRoZQogaW50ZXJydXB0IHRyZWUgd2hpY2ggd2lsbCBiZSBkZXNjcmliZWQgaW4gYSBmdXJ0aGVyIHZlcnNpb24gb2YgdGhpcwogZG9jdW1lbnQuCiAKLVRoaXMgImxpbnV4LCBwaGFuZGxlIiBwcm9wZXJ0eSBpcyBhIDMyLWJpdCB2YWx1ZSB0aGF0IHVuaXF1ZWx5CitUaGUgInBoYW5kbGUiIHByb3BlcnR5IGlzIGEgMzItYml0IHZhbHVlIHRoYXQgdW5pcXVlbHkKIGlkZW50aWZpZXMgYSBub2RlLiBZb3UgYXJlIGZyZWUgdG8gdXNlIHdoYXRldmVyIHZhbHVlcyBvciBzeXN0ZW0gb2YKIHZhbHVlcywgaW50ZXJuYWwgcG9pbnRlcnMsIG9yIHdoYXRldmVyIHRvIGdlbmVyYXRlIHRoZXNlLCB0aGUgb25seQogcmVxdWlyZW1lbnQgaXMgdGhhdCBldmVyeSBub2RlIGZvciB3aGljaCB5b3UgcHJvdmlkZSB0aGF0IHByb3BlcnR5IGhhcwpAQCAtNjk0LDcgKzY4NCw3IEBACiB3aGlsZSB0aGUgdG9wIGNlbGwgY29udGFpbnMgYWRkcmVzcyBzcGFjZSBpbmRpY2F0aW9uLCBmbGFncywgYW5kIHBjaQogYnVzICYgZGV2aWNlIG51bWJlcnMuCiAKLUZvciBidXNzZXMgdGhhdCBzdXBwb3J0IGR5bmFtaWMgYWxsb2NhdGlvbiwgaXQncyB0aGUgYWNjZXB0ZWQgcHJhY3RpY2UKK0ZvciBidXNlcyB0aGF0IHN1cHBvcnQgZHluYW1pYyBhbGxvY2F0aW9uLCBpdCdzIHRoZSBhY2NlcHRlZCBwcmFjdGljZQogdG8gdGhlbiBub3QgcHJvdmlkZSB0aGUgYWRkcmVzcyBpbiAicmVnIiAoa2VlcCBpdCAwKSB0aG91Z2ggd2hpbGUKIHByb3ZpZGluZyBhIGZsYWcgaW5kaWNhdGluZyB0aGUgYWRkcmVzcyBpcyBkeW5hbWljYWxseSBhbGxvY2F0ZWQsIGFuZAogdGhlbiwgdG8gcHJvdmlkZSBhIHNlcGFyYXRlICJhc3NpZ25lZC1hZGRyZXNzZXMiIHByb3BlcnR5IHRoYXQKQEAgLTcxMSw3ICs3MDEsNyBAQAogVGhlICJyZWciIHByb3BlcnR5IG9ubHkgZGVmaW5lcyBhZGRyZXNzZXMgYW5kIHNpemVzIChpZiAjc2l6ZS1jZWxscyBpcwogbm9uLTApIHdpdGhpbiBhIGdpdmVuIGJ1cy4gSW4gb3JkZXIgdG8gdHJhbnNsYXRlIGFkZHJlc3NlcyB1cHdhcmQKICh0aGF0IGlzIGludG8gcGFyZW50IGJ1cyBhZGRyZXNzZXMsIGFuZCBwb3NzaWJseSBpbnRvIENQVSBwaHlzaWNhbAotYWRkcmVzc2VzKSwgYWxsIGJ1c3NlcyBtdXN0IGNvbnRhaW4gYSAicmFuZ2VzIiBwcm9wZXJ0eS4gSWYgdGhlCithZGRyZXNzZXMpLCBhbGwgYnVzZXMgbXVzdCBjb250YWluIGEgInJhbmdlcyIgcHJvcGVydHkuIElmIHRoZQogInJhbmdlcyIgcHJvcGVydHkgaXMgbWlzc2luZyBhdCBhIGdpdmVuIGxldmVsLCBpdCdzIGFzc3VtZWQgdGhhdAogdHJhbnNsYXRpb24gaXNuJ3QgcG9zc2libGUsIGkuZS4sIHRoZSByZWdpc3RlcnMgYXJlIG5vdCB2aXNpYmxlIG9uIHRoZQogcGFyZW50IGJ1cy4gIFRoZSBmb3JtYXQgb2YgdGhlICJyYW5nZXMiIHByb3BlcnR5IGZvciBhIGJ1cyBpcyBhIGxpc3QKQEAgLTcyNyw5ICs3MTcsOSBAQAogUENJPC0+SVNBIGJyaWRnZSwgdGhhdCB3b3VsZCBiZSBhIFBDSSBhZGRyZXNzLiBJdCBkZWZpbmVzIHRoZSBiYXNlCiBhZGRyZXNzIGluIHRoZSBwYXJlbnQgYnVzIHdoZXJlIHRoZSBiZWdpbm5pbmcgb2YgdGhhdCByYW5nZSBpcyBtYXBwZWQuCiAKLUZvciBhIG5ldyA2NC1iaXQgcG93ZXJwYyBib2FyZCwgSSByZWNvbW1lbmQgZWl0aGVyIHRoZSAyLzIgZm9ybWF0IG9yCitGb3IgbmV3IDY0LWJpdCBib2FyZCBzdXBwb3J0LCBJIHJlY29tbWVuZCBlaXRoZXIgdGhlIDIvMiBmb3JtYXQgb3IKIEFwcGxlJ3MgMi8xIGZvcm1hdCB3aGljaCBpcyBzbGlnaHRseSBtb3JlIGNvbXBhY3Qgc2luY2Ugc2l6ZXMgdXN1YWxseQotZml0IGluIGEgc2luZ2xlIDMyLWJpdCB3b3JkLiAgIE5ldyAzMi1iaXQgcG93ZXJwYyBib2FyZHMgc2hvdWxkIHVzZSBhCitmaXQgaW4gYSBzaW5nbGUgMzItYml0IHdvcmQuICAgTmV3IDMyLWJpdCBib2FyZCBzdXBwb3J0IHNob3VsZCB1c2UgYQogMS8xIGZvcm1hdCwgdW5sZXNzIHRoZSBwcm9jZXNzb3Igc3VwcG9ydHMgcGh5c2ljYWwgYWRkcmVzc2VzIGdyZWF0ZXIKIHRoYW4gMzItYml0cywgaW4gd2hpY2ggY2FzZSBhIDIvMSBmb3JtYXQgaXMgcmVjb21tZW5kZWQuCiAKQEAgLTc1NCw3ICs3NDQsNyBAQAogV2hpbGUgZWFybGllciB1c2VycyBvZiBPcGVuIEZpcm13YXJlIGxpa2UgT2xkV29ybGQgbWFjaW50b3NoZXMgdGVuZGVkCiB0byB1c2UgdGhlIGFjdHVhbCBkZXZpY2UgbmFtZSBmb3IgdGhlICJuYW1lIiBwcm9wZXJ0eSwgaXQncyBub3dhZGF5cwogY29uc2lkZXJlZCBhIGdvb2QgcHJhY3RpY2UgdG8gdXNlIGEgbmFtZSB0aGF0IGlzIGNsb3NlciB0byB0aGUgZGV2aWNlCi1jbGFzcyAob2Z0ZW4gZXF1YWwgdG8gZGV2aWNlX3R5cGUpLiBGb3IgZXhhbXBsZSwgbm93YWRheXMsIGV0aGVybmV0CitjbGFzcyAob2Z0ZW4gZXF1YWwgdG8gZGV2aWNlX3R5cGUpLiBGb3IgZXhhbXBsZSwgbm93YWRheXMsIEV0aGVybmV0CiBjb250cm9sbGVycyBhcmUgbmFtZWQgImV0aGVybmV0IiwgYW4gYWRkaXRpb25hbCAibW9kZWwiIHByb3BlcnR5CiBkZWZpbmluZyBwcmVjaXNlbHkgdGhlIGNoaXAgdHlwZS9tb2RlbCwgYW5kICJjb21wYXRpYmxlIiBwcm9wZXJ0eQogZGVmaW5pbmcgdGhlIGZhbWlseSBpbiBjYXNlIGEgc2luZ2xlIGRyaXZlciBjYW4gZHJpdmVyIG1vcmUgdGhhbiBvbmUKQEAgLTc3Miw3ICs3NjIsNyBAQAogNCkgTm90ZSBhYm91dCBub2RlIGFuZCBwcm9wZXJ0eSBuYW1lcyBhbmQgY2hhcmFjdGVyIHNldAogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCi1XaGlsZSBvcGVuIGZpcm13YXJlIHByb3ZpZGVzIG1vcmUgZmxleGlibGUgdXNhZ2Ugb2YgODg1OS0xLCB0aGlzCitXaGlsZSBPcGVuIEZpcm13YXJlIHByb3ZpZGVzIG1vcmUgZmxleGlibGUgdXNhZ2Ugb2YgODg1OS0xLCB0aGlzCiBzcGVjaWZpY2F0aW9uIGVuZm9yY2VzIG1vcmUgc3RyaWN0IHJ1bGVzLiBOb2RlcyBhbmQgcHJvcGVydGllcyBzaG91bGQKIGJlIGNvbXByaXNlZCBvbmx5IG9mIEFTQ0lJIGNoYXJhY3RlcnMgJ2EnIHRvICd6JywgJzAnIHRvCiAnOScsICcsJywgJy4nLCAnXycsICcrJywgJyMnLCAnPycsIGFuZCAnLScuIE5vZGUgbmFtZXMgYWRkaXRpb25hbGx5CkBAIC03OTIsNyArNzgyLDcgQEAKIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgIFRoZXNlIGFyZSBhbGwgdGhhdCBhcmUgY3VycmVudGx5IHJlcXVpcmVkLiBIb3dldmVyLCBpdCBpcyBzdHJvbmdseQogICByZWNvbW1lbmRlZCB0aGF0IHlvdSBleHBvc2UgUENJIGhvc3QgYnJpZGdlcyBhcyBkb2N1bWVudGVkIGluIHRoZQotICBQQ0kgYmluZGluZyB0byBvcGVuIGZpcm13YXJlLCBhbmQgeW91ciBpbnRlcnJ1cHQgdHJlZSBhcyBkb2N1bWVudGVkCisgIFBDSSBiaW5kaW5nIHRvIE9wZW4gRmlybXdhcmUsIGFuZCB5b3VyIGludGVycnVwdCB0cmVlIGFzIGRvY3VtZW50ZWQKICAgaW4gT0YgaW50ZXJydXB0IHRyZWUgc3BlY2lmaWNhdGlvbi4KIAogICBhKSBUaGUgcm9vdCBub2RlCkBAIC04MDIsMjAgKzc5MiwxMiBAQAogICAgIC0gbW9kZWwgOiB0aGlzIGlzIHlvdXIgYm9hcmQgbmFtZS9tb2RlbAogICAgIC0gI2FkZHJlc3MtY2VsbHMgOiBhZGRyZXNzIHJlcHJlc2VudGF0aW9uIGZvciAicm9vdCIgZGV2aWNlcwogICAgIC0gI3NpemUtY2VsbHM6IHRoZSBzaXplIHJlcHJlc2VudGF0aW9uIGZvciAicm9vdCIgZGV2aWNlcwotICAgIC0gZGV2aWNlX3R5cGUgOiBUaGlzIHByb3BlcnR5IHNob3VsZG4ndCBiZSBuZWNlc3NhcnkuIEhvd2V2ZXIsIGlmCi0gICAgICB5b3UgZGVjaWRlIHRvIGNyZWF0ZSBhIGRldmljZV90eXBlIGZvciB5b3VyIHJvb3Qgbm9kZSwgbWFrZSBzdXJlIGl0Ci0gICAgICBpcyBfbm90XyAiY2hycCIgdW5sZXNzIHlvdXIgcGxhdGZvcm0gaXMgYSBwU2VyaWVzIG9yIFBBUFIgY29tcGxpYW50Ci0gICAgICBvbmUgZm9yIDY0LWJpdCwgb3IgYSBDSFJQLXR5cGUgbWFjaGluZSBmb3IgMzItYml0IGFzIHRoaXMgd2lsbAotICAgICAgbWF0Y2hlZCBieSB0aGUga2VybmVsIHRoaXMgd2F5LgotCi0gIEFkZGl0aW9uYWxseSwgc29tZSByZWNvbW1lbmRlZCBwcm9wZXJ0aWVzIGFyZToKLQogICAgIC0gY29tcGF0aWJsZSA6IHRoZSBib2FyZCAiZmFtaWx5IiBnZW5lcmFsbHkgZmluZHMgaXRzIHdheSBoZXJlLAogICAgICAgZm9yIGV4YW1wbGUsIGlmIHlvdSBoYXZlIDIgYm9hcmQgbW9kZWxzIHdpdGggYSBzaW1pbGFyIGxheW91dCwKICAgICAgIHRoYXQgdHlwaWNhbGx5IGdldCBkcml2ZW4gYnkgdGhlIHNhbWUgcGxhdGZvcm0gY29kZSBpbiB0aGUKLSAgICAgIGtlcm5lbCwgeW91IHdvdWxkIHVzZSBhIGRpZmZlcmVudCAibW9kZWwiIHByb3BlcnR5IGJ1dCBwdXQgYQotICAgICAgdmFsdWUgaW4gImNvbXBhdGlibGUiLiBUaGUga2VybmVsIGRvZXNuJ3QgZGlyZWN0bHkgdXNlIHRoYXQKLSAgICAgIHZhbHVlIGJ1dCBpdCBpcyBnZW5lcmFsbHkgdXNlZnVsLgorICAgICAga2VybmVsLCB5b3Ugd291bGQgc3BlY2lmeSB0aGUgZXhhY3QgYm9hcmQgbW9kZWwgaW4gdGhlCisgICAgICBjb21wYXRpYmxlIHByb3BlcnR5IGZvbGxvd2VkIGJ5IGFuIGVudHJ5IHRoYXQgcmVwcmVzZW50cyB0aGUgU29DCisgICAgICBtb2RlbC4KIAogICBUaGUgcm9vdCBub2RlIGlzIGFsc28gZ2VuZXJhbGx5IHdoZXJlIHlvdSBhZGQgYWRkaXRpb25hbCBwcm9wZXJ0aWVzCiAgIHNwZWNpZmljIHRvIHlvdXIgYm9hcmQgbGlrZSB0aGUgc2VyaWFsIG51bWJlciBpZiBhbnksIHRoYXQgc29ydCBvZgpAQCAtODQxLDggKzgyMywxMSBAQAogCiAgIFNvIHVuZGVyIC9jcHVzLCB5b3UgYXJlIHN1cHBvc2VkIHRvIGNyZWF0ZSBhIG5vZGUgZm9yIGV2ZXJ5IENQVSBvbgogICB0aGUgbWFjaGluZS4gVGhlcmUgaXMgbm8gc3BlY2lmaWMgcmVzdHJpY3Rpb24gb24gdGhlIG5hbWUgb2YgdGhlCi0gIENQVSwgdGhvdWdoIEl0J3MgY29tbW9uIHByYWN0aWNlIHRvIGNhbGwgaXQgUG93ZXJQQyw8bmFtZT4uIEZvcgorICBDUFUsIHRob3VnaCBpdCdzIGNvbW1vbiB0byBjYWxsIGl0IDxhcmNoaXRlY3R1cmU+LDxjb3JlPi4gRm9yCiAgIGV4YW1wbGUsIEFwcGxlIHVzZXMgUG93ZXJQQyxHNSB3aGlsZSBJQk0gdXNlcyBQb3dlclBDLDk3MEZYLgorICBIb3dldmVyLCB0aGUgR2VuZXJpYyBOYW1lcyBjb252ZW50aW9uIHN1Z2dlc3RzIHRoYXQgaXQgd291bGQgYmUKKyAgYmV0dGVyIHRvIHNpbXBseSB1c2UgJ2NwdScgZm9yIGVhY2ggY3B1IG5vZGUgYW5kIHVzZSB0aGUgY29tcGF0aWJsZQorICBwcm9wZXJ0eSB0byBpZGVudGlmeSB0aGUgc3BlY2lmaWMgY3B1IGNvcmUuCiAKICAgUmVxdWlyZWQgcHJvcGVydGllczoKIApAQCAtOTIzLDcgKzkwOCw3IEBACiAKICAgZSkgVGhlIC9jaG9zZW4gbm9kZQogCi0gIFRoaXMgbm9kZSBpcyBhIGJpdCAic3BlY2lhbCIuIE5vcm1hbGx5LCB0aGF0J3Mgd2hlcmUgb3BlbiBmaXJtd2FyZQorICBUaGlzIG5vZGUgaXMgYSBiaXQgInNwZWNpYWwiLiBOb3JtYWxseSwgdGhhdCdzIHdoZXJlIE9wZW4gRmlybXdhcmUKICAgcHV0cyBzb21lIHZhcmlhYmxlIGVudmlyb25tZW50IGluZm9ybWF0aW9uLCBsaWtlIHRoZSBhcmd1bWVudHMsIG9yCiAgIHRoZSBkZWZhdWx0IGlucHV0L291dHB1dCBkZXZpY2VzLgogCkBAIC05NDAsMTEgKzkyNSw3IEBACiAgICAgICBjb25zb2xlIGRldmljZSBpZiBhbnkuIFR5cGljYWxseSwgaWYgeW91IGhhdmUgc2VyaWFsIGRldmljZXMgb24KICAgICAgIHlvdXIgYm9hcmQsIHlvdSBtYXkgd2FudCB0byBwdXQgdGhlIGZ1bGwgcGF0aCB0byB0aGUgb25lIHNldCBhcwogICAgICAgdGhlIGRlZmF1bHQgY29uc29sZSBpbiB0aGUgZmlybXdhcmUgaGVyZSwgZm9yIHRoZSBrZXJuZWwgdG8gcGljawotICAgICAgaXQgdXAgYXMgaXRzIG93biBkZWZhdWx0IGNvbnNvbGUuIElmIHlvdSBsb29rIGF0IHRoZSBmdW5jdGlvbgotICAgICAgc2V0X3ByZWZlcnJlZF9jb25zb2xlKCkgaW4gYXJjaC9wcGM2NC9rZXJuZWwvc2V0dXAuYywgeW91J2xsIHNlZQotICAgICAgdGhhdCB0aGUga2VybmVsIHRyaWVzIHRvIGZpbmQgb3V0IHRoZSBkZWZhdWx0IGNvbnNvbGUgYW5kIGhhcwotICAgICAga25vd2xlZGdlIG9mIHZhcmlvdXMgdHlwZXMgbGlrZSA4MjUwIHNlcmlhbCBwb3J0cy4gWW91IG1heSB3YW50Ci0gICAgICB0byBleHRlbmQgdGhpcyBmdW5jdGlvbiB0byBhZGQgeW91ciBvd24uCisgICAgICBpdCB1cCBhcyBpdHMgb3duIGRlZmF1bHQgY29uc29sZS4KIAogICBOb3RlIHRoYXQgdS1ib290IGNyZWF0ZXMgYW5kIGZpbGxzIGluIHRoZSBjaG9zZW4gbm9kZSBmb3IgcGxhdGZvcm1zCiAgIHRoYXQgdXNlIGl0LgpAQCAtOTU1LDIzICs5MzYsMjMgQEAKIAogICBmKSB0aGUgL3NvYzxTT0NuYW1lPiBub2RlCiAKLSAgVGhpcyBub2RlIGlzIHVzZWQgdG8gcmVwcmVzZW50IGEgc3lzdGVtLW9uLWEtY2hpcCAoU09DKSBhbmQgbXVzdCBiZQotICBwcmVzZW50IGlmIHRoZSBwcm9jZXNzb3IgaXMgYSBTT0MuIFRoZSB0b3AtbGV2ZWwgc29jIG5vZGUgY29udGFpbnMKLSAgaW5mb3JtYXRpb24gdGhhdCBpcyBnbG9iYWwgdG8gYWxsIGRldmljZXMgb24gdGhlIFNPQy4gVGhlIG5vZGUgbmFtZQotICBzaG91bGQgY29udGFpbiBhIHVuaXQgYWRkcmVzcyBmb3IgdGhlIFNPQywgd2hpY2ggaXMgdGhlIGJhc2UgYWRkcmVzcwotICBvZiB0aGUgbWVtb3J5LW1hcHBlZCByZWdpc3RlciBzZXQgZm9yIHRoZSBTT0MuIFRoZSBuYW1lIG9mIGFuIHNvYworICBUaGlzIG5vZGUgaXMgdXNlZCB0byByZXByZXNlbnQgYSBzeXN0ZW0tb24tYS1jaGlwIChTb0MpIGFuZCBtdXN0IGJlCisgIHByZXNlbnQgaWYgdGhlIHByb2Nlc3NvciBpcyBhIFNvQy4gVGhlIHRvcC1sZXZlbCBzb2Mgbm9kZSBjb250YWlucworICBpbmZvcm1hdGlvbiB0aGF0IGlzIGdsb2JhbCB0byBhbGwgZGV2aWNlcyBvbiB0aGUgU29DLiBUaGUgbm9kZSBuYW1lCisgIHNob3VsZCBjb250YWluIGEgdW5pdCBhZGRyZXNzIGZvciB0aGUgU29DLCB3aGljaCBpcyB0aGUgYmFzZSBhZGRyZXNzCisgIG9mIHRoZSBtZW1vcnktbWFwcGVkIHJlZ2lzdGVyIHNldCBmb3IgdGhlIFNvQy4gVGhlIG5hbWUgb2YgYW4gU29DCiAgIG5vZGUgc2hvdWxkIHN0YXJ0IHdpdGggInNvYyIsIGFuZCB0aGUgcmVtYWluZGVyIG9mIHRoZSBuYW1lIHNob3VsZAogICByZXByZXNlbnQgdGhlIHBhcnQgbnVtYmVyIGZvciB0aGUgc29jLiAgRm9yIGV4YW1wbGUsIHRoZSBNUEM4NTQwJ3MKICAgc29jIG5vZGUgd291bGQgYmUgY2FsbGVkICJzb2M4NTQwIi4KIAogICBSZXF1aXJlZCBwcm9wZXJ0aWVzOgogCi0gICAgLSBkZXZpY2VfdHlwZSA6IFNob3VsZCBiZSAic29jIgogICAgIC0gcmFuZ2VzIDogU2hvdWxkIGJlIGRlZmluZWQgYXMgc3BlY2lmaWVkIGluIDEpIHRvIGRlc2NyaWJlIHRoZQotICAgICAgdHJhbnNsYXRpb24gb2YgU09DIGFkZHJlc3NlcyBmb3IgbWVtb3J5IG1hcHBlZCBTT0MgcmVnaXN0ZXJzLgotICAgIC0gYnVzLWZyZXF1ZW5jeTogQ29udGFpbnMgdGhlIGJ1cyBmcmVxdWVuY3kgZm9yIHRoZSBTT0Mgbm9kZS4KKyAgICAgIHRyYW5zbGF0aW9uIG9mIFNvQyBhZGRyZXNzZXMgZm9yIG1lbW9yeSBtYXBwZWQgU29DIHJlZ2lzdGVycy4KKyAgICAtIGJ1cy1mcmVxdWVuY3k6IENvbnRhaW5zIHRoZSBidXMgZnJlcXVlbmN5IGZvciB0aGUgU29DIG5vZGUuCiAgICAgICBUeXBpY2FsbHksIHRoZSB2YWx1ZSBvZiB0aGlzIGZpZWxkIGlzIGZpbGxlZCBpbiBieSB0aGUgYm9vdAogICAgICAgbG9hZGVyLgorICAgIC0gY29tcGF0aWJsZSA6IEV4YWN0IG1vZGVsIG9mIHRoZSBTb0MKIAogCiAgIFJlY29tbWVuZGVkIHByb3BlcnRpZXM6CkBAIC0xMTU1LDEyICsxMTM2LDEzIEBACiAKICAgLSBBbiBleGFtcGxlIG9mIGNvZGUgZm9yIGl0ZXJhdGluZyBub2RlcyAmIHJldHJpZXZpbmcgcHJvcGVydGllcwogICAgIGRpcmVjdGx5IGZyb20gdGhlIGZsYXR0ZW5lZCB0cmVlIGZvcm1hdCBjYW4gYmUgZm91bmQgaW4gdGhlIGtlcm5lbAotICAgIGZpbGUgYXJjaC9wcGM2NC9rZXJuZWwvcHJvbS5jLCBsb29rIGF0IHNjYW5fZmxhdF9kdCgpIGZ1bmN0aW9uLAorICAgIGZpbGUgZHJpdmVycy9vZi9mZHQuYy4gIExvb2sgYXQgdGhlIG9mX3NjYW5fZmxhdF9kdCgpIGZ1bmN0aW9uLAogICAgIGl0cyB1c2FnZSBpbiBlYXJseV9pbml0X2RldnRyZWUoKSwgYW5kIHRoZSBjb3JyZXNwb25kaW5nIHZhcmlvdXMKICAgICBlYXJseV9pbml0X2R0X3NjYW5fKigpIGNhbGxiYWNrcy4gVGhhdCBjb2RlIGNhbiBiZSByZS11c2VkIGluIGEKICAgICBHUEwgYm9vdGxvYWRlciwgYW5kIGFzIHRoZSBhdXRob3Igb2YgdGhhdCBjb2RlLCBJIHdvdWxkIGJlIGhhcHB5CiAgICAgdG8gZGlzY3VzcyBwb3NzaWJsZSBmcmVlIGxpY2Vuc2luZyB0byBhbnkgdmVuZG9yIHdobyB3aXNoZXMgdG8KICAgICBpbnRlZ3JhdGUgYWxsIG9yIHBhcnQgb2YgdGhpcyBjb2RlIGludG8gYSBub24tR1BMIGJvb3Rsb2FkZXIuCisgICAgKHJlZmVyZW5jZSBuZWVkZWQ7IHdobyBpcyAnSScgaGVyZT8gLS0tZ2NsIEphbiAzMSwgMjAxMSkKIAogCiAKQEAgLTEyMDMsMTggKzExODUsMTkgQEAKIDIpIFJlcHJlc2VudGluZyBkZXZpY2VzIHdpdGhvdXQgYSBjdXJyZW50IE9GIHNwZWNpZmljYXRpb24KIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAotQ3VycmVudGx5LCB0aGVyZSBhcmUgbWFueSBkZXZpY2VzIG9uIFNPQ3MgdGhhdCBkbyBub3QgaGF2ZSBhIHN0YW5kYXJkCi1yZXByZXNlbnRhdGlvbiBwcmUtZGVmaW5lZCBhcyBwYXJ0IG9mIHRoZSBvcGVuIGZpcm13YXJlCi1zcGVjaWZpY2F0aW9ucywgbWFpbmx5IGJlY2F1c2UgdGhlIGJvYXJkcyB0aGF0IGNvbnRhaW4gdGhlc2UgU09DcyBhcmUKLW5vdCBjdXJyZW50bHkgYm9vdGVkIHVzaW5nIG9wZW4gZmlybXdhcmUuICAgVGhpcyBzZWN0aW9uIGNvbnRhaW5zCi1kZXNjcmlwdGlvbnMgZm9yIHRoZSBTT0MgZGV2aWNlcyBmb3Igd2hpY2ggbmV3IG5vZGVzIGhhdmUgYmVlbgotZGVmaW5lZDsgdGhpcyBsaXN0IHdpbGwgZXhwYW5kIGFzIG1vcmUgYW5kIG1vcmUgU09DLWNvbnRhaW5pbmcKLXBsYXRmb3JtcyBhcmUgbW92ZWQgb3ZlciB0byB1c2UgdGhlIGZsYXR0ZW5lZC1kZXZpY2UtdHJlZSBtb2RlbC4KK0N1cnJlbnRseSwgdGhlcmUgYXJlIG1hbnkgZGV2aWNlcyBvbiBTb0NzIHRoYXQgZG8gbm90IGhhdmUgYSBzdGFuZGFyZAorcmVwcmVzZW50YXRpb24gZGVmaW5lZCBhcyBwYXJ0IG9mIHRoZSBPcGVuIEZpcm13YXJlIHNwZWNpZmljYXRpb25zLAorbWFpbmx5IGJlY2F1c2UgdGhlIGJvYXJkcyB0aGF0IGNvbnRhaW4gdGhlc2UgU29DcyBhcmUgbm90IGN1cnJlbnRseQorYm9vdGVkIHVzaW5nIE9wZW4gRmlybXdhcmUuICBCaW5kaW5nIGRvY3VtZW50YXRpb24gZm9yIG5ldyBkZXZpY2VzCitzaG91bGQgYmUgYWRkZWQgdG8gdGhlIERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncyBkaXJlY3RvcnkuCitUaGF0IGRpcmVjdG9yeSB3aWxsIGV4cGFuZCBhcyBkZXZpY2UgdHJlZSBzdXBwb3J0IGlzIGFkZGVkIHRvIG1vcmUgYW5kCittb3JlIFNvQ3MuCisKIAogVklJIC0gU3BlY2lmeWluZyBpbnRlcnJ1cHQgaW5mb3JtYXRpb24gZm9yIGRldmljZXMKID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogCi1UaGUgZGV2aWNlIHRyZWUgcmVwcmVzZW50cyB0aGUgYnVzc2VzIGFuZCBkZXZpY2VzIG9mIGEgaGFyZHdhcmUKK1RoZSBkZXZpY2UgdHJlZSByZXByZXNlbnRzIHRoZSBidXNlcyBhbmQgZGV2aWNlcyBvZiBhIGhhcmR3YXJlCiBzeXN0ZW0gaW4gYSBmb3JtIHNpbWlsYXIgdG8gdGhlIHBoeXNpY2FsIGJ1cyB0b3BvbG9neSBvZiB0aGUKIGhhcmR3YXJlLgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2ZlYXR1cmUtcmVtb3ZhbC1zY2hlZHVsZS50eHQgYi9Eb2N1bWVudGF0aW9uL2ZlYXR1cmUtcmVtb3ZhbC1zY2hlZHVsZS50eHQKaW5kZXggNmNiYmQyMC4uYjNmMzVlNSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9mZWF0dXJlLXJlbW92YWwtc2NoZWR1bGUudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZmVhdHVyZS1yZW1vdmFsLXNjaGVkdWxlLnR4dApAQCAtMjQ4LDYgKzI0OCwxNyBAQAogCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAorV2hhdDoJQ09ORklHX0FDUElfUFJPQ0ZTX1BPV0VSCitXaGVuOgkyLjYuMzkKK1doeToJc3lzZnMgSS9GIGZvciBBQ1BJIHBvd2VyIGRldmljZXMsIGluY2x1ZGluZyBBQyBhbmQgQmF0dGVyeSwKKyAgICAgICAgaGFzIGJlZW4gd29ya2luZyBpbiB1cHN0cmVhbSBrZW5yZWwgc2luY2UgMi42LjI0LCBTZXAgMjAwNy4KKwlJbiAyLjYuMzcsIHdlIG1ha2UgdGhlIHN5c2ZzIEkvRiBhbHdheXMgYnVpbHQgaW4gYW5kIHRoaXMgb3B0aW9uCisJZGlzYWJsZWQgYnkgZGVmYXVsdC4KKwlSZW1vdmUgdGhpcyBvcHRpb24gYW5kIHRoZSBBQ1BJIHBvd2VyIHByb2NmcyBpbnRlcmZhY2UgaW4gMi42LjM5LgorV2hvOglaaGFuZyBSdWkgPHJ1aS56aGFuZ0BpbnRlbC5jb20+CisKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCiBXaGF0OgkvcHJvYy9hY3BpL2J1dHRvbgogV2hlbjoJQXVndXN0IDIwMDcKIFdoeToJL3Byb2MvYWNwaS9idXR0b24gaGFzIGJlZW4gcmVwbGFjZWQgYnkgZXZlbnRzIHRvIHRoZSBpbnB1dCBsYXllcgpAQCAtMzQ2LDE0ICszNTcsNiBAQAogCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCi1XaGF0OglfX2RvX0lSUSBhbGwgaW4gb25lIGZpdHMgbm90aGluZyBpbnRlcnJ1cHQgaGFuZGxlcgotV2hlbjoJMi42LjMyCi1XaHk6CV9fZG9fSVJRIHdhcyBrZXB0IGZvciBlYXN5IG1pZ3JhdGlvbiB0byB0aGUgdHlwZSBmbG93IGhhbmRsZXJzLgotCU1vcmUgdGhhbiB0d28geWVhcnMgb2YgbWlncmF0aW9uIHRpbWUgaXMgZW5vdWdoLgotV2hvOglUaG9tYXMgR2xlaXhuZXIgPHRnbHhAbGludXRyb25peC5kZT4KLQotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLQogV2hhdDoJZmFrZXBocCBhbmQgYXNzb2NpYXRlZCBzeXNmcyBmaWxlcyBpbiAvc3lzL2J1cy9wY2kvc2xvdHMvCiBXaGVuOgkyMDExCiBXaHk6CUluIDIuNi4yNywgdGhlIHNlbWFudGljcyBvZiAvc3lzL2J1cy9wY2kvc2xvdHMgd2FzIHJlZGVmaW5lZCB0bwpAQCAtNjAwLDMgKzYwMywxOSBAQAogV2hvOglKZWFuIERlbHZhcmUgPGtoYWxpQGxpbnV4LWZyLm9yZz4KIAogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCitXaGF0Oglub3N3YXBhY2NvdW50IGtlcm5lbCBjb21tYW5kIGxpbmUgcGFyYW1ldGVyCitXaGVuOgkyLjYuNDAKK1doeToJVGhlIG9yaWdpbmFsIGltcGxlbWVudGF0aW9uIG9mIG1lbXN3IGZlYXR1cmUgZW5hYmxlZCBieQorCUNPTkZJR19DR1JPVVBfTUVNX1JFU19DVExSX1NXQVAgY291bGQgYmUgZGlzYWJsZWQgYnkgdGhlIG5vc3dhcGFjY291bnQKKwlrZXJuZWwgcGFyYW1ldGVyIChpbnRyb2R1Y2VkIGluIDIuNi4yOS1yYzEpLiBMYXRlciBvbiwgdGhpcyBkZWNpc2lvbgorCXR1cm5lZCBvdXQgdG8gYmUgbm90IGlkZWFsIGJlY2F1c2Ugd2UgY2Fubm90IGhhdmUgdGhlIGZlYXR1cmUgY29tcGlsZWQKKwlpbiBhbmQgZGlzYWJsZWQgYnkgZGVmYXVsdCBhbmQgbGV0IG9ubHkgaW50ZXJlc3RlZCB0byBlbmFibGUgaXQKKwkoZS5nLiBnZW5lcmFsIGRpc3RyaWJ1dGlvbiBrZXJuZWxzIG1pZ2h0IG5lZWQgaXQpLiBUaGVyZWZvcmUgd2UgaGF2ZQorCWFkZGVkIHN3YXBhY2NvdW50Wz0wfDFdIHBhcmFtZXRlciAoaW50cm9kdWNlZCBpbiAyLjYuMzcpIHdoaWNoIHByb3ZpZGVzCisJdGhlIGJvdGggcG9zc2liaWxpdGllcy4gSWYgd2UgcmVtb3ZlIG5vc3dhcGFjY291bnQgd2Ugd2lsbCBoYXZlCisJbGVzcyBjb21tYW5kIGxpbmUgcGFyYW1ldGVycyB3aXRoIHRoZSBzYW1lIGZ1bmN0aW9uYWxpdHkgYW5kIHdlCisJY2FuIGFsc28gY2xlYW51cCB0aGUgcGFyYW1ldGVyIGhhbmRsaW5nIGEgYml0ICgpLgorV2hvOglNaWNoYWwgSG9ja28gPG1ob2Nrb0BzdXNlLmN6PgorCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL0xvY2tpbmcgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL0xvY2tpbmcKaW5kZXggOTc3ZDg5MS4uNDQ3MWE0MSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9Mb2NraW5nCisrKyBiL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvTG9ja2luZwpAQCAtMTksNiArMTksOCBAQAogCXZvaWQgKCpkX3JlbGVhc2UpKHN0cnVjdCBkZW50cnkgKik7CiAJdm9pZCAoKmRfaXB1dCkoc3RydWN0IGRlbnRyeSAqLCBzdHJ1Y3QgaW5vZGUgKik7CiAJY2hhciAqKCpkX2RuYW1lKSgoc3RydWN0IGRlbnRyeSAqZGVudHJ5LCBjaGFyICpidWZmZXIsIGludCBidWZsZW4pOworCXN0cnVjdCB2ZnNtb3VudCAqKCpkX2F1dG9tb3VudCkoc3RydWN0IHBhdGggKnBhdGgpOworCWludCAoKmRfbWFuYWdlKShzdHJ1Y3QgZGVudHJ5ICosIGJvb2wpOwogCiBsb2NraW5nIHJ1bGVzOgogCQlyZW5hbWVfbG9jawktPmRfbG9jawltYXkgYmxvY2sJcmN1LXdhbGsKQEAgLTI5LDYgKzMxLDggQEAKIGRfcmVsZWFzZToJbm8JCW5vCQl5ZXMJCW5vCiBkX2lwdXQ6CQlubwkJbm8JCXllcwkJbm8KIGRfZG5hbWU6CW5vCQlubwkJbm8JCW5vCitkX2F1dG9tb3VudDoJbm8JCW5vCQl5ZXMJCW5vCitkX21hbmFnZToJbm8JCW5vCQl5ZXMgKHJlZi13YWxrKQltYXliZQogCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gaW5vZGVfb3BlcmF0aW9ucyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gCiBwcm90b3R5cGVzOgpAQCAtNTYsNyArNjAsNiBAQAogCXNzaXplX3QgKCpsaXN0eGF0dHIpIChzdHJ1Y3QgZGVudHJ5ICosIGNoYXIgKiwgc2l6ZV90KTsKIAlpbnQgKCpyZW1vdmV4YXR0cikgKHN0cnVjdCBkZW50cnkgKiwgY29uc3QgY2hhciAqKTsKIAl2b2lkICgqdHJ1bmNhdGVfcmFuZ2UpKHN0cnVjdCBpbm9kZSAqLCBsb2ZmX3QsIGxvZmZfdCk7Ci0JbG9uZyAoKmZhbGxvY2F0ZSkoc3RydWN0IGlub2RlICppbm9kZSwgaW50IG1vZGUsIGxvZmZfdCBvZmZzZXQsIGxvZmZfdCBsZW4pOwogCWludCAoKmZpZW1hcCkoc3RydWN0IGlub2RlICosIHN0cnVjdCBmaWVtYXBfZXh0ZW50X2luZm8gKiwgdTY0IHN0YXJ0LCB1NjQgbGVuKTsKIAogbG9ja2luZyBydWxlczoKQEAgLTg0LDcgKzg3LDYgQEAKIGxpc3R4YXR0cjoJbm8KIHJlbW92ZXhhdHRyOgl5ZXMKIHRydW5jYXRlX3JhbmdlOgl5ZXMKLWZhbGxvY2F0ZToJbm8KIGZpZW1hcDoJCW5vCiAJQWRkaXRpb25hbGx5LCAtPnJtZGlyKCksIC0+dW5saW5rKCkgYW5kIC0+cmVuYW1lKCkgaGF2ZSAtPmlfbXV0ZXggb24KIHZpY3RpbS4KQEAgLTM0Myw3ICszNDUsNiBAQAogCWludCAoKmZsX2dyYW50KShzdHJ1Y3QgZmlsZV9sb2NrICosIHN0cnVjdCBmaWxlX2xvY2sgKiwgaW50KTsKIAl2b2lkICgqZmxfcmVsZWFzZV9wcml2YXRlKShzdHJ1Y3QgZmlsZV9sb2NrICopOwogCXZvaWQgKCpmbF9icmVhaykoc3RydWN0IGZpbGVfbG9jayAqKTsgLyogYnJlYWtfbGVhc2UgY2FsbGJhY2sgKi8KLQlpbnQgKCpmbF9teWxlYXNlKShzdHJ1Y3QgZmlsZV9sb2NrICosIHN0cnVjdCBmaWxlX2xvY2sgKik7CiAJaW50ICgqZmxfY2hhbmdlKShzdHJ1Y3QgZmlsZV9sb2NrICoqLCBpbnQpOwogCiBsb2NraW5nIHJ1bGVzOgpAQCAtMzUzLDcgKzM1NCw2IEBACiBmbF9ncmFudDoJCW5vCQlubwogZmxfcmVsZWFzZV9wcml2YXRlOgltYXliZQkJbm8KIGZsX2JyZWFrOgkJeWVzCQlubwotZmxfbXlsZWFzZToJCXllcwkJbm8KIGZsX2NoYW5nZQkJeWVzCQlubwogCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gYnVmZmVyX2hlYWQgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KQEAgLTQzNSw2ICs0MzUsNyBAQAogCXNzaXplX3QgKCpzcGxpY2VfcmVhZCkoc3RydWN0IGZpbGUgKiwgbG9mZl90ICosIHN0cnVjdCBwaXBlX2lub2RlX2luZm8gKiwKIAkJCXNpemVfdCwgdW5zaWduZWQgaW50KTsKIAlpbnQgKCpzZXRsZWFzZSkoc3RydWN0IGZpbGUgKiwgbG9uZywgc3RydWN0IGZpbGVfbG9jayAqKik7CisJbG9uZyAoKmZhbGxvY2F0ZSkoc3RydWN0IGZpbGUgKiwgaW50LCBsb2ZmX3QsIGxvZmZfdCk7CiB9OwogCiBsb2NraW5nIHJ1bGVzOgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9udGZzLnR4dCBiL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvbnRmcy50eHQKaW5kZXggNmVmOGNmMy4uOTMzYmM2NiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9udGZzLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL250ZnMudHh0CkBAIC00NjAsNiArNDYwLDggQEAKIDIuMS4zMDoKIAktIEZpeCB3cml0ZXYoKSAoaXQga2VwdCB3cml0aW5nIHRoZSBmaXJzdCBzZWdtZW50IG92ZXIgYW5kIG92ZXIgYWdhaW4KIAkgIGluc3RlYWQgb2YgbW92aW5nIG9udG8gc3Vic2VxdWVudCBzZWdtZW50cykuCisJLSBGaXggY3Jhc2ggaW4gbnRmc19tZnRfcmVjb3JkX2FsbG9jKCkgd2hlbiBtYXBwaW5nIHRoZSBuZXcgZXh0ZW50IG1mdAorCSAgcmVjb3JkIGZhaWxlZC4KIDIuMS4yOToKIAktIEZpeCBhIGRlYWRsb2NrIHdoZW4gbW91bnRpbmcgcmVhZC13cml0ZS4KIDIuMS4yODoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvcG9ydGluZyBiL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvcG9ydGluZwppbmRleCAyNjZkMjA1Li5kZmJjZDFiIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3BvcnRpbmcKKysrIGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9wb3J0aW5nCkBAIC0zNjUsOCArMzY1LDggQEAKIFtyZWNvbW1lbmRlZF0KIAl2ZnMgbm93IHRyaWVzIHRvIGRvIHBhdGggd2Fsa2luZyBpbiAicmN1LXdhbGsgbW9kZSIsIHdoaWNoIGF2b2lkcwogYXRvbWljIG9wZXJhdGlvbnMgYW5kIHNjYWxhYmlsaXR5IGhhemFyZHMgb24gZGVudHJpZXMgYW5kIGlub2RlcyAoc2VlCi1Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3BhdGgtd2Fsay50eHQpLiBkX2hhc2ggYW5kIGRfY29tcGFyZSBjaGFuZ2VzIChhYm92ZSkKLWFyZSBleGFtcGxlcyBvZiB0aGUgY2hhbmdlcyByZXF1aXJlZCB0byBzdXBwb3J0IHRoaXMuIEZvciBtb3JlIGNvbXBsZXgKK0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvcGF0aC1sb29rdXAudHh0KS4gZF9oYXNoIGFuZCBkX2NvbXBhcmUgY2hhbmdlcworKGFib3ZlKSBhcmUgZXhhbXBsZXMgb2YgdGhlIGNoYW5nZXMgcmVxdWlyZWQgdG8gc3VwcG9ydCB0aGlzLiBGb3IgbW9yZSBjb21wbGV4CiBmaWxlc3lzdGVtIGNhbGxiYWNrcywgdGhlIHZmcyBkcm9wcyBvdXQgb2YgcmN1LXdhbGsgbW9kZSBiZWZvcmUgdGhlIGZzIGNhbGwsIHNvCiBubyBjaGFuZ2VzIGFyZSByZXF1aXJlZCB0byB0aGUgZmlsZXN5c3RlbS4gSG93ZXZlciwgdGhpcyBpcyBjb3N0bHkgYW5kIGxvc2VzCiB0aGUgYmVuZWZpdHMgb2YgcmN1LXdhbGsgbW9kZS4gV2Ugd2lsbCBiZWdpbiB0byBhZGQgZmlsZXN5c3RlbSBjYWxsYmFja3MgdGhhdApAQCAtMzgzLDggKzM4Myw4IEBACiAKIAlwZXJtaXNzaW9uIGFuZCBjaGVja19hY2wgYXJlIGlub2RlIHBlcm1pc3Npb24gY2hlY2tzIHRoYXQgYXJlIGNhbGxlZAogb24gbWFueSBvciBhbGwgZGlyZWN0b3J5IGlub2RlcyBvbiB0aGUgd2F5IGRvd24gYSBwYXRoIHdhbGsgKHRvIGNoZWNrIGZvcgotZXhlYyBwZXJtaXNzaW9uKS4gVGhlc2UgbXVzdCBub3cgYmUgcmN1LXdhbGsgYXdhcmUgKGZsYWdzICYgSVBFUk1fUkNVKS4gU2VlCi1Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3Zmcy50eHQgZm9yIG1vcmUgZGV0YWlscy4KK2V4ZWMgcGVybWlzc2lvbikuIFRoZXNlIG11c3Qgbm93IGJlIHJjdS13YWxrIGF3YXJlIChmbGFncyAmIElQRVJNX0ZMQUdfUkNVKS4KK1NlZSBEb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3Zmcy50eHQgZm9yIG1vcmUgZGV0YWlscy4KICAKIC0tCiBbbWFuZGF0b3J5XQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9wcm9jLnR4dCBiL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvcHJvYy50eHQKaW5kZXggOTQ3MTIyNS4uMjNjYWU2NSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9wcm9jLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3Byb2MudHh0CkBAIC0zNzUsNiArMzc1LDcgQEAKIFN3YXA6ICAgICAgICAgICAgICAgICAgMCBrQgogS2VybmVsUGFnZVNpemU6ICAgICAgICA0IGtCCiBNTVVQYWdlU2l6ZTogICAgICAgICAgIDQga0IKK0xvY2tlZDogICAgICAgICAgICAgIDM3NCBrQgogCiBUaGUgZmlyc3Qgb2YgdGhlc2UgbGluZXMgc2hvd3MgdGhlIHNhbWUgaW5mb3JtYXRpb24gYXMgaXMgZGlzcGxheWVkIGZvciB0aGUKIG1hcHBpbmcgaW4gL3Byb2MvUElEL21hcHMuICBUaGUgcmVtYWluaW5nIGxpbmVzIHNob3cgdGhlIHNpemUgb2YgdGhlIG1hcHBpbmcKQEAgLTY3MCw2ICs2NzEsOCBAQAogCiA+IGNhdCAvcHJvYy9tZW1pbmZvCiAKK1RoZSAiTG9ja2VkIiBpbmRpY2F0ZXMgd2hldGhlciB0aGUgbWFwcGluZyBpcyBsb2NrZWQgaW4gbWVtb3J5IG9yIG5vdC4KKwogCiBNZW1Ub3RhbDogICAgIDE2MzQ0OTcyIGtCCiBNZW1GcmVlOiAgICAgIDEzNjM0MDY0IGtCCkBAIC0xMzIwLDYgKzEzMjMsMTAgQEAKIFdyaXRpbmcgdG8gL3Byb2MvPHBpZD4vb29tX3Njb3JlX2FkaiBvciAvcHJvYy88cGlkPi9vb21fYWRqIHdpbGwgY2hhbmdlIHRoZQogb3RoZXIgd2l0aCBpdHMgc2NhbGVkIHZhbHVlLgogCitUaGUgdmFsdWUgb2YgL3Byb2MvPHBpZD4vb29tX3Njb3JlX2FkaiBtYXkgYmUgcmVkdWNlZCBubyBsb3dlciB0aGFuIHRoZSBsYXN0Cit2YWx1ZSBzZXQgYnkgYSBDQVBfU1lTX1JFU09VUkNFIHByb2Nlc3MuIFRvIHJlZHVjZSB0aGUgdmFsdWUgYW55IGxvd2VyCityZXF1aXJlcyBDQVBfU1lTX1JFU09VUkNFLgorCiBOT1RJQ0U6IC9wcm9jLzxwaWQ+L29vbV9hZGogaXMgZGVwcmVjYXRlZCBhbmQgd2lsbCBiZSByZW1vdmVkLCBwbGVhc2Ugc2VlCiBEb2N1bWVudGF0aW9uL2ZlYXR1cmUtcmVtb3ZhbC1zY2hlZHVsZS50eHQuCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvdmZzLnR4dCBiL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvdmZzLnR4dAppbmRleCBmYmIzMjRlLi45NGNmOTdiIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3Zmcy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy92ZnMudHh0CkBAIC00MTUsOCArNDE1LDggQEAKICAgcGVybWlzc2lvbjogY2FsbGVkIGJ5IHRoZSBWRlMgdG8gY2hlY2sgZm9yIGFjY2VzcyByaWdodHMgb24gYSBQT1NJWC1saWtlCiAgIAlmaWxlc3lzdGVtLgogCi0JTWF5IGJlIGNhbGxlZCBpbiByY3Utd2FsayBtb2RlIChmbGFncyAmIElQRVJNX1JDVSkuIElmIGluIHJjdS13YWxrCi0JbW9kZSwgdGhlIGZpbGVzeXN0ZW0gbXVzdCBjaGVjayB0aGUgcGVybWlzc2lvbiB3aXRob3V0IGJsb2NraW5nIG9yCisJTWF5IGJlIGNhbGxlZCBpbiByY3Utd2FsayBtb2RlIChmbGFncyAmIElQRVJNX0ZMQUdfUkNVKS4gSWYgaW4gcmN1LXdhbGsKKyAgICAgICAgbW9kZSwgdGhlIGZpbGVzeXN0ZW0gbXVzdCBjaGVjayB0aGUgcGVybWlzc2lvbiB3aXRob3V0IGJsb2NraW5nIG9yCiAJc3RvcmluZyB0byB0aGUgaW5vZGUuCiAKIAlJZiBhIHNpdHVhdGlvbiBpcyBlbmNvdW50ZXJlZCB0aGF0IHJjdS13YWxrIGNhbm5vdCBoYW5kbGUsIHJldHVybgpAQCAtODY0LDYgKzg2NCw4IEBACiAJdm9pZCAoKmRfcmVsZWFzZSkoc3RydWN0IGRlbnRyeSAqKTsKIAl2b2lkICgqZF9pcHV0KShzdHJ1Y3QgZGVudHJ5ICosIHN0cnVjdCBpbm9kZSAqKTsKIAljaGFyICooKmRfZG5hbWUpKHN0cnVjdCBkZW50cnkgKiwgY2hhciAqLCBpbnQpOworCXN0cnVjdCB2ZnNtb3VudCAqKCpkX2F1dG9tb3VudCkoc3RydWN0IHBhdGggKik7CisJaW50ICgqZF9tYW5hZ2UpKHN0cnVjdCBkZW50cnkgKiwgYm9vbCwgYm9vbCk7CiB9OwogCiAgIGRfcmV2YWxpZGF0ZTogY2FsbGVkIHdoZW4gdGhlIFZGUyBuZWVkcyB0byByZXZhbGlkYXRlIGEgZGVudHJ5LiBUaGlzCkBAIC05MzAsNiArOTMyLDQ3IEBACiAJYXQgdGhlIGVuZCBvZiB0aGUgYnVmZmVyLCBhbmQgcmV0dXJucyBhIHBvaW50ZXIgdG8gdGhlIGZpcnN0IGNoYXIuCiAJZHluYW1pY19kbmFtZSgpIGhlbHBlciBmdW5jdGlvbiBpcyBwcm92aWRlZCB0byB0YWtlIGNhcmUgb2YgdGhpcy4KIAorICBkX2F1dG9tb3VudDogY2FsbGVkIHdoZW4gYW4gYXV0b21vdW50IGRlbnRyeSBpcyB0byBiZSB0cmF2ZXJzZWQgKG9wdGlvbmFsKS4KKwlUaGlzIHNob3VsZCBjcmVhdGUgYSBuZXcgVkZTIG1vdW50IHJlY29yZCBhbmQgcmV0dXJuIHRoZSByZWNvcmQgdG8gdGhlCisJY2FsbGVyLiAgVGhlIGNhbGxlciBpcyBzdXBwbGllZCB3aXRoIGEgcGF0aCBwYXJhbWV0ZXIgZ2l2aW5nIHRoZQorCWF1dG9tb3VudCBkaXJlY3RvcnkgdG8gZGVzY3JpYmUgdGhlIGF1dG9tb3VudCB0YXJnZXQgYW5kIHRoZSBwYXJlbnQKKwlWRlMgbW91bnQgcmVjb3JkIHRvIHByb3ZpZGUgaW5oZXJpdGFibGUgbW91bnQgcGFyYW1ldGVycy4gIE5VTEwgc2hvdWxkCisJYmUgcmV0dXJuZWQgaWYgc29tZW9uZSBlbHNlIG1hbmFnZWQgdG8gbWFrZSB0aGUgYXV0b21vdW50IGZpcnN0LiAgSWYKKwl0aGUgdmZzbW91bnQgY3JlYXRpb24gZmFpbGVkLCB0aGVuIGFuIGVycm9yIGNvZGUgc2hvdWxkIGJlIHJldHVybmVkLgorCUlmIC1FSVNESVIgaXMgcmV0dXJuZWQsIHRoZW4gdGhlIGRpcmVjdG9yeSB3aWxsIGJlIHRyZWF0ZWQgYXMgYW4KKwlvcmRpbmFyeSBkaXJlY3RvcnkgYW5kIHJldHVybmVkIHRvIHBhdGh3YWxrIHRvIGNvbnRpbnVlIHdhbGtpbmcuCisKKwlJZiBhIHZmc21vdW50IGlzIHJldHVybmVkLCB0aGUgY2FsbGVyIHdpbGwgYXR0ZW1wdCB0byBtb3VudCBpdCBvbiB0aGUKKwltb3VudHBvaW50IGFuZCB3aWxsIHJlbW92ZSB0aGUgdmZzbW91bnQgZnJvbSBpdHMgZXhwaXJhdGlvbiBsaXN0IGluCisJdGhlIGNhc2Ugb2YgZmFpbHVyZS4gIFRoZSB2ZnNtb3VudCBzaG91bGQgYmUgcmV0dXJuZWQgd2l0aCAyIHJlZnMgb24KKwlpdCB0byBwcmV2ZW50IGF1dG9tYXRpYyBleHBpcmF0aW9uIC0gdGhlIGNhbGxlciB3aWxsIGNsZWFuIHVwIHRoZQorCWFkZGl0aW9uYWwgcmVmLgorCisJVGhpcyBmdW5jdGlvbiBpcyBvbmx5IHVzZWQgaWYgRENBQ0hFX05FRURfQVVUT01PVU5UIGlzIHNldCBvbiB0aGUKKwlkZW50cnkuICBUaGlzIGlzIHNldCBieSBfX2RfaW5zdGFudGlhdGUoKSBpZiBTX0FVVE9NT1VOVCBpcyBzZXQgb24gdGhlCisJaW5vZGUgYmVpbmcgYWRkZWQuCisKKyAgZF9tYW5hZ2U6IGNhbGxlZCB0byBhbGxvdyB0aGUgZmlsZXN5c3RlbSB0byBtYW5hZ2UgdGhlIHRyYW5zaXRpb24gZnJvbSBhCisJZGVudHJ5IChvcHRpb25hbCkuICBUaGlzIGFsbG93cyBhdXRvZnMsIGZvciBleGFtcGxlLCB0byBob2xkIHVwIGNsaWVudHMKKwl3YWl0aW5nIHRvIGV4cGxvcmUgYmVoaW5kIGEgJ21vdW50cG9pbnQnIHdoaWxzdCBsZXR0aW5nIHRoZSBkYWVtb24gZ28KKwlwYXN0IGFuZCBjb25zdHJ1Y3QgdGhlIHN1YnRyZWUgdGhlcmUuICAwIHNob3VsZCBiZSByZXR1cm5lZCB0byBsZXQgdGhlCisJY2FsbGluZyBwcm9jZXNzIGNvbnRpbnVlLiAgLUVJU0RJUiBjYW4gYmUgcmV0dXJuZWQgdG8gdGVsbCBwYXRod2FsayB0bworCXVzZSB0aGlzIGRpcmVjdG9yeSBhcyBhbiBvcmRpbmFyeSBkaXJlY3RvcnkgYW5kIHRvIGlnbm9yZSBhbnl0aGluZworCW1vdW50ZWQgb24gaXQgYW5kIG5vdCB0byBjaGVjayB0aGUgYXV0b21vdW50IGZsYWcuICBBbnkgb3RoZXIgZXJyb3IKKwljb2RlIHdpbGwgYWJvcnQgcGF0aHdhbGsgY29tcGxldGVseS4KKworCUlmIHRoZSAnbW91bnRpbmdfaGVyZScgcGFyYW1ldGVyIGlzIHRydWUsIHRoZW4gbmFtZXNwYWNlX3NlbSBpcyBiZWluZworCWhlbGQgYnkgdGhlIGNhbGxlciBhbmQgdGhlIGZ1bmN0aW9uIHNob3VsZCBub3QgaW5pdGlhdGUgYW55IG1vdW50cyBvcgorCXVubW91bnRzIHRoYXQgaXQgd2lsbCB0aGVuIHdhaXQgZm9yLgorCisJSWYgdGhlICdyY3Vfd2FsaycgcGFyYW1ldGVyIGlzIHRydWUsIHRoZW4gdGhlIGNhbGxlciBpcyBkb2luZyBhCisJcGF0aHdhbGsgaW4gUkNVLXdhbGsgbW9kZS4gIFNsZWVwaW5nIGlzIG5vdCBwZXJtaXR0ZWQgaW4gdGhpcyBtb2RlLAorCWFuZCB0aGUgY2FsbGVyIGNhbiBiZSBhc2tlZCB0byBsZWF2ZSBpdCBhbmQgY2FsbCBhZ2FpbiBieSByZXR1cmluZworCS1FQ0hJTEQuCisKKwlUaGlzIGZ1bmN0aW9uIGlzIG9ubHkgdXNlZCBpZiBEQ0FDSEVfTUFOQUdFX1RSQU5TSVQgaXMgc2V0IG9uIHRoZQorCWRlbnRyeSBiZWluZyB0cmFuc2l0ZWQgZnJvbS4KKwogRXhhbXBsZSA6CiAKIHN0YXRpYyBjaGFyICpwaXBlZnNfZG5hbWUoc3RydWN0IGRlbnRyeSAqZGVudCwgY2hhciAqYnVmZmVyLCBpbnQgYnVmbGVuKQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9ncGlvLnR4dCBiL0RvY3VtZW50YXRpb24vZ3Bpby50eHQKaW5kZXggYTQ5MmQ5Mi4uNzkyZmFhMyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9ncGlvLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dwaW8udHh0CkBAIC0xMzUsNyArMTM1LDcgQEAKIAlpbnQgZ3Bpb19kaXJlY3Rpb25faW5wdXQodW5zaWduZWQgZ3Bpbyk7CiAJaW50IGdwaW9fZGlyZWN0aW9uX291dHB1dCh1bnNpZ25lZCBncGlvLCBpbnQgdmFsdWUpOwogCi1UaGUgcmV0dXJuIHZhbHVlIGlzIHplcm8gZm9yIHN1Y2Nlc3MsIGVsc2UgYSBuZWdhdGl2ZSBlcnJuby4gIEl0IG11c3QKK1RoZSByZXR1cm4gdmFsdWUgaXMgemVybyBmb3Igc3VjY2VzcywgZWxzZSBhIG5lZ2F0aXZlIGVycm5vLiAgSXQgc2hvdWxkCiBiZSBjaGVja2VkLCBzaW5jZSB0aGUgZ2V0L3NldCBjYWxscyBkb24ndCBoYXZlIGVycm9yIHJldHVybnMgYW5kIHNpbmNlCiBtaXNjb25maWd1cmF0aW9uIGlzIHBvc3NpYmxlLiAgWW91IHNob3VsZCBub3JtYWxseSBpc3N1ZSB0aGVzZSBjYWxscyBmcm9tCiBhIHRhc2sgY29udGV4dC4gIEhvd2V2ZXIsIGZvciBzcGlubG9jay1zYWZlIEdQSU9zIGl0J3MgT0sgdG8gdXNlIHRoZW0KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaHdtb24vbG05MyBiL0RvY3VtZW50YXRpb24vaHdtb24vbG05MwppbmRleCA3YTEwNjE2Li5mM2IyYWQyIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2h3bW9uL2xtOTMKKysrIGIvRG9jdW1lbnRhdGlvbi9od21vbi9sbTkzCkBAIC02LDYgKzYsMTAgQEAKICAgICBQcmVmaXggJ2xtOTMnCiAgICAgQWRkcmVzc2VzIHNjYW5uZWQ6IEkyQyAweDJjLTB4MmUKICAgICBEYXRhc2hlZXQ6IGh0dHA6Ly93d3cubmF0aW9uYWwuY29tL2RzLmNnaS9MTS9MTTkzLnBkZgorICAqIE5hdGlvbmFsIFNlbWljb25kdWN0b3IgTE05NAorICAgIFByZWZpeCAnbG05NCcKKyAgICBBZGRyZXNzZXMgc2Nhbm5lZDogSTJDIDB4MmMtMHgyZQorICAgIERhdGFzaGVldDogaHR0cDovL3d3dy5uYXRpb25hbC5jb20vZHMuY2dpL0xNL0xNOTQucGRmCiAKIEF1dGhvcnM6CiAJTWFyayBNLiBIb2ZmbWFuIDxtaG9mZm1hbkBsaWdodGxpbmsuY29tPgpAQCAtNTYsNiArNjAsOSBAQAogZm9yIGR5bmFtaWMgVmNjcCBtb25pdG9yaW5nIGFuZCBQUk9DSE9ULiBJdCBpcyBkZXNpZ25lZCB0byBtb25pdG9yIGEgZHVhbAogcHJvY2Vzc29yIFhlb24gY2xhc3MgbW90aGVyYm9hcmQgd2l0aCBhIG1pbmltdW0gb2YgZXh0ZXJuYWwgY29tcG9uZW50cy4KIAorTE05NCBpcyBhbHNvIHN1cHBvcnRlZCBpbiBMTTkzIGNvbXBhdGlibGUgbW9kZS4gRXh0cmEgc2Vuc29ycyBhbmQgZmVhdHVyZXMgb2YKK0xNOTQgYXJlIG5vdCBzdXBwb3J0ZWQuCisKIAogVXNlciBJbnRlcmZhY2UKIC0tLS0tLS0tLS0tLS0tCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2tlcm5lbC1wYXJhbWV0ZXJzLnR4dCBiL0RvY3VtZW50YXRpb24va2VybmVsLXBhcmFtZXRlcnMudHh0CmluZGV4IDU1ZmU3NTkuLjg5ODM1YTQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24va2VybmVsLXBhcmFtZXRlcnMudHh0CisrKyBiL0RvY3VtZW50YXRpb24va2VybmVsLXBhcmFtZXRlcnMudHh0CkBAIC00MywxMSArNDMsMTEgQEAKIAlBVlIzMglBVlIzMiBhcmNoaXRlY3R1cmUgaXMgZW5hYmxlZC4KIAlBWDI1CUFwcHJvcHJpYXRlIEFYLjI1IHN1cHBvcnQgaXMgZW5hYmxlZC4KIAlCTEFDS0ZJTiBCbGFja2ZpbiBhcmNoaXRlY3R1cmUgaXMgZW5hYmxlZC4KKwlEUk0JRGlyZWN0IFJlbmRlcmluZyBNYW5hZ2VtZW50IHN1cHBvcnQgaXMgZW5hYmxlZC4KKwlEWU5BTUlDX0RFQlVHIEJ1aWxkIGluIGRlYnVnIG1lc3NhZ2VzIGFuZCBlbmFibGUgdGhlbSBhdCBydW50aW1lCiAJRURECUJJT1MgRW5oYW5jZWQgRGlzayBEcml2ZSBTZXJ2aWNlcyAoRUREKSBpcyBlbmFibGVkCiAJRUZJCUVGSSBQYXJ0aXRpb25pbmcgKEdQVCkgaXMgZW5hYmxlZAogCUVJREUJRUlERS9BVEFQSSBzdXBwb3J0IGlzIGVuYWJsZWQuCi0JRFJNCURpcmVjdCBSZW5kZXJpbmcgTWFuYWdlbWVudCBzdXBwb3J0IGlzIGVuYWJsZWQuCi0JRFlOQU1JQ19ERUJVRyBCdWlsZCBpbiBkZWJ1ZyBtZXNzYWdlcyBhbmQgZW5hYmxlIHRoZW0gYXQgcnVudGltZQogCUZCCVRoZSBmcmFtZSBidWZmZXIgZGV2aWNlIGlzIGVuYWJsZWQuCiAJR0NPVglHQ09WIHByb2ZpbGluZyBpcyBlbmFibGVkLgogCUhXCUFwcHJvcHJpYXRlIGhhcmR3YXJlIGlzIGVuYWJsZWQuCkBAIC0xOTksMTEgKzE5OSw2IEBACiAJCQl1bnVzYWJsZS4gIFRoZSAibG9nX2J1Zl9sZW4iIHBhcmFtZXRlciBtYXkgYmUgdXNlZnVsCiAJCQlpZiB5b3UgbmVlZCB0byBjYXB0dXJlIG1vcmUgb3V0cHV0LgogCi0JYWNwaV9kaXNwbGF5X291dHB1dD0JW0hXLEFDUEldCi0JCQlhY3BpX2Rpc3BsYXlfb3V0cHV0PXZlbmRvcgotCQkJYWNwaV9kaXNwbGF5X291dHB1dD12aWRlbwotCQkJU2VlIGFib3ZlLgotCiAJYWNwaV9pcnFfYmFsYW5jZSBbSFcsQUNQSV0KIAkJCUFDUEkgd2lsbCBiYWxhbmNlIGFjdGl2ZSBJUlFzCiAJCQlkZWZhdWx0IGluIEFQSUMgbW9kZQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9sZ3Vlc3QvbGd1ZXN0LmMgYi9Eb2N1bWVudGF0aW9uL2xndWVzdC9sZ3Vlc3QuYwppbmRleCBkYzczYmM1NC4uZDlkYTdlMSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9sZ3Vlc3QvbGd1ZXN0LmMKKysrIGIvRG9jdW1lbnRhdGlvbi9sZ3Vlc3QvbGd1ZXN0LmMKQEAgLTM5LDYgKzM5LDkgQEAKICNpbmNsdWRlIDxsaW1pdHMuaD4KICNpbmNsdWRlIDxzdGRkZWYuaD4KICNpbmNsdWRlIDxzaWduYWwuaD4KKyNpbmNsdWRlIDxwd2QuaD4KKyNpbmNsdWRlIDxncnAuaD4KKwogI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19jb25maWcuaD4KICNpbmNsdWRlIDxsaW51eC92aXJ0aW9fbmV0Lmg+CiAjaW5jbHVkZSA8bGludXgvdmlydGlvX2Jsay5oPgpAQCAtMjk4LDIwICszMDEsMjcgQEAKIAogCS8qCiAJICogV2UgdXNlIGEgcHJpdmF0ZSBtYXBwaW5nIChpZS4gaWYgd2Ugd3JpdGUgdG8gdGhlIHBhZ2UsIGl0IHdpbGwgYmUKLQkgKiBjb3BpZWQpLgorCSAqIGNvcGllZCkuIFdlIGFsbG9jYXRlIGFuIGV4dHJhIHR3byBwYWdlcyBQUk9UX05PTkUgdG8gYWN0IGFzIGd1YXJkCisJICogcGFnZXMgYWdhaW5zdCByZWFkL3dyaXRlIGF0dGVtcHRzIHRoYXQgZXhjZWVkIGFsbG9jYXRlZCBzcGFjZS4KIAkgKi8KLQlhZGRyID0gbW1hcChOVUxMLCBnZXRwYWdlc2l6ZSgpICogbnVtLAotCQkgICAgUFJPVF9SRUFEfFBST1RfV1JJVEV8UFJPVF9FWEVDLCBNQVBfUFJJVkFURSwgZmQsIDApOworCWFkZHIgPSBtbWFwKE5VTEwsIGdldHBhZ2VzaXplKCkgKiAobnVtKzIpLAorCQkgICAgUFJPVF9OT05FLCBNQVBfUFJJVkFURSwgZmQsIDApOworCiAJaWYgKGFkZHIgPT0gTUFQX0ZBSUxFRCkKIAkJZXJyKDEsICJNbWFwcGluZyAldSBwYWdlcyBvZiAvZGV2L3plcm8iLCBudW0pOwogCisJaWYgKG1wcm90ZWN0KGFkZHIgKyBnZXRwYWdlc2l6ZSgpLCBnZXRwYWdlc2l6ZSgpICogbnVtLAorCQkgICAgIFBST1RfUkVBRHxQUk9UX1dSSVRFKSA9PSAtMSkKKwkJZXJyKDEsICJtcHJvdGVjdCBydyAldSBwYWdlcyBmYWlsZWQiLCBudW0pOworCiAJLyoKIAkgKiBPbmUgbmVhdCBtbWFwIGZlYXR1cmUgaXMgdGhhdCB5b3UgY2FuIGNsb3NlIHRoZSBmZCwgYW5kIGl0CiAJICogc3RheXMgbWFwcGVkLgogCSAqLwogCWNsb3NlKGZkKTsKIAotCXJldHVybiBhZGRyOworCS8qIFJldHVybiBhZGRyZXNzIGFmdGVyIFBST1RfTk9ORSBwYWdlICovCisJcmV0dXJuIGFkZHIgKyBnZXRwYWdlc2l6ZSgpOwogfQogCiAvKiBHZXQgc29tZSBtb3JlIHBhZ2VzIGZvciBhIGRldmljZS4gKi8KQEAgLTM0Myw3ICszNTMsNyBAQAogCSAqIGRvbmUgdG8gaXQuICBUaGlzIGFsbG93cyB1cyB0byBzaGFyZSB1bnRvdWNoZWQgbWVtb3J5IGJldHdlZW4KIAkgKiBHdWVzdHMuCiAJICovCi0JaWYgKG1tYXAoYWRkciwgbGVuLCBQUk9UX1JFQUR8UFJPVF9XUklURXxQUk9UX0VYRUMsCisJaWYgKG1tYXAoYWRkciwgbGVuLCBQUk9UX1JFQUR8UFJPVF9XUklURSwKIAkJIE1BUF9GSVhFRHxNQVBfUFJJVkFURSwgZmQsIG9mZnNldCkgIT0gTUFQX0ZBSUxFRCkKIAkJcmV0dXJuOwogCkBAIC01NzMsMTAgKzU4MywxMCBAQAogCQkJICAgIHVuc2lnbmVkIGludCBsaW5lKQogewogCS8qCi0JICogV2UgaGF2ZSB0byBzZXBhcmF0ZWx5IGNoZWNrIGFkZHIgYW5kIGFkZHIrc2l6ZSwgYmVjYXVzZSBzaXplIGNvdWxkCi0JICogYmUgaHVnZSBhbmQgYWRkciArIHNpemUgbWlnaHQgd3JhcCBhcm91bmQuCisJICogQ2hlY2sgaWYgdGhlIHJlcXVlc3RlZCBhZGRyZXNzIGFuZCBzaXplIGV4Y2VlZHMgdGhlIGFsbG9jYXRlZCBtZW1vcnksCisJICogb3IgYWRkciArIHNpemUgd3JhcHMgYXJvdW5kLgogCSAqLwotCWlmIChhZGRyID49IGd1ZXN0X2xpbWl0IHx8IGFkZHIgKyBzaXplID49IGd1ZXN0X2xpbWl0KQorCWlmICgoYWRkciArIHNpemUpID4gZ3Vlc3RfbGltaXQgfHwgKGFkZHIgKyBzaXplKSA8IGFkZHIpCiAJCWVycngoMSwgIiVzOiVpOiBJbnZhbGlkIGFkZHJlc3MgJSNseCIsIF9fRklMRV9fLCBsaW5lLCBhZGRyKTsKIAkvKgogCSAqIFdlIHJldHVybiBhIHBvaW50ZXIgZm9yIHRoZSBjYWxsZXIncyBjb252ZW5pZW5jZSwgbm93IHdlIGtub3cgaXQncwpAQCAtMTg3Miw2ICsxODgyLDggQEAKIAl7ICJibG9jayIsIDEsIE5VTEwsICdiJyB9LAogCXsgInJuZyIsIDAsIE5VTEwsICdyJyB9LAogCXsgImluaXRyZCIsIDEsIE5VTEwsICdpJyB9LAorCXsgInVzZXJuYW1lIiwgMSwgTlVMTCwgJ3UnIH0sCisJeyAiY2hyb290IiwgMSwgTlVMTCwgJ2MnIH0sCiAJeyBOVUxMIH0sCiB9Owogc3RhdGljIHZvaWQgdXNhZ2Uodm9pZCkKQEAgLTE4OTQsNiArMTkwNiwxMiBAQAogCS8qIElmIHRoZXkgc3BlY2lmeSBhbiBpbml0cmQgZmlsZSB0byBsb2FkLiAqLwogCWNvbnN0IGNoYXIgKmluaXRyZF9uYW1lID0gTlVMTDsKIAorCS8qIFBhc3N3b3JkIHN0cnVjdHVyZSBmb3IgaW5pdGdyb3Vwcy9zZXRyZXNbZ3VdaWQgKi8KKwlzdHJ1Y3QgcGFzc3dkICp1c2VyX2RldGFpbHMgPSBOVUxMOworCisJLyogRGlyZWN0b3J5IHRvIGNocm9vdCB0byAqLworCWNoYXIgKmNocm9vdF9wYXRoID0gTlVMTDsKKwogCS8qIFNhdmUgdGhlIGFyZ3M6IHdlICJyZWJvb3QiIGJ5IGV4ZWNpbmcgb3Vyc2VsdmVzIGFnYWluLiAqLwogCW1haW5fYXJncyA9IGFyZ3Y7CiAKQEAgLTE5NTAsNiArMTk2OCwxNCBAQAogCQljYXNlICdpJzoKIAkJCWluaXRyZF9uYW1lID0gb3B0YXJnOwogCQkJYnJlYWs7CisJCWNhc2UgJ3UnOgorCQkJdXNlcl9kZXRhaWxzID0gZ2V0cHduYW0ob3B0YXJnKTsKKwkJCWlmICghdXNlcl9kZXRhaWxzKQorCQkJCWVycigxLCAiZ2V0cHduYW0gZmFpbGVkLCBpbmNvcnJlY3QgdXNlcm5hbWU/Iik7CisJCQlicmVhazsKKwkJY2FzZSAnYyc6CisJCQljaHJvb3RfcGF0aCA9IG9wdGFyZzsKKwkJCWJyZWFrOwogCQlkZWZhdWx0OgogCQkJd2FybngoIlVua25vd24gYXJndW1lbnQgJXMiLCBhcmd2W29wdGluZF0pOwogCQkJdXNhZ2UoKTsKQEAgLTIwMjEsNiArMjA0NywzNyBAQAogCS8qIElmIHdlIGV4aXQgdmlhIGVycigpLCB0aGlzIGtpbGxzIGFsbCB0aGUgdGhyZWFkcywgcmVzdG9yZXMgdHR5LiAqLwogCWF0ZXhpdChjbGVhbnVwX2RldmljZXMpOwogCisJLyogSWYgcmVxdWVzdGVkLCBjaHJvb3QgdG8gYSBkaXJlY3RvcnkgKi8KKwlpZiAoY2hyb290X3BhdGgpIHsKKwkJaWYgKGNocm9vdChjaHJvb3RfcGF0aCkgIT0gMCkKKwkJCWVycigxLCAiY2hyb290KFwiJXNcIikgZmFpbGVkIiwgY2hyb290X3BhdGgpOworCisJCWlmIChjaGRpcigiLyIpICE9IDApCisJCQllcnIoMSwgImNoZGlyKFwiL1wiKSBmYWlsZWQiKTsKKworCQl2ZXJib3NlKCJjaHJvb3QgZG9uZVxuIik7CisJfQorCisJLyogSWYgcmVxdWVzdGVkLCBkcm9wIHByaXZpbGVnZXMgKi8KKwlpZiAodXNlcl9kZXRhaWxzKSB7CisJCXVpZF90IHU7CisJCWdpZF90IGc7CisKKwkJdSA9IHVzZXJfZGV0YWlscy0+cHdfdWlkOworCQlnID0gdXNlcl9kZXRhaWxzLT5wd19naWQ7CisKKwkJaWYgKGluaXRncm91cHModXNlcl9kZXRhaWxzLT5wd19uYW1lLCBnKSAhPSAwKQorCQkJZXJyKDEsICJpbml0Z3JvdXBzIGZhaWxlZCIpOworCisJCWlmIChzZXRyZXNnaWQoZywgZywgZykgIT0gMCkKKwkJCWVycigxLCAic2V0cmVzZ2lkIGZhaWxlZCIpOworCisJCWlmIChzZXRyZXN1aWQodSwgdSwgdSkgIT0gMCkKKwkJCWVycigxLCAic2V0cmVzdWlkIGZhaWxlZCIpOworCisJCXZlcmJvc2UoIkRyb3BwaW5nIHByaXZpbGVnZXMgY29tcGxldGVkXG4iKTsKKwl9CisKIAkvKiBGaW5hbGx5LCBydW4gdGhlIEd1ZXN0LiAgVGhpcyBkb2Vzbid0IHJldHVybi4gKi8KIAlydW5fZ3Vlc3QoKTsKIH0KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vbGd1ZXN0L2xndWVzdC50eHQgYi9Eb2N1bWVudGF0aW9uL2xndWVzdC9sZ3Vlc3QudHh0CmluZGV4IDZjY2FmOGUuLmRhZDk5OTcgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vbGd1ZXN0L2xndWVzdC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9sZ3Vlc3QvbGd1ZXN0LnR4dApAQCAtMTE3LDYgKzExNywxMSBAQAogICAgIAogICBmb3IgZ2VuZXJhbCBpbmZvcm1hdGlvbiBvbiBob3cgdG8gZ2V0IGJyaWRnaW5nIHRvIHdvcmsuCiAKKy0gUmFuZG9tIG51bWJlciBnZW5lcmF0aW9uLiBVc2luZyB0aGUgLS1ybmcgb3B0aW9uIHdpbGwgcHJvdmlkZSBhCisgIC9kZXYvaHdybmcgaW4gdGhlIGd1ZXN0IHRoYXQgd2lsbCByZWFkIGZyb20gdGhlIGhvc3QncyAvZGV2L3JhbmRvbS4KKyAgVXNlIHRoaXMgb3B0aW9uIGluIGNvbmp1bmN0aW9uIHdpdGggcm5nLXRvb2xzIChzZWUgLi4vaHdfcmFuZG9tLnR4dCkKKyAgdG8gcHJvdmlkZSBlbnRyb3B5IHRvIHRoZSBndWVzdCBrZXJuZWwncyAvZGV2L3JhbmRvbS4KKwogVGhlcmUgaXMgYSBoZWxwZnVsIG1haWxpbmcgbGlzdCBhdCBodHRwOi8vb3psYWJzLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xndWVzdAogCiBHb29kIGx1Y2shCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvYm9uZGluZy50eHQgYi9Eb2N1bWVudGF0aW9uL25ldHdvcmtpbmcvYm9uZGluZy50eHQKaW5kZXggNWRjNjM4Ny4uMjVkMmY0MSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL2JvbmRpbmcudHh0CisrKyBiL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9ib25kaW5nLnR4dApAQCAtNDksNyArNDksOCBAQAogMy4zCUNvbmZpZ3VyaW5nIEJvbmRpbmcgTWFudWFsbHkgd2l0aCBJZmVuc2xhdmUKIDMuMy4xCQlDb25maWd1cmluZyBNdWx0aXBsZSBCb25kcyBNYW51YWxseQogMy40CUNvbmZpZ3VyaW5nIEJvbmRpbmcgTWFudWFsbHkgdmlhIFN5c2ZzCi0zLjUJT3ZlcnJpZGluZyBDb25maWd1cmF0aW9uIGZvciBTcGVjaWFsIENhc2VzCiszLjUJQ29uZmlndXJhdGlvbiB3aXRoIEludGVyZmFjZXMgU3VwcG9ydAorMy42CU92ZXJyaWRpbmcgQ29uZmlndXJhdGlvbiBmb3IgU3BlY2lhbCBDYXNlcwogCiA0LiBRdWVyeWluZyBCb25kaW5nIENvbmZpZ3VyYXRpb24KIDQuMQlCb25kaW5nIENvbmZpZ3VyYXRpb24KQEAgLTE2MSw4ICsxNjIsOCBAQAogZGVmYXVsdCBrZXJuZWwgc291cmNlIGluY2x1ZGUgZGlyZWN0b3J5LgogCiBTRUNPTkQgSU1QT1JUQU5UIE5PVEU6Ci0JSWYgeW91IHBsYW4gdG8gY29uZmlndXJlIGJvbmRpbmcgdXNpbmcgc3lzZnMsIHlvdSBkbyBub3QgbmVlZAotdG8gdXNlIGlmZW5zbGF2ZS4KKwlJZiB5b3UgcGxhbiB0byBjb25maWd1cmUgYm9uZGluZyB1c2luZyBzeXNmcyBvciB1c2luZyB0aGUKKy9ldGMvbmV0d29yay9pbnRlcmZhY2VzIGZpbGUsIHlvdSBkbyBub3QgbmVlZCB0byB1c2UgaWZlbnNsYXZlLgogCiAyLiBCb25kaW5nIERyaXZlciBPcHRpb25zCiA9PT09PT09PT09PT09PT09PT09PT09PT09CkBAIC03NzksMjIgKzc4MCwyNiBAQAogCiAJWW91IGNhbiBjb25maWd1cmUgYm9uZGluZyB1c2luZyBlaXRoZXIgeW91ciBkaXN0cm8ncyBuZXR3b3JrCiBpbml0aWFsaXphdGlvbiBzY3JpcHRzLCBvciBtYW51YWxseSB1c2luZyBlaXRoZXIgaWZlbnNsYXZlIG9yIHRoZQotc3lzZnMgaW50ZXJmYWNlLiAgRGlzdHJvcyBnZW5lcmFsbHkgdXNlIG9uZSBvZiB0d28gcGFja2FnZXMgZm9yIHRoZQotbmV0d29yayBpbml0aWFsaXphdGlvbiBzY3JpcHRzOiBpbml0c2NyaXB0cyBvciBzeXNjb25maWcuICBSZWNlbnQKLXZlcnNpb25zIG9mIHRoZXNlIHBhY2thZ2VzIGhhdmUgc3VwcG9ydCBmb3IgYm9uZGluZywgd2hpbGUgb2xkZXIKK3N5c2ZzIGludGVyZmFjZS4gIERpc3Ryb3MgZ2VuZXJhbGx5IHVzZSBvbmUgb2YgdGhyZWUgcGFja2FnZXMgZm9yIHRoZQorbmV0d29yayBpbml0aWFsaXphdGlvbiBzY3JpcHRzOiBpbml0c2NyaXB0cywgc3lzY29uZmlnIG9yIGludGVyZmFjZXMuCitSZWNlbnQgdmVyc2lvbnMgb2YgdGhlc2UgcGFja2FnZXMgaGF2ZSBzdXBwb3J0IGZvciBib25kaW5nLCB3aGlsZSBvbGRlcgogdmVyc2lvbnMgZG8gbm90LgogCiAJV2Ugd2lsbCBmaXJzdCBkZXNjcmliZSB0aGUgb3B0aW9ucyBmb3IgY29uZmlndXJpbmcgYm9uZGluZyBmb3IKLWRpc3Ryb3MgdXNpbmcgdmVyc2lvbnMgb2YgaW5pdHNjcmlwdHMgYW5kIHN5c2NvbmZpZyB3aXRoIGZ1bGwgb3IKLXBhcnRpYWwgc3VwcG9ydCBmb3IgYm9uZGluZywgdGhlbiBwcm92aWRlIGluZm9ybWF0aW9uIG9uIGVuYWJsaW5nCitkaXN0cm9zIHVzaW5nIHZlcnNpb25zIG9mIGluaXRzY3JpcHRzLCBzeXNjb25maWcgYW5kIGludGVyZmFjZXMgd2l0aCBmdWxsCitvciBwYXJ0aWFsIHN1cHBvcnQgZm9yIGJvbmRpbmcsIHRoZW4gcHJvdmlkZSBpbmZvcm1hdGlvbiBvbiBlbmFibGluZwogYm9uZGluZyB3aXRob3V0IHN1cHBvcnQgZnJvbSB0aGUgbmV0d29yayBpbml0aWFsaXphdGlvbiBzY3JpcHRzIChpLmUuLAogb2xkZXIgdmVyc2lvbnMgb2YgaW5pdHNjcmlwdHMgb3Igc3lzY29uZmlnKS4KIAotCUlmIHlvdSdyZSB1bnN1cmUgd2hldGhlciB5b3VyIGRpc3RybyB1c2VzIHN5c2NvbmZpZyBvcgotaW5pdHNjcmlwdHMsIG9yIGRvbid0IGtub3cgaWYgaXQncyBuZXcgZW5vdWdoLCBoYXZlIG5vIGZlYXIuCisJSWYgeW91J3JlIHVuc3VyZSB3aGV0aGVyIHlvdXIgZGlzdHJvIHVzZXMgc3lzY29uZmlnLAoraW5pdHNjcmlwdHMgb3IgaW50ZXJmYWNlcywgb3IgZG9uJ3Qga25vdyBpZiBpdCdzIG5ldyBlbm91Z2gsIGhhdmUgbm8gZmVhci4KIERldGVybWluaW5nIHRoaXMgaXMgZmFpcmx5IHN0cmFpZ2h0Zm9yd2FyZC4KIAotCUZpcnN0LCBpc3N1ZSB0aGUgY29tbWFuZDoKKwlGaXJzdCwgbG9vayBmb3IgYSBmaWxlIGNhbGxlZCBpbnRlcmZhY2VzIGluIC9ldGMvbmV0d29yayBkaXJlY3RvcnkuCitJZiB0aGlzIGZpbGUgaXMgcHJlc2VudCBpbiB5b3VyIHN5c3RlbSwgdGhlbiB5b3VyIHN5c3RlbSB1c2UgaW50ZXJmYWNlcy4gU2VlCitDb25maWd1cmF0aW9uIHdpdGggSW50ZXJmYWNlcyBTdXBwb3J0LgorCisJRWxzZSwgaXNzdWUgdGhlIGNvbW1hbmQ6CiAKICQgcnBtIC1xZiAvc2Jpbi9pZnVwCiAKQEAgLTEzMjcsOCArMTMzMiw2MiBAQAogZWNobyArZXRoMiA+IC9zeXMvY2xhc3MvbmV0L2JvbmQxL2JvbmRpbmcvc2xhdmVzCiBlY2hvICtldGgzID4gL3N5cy9jbGFzcy9uZXQvYm9uZDEvYm9uZGluZy9zbGF2ZXMKIAotMy41IE92ZXJyaWRpbmcgQ29uZmlndXJhdGlvbiBmb3IgU3BlY2lhbCBDYXNlcworMy41IENvbmZpZ3VyYXRpb24gd2l0aCBJbnRlcmZhY2VzIFN1cHBvcnQKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKKyAgICAgICAgVGhpcyBzZWN0aW9uIGFwcGxpZXMgdG8gZGlzdHJvcyB3aGljaCB1c2UgL2V0Yy9uZXR3b3JrL2ludGVyZmFjZXMgZmlsZQordG8gZGVzY3JpYmUgbmV0d29yayBpbnRlcmZhY2UgY29uZmlndXJhdGlvbiwgbW9zdCBub3RhYmx5IERlYmlhbiBhbmQgaXQncworZGVyaXZhdGl2ZXMuCisKKwlUaGUgaWZ1cCBhbmQgaWZkb3duIGNvbW1hbmRzIG9uIERlYmlhbiBkb24ndCBzdXBwb3J0IGJvbmRpbmcgb3V0IG9mCit0aGUgYm94LiBUaGUgaWZlbnNsYXZlLTIuNiBwYWNrYWdlIHNob3VsZCBiZSBpbnN0YWxsZWQgdG8gcHJvdmlkZSBib25kaW5nCitzdXBwb3J0LiAgT25jZSBpbnN0YWxsZWQsIHRoaXMgcGFja2FnZSB3aWxsIHByb3ZpZGUgYm9uZC0qIG9wdGlvbnMgdG8gYmUgdXNlZAoraW50byAvZXRjL25ldHdvcmsvaW50ZXJmYWNlcy4KKworCU5vdGUgdGhhdCBpZmVuc2xhdmUtMi42IHBhY2thZ2Ugd2lsbCBsb2FkIHRoZSBib25kaW5nIG1vZHVsZSBhbmQgdXNlCit0aGUgaWZlbnNsYXZlIGNvbW1hbmQgd2hlbiBhcHByb3ByaWF0ZS4KKworRXhhbXBsZSBDb25maWd1cmF0aW9ucworLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCitJbiAvZXRjL25ldHdvcmsvaW50ZXJmYWNlcywgdGhlIGZvbGxvd2luZyBzdGFuemEgd2lsbCBjb25maWd1cmUgYm9uZDAsIGluCithY3RpdmUtYmFja3VwIG1vZGUsIHdpdGggZXRoMCBhbmQgZXRoMSBhcyBzbGF2ZXMuCisKK2F1dG8gYm9uZDAKK2lmYWNlIGJvbmQwIGluZXQgZGhjcAorCWJvbmQtc2xhdmVzIGV0aDAgZXRoMQorCWJvbmQtbW9kZSBhY3RpdmUtYmFja3VwCisJYm9uZC1taWltb24gMTAwCisJYm9uZC1wcmltYXJ5IGV0aDAgZXRoMQorCitJZiB0aGUgYWJvdmUgY29uZmlndXJhdGlvbiBkb2Vzbid0IHdvcmssIHlvdSBtaWdodCBoYXZlIGEgc3lzdGVtIHVzaW5nCit1cHN0YXJ0IGZvciBzeXN0ZW0gc3RhcnR1cC4gVGhpcyBpcyBtb3N0IG5vdGFibHkgdHJ1ZSBmb3IgcmVjZW50CitVYnVudHUgdmVyc2lvbnMuIFRoZSBmb2xsb3dpbmcgc3RhbnphIGluIC9ldGMvbmV0d29yay9pbnRlcmZhY2VzIHdpbGwKK3Byb2R1Y2UgdGhlIHNhbWUgcmVzdWx0IG9uIHRob3NlIHN5c3RlbXMuCisKK2F1dG8gYm9uZDAKK2lmYWNlIGJvbmQwIGluZXQgZGhjcAorCWJvbmQtc2xhdmVzIG5vbmUKKwlib25kLW1vZGUgYWN0aXZlLWJhY2t1cAorCWJvbmQtbWlpbW9uIDEwMAorCithdXRvIGV0aDAKK2lmYWNlIGV0aDAgaW5ldCBtYW51YWwKKwlib25kLW1hc3RlciBib25kMAorCWJvbmQtcHJpbWFyeSBldGgwIGV0aDEKKworYXV0byBldGgxCitpZmFjZSBldGgxIGluZXQgbWFudWFsCisJYm9uZC1tYXN0ZXIgYm9uZDAKKwlib25kLXByaW1hcnkgZXRoMCBldGgxCisKK0ZvciBhIGZ1bGwgbGlzdCBvZiBib25kLSogc3VwcG9ydGVkIG9wdGlvbnMgaW4gL2V0Yy9uZXR3b3JrL2ludGVyZmFjZXMgYW5kIHNvbWUKK21vcmUgYWR2YW5jZWQgZXhhbXBsZXMgdGFpbG9yZWQgdG8geW91IHBhcnRpY3VsYXIgZGlzdHJvcywgc2VlIHRoZSBmaWxlcyBpbgorL3Vzci9zaGFyZS9kb2MvaWZlbnNsYXZlLTIuNi4KKworMy42IE92ZXJyaWRpbmcgQ29uZmlndXJhdGlvbiBmb3IgU3BlY2lhbCBDYXNlcwogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCiBXaGVuIHVzaW5nIHRoZSBib25kaW5nIGRyaXZlciwgdGhlIHBoeXNpY2FsIHBvcnQgd2hpY2ggdHJhbnNtaXRzIGEgZnJhbWUgaXMKIHR5cGljYWxseSBzZWxlY3RlZCBieSB0aGUgYm9uZGluZyBkcml2ZXIsIGFuZCBpcyBub3QgcmVsZXZhbnQgdG8gdGhlIHVzZXIgb3IKIHN5c3RlbSBhZG1pbmlzdHJhdG9yLiAgVGhlIG91dHB1dCBwb3J0IGlzIHNpbXBseSBzZWxlY3RlZCB1c2luZyB0aGUgcG9saWNpZXMgb2YKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vbmV0d29ya2luZy9pcC1zeXNjdGwudHh0IGIvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL2lwLXN5c2N0bC50eHQKaW5kZXggZDk5OTQwZC4uYWMzYjRhNyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL2lwLXN5c2N0bC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9uZXR3b3JraW5nL2lwLXN5c2N0bC50eHQKQEAgLTE4Nyw3ICsxODcsNyBAQAogdGNwX2RzYWNrIC0gQk9PTEVBTgogCUFsbG93cyBUQ1AgdG8gc2VuZCAiZHVwbGljYXRlIiBTQUNLcy4KIAotdGNwX2VjbiAtIEJPT0xFQU4KK3RjcF9lY24gLSBJTlRFR0VSCiAJRW5hYmxlIEV4cGxpY2l0IENvbmdlc3Rpb24gTm90aWZpY2F0aW9uIChFQ04pIGluIFRDUC4gRUNOIGlzIG9ubHkKIAl1c2VkIHdoZW4gYm90aCBlbmRzIG9mIHRoZSBUQ1AgZmxvdyBzdXBwb3J0IGl0LiBJdCBpcyB1c2VmdWwgdG8KIAlhdm9pZCBsb3NzZXMgZHVlIHRvIGNvbmdlc3Rpb24gKHdoZW4gdGhlIGJvdHRsZW5lY2sgcm91dGVyIHN1cHBvcnRzCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3NjaGVkdWxlci9zY2hlZC1zdGF0cy50eHQgYi9Eb2N1bWVudGF0aW9uL3NjaGVkdWxlci9zY2hlZC1zdGF0cy50eHQKaW5kZXggMDFlNjk0MC4uMWNkNWQ1MSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9zY2hlZHVsZXIvc2NoZWQtc3RhdHMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vc2NoZWR1bGVyL3NjaGVkLXN0YXRzLnR4dApAQCAtMSwzICsxLDcgQEAKK1ZlcnNpb24gMTUgb2Ygc2NoZWRzdGF0cyBkcm9wcGVkIGNvdW50ZXJzIGZvciBzb21lIHNjaGVkX3lpZWxkOgoreWxkX2V4cF9lbXB0eSwgeWxkX2FjdF9lbXB0eSBhbmQgeWxkX2JvdGhfZW1wdHkuIE90aGVyd2lzZSwgaXQgaXMKK2lkZW50aWNhbCB0byB2ZXJzaW9uIDE0LgorCiBWZXJzaW9uIDE0IG9mIHNjaGVkc3RhdHMgaW5jbHVkZXMgc3VwcG9ydCBmb3Igc2NoZWRfZG9tYWlucywgd2hpY2ggaGl0IHRoZQogbWFpbmxpbmUga2VybmVsIGluIDIuNi4yMCBhbHRob3VnaCBpdCBpcyBpZGVudGljYWwgdG8gdGhlIHN0YXRzIGZyb20gdmVyc2lvbgogMTIgd2hpY2ggd2FzIGluIHRoZSBrZXJuZWwgZnJvbSAyLjYuMTMtMi42LjE5ICh2ZXJzaW9uIDEzIG5ldmVyIHNhdyBhIGtlcm5lbApAQCAtMjgsMzIgKzMyLDI1IEBACiAKIENQVSBzdGF0aXN0aWNzCiAtLS0tLS0tLS0tLS0tLQotY3B1PE4+IDEgMiAzIDQgNSA2IDcgOCA5IDEwIDExIDEyCitjcHU8Tj4gMSAyIDMgNCA1IDYgNyA4IDkKIAotTk9URTogSW4gdGhlIHNjaGVkX3lpZWxkKCkgc3RhdGlzdGljcywgdGhlIGFjdGl2ZSBxdWV1ZSBpcyBjb25zaWRlcmVkIGVtcHR5Ci0gICAgaWYgaXQgaGFzIG9ubHkgb25lIHByb2Nlc3MgaW4gaXQsIHNpbmNlIG9idmlvdXNseSB0aGUgcHJvY2VzcyBjYWxsaW5nCi0gICAgc2NoZWRfeWllbGQoKSBpcyB0aGF0IHByb2Nlc3MuCi0KLUZpcnN0IGZvdXIgZmllbGRzIGFyZSBzY2hlZF95aWVsZCgpIHN0YXRpc3RpY3M6Ci0gICAgIDEpICMgb2YgdGltZXMgYm90aCB0aGUgYWN0aXZlIGFuZCB0aGUgZXhwaXJlZCBxdWV1ZSB3ZXJlIGVtcHR5Ci0gICAgIDIpICMgb2YgdGltZXMganVzdCB0aGUgYWN0aXZlIHF1ZXVlIHdhcyBlbXB0eQotICAgICAzKSAjIG9mIHRpbWVzIGp1c3QgdGhlIGV4cGlyZWQgcXVldWUgd2FzIGVtcHR5Ci0gICAgIDQpICMgb2YgdGltZXMgc2NoZWRfeWllbGQoKSB3YXMgY2FsbGVkCitGaXJzdCBmaWVsZCBpcyBhIHNjaGVkX3lpZWxkKCkgc3RhdGlzdGljOgorICAgICAxKSAjIG9mIHRpbWVzIHNjaGVkX3lpZWxkKCkgd2FzIGNhbGxlZAogCiBOZXh0IHRocmVlIGFyZSBzY2hlZHVsZSgpIHN0YXRpc3RpY3M6Ci0gICAgIDUpICMgb2YgdGltZXMgd2Ugc3dpdGNoZWQgdG8gdGhlIGV4cGlyZWQgcXVldWUgYW5kIHJldXNlZCBpdAotICAgICA2KSAjIG9mIHRpbWVzIHNjaGVkdWxlKCkgd2FzIGNhbGxlZAotICAgICA3KSAjIG9mIHRpbWVzIHNjaGVkdWxlKCkgbGVmdCB0aGUgcHJvY2Vzc29yIGlkbGUKKyAgICAgMikgIyBvZiB0aW1lcyB3ZSBzd2l0Y2hlZCB0byB0aGUgZXhwaXJlZCBxdWV1ZSBhbmQgcmV1c2VkIGl0CisgICAgIDMpICMgb2YgdGltZXMgc2NoZWR1bGUoKSB3YXMgY2FsbGVkCisgICAgIDQpICMgb2YgdGltZXMgc2NoZWR1bGUoKSBsZWZ0IHRoZSBwcm9jZXNzb3IgaWRsZQogCiBOZXh0IHR3byBhcmUgdHJ5X3RvX3dha2VfdXAoKSBzdGF0aXN0aWNzOgotICAgICA4KSAjIG9mIHRpbWVzIHRyeV90b193YWtlX3VwKCkgd2FzIGNhbGxlZAotICAgICA5KSAjIG9mIHRpbWVzIHRyeV90b193YWtlX3VwKCkgd2FzIGNhbGxlZCB0byB3YWtlIHVwIHRoZSBsb2NhbCBjcHUKKyAgICAgNSkgIyBvZiB0aW1lcyB0cnlfdG9fd2FrZV91cCgpIHdhcyBjYWxsZWQKKyAgICAgNikgIyBvZiB0aW1lcyB0cnlfdG9fd2FrZV91cCgpIHdhcyBjYWxsZWQgdG8gd2FrZSB1cCB0aGUgbG9jYWwgY3B1CiAKIE5leHQgdGhyZWUgYXJlIHN0YXRpc3RpY3MgZGVzY3JpYmluZyBzY2hlZHVsaW5nIGxhdGVuY3k6Ci0gICAgMTApIHN1bSBvZiBhbGwgdGltZSBzcGVudCBydW5uaW5nIGJ5IHRhc2tzIG9uIHRoaXMgcHJvY2Vzc29yIChpbiBqaWZmaWVzKQotICAgIDExKSBzdW0gb2YgYWxsIHRpbWUgc3BlbnQgd2FpdGluZyB0byBydW4gYnkgdGFza3Mgb24gdGhpcyBwcm9jZXNzb3IgKGluCisgICAgIDcpIHN1bSBvZiBhbGwgdGltZSBzcGVudCBydW5uaW5nIGJ5IHRhc2tzIG9uIHRoaXMgcHJvY2Vzc29yIChpbiBqaWZmaWVzKQorICAgICA4KSBzdW0gb2YgYWxsIHRpbWUgc3BlbnQgd2FpdGluZyB0byBydW4gYnkgdGFza3Mgb24gdGhpcyBwcm9jZXNzb3IgKGluCiAgICAgICAgIGppZmZpZXMpCi0gICAgMTIpICMgb2YgdGltZXNsaWNlcyBydW4gb24gdGhpcyBjcHUKKyAgICAgOSkgIyBvZiB0aW1lc2xpY2VzIHJ1biBvbiB0aGlzIGNwdQogCiAKIERvbWFpbiBzdGF0aXN0aWNzCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3NvdW5kL2Fsc2EvSEQtQXVkaW8tTW9kZWxzLnR4dCBiL0RvY3VtZW50YXRpb24vc291bmQvYWxzYS9IRC1BdWRpby1Nb2RlbHMudHh0CmluZGV4IDE2YWU0MzAuLjBjYWY3N2UgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vc291bmQvYWxzYS9IRC1BdWRpby1Nb2RlbHMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vc291bmQvYWxzYS9IRC1BdWRpby1Nb2RlbHMudHh0CkBAIC0yOTYsNiArMjk2LDcgQEAKID09PT09PT09PT09PT0KICAgbGFwdG9wCUJhc2ljIExhcHRvcCBjb25maWcgKGRlZmF1bHQpCiAgIGhwLWxhcHRvcAlIUCBsYXB0b3BzLCBlIGcgRzYwCisgIGFzdXMJCUFzdXMgSzUySlUsIExlbm92byBHNTYwCiAgIGRlbGwtbGFwdG9wCURlbGwgbGFwdG9wcwogICBkZWxsLXZvc3RybwlEZWxsIFZvc3RybwogICBvbHBjLXhvLTFfNQlPTFBDIFhPIDEuNQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zb3VuZC9hbHNhL3NvYy9jb2RlYy50eHQgYi9Eb2N1bWVudGF0aW9uL3NvdW5kL2Fsc2Evc29jL2NvZGVjLnR4dAppbmRleCAzN2JhM2E3Li5iY2UyM2E0IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3NvdW5kL2Fsc2Evc29jL2NvZGVjLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3NvdW5kL2Fsc2Evc29jL2NvZGVjLnR4dApAQCAtMjcsNDIgKzI3LDM4IEBACiAKIDEgLSBDb2RlYyBEQUkgYW5kIFBDTSBjb25maWd1cmF0aW9uCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotRWFjaCBjb2RlYyBkcml2ZXIgbXVzdCBoYXZlIGEgc3RydWN0IHNuZF9zb2NfY29kZWNfZGFpIHRvIGRlZmluZSBpdHMgREFJIGFuZAorRWFjaCBjb2RlYyBkcml2ZXIgbXVzdCBoYXZlIGEgc3RydWN0IHNuZF9zb2NfZGFpX2RyaXZlciB0byBkZWZpbmUgaXRzIERBSSBhbmQKIFBDTSBjYXBhYmlsaXRpZXMgYW5kIG9wZXJhdGlvbnMuIFRoaXMgc3RydWN0IGlzIGV4cG9ydGVkIHNvIHRoYXQgaXQgY2FuIGJlCiByZWdpc3RlcmVkIHdpdGggdGhlIGNvcmUgYnkgeW91ciBtYWNoaW5lIGRyaXZlci4KIAogZS5nLgogCi1zdHJ1Y3Qgc25kX3NvY19jb2RlY19kYWkgd204NzMxX2RhaSA9IHsKLQkubmFtZSA9ICJXTTg3MzEiLAotCS8qIHBsYXliYWNrIGNhcGFiaWxpdGllcyAqLworc3RhdGljIHN0cnVjdCBzbmRfc29jX2RhaV9vcHMgd204NzMxX2RhaV9vcHMgPSB7CisJLnByZXBhcmUJPSB3bTg3MzFfcGNtX3ByZXBhcmUsCisJLmh3X3BhcmFtcwk9IHdtODczMV9od19wYXJhbXMsCisJLnNodXRkb3duCT0gd204NzMxX3NodXRkb3duLAorCS5kaWdpdGFsX211dGUJPSB3bTg3MzFfbXV0ZSwKKwkuc2V0X3N5c2Nsawk9IHdtODczMV9zZXRfZGFpX3N5c2NsaywKKwkuc2V0X2ZtdAk9IHdtODczMV9zZXRfZGFpX2ZtdCwKK307CisKK3N0cnVjdCBzbmRfc29jX2RhaV9kcml2ZXIgd204NzMxX2RhaSA9IHsKKwkubmFtZSA9ICJ3bTg3MzEtaGlmaSIsCiAJLnBsYXliYWNrID0gewogCQkuc3RyZWFtX25hbWUgPSAiUGxheWJhY2siLAogCQkuY2hhbm5lbHNfbWluID0gMSwKIAkJLmNoYW5uZWxzX21heCA9IDIsCiAJCS5yYXRlcyA9IFdNODczMV9SQVRFUywKIAkJLmZvcm1hdHMgPSBXTTg3MzFfRk9STUFUUyx9LAotCS8qIGNhcHR1cmUgY2FwYWJpbGl0aWVzICovCiAJLmNhcHR1cmUgPSB7CiAJCS5zdHJlYW1fbmFtZSA9ICJDYXB0dXJlIiwKIAkJLmNoYW5uZWxzX21pbiA9IDEsCiAJCS5jaGFubmVsc19tYXggPSAyLAogCQkucmF0ZXMgPSBXTTg3MzFfUkFURVMsCiAJCS5mb3JtYXRzID0gV004NzMxX0ZPUk1BVFMsfSwKLQkvKiBwY20gb3BlcmF0aW9ucyAtIHNlZSBzZWN0aW9uIDQgYmVsb3cgKi8KLQkub3BzID0gewotCQkucHJlcGFyZSA9IHdtODczMV9wY21fcHJlcGFyZSwKLQkJLmh3X3BhcmFtcyA9IHdtODczMV9od19wYXJhbXMsCi0JCS5zaHV0ZG93biA9IHdtODczMV9zaHV0ZG93biwKLQl9LAotCS8qIERBSSBvcGVyYXRpb25zIC0gc2VlIERBSS50eHQgKi8KLQkuZGFpX29wcyA9IHsKLQkJLmRpZ2l0YWxfbXV0ZSA9IHdtODczMV9tdXRlLAotCQkuc2V0X3N5c2NsayA9IHdtODczMV9zZXRfZGFpX3N5c2NsaywKLQkJLnNldF9mbXQgPSB3bTg3MzFfc2V0X2RhaV9mbXQsCi0JfQorCS5vcHMgPSAmd204NzMxX2RhaV9vcHMsCisJLnN5bW1ldHJpY19yYXRlcyA9IDEsCiB9OwotRVhQT1JUX1NZTUJPTF9HUEwod204NzMxX2RhaSk7CiAKIAogMiAtIENvZGVjIGNvbnRyb2wgSU8KQEAgLTE4NiwxMyArMTgyLDE0IEBACiAKIGkuZS4KIAotc3RhdGljIGludCB3bTg5NzRfbXV0ZShzdHJ1Y3Qgc25kX3NvY19jb2RlYyAqY29kZWMsCi0Jc3RydWN0IHNuZF9zb2NfY29kZWNfZGFpICpkYWksIGludCBtdXRlKQorc3RhdGljIGludCB3bTg5NzRfbXV0ZShzdHJ1Y3Qgc25kX3NvY19kYWkgKmRhaSwgaW50IG11dGUpCiB7Ci0JdTE2IG11dGVfcmVnID0gd204OTc0X3JlYWRfcmVnX2NhY2hlKGNvZGVjLCBXTTg5NzRfREFDKSAmIDB4ZmZiZjsKLQlpZihtdXRlKQotCQl3bTg5NzRfd3JpdGUoY29kZWMsIFdNODk3NF9EQUMsIG11dGVfcmVnIHwgMHg0MCk7CisJc3RydWN0IHNuZF9zb2NfY29kZWMgKmNvZGVjID0gZGFpLT5jb2RlYzsKKwl1MTYgbXV0ZV9yZWcgPSBzbmRfc29jX3JlYWQoY29kZWMsIFdNODk3NF9EQUMpICYgMHhmZmJmOworCisJaWYgKG11dGUpCisJCXNuZF9zb2Nfd3JpdGUoY29kZWMsIFdNODk3NF9EQUMsIG11dGVfcmVnIHwgMHg0MCk7CiAJZWxzZQotCQl3bTg5NzRfd3JpdGUoY29kZWMsIFdNODk3NF9EQUMsIG11dGVfcmVnKTsKKwkJc25kX3NvY193cml0ZShjb2RlYywgV004OTc0X0RBQywgbXV0ZV9yZWcpOwogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zb3VuZC9hbHNhL3NvYy9tYWNoaW5lLnR4dCBiL0RvY3VtZW50YXRpb24vc291bmQvYWxzYS9zb2MvbWFjaGluZS50eHQKaW5kZXggMjUyNGM3NS4uM2UyZWM5YyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9zb3VuZC9hbHNhL3NvYy9tYWNoaW5lLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3NvdW5kL2Fsc2Evc29jL21hY2hpbmUudHh0CkBAIC0xMiw2ICsxMiw4IEBACiBzdHJ1Y3Qgc25kX3NvY19jYXJkIHsKIAljaGFyICpuYW1lOwogCisJLi4uCisKIAlpbnQgKCpwcm9iZSkoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldik7CiAJaW50ICgqcmVtb3ZlKShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KTsKIApAQCAtMjIsMTIgKzI0LDEzIEBACiAJaW50ICgqcmVzdW1lX3ByZSkoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldik7CiAJaW50ICgqcmVzdW1lX3Bvc3QpKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpOwogCi0JLyogbWFjaGluZSBzdHJlYW0gb3BlcmF0aW9ucyAqLwotCXN0cnVjdCBzbmRfc29jX29wcyAqb3BzOworCS4uLgogCiAJLyogQ1BVIDwtLT4gQ29kZWMgREFJIGxpbmtzICAqLwogCXN0cnVjdCBzbmRfc29jX2RhaV9saW5rICpkYWlfbGluazsKIAlpbnQgbnVtX2xpbmtzOworCisJLi4uCiB9OwogCiBwcm9iZSgpL3JlbW92ZSgpCkBAIC00MiwxMSArNDUsNiBAQAogYW5kIERNQSBpcyBzdXNwZW5kZWQgYW5kIHJlc3VtZWQuIE9wdGlvbmFsLgogCiAKLU1hY2hpbmUgb3BlcmF0aW9ucwotLS0tLS0tLS0tLS0tLS0tLS0tCi1UaGUgbWFjaGluZSBzcGVjaWZpYyBhdWRpbyBvcGVyYXRpb25zIGNhbiBiZSBzZXQgaGVyZS4gQWdhaW4gdGhpcyBpcyBvcHRpb25hbC4KLQotCiBNYWNoaW5lIERBSSBDb25maWd1cmF0aW9uCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBUaGUgbWFjaGluZSBEQUkgY29uZmlndXJhdGlvbiBnbHVlcyBhbGwgdGhlIGNvZGVjIGFuZCBDUFUgREFJcyB0b2dldGhlci4gSXQgY2FuCkBAIC02MSw4ICs1OSwxMCBAQAogc3RhdGljIHN0cnVjdCBzbmRfc29jX2RhaV9saW5rIGNvcmdpX2RhaSA9IHsKIAkubmFtZSA9ICJXTTg3MzEiLAogCS5zdHJlYW1fbmFtZSA9ICJXTTg3MzEiLAotCS5jcHVfZGFpID0gJnB4YV9pMnNfZGFpLAotCS5jb2RlY19kYWkgPSAmd204NzMxX2RhaSwKKwkuY3B1X2RhaV9uYW1lID0gInB4YS1pczItZGFpIiwKKwkuY29kZWNfZGFpX25hbWUgPSAid204NzMxLWhpZmkiLAorCS5wbGF0Zm9ybV9uYW1lID0gInB4YS1wY20tYXVkaW8iLAorCS5jb2RlY19uYW1lID0gIndtODcxMy1jb2RlYy4wLTAwMWEiLAogCS5pbml0ID0gY29yZ2lfd204NzMxX2luaXQsCiAJLm9wcyA9ICZjb3JnaV9vcHMsCiB9OwpAQCAtNzcsMjYgKzc3LDYgQEAKIH07CiAKIAotTWFjaGluZSBBdWRpbyBTdWJzeXN0ZW0KLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0KLVRoZSBtYWNoaW5lIHNvYyBkZXZpY2UgZ2x1ZXMgdGhlIHBsYXRmb3JtLCBtYWNoaW5lIGFuZCBjb2RlYyBkcml2ZXIgdG9nZXRoZXIuCi1Qcml2YXRlIGRhdGEgY2FuIGFsc28gYmUgc2V0IGhlcmUuIGUuZy4KLQotLyogY29yZ2kgYXVkaW8gcHJpdmF0ZSBkYXRhICovCi1zdGF0aWMgc3RydWN0IHdtODczMV9zZXR1cF9kYXRhIGNvcmdpX3dtODczMV9zZXR1cCA9IHsKLQkuaTJjX2FkZHJlc3MgPSAweDFiLAotfTsKLQotLyogY29yZ2kgYXVkaW8gc3Vic3lzdGVtICovCi1zdGF0aWMgc3RydWN0IHNuZF9zb2NfZGV2aWNlIGNvcmdpX3NuZF9kZXZkYXRhID0gewotCS5tYWNoaW5lID0gJnNuZF9zb2NfY29yZ2ksCi0JLnBsYXRmb3JtID0gJnB4YTJ4eF9zb2NfcGxhdGZvcm0sCi0JLmNvZGVjX2RldiA9ICZzb2NfY29kZWNfZGV2X3dtODczMSwKLQkuY29kZWNfZGF0YSA9ICZjb3JnaV93bTg3MzFfc2V0dXAsCi19OwotCi0KIE1hY2hpbmUgUG93ZXIgTWFwCiAtLS0tLS0tLS0tLS0tLS0tLQogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3NvdW5kL2Fsc2Evc29jL3BsYXRmb3JtLnR4dCBiL0RvY3VtZW50YXRpb24vc291bmQvYWxzYS9zb2MvcGxhdGZvcm0udHh0CmluZGV4IDA2ZDgzNTkuLmQ1N2VmYWQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vc291bmQvYWxzYS9zb2MvcGxhdGZvcm0udHh0CisrKyBiL0RvY3VtZW50YXRpb24vc291bmQvYWxzYS9zb2MvcGxhdGZvcm0udHh0CkBAIC0yMCw5ICsyMCwxMCBAQAogCWludCAoKnRyaWdnZXIpKHN0cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAqLCBpbnQpOwogfTsKIAotVGhlIHBsYXRmb3JtIGRyaXZlciBleHBvcnRzIGl0cyBETUEgZnVuY3Rpb25hbGl0eSB2aWEgc3RydWN0IHNuZF9zb2NfcGxhdGZvcm06LQorVGhlIHBsYXRmb3JtIGRyaXZlciBleHBvcnRzIGl0cyBETUEgZnVuY3Rpb25hbGl0eSB2aWEgc3RydWN0CitzbmRfc29jX3BsYXRmb3JtX2RyaXZlcjotCiAKLXN0cnVjdCBzbmRfc29jX3BsYXRmb3JtIHsKK3N0cnVjdCBzbmRfc29jX3BsYXRmb3JtX2RyaXZlciB7CiAJY2hhciAqbmFtZTsKIAogCWludCAoKnByb2JlKShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KTsKQEAgLTM0LDYgKzM1LDEzIEBACiAJaW50ICgqcGNtX25ldykoc3RydWN0IHNuZF9jYXJkICosIHN0cnVjdCBzbmRfc29jX2NvZGVjX2RhaSAqLCBzdHJ1Y3Qgc25kX3BjbSAqKTsKIAl2b2lkICgqcGNtX2ZyZWUpKHN0cnVjdCBzbmRfcGNtICopOwogCisJLyoKKwkgKiBGb3IgcGxhdGZvcm0gY2F1c2VkIGRlbGF5IHJlcG9ydGluZy4KKwkgKiBPcHRpb25hbC4KKwkgKi8KKwlzbmRfcGNtX3NmcmFtZXNfdCAoKmRlbGF5KShzdHJ1Y3Qgc25kX3BjbV9zdWJzdHJlYW0gKiwKKwkJc3RydWN0IHNuZF9zb2NfZGFpICopOworCiAJLyogcGxhdGZvcm0gc3RyZWFtIG9wcyAqLwogCXN0cnVjdCBzbmRfcGNtX29wcyAqcGNtX29wczsKIH07CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3RhcmdldC90Y21fbW9kX2J1aWxkZXIucHkgYi9Eb2N1bWVudGF0aW9uL3RhcmdldC90Y21fbW9kX2J1aWxkZXIucHkKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMC4uZGJlYjhhMAotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRpb24vdGFyZ2V0L3RjbV9tb2RfYnVpbGRlci5weQpAQCAtMCwwICsxLDEwOTQgQEAKKyMhL3Vzci9iaW4vcHl0aG9uCisjIFRoZSBUQ00gdjQgbXVsdGktcHJvdG9jb2wgZmFicmljIG1vZHVsZSBnZW5lcmF0aW9uIHNjcmlwdCBmb3IgZHJpdmVycy90YXJnZXQvJE5FV19NT0QKKyMKKyMgQ29weXJpZ2h0IChjKSAyMDEwIFJpc2luZyBUaWRlIFN5c3RlbXMKKyMgQ29weXJpZ2h0IChjKSAyMDEwIExpbnV4LWlTQ1NJLm9yZworIworIyBBdXRob3I6IG5hYkBrZXJuZWwub3JnCisjCitpbXBvcnQgb3MsIHN5cworaW1wb3J0IHN1YnByb2Nlc3MgYXMgc3ViCitpbXBvcnQgc3RyaW5nCitpbXBvcnQgcmUKK2ltcG9ydCBvcHRwYXJzZQorCit0Y21fZGlyID0gIiIKKworZmFicmljX29wcyA9IFtdCitmYWJyaWNfbW9kX2RpciA9ICIiCitmYWJyaWNfbW9kX3BvcnQgPSAiIgorZmFicmljX21vZF9pbml0X3BvcnQgPSAiIgorCitkZWYgdGNtX21vZF9lcnIobXNnKToKKwlwcmludCBtc2cKKwlzeXMuZXhpdCgxKQorCitkZWYgdGNtX21vZF9jcmVhdGVfbW9kdWxlX3N1YmRpcihmYWJyaWNfbW9kX2Rpcl92YXIpOgorCisJaWYgb3MucGF0aC5pc2RpcihmYWJyaWNfbW9kX2Rpcl92YXIpID09IFRydWU6CisJCXJldHVybiAxCisKKwlwcmludCAiQ3JlYXRpbmcgZmFicmljX21vZF9kaXI6ICIgKyBmYWJyaWNfbW9kX2Rpcl92YXIKKwlyZXQgPSBvcy5ta2RpcihmYWJyaWNfbW9kX2Rpcl92YXIpCisJaWYgcmV0OgorCQl0Y21fbW9kX2VycigiVW5hYmxlIHRvIG1rZGlyICIgKyBmYWJyaWNfbW9kX2Rpcl92YXIpCisKKwlyZXR1cm4KKworZGVmIHRjbV9tb2RfYnVpbGRfRkNfaW5jbHVkZShmYWJyaWNfbW9kX2Rpcl92YXIsIGZhYnJpY19tb2RfbmFtZSk6CisJZ2xvYmFsIGZhYnJpY19tb2RfcG9ydAorCWdsb2JhbCBmYWJyaWNfbW9kX2luaXRfcG9ydAorCWJ1ZiA9ICIiCisKKwlmID0gZmFicmljX21vZF9kaXJfdmFyICsgIi8iICsgZmFicmljX21vZF9uYW1lICsgIl9iYXNlLmgiCisJcHJpbnQgIldyaXRpbmcgZmlsZTogIiArIGYKKworCXAgPSBvcGVuKGYsICd3Jyk7CisJaWYgbm90IHA6CisJCXRjbV9tb2RfZXJyKCJVbmFibGUgdG8gb3BlbiBmaWxlOiAiICsgZikKKworCWJ1ZiA9ICIjZGVmaW5lICIgKyBmYWJyaWNfbW9kX25hbWUudXBwZXIoKSArICJfVkVSU0lPTglcInYwLjFcIlxuIgorCWJ1ZiArPSAiI2RlZmluZSAiICsgZmFicmljX21vZF9uYW1lLnVwcGVyKCkgKyAiX05BTUVMRU4JMzJcbiIKKwlidWYgKz0gIlxuIgorCWJ1ZiArPSAic3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX25hY2wge1xuIgorCWJ1ZiArPSAiCS8qIEJpbmFyeSBXb3JsZCBXaWRlIHVuaXF1ZSBQb3J0IE5hbWUgZm9yIEZDIEluaXRpYXRvciBOcG9ydCAqL1xuIgorCWJ1ZiArPSAiCXU2NCBucG9ydF93d3BuO1xuIgorCWJ1ZiArPSAiCS8qIEFTQ0lJIGZvcm1hdHRlZCBXV1BOIGZvciBGQyBJbml0aWF0b3IgTnBvcnQgKi9cbiIKKwlidWYgKz0gIgljaGFyIG5wb3J0X25hbWVbIiArIGZhYnJpY19tb2RfbmFtZS51cHBlcigpICsgIl9OQU1FTEVOXTtcbiIKKwlidWYgKz0gIgkvKiBSZXR1cm5lZCBieSAiICsgZmFicmljX21vZF9uYW1lICsgIl9tYWtlX25vZGVhY2woKSAqL1xuIgorCWJ1ZiArPSAiCXN0cnVjdCBzZV9ub2RlX2FjbCBzZV9ub2RlX2FjbDtcbiIKKwlidWYgKz0gIn07XG4iCisJYnVmICs9ICJcbiIKKwlidWYgKz0gInN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl90cGcge1xuIgorCWJ1ZiArPSAiCS8qIEZDIGxwb3J0IHRhcmdldCBwb3J0YWwgZ3JvdXAgdGFnIGZvciBUQ00gKi9cbiIKKwlidWYgKz0gIgl1MTYgbHBvcnRfdHBndDtcbiIKKwlidWYgKz0gIgkvKiBQb2ludGVyIGJhY2sgdG8gIiArIGZhYnJpY19tb2RfbmFtZSArICJfbHBvcnQgKi9cbiIKKwlidWYgKz0gIglzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfbHBvcnQgKmxwb3J0O1xuIgorCWJ1ZiArPSAiCS8qIFJldHVybmVkIGJ5ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX21ha2VfdHBnKCkgKi9cbiIKKwlidWYgKz0gIglzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwIHNlX3RwZztcbiIKKwlidWYgKz0gIn07XG4iCisJYnVmICs9ICJcbiIKKwlidWYgKz0gInN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl9scG9ydCB7XG4iCisJYnVmICs9ICIJLyogU0NTSSBwcm90b2NvbCB0aGUgbHBvcnQgaXMgcHJvdmlkaW5nICovXG4iCisJYnVmICs9ICIJdTggbHBvcnRfcHJvdG9faWQ7XG4iCisJYnVmICs9ICIJLyogQmluYXJ5IFdvcmxkIFdpZGUgdW5pcXVlIFBvcnQgTmFtZSBmb3IgRkMgVGFyZ2V0IExwb3J0ICovXG4iCisJYnVmICs9ICIJdTY0IGxwb3J0X3d3cG47XG4iCisJYnVmICs9ICIJLyogQVNDSUkgZm9ybWF0dGVkIFdXUE4gZm9yIEZDIFRhcmdldCBMcG9ydCAqL1xuIgorCWJ1ZiArPSAiCWNoYXIgbHBvcnRfbmFtZVsiICsgZmFicmljX21vZF9uYW1lLnVwcGVyKCkgKyAiX05BTUVMRU5dO1xuIgorCWJ1ZiArPSAiCS8qIFJldHVybmVkIGJ5ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX21ha2VfbHBvcnQoKSAqL1xuIgorCWJ1ZiArPSAiCXN0cnVjdCBzZV93d24gbHBvcnRfd3duO1xuIgorCWJ1ZiArPSAifTtcbiIKKworCXJldCA9IHAud3JpdGUoYnVmKQorCWlmIHJldDoKKwkJdGNtX21vZF9lcnIoIlVuYWJsZSB0byB3cml0ZSBmOiAiICsgZikKKworCXAuY2xvc2UoKQorCisJZmFicmljX21vZF9wb3J0ID0gImxwb3J0IgorCWZhYnJpY19tb2RfaW5pdF9wb3J0ID0gIm5wb3J0IgorCisJcmV0dXJuCisKK2RlZiB0Y21fbW9kX2J1aWxkX1NBU19pbmNsdWRlKGZhYnJpY19tb2RfZGlyX3ZhciwgZmFicmljX21vZF9uYW1lKToKKwlnbG9iYWwgZmFicmljX21vZF9wb3J0CisJZ2xvYmFsIGZhYnJpY19tb2RfaW5pdF9wb3J0CisJYnVmID0gIiIKKworCWYgPSBmYWJyaWNfbW9kX2Rpcl92YXIgKyAiLyIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2Jhc2UuaCIKKwlwcmludCAiV3JpdGluZyBmaWxlOiAiICsgZgorCisJcCA9IG9wZW4oZiwgJ3cnKTsKKwlpZiBub3QgcDoKKwkJdGNtX21vZF9lcnIoIlVuYWJsZSB0byBvcGVuIGZpbGU6ICIgKyBmKQorCisJYnVmID0gIiNkZWZpbmUgIiArIGZhYnJpY19tb2RfbmFtZS51cHBlcigpICsgIl9WRVJTSU9OICBcInYwLjFcIlxuIgorCWJ1ZiArPSAiI2RlZmluZSAiICsgZmFicmljX21vZF9uYW1lLnVwcGVyKCkgKyAiX05BTUVMRU4gMzJcbiIKKwlidWYgKz0gIlxuIgorCWJ1ZiArPSAic3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX25hY2wge1xuIgorCWJ1ZiArPSAiCS8qIEJpbmFyeSBXb3JsZCBXaWRlIHVuaXF1ZSBQb3J0IE5hbWUgZm9yIFNBUyBJbml0aWF0b3IgcG9ydCAqL1xuIgorCWJ1ZiArPSAiCXU2NCBpcG9ydF93d3BuO1xuIgorCWJ1ZiArPSAiCS8qIEFTQ0lJIGZvcm1hdHRlZCBXV1BOIGZvciBTYXMgSW5pdGlhdG9yIHBvcnQgKi9cbiIKKwlidWYgKz0gIgljaGFyIGlwb3J0X25hbWVbIiArIGZhYnJpY19tb2RfbmFtZS51cHBlcigpICsgIl9OQU1FTEVOXTtcbiIKKwlidWYgKz0gIgkvKiBSZXR1cm5lZCBieSAiICsgZmFicmljX21vZF9uYW1lICsgIl9tYWtlX25vZGVhY2woKSAqL1xuIgorCWJ1ZiArPSAiCXN0cnVjdCBzZV9ub2RlX2FjbCBzZV9ub2RlX2FjbDtcbiIKKwlidWYgKz0gIn07XG5cbiIKKwlidWYgKz0gInN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl90cGcge1xuIgorCWJ1ZiArPSAiCS8qIFNBUyBwb3J0IHRhcmdldCBwb3J0YWwgZ3JvdXAgdGFnIGZvciBUQ00gKi9cbiIKKwlidWYgKz0gIgl1MTYgdHBvcnRfdHBndDtcbiIKKwlidWYgKz0gIgkvKiBQb2ludGVyIGJhY2sgdG8gIiArIGZhYnJpY19tb2RfbmFtZSArICJfdHBvcnQgKi9cbiIKKwlidWYgKz0gIglzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfdHBvcnQgKnRwb3J0O1xuIgorCWJ1ZiArPSAiCS8qIFJldHVybmVkIGJ5ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX21ha2VfdHBnKCkgKi9cbiIKKwlidWYgKz0gIglzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwIHNlX3RwZztcbiIKKwlidWYgKz0gIn07XG5cbiIKKwlidWYgKz0gInN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl90cG9ydCB7XG4iCisJYnVmICs9ICIJLyogU0NTSSBwcm90b2NvbCB0aGUgdHBvcnQgaXMgcHJvdmlkaW5nICovXG4iCisJYnVmICs9ICIJdTggdHBvcnRfcHJvdG9faWQ7XG4iCisJYnVmICs9ICIJLyogQmluYXJ5IFdvcmxkIFdpZGUgdW5pcXVlIFBvcnQgTmFtZSBmb3IgU0FTIFRhcmdldCBwb3J0ICovXG4iCisJYnVmICs9ICIJdTY0IHRwb3J0X3d3cG47XG4iCisJYnVmICs9ICIJLyogQVNDSUkgZm9ybWF0dGVkIFdXUE4gZm9yIFNBUyBUYXJnZXQgcG9ydCAqL1xuIgorCWJ1ZiArPSAiCWNoYXIgdHBvcnRfbmFtZVsiICsgZmFicmljX21vZF9uYW1lLnVwcGVyKCkgKyAiX05BTUVMRU5dO1xuIgorCWJ1ZiArPSAiCS8qIFJldHVybmVkIGJ5ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX21ha2VfdHBvcnQoKSAqL1xuIgorCWJ1ZiArPSAiCXN0cnVjdCBzZV93d24gdHBvcnRfd3duO1xuIgorCWJ1ZiArPSAifTtcbiIKKworCXJldCA9IHAud3JpdGUoYnVmKQorCWlmIHJldDoKKwkJdGNtX21vZF9lcnIoIlVuYWJsZSB0byB3cml0ZSBmOiAiICsgZikKKworCXAuY2xvc2UoKQorCisJZmFicmljX21vZF9wb3J0ID0gInRwb3J0IgorCWZhYnJpY19tb2RfaW5pdF9wb3J0ID0gImlwb3J0IgorCisJcmV0dXJuCisKK2RlZiB0Y21fbW9kX2J1aWxkX2lTQ1NJX2luY2x1ZGUoZmFicmljX21vZF9kaXJfdmFyLCBmYWJyaWNfbW9kX25hbWUpOgorCWdsb2JhbCBmYWJyaWNfbW9kX3BvcnQKKwlnbG9iYWwgZmFicmljX21vZF9pbml0X3BvcnQKKwlidWYgPSAiIgorCisJZiA9IGZhYnJpY19tb2RfZGlyX3ZhciArICIvIiArIGZhYnJpY19tb2RfbmFtZSArICJfYmFzZS5oIgorCXByaW50ICJXcml0aW5nIGZpbGU6ICIgKyBmCisKKwlwID0gb3BlbihmLCAndycpOworCWlmIG5vdCBwOgorCQl0Y21fbW9kX2VycigiVW5hYmxlIHRvIG9wZW4gZmlsZTogIiArIGYpCisKKwlidWYgPSAiI2RlZmluZSAiICsgZmFicmljX21vZF9uYW1lLnVwcGVyKCkgKyAiX1ZFUlNJT04gIFwidjAuMVwiXG4iCisJYnVmICs9ICIjZGVmaW5lICIgKyBmYWJyaWNfbW9kX25hbWUudXBwZXIoKSArICJfTkFNRUxFTiAzMlxuIgorCWJ1ZiArPSAiXG4iCisJYnVmICs9ICJzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfbmFjbCB7XG4iCisJYnVmICs9ICIJLyogQVNDSUkgZm9ybWF0dGVkIEluaXRpYXRvck5hbWUgKi9cbiIKKwlidWYgKz0gIgljaGFyIGlwb3J0X25hbWVbIiArIGZhYnJpY19tb2RfbmFtZS51cHBlcigpICsgIl9OQU1FTEVOXTtcbiIKKwlidWYgKz0gIgkvKiBSZXR1cm5lZCBieSAiICsgZmFicmljX21vZF9uYW1lICsgIl9tYWtlX25vZGVhY2woKSAqL1xuIgorCWJ1ZiArPSAiCXN0cnVjdCBzZV9ub2RlX2FjbCBzZV9ub2RlX2FjbDtcbiIKKwlidWYgKz0gIn07XG5cbiIKKwlidWYgKz0gInN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl90cGcge1xuIgorCWJ1ZiArPSAiCS8qIGlTQ1NJIHRhcmdldCBwb3J0YWwgZ3JvdXAgdGFnIGZvciBUQ00gKi9cbiIKKwlidWYgKz0gIgl1MTYgdHBvcnRfdHBndDtcbiIKKwlidWYgKz0gIgkvKiBQb2ludGVyIGJhY2sgdG8gIiArIGZhYnJpY19tb2RfbmFtZSArICJfdHBvcnQgKi9cbiIKKwlidWYgKz0gIglzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfdHBvcnQgKnRwb3J0O1xuIgorCWJ1ZiArPSAiCS8qIFJldHVybmVkIGJ5ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX21ha2VfdHBnKCkgKi9cbiIKKwlidWYgKz0gIglzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwIHNlX3RwZztcbiIKKwlidWYgKz0gIn07XG5cbiIKKwlidWYgKz0gInN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl90cG9ydCB7XG4iCisJYnVmICs9ICIJLyogU0NTSSBwcm90b2NvbCB0aGUgdHBvcnQgaXMgcHJvdmlkaW5nICovXG4iCisJYnVmICs9ICIJdTggdHBvcnRfcHJvdG9faWQ7XG4iCisJYnVmICs9ICIJLyogQVNDSUkgZm9ybWF0dGVkIFRhcmdldE5hbWUgZm9yIElRTiAqL1xuIgorCWJ1ZiArPSAiCWNoYXIgdHBvcnRfbmFtZVsiICsgZmFicmljX21vZF9uYW1lLnVwcGVyKCkgKyAiX05BTUVMRU5dO1xuIgorCWJ1ZiArPSAiCS8qIFJldHVybmVkIGJ5ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX21ha2VfdHBvcnQoKSAqL1xuIgorCWJ1ZiArPSAiCXN0cnVjdCBzZV93d24gdHBvcnRfd3duO1xuIgorCWJ1ZiArPSAifTtcbiIKKworCXJldCA9IHAud3JpdGUoYnVmKQorCWlmIHJldDoKKwkJdGNtX21vZF9lcnIoIlVuYWJsZSB0byB3cml0ZSBmOiAiICsgZikKKworCXAuY2xvc2UoKQorCisJZmFicmljX21vZF9wb3J0ID0gInRwb3J0IgorCWZhYnJpY19tb2RfaW5pdF9wb3J0ID0gImlwb3J0IgorCisJcmV0dXJuCisKK2RlZiB0Y21fbW9kX2J1aWxkX2Jhc2VfaW5jbHVkZXMocHJvdG9faWRlbnQsIGZhYnJpY19tb2RfZGlyX3ZhbCwgZmFicmljX21vZF9uYW1lKToKKworCWlmIHByb3RvX2lkZW50ID09ICJGQyI6CisJCXRjbV9tb2RfYnVpbGRfRkNfaW5jbHVkZShmYWJyaWNfbW9kX2Rpcl92YWwsIGZhYnJpY19tb2RfbmFtZSkKKwllbGlmIHByb3RvX2lkZW50ID09ICJTQVMiOgorCQl0Y21fbW9kX2J1aWxkX1NBU19pbmNsdWRlKGZhYnJpY19tb2RfZGlyX3ZhbCwgZmFicmljX21vZF9uYW1lKQorCWVsaWYgcHJvdG9faWRlbnQgPT0gImlTQ1NJIjoKKwkJdGNtX21vZF9idWlsZF9pU0NTSV9pbmNsdWRlKGZhYnJpY19tb2RfZGlyX3ZhbCwgZmFicmljX21vZF9uYW1lKQorCWVsc2U6CisJCXByaW50ICJVbnN1cHBvcnRlZCBwcm90b19pZGVudDogIiArIHByb3RvX2lkZW50CisJCXN5cy5leGl0KDEpCisKKwlyZXR1cm4KKworZGVmIHRjbV9tb2RfYnVpbGRfY29uZmlnZnMocHJvdG9faWRlbnQsIGZhYnJpY19tb2RfZGlyX3ZhciwgZmFicmljX21vZF9uYW1lKToKKwlidWYgPSAiIgorCisJZiA9IGZhYnJpY19tb2RfZGlyX3ZhciArICIvIiArIGZhYnJpY19tb2RfbmFtZSArICJfY29uZmlnZnMuYyIKKwlwcmludCAiV3JpdGluZyBmaWxlOiAiICsgZgorCisgICAgICAgIHAgPSBvcGVuKGYsICd3Jyk7CisgICAgICAgIGlmIG5vdCBwOgorICAgICAgICAgICAgICAgIHRjbV9tb2RfZXJyKCJVbmFibGUgdG8gb3BlbiBmaWxlOiAiICsgZikKKworCWJ1ZiA9ICIjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8bGludXgvbW9kdWxlcGFyYW0uaD5cbiIKKwlidWYgKz0gIiNpbmNsdWRlIDxsaW51eC92ZXJzaW9uLmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8Z2VuZXJhdGVkL3V0c3JlbGVhc2UuaD5cbiIKKwlidWYgKz0gIiNpbmNsdWRlIDxsaW51eC91dHNuYW1lLmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8bGludXgvaW5pdC5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD5cbiIKKwlidWYgKz0gIiNpbmNsdWRlIDxsaW51eC9rdGhyZWFkLmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8bGludXgvdHlwZXMuaD5cbiIKKwlidWYgKz0gIiNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD5cbiIKKwlidWYgKz0gIiNpbmNsdWRlIDxsaW51eC9jb25maWdmcy5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8YXNtL3VuYWxpZ25lZC5oPlxuXG4iCisJYnVmICs9ICIjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2Jhc2UuaD5cbiIKKwlidWYgKz0gIiNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdHJhbnNwb3J0Lmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19vcHMuaD5cbiIKKwlidWYgKz0gIiNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX2NvbmZpZ2ZzLmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19saWIuaD5cbiIKKwlidWYgKz0gIiNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfZGV2aWNlLmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX3RwZy5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9jb25maWdmcy5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9iYXNlLmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8dGFyZ2V0L2NvbmZpZ2ZzX21hY3Jvcy5oPlxuXG4iCisJYnVmICs9ICIjaW5jbHVkZSA8IiArIGZhYnJpY19tb2RfbmFtZSArICJfYmFzZS5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPCIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2ZhYnJpYy5oPlxuXG4iCisKKwlidWYgKz0gIi8qIExvY2FsIHBvaW50ZXIgdG8gYWxsb2NhdGVkIFRDTSBjb25maWdmcyBmYWJyaWMgbW9kdWxlICovXG4iCisJYnVmICs9ICJzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19jb25maWdmcyAqIiArIGZhYnJpY19tb2RfbmFtZSArICJfZmFicmljX2NvbmZpZ2ZzO1xuXG4iCisKKwlidWYgKz0gInN0YXRpYyBzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKiIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX21ha2Vfbm9kZWFjbChcbiIKKwlidWYgKz0gIglzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcsXG4iCisJYnVmICs9ICIJc3RydWN0IGNvbmZpZ19ncm91cCAqZ3JvdXAsXG4iCisJYnVmICs9ICIJY29uc3QgY2hhciAqbmFtZSlcbiIKKwlidWYgKz0gIntcbiIKKwlidWYgKz0gIglzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKnNlX25hY2wsICpzZV9uYWNsX25ldztcbiIKKwlidWYgKz0gIglzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfbmFjbCAqbmFjbDtcbiIKKworCWlmIHByb3RvX2lkZW50ID09ICJGQyIgb3IgcHJvdG9faWRlbnQgPT0gIlNBUyI6CisJCWJ1ZiArPSAiCXU2NCB3d3BuID0gMDtcbiIKKworCWJ1ZiArPSAiCXUzMiBuZXh1c19kZXB0aDtcblxuIgorCWJ1ZiArPSAiCS8qICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3BhcnNlX3d3bihuYW1lLCAmd3dwbiwgMSkgPCAwKVxuIgorCWJ1ZiArPSAiCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsgKi9cbiIKKwlidWYgKz0gIglzZV9uYWNsX25ldyA9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2FsbG9jX2ZhYnJpY19hY2woc2VfdHBnKTtcbiIKKwlidWYgKz0gIglpZiAoIShzZV9uYWNsX25ldykpXG4iCisJYnVmICs9ICIJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pO1xuIgorCWJ1ZiArPSAiLy8jd2FybmluZyBGSVhNRTogSGFyZGNvZGVkIG5leHVzIGRlcHRoIGluICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX21ha2Vfbm9kZWFjbCgpXG4iCisJYnVmICs9ICIJbmV4dXNfZGVwdGggPSAxO1xuIgorCWJ1ZiArPSAiCS8qXG4iCisJYnVmICs9ICIJICogc2VfbmFjbF9uZXcgbWF5IGJlIHJlbGVhc2VkIGJ5IGNvcmVfdHBnX2FkZF9pbml0aWF0b3Jfbm9kZV9hY2woKVxuIgorCWJ1ZiArPSAiCSAqIHdoZW4gY29udmVydGluZyBhIE5vZGVBQ0wgZnJvbSBkZW1vIG1vZGUgLT4gZXhwbGljdFxuIgorCWJ1ZiArPSAiCSAqL1xuIgorCWJ1ZiArPSAiCXNlX25hY2wgPSBjb3JlX3RwZ19hZGRfaW5pdGlhdG9yX25vZGVfYWNsKHNlX3RwZywgc2VfbmFjbF9uZXcsXG4iCisJYnVmICs9ICIJCQkJbmFtZSwgbmV4dXNfZGVwdGgpO1xuIgorCWJ1ZiArPSAiCWlmIChJU19FUlIoc2VfbmFjbCkpIHtcbiIKKwlidWYgKz0gIgkJIiArIGZhYnJpY19tb2RfbmFtZSArICJfcmVsZWFzZV9mYWJyaWNfYWNsKHNlX3RwZywgc2VfbmFjbF9uZXcpO1xuIgorCWJ1ZiArPSAiCQlyZXR1cm4gc2VfbmFjbDtcbiIKKwlidWYgKz0gIgl9XG4iCisJYnVmICs9ICIJLypcbiIKKwlidWYgKz0gIgkgKiBMb2NhdGUgb3VyIHN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl9uYWNsIGFuZCBzZXQgdGhlIEZDIE5wb3J0IFdXUE5cbiIKKwlidWYgKz0gIgkgKi9cbiIKKwlidWYgKz0gIgluYWNsID0gY29udGFpbmVyX29mKHNlX25hY2wsIHN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl9uYWNsLCBzZV9ub2RlX2FjbCk7XG4iCisKKwlpZiBwcm90b19pZGVudCA9PSAiRkMiIG9yIHByb3RvX2lkZW50ID09ICJTQVMiOgorCQlidWYgKz0gIgluYWNsLT4iICsgZmFicmljX21vZF9pbml0X3BvcnQgKyAiX3d3cG4gPSB3d3BuO1xuIgorCisJYnVmICs9ICIJLyogIiArIGZhYnJpY19tb2RfbmFtZSArICJfZm9ybWF0X3d3bigmbmFjbC0+IiArIGZhYnJpY19tb2RfaW5pdF9wb3J0ICsgIl9uYW1lWzBdLCAiICsgZmFicmljX21vZF9uYW1lLnVwcGVyKCkgKyAiX05BTUVMRU4sIHd3cG4pOyAqL1xuXG4iCisJYnVmICs9ICIJcmV0dXJuIHNlX25hY2w7XG4iCisJYnVmICs9ICJ9XG5cbiIKKwlidWYgKz0gInN0YXRpYyB2b2lkICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2Ryb3Bfbm9kZWFjbChzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKnNlX2FjbClcbiIKKwlidWYgKz0gIntcbiIKKwlidWYgKz0gIglzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfbmFjbCAqbmFjbCA9IGNvbnRhaW5lcl9vZihzZV9hY2wsXG4iCisJYnVmICs9ICIJCQkJc3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX25hY2wsIHNlX25vZGVfYWNsKTtcbiIKKwlidWYgKz0gIglrZnJlZShuYWNsKTtcbiIKKwlidWYgKz0gIn1cblxuIgorCisJYnVmICs9ICJzdGF0aWMgc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqIiArIGZhYnJpY19tb2RfbmFtZSArICJfbWFrZV90cGcoXG4iCisJYnVmICs9ICIJc3RydWN0IHNlX3d3biAqd3duLFxuIgorCWJ1ZiArPSAiCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLFxuIgorCWJ1ZiArPSAiCWNvbnN0IGNoYXIgKm5hbWUpXG4iCisJYnVmICs9ICJ7XG4iCisJYnVmICs9ICIJc3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiXyIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiKiIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiID0gY29udGFpbmVyX29mKHd3bixcbiIKKwlidWYgKz0gIgkJCXN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl8iICsgZmFicmljX21vZF9wb3J0ICsgIiwgIiArIGZhYnJpY19tb2RfcG9ydCArICJfd3duKTtcblxuIgorCWJ1ZiArPSAiCXN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl90cGcgKnRwZztcbiIKKwlidWYgKz0gIgl1bnNpZ25lZCBsb25nIHRwZ3Q7XG4iCisJYnVmICs9ICIJaW50IHJldDtcblxuIgorCWJ1ZiArPSAiCWlmIChzdHJzdHIobmFtZSwgXCJ0cGd0X1wiKSAhPSBuYW1lKVxuIgorCWJ1ZiArPSAiCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTtcbiIKKwlidWYgKz0gIglpZiAoc3RyaWN0X3N0cnRvdWwobmFtZSArIDUsIDEwLCAmdHBndCkgfHwgdHBndCA+IFVJTlRfTUFYKVxuIgorCWJ1ZiArPSAiCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTtcblxuIgorCWJ1ZiArPSAiCXRwZyA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl90cGcpLCBHRlBfS0VSTkVMKTtcbiIKKwlidWYgKz0gIglpZiAoISh0cGcpKSB7XG4iCisJYnVmICs9ICIJCXByaW50ayhLRVJOX0VSUiBcIlVuYWJsZSB0byBhbGxvY2F0ZSBzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfdHBnXCIpO1xuIgorCWJ1ZiArPSAiCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTtcbiIKKwlidWYgKz0gIgl9XG4iCisJYnVmICs9ICIJdHBnLT4iICsgZmFicmljX21vZF9wb3J0ICsgIiA9ICIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiO1xuIgorCWJ1ZiArPSAiCXRwZy0+IiArIGZhYnJpY19tb2RfcG9ydCArICJfdHBndCA9IHRwZ3Q7XG5cbiIKKwlidWYgKz0gIglyZXQgPSBjb3JlX3RwZ19yZWdpc3RlcigmIiArIGZhYnJpY19tb2RfbmFtZSArICJfZmFicmljX2NvbmZpZ2ZzLT50Zl9vcHMsIHd3bixcbiIKKwlidWYgKz0gIgkJCQkmdHBnLT5zZV90cGcsICh2b2lkICopdHBnLFxuIgorCWJ1ZiArPSAiCQkJCVRSQU5TUE9SVF9UUEdfVFlQRV9OT1JNQUwpO1xuIgorCWJ1ZiArPSAiCWlmIChyZXQgPCAwKSB7XG4iCisJYnVmICs9ICIJCWtmcmVlKHRwZyk7XG4iCisJYnVmICs9ICIJCXJldHVybiBOVUxMO1xuIgorCWJ1ZiArPSAiCX1cbiIKKwlidWYgKz0gIglyZXR1cm4gJnRwZy0+c2VfdHBnO1xuIgorCWJ1ZiArPSAifVxuXG4iCisJYnVmICs9ICJzdGF0aWMgdm9pZCAiICsgZmFicmljX21vZF9uYW1lICsgIl9kcm9wX3RwZyhzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcpXG4iCisJYnVmICs9ICJ7XG4iCisJYnVmICs9ICIJc3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3RwZyAqdHBnID0gY29udGFpbmVyX29mKHNlX3RwZyxcbiIKKwlidWYgKz0gIgkJCQlzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfdHBnLCBzZV90cGcpO1xuXG4iCisJYnVmICs9ICIJY29yZV90cGdfZGVyZWdpc3RlcihzZV90cGcpO1xuIgorCWJ1ZiArPSAiCWtmcmVlKHRwZyk7XG4iCisJYnVmICs9ICJ9XG5cbiIKKworCWJ1ZiArPSAic3RhdGljIHN0cnVjdCBzZV93d24gKiIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX21ha2VfIiArIGZhYnJpY19tb2RfcG9ydCArICIoXG4iCisJYnVmICs9ICIJc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKnRmLFxuIgorCWJ1ZiArPSAiCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLFxuIgorCWJ1ZiArPSAiCWNvbnN0IGNoYXIgKm5hbWUpXG4iCisJYnVmICs9ICJ7XG4iCisJYnVmICs9ICIJc3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiXyIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiICoiICsgZmFicmljX21vZF9wb3J0ICsgIjtcbiIKKworCWlmIHByb3RvX2lkZW50ID09ICJGQyIgb3IgcHJvdG9faWRlbnQgPT0gIlNBUyI6CisJCWJ1ZiArPSAiCXU2NCB3d3BuID0gMDtcblxuIgorCisJYnVmICs9ICIJLyogaWYgKCIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3BhcnNlX3d3bihuYW1lLCAmd3dwbiwgMSkgPCAwKVxuIgorCWJ1ZiArPSAiCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsgKi9cblxuIgorCWJ1ZiArPSAiCSIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiID0ga3phbGxvYyhzaXplb2Yoc3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiXyIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiKSwgR0ZQX0tFUk5FTCk7XG4iCisJYnVmICs9ICIJaWYgKCEoIiArIGZhYnJpY19tb2RfcG9ydCArICIpKSB7XG4iCisJYnVmICs9ICIJCXByaW50ayhLRVJOX0VSUiBcIlVuYWJsZSB0byBhbGxvY2F0ZSBzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfIiArIGZhYnJpY19tb2RfcG9ydCArICJcIik7XG4iCisJYnVmICs9ICIJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pO1xuIgorCWJ1ZiArPSAiCX1cbiIKKworCWlmIHByb3RvX2lkZW50ID09ICJGQyIgb3IgcHJvdG9faWRlbnQgPT0gIlNBUyI6CisJCWJ1ZiArPSAiCSIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiLT4iICsgZmFicmljX21vZF9wb3J0ICsgIl93d3BuID0gd3dwbjtcbiIKKworCWJ1ZiArPSAiCS8qICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2Zvcm1hdF93d24oJiIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiLT4iICsgZmFicmljX21vZF9wb3J0ICsgIl9uYW1lWzBdLCAiICsgZmFicmljX21vZF9uYW1lLnVwcGVyKCkgKyAiX19OQU1FTEVOLCB3d3BuKTsgKi9cblxuIgorCWJ1ZiArPSAiCXJldHVybiAmIiArIGZhYnJpY19tb2RfcG9ydCArICItPiIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiX3d3bjtcbiIKKwlidWYgKz0gIn1cblxuIgorCWJ1ZiArPSAic3RhdGljIHZvaWQgIiArIGZhYnJpY19tb2RfbmFtZSArICJfZHJvcF8iICsgZmFicmljX21vZF9wb3J0ICsgIihzdHJ1Y3Qgc2Vfd3duICp3d24pXG4iCisJYnVmICs9ICJ7XG4iCisJYnVmICs9ICIJc3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiXyIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiICoiICsgZmFicmljX21vZF9wb3J0ICsgIiA9IGNvbnRhaW5lcl9vZih3d24sXG4iCisJYnVmICs9ICIJCQkJc3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiXyIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiLCAiICsgZmFicmljX21vZF9wb3J0ICsgIl93d24pO1xuIgorCWJ1ZiArPSAiCWtmcmVlKCIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiKTtcbiIKKwlidWYgKz0gIn1cblxuIgorCWJ1ZiArPSAic3RhdGljIHNzaXplX3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfd3duX3Nob3dfYXR0cl92ZXJzaW9uKFxuIgorCWJ1ZiArPSAiCXN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzICp0ZixcbiIKKwlidWYgKz0gIgljaGFyICpwYWdlKVxuIgorCWJ1ZiArPSAie1xuIgorCWJ1ZiArPSAiCXJldHVybiBzcHJpbnRmKHBhZ2UsIFwiIiArIGZhYnJpY19tb2RfbmFtZS51cHBlcigpICsgIiBmYWJyaWMgbW9kdWxlICVzIG9uICVzLyVzXCJcbiIKKwlidWYgKz0gIgkJXCJvbiBcIlVUU19SRUxFQVNFXCJcXG5cIiwgIiArIGZhYnJpY19tb2RfbmFtZS51cHBlcigpICsgIl9WRVJTSU9OLCB1dHNuYW1lKCktPnN5c25hbWUsXG4iCisJYnVmICs9ICIJCXV0c25hbWUoKS0+bWFjaGluZSk7XG4iCisJYnVmICs9ICJ9XG5cbiIKKwlidWYgKz0gIlRGX1dXTl9BVFRSX1JPKCIgKyBmYWJyaWNfbW9kX25hbWUgKyAiLCB2ZXJzaW9uKTtcblxuIgorCWJ1ZiArPSAic3RhdGljIHN0cnVjdCBjb25maWdmc19hdHRyaWJ1dGUgKiIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3d3bl9hdHRyc1tdID0ge1xuIgorCWJ1ZiArPSAiCSYiICsgZmFicmljX21vZF9uYW1lICsgIl93d25fdmVyc2lvbi5hdHRyLFxuIgorCWJ1ZiArPSAiCU5VTEwsXG4iCisJYnVmICs9ICJ9O1xuXG4iCisKKwlidWYgKz0gInN0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcyAiICsgZmFicmljX21vZF9uYW1lICsgIl9vcHMgPSB7XG4iCisJYnVmICs9ICIJLmdldF9mYWJyaWNfbmFtZQkJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9nZXRfZmFicmljX25hbWUsXG4iCisJYnVmICs9ICIJLmdldF9mYWJyaWNfcHJvdG9faWRlbnQJCT0gIiArIGZhYnJpY19tb2RfbmFtZSArICJfZ2V0X2ZhYnJpY19wcm90b19pZGVudCxcbiIKKwlidWYgKz0gIgkudHBnX2dldF93d24JCQk9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2dldF9mYWJyaWNfd3duLFxuIgorCWJ1ZiArPSAiCS50cGdfZ2V0X3RhZwkJCT0gIiArIGZhYnJpY19tb2RfbmFtZSArICJfZ2V0X3RhZyxcbiIKKwlidWYgKz0gIgkudHBnX2dldF9kZWZhdWx0X2RlcHRoCQk9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2dldF9kZWZhdWx0X2RlcHRoLFxuIgorCWJ1ZiArPSAiCS50cGdfZ2V0X3ByX3RyYW5zcG9ydF9pZAk9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2dldF9wcl90cmFuc3BvcnRfaWQsXG4iCisJYnVmICs9ICIJLnRwZ19nZXRfcHJfdHJhbnNwb3J0X2lkX2xlbgk9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2dldF9wcl90cmFuc3BvcnRfaWRfbGVuLFxuIgorCWJ1ZiArPSAiCS50cGdfcGFyc2VfcHJfb3V0X3RyYW5zcG9ydF9pZAk9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3BhcnNlX3ByX291dF90cmFuc3BvcnRfaWQsXG4iCisJYnVmICs9ICIJLnRwZ19jaGVja19kZW1vX21vZGUJCT0gIiArIGZhYnJpY19tb2RfbmFtZSArICJfY2hlY2tfZmFsc2UsXG4iCisJYnVmICs9ICIJLnRwZ19jaGVja19kZW1vX21vZGVfY2FjaGUJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9jaGVja190cnVlLFxuIgorCWJ1ZiArPSAiCS50cGdfY2hlY2tfZGVtb19tb2RlX3dyaXRlX3Byb3RlY3QgPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9jaGVja190cnVlLFxuIgorCWJ1ZiArPSAiCS50cGdfY2hlY2tfcHJvZF9tb2RlX3dyaXRlX3Byb3RlY3QgPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9jaGVja19mYWxzZSxcbiIKKwlidWYgKz0gIgkudHBnX2FsbG9jX2ZhYnJpY19hY2wJCT0gIiArIGZhYnJpY19tb2RfbmFtZSArICJfYWxsb2NfZmFicmljX2FjbCxcbiIKKwlidWYgKz0gIgkudHBnX3JlbGVhc2VfZmFicmljX2FjbAkJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9yZWxlYXNlX2ZhYnJpY19hY2wsXG4iCisJYnVmICs9ICIJLnRwZ19nZXRfaW5zdF9pbmRleAkJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl90cGdfZ2V0X2luc3RfaW5kZXgsXG4iCisJYnVmICs9ICIJLnJlbGVhc2VfY21kX3RvX3Bvb2wJCT0gIiArIGZhYnJpY19tb2RfbmFtZSArICJfcmVsZWFzZV9jbWQsXG4iCisJYnVmICs9ICIJLnJlbGVhc2VfY21kX2RpcmVjdAkJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9yZWxlYXNlX2NtZCxcbiIKKwlidWYgKz0gIgkuc2h1dGRvd25fc2Vzc2lvbgkJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9zaHV0ZG93bl9zZXNzaW9uLFxuIgorCWJ1ZiArPSAiCS5jbG9zZV9zZXNzaW9uCQkJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9jbG9zZV9zZXNzaW9uLFxuIgorCWJ1ZiArPSAiCS5zdG9wX3Nlc3Npb24JCQk9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3N0b3Bfc2Vzc2lvbixcbiIKKwlidWYgKz0gIgkuZmFsbF9iYWNrX3RvX2VybDAJCT0gIiArIGZhYnJpY19tb2RfbmFtZSArICJfcmVzZXRfbmV4dXMsXG4iCisJYnVmICs9ICIJLnNlc3NfbG9nZ2VkX2luCQkJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9zZXNzX2xvZ2dlZF9pbixcbiIKKwlidWYgKz0gIgkuc2Vzc19nZXRfaW5kZXgJCQk9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3Nlc3NfZ2V0X2luZGV4LFxuIgorCWJ1ZiArPSAiCS5zZXNzX2dldF9pbml0aWF0b3Jfc2lkCQk9IE5VTEwsXG4iCisJYnVmICs9ICIJLndyaXRlX3BlbmRpbmcJCQk9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3dyaXRlX3BlbmRpbmcsXG4iCisJYnVmICs9ICIJLndyaXRlX3BlbmRpbmdfc3RhdHVzCQk9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3dyaXRlX3BlbmRpbmdfc3RhdHVzLFxuIgorCWJ1ZiArPSAiCS5zZXRfZGVmYXVsdF9ub2RlX2F0dHJpYnV0ZXMJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9zZXRfZGVmYXVsdF9ub2RlX2F0dHJzLFxuIgorCWJ1ZiArPSAiCS5nZXRfdGFza190YWcJCQk9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2dldF90YXNrX3RhZyxcbiIKKwlidWYgKz0gIgkuZ2V0X2NtZF9zdGF0ZQkJCT0gIiArIGZhYnJpY19tb2RfbmFtZSArICJfZ2V0X2NtZF9zdGF0ZSxcbiIKKwlidWYgKz0gIgkubmV3X2NtZF9mYWlsdXJlCQk9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX25ld19jbWRfZmFpbHVyZSxcbiIKKwlidWYgKz0gIgkucXVldWVfZGF0YV9pbgkJCT0gIiArIGZhYnJpY19tb2RfbmFtZSArICJfcXVldWVfZGF0YV9pbixcbiIKKwlidWYgKz0gIgkucXVldWVfc3RhdHVzCQkJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9xdWV1ZV9zdGF0dXMsXG4iCisJYnVmICs9ICIJLnF1ZXVlX3RtX3JzcAkJCT0gIiArIGZhYnJpY19tb2RfbmFtZSArICJfcXVldWVfdG1fcnNwLFxuIgorCWJ1ZiArPSAiCS5nZXRfZmFicmljX3NlbnNlX2xlbgkJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9nZXRfZmFicmljX3NlbnNlX2xlbixcbiIKKwlidWYgKz0gIgkuc2V0X2ZhYnJpY19zZW5zZV9sZW4JCT0gIiArIGZhYnJpY19tb2RfbmFtZSArICJfc2V0X2ZhYnJpY19zZW5zZV9sZW4sXG4iCisJYnVmICs9ICIJLmlzX3N0YXRlX3JlbW92ZQkJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9pc19zdGF0ZV9yZW1vdmUsXG4iCisJYnVmICs9ICIJLnBhY2tfbHVuCQkJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9wYWNrX2x1bixcbiIKKwlidWYgKz0gIgkvKlxuIgorCWJ1ZiArPSAiCSAqIFNldHVwIGZ1bmN0aW9uIHBvaW50ZXJzIGZvciBnZW5lcmljIGxvZ2ljIGluIHRhcmdldF9jb3JlX2ZhYnJpY19jb25maWdmcy5jXG4iCisJYnVmICs9ICIJICovXG4iCisJYnVmICs9ICIJLmZhYnJpY19tYWtlX3d3bgkJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9tYWtlXyIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiLFxuIgorCWJ1ZiArPSAiCS5mYWJyaWNfZHJvcF93d24JCT0gIiArIGZhYnJpY19tb2RfbmFtZSArICJfZHJvcF8iICsgZmFicmljX21vZF9wb3J0ICsgIixcbiIKKwlidWYgKz0gIgkuZmFicmljX21ha2VfdHBnCQk9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX21ha2VfdHBnLFxuIgorCWJ1ZiArPSAiCS5mYWJyaWNfZHJvcF90cGcJCT0gIiArIGZhYnJpY19tb2RfbmFtZSArICJfZHJvcF90cGcsXG4iCisJYnVmICs9ICIJLmZhYnJpY19wb3N0X2xpbmsJCT0gTlVMTCxcbiIKKwlidWYgKz0gIgkuZmFicmljX3ByZV91bmxpbmsJCT0gTlVMTCxcbiIKKwlidWYgKz0gIgkuZmFicmljX21ha2VfbnAJCQk9IE5VTEwsXG4iCisJYnVmICs9ICIJLmZhYnJpY19kcm9wX25wCQkJPSBOVUxMLFxuIgorCWJ1ZiArPSAiCS5mYWJyaWNfbWFrZV9ub2RlYWNsCQk9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX21ha2Vfbm9kZWFjbCxcbiIKKwlidWYgKz0gIgkuZmFicmljX2Ryb3Bfbm9kZWFjbAkJPSAiICsgZmFicmljX21vZF9uYW1lICsgIl9kcm9wX25vZGVhY2wsXG4iCisJYnVmICs9ICJ9O1xuXG4iCisKKwlidWYgKz0gInN0YXRpYyBpbnQgIiArIGZhYnJpY19tb2RfbmFtZSArICJfcmVnaXN0ZXJfY29uZmlnZnModm9pZClcbiIKKwlidWYgKz0gIntcbiIKKwlidWYgKz0gIglzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19jb25maWdmcyAqZmFicmljO1xuIgorCWJ1ZiArPSAiCWludCByZXQ7XG5cbiIKKwlidWYgKz0gIglwcmludGsoS0VSTl9JTkZPIFwiIiArIGZhYnJpY19tb2RfbmFtZS51cHBlcigpICsgIiBmYWJyaWMgbW9kdWxlICVzIG9uICVzLyVzXCJcbiIKKwlidWYgKz0gIgkJXCIgb24gXCJVVFNfUkVMRUFTRVwiXFxuXCIsIiArIGZhYnJpY19tb2RfbmFtZS51cHBlcigpICsgIl9WRVJTSU9OLCB1dHNuYW1lKCktPnN5c25hbWUsXG4iCisJYnVmICs9ICIJCXV0c25hbWUoKS0+bWFjaGluZSk7XG4iCisJYnVmICs9ICIJLypcbiIKKwlidWYgKz0gIgkgKiBSZWdpc3RlciB0aGUgdG9wIGxldmVsIHN0cnVjdCBjb25maWdfaXRlbV90eXBlIHdpdGggVENNIGNvcmVcbiIKKwlidWYgKz0gIgkgKi9cbiIKKwlidWYgKz0gIglmYWJyaWMgPSB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzX2luaXQoVEhJU19NT0RVTEUsIFwiIiArIGZhYnJpY19tb2RfbmFtZVs0Ol0gKyAiXCIpO1xuIgorCWJ1ZiArPSAiCWlmICghKGZhYnJpYykpIHtcbiIKKwlidWYgKz0gIgkJcHJpbnRrKEtFUk5fRVJSIFwidGFyZ2V0X2ZhYnJpY19jb25maWdmc19pbml0KCkgZmFpbGVkXFxuXCIpO1xuIgorCWJ1ZiArPSAiCQlyZXR1cm4gLUVOT01FTTtcbiIKKwlidWYgKz0gIgl9XG4iCisJYnVmICs9ICIJLypcbiIKKwlidWYgKz0gIgkgKiBTZXR1cCBmYWJyaWMtPnRmX29wcyBmcm9tIG91ciBsb2NhbCAiICsgZmFicmljX21vZF9uYW1lICsgIl9vcHNcbiIKKwlidWYgKz0gIgkgKi9cbiIKKwlidWYgKz0gIglmYWJyaWMtPnRmX29wcyA9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX29wcztcbiIKKwlidWYgKz0gIgkvKlxuIgorCWJ1ZiArPSAiCSAqIFNldHVwIGRlZmF1bHQgYXR0cmlidXRlIGxpc3RzIGZvciB2YXJpb3VzIGZhYnJpYy0+dGZfY2l0X3RtcGxcbiIKKwlidWYgKz0gIgkgKi9cbiIKKwlidWYgKz0gIglURl9DSVRfVE1QTChmYWJyaWMpLT50ZmNfd3duX2NpdC5jdF9hdHRycyA9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3d3bl9hdHRycztcbiIKKwlidWYgKz0gIglURl9DSVRfVE1QTChmYWJyaWMpLT50ZmNfdHBnX2Jhc2VfY2l0LmN0X2F0dHJzID0gTlVMTDtcbiIKKwlidWYgKz0gIglURl9DSVRfVE1QTChmYWJyaWMpLT50ZmNfdHBnX2F0dHJpYl9jaXQuY3RfYXR0cnMgPSBOVUxMO1xuIgorCWJ1ZiArPSAiCVRGX0NJVF9UTVBMKGZhYnJpYyktPnRmY190cGdfcGFyYW1fY2l0LmN0X2F0dHJzID0gTlVMTDtcbiIKKwlidWYgKz0gIglURl9DSVRfVE1QTChmYWJyaWMpLT50ZmNfdHBnX25wX2Jhc2VfY2l0LmN0X2F0dHJzID0gTlVMTDtcbiIKKwlidWYgKz0gIglURl9DSVRfVE1QTChmYWJyaWMpLT50ZmNfdHBnX25hY2xfYmFzZV9jaXQuY3RfYXR0cnMgPSBOVUxMO1xuIgorCWJ1ZiArPSAiCVRGX0NJVF9UTVBMKGZhYnJpYyktPnRmY190cGdfbmFjbF9hdHRyaWJfY2l0LmN0X2F0dHJzID0gTlVMTDtcbiIKKwlidWYgKz0gIglURl9DSVRfVE1QTChmYWJyaWMpLT50ZmNfdHBnX25hY2xfYXV0aF9jaXQuY3RfYXR0cnMgPSBOVUxMO1xuIgorCWJ1ZiArPSAiCVRGX0NJVF9UTVBMKGZhYnJpYyktPnRmY190cGdfbmFjbF9wYXJhbV9jaXQuY3RfYXR0cnMgPSBOVUxMO1xuIgorCWJ1ZiArPSAiCS8qXG4iCisJYnVmICs9ICIJICogUmVnaXN0ZXIgdGhlIGZhYnJpYyBmb3IgdXNlIHdpdGhpbiBUQ01cbiIKKwlidWYgKz0gIgkgKi9cbiIKKwlidWYgKz0gIglyZXQgPSB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzX3JlZ2lzdGVyKGZhYnJpYyk7XG4iCisJYnVmICs9ICIJaWYgKHJldCA8IDApIHtcbiIKKwlidWYgKz0gIgkJcHJpbnRrKEtFUk5fRVJSIFwidGFyZ2V0X2ZhYnJpY19jb25maWdmc19yZWdpc3RlcigpIGZhaWxlZFwiXG4iCisJYnVmICs9ICIJCQkJXCIgZm9yICIgKyBmYWJyaWNfbW9kX25hbWUudXBwZXIoKSArICJcXG5cIik7XG4iCisJYnVmICs9ICIJCXJldHVybiByZXQ7XG4iCisJYnVmICs9ICIJfVxuIgorCWJ1ZiArPSAiCS8qXG4iCisJYnVmICs9ICIJICogU2V0dXAgb3VyIGxvY2FsIHBvaW50ZXIgdG8gKmZhYnJpY1xuIgorCWJ1ZiArPSAiCSAqL1xuIgorCWJ1ZiArPSAiCSIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2ZhYnJpY19jb25maWdmcyA9IGZhYnJpYztcbiIKKwlidWYgKz0gIglwcmludGsoS0VSTl9JTkZPIFwiIiArICBmYWJyaWNfbW9kX25hbWUudXBwZXIoKSArICJbMF0gLSBTZXQgZmFicmljIC0+ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2ZhYnJpY19jb25maWdmc1xcblwiKTtcbiIKKwlidWYgKz0gIglyZXR1cm4gMDtcbiIKKwlidWYgKz0gIn07XG5cbiIKKwlidWYgKz0gInN0YXRpYyB2b2lkICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2RlcmVnaXN0ZXJfY29uZmlnZnModm9pZClcbiIKKwlidWYgKz0gIntcbiIKKwlidWYgKz0gIglpZiAoISgiICsgZmFicmljX21vZF9uYW1lICsgIl9mYWJyaWNfY29uZmlnZnMpKVxuIgorCWJ1ZiArPSAiCQlyZXR1cm47XG5cbiIKKwlidWYgKz0gIgl0YXJnZXRfZmFicmljX2NvbmZpZ2ZzX2RlcmVnaXN0ZXIoIiArIGZhYnJpY19tb2RfbmFtZSArICJfZmFicmljX2NvbmZpZ2ZzKTtcbiIKKwlidWYgKz0gIgkiICsgZmFicmljX21vZF9uYW1lICsgIl9mYWJyaWNfY29uZmlnZnMgPSBOVUxMO1xuIgorCWJ1ZiArPSAiCXByaW50ayhLRVJOX0lORk8gXCIiICsgIGZhYnJpY19tb2RfbmFtZS51cHBlcigpICsgIlswXSAtIENsZWFyZWQgIiArIGZhYnJpY19tb2RfbmFtZSArICJfZmFicmljX2NvbmZpZ2ZzXFxuXCIpO1xuIgorCWJ1ZiArPSAifTtcblxuIgorCisJYnVmICs9ICJzdGF0aWMgaW50IF9faW5pdCAiICsgZmFicmljX21vZF9uYW1lICsgIl9pbml0KHZvaWQpXG4iCisJYnVmICs9ICJ7XG4iCisJYnVmICs9ICIJaW50IHJldDtcblxuIgorCWJ1ZiArPSAiCXJldCA9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3JlZ2lzdGVyX2NvbmZpZ2ZzKCk7XG4iCisJYnVmICs9ICIJaWYgKHJldCA8IDApXG4iCisJYnVmICs9ICIJCXJldHVybiByZXQ7XG5cbiIKKwlidWYgKz0gIglyZXR1cm4gMDtcbiIKKwlidWYgKz0gIn07XG5cbiIKKwlidWYgKz0gInN0YXRpYyB2b2lkICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2V4aXQodm9pZClcbiIKKwlidWYgKz0gIntcbiIKKwlidWYgKz0gIgkiICsgZmFicmljX21vZF9uYW1lICsgIl9kZXJlZ2lzdGVyX2NvbmZpZ2ZzKCk7XG4iCisJYnVmICs9ICJ9O1xuXG4iCisKKwlidWYgKz0gIiNpZmRlZiBNT0RVTEVcbiIKKwlidWYgKz0gIk1PRFVMRV9ERVNDUklQVElPTihcIiIgKyBmYWJyaWNfbW9kX25hbWUudXBwZXIoKSArICIgc2VyaWVzIGZhYnJpYyBkcml2ZXJcIik7XG4iCisJYnVmICs9ICJNT0RVTEVfTElDRU5TRShcIkdQTFwiKTtcbiIKKwlidWYgKz0gIm1vZHVsZV9pbml0KCIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2luaXQpO1xuIgorCWJ1ZiArPSAibW9kdWxlX2V4aXQoIiArIGZhYnJpY19tb2RfbmFtZSArICJfZXhpdCk7XG4iCisJYnVmICs9ICIjZW5kaWZcbiIKKworCXJldCA9IHAud3JpdGUoYnVmKQorCWlmIHJldDoKKwkJdGNtX21vZF9lcnIoIlVuYWJsZSB0byB3cml0ZSBmOiAiICsgZikKKworCXAuY2xvc2UoKQorCisJcmV0dXJuCisKK2RlZiB0Y21fbW9kX3NjYW5fZmFicmljX29wcyh0Y21fZGlyKToKKworCWZhYnJpY19vcHNfYXBpID0gdGNtX2RpciArICJpbmNsdWRlL3RhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfb3BzLmgiCisKKwlwcmludCAiVXNpbmcgdGNtX21vZF9zY2FuX2ZhYnJpY19vcHM6ICIgKyBmYWJyaWNfb3BzX2FwaQorCXByb2Nlc3NfZm8gPSAwOworCisJcCA9IG9wZW4oZmFicmljX29wc19hcGksICdyJykKKworCWxpbmUgPSBwLnJlYWRsaW5lKCkKKwl3aGlsZSBsaW5lOgorCQlpZiBwcm9jZXNzX2ZvID09IDAgYW5kIHJlLnNlYXJjaCgnc3RydWN0IHRhcmdldF9jb3JlX2ZhYnJpY19vcHMgeycsIGxpbmUpOgorCQkJbGluZSA9IHAucmVhZGxpbmUoKQorCQkJY29udGludWUKKworCQlpZiBwcm9jZXNzX2ZvID09IDA6CisJCQlwcm9jZXNzX2ZvID0gMTsKKwkJCWxpbmUgPSBwLnJlYWRsaW5lKCkKKwkJCSMgU2VhcmNoIGZvciBmdW5jdGlvbiBwb2ludGVyCisJCQlpZiBub3QgcmUuc2VhcmNoKCdcKFwqJywgbGluZSk6CisJCQkJY29udGludWUKKworCQkJZmFicmljX29wcy5hcHBlbmQobGluZS5yc3RyaXAoKSkKKwkJCWNvbnRpbnVlCisKKwkJbGluZSA9IHAucmVhZGxpbmUoKQorCQkjIFNlYXJjaCBmb3IgZnVuY3Rpb24gcG9pbnRlcgorCQlpZiBub3QgcmUuc2VhcmNoKCdcKFwqJywgbGluZSk6CisJCQljb250aW51ZQorCisJCWZhYnJpY19vcHMuYXBwZW5kKGxpbmUucnN0cmlwKCkpCisKKwlwLmNsb3NlKCkKKwlyZXR1cm4KKworZGVmIHRjbV9tb2RfZHVtcF9mYWJyaWNfb3BzKHByb3RvX2lkZW50LCBmYWJyaWNfbW9kX2Rpcl92YXIsIGZhYnJpY19tb2RfbmFtZSk6CisJYnVmID0gIiIKKwlidWZpID0gIiIKKworCWYgPSBmYWJyaWNfbW9kX2Rpcl92YXIgKyAiLyIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2ZhYnJpYy5jIgorCXByaW50ICJXcml0aW5nIGZpbGU6ICIgKyBmCisKKwlwID0gb3BlbihmLCAndycpCisJaWYgbm90IHA6CisJCXRjbV9tb2RfZXJyKCJVbmFibGUgdG8gb3BlbiBmaWxlOiAiICsgZikKKworCWZpID0gZmFicmljX21vZF9kaXJfdmFyICsgIi8iICsgZmFicmljX21vZF9uYW1lICsgIl9mYWJyaWMuaCIKKwlwcmludCAiV3JpdGluZyBmaWxlOiAiICsgZmkKKworCXBpID0gb3BlbihmaSwgJ3cnKQorCWlmIG5vdCBwaToKKwkJdGNtX21vZF9lcnIoIlVuYWJsZSB0byBvcGVuIGZpbGU6ICIgKyBmaSkKKworCWJ1ZiA9ICIjaW5jbHVkZSA8bGludXgvc2xhYi5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPGxpbnV4L2t0aHJlYWQuaD5cbiIKKwlidWYgKz0gIiNpbmNsdWRlIDxsaW51eC90eXBlcy5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD5cbiIKKwlidWYgKz0gIiNpbmNsdWRlIDxsaW51eC90eXBlcy5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8YXNtL3VuYWxpZ25lZC5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPHNjc2kvc2NzaS5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPHNjc2kvc2NzaV9ob3N0Lmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8c2NzaS9zY3NpX2RldmljZS5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPHNjc2kvc2NzaV9jbW5kLmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8c2NzaS9saWJmYy5oPlxuXG4iCisJYnVmICs9ICIjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2Jhc2UuaD5cbiIKKwlidWYgKz0gIiNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdHJhbnNwb3J0Lmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19vcHMuaD5cbiIKKwlidWYgKz0gIiNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX2xpYi5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuaD5cbiIKKwlidWYgKz0gIiNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdHBnLmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2NvbmZpZ2ZzLmg+XG4iCisJYnVmICs9ICIjaW5jbHVkZSA8IiArIGZhYnJpY19tb2RfbmFtZSArICJfYmFzZS5oPlxuIgorCWJ1ZiArPSAiI2luY2x1ZGUgPCIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2ZhYnJpYy5oPlxuXG4iCisKKwlidWYgKz0gImludCAiICsgZmFicmljX21vZF9uYW1lICsgIl9jaGVja190cnVlKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZylcbiIKKwlidWYgKz0gIntcbiIKKwlidWYgKz0gIglyZXR1cm4gMTtcbiIKKwlidWYgKz0gIn1cblxuIgorCWJ1ZmkgKz0gImludCAiICsgZmFicmljX21vZF9uYW1lICsgIl9jaGVja190cnVlKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKik7XG4iCisKKwlidWYgKz0gImludCAiICsgZmFicmljX21vZF9uYW1lICsgIl9jaGVja19mYWxzZShzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcpXG4iCisJYnVmICs9ICJ7XG4iCisJYnVmICs9ICIJcmV0dXJuIDA7XG4iCisJYnVmICs9ICJ9XG5cbiIKKwlidWZpICs9ICJpbnQgIiArIGZhYnJpY19tb2RfbmFtZSArICJfY2hlY2tfZmFsc2Uoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqKTtcbiIKKworCXRvdGFsX2ZhYnJpY19vcHMgPSBsZW4oZmFicmljX29wcykKKwlpID0gMAorCisJd2hpbGUgaSA8IHRvdGFsX2ZhYnJpY19vcHM6CisJCWZvID0gZmFicmljX29wc1tpXQorCQlpICs9IDEKKyMJCXByaW50ICJmYWJyaWNfb3BzOiAiICsgZm8KKworCQlpZiByZS5zZWFyY2goJ2dldF9mYWJyaWNfbmFtZScsIGZvKToKKwkJCWJ1ZiArPSAiY2hhciAqIiArIGZhYnJpY19tb2RfbmFtZSArICJfZ2V0X2ZhYnJpY19uYW1lKHZvaWQpXG4iCisJCQlidWYgKz0gIntcbiIKKwkJCWJ1ZiArPSAiCXJldHVybiBcIiIgKyBmYWJyaWNfbW9kX25hbWVbNDpdICsgIlwiO1xuIgorCQkJYnVmICs9ICJ9XG5cbiIKKwkJCWJ1ZmkgKz0gImNoYXIgKiIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2dldF9mYWJyaWNfbmFtZSh2b2lkKTtcbiIKKwkJCWNvbnRpbnVlCisKKwkJaWYgcmUuc2VhcmNoKCdnZXRfZmFicmljX3Byb3RvX2lkZW50JywgZm8pOgorCQkJYnVmICs9ICJ1OCAiICsgZmFicmljX21vZF9uYW1lICsgIl9nZXRfZmFicmljX3Byb3RvX2lkZW50KHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZylcbiIKKwkJCWJ1ZiArPSAie1xuIgorCQkJYnVmICs9ICIJc3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3RwZyAqdHBnID0gY29udGFpbmVyX29mKHNlX3RwZyxcbiIKKwkJCWJ1ZiArPSAiCQkJCXN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl90cGcsIHNlX3RwZyk7XG4iCisJCQlidWYgKz0gIglzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfIiArIGZhYnJpY19tb2RfcG9ydCArICIgKiIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiID0gdHBnLT4iICsgZmFicmljX21vZF9wb3J0ICsgIjtcbiIKKwkJCWJ1ZiArPSAiCXU4IHByb3RvX2lkO1xuXG4iCisJCQlidWYgKz0gIglzd2l0Y2ggKCIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiLT4iICsgZmFicmljX21vZF9wb3J0ICsgIl9wcm90b19pZCkge1xuIgorCQkJaWYgcHJvdG9faWRlbnQgPT0gIkZDIjoKKwkJCQlidWYgKz0gIgljYXNlIFNDU0lfUFJPVE9DT0xfRkNQOlxuIgorCQkJCWJ1ZiArPSAiCWRlZmF1bHQ6XG4iCisJCQkJYnVmICs9ICIJCXByb3RvX2lkID0gZmNfZ2V0X2ZhYnJpY19wcm90b19pZGVudChzZV90cGcpO1xuIgorCQkJCWJ1ZiArPSAiCQlicmVhaztcbiIKKwkJCWVsaWYgcHJvdG9faWRlbnQgPT0gIlNBUyI6CisJCQkJYnVmICs9ICIJY2FzZSBTQ1NJX1BST1RPQ09MX1NBUzpcbiIKKwkJCQlidWYgKz0gIglkZWZhdWx0OlxuIgorCQkJCWJ1ZiArPSAiCQlwcm90b19pZCA9IHNhc19nZXRfZmFicmljX3Byb3RvX2lkZW50KHNlX3RwZyk7XG4iCisJCQkJYnVmICs9ICIJCWJyZWFrO1xuIgorCQkJZWxpZiBwcm90b19pZGVudCA9PSAiaVNDU0kiOgorCQkJCWJ1ZiArPSAiCWNhc2UgU0NTSV9QUk9UT0NPTF9JU0NTSTpcbiIKKwkJCQlidWYgKz0gIglkZWZhdWx0OlxuIgorCQkJCWJ1ZiArPSAiCQlwcm90b19pZCA9IGlzY3NpX2dldF9mYWJyaWNfcHJvdG9faWRlbnQoc2VfdHBnKTtcbiIKKwkJCQlidWYgKz0gIgkJYnJlYWs7XG4iCisKKwkJCWJ1ZiArPSAiCX1cblxuIgorCQkJYnVmICs9ICIJcmV0dXJuIHByb3RvX2lkO1xuIgorCQkJYnVmICs9ICJ9XG5cbiIKKwkJCWJ1ZmkgKz0gInU4ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2dldF9mYWJyaWNfcHJvdG9faWRlbnQoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqKTtcbiIKKworCQlpZiByZS5zZWFyY2goJ2dldF93d24nLCBmbyk6CisJCQlidWYgKz0gImNoYXIgKiIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2dldF9mYWJyaWNfd3duKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZylcbiIKKwkJCWJ1ZiArPSAie1xuIgorCQkJYnVmICs9ICIJc3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3RwZyAqdHBnID0gY29udGFpbmVyX29mKHNlX3RwZyxcbiIKKwkJCWJ1ZiArPSAiCQkJCXN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl90cGcsIHNlX3RwZyk7XG4iCisJCQlidWYgKz0gIglzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfIiArIGZhYnJpY19tb2RfcG9ydCArICIgKiIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiID0gdHBnLT4iICsgZmFicmljX21vZF9wb3J0ICsgIjtcblxuIgorCQkJYnVmICs9ICIJcmV0dXJuICYiICsgZmFicmljX21vZF9wb3J0ICsgIi0+IiArIGZhYnJpY19tb2RfcG9ydCArICJfbmFtZVswXTtcbiIKKwkJCWJ1ZiArPSAifVxuXG4iCisJCQlidWZpICs9ICJjaGFyICoiICsgZmFicmljX21vZF9uYW1lICsgIl9nZXRfZmFicmljX3d3bihzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICopO1xuIgorCisJCWlmIHJlLnNlYXJjaCgnZ2V0X3RhZycsIGZvKToKKwkJCWJ1ZiArPSAidTE2ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2dldF90YWcoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfdHBnICp0cGcgPSBjb250YWluZXJfb2Yoc2VfdHBnLFxuIgorCQkJYnVmICs9ICIJCQkJc3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3RwZywgc2VfdHBnKTtcbiIKKwkJCWJ1ZiArPSAiCXJldHVybiB0cGctPiIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiX3RwZ3Q7XG4iCisJCQlidWYgKz0gIn1cblxuIgorCQkJYnVmaSArPSAidTE2ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2dldF90YWcoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqKTtcbiIKKworCQlpZiByZS5zZWFyY2goJ2dldF9kZWZhdWx0X2RlcHRoJywgZm8pOgorCQkJYnVmICs9ICJ1MzIgIiArIGZhYnJpY19tb2RfbmFtZSArICJfZ2V0X2RlZmF1bHRfZGVwdGgoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglyZXR1cm4gMTtcbiIKKwkJCWJ1ZiArPSAifVxuXG4iCisJCQlidWZpICs9ICJ1MzIgIiArIGZhYnJpY19tb2RfbmFtZSArICJfZ2V0X2RlZmF1bHRfZGVwdGgoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqKTtcbiIKKworCQlpZiByZS5zZWFyY2goJ2dldF9wcl90cmFuc3BvcnRfaWRcKVwoJywgZm8pOgorCQkJYnVmICs9ICJ1MzIgIiArIGZhYnJpY19tb2RfbmFtZSArICJfZ2V0X3ByX3RyYW5zcG9ydF9pZChcbiIKKwkJCWJ1ZiArPSAiCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZyxcbiIKKwkJCWJ1ZiArPSAiCXN0cnVjdCBzZV9ub2RlX2FjbCAqc2VfbmFjbCxcbiIKKwkJCWJ1ZiArPSAiCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsXG4iCisJCQlidWYgKz0gIglpbnQgKmZvcm1hdF9jb2RlLFxuIgorCQkJYnVmICs9ICIJdW5zaWduZWQgY2hhciAqYnVmKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfdHBnICp0cGcgPSBjb250YWluZXJfb2Yoc2VfdHBnLFxuIgorCQkJYnVmICs9ICIJCQkJc3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3RwZywgc2VfdHBnKTtcbiIKKwkJCWJ1ZiArPSAiCXN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl8iICsgZmFicmljX21vZF9wb3J0ICsgIiAqIiArIGZhYnJpY19tb2RfcG9ydCArICIgPSB0cGctPiIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiO1xuIgorCQkJYnVmICs9ICIJaW50IHJldCA9IDA7XG5cbiIKKwkJCWJ1ZiArPSAiCXN3aXRjaCAoIiArIGZhYnJpY19tb2RfcG9ydCArICItPiIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiX3Byb3RvX2lkKSB7XG4iCisJCQlpZiBwcm90b19pZGVudCA9PSAiRkMiOgorCQkJCWJ1ZiArPSAiCWNhc2UgU0NTSV9QUk9UT0NPTF9GQ1A6XG4iCisJCQkJYnVmICs9ICIJZGVmYXVsdDpcbiIKKwkJCQlidWYgKz0gIgkJcmV0ID0gZmNfZ2V0X3ByX3RyYW5zcG9ydF9pZChzZV90cGcsIHNlX25hY2wsIHByX3JlZyxcbiIKKwkJCQlidWYgKz0gIgkJCQkJZm9ybWF0X2NvZGUsIGJ1Zik7XG4iCisJCQkJYnVmICs9ICIJCWJyZWFrO1xuIgorCQkJZWxpZiBwcm90b19pZGVudCA9PSAiU0FTIjoKKwkJCQlidWYgKz0gIgljYXNlIFNDU0lfUFJPVE9DT0xfU0FTOlxuIgorCQkJCWJ1ZiArPSAiCWRlZmF1bHQ6XG4iCisJCQkJYnVmICs9ICIJCXJldCA9IHNhc19nZXRfcHJfdHJhbnNwb3J0X2lkKHNlX3RwZywgc2VfbmFjbCwgcHJfcmVnLFxuIgorCQkJCWJ1ZiArPSAiCQkJCQlmb3JtYXRfY29kZSwgYnVmKTtcbiIKKwkJCQlidWYgKz0gIgkJYnJlYWs7XG4iCisJCQllbGlmIHByb3RvX2lkZW50ID09ICJpU0NTSSI6CisJCQkJYnVmICs9ICIJY2FzZSBTQ1NJX1BST1RPQ09MX0lTQ1NJOlxuIgorCQkJCWJ1ZiArPSAiCWRlZmF1bHQ6XG4iCisJCQkJYnVmICs9ICIJCXJldCA9IGlzY3NpX2dldF9wcl90cmFuc3BvcnRfaWQoc2VfdHBnLCBzZV9uYWNsLCBwcl9yZWcsXG4iCisJCQkJYnVmICs9ICIJCQkJCWZvcm1hdF9jb2RlLCBidWYpO1xuIgorCQkJCWJ1ZiArPSAiCQlicmVhaztcbiIKKworCQkJYnVmICs9ICIJfVxuXG4iCisJCQlidWYgKz0gIglyZXR1cm4gcmV0O1xuIgorCQkJYnVmICs9ICJ9XG5cbiIKKwkJCWJ1ZmkgKz0gInUzMiAiICsgZmFicmljX21vZF9uYW1lICsgIl9nZXRfcHJfdHJhbnNwb3J0X2lkKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKixcbiIKKwkJCWJ1ZmkgKz0gIgkJCXN0cnVjdCBzZV9ub2RlX2FjbCAqLCBzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqLFxuIgorCQkJYnVmaSArPSAiCQkJaW50ICosIHVuc2lnbmVkIGNoYXIgKik7XG4iCisKKwkJaWYgcmUuc2VhcmNoKCdnZXRfcHJfdHJhbnNwb3J0X2lkX2xlblwpXCgnLCBmbyk6CisJCQlidWYgKz0gInUzMiAiICsgZmFicmljX21vZF9uYW1lICsgIl9nZXRfcHJfdHJhbnNwb3J0X2lkX2xlbihcbiIKKwkJCWJ1ZiArPSAiCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZyxcbiIKKwkJCWJ1ZiArPSAiCXN0cnVjdCBzZV9ub2RlX2FjbCAqc2VfbmFjbCxcbiIKKwkJCWJ1ZiArPSAiCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsXG4iCisJCQlidWYgKz0gIglpbnQgKmZvcm1hdF9jb2RlKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfdHBnICp0cGcgPSBjb250YWluZXJfb2Yoc2VfdHBnLFxuIgorCQkJYnVmICs9ICIJCQkJc3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3RwZywgc2VfdHBnKTtcbiIKKwkJCWJ1ZiArPSAiCXN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl8iICsgZmFicmljX21vZF9wb3J0ICsgIiAqIiArIGZhYnJpY19tb2RfcG9ydCArICIgPSB0cGctPiIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiO1xuIgorCQkJYnVmICs9ICIJaW50IHJldCA9IDA7XG5cbiIKKwkJCWJ1ZiArPSAiCXN3aXRjaCAoIiArIGZhYnJpY19tb2RfcG9ydCArICItPiIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiX3Byb3RvX2lkKSB7XG4iCisJCQlpZiBwcm90b19pZGVudCA9PSAiRkMiOgorCQkJCWJ1ZiArPSAiCWNhc2UgU0NTSV9QUk9UT0NPTF9GQ1A6XG4iCisJCQkJYnVmICs9ICIJZGVmYXVsdDpcbiIKKwkJCQlidWYgKz0gIgkJcmV0ID0gZmNfZ2V0X3ByX3RyYW5zcG9ydF9pZF9sZW4oc2VfdHBnLCBzZV9uYWNsLCBwcl9yZWcsXG4iCisJCQkJYnVmICs9ICIJCQkJCWZvcm1hdF9jb2RlKTtcbiIKKwkJCQlidWYgKz0gIgkJYnJlYWs7XG4iCisJCQllbGlmIHByb3RvX2lkZW50ID09ICJTQVMiOgorCQkJCWJ1ZiArPSAiCWNhc2UgU0NTSV9QUk9UT0NPTF9TQVM6XG4iCisJCQkJYnVmICs9ICIJZGVmYXVsdDpcbiIKKwkJCQlidWYgKz0gIgkJcmV0ID0gc2FzX2dldF9wcl90cmFuc3BvcnRfaWRfbGVuKHNlX3RwZywgc2VfbmFjbCwgcHJfcmVnLFxuIgorCQkJCWJ1ZiArPSAiCQkJCQlmb3JtYXRfY29kZSk7XG4iCisJCQkJYnVmICs9ICIJCWJyZWFrO1xuIgorCQkJZWxpZiBwcm90b19pZGVudCA9PSAiaVNDU0kiOgorCQkJCWJ1ZiArPSAiCWNhc2UgU0NTSV9QUk9UT0NPTF9JU0NTSTpcbiIKKwkJCQlidWYgKz0gIglkZWZhdWx0OlxuIgorCQkJCWJ1ZiArPSAiCQlyZXQgPSBpc2NzaV9nZXRfcHJfdHJhbnNwb3J0X2lkX2xlbihzZV90cGcsIHNlX25hY2wsIHByX3JlZyxcbiIKKwkJCQlidWYgKz0gIgkJCQkJZm9ybWF0X2NvZGUpO1xuIgorCQkJCWJ1ZiArPSAiCQlicmVhaztcbiIKKworCisJCQlidWYgKz0gIgl9XG5cbiIKKwkJCWJ1ZiArPSAiCXJldHVybiByZXQ7XG4iCisJCQlidWYgKz0gIn1cblxuIgorCQkJYnVmaSArPSAidTMyICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2dldF9wcl90cmFuc3BvcnRfaWRfbGVuKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKixcbiIKKwkJCWJ1ZmkgKz0gIgkJCXN0cnVjdCBzZV9ub2RlX2FjbCAqLCBzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqLFxuIgorCQkJYnVmaSArPSAiCQkJaW50ICopO1xuIgorCisJCWlmIHJlLnNlYXJjaCgncGFyc2VfcHJfb3V0X3RyYW5zcG9ydF9pZFwpXCgnLCBmbyk6CisJCQlidWYgKz0gImNoYXIgKiIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3BhcnNlX3ByX291dF90cmFuc3BvcnRfaWQoXG4iCisJCQlidWYgKz0gIglzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcsXG4iCisJCQlidWYgKz0gIgljb25zdCBjaGFyICpidWYsXG4iCisJCQlidWYgKz0gIgl1MzIgKm91dF90aWRfbGVuLFxuIgorCQkJYnVmICs9ICIJY2hhciAqKnBvcnRfbmV4dXNfcHRyKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfdHBnICp0cGcgPSBjb250YWluZXJfb2Yoc2VfdHBnLFxuIgorCQkJYnVmICs9ICIJCQkJc3RydWN0ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3RwZywgc2VfdHBnKTtcbiIKKwkJCWJ1ZiArPSAiCXN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl8iICsgZmFicmljX21vZF9wb3J0ICsgIiAqIiArIGZhYnJpY19tb2RfcG9ydCArICIgPSB0cGctPiIgKyBmYWJyaWNfbW9kX3BvcnQgKyAiO1xuIgorCQkJYnVmICs9ICIJY2hhciAqdGlkID0gTlVMTDtcblxuIgorCQkJYnVmICs9ICIJc3dpdGNoICgiICsgZmFicmljX21vZF9wb3J0ICsgIi0+IiArIGZhYnJpY19tb2RfcG9ydCArICJfcHJvdG9faWQpIHtcbiIKKwkJCWlmIHByb3RvX2lkZW50ID09ICJGQyI6CisJCQkJYnVmICs9ICIJY2FzZSBTQ1NJX1BST1RPQ09MX0ZDUDpcbiIKKwkJCQlidWYgKz0gIglkZWZhdWx0OlxuIgorCQkJCWJ1ZiArPSAiCQl0aWQgPSBmY19wYXJzZV9wcl9vdXRfdHJhbnNwb3J0X2lkKHNlX3RwZywgYnVmLCBvdXRfdGlkX2xlbixcbiIKKwkJCQlidWYgKz0gIgkJCQkJcG9ydF9uZXh1c19wdHIpO1xuIgorCQkJZWxpZiBwcm90b19pZGVudCA9PSAiU0FTIjoKKwkJCQlidWYgKz0gIgljYXNlIFNDU0lfUFJPVE9DT0xfU0FTOlxuIgorCQkJCWJ1ZiArPSAiCWRlZmF1bHQ6XG4iCisJCQkJYnVmICs9ICIJCXRpZCA9IHNhc19wYXJzZV9wcl9vdXRfdHJhbnNwb3J0X2lkKHNlX3RwZywgYnVmLCBvdXRfdGlkX2xlbixcbiIKKwkJCQlidWYgKz0gIgkJCQkJcG9ydF9uZXh1c19wdHIpO1xuIgorCQkJZWxpZiBwcm90b19pZGVudCA9PSAiaVNDU0kiOgorCQkJCWJ1ZiArPSAiCWNhc2UgU0NTSV9QUk9UT0NPTF9JU0NTSTpcbiIKKwkJCQlidWYgKz0gIglkZWZhdWx0OlxuIgorCQkJCWJ1ZiArPSAiCQl0aWQgPSBpc2NzaV9wYXJzZV9wcl9vdXRfdHJhbnNwb3J0X2lkKHNlX3RwZywgYnVmLCBvdXRfdGlkX2xlbixcbiIKKwkJCQlidWYgKz0gIgkJCQkJcG9ydF9uZXh1c19wdHIpO1xuIgorCisJCQlidWYgKz0gIgl9XG5cbiIKKwkJCWJ1ZiArPSAiCXJldHVybiB0aWQ7XG4iCisJCQlidWYgKz0gIn1cblxuIgorCQkJYnVmaSArPSAiY2hhciAqIiArIGZhYnJpY19tb2RfbmFtZSArICJfcGFyc2VfcHJfb3V0X3RyYW5zcG9ydF9pZChzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICosXG4iCisJCQlidWZpICs9CSIJCQljb25zdCBjaGFyICosIHUzMiAqLCBjaGFyICoqKTtcbiIKKworCQlpZiByZS5zZWFyY2goJ2FsbG9jX2ZhYnJpY19hY2xcKVwoJywgZm8pOgorCQkJYnVmICs9ICJzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKiIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2FsbG9jX2ZhYnJpY19hY2woc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglzdHJ1Y3QgIiArIGZhYnJpY19tb2RfbmFtZSArICJfbmFjbCAqbmFjbDtcblxuIgorCQkJYnVmICs9ICIJbmFjbCA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl9uYWNsKSwgR0ZQX0tFUk5FTCk7XG4iCisJCQlidWYgKz0gIglpZiAoIShuYWNsKSkge1xuIgorCQkJYnVmICs9ICIJCXByaW50ayhLRVJOX0VSUiBcIlVuYWJsZSB0byBhbG9jYXRlIHN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl9uYWNsXFxuXCIpO1xuIgorCQkJYnVmICs9ICIJCXJldHVybiBOVUxMO1xuIgorCQkJYnVmICs9ICIJfVxuXG4iCisJCQlidWYgKz0gIglyZXR1cm4gJm5hY2wtPnNlX25vZGVfYWNsO1xuIgorCQkJYnVmICs9ICJ9XG5cbiIKKwkJCWJ1ZmkgKz0gInN0cnVjdCBzZV9ub2RlX2FjbCAqIiArIGZhYnJpY19tb2RfbmFtZSArICJfYWxsb2NfZmFicmljX2FjbChzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICopO1xuIgorCisJCWlmIHJlLnNlYXJjaCgncmVsZWFzZV9mYWJyaWNfYWNsXClcKCcsIGZvKToKKwkJCWJ1ZiArPSAidm9pZCAiICsgZmFicmljX21vZF9uYW1lICsgIl9yZWxlYXNlX2ZhYnJpY19hY2woXG4iCisJCQlidWYgKz0gIglzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcsXG4iCisJCQlidWYgKz0gIglzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKnNlX25hY2wpXG4iCisJCQlidWYgKz0gIntcbiIKKwkJCWJ1ZiArPSAiCXN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl9uYWNsICpuYWNsID0gY29udGFpbmVyX29mKHNlX25hY2wsXG4iCisJCQlidWYgKz0gIgkJCXN0cnVjdCAiICsgZmFicmljX21vZF9uYW1lICsgIl9uYWNsLCBzZV9ub2RlX2FjbCk7XG4iCisJCQlidWYgKz0gIglrZnJlZShuYWNsKTtcbiIKKwkJCWJ1ZiArPSAifVxuXG4iCisJCQlidWZpICs9ICJ2b2lkICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3JlbGVhc2VfZmFicmljX2FjbChzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICosXG4iCisJCQlidWZpICs9CSIJCQlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKik7XG4iCisKKwkJaWYgcmUuc2VhcmNoKCd0cGdfZ2V0X2luc3RfaW5kZXhcKVwoJywgZm8pOgorCQkJYnVmICs9ICJ1MzIgIiArIGZhYnJpY19tb2RfbmFtZSArICJfdHBnX2dldF9pbnN0X2luZGV4KHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZylcbiIKKwkJCWJ1ZiArPSAie1xuIgorCQkJYnVmICs9ICIJcmV0dXJuIDE7XG4iCisJCQlidWYgKz0gIn1cblxuIgorCQkJYnVmaSArPSAidTMyICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3RwZ19nZXRfaW5zdF9pbmRleChzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICopO1xuIgorCisJCWlmIHJlLnNlYXJjaCgncmVsZWFzZV9jbWRfdG9fcG9vbCcsIGZvKToKKwkJCWJ1ZiArPSAidm9pZCAiICsgZmFicmljX21vZF9uYW1lICsgIl9yZWxlYXNlX2NtZChzdHJ1Y3Qgc2VfY21kICpzZV9jbWQpXG4iCisJCQlidWYgKz0gIntcbiIKKwkJCWJ1ZiArPSAiCXJldHVybjtcbiIKKwkJCWJ1ZiArPSAifVxuXG4iCisJCQlidWZpICs9ICJ2b2lkICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3JlbGVhc2VfY21kKHN0cnVjdCBzZV9jbWQgKik7XG4iCisKKwkJaWYgcmUuc2VhcmNoKCdzaHV0ZG93bl9zZXNzaW9uXClcKCcsIGZvKToKKwkJCWJ1ZiArPSAiaW50ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3NodXRkb3duX3Nlc3Npb24oc3RydWN0IHNlX3Nlc3Npb24gKnNlX3Nlc3MpXG4iCisJCQlidWYgKz0gIntcbiIKKwkJCWJ1ZiArPSAiCXJldHVybiAwO1xuIgorCQkJYnVmICs9ICJ9XG5cbiIKKwkJCWJ1ZmkgKz0gImludCAiICsgZmFicmljX21vZF9uYW1lICsgIl9zaHV0ZG93bl9zZXNzaW9uKHN0cnVjdCBzZV9zZXNzaW9uICopO1xuIgorCisJCWlmIHJlLnNlYXJjaCgnY2xvc2Vfc2Vzc2lvblwpXCgnLCBmbyk6CisJCQlidWYgKz0gInZvaWQgIiArIGZhYnJpY19tb2RfbmFtZSArICJfY2xvc2Vfc2Vzc2lvbihzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqc2Vfc2VzcylcbiIKKwkJCWJ1ZiArPSAie1xuIgorCQkJYnVmICs9ICIJcmV0dXJuO1xuIgorCQkJYnVmICs9ICJ9XG5cbiIKKwkJCWJ1ZmkgKz0gInZvaWQgIiArIGZhYnJpY19tb2RfbmFtZSArICJfY2xvc2Vfc2Vzc2lvbihzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqKTtcbiIKKworCQlpZiByZS5zZWFyY2goJ3N0b3Bfc2Vzc2lvblwpXCgnLCBmbyk6CisJCQlidWYgKz0gInZvaWQgIiArIGZhYnJpY19tb2RfbmFtZSArICJfc3RvcF9zZXNzaW9uKHN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzLCBpbnQgc2Vzc19zbGVlcCAsIGludCBjb25uX3NsZWVwKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglyZXR1cm47XG4iCisJCQlidWYgKz0gIn1cblxuIgorCQkJYnVmaSArPSAidm9pZCAiICsgZmFicmljX21vZF9uYW1lICsgIl9zdG9wX3Nlc3Npb24oc3RydWN0IHNlX3Nlc3Npb24gKiwgaW50LCBpbnQpO1xuIgorCisJCWlmIHJlLnNlYXJjaCgnZmFsbF9iYWNrX3RvX2VybDBcKVwoJywgZm8pOgorCQkJYnVmICs9ICJ2b2lkICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3Jlc2V0X25leHVzKHN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglyZXR1cm47XG4iCisJCQlidWYgKz0gIn1cblxuIgorCQkJYnVmaSArPSAidm9pZCAiICsgZmFicmljX21vZF9uYW1lICsgIl9yZXNldF9uZXh1cyhzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqKTtcbiIKKworCQlpZiByZS5zZWFyY2goJ3Nlc3NfbG9nZ2VkX2luXClcKCcsIGZvKToKKwkJCWJ1ZiArPSAiaW50ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3Nlc3NfbG9nZ2VkX2luKHN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglyZXR1cm4gMDtcbiIKKwkJCWJ1ZiArPSAifVxuXG4iCisJCQlidWZpICs9ICJpbnQgIiArIGZhYnJpY19tb2RfbmFtZSArICJfc2Vzc19sb2dnZWRfaW4oc3RydWN0IHNlX3Nlc3Npb24gKik7XG4iCisKKwkJaWYgcmUuc2VhcmNoKCdzZXNzX2dldF9pbmRleFwpXCgnLCBmbyk6CisJCQlidWYgKz0gInUzMiAiICsgZmFicmljX21vZF9uYW1lICsgIl9zZXNzX2dldF9pbmRleChzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqc2Vfc2VzcylcbiIKKwkJCWJ1ZiArPSAie1xuIgorCQkJYnVmICs9ICIJcmV0dXJuIDA7XG4iCisJCQlidWYgKz0gIn1cblxuIgorCQkJYnVmaSArPSAidTMyICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3Nlc3NfZ2V0X2luZGV4KHN0cnVjdCBzZV9zZXNzaW9uICopO1xuIgorCisJCWlmIHJlLnNlYXJjaCgnd3JpdGVfcGVuZGluZ1wpXCgnLCBmbyk6CisJCQlidWYgKz0gImludCAiICsgZmFicmljX21vZF9uYW1lICsgIl93cml0ZV9wZW5kaW5nKHN0cnVjdCBzZV9jbWQgKnNlX2NtZClcbiIKKwkJCWJ1ZiArPSAie1xuIgorCQkJYnVmICs9ICIJcmV0dXJuIDA7XG4iCisJCQlidWYgKz0gIn1cblxuIgorCQkJYnVmaSArPSAiaW50ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3dyaXRlX3BlbmRpbmcoc3RydWN0IHNlX2NtZCAqKTtcbiIKKworCQlpZiByZS5zZWFyY2goJ3dyaXRlX3BlbmRpbmdfc3RhdHVzXClcKCcsIGZvKToKKwkJCWJ1ZiArPSAiaW50ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3dyaXRlX3BlbmRpbmdfc3RhdHVzKHN0cnVjdCBzZV9jbWQgKnNlX2NtZClcbiIKKwkJCWJ1ZiArPSAie1xuIgorCQkJYnVmICs9ICIJcmV0dXJuIDA7XG4iCisJCQlidWYgKz0gIn1cblxuIgorCQkJYnVmaSArPSAiaW50ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3dyaXRlX3BlbmRpbmdfc3RhdHVzKHN0cnVjdCBzZV9jbWQgKik7XG4iCisKKwkJaWYgcmUuc2VhcmNoKCdzZXRfZGVmYXVsdF9ub2RlX2F0dHJpYnV0ZXNcKVwoJywgZm8pOgorCQkJYnVmICs9ICJ2b2lkICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3NldF9kZWZhdWx0X25vZGVfYXR0cnMoc3RydWN0IHNlX25vZGVfYWNsICpuYWNsKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglyZXR1cm47XG4iCisJCQlidWYgKz0gIn1cblxuIgorCQkJYnVmaSArPSAidm9pZCAiICsgZmFicmljX21vZF9uYW1lICsgIl9zZXRfZGVmYXVsdF9ub2RlX2F0dHJzKHN0cnVjdCBzZV9ub2RlX2FjbCAqKTtcbiIKKworCQlpZiByZS5zZWFyY2goJ2dldF90YXNrX3RhZ1wpXCgnLCBmbyk6CisJCQlidWYgKz0gInUzMiAiICsgZmFicmljX21vZF9uYW1lICsgIl9nZXRfdGFza190YWcoc3RydWN0IHNlX2NtZCAqc2VfY21kKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglyZXR1cm4gMDtcbiIKKwkJCWJ1ZiArPSAifVxuXG4iCisJCQlidWZpICs9ICJ1MzIgIiArIGZhYnJpY19tb2RfbmFtZSArICJfZ2V0X3Rhc2tfdGFnKHN0cnVjdCBzZV9jbWQgKik7XG4iCisKKwkJaWYgcmUuc2VhcmNoKCdnZXRfY21kX3N0YXRlXClcKCcsIGZvKToKKwkJCWJ1ZiArPSAiaW50ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2dldF9jbWRfc3RhdGUoc3RydWN0IHNlX2NtZCAqc2VfY21kKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglyZXR1cm4gMDtcbiIKKwkJCWJ1ZiArPSAifVxuXG4iCisJCQlidWZpICs9ICJpbnQgIiArIGZhYnJpY19tb2RfbmFtZSArICJfZ2V0X2NtZF9zdGF0ZShzdHJ1Y3Qgc2VfY21kICopO1xuIgorCisJCWlmIHJlLnNlYXJjaCgnbmV3X2NtZF9mYWlsdXJlXClcKCcsIGZvKToKKwkJCWJ1ZiArPSAidm9pZCAiICsgZmFicmljX21vZF9uYW1lICsgIl9uZXdfY21kX2ZhaWx1cmUoc3RydWN0IHNlX2NtZCAqc2VfY21kKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglyZXR1cm47XG4iCisJCQlidWYgKz0gIn1cblxuIgorCQkJYnVmaSArPSAidm9pZCAiICsgZmFicmljX21vZF9uYW1lICsgIl9uZXdfY21kX2ZhaWx1cmUoc3RydWN0IHNlX2NtZCAqKTtcbiIKKworCQlpZiByZS5zZWFyY2goJ3F1ZXVlX2RhdGFfaW5cKVwoJywgZm8pOgorCQkJYnVmICs9ICJpbnQgIiArIGZhYnJpY19tb2RfbmFtZSArICJfcXVldWVfZGF0YV9pbihzdHJ1Y3Qgc2VfY21kICpzZV9jbWQpXG4iCisJCQlidWYgKz0gIntcbiIKKwkJCWJ1ZiArPSAiCXJldHVybiAwO1xuIgorCQkJYnVmICs9ICJ9XG5cbiIKKwkJCWJ1ZmkgKz0gImludCAiICsgZmFicmljX21vZF9uYW1lICsgIl9xdWV1ZV9kYXRhX2luKHN0cnVjdCBzZV9jbWQgKik7XG4iCisKKwkJaWYgcmUuc2VhcmNoKCdxdWV1ZV9zdGF0dXNcKVwoJywgZm8pOgorCQkJYnVmICs9ICJpbnQgIiArIGZhYnJpY19tb2RfbmFtZSArICJfcXVldWVfc3RhdHVzKHN0cnVjdCBzZV9jbWQgKnNlX2NtZClcbiIKKwkJCWJ1ZiArPSAie1xuIgorCQkJYnVmICs9ICIJcmV0dXJuIDA7XG4iCisJCQlidWYgKz0gIn1cblxuIgorCQkJYnVmaSArPSAiaW50ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3F1ZXVlX3N0YXR1cyhzdHJ1Y3Qgc2VfY21kICopO1xuIgorCisJCWlmIHJlLnNlYXJjaCgncXVldWVfdG1fcnNwXClcKCcsIGZvKToKKwkJCWJ1ZiArPSAiaW50ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3F1ZXVlX3RtX3JzcChzdHJ1Y3Qgc2VfY21kICpzZV9jbWQpXG4iCisJCQlidWYgKz0gIntcbiIKKwkJCWJ1ZiArPSAiCXJldHVybiAwO1xuIgorCQkJYnVmICs9ICJ9XG5cbiIKKwkJCWJ1ZmkgKz0gImludCAiICsgZmFicmljX21vZF9uYW1lICsgIl9xdWV1ZV90bV9yc3Aoc3RydWN0IHNlX2NtZCAqKTtcbiIKKworCQlpZiByZS5zZWFyY2goJ2dldF9mYWJyaWNfc2Vuc2VfbGVuXClcKCcsIGZvKToKKwkJCWJ1ZiArPSAidTE2ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2dldF9mYWJyaWNfc2Vuc2VfbGVuKHZvaWQpXG4iCisJCQlidWYgKz0gIntcbiIKKwkJCWJ1ZiArPSAiCXJldHVybiAwO1xuIgorCQkJYnVmICs9ICJ9XG5cbiIKKwkJCWJ1ZmkgKz0gInUxNiAiICsgZmFicmljX21vZF9uYW1lICsgIl9nZXRfZmFicmljX3NlbnNlX2xlbih2b2lkKTtcbiIKKworCQlpZiByZS5zZWFyY2goJ3NldF9mYWJyaWNfc2Vuc2VfbGVuXClcKCcsIGZvKToKKwkJCWJ1ZiArPSAidTE2ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3NldF9mYWJyaWNfc2Vuc2VfbGVuKHN0cnVjdCBzZV9jbWQgKnNlX2NtZCwgdTMyIHNlbnNlX2xlbmd0aClcbiIKKwkJCWJ1ZiArPSAie1xuIgorCQkJYnVmICs9ICIJcmV0dXJuIDA7XG4iCisJCQlidWYgKz0gIn1cblxuIgorCQkJYnVmaSArPSAidTE2ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX3NldF9mYWJyaWNfc2Vuc2VfbGVuKHN0cnVjdCBzZV9jbWQgKiwgdTMyKTtcbiIKKworCQlpZiByZS5zZWFyY2goJ2lzX3N0YXRlX3JlbW92ZVwpXCgnLCBmbyk6CisJCQlidWYgKz0gImludCAiICsgZmFicmljX21vZF9uYW1lICsgIl9pc19zdGF0ZV9yZW1vdmUoc3RydWN0IHNlX2NtZCAqc2VfY21kKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglyZXR1cm4gMDtcbiIKKwkJCWJ1ZiArPSAifVxuXG4iCisJCQlidWZpICs9ICJpbnQgIiArIGZhYnJpY19tb2RfbmFtZSArICJfaXNfc3RhdGVfcmVtb3ZlKHN0cnVjdCBzZV9jbWQgKik7XG4iCisKKwkJaWYgcmUuc2VhcmNoKCdwYWNrX2x1blwpXCgnLCBmbyk6CisJCQlidWYgKz0gInU2NCAiICsgZmFicmljX21vZF9uYW1lICsgIl9wYWNrX2x1bih1bnNpZ25lZCBpbnQgbHVuKVxuIgorCQkJYnVmICs9ICJ7XG4iCisJCQlidWYgKz0gIglXQVJOX09OKGx1biA+PSAyNTYpO1xuIgorCQkJYnVmICs9ICIJLyogQ2FsbGVyIHdhbnRzIHRoaXMgYnl0ZS1zd2FwcGVkICovXG4iCisJCQlidWYgKz0gIglyZXR1cm4gY3B1X3RvX2xlNjQoKGx1biAmIDB4ZmYpIDw8IDgpO1xuIgorCQkJYnVmICs9ICJ9XG5cbiIKKwkJCWJ1ZmkgKz0gInU2NCAiICsgZmFicmljX21vZF9uYW1lICsgIl9wYWNrX2x1bih1bnNpZ25lZCBpbnQpO1xuIgorCisKKwlyZXQgPSBwLndyaXRlKGJ1ZikKKwlpZiByZXQ6CisJCXRjbV9tb2RfZXJyKCJVbmFibGUgdG8gd3JpdGUgZjogIiArIGYpCisKKwlwLmNsb3NlKCkKKworCXJldCA9IHBpLndyaXRlKGJ1ZmkpCisJaWYgcmV0OgorCQl0Y21fbW9kX2VycigiVW5hYmxlIHRvIHdyaXRlIGZpOiAiICsgZmkpCisKKwlwaS5jbG9zZSgpCisJcmV0dXJuCisKK2RlZiB0Y21fbW9kX2J1aWxkX2tidWlsZChmYWJyaWNfbW9kX2Rpcl92YXIsIGZhYnJpY19tb2RfbmFtZSk6CisKKwlidWYgPSAiIgorCWYgPSBmYWJyaWNfbW9kX2Rpcl92YXIgKyAiL0tidWlsZCIKKwlwcmludCAiV3JpdGluZyBmaWxlOiAiICsgZgorCisJcCA9IG9wZW4oZiwgJ3cnKQorCWlmIG5vdCBwOgorCQl0Y21fbW9kX2VycigiVW5hYmxlIHRvIG9wZW4gZmlsZTogIiArIGYpCisKKwlidWYgPSAiRVhUUkFfQ0ZMQUdTICs9IC1JJChzcmN0cmVlKS9kcml2ZXJzL3RhcmdldC8gLUkkKHNyY3RyZWUpL2luY2x1ZGUvIC1JJChzcmN0cmVlKS9kcml2ZXJzL3Njc2kvIC1JJChzcmN0cmVlKS9pbmNsdWRlL3Njc2kvIC1JJChzcmN0cmVlKS9kcml2ZXJzL3RhcmdldC8iICsgZmFicmljX21vZF9uYW1lICsgIlxuXG4iCisJYnVmICs9IGZhYnJpY19tb2RfbmFtZSArICItb2JqcwkJCTo9ICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2ZhYnJpYy5vIFxcXG4iCisJYnVmICs9ICIJCQkJCSAgICIgKyBmYWJyaWNfbW9kX25hbWUgKyAiX2NvbmZpZ2ZzLm9cbiIKKwlidWYgKz0gIm9iai0kKENPTkZJR18iICsgZmFicmljX21vZF9uYW1lLnVwcGVyKCkgKyAiKQkJKz0gIiArIGZhYnJpY19tb2RfbmFtZSArICIub1xuIgorCisJcmV0ID0gcC53cml0ZShidWYpCisJaWYgcmV0OgorCQl0Y21fbW9kX2VycigiVW5hYmxlIHRvIHdyaXRlIGY6ICIgKyBmKQorCisJcC5jbG9zZSgpCisJcmV0dXJuCisKK2RlZiB0Y21fbW9kX2J1aWxkX2tjb25maWcoZmFicmljX21vZF9kaXJfdmFyLCBmYWJyaWNfbW9kX25hbWUpOgorCisJYnVmID0gIiIKKwlmID0gZmFicmljX21vZF9kaXJfdmFyICsgIi9LY29uZmlnIgorCXByaW50ICJXcml0aW5nIGZpbGU6ICIgKyBmCisKKwlwID0gb3BlbihmLCAndycpCisJaWYgbm90IHA6CisJCXRjbV9tb2RfZXJyKCJVbmFibGUgdG8gb3BlbiBmaWxlOiAiICsgZikKKworCWJ1ZiA9ICJjb25maWcgIiArIGZhYnJpY19tb2RfbmFtZS51cHBlcigpICsgIlxuIgorCWJ1ZiArPSAiCXRyaXN0YXRlIFwiIiArIGZhYnJpY19tb2RfbmFtZS51cHBlcigpICsgIiBmYWJyaWMgbW9kdWxlXCJcbiIKKwlidWYgKz0gIglkZXBlbmRzIG9uIFRBUkdFVF9DT1JFICYmIENPTkZJR0ZTX0ZTXG4iCisJYnVmICs9ICIJZGVmYXVsdCBuXG4iCisJYnVmICs9ICIJLS0taGVscC0tLVxuIgorCWJ1ZiArPSAiCVNheSBZIGhlcmUgdG8gZW5hYmxlIHRoZSAiICsgZmFicmljX21vZF9uYW1lLnVwcGVyKCkgKyAiIGZhYnJpYyBtb2R1bGVcbiIKKworCXJldCA9IHAud3JpdGUoYnVmKQorCWlmIHJldDoKKwkJdGNtX21vZF9lcnIoIlVuYWJsZSB0byB3cml0ZSBmOiAiICsgZikKKworCXAuY2xvc2UoKQorCXJldHVybgorCitkZWYgdGNtX21vZF9hZGRfa2J1aWxkKHRjbV9kaXIsIGZhYnJpY19tb2RfbmFtZSk6CisJYnVmID0gIm9iai0kKENPTkZJR18iICsgZmFicmljX21vZF9uYW1lLnVwcGVyKCkgKyAiKQkrPSAiICsgZmFicmljX21vZF9uYW1lLmxvd2VyKCkgKyAiL1xuIgorCWtidWlsZCA9IHRjbV9kaXIgKyAiL2RyaXZlcnMvdGFyZ2V0L0tidWlsZCIKKworCWYgPSBvcGVuKGtidWlsZCwgJ2EnKQorCWYud3JpdGUoYnVmKQorCWYuY2xvc2UoKQorCXJldHVybgorCitkZWYgdGNtX21vZF9hZGRfa2NvbmZpZyh0Y21fZGlyLCBmYWJyaWNfbW9kX25hbWUpOgorCWJ1ZiA9ICJzb3VyY2UgXCJkcml2ZXJzL3RhcmdldC8iICsgZmFicmljX21vZF9uYW1lLmxvd2VyKCkgKyAiL0tjb25maWdcIlxuIgorCWtjb25maWcgPSB0Y21fZGlyICsgIi9kcml2ZXJzL3RhcmdldC9LY29uZmlnIgorCisJZiA9IG9wZW4oa2NvbmZpZywgJ2EnKQorCWYud3JpdGUoYnVmKQorCWYuY2xvc2UoKQorCXJldHVybgorCitkZWYgbWFpbihtb2RuYW1lLCBwcm90b19pZGVudCk6CisjCXByb3RvX2lkZW50ID0gIkZDIgorIwlwcm90b19pZGVudCA9ICJTQVMiCisjCXByb3RvX2lkZW50ID0gImlTQ1NJIgorCisJdGNtX2RpciA9IG9zLmdldGN3ZCgpOworCXRjbV9kaXIgKz0gIi8uLi8uLi8iCisJcHJpbnQgInRjbV9kaXI6ICIgKyB0Y21fZGlyCisJZmFicmljX21vZF9uYW1lID0gbW9kbmFtZQorCWZhYnJpY19tb2RfZGlyID0gdGNtX2RpciArICJkcml2ZXJzL3RhcmdldC8iICsgZmFicmljX21vZF9uYW1lCisJcHJpbnQgIlNldCBmYWJyaWNfbW9kX25hbWU6ICIgKyBmYWJyaWNfbW9kX25hbWUKKwlwcmludCAiU2V0IGZhYnJpY19tb2RfZGlyOiAiICsgZmFicmljX21vZF9kaXIKKwlwcmludCAiVXNpbmcgcHJvdG9faWRlbnQ6ICIgKyBwcm90b19pZGVudAorCisJaWYgcHJvdG9faWRlbnQgIT0gIkZDIiBhbmQgcHJvdG9faWRlbnQgIT0gIlNBUyIgYW5kIHByb3RvX2lkZW50ICE9ICJpU0NTSSI6CisJCXByaW50ICJVbnN1cHBvcnRlZCBwcm90b19pZGVudDogIiArIHByb3RvX2lkZW50CisJCXN5cy5leGl0KDEpCisKKwlyZXQgPSB0Y21fbW9kX2NyZWF0ZV9tb2R1bGVfc3ViZGlyKGZhYnJpY19tb2RfZGlyKQorCWlmIHJldDoKKwkJcHJpbnQgInRjbV9tb2RfY3JlYXRlX21vZHVsZV9zdWJkaXIoKSBmYWlsZWQgYmVjYXVzZSBtb2R1bGUgYWxyZWFkeSBleGlzdHMhIgorCQlzeXMuZXhpdCgxKQorCisJdGNtX21vZF9idWlsZF9iYXNlX2luY2x1ZGVzKHByb3RvX2lkZW50LCBmYWJyaWNfbW9kX2RpciwgZmFicmljX21vZF9uYW1lKQorCXRjbV9tb2Rfc2Nhbl9mYWJyaWNfb3BzKHRjbV9kaXIpCisJdGNtX21vZF9kdW1wX2ZhYnJpY19vcHMocHJvdG9faWRlbnQsIGZhYnJpY19tb2RfZGlyLCBmYWJyaWNfbW9kX25hbWUpCisJdGNtX21vZF9idWlsZF9jb25maWdmcyhwcm90b19pZGVudCwgZmFicmljX21vZF9kaXIsIGZhYnJpY19tb2RfbmFtZSkKKwl0Y21fbW9kX2J1aWxkX2tidWlsZChmYWJyaWNfbW9kX2RpciwgZmFicmljX21vZF9uYW1lKQorCXRjbV9tb2RfYnVpbGRfa2NvbmZpZyhmYWJyaWNfbW9kX2RpciwgZmFicmljX21vZF9uYW1lKQorCisJaW5wdXQgPSByYXdfaW5wdXQoIldvdWxkIHlvdSBsaWtlIHRvIGFkZCAiICsgZmFicmljX21vZF9uYW1lICsgInRvIGRyaXZlcnMvdGFyZ2V0L0tidWlsZC4uPyBbeWVzLG5vXTogIikKKwlpZiBpbnB1dCA9PSAieWVzIiBvciBpbnB1dCA9PSAieSI6CisJCXRjbV9tb2RfYWRkX2tidWlsZCh0Y21fZGlyLCBmYWJyaWNfbW9kX25hbWUpCisKKwlpbnB1dCA9IHJhd19pbnB1dCgiV291bGQgeW91IGxpa2UgdG8gYWRkICIgKyBmYWJyaWNfbW9kX25hbWUgKyAidG8gZHJpdmVycy90YXJnZXQvS2NvbmZpZy4uPyBbeWVzLG5vXTogIikKKwlpZiBpbnB1dCA9PSAieWVzIiBvciBpbnB1dCA9PSAieSI6CisJCXRjbV9tb2RfYWRkX2tjb25maWcodGNtX2RpciwgZmFicmljX21vZF9uYW1lKQorCisJcmV0dXJuCisKK3BhcnNlciA9IG9wdHBhcnNlLk9wdGlvblBhcnNlcigpCitwYXJzZXIuYWRkX29wdGlvbignLW0nLCAnLS1tb2R1bGVuYW1lJywgaGVscD0nTW9kdWxlIG5hbWUnLCBkZXN0PSdtb2RuYW1lJywKKwkJYWN0aW9uPSdzdG9yZScsIG5hcmdzPTEsIHR5cGU9J3N0cmluZycpCitwYXJzZXIuYWRkX29wdGlvbignLXAnLCAnLS1wcm90b2lkZW50JywgaGVscD0nUHJvdG9jb2wgSWRlbnQnLCBkZXN0PSdwcm90b2lkZW50JywKKwkJYWN0aW9uPSdzdG9yZScsIG5hcmdzPTEsIHR5cGU9J3N0cmluZycpCisKKyhvcHRzLCBhcmdzKSA9IHBhcnNlci5wYXJzZV9hcmdzKCkKKworbWFuZGF0b3JpZXMgPSBbJ21vZG5hbWUnLCAncHJvdG9pZGVudCddCitmb3IgbSBpbiBtYW5kYXRvcmllczoKKwlpZiBub3Qgb3B0cy5fX2RpY3RfX1ttXToKKwkJcHJpbnQgIm1hbmRhdG9yeSBvcHRpb24gaXMgbWlzc2luZ1xuIgorCQlwYXJzZXIucHJpbnRfaGVscCgpCisJCWV4aXQoLTEpCisKK2lmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CisKKwltYWluKHN0cihvcHRzLm1vZG5hbWUpLCBvcHRzLnByb3RvaWRlbnQpCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3RhcmdldC90Y21fbW9kX2J1aWxkZXIudHh0IGIvRG9jdW1lbnRhdGlvbi90YXJnZXQvdGNtX21vZF9idWlsZGVyLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44NDUzM2Q4Ci0tLSAvZGV2L251bGwKKysrIGIvRG9jdW1lbnRhdGlvbi90YXJnZXQvdGNtX21vZF9idWlsZGVyLnR4dApAQCAtMCwwICsxLDE0NSBAQAorPj4+Pj4+Pj4+PiBUaGUgVENNIHY0IGZhYnJpYyBtb2R1bGUgc2NyaXB0IGdlbmVyYXRvciA8PDw8PDw8PDw8CisKK0dyZWV0aW5ncyBhbGwsCisKK1RoaXMgZG9jdW1lbnQgaXMgaW50ZW5kZWQgdG8gYmUgYSBtaW5pLUhPV1RPIGZvciB1c2luZyB0aGUgdGNtX21vZF9idWlsZGVyLnB5CitzY3JpcHQgdG8gZ2VuZXJhdGUgYSBicmFuZCBuZXcgZnVuY3Rpb25hbCBUQ00gdjQgZmFicmljIC5rbyBtb2R1bGUgb2YgeW91ciB2ZXJ5IG93biwKK3RoYXQgb25jZSBidWlsdCBjYW4gYmUgaW1tZWRpYXRlbHkgYmUgbG9hZGVkIHRvIHN0YXJ0IGFjY2VzcyB0aGUgbmV3IFRDTS9Db25maWdGUworZmFicmljIHNrZWxldG9uLCBieSBzaW1wbHkgdXNpbmc6CisKKwltb2Rwcm9iZSAkVENNX05FV19NT0QKKwlta2RpciAtcCAvc3lzL2tlcm5lbC9jb25maWcvdGFyZ2V0LyRUQ01fTkVXX01PRAorCitUaGlzIHNjcmlwdCB3aWxsIGNyZWF0ZSBhIG5ldyBkcml2ZXJzL3RhcmdldC8kVENNX05FV19NT0QvLCBhbmQgd2lsbCBkbyB0aGUgZm9sbG93aW5nCisKKwkqKSBHZW5lcmF0ZSBuZXcgQVBJIGNhbGxlcnMgZm9yIGRyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19jb25maWdzLmMgbG9naWMKKwkgICAtPm1ha2Vfbm9kZWFjbCgpLCAtPmRyb3Bfbm9kZWFjbCgpLCAtPm1ha2VfdHBnKCksIC0+ZHJvcF90cGcoKQorCSAgIC0+bWFrZV93d24oKSwgLT5kcm9wX3d3bigpLiAgVGhlc2UgYXJlIGNyZWF0ZWQgaW50byAkVENNX05FV19NT0QvJFRDTV9ORVdfTU9EX2NvbmZpZ2ZzLmMKKwkqKSBHZW5lcmF0ZSBiYXNpYyBpbmZyYXN0cnVjdHVyZSBmb3IgbG9hZGluZy91bmxvYWRpbmcgTEtNcyBhbmQgVENNL0NvbmZpZ0ZTIGZhYnJpYyBtb2R1bGUKKwkgICB1c2luZyBhIHNrZWxldG9uIHN0cnVjdCB0YXJnZXRfY29yZV9mYWJyaWNfb3BzIEFQSSB0ZW1wbGF0ZS4KKwkqKSBCYXNlZCBvbiB1c2VyIGRlZmluZWQgVDEwIFByb3RvX0lkZW50IGZvciB0aGUgbmV3IGZhYnJpYyBtb2R1bGUgYmVpbmcgYnVpbHQsCisJICAgdGhlIFRyYW5zcG9ydElEIC8gSW5pdGlhdG9yIGFuZCBUYXJnZXQgV1dQTiByZWxhdGVkIGhhbmRsZXJzIGZvcgorCSAgIFNQQy0zIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gYXJlIGF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVkIGluICRUQ01fTkVXX01PRC8kVENNX05FV19NT0RfZmFicmljLmMKKwkgICB1c2luZyBkcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfbGliLmMgbG9naWMuCisJKikgTk9QIEFQSSBjYWxscyBmb3IgYWxsIG90aGVyIERhdGEgSS9PIHBhdGggYW5kIGZhYnJpYyBkZXBlbmRlbnQgYXR0cmlidXRlIGxvZ2ljCisJICAgaW4gJFRDTV9ORVdfTU9ELyRUQ01fTkVXX01PRF9mYWJyaWMuYworCit0Y21fbW9kX2J1aWxkZXIucHkgZGVwZW5kcyB1cG9uIHRoZSBtYW5kYXRvcnkgJy1wICRQUk9UT19JREVOVCcgYW5kICctbQorJEZBQlJJQ19NT0RfbmFtZScgcGFyYW1ldGVycywgYW5kIGFjdHVhbGx5IHJ1bm5pbmcgdGhlIHNjcmlwdCBsb29rcyBsaWtlOgorCit0YXJnZXQ6L21udC9zZGIvbGlvLWNvcmUtMi42LmdpdC9Eb2N1bWVudGF0aW9uL3RhcmdldCMgcHl0aG9uIHRjbV9tb2RfYnVpbGRlci5weSAtcCBpU0NTSSAtbSB0Y21fbmFiNTAwMAordGNtX2RpcjogL21udC9zZGIvbGlvLWNvcmUtMi42LmdpdC9Eb2N1bWVudGF0aW9uL3RhcmdldC8uLi8uLi8KK1NldCBmYWJyaWNfbW9kX25hbWU6IHRjbV9uYWI1MDAwCitTZXQgZmFicmljX21vZF9kaXI6CisvbW50L3NkYi9saW8tY29yZS0yLjYuZ2l0L0RvY3VtZW50YXRpb24vdGFyZ2V0Ly4uLy4uL2RyaXZlcnMvdGFyZ2V0L3RjbV9uYWI1MDAwCitVc2luZyBwcm90b19pZGVudDogaVNDU0kKK0NyZWF0aW5nIGZhYnJpY19tb2RfZGlyOgorL21udC9zZGIvbGlvLWNvcmUtMi42LmdpdC9Eb2N1bWVudGF0aW9uL3RhcmdldC8uLi8uLi9kcml2ZXJzL3RhcmdldC90Y21fbmFiNTAwMAorV3JpdGluZyBmaWxlOgorL21udC9zZGIvbGlvLWNvcmUtMi42LmdpdC9Eb2N1bWVudGF0aW9uL3RhcmdldC8uLi8uLi9kcml2ZXJzL3RhcmdldC90Y21fbmFiNTAwMC90Y21fbmFiNTAwMF9iYXNlLmgKK1VzaW5nIHRjbV9tb2Rfc2Nhbl9mYWJyaWNfb3BzOgorL21udC9zZGIvbGlvLWNvcmUtMi42LmdpdC9Eb2N1bWVudGF0aW9uL3RhcmdldC8uLi8uLi9pbmNsdWRlL3RhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfb3BzLmgKK1dyaXRpbmcgZmlsZToKKy9tbnQvc2RiL2xpby1jb3JlLTIuNi5naXQvRG9jdW1lbnRhdGlvbi90YXJnZXQvLi4vLi4vZHJpdmVycy90YXJnZXQvdGNtX25hYjUwMDAvdGNtX25hYjUwMDBfZmFicmljLmMKK1dyaXRpbmcgZmlsZToKKy9tbnQvc2RiL2xpby1jb3JlLTIuNi5naXQvRG9jdW1lbnRhdGlvbi90YXJnZXQvLi4vLi4vZHJpdmVycy90YXJnZXQvdGNtX25hYjUwMDAvdGNtX25hYjUwMDBfZmFicmljLmgKK1dyaXRpbmcgZmlsZToKKy9tbnQvc2RiL2xpby1jb3JlLTIuNi5naXQvRG9jdW1lbnRhdGlvbi90YXJnZXQvLi4vLi4vZHJpdmVycy90YXJnZXQvdGNtX25hYjUwMDAvdGNtX25hYjUwMDBfY29uZmlnZnMuYworV3JpdGluZyBmaWxlOgorL21udC9zZGIvbGlvLWNvcmUtMi42LmdpdC9Eb2N1bWVudGF0aW9uL3RhcmdldC8uLi8uLi9kcml2ZXJzL3RhcmdldC90Y21fbmFiNTAwMC9LYnVpbGQKK1dyaXRpbmcgZmlsZToKKy9tbnQvc2RiL2xpby1jb3JlLTIuNi5naXQvRG9jdW1lbnRhdGlvbi90YXJnZXQvLi4vLi4vZHJpdmVycy90YXJnZXQvdGNtX25hYjUwMDAvS2NvbmZpZworV291bGQgeW91IGxpa2UgdG8gYWRkIHRjbV9uYWI1MDAwdG8gZHJpdmVycy90YXJnZXQvS2J1aWxkLi4/IFt5ZXMsbm9dOiB5ZXMKK1dvdWxkIHlvdSBsaWtlIHRvIGFkZCB0Y21fbmFiNTAwMHRvIGRyaXZlcnMvdGFyZ2V0L0tjb25maWcuLj8gW3llcyxub106IHllcworCitBdCB0aGUgZW5kIG9mIHRjbV9tb2RfYnVpbGRlci5weS4gdGhlIHNjcmlwdCB3aWxsIGFzayB0byBhZGQgdGhlIGZvbGxvd2luZworbGluZSB0byBkcml2ZXJzL3RhcmdldC9LYnVpbGQ6CisKKwlvYmotJChDT05GSUdfVENNX05BQjUwMDApICAgICAgICs9IHRjbV9uYWI1MDAwLworCithbmQgdGhlIHNhbWUgZm9yIGRyaXZlcnMvdGFyZ2V0L0tjb25maWc6CisKKwlzb3VyY2UgImRyaXZlcnMvdGFyZ2V0L3RjbV9uYWI1MDAwL0tjb25maWciCisKKyopIFJ1biAnbWFrZSBtZW51Y29uZmlnJyBhbmQgc2VsZWN0IHRoZSBuZXcgQ09ORklHX1RDTV9OQUI1MDAwIGl0ZW06CisKKwk8TT4gICBUQ01fTkFCNTAwMCBmYWJyaWMgbW9kdWxlCisKKyopIEJ1aWxkIHVzaW5nICdtYWtlIG1vZHVsZXMnLCBvbmNlIGNvbXBsZXRlZCB5b3Ugd2lsbCBoYXZlOgorCit0YXJnZXQ6L21udC9zZGIvbGlvLWNvcmUtMi42LmdpdCMgbHMgLWxhIGRyaXZlcnMvdGFyZ2V0L3RjbV9uYWI1MDAwLwordG90YWwgMTM0OAorZHJ3eHIteHIteCAyIHJvb3Qgcm9vdCAgIDQwOTYgMjAxMC0xMC0wNSAwMzoyMyAuCitkcnd4ci14ci14IDkgcm9vdCByb290ICAgNDA5NiAyMDEwLTEwLTA1IDAzOjIyIC4uCistcnctci0tci0tIDEgcm9vdCByb290ICAgIDI4MiAyMDEwLTEwLTA1IDAzOjIyIEtidWlsZAorLXJ3LXItLXItLSAxIHJvb3Qgcm9vdCAgICAxNzEgMjAxMC0xMC0wNSAwMzoyMiBLY29uZmlnCistcnctci0tci0tIDEgcm9vdCByb290ICAgICA0OSAyMDEwLTEwLTA1IDAzOjIzIG1vZHVsZXMub3JkZXIKKy1ydy1yLS1yLS0gMSByb290IHJvb3QgICAgNzM4IDIwMTAtMTAtMDUgMDM6MjIgdGNtX25hYjUwMDBfYmFzZS5oCistcnctci0tci0tIDEgcm9vdCByb290ICAgOTA5NiAyMDEwLTEwLTA1IDAzOjIyIHRjbV9uYWI1MDAwX2NvbmZpZ2ZzLmMKKy1ydy1yLS1yLS0gMSByb290IHJvb3QgMTkxMjAwIDIwMTAtMTAtMDUgMDM6MjMgdGNtX25hYjUwMDBfY29uZmlnZnMubworLXJ3LXItLXItLSAxIHJvb3Qgcm9vdCAgNDA1MDQgMjAxMC0xMC0wNSAwMzoyMyAudGNtX25hYjUwMDBfY29uZmlnZnMuby5jbWQKKy1ydy1yLS1yLS0gMSByb290IHJvb3QgICA1NDE0IDIwMTAtMTAtMDUgMDM6MjIgdGNtX25hYjUwMDBfZmFicmljLmMKKy1ydy1yLS1yLS0gMSByb290IHJvb3QgICAyMDE2IDIwMTAtMTAtMDUgMDM6MjIgdGNtX25hYjUwMDBfZmFicmljLmgKKy1ydy1yLS1yLS0gMSByb290IHJvb3QgMTkwOTMyIDIwMTAtMTAtMDUgMDM6MjMgdGNtX25hYjUwMDBfZmFicmljLm8KKy1ydy1yLS1yLS0gMSByb290IHJvb3QgIDQwNzEzIDIwMTAtMTAtMDUgMDM6MjMgLnRjbV9uYWI1MDAwX2ZhYnJpYy5vLmNtZAorLXJ3LXItLXItLSAxIHJvb3Qgcm9vdCA0MDE4NjEgMjAxMC0xMC0wNSAwMzoyMyB0Y21fbmFiNTAwMC5rbworLXJ3LXItLXItLSAxIHJvb3Qgcm9vdCAgICAyNjUgMjAxMC0xMC0wNSAwMzoyMyAudGNtX25hYjUwMDAua28uY21kCistcnctci0tci0tIDEgcm9vdCByb290ICAgIDQ1OSAyMDEwLTEwLTA1IDAzOjIzIHRjbV9uYWI1MDAwLm1vZC5jCistcnctci0tci0tIDEgcm9vdCByb290ICAyMzg5NiAyMDEwLTEwLTA1IDAzOjIzIHRjbV9uYWI1MDAwLm1vZC5vCistcnctci0tci0tIDEgcm9vdCByb290ICAyMjY1NSAyMDEwLTEwLTA1IDAzOjIzIC50Y21fbmFiNTAwMC5tb2Quby5jbWQKKy1ydy1yLS1yLS0gMSByb290IHJvb3QgMzc5MDIyIDIwMTAtMTAtMDUgMDM6MjMgdGNtX25hYjUwMDAubworLXJ3LXItLXItLSAxIHJvb3Qgcm9vdCAgICAyMTEgMjAxMC0xMC0wNSAwMzoyMyAudGNtX25hYjUwMDAuby5jbWQKKworKikgTG9hZCB0aGUgbmV3IG1vZHVsZSwgY3JlYXRlIGEgbHVuXzAgY29uZmlnZnMgZ3JvdXAsIGFuZCBhZGQgbmV3IFRDTSBDb3JlCisgICBJQkxPQ0sgYmFja3N0b3JlIHN5bWxpbmsgdG8gcG9ydDoKKwordGFyZ2V0Oi9tbnQvc2RiL2xpby1jb3JlLTIuNi5naXQjIGluc21vZCBkcml2ZXJzL3RhcmdldC90Y21fbmFiNTAwMC5rbwordGFyZ2V0Oi9tbnQvc2RiL2xpby1jb3JlLTIuNi5naXQjIG1rZGlyIC1wIC9zeXMva2VybmVsL2NvbmZpZy90YXJnZXQvbmFiNTAwMC9pcW4uZm9vL3RwZ3RfMS9sdW4vbHVuXzAKK3RhcmdldDovbW50L3NkYi9saW8tY29yZS0yLjYuZ2l0IyBjZCAvc3lzL2tlcm5lbC9jb25maWcvdGFyZ2V0L25hYjUwMDAvaXFuLmZvby90cGd0XzEvbHVuL2x1bl8wLwordGFyZ2V0Oi9zeXMva2VybmVsL2NvbmZpZy90YXJnZXQvbmFiNTAwMC9pcW4uZm9vL3RwZ3RfMS9sdW4vbHVuXzAjIGxuIC1zIC9zeXMva2VybmVsL2NvbmZpZy90YXJnZXQvY29yZS9pYmxvY2tfMC9sdm1fdGVzdDAgbmFiNTAwMF9wb3J0CisKK3RhcmdldDovc3lzL2tlcm5lbC9jb25maWcvdGFyZ2V0L25hYjUwMDAvaXFuLmZvby90cGd0XzEvbHVuL2x1bl8wIyBjZCAtCit0YXJnZXQ6L21udC9zZGIvbGlvLWNvcmUtMi42LmdpdCMgdHJlZSAvc3lzL2tlcm5lbC9jb25maWcvdGFyZ2V0L25hYjUwMDAvCisvc3lzL2tlcm5lbC9jb25maWcvdGFyZ2V0L25hYjUwMDAvCit8LS0gZGlzY292ZXJ5X2F1dGgKK3wtLSBpcW4uZm9vCit8ICAgYC0tIHRwZ3RfMQorfCAgICAgICB8LS0gYWNscworfCAgICAgICB8LS0gYXR0cmliCit8ICAgICAgIHwtLSBsdW4KK3wgICAgICAgfCAgIGAtLSBsdW5fMAorfCAgICAgICB8ICAgICAgIHwtLSBhbHVhX3RnX3B0X2dwCit8ICAgICAgIHwgICAgICAgfC0tIGFsdWFfdGdfcHRfb2ZmbGluZQorfCAgICAgICB8ICAgICAgIHwtLSBhbHVhX3RnX3B0X3N0YXR1cworfCAgICAgICB8ICAgICAgIHwtLSBhbHVhX3RnX3B0X3dyaXRlX21kCit8CXwJYC0tIG5hYjUwMDBfcG9ydCAtPiAuLi8uLi8uLi8uLi8uLi8uLi90YXJnZXQvY29yZS9pYmxvY2tfMC9sdm1fdGVzdDAKK3wgICAgICAgfC0tIG5wCit8ICAgICAgIGAtLSBwYXJhbQorYC0tIHZlcnNpb24KKwordGFyZ2V0Oi9tbnQvc2RiL2xpby1jb3JlLTIuNi5naXQjIGxzbW9kCitNb2R1bGUgICAgICAgICAgICAgICAgICBTaXplICBVc2VkIGJ5Cit0Y21fbmFiNTAwMCAgICAgICAgICAgICAzOTM1ICA0Citpc2NzaV90YXJnZXRfbW9kICAgICAgMTkzMjExICAwCit0YXJnZXRfY29yZV9zdGd0ICAgICAgICA4MDkwICAwCit0YXJnZXRfY29yZV9wc2NzaSAgICAgIDExMTIyICAxCit0YXJnZXRfY29yZV9maWxlICAgICAgICA5MTcyICAyCit0YXJnZXRfY29yZV9pYmxvY2sgICAgICA5MjgwICAxCit0YXJnZXRfY29yZV9tb2QgICAgICAgMjI4NTc1ICAzMQordGNtX25hYjUwMDAsaXNjc2lfdGFyZ2V0X21vZCx0YXJnZXRfY29yZV9zdGd0LHRhcmdldF9jb3JlX3BzY3NpLHRhcmdldF9jb3JlX2ZpbGUsdGFyZ2V0X2NvcmVfaWJsb2NrCitsaWJmYyAgICAgICAgICAgICAgICAgIDczNjgxICAwCitzY3NpX2RlYnVnICAgICAgICAgICAgIDU2MjY1ICAwCitzY3NpX3RndCAgICAgICAgICAgICAgICA4NjY2ICAxIHRhcmdldF9jb3JlX3N0Z3QKK2NvbmZpZ2ZzICAgICAgICAgICAgICAgMjA2NDQgIDIgdGFyZ2V0X2NvcmVfbW9kCisKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworRnV0dXJlIFRPRE8gaXRlbXM6CisKKwkqKSBBZGQgbW9yZSBUMTAgcHJvdG9faWRlbnRzCisJKikgTWFrZSB0Y21fbW9kX2R1bXBfZmFicmljX29wcygpIHNtYXJ0ZXIgYW5kIGdlbmVyYXRlIGZ1bmN0aW9uIHBvaW50ZXIKKwkgICBkZWZzIGRpcmVjdGx5IGZyb20gaW5jbHVkZS90YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX29wcy5oOnN0cnVjdCB0YXJnZXRfY29yZV9mYWJyaWNfb3BzCisJICAgc3RydWN0dXJlIG1lbWJlcnMuCisKK09jdG9iZXIgNXRoLCAyMDEwCitOaWNob2xhcyBBLiBCZWxsaW5nZXIgPG5hYkBsaW51eC1pc2NzaS5vcmc+CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3RoZXJtYWwvc3lzZnMtYXBpLnR4dCBiL0RvY3VtZW50YXRpb24vdGhlcm1hbC9zeXNmcy1hcGkudHh0CmluZGV4IGNiM2QxNWIuLmI2MWU0NmYgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vdGhlcm1hbC9zeXNmcy1hcGkudHh0CisrKyBiL0RvY3VtZW50YXRpb24vdGhlcm1hbC9zeXNmcy1hcGkudHh0CkBAIC0yNzgsMyArMjc4LDE1IEBACiAgICAgfC0tLW5hbWU6CQkJYWNwaXR6CiAgICAgfC0tLXRlbXAxX2lucHV0OgkJMzcwMDAKICAgICB8LS0tdGVtcDFfY3JpdDoJCTEwMDAwMAorCis0LiBFdmVudCBOb3RpZmljYXRpb24KKworVGhlIGZyYW1ld29yayBpbmNsdWRlcyBhIHNpbXBsZSBub3RpZmljYXRpb24gbWVjaGFuaXNtLCBpbiB0aGUgZm9ybSBvZiBhCituZXRsaW5rIGV2ZW50LiBOZXRsaW5rIHNvY2tldCBpbml0aWFsaXphdGlvbiBpcyBkb25lIGR1cmluZyB0aGUgX2luaXRfCitvZiB0aGUgZnJhbWV3b3JrLiBEcml2ZXJzIHdoaWNoIGludGVuZCB0byB1c2UgdGhlIG5vdGlmaWNhdGlvbiBtZWNoYW5pc20KK2p1c3QgbmVlZCB0byBjYWxsIGdlbmVyYXRlX25ldGxpbmtfZXZlbnQoKSB3aXRoIHR3byBhcmd1bWVudHMgdml6Cisob3JpZ2luYXRvciwgZXZlbnQpLiBUeXBpY2FsbHkgdGhlIG9yaWdpbmF0b3Igd2lsbCBiZSBhbiBpbnRlZ2VyIGFzc2lnbmVkCit0byBhIHRoZXJtYWxfem9uZV9kZXZpY2Ugd2hlbiBpdCByZWdpc3RlcnMgaXRzZWxmIHdpdGggdGhlIGZyYW1ld29yay4gVGhlCitldmVudCB3aWxsIGJlIG9uZSBvZjp7VEhFUk1BTF9BVVgwLCBUSEVSTUFMX0FVWDEsIFRIRVJNQUxfQ1JJVElDQUwsCitUSEVSTUFMX0RFVl9GQVVMVH0uIE5vdGlmaWNhdGlvbiBjYW4gYmUgc2VudCB3aGVuIHRoZSBjdXJyZW50IHRlbXBlcmF0dXJlCitjcm9zc2VzIGFueSBvZiB0aGUgY29uZmlndXJlZCB0aHJlc2hvbGRzLgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi92aWRlbzRsaW51eC92NGwyLWNvbnRyb2xzLnR4dCBiL0RvY3VtZW50YXRpb24vdmlkZW80bGludXgvdjRsMi1jb250cm9scy50eHQKaW5kZXggODc3Mzc3OC4uODgxZTdmNCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi92aWRlbzRsaW51eC92NGwyLWNvbnRyb2xzLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3ZpZGVvNGxpbnV4L3Y0bDItY29udHJvbHMudHh0CkBAIC0yODUsNiArMjg1LDkgQEAKIFRoZSAnbmV3IHZhbHVlJyB1bmlvbiBpcyBub3QgdXNlZCBpbiBnX3ZvbGF0aWxlX2N0cmwuIEluIGdlbmVyYWwgY29udHJvbHMKIHRoYXQgbmVlZCB0byBpbXBsZW1lbnQgZ192b2xhdGlsZV9jdHJsIGFyZSByZWFkLW9ubHkgY29udHJvbHMuCiAKK05vdGUgdGhhdCBpZiBvbmUgb3IgbW9yZSBjb250cm9scyBpbiBhIGNvbnRyb2wgY2x1c3RlciBhcmUgbWFya2VkIGFzIHZvbGF0aWxlLAordGhlbiBhbGwgdGhlIGNvbnRyb2xzIGluIHRoZSBjbHVzdGVyIGFyZSBzZWVuIGFzIHZvbGF0aWxlLgorCiBUbyBtYXJrIGEgY29udHJvbCBhcyB2b2xhdGlsZSB5b3UgaGF2ZSB0byBzZXQgdGhlIGlzX3ZvbGF0aWxlIGZsYWc6CiAKIAljdHJsID0gdjRsMl9jdHJsX25ld19zdGQoJnNkLT5jdHJsX2hhbmRsZXIsIC4uLik7CkBAIC00NjIsNiArNDY1LDE1IEBACiBPYnZpb3VzbHksIGFsbCBjb250cm9scyBpbiB0aGUgY2x1c3RlciBhcnJheSBtdXN0IGJlIGluaXRpYWxpemVkIHRvIGVpdGhlcgogYSB2YWxpZCBjb250cm9sIG9yIHRvIE5VTEwuCiAKK0luIHJhcmUgY2FzZXMgeW91IG1pZ2h0IHdhbnQgdG8ga25vdyB3aGljaCBjb250cm9scyBvZiBhIGNsdXN0ZXIgYWN0dWFsbHkKK3dlcmUgc2V0IGV4cGxpY2l0bHkgYnkgdGhlIHVzZXIuIEZvciB0aGlzIHlvdSBjYW4gY2hlY2sgdGhlICdpc19uZXcnIGZsYWcgb2YKK2VhY2ggY29udHJvbC4gRm9yIGV4YW1wbGUsIGluIHRoZSBjYXNlIG9mIGEgdm9sdW1lL211dGUgY2x1c3RlciB0aGUgJ2lzX25ldycKK2ZsYWcgb2YgdGhlIG11dGUgY29udHJvbCB3b3VsZCBiZSBzZXQgaWYgdGhlIHVzZXIgY2FsbGVkIFZJRElPQ19TX0NUUkwgZm9yCittdXRlIG9ubHkuIElmIHRoZSB1c2VyIHdvdWxkIGNhbGwgVklESU9DX1NfRVhUX0NUUkxTIGZvciBib3RoIG11dGUgYW5kIHZvbHVtZQorY29udHJvbHMsIHRoZW4gdGhlICdpc19uZXcnIGZsYWcgd291bGQgYmUgMSBmb3IgYm90aCBjb250cm9scy4KKworVGhlICdpc19uZXcnIGZsYWcgaXMgYWx3YXlzIDEgd2hlbiBjYWxsZWQgZnJvbSB2NGwyX2N0cmxfaGFuZGxlcl9zZXR1cCgpLgorCiAKIFZJRElPQ19MT0dfU1RBVFVTIFN1cHBvcnQKID09PT09PT09PT09PT09PT09PT09PT09PT0KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdm0vdHJhbnNodWdlLnR4dCBiL0RvY3VtZW50YXRpb24vdm0vdHJhbnNodWdlLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wOTI0YWFjCi0tLSAvZGV2L251bGwKKysrIGIvRG9jdW1lbnRhdGlvbi92bS90cmFuc2h1Z2UudHh0CkBAIC0wLDAgKzEsMjk4IEBACis9IFRyYW5zcGFyZW50IEh1Z2VwYWdlIFN1cHBvcnQgPQorCis9PSBPYmplY3RpdmUgPT0KKworUGVyZm9ybWFuY2UgY3JpdGljYWwgY29tcHV0aW5nIGFwcGxpY2F0aW9ucyBkZWFsaW5nIHdpdGggbGFyZ2UgbWVtb3J5Cit3b3JraW5nIHNldHMgYXJlIGFscmVhZHkgcnVubmluZyBvbiB0b3Agb2YgbGliaHVnZXRsYmZzIGFuZCBpbiB0dXJuCitodWdldGxiZnMuIFRyYW5zcGFyZW50IEh1Z2VwYWdlIFN1cHBvcnQgaXMgYW4gYWx0ZXJuYXRpdmUgbWVhbnMgb2YKK3VzaW5nIGh1Z2UgcGFnZXMgZm9yIHRoZSBiYWNraW5nIG9mIHZpcnR1YWwgbWVtb3J5IHdpdGggaHVnZSBwYWdlcwordGhhdCBzdXBwb3J0cyB0aGUgYXV0b21hdGljIHByb21vdGlvbiBhbmQgZGVtb3Rpb24gb2YgcGFnZSBzaXplcyBhbmQKK3dpdGhvdXQgdGhlIHNob3J0Y29taW5ncyBvZiBodWdldGxiZnMuCisKK0N1cnJlbnRseSBpdCBvbmx5IHdvcmtzIGZvciBhbm9ueW1vdXMgbWVtb3J5IG1hcHBpbmdzIGJ1dCBpbiB0aGUKK2Z1dHVyZSBpdCBjYW4gZXhwYW5kIG92ZXIgdGhlIHBhZ2VjYWNoZSBsYXllciBzdGFydGluZyB3aXRoIHRtcGZzLgorCitUaGUgcmVhc29uIGFwcGxpY2F0aW9ucyBhcmUgcnVubmluZyBmYXN0ZXIgaXMgYmVjYXVzZSBvZiB0d28KK2ZhY3RvcnMuIFRoZSBmaXJzdCBmYWN0b3IgaXMgYWxtb3N0IGNvbXBsZXRlbHkgaXJyZWxldmFudCBhbmQgaXQncyBub3QKK29mIHNpZ25pZmljYW50IGludGVyZXN0IGJlY2F1c2UgaXQnbGwgYWxzbyBoYXZlIHRoZSBkb3duc2lkZSBvZgorcmVxdWlyaW5nIGxhcmdlciBjbGVhci1wYWdlIGNvcHktcGFnZSBpbiBwYWdlIGZhdWx0cyB3aGljaCBpcyBhCitwb3RlbnRpYWxseSBuZWdhdGl2ZSBlZmZlY3QuIFRoZSBmaXJzdCBmYWN0b3IgY29uc2lzdHMgaW4gdGFraW5nIGEKK3NpbmdsZSBwYWdlIGZhdWx0IGZvciBlYWNoIDJNIHZpcnR1YWwgcmVnaW9uIHRvdWNoZWQgYnkgdXNlcmxhbmQgKHNvCityZWR1Y2luZyB0aGUgZW50ZXIvZXhpdCBrZXJuZWwgZnJlcXVlbmN5IGJ5IGEgNTEyIHRpbWVzIGZhY3RvcikuIFRoaXMKK29ubHkgbWF0dGVycyB0aGUgZmlyc3QgdGltZSB0aGUgbWVtb3J5IGlzIGFjY2Vzc2VkIGZvciB0aGUgbGlmZXRpbWUgb2YKK2EgbWVtb3J5IG1hcHBpbmcuIFRoZSBzZWNvbmQgbG9uZyBsYXN0aW5nIGFuZCBtdWNoIG1vcmUgaW1wb3J0YW50CitmYWN0b3Igd2lsbCBhZmZlY3QgYWxsIHN1YnNlcXVlbnQgYWNjZXNzZXMgdG8gdGhlIG1lbW9yeSBmb3IgdGhlIHdob2xlCitydW50aW1lIG9mIHRoZSBhcHBsaWNhdGlvbi4gVGhlIHNlY29uZCBmYWN0b3IgY29uc2lzdCBvZiB0d28KK2NvbXBvbmVudHM6IDEpIHRoZSBUTEIgbWlzcyB3aWxsIHJ1biBmYXN0ZXIgKGVzcGVjaWFsbHkgd2l0aAordmlydHVhbGl6YXRpb24gdXNpbmcgbmVzdGVkIHBhZ2V0YWJsZXMgYnV0IGFsbW9zdCBhbHdheXMgYWxzbyBvbiBiYXJlCittZXRhbCB3aXRob3V0IHZpcnR1YWxpemF0aW9uKSBhbmQgMikgYSBzaW5nbGUgVExCIGVudHJ5IHdpbGwgYmUKK21hcHBpbmcgYSBtdWNoIGxhcmdlciBhbW91bnQgb2YgdmlydHVhbCBtZW1vcnkgaW4gdHVybiByZWR1Y2luZyB0aGUKK251bWJlciBvZiBUTEIgbWlzc2VzLiBXaXRoIHZpcnR1YWxpemF0aW9uIGFuZCBuZXN0ZWQgcGFnZXRhYmxlcyB0aGUKK1RMQiBjYW4gYmUgbWFwcGVkIG9mIGxhcmdlciBzaXplIG9ubHkgaWYgYm90aCBLVk0gYW5kIHRoZSBMaW51eCBndWVzdAorYXJlIHVzaW5nIGh1Z2VwYWdlcyBidXQgYSBzaWduaWZpY2FudCBzcGVlZHVwIGFscmVhZHkgaGFwcGVucyBpZiBvbmx5CitvbmUgb2YgdGhlIHR3byBpcyB1c2luZyBodWdlcGFnZXMganVzdCBiZWNhdXNlIG9mIHRoZSBmYWN0IHRoZSBUTEIKK21pc3MgaXMgZ29pbmcgdG8gcnVuIGZhc3Rlci4KKworPT0gRGVzaWduID09CisKKy0gImdyYWNlZnVsIGZhbGxiYWNrIjogbW0gY29tcG9uZW50cyB3aGljaCBkb24ndCBoYXZlIHRyYW5zcGFyZW50CisgIGh1Z2VwYWdlIGtub3dsZWRnZSBmYWxsIGJhY2sgdG8gYnJlYWtpbmcgYSB0cmFuc3BhcmVudCBodWdlcGFnZSBhbmQKKyAgd29ya2luZyBvbiB0aGUgcmVndWxhciBwYWdlcyBhbmQgdGhlaXIgcmVzcGVjdGl2ZSByZWd1bGFyIHBtZC9wdGUKKyAgbWFwcGluZ3MKKworLSBpZiBhIGh1Z2VwYWdlIGFsbG9jYXRpb24gZmFpbHMgYmVjYXVzZSBvZiBtZW1vcnkgZnJhZ21lbnRhdGlvbiwKKyAgcmVndWxhciBwYWdlcyBzaG91bGQgYmUgZ3JhY2VmdWxseSBhbGxvY2F0ZWQgaW5zdGVhZCBhbmQgbWl4ZWQgaW4KKyAgdGhlIHNhbWUgdm1hIHdpdGhvdXQgYW55IGZhaWx1cmUgb3Igc2lnbmlmaWNhbnQgZGVsYXkgYW5kIHdpdGhvdXQKKyAgdXNlcmxhbmQgbm90aWNpbmcKKworLSBpZiBzb21lIHRhc2sgcXVpdHMgYW5kIG1vcmUgaHVnZXBhZ2VzIGJlY29tZSBhdmFpbGFibGUgKGVpdGhlcgorICBpbW1lZGlhdGVseSBpbiB0aGUgYnVkZHkgb3IgdGhyb3VnaCB0aGUgVk0pLCBndWVzdCBwaHlzaWNhbCBtZW1vcnkKKyAgYmFja2VkIGJ5IHJlZ3VsYXIgcGFnZXMgc2hvdWxkIGJlIHJlbG9jYXRlZCBvbiBodWdlcGFnZXMKKyAgYXV0b21hdGljYWxseSAod2l0aCBraHVnZXBhZ2VkKQorCistIGl0IGRvZXNuJ3QgcmVxdWlyZSBtZW1vcnkgcmVzZXJ2YXRpb24gYW5kIGluIHR1cm4gaXQgdXNlcyBodWdlcGFnZXMKKyAgd2hlbmV2ZXIgcG9zc2libGUgKHRoZSBvbmx5IHBvc3NpYmxlIHJlc2VydmF0aW9uIGhlcmUgaXMga2VybmVsY29yZT0KKyAgdG8gYXZvaWQgdW5tb3ZhYmxlIHBhZ2VzIHRvIGZyYWdtZW50IGFsbCB0aGUgbWVtb3J5IGJ1dCBzdWNoIGEgdHdlYWsKKyAgaXMgbm90IHNwZWNpZmljIHRvIHRyYW5zcGFyZW50IGh1Z2VwYWdlIHN1cHBvcnQgYW5kIGl0J3MgYSBnZW5lcmljCisgIGZlYXR1cmUgdGhhdCBhcHBsaWVzIHRvIGFsbCBkeW5hbWljIGhpZ2ggb3JkZXIgYWxsb2NhdGlvbnMgaW4gdGhlCisgIGtlcm5lbCkKKworLSB0aGlzIGluaXRpYWwgc3VwcG9ydCBvbmx5IG9mZmVycyB0aGUgZmVhdHVyZSBpbiB0aGUgYW5vbnltb3VzIG1lbW9yeQorICByZWdpb25zIGJ1dCBpdCdkIGJlIGlkZWFsIHRvIG1vdmUgaXQgdG8gdG1wZnMgYW5kIHRoZSBwYWdlY2FjaGUKKyAgbGF0ZXIKKworVHJhbnNwYXJlbnQgSHVnZXBhZ2UgU3VwcG9ydCBtYXhpbWl6ZXMgdGhlIHVzZWZ1bG5lc3Mgb2YgZnJlZSBtZW1vcnkKK2lmIGNvbXBhcmVkIHRvIHRoZSByZXNlcnZhdGlvbiBhcHByb2FjaCBvZiBodWdldGxiZnMgYnkgYWxsb3dpbmcgYWxsCit1bnVzZWQgbWVtb3J5IHRvIGJlIHVzZWQgYXMgY2FjaGUgb3Igb3RoZXIgbW92YWJsZSAob3IgZXZlbiB1bm1vdmFibGUKK2VudGl0aWVzKS4gSXQgZG9lc24ndCByZXF1aXJlIHJlc2VydmF0aW9uIHRvIHByZXZlbnQgaHVnZXBhZ2UKK2FsbG9jYXRpb24gZmFpbHVyZXMgdG8gYmUgbm90aWNlYWJsZSBmcm9tIHVzZXJsYW5kLiBJdCBhbGxvd3MgcGFnaW5nCithbmQgYWxsIG90aGVyIGFkdmFuY2VkIFZNIGZlYXR1cmVzIHRvIGJlIGF2YWlsYWJsZSBvbiB0aGUKK2h1Z2VwYWdlcy4gSXQgcmVxdWlyZXMgbm8gbW9kaWZpY2F0aW9ucyBmb3IgYXBwbGljYXRpb25zIHRvIHRha2UKK2FkdmFudGFnZSBvZiBpdC4KKworQXBwbGljYXRpb25zIGhvd2V2ZXIgY2FuIGJlIGZ1cnRoZXIgb3B0aW1pemVkIHRvIHRha2UgYWR2YW50YWdlIG9mCit0aGlzIGZlYXR1cmUsIGxpa2UgZm9yIGV4YW1wbGUgdGhleSd2ZSBiZWVuIG9wdGltaXplZCBiZWZvcmUgdG8gYXZvaWQKK2EgZmxvb2Qgb2YgbW1hcCBzeXN0ZW0gY2FsbHMgZm9yIGV2ZXJ5IG1hbGxvYyg0aykuIE9wdGltaXppbmcgdXNlcmxhbmQKK2lzIGJ5IGZhciBub3QgbWFuZGF0b3J5IGFuZCBraHVnZXBhZ2VkIGFscmVhZHkgY2FuIHRha2UgY2FyZSBvZiBsb25nCitsaXZlZCBwYWdlIGFsbG9jYXRpb25zIGV2ZW4gZm9yIGh1Z2VwYWdlIHVuYXdhcmUgYXBwbGljYXRpb25zIHRoYXQKK2RlYWxzIHdpdGggbGFyZ2UgYW1vdW50cyBvZiBtZW1vcnkuCisKK0luIGNlcnRhaW4gY2FzZXMgd2hlbiBodWdlcGFnZXMgYXJlIGVuYWJsZWQgc3lzdGVtIHdpZGUsIGFwcGxpY2F0aW9uCittYXkgZW5kIHVwIGFsbG9jYXRpbmcgbW9yZSBtZW1vcnkgcmVzb3VyY2VzLiBBbiBhcHBsaWNhdGlvbiBtYXkgbW1hcCBhCitsYXJnZSByZWdpb24gYnV0IG9ubHkgdG91Y2ggMSBieXRlIG9mIGl0LCBpbiB0aGF0IGNhc2UgYSAyTSBwYWdlIG1pZ2h0CitiZSBhbGxvY2F0ZWQgaW5zdGVhZCBvZiBhIDRrIHBhZ2UgZm9yIG5vIGdvb2QuIFRoaXMgaXMgd2h5IGl0J3MKK3Bvc3NpYmxlIHRvIGRpc2FibGUgaHVnZXBhZ2VzIHN5c3RlbS13aWRlIGFuZCB0byBvbmx5IGhhdmUgdGhlbSBpbnNpZGUKK01BRFZfSFVHRVBBR0UgbWFkdmlzZSByZWdpb25zLgorCitFbWJlZGRlZCBzeXN0ZW1zIHNob3VsZCBlbmFibGUgaHVnZXBhZ2VzIG9ubHkgaW5zaWRlIG1hZHZpc2UgcmVnaW9ucwordG8gZWxpbWluYXRlIGFueSByaXNrIG9mIHdhc3RpbmcgYW55IHByZWNpb3VzIGJ5dGUgb2YgbWVtb3J5IGFuZCB0bworb25seSBydW4gZmFzdGVyLgorCitBcHBsaWNhdGlvbnMgdGhhdCBnZXRzIGEgbG90IG9mIGJlbmVmaXQgZnJvbSBodWdlcGFnZXMgYW5kIHRoYXQgZG9uJ3QKK3Jpc2sgdG8gbG9zZSBtZW1vcnkgYnkgdXNpbmcgaHVnZXBhZ2VzLCBzaG91bGQgdXNlCittYWR2aXNlKE1BRFZfSFVHRVBBR0UpIG9uIHRoZWlyIGNyaXRpY2FsIG1tYXBwZWQgcmVnaW9ucy4KKworPT0gc3lzZnMgPT0KKworVHJhbnNwYXJlbnQgSHVnZXBhZ2UgU3VwcG9ydCBjYW4gYmUgZW50aXJlbHkgZGlzYWJsZWQgKG1vc3RseSBmb3IKK2RlYnVnZ2luZyBwdXJwb3Nlcykgb3Igb25seSBlbmFibGVkIGluc2lkZSBNQURWX0hVR0VQQUdFIHJlZ2lvbnMgKHRvCithdm9pZCB0aGUgcmlzayBvZiBjb25zdW1pbmcgbW9yZSBtZW1vcnkgcmVzb3VyY2VzKSBvciBlbmFibGVkIHN5c3RlbQord2lkZS4gVGhpcyBjYW4gYmUgYWNoaWV2ZWQgd2l0aCBvbmUgb2Y6CisKK2VjaG8gYWx3YXlzID4vc3lzL2tlcm5lbC9tbS90cmFuc3BhcmVudF9odWdlcGFnZS9lbmFibGVkCitlY2hvIG1hZHZpc2UgPi9zeXMva2VybmVsL21tL3RyYW5zcGFyZW50X2h1Z2VwYWdlL2VuYWJsZWQKK2VjaG8gbmV2ZXIgPi9zeXMva2VybmVsL21tL3RyYW5zcGFyZW50X2h1Z2VwYWdlL2VuYWJsZWQKKworSXQncyBhbHNvIHBvc3NpYmxlIHRvIGxpbWl0IGRlZnJhZyBlZmZvcnRzIGluIHRoZSBWTSB0byBnZW5lcmF0ZQoraHVnZXBhZ2VzIGluIGNhc2UgdGhleSdyZSBub3QgaW1tZWRpYXRlbHkgZnJlZSB0byBtYWR2aXNlIHJlZ2lvbnMgb3IKK3RvIG5ldmVyIHRyeSB0byBkZWZyYWcgbWVtb3J5IGFuZCBzaW1wbHkgZmFsbGJhY2sgdG8gcmVndWxhciBwYWdlcwordW5sZXNzIGh1Z2VwYWdlcyBhcmUgaW1tZWRpYXRlbHkgYXZhaWxhYmxlLiBDbGVhcmx5IGlmIHdlIHNwZW5kIENQVQordGltZSB0byBkZWZyYWcgbWVtb3J5LCB3ZSB3b3VsZCBleHBlY3QgdG8gZ2FpbiBldmVuIG1vcmUgYnkgdGhlIGZhY3QKK3dlIHVzZSBodWdlcGFnZXMgbGF0ZXIgaW5zdGVhZCBvZiByZWd1bGFyIHBhZ2VzLiBUaGlzIGlzbid0IGFsd2F5cworZ3VhcmFudGVlZCwgYnV0IGl0IG1heSBiZSBtb3JlIGxpa2VseSBpbiBjYXNlIHRoZSBhbGxvY2F0aW9uIGlzIGZvciBhCitNQURWX0hVR0VQQUdFIHJlZ2lvbi4KKworZWNobyBhbHdheXMgPi9zeXMva2VybmVsL21tL3RyYW5zcGFyZW50X2h1Z2VwYWdlL2RlZnJhZworZWNobyBtYWR2aXNlID4vc3lzL2tlcm5lbC9tbS90cmFuc3BhcmVudF9odWdlcGFnZS9kZWZyYWcKK2VjaG8gbmV2ZXIgPi9zeXMva2VybmVsL21tL3RyYW5zcGFyZW50X2h1Z2VwYWdlL2RlZnJhZworCitraHVnZXBhZ2VkIHdpbGwgYmUgYXV0b21hdGljYWxseSBzdGFydGVkIHdoZW4KK3RyYW5zcGFyZW50X2h1Z2VwYWdlL2VuYWJsZWQgaXMgc2V0IHRvICJhbHdheXMiIG9yICJtYWR2aXNlLCBhbmQgaXQnbGwKK2JlIGF1dG9tYXRpY2FsbHkgc2h1dGRvd24gaWYgaXQncyBzZXQgdG8gIm5ldmVyIi4KKwora2h1Z2VwYWdlZCBydW5zIHVzdWFsbHkgYXQgbG93IGZyZXF1ZW5jeSBzbyB3aGlsZSBvbmUgbWF5IG5vdCB3YW50IHRvCitpbnZva2UgZGVmcmFnIGFsZ29yaXRobXMgc3luY2hyb25vdXNseSBkdXJpbmcgdGhlIHBhZ2UgZmF1bHRzLCBpdAorc2hvdWxkIGJlIHdvcnRoIGludm9raW5nIGRlZnJhZyBhdCBsZWFzdCBpbiBraHVnZXBhZ2VkLiBIb3dldmVyIGl0J3MKK2Fsc28gcG9zc2libGUgdG8gZGlzYWJsZSBkZWZyYWcgaW4ga2h1Z2VwYWdlZDoKKworZWNobyB5ZXMgPi9zeXMva2VybmVsL21tL3RyYW5zcGFyZW50X2h1Z2VwYWdlL2todWdlcGFnZWQvZGVmcmFnCitlY2hvIG5vID4vc3lzL2tlcm5lbC9tbS90cmFuc3BhcmVudF9odWdlcGFnZS9raHVnZXBhZ2VkL2RlZnJhZworCitZb3UgY2FuIGFsc28gY29udHJvbCBob3cgbWFueSBwYWdlcyBraHVnZXBhZ2VkIHNob3VsZCBzY2FuIGF0IGVhY2gKK3Bhc3M6CisKKy9zeXMva2VybmVsL21tL3RyYW5zcGFyZW50X2h1Z2VwYWdlL2todWdlcGFnZWQvcGFnZXNfdG9fc2NhbgorCithbmQgaG93IG1hbnkgbWlsbGlzZWNvbmRzIHRvIHdhaXQgaW4ga2h1Z2VwYWdlZCBiZXR3ZWVuIGVhY2ggcGFzcyAoeW91CitjYW4gc2V0IHRoaXMgdG8gMCB0byBydW4ga2h1Z2VwYWdlZCBhdCAxMDAlIHV0aWxpemF0aW9uIG9mIG9uZSBjb3JlKToKKworL3N5cy9rZXJuZWwvbW0vdHJhbnNwYXJlbnRfaHVnZXBhZ2Uva2h1Z2VwYWdlZC9zY2FuX3NsZWVwX21pbGxpc2VjcworCithbmQgaG93IG1hbnkgbWlsbGlzZWNvbmRzIHRvIHdhaXQgaW4ga2h1Z2VwYWdlZCBpZiB0aGVyZSdzIGFuIGh1Z2VwYWdlCithbGxvY2F0aW9uIGZhaWx1cmUgdG8gdGhyb3R0bGUgdGhlIG5leHQgYWxsb2NhdGlvbiBhdHRlbXB0LgorCisvc3lzL2tlcm5lbC9tbS90cmFuc3BhcmVudF9odWdlcGFnZS9raHVnZXBhZ2VkL2FsbG9jX3NsZWVwX21pbGxpc2VjcworCitUaGUga2h1Z2VwYWdlZCBwcm9ncmVzcyBjYW4gYmUgc2VlbiBpbiB0aGUgbnVtYmVyIG9mIHBhZ2VzIGNvbGxhcHNlZDoKKworL3N5cy9rZXJuZWwvbW0vdHJhbnNwYXJlbnRfaHVnZXBhZ2Uva2h1Z2VwYWdlZC9wYWdlc19jb2xsYXBzZWQKKworZm9yIGVhY2ggcGFzczoKKworL3N5cy9rZXJuZWwvbW0vdHJhbnNwYXJlbnRfaHVnZXBhZ2Uva2h1Z2VwYWdlZC9mdWxsX3NjYW5zCisKKz09IEJvb3QgcGFyYW1ldGVyID09CisKK1lvdSBjYW4gY2hhbmdlIHRoZSBzeXNmcyBib290IHRpbWUgZGVmYXVsdHMgb2YgVHJhbnNwYXJlbnQgSHVnZXBhZ2UKK1N1cHBvcnQgYnkgcGFzc2luZyB0aGUgcGFyYW1ldGVyICJ0cmFuc3BhcmVudF9odWdlcGFnZT1hbHdheXMiIG9yCisidHJhbnNwYXJlbnRfaHVnZXBhZ2U9bWFkdmlzZSIgb3IgInRyYW5zcGFyZW50X2h1Z2VwYWdlPW5ldmVyIgorKHdpdGhvdXQgIiIpIHRvIHRoZSBrZXJuZWwgY29tbWFuZCBsaW5lLgorCis9PSBOZWVkIG9mIGFwcGxpY2F0aW9uIHJlc3RhcnQgPT0KKworVGhlIHRyYW5zcGFyZW50X2h1Z2VwYWdlL2VuYWJsZWQgdmFsdWVzIG9ubHkgYWZmZWN0IGZ1dHVyZQorYmVoYXZpb3IuIFNvIHRvIG1ha2UgdGhlbSBlZmZlY3RpdmUgeW91IG5lZWQgdG8gcmVzdGFydCBhbnkKK2FwcGxpY2F0aW9uIHRoYXQgY291bGQgaGF2ZSBiZWVuIHVzaW5nIGh1Z2VwYWdlcy4gVGhpcyBhbHNvIGFwcGxpZXMgdG8KK3RoZSByZWdpb25zIHJlZ2lzdGVyZWQgaW4ga2h1Z2VwYWdlZC4KKworPT0gZ2V0X3VzZXJfcGFnZXMgYW5kIGZvbGxvd19wYWdlID09CisKK2dldF91c2VyX3BhZ2VzIGFuZCBmb2xsb3dfcGFnZSBpZiBydW4gb24gYSBodWdlcGFnZSwgd2lsbCByZXR1cm4gdGhlCitoZWFkIG9yIHRhaWwgcGFnZXMgYXMgdXN1YWwgKGV4YWN0bHkgYXMgdGhleSB3b3VsZCBkbyBvbgoraHVnZXRsYmZzKS4gTW9zdCBndXAgdXNlcnMgd2lsbCBvbmx5IGNhcmUgYWJvdXQgdGhlIGFjdHVhbCBwaHlzaWNhbAorYWRkcmVzcyBvZiB0aGUgcGFnZSBhbmQgaXRzIHRlbXBvcmFyeSBwaW5uaW5nIHRvIHJlbGVhc2UgYWZ0ZXIgdGhlIEkvTworaXMgY29tcGxldGUsIHNvIHRoZXkgd29uJ3QgZXZlciBub3RpY2UgdGhlIGZhY3QgdGhlIHBhZ2UgaXMgaHVnZS4gQnV0CitpZiBhbnkgZHJpdmVyIGlzIGdvaW5nIHRvIG1hbmdsZSBvdmVyIHRoZSBwYWdlIHN0cnVjdHVyZSBvZiB0aGUgdGFpbAorcGFnZSAobGlrZSBmb3IgY2hlY2tpbmcgcGFnZS0+bWFwcGluZyBvciBvdGhlciBiaXRzIHRoYXQgYXJlIHJlbGV2YW50Citmb3IgdGhlIGhlYWQgcGFnZSBhbmQgbm90IHRoZSB0YWlsIHBhZ2UpLCBpdCBzaG91bGQgYmUgdXBkYXRlZCB0byBqdW1wCit0byBjaGVjayBoZWFkIHBhZ2UgaW5zdGVhZCAod2hpbGUgc2VyaWFsaXppbmcgcHJvcGVybHkgYWdhaW5zdAorc3BsaXRfaHVnZV9wYWdlKCkgdG8gYXZvaWQgdGhlIGhlYWQgYW5kIHRhaWwgcGFnZXMgdG8gZGlzYXBwZWFyIGZyb20KK3VuZGVyIGl0LCBzZWUgdGhlIGZ1dGV4IGNvZGUgdG8gc2VlIGFuIGV4YW1wbGUgb2YgdGhhdCwgaHVnZXRsYmZzIGFsc28KK25lZWRlZCBzcGVjaWFsIGhhbmRsaW5nIGluIGZ1dGV4IGNvZGUgZm9yIHNpbWlsYXIgcmVhc29ucykuCisKK05PVEU6IHRoZXNlIGFyZW4ndCBuZXcgY29uc3RyYWludHMgdG8gdGhlIEdVUCBBUEksIGFuZCB0aGV5IG1hdGNoIHRoZQorc2FtZSBjb25zdHJhaW5zIHRoYXQgYXBwbGllcyB0byBodWdldGxiZnMgdG9vLCBzbyBhbnkgZHJpdmVyIGNhcGFibGUKK29mIGhhbmRsaW5nIEdVUCBvbiBodWdldGxiZnMgd2lsbCBhbHNvIHdvcmsgZmluZSBvbiB0cmFuc3BhcmVudAoraHVnZXBhZ2UgYmFja2VkIG1hcHBpbmdzLgorCitJbiBjYXNlIHlvdSBjYW4ndCBoYW5kbGUgY29tcG91bmQgcGFnZXMgaWYgdGhleSdyZSByZXR1cm5lZCBieQorZm9sbG93X3BhZ2UsIHRoZSBGT0xMX1NQTElUIGJpdCBjYW4gYmUgc3BlY2lmaWVkIGFzIHBhcmFtZXRlciB0bworZm9sbG93X3BhZ2UsIHNvIHRoYXQgaXQgd2lsbCBzcGxpdCB0aGUgaHVnZXBhZ2VzIGJlZm9yZSByZXR1cm5pbmcKK3RoZW0uIE1pZ3JhdGlvbiBmb3IgZXhhbXBsZSBwYXNzZXMgRk9MTF9TUExJVCBhcyBwYXJhbWV0ZXIgdG8KK2ZvbGxvd19wYWdlIGJlY2F1c2UgaXQncyBub3QgaHVnZXBhZ2UgYXdhcmUgYW5kIGluIGZhY3QgaXQgY2FuJ3Qgd29yaworYXQgYWxsIG9uIGh1Z2V0bGJmcyAoYnV0IGl0IGluc3RlYWQgd29ya3MgZmluZSBvbiB0cmFuc3BhcmVudAoraHVnZXBhZ2VzIHRoYW5rcyB0byBGT0xMX1NQTElUKS4gbWlncmF0aW9uIHNpbXBseSBjYW4ndCBkZWFsIHdpdGgKK2h1Z2VwYWdlcyBiZWluZyByZXR1cm5lZCAoYXMgaXQncyBub3Qgb25seSBjaGVja2luZyB0aGUgcGZuIG9mIHRoZQorcGFnZSBhbmQgcGlubmluZyBpdCBkdXJpbmcgdGhlIGNvcHkgYnV0IGl0IHByZXRlbmRzIHRvIG1pZ3JhdGUgdGhlCittZW1vcnkgaW4gcmVndWxhciBwYWdlIHNpemVzIGFuZCB3aXRoIHJlZ3VsYXIgcHRlL3BtZCBtYXBwaW5ncykuCisKKz09IE9wdGltaXppbmcgdGhlIGFwcGxpY2F0aW9ucyA9PQorCitUbyBiZSBndWFyYW50ZWVkIHRoYXQgdGhlIGtlcm5lbCB3aWxsIG1hcCBhIDJNIHBhZ2UgaW1tZWRpYXRlbHkgaW4gYW55CittZW1vcnkgcmVnaW9uLCB0aGUgbW1hcCByZWdpb24gaGFzIHRvIGJlIGh1Z2VwYWdlIG5hdHVyYWxseQorYWxpZ25lZC4gcG9zaXhfbWVtYWxpZ24oKSBjYW4gcHJvdmlkZSB0aGF0IGd1YXJhbnRlZS4KKworPT0gSHVnZXRsYmZzID09CisKK1lvdSBjYW4gdXNlIGh1Z2V0bGJmcyBvbiBhIGtlcm5lbCB0aGF0IGhhcyB0cmFuc3BhcmVudCBodWdlcGFnZQorc3VwcG9ydCBlbmFibGVkIGp1c3QgZmluZSBhcyBhbHdheXMuIE5vIGRpZmZlcmVuY2UgY2FuIGJlIG5vdGVkIGluCitodWdldGxiZnMgb3RoZXIgdGhhbiB0aGVyZSB3aWxsIGJlIGxlc3Mgb3ZlcmFsbCBmcmFnbWVudGF0aW9uLiBBbGwKK3VzdWFsIGZlYXR1cmVzIGJlbG9uZ2luZyB0byBodWdldGxiZnMgYXJlIHByZXNlcnZlZCBhbmQKK3VuYWZmZWN0ZWQuIGxpYmh1Z2V0bGJmcyB3aWxsIGFsc28gd29yayBmaW5lIGFzIHVzdWFsLgorCis9PSBHcmFjZWZ1bCBmYWxsYmFjayA9PQorCitDb2RlIHdhbGtpbmcgcGFnZXRhYmxlcyBidXQgdW53YXJlIGFib3V0IGh1Z2UgcG1kcyBjYW4gc2ltcGx5IGNhbGwKK3NwbGl0X2h1Z2VfcGFnZV9wbWQobW0sIHBtZCkgd2hlcmUgdGhlIHBtZCBpcyB0aGUgb25lIHJldHVybmVkIGJ5CitwbWRfb2Zmc2V0LiBJdCdzIHRyaXZpYWwgdG8gbWFrZSB0aGUgY29kZSB0cmFuc3BhcmVudCBodWdlcGFnZSBhd2FyZQorYnkganVzdCBncmVwcGluZyBmb3IgInBtZF9vZmZzZXQiIGFuZCBhZGRpbmcgc3BsaXRfaHVnZV9wYWdlX3BtZCB3aGVyZQorbWlzc2luZyBhZnRlciBwbWRfb2Zmc2V0IHJldHVybnMgdGhlIHBtZC4gVGhhbmtzIHRvIHRoZSBncmFjZWZ1bAorZmFsbGJhY2sgZGVzaWduLCB3aXRoIGEgb25lIGxpbmVyIGNoYW5nZSwgeW91IGNhbiBhdm9pZCB0byB3cml0ZQoraHVuZHJlZCBpZiBub3QgdGhvdXNhbmQgb2YgbGluZXMgb2YgY29tcGxleCBjb2RlIHRvIG1ha2UgeW91ciBjb2RlCitodWdlcGFnZSBhd2FyZS4KKworSWYgeW91J3JlIG5vdCB3YWxraW5nIHBhZ2V0YWJsZXMgYnV0IHlvdSBydW4gaW50byBhIHBoeXNpY2FsIGh1Z2VwYWdlCitidXQgeW91IGNhbid0IGhhbmRsZSBpdCBuYXRpdmVseSBpbiB5b3VyIGNvZGUsIHlvdSBjYW4gc3BsaXQgaXQgYnkKK2NhbGxpbmcgc3BsaXRfaHVnZV9wYWdlKHBhZ2UpLiBUaGlzIGlzIHdoYXQgdGhlIExpbnV4IFZNIGRvZXMgYmVmb3JlCitpdCB0cmllcyB0byBzd2Fwb3V0IHRoZSBodWdlcGFnZSBmb3IgZXhhbXBsZS4KKworRXhhbXBsZSB0byBtYWtlIG1yZW1hcC5jIHRyYW5zcGFyZW50IGh1Z2VwYWdlIGF3YXJlIHdpdGggYSBvbmUgbGluZXIKK2NoYW5nZToKKworZGlmZiAtLWdpdCBhL21tL21yZW1hcC5jIGIvbW0vbXJlbWFwLmMKKy0tLSBhL21tL21yZW1hcC5jCisrKysgYi9tbS9tcmVtYXAuYworQEAgLTQxLDYgKzQxLDcgQEAgc3RhdGljIHBtZF90ICpnZXRfb2xkX3BtZChzdHJ1Y3QgbW1fc3RydQorCQlyZXR1cm4gTlVMTDsKKworCXBtZCA9IHBtZF9vZmZzZXQocHVkLCBhZGRyKTsKKysJc3BsaXRfaHVnZV9wYWdlX3BtZChtbSwgcG1kKTsKKwlpZiAocG1kX25vbmVfb3JfY2xlYXJfYmFkKHBtZCkpCisJCXJldHVybiBOVUxMOworCis9PSBMb2NraW5nIGluIGh1Z2VwYWdlIGF3YXJlIGNvZGUgPT0KKworV2Ugd2FudCBhcyBtdWNoIGNvZGUgYXMgcG9zc2libGUgaHVnZXBhZ2UgYXdhcmUsIGFzIGNhbGxpbmcKK3NwbGl0X2h1Z2VfcGFnZSgpIG9yIHNwbGl0X2h1Z2VfcGFnZV9wbWQoKSBoYXMgYSBjb3N0LgorCitUbyBtYWtlIHBhZ2V0YWJsZSB3YWxrcyBodWdlIHBtZCBhd2FyZSwgYWxsIHlvdSBuZWVkIHRvIGRvIGlzIHRvIGNhbGwKK3BtZF90cmFuc19odWdlKCkgb24gdGhlIHBtZCByZXR1cm5lZCBieSBwbWRfb2Zmc2V0LiBZb3UgbXVzdCBob2xkIHRoZQorbW1hcF9zZW0gaW4gcmVhZCAob3Igd3JpdGUpIG1vZGUgdG8gYmUgc3VyZSBhbiBodWdlIHBtZCBjYW5ub3QgYmUKK2NyZWF0ZWQgZnJvbSB1bmRlciB5b3UgYnkga2h1Z2VwYWdlZCAoa2h1Z2VwYWdlZCBjb2xsYXBzZV9odWdlX3BhZ2UKK3Rha2VzIHRoZSBtbWFwX3NlbSBpbiB3cml0ZSBtb2RlIGluIGFkZGl0aW9uIHRvIHRoZSBhbm9uX3ZtYSBsb2NrKS4gSWYKK3BtZF90cmFuc19odWdlIHJldHVybnMgZmFsc2UsIHlvdSBqdXN0IGZhbGxiYWNrIGluIHRoZSBvbGQgY29kZQorcGF0aHMuIElmIGluc3RlYWQgcG1kX3RyYW5zX2h1Z2UgcmV0dXJucyB0cnVlLCB5b3UgaGF2ZSB0byB0YWtlIHRoZQorbW0tPnBhZ2VfdGFibGVfbG9jayBhbmQgcmUtcnVuIHBtZF90cmFuc19odWdlLiBUYWtpbmcgdGhlCitwYWdlX3RhYmxlX2xvY2sgd2lsbCBwcmV2ZW50IHRoZSBodWdlIHBtZCB0byBiZSBjb252ZXJ0ZWQgaW50byBhCityZWd1bGFyIHBtZCBmcm9tIHVuZGVyIHlvdSAoc3BsaXRfaHVnZV9wYWdlIGNhbiBydW4gaW4gcGFyYWxsZWwgdG8gdGhlCitwYWdldGFibGUgd2FsaykuIElmIHRoZSBzZWNvbmQgcG1kX3RyYW5zX2h1Z2UgcmV0dXJucyBmYWxzZSwgeW91CitzaG91bGQganVzdCBkcm9wIHRoZSBwYWdlX3RhYmxlX2xvY2sgYW5kIGZhbGxiYWNrIHRvIHRoZSBvbGQgY29kZSBhcworYmVmb3JlLiBPdGhlcndpc2UgeW91IHNob3VsZCBydW4gcG1kX3RyYW5zX3NwbGl0dGluZyBvbiB0aGUgcG1kLiBJbgorY2FzZSBwbWRfdHJhbnNfc3BsaXR0aW5nIHJldHVybnMgdHJ1ZSwgaXQgbWVhbnMgc3BsaXRfaHVnZV9wYWdlIGlzCithbHJlYWR5IGluIHRoZSBtaWRkbGUgb2Ygc3BsaXR0aW5nIHRoZSBwYWdlLiBTbyBpZiBwbWRfdHJhbnNfc3BsaXR0aW5nCityZXR1cm5zIHRydWUgaXQncyBlbm91Z2ggdG8gZHJvcCB0aGUgcGFnZV90YWJsZV9sb2NrIGFuZCBjYWxsCit3YWl0X3NwbGl0X2h1Z2VfcGFnZSBhbmQgdGhlbiBmYWxsYmFjayB0aGUgb2xkIGNvZGUgcGF0aHMuIFlvdSBhcmUKK2d1YXJhbnRlZWQgYnkgdGhlIHRpbWUgd2FpdF9zcGxpdF9odWdlX3BhZ2UgcmV0dXJucywgdGhlIHBtZCBpc24ndAoraHVnZSBhbnltb3JlLiBJZiBwbWRfdHJhbnNfc3BsaXR0aW5nIHJldHVybnMgZmFsc2UsIHlvdSBjYW4gcHJvY2VlZCB0bworcHJvY2VzcyB0aGUgaHVnZSBwbWQgYW5kIHRoZSBodWdlcGFnZSBuYXRpdmVseS4gT25jZSBmaW5pc2hlZCB5b3UgY2FuCitkcm9wIHRoZSBwYWdlX3RhYmxlX2xvY2suCisKKz09IGNvbXBvdW5kX2xvY2ssIGdldF91c2VyX3BhZ2VzIGFuZCBwdXRfcGFnZSA9PQorCitzcGxpdF9odWdlX3BhZ2UgaW50ZXJuYWxseSBoYXMgdG8gZGlzdHJpYnV0ZSB0aGUgcmVmY291bnRzIGluIHRoZSBoZWFkCitwYWdlIHRvIHRoZSB0YWlsIHBhZ2VzIGJlZm9yZSBjbGVhcmluZyBhbGwgUEdfaGVhZC90YWlsIGJpdHMgZnJvbSB0aGUKK3BhZ2Ugc3RydWN0dXJlcy4gSXQgY2FuIGRvIHRoYXQgZWFzaWx5IGZvciByZWZjb3VudHMgdGFrZW4gYnkgaHVnZSBwbWQKK21hcHBpbmdzLiBCdXQgdGhlIEdVSSBBUEkgYXMgY3JlYXRlZCBieSBodWdldGxiZnMgKHRoYXQgcmV0dXJucyBoZWFkCithbmQgdGFpbCBwYWdlcyBpZiBydW5uaW5nIGdldF91c2VyX3BhZ2VzIG9uIGFuIGFkZHJlc3MgYmFja2VkIGJ5IGFueQoraHVnZXBhZ2UpLCByZXF1aXJlcyB0aGUgcmVmY291bnQgdG8gYmUgYWNjb3VudGVkIG9uIHRoZSB0YWlsIHBhZ2VzIGFuZAorbm90IG9ubHkgaW4gdGhlIGhlYWQgcGFnZXMsIGlmIHdlIHdhbnQgdG8gYmUgYWJsZSB0byBydW4KK3NwbGl0X2h1Z2VfcGFnZSB3aGlsZSB0aGVyZSBhcmUgZ3VwIHBpbnMgZXN0YWJsaXNoZWQgb24gYW55IHRhaWwKK3BhZ2UuIEZhaWx1cmUgdG8gYmUgYWJsZSB0byBydW4gc3BsaXRfaHVnZV9wYWdlIGlmIHRoZXJlJ3MgYW55IGd1cCBwaW4KK29uIGFueSB0YWlsIHBhZ2UsIHdvdWxkIG1lYW4gaGF2aW5nIHRvIHNwbGl0IGFsbCBodWdlcGFnZXMgdXBmcm9udCBpbgorZ2V0X3VzZXJfcGFnZXMgd2hpY2ggaXMgdW5hY2NlcHRhYmxlIGFzIHRvbyBtYW55IGd1cCB1c2VycyBhcmUKK3BlcmZvcm1hbmNlIGNyaXRpY2FsIGFuZCB0aGV5IG11c3Qgd29yayBuYXRpdmVseSBvbiBodWdlcGFnZXMgbGlrZQordGhleSB3b3JrIG5hdGl2ZWx5IG9uIGh1Z2V0bGJmcyBhbHJlYWR5IChodWdldGxiZnMgaXMgc2ltcGxlciBiZWNhdXNlCitodWdldGxiZnMgcGFnZXMgY2Fubm90IGJlIHNwbGl0dGVkIHNvIHRoZXJlIHdvdWxkbid0IGJlIHJlcXVpcmVtZW50IG9mCithY2NvdW50aW5nIHRoZSBwaW5zIG9uIHRoZSB0YWlsIHBhZ2VzIGZvciBodWdldGxiZnMpLiBJZiB3ZSB3b3VsZG4ndAorYWNjb3VudCB0aGUgZ3VwIHJlZmNvdW50cyBvbiB0aGUgdGFpbCBwYWdlcyBkdXJpbmcgZ3VwLCB3ZSB3b24ndCBrbm93Cithbnltb3JlIHdoaWNoIHRhaWwgcGFnZSBpcyBwaW5uZWQgYnkgZ3VwIGFuZCB3aGljaCBpcyBub3Qgd2hpbGUgd2UgcnVuCitzcGxpdF9odWdlX3BhZ2UuIEJ1dCB3ZSBzdGlsbCBoYXZlIHRvIGFkZCB0aGUgZ3VwIHBpbiB0byB0aGUgaGVhZCBwYWdlCit0b28sIHRvIGtub3cgd2hlbiB3ZSBjYW4gZnJlZSB0aGUgY29tcG91bmQgcGFnZSBpbiBjYXNlIGl0J3MgbmV2ZXIKK3NwbGl0dGVkIGR1cmluZyBpdHMgbGlmZXRpbWUuIFRoYXQgcmVxdWlyZXMgY2hhbmdpbmcgbm90IGp1c3QKK2dldF9wYWdlLCBidXQgcHV0X3BhZ2UgYXMgd2VsbCBzbyB0aGF0IHdoZW4gcHV0X3BhZ2UgcnVucyBvbiBhIHRhaWwKK3BhZ2UgKGFuZCBvbmx5IG9uIGEgdGFpbCBwYWdlKSBpdCB3aWxsIGZpbmQgaXRzIHJlc3BlY3RpdmUgaGVhZCBwYWdlLAorYW5kIHRoZW4gaXQgd2lsbCBkZWNyZWFzZSB0aGUgaGVhZCBwYWdlIHJlZmNvdW50IGluIGFkZGl0aW9uIHRvIHRoZQordGFpbCBwYWdlIHJlZmNvdW50LiBUbyBvYnRhaW4gYSBoZWFkIHBhZ2UgcmVsaWFibHkgYW5kIHRvIGRlY3JlYXNlIGl0cworcmVmY291bnQgd2l0aG91dCByYWNlIGNvbmRpdGlvbnMsIHB1dF9wYWdlIGhhcyB0byBzZXJpYWxpemUgYWdhaW5zdAorX19zcGxpdF9odWdlX3BhZ2VfcmVmY291bnQgdXNpbmcgYSBzcGVjaWFsIHBlci1wYWdlIGxvY2sgY2FsbGVkCitjb21wb3VuZF9sb2NrLgpkaWZmIC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJTkVSUwppbmRleCBlYzAyM2JjLi5iNmQ2ZDUxIDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysgYi9NQUlOVEFJTkVSUwpAQCAtMTYyLDcgKzE2Miw3IEBACiBXOglodHRwOi8vc2VyaWFsLnNvdXJjZWZvcmdlLm5ldAogUzoJTWFpbnRhaW5lZAogVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC9ncmVna2gvdHR5LTIuNi5naXQKLUY6CWRyaXZlcnMvc2VyaWFsLzgyNTAqCitGOglkcml2ZXJzL3R0eS9zZXJpYWwvODI1MCoKIEY6CWluY2x1ZGUvbGludXgvc2VyaWFsXzgyNTAuaAogCiA4MzkwIE5FVFdPUksgRFJJVkVSUyBbV0Q4MHgzL1NNQy1FTElURSwgU01DLVVMVFJBLCBORTIwMDAsIDNDNTAzLCBldGMuXQpAQCAtNjI0LDExICs2MjQsMTUgQEAKIEw6CWxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZyAobW9kZXJhdGVkIGZvciBub24tc3Vic2NyaWJlcnMpCiBTOglNYWludGFpbmVkCiAKLUFSTS9BVE1FTCBBVDkxUk05MjAwIEFSTSBBUkNISVRFQ1RVUkUKK0FSTS9BVE1FTCBBVDkxUk05MjAwIEFORCBBVDkxU0FNIEFSTSBBUkNISVRFQ1RVUkVTCiBNOglBbmRyZXcgVmljdG9yIDxsaW51eEBtYXhpbS5vcmcuemE+CitNOglOaWNvbGFzIEZlcnJlIDxuaWNvbGFzLmZlcnJlQGF0bWVsLmNvbT4KK006CUplYW4tQ2hyaXN0b3BoZSBQbGFnbmlvbC1WaWxsYXJkIDxwbGFnbmlvakBqY3Jvc29mdC5jb20+CiBMOglsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcgKG1vZGVyYXRlZCBmb3Igbm9uLXN1YnNjcmliZXJzKQogVzoJaHR0cDovL21heGltLm9yZy56YS9hdDkxXzI2Lmh0bWwKLVM6CU1haW50YWluZWQKK1c6CWh0dHA6Ly93d3cubGludXg0c2FtLm9yZworUzoJU3VwcG9ydGVkCitGOglhcmNoL2FybS9tYWNoLWF0OTEvCiAKIEFSTS9CQ01SSU5HIEFSTSBBUkNISVRFQ1RVUkUKIE06CUppYW5kb25nIFpoZW5nIDxqZHpoZW5nQGJyb2FkY29tLmNvbT4KQEAgLTg4OCw4ICs4OTIsOCBAQAogRjoJZHJpdmVycy92aWRlby9tc20vCiBGOglkcml2ZXJzL21tYy9ob3N0L21zbV9zZGNjLmMKIEY6CWRyaXZlcnMvbW1jL2hvc3QvbXNtX3NkY2MuaAotRjoJZHJpdmVycy9zZXJpYWwvbXNtX3NlcmlhbC5oCi1GOglkcml2ZXJzL3NlcmlhbC9tc21fc2VyaWFsLmMKK0Y6CWRyaXZlcnMvdHR5L3NlcmlhbC9tc21fc2VyaWFsLmgKK0Y6CWRyaXZlcnMvdHR5L3NlcmlhbC9tc21fc2VyaWFsLmMKIFQ6CWdpdCBnaXQ6Ly9jb2RlYXVyb3JhLm9yZy9xdWljL2tlcm5lbC9kYXZpZGIvbGludXgtbXNtLmdpdAogUzoJTWFpbnRhaW5lZAogCkBAIC05NzQsNiArOTc4LDggQEAKIEY6CWFyY2gvYXJtL3BsYXQtc2Ftc3VuZy8KIEY6CWFyY2gvYXJtL3BsYXQtczNjMjR4eC8KIEY6CWFyY2gvYXJtL3BsYXQtczVwLworRjoJZHJpdmVycy8qLypzM2MyNDEwKgorRjoJZHJpdmVycy8qLyovKnMzYzI0MTAqCiAKIEFSTS9TM0MyNDEwIEFSTSBBUkNISVRFQ1RVUkUKIE06CUJlbiBEb29rcyA8YmVuLWxpbnV4QGZsdWZmLm9yZz4KQEAgLTEyNTYsNyArMTI2Miw3IEBACiBBVE1FTCBBVDkxIC8gQVQzMiBTRVJJQUwgRFJJVkVSCiBNOglOaWNvbGFzIEZlcnJlIDxuaWNvbGFzLmZlcnJlQGF0bWVsLmNvbT4KIFM6CVN1cHBvcnRlZAotRjoJZHJpdmVycy9zZXJpYWwvYXRtZWxfc2VyaWFsLmMKK0Y6CWRyaXZlcnMvdHR5L3NlcmlhbC9hdG1lbF9zZXJpYWwuYwogCiBBVE1FTCBMQ0RGQiBEUklWRVIKIE06CU5pY29sYXMgRmVycmUgPG5pY29sYXMuZmVycmVAYXRtZWwuY29tPgpAQCAtMTQxMiw3ICsxNDE4LDcgQEAKIEw6CXVjbGludXgtZGlzdC1kZXZlbEBibGFja2Zpbi51Y2xpbnV4Lm9yZwogVzoJaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnCiBTOglTdXBwb3J0ZWQKLUY6CWRyaXZlcnMvc2VyaWFsL2JmaW5fNXh4LmMKK0Y6CWRyaXZlcnMvdHR5L3NlcmlhbC9iZmluXzV4eC5jCiAKIEJMQUNLRklOIFdBVENIRE9HIERSSVZFUgogTToJTWlrZSBGcnlzaW5nZXIgPHZhcGllci5hZGlAZ21haWwuY29tPgpAQCAtMTg3Nyw3ICsxODgzLDcgQEAKIFc6CWh0dHA6Ly9kZXZlbG9wZXIuYXhpcy5jb20KIFM6CU1haW50YWluZWQKIEY6CWFyY2gvY3Jpcy8KLUY6CWRyaXZlcnMvc2VyaWFsL2NyaXN2MTAuKgorRjoJZHJpdmVycy90dHkvc2VyaWFsL2NyaXN2MTAuKgogCiBDUllQVE8gQVBJCiBNOglIZXJiZXJ0IFh1IDxoZXJiZXJ0QGdvbmRvci5hcGFuYS5vcmcuYXU+CkBAIC0yMjE2LDcgKzIyMjIsNyBAQAogRFogREVDU1RBVElPTiBEWjExIFNFUklBTCBEUklWRVIKIE06CSJNYWNpZWogVy4gUm96eWNraSIgPG1hY3JvQGxpbnV4LW1pcHMub3JnPgogUzoJTWFpbnRhaW5lZAotRjoJZHJpdmVycy9zZXJpYWwvZHouKgorRjoJZHJpdmVycy90dHkvc2VyaWFsL2R6LioKIAogRUFUQS1ETUEgU0NTSSBEUklWRVIKIE06CU1pY2hhZWwgTmV1ZmZlciA8bWlrZUBpLUNvbm5lY3QuTmV0PgpAQCAtMjY0Myw3ICsyNjQ5LDcgQEAKIE06CVRpbXVyIFRhYmkgPHRpbXVyQGZyZWVzY2FsZS5jb20+CiBMOglsaW51eHBwYy1kZXZAbGlzdHMub3psYWJzLm9yZwogUzoJU3VwcG9ydGVkCi1GOglkcml2ZXJzL3NlcmlhbC91Y2NfdWFydC5jCitGOglkcml2ZXJzL3R0eS9zZXJpYWwvdWNjX3VhcnQuYwogCiBGUkVFU0NBTEUgU09DIFNPVU5EIERSSVZFUlMKIE06CVRpbXVyIFRhYmkgPHRpbXVyQGZyZWVzY2FsZS5jb20+CkBAIC0yNzY4LDYgKzI3NzQsMTUgQEAKIEY6CWRyaXZlcnMvaXNkbi9naWdhc2V0LwogRjoJaW5jbHVkZS9saW51eC9naWdhc2V0X2Rldi5oCiAKK0dQSU8gU1VCU1lTVEVNCitNOglHcmFudCBMaWtlbHkgPGdyYW50Lmxpa2VseUBzZWNyZXRsYWIuY2E+CitMOglsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3JnCitTOglNYWludGFpbmVkCitUOglnaXQgZ2l0Oi8vZ2l0LnNlY3JldGxhYi5jYS9naXQvbGludXgtMi42LmdpdAorRjoJRG9jdW1lbnRhdGlvbi9ncGlvL2dwaW8udHh0CitGOglkcml2ZXJzL2dwaW8vCitGOglpbmNsdWRlL2xpbnV4L2dwaW8qCisKIEdSRVRIIDEwLzEwMC8xRyBFdGhlcm5ldCBNQUMgZGV2aWNlIGRyaXZlcgogTToJS3Jpc3RvZmZlciBHbGVtYm8gPGtyaXN0b2ZmZXJAZ2Fpc2xlci5jb20+CiBMOgluZXRkZXZAdmdlci5rZXJuZWwub3JnCkBAIC0zMTM1LDYgKzMxNTAsMTIgQEAKIEY6CW5ldC9pZWVlODAyMTU0LwogRjoJZHJpdmVycy9pZWVlODAyMTU0LwogCitJS0FOT1MvQURJIEVBR0xFIEFEU0wgVVNCIERSSVZFUgorTToJTWF0dGhpZXUgQ2FzdGV0IDxjYXN0ZXQubWF0dGhpZXVAZnJlZS5mcj4KK006CVN0YW5pc2xhdyBHcnVzemthIDxzdGZfeGxAd3AucGw+CitTOglNYWludGFpbmVkCitGOglkcml2ZXJzL3VzYi9hdG0vdWVhZ2xlLWF0bS5jCisKIElOVEVHUklUWSBNRUFTVVJFTUVOVCBBUkNISVRFQ1RVUkUgKElNQSkKIE06CU1pbWkgWm9oYXIgPHpvaGFyQHVzLmlibS5jb20+CiBTOglTdXBwb3J0ZWQKQEAgLTMxNDYsNyArMzE2Nyw3IEBACiBGOglkcml2ZXJzL3ZpZGVvL2ltc3R0ZmIuYwogCiBJTkZJTklCQU5EIFNVQlNZU1RFTQotTToJUm9sYW5kIERyZWllciA8cm9sYW5kZEBjaXNjby5jb20+CitNOglSb2xhbmQgRHJlaWVyIDxyb2xhbmRAa2VybmVsLm9yZz4KIE06CVNlYW4gSGVmdHkgPHNlYW4uaGVmdHlAaW50ZWwuY29tPgogTToJSGFsIFJvc2Vuc3RvY2sgPGhhbC5yb3NlbnN0b2NrQGdtYWlsLmNvbT4KIEw6CWxpbnV4LXJkbWFAdmdlci5rZXJuZWwub3JnCkBAIC0zMzIzLDcgKzMzNDQsNiBAQAogRjoJaW5jbHVkZS9saW51eC93aW1heC9pMjQwMG0uaAogCiBJTlRFTCBXSVJFTEVTUyBXSUZJIExJTksgKGl3bHdpZmkpCi1NOglSZWluZXR0ZSBDaGF0cmUgPHJlaW5ldHRlLmNoYXRyZUBpbnRlbC5jb20+CiBNOglXZXktWWkgR3V5IDx3ZXkteWkudy5ndXlAaW50ZWwuY29tPgogTToJSW50ZWwgTGludXggV2lyZWxlc3MgPGlsd0BsaW51eC5pbnRlbC5jb20+CiBMOglsaW51eC13aXJlbGVzc0B2Z2VyLmtlcm5lbC5vcmcKQEAgLTMzNTAsNyArMzM3MCw3IEBACiBNOglQYXQgR2VmcmUgPHBmZ0BzZ2kuY29tPgogTDoJbGludXgtc2VyaWFsQHZnZXIua2VybmVsLm9yZwogUzoJTWFpbnRhaW5lZAotRjoJZHJpdmVycy9zZXJpYWwvaW9jM19zZXJpYWwuYworRjoJZHJpdmVycy90dHkvc2VyaWFsL2lvYzNfc2VyaWFsLmMKIAogSVAgTUFTUVVFUkFESU5HCiBNOglKdWFuam8gQ2lhcmxhbnRlIDxqamNpYXJsYUByYWl6LnVuY3UuZWR1LmFyPgpAQCAtMzUyOCw3ICszNTQ4LDcgQEAKIE06CUJyZW5vIExlaXRhbyA8bGVpdGFvQGxpbnV4LnZuZXQuaWJtLmNvbT4KIEw6CWxpbnV4LXNlcmlhbEB2Z2VyLmtlcm5lbC5vcmcKIFM6CU1haW50YWluZWQKLUY6CWRyaXZlcnMvc2VyaWFsL2pzbS8KK0Y6CWRyaXZlcnMvdHR5L3NlcmlhbC9qc20vCiAKIEsxMFRFTVAgSEFSRFdBUkUgTU9OSVRPUklORyBEUklWRVIKIE06CUNsZW1lbnMgTGFkaXNjaCA8Y2xlbWVuc0BsYWRpc2NoLmRlPgpAQCAtMzY3MSw2ICszNjkxLDI4IEBACiBGOglpbmNsdWRlL2tleXMvCiBGOglzZWN1cml0eS9rZXlzLwogCitLRVlTLVRSVVNURUQKK006CURhdmlkIFNhZmZvcmQgPHNhZmZvcmRAd2F0c29uLmlibS5jb20+CitNOglNaW1pIFpvaGFyIDx6b2hhckB1cy5pYm0uY29tPgorTDoJbGludXgtc2VjdXJpdHktbW9kdWxlQHZnZXIua2VybmVsLm9yZworTDoJa2V5cmluZ3NAbGludXgtbmZzLm9yZworUzoJU3VwcG9ydGVkCitGOglEb2N1bWVudGF0aW9uL2tleXMtdHJ1c3RlZC1lbmNyeXB0ZWQudHh0CitGOglpbmNsdWRlL2tleXMvdHJ1c3RlZC10eXBlLmgKK0Y6CXNlY3VyaXR5L2tleXMvdHJ1c3RlZC5jCitGOglzZWN1cml0eS9rZXlzL3RydXN0ZWQuaAorCitLRVlTLUVOQ1JZUFRFRAorTToJTWltaSBab2hhciA8em9oYXJAdXMuaWJtLmNvbT4KK006CURhdmlkIFNhZmZvcmQgPHNhZmZvcmRAd2F0c29uLmlibS5jb20+CitMOglsaW51eC1zZWN1cml0eS1tb2R1bGVAdmdlci5rZXJuZWwub3JnCitMOglrZXlyaW5nc0BsaW51eC1uZnMub3JnCitTOglTdXBwb3J0ZWQKK0Y6CURvY3VtZW50YXRpb24va2V5cy10cnVzdGVkLWVuY3J5cHRlZC50eHQKK0Y6CWluY2x1ZGUva2V5cy9lbmNyeXB0ZWQtdHlwZS5oCitGOglzZWN1cml0eS9rZXlzL2VuY3J5cHRlZC5jCitGOglzZWN1cml0eS9rZXlzL2VuY3J5cHRlZC5oCisKIEtHREIgLyBLREIgL2RlYnVnX2NvcmUKIE06CUphc29uIFdlc3NlbCA8amFzb24ud2Vzc2VsQHdpbmRyaXZlci5jb20+CiBXOglodHRwOi8va2dkYi53aWtpLmtlcm5lbC5vcmcvCkBAIC0zNjc4LDE0ICszNzIwLDE0IEBACiBTOglNYWludGFpbmVkCiBGOglEb2N1bWVudGF0aW9uL0RvY0Jvb2sva2dkYi50bXBsCiBGOglkcml2ZXJzL21pc2Mva2dkYnRzLmMKLUY6CWRyaXZlcnMvc2VyaWFsL2tnZGJvYy5jCitGOglkcml2ZXJzL3R0eS9zZXJpYWwva2dkYm9jLmMKIEY6CWluY2x1ZGUvbGludXgva2RiLmgKIEY6CWluY2x1ZGUvbGludXgva2dkYi5oCiBGOglrZXJuZWwvZGVidWcvCiAKIEtNRU1DSEVDSwogTToJVmVnYXJkIE5vc3N1bSA8dmVnYXJkbm9AaWZpLnVpby5ubz4KLU06CVBla2thIEVuYmVyZyA8cGVuYmVyZ0Bjcy5oZWxzaW5raS5maT4KK006CVBla2thIEVuYmVyZyA8cGVuYmVyZ0BrZXJuZWwub3JnPgogUzoJTWFpbnRhaW5lZAogRjoJRG9jdW1lbnRhdGlvbi9rbWVtY2hlY2sudHh0CiBGOglhcmNoL3g4Ni9pbmNsdWRlL2FzbS9rbWVtY2hlY2suaApAQCAtNDU1OSw3ICs0NjAxLDcgQEAKIAogT1BFTiBGSVJNV0FSRSBBTkQgRkxBVFRFTkVEIERFVklDRSBUUkVFCiBNOglHcmFudCBMaWtlbHkgPGdyYW50Lmxpa2VseUBzZWNyZXRsYWIuY2E+Ci1MOglkZXZpY2V0cmVlLWRpc2N1c3NAbGlzdHMub3psYWJzLm9yZworTDoJZGV2aWNldHJlZS1kaXNjdXNzQGxpc3RzLm96bGFicy5vcmcgKG1vZGVyYXRlZCBmb3Igbm9uLXN1YnNjcmliZXJzKQogVzoJaHR0cDovL2ZkdC5zZWNyZXRsYWIuY2EKIFQ6CWdpdCBnaXQ6Ly9naXQuc2VjcmV0bGFiLmNhL2dpdC9saW51eC0yLjYuZ2l0CiBTOglNYWludGFpbmVkCkBAIC01MjczLDggKzUzMTUsNyBAQAogRjoJZHJpdmVycy9zMzkwL25ldC8KIAogUzM5MCBaQ1JZUFQgRFJJVkVSCi1NOglGZWxpeCBCZWNrIDxmZWxpeC5iZWNrQGRlLmlibS5jb20+Ci1NOglSYWxwaCBXdWVydGhuZXIgPHJhbHBoLnd1ZXJ0aG5lckBkZS5pYm0uY29tPgorTToJSG9sZ2VyIERlbmdsZXIgPGhkQGxpbnV4LnZuZXQuaWJtLmNvbT4KIE06CWxpbnV4MzkwQGRlLmlibS5jb20KIEw6CWxpbnV4LXMzOTBAdmdlci5rZXJuZWwub3JnCiBXOglodHRwOi8vd3d3LmlibS5jb20vZGV2ZWxvcGVyd29ya3MvbGludXgvbGludXgzOTAvCkBAIC01NTIwLDEyICs1NTYxLDExIEBACiBGOglkcml2ZXJzL3Njc2kvYmUyaXNjc2kvCiAKIFNFUlZFUiBFTkdJTkVTIDEwR2JwcyBOSUMgLSBCbGFkZUVuZ2luZSAyIERSSVZFUgotTToJU2F0aHlhIFBlcmxhIDxzYXRoeWFwQHNlcnZlcmVuZ2luZXMuY29tPgotTToJU3ViYnUgU2VldGhhcmFtYW4gPHN1YmJ1c0BzZXJ2ZXJlbmdpbmVzLmNvbT4KLU06CVNhcnZlc2h3YXIgQmFuZGkgPHNhcnZlc2h3YXJiQHNlcnZlcmVuZ2luZXMuY29tPgotTToJQWppdCBLaGFwYXJkZSA8YWppdGtAc2VydmVyZW5naW5lcy5jb20+CitNOglTYXRoeWEgUGVybGEgPHNhdGh5YS5wZXJsYUBlbXVsZXguY29tPgorTToJU3ViYnUgU2VldGhhcmFtYW4gPHN1YmJ1LnNlZXRoYXJhbWFuQGVtdWxleC5jb20+CitNOglBaml0IEtoYXBhcmRlIDxhaml0LmtoYXBhcmRlQGVtdWxleC5jb20+CiBMOgluZXRkZXZAdmdlci5rZXJuZWwub3JnCi1XOglodHRwOi8vd3d3LnNlcnZlcmVuZ2luZXMuY29tCitXOglodHRwOi8vd3d3LmVtdWxleC5jb20KIFM6CVN1cHBvcnRlZAogRjoJZHJpdmVycy9uZXQvYmVuZXQvCiAKQEAgLTU1NDcsNyArNTU4Nyw3IEBACiBMOglsaW51eC1pYTY0QHZnZXIua2VybmVsLm9yZwogUzoJU3VwcG9ydGVkCiBGOglEb2N1bWVudGF0aW9uL2lhNjQvc2VyaWFsLnR4dAotRjoJZHJpdmVycy9zZXJpYWwvaW9jP19zZXJpYWwuYworRjoJZHJpdmVycy90dHkvc2VyaWFsL2lvYz9fc2VyaWFsLmMKIEY6CWluY2x1ZGUvbGludXgvaW9jPy5oCiAKIFNHSSBWSVNVQUwgV09SS1NUQVRJT04gMzIwIEFORCA1NDAKQEAgLTU1NjksNyArNTYwOSw3IEBACiBTOglNYWludGFpbmVkCiBGOglEb2N1bWVudGF0aW9uL2FybS9TaGFycC1MSC9BREMtTEg3LVRvdWNoc2NyZWVuCiBGOglhcmNoL2FybS9tYWNoLWxoN2E0MHgvCi1GOglkcml2ZXJzL3NlcmlhbC9zZXJpYWxfbGg3YTQweC5jCitGOglkcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX2xoN2E0MHguYwogRjoJZHJpdmVycy91c2IvZ2FkZ2V0L2xoN2E0MCoKIEY6CWRyaXZlcnMvdXNiL2hvc3Qvb2hjaS1saDdhNDAqCiAKQEAgLTU1ODUsMTggKzU2MjUsMjAgQEAKIAogU0lNVEVDIEVCMTEwQVRYIChDaGFsaWNlIENBVFMpCiBQOglCZW4gRG9va3MKLU06CVZpbmNlbnQgU2FuZGVycyA8c3VwcG9ydEBzaW10ZWMuY28udWs+CitQOglWaW5jZW50IFNhbmRlcnMgPHZpbmNlQHNpbXRlYy5jby51az4KK006CVNpbXRlYyBMaW51eCBUZWFtIDxsaW51eEBzaW10ZWMuY28udWs+CiBXOglodHRwOi8vd3d3LnNpbXRlYy5jby51ay9wcm9kdWN0cy9FQjExMEFUWC8KIFM6CVN1cHBvcnRlZAogCiBTSU1URUMgRUIyNDEwSVRYIChCQVNUKQogUDoJQmVuIERvb2tzCi1NOglWaW5jZW50IFNhbmRlcnMgPHN1cHBvcnRAc2ltdGVjLmNvLnVrPgorUDoJVmluY2VudCBTYW5kZXJzIDx2aW5jZUBzaW10ZWMuY28udWs+CitNOglTaW10ZWMgTGludXggVGVhbSA8bGludXhAc2ltdGVjLmNvLnVrPgogVzoJaHR0cDovL3d3dy5zaW10ZWMuY28udWsvcHJvZHVjdHMvRUIyNDEwSVRYLwogUzoJU3VwcG9ydGVkCi1GOglhcmNoL2FybS9tYWNoLXMzYzI0MTAvCi1GOglkcml2ZXJzLyovKnMzYzI0MTAqCi1GOglkcml2ZXJzLyovKi8qczNjMjQxMCoKK0Y6CWFyY2gvYXJtL21hY2gtczNjMjQxMC9tYWNoLWJhc3QuYworRjoJYXJjaC9hcm0vbWFjaC1zM2MyNDEwL2Jhc3QtaWRlLmMKK0Y6CWFyY2gvYXJtL21hY2gtczNjMjQxMC9iYXN0LWlycS5jCiAKIFRJIERBVklOQ0kgTUFDSElORSBTVVBQT1JUCiBNOglLZXZpbiBIaWxtYW4gPGtoaWxtYW5AZGVlcHJvb3RzeXN0ZW1zLmNvbT4KQEAgLTU2NDgsNyArNTY5MCw3IEBACiAKIFNMQUIgQUxMT0NBVE9SCiBNOglDaHJpc3RvcGggTGFtZXRlciA8Y2xAbGludXgtZm91bmRhdGlvbi5vcmc+Ci1NOglQZWtrYSBFbmJlcmcgPHBlbmJlcmdAY3MuaGVsc2lua2kuZmk+CitNOglQZWtrYSBFbmJlcmcgPHBlbmJlcmdAa2VybmVsLm9yZz4KIE06CU1hdHQgTWFja2FsbCA8bXBtQHNlbGVuaWMuY29tPgogTDoJbGludXgtbW1Aa3ZhY2sub3JnCiBTOglNYWludGFpbmVkCkBAIC01Nzg5LDE0ICs1ODMxLDE0IEBACiBUOglnaXQgZ2l0Oi8vZ2l0Lmtlcm5lbC5vcmcvcHViL3NjbS9saW51eC9rZXJuZWwvZ2l0L2RhdmVtL3NwYXJjLTIuNi5naXQKIFQ6CWdpdCBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4L2tlcm5lbC9naXQvZGF2ZW0vc3BhcmMtbmV4dC0yLjYuZ2l0CiBTOglNYWludGFpbmVkCi1GOglkcml2ZXJzL3NlcmlhbC9zdW5jb3JlLmMKLUY6CWRyaXZlcnMvc2VyaWFsL3N1bmNvcmUuaAotRjoJZHJpdmVycy9zZXJpYWwvc3VuaHYuYwotRjoJZHJpdmVycy9zZXJpYWwvc3Vuc2FiLmMKLUY6CWRyaXZlcnMvc2VyaWFsL3N1bnNhYi5oCi1GOglkcml2ZXJzL3NlcmlhbC9zdW5zdS5jCi1GOglkcml2ZXJzL3NlcmlhbC9zdW56aWxvZy5jCi1GOglkcml2ZXJzL3NlcmlhbC9zdW56aWxvZy5oCitGOglkcml2ZXJzL3R0eS9zZXJpYWwvc3VuY29yZS5jCitGOglkcml2ZXJzL3R0eS9zZXJpYWwvc3VuY29yZS5oCitGOglkcml2ZXJzL3R0eS9zZXJpYWwvc3VuaHYuYworRjoJZHJpdmVycy90dHkvc2VyaWFsL3N1bnNhYi5jCitGOglkcml2ZXJzL3R0eS9zZXJpYWwvc3Vuc2FiLmgKK0Y6CWRyaXZlcnMvdHR5L3NlcmlhbC9zdW5zdS5jCitGOglkcml2ZXJzL3R0eS9zZXJpYWwvc3Vuemlsb2cuYworRjoJZHJpdmVycy90dHkvc2VyaWFsL3N1bnppbG9nLmgKIAogU1BFQVIgUExBVEZPUk0gU1VQUE9SVAogTToJVmlyZXNoIEt1bWFyIDx2aXJlc2gua3VtYXJAc3QuY29tPgpAQCAtNjEyNiw4ICs2MTY4LDggQEAKIE06CUdyZWcgS3JvYWgtSGFydG1hbiA8Z3JlZ2toQHN1c2UuZGU+CiBTOglNYWludGFpbmVkCiBUOglnaXQgZ2l0Oi8vZ2l0Lmtlcm5lbC5vcmcvcHViL3NjbS9saW51eC9rZXJuZWwvZ2l0L2dyZWdraC90dHktMi42LmdpdAotRjoJZHJpdmVycy9jaGFyL3R0eV8qCi1GOglkcml2ZXJzL3NlcmlhbC9zZXJpYWxfY29yZS5jCitGOglkcml2ZXJzL3R0eS8qCitGOglkcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX2NvcmUuYwogRjoJaW5jbHVkZS9saW51eC9zZXJpYWxfY29yZS5oCiBGOglpbmNsdWRlL2xpbnV4L3NlcmlhbC5oCiBGOglpbmNsdWRlL2xpbnV4L3R0eS5oCkBAIC02NTcxLDYgKzY2MTMsMTYgQEAKIEY6CWRyaXZlcnMvY2hhci92aXJ0aW9fY29uc29sZS5jCiBGOglpbmNsdWRlL2xpbnV4L3ZpcnRpb19jb25zb2xlLmgKIAorVklSVElPIENPUkUsIE5FVCBBTkQgQkxPQ0sgRFJJVkVSUworTToJUnVzdHkgUnVzc2VsbCA8cnVzdHlAcnVzdGNvcnAuY29tLmF1PgorTToJIk1pY2hhZWwgUy4gVHNpcmtpbiIgPG1zdEByZWRoYXQuY29tPgorTDoJdmlydHVhbGl6YXRpb25AbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKK1M6CU1haW50YWluZWQKK0Y6CWRyaXZlcnMvdmlydGlvLworRjoJZHJpdmVycy9uZXQvdmlydGlvX25ldC5jCitGOglkcml2ZXJzL2Jsb2NrL3ZpcnRpb19ibGsuYworRjoJaW5jbHVkZS9saW51eC92aXJ0aW9fKi5oCisKIFZJUlRJTyBIT1NUIChWSE9TVCkKIE06CSJNaWNoYWVsIFMuIFRzaXJraW4iIDxtc3RAcmVkaGF0LmNvbT4KIEw6CWt2bUB2Z2VyLmtlcm5lbC5vcmcKQEAgLTY1OTMsMTMgKzY2NDUsMTIgQEAKIEY6CWRyaXZlcnMvaTJjL2J1c3Nlcy9pMmMtdmlhcHJvLmMKIAogVklBIFNEL01NQyBDQVJEIENPTlRST0xMRVIgRFJJVkVSCi1NOglKb3NlcGggQ2hhbiA8Sm9zZXBoQ2hhbkB2aWEuY29tLnR3PgorTToJQnJ1Y2UgQ2hhbmcgPGJydWNlY2hhbmdAdmlhLmNvbS50dz4KIE06CUhhcmFsZCBXZWx0ZSA8SGFyYWxkV2VsdGVAdmlhdGVjaC5jb20+CiBTOglNYWludGFpbmVkCiBGOglkcml2ZXJzL21tYy9ob3N0L3ZpYS1zZG1tYy5jCiAKIFZJQSBVTklDSFJPTUUoUFJPKS9DSFJPTUU5IEZSQU1FQlVGRkVSIERSSVZFUgotTToJSm9zZXBoIENoYW4gPEpvc2VwaENoYW5AdmlhLmNvbS50dz4KIE06CUZsb3JpYW4gVG9iaWFzIFNjaGFuZGluYXQgPEZsb3JpYW5TY2hhbmRpbmF0QGdteC5kZT4KIEw6CWxpbnV4LWZiZGV2QHZnZXIua2VybmVsLm9yZwogUzoJTWFpbnRhaW5lZApAQCAtNjc0NSwxMiArNjc5NiwxMiBAQAogRjoJZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMjUxLyoKIAogV0wxMjcxIFdJUkVMRVNTIERSSVZFUgotTToJTHVjaWFubyBDb2VsaG8gPGx1Y2lhbm8uY29lbGhvQG5va2lhLmNvbT4KK006CUx1Y2lhbm8gQ29lbGhvIDxjb2VsaG9AdGkuY29tPgogTDoJbGludXgtd2lyZWxlc3NAdmdlci5rZXJuZWwub3JnCi1XOglodHRwOi8vd2lyZWxlc3Mua2VybmVsLm9yZworVzoJaHR0cDovL3dpcmVsZXNzLmtlcm5lbC5vcmcvZW4vdXNlcnMvRHJpdmVycy93bDEyeHgKIFQ6CWdpdCBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4L2tlcm5lbC9naXQvbHVjYS93bDEyeHguZ2l0CiBTOglNYWludGFpbmVkCi1GOglkcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvd2wxMjcxKgorRjoJZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMnh4LwogRjoJaW5jbHVkZS9saW51eC93bDEyeHguaAogCiBXTDM1MDEgV0lSRUxFU1MgUENNQ0lBIENBUkQgRFJJVkVSCkBAIC02ODczLDcgKzY5MjQsNyBAQAogTToJUGV0ZXIgS29yc2dhYXJkIDxqYWNtZXRAc3Vuc2l0ZS5kaz4KIEw6CWxpbnV4LXNlcmlhbEB2Z2VyLmtlcm5lbC5vcmcKIFM6CU1haW50YWluZWQKLUY6CWRyaXZlcnMvc2VyaWFsL3VhcnRsaXRlLmMKK0Y6CWRyaXZlcnMvdHR5L3NlcmlhbC91YXJ0bGl0ZS5jCiAKIFlBTSBEUklWRVIgRk9SIEFYLjI1CiBNOglKZWFuLVBhdWwgUm91YmVsYXQgPGpwckBmNmZiYi5vcmc+CkBAIC02OTE5LDcgKzY5NzAsNyBAQAogWlMgREVDU1RBVElPTiBaODVDMzAgU0VSSUFMIERSSVZFUgogTToJIk1hY2llaiBXLiBSb3p5Y2tpIiA8bWFjcm9AbGludXgtbWlwcy5vcmc+CiBTOglNYWludGFpbmVkCi1GOglkcml2ZXJzL3NlcmlhbC96cy4qCitGOglkcml2ZXJzL3R0eS9zZXJpYWwvenMuKgogCiBHUkUgREVNVUxUSVBMRVhFUiBEUklWRVIKIE06CURtaXRyeSBLb3psb3YgPHhlYkBtYWlsLnJ1PgpkaWZmIC0tZ2l0IGEvTWFrZWZpbGUgYi9NYWtlZmlsZQppbmRleCA2YTQ1NzY5Li5jOWM4YzhmIDEwMDY0NAotLS0gYS9NYWtlZmlsZQorKysgYi9NYWtlZmlsZQpAQCAtMSw3ICsxLDcgQEAKIFZFUlNJT04gPSAyCiBQQVRDSExFVkVMID0gNgotU1VCTEVWRUwgPSAzNwotRVhUUkFWRVJTSU9OID0KK1NVQkxFVkVMID0gMzgKK0VYVFJBVkVSU0lPTiA9IC1yYzQKIE5BTUUgPSBGbGVzaC1FYXRpbmcgQmF0cyB3aXRoIEZhbmdzCiAKICMgKkRPQ1VNRU5UQVRJT04qCmRpZmYgLS1naXQgYS9hcmNoL2FscGhhL0tjb25maWcgYi9hcmNoL2FscGhhL0tjb25maWcKaW5kZXggOTQzZmU2OS4uNDdmNjNkNCAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9LY29uZmlnCisrKyBiL2FyY2gvYWxwaGEvS2NvbmZpZwpAQCAtOCw2ICs4LDkgQEAKIAlzZWxlY3QgSEFWRV9JUlFfV09SSwogCXNlbGVjdCBIQVZFX1BFUkZfRVZFTlRTCiAJc2VsZWN0IEhBVkVfRE1BX0FUVFJTCisJc2VsZWN0IEhBVkVfR0VORVJJQ19IQVJESVJRUworCXNlbGVjdCBHRU5FUklDX0lSUV9QUk9CRQorCXNlbGVjdCBBVVRPX0lSUV9BRkZJTklUWSBpZiBTTVAKIAloZWxwCiAJICBUaGUgQWxwaGEgaXMgYSA2NC1iaXQgZ2VuZXJhbC1wdXJwb3NlIHByb2Nlc3NvciBkZXNpZ25lZCBhbmQKIAkgIG1hcmtldGVkIGJ5IHRoZSBEaWdpdGFsIEVxdWlwbWVudCBDb3Jwb3JhdGlvbiBvZiBibGVzc2VkIG1lbW9yeSwKQEAgLTY4LDE5ICs3MSw2IEBACiAJYm9vbAogCWRlZmF1bHQgbgogCi1jb25maWcgR0VORVJJQ19IQVJESVJRUwotCWJvb2wKLQlkZWZhdWx0IHkKLQotY29uZmlnIEdFTkVSSUNfSVJRX1BST0JFCi0JYm9vbAotCWRlZmF1bHQgeQotCi1jb25maWcgQVVUT19JUlFfQUZGSU5JVFkKLQlib29sCi0JZGVwZW5kcyBvbiBTTVAKLQlkZWZhdWx0IHkKLQogc291cmNlICJpbml0L0tjb25maWciCiBzb3VyY2UgImtlcm5lbC9LY29uZmlnLmZyZWV6ZXIiCiAKZGlmZiAtLWdpdCBhL2FyY2gvYWxwaGEvaW5jbHVkZS9hc20vaW8uaCBiL2FyY2gvYWxwaGEvaW5jbHVkZS9hc20vaW8uaAppbmRleCBlZGE5YjkwLi41NmZmOTY1IDEwMDY0NAotLS0gYS9hcmNoL2FscGhhL2luY2x1ZGUvYXNtL2lvLmgKKysrIGIvYXJjaC9hbHBoYS9pbmNsdWRlL2FzbS9pby5oCkBAIC0zNyw4ICszNyw5IEBACiAgKi8KIGV4dGVybiBpbmxpbmUgdm9pZCBfX3NldF9oYWUodW5zaWduZWQgbG9uZyBuZXdfaGFlKQogewotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0JbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOworCXVuc2lnbmVkIGxvbmcgZmxhZ3MgPSBzd3BpcGwoSVBMX01BWCk7CisKKwliYXJyaWVyKCk7CiAKIAlhbHBoYV9tdi5oYWVfY2FjaGUgPSBuZXdfaGFlOwogCSphbHBoYV9tdi5oYWVfcmVnaXN0ZXIgPSBuZXdfaGFlOwpAQCAtNDYsNyArNDcsOCBAQAogCS8qIFJlLXJlYWQgdG8gbWFrZSBzdXJlIGl0IHdhcyB3cml0dGVuLiAgKi8KIAluZXdfaGFlID0gKmFscGhhX212LmhhZV9yZWdpc3RlcjsKIAotCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKKwlzZXRpcGwoZmxhZ3MpOworCWJhcnJpZXIoKTsKIH0KIAogZXh0ZXJuIGlubGluZSB2b2lkIHNldF9oYWUodW5zaWduZWQgbG9uZyBuZXdfaGFlKQpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9pbmNsdWRlL2FzbS9tbWFuLmggYi9hcmNoL2FscGhhL2luY2x1ZGUvYXNtL21tYW4uaAppbmRleCA5OWM1NmQ0Li43MmRiOTg0IDEwMDY0NAotLS0gYS9hcmNoL2FscGhhL2luY2x1ZGUvYXNtL21tYW4uaAorKysgYi9hcmNoL2FscGhhL2luY2x1ZGUvYXNtL21tYW4uaApAQCAtNTMsNiArNTMsOSBAQAogI2RlZmluZSBNQURWX01FUkdFQUJMRSAgIDEyCQkvKiBLU00gbWF5IG1lcmdlIGlkZW50aWNhbCBwYWdlcyAqLwogI2RlZmluZSBNQURWX1VOTUVSR0VBQkxFIDEzCQkvKiBLU00gbWF5IG5vdCBtZXJnZSBpZGVudGljYWwgcGFnZXMgKi8KIAorI2RlZmluZSBNQURWX0hVR0VQQUdFCTE0CQkvKiBXb3J0aCBiYWNraW5nIHdpdGggaHVnZXBhZ2VzICovCisjZGVmaW5lIE1BRFZfTk9IVUdFUEFHRQkxNQkJLyogTm90IHdvcnRoIGJhY2tpbmcgd2l0aCBodWdlcGFnZXMgKi8KKwogLyogY29tcGF0aWJpbGl0eSBmbGFncyAqLwogI2RlZmluZSBNQVBfRklMRQkwCiAKZGlmZiAtLWdpdCBhL2FyY2gvYWxwaGEva2VybmVsL01ha2VmaWxlIGIvYXJjaC9hbHBoYS9rZXJuZWwvTWFrZWZpbGUKaW5kZXggMWVlOWI1Yi4uOWJiN2I4NTggMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEva2VybmVsL01ha2VmaWxlCisrKyBiL2FyY2gvYWxwaGEva2VybmVsL01ha2VmaWxlCkBAIC0zLDggKzMsOCBAQAogIwogCiBleHRyYS15CQk6PSBoZWFkLm8gdm1saW51eC5sZHMKLUVYVFJBX0FGTEFHUwk6PSAkKEtCVUlMRF9DRkxBR1MpCi1FWFRSQV9DRkxBR1MJOj0gLVdlcnJvciAtV25vLXNpZ24tY29tcGFyZQorYXNmbGFncy15CTo9ICQoS0JVSUxEX0NGTEFHUykKK2NjZmxhZ3MteQk6PSAtV2Vycm9yIC1Xbm8tc2lnbi1jb21wYXJlCiAKIG9iai15ICAgIDo9IGVudHJ5Lm8gdHJhcHMubyBwcm9jZXNzLm8gaW5pdF90YXNrLm8gb3NmX3N5cy5vIGlycS5vIFwKIAkgICAgaXJxX2FscGhhLm8gc2lnbmFsLm8gc2V0dXAubyBwdHJhY2UubyB0aW1lLm8gXApkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvaXJxLmMgYi9hcmNoL2FscGhhL2tlcm5lbC9pcnEuYwppbmRleCBmZTkxMjk4Li45YWIyMzRmIDEwMDY0NAotLS0gYS9hcmNoL2FscGhhL2tlcm5lbC9pcnEuYworKysgYi9hcmNoL2FscGhhL2tlcm5lbC9pcnEuYwpAQCAtNDQsMTAgKzQ0LDExIEBACiAKIGludCBpcnFfc2VsZWN0X2FmZmluaXR5KHVuc2lnbmVkIGludCBpcnEpCiB7CisJc3RydWN0IGlycV9kZXNjICpkZXNjID0gaXJxX3RvX2Rlc2NbaXJxXTsKIAlzdGF0aWMgaW50IGxhc3RfY3B1OwogCWludCBjcHUgPSBsYXN0X2NwdSArIDE7CiAKLQlpZiAoIWlycV9kZXNjW2lycV0uY2hpcC0+c2V0X2FmZmluaXR5IHx8IGlycV91c2VyX2FmZmluaXR5W2lycV0pCisJaWYgKCFkZXNjIHx8ICFnZXRfaXJxX2Rlc2NfY2hpcChkZXNjKS0+c2V0X2FmZmluaXR5IHx8IGlycV91c2VyX2FmZmluaXR5W2lycV0pCiAJCXJldHVybiAxOwogCiAJd2hpbGUgKCFjcHVfcG9zc2libGUoY3B1KSB8fApAQCAtNTUsOCArNTYsOCBAQAogCQljcHUgPSAoY3B1IDwgKE5SX0NQVVMtMSkgPyBjcHUgKyAxIDogMCk7CiAJbGFzdF9jcHUgPSBjcHU7CiAKLQljcHVtYXNrX2NvcHkoaXJxX2Rlc2NbaXJxXS5hZmZpbml0eSwgY3B1bWFza19vZihjcHUpKTsKLQlpcnFfZGVzY1tpcnFdLmNoaXAtPnNldF9hZmZpbml0eShpcnEsIGNwdW1hc2tfb2YoY3B1KSk7CisJY3B1bWFza19jb3B5KGRlc2MtPmFmZmluaXR5LCBjcHVtYXNrX29mKGNwdSkpOworCWdldF9pcnFfZGVzY19jaGlwKGRlc2MpLT5zZXRfYWZmaW5pdHkoaXJxLCBjcHVtYXNrX29mKGNwdSkpOwogCXJldHVybiAwOwogfQogI2VuZGlmIC8qIENPTkZJR19TTVAgKi8KQEAgLTY3LDYgKzY4LDcgQEAKIAlpbnQgajsKIAlpbnQgaXJxID0gKihsb2ZmX3QgKikgdjsKIAlzdHJ1Y3QgaXJxYWN0aW9uICogYWN0aW9uOworCXN0cnVjdCBpcnFfZGVzYyAqZGVzYzsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAjaWZkZWYgQ09ORklHX1NNUApAQCAtNzksOCArODEsMTMgQEAKICNlbmRpZgogCiAJaWYgKGlycSA8IEFDVFVBTF9OUl9JUlFTKSB7Ci0JCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmaXJxX2Rlc2NbaXJxXS5sb2NrLCBmbGFncyk7Ci0JCWFjdGlvbiA9IGlycV9kZXNjW2lycV0uYWN0aW9uOworCQlkZXNjID0gaXJxX3RvX2Rlc2MoaXJxKTsKKworCQlpZiAoIWRlc2MpCisJCQlyZXR1cm4gMDsKKworCQlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJmRlc2MtPmxvY2ssIGZsYWdzKTsKKwkJYWN0aW9uID0gZGVzYy0+YWN0aW9uOwogCQlpZiAoIWFjdGlvbikgCiAJCQlnb3RvIHVubG9jazsKIAkJc2VxX3ByaW50ZihwLCAiJTNkOiAiLCBpcnEpOwpAQCAtOTAsNyArOTcsNyBAQAogCQlmb3JfZWFjaF9vbmxpbmVfY3B1KGopCiAJCQlzZXFfcHJpbnRmKHAsICIlMTB1ICIsIGtzdGF0X2lycXNfY3B1KGlycSwgaikpOwogI2VuZGlmCi0JCXNlcV9wcmludGYocCwgIiAlMTRzIiwgaXJxX2Rlc2NbaXJxXS5jaGlwLT5uYW1lKTsKKwkJc2VxX3ByaW50ZihwLCAiICUxNHMiLCBnZXRfaXJxX2Rlc2NfY2hpcChkZXNjKS0+bmFtZSk7CiAJCXNlcV9wcmludGYocCwgIiAgJWMlcyIsCiAJCQkoYWN0aW9uLT5mbGFncyAmIElSUUZfRElTQUJMRUQpPycrJzonICcsCiAJCQlhY3Rpb24tPm5hbWUpOwpAQCAtMTAzLDcgKzExMCw3IEBACiAKIAkJc2VxX3B1dGMocCwgJ1xuJyk7CiB1bmxvY2s6Ci0JCXJhd19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZpcnFfZGVzY1tpcnFdLmxvY2ssIGZsYWdzKTsKKwkJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRlc2MtPmxvY2ssIGZsYWdzKTsKIAl9IGVsc2UgaWYgKGlycSA9PSBBQ1RVQUxfTlJfSVJRUykgewogI2lmZGVmIENPTkZJR19TTVAKIAkJc2VxX3B1dHMocCwgIklQSTogIik7CkBAIC0xNDIsOCArMTQ5LDEwIEBACiAJICogaGFuZGxlZCBieSBzb21lIG90aGVyIENQVS4gKG9yIGlzIGRpc2FibGVkKQogCSAqLwogCXN0YXRpYyB1bnNpZ25lZCBpbnQgaWxsZWdhbF9jb3VudD0wOworCXN0cnVjdCBpcnFfZGVzYyAqZGVzYyA9IGlycV90b19kZXNjKGlycSk7CiAJCi0JaWYgKCh1bnNpZ25lZCkgaXJxID4gQUNUVUFMX05SX0lSUVMgJiYgaWxsZWdhbF9jb3VudCA8IE1BWF9JTExFR0FMX0lSUVMgKSB7CisJaWYgKCFkZXNjIHx8ICgodW5zaWduZWQpIGlycSA+IEFDVFVBTF9OUl9JUlFTICYmCisJICAgIGlsbGVnYWxfY291bnQgPCBNQVhfSUxMRUdBTF9JUlFTKSkgewogCQlpcnFfZXJyX2NvdW50Kys7CiAJCWlsbGVnYWxfY291bnQrKzsKIAkJcHJpbnRrKEtFUk5fQ1JJVCAiZGV2aWNlX2ludGVycnVwdDogaW52YWxpZCBpbnRlcnJ1cHQgJWRcbiIsCkBAIC0xNTEsMTQgKzE2MCwxNCBAQAogCQlyZXR1cm47CiAJfQogCi0JaXJxX2VudGVyKCk7CiAJLyoKLQkgKiBfX2RvX0lSUSgpIG11c3QgYmUgY2FsbGVkIHdpdGggSVBMX01BWC4gTm90ZSB0aGF0IHdlIGRvIG5vdAorCSAqIEZyb20gaGVyZSB3ZSBtdXN0IHByb2NlZWQgd2l0aCBJUExfTUFYLiBOb3RlIHRoYXQgd2UgZG8gbm90CiAJICogZXhwbGljaXRseSBlbmFibGUgaW50ZXJydXB0cyBhZnRlcndhcmRzIC0gc29tZSBNSUxPIFBBTGNvZGUKIAkgKiAobmFtZWx5IExYMTY0IG9uZSkgc2VlbXMgdG8gaGF2ZSBzZXZlcmUgcHJvYmxlbXMgd2l0aCBSVEkKIAkgKiBhdCBJUEwgMC4KIAkgKi8KIAlsb2NhbF9pcnFfZGlzYWJsZSgpOwotCV9fZG9fSVJRKGlycSk7CisJaXJxX2VudGVyKCk7CisJZ2VuZXJpY19oYW5kbGVfaXJxX2Rlc2MoaXJxLCBkZXNjKTsKIAlpcnFfZXhpdCgpOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvaXJxX2FscGhhLmMgYi9hcmNoL2FscGhhL2tlcm5lbC9pcnFfYWxwaGEuYwppbmRleCA0YzhiYjM3Li4yZDA2NzliIDEwMDY0NAotLS0gYS9hcmNoL2FscGhhL2tlcm5lbC9pcnFfYWxwaGEuYworKysgYi9hcmNoL2FscGhhL2tlcm5lbC9pcnFfYWxwaGEuYwpAQCAtMjE5LDMxICsyMTksMjMgQEAKICAqIHByb2Nlc3NlZCBieSBQQUxjb2RlLCBhbmQgY29tZXMgaW4gdmlhIGVudEludCB2ZWN0b3IgMS4KICAqLwogCi1zdGF0aWMgdm9pZCBydGNfZW5hYmxlX2Rpc2FibGUodW5zaWduZWQgaW50IGlycSkgeyB9Ci1zdGF0aWMgdW5zaWduZWQgaW50IHJ0Y19zdGFydHVwKHVuc2lnbmVkIGludCBpcnEpIHsgcmV0dXJuIDA7IH0KLQogc3RydWN0IGlycWFjdGlvbiB0aW1lcl9pcnFhY3Rpb24gPSB7CiAJLmhhbmRsZXIJPSB0aW1lcl9pbnRlcnJ1cHQsCiAJLmZsYWdzCQk9IElSUUZfRElTQUJMRUQsCiAJLm5hbWUJCT0gInRpbWVyIiwKIH07CiAKLXN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgcnRjX2lycV90eXBlID0gewotCS5uYW1lCQk9ICJSVEMiLAotCS5zdGFydHVwCT0gcnRjX3N0YXJ0dXAsCi0JLnNodXRkb3duCT0gcnRjX2VuYWJsZV9kaXNhYmxlLAotCS5lbmFibGUJCT0gcnRjX2VuYWJsZV9kaXNhYmxlLAotCS5kaXNhYmxlCT0gcnRjX2VuYWJsZV9kaXNhYmxlLAotCS5hY2sJCT0gcnRjX2VuYWJsZV9kaXNhYmxlLAotCS5lbmQJCT0gcnRjX2VuYWJsZV9kaXNhYmxlLAotfTsKLQogdm9pZCBfX2luaXQKIGluaXRfcnRjX2lycSh2b2lkKQogewotCWlycV9kZXNjW1JUQ19JUlFdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tSVENfSVJRXS5jaGlwID0gJnJ0Y19pcnFfdHlwZTsKLQlzZXR1cF9pcnEoUlRDX0lSUSwgJnRpbWVyX2lycWFjdGlvbik7CisJc3RydWN0IGlycV9kZXNjICpkZXNjID0gaXJxX3RvX2Rlc2MoUlRDX0lSUSk7CisKKwlpZiAoZGVzYykgeworCQlkZXNjLT5zdGF0dXMgfD0gSVJRX0RJU0FCTEVEOworCQlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXJfbmFtZShSVENfSVJRLCAmbm9faXJxX2NoaXAsCisJCQloYW5kbGVfc2ltcGxlX2lycSwgIlJUQyIpOworCQlzZXR1cF9pcnEoUlRDX0lSUSwgJnRpbWVyX2lycWFjdGlvbik7CisJfQogfQogCiAvKiBEdW1teSBpcnFhY3Rpb25zLiAgKi8KZGlmZiAtLWdpdCBhL2FyY2gvYWxwaGEva2VybmVsL2lycV9pODI1OS5jIGIvYXJjaC9hbHBoYS9rZXJuZWwvaXJxX2k4MjU5LmMKaW5kZXggODNhOWFjMi4uOTU2ZWEwZSAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9rZXJuZWwvaXJxX2k4MjU5LmMKKysrIGIvYXJjaC9hbHBoYS9rZXJuZWwvaXJxX2k4MjU5LmMKQEAgLTY5LDI4ICs2OSwxMSBAQAogCXNwaW5fdW5sb2NrKCZpODI1OV9pcnFfbG9jayk7CiB9CiAKLXVuc2lnbmVkIGludAotaTgyNTlhX3N0YXJ0dXBfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JaTgyNTlhX2VuYWJsZV9pcnEoaXJxKTsKLQlyZXR1cm4gMDsgLyogbmV2ZXIgYW55dGhpbmcgcGVuZGluZyAqLwotfQotCi12b2lkCi1pODI1OWFfZW5kX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWlmICghKGlycV9kZXNjW2lycV0uc3RhdHVzICYgKElSUV9ESVNBQkxFRHxJUlFfSU5QUk9HUkVTUykpKQotCQlpODI1OWFfZW5hYmxlX2lycShpcnEpOwotfQotCiBzdHJ1Y3QgaXJxX2NoaXAgaTgyNTlhX2lycV90eXBlID0gewogCS5uYW1lCQk9ICJYVC1QSUMiLAotCS5zdGFydHVwCT0gaTgyNTlhX3N0YXJ0dXBfaXJxLAotCS5zaHV0ZG93bgk9IGk4MjU5YV9kaXNhYmxlX2lycSwKLQkuZW5hYmxlCQk9IGk4MjU5YV9lbmFibGVfaXJxLAotCS5kaXNhYmxlCT0gaTgyNTlhX2Rpc2FibGVfaXJxLAotCS5hY2sJCT0gaTgyNTlhX21hc2tfYW5kX2Fja19pcnEsCi0JLmVuZAkJPSBpODI1OWFfZW5kX2lycSwKKwkudW5tYXNrCQk9IGk4MjU5YV9lbmFibGVfaXJxLAorCS5tYXNrCQk9IGk4MjU5YV9kaXNhYmxlX2lycSwKKwkubWFza19hY2sJPSBpODI1OWFfbWFza19hbmRfYWNrX2lycSwKIH07CiAKIHZvaWQgX19pbml0CkBAIC0xMDcsOCArOTAsNyBAQAogCW91dGIoMHhmZiwgMHhBMSk7CS8qIG1hc2sgYWxsIG9mIDgyNTlBLTIgKi8KIAogCWZvciAoaSA9IDA7IGkgPCAxNjsgaSsrKSB7Ci0JCWlycV9kZXNjW2ldLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQkJaXJxX2Rlc2NbaV0uY2hpcCA9ICZpODI1OWFfaXJxX3R5cGU7CisJCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihpLCAmaTgyNTlhX2lycV90eXBlLCBoYW5kbGVfbGV2ZWxfaXJxKTsKIAl9CiAKIAlzZXR1cF9pcnEoMiwgJmNhc2NhZGUpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvaXJxX3B5eGlzLmMgYi9hcmNoL2FscGhhL2tlcm5lbC9pcnFfcHl4aXMuYwppbmRleCA5ODljZTQ2Li4yODYzNDU4IDEwMDY0NAotLS0gYS9hcmNoL2FscGhhL2tlcm5lbC9pcnFfcHl4aXMuYworKysgYi9hcmNoL2FscGhhL2tlcm5lbC9pcnFfcHl4aXMuYwpAQCAtNDAsMjAgKzQwLDYgQEAKIAlweXhpc191cGRhdGVfaXJxX2h3KGNhY2hlZF9pcnFfbWFzayAmPSB+KDFVTCA8PCAoaXJxIC0gMTYpKSk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQKLXB5eGlzX3N0YXJ0dXBfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JcHl4aXNfZW5hYmxlX2lycShpcnEpOwotCXJldHVybiAwOwotfQotCi1zdGF0aWMgdm9pZAotcHl4aXNfZW5kX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWlmICghKGlycV9kZXNjW2lycV0uc3RhdHVzICYgKElSUV9ESVNBQkxFRHxJUlFfSU5QUk9HUkVTUykpKQotCQlweXhpc19lbmFibGVfaXJxKGlycSk7Ci19Ci0KIHN0YXRpYyB2b2lkCiBweXhpc19tYXNrX2FuZF9hY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCiB7CkBAIC03MiwxMiArNTgsOSBAQAogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHB5eGlzX2lycV90eXBlID0gewogCS5uYW1lCQk9ICJQWVhJUyIsCi0JLnN0YXJ0dXAJPSBweXhpc19zdGFydHVwX2lycSwKLQkuc2h1dGRvd24JPSBweXhpc19kaXNhYmxlX2lycSwKLQkuZW5hYmxlCQk9IHB5eGlzX2VuYWJsZV9pcnEsCi0JLmRpc2FibGUJPSBweXhpc19kaXNhYmxlX2lycSwKLQkuYWNrCQk9IHB5eGlzX21hc2tfYW5kX2Fja19pcnEsCi0JLmVuZAkJPSBweXhpc19lbmRfaXJxLAorCS5tYXNrX2Fjawk9IHB5eGlzX21hc2tfYW5kX2Fja19pcnEsCisJLm1hc2sJCT0gcHl4aXNfZGlzYWJsZV9pcnEsCisJLnVubWFzawkJPSBweXhpc19lbmFibGVfaXJxLAogfTsKIAogdm9pZCAKQEAgLTExOSw4ICsxMDIsOCBAQAogCWZvciAoaSA9IDE2OyBpIDwgNDg7ICsraSkgewogCQlpZiAoKGlnbm9yZV9tYXNrID4+IGkpICYgMSkKIAkJCWNvbnRpbnVlOwotCQlpcnFfZGVzY1tpXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQgfCBJUlFfTEVWRUw7Ci0JCWlycV9kZXNjW2ldLmNoaXAgPSAmcHl4aXNfaXJxX3R5cGU7CisJCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihpLCAmcHl4aXNfaXJxX3R5cGUsIGhhbmRsZV9sZXZlbF9pcnEpOworCQlpcnFfdG9fZGVzYyhpKS0+c3RhdHVzIHw9IElSUV9MRVZFTDsKIAl9CiAKIAlzZXR1cF9pcnEoMTYrNywgJmlzYV9jYXNjYWRlX2lycWFjdGlvbik7CmRpZmYgLS1naXQgYS9hcmNoL2FscGhhL2tlcm5lbC9pcnFfc3JtLmMgYi9hcmNoL2FscGhhL2tlcm5lbC9pcnFfc3JtLmMKaW5kZXggZDYzZTkzZS4uMGU1N2U4MiAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9rZXJuZWwvaXJxX3NybS5jCisrKyBiL2FyY2gvYWxwaGEva2VybmVsL2lycV9zcm0uYwpAQCAtMzMsMjkgKzMzLDEyIEBACiAJc3Bpbl91bmxvY2soJnNybV9pcnFfbG9jayk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQKLXNybV9zdGFydHVwX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCXNybV9lbmFibGVfaXJxKGlycSk7Ci0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyB2b2lkCi1zcm1fZW5kX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWlmICghKGlycV9kZXNjW2lycV0uc3RhdHVzICYgKElSUV9ESVNBQkxFRHxJUlFfSU5QUk9HUkVTUykpKQotCQlzcm1fZW5hYmxlX2lycShpcnEpOwotfQotCiAvKiBIYW5kbGUgaW50ZXJydXB0cyBmcm9tIHRoZSBTUk0sIGFzc3VtaW5nIG5vIGFkZGl0aW9uYWwgd2VpcmRuZXNzLiAgKi8KIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgc3JtX2lycV90eXBlID0gewogCS5uYW1lCQk9ICJTUk0iLAotCS5zdGFydHVwCT0gc3JtX3N0YXJ0dXBfaXJxLAotCS5zaHV0ZG93bgk9IHNybV9kaXNhYmxlX2lycSwKLQkuZW5hYmxlCQk9IHNybV9lbmFibGVfaXJxLAotCS5kaXNhYmxlCT0gc3JtX2Rpc2FibGVfaXJxLAotCS5hY2sJCT0gc3JtX2Rpc2FibGVfaXJxLAotCS5lbmQJCT0gc3JtX2VuZF9pcnEsCisJLnVubWFzawkJPSBzcm1fZW5hYmxlX2lycSwKKwkubWFzawkJPSBzcm1fZGlzYWJsZV9pcnEsCisJLm1hc2tfYWNrCT0gc3JtX2Rpc2FibGVfaXJxLAogfTsKIAogdm9pZCBfX2luaXQKQEAgLTY4LDggKzUxLDggQEAKIAlmb3IgKGkgPSAxNjsgaSA8IG1heDsgKytpKSB7CiAJCWlmIChpIDwgNjQgJiYgKChpZ25vcmVfbWFzayA+PiBpKSAmIDEpKQogCQkJY29udGludWU7Ci0JCWlycV9kZXNjW2ldLnN0YXR1cyA9IElSUV9ESVNBQkxFRCB8IElSUV9MRVZFTDsKLQkJaXJxX2Rlc2NbaV0uY2hpcCA9ICZzcm1faXJxX3R5cGU7CisJCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihpLCAmc3JtX2lycV90eXBlLCBoYW5kbGVfbGV2ZWxfaXJxKTsKKwkJaXJxX3RvX2Rlc2MoaSktPnN0YXR1cyB8PSBJUlFfTEVWRUw7CiAJfQogfQogCmRpZmYgLS1naXQgYS9hcmNoL2FscGhhL2tlcm5lbC9vc2Zfc3lzLmMgYi9hcmNoL2FscGhhL2tlcm5lbC9vc2Zfc3lzLmMKaW5kZXggNTQ3ZThiOC4uZmU2OThiNSAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9rZXJuZWwvb3NmX3N5cy5jCisrKyBiL2FyY2gvYWxwaGEva2VybmVsL29zZl9zeXMuYwpAQCAtOTUxLDkgKzk1MSw2IEBACiAJcmV0dXJuIGRvX3V0aW1lcyhBVF9GRENXRCwgZmlsZW5hbWUsIHR2cyA/IHR2IDogTlVMTCwgMCk7CiB9CiAKLSNkZWZpbmUgTUFYX1NFTEVDVF9TRUNPTkRTIFwKLQkoKHVuc2lnbmVkIGxvbmcpIChNQVhfU0NIRURVTEVfVElNRU9VVCAvIEhaKS0xKQotCiBTWVNDQUxMX0RFRklORTUob3NmX3NlbGVjdCwgaW50LCBuLCBmZF9zZXQgX191c2VyICosIGlucCwgZmRfc2V0IF9fdXNlciAqLCBvdXRwLAogCQlmZF9zZXQgX191c2VyICosIGV4cCwgc3RydWN0IHRpbWV2YWwzMiBfX3VzZXIgKiwgdHZwKQogewpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX2FsY29yLmMgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfYWxjb3IuYwppbmRleCAyMGEzMGI4Li43YmVmNjE3IDEwMDY0NAotLS0gYS9hcmNoL2FscGhhL2tlcm5lbC9zeXNfYWxjb3IuYworKysgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfYWxjb3IuYwpAQCAtNjUsMTMgKzY1LDYgQEAKIAkqKHZ1aXApR1JVX0lOVF9DTEVBUiA9IDA7IG1iKCk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQKLWFsY29yX3N0YXJ0dXBfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JYWxjb3JfZW5hYmxlX2lycShpcnEpOwotCXJldHVybiAwOwotfQotCiBzdGF0aWMgdm9pZAogYWxjb3JfaXNhX21hc2tfYW5kX2Fja19pcnEodW5zaWduZWQgaW50IGlycSkKIHsKQEAgLTgyLDIxICs3NSwxMSBAQAogCSoodnVpcClHUlVfSU5UX0NMRUFSID0gMDsgbWIoKTsKIH0KIAotc3RhdGljIHZvaWQKLWFsY29yX2VuZF9pcnEodW5zaWduZWQgaW50IGlycSkKLXsKLQlpZiAoIShpcnFfZGVzY1tpcnFdLnN0YXR1cyAmIChJUlFfRElTQUJMRUR8SVJRX0lOUFJPR1JFU1MpKSkKLQkJYWxjb3JfZW5hYmxlX2lycShpcnEpOwotfQotCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGFsY29yX2lycV90eXBlID0gewogCS5uYW1lCQk9ICJBTENPUiIsCi0JLnN0YXJ0dXAJPSBhbGNvcl9zdGFydHVwX2lycSwKLQkuc2h1dGRvd24JPSBhbGNvcl9kaXNhYmxlX2lycSwKLQkuZW5hYmxlCQk9IGFsY29yX2VuYWJsZV9pcnEsCi0JLmRpc2FibGUJPSBhbGNvcl9kaXNhYmxlX2lycSwKLQkuYWNrCQk9IGFsY29yX21hc2tfYW5kX2Fja19pcnEsCi0JLmVuZAkJPSBhbGNvcl9lbmRfaXJxLAorCS51bm1hc2sJCT0gYWxjb3JfZW5hYmxlX2lycSwKKwkubWFzawkJPSBhbGNvcl9kaXNhYmxlX2lycSwKKwkubWFza19hY2sJPSBhbGNvcl9tYXNrX2FuZF9hY2tfaXJxLAogfTsKIAogc3RhdGljIHZvaWQKQEAgLTE0Miw4ICsxMjUsOCBAQAogCQkgICBvbiB3aGlsZSBJUlEgcHJvYmluZy4gICovCiAJCWlmIChpID49IDE2KzIwICYmIGkgPD0gMTYrMzApCiAJCQljb250aW51ZTsKLQkJaXJxX2Rlc2NbaV0uc3RhdHVzID0gSVJRX0RJU0FCTEVEIHwgSVJRX0xFVkVMOwotCQlpcnFfZGVzY1tpXS5jaGlwID0gJmFsY29yX2lycV90eXBlOworCQlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoaSwgJmFsY29yX2lycV90eXBlLCBoYW5kbGVfbGV2ZWxfaXJxKTsKKwkJaXJxX3RvX2Rlc2MoaSktPnN0YXR1cyB8PSBJUlFfTEVWRUw7CiAJfQogCWk4MjU5YV9pcnFfdHlwZS5hY2sgPSBhbGNvcl9pc2FfbWFza19hbmRfYWNrX2lycTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX2NhYnJpb2xldC5jIGIvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX2NhYnJpb2xldC5jCmluZGV4IDE0Yzg4OTguLmIwYzkxNjQgMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEva2VybmVsL3N5c19jYWJyaW9sZXQuYworKysgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfY2FicmlvbGV0LmMKQEAgLTU3LDI4ICs1NywxMSBAQAogCWNhYnJpb2xldF91cGRhdGVfaXJxX2h3KGlycSwgY2FjaGVkX2lycV9tYXNrIHw9IDFVTCA8PCBpcnEpOwogfQogCi1zdGF0aWMgdW5zaWduZWQgaW50Ci1jYWJyaW9sZXRfc3RhcnR1cF9pcnEodW5zaWduZWQgaW50IGlycSkKLXsgCi0JY2FicmlvbGV0X2VuYWJsZV9pcnEoaXJxKTsKLQlyZXR1cm4gMDsgLyogbmV2ZXIgYW55dGhpbmcgcGVuZGluZyAqLwotfQotCi1zdGF0aWMgdm9pZAotY2FicmlvbGV0X2VuZF9pcnEodW5zaWduZWQgaW50IGlycSkKLXsgCi0JaWYgKCEoaXJxX2Rlc2NbaXJxXS5zdGF0dXMgJiAoSVJRX0RJU0FCTEVEfElSUV9JTlBST0dSRVNTKSkpCi0JCWNhYnJpb2xldF9lbmFibGVfaXJxKGlycSk7Ci19Ci0KIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgY2FicmlvbGV0X2lycV90eXBlID0gewogCS5uYW1lCQk9ICJDQUJSSU9MRVQiLAotCS5zdGFydHVwCT0gY2FicmlvbGV0X3N0YXJ0dXBfaXJxLAotCS5zaHV0ZG93bgk9IGNhYnJpb2xldF9kaXNhYmxlX2lycSwKLQkuZW5hYmxlCQk9IGNhYnJpb2xldF9lbmFibGVfaXJxLAotCS5kaXNhYmxlCT0gY2FicmlvbGV0X2Rpc2FibGVfaXJxLAotCS5hY2sJCT0gY2FicmlvbGV0X2Rpc2FibGVfaXJxLAotCS5lbmQJCT0gY2FicmlvbGV0X2VuZF9pcnEsCisJLnVubWFzawkJPSBjYWJyaW9sZXRfZW5hYmxlX2lycSwKKwkubWFzawkJPSBjYWJyaW9sZXRfZGlzYWJsZV9pcnEsCisJLm1hc2tfYWNrCT0gY2FicmlvbGV0X2Rpc2FibGVfaXJxLAogfTsKIAogc3RhdGljIHZvaWQgCkBAIC0xMjIsOCArMTA1LDkgQEAKIAkJb3V0YigweGZmLCAweDgwNik7CiAKIAkJZm9yIChpID0gMTY7IGkgPCAzNTsgKytpKSB7Ci0JCQlpcnFfZGVzY1tpXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQgfCBJUlFfTEVWRUw7Ci0JCQlpcnFfZGVzY1tpXS5jaGlwID0gJmNhYnJpb2xldF9pcnFfdHlwZTsKKwkJCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihpLCAmY2FicmlvbGV0X2lycV90eXBlLAorCQkJCWhhbmRsZV9sZXZlbF9pcnEpOworCQkJaXJxX3RvX2Rlc2MoaSktPnN0YXR1cyB8PSBJUlFfTEVWRUw7CiAJCX0KIAl9CiAKZGlmZiAtLWdpdCBhL2FyY2gvYWxwaGEva2VybmVsL3N5c19kcDI2NC5jIGIvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX2RwMjY0LmMKaW5kZXggNDAyNjUwMi4uZWRhZDVmNyAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX2RwMjY0LmMKKysrIGIvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX2RwMjY0LmMKQEAgLTExNSwyMCArMTE1LDYgQEAKIAlzcGluX3VubG9jaygmZHAyNjRfaXJxX2xvY2spOwogfQogCi1zdGF0aWMgdW5zaWduZWQgaW50Ci1kcDI2NF9zdGFydHVwX2lycSh1bnNpZ25lZCBpbnQgaXJxKQoteyAKLQlkcDI2NF9lbmFibGVfaXJxKGlycSk7Ci0JcmV0dXJuIDA7IC8qIG5ldmVyIGFueXRoaW5nIHBlbmRpbmcgKi8KLX0KLQotc3RhdGljIHZvaWQKLWRwMjY0X2VuZF9pcnEodW5zaWduZWQgaW50IGlycSkKLXsgCi0JaWYgKCEoaXJxX2Rlc2NbaXJxXS5zdGF0dXMgJiAoSVJRX0RJU0FCTEVEfElSUV9JTlBST0dSRVNTKSkpCi0JCWRwMjY0X2VuYWJsZV9pcnEoaXJxKTsKLX0KLQogc3RhdGljIHZvaWQKIGNsaXBwZXJfZW5hYmxlX2lycSh1bnNpZ25lZCBpbnQgaXJxKQogewpAQCAtMTQ3LDIwICsxMzMsNiBAQAogCXNwaW5fdW5sb2NrKCZkcDI2NF9pcnFfbG9jayk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQKLWNsaXBwZXJfc3RhcnR1cF9pcnEodW5zaWduZWQgaW50IGlycSkKLXsgCi0JY2xpcHBlcl9lbmFibGVfaXJxKGlycSk7Ci0JcmV0dXJuIDA7IC8qIG5ldmVyIGFueXRoaW5nIHBlbmRpbmcgKi8KLX0KLQotc3RhdGljIHZvaWQKLWNsaXBwZXJfZW5kX2lycSh1bnNpZ25lZCBpbnQgaXJxKQoteyAKLQlpZiAoIShpcnFfZGVzY1tpcnFdLnN0YXR1cyAmIChJUlFfRElTQUJMRUR8SVJRX0lOUFJPR1JFU1MpKSkKLQkJY2xpcHBlcl9lbmFibGVfaXJxKGlycSk7Ci19Ci0KIHN0YXRpYyB2b2lkCiBjcHVfc2V0X2lycV9hZmZpbml0eSh1bnNpZ25lZCBpbnQgaXJxLCBjcHVtYXNrX3QgYWZmaW5pdHkpCiB7CkBAIC0yMDAsMjMgKzE3MiwxNyBAQAogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGRwMjY0X2lycV90eXBlID0gewogCS5uYW1lCQk9ICJEUDI2NCIsCi0JLnN0YXJ0dXAJPSBkcDI2NF9zdGFydHVwX2lycSwKLQkuc2h1dGRvd24JPSBkcDI2NF9kaXNhYmxlX2lycSwKLQkuZW5hYmxlCQk9IGRwMjY0X2VuYWJsZV9pcnEsCi0JLmRpc2FibGUJPSBkcDI2NF9kaXNhYmxlX2lycSwKLQkuYWNrCQk9IGRwMjY0X2Rpc2FibGVfaXJxLAotCS5lbmQJCT0gZHAyNjRfZW5kX2lycSwKKwkudW5tYXNrCQk9IGRwMjY0X2VuYWJsZV9pcnEsCisJLm1hc2sJCT0gZHAyNjRfZGlzYWJsZV9pcnEsCisJLm1hc2tfYWNrCT0gZHAyNjRfZGlzYWJsZV9pcnEsCiAJLnNldF9hZmZpbml0eQk9IGRwMjY0X3NldF9hZmZpbml0eSwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgY2xpcHBlcl9pcnFfdHlwZSA9IHsKIAkubmFtZQkJPSAiQ0xJUFBFUiIsCi0JLnN0YXJ0dXAJPSBjbGlwcGVyX3N0YXJ0dXBfaXJxLAotCS5zaHV0ZG93bgk9IGNsaXBwZXJfZGlzYWJsZV9pcnEsCi0JLmVuYWJsZQkJPSBjbGlwcGVyX2VuYWJsZV9pcnEsCi0JLmRpc2FibGUJPSBjbGlwcGVyX2Rpc2FibGVfaXJxLAotCS5hY2sJCT0gY2xpcHBlcl9kaXNhYmxlX2lycSwKLQkuZW5kCQk9IGNsaXBwZXJfZW5kX2lycSwKKwkudW5tYXNrCQk9IGNsaXBwZXJfZW5hYmxlX2lycSwKKwkubWFzawkJPSBjbGlwcGVyX2Rpc2FibGVfaXJxLAorCS5tYXNrX2Fjawk9IGNsaXBwZXJfZGlzYWJsZV9pcnEsCiAJLnNldF9hZmZpbml0eQk9IGNsaXBwZXJfc2V0X2FmZmluaXR5LAogfTsKIApAQCAtMzAyLDggKzI2OCw4IEBACiB7CiAJbG9uZyBpOwogCWZvciAoaSA9IGltaW47IGkgPD0gaW1heDsgKytpKSB7Ci0JCWlycV9kZXNjW2ldLnN0YXR1cyA9IElSUV9ESVNBQkxFRCB8IElSUV9MRVZFTDsKLQkJaXJxX2Rlc2NbaV0uY2hpcCA9IG9wczsKKwkJaXJxX3RvX2Rlc2MoaSktPnN0YXR1cyB8PSBJUlFfTEVWRUw7CisJCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihpLCBvcHMsIGhhbmRsZV9sZXZlbF9pcnEpOwogCX0KIH0KIApkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX2ViNjRwLmMgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfZWI2NHAuYwppbmRleCBkZjIwOTBjLi5hZTVmMjlkIDEwMDY0NAotLS0gYS9hcmNoL2FscGhhL2tlcm5lbC9zeXNfZWI2NHAuYworKysgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfZWI2NHAuYwpAQCAtNTUsMjggKzU1LDExIEBACiAJZWI2NHBfdXBkYXRlX2lycV9odyhpcnEsIGNhY2hlZF9pcnFfbWFzayB8PSAxIDw8IGlycSk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQKLWViNjRwX3N0YXJ0dXBfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JZWI2NHBfZW5hYmxlX2lycShpcnEpOwotCXJldHVybiAwOyAvKiBuZXZlciBhbnl0aGluZyBwZW5kaW5nICovCi19Ci0KLXN0YXRpYyB2b2lkCi1lYjY0cF9lbmRfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JaWYgKCEoaXJxX2Rlc2NbaXJxXS5zdGF0dXMgJiAoSVJRX0RJU0FCTEVEfElSUV9JTlBST0dSRVNTKSkpCi0JCWViNjRwX2VuYWJsZV9pcnEoaXJxKTsKLX0KLQogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBlYjY0cF9pcnFfdHlwZSA9IHsKIAkubmFtZQkJPSAiRUI2NFAiLAotCS5zdGFydHVwCT0gZWI2NHBfc3RhcnR1cF9pcnEsCi0JLnNodXRkb3duCT0gZWI2NHBfZGlzYWJsZV9pcnEsCi0JLmVuYWJsZQkJPSBlYjY0cF9lbmFibGVfaXJxLAotCS5kaXNhYmxlCT0gZWI2NHBfZGlzYWJsZV9pcnEsCi0JLmFjawkJPSBlYjY0cF9kaXNhYmxlX2lycSwKLQkuZW5kCQk9IGViNjRwX2VuZF9pcnEsCisJLnVubWFzawkJPSBlYjY0cF9lbmFibGVfaXJxLAorCS5tYXNrCQk9IGViNjRwX2Rpc2FibGVfaXJxLAorCS5tYXNrX2Fjawk9IGViNjRwX2Rpc2FibGVfaXJxLAogfTsKIAogc3RhdGljIHZvaWQgCkBAIC0xMzUsOCArMTE4LDggQEAKIAlpbml0X2k4MjU5YV9pcnFzKCk7CiAKIAlmb3IgKGkgPSAxNjsgaSA8IDMyOyArK2kpIHsKLQkJaXJxX2Rlc2NbaV0uc3RhdHVzID0gSVJRX0RJU0FCTEVEIHwgSVJRX0xFVkVMOwotCQlpcnFfZGVzY1tpXS5jaGlwID0gJmViNjRwX2lycV90eXBlOworCQlpcnFfdG9fZGVzYyhpKS0+c3RhdHVzIHw9IElSUV9MRVZFTDsKKwkJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKGksICZlYjY0cF9pcnFfdHlwZSwgaGFuZGxlX2xldmVsX2lycSk7CiAJfQkJCiAKIAljb21tb25faW5pdF9pc2FfZG1hKCk7CmRpZmYgLS1naXQgYS9hcmNoL2FscGhhL2tlcm5lbC9zeXNfZWlnZXIuYyBiL2FyY2gvYWxwaGEva2VybmVsL3N5c19laWdlci5jCmluZGV4IDNjYTFkYmMuLjExMjFiYzUgMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEva2VybmVsL3N5c19laWdlci5jCisrKyBiL2FyY2gvYWxwaGEva2VybmVsL3N5c19laWdlci5jCkBAIC02NiwyOCArNjYsMTEgQEAKIAllaWdlcl91cGRhdGVfaXJxX2h3KGlycSwgbWFzayk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQKLWVpZ2VyX3N0YXJ0dXBfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JZWlnZXJfZW5hYmxlX2lycShpcnEpOwotCXJldHVybiAwOyAvKiBuZXZlciBhbnl0aGluZyBwZW5kaW5nICovCi19Ci0KLXN0YXRpYyB2b2lkCi1laWdlcl9lbmRfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JaWYgKCEoaXJxX2Rlc2NbaXJxXS5zdGF0dXMgJiAoSVJRX0RJU0FCTEVEfElSUV9JTlBST0dSRVNTKSkpCi0JCWVpZ2VyX2VuYWJsZV9pcnEoaXJxKTsKLX0KLQogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBlaWdlcl9pcnFfdHlwZSA9IHsKIAkubmFtZQkJPSAiRUlHRVIiLAotCS5zdGFydHVwCT0gZWlnZXJfc3RhcnR1cF9pcnEsCi0JLnNodXRkb3duCT0gZWlnZXJfZGlzYWJsZV9pcnEsCi0JLmVuYWJsZQkJPSBlaWdlcl9lbmFibGVfaXJxLAotCS5kaXNhYmxlCT0gZWlnZXJfZGlzYWJsZV9pcnEsCi0JLmFjawkJPSBlaWdlcl9kaXNhYmxlX2lycSwKLQkuZW5kCQk9IGVpZ2VyX2VuZF9pcnEsCisJLnVubWFzawkJPSBlaWdlcl9lbmFibGVfaXJxLAorCS5tYXNrCQk9IGVpZ2VyX2Rpc2FibGVfaXJxLAorCS5tYXNrX2Fjawk9IGVpZ2VyX2Rpc2FibGVfaXJxLAogfTsKIAogc3RhdGljIHZvaWQKQEAgLTE1Myw4ICsxMzYsOCBAQAogCWluaXRfaTgyNTlhX2lycXMoKTsKIAogCWZvciAoaSA9IDE2OyBpIDwgMTI4OyArK2kpIHsKLQkJaXJxX2Rlc2NbaV0uc3RhdHVzID0gSVJRX0RJU0FCTEVEIHwgSVJRX0xFVkVMOwotCQlpcnFfZGVzY1tpXS5jaGlwID0gJmVpZ2VyX2lycV90eXBlOworCQlpcnFfdG9fZGVzYyhpKS0+c3RhdHVzIHw9IElSUV9MRVZFTDsKKwkJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKGksICZlaWdlcl9pcnFfdHlwZSwgaGFuZGxlX2xldmVsX2lycSk7CiAJfQogfQogCmRpZmYgLS1naXQgYS9hcmNoL2FscGhhL2tlcm5lbC9zeXNfamVuc2VuLmMgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfamVuc2VuLmMKaW5kZXggN2E3YWUzNi4uMzRmNTVlMCAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX2plbnNlbi5jCisrKyBiL2FyY2gvYWxwaGEva2VybmVsL3N5c19qZW5zZW4uYwpAQCAtNjIsMzAgKzYyLDYgQEAKICAqIHdvcmxkLgogICovCiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQKLWplbnNlbl9sb2NhbF9zdGFydHVwKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JLyogdGhlIHBhcnBvcnQgaXMgcmVhbGx5IGh3IElSUSAxLCBzaWxseSBKZW5zZW4uICAqLwotCWlmIChpcnEgPT0gNykKLQkJaTgyNTlhX3N0YXJ0dXBfaXJxKDEpOwotCWVsc2UKLQkJLyoKLQkJICogRm9yIGFsbCB0cnVlIGxvY2FsIGludGVycnVwdHMsIHNldCB0aGUgZmxhZyB0aGF0IHByZXZlbnRzCi0JCSAqIHRoZSBJUEwgZnJvbSBiZWluZyBkcm9wcGVkIGR1cmluZyBoYW5kbGVyIHByb2Nlc3NpbmcuCi0JCSAqLwotCQlpZiAoaXJxX2Rlc2NbaXJxXS5hY3Rpb24pCi0JCQlpcnFfZGVzY1tpcnFdLmFjdGlvbi0+ZmxhZ3MgfD0gSVJRRl9ESVNBQkxFRDsKLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIHZvaWQKLWplbnNlbl9sb2NhbF9zaHV0ZG93bih1bnNpZ25lZCBpbnQgaXJxKQotewotCS8qIHRoZSBwYXJwb3J0IGlzIHJlYWxseSBodyBJUlEgMSwgc2lsbHkgSmVuc2VuLiAgKi8KLQlpZiAoaXJxID09IDcpCi0JCWk4MjU5YV9kaXNhYmxlX2lycSgxKTsKLX0KLQogc3RhdGljIHZvaWQKIGplbnNlbl9sb2NhbF9lbmFibGUodW5zaWduZWQgaW50IGlycSkKIHsKQEAgLTEwMywyOSArNzksMTggQEAKIH0KIAogc3RhdGljIHZvaWQKLWplbnNlbl9sb2NhbF9hY2sodW5zaWduZWQgaW50IGlycSkKK2plbnNlbl9sb2NhbF9tYXNrX2Fjayh1bnNpZ25lZCBpbnQgaXJxKQogewogCS8qIHRoZSBwYXJwb3J0IGlzIHJlYWxseSBodyBJUlEgMSwgc2lsbHkgSmVuc2VuLiAgKi8KIAlpZiAoaXJxID09IDcpCiAJCWk4MjU5YV9tYXNrX2FuZF9hY2tfaXJxKDEpOwogfQogCi1zdGF0aWMgdm9pZAotamVuc2VuX2xvY2FsX2VuZCh1bnNpZ25lZCBpbnQgaXJxKQotewotCS8qIHRoZSBwYXJwb3J0IGlzIHJlYWxseSBodyBJUlEgMSwgc2lsbHkgSmVuc2VuLiAgKi8KLQlpZiAoaXJxID09IDcpCi0JCWk4MjU5YV9lbmRfaXJxKDEpOwotfQotCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGplbnNlbl9sb2NhbF9pcnFfdHlwZSA9IHsKIAkubmFtZQkJPSAiTE9DQUwiLAotCS5zdGFydHVwCT0gamVuc2VuX2xvY2FsX3N0YXJ0dXAsCi0JLnNodXRkb3duCT0gamVuc2VuX2xvY2FsX3NodXRkb3duLAotCS5lbmFibGUJCT0gamVuc2VuX2xvY2FsX2VuYWJsZSwKLQkuZGlzYWJsZQk9IGplbnNlbl9sb2NhbF9kaXNhYmxlLAotCS5hY2sJCT0gamVuc2VuX2xvY2FsX2FjaywKLQkuZW5kCQk9IGplbnNlbl9sb2NhbF9lbmQsCisJLnVubWFzawkJPSBqZW5zZW5fbG9jYWxfZW5hYmxlLAorCS5tYXNrCQk9IGplbnNlbl9sb2NhbF9kaXNhYmxlLAorCS5tYXNrX2Fjawk9IGplbnNlbl9sb2NhbF9tYXNrX2FjaywKIH07CiAKIHN0YXRpYyB2b2lkIApAQCAtMTU4LDcgKzEyMyw3IEBACiAJfQogCiAJLyogSWYgdGhlcmUgaXMgbm8gaGFuZGxlciB5ZXQuLi4gKi8KLQlpZiAoaXJxX2Rlc2NbaXJxXS5hY3Rpb24gPT0gTlVMTCkgeworCWlmICghaXJxX2hhc19hY3Rpb24oaXJxKSkgewogCSAgICAvKiBJZiBpdCBpcyBhIGxvY2FsIGludGVycnVwdCB0aGF0IGNhbm5vdCBiZSBtYXNrZWQuLi4gKi8KIAkgICAgaWYgKHZlY3RvciA+PSAweDkwMCkKIAkgICAgewpAQCAtMjA2LDExICsxNzEsMTEgQEAKIHsKIAlpbml0X2k4MjU5YV9pcnFzKCk7CiAKLQlpcnFfZGVzY1sxXS5jaGlwID0gJmplbnNlbl9sb2NhbF9pcnFfdHlwZTsKLQlpcnFfZGVzY1s0XS5jaGlwID0gJmplbnNlbl9sb2NhbF9pcnFfdHlwZTsKLQlpcnFfZGVzY1szXS5jaGlwID0gJmplbnNlbl9sb2NhbF9pcnFfdHlwZTsKLQlpcnFfZGVzY1s3XS5jaGlwID0gJmplbnNlbl9sb2NhbF9pcnFfdHlwZTsKLQlpcnFfZGVzY1s5XS5jaGlwID0gJmplbnNlbl9sb2NhbF9pcnFfdHlwZTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoMSwgJmplbnNlbl9sb2NhbF9pcnFfdHlwZSwgaGFuZGxlX2xldmVsX2lycSk7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKDQsICZqZW5zZW5fbG9jYWxfaXJxX3R5cGUsIGhhbmRsZV9sZXZlbF9pcnEpOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcigzLCAmamVuc2VuX2xvY2FsX2lycV90eXBlLCBoYW5kbGVfbGV2ZWxfaXJxKTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoNywgJmplbnNlbl9sb2NhbF9pcnFfdHlwZSwgaGFuZGxlX2xldmVsX2lycSk7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKDksICZqZW5zZW5fbG9jYWxfaXJxX3R5cGUsIGhhbmRsZV9sZXZlbF9pcnEpOwogCiAJY29tbW9uX2luaXRfaXNhX2RtYSgpOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX21hcnZlbC5jIGIvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX21hcnZlbC5jCmluZGV4IDBiYjNiNWMuLjJiZmM5ZjEgMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEva2VybmVsL3N5c19tYXJ2ZWwuYworKysgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfbWFydmVsLmMKQEAgLTE0MywyMCArMTQzLDYgQEAKIAlzcGluX3VubG9jaygmaW83LT5pcnFfbG9jayk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQKLWlvN19zdGFydHVwX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWlvN19lbmFibGVfaXJxKGlycSk7Ci0JcmV0dXJuIDA7CS8qIG5ldmVyIGFueXRoaW5nIHBlbmRpbmcgKi8KLX0KLQotc3RhdGljIHZvaWQKLWlvN19lbmRfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JaWYgKCEoaXJxX2Rlc2NbaXJxXS5zdGF0dXMgJiAoSVJRX0RJU0FCTEVEfElSUV9JTlBST0dSRVNTKSkpCi0JCWlvN19lbmFibGVfaXJxKGlycSk7Ci19Ci0KIHN0YXRpYyB2b2lkCiBtYXJ2ZWxfaXJxX25vb3AodW5zaWduZWQgaW50IGlycSkgCiB7IApAQCAtMTcxLDMyICsxNTcsMjIgQEAKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBtYXJ2ZWxfbGVnYWN5X2lycV90eXBlID0gewogCS5uYW1lCQk9ICJMRUdBQ1kiLAotCS5zdGFydHVwCT0gbWFydmVsX2lycV9ub29wX3JldHVybiwKLQkuc2h1dGRvd24JPSBtYXJ2ZWxfaXJxX25vb3AsCi0JLmVuYWJsZQkJPSBtYXJ2ZWxfaXJxX25vb3AsCi0JLmRpc2FibGUJPSBtYXJ2ZWxfaXJxX25vb3AsCi0JLmFjawkJPSBtYXJ2ZWxfaXJxX25vb3AsCi0JLmVuZAkJPSBtYXJ2ZWxfaXJxX25vb3AsCisJLm1hc2sJCT0gbWFydmVsX2lycV9ub29wLAorCS51bm1hc2sJCT0gbWFydmVsX2lycV9ub29wLAogfTsKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBpbzdfbHNpX2lycV90eXBlID0gewogCS5uYW1lCQk9ICJMU0kiLAotCS5zdGFydHVwCT0gaW83X3N0YXJ0dXBfaXJxLAotCS5zaHV0ZG93bgk9IGlvN19kaXNhYmxlX2lycSwKLQkuZW5hYmxlCQk9IGlvN19lbmFibGVfaXJxLAotCS5kaXNhYmxlCT0gaW83X2Rpc2FibGVfaXJxLAotCS5hY2sJCT0gaW83X2Rpc2FibGVfaXJxLAotCS5lbmQJCT0gaW83X2VuZF9pcnEsCisJLnVubWFzawkJPSBpbzdfZW5hYmxlX2lycSwKKwkubWFzawkJPSBpbzdfZGlzYWJsZV9pcnEsCisJLm1hc2tfYWNrCT0gaW83X2Rpc2FibGVfaXJxLAogfTsKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBpbzdfbXNpX2lycV90eXBlID0gewogCS5uYW1lCQk9ICJNU0kiLAotCS5zdGFydHVwCT0gaW83X3N0YXJ0dXBfaXJxLAotCS5zaHV0ZG93bgk9IGlvN19kaXNhYmxlX2lycSwKLQkuZW5hYmxlCQk9IGlvN19lbmFibGVfaXJxLAotCS5kaXNhYmxlCT0gaW83X2Rpc2FibGVfaXJxLAorCS51bm1hc2sJCT0gaW83X2VuYWJsZV9pcnEsCisJLm1hc2sJCT0gaW83X2Rpc2FibGVfaXJxLAogCS5hY2sJCT0gbWFydmVsX2lycV9ub29wLAotCS5lbmQJCT0gaW83X2VuZF9pcnEsCiB9OwogCiBzdGF0aWMgdm9pZApAQCAtMzA0LDggKzI4MCw4IEBACiAKIAkvKiBTZXQgdXAgdGhlIGxzaSBpcnFzLiAgKi8KIAlmb3IgKGkgPSAwOyBpIDwgMTI4OyArK2kpIHsKLQkJaXJxX2Rlc2NbYmFzZSArIGldLnN0YXR1cyA9IElSUV9ESVNBQkxFRCB8IElSUV9MRVZFTDsKLQkJaXJxX2Rlc2NbYmFzZSArIGldLmNoaXAgPSBsc2lfb3BzOworCQlpcnFfdG9fZGVzYyhiYXNlICsgaSktPnN0YXR1cyB8PSBJUlFfTEVWRUw7CisJCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihiYXNlICsgaSwgbHNpX29wcywgaGFuZGxlX2xldmVsX2lycSk7CiAJfQogCiAJLyogRGlzYWJsZSB0aGUgaW1wbGVtZW50ZWQgaXJxcyBpbiBoYXJkd2FyZS4gICovCkBAIC0zMTgsOCArMjk0LDggQEAKIAogCS8qIFNldCB1cCB0aGUgbXNpIGlycXMuICAqLwogCWZvciAoaSA9IDEyODsgaSA8ICgxMjggKyA1MTIpOyArK2kpIHsKLQkJaXJxX2Rlc2NbYmFzZSArIGldLnN0YXR1cyA9IElSUV9ESVNBQkxFRCB8IElSUV9MRVZFTDsKLQkJaXJxX2Rlc2NbYmFzZSArIGldLmNoaXAgPSBtc2lfb3BzOworCQlpcnFfdG9fZGVzYyhiYXNlICsgaSktPnN0YXR1cyB8PSBJUlFfTEVWRUw7CisJCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihiYXNlICsgaSwgbXNpX29wcywgaGFuZGxlX2xldmVsX2lycSk7CiAJfQogCiAJZm9yIChpID0gMDsgaSA8IDE2OyArK2kpCkBAIC0zMzYsOCArMzEyLDggQEAKIAogCS8qIFJlc2VydmUgdGhlIGxlZ2FjeSBpcnFzLiAgKi8KIAlmb3IgKGkgPSAwOyBpIDwgMTY7ICsraSkgewotCQlpcnFfZGVzY1tpXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JCWlycV9kZXNjW2ldLmNoaXAgPSAmbWFydmVsX2xlZ2FjeV9pcnFfdHlwZTsKKwkJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKGksICZtYXJ2ZWxfbGVnYWN5X2lycV90eXBlLAorCQkJaGFuZGxlX2xldmVsX2lycSk7CiAJfQogCiAJLyogSW5pdCB0aGUgaW83IGlycXMuICAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX21pa2FzYS5jIGIvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX21pa2FzYS5jCmluZGV4IGVlODg2NTEuLmJjYzE2MzkgMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEva2VybmVsL3N5c19taWthc2EuYworKysgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfbWlrYXNhLmMKQEAgLTU0LDI4ICs1NCwxMSBAQAogCW1pa2FzYV91cGRhdGVfaXJxX2h3KGNhY2hlZF9pcnFfbWFzayAmPSB+KDEgPDwgKGlycSAtIDE2KSkpOwogfQogCi1zdGF0aWMgdW5zaWduZWQgaW50Ci1taWthc2Ffc3RhcnR1cF9pcnEodW5zaWduZWQgaW50IGlycSkKLXsKLQltaWthc2FfZW5hYmxlX2lycShpcnEpOwotCXJldHVybiAwOwotfQotCi1zdGF0aWMgdm9pZAotbWlrYXNhX2VuZF9pcnEodW5zaWduZWQgaW50IGlycSkKLXsKLQlpZiAoIShpcnFfZGVzY1tpcnFdLnN0YXR1cyAmIChJUlFfRElTQUJMRUR8SVJRX0lOUFJPR1JFU1MpKSkKLQkJbWlrYXNhX2VuYWJsZV9pcnEoaXJxKTsKLX0KLQogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBtaWthc2FfaXJxX3R5cGUgPSB7CiAJLm5hbWUJCT0gIk1JS0FTQSIsCi0JLnN0YXJ0dXAJPSBtaWthc2Ffc3RhcnR1cF9pcnEsCi0JLnNodXRkb3duCT0gbWlrYXNhX2Rpc2FibGVfaXJxLAotCS5lbmFibGUJCT0gbWlrYXNhX2VuYWJsZV9pcnEsCi0JLmRpc2FibGUJPSBtaWthc2FfZGlzYWJsZV9pcnEsCi0JLmFjawkJPSBtaWthc2FfZGlzYWJsZV9pcnEsCi0JLmVuZAkJPSBtaWthc2FfZW5kX2lycSwKKwkudW5tYXNrCQk9IG1pa2FzYV9lbmFibGVfaXJxLAorCS5tYXNrCQk9IG1pa2FzYV9kaXNhYmxlX2lycSwKKwkubWFza19hY2sJPSBtaWthc2FfZGlzYWJsZV9pcnEsCiB9OwogCiBzdGF0aWMgdm9pZCAKQEAgLTExNSw4ICs5OCw4IEBACiAJbWlrYXNhX3VwZGF0ZV9pcnFfaHcoMCk7CiAKIAlmb3IgKGkgPSAxNjsgaSA8IDMyOyArK2kpIHsKLQkJaXJxX2Rlc2NbaV0uc3RhdHVzID0gSVJRX0RJU0FCTEVEIHwgSVJRX0xFVkVMOwotCQlpcnFfZGVzY1tpXS5jaGlwID0gJm1pa2FzYV9pcnFfdHlwZTsKKwkJaXJxX3RvX2Rlc2MoaSktPnN0YXR1cyB8PSBJUlFfTEVWRUw7CisJCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihpLCAmbWlrYXNhX2lycV90eXBlLCBoYW5kbGVfbGV2ZWxfaXJxKTsKIAl9CiAKIAlpbml0X2k4MjU5YV9pcnFzKCk7CmRpZmYgLS1naXQgYS9hcmNoL2FscGhhL2tlcm5lbC9zeXNfbm9yaXRha2UuYyBiL2FyY2gvYWxwaGEva2VybmVsL3N5c19ub3JpdGFrZS5jCmluZGV4IDg2NTAzZmUuLmU4OGY0YWUgMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEva2VybmVsL3N5c19ub3JpdGFrZS5jCisrKyBiL2FyY2gvYWxwaGEva2VybmVsL3N5c19ub3JpdGFrZS5jCkBAIC01OSwyOCArNTksMTEgQEAKIAlub3JpdGFrZV91cGRhdGVfaXJxX2h3KGlycSwgY2FjaGVkX2lycV9tYXNrICY9IH4oMSA8PCAoaXJxIC0gMTYpKSk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQKLW5vcml0YWtlX3N0YXJ0dXBfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0Jbm9yaXRha2VfZW5hYmxlX2lycShpcnEpOwotCXJldHVybiAwOwotfQotCi1zdGF0aWMgdm9pZAotbm9yaXRha2VfZW5kX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotICAgICAgICBpZiAoIShpcnFfZGVzY1tpcnFdLnN0YXR1cyAmIChJUlFfRElTQUJMRUR8SVJRX0lOUFJPR1JFU1MpKSkKLSAgICAgICAgICAgICAgICBub3JpdGFrZV9lbmFibGVfaXJxKGlycSk7Ci19Ci0KIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbm9yaXRha2VfaXJxX3R5cGUgPSB7CiAJLm5hbWUJCT0gIk5PUklUQUtFIiwKLQkuc3RhcnR1cAk9IG5vcml0YWtlX3N0YXJ0dXBfaXJxLAotCS5zaHV0ZG93bgk9IG5vcml0YWtlX2Rpc2FibGVfaXJxLAotCS5lbmFibGUJCT0gbm9yaXRha2VfZW5hYmxlX2lycSwKLQkuZGlzYWJsZQk9IG5vcml0YWtlX2Rpc2FibGVfaXJxLAotCS5hY2sJCT0gbm9yaXRha2VfZGlzYWJsZV9pcnEsCi0JLmVuZAkJPSBub3JpdGFrZV9lbmRfaXJxLAorCS51bm1hc2sJCT0gbm9yaXRha2VfZW5hYmxlX2lycSwKKwkubWFzawkJPSBub3JpdGFrZV9kaXNhYmxlX2lycSwKKwkubWFza19hY2sJPSBub3JpdGFrZV9kaXNhYmxlX2lycSwKIH07CiAKIHN0YXRpYyB2b2lkIApAQCAtMTQ0LDggKzEyNyw4IEBACiAJb3V0dygwLCAweDU0Yyk7CiAKIAlmb3IgKGkgPSAxNjsgaSA8IDQ4OyArK2kpIHsKLQkJaXJxX2Rlc2NbaV0uc3RhdHVzID0gSVJRX0RJU0FCTEVEIHwgSVJRX0xFVkVMOwotCQlpcnFfZGVzY1tpXS5jaGlwID0gJm5vcml0YWtlX2lycV90eXBlOworCQlpcnFfdG9fZGVzYyhpKS0+c3RhdHVzIHw9IElSUV9MRVZFTDsKKwkJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKGksICZub3JpdGFrZV9pcnFfdHlwZSwgaGFuZGxlX2xldmVsX2lycSk7CiAJfQogCiAJaW5pdF9pODI1OWFfaXJxcygpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX3Jhd2hpZGUuYyBiL2FyY2gvYWxwaGEva2VybmVsL3N5c19yYXdoaWRlLmMKaW5kZXggMjZjMzIyYi4uNmE1MTM2NCAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX3Jhd2hpZGUuYworKysgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfcmF3aGlkZS5jCkBAIC0xMjEsMjggKzEyMSwxMSBAQAogCXNwaW5fdW5sb2NrKCZyYXdoaWRlX2lycV9sb2NrKTsKIH0KIAotc3RhdGljIHVuc2lnbmVkIGludAotcmF3aGlkZV9zdGFydHVwX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCXJhd2hpZGVfZW5hYmxlX2lycShpcnEpOwotCXJldHVybiAwOwotfQotCi1zdGF0aWMgdm9pZAotcmF3aGlkZV9lbmRfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JaWYgKCEoaXJxX2Rlc2NbaXJxXS5zdGF0dXMgJiAoSVJRX0RJU0FCTEVEfElSUV9JTlBST0dSRVNTKSkpCi0JCXJhd2hpZGVfZW5hYmxlX2lycShpcnEpOwotfQotCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHJhd2hpZGVfaXJxX3R5cGUgPSB7CiAJLm5hbWUJCT0gIlJBV0hJREUiLAotCS5zdGFydHVwCT0gcmF3aGlkZV9zdGFydHVwX2lycSwKLQkuc2h1dGRvd24JPSByYXdoaWRlX2Rpc2FibGVfaXJxLAotCS5lbmFibGUJCT0gcmF3aGlkZV9lbmFibGVfaXJxLAotCS5kaXNhYmxlCT0gcmF3aGlkZV9kaXNhYmxlX2lycSwKLQkuYWNrCQk9IHJhd2hpZGVfbWFza19hbmRfYWNrX2lycSwKLQkuZW5kCQk9IHJhd2hpZGVfZW5kX2lycSwKKwkudW5tYXNrCQk9IHJhd2hpZGVfZW5hYmxlX2lycSwKKwkubWFzawkJPSByYXdoaWRlX2Rpc2FibGVfaXJxLAorCS5tYXNrX2Fjawk9IHJhd2hpZGVfbWFza19hbmRfYWNrX2lycSwKIH07CiAKIHN0YXRpYyB2b2lkIApAQCAtMTk0LDggKzE3Nyw4IEBACiAJfQogCiAJZm9yIChpID0gMTY7IGkgPCAxMjg7ICsraSkgewotCQlpcnFfZGVzY1tpXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQgfCBJUlFfTEVWRUw7Ci0JCWlycV9kZXNjW2ldLmNoaXAgPSAmcmF3aGlkZV9pcnFfdHlwZTsKKwkJaXJxX3RvX2Rlc2MoaSktPnN0YXR1cyB8PSBJUlFfTEVWRUw7CisJCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihpLCAmcmF3aGlkZV9pcnFfdHlwZSwgaGFuZGxlX2xldmVsX2lycSk7CiAJfQogCiAJaW5pdF9pODI1OWFfaXJxcygpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX3J4MTY0LmMgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfcngxNjQuYwppbmRleCBiZTE2MTEyLi44OWU3ZTM3ZSAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX3J4MTY0LmMKKysrIGIvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX3J4MTY0LmMKQEAgLTU4LDI4ICs1OCwxMSBAQAogCXJ4MTY0X3VwZGF0ZV9pcnFfaHcoY2FjaGVkX2lycV9tYXNrICY9IH4oMVVMIDw8IChpcnEgLSAxNikpKTsKIH0KIAotc3RhdGljIHVuc2lnbmVkIGludAotcngxNjRfc3RhcnR1cF9pcnEodW5zaWduZWQgaW50IGlycSkKLXsKLQlyeDE2NF9lbmFibGVfaXJxKGlycSk7Ci0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyB2b2lkCi1yeDE2NF9lbmRfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JaWYgKCEoaXJxX2Rlc2NbaXJxXS5zdGF0dXMgJiAoSVJRX0RJU0FCTEVEfElSUV9JTlBST0dSRVNTKSkpCi0JCXJ4MTY0X2VuYWJsZV9pcnEoaXJxKTsKLX0KLQogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCByeDE2NF9pcnFfdHlwZSA9IHsKIAkubmFtZQkJPSAiUlgxNjQiLAotCS5zdGFydHVwCT0gcngxNjRfc3RhcnR1cF9pcnEsCi0JLnNodXRkb3duCT0gcngxNjRfZGlzYWJsZV9pcnEsCi0JLmVuYWJsZQkJPSByeDE2NF9lbmFibGVfaXJxLAotCS5kaXNhYmxlCT0gcngxNjRfZGlzYWJsZV9pcnEsCi0JLmFjawkJPSByeDE2NF9kaXNhYmxlX2lycSwKLQkuZW5kCQk9IHJ4MTY0X2VuZF9pcnEsCisJLnVubWFzawkJPSByeDE2NF9lbmFibGVfaXJxLAorCS5tYXNrCQk9IHJ4MTY0X2Rpc2FibGVfaXJxLAorCS5tYXNrX2Fjawk9IHJ4MTY0X2Rpc2FibGVfaXJxLAogfTsKIAogc3RhdGljIHZvaWQgCkBAIC0xMTYsOCArOTksOCBAQAogCiAJcngxNjRfdXBkYXRlX2lycV9odygwKTsKIAlmb3IgKGkgPSAxNjsgaSA8IDQwOyArK2kpIHsKLQkJaXJxX2Rlc2NbaV0uc3RhdHVzID0gSVJRX0RJU0FCTEVEIHwgSVJRX0xFVkVMOwotCQlpcnFfZGVzY1tpXS5jaGlwID0gJnJ4MTY0X2lycV90eXBlOworCQlpcnFfdG9fZGVzYyhpKS0+c3RhdHVzIHw9IElSUV9MRVZFTDsKKwkJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKGksICZyeDE2NF9pcnFfdHlwZSwgaGFuZGxlX2xldmVsX2lycSk7CiAJfQogCiAJaW5pdF9pODI1OWFfaXJxcygpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX3NhYmxlLmMgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfc2FibGUuYwppbmRleCBiMmFiZTI3Li41YzQ0MjNkIDEwMDY0NAotLS0gYS9hcmNoL2FscGhhL2tlcm5lbC9zeXNfc2FibGUuYworKysgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfc2FibGUuYwpAQCAtNDc0LDIwICs0NzQsNiBAQAogI2VuZGlmCiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQKLXNhYmxlX2x5bnhfc3RhcnR1cF9pcnEodW5zaWduZWQgaW50IGlycSkKLXsKLQlzYWJsZV9seW54X2VuYWJsZV9pcnEoaXJxKTsKLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIHZvaWQKLXNhYmxlX2x5bnhfZW5kX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWlmICghKGlycV9kZXNjW2lycV0uc3RhdHVzICYgKElSUV9ESVNBQkxFRHxJUlFfSU5QUk9HUkVTUykpKQotCQlzYWJsZV9seW54X2VuYWJsZV9pcnEoaXJxKTsKLX0KLQogc3RhdGljIHZvaWQKIHNhYmxlX2x5bnhfbWFza19hbmRfYWNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQogewpAQCAtNTAzLDEyICs0ODksOSBAQAogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHNhYmxlX2x5bnhfaXJxX3R5cGUgPSB7CiAJLm5hbWUJCT0gIlNBQkxFL0xZTlgiLAotCS5zdGFydHVwCT0gc2FibGVfbHlueF9zdGFydHVwX2lycSwKLQkuc2h1dGRvd24JPSBzYWJsZV9seW54X2Rpc2FibGVfaXJxLAotCS5lbmFibGUJCT0gc2FibGVfbHlueF9lbmFibGVfaXJxLAotCS5kaXNhYmxlCT0gc2FibGVfbHlueF9kaXNhYmxlX2lycSwKLQkuYWNrCQk9IHNhYmxlX2x5bnhfbWFza19hbmRfYWNrX2lycSwKLQkuZW5kCQk9IHNhYmxlX2x5bnhfZW5kX2lycSwKKwkudW5tYXNrCQk9IHNhYmxlX2x5bnhfZW5hYmxlX2lycSwKKwkubWFzawkJPSBzYWJsZV9seW54X2Rpc2FibGVfaXJxLAorCS5tYXNrX2Fjawk9IHNhYmxlX2x5bnhfbWFza19hbmRfYWNrX2lycSwKIH07CiAKIHN0YXRpYyB2b2lkIApAQCAtNTM1LDggKzUxOCw5IEBACiAJbG9uZyBpOwogCiAJZm9yIChpID0gMDsgaSA8IG5yX29mX2lycXM7ICsraSkgewotCQlpcnFfZGVzY1tpXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQgfCBJUlFfTEVWRUw7Ci0JCWlycV9kZXNjW2ldLmNoaXAgPSAmc2FibGVfbHlueF9pcnFfdHlwZTsKKwkJaXJxX3RvX2Rlc2MoaSktPnN0YXR1cyB8PSBJUlFfTEVWRUw7CisJCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihpLCAmc2FibGVfbHlueF9pcnFfdHlwZSwKKwkJCWhhbmRsZV9sZXZlbF9pcnEpOwogCX0KIAogCWNvbW1vbl9pbml0X2lzYV9kbWEoKTsKZGlmZiAtLWdpdCBhL2FyY2gvYWxwaGEva2VybmVsL3N5c190YWthcmEuYyBiL2FyY2gvYWxwaGEva2VybmVsL3N5c190YWthcmEuYwppbmRleCA0ZGE1OTZiLi5mOGExZThhIDEwMDY0NAotLS0gYS9hcmNoL2FscGhhL2tlcm5lbC9zeXNfdGFrYXJhLmMKKysrIGIvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX3Rha2FyYS5jCkBAIC02MCwyOCArNjAsMTEgQEAKIAl0YWthcmFfdXBkYXRlX2lycV9odyhpcnEsIG1hc2spOwogfQogCi1zdGF0aWMgdW5zaWduZWQgaW50Ci10YWthcmFfc3RhcnR1cF9pcnEodW5zaWduZWQgaW50IGlycSkKLXsKLQl0YWthcmFfZW5hYmxlX2lycShpcnEpOwotCXJldHVybiAwOyAvKiBuZXZlciBhbnl0aGluZyBwZW5kaW5nICovCi19Ci0KLXN0YXRpYyB2b2lkCi10YWthcmFfZW5kX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWlmICghKGlycV9kZXNjW2lycV0uc3RhdHVzICYgKElSUV9ESVNBQkxFRHxJUlFfSU5QUk9HUkVTUykpKQotCQl0YWthcmFfZW5hYmxlX2lycShpcnEpOwotfQotCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHRha2FyYV9pcnFfdHlwZSA9IHsKIAkubmFtZQkJPSAiVEFLQVJBIiwKLQkuc3RhcnR1cAk9IHRha2FyYV9zdGFydHVwX2lycSwKLQkuc2h1dGRvd24JPSB0YWthcmFfZGlzYWJsZV9pcnEsCi0JLmVuYWJsZQkJPSB0YWthcmFfZW5hYmxlX2lycSwKLQkuZGlzYWJsZQk9IHRha2FyYV9kaXNhYmxlX2lycSwKLQkuYWNrCQk9IHRha2FyYV9kaXNhYmxlX2lycSwKLQkuZW5kCQk9IHRha2FyYV9lbmRfaXJxLAorCS51bm1hc2sJCT0gdGFrYXJhX2VuYWJsZV9pcnEsCisJLm1hc2sJCT0gdGFrYXJhX2Rpc2FibGVfaXJxLAorCS5tYXNrX2Fjawk9IHRha2FyYV9kaXNhYmxlX2lycSwKIH07CiAKIHN0YXRpYyB2b2lkCkBAIC0xNTMsOCArMTM2LDggQEAKIAkJdGFrYXJhX3VwZGF0ZV9pcnFfaHcoaSwgLTEpOwogCiAJZm9yIChpID0gMTY7IGkgPCAxMjg7ICsraSkgewotCQlpcnFfZGVzY1tpXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQgfCBJUlFfTEVWRUw7Ci0JCWlycV9kZXNjW2ldLmNoaXAgPSAmdGFrYXJhX2lycV90eXBlOworCQlpcnFfdG9fZGVzYyhpKS0+c3RhdHVzIHw9IElSUV9MRVZFTDsKKwkJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKGksICZ0YWthcmFfaXJxX3R5cGUsIGhhbmRsZV9sZXZlbF9pcnEpOwogCX0KIAogCWNvbW1vbl9pbml0X2lzYV9kbWEoKTsKZGlmZiAtLWdpdCBhL2FyY2gvYWxwaGEva2VybmVsL3N5c190aXRhbi5jIGIvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX3RpdGFuLmMKaW5kZXggOTAwOGQwZi4uZTAyNDk0YiAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX3RpdGFuLmMKKysrIGIvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX3RpdGFuLmMKQEAgLTEyOSwyMCArMTI5LDYgQEAKIAlzcGluX3VubG9jaygmdGl0YW5faXJxX2xvY2spOwogfQogCi1zdGF0aWMgdW5zaWduZWQgaW50Ci10aXRhbl9zdGFydHVwX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCXRpdGFuX2VuYWJsZV9pcnEoaXJxKTsKLQlyZXR1cm4gMDsJLyogbmV2ZXIgYW55dGhpbmcgcGVuZGluZyAqLwotfQotCi1zdGF0aWMgdm9pZAotdGl0YW5fZW5kX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWlmICghKGlycV9kZXNjW2lycV0uc3RhdHVzICYgKElSUV9ESVNBQkxFRHxJUlFfSU5QUk9HUkVTUykpKQotCQl0aXRhbl9lbmFibGVfaXJxKGlycSk7Ci19Ci0KIHN0YXRpYyB2b2lkCiB0aXRhbl9jcHVfc2V0X2lycV9hZmZpbml0eSh1bnNpZ25lZCBpbnQgaXJxLCBjcHVtYXNrX3QgYWZmaW5pdHkpCiB7CkBAIC0xODksMjAgKzE3NSwxNyBAQAogewogCWxvbmcgaTsKIAlmb3IgKGkgPSBpbWluOyBpIDw9IGltYXg7ICsraSkgewotCQlpcnFfZGVzY1tpXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQgfCBJUlFfTEVWRUw7Ci0JCWlycV9kZXNjW2ldLmNoaXAgPSBvcHM7CisJCWlycV90b19kZXNjKGkpLT5zdGF0dXMgfD0gSVJRX0xFVkVMOworCQlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoaSwgb3BzLCBoYW5kbGVfbGV2ZWxfaXJxKTsKIAl9CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgdGl0YW5faXJxX3R5cGUgPSB7Ci0gICAgICAgLm5hbWUJICAgICAgID0gIlRJVEFOIiwKLSAgICAgICAuc3RhcnR1cCAgICAgICAgPSB0aXRhbl9zdGFydHVwX2lycSwKLSAgICAgICAuc2h1dGRvd24gICAgICAgPSB0aXRhbl9kaXNhYmxlX2lycSwKLSAgICAgICAuZW5hYmxlICAgICAgICAgPSB0aXRhbl9lbmFibGVfaXJxLAotICAgICAgIC5kaXNhYmxlICAgICAgICA9IHRpdGFuX2Rpc2FibGVfaXJxLAotICAgICAgIC5hY2sgICAgICAgICAgICA9IHRpdGFuX2Rpc2FibGVfaXJxLAotICAgICAgIC5lbmQgICAgICAgICAgICA9IHRpdGFuX2VuZF9pcnEsCi0gICAgICAgLnNldF9hZmZpbml0eSAgID0gdGl0YW5fc2V0X2lycV9hZmZpbml0eSwKKyAgICAgICAubmFtZQkJPSAiVElUQU4iLAorICAgICAgIC51bm1hc2sJCT0gdGl0YW5fZW5hYmxlX2lycSwKKyAgICAgICAubWFzawkJPSB0aXRhbl9kaXNhYmxlX2lycSwKKyAgICAgICAubWFza19hY2sJPSB0aXRhbl9kaXNhYmxlX2lycSwKKyAgICAgICAuc2V0X2FmZmluaXR5CT0gdGl0YW5fc2V0X2lycV9hZmZpbml0eSwKIH07CiAKIHN0YXRpYyBpcnFyZXR1cm5fdApkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9rZXJuZWwvc3lzX3dpbGRmaXJlLmMgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfd2lsZGZpcmUuYwppbmRleCA2MmZkOTcyLi5lZWM1MjU5IDEwMDY0NAotLS0gYS9hcmNoL2FscGhhL2tlcm5lbC9zeXNfd2lsZGZpcmUuYworKysgYi9hcmNoL2FscGhhL2tlcm5lbC9zeXNfd2lsZGZpcmUuYwpAQCAtMTM5LDMyICsxMzksMTEgQEAKIAlzcGluX3VubG9jaygmd2lsZGZpcmVfaXJxX2xvY2spOwogfQogCi1zdGF0aWMgdW5zaWduZWQgaW50Ci13aWxkZmlyZV9zdGFydHVwX2lycSh1bnNpZ25lZCBpbnQgaXJxKQoteyAKLQl3aWxkZmlyZV9lbmFibGVfaXJxKGlycSk7Ci0JcmV0dXJuIDA7IC8qIG5ldmVyIGFueXRoaW5nIHBlbmRpbmcgKi8KLX0KLQotc3RhdGljIHZvaWQKLXdpbGRmaXJlX2VuZF9pcnEodW5zaWduZWQgaW50IGlycSkKLXsgCi0jaWYgMAotCWlmICghaXJxX2Rlc2NbaXJxXS5hY3Rpb24pCi0JCXByaW50aygiZ290IGlycSAlZFxuIiwgaXJxKTsKLSNlbmRpZgotCWlmICghKGlycV9kZXNjW2lycV0uc3RhdHVzICYgKElSUV9ESVNBQkxFRHxJUlFfSU5QUk9HUkVTUykpKQotCQl3aWxkZmlyZV9lbmFibGVfaXJxKGlycSk7Ci19Ci0KIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgd2lsZGZpcmVfaXJxX3R5cGUgPSB7CiAJLm5hbWUJCT0gIldJTERGSVJFIiwKLQkuc3RhcnR1cAk9IHdpbGRmaXJlX3N0YXJ0dXBfaXJxLAotCS5zaHV0ZG93bgk9IHdpbGRmaXJlX2Rpc2FibGVfaXJxLAotCS5lbmFibGUJCT0gd2lsZGZpcmVfZW5hYmxlX2lycSwKLQkuZGlzYWJsZQk9IHdpbGRmaXJlX2Rpc2FibGVfaXJxLAotCS5hY2sJCT0gd2lsZGZpcmVfbWFza19hbmRfYWNrX2lycSwKLQkuZW5kCQk9IHdpbGRmaXJlX2VuZF9pcnEsCisJLnVubWFzawkJPSB3aWxkZmlyZV9lbmFibGVfaXJxLAorCS5tYXNrCQk9IHdpbGRmaXJlX2Rpc2FibGVfaXJxLAorCS5tYXNrX2Fjawk9IHdpbGRmaXJlX21hc2tfYW5kX2Fja19pcnEsCiB9OwogCiBzdGF0aWMgdm9pZCBfX2luaXQKQEAgLTE5OCwxNSArMTc3LDE4IEBACiAJZm9yIChpID0gMDsgaSA8IDE2OyArK2kpIHsKIAkJaWYgKGkgPT0gMikKIAkJCWNvbnRpbnVlOwotCQlpcnFfZGVzY1tpK2lycV9iaWFzXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQgfCBJUlFfTEVWRUw7Ci0JCWlycV9kZXNjW2kraXJxX2JpYXNdLmNoaXAgPSAmd2lsZGZpcmVfaXJxX3R5cGU7CisJCWlycV90b19kZXNjKGkraXJxX2JpYXMpLT5zdGF0dXMgfD0gSVJRX0xFVkVMOworCQlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoaStpcnFfYmlhcywgJndpbGRmaXJlX2lycV90eXBlLAorCQkJaGFuZGxlX2xldmVsX2lycSk7CiAJfQogCi0JaXJxX2Rlc2NbMzYraXJxX2JpYXNdLnN0YXR1cyA9IElSUV9ESVNBQkxFRCB8IElSUV9MRVZFTDsKLQlpcnFfZGVzY1szNitpcnFfYmlhc10uY2hpcCA9ICZ3aWxkZmlyZV9pcnFfdHlwZTsKKwlpcnFfdG9fZGVzYygzNitpcnFfYmlhcyktPnN0YXR1cyB8PSBJUlFfTEVWRUw7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKDM2K2lycV9iaWFzLCAmd2lsZGZpcmVfaXJxX3R5cGUsCisJCWhhbmRsZV9sZXZlbF9pcnEpOwogCWZvciAoaSA9IDQwOyBpIDwgNjQ7ICsraSkgewotCQlpcnFfZGVzY1tpK2lycV9iaWFzXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQgfCBJUlFfTEVWRUw7Ci0JCWlycV9kZXNjW2kraXJxX2JpYXNdLmNoaXAgPSAmd2lsZGZpcmVfaXJxX3R5cGU7CisJCWlycV90b19kZXNjKGkraXJxX2JpYXMpLT5zdGF0dXMgfD0gSVJRX0xFVkVMOworCQlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoaStpcnFfYmlhcywgJndpbGRmaXJlX2lycV90eXBlLAorCQkJaGFuZGxlX2xldmVsX2lycSk7CiAJfQogCiAJc2V0dXBfaXJxKDMyK2lycV9iaWFzLCAmaXNhX2VuYWJsZSk7CQpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9saWIvTWFrZWZpbGUgYi9hcmNoL2FscGhhL2xpYi9NYWtlZmlsZQppbmRleCA5YjcyYzU5Li5jMGE4M2FiIDEwMDY0NAotLS0gYS9hcmNoL2FscGhhL2xpYi9NYWtlZmlsZQorKysgYi9hcmNoL2FscGhhL2xpYi9NYWtlZmlsZQpAQCAtMiw4ICsyLDggQEAKICMgTWFrZWZpbGUgZm9yIGFscGhhLXNwZWNpZmljIGxpYnJhcnkgZmlsZXMuLgogIwogCi1FWFRSQV9BRkxBR1MgOj0gJChLQlVJTERfQ0ZMQUdTKQotRVhUUkFfQ0ZMQUdTIDo9IC1XZXJyb3IKK2FzZmxhZ3MteSA6PSAkKEtCVUlMRF9DRkxBR1MpCitjY2ZsYWdzLXkgOj0gLVdlcnJvcgogCiAjIE1hbnkgb2YgdGhlc2Ugcm91dGluZXMgaGF2ZSBpbXBsZW1lbnRhdGlvbnMgdHVuZWQgZm9yIGV2Ni4KICMgQ2hvb3NlIHRoZW0gaWZmIHdlJ3JlIHRhcmdldGluZyBldjYgc3BlY2lmaWNhbGx5LgpkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9tYXRoLWVtdS9NYWtlZmlsZSBiL2FyY2gvYWxwaGEvbWF0aC1lbXUvTWFrZWZpbGUKaW5kZXggMzU5ZWYwOC4uN2Y0NjcxOSAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9tYXRoLWVtdS9NYWtlZmlsZQorKysgYi9hcmNoL2FscGhhL21hdGgtZW11L01ha2VmaWxlCkBAIC0yLDcgKzIsNyBAQAogIyBNYWtlZmlsZSBmb3IgdGhlIEZQVSBpbnN0cnVjdGlvbiBlbXVsYXRpb24uCiAjCiAKLUVYVFJBX0NGTEFHUyA6PSAtdworY2NmbGFncy15IDo9IC13CiAKIG9iai0kKENPTkZJR19NQVRIRU1VKSArPSBtYXRoLWVtdS5vCiAKZGlmZiAtLWdpdCBhL2FyY2gvYWxwaGEvbW0vTWFrZWZpbGUgYi9hcmNoL2FscGhhL21tL01ha2VmaWxlCmluZGV4IDA5Mzk5YzUuLmM5OTNkM2YgMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEvbW0vTWFrZWZpbGUKKysrIGIvYXJjaC9hbHBoYS9tbS9NYWtlZmlsZQpAQCAtMiw3ICsyLDcgQEAKICMgTWFrZWZpbGUgZm9yIHRoZSBsaW51eCBhbHBoYS1zcGVjaWZpYyBwYXJ0cyBvZiB0aGUgbWVtb3J5IG1hbmFnZXIuCiAjCiAKLUVYVFJBX0NGTEFHUyA6PSAtV2Vycm9yCitjY2ZsYWdzLXkgOj0gLVdlcnJvcgogCiBvYmoteQk6PSBpbml0Lm8gZmF1bHQubyBleHRhYmxlLm8KIApkaWZmIC0tZ2l0IGEvYXJjaC9hbHBoYS9vcHJvZmlsZS9NYWtlZmlsZSBiL2FyY2gvYWxwaGEvb3Byb2ZpbGUvTWFrZWZpbGUKaW5kZXggNGFhNTYyNC4uMzQ3M2RlNyAxMDA2NDQKLS0tIGEvYXJjaC9hbHBoYS9vcHJvZmlsZS9NYWtlZmlsZQorKysgYi9hcmNoL2FscGhhL29wcm9maWxlL01ha2VmaWxlCkBAIC0xLDQgKzEsNCBAQAotRVhUUkFfQ0ZMQUdTIDo9IC1XZXJyb3IgLVduby1zaWduLWNvbXBhcmUKK2NjZmxhZ3MteSA6PSAtV2Vycm9yIC1Xbm8tc2lnbi1jb21wYXJlCiAKIG9iai0kKENPTkZJR19PUFJPRklMRSkgKz0gb3Byb2ZpbGUubwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9LY29uZmlnIGIvYXJjaC9hcm0vS2NvbmZpZwppbmRleCBlMmY4MDExLi41Y2ZmMTY1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9LY29uZmlnCisrKyBiL2FyY2gvYXJtL0tjb25maWcKQEAgLTI2LDYgKzI2LDggQEAKIAlzZWxlY3QgSEFWRV9SRUdTX0FORF9TVEFDS19BQ0NFU1NfQVBJCiAJc2VsZWN0IEhBVkVfSFdfQlJFQUtQT0lOVCBpZiAoUEVSRl9FVkVOVFMgJiYgKENQVV9WNiB8fCBDUFVfVjcpKQogCXNlbGVjdCBIQVZFX0NfUkVDT1JETUNPVU5UCisJc2VsZWN0IEhBVkVfR0VORVJJQ19IQVJESVJRUworCXNlbGVjdCBIQVZFX1NQQVJTRV9JUlEKIAloZWxwCiAJICBUaGUgQVJNIHNlcmllcyBpcyBhIGxpbmUgb2YgbG93LXBvd2VyLWNvbnN1bXB0aW9uIFJJU0MgY2hpcCBkZXNpZ25zCiAJICBsaWNlbnNlZCBieSBBUk0gTHRkIGFuZCB0YXJnZXRlZCBhdCBlbWJlZGRlZCBhcHBsaWNhdGlvbnMgYW5kCkBAIC05NywxMCArOTksNiBAQAogCSAgPGZpbGU6RG9jdW1lbnRhdGlvbi9tY2EudHh0PiAoYW5kIGVzcGVjaWFsbHkgdGhlIHdlYiBwYWdlIGdpdmVuCiAJICB0aGVyZSkgYmVmb3JlIGF0dGVtcHRpbmcgdG8gYnVpbGQgYW4gTUNBIGJ1cyBrZXJuZWwuCiAKLWNvbmZpZyBHRU5FUklDX0hBUkRJUlFTCi0JYm9vbAotCWRlZmF1bHQgeQotCiBjb25maWcgU1RBQ0tUUkFDRV9TVVBQT1JUCiAJYm9vbAogCWRlZmF1bHQgeQpAQCAtMTgwLDkgKzE3OCw2IEBACiBjb25maWcgQVJDSF9NVERfWElQCiAJYm9vbAogCi1jb25maWcgR0VORVJJQ19IQVJESVJRU19OT19fRE9fSVJRCi0JZGVmX2Jvb2wgeQotCiBjb25maWcgQVJNX0wxX0NBQ0hFX1NISUZUXzYKIAlib29sCiAJaGVscApAQCAtMzY4LDcgKzM2Myw3IEBACiAJYm9vbCAiRnJlZXNjYWxlIE1YUy1iYXNlZCIKIAlzZWxlY3QgR0VORVJJQ19DTE9DS0VWRU5UUwogCXNlbGVjdCBBUkNIX1JFUVVJUkVfR1BJT0xJQgotCXNlbGVjdCBDT01NT05fQ0xLREVWCisJc2VsZWN0IENMS0RFVl9MT09LVVAKIAloZWxwCiAJICBTdXBwb3J0IGZvciBGcmVlc2NhbGUgTVhTLWJhc2VkIGZhbWlseSBvZiBwcm9jZXNzb3JzCiAKQEAgLTc3MSw2ICs3NjYsNyBAQAogCXNlbGVjdCBBUkNIX1NQQVJTRU1FTV9FTkFCTEUKIAlzZWxlY3QgR0VORVJJQ19HUElPCiAJc2VsZWN0IEhBVkVfQ0xLCisJc2VsZWN0IEFSQ0hfSEFTX0NQVUZSRVEKIAlzZWxlY3QgR0VORVJJQ19DTE9DS0VWRU5UUwogCXNlbGVjdCBIQVZFX1MzQ19SVEMgaWYgUlRDX0NMQVNTCiAJc2VsZWN0IEhBVkVfUzNDMjQxMF9JMkMgaWYgSTJDCkBAIC0xMjgxLDcgKzEyNzcsNyBAQAogY29uZmlnIFNNUF9PTl9VUAogCWJvb2wgIkFsbG93IGJvb3RpbmcgU01QIGtlcm5lbCBvbiB1bmlwcm9jZXNzb3Igc3lzdGVtcyAoRVhQRVJJTUVOVEFMKSIKIAlkZXBlbmRzIG9uIEVYUEVSSU1FTlRBTAotCWRlcGVuZHMgb24gU01QICYmICFYSVAKKwlkZXBlbmRzIG9uIFNNUCAmJiAhWElQX0tFUk5FTAogCWRlZmF1bHQgeQogCWhlbHAKIAkgIFNNUCBrZXJuZWxzIGNvbnRhaW4gaW5zdHJ1Y3Rpb25zIHdoaWNoIGZhaWwgb24gbm9uLVNNUCBwcm9jZXNzb3JzLgpAQCAtMTQ1MiwxNSArMTQ0OCw2IEBACiAJICBFbmFibGUgaGFyZHdhcmUgcGVyZm9ybWFuY2UgY291bnRlciBzdXBwb3J0IGZvciBwZXJmIGV2ZW50cy4gSWYKIAkgIGRpc2FibGVkLCBwZXJmIGV2ZW50cyB3aWxsIHVzZSBzb2Z0d2FyZSBldmVudHMgb25seS4KIAotY29uZmlnIFNQQVJTRV9JUlEKLQlkZWZfYm9vbCBuCi0JaGVscAotCSAgVGhpcyBlbmFibGVzIHN1cHBvcnQgZm9yIHNwYXJzZSBpcnFzLiBUaGlzIGlzIHVzZWZ1bCBpbiBnZW5lcmFsCi0JICBhcyBtb3N0IENQVXMgaGF2ZSBhIGZhaXJseSBzcGFyc2UgYXJyYXkgb2YgSVJRIHZlY3RvcnMsIHdoaWNoCi0JICB0aGUgaXJxX2Rlc2MgdGhlbiBtYXBzIGRpcmVjdGx5IG9uIHRvLiBTeXN0ZW1zIHdpdGggYSBoaWdoCi0JICBudW1iZXIgb2Ygb2ZmLWNoaXAgSVJRcyB3aWxsIHdhbnQgdG8gdHJlYXQgdGhpcyBhcwotCSAgZXhwZXJpbWVudGFsIHVudGlsIHRoZXkgaGF2ZSBiZWVuIGluZGVwZW5kZW50bHkgdmVyaWZpZWQuCi0KIHNvdXJjZSAibW0vS2NvbmZpZyIKIAogY29uZmlnIEZPUkNFX01BWF9aT05FT1JERVIKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbW1vbi9naWMuYyBiL2FyY2gvYXJtL2NvbW1vbi9naWMuYwppbmRleCAwYjg5ZWYwLi4yMjQzNzcyIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb21tb24vZ2ljLmMKKysrIGIvYXJjaC9hcm0vY29tbW9uL2dpYy5jCkBAIC01MCw1NyArNTAsNTYgQEAKIAogc3RhdGljIHN0cnVjdCBnaWNfY2hpcF9kYXRhIGdpY19kYXRhW01BWF9HSUNfTlJdIF9fcmVhZF9tb3N0bHk7CiAKLXN0YXRpYyBpbmxpbmUgdm9pZCBfX2lvbWVtICpnaWNfZGlzdF9iYXNlKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgaW5saW5lIHZvaWQgX19pb21lbSAqZ2ljX2Rpc3RfYmFzZShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jc3RydWN0IGdpY19jaGlwX2RhdGEgKmdpY19kYXRhID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgZ2ljX2NoaXBfZGF0YSAqZ2ljX2RhdGEgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKIAlyZXR1cm4gZ2ljX2RhdGEtPmRpc3RfYmFzZTsKIH0KIAotc3RhdGljIGlubGluZSB2b2lkIF9faW9tZW0gKmdpY19jcHVfYmFzZSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIGlubGluZSB2b2lkIF9faW9tZW0gKmdpY19jcHVfYmFzZShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jc3RydWN0IGdpY19jaGlwX2RhdGEgKmdpY19kYXRhID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgZ2ljX2NoaXBfZGF0YSAqZ2ljX2RhdGEgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKIAlyZXR1cm4gZ2ljX2RhdGEtPmNwdV9iYXNlOwogfQogCi1zdGF0aWMgaW5saW5lIHVuc2lnbmVkIGludCBnaWNfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGludCBnaWNfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlzdHJ1Y3QgZ2ljX2NoaXBfZGF0YSAqZ2ljX2RhdGEgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOwotCXJldHVybiBpcnEgLSBnaWNfZGF0YS0+aXJxX29mZnNldDsKKwlzdHJ1Y3QgZ2ljX2NoaXBfZGF0YSAqZ2ljX2RhdGEgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKKwlyZXR1cm4gZC0+aXJxIC0gZ2ljX2RhdGEtPmlycV9vZmZzZXQ7CiB9CiAKIC8qCiAgKiBSb3V0aW5lcyB0byBhY2tub3dsZWRnZSwgZGlzYWJsZSBhbmQgZW5hYmxlIGludGVycnVwdHMKICAqLwotc3RhdGljIHZvaWQgZ2ljX2Fja19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGdpY19hY2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQogCXNwaW5fbG9jaygmaXJxX2NvbnRyb2xsZXJfbG9jayk7Ci0Jd3JpdGVsKGdpY19pcnEoaXJxKSwgZ2ljX2NwdV9iYXNlKGlycSkgKyBHSUNfQ1BVX0VPSSk7CisJd3JpdGVsKGdpY19pcnEoZCksIGdpY19jcHVfYmFzZShkKSArIEdJQ19DUFVfRU9JKTsKIAlzcGluX3VubG9jaygmaXJxX2NvbnRyb2xsZXJfbG9jayk7CiB9CiAKLXN0YXRpYyB2b2lkIGdpY19tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgZ2ljX21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl1MzIgbWFzayA9IDEgPDwgKGlycSAlIDMyKTsKKwl1MzIgbWFzayA9IDEgPDwgKGQtPmlycSAlIDMyKTsKIAogCXNwaW5fbG9jaygmaXJxX2NvbnRyb2xsZXJfbG9jayk7Ci0Jd3JpdGVsKG1hc2ssIGdpY19kaXN0X2Jhc2UoaXJxKSArIEdJQ19ESVNUX0VOQUJMRV9DTEVBUiArIChnaWNfaXJxKGlycSkgLyAzMikgKiA0KTsKKwl3cml0ZWwobWFzaywgZ2ljX2Rpc3RfYmFzZShkKSArIEdJQ19ESVNUX0VOQUJMRV9DTEVBUiArIChnaWNfaXJxKGQpIC8gMzIpICogNCk7CiAJc3Bpbl91bmxvY2soJmlycV9jb250cm9sbGVyX2xvY2spOwogfQogCi1zdGF0aWMgdm9pZCBnaWNfdW5tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgZ2ljX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXUzMiBtYXNrID0gMSA8PCAoaXJxICUgMzIpOworCXUzMiBtYXNrID0gMSA8PCAoZC0+aXJxICUgMzIpOwogCiAJc3Bpbl9sb2NrKCZpcnFfY29udHJvbGxlcl9sb2NrKTsKLQl3cml0ZWwobWFzaywgZ2ljX2Rpc3RfYmFzZShpcnEpICsgR0lDX0RJU1RfRU5BQkxFX1NFVCArIChnaWNfaXJxKGlycSkgLyAzMikgKiA0KTsKKwl3cml0ZWwobWFzaywgZ2ljX2Rpc3RfYmFzZShkKSArIEdJQ19ESVNUX0VOQUJMRV9TRVQgKyAoZ2ljX2lycShkKSAvIDMyKSAqIDQpOwogCXNwaW5fdW5sb2NrKCZpcnFfY29udHJvbGxlcl9sb2NrKTsKIH0KIAotc3RhdGljIGludCBnaWNfc2V0X3R5cGUodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IHR5cGUpCitzdGF0aWMgaW50IGdpY19zZXRfdHlwZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCB0eXBlKQogewotCXZvaWQgX19pb21lbSAqYmFzZSA9IGdpY19kaXN0X2Jhc2UoaXJxKTsKLQl1bnNpZ25lZCBpbnQgZ2ljaXJxID0gZ2ljX2lycShpcnEpOworCXZvaWQgX19pb21lbSAqYmFzZSA9IGdpY19kaXN0X2Jhc2UoZCk7CisJdW5zaWduZWQgaW50IGdpY2lycSA9IGdpY19pcnEoZCk7CiAJdTMyIGVuYWJsZW1hc2sgPSAxIDw8IChnaWNpcnEgJSAzMik7CiAJdTMyIGVuYWJsZW9mZiA9IChnaWNpcnEgLyAzMikgKiA0OwogCXUzMiBjb25mbWFzayA9IDB4MiA8PCAoKGdpY2lycSAlIDE2KSAqIDIpOwpAQCAtMTQzLDIxICsxNDIsMjIgQEAKIH0KIAogI2lmZGVmIENPTkZJR19TTVAKLXN0YXRpYyBpbnQgZ2ljX3NldF9jcHUodW5zaWduZWQgaW50IGlycSwgY29uc3Qgc3RydWN0IGNwdW1hc2sgKm1hc2tfdmFsKQorc3RhdGljIGludAorZ2ljX3NldF9jcHUoc3RydWN0IGlycV9kYXRhICpkLCBjb25zdCBzdHJ1Y3QgY3B1bWFzayAqbWFza192YWwsIGJvb2wgZm9yY2UpCiB7Ci0Jdm9pZCBfX2lvbWVtICpyZWcgPSBnaWNfZGlzdF9iYXNlKGlycSkgKyBHSUNfRElTVF9UQVJHRVQgKyAoZ2ljX2lycShpcnEpICYgfjMpOwotCXVuc2lnbmVkIGludCBzaGlmdCA9IChpcnEgJSA0KSAqIDg7CisJdm9pZCBfX2lvbWVtICpyZWcgPSBnaWNfZGlzdF9iYXNlKGQpICsgR0lDX0RJU1RfVEFSR0VUICsgKGdpY19pcnEoZCkgJiB+Myk7CisJdW5zaWduZWQgaW50IHNoaWZ0ID0gKGQtPmlycSAlIDQpICogODsKIAl1bnNpZ25lZCBpbnQgY3B1ID0gY3B1bWFza19maXJzdChtYXNrX3ZhbCk7CiAJdTMyIHZhbDsKIAlzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2M7CiAKIAlzcGluX2xvY2soJmlycV9jb250cm9sbGVyX2xvY2spOwotCWRlc2MgPSBpcnFfdG9fZGVzYyhpcnEpOworCWRlc2MgPSBpcnFfdG9fZGVzYyhkLT5pcnEpOwogCWlmIChkZXNjID09IE5VTEwpIHsKIAkJc3Bpbl91bmxvY2soJmlycV9jb250cm9sbGVyX2xvY2spOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9Ci0JZGVzYy0+bm9kZSA9IGNwdTsKKwlkLT5ub2RlID0gY3B1OwogCXZhbCA9IHJlYWRsKHJlZykgJiB+KDB4ZmYgPDwgc2hpZnQpOwogCXZhbCB8PSAxIDw8IChjcHUgKyBzaGlmdCk7CiAJd3JpdGVsKHZhbCwgcmVnKTsKQEAgLTE3NSw3ICsxNzUsNyBAQAogCXVuc2lnbmVkIGxvbmcgc3RhdHVzOwogCiAJLyogcHJpbWFyeSBjb250cm9sbGVyIGFjaydpbmcgKi8KLQljaGlwLT5hY2soaXJxKTsKKwljaGlwLT5pcnFfYWNrKCZkZXNjLT5pcnFfZGF0YSk7CiAKIAlzcGluX2xvY2soJmlycV9jb250cm9sbGVyX2xvY2spOwogCXN0YXR1cyA9IHJlYWRsKGNoaXBfZGF0YS0+Y3B1X2Jhc2UgKyBHSUNfQ1BVX0lOVEFDSyk7CkBAIC0xOTMsMTcgKzE5MywxNyBAQAogCiAgb3V0OgogCS8qIHByaW1hcnkgY29udHJvbGxlciB1bm1hc2tpbmcgKi8KLQljaGlwLT51bm1hc2soaXJxKTsKKwljaGlwLT5pcnFfdW5tYXNrKCZkZXNjLT5pcnFfZGF0YSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgZ2ljX2NoaXAgPSB7Ci0JLm5hbWUJCT0gIkdJQyIsCi0JLmFjawkJPSBnaWNfYWNrX2lycSwKLQkubWFzawkJPSBnaWNfbWFza19pcnEsCi0JLnVubWFzawkJPSBnaWNfdW5tYXNrX2lycSwKLQkuc2V0X3R5cGUJPSBnaWNfc2V0X3R5cGUsCisJLm5hbWUJCQk9ICJHSUMiLAorCS5pcnFfYWNrCQk9IGdpY19hY2tfaXJxLAorCS5pcnFfbWFzawkJPSBnaWNfbWFza19pcnEsCisJLmlycV91bm1hc2sJCT0gZ2ljX3VubWFza19pcnEsCisJLmlycV9zZXRfdHlwZQkJPSBnaWNfc2V0X3R5cGUsCiAjaWZkZWYgQ09ORklHX1NNUAotCS5zZXRfYWZmaW5pdHkJPSBnaWNfc2V0X2NwdSwKKwkuaXJxX3NldF9hZmZpbml0eQk9IGdpY19zZXRfY3B1LAogI2VuZGlmCiB9OwogCkBAIC0zMzcsNyArMzM3LDcgQEAKIAogCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKIAlpcnFfdG9fZGVzYyhpcnEpLT5zdGF0dXMgfD0gSVJRX05PUFJPQkU7Ci0JZ2ljX3VubWFza19pcnEoaXJxKTsKKwlnaWNfdW5tYXNrX2lycShpcnFfZ2V0X2lycV9kYXRhKGlycSkpOwogCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKIH0KIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29tbW9uL2l0ODE1Mi5jIGIvYXJjaC9hcm0vY29tbW9uL2l0ODE1Mi5jCmluZGV4IDY2NWViZjcuLmZjZGRkNDggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbW1vbi9pdDgxNTIuYworKysgYi9hcmNoL2FybS9jb21tb24vaXQ4MTUyLmMKQEAgLTMxLDggKzMxLDEwIEBACiAKICNkZWZpbmUgTUFYX1NMT1RTCQkyMQogCi1zdGF0aWMgdm9pZCBpdDgxNTJfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGl0ODE1Ml9tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CisJdW5zaWduZWQgaW50IGlycSA9IGQtPmlycTsKKwogICAgICAgIGlmIChpcnEgPj0gSVQ4MTUyX0xEX0lSUSgwKSkgewogCSAgICAgICBfX3Jhd193cml0ZWwoKF9fcmF3X3JlYWRsKElUODE1Ml9JTlRDX0xEQ05JTVIpIHwKIAkJCSAgICAoMSA8PCAoaXJxIC0gSVQ4MTUyX0xEX0lSUSgwKSkpKSwKQEAgLTQ4LDggKzUwLDEwIEBACiAgICAgICAgfQogfQogCi1zdGF0aWMgdm9pZCBpdDgxNTJfdW5tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaXQ4MTUyX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogeworCXVuc2lnbmVkIGludCBpcnEgPSBkLT5pcnE7CisKICAgICAgICBpZiAoaXJxID49IElUODE1Ml9MRF9JUlEoMCkpIHsKIAkgICAgICAgX19yYXdfd3JpdGVsKChfX3Jhd19yZWFkbChJVDgxNTJfSU5UQ19MRENOSU1SKSAmCiAJCQkgICAgIH4oMSA8PCAoaXJxIC0gSVQ4MTUyX0xEX0lSUSgwKSkpKSwKQEAgLTY3LDkgKzcxLDkgQEAKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBpdDgxNTJfaXJxX2NoaXAgPSB7CiAJLm5hbWUJCT0gIml0ODE1MiIsCi0JLmFjawkJPSBpdDgxNTJfbWFza19pcnEsCi0JLm1hc2sJCT0gaXQ4MTUyX21hc2tfaXJxLAotCS51bm1hc2sJCT0gaXQ4MTUyX3VubWFza19pcnEsCisJLmlycV9hY2sJPSBpdDgxNTJfbWFza19pcnEsCisJLmlycV9tYXNrCT0gaXQ4MTUyX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gaXQ4MTUyX3VubWFza19pcnEsCiB9OwogCiB2b2lkIGl0ODE1Ml9pbml0X2lycSh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29tbW9uL2xvY29tby5jIGIvYXJjaC9hcm0vY29tbW9uL2xvY29tby5jCmluZGV4IDlkZmYwN2MuLmEwMjZhNmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbW1vbi9sb2NvbW8uYworKysgYi9hcmNoL2FybS9jb21tb24vbG9jb21vLmMKQEAgLTE0NCw3ICsxNDQsNyBAQAogCWludCByZXEsIGk7CiAKIAkvKiBBY2tub3dsZWRnZSB0aGUgcGFyZW50IElSUSAqLwotCWRlc2MtPmNoaXAtPmFjayhpcnEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9hY2soJmRlc2MtPmlycV9kYXRhKTsKIAogCS8qIGNoZWNrIHdoeSB0aGlzIGludGVycnVwdCB3YXMgZ2VuZXJhdGVkICovCiAJcmVxID0gbG9jb21vX3JlYWRsKGxjaGlwLT5iYXNlICsgTE9DT01PX0lDUikgJiAweDBmMDA7CkBAIC0xNjEsMzMgKzE2MSwzMyBAQAogCX0KIH0KIAotc3RhdGljIHZvaWQgbG9jb21vX2Fja19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGxvY29tb19hY2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIH0KIAotc3RhdGljIHZvaWQgbG9jb21vX21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBsb2NvbW9fbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXN0cnVjdCBsb2NvbW8gKmxjaGlwID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgbG9jb21vICpsY2hpcCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOwogCXVuc2lnbmVkIGludCByOwogCXIgPSBsb2NvbW9fcmVhZGwobGNoaXAtPmJhc2UgKyBMT0NPTU9fSUNSKTsKLQlyICY9IH4oMHgwMDEwIDw8IChpcnEgLSBsY2hpcC0+aXJxX2Jhc2UpKTsKKwlyICY9IH4oMHgwMDEwIDw8IChkLT5pcnEgLSBsY2hpcC0+aXJxX2Jhc2UpKTsKIAlsb2NvbW9fd3JpdGVsKHIsIGxjaGlwLT5iYXNlICsgTE9DT01PX0lDUik7CiB9CiAKLXN0YXRpYyB2b2lkIGxvY29tb191bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBsb2NvbW9fdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jc3RydWN0IGxvY29tbyAqbGNoaXAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBsb2NvbW8gKmxjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZCk7CiAJdW5zaWduZWQgaW50IHI7CiAJciA9IGxvY29tb19yZWFkbChsY2hpcC0+YmFzZSArIExPQ09NT19JQ1IpOwotCXIgfD0gKDB4MDAxMCA8PCAoaXJxIC0gbGNoaXAtPmlycV9iYXNlKSk7CisJciB8PSAoMHgwMDEwIDw8IChkLT5pcnEgLSBsY2hpcC0+aXJxX2Jhc2UpKTsKIAlsb2NvbW9fd3JpdGVsKHIsIGxjaGlwLT5iYXNlICsgTE9DT01PX0lDUik7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbG9jb21vX2NoaXAgPSB7Ci0JLm5hbWUJPSAiTE9DT01PIiwKLQkuYWNrCT0gbG9jb21vX2Fja19pcnEsCi0JLm1hc2sJPSBsb2NvbW9fbWFza19pcnEsCi0JLnVubWFzawk9IGxvY29tb191bm1hc2tfaXJxLAorCS5uYW1lCQk9ICJMT0NPTU8iLAorCS5pcnFfYWNrCT0gbG9jb21vX2Fja19pcnEsCisJLmlycV9tYXNrCT0gbG9jb21vX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gbG9jb21vX3VubWFza19pcnEsCiB9OwogCiBzdGF0aWMgdm9pZCBsb2NvbW9fc2V0dXBfaXJxKHN0cnVjdCBsb2NvbW8gKmxjaGlwKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29tbW9uL3NhMTExMS5jIGIvYXJjaC9hcm0vY29tbW9uL3NhMTExMS5jCmluZGV4IGMwMjU4YTguLmViOTc5NmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbW1vbi9zYTExMTEuYworKysgYi9hcmNoL2FybS9jb21tb24vc2ExMTExLmMKQEAgLTIxMCw3ICsyMTAsNyBAQAogCiAJc2ExMTExX3dyaXRlbChzdGF0MCwgbWFwYmFzZSArIFNBMTExMV9JTlRTVEFUQ0xSMCk7CiAKLQlkZXNjLT5jaGlwLT5hY2soaXJxKTsKKwlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfYWNrKCZkZXNjLT5pcnFfZGF0YSk7CiAKIAlzYTExMTFfd3JpdGVsKHN0YXQxLCBtYXBiYXNlICsgU0ExMTExX0lOVFNUQVRDTFIxKTsKIApAQCAtMjI4LDM1ICsyMjgsMzUgQEAKIAkJCWdlbmVyaWNfaGFuZGxlX2lycShpICsgc2FjaGlwLT5pcnFfYmFzZSk7CiAKIAkvKiBGb3IgbGV2ZWwtYmFzZWQgaW50ZXJydXB0cyAqLwotCWRlc2MtPmNoaXAtPnVubWFzayhpcnEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV91bm1hc2soJmRlc2MtPmlycV9kYXRhKTsKIH0KIAogI2RlZmluZSBTQTExMTFfSVJRTUFTS19MTyh4KQkoMSA8PCAoeCAtIHNhY2hpcC0+aXJxX2Jhc2UpKQogI2RlZmluZSBTQTExMTFfSVJRTUFTS19ISSh4KQkoMSA8PCAoeCAtIHNhY2hpcC0+aXJxX2Jhc2UgLSAzMikpCiAKLXN0YXRpYyB2b2lkIHNhMTExMV9hY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzYTExMTFfYWNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiB9CiAKLXN0YXRpYyB2b2lkIHNhMTExMV9tYXNrX2xvd2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc2ExMTExX21hc2tfbG93aXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlzdHJ1Y3Qgc2ExMTExICpzYWNoaXAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBzYTExMTEgKnNhY2hpcCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOwogCXZvaWQgX19pb21lbSAqbWFwYmFzZSA9IHNhY2hpcC0+YmFzZSArIFNBMTExMV9JTlRDOwogCXVuc2lnbmVkIGxvbmcgaWUwOwogCiAJaWUwID0gc2ExMTExX3JlYWRsKG1hcGJhc2UgKyBTQTExMTFfSU5URU4wKTsKLQlpZTAgJj0gflNBMTExMV9JUlFNQVNLX0xPKGlycSk7CisJaWUwICY9IH5TQTExMTFfSVJRTUFTS19MTyhkLT5pcnEpOwogCXdyaXRlbChpZTAsIG1hcGJhc2UgKyBTQTExMTFfSU5URU4wKTsKIH0KIAotc3RhdGljIHZvaWQgc2ExMTExX3VubWFza19sb3dpcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHNhMTExMV91bm1hc2tfbG93aXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlzdHJ1Y3Qgc2ExMTExICpzYWNoaXAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBzYTExMTEgKnNhY2hpcCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOwogCXZvaWQgX19pb21lbSAqbWFwYmFzZSA9IHNhY2hpcC0+YmFzZSArIFNBMTExMV9JTlRDOwogCXVuc2lnbmVkIGxvbmcgaWUwOwogCiAJaWUwID0gc2ExMTExX3JlYWRsKG1hcGJhc2UgKyBTQTExMTFfSU5URU4wKTsKLQlpZTAgfD0gU0ExMTExX0lSUU1BU0tfTE8oaXJxKTsKKwlpZTAgfD0gU0ExMTExX0lSUU1BU0tfTE8oZC0+aXJxKTsKIAlzYTExMTFfd3JpdGVsKGllMCwgbWFwYmFzZSArIFNBMTExMV9JTlRFTjApOwogfQogCkBAIC0yNjcsMTEgKzI2NywxMSBAQAogICogYmUgdHJpZ2dlcmVkLiAgSW4gZmFjdCwgaXRzIHZlcnkgZGlmZmljdWx0LCBpZiBub3QgaW1wb3NzaWJsZSB0byBnZXQKICAqIElOVFNFVCB0byByZS10cmlnZ2VyIHRoZSBpbnRlcnJ1cHQuCiAgKi8KLXN0YXRpYyBpbnQgc2ExMTExX3JldHJpZ2dlcl9sb3dpcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyBpbnQgc2ExMTExX3JldHJpZ2dlcl9sb3dpcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXN0cnVjdCBzYTExMTEgKnNhY2hpcCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IHNhMTExMSAqc2FjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZCk7CiAJdm9pZCBfX2lvbWVtICptYXBiYXNlID0gc2FjaGlwLT5iYXNlICsgU0ExMTExX0lOVEM7Ci0JdW5zaWduZWQgaW50IG1hc2sgPSBTQTExMTFfSVJRTUFTS19MTyhpcnEpOworCXVuc2lnbmVkIGludCBtYXNrID0gU0ExMTExX0lSUU1BU0tfTE8oZC0+aXJxKTsKIAl1bnNpZ25lZCBsb25nIGlwMDsKIAlpbnQgaTsKIApAQCAtMjc5LDIxICsyNzksMjEgQEAKIAlmb3IgKGkgPSAwOyBpIDwgODsgaSsrKSB7CiAJCXNhMTExMV93cml0ZWwoaXAwIF4gbWFzaywgbWFwYmFzZSArIFNBMTExMV9JTlRQT0wwKTsKIAkJc2ExMTExX3dyaXRlbChpcDAsIG1hcGJhc2UgKyBTQTExMTFfSU5UUE9MMCk7Ci0JCWlmIChzYTExMTFfcmVhZGwobWFwYmFzZSArIFNBMTExMV9JTlRTVEFUQ0xSMSkgJiBtYXNrKQorCQlpZiAoc2ExMTExX3JlYWRsKG1hcGJhc2UgKyBTQTExMTFfSU5UU1RBVENMUjApICYgbWFzaykKIAkJCWJyZWFrOwogCX0KIAogCWlmIChpID09IDgpCiAJCXByaW50ayhLRVJOX0VSUiAiRGFuZ2VyIFdpbGwgUm9iaW5zb246IGZhaWxlZCB0byAiCi0JCQkicmUtdHJpZ2dlciBJUlElZFxuIiwgaXJxKTsKKwkJCSJyZS10cmlnZ2VyIElSUSVkXG4iLCBkLT5pcnEpOwogCXJldHVybiBpID09IDggPyAtMSA6IDA7CiB9CiAKLXN0YXRpYyBpbnQgc2ExMTExX3R5cGVfbG93aXJxKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCBmbGFncykKK3N0YXRpYyBpbnQgc2ExMTExX3R5cGVfbG93aXJxKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IGZsYWdzKQogewotCXN0cnVjdCBzYTExMTEgKnNhY2hpcCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IHNhMTExMSAqc2FjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZCk7CiAJdm9pZCBfX2lvbWVtICptYXBiYXNlID0gc2FjaGlwLT5iYXNlICsgU0ExMTExX0lOVEM7Ci0JdW5zaWduZWQgaW50IG1hc2sgPSBTQTExMTFfSVJRTUFTS19MTyhpcnEpOworCXVuc2lnbmVkIGludCBtYXNrID0gU0ExMTExX0lSUU1BU0tfTE8oZC0+aXJxKTsKIAl1bnNpZ25lZCBsb25nIGlwMDsKIAogCWlmIChmbGFncyA9PSBJUlFfVFlQRV9QUk9CRSkKQEAgLTMxMywxMSArMzEzLDExIEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgc2ExMTExX3dha2VfbG93aXJxKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCBvbikKK3N0YXRpYyBpbnQgc2ExMTExX3dha2VfbG93aXJxKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IG9uKQogewotCXN0cnVjdCBzYTExMTEgKnNhY2hpcCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IHNhMTExMSAqc2FjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZCk7CiAJdm9pZCBfX2lvbWVtICptYXBiYXNlID0gc2FjaGlwLT5iYXNlICsgU0ExMTExX0lOVEM7Ci0JdW5zaWduZWQgaW50IG1hc2sgPSBTQTExMTFfSVJRTUFTS19MTyhpcnEpOworCXVuc2lnbmVkIGludCBtYXNrID0gU0ExMTExX0lSUU1BU0tfTE8oZC0+aXJxKTsKIAl1bnNpZ25lZCBsb25nIHdlMDsKIAogCXdlMCA9IHNhMTExMV9yZWFkbChtYXBiYXNlICsgU0ExMTExX1dBS0VFTjApOwpAQCAtMzMyLDMzICszMzIsMzMgQEAKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzYTExMTFfbG93X2NoaXAgPSB7CiAJLm5hbWUJCT0gIlNBMTExMS1sIiwKLQkuYWNrCQk9IHNhMTExMV9hY2tfaXJxLAotCS5tYXNrCQk9IHNhMTExMV9tYXNrX2xvd2lycSwKLQkudW5tYXNrCQk9IHNhMTExMV91bm1hc2tfbG93aXJxLAotCS5yZXRyaWdnZXIJPSBzYTExMTFfcmV0cmlnZ2VyX2xvd2lycSwKLQkuc2V0X3R5cGUJPSBzYTExMTFfdHlwZV9sb3dpcnEsCi0JLnNldF93YWtlCT0gc2ExMTExX3dha2VfbG93aXJxLAorCS5pcnFfYWNrCT0gc2ExMTExX2Fja19pcnEsCisJLmlycV9tYXNrCT0gc2ExMTExX21hc2tfbG93aXJxLAorCS5pcnFfdW5tYXNrCT0gc2ExMTExX3VubWFza19sb3dpcnEsCisJLmlycV9yZXRyaWdnZXIJPSBzYTExMTFfcmV0cmlnZ2VyX2xvd2lycSwKKwkuaXJxX3NldF90eXBlCT0gc2ExMTExX3R5cGVfbG93aXJxLAorCS5pcnFfc2V0X3dha2UJPSBzYTExMTFfd2FrZV9sb3dpcnEsCiB9OwogCi1zdGF0aWMgdm9pZCBzYTExMTFfbWFza19oaWdoaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzYTExMTFfbWFza19oaWdoaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlzdHJ1Y3Qgc2ExMTExICpzYWNoaXAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBzYTExMTEgKnNhY2hpcCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOwogCXZvaWQgX19pb21lbSAqbWFwYmFzZSA9IHNhY2hpcC0+YmFzZSArIFNBMTExMV9JTlRDOwogCXVuc2lnbmVkIGxvbmcgaWUxOwogCiAJaWUxID0gc2ExMTExX3JlYWRsKG1hcGJhc2UgKyBTQTExMTFfSU5URU4xKTsKLQlpZTEgJj0gflNBMTExMV9JUlFNQVNLX0hJKGlycSk7CisJaWUxICY9IH5TQTExMTFfSVJRTUFTS19ISShkLT5pcnEpOwogCXNhMTExMV93cml0ZWwoaWUxLCBtYXBiYXNlICsgU0ExMTExX0lOVEVOMSk7CiB9CiAKLXN0YXRpYyB2b2lkIHNhMTExMV91bm1hc2tfaGlnaGlycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc2ExMTExX3VubWFza19oaWdoaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlzdHJ1Y3Qgc2ExMTExICpzYWNoaXAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBzYTExMTEgKnNhY2hpcCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOwogCXZvaWQgX19pb21lbSAqbWFwYmFzZSA9IHNhY2hpcC0+YmFzZSArIFNBMTExMV9JTlRDOwogCXVuc2lnbmVkIGxvbmcgaWUxOwogCiAJaWUxID0gc2ExMTExX3JlYWRsKG1hcGJhc2UgKyBTQTExMTFfSU5URU4xKTsKLQlpZTEgfD0gU0ExMTExX0lSUU1BU0tfSEkoaXJxKTsKKwlpZTEgfD0gU0ExMTExX0lSUU1BU0tfSEkoZC0+aXJxKTsKIAlzYTExMTFfd3JpdGVsKGllMSwgbWFwYmFzZSArIFNBMTExMV9JTlRFTjEpOwogfQogCkBAIC0zNjksMTEgKzM2OSwxMSBAQAogICogYmUgdHJpZ2dlcmVkLiAgSW4gZmFjdCwgaXRzIHZlcnkgZGlmZmljdWx0LCBpZiBub3QgaW1wb3NzaWJsZSB0byBnZXQKICAqIElOVFNFVCB0byByZS10cmlnZ2VyIHRoZSBpbnRlcnJ1cHQuCiAgKi8KLXN0YXRpYyBpbnQgc2ExMTExX3JldHJpZ2dlcl9oaWdoaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgaW50IHNhMTExMV9yZXRyaWdnZXJfaGlnaGlycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jc3RydWN0IHNhMTExMSAqc2FjaGlwID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3Qgc2ExMTExICpzYWNoaXAgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKIAl2b2lkIF9faW9tZW0gKm1hcGJhc2UgPSBzYWNoaXAtPmJhc2UgKyBTQTExMTFfSU5UQzsKLQl1bnNpZ25lZCBpbnQgbWFzayA9IFNBMTExMV9JUlFNQVNLX0hJKGlycSk7CisJdW5zaWduZWQgaW50IG1hc2sgPSBTQTExMTFfSVJRTUFTS19ISShkLT5pcnEpOwogCXVuc2lnbmVkIGxvbmcgaXAxOwogCWludCBpOwogCkBAIC0zODcsMTUgKzM4NywxNSBAQAogCiAJaWYgKGkgPT0gOCkKIAkJcHJpbnRrKEtFUk5fRVJSICJEYW5nZXIgV2lsbCBSb2JpbnNvbjogZmFpbGVkIHRvICIKLQkJCSJyZS10cmlnZ2VyIElSUSVkXG4iLCBpcnEpOworCQkJInJlLXRyaWdnZXIgSVJRJWRcbiIsIGQtPmlycSk7CiAJcmV0dXJuIGkgPT0gOCA/IC0xIDogMDsKIH0KIAotc3RhdGljIGludCBzYTExMTFfdHlwZV9oaWdoaXJxKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCBmbGFncykKK3N0YXRpYyBpbnQgc2ExMTExX3R5cGVfaGlnaGlycShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCBmbGFncykKIHsKLQlzdHJ1Y3Qgc2ExMTExICpzYWNoaXAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBzYTExMTEgKnNhY2hpcCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOwogCXZvaWQgX19pb21lbSAqbWFwYmFzZSA9IHNhY2hpcC0+YmFzZSArIFNBMTExMV9JTlRDOwotCXVuc2lnbmVkIGludCBtYXNrID0gU0ExMTExX0lSUU1BU0tfSEkoaXJxKTsKKwl1bnNpZ25lZCBpbnQgbWFzayA9IFNBMTExMV9JUlFNQVNLX0hJKGQtPmlycSk7CiAJdW5zaWduZWQgbG9uZyBpcDE7CiAKIAlpZiAoZmxhZ3MgPT0gSVJRX1RZUEVfUFJPQkUpCkBAIC00MTUsMTEgKzQxNSwxMSBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IHNhMTExMV93YWtlX2hpZ2hpcnEodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IG9uKQorc3RhdGljIGludCBzYTExMTFfd2FrZV9oaWdoaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IG9uKQogewotCXN0cnVjdCBzYTExMTEgKnNhY2hpcCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IHNhMTExMSAqc2FjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZCk7CiAJdm9pZCBfX2lvbWVtICptYXBiYXNlID0gc2FjaGlwLT5iYXNlICsgU0ExMTExX0lOVEM7Ci0JdW5zaWduZWQgaW50IG1hc2sgPSBTQTExMTFfSVJRTUFTS19ISShpcnEpOworCXVuc2lnbmVkIGludCBtYXNrID0gU0ExMTExX0lSUU1BU0tfSEkoZC0+aXJxKTsKIAl1bnNpZ25lZCBsb25nIHdlMTsKIAogCXdlMSA9IHNhMTExMV9yZWFkbChtYXBiYXNlICsgU0ExMTExX1dBS0VFTjEpOwpAQCAtNDM0LDEyICs0MzQsMTIgQEAKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzYTExMTFfaGlnaF9jaGlwID0gewogCS5uYW1lCQk9ICJTQTExMTEtaCIsCi0JLmFjawkJPSBzYTExMTFfYWNrX2lycSwKLQkubWFzawkJPSBzYTExMTFfbWFza19oaWdoaXJxLAotCS51bm1hc2sJCT0gc2ExMTExX3VubWFza19oaWdoaXJxLAotCS5yZXRyaWdnZXIJPSBzYTExMTFfcmV0cmlnZ2VyX2hpZ2hpcnEsCi0JLnNldF90eXBlCT0gc2ExMTExX3R5cGVfaGlnaGlycSwKLQkuc2V0X3dha2UJPSBzYTExMTFfd2FrZV9oaWdoaXJxLAorCS5pcnFfYWNrCT0gc2ExMTExX2Fja19pcnEsCisJLmlycV9tYXNrCT0gc2ExMTExX21hc2tfaGlnaGlycSwKKwkuaXJxX3VubWFzawk9IHNhMTExMV91bm1hc2tfaGlnaGlycSwKKwkuaXJxX3JldHJpZ2dlcgk9IHNhMTExMV9yZXRyaWdnZXJfaGlnaGlycSwKKwkuaXJxX3NldF90eXBlCT0gc2ExMTExX3R5cGVfaGlnaGlycSwKKwkuaXJxX3NldF93YWtlCT0gc2ExMTExX3dha2VfaGlnaGlycSwKIH07CiAKIHN0YXRpYyB2b2lkIHNhMTExMV9zZXR1cF9pcnEoc3RydWN0IHNhMTExMSAqc2FjaGlwKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29tbW9uL3ZpYy5jIGIvYXJjaC9hcm0vY29tbW9uL3ZpYy5jCmluZGV4IGNiNjYwYmMuLmFlNWZlNzIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbW1vbi92aWMuYworKysgYi9hcmNoL2FybS9jb21tb24vdmljLmMKQEAgLTIwNCwyNiArMjA0LDI2IEBACiBzdGF0aWMgaW5saW5lIHZvaWQgdmljX3BtX3JlZ2lzdGVyKHZvaWQgX19pb21lbSAqYmFzZSwgdW5zaWduZWQgaW50IGlycSwgdTMyIGFyZzEpIHsgfQogI2VuZGlmIC8qIENPTkZJR19QTSAqLwogCi1zdGF0aWMgdm9pZCB2aWNfYWNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgdmljX2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXZvaWQgX19pb21lbSAqYmFzZSA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7Ci0JaXJxICY9IDMxOworCXZvaWQgX19pb21lbSAqYmFzZSA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOworCXVuc2lnbmVkIGludCBpcnEgPSBkLT5pcnEgJiAzMTsKIAl3cml0ZWwoMSA8PCBpcnEsIGJhc2UgKyBWSUNfSU5UX0VOQUJMRV9DTEVBUik7CiAJLyogbW9yZW92ZXIsIGNsZWFyIHRoZSBzb2Z0LXRyaWdnZXJlZCwgaW4gY2FzZSBpdCB3YXMgdGhlIHJlYXNvbiAqLwogCXdyaXRlbCgxIDw8IGlycSwgYmFzZSArIFZJQ19JTlRfU09GVF9DTEVBUik7CiB9CiAKLXN0YXRpYyB2b2lkIHZpY19tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgdmljX21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl2b2lkIF9faW9tZW0gKmJhc2UgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOwotCWlycSAmPSAzMTsKKwl2b2lkIF9faW9tZW0gKmJhc2UgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKKwl1bnNpZ25lZCBpbnQgaXJxID0gZC0+aXJxICYgMzE7CiAJd3JpdGVsKDEgPDwgaXJxLCBiYXNlICsgVklDX0lOVF9FTkFCTEVfQ0xFQVIpOwogfQogCi1zdGF0aWMgdm9pZCB2aWNfdW5tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgdmljX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXZvaWQgX19pb21lbSAqYmFzZSA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7Ci0JaXJxICY9IDMxOworCXZvaWQgX19pb21lbSAqYmFzZSA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOworCXVuc2lnbmVkIGludCBpcnEgPSBkLT5pcnEgJiAzMTsKIAl3cml0ZWwoMSA8PCBpcnEsIGJhc2UgKyBWSUNfSU5UX0VOQUJMRSk7CiB9CiAKQEAgLTI0MiwxMCArMjQyLDEwIEBACiAJcmV0dXJuIE5VTEw7CiB9CiAKLXN0YXRpYyBpbnQgdmljX3NldF93YWtlKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCBvbikKK3N0YXRpYyBpbnQgdmljX3NldF93YWtlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IG9uKQogewotCXN0cnVjdCB2aWNfZGV2aWNlICp2ID0gdmljX2Zyb21faXJxKGlycSk7Ci0JdW5zaWduZWQgaW50IG9mZiA9IGlycSAmIDMxOworCXN0cnVjdCB2aWNfZGV2aWNlICp2ID0gdmljX2Zyb21faXJxKGQtPmlycSk7CisJdW5zaWduZWQgaW50IG9mZiA9IGQtPmlycSAmIDMxOwogCXUzMiBiaXQgPSAxIDw8IG9mZjsKIAogCWlmICghdikKQEAgLTI2NywxMCArMjY3LDEwIEBACiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgdmljX2NoaXAgPSB7CiAJLm5hbWUJCT0gIlZJQyIsCi0JLmFjawkJPSB2aWNfYWNrX2lycSwKLQkubWFzawkJPSB2aWNfbWFza19pcnEsCi0JLnVubWFzawkJPSB2aWNfdW5tYXNrX2lycSwKLQkuc2V0X3dha2UJPSB2aWNfc2V0X3dha2UsCisJLmlycV9hY2sJPSB2aWNfYWNrX2lycSwKKwkuaXJxX21hc2sJPSB2aWNfbWFza19pcnEsCisJLmlycV91bm1hc2sJPSB2aWNfdW5tYXNrX2lycSwKKwkuaXJxX3NldF93YWtlCT0gdmljX3NldF93YWtlLAogfTsKIAogc3RhdGljIHZvaWQgX19pbml0IHZpY19kaXNhYmxlKHZvaWQgX19pb21lbSAqYmFzZSkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvYWc1ZXZtX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvYWc1ZXZtX2RlZmNvbmZpZwppbmRleCAyYjljZjU2Li4yMTJlYWQzIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL2FnNWV2bV9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9hZzVldm1fZGVmY29uZmlnCkBAIC0xMCw3ICsxMCw3IEBACiAjIENPTkZJR19QSURfTlMgaXMgbm90IHNldAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKIENPTkZJR19JTklUUkFNRlNfU09VUkNFPSIiCi1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfU0xBQj15CiAjIENPTkZJR19CTEtfREVWX0JTRyBpcyBub3Qgc2V0CiAjIENPTkZJR19JT1NDSEVEX0RFQURMSU5FIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvYW0yMDBlcGRraXRfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9hbTIwMGVwZGtpdF9kZWZjb25maWcKaW5kZXggNTUzNmM0OC4uZjBkZWE1MiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9hbTIwMGVwZGtpdF9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9hbTIwMGVwZGtpdF9kZWZjb25maWcKQEAgLTMsNyArMyw3IEBACiAjIENPTkZJR19TV0FQIGlzIG5vdCBzZXQKIENPTkZJR19TWVNWSVBDPXkKIENPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0VQT0xMIGlzIG5vdCBzZXQKICMgQ09ORklHX1NITUVNIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvYXQ1NzJkOTQwaGZla19kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL2F0NTcyZDk0MGhmZWtfZGVmY29uZmlnCmluZGV4IDY5NWUzMmQuLjFiMTE1OGEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3MvYXQ1NzJkOTQwaGZla19kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9hdDU3MmQ5NDBoZmVrX2RlZmNvbmZpZwpAQCAtMTcsNyArMTcsNyBAQAogQ09ORklHX1JFTEFZPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfU0xBQj15CiBDT05GSUdfUFJPRklMSU5HPXkKIENPTkZJR19PUFJPRklMRT1tCmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL2JhZGdlNF9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL2JhZGdlNF9kZWZjb25maWcKaW5kZXggM2ExYWQxNS4uNWI1NGFiYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9iYWRnZTRfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvYmFkZ2U0X2RlZmNvbmZpZwpAQCAtMSw2ICsxLDYgQEAKIENPTkZJR19FWFBFUklNRU5UQUw9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RWRVJTSU9OUz15CiBDT05GSUdfQVJDSF9TQTExMDA9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9iY21yaW5nX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvYmNtcmluZ19kZWZjb25maWcKaW5kZXggNzU5ODRjZC4uNzk1Mzc0ZCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9iY21yaW5nX2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL2JjbXJpbmdfZGVmY29uZmlnCkBAIC0yLDcgKzIsNyBAQAogIyBDT05GSUdfTE9DQUxWRVJTSU9OX0FVVE8gaXMgbm90IHNldAogIyBDT05GSUdfU1dBUCBpcyBub3Qgc2V0CiBDT05GSUdfU1lTVklQQz15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfRVhUUkFfUEFTUz15CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvY21feDJ4eF9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL2NtX3gyeHhfZGVmY29uZmlnCmluZGV4IGRjZmJjZjMuLmE5M2ZmOGQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3MvY21feDJ4eF9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9jbV94Mnh4X2RlZmNvbmZpZwpAQCAtNiw3ICs2LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfVk1fRVZFTlRfQ09VTlRFUlMgaXMgbm90IHNldAogIyBDT05GSUdfU0xVQl9ERUJVRyBpcyBub3Qgc2V0CiAjIENPTkZJR19DT01QQVRfQlJLIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvY29saWJyaV9weGEyNzBfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9jb2xpYnJpX3B4YTI3MF9kZWZjb25maWcKaW5kZXggZjUyYzY0ZS4uMmVmMmM1ZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9jb2xpYnJpX3B4YTI3MF9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9jb2xpYnJpX3B4YTI3MF9kZWZjb25maWcKQEAgLTgsNyArOCw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19LQUxMU1lNU19FWFRSQV9QQVNTPXkKIENPTkZJR19TTEFCPXkKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvY29sbGllX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvY29sbGllX2RlZmNvbmZpZwppbmRleCAzMTBmOWE2Li42YzU2YWQwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL2NvbGxpZV9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9jb2xsaWVfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19CQVNFX0ZVTEwgaXMgbm90IHNldAogIyBDT05GSUdfRVBPTEwgaXMgbm90IHNldAogQ09ORklHX1NMT0I9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9jb3JnaV9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL2NvcmdpX2RlZmNvbmZpZwppbmRleCA0YTFmYTgxLi5lNTNjNDc1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL2NvcmdpX2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL2NvcmdpX2RlZmNvbmZpZwpAQCAtNCw3ICs0LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfUFJPRklMSU5HPXkKIENPTkZJR19PUFJPRklMRT1tCiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL2RhOHh4X29tYXBsX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvZGE4eHhfb21hcGxfZGVmY29uZmlnCmluZGV4IGNkYzQwYzQuLjg4Y2NkZTAgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3MvZGE4eHhfb21hcGxfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvZGE4eHhfb21hcGxfZGVmY29uZmlnCkBAIC02LDcgKzYsNyBAQAogQ09ORklHX0lLQ09ORklHX1BST0M9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CiBDT05GSUdfTU9EVUxFX0ZPUkNFX1VOTE9BRD15CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL2RhdmluY2lfYWxsX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvZGF2aW5jaV9hbGxfZGVmY29uZmlnCmluZGV4IDI1MTljYzUuLjg4OTkyMmEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3MvZGF2aW5jaV9hbGxfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvZGF2aW5jaV9hbGxfZGVmY29uZmlnCkBAIC02LDcgKzYsNyBAQAogQ09ORklHX0lLQ09ORklHX1BST0M9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CiBDT05GSUdfTU9EVUxFX0ZPUkNFX1VOTE9BRD15CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL2RvdmVfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9kb3ZlX2RlZmNvbmZpZwppbmRleCA5MzU5ZTFiLi41NGJmNWVlIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL2RvdmVfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvZG92ZV9kZWZjb25maWcKQEAgLTEsNyArMSw3IEBACiBDT05GSUdfRVhQRVJJTUVOVEFMPXkKIENPTkZJR19TWVNWSVBDPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL2Vic2ExMTBfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9lYnNhMTEwX2RlZmNvbmZpZwppbmRleCBjMzE5NDE4Li4xNDU1OWRiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL2Vic2ExMTBfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvZWJzYTExMF9kZWZjb25maWcKQEAgLTIsNyArMiw3IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfQlNEX1BST0NFU1NfQUNDVD15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX0FSQ0hfRUJTQTExMD15CiBDT05GSUdfUENDQVJEPW0KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvZWRiNzIxMV9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL2VkYjcyMTFfZGVmY29uZmlnCmluZGV4IDdiNjJiZTEuLmQ1MmRlZDM1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL2VkYjcyMTFfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvZWRiNzIxMV9kZWZjb25maWcKQEAgLTIsNyArMiw3IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0hPVFBMVUcgaXMgbm90IHNldAogQ09ORklHX0FSQ0hfQ0xQUzcxMVg9eQogQ09ORklHX0FSQ0hfRURCNzIxMT15CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL2VtX3gyNzBfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9lbV94MjcwX2RlZmNvbmZpZwppbmRleCBkN2RiMzRmLi42MGEyMWUwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL2VtX3gyNzBfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvZW1feDI3MF9kZWZjb25maWcKQEAgLTYsNyArNiw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1ZNX0VWRU5UX0NPVU5URVJTIGlzIG5vdCBzZXQKICMgQ09ORklHX1NMVUJfREVCVUcgaXMgbm90IHNldAogIyBDT05GSUdfQ09NUEFUX0JSSyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL2VwOTN4eF9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL2VwOTN4eF9kZWZjb25maWcKaW5kZXggNmQ2Njg5Yy4uOGU5N2IyZiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9lcDkzeHhfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvZXA5M3h4X2RlZmNvbmZpZwpAQCAtNCw3ICs0LDcgQEAKIENPTkZJR19JS0NPTkZJR19QUk9DPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL2VzZXJpZXNfcHhhX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvZXNlcmllc19weGFfZGVmY29uZmlnCmluZGV4IDE2OTFkZWEuLmQ2OGFjNjcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3MvZXNlcmllc19weGFfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvZXNlcmllc19weGFfZGVmY29uZmlnCkBAIC0yLDcgKzIsNyBAQAogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX0NPTVBBVF9CUksgaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9lenhfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9lenhfZGVmY29uZmlnCmluZGV4IGM0ZWViNmQuLjIyN2E0NzcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3MvZXp4X2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL2V6eF9kZWZjb25maWcKQEAgLTcsNyArNyw3IEBACiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogQ09ORklHX1JEX0JaSVAyPXkKIENPTkZJR19SRF9MWk1BPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0NPTVBBVF9CUksgaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9mb290YnJpZGdlX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvZm9vdGJyaWRnZV9kZWZjb25maWcKaW5kZXggNGY5MjVlYS4uMDM4NTE4YSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9mb290YnJpZGdlX2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL2Zvb3RicmlkZ2VfZGVmY29uZmlnCkBAIC0zLDcgKzMsNyBAQAogQ09ORklHX0JTRF9QUk9DRVNTX0FDQ1Q9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19BUkNIX0ZPT1RCUklER0U9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9mb3J0dW5ldF9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL2ZvcnR1bmV0X2RlZmNvbmZpZwppbmRleCBlMTFjN2VhLi44NDBmY2VkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL2ZvcnR1bmV0X2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL2ZvcnR1bmV0X2RlZmNvbmZpZwpAQCAtMiw3ICsyLDcgQEAKIENPTkZJR19TWVNWSVBDPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfSE9UUExVRyBpcyBub3Qgc2V0CiBDT05GSUdfQVJDSF9DTFBTNzExWD15CiBDT05GSUdfQVJDSF9GT1JUVU5FVD15CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL2g1MDAwX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvaDUwMDBfZGVmY29uZmlnCmluZGV4IGFjMzM2ZjEuLjM3OTAzZTMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3MvaDUwMDBfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvaDUwMDBfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX0lLQ09ORklHX1BST0M9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTYKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1VJRDE2IGlzIG5vdCBzZXQKIENPTkZJR19TTEFCPXkKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvaW1vdGUyX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvaW1vdGUyX2RlZmNvbmZpZwppbmRleCBhZGU1NWM4Li4xNzZlYzIyIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL2ltb3RlMl9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9pbW90ZTJfZGVmY29uZmlnCkBAIC02LDcgKzYsNyBAQAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKIENPTkZJR19SRF9CWklQMj15CiBDT05GSUdfUkRfTFpNQT15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19DT01QQVRfQlJLIGlzIG5vdCBzZXQKIENPTkZJR19TTEFCPXkKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvaXhwMjAwMF9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL2l4cDIwMDBfZGVmY29uZmlnCmluZGV4IDkwODMyNDYuLjg0MDVhZGUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3MvaXhwMjAwMF9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9peHAyMDAwX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19CU0RfUFJPQ0VTU19BQ0NUPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfSE9UUExVRyBpcyBub3Qgc2V0CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL2l4cDIzeHhfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9peHAyM3h4X2RlZmNvbmZpZwppbmRleCA3ZmMwNTZhLi42ODg3MTc2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL2l4cDIzeHhfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvaXhwMjN4eF9kZWZjb25maWcKQEAgLTMsNyArMyw3IEBACiBDT05GSUdfQlNEX1BST0NFU1NfQUNDVD15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19TTEFCPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvaXhwNHh4X2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvaXhwNHh4X2RlZmNvbmZpZwppbmRleCA1YzUwMjM5Li4wNjNlMmFiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL2l4cDR4eF9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9peHA0eHhfZGVmY29uZmlnCkBAIC0zLDcgKzMsNyBAQAogQ09ORklHX0JTRF9QUk9DRVNTX0FDQ1Q9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVkVSU0lPTlM9eQogIyBDT05GSUdfQkxLX0RFVl9CU0cgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9sb2tpX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvbG9raV9kZWZjb25maWcKaW5kZXggZTFlYWZmNy4uMWJhNzUyYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9sb2tpX2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL2xva2lfZGVmY29uZmlnCkBAIC0xLDcgKzEsNyBAQAogQ09ORklHX0VYUEVSSU1FTlRBTD15CiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9scGQ3YTQwMF9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL2xwZDdhNDAwX2RlZmNvbmZpZwppbmRleCAyMGNhYWFiLi41YTQ4ZjE3IDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL2xwZDdhNDAwX2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL2xwZDdhNDAwX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19TWVNWSVBDPXkKIENPTkZJR19JS0NPTkZJRz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfSE9UUExVRyBpcyBub3Qgc2V0CiAjIENPTkZJR19FUE9MTCBpcyBub3Qgc2V0CiAjIENPTkZJR19JT1NDSEVEX0RFQURMSU5FIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvbHBkN2E0MDRfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9scGQ3YTQwNF9kZWZjb25maWcKaW5kZXggMWVmY2NlOS4uMjJkMDYzMSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9scGQ3YTQwNF9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9scGQ3YTQwNF9kZWZjb25maWcKQEAgLTMsNyArMyw3IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfSUtDT05GSUc9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTYKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0hPVFBMVUcgaXMgbm90IHNldAogIyBDT05GSUdfRVBPTEwgaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9tYWdpY2lhbl9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL21hZ2ljaWFuX2RlZmNvbmZpZwppbmRleCBhZjgwNWU4Li5hODhlNjRkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL21hZ2ljaWFuX2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL21hZ2ljaWFuX2RlZmNvbmZpZwpAQCAtNCw3ICs0LDcgQEAKIENPTkZJR19JS0NPTkZJR19QUk9DPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE2CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfVUlEMTYgaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9tdjc4eHgwX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvbXY3OHh4MF9kZWZjb25maWcKaW5kZXggYjBkMDgyNC4uNzMwNWViZCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9tdjc4eHgwX2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL212Nzh4eDBfZGVmY29uZmlnCkBAIC0yLDcgKzIsNyBAQAogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19LQUxMU1lNU19BTEw9eQogIyBDT05GSUdfU0xVQl9ERUJVRyBpcyBub3Qgc2V0CiBDT05GSUdfUFJPRklMSU5HPXkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvbXgxX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvbXgxX2RlZmNvbmZpZwppbmRleCAyZjM4ZDk3Li5iMzliNWNlIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL214MV9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9teDFfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX0lLQ09ORklHX1BST0M9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19TTEFCPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvbXgyMV9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL214MjFfZGVmY29uZmlnCmluZGV4IDY0NTRlMTguLjQxMWY4OGQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3MvbXgyMV9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9teDIxX2RlZmNvbmZpZwpAQCAtNCw3ICs0LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfRVhUUkFfUEFTUz15CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL214MjdfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9teDI3X2RlZmNvbmZpZwppbmRleCA4MTNjZmIzLi45YWQ0YzY1NiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9teDI3X2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL214MjdfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX1BPU0lYX01RVUVVRT15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX0tBTExTWU1TX0VYVFJBX1BBU1M9eQogIyBDT05GSUdfQ09NUEFUX0JSSyBpcyBub3Qgc2V0CiBDT05GSUdfU0xBQj15CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL214M19kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL214M19kZWZjb25maWcKaW5kZXggZTY0OGVhMy4uN2M0YjMwYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9teDNfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvbXgzX2RlZmNvbmZpZwpAQCAtNCw3ICs0LDcgQEAKIENPTkZJR19JS0NPTkZJR19QUk9DPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL214NTFfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9teDUxX2RlZmNvbmZpZwppbmRleCA1YzdhODcyLi45Y2JhNjhjIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL214NTFfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvbXg1MV9kZWZjb25maWcKQEAgLTMsNyArMyw3IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xOAogQ09ORklHX1JFTEFZPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NMVUJfREVCVUcgaXMgbm90IHNldAogIyBDT05GSUdfQ09NUEFUX0JSSyBpcyBub3Qgc2V0CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL25oazg4MTVfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9uaGs4ODE1X2RlZmNvbmZpZwppbmRleCAwZTJkYzI2Li4zNzIwN2QxIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL25oazg4MTVfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3MvbmhrODgxNV9kZWZjb25maWcKQEAgLTcsNyArNyw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19LQUxMU1lNU19BTEw9eQogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9vbWFwMV9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL29tYXAxX2RlZmNvbmZpZwppbmRleCBhMzUwY2M2Li43YjYzNDYyIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL29tYXAxX2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL29tYXAxX2RlZmNvbmZpZwpAQCAtNiw3ICs2LDcgQEAKIENPTkZJR19JS0NPTkZJRz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKICMgQ09ORklHX0JBU0VfRlVMTCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL29tYXAycGx1c19kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL29tYXAycGx1c19kZWZjb25maWcKaW5kZXggY2NlZGRlMS4uYWU4OTBjYSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9vbWFwMnBsdXNfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3Mvb21hcDJwbHVzX2RlZmNvbmZpZwpAQCAtNiw3ICs2LDcgQEAKIENPTkZJR19JS0NPTkZJR19QUk9DPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE2CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogQ09ORklHX0tBTExTWU1TX0VYVFJBX1BBU1M9eQogQ09ORklHX1NMQUI9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9vcmlvbjV4X2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3Mvb3Jpb241eF9kZWZjb25maWcKaW5kZXggNDM5MzIzYi4uYTI4OGQ3MCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9vcmlvbjV4X2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL29yaW9uNXhfZGVmY29uZmlnCkBAIC0yLDcgKzIsNyBAQAogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NMVUJfREVCVUcgaXMgbm90IHNldAogQ09ORklHX1BST0ZJTElORz15CiBDT05GSUdfT1BST0ZJTEU9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9wY20wMjdfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9wY20wMjdfZGVmY29uZmlnCmluZGV4IDU4M2EwNjEuLjJmMTM2YzMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3MvcGNtMDI3X2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL3BjbTAyN19kZWZjb25maWcKQEAgLTcsNyArNyw3IEBACiBDT05GSUdfSUtDT05GSUdfUFJPQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9wY29udHJvbF9nMjBfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9wY29udHJvbF9nMjBfZGVmY29uZmlnCmluZGV4IGI0MmVlNjIuLmM3NWM5ZmMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3MvcGNvbnRyb2xfZzIwX2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL3Bjb250cm9sX2cyMF9kZWZjb25maWcKQEAgLTEwLDcgKzEwLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfTkFNRVNQQUNFUz15CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfVk1fRVZFTlRfQ09VTlRFUlMgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9wbGViX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvcGxlYl9kZWZjb25maWcKaW5kZXggZDFlZmJkYy4uY2IwOGNjNSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9wbGViX2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL3BsZWJfZGVmY29uZmlnCkBAIC0zLDcgKzMsNyBAQAogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX1NITUVNIGlzIG5vdCBzZXQKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvcG54NDAwOF9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL3BueDQwMDhfZGVmY29uZmlnCmluZGV4IGJkNDgxZjAuLjM1YTMxY2MgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3MvcG54NDAwOF9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9wbng0MDA4X2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19BVURJVD15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19TTEFCPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3Mvc2ltcGFkX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3Mvc2ltcGFkX2RlZmNvbmZpZwppbmRleCBhZjNiMTJlLi5kMzM1ODE1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL3NpbXBhZF9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9zaW1wYWRfZGVmY29uZmlnCkBAIC0yLDcgKzIsNyBAQAogQ09ORklHX0xPQ0FMVkVSU0lPTj0ib2UxIgogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19LQUxMU1lNU19BTEw9eQogQ09ORklHX0tBTExTWU1TX0VYVFJBX1BBU1M9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy9zcGl0el9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL3NwaXR6X2RlZmNvbmZpZwppbmRleCBhZWJkNGJiLi43MDE1ODI3IDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL3NwaXR6X2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL3NwaXR6X2RlZmNvbmZpZwpAQCAtNCw3ICs0LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfUFJPRklMSU5HPXkKIENPTkZJR19PUFJPRklMRT1tCiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL3N0bXAzNzh4X2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3Mvc3RtcDM3OHhfZGVmY29uZmlnCmluZGV4IDk0YTJkOTAuLjEwNzljMmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2NvbmZpZ3Mvc3RtcDM3OHhfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3Mvc3RtcDM3OHhfZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0JTRF9QUk9DRVNTX0FDQ1Q9eQogQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19TTEFCPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3Mvc3RtcDM3eHhfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy9zdG1wMzd4eF9kZWZjb25maWcKaW5kZXggZDhlZTU4Yy4uNTY0YTVjYyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9zdG1wMzd4eF9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy9zdG1wMzd4eF9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfQlNEX1BST0NFU1NfQUNDVD15CiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy90Y3RfaGFtbWVyX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvdGN0X2hhbW1lcl9kZWZjb25maWcKaW5kZXggZTg5Y2ExOS4uOTVjMGYwZCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy90Y3RfaGFtbWVyX2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL3RjdF9oYW1tZXJfZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19CVUcgaXMgbm90IHNldAogIyBDT05GSUdfRUxGX0NPUkUgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy90cml6ZXBzNF9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL3RyaXplcHM0X2RlZmNvbmZpZwppbmRleCAzN2Y0ODM0Li4zMTYyMTczIDEwMDY0NAotLS0gYS9hcmNoL2FybS9jb25maWdzL3RyaXplcHM0X2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL3RyaXplcHM0X2RlZmNvbmZpZwpAQCAtNyw3ICs3LDcgQEAKIENPTkZJR19JS0NPTkZJR19QUk9DPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX0tBTExTWU1TX0VYVFJBX1BBU1M9eQogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy91MzAwX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MvdTMwMF9kZWZjb25maWcKaW5kZXggYzFjMjUyYy4uNGE1YTEyNiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy91MzAwX2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL3UzMDBfZGVmY29uZmlnCkBAIC0zLDcgKzMsNyBAQAogIyBDT05GSUdfU1dBUCBpcyBub3Qgc2V0CiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfQUlPIGlzIG5vdCBzZXQKICMgQ09ORklHX1ZNX0VWRU5UX0NPVU5URVJTIGlzIG5vdCBzZXQKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2NvbmZpZ3MvdmlwZXJfZGVmY29uZmlnIGIvYXJjaC9hcm0vY29uZmlncy92aXBlcl9kZWZjb25maWcKaW5kZXggOWQ3YmY1ZS4uOGIwYzcxNyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy92aXBlcl9kZWZjb25maWcKKysrIGIvYXJjaC9hcm0vY29uZmlncy92aXBlcl9kZWZjb25maWcKQEAgLTMsNyArMyw3IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xMwogQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfRUxGX0NPUkUgaXMgbm90IHNldAogIyBDT05GSUdfU0hNRU0gaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vY29uZmlncy94Y2VwX2RlZmNvbmZpZyBiL2FyY2gvYXJtL2NvbmZpZ3MveGNlcF9kZWZjb25maWcKaW5kZXggNzBkNDdkYi4uNWI1NTA0MSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy94Y2VwX2RlZmNvbmZpZworKysgYi9hcmNoL2FybS9jb25maWdzL3hjZXBfZGVmY29uZmlnCkBAIC04LDcgKzgsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTYKIENPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19VSUQxNiBpcyBub3Qgc2V0CiAjIENPTkZJR19TSE1FTSBpcyBub3Qgc2V0CiAjIENPTkZJR19WTV9FVkVOVF9DT1VOVEVSUyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9iaXRvcHMuaCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2JpdG9wcy5oCmluZGV4IDMzOGZmMTkuLjdiMWJiMmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2JpdG9wcy5oCisrKyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2JpdG9wcy5oCkBAIC0yODUsNyArMjg1LDcgQEAKIAlpZiAoX19idWlsdGluX2NvbnN0YW50X3AoeCkpCiAJICAgICAgIHJldHVybiBjb25zdGFudF9mbHMoeCk7CiAKLQlhc20oImNselx0JTAsICUxIiA6ICI9ciIgKHJldCkgOiAiciIgKHgpIDogImNjIik7CisJYXNtKCJjbHpcdCUwLCAlMSIgOiAiPXIiIChyZXQpIDogInIiICh4KSk7CiAgICAgICAgCXJldCA9IDMyIC0gcmV0OwogCXJldHVybiByZXQ7CiB9CmRpZmYgLS1naXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9oYXJkd2FyZS9zcDgxMC5oIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20vaGFyZHdhcmUvc3A4MTAuaAppbmRleCBhMTAxZjEwLi43MjE4NDdkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9oYXJkd2FyZS9zcDgxMC5oCisrKyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2hhcmR3YXJlL3NwODEwLmgKQEAgLTUwLDYgKzUwLDEyIEBACiAjZGVmaW5lIFNDUENFTExJRDIJCTB4RkY4CiAjZGVmaW5lIFNDUENFTExJRDMJCTB4RkZDCiAKKyNkZWZpbmUgU0NDVFJMX1RJTUVSRU4wU0VMX1JFRkNMSwkoMCA8PCAxNSkKKyNkZWZpbmUgU0NDVFJMX1RJTUVSRU4wU0VMX1RJTUNMSwkoMSA8PCAxNSkKKworI2RlZmluZSBTQ0NUUkxfVElNRVJFTjFTRUxfUkVGQ0xLCSgwIDw8IDE3KQorI2RlZmluZSBTQ0NUUkxfVElNRVJFTjFTRUxfVElNQ0xLCSgxIDw8IDE3KQorCiBzdGF0aWMgaW5saW5lIHZvaWQgc3lzY3RsX3NvZnRfcmVzZXQodm9pZCBfX2lvbWVtICpiYXNlKQogewogCS8qIHdyaXRpbmcgYW55IHZhbHVlIHRvIFNDU1lTU1RBVCByZWcgd2lsbCByZXNldCBzeXN0ZW0gKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2lvLmggYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9pby5oCmluZGV4IDIwZTBmN2MuLmQ2NjYwNWRlIDEwMDY0NAotLS0gYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9pby5oCisrKyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2lvLmgKQEAgLTk1LDYgKzk1LDE1IEBACiAJcmV0dXJuICh2b2lkIF9faW9tZW0gKilhZGRyOwogfQogCisvKiBJTyBiYXJyaWVycyAqLworI2lmZGVmIENPTkZJR19BUk1fRE1BX01FTV9CVUZGRVJBQkxFCisjZGVmaW5lIF9faW9ybWIoKQkJcm1iKCkKKyNkZWZpbmUgX19pb3dtYigpCQl3bWIoKQorI2Vsc2UKKyNkZWZpbmUgX19pb3JtYigpCQlkbyB7IH0gd2hpbGUgKDApCisjZGVmaW5lIF9faW93bWIoKQkJZG8geyB9IHdoaWxlICgwKQorI2VuZGlmCisKIC8qCiAgKiBOb3csIHBpY2sgdXAgdGhlIG1hY2hpbmUtZGVmaW5lZCBJTyBkZWZpbml0aW9ucwogICovCkBAIC0xMjUsMTcgKzEzNCwxNyBAQAogICogVGhlIHtpbixvdXR9W2J3bF0gbWFjcm9zIGFyZSBmb3IgZW11bGF0aW5nIHg4Ni1zdHlsZSBQQ0kvSVNBIElPIHNwYWNlLgogICovCiAjaWZkZWYgX19pbwotI2RlZmluZSBvdXRiKHYscCkJCV9fcmF3X3dyaXRlYih2LF9faW8ocCkpCi0jZGVmaW5lIG91dHcodixwKQkJX19yYXdfd3JpdGV3KChfX2ZvcmNlIF9fdTE2KSBcCi0JCQkJCWNwdV90b19sZTE2KHYpLF9faW8ocCkpCi0jZGVmaW5lIG91dGwodixwKQkJX19yYXdfd3JpdGVsKChfX2ZvcmNlIF9fdTMyKSBcCi0JCQkJCWNwdV90b19sZTMyKHYpLF9faW8ocCkpCisjZGVmaW5lIG91dGIodixwKQkoeyBfX2lvd21iKCk7IF9fcmF3X3dyaXRlYih2LF9faW8ocCkpOyB9KQorI2RlZmluZSBvdXR3KHYscCkJKHsgX19pb3dtYigpOyBfX3Jhd193cml0ZXcoKF9fZm9yY2UgX191MTYpIFwKKwkJCQkJY3B1X3RvX2xlMTYodiksX19pbyhwKSk7IH0pCisjZGVmaW5lIG91dGwodixwKQkoeyBfX2lvd21iKCk7IF9fcmF3X3dyaXRlbCgoX19mb3JjZSBfX3UzMikgXAorCQkJCQljcHVfdG9fbGUzMih2KSxfX2lvKHApKTsgfSkKIAotI2RlZmluZSBpbmIocCkJKHsgX191OCBfX3YgPSBfX3Jhd19yZWFkYihfX2lvKHApKTsgX192OyB9KQorI2RlZmluZSBpbmIocCkJKHsgX191OCBfX3YgPSBfX3Jhd19yZWFkYihfX2lvKHApKTsgX19pb3JtYigpOyBfX3Y7IH0pCiAjZGVmaW5lIGludyhwKQkoeyBfX3UxNiBfX3YgPSBsZTE2X3RvX2NwdSgoX19mb3JjZSBfX2xlMTYpIFwKLQkJCV9fcmF3X3JlYWR3KF9faW8ocCkpKTsgX192OyB9KQorCQkJX19yYXdfcmVhZHcoX19pbyhwKSkpOyBfX2lvcm1iKCk7IF9fdjsgfSkKICNkZWZpbmUgaW5sKHApCSh7IF9fdTMyIF9fdiA9IGxlMzJfdG9fY3B1KChfX2ZvcmNlIF9fbGUzMikgXAotCQkJX19yYXdfcmVhZGwoX19pbyhwKSkpOyBfX3Y7IH0pCisJCQlfX3Jhd19yZWFkbChfX2lvKHApKSk7IF9faW9ybWIoKTsgX192OyB9KQogCiAjZGVmaW5lIG91dHNiKHAsZCxsKQkJX19yYXdfd3JpdGVzYihfX2lvKHApLGQsbCkKICNkZWZpbmUgb3V0c3cocCxkLGwpCQlfX3Jhd193cml0ZXN3KF9faW8ocCksZCxsKQpAQCAtMTkyLDE0ICsyMDEsNiBAQAogI2RlZmluZSB3cml0ZWxfcmVsYXhlZCh2LGMpCSgodm9pZClfX3Jhd193cml0ZWwoKF9fZm9yY2UgdTMyKSBcCiAJCQkJCWNwdV90b19sZTMyKHYpLF9fbWVtX3BjaShjKSkpCiAKLSNpZmRlZiBDT05GSUdfQVJNX0RNQV9NRU1fQlVGRkVSQUJMRQotI2RlZmluZSBfX2lvcm1iKCkJCXJtYigpCi0jZGVmaW5lIF9faW93bWIoKQkJd21iKCkKLSNlbHNlCi0jZGVmaW5lIF9faW9ybWIoKQkJZG8geyB9IHdoaWxlICgwKQotI2RlZmluZSBfX2lvd21iKCkJCWRvIHsgfSB3aGlsZSAoMCkKLSNlbmRpZgotCiAjZGVmaW5lIHJlYWRiKGMpCQkoeyB1OCAgX192ID0gcmVhZGJfcmVsYXhlZChjKTsgX19pb3JtYigpOyBfX3Y7IH0pCiAjZGVmaW5lIHJlYWR3KGMpCQkoeyB1MTYgX192ID0gcmVhZHdfcmVsYXhlZChjKTsgX19pb3JtYigpOyBfX3Y7IH0pCiAjZGVmaW5lIHJlYWRsKGMpCQkoeyB1MzIgX192ID0gcmVhZGxfcmVsYXhlZChjKTsgX19pb3JtYigpOyBfX3Y7IH0pCmRpZmYgLS1naXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9tZW1vcnkuaCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL21lbW9yeS5oCmluZGV4IDIzYzJlOGUuLmQwZWU3NGIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL21lbW9yeS5oCisrKyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL21lbW9yeS5oCkBAIC0xODgsNyArMTg4LDcgQEAKICAqIHRyYW5zbGF0aW9uIGZvciB0cmFuc2xhdGluZyBETUEgYWRkcmVzc2VzLiAgVXNlIHRoZSBkcml2ZXIKICAqIERNQSBzdXBwb3J0IC0gc2VlIGRtYS1tYXBwaW5nLmguCiAgKi8KLXN0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyB2aXJ0X3RvX3BoeXModm9pZCAqeCkKK3N0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyB2aXJ0X3RvX3BoeXMoY29uc3Qgdm9sYXRpbGUgdm9pZCAqeCkKIHsKIAlyZXR1cm4gX192aXJ0X3RvX3BoeXMoKHVuc2lnbmVkIGxvbmcpKHgpKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL3NjaGVkX2Nsb2NrLmggYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9zY2hlZF9jbG9jay5oCmluZGV4IGE4NDYyOGIuLmM4ZTZkZGYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL3NjaGVkX2Nsb2NrLmgKKysrIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20vc2NoZWRfY2xvY2suaApAQCAtMTE1LDQgKzExNSw2IEBACiAJfQogfQogCitleHRlcm4gdm9pZCBzY2hlZF9jbG9ja19wb3N0aW5pdCh2b2lkKTsKKwogI2VuZGlmCmRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwvZWNhcmQuYyBiL2FyY2gvYXJtL2tlcm5lbC9lY2FyZC5jCmluZGV4IGVlZDJmNzkuLjJhZDYyZGYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2tlcm5lbC9lY2FyZC5jCisrKyBiL2FyY2gvYXJtL2tlcm5lbC9lY2FyZC5jCkBAIC00NDMsNDAgKzQ0Myw0MCBAQAogICoKICAqIFRoZXkgYXJlIG5vdCBtZWFudCB0byBiZSBjYWxsZWQgZGlyZWN0bHksIGJ1dCB2aWEgZW5hYmxlL2Rpc2FibGVfaXJxLgogICovCi1zdGF0aWMgdm9pZCBlY2FyZF9pcnFfdW5tYXNrKHVuc2lnbmVkIGludCBpcnFucikKK3N0YXRpYyB2b2lkIGVjYXJkX2lycV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQogewotCWVjYXJkX3QgKmVjID0gc2xvdF90b19lY2FyZChpcnFuciAtIDMyKTsKKwllY2FyZF90ICplYyA9IHNsb3RfdG9fZWNhcmQoZC0+aXJxIC0gMzIpOwogCiAJaWYgKGVjKSB7CiAJCWlmICghZWMtPm9wcykKIAkJCWVjLT5vcHMgPSAmZWNhcmRfZGVmYXVsdF9vcHM7CiAKIAkJaWYgKGVjLT5jbGFpbWVkICYmIGVjLT5vcHMtPmlycWVuYWJsZSkKLQkJCWVjLT5vcHMtPmlycWVuYWJsZShlYywgaXJxbnIpOworCQkJZWMtPm9wcy0+aXJxZW5hYmxlKGVjLCBkLT5pcnEpOwogCQllbHNlCiAJCQlwcmludGsoS0VSTl9FUlIgImVjYXJkOiByZWplY3RpbmcgcmVxdWVzdCB0byAiCi0JCQkJImVuYWJsZSBJUlFzIGZvciAlZFxuIiwgaXJxbnIpOworCQkJCSJlbmFibGUgSVJRcyBmb3IgJWRcbiIsIGQtPmlycSk7CiAJfQogfQogCi1zdGF0aWMgdm9pZCBlY2FyZF9pcnFfbWFzayh1bnNpZ25lZCBpbnQgaXJxbnIpCitzdGF0aWMgdm9pZCBlY2FyZF9pcnFfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JZWNhcmRfdCAqZWMgPSBzbG90X3RvX2VjYXJkKGlycW5yIC0gMzIpOworCWVjYXJkX3QgKmVjID0gc2xvdF90b19lY2FyZChkLT5pcnEgLSAzMik7CiAKIAlpZiAoZWMpIHsKIAkJaWYgKCFlYy0+b3BzKQogCQkJZWMtPm9wcyA9ICZlY2FyZF9kZWZhdWx0X29wczsKIAogCQlpZiAoZWMtPm9wcyAmJiBlYy0+b3BzLT5pcnFkaXNhYmxlKQotCQkJZWMtPm9wcy0+aXJxZGlzYWJsZShlYywgaXJxbnIpOworCQkJZWMtPm9wcy0+aXJxZGlzYWJsZShlYywgZC0+aXJxKTsKIAl9CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgZWNhcmRfY2hpcCA9IHsKLQkubmFtZQk9ICJFQ0FSRCIsCi0JLmFjawk9IGVjYXJkX2lycV9tYXNrLAotCS5tYXNrCT0gZWNhcmRfaXJxX21hc2ssCi0JLnVubWFzayA9IGVjYXJkX2lycV91bm1hc2ssCisJLm5hbWUJCT0gIkVDQVJEIiwKKwkuaXJxX2Fjawk9IGVjYXJkX2lycV9tYXNrLAorCS5pcnFfbWFzawk9IGVjYXJkX2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gZWNhcmRfaXJxX3VubWFzaywKIH07CiAKIHZvaWQgZWNhcmRfZW5hYmxlZmlxKHVuc2lnbmVkIGludCBmaXFucikKQEAgLTU1MSw3ICs1NTEsNyBAQAogCQkJcHJpbnRrKEtFUk5fRVJSICJcbkludGVycnVwdCBsb2NrdXAgZGV0ZWN0ZWQgLSAiCiAJCQkgICAgICAgImRpc2FibGluZyBhbGwgZXhwYW5zaW9uIGNhcmQgaW50ZXJydXB0c1xuIik7CiAKLQkJCWRlc2MtPmNoaXAtPm1hc2soSVJRX0VYUEFOU0lPTkNBUkQpOworCQkJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX21hc2soJmRlc2MtPmlycV9kYXRhKTsKIAkJCWVjYXJkX2R1bXBfaXJxX3N0YXRlKCk7CiAJCX0KIAl9IGVsc2UKQEAgLTU3NCw3ICs1NzQsNyBAQAogCWVjYXJkX3QgKmVjOwogCWludCBjYWxsZWQgPSAwOwogCi0JZGVzYy0+Y2hpcC0+bWFzayhpcnEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9tYXNrKCZkZXNjLT5pcnFfZGF0YSk7CiAJZm9yIChlYyA9IGNhcmRzOyBlYzsgZWMgPSBlYy0+bmV4dCkgewogCQlpbnQgcGVuZGluZzsKIApAQCAtNTkxLDcgKzU5MSw3IEBACiAJCQljYWxsZWQgKys7CiAJCX0KIAl9Ci0JZGVzYy0+Y2hpcC0+dW5tYXNrKGlycSk7CisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX3VubWFzaygmZGVzYy0+aXJxX2RhdGEpOwogCiAJaWYgKGNhbGxlZCA9PSAwKQogCQllY2FyZF9jaGVja19sb2NrdXAoZGVzYyk7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwvaGVhZC1jb21tb24uUyBiL2FyY2gvYXJtL2tlcm5lbC9oZWFkLWNvbW1vbi5TCmluZGV4IGJiZWNhYWMuLjhmNTc1MTUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2tlcm5lbC9oZWFkLWNvbW1vbi5TCisrKyBiL2FyY2gvYXJtL2tlcm5lbC9oZWFkLWNvbW1vbi5TCkBAIC02MCw2ICs2MCw4IEBACiBzdHJfYTI6CS5hc2NpegkiKS5cblxuQXZhaWxhYmxlIG1hY2hpbmUgc3VwcG9ydDpcblxuSUQgKGhleClcdE5BTUVcbiIKIHN0cl9hMzoJLmFzY2l6CSJcblBsZWFzZSBjaGVjayB5b3VyIGtlcm5lbCBjb25maWcgYW5kL29yIGJvb3Rsb2FkZXIuXG4iCiAJLmFsaWduCisjZWxzZQorCWIJX19lcnJvcgogI2VuZGlmCiAKIC8qCmRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwvaGVhZC5TIGIvYXJjaC9hcm0va2VybmVsL2hlYWQuUwppbmRleCBmMTdkOWEwLi5jMDIyNWRhIDEwMDY0NAotLS0gYS9hcmNoL2FybS9rZXJuZWwvaGVhZC5TCisrKyBiL2FyY2gvYXJtL2tlcm5lbC9oZWFkLlMKQEAgLTM5MiwyNCArMzkyLDIyIEBACiAKICNpZmRlZiBDT05GSUdfU01QX09OX1VQCiBfX2ZpeHVwX3NtcDoKLQltb3YJcjQsICMweDAwMDcwMDAwCi0Jb3JyCXIzLCByNCwgIzB4ZmYwMDAwMDAJQCBtYXNrIDB4ZmYwNzAwMDAKLQlvcnIJcjQsIHI0LCAjMHg0MTAwMDAwMAlAIHZhbCAweDQxMDcwMDAwCi0JYW5kCXIwLCByOSwgcjMKLQl0ZXEJcjAsIHI0CQkJQCBBUk0gQ1BVIGFuZCBBUk12Ni92Nz8KKwlhbmQJcjMsIHI5LCAjMHgwMDBmMDAwMAlAIGFyY2hpdGVjdHVyZSB2ZXJzaW9uCisJdGVxCXIzLCAjMHgwMDBmMDAwMAkJQCBDUFUgSUQgc3VwcG9ydGVkPwogCWJuZQlfX2ZpeHVwX3NtcF9vbl91cAlAIG5vLCBhc3N1bWUgVVAKIAotCW9ycglyMywgcjMsICMweDAwMDBmZjAwCi0Jb3JyCXIzLCByMywgIzB4MDAwMDAwZjAJQCBtYXNrIDB4ZmYwN2ZmZjAKKwliaWMJcjMsIHI5LCAjMHgwMGZmMDAwMAorCWJpYwlyMywgcjMsICMweDAwMDAwMDBmCUAgbWFzayAweGZmMDBmZmYwCisJbW92CXI0LCAjMHg0MTAwMDAwMAogCW9ycglyNCwgcjQsICMweDAwMDBiMDAwCi0Jb3JyCXI0LCByNCwgIzB4MDAwMDAwMjAJQCB2YWwgMHg0MTA3YjAyMAotCWFuZAlyMCwgcjksIHIzCi0JdGVxCXIwLCByNAkJCUAgQVJNIDExTVBDb3JlPworCW9ycglyNCwgcjQsICMweDAwMDAwMDIwCUAgdmFsIDB4NDEwMGIwMjAKKwl0ZXEJcjMsIHI0CQkJQCBBUk0gMTFNUENvcmU/CiAJbW92ZXEJcGMsIGxyCQkJQCB5ZXMsIGFzc3VtZSBTTVAKIAogCW1yYwlwMTUsIDAsIHIwLCBjMCwgYzAsIDUJQCByZWFkIE1QSURSCi0JdHN0CXIwLCAjMSA8PCAzMQotCW1vdm5lCXBjLCBscgkJCUAgYml0IDMxID0+IFNNUAorCWFuZAlyMCwgcjAsICMweGMwMDAwMDAwCUAgbXVsdGlwcm9jZXNzaW5nIGV4dGVuc2lvbnMgYW5kCisJdGVxCXIwLCAjMHg4MDAwMDAwMAkJQCBub3QgcGFydCBvZiBhIHVuaXByb2Nlc3NvciBzeXN0ZW0/CisJbW92ZXEJcGMsIGxyCQkJQCB5ZXMsIGFzc3VtZSBTTVAKIAogX19maXh1cF9zbXBfb25fdXA6CiAJYWRyCXIwLCAxZgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va2VybmVsL2lycS5jIGIvYXJjaC9hcm0va2VybmVsL2lycS5jCmluZGV4IDgxMzU0MzguLjI4NTM2ZTMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2tlcm5lbC9pcnEuYworKysgYi9hcmNoL2FybS9rZXJuZWwvaXJxLmMKQEAgLTg4LDcgKzg4LDcgQEAKIAkJc2VxX3ByaW50ZihwLCAiJSpkOiAiLCBwcmVjLCBpKTsKIAkJZm9yX2VhY2hfcHJlc2VudF9jcHUoY3B1KQogCQkJc2VxX3ByaW50ZihwLCAiJTEwdSAiLCBrc3RhdF9pcnFzX2NwdShpLCBjcHUpKTsKLQkJc2VxX3ByaW50ZihwLCAiICUxMHMiLCBkZXNjLT5jaGlwLT5uYW1lID8gOiAiLSIpOworCQlzZXFfcHJpbnRmKHAsICIgJTEwcyIsIGRlc2MtPmlycV9kYXRhLmNoaXAtPm5hbWUgPyA6ICItIik7CiAJCXNlcV9wcmludGYocCwgIiAgJXMiLCBhY3Rpb24tPm5hbWUpOwogCQlmb3IgKGFjdGlvbiA9IGFjdGlvbi0+bmV4dDsgYWN0aW9uOyBhY3Rpb24gPSBhY3Rpb24tPm5leHQpCiAJCQlzZXFfcHJpbnRmKHAsICIsICVzIiwgYWN0aW9uLT5uYW1lKTsKQEAgLTE4MSwxMCArMTgxLDExIEBACiAKIHN0YXRpYyB2b2lkIHJvdXRlX2lycShzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MsIHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCBjcHUpCiB7Ci0JcHJfZGVidWcoIklSUSV1OiBtb3ZpbmcgZnJvbSBjcHUldSB0byBjcHUldVxuIiwgaXJxLCBkZXNjLT5ub2RlLCBjcHUpOworCXByX2RlYnVnKCJJUlEldTogbW92aW5nIGZyb20gY3B1JXUgdG8gY3B1JXVcbiIsIGlycSwgZGVzYy0+aXJxX2RhdGEubm9kZSwgY3B1KTsKIAogCXJhd19zcGluX2xvY2tfaXJxKCZkZXNjLT5sb2NrKTsKLQlkZXNjLT5jaGlwLT5zZXRfYWZmaW5pdHkoaXJxLCBjcHVtYXNrX29mKGNwdSkpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9zZXRfYWZmaW5pdHkoJmRlc2MtPmlycV9kYXRhLAorCQkJCQkgICAgICBjcHVtYXNrX29mKGNwdSksIGZhbHNlKTsKIAlyYXdfc3Bpbl91bmxvY2tfaXJxKCZkZXNjLT5sb2NrKTsKIH0KIApAQCAtMTk5LDE2ICsyMDAsMTggQEAKIAlzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2M7CiAKIAlmb3JfZWFjaF9pcnFfZGVzYyhpLCBkZXNjKSB7Ci0JCWlmIChkZXNjLT5ub2RlID09IGNwdSkgewotCQkJdW5zaWduZWQgaW50IG5ld2NwdSA9IGNwdW1hc2tfYW55X2FuZChkZXNjLT5hZmZpbml0eSwKKwkJc3RydWN0IGlycV9kYXRhICpkID0gJmRlc2MtPmlycV9kYXRhOworCisJCWlmIChkLT5ub2RlID09IGNwdSkgeworCQkJdW5zaWduZWQgaW50IG5ld2NwdSA9IGNwdW1hc2tfYW55X2FuZChkLT5hZmZpbml0eSwKIAkJCQkJCQkgICAgICBjcHVfb25saW5lX21hc2spOwogCQkJaWYgKG5ld2NwdSA+PSBucl9jcHVfaWRzKSB7CiAJCQkJaWYgKHByaW50a19yYXRlbGltaXQoKSkKIAkJCQkJcHJpbnRrKEtFUk5fSU5GTyAiSVJRJXUgbm8gbG9uZ2VyIGFmZmluZSB0byBDUFUldVxuIiwKIAkJCQkJICAgICAgIGksIGNwdSk7CiAKLQkJCQljcHVtYXNrX3NldGFsbChkZXNjLT5hZmZpbml0eSk7Ci0JCQkJbmV3Y3B1ID0gY3B1bWFza19hbnlfYW5kKGRlc2MtPmFmZmluaXR5LAorCQkJCWNwdW1hc2tfc2V0YWxsKGQtPmFmZmluaXR5KTsKKwkJCQluZXdjcHUgPSBjcHVtYXNrX2FueV9hbmQoZC0+YWZmaW5pdHksCiAJCQkJCQkJIGNwdV9vbmxpbmVfbWFzayk7CiAJCQl9CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2tlcm5lbC9tb2R1bGUuYyBiL2FyY2gvYXJtL2tlcm5lbC9tb2R1bGUuYwppbmRleCAwYzFiYjY4Li4yY2ZlODE2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9rZXJuZWwvbW9kdWxlLmMKKysrIGIvYXJjaC9hcm0va2VybmVsL21vZHVsZS5jCkBAIC0zOCwxNyArMzgsOSBAQAogI2lmZGVmIENPTkZJR19NTVUKIHZvaWQgKm1vZHVsZV9hbGxvYyh1bnNpZ25lZCBsb25nIHNpemUpCiB7Ci0Jc3RydWN0IHZtX3N0cnVjdCAqYXJlYTsKLQotCXNpemUgPSBQQUdFX0FMSUdOKHNpemUpOwotCWlmICghc2l6ZSkKLQkJcmV0dXJuIE5VTEw7Ci0KLQlhcmVhID0gX19nZXRfdm1fYXJlYShzaXplLCBWTV9BTExPQywgTU9EVUxFU19WQUREUiwgTU9EVUxFU19FTkQpOwotCWlmICghYXJlYSkKLQkJcmV0dXJuIE5VTEw7Ci0KLQlyZXR1cm4gX192bWFsbG9jX2FyZWEoYXJlYSwgR0ZQX0tFUk5FTCwgUEFHRV9LRVJORUxfRVhFQyk7CisJcmV0dXJuIF9fdm1hbGxvY19ub2RlX3JhbmdlKHNpemUsIDEsIE1PRFVMRVNfVkFERFIsIE1PRFVMRVNfRU5ELAorCQkJCUdGUF9LRVJORUwsIFBBR0VfS0VSTkVMX0VYRUMsIC0xLAorCQkJCV9fYnVpbHRpbl9yZXR1cm5fYWRkcmVzcygwKSk7CiB9CiAjZWxzZSAvKiBDT05GSUdfTU1VICovCiB2b2lkICptb2R1bGVfYWxsb2ModW5zaWduZWQgbG9uZyBzaXplKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va2VybmVsL3Byb2Nlc3MuYyBiL2FyY2gvYXJtL2tlcm5lbC9wcm9jZXNzLmMKaW5kZXggZTc2ZmNhYS4uOTRiYmVkYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0va2VybmVsL3Byb2Nlc3MuYworKysgYi9hcmNoL2FybS9rZXJuZWwvcHJvY2Vzcy5jCkBAIC00ODMsNiArNDgzLDcgQEAKIAlyZXR1cm4gcmFuZG9taXplX3JhbmdlKG1tLT5icmssIHJhbmdlX2VuZCwgMCkgPyA6IG1tLT5icms7CiB9CiAKKyNpZmRlZiBDT05GSUdfTU1VCiAvKgogICogVGhlIHZlY3RvcnMgcGFnZSBpcyBhbHdheXMgcmVhZGFibGUgZnJvbSB1c2VyIHNwYWNlIGZvciB0aGUKICAqIGF0b21pYyBoZWxwZXJzIGFuZCB0aGUgc2lnbmFsIHJlc3RhcnQgY29kZS4gIExldCdzIGRlY2xhcmUgYSBtYXBwaW5nCkBAIC01MDMsMyArNTA0LDQgQEAKIHsKIAlyZXR1cm4gKHZtYS0+dm1fc3RhcnQgPT0gMHhmZmZmMDAwMCkgPyAiW3ZlY3RvcnNdIiA6IE5VTEw7CiB9CisjZW5kaWYKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2tlcm5lbC9zY2hlZF9jbG9jay5jIGIvYXJjaC9hcm0va2VybmVsL3NjaGVkX2Nsb2NrLmMKaW5kZXggMmNkY2M5Mi4uOWE0NjM3MCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0va2VybmVsL3NjaGVkX2Nsb2NrLmMKKysrIGIvYXJjaC9hcm0va2VybmVsL3NjaGVkX2Nsb2NrLmMKQEAgLTM0LDcgKzM0LDcgQEAKIAlzY2hlZF9jbG9ja191cGRhdGVfZm4gPSB1cGRhdGU7CiAKIAkvKiBjYWxjdWxhdGUgdGhlIG11bHQvc2hpZnQgdG8gY29udmVydCBjb3VudGVyIHRpY2tzIHRvIG5zLiAqLwotCWNsb2Nrc19jYWxjX211bHRfc2hpZnQoJmNkLT5tdWx0LCAmY2QtPnNoaWZ0LCByYXRlLCBOU0VDX1BFUl9TRUMsIDYwKTsKKwljbG9ja3NfY2FsY19tdWx0X3NoaWZ0KCZjZC0+bXVsdCwgJmNkLT5zaGlmdCwgcmF0ZSwgTlNFQ19QRVJfU0VDLCAwKTsKIAogCXIgPSByYXRlOwogCWlmIChyID49IDQwMDAwMDApIHsKQEAgLTYwLDEwICs2MCwxNSBAQAogCSAqIHNldHMgdGhlIGluaXRpYWwgZXBvY2guCiAJICovCiAJc2NoZWRfY2xvY2tfdGltZXIuZGF0YSA9IG1zZWNzX3RvX2ppZmZpZXModyAtICh3IC8gMTApKTsKLQlzY2hlZF9jbG9ja19wb2xsKHNjaGVkX2Nsb2NrX3RpbWVyLmRhdGEpOworCXVwZGF0ZSgpOwogCiAJLyoKIAkgKiBFbnN1cmUgdGhhdCBzY2hlZF9jbG9jaygpIHN0YXJ0cyBvZmYgYXQgMG5zCiAJICovCiAJY2QtPmVwb2NoX25zID0gMDsKIH0KKwordm9pZCBfX2luaXQgc2NoZWRfY2xvY2tfcG9zdGluaXQodm9pZCkKK3sKKwlzY2hlZF9jbG9ja19wb2xsKHNjaGVkX2Nsb2NrX3RpbWVyLmRhdGEpOworfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va2VybmVsL3NldHVwLmMgYi9hcmNoL2FybS9rZXJuZWwvc2V0dXAuYwppbmRleCAzNDU1YWQzLi40MjBiOGQ2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9rZXJuZWwvc2V0dXAuYworKysgYi9hcmNoL2FybS9rZXJuZWwvc2V0dXAuYwpAQCAtNTE4LDI1ICs1MTgsMjEgQEAKICNlbmRpZgogfQogCi1zdGF0aWMgdm9pZCBfX2luaXQKLXJlcXVlc3Rfc3RhbmRhcmRfcmVzb3VyY2VzKHN0cnVjdCBtZW1pbmZvICptaSwgc3RydWN0IG1hY2hpbmVfZGVzYyAqbWRlc2MpCitzdGF0aWMgdm9pZCBfX2luaXQgcmVxdWVzdF9zdGFuZGFyZF9yZXNvdXJjZXMoc3RydWN0IG1hY2hpbmVfZGVzYyAqbWRlc2MpCiB7CisJc3RydWN0IG1lbWJsb2NrX3JlZ2lvbiAqcmVnaW9uOwogCXN0cnVjdCByZXNvdXJjZSAqcmVzOwotCWludCBpOwogCiAJa2VybmVsX2NvZGUuc3RhcnQgICA9IHZpcnRfdG9fcGh5cyhfdGV4dCk7CiAJa2VybmVsX2NvZGUuZW5kICAgICA9IHZpcnRfdG9fcGh5cyhfZXRleHQgLSAxKTsKIAlrZXJuZWxfZGF0YS5zdGFydCAgID0gdmlydF90b19waHlzKF9zZGF0YSk7CiAJa2VybmVsX2RhdGEuZW5kICAgICA9IHZpcnRfdG9fcGh5cyhfZW5kIC0gMSk7CiAKLQlmb3IgKGkgPSAwOyBpIDwgbWktPm5yX2JhbmtzOyBpKyspIHsKLQkJaWYgKG1pLT5iYW5rW2ldLnNpemUgPT0gMCkKLQkJCWNvbnRpbnVlOwotCisJZm9yX2VhY2hfbWVtYmxvY2sobWVtb3J5LCByZWdpb24pIHsKIAkJcmVzID0gYWxsb2NfYm9vdG1lbV9sb3coc2l6ZW9mKCpyZXMpKTsKIAkJcmVzLT5uYW1lICA9ICJTeXN0ZW0gUkFNIjsKLQkJcmVzLT5zdGFydCA9IG1pLT5iYW5rW2ldLnN0YXJ0OwotCQlyZXMtPmVuZCAgID0gbWktPmJhbmtbaV0uc3RhcnQgKyBtaS0+YmFua1tpXS5zaXplIC0gMTsKKwkJcmVzLT5zdGFydCA9IF9fcGZuX3RvX3BoeXMobWVtYmxvY2tfcmVnaW9uX21lbW9yeV9iYXNlX3BmbihyZWdpb24pKTsKKwkJcmVzLT5lbmQgPSBfX3Bmbl90b19waHlzKG1lbWJsb2NrX3JlZ2lvbl9tZW1vcnlfZW5kX3BmbihyZWdpb24pKSAtIDE7CiAJCXJlcy0+ZmxhZ3MgPSBJT1JFU09VUkNFX01FTSB8IElPUkVTT1VSQ0VfQlVTWTsKIAogCQlyZXF1ZXN0X3Jlc291cmNlKCZpb21lbV9yZXNvdXJjZSwgcmVzKTsKQEAgLTY1MCwxNSArNjQ2LDE3IEBACiAKIF9fdGFndGFibGUoQVRBR19SRVZJU0lPTiwgcGFyc2VfdGFnX3JldmlzaW9uKTsKIAotI2lmbmRlZiBDT05GSUdfQ01ETElORV9GT1JDRQogc3RhdGljIGludCBfX2luaXQgcGFyc2VfdGFnX2NtZGxpbmUoY29uc3Qgc3RydWN0IHRhZyAqdGFnKQogeworI2lmbmRlZiBDT05GSUdfQ01ETElORV9GT1JDRQogCXN0cmxjcHkoZGVmYXVsdF9jb21tYW5kX2xpbmUsIHRhZy0+dS5jbWRsaW5lLmNtZGxpbmUsIENPTU1BTkRfTElORV9TSVpFKTsKKyNlbHNlCisJcHJfd2FybmluZygiSWdub3JpbmcgdGFnIGNtZGxpbmUgKHVzaW5nIHRoZSBkZWZhdWx0IGtlcm5lbCBjb21tYW5kIGxpbmUpXG4iKTsKKyNlbmRpZiAvKiBDT05GSUdfQ01ETElORV9GT1JDRSAqLwogCXJldHVybiAwOwogfQogCiBfX3RhZ3RhYmxlKEFUQUdfQ01ETElORSwgcGFyc2VfdGFnX2NtZGxpbmUpOwotI2VuZGlmIC8qIENPTkZJR19DTURMSU5FX0ZPUkNFICovCiAKIC8qCiAgKiBTY2FuIHRoZSB0YWcgdGFibGUgZm9yIHRoaXMgdGFnLCBhbmQgY2FsbCBpdHMgcGFyc2UgZnVuY3Rpb24uCkBAIC04NTcsNyArODU1LDcgQEAKIAlhcm1fbWVtYmxvY2tfaW5pdCgmbWVtaW5mbywgbWRlc2MpOwogCiAJcGFnaW5nX2luaXQobWRlc2MpOwotCXJlcXVlc3Rfc3RhbmRhcmRfcmVzb3VyY2VzKCZtZW1pbmZvLCBtZGVzYyk7CisJcmVxdWVzdF9zdGFuZGFyZF9yZXNvdXJjZXMobWRlc2MpOwogCiAjaWZkZWYgQ09ORklHX1NNUAogCWlmIChpc19zbXAoKSkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2tlcm5lbC9zbXBfdHdkLmMgYi9hcmNoL2FybS9rZXJuZWwvc21wX3R3ZC5jCmluZGV4IGRkNzkwNzQuLjYwNjM2ZjQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2tlcm5lbC9zbXBfdHdkLmMKKysrIGIvYXJjaC9hcm0va2VybmVsL3NtcF90d2QuYwpAQCAtMzYsNiArMzYsNyBAQAogCQkvKiB0aW1lciBsb2FkIGFscmVhZHkgc2V0IHVwICovCiAJCWN0cmwgPSBUV0RfVElNRVJfQ09OVFJPTF9FTkFCTEUgfCBUV0RfVElNRVJfQ09OVFJPTF9JVF9FTkFCTEUKIAkJCXwgVFdEX1RJTUVSX0NPTlRST0xfUEVSSU9ESUM7CisJCV9fcmF3X3dyaXRlbCh0d2RfdGltZXJfcmF0ZSAvIEhaLCB0d2RfYmFzZSArIFRXRF9USU1FUl9MT0FEKTsKIAkJYnJlYWs7CiAJY2FzZSBDTE9DS19FVlRfTU9ERV9PTkVTSE9UOgogCQkvKiBwZXJpb2Qgc2V0LCBhbmQgdGltZXIgZW5hYmxlZCBpbiAnbmV4dF9ldmVudCcgaG9vayAqLwpAQCAtODEsNyArODIsNyBAQAogCiBzdGF0aWMgdm9pZCBfX2NwdWluaXQgdHdkX2NhbGlicmF0ZV9yYXRlKHZvaWQpCiB7Ci0JdW5zaWduZWQgbG9uZyBsb2FkLCBjb3VudDsKKwl1bnNpZ25lZCBsb25nIGNvdW50OwogCXU2NCB3YWl0amlmZmllczsKIAogCS8qCkBAIC0xMTQsMTIgKzExNSw4IEBACiAJCXR3ZF90aW1lcl9yYXRlID0gKDB4RkZGRkZGRkZVIC0gY291bnQpICogKEhaIC8gNSk7CiAKIAkJcHJpbnRrKCIlbHUuJTAybHVNSHouXG4iLCB0d2RfdGltZXJfcmF0ZSAvIDEwMDAwMDAsCi0JCQkodHdkX3RpbWVyX3JhdGUgLyAxMDAwMDApICUgMTAwKTsKKwkJCSh0d2RfdGltZXJfcmF0ZSAvIDEwMDAwMDApICUgMTAwKTsKIAl9Ci0KLQlsb2FkID0gdHdkX3RpbWVyX3JhdGUgLyBIWjsKLQotCV9fcmF3X3dyaXRlbChsb2FkLCB0d2RfYmFzZSArIFRXRF9USU1FUl9MT0FEKTsKIH0KIAogLyoKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2tlcm5lbC9zdGFja3RyYWNlLmMgYi9hcmNoL2FybS9rZXJuZWwvc3RhY2t0cmFjZS5jCmluZGV4IGMyZTExMmUuLjM4MWQyM2EgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2tlcm5lbC9zdGFja3RyYWNlLmMKKysrIGIvYXJjaC9hcm0va2VybmVsL3N0YWNrdHJhY2UuYwpAQCAtOTQsMTAgKzk0LDEzIEBACiAJaWYgKHRzayAhPSBjdXJyZW50KSB7CiAjaWZkZWYgQ09ORklHX1NNUAogCQkvKgotCQkgKiBXaGF0IGd1YXJhbnRlZXMgZG8gd2UgaGF2ZSBoZXJlIHRoYXQgJ3RzaycKLQkJICogaXMgbm90IHJ1bm5pbmcgb24gYW5vdGhlciBDUFU/CisJCSAqIFdoYXQgZ3VhcmFudGVlcyBkbyB3ZSBoYXZlIGhlcmUgdGhhdCAndHNrJyBpcyBub3QKKwkJICogcnVubmluZyBvbiBhbm90aGVyIENQVT8gIEZvciBub3csIGlnbm9yZSBpdCBhcyB3ZQorCQkgKiBjYW4ndCBndWFyYW50ZWUgd2Ugd29uJ3QgZXhwbG9kZS4KIAkJICovCi0JCUJVRygpOworCQlpZiAodHJhY2UtPm5yX2VudHJpZXMgPCB0cmFjZS0+bWF4X2VudHJpZXMpCisJCQl0cmFjZS0+ZW50cmllc1t0cmFjZS0+bnJfZW50cmllcysrXSA9IFVMT05HX01BWDsKKwkJcmV0dXJuOwogI2Vsc2UKIAkJZGF0YS5ub19zY2hlZF9mdW5jdGlvbnMgPSAxOwogCQlmcmFtZS5mcCA9IHRocmVhZF9zYXZlZF9mcCh0c2spOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va2VybmVsL3RpbWUuYyBiL2FyY2gvYXJtL2tlcm5lbC90aW1lLmMKaW5kZXggZjFlMmViMS4uM2Q3NmJmMiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0va2VybmVsL3RpbWUuYworKysgYi9hcmNoL2FybS9rZXJuZWwvdGltZS5jCkBAIC0yOSw2ICsyOSw3IEBACiAKICNpbmNsdWRlIDxhc20vbGVkcy5oPgogI2luY2x1ZGUgPGFzbS90aHJlYWRfaW5mby5oPgorI2luY2x1ZGUgPGFzbS9zY2hlZF9jbG9jay5oPgogI2luY2x1ZGUgPGFzbS9zdGFja3RyYWNlLmg+CiAjaW5jbHVkZSA8YXNtL21hY2gvYXJjaC5oPgogI2luY2x1ZGUgPGFzbS9tYWNoL3RpbWUuaD4KQEAgLTE2Myw1ICsxNjQsOCBAQAogewogCXN5c3RlbV90aW1lciA9IG1hY2hpbmVfZGVzYy0+dGltZXI7CiAJc3lzdGVtX3RpbWVyLT5pbml0KCk7CisjaWZkZWYgQ09ORklHX0hBVkVfU0NIRURfQ0xPQ0sKKwlzY2hlZF9jbG9ja19wb3N0aW5pdCgpOworI2VuZGlmCiB9CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2xpYi9kZWxheS5TIGIvYXJjaC9hcm0vbGliL2RlbGF5LlMKaW5kZXggOGQ2YTg3Ni4uM2M5YTA1YyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbGliL2RlbGF5LlMKKysrIGIvYXJjaC9hcm0vbGliL2RlbGF5LlMKQEAgLTI1LDExICsyNSwxNSBAQAogCQlsZHIJcjIsIC5MQzEKIAkJbXVsCXIwLCByMiwgcjAKIEVOVFJZKF9fY29uc3RfdWRlbGF5KQkJCQlAIDAgPD0gcjAgPD0gMHg3ZmZmZmYwNgorCQltb3YJcjEsICMtMQogCQlsZHIJcjIsIC5MQzAKIAkJbGRyCXIyLCBbcjJdCQlAIG1heCA9IDB4MDFmZmZmZmYKKwkJYWRkCXIwLCByMCwgcjEsIGxzciAjMzItMTQKIAkJbW92CXIwLCByMCwgbHNyICMxNAkJQCBtYXggPSAweDAwMDFmZmZmCisJCWFkZAlyMiwgcjIsIHIxLCBsc3IgIzMyLTEwCiAJCW1vdglyMiwgcjIsIGxzciAjMTAJCUAgbWF4ID0gMHgwMDAwN2ZmZgogCQltdWwJcjAsIHIyLCByMAkJQCBtYXggPSAyXjMyLTEKKwkJYWRkCXIwLCByMCwgcjEsIGxzciAjMzItNgogCQltb3ZzCXIwLCByMCwgbHNyICM2CiAJCW1vdmVxCXBjLCBscgogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWFhZWMyMDAwL2NvcmUuYyBiL2FyY2gvYXJtL21hY2gtYWFlYzIwMDAvY29yZS5jCmluZGV4IDNlZjY4MzMuLmY4NDY1YmQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtYWFlYzIwMDAvY29yZS5jCisrKyBiL2FyY2gvYXJtL21hY2gtYWFlYzIwMDAvY29yZS5jCkBAIC02OCwyNSArNjgsMjUgQEAKIC8qCiAgKiBJbnRlcnJ1cHQgaGFuZGxpbmcgcm91dGluZXMKICAqLwotc3RhdGljIHZvaWQgYWFlYzIwMDBfaW50X2Fjayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgYWFlYzIwMDBfaW50X2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JSVJRX0lOVFNSID0gMSA8PCBpcnE7CisJSVJRX0lOVFNSID0gMSA8PCBkLT5pcnE7CiB9CiAKLXN0YXRpYyB2b2lkIGFhZWMyMDAwX2ludF9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBhYWVjMjAwMF9pbnRfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JSVJRX0lOVEVOQyB8PSAoMSA8PCBpcnEpOworCUlSUV9JTlRFTkMgfD0gKDEgPDwgZC0+aXJxKTsKIH0KIAotc3RhdGljIHZvaWQgYWFlYzIwMDBfaW50X3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgYWFlYzIwMDBfaW50X3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JSVJRX0lOVEVOUyB8PSAoMSA8PCBpcnEpOworCUlSUV9JTlRFTlMgfD0gKDEgPDwgZC0+aXJxKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBhYWVjMjAwMF9pcnFfY2hpcCA9IHsKLQkuYWNrCT0gYWFlYzIwMDBfaW50X2FjaywKLQkubWFzawk9IGFhZWMyMDAwX2ludF9tYXNrLAotCS51bm1hc2sJPSBhYWVjMjAwMF9pbnRfdW5tYXNrLAorCS5pcnFfYWNrCT0gYWFlYzIwMDBfaW50X2FjaywKKwkuaXJxX21hc2sJPSBhYWVjMjAwMF9pbnRfbWFzaywKKwkuaXJxX3VubWFzawk9IGFhZWMyMDAwX2ludF91bm1hc2ssCiB9OwogCiB2b2lkIF9faW5pdCBhYWVjMjAwMF9pbml0X2lycSh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1hdDkxL0tjb25maWcgYi9hcmNoL2FybS9tYWNoLWF0OTEvS2NvbmZpZwppbmRleCBjMDE1YjY4Li4xOTM5MDIzIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWF0OTEvS2NvbmZpZworKysgYi9hcmNoL2FybS9tYWNoLWF0OTEvS2NvbmZpZwpAQCAtMzYyLDYgKzM2MiwxMiBAQAogCSAgU2VsZWN0IHRoaXMgaWYgeW91IGFyZSB1c2luZyBhIEV1a3JlYSBFbGVjdHJvbWF0aXF1ZSdzCiAJICBDUFU5RzIwIEJvYXJkIDxodHRwOi8vd3d3LmV1a3JlYS5jb20vPgogCitjb25maWcgTUFDSF9BQ01FTkVUVVNGT1hHMjAKKwlib29sICJBY21lIFN5c3RlbXMgc3JsIEZPWCBCb2FyZCBHMjAiCisJaGVscAorCSAgU2VsZWN0IHRoaXMgaWYgeW91IGFyZSB1c2luZyBBY21lIFN5c3RlbXMKKwkgIEZPWCBCb2FyZCBHMjAgPGh0dHA6Ly93d3cuYWNtZXN5c3RlbXMuaXQ+CisKIGNvbmZpZyBNQUNIX1BPUlRVWEcyMAogCWJvb2wgInRhc2tpdCBQb3J0dXhHMjAiCiAJaGVscApAQCAtMzgxLDYgKzM4NywxMyBAQAogCSAgU2VsZWN0IHRoaXMgaWYgeW91IGFyZSB1c2luZyB0YXNraXQncyBTdGFtcDlHMjAgQ1BVIG1vZHVsZSBvbiB0aGlzCiAJICBjYXJyaWVyIGJvYXJkLCBiZWVpbmcgdGhlIGRlY2VudHJhbGl6ZWQgdW5pdCBvZiBhIGJ1aWxkaW5nIGF1dG9tYXRpb24KIAkgIHN5c3RlbTsgZmVhdHVyaW5nIG52cmFtLCBldGgtc3dpdGNoLCBpc28tcnM0ODUsIGRpc3BsYXksIGlvCisKK2NvbmZpZyBNQUNIX0dTSUExOFMKKwlib29sICJHU19JQTE4X1MgYm9hcmQiCisJaGVscAorCSAgVGhpcyBlbmFibGVzIHN1cHBvcnQgZm9yIHRoZSBHU19JQTE4X1MgYm9hcmQKKwkgIHByb2R1Y2VkIGJ5IEdlb1NJRyBMdGQgY29tcGFueS4gVGhpcyBpcyBhbiBpbnRlcm5ldCBhY2NlbGVyb2dyYXBoLgorCSAgPGh0dHA6Ly93d3cuZ2Vvc2lnLmNvbT4KIGVuZGlmCiAKIGlmIChBUkNIX0FUOTFTQU05MjYwIHx8IEFSQ0hfQVQ5MVNBTTlHMjApCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWF0OTEvTWFrZWZpbGUgYi9hcmNoL2FybS9tYWNoLWF0OTEvTWFrZWZpbGUKaW5kZXggZDEzYWRkNy4uYTgzODM1ZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1hdDkxL01ha2VmaWxlCisrKyBiL2FyY2gvYXJtL21hY2gtYXQ5MS9NYWtlZmlsZQpAQCAtNjMsOSArNjMsMTEgQEAKICMgQVQ5MVNBTTlHMjAgYm9hcmQtc3BlY2lmaWMgc3VwcG9ydAogb2JqLSQoQ09ORklHX01BQ0hfQVQ5MVNBTTlHMjBFSykgKz0gYm9hcmQtc2FtOWcyMGVrLm8KIG9iai0kKENPTkZJR19NQUNIX0NQVTlHMjApCSs9IGJvYXJkLWNwdTlrcmVhLm8KK29iai0kKENPTkZJR19NQUNIX0FDTUVORVRVU0ZPWEcyMCkgKz0gYm9hcmQtZm94ZzIwLm8KIG9iai0kKENPTkZJR19NQUNIX1NUQU1QOUcyMCkJKz0gYm9hcmQtc3RhbXA5ZzIwLm8KIG9iai0kKENPTkZJR19NQUNIX1BPUlRVWEcyMCkJKz0gYm9hcmQtc3RhbXA5ZzIwLm8KIG9iai0kKENPTkZJR19NQUNIX1BDT05UUk9MX0cyMCkJKz0gYm9hcmQtcGNvbnRyb2wtZzIwLm8gYm9hcmQtc3RhbXA5ZzIwLm8KK29iai0kKENPTkZJR19NQUNIX0dTSUExOFMpCSs9IGJvYXJkLWdzaWExOHMubyBib2FyZC1zdGFtcDlnMjAubwogCiAjIEFUOTFTQU05MjYwL0FUOTFTQU05RzIwIGJvYXJkLXNwZWNpZmljIHN1cHBvcnQKIG9iai0kKENPTkZJR19NQUNIX1NOQVBQRVJfOTI2MCkJKz0gYm9hcmQtc25hcHBlcjkyNjAubwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1hdDkxL2JvYXJkLWZveGcyMC5jIGIvYXJjaC9hcm0vbWFjaC1hdDkxL2JvYXJkLWZveGcyMC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmRmYzdkZmUKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL2FybS9tYWNoLWF0OTEvYm9hcmQtZm94ZzIwLmMKQEAgLTAsMCArMSwyNzQgQEAKKy8qCisgKiAgQ29weXJpZ2h0IChDKSAyMDA1IFNBTiBQZW9wbGUKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDggQXRtZWwKKyAqICBDb3B5cmlnaHQgKEMpIDIwMTAgTGVlIE1jTG91Z2hsaW4gLSBsZWVAbG1tcnRlY2guY29tCisgKiAgQ29weXJpZ2h0IChDKSAyMDEwIFNlcmdpbyBUYW56aWxsaSAtIHRhbnppbGxpQGFjbWVzeXN0ZW1zLml0CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgIDAyMTExLTEzMDcgIFVTQQorICovCisKKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9tbS5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NwaS9zcGkuaD4KKyNpbmNsdWRlIDxsaW51eC9zcGkvYXQ3M2MyMTMuaD4KKyNpbmNsdWRlIDxsaW51eC9ncGlvLmg+CisjaW5jbHVkZSA8bGludXgvZ3Bpb19rZXlzLmg+CisjaW5jbHVkZSA8bGludXgvaW5wdXQuaD4KKyNpbmNsdWRlIDxsaW51eC9jbGsuaD4KKyNpbmNsdWRlIDxsaW51eC93MS1ncGlvLmg+CisKKyNpbmNsdWRlIDxtYWNoL2hhcmR3YXJlLmg+CisjaW5jbHVkZSA8YXNtL3NldHVwLmg+CisjaW5jbHVkZSA8YXNtL21hY2gtdHlwZXMuaD4KKyNpbmNsdWRlIDxhc20vaXJxLmg+CisKKyNpbmNsdWRlIDxhc20vbWFjaC9hcmNoLmg+CisjaW5jbHVkZSA8YXNtL21hY2gvbWFwLmg+CisjaW5jbHVkZSA8YXNtL21hY2gvaXJxLmg+CisKKyNpbmNsdWRlIDxtYWNoL2JvYXJkLmg+CisjaW5jbHVkZSA8bWFjaC9hdDkxc2FtOV9zbWMuaD4KKworI2luY2x1ZGUgInNhbTlfc21jLmgiCisjaW5jbHVkZSAiZ2VuZXJpYy5oIgorCisvKgorICogVGhlIEZPWCBCb2FyZCBHMjAgaGFyZHdhcmUgY29tZXMgYXMgdGhlICJOZXR1cyBHMjAiIGJvYXJkIHdpdGgKKyAqIGp1c3QgdGhlIGNwdSwgcmFtLCBkYXRhZmxhc2ggYW5kIHR3byBoZWFkZXIgY29ubmVjdG9ycy4KKyAqIFRoaXMgaXMgcGx1Z2dlZCBpbnRvIHRoZSBGT1ggQm9hcmQgd2hpY2ggcHJvdmlkZXMgdGhlIGV0aGVybmV0LAorICogdXNiLCBydGMsIGxlZHMsIHN3aXRjaCwgLi4uCisgKgorICogRm9yIG1vcmUgaW5mbyB2aXNpdDogaHR0cDovL3d3dy5hY21lc3lzdGVtcy5pdC9mb3hnMjAKKyAqLworCisKK3N0YXRpYyB2b2lkIF9faW5pdCBmb3hnMjBfbWFwX2lvKHZvaWQpCit7CisJLyogSW5pdGlhbGl6ZSBwcm9jZXNzb3I6IDE4LjQzMiBNSHogY3J5c3RhbCAqLworCWF0OTFzYW05MjYwX2luaXRpYWxpemUoMTg0MzIwMDApOworCisJLyogREJHVSBvbiB0dHlTMC4gKFJ4ICYgVHggb25seSkgKi8KKwlhdDkxX3JlZ2lzdGVyX3VhcnQoMCwgMCwgMCk7CisKKwkvKiBVU0FSVDAgb24gdHR5UzEuIChSeCwgVHgsIENUUywgUlRTLCBEVFIsIERTUiwgRENELCBSSSkgKi8KKwlhdDkxX3JlZ2lzdGVyX3VhcnQoQVQ5MVNBTTkyNjBfSURfVVMwLCAxLAorCQkJCUFUTUVMX1VBUlRfQ1RTCisJCQkJfCBBVE1FTF9VQVJUX1JUUworCQkJCXwgQVRNRUxfVUFSVF9EVFIKKwkJCQl8IEFUTUVMX1VBUlRfRFNSCisJCQkJfCBBVE1FTF9VQVJUX0RDRAorCQkJCXwgQVRNRUxfVUFSVF9SSSk7CisKKwkvKiBVU0FSVDEgb24gdHR5UzIuIChSeCwgVHgsIFJUUywgQ1RTKSAqLworCWF0OTFfcmVnaXN0ZXJfdWFydChBVDkxU0FNOTI2MF9JRF9VUzEsIDIsCisJCUFUTUVMX1VBUlRfQ1RTCisJCXwgQVRNRUxfVUFSVF9SVFMpOworCisJLyogVVNBUlQyIG9uIHR0eVMzLiAoUnggJiBUeCBvbmx5KSAqLworCWF0OTFfcmVnaXN0ZXJfdWFydChBVDkxU0FNOTI2MF9JRF9VUzIsIDMsIDApOworCisJLyogVVNBUlQzIG9uIHR0eVM0LiAoUngsIFR4LCBSVFMsIENUUykgKi8KKwlhdDkxX3JlZ2lzdGVyX3VhcnQoQVQ5MVNBTTkyNjBfSURfVVMzLCA0LAorCQlBVE1FTF9VQVJUX0NUUworCQl8IEFUTUVMX1VBUlRfUlRTKTsKKworCS8qIFVTQVJUNCBvbiB0dHlTNS4gKFJ4ICYgVHggb25seSkgKi8KKwlhdDkxX3JlZ2lzdGVyX3VhcnQoQVQ5MVNBTTkyNjBfSURfVVM0LCA1LCAwKTsKKworCS8qIFVTQVJUNSBvbiB0dHlTNi4gKFJ4ICYgVHggb25seSkgKi8KKwlhdDkxX3JlZ2lzdGVyX3VhcnQoQVQ5MVNBTTkyNjBfSURfVVM1LCA2LCAwKTsKKworCS8qIHNldCBzZXJpYWwgY29uc29sZSB0byB0dHlTMCAoaWUsIERCR1UpICovCisJYXQ5MV9zZXRfc2VyaWFsX2NvbnNvbGUoMCk7CisKKwkvKiBTZXQgdGhlIGludGVybmFsIHB1bGwtdXAgcmVzaXN0b3Igb24gRFJYRCAqLworCWF0OTFfc2V0X0FfcGVyaXBoKEFUOTFfUElOX1BCMTQsIDEpOworCit9CisKK3N0YXRpYyB2b2lkIF9faW5pdCBmb3hnMjBfaW5pdF9pcnEodm9pZCkKK3sKKwlhdDkxc2FtOTI2MF9pbml0X2ludGVycnVwdHMoTlVMTCk7Cit9CisKKworLyoKKyAqIFVTQiBIb3N0IHBvcnQKKyAqLworc3RhdGljIHN0cnVjdCBhdDkxX3VzYmhfZGF0YSBfX2luaXRkYXRhIGZveGcyMF91c2JoX2RhdGEgPSB7CisJLnBvcnRzCQk9IDIsCit9OworCisvKgorICogVVNCIERldmljZSBwb3J0CisgKi8KK3N0YXRpYyBzdHJ1Y3QgYXQ5MV91ZGNfZGF0YSBfX2luaXRkYXRhIGZveGcyMF91ZGNfZGF0YSA9IHsKKwkudmJ1c19waW4JPSBBVDkxX1BJTl9QQzYsCisJLnB1bGx1cF9waW4JPSAwLAkJLyogcHVsbC11cCBkcml2ZW4gYnkgVURDICovCit9OworCisKKy8qCisgKiBTUEkgZGV2aWNlcy4KKyAqLworc3RhdGljIHN0cnVjdCBzcGlfYm9hcmRfaW5mbyBmb3hnMjBfc3BpX2RldmljZXNbXSA9IHsKKyNpZiAhZGVmaW5lZChDT05GSUdfTU1DX0FUOTEpCisJeworCQkubW9kYWxpYXMJPSAibXRkX2RhdGFmbGFzaCIsCisJCS5jaGlwX3NlbGVjdAk9IDEsCisJCS5tYXhfc3BlZWRfaHoJPSAxNSAqIDEwMDAgKiAxMDAwLAorCQkuYnVzX251bQk9IDAsCisJfSwKKyNlbmRpZgorfTsKKworCisvKgorICogTUFDQiBFdGhlcm5ldCBkZXZpY2UKKyAqLworc3RhdGljIHN0cnVjdCBhdDkxX2V0aF9kYXRhIF9faW5pdGRhdGEgZm94ZzIwX21hY2JfZGF0YSA9IHsKKwkucGh5X2lycV9waW4JPSBBVDkxX1BJTl9QQTcsCisJLmlzX3JtaWkJPSAxLAorfTsKKworLyoKKyAqIE1DSSAoU0QvTU1DKQorICogZGV0X3Bpbiwgd3BfcGluIGFuZCB2Y2NfcGluIGFyZSBub3QgY29ubmVjdGVkCisgKi8KK3N0YXRpYyBzdHJ1Y3QgYXQ5MV9tbWNfZGF0YSBfX2luaXRkYXRhIGZveGcyMF9tbWNfZGF0YSA9IHsKKwkuc2xvdF9iCQk9IDEsCisJLndpcmU0CQk9IDEsCit9OworCisKKy8qCisgKiBMRURzCisgKi8KK3N0YXRpYyBzdHJ1Y3QgZ3Bpb19sZWQgZm94ZzIwX2xlZHNbXSA9IHsKKwl7CS8qIHVzZXIgbGVkLCByZWQgKi8KKwkJLm5hbWUJCQk9ICJ1c2VyX2xlZCIsCisJCS5ncGlvCQkJPSBBVDkxX1BJTl9QQzcsCisJCS5hY3RpdmVfbG93CQk9IDAsCisJCS5kZWZhdWx0X3RyaWdnZXIJPSAiaGVhcnRiZWF0IiwKKwl9LAorfTsKKworCisvKgorICogR1BJTyBCdXR0b25zCisgKi8KKyNpZiBkZWZpbmVkKENPTkZJR19LRVlCT0FSRF9HUElPKSB8fCBkZWZpbmVkKENPTkZJR19LRVlCT0FSRF9HUElPX01PRFVMRSkKK3N0YXRpYyBzdHJ1Y3QgZ3Bpb19rZXlzX2J1dHRvbiBmb3hnMjBfYnV0dG9uc1tdID0geworCXsKKwkJLmdwaW8JCT0gQVQ5MV9QSU5fUEM0LAorCQkuY29kZQkJPSBCVE5fMSwKKwkJLmRlc2MJCT0gIkJ1dHRvbiAxIiwKKwkJLmFjdGl2ZV9sb3cJPSAxLAorCQkud2FrZXVwCQk9IDEsCisJfSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgZ3Bpb19rZXlzX3BsYXRmb3JtX2RhdGEgZm94ZzIwX2J1dHRvbl9kYXRhID0geworCS5idXR0b25zCT0gZm94ZzIwX2J1dHRvbnMsCisJLm5idXR0b25zCT0gQVJSQVlfU0laRShmb3hnMjBfYnV0dG9ucyksCit9OworCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSBmb3hnMjBfYnV0dG9uX2RldmljZSA9IHsKKwkubmFtZQkJPSAiZ3Bpby1rZXlzIiwKKwkuaWQJCT0gLTEsCisJLm51bV9yZXNvdXJjZXMJPSAwLAorCS5kZXYJCT0geworCQkucGxhdGZvcm1fZGF0YQk9ICZmb3hnMjBfYnV0dG9uX2RhdGEsCisJfQorfTsKKworc3RhdGljIHZvaWQgX19pbml0IGZveGcyMF9hZGRfZGV2aWNlX2J1dHRvbnModm9pZCkKK3sKKwlhdDkxX3NldF9ncGlvX2lucHV0KEFUOTFfUElOX1BDNCwgMSk7CS8qIGJ0bjEgKi8KKwlhdDkxX3NldF9kZWdsaXRjaChBVDkxX1BJTl9QQzQsIDEpOworCisJcGxhdGZvcm1fZGV2aWNlX3JlZ2lzdGVyKCZmb3hnMjBfYnV0dG9uX2RldmljZSk7Cit9CisjZWxzZQorc3RhdGljIHZvaWQgX19pbml0IGZveGcyMF9hZGRfZGV2aWNlX2J1dHRvbnModm9pZCkge30KKyNlbmRpZgorCisKKyNpZiBkZWZpbmVkKENPTkZJR19XMV9NQVNURVJfR1BJTykgfHwgZGVmaW5lZChDT05GSUdfVzFfTUFTVEVSX0dQSU9fTU9EVUxFKQorc3RhdGljIHN0cnVjdCB3MV9ncGlvX3BsYXRmb3JtX2RhdGEgdzFfZ3Bpb19wZGF0YSA9IHsKKwkvKiBJZiB5b3UgY2hvb3NlIHRvIHVzZSBhIHBpbiBvdGhlciB0aGFuIFBCMTYgaXQgbmVlZHMgdG8gYmUgMy4zViAqLworCS5waW4JCT0gQVQ5MV9QSU5fUEIxNiwKKwkuaXNfb3Blbl9kcmFpbiAgPSAxLAorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgdzFfZGV2aWNlID0geworCS5uYW1lCQkJPSAidzEtZ3BpbyIsCisJLmlkCQkJPSAtMSwKKwkuZGV2LnBsYXRmb3JtX2RhdGEJPSAmdzFfZ3Bpb19wZGF0YSwKK307CisKK3N0YXRpYyB2b2lkIF9faW5pdCBhdDkxX2FkZF9kZXZpY2VfdzEodm9pZCkKK3sKKwlhdDkxX3NldF9HUElPX3BlcmlwaCh3MV9ncGlvX3BkYXRhLnBpbiwgMSk7CisJYXQ5MV9zZXRfbXVsdGlfZHJpdmUodzFfZ3Bpb19wZGF0YS5waW4sIDEpOworCXBsYXRmb3JtX2RldmljZV9yZWdpc3RlcigmdzFfZGV2aWNlKTsKK30KKworI2VuZGlmCisKKworc3RhdGljIHN0cnVjdCBpMmNfYm9hcmRfaW5mbyBfX2luaXRkYXRhIGZveGcyMF9pMmNfZGV2aWNlc1tdID0geworCXsKKwkJSTJDX0JPQVJEX0lORk8oIjI0YzUxMiIsIDB4NTApLAorCX0sCit9OworCisKK3N0YXRpYyB2b2lkIF9faW5pdCBmb3hnMjBfYm9hcmRfaW5pdCh2b2lkKQoreworCS8qIFNlcmlhbCAqLworCWF0OTFfYWRkX2RldmljZV9zZXJpYWwoKTsKKwkvKiBVU0IgSG9zdCAqLworCWF0OTFfYWRkX2RldmljZV91c2JoKCZmb3hnMjBfdXNiaF9kYXRhKTsKKwkvKiBVU0IgRGV2aWNlICovCisJYXQ5MV9hZGRfZGV2aWNlX3VkYygmZm94ZzIwX3VkY19kYXRhKTsKKwkvKiBTUEkgKi8KKwlhdDkxX2FkZF9kZXZpY2Vfc3BpKGZveGcyMF9zcGlfZGV2aWNlcywgQVJSQVlfU0laRShmb3hnMjBfc3BpX2RldmljZXMpKTsKKwkvKiBFdGhlcm5ldCAqLworCWF0OTFfYWRkX2RldmljZV9ldGgoJmZveGcyMF9tYWNiX2RhdGEpOworCS8qIE1NQyAqLworCWF0OTFfYWRkX2RldmljZV9tbWMoMCwgJmZveGcyMF9tbWNfZGF0YSk7CisJLyogSTJDICovCisJYXQ5MV9hZGRfZGV2aWNlX2kyYyhmb3hnMjBfaTJjX2RldmljZXMsIEFSUkFZX1NJWkUoZm94ZzIwX2kyY19kZXZpY2VzKSk7CisJLyogTEVEcyAqLworCWF0OTFfZ3Bpb19sZWRzKGZveGcyMF9sZWRzLCBBUlJBWV9TSVpFKGZveGcyMF9sZWRzKSk7CisJLyogUHVzaCBCdXR0b25zICovCisJZm94ZzIwX2FkZF9kZXZpY2VfYnV0dG9ucygpOworI2lmIGRlZmluZWQoQ09ORklHX1cxX01BU1RFUl9HUElPKSB8fCBkZWZpbmVkKENPTkZJR19XMV9NQVNURVJfR1BJT19NT0RVTEUpCisJYXQ5MV9hZGRfZGV2aWNlX3cxKCk7CisjZW5kaWYKK30KKworTUFDSElORV9TVEFSVChBQ01FTkVUVVNGT1hHMjAsICJBY21lIFN5c3RlbXMgc3JsIEZPWCBCb2FyZCBHMjAiKQorCS8qIE1haW50YWluZXI6IFNlcmdpbyBUYW56aWxsaSAqLworCS5ib290X3BhcmFtcwk9IEFUOTFfU0RSQU1fQkFTRSArIDB4MTAwLAorCS50aW1lcgkJPSAmYXQ5MXNhbTkyNnhfdGltZXIsCisJLm1hcF9pbwkJPSBmb3hnMjBfbWFwX2lvLAorCS5pbml0X2lycQk9IGZveGcyMF9pbml0X2lycSwKKwkuaW5pdF9tYWNoaW5lCT0gZm94ZzIwX2JvYXJkX2luaXQsCitNQUNISU5FX0VORApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1hdDkxL2JvYXJkLWdzaWExOHMuYyBiL2FyY2gvYXJtL21hY2gtYXQ5MS9ib2FyZC1nc2lhMThzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYmMyODEzNgotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvYXJtL21hY2gtYXQ5MS9ib2FyZC1nc2lhMThzLmMKQEAgLTAsMCArMSw1ODQgQEAKKy8qCisgKiAgQ29weXJpZ2h0IChDKSAyMDEwIENocmlzdGlhbiBHbGluZGthbXAgPGNocmlzdGlhbi5nbGluZGthbXBAdGFza2l0LmRlPgorICogICAgICAgICAgICAgICAgICAgICB0YXNraXQgR21iSAorICogICAgICAgICAgICAgICAgMjAxMCBJZ29yIFBseWF0b3YgPHBseWF0b3ZAZ21haWwuY29tPgorICogICAgICAgICAgICAgICAgICAgICBHZW9TSUcgTHRkCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgIDAyMTExLTEzMDcgIFVTQQorICovCisKKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9ncGlvLmg+CisjaW5jbHVkZSA8bGludXgvdzEtZ3Bpby5oPgorI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgorI2luY2x1ZGUgPGxpbnV4L2kyYy9wY2Y4NTd4Lmg+CisjaW5jbHVkZSA8bGludXgvZ3Bpb19rZXlzLmg+CisjaW5jbHVkZSA8bGludXgvaW5wdXQuaD4KKworI2luY2x1ZGUgPGFzbS9tYWNoLXR5cGVzLmg+CisjaW5jbHVkZSA8YXNtL21hY2gvYXJjaC5oPgorCisjaW5jbHVkZSA8bWFjaC9ib2FyZC5oPgorI2luY2x1ZGUgPG1hY2gvYXQ5MXNhbTlfc21jLmg+CisjaW5jbHVkZSA8bWFjaC9nc2lhMThzLmg+CisjaW5jbHVkZSA8bWFjaC9zdGFtcDlnMjAuaD4KKworI2luY2x1ZGUgInNhbTlfc21jLmgiCisjaW5jbHVkZSAiZ2VuZXJpYy5oIgorCitzdGF0aWMgdm9pZCBfX2luaXQgZ3NpYTE4c19tYXBfaW8odm9pZCkKK3sKKwlzdGFtcDlnMjBfbWFwX2lvKCk7CisKKwkvKgorCSAqIFVTQVJUMCBvbiB0dHlTMSAoUngsIFR4LCBDVFMsIFJUUywgRFRSLCBEU1IsIERDRCwgUkkpLgorCSAqIFVzZWQgZm9yIEludGVybmFsIEFuYWxvZyBNb2RlbS4KKwkgKi8KKwlhdDkxX3JlZ2lzdGVyX3VhcnQoQVQ5MVNBTTkyNjBfSURfVVMwLCAxLAorCQkJCUFUTUVMX1VBUlRfQ1RTIHwgQVRNRUxfVUFSVF9SVFMgfAorCQkJCUFUTUVMX1VBUlRfRFRSIHwgQVRNRUxfVUFSVF9EU1IgfAorCQkJCUFUTUVMX1VBUlRfRENEIHwgQVRNRUxfVUFSVF9SSSk7CisJLyoKKwkgKiBVU0FSVDEgb24gdHR5UzIgKFJ4LCBUeCwgQ1RTLCBSVFMpLgorCSAqIFVzZWQgZm9yIEdQUyBvciBXaUZpIG9yIERhdGEgc3RyZWFtLgorCSAqLworCWF0OTFfcmVnaXN0ZXJfdWFydChBVDkxU0FNOTI2MF9JRF9VUzEsIDIsCisJCQkJQVRNRUxfVUFSVF9DVFMgfCBBVE1FTF9VQVJUX1JUUyk7CisJLyoKKwkgKiBVU0FSVDIgb24gdHR5UzMgKFJ4LCBUeCwgQ1RTLCBSVFMpLgorCSAqIFVzZWQgZm9yIEV4dGVybmFsIE1vZGVtLgorCSAqLworCWF0OTFfcmVnaXN0ZXJfdWFydChBVDkxU0FNOTI2MF9JRF9VUzIsIDMsCisJCQkJQVRNRUxfVUFSVF9DVFMgfCBBVE1FTF9VQVJUX1JUUyk7CisJLyoKKwkgKiBVU0FSVDMgb24gdHR5UzQgKFJ4LCBUeCwgUlRTKS4KKwkgKiBVc2VkIGZvciBSUy00ODUuCisJICovCisJYXQ5MV9yZWdpc3Rlcl91YXJ0KEFUOTFTQU05MjYwX0lEX1VTMywgNCwgQVRNRUxfVUFSVF9SVFMpOworCisJLyoKKwkgKiBVU0FSVDQgb24gdHR5UzUgKFJ4LCBUeCkuCisJICogVXNlZCBmb3IgVFJYNDMzIFJhZGlvIE1vZHVsZS4KKwkgKi8KKwlhdDkxX3JlZ2lzdGVyX3VhcnQoQVQ5MVNBTTkyNjBfSURfVVM0LCA1LCAwKTsKK30KKworc3RhdGljIHZvaWQgX19pbml0IGluaXRfaXJxKHZvaWQpCit7CisJYXQ5MXNhbTkyNjBfaW5pdF9pbnRlcnJ1cHRzKE5VTEwpOworfQorCisvKgorICogVHdvIFVTQiBIb3N0IHBvcnRzCisgKi8KK3N0YXRpYyBzdHJ1Y3QgYXQ5MV91c2JoX2RhdGEgX19pbml0ZGF0YSB1c2JoX2RhdGEgPSB7CisJLnBvcnRzCQk9IDIsCit9OworCisvKgorICogVVNCIERldmljZSBwb3J0CisgKi8KK3N0YXRpYyBzdHJ1Y3QgYXQ5MV91ZGNfZGF0YSBfX2luaXRkYXRhIHVkY19kYXRhID0geworCS52YnVzX3Bpbgk9IEFUOTFfUElOX1BBMjIsCisJLnB1bGx1cF9waW4JPSAwLAkJLyogcHVsbC11cCBkcml2ZW4gYnkgVURDICovCit9OworCisvKgorICogTUFDQiBFdGhlcm5ldCBkZXZpY2UKKyAqLworc3RhdGljIHN0cnVjdCBhdDkxX2V0aF9kYXRhIF9faW5pdGRhdGEgbWFjYl9kYXRhID0geworCS5waHlfaXJxX3Bpbgk9IEFUOTFfUElOX1BBMjgsCisJLmlzX3JtaWkJPSAxLAorfTsKKworLyoKKyAqIExFRHMgYW5kIEdQT3MKKyAqLworc3RhdGljIHN0cnVjdCBncGlvX2xlZCBncGlvX2xlZHNbXSA9IHsKKwl7CisJCS5uYW1lCQkJPSAiZ3BvOnNwaTFyZXNldCIsCisJCS5ncGlvCQkJPSBBVDkxX1BJTl9QQzEsCisJCS5hY3RpdmVfbG93CQk9IDAsCisJCS5kZWZhdWx0X3RyaWdnZXIJPSAibm9uZSIsCisJCS5kZWZhdWx0X3N0YXRlCQk9IExFRFNfR1BJT19ERUZTVEFURV9PRkYsCisJfSwKKwl7CisJCS5uYW1lCQkJPSAiZ3BvOnRyaWdfbmV0X291dCIsCisJCS5ncGlvCQkJPSBBVDkxX1BJTl9QQjIwLAorCQkuYWN0aXZlX2xvdwkJPSAwLAorCQkuZGVmYXVsdF90cmlnZ2VyCT0gIm5vbmUiLAorCQkuZGVmYXVsdF9zdGF0ZQkJPSBMRURTX0dQSU9fREVGU1RBVEVfT0ZGLAorCX0sCisJeworCQkubmFtZQkJCT0gImdwbzp0cmlnX25ldF9kaXIiLAorCQkuZ3BpbwkJCT0gQVQ5MV9QSU5fUEIxOSwKKwkJLmFjdGl2ZV9sb3cJCT0gMCwKKwkJLmRlZmF1bHRfdHJpZ2dlcgk9ICJub25lIiwKKwkJLmRlZmF1bHRfc3RhdGUJCT0gTEVEU19HUElPX0RFRlNUQVRFX09GRiwKKwl9LAorCXsKKwkJLm5hbWUJCQk9ICJncG86Y2hhcmdlX2RpcyIsCisJCS5ncGlvCQkJPSBBVDkxX1BJTl9QQzIsCisJCS5hY3RpdmVfbG93CQk9IDAsCisJCS5kZWZhdWx0X3RyaWdnZXIJPSAibm9uZSIsCisJCS5kZWZhdWx0X3N0YXRlCQk9IExFRFNfR1BJT19ERUZTVEFURV9PRkYsCisJfSwKKwl7CisJCS5uYW1lCQkJPSAibGVkOmV2ZW50IiwKKwkJLmdwaW8JCQk9IEFUOTFfUElOX1BCMTcsCisJCS5hY3RpdmVfbG93CQk9IDEsCisJCS5kZWZhdWx0X3RyaWdnZXIJPSAibm9uZSIsCisJCS5kZWZhdWx0X3N0YXRlCQk9IExFRFNfR1BJT19ERUZTVEFURV9PRkYsCisJfSwKKwl7CisJCS5uYW1lCQkJPSAibGVkOmxhbiIsCisJCS5ncGlvCQkJPSBBVDkxX1BJTl9QQjE4LAorCQkuYWN0aXZlX2xvdwkJPSAxLAorCQkuZGVmYXVsdF90cmlnZ2VyCT0gIm5vbmUiLAorCQkuZGVmYXVsdF9zdGF0ZQkJPSBMRURTX0dQSU9fREVGU1RBVEVfT0ZGLAorCX0sCisJeworCQkubmFtZQkJCT0gImxlZDplcnJvciIsCisJCS5ncGlvCQkJPSBBVDkxX1BJTl9QQjE2LAorCQkuYWN0aXZlX2xvdwkJPSAxLAorCQkuZGVmYXVsdF90cmlnZ2VyCT0gIm5vbmUiLAorCQkuZGVmYXVsdF9zdGF0ZQkJPSBMRURTX0dQSU9fREVGU1RBVEVfT04sCisJfQorfTsKKworc3RhdGljIHN0cnVjdCBncGlvX2xlZF9wbGF0Zm9ybV9kYXRhIGdwaW9fbGVkX2luZm8gPSB7CisJLmxlZHMJCT0gZ3Bpb19sZWRzLAorCS5udW1fbGVkcwk9IEFSUkFZX1NJWkUoZ3Bpb19sZWRzKSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGxlZHMgPSB7CisJLm5hbWUJPSAibGVkcy1ncGlvIiwKKwkuaWQJPSAwLAorCS5kZXYJPSB7CisJCS5wbGF0Zm9ybV9kYXRhCT0gJmdwaW9fbGVkX2luZm8sCisJfQorfTsKKworc3RhdGljIHZvaWQgX19pbml0IGdzaWExOHNfbGVkc19pbml0KHZvaWQpCit7CisJcGxhdGZvcm1fZGV2aWNlX3JlZ2lzdGVyKCZsZWRzKTsKK30KKworLyogUENGODU3NCAweDIwIEdQSU8gLSBVMSBvbiB0aGUgR1NfSUExOC1DQl9WMyBib2FyZCAqLworc3RhdGljIHN0cnVjdCBncGlvX2xlZCBwY2ZfZ3Bpb19sZWRzMVtdID0geworCXsgLyogYml0IDAgKi8KKwkJLm5hbWUJCQk9ICJncG86aGRjX3Bvd2VyIiwKKwkJLmdwaW8JCQk9IFBDRl9HUElPX0hEQ19QT1dFUiwKKwkJLmFjdGl2ZV9sb3cJCT0gMCwKKwkJLmRlZmF1bHRfdHJpZ2dlcgk9ICJub25lIiwKKwkJLmRlZmF1bHRfc3RhdGUJCT0gTEVEU19HUElPX0RFRlNUQVRFX09GRiwKKwl9LAorCXsgLyogYml0IDEgKi8KKwkJLm5hbWUJCQk9ICJncG86d2lmaV9zZXR1cCIsCisJCS5ncGlvCQkJPSBQQ0ZfR1BJT19XSUZJX1NFVFVQLAorCQkuYWN0aXZlX2xvdwkJPSAxLAorCQkuZGVmYXVsdF90cmlnZ2VyCT0gIm5vbmUiLAorCQkuZGVmYXVsdF9zdGF0ZQkJPSBMRURTX0dQSU9fREVGU1RBVEVfT0ZGLAorCX0sCisJeyAvKiBiaXQgMiAqLworCQkubmFtZQkJCT0gImdwbzp3aWZpX2VuYWJsZSIsCisJCS5ncGlvCQkJPSBQQ0ZfR1BJT19XSUZJX0VOQUJMRSwKKwkJLmFjdGl2ZV9sb3cJCT0gMSwKKwkJLmRlZmF1bHRfdHJpZ2dlcgk9ICJub25lIiwKKwkJLmRlZmF1bHRfc3RhdGUJCT0gTEVEU19HUElPX0RFRlNUQVRFX09GRiwKKwl9LAorCXsgLyogYml0IDMJKi8KKwkJLm5hbWUJCQk9ICJncG86d2lmaV9yZXNldCIsCisJCS5ncGlvCQkJPSBQQ0ZfR1BJT19XSUZJX1JFU0VULAorCQkuYWN0aXZlX2xvdwkJPSAxLAorCQkuZGVmYXVsdF90cmlnZ2VyCT0gIm5vbmUiLAorCQkuZGVmYXVsdF9zdGF0ZQkJPSBMRURTX0dQSU9fREVGU1RBVEVfT04sCisJfSwKKwkvKiBiaXQgNCB1c2VkIGFzIEdQSQkqLworCXsgLyogYml0IDUgKi8KKwkJLm5hbWUJCQk9ICJncG86Z3BzX3NldHVwIiwKKwkJLmdwaW8JCQk9IFBDRl9HUElPX0dQU19TRVRVUCwKKwkJLmFjdGl2ZV9sb3cJCT0gMSwKKwkJLmRlZmF1bHRfdHJpZ2dlcgk9ICJub25lIiwKKwkJLmRlZmF1bHRfc3RhdGUJCT0gTEVEU19HUElPX0RFRlNUQVRFX09GRiwKKwl9LAorCXsgLyogYml0IDYgKi8KKwkJLm5hbWUJCQk9ICJncG86Z3BzX3N0YW5kYnkiLAorCQkuZ3BpbwkJCT0gUENGX0dQSU9fR1BTX1NUQU5EQlksCisJCS5hY3RpdmVfbG93CQk9IDAsCisJCS5kZWZhdWx0X3RyaWdnZXIJPSAibm9uZSIsCisJCS5kZWZhdWx0X3N0YXRlCQk9IExFRFNfR1BJT19ERUZTVEFURV9PTiwKKwl9LAorCXsgLyogYml0IDcgKi8KKwkJLm5hbWUJCQk9ICJncG86Z3BzX3Bvd2VyIiwKKwkJLmdwaW8JCQk9IFBDRl9HUElPX0dQU19QT1dFUiwKKwkJLmFjdGl2ZV9sb3cJCT0gMCwKKwkJLmRlZmF1bHRfdHJpZ2dlcgk9ICJub25lIiwKKwkJLmRlZmF1bHRfc3RhdGUJCT0gTEVEU19HUElPX0RFRlNUQVRFX09GRiwKKwl9Cit9OworCitzdGF0aWMgc3RydWN0IGdwaW9fbGVkX3BsYXRmb3JtX2RhdGEgcGNmX2dwaW9fbGVkX2luZm8xID0geworCS5sZWRzCQk9IHBjZl9ncGlvX2xlZHMxLAorCS5udW1fbGVkcwk9IEFSUkFZX1NJWkUocGNmX2dwaW9fbGVkczEpLAorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgcGNmX2xlZHMxID0geworCS5uYW1lCT0gImxlZHMtZ3BpbyIsIC8qIEdTX0lBMTgtQ0JfYm9hcmQgKi8KKwkuaWQJPSAxLAorCS5kZXYJPSB7CisJCS5wbGF0Zm9ybV9kYXRhCT0gJnBjZl9ncGlvX2xlZF9pbmZvMSwKKwl9Cit9OworCisvKiBQQ0Y4NTc0IDB4MjIgR1BJTyAtIFUxIG9uIHRoZSBHU18yR19PUFQxLUFfVjAgYm9hcmQgKEFsYXJtKSAqLworc3RhdGljIHN0cnVjdCBncGlvX2xlZCBwY2ZfZ3Bpb19sZWRzMltdID0geworCXsgLyogYml0IDAgKi8KKwkJLm5hbWUJCQk9ICJncG86YWxhcm1fMSIsCisJCS5ncGlvCQkJPSBQQ0ZfR1BJT19BTEFSTTEsCisJCS5hY3RpdmVfbG93CQk9IDEsCisJCS5kZWZhdWx0X3RyaWdnZXIJPSAibm9uZSIsCisJCS5kZWZhdWx0X3N0YXRlCQk9IExFRFNfR1BJT19ERUZTVEFURV9PRkYsCisJfSwKKwl7IC8qIGJpdCAxICovCisJCS5uYW1lCQkJPSAiZ3BvOmFsYXJtXzIiLAorCQkuZ3BpbwkJCT0gUENGX0dQSU9fQUxBUk0yLAorCQkuYWN0aXZlX2xvdwkJPSAxLAorCQkuZGVmYXVsdF90cmlnZ2VyCT0gIm5vbmUiLAorCQkuZGVmYXVsdF9zdGF0ZQkJPSBMRURTX0dQSU9fREVGU1RBVEVfT0ZGLAorCX0sCisJeyAvKiBiaXQgMiAqLworCQkubmFtZQkJCT0gImdwbzphbGFybV8zIiwKKwkJLmdwaW8JCQk9IFBDRl9HUElPX0FMQVJNMywKKwkJLmFjdGl2ZV9sb3cJCT0gMSwKKwkJLmRlZmF1bHRfdHJpZ2dlcgk9ICJub25lIiwKKwkJLmRlZmF1bHRfc3RhdGUJCT0gTEVEU19HUElPX0RFRlNUQVRFX09GRiwKKwl9LAorCXsgLyogYml0IDMgKi8KKwkJLm5hbWUJCQk9ICJncG86YWxhcm1fNCIsCisJCS5ncGlvCQkJPSBQQ0ZfR1BJT19BTEFSTTQsCisJCS5hY3RpdmVfbG93CQk9IDEsCisJCS5kZWZhdWx0X3RyaWdnZXIJPSAibm9uZSIsCisJCS5kZWZhdWx0X3N0YXRlCQk9IExFRFNfR1BJT19ERUZTVEFURV9PRkYsCisJfSwKKwkvKiBiaXRzIDQsIDUsIDYgbm90IHVzZWQgKi8KKwl7IC8qIGJpdCA3ICovCisJCS5uYW1lCQkJPSAiZ3BvOmFsYXJtX3ZfcmVsYXlfb24iLAorCQkuZ3BpbwkJCT0gUENGX0dQSU9fQUxBUk1fVl9SRUxBWV9PTiwKKwkJLmFjdGl2ZV9sb3cJCT0gMCwKKwkJLmRlZmF1bHRfdHJpZ2dlcgk9ICJub25lIiwKKwkJLmRlZmF1bHRfc3RhdGUJCT0gTEVEU19HUElPX0RFRlNUQVRFX09GRiwKKwl9LAorfTsKKworc3RhdGljIHN0cnVjdCBncGlvX2xlZF9wbGF0Zm9ybV9kYXRhIHBjZl9ncGlvX2xlZF9pbmZvMiA9IHsKKwkubGVkcwkJPSBwY2ZfZ3Bpb19sZWRzMiwKKwkubnVtX2xlZHMJPSBBUlJBWV9TSVpFKHBjZl9ncGlvX2xlZHMyKSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIHBjZl9sZWRzMiA9IHsKKwkubmFtZQk9ICJsZWRzLWdwaW8iLAorCS5pZAk9IDIsCisJLmRldgk9IHsKKwkJLnBsYXRmb3JtX2RhdGEJPSAmcGNmX2dwaW9fbGVkX2luZm8yLAorCX0KK307CisKKy8qIFBDRjg1NzQgMHgyNCBHUElPIFUxIG9uIHRoZSBHU18yRy1PUFQyMy1BX1YwIGJvYXJkIChNb2RlbSkgKi8KK3N0YXRpYyBzdHJ1Y3QgZ3Bpb19sZWQgcGNmX2dwaW9fbGVkczNbXSA9IHsKKwl7IC8qIGJpdCAwICovCisJCS5uYW1lCQkJPSAiZ3BvOm1vZGVtX3Bvd2VyIiwKKwkJLmdwaW8JCQk9IFBDRl9HUElPX01PREVNX1BPV0VSLAorCQkuYWN0aXZlX2xvdwkJPSAxLAorCQkuZGVmYXVsdF90cmlnZ2VyCT0gIm5vbmUiLAorCQkuZGVmYXVsdF9zdGF0ZQkJPSBMRURTX0dQSU9fREVGU1RBVEVfT0ZGLAorCX0sCisJCS8qIGJpdHMgMSBhbmQgMiBub3QgdXNlZCAqLworCXsgLyogYml0IDMgKi8KKwkJLm5hbWUJCQk9ICJncG86bW9kZW1fcmVzZXQiLAorCQkuZ3BpbwkJCT0gUENGX0dQSU9fTU9ERU1fUkVTRVQsCisJCS5hY3RpdmVfbG93CQk9IDEsCisJCS5kZWZhdWx0X3RyaWdnZXIJPSAibm9uZSIsCisJCS5kZWZhdWx0X3N0YXRlCQk9IExFRFNfR1BJT19ERUZTVEFURV9PTiwKKwl9LAorCQkvKiBiaXRzIDQsIDUgYW5kIDYgbm90IHVzZWQgKi8KKwl7IC8qIGJpdCA3ICovCisJCS5uYW1lCQkJPSAiZ3BvOnRyeF9yZXNldCIsCisJCS5ncGlvCQkJPSBQQ0ZfR1BJT19UUlhfUkVTRVQsCisJCS5hY3RpdmVfbG93CQk9IDEsCisJCS5kZWZhdWx0X3RyaWdnZXIJPSAibm9uZSIsCisJCS5kZWZhdWx0X3N0YXRlCQk9IExFRFNfR1BJT19ERUZTVEFURV9PTiwKKwl9Cit9OworCitzdGF0aWMgc3RydWN0IGdwaW9fbGVkX3BsYXRmb3JtX2RhdGEgcGNmX2dwaW9fbGVkX2luZm8zID0geworCS5sZWRzCQk9IHBjZl9ncGlvX2xlZHMzLAorCS5udW1fbGVkcwk9IEFSUkFZX1NJWkUocGNmX2dwaW9fbGVkczMpLAorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgcGNmX2xlZHMzID0geworCS5uYW1lCT0gImxlZHMtZ3BpbyIsCisJLmlkCT0gMywKKwkuZGV2CT0geworCQkucGxhdGZvcm1fZGF0YQk9ICZwY2ZfZ3Bpb19sZWRfaW5mbzMsCisJfQorfTsKKworc3RhdGljIHZvaWQgX19pbml0IGdzaWExOHNfcGNmX2xlZHNfaW5pdCh2b2lkKQoreworCXBsYXRmb3JtX2RldmljZV9yZWdpc3RlcigmcGNmX2xlZHMxKTsKKwlwbGF0Zm9ybV9kZXZpY2VfcmVnaXN0ZXIoJnBjZl9sZWRzMik7CisJcGxhdGZvcm1fZGV2aWNlX3JlZ2lzdGVyKCZwY2ZfbGVkczMpOworfQorCisvKgorICogU1BJIGJ1c3Nlcy4KKyAqLworc3RhdGljIHN0cnVjdCBzcGlfYm9hcmRfaW5mbyBnc2lhMThzX3NwaV9kZXZpY2VzW10gPSB7CisJeyAvKiBVc2VyIGFjY2Vzc2libGUgc3BpMCwgY3MwIHVzZWQgZm9yIGNvbW11bmljYXRpb24gd2l0aCBNU1AgUlRDICovCisJCS5tb2RhbGlhcwk9ICJzcGlkZXYiLAorCQkuYnVzX251bQk9IDAsCisJCS5jaGlwX3NlbGVjdAk9IDAsCisJCS5tYXhfc3BlZWRfaHoJPSA1ODAwMDAsCisJCS5tb2RlCQk9IFNQSV9NT0RFXzEsCisJfSwKKwl7IC8qIFVzZXIgYWNjZXNzaWJsZSBzcGkxLCBjczAgdXNlZCBmb3IgY29tbXVuaWNhdGlvbiB3aXRoIGludC4gRFNQICovCisJCS5tb2RhbGlhcwk9ICJzcGlkZXYiLAorCQkuYnVzX251bQk9IDEsCisJCS5jaGlwX3NlbGVjdAk9IDAsCisJCS5tYXhfc3BlZWRfaHoJPSA1NjAwMDAwLAorCQkubW9kZQkJPSBTUElfTU9ERV8wLAorCX0sCisJeyAvKiBVc2VyIGFjY2Vzc2libGUgc3BpMSwgY3MxIHVzZWQgZm9yIGNvbW11bmljYXRpb24gd2l0aCBleHQuIERTUCAqLworCQkubW9kYWxpYXMJPSAic3BpZGV2IiwKKwkJLmJ1c19udW0JPSAxLAorCQkuY2hpcF9zZWxlY3QJPSAxLAorCQkubWF4X3NwZWVkX2h6CT0gNTYwMDAwMCwKKwkJLm1vZGUJCT0gU1BJX01PREVfMCwKKwl9LAorCXsgLyogVXNlciBhY2Nlc3NpYmxlIHNwaTEsIGNzMiB1c2VkIGZvciBjb21tdW5pY2F0aW9uIHdpdGggZXh0LiBEU1AgKi8KKwkJLm1vZGFsaWFzCT0gInNwaWRldiIsCisJCS5idXNfbnVtCT0gMSwKKwkJLmNoaXBfc2VsZWN0CT0gMiwKKwkJLm1heF9zcGVlZF9oegk9IDU2MDAwMDAsCisJCS5tb2RlCQk9IFNQSV9NT0RFXzAsCisJfSwKKwl7IC8qIFVzZXIgYWNjZXNzaWJsZSBzcGkxLCBjczMgdXNlZCBmb3IgY29tbXVuaWNhdGlvbiB3aXRoIGV4dC4gRFNQICovCisJCS5tb2RhbGlhcwk9ICJzcGlkZXYiLAorCQkuYnVzX251bQk9IDEsCisJCS5jaGlwX3NlbGVjdAk9IDMsCisJCS5tYXhfc3BlZWRfaHoJPSA1NjAwMDAwLAorCQkubW9kZQkJPSBTUElfTU9ERV8wLAorCX0KK307CisKKy8qCisgKiBHUEkgQnV0dG9ucworICovCitzdGF0aWMgc3RydWN0IGdwaW9fa2V5c19idXR0b24gYnV0dG9uc1tdID0geworCXsKKwkJLmdwaW8JCT0gR1BJT19UUklHX05FVF9JTiwKKwkJLmNvZGUJCT0gQlROXzEsCisJCS5kZXNjCQk9ICJUUklHX05FVF9JTiIsCisJCS50eXBlCQk9IEVWX0tFWSwKKwkJLmFjdGl2ZV9sb3cJPSAwLAorCQkud2FrZXVwCQk9IDEsCisJfSwKKwl7IC8qIFNXODAgb24gdGhlIEdTX0lBMThfUy1NTiBib2FyZCovCisJCS5ncGlvCQk9IEdQSU9fQ0FSRF9VTk1PVU5UXzAsCisJCS5jb2RlCQk9IEJUTl8yLAorCQkuZGVzYwkJPSAiQ2FyZCB1bW91bnQgMCIsCisJCS50eXBlCQk9IEVWX0tFWSwKKwkJLmFjdGl2ZV9sb3cJPSAxLAorCQkud2FrZXVwCQk9IDEsCisJfSwKKwl7IC8qIFNXNzkgb24gdGhlIEdTX0lBMThfUy1NTiBib2FyZCovCisJCS5ncGlvCQk9IEdQSU9fQ0FSRF9VTk1PVU5UXzEsCisJCS5jb2RlCQk9IEJUTl8zLAorCQkuZGVzYwkJPSAiQ2FyZCB1bW91bnQgMSIsCisJCS50eXBlCQk9IEVWX0tFWSwKKwkJLmFjdGl2ZV9sb3cJPSAxLAorCQkud2FrZXVwCQk9IDEsCisJfSwKKwl7IC8qIFNXMjgwIG9uIHRoZSBHU19JQTE4LUNCIGJvYXJkKi8KKwkJLmdwaW8JCT0gR1BJT19LRVlfUE9XRVIsCisJCS5jb2RlCQk9IEtFWV9QT1dFUiwKKwkJLmRlc2MJCT0gIlBvd2VyIE9mZiBCdXR0b24iLAorCQkudHlwZQkJPSBFVl9LRVksCisJCS5hY3RpdmVfbG93CT0gMCwKKwkJLndha2V1cAkJPSAxLAorCX0KK307CisKK3N0YXRpYyBzdHJ1Y3QgZ3Bpb19rZXlzX3BsYXRmb3JtX2RhdGEgYnV0dG9uX2RhdGEgPSB7CisJLmJ1dHRvbnMJPSBidXR0b25zLAorCS5uYnV0dG9ucwk9IEFSUkFZX1NJWkUoYnV0dG9ucyksCit9OworCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSBidXR0b25fZGV2aWNlID0geworCS5uYW1lCQk9ICJncGlvLWtleXMiLAorCS5pZAkJPSAtMSwKKwkubnVtX3Jlc291cmNlcwk9IDAsCisJLmRldgkJPSB7CisJCS5wbGF0Zm9ybV9kYXRhCT0gJmJ1dHRvbl9kYXRhLAorCX0KK307CisKK3N0YXRpYyB2b2lkIF9faW5pdCBnc2lhMThzX2FkZF9kZXZpY2VfYnV0dG9ucyh2b2lkKQoreworCWF0OTFfc2V0X2dwaW9faW5wdXQoR1BJT19UUklHX05FVF9JTiwgMSk7CisJYXQ5MV9zZXRfZGVnbGl0Y2goR1BJT19UUklHX05FVF9JTiwgMSk7CisJYXQ5MV9zZXRfZ3Bpb19pbnB1dChHUElPX0NBUkRfVU5NT1VOVF8wLCAxKTsKKwlhdDkxX3NldF9kZWdsaXRjaChHUElPX0NBUkRfVU5NT1VOVF8wLCAxKTsKKwlhdDkxX3NldF9ncGlvX2lucHV0KEdQSU9fQ0FSRF9VTk1PVU5UXzEsIDEpOworCWF0OTFfc2V0X2RlZ2xpdGNoKEdQSU9fQ0FSRF9VTk1PVU5UXzEsIDEpOworCWF0OTFfc2V0X2dwaW9faW5wdXQoR1BJT19LRVlfUE9XRVIsIDApOworCWF0OTFfc2V0X2RlZ2xpdGNoKEdQSU9fS0VZX1BPV0VSLCAxKTsKKworCXBsYXRmb3JtX2RldmljZV9yZWdpc3RlcigmYnV0dG9uX2RldmljZSk7Cit9CisKKy8qCisgKiBJMkMKKyAqLworc3RhdGljIGludCBwY2Y4NTc0eF8weDIwX3NldHVwKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsIGludCBncGlvLAorCQkJCXVuc2lnbmVkIGludCBuZ3Bpbywgdm9pZCAqY29udGV4dCkKK3sKKwlpbnQgc3RhdHVzOworCisJc3RhdHVzID0gZ3Bpb19yZXF1ZXN0KGdwaW8gKyBQQ0ZfR1BJT19FVEhfREVURUNULCAiZXRoX2RldCIpOworCWlmIChzdGF0dXMgPCAwKSB7CisJCXByX2VycigiZXJyb3I6IGNhbid0IHJlcXVlc3QgR1BJTyVkXG4iLAorCQkJZ3BpbyArIFBDRl9HUElPX0VUSF9ERVRFQ1QpOworCQlyZXR1cm4gc3RhdHVzOworCX0KKwlzdGF0dXMgPSBncGlvX2RpcmVjdGlvbl9pbnB1dChncGlvICsgUENGX0dQSU9fRVRIX0RFVEVDVCk7CisJaWYgKHN0YXR1cyA8IDApIHsKKwkJcHJfZXJyKCJlcnJvcjogY2FuJ3Qgc2V0dXAgR1BJTyVkIGFzIGlucHV0XG4iLAorCQkJZ3BpbyArIFBDRl9HUElPX0VUSF9ERVRFQ1QpOworCQlyZXR1cm4gc3RhdHVzOworCX0KKwlzdGF0dXMgPSBncGlvX2V4cG9ydChncGlvICsgUENGX0dQSU9fRVRIX0RFVEVDVCwgZmFsc2UpOworCWlmIChzdGF0dXMgPCAwKSB7CisJCXByX2VycigiZXJyb3I6IGNhbid0IGV4cG9ydCBHUElPJWRcbiIsCisJCQlncGlvICsgUENGX0dQSU9fRVRIX0RFVEVDVCk7CisJCXJldHVybiBzdGF0dXM7CisJfQorCXN0YXR1cyA9IGdwaW9fc3lzZnNfc2V0X2FjdGl2ZV9sb3coZ3BpbyArIFBDRl9HUElPX0VUSF9ERVRFQ1QsIDEpOworCWlmIChzdGF0dXMgPCAwKSB7CisJCXByX2VycigiZXJyb3I6IGdwaW9fc3lzZnNfc2V0IGFjdGl2ZV9sb3coR1BJTyVkLCAxKVxuIiwKKwkJCWdwaW8gKyBQQ0ZfR1BJT19FVEhfREVURUNUKTsKKwkJcmV0dXJuIHN0YXR1czsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBwY2Y4NTc0eF8weDIwX3RlYXJkb3duKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsIGludCBncGlvLAorCQkJCQl1bnNpZ25lZCBuZ3Bpbywgdm9pZCAqY29udGV4dCkKK3sKKwlncGlvX2ZyZWUoZ3BpbyArIFBDRl9HUElPX0VUSF9ERVRFQ1QpOworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IHBjZjg1N3hfcGxhdGZvcm1fZGF0YSBwY2YyMF9wZGF0YSA9IHsKKwkuZ3Bpb19iYXNlCT0gR1NfSUExOF9TX1BDRl9HUElPX0JBU0UwLAorCS5uX2xhdGNoCT0gKDEgPDwgNCksCisJLnNldHVwCQk9IHBjZjg1NzR4XzB4MjBfc2V0dXAsCisJLnRlYXJkb3duCT0gcGNmODU3NHhfMHgyMF90ZWFyZG93biwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGNmODU3eF9wbGF0Zm9ybV9kYXRhIHBjZjIyX3BkYXRhID0geworCS5ncGlvX2Jhc2UJPSBHU19JQTE4X1NfUENGX0dQSU9fQkFTRTEsCit9OworCitzdGF0aWMgc3RydWN0IHBjZjg1N3hfcGxhdGZvcm1fZGF0YSBwY2YyNF9wZGF0YSA9IHsKKwkuZ3Bpb19iYXNlCT0gR1NfSUExOF9TX1BDRl9HUElPX0JBU0UyLAorfTsKKworc3RhdGljIHN0cnVjdCBpMmNfYm9hcmRfaW5mbyBfX2luaXRkYXRhIGdzaWExOHNfaTJjX2RldmljZXNbXSA9IHsKKwl7IC8qIFUxIG9uIHRoZSBHU19JQTE4LUNCX1YzIGJvYXJkICovCisJCUkyQ19CT0FSRF9JTkZPKCJwY2Y4NTc0IiwgMHgyMCksCisJCS5wbGF0Zm9ybV9kYXRhID0gJnBjZjIwX3BkYXRhLAorCX0sCisJeyAvKiBVMSBvbiB0aGUgR1NfMkdfT1BUMS1BX1YwIGJvYXJkIChBbGFybSkgKi8KKwkJSTJDX0JPQVJEX0lORk8oInBjZjg1NzQiLCAweDIyKSwKKwkJLnBsYXRmb3JtX2RhdGEgPSAmcGNmMjJfcGRhdGEsCisJfSwKKwl7IC8qIFUxIG9uIHRoZSBHU18yRy1PUFQyMy1BX1YwIGJvYXJkIChNb2RlbSkgKi8KKwkJSTJDX0JPQVJEX0lORk8oInBjZjg1NzQiLCAweDI0KSwKKwkJLnBsYXRmb3JtX2RhdGEgPSAmcGNmMjRfcGRhdGEsCisJfSwKKwl7IC8qIFUxNjEgb24gdGhlIEdTX0lBMThfUy1NTiBib2FyZCAqLworCQlJMkNfQk9BUkRfSU5GTygiMjRjMTAyNCIsIDB4NTApLAorCX0sCisJeyAvKiBVMTYyIG9uIHRoZSBHU19JQTE4X1MtTU4gYm9hcmQgKi8KKwkJSTJDX0JPQVJEX0lORk8oIjI0YzAxIiwgMHg1MyksCisJfSwKK307CisKKy8qCisgKiBDb21wYWN0IEZsYXNoCisgKi8KK3N0YXRpYyBzdHJ1Y3QgYXQ5MV9jZl9kYXRhIF9faW5pdGRhdGEgZ3NpYTE4c19jZjFfZGF0YSA9IHsKKwkuaXJxX3Bpbgk9IEFUOTFfUElOX1BBMjcsCisJLmRldF9waW4JPSBBVDkxX1BJTl9QQjMwLAorCS5yc3RfcGluCT0gQVQ5MV9QSU5fUEIzMSwKKwkuY2hpcHNlbGVjdAk9IDUsCisJLmZsYWdzCQk9IEFUOTFfQ0ZfVFJVRV9JREUsCit9OworCisvKiBQb3dlciBPZmYgYnkgUlRDICovCitzdGF0aWMgdm9pZCBnc2lhMThzX3Bvd2VyX29mZih2b2lkKQoreworCXByX25vdGljZSgiUG93ZXIgc3VwcGx5IHdpbGwgYmUgc3dpdGNoZWQgb2ZmIGF1dG9tYXRpY2FsbHkgbm93IG9yIGFmdGVyIDYwIHNlY29uZHMgd2l0aG91dCBBcm1EQVMuXG4iKTsKKwlhdDkxX3NldF9ncGlvX291dHB1dChBVDkxX1BJTl9QQTI1LCAxKTsKKwkvKiBTcGluIHRvIGRlYXRoLi4uICovCisJd2hpbGUgKDEpCisJCTsKK30KKworc3RhdGljIGludCBfX2luaXQgZ3NpYTE4c19wb3dlcl9vZmZfaW5pdCh2b2lkKQoreworCXBtX3Bvd2VyX29mZiA9IGdzaWExOHNfcG93ZXJfb2ZmOworCXJldHVybiAwOworfQorCisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLworCitzdGF0aWMgdm9pZCBfX2luaXQgZ3NpYTE4c19ib2FyZF9pbml0KHZvaWQpCit7CisJc3RhbXA5ZzIwX2JvYXJkX2luaXQoKTsKKwlhdDkxX2FkZF9kZXZpY2VfdXNiaCgmdXNiaF9kYXRhKTsKKwlhdDkxX2FkZF9kZXZpY2VfdWRjKCZ1ZGNfZGF0YSk7CisJYXQ5MV9hZGRfZGV2aWNlX2V0aCgmbWFjYl9kYXRhKTsKKwlnc2lhMThzX2xlZHNfaW5pdCgpOworCWdzaWExOHNfcGNmX2xlZHNfaW5pdCgpOworCWdzaWExOHNfYWRkX2RldmljZV9idXR0b25zKCk7CisJYXQ5MV9hZGRfZGV2aWNlX2kyYyhnc2lhMThzX2kyY19kZXZpY2VzLAorCQkJCUFSUkFZX1NJWkUoZ3NpYTE4c19pMmNfZGV2aWNlcykpOworCWF0OTFfYWRkX2RldmljZV9jZigmZ3NpYTE4c19jZjFfZGF0YSk7CisJYXQ5MV9hZGRfZGV2aWNlX3NwaShnc2lhMThzX3NwaV9kZXZpY2VzLAorCQkJCUFSUkFZX1NJWkUoZ3NpYTE4c19zcGlfZGV2aWNlcykpOworCWdzaWExOHNfcG93ZXJfb2ZmX2luaXQoKTsKK30KKworTUFDSElORV9TVEFSVChHU0lBMThTLCAiR1NfSUExOF9TIikKKwkuYm9vdF9wYXJhbXMJPSBBVDkxX1NEUkFNX0JBU0UgKyAweDEwMCwKKwkudGltZXIJCT0gJmF0OTFzYW05MjZ4X3RpbWVyLAorCS5tYXBfaW8JCT0gZ3NpYTE4c19tYXBfaW8sCisJLmluaXRfaXJxCT0gaW5pdF9pcnEsCisJLmluaXRfbWFjaGluZQk9IGdzaWExOHNfYm9hcmRfaW5pdCwKK01BQ0hJTkVfRU5ECmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWF0OTEvYm9hcmQtc2FtOW0xMGc0NWVrLmMgYi9hcmNoL2FybS9tYWNoLWF0OTEvYm9hcmQtc2FtOW0xMGc0NWVrLmMKaW5kZXggODZmZjRiNS4uNmM5OTlkYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1hdDkxL2JvYXJkLXNhbTltMTBnNDVlay5jCisrKyBiL2FyY2gvYXJtL21hY2gtYXQ5MS9ib2FyZC1zYW05bTEwZzQ1ZWsuYwpAQCAtMzcsNyArMzcsNiBAQAogI2luY2x1ZGUgPGFzbS9tYWNoL21hcC5oPgogI2luY2x1ZGUgPGFzbS9tYWNoL2lycS5oPgogCi0jaW5jbHVkZSA8bWFjaC9oYXJkd2FyZS5oPgogI2luY2x1ZGUgPG1hY2gvYm9hcmQuaD4KICNpbmNsdWRlIDxtYWNoL2dwaW8uaD4KICNpbmNsdWRlIDxtYWNoL2F0OTFzYW05X3NtYy5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1hdDkxL2dwaW8uYyBiL2FyY2gvYXJtL21hY2gtYXQ5MS9ncGlvLmMKaW5kZXggYWU0NzcyZS4uYWY4MThhMiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1hdDkxL2dwaW8uYworKysgYi9hcmNoL2FybS9tYWNoLWF0OTEvZ3Bpby5jCkBAIC0yNzQsMTAgKzI3NCwxMCBAQAogc3RhdGljIHUzMiB3YWtldXBzW01BWF9HUElPX0JBTktTXTsKIHN0YXRpYyB1MzIgYmFja3Vwc1tNQVhfR1BJT19CQU5LU107CiAKLXN0YXRpYyBpbnQgZ3Bpb19pcnFfc2V0X3dha2UodW5zaWduZWQgcGluLCB1bnNpZ25lZCBzdGF0ZSkKK3N0YXRpYyBpbnQgZ3Bpb19pcnFfc2V0X3dha2Uoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBzdGF0ZSkKIHsKLQl1bnNpZ25lZAltYXNrID0gcGluX3RvX21hc2socGluKTsKLQl1bnNpZ25lZAliYW5rID0gKHBpbiAtIFBJTl9CQVNFKSAvIDMyOworCXVuc2lnbmVkCW1hc2sgPSBwaW5fdG9fbWFzayhkLT5pcnEpOworCXVuc2lnbmVkCWJhbmsgPSAoZC0+aXJxIC0gUElOX0JBU0UpIC8gMzI7CiAKIAlpZiAodW5saWtlbHkoYmFuayA+PSBNQVhfR1BJT19CQU5LUykpCiAJCXJldHVybiAtRUlOVkFMOwpAQCAtMzQ0LDI1ICszNDQsMjUgQEAKICAqIElSUTAuLklSUTYgc2hvdWxkIGJlIGNvbmZpZ3VyYWJsZSwgZS5nLiBsZXZlbCB2cyBlZGdlIHRyaWdnZXJpbmcuCiAgKi8KIAotc3RhdGljIHZvaWQgZ3Bpb19pcnFfbWFzayh1bnNpZ25lZCBwaW4pCitzdGF0aWMgdm9pZCBncGlvX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl2b2lkIF9faW9tZW0JKnBpbyA9IHBpbl90b19jb250cm9sbGVyKHBpbik7Ci0JdW5zaWduZWQJbWFzayA9IHBpbl90b19tYXNrKHBpbik7CisJdm9pZCBfX2lvbWVtCSpwaW8gPSBwaW5fdG9fY29udHJvbGxlcihkLT5pcnEpOworCXVuc2lnbmVkCW1hc2sgPSBwaW5fdG9fbWFzayhkLT5pcnEpOwogCiAJaWYgKHBpbykKIAkJX19yYXdfd3JpdGVsKG1hc2ssIHBpbyArIFBJT19JRFIpOwogfQogCi1zdGF0aWMgdm9pZCBncGlvX2lycV91bm1hc2sodW5zaWduZWQgcGluKQorc3RhdGljIHZvaWQgZ3Bpb19pcnFfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl2b2lkIF9faW9tZW0JKnBpbyA9IHBpbl90b19jb250cm9sbGVyKHBpbik7Ci0JdW5zaWduZWQJbWFzayA9IHBpbl90b19tYXNrKHBpbik7CisJdm9pZCBfX2lvbWVtCSpwaW8gPSBwaW5fdG9fY29udHJvbGxlcihkLT5pcnEpOworCXVuc2lnbmVkCW1hc2sgPSBwaW5fdG9fbWFzayhkLT5pcnEpOwogCiAJaWYgKHBpbykKIAkJX19yYXdfd3JpdGVsKG1hc2ssIHBpbyArIFBJT19JRVIpOwogfQogCi1zdGF0aWMgaW50IGdwaW9faXJxX3R5cGUodW5zaWduZWQgcGluLCB1bnNpZ25lZCB0eXBlKQorc3RhdGljIGludCBncGlvX2lycV90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgdHlwZSkKIHsKIAlzd2l0Y2ggKHR5cGUpIHsKIAljYXNlIElSUV9UWVBFX05PTkU6CkBAIC0zNzUsMTAgKzM3NSwxMCBAQAogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGdwaW9faXJxY2hpcCA9IHsKIAkubmFtZQkJPSAiR1BJTyIsCi0JLm1hc2sJCT0gZ3Bpb19pcnFfbWFzaywKLQkudW5tYXNrCQk9IGdwaW9faXJxX3VubWFzaywKLQkuc2V0X3R5cGUJPSBncGlvX2lycV90eXBlLAotCS5zZXRfd2FrZQk9IGdwaW9faXJxX3NldF93YWtlLAorCS5pcnFfbWFzawk9IGdwaW9faXJxX21hc2ssCisJLmlycV91bm1hc2sJPSBncGlvX2lycV91bm1hc2ssCisJLmlycV9zZXRfdHlwZQk9IGdwaW9faXJxX3R5cGUsCisJLmlycV9zZXRfd2FrZQk9IGdwaW9faXJxX3NldF93YWtlLAogfTsKIAogc3RhdGljIHZvaWQgZ3Bpb19pcnFfaGFuZGxlcih1bnNpZ25lZCBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKQEAgLTM5Myw3ICszOTMsNyBAQAogCXBpbyA9IGF0OTFfZ3Bpby0+cmVnYmFzZTsKIAogCS8qIHRlbXBvcmFyaWx5IG1hc2sgKGxldmVsIHNlbnNpdGl2ZSkgcGFyZW50IElSUSAqLwotCWRlc2MtPmNoaXAtPmFjayhpcnEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9hY2soJmRlc2MtPmlycV9kYXRhKTsKIAlmb3IgKDs7KSB7CiAJCS8qIFJlYWRpbmcgSVNSIGFja3MgcGVuZGluZyAoZWRnZSB0cmlnZ2VyZWQpIEdQSU8gaW50ZXJydXB0cy4KIAkJICogV2hlbiB0aGVyZSBub25lIGFyZSBwZW5kaW5nLCB3ZSdyZSBmaW5pc2hlZCB1bmxlc3Mgd2UgbmVlZApAQCAtNDE5LDcgKzQxOSw3IEBACiAJCQkJCSAqIGFub3RoZXIgSVJRIG11c3QgYmUgZ2VuZXJhdGVkIGJlZm9yZSBpdCBhY3R1YWxseSBnZXRzCiAJCQkJCSAqIGhlcmUgdG8gYmUgZGlzYWJsZWQgb24gdGhlIEdQSU8gY29udHJvbGxlci4KIAkJCQkJICovCi0JCQkJCWdwaW9faXJxX21hc2socGluKTsKKwkJCQkJZ3Bpb19pcnFfbWFzayhpcnFfZ2V0X2lycV9kYXRhKHBpbikpOwogCQkJCX0KIAkJCQllbHNlCiAJCQkJCWdlbmVyaWNfaGFuZGxlX2lycShwaW4pOwpAQCAtNDI5LDcgKzQyOSw3IEBACiAJCQlpc3IgPj49IDE7CiAJCX0KIAl9Ci0JZGVzYy0+Y2hpcC0+dW5tYXNrKGlycSk7CisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX3VubWFzaygmZGVzYy0+aXJxX2RhdGEpOwogCS8qIG5vdyBpdCBtYXkgcmUtdHJpZ2dlciAqLwogfQogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWF0OTEvaW5jbHVkZS9tYWNoL2dzaWExOHMuaCBiL2FyY2gvYXJtL21hY2gtYXQ5MS9pbmNsdWRlL21hY2gvZ3NpYTE4cy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjMwN2MxOTQKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL2FybS9tYWNoLWF0OTEvaW5jbHVkZS9tYWNoL2dzaWExOHMuaApAQCAtMCwwICsxLDMzIEBACisvKiBCdXR0b25zICovCisjZGVmaW5lIEdQSU9fVFJJR19ORVRfSU4JCUFUOTFfUElOX1BCMjEKKyNkZWZpbmUgR1BJT19DQVJEX1VOTU9VTlRfMAkJQVQ5MV9QSU5fUEIxMworI2RlZmluZSBHUElPX0NBUkRfVU5NT1VOVF8xCQlBVDkxX1BJTl9QQjEyCisjZGVmaW5lIEdQSU9fS0VZX1BPV0VSCQkJQVQ5MV9QSU5fUEEyNQorCisvKiBQQ0Y4NTc0IDB4MjAgR1BJTyAtIFUxIG9uIHRoZSBHU19JQTE4LUNCX1YzIGJvYXJkICovCisjZGVmaW5lIEdTX0lBMThfU19QQ0ZfR1BJT19CQVNFMAlOUl9CVUlMVElOX0dQSU8KKyNkZWZpbmUgUENGX0dQSU9fSERDX1BPV0VSCQkoR1NfSUExOF9TX1BDRl9HUElPX0JBU0UwICsgMCkKKyNkZWZpbmUgUENGX0dQSU9fV0lGSV9TRVRVUAkJKEdTX0lBMThfU19QQ0ZfR1BJT19CQVNFMCArIDEpCisjZGVmaW5lIFBDRl9HUElPX1dJRklfRU5BQkxFCQkoR1NfSUExOF9TX1BDRl9HUElPX0JBU0UwICsgMikKKyNkZWZpbmUgUENGX0dQSU9fV0lGSV9SRVNFVAkJKEdTX0lBMThfU19QQ0ZfR1BJT19CQVNFMCArIDMpCisjZGVmaW5lIFBDRl9HUElPX0VUSF9ERVRFQ1QJCTQgLyogdGhpcyBpcyBhIEdQSSAqLworI2RlZmluZSBQQ0ZfR1BJT19HUFNfU0VUVVAJCShHU19JQTE4X1NfUENGX0dQSU9fQkFTRTAgKyA1KQorI2RlZmluZSBQQ0ZfR1BJT19HUFNfU1RBTkRCWQkJKEdTX0lBMThfU19QQ0ZfR1BJT19CQVNFMCArIDYpCisjZGVmaW5lIFBDRl9HUElPX0dQU19QT1dFUgkJKEdTX0lBMThfU19QQ0ZfR1BJT19CQVNFMCArIDcpCisKKy8qIFBDRjg1NzQgMHgyMiBHUElPIC0gVTEgb24gdGhlIEdTXzJHX09QVDEtQV9WMCBib2FyZCAoQWxhcm0pICovCisjZGVmaW5lIEdTX0lBMThfU19QQ0ZfR1BJT19CQVNFMQkoR1NfSUExOF9TX1BDRl9HUElPX0JBU0UwICsgOCkKKyNkZWZpbmUgUENGX0dQSU9fQUxBUk0xCQkJKEdTX0lBMThfU19QQ0ZfR1BJT19CQVNFMSArIDApCisjZGVmaW5lIFBDRl9HUElPX0FMQVJNMgkJCShHU19JQTE4X1NfUENGX0dQSU9fQkFTRTEgKyAxKQorI2RlZmluZSBQQ0ZfR1BJT19BTEFSTTMJCQkoR1NfSUExOF9TX1BDRl9HUElPX0JBU0UxICsgMikKKyNkZWZpbmUgUENGX0dQSU9fQUxBUk00CQkJKEdTX0lBMThfU19QQ0ZfR1BJT19CQVNFMSArIDMpCisvKiBiaXRzIDQsIDUsIDYgbm90IHVzZWQgKi8KKyNkZWZpbmUgUENGX0dQSU9fQUxBUk1fVl9SRUxBWV9PTgkoR1NfSUExOF9TX1BDRl9HUElPX0JBU0UxICsgNykKKworLyogUENGODU3NCAweDI0IEdQSU8gVTEgb24gdGhlIEdTXzJHLU9QVDIzLUFfVjAgYm9hcmQgKE1vZGVtKSAqLworI2RlZmluZSBHU19JQTE4X1NfUENGX0dQSU9fQkFTRTIJKEdTX0lBMThfU19QQ0ZfR1BJT19CQVNFMSArIDgpCisjZGVmaW5lIFBDRl9HUElPX01PREVNX1BPV0VSCQkoR1NfSUExOF9TX1BDRl9HUElPX0JBU0UyICsgMCkKKyNkZWZpbmUgUENGX0dQSU9fTU9ERU1fUkVTRVQJCShHU19JQTE4X1NfUENGX0dQSU9fQkFTRTIgKyAzKQorLyogYml0cyAxLCAyLCA0LCA1IG5vdCB1c2VkICovCisjZGVmaW5lIFBDRl9HUElPX1RSWF9SRVNFVAkJKEdTX0lBMThfU19QQ0ZfR1BJT19CQVNFMiArIDYpCisvKiBiaXQgNyBub3QgdXNlZCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1hdDkxL2lycS5jIGIvYXJjaC9hcm0vbWFjaC1hdDkxL2lycS5jCmluZGV4IGRhMzQ5NGEuLmI1NmQ2YjNhIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWF0OTEvaXJxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1hdDkxL2lycS5jCkBAIC0zNCwyMyArMzQsMjMgQEAKICNpbmNsdWRlIDxhc20vbWFjaC9tYXAuaD4KIAogCi1zdGF0aWMgdm9pZCBhdDkxX2FpY19tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgYXQ5MV9haWNfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCS8qIERpc2FibGUgaW50ZXJydXB0IG9uIEFJQyAqLwotCWF0OTFfc3lzX3dyaXRlKEFUOTFfQUlDX0lEQ1IsIDEgPDwgaXJxKTsKKwlhdDkxX3N5c193cml0ZShBVDkxX0FJQ19JRENSLCAxIDw8IGQtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIGF0OTFfYWljX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGF0OTFfYWljX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCS8qIEVuYWJsZSBpbnRlcnJ1cHQgb24gQUlDICovCi0JYXQ5MV9zeXNfd3JpdGUoQVQ5MV9BSUNfSUVDUiwgMSA8PCBpcnEpOworCWF0OTFfc3lzX3dyaXRlKEFUOTFfQUlDX0lFQ1IsIDEgPDwgZC0+aXJxKTsKIH0KIAogdW5zaWduZWQgaW50IGF0OTFfZXh0ZXJuX2lycTsKIAogI2RlZmluZSBpc19leHRlcm5faXJxKGlycSkgKCgxIDw8IChpcnEpKSAmIGF0OTFfZXh0ZXJuX2lycSkKIAotc3RhdGljIGludCBhdDkxX2FpY19zZXRfdHlwZSh1bnNpZ25lZCBpcnEsIHVuc2lnbmVkIHR5cGUpCitzdGF0aWMgaW50IGF0OTFfYWljX3NldF90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgdHlwZSkKIHsKIAl1bnNpZ25lZCBpbnQgc21yLCBzcmN0eXBlOwogCkBAIC02MiwxMyArNjIsMTMgQEAKIAkJc3JjdHlwZSA9IEFUOTFfQUlDX1NSQ1RZUEVfUklTSU5HOwogCQlicmVhazsKIAljYXNlIElSUV9UWVBFX0xFVkVMX0xPVzoKLQkJaWYgKChpcnEgPT0gQVQ5MV9JRF9GSVEpIHx8IGlzX2V4dGVybl9pcnEoaXJxKSkJCS8qIG9ubHkgc3VwcG9ydGVkIG9uIGV4dGVybmFsIGludGVycnVwdHMgKi8KKwkJaWYgKChkLT5pcnEgPT0gQVQ5MV9JRF9GSVEpIHx8IGlzX2V4dGVybl9pcnEoZC0+aXJxKSkJCS8qIG9ubHkgc3VwcG9ydGVkIG9uIGV4dGVybmFsIGludGVycnVwdHMgKi8KIAkJCXNyY3R5cGUgPSBBVDkxX0FJQ19TUkNUWVBFX0xPVzsKIAkJZWxzZQogCQkJcmV0dXJuIC1FSU5WQUw7CiAJCWJyZWFrOwogCWNhc2UgSVJRX1RZUEVfRURHRV9GQUxMSU5HOgotCQlpZiAoKGlycSA9PSBBVDkxX0lEX0ZJUSkgfHwgaXNfZXh0ZXJuX2lycShpcnEpKQkJLyogb25seSBzdXBwb3J0ZWQgb24gZXh0ZXJuYWwgaW50ZXJydXB0cyAqLworCQlpZiAoKGQtPmlycSA9PSBBVDkxX0lEX0ZJUSkgfHwgaXNfZXh0ZXJuX2lycShkLT5pcnEpKQkJLyogb25seSBzdXBwb3J0ZWQgb24gZXh0ZXJuYWwgaW50ZXJydXB0cyAqLwogCQkJc3JjdHlwZSA9IEFUOTFfQUlDX1NSQ1RZUEVfRkFMTElORzsKIAkJZWxzZQogCQkJcmV0dXJuIC1FSU5WQUw7CkBAIC03Nyw4ICs3Nyw4IEBACiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAotCXNtciA9IGF0OTFfc3lzX3JlYWQoQVQ5MV9BSUNfU01SKGlycSkpICYgfkFUOTFfQUlDX1NSQ1RZUEU7Ci0JYXQ5MV9zeXNfd3JpdGUoQVQ5MV9BSUNfU01SKGlycSksIHNtciB8IHNyY3R5cGUpOworCXNtciA9IGF0OTFfc3lzX3JlYWQoQVQ5MV9BSUNfU01SKGQtPmlycSkpICYgfkFUOTFfQUlDX1NSQ1RZUEU7CisJYXQ5MV9zeXNfd3JpdGUoQVQ5MV9BSUNfU01SKGQtPmlycSksIHNtciB8IHNyY3R5cGUpOwogCXJldHVybiAwOwogfQogCkBAIC04NywxNSArODcsMTUgQEAKIHN0YXRpYyB1MzIgd2FrZXVwczsKIHN0YXRpYyB1MzIgYmFja3VwczsKIAotc3RhdGljIGludCBhdDkxX2FpY19zZXRfd2FrZSh1bnNpZ25lZCBpcnEsIHVuc2lnbmVkIHZhbHVlKQorc3RhdGljIGludCBhdDkxX2FpY19zZXRfd2FrZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIHZhbHVlKQogewotCWlmICh1bmxpa2VseShpcnEgPj0gMzIpKQorCWlmICh1bmxpa2VseShkLT5pcnEgPj0gMzIpKQogCQlyZXR1cm4gLUVJTlZBTDsKIAogCWlmICh2YWx1ZSkKLQkJd2FrZXVwcyB8PSAoMSA8PCBpcnEpOworCQl3YWtldXBzIHw9ICgxIDw8IGQtPmlycSk7CiAJZWxzZQotCQl3YWtldXBzICY9IH4oMSA8PCBpcnEpOworCQl3YWtldXBzICY9IH4oMSA8PCBkLT5pcnEpOwogCiAJcmV0dXJuIDA7CiB9CkBAIC0xMTksMTEgKzExOSwxMSBAQAogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGF0OTFfYWljX2NoaXAgPSB7CiAJLm5hbWUJCT0gIkFJQyIsCi0JLmFjawkJPSBhdDkxX2FpY19tYXNrX2lycSwKLQkubWFzawkJPSBhdDkxX2FpY19tYXNrX2lycSwKLQkudW5tYXNrCQk9IGF0OTFfYWljX3VubWFza19pcnEsCi0JLnNldF90eXBlCT0gYXQ5MV9haWNfc2V0X3R5cGUsCi0JLnNldF93YWtlCT0gYXQ5MV9haWNfc2V0X3dha2UsCisJLmlycV9hY2sJPSBhdDkxX2FpY19tYXNrX2lycSwKKwkuaXJxX21hc2sJPSBhdDkxX2FpY19tYXNrX2lycSwKKwkuaXJxX3VubWFzawk9IGF0OTFfYWljX3VubWFza19pcnEsCisJLmlycV9zZXRfdHlwZQk9IGF0OTFfYWljX3NldF90eXBlLAorCS5pcnFfc2V0X3dha2UJPSBhdDkxX2FpY19zZXRfd2FrZSwKIH07CiAKIC8qCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWJjbXJpbmcvaXJxLmMgYi9hcmNoL2FybS9tYWNoLWJjbXJpbmcvaXJxLmMKaW5kZXggZTMxNTI2My4uODRkY2RhMCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1iY21yaW5nL2lycS5jCisrKyBiL2FyY2gvYXJtL21hY2gtYmNtcmluZy9pcnEuYwpAQCAtMzAsNjEgKzMwLDYxIEBACiAjaW5jbHVkZSA8bWFjaC9jc3AvaW50Y0h3X3JlZy5oPgogI2luY2x1ZGUgPG1hY2gvY3NwL21tX2lvLmg+CiAKLXN0YXRpYyB2b2lkIGJjbXJpbmdfbWFza19pcnEwKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBiY21yaW5nX21hc2tfaXJxMChzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jd3JpdGVsKDEgPDwgKGlycSAtIElSUV9JTlRDMF9TVEFSVCksCisJd3JpdGVsKDEgPDwgKGQtPmlycSAtIElSUV9JTlRDMF9TVEFSVCksCiAJICAgICAgIE1NX0lPX0JBU0VfSU5UQzAgKyBJTlRDSFdfSU5URU5DTEVBUik7CiB9CiAKLXN0YXRpYyB2b2lkIGJjbXJpbmdfdW5tYXNrX2lycTAodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGJjbXJpbmdfdW5tYXNrX2lycTAoc3RydWN0IGlycV9kYXRhICpkKQogewotCXdyaXRlbCgxIDw8IChpcnEgLSBJUlFfSU5UQzBfU1RBUlQpLAorCXdyaXRlbCgxIDw8IChkLT5pcnEgLSBJUlFfSU5UQzBfU1RBUlQpLAogCSAgICAgICBNTV9JT19CQVNFX0lOVEMwICsgSU5UQ0hXX0lOVEVOQUJMRSk7CiB9CiAKLXN0YXRpYyB2b2lkIGJjbXJpbmdfbWFza19pcnExKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBiY21yaW5nX21hc2tfaXJxMShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jd3JpdGVsKDEgPDwgKGlycSAtIElSUV9JTlRDMV9TVEFSVCksCisJd3JpdGVsKDEgPDwgKGQtPmlycSAtIElSUV9JTlRDMV9TVEFSVCksCiAJICAgICAgIE1NX0lPX0JBU0VfSU5UQzEgKyBJTlRDSFdfSU5URU5DTEVBUik7CiB9CiAKLXN0YXRpYyB2b2lkIGJjbXJpbmdfdW5tYXNrX2lycTEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGJjbXJpbmdfdW5tYXNrX2lycTEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXdyaXRlbCgxIDw8IChpcnEgLSBJUlFfSU5UQzFfU1RBUlQpLAorCXdyaXRlbCgxIDw8IChkLT5pcnEgLSBJUlFfSU5UQzFfU1RBUlQpLAogCSAgICAgICBNTV9JT19CQVNFX0lOVEMxICsgSU5UQ0hXX0lOVEVOQUJMRSk7CiB9CiAKLXN0YXRpYyB2b2lkIGJjbXJpbmdfbWFza19pcnEyKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBiY21yaW5nX21hc2tfaXJxMihzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jd3JpdGVsKDEgPDwgKGlycSAtIElSUV9TSU5UQ19TVEFSVCksCisJd3JpdGVsKDEgPDwgKGQtPmlycSAtIElSUV9TSU5UQ19TVEFSVCksCiAJICAgICAgIE1NX0lPX0JBU0VfU0lOVEMgKyBJTlRDSFdfSU5URU5DTEVBUik7CiB9CiAKLXN0YXRpYyB2b2lkIGJjbXJpbmdfdW5tYXNrX2lycTIodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGJjbXJpbmdfdW5tYXNrX2lycTIoc3RydWN0IGlycV9kYXRhICpkKQogewotCXdyaXRlbCgxIDw8IChpcnEgLSBJUlFfU0lOVENfU1RBUlQpLAorCXdyaXRlbCgxIDw8IChkLT5pcnEgLSBJUlFfU0lOVENfU1RBUlQpLAogCSAgICAgICBNTV9JT19CQVNFX1NJTlRDICsgSU5UQ0hXX0lOVEVOQUJMRSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgYmNtcmluZ19pcnEwX2NoaXAgPSB7CiAJLm5hbWUgPSAiQVJNLUlOVEMwIiwKLQkuYWNrID0gYmNtcmluZ19tYXNrX2lycTAsCi0JLm1hc2sgPSBiY21yaW5nX21hc2tfaXJxMCwJLyogbWFzayBhIHNwZWNpZmljIGludGVycnVwdCwgYmxvY2tpbmcgaXRzIGRlbGl2ZXJ5LiAqLwotCS51bm1hc2sgPSBiY21yaW5nX3VubWFza19pcnEwLAkvKiB1bm1ha3MgYW4gaW50ZXJydXB0ICovCisJLmlycV9hY2sgPSBiY21yaW5nX21hc2tfaXJxMCwKKwkuaXJxX21hc2sgPSBiY21yaW5nX21hc2tfaXJxMCwJLyogbWFzayBhIHNwZWNpZmljIGludGVycnVwdCwgYmxvY2tpbmcgaXRzIGRlbGl2ZXJ5LiAqLworCS5pcnFfdW5tYXNrID0gYmNtcmluZ191bm1hc2tfaXJxMCwJLyogdW5tYWtzIGFuIGludGVycnVwdCAqLwogfTsKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBiY21yaW5nX2lycTFfY2hpcCA9IHsKIAkubmFtZSA9ICJBUk0tSU5UQzEiLAotCS5hY2sgPSBiY21yaW5nX21hc2tfaXJxMSwKLQkubWFzayA9IGJjbXJpbmdfbWFza19pcnExLAotCS51bm1hc2sgPSBiY21yaW5nX3VubWFza19pcnExLAorCS5pcnFfYWNrID0gYmNtcmluZ19tYXNrX2lycTEsCisJLmlycV9tYXNrID0gYmNtcmluZ19tYXNrX2lycTEsCisJLmlycV91bm1hc2sgPSBiY21yaW5nX3VubWFza19pcnExLAogfTsKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBiY21yaW5nX2lycTJfY2hpcCA9IHsKIAkubmFtZSA9ICJBUk0tU0lOVEMiLAotCS5hY2sgPSBiY21yaW5nX21hc2tfaXJxMiwKLQkubWFzayA9IGJjbXJpbmdfbWFza19pcnEyLAotCS51bm1hc2sgPSBiY21yaW5nX3VubWFza19pcnEyLAorCS5pcnFfYWNrID0gYmNtcmluZ19tYXNrX2lycTIsCisJLmlycV9tYXNrID0gYmNtcmluZ19tYXNrX2lycTIsCisJLmlycV91bm1hc2sgPSBiY21yaW5nX3VubWFza19pcnEyLAogfTsKIAogc3RhdGljIHZvaWQgdmljX2luaXQodm9pZCBfX2lvbWVtICpiYXNlLCBzdHJ1Y3QgaXJxX2NoaXAgKmNoaXAsCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWNscHM3MTF4L2lycS5jIGIvYXJjaC9hcm0vbWFjaC1jbHBzNzExeC9pcnEuYwppbmRleCA5YTEyZDg1Li44NmRhN2ExIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWNscHM3MTF4L2lycS5jCisrKyBiL2FyY2gvYXJtL21hY2gtY2xwczcxMXgvaXJxLmMKQEAgLTI3LDI0ICsyNywyNCBAQAogCiAjaW5jbHVkZSA8YXNtL2hhcmR3YXJlL2NscHM3MTExLmg+CiAKLXN0YXRpYyB2b2lkIGludDFfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaW50MV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl1MzIgaW50bXIxOwogCiAJaW50bXIxID0gY2xwc19yZWFkbChJTlRNUjEpOwotCWludG1yMSAmPSB+KDEgPDwgaXJxKTsKKwlpbnRtcjEgJj0gfigxIDw8IGQtPmlycSk7CiAJY2xwc193cml0ZWwoaW50bXIxLCBJTlRNUjEpOwogfQogCi1zdGF0aWMgdm9pZCBpbnQxX2Fjayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaW50MV9hY2soc3RydWN0IGlycV9kYXRhICpkKQogewogCXUzMiBpbnRtcjE7CiAKIAlpbnRtcjEgPSBjbHBzX3JlYWRsKElOVE1SMSk7Ci0JaW50bXIxICY9IH4oMSA8PCBpcnEpOworCWludG1yMSAmPSB+KDEgPDwgZC0+aXJxKTsKIAljbHBzX3dyaXRlbChpbnRtcjEsIElOVE1SMSk7CiAKLQlzd2l0Y2ggKGlycSkgeworCXN3aXRjaCAoZC0+aXJxKSB7CiAJY2FzZSBJUlFfQ1NJTlQ6ICBjbHBzX3dyaXRlbCgwLCBDT0VPSSk7ICBicmVhazsKIAljYXNlIElSUV9UQzFPSTogIGNscHNfd3JpdGVsKDAsIFRDMUVPSSk7IGJyZWFrOwogCWNhc2UgSVJRX1RDMk9JOiAgY2xwc193cml0ZWwoMCwgVEMyRU9JKTsgYnJlYWs7CkBAIC01NCw1NiArNTQsNTYgQEAKIAl9CiB9CiAKLXN0YXRpYyB2b2lkIGludDFfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpbnQxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdTMyIGludG1yMTsKIAogCWludG1yMSA9IGNscHNfcmVhZGwoSU5UTVIxKTsKLQlpbnRtcjEgfD0gMSA8PCBpcnE7CisJaW50bXIxIHw9IDEgPDwgZC0+aXJxOwogCWNscHNfd3JpdGVsKGludG1yMSwgSU5UTVIxKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBpbnQxX2NoaXAgPSB7Ci0JLmFjawk9IGludDFfYWNrLAotCS5tYXNrCT0gaW50MV9tYXNrLAotCS51bm1hc2sgPSBpbnQxX3VubWFzaywKKwkuaXJxX2Fjawk9IGludDFfYWNrLAorCS5pcnFfbWFzawk9IGludDFfbWFzaywKKwkuaXJxX3VubWFzawk9IGludDFfdW5tYXNrLAogfTsKIAotc3RhdGljIHZvaWQgaW50Ml9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpbnQyX21hc2soc3RydWN0IGlycV9kYXRhICpkKQogewogCXUzMiBpbnRtcjI7CiAKIAlpbnRtcjIgPSBjbHBzX3JlYWRsKElOVE1SMik7Ci0JaW50bXIyICY9IH4oMSA8PCAoaXJxIC0gMTYpKTsKKwlpbnRtcjIgJj0gfigxIDw8IChkLT5pcnEgLSAxNikpOwogCWNscHNfd3JpdGVsKGludG1yMiwgSU5UTVIyKTsKIH0KIAotc3RhdGljIHZvaWQgaW50Ml9hY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGludDJfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl1MzIgaW50bXIyOwogCiAJaW50bXIyID0gY2xwc19yZWFkbChJTlRNUjIpOwotCWludG1yMiAmPSB+KDEgPDwgKGlycSAtIDE2KSk7CisJaW50bXIyICY9IH4oMSA8PCAoZC0+aXJxIC0gMTYpKTsKIAljbHBzX3dyaXRlbChpbnRtcjIsIElOVE1SMik7CiAKLQlzd2l0Y2ggKGlycSkgeworCXN3aXRjaCAoZC0+aXJxKSB7CiAJY2FzZSBJUlFfS0JESU5UOiBjbHBzX3dyaXRlbCgwLCBLQkRFT0kpOyBicmVhazsKIAl9CiB9CiAKLXN0YXRpYyB2b2lkIGludDJfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpbnQyX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdTMyIGludG1yMjsKIAogCWludG1yMiA9IGNscHNfcmVhZGwoSU5UTVIyKTsKLQlpbnRtcjIgfD0gMSA8PCAoaXJxIC0gMTYpOworCWludG1yMiB8PSAxIDw8IChkLT5pcnEgLSAxNik7CiAJY2xwc193cml0ZWwoaW50bXIyLCBJTlRNUjIpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGludDJfY2hpcCA9IHsKLQkuYWNrCT0gaW50Ml9hY2ssCi0JLm1hc2sJPSBpbnQyX21hc2ssCi0JLnVubWFzayA9IGludDJfdW5tYXNrLAorCS5pcnFfYWNrCT0gaW50Ml9hY2ssCisJLmlycV9tYXNrCT0gaW50Ml9tYXNrLAorCS5pcnFfdW5tYXNrCT0gaW50Ml91bm1hc2ssCiB9OwogCiB2b2lkIF9faW5pdCBjbHBzNzExeF9pbml0X2lycSh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1kYXZpbmNpL2NwX2ludGMuYyBiL2FyY2gvYXJtL21hY2gtZGF2aW5jaS9jcF9pbnRjLmMKaW5kZXggYmI0YzQwZS4uOWFiYzgwYSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1kYXZpbmNpL2NwX2ludGMuYworKysgYi9hcmNoL2FybS9tYWNoLWRhdmluY2kvY3BfaW50Yy5jCkBAIC0yNiwzMCArMjYsMzAgQEAKIAlfX3Jhd193cml0ZWwodmFsdWUsIGRhdmluY2lfaW50Y19iYXNlICsgb2Zmc2V0KTsKIH0KIAotc3RhdGljIHZvaWQgY3BfaW50Y19hY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBjcF9pbnRjX2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCWNwX2ludGNfd3JpdGUoaXJxLCBDUF9JTlRDX1NZU19TVEFUX0lEWF9DTFIpOworCWNwX2ludGNfd3JpdGUoZC0+aXJxLCBDUF9JTlRDX1NZU19TVEFUX0lEWF9DTFIpOwogfQogCiAvKiBEaXNhYmxlIGludGVycnVwdCAqLwotc3RhdGljIHZvaWQgY3BfaW50Y19tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgY3BfaW50Y19tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJLyogWFhYIGRvbid0IGtub3cgd2h5IHdlIG5lZWQgdG8gZGlzYWJsZSBuSVJRIGhlcmUuLi4gKi8KIAljcF9pbnRjX3dyaXRlKDEsIENQX0lOVENfSE9TVF9FTkFCTEVfSURYX0NMUik7Ci0JY3BfaW50Y193cml0ZShpcnEsIENQX0lOVENfU1lTX0VOQUJMRV9JRFhfQ0xSKTsKKwljcF9pbnRjX3dyaXRlKGQtPmlycSwgQ1BfSU5UQ19TWVNfRU5BQkxFX0lEWF9DTFIpOwogCWNwX2ludGNfd3JpdGUoMSwgQ1BfSU5UQ19IT1NUX0VOQUJMRV9JRFhfU0VUKTsKIH0KIAogLyogRW5hYmxlIGludGVycnVwdCAqLwotc3RhdGljIHZvaWQgY3BfaW50Y191bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBjcF9pbnRjX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCWNwX2ludGNfd3JpdGUoaXJxLCBDUF9JTlRDX1NZU19FTkFCTEVfSURYX1NFVCk7CisJY3BfaW50Y193cml0ZShkLT5pcnEsIENQX0lOVENfU1lTX0VOQUJMRV9JRFhfU0VUKTsKIH0KIAotc3RhdGljIGludCBjcF9pbnRjX3NldF9pcnFfdHlwZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgZmxvd190eXBlKQorc3RhdGljIGludCBjcF9pbnRjX3NldF9pcnFfdHlwZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCBmbG93X3R5cGUpCiB7Ci0JdW5zaWduZWQgcmVnCQk9IEJJVF9XT1JEKGlycSk7Ci0JdW5zaWduZWQgbWFzawkJPSBCSVRfTUFTSyhpcnEpOworCXVuc2lnbmVkIHJlZwkJPSBCSVRfV09SRChkLT5pcnEpOworCXVuc2lnbmVkIG1hc2sJCT0gQklUX01BU0soZC0+aXJxKTsKIAl1bnNpZ25lZCBwb2xhcml0eQk9IGNwX2ludGNfcmVhZChDUF9JTlRDX1NZU19QT0xBUklUWShyZWcpKTsKIAl1bnNpZ25lZCB0eXBlCQk9IGNwX2ludGNfcmVhZChDUF9JTlRDX1NZU19UWVBFKHJlZykpOwogCkBAIC04NSwxOCArODUsMTggQEAKICAqIGdlbmVyaWMgZHJpdmVycyB3aGljaCBjYWxsIHtlbmFibGV8ZGlzYWJsZX1faXJxX3dha2UgZm9yCiAgKiB3YWtlIHVwIGludGVycnVwdCBzb3VyY2VzIChlZyBSVEMgb24gREE4NTApLgogICovCi1zdGF0aWMgaW50IGNwX2ludGNfc2V0X3dha2UodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IG9uKQorc3RhdGljIGludCBjcF9pbnRjX3NldF93YWtlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IG9uKQogewogCXJldHVybiAwOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGNwX2ludGNfaXJxX2NoaXAgPSB7CiAJLm5hbWUJCT0gImNwX2ludGMiLAotCS5hY2sJCT0gY3BfaW50Y19hY2tfaXJxLAotCS5tYXNrCQk9IGNwX2ludGNfbWFza19pcnEsCi0JLnVubWFzawkJPSBjcF9pbnRjX3VubWFza19pcnEsCi0JLnNldF90eXBlCT0gY3BfaW50Y19zZXRfaXJxX3R5cGUsCi0JLnNldF93YWtlCT0gY3BfaW50Y19zZXRfd2FrZSwKKwkuaXJxX2Fjawk9IGNwX2ludGNfYWNrX2lycSwKKwkuaXJxX21hc2sJPSBjcF9pbnRjX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gY3BfaW50Y191bm1hc2tfaXJxLAorCS5pcnFfc2V0X3R5cGUJPSBjcF9pbnRjX3NldF9pcnFfdHlwZSwKKwkuaXJxX3NldF93YWtlCT0gY3BfaW50Y19zZXRfd2FrZSwKIH07CiAKIHZvaWQgX19pbml0IGNwX2ludGNfaW5pdCh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1kYXZpbmNpL2dwaW8uYyBiL2FyY2gvYXJtL21hY2gtZGF2aW5jaS9ncGlvLmMKaW5kZXggYmYwZmY1OC4uMjBkNjZlNSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1kYXZpbmNpL2dwaW8uYworKysgYi9hcmNoL2FybS9tYWNoLWRhdmluY2kvZ3Bpby5jCkBAIC0yMDUsMjAgKzIwNSwyMCBAQAogICogc2VydmUgYXMgRURNQSBldmVudCB0cmlnZ2Vycy4KICAqLwogCi1zdGF0aWMgdm9pZCBncGlvX2lycV9kaXNhYmxlKHVuc2lnbmVkIGlycSkKK3N0YXRpYyB2b2lkIGdwaW9faXJxX2Rpc2FibGUoc3RydWN0IGlycV9kYXRhICpkKQogewotCXN0cnVjdCBkYXZpbmNpX2dwaW9fcmVncyBfX2lvbWVtICpnID0gaXJxMnJlZ3MoaXJxKTsKLQl1MzIgbWFzayA9ICh1MzIpIGdldF9pcnFfZGF0YShpcnEpOworCXN0cnVjdCBkYXZpbmNpX2dwaW9fcmVncyBfX2lvbWVtICpnID0gaXJxMnJlZ3MoZC0+aXJxKTsKKwl1MzIgbWFzayA9ICh1MzIpIGlycV9kYXRhX2dldF9pcnFfZGF0YShkKTsKIAogCV9fcmF3X3dyaXRlbChtYXNrLCAmZy0+Y2xyX2ZhbGxpbmcpOwogCV9fcmF3X3dyaXRlbChtYXNrLCAmZy0+Y2xyX3Jpc2luZyk7CiB9CiAKLXN0YXRpYyB2b2lkIGdwaW9faXJxX2VuYWJsZSh1bnNpZ25lZCBpcnEpCitzdGF0aWMgdm9pZCBncGlvX2lycV9lbmFibGUoc3RydWN0IGlycV9kYXRhICpkKQogewotCXN0cnVjdCBkYXZpbmNpX2dwaW9fcmVncyBfX2lvbWVtICpnID0gaXJxMnJlZ3MoaXJxKTsKLQl1MzIgbWFzayA9ICh1MzIpIGdldF9pcnFfZGF0YShpcnEpOwotCXVuc2lnbmVkIHN0YXR1cyA9IGlycV9kZXNjW2lycV0uc3RhdHVzOworCXN0cnVjdCBkYXZpbmNpX2dwaW9fcmVncyBfX2lvbWVtICpnID0gaXJxMnJlZ3MoZC0+aXJxKTsKKwl1MzIgbWFzayA9ICh1MzIpIGlycV9kYXRhX2dldF9pcnFfZGF0YShkKTsKKwl1bnNpZ25lZCBzdGF0dXMgPSBpcnFfZGVzY1tkLT5pcnFdLnN0YXR1czsKIAogCXN0YXR1cyAmPSBJUlFfVFlQRV9FREdFX0ZBTExJTkcgfCBJUlFfVFlQRV9FREdFX1JJU0lORzsKIAlpZiAoIXN0YXR1cykKQEAgLTIzMCwxOSArMjMwLDE5IEBACiAJCV9fcmF3X3dyaXRlbChtYXNrLCAmZy0+c2V0X3Jpc2luZyk7CiB9CiAKLXN0YXRpYyBpbnQgZ3Bpb19pcnFfdHlwZSh1bnNpZ25lZCBpcnEsIHVuc2lnbmVkIHRyaWdnZXIpCitzdGF0aWMgaW50IGdwaW9faXJxX3R5cGUoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCB0cmlnZ2VyKQogewotCXN0cnVjdCBkYXZpbmNpX2dwaW9fcmVncyBfX2lvbWVtICpnID0gaXJxMnJlZ3MoaXJxKTsKLQl1MzIgbWFzayA9ICh1MzIpIGdldF9pcnFfZGF0YShpcnEpOworCXN0cnVjdCBkYXZpbmNpX2dwaW9fcmVncyBfX2lvbWVtICpnID0gaXJxMnJlZ3MoZC0+aXJxKTsKKwl1MzIgbWFzayA9ICh1MzIpIGlycV9kYXRhX2dldF9pcnFfZGF0YShkKTsKIAogCWlmICh0cmlnZ2VyICYgfihJUlFfVFlQRV9FREdFX0ZBTExJTkcgfCBJUlFfVFlQRV9FREdFX1JJU0lORykpCiAJCXJldHVybiAtRUlOVkFMOwogCi0JaXJxX2Rlc2NbaXJxXS5zdGF0dXMgJj0gfklSUV9UWVBFX1NFTlNFX01BU0s7Ci0JaXJxX2Rlc2NbaXJxXS5zdGF0dXMgfD0gdHJpZ2dlcjsKKwlpcnFfZGVzY1tkLT5pcnFdLnN0YXR1cyAmPSB+SVJRX1RZUEVfU0VOU0VfTUFTSzsKKwlpcnFfZGVzY1tkLT5pcnFdLnN0YXR1cyB8PSB0cmlnZ2VyOwogCiAJLyogZG9uJ3QgZW5hYmxlIHRoZSBJUlEgaWYgaXQncyBjdXJyZW50bHkgZGlzYWJsZWQgKi8KLQlpZiAoaXJxX2Rlc2NbaXJxXS5kZXB0aCA9PSAwKSB7CisJaWYgKGlycV9kZXNjW2QtPmlycV0uZGVwdGggPT0gMCkgewogCQlfX3Jhd193cml0ZWwobWFzaywgKHRyaWdnZXIgJiBJUlFfVFlQRV9FREdFX0ZBTExJTkcpCiAJCQkgICAgID8gJmctPnNldF9mYWxsaW5nIDogJmctPmNscl9mYWxsaW5nKTsKIAkJX19yYXdfd3JpdGVsKG1hc2ssICh0cmlnZ2VyICYgSVJRX1RZUEVfRURHRV9SSVNJTkcpCkBAIC0yNTMsOSArMjUzLDkgQEAKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBncGlvX2lycWNoaXAgPSB7CiAJLm5hbWUJCT0gIkdQSU8iLAotCS5lbmFibGUJCT0gZ3Bpb19pcnFfZW5hYmxlLAotCS5kaXNhYmxlCT0gZ3Bpb19pcnFfZGlzYWJsZSwKLQkuc2V0X3R5cGUJPSBncGlvX2lycV90eXBlLAorCS5pcnFfZW5hYmxlCT0gZ3Bpb19pcnFfZW5hYmxlLAorCS5pcnFfZGlzYWJsZQk9IGdwaW9faXJxX2Rpc2FibGUsCisJLmlycV9zZXRfdHlwZQk9IGdwaW9faXJxX3R5cGUsCiB9OwogCiBzdGF0aWMgdm9pZApAQCAtMjY5LDggKzI2OSw4IEBACiAJCW1hc2sgPDw9IDE2OwogCiAJLyogdGVtcG9yYXJpbHkgbWFzayAobGV2ZWwgc2Vuc2l0aXZlKSBwYXJlbnQgSVJRICovCi0JZGVzYy0+Y2hpcC0+bWFzayhpcnEpOwotCWRlc2MtPmNoaXAtPmFjayhpcnEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9tYXNrKCZkZXNjLT5pcnFfZGF0YSk7CisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX2FjaygmZGVzYy0+aXJxX2RhdGEpOwogCXdoaWxlICgxKSB7CiAJCXUzMgkJc3RhdHVzOwogCQlpbnQJCW47CkBAIC0yOTMsNyArMjkzLDcgQEAKIAkJCXN0YXR1cyA+Pj0gcmVzOwogCQl9CiAJfQotCWRlc2MtPmNoaXAtPnVubWFzayhpcnEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV91bm1hc2soJmRlc2MtPmlycV9kYXRhKTsKIAkvKiBub3cgaXQgbWF5IHJlLXRyaWdnZXIgKi8KIH0KIApAQCAtMzIwLDEwICszMjAsMTAgQEAKIAkJcmV0dXJuIC1FTk9ERVY7CiB9CiAKLXN0YXRpYyBpbnQgZ3Bpb19pcnFfdHlwZV91bmJhbmtlZCh1bnNpZ25lZCBpcnEsIHVuc2lnbmVkIHRyaWdnZXIpCitzdGF0aWMgaW50IGdwaW9faXJxX3R5cGVfdW5iYW5rZWQoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCB0cmlnZ2VyKQogewotCXN0cnVjdCBkYXZpbmNpX2dwaW9fcmVncyBfX2lvbWVtICpnID0gaXJxMnJlZ3MoaXJxKTsKLQl1MzIgbWFzayA9ICh1MzIpIGdldF9pcnFfZGF0YShpcnEpOworCXN0cnVjdCBkYXZpbmNpX2dwaW9fcmVncyBfX2lvbWVtICpnID0gaXJxMnJlZ3MoZC0+aXJxKTsKKwl1MzIgbWFzayA9ICh1MzIpIGlycV9kYXRhX2dldF9pcnFfZGF0YShkKTsKIAogCWlmICh0cmlnZ2VyICYgfihJUlFfVFlQRV9FREdFX0ZBTExJTkcgfCBJUlFfVFlQRV9FREdFX1JJU0lORykpCiAJCXJldHVybiAtRUlOVkFMOwpAQCAtMzk3LDcgKzM5Nyw3IEBACiAJCWlycSA9IGJhbmtfaXJxOwogCQlncGlvX2lycWNoaXBfdW5iYW5rZWQgPSAqZ2V0X2lycV9kZXNjX2NoaXAoaXJxX3RvX2Rlc2MoaXJxKSk7CiAJCWdwaW9faXJxY2hpcF91bmJhbmtlZC5uYW1lID0gIkdQSU8tQUlOVEMiOwotCQlncGlvX2lycWNoaXBfdW5iYW5rZWQuc2V0X3R5cGUgPSBncGlvX2lycV90eXBlX3VuYmFua2VkOworCQlncGlvX2lycWNoaXBfdW5iYW5rZWQuaXJxX3NldF90eXBlID0gZ3Bpb19pcnFfdHlwZV91bmJhbmtlZDsKIAogCQkvKiBkZWZhdWx0IHRyaWdnZXI6IGJvdGggZWRnZXMgKi8KIAkJZyA9IGdwaW8ycmVncygwKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtZGF2aW5jaS9pcnEuYyBiL2FyY2gvYXJtL21hY2gtZGF2aW5jaS9pcnEuYwppbmRleCA3ODRkZGYzLi41ZTA1YzliIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWRhdmluY2kvaXJxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1kYXZpbmNpL2lycS5jCkBAIC01MywxNCArNTMsMTQgQEAKIH0KIAogLyogRGlzYWJsZSBpbnRlcnJ1cHQgKi8KLXN0YXRpYyB2b2lkIGRhdmluY2lfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGRhdmluY2lfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGludCBtYXNrOwogCXUzMiBsOwogCi0JbWFzayA9IDEgPDwgSVJRX0JJVChpcnEpOworCW1hc2sgPSAxIDw8IElSUV9CSVQoZC0+aXJxKTsKIAotCWlmIChpcnEgPiAzMSkgeworCWlmIChkLT5pcnEgPiAzMSkgewogCQlsID0gZGF2aW5jaV9pcnFfcmVhZGwoSVJRX0VOVF9SRUcxX09GRlNFVCk7CiAJCWwgJj0gfm1hc2s7CiAJCWRhdmluY2lfaXJxX3dyaXRlbChsLCBJUlFfRU5UX1JFRzFfT0ZGU0VUKTsKQEAgLTcyLDE0ICs3MiwxNCBAQAogfQogCiAvKiBFbmFibGUgaW50ZXJydXB0ICovCi1zdGF0aWMgdm9pZCBkYXZpbmNpX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGRhdmluY2lfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdW5zaWduZWQgaW50IG1hc2s7CiAJdTMyIGw7CiAKLQltYXNrID0gMSA8PCBJUlFfQklUKGlycSk7CisJbWFzayA9IDEgPDwgSVJRX0JJVChkLT5pcnEpOwogCi0JaWYgKGlycSA+IDMxKSB7CisJaWYgKGQtPmlycSA+IDMxKSB7CiAJCWwgPSBkYXZpbmNpX2lycV9yZWFkbChJUlFfRU5UX1JFRzFfT0ZGU0VUKTsKIAkJbCB8PSBtYXNrOwogCQlkYXZpbmNpX2lycV93cml0ZWwobCwgSVJRX0VOVF9SRUcxX09GRlNFVCk7CkBAIC05MSwyMyArOTEsMjMgQEAKIH0KIAogLyogRU9JIGludGVycnVwdCAqLwotc3RhdGljIHZvaWQgZGF2aW5jaV9hY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBkYXZpbmNpX2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGludCBtYXNrOwogCi0JbWFzayA9IDEgPDwgSVJRX0JJVChpcnEpOworCW1hc2sgPSAxIDw8IElSUV9CSVQoZC0+aXJxKTsKIAotCWlmIChpcnEgPiAzMSkKKwlpZiAoZC0+aXJxID4gMzEpCiAJCWRhdmluY2lfaXJxX3dyaXRlbChtYXNrLCBJUlFfUkVHMV9PRkZTRVQpOwogCWVsc2UKIAkJZGF2aW5jaV9pcnFfd3JpdGVsKG1hc2ssIElSUV9SRUcwX09GRlNFVCk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgZGF2aW5jaV9pcnFfY2hpcF8wID0gewotCS5uYW1lCT0gIkFJTlRDIiwKLQkuYWNrCT0gZGF2aW5jaV9hY2tfaXJxLAotCS5tYXNrCT0gZGF2aW5jaV9tYXNrX2lycSwKLQkudW5tYXNrID0gZGF2aW5jaV91bm1hc2tfaXJxLAorCS5uYW1lCQk9ICJBSU5UQyIsCisJLmlycV9hY2sJPSBkYXZpbmNpX2Fja19pcnEsCisJLmlycV9tYXNrCT0gZGF2aW5jaV9tYXNrX2lycSwKKwkuaXJxX3VubWFzawk9IGRhdmluY2lfdW5tYXNrX2lycSwKIH07CiAKIC8qIEFSTSBJbnRlcnJ1cHQgQ29udHJvbGxlciBJbml0aWFsaXphdGlvbiAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1kb3ZlL2lycS5jIGIvYXJjaC9hcm0vbWFjaC1kb3ZlL2lycS5jCmluZGV4IDYxYmZjYjMuLjkzMTdmMDUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtZG92ZS9pcnEuYworKysgYi9hcmNoL2FybS9tYWNoLWRvdmUvaXJxLmMKQEAgLTM2LDkgKzM2LDkgQEAKIAl9CiB9CiAKLXN0YXRpYyB2b2lkIHBtdV9pcnFfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgcG11X2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpbnQgcGluID0gaXJxX3RvX3BtdShpcnEpOworCWludCBwaW4gPSBpcnFfdG9fcG11KGQtPmlycSk7CiAJdTMyIHU7CiAKIAl1ID0gcmVhZGwoUE1VX0lOVEVSUlVQVF9NQVNLKTsKQEAgLTQ2LDkgKzQ2LDkgQEAKIAl3cml0ZWwodSwgUE1VX0lOVEVSUlVQVF9NQVNLKTsKIH0KIAotc3RhdGljIHZvaWQgcG11X2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHBtdV9pcnFfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpbnQgcGluID0gaXJxX3RvX3BtdShpcnEpOworCWludCBwaW4gPSBpcnFfdG9fcG11KGQtPmlycSk7CiAJdTMyIHU7CiAKIAl1ID0gcmVhZGwoUE1VX0lOVEVSUlVQVF9NQVNLKTsKQEAgLTU2LDkgKzU2LDkgQEAKIAl3cml0ZWwodSwgUE1VX0lOVEVSUlVQVF9NQVNLKTsKIH0KIAotc3RhdGljIHZvaWQgcG11X2lycV9hY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHBtdV9pcnFfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpbnQgcGluID0gaXJxX3RvX3BtdShpcnEpOworCWludCBwaW4gPSBpcnFfdG9fcG11KGQtPmlycSk7CiAJdTMyIHU7CiAKIAl1ID0gfigxIDw8IChwaW4gJiAzMSkpOwpAQCAtNjcsOSArNjcsOSBAQAogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHBtdV9pcnFfY2hpcCA9IHsKIAkubmFtZQkJPSAicG11X2lycSIsCi0JLm1hc2sJCT0gcG11X2lycV9tYXNrLAotCS51bm1hc2sJCT0gcG11X2lycV91bm1hc2ssCi0JLmFjawkJPSBwbXVfaXJxX2FjaywKKwkuaXJxX21hc2sJPSBwbXVfaXJxX21hc2ssCisJLmlycV91bm1hc2sJPSBwbXVfaXJxX3VubWFzaywKKwkuaXJxX2Fjawk9IHBtdV9pcnFfYWNrLAogfTsKIAogc3RhdGljIHZvaWQgcG11X2lycV9oYW5kbGVyKHVuc2lnbmVkIGludCBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtZWJzYTExMC9jb3JlLmMgYi9hcmNoL2FybS9tYWNoLWVic2ExMTAvY29yZS5jCmluZGV4IDVkZjQwOTkuLjdkZjA4M2YgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtZWJzYTExMC9jb3JlLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1lYnNhMTEwL2NvcmUuYwpAQCAtMzUsMjAgKzM1LDIwIEBACiAjZGVmaW5lIElSUV9TVEFUCQkweGZmMDAwMDAwCS8qIHJlYWQgKi8KICNkZWZpbmUgSVJRX01DTFIJCTB4ZmYwMDAwMDAJLyogd3JpdGUgKi8KIAotc3RhdGljIHZvaWQgZWJzYTExMF9tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgZWJzYTExMF9tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JX19yYXdfd3JpdGViKDEgPDwgaXJxLCBJUlFfTUNMUik7CisJX19yYXdfd3JpdGViKDEgPDwgZC0+aXJxLCBJUlFfTUNMUik7CiB9CiAKLXN0YXRpYyB2b2lkIGVic2ExMTBfdW5tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgZWJzYTExMF91bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlfX3Jhd193cml0ZWIoMSA8PCBpcnEsIElSUV9NU0VUKTsKKwlfX3Jhd193cml0ZWIoMSA8PCBkLT5pcnEsIElSUV9NU0VUKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBlYnNhMTEwX2lycV9jaGlwID0gewotCS5hY2sJPSBlYnNhMTEwX21hc2tfaXJxLAotCS5tYXNrCT0gZWJzYTExMF9tYXNrX2lycSwKLQkudW5tYXNrID0gZWJzYTExMF91bm1hc2tfaXJxLAorCS5pcnFfYWNrCT0gZWJzYTExMF9tYXNrX2lycSwKKwkuaXJxX21hc2sJPSBlYnNhMTEwX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gZWJzYTExMF91bm1hc2tfaXJxLAogfTsKICAKIHN0YXRpYyB2b2lkIF9faW5pdCBlYnNhMTEwX2luaXRfaXJxKHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWVwOTN4eC9jb3JlLmMgYi9hcmNoL2FybS9tYWNoLWVwOTN4eC9jb3JlLmMKaW5kZXggZmZkZjg3Yi4uODIwNzk1NCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1lcDkzeHgvY29yZS5jCisrKyBiL2FyY2gvYXJtL21hY2gtZXA5M3h4L2NvcmUuYwpAQCAtODM4LDcgKzgzOCw3IEBACiBzdGF0aWMgc3RydWN0IHJlc291cmNlIGVwOTN4eF9hYzk3X3Jlc291cmNlc1tdID0gewogCXsKIAkJLnN0YXJ0CT0gRVA5M1hYX0FBQ19QSFlTX0JBU0UsCi0JCS5lbmQJPSBFUDkzWFhfQUFDX1BIWVNfQkFTRSArIDB4YjAgLSAxLAorCQkuZW5kCT0gRVA5M1hYX0FBQ19QSFlTX0JBU0UgKyAweGFjIC0gMSwKIAkJLmZsYWdzCT0gSU9SRVNPVVJDRV9NRU0sCiAJfSwKIAl7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWVwOTN4eC9ncGlvLmMgYi9hcmNoL2FybS9tYWNoLWVwOTN4eC9ncGlvLmMKaW5kZXggY2Y1NDdhZC4uYmVjMzRiOCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1lcDkzeHgvZ3Bpby5jCisrKyBiL2FyY2gvYXJtL21hY2gtZXA5M3h4L2dwaW8uYwpAQCAtMTEyLDEzICsxMTIsMTMgQEAKIAlnZW5lcmljX2hhbmRsZV9pcnEoZ3Bpb19pcnEpOwogfQogCi1zdGF0aWMgdm9pZCBlcDkzeHhfZ3Bpb19pcnFfYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBlcDkzeHhfZ3Bpb19pcnFfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpbnQgbGluZSA9IGlycV90b19ncGlvKGlycSk7CisJaW50IGxpbmUgPSBpcnFfdG9fZ3BpbyhkLT5pcnEpOwogCWludCBwb3J0ID0gbGluZSA+PiAzOwogCWludCBwb3J0X21hc2sgPSAxIDw8IChsaW5lICYgNyk7CiAKLQlpZiAoKGlycV9kZXNjW2lycV0uc3RhdHVzICYgSVJRX1RZUEVfU0VOU0VfTUFTSykgPT0gSVJRX1RZUEVfRURHRV9CT1RIKSB7CisJaWYgKChpcnFfZGVzY1tkLT5pcnFdLnN0YXR1cyAmIElSUV9UWVBFX1NFTlNFX01BU0spID09IElSUV9UWVBFX0VER0VfQk9USCkgewogCQlncGlvX2ludF90eXBlMltwb3J0XSBePSBwb3J0X21hc2s7IC8qIHN3aXRjaCBlZGdlIGRpcmVjdGlvbiAqLwogCQllcDkzeHhfZ3Bpb191cGRhdGVfaW50X3BhcmFtcyhwb3J0KTsKIAl9CkBAIC0xMjYsMTMgKzEyNiwxMyBAQAogCV9fcmF3X3dyaXRlYihwb3J0X21hc2ssIEVQOTNYWF9HUElPX1JFRyhlb2lfcmVnaXN0ZXJfb2Zmc2V0W3BvcnRdKSk7CiB9CiAKLXN0YXRpYyB2b2lkIGVwOTN4eF9ncGlvX2lycV9tYXNrX2Fjayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgZXA5M3h4X2dwaW9faXJxX21hc2tfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpbnQgbGluZSA9IGlycV90b19ncGlvKGlycSk7CisJaW50IGxpbmUgPSBpcnFfdG9fZ3BpbyhkLT5pcnEpOwogCWludCBwb3J0ID0gbGluZSA+PiAzOwogCWludCBwb3J0X21hc2sgPSAxIDw8IChsaW5lICYgNyk7CiAKLQlpZiAoKGlycV9kZXNjW2lycV0uc3RhdHVzICYgSVJRX1RZUEVfU0VOU0VfTUFTSykgPT0gSVJRX1RZUEVfRURHRV9CT1RIKQorCWlmICgoaXJxX2Rlc2NbZC0+aXJxXS5zdGF0dXMgJiBJUlFfVFlQRV9TRU5TRV9NQVNLKSA9PSBJUlFfVFlQRV9FREdFX0JPVEgpCiAJCWdwaW9faW50X3R5cGUyW3BvcnRdIF49IHBvcnRfbWFzazsgLyogc3dpdGNoIGVkZ2UgZGlyZWN0aW9uICovCiAKIAlncGlvX2ludF91bm1hc2tlZFtwb3J0XSAmPSB+cG9ydF9tYXNrOwpAQCAtMTQxLDE4ICsxNDEsMTggQEAKIAlfX3Jhd193cml0ZWIocG9ydF9tYXNrLCBFUDkzWFhfR1BJT19SRUcoZW9pX3JlZ2lzdGVyX29mZnNldFtwb3J0XSkpOwogfQogCi1zdGF0aWMgdm9pZCBlcDkzeHhfZ3Bpb19pcnFfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgZXA5M3h4X2dwaW9faXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkKQogewotCWludCBsaW5lID0gaXJxX3RvX2dwaW8oaXJxKTsKKwlpbnQgbGluZSA9IGlycV90b19ncGlvKGQtPmlycSk7CiAJaW50IHBvcnQgPSBsaW5lID4+IDM7CiAKIAlncGlvX2ludF91bm1hc2tlZFtwb3J0XSAmPSB+KDEgPDwgKGxpbmUgJiA3KSk7CiAJZXA5M3h4X2dwaW9fdXBkYXRlX2ludF9wYXJhbXMocG9ydCk7CiB9CiAKLXN0YXRpYyB2b2lkIGVwOTN4eF9ncGlvX2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGVwOTN4eF9ncGlvX2lycV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQogewotCWludCBsaW5lID0gaXJxX3RvX2dwaW8oaXJxKTsKKwlpbnQgbGluZSA9IGlycV90b19ncGlvKGQtPmlycSk7CiAJaW50IHBvcnQgPSBsaW5lID4+IDM7CiAKIAlncGlvX2ludF91bm1hc2tlZFtwb3J0XSB8PSAxIDw8IChsaW5lICYgNyk7CkBAIC0xNjQsMTAgKzE2NCwxMCBAQAogICogZWRnZSAoMSkgdHJpZ2dlcmVkLCB3aGlsZSBncGlvX2ludF90eXBlMiBjb250cm9scyB3aGV0aGVyIGl0CiAgKiB0cmlnZ2VycyBvbiBsb3cvZmFsbGluZyAoMCkgb3IgaGlnaC9yaXNpbmcgKDEpLgogICovCi1zdGF0aWMgaW50IGVwOTN4eF9ncGlvX2lycV90eXBlKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCB0eXBlKQorc3RhdGljIGludCBlcDkzeHhfZ3Bpb19pcnFfdHlwZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCB0eXBlKQogewotCXN0cnVjdCBpcnFfZGVzYyAqZGVzYyA9IGlycV9kZXNjICsgaXJxOwotCWNvbnN0IGludCBncGlvID0gaXJxX3RvX2dwaW8oaXJxKTsKKwlzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MgPSBpcnFfZGVzYyArIGQtPmlycTsKKwljb25zdCBpbnQgZ3BpbyA9IGlycV90b19ncGlvKGQtPmlycSk7CiAJY29uc3QgaW50IHBvcnQgPSBncGlvID4+IDM7CiAJY29uc3QgaW50IHBvcnRfbWFzayA9IDEgPDwgKGdwaW8gJiA3KTsKIApAQCAtMjIwLDExICsyMjAsMTEgQEAKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBlcDkzeHhfZ3Bpb19pcnFfY2hpcCA9IHsKIAkubmFtZQkJPSAiR1BJTyIsCi0JLmFjawkJPSBlcDkzeHhfZ3Bpb19pcnFfYWNrLAotCS5tYXNrX2Fjawk9IGVwOTN4eF9ncGlvX2lycV9tYXNrX2FjaywKLQkubWFzawkJPSBlcDkzeHhfZ3Bpb19pcnFfbWFzaywKLQkudW5tYXNrCQk9IGVwOTN4eF9ncGlvX2lycV91bm1hc2ssCi0JLnNldF90eXBlCT0gZXA5M3h4X2dwaW9faXJxX3R5cGUsCisJLmlycV9hY2sJPSBlcDkzeHhfZ3Bpb19pcnFfYWNrLAorCS5pcnFfbWFza19hY2sJPSBlcDkzeHhfZ3Bpb19pcnFfbWFza19hY2ssCisJLmlycV9tYXNrCT0gZXA5M3h4X2dwaW9faXJxX21hc2ssCisJLmlycV91bm1hc2sJPSBlcDkzeHhfZ3Bpb19pcnFfdW5tYXNrLAorCS5pcnFfc2V0X3R5cGUJPSBlcDkzeHhfZ3Bpb19pcnFfdHlwZSwKIH07CiAKIHZvaWQgX19pbml0IGVwOTN4eF9ncGlvX2luaXRfaXJxKHZvaWQpCkBAIC00MjcsNiArNDI3LDEzIEBACiB7CiAJaW50IGk7CiAKKwkvKiBTZXQgUG9ydHMgQywgRCwgRSwgRywgYW5kIEggZm9yIEdQSU8gdXNlICovCisJZXA5M3h4X2RldmNmZ19zZXRfYml0cyhFUDkzWFhfU1lTQ09OX0RFVkNGR19LRVlTIHwKKwkJCQkgRVA5M1hYX1NZU0NPTl9ERVZDRkdfR09OSyB8CisJCQkJIEVQOTNYWF9TWVNDT05fREVWQ0ZHX0VPTklERSB8CisJCQkJIEVQOTNYWF9TWVNDT05fREVWQ0ZHX0dPTklERSB8CisJCQkJIEVQOTNYWF9TWVNDT05fREVWQ0ZHX0hPTklERSk7CisKIAlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShlcDkzeHhfZ3Bpb19iYW5rcyk7IGkrKykKIAkJZ3Bpb2NoaXBfYWRkKCZlcDkzeHhfZ3Bpb19iYW5rc1tpXS5jaGlwKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtZm9vdGJyaWRnZS9jb21tb24uYyBiL2FyY2gvYXJtL21hY2gtZm9vdGJyaWRnZS9jb21tb24uYwppbmRleCA4OGIzZGQ4Li44NGM1ZjI1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWZvb3RicmlkZ2UvY29tbW9uLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1mb290YnJpZGdlL2NvbW1vbi5jCkBAIC03NSwyMCArNzUsMjAgQEAKIAlJUlFfTUFTS19QQ0lfUEVSUiwJLyogMTkgKi8KIH07CiAKLXN0YXRpYyB2b2lkIGZiX21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBmYl9tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JKkNTUl9JUlFfRElTQUJMRSA9IGZiX2lycV9tYXNrW19EQzIxMjg1X0lOUihpcnEpXTsKKwkqQ1NSX0lSUV9ESVNBQkxFID0gZmJfaXJxX21hc2tbX0RDMjEyODVfSU5SKGQtPmlycSldOwogfQogCi1zdGF0aWMgdm9pZCBmYl91bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBmYl91bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQkqQ1NSX0lSUV9FTkFCTEUgPSBmYl9pcnFfbWFza1tfREMyMTI4NV9JTlIoaXJxKV07CisJKkNTUl9JUlFfRU5BQkxFID0gZmJfaXJxX21hc2tbX0RDMjEyODVfSU5SKGQtPmlycSldOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGZiX2NoaXAgPSB7Ci0JLmFjawk9IGZiX21hc2tfaXJxLAotCS5tYXNrCT0gZmJfbWFza19pcnEsCi0JLnVubWFzayA9IGZiX3VubWFza19pcnEsCisJLmlycV9hY2sJPSBmYl9tYXNrX2lycSwKKwkuaXJxX21hc2sJPSBmYl9tYXNrX2lycSwKKwkuaXJxX3VubWFzawk9IGZiX3VubWFza19pcnEsCiB9OwogCiBzdGF0aWMgdm9pZCBfX2luaXQgX19mYl9pbml0X2lycSh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1mb290YnJpZGdlL2luY2x1ZGUvbWFjaC9kZWJ1Zy1tYWNyby5TIGIvYXJjaC9hcm0vbWFjaC1mb290YnJpZGdlL2luY2x1ZGUvbWFjaC9kZWJ1Zy1tYWNyby5TCmluZGV4IDNjOWUwYzQuLjMwYjk3MWQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtZm9vdGJyaWRnZS9pbmNsdWRlL21hY2gvZGVidWctbWFjcm8uUworKysgYi9hcmNoL2FybS9tYWNoLWZvb3RicmlkZ2UvaW5jbHVkZS9tYWNoL2RlYnVnLW1hY3JvLlMKQEAgLTE3LDggKzE3LDggQEAKIAkvKiBGb3IgTmV0V2luZGVyIGRlYnVnZ2luZyAqLwogCQkubWFjcm8JYWRkcnVhcnQsIHJwLCBydgogCQltb3YJXHJwLCAjMHgwMDAwMDNmOAotCQlvcnIJXHJ2LCBccnAsICMweDdjMDAwMDAwCUAgcGh5c2ljYWwKLQkJb3JyCVxycCwgXHJwLCAjMHhmZjAwMDAwMAlAIHZpcnR1YWwKKwkJb3JyCVxydiwgXHJwLCAjMHhmZjAwMDAwMAlAIHZpcnR1YWwKKwkJb3JyCVxycCwgXHJwLCAjMHg3YzAwMDAwMAlAIHBoeXNpY2FsCiAJCS5lbmRtCiAKICNkZWZpbmUgVUFSVF9TSElGVAkwCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWZvb3RicmlkZ2UvaXNhLWlycS5jIGIvYXJjaC9hcm0vbWFjaC1mb290YnJpZGdlL2lzYS1pcnEuYwppbmRleCA4YmZkMDZhLi5kZTdhNWNiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWZvb3RicmlkZ2UvaXNhLWlycS5jCisrKyBiL2FyY2gvYXJtL21hY2gtZm9vdGJyaWRnZS9pc2EtaXJxLmMKQEAgLTMwLDYxICszMCw2MSBAQAogCiAjaW5jbHVkZSAiY29tbW9uLmgiCiAKLXN0YXRpYyB2b2lkIGlzYV9tYXNrX3BpY19sb19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGlzYV9tYXNrX3BpY19sb19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXVuc2lnbmVkIGludCBtYXNrID0gMSA8PCAoaXJxICYgNyk7CisJdW5zaWduZWQgaW50IG1hc2sgPSAxIDw8IChkLT5pcnEgJiA3KTsKIAogCW91dGIoaW5iKFBJQ19NQVNLX0xPKSB8IG1hc2ssIFBJQ19NQVNLX0xPKTsKIH0KIAotc3RhdGljIHZvaWQgaXNhX2Fja19waWNfbG9faXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpc2FfYWNrX3BpY19sb19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXVuc2lnbmVkIGludCBtYXNrID0gMSA8PCAoaXJxICYgNyk7CisJdW5zaWduZWQgaW50IG1hc2sgPSAxIDw8IChkLT5pcnEgJiA3KTsKIAogCW91dGIoaW5iKFBJQ19NQVNLX0xPKSB8IG1hc2ssIFBJQ19NQVNLX0xPKTsKIAlvdXRiKDB4MjAsIFBJQ19MTyk7CiB9CiAKLXN0YXRpYyB2b2lkIGlzYV91bm1hc2tfcGljX2xvX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaXNhX3VubWFza19waWNfbG9faXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl1bnNpZ25lZCBpbnQgbWFzayA9IDEgPDwgKGlycSAmIDcpOworCXVuc2lnbmVkIGludCBtYXNrID0gMSA8PCAoZC0+aXJxICYgNyk7CiAKIAlvdXRiKGluYihQSUNfTUFTS19MTykgJiB+bWFzaywgUElDX01BU0tfTE8pOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGlzYV9sb19jaGlwID0gewotCS5hY2sJPSBpc2FfYWNrX3BpY19sb19pcnEsCi0JLm1hc2sJPSBpc2FfbWFza19waWNfbG9faXJxLAotCS51bm1hc2sgPSBpc2FfdW5tYXNrX3BpY19sb19pcnEsCisJLmlycV9hY2sJPSBpc2FfYWNrX3BpY19sb19pcnEsCisJLmlycV9tYXNrCT0gaXNhX21hc2tfcGljX2xvX2lycSwKKwkuaXJxX3VubWFzawk9IGlzYV91bm1hc2tfcGljX2xvX2lycSwKIH07CiAKLXN0YXRpYyB2b2lkIGlzYV9tYXNrX3BpY19oaV9pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGlzYV9tYXNrX3BpY19oaV9pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXVuc2lnbmVkIGludCBtYXNrID0gMSA8PCAoaXJxICYgNyk7CisJdW5zaWduZWQgaW50IG1hc2sgPSAxIDw8IChkLT5pcnEgJiA3KTsKIAogCW91dGIoaW5iKFBJQ19NQVNLX0hJKSB8IG1hc2ssIFBJQ19NQVNLX0hJKTsKIH0KIAotc3RhdGljIHZvaWQgaXNhX2Fja19waWNfaGlfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpc2FfYWNrX3BpY19oaV9pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXVuc2lnbmVkIGludCBtYXNrID0gMSA8PCAoaXJxICYgNyk7CisJdW5zaWduZWQgaW50IG1hc2sgPSAxIDw8IChkLT5pcnEgJiA3KTsKIAogCW91dGIoaW5iKFBJQ19NQVNLX0hJKSB8IG1hc2ssIFBJQ19NQVNLX0hJKTsKIAlvdXRiKDB4NjIsIFBJQ19MTyk7CiAJb3V0YigweDIwLCBQSUNfSEkpOwogfQogCi1zdGF0aWMgdm9pZCBpc2FfdW5tYXNrX3BpY19oaV9pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGlzYV91bm1hc2tfcGljX2hpX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JdW5zaWduZWQgaW50IG1hc2sgPSAxIDw8IChpcnEgJiA3KTsKKwl1bnNpZ25lZCBpbnQgbWFzayA9IDEgPDwgKGQtPmlycSAmIDcpOwogCiAJb3V0YihpbmIoUElDX01BU0tfSEkpICYgfm1hc2ssIFBJQ19NQVNLX0hJKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBpc2FfaGlfY2hpcCA9IHsKLQkuYWNrCT0gaXNhX2Fja19waWNfaGlfaXJxLAotCS5tYXNrCT0gaXNhX21hc2tfcGljX2hpX2lycSwKLQkudW5tYXNrID0gaXNhX3VubWFza19waWNfaGlfaXJxLAorCS5pcnFfYWNrCT0gaXNhX2Fja19waWNfaGlfaXJxLAorCS5pcnFfbWFzawk9IGlzYV9tYXNrX3BpY19oaV9pcnEsCisJLmlycV91bm1hc2sJPSBpc2FfdW5tYXNrX3BpY19oaV9pcnEsCiB9OwogCiBzdGF0aWMgdm9pZApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1nZW1pbmkvZ3Bpby5jIGIvYXJjaC9hcm0vbWFjaC1nZW1pbmkvZ3Bpby5jCmluZGV4IGZlM2JkNWEuLmZhM2QzMzMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtZ2VtaW5pL2dwaW8uYworKysgYi9hcmNoL2FybS9tYWNoLWdlbWluaS9ncGlvLmMKQEAgLTU0LDMzICs1NCwzMyBAQAogCV9fcmF3X3dyaXRlbChyZWcsIGJhc2UgKyBHUElPX0lOVF9FTik7CiB9CiAKLXN0YXRpYyB2b2lkIGdwaW9fYWNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgZ3Bpb19hY2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl1bnNpZ25lZCBpbnQgZ3BpbyA9IGlycV90b19ncGlvKGlycSk7CisJdW5zaWduZWQgaW50IGdwaW8gPSBpcnFfdG9fZ3BpbyhkLT5pcnEpOwogCXVuc2lnbmVkIGludCBiYXNlID0gR1BJT19CQVNFKGdwaW8gLyAzMik7CiAKIAlfX3Jhd193cml0ZWwoMSA8PCAoZ3BpbyAlIDMyKSwgYmFzZSArIEdQSU9fSU5UX0NMUik7CiB9CiAKLXN0YXRpYyB2b2lkIGdwaW9fbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGdwaW9fbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXVuc2lnbmVkIGludCBncGlvID0gaXJxX3RvX2dwaW8oaXJxKTsKKwl1bnNpZ25lZCBpbnQgZ3BpbyA9IGlycV90b19ncGlvKGQtPmlycSk7CiAJdW5zaWduZWQgaW50IGJhc2UgPSBHUElPX0JBU0UoZ3BpbyAvIDMyKTsKIAogCV9zZXRfZ3Bpb19pcnFlbmFibGUoYmFzZSwgZ3BpbyAlIDMyLCAwKTsKIH0KIAotc3RhdGljIHZvaWQgZ3Bpb191bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBncGlvX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXVuc2lnbmVkIGludCBncGlvID0gaXJxX3RvX2dwaW8oaXJxKTsKKwl1bnNpZ25lZCBpbnQgZ3BpbyA9IGlycV90b19ncGlvKGQtPmlycSk7CiAJdW5zaWduZWQgaW50IGJhc2UgPSBHUElPX0JBU0UoZ3BpbyAvIDMyKTsKIAogCV9zZXRfZ3Bpb19pcnFlbmFibGUoYmFzZSwgZ3BpbyAlIDMyLCAxKTsKIH0KIAotc3RhdGljIGludCBncGlvX3NldF9pcnFfdHlwZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgdHlwZSkKK3N0YXRpYyBpbnQgZ3Bpb19zZXRfaXJxX3R5cGUoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgdHlwZSkKIHsKLQl1bnNpZ25lZCBpbnQgZ3BpbyA9IGlycV90b19ncGlvKGlycSk7CisJdW5zaWduZWQgaW50IGdwaW8gPSBpcnFfdG9fZ3BpbyhkLT5pcnEpOwogCXVuc2lnbmVkIGludCBncGlvX21hc2sgPSAxIDw8IChncGlvICUgMzIpOwogCXVuc2lnbmVkIGludCBiYXNlID0gR1BJT19CQVNFKGdwaW8gLyAzMik7CiAJdW5zaWduZWQgaW50IHJlZ19ib3RoLCByZWdfbGV2ZWwsIHJlZ190eXBlOwpAQCAtMTIwLDcgKzEyMCw3IEBACiAJX19yYXdfd3JpdGVsKHJlZ19sZXZlbCwgYmFzZSArIEdQSU9fSU5UX0xFVkVMKTsKIAlfX3Jhd193cml0ZWwocmVnX2JvdGgsIGJhc2UgKyBHUElPX0lOVF9CT1RIX0VER0UpOwogCi0JZ3Bpb19hY2tfaXJxKGlycSk7CisJZ3Bpb19hY2tfaXJxKGQtPmlycSk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTE0NiwxMCArMTQ2LDEwIEBACiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgZ3Bpb19pcnFfY2hpcCA9IHsKIAkubmFtZSA9ICJHUElPIiwKLQkuYWNrID0gZ3Bpb19hY2tfaXJxLAotCS5tYXNrID0gZ3Bpb19tYXNrX2lycSwKLQkudW5tYXNrID0gZ3Bpb191bm1hc2tfaXJxLAotCS5zZXRfdHlwZSA9IGdwaW9fc2V0X2lycV90eXBlLAorCS5pcnFfYWNrID0gZ3Bpb19hY2tfaXJxLAorCS5pcnFfbWFzayA9IGdwaW9fbWFza19pcnEsCisJLmlycV91bm1hc2sgPSBncGlvX3VubWFza19pcnEsCisJLmlycV9zZXRfdHlwZSA9IGdwaW9fc2V0X2lycV90eXBlLAogfTsKIAogc3RhdGljIHZvaWQgX3NldF9ncGlvX2RpcmVjdGlvbihzdHJ1Y3QgZ3Bpb19jaGlwICpjaGlwLCB1bnNpZ25lZCBvZmZzZXQsCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWdlbWluaS9pcnEuYyBiL2FyY2gvYXJtL21hY2gtZ2VtaW5pL2lycS5jCmluZGV4IDllNjEzY2EuLjk2YmMyMjcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtZ2VtaW5pL2lycS5jCisrKyBiL2FyY2gvYXJtL21hY2gtZ2VtaW5pL2lycS5jCkBAIC0zMiwzNCArMzIsMzQgQEAKICNkZWZpbmUgRklRX0xFVkVMKGJhc2VfYWRkcikJKGJhc2VfYWRkciArIDB4MzApCiAjZGVmaW5lIEZJUV9TVEFUVVMoYmFzZV9hZGRyKQkoYmFzZV9hZGRyICsgMHgzNCkKIAotc3RhdGljIHZvaWQgZ2VtaW5pX2Fja19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGdlbWluaV9hY2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlfX3Jhd193cml0ZWwoMSA8PCBpcnEsIElSUV9DTEVBUihJT19BRERSRVNTKEdFTUlOSV9JTlRFUlJVUFRfQkFTRSkpKTsKKwlfX3Jhd193cml0ZWwoMSA8PCBkLT5pcnEsIElSUV9DTEVBUihJT19BRERSRVNTKEdFTUlOSV9JTlRFUlJVUFRfQkFTRSkpKTsKIH0KIAotc3RhdGljIHZvaWQgZ2VtaW5pX21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBnZW1pbmlfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGludCBtYXNrOwogCiAJbWFzayA9IF9fcmF3X3JlYWRsKElSUV9NQVNLKElPX0FERFJFU1MoR0VNSU5JX0lOVEVSUlVQVF9CQVNFKSkpOwotCW1hc2sgJj0gfigxIDw8IGlycSk7CisJbWFzayAmPSB+KDEgPDwgZC0+aXJxKTsKIAlfX3Jhd193cml0ZWwobWFzaywgSVJRX01BU0soSU9fQUREUkVTUyhHRU1JTklfSU5URVJSVVBUX0JBU0UpKSk7CiB9CiAKLXN0YXRpYyB2b2lkIGdlbWluaV91bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBnZW1pbmlfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdW5zaWduZWQgaW50IG1hc2s7CiAKIAltYXNrID0gX19yYXdfcmVhZGwoSVJRX01BU0soSU9fQUREUkVTUyhHRU1JTklfSU5URVJSVVBUX0JBU0UpKSk7Ci0JbWFzayB8PSAoMSA8PCBpcnEpOworCW1hc2sgfD0gKDEgPDwgZC0+aXJxKTsKIAlfX3Jhd193cml0ZWwobWFzaywgSVJRX01BU0soSU9fQUREUkVTUyhHRU1JTklfSU5URVJSVVBUX0JBU0UpKSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgZ2VtaW5pX2lycV9jaGlwID0gewotCS5uYW1lCT0gIklOVEMiLAotCS5hY2sJPSBnZW1pbmlfYWNrX2lycSwKLQkubWFzawk9IGdlbWluaV9tYXNrX2lycSwKLQkudW5tYXNrCT0gZ2VtaW5pX3VubWFza19pcnEsCisJLm5hbWUJCT0gIklOVEMiLAorCS5pcnFfYWNrCT0gZ2VtaW5pX2Fja19pcnEsCisJLmlycV9tYXNrCT0gZ2VtaW5pX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gZ2VtaW5pX3VubWFza19pcnEsCiB9OwogCiBzdGF0aWMgc3RydWN0IHJlc291cmNlIGlycV9yZXNvdXJjZSA9IHsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtaDcyMHgvY29tbW9uLmMgYi9hcmNoL2FybS9tYWNoLWg3MjB4L2NvbW1vbi5jCmluZGV4IGJkYjNmNjcuLjFmMjhjOTAgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtaDcyMHgvY29tbW9uLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1oNzIweC9jb21tb24uYwpAQCAtNTIsMTcgKzUyLDE3IEBACiAvKgogICogbWFzayBHbG9iYWwgaXJxJ3MKICAqLwotc3RhdGljIHZvaWQgbWFza19nbG9iYWxfaXJxICh1bnNpZ25lZCBpbnQgaXJxICkKK3N0YXRpYyB2b2lkIG1hc2tfZ2xvYmFsX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JQ1BVX1JFRyAoSVJRQ19WSVJULCBJUlFDX0lFUikgJj0gfigxIDw8IGlycSk7CisJQ1BVX1JFRyAoSVJRQ19WSVJULCBJUlFDX0lFUikgJj0gfigxIDw8IGQtPmlycSk7CiB9CiAKIC8qCiAgKiB1bm1hc2sgR2xvYmFsIGlycSdzCiAgKi8KLXN0YXRpYyB2b2lkIHVubWFza19nbG9iYWxfaXJxICh1bnNpZ25lZCBpbnQgaXJxICkKK3N0YXRpYyB2b2lkIHVubWFza19nbG9iYWxfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlDUFVfUkVHIChJUlFDX1ZJUlQsIElSUUNfSUVSKSB8PSAoMSA8PCBpcnEpOworCUNQVV9SRUcgKElSUUNfVklSVCwgSVJRQ19JRVIpIHw9ICgxIDw8IGQtPmlycSk7CiB9CiAKIApAQCAtNzAsMTAgKzcwLDEwIEBACiAgKiBhY2sgR1BJTyBpcnEncwogICogQWNrIG9ubHkgZm9yIGVkZ2UgdHJpZ2dlcmVkIGludCdzIHZhbGlkCiAgKi8KLXN0YXRpYyB2b2lkIGlubGluZSBhY2tfZ3Bpb19pcnEodTMyIGlycSkKK3N0YXRpYyB2b2lkIGlubGluZSBhY2tfZ3Bpb19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXUzMiByZWdfYmFzZSA9IEdQSU9fVklSVChJUlFfVE9fUkVHTk8oaXJxKSk7Ci0JdTMyIGJpdCA9IElSUV9UT19CSVQoaXJxKTsKKwl1MzIgcmVnX2Jhc2UgPSBHUElPX1ZJUlQoSVJRX1RPX1JFR05PKGQtPmlycSkpOworCXUzMiBiaXQgPSBJUlFfVE9fQklUKGQtPmlycSk7CiAJaWYgKCAoQ1BVX1JFRyAocmVnX2Jhc2UsIEdQSU9fRURHRSkgJiBiaXQpKQogCQlDUFVfUkVHIChyZWdfYmFzZSwgR1BJT19DTFIpID0gYml0OwogfQpAQCAtODEsMjAgKzgxLDIwIEBACiAvKgogICogbWFzayBHUElPIGlycSdzCiAgKi8KLXN0YXRpYyB2b2lkIGlubGluZSBtYXNrX2dwaW9faXJxKHUzMiBpcnEpCitzdGF0aWMgdm9pZCBpbmxpbmUgbWFza19ncGlvX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JdTMyIHJlZ19iYXNlID0gR1BJT19WSVJUKElSUV9UT19SRUdOTyhpcnEpKTsKLQl1MzIgYml0ID0gSVJRX1RPX0JJVChpcnEpOworCXUzMiByZWdfYmFzZSA9IEdQSU9fVklSVChJUlFfVE9fUkVHTk8oZC0+aXJxKSk7CisJdTMyIGJpdCA9IElSUV9UT19CSVQoZC0+aXJxKTsKIAlDUFVfUkVHIChyZWdfYmFzZSwgR1BJT19NQVNLKSAmPSB+Yml0OwogfQogCiAvKgogICogdW5tYXNrIEdQSU8gaXJxJ3MKICAqLwotc3RhdGljIHZvaWQgaW5saW5lIHVubWFza19ncGlvX2lycSh1MzIgaXJxKQorc3RhdGljIHZvaWQgaW5saW5lIHVubWFza19ncGlvX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JdTMyIHJlZ19iYXNlID0gR1BJT19WSVJUKElSUV9UT19SRUdOTyhpcnEpKTsKLQl1MzIgYml0ID0gSVJRX1RPX0JJVChpcnEpOworCXUzMiByZWdfYmFzZSA9IEdQSU9fVklSVChJUlFfVE9fUkVHTk8oZC0+aXJxKSk7CisJdTMyIGJpdCA9IElSUV9UT19CSVQoZC0+aXJxKTsKIAlDUFVfUkVHIChyZWdfYmFzZSwgR1BJT19NQVNLKSB8PSBiaXQ7CiB9CiAKQEAgLTE3MCwxNSArMTcwLDE1IEBACiAjZW5kaWYKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBoNzIweF9nbG9iYWxfY2hpcCA9IHsKLQkuYWNrID0gbWFza19nbG9iYWxfaXJxLAotCS5tYXNrID0gbWFza19nbG9iYWxfaXJxLAotCS51bm1hc2sgPSB1bm1hc2tfZ2xvYmFsX2lycSwKKwkuaXJxX2FjayA9IG1hc2tfZ2xvYmFsX2lycSwKKwkuaXJxX21hc2sgPSBtYXNrX2dsb2JhbF9pcnEsCisJLmlycV91bm1hc2sgPSB1bm1hc2tfZ2xvYmFsX2lycSwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgaDcyMHhfZ3Bpb19jaGlwID0gewotCS5hY2sgPSBhY2tfZ3Bpb19pcnEsCi0JLm1hc2sgPSBtYXNrX2dwaW9faXJxLAotCS51bm1hc2sgPSB1bm1hc2tfZ3Bpb19pcnEsCisJLmlycV9hY2sgPSBhY2tfZ3Bpb19pcnEsCisJLmlycV9tYXNrID0gbWFza19ncGlvX2lycSwKKwkuaXJxX3VubWFzayA9IHVubWFza19ncGlvX2lycSwKIH07CiAKIC8qCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWg3MjB4L2NwdS1oNzIwMi5jIGIvYXJjaC9hcm0vbWFjaC1oNzIweC9jcHUtaDcyMDIuYwppbmRleCBmZDMzYTE5Li5hYzNmOTE0IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWg3MjB4L2NwdS1oNzIwMi5jCisrKyBiL2FyY2gvYXJtL21hY2gtaDcyMHgvY3B1LWg3MjAyLmMKQEAgLTE0MSwyNyArMTQxLDI3IEBACiAvKgogICogbWFzayBtdWx0aXBsZXhlZCB0aW1lciBJUlFzCiAgKi8KLXN0YXRpYyB2b2lkIGlubGluZSBtYXNrX3RpbWVyeF9pcnEgKHUzMiBpcnEpCitzdGF0aWMgdm9pZCBpbmxpbmUgbWFza190aW1lcnhfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl1bnNpZ25lZCBpbnQgYml0OwotCWJpdCA9IDIgPDwgKChpcnEgPT0gSVJRX1RJTUVSNjRCKSA/IDQgOiAoaXJxIC0gSVJRX1RJTUVSMSkpOworCWJpdCA9IDIgPDwgKChkLT5pcnEgPT0gSVJRX1RJTUVSNjRCKSA/IDQgOiAoZC0+aXJxIC0gSVJRX1RJTUVSMSkpOwogCUNQVV9SRUcgKFRJTUVSX1ZJUlQsIFRJTUVSX1RPUENUUkwpICY9IH5iaXQ7CiB9CiAKIC8qCiAgKiB1bm1hc2sgbXVsdGlwbGV4ZWQgdGltZXIgSVJRcwogICovCi1zdGF0aWMgdm9pZCBpbmxpbmUgdW5tYXNrX3RpbWVyeF9pcnEgKHUzMiBpcnEpCitzdGF0aWMgdm9pZCBpbmxpbmUgdW5tYXNrX3RpbWVyeF9pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGludCBiaXQ7Ci0JYml0ID0gMiA8PCAoKGlycSA9PSBJUlFfVElNRVI2NEIpID8gNCA6IChpcnEgLSBJUlFfVElNRVIxKSk7CisJYml0ID0gMiA8PCAoKGQtPmlycSA9PSBJUlFfVElNRVI2NEIpID8gNCA6IChkLT5pcnEgLSBJUlFfVElNRVIxKSk7CiAJQ1BVX1JFRyAoVElNRVJfVklSVCwgVElNRVJfVE9QQ1RSTCkgfD0gYml0OwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGg3MjAyX3RpbWVyeF9jaGlwID0gewotCS5hY2sgPSBtYXNrX3RpbWVyeF9pcnEsCi0JLm1hc2sgPSBtYXNrX3RpbWVyeF9pcnEsCi0JLnVubWFzayA9IHVubWFza190aW1lcnhfaXJxLAorCS5pcnFfYWNrID0gbWFza190aW1lcnhfaXJxLAorCS5pcnFfbWFzayA9IG1hc2tfdGltZXJ4X2lycSwKKwkuaXJxX3VubWFzayA9IHVubWFza190aW1lcnhfaXJxLAogfTsKIAogc3RhdGljIHN0cnVjdCBpcnFhY3Rpb24gaDcyMDJfdGltZXJfaXJxID0gewpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1oNzIweC9oNzIwMS1ldmFsLmMgYi9hcmNoL2FybS9tYWNoLWg3MjB4L2g3MjAxLWV2YWwuYwppbmRleCA3OWYwYjg5Li42Mjk0NTRkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWg3MjB4L2g3MjAxLWV2YWwuYworKysgYi9hcmNoL2FybS9tYWNoLWg3MjB4L2g3MjAxLWV2YWwuYwpAQCAtMjMsNyArMjMsNiBAQAogI2luY2x1ZGUgPGFzbS90eXBlcy5oPgogI2luY2x1ZGUgPGFzbS9tYWNoLXR5cGVzLmg+CiAjaW5jbHVkZSA8YXNtL3BhZ2UuaD4KLSNpbmNsdWRlIDxhc20vcGd0YWJsZS5oPgogI2luY2x1ZGUgPGFzbS9tYWNoL2FyY2guaD4KICNpbmNsdWRlIDxtYWNoL2hhcmR3YXJlLmg+CiAjaW5jbHVkZSAiY29tbW9uLmgiCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWg3MjB4L2g3MjAyLWV2YWwuYyBiL2FyY2gvYXJtL21hY2gtaDcyMHgvaDcyMDItZXZhbC5jCmluZGV4IGNjMjhiMWUuLmU5ZjQ2YjYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtaDcyMHgvaDcyMDItZXZhbC5jCisrKyBiL2FyY2gvYXJtL21hY2gtaDcyMHgvaDcyMDItZXZhbC5jCkBAIC0yMyw3ICsyMyw2IEBACiAjaW5jbHVkZSA8YXNtL3R5cGVzLmg+CiAjaW5jbHVkZSA8YXNtL21hY2gtdHlwZXMuaD4KICNpbmNsdWRlIDxhc20vcGFnZS5oPgotI2luY2x1ZGUgPGFzbS9wZ3RhYmxlLmg+CiAjaW5jbHVkZSA8YXNtL21hY2gvYXJjaC5oPgogI2luY2x1ZGUgPG1hY2gvaXJxcy5oPgogI2luY2x1ZGUgPG1hY2gvaGFyZHdhcmUuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtaW14L0tjb25maWcgYi9hcmNoL2FybS9tYWNoLWlteC9LY29uZmlnCmluZGV4IDE3ZDJlNjAuLjU2Njg0YjUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtaW14L0tjb25maWcKKysrIGIvYXJjaC9hcm0vbWFjaC1pbXgvS2NvbmZpZwpAQCAtMjQzLDYgKzI0Myw3IEBACiAJc2VsZWN0IElNWF9IQVZFX1BMQVRGT1JNX01YQ19FSENJCiAJc2VsZWN0IElNWF9IQVZFX1BMQVRGT1JNX01YQ19NTUMKIAlzZWxlY3QgSU1YX0hBVkVfUExBVEZPUk1fU1BJX0lNWAorCXNlbGVjdCBNWENfREVCVUdfQk9BUkQKIAlzZWxlY3QgTVhDX1VMUEkgaWYgVVNCX1VMUEkKIAloZWxwCiAJICBJbmNsdWRlIHN1cHBvcnQgZm9yIE1YMjdQREsgcGxhdGZvcm0uIFRoaXMgaW5jbHVkZXMgc3BlY2lmaWMKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtaW14L21hY2gtbXgyNV8zZHMuYyBiL2FyY2gvYXJtL21hY2gtaW14L21hY2gtbXgyNV8zZHMuYwppbmRleCBhYTc2Y2ZkLi44MzgyZTc5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWlteC9tYWNoLW14MjVfM2RzLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1pbXgvbWFjaC1teDI1XzNkcy5jCkBAIC0xODAsNyArMTgwLDcgQEAKIAlLRVkoMywgMywgS0VZX1BPV0VSKSwKIH07CiAKLXN0YXRpYyBjb25zdCBzdHJ1Y3QgbWF0cml4X2tleW1hcF9kYXRhIG14MjVwZGtfa2V5bWFwX2RhdGEgX19pbml0ZGF0YSA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbWF0cml4X2tleW1hcF9kYXRhIG14MjVwZGtfa2V5bWFwX2RhdGEgX19pbml0Y29uc3QgPSB7CiAJLmtleW1hcAkJPSBteDI1cGRrX2tleW1hcCwKIAkua2V5bWFwX3NpemUJPSBBUlJBWV9TSVpFKG14MjVwZGtfa2V5bWFwKSwKIH07CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWlteC9tYWNoLW14MjdfM2RzLmMgYi9hcmNoL2FybS9tYWNoLWlteC9tYWNoLW14MjdfM2RzLmMKaW5kZXggNmZkMGY4Zi4uMTY0MzMxNSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1pbXgvbWFjaC1teDI3XzNkcy5jCisrKyBiL2FyY2gvYXJtL21hY2gtaW14L21hY2gtbXgyN18zZHMuYwpAQCAtMzcsMTIgKzM3LDE1IEBACiAjaW5jbHVkZSA8bWFjaC9jb21tb24uaD4KICNpbmNsdWRlIDxtYWNoL2lvbXV4LW14MjcuaD4KICNpbmNsdWRlIDxtYWNoL3VscGkuaD4KKyNpbmNsdWRlIDxtYWNoL2lycXMuaD4KKyNpbmNsdWRlIDxtYWNoLzNkc19kZWJ1Z2JvYXJkLmg+CiAKICNpbmNsdWRlICJkZXZpY2VzLWlteDI3LmgiCiAKICNkZWZpbmUgU0QxX0VOX0dQSU8gKEdQSU9fUE9SVEIgKyAyNSkKICNkZWZpbmUgT1RHX1BIWV9SRVNFVF9HUElPIChHUElPX1BPUlRCICsgMjMpCiAjZGVmaW5lIFNQSTJfU1MwIChHUElPX1BPUlREICsgMjEpCisjZGVmaW5lIEVYUElPX1BBUkVOVF9JTlQJKE1YQ19JTlRFUk5BTF9JUlFTICsgR1BJT19QT1JUQyArIDI4KQogCiBzdGF0aWMgY29uc3QgaW50IG14MjdwZGtfcGluc1tdIF9faW5pdGNvbnN0ID0gewogCS8qIFVBUlQxICovCkBAIC0yMTUsMTAgKzIxOCwxMCBAQAogCiBzdGF0aWMgc3RydWN0IG1jMTM3ODNfcmVndWxhdG9yX2luaXRfZGF0YSBteDI3XzNkc19yZWd1bGF0b3JzW10gPSB7CiAJewotCQkuaWQgPSBNQzEzNzgzX1JFR1VfVk1NQzEsCisJCS5pZCA9IE1DMTM3ODNfUkVHX1ZNTUMxLAogCQkuaW5pdF9kYXRhID0gJnZtbWMxX2luaXQsCiAJfSwgewotCQkuaWQgPSBNQzEzNzgzX1JFR1VfVkdFTiwKKwkJLmlkID0gTUMxMzc4M19SRUdfVkdFTiwKIAkJLmluaXRfZGF0YSA9ICZ2Z2VuX2luaXQsCiAJfSwKIH07CkBAIC0yNzYsNiArMjc5LDkgQEAKIAlpbXgyN19hZGRfc3BpX2lteDEoJnNwaTJfcGRhdGEpOwogCXNwaV9yZWdpc3Rlcl9ib2FyZF9pbmZvKG14MjdfM2RzX3NwaV9kZXZzLAogCQkJCQkJQVJSQVlfU0laRShteDI3XzNkc19zcGlfZGV2cykpOworCisJaWYgKG14Y19leHBpb19pbml0KE1YMjdfQ1M1X0JBU0VfQUREUiwgRVhQSU9fUEFSRU5UX0lOVCkpCisJCXByX3dhcm4oIkluaXQgb2YgdGhlIGRlYnVnYm9hcmQgZmFpbGVkLCBhbGwgZGV2aWNlcyBvbiB0aGUgZGVidWdib2FyZCBhcmUgdW51c2FibGUuXG4iKTsKIH0KIAogc3RhdGljIHZvaWQgX19pbml0IG14MjdwZGtfdGltZXJfaW5pdCh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1pbnRlZ3JhdG9yL2NwdS5jIGIvYXJjaC9hcm0vbWFjaC1pbnRlZ3JhdG9yL2NwdS5jCmluZGV4IGEzZmJjYjNhLi5mYmI0NTc3IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWludGVncmF0b3IvY3B1LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1pbnRlZ3JhdG9yL2NwdS5jCkBAIC0xNzMsNyArMTczLDcgQEAKIAogCWlmIChtYWNoaW5lX2lzX2ludGVncmF0b3IoKSkgewogCQl2Y28ucyA9IChjbV9vc2MgPj4gOCkgJiA3OwotCX0gZWxzZSBpZiAobWFjaGluZV9pc19jaW50ZWdyYXRvcigpKSB7CisJfSBlbHNlIHsKIAkJdmNvLnMgPSAxOwogCX0KIAl2Y28udiA9IGNtX29zYyAmIDI1NTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtaW50ZWdyYXRvci9pbnRlZ3JhdG9yX2FwLmMgYi9hcmNoL2FybS9tYWNoLWludGVncmF0b3IvaW50ZWdyYXRvcl9hcC5jCmluZGV4IDI3NzRkZjguLmI2NjY0NDMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtaW50ZWdyYXRvci9pbnRlZ3JhdG9yX2FwLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1pbnRlZ3JhdG9yL2ludGVncmF0b3JfYXAuYwpAQCAtMTU2LDIxICsxNTYsMjEgQEAKIAogI2RlZmluZSBJTlRFR1JBVE9SX1NDX1ZBTElEX0lOVAkweDAwM2ZmZmZmCiAKLXN0YXRpYyB2b2lkIHNjX21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzY19tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jd3JpdGVsKDEgPDwgaXJxLCBWQV9JQ19CQVNFICsgSVJRX0VOQUJMRV9DTEVBUik7CisJd3JpdGVsKDEgPDwgZC0+aXJxLCBWQV9JQ19CQVNFICsgSVJRX0VOQUJMRV9DTEVBUik7CiB9CiAKLXN0YXRpYyB2b2lkIHNjX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHNjX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXdyaXRlbCgxIDw8IGlycSwgVkFfSUNfQkFTRSArIElSUV9FTkFCTEVfU0VUKTsKKwl3cml0ZWwoMSA8PCBkLT5pcnEsIFZBX0lDX0JBU0UgKyBJUlFfRU5BQkxFX1NFVCk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgc2NfY2hpcCA9IHsKLQkubmFtZQk9ICJTQyIsCi0JLmFjawk9IHNjX21hc2tfaXJxLAotCS5tYXNrCT0gc2NfbWFza19pcnEsCi0JLnVubWFzayA9IHNjX3VubWFza19pcnEsCisJLm5hbWUJCT0gIlNDIiwKKwkuaXJxX2Fjawk9IHNjX21hc2tfaXJxLAorCS5pcnFfbWFzawk9IHNjX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gc2NfdW5tYXNrX2lycSwKIH07CiAKIHN0YXRpYyB2b2lkIF9faW5pdCBhcF9pbml0X2lycSh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1pbnRlZ3JhdG9yL2ludGVncmF0b3JfY3AuYyBiL2FyY2gvYXJtL21hY2gtaW50ZWdyYXRvci9pbnRlZ3JhdG9yX2NwLmMKaW5kZXggODVlNDhhNS4uZTkzMjdkYSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1pbnRlZ3JhdG9yL2ludGVncmF0b3JfY3AuYworKysgYi9hcmNoL2FybS9tYWNoLWludGVncmF0b3IvaW50ZWdyYXRvcl9jcC5jCkBAIC0xNDYsNjEgKzE0Niw2MSBAQAogI2RlZmluZSBzaWNfd3JpdGVsCV9fcmF3X3dyaXRlbAogI2RlZmluZSBzaWNfcmVhZGwJX19yYXdfcmVhZGwKIAotc3RhdGljIHZvaWQgY2ljX21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBjaWNfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCWlycSAtPSBJUlFfQ0lDX1NUQVJUOworCXVuc2lnbmVkIGludCBpcnEgPSBkLT5pcnEgLSBJUlFfQ0lDX1NUQVJUOwogCWNpY193cml0ZWwoMSA8PCBpcnEsIElOVENQX1ZBX0NJQ19CQVNFICsgSVJRX0VOQUJMRV9DTEVBUik7CiB9CiAKLXN0YXRpYyB2b2lkIGNpY191bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBjaWNfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaXJxIC09IElSUV9DSUNfU1RBUlQ7CisJdW5zaWduZWQgaW50IGlycSA9IGQtPmlycSAtIElSUV9DSUNfU1RBUlQ7CiAJY2ljX3dyaXRlbCgxIDw8IGlycSwgSU5UQ1BfVkFfQ0lDX0JBU0UgKyBJUlFfRU5BQkxFX1NFVCk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgY2ljX2NoaXAgPSB7Ci0JLm5hbWUJPSAiQ0lDIiwKLQkuYWNrCT0gY2ljX21hc2tfaXJxLAotCS5tYXNrCT0gY2ljX21hc2tfaXJxLAotCS51bm1hc2sJPSBjaWNfdW5tYXNrX2lycSwKKwkubmFtZQkJPSAiQ0lDIiwKKwkuaXJxX2Fjawk9IGNpY19tYXNrX2lycSwKKwkuaXJxX21hc2sJPSBjaWNfbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBjaWNfdW5tYXNrX2lycSwKIH07CiAKLXN0YXRpYyB2b2lkIHBpY19tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgcGljX21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpcnEgLT0gSVJRX1BJQ19TVEFSVDsKKwl1bnNpZ25lZCBpbnQgaXJxID0gZC0+aXJxIC0gSVJRX1BJQ19TVEFSVDsKIAlwaWNfd3JpdGVsKDEgPDwgaXJxLCBJTlRDUF9WQV9QSUNfQkFTRSArIElSUV9FTkFCTEVfQ0xFQVIpOwogfQogCi1zdGF0aWMgdm9pZCBwaWNfdW5tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgcGljX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCWlycSAtPSBJUlFfUElDX1NUQVJUOworCXVuc2lnbmVkIGludCBpcnEgPSBkLT5pcnEgLSBJUlFfUElDX1NUQVJUOwogCXBpY193cml0ZWwoMSA8PCBpcnEsIElOVENQX1ZBX1BJQ19CQVNFICsgSVJRX0VOQUJMRV9TRVQpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHBpY19jaGlwID0gewotCS5uYW1lCT0gIlBJQyIsCi0JLmFjawk9IHBpY19tYXNrX2lycSwKLQkubWFzawk9IHBpY19tYXNrX2lycSwKLQkudW5tYXNrID0gcGljX3VubWFza19pcnEsCisJLm5hbWUJCT0gIlBJQyIsCisJLmlycV9hY2sJPSBwaWNfbWFza19pcnEsCisJLmlycV9tYXNrCT0gcGljX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gcGljX3VubWFza19pcnEsCiB9OwogCi1zdGF0aWMgdm9pZCBzaWNfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHNpY19tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaXJxIC09IElSUV9TSUNfU1RBUlQ7CisJdW5zaWduZWQgaW50IGlycSA9IGQtPmlycSAtIElSUV9TSUNfU1RBUlQ7CiAJc2ljX3dyaXRlbCgxIDw8IGlycSwgSU5UQ1BfVkFfU0lDX0JBU0UgKyBJUlFfRU5BQkxFX0NMRUFSKTsKIH0KIAotc3RhdGljIHZvaWQgc2ljX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHNpY191bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpcnEgLT0gSVJRX1NJQ19TVEFSVDsKKwl1bnNpZ25lZCBpbnQgaXJxID0gZC0+aXJxIC0gSVJRX1NJQ19TVEFSVDsKIAlzaWNfd3JpdGVsKDEgPDwgaXJxLCBJTlRDUF9WQV9TSUNfQkFTRSArIElSUV9FTkFCTEVfU0VUKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzaWNfY2hpcCA9IHsKLQkubmFtZQk9ICJTSUMiLAotCS5hY2sJPSBzaWNfbWFza19pcnEsCi0JLm1hc2sJPSBzaWNfbWFza19pcnEsCi0JLnVubWFzawk9IHNpY191bm1hc2tfaXJxLAorCS5uYW1lCQk9ICJTSUMiLAorCS5pcnFfYWNrCT0gc2ljX21hc2tfaXJxLAorCS5pcnFfbWFzawk9IHNpY19tYXNrX2lycSwKKwkuaXJxX3VubWFzawk9IHNpY191bm1hc2tfaXJxLAogfTsKIAogc3RhdGljIHZvaWQKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtaW9wMTN4eC9pcnEuYyBiL2FyY2gvYXJtL21hY2gtaW9wMTN4eC9pcnEuYwppbmRleCAwZDA5OWNhLi5hMjMzNDcwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWlvcDEzeHgvaXJxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1pb3AxM3h4L2lycS5jCkBAIC0xMjMsNzkgKzEyMyw3OSBAQAogCiAvKiAwID0gSW50ZXJydXB0IE1hc2tlZCBhbmQgMSA9IEludGVycnVwdCBub3QgbWFza2VkICovCiBzdGF0aWMgdm9pZAotaW9wMTN4eF9pcnFfbWFzazAgKHVuc2lnbmVkIGludCBpcnEpCitpb3AxM3h4X2lycV9tYXNrMCAoc3RydWN0IGlycV9kYXRhICpkKQogewotCXdyaXRlX2ludGN0bF8wKHJlYWRfaW50Y3RsXzAoKSAmIH4oMSA8PCAoaXJxIC0gMCkpKTsKKwl3cml0ZV9pbnRjdGxfMChyZWFkX2ludGN0bF8wKCkgJiB+KDEgPDwgKGQtPmlycSAtIDApKSk7CiB9CiAKIHN0YXRpYyB2b2lkCi1pb3AxM3h4X2lycV9tYXNrMSAodW5zaWduZWQgaW50IGlycSkKK2lvcDEzeHhfaXJxX21hc2sxIChzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jd3JpdGVfaW50Y3RsXzEocmVhZF9pbnRjdGxfMSgpICYgfigxIDw8IChpcnEgLSAzMikpKTsKKwl3cml0ZV9pbnRjdGxfMShyZWFkX2ludGN0bF8xKCkgJiB+KDEgPDwgKGQtPmlycSAtIDMyKSkpOwogfQogCiBzdGF0aWMgdm9pZAotaW9wMTN4eF9pcnFfbWFzazIgKHVuc2lnbmVkIGludCBpcnEpCitpb3AxM3h4X2lycV9tYXNrMiAoc3RydWN0IGlycV9kYXRhICpkKQogewotCXdyaXRlX2ludGN0bF8yKHJlYWRfaW50Y3RsXzIoKSAmIH4oMSA8PCAoaXJxIC0gNjQpKSk7CisJd3JpdGVfaW50Y3RsXzIocmVhZF9pbnRjdGxfMigpICYgfigxIDw8IChkLT5pcnEgLSA2NCkpKTsKIH0KIAogc3RhdGljIHZvaWQKLWlvcDEzeHhfaXJxX21hc2szICh1bnNpZ25lZCBpbnQgaXJxKQoraW9wMTN4eF9pcnFfbWFzazMgKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl3cml0ZV9pbnRjdGxfMyhyZWFkX2ludGN0bF8zKCkgJiB+KDEgPDwgKGlycSAtIDk2KSkpOworCXdyaXRlX2ludGN0bF8zKHJlYWRfaW50Y3RsXzMoKSAmIH4oMSA8PCAoZC0+aXJxIC0gOTYpKSk7CiB9CiAKIHN0YXRpYyB2b2lkCi1pb3AxM3h4X2lycV91bm1hc2swKHVuc2lnbmVkIGludCBpcnEpCitpb3AxM3h4X2lycV91bm1hc2swKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl3cml0ZV9pbnRjdGxfMChyZWFkX2ludGN0bF8wKCkgfCAoMSA8PCAoaXJxIC0gMCkpKTsKKwl3cml0ZV9pbnRjdGxfMChyZWFkX2ludGN0bF8wKCkgfCAoMSA8PCAoZC0+aXJxIC0gMCkpKTsKIH0KIAogc3RhdGljIHZvaWQKLWlvcDEzeHhfaXJxX3VubWFzazEodW5zaWduZWQgaW50IGlycSkKK2lvcDEzeHhfaXJxX3VubWFzazEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXdyaXRlX2ludGN0bF8xKHJlYWRfaW50Y3RsXzEoKSB8ICgxIDw8IChpcnEgLSAzMikpKTsKKwl3cml0ZV9pbnRjdGxfMShyZWFkX2ludGN0bF8xKCkgfCAoMSA8PCAoZC0+aXJxIC0gMzIpKSk7CiB9CiAKIHN0YXRpYyB2b2lkCi1pb3AxM3h4X2lycV91bm1hc2syKHVuc2lnbmVkIGludCBpcnEpCitpb3AxM3h4X2lycV91bm1hc2syKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl3cml0ZV9pbnRjdGxfMihyZWFkX2ludGN0bF8yKCkgfCAoMSA8PCAoaXJxIC0gNjQpKSk7CisJd3JpdGVfaW50Y3RsXzIocmVhZF9pbnRjdGxfMigpIHwgKDEgPDwgKGQtPmlycSAtIDY0KSkpOwogfQogCiBzdGF0aWMgdm9pZAotaW9wMTN4eF9pcnFfdW5tYXNrMyh1bnNpZ25lZCBpbnQgaXJxKQoraW9wMTN4eF9pcnFfdW5tYXNrMyhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jd3JpdGVfaW50Y3RsXzMocmVhZF9pbnRjdGxfMygpIHwgKDEgPDwgKGlycSAtIDk2KSkpOworCXdyaXRlX2ludGN0bF8zKHJlYWRfaW50Y3RsXzMoKSB8ICgxIDw8IChkLT5pcnEgLSA5NikpKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBpb3AxM3h4X2lycWNoaXAxID0gewotCS5uYW1lCT0gIklPUDEzeHgtMSIsCi0JLmFjayAgICA9IGlvcDEzeHhfaXJxX21hc2swLAotCS5tYXNrICAgPSBpb3AxM3h4X2lycV9tYXNrMCwKLQkudW5tYXNrID0gaW9wMTN4eF9pcnFfdW5tYXNrMCwKKwkubmFtZSAgICAgICA9ICJJT1AxM3h4LTEiLAorCS5pcnFfYWNrICAgID0gaW9wMTN4eF9pcnFfbWFzazAsCisJLmlycV9tYXNrICAgPSBpb3AxM3h4X2lycV9tYXNrMCwKKwkuaXJxX3VubWFzayA9IGlvcDEzeHhfaXJxX3VubWFzazAsCiB9OwogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGlvcDEzeHhfaXJxY2hpcDIgPSB7Ci0JLm5hbWUJPSAiSU9QMTN4eC0yIiwKLQkuYWNrICAgID0gaW9wMTN4eF9pcnFfbWFzazEsCi0JLm1hc2sgICA9IGlvcDEzeHhfaXJxX21hc2sxLAotCS51bm1hc2sgPSBpb3AxM3h4X2lycV91bm1hc2sxLAorCS5uYW1lICAgICAgID0gIklPUDEzeHgtMiIsCisJLmlycV9hY2sgICAgPSBpb3AxM3h4X2lycV9tYXNrMSwKKwkuaXJxX21hc2sgICA9IGlvcDEzeHhfaXJxX21hc2sxLAorCS5pcnFfdW5tYXNrID0gaW9wMTN4eF9pcnFfdW5tYXNrMSwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgaW9wMTN4eF9pcnFjaGlwMyA9IHsKLQkubmFtZQk9ICJJT1AxM3h4LTMiLAotCS5hY2sgICAgPSBpb3AxM3h4X2lycV9tYXNrMiwKLQkubWFzayAgID0gaW9wMTN4eF9pcnFfbWFzazIsCi0JLnVubWFzayA9IGlvcDEzeHhfaXJxX3VubWFzazIsCisJLm5hbWUgICAgICAgPSAiSU9QMTN4eC0zIiwKKwkuaXJxX2FjayAgICA9IGlvcDEzeHhfaXJxX21hc2syLAorCS5pcnFfbWFzayAgID0gaW9wMTN4eF9pcnFfbWFzazIsCisJLmlycV91bm1hc2sgPSBpb3AxM3h4X2lycV91bm1hc2syLAogfTsKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBpb3AxM3h4X2lycWNoaXA0ID0gewotCS5uYW1lCT0gIklPUDEzeHgtNCIsCi0JLmFjayAgICA9IGlvcDEzeHhfaXJxX21hc2szLAotCS5tYXNrICAgPSBpb3AxM3h4X2lycV9tYXNrMywKLQkudW5tYXNrID0gaW9wMTN4eF9pcnFfdW5tYXNrMywKKwkubmFtZSAgICAgICA9ICJJT1AxM3h4LTQiLAorCS5pcnFfYWNrICAgID0gaW9wMTN4eF9pcnFfbWFzazMsCisJLmlycV9tYXNrICAgPSBpb3AxM3h4X2lycV9tYXNrMywKKwkuaXJxX3VubWFzayA9IGlvcDEzeHhfaXJxX3VubWFzazMsCiB9OwogCiBleHRlcm4gdm9pZCBpb3BfaW5pdF9jcDZfaGFuZGxlcih2b2lkKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtaW9wMTN4eC9tc2kuYyBiL2FyY2gvYXJtL21hY2gtaW9wMTN4eC9tc2kuYwppbmRleCA3MTQ5ZmNjLi5jOWMwMmUzIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWlvcDEzeHgvbXNpLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1pb3AxM3h4L21zaS5jCkBAIC0xNTYsMTQgKzE1NiwxNCBAQAogCWRlc3Ryb3lfaXJxKGlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIGlvcDEzeHhfbXNpX25vcCh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaW9wMTN4eF9tc2lfbm9wKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAlyZXR1cm47CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgaW9wMTN4eF9tc2lfY2hpcCA9IHsKIAkubmFtZSA9ICJQQ0ktTVNJIiwKLQkuYWNrID0gaW9wMTN4eF9tc2lfbm9wLAorCS5pcnFfYWNrID0gaW9wMTN4eF9tc2lfbm9wLAogCS5pcnFfZW5hYmxlID0gdW5tYXNrX21zaV9pcnEsCiAJLmlycV9kaXNhYmxlID0gbWFza19tc2lfaXJxLAogCS5pcnFfbWFzayA9IG1hc2tfbXNpX2lycSwKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtaW9wMzJ4L2lycS5jIGIvYXJjaC9hcm0vbWFjaC1pb3AzMngvaXJxLmMKaW5kZXggYmE1OWIyZC4uZDM0MjZhMSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1pb3AzMngvaXJxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1pb3AzMngvaXJxLmMKQEAgLTMyLDI0ICszMiwyNCBAQAogfQogCiBzdGF0aWMgdm9pZAotaW9wMzJ4X2lycV9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitpb3AzMnhfaXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkKQogewotCWlvcDMyeF9tYXNrICY9IH4oMSA8PCBpcnEpOworCWlvcDMyeF9tYXNrICY9IH4oMSA8PCBkLT5pcnEpOwogCWludGN0bF93cml0ZShpb3AzMnhfbWFzayk7CiB9CiAKIHN0YXRpYyB2b2lkCi1pb3AzMnhfaXJxX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQoraW9wMzJ4X2lycV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQogewotCWlvcDMyeF9tYXNrIHw9IDEgPDwgaXJxOworCWlvcDMyeF9tYXNrIHw9IDEgPDwgZC0+aXJxOwogCWludGN0bF93cml0ZShpb3AzMnhfbWFzayk7CiB9CiAKIHN0cnVjdCBpcnFfY2hpcCBleHRfY2hpcCA9IHsKLQkubmFtZQk9ICJJT1AzMngiLAotCS5hY2sJPSBpb3AzMnhfaXJxX21hc2ssCi0JLm1hc2sJPSBpb3AzMnhfaXJxX21hc2ssCi0JLnVubWFzawk9IGlvcDMyeF9pcnFfdW5tYXNrLAorCS5uYW1lCQk9ICJJT1AzMngiLAorCS5pcnFfYWNrCT0gaW9wMzJ4X2lycV9tYXNrLAorCS5pcnFfbWFzawk9IGlvcDMyeF9pcnFfbWFzaywKKwkuaXJxX3VubWFzawk9IGlvcDMyeF9pcnFfdW5tYXNrLAogfTsKIAogdm9pZCBfX2luaXQgaW9wMzJ4X2luaXRfaXJxKHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWlvcDMzeC9pcnEuYyBiL2FyY2gvYXJtL21hY2gtaW9wMzN4L2lycS5jCmluZGV4IGFiYjRlYTIuLjBmZjJmNzQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtaW9wMzN4L2lycS5jCisrKyBiL2FyY2gvYXJtL21hY2gtaW9wMzN4L2lycS5jCkBAIC01Myw0NSArNTMsNDUgQEAKIH0KIAogc3RhdGljIHZvaWQKLWlvcDMzeF9pcnFfbWFzazEgKHVuc2lnbmVkIGludCBpcnEpCitpb3AzM3hfaXJxX21hc2sxIChzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaW9wMzN4X21hc2swICY9IH4oMSA8PCBpcnEpOworCWlvcDMzeF9tYXNrMCAmPSB+KDEgPDwgZC0+aXJxKTsKIAlpbnRjdGwwX3dyaXRlKGlvcDMzeF9tYXNrMCk7CiB9CiAKIHN0YXRpYyB2b2lkCi1pb3AzM3hfaXJxX21hc2syICh1bnNpZ25lZCBpbnQgaXJxKQoraW9wMzN4X2lycV9tYXNrMiAoc3RydWN0IGlycV9kYXRhICpkKQogewotCWlvcDMzeF9tYXNrMSAmPSB+KDEgPDwgKGlycSAtIDMyKSk7CisJaW9wMzN4X21hc2sxICY9IH4oMSA8PCAoZC0+aXJxIC0gMzIpKTsKIAlpbnRjdGwxX3dyaXRlKGlvcDMzeF9tYXNrMSk7CiB9CiAKIHN0YXRpYyB2b2lkCi1pb3AzM3hfaXJxX3VubWFzazEodW5zaWduZWQgaW50IGlycSkKK2lvcDMzeF9pcnFfdW5tYXNrMShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaW9wMzN4X21hc2swIHw9IDEgPDwgaXJxOworCWlvcDMzeF9tYXNrMCB8PSAxIDw8IGQtPmlycTsKIAlpbnRjdGwwX3dyaXRlKGlvcDMzeF9tYXNrMCk7CiB9CiAKIHN0YXRpYyB2b2lkCi1pb3AzM3hfaXJxX3VubWFzazIodW5zaWduZWQgaW50IGlycSkKK2lvcDMzeF9pcnFfdW5tYXNrMihzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaW9wMzN4X21hc2sxIHw9ICgxIDw8IChpcnEgLSAzMikpOworCWlvcDMzeF9tYXNrMSB8PSAoMSA8PCAoZC0+aXJxIC0gMzIpKTsKIAlpbnRjdGwxX3dyaXRlKGlvcDMzeF9tYXNrMSk7CiB9CiAKIHN0cnVjdCBpcnFfY2hpcCBpb3AzM3hfaXJxY2hpcDEgPSB7Ci0JLm5hbWUJPSAiSU9QMzN4LTEiLAotCS5hY2sJPSBpb3AzM3hfaXJxX21hc2sxLAotCS5tYXNrCT0gaW9wMzN4X2lycV9tYXNrMSwKLQkudW5tYXNrCT0gaW9wMzN4X2lycV91bm1hc2sxLAorCS5uYW1lCQk9ICJJT1AzM3gtMSIsCisJLmlycV9hY2sJPSBpb3AzM3hfaXJxX21hc2sxLAorCS5pcnFfbWFzawk9IGlvcDMzeF9pcnFfbWFzazEsCisJLmlycV91bm1hc2sJPSBpb3AzM3hfaXJxX3VubWFzazEsCiB9OwogCiBzdHJ1Y3QgaXJxX2NoaXAgaW9wMzN4X2lycWNoaXAyID0gewotCS5uYW1lCT0gIklPUDMzeC0yIiwKLQkuYWNrCT0gaW9wMzN4X2lycV9tYXNrMiwKLQkubWFzawk9IGlvcDMzeF9pcnFfbWFzazIsCi0JLnVubWFzawk9IGlvcDMzeF9pcnFfdW5tYXNrMiwKKwkubmFtZQkJPSAiSU9QMzN4LTIiLAorCS5pcnFfYWNrCT0gaW9wMzN4X2lycV9tYXNrMiwKKwkuaXJxX21hc2sJPSBpb3AzM3hfaXJxX21hc2syLAorCS5pcnFfdW5tYXNrCT0gaW9wMzN4X2lycV91bm1hc2syLAogfTsKIAogdm9pZCBfX2luaXQgaW9wMzN4X2luaXRfaXJxKHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWl4cDIwMDAvY29yZS5jIGIvYXJjaC9hcm0vbWFjaC1peHAyMDAwL2NvcmUuYwppbmRleCBlMjRlM2QwLi41ZmM0ZTA2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWl4cDIwMDAvY29yZS5jCisrKyBiL2FyY2gvYXJtL21hY2gtaXhwMjAwMC9jb3JlLmMKQEAgLTMwOSw5ICszMDksOSBAQAogCX0KIH0KIAotc3RhdGljIGludCBpeHAyMDAwX0dQSU9faXJxX3R5cGUodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IHR5cGUpCitzdGF0aWMgaW50IGl4cDIwMDBfR1BJT19pcnFfdHlwZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCB0eXBlKQogewotCWludCBsaW5lID0gaXJxIC0gSVJRX0lYUDIwMDBfR1BJTzA7CisJaW50IGxpbmUgPSBkLT5pcnEgLSBJUlFfSVhQMjAwMF9HUElPMDsKIAogCS8qCiAJICogRmlyc3QsIGNvbmZpZ3VyZSB0aGlzIEdQSU8gbGluZSBhcyBhbiBpbnB1dC4KQEAgLTM0Miw4ICszNDIsMTAgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIHZvaWQgaXhwMjAwMF9HUElPX2lycV9tYXNrX2Fjayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaXhwMjAwMF9HUElPX2lycV9tYXNrX2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CisJdW5zaWduZWQgaW50IGlycSA9IGQtPmlycTsKKwogCWl4cDIwMDBfcmVnX3dyaXRlKElYUDIwMDBfR1BJT19JTkNSLCAoMSA8PCAoaXJxIC0gSVJRX0lYUDIwMDBfR1BJTzApKSk7CiAKIAlpeHAyMDAwX3JlZ193cml0ZShJWFAyMDAwX0dQSU9fRURTUiwgKDEgPDwgKGlycSAtIElSUV9JWFAyMDAwX0dQSU8wKSkpOwpAQCAtMzUxLDM4ICszNTMsNDIgQEAKIAlpeHAyMDAwX3JlZ193cmIoSVhQMjAwMF9HUElPX0lOU1QsICgxIDw8IChpcnEgLSBJUlFfSVhQMjAwMF9HUElPMCkpKTsKIH0KIAotc3RhdGljIHZvaWQgaXhwMjAwMF9HUElPX2lycV9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpeHAyMDAwX0dQSU9faXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkKQogeworCXVuc2lnbmVkIGludCBpcnEgPSBkLT5pcnE7CisKIAlpeHAyMDAwX3JlZ193cmIoSVhQMjAwMF9HUElPX0lOQ1IsICgxIDw8IChpcnEgLSBJUlFfSVhQMjAwMF9HUElPMCkpKTsKIH0KIAotc3RhdGljIHZvaWQgaXhwMjAwMF9HUElPX2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGl4cDIwMDBfR1BJT19pcnFfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKKwl1bnNpZ25lZCBpbnQgaXJxID0gZC0+aXJxOworCiAJaXhwMjAwMF9yZWdfd3JpdGUoSVhQMjAwMF9HUElPX0lOU1IsICgxIDw8IChpcnEgLSBJUlFfSVhQMjAwMF9HUElPMCkpKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBpeHAyMDAwX0dQSU9faXJxX2NoaXAgPSB7Ci0JLmFjawkJPSBpeHAyMDAwX0dQSU9faXJxX21hc2tfYWNrLAotCS5tYXNrCQk9IGl4cDIwMDBfR1BJT19pcnFfbWFzaywKLQkudW5tYXNrCQk9IGl4cDIwMDBfR1BJT19pcnFfdW5tYXNrLAotCS5zZXRfdHlwZQk9IGl4cDIwMDBfR1BJT19pcnFfdHlwZSwKKwkuaXJxX2Fjawk9IGl4cDIwMDBfR1BJT19pcnFfbWFza19hY2ssCisJLmlycV9tYXNrCT0gaXhwMjAwMF9HUElPX2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gaXhwMjAwMF9HUElPX2lycV91bm1hc2ssCisJLmlycV9zZXRfdHlwZQk9IGl4cDIwMDBfR1BJT19pcnFfdHlwZSwKIH07CiAKLXN0YXRpYyB2b2lkIGl4cDIwMDBfcGNpX2lycV9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpeHAyMDAwX3BjaV9pcnFfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdW5zaWduZWQgbG9uZyB0ZW1wID0gKklYUDIwMDBfUENJX1hTQ0FMRV9JTlRfRU5BQkxFOwotCWlmIChpcnEgPT0gSVJRX0lYUDIwMDBfUENJQSkKKwlpZiAoZC0+aXJxID09IElSUV9JWFAyMDAwX1BDSUEpCiAJCWl4cDIwMDBfcmVnX3dyYihJWFAyMDAwX1BDSV9YU0NBTEVfSU5UX0VOQUJMRSwgKHRlbXAgJiB+KDEgPDwgMjYpKSk7Ci0JZWxzZSBpZiAoaXJxID09IElSUV9JWFAyMDAwX1BDSUIpCisJZWxzZSBpZiAoZC0+aXJxID09IElSUV9JWFAyMDAwX1BDSUIpCiAJCWl4cDIwMDBfcmVnX3dyYihJWFAyMDAwX1BDSV9YU0NBTEVfSU5UX0VOQUJMRSwgKHRlbXAgJiB+KDEgPDwgMjcpKSk7CiB9CiAKLXN0YXRpYyB2b2lkIGl4cDIwMDBfcGNpX2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGl4cDIwMDBfcGNpX2lycV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGxvbmcgdGVtcCA9ICpJWFAyMDAwX1BDSV9YU0NBTEVfSU5UX0VOQUJMRTsKLQlpZiAoaXJxID09IElSUV9JWFAyMDAwX1BDSUEpCisJaWYgKGQtPmlycSA9PSBJUlFfSVhQMjAwMF9QQ0lBKQogCQlpeHAyMDAwX3JlZ193cml0ZShJWFAyMDAwX1BDSV9YU0NBTEVfSU5UX0VOQUJMRSwgKHRlbXAgfCAoMSA8PCAyNikpKTsKLQllbHNlIGlmIChpcnEgPT0gSVJRX0lYUDIwMDBfUENJQikKKwllbHNlIGlmIChkLT5pcnEgPT0gSVJRX0lYUDIwMDBfUENJQikKIAkJaXhwMjAwMF9yZWdfd3JpdGUoSVhQMjAwMF9QQ0lfWFNDQUxFX0lOVF9FTkFCTEUsICh0ZW1wIHwgKDEgPDwgMjcpKSk7CiB9CiAKQEAgLTQwMSw0NCArNDA3LDQ0IEBACiAJfQogfQogCi1zdGF0aWMgdm9pZCBpeHAyMDAwX2Vycl9pcnFfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaXhwMjAwMF9lcnJfaXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkKQogewogCWl4cDIwMDBfcmVnX3dyaXRlKElYUDIwMDBfSVJRX0VSUl9FTkFCTEVfQ0xSLAotCQkJKDEgPDwgKGlycSAtIElSUV9JWFAyMDAwX0RSQU0wX01JTl9FUlIpKSk7CisJCQkoMSA8PCAoZC0+aXJxIC0gSVJRX0lYUDIwMDBfRFJBTTBfTUlOX0VSUikpKTsKIH0KIAotc3RhdGljIHZvaWQgaXhwMjAwMF9lcnJfaXJxX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaXhwMjAwMF9lcnJfaXJxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJaXhwMjAwMF9yZWdfd3JpdGUoSVhQMjAwMF9JUlFfRVJSX0VOQUJMRV9TRVQsCi0JCQkoMSA8PCAoaXJxIC0gSVJRX0lYUDIwMDBfRFJBTTBfTUlOX0VSUikpKTsKKwkJCSgxIDw8IChkLT5pcnEgLSBJUlFfSVhQMjAwMF9EUkFNMF9NSU5fRVJSKSkpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGl4cDIwMDBfZXJyX2lycV9jaGlwID0gewotCS5hY2sJPSBpeHAyMDAwX2Vycl9pcnFfbWFzaywKLQkubWFzawk9IGl4cDIwMDBfZXJyX2lycV9tYXNrLAotCS51bm1hc2sJPSBpeHAyMDAwX2Vycl9pcnFfdW5tYXNrCisJLmlycV9hY2sJPSBpeHAyMDAwX2Vycl9pcnFfbWFzaywKKwkuaXJxX21hc2sJPSBpeHAyMDAwX2Vycl9pcnFfbWFzaywKKwkuaXJxX3VubWFzawk9IGl4cDIwMDBfZXJyX2lycV91bm1hc2sKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgaXhwMjAwMF9wY2lfaXJxX2NoaXAgPSB7Ci0JLmFjawk9IGl4cDIwMDBfcGNpX2lycV9tYXNrLAotCS5tYXNrCT0gaXhwMjAwMF9wY2lfaXJxX21hc2ssCi0JLnVubWFzawk9IGl4cDIwMDBfcGNpX2lycV91bm1hc2sKKwkuaXJxX2Fjawk9IGl4cDIwMDBfcGNpX2lycV9tYXNrLAorCS5pcnFfbWFzawk9IGl4cDIwMDBfcGNpX2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gaXhwMjAwMF9wY2lfaXJxX3VubWFzawogfTsKIAotc3RhdGljIHZvaWQgaXhwMjAwMF9pcnFfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaXhwMjAwMF9pcnFfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaXhwMjAwMF9yZWdfd3JiKElYUDIwMDBfSVJRX0VOQUJMRV9DTFIsICgxIDw8IGlycSkpOworCWl4cDIwMDBfcmVnX3dyYihJWFAyMDAwX0lSUV9FTkFCTEVfQ0xSLCAoMSA8PCBkLT5pcnEpKTsKIH0KIAotc3RhdGljIHZvaWQgaXhwMjAwMF9pcnFfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpeHAyMDAwX2lycV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQogewotCWl4cDIwMDBfcmVnX3dyaXRlKElYUDIwMDBfSVJRX0VOQUJMRV9TRVQsICgxIDw8IGlycSkpOworCWl4cDIwMDBfcmVnX3dyaXRlKElYUDIwMDBfSVJRX0VOQUJMRV9TRVQsICgxIDw8IGQtPmlycSkpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGl4cDIwMDBfaXJxX2NoaXAgPSB7Ci0JLmFjawk9IGl4cDIwMDBfaXJxX21hc2ssCi0JLm1hc2sJPSBpeHAyMDAwX2lycV9tYXNrLAotCS51bm1hc2sJPSBpeHAyMDAwX2lycV91bm1hc2sKKwkuaXJxX2Fjawk9IGl4cDIwMDBfaXJxX21hc2ssCisJLmlycV9tYXNrCT0gaXhwMjAwMF9pcnFfbWFzaywKKwkuaXJxX3VubWFzawk9IGl4cDIwMDBfaXJxX3VubWFzawogfTsKIAogdm9pZCBfX2luaXQgaXhwMjAwMF9pbml0X2lycSh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1peHAyMDAwL2l4ZHAyeDAwLmMgYi9hcmNoL2FybS9tYWNoLWl4cDIwMDAvaXhkcDJ4MDAuYwppbmRleCA5MWZmZmI5Li43ZDkwZDNmIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWl4cDIwMDAvaXhkcDJ4MDAuYworKysgYi9hcmNoL2FybS9tYWNoLWl4cDIwMDAvaXhkcDJ4MDAuYwpAQCAtNjMsNyArNjMsNyBAQAogfTsKICNlbmRpZgogCi1zdGF0aWMgdm9pZCBpeGRwMngwMF9pcnFfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaXhkcDJ4MDBfaXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGxvbmcgZHVtbXk7CiAJc3RhdGljIHN0cnVjdCBzbG93cG9ydF9jZmcgb2xkX2NmZzsKQEAgLTc4LDcgKzc4LDcgQEAKICNlbmRpZgogCiAJZHVtbXkgPSAqYm9hcmRfaXJxX21hc2s7Ci0JZHVtbXkgfD0gIElYUDIwMDBfQk9BUkRfSVJRX01BU0soaXJxKTsKKwlkdW1teSB8PSAgSVhQMjAwMF9CT0FSRF9JUlFfTUFTSyhkLT5pcnEpOwogCWl4cDIwMDBfcmVnX3dyYihib2FyZF9pcnFfbWFzaywgZHVtbXkpOwogCiAjaWZkZWYgQ09ORklHX0FSQ0hfSVhEUDI0MDAKQEAgLTg3LDcgKzg3LDcgQEAKICNlbmRpZgogfQogCi1zdGF0aWMgdm9pZCBpeGRwMngwMF9pcnFfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpeGRwMngwMF9pcnFfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl1bnNpZ25lZCBsb25nIGR1bW15OwogCXN0YXRpYyBzdHJ1Y3Qgc2xvd3BvcnRfY2ZnIG9sZF9jZmc7CkBAIC05OCw3ICs5OCw3IEBACiAjZW5kaWYKIAogCWR1bW15ID0gKmJvYXJkX2lycV9tYXNrOwotCWR1bW15ICY9ICB+SVhQMjAwMF9CT0FSRF9JUlFfTUFTSyhpcnEpOworCWR1bW15ICY9ICB+SVhQMjAwMF9CT0FSRF9JUlFfTUFTSyhkLT5pcnEpOwogCWl4cDIwMDBfcmVnX3dyYihib2FyZF9pcnFfbWFzaywgZHVtbXkpOwogCiAJaWYgKG1hY2hpbmVfaXNfaXhkcDI0MDAoKSkgCkBAIC0xMTEsNyArMTExLDcgQEAKIAlzdGF0aWMgc3RydWN0IHNsb3dwb3J0X2NmZyBvbGRfY2ZnOwogCWludCBpOwogCi0JZGVzYy0+Y2hpcC0+bWFzayhpcnEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9tYXNrKCZkZXNjLT5pcnFfZGF0YSk7CiAKICNpZmRlZiBDT05GSUdfQVJDSF9JWERQMjQwMAogCWlmIChtYWNoaW5lX2lzX2l4ZHAyNDAwKCkpCkBAIC0xMzMsMTMgKzEzMywxMyBAQAogCQl9CiAJfQogCi0JZGVzYy0+Y2hpcC0+dW5tYXNrKGlycSk7CisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX3VubWFzaygmZGVzYy0+aXJxX2RhdGEpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGl4ZHAyeDAwX2NwbGRfaXJxX2NoaXAgPSB7Ci0JLmFjawk9IGl4ZHAyeDAwX2lycV9tYXNrLAotCS5tYXNrCT0gaXhkcDJ4MDBfaXJxX21hc2ssCi0JLnVubWFzawk9IGl4ZHAyeDAwX2lycV91bm1hc2sKKwkuaXJxX2Fjawk9IGl4ZHAyeDAwX2lycV9tYXNrLAorCS5pcnFfbWFzawk9IGl4ZHAyeDAwX2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gaXhkcDJ4MDBfaXJxX3VubWFzawogfTsKIAogdm9pZCBfX2luaXQgaXhkcDJ4MDBfaW5pdF9pcnEodm9sYXRpbGUgdW5zaWduZWQgbG9uZyAqc3RhdF9yZWcsIHZvbGF0aWxlIHVuc2lnbmVkIGxvbmcgKm1hc2tfcmVnLCB1bnNpZ25lZCBsb25nIG5yX29mX2lycXMpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWl4cDIwMDAvaXhkcDJ4MDEuYyBiL2FyY2gvYXJtL21hY2gtaXhwMjAwMC9peGRwMngwMS5jCmluZGV4IDZjMTIxYmQuLjM0YjFiMmEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtaXhwMjAwMC9peGRwMngwMS5jCisrKyBiL2FyY2gvYXJtL21hY2gtaXhwMjAwMC9peGRwMngwMS5jCkBAIC00OCwxNiArNDgsMTYgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKiBJWERQMngwMSBJUlEgSGFuZGxpbmcKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotc3RhdGljIHZvaWQgaXhkcDJ4MDFfaXJxX21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGl4ZHAyeDAxX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAlpeHAyMDAwX3JlZ193cmIoSVhEUDJYMDFfSU5UX01BU0tfU0VUX1JFRywKLQkJCQlJWFAyMDAwX0JPQVJEX0lSUV9NQVNLKGlycSkpOworCQkJCUlYUDIwMDBfQk9BUkRfSVJRX01BU0soZC0+aXJxKSk7CiB9CiAKLXN0YXRpYyB2b2lkIGl4ZHAyeDAxX2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGl4ZHAyeDAxX2lycV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQogewogCWl4cDIwMDBfcmVnX3dyaXRlKElYRFAyWDAxX0lOVF9NQVNLX0NMUl9SRUcsCi0JCQkJSVhQMjAwMF9CT0FSRF9JUlFfTUFTSyhpcnEpKTsKKwkJCQlJWFAyMDAwX0JPQVJEX0lSUV9NQVNLKGQtPmlycSkpOwogfQogCiBzdGF0aWMgdTMyIHZhbGlkX2lycV9tYXNrOwpAQCAtNjcsNyArNjcsNyBAQAogCXUzMiBleF9pbnRlcnJ1cHQ7CiAJaW50IGk7CiAKLQlkZXNjLT5jaGlwLT5tYXNrKGlycSk7CisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX21hc2soJmRlc2MtPmlycV9kYXRhKTsKIAogCWV4X2ludGVycnVwdCA9ICpJWERQMlgwMV9JTlRfU1RBVF9SRUcgJiB2YWxpZF9pcnFfbWFzazsKIApAQCAtODMsMTMgKzgzLDEzIEBACiAJCX0KIAl9CiAKLQlkZXNjLT5jaGlwLT51bm1hc2soaXJxKTsKKwlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfdW5tYXNrKCZkZXNjLT5pcnFfZGF0YSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgaXhkcDJ4MDFfaXJxX2NoaXAgPSB7Ci0JLm1hc2sJPSBpeGRwMngwMV9pcnFfbWFzaywKLQkuYWNrCT0gaXhkcDJ4MDFfaXJxX21hc2ssCi0JLnVubWFzawk9IGl4ZHAyeDAxX2lycV91bm1hc2sKKwkuaXJxX21hc2sJPSBpeGRwMngwMV9pcnFfbWFzaywKKwkuaXJxX2Fjawk9IGl4ZHAyeDAxX2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gaXhkcDJ4MDFfaXJxX3VubWFzawogfTsKIAogLyoKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtaXhwMjN4eC9jb3JlLmMgYi9hcmNoL2FybS9tYWNoLWl4cDIzeHgvY29yZS5jCmluZGV4IGFhNGM0NDIuLjljOGEzMzkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtaXhwMjN4eC9jb3JlLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1peHAyM3h4L2NvcmUuYwpAQCAtMTExLDkgKzExMSw5IEBACiAKIHN0YXRpYyB2b2lkIGl4cDIzeHhfY29uZmlnX2lycSh1bnNpZ25lZCBpbnQsIGVudW0gaXhwMjN4eF9pcnFfdHlwZSk7CiAKLXN0YXRpYyBpbnQgaXhwMjN4eF9pcnFfc2V0X3R5cGUodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IHR5cGUpCitzdGF0aWMgaW50IGl4cDIzeHhfaXJxX3NldF90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IHR5cGUpCiB7Ci0JaW50IGxpbmUgPSBpcnEgLSBJUlFfSVhQMjNYWF9HUElPNiArIDY7CisJaW50IGxpbmUgPSBkLT5pcnEgLSBJUlFfSVhQMjNYWF9HUElPNiArIDY7CiAJdTMyIGludF9zdHlsZTsKIAllbnVtIGl4cDIzeHhfaXJxX3R5cGUgaXJxX3R5cGU7CiAJdm9sYXRpbGUgdTMyICppbnRfcmVnOwpAQCAtMTQ5LDcgKzE0OSw3IEBACiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAotCWl4cDIzeHhfY29uZmlnX2lycShpcnEsIGlycV90eXBlKTsKKwlpeHAyM3h4X2NvbmZpZ19pcnEoZC0+aXJxLCBpcnFfdHlwZSk7CiAKIAlpZiAobGluZSA+PSA4KSB7CS8qIHBpbnMgOC0xNSAqLwogCQlsaW5lIC09IDg7CkBAIC0xNzMsOSArMTczLDEwIEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyB2b2lkIGl4cDIzeHhfaXJxX21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGl4cDIzeHhfaXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkKQogewogCXZvbGF0aWxlIHVuc2lnbmVkIGxvbmcgKmludHJfcmVnOworCXVuc2lnbmVkIGludCBpcnEgPSBkLT5pcnE7CiAKIAlpZiAoaXJxID49IDU2KQogCQlpcnEgKz0gODsKQEAgLTE4NCw5ICsxODUsOSBAQAogCSppbnRyX3JlZyAmPSB+KDEgPDwgKGlycSAlIDMyKSk7CiB9CiAKLXN0YXRpYyB2b2lkIGl4cDIzeHhfaXJxX2Fjayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaXhwMjN4eF9pcnFfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpbnQgbGluZSA9IGlycSAtIElSUV9JWFAyM1hYX0dQSU82ICsgNjsKKwlpbnQgbGluZSA9IGQtPmlycSAtIElSUV9JWFAyM1hYX0dQSU82ICsgNjsKIAogCWlmICgobGluZSA8IDYpIHx8IChsaW5lID4gMTUpKQogCQlyZXR1cm47CkBAIC0xOTgsMTEgKzE5OSwxMiBAQAogICogTGV2ZWwgdHJpZ2dlcmVkIGludGVycnVwdHMgb24gR1BJTyBsaW5lcyBjYW4gb25seSBiZSBjbGVhcmVkIHdoZW4gdGhlCiAgKiBpbnRlcnJ1cHQgY29uZGl0aW9uIGRpc2FwcGVhcnMuCiAgKi8KLXN0YXRpYyB2b2lkIGl4cDIzeHhfaXJxX2xldmVsX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaXhwMjN4eF9pcnFfbGV2ZWxfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl2b2xhdGlsZSB1bnNpZ25lZCBsb25nICppbnRyX3JlZzsKKwl1bnNpZ25lZCBpbnQgaXJxID0gZC0+aXJxOwogCi0JaXhwMjN4eF9pcnFfYWNrKGlycSk7CisJaXhwMjN4eF9pcnFfYWNrKGQpOwogCiAJaWYgKGlycSA+PSA1NikKIAkJaXJxICs9IDg7CkBAIC0yMTEsOSArMjEzLDEwIEBACiAJKmludHJfcmVnIHw9ICgxIDw8IChpcnEgJSAzMikpOwogfQogCi1zdGF0aWMgdm9pZCBpeHAyM3h4X2lycV9lZGdlX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaXhwMjN4eF9pcnFfZWRnZV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQogewogCXZvbGF0aWxlIHVuc2lnbmVkIGxvbmcgKmludHJfcmVnOworCXVuc2lnbmVkIGludCBpcnEgPSBkLT5pcnE7CiAKIAlpZiAoaXJxID49IDU2KQogCQlpcnEgKz0gODsKQEAgLTIyMywyNiArMjI2LDMwIEBACiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgaXhwMjN4eF9pcnFfbGV2ZWxfY2hpcCA9IHsKLQkuYWNrCQk9IGl4cDIzeHhfaXJxX21hc2ssCi0JLm1hc2sJCT0gaXhwMjN4eF9pcnFfbWFzaywKLQkudW5tYXNrCQk9IGl4cDIzeHhfaXJxX2xldmVsX3VubWFzaywKLQkuc2V0X3R5cGUJPSBpeHAyM3h4X2lycV9zZXRfdHlwZQorCS5pcnFfYWNrCT0gaXhwMjN4eF9pcnFfbWFzaywKKwkuaXJxX21hc2sJPSBpeHAyM3h4X2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gaXhwMjN4eF9pcnFfbGV2ZWxfdW5tYXNrLAorCS5pcnFfc2V0X3R5cGUJPSBpeHAyM3h4X2lycV9zZXRfdHlwZQogfTsKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBpeHAyM3h4X2lycV9lZGdlX2NoaXAgPSB7Ci0JLmFjawkJPSBpeHAyM3h4X2lycV9hY2ssCi0JLm1hc2sJCT0gaXhwMjN4eF9pcnFfbWFzaywKLQkudW5tYXNrCQk9IGl4cDIzeHhfaXJxX2VkZ2VfdW5tYXNrLAotCS5zZXRfdHlwZQk9IGl4cDIzeHhfaXJxX3NldF90eXBlCisJLmlycV9hY2sJPSBpeHAyM3h4X2lycV9hY2ssCisJLmlycV9tYXNrCT0gaXhwMjN4eF9pcnFfbWFzaywKKwkuaXJxX3VubWFzawk9IGl4cDIzeHhfaXJxX2VkZ2VfdW5tYXNrLAorCS5pcnFfc2V0X3R5cGUJPSBpeHAyM3h4X2lycV9zZXRfdHlwZQogfTsKIAotc3RhdGljIHZvaWQgaXhwMjN4eF9wY2lfaXJxX21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGl4cDIzeHhfcGNpX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKKwl1bnNpZ25lZCBpbnQgaXJxID0gZC0+aXJxOworCiAJKklYUDIzWFhfUENJX1hTQ0FMRV9JTlRfRU5BQkxFICY9IH4oMSA8PCAoSVJRX0lYUDIzWFhfSU5UQSArIDI3IC0gaXJxKSk7CiB9CiAKLXN0YXRpYyB2b2lkIGl4cDIzeHhfcGNpX2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGl4cDIzeHhfcGNpX2lycV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQogeworCXVuc2lnbmVkIGludCBpcnEgPSBkLT5pcnE7CisKIAkqSVhQMjNYWF9QQ0lfWFNDQUxFX0lOVF9FTkFCTEUgfD0gKDEgPDwgKElSUV9JWFAyM1hYX0lOVEEgKyAyNyAtIGlycSkpOwogfQogCkBAIC0yNTYsNyArMjYzLDcgQEAKIAogCXBjaV9pbnRlcnJ1cHQgPSAqSVhQMjNYWF9QQ0lfWFNDQUxFX0lOVF9TVEFUVVM7CiAKLQlkZXNjLT5jaGlwLT5hY2soaXJxKTsKKwlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfYWNrKCZkZXNjLT5pcnFfZGF0YSk7CiAKIAkvKiBTZWUgd2hpY2ggUENJX0lOVEEsIG9yIFBDSV9JTlRCIGludGVycnVwdGVkICovCiAJaWYgKHBjaV9pbnRlcnJ1cHQgJiAoMSA8PCAyNikpIHsKQEAgLTI2OSwxMyArMjc2LDEzIEBACiAKIAlnZW5lcmljX2hhbmRsZV9pcnEoaXJxbm8pOwogCi0JZGVzYy0+Y2hpcC0+dW5tYXNrKGlycSk7CisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX3VubWFzaygmZGVzYy0+aXJxX2RhdGEpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGl4cDIzeHhfcGNpX2lycV9jaGlwID0gewotCS5hY2sJPSBpeHAyM3h4X3BjaV9pcnFfbWFzaywKLQkubWFzawk9IGl4cDIzeHhfcGNpX2lycV9tYXNrLAotCS51bm1hc2sJPSBpeHAyM3h4X3BjaV9pcnFfdW5tYXNrCisJLmlycV9hY2sJPSBpeHAyM3h4X3BjaV9pcnFfbWFzaywKKwkuaXJxX21hc2sJPSBpeHAyM3h4X3BjaV9pcnFfbWFzaywKKwkuaXJxX3VubWFzawk9IGl4cDIzeHhfcGNpX2lycV91bm1hc2sKIH07CiAKIHN0YXRpYyB2b2lkIGl4cDIzeHhfY29uZmlnX2lycSh1bnNpZ25lZCBpbnQgaXJxLCBlbnVtIGl4cDIzeHhfaXJxX3R5cGUgdHlwZSkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtaXhwMjN4eC9peGRwMjM1MS5jIGIvYXJjaC9hcm0vbWFjaC1peHAyM3h4L2l4ZHAyMzUxLmMKaW5kZXggNjY0ZTM5Yy4uMTgxMTE2YSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1peHAyM3h4L2l4ZHAyMzUxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1peHAyM3h4L2l4ZHAyMzUxLmMKQEAgLTQ4LDE0ICs0OCwxNCBAQAogLyoKICAqIElYRFAyMzUxIEludGVycnVwdCBIYW5kbGluZwogICovCi1zdGF0aWMgdm9pZCBpeGRwMjM1MV9pbnRhX21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGl4ZHAyMzUxX2ludGFfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JKklYRFAyMzUxX0NQTERfSU5UQV9NQVNLX1NFVF9SRUcgPSBJWERQMjM1MV9JTlRBX0lSUV9NQVNLKGlycSk7CisJKklYRFAyMzUxX0NQTERfSU5UQV9NQVNLX1NFVF9SRUcgPSBJWERQMjM1MV9JTlRBX0lSUV9NQVNLKGQtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIGl4ZHAyMzUxX2ludGFfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpeGRwMjM1MV9pbnRhX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JKklYRFAyMzUxX0NQTERfSU5UQV9NQVNLX0NMUl9SRUcgPSBJWERQMjM1MV9JTlRBX0lSUV9NQVNLKGlycSk7CisJKklYRFAyMzUxX0NQTERfSU5UQV9NQVNLX0NMUl9SRUcgPSBJWERQMjM1MV9JTlRBX0lSUV9NQVNLKGQtPmlycSk7CiB9CiAKIHN0YXRpYyB2b2lkIGl4ZHAyMzUxX2ludGFfaGFuZGxlcih1bnNpZ25lZCBpbnQgaXJxLCBzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MpCkBAIC02NCw3ICs2NCw3IEBACiAJCSpJWERQMjM1MV9DUExEX0lOVEFfU1RBVF9SRUcgJiBJWERQMjM1MV9JTlRBX0lSUV9WQUxJRDsKIAlpbnQgaTsKIAotCWRlc2MtPmNoaXAtPm1hc2soaXJxKTsKKwlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfbWFzaygmZGVzYy0+aXJxX2RhdGEpOwogCiAJZm9yIChpID0gMDsgaSA8IElYRFAyMzUxX0lOVEFfSVJRX05VTTsgaSsrKSB7CiAJCWlmIChleF9pbnRlcnJ1cHQgJiAoMSA8PCBpKSkgewpAQCAtNzQsMjMgKzc0LDIzIEBACiAJCX0KIAl9CiAKLQlkZXNjLT5jaGlwLT51bm1hc2soaXJxKTsKKwlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfdW5tYXNrKCZkZXNjLT5pcnFfZGF0YSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgaXhkcDIzNTFfaW50YV9jaGlwID0gewotCS5hY2sJPSBpeGRwMjM1MV9pbnRhX21hc2ssCi0JLm1hc2sJPSBpeGRwMjM1MV9pbnRhX21hc2ssCi0JLnVubWFzawk9IGl4ZHAyMzUxX2ludGFfdW5tYXNrCisJLmlycV9hY2sJPSBpeGRwMjM1MV9pbnRhX21hc2ssCisJLmlycV9tYXNrCT0gaXhkcDIzNTFfaW50YV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gaXhkcDIzNTFfaW50YV91bm1hc2sKIH07CiAKLXN0YXRpYyB2b2lkIGl4ZHAyMzUxX2ludGJfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaXhkcDIzNTFfaW50Yl9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQkqSVhEUDIzNTFfQ1BMRF9JTlRCX01BU0tfU0VUX1JFRyA9IElYRFAyMzUxX0lOVEJfSVJRX01BU0soaXJxKTsKKwkqSVhEUDIzNTFfQ1BMRF9JTlRCX01BU0tfU0VUX1JFRyA9IElYRFAyMzUxX0lOVEJfSVJRX01BU0soZC0+aXJxKTsKIH0KIAotc3RhdGljIHZvaWQgaXhkcDIzNTFfaW50Yl91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGl4ZHAyMzUxX2ludGJfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQkqSVhEUDIzNTFfQ1BMRF9JTlRCX01BU0tfQ0xSX1JFRyA9IElYRFAyMzUxX0lOVEJfSVJRX01BU0soaXJxKTsKKwkqSVhEUDIzNTFfQ1BMRF9JTlRCX01BU0tfQ0xSX1JFRyA9IElYRFAyMzUxX0lOVEJfSVJRX01BU0soZC0+aXJxKTsKIH0KIAogc3RhdGljIHZvaWQgaXhkcDIzNTFfaW50Yl9oYW5kbGVyKHVuc2lnbmVkIGludCBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKQEAgLTk5LDcgKzk5LDcgQEAKIAkJKklYRFAyMzUxX0NQTERfSU5UQl9TVEFUX1JFRyAmIElYRFAyMzUxX0lOVEJfSVJRX1ZBTElEOwogCWludCBpOwogCi0JZGVzYy0+Y2hpcC0+YWNrKGlycSk7CisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX2FjaygmZGVzYy0+aXJxX2RhdGEpOwogCiAJZm9yIChpID0gMDsgaSA8IElYRFAyMzUxX0lOVEJfSVJRX05VTTsgaSsrKSB7CiAJCWlmIChleF9pbnRlcnJ1cHQgJiAoMSA8PCBpKSkgewpAQCAtMTA5LDEzICsxMDksMTMgQEAKIAkJfQogCX0KIAotCWRlc2MtPmNoaXAtPnVubWFzayhpcnEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV91bm1hc2soJmRlc2MtPmlycV9kYXRhKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBpeGRwMjM1MV9pbnRiX2NoaXAgPSB7Ci0JLmFjawk9IGl4ZHAyMzUxX2ludGJfbWFzaywKLQkubWFzawk9IGl4ZHAyMzUxX2ludGJfbWFzaywKLQkudW5tYXNrCT0gaXhkcDIzNTFfaW50Yl91bm1hc2sKKwkuaXJxX2Fjawk9IGl4ZHAyMzUxX2ludGJfbWFzaywKKwkuaXJxX21hc2sJPSBpeGRwMjM1MV9pbnRiX21hc2ssCisJLmlycV91bm1hc2sJPSBpeGRwMjM1MV9pbnRiX3VubWFzawogfTsKIAogdm9pZCBfX2luaXQgaXhkcDIzNTFfaW5pdF9pcnEodm9pZCkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtaXhwNHh4L2NvbW1vbi5jIGIvYXJjaC9hcm0vbWFjaC1peHA0eHgvY29tbW9uLmMKaW5kZXggNGRiZmNiYi4uOWZkODk0MiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1peHA0eHgvY29tbW9uLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1peHA0eHgvY29tbW9uLmMKQEAgLTEyOCw5ICsxMjgsOSBAQAogfQogRVhQT1JUX1NZTUJPTChpcnFfdG9fZ3Bpbyk7CiAKLXN0YXRpYyBpbnQgaXhwNHh4X3NldF9pcnFfdHlwZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgdHlwZSkKK3N0YXRpYyBpbnQgaXhwNHh4X3NldF9pcnFfdHlwZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCB0eXBlKQogewotCWludCBsaW5lID0gaXJxMmdwaW9baXJxXTsKKwlpbnQgbGluZSA9IGlycTJncGlvW2QtPmlycV07CiAJdTMyIGludF9zdHlsZTsKIAllbnVtIGl4cDR4eF9pcnFfdHlwZSBpcnFfdHlwZTsKIAl2b2xhdGlsZSB1MzIgKmludF9yZWc7CkBAIC0xNjcsOSArMTY3LDkgQEAKIAl9CiAKIAlpZiAoaXJxX3R5cGUgPT0gSVhQNFhYX0lSUV9FREdFKQotCQlpeHA0eHhfaXJxX2VkZ2UgfD0gKDEgPDwgaXJxKTsKKwkJaXhwNHh4X2lycV9lZGdlIHw9ICgxIDw8IGQtPmlycSk7CiAJZWxzZQotCQlpeHA0eHhfaXJxX2VkZ2UgJj0gfigxIDw8IGlycSk7CisJCWl4cDR4eF9pcnFfZWRnZSAmPSB+KDEgPDwgZC0+aXJxKTsKIAogCWlmIChsaW5lID49IDgpIHsJLyogcGlucyA4LTE1ICovCiAJCWxpbmUgLT0gODsKQEAgLTE4OCwyMiArMTg4LDIyIEBACiAJKmludF9yZWcgfD0gKGludF9zdHlsZSA8PCAobGluZSAqIElYUDRYWF9HUElPX1NUWUxFX1NJWkUpKTsKIAogCS8qIENvbmZpZ3VyZSB0aGUgbGluZSBhcyBhbiBpbnB1dCAqLwotCWdwaW9fbGluZV9jb25maWcoaXJxMmdwaW9baXJxXSwgSVhQNFhYX0dQSU9fSU4pOworCWdwaW9fbGluZV9jb25maWcoaXJxMmdwaW9bZC0+aXJxXSwgSVhQNFhYX0dQSU9fSU4pOwogCiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyB2b2lkIGl4cDR4eF9pcnFfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaXhwNHh4X2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpZiAoKGNwdV9pc19peHA0NngoKSB8fCBjcHVfaXNfaXhwNDN4KCkpICYmIGlycSA+PSAzMikKLQkJKklYUDRYWF9JQ01SMiAmPSB+KDEgPDwgKGlycSAtIDMyKSk7CisJaWYgKChjcHVfaXNfaXhwNDZ4KCkgfHwgY3B1X2lzX2l4cDQzeCgpKSAmJiBkLT5pcnEgPj0gMzIpCisJCSpJWFA0WFhfSUNNUjIgJj0gfigxIDw8IChkLT5pcnEgLSAzMikpOwogCWVsc2UKLQkJKklYUDRYWF9JQ01SICY9IH4oMSA8PCBpcnEpOworCQkqSVhQNFhYX0lDTVIgJj0gfigxIDw8IGQtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIGl4cDR4eF9pcnFfYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpeHA0eHhfaXJxX2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaW50IGxpbmUgPSAoaXJxIDwgMzIpID8gaXJxMmdwaW9baXJxXSA6IC0xOworCWludCBsaW5lID0gKGQtPmlycSA8IDMyKSA/IGlycTJncGlvW2QtPmlycV0gOiAtMTsKIAogCWlmIChsaW5lID49IDApCiAJCSpJWFA0WFhfR1BJT19HUElTUiA9ICgxIDw8IGxpbmUpOwpAQCAtMjEzLDIzICsyMTMsMjMgQEAKICAqIExldmVsIHRyaWdnZXJlZCBpbnRlcnJ1cHRzIG9uIEdQSU8gbGluZXMgY2FuIG9ubHkgYmUgY2xlYXJlZCB3aGVuIHRoZQogICogaW50ZXJydXB0IGNvbmRpdGlvbiBkaXNhcHBlYXJzLgogICovCi1zdGF0aWMgdm9pZCBpeHA0eHhfaXJxX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaXhwNHh4X2lycV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQogewotCWlmICghKGl4cDR4eF9pcnFfZWRnZSAmICgxIDw8IGlycSkpKQotCQlpeHA0eHhfaXJxX2FjayhpcnEpOworCWlmICghKGl4cDR4eF9pcnFfZWRnZSAmICgxIDw8IGQtPmlycSkpKQorCQlpeHA0eHhfaXJxX2FjayhkKTsKIAotCWlmICgoY3B1X2lzX2l4cDQ2eCgpIHx8IGNwdV9pc19peHA0M3goKSkgJiYgaXJxID49IDMyKQotCQkqSVhQNFhYX0lDTVIyIHw9ICgxIDw8IChpcnEgLSAzMikpOworCWlmICgoY3B1X2lzX2l4cDQ2eCgpIHx8IGNwdV9pc19peHA0M3goKSkgJiYgZC0+aXJxID49IDMyKQorCQkqSVhQNFhYX0lDTVIyIHw9ICgxIDw8IChkLT5pcnEgLSAzMikpOwogCWVsc2UKLQkJKklYUDRYWF9JQ01SIHw9ICgxIDw8IGlycSk7CisJCSpJWFA0WFhfSUNNUiB8PSAoMSA8PCBkLT5pcnEpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGl4cDR4eF9pcnFfY2hpcCA9IHsKIAkubmFtZQkJPSAiSVhQNHh4IiwKLQkuYWNrCQk9IGl4cDR4eF9pcnFfYWNrLAotCS5tYXNrCQk9IGl4cDR4eF9pcnFfbWFzaywKLQkudW5tYXNrCQk9IGl4cDR4eF9pcnFfdW5tYXNrLAotCS5zZXRfdHlwZQk9IGl4cDR4eF9zZXRfaXJxX3R5cGUsCisJLmlycV9hY2sJPSBpeHA0eHhfaXJxX2FjaywKKwkuaXJxX21hc2sJPSBpeHA0eHhfaXJxX21hc2ssCisJLmlycV91bm1hc2sJPSBpeHA0eHhfaXJxX3VubWFzaywKKwkuaXJxX3NldF90eXBlCT0gaXhwNHh4X3NldF9pcnFfdHlwZSwKIH07CiAKIHZvaWQgX19pbml0IGl4cDR4eF9pbml0X2lycSh2b2lkKQpAQCAtNDMyLDcgKzQzMiw3IEBACiAJLmZsYWdzCQk9IENMT0NLX1NPVVJDRV9JU19DT05USU5VT1VTLAogfTsKIAotdW5zaWduZWQgbG9uZyBpeHA0eHhfdGltZXJfZnJlcSA9IEZSRVE7Cit1bnNpZ25lZCBsb25nIGl4cDR4eF90aW1lcl9mcmVxID0gSVhQNFhYX1RJTUVSX0ZSRVE7CiBFWFBPUlRfU1lNQk9MKGl4cDR4eF90aW1lcl9mcmVxKTsKIHN0YXRpYyB2b2lkIF9faW5pdCBpeHA0eHhfY2xvY2tzb3VyY2VfaW5pdCh2b2lkKQogewpAQCAtNDk2LDcgKzQ5Niw3IEBACiAKIHN0YXRpYyB2b2lkIF9faW5pdCBpeHA0eHhfY2xvY2tldmVudF9pbml0KHZvaWQpCiB7Ci0JY2xvY2tldmVudF9peHA0eHgubXVsdCA9IGRpdl9zYyhGUkVRLCBOU0VDX1BFUl9TRUMsCisJY2xvY2tldmVudF9peHA0eHgubXVsdCA9IGRpdl9zYyhJWFA0WFhfVElNRVJfRlJFUSwgTlNFQ19QRVJfU0VDLAogCQkJCQljbG9ja2V2ZW50X2l4cDR4eC5zaGlmdCk7CiAJY2xvY2tldmVudF9peHA0eHgubWF4X2RlbHRhX25zID0KIAkJY2xvY2tldmVudF9kZWx0YTJucygweGZmZmZmZmZlLCAmY2xvY2tldmVudF9peHA0eHgpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1peHA0eHgvaW5jbHVkZS9tYWNoL3RpbWV4LmggYi9hcmNoL2FybS9tYWNoLWl4cDR4eC9pbmNsdWRlL21hY2gvdGltZXguaAppbmRleCAyYzNmOTNjLi5jOWU5MzBmIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWl4cDR4eC9pbmNsdWRlL21hY2gvdGltZXguaAorKysgYi9hcmNoL2FybS9tYWNoLWl4cDR4eC9pbmNsdWRlL21hY2gvdGltZXguaApAQCAtMTAsNiArMTAsNyBAQAogICogNjYuNjYuLi4gTUh6LiBXZSBkbyBhIGNvbnZ1bHRlZCBjYWxjdWxhdGlvbiBvZiBDTE9DS19USUNLX1JBVEUgYi9jIHRoZQogICogdGltZXIgcmVnaXN0ZXIgaWdub3JlcyB0aGUgYm90dG9tIDIgYml0cyBvZiB0aGUgTEFUQ0ggdmFsdWUuCiAgKi8KLSNkZWZpbmUgRlJFUSA2NjY2NjAwMAotI2RlZmluZSBDTE9DS19USUNLX1JBVEUgKCgoRlJFUSAvIEhaICYgfklYUDRYWF9PU1RfUkVMT0FEX01BU0spICsgMSkgKiBIWikKKyNkZWZpbmUgSVhQNFhYX1RJTUVSX0ZSRVEgNjY2NjYwMDAKKyNkZWZpbmUgQ0xPQ0tfVElDS19SQVRFIFwKKwkoKChJWFA0WFhfVElNRVJfRlJFUSAvIEhaICYgfklYUDRYWF9PU1RfUkVMT0FEX01BU0spICsgMSkgKiBIWikKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1peHA0eHgvaXhwNHh4X3FtZ3IuYyBiL2FyY2gvYXJtL21hY2gtaXhwNHh4L2l4cDR4eF9xbWdyLmMKaW5kZXggYmZkYmU0Yi4uODUyZjdjOSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1peHA0eHgvaXhwNHh4X3FtZ3IuYworKysgYi9hcmNoL2FybS9tYWNoLWl4cDR4eC9peHA0eHhfcW1nci5jCkBAIC0yNjUsNiArMjY1LDExIEBACiAJICAgICAgIHFtZ3JfcXVldWVfZGVzY3NbcXVldWVdLCBxdWV1ZSk7CiAJcW1ncl9xdWV1ZV9kZXNjc1txdWV1ZV1bMF0gPSAnXHgwJzsKICNlbmRpZgorCisJd2hpbGUgKChhZGRyID0gcW1ncl9nZXRfZW50cnkocXVldWUpKSkKKwkJcHJpbnRrKEtFUk5fRVJSICJxbWdyOiByZWxlYXNlZCBxdWV1ZSAlaSBub3QgZW1wdHk6IDB4JTA4WFxuIiwKKwkJICAgICAgIHF1ZXVlLCBhZGRyKTsKKwogCV9fcmF3X3dyaXRlbCgwLCAmcW1ncl9yZWdzLT5zcmFtW3F1ZXVlXSk7CiAKIAl1c2VkX3NyYW1fYml0bWFwWzBdICY9IH5tYXNrWzBdOwpAQCAtMjc1LDEwICsyODAsNiBAQAogCXNwaW5fdW5sb2NrX2lycSgmcW1ncl9sb2NrKTsKIAogCW1vZHVsZV9wdXQoVEhJU19NT0RVTEUpOwotCi0Jd2hpbGUgKChhZGRyID0gcW1ncl9nZXRfZW50cnkocXVldWUpKSkKLQkJcHJpbnRrKEtFUk5fRVJSICJxbWdyOiByZWxlYXNlZCBxdWV1ZSAlaSBub3QgZW1wdHk6IDB4JTA4WFxuIiwKLQkJICAgICAgIHF1ZXVlLCBhZGRyKTsKIH0KIAogc3RhdGljIGludCBxbWdyX2luaXQodm9pZCkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gta3M4Njk1L2lycS5jIGIvYXJjaC9hcm0vbWFjaC1rczg2OTUvaXJxLmMKaW5kZXggZTM3NWMxZC4uNzk5OGNjYSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1rczg2OTUvaXJxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1rczg2OTUvaXJxLmMKQEAgLTM0LDI5ICszNCwyOSBAQAogI2luY2x1ZGUgPG1hY2gvcmVncy1pcnEuaD4KICNpbmNsdWRlIDxtYWNoL3JlZ3MtZ3Bpby5oPgogCi1zdGF0aWMgdm9pZCBrczg2OTVfaXJxX21hc2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQga3M4Njk1X2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl1bnNpZ25lZCBsb25nIGludGVuOwogCiAJaW50ZW4gPSBfX3Jhd19yZWFkbChLUzg2OTVfSVJRX1ZBICsgS1M4Njk1X0lOVEVOKTsKLQlpbnRlbiAmPSB+KDEgPDwgaXJxbm8pOworCWludGVuICY9IH4oMSA8PCBkLT5pcnEpOwogCiAJX19yYXdfd3JpdGVsKGludGVuLCBLUzg2OTVfSVJRX1ZBICsgS1M4Njk1X0lOVEVOKTsKIH0KIAotc3RhdGljIHZvaWQga3M4Njk1X2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQga3M4Njk1X2lycV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGxvbmcgaW50ZW47CiAKIAlpbnRlbiA9IF9fcmF3X3JlYWRsKEtTODY5NV9JUlFfVkEgKyBLUzg2OTVfSU5URU4pOwotCWludGVuIHw9ICgxIDw8IGlycW5vKTsKKwlpbnRlbiB8PSAoMSA8PCBkLT5pcnEpOwogCiAJX19yYXdfd3JpdGVsKGludGVuLCBLUzg2OTVfSVJRX1ZBICsgS1M4Njk1X0lOVEVOKTsKIH0KIAotc3RhdGljIHZvaWQga3M4Njk1X2lycV9hY2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQga3M4Njk1X2lycV9hY2soc3RydWN0IGlycV9kYXRhICpkKQogewotCV9fcmF3X3dyaXRlbCgoMSA8PCBpcnFubyksIEtTODY5NV9JUlFfVkEgKyBLUzg2OTVfSU5UU1QpOworCV9fcmF3X3dyaXRlbCgoMSA8PCBkLT5pcnEpLCBLUzg2OTVfSVJRX1ZBICsgS1M4Njk1X0lOVFNUKTsKIH0KIAogCkBAIC02NCw3ICs2NCw3IEBACiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGtzODY5NV9pcnFfZWRnZV9jaGlwOwogCiAKLXN0YXRpYyBpbnQga3M4Njk1X2lycV9zZXRfdHlwZSh1bnNpZ25lZCBpbnQgaXJxbm8sIHVuc2lnbmVkIGludCB0eXBlKQorc3RhdGljIGludCBrczg2OTVfaXJxX3NldF90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IHR5cGUpCiB7CiAJdW5zaWduZWQgbG9uZyBjdHJsLCBtb2RlOwogCXVuc2lnbmVkIHNob3J0IGxldmVsX3RyaWdnZXJlZCA9IDA7CkBAIC05Myw3ICs5Myw3IEBACiAJCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKLQlzd2l0Y2ggKGlycW5vKSB7CisJc3dpdGNoIChkLT5pcnEpIHsKIAkJY2FzZSBLUzg2OTVfSVJRX0VYVEVSTjA6CiAJCQljdHJsICY9IH5JT1BDX0lPRUlOVDBUTTsKIAkJCWN0cmwgfD0gSU9QQ19JT0VJTlQwX01PREUobW9kZSk7CkBAIC0xMTUsMTIgKzExNSwxMiBAQAogCX0KIAogCWlmIChsZXZlbF90cmlnZ2VyZWQpIHsKLQkJc2V0X2lycV9jaGlwKGlycW5vLCAma3M4Njk1X2lycV9sZXZlbF9jaGlwKTsKLQkJc2V0X2lycV9oYW5kbGVyKGlycW5vLCBoYW5kbGVfbGV2ZWxfaXJxKTsKKwkJc2V0X2lycV9jaGlwKGQtPmlycSwgJmtzODY5NV9pcnFfbGV2ZWxfY2hpcCk7CisJCXNldF9pcnFfaGFuZGxlcihkLT5pcnEsIGhhbmRsZV9sZXZlbF9pcnEpOwogCX0KIAllbHNlIHsKLQkJc2V0X2lycV9jaGlwKGlycW5vLCAma3M4Njk1X2lycV9lZGdlX2NoaXApOwotCQlzZXRfaXJxX2hhbmRsZXIoaXJxbm8sIGhhbmRsZV9lZGdlX2lycSk7CisJCXNldF9pcnFfY2hpcChkLT5pcnEsICZrczg2OTVfaXJxX2VkZ2VfY2hpcCk7CisJCXNldF9pcnFfaGFuZGxlcihkLT5pcnEsIGhhbmRsZV9lZGdlX2lycSk7CiAJfQogCiAJX19yYXdfd3JpdGVsKGN0cmwsIEtTODY5NV9HUElPX1ZBICsgS1M4Njk1X0lPUEMpOwpAQCAtMTI4LDE3ICsxMjgsMTcgQEAKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBrczg2OTVfaXJxX2xldmVsX2NoaXAgPSB7Ci0JLmFjawkJPSBrczg2OTVfaXJxX21hc2ssCi0JLm1hc2sJCT0ga3M4Njk1X2lycV9tYXNrLAotCS51bm1hc2sJCT0ga3M4Njk1X2lycV91bm1hc2ssCi0JLnNldF90eXBlCT0ga3M4Njk1X2lycV9zZXRfdHlwZSwKKwkuaXJxX2Fjawk9IGtzODY5NV9pcnFfbWFzaywKKwkuaXJxX21hc2sJPSBrczg2OTVfaXJxX21hc2ssCisJLmlycV91bm1hc2sJPSBrczg2OTVfaXJxX3VubWFzaywKKwkuaXJxX3NldF90eXBlCT0ga3M4Njk1X2lycV9zZXRfdHlwZSwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAga3M4Njk1X2lycV9lZGdlX2NoaXAgPSB7Ci0JLmFjawkJPSBrczg2OTVfaXJxX2FjaywKLQkubWFzawkJPSBrczg2OTVfaXJxX21hc2ssCi0JLnVubWFzawkJPSBrczg2OTVfaXJxX3VubWFzaywKLQkuc2V0X3R5cGUJPSBrczg2OTVfaXJxX3NldF90eXBlLAorCS5pcnFfYWNrCT0ga3M4Njk1X2lycV9hY2ssCisJLmlycV9tYXNrCT0ga3M4Njk1X2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCT0ga3M4Njk1X2lycV91bm1hc2ssCisJLmlycV9zZXRfdHlwZQk9IGtzODY5NV9pcnFfc2V0X3R5cGUsCiB9OwogCiB2b2lkIF9faW5pdCBrczg2OTVfaW5pdF9pcnEodm9pZCkKQEAgLTE2NCw3ICsxNjQsOCBAQAogCiAJCQkvKiBFZGdlLXRyaWdnZXJlZCBpbnRlcnJ1cHRzICovCiAJCQlkZWZhdWx0OgotCQkJCWtzODY5NV9pcnFfYWNrKGlycSk7CS8qIGNsZWFyIHBlbmRpbmcgYml0ICovCisJCQkJLyogY2xlYXIgcGVuZGluZyBiaXQgKi8KKwkJCQlrczg2OTVfaXJxX2FjayhpcnFfZ2V0X2lycV9kYXRhKGlycSkpOwogCQkJCXNldF9pcnFfY2hpcChpcnEsICZrczg2OTVfaXJxX2VkZ2VfY2hpcCk7CiAJCQkJc2V0X2lycV9oYW5kbGVyKGlycSwgaGFuZGxlX2VkZ2VfaXJxKTsKIAkJfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1saDdhNDB4L2FyY2gta2V2N2E0MDAuYyBiL2FyY2gvYXJtL21hY2gtbGg3YTQweC9hcmNoLWtldjdhNDAwLmMKaW5kZXggOTA4OGMxNjYuLjcxMTI5YzMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbGg3YTQweC9hcmNoLWtldjdhNDAwLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1saDdhNDB4L2FyY2gta2V2N2E0MDAuYwpAQCAtNDYsMjggKzQ2LDI4IEBACiAKIHN0YXRpYyB1MTYgQ1BMRF9JUlFfbWFzazsJLyogTWFzayBmb3IgQ1BMRCBJUlFzLCAxID09IHVubWFza2VkICovCiAKLXN0YXRpYyB2b2lkIGtldjdhNDAwX2Fja19jcGxkX2lycSAodTMyIGlycSkKK3N0YXRpYyB2b2lkIGtldjdhNDAwX2Fja19jcGxkX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JQ1BMRF9DTF9JTlQgPSAxIDw8IChpcnEgLSBJUlFfS0VWN0E0MDBfQ1BMRCk7CisJQ1BMRF9DTF9JTlQgPSAxIDw8IChkLT5pcnEgLSBJUlFfS0VWN0E0MDBfQ1BMRCk7CiB9CiAKLXN0YXRpYyB2b2lkIGtldjdhNDAwX21hc2tfY3BsZF9pcnEgKHUzMiBpcnEpCitzdGF0aWMgdm9pZCBrZXY3YTQwMF9tYXNrX2NwbGRfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlDUExEX0lSUV9tYXNrICY9IH4oMSA8PCAoaXJxIC0gSVJRX0tFVjdBNDAwX0NQTEQpKTsKKwlDUExEX0lSUV9tYXNrICY9IH4oMSA8PCAoZC0+aXJxIC0gSVJRX0tFVjdBNDAwX0NQTEQpKTsKIAlDUExEX1dSX1BCX0lOVF9NQVNLID0gQ1BMRF9JUlFfbWFzazsKIH0KIAotc3RhdGljIHZvaWQga2V2N2E0MDBfdW5tYXNrX2NwbGRfaXJxICh1MzIgaXJxKQorc3RhdGljIHZvaWQga2V2N2E0MDBfdW5tYXNrX2NwbGRfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlDUExEX0lSUV9tYXNrIHw9IDEgPDwgKGlycSAtIElSUV9LRVY3QTQwMF9DUExEKTsKKwlDUExEX0lSUV9tYXNrIHw9IDEgPDwgKGQtPmlycSAtIElSUV9LRVY3QTQwMF9DUExEKTsKIAlDUExEX1dSX1BCX0lOVF9NQVNLID0gQ1BMRF9JUlFfbWFzazsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBrZXY3YTQwMF9jcGxkX2NoaXAgPSB7Ci0JLm5hbWUJPSAiQ1BMRCIsCi0JLmFjawk9IGtldjdhNDAwX2Fja19jcGxkX2lycSwKLQkubWFzawk9IGtldjdhNDAwX21hc2tfY3BsZF9pcnEsCi0JLnVubWFzawk9IGtldjdhNDAwX3VubWFza19jcGxkX2lycSwKKwkubmFtZQkJPSAiQ1BMRCIsCisJLmlycV9hY2sJPSBrZXY3YTQwMF9hY2tfY3BsZF9pcnEsCisJLmlycV9tYXNrCT0ga2V2N2E0MDBfbWFza19jcGxkX2lycSwKKwkuaXJxX3VubWFzawk9IGtldjdhNDAwX3VubWFza19jcGxkX2lycSwKIH07CiAKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1saDdhNDB4L2FyY2gtbHBkN2E0MHguYyBiL2FyY2gvYXJtL21hY2gtbGg3YTQweC9hcmNoLWxwZDdhNDB4LmMKaW5kZXggNzMxNWE1Ni4uZTczNTU0NiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1saDdhNDB4L2FyY2gtbHBkN2E0MHguYworKysgYi9hcmNoL2FybS9tYWNoLWxoN2E0MHgvYXJjaC1scGQ3YTQweC5jCkBAIC0xNTksNyArMTU5LDcgQEAKICNlbmRpZgogfQogCi1zdGF0aWMgdm9pZCBsaDdhNDB4X2Fja19jcGxkX2lycSAodTMyIGlycSkKK3N0YXRpYyB2b2lkIGxoN2E0MHhfYWNrX2NwbGRfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAkvKiBDUExEIGRvZXNuJ3QgaGF2ZSBhY2sgY2FwYWJpbGl0eSwgYnV0IHNvbWUgZGV2aWNlcyBtYXkgKi8KIApAQCAtMTY3LDE0ICsxNjcsMTQgQEAKIAkvKiBUaGUgdG91Y2ggY29udHJvbCAqbXVzdCogbWFzayB0aGUgaW50ZXJydXB0IGJlY2F1c2UgdGhlCiAJICogaW50ZXJydXB0IGJpdCBpcyByZWFkIGJ5IHRoZSBkcml2ZXIgdG8gZGV0ZXJtaW5lIGlmIHRoZSBwZW4KIAkgKiBpcyBzdGlsbCBkb3duLiAqLwotCWlmIChpcnEgPT0gSVJRX1RPVUNIKQorCWlmIChkLT5pcnEgPT0gSVJRX1RPVUNIKQogCQlDUExEX0lOVEVSUlVQVFMgfD0gQ1BMRF9JTlRNQVNLX1RPVUNIOwogI2VuZGlmCiB9CiAKLXN0YXRpYyB2b2lkIGxoN2E0MHhfbWFza19jcGxkX2lycSAodTMyIGlycSkKK3N0YXRpYyB2b2lkIGxoN2E0MHhfbWFza19jcGxkX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jc3dpdGNoIChpcnEpIHsKKwlzd2l0Y2ggKGQtPmlycSkgewogCWNhc2UgSVJRX0xQRDdBNDBYX0VUSF9JTlQ6CiAJCUNQTERfSU5URVJSVVBUUyB8PSBDUExEX0lOVE1BU0tfRVRIRVJORVQ7CiAJCWJyZWFrOwpAQCAtMTg2LDkgKzE4Niw5IEBACiAJfQogfQogCi1zdGF0aWMgdm9pZCBsaDdhNDB4X3VubWFza19jcGxkX2lycSAodTMyIGlycSkKK3N0YXRpYyB2b2lkIGxoN2E0MHhfdW5tYXNrX2NwbGRfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlzd2l0Y2ggKGlycSkgeworCXN3aXRjaCAoZC0+aXJxKSB7CiAJY2FzZSBJUlFfTFBEN0E0MFhfRVRIX0lOVDoKIAkJQ1BMRF9JTlRFUlJVUFRTICY9IH5DUExEX0lOVE1BU0tfRVRIRVJORVQ7CiAJCWJyZWFrOwpAQCAtMjAxLDE3ICsyMDEsMTcgQEAKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBscGQ3YTQweF9jcGxkX2NoaXAgPSB7Ci0JLm5hbWUJPSAiQ1BMRCIsCi0JLmFjawk9IGxoN2E0MHhfYWNrX2NwbGRfaXJxLAotCS5tYXNrCT0gbGg3YTQweF9tYXNrX2NwbGRfaXJxLAotCS51bm1hc2sJPSBsaDdhNDB4X3VubWFza19jcGxkX2lycSwKKwkubmFtZQkJPSAiQ1BMRCIsCisJLmlycV9hY2sJPSBsaDdhNDB4X2Fja19jcGxkX2lycSwKKwkuaXJxX21hc2sJPSBsaDdhNDB4X21hc2tfY3BsZF9pcnEsCisJLmlycV91bm1hc2sJPSBsaDdhNDB4X3VubWFza19jcGxkX2lycSwKIH07CiAKIHN0YXRpYyB2b2lkIGxwZDdhNDB4X2NwbGRfaGFuZGxlciAodW5zaWduZWQgaW50IGlycSwgc3RydWN0IGlycV9kZXNjICpkZXNjKQogewogCXVuc2lnbmVkIGludCBtYXNrID0gQ1BMRF9JTlRFUlJVUFRTOwogCi0JZGVzYy0+Y2hpcC0+YWNrIChpcnEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9hY2soJmRlc2MtPmlycV9kYXRhKTsKIAogCWlmICgobWFzayAmICgxPDwwKSkgPT0gMCkJLyogV0xBTiAqLwogCQlnZW5lcmljX2hhbmRsZV9pcnEoSVJRX0xQRDdBNDBYX0VUSF9JTlQpOwpAQCAtMjIxLDcgKzIyMSw4IEBACiAJCWdlbmVyaWNfaGFuZGxlX2lycShJUlFfVE9VQ0gpOwogI2VuZGlmCiAKLQlkZXNjLT5jaGlwLT51bm1hc2sgKGlycSk7IC8qIExldmVsLXRyaWdnZXJlZCBuZWVkIHRoaXMgKi8KKwkvKiBMZXZlbC10cmlnZ2VyZWQgbmVlZCB0aGlzICovCisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX3VubWFzaygmZGVzYy0+aXJxX2RhdGEpOwogfQogCiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbGg3YTQweC9pcnEtbGg3YTQwMC5jIGIvYXJjaC9hcm0vbWFjaC1saDdhNDB4L2lycS1saDdhNDAwLmMKaW5kZXggMWFkM2FmYy4uZjJlN2U2NSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1saDdhNDB4L2lycS1saDdhNDAwLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1saDdhNDB4L2lycS1saDdhNDAwLmMKQEAgLTIxLDM0ICsyMSwzNCBAQAogCiAgIC8qIENQVSBJUlEgaGFuZGxpbmcgKi8KIAotc3RhdGljIHZvaWQgbGg3YTQwMF9tYXNrX2lycSAodTMyIGlycSkKK3N0YXRpYyB2b2lkIGxoN2E0MDBfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCUlOVENfSU5URU5DID0gKDEgPDwgaXJxKTsKKwlJTlRDX0lOVEVOQyA9ICgxIDw8IGQtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIGxoN2E0MDBfdW5tYXNrX2lycSAodTMyIGlycSkKK3N0YXRpYyB2b2lkIGxoN2E0MDBfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JSU5UQ19JTlRFTlMgPSAoMSA8PCBpcnEpOworCUlOVENfSU5URU5TID0gKDEgPDwgZC0+aXJxKTsKIH0KIAotc3RhdGljIHZvaWQgbGg3YTQwMF9hY2tfZ3Bpb19pcnEgKHUzMiBpcnEpCitzdGF0aWMgdm9pZCBsaDdhNDAwX2Fja19ncGlvX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JR1BJT19HUElPRkVPSSA9ICgxIDw8IElSUV9UT19HUElPIChpcnEpKTsKLQlJTlRDX0lOVEVOQyA9ICgxIDw8IGlycSk7CisJR1BJT19HUElPRkVPSSA9ICgxIDw8IElSUV9UT19HUElPIChkLT5pcnEpKTsKKwlJTlRDX0lOVEVOQyA9ICgxIDw8IGQtPmlycSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbGg3YTQwMF9pbnRlcm5hbF9jaGlwID0gewotCS5uYW1lCT0gIk1QVSIsCi0JLmFjawk9IGxoN2E0MDBfbWFza19pcnEsIC8qIExldmVsIHRyaWdnZXJpbmcgLT4gbWFzayBpcyBhY2sgKi8KLQkubWFzawk9IGxoN2E0MDBfbWFza19pcnEsCi0JLnVubWFzawk9IGxoN2E0MDBfdW5tYXNrX2lycSwKKwkubmFtZQkJPSAiTVBVIiwKKwkuaXJxX2Fjawk9IGxoN2E0MDBfbWFza19pcnEsIC8qIExldmVsIHRyaWdnZXJpbmcgLT4gbWFzayBpcyBhY2sgKi8KKwkuaXJxX21hc2sJPSBsaDdhNDAwX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gbGg3YTQwMF91bm1hc2tfaXJxLAogfTsKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBsaDdhNDAwX2dwaW9fY2hpcCA9IHsKLQkubmFtZQk9ICJHUElPIiwKLQkuYWNrCT0gbGg3YTQwMF9hY2tfZ3Bpb19pcnEsCi0JLm1hc2sJPSBsaDdhNDAwX21hc2tfaXJxLAotCS51bm1hc2sJPSBsaDdhNDAwX3VubWFza19pcnEsCisJLm5hbWUJCT0gIkdQSU8iLAorCS5pcnFfYWNrCT0gbGg3YTQwMF9hY2tfZ3Bpb19pcnEsCisJLmlycV9tYXNrCT0gbGg3YTQwMF9tYXNrX2lycSwKKwkuaXJxX3VubWFzawk9IGxoN2E0MDBfdW5tYXNrX2lycSwKIH07CiAKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1saDdhNDB4L2lycS1saDdhNDA0LmMgYi9hcmNoL2FybS9tYWNoLWxoN2E0MHgvaXJxLWxoN2E0MDQuYwppbmRleCAxMmIwNDViLi4xNGIxNzMzIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWxoN2E0MHgvaXJxLWxoN2E0MDQuYworKysgYi9hcmNoL2FybS9tYWNoLWxoN2E0MHgvaXJxLWxoN2E0MDQuYwpAQCAtNDMsNjQgKzQzLDY0IEBACiAKICAgLyogQ1BVIElSUSBoYW5kbGluZyAqLwogCi1zdGF0aWMgdm9pZCBsaDdhNDA0X3ZpYzFfbWFza19pcnEgKHUzMiBpcnEpCitzdGF0aWMgdm9pZCBsaDdhNDA0X3ZpYzFfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCVZJQzFfSU5URU5DTFIgPSAoMSA8PCBpcnEpOworCVZJQzFfSU5URU5DTFIgPSAoMSA8PCBkLT5pcnEpOwogfQogCi1zdGF0aWMgdm9pZCBsaDdhNDA0X3ZpYzFfdW5tYXNrX2lycSAodTMyIGlycSkKK3N0YXRpYyB2b2lkIGxoN2E0MDRfdmljMV91bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlWSUMxX0lOVEVOID0gKDEgPDwgaXJxKTsKKwlWSUMxX0lOVEVOID0gKDEgPDwgZC0+aXJxKTsKIH0KIAotc3RhdGljIHZvaWQgbGg3YTQwNF92aWMyX21hc2tfaXJxICh1MzIgaXJxKQorc3RhdGljIHZvaWQgbGg3YTQwNF92aWMyX21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlWSUMyX0lOVEVOQ0xSID0gKDEgPDwgKGlycSAtIDMyKSk7CisJVklDMl9JTlRFTkNMUiA9ICgxIDw8IChkLT5pcnEgLSAzMikpOwogfQogCi1zdGF0aWMgdm9pZCBsaDdhNDA0X3ZpYzJfdW5tYXNrX2lycSAodTMyIGlycSkKK3N0YXRpYyB2b2lkIGxoN2E0MDRfdmljMl91bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlWSUMyX0lOVEVOID0gKDEgPDwgKGlycSAtIDMyKSk7CisJVklDMl9JTlRFTiA9ICgxIDw8IChkLT5pcnEgLSAzMikpOwogfQogCi1zdGF0aWMgdm9pZCBsaDdhNDA0X3ZpYzFfYWNrX2dwaW9faXJxICh1MzIgaXJxKQorc3RhdGljIHZvaWQgbGg3YTQwNF92aWMxX2Fja19ncGlvX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JR1BJT19HUElPRkVPSSA9ICgxIDw8IElSUV9UT19HUElPIChpcnEpKTsKLQlWSUMxX0lOVEVOQ0xSID0gKDEgPDwgaXJxKTsKKwlHUElPX0dQSU9GRU9JID0gKDEgPDwgSVJRX1RPX0dQSU8gKGQtPmlycSkpOworCVZJQzFfSU5URU5DTFIgPSAoMSA8PCBkLT5pcnEpOwogfQogCi1zdGF0aWMgdm9pZCBsaDdhNDA0X3ZpYzJfYWNrX2dwaW9faXJxICh1MzIgaXJxKQorc3RhdGljIHZvaWQgbGg3YTQwNF92aWMyX2Fja19ncGlvX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JR1BJT19HUElPRkVPSSA9ICgxIDw8IElSUV9UT19HUElPIChpcnEpKTsKLQlWSUMyX0lOVEVOQ0xSID0gKDEgPDwgaXJxKTsKKwlHUElPX0dQSU9GRU9JID0gKDEgPDwgSVJRX1RPX0dQSU8gKGQtPmlycSkpOworCVZJQzJfSU5URU5DTFIgPSAoMSA8PCBkLT5pcnEpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGxoN2E0MDRfdmljMV9jaGlwID0gewotCS5uYW1lCT0gIlZJQzEiLAotCS5hY2sJPSBsaDdhNDA0X3ZpYzFfbWFza19pcnEsIC8qIEJlY2F1c2UgbGV2ZWwtdHJpZ2dlcmVkICovCi0JLm1hc2sJPSBsaDdhNDA0X3ZpYzFfbWFza19pcnEsCi0JLnVubWFzawk9IGxoN2E0MDRfdmljMV91bm1hc2tfaXJxLAorCS5uYW1lCQk9ICJWSUMxIiwKKwkuaXJxX2Fjawk9IGxoN2E0MDRfdmljMV9tYXNrX2lycSwgLyogQmVjYXVzZSBsZXZlbC10cmlnZ2VyZWQgKi8KKwkuaXJxX21hc2sJPSBsaDdhNDA0X3ZpYzFfbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBsaDdhNDA0X3ZpYzFfdW5tYXNrX2lycSwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbGg3YTQwNF92aWMyX2NoaXAgPSB7Ci0JLm5hbWUJPSAiVklDMiIsCi0JLmFjawk9IGxoN2E0MDRfdmljMl9tYXNrX2lycSwgLyogQmVjYXVzZSBsZXZlbC10cmlnZ2VyZWQgKi8KLQkubWFzawk9IGxoN2E0MDRfdmljMl9tYXNrX2lycSwKLQkudW5tYXNrCT0gbGg3YTQwNF92aWMyX3VubWFza19pcnEsCisJLm5hbWUJCT0gIlZJQzIiLAorCS5pcnFfYWNrCT0gbGg3YTQwNF92aWMyX21hc2tfaXJxLCAvKiBCZWNhdXNlIGxldmVsLXRyaWdnZXJlZCAqLworCS5pcnFfbWFzawk9IGxoN2E0MDRfdmljMl9tYXNrX2lycSwKKwkuaXJxX3VubWFzawk9IGxoN2E0MDRfdmljMl91bm1hc2tfaXJxLAogfTsKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBsaDdhNDA0X2dwaW9fdmljMV9jaGlwID0gewotCS5uYW1lCT0gIkdQSU8tVklDMSIsCi0JLmFjawk9IGxoN2E0MDRfdmljMV9hY2tfZ3Bpb19pcnEsCi0JLm1hc2sJPSBsaDdhNDA0X3ZpYzFfbWFza19pcnEsCi0JLnVubWFzawk9IGxoN2E0MDRfdmljMV91bm1hc2tfaXJxLAorCS5uYW1lCQk9ICJHUElPLVZJQzEiLAorCS5pcnFfYWNrCT0gbGg3YTQwNF92aWMxX2Fja19ncGlvX2lycSwKKwkuaXJxX21hc2sJPSBsaDdhNDA0X3ZpYzFfbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBsaDdhNDA0X3ZpYzFfdW5tYXNrX2lycSwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbGg3YTQwNF9ncGlvX3ZpYzJfY2hpcCA9IHsKLQkubmFtZQk9ICJHUElPLVZJQzIiLAotCS5hY2sJPSBsaDdhNDA0X3ZpYzJfYWNrX2dwaW9faXJxLAotCS5tYXNrCT0gbGg3YTQwNF92aWMyX21hc2tfaXJxLAotCS51bm1hc2sJPSBsaDdhNDA0X3ZpYzJfdW5tYXNrX2lycSwKKwkubmFtZQkJPSAiR1BJTy1WSUMyIiwKKwkuaXJxX2Fjawk9IGxoN2E0MDRfdmljMl9hY2tfZ3Bpb19pcnEsCisJLmlycV9tYXNrCT0gbGg3YTQwNF92aWMyX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gbGg3YTQwNF92aWMyX3VubWFza19pcnEsCiB9OwogCiAgIC8qIElSUSBpbml0aWFsaXphdGlvbiAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1saDdhNDB4L2lycS1scGQ3YTQweC5jIGIvYXJjaC9hcm0vbWFjaC1saDdhNDB4L2lycS1scGQ3YTQweC5jCmluZGV4IGZkMDMzYmIuLjFiZmRjZGQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbGg3YTQweC9pcnEtbHBkN2E0MHguYworKysgYi9hcmNoL2FybS9tYWNoLWxoN2E0MHgvaXJxLWxwZDdhNDB4LmMKQEAgLTIwLDE0ICsyMCwxNCBAQAogCiAjaW5jbHVkZSAiY29tbW9uLmgiCiAKLXN0YXRpYyB2b2lkIGxoN2E0MHhfYWNrX2NwbGRfaXJxICh1MzIgaXJxKQorc3RhdGljIHZvaWQgbGg3YTQweF9hY2tfY3BsZF9pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCS8qIENQTEQgZG9lc24ndCBoYXZlIGFjayBjYXBhYmlsaXR5ICovCiB9CiAKLXN0YXRpYyB2b2lkIGxoN2E0MHhfbWFza19jcGxkX2lycSAodTMyIGlycSkKK3N0YXRpYyB2b2lkIGxoN2E0MHhfbWFza19jcGxkX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jc3dpdGNoIChpcnEpIHsKKwlzd2l0Y2ggKGQtPmlycSkgewogCWNhc2UgSVJRX0xQRDdBNDBYX0VUSF9JTlQ6CiAJCUNQTERfSU5URVJSVVBUUyA9IENQTERfSU5URVJSVVBUUyB8IDB4NDsKIAkJYnJlYWs7CkBAIC0zNyw5ICszNyw5IEBACiAJfQogfQogCi1zdGF0aWMgdm9pZCBsaDdhNDB4X3VubWFza19jcGxkX2lycSAodTMyIGlycSkKK3N0YXRpYyB2b2lkIGxoN2E0MHhfdW5tYXNrX2NwbGRfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlzd2l0Y2ggKGlycSkgeworCXN3aXRjaCAoZC0+aXJxKSB7CiAJY2FzZSBJUlFfTFBEN0E0MFhfRVRIX0lOVDoKIAkJQ1BMRF9JTlRFUlJVUFRTID0gQ1BMRF9JTlRFUlJVUFRTICYgfiAweDQ7CiAJCWJyZWFrOwpAQCAtNTAsMTcgKzUwLDE3IEBACiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbGg3YTQweF9jcGxkX2NoaXAgPSB7Ci0JLm5hbWUJPSAiQ1BMRCIsCi0JLmFjawk9IGxoN2E0MHhfYWNrX2NwbGRfaXJxLAotCS5tYXNrCT0gbGg3YTQweF9tYXNrX2NwbGRfaXJxLAotCS51bm1hc2sJPSBsaDdhNDB4X3VubWFza19jcGxkX2lycSwKKwkubmFtZQkJPSAiQ1BMRCIsCisJLmlycV9hY2sJPSBsaDdhNDB4X2Fja19jcGxkX2lycSwKKwkuaXJxX21hc2sJPSBsaDdhNDB4X21hc2tfY3BsZF9pcnEsCisJLmlycV91bm1hc2sJPSBsaDdhNDB4X3VubWFza19jcGxkX2lycSwKIH07CiAKIHN0YXRpYyB2b2lkIGxoN2E0MHhfY3BsZF9oYW5kbGVyICh1bnNpZ25lZCBpbnQgaXJxLCBzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MpCiB7CiAJdW5zaWduZWQgaW50IG1hc2sgPSBDUExEX0lOVEVSUlVQVFM7CiAKLQlkZXNjLT5jaGlwLT5hY2sgKGlycSk7CisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+YWNrIChpcnEpOwogCiAJaWYgKChtYXNrICYgMHgxKSA9PSAwKQkvKiBXTEFOICovCiAJCWdlbmVyaWNfaGFuZGxlX2lycShJUlFfTFBEN0E0MFhfRVRIX0lOVCk7CkBAIC02OCw3ICs2OCw3IEBACiAJaWYgKChtYXNrICYgMHgyKSA9PSAwKQkvKiBUb3VjaCAqLwogCQlnZW5lcmljX2hhbmRsZV9pcnEoSVJRX0xQRDdBNDAwX1RTKTsKIAotCWRlc2MtPmNoaXAtPnVubWFzayAoaXJxKTsgLyogTGV2ZWwtdHJpZ2dlcmVkIG5lZWQgdGhpcyAqLworCWRlc2MtPmlycV9kYXRhLmNoaXAtPnVubWFzayAoaXJxKTsgLyogTGV2ZWwtdHJpZ2dlcmVkIG5lZWQgdGhpcyAqLwogfQogCiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbHBjMzJ4eC9pcnEuYyBiL2FyY2gvYXJtL21hY2gtbHBjMzJ4eC9pcnEuYwppbmRleCBiZDBkZjI2Yy4uMzE2ZWNiZiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1scGMzMnh4L2lycS5jCisrKyBiL2FyY2gvYXJtL21hY2gtbHBjMzJ4eC9pcnEuYwpAQCAtMTkxLDM4ICsxOTEsMzggQEAKIAl9CiB9CiAKLXN0YXRpYyB2b2lkIGxwYzMyeHhfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGxwYzMyeHhfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGludCByZWcsIGN0cmwsIG1hc2s7CiAKLQlnZXRfY29udHJvbGxlcihpcnEsICZjdHJsLCAmbWFzayk7CisJZ2V0X2NvbnRyb2xsZXIoZC0+aXJxLCAmY3RybCwgJm1hc2spOwogCiAJcmVnID0gX19yYXdfcmVhZGwoTFBDMzJYWF9JTlRDX01BU0soY3RybCkpICYgfm1hc2s7CiAJX19yYXdfd3JpdGVsKHJlZywgTFBDMzJYWF9JTlRDX01BU0soY3RybCkpOwogfQogCi1zdGF0aWMgdm9pZCBscGMzMnh4X3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGxwYzMyeHhfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdW5zaWduZWQgaW50IHJlZywgY3RybCwgbWFzazsKIAotCWdldF9jb250cm9sbGVyKGlycSwgJmN0cmwsICZtYXNrKTsKKwlnZXRfY29udHJvbGxlcihkLT5pcnEsICZjdHJsLCAmbWFzayk7CiAKIAlyZWcgPSBfX3Jhd19yZWFkbChMUEMzMlhYX0lOVENfTUFTSyhjdHJsKSkgfCBtYXNrOwogCV9fcmF3X3dyaXRlbChyZWcsIExQQzMyWFhfSU5UQ19NQVNLKGN0cmwpKTsKIH0KIAotc3RhdGljIHZvaWQgbHBjMzJ4eF9hY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBscGMzMnh4X2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGludCBjdHJsLCBtYXNrOwogCi0JZ2V0X2NvbnRyb2xsZXIoaXJxLCAmY3RybCwgJm1hc2spOworCWdldF9jb250cm9sbGVyKGQtPmlycSwgJmN0cmwsICZtYXNrKTsKIAogCV9fcmF3X3dyaXRlbChtYXNrLCBMUEMzMlhYX0lOVENfUkFXX1NUQVQoY3RybCkpOwogCiAJLyogQWxzbyBuZWVkIHRvIGNsZWFyIHBlbmRpbmcgd2FrZSBldmVudCAqLwotCWlmIChscGMzMnh4X2V2ZW50c1tpcnFdLm1hc2sgIT0gMCkKLQkJX19yYXdfd3JpdGVsKGxwYzMyeHhfZXZlbnRzW2lycV0ubWFzaywKLQkJCWxwYzMyeHhfZXZlbnRzW2lycV0uZXZlbnRfZ3JvdXAtPnJhd3N0YXRfcmVnKTsKKwlpZiAobHBjMzJ4eF9ldmVudHNbZC0+aXJxXS5tYXNrICE9IDApCisJCV9fcmF3X3dyaXRlbChscGMzMnh4X2V2ZW50c1tkLT5pcnFdLm1hc2ssCisJCQlscGMzMnh4X2V2ZW50c1tkLT5pcnFdLmV2ZW50X2dyb3VwLT5yYXdzdGF0X3JlZyk7CiB9CiAKIHN0YXRpYyB2b2lkIF9fbHBjMzJ4eF9zZXRfaXJxX3R5cGUodW5zaWduZWQgaW50IGlycSwgaW50IHVzZV9oaWdoX2xldmVsLApAQCAtMjYxLDI3ICsyNjEsMjcgQEAKIAl9CiB9CiAKLXN0YXRpYyBpbnQgbHBjMzJ4eF9zZXRfaXJxX3R5cGUodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IHR5cGUpCitzdGF0aWMgaW50IGxwYzMyeHhfc2V0X2lycV90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IHR5cGUpCiB7CiAJc3dpdGNoICh0eXBlKSB7CiAJY2FzZSBJUlFfVFlQRV9FREdFX1JJU0lORzoKIAkJLyogUmlzaW5nIGVkZ2Ugc2Vuc2l0aXZlICovCi0JCV9fbHBjMzJ4eF9zZXRfaXJxX3R5cGUoaXJxLCAxLCAxKTsKKwkJX19scGMzMnh4X3NldF9pcnFfdHlwZShkLT5pcnEsIDEsIDEpOwogCQlicmVhazsKIAogCWNhc2UgSVJRX1RZUEVfRURHRV9GQUxMSU5HOgogCQkvKiBGYWxsaW5nIGVkZ2Ugc2Vuc2l0aXZlICovCi0JCV9fbHBjMzJ4eF9zZXRfaXJxX3R5cGUoaXJxLCAwLCAxKTsKKwkJX19scGMzMnh4X3NldF9pcnFfdHlwZShkLT5pcnEsIDAsIDEpOwogCQlicmVhazsKIAogCWNhc2UgSVJRX1RZUEVfTEVWRUxfTE9XOgogCQkvKiBMb3cgbGV2ZWwgc2Vuc2l0aXZlICovCi0JCV9fbHBjMzJ4eF9zZXRfaXJxX3R5cGUoaXJxLCAwLCAwKTsKKwkJX19scGMzMnh4X3NldF9pcnFfdHlwZShkLT5pcnEsIDAsIDApOwogCQlicmVhazsKIAogCWNhc2UgSVJRX1RZUEVfTEVWRUxfSElHSDoKIAkJLyogSGlnaCBsZXZlbCBzZW5zaXRpdmUgKi8KLQkJX19scGMzMnh4X3NldF9pcnFfdHlwZShpcnEsIDEsIDApOworCQlfX2xwYzMyeHhfc2V0X2lycV90eXBlKGQtPmlycSwgMSwgMCk7CiAJCWJyZWFrOwogCiAJLyogT3RoZXIgbW9kZXMgYXJlIG5vdCBzdXBwb3J0ZWQgKi8KQEAgLTI5MCwzMyArMjkwLDMzIEBACiAJfQogCiAJLyogT2sgdG8gdXNlIHRoZSBsZXZlbCBoYW5kbGVyIGZvciBhbGwgdHlwZXMgKi8KLQlzZXRfaXJxX2hhbmRsZXIoaXJxLCBoYW5kbGVfbGV2ZWxfaXJxKTsKKwlzZXRfaXJxX2hhbmRsZXIoZC0+aXJxLCBoYW5kbGVfbGV2ZWxfaXJxKTsKIAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IGxwYzMyeHhfaXJxX3dha2UodW5zaWduZWQgaW50IGlycW5vLCB1bnNpZ25lZCBpbnQgc3RhdGUpCitzdGF0aWMgaW50IGxwYzMyeHhfaXJxX3dha2Uoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgc3RhdGUpCiB7CiAJdW5zaWduZWQgbG9uZyBldmVudHJlZzsKIAotCWlmIChscGMzMnh4X2V2ZW50c1tpcnFub10ubWFzayAhPSAwKSB7Ci0JCWV2ZW50cmVnID0gX19yYXdfcmVhZGwobHBjMzJ4eF9ldmVudHNbaXJxbm9dLgorCWlmIChscGMzMnh4X2V2ZW50c1tkLT5pcnFdLm1hc2sgIT0gMCkgeworCQlldmVudHJlZyA9IF9fcmF3X3JlYWRsKGxwYzMyeHhfZXZlbnRzW2QtPmlycV0uCiAJCQlldmVudF9ncm91cC0+ZW5hYl9yZWcpOwogCiAJCWlmIChzdGF0ZSkKLQkJCWV2ZW50cmVnIHw9IGxwYzMyeHhfZXZlbnRzW2lycW5vXS5tYXNrOworCQkJZXZlbnRyZWcgfD0gbHBjMzJ4eF9ldmVudHNbZC0+aXJxXS5tYXNrOwogCQllbHNlCi0JCQlldmVudHJlZyAmPSB+bHBjMzJ4eF9ldmVudHNbaXJxbm9dLm1hc2s7CisJCQlldmVudHJlZyAmPSB+bHBjMzJ4eF9ldmVudHNbZC0+aXJxXS5tYXNrOwogCiAJCV9fcmF3X3dyaXRlbChldmVudHJlZywKLQkJCWxwYzMyeHhfZXZlbnRzW2lycW5vXS5ldmVudF9ncm91cC0+ZW5hYl9yZWcpOworCQkJbHBjMzJ4eF9ldmVudHNbZC0+aXJxXS5ldmVudF9ncm91cC0+ZW5hYl9yZWcpOwogCiAJCXJldHVybiAwOwogCX0KIAogCS8qIENsZWFyIGV2ZW50ICovCi0JX19yYXdfd3JpdGVsKGxwYzMyeHhfZXZlbnRzW2lycW5vXS5tYXNrLAotCQlscGMzMnh4X2V2ZW50c1tpcnFub10uZXZlbnRfZ3JvdXAtPnJhd3N0YXRfcmVnKTsKKwlfX3Jhd193cml0ZWwobHBjMzJ4eF9ldmVudHNbZC0+aXJxXS5tYXNrLAorCQlscGMzMnh4X2V2ZW50c1tkLT5pcnFdLmV2ZW50X2dyb3VwLT5yYXdzdGF0X3JlZyk7CiAKIAlyZXR1cm4gLUVOT0RFVjsKIH0KQEAgLTMzNiwxMSArMzM2LDExIEBACiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbHBjMzJ4eF9pcnFfY2hpcCA9IHsKLQkuYWNrID0gbHBjMzJ4eF9hY2tfaXJxLAotCS5tYXNrID0gbHBjMzJ4eF9tYXNrX2lycSwKLQkudW5tYXNrID0gbHBjMzJ4eF91bm1hc2tfaXJxLAotCS5zZXRfdHlwZSA9IGxwYzMyeHhfc2V0X2lycV90eXBlLAotCS5zZXRfd2FrZSA9IGxwYzMyeHhfaXJxX3dha2UKKwkuaXJxX2FjayA9IGxwYzMyeHhfYWNrX2lycSwKKwkuaXJxX21hc2sgPSBscGMzMnh4X21hc2tfaXJxLAorCS5pcnFfdW5tYXNrID0gbHBjMzJ4eF91bm1hc2tfaXJxLAorCS5pcnFfc2V0X3R5cGUgPSBscGMzMnh4X3NldF9pcnFfdHlwZSwKKwkuaXJxX3NldF93YWtlID0gbHBjMzJ4eF9pcnFfd2FrZQogfTsKIAogc3RhdGljIHZvaWQgbHBjMzJ4eF9zaWMxX2hhbmRsZXIodW5zaWduZWQgaW50IGlycSwgc3RydWN0IGlycV9kZXNjICpkZXNjKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1tbXAvaW5jbHVkZS9tYWNoL21mcC1tbXAyLmggYi9hcmNoL2FybS9tYWNoLW1tcC9pbmNsdWRlL21hY2gvbWZwLW1tcDIuaAppbmRleCAxMTdlMzAzLi40YWQzODYyIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW1tcC9pbmNsdWRlL21hY2gvbWZwLW1tcDIuaAorKysgYi9hcmNoL2FybS9tYWNoLW1tcC9pbmNsdWRlL21hY2gvbWZwLW1tcDIuaApAQCAtNiw3ICs2LDcgQEAKICNkZWZpbmUgTUZQX0RSSVZFX1ZFUllfU0xPVwkoMHgwIDw8IDEzKQogI2RlZmluZSBNRlBfRFJJVkVfU0xPVwkJKDB4MiA8PCAxMykKICNkZWZpbmUgTUZQX0RSSVZFX01FRElVTQkoMHg0IDw8IDEzKQotI2RlZmluZSBNRlBfRFJJVkVfRkFTVAkJKDB4OCA8PCAxMykKKyNkZWZpbmUgTUZQX0RSSVZFX0ZBU1QJCSgweDYgPDwgMTMpCiAKIC8qIEdQSU8gKi8KICNkZWZpbmUgR1BJTzBfR1BJTwlNRlBfQ0ZHKEdQSU8wLCBBRjApCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW1tcC9pbmNsdWRlL21hY2gvbWZwLXB4YTkxMC5oIGIvYXJjaC9hcm0vbWFjaC1tbXAvaW5jbHVkZS9tYWNoL21mcC1weGE5MTAuaAppbmRleCA3ZThhODBmLi5mYmQ3ZWU4IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW1tcC9pbmNsdWRlL21hY2gvbWZwLXB4YTkxMC5oCisrKyBiL2FyY2gvYXJtL21hY2gtbW1wL2luY2x1ZGUvbWFjaC9tZnAtcHhhOTEwLmgKQEAgLTYsNyArNiw3IEBACiAjZGVmaW5lIE1GUF9EUklWRV9WRVJZX1NMT1cJKDB4MCA8PCAxMykKICNkZWZpbmUgTUZQX0RSSVZFX1NMT1cJCSgweDIgPDwgMTMpCiAjZGVmaW5lIE1GUF9EUklWRV9NRURJVU0JKDB4NCA8PCAxMykKLSNkZWZpbmUgTUZQX0RSSVZFX0ZBU1QJCSgweDggPDwgMTMpCisjZGVmaW5lIE1GUF9EUklWRV9GQVNUCQkoMHg2IDw8IDEzKQogCiAvKiBVQVJUMiAqLwogI2RlZmluZSBHUElPNDdfVUFSVDJfUlhECU1GUF9DRkcoR1BJTzQ3LCBBRjYpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW1tcC9pcnEtbW1wMi5jIGIvYXJjaC9hcm0vbWFjaC1tbXAvaXJxLW1tcDIuYwppbmRleCAwMTM0MmJlLi5mYTAzNzAzIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW1tcC9pcnEtbW1wMi5jCisrKyBiL2FyY2gvYXJtL21hY2gtbW1wL2lycS1tbXAyLmMKQEAgLTIwLDQ4ICsyMCw0OCBAQAogCiAjaW5jbHVkZSAiY29tbW9uLmgiCiAKLXN0YXRpYyB2b2lkIGljdV9tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaWN1X21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl1aW50MzJfdCByID0gX19yYXdfcmVhZGwoSUNVX0lOVF9DT05GKGlycSkpOworCXVpbnQzMl90IHIgPSBfX3Jhd19yZWFkbChJQ1VfSU5UX0NPTkYoZC0+aXJxKSk7CiAKIAlyICY9IH5JQ1VfSU5UX1JPVVRFX1BKNF9JUlE7Ci0JX19yYXdfd3JpdGVsKHIsIElDVV9JTlRfQ09ORihpcnEpKTsKKwlfX3Jhd193cml0ZWwociwgSUNVX0lOVF9DT05GKGQtPmlycSkpOwogfQogCi1zdGF0aWMgdm9pZCBpY3VfdW5tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaWN1X3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXVpbnQzMl90IHIgPSBfX3Jhd19yZWFkbChJQ1VfSU5UX0NPTkYoaXJxKSk7CisJdWludDMyX3QgciA9IF9fcmF3X3JlYWRsKElDVV9JTlRfQ09ORihkLT5pcnEpKTsKIAogCXIgfD0gSUNVX0lOVF9ST1VURV9QSjRfSVJROwotCV9fcmF3X3dyaXRlbChyLCBJQ1VfSU5UX0NPTkYoaXJxKSk7CisJX19yYXdfd3JpdGVsKHIsIElDVV9JTlRfQ09ORihkLT5pcnEpKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBpY3VfaXJxX2NoaXAgPSB7CiAJLm5hbWUJCT0gImljdV9pcnEiLAotCS5tYXNrCQk9IGljdV9tYXNrX2lycSwKLQkubWFza19hY2sJPSBpY3VfbWFza19pcnEsCi0JLnVubWFzawkJPSBpY3VfdW5tYXNrX2lycSwKKwkuaXJxX21hc2sJPSBpY3VfbWFza19pcnEsCisJLmlycV9tYXNrX2Fjawk9IGljdV9tYXNrX2lycSwKKwkuaXJxX3VubWFzawk9IGljdV91bm1hc2tfaXJxLAogfTsKIAotc3RhdGljIHZvaWQgcG1pY19pcnFfYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBwbWljX2lycV9hY2soc3RydWN0IGlycV9kYXRhICpkKQogewotCWlmIChpcnEgPT0gSVJRX01NUDJfUE1JQykKKwlpZiAoZC0+aXJxID09IElSUV9NTVAyX1BNSUMpCiAJCW1tcDJfY2xlYXJfcG1pY19pbnQoKTsKIH0KIAogI2RlZmluZSBTRUNPTkRfSVJRX01BU0soX25hbWVfLCBpcnFfYmFzZSwgcHJlZml4KQkJCVwKLXN0YXRpYyB2b2lkIF9uYW1lXyMjX21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCQkJCVwKK3N0YXRpYyB2b2lkIF9uYW1lXyMjX21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkJCQlcCiB7CQkJCQkJCQkJXAogCXVpbnQzMl90IHI7CQkJCQkJCVwKLQlyID0gX19yYXdfcmVhZGwocHJlZml4IyNfTUFTSykgfCAoMSA8PCAoaXJxIC0gaXJxX2Jhc2UpKTsJXAorCXIgPSBfX3Jhd19yZWFkbChwcmVmaXgjI19NQVNLKSB8ICgxIDw8IChkLT5pcnEgLSBpcnFfYmFzZSkpOwlcCiAJX19yYXdfd3JpdGVsKHIsIHByZWZpeCMjX01BU0spOwkJCQkJXAogfQogCiAjZGVmaW5lIFNFQ09ORF9JUlFfVU5NQVNLKF9uYW1lXywgaXJxX2Jhc2UsIHByZWZpeCkJCQlcCi1zdGF0aWMgdm9pZCBfbmFtZV8jI191bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCQkJXAorc3RhdGljIHZvaWQgX25hbWVfIyNfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCQkJXAogewkJCQkJCQkJCVwKIAl1aW50MzJfdCByOwkJCQkJCQlcCi0JciA9IF9fcmF3X3JlYWRsKHByZWZpeCMjX01BU0spICYgfigxIDw8IChpcnEgLSBpcnFfYmFzZSkpOwlcCisJciA9IF9fcmF3X3JlYWRsKHByZWZpeCMjX01BU0spICYgfigxIDw8IChkLT5pcnEgLSBpcnFfYmFzZSkpOwlcCiAJX19yYXdfd3JpdGVsKHIsIHByZWZpeCMjX01BU0spOwkJCQkJXAogfQogCkBAIC04OCw4ICs4OCw4IEBACiBTRUNPTkRfSVJRX0RFTVVYKF9uYW1lXywgaXJxX2Jhc2UsIHByZWZpeCkJCQkJXAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBfbmFtZV8jI19pcnFfY2hpcCA9IHsJCQkJXAogCS5uYW1lCQk9ICNfbmFtZV8sCQkJCQlcCi0JLm1hc2sJCT0gX25hbWVfIyNfbWFza19pcnEsCQkJCVwKLQkudW5tYXNrCQk9IF9uYW1lXyMjX3VubWFza19pcnEsCQkJCVwKKwkuaXJxX21hc2sJPSBfbmFtZV8jI19tYXNrX2lycSwJCQkJXAorCS5pcnFfdW5tYXNrCT0gX25hbWVfIyNfdW5tYXNrX2lycSwJCQkJXAogfQogCiBTRUNPTkRfSVJRX0NISVAocG1pYywgSVJRX01NUDJfUE1JQ19CQVNFLCBNTVAyX0lDVV9JTlQ0KTsKQEAgLTEwMywxMCArMTAzLDEyIEBACiAJaW50IGlycTsKIAogCWZvciAoaXJxID0gc3RhcnQ7IG51bSA+IDA7IGlycSsrLCBudW0tLSkgeworCQlzdHJ1Y3QgaXJxX2RhdGEgKmQgPSBpcnFfZ2V0X2lycV9kYXRhKGlycSk7CisKIAkJLyogbWFzayBhbmQgY2xlYXIgdGhlIElSUSAqLwotCQljaGlwLT5tYXNrKGlycSk7Ci0JCWlmIChjaGlwLT5hY2spCi0JCQljaGlwLT5hY2soaXJxKTsKKwkJY2hpcC0+aXJxX21hc2soZCk7CisJCWlmIChjaGlwLT5pcnFfYWNrKQorCQkJY2hpcC0+aXJxX2FjayhkKTsKIAogCQlzZXRfaXJxX2NoaXAoaXJxLCBjaGlwKTsKIAkJc2V0X2lycV9mbGFncyhpcnEsIElSUUZfVkFMSUQpOwpAQCAtMTE5LDcgKzEyMSw3IEBACiAJaW50IGlycTsKIAogCWZvciAoaXJxID0gMDsgaXJxIDwgSVJRX01NUDJfTVVYX0JBU0U7IGlycSsrKSB7Ci0JCWljdV9tYXNrX2lycShpcnEpOworCQlpY3VfbWFza19pcnEoaXJxX2dldF9pcnFfZGF0YShpcnEpKTsKIAkJc2V0X2lycV9jaGlwKGlycSwgJmljdV9pcnFfY2hpcCk7CiAJCXNldF9pcnFfZmxhZ3MoaXJxLCBJUlFGX1ZBTElEKTsKIApAQCAtMTM5LDcgKzE0MSw3IEBACiAJLyogTk9URTogSVJRX01NUDJfUE1JQyByZXF1aXJlcyB0aGUgUE1JQyBNRlBSIHJlZ2lzdGVyCiAJICogdG8gYmUgd3JpdHRlbiB0byBjbGVhciB0aGUgaW50ZXJydXB0CiAJICovCi0JcG1pY19pcnFfY2hpcC5hY2sgPSBwbWljX2lycV9hY2s7CisJcG1pY19pcnFfY2hpcC5pcnFfYWNrID0gcG1pY19pcnFfYWNrOwogCiAJaW5pdF9tdXhfaXJxKCZwbWljX2lycV9jaGlwLCBJUlFfTU1QMl9QTUlDX0JBU0UsIDIpOwogCWluaXRfbXV4X2lycSgmcnRjX2lycV9jaGlwLCBJUlFfTU1QMl9SVENfQkFTRSwgMik7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW1tcC9pcnEtcHhhMTY4LmMgYi9hcmNoL2FybS9tYWNoLW1tcC9pcnEtcHhhMTY4LmMKaW5kZXggNTJmZjJmMC4uZjg2YjQ1MCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1tbXAvaXJxLXB4YTE2OC5jCisrKyBiL2FyY2gvYXJtL21hY2gtbW1wL2lycS1weGExNjguYwpAQCAtMjUsMjEgKzI1LDIxIEBACiAjZGVmaW5lIFBSSU9SSVRZX0RFRkFVTFQJMHgxCiAjZGVmaW5lIFBSSU9SSVRZX05PTkUJCTB4MAkvKiBtZWFucyBJUlEgZGlzYWJsZWQgKi8KIAotc3RhdGljIHZvaWQgaWN1X21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpY3VfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCV9fcmF3X3dyaXRlbChQUklPUklUWV9OT05FLCBJQ1VfSU5UX0NPTkYoaXJxKSk7CisJX19yYXdfd3JpdGVsKFBSSU9SSVRZX05PTkUsIElDVV9JTlRfQ09ORihkLT5pcnEpKTsKIH0KIAotc3RhdGljIHZvaWQgaWN1X3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGljdV91bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlfX3Jhd193cml0ZWwoSVJRX1JPVVRFX1RPX0FQIHwgUFJJT1JJVFlfREVGQVVMVCwgSUNVX0lOVF9DT05GKGlycSkpOworCV9fcmF3X3dyaXRlbChJUlFfUk9VVEVfVE9fQVAgfCBQUklPUklUWV9ERUZBVUxULCBJQ1VfSU5UX0NPTkYoZC0+aXJxKSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgaWN1X2lycV9jaGlwID0gewotCS5uYW1lCT0gImljdV9pcnEiLAotCS5hY2sJPSBpY3VfbWFza19pcnEsCi0JLm1hc2sJPSBpY3VfbWFza19pcnEsCi0JLnVubWFzawk9IGljdV91bm1hc2tfaXJxLAorCS5uYW1lCQk9ICJpY3VfaXJxIiwKKwkuaXJxX2Fjawk9IGljdV9tYXNrX2lycSwKKwkuaXJxX21hc2sJPSBpY3VfbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBpY3VfdW5tYXNrX2lycSwKIH07CiAKIHZvaWQgX19pbml0IGljdV9pbml0X2lycSh2b2lkKQpAQCAtNDcsNyArNDcsNyBAQAogCWludCBpcnE7CiAKIAlmb3IgKGlycSA9IDA7IGlycSA8IDY0OyBpcnErKykgewotCQlpY3VfbWFza19pcnEoaXJxKTsKKwkJaWN1X21hc2tfaXJxKGlycV9nZXRfaXJxX2RhdGEoaXJxKSk7CiAJCXNldF9pcnFfY2hpcChpcnEsICZpY3VfaXJxX2NoaXApOwogCQlzZXRfaXJxX2hhbmRsZXIoaXJxLCBoYW5kbGVfbGV2ZWxfaXJxKTsKIAkJc2V0X2lycV9mbGFncyhpcnEsIElSUUZfVkFMSUQpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1tc20vYm9hcmQtcXNkOHg1MC5jIGIvYXJjaC9hcm0vbWFjaC1tc20vYm9hcmQtcXNkOHg1MC5jCmluZGV4IDJlODM5MTMuLjZkZGU4MTggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbXNtL2JvYXJkLXFzZDh4NTAuYworKysgYi9hcmNoL2FybS9tYWNoLW1zbS9ib2FyZC1xc2Q4eDUwLmMKQEAgLTQzLDcgKzQzLDcgQEAKICAqIGF0IHJ1bi10aW1lOiB0aGV5IHZhcnkgZnJvbSBib2FyZCB0byBib2FyZCwgYW5kIHRoZSB0cnVlCiAgKiBjb25maWd1cmF0aW9uIHdvbid0IGJlIGtub3duIHVudGlsIGJvb3QuCiAgKi8KLXN0YXRpYyBzdHJ1Y3QgcmVzb3VyY2Ugc21jOTF4X3Jlc291cmNlc1tdIF9faW5pdGRhdGEgPSB7CitzdGF0aWMgc3RydWN0IHJlc291cmNlIHNtYzkxeF9yZXNvdXJjZXNbXSA9IHsKIAlbMF0gPSB7CiAJCS5mbGFncyA9IElPUkVTT1VSQ0VfTUVNLAogCX0sCkBAIC01Miw3ICs1Miw3IEBACiAJfSwKIH07CiAKLXN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIHNtYzkxeF9kZXZpY2UgX19pbml0ZGF0YSA9IHsKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIHNtYzkxeF9kZXZpY2UgPSB7CiAJLm5hbWUgICAgICAgICAgID0gInNtYzkxeCIsCiAJLmlkICAgICAgICAgICAgID0gMCwKIAkubnVtX3Jlc291cmNlcyAgPSBBUlJBWV9TSVpFKHNtYzkxeF9yZXNvdXJjZXMpLApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1tc20vYm9hcmQtdHJvdXQtZ3Bpby5jIGIvYXJjaC9hcm0vbWFjaC1tc20vYm9hcmQtdHJvdXQtZ3Bpby5jCmluZGV4IGY4YzA5ZWYuLmE2MDRlYzEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbXNtL2JvYXJkLXRyb3V0LWdwaW8uYworKysgYi9hcmNoL2FybS9tYWNoLW1zbS9ib2FyZC10cm91dC1ncGlvLmMKQEAgLTExMyw1MiArMTEzLDUyIEBACiAJVFJPVVRfR1BJT19CQU5LKCJWSVJUVUFMIiwgMHgxMiwgVFJPVVRfR1BJT19WSVJUVUFMX0JBU0UsIDApLAogfTsKIAotc3RhdGljIHZvaWQgdHJvdXRfZ3Bpb19pcnFfYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB0cm91dF9ncGlvX2lycV9hY2soc3RydWN0IGlycV9kYXRhICpkKQogewotCWludCBiYW5rID0gVFJPVVRfSU5UX1RPX0JBTksoaXJxKTsKLQl1aW50OF90IG1hc2sgPSBUUk9VVF9JTlRfVE9fTUFTSyhpcnEpOworCWludCBiYW5rID0gVFJPVVRfSU5UX1RPX0JBTksoZC0+aXJxKTsKKwl1aW50OF90IG1hc2sgPSBUUk9VVF9JTlRfVE9fTUFTSyhkLT5pcnEpOwogCWludCByZWcgPSBUUk9VVF9CQU5LX1RPX1NUQVRfUkVHKGJhbmspOwotCS8qcHJpbnRrKEtFUk5fSU5GTyAidHJvdXRfZ3Bpb19pcnFfYWNrIGlycSAlZFxuIiwgaXJxKTsqLworCS8qcHJpbnRrKEtFUk5fSU5GTyAidHJvdXRfZ3Bpb19pcnFfYWNrIGlycSAlZFxuIiwgZC0+aXJxKTsqLwogCXdyaXRlYihtYXNrLCBUUk9VVF9DUExEX0JBU0UgKyByZWcpOwogfQogCi1zdGF0aWMgdm9pZCB0cm91dF9ncGlvX2lycV9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB0cm91dF9ncGlvX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCXVpbnQ4X3QgcmVnX3ZhbDsKLQlpbnQgYmFuayA9IFRST1VUX0lOVF9UT19CQU5LKGlycSk7Ci0JdWludDhfdCBtYXNrID0gVFJPVVRfSU5UX1RPX01BU0soaXJxKTsKKwlpbnQgYmFuayA9IFRST1VUX0lOVF9UT19CQU5LKGQtPmlycSk7CisJdWludDhfdCBtYXNrID0gVFJPVVRfSU5UX1RPX01BU0soZC0+aXJxKTsKIAlpbnQgcmVnID0gVFJPVVRfQkFOS19UT19NQVNLX1JFRyhiYW5rKTsKIAogCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKIAlyZWdfdmFsID0gdHJvdXRfaW50X21hc2tbYmFua10gfD0gbWFzazsKIAkvKnByaW50ayhLRVJOX0lORk8gInRyb3V0X2dwaW9faXJxX21hc2sgaXJxICVkID0+ICVkOiUwMnhcbiIsCi0JICAgICAgIGlycSwgYmFuaywgcmVnX3ZhbCk7Ki8KKwkgICAgICAgZC0+aXJxLCBiYW5rLCByZWdfdmFsKTsqLwogCXdyaXRlYihyZWdfdmFsLCBUUk9VVF9DUExEX0JBU0UgKyByZWcpOwogCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKIH0KIAotc3RhdGljIHZvaWQgdHJvdXRfZ3Bpb19pcnFfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB0cm91dF9ncGlvX2lycV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJdWludDhfdCByZWdfdmFsOwotCWludCBiYW5rID0gVFJPVVRfSU5UX1RPX0JBTksoaXJxKTsKLQl1aW50OF90IG1hc2sgPSBUUk9VVF9JTlRfVE9fTUFTSyhpcnEpOworCWludCBiYW5rID0gVFJPVVRfSU5UX1RPX0JBTksoZC0+aXJxKTsKKwl1aW50OF90IG1hc2sgPSBUUk9VVF9JTlRfVE9fTUFTSyhkLT5pcnEpOwogCWludCByZWcgPSBUUk9VVF9CQU5LX1RPX01BU0tfUkVHKGJhbmspOwogCiAJbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOwogCXJlZ192YWwgPSB0cm91dF9pbnRfbWFza1tiYW5rXSAmPSB+bWFzazsKIAkvKnByaW50ayhLRVJOX0lORk8gInRyb3V0X2dwaW9faXJxX3VubWFzayBpcnEgJWQgPT4gJWQ6JTAyeFxuIiwKLQkgICAgICAgaXJxLCBiYW5rLCByZWdfdmFsKTsqLworCSAgICAgICBkLT5pcnEsIGJhbmssIHJlZ192YWwpOyovCiAJd3JpdGViKHJlZ192YWwsIFRST1VUX0NQTERfQkFTRSArIHJlZyk7CiAJbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogfQogCi1pbnQgdHJvdXRfZ3Bpb19pcnFfc2V0X3dha2UodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IG9uKQoraW50IHRyb3V0X2dwaW9faXJxX3NldF93YWtlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IG9uKQogewogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0JaW50IGJhbmsgPSBUUk9VVF9JTlRfVE9fQkFOSyhpcnEpOwotCXVpbnQ4X3QgbWFzayA9IFRST1VUX0lOVF9UT19NQVNLKGlycSk7CisJaW50IGJhbmsgPSBUUk9VVF9JTlRfVE9fQkFOSyhkLT5pcnEpOworCXVpbnQ4X3QgbWFzayA9IFRST1VUX0lOVF9UT19NQVNLKGQtPmlycSk7CiAKIAlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CiAJaWYob24pCkBAIC0xOTgsMTUgKzE5OCwxNSBAQAogCQl9CiAJCWludF9iYXNlICs9IFRST1VUX0lOVF9CQU5LMF9DT1VOVDsKIAl9Ci0JZGVzYy0+Y2hpcC0+YWNrKGlycSk7CisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX2FjaygmZGVzYy0+aXJxX2RhdGEpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHRyb3V0X2dwaW9faXJxX2NoaXAgPSB7Ci0JLm5hbWUgICAgICA9ICJ0cm91dGdwaW8iLAotCS5hY2sgICAgICAgPSB0cm91dF9ncGlvX2lycV9hY2ssCi0JLm1hc2sgICAgICA9IHRyb3V0X2dwaW9faXJxX21hc2ssCi0JLnVubWFzayAgICA9IHRyb3V0X2dwaW9faXJxX3VubWFzaywKLQkuc2V0X3dha2UgID0gdHJvdXRfZ3Bpb19pcnFfc2V0X3dha2UsCisJLm5hbWUgICAgICAgICAgPSAidHJvdXRncGlvIiwKKwkuaXJxX2FjayAgICAgICA9IHRyb3V0X2dwaW9faXJxX2FjaywKKwkuaXJxX21hc2sgICAgICA9IHRyb3V0X2dwaW9faXJxX21hc2ssCisJLmlycV91bm1hc2sgICAgPSB0cm91dF9ncGlvX2lycV91bm1hc2ssCisJLmlycV9zZXRfd2FrZSAgPSB0cm91dF9ncGlvX2lycV9zZXRfd2FrZSwKIH07CiAKIC8qCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW1zbS9ncGlvLmMgYi9hcmNoL2FybS9tYWNoLW1zbS9ncGlvLmMKaW5kZXggMzMwNTFiNS4uMTc2YWY5ZCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1tc20vZ3Bpby5jCisrKyBiL2FyY2gvYXJtL21hY2gtbXNtL2dwaW8uYwpAQCAtMjI1LDIxICsyMjUsMjEgQEAKICNlbmRpZgogfTsKIAotc3RhdGljIHZvaWQgbXNtX2dwaW9faXJxX2Fjayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbXNtX2dwaW9faXJxX2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdW5zaWduZWQgbG9uZyBpcnFfZmxhZ3M7Ci0Jc3RydWN0IG1zbV9ncGlvX2NoaXAgKm1zbV9jaGlwID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgbXNtX2dwaW9fY2hpcCAqbXNtX2NoaXAgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKIAlzcGluX2xvY2tfaXJxc2F2ZSgmbXNtX2NoaXAtPmxvY2ssIGlycV9mbGFncyk7CiAJbXNtX2dwaW9fY2xlYXJfZGV0ZWN0X3N0YXR1cyhtc21fY2hpcCwKLQkJCQkgICAgIGlycSAtIGdwaW9fdG9faXJxKG1zbV9jaGlwLT5jaGlwLmJhc2UpKTsKKwkJCQkgICAgIGQtPmlycSAtIGdwaW9fdG9faXJxKG1zbV9jaGlwLT5jaGlwLmJhc2UpKTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZtc21fY2hpcC0+bG9jaywgaXJxX2ZsYWdzKTsKIH0KIAotc3RhdGljIHZvaWQgbXNtX2dwaW9faXJxX21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1zbV9ncGlvX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl1bnNpZ25lZCBsb25nIGlycV9mbGFnczsKLQlzdHJ1Y3QgbXNtX2dwaW9fY2hpcCAqbXNtX2NoaXAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOwotCXVuc2lnbmVkIG9mZnNldCA9IGlycSAtIGdwaW9fdG9faXJxKG1zbV9jaGlwLT5jaGlwLmJhc2UpOworCXN0cnVjdCBtc21fZ3Bpb19jaGlwICptc21fY2hpcCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOworCXVuc2lnbmVkIG9mZnNldCA9IGQtPmlycSAtIGdwaW9fdG9faXJxKG1zbV9jaGlwLT5jaGlwLmJhc2UpOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJm1zbV9jaGlwLT5sb2NrLCBpcnFfZmxhZ3MpOwogCS8qIGxldmVsIHRyaWdnZXJlZCBpbnRlcnJ1cHRzIGFyZSBhbHNvIGxhdGNoZWQgKi8KQEAgLTI1MCwxMSArMjUwLDExIEBACiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmbXNtX2NoaXAtPmxvY2ssIGlycV9mbGFncyk7CiB9CiAKLXN0YXRpYyB2b2lkIG1zbV9ncGlvX2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1zbV9ncGlvX2lycV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGxvbmcgaXJxX2ZsYWdzOwotCXN0cnVjdCBtc21fZ3Bpb19jaGlwICptc21fY2hpcCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7Ci0JdW5zaWduZWQgb2Zmc2V0ID0gaXJxIC0gZ3Bpb190b19pcnEobXNtX2NoaXAtPmNoaXAuYmFzZSk7CisJc3RydWN0IG1zbV9ncGlvX2NoaXAgKm1zbV9jaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZCk7CisJdW5zaWduZWQgb2Zmc2V0ID0gZC0+aXJxIC0gZ3Bpb190b19pcnEobXNtX2NoaXAtPmNoaXAuYmFzZSk7CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmbXNtX2NoaXAtPmxvY2ssIGlycV9mbGFncyk7CiAJLyogbGV2ZWwgdHJpZ2dlcmVkIGludGVycnVwdHMgYXJlIGFsc28gbGF0Y2hlZCAqLwpAQCAtMjY1LDExICsyNjUsMTEgQEAKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZtc21fY2hpcC0+bG9jaywgaXJxX2ZsYWdzKTsKIH0KIAotc3RhdGljIGludCBtc21fZ3Bpb19pcnFfc2V0X3dha2UodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IG9uKQorc3RhdGljIGludCBtc21fZ3Bpb19pcnFfc2V0X3dha2Uoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgb24pCiB7CiAJdW5zaWduZWQgbG9uZyBpcnFfZmxhZ3M7Ci0Jc3RydWN0IG1zbV9ncGlvX2NoaXAgKm1zbV9jaGlwID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQl1bnNpZ25lZCBvZmZzZXQgPSBpcnEgLSBncGlvX3RvX2lycShtc21fY2hpcC0+Y2hpcC5iYXNlKTsKKwlzdHJ1Y3QgbXNtX2dwaW9fY2hpcCAqbXNtX2NoaXAgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKKwl1bnNpZ25lZCBvZmZzZXQgPSBkLT5pcnEgLSBncGlvX3RvX2lycShtc21fY2hpcC0+Y2hpcC5iYXNlKTsKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZtc21fY2hpcC0+bG9jaywgaXJxX2ZsYWdzKTsKIApAQCAtMjgyLDIxICsyODIsMjEgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCBtc21fZ3Bpb19pcnFfc2V0X3R5cGUodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IGZsb3dfdHlwZSkKK3N0YXRpYyBpbnQgbXNtX2dwaW9faXJxX3NldF90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IGZsb3dfdHlwZSkKIHsKIAl1bnNpZ25lZCBsb25nIGlycV9mbGFnczsKLQlzdHJ1Y3QgbXNtX2dwaW9fY2hpcCAqbXNtX2NoaXAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOwotCXVuc2lnbmVkIG9mZnNldCA9IGlycSAtIGdwaW9fdG9faXJxKG1zbV9jaGlwLT5jaGlwLmJhc2UpOworCXN0cnVjdCBtc21fZ3Bpb19jaGlwICptc21fY2hpcCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOworCXVuc2lnbmVkIG9mZnNldCA9IGQtPmlycSAtIGdwaW9fdG9faXJxKG1zbV9jaGlwLT5jaGlwLmJhc2UpOwogCXVuc2lnbmVkIHZhbCwgbWFzayA9IEJJVChvZmZzZXQpOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJm1zbV9jaGlwLT5sb2NrLCBpcnFfZmxhZ3MpOwogCXZhbCA9IHJlYWRsKG1zbV9jaGlwLT5yZWdzLmludF9lZGdlKTsKIAlpZiAoZmxvd190eXBlICYgSVJRX1RZUEVfRURHRV9CT1RIKSB7CiAJCXdyaXRlbCh2YWwgfCBtYXNrLCBtc21fY2hpcC0+cmVncy5pbnRfZWRnZSk7Ci0JCWlycV9kZXNjW2lycV0uaGFuZGxlX2lycSA9IGhhbmRsZV9lZGdlX2lycTsKKwkJaXJxX2Rlc2NbZC0+aXJxXS5oYW5kbGVfaXJxID0gaGFuZGxlX2VkZ2VfaXJxOwogCX0gZWxzZSB7CiAJCXdyaXRlbCh2YWwgJiB+bWFzaywgbXNtX2NoaXAtPnJlZ3MuaW50X2VkZ2UpOwotCQlpcnFfZGVzY1tpcnFdLmhhbmRsZV9pcnEgPSBoYW5kbGVfbGV2ZWxfaXJxOworCQlpcnFfZGVzY1tkLT5pcnFdLmhhbmRsZV9pcnEgPSBoYW5kbGVfbGV2ZWxfaXJxOwogCX0KIAlpZiAoKGZsb3dfdHlwZSAmIElSUV9UWVBFX0VER0VfQk9USCkgPT0gSVJRX1RZUEVfRURHRV9CT1RIKSB7CiAJCW1zbV9jaGlwLT5ib3RoX2VkZ2VfZGV0ZWN0IHw9IG1hc2s7CkBAIC0zMzMsMTYgKzMzMywxNiBAQAogCQkJCQkgICBtc21fY2hpcC0+Y2hpcC5iYXNlICsgaik7CiAJCX0KIAl9Ci0JZGVzYy0+Y2hpcC0+YWNrKGlycSk7CisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX2FjaygmZGVzYy0+aXJxX2RhdGEpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG1zbV9ncGlvX2lycV9jaGlwID0gewotCS5uYW1lICAgICAgPSAibXNtZ3BpbyIsCi0JLmFjayAgICAgICA9IG1zbV9ncGlvX2lycV9hY2ssCi0JLm1hc2sgICAgICA9IG1zbV9ncGlvX2lycV9tYXNrLAotCS51bm1hc2sgICAgPSBtc21fZ3Bpb19pcnFfdW5tYXNrLAotCS5zZXRfd2FrZSAgPSBtc21fZ3Bpb19pcnFfc2V0X3dha2UsCi0JLnNldF90eXBlICA9IG1zbV9ncGlvX2lycV9zZXRfdHlwZSwKKwkubmFtZSAgICAgICAgICA9ICJtc21ncGlvIiwKKwkuaXJxX2FjayAgICAgICA9IG1zbV9ncGlvX2lycV9hY2ssCisJLmlycV9tYXNrICAgICAgPSBtc21fZ3Bpb19pcnFfbWFzaywKKwkuaXJxX3VubWFzayAgICA9IG1zbV9ncGlvX2lycV91bm1hc2ssCisJLmlycV9zZXRfd2FrZSAgPSBtc21fZ3Bpb19pcnFfc2V0X3dha2UsCisJLmlycV9zZXRfdHlwZSAgPSBtc21fZ3Bpb19pcnFfc2V0X3R5cGUsCiB9OwogCiBzdGF0aWMgaW50IF9faW5pdCBtc21faW5pdF9ncGlvKHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW1zbS9pcnEtdmljLmMgYi9hcmNoL2FybS9tYWNoLW1zbS9pcnEtdmljLmMKaW5kZXggOTlmMmMzNC4uNjhjMjhiYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1tc20vaXJxLXZpYy5jCisrKyBiL2FyY2gvYXJtL21hY2gtbXNtL2lycS12aWMuYwpAQCAtMjI2LDE5ICsyMjYsMTggQEAKIAkJd3JpdGVsKHZhbCwgYmFzZSArIChpICogNCkpOwogfQogCi1zdGF0aWMgdm9pZCBtc21faXJxX2Fjayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbXNtX2lycV9hY2soc3RydWN0IGlycV9kYXRhICpkKQogewotCXZvaWQgX19pb21lbSAqcmVnID0gVklDX0lOVF9UT19SRUdfQUREUihWSUNfSU5UX0NMRUFSMCwgaXJxKTsKLQlpcnEgPSAxIDw8IChpcnEgJiAzMSk7Ci0Jd3JpdGVsKGlycSwgcmVnKTsKKwl2b2lkIF9faW9tZW0gKnJlZyA9IFZJQ19JTlRfVE9fUkVHX0FERFIoVklDX0lOVF9DTEVBUjAsIGQtPmlycSk7CisJd3JpdGVsKDEgPDwgKGQtPmlycSAmIDMxKSwgcmVnKTsKIH0KIAotc3RhdGljIHZvaWQgbXNtX2lycV9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBtc21faXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkKQogewotCXZvaWQgX19pb21lbSAqcmVnID0gVklDX0lOVF9UT19SRUdfQUREUihWSUNfSU5UX0VOQ0xFQVIwLCBpcnEpOwotCXVuc2lnbmVkIGluZGV4ID0gVklDX0lOVF9UT19SRUdfSU5ERVgoaXJxKTsKLQl1aW50MzJfdCBtYXNrID0gMVVMIDw8IChpcnEgJiAzMSk7Ci0JaW50IHNtc21faXJxID0gbXNtX2lycV90b19zbXNtW2lycV07CisJdm9pZCBfX2lvbWVtICpyZWcgPSBWSUNfSU5UX1RPX1JFR19BRERSKFZJQ19JTlRfRU5DTEVBUjAsIGQtPmlycSk7CisJdW5zaWduZWQgaW5kZXggPSBWSUNfSU5UX1RPX1JFR19JTkRFWChkLT5pcnEpOworCXVpbnQzMl90IG1hc2sgPSAxVUwgPDwgKGQtPmlycSAmIDMxKTsKKwlpbnQgc21zbV9pcnEgPSBtc21faXJxX3RvX3Ntc21bZC0+aXJxXTsKIAogCW1zbV9pcnFfc2hhZG93X3JlZ1tpbmRleF0uaW50X2VuWzBdICY9IH5tYXNrOwogCXdyaXRlbChtYXNrLCByZWcpOwpAQCAtMjUwLDEyICsyNDksMTIgQEAKIAl9CiB9CiAKLXN0YXRpYyB2b2lkIG1zbV9pcnFfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBtc21faXJxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jdm9pZCBfX2lvbWVtICpyZWcgPSBWSUNfSU5UX1RPX1JFR19BRERSKFZJQ19JTlRfRU5TRVQwLCBpcnEpOwotCXVuc2lnbmVkIGluZGV4ID0gVklDX0lOVF9UT19SRUdfSU5ERVgoaXJxKTsKLQl1aW50MzJfdCBtYXNrID0gMVVMIDw8IChpcnEgJiAzMSk7Ci0JaW50IHNtc21faXJxID0gbXNtX2lycV90b19zbXNtW2lycV07CisJdm9pZCBfX2lvbWVtICpyZWcgPSBWSUNfSU5UX1RPX1JFR19BRERSKFZJQ19JTlRfRU5TRVQwLCBkLT5pcnEpOworCXVuc2lnbmVkIGluZGV4ID0gVklDX0lOVF9UT19SRUdfSU5ERVgoZC0+aXJxKTsKKwl1aW50MzJfdCBtYXNrID0gMVVMIDw8IChkLT5pcnEgJiAzMSk7CisJaW50IHNtc21faXJxID0gbXNtX2lycV90b19zbXNtW2QtPmlycV07CiAKIAltc21faXJxX3NoYWRvd19yZWdbaW5kZXhdLmludF9lblswXSB8PSBtYXNrOwogCXdyaXRlbChtYXNrLCByZWcpOwpAQCAtMjY4LDE0ICsyNjcsMTQgQEAKIAl9CiB9CiAKLXN0YXRpYyBpbnQgbXNtX2lycV9zZXRfd2FrZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgb24pCitzdGF0aWMgaW50IG1zbV9pcnFfc2V0X3dha2Uoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgb24pCiB7Ci0JdW5zaWduZWQgaW5kZXggPSBWSUNfSU5UX1RPX1JFR19JTkRFWChpcnEpOwotCXVpbnQzMl90IG1hc2sgPSAxVUwgPDwgKGlycSAmIDMxKTsKLQlpbnQgc21zbV9pcnEgPSBtc21faXJxX3RvX3Ntc21baXJxXTsKKwl1bnNpZ25lZCBpbmRleCA9IFZJQ19JTlRfVE9fUkVHX0lOREVYKGQtPmlycSk7CisJdWludDMyX3QgbWFzayA9IDFVTCA8PCAoZC0+aXJxICYgMzEpOworCWludCBzbXNtX2lycSA9IG1zbV9pcnFfdG9fc21zbVtkLT5pcnFdOwogCiAJaWYgKHNtc21faXJxID09IDApIHsKLQkJcHJpbnRrKEtFUk5fRVJSICJtc21faXJxX3NldF93YWtlOiBiYWQgd2FrZXVwIGlycSAlZFxuIiwgaXJxKTsKKwkJcHJpbnRrKEtFUk5fRVJSICJtc21faXJxX3NldF93YWtlOiBiYWQgd2FrZXVwIGlycSAlZFxuIiwgZC0+aXJxKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCWlmIChvbikKQEAgLTI5NCwxMiArMjkzLDEyIEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgbXNtX2lycV9zZXRfdHlwZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgZmxvd190eXBlKQorc3RhdGljIGludCBtc21faXJxX3NldF90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IGZsb3dfdHlwZSkKIHsKLQl2b2lkIF9faW9tZW0gKnRyZWcgPSBWSUNfSU5UX1RPX1JFR19BRERSKFZJQ19JTlRfVFlQRTAsIGlycSk7Ci0Jdm9pZCBfX2lvbWVtICpwcmVnID0gVklDX0lOVF9UT19SRUdfQUREUihWSUNfSU5UX1BPTEFSSVRZMCwgaXJxKTsKLQl1bnNpZ25lZCBpbmRleCA9IFZJQ19JTlRfVE9fUkVHX0lOREVYKGlycSk7Ci0JaW50IGIgPSAxIDw8IChpcnEgJiAzMSk7CisJdm9pZCBfX2lvbWVtICp0cmVnID0gVklDX0lOVF9UT19SRUdfQUREUihWSUNfSU5UX1RZUEUwLCBkLT5pcnEpOworCXZvaWQgX19pb21lbSAqcHJlZyA9IFZJQ19JTlRfVE9fUkVHX0FERFIoVklDX0lOVF9QT0xBUklUWTAsIGQtPmlycSk7CisJdW5zaWduZWQgaW5kZXggPSBWSUNfSU5UX1RPX1JFR19JTkRFWChkLT5pcnEpOworCWludCBiID0gMSA8PCAoZC0+aXJxICYgMzEpOwogCXVpbnQzMl90IHBvbGFyaXR5OwogCXVpbnQzMl90IHR5cGU7CiAKQEAgLTMxNCwxMSArMzEzLDExIEBACiAJdHlwZSA9IG1zbV9pcnFfc2hhZG93X3JlZ1tpbmRleF0uaW50X3R5cGU7CiAJaWYgKGZsb3dfdHlwZSAmIChJUlFGX1RSSUdHRVJfUklTSU5HIHwgSVJRRl9UUklHR0VSX0ZBTExJTkcpKSB7CiAJCXR5cGUgfD0gYjsKLQkJaXJxX2Rlc2NbaXJxXS5oYW5kbGVfaXJxID0gaGFuZGxlX2VkZ2VfaXJxOworCQlpcnFfZGVzY1tkLT5pcnFdLmhhbmRsZV9pcnEgPSBoYW5kbGVfZWRnZV9pcnE7CiAJfQogCWlmIChmbG93X3R5cGUgJiAoSVJRRl9UUklHR0VSX0hJR0ggfCBJUlFGX1RSSUdHRVJfTE9XKSkgewogCQl0eXBlICY9IH5iOwotCQlpcnFfZGVzY1tpcnFdLmhhbmRsZV9pcnEgPSBoYW5kbGVfbGV2ZWxfaXJxOworCQlpcnFfZGVzY1tkLT5pcnFdLmhhbmRsZV9pcnEgPSBoYW5kbGVfbGV2ZWxfaXJxOwogCX0KIAl3cml0ZWwodHlwZSwgdHJlZyk7CiAJbXNtX2lycV9zaGFkb3dfcmVnW2luZGV4XS5pbnRfdHlwZSA9IHR5cGU7CkBAIC0zMjYsMTMgKzMyNSwxMyBAQAogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG1zbV9pcnFfY2hpcCA9IHsKLQkubmFtZSAgICAgID0gIm1zbSIsCi0JLmRpc2FibGUgICA9IG1zbV9pcnFfbWFzaywKLQkuYWNrICAgICAgID0gbXNtX2lycV9hY2ssCi0JLm1hc2sgICAgICA9IG1zbV9pcnFfbWFzaywKLQkudW5tYXNrICAgID0gbXNtX2lycV91bm1hc2ssCi0JLnNldF93YWtlICA9IG1zbV9pcnFfc2V0X3dha2UsCi0JLnNldF90eXBlICA9IG1zbV9pcnFfc2V0X3R5cGUsCisJLm5hbWUgICAgICAgICAgPSAibXNtIiwKKwkuaXJxX2Rpc2FibGUgICA9IG1zbV9pcnFfbWFzaywKKwkuaXJxX2FjayAgICAgICA9IG1zbV9pcnFfYWNrLAorCS5pcnFfbWFzayAgICAgID0gbXNtX2lycV9tYXNrLAorCS5pcnFfdW5tYXNrICAgID0gbXNtX2lycV91bm1hc2ssCisJLmlycV9zZXRfd2FrZSAgPSBtc21faXJxX3NldF93YWtlLAorCS5pcnFfc2V0X3R5cGUgID0gbXNtX2lycV9zZXRfdHlwZSwKIH07CiAKIHZvaWQgX19pbml0IG1zbV9pbml0X2lycSh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1tc20vaXJxLmMgYi9hcmNoL2FybS9tYWNoLW1zbS9pcnEuYwppbmRleCA2YzhkNWY4Li4wYjI3ZDg5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW1zbS9pcnEuYworKysgYi9hcmNoL2FybS9tYWNoLW1zbS9pcnEuYwpAQCAtNjQsMzUgKzY0LDM0IEBACiAjZGVmaW5lIFZJQ19WRUNUUFJJT1JJVFkobikgVklDX1JFRygweDAyMDArKChuKSAqIDQpKQogI2RlZmluZSBWSUNfVkVDVEFERFIobikgICAgIFZJQ19SRUcoMHgwNDAwKygobikgKiA0KSkKIAotc3RhdGljIHZvaWQgbXNtX2lycV9hY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1zbV9pcnFfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl2b2lkIF9faW9tZW0gKnJlZyA9IFZJQ19JTlRfQ0xFQVIwICsgKChpcnEgJiAzMikgPyA0IDogMCk7Ci0JaXJxID0gMSA8PCAoaXJxICYgMzEpOwotCXdyaXRlbChpcnEsIHJlZyk7CisJdm9pZCBfX2lvbWVtICpyZWcgPSBWSUNfSU5UX0NMRUFSMCArICgoZC0+aXJxICYgMzIpID8gNCA6IDApOworCXdyaXRlbCgxIDw8IChkLT5pcnEgJiAzMSksIHJlZyk7CiB9CiAKLXN0YXRpYyB2b2lkIG1zbV9pcnFfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbXNtX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl2b2lkIF9faW9tZW0gKnJlZyA9IFZJQ19JTlRfRU5DTEVBUjAgKyAoKGlycSAmIDMyKSA/IDQgOiAwKTsKLQl3cml0ZWwoMSA8PCAoaXJxICYgMzEpLCByZWcpOworCXZvaWQgX19pb21lbSAqcmVnID0gVklDX0lOVF9FTkNMRUFSMCArICgoZC0+aXJxICYgMzIpID8gNCA6IDApOworCXdyaXRlbCgxIDw8IChkLT5pcnEgJiAzMSksIHJlZyk7CiB9CiAKLXN0YXRpYyB2b2lkIG1zbV9pcnFfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBtc21faXJxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jdm9pZCBfX2lvbWVtICpyZWcgPSBWSUNfSU5UX0VOU0VUMCArICgoaXJxICYgMzIpID8gNCA6IDApOwotCXdyaXRlbCgxIDw8IChpcnEgJiAzMSksIHJlZyk7CisJdm9pZCBfX2lvbWVtICpyZWcgPSBWSUNfSU5UX0VOU0VUMCArICgoZC0+aXJxICYgMzIpID8gNCA6IDApOworCXdyaXRlbCgxIDw8IChkLT5pcnEgJiAzMSksIHJlZyk7CiB9CiAKLXN0YXRpYyBpbnQgbXNtX2lycV9zZXRfd2FrZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgb24pCitzdGF0aWMgaW50IG1zbV9pcnFfc2V0X3dha2Uoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgb24pCiB7CiAJcmV0dXJuIC1FSU5WQUw7CiB9CiAKLXN0YXRpYyBpbnQgbXNtX2lycV9zZXRfdHlwZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgZmxvd190eXBlKQorc3RhdGljIGludCBtc21faXJxX3NldF90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IGZsb3dfdHlwZSkKIHsKLQl2b2lkIF9faW9tZW0gKnRyZWcgPSBWSUNfSU5UX1RZUEUwICsgKChpcnEgJiAzMikgPyA0IDogMCk7Ci0Jdm9pZCBfX2lvbWVtICpwcmVnID0gVklDX0lOVF9QT0xBUklUWTAgKyAoKGlycSAmIDMyKSA/IDQgOiAwKTsKLQlpbnQgYiA9IDEgPDwgKGlycSAmIDMxKTsKKwl2b2lkIF9faW9tZW0gKnRyZWcgPSBWSUNfSU5UX1RZUEUwICsgKChkLT5pcnEgJiAzMikgPyA0IDogMCk7CisJdm9pZCBfX2lvbWVtICpwcmVnID0gVklDX0lOVF9QT0xBUklUWTAgKyAoKGQtPmlycSAmIDMyKSA/IDQgOiAwKTsKKwlpbnQgYiA9IDEgPDwgKGQtPmlycSAmIDMxKTsKIAogCWlmIChmbG93X3R5cGUgJiAoSVJRRl9UUklHR0VSX0ZBTExJTkcgfCBJUlFGX1RSSUdHRVJfTE9XKSkKIAkJd3JpdGVsKHJlYWRsKHByZWcpIHwgYiwgcHJlZyk7CkBAIC0xMDEsMjIgKzEwMCwyMiBAQAogCiAJaWYgKGZsb3dfdHlwZSAmIChJUlFGX1RSSUdHRVJfUklTSU5HIHwgSVJRRl9UUklHR0VSX0ZBTExJTkcpKSB7CiAJCXdyaXRlbChyZWFkbCh0cmVnKSB8IGIsIHRyZWcpOwotCQlpcnFfZGVzY1tpcnFdLmhhbmRsZV9pcnEgPSBoYW5kbGVfZWRnZV9pcnE7CisJCWlycV9kZXNjW2QtPmlycV0uaGFuZGxlX2lycSA9IGhhbmRsZV9lZGdlX2lycTsKIAl9CiAJaWYgKGZsb3dfdHlwZSAmIChJUlFGX1RSSUdHRVJfSElHSCB8IElSUUZfVFJJR0dFUl9MT1cpKSB7CiAJCXdyaXRlbChyZWFkbCh0cmVnKSAmICh+YiksIHRyZWcpOwotCQlpcnFfZGVzY1tpcnFdLmhhbmRsZV9pcnEgPSBoYW5kbGVfbGV2ZWxfaXJxOworCQlpcnFfZGVzY1tkLT5pcnFdLmhhbmRsZV9pcnEgPSBoYW5kbGVfbGV2ZWxfaXJxOwogCX0KIAlyZXR1cm4gMDsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBtc21faXJxX2NoaXAgPSB7Ci0JLm5hbWUgICAgICA9ICJtc20iLAotCS5hY2sgICAgICAgPSBtc21faXJxX2FjaywKLQkubWFzayAgICAgID0gbXNtX2lycV9tYXNrLAotCS51bm1hc2sgICAgPSBtc21faXJxX3VubWFzaywKLQkuc2V0X3dha2UgID0gbXNtX2lycV9zZXRfd2FrZSwKLQkuc2V0X3R5cGUgID0gbXNtX2lycV9zZXRfdHlwZSwKKwkubmFtZSAgICAgICAgICA9ICJtc20iLAorCS5pcnFfYWNrICAgICAgID0gbXNtX2lycV9hY2ssCisJLmlycV9tYXNrICAgICAgPSBtc21faXJxX21hc2ssCisJLmlycV91bm1hc2sgICAgPSBtc21faXJxX3VubWFzaywKKwkuaXJxX3NldF93YWtlICA9IG1zbV9pcnFfc2V0X3dha2UsCisJLmlycV9zZXRfdHlwZSAgPSBtc21faXJxX3NldF90eXBlLAogfTsKIAogdm9pZCBfX2luaXQgbXNtX2luaXRfaXJxKHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW1zbS9zaXJjLmMgYi9hcmNoL2FybS9tYWNoLW1zbS9zaXJjLmMKaW5kZXggMTUyZWVmZC4uMTFiNTRjNyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1tc20vc2lyYy5jCisrKyBiL2FyY2gvYXJtL21hY2gtbXNtL3NpcmMuYwpAQCAtNDIsMTIgKzQyLDExIEBACiAKIC8qIE1hc2sgb2ZmIHRoZSBnaXZlbiBpbnRlcnJ1cHQuIEtlZXAgdGhlIGludF9lbmFibGUgbWFzayBpbiBzeW5jIHdpdGgKICAgIHRoZSBlbmFibGUgcmVnLCBzbyBpdCBjYW4gYmUgcmVzdG9yZWQgYWZ0ZXIgcG93ZXIgY29sbGFwc2UuICovCi1zdGF0aWMgdm9pZCBzaXJjX2lycV9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzaXJjX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl1bnNpZ25lZCBpbnQgbWFzazsKIAotCi0JbWFzayA9IDEgPDwgKGlycSAtIEZJUlNUX1NJUkNfSVJRKTsKKwltYXNrID0gMSA8PCAoZC0+aXJxIC0gRklSU1RfU0lSQ19JUlEpOwogCXdyaXRlbChtYXNrLCBzaXJjX3JlZ3MuaW50X2VuYWJsZV9jbGVhcik7CiAJaW50X2VuYWJsZSAmPSB+bWFzazsKIAlyZXR1cm47CkBAIC01NSwzMSArNTQsMzEgQEAKIAogLyogVW5tYXNrIHRoZSBnaXZlbiBpbnRlcnJ1cHQuIEtlZXAgdGhlIGludF9lbmFibGUgbWFzayBpbiBzeW5jIHdpdGgKICAgIHRoZSBlbmFibGUgcmVnLCBzbyBpdCBjYW4gYmUgcmVzdG9yZWQgYWZ0ZXIgcG93ZXIgY29sbGFwc2UuICovCi1zdGF0aWMgdm9pZCBzaXJjX2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHNpcmNfaXJxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdW5zaWduZWQgaW50IG1hc2s7CiAKLQltYXNrID0gMSA8PCAoaXJxIC0gRklSU1RfU0lSQ19JUlEpOworCW1hc2sgPSAxIDw8IChkLT5pcnEgLSBGSVJTVF9TSVJDX0lSUSk7CiAJd3JpdGVsKG1hc2ssIHNpcmNfcmVncy5pbnRfZW5hYmxlX3NldCk7CiAJaW50X2VuYWJsZSB8PSBtYXNrOwogCXJldHVybjsKIH0KIAotc3RhdGljIHZvaWQgc2lyY19pcnFfYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzaXJjX2lycV9hY2soc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGludCBtYXNrOwogCi0JbWFzayA9IDEgPDwgKGlycSAtIEZJUlNUX1NJUkNfSVJRKTsKKwltYXNrID0gMSA8PCAoZC0+aXJxIC0gRklSU1RfU0lSQ19JUlEpOwogCXdyaXRlbChtYXNrLCBzaXJjX3JlZ3MuaW50X2NsZWFyKTsKIAlyZXR1cm47CiB9CiAKLXN0YXRpYyBpbnQgc2lyY19pcnFfc2V0X3dha2UodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IG9uKQorc3RhdGljIGludCBzaXJjX2lycV9zZXRfd2FrZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCBvbikKIHsKIAl1bnNpZ25lZCBpbnQgbWFzazsKIAogCS8qIFVzZWQgdG8gc2V0IHRoZSBpbnRlcnJ1cHQgZW5hYmxlIG1hc2sgZHVyaW5nIHBvd2VyIGNvbGxhcHNlLiAqLwotCW1hc2sgPSAxIDw8IChpcnEgLSBGSVJTVF9TSVJDX0lSUSk7CisJbWFzayA9IDEgPDwgKGQtPmlycSAtIEZJUlNUX1NJUkNfSVJRKTsKIAlpZiAob24pCiAJCXdha2VfZW5hYmxlIHw9IG1hc2s7CiAJZWxzZQpAQCAtODgsMTIgKzg3LDEyIEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgc2lyY19pcnFfc2V0X3R5cGUodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IGZsb3dfdHlwZSkKK3N0YXRpYyBpbnQgc2lyY19pcnFfc2V0X3R5cGUoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgZmxvd190eXBlKQogewogCXVuc2lnbmVkIGludCBtYXNrOwogCXVuc2lnbmVkIGludCB2YWw7CiAKLQltYXNrID0gMSA8PCAoaXJxIC0gRklSU1RfU0lSQ19JUlEpOworCW1hc2sgPSAxIDw8IChkLT5pcnEgLSBGSVJTVF9TSVJDX0lSUSk7CiAJdmFsID0gcmVhZGwoc2lyY19yZWdzLmludF9wb2xhcml0eSk7CiAKIAlpZiAoZmxvd190eXBlICYgKElSUUZfVFJJR0dFUl9MT1cgfCBJUlFGX1RSSUdHRVJfRkFMTElORykpCkBAIC0xMDYsMTAgKzEwNSwxMCBAQAogCXZhbCA9IHJlYWRsKHNpcmNfcmVncy5pbnRfdHlwZSk7CiAJaWYgKGZsb3dfdHlwZSAmIChJUlFGX1RSSUdHRVJfUklTSU5HIHwgSVJRRl9UUklHR0VSX0ZBTExJTkcpKSB7CiAJCXZhbCB8PSBtYXNrOwotCQlpcnFfZGVzY1tpcnFdLmhhbmRsZV9pcnEgPSBoYW5kbGVfZWRnZV9pcnE7CisJCWlycV9kZXNjW2QtPmlycV0uaGFuZGxlX2lycSA9IGhhbmRsZV9lZGdlX2lycTsKIAl9IGVsc2UgewogCQl2YWwgJj0gfm1hc2s7Ci0JCWlycV9kZXNjW2lycV0uaGFuZGxlX2lycSA9IGhhbmRsZV9sZXZlbF9pcnE7CisJCWlycV9kZXNjW2QtPmlycV0uaGFuZGxlX2lycSA9IGhhbmRsZV9sZXZlbF9pcnE7CiAJfQogCiAJd3JpdGVsKHZhbCwgc2lyY19yZWdzLmludF90eXBlKTsKQEAgLTEzOSwxNiArMTM4LDE2IEBACiAJCTsKIAlnZW5lcmljX2hhbmRsZV9pcnEoc2lycStGSVJTVF9TSVJDX0lSUSk7CiAKLQlkZXNjLT5jaGlwLT5hY2soaXJxKTsKKwlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfYWNrKCZkZXNjLT5pcnFfZGF0YSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgc2lyY19pcnFfY2hpcCA9IHsKLQkubmFtZSAgICAgID0gInNpcmMiLAotCS5hY2sgICAgICAgPSBzaXJjX2lycV9hY2ssCi0JLm1hc2sgICAgICA9IHNpcmNfaXJxX21hc2ssCi0JLnVubWFzayAgICA9IHNpcmNfaXJxX3VubWFzaywKLQkuc2V0X3dha2UgID0gc2lyY19pcnFfc2V0X3dha2UsCi0JLnNldF90eXBlICA9IHNpcmNfaXJxX3NldF90eXBlLAorCS5uYW1lICAgICAgICAgID0gInNpcmMiLAorCS5pcnFfYWNrICAgICAgID0gc2lyY19pcnFfYWNrLAorCS5pcnFfbWFzayAgICAgID0gc2lyY19pcnFfbWFzaywKKwkuaXJxX3VubWFzayAgICA9IHNpcmNfaXJxX3VubWFzaywKKwkuaXJxX3NldF93YWtlICA9IHNpcmNfaXJxX3NldF93YWtlLAorCS5pcnFfc2V0X3R5cGUgID0gc2lyY19pcnFfc2V0X3R5cGUsCiB9OwogCiB2b2lkIF9faW5pdCBtc21faW5pdF9zaXJjKHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW14My9tYWNoLW14MzFfM2RzLmMgYi9hcmNoL2FybS9tYWNoLW14My9tYWNoLW14MzFfM2RzLmMKaW5kZXggODk5YTk2OS4uMGQ2NWRiOCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1teDMvbWFjaC1teDMxXzNkcy5jCisrKyBiL2FyY2gvYXJtL21hY2gtbXgzL21hY2gtbXgzMV8zZHMuYwpAQCAtMTQ3LDEwICsxNDcsMTAgQEAKIAkJLmluaXRfZGF0YSA9ICZwd2d0eF9pbml0LAogCX0sIHsKIAotCQkuaWQgPSBNQzEzNzgzX1JFR1VfR1BPMSwgLyogVHVybiBvbiAxLjhWICovCisJCS5pZCA9IE1DMTM3ODNfUkVHX0dQTzEsIC8qIFR1cm4gb24gMS44ViAqLwogCQkuaW5pdF9kYXRhID0gJmdwb19pbml0LAogCX0sIHsKLQkJLmlkID0gTUMxMzc4M19SRUdVX0dQTzMsIC8qIFR1cm4gb24gMy4zViAqLworCQkuaWQgPSBNQzEzNzgzX1JFR19HUE8zLCAvKiBUdXJuIG9uIDMuM1YgKi8KIAkJLmluaXRfZGF0YSA9ICZncG9faW5pdCwKIAl9LAogfTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbXgzL21hY2gtbXgzMWFkcy5jIGIvYXJjaC9hcm0vbWFjaC1teDMvbWFjaC1teDMxYWRzLmMKaW5kZXggYjk5M2I5Yi4uODhiOTdkNiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1teDMvbWFjaC1teDMxYWRzLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1teDMvbWFjaC1teDMxYWRzLmMKQEAgLTE2Miw5ICsxNjIsOSBAQAogICogRGlzYWJsZSBhbiBleHBpbyBwaW4ncyBpbnRlcnJ1cHQgYnkgc2V0dGluZyB0aGUgYml0IGluIHRoZSBpbXIuCiAgKiBAcGFyYW0gaXJxICAgICAgICAgICBhbiBleHBpbyB2aXJ0dWFsIGlycSBudW1iZXIKICAqLwotc3RhdGljIHZvaWQgZXhwaW9fbWFza19pcnEodTMyIGlycSkKK3N0YXRpYyB2b2lkIGV4cGlvX21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl1MzIgZXhwaW8gPSBNWENfSVJRX1RPX0VYUElPKGlycSk7CisJdTMyIGV4cGlvID0gTVhDX0lSUV9UT19FWFBJTyhkLT5pcnEpOwogCS8qIG1hc2sgdGhlIGludGVycnVwdCAqLwogCV9fcmF3X3dyaXRldygxIDw8IGV4cGlvLCBQQkNfSU5UTUFTS19DTEVBUl9SRUcpOwogCV9fcmF3X3JlYWR3KFBCQ19JTlRNQVNLX0NMRUFSX1JFRyk7CkBAIC0xNzQsOSArMTc0LDkgQEAKICAqIEFja25vd2xlZGdlIGFuIGV4cGFuZGVkIGlvIHBpbidzIGludGVycnVwdCBieSBjbGVhcmluZyB0aGUgYml0IGluIHRoZSBpc3IuCiAgKiBAcGFyYW0gaXJxICAgICAgICAgICBhbiBleHBhbmRlZCBpbyB2aXJ0dWFsIGlycSBudW1iZXIKICAqLwotc3RhdGljIHZvaWQgZXhwaW9fYWNrX2lycSh1MzIgaXJxKQorc3RhdGljIHZvaWQgZXhwaW9fYWNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JdTMyIGV4cGlvID0gTVhDX0lSUV9UT19FWFBJTyhpcnEpOworCXUzMiBleHBpbyA9IE1YQ19JUlFfVE9fRVhQSU8oZC0+aXJxKTsKIAkvKiBjbGVhciB0aGUgaW50ZXJydXB0IHN0YXR1cyAqLwogCV9fcmF3X3dyaXRldygxIDw8IGV4cGlvLCBQQkNfSU5UU1RBVFVTX1JFRyk7CiB9CkBAIC0xODUsMTggKzE4NSwxOCBAQAogICogRW5hYmxlIGEgZXhwaW8gcGluJ3MgaW50ZXJydXB0IGJ5IGNsZWFyaW5nIHRoZSBiaXQgaW4gdGhlIGltci4KICAqIEBwYXJhbSBpcnEgICAgICAgICAgIGEgZXhwaW8gdmlydHVhbCBpcnEgbnVtYmVyCiAgKi8KLXN0YXRpYyB2b2lkIGV4cGlvX3VubWFza19pcnEodTMyIGlycSkKK3N0YXRpYyB2b2lkIGV4cGlvX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXUzMiBleHBpbyA9IE1YQ19JUlFfVE9fRVhQSU8oaXJxKTsKKwl1MzIgZXhwaW8gPSBNWENfSVJRX1RPX0VYUElPKGQtPmlycSk7CiAJLyogdW5tYXNrIHRoZSBpbnRlcnJ1cHQgKi8KIAlfX3Jhd193cml0ZXcoMSA8PCBleHBpbywgUEJDX0lOVE1BU0tfU0VUX1JFRyk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgZXhwaW9faXJxX2NoaXAgPSB7CiAJLm5hbWUgPSAiRVhQSU8oQ1BMRCkiLAotCS5hY2sgPSBleHBpb19hY2tfaXJxLAotCS5tYXNrID0gZXhwaW9fbWFza19pcnEsCi0JLnVubWFzayA9IGV4cGlvX3VubWFza19pcnEsCisJLmlycV9hY2sgPSBleHBpb19hY2tfaXJxLAorCS5pcnFfbWFzayA9IGV4cGlvX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrID0gZXhwaW9fdW5tYXNrX2lycSwKIH07CiAKIHN0YXRpYyB2b2lkIF9faW5pdCBteDMxYWRzX2luaXRfZXhwaW8odm9pZCkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbXg1L0tjb25maWcgYi9hcmNoL2FybS9tYWNoLW14NS9LY29uZmlnCmluZGV4IDU1MjU0YjYuLmRlNGZhOTkyZiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1teDUvS2NvbmZpZworKysgYi9hcmNoL2FybS9tYWNoLW14NS9LY29uZmlnCkBAIC01MCw2ICs1MCw3IEBACiBjb25maWcgTUFDSF9NWDUxXzNEUwogCWJvb2wgIlN1cHBvcnQgTVg1MVBESyAoM0RTKSIKIAlzZWxlY3QgU09DX0lNWDUxCisJc2VsZWN0IElNWF9IQVZFX1BMQVRGT1JNX0lNWF9LRVlQQUQKIAlzZWxlY3QgSU1YX0hBVkVfUExBVEZPUk1fSU1YX1VBUlQKIAlzZWxlY3QgSU1YX0hBVkVfUExBVEZPUk1fU0RIQ0lfRVNESENfSU1YCiAJc2VsZWN0IElNWF9IQVZFX1BMQVRGT1JNX1NQSV9JTVgKQEAgLTc3LDYgKzc4LDcgQEAKIGNvbmZpZyBNQUNIX0VVS1JFQV9NQklNWDUxX0JBU0VCT0FSRAogCXByb21wdCAiRXVrcmVhIE1CSU1YNTEgZGV2ZWxvcG1lbnQgYm9hcmQiCiAJYm9vbAorCXNlbGVjdCBJTVhfSEFWRV9QTEFURk9STV9JTVhfS0VZUEFECiAJc2VsZWN0IElNWF9IQVZFX1BMQVRGT1JNX1NESENJX0VTREhDX0lNWAogCWhlbHAKIAkgIFRoaXMgYWRkcyBib2FyZCBzcGVjaWZpYyBkZXZpY2VzIHRoYXQgY2FuIGJlIGZvdW5kIG9uIEV1a3JlYSdzCkBAIC0xMjQsMTAgKzEyNiwyOCBAQAogCWJvb2wgIlN1cHBvcnQgTVg1MyBFVksgcGxhdGZvcm1zIgogCXNlbGVjdCBTT0NfSU1YNTMKIAlzZWxlY3QgSU1YX0hBVkVfUExBVEZPUk1fSU1YX1VBUlQKKwlzZWxlY3QgSU1YX0hBVkVfUExBVEZPUk1fSU1YX0kyQworCXNlbGVjdCBJTVhfSEFWRV9QTEFURk9STV9TREhDSV9FU0RIQ19JTVgKKwlzZWxlY3QgSU1YX0hBVkVfUExBVEZPUk1fU1BJX0lNWAogCWhlbHAKIAkgIEluY2x1ZGUgc3VwcG9ydCBmb3IgTVg1MyBFVksgcGxhdGZvcm0uIFRoaXMgaW5jbHVkZXMgc3BlY2lmaWMKIAkgIGNvbmZpZ3VyYXRpb25zIGZvciB0aGUgYm9hcmQgYW5kIGl0cyBwZXJpcGhlcmFscy4KIAorY29uZmlnIE1BQ0hfTVg1M19TTUQKKwlib29sICJTdXBwb3J0IE1YNTMgU01EIHBsYXRmb3JtcyIKKwlzZWxlY3QgU09DX0lNWDUzCisJc2VsZWN0IElNWF9IQVZFX1BMQVRGT1JNX0lNWF9VQVJUCisJaGVscAorCSAgSW5jbHVkZSBzdXBwb3J0IGZvciBNWDUzIFNNRCBwbGF0Zm9ybS4gVGhpcyBpbmNsdWRlcyBzcGVjaWZpYworCSAgY29uZmlndXJhdGlvbnMgZm9yIHRoZSBib2FyZCBhbmQgaXRzIHBlcmlwaGVyYWxzLgorCitjb25maWcgTUFDSF9NWDUzX0xPQ08KKwlib29sICJTdXBwb3J0IE1YNTMgTE9DTyBwbGF0Zm9ybXMiCisJc2VsZWN0IFNPQ19JTVg1MworCXNlbGVjdCBJTVhfSEFWRV9QTEFURk9STV9JTVhfVUFSVAorCWhlbHAKKwkgIEluY2x1ZGUgc3VwcG9ydCBmb3IgTVg1MyBMT0NPIHBsYXRmb3JtLiBUaGlzIGluY2x1ZGVzIHNwZWNpZmljCisJICBjb25maWd1cmF0aW9ucyBmb3IgdGhlIGJvYXJkIGFuZCBpdHMgcGVyaXBoZXJhbHMuCiAKIGNvbmZpZyBNQUNIX01YNTBfUkRQCiAJYm9vbCAiU3VwcG9ydCBNWDUwIHJlZmVyZW5jZSBkZXNpZ24gcGxhdGZvcm0iCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW14NS9NYWtlZmlsZSBiL2FyY2gvYXJtL21hY2gtbXg1L01ha2VmaWxlCmluZGV4IDBjMzk4YmEuLjBkNDNiZTkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbXg1L01ha2VmaWxlCisrKyBiL2FyY2gvYXJtL21hY2gtbXg1L01ha2VmaWxlCkBAIC0xMCw2ICsxMCw4IEBACiBvYmotJChDT05GSUdfTUFDSF9NWDUxX0JBQkJBR0UpICs9IGJvYXJkLW14NTFfYmFiYmFnZS5vCiBvYmotJChDT05GSUdfTUFDSF9NWDUxXzNEUykgKz0gYm9hcmQtbXg1MV8zZHMubwogb2JqLSQoQ09ORklHX01BQ0hfTVg1M19FVkspICs9IGJvYXJkLW14NTNfZXZrLm8KK29iai0kKENPTkZJR19NQUNIX01YNTNfU01EKSArPSBib2FyZC1teDUzX3NtZC5vCitvYmotJChDT05GSUdfTUFDSF9NWDUzX0xPQ08pICs9IGJvYXJkLW14NTNfbG9jby5vCiBvYmotJChDT05GSUdfTUFDSF9FVUtSRUFfQ1BVSU1YNTEpICs9IGJvYXJkLWNwdWlteDUxLm8KIG9iai0kKENPTkZJR19NQUNIX0VVS1JFQV9NQklNWDUxX0JBU0VCT0FSRCkgKz0gZXVrcmVhX21iaW14NTEtYmFzZWJvYXJkLm8KIG9iai0kKENPTkZJR19NQUNIX0VVS1JFQV9DUFVJTVg1MVNEKSArPSBib2FyZC1jcHVpbXg1MXNkLm8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbXg1L2JvYXJkLW14NTFfM2RzLmMgYi9hcmNoL2FybS9tYWNoLW14NS9ib2FyZC1teDUxXzNkcy5jCmluZGV4IGU0MmJkMmUuLjQ5ZDY0NDggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbXg1L2JvYXJkLW14NTFfM2RzLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1teDUvYm9hcmQtbXg1MV8zZHMuYwpAQCAtMTIsNyArMTIsNiBAQAogCiAjaW5jbHVkZSA8bGludXgvaXJxLmg+CiAjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+Ci0jaW5jbHVkZSA8bGludXgvaW5wdXQvbWF0cml4X2tleXBhZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaS9zcGkuaD4KIAogI2luY2x1ZGUgPGFzbS9tYWNoLXR5cGVzLmg+CkBAIC0xMjAsMTQgKzExOSwxNCBAQAogCUtFWSgzLCA1LCBLRVlfQkFDSykKIH07CiAKLXN0YXRpYyBzdHJ1Y3QgbWF0cml4X2tleW1hcF9kYXRhIG14NTFfM2RzX21hcF9kYXRhID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBtYXRyaXhfa2V5bWFwX2RhdGEgbXg1MV8zZHNfbWFwX2RhdGEgX19pbml0Y29uc3QgPSB7CiAJLmtleW1hcAkJPSBteDUxXzNkc19ib2FyZF9rZXltYXAsCiAJLmtleW1hcF9zaXplCT0gQVJSQVlfU0laRShteDUxXzNkc19ib2FyZF9rZXltYXApLAogfTsKIAogc3RhdGljIHZvaWQgbXhjX2luaXRfa2V5cGFkKHZvaWQpCiB7Ci0JbXhjX3JlZ2lzdGVyX2RldmljZSgmbXhjX2tleXBhZF9kZXZpY2UsICZteDUxXzNkc19tYXBfZGF0YSk7CisJaW14NTFfYWRkX2lteF9rZXlwYWQoJm14NTFfM2RzX21hcF9kYXRhKTsKIH0KICNlbHNlCiBzdGF0aWMgaW5saW5lIHZvaWQgbXhjX2luaXRfa2V5cGFkKHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW14NS9ib2FyZC1teDUzX2V2ay5jIGIvYXJjaC9hcm0vbWFjaC1teDUvYm9hcmQtbXg1M19ldmsuYwppbmRleCBmYTk3ZDBkLi5jYWVlMDRjIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW14NS9ib2FyZC1teDUzX2V2ay5jCisrKyBiL2FyY2gvYXJtL21hY2gtbXg1L2JvYXJkLW14NTNfZXZrLmMKQEAgLTIxLDYgKzIxLDExIEBACiAKICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiAjaW5jbHVkZSA8bGludXgvY2xrLmg+CisjaW5jbHVkZSA8bGludXgvZmVjLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9ncGlvLmg+CisjaW5jbHVkZSA8bGludXgvc3BpL2ZsYXNoLmg+CisjaW5jbHVkZSA8bGludXgvc3BpL3NwaS5oPgogI2luY2x1ZGUgPG1hY2gvY29tbW9uLmg+CiAjaW5jbHVkZSA8bWFjaC9oYXJkd2FyZS5oPgogI2luY2x1ZGUgPGFzbS9tYWNoLXR5cGVzLmg+CkBAIC0yOSw2ICszNCwxMCBAQAogI2luY2x1ZGUgPG1hY2gvaW14LXVhcnQuaD4KICNpbmNsdWRlIDxtYWNoL2lvbXV4LW14NTMuaD4KIAorI2RlZmluZSBTTURfRkVDX1BIWV9SU1QJCUlNWF9HUElPX05SKDcsIDYpCisjZGVmaW5lIEVWS19FQ1NQSTFfQ1MwCQlJTVhfR1BJT19OUigyLCAzMCkKKyNkZWZpbmUgRVZLX0VDU1BJMV9DUzEJCUlNWF9HUElPX05SKDMsIDE5KQorCiAjaW5jbHVkZSAiY3JtX3JlZ3MuaCIKICNpbmNsdWRlICJkZXZpY2VzLWlteDUzLmgiCiAKQEAgLTQ3LDYgKzU2LDE0IEBACiAJTVg1M19QQURfQVRBX0NTXzFfX1VBUlQzX1JYRCwKIAlNWDUzX1BBRF9BVEFfREFfMV9fVUFSVDNfQ1RTLAogCU1YNTNfUEFEX0FUQV9EQV8yX19VQVJUM19SVFMsCisKKwlNWDUzX1BBRF9FSU1fRDE2X19DU1BJMV9TQ0xLLAorCU1YNTNfUEFEX0VJTV9EMTdfX0NTUEkxX01JU08sCisJTVg1M19QQURfRUlNX0QxOF9fQ1NQSTFfTU9TSSwKKworCS8qIGVjc3BpIGNoaXAgc2VsZWN0IGxpbmVzICovCisJTVg1M19QQURfRUlNX0VCMl9fR1BJT18yXzMwLAorCU1YNTNfUEFEX0VJTV9EMTlfX0dQSU9fM18xOSwKIH07CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgaW14dWFydF9wbGF0Zm9ybV9kYXRhIG14NTNfZXZrX3VhcnRfcGRhdGEgX19pbml0Y29uc3QgPSB7CkBAIC02MCwxMSArNzcsNjggQEAKIAlpbXg1M19hZGRfaW14X3VhcnQoMiwgJm14NTNfZXZrX3VhcnRfcGRhdGEpOwogfQogCitzdGF0aWMgY29uc3Qgc3RydWN0IGlteGkyY19wbGF0Zm9ybV9kYXRhIG14NTNfZXZrX2kyY19kYXRhIF9faW5pdGNvbnN0ID0geworCS5iaXRyYXRlID0gMTAwMDAwLAorfTsKKworc3RhdGljIGlubGluZSB2b2lkIG14NTNfZXZrX2ZlY19yZXNldCh2b2lkKQoreworCWludCByZXQ7CisKKwkvKiByZXNldCBGRUMgUEhZICovCisJcmV0ID0gZ3Bpb19yZXF1ZXN0KFNNRF9GRUNfUEhZX1JTVCwgImZlYy1waHktcmVzZXQiKTsKKwlpZiAocmV0KSB7CisJCXByaW50ayhLRVJOX0VSUiJmYWlsZWQgdG8gZ2V0IEdQSU9fRkVDX1BIWV9SRVNFVDogJWRcbiIsIHJldCk7CisJCXJldHVybjsKKwl9CisJZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KFNNRF9GRUNfUEhZX1JTVCwgMCk7CisJZ3Bpb19zZXRfdmFsdWUoU01EX0ZFQ19QSFlfUlNULCAwKTsKKwltc2xlZXAoMSk7CisJZ3Bpb19zZXRfdmFsdWUoU01EX0ZFQ19QSFlfUlNULCAxKTsKK30KKworc3RhdGljIHN0cnVjdCBmZWNfcGxhdGZvcm1fZGF0YSBteDUzX2V2a19mZWNfcGRhdGEgPSB7CisJLnBoeSA9IFBIWV9JTlRFUkZBQ0VfTU9ERV9STUlJLAorfTsKKworc3RhdGljIHN0cnVjdCBzcGlfYm9hcmRfaW5mbyBteDUzX2V2a19zcGlfYm9hcmRfaW5mb1tdIF9faW5pdGRhdGEgPSB7CisJeworCQkubW9kYWxpYXMgPSAibXRkX2RhdGFmbGFzaCIsCisJCS5tYXhfc3BlZWRfaHogPSAyNTAwMDAwMCwKKwkJLmJ1c19udW0gPSAwLAorCQkuY2hpcF9zZWxlY3QgPSAxLAorCQkubW9kZSA9IFNQSV9NT0RFXzAsCisJCS5wbGF0Zm9ybV9kYXRhID0gTlVMTCwKKwl9LAorfTsKKworc3RhdGljIGludCBteDUzX2V2a19zcGlfY3NbXSA9IHsKKwlFVktfRUNTUEkxX0NTMCwKKwlFVktfRUNTUEkxX0NTMSwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc3BpX2lteF9tYXN0ZXIgbXg1M19ldmtfc3BpX2RhdGEgX19pbml0Y29uc3QgPSB7CisJLmNoaXBzZWxlY3QgICAgID0gbXg1M19ldmtfc3BpX2NzLAorCS5udW1fY2hpcHNlbGVjdCA9IEFSUkFZX1NJWkUobXg1M19ldmtfc3BpX2NzKSwKK307CisKIHN0YXRpYyB2b2lkIF9faW5pdCBteDUzX2V2a19ib2FyZF9pbml0KHZvaWQpCiB7CiAJbXhjX2lvbXV4X3YzX3NldHVwX211bHRpcGxlX3BhZHMobXg1M19ldmtfcGFkcywKIAkJCQkJQVJSQVlfU0laRShteDUzX2V2a19wYWRzKSk7CiAJbXg1M19ldmtfaW5pdF91YXJ0KCk7CisJbXg1M19ldmtfZmVjX3Jlc2V0KCk7CisJaW14NTNfYWRkX2ZlYygmbXg1M19ldmtfZmVjX3BkYXRhKTsKKworCWlteDUzX2FkZF9pbXhfaTJjKDAsICZteDUzX2V2a19pMmNfZGF0YSk7CisJaW14NTNfYWRkX2lteF9pMmMoMSwgJm14NTNfZXZrX2kyY19kYXRhKTsKKworCWlteDUzX2FkZF9zZGhjaV9lc2RoY19pbXgoMCwgTlVMTCk7CisJaW14NTNfYWRkX3NkaGNpX2VzZGhjX2lteCgxLCBOVUxMKTsKKworCXNwaV9yZWdpc3Rlcl9ib2FyZF9pbmZvKG14NTNfZXZrX3NwaV9ib2FyZF9pbmZvLAorCQlBUlJBWV9TSVpFKG14NTNfZXZrX3NwaV9ib2FyZF9pbmZvKSk7CisJaW14NTNfYWRkX2Vjc3BpKDAsICZteDUzX2V2a19zcGlfZGF0YSk7CiB9CiAKIHN0YXRpYyB2b2lkIF9faW5pdCBteDUzX2V2a190aW1lcl9pbml0KHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW14NS9ib2FyZC1teDUzX2xvY28uYyBiL2FyY2gvYXJtL21hY2gtbXg1L2JvYXJkLW14NTNfbG9jby5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQxMzQ4ZTAKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL2FybS9tYWNoLW14NS9ib2FyZC1teDUzX2xvY28uYwpAQCAtMCwwICsxLDExMSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBGcmVlc2NhbGUgU2VtaWNvbmR1Y3RvciwgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICovCisKKy8qCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCisgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhbG9uZworICogd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKKyAqIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EuCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9jbGsuaD4KKyNpbmNsdWRlIDxsaW51eC9mZWMuaD4KKyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L2dwaW8uaD4KKworI2luY2x1ZGUgPG1hY2gvY29tbW9uLmg+CisjaW5jbHVkZSA8bWFjaC9oYXJkd2FyZS5oPgorI2luY2x1ZGUgPG1hY2gvaW14LXVhcnQuaD4KKyNpbmNsdWRlIDxtYWNoL2lvbXV4LW14NTMuaD4KKworI2luY2x1ZGUgPGFzbS9tYWNoLXR5cGVzLmg+CisjaW5jbHVkZSA8YXNtL21hY2gvYXJjaC5oPgorI2luY2x1ZGUgPGFzbS9tYWNoL3RpbWUuaD4KKworI2luY2x1ZGUgImNybV9yZWdzLmgiCisjaW5jbHVkZSAiZGV2aWNlcy1pbXg1My5oIgorCisjZGVmaW5lIExPQ09fRkVDX1BIWV9SU1QJCUlNWF9HUElPX05SKDcsIDYpCisKK3N0YXRpYyBpb211eF92M19jZmdfdCBteDUzX2xvY29fcGFkc1tdID0geworCU1YNTNfUEFEX0NTSTBfRDEwX19VQVJUMV9UWEQsCisJTVg1M19QQURfQ1NJMF9EMTFfX1VBUlQxX1JYRCwKKwlNWDUzX1BBRF9BVEFfRElPV19fVUFSVDFfVFhELAorCU1YNTNfUEFEX0FUQV9ETUFDS19fVUFSVDFfUlhELAorCisJTVg1M19QQURfQVRBX0JVRkZFUl9FTl9fVUFSVDJfUlhELAorCU1YNTNfUEFEX0FUQV9ETUFSUV9fVUFSVDJfVFhELAorCU1YNTNfUEFEX0FUQV9ESU9SX19VQVJUMl9SVFMsCisJTVg1M19QQURfQVRBX0lOVFJRX19VQVJUMl9DVFMsCisKKwlNWDUzX1BBRF9BVEFfQ1NfMF9fVUFSVDNfVFhELAorCU1YNTNfUEFEX0FUQV9DU18xX19VQVJUM19SWEQsCisJTVg1M19QQURfQVRBX0RBXzFfX1VBUlQzX0NUUywKKwlNWDUzX1BBRF9BVEFfREFfMl9fVUFSVDNfUlRTLAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBpbXh1YXJ0X3BsYXRmb3JtX2RhdGEgbXg1M19sb2NvX3VhcnRfZGF0YSBfX2luaXRjb25zdCA9IHsKKwkuZmxhZ3MgPSBJTVhVQVJUX0hBVkVfUlRTQ1RTLAorfTsKKworc3RhdGljIGlubGluZSB2b2lkIG14NTNfbG9jb19pbml0X3VhcnQodm9pZCkKK3sKKwlpbXg1M19hZGRfaW14X3VhcnQoMCwgJm14NTNfbG9jb191YXJ0X2RhdGEpOworCWlteDUzX2FkZF9pbXhfdWFydCgxLCAmbXg1M19sb2NvX3VhcnRfZGF0YSk7CisJaW14NTNfYWRkX2lteF91YXJ0KDIsICZteDUzX2xvY29fdWFydF9kYXRhKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIG14NTNfbG9jb19mZWNfcmVzZXQodm9pZCkKK3sKKwlpbnQgcmV0OworCisJLyogcmVzZXQgRkVDIFBIWSAqLworCXJldCA9IGdwaW9fcmVxdWVzdChMT0NPX0ZFQ19QSFlfUlNULCAiZmVjLXBoeS1yZXNldCIpOworCWlmIChyZXQpIHsKKwkJcHJpbnRrKEtFUk5fRVJSImZhaWxlZCB0byBnZXQgR1BJT19GRUNfUEhZX1JFU0VUOiAlZFxuIiwgcmV0KTsKKwkJcmV0dXJuOworCX0KKwlncGlvX2RpcmVjdGlvbl9vdXRwdXQoTE9DT19GRUNfUEhZX1JTVCwgMCk7CisJbXNsZWVwKDEpOworCWdwaW9fc2V0X3ZhbHVlKExPQ09fRkVDX1BIWV9SU1QsIDEpOworfQorCitzdGF0aWMgc3RydWN0IGZlY19wbGF0Zm9ybV9kYXRhIG14NTNfbG9jb19mZWNfZGF0YSA9IHsKKwkucGh5ID0gUEhZX0lOVEVSRkFDRV9NT0RFX1JNSUksCit9OworCitzdGF0aWMgdm9pZCBfX2luaXQgbXg1M19sb2NvX2JvYXJkX2luaXQodm9pZCkKK3sKKwlteGNfaW9tdXhfdjNfc2V0dXBfbXVsdGlwbGVfcGFkcyhteDUzX2xvY29fcGFkcywKKwkJCQkJQVJSQVlfU0laRShteDUzX2xvY29fcGFkcykpOworCW14NTNfbG9jb19pbml0X3VhcnQoKTsKKwlteDUzX2xvY29fZmVjX3Jlc2V0KCk7CisJaW14NTNfYWRkX2ZlYygmbXg1M19sb2NvX2ZlY19kYXRhKTsKK30KKworc3RhdGljIHZvaWQgX19pbml0IG14NTNfbG9jb190aW1lcl9pbml0KHZvaWQpCit7CisJbXg1M19jbG9ja3NfaW5pdCgzMjc2OCwgMjQwMDAwMDAsIDAsIDApOworfQorCitzdGF0aWMgc3RydWN0IHN5c190aW1lciBteDUzX2xvY29fdGltZXIgPSB7CisJLmluaXQJPSBteDUzX2xvY29fdGltZXJfaW5pdCwKK307CisKK01BQ0hJTkVfU1RBUlQoTVg1M19MT0NPLCAiRnJlZXNjYWxlIE1YNTMgTE9DTyBCb2FyZCIpCisJLm1hcF9pbyA9IG14NTNfbWFwX2lvLAorCS5pbml0X2lycSA9IG14NTNfaW5pdF9pcnEsCisJLmluaXRfbWFjaGluZSA9IG14NTNfbG9jb19ib2FyZF9pbml0LAorCS50aW1lciA9ICZteDUzX2xvY29fdGltZXIsCitNQUNISU5FX0VORApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1teDUvYm9hcmQtbXg1M19zbWQuYyBiL2FyY2gvYXJtL21hY2gtbXg1L2JvYXJkLW14NTNfc21kLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzk3MGY3YQotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvYXJtL21hY2gtbXg1L2JvYXJkLW14NTNfc21kLmMKQEAgLTAsMCArMSwxMTEgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgRnJlZXNjYWxlIFNlbWljb25kdWN0b3IsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKyAqLworCisvKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKworICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYWxvbmcKKyAqIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCisgKiA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBLgorICovCisKKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvY2xrLmg+CisjaW5jbHVkZSA8bGludXgvZmVjLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9ncGlvLmg+CisKKyNpbmNsdWRlIDxtYWNoL2NvbW1vbi5oPgorI2luY2x1ZGUgPG1hY2gvaGFyZHdhcmUuaD4KKyNpbmNsdWRlIDxtYWNoL2lteC11YXJ0Lmg+CisjaW5jbHVkZSA8bWFjaC9pb211eC1teDUzLmg+CisKKyNpbmNsdWRlIDxhc20vbWFjaC10eXBlcy5oPgorI2luY2x1ZGUgPGFzbS9tYWNoL2FyY2guaD4KKyNpbmNsdWRlIDxhc20vbWFjaC90aW1lLmg+CisKKyNpbmNsdWRlICJjcm1fcmVncy5oIgorI2luY2x1ZGUgImRldmljZXMtaW14NTMuaCIKKworI2RlZmluZSBTTURfRkVDX1BIWV9SU1QJCUlNWF9HUElPX05SKDcsIDYpCisKK3N0YXRpYyBpb211eF92M19jZmdfdCBteDUzX3NtZF9wYWRzW10gPSB7CisJTVg1M19QQURfQ1NJMF9EMTBfX1VBUlQxX1RYRCwKKwlNWDUzX1BBRF9DU0kwX0QxMV9fVUFSVDFfUlhELAorCU1YNTNfUEFEX0FUQV9ESU9XX19VQVJUMV9UWEQsCisJTVg1M19QQURfQVRBX0RNQUNLX19VQVJUMV9SWEQsCisKKwlNWDUzX1BBRF9BVEFfQlVGRkVSX0VOX19VQVJUMl9SWEQsCisJTVg1M19QQURfQVRBX0RNQVJRX19VQVJUMl9UWEQsCisJTVg1M19QQURfQVRBX0RJT1JfX1VBUlQyX1JUUywKKwlNWDUzX1BBRF9BVEFfSU5UUlFfX1VBUlQyX0NUUywKKworCU1YNTNfUEFEX0FUQV9DU18wX19VQVJUM19UWEQsCisJTVg1M19QQURfQVRBX0NTXzFfX1VBUlQzX1JYRCwKKwlNWDUzX1BBRF9BVEFfREFfMV9fVUFSVDNfQ1RTLAorCU1YNTNfUEFEX0FUQV9EQV8yX19VQVJUM19SVFMsCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGlteHVhcnRfcGxhdGZvcm1fZGF0YSBteDUzX3NtZF91YXJ0X2RhdGEgX19pbml0Y29uc3QgPSB7CisJLmZsYWdzID0gSU1YVUFSVF9IQVZFX1JUU0NUUywKK307CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBteDUzX3NtZF9pbml0X3VhcnQodm9pZCkKK3sKKwlpbXg1M19hZGRfaW14X3VhcnQoMCwgJm14NTNfc21kX3VhcnRfZGF0YSk7CisJaW14NTNfYWRkX2lteF91YXJ0KDEsICZteDUzX3NtZF91YXJ0X2RhdGEpOworCWlteDUzX2FkZF9pbXhfdWFydCgyLCAmbXg1M19zbWRfdWFydF9kYXRhKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIG14NTNfc21kX2ZlY19yZXNldCh2b2lkKQoreworCWludCByZXQ7CisKKwkvKiByZXNldCBGRUMgUEhZICovCisJcmV0ID0gZ3Bpb19yZXF1ZXN0KFNNRF9GRUNfUEhZX1JTVCwgImZlYy1waHktcmVzZXQiKTsKKwlpZiAocmV0KSB7CisJCXByaW50ayhLRVJOX0VSUiJmYWlsZWQgdG8gZ2V0IEdQSU9fRkVDX1BIWV9SRVNFVDogJWRcbiIsIHJldCk7CisJCXJldHVybjsKKwl9CisJZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KFNNRF9GRUNfUEhZX1JTVCwgMCk7CisJbXNsZWVwKDEpOworCWdwaW9fc2V0X3ZhbHVlKFNNRF9GRUNfUEhZX1JTVCwgMSk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgZmVjX3BsYXRmb3JtX2RhdGEgbXg1M19zbWRfZmVjX2RhdGEgPSB7CisJLnBoeSA9IFBIWV9JTlRFUkZBQ0VfTU9ERV9STUlJLAorfTsKKworc3RhdGljIHZvaWQgX19pbml0IG14NTNfc21kX2JvYXJkX2luaXQodm9pZCkKK3sKKwlteGNfaW9tdXhfdjNfc2V0dXBfbXVsdGlwbGVfcGFkcyhteDUzX3NtZF9wYWRzLAorCQkJCQlBUlJBWV9TSVpFKG14NTNfc21kX3BhZHMpKTsKKwlteDUzX3NtZF9pbml0X3VhcnQoKTsKKwlteDUzX3NtZF9mZWNfcmVzZXQoKTsKKwlpbXg1M19hZGRfZmVjKCZteDUzX3NtZF9mZWNfZGF0YSk7Cit9CisKK3N0YXRpYyB2b2lkIF9faW5pdCBteDUzX3NtZF90aW1lcl9pbml0KHZvaWQpCit7CisJbXg1M19jbG9ja3NfaW5pdCgzMjc2OCwgMjQwMDAwMDAsIDIyNTc5MjAwLCAwKTsKK30KKworc3RhdGljIHN0cnVjdCBzeXNfdGltZXIgbXg1M19zbWRfdGltZXIgPSB7CisJLmluaXQJPSBteDUzX3NtZF90aW1lcl9pbml0LAorfTsKKworTUFDSElORV9TVEFSVChNWDUzX1NNRCwgIkZyZWVzY2FsZSBNWDUzIFNNRCBCb2FyZCIpCisJLm1hcF9pbyA9IG14NTNfbWFwX2lvLAorCS5pbml0X2lycSA9IG14NTNfaW5pdF9pcnEsCisJLmluaXRfbWFjaGluZSA9IG14NTNfc21kX2JvYXJkX2luaXQsCisJLnRpbWVyID0gJm14NTNfc21kX3RpbWVyLAorTUFDSElORV9FTkQKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbXg1L2Nsb2NrLW14NTEtbXg1My5jIGIvYXJjaC9hcm0vbWFjaC1teDUvY2xvY2stbXg1MS1teDUzLmMKaW5kZXggNzg1ZTFhMy4uMGExOWU3NSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1teDUvY2xvY2stbXg1MS1teDUzLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1teDUvY2xvY2stbXg1MS1teDUzLmMKQEAgLTExOTEsNiArMTE5MSwxMSBAQAogREVGSU5FX0NMT0NLKGdwdF9jbGssIDAsIE1YQ19DQ01fQ0NHUjIsIE1YQ19DQ01fQ0NHUnhfQ0c5X09GRlNFVCwKIAlOVUxMLCAgTlVMTCwgJmlwZ19jbGssICZncHRfaXBnX2Nsayk7CiAKK0RFRklORV9DTE9DSyhwd20xX2NsaywgMCwgTVhDX0NDTV9DQ0dSMiwgTVhDX0NDTV9DQ0dSeF9DRzZfT0ZGU0VULAorCU5VTEwsIE5VTEwsICZpcGdfY2xrLCBOVUxMKTsKK0RFRklORV9DTE9DSyhwd20yX2NsaywgMCwgTVhDX0NDTV9DQ0dSMiwgTVhDX0NDTV9DQ0dSeF9DRzhfT0ZGU0VULAorCU5VTEwsIE5VTEwsICZpcGdfY2xrLCBOVUxMKTsKKwogLyogSTJDICovCiBERUZJTkVfQ0xPQ0soaTJjMV9jbGssIDAsIE1YQ19DQ01fQ0NHUjEsIE1YQ19DQ01fQ0NHUnhfQ0c5X09GRlNFVCwKIAlOVUxMLCBOVUxMLCAmaXBnX2NsaywgTlVMTCk7CkBAIC0xMjgzLDYgKzEyODgsOCBAQAogCV9SRUdJU1RFUl9DTE9DSygiaW14LXVhcnQuMiIsIE5VTEwsIHVhcnQzX2NsaykKIAlfUkVHSVNURVJfQ0xPQ0soTlVMTCwgImdwdCIsIGdwdF9jbGspCiAJX1JFR0lTVEVSX0NMT0NLKCJmZWMuMCIsIE5VTEwsIGZlY19jbGspCisJX1JFR0lTVEVSX0NMT0NLKCJteGNfcHdtLjAiLCAicHdtIiwgcHdtMV9jbGspCisJX1JFR0lTVEVSX0NMT0NLKCJteGNfcHdtLjEiLCAicHdtIiwgcHdtMl9jbGspCiAJX1JFR0lTVEVSX0NMT0NLKCJpbXgtaTJjLjAiLCBOVUxMLCBpMmMxX2NsaykKIAlfUkVHSVNURVJfQ0xPQ0soImlteC1pMmMuMSIsIE5VTEwsIGkyYzJfY2xrKQogCV9SRUdJU1RFUl9DTE9DSygiaW14LWkyYy4yIiwgTlVMTCwgaHNpMmNfY2xrKQpAQCAtMTI5NSw3ICsxMzAyLDcgQEAKIAlfUkVHSVNURVJfQ0xPQ0soIm14Yy1laGNpLjIiLCAidXNiX2FoYiIsIHVzYl9haGJfY2xrKQogCV9SRUdJU1RFUl9DTE9DSygiZnNsLXVzYjItdWRjIiwgInVzYiIsIHVzYm9oM19jbGspCiAJX1JFR0lTVEVSX0NMT0NLKCJmc2wtdXNiMi11ZGMiLCAidXNiX2FoYiIsIGFoYl9jbGspCi0JX1JFR0lTVEVSX0NMT0NLKCJpbXgta2V5cGFkLjAiLCBOVUxMLCBrcHBfY2xrKQorCV9SRUdJU1RFUl9DTE9DSygiaW14LWtleXBhZCIsIE5VTEwsIGtwcF9jbGspCiAJX1JFR0lTVEVSX0NMT0NLKCJteGNfbmFuZCIsIE5VTEwsIG5mY19jbGspCiAJX1JFR0lTVEVSX0NMT0NLKCJpbXgtc3NpLjAiLCBOVUxMLCBzc2kxX2NsaykKIAlfUkVHSVNURVJfQ0xPQ0soImlteC1zc2kuMSIsIE5VTEwsIHNzaTJfY2xrKQpAQCAtMTMyNiw2ICsxMzMzLDEzIEBACiAJX1JFR0lTVEVSX0NMT0NLKE5VTEwsICJncHQiLCBncHRfY2xrKQogCV9SRUdJU1RFUl9DTE9DSygiZmVjLjAiLCBOVUxMLCBmZWNfY2xrKQogCV9SRUdJU1RFUl9DTE9DSyhOVUxMLCAiaWltX2NsayIsIGlpbV9jbGspCisJX1JFR0lTVEVSX0NMT0NLKCJpbXgtaTJjLjAiLCBOVUxMLCBpMmMxX2NsaykKKwlfUkVHSVNURVJfQ0xPQ0soImlteC1pMmMuMSIsIE5VTEwsIGkyYzJfY2xrKQorCV9SRUdJU1RFUl9DTE9DSygic2RoY2ktZXNkaGMtaW14LjAiLCBOVUxMLCBlc2RoYzFfY2xrKQorCV9SRUdJU1RFUl9DTE9DSygic2RoY2ktZXNkaGMtaW14LjEiLCBOVUxMLCBlc2RoYzJfY2xrKQorCV9SRUdJU1RFUl9DTE9DSygiaW14NTMtZWNzcGkuMCIsIE5VTEwsIGVjc3BpMV9jbGspCisJX1JFR0lTVEVSX0NMT0NLKCJpbXg1My1lY3NwaS4xIiwgTlVMTCwgZWNzcGkyX2NsaykKKwlfUkVHSVNURVJfQ0xPQ0soImlteDUzLWNzcGkuMCIsIE5VTEwsIGNzcGlfY2xrKQogfTsKIAogc3RhdGljIHZvaWQgY2xrX3RyZWVfaW5pdCh2b2lkKQpAQCAtMTM2Myw3ICsxMzc3LDYgQEAKIAogCWNsa190cmVlX2luaXQoKTsKIAotCWNsa19zZXRfcGFyZW50KCZ1YXJ0X3Jvb3RfY2xrLCAmcGxsM19zd19jbGspOwogCWNsa19lbmFibGUoJmNwdV9jbGspOwogCWNsa19lbmFibGUoJm1haW5fYnVzX2Nsayk7CiAKQEAgLTE0MDYsNiArMTQxOSw3IEBACiAKIAljbGtfdHJlZV9pbml0KCk7CiAKKwljbGtfc2V0X3BhcmVudCgmdWFydF9yb290X2NsaywgJnBsbDNfc3dfY2xrKTsKIAljbGtfZW5hYmxlKCZjcHVfY2xrKTsKIAljbGtfZW5hYmxlKCZtYWluX2J1c19jbGspOwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW14NS9kZXZpY2VzLWlteDUxLmggYi9hcmNoL2FybS9tYWNoLW14NS9kZXZpY2VzLWlteDUxLmgKaW5kZXggNjMwMmU0Ni4uN2ZmZjQ4NSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1teDUvZGV2aWNlcy1pbXg1MS5oCisrKyBiL2FyY2gvYXJtL21hY2gtbXg1L2RldmljZXMtaW14NTEuaApAQCAtNDcsMyArNDcsMTEgQEAKIGV4dGVybiBjb25zdCBzdHJ1Y3QgaW14X2lteDJfd2R0X2RhdGEgaW14NTFfaW14Ml93ZHRfZGF0YVtdIF9faW5pdGNvbnN0OwogI2RlZmluZSBpbXg1MV9hZGRfaW14Ml93ZHQoaWQsIHBkYXRhKQlcCiAJaW14X2FkZF9pbXgyX3dkdCgmaW14NTFfaW14Ml93ZHRfZGF0YVtpZF0pCisKK2V4dGVybiBjb25zdCBzdHJ1Y3QgaW14X214Y19wd21fZGF0YSBpbXg1MV9teGNfcHdtX2RhdGFbXSBfX2luaXRjb25zdDsKKyNkZWZpbmUgaW14NTFfYWRkX214Y19wd20oaWQpCVwKKwlpbXhfYWRkX214Y19wd20oJmlteDUxX214Y19wd21fZGF0YVtpZF0pCisKK2V4dGVybiBjb25zdCBzdHJ1Y3QgaW14X2lteF9rZXlwYWRfZGF0YSBpbXg1MV9pbXhfa2V5cGFkX2RhdGEgX19pbml0Y29uc3Q7CisjZGVmaW5lIGlteDUxX2FkZF9pbXhfa2V5cGFkKHBkYXRhKQlcCisJaW14X2FkZF9pbXhfa2V5cGFkKCZpbXg1MV9pbXhfa2V5cGFkX2RhdGEsIHBkYXRhKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1teDUvZGV2aWNlcy1pbXg1My5oIGIvYXJjaC9hcm0vbWFjaC1teDUvZGV2aWNlcy1pbXg1My5oCmluZGV4IDlkMGVjMjUuLjg2Mzk3MzUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbXg1L2RldmljZXMtaW14NTMuaAorKysgYi9hcmNoL2FybS9tYWNoLW14NS9kZXZpY2VzLWlteDUzLmgKQEAgLTgsNiArOCwyNCBAQAogI2luY2x1ZGUgPG1hY2gvbXg1My5oPgogI2luY2x1ZGUgPG1hY2gvZGV2aWNlcy1jb21tb24uaD4KIAorZXh0ZXJuIGNvbnN0IHN0cnVjdCBpbXhfZmVjX2RhdGEgaW14NTNfZmVjX2RhdGEgX19pbml0Y29uc3Q7CisjZGVmaW5lIGlteDUzX2FkZF9mZWMocGRhdGEpICAgXAorCWlteF9hZGRfZmVjKCZpbXg1M19mZWNfZGF0YSwgcGRhdGEpCisKIGV4dGVybiBjb25zdCBzdHJ1Y3QgaW14X2lteF91YXJ0XzFpcnFfZGF0YSBpbXg1M19pbXhfdWFydF9kYXRhW10gX19pbml0Y29uc3Q7CiAjZGVmaW5lIGlteDUzX2FkZF9pbXhfdWFydChpZCwgcGRhdGEpCVwKIAlpbXhfYWRkX2lteF91YXJ0XzFpcnEoJmlteDUzX2lteF91YXJ0X2RhdGFbaWRdLCBwZGF0YSkKKworCitleHRlcm4gY29uc3Qgc3RydWN0IGlteF9pbXhfaTJjX2RhdGEgaW14NTNfaW14X2kyY19kYXRhW10gX19pbml0Y29uc3Q7CisjZGVmaW5lIGlteDUzX2FkZF9pbXhfaTJjKGlkLCBwZGF0YSkJXAorCWlteF9hZGRfaW14X2kyYygmaW14NTNfaW14X2kyY19kYXRhW2lkXSwgcGRhdGEpCisKK2V4dGVybiBjb25zdCBzdHJ1Y3QgaW14X3NkaGNpX2VzZGhjX2lteF9kYXRhCitpbXg1M19zZGhjaV9lc2RoY19pbXhfZGF0YVtdIF9faW5pdGNvbnN0OworI2RlZmluZSBpbXg1M19hZGRfc2RoY2lfZXNkaGNfaW14KGlkLCBwZGF0YSkJXAorCWlteF9hZGRfc2RoY2lfZXNkaGNfaW14KCZpbXg1M19zZGhjaV9lc2RoY19pbXhfZGF0YVtpZF0sIHBkYXRhKQorCitleHRlcm4gY29uc3Qgc3RydWN0IGlteF9zcGlfaW14X2RhdGEgaW14NTNfZWNzcGlfZGF0YVtdIF9faW5pdGNvbnN0OworI2RlZmluZSBpbXg1M19hZGRfZWNzcGkoaWQsIHBkYXRhKQlcCisJaW14X2FkZF9zcGlfaW14KCZpbXg1M19lY3NwaV9kYXRhW2lkXSwgcGRhdGEpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW14NS9kZXZpY2VzLmMgYi9hcmNoL2FybS9tYWNoLW14NS9kZXZpY2VzLmMKaW5kZXggMWJkYTVjYi4uMTUzYWRhNSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1teDUvZGV2aWNlcy5jCisrKyBiL2FyY2gvYXJtL21hY2gtbXg1L2RldmljZXMuYwpAQCAtMTIwLDI1ICsxMjAsNiBAQAogCX0sCiB9OwogCi1zdGF0aWMgc3RydWN0IHJlc291cmNlIG14Y19rcHBfcmVzb3VyY2VzW10gPSB7Ci0JewotCQkuc3RhcnQgPSBNWDUxX01YQ19JTlRfS1BQLAotCQkuZW5kID0gTVg1MV9NWENfSU5UX0tQUCwKLQkJLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCi0JfSAsIHsKLQkJLnN0YXJ0ID0gTVg1MV9LUFBfQkFTRV9BRERSLAotCQkuZW5kID0gTVg1MV9LUFBfQkFTRV9BRERSICsgMHg4IC0gMSwKLQkJLmZsYWdzID0gSU9SRVNPVVJDRV9NRU0sCi0JfSwKLX07Ci0KLXN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgbXhjX2tleXBhZF9kZXZpY2UgPSB7Ci0JLm5hbWUgPSAiaW14LWtleXBhZCIsCi0JLmlkID0gMCwKLQkubnVtX3Jlc291cmNlcyA9IEFSUkFZX1NJWkUobXhjX2twcF9yZXNvdXJjZXMpLAotCS5yZXNvdXJjZSA9IG14Y19rcHBfcmVzb3VyY2VzLAotfTsKLQogc3RhdGljIHN0cnVjdCBteGNfZ3Bpb19wb3J0IG14Y19ncGlvX3BvcnRzW10gPSB7CiAJewogCQkuY2hpcC5sYWJlbCA9ICJncGlvLTAiLApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1teDUvZGV2aWNlcy5oIGIvYXJjaC9hcm0vbWFjaC1teDUvZGV2aWNlcy5oCmluZGV4IDE2ODkxYWEuLjU1YTUxMjkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbXg1L2RldmljZXMuaAorKysgYi9hcmNoL2FybS9tYWNoLW14NS9kZXZpY2VzLmgKQEAgLTMsNCArMywzIEBACiBleHRlcm4gc3RydWN0IHBsYXRmb3JtX2RldmljZSBteGNfdXNiaDJfZGV2aWNlOwogZXh0ZXJuIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgbXhjX3VzYmRyX3VkY19kZXZpY2U7CiBleHRlcm4gc3RydWN0IHBsYXRmb3JtX2RldmljZSBteGNfaHNpMmNfZGV2aWNlOwotZXh0ZXJuIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgbXhjX2tleXBhZF9kZXZpY2U7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW14NS9ldWtyZWFfbWJpbXg1MS1iYXNlYm9hcmQuYyBiL2FyY2gvYXJtL21hY2gtbXg1L2V1a3JlYV9tYmlteDUxLWJhc2Vib2FyZC5jCmluZGV4IGM5NmQwMTguLmU4M2ZmYWQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbXg1L2V1a3JlYV9tYmlteDUxLWJhc2Vib2FyZC5jCisrKyBiL2FyY2gvYXJtL21hY2gtbXg1L2V1a3JlYV9tYmlteDUxLWJhc2Vib2FyZC5jCkBAIC0yMSw3ICsyMSw2IEBACiAjaW5jbHVkZSA8bGludXgvZnNsX2RldmljZXMuaD4KICNpbmNsdWRlIDxsaW51eC9pMmMvdHNjMjAwNy5oPgogI2luY2x1ZGUgPGxpbnV4L2xlZHMuaD4KLSNpbmNsdWRlIDxsaW51eC9pbnB1dC9tYXRyaXhfa2V5cGFkLmg+CiAKICNpbmNsdWRlIDxtYWNoL2NvbW1vbi5oPgogI2luY2x1ZGUgPG1hY2gvaGFyZHdhcmUuaD4KQEAgLTE1Nyw3ICsxNTYsNyBAQAogCUtFWSgzLCAzLCBLRVlfRU5URVIpLAogfTsKIAotc3RhdGljIHN0cnVjdCBtYXRyaXhfa2V5bWFwX2RhdGEgbWJpbXg1MV9tYXBfZGF0YSA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbWF0cml4X2tleW1hcF9kYXRhIG1iaW14NTFfbWFwX2RhdGEgX19pbml0Y29uc3QgPSB7CiAJLmtleW1hcAkJPSBtYmlteDUxX2tleW1hcCwKIAkua2V5bWFwX3NpemUJPSBBUlJBWV9TSVpFKG1iaW14NTFfa2V5bWFwKSwKIH07CkBAIC0yMDksNyArMjA4LDcgQEAKIAogCXBsYXRmb3JtX2FkZF9kZXZpY2VzKGRldmljZXMsIEFSUkFZX1NJWkUoZGV2aWNlcykpOwogCi0JbXhjX3JlZ2lzdGVyX2RldmljZSgmbXhjX2tleXBhZF9kZXZpY2UsICZtYmlteDUxX21hcF9kYXRhKTsKKwlpbXg1MV9hZGRfaW14X2tleXBhZCgmbWJpbXg1MV9tYXBfZGF0YSk7CiAKIAlncGlvX3JlcXVlc3QoTUJJTVg1MV9UU0MyMDA3X0dQSU8sICJ0c2MyMDA3X2lycSIpOwogCWdwaW9fZGlyZWN0aW9uX2lucHV0KE1CSU1YNTFfVFNDMjAwN19HUElPKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbXhzL0tjb25maWcgYi9hcmNoL2FybS9tYWNoLW14cy9LY29uZmlnCmluZGV4IGM0YWM3YjQuLjhiZmM4ZGYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbXhzL0tjb25maWcKKysrIGIvYXJjaC9hcm0vbWFjaC1teHMvS2NvbmZpZwpAQCAtMTUsNyArMTUsNyBAQAogY29uZmlnIE1BQ0hfTVgyM0VWSwogCWJvb2wgIlN1cHBvcnQgTVgyM0VWSyBQbGF0Zm9ybSIKIAlzZWxlY3QgU09DX0lNWDIzCi0Jc2VsZWN0IE1YU19IQVZFX1BMQVRGT1JNX0RVQVJUCisJc2VsZWN0IE1YU19IQVZFX0FNQkFfRFVBUlQKIAlkZWZhdWx0IHkKIAloZWxwCiAJICBJbmNsdWRlIHN1cHBvcnQgZm9yIE1YMjNFVksgcGxhdGZvcm0uIFRoaXMgaW5jbHVkZXMgc3BlY2lmaWMKQEAgLTI0LDcgKzI0LDcgQEAKIGNvbmZpZyBNQUNIX01YMjhFVksKIAlib29sICJTdXBwb3J0IE1YMjhFVksgUGxhdGZvcm0iCiAJc2VsZWN0IFNPQ19JTVgyOAotCXNlbGVjdCBNWFNfSEFWRV9QTEFURk9STV9EVUFSVAorCXNlbGVjdCBNWFNfSEFWRV9BTUJBX0RVQVJUCiAJc2VsZWN0IE1YU19IQVZFX1BMQVRGT1JNX0ZFQwogCWRlZmF1bHQgeQogCWhlbHAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbXhzL2Nsb2NrLW14MjMuYyBiL2FyY2gvYXJtL21hY2gtbXhzL2Nsb2NrLW14MjMuYwppbmRleCA4ZjVhMTlhLi5jYTcyYTA1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW14cy9jbG9jay1teDIzLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1teHMvY2xvY2stbXgyMy5jCkBAIC0yMSw2ICsyMSw3IEBACiAjaW5jbHVkZSA8bGludXgvY2xrLmg+CiAjaW5jbHVkZSA8bGludXgvaW8uaD4KICNpbmNsdWRlIDxsaW51eC9qaWZmaWVzLmg+CisjaW5jbHVkZSA8bGludXgvY2xrZGV2Lmg+CiAKICNpbmNsdWRlIDxhc20vY2xrZGV2Lmg+CiAjaW5jbHVkZSA8YXNtL2RpdjY0Lmg+CkBAIC0zMDMsNyArMzA0LDcgQEAKIAlyZWcgPSBfX3Jhd19yZWFkbChDTEtDVFJMX0JBU0VfQUREUiArIEhXX0NMS0NUUkxfIyNkcik7CQlcCiAJcmVnICY9IH5CTV9DTEtDVFJMXyMjZHIjI19ESVY7CQkJCQlcCiAJcmVnIHw9IGRpdiA8PCBCUF9DTEtDVFJMXyMjZHIjI19ESVY7CQkJCVwKLQlpZiAocmVnIHwgKDEgPDwgY2xrLT5lbmFibGVfc2hpZnQpKSB7CQkJCVwKKwlpZiAocmVnICYgKDEgPDwgY2xrLT5lbmFibGVfc2hpZnQpKSB7CQkJCVwKIAkJcHJfZXJyKCIlczogY2xvY2sgaXMgZ2F0ZWRcbiIsIF9fZnVuY19fKTsJCVwKIAkJcmV0dXJuIC1FSU5WQUw7CQkJCQkJXAogCX0JCQkJCQkJCVwKQEAgLTM0Niw3ICszNDcsNyBAQAogewkJCQkJCQkJCVwKIAlpZiAocGFyZW50ICE9IGNsay0+cGFyZW50KSB7CQkJCQlcCiAJCV9fcmF3X3dyaXRlbChCTV9DTEtDVFJMX0NMS1NFUV9CWVBBU1NfIyNiaXQsCQlcCi0JCQkgSFdfQ0xLQ1RSTF9DTEtTRVFfVE9HKTsJCQlcCisJCQkgQ0xLQ1RSTF9CQVNFX0FERFIgKyBIV19DTEtDVFJMX0NMS1NFUV9UT0cpOwlcCiAJCWNsay0+cGFyZW50ID0gcGFyZW50OwkJCQkJXAogCX0JCQkJCQkJCVwKIAkJCQkJCQkJCVwKQEAgLTQzNywxMCArNDM4LDEyIEBACiAJfSwKIAogc3RhdGljIHN0cnVjdCBjbGtfbG9va3VwIGxvb2t1cHNbXSA9IHsKLQlfUkVHSVNURVJfQ0xPQ0soIm14cy1kdWFydC4wIiwgTlVMTCwgdWFydF9jbGspCisJLyogZm9yIGFtYmEgYnVzIGRyaXZlciAqLworCV9SRUdJU1RFUl9DTE9DSygiZHVhcnQiLCAiYXBiX3BjbGsiLCB4YnVzX2NsaykKKwkvKiBmb3IgYW1iYS1wbDAxMSBkcml2ZXIgKi8KKwlfUkVHSVNURVJfQ0xPQ0soImR1YXJ0IiwgTlVMTCwgdWFydF9jbGspCiAJX1JFR0lTVEVSX0NMT0NLKCJydGMiLCBOVUxMLCBydGNfY2xrKQogCV9SRUdJU1RFUl9DTE9DSyhOVUxMLCAiaGNsayIsIGhidXNfY2xrKQotCV9SRUdJU1RFUl9DTE9DSyhOVUxMLCAieGNsayIsIHhidXNfY2xrKQogCV9SRUdJU1RFUl9DTE9DSyhOVUxMLCAidXNiIiwgdXNiX2NsaykKIAlfUkVHSVNURVJfQ0xPQ0soTlVMTCwgImF1ZGlvIiwgYXVkaW9fY2xrKQogCV9SRUdJU1RFUl9DTE9DSyhOVUxMLCAicHdtIiwgcHdtX2NsaykKQEAgLTUxOCw2ICs1MjEsMTIgQEAKIHsKIAljbGtfbWlzY19pbml0KCk7CiAKKwljbGtfZW5hYmxlKCZjcHVfY2xrKTsKKwljbGtfZW5hYmxlKCZoYnVzX2Nsayk7CisJY2xrX2VuYWJsZSgmeGJ1c19jbGspOworCWNsa19lbmFibGUoJmVtaV9jbGspOworCWNsa19lbmFibGUoJnVhcnRfY2xrKTsKKwogCWNsa2Rldl9hZGRfdGFibGUobG9va3VwcywgQVJSQVlfU0laRShsb29rdXBzKSk7CiAKIAlteHNfdGltZXJfaW5pdCgmY2xrMzJrX2NsaywgTVgyM19JTlRfVElNRVIwKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbXhzL2Nsb2NrLW14MjguYyBiL2FyY2gvYXJtL21hY2gtbXhzL2Nsb2NrLW14MjguYwppbmRleCA3NGUyMTAzLi5mZDFjNGM1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW14cy9jbG9jay1teDI4LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1teHMvY2xvY2stbXgyOC5jCkBAIC0yMSw2ICsyMSw3IEBACiAjaW5jbHVkZSA8bGludXgvY2xrLmg+CiAjaW5jbHVkZSA8bGludXgvaW8uaD4KICNpbmNsdWRlIDxsaW51eC9qaWZmaWVzLmg+CisjaW5jbHVkZSA8bGludXgvY2xrZGV2Lmg+CiAKICNpbmNsdWRlIDxhc20vY2xrZGV2Lmg+CiAjaW5jbHVkZSA8YXNtL2RpdjY0Lmg+CkBAIC0zNTQsMTIgKzM1NSwxMiBAQAogCX0gZWxzZSB7CQkJCQkJCVwKIAkJcmVnICY9IH5CTV9DTEtDVFJMXyMjZHIjI19ESVY7CQkJCVwKIAkJcmVnIHw9IGRpdiA8PCBCUF9DTEtDVFJMXyMjZHIjI19ESVY7CQkJXAotCQlpZiAocmVnIHwgKDEgPDwgY2xrLT5lbmFibGVfc2hpZnQpKSB7CQkJXAorCQlpZiAocmVnICYgKDEgPDwgY2xrLT5lbmFibGVfc2hpZnQpKSB7CQkJXAogCQkJcHJfZXJyKCIlczogY2xvY2sgaXMgZ2F0ZWRcbiIsIF9fZnVuY19fKTsJXAogCQkJcmV0dXJuIC1FSU5WQUw7CQkJCQlcCiAJCX0JCQkJCQkJXAogCX0JCQkJCQkJCVwKLQlfX3Jhd193cml0ZWwocmVnLCBDTEtDVFJMX0JBU0VfQUREUiArIEhXX0NMS0NUUkxfQ1BVKTsJCVwKKwlfX3Jhd193cml0ZWwocmVnLCBDTEtDVFJMX0JBU0VfQUREUiArIEhXX0NMS0NUUkxfIyNkcik7CQlcCiAJCQkJCQkJCQlcCiAJZm9yIChpID0gMTAwMDA7IGk7IGktLSkJCQkJCQlcCiAJCWlmICghKF9fcmF3X3JlYWRsKENMS0NUUkxfQkFTRV9BRERSICsJCQlcCkBAIC00ODIsNyArNDgzLDcgQEAKIHsJCQkJCQkJCQlcCiAJaWYgKHBhcmVudCAhPSBjbGstPnBhcmVudCkgewkJCQkJXAogCQlfX3Jhd193cml0ZWwoQk1fQ0xLQ1RSTF9DTEtTRVFfQllQQVNTXyMjYml0LAkJXAotCQkJIEhXX0NMS0NUUkxfQ0xLU0VRX1RPRyk7CQkJXAorCQkJIENMS0NUUkxfQkFTRV9BRERSICsgSFdfQ0xLQ1RSTF9DTEtTRVFfVE9HKTsJXAogCQljbGstPnBhcmVudCA9IHBhcmVudDsJCQkJCVwKIAl9CQkJCQkJCQlcCiAJCQkJCQkJCQlcCkBAIC02MDIsOCArNjAzLDEyIEBACiAJfSwKIAogc3RhdGljIHN0cnVjdCBjbGtfbG9va3VwIGxvb2t1cHNbXSA9IHsKLQlfUkVHSVNURVJfQ0xPQ0soIm14cy1kdWFydC4wIiwgTlVMTCwgdWFydF9jbGspCi0JX1JFR0lTVEVSX0NMT0NLKCJmZWMuMCIsIE5VTEwsIGZlY19jbGspCisJLyogZm9yIGFtYmEgYnVzIGRyaXZlciAqLworCV9SRUdJU1RFUl9DTE9DSygiZHVhcnQiLCAiYXBiX3BjbGsiLCB4YnVzX2NsaykKKwkvKiBmb3IgYW1iYS1wbDAxMSBkcml2ZXIgKi8KKwlfUkVHSVNURVJfQ0xPQ0soImR1YXJ0IiwgTlVMTCwgdWFydF9jbGspCisJX1JFR0lTVEVSX0NMT0NLKCJpbXgyOC1mZWMuMCIsIE5VTEwsIGZlY19jbGspCisJX1JFR0lTVEVSX0NMT0NLKCJpbXgyOC1mZWMuMSIsIE5VTEwsIGZlY19jbGspCiAJX1JFR0lTVEVSX0NMT0NLKCJydGMiLCBOVUxMLCBydGNfY2xrKQogCV9SRUdJU1RFUl9DTE9DSygicGxsMiIsIE5VTEwsIHBsbDJfY2xrKQogCV9SRUdJU1RFUl9DTE9DSyhOVUxMLCAiaGNsayIsIGhidXNfY2xrKQpAQCAtNzI2LDYgKzczMSwxMiBAQAogewogCWNsa19taXNjX2luaXQoKTsKIAorCWNsa19lbmFibGUoJmNwdV9jbGspOworCWNsa19lbmFibGUoJmhidXNfY2xrKTsKKwljbGtfZW5hYmxlKCZ4YnVzX2Nsayk7CisJY2xrX2VuYWJsZSgmZW1pX2Nsayk7CisJY2xrX2VuYWJsZSgmdWFydF9jbGspOworCiAJY2xrZGV2X2FkZF90YWJsZShsb29rdXBzLCBBUlJBWV9TSVpFKGxvb2t1cHMpKTsKIAogCW14c190aW1lcl9pbml0KCZjbGszMmtfY2xrLCBNWDI4X0lOVF9USU1FUjApOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1teHMvY2xvY2suYyBiL2FyY2gvYXJtL21hY2gtbXhzL2Nsb2NrLmMKaW5kZXggZTdkMjI2OS4uYTcwOTNjOCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1teHMvY2xvY2suYworKysgYi9hcmNoL2FybS9tYWNoLW14cy9jbG9jay5jCkBAIC01Nyw3ICs1Nyw2IEBACiAJCWlmIChjbGstPmRpc2FibGUpCiAJCQljbGstPmRpc2FibGUoY2xrKTsKIAkJX19jbGtfZGlzYWJsZShjbGstPnBhcmVudCk7Ci0JCV9fY2xrX2Rpc2FibGUoY2xrLT5zZWNvbmRhcnkpOwogCX0KIH0KIApAQCAtNjgsNyArNjcsNiBAQAogCiAJaWYgKGNsay0+dXNlY291bnQrKyA9PSAwKSB7CiAJCV9fY2xrX2VuYWJsZShjbGstPnBhcmVudCk7Ci0JCV9fY2xrX2VuYWJsZShjbGstPnNlY29uZGFyeSk7CiAKIAkJaWYgKGNsay0+ZW5hYmxlKQogCQkJY2xrLT5lbmFibGUoY2xrKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbXhzL2RldmljZXMtbXgyMy5oIGIvYXJjaC9hcm0vbWFjaC1teHMvZGV2aWNlcy1teDIzLmgKaW5kZXggZDBmNDlmYy4uMTI1Njc4OCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1teHMvZGV2aWNlcy1teDIzLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1teHMvZGV2aWNlcy1teDIzLmgKQEAgLTExLDYgKzExLDYgQEAKICNpbmNsdWRlIDxtYWNoL214MjMuaD4KICNpbmNsdWRlIDxtYWNoL2RldmljZXMtY29tbW9uLmg+CiAKLWV4dGVybiBjb25zdCBzdHJ1Y3QgbXhzX2R1YXJ0X2RhdGEgbXgyM19kdWFydF9kYXRhIF9faW5pdGNvbnN0OworZXh0ZXJuIGNvbnN0IHN0cnVjdCBhbWJhX2RldmljZSBteDIzX2R1YXJ0X2RldmljZSBfX2luaXRjb25zdDsKICNkZWZpbmUgbXgyM19hZGRfZHVhcnQoKSBcCi0JbXhzX2FkZF9kdWFydCgmbXgyM19kdWFydF9kYXRhKQorCW14c19hZGRfZHVhcnQoJm14MjNfZHVhcnRfZGV2aWNlKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1teHMvZGV2aWNlcy1teDI4LmggYi9hcmNoL2FybS9tYWNoLW14cy9kZXZpY2VzLW14MjguaAppbmRleCAwMGI3MzZjLi4zMzc3M2E2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW14cy9kZXZpY2VzLW14MjguaAorKysgYi9hcmNoL2FybS9tYWNoLW14cy9kZXZpY2VzLW14MjguaApAQCAtMTEsOSArMTEsOSBAQAogI2luY2x1ZGUgPG1hY2gvbXgyOC5oPgogI2luY2x1ZGUgPG1hY2gvZGV2aWNlcy1jb21tb24uaD4KIAotZXh0ZXJuIGNvbnN0IHN0cnVjdCBteHNfZHVhcnRfZGF0YSBteDI4X2R1YXJ0X2RhdGEgX19pbml0Y29uc3Q7CitleHRlcm4gY29uc3Qgc3RydWN0IGFtYmFfZGV2aWNlIG14MjhfZHVhcnRfZGV2aWNlIF9faW5pdGNvbnN0OwogI2RlZmluZSBteDI4X2FkZF9kdWFydCgpIFwKLQlteHNfYWRkX2R1YXJ0KCZteDI4X2R1YXJ0X2RhdGEpCisJbXhzX2FkZF9kdWFydCgmbXgyOF9kdWFydF9kZXZpY2UpCiAKIGV4dGVybiBjb25zdCBzdHJ1Y3QgbXhzX2ZlY19kYXRhIG14MjhfZmVjX2RhdGFbXSBfX2luaXRjb25zdDsKICNkZWZpbmUgbXgyOF9hZGRfZmVjKGlkLCBwZGF0YSkgXApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1teHMvZGV2aWNlcy5jIGIvYXJjaC9hcm0vbWFjaC1teHMvZGV2aWNlcy5jCmluZGV4IDZiNjBmMDIuLmMyMGQ1NDcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbXhzL2RldmljZXMuYworKysgYi9hcmNoL2FybS9tYWNoLW14cy9kZXZpY2VzLmMKQEAgLTE5LDkgKzE5LDggQEAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgotI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgogI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgotI2luY2x1ZGUgPG1hY2gvY29tbW9uLmg+CisjaW5jbHVkZSA8bGludXgvYW1iYS9idXMuaD4KIAogc3RydWN0IHBsYXRmb3JtX2RldmljZSAqX19pbml0IG14c19hZGRfcGxhdGZvcm1fZGV2aWNlX2RtYW1hc2soCiAJCWNvbnN0IGNoYXIgKm5hbWUsIGludCBpZCwKQEAgLTczLDMgKzcyLDE3IEBACiAKIAlyZXR1cm4gcGRldjsKIH0KKworaW50IF9faW5pdCBteHNfYWRkX2FtYmFfZGV2aWNlKGNvbnN0IHN0cnVjdCBhbWJhX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBhbWJhX2RldmljZSAqYWRldiA9IGttYWxsb2Moc2l6ZW9mKCphZGV2KSwgR0ZQX0tFUk5FTCk7CisKKwlpZiAoIWFkZXYpIHsKKwkJcHJfZXJyKCIlczogZmFpbGVkIHRvIGFsbG9jYXRlIG1lbW9yeSIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJKmFkZXYgPSAqZGV2OworCisJcmV0dXJuIGFtYmFfZGV2aWNlX3JlZ2lzdGVyKGFkZXYsICZpb21lbV9yZXNvdXJjZSk7Cit9CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW14cy9kZXZpY2VzL0tjb25maWcgYi9hcmNoL2FybS9tYWNoLW14cy9kZXZpY2VzL0tjb25maWcKaW5kZXggYTM1YTJkYy4uY2Y3ZGMxYSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1teHMvZGV2aWNlcy9LY29uZmlnCisrKyBiL2FyY2gvYXJtL21hY2gtbXhzL2RldmljZXMvS2NvbmZpZwpAQCAtMSw1ICsxLDYgQEAKLWNvbmZpZyBNWFNfSEFWRV9QTEFURk9STV9EVUFSVAorY29uZmlnIE1YU19IQVZFX0FNQkFfRFVBUlQKIAlib29sCisJc2VsZWN0IEFSTV9BTUJBCiAKIGNvbmZpZyBNWFNfSEFWRV9QTEFURk9STV9GRUMKIAlib29sCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW14cy9kZXZpY2VzL01ha2VmaWxlIGIvYXJjaC9hcm0vbWFjaC1teHMvZGV2aWNlcy9NYWtlZmlsZQppbmRleCA0YjUyNjZhLi5kMGEwOWY2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW14cy9kZXZpY2VzL01ha2VmaWxlCisrKyBiL2FyY2gvYXJtL21hY2gtbXhzL2RldmljZXMvTWFrZWZpbGUKQEAgLTEsMiArMSwyIEBACi1vYmotJChDT05GSUdfTVhTX0hBVkVfUExBVEZPUk1fRFVBUlQpICs9IHBsYXRmb3JtLWR1YXJ0Lm8KK29iai0kKENPTkZJR19NWFNfSEFWRV9BTUJBX0RVQVJUKSArPSBhbWJhLWR1YXJ0Lm8KIG9iai0kKENPTkZJR19NWFNfSEFWRV9QTEFURk9STV9GRUMpICs9IHBsYXRmb3JtLWZlYy5vCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW14cy9kZXZpY2VzL2FtYmEtZHVhcnQuYyBiL2FyY2gvYXJtL21hY2gtbXhzL2RldmljZXMvYW1iYS1kdWFydC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmE1NTlkYjAKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL2FybS9tYWNoLW14cy9kZXZpY2VzL2FtYmEtZHVhcnQuYwpAQCAtMCwwICsxLDQwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5LTIwMTAgUGVuZ3V0cm9uaXgKKyAqIFV3ZSBLbGVpbmUtS29lbmlnIDx1LmtsZWluZS1rb2VuaWdAcGVuZ3V0cm9uaXguZGU+CisgKgorICogQ29weXJpZ2h0IDIwMTAgRnJlZXNjYWxlIFNlbWljb25kdWN0b3IsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdCB1bmRlcgorICogdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkIGJ5IHRoZQorICogRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICovCisjaW5jbHVkZSA8YXNtL2lycS5oPgorI2luY2x1ZGUgPG1hY2gvbXgyMy5oPgorI2luY2x1ZGUgPG1hY2gvbXgyOC5oPgorI2luY2x1ZGUgPG1hY2gvZGV2aWNlcy1jb21tb24uaD4KKworI2RlZmluZSBNWFNfQU1CQV9EVUFSVF9ERVZJQ0UobmFtZSwgc29jKQkJCVwKK2NvbnN0IHN0cnVjdCBhbWJhX2RldmljZSBuYW1lIyNfZGV2aWNlIF9faW5pdGNvbnN0ID0gewkJXAorCS5kZXYgPSB7CQkJCQkJXAorCQkuaW5pdF9uYW1lID0gImR1YXJ0IiwJCQkJXAorCX0sCQkJCQkJCVwKKwkucmVzID0gewkJCQkJCVwKKwkJLnN0YXJ0ID0gc29jICMjIF9EVUFSVF9CQVNFX0FERFIsCQlcCisJCS5lbmQgPSAoc29jICMjIF9EVUFSVF9CQVNFX0FERFIpICsgU1pfOEsgLSAxLAlcCisJCS5mbGFncyA9IElPUkVTT1VSQ0VfTUVNLAkJCVwKKwl9LAkJCQkJCQlcCisJLmlycSA9IHtzb2MgIyMgX0lOVF9EVUFSVCwgTk9fSVJRfSwJCQlcCit9CisKKyNpZmRlZiBDT05GSUdfU09DX0lNWDIzCitNWFNfQU1CQV9EVUFSVF9ERVZJQ0UobXgyM19kdWFydCwgTVgyMyk7CisjZW5kaWYKKworI2lmZGVmIENPTkZJR19TT0NfSU1YMjgKK01YU19BTUJBX0RVQVJUX0RFVklDRShteDI4X2R1YXJ0LCBNWDI4KTsKKyNlbmRpZgorCitpbnQgX19pbml0IG14c19hZGRfZHVhcnQoY29uc3Qgc3RydWN0IGFtYmFfZGV2aWNlICpkZXYpCit7CisJcmV0dXJuIG14c19hZGRfYW1iYV9kZXZpY2UoZGV2KTsKK30KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbXhzL2RldmljZXMvcGxhdGZvcm0tZHVhcnQuYyBiL2FyY2gvYXJtL21hY2gtbXhzL2RldmljZXMvcGxhdGZvcm0tZHVhcnQuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMmZlMGRmNS4uMDAwMDAwMAotLS0gYS9hcmNoL2FybS9tYWNoLW14cy9kZXZpY2VzL3BsYXRmb3JtLWR1YXJ0LmMKKysrIC9kZXYvbnVsbApAQCAtMSw0OCArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSAyMDA5LTIwMTAgUGVuZ3V0cm9uaXgKLSAqIFV3ZSBLbGVpbmUtS29lbmlnIDx1LmtsZWluZS1rb2VuaWdAcGVuZ3V0cm9uaXguZGU+Ci0gKgotICogQ29weXJpZ2h0IDIwMTAgRnJlZXNjYWxlIFNlbWljb25kdWN0b3IsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdCB1bmRlcgotICogdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkIGJ5IHRoZQotICogRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgotICovCi0jaW5jbHVkZSA8bWFjaC9teDIzLmg+Ci0jaW5jbHVkZSA8bWFjaC9teDI4Lmg+Ci0jaW5jbHVkZSA8bWFjaC9kZXZpY2VzLWNvbW1vbi5oPgotCi0jZGVmaW5lIG14c19kdWFydF9kYXRhX2VudHJ5KHNvYykJCQkJCVwKLQl7CQkJCQkJCQlcCi0JCS5pb2Jhc2UgPSBzb2MgIyMgX0RVQVJUX0JBU0VfQUREUiwJCQlcCi0JCS5pcnEgPSBzb2MgIyMgX0lOVF9EVUFSVCwJCQkJXAotCX0KLQotI2lmZGVmIENPTkZJR19TT0NfSU1YMjMKLWNvbnN0IHN0cnVjdCBteHNfZHVhcnRfZGF0YSBteDIzX2R1YXJ0X2RhdGEgX19pbml0Y29uc3QgPQotCW14c19kdWFydF9kYXRhX2VudHJ5KE1YMjMpOwotI2VuZGlmCi0KLSNpZmRlZiBDT05GSUdfU09DX0lNWDI4Ci1jb25zdCBzdHJ1Y3QgbXhzX2R1YXJ0X2RhdGEgbXgyOF9kdWFydF9kYXRhIF9faW5pdGNvbnN0ID0KLQlteHNfZHVhcnRfZGF0YV9lbnRyeShNWDI4KTsKLSNlbmRpZgotCi1zdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpfX2luaXQgbXhzX2FkZF9kdWFydCgKLQkJY29uc3Qgc3RydWN0IG14c19kdWFydF9kYXRhICpkYXRhKQotewotCXN0cnVjdCByZXNvdXJjZSByZXNbXSA9IHsKLQkJewotCQkJLnN0YXJ0ID0gZGF0YS0+aW9iYXNlLAotCQkJLmVuZCA9IGRhdGEtPmlvYmFzZSArIFNaXzhLIC0gMSwKLQkJCS5mbGFncyA9IElPUkVTT1VSQ0VfTUVNLAotCQl9LCB7Ci0JCQkuc3RhcnQgPSBkYXRhLT5pcnEsCi0JCQkuZW5kID0gZGF0YS0+aXJxLAotCQkJLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCi0JCX0sCi0JfTsKLQotCXJldHVybiBteHNfYWRkX3BsYXRmb3JtX2RldmljZSgibXhzLWR1YXJ0IiwgMCwgcmVzLCBBUlJBWV9TSVpFKHJlcyksCi0JCQkJCU5VTEwsIDApOwotfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1teHMvZGV2aWNlcy9wbGF0Zm9ybS1mZWMuYyBiL2FyY2gvYXJtL21hY2gtbXhzL2RldmljZXMvcGxhdGZvcm0tZmVjLmMKaW5kZXggYzA4MTY4Yy4uYzQyZGZmNyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1teHMvZGV2aWNlcy9wbGF0Zm9ybS1mZWMuYworKysgYi9hcmNoL2FybS9tYWNoLW14cy9kZXZpY2VzL3BsYXRmb3JtLWZlYy5jCkBAIC00NSw2ICs0NSw2IEBACiAJCX0sCiAJfTsKIAotCXJldHVybiBteHNfYWRkX3BsYXRmb3JtX2RldmljZSgiZmVjIiwgZGF0YS0+aWQsCisJcmV0dXJuIG14c19hZGRfcGxhdGZvcm1fZGV2aWNlKCJpbXgyOC1mZWMiLCBkYXRhLT5pZCwKIAkJCXJlcywgQVJSQVlfU0laRShyZXMpLCBwZGF0YSwgc2l6ZW9mKCpwZGF0YSkpOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1teHMvZ3Bpby5jIGIvYXJjaC9hcm0vbWFjaC1teHMvZ3Bpby5jCmluZGV4IGQ3YWQ3YTYuLmNiMGMwZTggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbXhzL2dwaW8uYworKysgYi9hcmNoL2FybS9tYWNoLW14cy9ncGlvLmMKQEAgLTEzOSw2ICsxMzksOCBAQAogCXN0cnVjdCBteHNfZ3Bpb19wb3J0ICpwb3J0ID0gKHN0cnVjdCBteHNfZ3Bpb19wb3J0ICopZ2V0X2lycV9kYXRhKGlycSk7CiAJdTMyIGdwaW9faXJxX25vX2Jhc2UgPSBwb3J0LT52aXJ0dWFsX2lycV9zdGFydDsKIAorCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9hY2soJmRlc2MtPmlycV9kYXRhKTsKKwogCWlycV9zdGF0ID0gX19yYXdfcmVhZGwocG9ydC0+YmFzZSArIFBJTkNUUkxfSVJRU1RBVChwb3J0LT5pZCkpICYKIAkJCV9fcmF3X3JlYWRsKHBvcnQtPmJhc2UgKyBQSU5DVFJMX0lSUUVOKHBvcnQtPmlkKSk7CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbXhzL2luY2x1ZGUvbWFjaC9jbG9jay5oIGIvYXJjaC9hcm0vbWFjaC1teHMvaW5jbHVkZS9tYWNoL2Nsb2NrLmgKaW5kZXggMDQxZTI3Ni4uNTkyYzlhYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1teHMvaW5jbHVkZS9tYWNoL2Nsb2NrLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1teHMvaW5jbHVkZS9tYWNoL2Nsb2NrLmgKQEAgLTI5LDggKzI5LDYgQEAKIAlpbnQgaWQ7CiAJLyogU291cmNlIGNsb2NrIHRoaXMgY2xrIGRlcGVuZHMgb24gKi8KIAlzdHJ1Y3QgY2xrICpwYXJlbnQ7Ci0JLyogU2Vjb25kYXJ5IGNsb2NrIHRvIGVuYWJsZS9kaXNhYmxlIHdpdGggdGhpcyBjbG9jayAqLwotCXN0cnVjdCBjbGsgKnNlY29uZGFyeTsKIAkvKiBSZWZlcmVuY2UgY291bnQgb2YgY2xvY2sgZW5hYmxlL2Rpc2FibGUgKi8KIAlfX3M4IHVzZWNvdW50OwogCS8qIFJlZ2lzdGVyIGJpdCBwb3NpdGlvbiBmb3IgY2xvY2sncyBlbmFibGUvZGlzYWJsZSBjb250cm9sLiAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1teHMvaW5jbHVkZS9tYWNoL2RldmljZXMtY29tbW9uLmggYi9hcmNoL2FybS9tYWNoLW14cy9pbmNsdWRlL21hY2gvZGV2aWNlcy1jb21tb24uaAppbmRleCAzZGE0OGQ0Li42YzNkMWExIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW14cy9pbmNsdWRlL21hY2gvZGV2aWNlcy1jb21tb24uaAorKysgYi9hcmNoL2FybS9tYWNoLW14cy9pbmNsdWRlL21hY2gvZGV2aWNlcy1jb21tb24uaApAQCAtOSw2ICs5LDcgQEAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvYW1iYS9idXMuaD4KIAogc3RydWN0IHBsYXRmb3JtX2RldmljZSAqbXhzX2FkZF9wbGF0Zm9ybV9kZXZpY2VfZG1hbWFzaygKIAkJY29uc3QgY2hhciAqbmFtZSwgaW50IGlkLApAQCAtMjQsMTQgKzI1LDEwIEBACiAJCQluYW1lLCBpZCwgcmVzLCBudW1fcmVzb3VyY2VzLCBkYXRhLCBzaXplX2RhdGEsIDApOwogfQogCitpbnQgX19pbml0IG14c19hZGRfYW1iYV9kZXZpY2UoY29uc3Qgc3RydWN0IGFtYmFfZGV2aWNlICpkZXYpOworCiAvKiBkdWFydCAqLwotc3RydWN0IG14c19kdWFydF9kYXRhIHsKLQlyZXNvdXJjZV9zaXplX3QgaW9iYXNlOwotCXJlc291cmNlX3NpemVfdCBpb3NpemU7Ci0JcmVzb3VyY2Vfc2l6ZV90IGlycTsKLX07Ci1zdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpfX2luaXQgbXhzX2FkZF9kdWFydCgKLQkJY29uc3Qgc3RydWN0IG14c19kdWFydF9kYXRhICpkYXRhKTsKK2ludCBfX2luaXQgbXhzX2FkZF9kdWFydChjb25zdCBzdHJ1Y3QgYW1iYV9kZXZpY2UgKmRldik7CiAKIC8qIGZlYyAqLwogI2luY2x1ZGUgPGxpbnV4L2ZlYy5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1teHMvbWFjaC1teDI4ZXZrLmMgYi9hcmNoL2FybS9tYWNoLW14cy9tYWNoLW14MjhldmsuYwppbmRleCBkMTYyZTk1Li44ZTJjNTk3IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW14cy9tYWNoLW14MjhldmsuYworKysgYi9hcmNoL2FybS9tYWNoLW14cy9tYWNoLW14MjhldmsuYwpAQCAtNTcsNiArNTcsMTkgQEAKIAkJKE1YU19QQURfOE1BIHwgTVhTX1BBRF8zVjMgfCBNWFNfUEFEX1BVTExVUCksCiAJTVgyOF9QQURfRU5FVF9DTEtfX0NMS0NUUkxfRU5FVCB8CiAJCShNWFNfUEFEXzhNQSB8IE1YU19QQURfM1YzIHwgTVhTX1BBRF9QVUxMVVApLAorCS8qIGZlYzEgKi8KKwlNWDI4X1BBRF9FTkVUMF9DUlNfX0VORVQxX1JYX0VOIHwKKwkJKE1YU19QQURfOE1BIHwgTVhTX1BBRF8zVjMgfCBNWFNfUEFEX1BVTExVUCksCisJTVgyOF9QQURfRU5FVDBfUlhEMl9fRU5FVDFfUlhEMCB8CisJCShNWFNfUEFEXzhNQSB8IE1YU19QQURfM1YzIHwgTVhTX1BBRF9QVUxMVVApLAorCU1YMjhfUEFEX0VORVQwX1JYRDNfX0VORVQxX1JYRDEgfAorCQkoTVhTX1BBRF84TUEgfCBNWFNfUEFEXzNWMyB8IE1YU19QQURfUFVMTFVQKSwKKwlNWDI4X1BBRF9FTkVUMF9DT0xfX0VORVQxX1RYX0VOIHwKKwkJKE1YU19QQURfOE1BIHwgTVhTX1BBRF8zVjMgfCBNWFNfUEFEX1BVTExVUCksCisJTVgyOF9QQURfRU5FVDBfVFhEMl9fRU5FVDFfVFhEMCB8CisJCShNWFNfUEFEXzhNQSB8IE1YU19QQURfM1YzIHwgTVhTX1BBRF9QVUxMVVApLAorCU1YMjhfUEFEX0VORVQwX1RYRDNfX0VORVQxX1RYRDEgfAorCQkoTVhTX1BBRF84TUEgfCBNWFNfUEFEXzNWMyB8IE1YU19QQURfUFVMTFVQKSwKIAkvKiBwaHkgcG93ZXIgbGluZSAqLwogCU1YMjhfUEFEX1NTUDFfREFUQTNfX0dQSU9fMl8xNSB8CiAJCShNWFNfUEFEXzRNQSB8IE1YU19QQURfM1YzIHwgTVhTX1BBRF9OT1BVTEwpLApAQCAtMTA2LDggKzExOSwxNCBAQAogCWdwaW9fc2V0X3ZhbHVlKE1YMjhFVktfRkVDX1BIWV9SRVNFVCwgMSk7CiB9CiAKLXN0YXRpYyBjb25zdCBzdHJ1Y3QgZmVjX3BsYXRmb3JtX2RhdGEgbXgyOF9mZWNfcGRhdGEgX19pbml0Y29uc3QgPSB7Ci0JLnBoeSA9IFBIWV9JTlRFUkZBQ0VfTU9ERV9STUlJLAorc3RhdGljIHN0cnVjdCBmZWNfcGxhdGZvcm1fZGF0YSBteDI4X2ZlY19wZGF0YVtdID0geworCXsKKwkJLyogZmVjMCAqLworCQkucGh5ID0gUEhZX0lOVEVSRkFDRV9NT0RFX1JNSUksCisJfSwgeworCQkvKiBmZWMxICovCisJCS5waHkgPSBQSFlfSU5URVJGQUNFX01PREVfUk1JSSwKKwl9LAogfTsKIAogc3RhdGljIHZvaWQgX19pbml0IG14MjhldmtfaW5pdCh2b2lkKQpAQCAtMTE3LDcgKzEzNiw4IEBACiAJbXgyOF9hZGRfZHVhcnQoKTsKIAogCW14MjhldmtfZmVjX3Jlc2V0KCk7Ci0JbXgyOF9hZGRfZmVjKDAsICZteDI4X2ZlY19wZGF0YSk7CisJbXgyOF9hZGRfZmVjKDAsICZteDI4X2ZlY19wZGF0YVswXSk7CisJbXgyOF9hZGRfZmVjKDEsICZteDI4X2ZlY19wZGF0YVsxXSk7CiB9CiAKIHN0YXRpYyB2b2lkIF9faW5pdCBteDI4ZXZrX3RpbWVyX2luaXQodm9pZCkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbmV0eC9nZW5lcmljLmMgYi9hcmNoL2FybS9tYWNoLW5ldHgvZ2VuZXJpYy5jCmluZGV4IDQzZGE4YmIuLjI5ZmZhNzUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtbmV0eC9nZW5lcmljLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1uZXR4L2dlbmVyaWMuYwpAQCAtODgsMTMgKzg4LDEzIEBACiB9CiAKIHN0YXRpYyBpbnQKLW5ldHhfaGlmX2lycV90eXBlKHVuc2lnbmVkIGludCBfaXJxLCB1bnNpZ25lZCBpbnQgdHlwZSkKK25ldHhfaGlmX2lycV90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IHR5cGUpCiB7CiAJdW5zaWduZWQgaW50IHZhbCwgaXJxOwogCiAJdmFsID0gcmVhZGwoTkVUWF9EUE1BU19JRl9DT05GMSk7CiAKLQlpcnEgPSBfaXJxIC0gTkVUWF9JUlFfSElGX0NIQUlORUQoMCk7CisJaXJxID0gZC0+aXJxIC0gTkVUWF9JUlFfSElGX0NIQUlORUQoMCk7CiAKIAlpZiAodHlwZSAmIElSUV9UWVBFX0VER0VfUklTSU5HKSB7CiAJCURFQlVHX0lSUSgicmlzaW5nIGVkZ2VzXG4iKTsKQEAgLTExOSw0OSArMTE5LDQ5IEBACiB9CiAKIHN0YXRpYyB2b2lkCi1uZXR4X2hpZl9hY2tfaXJxKHVuc2lnbmVkIGludCBfaXJxKQorbmV0eF9oaWZfYWNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdW5zaWduZWQgaW50IHZhbCwgaXJxOwogCi0JaXJxID0gX2lycSAtIE5FVFhfSVJRX0hJRl9DSEFJTkVEKDApOworCWlycSA9IGQtPmlycSAtIE5FVFhfSVJRX0hJRl9DSEFJTkVEKDApOwogCXdyaXRlbCgoMSA8PCAyNCkgPDwgaXJxLCBORVRYX0RQTUFTX0lOVF9TVEFUKTsKIAogCXZhbCA9IHJlYWRsKE5FVFhfRFBNQVNfSU5UX0VOKTsKIAl2YWwgJj0gfigoMSA8PCAyNCkgPDwgaXJxKTsKIAl3cml0ZWwodmFsLCBORVRYX0RQTUFTX0lOVF9FTik7CiAKLQlERUJVR19JUlEoIiVzOiBpcnEgJWRcbiIsIF9fZnVuY19fLCBfaXJxKTsKKwlERUJVR19JUlEoIiVzOiBpcnEgJWRcbiIsIF9fZnVuY19fLCBkLT5pcnEpOwogfQogCiBzdGF0aWMgdm9pZAotbmV0eF9oaWZfbWFza19pcnEodW5zaWduZWQgaW50IF9pcnEpCituZXR4X2hpZl9tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdW5zaWduZWQgaW50IHZhbCwgaXJxOwogCi0JaXJxID0gX2lycSAtIE5FVFhfSVJRX0hJRl9DSEFJTkVEKDApOworCWlycSA9IGQtPmlycSAtIE5FVFhfSVJRX0hJRl9DSEFJTkVEKDApOwogCXZhbCA9IHJlYWRsKE5FVFhfRFBNQVNfSU5UX0VOKTsKIAl2YWwgJj0gfigoMSA8PCAyNCkgPDwgaXJxKTsKIAl3cml0ZWwodmFsLCBORVRYX0RQTUFTX0lOVF9FTik7Ci0JREVCVUdfSVJRKCIlczogaXJxICVkXG4iLCBfX2Z1bmNfXywgX2lycSk7CisJREVCVUdfSVJRKCIlczogaXJxICVkXG4iLCBfX2Z1bmNfXywgZC0+aXJxKTsKIH0KIAogc3RhdGljIHZvaWQKLW5ldHhfaGlmX3VubWFza19pcnEodW5zaWduZWQgaW50IF9pcnEpCituZXR4X2hpZl91bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl1bnNpZ25lZCBpbnQgdmFsLCBpcnE7CiAKLQlpcnEgPSBfaXJxIC0gTkVUWF9JUlFfSElGX0NIQUlORUQoMCk7CisJaXJxID0gZC0+aXJxIC0gTkVUWF9JUlFfSElGX0NIQUlORUQoMCk7CiAJdmFsID0gcmVhZGwoTkVUWF9EUE1BU19JTlRfRU4pOwogCXZhbCB8PSAoMSA8PCAyNCkgPDwgaXJxOwogCXdyaXRlbCh2YWwsIE5FVFhfRFBNQVNfSU5UX0VOKTsKLQlERUJVR19JUlEoIiVzOiBpcnEgJWRcbiIsIF9fZnVuY19fLCBfaXJxKTsKKwlERUJVR19JUlEoIiVzOiBpcnEgJWRcbiIsIF9fZnVuY19fLCBkLT5pcnEpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG5ldHhfaGlmX2NoaXAgPSB7Ci0JLmFjayA9IG5ldHhfaGlmX2Fja19pcnEsCi0JLm1hc2sgPSBuZXR4X2hpZl9tYXNrX2lycSwKLQkudW5tYXNrID0gbmV0eF9oaWZfdW5tYXNrX2lycSwKLQkuc2V0X3R5cGUgPSBuZXR4X2hpZl9pcnFfdHlwZSwKKwkuaXJxX2FjayA9IG5ldHhfaGlmX2Fja19pcnEsCisJLmlycV9tYXNrID0gbmV0eF9oaWZfbWFza19pcnEsCisJLmlycV91bm1hc2sgPSBuZXR4X2hpZl91bm1hc2tfaXJxLAorCS5pcnFfc2V0X3R5cGUgPSBuZXR4X2hpZl9pcnFfdHlwZSwKIH07CiAKIHZvaWQgX19pbml0IG5ldHhfaW5pdF9pcnEodm9pZCkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbnM5eHh4L2JvYXJkLWE5bTk3NTBkZXYuYyBiL2FyY2gvYXJtL21hY2gtbnM5eHh4L2JvYXJkLWE5bTk3NTBkZXYuYwppbmRleCBiNDViYjNiLi4wYzBkNTI0IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW5zOXh4eC9ib2FyZC1hOW05NzUwZGV2LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1uczl4eHgvYm9hcmQtYTltOTc1MGRldi5jCkBAIC0zNyw0NCArMzcsNDQgQEAKIAkJICAgICBBUlJBWV9TSVpFKGJvYXJkX2E5bTk3NTBkZXZfaW9fZGVzYykpOwogfQogCi1zdGF0aWMgdm9pZCBhOW05NzUwZGV2X2ZwZ2FfYWNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgYTltOTc1MGRldl9mcGdhX2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCS8qIG5vdGhpbmcgKi8KIH0KIAotc3RhdGljIHZvaWQgYTltOTc1MGRldl9mcGdhX21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBhOW05NzUwZGV2X2ZwZ2FfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCXU4IGllcjsKIAogCWllciA9IF9fcmF3X3JlYWRiKEZQR0FfSUVSKTsKIAotCWllciAmPSB+KDEgPDwgKGlycSAtIEZQR0FfSVJRKDApKSk7CisJaWVyICY9IH4oMSA8PCAoZC0+aXJxIC0gRlBHQV9JUlEoMCkpKTsKIAogCV9fcmF3X3dyaXRlYihpZXIsIEZQR0FfSUVSKTsKIH0KIAotc3RhdGljIHZvaWQgYTltOTc1MGRldl9mcGdhX21hc2thY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBhOW05NzUwZGV2X2ZwZ2FfbWFza2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCWE5bTk3NTBkZXZfZnBnYV9tYXNrX2lycShpcnEpOwotCWE5bTk3NTBkZXZfZnBnYV9hY2tfaXJxKGlycSk7CisJYTltOTc1MGRldl9mcGdhX21hc2tfaXJxKGQpOworCWE5bTk3NTBkZXZfZnBnYV9hY2tfaXJxKGQpOwogfQogCi1zdGF0aWMgdm9pZCBhOW05NzUwZGV2X2ZwZ2FfdW5tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgYTltOTc1MGRldl9mcGdhX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCXU4IGllcjsKIAogCWllciA9IF9fcmF3X3JlYWRiKEZQR0FfSUVSKTsKIAotCWllciB8PSAxIDw8IChpcnEgLSBGUEdBX0lSUSgwKSk7CisJaWVyIHw9IDEgPDwgKGQtPmlycSAtIEZQR0FfSVJRKDApKTsKIAogCV9fcmF3X3dyaXRlYihpZXIsIEZQR0FfSUVSKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBhOW05NzUwZGV2X2ZwZ2FfY2hpcCA9IHsKLQkuYWNrCQk9IGE5bTk3NTBkZXZfZnBnYV9hY2tfaXJxLAotCS5tYXNrCQk9IGE5bTk3NTBkZXZfZnBnYV9tYXNrX2lycSwKLQkubWFza19hY2sJPSBhOW05NzUwZGV2X2ZwZ2FfbWFza2Fja19pcnEsCi0JLnVubWFzawkJPSBhOW05NzUwZGV2X2ZwZ2FfdW5tYXNrX2lycSwKKwkuaXJxX2Fjawk9IGE5bTk3NTBkZXZfZnBnYV9hY2tfaXJxLAorCS5pcnFfbWFzawk9IGE5bTk3NTBkZXZfZnBnYV9tYXNrX2lycSwKKwkuaXJxX21hc2tfYWNrCT0gYTltOTc1MGRldl9mcGdhX21hc2thY2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gYTltOTc1MGRldl9mcGdhX3VubWFza19pcnEsCiB9OwogCiBzdGF0aWMgdm9pZCBhOW05NzUwZGV2X2ZwZ2FfZGVtdXhfaGFuZGxlcih1bnNpZ25lZCBpbnQgaXJxLApAQCAtODIsNyArODIsNyBAQAogewogCXU4IHN0YXQgPSBfX3Jhd19yZWFkYihGUEdBX0lTUik7CiAKLQlkZXNjLT5jaGlwLT5tYXNrX2FjayhpcnEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9tYXNrX2FjaygmZGVzYy0+aXJxX2RhdGEpOwogCiAJd2hpbGUgKHN0YXQgIT0gMCkgewogCQlpbnQgaXJxbm8gPSBmbHMoc3RhdCkgLSAxOwpAQCAtOTIsNyArOTIsNyBAQAogCQlnZW5lcmljX2hhbmRsZV9pcnEoRlBHQV9JUlEoaXJxbm8pKTsKIAl9CiAKLQlkZXNjLT5jaGlwLT51bm1hc2soaXJxKTsKKwlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfdW5tYXNrKCZkZXNjLT5pcnFfZGF0YSk7CiB9CiAKIHZvaWQgX19pbml0IGJvYXJkX2E5bTk3NTBkZXZfaW5pdF9pcnEodm9pZCkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtbnM5eHh4L2lycS5jIGIvYXJjaC9hcm0vbWFjaC1uczl4eHgvaXJxLmMKaW5kZXggMDM4ZjI0ZC4uMzg5ZmE1YyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1uczl4eHgvaXJxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1uczl4eHgvaXJxLmMKQEAgLTIyLDQwICsyMiw0MCBAQAogI2RlZmluZSBpcnEycHJpbyhpKSAoaSkKICNkZWZpbmUgcHJpbzJpcnEocCkgKHApCiAKLXN0YXRpYyB2b2lkIG5zOXh4eF9tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbnM5eHh4X21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAkvKiBYWFg6IGJldHRlciB1c2UgY3BwIHN5bWJvbHMgKi8KLQlpbnQgcHJpbyA9IGlycTJwcmlvKGlycSk7CisJaW50IHByaW8gPSBpcnEycHJpbyhkLT5pcnEpOwogCXUzMiBpYyA9IF9fcmF3X3JlYWRsKFNZU19JQyhwcmlvIC8gNCkpOwogCWljICY9IH4oMSA8PCAoNyArIDggKiAoMyAtIChwcmlvICYgMykpKSk7CiAJX19yYXdfd3JpdGVsKGljLCBTWVNfSUMocHJpbyAvIDQpKTsKIH0KIAotc3RhdGljIHZvaWQgbnM5eHh4X2Fja19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG5zOXh4eF9hY2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAlfX3Jhd193cml0ZWwoMCwgU1lTX0lTUkFERFIpOwogfQogCi1zdGF0aWMgdm9pZCBuczl4eHhfbWFza2Fja19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG5zOXh4eF9tYXNrYWNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JbnM5eHh4X21hc2tfaXJxKGlycSk7Ci0JbnM5eHh4X2Fja19pcnEoaXJxKTsKKwluczl4eHhfbWFza19pcnEoZCk7CisJbnM5eHh4X2Fja19pcnEoZCk7CiB9CiAKLXN0YXRpYyB2b2lkIG5zOXh4eF91bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBuczl4eHhfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJLyogWFhYOiBiZXR0ZXIgdXNlIGNwcCBzeW1ib2xzICovCi0JaW50IHByaW8gPSBpcnEycHJpbyhpcnEpOworCWludCBwcmlvID0gaXJxMnByaW8oZC0+aXJxKTsKIAl1MzIgaWMgPSBfX3Jhd19yZWFkbChTWVNfSUMocHJpbyAvIDQpKTsKIAlpYyB8PSAxIDw8ICg3ICsgOCAqICgzIC0gKHByaW8gJiAzKSkpOwogCV9fcmF3X3dyaXRlbChpYywgU1lTX0lDKHByaW8gLyA0KSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbnM5eHh4X2NoaXAgPSB7Ci0JLmFjawkJPSBuczl4eHhfYWNrX2lycSwKLQkubWFzawkJPSBuczl4eHhfbWFza19pcnEsCi0JLm1hc2tfYWNrCT0gbnM5eHh4X21hc2thY2tfaXJxLAotCS51bm1hc2sJCT0gbnM5eHh4X3VubWFza19pcnEsCisJLmlycV9hY2sJPSBuczl4eHhfYWNrX2lycSwKKwkuaXJxX21hc2sJPSBuczl4eHhfbWFza19pcnEsCisJLmlycV9tYXNrX2Fjawk9IG5zOXh4eF9tYXNrYWNrX2lycSwKKwkuaXJxX3VubWFzawk9IG5zOXh4eF91bm1hc2tfaXJxLAogfTsKIAogI2lmIDAKQEAgLTkyLDEwICs5MiwxMCBAQAogCiAJaWYgKGRlc2MtPnN0YXR1cyAmIElSUV9ESVNBQkxFRCkKIG91dF9tYXNrOgotCQlkZXNjLT5jaGlwLT5tYXNrKGlycSk7CisJCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9tYXNrKCZkZXNjLT5pcnFfZGF0YSk7CiAKIAkvKiBhY2sgdW5jb25kaXRpb25hbGx5IHRvIHVubWFzayBsb3dlciBwcmlvIGlycXMgKi8KLQlkZXNjLT5jaGlwLT5hY2soaXJxKTsKKwlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfYWNrKCZkZXNjLT5pcnFfZGF0YSk7CiAKIAlyYXdfc3Bpbl91bmxvY2soJmRlc2MtPmxvY2spOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1udWM5M3gvaXJxLmMgYi9hcmNoL2FybS9tYWNoLW51YzkzeC9pcnEuYwppbmRleCBhN2E4OGVhLi4xZjhhMDVhIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW51YzkzeC9pcnEuYworKysgYi9hcmNoL2FybS9tYWNoLW51YzkzeC9pcnEuYwpAQCAtMjUsOSArMjUsOSBAQAogI2luY2x1ZGUgPG1hY2gvaGFyZHdhcmUuaD4KICNpbmNsdWRlIDxtYWNoL3JlZ3MtaXJxLmg+CiAKLXN0YXRpYyB2b2lkIG51YzkzeF9pcnFfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbnVjOTN4X2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlfX3Jhd193cml0ZWwoMSA8PCBpcnEsIFJFR19BSUNfTURDUik7CisJX19yYXdfd3JpdGVsKDEgPDwgZC0+aXJxLCBSRUdfQUlDX01EQ1IpOwogfQogCiAvKgpAQCAtMzUsMjEgKzM1LDIxIEBACiAgKiB0byBSRUdfQUlDX0VPU0NSIGZvciBBQ0sKICAqLwogCi1zdGF0aWMgdm9pZCBudWM5M3hfaXJxX2Fjayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbnVjOTN4X2lycV9hY2soc3RydWN0IGlycV9kYXRhICpkKQogewogCV9fcmF3X3dyaXRlbCgweDAxLCBSRUdfQUlDX0VPU0NSKTsKIH0KIAotc3RhdGljIHZvaWQgbnVjOTN4X2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG51YzkzeF9pcnFfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlfX3Jhd193cml0ZWwoMSA8PCBpcnEsIFJFR19BSUNfTUVDUik7CisJX19yYXdfd3JpdGVsKDEgPDwgZC0+aXJxLCBSRUdfQUlDX01FQ1IpOwogCiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbnVjOTN4X2lycV9jaGlwID0gewotCS5hY2sJICAgPSBudWM5M3hfaXJxX2FjaywKLQkubWFzawkgICA9IG51YzkzeF9pcnFfbWFzaywKLQkudW5tYXNrCSAgID0gbnVjOTN4X2lycV91bm1hc2ssCisJLmlycV9hY2sJPSBudWM5M3hfaXJxX2FjaywKKwkuaXJxX21hc2sJPSBudWM5M3hfaXJxX21hc2ssCisJLmlycV91bm1hc2sJPSBudWM5M3hfaXJxX3VubWFzaywKIH07CiAKIHZvaWQgX19pbml0IG51YzkzeF9pbml0X2lycSh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMS9LY29uZmlnIGIvYXJjaC9hcm0vbWFjaC1vbWFwMS9LY29uZmlnCmluZGV4IDhkMmYyZGEuLmUwYTAyODEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDEvS2NvbmZpZworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAxL0tjb25maWcKQEAgLTksNiArOSw3IEBACiAJZGVwZW5kcyBvbiBBUkNIX09NQVAxCiAJYm9vbCAiT01BUDczMCBCYXNlZCBTeXN0ZW0iCiAJc2VsZWN0IENQVV9BUk05MjZUCisJc2VsZWN0IE9NQVBfTVBVX1RJTUVSCiAJc2VsZWN0IEFSQ0hfT01BUF9PVEcKIAogY29uZmlnIEFSQ0hfT01BUDg1MApAQCAtMjIsNiArMjMsNyBAQAogCWRlZmF1bHQgeQogCWJvb2wgIk9NQVAxNXh4IEJhc2VkIFN5c3RlbSIKIAlzZWxlY3QgQ1BVX0FSTTkyNVQKKwlzZWxlY3QgT01BUF9NUFVfVElNRVIKIAogY29uZmlnIEFSQ0hfT01BUDE2WFgKIAlkZXBlbmRzIG9uIEFSQ0hfT01BUDEKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDEvTWFrZWZpbGUgYi9hcmNoL2FybS9tYWNoLW9tYXAxL01ha2VmaWxlCmluZGV4IDZlZTE5NTAuLmJhNjAwOWYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDEvTWFrZWZpbGUKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMS9NYWtlZmlsZQpAQCAtMywxMiArMywxMSBAQAogIwogCiAjIENvbW1vbiBzdXBwb3J0Ci1vYmoteSA6PSBpby5vIGlkLm8gc3JhbS5vIGlycS5vIG11eC5vIGZsYXNoLm8gc2VyaWFsLm8gZGV2aWNlcy5vIGRtYS5vCitvYmoteSA6PSBpby5vIGlkLm8gc3JhbS5vIHRpbWUubyBpcnEubyBtdXgubyBmbGFzaC5vIHNlcmlhbC5vIGRldmljZXMubyBkbWEubwogb2JqLXkgKz0gY2xvY2subyBjbG9ja19kYXRhLm8gb3BwX2RhdGEubwogCiBvYmotJChDT05GSUdfT01BUF9NQ0JTUCkgKz0gbWNic3AubwogCi1vYmotJChDT05GSUdfT01BUF9NUFVfVElNRVIpCSs9IHRpbWUubwogb2JqLSQoQ09ORklHX09NQVBfMzJLX1RJTUVSKQkrPSB0aW1lcjMyay5vCiAKICMgUG93ZXIgTWFuYWdlbWVudApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMS9hbXMtZGVsdGEtZmlxLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAxL2Ftcy1kZWx0YS1maXEuYwppbmRleCA2Yzk5NGUyLi4xNTJiMzJjIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAxL2Ftcy1kZWx0YS1maXEuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAxL2Ftcy1kZWx0YS1maXEuYwpAQCAtNDksNyArNDksNyBAQAogCiAJaXJxX2Rlc2MgPSBpcnFfdG9fZGVzYyhJSF9HUElPX0JBU0UpOwogCWlmIChpcnFfZGVzYykKLQkJaXJxX2NoaXAgPSBpcnFfZGVzYy0+Y2hpcDsKKwkJaXJxX2NoaXAgPSBpcnFfZGVzYy0+aXJxX2RhdGEuY2hpcDsKIAogCS8qCiAJICogRm9yIGVhY2ggaGFuZGxlZCBHUElPIGludGVycnVwdCwga2VlcCBjYWxsaW5nIGl0cyBpbnRlcnJ1cHQgaGFuZGxlcgpAQCAtNjIsMTMgKzYyLDE1IEBACiAKIAkJd2hpbGUgKGlycV9jb3VudGVyW2dwaW9dIDwgZmlxX2NvdW50KSB7CiAJCQlpZiAoZ3BpbyAhPSBBTVNfREVMVEFfR1BJT19QSU5fS0VZQlJEX0NMSykgeworCQkJCXN0cnVjdCBpcnFfZGF0YSAqZCA9IGlycV9nZXRfaXJxX2RhdGEoaXJxX251bSk7CisKIAkJCQkvKgogCQkJCSAqIEl0IGxvb2tzIGxpa2UgaGFuZGxlX2VkZ2VfaXJxKCkgdGhhdAogCQkJCSAqIE9NQVAgR1BJTyBlZGdlIGludGVycnVwdHMgZGVmYXVsdCB0bywKIAkJCQkgKiBleHBlY3RzIGludGVycnVwdCBhbHJlYWR5IHVubWFza2VkLgogCQkJCSAqLwotCQkJCWlmIChpcnFfY2hpcCAmJiBpcnFfY2hpcC0+dW5tYXNrKQotCQkJCQlpcnFfY2hpcC0+dW5tYXNrKGlycV9udW0pOworCQkJCWlmIChpcnFfY2hpcCAmJiBpcnFfY2hpcC0+aXJxX3VubWFzaykKKwkJCQkJaXJxX2NoaXAtPmlycV91bm1hc2soZCk7CiAJCQl9CiAJCQlnZW5lcmljX2hhbmRsZV9pcnEoaXJxX251bSk7CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDEvYm9hcmQtYW1zLWRlbHRhLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAxL2JvYXJkLWFtcy1kZWx0YS5jCmluZGV4IGJkMDQ5NWEuLjIyY2M4YzggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDEvYm9hcmQtYW1zLWRlbHRhLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMS9ib2FyZC1hbXMtZGVsdGEuYwpAQCAtMTc5LDYgKzE3OSwyMiBAQAogCXsgT01BUF9UQUdfTENELAkJJmFtc19kZWx0YV9sY2RfY29uZmlnIH0sCiB9OwogCitzdGF0aWMgc3RydWN0IHJlc291cmNlIGFtc19kZWx0YV9uYW5kX3Jlc291cmNlc1tdID0geworCVswXSA9IHsKKwkJLnN0YXJ0CT0gT01BUDFfTVBVSU9fQkFTRSwKKwkJLmVuZAk9IE9NQVAxX01QVUlPX0JBU0UgKworCQkJCU9NQVBfTVBVSU9fSU9fQ05UTCArIHNpemVvZih1MzIpIC0gMSwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9NRU0sCisJfSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGFtc19kZWx0YV9uYW5kX2RldmljZSA9IHsKKwkubmFtZQk9ICJhbXMtZGVsdGEtbmFuZCIsCisJLmlkCT0gLTEsCisJLm51bV9yZXNvdXJjZXMJPSBBUlJBWV9TSVpFKGFtc19kZWx0YV9uYW5kX3Jlc291cmNlcyksCisJLnJlc291cmNlCT0gYW1zX2RlbHRhX25hbmRfcmVzb3VyY2VzLAorfTsKKwogc3RhdGljIHN0cnVjdCByZXNvdXJjZSBhbXNfZGVsdGFfa3BfcmVzb3VyY2VzW10gPSB7CiAJWzBdID0gewogCQkuc3RhcnQJPSBJTlRfS0VZQk9BUkQsCkBAIC0yNjUsNiArMjgxLDcgQEAKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICphbXNfZGVsdGFfZGV2aWNlc1tdIF9faW5pdGRhdGEgPSB7CisJJmFtc19kZWx0YV9uYW5kX2RldmljZSwKIAkmYW1zX2RlbHRhX2twX2RldmljZSwKIAkmYW1zX2RlbHRhX2xjZF9kZXZpY2UsCiAJJmFtc19kZWx0YV9sZWRfZGV2aWNlLApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMS9mcGdhLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAxL2ZwZ2EuYwppbmRleCA4NzgwZTc1Li4wYWNlNzk5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAxL2ZwZ2EuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAxL2ZwZ2EuYwpAQCAtMzAsOSArMzAsOSBAQAogI2luY2x1ZGUgPHBsYXQvZnBnYS5oPgogI2luY2x1ZGUgPG1hY2gvZ3Bpby5oPgogCi1zdGF0aWMgdm9pZCBmcGdhX21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBmcGdhX21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpcnEgLT0gT01BUF9GUEdBX0lSUV9CQVNFOworCXVuc2lnbmVkIGludCBpcnEgPSBkLT5pcnEgLSBPTUFQX0ZQR0FfSVJRX0JBU0U7CiAKIAlpZiAoaXJxIDwgOCkKIAkJX19yYXdfd3JpdGViKChfX3Jhd19yZWFkYihPTUFQMTUxMF9GUEdBX0lNUl9MTykKQEAgLTU4LDE0ICs1OCwxNCBAQAogfQogCiAKLXN0YXRpYyB2b2lkIGZwZ2FfYWNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgZnBnYV9hY2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAkvKiBEb24ndCBuZWVkIHRvIGV4cGxpY2l0bHkgQUNLIEZQR0EgaW50ZXJydXB0cyAqLwogfQogCi1zdGF0aWMgdm9pZCBmcGdhX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGZwZ2FfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaXJxIC09IE9NQVBfRlBHQV9JUlFfQkFTRTsKKwl1bnNpZ25lZCBpbnQgaXJxID0gZC0+aXJxIC0gT01BUF9GUEdBX0lSUV9CQVNFOwogCiAJaWYgKGlycSA8IDgpCiAJCV9fcmF3X3dyaXRlYigoX19yYXdfcmVhZGIoT01BUDE1MTBfRlBHQV9JTVJfTE8pIHwgKDEgPDwgaXJxKSksCkBAIC03OCwxMCArNzgsMTAgQEAKIAkJCSAgICAgIHwgKDEgPDwgKGlycSAtIDE2KSkpLCBJTk5PVkFUT1JfRlBHQV9JTVIyKTsKIH0KIAotc3RhdGljIHZvaWQgZnBnYV9tYXNrX2Fja19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGZwZ2FfbWFza19hY2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlmcGdhX21hc2tfaXJxKGlycSk7Ci0JZnBnYV9hY2tfaXJxKGlycSk7CisJZnBnYV9tYXNrX2lycShkKTsKKwlmcGdhX2Fja19pcnEoZCk7CiB9CiAKIHZvaWQgaW5ub3ZhdG9yX2ZwZ2FfSVJRX2RlbXV4KHVuc2lnbmVkIGludCBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKQEAgLTEwNSwxNyArMTA1LDE3IEBACiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgb21hcF9mcGdhX2lycV9hY2sgPSB7CiAJLm5hbWUJCT0gIkZQR0EtYWNrIiwKLQkuYWNrCQk9IGZwZ2FfbWFza19hY2tfaXJxLAotCS5tYXNrCQk9IGZwZ2FfbWFza19pcnEsCi0JLnVubWFzawkJPSBmcGdhX3VubWFza19pcnEsCisJLmlycV9hY2sJPSBmcGdhX21hc2tfYWNrX2lycSwKKwkuaXJxX21hc2sJPSBmcGdhX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gZnBnYV91bm1hc2tfaXJxLAogfTsKIAogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG9tYXBfZnBnYV9pcnEgPSB7CiAJLm5hbWUJCT0gIkZQR0EiLAotCS5hY2sJCT0gZnBnYV9hY2tfaXJxLAotCS5tYXNrCQk9IGZwZ2FfbWFza19pcnEsCi0JLnVubWFzawkJPSBmcGdhX3VubWFza19pcnEsCisJLmlycV9hY2sJPSBmcGdhX2Fja19pcnEsCisJLmlycV9tYXNrCT0gZnBnYV9tYXNrX2lycSwKKwkuaXJxX3VubWFzawk9IGZwZ2FfdW5tYXNrX2lycSwKIH07CiAKIC8qCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAxL2luY2x1ZGUvbWFjaC9lbnRyeS1tYWNyby5TIGIvYXJjaC9hcm0vbWFjaC1vbWFwMS9pbmNsdWRlL21hY2gvZW50cnktbWFjcm8uUwppbmRleCBjOWJlNmQ0Li5iZmI0ZmIxIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAxL2luY2x1ZGUvbWFjaC9lbnRyeS1tYWNyby5TCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDEvaW5jbHVkZS9tYWNoL2VudHJ5LW1hY3JvLlMKQEAgLTE0LDE5ICsxNCw2IEBACiAjaW5jbHVkZSA8bWFjaC9pcnFzLmg+CiAjaW5jbHVkZSA8YXNtL2hhcmR3YXJlL2dpYy5oPgogCi0vKgotICogV2UgdXNlIF9fZ2x1ZSB0byBhdm9pZCBlcnJvcnMgd2l0aCBtdWx0aXBsZSBkZWZpbml0aW9ucyBvZgotICogLmdsb2JsIG9tYXBfaXJxX2ZsYWdzIGFzIGl0J3MgaW5jbHVkZWQgZnJvbSBlbnRyeS1hcm12LlMgYnV0IG5vdAotICogZnJvbSBlbnRyeS1jb21tb24uUy4KLSAqLwotI2lmZGVmIF9fZ2x1ZQotCQkucHVzaHNlY3Rpb24gLmRhdGEKLQkJLmdsb2JsCW9tYXBfaXJxX2ZsYWdzCi1vbWFwX2lycV9mbGFnczoKLQkJLndvcmQJMAotCQkucG9wc2VjdGlvbgotI2VuZGlmCi0KICAJCS5tYWNybwlkaXNhYmxlX2ZpcQogCQkuZW5kbQogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAxL2lycS5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMS9pcnEuYwppbmRleCA2YmRkYmM4Li43MzFkZDMzIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAxL2lycS5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDEvaXJxLmMKQEAgLTU3LDYgKzU3LDcgQEAKIAl1bnNpZ25lZCBsb25nIHdha2VfZW5hYmxlOwogfTsKIAordTMyIG9tYXBfaXJxX2ZsYWdzOwogc3RhdGljIHVuc2lnbmVkIGludCBpcnFfYmFua19jb3VudDsKIHN0YXRpYyBzdHJ1Y3Qgb21hcF9pcnFfYmFuayAqaXJxX2JhbmtzOwogCkBAIC03MCw0OCArNzEsNDggQEAKIAlvbWFwX3dyaXRlbCh2YWx1ZSwgaXJxX2JhbmtzW2JhbmtdLmJhc2VfcmVnICsgb2Zmc2V0KTsKIH0KIAotc3RhdGljIHZvaWQgb21hcF9hY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBvbWFwX2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCWlmIChpcnEgPiAzMSkKKwlpZiAoZC0+aXJxID4gMzEpCiAJCW9tYXBfd3JpdGVsKDB4MSwgT01BUF9JSDJfQkFTRSArIElSUV9DT05UUk9MX1JFR19PRkZTRVQpOwogCiAJb21hcF93cml0ZWwoMHgxLCBPTUFQX0lIMV9CQVNFICsgSVJRX0NPTlRST0xfUkVHX09GRlNFVCk7CiB9CiAKLXN0YXRpYyB2b2lkIG9tYXBfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG9tYXBfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCWludCBiYW5rID0gSVJRX0JBTksoaXJxKTsKKwlpbnQgYmFuayA9IElSUV9CQU5LKGQtPmlycSk7CiAJdTMyIGw7CiAKIAlsID0gb21hcF9yZWFkbChpcnFfYmFua3NbYmFua10uYmFzZV9yZWcgKyBJUlFfTUlSX1JFR19PRkZTRVQpOwotCWwgfD0gMSA8PCBJUlFfQklUKGlycSk7CisJbCB8PSAxIDw8IElSUV9CSVQoZC0+aXJxKTsKIAlvbWFwX3dyaXRlbChsLCBpcnFfYmFua3NbYmFua10uYmFzZV9yZWcgKyBJUlFfTUlSX1JFR19PRkZTRVQpOwogfQogCi1zdGF0aWMgdm9pZCBvbWFwX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG9tYXBfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaW50IGJhbmsgPSBJUlFfQkFOSyhpcnEpOworCWludCBiYW5rID0gSVJRX0JBTksoZC0+aXJxKTsKIAl1MzIgbDsKIAogCWwgPSBvbWFwX3JlYWRsKGlycV9iYW5rc1tiYW5rXS5iYXNlX3JlZyArIElSUV9NSVJfUkVHX09GRlNFVCk7Ci0JbCAmPSB+KDEgPDwgSVJRX0JJVChpcnEpKTsKKwlsICY9IH4oMSA8PCBJUlFfQklUKGQtPmlycSkpOwogCW9tYXBfd3JpdGVsKGwsIGlycV9iYW5rc1tiYW5rXS5iYXNlX3JlZyArIElSUV9NSVJfUkVHX09GRlNFVCk7CiB9CiAKLXN0YXRpYyB2b2lkIG9tYXBfbWFza19hY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBvbWFwX21hc2tfYWNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jb21hcF9tYXNrX2lycShpcnEpOwotCW9tYXBfYWNrX2lycShpcnEpOworCW9tYXBfbWFza19pcnEoZCk7CisJb21hcF9hY2tfaXJxKGQpOwogfQogCi1zdGF0aWMgaW50IG9tYXBfd2FrZV9pcnEodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IGVuYWJsZSkKK3N0YXRpYyBpbnQgb21hcF93YWtlX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCBlbmFibGUpCiB7Ci0JaW50IGJhbmsgPSBJUlFfQkFOSyhpcnEpOworCWludCBiYW5rID0gSVJRX0JBTksoZC0+aXJxKTsKIAogCWlmIChlbmFibGUpCi0JCWlycV9iYW5rc1tiYW5rXS53YWtlX2VuYWJsZSB8PSBJUlFfQklUKGlycSk7CisJCWlycV9iYW5rc1tiYW5rXS53YWtlX2VuYWJsZSB8PSBJUlFfQklUKGQtPmlycSk7CiAJZWxzZQotCQlpcnFfYmFua3NbYmFua10ud2FrZV9lbmFibGUgJj0gfklSUV9CSVQoaXJxKTsKKwkJaXJxX2JhbmtzW2JhbmtdLndha2VfZW5hYmxlICY9IH5JUlFfQklUKGQtPmlycSk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTE2OCwxNSArMTY5LDE0IEBACiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgb21hcF9pcnFfY2hpcCA9IHsKIAkubmFtZQkJPSAiTVBVIiwKLQkuYWNrCQk9IG9tYXBfbWFza19hY2tfaXJxLAotCS5tYXNrCQk9IG9tYXBfbWFza19pcnEsCi0JLnVubWFzawkJPSBvbWFwX3VubWFza19pcnEsCi0JLnNldF93YWtlCT0gb21hcF93YWtlX2lycSwKKwkuaXJxX2Fjawk9IG9tYXBfbWFza19hY2tfaXJxLAorCS5pcnFfbWFzawk9IG9tYXBfbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBvbWFwX3VubWFza19pcnEsCisJLmlycV9zZXRfd2FrZQk9IG9tYXBfd2FrZV9pcnEsCiB9OwogCiB2b2lkIF9faW5pdCBvbWFwX2luaXRfaXJxKHZvaWQpCiB7Ci0JZXh0ZXJuIHVuc2lnbmVkIGludCBvbWFwX2lycV9mbGFnczsKIAlpbnQgaSwgajsKIAogI2lmIGRlZmluZWQoQ09ORklHX0FSQ0hfT01BUDczMCkgfHwgZGVmaW5lZChDT05GSUdfQVJDSF9PTUFQODUwKQpAQCAtMjM5LDkgKzIzOSw5IEBACiAJLyogVW5tYXNrIGxldmVsIDIgaGFuZGxlciAqLwogCiAJaWYgKGNwdV9pc19vbWFwN3h4KCkpCi0JCW9tYXBfdW5tYXNrX2lycShJTlRfN1hYX0lIMl9JUlEpOworCQlvbWFwX3VubWFza19pcnEoaXJxX2dldF9pcnFfZGF0YShJTlRfN1hYX0lIMl9JUlEpKTsKIAllbHNlIGlmIChjcHVfaXNfb21hcDE1eHgoKSkKLQkJb21hcF91bm1hc2tfaXJxKElOVF8xNTEwX0lIMl9JUlEpOworCQlvbWFwX3VubWFza19pcnEoaXJxX2dldF9pcnFfZGF0YShJTlRfMTUxMF9JSDJfSVJRKSk7CiAJZWxzZSBpZiAoY3B1X2lzX29tYXAxNnh4KCkpCi0JCW9tYXBfdW5tYXNrX2lycShJTlRfMTYxMF9JSDJfSVJRKTsKKwkJb21hcF91bm1hc2tfaXJxKGlycV9nZXRfaXJxX2RhdGEoSU5UXzE2MTBfSUgyX0lSUSkpOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMS9sY2RfZG1hLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAxL2xjZF9kbWEuYwppbmRleCBjOTA4OGQ4Li40NTM4MDkzIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAxL2xjZF9kbWEuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAxL2xjZF9kbWEuYwpAQCAtMzcsNyArMzcsNyBAQAogCSAqIE9uIE9NQVAxNTEwLCBpbnRlcm5hbCBMQ0QgY29udHJvbGxlciB3aWxsIHN0YXJ0IHRoZSB0cmFuc2ZlcgogCSAqIHdoZW4gaXQgZ2V0cyBlbmFibGVkLCBzbyBhc3N1bWUgRE1BIHJ1bm5pbmcgaWYgTENEIGVuYWJsZWQuCiAJICovCi0JaWYgKGNwdV9pc19vbWFwMTUxMCgpKQorCWlmIChjcHVfaXNfb21hcDE1eHgoKSkKIAkJaWYgKG9tYXBfcmVhZHcoT01BUF9MQ0RDX0NPTlRST0wpICYgT01BUF9MQ0RDX0NUUkxfTENEX0VOKQogCQkJcmV0dXJuIDE7CiAKQEAgLTk1LDcgKzk1LDcgQEAKIAogdm9pZCBvbWFwX3NldF9sY2RfZG1hX2IxX3JvdGF0aW9uKGludCByb3RhdGUpCiB7Ci0JaWYgKGNwdV9pc19vbWFwMTUxMCgpKSB7CisJaWYgKGNwdV9pc19vbWFwMTV4eCgpKSB7CiAJCXByaW50ayhLRVJOX0VSUiAiRE1BIHJvdGF0aW9uIGlzIG5vdCBzdXBwb3J0ZWQgaW4gMTUxMCBtb2RlXG4iKTsKIAkJQlVHKCk7CiAJCXJldHVybjsKQEAgLTEwNiw3ICsxMDYsNyBAQAogCiB2b2lkIG9tYXBfc2V0X2xjZF9kbWFfYjFfbWlycm9yKGludCBtaXJyb3IpCiB7Ci0JaWYgKGNwdV9pc19vbWFwMTUxMCgpKSB7CisJaWYgKGNwdV9pc19vbWFwMTV4eCgpKSB7CiAJCXByaW50ayhLRVJOX0VSUiAiRE1BIG1pcnJvciBpcyBub3Qgc3VwcG9ydGVkIGluIDE1MTAgbW9kZVxuIik7CiAJCUJVRygpOwogCX0KQEAgLTExNiw3ICsxMTYsNyBAQAogCiB2b2lkIG9tYXBfc2V0X2xjZF9kbWFfYjFfdnhyZXModW5zaWduZWQgbG9uZyB2eHJlcykKIHsKLQlpZiAoY3B1X2lzX29tYXAxNTEwKCkpIHsKKwlpZiAoY3B1X2lzX29tYXAxNXh4KCkpIHsKIAkJcHJpbnRrKEtFUk5fRVJSICJETUEgdmlydHVhbCByZXN1bG90aW9uIGlzIG5vdCBzdXBwb3J0ZWQgIgogCQkJCSJpbiAxNTEwIG1vZGVcbiIpOwogCQlCVUcoKTsKQEAgLTEyNyw3ICsxMjcsNyBAQAogCiB2b2lkIG9tYXBfc2V0X2xjZF9kbWFfYjFfc2NhbGUodW5zaWduZWQgaW50IHhzY2FsZSwgdW5zaWduZWQgaW50IHlzY2FsZSkKIHsKLQlpZiAoY3B1X2lzX29tYXAxNTEwKCkpIHsKKwlpZiAoY3B1X2lzX29tYXAxNXh4KCkpIHsKIAkJcHJpbnRrKEtFUk5fRVJSICJETUEgc2NhbGUgaXMgbm90IHN1cHBvcnRlZCBpbiAxNTEwIG1vZGVcbiIpOwogCQlCVUcoKTsKIAl9CkBAIC0xNzcsNyArMTc3LDcgQEAKIAkJCWJvdHRvbSA9IFBJWEFERFIobGNkX2RtYS54cmVzIC0gMSwgbGNkX2RtYS55cmVzIC0gMSk7CiAJCQkvKiAxNTEwIERNQSByZXF1aXJlcyB0aGUgYm90dG9tIGFkZHJlc3MgdG8gYmUgMiBtb3JlCiAJCQkgKiB0aGFuIHRoZSBhY3R1YWwgbGFzdCBtZW1vcnkgYWNjZXNzIGxvY2F0aW9uLiAqLwotCQkJaWYgKGNwdV9pc19vbWFwMTUxMCgpICYmCisJCQlpZiAoY3B1X2lzX29tYXAxNXh4KCkgJiYKIAkJCQlsY2RfZG1hLmRhdGFfdHlwZSA9PSBPTUFQX0RNQV9EQVRBX1RZUEVfUzMyKQogCQkJCQlib3R0b20gKz0gMjsKIAkJCWVpID0gUElYU1RFUCgwLCAwLCAxLCAwKTsKQEAgLTI0MSw3ICsyNDEsNyBAQAogCQlyZXR1cm47CS8qIFN1cHByZXNzIHdhcm5pbmcgYWJvdXQgdW5pbml0aWFsaXplZCB2YXJzICovCiAJfQogCi0JaWYgKGNwdV9pc19vbWFwMTUxMCgpKSB7CisJaWYgKGNwdV9pc19vbWFwMTV4eCgpKSB7CiAJCW9tYXBfd3JpdGV3KHRvcCA+PiAxNiwgT01BUDE1MTBfRE1BX0xDRF9UT1BfRjFfVSk7CiAJCW9tYXBfd3JpdGV3KHRvcCwgT01BUDE1MTBfRE1BX0xDRF9UT1BfRjFfTCk7CiAJCW9tYXBfd3JpdGV3KGJvdHRvbSA+PiAxNiwgT01BUDE1MTBfRE1BX0xDRF9CT1RfRjFfVSk7CkBAIC0zNDMsNyArMzQzLDcgQEAKIAkJQlVHKCk7CiAJCXJldHVybjsKIAl9Ci0JaWYgKCFjcHVfaXNfb21hcDE1MTAoKSkKKwlpZiAoIWNwdV9pc19vbWFwMTV4eCgpKQogCQlvbWFwX3dyaXRldyhvbWFwX3JlYWR3KE9NQVAxNjEwX0RNQV9MQ0RfQ0NSKSAmIH4xLAogCQkJICAgIE9NQVAxNjEwX0RNQV9MQ0RfQ0NSKTsKIAlsY2RfZG1hLnJlc2VydmVkID0gMDsKQEAgLTM2MCw3ICszNjAsNyBAQAogCSAqIGNvbm5lY3RlZC4gT3RoZXJ3aXNlIHRoZSBPTUFQIGludGVybmFsIGNvbnRyb2xsZXIgd2lsbAogCSAqIHN0YXJ0IHRoZSB0cmFuc2ZlciB3aGVuIGl0IGdldHMgZW5hYmxlZC4KIAkgKi8KLQlpZiAoY3B1X2lzX29tYXAxNTEwKCkgfHwgIWxjZF9kbWEuZXh0X2N0cmwpCisJaWYgKGNwdV9pc19vbWFwMTV4eCgpIHx8ICFsY2RfZG1hLmV4dF9jdHJsKQogCQlyZXR1cm47CiAKIAl3ID0gb21hcF9yZWFkdyhPTUFQMTYxMF9ETUFfTENEX0NUUkwpOwpAQCAtMzc4LDE0ICszNzgsMTQgQEAKIHZvaWQgb21hcF9zZXR1cF9sY2RfZG1hKHZvaWQpCiB7CiAJQlVHX09OKGxjZF9kbWEuYWN0aXZlKTsKLQlpZiAoIWNwdV9pc19vbWFwMTUxMCgpKSB7CisJaWYgKCFjcHVfaXNfb21hcDE1eHgoKSkgewogCQkvKiBTZXQgc29tZSByZWFzb25hYmxlIGRlZmF1bHRzICovCiAJCW9tYXBfd3JpdGV3KDB4NTQ0MCwgT01BUDE2MTBfRE1BX0xDRF9DQ1IpOwogCQlvbWFwX3dyaXRldygweDkxMDIsIE9NQVAxNjEwX0RNQV9MQ0RfQ1NEUCk7CiAJCW9tYXBfd3JpdGV3KDB4MDAwNCwgT01BUDE2MTBfRE1BX0xDRF9MQ0hfQ1RSTCk7CiAJfQogCXNldF9iMV9yZWdzKCk7Ci0JaWYgKCFjcHVfaXNfb21hcDE1MTAoKSkgeworCWlmICghY3B1X2lzX29tYXAxNXh4KCkpIHsKIAkJdTE2IHc7CiAKIAkJdyA9IG9tYXBfcmVhZHcoT01BUDE2MTBfRE1BX0xDRF9DQ1IpOwpAQCAtNDA3LDcgKzQwNyw3IEBACiAJdTE2IHc7CiAKIAlsY2RfZG1hLmFjdGl2ZSA9IDA7Ci0JaWYgKGNwdV9pc19vbWFwMTUxMCgpIHx8ICFsY2RfZG1hLmV4dF9jdHJsKQorCWlmIChjcHVfaXNfb21hcDE1eHgoKSB8fCAhbGNkX2RtYS5leHRfY3RybCkKIAkJcmV0dXJuOwogCiAJdyA9IG9tYXBfcmVhZHcoT01BUDE2MTBfRE1BX0xDRF9DQ1IpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMS90aW1lLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAxL3RpbWUuYwppbmRleCBlZDdhNjFmLi42ODg1ZDJmIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAxL3RpbWUuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAxL3RpbWUuYwpAQCAtNDksMTEgKzQ5LDE1IEBACiAjaW5jbHVkZSA8bWFjaC9oYXJkd2FyZS5oPgogI2luY2x1ZGUgPGFzbS9sZWRzLmg+CiAjaW5jbHVkZSA8YXNtL2lycS5oPgorI2luY2x1ZGUgPGFzbS9zY2hlZF9jbG9jay5oPgorCiAjaW5jbHVkZSA8YXNtL21hY2gvaXJxLmg+CiAjaW5jbHVkZSA8YXNtL21hY2gvdGltZS5oPgogCiAjaW5jbHVkZSA8cGxhdC9jb21tb24uaD4KIAorI2lmZGVmIENPTkZJR19PTUFQX01QVV9USU1FUgorCiAjZGVmaW5lIE9NQVBfTVBVX1RJTUVSX0JBU0UJCU9NQVBfTVBVX1RJTUVSMV9CQVNFCiAjZGVmaW5lIE9NQVBfTVBVX1RJTUVSX09GRlNFVAkJMHgxMDAKIApAQCAtNjcsNyArNzEsNyBAQAogKCh2b2xhdGlsZSBvbWFwX21wdV90aW1lcl9yZWdzX3QqKU9NQVAxX0lPX0FERFJFU1MoT01BUF9NUFVfVElNRVJfQkFTRSArCVwKIAkJCQkgKG4pKk9NQVBfTVBVX1RJTUVSX09GRlNFVCkpCiAKLXN0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyBvbWFwX21wdV90aW1lcl9yZWFkKGludCBucikKK3N0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyBub3RyYWNlIG9tYXBfbXB1X3RpbWVyX3JlYWQoaW50IG5yKQogewogCXZvbGF0aWxlIG9tYXBfbXB1X3RpbWVyX3JlZ3NfdCogdGltZXIgPSBvbWFwX21wdV90aW1lcl9iYXNlKG5yKTsKIAlyZXR1cm4gdGltZXItPnJlYWRfdGltOwpAQCAtMjEyLDYgKzIxNiwzMiBAQAogCS5mbGFncwkJPSBDTE9DS19TT1VSQ0VfSVNfQ09OVElOVU9VUywKIH07CiAKK3N0YXRpYyBERUZJTkVfQ0xPQ0tfREFUQShjZCk7CisKK3N0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyBsb25nIG5vdHJhY2UgX29tYXBfbXB1X3NjaGVkX2Nsb2NrKHZvaWQpCit7CisJdTMyIGN5YyA9IG1wdV9yZWFkKCZjbG9ja3NvdXJjZV9tcHUpOworCXJldHVybiBjeWNfdG9fc2NoZWRfY2xvY2soJmNkLCBjeWMsICh1MzIpfjApOworfQorCisjaWZuZGVmIENPTkZJR19PTUFQXzMyS19USU1FUgordW5zaWduZWQgbG9uZyBsb25nIG5vdHJhY2Ugc2NoZWRfY2xvY2sodm9pZCkKK3sKKwlyZXR1cm4gX29tYXBfbXB1X3NjaGVkX2Nsb2NrKCk7Cit9CisjZWxzZQorc3RhdGljIHVuc2lnbmVkIGxvbmcgbG9uZyBub3RyYWNlIG9tYXBfbXB1X3NjaGVkX2Nsb2NrKHZvaWQpCit7CisJcmV0dXJuIF9vbWFwX21wdV9zY2hlZF9jbG9jaygpOworfQorI2VuZGlmCisKK3N0YXRpYyB2b2lkIG5vdHJhY2UgbXB1X3VwZGF0ZV9zY2hlZF9jbG9jayh2b2lkKQoreworCXUzMiBjeWMgPSBtcHVfcmVhZCgmY2xvY2tzb3VyY2VfbXB1KTsKKwl1cGRhdGVfc2NoZWRfY2xvY2soJmNkLCBjeWMsICh1MzIpfjApOworfQorCiBzdGF0aWMgdm9pZCBfX2luaXQgb21hcF9pbml0X2Nsb2Nrc291cmNlKHVuc2lnbmVkIGxvbmcgcmF0ZSkKIHsKIAlzdGF0aWMgY2hhciBlcnJbXSBfX2luaXRkYXRhID0gS0VSTl9FUlIKQEAgLTIxOSwxNyArMjQ5LDEzIEBACiAKIAlzZXR1cF9pcnEoSU5UX1RJTUVSMiwgJm9tYXBfbXB1X3RpbWVyMl9pcnEpOwogCW9tYXBfbXB1X3RpbWVyX3N0YXJ0KDEsIH4wLCAxKTsKKwlpbml0X3NjaGVkX2Nsb2NrKCZjZCwgbXB1X3VwZGF0ZV9zY2hlZF9jbG9jaywgMzIsIHJhdGUpOwogCiAJaWYgKGNsb2Nrc291cmNlX3JlZ2lzdGVyX2h6KCZjbG9ja3NvdXJjZV9tcHUsIHJhdGUpKQogCQlwcmludGsoZXJyLCBjbG9ja3NvdXJjZV9tcHUubmFtZSk7CiB9CiAKLS8qCi0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSAqIFRpbWVyIGluaXRpYWxpemF0aW9uCi0gKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLSAqLwotc3RhdGljIHZvaWQgX19pbml0IG9tYXBfdGltZXJfaW5pdCh2b2lkKQorc3RhdGljIHZvaWQgX19pbml0IG9tYXBfbXB1X3RpbWVyX2luaXQodm9pZCkKIHsKIAlzdHJ1Y3QgY2xrCSpja19yZWYgPSBjbGtfZ2V0KE5VTEwsICJja19yZWYiKTsKIAl1bnNpZ25lZCBsb25nCXJhdGU7CkBAIC0yNDYsNiArMjcyLDY2IEBACiAJb21hcF9pbml0X2Nsb2Nrc291cmNlKHJhdGUpOwogfQogCisjZWxzZQorc3RhdGljIGlubGluZSB2b2lkIG9tYXBfbXB1X3RpbWVyX2luaXQodm9pZCkKK3sKKwlwcl9lcnIoIkJvZ3VzIHRpbWVyLCBzaG91bGQgbm90IGhhcHBlblxuIik7Cit9CisjZW5kaWYJLyogQ09ORklHX09NQVBfTVBVX1RJTUVSICovCisKKyNpZiBkZWZpbmVkKENPTkZJR19PTUFQX01QVV9USU1FUikgJiYgZGVmaW5lZChDT05GSUdfT01BUF8zMktfVElNRVIpCitzdGF0aWMgdW5zaWduZWQgbG9uZyBsb25nICgqcHJlZmVycmVkX3NjaGVkX2Nsb2NrKSh2b2lkKTsKKwordW5zaWduZWQgbG9uZyBsb25nIG5vdHJhY2Ugc2NoZWRfY2xvY2sodm9pZCkKK3sKKwlpZiAoIXByZWZlcnJlZF9zY2hlZF9jbG9jaykKKwkJcmV0dXJuIDA7CisKKwlyZXR1cm4gcHJlZmVycmVkX3NjaGVkX2Nsb2NrKCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBwcmVmZXJyZWRfc2NoZWRfY2xvY2tfaW5pdChib29sIHVzZV8zMmtfc2NoZWRfY2xvY2spCit7CisJaWYgKHVzZV8zMmtfc2NoZWRfY2xvY2spCisJCXByZWZlcnJlZF9zY2hlZF9jbG9jayA9IG9tYXBfMzJrX3NjaGVkX2Nsb2NrOworCWVsc2UKKwkJcHJlZmVycmVkX3NjaGVkX2Nsb2NrID0gb21hcF9tcHVfc2NoZWRfY2xvY2s7Cit9CisjZWxzZQorc3RhdGljIGlubGluZSB2b2lkIHByZWZlcnJlZF9zY2hlZF9jbG9ja19pbml0KGJvb2wgdXNlXzMya19zY2hlZF9jbGNvaykKK3sKK30KKyNlbmRpZgorCitzdGF0aWMgaW5saW5lIGludCBvbWFwXzMya190aW1lcl91c2FibGUodm9pZCkKK3sKKwlpbnQgcmVzID0gZmFsc2U7CisKKwlpZiAoY3B1X2lzX29tYXA3MzAoKSB8fCBjcHVfaXNfb21hcDE1eHgoKSkKKwkJcmV0dXJuIHJlczsKKworI2lmZGVmIENPTkZJR19PTUFQXzMyS19USU1FUgorCXJlcyA9IG9tYXBfMzJrX3RpbWVyX2luaXQoKTsKKyNlbmRpZgorCisJcmV0dXJuIHJlczsKK30KKworLyoKKyAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICogVGltZXIgaW5pdGlhbGl6YXRpb24KKyAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICovCitzdGF0aWMgdm9pZCBfX2luaXQgb21hcF90aW1lcl9pbml0KHZvaWQpCit7CisJaWYgKG9tYXBfMzJrX3RpbWVyX3VzYWJsZSgpKSB7CisJCXByZWZlcnJlZF9zY2hlZF9jbG9ja19pbml0KDEpOworCX0gZWxzZSB7CisJCW9tYXBfbXB1X3RpbWVyX2luaXQoKTsKKwkJcHJlZmVycmVkX3NjaGVkX2Nsb2NrX2luaXQoMCk7CisJfQorfQorCiBzdHJ1Y3Qgc3lzX3RpbWVyIG9tYXBfdGltZXIgPSB7CiAJLmluaXQJCT0gb21hcF90aW1lcl9pbml0LAogfTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDEvdGltZXIzMmsuYyBiL2FyY2gvYXJtL21hY2gtb21hcDEvdGltZXIzMmsuYwppbmRleCAyMGNmYmNjLi4xM2Q3YjhmIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAxL3RpbWVyMzJrLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMS90aW1lcjMyay5jCkBAIC01MiwxMCArNTIsOSBAQAogI2luY2x1ZGUgPGFzbS9pcnEuaD4KICNpbmNsdWRlIDxhc20vbWFjaC9pcnEuaD4KICNpbmNsdWRlIDxhc20vbWFjaC90aW1lLmg+CisjaW5jbHVkZSA8cGxhdC9jb21tb24uaD4KICNpbmNsdWRlIDxwbGF0L2RtdGltZXIuaD4KIAotc3RydWN0IHN5c190aW1lciBvbWFwX3RpbWVyOwotCiAvKgogICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKiAzMktIeiBPUyB0aW1lcgpAQCAtMTgxLDE0ICsxODAsMTQgQEAKICAqIFRpbWVyIGluaXRpYWxpemF0aW9uCiAgKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICAqLwotc3RhdGljIHZvaWQgX19pbml0IG9tYXBfdGltZXJfaW5pdCh2b2lkKQorYm9vbCBfX2luaXQgb21hcF8zMmtfdGltZXJfaW5pdCh2b2lkKQogeworCW9tYXBfaW5pdF9jbG9ja3NvdXJjZV8zMmsoKTsKKwogI2lmZGVmIENPTkZJR19PTUFQX0RNX1RJTUVSCiAJb21hcF9kbV90aW1lcl9pbml0KCk7CiAjZW5kaWYKIAlvbWFwX2luaXRfMzJrX3RpbWVyKCk7Ci19CiAKLXN0cnVjdCBzeXNfdGltZXIgb21hcF90aW1lciA9IHsKLQkuaW5pdAkJPSBvbWFwX3RpbWVyX2luaXQsCi19OworCXJldHVybiB0cnVlOworfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9ib2FyZC00NDMwc2RwLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLTQ0MzBzZHAuYwppbmRleCBhNzBiZGYyLi4wN2QxYjIwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLTQ0MzBzZHAuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLTQ0MzBzZHAuYwpAQCAtNTU0LDYgKzU1NCw3IEBACiAKICNpZmRlZiBDT05GSUdfT01BUF9NVVgKIHN0YXRpYyBzdHJ1Y3Qgb21hcF9ib2FyZF9tdXggYm9hcmRfbXV4W10gX19pbml0ZGF0YSA9IHsKKwlPTUFQNF9NVVgoVVNCQjJfVUxQSVRMTF9DTEssIE9NQVBfTVVYX01PREU0IHwgT01BUF9QSU5fT1VUUFVUKSwKIAl7IC5yZWdfb2Zmc2V0ID0gT01BUF9NVVhfVEVSTUlOQVRPUiB9LAogfTsKICNlbHNlCkBAIC01NzYsMTEgKzU3NywxMiBAQAogCW9tYXA0X3R3bDYwMzBfaHNtbWNfaW5pdChtbWMpOwogCiAJLyogUG93ZXIgb24gdGhlIFVMUEkgUEhZICovCi0JaWYgKGdwaW9faXNfdmFsaWQoT01BUDRTRFBfTURNX1BXUl9FTl9HUElPKSkgewotCQkvKiBGSVhNRTogQXNzdW1lcyBwYWQgaXMgYWxyZWFkeSBtdXhlZCBmb3IgR1BJTyBtb2RlICovCi0JCWdwaW9fcmVxdWVzdChPTUFQNFNEUF9NRE1fUFdSX0VOX0dQSU8sICJVU0JCMSBQSFkgVk1ETV8zVjMiKTsKKwlzdGF0dXMgPSBncGlvX3JlcXVlc3QoT01BUDRTRFBfTURNX1BXUl9FTl9HUElPLCAiVVNCQjEgUEhZIFZNRE1fM1YzIik7CisJaWYgKHN0YXR1cykKKwkJcHJfZXJyKCIlczogQ291bGQgbm90IGdldCBVU0JCMSBQSFkgR1BJT1xuIiwgX19mdW5jX18pOworCWVsc2UKIAkJZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KE9NQVA0U0RQX01ETV9QV1JfRU5fR1BJTywgMSk7Ci0JfQorCiAJdXNiX2VoY2lfaW5pdCgmZWhjaV9wZGF0YSk7CiAJdXNiX211c2JfaW5pdCgmbXVzYl9ib2FyZF9kYXRhKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9ib2FyZC1jbS10MzUxNy5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9ib2FyZC1jbS10MzUxNy5jCmluZGV4IDViMGM3NzcuLjhmOWE2NGQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtY20tdDM1MTcuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLWNtLXQzNTE3LmMKQEAgLTEyNCw4ICsxMjQsOSBAQAogI2lmIGRlZmluZWQoQ09ORklHX1JUQ19EUlZfVjMwMjApIHx8IGRlZmluZWQoQ09ORklHX1JUQ19EUlZfVjMwMjBfTU9EVUxFKQogI2RlZmluZSBSVENfSU9fR1BJTwkJKDE1MykKICNkZWZpbmUgUlRDX1dSX0dQSU8JCSgxNTQpCi0jZGVmaW5lIFJUQ19SRF9HUElPCQkoMTYwKQorI2RlZmluZSBSVENfUkRfR1BJTwkJKDUzKQogI2RlZmluZSBSVENfQ1NfR1BJTwkJKDE2MykKKyNkZWZpbmUgUlRDX0NTX0VOX0dQSU8JCSgxNjApCiAKIHN0cnVjdCB2MzAyMF9wbGF0Zm9ybV9kYXRhIGNtX3QzNTE3X3YzMDIwX3BkYXRhID0gewogCS51c2VfZ3Bpbwk9IDEsCkBAIC0xNDUsNiArMTQ2LDE2IEBACiAKIHN0YXRpYyB2b2lkIF9faW5pdCBjbV90MzUxN19pbml0X3J0Yyh2b2lkKQogeworCWludCBlcnI7CisKKwllcnIgPSBncGlvX3JlcXVlc3QoUlRDX0NTX0VOX0dQSU8sICJydGMgY3MgZW4iKTsKKwlpZiAoZXJyKSB7CisJCXByX2VycigiQ00tVDM1MTc6IHJ0YyBjcyBlbiBncGlvIHJlcXVlc3QgZmFpbGVkOiAlZFxuIiwgZXJyKTsKKwkJcmV0dXJuOworCX0KKworCWdwaW9fZGlyZWN0aW9uX291dHB1dChSVENfQ1NfRU5fR1BJTywgMSk7CisKIAlwbGF0Zm9ybV9kZXZpY2VfcmVnaXN0ZXIoJmNtX3QzNTE3X3J0Y19kZXZpY2UpOwogfQogI2Vsc2UKQEAgLTIxNCwxMiArMjI1LDEyIEBACiAJfSwKIAl7CiAJCS5uYW1lICAgICAgICAgICA9ICJsaW51eCIsCi0JCS5vZmZzZXQgICAgICAgICA9IE1URFBBUlRfT0ZTX0FQUEVORCwJLyogT2Zmc2V0ID0gMHgyODAwMDAgKi8KKwkJLm9mZnNldCAgICAgICAgID0gTVREUEFSVF9PRlNfQVBQRU5ELAkvKiBPZmZzZXQgPSAweDJBMDAwMCAqLwogCQkuc2l6ZSAgICAgICAgICAgPSAzMiAqIE5BTkRfQkxPQ0tfU0laRSwKIAl9LAogCXsKIAkJLm5hbWUgICAgICAgICAgID0gInJvb3RmcyIsCi0JCS5vZmZzZXQgICAgICAgICA9IE1URFBBUlRfT0ZTX0FQUEVORCwJLyogT2Zmc2V0ID0gMHg2ODAwMDAgKi8KKwkJLm9mZnNldCAgICAgICAgID0gTVREUEFSVF9PRlNfQVBQRU5ELAkvKiBPZmZzZXQgPSAweDZBMDAwMCAqLwogCQkuc2l6ZSAgICAgICAgICAgPSBNVERQQVJUX1NJWl9GVUxMLAogCX0sCiB9OwpAQCAtMjU2LDExICsyNjcsMTkgQEAKIHN0YXRpYyBzdHJ1Y3Qgb21hcF9ib2FyZF9tdXggYm9hcmRfbXV4W10gX19pbml0ZGF0YSA9IHsKIAkvKiBHUElPMTg2IC0gR3JlZW4gTEVEICovCiAJT01BUDNfTVVYKFNZU19DTEtPVVQyLCBPTUFQX01VWF9NT0RFNCB8IE9NQVBfUElOX09VVFBVVCksCi0JLyogUlRDIEdQSU9zOiBJTywgV1IjLCBSRCMsIENTIyAqLworCisJLyogUlRDIEdQSU9zOiAqLworCS8qIElPIC0gR1BJTzE1MyAqLwogCU9NQVAzX01VWChNQ0JTUDRfRFIsIE9NQVBfTVVYX01PREU0IHwgT01BUF9QSU5fSU5QVVQpLAorCS8qIFdSIyAtIEdQSU8xNTQgKi8KIAlPTUFQM19NVVgoTUNCU1A0X0RYLCBPTUFQX01VWF9NT0RFNCB8IE9NQVBfUElOX0lOUFVUKSwKLQlPTUFQM19NVVgoTUNCU1BfQ0xLUywgT01BUF9NVVhfTU9ERTQgfCBPTUFQX1BJTl9JTlBVVCksCisJLyogUkQjIC0gR1BJTzUzICovCisJT01BUDNfTVVYKEdQTUNfTkNTMiwgT01BUF9NVVhfTU9ERTQgfCBPTUFQX1BJTl9JTlBVVCksCisJLyogQ1MjIC0gR1BJTzE2MyAqLwogCU9NQVAzX01VWChVQVJUM19DVFNfUkNUWCwgT01BUF9NVVhfTU9ERTQgfCBPTUFQX1BJTl9JTlBVVCksCisJLyogQ1MgRU4gLSBHUElPMTYwICovCisJT01BUDNfTVVYKE1DQlNQX0NMS1MsIE9NQVBfTVVYX01PREU0IHwgT01BUF9QSU5fSU5QVVQpLAorCiAJLyogSFNVU0IxIFJFU0VUICovCiAJT01BUDNfTVVYKFVBUlQyX1RYLCBPTUFQX01VWF9NT0RFNCB8IE9NQVBfUElOX09VVFBVVCksCiAJLyogSFNVU0IyIFJFU0VUICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLWRldmtpdDgwMDAuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtZGV2a2l0ODAwMC5jCmluZGV4IDAwYmIxZmMuLjlhMmEzMWUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtZGV2a2l0ODAwMC5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtZGV2a2l0ODAwMC5jCkBAIC0xMTUsOSArMTE1LDYgQEAKIAogc3RhdGljIGludCBkZXZraXQ4MDAwX3BhbmVsX2VuYWJsZV9sY2Qoc3RydWN0IG9tYXBfZHNzX2RldmljZSAqZHNzZGV2KQogewotCXR3bF9pMmNfd3JpdGVfdTgoVFdMNDAzMF9NT0RVTEVfR1BJTywgMHg4MCwgUkVHX0dQSU9EQVRBRElSMSk7Ci0JdHdsX2kyY193cml0ZV91OChUV0w0MDMwX01PRFVMRV9MRUQsIDB4MCwgMHgwKTsKLQogCWlmIChncGlvX2lzX3ZhbGlkKGRzc2Rldi0+cmVzZXRfZ3BpbykpCiAJCWdwaW9fc2V0X3ZhbHVlX2NhbnNsZWVwKGRzc2Rldi0+cmVzZXRfZ3BpbywgMSk7CiAJcmV0dXJuIDA7CkBAIC0yNDcsNiArMjQ0LDggQEAKIHN0YXRpYyBpbnQgZGV2a2l0ODAwMF90d2xfZ3Bpb19zZXR1cChzdHJ1Y3QgZGV2aWNlICpkZXYsCiAJCXVuc2lnbmVkIGdwaW8sIHVuc2lnbmVkIG5ncGlvKQogeworCWludCByZXQ7CisKIAlvbWFwX211eF9pbml0X2dwaW8oMjksIE9NQVBfUElOX0lOUFVUKTsKIAkvKiBncGlvICsgMCBpcyAibW1jMF9jZCIgKGlucHV0L0lSUSkgKi8KIAltbWNbMF0uZ3Bpb19jZCA9IGdwaW8gKyAwOwpAQCAtMjU1LDE3ICsyNTQsMjMgQEAKIAkvKiBUV0w0MDMwX0dQSU9fTUFYICsgMSA9PSBsZWRCLCBQTVVfU1RBVCAob3V0LCBhY3RpdmUgbG93IExFRCkgKi8KIAlncGlvX2xlZHNbMl0uZ3BpbyA9IGdwaW8gKyBUV0w0MDMwX0dQSU9fTUFYICsgMTsKIAotICAgICAgICAvKiBncGlvICsgMSBpcyAiTENEX1BXUkVOIiAob3V0LCBhY3RpdmUgaGlnaCkgKi8KLQlkZXZraXQ4MDAwX2xjZF9kZXZpY2UucmVzZXRfZ3BpbyA9IGdwaW8gKyAxOwotCWdwaW9fcmVxdWVzdChkZXZraXQ4MDAwX2xjZF9kZXZpY2UucmVzZXRfZ3BpbywgIkxDRF9QV1JFTiIpOwotCS8qIERpc2FibGUgdW50aWwgbmVlZGVkICovCi0JZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KGRldmtpdDgwMDBfbGNkX2RldmljZS5yZXNldF9ncGlvLCAwKTsKKwkvKiBUV0w0MDMwX0dQSU9fTUFYICsgMCBpcyAiTENEX1BXUkVOIiAob3V0LCBhY3RpdmUgaGlnaCkgKi8KKwlkZXZraXQ4MDAwX2xjZF9kZXZpY2UucmVzZXRfZ3BpbyA9IGdwaW8gKyBUV0w0MDMwX0dQSU9fTUFYICsgMDsKKwlyZXQgPSBncGlvX3JlcXVlc3Rfb25lKGRldmtpdDgwMDBfbGNkX2RldmljZS5yZXNldF9ncGlvLAorCQkJR1BJT0ZfRElSX09VVCB8IEdQSU9GX0lOSVRfTE9XLCAiTENEX1BXUkVOIik7CisJaWYgKHJldCA8IDApIHsKKwkJZGV2a2l0ODAwMF9sY2RfZGV2aWNlLnJlc2V0X2dwaW8gPSAtRUlOVkFMOworCQlwcmludGsoS0VSTl9FUlIgIkZhaWxlZCB0byByZXF1ZXN0IEdQSU8gZm9yIExDRF9QV1JOXG4iKTsKKwl9CiAKIAkvKiBncGlvICsgNyBpcyAiRFZJX1BEIiAob3V0LCBhY3RpdmUgbG93KSAqLwogCWRldmtpdDgwMDBfZHZpX2RldmljZS5yZXNldF9ncGlvID0gZ3BpbyArIDc7Ci0JZ3Bpb19yZXF1ZXN0KGRldmtpdDgwMDBfZHZpX2RldmljZS5yZXNldF9ncGlvLCAiRFZJIFBvd2VyRG93biIpOwotCS8qIERpc2FibGUgdW50aWwgbmVlZGVkICovCi0JZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KGRldmtpdDgwMDBfZHZpX2RldmljZS5yZXNldF9ncGlvLCAwKTsKKwlyZXQgPSBncGlvX3JlcXVlc3Rfb25lKGRldmtpdDgwMDBfZHZpX2RldmljZS5yZXNldF9ncGlvLAorCQkJR1BJT0ZfRElSX09VVCB8IEdQSU9GX0lOSVRfTE9XLCAiRFZJIFBvd2VyRG93biIpOworCWlmIChyZXQgPCAwKSB7CisJCWRldmtpdDgwMDBfZHZpX2RldmljZS5yZXNldF9ncGlvID0gLUVJTlZBTDsKKwkJcHJpbnRrKEtFUk5fRVJSICJGYWlsZWQgdG8gcmVxdWVzdCBHUElPIGZvciBEVkkgUG93ZXJEb3duXG4iKTsKKwl9CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTI3NSw4ICsyODAsNyBAQAogCS5pcnFfYmFzZQk9IFRXTDQwMzBfR1BJT19JUlFfQkFTRSwKIAkuaXJxX2VuZAk9IFRXTDQwMzBfR1BJT19JUlFfRU5ELAogCS51c2VfbGVkcwk9IHRydWUsCi0JLnB1bGx1cHMJPSBCSVQoMSksCi0JLnB1bGxkb3ducwk9IEJJVCgyKSB8IEJJVCg2KSB8IEJJVCg3KSB8IEJJVCg4KSB8IEJJVCgxMykKKwkucHVsbGRvd25zCT0gQklUKDEpIHwgQklUKDIpIHwgQklUKDYpIHwgQklUKDgpIHwgQklUKDEzKQogCQkJCXwgQklUKDE1KSB8IEJJVCgxNikgfCBCSVQoMTcpLAogCS5zZXR1cAkJPSBkZXZraXQ4MDAwX3R3bF9ncGlvX3NldHVwLAogfTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtaWdlcDAwMjAuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtaWdlcDAwMjAuYwppbmRleCBlYmFhMjMwLi4zYmU4NWExIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLWlnZXAwMDIwLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9ib2FyZC1pZ2VwMDAyMC5jCkBAIC0xNyw2ICsxNyw3IEBACiAjaW5jbHVkZSA8bGludXgvaW8uaD4KICNpbmNsdWRlIDxsaW51eC9ncGlvLmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CisjaW5jbHVkZSA8bGludXgvaW5wdXQuaD4KIAogI2luY2x1ZGUgPGxpbnV4L3JlZ3VsYXRvci9tYWNoaW5lLmg+CiAjaW5jbHVkZSA8bGludXgvcmVndWxhdG9yL2ZpeGVkLmg+CkBAIC01NDEsNiArNTQyLDM3IEBACiAJLmF1ZGlvID0gJmlnZXAyX2F1ZGlvX2RhdGEsCiB9OwogCitzdGF0aWMgaW50IGlnZXAyX2tleW1hcFtdID0geworCUtFWSgwLCAwLCBLRVlfTEVGVCksCisJS0VZKDAsIDEsIEtFWV9SSUdIVCksCisJS0VZKDAsIDIsIEtFWV9BKSwKKwlLRVkoMCwgMywgS0VZX0IpLAorCUtFWSgxLCAwLCBLRVlfRE9XTiksCisJS0VZKDEsIDEsIEtFWV9VUCksCisJS0VZKDEsIDIsIEtFWV9FKSwKKwlLRVkoMSwgMywgS0VZX0YpLAorCUtFWSgyLCAwLCBLRVlfRU5URVIpLAorCUtFWSgyLCAxLCBLRVlfSSksCisJS0VZKDIsIDIsIEtFWV9KKSwKKwlLRVkoMiwgMywgS0VZX0spLAorCUtFWSgzLCAwLCBLRVlfTSksCisJS0VZKDMsIDEsIEtFWV9OKSwKKwlLRVkoMywgMiwgS0VZX08pLAorCUtFWSgzLCAzLCBLRVlfUCkKK307CisKK3N0YXRpYyBzdHJ1Y3QgbWF0cml4X2tleW1hcF9kYXRhIGlnZXAyX2tleW1hcF9kYXRhID0geworCS5rZXltYXAJCQk9IGlnZXAyX2tleW1hcCwKKwkua2V5bWFwX3NpemUJCT0gQVJSQVlfU0laRShpZ2VwMl9rZXltYXApLAorfTsKKworc3RhdGljIHN0cnVjdCB0d2w0MDMwX2tleXBhZF9kYXRhIGlnZXAyX2tleXBhZF9wZGF0YSA9IHsKKwkua2V5bWFwX2RhdGEJPSAmaWdlcDJfa2V5bWFwX2RhdGEsCisJLnJvd3MJCT0gNCwKKwkuY29scwkJPSA0LAorCS5yZXAJCT0gMSwKK307CisKIHN0YXRpYyBzdHJ1Y3QgdHdsNDAzMF9wbGF0Zm9ybV9kYXRhIGlnZXAyX3R3bGRhdGEgPSB7CiAJLmlycV9iYXNlCT0gVFdMNDAzMF9JUlFfQkFTRSwKIAkuaXJxX2VuZAk9IFRXTDQwMzBfSVJRX0VORCwKQEAgLTU0OSw2ICs1ODEsNyBAQAogCS51c2IJCT0gJmlnZXAyX3VzYl9kYXRhLAogCS5jb2RlYwkJPSAmaWdlcDJfY29kZWNfZGF0YSwKIAkuZ3BpbwkJPSAmaWdlcDJfdHdsNDAzMF9ncGlvX3BkYXRhLAorCS5rZXlwYWQJCT0gJmlnZXAyX2tleXBhZF9wZGF0YSwKIAkudm1tYzEgICAgICAgICAgPSAmaWdlcDJfdm1tYzEsCiAJLnZwbGwyCQk9ICZpZ2VwMl92cGxsMiwKIAkudmlvCQk9ICZpZ2VwMl92aW8sCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLWlnZXAwMDMwLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLWlnZXAwMDMwLmMKaW5kZXggYmNjY2Q2OC4uNGRjNjJhOSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9ib2FyZC1pZ2VwMDAzMC5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtaWdlcDAwMzAuYwpAQCAtMTksNiArMTksNyBAQAogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogCiAjaW5jbHVkZSA8bGludXgvcmVndWxhdG9yL21hY2hpbmUuaD4KKyNpbmNsdWRlIDxsaW51eC9yZWd1bGF0b3IvZml4ZWQuaD4KICNpbmNsdWRlIDxsaW51eC9pMmMvdHdsLmg+CiAjaW5jbHVkZSA8bGludXgvbW1jL2hvc3QuaD4KIApAQCAtNDMsNyArNDQsNyBAQAogI2RlZmluZSBJR0VQM19HUElPX1dJRklfTlJFU0VUCTEzOQogI2RlZmluZSBJR0VQM19HUElPX0JUX05SRVNFVAkxMzcKIAotI2RlZmluZSBJR0VQM19HUElPX1VTQkhfTlJFU0VUICAxMTUKKyNkZWZpbmUgSUdFUDNfR1BJT19VU0JIX05SRVNFVCAgMTgzCiAKIAogI2lmIGRlZmluZWQoQ09ORklHX01URF9PTkVOQU5EX09NQVAyKSB8fCBcCkBAIC0xMDMsNyArMTA0LDcgQEAKIAl9LAogfTsKIAotdm9pZCBfX2luaXQgaWdlcDNfZmxhc2hfaW5pdCh2b2lkKQorc3RhdGljIHZvaWQgX19pbml0IGlnZXAzX2ZsYXNoX2luaXQodm9pZCkKIHsKIAl1OCBjcyA9IDA7CiAJdTggb25lbmFuZGNzID0gR1BNQ19DU19OVU0gKyAxOwpAQCAtMTM3LDEyICsxMzgsMTEgQEAKIH0KIAogI2Vsc2UKLXZvaWQgX19pbml0IGlnZXAzX2ZsYXNoX2luaXQodm9pZCkge30KK3N0YXRpYyB2b2lkIF9faW5pdCBpZ2VwM19mbGFzaF9pbml0KHZvaWQpIHt9CiAjZW5kaWYKIAotc3RhdGljIHN0cnVjdCByZWd1bGF0b3JfY29uc3VtZXJfc3VwcGx5IGlnZXAzX3ZtbWMxX3N1cHBseSA9IHsKLQkuc3VwcGx5CQk9ICJ2bW1jIiwKLX07CitzdGF0aWMgc3RydWN0IHJlZ3VsYXRvcl9jb25zdW1lcl9zdXBwbHkgaWdlcDNfdm1tYzFfc3VwcGx5ID0KKwlSRUdVTEFUT1JfU1VQUExZKCJ2bW1jIiwgIm1tY2ktb21hcC1ocy4wIik7CiAKIC8qIFZNTUMxIGZvciBPTUFQIFZERF9NTUMxIChpL28pIGFuZCBNTUMxIGNhcmQgKi8KIHN0YXRpYyBzdHJ1Y3QgcmVndWxhdG9yX2luaXRfZGF0YSBpZ2VwM192bW1jMSA9IHsKQEAgLTE1OSw2ICsxNTksNTIgQEAKIAkuY29uc3VtZXJfc3VwcGxpZXMgICAgICA9ICZpZ2VwM192bW1jMV9zdXBwbHksCiB9OwogCitzdGF0aWMgc3RydWN0IHJlZ3VsYXRvcl9jb25zdW1lcl9zdXBwbHkgaWdlcDNfdmlvX3N1cHBseSA9CisJUkVHVUxBVE9SX1NVUFBMWSgidm1tY19hdXgiLCAibW1jaS1vbWFwLWhzLjEiKTsKKworc3RhdGljIHN0cnVjdCByZWd1bGF0b3JfaW5pdF9kYXRhIGlnZXAzX3ZpbyA9IHsKKwkuY29uc3RyYWludHMgPSB7CisJCS5taW5fdVYJCQk9IDE4MDAwMDAsCisJCS5tYXhfdVYJCQk9IDE4MDAwMDAsCisJCS5hcHBseV91VgkJPSAxLAorCQkudmFsaWRfbW9kZXNfbWFzawk9IFJFR1VMQVRPUl9NT0RFX05PUk1BTAorCQkJCQl8IFJFR1VMQVRPUl9NT0RFX1NUQU5EQlksCisJCS52YWxpZF9vcHNfbWFzawkJPSBSRUdVTEFUT1JfQ0hBTkdFX1ZPTFRBR0UKKwkJCQkJfCBSRUdVTEFUT1JfQ0hBTkdFX01PREUKKwkJCQkJfCBSRUdVTEFUT1JfQ0hBTkdFX1NUQVRVUywKKwl9LAorCS5udW1fY29uc3VtZXJfc3VwcGxpZXMJPSAxLAorCS5jb25zdW1lcl9zdXBwbGllcwk9ICZpZ2VwM192aW9fc3VwcGx5LAorfTsKKworc3RhdGljIHN0cnVjdCByZWd1bGF0b3JfY29uc3VtZXJfc3VwcGx5IGlnZXAzX3ZtbWMyX3N1cHBseSA9CisJUkVHVUxBVE9SX1NVUFBMWSgidm1tYyIsICJtbWNpLW9tYXAtaHMuMSIpOworCitzdGF0aWMgc3RydWN0IHJlZ3VsYXRvcl9pbml0X2RhdGEgaWdlcDNfdm1tYzIgPSB7CisJLmNvbnN0cmFpbnRzCT0geworCQkudmFsaWRfbW9kZXNfbWFzawk9IFJFR1VMQVRPUl9NT0RFX05PUk1BTCwKKwkJLmFsd2F5c19vbgkJPSAxLAorCX0sCisJLm51bV9jb25zdW1lcl9zdXBwbGllcwk9IDEsCisJLmNvbnN1bWVyX3N1cHBsaWVzCT0gJmlnZXAzX3ZtbWMyX3N1cHBseSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgZml4ZWRfdm9sdGFnZV9jb25maWcgaWdlcDNfdndsYW4gPSB7CisJLnN1cHBseV9uYW1lCQk9ICJ2d2xhbiIsCisJLm1pY3Jvdm9sdHMJCT0gMzMwMDAwMCwKKwkuZ3BpbwkJCT0gLUVJTlZBTCwKKwkuZW5hYmxlZF9hdF9ib290CT0gMSwKKwkuaW5pdF9kYXRhCQk9ICZpZ2VwM192bW1jMiwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGlnZXAzX3Z3bGFuX2RldmljZSA9IHsKKwkubmFtZQk9ICJyZWctZml4ZWQtdm9sdGFnZSIsCisJLmlkCT0gMCwKKwkuZGV2CT0geworCQkucGxhdGZvcm1fZGF0YSA9ICZpZ2VwM192d2xhbiwKKwl9LAorfTsKKwogc3RhdGljIHN0cnVjdCBvbWFwMl9oc21tY19pbmZvIG1tY1tdID0gewogCVswXSA9IHsKIAkJLm1tYwkJPSAxLApAQCAtMjU0LDEyICszMDAsNiBAQAogCW1tY1swXS5ncGlvX2NkID0gZ3BpbyArIDA7CiAJb21hcDJfaHNtbWNfaW5pdChtbWMpOwogCi0JLyoKLQkgKiBsaW5rIHJlZ3VsYXRvcnMgdG8gTU1DIGFkYXB0ZXJzIC4uLiB3ZSAia25vdyIgdGhlCi0JICogcmVndWxhdG9ycyB3aWxsIGJlIHNldCB1cCBvbmx5ICphZnRlciogd2UgcmV0dXJuLgotCSAqLwotCWlnZXAzX3ZtbWMxX3N1cHBseS5kZXYgPSBtbWNbMF0uZGV2OwotCiAJLyogVFdMNDAzMF9HUElPX01BWCArIDEgPT0gbGVkQiAob3V0LCBhY3RpdmUgbG93IExFRCkgKi8KICNpZiAhZGVmaW5lZChDT05GSUdfTEVEU19HUElPKSAmJiAhZGVmaW5lZChDT05GSUdfTEVEU19HUElPX01PRFVMRSkKIAlpZiAoKGdwaW9fcmVxdWVzdChncGlvK1RXTDQwMzBfR1BJT19NQVgrMSwgImdwaW8tbGVkOmdyZWVuOmQxIikgPT0gMCkKQEAgLTI4Nyw2ICszMjcsMTAgQEAKIAkudXNiX21vZGUJPSBUMl9VU0JfTU9ERV9VTFBJLAogfTsKIAorc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKmlnZXAzX2RldmljZXNbXSBfX2luaXRkYXRhID0geworCSZpZ2VwM192d2xhbl9kZXZpY2UsCit9OworCiBzdGF0aWMgdm9pZCBfX2luaXQgaWdlcDNfaW5pdF9pcnEodm9pZCkKIHsKIAlvbWFwMl9pbml0X2NvbW1vbl9pbmZyYXN0cnVjdHVyZSgpOwpAQCAtMzAzLDYgKzM0Nyw3IEBACiAJLnVzYgkJPSAmaWdlcDNfdHdsNDAzMF91c2JfZGF0YSwKIAkuZ3BpbwkJPSAmaWdlcDNfdHdsNDAzMF9ncGlvX3BkYXRhLAogCS52bW1jMQkJPSAmaWdlcDNfdm1tYzEsCisJLnZpbwkJPSAmaWdlcDNfdmlvLAogfTsKIAogc3RhdGljIHN0cnVjdCBpMmNfYm9hcmRfaW5mbyBfX2luaXRkYXRhIGlnZXAzX2kyY19ib2FyZGluZm9bXSA9IHsKQEAgLTM2Myw4ICs0MDgsMjAgQEAKIHZvaWQgX19pbml0IGlnZXAzX3dpZmlfYnRfaW5pdCh2b2lkKSB7fQogI2VuZGlmCiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZWhjaV9oY2Rfb21hcF9wbGF0Zm9ybV9kYXRhIGVoY2lfcGRhdGEgX19pbml0Y29uc3QgPSB7CisJLnBvcnRfbW9kZVswXSA9IEVIQ0lfSENEX09NQVBfTU9ERV9VTktOT1dOLAorCS5wb3J0X21vZGVbMV0gPSBFSENJX0hDRF9PTUFQX01PREVfUEhZLAorCS5wb3J0X21vZGVbMl0gPSBFSENJX0hDRF9PTUFQX01PREVfVU5LTk9XTiwKKworCS5waHlfcmVzZXQgPSB0cnVlLAorCS5yZXNldF9ncGlvX3BvcnRbMF0gPSAtRUlOVkFMLAorCS5yZXNldF9ncGlvX3BvcnRbMV0gPSBJR0VQM19HUElPX1VTQkhfTlJFU0VULAorCS5yZXNldF9ncGlvX3BvcnRbMl0gPSAtRUlOVkFMLAorfTsKKwogI2lmZGVmIENPTkZJR19PTUFQX01VWAogc3RhdGljIHN0cnVjdCBvbWFwX2JvYXJkX211eCBib2FyZF9tdXhbXSBfX2luaXRkYXRhID0geworCU9NQVAzX01VWChJMkMyX1NEQSwgT01BUF9NVVhfTU9ERTQgfCBPTUFQX1BJTl9PVVRQVVQpLAogCXsgLnJlZ19vZmZzZXQgPSBPTUFQX01VWF9URVJNSU5BVE9SIH0sCiB9OwogI2VuZGlmCkBAIC0zNzUsOSArNDMyLDEwIEBACiAKIAkvKiBSZWdpc3RlciBJMkMgYnVzc2VzIGFuZCBkcml2ZXJzICovCiAJaWdlcDNfaTJjX2luaXQoKTsKLQorCXBsYXRmb3JtX2FkZF9kZXZpY2VzKGlnZXAzX2RldmljZXMsIEFSUkFZX1NJWkUoaWdlcDNfZGV2aWNlcykpOwogCW9tYXBfc2VyaWFsX2luaXQoKTsKIAl1c2JfbXVzYl9pbml0KCZtdXNiX2JvYXJkX2RhdGEpOworCXVzYl9laGNpX2luaXQoJmVoY2lfcGRhdGEpOwogCiAJaWdlcDNfZmxhc2hfaW5pdCgpOwogCWlnZXAzX2xlZHNfaW5pdCgpOwpAQCAtMzkyLDYgKzQ1MCw3IEBACiAKIE1BQ0hJTkVfU1RBUlQoSUdFUDAwMzAsICJJR0VQIE9NQVAzIG1vZHVsZSIpCiAJLmJvb3RfcGFyYW1zCT0gMHg4MDAwMDEwMCwKKwkucmVzZXJ2ZQk9IG9tYXBfcmVzZXJ2ZSwKIAkubWFwX2lvCQk9IG9tYXAzX21hcF9pbywKIAkuaW5pdF9pcnEJPSBpZ2VwM19pbml0X2lycSwKIAkuaW5pdF9tYWNoaW5lCT0gaWdlcDNfaW5pdCwKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtb21hcDNiZWFnbGUuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtb21hcDNiZWFnbGUuYwppbmRleCBhNGZlOGUxLi40NmQ4MTRhIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLW9tYXAzYmVhZ2xlLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9ib2FyZC1vbWFwM2JlYWdsZS5jCkBAIC0yMDcsNyArMjA3LDcgQEAKIAkuZHJpdmVyX25hbWUgPSAiZ2VuZXJpY19kcGlfcGFuZWwiLAogCS5kYXRhID0gJmR2aV9wYW5lbCwKIAkucGh5LmRwaS5kYXRhX2xpbmVzID0gMjQsCi0JLnJlc2V0X2dwaW8gPSAxNzAsCisJLnJlc2V0X2dwaW8gPSAtRUlOVkFMLAogfTsKIAogc3RhdGljIHN0cnVjdCBvbWFwX2Rzc19kZXZpY2UgYmVhZ2xlX3R2X2RldmljZSA9IHsKQEAgLTI3OSw2ICsyNzksOCBAQAogc3RhdGljIGludCBiZWFnbGVfdHdsX2dwaW9fc2V0dXAoc3RydWN0IGRldmljZSAqZGV2LAogCQl1bnNpZ25lZCBncGlvLCB1bnNpZ25lZCBuZ3BpbykKIHsKKwlpbnQgcjsKKwogCWlmIChvbWFwM19iZWFnbGVfZ2V0X3JldigpID09IE9NQVAzQkVBR0xFX0JPQVJEX1hNKSB7CiAJCW1tY1swXS5ncGlvX3dwID0gLUVJTlZBTDsKIAl9IGVsc2UgaWYgKChvbWFwM19iZWFnbGVfZ2V0X3JldigpID09IE9NQVAzQkVBR0xFX0JPQVJEX0MxXzMpIHx8CkBAIC0yOTksMTcgKzMwMSw2MyBAQAogCS8qIFJFVklTSVQ6IG5lZWQgZWhjaS1vbWFwIGhvb2tzIGZvciBleHRlcm5hbCBWQlVTCiAJICogcG93ZXIgc3dpdGNoIGFuZCBvdmVyY3VycmVudCBkZXRlY3QKIAkgKi8KKwlpZiAob21hcDNfYmVhZ2xlX2dldF9yZXYoKSAhPSBPTUFQM0JFQUdMRV9CT0FSRF9YTSkgeworCQlyID0gZ3Bpb19yZXF1ZXN0KGdwaW8gKyAxLCAiRUhDSV9uT0MiKTsKKwkJaWYgKCFyKSB7CisJCQlyID0gZ3Bpb19kaXJlY3Rpb25faW5wdXQoZ3BpbyArIDEpOworCQkJaWYgKHIpCisJCQkJZ3Bpb19mcmVlKGdwaW8gKyAxKTsKKwkJfQorCQlpZiAocikKKwkJCXByX2VycigiJXM6IHVuYWJsZSB0byBjb25maWd1cmUgRUhDSV9uT0NcbiIsIF9fZnVuY19fKTsKKwl9CiAKLQlncGlvX3JlcXVlc3QoZ3BpbyArIDEsICJFSENJX25PQyIpOwotCWdwaW9fZGlyZWN0aW9uX2lucHV0KGdwaW8gKyAxKTsKLQotCS8qIFRXTDQwMzBfR1BJT19NQVggKyAwID09IGxlZEEsIEVIQ0kgbkVOX1VTQl9QV1IgKG91dCwgYWN0aXZlIGxvdykgKi8KKwkvKgorCSAqIFRXTDQwMzBfR1BJT19NQVggKyAwID09IGxlZEEsIEVIQ0kgbkVOX1VTQl9QV1IgKG91dCwgWE0gYWN0aXZlCisJICogaGlnaCAvIG90aGVycyBhY3RpdmUgbG93KQorCSAqLwogCWdwaW9fcmVxdWVzdChncGlvICsgVFdMNDAzMF9HUElPX01BWCwgIm5FTl9VU0JfUFdSIik7Ci0JZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KGdwaW8gKyBUV0w0MDMwX0dQSU9fTUFYLCAwKTsKKwlpZiAob21hcDNfYmVhZ2xlX2dldF9yZXYoKSA9PSBPTUFQM0JFQUdMRV9CT0FSRF9YTSkKKwkJZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KGdwaW8gKyBUV0w0MDMwX0dQSU9fTUFYLCAxKTsKKwllbHNlCisJCWdwaW9fZGlyZWN0aW9uX291dHB1dChncGlvICsgVFdMNDAzMF9HUElPX01BWCwgMCk7CisKKwkvKiBEVkkgcmVzZXQgR1BJTyBpcyBkaWZmZXJlbnQgYmV0d2VlbiBiZWFnbGUgcmV2aXNpb25zICovCisJaWYgKG9tYXAzX2JlYWdsZV9nZXRfcmV2KCkgPT0gT01BUDNCRUFHTEVfQk9BUkRfWE0pCisJCWJlYWdsZV9kdmlfZGV2aWNlLnJlc2V0X2dwaW8gPSAxMjk7CisJZWxzZQorCQliZWFnbGVfZHZpX2RldmljZS5yZXNldF9ncGlvID0gMTcwOwogCiAJLyogVFdMNDAzMF9HUElPX01BWCArIDEgPT0gbGVkQiwgUE1VX1NUQVQgKG91dCwgYWN0aXZlIGxvdyBMRUQpICovCiAJZ3Bpb19sZWRzWzJdLmdwaW8gPSBncGlvICsgVFdMNDAzMF9HUElPX01BWCArIDE7CiAKKwkvKgorCSAqIGdwaW8gKyAxIG9uIFhtIGNvbnRyb2xzIHRoZSBURlA0MTAncyBlbmFibGUgbGluZSAoYWN0aXZlIGxvdykKKwkgKiBncGlvICsgMiBjb250cm9sIHZhcmllcyBkZXBlbmRpbmcgb24gdGhlIGJvYXJkIHJldiBhcyBmb2xsb3dzOgorCSAqIFA3L1A4IHJldmlzaW9ucyhwcm90b3R5cGUpOiBDYW1lcmEgRU4KKwkgKiBBMisgcmV2aXNpb25zIChwcm9kdWN0aW9uKTogTERPIChzdXBwbGllcyBEVkksIHNlcmlhbCwgbGVkIGJsb2NrcykKKwkgKi8KKwlpZiAob21hcDNfYmVhZ2xlX2dldF9yZXYoKSA9PSBPTUFQM0JFQUdMRV9CT0FSRF9YTSkgeworCQlyID0gZ3Bpb19yZXF1ZXN0KGdwaW8gKyAxLCAibkRWSV9QV1JfRU4iKTsKKwkJaWYgKCFyKSB7CisJCQlyID0gZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KGdwaW8gKyAxLCAwKTsKKwkJCWlmIChyKQorCQkJCWdwaW9fZnJlZShncGlvICsgMSk7CisJCX0KKwkJaWYgKHIpCisJCQlwcl9lcnIoIiVzOiB1bmFibGUgdG8gY29uZmlndXJlIG5EVklfUFdSX0VOXG4iLAorCQkJCV9fZnVuY19fKTsKKwkJciA9IGdwaW9fcmVxdWVzdChncGlvICsgMiwgIkRWSV9MRE9fRU4iKTsKKwkJaWYgKCFyKSB7CisJCQlyID0gZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KGdwaW8gKyAyLCAxKTsKKwkJCWlmIChyKQorCQkJCWdwaW9fZnJlZShncGlvICsgMik7CisJCX0KKwkJaWYgKHIpCisJCQlwcl9lcnIoIiVzOiB1bmFibGUgdG8gY29uZmlndXJlIERWSV9MRE9fRU5cbiIsCisJCQkJX19mdW5jX18pOworCX0KKwogCXJldHVybiAwOwogfQogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLW9tYXA0cGFuZGEuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtb21hcDRwYW5kYS5jCmluZGV4IDMwOTRlMjAuLmU5NDQwMjUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtb21hcDRwYW5kYS5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtb21hcDRwYW5kYS5jCkBAIC0xOSw2ICsxOSw3IEBACiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgogI2luY2x1ZGUgPGxpbnV4L2lvLmg+CiAjaW5jbHVkZSA8bGludXgvbGVkcy5oPgogI2luY2x1ZGUgPGxpbnV4L2dwaW8uaD4KQEAgLTk1LDcgKzk2LDE2IEBACiBzdGF0aWMgdm9pZCBfX2luaXQgb21hcDRfZWhjaV9pbml0KHZvaWQpCiB7CiAJaW50IHJldDsKKwlzdHJ1Y3QgY2xrICpwaHlfcmVmX2NsazsKIAorCS8qIEZSRUZfQ0xLMyBwcm92aWRlcyB0aGUgMTkuMiBNSHogcmVmZXJlbmNlIGNsb2NrIHRvIHRoZSBQSFkgKi8KKwlwaHlfcmVmX2NsayA9IGNsa19nZXQoTlVMTCwgImF1eGNsazNfY2siKTsKKwlpZiAoSVNfRVJSKHBoeV9yZWZfY2xrKSkgeworCQlwcl9lcnIoIkNhbm5vdCByZXF1ZXN0IGF1eGNsazNcbiIpOworCQlnb3RvIGVycm9yMTsKKwl9CisJY2xrX3NldF9yYXRlKHBoeV9yZWZfY2xrLCAxOTIwMDAwMCk7CisJY2xrX2VuYWJsZShwaHlfcmVmX2Nsayk7CiAKIAkvKiBkaXNhYmxlIHRoZSBwb3dlciB0byB0aGUgdXNiIGh1YiBwcmlvciB0byBpbml0ICovCiAJcmV0ID0gZ3Bpb19yZXF1ZXN0KEdQSU9fSFVCX1BPV0VSLCAiaHViX3Bvd2VyIik7CkBAIC0zOTksOCArNDA5LDYgQEAKIAlwbGF0Zm9ybV9hZGRfZGV2aWNlcyhwYW5kYV9kZXZpY2VzLCBBUlJBWV9TSVpFKHBhbmRhX2RldmljZXMpKTsKIAlvbWFwX3NlcmlhbF9pbml0KCk7CiAJb21hcDRfdHdsNjAzMF9oc21tY19pbml0KG1tYyk7Ci0JLyogT01BUDQgUGFuZGEgdXNlcyBpbnRlcm5hbCB0cmFuc2NlaXZlciBzbyByZWdpc3RlciBub3AgdHJhbnNjZWl2ZXIgKi8KLQl1c2Jfbm9wX3hjZWl2X3JlZ2lzdGVyKCk7CiAJb21hcDRfZWhjaV9pbml0KCk7CiAJdXNiX211c2JfaW5pdCgmbXVzYl9ib2FyZF9kYXRhKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtcm02ODAuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtcm02ODAuYwppbmRleCBjYjc3YmU3Li4zOWE3MWJiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLXJtNjgwLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9ib2FyZC1ybTY4MC5jCkBAIC00MCw5ICs0MCw2IEBACiBzdGF0aWMgc3RydWN0IHJlZ3VsYXRvcl9pbml0X2RhdGEgcm02ODBfdmVtbWMgPSB7CiAJLmNvbnN0cmFpbnRzID0JewogCQkubmFtZQkJCT0gInJtNjgwX3ZlbW1jIiwKLQkJLm1pbl91VgkJCT0gMjkwMDAwMCwKLQkJLm1heF91VgkJCT0gMjkwMDAwMCwKLQkJLmFwcGx5X3VWCQk9IDEsCiAJCS52YWxpZF9tb2Rlc19tYXNrCT0gUkVHVUxBVE9SX01PREVfTk9STUFMCiAJCQkJCXwgUkVHVUxBVE9SX01PREVfU1RBTkRCWSwKIAkJLnZhbGlkX29wc19tYXNrCQk9IFJFR1VMQVRPUl9DSEFOR0VfU1RBVFVTCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLXpvb20tcGVyaXBoZXJhbHMuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtem9vbS1wZXJpcGhlcmFscy5jCmluZGV4IDE0ZDk1YWYuLmUwZTA0MGYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtem9vbS1wZXJpcGhlcmFscy5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtem9vbS1wZXJpcGhlcmFscy5jCkBAIC0xOTIsNyArMTkyLDcgQEAKIAl9LAogfTsKIAotc3RydWN0IHdsMTJ4eF9wbGF0Zm9ybV9kYXRhIG9tYXBfem9vbV93bGFuX2RhdGEgX19pbml0ZGF0YSA9IHsKK3N0YXRpYyBzdHJ1Y3Qgd2wxMnh4X3BsYXRmb3JtX2RhdGEgb21hcF96b29tX3dsYW5fZGF0YSBfX2luaXRkYXRhID0gewogCS5pcnEgPSBPTUFQX0dQSU9fSVJRKE9NQVBfWk9PTV9XTEFOX0lSUV9HUElPKSwKIAkvKiBaT09NIHJlZiBjbG9jayBpcyAyNiBNSHogKi8KIAkuYm9hcmRfcmVmX2Nsb2NrID0gMSwKQEAgLTI4Niw3ICsyODYsNyBAQAogfQogCiAvKiBFWFRNVVRFIGNhbGxiYWNrIGZ1bmN0aW9uICovCi12b2lkIHpvb20yX3NldF9oc19leHRtdXRlKGludCBtdXRlKQorc3RhdGljIHZvaWQgem9vbTJfc2V0X2hzX2V4dG11dGUoaW50IG11dGUpCiB7CiAJZ3Bpb19zZXRfdmFsdWUoWk9PTTJfSEVBRFNFVF9FWFRNVVRFX0dQSU8sIG11dGUpOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9jbG9jazN4eHhfZGF0YS5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9jbG9jazN4eHhfZGF0YS5jCmluZGV4IGQzYWIxYzllLi40MDNhNGExIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2Nsb2NrM3h4eF9kYXRhLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9jbG9jazN4eHhfZGF0YS5jCkBAIC0zMjg2LDcgKzMyODYsNyBAQAogCUNMSyhOVUxMLAkiY3BlZnVzZV9mY2siLAkmY3BlZnVzZV9mY2ssCUNLXzM0MzBFUzJQTFVTIHwgQ0tfQU0zNVhYIHwgQ0tfMzZYWCksCiAJQ0xLKE5VTEwsCSJ0c19mY2siLAkmdHNfZmNrLAlDS18zNDMwRVMyUExVUyB8IENLX0FNMzVYWCB8IENLXzM2WFgpLAogCUNMSyhOVUxMLAkidXNidGxsX2ZjayIsCSZ1c2J0bGxfZmNrLAlDS18zNDMwRVMyUExVUyB8IENLX0FNMzVYWCB8IENLXzM2WFgpLAotCUNMSygiZWhjaS1vbWFwLjAiLAkidXNidGxsX2ZjayIsCSZ1c2J0bGxfZmNrLAlDS18zNDMwRVMyIHwgQ0tfQU0zNVhYKSwKKwlDTEsoImVoY2ktb21hcC4wIiwJInVzYnRsbF9mY2siLAkmdXNidGxsX2ZjaywJQ0tfMzQzMEVTMlBMVVMgfCBDS19BTTM1WFggfCBDS18zNlhYKSwKIAlDTEsoIm9tYXAtbWNic3AuMSIsCSJwcmNtX2ZjayIsCSZjb3JlXzk2bV9mY2ssCUNLXzNYWFgpLAogCUNMSygib21hcC1tY2JzcC41IiwJInByY21fZmNrIiwJJmNvcmVfOTZtX2ZjaywJQ0tfM1hYWCksCiAJQ0xLKE5VTEwsCSJjb3JlXzk2bV9mY2siLAkmY29yZV85Nm1fZmNrLAlDS18zWFhYKSwKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvY2xvY2s0NHh4X2RhdGEuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvY2xvY2s0NHh4X2RhdGEuYwppbmRleCBlOGNiMzJmLi5kZTllYzhkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2Nsb2NrNDR4eF9kYXRhLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9jbG9jazQ0eHhfZGF0YS5jCkBAIC0zNCw3ICszNCw2IEBACiAjaW5jbHVkZSAiY20yXzQ0eHguaCIKICNpbmNsdWRlICJjbS1yZWdiaXRzLTQ0eHguaCIKICNpbmNsdWRlICJwcm00NHh4LmgiCi0jaW5jbHVkZSAicHJtNDR4eC5oIgogI2luY2x1ZGUgInBybS1yZWdiaXRzLTQ0eHguaCIKICNpbmNsdWRlICJjb250cm9sLmgiCiAjaW5jbHVkZSAic2NybTQ0eHguaCIKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvY2xvY2tkb21haW4uYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvY2xvY2tkb21haW4uYwppbmRleCBlMjBiOTg2Li41OGU0MmY3IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2Nsb2NrZG9tYWluLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9jbG9ja2RvbWFpbi5jCkBAIC00MjMsNiArNDIzLDEyIEBACiB7CiAJc3RydWN0IGNsa2RtX2RlcCAqY2Q7CiAKKwlpZiAoIWNwdV9pc19vbWFwMjR4eCgpICYmICFjcHVfaXNfb21hcDM0eHgoKSkgeworCQlwcl9lcnIoImNsb2NrZG9tYWluOiAlcy8lczogJXM6IG5vdCB5ZXQgaW1wbGVtZW50ZWRcbiIsCisJCSAgICAgICBjbGtkbTEtPm5hbWUsIGNsa2RtMi0+bmFtZSwgX19mdW5jX18pOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKIAlpZiAoIWNsa2RtMSB8fCAhY2xrZG0yKQogCQlyZXR1cm4gLUVJTlZBTDsKIApAQCAtNDU4LDYgKzQ2NCwxMiBAQAogewogCXN0cnVjdCBjbGtkbV9kZXAgKmNkOwogCisJaWYgKCFjcHVfaXNfb21hcDI0eHgoKSAmJiAhY3B1X2lzX29tYXAzNHh4KCkpIHsKKwkJcHJfZXJyKCJjbG9ja2RvbWFpbjogJXMvJXM6ICVzOiBub3QgeWV0IGltcGxlbWVudGVkXG4iLAorCQkgICAgICAgY2xrZG0xLT5uYW1lLCBjbGtkbTItPm5hbWUsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCiAJaWYgKCFjbGtkbTEgfHwgIWNsa2RtMikKIAkJcmV0dXJuIC1FSU5WQUw7CiAKQEAgLTUwMCw2ICs1MTIsMTIgQEAKIAlpZiAoIWNsa2RtMSB8fCAhY2xrZG0yKQogCQlyZXR1cm4gLUVJTlZBTDsKIAorCWlmICghY3B1X2lzX29tYXAyNHh4KCkgJiYgIWNwdV9pc19vbWFwMzR4eCgpKSB7CisJCXByX2VycigiY2xvY2tkb21haW46ICVzLyVzOiAlczogbm90IHlldCBpbXBsZW1lbnRlZFxuIiwKKwkJICAgICAgIGNsa2RtMS0+bmFtZSwgY2xrZG0yLT5uYW1lLCBfX2Z1bmNfXyk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwogCWNkID0gX2Nsa2RtX2RlcHNfbG9va3VwKGNsa2RtMiwgY2xrZG0xLT53a2RlcF9zcmNzKTsKIAlpZiAoSVNfRVJSKGNkKSkgewogCQlwcl9kZWJ1ZygiY2xvY2tkb21haW46IGhhcmR3YXJlIGNhbm5vdCBzZXQvY2xlYXIgd2FrZSB1cCBvZiAiCkBAIC01MjcsNiArNTQ1LDEyIEBACiAJc3RydWN0IGNsa2RtX2RlcCAqY2Q7CiAJdTMyIG1hc2sgPSAwOwogCisJaWYgKCFjcHVfaXNfb21hcDI0eHgoKSAmJiAhY3B1X2lzX29tYXAzNHh4KCkpIHsKKwkJcHJfZXJyKCJjbG9ja2RvbWFpbjogJXM6ICVzOiBub3QgeWV0IGltcGxlbWVudGVkXG4iLAorCQkgICAgICAgY2xrZG0tPm5hbWUsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCiAJaWYgKCFjbGtkbSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKQEAgLTgzMCw4ICs4NTQsNyBAQAogCSAqIGRlcGVuZGVuY3kgY29kZSBhbmQgZGF0YSBmb3IgT01BUDQuCiAJICovCiAJaWYgKGNwdV9pc19vbWFwNDR4eCgpKSB7Ci0JCVdBUk5fT05DRSgxLCAiY2xvY2tkb21haW46IE9NQVA0IHdha2V1cC9zbGVlcCBkZXBlbmRlbmN5ICIKLQkJCSAgInN1cHBvcnQgaXMgbm90IHlldCBpbXBsZW1lbnRlZFxuIik7CisJCXByX2VycigiY2xvY2tkb21haW46ICVzOiBPTUFQNCB3YWtldXAvc2xlZXAgZGVwZW5kZW5jeSBzdXBwb3J0OiBub3QgeWV0IGltcGxlbWVudGVkXG4iLCBjbGtkbS0+bmFtZSk7CiAJfSBlbHNlIHsKIAkJaWYgKGF0b21pY19yZWFkKCZjbGtkbS0+dXNlY291bnQpID4gMCkKIAkJCV9jbGtkbV9hZGRfYXV0b2RlcHMoY2xrZG0pOwpAQCAtODcyLDggKzg5NSw3IEBACiAJICogZGVwZW5kZW5jeSBjb2RlIGFuZCBkYXRhIGZvciBPTUFQNC4KIAkgKi8KIAlpZiAoY3B1X2lzX29tYXA0NHh4KCkpIHsKLQkJV0FSTl9PTkNFKDEsICJjbG9ja2RvbWFpbjogT01BUDQgd2FrZXVwL3NsZWVwIGRlcGVuZGVuY3kgIgotCQkJICAic3VwcG9ydCBpcyBub3QgeWV0IGltcGxlbWVudGVkXG4iKTsKKwkJcHJfZXJyKCJjbG9ja2RvbWFpbjogJXM6IE9NQVA0IHdha2V1cC9zbGVlcCBkZXBlbmRlbmN5IHN1cHBvcnQ6IG5vdCB5ZXQgaW1wbGVtZW50ZWRcbiIsIGNsa2RtLT5uYW1lKTsKIAl9IGVsc2UgewogCQlpZiAoYXRvbWljX3JlYWQoJmNsa2RtLT51c2Vjb3VudCkgPiAwKQogCQkJX2Nsa2RtX2RlbF9hdXRvZGVwcyhjbGtkbSk7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2Nsb2NrZG9tYWluLmggYi9hcmNoL2FybS9tYWNoLW9tYXAyL2Nsb2NrZG9tYWluLmgKaW5kZXggZGUzZmFhMi4uOWI0NTljMiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9jbG9ja2RvbWFpbi5oCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvY2xvY2tkb21haW4uaApAQCAtMTAzLDkgKzEwMyw3IEBACiAJCWNvbnN0IGNoYXIgKm5hbWU7CiAJCXN0cnVjdCBwb3dlcmRvbWFpbiAqcHRyOwogCX0gcHdyZG07Ci0jaWYgZGVmaW5lZChDT05GSUdfQVJDSF9PTUFQMikgfHwgZGVmaW5lZChDT05GSUdfQVJDSF9PTUFQMykKIAljb25zdCB1MTYgY2xrdHJjdHJsX21hc2s7Ci0jZW5kaWYKIAljb25zdCB1OCBmbGFnczsKIAljb25zdCB1OCBkZXBfYml0OwogCWNvbnN0IHU4IHByY21fcGFydGl0aW9uOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9jbG9ja2RvbWFpbnM0NHh4X2RhdGEuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvY2xvY2tkb21haW5zNDR4eF9kYXRhLmMKaW5kZXggNTE5MjBmYy4uMTA2MjJjOSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9jbG9ja2RvbWFpbnM0NHh4X2RhdGEuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2Nsb2NrZG9tYWluczQ0eHhfZGF0YS5jCkBAIC0zMCw4ICszMCw2IEBACiAjaW5jbHVkZSAiY20xXzQ0eHguaCIKICNpbmNsdWRlICJjbTJfNDR4eC5oIgogCi0jaW5jbHVkZSAiY20xXzQ0eHguaCIKLSNpbmNsdWRlICJjbTJfNDR4eC5oIgogI2luY2x1ZGUgImNtLXJlZ2JpdHMtNDR4eC5oIgogI2luY2x1ZGUgInBybTQ0eHguaCIKICNpbmNsdWRlICJwcmNtNDR4eC5oIgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9jcHVpZGxlMzR4eC5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9jcHVpZGxlMzR4eC5jCmluZGV4IDExYjg5ZTk2Li5mN2IyMmExIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2NwdWlkbGUzNHh4LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9jcHVpZGxlMzR4eC5jCkBAIC00Nyw2ICs0Nyw4IEBACiAKICNkZWZpbmUgT01BUDNfU1RBVEVfTUFYIE9NQVAzX1NUQVRFX0M3CiAKKyNkZWZpbmUgQ1BVSURMRV9GTEFHX0NIRUNLX0JNCTB4MTAwMDAJLyogdXNlIG9tYXAzX2VudGVyX2lkbGVfYm0oKSAqLworCiBzdHJ1Y3Qgb21hcDNfcHJvY2Vzc29yX2N4IHsKIAl1OCB2YWxpZDsKIAl1OCB0eXBlOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9kZXZpY2VzLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2RldmljZXMuYwppbmRleCAzODFmNGViLi4yYzljOTEyIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2RldmljZXMuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2RldmljZXMuYwpAQCAtOTc4LDcgKzk3OCw3IEBACiBhcmNoX2luaXRjYWxsKG9tYXAyX2luaXRfZGV2aWNlcyk7CiAKICNpZiBkZWZpbmVkKENPTkZJR19PTUFQX1dBVENIRE9HKSB8fCBkZWZpbmVkKENPTkZJR19PTUFQX1dBVENIRE9HX01PRFVMRSkKLXN0cnVjdCBvbWFwX2RldmljZV9wbV9sYXRlbmN5IG9tYXBfd2R0X2xhdGVuY3lbXSA9IHsKK3N0YXRpYyBzdHJ1Y3Qgb21hcF9kZXZpY2VfcG1fbGF0ZW5jeSBvbWFwX3dkdF9sYXRlbmN5W10gPSB7CiAJWzBdID0gewogCQkuZGVhY3RpdmF0ZV9mdW5jID0gb21hcF9kZXZpY2VfaWRsZV9od21vZHMsCiAJCS5hY3RpdmF0ZV9mdW5jICAgPSBvbWFwX2RldmljZV9lbmFibGVfaHdtb2RzLApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9kbWEuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvZG1hLmMKaW5kZXggZDJmMTVmNS4uMzQ5MjJiMiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9kbWEuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2RtYS5jCkBAIC0yNjQsNyArMjY0LDcgQEAKIAlpZiAoSVNfRVJSKG9kKSkgewogCQlwcl9lcnIoIiVzOiBDYW50IGJ1aWxkIG9tYXBfZGV2aWNlIGZvciAlczolcy5cbiIsCiAJCQlfX2Z1bmNfXywgbmFtZSwgb2gtPm5hbWUpOwotCQlyZXR1cm4gSVNfRVJSKG9kKTsKKwkJcmV0dXJuIFBUUl9FUlIob2QpOwogCX0KIAogCW1lbSA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZSgmb2QtPnBkZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvaW5jbHVkZS9tYWNoL2VudHJ5LW1hY3JvLlMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2luY2x1ZGUvbWFjaC9lbnRyeS1tYWNyby5TCmluZGV4IGJlZmEzMjEuLjgxOTg1YTYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvaW5jbHVkZS9tYWNoL2VudHJ5LW1hY3JvLlMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9pbmNsdWRlL21hY2gvZW50cnktbWFjcm8uUwpAQCAtMzgsMjAgKzM4LDYgQEAKICAqLwogCiAjaWZkZWYgTVVMVElfT01BUDIKLQotLyoKLSAqIFdlIHVzZSBfX2dsdWUgdG8gYXZvaWQgZXJyb3JzIHdpdGggbXVsdGlwbGUgZGVmaW5pdGlvbnMgb2YKLSAqIC5nbG9ibCBvbWFwX2lycV9iYXNlIGFzIGl0J3MgaW5jbHVkZWQgZnJvbSBlbnRyeS1hcm12LlMgYnV0IG5vdAotICogZnJvbSBlbnRyeS1jb21tb24uUy4KLSAqLwotI2lmZGVmIF9fZ2x1ZQotCQkucHVzaHNlY3Rpb24gLmRhdGEKLQkJLmdsb2JsCW9tYXBfaXJxX2Jhc2UKLW9tYXBfaXJxX2Jhc2U6Ci0JCS53b3JkCTAKLQkJLnBvcHNlY3Rpb24KLSNlbmRpZgotCiAJCS8qCiAJCSAqIENvbmZpZ3VyZSB0aGUgaW50ZXJydXB0IGJhc2Ugb24gdGhlIGZpcnN0IGludGVycnVwdC4KIAkJICogU2VlIGFsc28gb21hcF9pcnFfYmFzZV9pbml0IGZvciBzZXR0aW5nIG9tYXBfaXJxX2Jhc2UuCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2lvLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2lvLmMKaW5kZXggZTY2Njg3Yi4uYzIwMzIwNCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9pby5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvaW8uYwpAQCAtMzE0LDE0ICszMTQsMTMgQEAKIAlyZXR1cm4gb21hcF9od21vZF9zZXRfcG9zdHNldHVwX3N0YXRlKG9oLCAqKHU4ICopZGF0YSk7CiB9CiAKK3ZvaWQgX19pb21lbSAqb21hcF9pcnFfYmFzZTsKKwogLyoKICAqIEluaXRpYWxpemUgYXNtX2lycV9iYXNlIGZvciBlbnRyeS1tYWNyby5TCiAgKi8KIHN0YXRpYyBpbmxpbmUgdm9pZCBvbWFwX2lycV9iYXNlX2luaXQodm9pZCkKIHsKLQlleHRlcm4gdm9pZCBfX2lvbWVtICpvbWFwX2lycV9iYXNlOwotCi0jaWZkZWYgTVVMVElfT01BUDIKIAlpZiAoY3B1X2lzX29tYXAyNHh4KCkpCiAJCW9tYXBfaXJxX2Jhc2UgPSBPTUFQMl9MNF9JT19BRERSRVNTKE9NQVAyNFhYX0lDX0JBU0UpOwogCWVsc2UgaWYgKGNwdV9pc19vbWFwMzR4eCgpKQpAQCAtMzMwLDcgKzMyOSw2IEBACiAJCW9tYXBfaXJxX2Jhc2UgPSBPTUFQMl9MNF9JT19BRERSRVNTKE9NQVA0NFhYX0dJQ19DUFVfQkFTRSk7CiAJZWxzZQogCQlwcl9lcnIoIkNvdWxkIG5vdCBpbml0aWFsaXplIG9tYXBfaXJxX2Jhc2VcbiIpOwotI2VuZGlmCiB9CiAKIHZvaWQgX19pbml0IG9tYXAyX2luaXRfY29tbW9uX2luZnJhc3RydWN0dXJlKHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2lycS5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9pcnEuYwppbmRleCA4NWJmOGNhLi4yMzA0OWM0IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2lycS5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvaXJxLmMKQEAgLTEwMCwxMyArMTAwLDE0IEBACiB9CiAKIC8qIFhYWDogRklRIGFuZCBhZGRpdGlvbmFsIElOVEMgc3VwcG9ydCAob25seSBNUFUgYXQgdGhlIG1vbWVudCkgKi8KLXN0YXRpYyB2b2lkIG9tYXBfYWNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgb21hcF9hY2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAlpbnRjX2Jhbmtfd3JpdGVfcmVnKDB4MSwgJmlycV9iYW5rc1swXSwgSU5UQ19DT05UUk9MKTsKIH0KIAotc3RhdGljIHZvaWQgb21hcF9tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgb21hcF9tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CisJdW5zaWduZWQgaW50IGlycSA9IGQtPmlycTsKIAlpbnQgb2Zmc2V0ID0gaXJxICYgKH4oSVJRX0JJVFNfUEVSX1JFRyAtIDEpKTsKIAogCWlmIChjcHVfaXNfb21hcDM0eHgoKSkgewpAQCAtMTI4LDggKzEyOSw5IEBACiAJaW50Y19iYW5rX3dyaXRlX3JlZygxIDw8IGlycSwgJmlycV9iYW5rc1swXSwgSU5UQ19NSVJfU0VUMCArIG9mZnNldCk7CiB9CiAKLXN0YXRpYyB2b2lkIG9tYXBfdW5tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgb21hcF91bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKKwl1bnNpZ25lZCBpbnQgaXJxID0gZC0+aXJxOwogCWludCBvZmZzZXQgPSBpcnEgJiAofihJUlFfQklUU19QRVJfUkVHIC0gMSkpOwogCiAJaXJxICY9IChJUlFfQklUU19QRVJfUkVHIC0gMSk7CkBAIC0xMzcsMTcgKzEzOSwxNyBAQAogCWludGNfYmFua193cml0ZV9yZWcoMSA8PCBpcnEsICZpcnFfYmFua3NbMF0sIElOVENfTUlSX0NMRUFSMCArIG9mZnNldCk7CiB9CiAKLXN0YXRpYyB2b2lkIG9tYXBfbWFza19hY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBvbWFwX21hc2tfYWNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jb21hcF9tYXNrX2lycShpcnEpOwotCW9tYXBfYWNrX2lycShpcnEpOworCW9tYXBfbWFza19pcnEoZCk7CisJb21hcF9hY2tfaXJxKGQpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG9tYXBfaXJxX2NoaXAgPSB7Ci0JLm5hbWUJPSAiSU5UQyIsCi0JLmFjawk9IG9tYXBfbWFza19hY2tfaXJxLAotCS5tYXNrCT0gb21hcF9tYXNrX2lycSwKLQkudW5tYXNrCT0gb21hcF91bm1hc2tfaXJxLAorCS5uYW1lCQk9ICJJTlRDIiwKKwkuaXJxX2Fjawk9IG9tYXBfbWFza19hY2tfaXJxLAorCS5pcnFfbWFzawk9IG9tYXBfbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBvbWFwX3VubWFza19pcnEsCiB9OwogCiBzdGF0aWMgdm9pZCBfX2luaXQgb21hcF9pcnFfYmFua19pbml0X29uZShzdHJ1Y3Qgb21hcF9pcnFfYmFuayAqYmFuaykKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvbXV4LmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL211eC5jCmluZGV4IDE3YmQ2MzkuLjk4MTQ4YjYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvbXV4LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9tdXguYwpAQCAtMTYwLDcgKzE2MCw3IEBACiAJc3RydWN0IG9tYXBfbXV4ICptdXggPSBOVUxMOwogCXN0cnVjdCBvbWFwX211eF9lbnRyeSAqZTsKIAljb25zdCBjaGFyICptb2RlX25hbWU7Ci0JaW50IGZvdW5kID0gMCwgZm91bmRfbW9kZSwgbW9kZTBfbGVuID0gMDsKKwlpbnQgZm91bmQgPSAwLCBmb3VuZF9tb2RlID0gMCwgbW9kZTBfbGVuID0gMDsKIAlzdHJ1Y3QgbGlzdF9oZWFkICptdXhtb2RlcyA9ICZwYXJ0aXRpb24tPm11eG1vZGVzOwogCiAJbW9kZV9uYW1lID0gc3RyY2hyKG11eG5hbWUsICcuJyk7CkBAIC04OTMsNyArODkzLDcgQEAKIAkJcmV0dXJuIE5VTEw7CiAKIAltID0gJmVudHJ5LT5tdXg7Ci0JbWVtY3B5KG0sIHNyYywgc2l6ZW9mKHN0cnVjdCBvbWFwX211eF9lbnRyeSkpOworCWVudHJ5LT5tdXggPSAqc3JjOwogCiAjaWZkZWYgQ09ORklHX09NQVBfTVVYCiAJaWYgKG9tYXBfbXV4X2NvcHlfbmFtZXMoc3JjLCBtKSkgewpAQCAtMTAwMCw2ICsxMDAwLDcgQEAKIAlpZiAoIXBhcnRpdGlvbi0+YmFzZSkgewogCQlwcl9lcnIoIiVzOiBDb3VsZCBub3QgaW9yZW1hcCBtdXggcGFydGl0aW9uIGF0IDB4JTA4eFxuIiwKIAkJCV9fZnVuY19fLCBwYXJ0aXRpb24tPnBoeXMpOworCQlrZnJlZShwYXJ0aXRpb24pOwogCQlyZXR1cm4gLUVOT0RFVjsKIAl9CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvbXV4MzR4eC5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9tdXgzNHh4LmMKaW5kZXggNDQwYzk4ZS4uMTdmODBlNCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9tdXgzNHh4LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9tdXgzNHh4LmMKQEAgLTcwMyw3ICs3MDMsNyBAQAogICogU2lnbmFscyBkaWZmZXJlbnQgb24gQ0JDIHBhY2thZ2UgY29tcGFyZWQgdG8gdGhlIHN1cGVyc2V0CiAgKi8KICNpZiBkZWZpbmVkKENPTkZJR19PTUFQX01VWCkgJiYgZGVmaW5lZChDT05GSUdfT01BUF9QQUNLQUdFX0NCQykKLXN0cnVjdCBvbWFwX211eCBfX2luaXRkYXRhIG9tYXAzX2NiY19zdWJzZXRbXSA9IHsKK3N0YXRpYyBzdHJ1Y3Qgb21hcF9tdXggX19pbml0ZGF0YSBvbWFwM19jYmNfc3Vic2V0W10gPSB7CiAJeyAucmVnX29mZnNldCA9IE9NQVBfTVVYX1RFUk1JTkFUT1IgfSwKIH07CiAjZWxzZQpAQCAtNzIxLDcgKzcyMSw3IEBACiAgKi8KICNpZiBkZWZpbmVkKENPTkZJR19PTUFQX01VWCkgJiYgZGVmaW5lZChDT05GSUdfREVCVUdfRlMpCVwKIAkJJiYgZGVmaW5lZChDT05GSUdfT01BUF9QQUNLQUdFX0NCQykKLXN0cnVjdCBvbWFwX2JhbGwgX19pbml0ZGF0YSBvbWFwM19jYmNfYmFsbFtdID0geworc3RhdGljIHN0cnVjdCBvbWFwX2JhbGwgX19pbml0ZGF0YSBvbWFwM19jYmNfYmFsbFtdID0gewogCV9PTUFQM19CQUxMRU5UUlkoQ0FNX0QwLCAiYWUxNiIsIE5VTEwpLAogCV9PTUFQM19CQUxMRU5UUlkoQ0FNX0QxLCAiYWUxNSIsIE5VTEwpLAogCV9PTUFQM19CQUxMRU5UUlkoQ0FNX0QxMCwgImQyNSIsIE5VTEwpLApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9tdXg0NHh4LmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL211eDQ0eHguYwppbmRleCA5ODBmMTFkLi5jMzIyZTdiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL211eDQ0eHguYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL211eDQ0eHguYwpAQCAtNTQ0LDcgKzU0NCw3IEBACiAgKi8KICNpZiBkZWZpbmVkKENPTkZJR19PTUFQX01VWCkgJiYgZGVmaW5lZChDT05GSUdfREVCVUdfRlMpCQlcCiAJCSYmIGRlZmluZWQoQ09ORklHX09NQVBfUEFDS0FHRV9DQkwpCi1zdHJ1Y3Qgb21hcF9iYWxsIF9faW5pdGRhdGEgb21hcDRfY29yZV9jYmxfYmFsbFtdID0geworc3RhdGljIHN0cnVjdCBvbWFwX2JhbGwgX19pbml0ZGF0YSBvbWFwNF9jb3JlX2NibF9iYWxsW10gPSB7CiAJX09NQVA0X0JBTExFTlRSWShHUE1DX0FEMCwgImMxMiIsIE5VTEwpLAogCV9PTUFQNF9CQUxMRU5UUlkoR1BNQ19BRDEsICJkMTIiLCBOVUxMKSwKIAlfT01BUDRfQkFMTEVOVFJZKEdQTUNfQUQyLCAiYzEzIiwgTlVMTCksCkBAIC0xMjYyLDcgKzEyNjIsNyBAQAogICovCiAjaWYgZGVmaW5lZChDT05GSUdfT01BUF9NVVgpICYmIGRlZmluZWQoQ09ORklHX0RFQlVHX0ZTKQkJXAogCQkmJiBkZWZpbmVkKENPTkZJR19PTUFQX1BBQ0tBR0VfQ0JTKQotc3RydWN0IG9tYXBfYmFsbCBfX2luaXRkYXRhIG9tYXA0X2NvcmVfY2JzX2JhbGxbXSA9IHsKK3N0YXRpYyBzdHJ1Y3Qgb21hcF9iYWxsIF9faW5pdGRhdGEgb21hcDRfY29yZV9jYnNfYmFsbFtdID0gewogCV9PTUFQNF9CQUxMRU5UUlkoR1BNQ19BRDAsICJjMTIiLCBOVUxMKSwKIAlfT01BUDRfQkFMTEVOVFJZKEdQTUNfQUQxLCAiZDEyIiwgTlVMTCksCiAJX09NQVA0X0JBTExFTlRSWShHUE1DX0FEMiwgImMxMyIsIE5VTEwpLApAQCAtMTU0Niw3ICsxNTQ2LDcgQEAKICAqLwogI2lmIGRlZmluZWQoQ09ORklHX09NQVBfTVVYKSAmJiBkZWZpbmVkKENPTkZJR19ERUJVR19GUykJCVwKIAkJJiYgZGVmaW5lZChDT05GSUdfT01BUF9QQUNLQUdFX0NCTCkKLXN0cnVjdCBvbWFwX2JhbGwgX19pbml0ZGF0YSBvbWFwNF93a3VwX2NibF9jYnNfYmFsbFtdID0geworc3RhdGljIHN0cnVjdCBvbWFwX2JhbGwgX19pbml0ZGF0YSBvbWFwNF93a3VwX2NibF9jYnNfYmFsbFtdID0gewogCV9PTUFQNF9CQUxMRU5UUlkoU0lNX0lPLCAiaDQiLCBOVUxMKSwKIAlfT01BUDRfQkFMTEVOVFJZKFNJTV9DTEssICJqMiIsIE5VTEwpLAogCV9PTUFQNF9CQUxMRU5UUlkoU0lNX1JFU0VULCAiZzIiLCBOVUxMKSwKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvb21hcF90d2wuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvb21hcF90d2wuYwppbmRleCAxNWY4YzZjLi4wMGUxZDJiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL29tYXBfdHdsLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9vbWFwX3R3bC5jCkBAIC0yMCw2ICsyMCw4IEBACiAKICNpbmNsdWRlIDxwbGF0L3ZvbHRhZ2UuaD4KIAorI2luY2x1ZGUgInBtLmgiCisKICNkZWZpbmUgT01BUDNfU1JJMkNfU0xBVkVfQUREUgkJMHgxMgogI2RlZmluZSBPTUFQM19WRERfTVBVX1NSX0NPTlRST0xfUkVHCTB4MDAKICNkZWZpbmUgT01BUDNfVkREX0NPUkVfU1JfQ09OVFJPTF9SRUcJMHgwMQpAQCAtNjAsMTcgKzYyLDE3IEBACiAKICNkZWZpbmUgUkVHX1NNUFNfT0ZGU0VUICAgICAgICAgMHhFMAogCi11bnNpZ25lZCBsb25nIHR3bDQwMzBfdnNlbF90b191dihjb25zdCB1OCB2c2VsKQorc3RhdGljIHVuc2lnbmVkIGxvbmcgdHdsNDAzMF92c2VsX3RvX3V2KGNvbnN0IHU4IHZzZWwpCiB7CiAJcmV0dXJuICgoKHZzZWwgKiAxMjUpICsgNjAwMCkpICogMTAwOwogfQogCi11OCB0d2w0MDMwX3V2X3RvX3ZzZWwodW5zaWduZWQgbG9uZyB1dikKK3N0YXRpYyB1OCB0d2w0MDMwX3V2X3RvX3ZzZWwodW5zaWduZWQgbG9uZyB1dikKIHsKIAlyZXR1cm4gRElWX1JPVU5EX1VQKHV2IC0gNjAwMDAwLCAxMjUwMCk7CiB9CiAKLXVuc2lnbmVkIGxvbmcgdHdsNjAzMF92c2VsX3RvX3V2KGNvbnN0IHU4IHZzZWwpCitzdGF0aWMgdW5zaWduZWQgbG9uZyB0d2w2MDMwX3ZzZWxfdG9fdXYoY29uc3QgdTggdnNlbCkKIHsKIAkvKgogCSAqIEluIFRXTDYwMzAgZGVwZW5kaW5nIG9uIHRoZSB2YWx1ZSBvZiBTTVBTX09GRlNFVApAQCAtMTAyLDcgKzEwNCw3IEBACiAJCXJldHVybiAoKCgodnNlbCAtIDEpICogMTI1KSArIDYwMDApKSAqIDEwMDsKIH0KIAotdTggdHdsNjAzMF91dl90b192c2VsKHVuc2lnbmVkIGxvbmcgdXYpCitzdGF0aWMgdTggdHdsNjAzMF91dl90b192c2VsKHVuc2lnbmVkIGxvbmcgdXYpCiB7CiAJLyoKIAkgKiBJbiBUV0w2MDMwIGRlcGVuZGluZyBvbiB0aGUgdmFsdWUgb2YgU01QU19PRkZTRVQKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvcG0yNHh4LmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3BtMjR4eC5jCmluZGV4IDllNWRjOGUuLjk3ZmViM2EgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvcG0yNHh4LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9wbTI0eHguYwpAQCAtMTM0LDcgKzEzNCw3IEBACiAKIAkvKiBCbG9jayBjb25zb2xlIG91dHB1dCBpbiBjYXNlIGl0IGlzIG9uIG9uZSBvZiB0aGUgT01BUCBVQVJUcyAqLwogCWlmICghaXNfc3VzcGVuZGluZygpKQotCQlpZiAodHJ5X2FjcXVpcmVfY29uc29sZV9zZW0oKSkKKwkJaWYgKCFjb25zb2xlX3RyeWxvY2soKSkKIAkJCWdvdG8gbm9fc2xlZXA7CiAKIAlvbWFwX3VhcnRfcHJlcGFyZV9pZGxlKDApOwpAQCAtMTUxLDcgKzE1MSw3IEBACiAJb21hcF91YXJ0X3Jlc3VtZV9pZGxlKDApOwogCiAJaWYgKCFpc19zdXNwZW5kaW5nKCkpCi0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAogbm9fc2xlZXA6CiAJaWYgKG9tYXAyX3BtX2RlYnVnKSB7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL3BtMzR4eC5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9wbTM0eHguYwppbmRleCA4Y2JiZWFkLi4yZjg2NGU0IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL3BtMzR4eC5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvcG0zNHh4LmMKQEAgLTE2OCw5ICsxNjgsMTAgQEAKICAqIG9uY2UgZHVyaW5nIGJvb3Qgc2VxdWVuY2UsIGJ1dCB0aGlzIHdvcmtzIGFzIHdlIGFyZSBub3QgdXNpbmcgc2VjdXJlCiAgKiBzZXJ2aWNlcy4KICAqLwotc3RhdGljIHZvaWQgb21hcDNfc2F2ZV9zZWN1cmVfcmFtX2NvbnRleHQodTMyIHRhcmdldF9tcHVfc3RhdGUpCitzdGF0aWMgdm9pZCBvbWFwM19zYXZlX3NlY3VyZV9yYW1fY29udGV4dCh2b2lkKQogewogCXUzMiByZXQ7CisJaW50IG1wdV9uZXh0X3N0YXRlID0gcHdyZG1fcmVhZF9uZXh0X3B3cnN0KG1wdV9wd3JkbSk7CiAKIAlpZiAob21hcF90eXBlKCkgIT0gT01BUDJfREVWSUNFX1RZUEVfR1ApIHsKIAkJLyoKQEAgLTE4MSw3ICsxODIsNyBAQAogCQlwd3JkbV9zZXRfbmV4dF9wd3JzdChtcHVfcHdyZG0sIFBXUkRNX1BPV0VSX09OKTsKIAkJcmV0ID0gX29tYXBfc2F2ZV9zZWN1cmVfc3JhbSgodTMyICopCiAJCQkJX19wYShvbWFwM19zZWN1cmVfcmFtX3N0b3JhZ2UpKTsKLQkJcHdyZG1fc2V0X25leHRfcHdyc3QobXB1X3B3cmRtLCB0YXJnZXRfbXB1X3N0YXRlKTsKKwkJcHdyZG1fc2V0X25leHRfcHdyc3QobXB1X3B3cmRtLCBtcHVfbmV4dF9zdGF0ZSk7CiAJCS8qIEZvbGxvd2luZyBpcyBmb3IgZXJyb3IgdHJhY2tpbmcsIGl0IHNob3VsZCBub3QgaGFwcGVuICovCiAJCWlmIChyZXQpIHsKIAkJCXByaW50ayhLRVJOX0VSUiAic2F2ZV9zZWN1cmVfc3JhbSgpIHJldHVybnMgJTA4eFxuIiwKQEAgLTM5OCw3ICszOTksNyBAQAogCWlmICghaXNfc3VzcGVuZGluZygpKQogCQlpZiAocGVyX25leHRfc3RhdGUgPCBQV1JETV9QT1dFUl9PTiB8fAogCQkgICAgY29yZV9uZXh0X3N0YXRlIDwgUFdSRE1fUE9XRVJfT04pCi0JCQlpZiAodHJ5X2FjcXVpcmVfY29uc29sZV9zZW0oKSkKKwkJCWlmICghY29uc29sZV90cnlsb2NrKCkpCiAJCQkJZ290byBjb25zb2xlX3N0aWxsX2FjdGl2ZTsKIAogCS8qIFBFUiAqLwpAQCAtNDgxLDcgKzQ4Miw3IEBACiAJfQogCiAJaWYgKCFpc19zdXNwZW5kaW5nKCkpCi0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAogY29uc29sZV9zdGlsbF9hY3RpdmU6CiAJLyogRGlzYWJsZSBJTy1QQUQgYW5kIElPLUNIQUlOIHdha2V1cCAqLwpAQCAtMTA5NCw3ICsxMDk1LDcgQEAKIAkJbG9jYWxfZmlxX2Rpc2FibGUoKTsKIAogCQlvbWFwX2RtYV9nbG9iYWxfY29udGV4dF9zYXZlKCk7Ci0JCW9tYXAzX3NhdmVfc2VjdXJlX3JhbV9jb250ZXh0KFBXUkRNX1BPV0VSX09OKTsKKwkJb21hcDNfc2F2ZV9zZWN1cmVfcmFtX2NvbnRleHQoKTsKIAkJb21hcF9kbWFfZ2xvYmFsX2NvbnRleHRfcmVzdG9yZSgpOwogCiAJCWxvY2FsX2lycV9lbmFibGUoKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvcG1fYnVzLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3BtX2J1cy5jCmluZGV4IDc4NDk4OWYuLjVhY2QyYWIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvcG1fYnVzLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9wbV9idXMuYwpAQCAtMjAsNyArMjAsNyBAQAogI2luY2x1ZGUgPHBsYXQvb21hcC1wbS5oPgogCiAjaWZkZWYgQ09ORklHX1BNX1JVTlRJTUUKLWludCBvbWFwX3BtX3J1bnRpbWVfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCitzdGF0aWMgaW50IG9tYXBfcG1fcnVudGltZV9zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRldikKIHsKIAlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2ID0gdG9fcGxhdGZvcm1fZGV2aWNlKGRldik7CiAJaW50IHIsIHJldCA9IDA7CkBAIC0zNyw3ICszNyw3IEBACiAJcmV0dXJuIHJldDsKIH07CiAKLWludCBvbWFwX3BtX3J1bnRpbWVfcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRldikKK3N0YXRpYyBpbnQgb21hcF9wbV9ydW50aW1lX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiA9IHRvX3BsYXRmb3JtX2RldmljZShkZXYpOwogCWludCByOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9wb3dlcmRvbWFpbjJ4eHhfM3h4eC5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9wb3dlcmRvbWFpbjJ4eHhfM3h4eC5jCmluZGV4IGQ1MjMzODkuLmNmNjAwZTIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvcG93ZXJkb21haW4yeHh4XzN4eHguYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3Bvd2VyZG9tYWluMnh4eF8zeHh4LmMKQEAgLTE5LDcgKzE5LDYgQEAKICNpbmNsdWRlIDxwbGF0L3ByY20uaD4KIAogI2luY2x1ZGUgInBvd2VyZG9tYWluLmgiCi0jaW5jbHVkZSAicHJtLXJlZ2JpdHMtMzR4eC5oIgogI2luY2x1ZGUgInBybS5oIgogI2luY2x1ZGUgInBybS1yZWdiaXRzLTI0eHguaCIKICNpbmNsdWRlICJwcm0tcmVnYml0cy0zNHh4LmgiCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL3BybTJ4eHhfM3h4eC5oIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9wcm0yeHh4XzN4eHguaAppbmRleCA1M2Q0NGY2Li40OTY1NGM4IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL3BybTJ4eHhfM3h4eC5oCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvcHJtMnh4eF8zeHh4LmgKQEAgLTIyOCw3ICsyMjgsNjcgQEAKIAogCiAjaWZuZGVmIF9fQVNTRU1CTEVSX18KLQorLyoKKyAqIFN0dWIgb21hcDJ4eHgvb21hcDN4eHggZnVuY3Rpb25zIHNvIHRoYXQgY29tbW9uIGZpbGVzCisgKiBjb250aW51ZSB0byBidWlsZCB3aGVuIGN1c3RvbSBidWlsZHMgYXJlIHVzZWQKKyAqLworI2lmIGRlZmluZWQoQ09ORklHX0FSQ0hfT01BUDQpICYmICEoZGVmaW5lZChDT05GSUdfQVJDSF9PTUFQMikgfHwJXAorCQkJCQlkZWZpbmVkKENPTkZJR19BUkNIX09NQVAzKSkKK3N0YXRpYyBpbmxpbmUgdTMyIG9tYXAyX3BybV9yZWFkX21vZF9yZWcoczE2IG1vZHVsZSwgdTE2IGlkeCkKK3sKKwlXQVJOKDEsICJwcm06IG9tYXAyeHh4L29tYXAzeHh4IHNwZWNpZmljIGZ1bmN0aW9uIGFuZCAiCisJCSJub3Qgc3VwcG9zZSB0byBiZSB1c2VkIG9uIG9tYXA0XG4iKTsKKwlyZXR1cm4gMDsKK30KK3N0YXRpYyBpbmxpbmUgdm9pZCBvbWFwMl9wcm1fd3JpdGVfbW9kX3JlZyh1MzIgdmFsLCBzMTYgbW9kdWxlLCB1MTYgaWR4KQoreworCVdBUk4oMSwgInBybTogb21hcDJ4eHgvb21hcDN4eHggc3BlY2lmaWMgZnVuY3Rpb24gYW5kICIKKwkJIm5vdCBzdXBwb3NlIHRvIGJlIHVzZWQgb24gb21hcDRcbiIpOworfQorc3RhdGljIGlubGluZSB1MzIgb21hcDJfcHJtX3Jtd19tb2RfcmVnX2JpdHModTMyIG1hc2ssIHUzMiBiaXRzLAorCQlzMTYgbW9kdWxlLCBzMTYgaWR4KQoreworCVdBUk4oMSwgInBybTogb21hcDJ4eHgvb21hcDN4eHggc3BlY2lmaWMgZnVuY3Rpb24gYW5kICIKKwkJIm5vdCBzdXBwb3NlIHRvIGJlIHVzZWQgb24gb21hcDRcbiIpOworCXJldHVybiAwOworfQorc3RhdGljIGlubGluZSB1MzIgb21hcDJfcHJtX3NldF9tb2RfcmVnX2JpdHModTMyIGJpdHMsIHMxNiBtb2R1bGUsIHMxNiBpZHgpCit7CisJV0FSTigxLCAicHJtOiBvbWFwMnh4eC9vbWFwM3h4eCBzcGVjaWZpYyBmdW5jdGlvbiBhbmQgIgorCQkibm90IHN1cHBvc2UgdG8gYmUgdXNlZCBvbiBvbWFwNFxuIik7CisJcmV0dXJuIDA7Cit9CitzdGF0aWMgaW5saW5lIHUzMiBvbWFwMl9wcm1fY2xlYXJfbW9kX3JlZ19iaXRzKHUzMiBiaXRzLCBzMTYgbW9kdWxlLCBzMTYgaWR4KQoreworCVdBUk4oMSwgInBybTogb21hcDJ4eHgvb21hcDN4eHggc3BlY2lmaWMgZnVuY3Rpb24gYW5kICIKKwkJIm5vdCBzdXBwb3NlIHRvIGJlIHVzZWQgb24gb21hcDRcbiIpOworCXJldHVybiAwOworfQorc3RhdGljIGlubGluZSB1MzIgb21hcDJfcHJtX3JlYWRfbW9kX2JpdHNfc2hpZnQoczE2IGRvbWFpbiwgczE2IGlkeCwgdTMyIG1hc2spCit7CisJV0FSTigxLCAicHJtOiBvbWFwMnh4eC9vbWFwM3h4eCBzcGVjaWZpYyBmdW5jdGlvbiBhbmQgIgorCQkibm90IHN1cHBvc2UgdG8gYmUgdXNlZCBvbiBvbWFwNFxuIik7CisJcmV0dXJuIDA7Cit9CitzdGF0aWMgaW5saW5lIGludCBvbWFwMl9wcm1faXNfaGFyZHJlc2V0X2Fzc2VydGVkKHMxNiBwcm1fbW9kLCB1OCBzaGlmdCkKK3sKKwlXQVJOKDEsICJwcm06IG9tYXAyeHh4L29tYXAzeHh4IHNwZWNpZmljIGZ1bmN0aW9uIGFuZCAiCisJCSJub3Qgc3VwcG9zZSB0byBiZSB1c2VkIG9uIG9tYXA0XG4iKTsKKwlyZXR1cm4gMDsKK30KK3N0YXRpYyBpbmxpbmUgaW50IG9tYXAyX3BybV9hc3NlcnRfaGFyZHJlc2V0KHMxNiBwcm1fbW9kLCB1OCBzaGlmdCkKK3sKKwlXQVJOKDEsICJwcm06IG9tYXAyeHh4L29tYXAzeHh4IHNwZWNpZmljIGZ1bmN0aW9uIGFuZCAiCisJCSJub3Qgc3VwcG9zZSB0byBiZSB1c2VkIG9uIG9tYXA0XG4iKTsKKwlyZXR1cm4gMDsKK30KK3N0YXRpYyBpbmxpbmUgaW50IG9tYXAyX3BybV9kZWFzc2VydF9oYXJkcmVzZXQoczE2IHBybV9tb2QsIHU4IHNoaWZ0KQoreworCVdBUk4oMSwgInBybTogb21hcDJ4eHgvb21hcDN4eHggc3BlY2lmaWMgZnVuY3Rpb24gYW5kICIKKwkJIm5vdCBzdXBwb3NlIHRvIGJlIHVzZWQgb24gb21hcDRcbiIpOworCXJldHVybiAwOworfQorI2Vsc2UKIC8qIFBvd2VyL3Jlc2V0IG1hbmFnZW1lbnQgZG9tYWluIHJlZ2lzdGVyIGdldC9zZXQgKi8KIGV4dGVybiB1MzIgb21hcDJfcHJtX3JlYWRfbW9kX3JlZyhzMTYgbW9kdWxlLCB1MTYgaWR4KTsKIGV4dGVybiB2b2lkIG9tYXAyX3BybV93cml0ZV9tb2RfcmVnKHUzMiB2YWwsIHMxNiBtb2R1bGUsIHUxNiBpZHgpOwpAQCAtMjQyLDYgKzMwMiw3IEBACiBleHRlcm4gaW50IG9tYXAyX3BybV9hc3NlcnRfaGFyZHJlc2V0KHMxNiBwcm1fbW9kLCB1OCBzaGlmdCk7CiBleHRlcm4gaW50IG9tYXAyX3BybV9kZWFzc2VydF9oYXJkcmVzZXQoczE2IHBybV9tb2QsIHU4IHNoaWZ0KTsKIAorI2VuZGlmCS8qIENPTkZJR19BUkNIX09NQVA0ICovCiAjZW5kaWYKIAogLyoKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvc2VyaWFsLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3NlcmlhbC5jCmluZGV4IDMwMmRhNzQuLjMyZTkxYTkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvc2VyaWFsLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9zZXJpYWwuYwpAQCAtODEyLDcgKzgxMiw3IEBACiAKIAlvaC0+ZGV2X2F0dHIgPSB1YXJ0OwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOyAvKiBpbiBjYXNlIHRoZSBlYXJseWNvbiBpcyBvbiB0aGUgVUFSVCAqLworCWNvbnNvbGVfbG9jaygpOyAvKiBpbiBjYXNlIHRoZSBlYXJseWNvbiBpcyBvbiB0aGUgVUFSVCAqLwogCiAJLyoKIAkgKiBCZWNhdXNlIG9mIGVhcmx5IFVBUlQgcHJvYmluZywgVUFSVCBkaWQgbm90IGdldCBpZGxlZApAQCAtODM4LDcgKzgzOCw3IEBACiAJb21hcF91YXJ0X2Jsb2NrX3NsZWVwKHVhcnQpOwogCXVhcnQtPnRpbWVvdXQgPSBERUZBVUxUX1RJTUVPVVQ7CiAKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCWlmICgoY3B1X2lzX29tYXAzNHh4KCkgJiYgdWFydC0+cGFkY29uZikgfHwKIAkgICAgKHVhcnQtPndrX2VuICYmIHVhcnQtPndrX21hc2spKSB7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL3NtYXJ0cmVmbGV4LmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3NtYXJ0cmVmbGV4LmMKaW5kZXggNzdlY2ViZi4uYzM3ZTgyMyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9zbWFydHJlZmxleC5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvc21hcnRyZWZsZXguYwpAQCAtNzgwLDggKzc4MCw3IEBACiAJc3RydWN0IG9tYXBfc3IgKnNyX2luZm8gPSAoc3RydWN0IG9tYXBfc3IgKikgZGF0YTsKIAogCWlmICghc3JfaW5mbykgewotCQlwcl93YXJuaW5nKCIlczogb21hcF9zciBzdHJ1Y3QgZm9yIHNyXyVzIG5vdCBmb3VuZFxuIiwKLQkJCV9fZnVuY19fLCBzcl9pbmZvLT52b2x0ZG0tPm5hbWUpOworCQlwcl93YXJuaW5nKCIlczogb21hcF9zciBzdHJ1Y3Qgbm90IGZvdW5kXG4iLCBfX2Z1bmNfXyk7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIApAQCAtNzk1LDggKzc5NCw3IEBACiAJc3RydWN0IG9tYXBfc3IgKnNyX2luZm8gPSAoc3RydWN0IG9tYXBfc3IgKikgZGF0YTsKIAogCWlmICghc3JfaW5mbykgewotCQlwcl93YXJuaW5nKCIlczogb21hcF9zciBzdHJ1Y3QgZm9yIHNyXyVzIG5vdCBmb3VuZFxuIiwKLQkJCV9fZnVuY19fLCBzcl9pbmZvLT52b2x0ZG0tPm5hbWUpOworCQlwcl93YXJuaW5nKCIlczogb21hcF9zciBzdHJ1Y3Qgbm90IGZvdW5kXG4iLCBfX2Z1bmNfXyk7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIApAQCAtODM0LDcgKzgzMiw4IEBACiAKIAlpZiAoIXBkYXRhKSB7CiAJCWRldl9lcnIoJnBkZXYtPmRldiwgIiVzOiBwbGF0Zm9ybSBkYXRhIG1pc3NpbmdcbiIsIF9fZnVuY19fKTsKLQkJcmV0dXJuIC1FSU5WQUw7CisJCXJldCA9IC1FSU5WQUw7CisJCWdvdG8gZXJyX2ZyZWVfZGV2aW5mbzsKIAl9CiAKIAltZW0gPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9NRU0sIDApOwpAQCAtOTY2LDcgKzk2NSw3IEBACiAJfQogCiAJc3JfaW5mbyA9IF9zcl9sb29rdXAocGRhdGEtPnZvbHRkbSk7Ci0JaWYgKCFzcl9pbmZvKSB7CisJaWYgKElTX0VSUihzcl9pbmZvKSkgewogCQlkZXZfd2FybigmcGRldi0+ZGV2LCAiJXM6IG9tYXBfc3Igc3RydWN0IG5vdCBmb3VuZFxuIiwKIAkJCV9fZnVuY19fKTsKIAkJcmV0dXJuIC1FSU5WQUw7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL3NyX2RldmljZS5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9zcl9kZXZpY2UuYwppbmRleCA3ODZkNjg1Li5iMWUwYWYxIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL3NyX2RldmljZS5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvc3JfZGV2aWNlLmMKQEAgLTI3LDYgKzI3LDcgQEAKICNpbmNsdWRlIDxwbGF0L3ZvbHRhZ2UuaD4KIAogI2luY2x1ZGUgImNvbnRyb2wuaCIKKyNpbmNsdWRlICJwbS5oIgogCiBzdGF0aWMgYm9vbCBzcl9lbmFibGVfb25faW5pdDsKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi90aW1lci1ncC5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi90aW1lci1ncC5jCmluZGV4IDRlNDhlNzguLjdiN2MyNjggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvdGltZXItZ3AuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3RpbWVyLWdwLmMKQEAgLTQyLDYgKzQyLDggQEAKIAogI2luY2x1ZGUgInRpbWVyLWdwLmgiCiAKKyNpbmNsdWRlIDxwbGF0L2NvbW1vbi5oPgorCiAvKiBNQVhfR1BUSU1FUl9JRDogbnVtYmVyIG9mIEdQVElNRVJzIG9uIHRoZSBjaGlwICovCiAjZGVmaW5lIE1BWF9HUFRJTUVSX0lECQkxMgogCkBAIC0xNzYsMTAgKzE3OCwxNCBAQAogLyogCiAgKiBXaGVuIDMyay10aW1lciBpcyBlbmFibGVkLCBkb24ndCB1c2UgR1BUaW1lciBmb3IgY2xvY2tzb3VyY2UKICAqIGluc3RlYWQsIGp1c3QgbGVhdmUgZGVmYXVsdCBjbG9ja3NvdXJjZSB3aGljaCB1c2VzIHRoZSAzMmsKLSAqIHN5bmMgY291bnRlci4gIFNlZSBjbG9ja3NvdXJjZSBzZXR1cCBpbiBzZWUgcGxhdC1vbWFwL2NvbW1vbi5jLiAKKyAqIHN5bmMgY291bnRlci4gIFNlZSBjbG9ja3NvdXJjZSBzZXR1cCBpbiBwbGF0LW9tYXAvY291bnRlcl8zMmsuYwogICovCiAKLXN0YXRpYyBpbmxpbmUgdm9pZCBfX2luaXQgb21hcDJfZ3BfY2xvY2tzb3VyY2VfaW5pdCh2b2lkKSB7fQorc3RhdGljIHZvaWQgX19pbml0IG9tYXAyX2dwX2Nsb2Nrc291cmNlX2luaXQodm9pZCkKK3sKKwlvbWFwX2luaXRfY2xvY2tzb3VyY2VfMzJrKCk7Cit9CisKICNlbHNlCiAvKgogICogY2xvY2tzb3VyY2UKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvdm9sdGFnZS5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi92b2x0YWdlLmMKaW5kZXggZWQ2MDc5YzkuLjEyYmU1MjUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtb21hcDIvdm9sdGFnZS5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvdm9sdGFnZS5jCkBAIC00NzEsNiArNDcxLDcgQEAKIAlzdHJjYXQobmFtZSwgdmRkLT52b2x0ZG0ubmFtZSk7CiAKIAl2ZGQtPmRlYnVnX2RpciA9IGRlYnVnZnNfY3JlYXRlX2RpcihuYW1lLCB2b2x0YWdlX2Rpcik7CisJa2ZyZWUobmFtZSk7CiAJaWYgKElTX0VSUih2ZGQtPmRlYnVnX2RpcikpIHsKIAkJcHJfd2FybmluZygiJXM6IFVuYWJsZSB0byBjcmVhdGUgZGVidWdmcyBkaXJlY3RvcnkgZm9yIgogCQkJIiB2ZGRfJXNcbiIsIF9fZnVuY19fLCB2ZGQtPnZvbHRkbS5uYW1lKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvd2RfdGltZXIuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvd2RfdGltZXIuYwppbmRleCBiMGM0OTA3Li40MDY3NjY5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL3dkX3RpbWVyLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi93ZF90aW1lci5jCkBAIC0xMyw2ICsxMyw4IEBACiAKICNpbmNsdWRlIDxwbGF0L29tYXBfaHdtb2QuaD4KIAorI2luY2x1ZGUgIndkX3RpbWVyLmgiCisKIC8qCiAgKiBJbiBvcmRlciB0byBhdm9pZCBhbnkgYXNzdW1wdGlvbnMgZnJvbSBib290bG9hZGVyIHJlZ2FyZGluZyBXRFQKICAqIHNldHRpbmdzLCBXRFQgbW9kdWxlIGlzIHJlc2V0IGR1cmluZyBpbml0LiBUaGlzIGVuYWJsZXMgdGhlIHdhdGNoZG9nCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXBueDQwMDgvaXJxLmMgYi9hcmNoL2FybS9tYWNoLXBueDQwMDgvaXJxLmMKaW5kZXggYTljZTAyYi4uYzY5YzE4MCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1wbng0MDA4L2lycS5jCisrKyBiL2FyY2gvYXJtL21hY2gtcG54NDAwOC9pcnEuYwpAQCAtMzYsNDQgKzM2LDQ0IEBACiAKIHN0YXRpYyB1OCBwbng0MDA4X2lycV90eXBlW05SX0lSUVNdID0gUE5YNDAwOF9JUlFfVFlQRVM7CiAKLXN0YXRpYyB2b2lkIHBueDQwMDhfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHBueDQwMDhfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCV9fcmF3X3dyaXRlbChfX3Jhd19yZWFkbChJTlRDX0VSKGlycSkpICYgfklOVENfQklUKGlycSksIElOVENfRVIoaXJxKSk7CS8qIG1hc2sgaW50ZXJydXB0ICovCisJX19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKElOVENfRVIoZC0+aXJxKSkgJiB+SU5UQ19CSVQoZC0+aXJxKSwgSU5UQ19FUihkLT5pcnEpKTsJLyogbWFzayBpbnRlcnJ1cHQgKi8KIH0KIAotc3RhdGljIHZvaWQgcG54NDAwOF91bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBwbng0MDA4X3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCV9fcmF3X3dyaXRlbChfX3Jhd19yZWFkbChJTlRDX0VSKGlycSkpIHwgSU5UQ19CSVQoaXJxKSwgSU5UQ19FUihpcnEpKTsJLyogdW5tYXNrIGludGVycnVwdCAqLworCV9fcmF3X3dyaXRlbChfX3Jhd19yZWFkbChJTlRDX0VSKGQtPmlycSkpIHwgSU5UQ19CSVQoZC0+aXJxKSwgSU5UQ19FUihkLT5pcnEpKTsJLyogdW5tYXNrIGludGVycnVwdCAqLwogfQogCi1zdGF0aWMgdm9pZCBwbng0MDA4X21hc2tfYWNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgcG54NDAwOF9tYXNrX2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCV9fcmF3X3dyaXRlbChfX3Jhd19yZWFkbChJTlRDX0VSKGlycSkpICYgfklOVENfQklUKGlycSksIElOVENfRVIoaXJxKSk7CS8qIG1hc2sgaW50ZXJydXB0ICovCi0JX19yYXdfd3JpdGVsKElOVENfQklUKGlycSksIElOVENfU1IoaXJxKSk7CS8qIGNsZWFyIGludGVycnVwdCBzdGF0dXMgKi8KKwlfX3Jhd193cml0ZWwoX19yYXdfcmVhZGwoSU5UQ19FUihkLT5pcnEpKSAmIH5JTlRDX0JJVChkLT5pcnEpLCBJTlRDX0VSKGQtPmlycSkpOwkvKiBtYXNrIGludGVycnVwdCAqLworCV9fcmF3X3dyaXRlbChJTlRDX0JJVChkLT5pcnEpLCBJTlRDX1NSKGQtPmlycSkpOwkvKiBjbGVhciBpbnRlcnJ1cHQgc3RhdHVzICovCiB9CiAKLXN0YXRpYyBpbnQgcG54NDAwOF9zZXRfaXJxX3R5cGUodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IHR5cGUpCitzdGF0aWMgaW50IHBueDQwMDhfc2V0X2lycV90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IHR5cGUpCiB7CiAJc3dpdGNoICh0eXBlKSB7CiAJY2FzZSBJUlFfVFlQRV9FREdFX1JJU0lORzoKLQkJX19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKElOVENfQVRSKGlycSkpIHwgSU5UQ19CSVQoaXJxKSwgSU5UQ19BVFIoaXJxKSk7CS8qZWRnZSBzZW5zaXRpdmUgKi8KLQkJX19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKElOVENfQVBSKGlycSkpIHwgSU5UQ19CSVQoaXJxKSwgSU5UQ19BUFIoaXJxKSk7CS8qcmlzaW5nIGVkZ2UgKi8KLQkJc2V0X2lycV9oYW5kbGVyKGlycSwgaGFuZGxlX2VkZ2VfaXJxKTsKKwkJX19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKElOVENfQVRSKGQtPmlycSkpIHwgSU5UQ19CSVQoZC0+aXJxKSwgSU5UQ19BVFIoZC0+aXJxKSk7CS8qZWRnZSBzZW5zaXRpdmUgKi8KKwkJX19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKElOVENfQVBSKGQtPmlycSkpIHwgSU5UQ19CSVQoZC0+aXJxKSwgSU5UQ19BUFIoZC0+aXJxKSk7CS8qcmlzaW5nIGVkZ2UgKi8KKwkJc2V0X2lycV9oYW5kbGVyKGQtPmlycSwgaGFuZGxlX2VkZ2VfaXJxKTsKIAkJYnJlYWs7CiAJY2FzZSBJUlFfVFlQRV9FREdFX0ZBTExJTkc6Ci0JCV9fcmF3X3dyaXRlbChfX3Jhd19yZWFkbChJTlRDX0FUUihpcnEpKSB8IElOVENfQklUKGlycSksIElOVENfQVRSKGlycSkpOwkvKmVkZ2Ugc2Vuc2l0aXZlICovCi0JCV9fcmF3X3dyaXRlbChfX3Jhd19yZWFkbChJTlRDX0FQUihpcnEpKSAmIH5JTlRDX0JJVChpcnEpLCBJTlRDX0FQUihpcnEpKTsJLypmYWxsaW5nIGVkZ2UgKi8KLQkJc2V0X2lycV9oYW5kbGVyKGlycSwgaGFuZGxlX2VkZ2VfaXJxKTsKKwkJX19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKElOVENfQVRSKGQtPmlycSkpIHwgSU5UQ19CSVQoZC0+aXJxKSwgSU5UQ19BVFIoZC0+aXJxKSk7CS8qZWRnZSBzZW5zaXRpdmUgKi8KKwkJX19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKElOVENfQVBSKGQtPmlycSkpICYgfklOVENfQklUKGQtPmlycSksIElOVENfQVBSKGQtPmlycSkpOwkvKmZhbGxpbmcgZWRnZSAqLworCQlzZXRfaXJxX2hhbmRsZXIoZC0+aXJxLCBoYW5kbGVfZWRnZV9pcnEpOwogCQlicmVhazsKIAljYXNlIElSUV9UWVBFX0xFVkVMX0xPVzoKLQkJX19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKElOVENfQVRSKGlycSkpICYgfklOVENfQklUKGlycSksIElOVENfQVRSKGlycSkpOwkvKmxldmVsIHNlbnNpdGl2ZSAqLwotCQlfX3Jhd193cml0ZWwoX19yYXdfcmVhZGwoSU5UQ19BUFIoaXJxKSkgJiB+SU5UQ19CSVQoaXJxKSwgSU5UQ19BUFIoaXJxKSk7CS8qbG93IGxldmVsICovCi0JCXNldF9pcnFfaGFuZGxlcihpcnEsIGhhbmRsZV9sZXZlbF9pcnEpOworCQlfX3Jhd193cml0ZWwoX19yYXdfcmVhZGwoSU5UQ19BVFIoZC0+aXJxKSkgJiB+SU5UQ19CSVQoZC0+aXJxKSwgSU5UQ19BVFIoZC0+aXJxKSk7CS8qbGV2ZWwgc2Vuc2l0aXZlICovCisJCV9fcmF3X3dyaXRlbChfX3Jhd19yZWFkbChJTlRDX0FQUihkLT5pcnEpKSAmIH5JTlRDX0JJVChkLT5pcnEpLCBJTlRDX0FQUihkLT5pcnEpKTsJLypsb3cgbGV2ZWwgKi8KKwkJc2V0X2lycV9oYW5kbGVyKGQtPmlycSwgaGFuZGxlX2xldmVsX2lycSk7CiAJCWJyZWFrOwogCWNhc2UgSVJRX1RZUEVfTEVWRUxfSElHSDoKLQkJX19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKElOVENfQVRSKGlycSkpICYgfklOVENfQklUKGlycSksIElOVENfQVRSKGlycSkpOwkvKmxldmVsIHNlbnNpdGl2ZSAqLwotCQlfX3Jhd193cml0ZWwoX19yYXdfcmVhZGwoSU5UQ19BUFIoaXJxKSkgfCBJTlRDX0JJVChpcnEpLCBJTlRDX0FQUihpcnEpKTsJLyogaGlnaCBsZXZlbCAqLwotCQlzZXRfaXJxX2hhbmRsZXIoaXJxLCBoYW5kbGVfbGV2ZWxfaXJxKTsKKwkJX19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKElOVENfQVRSKGQtPmlycSkpICYgfklOVENfQklUKGQtPmlycSksIElOVENfQVRSKGQtPmlycSkpOwkvKmxldmVsIHNlbnNpdGl2ZSAqLworCQlfX3Jhd193cml0ZWwoX19yYXdfcmVhZGwoSU5UQ19BUFIoZC0+aXJxKSkgfCBJTlRDX0JJVChkLT5pcnEpLCBJTlRDX0FQUihkLT5pcnEpKTsJLyogaGlnaCBsZXZlbCAqLworCQlzZXRfaXJxX2hhbmRsZXIoZC0+aXJxLCBoYW5kbGVfbGV2ZWxfaXJxKTsKIAkJYnJlYWs7CiAKIAkvKiBJUlFfVFlQRV9FREdFX0JPVEggaXMgbm90IHN1cHBvcnRlZCAqLwpAQCAtODUsMTAgKzg1LDEwIEBACiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgcG54NDAwOF9pcnFfY2hpcCA9IHsKLQkuYWNrID0gcG54NDAwOF9tYXNrX2Fja19pcnEsCi0JLm1hc2sgPSBwbng0MDA4X21hc2tfaXJxLAotCS51bm1hc2sgPSBwbng0MDA4X3VubWFza19pcnEsCi0JLnNldF90eXBlID0gcG54NDAwOF9zZXRfaXJxX3R5cGUsCisJLmlycV9hY2sgPSBwbng0MDA4X21hc2tfYWNrX2lycSwKKwkuaXJxX21hc2sgPSBwbng0MDA4X21hc2tfaXJxLAorCS5pcnFfdW5tYXNrID0gcG54NDAwOF91bm1hc2tfaXJxLAorCS5pcnFfc2V0X3R5cGUgPSBwbng0MDA4X3NldF9pcnFfdHlwZSwKIH07CiAKIHZvaWQgX19pbml0IHBueDQwMDhfaW5pdF9pcnEodm9pZCkKQEAgLTk5LDE0ICs5OSwxOCBAQAogCWZvciAoaSA9IDA7IGkgPCBOUl9JUlFTOyBpKyspIHsKIAkJc2V0X2lycV9mbGFncyhpLCBJUlFGX1ZBTElEKTsKIAkJc2V0X2lycV9jaGlwKGksICZwbng0MDA4X2lycV9jaGlwKTsKLQkJcG54NDAwOF9zZXRfaXJxX3R5cGUoaSwgcG54NDAwOF9pcnFfdHlwZVtpXSk7CisJCXBueDQwMDhfc2V0X2lycV90eXBlKGlycV9nZXRfaXJxX2RhdGEoaSksIHBueDQwMDhfaXJxX3R5cGVbaV0pOwogCX0KIAogCS8qIGNvbmZpZ3VyZSBhbmQgZW5hYmxlIElSUSAwLDEsMzAsMzEgKGNhc2NhZGUgaW50ZXJydXB0cykgKi8KLQlwbng0MDA4X3NldF9pcnFfdHlwZShTVUIxX0lSUV9OLCBwbng0MDA4X2lycV90eXBlW1NVQjFfSVJRX05dKTsKLQlwbng0MDA4X3NldF9pcnFfdHlwZShTVUIyX0lSUV9OLCBwbng0MDA4X2lycV90eXBlW1NVQjJfSVJRX05dKTsKLQlwbng0MDA4X3NldF9pcnFfdHlwZShTVUIxX0ZJUV9OLCBwbng0MDA4X2lycV90eXBlW1NVQjFfRklRX05dKTsKLQlwbng0MDA4X3NldF9pcnFfdHlwZShTVUIyX0ZJUV9OLCBwbng0MDA4X2lycV90eXBlW1NVQjJfRklRX05dKTsKKwlwbng0MDA4X3NldF9pcnFfdHlwZShpcnFfZ2V0X2lycV9kYXRhKFNVQjFfSVJRX04pLAorCQkJICAgICBwbng0MDA4X2lycV90eXBlW1NVQjFfSVJRX05dKTsKKwlwbng0MDA4X3NldF9pcnFfdHlwZShpcnFfZ2V0X2lycV9kYXRhKFNVQjJfSVJRX04pLAorCQkJICAgICBwbng0MDA4X2lycV90eXBlW1NVQjJfSVJRX05dKTsKKwlwbng0MDA4X3NldF9pcnFfdHlwZShpcnFfZ2V0X2lycV9kYXRhKFNVQjFfRklRX04pLAorCQkJICAgICBwbng0MDA4X2lycV90eXBlW1NVQjFfRklRX05dKTsKKwlwbng0MDA4X3NldF9pcnFfdHlwZShpcnFfZ2V0X2lycV9kYXRhKFNVQjJfRklRX04pLAorCQkJICAgICBwbng0MDA4X2lycV90eXBlW1NVQjJfRklRX05dKTsKIAogCS8qIG1hc2sgYWxsIG90aGVycyAqLwogCV9fcmF3X3dyaXRlbCgoMSA8PCBTVUIyX0ZJUV9OKSB8ICgxIDw8IFNVQjFfRklRX04pIHwKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtcHhhL2JhbGxvb24zLmMgYi9hcmNoL2FybS9tYWNoLXB4YS9iYWxsb29uMy5jCmluZGV4IGNjYjJkMGMuLmExMzRhMTQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtcHhhL2JhbGxvb24zLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1weGEvYmFsbG9vbjMuYwpAQCAtNDc3LDI1ICs0NzcsMjUgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqIEZQR0EgSVJRCiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotc3RhdGljIHZvaWQgYmFsbG9vbjNfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGJhbGxvb24zX21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpbnQgYmFsbG9vbjNfaXJxID0gKGlycSAtIEJBTExPT04zX0lSUSgwKSk7CisJaW50IGJhbGxvb24zX2lycSA9IChkLT5pcnEgLSBCQUxMT09OM19JUlEoMCkpOwogCWJhbGxvb24zX2lycV9lbmFibGVkICY9IH4oMSA8PCBiYWxsb29uM19pcnEpOwogCV9fcmF3X3dyaXRlbCh+YmFsbG9vbjNfaXJxX2VuYWJsZWQsIEJBTExPT04zX0lOVF9DT05UUk9MX1JFRyk7CiB9CiAKLXN0YXRpYyB2b2lkIGJhbGxvb24zX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGJhbGxvb24zX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCWludCBiYWxsb29uM19pcnEgPSAoaXJxIC0gQkFMTE9PTjNfSVJRKDApKTsKKwlpbnQgYmFsbG9vbjNfaXJxID0gKGQtPmlycSAtIEJBTExPT04zX0lSUSgwKSk7CiAJYmFsbG9vbjNfaXJxX2VuYWJsZWQgfD0gKDEgPDwgYmFsbG9vbjNfaXJxKTsKIAlfX3Jhd193cml0ZWwofmJhbGxvb24zX2lycV9lbmFibGVkLCBCQUxMT09OM19JTlRfQ09OVFJPTF9SRUcpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGJhbGxvb24zX2lycV9jaGlwID0gewogCS5uYW1lCQk9ICJGUEdBIiwKLQkuYWNrCQk9IGJhbGxvb24zX21hc2tfaXJxLAotCS5tYXNrCQk9IGJhbGxvb24zX21hc2tfaXJxLAotCS51bm1hc2sJCT0gYmFsbG9vbjNfdW5tYXNrX2lycSwKKwkuaXJxX2Fjawk9IGJhbGxvb24zX21hc2tfaXJxLAorCS5pcnFfbWFzawk9IGJhbGxvb24zX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gYmFsbG9vbjNfdW5tYXNrX2lycSwKIH07CiAKIHN0YXRpYyB2b2lkIGJhbGxvb24zX2lycV9oYW5kbGVyKHVuc2lnbmVkIGludCBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKQEAgLTUwNCw4ICs1MDQsMTMgQEAKIAkJCQkJYmFsbG9vbjNfaXJxX2VuYWJsZWQ7CiAJZG8gewogCQkvKiBjbGVhciB1c2VsZXNzIGVkZ2Ugbm90aWZpY2F0aW9uICovCi0JCWlmIChkZXNjLT5jaGlwLT5hY2spCi0JCQlkZXNjLT5jaGlwLT5hY2soQkFMTE9PTjNfQVVYX05JUlEpOworCQlpZiAoZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX2FjaykgeworCQkJc3RydWN0IGlycV9kYXRhICpkOworCisJCQlkID0gaXJxX2dldF9pcnFfZGF0YShCQUxMT09OM19BVVhfTklSUSk7CisJCQlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfYWNrKGQpOworCQl9CisKIAkJd2hpbGUgKHBlbmRpbmcpIHsKIAkJCWlycSA9IEJBTExPT04zX0lSUSgwKSArIF9fZmZzKHBlbmRpbmcpOwogCQkJZ2VuZXJpY19oYW5kbGVfaXJxKGlycSk7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXB4YS9jbG9jay1weGEzeHguYyBiL2FyY2gvYXJtL21hY2gtcHhhL2Nsb2NrLXB4YTN4eC5jCmluZGV4IDFiMDhhMzQuLjNmODY0Y2QgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtcHhhL2Nsb2NrLXB4YTN4eC5jCisrKyBiL2FyY2gvYXJtL21hY2gtcHhhL2Nsb2NrLXB4YTN4eC5jCkBAIC0xMTUsNyArMTE1LDYgQEAKIHsKIAl1bnNpZ25lZCBsb25nIGFjc3IgPSBBQ1NSOwogCXVuc2lnbmVkIGxvbmcgbWVtY2xrY2ZnID0gX19yYXdfcmVhZGwoTUVNQ0xLQ0ZHKTsKLQl1bnNpZ25lZCBpbnQgc21jZnMgPSAoYWNzciA+PiAyMykgJiAweDc7CiAKIAlyZXR1cm4gQkFTRV9DTEsgKiBzbWNmc19tdWx0WyhhY3NyID4+IDIzKSAmIDB4N10gLwogCQkJZGZfY2xrZGl2WyhtZW1jbGtjZmcgPj4gMTYpICYgMHgzXTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtcHhhL2NtLXgyeHgtcGNpLmMgYi9hcmNoL2FybS9tYWNoLXB4YS9jbS14Mnh4LXBjaS5jCmluZGV4IDBmMzEzMDUuLmEyMzgwY2QgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtcHhhL2NtLXgyeHgtcGNpLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1weGEvY20teDJ4eC1wY2kuYwpAQCAtNTksNyArNTksNyBAQAogc3RhdGljIHZvaWQgY214Mnh4X2l0ODE1Ml9pcnFfZGVtdXgodW5zaWduZWQgaW50IGlycSwgc3RydWN0IGlycV9kZXNjICpkZXNjKQogewogCS8qIGNsZWFyIG91ciBwYXJlbnQgaXJxICovCi0JZGVzYy0+Y2hpcC0+YWNrKGlycSk7CisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX2FjaygmZGVzYy0+aXJxX2RhdGEpOwogCiAJaXQ4MTUyX2lycV9kZW11eChpcnEsIGRlc2MpOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1weGEvZ2VuZXJpYy5jIGIvYXJjaC9hcm0vbWFjaC1weGEvZ2VuZXJpYy5jCmluZGV4IGQ2ZTE1ZjcuLmY1ZDkxZWYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtcHhhL2dlbmVyaWMuYworKysgYi9hcmNoL2FybS9tYWNoLXB4YS9nZW5lcmljLmMKQEAgLTIyLDcgKzIyLDYgQEAKIAogI2luY2x1ZGUgPG1hY2gvaGFyZHdhcmUuaD4KICNpbmNsdWRlIDxhc20vc3lzdGVtLmg+Ci0jaW5jbHVkZSA8YXNtL3BndGFibGUuaD4KICNpbmNsdWRlIDxhc20vbWFjaC9tYXAuaD4KICNpbmNsdWRlIDxhc20vbWFjaC10eXBlcy5oPgogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXB4YS9nZW5lcmljLmggYi9hcmNoL2FybS9tYWNoLXB4YS9nZW5lcmljLmgKaW5kZXggNjIwNWRjOS4uYTA3OWQ4YiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1weGEvZ2VuZXJpYy5oCisrKyBiL2FyY2gvYXJtL21hY2gtcHhhL2dlbmVyaWMuaApAQCAtOSwxMSArOSwxMyBAQAogICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCiAgKi8KIAorc3RydWN0IGlycV9kYXRhOwogc3RydWN0IHN5c190aW1lcjsKIAogZXh0ZXJuIHN0cnVjdCBzeXNfdGltZXIgcHhhX3RpbWVyOwogZXh0ZXJuIHZvaWQgX19pbml0IHB4YV9pbml0X2lycShpbnQgaXJxX25yLAotCQkJCWludCAoKnNldF93YWtlKSh1bnNpZ25lZCBpbnQsIHVuc2lnbmVkIGludCkpOworCQkJCWludCAoKnNldF93YWtlKShzdHJ1Y3QgaXJxX2RhdGEgKiwKKwkJCQkJCXVuc2lnbmVkIGludCkpOwogZXh0ZXJuIHZvaWQgX19pbml0IHB4YTI1eF9pbml0X2lycSh2b2lkKTsKICNpZmRlZiBDT05GSUdfQ1BVX1BYQTI2eAogZXh0ZXJuIHZvaWQgX19pbml0IHB4YTI2eF9pbml0X2lycSh2b2lkKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtcHhhL2lycS5jIGIvYXJjaC9hcm0vbWFjaC1weGEvaXJxLmMKaW5kZXggNTRlOTFjOS4uMjY5M2UzYyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1weGEvaXJxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1weGEvaXJxLmMKQEAgLTUzLDM3ICs1Myw0OCBAQAogCXJldHVybiAhY3B1X2lzX3B4YTI1eCgpOwogfQogCi1zdGF0aWMgdm9pZCBweGFfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2lvbWVtICppcnFfYmFzZShpbnQgaSkKIHsKLQl2b2lkIF9faW9tZW0gKmJhc2UgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0YXRpYyB1bnNpZ25lZCBsb25nIHBoeXNfYmFzZVtdID0geworCQkweDQwZDAwMDAwLAorCQkweDQwZDAwMDljLAorCQkweDQwZDAwMTMwLAorCX07CisKKwlyZXR1cm4gKHZvaWQgX19pb21lbSAqKWlvX3AydihwaHlzX2Jhc2VbaV0pOworfQorCitzdGF0aWMgdm9pZCBweGFfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQoreworCXZvaWQgX19pb21lbSAqYmFzZSA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOwogCXVpbnQzMl90IGljbXIgPSBfX3Jhd19yZWFkbChiYXNlICsgSUNNUik7CiAKLQlpY21yICY9IH4oMSA8PCBJUlFfQklUKGlycSkpOworCWljbXIgJj0gfigxIDw8IElSUV9CSVQoZC0+aXJxKSk7CiAJX19yYXdfd3JpdGVsKGljbXIsIGJhc2UgKyBJQ01SKTsKIH0KIAotc3RhdGljIHZvaWQgcHhhX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHB4YV91bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl2b2lkIF9faW9tZW0gKmJhc2UgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXZvaWQgX19pb21lbSAqYmFzZSA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOwogCXVpbnQzMl90IGljbXIgPSBfX3Jhd19yZWFkbChiYXNlICsgSUNNUik7CiAKLQlpY21yIHw9IDEgPDwgSVJRX0JJVChpcnEpOworCWljbXIgfD0gMSA8PCBJUlFfQklUKGQtPmlycSk7CiAJX19yYXdfd3JpdGVsKGljbXIsIGJhc2UgKyBJQ01SKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBweGFfaW50ZXJuYWxfaXJxX2NoaXAgPSB7CiAJLm5hbWUJCT0gIlNDIiwKLQkuYWNrCQk9IHB4YV9tYXNrX2lycSwKLQkubWFzawkJPSBweGFfbWFza19pcnEsCi0JLnVubWFzawkJPSBweGFfdW5tYXNrX2lycSwKKwkuaXJxX2Fjawk9IHB4YV9tYXNrX2lycSwKKwkuaXJxX21hc2sJPSBweGFfbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBweGFfdW5tYXNrX2lycSwKIH07CiAKIC8qCiAgKiBHUElPIElSUXMgZm9yIEdQSU8gMCBhbmQgMQogICovCi1zdGF0aWMgaW50IHB4YV9zZXRfbG93X2dwaW9fdHlwZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgdHlwZSkKK3N0YXRpYyBpbnQgcHhhX3NldF9sb3dfZ3Bpb190eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IHR5cGUpCiB7Ci0JaW50IGdwaW8gPSBpcnEgLSBJUlFfR1BJTzA7CisJaW50IGdwaW8gPSBkLT5pcnEgLSBJUlFfR1BJTzA7CiAKIAlpZiAoX19ncGlvX2lzX29jY3VwaWVkKGdwaW8pKSB7CiAJCXByX2VycigiJXMgZmFpbGVkOiBHUElPIGlzIGNvbmZpZ3VyZWRcbiIsIF9fZnVuY19fKTsKQEAgLTEwMywzMSArMTE0LDE3IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyB2b2lkIHB4YV9hY2tfbG93X2dwaW8odW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHB4YV9hY2tfbG93X2dwaW8oc3RydWN0IGlycV9kYXRhICpkKQogewotCUdFRFIwID0gKDEgPDwgKGlycSAtIElSUV9HUElPMCkpOwotfQotCi1zdGF0aWMgdm9pZCBweGFfbWFza19sb3dfZ3Bpbyh1bnNpZ25lZCBpbnQgaXJxKQotewotCXN0cnVjdCBpcnFfZGVzYyAqZGVzYyA9IGlycV90b19kZXNjKGlycSk7Ci0KLQlkZXNjLT5jaGlwLT5tYXNrKGlycSk7Ci19Ci0KLXN0YXRpYyB2b2lkIHB4YV91bm1hc2tfbG93X2dwaW8odW5zaWduZWQgaW50IGlycSkKLXsKLQlzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MgPSBpcnFfdG9fZGVzYyhpcnEpOwotCi0JZGVzYy0+Y2hpcC0+dW5tYXNrKGlycSk7CisJR0VEUjAgPSAoMSA8PCAoZC0+aXJxIC0gSVJRX0dQSU8wKSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgcHhhX2xvd19ncGlvX2NoaXAgPSB7CiAJLm5hbWUJCT0gIkdQSU8tbCIsCi0JLmFjawkJPSBweGFfYWNrX2xvd19ncGlvLAotCS5tYXNrCQk9IHB4YV9tYXNrX2xvd19ncGlvLAotCS51bm1hc2sJCT0gcHhhX3VubWFza19sb3dfZ3BpbywKLQkuc2V0X3R5cGUJPSBweGFfc2V0X2xvd19ncGlvX3R5cGUsCisJLmlycV9hY2sJPSBweGFfYWNrX2xvd19ncGlvLAorCS5pcnFfbWFzawk9IHB4YV9tYXNrX2lycSwKKwkuaXJxX3VubWFzawk9IHB4YV91bm1hc2tfaXJxLAorCS5pcnFfc2V0X3R5cGUJPSBweGFfc2V0X2xvd19ncGlvX3R5cGUsCiB9OwogCiBzdGF0aWMgdm9pZCBfX2luaXQgcHhhX2luaXRfbG93X2dwaW9faXJxKHNldF93YWtlX3QgZm4pCkBAIC0xNDEsMjIgKzEzOCwxMiBAQAogCiAJZm9yIChpcnEgPSBJUlFfR1BJTzA7IGlycSA8PSBJUlFfR1BJTzE7IGlycSsrKSB7CiAJCXNldF9pcnFfY2hpcChpcnEsICZweGFfbG93X2dwaW9fY2hpcCk7CisJCXNldF9pcnFfY2hpcF9kYXRhKGlycSwgaXJxX2Jhc2UoMCkpOwogCQlzZXRfaXJxX2hhbmRsZXIoaXJxLCBoYW5kbGVfZWRnZV9pcnEpOwogCQlzZXRfaXJxX2ZsYWdzKGlycSwgSVJRRl9WQUxJRCk7CiAJfQogCi0JcHhhX2xvd19ncGlvX2NoaXAuc2V0X3dha2UgPSBmbjsKLX0KLQotc3RhdGljIGlubGluZSB2b2lkIF9faW9tZW0gKmlycV9iYXNlKGludCBpKQotewotCXN0YXRpYyB1bnNpZ25lZCBsb25nIHBoeXNfYmFzZVtdID0gewotCQkweDQwZDAwMDAwLAotCQkweDQwZDAwMDljLAotCQkweDQwZDAwMTMwLAotCX07Ci0KLQlyZXR1cm4gKHZvaWQgX19pb21lbSAqKWlvX3AydihwaHlzX2Jhc2VbaSA+PiA1XSk7CisJcHhhX2xvd19ncGlvX2NoaXAuaXJxX3NldF93YWtlID0gZm47CiB9CiAKIHZvaWQgX19pbml0IHB4YV9pbml0X2lycShpbnQgaXJxX25yLCBzZXRfd2FrZV90IGZuKQpAQCAtMTY4LDcgKzE1NSw3IEBACiAJcHhhX2ludGVybmFsX2lycV9uciA9IGlycV9ucjsKIAogCWZvciAobiA9IDA7IG4gPCBpcnFfbnI7IG4gKz0gMzIpIHsKLQkJdm9pZCBfX2lvbWVtICpiYXNlID0gaXJxX2Jhc2Uobik7CisJCXZvaWQgX19pb21lbSAqYmFzZSA9IGlycV9iYXNlKG4gPj4gNSk7CiAKIAkJX19yYXdfd3JpdGVsKDAsIGJhc2UgKyBJQ01SKTsJLyogZGlzYWJsZSBhbGwgSVJRcyAqLwogCQlfX3Jhd193cml0ZWwoMCwgYmFzZSArIElDTFIpOwkvKiBhbGwgSVJRcyBhcmUgSVJRLCBub3QgRklRICovCkBAIC0xODgsNyArMTc1LDcgQEAKIAkvKiBvbmx5IHVubWFza2VkIGludGVycnVwdHMga2ljayB1cyBvdXQgb2YgaWRsZSAqLwogCV9fcmF3X3dyaXRlbCgxLCBpcnFfYmFzZSgwKSArIElDQ1IpOwogCi0JcHhhX2ludGVybmFsX2lycV9jaGlwLnNldF93YWtlID0gZm47CisJcHhhX2ludGVybmFsX2lycV9jaGlwLmlycV9zZXRfd2FrZSA9IGZuOwogCXB4YV9pbml0X2xvd19ncGlvX2lycShmbik7CiB9CiAKQEAgLTIwMCw3ICsxODcsNyBAQAogewogCWludCBpOwogCi0JZm9yIChpID0gMDsgaSA8IHB4YV9pbnRlcm5hbF9pcnFfbnI7IGkgKz0gMzIpIHsKKwlmb3IgKGkgPSAwOyBpIDwgcHhhX2ludGVybmFsX2lycV9uciAvIDMyOyBpKyspIHsKIAkJdm9pZCBfX2lvbWVtICpiYXNlID0gaXJxX2Jhc2UoaSk7CiAKIAkJc2F2ZWRfaWNtcltpXSA9IF9fcmF3X3JlYWRsKGJhc2UgKyBJQ01SKTsKQEAgLTIxOSwxNCArMjA2LDE0IEBACiB7CiAJaW50IGk7CiAKLQlmb3IgKGkgPSAwOyBpIDwgcHhhX2ludGVybmFsX2lycV9ucjsgaSArPSAzMikgeworCWZvciAoaSA9IDA7IGkgPCBweGFfaW50ZXJuYWxfaXJxX25yIC8gMzI7IGkrKykgewogCQl2b2lkIF9faW9tZW0gKmJhc2UgPSBpcnFfYmFzZShpKTsKIAogCQlfX3Jhd193cml0ZWwoc2F2ZWRfaWNtcltpXSwgYmFzZSArIElDTVIpOwogCQlfX3Jhd193cml0ZWwoMCwgYmFzZSArIElDTFIpOwogCX0KIAotCWlmICghY3B1X2lzX3B4YTI1eCgpKQorCWlmIChjcHVfaGFzX2lwcigpKQogCQlmb3IgKGkgPSAwOyBpIDwgcHhhX2ludGVybmFsX2lycV9ucjsgaSsrKQogCQkJX19yYXdfd3JpdGVsKHNhdmVkX2lwcltpXSwgSVJRX0JBU0UgKyBJUFIoaSkpOwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXB4YS9scGQyNzAuYyBiL2FyY2gvYXJtL21hY2gtcHhhL2xwZDI3MC5jCmluZGV4IDhhYjYyYTYuLmM5YTNlNzcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtcHhhL2xwZDI3MC5jCisrKyBiL2FyY2gvYXJtL21hY2gtcHhhL2xwZDI3MC5jCkBAIC05NSw5ICs5NSw5IEBACiAKIHN0YXRpYyB1bnNpZ25lZCBpbnQgbHBkMjcwX2lycV9lbmFibGVkOwogCi1zdGF0aWMgdm9pZCBscGQyNzBfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGxwZDI3MF9tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaW50IGxwZDI3MF9pcnEgPSBpcnEgLSBMUEQyNzBfSVJRKDApOworCWludCBscGQyNzBfaXJxID0gZC0+aXJxIC0gTFBEMjcwX0lSUSgwKTsKIAogCV9fcmF3X3dyaXRldyh+KDEgPDwgbHBkMjcwX2lycSksIExQRDI3MF9JTlRfU1RBVFVTKTsKIApAQCAtMTA1LDkgKzEwNSw5IEBACiAJX19yYXdfd3JpdGV3KGxwZDI3MF9pcnFfZW5hYmxlZCwgTFBEMjcwX0lOVF9NQVNLKTsKIH0KIAotc3RhdGljIHZvaWQgbHBkMjcwX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGxwZDI3MF91bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpbnQgbHBkMjcwX2lycSA9IGlycSAtIExQRDI3MF9JUlEoMCk7CisJaW50IGxwZDI3MF9pcnEgPSBkLT5pcnEgLSBMUEQyNzBfSVJRKDApOwogCiAJbHBkMjcwX2lycV9lbmFibGVkIHw9IDEgPDwgbHBkMjcwX2lycTsKIAlfX3Jhd193cml0ZXcobHBkMjcwX2lycV9lbmFibGVkLCBMUEQyNzBfSU5UX01BU0spOwpAQCAtMTE1LDkgKzExNSw5IEBACiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbHBkMjcwX2lycV9jaGlwID0gewogCS5uYW1lCQk9ICJDUExEIiwKLQkuYWNrCQk9IGxwZDI3MF9tYXNrX2lycSwKLQkubWFzawkJPSBscGQyNzBfbWFza19pcnEsCi0JLnVubWFzawkJPSBscGQyNzBfdW5tYXNrX2lycSwKKwkuaXJxX2Fjawk9IGxwZDI3MF9tYXNrX2lycSwKKwkuaXJxX21hc2sJPSBscGQyNzBfbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBscGQyNzBfdW5tYXNrX2lycSwKIH07CiAKIHN0YXRpYyB2b2lkIGxwZDI3MF9pcnFfaGFuZGxlcih1bnNpZ25lZCBpbnQgaXJxLCBzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MpCkBAIC0xMjYsNyArMTI2LDggQEAKIAogCXBlbmRpbmcgPSBfX3Jhd19yZWFkdyhMUEQyNzBfSU5UX1NUQVRVUykgJiBscGQyNzBfaXJxX2VuYWJsZWQ7CiAJZG8gewotCQlkZXNjLT5jaGlwLT5hY2soaXJxKTsJLyogY2xlYXIgdXNlbGVzcyBlZGdlIG5vdGlmaWNhdGlvbiAqLworCQkvKiBjbGVhciB1c2VsZXNzIGVkZ2Ugbm90aWZpY2F0aW9uICovCisJCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9hY2soJmRlc2MtPmlycV9kYXRhKTsKIAkJaWYgKGxpa2VseShwZW5kaW5nKSkgewogCQkJaXJxID0gTFBEMjcwX0lSUSgwKSArIF9fZmZzKHBlbmRpbmcpOwogCQkJZ2VuZXJpY19oYW5kbGVfaXJxKGlycSk7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXB4YS9sdWJib2NrLmMgYi9hcmNoL2FybS9tYWNoLXB4YS9sdWJib2NrLmMKaW5kZXggMzA3MmRiZS4uZGNhMjBkZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1weGEvbHViYm9jay5jCisrKyBiL2FyY2gvYXJtL21hY2gtcHhhL2x1YmJvY2suYwpAQCAtMTIyLDE1ICsxMjIsMTUgQEAKIAogc3RhdGljIHVuc2lnbmVkIGxvbmcgbHViYm9ja19pcnFfZW5hYmxlZDsKIAotc3RhdGljIHZvaWQgbHViYm9ja19tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbHViYm9ja19tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaW50IGx1YmJvY2tfaXJxID0gKGlycSAtIExVQkJPQ0tfSVJRKDApKTsKKwlpbnQgbHViYm9ja19pcnEgPSAoZC0+aXJxIC0gTFVCQk9DS19JUlEoMCkpOwogCUxVQl9JUlFfTUFTS19FTiA9IChsdWJib2NrX2lycV9lbmFibGVkICY9IH4oMSA8PCBsdWJib2NrX2lycSkpOwogfQogCi1zdGF0aWMgdm9pZCBsdWJib2NrX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGx1YmJvY2tfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaW50IGx1YmJvY2tfaXJxID0gKGlycSAtIExVQkJPQ0tfSVJRKDApKTsKKwlpbnQgbHViYm9ja19pcnEgPSAoZC0+aXJxIC0gTFVCQk9DS19JUlEoMCkpOwogCS8qIHRoZSBpcnEgY2FuIGJlIGFja25vd2xlZGdlZCBvbmx5IGlmIGRlYXNzZXJ0ZWQsIHNvIGl0J3MgZG9uZSBoZXJlICovCiAJTFVCX0lSUV9TRVRfQ0xSICY9IH4oMSA8PCBsdWJib2NrX2lycSk7CiAJTFVCX0lSUV9NQVNLX0VOID0gKGx1YmJvY2tfaXJxX2VuYWJsZWQgfD0gKDEgPDwgbHViYm9ja19pcnEpKTsKQEAgLTEzOCwxNiArMTM4LDE3IEBACiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbHViYm9ja19pcnFfY2hpcCA9IHsKIAkubmFtZQkJPSAiRlBHQSIsCi0JLmFjawkJPSBsdWJib2NrX21hc2tfaXJxLAotCS5tYXNrCQk9IGx1YmJvY2tfbWFza19pcnEsCi0JLnVubWFzawkJPSBsdWJib2NrX3VubWFza19pcnEsCisJLmlycV9hY2sJPSBsdWJib2NrX21hc2tfaXJxLAorCS5pcnFfbWFzawk9IGx1YmJvY2tfbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBsdWJib2NrX3VubWFza19pcnEsCiB9OwogCiBzdGF0aWMgdm9pZCBsdWJib2NrX2lycV9oYW5kbGVyKHVuc2lnbmVkIGludCBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKIHsKIAl1bnNpZ25lZCBsb25nIHBlbmRpbmcgPSBMVUJfSVJRX1NFVF9DTFIgJiBsdWJib2NrX2lycV9lbmFibGVkOwogCWRvIHsKLQkJZGVzYy0+Y2hpcC0+YWNrKGlycSk7CS8qIGNsZWFyIG91ciBwYXJlbnQgaXJxICovCisJCS8qIGNsZWFyIG91ciBwYXJlbnQgaXJxICovCisJCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9hY2soJmRlc2MtPmlycV9kYXRhKTsKIAkJaWYgKGxpa2VseShwZW5kaW5nKSkgewogCQkJaXJxID0gTFVCQk9DS19JUlEoMCkgKyBfX2ZmcyhwZW5kaW5nKTsKIAkJCWdlbmVyaWNfaGFuZGxlX2lycShpcnEpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1weGEvbWFpbnN0b25lLmMgYi9hcmNoL2FybS9tYWNoLXB4YS9tYWluc3RvbmUuYwppbmRleCA3NDBjMDM1Li5kNGI2ZjIzIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXB4YS9tYWluc3RvbmUuYworKysgYi9hcmNoL2FybS9tYWNoLXB4YS9tYWluc3RvbmUuYwpAQCAtMTIzLDE1ICsxMjMsMTUgQEAKIAogc3RhdGljIHVuc2lnbmVkIGxvbmcgbWFpbnN0b25lX2lycV9lbmFibGVkOwogCi1zdGF0aWMgdm9pZCBtYWluc3RvbmVfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1haW5zdG9uZV9tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaW50IG1haW5zdG9uZV9pcnEgPSAoaXJxIC0gTUFJTlNUT05FX0lSUSgwKSk7CisJaW50IG1haW5zdG9uZV9pcnEgPSAoZC0+aXJxIC0gTUFJTlNUT05FX0lSUSgwKSk7CiAJTVNUX0lOVE1TS0VOQSA9IChtYWluc3RvbmVfaXJxX2VuYWJsZWQgJj0gfigxIDw8IG1haW5zdG9uZV9pcnEpKTsKIH0KIAotc3RhdGljIHZvaWQgbWFpbnN0b25lX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1haW5zdG9uZV91bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpbnQgbWFpbnN0b25lX2lycSA9IChpcnEgLSBNQUlOU1RPTkVfSVJRKDApKTsKKwlpbnQgbWFpbnN0b25lX2lycSA9IChkLT5pcnEgLSBNQUlOU1RPTkVfSVJRKDApKTsKIAkvKiB0aGUgaXJxIGNhbiBiZSBhY2tub3dsZWRnZWQgb25seSBpZiBkZWFzc2VydGVkLCBzbyBpdCdzIGRvbmUgaGVyZSAqLwogCU1TVF9JTlRTRVRDTFIgJj0gfigxIDw8IG1haW5zdG9uZV9pcnEpOwogCU1TVF9JTlRNU0tFTkEgPSAobWFpbnN0b25lX2lycV9lbmFibGVkIHw9ICgxIDw8IG1haW5zdG9uZV9pcnEpKTsKQEAgLTEzOSwxNiArMTM5LDE3IEBACiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbWFpbnN0b25lX2lycV9jaGlwID0gewogCS5uYW1lCQk9ICJGUEdBIiwKLQkuYWNrCQk9IG1haW5zdG9uZV9tYXNrX2lycSwKLQkubWFzawkJPSBtYWluc3RvbmVfbWFza19pcnEsCi0JLnVubWFzawkJPSBtYWluc3RvbmVfdW5tYXNrX2lycSwKKwkuaXJxX2Fjawk9IG1haW5zdG9uZV9tYXNrX2lycSwKKwkuaXJxX21hc2sJPSBtYWluc3RvbmVfbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBtYWluc3RvbmVfdW5tYXNrX2lycSwKIH07CiAKIHN0YXRpYyB2b2lkIG1haW5zdG9uZV9pcnFfaGFuZGxlcih1bnNpZ25lZCBpbnQgaXJxLCBzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MpCiB7CiAJdW5zaWduZWQgbG9uZyBwZW5kaW5nID0gTVNUX0lOVFNFVENMUiAmIG1haW5zdG9uZV9pcnFfZW5hYmxlZDsKIAlkbyB7Ci0JCWRlc2MtPmNoaXAtPmFjayhpcnEpOwkvKiBjbGVhciB1c2VsZXNzIGVkZ2Ugbm90aWZpY2F0aW9uICovCisJCS8qIGNsZWFyIHVzZWxlc3MgZWRnZSBub3RpZmljYXRpb24gKi8KKwkJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX2FjaygmZGVzYy0+aXJxX2RhdGEpOwogCQlpZiAobGlrZWx5KHBlbmRpbmcpKSB7CiAJCQlpcnEgPSBNQUlOU1RPTkVfSVJRKDApICsgX19mZnMocGVuZGluZyk7CiAJCQlnZW5lcmljX2hhbmRsZV9pcnEoaXJxKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtcHhhL3BjbTk5MC1iYXNlYm9hcmQuYyBiL2FyY2gvYXJtL21hY2gtcHhhL3BjbTk5MC1iYXNlYm9hcmQuYwppbmRleCBmMzM2NDdhLi45MDgyMGZhIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXB4YS9wY205OTAtYmFzZWJvYXJkLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1weGEvcGNtOTkwLWJhc2Vib2FyZC5jCkBAIC0yNDEsMjMgKzI0MSwyMyBAQAogCiBzdGF0aWMgdW5zaWduZWQgbG9uZyBwY205OTBfaXJxX2VuYWJsZWQ7CiAKLXN0YXRpYyB2b2lkIHBjbTk5MF9tYXNrX2Fja19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHBjbTk5MF9tYXNrX2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCWludCBwY205OTBfaXJxID0gKGlycSAtIFBDTTAyN19JUlEoMCkpOworCWludCBwY205OTBfaXJxID0gKGQtPmlycSAtIFBDTTAyN19JUlEoMCkpOwogCVBDTTk5MF9JTlRNU0tFTkEgPSAocGNtOTkwX2lycV9lbmFibGVkICY9IH4oMSA8PCBwY205OTBfaXJxKSk7CiB9CiAKLXN0YXRpYyB2b2lkIHBjbTk5MF91bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBwY205OTBfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaW50IHBjbTk5MF9pcnEgPSAoaXJxIC0gUENNMDI3X0lSUSgwKSk7CisJaW50IHBjbTk5MF9pcnEgPSAoZC0+aXJxIC0gUENNMDI3X0lSUSgwKSk7CiAJLyogdGhlIGlycSBjYW4gYmUgYWNrbm93bGVkZ2VkIG9ubHkgaWYgZGVhc3NlcnRlZCwgc28gaXQncyBkb25lIGhlcmUgKi8KIAlQQ005OTBfSU5UU0VUQ0xSIHw9IDEgPDwgcGNtOTkwX2lycTsKIAlQQ005OTBfSU5UTVNLRU5BICA9IChwY205OTBfaXJxX2VuYWJsZWQgfD0gKDEgPDwgcGNtOTkwX2lycSkpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHBjbTk5MF9pcnFfY2hpcCA9IHsKLQkubWFza19hY2sJPSBwY205OTBfbWFza19hY2tfaXJxLAotCS51bm1hc2sJCT0gcGNtOTkwX3VubWFza19pcnEsCisJLmlycV9tYXNrX2Fjawk9IHBjbTk5MF9tYXNrX2Fja19pcnEsCisJLmlycV91bm1hc2sJPSBwY205OTBfdW5tYXNrX2lycSwKIH07CiAKIHN0YXRpYyB2b2lkIHBjbTk5MF9pcnFfaGFuZGxlcih1bnNpZ25lZCBpbnQgaXJxLCBzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MpCkBAIC0yNjUsNyArMjY1LDggQEAKIAl1bnNpZ25lZCBsb25nIHBlbmRpbmcgPSAoflBDTTk5MF9JTlRTRVRDTFIpICYgcGNtOTkwX2lycV9lbmFibGVkOwogCiAJZG8gewotCQlkZXNjLT5jaGlwLT5hY2soaXJxKTsJLyogY2xlYXIgb3VyIHBhcmVudCBJUlEgKi8KKwkJLyogY2xlYXIgb3VyIHBhcmVudCBJUlEgKi8KKwkJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX2FjaygmZGVzYy0+aXJxX2RhdGEpOwogCQlpZiAobGlrZWx5KHBlbmRpbmcpKSB7CiAJCQlpcnEgPSBQQ00wMjdfSVJRKDApICsgX19mZnMocGVuZGluZyk7CiAJCQlnZW5lcmljX2hhbmRsZV9pcnEoaXJxKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtcHhhL3B4YTI1eC5jIGIvYXJjaC9hcm0vbWFjaC1weGEvcHhhMjV4LmMKaW5kZXggM2Y1MjQxYy4uZmJjNWI3NyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1weGEvcHhhMjV4LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1weGEvcHhhMjV4LmMKQEAgLTIyLDYgKzIyLDcgQEAKICNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9zdXNwZW5kLmg+CiAjaW5jbHVkZSA8bGludXgvc3lzZGV2Lmg+CisjaW5jbHVkZSA8bGludXgvaXJxLmg+CiAKICNpbmNsdWRlIDxhc20vbWFjaC9tYXAuaD4KICNpbmNsdWRlIDxtYWNoL2hhcmR3YXJlLmg+CkBAIC0yODIsMTUgKzI4MywxNSBAQAogLyogUFhBMjV4OiBzdXBwb3J0cyB3YWtldXAgZnJvbSBHUElPMC4uR1BJTzE1IGFuZCBSVEMgYWxhcm0KICAqLwogCi1zdGF0aWMgaW50IHB4YTI1eF9zZXRfd2FrZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgb24pCitzdGF0aWMgaW50IHB4YTI1eF9zZXRfd2FrZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCBvbikKIHsKLQlpbnQgZ3BpbyA9IElSUV9UT19HUElPKGlycSk7CisJaW50IGdwaW8gPSBJUlFfVE9fR1BJTyhkLT5pcnEpOwogCXVpbnQzMl90IG1hc2sgPSAwOwogCiAJaWYgKGdwaW8gPj0gMCAmJiBncGlvIDwgODUpCiAJCXJldHVybiBncGlvX3NldF93YWtlKGdwaW8sIG9uKTsKIAotCWlmIChpcnEgPT0gSVJRX1JUQ0Fscm0pIHsKKwlpZiAoZC0+aXJxID09IElSUV9SVENBbHJtKSB7CiAJCW1hc2sgPSBQV0VSX1JUQzsKIAkJZ290byBzZXRfcHdlcjsKIAl9CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXB4YS9weGEyN3guYyBiL2FyY2gvYXJtL21hY2gtcHhhL3B4YTI3eC5jCmluZGV4IGIyMTMwYjcuLjk4NzMwMWYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtcHhhL3B4YTI3eC5jCisrKyBiL2FyY2gvYXJtL21hY2gtcHhhL3B4YTI3eC5jCkBAIC0xOCw2ICsxOCw3IEBACiAjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvc3lzZGV2Lmg+CiAjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9pcnEuaD4KIAogI2luY2x1ZGUgPGFzbS9tYWNoL21hcC5oPgogI2luY2x1ZGUgPG1hY2gvaGFyZHdhcmUuaD4KQEAgLTM0MywxOCArMzQ0LDE4IEBACiAvKiBQWEEyN3g6ICBWYXJpb3VzIGdwaW9zIGNhbiBpc3N1ZSB3YWtldXAgZXZlbnRzLiAgVGhpcyBsb2dpYyBvbmx5CiAgKiBoYW5kbGVzIHRoZSBzaW1wbGUgY2FzZXMsIG5vdCB0aGUgV0VNVVgyIGFuZCBXRU1VWDMgb3B0aW9ucwogICovCi1zdGF0aWMgaW50IHB4YTI3eF9zZXRfd2FrZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgb24pCitzdGF0aWMgaW50IHB4YTI3eF9zZXRfd2FrZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCBvbikKIHsKLQlpbnQgZ3BpbyA9IElSUV9UT19HUElPKGlycSk7CisJaW50IGdwaW8gPSBJUlFfVE9fR1BJTyhkLT5pcnEpOwogCXVpbnQzMl90IG1hc2s7CiAKIAlpZiAoZ3BpbyA+PSAwICYmIGdwaW8gPCAxMjgpCiAJCXJldHVybiBncGlvX3NldF93YWtlKGdwaW8sIG9uKTsKIAotCWlmIChpcnEgPT0gSVJRX0tFWVBBRCkKKwlpZiAoZC0+aXJxID09IElSUV9LRVlQQUQpCiAJCXJldHVybiBrZXlwYWRfc2V0X3dha2Uob24pOwogCi0Jc3dpdGNoIChpcnEpIHsKKwlzd2l0Y2ggKGQtPmlycSkgewogCWNhc2UgSVJRX1JUQ0Fscm06CiAJCW1hc2sgPSBQV0VSX1JUQzsKIAkJYnJlYWs7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXB4YS9weGEzeHguYyBiL2FyY2gvYXJtL21hY2gtcHhhL3B4YTN4eC5jCmluZGV4IGUxNDgxOGYuLmE3YTE5ZTEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtcHhhL3B4YTN4eC5jCisrKyBiL2FyY2gvYXJtL21hY2gtcHhhL3B4YTN4eC5jCkBAIC0yMjksMTEgKzIyOSwxMSBAQAogCXB4YV9jcHVfcG1fZm5zID0gJnB4YTN4eF9jcHVfcG1fZm5zOwogfQogCi1zdGF0aWMgaW50IHB4YTN4eF9zZXRfd2FrZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgb24pCitzdGF0aWMgaW50IHB4YTN4eF9zZXRfd2FrZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCBvbikKIHsKIAl1bnNpZ25lZCBsb25nIGZsYWdzLCBtYXNrID0gMDsKIAotCXN3aXRjaCAoaXJxKSB7CisJc3dpdGNoIChkLT5pcnEpIHsKIAljYXNlIElSUV9TU1AzOgogCQltYXNrID0gQURYRVJfTUZQX1dTU1AzOwogCQlicmVhazsKQEAgLTMyMiw0MCArMzIyLDQwIEBACiAjZGVmaW5lIHB4YTN4eF9zZXRfd2FrZQlOVUxMCiAjZW5kaWYKIAotc3RhdGljIHZvaWQgcHhhX2Fja19leHRfd2FrZXVwKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBweGFfYWNrX2V4dF93YWtldXAoc3RydWN0IGlycV9kYXRhICpkKQogewotCVBFQ1IgfD0gUEVDUl9JUyhpcnEgLSBJUlFfV0FLRVVQMCk7CisJUEVDUiB8PSBQRUNSX0lTKGQtPmlycSAtIElSUV9XQUtFVVAwKTsKIH0KIAotc3RhdGljIHZvaWQgcHhhX21hc2tfZXh0X3dha2V1cCh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgcHhhX21hc2tfZXh0X3dha2V1cChzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JSUNNUjIgJj0gfigxIDw8ICgoaXJxIC0gUFhBX0lSUSgwKSkgJiAweDFmKSk7Ci0JUEVDUiAmPSB+UEVDUl9JRShpcnEgLSBJUlFfV0FLRVVQMCk7CisJSUNNUjIgJj0gfigxIDw8ICgoZC0+aXJxIC0gUFhBX0lSUSgwKSkgJiAweDFmKSk7CisJUEVDUiAmPSB+UEVDUl9JRShkLT5pcnEgLSBJUlFfV0FLRVVQMCk7CiB9CiAKLXN0YXRpYyB2b2lkIHB4YV91bm1hc2tfZXh0X3dha2V1cCh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgcHhhX3VubWFza19leHRfd2FrZXVwKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlJQ01SMiB8PSAxIDw8ICgoaXJxIC0gUFhBX0lSUSgwKSkgJiAweDFmKTsKLQlQRUNSIHw9IFBFQ1JfSUUoaXJxIC0gSVJRX1dBS0VVUDApOworCUlDTVIyIHw9IDEgPDwgKChkLT5pcnEgLSBQWEFfSVJRKDApKSAmIDB4MWYpOworCVBFQ1IgfD0gUEVDUl9JRShkLT5pcnEgLSBJUlFfV0FLRVVQMCk7CiB9CiAKLXN0YXRpYyBpbnQgcHhhX3NldF9leHRfd2FrZXVwX3R5cGUodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IGZsb3dfdHlwZSkKK3N0YXRpYyBpbnQgcHhhX3NldF9leHRfd2FrZXVwX3R5cGUoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgZmxvd190eXBlKQogewogCWlmIChmbG93X3R5cGUgJiBJUlFfVFlQRV9FREdFX1JJU0lORykKLQkJUFdFUiB8PSAxIDw8IChpcnEgLSBJUlFfV0FLRVVQMCk7CisJCVBXRVIgfD0gMSA8PCAoZC0+aXJxIC0gSVJRX1dBS0VVUDApOwogCiAJaWYgKGZsb3dfdHlwZSAmIElSUV9UWVBFX0VER0VfRkFMTElORykKLQkJUFdFUiB8PSAxIDw8IChpcnEgLSBJUlFfV0FLRVVQMCArIDIpOworCQlQV0VSIHw9IDEgPDwgKGQtPmlycSAtIElSUV9XQUtFVVAwICsgMik7CiAKIAlyZXR1cm4gMDsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBweGFfZXh0X3dha2V1cF9jaGlwID0gewogCS5uYW1lCQk9ICJXQUtFVVAiLAotCS5hY2sJCT0gcHhhX2Fja19leHRfd2FrZXVwLAotCS5tYXNrCQk9IHB4YV9tYXNrX2V4dF93YWtldXAsCi0JLnVubWFzawkJPSBweGFfdW5tYXNrX2V4dF93YWtldXAsCi0JLnNldF90eXBlCT0gcHhhX3NldF9leHRfd2FrZXVwX3R5cGUsCisJLmlycV9hY2sJPSBweGFfYWNrX2V4dF93YWtldXAsCisJLmlycV9tYXNrCT0gcHhhX21hc2tfZXh0X3dha2V1cCwKKwkuaXJxX3VubWFzawk9IHB4YV91bm1hc2tfZXh0X3dha2V1cCwKKwkuaXJxX3NldF90eXBlCT0gcHhhX3NldF9leHRfd2FrZXVwX3R5cGUsCiB9OwogCiBzdGF0aWMgdm9pZCBfX2luaXQgcHhhX2luaXRfZXh0X3dha2V1cF9pcnEoc2V0X3dha2VfdCBmbikKQEAgLTM2OCw3ICszNjgsNyBAQAogCQlzZXRfaXJxX2ZsYWdzKGlycSwgSVJRRl9WQUxJRCk7CiAJfQogCi0JcHhhX2V4dF93YWtldXBfY2hpcC5zZXRfd2FrZSA9IGZuOworCXB4YV9leHRfd2FrZXVwX2NoaXAuaXJxX3NldF93YWtlID0gZm47CiB9CiAKIHZvaWQgX19pbml0IHB4YTN4eF9pbml0X2lycSh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1weGEvc3BpdHouYyBiL2FyY2gvYXJtL21hY2gtcHhhL3NwaXR6LmMKaW5kZXggMGJjOTM4Ny4uYjQ5YTJjMiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1weGEvc3BpdHouYworKysgYi9hcmNoL2FybS9tYWNoLXB4YS9zcGl0ei5jCkBAIC0yNSw2ICsyNSw3IEBACiAjaW5jbHVkZSA8bGludXgvc3BpL2NvcmdpX2xjZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaS9weGEyeHhfc3BpLmg+CiAjaW5jbHVkZSA8bGludXgvbXRkL3NoYXJwc2wuaD4KKyNpbmNsdWRlIDxsaW51eC9tdGQvcGh5c21hcC5oPgogI2luY2x1ZGUgPGxpbnV4L2lucHV0L21hdHJpeF9rZXlwYWQuaD4KICNpbmNsdWRlIDxsaW51eC9yZWd1bGF0b3IvbWFjaGluZS5oPgogI2luY2x1ZGUgPGxpbnV4L2lvLmg+CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXB4YS92aXBlci5jIGIvYXJjaC9hcm0vbWFjaC1weGEvdmlwZXIuYwppbmRleCBkZTY5YjIwLi40OWVlZWFiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXB4YS92aXBlci5jCisrKyBiL2FyY2gvYXJtL21hY2gtcHhhL3ZpcGVyLmMKQEAgLTI0OSw5ICsyNDksOSBAQAogCXJldHVybiB2aXBlcl9pc2FfaXJxc1tiaXRdICsgUFhBX0lTQV9JUlEoMCk7CiB9CiAKLXN0YXRpYyB2b2lkIHZpcGVyX2Fja19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHZpcGVyX2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCWludCB2aXBlcl9pcnEgPSB2aXBlcl9pcnFfdG9fYml0bWFzayhpcnEpOworCWludCB2aXBlcl9pcnEgPSB2aXBlcl9pcnFfdG9fYml0bWFzayhkLT5pcnEpOwogCiAJaWYgKHZpcGVyX2lycSAmIDB4ZmYpCiAJCVZJUEVSX0xPX0lSUV9TVEFUVVMgPSB2aXBlcl9pcnE7CkBAIC0yNTksMTQgKzI1OSwxNCBAQAogCQlWSVBFUl9ISV9JUlFfU1RBVFVTID0gKHZpcGVyX2lycSA+PiA4KTsKIH0KIAotc3RhdGljIHZvaWQgdmlwZXJfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHZpcGVyX21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl2aXBlcl9pcnFfZW5hYmxlZF9tYXNrICY9IH4odmlwZXJfaXJxX3RvX2JpdG1hc2soaXJxKSk7CisJdmlwZXJfaXJxX2VuYWJsZWRfbWFzayAmPSB+KHZpcGVyX2lycV90b19iaXRtYXNrKGQtPmlycSkpOwogfQogCi1zdGF0aWMgdm9pZCB2aXBlcl91bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB2aXBlcl91bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl2aXBlcl9pcnFfZW5hYmxlZF9tYXNrIHw9IHZpcGVyX2lycV90b19iaXRtYXNrKGlycSk7CisJdmlwZXJfaXJxX2VuYWJsZWRfbWFzayB8PSB2aXBlcl9pcnFfdG9fYml0bWFzayhkLT5pcnEpOwogfQogCiBzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgdmlwZXJfaXJxX3BlbmRpbmcodm9pZCkKQEAgLTI4Myw3ICsyODMsNyBAQAogCWRvIHsKIAkJLyogd2UncmUgaW4gYSBjaGFpbmVkIGlycSBoYW5kbGVyLAogCQkgKiBzbyBhY2sgdGhlIGludGVycnVwdCBieSBoYW5kICovCi0JCWRlc2MtPmNoaXAtPmFjayhpcnEpOworCQlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfYWNrKCZkZXNjLT5pcnFfZGF0YSk7CiAKIAkJaWYgKGxpa2VseShwZW5kaW5nKSkgewogCQkJaXJxID0gdmlwZXJfYml0X3RvX2lycShfX2ZmcyhwZW5kaW5nKSk7CkBAIC0yOTQsMTAgKzI5NCwxMCBAQAogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHZpcGVyX2lycV9jaGlwID0gewotCS5uYW1lCT0gIklTQSIsCi0JLmFjawk9IHZpcGVyX2Fja19pcnEsCi0JLm1hc2sJPSB2aXBlcl9tYXNrX2lycSwKLQkudW5tYXNrCT0gdmlwZXJfdW5tYXNrX2lycQorCS5uYW1lCQk9ICJJU0EiLAorCS5pcnFfYWNrCT0gdmlwZXJfYWNrX2lycSwKKwkuaXJxX21hc2sJPSB2aXBlcl9tYXNrX2lycSwKKwkuaXJxX3VubWFzawk9IHZpcGVyX3VubWFza19pcnEKIH07CiAKIHN0YXRpYyB2b2lkIF9faW5pdCB2aXBlcl9pbml0X2lycSh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1weGEvemV1cy5jIGIvYXJjaC9hcm0vbWFjaC1weGEvemV1cy5jCmluZGV4IGJmMDM0YzcuLmY0YjA1M2IgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtcHhhL3pldXMuYworKysgYi9hcmNoL2FybS9tYWNoLXB4YS96ZXVzLmMKQEAgLTgzLDE5ICs4MywxOSBAQAogCXJldHVybiB6ZXVzX2lzYV9pcnFzW2JpdF0gKyBQWEFfSVNBX0lSUSgwKTsKIH0KIAotc3RhdGljIHZvaWQgemV1c19hY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB6ZXVzX2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCV9fcmF3X3dyaXRldyh6ZXVzX2lycV90b19iaXRtYXNrKGlycSksIFpFVVNfQ1BMRF9JU0FfSVJRKTsKKwlfX3Jhd193cml0ZXcoemV1c19pcnFfdG9fYml0bWFzayhkLT5pcnEpLCBaRVVTX0NQTERfSVNBX0lSUSk7CiB9CiAKLXN0YXRpYyB2b2lkIHpldXNfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHpldXNfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXpldXNfaXJxX2VuYWJsZWRfbWFzayAmPSB+KHpldXNfaXJxX3RvX2JpdG1hc2soaXJxKSk7CisJemV1c19pcnFfZW5hYmxlZF9tYXNrICY9IH4oemV1c19pcnFfdG9fYml0bWFzayhkLT5pcnEpKTsKIH0KIAotc3RhdGljIHZvaWQgemV1c191bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB6ZXVzX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXpldXNfaXJxX2VuYWJsZWRfbWFzayB8PSB6ZXVzX2lycV90b19iaXRtYXNrKGlycSk7CisJemV1c19pcnFfZW5hYmxlZF9tYXNrIHw9IHpldXNfaXJxX3RvX2JpdG1hc2soZC0+aXJxKTsKIH0KIAogc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIHpldXNfaXJxX3BlbmRpbmcodm9pZCkKQEAgLTExMSw3ICsxMTEsNyBAQAogCWRvIHsKIAkJLyogd2UncmUgaW4gYSBjaGFpbmVkIGlycSBoYW5kbGVyLAogCQkgKiBzbyBhY2sgdGhlIGludGVycnVwdCBieSBoYW5kICovCi0JCWRlc2MtPmNoaXAtPmFjayhncGlvX3RvX2lycShaRVVTX0lTQV9HUElPKSk7CisJCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9hY2soJmRlc2MtPmlycV9kYXRhKTsKIAogCQlpZiAobGlrZWx5KHBlbmRpbmcpKSB7CiAJCQlpcnEgPSB6ZXVzX2JpdF90b19pcnEoX19mZnMocGVuZGluZykpOwpAQCAtMTIyLDEwICsxMjIsMTAgQEAKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCB6ZXVzX2lycV9jaGlwID0gewotCS5uYW1lCT0gIklTQSIsCi0JLmFjawk9IHpldXNfYWNrX2lycSwKLQkubWFzawk9IHpldXNfbWFza19pcnEsCi0JLnVubWFzawk9IHpldXNfdW5tYXNrX2lycSwKKwkubmFtZQkJPSAiSVNBIiwKKwkuaXJxX2Fjawk9IHpldXNfYWNrX2lycSwKKwkuaXJxX21hc2sJPSB6ZXVzX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gemV1c191bm1hc2tfaXJxLAogfTsKIAogc3RhdGljIHZvaWQgX19pbml0IHpldXNfaW5pdF9pcnEodm9pZCkKQEAgLTgzMCw4ICs4MzAsOCBAQAogCXByX2luZm8oIlpldXMgQ1BMRCBWJWRJJWRcbiIsIChzeXN0ZW1fcmV2ICYgMHhmMCkgPj4gNCwgKHN5c3RlbV9yZXYgJiAweDBmKSk7CiAKIAkvKiBGaXggdGltaW5ncyBmb3IgZG05MDAwcyAoQ1MxL0NTMikqLwotCW1zYzAgPSBfX3Jhd19yZWFkbChNU0MwKSAmIDB4MDAwMGZmZmYgfCAoZG05MDAwX21zYyA8PCAxNik7Ci0JbXNjMSA9IF9fcmF3X3JlYWRsKE1TQzEpICYgMHhmZmZmMDAwMCB8IGRtOTAwMF9tc2M7CisJbXNjMCA9IChfX3Jhd19yZWFkbChNU0MwKSAmIDB4MDAwMGZmZmYpIHwgKGRtOTAwMF9tc2MgPDwgMTYpOworCW1zYzEgPSAoX19yYXdfcmVhZGwoTVNDMSkgJiAweGZmZmYwMDAwKSB8IGRtOTAwMF9tc2M7CiAJX19yYXdfd3JpdGVsKG1zYzAsIE1TQzApOwogCV9fcmF3X3dyaXRlbChtc2MxLCBNU0MxKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1yZWFsdmlldy9LY29uZmlnIGIvYXJjaC9hcm0vbWFjaC1yZWFsdmlldy9LY29uZmlnCmluZGV4IGI0NTc1YWUuLjdjYTEzOGEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtcmVhbHZpZXcvS2NvbmZpZworKysgYi9hcmNoL2FybS9tYWNoLXJlYWx2aWV3L0tjb25maWcKQEAgLTIsNTIgKzIsNTYgQEAKIAlkZXBlbmRzIG9uIEFSQ0hfUkVBTFZJRVcKIAogY29uZmlnIE1BQ0hfUkVBTFZJRVdfRUIKLQlib29sICJTdXBwb3J0IFJlYWxWaWV3L0VCIHBsYXRmb3JtIgorCWJvb2wgIlN1cHBvcnQgUmVhbFZpZXcoUikgRW11bGF0aW9uIEJhc2Vib2FyZCIKIAlzZWxlY3QgQVJNX0dJQwogCWhlbHAKLQkgIEluY2x1ZGUgc3VwcG9ydCBmb3IgdGhlIEFSTShSKSBSZWFsVmlldyBFbXVsYXRpb24gQmFzZWJvYXJkIHBsYXRmb3JtLgorCSAgSW5jbHVkZSBzdXBwb3J0IGZvciB0aGUgQVJNKFIpIFJlYWxWaWV3KFIpIEVtdWxhdGlvbiBCYXNlYm9hcmQKKwkgIHBsYXRmb3JtLgogCiBjb25maWcgUkVBTFZJRVdfRUJfQTlNUAotCWJvb2wgIlN1cHBvcnQgTXVsdGljb3JlIENvcnRleC1BOSIKKwlib29sICJTdXBwb3J0IE11bHRpY29yZSBDb3J0ZXgtQTkgVGlsZSIKIAlkZXBlbmRzIG9uIE1BQ0hfUkVBTFZJRVdfRUIKIAlzZWxlY3QgQ1BVX1Y3CiAJaGVscAotCSAgRW5hYmxlIHN1cHBvcnQgZm9yIHRoZSBDb3J0ZXgtQTlNUENvcmUgdGlsZSBvbiB0aGUgUmVhbHZpZXcgcGxhdGZvcm0uCisJICBFbmFibGUgc3VwcG9ydCBmb3IgdGhlIENvcnRleC1BOU1QQ29yZSB0aWxlIGZpdHRlZCB0byB0aGUKKwkgIFJlYWx2aWV3KFIpIEVtdWxhdGlvbiBCYXNlYm9hcmQgcGxhdGZvcm0uCiAKIGNvbmZpZyBSRUFMVklFV19FQl9BUk0xMU1QCi0JYm9vbCAiU3VwcG9ydCBBUk0xMU1QQ29yZSB0aWxlIgorCWJvb2wgIlN1cHBvcnQgQVJNMTFNUENvcmUgVGlsZSIKIAlkZXBlbmRzIG9uIE1BQ0hfUkVBTFZJRVdfRUIKIAlzZWxlY3QgQ1BVX1Y2CiAJc2VsZWN0IEFSQ0hfSEFTX0JBUlJJRVJTIGlmIFNNUAogCWhlbHAKLQkgIEVuYWJsZSBzdXBwb3J0IGZvciB0aGUgQVJNMTFNUENvcmUgdGlsZSBvbiB0aGUgUmVhbHZpZXcgcGxhdGZvcm0uCisJICBFbmFibGUgc3VwcG9ydCBmb3IgdGhlIEFSTTExTVBDb3JlIHRpbGUgZml0dGVkIHRvIHRoZSBSZWFsdmlldyhSKQorCSAgRW11bGF0aW9uIEJhc2Vib2FyZCBwbGF0Zm9ybS4KIAogY29uZmlnIFJFQUxWSUVXX0VCX0FSTTExTVBfUkVWQgotCWJvb2wgIlN1cHBvcnQgQVJNMTFNUENvcmUgUmV2QiB0aWxlIgorCWJvb2wgIlN1cHBvcnQgQVJNMTFNUENvcmUgUmV2QiBUaWxlIgogCWRlcGVuZHMgb24gUkVBTFZJRVdfRUJfQVJNMTFNUAogCWhlbHAKLQkgIEVuYWJsZSBzdXBwb3J0IGZvciB0aGUgQVJNMTFNUENvcmUgUmV2QiB0aWxlIG9uIHRoZSBSZWFsdmlldwotCSAgcGxhdGZvcm0uIFNpbmNlIHRoZXJlIGFyZSBkZXZpY2UgYWRkcmVzcyBkaWZmZXJlbmNlcywgYQotCSAga2VybmVsIGJ1aWx0IHdpdGggdGhpcyBvcHRpb24gZW5hYmxlZCBpcyBub3QgY29tcGF0aWJsZSB3aXRoCi0JICBvdGhlciByZXZpc2lvbnMgb2YgdGhlIEFSTTExTVBDb3JlIHRpbGUuCisJICBFbmFibGUgc3VwcG9ydCBmb3IgdGhlIEFSTTExTVBDb3JlIFJldmlzaW9uIEIgdGlsZSBvbiB0aGUKKwkgIFJlYWx2aWV3KFIpIEVtdWxhdGlvbiBCYXNlYm9hcmQgcGxhdGZvcm0uIFNpbmNlIHRoZXJlIGFyZSBkZXZpY2UKKwkgIGFkZHJlc3MgZGlmZmVyZW5jZXMsIGEga2VybmVsIGJ1aWx0IHdpdGggdGhpcyBvcHRpb24gZW5hYmxlZCBpcworCSAgbm90IGNvbXBhdGlibGUgd2l0aCBvdGhlciByZXZpc2lvbnMgb2YgdGhlIEFSTTExTVBDb3JlIHRpbGUuCiAKIGNvbmZpZyBNQUNIX1JFQUxWSUVXX1BCMTFNUAotCWJvb2wgIlN1cHBvcnQgUmVhbFZpZXcvUEIxMU1QQ29yZSBwbGF0Zm9ybSIKKwlib29sICJTdXBwb3J0IFJlYWxWaWV3KFIpIFBsYXRmb3JtIEJhc2Vib2FyZCBmb3IgQVJNMTFNUENvcmUiCiAJc2VsZWN0IENQVV9WNgogCXNlbGVjdCBBUk1fR0lDCiAJc2VsZWN0IEhBVkVfUEFUQV9QTEFURk9STQogCXNlbGVjdCBBUkNIX0hBU19CQVJSSUVSUyBpZiBTTVAKIAloZWxwCi0JICBJbmNsdWRlIHN1cHBvcnQgZm9yIHRoZSBBUk0oUikgUmVhbFZpZXcgTVBDb3JlIFBsYXRmb3JtIEJhc2Vib2FyZC4KLQkgIFBCMTFNUENvcmUgaXMgYSBwbGF0Zm9ybSB3aXRoIGFuIG9uLWJvYXJkIEFSTTExTVBDb3JlIGFuZCBoYXMKKwkgIEluY2x1ZGUgc3VwcG9ydCBmb3IgdGhlIEFSTShSKSBSZWFsVmlldyhSKSBQbGF0Zm9ybSBCYXNlYm9hcmQgZm9yCisJICB0aGUgQVJNMTFNUENvcmUuICBUaGlzIHBsYXRmb3JtIGhhcyBhbiBvbi1ib2FyZCBBUk0xMU1QQ29yZSBhbmQgaGFzCiAJICBzdXBwb3J0IGZvciBQQ0ktRSBhbmQgQ29tcGFjdCBGbGFzaC4KIAogY29uZmlnIE1BQ0hfUkVBTFZJRVdfUEIxMTc2Ci0JYm9vbCAiU3VwcG9ydCBSZWFsVmlldy9QQjExNzYgcGxhdGZvcm0iCisJYm9vbCAiU3VwcG9ydCBSZWFsVmlldyhSKSBQbGF0Zm9ybSBCYXNlYm9hcmQgZm9yIEFSTTExNzZKWkYtUyIKIAlzZWxlY3QgQ1BVX1Y2CiAJc2VsZWN0IEFSTV9HSUMKIAloZWxwCi0JICBJbmNsdWRlIHN1cHBvcnQgZm9yIHRoZSBBUk0oUikgUmVhbFZpZXcgQVJNMTE3NiBQbGF0Zm9ybSBCYXNlYm9hcmQuCisJICBJbmNsdWRlIHN1cHBvcnQgZm9yIHRoZSBBUk0oUikgUmVhbFZpZXcoUikgUGxhdGZvcm0gQmFzZWJvYXJkIGZvcgorCSAgQVJNMTE3NkpaRi1TLgogCiBjb25maWcgUkVBTFZJRVdfUEIxMTc2X1NFQ1VSRV9GTEFTSAogCWJvb2wgIkFsbG93IGFjY2VzcyB0byB0aGUgc2VjdXJlIGZsYXNoIG1lbW9yeSBibG9jayIKQEAgLTU5LDIzICs2MywyNCBAQAogCSAgYmxvY2sgKDY0TUIgQCAweDNjMDAwMDAwKSBpcyByZXF1aXJlZC4KIAogY29uZmlnIE1BQ0hfUkVBTFZJRVdfUEJBOAotCWJvb2wgIlN1cHBvcnQgUmVhbFZpZXcvUEItQTggcGxhdGZvcm0iCisJYm9vbCAiU3VwcG9ydCBSZWFsVmlldyhSKSBQbGF0Zm9ybSBCYXNlYm9hcmQgZm9yIENvcnRleCh0bSktQTggcGxhdGZvcm0iCiAJc2VsZWN0IENQVV9WNwogCXNlbGVjdCBBUk1fR0lDCiAJc2VsZWN0IEhBVkVfUEFUQV9QTEFURk9STQogCWhlbHAKLQkgIEluY2x1ZGUgc3VwcG9ydCBmb3IgdGhlIEFSTShSKSBSZWFsVmlldyBDb3J0ZXgtQTggUGxhdGZvcm0gQmFzZWJvYXJkLgotCSAgUEItQTggaXMgYSBwbGF0Zm9ybSB3aXRoIGFuIG9uLWJvYXJkIENvcnRleC1BOCBhbmQgaGFzIHN1cHBvcnQgZm9yCi0JICBQQ0ktRSBhbmQgQ29tcGFjdCBGbGFzaC4KKwkgIEluY2x1ZGUgc3VwcG9ydCBmb3IgdGhlIEFSTShSKSBSZWFsVmlldyBQbGF0Zm9ybSBCYXNlYm9hcmQgZm9yCisJICBDb3J0ZXgodG0pLUE4LiAgVGhpcyBwbGF0Zm9ybSBoYXMgYW4gb24tYm9hcmQgQ29ydGV4LUE4IGFuZCBoYXMKKwkgIHN1cHBvcnQgZm9yIFBDSS1FIGFuZCBDb21wYWN0IEZsYXNoLgogCiBjb25maWcgTUFDSF9SRUFMVklFV19QQlgKLQlib29sICJTdXBwb3J0IFJlYWxWaWV3L1BCWCBwbGF0Zm9ybSIKKwlib29sICJTdXBwb3J0IFJlYWxWaWV3KFIpIFBsYXRmb3JtIEJhc2Vib2FyZCBFeHBsb3JlIgogCXNlbGVjdCBBUk1fR0lDCiAJc2VsZWN0IEhBVkVfUEFUQV9QTEFURk9STQogCXNlbGVjdCBBUkNIX1NQQVJTRU1FTV9FTkFCTEUgaWYgQ1BVX1Y3ICYmICFSRUFMVklFV19ISUdIX1BIWVNfT0ZGU0VUCiAJc2VsZWN0IFpPTkVfRE1BIGlmIFNQQVJTRU1FTQogCWhlbHAKLQkgIEluY2x1ZGUgc3VwcG9ydCBmb3IgdGhlIEFSTShSKSBSZWFsVmlldyBQQlggcGxhdGZvcm0uCisJICBJbmNsdWRlIHN1cHBvcnQgZm9yIHRoZSBBUk0oUikgUmVhbFZpZXcoUikgUGxhdGZvcm0gQmFzZWJvYXJkCisJICBFeHBsb3JlLgogCiBjb25maWcgUkVBTFZJRVdfSElHSF9QSFlTX09GRlNFVAogCWJvb2wgIkhpZ2ggcGh5c2ljYWwgYmFzZSBhZGRyZXNzIGZvciB0aGUgUmVhbFZpZXcgcGxhdGZvcm0iCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXJlYWx2aWV3L3BsYXRzbXAuYyBiL2FyY2gvYXJtL21hY2gtcmVhbHZpZXcvcGxhdHNtcC5jCmluZGV4IGEyMmJmNjcuLjY5NTlkMTMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtcmVhbHZpZXcvcGxhdHNtcC5jCisrKyBiL2FyY2gvYXJtL21hY2gtcmVhbHZpZXcvcGxhdHNtcC5jCkBAIC00MSw3ICs0MSw3IEBACiAgKiBvYnNlcnZlcnMsIGlycmVzcGVjdGl2ZSBvZiB3aGV0aGVyIHRoZXkncmUgdGFraW5nIHBhcnQgaW4gY29oZXJlbmN5CiAgKiBvciBub3QuICBUaGlzIGlzIG5lY2Vzc2FyeSBmb3IgdGhlIGhvdHBsdWcgY29kZSB0byB3b3JrIHJlbGlhYmx5LgogICovCi1zdGF0aWMgdm9pZCB3cml0ZV9wZW5fcmVsZWFzZShpbnQgdmFsKQorc3RhdGljIHZvaWQgX19jcHVpbml0IHdyaXRlX3Blbl9yZWxlYXNlKGludCB2YWwpCiB7CiAJcGVuX3JlbGVhc2UgPSB2YWw7CiAJc21wX3dtYigpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1ycGMvaXJxLmMgYi9hcmNoL2FybS9tYWNoLXJwYy9pcnEuYwppbmRleCA5ZGQxNWQ2Li5kMjljZDliIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXJwYy9pcnEuYworKysgYi9hcmNoL2FybS9tYWNoLXJwYy9pcnEuYwpAQCAtNiwxMTAgKzYsMTEwIEBACiAjaW5jbHVkZSA8YXNtL2hhcmR3YXJlL2lvbWQuaD4KICNpbmNsdWRlIDxhc20vaXJxLmg+CiAKLXN0YXRpYyB2b2lkIGlvbWRfYWNrX2lycV9hKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpb21kX2Fja19pcnFfYShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdW5zaWduZWQgaW50IHZhbCwgbWFzazsKIAotCW1hc2sgPSAxIDw8IGlycTsKKwltYXNrID0gMSA8PCBkLT5pcnE7CiAJdmFsID0gaW9tZF9yZWFkYihJT01EX0lSUU1BU0tBKTsKIAlpb21kX3dyaXRlYih2YWwgJiB+bWFzaywgSU9NRF9JUlFNQVNLQSk7CiAJaW9tZF93cml0ZWIobWFzaywgSU9NRF9JUlFDTFJBKTsKIH0KIAotc3RhdGljIHZvaWQgaW9tZF9tYXNrX2lycV9hKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpb21kX21hc2tfaXJxX2Eoc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGludCB2YWwsIG1hc2s7CiAKLQltYXNrID0gMSA8PCBpcnE7CisJbWFzayA9IDEgPDwgZC0+aXJxOwogCXZhbCA9IGlvbWRfcmVhZGIoSU9NRF9JUlFNQVNLQSk7CiAJaW9tZF93cml0ZWIodmFsICYgfm1hc2ssIElPTURfSVJRTUFTS0EpOwogfQogCi1zdGF0aWMgdm9pZCBpb21kX3VubWFza19pcnFfYSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaW9tZF91bm1hc2tfaXJxX2Eoc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGludCB2YWwsIG1hc2s7CiAKLQltYXNrID0gMSA8PCBpcnE7CisJbWFzayA9IDEgPDwgZC0+aXJxOwogCXZhbCA9IGlvbWRfcmVhZGIoSU9NRF9JUlFNQVNLQSk7CiAJaW9tZF93cml0ZWIodmFsIHwgbWFzaywgSU9NRF9JUlFNQVNLQSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgaW9tZF9hX2NoaXAgPSB7Ci0JLmFjawk9IGlvbWRfYWNrX2lycV9hLAotCS5tYXNrCT0gaW9tZF9tYXNrX2lycV9hLAotCS51bm1hc2sgPSBpb21kX3VubWFza19pcnFfYSwKKwkuaXJxX2Fjawk9IGlvbWRfYWNrX2lycV9hLAorCS5pcnFfbWFzawk9IGlvbWRfbWFza19pcnFfYSwKKwkuaXJxX3VubWFzawk9IGlvbWRfdW5tYXNrX2lycV9hLAogfTsKIAotc3RhdGljIHZvaWQgaW9tZF9tYXNrX2lycV9iKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpb21kX21hc2tfaXJxX2Ioc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGludCB2YWwsIG1hc2s7CiAKLQltYXNrID0gMSA8PCAoaXJxICYgNyk7CisJbWFzayA9IDEgPDwgKGQtPmlycSAmIDcpOwogCXZhbCA9IGlvbWRfcmVhZGIoSU9NRF9JUlFNQVNLQik7CiAJaW9tZF93cml0ZWIodmFsICYgfm1hc2ssIElPTURfSVJRTUFTS0IpOwogfQogCi1zdGF0aWMgdm9pZCBpb21kX3VubWFza19pcnFfYih1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaW9tZF91bm1hc2tfaXJxX2Ioc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGludCB2YWwsIG1hc2s7CiAKLQltYXNrID0gMSA8PCAoaXJxICYgNyk7CisJbWFzayA9IDEgPDwgKGQtPmlycSAmIDcpOwogCXZhbCA9IGlvbWRfcmVhZGIoSU9NRF9JUlFNQVNLQik7CiAJaW9tZF93cml0ZWIodmFsIHwgbWFzaywgSU9NRF9JUlFNQVNLQik7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgaW9tZF9iX2NoaXAgPSB7Ci0JLmFjawk9IGlvbWRfbWFza19pcnFfYiwKLQkubWFzawk9IGlvbWRfbWFza19pcnFfYiwKLQkudW5tYXNrID0gaW9tZF91bm1hc2tfaXJxX2IsCisJLmlycV9hY2sJPSBpb21kX21hc2tfaXJxX2IsCisJLmlycV9tYXNrCT0gaW9tZF9tYXNrX2lycV9iLAorCS5pcnFfdW5tYXNrCT0gaW9tZF91bm1hc2tfaXJxX2IsCiB9OwogCi1zdGF0aWMgdm9pZCBpb21kX21hc2tfaXJxX2RtYSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaW9tZF9tYXNrX2lycV9kbWEoc3RydWN0IGlycV9kYXRhICpkKQogewogCXVuc2lnbmVkIGludCB2YWwsIG1hc2s7CiAKLQltYXNrID0gMSA8PCAoaXJxICYgNyk7CisJbWFzayA9IDEgPDwgKGQtPmlycSAmIDcpOwogCXZhbCA9IGlvbWRfcmVhZGIoSU9NRF9ETUFNQVNLKTsKIAlpb21kX3dyaXRlYih2YWwgJiB+bWFzaywgSU9NRF9ETUFNQVNLKTsKIH0KIAotc3RhdGljIHZvaWQgaW9tZF91bm1hc2tfaXJxX2RtYSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaW9tZF91bm1hc2tfaXJxX2RtYShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdW5zaWduZWQgaW50IHZhbCwgbWFzazsKIAotCW1hc2sgPSAxIDw8IChpcnEgJiA3KTsKKwltYXNrID0gMSA8PCAoZC0+aXJxICYgNyk7CiAJdmFsID0gaW9tZF9yZWFkYihJT01EX0RNQU1BU0spOwogCWlvbWRfd3JpdGViKHZhbCB8IG1hc2ssIElPTURfRE1BTUFTSyk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgaW9tZF9kbWFfY2hpcCA9IHsKLQkuYWNrCT0gaW9tZF9tYXNrX2lycV9kbWEsCi0JLm1hc2sJPSBpb21kX21hc2tfaXJxX2RtYSwKLQkudW5tYXNrID0gaW9tZF91bm1hc2tfaXJxX2RtYSwKKwkuaXJxX2Fjawk9IGlvbWRfbWFza19pcnFfZG1hLAorCS5pcnFfbWFzawk9IGlvbWRfbWFza19pcnFfZG1hLAorCS5pcnFfdW5tYXNrCT0gaW9tZF91bm1hc2tfaXJxX2RtYSwKIH07CiAKLXN0YXRpYyB2b2lkIGlvbWRfbWFza19pcnFfZmlxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpb21kX21hc2tfaXJxX2ZpcShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdW5zaWduZWQgaW50IHZhbCwgbWFzazsKIAotCW1hc2sgPSAxIDw8IChpcnEgJiA3KTsKKwltYXNrID0gMSA8PCAoZC0+aXJxICYgNyk7CiAJdmFsID0gaW9tZF9yZWFkYihJT01EX0ZJUU1BU0spOwogCWlvbWRfd3JpdGViKHZhbCAmIH5tYXNrLCBJT01EX0ZJUU1BU0spOwogfQogCi1zdGF0aWMgdm9pZCBpb21kX3VubWFza19pcnFfZmlxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBpb21kX3VubWFza19pcnFfZmlxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl1bnNpZ25lZCBpbnQgdmFsLCBtYXNrOwogCi0JbWFzayA9IDEgPDwgKGlycSAmIDcpOworCW1hc2sgPSAxIDw8IChkLT5pcnEgJiA3KTsKIAl2YWwgPSBpb21kX3JlYWRiKElPTURfRklRTUFTSyk7CiAJaW9tZF93cml0ZWIodmFsIHwgbWFzaywgSU9NRF9GSVFNQVNLKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBpb21kX2ZpcV9jaGlwID0gewotCS5hY2sJPSBpb21kX21hc2tfaXJxX2ZpcSwKLQkubWFzawk9IGlvbWRfbWFza19pcnFfZmlxLAotCS51bm1hc2sgPSBpb21kX3VubWFza19pcnFfZmlxLAorCS5pcnFfYWNrCT0gaW9tZF9tYXNrX2lycV9maXEsCisJLmlycV9tYXNrCT0gaW9tZF9tYXNrX2lycV9maXEsCisJLmlycV91bm1hc2sJPSBpb21kX3VubWFza19pcnFfZmlxLAogfTsKIAogdm9pZCBfX2luaXQgcnBjX2luaXRfaXJxKHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXMzYzI0MTAvYmFzdC1pcnEuYyBiL2FyY2gvYXJtL21hY2gtczNjMjQxMC9iYXN0LWlycS5jCmluZGV4IDIxN2IxMDIuLjYwNmNiNmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczNjMjQxMC9iYXN0LWlycS5jCisrKyBiL2FyY2gvYXJtL21hY2gtczNjMjQxMC9iYXN0LWlycS5jCkBAIC03NSwzOCArNzUsMzggQEAKIHN0YXRpYyB1bnNpZ25lZCBjaGFyIGJhc3RfcGMxMDRfaXJxc1tdID0geyAzLCA1LCA3LCAxMCB9OwogCiBzdGF0aWMgdm9pZAotYmFzdF9wYzEwNF9tYXNrKHVuc2lnbmVkIGludCBpcnFubykKK2Jhc3RfcGMxMDRfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7CiAJdW5zaWduZWQgbG9uZyB0ZW1wOwogCiAJdGVtcCA9IF9fcmF3X3JlYWRiKEJBU1RfVkFfUEMxMDRfSVJRTUFTSyk7Ci0JdGVtcCAmPSB+YmFzdF9wYzEwNF9pcnFtYXNrc1tpcnFub107CisJdGVtcCAmPSB+YmFzdF9wYzEwNF9pcnFtYXNrc1tkYXRhLT5pcnFdOwogCV9fcmF3X3dyaXRlYih0ZW1wLCBCQVNUX1ZBX1BDMTA0X0lSUU1BU0spOwogfQogCiBzdGF0aWMgdm9pZAotYmFzdF9wYzEwNF9tYXNrYWNrKHVuc2lnbmVkIGludCBpcnFubykKK2Jhc3RfcGMxMDRfbWFza2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7CiAJc3RydWN0IGlycV9kZXNjICpkZXNjID0gaXJxX2Rlc2MgKyBJUlFfSVNBOwogCi0JYmFzdF9wYzEwNF9tYXNrKGlycW5vKTsKLQlkZXNjLT5jaGlwLT5hY2soSVJRX0lTQSk7CisJYmFzdF9wYzEwNF9tYXNrKGRhdGEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9hY2soJmRlc2MtPmlycV9kYXRhKTsKIH0KIAogc3RhdGljIHZvaWQKLWJhc3RfcGMxMDRfdW5tYXNrKHVuc2lnbmVkIGludCBpcnFubykKK2Jhc3RfcGMxMDRfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1bnNpZ25lZCBsb25nIHRlbXA7CiAKIAl0ZW1wID0gX19yYXdfcmVhZGIoQkFTVF9WQV9QQzEwNF9JUlFNQVNLKTsKLQl0ZW1wIHw9IGJhc3RfcGMxMDRfaXJxbWFza3NbaXJxbm9dOworCXRlbXAgfD0gYmFzdF9wYzEwNF9pcnFtYXNrc1tkYXRhLT5pcnFdOwogCV9fcmF3X3dyaXRlYih0ZW1wLCBCQVNUX1ZBX1BDMTA0X0lSUU1BU0spOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwICBiYXN0X3BjMTA0X2NoaXAgPSB7Ci0JLm1hc2sJICAgICA9IGJhc3RfcGMxMDRfbWFzaywKLQkudW5tYXNrCSAgICAgPSBiYXN0X3BjMTA0X3VubWFzaywKLQkuYWNrCSAgICAgPSBiYXN0X3BjMTA0X21hc2thY2sKKwkuaXJxX21hc2sJPSBiYXN0X3BjMTA0X21hc2ssCisJLmlycV91bm1hc2sJPSBiYXN0X3BjMTA0X3VubWFzaywKKwkuaXJxX2Fjawk9IGJhc3RfcGMxMDRfbWFza2FjawogfTsKIAogc3RhdGljIHZvaWQKQEAgLTEyMyw3ICsxMjMsNyBAQAogCQkvKiBhY2sgaWYgd2UgZ2V0IGFuIGlycSB3aXRoIG5vdGhpbmcgKGllLCBzdGFydHVwKSAqLwogCiAJCWRlc2MgPSBpcnFfZGVzYyArIElSUV9JU0E7Ci0JCWRlc2MtPmNoaXAtPmFjayhJUlFfSVNBKTsKKwkJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX2FjaygmZGVzYy0+aXJxX2RhdGEpOwogCX0gZWxzZSB7CiAJCS8qIGhhbmRsZSB0aGUgSVJRICovCiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczNjMjQxMC9pbmNsdWRlL21hY2gvaXJxcy5oIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDEwL2luY2x1ZGUvbWFjaC9pcnFzLmgKaW5kZXggMTFiYjBmMC4uZTVhNjhlYSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zM2MyNDEwL2luY2x1ZGUvbWFjaC9pcnFzLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDEwL2luY2x1ZGUvbWFjaC9pcnFzLmgKQEAgLTE1Miw4ICsxNTIsOCBAQAogCiAjZGVmaW5lIElSUV9TM0MyNDE2X0hTTU1DMAlTM0MyNDEwX0lSUSgyMSkJCS8qIFMzQzI0MTYvUzNDMjQ1MCAqLwogCi0jZGVmaW5lIElSUV9IU01NQzAJCUlSUV9TM0MyNDQzX0hTTU1DCi0jZGVmaW5lIElSUV9IU01NQzEJCUlSUV9TM0MyNDE2X0hTTU1DMAorI2RlZmluZSBJUlFfSFNNTUMwCQlJUlFfUzNDMjQxNl9IU01NQzAKKyNkZWZpbmUgSVJRX0hTTU1DMQkJSVJRX1MzQzI0NDNfSFNNTUMKIAogI2RlZmluZSBJUlFfUzNDMjQ0M19MQ0QxCVMzQzI0MTBfSVJRU1VCKDE0KQogI2RlZmluZSBJUlFfUzNDMjQ0M19MQ0QyCVMzQzI0MTBfSVJRU1VCKDE1KQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zM2MyNDEwL2luY2x1ZGUvbWFjaC9tYXAuaCBiL2FyY2gvYXJtL21hY2gtczNjMjQxMC9pbmNsdWRlL21hY2gvbWFwLmgKaW5kZXggY2QzOTgzYS4uMjViYmY1YSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zM2MyNDEwL2luY2x1ZGUvbWFjaC9tYXAuaAorKysgYi9hcmNoL2FybS9tYWNoLXMzYzI0MTAvaW5jbHVkZS9tYWNoL21hcC5oCkBAIC0xMTIsOCArMTEyLDggQEAKICNkZWZpbmUgUzNDX1BBX0lJQyAgICAgICAgICBTM0MyNDEwX1BBX0lJQwogI2RlZmluZSBTM0NfUEFfVUFSVAkgICAgUzNDMjRYWF9QQV9VQVJUCiAjZGVmaW5lIFMzQ19QQV9VU0JIT1NUCVMzQzI0MTBfUEFfVVNCSE9TVAotI2RlZmluZSBTM0NfUEFfSFNNTUMwCSAgICBTM0MyNDQzX1BBX0hTTU1DCi0jZGVmaW5lIFMzQ19QQV9IU01NQzEJICAgIFMzQzI0MTZfUEFfSFNNTUMwCisjZGVmaW5lIFMzQ19QQV9IU01NQzAJICAgIFMzQzI0MTZfUEFfSFNNTUMwCisjZGVmaW5lIFMzQ19QQV9IU01NQzEJICAgIFMzQzI0NDNfUEFfSFNNTUMKICNkZWZpbmUgUzNDX1BBX1dEVAkgICAgUzNDMjQxMF9QQV9XQVRDSERPRwogI2RlZmluZSBTM0NfUEFfTkFORAkgICAgUzNDMjRYWF9QQV9OQU5ECiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczNjMjQxMC9pbmNsdWRlL21hY2gvcmVncy1zM2MyNDQzLWNsb2NrLmggYi9hcmNoL2FybS9tYWNoLXMzYzI0MTAvaW5jbHVkZS9tYWNoL3JlZ3MtczNjMjQ0My1jbG9jay5oCmluZGV4IDEwMWFlZWEuLjQ0NDk0YTUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczNjMjQxMC9pbmNsdWRlL21hY2gvcmVncy1zM2MyNDQzLWNsb2NrLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDEwL2luY2x1ZGUvbWFjaC9yZWdzLXMzYzI0NDMtY2xvY2suaApAQCAtODYsNiArODYsNyBAQAogI2RlZmluZSBTM0MyNDQzX0hDTEtDT05fTENEQwkJKDE8PDkpCiAjZGVmaW5lIFMzQzI0NDNfSENMS0NPTl9VU0JICQkoMTw8MTEpCiAjZGVmaW5lIFMzQzI0NDNfSENMS0NPTl9VU0JECQkoMTw8MTIpCisjZGVmaW5lIFMzQzI0MTZfSENMS0NPTl9IU01NQzAJCSgxPDwxNSkKICNkZWZpbmUgUzNDMjQ0M19IQ0xLQ09OX0hTTU1DCQkoMTw8MTYpCiAjZGVmaW5lIFMzQzI0NDNfSENMS0NPTl9DRkMJCSgxPDwxNykKICNkZWZpbmUgUzNDMjQ0M19IQ0xLQ09OX1NTTUMJCSgxPDwxOCkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczNjMjQxMi9pcnEuYyBiL2FyY2gvYXJtL21hY2gtczNjMjQxMi9pcnEuYwppbmRleCA2MDAwY2E5Li5lZGRiNTJiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXMzYzI0MTIvaXJxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDEyL2lycS5jCkBAIC00OSw5ICs0OSw5IEBACiAqLwogCiBzdGF0aWMgdm9pZAotczNjMjQxMl9pcnFfbWFzayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzM2MyNDEyX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQl1bnNpZ25lZCBsb25nIGJpdHZhbCA9IDFVTCA8PCAoaXJxbm8gLSBJUlFfRUlOVDApOworCXVuc2lnbmVkIGxvbmcgYml0dmFsID0gMVVMIDw8IChkYXRhLT5pcnEgLSBJUlFfRUlOVDApOwogCXVuc2lnbmVkIGxvbmcgbWFzazsKIAogCW1hc2sgPSBfX3Jhd19yZWFkbChTM0MyNDEwX0lOVE1TSyk7CkBAIC02Miw5ICs2Miw5IEBACiB9CiAKIHN0YXRpYyBpbmxpbmUgdm9pZAotczNjMjQxMl9pcnFfYWNrKHVuc2lnbmVkIGludCBpcnFubykKK3MzYzI0MTJfaXJxX2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JdW5zaWduZWQgbG9uZyBiaXR2YWwgPSAxVUwgPDwgKGlycW5vIC0gSVJRX0VJTlQwKTsKKwl1bnNpZ25lZCBsb25nIGJpdHZhbCA9IDFVTCA8PCAoZGF0YS0+aXJxIC0gSVJRX0VJTlQwKTsKIAogCV9fcmF3X3dyaXRlbChiaXR2YWwsIFMzQzI0MTJfRUlOVFBFTkQpOwogCV9fcmF3X3dyaXRlbChiaXR2YWwsIFMzQzI0MTBfU1JDUE5EKTsKQEAgLTcyLDkgKzcyLDkgQEAKIH0KIAogc3RhdGljIGlubGluZSB2b2lkCi1zM2MyNDEyX2lycV9tYXNrYWNrKHVuc2lnbmVkIGludCBpcnFubykKK3MzYzI0MTJfaXJxX21hc2thY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXVuc2lnbmVkIGxvbmcgYml0dmFsID0gMVVMIDw8IChpcnFubyAtIElSUV9FSU5UMCk7CisJdW5zaWduZWQgbG9uZyBiaXR2YWwgPSAxVUwgPDwgKGRhdGEtPmlycSAtIElSUV9FSU5UMCk7CiAJdW5zaWduZWQgbG9uZyBtYXNrOwogCiAJbWFzayA9IF9fcmF3X3JlYWRsKFMzQzI0MTBfSU5UTVNLKTsKQEAgLTg5LDkgKzg5LDkgQEAKIH0KIAogc3RhdGljIHZvaWQKLXMzYzI0MTJfaXJxX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzM2MyNDEyX2lycV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXVuc2lnbmVkIGxvbmcgYml0dmFsID0gMVVMIDw8IChpcnFubyAtIElSUV9FSU5UMCk7CisJdW5zaWduZWQgbG9uZyBiaXR2YWwgPSAxVUwgPDwgKGRhdGEtPmlycSAtIElSUV9FSU5UMCk7CiAJdW5zaWduZWQgbG9uZyBtYXNrOwogCiAJbWFzayA9IF9fcmF3X3JlYWRsKFMzQzI0MTJfRUlOVE1BU0spOwpAQCAtMTAyLDExICsxMDIsMTEgQEAKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2MyNDEyX2lycV9laW50MHQ0ID0gewotCS5hY2sJICAgPSBzM2MyNDEyX2lycV9hY2ssCi0JLm1hc2sJICAgPSBzM2MyNDEyX2lycV9tYXNrLAotCS51bm1hc2sJICAgPSBzM2MyNDEyX2lycV91bm1hc2ssCi0JLnNldF93YWtlICA9IHMzY19pcnFfd2FrZSwKLQkuc2V0X3R5cGUgID0gczNjX2lycWV4dF90eXBlLAorCS5pcnFfYWNrCT0gczNjMjQxMl9pcnFfYWNrLAorCS5pcnFfbWFzawk9IHMzYzI0MTJfaXJxX21hc2ssCisJLmlycV91bm1hc2sJPSBzM2MyNDEyX2lycV91bm1hc2ssCisJLmlycV9zZXRfd2FrZQk9IHMzY19pcnFfd2FrZSwKKwkuaXJxX3NldF90eXBlCT0gczNjX2lycWV4dF90eXBlLAogfTsKIAogI2RlZmluZSBJTlRCSVQoeCkJKDEgPDwgKCh4KSAtIFMzQzI0MTBfSVJRU1VCKDApKSkKQEAgLTEzMiwyOSArMTMyLDI5IEBACiAjZGVmaW5lIElOVE1TS19DRlNESQkoMVVMIDw8IChJUlFfUzNDMjQxMl9DRlNESSAtIElSUV9FSU5UMCkpCiAjZGVmaW5lIFNVQk1TS19DRlNESQlJTlRNU0tfU1VCKElSUV9TM0MyNDEyX1NESSwgSVJRX1MzQzI0MTJfQ0YpCiAKLXN0YXRpYyB2b2lkIHMzYzI0MTJfaXJxX2Nmc2RpX21hc2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQxMl9pcnFfY2ZzZGlfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl9tYXNrKGlycW5vLCBJTlRNU0tfQ0ZTREksIFNVQk1TS19DRlNESSk7CisJczNjX2lycXN1Yl9tYXNrKGRhdGEtPmlycSwgSU5UTVNLX0NGU0RJLCBTVUJNU0tfQ0ZTREkpOwogfQogCi1zdGF0aWMgdm9pZCBzM2MyNDEyX2lycV9jZnNkaV91bm1hc2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQxMl9pcnFfY2ZzZGlfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX3VubWFzayhpcnFubywgSU5UTVNLX0NGU0RJKTsKKwlzM2NfaXJxc3ViX3VubWFzayhkYXRhLT5pcnEsIElOVE1TS19DRlNESSk7CiB9CiAKLXN0YXRpYyB2b2lkIHMzYzI0MTJfaXJxX2Nmc2RpX2Fjayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzdGF0aWMgdm9pZCBzM2MyNDEyX2lycV9jZnNkaV9hY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXMzY19pcnFzdWJfbWFza2FjayhpcnFubywgSU5UTVNLX0NGU0RJLCBTVUJNU0tfQ0ZTREkpOworCXMzY19pcnFzdWJfbWFza2FjayhkYXRhLT5pcnEsIElOVE1TS19DRlNESSwgU1VCTVNLX0NGU0RJKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2MyNDEyX2lycV9jZnNkaSA9IHsKIAkubmFtZQkJPSAiczNjMjQxMi1jZnNkaSIsCi0JLmFjawkJPSBzM2MyNDEyX2lycV9jZnNkaV9hY2ssCi0JLm1hc2sJCT0gczNjMjQxMl9pcnFfY2ZzZGlfbWFzaywKLQkudW5tYXNrCQk9IHMzYzI0MTJfaXJxX2Nmc2RpX3VubWFzaywKKwkuaXJxX2Fjawk9IHMzYzI0MTJfaXJxX2Nmc2RpX2FjaywKKwkuaXJxX21hc2sJPSBzM2MyNDEyX2lycV9jZnNkaV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gczNjMjQxMl9pcnFfY2ZzZGlfdW5tYXNrLAogfTsKIAotc3RhdGljIGludCBzM2MyNDEyX2lycV9ydGNfd2FrZSh1bnNpZ25lZCBpbnQgaXJxbm8sIHVuc2lnbmVkIGludCBzdGF0ZSkKK3N0YXRpYyBpbnQgczNjMjQxMl9pcnFfcnRjX3dha2Uoc3RydWN0IGlycV9kYXRhICpkYXRhLCB1bnNpZ25lZCBpbnQgc3RhdGUpCiB7CiAJdW5zaWduZWQgbG9uZyBwd3JjZmc7CiAKQEAgLTE2NSw3ICsxNjUsNyBAQAogCQlwd3JjZmcgfD0gUzNDMjQxMl9QV1JDRkdfUlRDX01BU0tJUlE7CiAJX19yYXdfd3JpdGVsKHB3cmNmZywgUzNDMjQxMl9QV1JDRkcpOwogCi0JcmV0dXJuIHMzY19pcnFfY2hpcC5zZXRfd2FrZShpcnFubywgc3RhdGUpOworCXJldHVybiBzM2NfaXJxX2NoaXAuaXJxX3NldF93YWtlKGRhdGEsIHN0YXRlKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2MyNDEyX2lycV9ydGNfY2hpcDsKQEAgLTE5Myw3ICsxOTMsNyBAQAogCS8qIGNoYW5nZSBSVEMgSVJRJ3Mgc2V0IHdha2UgbWV0aG9kICovCiAKIAlzM2MyNDEyX2lycV9ydGNfY2hpcCA9IHMzY19pcnFfY2hpcDsKLQlzM2MyNDEyX2lycV9ydGNfY2hpcC5zZXRfd2FrZSA9IHMzYzI0MTJfaXJxX3J0Y193YWtlOworCXMzYzI0MTJfaXJxX3J0Y19jaGlwLmlycV9zZXRfd2FrZSA9IHMzYzI0MTJfaXJxX3J0Y193YWtlOwogCiAJc2V0X2lycV9jaGlwKElSUV9SVEMsICZzM2MyNDEyX2lycV9ydGNfY2hpcCk7CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczNjMjQxNi9LY29uZmlnIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDE2L0tjb25maWcKaW5kZXggZGY4ZDE0OS4uNjliNDhhNyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zM2MyNDE2L0tjb25maWcKKysrIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDE2L0tjb25maWcKQEAgLTMxLDYgKzMxLDE3IEBACiAJaGVscAogCSAgSW50ZXJuYWwgY29uZmlnIG5vZGUgdG8gYXBwbHkgUzNDMjQxNiBwb3dlciBtYW5hZ2VtZW50CiAKK2NvbmZpZyBTM0MyNDE2X1NFVFVQX1NESENJCisJYm9vbAorCXNlbGVjdCBTM0MyNDE2X1NFVFVQX1NESENJX0dQSU8KKwloZWxwCisJICBJbnRlcm5hbCBoZWxwZXIgZnVuY3Rpb25zIGZvciBTM0MyNDE2IGJhc2VkIFNESENJIHN5c3RlbXMKKworY29uZmlnIFMzQzI0MTZfU0VUVVBfU0RIQ0lfR1BJTworCWJvb2wKKwloZWxwCisJICBDb21tb24gc2V0dXAgY29kZSBmb3IgU0RIQ0kgZ3Bpby4KKwogbWVudSAiUzNDMjQxNiBNYWNoaW5lcyIKIAogY29uZmlnIE1BQ0hfU01ESzI0MTYKQEAgLTQyLDYgKzUzLDcgQEAKIAlzZWxlY3QgUzNDX0RFVl9IU01NQzEKIAlzZWxlY3QgUzNDX0RFVl9OQU5ECiAJc2VsZWN0IFMzQ19ERVZfVVNCX0hPU1QKKwlzZWxlY3QgUzNDMjQxNl9TRVRVUF9TREhDSQogCXNlbGVjdCBTM0MyNDE2X1BNIGlmIFBNCiAJaGVscAogCSAgU2F5IFkgaGVyZSBpZiB5b3UgYXJlIHVzaW5nIGFuIFNNREsyNDE2CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXMzYzI0MTYvTWFrZWZpbGUgYi9hcmNoL2FybS9tYWNoLXMzYzI0MTYvTWFrZWZpbGUKaW5kZXggZWYwMzhkNi4uN2I4MDViMiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zM2MyNDE2L01ha2VmaWxlCisrKyBiL2FyY2gvYXJtL21hY2gtczNjMjQxNi9NYWtlZmlsZQpAQCAtMTQsNiArMTQsMTAgQEAKIG9iai0kKENPTkZJR19TM0MyNDE2X1BNKQkrPSBwbS5vCiAjb2JqLSQoQ09ORklHX1MzQzI0MTZfRE1BKQkrPSBkbWEubwogCisjIERldmljZSBzZXR1cAorb2JqLSQoQ09ORklHX1MzQzI0MTZfU0VUVVBfU0RIQ0kpICs9IHNldHVwLXNkaGNpLm8KK29iai0kKENPTkZJR19TM0MyNDE2X1NFVFVQX1NESENJX0dQSU8pICs9IHNldHVwLXNkaGNpLWdwaW8ubworCiAjIE1hY2hpbmUgc3VwcG9ydAogCiBvYmotJChDT05GSUdfTUFDSF9TTURLMjQxNikJKz0gbWFjaC1zbWRrMjQxNi5vCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXMzYzI0MTYvY2xvY2suYyBiL2FyY2gvYXJtL21hY2gtczNjMjQxNi9jbG9jay5jCmluZGV4IDdjY2Y1YTIuLjNiMDJkODUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczNjMjQxNi9jbG9jay5jCisrKyBiL2FyY2gvYXJtL21hY2gtczNjMjQxNi9jbG9jay5jCkBAIC0zOCwxMiArMzgsMTEgQEAKIAlbN10gPSA4LAogfTsKIAotLyogSUQgdG8gaGFyZHdhcmUgbnVtYmVyaW5nLCAwIGlzIEhTTU1DMSwgMSBpcyBIU01NQzAgKi8KIHN0YXRpYyBzdHJ1Y3QgY2xrc3JjX2NsayBoc21tY19kaXZbXSA9IHsKIAlbMF0gPSB7CiAJCS5jbGsgPSB7CiAJCQkubmFtZQk9ICJoc21tYy1kaXYiLAotCQkJLmlkCT0gMSwKKwkJCS5pZAk9IDAsCiAJCQkucGFyZW50CT0gJmNsa19lc3lzY2xrLmNsaywKIAkJfSwKIAkJLnJlZ19kaXYgPSB7IC5yZWcgPSBTM0MyNDE2X0NMS0RJVjIsIC5zaXplID0gMiwgLnNoaWZ0ID0gNiB9LApAQCAtNTEsNyArNTAsNyBAQAogCVsxXSA9IHsKIAkJLmNsayA9IHsKIAkJCS5uYW1lCT0gImhzbW1jLWRpdiIsCi0JCQkuaWQJPSAwLAorCQkJLmlkCT0gMSwKIAkJCS5wYXJlbnQJPSAmY2xrX2VzeXNjbGsuY2xrLAogCQl9LAogCQkucmVnX2RpdiA9IHsgLnJlZyA9IFMzQzI0NDNfQ0xLRElWMSwgLnNpemUgPSAyLCAuc2hpZnQgPSA2IH0sCkBAIC02MSw3ICs2MCw3IEBACiBzdGF0aWMgc3RydWN0IGNsa3NyY19jbGsgaHNtbWNfbXV4W10gPSB7CiAJWzBdID0gewogCQkuY2xrCT0gewotCQkJLmlkCT0gMSwKKwkJCS5pZAk9IDAsCiAJCQkubmFtZQk9ICJoc21tYy1pZiIsCiAJCQkuY3RybGJpdCA9ICgxIDw8IDYpLAogCQkJLmVuYWJsZSA9IHMzYzI0NDNfY2xrY29uX2VuYWJsZV9zLApAQCAtNzcsNyArNzYsNyBAQAogCX0sCiAJWzFdID0gewogCQkuY2xrCT0gewotCQkJLmlkCT0gMCwKKwkJCS5pZAk9IDEsCiAJCQkubmFtZQk9ICJoc21tYy1pZiIsCiAJCQkuY3RybGJpdCA9ICgxIDw8IDEyKSwKIAkJCS5lbmFibGUgPSBzM2MyNDQzX2Nsa2Nvbl9lbmFibGVfcywKQEAgLTkzLDYgKzkyLDEzIEBACiAJfSwKIH07CiAKK3N0YXRpYyBzdHJ1Y3QgY2xrIGhzbW1jMF9jbGsgPSB7CisJLm5hbWUJCT0gImhzbW1jIiwKKwkuaWQJCT0gMCwKKwkucGFyZW50CQk9ICZjbGtfaCwKKwkuZW5hYmxlCQk9IHMzYzI0NDNfY2xrY29uX2VuYWJsZV9oLAorCS5jdHJsYml0CT0gUzNDMjQxNl9IQ0xLQ09OX0hTTU1DMCwKK307CiAKIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgaW50IHMzYzI0MTZfZmNsa19kaXYodW5zaWduZWQgbG9uZyBjbGtjb24wKQogewpAQCAtMTMwLDYgKzEzNiw4IEBACiAJZm9yIChwdHIgPSAwOyBwdHIgPCBBUlJBWV9TSVpFKGNsa3NyY3MpOyBwdHIrKykKIAkJczNjX3JlZ2lzdGVyX2Nsa3NyYyhjbGtzcmNzW3B0cl0sIDEpOwogCisJczNjMjR4eF9yZWdpc3Rlcl9jbG9jaygmaHNtbWMwX2Nsayk7CisKIAlzM2NfcHdtY2xrX2luaXQoKTsKIAogfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zM2MyNDE2L2lycS5jIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDE2L2lycS5jCmluZGV4IDAwMTc0ZGEuLjY4MGZlMzggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczNjMjQxNi9pcnEuYworKysgYi9hcmNoL2FybS9tYWNoLXMzYzI0MTYvaXJxLmMKQEAgLTc3LDI4ICs3NywyNyBAQAogI2RlZmluZSBJTlRNU0tfV0RUQUM5NwkoMVVMIDw8IChJUlFfV0RUIC0gSVJRX0VJTlQwKSkKICNkZWZpbmUgU1VCTVNLX1dEVEFDOTcJSU5UTVNLKElSUV9TM0MyNDQzX1dEVCwgSVJRX1MzQzI0NDNfQUM5NykKIAotc3RhdGljIHZvaWQgczNjMjQxNl9pcnFfd2R0YWM5N19tYXNrKHVuc2lnbmVkIGludCBpcnFubykKK3N0YXRpYyB2b2lkIHMzYzI0MTZfaXJxX3dkdGFjOTdfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl9tYXNrKGlycW5vLCBJTlRNU0tfV0RUQUM5NywgU1VCTVNLX1dEVEFDOTcpOworCXMzY19pcnFzdWJfbWFzayhkYXRhLT5pcnEsIElOVE1TS19XRFRBQzk3LCBTVUJNU0tfV0RUQUM5Nyk7CiB9CiAKLXN0YXRpYyB2b2lkIHMzYzI0MTZfaXJxX3dkdGFjOTdfdW5tYXNrKHVuc2lnbmVkIGludCBpcnFubykKK3N0YXRpYyB2b2lkIHMzYzI0MTZfaXJxX3dkdGFjOTdfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX3VubWFzayhpcnFubywgSU5UTVNLX1dEVEFDOTcpOworCXMzY19pcnFzdWJfdW5tYXNrKGRhdGEtPmlycSwgSU5UTVNLX1dEVEFDOTcpOwogfQogCi1zdGF0aWMgdm9pZCBzM2MyNDE2X2lycV93ZHRhYzk3X2Fjayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzdGF0aWMgdm9pZCBzM2MyNDE2X2lycV93ZHRhYzk3X2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl9tYXNrYWNrKGlycW5vLCBJTlRNU0tfV0RUQUM5NywgU1VCTVNLX1dEVEFDOTcpOworCXMzY19pcnFzdWJfbWFza2FjayhkYXRhLT5pcnEsIElOVE1TS19XRFRBQzk3LCBTVUJNU0tfV0RUQUM5Nyk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgczNjMjQxNl9pcnFfd2R0YWM5NyA9IHsKLQkubWFzawkgICAgPSBzM2MyNDE2X2lycV93ZHRhYzk3X21hc2ssCi0JLnVubWFzawkgICAgPSBzM2MyNDE2X2lycV93ZHRhYzk3X3VubWFzaywKLQkuYWNrCSAgICA9IHMzYzI0MTZfaXJxX3dkdGFjOTdfYWNrLAorCS5pcnFfbWFzawk9IHMzYzI0MTZfaXJxX3dkdGFjOTdfbWFzaywKKwkuaXJxX3VubWFzawk9IHMzYzI0MTZfaXJxX3dkdGFjOTdfdW5tYXNrLAorCS5pcnFfYWNrCT0gczNjMjQxNl9pcnFfd2R0YWM5N19hY2ssCiB9OwogCi0KIC8qIExDRCBzdWIgaW50ZXJydXB0cyAqLwogCiBzdGF0aWMgdm9pZCBzM2MyNDE2X2lycV9kZW11eF9sY2QodW5zaWduZWQgaW50IGlycSwgc3RydWN0IGlycV9kZXNjICpkZXNjKQpAQCAtMTA5LDI4ICsxMDgsMjcgQEAKICNkZWZpbmUgSU5UTVNLX0xDRAkoMVVMIDw8IChJUlFfTENEIC0gSVJRX0VJTlQwKSkKICNkZWZpbmUgU1VCTVNLX0xDRAlJTlRNU0soSVJRX1MzQzI0NDNfTENEMSwgSVJRX1MzQzI0NDNfTENENCkKIAotc3RhdGljIHZvaWQgczNjMjQxNl9pcnFfbGNkX21hc2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQxNl9pcnFfbGNkX21hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXMzY19pcnFzdWJfbWFzayhpcnFubywgSU5UTVNLX0xDRCwgU1VCTVNLX0xDRCk7CisJczNjX2lycXN1Yl9tYXNrKGRhdGEtPmlycSwgSU5UTVNLX0xDRCwgU1VCTVNLX0xDRCk7CiB9CiAKLXN0YXRpYyB2b2lkIHMzYzI0MTZfaXJxX2xjZF91bm1hc2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQxNl9pcnFfbGNkX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl91bm1hc2soaXJxbm8sIElOVE1TS19MQ0QpOworCXMzY19pcnFzdWJfdW5tYXNrKGRhdGEtPmlycSwgSU5UTVNLX0xDRCk7CiB9CiAKLXN0YXRpYyB2b2lkIHMzYzI0MTZfaXJxX2xjZF9hY2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQxNl9pcnFfbGNkX2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl9tYXNrYWNrKGlycW5vLCBJTlRNU0tfTENELCBTVUJNU0tfTENEKTsKKwlzM2NfaXJxc3ViX21hc2thY2soZGF0YS0+aXJxLCBJTlRNU0tfTENELCBTVUJNU0tfTENEKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2MyNDE2X2lycV9sY2QgPSB7Ci0JLm1hc2sJICAgID0gczNjMjQxNl9pcnFfbGNkX21hc2ssCi0JLnVubWFzawkgICAgPSBzM2MyNDE2X2lycV9sY2RfdW5tYXNrLAotCS5hY2sJICAgID0gczNjMjQxNl9pcnFfbGNkX2FjaywKKwkuaXJxX21hc2sJPSBzM2MyNDE2X2lycV9sY2RfbWFzaywKKwkuaXJxX3VubWFzawk9IHMzYzI0MTZfaXJxX2xjZF91bm1hc2ssCisJLmlycV9hY2sJPSBzM2MyNDE2X2lycV9sY2RfYWNrLAogfTsKIAotCiAvKiBETUEgc3ViIGludGVycnVwdHMgKi8KIAogc3RhdGljIHZvaWQgczNjMjQxNl9pcnFfZGVtdXhfZG1hKHVuc2lnbmVkIGludCBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKQEAgLTE0MiwyOCArMTQwLDI3IEBACiAjZGVmaW5lIFNVQk1TS19ETUEJSU5UTVNLKElSUV9TM0MyNDQzX0RNQTAsIElSUV9TM0MyNDQzX0RNQTUpCiAKIAotc3RhdGljIHZvaWQgczNjMjQxNl9pcnFfZG1hX21hc2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQxNl9pcnFfZG1hX21hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXMzY19pcnFzdWJfbWFzayhpcnFubywgSU5UTVNLX0RNQSwgU1VCTVNLX0RNQSk7CisJczNjX2lycXN1Yl9tYXNrKGRhdGEtPmlycSwgSU5UTVNLX0RNQSwgU1VCTVNLX0RNQSk7CiB9CiAKLXN0YXRpYyB2b2lkIHMzYzI0MTZfaXJxX2RtYV91bm1hc2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQxNl9pcnFfZG1hX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl91bm1hc2soaXJxbm8sIElOVE1TS19ETUEpOworCXMzY19pcnFzdWJfdW5tYXNrKGRhdGEtPmlycSwgSU5UTVNLX0RNQSk7CiB9CiAKLXN0YXRpYyB2b2lkIHMzYzI0MTZfaXJxX2RtYV9hY2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQxNl9pcnFfZG1hX2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl9tYXNrYWNrKGlycW5vLCBJTlRNU0tfRE1BLCBTVUJNU0tfRE1BKTsKKwlzM2NfaXJxc3ViX21hc2thY2soZGF0YS0+aXJxLCBJTlRNU0tfRE1BLCBTVUJNU0tfRE1BKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2MyNDE2X2lycV9kbWEgPSB7Ci0JLm1hc2sJICAgID0gczNjMjQxNl9pcnFfZG1hX21hc2ssCi0JLnVubWFzawkgICAgPSBzM2MyNDE2X2lycV9kbWFfdW5tYXNrLAotCS5hY2sJICAgID0gczNjMjQxNl9pcnFfZG1hX2FjaywKKwkuaXJxX21hc2sJPSBzM2MyNDE2X2lycV9kbWFfbWFzaywKKwkuaXJxX3VubWFzawk9IHMzYzI0MTZfaXJxX2RtYV91bm1hc2ssCisJLmlycV9hY2sJPSBzM2MyNDE2X2lycV9kbWFfYWNrLAogfTsKIAotCiAvKiBVQVJUMyBzdWIgaW50ZXJydXB0cyAqLwogCiBzdGF0aWMgdm9pZCBzM2MyNDE2X2lycV9kZW11eF91YXJ0Myh1bnNpZ25lZCBpbnQgaXJxLCBzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MpCkBAIC0xNzQsMjggKzE3MSwyNyBAQAogI2RlZmluZSBJTlRNU0tfVUFSVDMJKDFVTCA8PCAoSVJRX1MzQzI0NDNfVUFSVDMgLSBJUlFfRUlOVDApKQogI2RlZmluZSBTVUJNU0tfVUFSVDMJKDB4NyA8PCAoSVJRX1MzQzI0NDNfUlgzIC0gUzNDMjQxMF9JUlFTVUIoMCkpKQogCi1zdGF0aWMgdm9pZCBzM2MyNDE2X2lycV91YXJ0M19tYXNrKHVuc2lnbmVkIGludCBpcnFubykKK3N0YXRpYyB2b2lkIHMzYzI0MTZfaXJxX3VhcnQzX21hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXMzY19pcnFzdWJfbWFzayhpcnFubywgSU5UTVNLX1VBUlQzLCBTVUJNU0tfVUFSVDMpOworCXMzY19pcnFzdWJfbWFzayhkYXRhLT5pcnEsIElOVE1TS19VQVJUMywgU1VCTVNLX1VBUlQzKTsKIH0KIAotc3RhdGljIHZvaWQgczNjMjQxNl9pcnFfdWFydDNfdW5tYXNrKHVuc2lnbmVkIGludCBpcnFubykKK3N0YXRpYyB2b2lkIHMzYzI0MTZfaXJxX3VhcnQzX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl91bm1hc2soaXJxbm8sIElOVE1TS19VQVJUMyk7CisJczNjX2lycXN1Yl91bm1hc2soZGF0YS0+aXJxLCBJTlRNU0tfVUFSVDMpOwogfQogCi1zdGF0aWMgdm9pZCBzM2MyNDE2X2lycV91YXJ0M19hY2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQxNl9pcnFfdWFydDNfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX21hc2thY2soaXJxbm8sIElOVE1TS19VQVJUMywgU1VCTVNLX1VBUlQzKTsKKwlzM2NfaXJxc3ViX21hc2thY2soZGF0YS0+aXJxLCBJTlRNU0tfVUFSVDMsIFNVQk1TS19VQVJUMyk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgczNjMjQxNl9pcnFfdWFydDMgPSB7Ci0JLm1hc2sJICAgID0gczNjMjQxNl9pcnFfdWFydDNfbWFzaywKLQkudW5tYXNrCSAgICA9IHMzYzI0MTZfaXJxX3VhcnQzX3VubWFzaywKLQkuYWNrCSAgICA9IHMzYzI0MTZfaXJxX3VhcnQzX2FjaywKKwkuaXJxX21hc2sJPSBzM2MyNDE2X2lycV91YXJ0M19tYXNrLAorCS5pcnFfdW5tYXNrCT0gczNjMjQxNl9pcnFfdWFydDNfdW5tYXNrLAorCS5pcnFfYWNrCT0gczNjMjQxNl9pcnFfdWFydDNfYWNrLAogfTsKIAotCiAvKiBJUlEgaW5pdGlhbGlzYXRpb24gY29kZSAqLwogCiBzdGF0aWMgaW50IF9faW5pdCBzM2MyNDE2X2FkZF9zdWIodW5zaWduZWQgaW50IGJhc2UsCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXMzYzI0MTYvbWFjaC1zbWRrMjQxNi5jIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDE2L21hY2gtc21kazI0MTYuYwppbmRleCA3ZmMzNjY0Li4zZjgzMTc3IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXMzYzI0MTYvbWFjaC1zbWRrMjQxNi5jCisrKyBiL2FyY2gvYXJtL21hY2gtczNjMjQxNi9tYWNoLXNtZGsyNDE2LmMKQEAgLTQ2LDYgKzQ2LDcgQEAKICNpbmNsdWRlIDxwbGF0L2RldnMuaD4KICNpbmNsdWRlIDxwbGF0L2NwdS5oPgogI2luY2x1ZGUgPHBsYXQvbmFuZC5oPgorI2luY2x1ZGUgPHBsYXQvc2RoY2kuaD4KIAogI2luY2x1ZGUgPHBsYXQvcmVncy1mYi12NC5oPgogI2luY2x1ZGUgPHBsYXQvZmIuaD4KQEAgLTExMCw2ICsxMTEsMTMgQEAKIAkJLnVjb24JICAgICA9IFVDT04sCiAJCS51bGNvbgkgICAgID0gVUxDT04gfCAweDUwLAogCQkudWZjb24JICAgICA9IFVGQ09OLAorCX0sCisJWzNdID0geworCQkuaHdwb3J0CSAgICAgPSAzLAorCQkuZmxhZ3MJICAgICA9IDAsCisJCS51Y29uCSAgICAgPSBVQ09OLAorCQkudWxjb24JICAgICA9IFVMQ09OLAorCQkudWZjb24JICAgICA9IFVGQ09OLAogCX0KIH07CiAKQEAgLTE1OSw2ICsxNjcsMTggQEAKIAkudmlkY29uMQk9IFZJRENPTjFfSU5WX0hTWU5DIHwgVklEQ09OMV9JTlZfVlNZTkMsCiB9OwogCitzdGF0aWMgc3RydWN0IHMzY19zZGhjaV9wbGF0ZGF0YSBzbWRrMjQxNl9oc21tYzBfcGRhdGEgX19pbml0ZGF0YSA9IHsKKwkubWF4X3dpZHRoCQk9IDQsCisJLmNkX3R5cGUJCT0gUzNDX1NESENJX0NEX0dQSU8sCisJLmV4dF9jZF9ncGlvCQk9IFMzQzI0MTBfR1BGKDEpLAorCS5leHRfY2RfZ3Bpb19pbnZlcnQJPSAxLAorfTsKKworc3RhdGljIHN0cnVjdCBzM2Nfc2RoY2lfcGxhdGRhdGEgc21kazI0MTZfaHNtbWMxX3BkYXRhIF9faW5pdGRhdGEgPSB7CisJLm1heF93aWR0aAkJPSA0LAorCS5jZF90eXBlCQk9IFMzQ19TREhDSV9DRF9OT05FLAorfTsKKwogc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnNtZGsyNDE2X2RldmljZXNbXSBfX2luaXRkYXRhID0gewogCSZzM2NfZGV2aWNlX2ZiLAogCSZzM2NfZGV2aWNlX3dkdCwKQEAgLTE4MCw2ICsyMDAsOSBAQAogCXMzY19pMmMwX3NldF9wbGF0ZGF0YShOVUxMKTsKIAlzM2NfZmJfc2V0X3BsYXRkYXRhKCZzbWRrMjQxNl9mYl9wbGF0ZGF0YSk7CiAKKwlzM2Nfc2RoY2kwX3NldF9wbGF0ZGF0YSgmc21kazI0MTZfaHNtbWMwX3BkYXRhKTsKKwlzM2Nfc2RoY2kxX3NldF9wbGF0ZGF0YSgmc21kazI0MTZfaHNtbWMxX3BkYXRhKTsKKwogCWdwaW9fcmVxdWVzdChTM0MyNDEwX0dQQig0KSwgIlVTQkhvc3QgUG93ZXIiKTsKIAlncGlvX2RpcmVjdGlvbl9vdXRwdXQoUzNDMjQxMF9HUEIoNCksIDEpOwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXMzYzI0MTYvczNjMjQxNi5jIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDE2L3MzYzI0MTYuYwppbmRleCA2M2YzOWNkLi5iYTdmZDg3IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXMzYzI0MTYvczNjMjQxNi5jCisrKyBiL2FyY2gvYXJtL21hY2gtczNjMjQxNi9zM2MyNDE2LmMKQEAgLTUzLDYgKzUzLDcgQEAKICNpbmNsdWRlIDxwbGF0L3MzYzI0MTYuaD4KICNpbmNsdWRlIDxwbGF0L2RldnMuaD4KICNpbmNsdWRlIDxwbGF0L2NwdS5oPgorI2luY2x1ZGUgPHBsYXQvc2RoY2kuaD4KIAogI2luY2x1ZGUgPHBsYXQvaWljLWNvcmUuaD4KICNpbmNsdWRlIDxwbGF0L2ZiLWNvcmUuaD4KQEAgLTExNSw2ICsxMTYsMTAgQEAKIAlzM2MyNHh4X2dwaW9jZmdfZGVmYXVsdC5zZXRfcHVsbCA9IHMzY19ncGlvX3NldHB1bGxfdXBkb3duOwogCXMzYzI0eHhfZ3Bpb2NmZ19kZWZhdWx0LmdldF9wdWxsID0gczNjX2dwaW9fZ2V0cHVsbF91cGRvd247CiAKKwkvKiBpbml0aWFsaXplIGRldmljZSBpbmZvcm1hdGlvbiBlYXJseSAqLworCXMzYzI0MTZfZGVmYXVsdF9zZGhjaTAoKTsKKwlzM2MyNDE2X2RlZmF1bHRfc2RoY2kxKCk7CisKIAlpb3RhYmxlX2luaXQoczNjMjQxNl9pb2Rlc2MsIEFSUkFZX1NJWkUoczNjMjQxNl9pb2Rlc2MpKTsKIH0KIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zM2MyNDE2L3NldHVwLXNkaGNpLWdwaW8uYyBiL2FyY2gvYXJtL21hY2gtczNjMjQxNi9zZXR1cC1zZGhjaS1ncGlvLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjY1Y2IzZQotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvYXJtL21hY2gtczNjMjQxNi9zZXR1cC1zZGhjaS1ncGlvLmMKQEAgLTAsMCArMSwzNCBAQAorLyogbGludXgvYXJjaC9hcm0vcGxhdC1zM2MyNDE2L3NldHVwLXNkaGNpLWdwaW8uYworICoKKyAqIENvcHlyaWdodCAyMDEwIFByb213YWQgSW5ub3ZhdGlvbiBDb21wYW55CisgKglZYXVoZW4gS2hhcnV6aHkgPHlhdWhlbi5raGFydXpoeUBwcm9td2FkLmNvbT4KKyAqCisgKiBTM0MyNDE2IC0gSGVscGVyIGZ1bmN0aW9ucyBmb3Igc2V0dGluZyB1cCBTREhDSSBkZXZpY2UocykgR1BJTyAoSFNNTUMpCisgKgorICogQmFzZWQgb24gbWFjaC1zM2M2NHh4L3NldHVwLXNkaGNpLWdwaW8uYworICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisqLworCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9pby5oPgorI2luY2x1ZGUgPGxpbnV4L2dwaW8uaD4KKworI2luY2x1ZGUgPG1hY2gvcmVncy1ncGlvLmg+CisjaW5jbHVkZSA8cGxhdC9ncGlvLWNmZy5oPgorCit2b2lkIHMzYzI0MTZfc2V0dXBfc2RoY2kwX2NmZ19ncGlvKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKmRldiwgaW50IHdpZHRoKQoreworCXMzY19ncGlvX2NmZ3JhbmdlX25vcHVsbChTM0MyNDEwX0dQRSg1KSwgMiArIHdpZHRoLCBTM0NfR1BJT19TRk4oMikpOworfQorCit2b2lkIHMzYzI0MTZfc2V0dXBfc2RoY2kxX2NmZ19ncGlvKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKmRldiwgaW50IHdpZHRoKQoreworCXMzY19ncGlvX2NmZ3JhbmdlX25vcHVsbChTM0MyNDEwX0dQTCgwKSwgd2lkdGgsIFMzQ19HUElPX1NGTigyKSk7CisJczNjX2dwaW9fY2ZncmFuZ2Vfbm9wdWxsKFMzQzI0MTBfR1BMKDgpLCAyLCBTM0NfR1BJT19TRk4oMikpOworfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zM2MyNDE2L3NldHVwLXNkaGNpLmMgYi9hcmNoL2FybS9tYWNoLXMzYzI0MTYvc2V0dXAtc2RoY2kuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lZDM0ZmFkCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDE2L3NldHVwLXNkaGNpLmMKQEAgLTAsMCArMSw2MSBAQAorLyogbGludXgvYXJjaC9hcm0vbWFjaC1zM2MyNDE2L3NldHVwLXNkaGNpLmMKKyAqCisgKiBDb3B5cmlnaHQgMjAxMCBQcm9td2FkIElubm92YXRpb24gQ29tcGFueQorICoJWWF1aGVuIEtoYXJ1emh5IDx5YXVoZW4ua2hhcnV6aHlAcHJvbXdhZC5jb20+CisgKgorICogUzNDMjQxNiAtIEhlbHBlciBmdW5jdGlvbnMgZm9yIHNldHRpZ24gdXAgU0RIQ0kgZGV2aWNlKHMpIChIU01NQykKKyAqCisgKiBCYXNlZCBvbiBtYWNoLXMzYzY0eHgvc2V0dXAtc2RoY2kuYworICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisqLworCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9pby5oPgorCisjaW5jbHVkZSA8bGludXgvbW1jL2NhcmQuaD4KKyNpbmNsdWRlIDxsaW51eC9tbWMvaG9zdC5oPgorCisjaW5jbHVkZSA8cGxhdC9yZWdzLXNkaGNpLmg+CisjaW5jbHVkZSA8cGxhdC9zZGhjaS5oPgorCisvKiBjbG9jayBzb3VyY2VzIGZvciB0aGUgbW1jIGJ1cyBjbG9jaywgb3JkZXIgYXMgZm9yIHRoZSBjdHJsMls1Li40XSAqLworCitjaGFyICpzM2MyNDE2X2hzbW1jX2Nsa3NyY3NbNF0gPSB7CisJWzBdID0gImhzbW1jIiwKKwlbMV0gPSAiaHNtbWMiLAorCVsyXSA9ICJoc21tYy1pZiIsCisJLyogWzNdID0gIjQ4bSIsIC0gbm90ZSBub3Qgc3VjY2Vzc2Z1bGx5IHVzZWQgeWV0ICovCit9OworCit2b2lkIHMzYzI0MTZfc2V0dXBfc2RoY2lfY2ZnX2NhcmQoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqZGV2LAorCQkJCSAgdm9pZCBfX2lvbWVtICpyLAorCQkJCSAgc3RydWN0IG1tY19pb3MgKmlvcywKKwkJCQkgIHN0cnVjdCBtbWNfY2FyZCAqY2FyZCkKK3sKKwl1MzIgY3RybDIsIGN0cmwzOworCisJY3RybDIgPSBfX3Jhd19yZWFkbChyICsgUzNDX1NESENJX0NPTlRST0wyKTsKKwljdHJsMiAmPSBTM0NfU0RIQ0lfQ1RSTDJfU0VMQkFTRUNMS19NQVNLOworCWN0cmwyIHw9IChTM0M2NFhYX1NESENJX0NUUkwyX0VOU1RBQVNZTkNDTFIgfAorCQkgIFMzQzY0WFhfU0RIQ0lfQ1RSTDJfRU5DTURDTkZNU0sgfAorCQkgIFMzQ19TREhDSV9DVFJMMl9FTkZCQ0xLUlggfAorCQkgIFMzQ19TREhDSV9DVFJMMl9ERkNOVF9OT05FIHwKKwkJICBTM0NfU0RIQ0lfQ1RSTDJfRU5DTEtPVVRIT0xEKTsKKworCWlmIChpb3MtPmNsb2NrIDwgMjUgKiAxMDAwMDAwKQorCQljdHJsMyA9IChTM0NfU0RIQ0lfQ1RSTDNfRkNTRUwzIHwKKwkJCSBTM0NfU0RIQ0lfQ1RSTDNfRkNTRUwyIHwKKwkJCSBTM0NfU0RIQ0lfQ1RSTDNfRkNTRUwxIHwKKwkJCSBTM0NfU0RIQ0lfQ1RSTDNfRkNTRUwwKTsKKwllbHNlCisJCWN0cmwzID0gKFMzQ19TREhDSV9DVFJMM19GQ1NFTDEgfCBTM0NfU0RIQ0lfQ1RSTDNfRkNTRUwwKTsKKworCV9fcmF3X3dyaXRlbChjdHJsMiwgciArIFMzQ19TREhDSV9DT05UUk9MMik7CisJX19yYXdfd3JpdGVsKGN0cmwzLCByICsgUzNDX1NESENJX0NPTlRST0wzKTsKK30KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczNjMjQ0MC9pcnEuYyBiL2FyY2gvYXJtL21hY2gtczNjMjQ0MC9pcnEuYwppbmRleCAwYzA0OWI5Li5hY2FkNDQyIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXMzYzI0NDAvaXJxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDQwL2lycS5jCkBAIC02OSwyNyArNjksMjcgQEAKICNkZWZpbmUgSU5UTVNLX1dEVAkgKDFVTCA8PCAoSVJRX1dEVCAtIElSUV9FSU5UMCkpCiAKIHN0YXRpYyB2b2lkCi1zM2NfaXJxX3dkdGFjOTdfbWFzayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzM2NfaXJxX3dkdGFjOTdfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl9tYXNrKGlycW5vLCBJTlRNU0tfV0RULCAzPDwxMyk7CisJczNjX2lycXN1Yl9tYXNrKGRhdGEtPmlycSwgSU5UTVNLX1dEVCwgMyA8PCAxMyk7CiB9CiAKIHN0YXRpYyB2b2lkCi1zM2NfaXJxX3dkdGFjOTdfdW5tYXNrKHVuc2lnbmVkIGludCBpcnFubykKK3MzY19pcnFfd2R0YWM5N191bm1hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXMzY19pcnFzdWJfdW5tYXNrKGlycW5vLCBJTlRNU0tfV0RUKTsKKwlzM2NfaXJxc3ViX3VubWFzayhkYXRhLT5pcnEsIElOVE1TS19XRFQpOwogfQogCiBzdGF0aWMgdm9pZAotczNjX2lycV93ZHRhYzk3X2Fjayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzM2NfaXJxX3dkdGFjOTdfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX21hc2thY2soaXJxbm8sIElOVE1TS19XRFQsIDM8PDEzKTsKKwlzM2NfaXJxc3ViX21hc2thY2soZGF0YS0+aXJxLCBJTlRNU0tfV0RULCAzIDw8IDEzKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2NfaXJxX3dkdGFjOTcgPSB7Ci0JLm1hc2sJICAgID0gczNjX2lycV93ZHRhYzk3X21hc2ssCi0JLnVubWFzawkgICAgPSBzM2NfaXJxX3dkdGFjOTdfdW5tYXNrLAotCS5hY2sJICAgID0gczNjX2lycV93ZHRhYzk3X2FjaywKKwkuaXJxX21hc2sJPSBzM2NfaXJxX3dkdGFjOTdfbWFzaywKKwkuaXJxX3VubWFzawk9IHMzY19pcnFfd2R0YWM5N191bm1hc2ssCisJLmlycV9hY2sJPSBzM2NfaXJxX3dkdGFjOTdfYWNrLAogfTsKIAogc3RhdGljIGludCBzM2MyNDQwX2lycV9hZGQoc3RydWN0IHN5c19kZXZpY2UgKnN5c2RldikKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczNjMjQ0MC9zM2MyNDR4LWlycS5jIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDQwL3MzYzI0NHgtaXJxLmMKaW5kZXggYTc1YzBjMi4uODNkYWY0ZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zM2MyNDQwL3MzYzI0NHgtaXJxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDQwL3MzYzI0NHgtaXJxLmMKQEAgLTY4LDI3ICs2OCwyNyBAQAogI2RlZmluZSBJTlRNU0tfQ0FNICgxVUwgPDwgKElSUV9DQU0gLSBJUlFfRUlOVDApKQogCiBzdGF0aWMgdm9pZAotczNjX2lycV9jYW1fbWFzayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzM2NfaXJxX2NhbV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX21hc2soaXJxbm8sIElOVE1TS19DQU0sIDM8PDExKTsKKwlzM2NfaXJxc3ViX21hc2soZGF0YS0+aXJxLCBJTlRNU0tfQ0FNLCAzIDw8IDExKTsKIH0KIAogc3RhdGljIHZvaWQKLXMzY19pcnFfY2FtX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzM2NfaXJxX2NhbV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXMzY19pcnFzdWJfdW5tYXNrKGlycW5vLCBJTlRNU0tfQ0FNKTsKKwlzM2NfaXJxc3ViX3VubWFzayhkYXRhLT5pcnEsIElOVE1TS19DQU0pOwogfQogCiBzdGF0aWMgdm9pZAotczNjX2lycV9jYW1fYWNrKHVuc2lnbmVkIGludCBpcnFubykKK3MzY19pcnFfY2FtX2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl9tYXNrYWNrKGlycW5vLCBJTlRNU0tfQ0FNLCAzPDwxMSk7CisJczNjX2lycXN1Yl9tYXNrYWNrKGRhdGEtPmlycSwgSU5UTVNLX0NBTSwgMyA8PCAxMSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgczNjX2lycV9jYW0gPSB7Ci0JLm1hc2sJICAgID0gczNjX2lycV9jYW1fbWFzaywKLQkudW5tYXNrCSAgICA9IHMzY19pcnFfY2FtX3VubWFzaywKLQkuYWNrCSAgICA9IHMzY19pcnFfY2FtX2FjaywKKwkuaXJxX21hc2sJPSBzM2NfaXJxX2NhbV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gczNjX2lycV9jYW1fdW5tYXNrLAorCS5pcnFfYWNrCT0gczNjX2lycV9jYW1fYWNrLAogfTsKIAogc3RhdGljIGludCBzM2MyNDR4X2lycV9hZGQoc3RydWN0IHN5c19kZXZpY2UgKnN5c2RldikKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczNjMjQ0My9LY29uZmlnIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDQzL0tjb25maWcKaW5kZXggMzFiYWJlYy4uZDhlYjg2OCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zM2MyNDQzL0tjb25maWcKKysrIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDQzL0tjb25maWcKQEAgLTEwLDYgKzEwLDcgQEAKIAlzZWxlY3QgQ1BVX0xMU0VSSUFMX1MzQzI0NDAKIAlzZWxlY3QgU0FNU1VOR19DTEtTUkMKIAlzZWxlY3QgUzNDMjQ0M19DTE9DSworCXNlbGVjdCBTM0NfR1BJT19QVUxMX1MzQzI0NDMKIAloZWxwCiAJICBTdXBwb3J0IGZvciB0aGUgUzNDMjQ0MyBTb0MgZnJvbSB0aGUgUzNDMjRYWCBsaW5lCiAKQEAgLTI1LDcgKzI2LDcgQEAKIAlib29sICJTTURLMjQ0MyIKIAlzZWxlY3QgQ1BVX1MzQzI0NDMKIAlzZWxlY3QgTUFDSF9TTURLCi0Jc2VsZWN0IFMzQ19ERVZfSFNNTUMKKwlzZWxlY3QgUzNDX0RFVl9IU01NQzEKIAloZWxwCiAJICBTYXkgWSBoZXJlIGlmIHlvdSBhcmUgdXNpbmcgYW4gU01ESzI0NDMKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zM2MyNDQzL2Nsb2NrLmMgYi9hcmNoL2FybS9tYWNoLXMzYzI0NDMvY2xvY2suYwppbmRleCAwYzNjMGM4Li5mNGVjNmQ1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXMzYzI0NDMvY2xvY2suYworKysgYi9hcmNoL2FybS9tYWNoLXMzYzI0NDMvY2xvY2suYwpAQCAtMTk2LDcgKzE5Niw3IEBACiBzdGF0aWMgc3RydWN0IGNsa3NyY19jbGsgY2xrX2hzbW1jX2RpdiA9IHsKIAkuY2xrCT0gewogCQkubmFtZQkJPSAiaHNtbWMtZGl2IiwKLQkJLmlkCQk9IC0xLAorCQkuaWQJCT0gMSwKIAkJLnBhcmVudAkJPSAmY2xrX2VzeXNjbGsuY2xrLAogCX0sCiAJLnJlZ19kaXYgPSB7IC5yZWcgPSBTM0MyNDQzX0NMS0RJVjEsIC5zaXplID0gMiwgLnNoaWZ0ID0gNiB9LApAQCAtMjMxLDcgKzIzMSw3IEBACiAKIHN0YXRpYyBzdHJ1Y3QgY2xrIGNsa19oc21tYyA9IHsKIAkubmFtZQkJPSAiaHNtbWMtaWYiLAotCS5pZAkJPSAtMSwKKwkuaWQJCT0gMSwKIAkucGFyZW50CQk9ICZjbGtfaHNtbWNfZGl2LmNsaywKIAkuZW5hYmxlCQk9IHMzYzI0NDNfZW5hYmxlX2hzbW1jLAogCS5vcHMJCT0gJihzdHJ1Y3QgY2xrX29wcykgewpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zM2MyNDQzL2lycS5jIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDQzL2lycS5jCmluZGV4IDg5MzQyNDcuLmM3ODIwZjkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczNjMjQ0My9pcnEuYworKysgYi9hcmNoL2FybS9tYWNoLXMzYzI0NDMvaXJxLmMKQEAgLTc1LDI4ICs3NSwyNyBAQAogI2RlZmluZSBJTlRNU0tfV0RUQUM5NwkoMVVMIDw8IChJUlFfV0RUIC0gSVJRX0VJTlQwKSkKICNkZWZpbmUgU1VCTVNLX1dEVEFDOTcJSU5UTVNLKElSUV9TM0MyNDQzX1dEVCwgSVJRX1MzQzI0NDNfQUM5NykKIAotc3RhdGljIHZvaWQgczNjMjQ0M19pcnFfd2R0YWM5N19tYXNrKHVuc2lnbmVkIGludCBpcnFubykKK3N0YXRpYyB2b2lkIHMzYzI0NDNfaXJxX3dkdGFjOTdfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl9tYXNrKGlycW5vLCBJTlRNU0tfV0RUQUM5NywgU1VCTVNLX1dEVEFDOTcpOworCXMzY19pcnFzdWJfbWFzayhkYXRhLT5pcnEsIElOVE1TS19XRFRBQzk3LCBTVUJNU0tfV0RUQUM5Nyk7CiB9CiAKLXN0YXRpYyB2b2lkIHMzYzI0NDNfaXJxX3dkdGFjOTdfdW5tYXNrKHVuc2lnbmVkIGludCBpcnFubykKK3N0YXRpYyB2b2lkIHMzYzI0NDNfaXJxX3dkdGFjOTdfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX3VubWFzayhpcnFubywgSU5UTVNLX1dEVEFDOTcpOworCXMzY19pcnFzdWJfdW5tYXNrKGRhdGEtPmlycSwgSU5UTVNLX1dEVEFDOTcpOwogfQogCi1zdGF0aWMgdm9pZCBzM2MyNDQzX2lycV93ZHRhYzk3X2Fjayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzdGF0aWMgdm9pZCBzM2MyNDQzX2lycV93ZHRhYzk3X2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl9tYXNrYWNrKGlycW5vLCBJTlRNU0tfV0RUQUM5NywgU1VCTVNLX1dEVEFDOTcpOworCXMzY19pcnFzdWJfbWFza2FjayhkYXRhLT5pcnEsIElOVE1TS19XRFRBQzk3LCBTVUJNU0tfV0RUQUM5Nyk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgczNjMjQ0M19pcnFfd2R0YWM5NyA9IHsKLQkubWFzawkgICAgPSBzM2MyNDQzX2lycV93ZHRhYzk3X21hc2ssCi0JLnVubWFzawkgICAgPSBzM2MyNDQzX2lycV93ZHRhYzk3X3VubWFzaywKLQkuYWNrCSAgICA9IHMzYzI0NDNfaXJxX3dkdGFjOTdfYWNrLAorCS5pcnFfbWFzawk9IHMzYzI0NDNfaXJxX3dkdGFjOTdfbWFzaywKKwkuaXJxX3VubWFzawk9IHMzYzI0NDNfaXJxX3dkdGFjOTdfdW5tYXNrLAorCS5pcnFfYWNrCT0gczNjMjQ0M19pcnFfd2R0YWM5N19hY2ssCiB9OwogCi0KIC8qIExDRCBzdWIgaW50ZXJydXB0cyAqLwogCiBzdGF0aWMgdm9pZCBzM2MyNDQzX2lycV9kZW11eF9sY2QodW5zaWduZWQgaW50IGlycSwgc3RydWN0IGlycV9kZXNjICpkZXNjKQpAQCAtMTA3LDI4ICsxMDYsMjcgQEAKICNkZWZpbmUgSU5UTVNLX0xDRAkoMVVMIDw8IChJUlFfTENEIC0gSVJRX0VJTlQwKSkKICNkZWZpbmUgU1VCTVNLX0xDRAlJTlRNU0soSVJRX1MzQzI0NDNfTENEMSwgSVJRX1MzQzI0NDNfTENENCkKIAotc3RhdGljIHZvaWQgczNjMjQ0M19pcnFfbGNkX21hc2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQ0M19pcnFfbGNkX21hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXMzY19pcnFzdWJfbWFzayhpcnFubywgSU5UTVNLX0xDRCwgU1VCTVNLX0xDRCk7CisJczNjX2lycXN1Yl9tYXNrKGRhdGEtPmlycSwgSU5UTVNLX0xDRCwgU1VCTVNLX0xDRCk7CiB9CiAKLXN0YXRpYyB2b2lkIHMzYzI0NDNfaXJxX2xjZF91bm1hc2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQ0M19pcnFfbGNkX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl91bm1hc2soaXJxbm8sIElOVE1TS19MQ0QpOworCXMzY19pcnFzdWJfdW5tYXNrKGRhdGEtPmlycSwgSU5UTVNLX0xDRCk7CiB9CiAKLXN0YXRpYyB2b2lkIHMzYzI0NDNfaXJxX2xjZF9hY2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQ0M19pcnFfbGNkX2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl9tYXNrYWNrKGlycW5vLCBJTlRNU0tfTENELCBTVUJNU0tfTENEKTsKKwlzM2NfaXJxc3ViX21hc2thY2soZGF0YS0+aXJxLCBJTlRNU0tfTENELCBTVUJNU0tfTENEKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2MyNDQzX2lycV9sY2QgPSB7Ci0JLm1hc2sJICAgID0gczNjMjQ0M19pcnFfbGNkX21hc2ssCi0JLnVubWFzawkgICAgPSBzM2MyNDQzX2lycV9sY2RfdW5tYXNrLAotCS5hY2sJICAgID0gczNjMjQ0M19pcnFfbGNkX2FjaywKKwkuaXJxX21hc2sJPSBzM2MyNDQzX2lycV9sY2RfbWFzaywKKwkuaXJxX3VubWFzawk9IHMzYzI0NDNfaXJxX2xjZF91bm1hc2ssCisJLmlycV9hY2sJPSBzM2MyNDQzX2lycV9sY2RfYWNrLAogfTsKIAotCiAvKiBETUEgc3ViIGludGVycnVwdHMgKi8KIAogc3RhdGljIHZvaWQgczNjMjQ0M19pcnFfZGVtdXhfZG1hKHVuc2lnbmVkIGludCBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKQEAgLTEzOSwyOSArMTM3LDI3IEBACiAjZGVmaW5lIElOVE1TS19ETUEJKDFVTCA8PCAoSVJRX1MzQzI0NDNfRE1BIC0gSVJRX0VJTlQwKSkKICNkZWZpbmUgU1VCTVNLX0RNQQlJTlRNU0soSVJRX1MzQzI0NDNfRE1BMCwgSVJRX1MzQzI0NDNfRE1BNSkKIAotCi1zdGF0aWMgdm9pZCBzM2MyNDQzX2lycV9kbWFfbWFzayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzdGF0aWMgdm9pZCBzM2MyNDQzX2lycV9kbWFfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl9tYXNrKGlycW5vLCBJTlRNU0tfRE1BLCBTVUJNU0tfRE1BKTsKKwlzM2NfaXJxc3ViX21hc2soZGF0YS0+aXJxLCBJTlRNU0tfRE1BLCBTVUJNU0tfRE1BKTsKIH0KIAotc3RhdGljIHZvaWQgczNjMjQ0M19pcnFfZG1hX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzdGF0aWMgdm9pZCBzM2MyNDQzX2lycV9kbWFfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX3VubWFzayhpcnFubywgSU5UTVNLX0RNQSk7CisJczNjX2lycXN1Yl91bm1hc2soZGF0YS0+aXJxLCBJTlRNU0tfRE1BKTsKIH0KIAotc3RhdGljIHZvaWQgczNjMjQ0M19pcnFfZG1hX2Fjayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzdGF0aWMgdm9pZCBzM2MyNDQzX2lycV9kbWFfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX21hc2thY2soaXJxbm8sIElOVE1TS19ETUEsIFNVQk1TS19ETUEpOworCXMzY19pcnFzdWJfbWFza2FjayhkYXRhLT5pcnEsIElOVE1TS19ETUEsIFNVQk1TS19ETUEpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHMzYzI0NDNfaXJxX2RtYSA9IHsKLQkubWFzawkgICAgPSBzM2MyNDQzX2lycV9kbWFfbWFzaywKLQkudW5tYXNrCSAgICA9IHMzYzI0NDNfaXJxX2RtYV91bm1hc2ssCi0JLmFjawkgICAgPSBzM2MyNDQzX2lycV9kbWFfYWNrLAorCS5pcnFfbWFzawk9IHMzYzI0NDNfaXJxX2RtYV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gczNjMjQ0M19pcnFfZG1hX3VubWFzaywKKwkuaXJxX2Fjawk9IHMzYzI0NDNfaXJxX2RtYV9hY2ssCiB9OwogCi0KIC8qIFVBUlQzIHN1YiBpbnRlcnJ1cHRzICovCiAKIHN0YXRpYyB2b2lkIHMzYzI0NDNfaXJxX2RlbXV4X3VhcnQzKHVuc2lnbmVkIGludCBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKQEAgLTE3MiwyOCArMTY4LDI3IEBACiAjZGVmaW5lIElOVE1TS19VQVJUMwkoMVVMIDw8IChJUlFfUzNDMjQ0M19VQVJUMyAtIElSUV9FSU5UMCkpCiAjZGVmaW5lIFNVQk1TS19VQVJUMwkoMHg3IDw8IChJUlFfUzNDMjQ0M19SWDMgLSBTM0MyNDEwX0lSUVNVQigwKSkpCiAKLXN0YXRpYyB2b2lkIHMzYzI0NDNfaXJxX3VhcnQzX21hc2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQ0M19pcnFfdWFydDNfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl9tYXNrKGlycW5vLCBJTlRNU0tfVUFSVDMsIFNVQk1TS19VQVJUMyk7CisJczNjX2lycXN1Yl9tYXNrKGRhdGEtPmlycSwgSU5UTVNLX1VBUlQzLCBTVUJNU0tfVUFSVDMpOwogfQogCi1zdGF0aWMgdm9pZCBzM2MyNDQzX2lycV91YXJ0M191bm1hc2sodW5zaWduZWQgaW50IGlycW5vKQorc3RhdGljIHZvaWQgczNjMjQ0M19pcnFfdWFydDNfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX3VubWFzayhpcnFubywgSU5UTVNLX1VBUlQzKTsKKwlzM2NfaXJxc3ViX3VubWFzayhkYXRhLT5pcnEsIElOVE1TS19VQVJUMyk7CiB9CiAKLXN0YXRpYyB2b2lkIHMzYzI0NDNfaXJxX3VhcnQzX2Fjayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzdGF0aWMgdm9pZCBzM2MyNDQzX2lycV91YXJ0M19hY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXMzY19pcnFzdWJfbWFza2FjayhpcnFubywgSU5UTVNLX1VBUlQzLCBTVUJNU0tfVUFSVDMpOworCXMzY19pcnFzdWJfbWFza2FjayhkYXRhLT5pcnEsIElOVE1TS19VQVJUMywgU1VCTVNLX1VBUlQzKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2MyNDQzX2lycV91YXJ0MyA9IHsKLQkubWFzawkgICAgPSBzM2MyNDQzX2lycV91YXJ0M19tYXNrLAotCS51bm1hc2sJICAgID0gczNjMjQ0M19pcnFfdWFydDNfdW5tYXNrLAotCS5hY2sJICAgID0gczNjMjQ0M19pcnFfdWFydDNfYWNrLAorCS5pcnFfbWFzawk9IHMzYzI0NDNfaXJxX3VhcnQzX21hc2ssCisJLmlycV91bm1hc2sJPSBzM2MyNDQzX2lycV91YXJ0M191bm1hc2ssCisJLmlycV9hY2sJPSBzM2MyNDQzX2lycV91YXJ0M19hY2ssCiB9OwogCi0KIC8qIENBTSBzdWIgaW50ZXJydXB0cyAqLwogCiBzdGF0aWMgdm9pZCBzM2MyNDQzX2lycV9kZW11eF9jYW0odW5zaWduZWQgaW50IGlycSwgc3RydWN0IGlycV9kZXNjICpkZXNjKQpAQCAtMjA0LDI1ICsxOTksMjUgQEAKICNkZWZpbmUgSU5UTVNLX0NBTQkoMVVMIDw8IChJUlFfQ0FNIC0gSVJRX0VJTlQwKSkKICNkZWZpbmUgU1VCTVNLX0NBTQlJTlRNU0soSVJRX1MzQzI0NDBfQ0FNX0MsIElSUV9TM0MyNDQwX0NBTV9QKQogCi1zdGF0aWMgdm9pZCBzM2MyNDQzX2lycV9jYW1fbWFzayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzdGF0aWMgdm9pZCBzM2MyNDQzX2lycV9jYW1fbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl9tYXNrKGlycW5vLCBJTlRNU0tfQ0FNLCBTVUJNU0tfQ0FNKTsKKwlzM2NfaXJxc3ViX21hc2soZGF0YS0+aXJxLCBJTlRNU0tfQ0FNLCBTVUJNU0tfQ0FNKTsKIH0KIAotc3RhdGljIHZvaWQgczNjMjQ0M19pcnFfY2FtX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzdGF0aWMgdm9pZCBzM2MyNDQzX2lycV9jYW1fdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX3VubWFzayhpcnFubywgSU5UTVNLX0NBTSk7CisJczNjX2lycXN1Yl91bm1hc2soZGF0YS0+aXJxLCBJTlRNU0tfQ0FNKTsKIH0KIAotc3RhdGljIHZvaWQgczNjMjQ0M19pcnFfY2FtX2Fjayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzdGF0aWMgdm9pZCBzM2MyNDQzX2lycV9jYW1fYWNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX21hc2thY2soaXJxbm8sIElOVE1TS19DQU0sIFNVQk1TS19DQU0pOworCXMzY19pcnFzdWJfbWFza2FjayhkYXRhLT5pcnEsIElOVE1TS19DQU0sIFNVQk1TS19DQU0pOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHMzYzI0NDNfaXJxX2NhbSA9IHsKLQkubWFzawkgICAgPSBzM2MyNDQzX2lycV9jYW1fbWFzaywKLQkudW5tYXNrCSAgICA9IHMzYzI0NDNfaXJxX2NhbV91bm1hc2ssCi0JLmFjawkgICAgPSBzM2MyNDQzX2lycV9jYW1fYWNrLAorCS5pcnFfbWFzawk9IHMzYzI0NDNfaXJxX2NhbV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gczNjMjQ0M19pcnFfY2FtX3VubWFzaywKKwkuaXJxX2Fjawk9IHMzYzI0NDNfaXJxX2NhbV9hY2ssCiB9OwogCiAvKiBJUlEgaW5pdGlhbGlzYXRpb24gY29kZSAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zM2MyNDQzL21hY2gtc21kazI0NDMuYyBiL2FyY2gvYXJtL21hY2gtczNjMjQ0My9tYWNoLXNtZGsyNDQzLmMKaW5kZXggNDMzN2YwYS4uNTE0Mjc1ZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zM2MyNDQzL21hY2gtc21kazI0NDMuYworKysgYi9hcmNoL2FybS9tYWNoLXMzYzI0NDMvbWFjaC1zbWRrMjQ0My5jCkBAIC05OSwxMyArOTksMjAgQEAKIAkJLnVjb24JICAgICA9IDB4M2M1LAogCQkudWxjb24JICAgICA9IDB4NDMsCiAJCS51ZmNvbgkgICAgID0gMHg1MSwKKwl9LAorCVszXSA9IHsKKwkJLmh3cG9ydAkgICAgID0gMywKKwkJLmZsYWdzCSAgICAgPSAwLAorCQkudWNvbgkgICAgID0gMHgzYzUsCisJCS51bGNvbgkgICAgID0gMHgwMywKKwkJLnVmY29uCSAgICAgPSAweDUxLAogCX0KIH07CiAKIHN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpzbWRrMjQ0M19kZXZpY2VzW10gX19pbml0ZGF0YSA9IHsKIAkmczNjX2RldmljZV93ZHQsCiAJJnMzY19kZXZpY2VfaTJjMCwKLQkmczNjX2RldmljZV9oc21tYzAsCisJJnMzY19kZXZpY2VfaHNtbWMxLAogI2lmZGVmIENPTkZJR19TTkRfU09DX1NNREsyNDQzX1dNOTcxMAogCSZzM2NfZGV2aWNlX2FjOTcsCiAjZW5kaWYKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczNjMjQ0My9zM2MyNDQzLmMgYi9hcmNoL2FybS9tYWNoLXMzYzI0NDMvczNjMjQ0My5jCmluZGV4IDMzZDE4ZGQuLmU2YTI4YmEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczNjMjQ0My9zM2MyNDQzLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zM2MyNDQzL3MzYzI0NDMuYwpAQCAtMTYsNiArMTYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KICNpbmNsdWRlIDxsaW51eC90aW1lci5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9ncGlvLmg+CiAjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvc2VyaWFsX2NvcmUuaD4KICNpbmNsdWRlIDxsaW51eC9zeXNkZXYuaD4KQEAgLTMyLDYgKzMzLDkgQEAKICNpbmNsdWRlIDxtYWNoL3JlZ3MtczNjMjQ0My1jbG9jay5oPgogI2luY2x1ZGUgPG1hY2gvcmVzZXQuaD4KIAorI2luY2x1ZGUgPHBsYXQvZ3Bpby1jb3JlLmg+CisjaW5jbHVkZSA8cGxhdC9ncGlvLWNmZy5oPgorI2luY2x1ZGUgPHBsYXQvZ3Bpby1jZmctaGVscGVycy5oPgogI2luY2x1ZGUgPHBsYXQvczNjMjQ0My5oPgogI2luY2x1ZGUgPHBsYXQvZGV2cy5oPgogI2luY2x1ZGUgPHBsYXQvY3B1Lmg+CkBAIC04Niw2ICs5MCw5IEBACiAKIHZvaWQgX19pbml0IHMzYzI0NDNfbWFwX2lvKHZvaWQpCiB7CisJczNjMjR4eF9ncGlvY2ZnX2RlZmF1bHQuc2V0X3B1bGwgPSBzM2NfZ3Bpb19zZXRwdWxsX3MzYzI0NDM7CisJczNjMjR4eF9ncGlvY2ZnX2RlZmF1bHQuZ2V0X3B1bGwgPSBzM2NfZ3Bpb19nZXRwdWxsX3MzYzI0NDM7CisKIAlpb3RhYmxlX2luaXQoczNjMjQ0M19pb2Rlc2MsIEFSUkFZX1NJWkUoczNjMjQ0M19pb2Rlc2MpKTsKIH0KIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zM2M2NHh4L2Nsb2NrLmMgYi9hcmNoL2FybS9tYWNoLXMzYzY0eHgvY2xvY2suYwppbmRleCAxYzk4ZDJmZi4uZGQzNzgyMCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zM2M2NHh4L2Nsb2NrLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zM2M2NHh4L2Nsb2NrLmMKQEAgLTEyNyw3ICsxMjcsNyBAQAogCXJldHVybiBzM2M2NHh4X2dhdGUoUzNDX1NDTEtfR0FURSwgY2xrLCBlbmFibGUpOwogfQogCi1zdGF0aWMgc3RydWN0IGNsayBpbml0X2Nsb2Nrc19kaXNhYmxlW10gPSB7CitzdGF0aWMgc3RydWN0IGNsayBpbml0X2Nsb2Nrc19vZmZbXSA9IHsKIAl7CiAJCS5uYW1lCQk9ICJuYW5kIiwKIAkJLmlkCQk9IC0xLApAQCAtODM0LDEwICs4MzQsNiBAQAogdm9pZCBfX2luaXQgczNjNjR4eF9yZWdpc3Rlcl9jbG9ja3ModW5zaWduZWQgbG9uZyB4dGFsLCAKIAkJCQkgICAgdW5zaWduZWQgYXJtY2xrX2RpdmxpbWl0KQogewotCXN0cnVjdCBjbGsgKmNsa3A7Ci0JaW50IHJldDsKLQlpbnQgcHRyOwotCiAJYXJtY2xrX21hc2sgPSBhcm1jbGtfZGl2bGltaXQ7CiAKIAlzM2MyNHh4X3JlZ2lzdGVyX2Jhc2VjbG9ja3MoeHRhbCk7CkBAIC04NDUsMTcgKzg0MSw4IEBACiAKIAlzM2NfcmVnaXN0ZXJfY2xvY2tzKGluaXRfY2xvY2tzLCBBUlJBWV9TSVpFKGluaXRfY2xvY2tzKSk7CiAKLQljbGtwID0gaW5pdF9jbG9ja3NfZGlzYWJsZTsKLQlmb3IgKHB0ciA9IDA7IHB0ciA8IEFSUkFZX1NJWkUoaW5pdF9jbG9ja3NfZGlzYWJsZSk7IHB0cisrLCBjbGtwKyspIHsKLQotCQlyZXQgPSBzM2MyNHh4X3JlZ2lzdGVyX2Nsb2NrKGNsa3ApOwotCQlpZiAocmV0IDwgMCkgewotCQkJcHJpbnRrKEtFUk5fRVJSICJGYWlsZWQgdG8gcmVnaXN0ZXIgY2xvY2sgJXMgKCVkKVxuIiwKLQkJCSAgICAgICBjbGtwLT5uYW1lLCByZXQpOwotCQl9Ci0KLQkJKGNsa3AtPmVuYWJsZSkoY2xrcCwgMCk7Ci0JfQorCXMzY19yZWdpc3Rlcl9jbG9ja3MoaW5pdF9jbG9ja3Nfb2ZmLCBBUlJBWV9TSVpFKGluaXRfY2xvY2tzX29mZikpOworCXMzY19kaXNhYmxlX2Nsb2Nrcyhpbml0X2Nsb2Nrc19vZmYsIEFSUkFZX1NJWkUoaW5pdF9jbG9ja3Nfb2ZmKSk7CiAKIAlzM2MyNHh4X3JlZ2lzdGVyX2Nsb2NrcyhjbGtzMSwgQVJSQVlfU0laRShjbGtzMSkpOwogCXMzY19yZWdpc3Rlcl9jbGtzcmMoY2xrc3JjcywgQVJSQVlfU0laRShjbGtzcmNzKSk7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXMzYzY0eHgvZG1hLmMgYi9hcmNoL2FybS9tYWNoLXMzYzY0eHgvZG1hLmMKaW5kZXggMzcyZWE2OC4uMTM1ZGIxYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zM2M2NHh4L2RtYS5jCisrKyBiL2FyY2gvYXJtL21hY2gtczNjNjR4eC9kbWEuYwpAQCAtMjEyLDYgKzIxMiw3IEBACiAKIAljb25maWcgPSByZWFkbChjaGFuLT5yZWdzICsgUEwwODBTX0NIX0NPTkZJRyk7CiAJY29uZmlnIHw9IFBMMDgwX0NPTkZJR19FTkFCTEU7CisJY29uZmlnICY9IH5QTDA4MF9DT05GSUdfSEFMVDsKIAogCXByX2RlYnVnKCIlczogd3JpdGluZyBjb25maWcgJTA4eFxuIiwgX19mdW5jX18sIGNvbmZpZyk7CiAJd3JpdGVsKGNvbmZpZywgY2hhbi0+cmVncyArIFBMMDgwU19DSF9DT05GSUcpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zM2M2NHh4L2lycS1laW50LmMgYi9hcmNoL2FybS9tYWNoLXMzYzY0eHgvaXJxLWVpbnQuYwppbmRleCA1NjgyZDZhLi4yZWFkODE4IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXMzYzY0eHgvaXJxLWVpbnQuYworKysgYi9hcmNoL2FybS9tYWNoLXMzYzY0eHgvaXJxLWVpbnQuYwpAQCAtMzAsNDEgKzMwLDQxIEBACiAjaW5jbHVkZSA8cGxhdC9wbS5oPgogCiAjZGVmaW5lIGVpbnRfb2Zmc2V0KGlycSkJKChpcnEpIC0gSVJRX0VJTlQoMCkpCi0jZGVmaW5lIGVpbnRfaXJxX3RvX2JpdChpcnEpCSgxIDw8IGVpbnRfb2Zmc2V0KGlycSkpCisjZGVmaW5lIGVpbnRfaXJxX3RvX2JpdChpcnEpCSgodTMyKSgxIDw8IGVpbnRfb2Zmc2V0KGlycSkpKQogCi1zdGF0aWMgaW5saW5lIHZvaWQgczNjX2lycV9laW50X21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyBpbmxpbmUgdm9pZCBzM2NfaXJxX2VpbnRfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7CiAJdTMyIG1hc2s7CiAKIAltYXNrID0gX19yYXdfcmVhZGwoUzNDNjRYWF9FSU5UME1BU0spOwotCW1hc2sgfD0gZWludF9pcnFfdG9fYml0KGlycSk7CisJbWFzayB8PSAodTMyKWRhdGEtPmNoaXBfZGF0YTsKIAlfX3Jhd193cml0ZWwobWFzaywgUzNDNjRYWF9FSU5UME1BU0spOwogfQogCi1zdGF0aWMgdm9pZCBzM2NfaXJxX2VpbnRfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzM2NfaXJxX2VpbnRfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1MzIgbWFzazsKIAogCW1hc2sgPSBfX3Jhd19yZWFkbChTM0M2NFhYX0VJTlQwTUFTSyk7Ci0JbWFzayAmPSB+ZWludF9pcnFfdG9fYml0KGlycSk7CisJbWFzayAmPSB+KCh1MzIpZGF0YS0+Y2hpcF9kYXRhKTsKIAlfX3Jhd193cml0ZWwobWFzaywgUzNDNjRYWF9FSU5UME1BU0spOwogfQogCi1zdGF0aWMgaW5saW5lIHZvaWQgczNjX2lycV9laW50X2Fjayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIGlubGluZSB2b2lkIHMzY19pcnFfZWludF9hY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCV9fcmF3X3dyaXRlbChlaW50X2lycV90b19iaXQoaXJxKSwgUzNDNjRYWF9FSU5UMFBFTkQpOworCV9fcmF3X3dyaXRlbCgodTMyKWRhdGEtPmNoaXBfZGF0YSwgUzNDNjRYWF9FSU5UMFBFTkQpOwogfQogCi1zdGF0aWMgdm9pZCBzM2NfaXJxX2VpbnRfbWFza2Fjayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgczNjX2lycV9laW50X21hc2thY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewogCS8qIGNvbXBpbGVyIHNob3VsZCBpbi1saW5lIHRoZXNlICovCi0JczNjX2lycV9laW50X21hc2soaXJxKTsKLQlzM2NfaXJxX2VpbnRfYWNrKGlycSk7CisJczNjX2lycV9laW50X21hc2soZGF0YSk7CisJczNjX2lycV9laW50X2FjayhkYXRhKTsKIH0KIAotc3RhdGljIGludCBzM2NfaXJxX2VpbnRfc2V0X3R5cGUodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IHR5cGUpCitzdGF0aWMgaW50IHMzY19pcnFfZWludF9zZXRfdHlwZShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEsIHVuc2lnbmVkIGludCB0eXBlKQogewotCWludCBvZmZzID0gZWludF9vZmZzZXQoaXJxKTsKKwlpbnQgb2ZmcyA9IGVpbnRfb2Zmc2V0KGRhdGEtPmlycSk7CiAJaW50IHBpbiwgcGluX3ZhbDsKIAlpbnQgc2hpZnQ7CiAJdTMyIGN0cmwsIG1hc2s7CkBAIC0xNDAsMTIgKzE0MCwxMiBAQAogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHMzY19pcnFfZWludCA9IHsKIAkubmFtZQkJPSAiczNjLWVpbnQiLAotCS5tYXNrCQk9IHMzY19pcnFfZWludF9tYXNrLAotCS51bm1hc2sJCT0gczNjX2lycV9laW50X3VubWFzaywKLQkubWFza19hY2sJPSBzM2NfaXJxX2VpbnRfbWFza2FjaywKLQkuYWNrCQk9IHMzY19pcnFfZWludF9hY2ssCi0JLnNldF90eXBlCT0gczNjX2lycV9laW50X3NldF90eXBlLAotCS5zZXRfd2FrZQk9IHMzY19pcnFleHRfd2FrZSwKKwkuaXJxX21hc2sJPSBzM2NfaXJxX2VpbnRfbWFzaywKKwkuaXJxX3VubWFzawk9IHMzY19pcnFfZWludF91bm1hc2ssCisJLmlycV9tYXNrX2Fjawk9IHMzY19pcnFfZWludF9tYXNrYWNrLAorCS5pcnFfYWNrCT0gczNjX2lycV9laW50X2FjaywKKwkuaXJxX3NldF90eXBlCT0gczNjX2lycV9laW50X3NldF90eXBlLAorCS5pcnFfc2V0X3dha2UJPSBzM2NfaXJxZXh0X3dha2UsCiB9OwogCiAvKiBzM2NfaXJxX2RlbXV4X2VpbnQKQEAgLTE5OCw2ICsxOTgsNyBAQAogCiAJZm9yIChpcnEgPSBJUlFfRUlOVCgwKTsgaXJxIDw9IElSUV9FSU5UKDI3KTsgaXJxKyspIHsKIAkJc2V0X2lycV9jaGlwKGlycSwgJnMzY19pcnFfZWludCk7CisJCXNldF9pcnFfY2hpcF9kYXRhKGlycSwgKHZvaWQgKillaW50X2lycV90b19iaXQoaXJxKSk7CiAJCXNldF9pcnFfaGFuZGxlcihpcnEsIGhhbmRsZV9sZXZlbF9pcnEpOwogCQlzZXRfaXJxX2ZsYWdzKGlycSwgSVJRRl9WQUxJRCk7CiAJfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXA2NDQyL2Nsb2NrLmMgYi9hcmNoL2FybS9tYWNoLXM1cDY0NDIvY2xvY2suYwppbmRleCAxNmQ2ZTdlLi5mYmJjN2JlIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cDY0NDIvY2xvY2suYworKysgYi9hcmNoL2FybS9tYWNoLXM1cDY0NDIvY2xvY2suYwpAQCAtMzQwLDcgKzM0MCw3IEBACiAJY2xrX3BjbGtkMS5yYXRlID0gcGNsa2QxOwogfQogCi1zdGF0aWMgc3RydWN0IGNsayBpbml0X2Nsb2Nrc19kaXNhYmxlW10gPSB7CitzdGF0aWMgc3RydWN0IGNsayBpbml0X2Nsb2Nrc19vZmZbXSA9IHsKIAl7CiAJCS5uYW1lCQk9ICJwZG1hIiwKIAkJLmlkCQk9IC0xLApAQCAtNDA4LDIzICs0MDgsMTMgQEAKIAogdm9pZCBfX2luaXQgczVwNjQ0Ml9yZWdpc3Rlcl9jbG9ja3Modm9pZCkKIHsKLQlzdHJ1Y3QgY2xrICpjbGtwdHI7Ci0JaW50IGksIHJldDsKLQogCXMzYzI0eHhfcmVnaXN0ZXJfY2xvY2tzKGNsa3MsIEFSUkFZX1NJWkUoY2xrcykpOwogCiAJczNjX3JlZ2lzdGVyX2Nsa3NyYyhjbGtzcmNzLCBBUlJBWV9TSVpFKGNsa3NyY3MpKTsKIAlzM2NfcmVnaXN0ZXJfY2xvY2tzKGluaXRfY2xvY2tzLCBBUlJBWV9TSVpFKGluaXRfY2xvY2tzKSk7CiAKLQljbGtwdHIgPSBpbml0X2Nsb2Nrc19kaXNhYmxlOwotCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGluaXRfY2xvY2tzX2Rpc2FibGUpOyBpKyssIGNsa3B0cisrKSB7Ci0JCXJldCA9IHMzYzI0eHhfcmVnaXN0ZXJfY2xvY2soY2xrcHRyKTsKLQkJaWYgKHJldCA8IDApIHsKLQkJCXByaW50ayhLRVJOX0VSUiAiRmFpbCB0byByZWdpc3RlciBjbG9jayAlcyAoJWQpXG4iLAotCQkJCQljbGtwdHItPm5hbWUsIHJldCk7Ci0JCX0gZWxzZQotCQkJKGNsa3B0ci0+ZW5hYmxlKShjbGtwdHIsIDApOwotCX0KKwlzM2NfcmVnaXN0ZXJfY2xvY2tzKGluaXRfY2xvY2tzX29mZiwgQVJSQVlfU0laRShpbml0X2Nsb2Nrc19vZmYpKTsKKwlzM2NfZGlzYWJsZV9jbG9ja3MoaW5pdF9jbG9ja3Nfb2ZmLCBBUlJBWV9TSVpFKGluaXRfY2xvY2tzX29mZikpOwogCiAJczNjX3B3bWNsa19pbml0KCk7CiB9CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cDY0NDIvaW5jbHVkZS9tYWNoL21hcC5oIGIvYXJjaC9hcm0vbWFjaC1zNXA2NDQyL2luY2x1ZGUvbWFjaC9tYXAuaAppbmRleCAzMWZiMmU2OC4uMjAzZGQ1YSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXA2NDQyL2luY2x1ZGUvbWFjaC9tYXAuaAorKysgYi9hcmNoL2FybS9tYWNoLXM1cDY0NDIvaW5jbHVkZS9tYWNoL21hcC5oCkBAIC0yOCw2ICsyOCw5IEBACiAjZGVmaW5lIFM1UDY0NDJfUEFfVklDMQkJKDB4RTQxMDAwMDApCiAjZGVmaW5lIFM1UDY0NDJfUEFfVklDMgkJKDB4RTQyMDAwMDApCiAKKyNkZWZpbmUgUzVQNjQ0Ml9QQV9TUk9NQwkoMHhFNzAwMDAwMCkKKyNkZWZpbmUgUzVQX1BBX1NST01DCQlTNVA2NDQyX1BBX1NST01DCisKICNkZWZpbmUgUzVQNjQ0Ml9QQV9NRE1BCQkweEU4MDAwMDAwCiAjZGVmaW5lIFM1UDY0NDJfUEFfUERNQQkJMHhFOTAwMDAwMAogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cDY0NDIvbWFjaC1zbWRrNjQ0Mi5jIGIvYXJjaC9hcm0vbWFjaC1zNXA2NDQyL21hY2gtc21kazY0NDIuYwppbmRleCA4MTlmZDgwLi5lYWY2YjljIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cDY0NDIvbWFjaC1zbWRrNjQ0Mi5jCisrKyBiL2FyY2gvYXJtL21hY2gtczVwNjQ0Mi9tYWNoLXNtZGs2NDQyLmMKQEAgLTEyLDYgKzEyLDcgQEAKICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxsaW51eC9zZXJpYWxfY29yZS5oPgorI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgogCiAjaW5jbHVkZSA8YXNtL21hY2gvYXJjaC5oPgogI2luY2x1ZGUgPGFzbS9tYWNoL21hcC5oPgpAQCAtMjUsNiArMjYsNyBAQAogI2luY2x1ZGUgPHBsYXQvczVwNjQ0Mi5oPgogI2luY2x1ZGUgPHBsYXQvZGV2cy5oPgogI2luY2x1ZGUgPHBsYXQvY3B1Lmg+CisjaW5jbHVkZSA8cGxhdC9paWMuaD4KIAogLyogRm9sbG93aW5nIGFyZSBkZWZhdWx0IHZhbHVlcyBmb3IgVUNPTiwgVUxDT04gYW5kIFVGQ09OIFVBUlQgcmVnaXN0ZXJzICovCiAjZGVmaW5lIFNNREs2NDQyX1VDT05fREVGQVVMVAkoUzNDMjQxMF9VQ09OX1RYSUxFVkVMIHwJXApAQCAtNjUsMTAgKzY3LDE2IEBACiB9OwogCiBzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSAqc21kazY0NDJfZGV2aWNlc1tdIF9faW5pdGRhdGEgPSB7CisJJnMzY19kZXZpY2VfaTJjMCwKKwkmc2Ftc3VuZ19hc29jX2RtYSwKIAkmczVwNjQ0Ml9kZXZpY2VfaWlzMCwKIAkmczNjX2RldmljZV93ZHQsCiB9OwogCitzdGF0aWMgc3RydWN0IGkyY19ib2FyZF9pbmZvIHNtZGs2NDQyX2kyY19kZXZzMFtdIF9faW5pdGRhdGEgPSB7CisJeyBJMkNfQk9BUkRfSU5GTygid204NTgwIiwgMHgxYiksIH0sCit9OworCiBzdGF0aWMgdm9pZCBfX2luaXQgc21kazY0NDJfbWFwX2lvKHZvaWQpCiB7CiAJczVwX2luaXRfaW8oTlVMTCwgMCwgUzVQX1ZBX0NISVBJRCk7CkBAIC03OCw2ICs4Niw5IEBACiAKIHN0YXRpYyB2b2lkIF9faW5pdCBzbWRrNjQ0Ml9tYWNoaW5lX2luaXQodm9pZCkKIHsKKwlzM2NfaTJjMF9zZXRfcGxhdGRhdGEoTlVMTCk7CisJaTJjX3JlZ2lzdGVyX2JvYXJkX2luZm8oMCwgc21kazY0NDJfaTJjX2RldnMwLAorCQkJQVJSQVlfU0laRShzbWRrNjQ0Ml9pMmNfZGV2czApKTsKIAlwbGF0Zm9ybV9hZGRfZGV2aWNlcyhzbWRrNjQ0Ml9kZXZpY2VzLCBBUlJBWV9TSVpFKHNtZGs2NDQyX2RldmljZXMpKTsKIH0KIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXA2NDQyL3NldHVwLWkyYzAuYyBiL2FyY2gvYXJtL21hY2gtczVwNjQ0Mi9zZXR1cC1pMmMwLmMKaW5kZXggNjYyNjk1ZC4uYWFkODU2NSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXA2NDQyL3NldHVwLWkyYzAuYworKysgYi9hcmNoL2FybS9tYWNoLXM1cDY0NDIvc2V0dXAtaTJjMC5jCkBAIC0xNCwxMiArMTQsMTUgQEAKIAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisjaW5jbHVkZSA8bGludXgvZ3Bpby5oPgogCiBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlOyAvKiBkb24ndCBuZWVkIHRoZSBjb250ZW50cyAqLwogCisjaW5jbHVkZSA8cGxhdC9ncGlvLWNmZy5oPgogI2luY2x1ZGUgPHBsYXQvaWljLmg+CiAKIHZvaWQgczNjX2kyYzBfY2ZnX2dwaW8oc3RydWN0IHBsYXRmb3JtX2RldmljZSAqZGV2KQogewotCS8qIFdpbGwgYmUgcG9wdWxhdGVkIGxhdGVyICovCisJczNjX2dwaW9fY2ZnYWxsX3JhbmdlKFM1UDY0NDJfR1BEMSgwKSwgMiwKKwkJCSAgICAgIFMzQ19HUElPX1NGTigyKSwgUzNDX0dQSU9fUFVMTF9VUCk7CiB9CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cDY0eDAvTWFrZWZpbGUgYi9hcmNoL2FybS9tYWNoLXM1cDY0eDAvTWFrZWZpbGUKaW5kZXggMjY1NTgyOS4uYWU2YmY2ZiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL01ha2VmaWxlCisrKyBiL2FyY2gvYXJtL21hY2gtczVwNjR4MC9NYWtlZmlsZQpAQCAtMTIsOSArMTIsOSBAQAogCiAjIENvcmUgc3VwcG9ydCBmb3IgUzVQNjRYMCBzeXN0ZW0KIAotb2JqLSQoQ09ORklHX0FSQ0hfUzVQNjRYMCkJKz0gY3B1Lm8gaW5pdC5vIGNsb2NrLm8gZG1hLm8KK29iai0kKENPTkZJR19BUkNIX1M1UDY0WDApCSs9IGNwdS5vIGluaXQubyBjbG9jay5vIGRtYS5vIGdwaW9saWIubwogb2JqLSQoQ09ORklHX0FSQ0hfUzVQNjRYMCkJKz0gc2V0dXAtaTJjMC5vCi1vYmotJChDT05GSUdfQ1BVX1M1UDY0NDApCSs9IGNsb2NrLXM1cDY0NDAubyBncGlvLm8KK29iai0kKENPTkZJR19DUFVfUzVQNjQ0MCkJKz0gY2xvY2stczVwNjQ0MC5vCiBvYmotJChDT05GSUdfQ1BVX1M1UDY0NTApCSs9IGNsb2NrLXM1cDY0NTAubwogCiAjIG1hY2hpbmUgc3VwcG9ydApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL2Nsb2NrLXM1cDY0NDAuYyBiL2FyY2gvYXJtL21hY2gtczVwNjR4MC9jbG9jay1zNXA2NDQwLmMKaW5kZXggNDA5YzVmYy4uOWYxMmMyZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL2Nsb2NrLXM1cDY0NDAuYworKysgYi9hcmNoL2FybS9tYWNoLXM1cDY0eDAvY2xvY2stczVwNjQ0MC5jCkBAIC0xMzMsNyArMTMzLDcgQEAKICAqIHJlY29tbWVuZGVkIHRvIGtlZXAgdGhlIGZvbGxvd2luZyBjbG9ja3MgZGlzYWJsZWQgdW50aWwgdGhlIGRyaXZlciByZXF1ZXN0cwogICogZm9yIGVuYWJsaW5nIHRoZSBjbG9jay4KICAqLwotc3RhdGljIHN0cnVjdCBjbGsgaW5pdF9jbG9ja3NfZGlzYWJsZVtdID0geworc3RhdGljIHN0cnVjdCBjbGsgaW5pdF9jbG9ja3Nfb2ZmW10gPSB7CiAJewogCQkubmFtZQkJPSAibmFuZCIsCiAJCS5pZAkJPSAtMSwKQEAgLTQxOSw3ICs0MTksNyBAQAogc3RhdGljIHN0cnVjdCBjbGtzcmNfY2xrIGNsa3NyY3NbXSA9IHsKIAl7CiAJCS5jbGsJPSB7Ci0JCQkubmFtZQkJPSAibW1jX2J1cyIsCisJCQkubmFtZQkJPSAic2Nsa19tbWMiLAogCQkJLmlkCQk9IDAsCiAJCQkuY3RybGJpdAk9ICgxIDw8IDI0KSwKIAkJCS5lbmFibGUJCT0gczVwNjR4MF9zY2xrX2N0cmwsCkBAIC00MjksNyArNDI5LDcgQEAKIAkJLnJlZ19kaXYgPSB7IC5yZWcgPSBTNVA2NFgwX0NMS19ESVYxLCAuc2hpZnQgPSAwLCAuc2l6ZSA9IDQgfSwKIAl9LCB7CiAJCS5jbGsJPSB7Ci0JCQkubmFtZQkJPSAibW1jX2J1cyIsCisJCQkubmFtZQkJPSAic2Nsa19tbWMiLAogCQkJLmlkCQk9IDEsCiAJCQkuY3RybGJpdAk9ICgxIDw8IDI1KSwKIAkJCS5lbmFibGUJCT0gczVwNjR4MF9zY2xrX2N0cmwsCkBAIC00MzksNyArNDM5LDcgQEAKIAkJLnJlZ19kaXYgPSB7IC5yZWcgPSBTNVA2NFgwX0NMS19ESVYxLCAuc2hpZnQgPSA0LCAuc2l6ZSA9IDQgfSwKIAl9LCB7CiAJCS5jbGsJPSB7Ci0JCQkubmFtZQkJPSAibW1jX2J1cyIsCisJCQkubmFtZQkJPSAic2Nsa19tbWMiLAogCQkJLmlkCQk9IDIsCiAJCQkuY3RybGJpdAk9ICgxIDw8IDI2KSwKIAkJCS5lbmFibGUJCT0gczVwNjR4MF9zY2xrX2N0cmwsCkBAIC02MDIsOCArNjAyLDYgQEAKIAogdm9pZCBfX2luaXQgczVwNjQ0MF9yZWdpc3Rlcl9jbG9ja3Modm9pZCkKIHsKLQlzdHJ1Y3QgY2xrICpjbGtwOwotCWludCByZXQ7CiAJaW50IHB0cjsKIAogCXMzYzI0eHhfcmVnaXN0ZXJfY2xvY2tzKGNsa3MsIEFSUkFZX1NJWkUoY2xrcykpOwpAQCAtNjE0LDE2ICs2MTIsOCBAQAogCXMzY19yZWdpc3Rlcl9jbGtzcmMoY2xrc3JjcywgQVJSQVlfU0laRShjbGtzcmNzKSk7CiAJczNjX3JlZ2lzdGVyX2Nsb2Nrcyhpbml0X2Nsb2NrcywgQVJSQVlfU0laRShpbml0X2Nsb2NrcykpOwogCi0JY2xrcCA9IGluaXRfY2xvY2tzX2Rpc2FibGU7Ci0JZm9yIChwdHIgPSAwOyBwdHIgPCBBUlJBWV9TSVpFKGluaXRfY2xvY2tzX2Rpc2FibGUpOyBwdHIrKywgY2xrcCsrKSB7Ci0KLQkJcmV0ID0gczNjMjR4eF9yZWdpc3Rlcl9jbG9jayhjbGtwKTsKLQkJaWYgKHJldCA8IDApIHsKLQkJCXByaW50ayhLRVJOX0VSUiAiRmFpbGVkIHRvIHJlZ2lzdGVyIGNsb2NrICVzICglZClcbiIsCi0JCQkgICAgICAgY2xrcC0+bmFtZSwgcmV0KTsKLQkJfQotCQkoY2xrcC0+ZW5hYmxlKShjbGtwLCAwKTsKLQl9CisJczNjX3JlZ2lzdGVyX2Nsb2Nrcyhpbml0X2Nsb2Nrc19vZmYsIEFSUkFZX1NJWkUoaW5pdF9jbG9ja3Nfb2ZmKSk7CisJczNjX2Rpc2FibGVfY2xvY2tzKGluaXRfY2xvY2tzX29mZiwgQVJSQVlfU0laRShpbml0X2Nsb2Nrc19vZmYpKTsKIAogCXMzY19wd21jbGtfaW5pdCgpOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL2Nsb2NrLXM1cDY0NTAuYyBiL2FyY2gvYXJtL21hY2gtczVwNjR4MC9jbG9jay1zNXA2NDUwLmMKaW5kZXggN2ZjNmFiZC4uNGVlYzQ1NyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL2Nsb2NrLXM1cDY0NTAuYworKysgYi9hcmNoL2FybS9tYWNoLXM1cDY0eDAvY2xvY2stczVwNjQ1MC5jCkBAIC0xODEsNyArMTgxLDcgQEAKICAqIHJlY29tbWVuZGVkIHRvIGtlZXAgdGhlIGZvbGxvd2luZyBjbG9ja3MgZGlzYWJsZWQgdW50aWwgdGhlIGRyaXZlciByZXF1ZXN0cwogICogZm9yIGVuYWJsaW5nIHRoZSBjbG9jay4KICAqLwotc3RhdGljIHN0cnVjdCBjbGsgaW5pdF9jbG9ja3NfZGlzYWJsZVtdID0geworc3RhdGljIHN0cnVjdCBjbGsgaW5pdF9jbG9ja3Nfb2ZmW10gPSB7CiAJewogCQkubmFtZQkJPSAidXNiaG9zdCIsCiAJCS5pZAkJPSAtMSwKQEAgLTIzMSw2ICsyMzEsMTIgQEAKIAkJLmVuYWJsZQkJPSBzNXA2NHgwX3BjbGtfY3RybCwKIAkJLmN0cmxiaXQJPSAoMSA8PCA1KSwKIAl9LCB7CisJCS5uYW1lCQk9ICJydGMiLAorCQkuaWQJCT0gLTEsCisJCS5wYXJlbnQJCT0gJmNsa19wY2xrX2xvdy5jbGssCisJCS5lbmFibGUJCT0gczVwNjR4MF9wY2xrX2N0cmwsCisJCS5jdHJsYml0CT0gKDEgPDwgNiksCisJfSwgewogCQkubmFtZQkJPSAiYWRjIiwKIAkJLmlkCQk9IC0xLAogCQkucGFyZW50CQk9ICZjbGtfcGNsa19sb3cuY2xrLApAQCAtMjYxLDYgKzI2NywxOCBAQAogCQkuZW5hYmxlCQk9IHM1cDY0eDBfcGNsa19jdHJsLAogCQkuY3RybGJpdAk9ICgxIDw8IDI2KSwKIAl9LCB7CisJCS5uYW1lCQk9ICJpaXMiLAorCQkuaWQJCT0gMSwKKwkJLnBhcmVudAkJPSAmY2xrX3BjbGtfbG93LmNsaywKKwkJLmVuYWJsZQkJPSBzNXA2NHgwX3BjbGtfY3RybCwKKwkJLmN0cmxiaXQJPSAoMSA8PCAxNSksCisJfSwgeworCQkubmFtZQkJPSAiaWlzIiwKKwkJLmlkCQk9IDIsCisJCS5wYXJlbnQJCT0gJmNsa19wY2xrX2xvdy5jbGssCisJCS5lbmFibGUJCT0gczVwNjR4MF9wY2xrX2N0cmwsCisJCS5jdHJsYml0CT0gKDEgPDwgMTYpLAorCX0sIHsKIAkJLm5hbWUJCT0gImkyYyIsCiAJCS5pZAkJPSAxLAogCQkucGFyZW50CQk9ICZjbGtfcGNsa19sb3cuY2xrLApAQCAtNjMzLDggKzY1MSw2IEBACiAKIHZvaWQgX19pbml0IHM1cDY0NTBfcmVnaXN0ZXJfY2xvY2tzKHZvaWQpCiB7Ci0Jc3RydWN0IGNsayAqY2xrcDsKLQlpbnQgcmV0OwogCWludCBwdHI7CiAKIAlmb3IgKHB0ciA9IDA7IHB0ciA8IEFSUkFZX1NJWkUoc3lzY2xrcyk7IHB0cisrKQpAQCAtNjQzLDE2ICs2NTksOCBAQAogCXMzY19yZWdpc3Rlcl9jbGtzcmMoY2xrc3JjcywgQVJSQVlfU0laRShjbGtzcmNzKSk7CiAJczNjX3JlZ2lzdGVyX2Nsb2Nrcyhpbml0X2Nsb2NrcywgQVJSQVlfU0laRShpbml0X2Nsb2NrcykpOwogCi0JY2xrcCA9IGluaXRfY2xvY2tzX2Rpc2FibGU7Ci0JZm9yIChwdHIgPSAwOyBwdHIgPCBBUlJBWV9TSVpFKGluaXRfY2xvY2tzX2Rpc2FibGUpOyBwdHIrKywgY2xrcCsrKSB7Ci0KLQkJcmV0ID0gczNjMjR4eF9yZWdpc3Rlcl9jbG9jayhjbGtwKTsKLQkJaWYgKHJldCA8IDApIHsKLQkJCXByaW50ayhLRVJOX0VSUiAiRmFpbGVkIHRvIHJlZ2lzdGVyIGNsb2NrICVzICglZClcbiIsCi0JCQkgICAgICAgY2xrcC0+bmFtZSwgcmV0KTsKLQkJfQotCQkoY2xrcC0+ZW5hYmxlKShjbGtwLCAwKTsKLQl9CisJczNjX3JlZ2lzdGVyX2Nsb2Nrcyhpbml0X2Nsb2Nrc19vZmYsIEFSUkFZX1NJWkUoaW5pdF9jbG9ja3Nfb2ZmKSk7CisJczNjX2Rpc2FibGVfY2xvY2tzKGluaXRfY2xvY2tzX29mZiwgQVJSQVlfU0laRShpbml0X2Nsb2Nrc19vZmYpKTsKIAogCXMzY19wd21jbGtfaW5pdCgpOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL2Rldi1hdWRpby5jIGIvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL2Rldi1hdWRpby5jCmluZGV4IDE0Zjg5ZTczLi4zNWYxZjIyIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cDY0eDAvZGV2LWF1ZGlvLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL2Rldi1hdWRpby5jCkBAIC0yNCwxMyArMjQsMTMgQEAKIAlbMV0gPSAic2Nsa19hdWRpbzIiLAogfTsKIAotc3RhdGljIGludCBzNXA2NHgwX2NmZ19pMnMoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3N0YXRpYyBpbnQgczVwNjQ0MF9jZmdfaTJzKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiB7Ci0JLyogY29uZmlndXJlIEdQSU8gZm9yIGkycyBwb3J0ICovCiAJc3dpdGNoIChwZGV2LT5pZCkgewogCWNhc2UgMDoKLQkJczNjX2dwaW9fY2ZncGluX3JhbmdlKFM1UDY0NDBfR1BSKDQpLCA1LCBTM0NfR1BJT19TRk4oNSkpOwotCQlzM2NfZ3Bpb19jZmdwaW5fcmFuZ2UoUzVQNjQ0MF9HUFIoMTMpLCAyLCBTM0NfR1BJT19TRk4oNSkpOworCQlzM2NfZ3Bpb19jZmdwaW5fcmFuZ2UoUzVQNjQ0MF9HUEMoNCksIDIsIFMzQ19HUElPX1NGTig1KSk7CisJCXMzY19ncGlvX2NmZ3BpbihTNVA2NDQwX0dQQyg3KSwgUzNDX0dQSU9fU0ZOKDUpKTsKKwkJczNjX2dwaW9fY2ZncGluX3JhbmdlKFM1UDY0NDBfR1BIKDYpLCA0LCBTM0NfR1BJT19TRk4oNSkpOwogCQlicmVhazsKIAlkZWZhdWx0OgogCQlwcmludGsoS0VSTl9FUlIgIkludmFsaWQgRGV2aWNlICVkXG4iLCBwZGV2LT5pZCk7CkBAIC00MCw4ICs0MCw4IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBzdHJ1Y3QgczNjX2F1ZGlvX3BkYXRhIHM1cDY0eDBfaTJzX3BkYXRhID0gewotCS5jZmdfZ3BpbyA9IHM1cDY0eDBfY2ZnX2kycywKK3N0YXRpYyBzdHJ1Y3QgczNjX2F1ZGlvX3BkYXRhIHM1cDY0NDBfaTJzX3BkYXRhID0geworCS5jZmdfZ3BpbyA9IHM1cDY0NDBfY2ZnX2kycywKIAkudHlwZSA9IHsKIAkJLmkycyA9IHsKIAkJCS5xdWlya3MgPSBRVUlSS19QUklfNkNIQU4sCkBAIC01MCw3ICs1MCw3IEBACiAJfSwKIH07CiAKLXN0YXRpYyBzdHJ1Y3QgcmVzb3VyY2UgczVwNjR4MF9paXMwX3Jlc291cmNlW10gPSB7CitzdGF0aWMgc3RydWN0IHJlc291cmNlIHM1cDY0eDBfaTJzMF9yZXNvdXJjZVtdID0gewogCVswXSA9IHsKIAkJLnN0YXJ0CT0gUzVQNjRYMF9QQV9JMlMsCiAJCS5lbmQJPSBTNVA2NFgwX1BBX0kyUyArIDB4MTAwIC0gMSwKQEAgLTcxLDIwICs3MSwxMTcgQEAKIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgczVwNjQ0MF9kZXZpY2VfaWlzID0gewogCS5uYW1lCQk9ICJzYW1zdW5nLWkycyIsCiAJLmlkCQk9IDAsCi0JLm51bV9yZXNvdXJjZXMJPSBBUlJBWV9TSVpFKHM1cDY0eDBfaWlzMF9yZXNvdXJjZSksCi0JLnJlc291cmNlCT0gczVwNjR4MF9paXMwX3Jlc291cmNlLAorCS5udW1fcmVzb3VyY2VzCT0gQVJSQVlfU0laRShzNXA2NHgwX2kyczBfcmVzb3VyY2UpLAorCS5yZXNvdXJjZQk9IHM1cDY0eDBfaTJzMF9yZXNvdXJjZSwKIAkuZGV2ID0gewotCQkucGxhdGZvcm1fZGF0YSA9ICZzNXA2NHgwX2kyc19wZGF0YSwKKwkJLnBsYXRmb3JtX2RhdGEgPSAmczVwNjQ0MF9pMnNfcGRhdGEsCisJfSwKK307CisKK3N0YXRpYyBpbnQgczVwNjQ1MF9jZmdfaTJzKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3dpdGNoIChwZGV2LT5pZCkgeworCWNhc2UgMDoKKwkJczNjX2dwaW9fY2ZncGluX3JhbmdlKFM1UDY0NTBfR1BSKDQpLCA1LCBTM0NfR1BJT19TRk4oNSkpOworCQlzM2NfZ3Bpb19jZmdwaW5fcmFuZ2UoUzVQNjQ1MF9HUFIoMTMpLCAyLCBTM0NfR1BJT19TRk4oNSkpOworCQlicmVhazsKKwljYXNlIDE6CisJCXMzY19ncGlvX2NmZ3BpbihTNVA2NDQwX0dQQig0KSwgUzNDX0dQSU9fU0ZOKDUpKTsKKwkJczNjX2dwaW9fY2ZncGluX3JhbmdlKFM1UDY0NTBfR1BDKDApLCA0LCBTM0NfR1BJT19TRk4oNSkpOworCQlicmVhazsKKwljYXNlIDI6CisJCXMzY19ncGlvX2NmZ3Bpbl9yYW5nZShTNVA2NDUwX0dQSygwKSwgNSwgUzNDX0dQSU9fU0ZOKDUpKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcHJpbnRrKEtFUk5fRVJSICJJbnZhbGlkIERldmljZSAlZFxuIiwgcGRldi0+aWQpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCBzM2NfYXVkaW9fcGRhdGEgczVwNjQ1MF9pMnMwX3BkYXRhID0geworCS5jZmdfZ3BpbyA9IHM1cDY0NTBfY2ZnX2kycywKKwkudHlwZSA9IHsKKwkJLmkycyA9IHsKKwkJCS5xdWlya3MgPSBRVUlSS19QUklfNkNIQU4sCisJCQkuc3JjX2NsayA9IHJjbGtzcmMsCisJCX0sCiAJfSwKIH07CiAKIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgczVwNjQ1MF9kZXZpY2VfaWlzMCA9IHsKIAkubmFtZQkJPSAic2Ftc3VuZy1pMnMiLAogCS5pZAkJPSAwLAotCS5udW1fcmVzb3VyY2VzCT0gQVJSQVlfU0laRShzNXA2NHgwX2lpczBfcmVzb3VyY2UpLAotCS5yZXNvdXJjZQk9IHM1cDY0eDBfaWlzMF9yZXNvdXJjZSwKKwkubnVtX3Jlc291cmNlcwk9IEFSUkFZX1NJWkUoczVwNjR4MF9pMnMwX3Jlc291cmNlKSwKKwkucmVzb3VyY2UJPSBzNXA2NHgwX2kyczBfcmVzb3VyY2UsCiAJLmRldiA9IHsKLQkJLnBsYXRmb3JtX2RhdGEgPSAmczVwNjR4MF9pMnNfcGRhdGEsCisJCS5wbGF0Zm9ybV9kYXRhID0gJnM1cDY0NTBfaTJzMF9wZGF0YSwKKwl9LAorfTsKKworc3RhdGljIHN0cnVjdCBzM2NfYXVkaW9fcGRhdGEgczVwNjQ1MF9pMnNfcGRhdGEgPSB7CisJLmNmZ19ncGlvID0gczVwNjQ1MF9jZmdfaTJzLAorCS50eXBlID0geworCQkuaTJzID0geworCQkJLnNyY19jbGsgPSByY2xrc3JjLAorCQl9LAorCX0sCit9OworCitzdGF0aWMgc3RydWN0IHJlc291cmNlIHM1cDY0NTBfaTJzMV9yZXNvdXJjZVtdID0geworCVswXSA9IHsKKwkJLnN0YXJ0CT0gUzVQNjQ1MF9QQV9JMlMxLAorCQkuZW5kCT0gUzVQNjQ1MF9QQV9JMlMxICsgMHgxMDAgLSAxLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX01FTSwKKwl9LAorCVsxXSA9IHsKKwkJLnN0YXJ0CT0gRE1BQ0hfSTJTMV9UWCwKKwkJLmVuZAk9IERNQUNIX0kyUzFfVFgsCisJCS5mbGFncwk9IElPUkVTT1VSQ0VfRE1BLAorCX0sCisJWzJdID0geworCQkuc3RhcnQJPSBETUFDSF9JMlMxX1JYLAorCQkuZW5kCT0gRE1BQ0hfSTJTMV9SWCwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9ETUEsCisJfSwKK307CisKK3N0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgczVwNjQ1MF9kZXZpY2VfaWlzMSA9IHsKKwkubmFtZQkJPSAic2Ftc3VuZy1pMnMiLAorCS5pZAkJPSAxLAorCS5udW1fcmVzb3VyY2VzCT0gQVJSQVlfU0laRShzNXA2NDUwX2kyczFfcmVzb3VyY2UpLAorCS5yZXNvdXJjZQk9IHM1cDY0NTBfaTJzMV9yZXNvdXJjZSwKKwkuZGV2ID0geworCQkucGxhdGZvcm1fZGF0YSA9ICZzNXA2NDUwX2kyc19wZGF0YSwKKwl9LAorfTsKKworc3RhdGljIHN0cnVjdCByZXNvdXJjZSBzNXA2NDUwX2kyczJfcmVzb3VyY2VbXSA9IHsKKwlbMF0gPSB7CisJCS5zdGFydAk9IFM1UDY0NTBfUEFfSTJTMiwKKwkJLmVuZAk9IFM1UDY0NTBfUEFfSTJTMiArIDB4MTAwIC0gMSwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9NRU0sCisJfSwKKwlbMV0gPSB7CisJCS5zdGFydAk9IERNQUNIX0kyUzJfVFgsCisJCS5lbmQJPSBETUFDSF9JMlMyX1RYLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX0RNQSwKKwl9LAorCVsyXSA9IHsKKwkJLnN0YXJ0CT0gRE1BQ0hfSTJTMl9SWCwKKwkJLmVuZAk9IERNQUNIX0kyUzJfUlgsCisJCS5mbGFncwk9IElPUkVTT1VSQ0VfRE1BLAorCX0sCit9OworCitzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIHM1cDY0NTBfZGV2aWNlX2lpczIgPSB7CisJLm5hbWUJCT0gInNhbXN1bmctaTJzIiwKKwkuaWQJCT0gMiwKKwkubnVtX3Jlc291cmNlcwk9IEFSUkFZX1NJWkUoczVwNjQ1MF9pMnMyX3Jlc291cmNlKSwKKwkucmVzb3VyY2UJPSBzNXA2NDUwX2kyczJfcmVzb3VyY2UsCisJLmRldiA9IHsKKwkJLnBsYXRmb3JtX2RhdGEgPSAmczVwNjQ1MF9pMnNfcGRhdGEsCiAJfSwKIH07CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczVwNjR4MC9ncGlvLmMgYi9hcmNoL2FybS9tYWNoLXM1cDY0eDAvZ3Bpby5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzOTE1OWRkLi4wMDAwMDAwCi0tLSBhL2FyY2gvYXJtL21hY2gtczVwNjR4MC9ncGlvLmMKKysrIC9kZXYvbnVsbApAQCAtMSwzNDIgKzAsMCBAQAotLyogbGludXgvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL2dwaW8uYwotICoKLSAqIENvcHlyaWdodCAoYykgMjAwOS0yMDEwIFNhbXN1bmcgRWxlY3Ryb25pY3MgQ28uLCBMdGQuCi0gKgkJaHR0cDovL3d3dy5zYW1zdW5nLmNvbQotICoKLSAqIFM1UDY0WDAgLSBHUElPbGliIHN1cHBvcnQKLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKLSAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgotKi8KLQotI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgotI2luY2x1ZGUgPGxpbnV4L2lycS5oPgotI2luY2x1ZGUgPGxpbnV4L2lvLmg+Ci0jaW5jbHVkZSA8bGludXgvZ3Bpby5oPgotCi0jaW5jbHVkZSA8bWFjaC9tYXAuaD4KLSNpbmNsdWRlIDxtYWNoL3JlZ3MtZ3Bpby5oPgotCi0jaW5jbHVkZSA8cGxhdC9ncGlvLWNvcmUuaD4KLSNpbmNsdWRlIDxwbGF0L2dwaW8tY2ZnLmg+Ci0jaW5jbHVkZSA8cGxhdC9ncGlvLWNmZy1oZWxwZXJzLmg+Ci0KLS8qIFRvIGJlIGltcGxlbWVudGVkIFM1UDY0NTAgR1BJTyAqLwotCi0vKgotICogUzVQNjQ0MCBHUElPIGJhbmsgc3VtbWFyeToKLSAqCi0gKiBCYW5rCUdQSU9zCVN0eWxlCVNscENvbglFeHRJbnQgR3JvdXAKLSAqIEEJNgk0Qml0CVllcwkxCi0gKiBCCTcJNEJpdAlZZXMJMQotICogQwk4CTRCaXQJWWVzCTIKLSAqIEYJMgkyQml0CVllcwk0IFsxXQotICogRwk3CTRCaXQJWWVzCTUKLSAqIEgJMTAJNEJpdFsyXQlZZXMJNgotICogSQkxNgkyQml0CVllcwlOb25lCi0gKiBKCTEyCTJCaXQJWWVzCU5vbmUKLSAqIE4JMTYJMkJpdAlObwlJUlFfRUlOVAotICogUAk4CTJCaXQJWWVzCTgKLSAqIFIJMTUJNEJpdFsyXQlZZXMJOAotICoKLSAqIFsxXSBCQU5LRiBwaW5zIDE0LDE1IGRvIG5vdCBmb3JtIHBhcnQgb2YgdGhlIGV4dGVybmFsIGludGVycnVwdCBzb3VyY2VzCi0gKiBbMl0gQkFOSyBoYXMgdHdvIGNvbnRyb2wgcmVnaXN0ZXJzLCBHUHhDT04wIGFuZCBHUHhDT04xCi0gKi8KLQotc3RhdGljIGludCBzNXA2NHgwX2dwaW9saWJfcmJhbmtfNGJpdDJfaW5wdXQoc3RydWN0IGdwaW9fY2hpcCAqY2hpcCwKLQkJCQkJICAgICB1bnNpZ25lZCBpbnQgb2Zmc2V0KQotewotCXN0cnVjdCBzM2NfZ3Bpb19jaGlwICpvdXJjaGlwID0gdG9fczNjX2dwaW8oY2hpcCk7Ci0Jdm9pZCBfX2lvbWVtICpiYXNlID0gb3VyY2hpcC0+YmFzZTsKLQl2b2lkIF9faW9tZW0gKnJlZ2NvbiA9IGJhc2U7Ci0JdW5zaWduZWQgbG9uZyBjb247Ci0JdW5zaWduZWQgbG9uZyBmbGFnczsKLQotCXN3aXRjaCAob2Zmc2V0KSB7Ci0JY2FzZSA2OgotCQlvZmZzZXQgKz0gMTsKLQljYXNlIDA6Ci0JY2FzZSAxOgotCWNhc2UgMjoKLQljYXNlIDM6Ci0JY2FzZSA0OgotCWNhc2UgNToKLQkJcmVnY29uIC09IDQ7Ci0JCWJyZWFrOwotCWRlZmF1bHQ6Ci0JCW9mZnNldCAtPSA3OwotCQlicmVhazsKLQl9Ci0KLQlzM2NfZ3Bpb19sb2NrKG91cmNoaXAsIGZsYWdzKTsKLQotCWNvbiA9IF9fcmF3X3JlYWRsKHJlZ2Nvbik7Ci0JY29uICY9IH4oMHhmIDw8IGNvbl80Yml0X3NoaWZ0KG9mZnNldCkpOwotCV9fcmF3X3dyaXRlbChjb24sIHJlZ2Nvbik7Ci0KLQlzM2NfZ3Bpb191bmxvY2sob3VyY2hpcCwgZmxhZ3MpOwotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBpbnQgczVwNjR4MF9ncGlvbGliX3JiYW5rXzRiaXQyX291dHB1dChzdHJ1Y3QgZ3Bpb19jaGlwICpjaGlwLAotCQkJCQkgICAgICB1bnNpZ25lZCBpbnQgb2Zmc2V0LCBpbnQgdmFsdWUpCi17Ci0Jc3RydWN0IHMzY19ncGlvX2NoaXAgKm91cmNoaXAgPSB0b19zM2NfZ3BpbyhjaGlwKTsKLQl2b2lkIF9faW9tZW0gKmJhc2UgPSBvdXJjaGlwLT5iYXNlOwotCXZvaWQgX19pb21lbSAqcmVnY29uID0gYmFzZTsKLQl1bnNpZ25lZCBsb25nIGNvbjsKLQl1bnNpZ25lZCBsb25nIGRhdDsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwotCXVuc2lnbmVkIGNvbl9vZmZzZXQgID0gb2Zmc2V0OwotCi0Jc3dpdGNoIChjb25fb2Zmc2V0KSB7Ci0JY2FzZSA2OgotCQljb25fb2Zmc2V0ICs9IDE7Ci0JY2FzZSAwOgotCWNhc2UgMToKLQljYXNlIDI6Ci0JY2FzZSAzOgotCWNhc2UgNDoKLQljYXNlIDU6Ci0JCXJlZ2NvbiAtPSA0OwotCQlicmVhazsKLQlkZWZhdWx0OgotCQljb25fb2Zmc2V0IC09IDc7Ci0JCWJyZWFrOwotCX0KLQotCXMzY19ncGlvX2xvY2sob3VyY2hpcCwgZmxhZ3MpOwotCi0JY29uID0gX19yYXdfcmVhZGwocmVnY29uKTsKLQljb24gJj0gfigweGYgPDwgY29uXzRiaXRfc2hpZnQoY29uX29mZnNldCkpOwotCWNvbiB8PSAweDEgPDwgY29uXzRiaXRfc2hpZnQoY29uX29mZnNldCk7Ci0KLQlkYXQgPSBfX3Jhd19yZWFkbChiYXNlICsgR1BJT0RBVF9PRkYpOwotCWlmICh2YWx1ZSkKLQkJZGF0IHw9IDEgPDwgb2Zmc2V0OwotCWVsc2UKLQkJZGF0ICY9IH4oMSA8PCBvZmZzZXQpOwotCi0JX19yYXdfd3JpdGVsKGNvbiwgcmVnY29uKTsKLQlfX3Jhd193cml0ZWwoZGF0LCBiYXNlICsgR1BJT0RBVF9PRkYpOwotCi0JczNjX2dwaW9fdW5sb2NrKG91cmNoaXAsIGZsYWdzKTsKLQotCXJldHVybiAwOwotfQotCi1pbnQgczVwNjR4MF9ncGlvX3NldGNmZ180Yml0X3JiYW5rKHN0cnVjdCBzM2NfZ3Bpb19jaGlwICpjaGlwLAotCQkJCSAgIHVuc2lnbmVkIGludCBvZmYsIHVuc2lnbmVkIGludCBjZmcpCi17Ci0Jdm9pZCBfX2lvbWVtICpyZWcgPSBjaGlwLT5iYXNlOwotCXVuc2lnbmVkIGludCBzaGlmdDsKLQl1MzIgY29uOwotCi0Jc3dpdGNoIChvZmYpIHsKLQljYXNlIDA6Ci0JY2FzZSAxOgotCWNhc2UgMjoKLQljYXNlIDM6Ci0JY2FzZSA0OgotCWNhc2UgNToKLQkJc2hpZnQgPSAob2ZmICYgNykgKiA0OwotCQlyZWcgLT0gNDsKLQkJYnJlYWs7Ci0JY2FzZSA2OgotCQlzaGlmdCA9ICgob2ZmICsgMSkgJiA3KSAqIDQ7Ci0JCXJlZyAtPSA0OwotCWRlZmF1bHQ6Ci0JCXNoaWZ0ID0gKChvZmYgKyAxKSAmIDcpICogNDsKLQkJYnJlYWs7Ci0JfQotCi0JaWYgKHMzY19ncGlvX2lzX2NmZ19zcGVjaWFsKGNmZykpIHsKLQkJY2ZnICY9IDB4ZjsKLQkJY2ZnIDw8PSBzaGlmdDsKLQl9Ci0KLQljb24gPSBfX3Jhd19yZWFkbChyZWcpOwotCWNvbiAmPSB+KDB4ZiA8PCBzaGlmdCk7Ci0JY29uIHw9IGNmZzsKLQlfX3Jhd193cml0ZWwoY29uLCByZWcpOwotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBzdHJ1Y3QgczNjX2dwaW9fY2ZnIHM1cDY0eDBfZ3Bpb19jZmdzW10gPSB7Ci0JewotCQkuY2ZnX2VpbnQJPSAwLAotCX0sIHsKLQkJLmNmZ19laW50CT0gNywKLQl9LCB7Ci0JCS5jZmdfZWludAk9IDMsCi0JCS5zZXRfY29uZmlnCT0gczVwNjR4MF9ncGlvX3NldGNmZ180Yml0X3JiYW5rLAotCX0sIHsKLQkJLmNmZ19laW50CT0gMCwKLQkJLnNldF9jb25maWcJPSBzM2NfZ3Bpb19zZXRjZmdfczNjMjR4eCwKLQkJLmdldF9jb25maWcJPSBzM2NfZ3Bpb19nZXRjZmdfczNjMjR4eCwKLQl9LCB7Ci0JCS5jZmdfZWludAk9IDIsCi0JCS5zZXRfY29uZmlnCT0gczNjX2dwaW9fc2V0Y2ZnX3MzYzI0eHgsCi0JCS5nZXRfY29uZmlnCT0gczNjX2dwaW9fZ2V0Y2ZnX3MzYzI0eHgsCi0JfSwgewotCQkuY2ZnX2VpbnQJPSAzLAotCQkuc2V0X2NvbmZpZwk9IHMzY19ncGlvX3NldGNmZ19zM2MyNHh4LAotCQkuZ2V0X2NvbmZpZwk9IHMzY19ncGlvX2dldGNmZ19zM2MyNHh4LAotCX0sCi19OwotCi1zdGF0aWMgc3RydWN0IHMzY19ncGlvX2NoaXAgczVwNjQ0MF9ncGlvXzRiaXRbXSA9IHsKLQl7Ci0JCS5iYXNlCT0gUzVQNjQ0MF9HUEFfQkFTRSwKLQkJLmNvbmZpZwk9ICZzNXA2NHgwX2dwaW9fY2Znc1sxXSwKLQkJLmNoaXAJPSB7Ci0JCQkuYmFzZQk9IFM1UDY0NDBfR1BBKDApLAotCQkJLm5ncGlvCT0gUzVQNjQ0MF9HUElPX0FfTlIsCi0JCQkubGFiZWwJPSAiR1BBIiwKLQkJfSwKLQl9LCB7Ci0JCS5iYXNlCT0gUzVQNjQ0MF9HUEJfQkFTRSwKLQkJLmNvbmZpZwk9ICZzNXA2NHgwX2dwaW9fY2Znc1sxXSwKLQkJLmNoaXAJPSB7Ci0JCQkuYmFzZQk9IFM1UDY0NDBfR1BCKDApLAotCQkJLm5ncGlvCT0gUzVQNjQ0MF9HUElPX0JfTlIsCi0JCQkubGFiZWwJPSAiR1BCIiwKLQkJfSwKLQl9LCB7Ci0JCS5iYXNlCT0gUzVQNjQ0MF9HUENfQkFTRSwKLQkJLmNvbmZpZwk9ICZzNXA2NHgwX2dwaW9fY2Znc1sxXSwKLQkJLmNoaXAJPSB7Ci0JCQkuYmFzZQk9IFM1UDY0NDBfR1BDKDApLAotCQkJLm5ncGlvCT0gUzVQNjQ0MF9HUElPX0NfTlIsCi0JCQkubGFiZWwJPSAiR1BDIiwKLQkJfSwKLQl9LCB7Ci0JCS5iYXNlCT0gUzVQNjQ0MF9HUEdfQkFTRSwKLQkJLmNvbmZpZwk9ICZzNXA2NHgwX2dwaW9fY2Znc1sxXSwKLQkJLmNoaXAJPSB7Ci0JCQkuYmFzZQk9IFM1UDY0NDBfR1BHKDApLAotCQkJLm5ncGlvCT0gUzVQNjQ0MF9HUElPX0dfTlIsCi0JCQkubGFiZWwJPSAiR1BHIiwKLQkJfSwKLQl9LAotfTsKLQotc3RhdGljIHN0cnVjdCBzM2NfZ3Bpb19jaGlwIHM1cDY0NDBfZ3Bpb180Yml0MltdID0gewotCXsKLQkJLmJhc2UJPSBTNVA2NDQwX0dQSF9CQVNFICsgMHg0LAotCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzFdLAotCQkuY2hpcAk9IHsKLQkJCS5iYXNlCT0gUzVQNjQ0MF9HUEgoMCksCi0JCQkubmdwaW8JPSBTNVA2NDQwX0dQSU9fSF9OUiwKLQkJCS5sYWJlbAk9ICJHUEgiLAotCQl9LAotCX0sCi19OwotCi1zdGF0aWMgc3RydWN0IHMzY19ncGlvX2NoaXAgczVwNjQ0MF9ncGlvX3JiYW5rXzRiaXQyW10gPSB7Ci0JewotCQkuYmFzZQk9IFM1UDY0NDBfR1BSX0JBU0UgKyAweDQsCi0JCS5jb25maWcJPSAmczVwNjR4MF9ncGlvX2NmZ3NbMl0sCi0JCS5jaGlwCT0gewotCQkJLmJhc2UJPSBTNVA2NDQwX0dQUigwKSwKLQkJCS5uZ3Bpbwk9IFM1UDY0NDBfR1BJT19SX05SLAotCQkJLmxhYmVsCT0gIkdQUiIsCi0JCX0sCi0JfSwKLX07Ci0KLXN0YXRpYyBzdHJ1Y3QgczNjX2dwaW9fY2hpcCBzNXA2NDQwX2dwaW9fMmJpdFtdID0gewotCXsKLQkJLmJhc2UJPSBTNVA2NDQwX0dQRl9CQVNFLAotCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzVdLAotCQkuY2hpcAk9IHsKLQkJCS5iYXNlCT0gUzVQNjQ0MF9HUEYoMCksCi0JCQkubmdwaW8JPSBTNVA2NDQwX0dQSU9fRl9OUiwKLQkJCS5sYWJlbAk9ICJHUEYiLAotCQl9LAotCX0sIHsKLQkJLmJhc2UJPSBTNVA2NDQwX0dQSV9CQVNFLAotCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzNdLAotCQkuY2hpcAk9IHsKLQkJCS5iYXNlCT0gUzVQNjQ0MF9HUEkoMCksCi0JCQkubmdwaW8JPSBTNVA2NDQwX0dQSU9fSV9OUiwKLQkJCS5sYWJlbAk9ICJHUEkiLAotCQl9LAotCX0sIHsKLQkJLmJhc2UJPSBTNVA2NDQwX0dQSl9CQVNFLAotCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzNdLAotCQkuY2hpcAk9IHsKLQkJCS5iYXNlCT0gUzVQNjQ0MF9HUEooMCksCi0JCQkubmdwaW8JPSBTNVA2NDQwX0dQSU9fSl9OUiwKLQkJCS5sYWJlbAk9ICJHUEoiLAotCQl9LAotCX0sIHsKLQkJLmJhc2UJPSBTNVA2NDQwX0dQTl9CQVNFLAotCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzRdLAotCQkuY2hpcAk9IHsKLQkJCS5iYXNlCT0gUzVQNjQ0MF9HUE4oMCksCi0JCQkubmdwaW8JPSBTNVA2NDQwX0dQSU9fTl9OUiwKLQkJCS5sYWJlbAk9ICJHUE4iLAotCQl9LAotCX0sIHsKLQkJLmJhc2UJPSBTNVA2NDQwX0dQUF9CQVNFLAotCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzVdLAotCQkuY2hpcAk9IHsKLQkJCS5iYXNlCT0gUzVQNjQ0MF9HUFAoMCksCi0JCQkubmdwaW8JPSBTNVA2NDQwX0dQSU9fUF9OUiwKLQkJCS5sYWJlbAk9ICJHUFAiLAotCQl9LAotCX0sCi19OwotCi12b2lkIF9faW5pdCBzNXA2NHgwX2dwaW9saWJfc2V0X2NmZyhzdHJ1Y3QgczNjX2dwaW9fY2ZnICpjaGlwY2ZnLCBpbnQgbnJfY2hpcHMpCi17Ci0JZm9yICg7IG5yX2NoaXBzID4gMDsgbnJfY2hpcHMtLSwgY2hpcGNmZysrKSB7Ci0JCWlmICghY2hpcGNmZy0+c2V0X2NvbmZpZykKLQkJCWNoaXBjZmctPnNldF9jb25maWcJPSBzM2NfZ3Bpb19zZXRjZmdfczNjNjR4eF80Yml0OwotCQlpZiAoIWNoaXBjZmctPmdldF9jb25maWcpCi0JCQljaGlwY2ZnLT5nZXRfY29uZmlnCT0gczNjX2dwaW9fZ2V0Y2ZnX3MzYzY0eHhfNGJpdDsKLQkJaWYgKCFjaGlwY2ZnLT5zZXRfcHVsbCkKLQkJCWNoaXBjZmctPnNldF9wdWxsCT0gczNjX2dwaW9fc2V0cHVsbF91cGRvd247Ci0JCWlmICghY2hpcGNmZy0+Z2V0X3B1bGwpCi0JCQljaGlwY2ZnLT5nZXRfcHVsbAk9IHMzY19ncGlvX2dldHB1bGxfdXBkb3duOwotCX0KLX0KLQotc3RhdGljIHZvaWQgX19pbml0IHM1cDY0eDBfZ3Bpb19hZGRfcmJhbmtfNGJpdDIoc3RydWN0IHMzY19ncGlvX2NoaXAgKmNoaXAsCi0JCQkJCQlpbnQgbnJfY2hpcHMpCi17Ci0JZm9yICg7IG5yX2NoaXBzID4gMDsgbnJfY2hpcHMtLSwgY2hpcCsrKSB7Ci0JCWNoaXAtPmNoaXAuZGlyZWN0aW9uX2lucHV0ID0gczVwNjR4MF9ncGlvbGliX3JiYW5rXzRiaXQyX2lucHV0OwotCQljaGlwLT5jaGlwLmRpcmVjdGlvbl9vdXRwdXQgPQotCQkJCQlzNXA2NHgwX2dwaW9saWJfcmJhbmtfNGJpdDJfb3V0cHV0OwotCQlzM2NfZ3Bpb2xpYl9hZGQoY2hpcCk7Ci0JfQotfQotCi1zdGF0aWMgaW50IF9faW5pdCBzNXA2NDQwX2dwaW9saWJfaW5pdCh2b2lkKQotewotCXN0cnVjdCBzM2NfZ3Bpb19jaGlwICpjaGlwcyA9IHM1cDY0NDBfZ3Bpb18yYml0OwotCWludCBucl9jaGlwcyA9IEFSUkFZX1NJWkUoczVwNjQ0MF9ncGlvXzJiaXQpOwotCi0JczVwNjR4MF9ncGlvbGliX3NldF9jZmcoczVwNjR4MF9ncGlvX2NmZ3MsCi0JCQkJQVJSQVlfU0laRShzNXA2NHgwX2dwaW9fY2ZncykpOwotCi0JZm9yICg7IG5yX2NoaXBzID4gMDsgbnJfY2hpcHMtLSwgY2hpcHMrKykKLQkJczNjX2dwaW9saWJfYWRkKGNoaXBzKTsKLQotCXNhbXN1bmdfZ3Bpb2xpYl9hZGRfNGJpdF9jaGlwcyhzNXA2NDQwX2dwaW9fNGJpdCwKLQkJCQlBUlJBWV9TSVpFKHM1cDY0NDBfZ3Bpb180Yml0KSk7Ci0KLQlzYW1zdW5nX2dwaW9saWJfYWRkXzRiaXQyX2NoaXBzKHM1cDY0NDBfZ3Bpb180Yml0MiwKLQkJCQlBUlJBWV9TSVpFKHM1cDY0NDBfZ3Bpb180Yml0MikpOwotCi0JczVwNjR4MF9ncGlvX2FkZF9yYmFua180Yml0MihzNXA2NDQwX2dwaW9fcmJhbmtfNGJpdDIsCi0JCQkJQVJSQVlfU0laRShzNXA2NDQwX2dwaW9fcmJhbmtfNGJpdDIpKTsKLQotCXJldHVybiAwOwotfQotYXJjaF9pbml0Y2FsbChzNXA2NDQwX2dwaW9saWJfaW5pdCk7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cDY0eDAvZ3Bpb2xpYi5jIGIvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL2dwaW9saWIuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lN2ZiM2IwCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL2dwaW9saWIuYwpAQCAtMCwwICsxLDUxMSBAQAorLyogbGludXgvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL2dwaW9saWIuYworICoKKyAqIENvcHlyaWdodCAoYykgMjAwOS0yMDEwIFNhbXN1bmcgRWxlY3Ryb25pY3MgQ28uLCBMdGQuCisgKgkJaHR0cDovL3d3dy5zYW1zdW5nLmNvbQorICoKKyAqIFM1UDY0WDAgLSBHUElPbGliIHN1cHBvcnQKKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorKi8KKworI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2lycS5oPgorI2luY2x1ZGUgPGxpbnV4L2lvLmg+CisjaW5jbHVkZSA8bGludXgvZ3Bpby5oPgorCisjaW5jbHVkZSA8bWFjaC9tYXAuaD4KKyNpbmNsdWRlIDxtYWNoL3JlZ3MtZ3Bpby5oPgorI2luY2x1ZGUgPG1hY2gvcmVncy1jbG9jay5oPgorCisjaW5jbHVkZSA8cGxhdC9ncGlvLWNvcmUuaD4KKyNpbmNsdWRlIDxwbGF0L2dwaW8tY2ZnLmg+CisjaW5jbHVkZSA8cGxhdC9ncGlvLWNmZy1oZWxwZXJzLmg+CisKKy8qCisgKiBTNVA2NDQwIEdQSU8gYmFuayBzdW1tYXJ5OgorICoKKyAqIEJhbmsJR1BJT3MJU3R5bGUJU2xwQ29uCUV4dEludCBHcm91cAorICogQQk2CTRCaXQJWWVzCTEKKyAqIEIJNwk0Qml0CVllcwkxCisgKiBDCTgJNEJpdAlZZXMJMgorICogRgkyCTJCaXQJWWVzCTQgWzFdCisgKiBHCTcJNEJpdAlZZXMJNQorICogSAkxMAk0Qml0WzJdCVllcwk2CisgKiBJCTE2CTJCaXQJWWVzCU5vbmUKKyAqIEoJMTIJMkJpdAlZZXMJTm9uZQorICogTgkxNgkyQml0CU5vCUlSUV9FSU5UCisgKiBQCTgJMkJpdAlZZXMJOAorICogUgkxNQk0Qml0WzJdCVllcwk4CisgKgorICogUzVQNjQ1MCBHUElPIGJhbmsgc3VtbWFyeToKKyAqCisgKiBCYW5rCUdQSU9zCVN0eWxlCVNscENvbglFeHRJbnQgR3JvdXAKKyAqIEEJNgk0Qml0CVllcwkxCisgKiBCCTcJNEJpdAlZZXMJMQorICogQwk4CTRCaXQJWWVzCTIKKyAqIEQJOAk0Qml0CVllcwlOb25lCisgKiBGCTIJMkJpdAlZZXMJTm9uZQorICogRwkxNAk0Qml0WzJdCVllcwk1CisgKiBICTEwCTRCaXRbMl0JWWVzCTYKKyAqIEkJMTYJMkJpdAlZZXMJTm9uZQorICogSgkxMgkyQml0CVllcwlOb25lCisgKiBLCTUJNEJpdAlZZXMJTm9uZQorICogTgkxNgkyQml0CU5vCUlSUV9FSU5UCisgKiBQCTExCTJCaXQJWWVzCTgKKyAqIFEJMTQJMkJpdAlZZXMJTm9uZQorICogUgkxNQk0Qml0WzJdCVllcwlOb25lCisgKiBTCTgJMkJpdAlZZXMJTm9uZQorICoKKyAqIFsxXSBCQU5LRiBwaW5zIDE0LDE1IGRvIG5vdCBmb3JtIHBhcnQgb2YgdGhlIGV4dGVybmFsIGludGVycnVwdCBzb3VyY2VzCisgKiBbMl0gQkFOSyBoYXMgdHdvIGNvbnRyb2wgcmVnaXN0ZXJzLCBHUHhDT04wIGFuZCBHUHhDT04xCisgKi8KKworc3RhdGljIGludCBzNXA2NHgwX2dwaW9saWJfcmJhbmtfNGJpdDJfaW5wdXQoc3RydWN0IGdwaW9fY2hpcCAqY2hpcCwKKwkJCQkJICAgICB1bnNpZ25lZCBpbnQgb2Zmc2V0KQoreworCXN0cnVjdCBzM2NfZ3Bpb19jaGlwICpvdXJjaGlwID0gdG9fczNjX2dwaW8oY2hpcCk7CisJdm9pZCBfX2lvbWVtICpiYXNlID0gb3VyY2hpcC0+YmFzZTsKKwl2b2lkIF9faW9tZW0gKnJlZ2NvbiA9IGJhc2U7CisJdW5zaWduZWQgbG9uZyBjb247CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCXN3aXRjaCAob2Zmc2V0KSB7CisJY2FzZSA2OgorCQlvZmZzZXQgKz0gMTsKKwljYXNlIDA6CisJY2FzZSAxOgorCWNhc2UgMjoKKwljYXNlIDM6CisJY2FzZSA0OgorCWNhc2UgNToKKwkJcmVnY29uIC09IDQ7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCW9mZnNldCAtPSA3OworCQlicmVhazsKKwl9CisKKwlzM2NfZ3Bpb19sb2NrKG91cmNoaXAsIGZsYWdzKTsKKworCWNvbiA9IF9fcmF3X3JlYWRsKHJlZ2Nvbik7CisJY29uICY9IH4oMHhmIDw8IGNvbl80Yml0X3NoaWZ0KG9mZnNldCkpOworCV9fcmF3X3dyaXRlbChjb24sIHJlZ2Nvbik7CisKKwlzM2NfZ3Bpb191bmxvY2sob3VyY2hpcCwgZmxhZ3MpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgczVwNjR4MF9ncGlvbGliX3JiYW5rXzRiaXQyX291dHB1dChzdHJ1Y3QgZ3Bpb19jaGlwICpjaGlwLAorCQkJCQkgICAgICB1bnNpZ25lZCBpbnQgb2Zmc2V0LCBpbnQgdmFsdWUpCit7CisJc3RydWN0IHMzY19ncGlvX2NoaXAgKm91cmNoaXAgPSB0b19zM2NfZ3BpbyhjaGlwKTsKKwl2b2lkIF9faW9tZW0gKmJhc2UgPSBvdXJjaGlwLT5iYXNlOworCXZvaWQgX19pb21lbSAqcmVnY29uID0gYmFzZTsKKwl1bnNpZ25lZCBsb25nIGNvbjsKKwl1bnNpZ25lZCBsb25nIGRhdDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXVuc2lnbmVkIGNvbl9vZmZzZXQgID0gb2Zmc2V0OworCisJc3dpdGNoIChjb25fb2Zmc2V0KSB7CisJY2FzZSA2OgorCQljb25fb2Zmc2V0ICs9IDE7CisJY2FzZSAwOgorCWNhc2UgMToKKwljYXNlIDI6CisJY2FzZSAzOgorCWNhc2UgNDoKKwljYXNlIDU6CisJCXJlZ2NvbiAtPSA0OworCQlicmVhazsKKwlkZWZhdWx0OgorCQljb25fb2Zmc2V0IC09IDc7CisJCWJyZWFrOworCX0KKworCXMzY19ncGlvX2xvY2sob3VyY2hpcCwgZmxhZ3MpOworCisJY29uID0gX19yYXdfcmVhZGwocmVnY29uKTsKKwljb24gJj0gfigweGYgPDwgY29uXzRiaXRfc2hpZnQoY29uX29mZnNldCkpOworCWNvbiB8PSAweDEgPDwgY29uXzRiaXRfc2hpZnQoY29uX29mZnNldCk7CisKKwlkYXQgPSBfX3Jhd19yZWFkbChiYXNlICsgR1BJT0RBVF9PRkYpOworCWlmICh2YWx1ZSkKKwkJZGF0IHw9IDEgPDwgb2Zmc2V0OworCWVsc2UKKwkJZGF0ICY9IH4oMSA8PCBvZmZzZXQpOworCisJX19yYXdfd3JpdGVsKGNvbiwgcmVnY29uKTsKKwlfX3Jhd193cml0ZWwoZGF0LCBiYXNlICsgR1BJT0RBVF9PRkYpOworCisJczNjX2dwaW9fdW5sb2NrKG91cmNoaXAsIGZsYWdzKTsKKworCXJldHVybiAwOworfQorCitpbnQgczVwNjR4MF9ncGlvX3NldGNmZ180Yml0X3JiYW5rKHN0cnVjdCBzM2NfZ3Bpb19jaGlwICpjaGlwLAorCQkJCSAgIHVuc2lnbmVkIGludCBvZmYsIHVuc2lnbmVkIGludCBjZmcpCit7CisJdm9pZCBfX2lvbWVtICpyZWcgPSBjaGlwLT5iYXNlOworCXVuc2lnbmVkIGludCBzaGlmdDsKKwl1MzIgY29uOworCisJc3dpdGNoIChvZmYpIHsKKwljYXNlIDA6CisJY2FzZSAxOgorCWNhc2UgMjoKKwljYXNlIDM6CisJY2FzZSA0OgorCWNhc2UgNToKKwkJc2hpZnQgPSAob2ZmICYgNykgKiA0OworCQlyZWcgLT0gNDsKKwkJYnJlYWs7CisJY2FzZSA2OgorCQlzaGlmdCA9ICgob2ZmICsgMSkgJiA3KSAqIDQ7CisJCXJlZyAtPSA0OworCWRlZmF1bHQ6CisJCXNoaWZ0ID0gKChvZmYgKyAxKSAmIDcpICogNDsKKwkJYnJlYWs7CisJfQorCisJaWYgKHMzY19ncGlvX2lzX2NmZ19zcGVjaWFsKGNmZykpIHsKKwkJY2ZnICY9IDB4ZjsKKwkJY2ZnIDw8PSBzaGlmdDsKKwl9CisKKwljb24gPSBfX3Jhd19yZWFkbChyZWcpOworCWNvbiAmPSB+KDB4ZiA8PCBzaGlmdCk7CisJY29uIHw9IGNmZzsKKwlfX3Jhd193cml0ZWwoY29uLCByZWcpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgczNjX2dwaW9fY2ZnIHM1cDY0eDBfZ3Bpb19jZmdzW10gPSB7CisJeworCQkuY2ZnX2VpbnQJPSAwLAorCX0sIHsKKwkJLmNmZ19laW50CT0gNywKKwl9LCB7CisJCS5jZmdfZWludAk9IDMsCisJCS5zZXRfY29uZmlnCT0gczVwNjR4MF9ncGlvX3NldGNmZ180Yml0X3JiYW5rLAorCX0sIHsKKwkJLmNmZ19laW50CT0gMCwKKwkJLnNldF9jb25maWcJPSBzM2NfZ3Bpb19zZXRjZmdfczNjMjR4eCwKKwkJLmdldF9jb25maWcJPSBzM2NfZ3Bpb19nZXRjZmdfczNjMjR4eCwKKwl9LCB7CisJCS5jZmdfZWludAk9IDIsCisJCS5zZXRfY29uZmlnCT0gczNjX2dwaW9fc2V0Y2ZnX3MzYzI0eHgsCisJCS5nZXRfY29uZmlnCT0gczNjX2dwaW9fZ2V0Y2ZnX3MzYzI0eHgsCisJfSwgeworCQkuY2ZnX2VpbnQJPSAzLAorCQkuc2V0X2NvbmZpZwk9IHMzY19ncGlvX3NldGNmZ19zM2MyNHh4LAorCQkuZ2V0X2NvbmZpZwk9IHMzY19ncGlvX2dldGNmZ19zM2MyNHh4LAorCX0sCit9OworCitzdGF0aWMgc3RydWN0IHMzY19ncGlvX2NoaXAgczVwNjQ0MF9ncGlvXzRiaXRbXSA9IHsKKwl7CisJCS5iYXNlCT0gUzVQNjRYMF9HUEFfQkFTRSwKKwkJLmNvbmZpZwk9ICZzNXA2NHgwX2dwaW9fY2Znc1sxXSwKKwkJLmNoaXAJPSB7CisJCQkuYmFzZQk9IFM1UDY0NDBfR1BBKDApLAorCQkJLm5ncGlvCT0gUzVQNjQ0MF9HUElPX0FfTlIsCisJCQkubGFiZWwJPSAiR1BBIiwKKwkJfSwKKwl9LCB7CisJCS5iYXNlCT0gUzVQNjRYMF9HUEJfQkFTRSwKKwkJLmNvbmZpZwk9ICZzNXA2NHgwX2dwaW9fY2Znc1sxXSwKKwkJLmNoaXAJPSB7CisJCQkuYmFzZQk9IFM1UDY0NDBfR1BCKDApLAorCQkJLm5ncGlvCT0gUzVQNjQ0MF9HUElPX0JfTlIsCisJCQkubGFiZWwJPSAiR1BCIiwKKwkJfSwKKwl9LCB7CisJCS5iYXNlCT0gUzVQNjRYMF9HUENfQkFTRSwKKwkJLmNvbmZpZwk9ICZzNXA2NHgwX2dwaW9fY2Znc1sxXSwKKwkJLmNoaXAJPSB7CisJCQkuYmFzZQk9IFM1UDY0NDBfR1BDKDApLAorCQkJLm5ncGlvCT0gUzVQNjQ0MF9HUElPX0NfTlIsCisJCQkubGFiZWwJPSAiR1BDIiwKKwkJfSwKKwl9LCB7CisJCS5iYXNlCT0gUzVQNjRYMF9HUEdfQkFTRSwKKwkJLmNvbmZpZwk9ICZzNXA2NHgwX2dwaW9fY2Znc1sxXSwKKwkJLmNoaXAJPSB7CisJCQkuYmFzZQk9IFM1UDY0NDBfR1BHKDApLAorCQkJLm5ncGlvCT0gUzVQNjQ0MF9HUElPX0dfTlIsCisJCQkubGFiZWwJPSAiR1BHIiwKKwkJfSwKKwl9LAorfTsKKworc3RhdGljIHN0cnVjdCBzM2NfZ3Bpb19jaGlwIHM1cDY0NDBfZ3Bpb180Yml0MltdID0geworCXsKKwkJLmJhc2UJPSBTNVA2NFgwX0dQSF9CQVNFICsgMHg0LAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzFdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ0MF9HUEgoMCksCisJCQkubmdwaW8JPSBTNVA2NDQwX0dQSU9fSF9OUiwKKwkJCS5sYWJlbAk9ICJHUEgiLAorCQl9LAorCX0sCit9OworCitzdGF0aWMgc3RydWN0IHMzY19ncGlvX2NoaXAgczVwNjQ0MF9ncGlvX3JiYW5rXzRiaXQyW10gPSB7CisJeworCQkuYmFzZQk9IFM1UDY0WDBfR1BSX0JBU0UgKyAweDQsCisJCS5jb25maWcJPSAmczVwNjR4MF9ncGlvX2NmZ3NbMl0sCisJCS5jaGlwCT0geworCQkJLmJhc2UJPSBTNVA2NDQwX0dQUigwKSwKKwkJCS5uZ3Bpbwk9IFM1UDY0NDBfR1BJT19SX05SLAorCQkJLmxhYmVsCT0gIkdQUiIsCisJCX0sCisJfSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgczNjX2dwaW9fY2hpcCBzNXA2NDQwX2dwaW9fMmJpdFtdID0geworCXsKKwkJLmJhc2UJPSBTNVA2NFgwX0dQRl9CQVNFLAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzVdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ0MF9HUEYoMCksCisJCQkubmdwaW8JPSBTNVA2NDQwX0dQSU9fRl9OUiwKKwkJCS5sYWJlbAk9ICJHUEYiLAorCQl9LAorCX0sIHsKKwkJLmJhc2UJPSBTNVA2NFgwX0dQSV9CQVNFLAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzNdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ0MF9HUEkoMCksCisJCQkubmdwaW8JPSBTNVA2NDQwX0dQSU9fSV9OUiwKKwkJCS5sYWJlbAk9ICJHUEkiLAorCQl9LAorCX0sIHsKKwkJLmJhc2UJPSBTNVA2NFgwX0dQSl9CQVNFLAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzNdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ0MF9HUEooMCksCisJCQkubmdwaW8JPSBTNVA2NDQwX0dQSU9fSl9OUiwKKwkJCS5sYWJlbAk9ICJHUEoiLAorCQl9LAorCX0sIHsKKwkJLmJhc2UJPSBTNVA2NFgwX0dQTl9CQVNFLAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzRdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ0MF9HUE4oMCksCisJCQkubmdwaW8JPSBTNVA2NDQwX0dQSU9fTl9OUiwKKwkJCS5sYWJlbAk9ICJHUE4iLAorCQl9LAorCX0sIHsKKwkJLmJhc2UJPSBTNVA2NFgwX0dQUF9CQVNFLAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzVdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ0MF9HUFAoMCksCisJCQkubmdwaW8JPSBTNVA2NDQwX0dQSU9fUF9OUiwKKwkJCS5sYWJlbAk9ICJHUFAiLAorCQl9LAorCX0sCit9OworCitzdGF0aWMgc3RydWN0IHMzY19ncGlvX2NoaXAgczVwNjQ1MF9ncGlvXzRiaXRbXSA9IHsKKwl7CisJCS5iYXNlCT0gUzVQNjRYMF9HUEFfQkFTRSwKKwkJLmNvbmZpZwk9ICZzNXA2NHgwX2dwaW9fY2Znc1sxXSwKKwkJLmNoaXAJPSB7CisJCQkuYmFzZQk9IFM1UDY0NTBfR1BBKDApLAorCQkJLm5ncGlvCT0gUzVQNjQ1MF9HUElPX0FfTlIsCisJCQkubGFiZWwJPSAiR1BBIiwKKwkJfSwKKwl9LCB7CisJCS5iYXNlCT0gUzVQNjRYMF9HUEJfQkFTRSwKKwkJLmNvbmZpZwk9ICZzNXA2NHgwX2dwaW9fY2Znc1sxXSwKKwkJLmNoaXAJPSB7CisJCQkuYmFzZQk9IFM1UDY0NTBfR1BCKDApLAorCQkJLm5ncGlvCT0gUzVQNjQ1MF9HUElPX0JfTlIsCisJCQkubGFiZWwJPSAiR1BCIiwKKwkJfSwKKwl9LCB7CisJCS5iYXNlCT0gUzVQNjRYMF9HUENfQkFTRSwKKwkJLmNvbmZpZwk9ICZzNXA2NHgwX2dwaW9fY2Znc1sxXSwKKwkJLmNoaXAJPSB7CisJCQkuYmFzZQk9IFM1UDY0NTBfR1BDKDApLAorCQkJLm5ncGlvCT0gUzVQNjQ1MF9HUElPX0NfTlIsCisJCQkubGFiZWwJPSAiR1BDIiwKKwkJfSwKKwl9LCB7CisJCS5iYXNlCT0gUzVQNjQ1MF9HUERfQkFTRSwKKwkJLmNvbmZpZwk9ICZzNXA2NHgwX2dwaW9fY2Znc1sxXSwKKwkJLmNoaXAJPSB7CisJCQkuYmFzZQk9IFM1UDY0NTBfR1BEKDApLAorCQkJLm5ncGlvCT0gUzVQNjQ1MF9HUElPX0RfTlIsCisJCQkubGFiZWwJPSAiR1BEIiwKKwkJfSwKKwl9LCB7CisJCS5iYXNlCT0gUzVQNjQ1MF9HUEtfQkFTRSwKKwkJLmNvbmZpZwk9ICZzNXA2NHgwX2dwaW9fY2Znc1sxXSwKKwkJLmNoaXAJPSB7CisJCQkuYmFzZQk9IFM1UDY0NTBfR1BLKDApLAorCQkJLm5ncGlvCT0gUzVQNjQ1MF9HUElPX0tfTlIsCisJCQkubGFiZWwJPSAiR1BLIiwKKwkJfSwKKwl9LAorfTsKKworc3RhdGljIHN0cnVjdCBzM2NfZ3Bpb19jaGlwIHM1cDY0NTBfZ3Bpb180Yml0MltdID0geworCXsKKwkJLmJhc2UJPSBTNVA2NFgwX0dQR19CQVNFICsgMHg0LAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzFdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ1MF9HUEcoMCksCisJCQkubmdwaW8JPSBTNVA2NDUwX0dQSU9fR19OUiwKKwkJCS5sYWJlbAk9ICJHUEciLAorCQl9LAorCX0sIHsKKwkJLmJhc2UJPSBTNVA2NFgwX0dQSF9CQVNFICsgMHg0LAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzFdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ1MF9HUEgoMCksCisJCQkubmdwaW8JPSBTNVA2NDUwX0dQSU9fSF9OUiwKKwkJCS5sYWJlbAk9ICJHUEgiLAorCQl9LAorCX0sCit9OworCitzdGF0aWMgc3RydWN0IHMzY19ncGlvX2NoaXAgczVwNjQ1MF9ncGlvX3JiYW5rXzRiaXQyW10gPSB7CisJeworCQkuYmFzZQk9IFM1UDY0WDBfR1BSX0JBU0UgKyAweDQsCisJCS5jb25maWcJPSAmczVwNjR4MF9ncGlvX2NmZ3NbMl0sCisJCS5jaGlwCT0geworCQkJLmJhc2UJPSBTNVA2NDUwX0dQUigwKSwKKwkJCS5uZ3Bpbwk9IFM1UDY0NTBfR1BJT19SX05SLAorCQkJLmxhYmVsCT0gIkdQUiIsCisJCX0sCisJfSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgczNjX2dwaW9fY2hpcCBzNXA2NDUwX2dwaW9fMmJpdFtdID0geworCXsKKwkJLmJhc2UJPSBTNVA2NFgwX0dQRl9CQVNFLAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzVdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ1MF9HUEYoMCksCisJCQkubmdwaW8JPSBTNVA2NDUwX0dQSU9fRl9OUiwKKwkJCS5sYWJlbAk9ICJHUEYiLAorCQl9LAorCX0sIHsKKwkJLmJhc2UJPSBTNVA2NFgwX0dQSV9CQVNFLAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzNdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ1MF9HUEkoMCksCisJCQkubmdwaW8JPSBTNVA2NDUwX0dQSU9fSV9OUiwKKwkJCS5sYWJlbAk9ICJHUEkiLAorCQl9LAorCX0sIHsKKwkJLmJhc2UJPSBTNVA2NFgwX0dQSl9CQVNFLAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzNdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ1MF9HUEooMCksCisJCQkubmdwaW8JPSBTNVA2NDUwX0dQSU9fSl9OUiwKKwkJCS5sYWJlbAk9ICJHUEoiLAorCQl9LAorCX0sIHsKKwkJLmJhc2UJPSBTNVA2NFgwX0dQTl9CQVNFLAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzRdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ1MF9HUE4oMCksCisJCQkubmdwaW8JPSBTNVA2NDUwX0dQSU9fTl9OUiwKKwkJCS5sYWJlbAk9ICJHUE4iLAorCQl9LAorCX0sIHsKKwkJLmJhc2UJPSBTNVA2NFgwX0dQUF9CQVNFLAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzVdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ1MF9HUFAoMCksCisJCQkubmdwaW8JPSBTNVA2NDUwX0dQSU9fUF9OUiwKKwkJCS5sYWJlbAk9ICJHUFAiLAorCQl9LAorCX0sIHsKKwkJLmJhc2UJPSBTNVA2NDUwX0dQUV9CQVNFLAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzRdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ1MF9HUFEoMCksCisJCQkubmdwaW8JPSBTNVA2NDUwX0dQSU9fUV9OUiwKKwkJCS5sYWJlbAk9ICJHUFEiLAorCQl9LAorCX0sIHsKKwkJLmJhc2UJPSBTNVA2NDUwX0dQU19CQVNFLAorCQkuY29uZmlnCT0gJnM1cDY0eDBfZ3Bpb19jZmdzWzVdLAorCQkuY2hpcAk9IHsKKwkJCS5iYXNlCT0gUzVQNjQ1MF9HUFMoMCksCisJCQkubmdwaW8JPSBTNVA2NDUwX0dQSU9fU19OUiwKKwkJCS5sYWJlbAk9ICJHUFMiLAorCQl9LAorCX0sCit9OworCit2b2lkIF9faW5pdCBzNXA2NHgwX2dwaW9saWJfc2V0X2NmZyhzdHJ1Y3QgczNjX2dwaW9fY2ZnICpjaGlwY2ZnLCBpbnQgbnJfY2hpcHMpCit7CisJZm9yICg7IG5yX2NoaXBzID4gMDsgbnJfY2hpcHMtLSwgY2hpcGNmZysrKSB7CisJCWlmICghY2hpcGNmZy0+c2V0X2NvbmZpZykKKwkJCWNoaXBjZmctPnNldF9jb25maWcJPSBzM2NfZ3Bpb19zZXRjZmdfczNjNjR4eF80Yml0OworCQlpZiAoIWNoaXBjZmctPmdldF9jb25maWcpCisJCQljaGlwY2ZnLT5nZXRfY29uZmlnCT0gczNjX2dwaW9fZ2V0Y2ZnX3MzYzY0eHhfNGJpdDsKKwkJaWYgKCFjaGlwY2ZnLT5zZXRfcHVsbCkKKwkJCWNoaXBjZmctPnNldF9wdWxsCT0gczNjX2dwaW9fc2V0cHVsbF91cGRvd247CisJCWlmICghY2hpcGNmZy0+Z2V0X3B1bGwpCisJCQljaGlwY2ZnLT5nZXRfcHVsbAk9IHMzY19ncGlvX2dldHB1bGxfdXBkb3duOworCX0KK30KKworc3RhdGljIHZvaWQgX19pbml0IHM1cDY0eDBfZ3Bpb19hZGRfcmJhbmtfNGJpdDIoc3RydWN0IHMzY19ncGlvX2NoaXAgKmNoaXAsCisJCQkJCQlpbnQgbnJfY2hpcHMpCit7CisJZm9yICg7IG5yX2NoaXBzID4gMDsgbnJfY2hpcHMtLSwgY2hpcCsrKSB7CisJCWNoaXAtPmNoaXAuZGlyZWN0aW9uX2lucHV0ID0gczVwNjR4MF9ncGlvbGliX3JiYW5rXzRiaXQyX2lucHV0OworCQljaGlwLT5jaGlwLmRpcmVjdGlvbl9vdXRwdXQgPQorCQkJCQlzNXA2NHgwX2dwaW9saWJfcmJhbmtfNGJpdDJfb3V0cHV0OworCQlzM2NfZ3Bpb2xpYl9hZGQoY2hpcCk7CisJfQorfQorCitzdGF0aWMgaW50IF9faW5pdCBzNXA2NHgwX2dwaW9saWJfaW5pdCh2b2lkKQoreworCXVuc2lnbmVkIGludCBjaGlwaWQ7CisKKwljaGlwaWQgPSBfX3Jhd19yZWFkbChTNVA2NFgwX1NZU19JRCk7CisKKwlzNXA2NHgwX2dwaW9saWJfc2V0X2NmZyhzNXA2NHgwX2dwaW9fY2ZncywKKwkJCQlBUlJBWV9TSVpFKHM1cDY0eDBfZ3Bpb19jZmdzKSk7CisKKwlpZiAoKGNoaXBpZCAmIDB4ZmYwMDApID09IDB4NTAwMDApIHsKKwkJc2Ftc3VuZ19ncGlvbGliX2FkZF8yYml0X2NoaXBzKHM1cDY0NTBfZ3Bpb18yYml0LAorCQkJCQlBUlJBWV9TSVpFKHM1cDY0NTBfZ3Bpb18yYml0KSk7CisKKwkJc2Ftc3VuZ19ncGlvbGliX2FkZF80Yml0X2NoaXBzKHM1cDY0NTBfZ3Bpb180Yml0LAorCQkJCQlBUlJBWV9TSVpFKHM1cDY0NTBfZ3Bpb180Yml0KSk7CisKKwkJc2Ftc3VuZ19ncGlvbGliX2FkZF80Yml0Ml9jaGlwcyhzNXA2NDUwX2dwaW9fNGJpdDIsCisJCQkJCUFSUkFZX1NJWkUoczVwNjQ1MF9ncGlvXzRiaXQyKSk7CisKKwkJczVwNjR4MF9ncGlvX2FkZF9yYmFua180Yml0MihzNXA2NDUwX2dwaW9fcmJhbmtfNGJpdDIsCisJCQkJCUFSUkFZX1NJWkUoczVwNjQ1MF9ncGlvX3JiYW5rXzRiaXQyKSk7CisJfSBlbHNlIHsKKwkJc2Ftc3VuZ19ncGlvbGliX2FkZF8yYml0X2NoaXBzKHM1cDY0NDBfZ3Bpb18yYml0LAorCQkJCQlBUlJBWV9TSVpFKHM1cDY0NDBfZ3Bpb18yYml0KSk7CisKKwkJc2Ftc3VuZ19ncGlvbGliX2FkZF80Yml0X2NoaXBzKHM1cDY0NDBfZ3Bpb180Yml0LAorCQkJCQlBUlJBWV9TSVpFKHM1cDY0NDBfZ3Bpb180Yml0KSk7CisKKwkJc2Ftc3VuZ19ncGlvbGliX2FkZF80Yml0Ml9jaGlwcyhzNXA2NDQwX2dwaW9fNGJpdDIsCisJCQkJCUFSUkFZX1NJWkUoczVwNjQ0MF9ncGlvXzRiaXQyKSk7CisKKwkJczVwNjR4MF9ncGlvX2FkZF9yYmFua180Yml0MihzNXA2NDQwX2dwaW9fcmJhbmtfNGJpdDIsCisJCQkJCUFSUkFZX1NJWkUoczVwNjQ0MF9ncGlvX3JiYW5rXzRiaXQyKSk7CisJfQorCisJcmV0dXJuIDA7Cit9Citjb3JlX2luaXRjYWxsKHM1cDY0eDBfZ3Bpb2xpYl9pbml0KTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczVwNjR4MC9pbmNsdWRlL21hY2gvbWFwLmggYi9hcmNoL2FybS9tYWNoLXM1cDY0eDAvaW5jbHVkZS9tYWNoL21hcC5oCmluZGV4IDMxZTUzNDEuLmE5MzY1ZTUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczVwNjR4MC9pbmNsdWRlL21hY2gvbWFwLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL2luY2x1ZGUvbWFjaC9tYXAuaApAQCAtMjksNiArMjksOSBAQAogI2RlZmluZSBTNVA2NFgwX1BBX1ZJQzAJCSgweEU0MDAwMDAwKQogI2RlZmluZSBTNVA2NFgwX1BBX1ZJQzEJCSgweEU0MTAwMDAwKQogCisjZGVmaW5lIFM1UDY0WDBfUEFfU1JPTUMJKDB4RTcwMDAwMDApCisjZGVmaW5lIFM1UF9QQV9TUk9NQwkJUzVQNjRYMF9QQV9TUk9NQworCiAjZGVmaW5lIFM1UDY0WDBfUEFfUERNQQkJKDB4RTkwMDAwMDApCiAKICNkZWZpbmUgUzVQNjRYMF9QQV9USU1FUgkoMHhFQTAwMDAwMCkKQEAgLTYzLDYgKzY2LDggQEAKICNkZWZpbmUgUzVQNjRYMF9QQV9IU01NQyh4KQkoMHhFRDgwMDAwMCArICgoeCkgKiAweDEwMDAwMCkpCiAKICNkZWZpbmUgUzVQNjRYMF9QQV9JMlMJCSgweEYyMDAwMDAwKQorI2RlZmluZSBTNVA2NDUwX1BBX0kyUzEJCTB4RjI4MDAwMDAKKyNkZWZpbmUgUzVQNjQ1MF9QQV9JMlMyCQkweEYyOTAwMDAwCiAKICNkZWZpbmUgUzVQNjRYMF9QQV9QQ00JCSgweEYyMTAwMDAwKQogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cDY0eDAvaW5jbHVkZS9tYWNoL3JlZ3MtZ3Bpby5oIGIvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL2luY2x1ZGUvbWFjaC9yZWdzLWdwaW8uaAppbmRleCA4NWY0NDhlLi4wOTUzZWY2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cDY0eDAvaW5jbHVkZS9tYWNoL3JlZ3MtZ3Bpby5oCisrKyBiL2FyY2gvYXJtL21hY2gtczVwNjR4MC9pbmNsdWRlL21hY2gvcmVncy1ncGlvLmgKQEAgLTE1LDQ4ICsxNSwyMyBAQAogCiAjaW5jbHVkZSA8bWFjaC9tYXAuaD4KIAotLyogV2lsbCBiZSBpbXBsZW1lbnRlZCBTNVA2NDQyIEdQSU9saWIgKi8KLQogLyogQmFzZSBhZGRyZXNzZXMgZm9yIGVhY2ggb2YgdGhlIGJhbmtzICovCiAKLSNkZWZpbmUgUzVQNjQ0MF9HUEFfQkFTRQkJKFM1UF9WQV9HUElPICsgMHgwMDAwKQotI2RlZmluZSBTNVA2NDQwX0dQQl9CQVNFCQkoUzVQX1ZBX0dQSU8gKyAweDAwMjApCi0jZGVmaW5lIFM1UDY0NDBfR1BDX0JBU0UJCShTNVBfVkFfR1BJTyArIDB4MDA0MCkKLSNkZWZpbmUgUzVQNjQ0MF9HUEZfQkFTRQkJKFM1UF9WQV9HUElPICsgMHgwMEEwKQotI2RlZmluZSBTNVA2NDQwX0dQR19CQVNFCQkoUzVQX1ZBX0dQSU8gKyAweDAwQzApCi0jZGVmaW5lIFM1UDY0NDBfR1BIX0JBU0UJCShTNVBfVkFfR1BJTyArIDB4MDBFMCkKLSNkZWZpbmUgUzVQNjQ0MF9HUElfQkFTRQkJKFM1UF9WQV9HUElPICsgMHgwMTAwKQotI2RlZmluZSBTNVA2NDQwX0dQSl9CQVNFCQkoUzVQX1ZBX0dQSU8gKyAweDAxMjApCi0jZGVmaW5lIFM1UDY0NDBfR1BOX0JBU0UJCShTNVBfVkFfR1BJTyArIDB4MDgzMCkKLSNkZWZpbmUgUzVQNjQ0MF9HUFBfQkFTRQkJKFM1UF9WQV9HUElPICsgMHgwMTYwKQotI2RlZmluZSBTNVA2NDQwX0dQUl9CQVNFCQkoUzVQX1ZBX0dQSU8gKyAweDAyOTApCisjZGVmaW5lIFM1UDY0WDBfR1BBX0JBU0UJCShTNVBfVkFfR1BJTyArIDB4MDAwMCkKKyNkZWZpbmUgUzVQNjRYMF9HUEJfQkFTRQkJKFM1UF9WQV9HUElPICsgMHgwMDIwKQorI2RlZmluZSBTNVA2NFgwX0dQQ19CQVNFCQkoUzVQX1ZBX0dQSU8gKyAweDAwNDApCisjZGVmaW5lIFM1UDY0WDBfR1BGX0JBU0UJCShTNVBfVkFfR1BJTyArIDB4MDBBMCkKKyNkZWZpbmUgUzVQNjRYMF9HUEdfQkFTRQkJKFM1UF9WQV9HUElPICsgMHgwMEMwKQorI2RlZmluZSBTNVA2NFgwX0dQSF9CQVNFCQkoUzVQX1ZBX0dQSU8gKyAweDAwRTApCisjZGVmaW5lIFM1UDY0WDBfR1BJX0JBU0UJCShTNVBfVkFfR1BJTyArIDB4MDEwMCkKKyNkZWZpbmUgUzVQNjRYMF9HUEpfQkFTRQkJKFM1UF9WQV9HUElPICsgMHgwMTIwKQorI2RlZmluZSBTNVA2NFgwX0dQTl9CQVNFCQkoUzVQX1ZBX0dQSU8gKyAweDA4MzApCisjZGVmaW5lIFM1UDY0WDBfR1BQX0JBU0UJCShTNVBfVkFfR1BJTyArIDB4MDE2MCkKKyNkZWZpbmUgUzVQNjRYMF9HUFJfQkFTRQkJKFM1UF9WQV9HUElPICsgMHgwMjkwKQogCi0jZGVmaW5lIFM1UDY0NDBfRUlOVDBDT04wCQkoUzVQX1ZBX0dQSU8gKyAweDkwMCkKLSNkZWZpbmUgUzVQNjQ0MF9FSU5UMEZMVENPTjAJCShTNVBfVkFfR1BJTyArIDB4OTEwKQotI2RlZmluZSBTNVA2NDQwX0VJTlQwRkxUQ09OMQkJKFM1UF9WQV9HUElPICsgMHg5MTQpCi0jZGVmaW5lIFM1UDY0NDBfRUlOVDBNQVNLCQkoUzVQX1ZBX0dQSU8gKyAweDkyMCkKLSNkZWZpbmUgUzVQNjQ0MF9FSU5UMFBFTkQJCShTNVBfVkFfR1BJTyArIDB4OTI0KQotCi0vKiBmb3IgTENEICovCi0KLSNkZWZpbmUgUzVQNjQ0MF9TUENPTl9MQ0RfU0VMX1JHQgkoMSA8PCAwKQotI2RlZmluZSBTNVA2NDQwX1NQQ09OX0xDRF9TRUxfTUFTSwkoMyA8PCAwKQotCi0vKgotICogVGhlc2Ugc2V0IG9mIG1hY3JvcyBhcmUgbm90IHJlYWxseSB1c2VmdWwgZm9yIHRoZQotICogR1BGL0dQSS9HUEovR1BOL0dQUCwgdXNlZnVsIGZvciBvdGhlcnMgc2V0IG9mIEdQSU8ncyAoNCBiaXQpCi0gKi8KLQotI2RlZmluZSBTNVA2NDQwX0dQSU9fQ09OTUFTSyhfX2dwaW8pCSgweGYgPDwgKChfX2dwaW8pICogNCkpCi0jZGVmaW5lIFM1UDY0NDBfR1BJT19JTlBVVChfX2dwaW8pCSgweDAgPDwgKChfX2dwaW8pICogNCkpCi0jZGVmaW5lIFM1UDY0NDBfR1BJT19PVVRQVVQoX19ncGlvKQkoMHgxIDw8ICgoX19ncGlvKSAqIDQpKQotCi0vKgotICogVXNlIHRoZXNlIG1hY3JvcyBmb3IgR1BGL0dQSS9HUEovR1BOL0dQUCBzZXQgb2YgR1BJTyAoMiBiaXQpCi0gKi8KLQotI2RlZmluZSBTNVA2NDQwX0dQSU8yX0NPTk1BU0soX19ncGlvKQkoMHgzIDw8ICgoX19ncGlvKSAqIDIpKQotI2RlZmluZSBTNVA2NDQwX0dQSU8yX0lOUFVUKF9fZ3BpbykJKDB4MCA8PCAoKF9fZ3BpbykgKiAyKSkKLSNkZWZpbmUgUzVQNjQ0MF9HUElPMl9PVVRQVVQoX19ncGlvKQkoMHgxIDw8ICgoX19ncGlvKSAqIDIpKQorI2RlZmluZSBTNVA2NDUwX0dQRF9CQVNFCQkoUzVQX1ZBX0dQSU8gKyAweDAwNjApCisjZGVmaW5lIFM1UDY0NTBfR1BLX0JBU0UJCShTNVBfVkFfR1BJTyArIDB4MDE0MCkKKyNkZWZpbmUgUzVQNjQ1MF9HUFFfQkFTRQkJKFM1UF9WQV9HUElPICsgMHgwMTgwKQorI2RlZmluZSBTNVA2NDUwX0dQU19CQVNFCQkoUzVQX1ZBX0dQSU8gKyAweDAzMDApCiAKICNlbmRpZiAvKiBfX0FTTV9BUkNIX1JFR1NfR1BJT19IICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cDY0eDAvbWFjaC1zbWRrNjQ0MC5jIGIvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL21hY2gtc21kazY0NDAuYwppbmRleCA4N2MzZjAzLi5lNWJlYjg0IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cDY0eDAvbWFjaC1zbWRrNjQ0MC5jCisrKyBiL2FyY2gvYXJtL21hY2gtczVwNjR4MC9tYWNoLXNtZGs2NDQwLmMKQEAgLTk1LDYgKzk1LDcgQEAKIAkmczNjX2RldmljZV9pMmMxLAogCSZzM2NfZGV2aWNlX3RzLAogCSZzM2NfZGV2aWNlX3dkdCwKKwkmc2Ftc3VuZ19hc29jX2RtYSwKIAkmczVwNjQ0MF9kZXZpY2VfaWlzLAogfTsKIApAQCAtMTE3LDYgKzExOCw3IEBACiAKIHN0YXRpYyBzdHJ1Y3QgaTJjX2JvYXJkX2luZm8gc21kazY0NDBfaTJjX2RldnMwW10gX19pbml0ZGF0YSA9IHsKIAl7IEkyQ19CT0FSRF9JTkZPKCIyNGMwOCIsIDB4NTApLCB9LAorCXsgSTJDX0JPQVJEX0lORk8oIndtODU4MCIsIDB4MWIpLCB9LAogfTsKIAogc3RhdGljIHN0cnVjdCBpMmNfYm9hcmRfaW5mbyBzbWRrNjQ0MF9pMmNfZGV2czFbXSBfX2luaXRkYXRhID0gewpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL21hY2gtc21kazY0NTAuYyBiL2FyY2gvYXJtL21hY2gtczVwNjR4MC9tYWNoLXNtZGs2NDUwLmMKaW5kZXggZDYwOWY1YS4uM2EyMGRlMCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXA2NHgwL21hY2gtc21kazY0NTAuYworKysgYi9hcmNoL2FybS9tYWNoLXM1cDY0eDAvbWFjaC1zbWRrNjQ1MC5jCkBAIC0xMTMsNiArMTEzLDcgQEAKIAkmczNjX2RldmljZV9pMmMxLAogCSZzM2NfZGV2aWNlX3RzLAogCSZzM2NfZGV2aWNlX3dkdCwKKwkmc2Ftc3VuZ19hc29jX2RtYSwKIAkmczVwNjQ1MF9kZXZpY2VfaWlzMCwKIAkvKiBzNXA2NDUwX2RldmljZV9zcGkwIHdpbGwgYmUgYWRkZWQgKi8KIH07CkBAIC0xMzUsNiArMTM2LDcgQEAKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgaTJjX2JvYXJkX2luZm8gc21kazY0NTBfaTJjX2RldnMwW10gX19pbml0ZGF0YSA9IHsKKwl7IEkyQ19CT0FSRF9JTkZPKCJ3bTg1ODAiLCAweDFiKSwgfSwKIAl7IEkyQ19CT0FSRF9JTkZPKCIyNGMwOCIsIDB4NTApLCB9LAkvKiBTYW1zdW5nIEtTMjRDMDgwQyBFRVBST00gKi8KIH07CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczVwYzEwMC9jbG9jay5jIGIvYXJjaC9hcm0vbWFjaC1zNXBjMTAwL2Nsb2NrLmMKaW5kZXggMmQ0YTc2MS4uMDMwNWU5YiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXBjMTAwL2Nsb2NrLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zNXBjMTAwL2Nsb2NrLmMKQEAgLTM5Niw3ICszOTYsNyBAQAogICogcmVjb21tZW5kZWQgdG8ga2VlcCB0aGUgZm9sbG93aW5nIGNsb2NrcyBkaXNhYmxlZCB1bnRpbCB0aGUgZHJpdmVyIHJlcXVlc3RzCiAgKiBmb3IgZW5hYmxpbmcgdGhlIGNsb2NrLgogICovCi1zdGF0aWMgc3RydWN0IGNsayBpbml0X2Nsb2Nrc19kaXNhYmxlW10gPSB7CitzdGF0aWMgc3RydWN0IGNsayBpbml0X2Nsb2Nrc19vZmZbXSA9IHsKIAl7CiAJCS5uYW1lCQk9ICJjc3N5cyIsCiAJCS5pZAkJPSAtMSwKQEAgLTEzODEsOCArMTM4MSw2IEBACiAKIHZvaWQgX19pbml0IHM1cGMxMDBfcmVnaXN0ZXJfY2xvY2tzKHZvaWQpCiB7Ci0Jc3RydWN0IGNsayAqY2xrcDsKLQlpbnQgcmV0OwogCWludCBwdHI7CiAKIAlzM2MyNHh4X3JlZ2lzdGVyX2Nsb2NrcyhjbGtzLCBBUlJBWV9TSVpFKGNsa3MpKTsKQEAgLTEzOTMsMTYgKzEzOTEsOCBAQAogCXMzY19yZWdpc3Rlcl9jbGtzcmMoY2xrc3JjcywgQVJSQVlfU0laRShjbGtzcmNzKSk7CiAJczNjX3JlZ2lzdGVyX2Nsb2Nrcyhpbml0X2Nsb2NrcywgQVJSQVlfU0laRShpbml0X2Nsb2NrcykpOwogCi0JY2xrcCA9IGluaXRfY2xvY2tzX2Rpc2FibGU7Ci0JZm9yIChwdHIgPSAwOyBwdHIgPCBBUlJBWV9TSVpFKGluaXRfY2xvY2tzX2Rpc2FibGUpOyBwdHIrKywgY2xrcCsrKSB7Ci0KLQkJcmV0ID0gczNjMjR4eF9yZWdpc3Rlcl9jbG9jayhjbGtwKTsKLQkJaWYgKHJldCA8IDApIHsKLQkJCXByaW50ayhLRVJOX0VSUiAiRmFpbGVkIHRvIHJlZ2lzdGVyIGNsb2NrICVzICglZClcbiIsCi0JCQkgICAgICAgY2xrcC0+bmFtZSwgcmV0KTsKLQkJfQotCQkoY2xrcC0+ZW5hYmxlKShjbGtwLCAwKTsKLQl9CisJczNjX3JlZ2lzdGVyX2Nsb2Nrcyhpbml0X2Nsb2Nrc19vZmYsIEFSUkFZX1NJWkUoaW5pdF9jbG9ja3Nfb2ZmKSk7CisJczNjX2Rpc2FibGVfY2xvY2tzKGluaXRfY2xvY2tzX29mZiwgQVJSQVlfU0laRShpbml0X2Nsb2Nrc19vZmYpKTsKIAogCXMzY19wd21jbGtfaW5pdCgpOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXBjMTAwL2luY2x1ZGUvbWFjaC9tYXAuaCBiL2FyY2gvYXJtL21hY2gtczVwYzEwMC9pbmNsdWRlL21hY2gvbWFwLmgKaW5kZXggMzJlOWNhYi4uMzI4NDY3YiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXBjMTAwL2luY2x1ZGUvbWFjaC9tYXAuaAorKysgYi9hcmNoL2FybS9tYWNoLXM1cGMxMDAvaW5jbHVkZS9tYWNoL21hcC5oCkBAIC01NSw2ICs1NSw4IEBACiAjZGVmaW5lIFM1UEMxMDBfVkFfVklDX09GRlNFVAkweDEwMDAwCiAjZGVmaW5lIFM1UEMxWFhfVkFfVklDKHgpCShTNVBDMTAwX1ZBX1ZJQyArICgoeCkgKiBTNVBDMTAwX1ZBX1ZJQ19PRkZTRVQpKQogCisjZGVmaW5lIFM1UEMxMDBfUEFfU1JPTUMJKDB4RTcwMDAwMDApCisjZGVmaW5lIFM1UF9QQV9TUk9NQwkJUzVQQzEwMF9QQV9TUk9NQwogCiAjZGVmaW5lIFM1UEMxMDBfUEFfT05FTkFORAkoMHhFNzEwMDAwMCkKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL0tjb25maWcgYi9hcmNoL2FybS9tYWNoLXM1cHYyMTAvS2NvbmZpZwppbmRleCA4NjJmMjM5Li41M2FhYmVmIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cHYyMTAvS2NvbmZpZworKysgYi9hcmNoL2FybS9tYWNoLXM1cHYyMTAvS2NvbmZpZwpAQCAtMTE4LDYgKzExOCw3IEBACiBjb25maWcgTUFDSF9TTURLVjIxMAogCWJvb2wgIlNNREtWMjEwIgogCXNlbGVjdCBDUFVfUzVQVjIxMAorCXNlbGVjdCBTM0NfREVWX0ZCCiAJc2VsZWN0IFMzQ19ERVZfSFNNTUMKIAlzZWxlY3QgUzNDX0RFVl9IU01NQzEKIAlzZWxlY3QgUzNDX0RFVl9IU01NQzIKQEAgLTEzMCw2ICsxMzEsNyBAQAogCXNlbGVjdCBTQU1TVU5HX0RFVl9JREUKIAlzZWxlY3QgU0FNU1VOR19ERVZfS0VZUEFECiAJc2VsZWN0IFNBTVNVTkdfREVWX1RTCisJc2VsZWN0IFM1UFYyMTBfU0VUVVBfRkJfMjRCUFAKIAlzZWxlY3QgUzVQVjIxMF9TRVRVUF9JMkMxCiAJc2VsZWN0IFM1UFYyMTBfU0VUVVBfSTJDMgogCXNlbGVjdCBTNVBWMjEwX1NFVFVQX0lERQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL2Nsb2NrLmMgYi9hcmNoL2FybS9tYWNoLXM1cHYyMTAvY2xvY2suYwppbmRleCBiNzc0ZmYxLi4yZDU5OTQ5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cHYyMTAvY2xvY2suYworKysgYi9hcmNoL2FybS9tYWNoLXM1cHYyMTAvY2xvY2suYwpAQCAtMzA5LDcgKzMwOSw3IEBACiAJLmdldF9yYXRlCT0gczVwdjIxMF9jbGtfZm91dF9hcGxsX2dldF9yYXRlLAogfTsKIAotc3RhdGljIHN0cnVjdCBjbGsgaW5pdF9jbG9ja3NfZGlzYWJsZVtdID0geworc3RhdGljIHN0cnVjdCBjbGsgaW5pdF9jbG9ja3Nfb2ZmW10gPSB7CiAJewogCQkubmFtZQkJPSAicGRtYSIsCiAJCS5pZAkJPSAwLApAQCAtNTI1LDYgKzUyNSwxMiBAQAogCQkucGFyZW50CQk9ICZjbGtfcGNsa19wc3lzLmNsaywKIAkJLmVuYWJsZQkJPSBzNXB2MjEwX2Nsa19pcDNfY3RybCwKIAkJLmN0cmxiaXQJPSAoMSA8PCAyMCksCisJfSwgeworCQkubmFtZQkJPSAic3JvbWMiLAorCQkuaWQJCT0gLTEsCisJCS5wYXJlbnQJCT0gJmNsa19oY2xrX3BzeXMuY2xrLAorCQkuZW5hYmxlCQk9IHM1cHYyMTBfY2xrX2lwMV9jdHJsLAorCQkuY3RybGJpdAk9ICgxIDw8IDI2KSwKIAl9LAogfTsKIApAQCAtMTIyMCwxMyArMTIyNiw5IEBACiAKIHZvaWQgX19pbml0IHM1cHYyMTBfcmVnaXN0ZXJfY2xvY2tzKHZvaWQpCiB7Ci0Jc3RydWN0IGNsayAqY2xrcDsKLQlpbnQgcmV0OwogCWludCBwdHI7CiAKLQlyZXQgPSBzM2MyNHh4X3JlZ2lzdGVyX2Nsb2NrcyhjbGtzLCBBUlJBWV9TSVpFKGNsa3MpKTsKLQlpZiAocmV0ID4gMCkKLQkJcHJpbnRrKEtFUk5fRVJSICJGYWlsZWQgdG8gcmVnaXN0ZXIgJXUgY2xvY2tzXG4iLCByZXQpOworCXMzYzI0eHhfcmVnaXN0ZXJfY2xvY2tzKGNsa3MsIEFSUkFZX1NJWkUoY2xrcykpOwogCiAJZm9yIChwdHIgPSAwOyBwdHIgPCBBUlJBWV9TSVpFKHN5c2Nsa3MpOyBwdHIrKykKIAkJczNjX3JlZ2lzdGVyX2Nsa3NyYyhzeXNjbGtzW3B0cl0sIDEpOwpAQCAtMTIzNCwxNSArMTIzNiw4IEBACiAJczNjX3JlZ2lzdGVyX2Nsa3NyYyhjbGtzcmNzLCBBUlJBWV9TSVpFKGNsa3NyY3MpKTsKIAlzM2NfcmVnaXN0ZXJfY2xvY2tzKGluaXRfY2xvY2tzLCBBUlJBWV9TSVpFKGluaXRfY2xvY2tzKSk7CiAKLQljbGtwID0gaW5pdF9jbG9ja3NfZGlzYWJsZTsKLQlmb3IgKHB0ciA9IDA7IHB0ciA8IEFSUkFZX1NJWkUoaW5pdF9jbG9ja3NfZGlzYWJsZSk7IHB0cisrLCBjbGtwKyspIHsKLQkJcmV0ID0gczNjMjR4eF9yZWdpc3Rlcl9jbG9jayhjbGtwKTsKLQkJaWYgKHJldCA8IDApIHsKLQkJCXByaW50ayhLRVJOX0VSUiAiRmFpbGVkIHRvIHJlZ2lzdGVyIGNsb2NrICVzICglZClcbiIsCi0JCQkgICAgICAgY2xrcC0+bmFtZSwgcmV0KTsKLQkJfQotCQkoY2xrcC0+ZW5hYmxlKShjbGtwLCAwKTsKLQl9CisJczNjX3JlZ2lzdGVyX2Nsb2Nrcyhpbml0X2Nsb2Nrc19vZmYsIEFSUkFZX1NJWkUoaW5pdF9jbG9ja3Nfb2ZmKSk7CisJczNjX2Rpc2FibGVfY2xvY2tzKGluaXRfY2xvY2tzX29mZiwgQVJSQVlfU0laRShpbml0X2Nsb2Nrc19vZmYpKTsKIAogCXMzY19wd21jbGtfaW5pdCgpOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL2NwdS5jIGIvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL2NwdS5jCmluZGV4IDhlYjQ4MGUuLjYxZTZjMjQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczVwdjIxMC9jcHUuYworKysgYi9hcmNoL2FybS9tYWNoLXM1cHYyMTAvY3B1LmMKQEAgLTgxLDExICs4MSw2IEBACiAJCS5sZW5ndGgJCT0gU1pfNTEySywKIAkJLnR5cGUJCT0gTVRfREVWSUNFLAogCX0sIHsKLQkJLnZpcnR1YWwJPSAodW5zaWduZWQgbG9uZylTNVBfVkFfU1JPTUMsCi0JCS5wZm4JCT0gX19waHlzX3RvX3BmbihTNVBWMjEwX1BBX1NST01DKSwKLQkJLmxlbmd0aAkJPSBTWl80SywKLQkJLnR5cGUJCT0gTVRfREVWSUNFLAotCX0sIHsKIAkJLnZpcnR1YWwJPSAodW5zaWduZWQgbG9uZylTNVBfVkFfRE1DMCwKIAkJLnBmbgkJPSBfX3BoeXNfdG9fcGZuKFM1UFYyMTBfUEFfRE1DMCksCiAJCS5sZW5ndGgJCT0gU1pfNEssCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cHYyMTAvaW5jbHVkZS9tYWNoL2lycXMuaCBiL2FyY2gvYXJtL21hY2gtczVwdjIxMC9pbmNsdWRlL21hY2gvaXJxcy5oCmluZGV4IDExOWI5NWYuLjI2NzEwYjMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczVwdjIxMC9pbmNsdWRlL21hY2gvaXJxcy5oCisrKyBiL2FyY2gvYXJtL21hY2gtczVwdjIxMC9pbmNsdWRlL21hY2gvaXJxcy5oCkBAIC02NSw3ICs2NSw3IEBACiAjZGVmaW5lIElSUV9IU01NQzAJCVM1UF9JUlFfVklDMSgyNikKICNkZWZpbmUgSVJRX0hTTU1DMQkJUzVQX0lSUV9WSUMxKDI3KQogI2RlZmluZSBJUlFfSFNNTUMyCQlTNVBfSVJRX1ZJQzEoMjgpCi0jZGVmaW5lIElSUV9NSVBJQ1NJCQlTNVBfSVJRX1ZJQzEoMjkpCisjZGVmaW5lIElSUV9NSVBJX0NTSVMJCVM1UF9JUlFfVklDMSgyOSkKICNkZWZpbmUgSVJRX01JUElEU0kJCVM1UF9JUlFfVklDMSgzMCkKICNkZWZpbmUgSVJRX09ORU5BTkRfQVVESQlTNVBfSVJRX1ZJQzEoMzEpCiAKQEAgLTEzMiw1ICsxMzIsNiBAQAogI2RlZmluZSBJUlFfTENEX0ZJRk8JCUlSUV9MQ0QwCiAjZGVmaW5lIElSUV9MQ0RfVlNZTkMJCUlSUV9MQ0QxCiAjZGVmaW5lIElSUV9MQ0RfU1lTVEVNCQlJUlFfTENEMgorI2RlZmluZSBJUlFfTUlQSV9DU0lTMAkJSVJRX01JUElfQ1NJUwogCiAjZW5kaWYgLyogQVNNX0FSQ0hfSVJRU19IICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cHYyMTAvaW5jbHVkZS9tYWNoL21hcC5oIGIvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL2luY2x1ZGUvbWFjaC9tYXAuaAppbmRleCA4NjFkN2ZlLi4zNjExNDkyIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cHYyMTAvaW5jbHVkZS9tYWNoL21hcC5oCisrKyBiL2FyY2gvYXJtL21hY2gtczVwdjIxMC9pbmNsdWRlL21hY2gvbWFwLmgKQEAgLTE2LDYgKzE2LDggQEAKICNpbmNsdWRlIDxwbGF0L21hcC1iYXNlLmg+CiAjaW5jbHVkZSA8cGxhdC9tYXAtczVwLmg+CiAKKyNkZWZpbmUgUzVQVjIxMF9QQV9TUk9NX0JBTks1CSgweEE4MDAwMDAwKQorCiAjZGVmaW5lIFM1UEMxMTBfUEFfT05FTkFORAkoMHhCMDAwMDAwMCkKICNkZWZpbmUgUzVQX1BBX09ORU5BTkQJCVM1UEMxMTBfUEFfT05FTkFORAogCkBAIC02MCw2ICs2Miw3IEBACiAjZGVmaW5lIFMzQ19WQV9VQVJUeCh4KQkJKFMzQ19WQV9VQVJUICsgKCh4KSAqIFMzQ19VQVJUX09GRlNFVCkpCiAKICNkZWZpbmUgUzVQVjIxMF9QQV9TUk9NQwkoMHhFODAwMDAwMCkKKyNkZWZpbmUgUzVQX1BBX1NST01DCQlTNVBWMjEwX1BBX1NST01DCiAKICNkZWZpbmUgUzVQVjIxMF9QQV9DRkNPTgkoMHhFODIwMDAwMCkKIApAQCAtMTA3LDYgKzExMCw4IEBACiAjZGVmaW5lIFM1UFYyMTBfUEFfRE1DMAkJKDB4RjAwMDAwMDApCiAjZGVmaW5lIFM1UFYyMTBfUEFfRE1DMQkJKDB4RjE0MDAwMDApCiAKKyNkZWZpbmUgUzVQVjIxMF9QQV9NSVBJX0NTSVMJMHhGQTYwMDAwMAorCiAvKiBjb21wYXRpYmlsdGl5IGRlZmluZXMuICovCiAjZGVmaW5lIFMzQ19QQV9VQVJUCQlTNVBWMjEwX1BBX1VBUlQKICNkZWZpbmUgUzNDX1BBX0hTTU1DMAkJUzVQVjIxMF9QQV9IU01NQygwKQpAQCAtMTIzLDYgKzEyOCw3IEBACiAjZGVmaW5lIFM1UF9QQV9GSU1DMAkJUzVQVjIxMF9QQV9GSU1DMAogI2RlZmluZSBTNVBfUEFfRklNQzEJCVM1UFYyMTBfUEFfRklNQzEKICNkZWZpbmUgUzVQX1BBX0ZJTUMyCQlTNVBWMjEwX1BBX0ZJTUMyCisjZGVmaW5lIFM1UF9QQV9NSVBJX0NTSVMwCVM1UFYyMTBfUEFfTUlQSV9DU0lTCiAKICNkZWZpbmUgU0FNU1VOR19QQV9BREMJCVM1UFYyMTBfUEFfQURDCiAjZGVmaW5lIFNBTVNVTkdfUEFfQ0ZDT04JUzVQVjIxMF9QQV9DRkNPTgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL2luY2x1ZGUvbWFjaC9yZWdzLWNsb2NrLmggYi9hcmNoL2FybS9tYWNoLXM1cHYyMTAvaW5jbHVkZS9tYWNoL3JlZ3MtY2xvY2suaAppbmRleCBlYmFhYmUwLi40YzQ1Yjc0IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cHYyMTAvaW5jbHVkZS9tYWNoL3JlZ3MtY2xvY2suaAorKysgYi9hcmNoL2FybS9tYWNoLXM1cHYyMTAvaW5jbHVkZS9tYWNoL3JlZ3MtY2xvY2suaApAQCAtMTYxLDcgKzE2MSw3IEBACiAjZGVmaW5lIFM1UF9NRE5JRV9TRUwJCVM1UF9DTEtSRUcoMHg3MDA4KQogI2RlZmluZSBTNVBfTUlQSV9QSFlfQ09OMAlTNVBfQ0xLUkVHKDB4NzIwMCkKICNkZWZpbmUgUzVQX01JUElfUEhZX0NPTjEJUzVQX0NMS1JFRygweDcyMDQpCi0jZGVmaW5lIFM1UF9NSVBJX0NPTlRST0wJUzVQX0NMS1JFRygweEU4MTQpCisjZGVmaW5lIFM1UF9NSVBJX0RQSFlfQ09OVFJPTAlTNVBfQ0xLUkVHKDB4RTgxNCkKIAogI2RlZmluZSBTNVBfSURMRV9DRkdfVExfTUFTSwkoMyA8PCAzMCkKICNkZWZpbmUgUzVQX0lETEVfQ0ZHX1RNX01BU0sJKDMgPDwgMjgpCkBAIC0xOTUsOSArMTk1LDYgQEAKICNkZWZpbmUgUzVQX09USEVSU19SRVRfVUFSVAkJKDEgPDwgMjgpCiAjZGVmaW5lIFM1UF9PVEhFUlNfVVNCX1NJR19NQVNLCQkoMSA8PCAxNikKIAotLyogTUlQSSAqLwotI2RlZmluZSBTNVBfTUlQSV9EUEhZX0VOCQkoMykKLQogLyogUzVQX0RBQ19DT05UUk9MICovCiAjZGVmaW5lIFM1UF9EQUNfRU5BQkxFCQkJKDEpCiAjZGVmaW5lIFM1UF9EQUNfRElTQUJMRQkJCSgwKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL21hY2gtc21ka2MxMTAuYyBiL2FyY2gvYXJtL21hY2gtczVwdjIxMC9tYWNoLXNtZGtjMTEwLmMKaW5kZXggNWRkMTY4MS4uY2UxMWEwMiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL21hY2gtc21ka2MxMTAuYworKysgYi9hcmNoL2FybS9tYWNoLXM1cHYyMTAvbWFjaC1zbWRrYzExMC5jCkBAIC04MSw2ICs4MSw3IEBACiB9OwogCiBzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSAqc21ka2MxMTBfZGV2aWNlc1tdIF9faW5pdGRhdGEgPSB7CisJJnNhbXN1bmdfYXNvY19kbWEsCiAJJnM1cHYyMTBfZGV2aWNlX2lpczAsCiAJJnM1cHYyMTBfZGV2aWNlX2FjOTcsCiAJJnM1cHYyMTBfZGV2aWNlX3NwZGlmLApAQCAtOTQsNiArOTUsNyBAQAogCiBzdGF0aWMgc3RydWN0IGkyY19ib2FyZF9pbmZvIHNtZGtjMTEwX2kyY19kZXZzMFtdIF9faW5pdGRhdGEgPSB7CiAJeyBJMkNfQk9BUkRfSU5GTygiMjRjMDgiLCAweDUwKSwgfSwgICAgIC8qIFNhbXN1bmcgUzUyNEFEMFhEMSAqLworCXsgSTJDX0JPQVJEX0lORk8oIndtODU4MCIsIDB4MWIpLCB9LAogfTsKIAogc3RhdGljIHN0cnVjdCBpMmNfYm9hcmRfaW5mbyBzbWRrYzExMF9pMmNfZGV2czFbXSBfX2luaXRkYXRhID0gewpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL21hY2gtc21ka3YyMTAuYyBiL2FyY2gvYXJtL21hY2gtczVwdjIxMC9tYWNoLXNtZGt2MjEwLmMKaW5kZXggMWZiYzQ1Yi4uYmM5ZmRiNSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXB2MjEwL21hY2gtc21ka3YyMTAuYworKysgYi9hcmNoL2FybS9tYWNoLXM1cHYyMTAvbWFjaC1zbWRrdjIxMC5jCkBAIC0xNCwxNiArMTQsMjUgQEAKICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiAjaW5jbHVkZSA8bGludXgvc2VyaWFsX2NvcmUuaD4KICNpbmNsdWRlIDxsaW51eC9zeXNkZXYuaD4KKyNpbmNsdWRlIDxsaW51eC9kbTkwMDAuaD4KKyNpbmNsdWRlIDxsaW51eC9mYi5oPgorI2luY2x1ZGUgPGxpbnV4L2dwaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgogCiAjaW5jbHVkZSA8YXNtL21hY2gvYXJjaC5oPgogI2luY2x1ZGUgPGFzbS9tYWNoL21hcC5oPgogI2luY2x1ZGUgPGFzbS9zZXR1cC5oPgogI2luY2x1ZGUgPGFzbS9tYWNoLXR5cGVzLmg+CiAKKyNpbmNsdWRlIDx2aWRlby9wbGF0Zm9ybV9sY2QuaD4KKwogI2luY2x1ZGUgPG1hY2gvbWFwLmg+CiAjaW5jbHVkZSA8bWFjaC9yZWdzLWNsb2NrLmg+CisjaW5jbHVkZSA8bWFjaC9yZWdzLWZiLmg+CiAKICNpbmNsdWRlIDxwbGF0L3JlZ3Mtc2VyaWFsLmg+CisjaW5jbHVkZSA8cGxhdC9yZWdzLXNyb20uaD4KKyNpbmNsdWRlIDxwbGF0L2dwaW8tY2ZnLmg+CiAjaW5jbHVkZSA8cGxhdC9zNXB2MjEwLmg+CiAjaW5jbHVkZSA8cGxhdC9kZXZzLmg+CiAjaW5jbHVkZSA8cGxhdC9jcHUuaD4KQEAgLTMzLDYgKzQyLDcgQEAKICNpbmNsdWRlIDxwbGF0L2lpYy5oPgogI2luY2x1ZGUgPHBsYXQva2V5cGFkLmg+CiAjaW5jbHVkZSA8cGxhdC9wbS5oPgorI2luY2x1ZGUgPHBsYXQvZmIuaD4KIAogLyogRm9sbG93aW5nIGFyZSBkZWZhdWx0IHZhbHVlcyBmb3IgVUNPTiwgVUxDT04gYW5kIFVGQ09OIFVBUlQgcmVnaXN0ZXJzICovCiAjZGVmaW5lIFNNREtWMjEwX1VDT05fREVGQVVMVAkoUzNDMjQxMF9VQ09OX1RYSUxFVkVMIHwJXApAQCAtMTAyLDEyICsxMTIsMTA2IEBACiAJLmNvbHMJCT0gOCwKIH07CiAKK3N0YXRpYyBzdHJ1Y3QgcmVzb3VyY2Ugc21ka3YyMTBfZG05MDAwX3Jlc291cmNlc1tdID0geworCVswXSA9IHsKKwkJLnN0YXJ0CT0gUzVQVjIxMF9QQV9TUk9NX0JBTks1LAorCQkuZW5kCT0gUzVQVjIxMF9QQV9TUk9NX0JBTks1LAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX01FTSwKKwl9LAorCVsxXSA9IHsKKwkJLnN0YXJ0CT0gUzVQVjIxMF9QQV9TUk9NX0JBTks1ICsgMiwKKwkJLmVuZAk9IFM1UFYyMTBfUEFfU1JPTV9CQU5LNSArIDIsCisJCS5mbGFncwk9IElPUkVTT1VSQ0VfTUVNLAorCX0sCisJWzJdID0geworCQkuc3RhcnQJPSBJUlFfRUlOVCg5KSwKKwkJLmVuZAk9IElSUV9FSU5UKDkpLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX0lSUSB8IElPUkVTT1VSQ0VfSVJRX0hJR0hMRVZFTCwKKwl9LAorfTsKKworc3RhdGljIHN0cnVjdCBkbTkwMDBfcGxhdF9kYXRhIHNtZGt2MjEwX2RtOTAwMF9wbGF0ZGF0YSA9IHsKKwkuZmxhZ3MJCT0gRE05MDAwX1BMQVRGXzE2QklUT05MWSB8IERNOTAwMF9QTEFURl9OT19FRVBST00sCisJLmRldl9hZGRyCT0geyAweDAwLCAweDA5LCAweGMwLCAweGZmLCAweGVjLCAweDQ4IH0sCit9OworCitzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIHNtZGt2MjEwX2RtOTAwMCA9IHsKKwkubmFtZQkJPSAiZG05MDAwIiwKKwkuaWQJCT0gLTEsCisJLm51bV9yZXNvdXJjZXMJPSBBUlJBWV9TSVpFKHNtZGt2MjEwX2RtOTAwMF9yZXNvdXJjZXMpLAorCS5yZXNvdXJjZQk9IHNtZGt2MjEwX2RtOTAwMF9yZXNvdXJjZXMsCisJLmRldgkJPSB7CisJCS5wbGF0Zm9ybV9kYXRhCT0gJnNtZGt2MjEwX2RtOTAwMF9wbGF0ZGF0YSwKKwl9LAorfTsKKworc3RhdGljIHZvaWQgc21ka3YyMTBfbHRlNDgwd3Zfc2V0X3Bvd2VyKHN0cnVjdCBwbGF0X2xjZF9kYXRhICpwZCwKKwkJCQkJdW5zaWduZWQgaW50IHBvd2VyKQoreworCWlmIChwb3dlcikgeworI2lmICFkZWZpbmVkKENPTkZJR19CQUNLTElHSFRfUFdNKQorCQlncGlvX3JlcXVlc3QoUzVQVjIxMF9HUEQwKDMpLCAiR1BEMCIpOworCQlncGlvX2RpcmVjdGlvbl9vdXRwdXQoUzVQVjIxMF9HUEQwKDMpLCAxKTsKKwkJZ3Bpb19mcmVlKFM1UFYyMTBfR1BEMCgzKSk7CisjZW5kaWYKKworCQkvKiBmaXJlIG5SRVNFVCBvbiBwb3dlciB1cCAqLworCQlncGlvX3JlcXVlc3QoUzVQVjIxMF9HUEgwKDYpLCAiR1BIMCIpOworCisJCWdwaW9fZGlyZWN0aW9uX291dHB1dChTNVBWMjEwX0dQSDAoNiksIDEpOworCisJCWdwaW9fc2V0X3ZhbHVlKFM1UFYyMTBfR1BIMCg2KSwgMCk7CisJCW1kZWxheSgxMCk7CisKKwkJZ3Bpb19zZXRfdmFsdWUoUzVQVjIxMF9HUEgwKDYpLCAxKTsKKwkJbWRlbGF5KDEwKTsKKworCQlncGlvX2ZyZWUoUzVQVjIxMF9HUEgwKDYpKTsKKwl9IGVsc2UgeworI2lmICFkZWZpbmVkKENPTkZJR19CQUNLTElHSFRfUFdNKQorCQlncGlvX3JlcXVlc3QoUzVQVjIxMF9HUEQwKDMpLCAiR1BEMCIpOworCQlncGlvX2RpcmVjdGlvbl9vdXRwdXQoUzVQVjIxMF9HUEQwKDMpLCAwKTsKKwkJZ3Bpb19mcmVlKFM1UFYyMTBfR1BEMCgzKSk7CisjZW5kaWYKKwl9Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdF9sY2RfZGF0YSBzbWRrdjIxMF9sY2RfbHRlNDgwd3ZfZGF0YSA9IHsKKwkuc2V0X3Bvd2VyCT0gc21ka3YyMTBfbHRlNDgwd3Zfc2V0X3Bvd2VyLAorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2Ugc21ka3YyMTBfbGNkX2x0ZTQ4MHd2ID0geworCS5uYW1lCQkJPSAicGxhdGZvcm0tbGNkIiwKKwkuZGV2LnBhcmVudAkJPSAmczNjX2RldmljZV9mYi5kZXYsCisJLmRldi5wbGF0Zm9ybV9kYXRhCT0gJnNtZGt2MjEwX2xjZF9sdGU0ODB3dl9kYXRhLAorfTsKKworc3RhdGljIHN0cnVjdCBzM2NfZmJfcGRfd2luIHNtZGt2MjEwX2ZiX3dpbjAgPSB7CisJLndpbl9tb2RlID0geworCQkubGVmdF9tYXJnaW4JPSAxMywKKwkJLnJpZ2h0X21hcmdpbgk9IDgsCisJCS51cHBlcl9tYXJnaW4JPSA3LAorCQkubG93ZXJfbWFyZ2luCT0gNSwKKwkJLmhzeW5jX2xlbgk9IDMsCisJCS52c3luY19sZW4JPSAxLAorCQkueHJlcwkJPSA4MDAsCisJCS55cmVzCQk9IDQ4MCwKKwl9LAorCS5tYXhfYnBwCT0gMzIsCisJLmRlZmF1bHRfYnBwCT0gMjQsCit9OworCitzdGF0aWMgc3RydWN0IHMzY19mYl9wbGF0ZGF0YSBzbWRrdjIxMF9sY2QwX3BkYXRhIF9faW5pdGRhdGEgPSB7CisJLndpblswXQkJPSAmc21ka3YyMTBfZmJfd2luMCwKKwkudmlkY29uMAk9IFZJRENPTjBfVklET1VUX1JHQiB8IFZJRENPTjBfUE5STU9ERV9SR0IsCisJLnZpZGNvbjEJPSBWSURDT04xX0lOVl9IU1lOQyB8IFZJRENPTjFfSU5WX1ZTWU5DLAorCS5zZXR1cF9ncGlvCT0gczVwdjIxMF9mYl9ncGlvX3NldHVwXzI0YnBwLAorfTsKKwogc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnNtZGt2MjEwX2RldmljZXNbXSBfX2luaXRkYXRhID0gewotCSZzNXB2MjEwX2RldmljZV9paXMwLAotCSZzNXB2MjEwX2RldmljZV9hYzk3LAotCSZzNXB2MjEwX2RldmljZV9zcGRpZiwKIAkmczNjX2RldmljZV9hZGMsCiAJJnMzY19kZXZpY2VfY2Zjb24sCisJJnMzY19kZXZpY2VfZmIsCiAJJnMzY19kZXZpY2VfaHNtbWMwLAogCSZzM2NfZGV2aWNlX2hzbW1jMSwKIAkmczNjX2RldmljZV9oc21tYzIsCkBAIC0xMTUsMTQgKzIxOSwzOCBAQAogCSZzM2NfZGV2aWNlX2kyYzAsCiAJJnMzY19kZXZpY2VfaTJjMSwKIAkmczNjX2RldmljZV9pMmMyLAotCSZzYW1zdW5nX2RldmljZV9rZXlwYWQsCiAJJnMzY19kZXZpY2VfcnRjLAogCSZzM2NfZGV2aWNlX3RzLAogCSZzM2NfZGV2aWNlX3dkdCwKKwkmczVwdjIxMF9kZXZpY2VfYWM5NywKKwkmczVwdjIxMF9kZXZpY2VfaWlzMCwKKwkmczVwdjIxMF9kZXZpY2Vfc3BkaWYsCisJJnNhbXN1bmdfYXNvY19kbWEsCisJJnNhbXN1bmdfZGV2aWNlX2tleXBhZCwKKwkmc21ka3YyMTBfZG05MDAwLAorCSZzbWRrdjIxMF9sY2RfbHRlNDgwd3YsCiB9OwogCitzdGF0aWMgdm9pZCBfX2luaXQgc21ka3YyMTBfZG05MDAwX2luaXQodm9pZCkKK3sKKwl1bnNpZ25lZCBpbnQgdG1wOworCisJZ3Bpb19yZXF1ZXN0KFM1UFYyMTBfTVAwMSg1KSwgIm5DUzUiKTsKKwlzM2NfZ3Bpb19jZmdwaW4oUzVQVjIxMF9NUDAxKDUpLCBTM0NfR1BJT19TRk4oMikpOworCWdwaW9fZnJlZShTNVBWMjEwX01QMDEoNSkpOworCisJdG1wID0gKDUgPDwgUzVQX1NST01fQkNYX19UQUNDX19TSElGVCk7CisJX19yYXdfd3JpdGVsKHRtcCwgUzVQX1NST01fQkM1KTsKKworCXRtcCA9IF9fcmF3X3JlYWRsKFM1UF9TUk9NX0JXKTsKKwl0bXAgJj0gKFM1UF9TUk9NX0JXX19DU19NQVNLIDw8IFM1UF9TUk9NX0JXX19OQ1M1X19TSElGVCk7CisJdG1wIHw9ICgxIDw8IFM1UF9TUk9NX0JXX19OQ1M1X19TSElGVCk7CisJX19yYXdfd3JpdGVsKHRtcCwgUzVQX1NST01fQlcpOworfQorCiBzdGF0aWMgc3RydWN0IGkyY19ib2FyZF9pbmZvIHNtZGt2MjEwX2kyY19kZXZzMFtdIF9faW5pdGRhdGEgPSB7CiAJeyBJMkNfQk9BUkRfSU5GTygiMjRjMDgiLCAweDUwKSwgfSwgICAgIC8qIFNhbXN1bmcgUzUyNEFEMFhEMSAqLworCXsgSTJDX0JPQVJEX0lORk8oIndtODU4MCIsIDB4MWIpLCB9LAogfTsKIAogc3RhdGljIHN0cnVjdCBpMmNfYm9hcmRfaW5mbyBzbWRrdjIxMF9pMmNfZGV2czFbXSBfX2luaXRkYXRhID0gewpAQCAtMTUwLDYgKzI3OCw4IEBACiB7CiAJczNjX3BtX2luaXQoKTsKIAorCXNtZGt2MjEwX2RtOTAwMF9pbml0KCk7CisKIAlzYW1zdW5nX2tleXBhZF9zZXRfcGxhdGRhdGEoJnNtZGt2MjEwX2tleXBhZF9kYXRhKTsKIAlzM2MyNHh4X3RzX3NldF9wbGF0ZGF0YSgmczNjX3RzX3BsYXRmb3JtKTsKIApAQCAtMTY1LDYgKzI5NSw4IEBACiAKIAlzM2NfaWRlX3NldF9wbGF0ZGF0YSgmc21ka3YyMTBfaWRlX3BkYXRhKTsKIAorCXMzY19mYl9zZXRfcGxhdGRhdGEoJnNtZGt2MjEwX2xjZDBfcGRhdGEpOworCiAJcGxhdGZvcm1fYWRkX2RldmljZXMoc21ka3YyMTBfZGV2aWNlcywgQVJSQVlfU0laRShzbWRrdjIxMF9kZXZpY2VzKSk7CiB9CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczVwdjMxMC9LY29uZmlnIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL0tjb25maWcKaW5kZXggZDY0ZWZlMC4uYjJhOWFjYyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL0tjb25maWcKKysrIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL0tjb25maWcKQEAgLTE1LDYgKzE1LDExIEBACiAJaGVscAogCSAgRW5hYmxlIFM1UFYzMTAgQ1BVIHN1cHBvcnQKIAorY29uZmlnIFM1UFYzMTBfREVWX1BECisJYm9vbAorCWhlbHAKKwkgIENvbXBpbGUgaW4gcGxhdGZvcm0gZGV2aWNlIGRlZmluaXRpb25zIGZvciBQb3dlciBEb21haW4KKwogY29uZmlnIFM1UFYzMTBfU0VUVVBfSTJDMQogCWJvb2wKIAloZWxwCkBAIC02MSw2ICs2NiwxMSBAQAogCWhlbHAKIAkgIENvbW1vbiBzZXR1cCBjb2RlIGZvciBTREhDSSBncGlvLgogCitjb25maWcgUzVQVjMxMF9ERVZfU1lTTU1VCisJYm9vbAorCWhlbHAKKwkgIENvbW1vbiBzZXR1cCBjb2RlIGZvciBTWVNURU0gTU1VIGluIFM1UFYzMTAKKwogIyBtYWNoaW5lIHN1cHBvcnQKIAogbWVudSAiUzVQQzIxMCBNYWNoaW5lcyIKQEAgLTcwLDExICs4MCwxNSBAQAogCXNlbGVjdCBDUFVfUzVQVjMxMAogCXNlbGVjdCBTM0NfREVWX1JUQwogCXNlbGVjdCBTM0NfREVWX1dEVAorCXNlbGVjdCBTM0NfREVWX0kyQzEKIAlzZWxlY3QgUzNDX0RFVl9IU01NQwogCXNlbGVjdCBTM0NfREVWX0hTTU1DMQogCXNlbGVjdCBTM0NfREVWX0hTTU1DMgogCXNlbGVjdCBTM0NfREVWX0hTTU1DMworCXNlbGVjdCBTNVBWMzEwX0RFVl9QRAorCXNlbGVjdCBTNVBWMzEwX1NFVFVQX0kyQzEKIAlzZWxlY3QgUzVQVjMxMF9TRVRVUF9TREhDSQorCXNlbGVjdCBTNVBWMzEwX0RFVl9TWVNNTVUKIAloZWxwCiAJICBNYWNoaW5lIHN1cHBvcnQgZm9yIFNhbXN1bmcgU01ES0MyMTAKIAkgIFM1UEMyMTAoTUNQKSBpcyBvbmUgb2YgcGFja2FnZSBvcHRpb24gb2YgUzVQVjMxMApAQCAtODMsNiArOTcsMTAgQEAKIAlib29sICJNb2JpbGUgVU5JVkVSU0FMX0MyMTAgQm9hcmQiCiAJc2VsZWN0IENQVV9TNVBWMzEwCiAJc2VsZWN0IFM1UF9ERVZfT05FTkFORAorCXNlbGVjdCBTM0NfREVWX0hTTU1DCisJc2VsZWN0IFMzQ19ERVZfSFNNTUMyCisJc2VsZWN0IFMzQ19ERVZfSFNNTUMzCisJc2VsZWN0IFM1UFYzMTBfU0VUVVBfU0RIQ0kKIAlzZWxlY3QgUzNDX0RFVl9JMkMxCiAJc2VsZWN0IFM1UFYzMTBfU0VUVVBfSTJDMQogCWhlbHAKQEAgLTk4LDEwICsxMTYsMTQgQEAKIAlzZWxlY3QgQ1BVX1M1UFYzMTAKIAlzZWxlY3QgUzNDX0RFVl9SVEMKIAlzZWxlY3QgUzNDX0RFVl9XRFQKKwlzZWxlY3QgUzNDX0RFVl9JMkMxCiAJc2VsZWN0IFMzQ19ERVZfSFNNTUMKIAlzZWxlY3QgUzNDX0RFVl9IU01NQzEKIAlzZWxlY3QgUzNDX0RFVl9IU01NQzIKIAlzZWxlY3QgUzNDX0RFVl9IU01NQzMKKwlzZWxlY3QgUzVQVjMxMF9ERVZfUEQKKwlzZWxlY3QgUzVQVjMxMF9ERVZfU1lTTU1VCisJc2VsZWN0IFM1UFYzMTBfU0VUVVBfSTJDMQogCXNlbGVjdCBTNVBWMzEwX1NFVFVQX1NESENJCiAJaGVscAogCSAgTWFjaGluZSBzdXBwb3J0IGZvciBTYW1zdW5nIFNNREtWMzEwCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cHYzMTAvTWFrZWZpbGUgYi9hcmNoL2FybS9tYWNoLXM1cHYzMTAvTWFrZWZpbGUKaW5kZXggNjFlM2NiNi4uMDM2ZmIzOCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL01ha2VmaWxlCisrKyBiL2FyY2gvYXJtL21hY2gtczVwdjMxMC9NYWtlZmlsZQpAQCAtMTQsNiArMTQsNyBAQAogCiBvYmotJChDT05GSUdfQ1BVX1M1UFYzMTApCSs9IGNwdS5vIGluaXQubyBjbG9jay5vIGlycS1jb21iaW5lci5vCiBvYmotJChDT05GSUdfQ1BVX1M1UFYzMTApCSs9IHNldHVwLWkyYzAubyB0aW1lLm8gZ3Bpb2xpYi5vIGlycS1laW50Lm8gZG1hLm8KK29iai0kKENPTkZJR19DUFVfRlJFUSkJCSs9IGNwdWZyZXEubwogCiBvYmotJChDT05GSUdfU01QKQkJKz0gcGxhdHNtcC5vIGhlYWRzbXAubwogb2JqLSQoQ09ORklHX0xPQ0FMX1RJTUVSUykJKz0gbG9jYWx0aW1lci5vCkBAIC0yNyw3ICsyOCwxMCBAQAogCiAjIGRldmljZSBzdXBwb3J0CiAKLW9iai15ICs9IGRldi1hdWRpby5vCitvYmoteQkJCQkJKz0gZGV2LWF1ZGlvLm8KK29iai0kKENPTkZJR19TNVBWMzEwX0RFVl9QRCkJCSs9IGRldi1wZC5vCitvYmotJChDT05GSUdfUzVQVjMxMF9ERVZfU1lTTU1VKQkrPSBkZXYtc3lzbW11Lm8KKwogb2JqLSQoQ09ORklHX1M1UFYzMTBfU0VUVVBfSTJDMSkJKz0gc2V0dXAtaTJjMS5vCiBvYmotJChDT05GSUdfUzVQVjMxMF9TRVRVUF9JMkMyKQkrPSBzZXR1cC1pMmMyLm8KIG9iai0kKENPTkZJR19TNVBWMzEwX1NFVFVQX0kyQzMpCSs9IHNldHVwLWkyYzMubwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2Nsb2NrLmMgYi9hcmNoL2FybS9tYWNoLXM1cHYzMTAvY2xvY2suYwppbmRleCA1OGM5ZDMzLi5mYzdjMmY4IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cHYzMTAvY2xvY2suYworKysgYi9hcmNoL2FybS9tYWNoLXM1cHYzMTAvY2xvY2suYwpAQCAtMjQ0LDcgKzI0NCw3IEBACiAJCS5pZAkJPSAtMSwKIAl9LAogCS5zb3VyY2VzCT0gJmNsa3NldF9tb3V0X2NvcmVidXMsCi0JLnJlZ19zcmMJPSB7IC5yZWcgPSBTNVBfQ0xLU1JDX0NPUkUsIC5zaGlmdCA9IDQsIC5zaXplID0gMSB9LAorCS5yZWdfc3JjCT0geyAucmVnID0gUzVQX0NMS1NSQ19ETUMsIC5zaGlmdCA9IDQsIC5zaXplID0gMSB9LAogfTsKIAogc3RhdGljIHN0cnVjdCBjbGtzcmNfY2xrIGNsa19zY2xrX2RtYyA9IHsKQEAgLTI1Myw3ICsyNTMsNyBAQAogCQkuaWQJCT0gLTEsCiAJCS5wYXJlbnQJCT0gJmNsa19tb3V0X2NvcmVidXMuY2xrLAogCX0sCi0JLnJlZ19kaXYJPSB7IC5yZWcgPSBTNVBfQ0xLRElWX0NPUkUwLCAuc2hpZnQgPSAxMiwgLnNpemUgPSAzIH0sCisJLnJlZ19kaXYJPSB7IC5yZWcgPSBTNVBfQ0xLRElWX0RNQzAsIC5zaGlmdCA9IDEyLCAuc2l6ZSA9IDMgfSwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgY2xrc3JjX2NsayBjbGtfYWNsa19jb3JlZCA9IHsKQEAgLTI2Miw3ICsyNjIsNyBAQAogCQkuaWQJCT0gLTEsCiAJCS5wYXJlbnQJCT0gJmNsa19zY2xrX2RtYy5jbGssCiAJfSwKLQkucmVnX2Rpdgk9IHsgLnJlZyA9IFM1UF9DTEtESVZfQ09SRTAsIC5zaGlmdCA9IDE2LCAuc2l6ZSA9IDMgfSwKKwkucmVnX2Rpdgk9IHsgLnJlZyA9IFM1UF9DTEtESVZfRE1DMCwgLnNoaWZ0ID0gMTYsIC5zaXplID0gMyB9LAogfTsKIAogc3RhdGljIHN0cnVjdCBjbGtzcmNfY2xrIGNsa19hY2xrX2NvcmVwID0gewpAQCAtMjcxLDcgKzI3MSw3IEBACiAJCS5pZAkJPSAtMSwKIAkJLnBhcmVudAkJPSAmY2xrX2FjbGtfY29yZWQuY2xrLAogCX0sCi0JLnJlZ19kaXYJPSB7IC5yZWcgPSBTNVBfQ0xLRElWX0NPUkUwLCAuc2hpZnQgPSAyMCwgLnNpemUgPSAzIH0sCisJLnJlZ19kaXYJPSB7IC5yZWcgPSBTNVBfQ0xLRElWX0RNQzAsIC5zaGlmdCA9IDIwLCAuc2l6ZSA9IDMgfSwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgY2xrc3JjX2NsayBjbGtfYWNsa19hY3AgPSB7CkBAIC0yODAsNyArMjgwLDcgQEAKIAkJLmlkCQk9IC0xLAogCQkucGFyZW50CQk9ICZjbGtfbW91dF9jb3JlYnVzLmNsaywKIAl9LAotCS5yZWdfZGl2CT0geyAucmVnID0gUzVQX0NMS0RJVl9DT1JFMCwgLnNoaWZ0ID0gMCwgLnNpemUgPSAzIH0sCisJLnJlZ19kaXYJPSB7IC5yZWcgPSBTNVBfQ0xLRElWX0RNQzAsIC5zaGlmdCA9IDAsIC5zaXplID0gMyB9LAogfTsKIAogc3RhdGljIHN0cnVjdCBjbGtzcmNfY2xrIGNsa19wY2xrX2FjcCA9IHsKQEAgLTI4OSw3ICsyODksNyBAQAogCQkuaWQJCT0gLTEsCiAJCS5wYXJlbnQJCT0gJmNsa19hY2xrX2FjcC5jbGssCiAJfSwKLQkucmVnX2Rpdgk9IHsgLnJlZyA9IFM1UF9DTEtESVZfQ09SRTAsIC5zaGlmdCA9IDQsIC5zaXplID0gMyB9LAorCS5yZWdfZGl2CT0geyAucmVnID0gUzVQX0NMS0RJVl9ETUMwLCAuc2hpZnQgPSA0LCAuc2l6ZSA9IDMgfSwKIH07CiAKIC8qIENvcmUgbGlzdCBvZiBDTVVfVE9QIHNpZGUgKi8KQEAgLTM4NCw3ICszODQsNyBAQAogCS5yZWdfc3JjCT0geyAucmVnID0gUzVQX0NMS1NSQ19UT1AwLCAuc2hpZnQgPSA4LCAuc2l6ZSA9IDEgfSwKIH07CiAKLXN0YXRpYyBzdHJ1Y3QgY2xrIGluaXRfY2xvY2tzX2Rpc2FibGVbXSA9IHsKK3N0YXRpYyBzdHJ1Y3QgY2xrIGluaXRfY2xvY2tzX29mZltdID0gewogCXsKIAkJLm5hbWUJCT0gInRpbWVycyIsCiAJCS5pZAkJPSAtMSwKQEAgLTQ2Nyw2ICs0NjcsMTYgQEAKIAkJLmVuYWJsZQkJPSBzNXB2MzEwX2Nsa19pcF9mc3lzX2N0cmwsCiAJCS5jdHJsYml0CT0gKDEgPDwgMTApLAogCX0sIHsKKwkJLm5hbWUJCT0gInBkbWEiLAorCQkuaWQJCT0gMCwKKwkJLmVuYWJsZQkJPSBzNXB2MzEwX2Nsa19pcF9mc3lzX2N0cmwsCisJCS5jdHJsYml0CT0gKDEgPDwgMCksCisJfSwgeworCQkubmFtZQkJPSAicGRtYSIsCisJCS5pZAkJPSAxLAorCQkuZW5hYmxlCQk9IHM1cHYzMTBfY2xrX2lwX2ZzeXNfY3RybCwKKwkJLmN0cmxiaXQJPSAoMSA8PCAxKSwKKwl9LCB7CiAJCS5uYW1lCQk9ICJhZGMiLAogCQkuaWQJCT0gLTEsCiAJCS5lbmFibGUJCT0gczVwdjMxMF9jbGtfaXBfcGVyaWxfY3RybCwKQEAgLTUwNyw2ICs1MTcsMjYgQEAKIAkJLmVuYWJsZQkJPSBzNXB2MzEwX2Nsa19pcF9wZXJpbF9jdHJsLAogCQkuY3RybGJpdAk9ICgxIDw8IDE4KSwKIAl9LCB7CisJCS5uYW1lCQk9ICJpaXMiLAorCQkuaWQJCT0gMCwKKwkJLmVuYWJsZQkJPSBzNXB2MzEwX2Nsa19pcF9wZXJpbF9jdHJsLAorCQkuY3RybGJpdAk9ICgxIDw8IDE5KSwKKwl9LCB7CisJCS5uYW1lCQk9ICJpaXMiLAorCQkuaWQJCT0gMSwKKwkJLmVuYWJsZQkJPSBzNXB2MzEwX2Nsa19pcF9wZXJpbF9jdHJsLAorCQkuY3RybGJpdAk9ICgxIDw8IDIwKSwKKwl9LCB7CisJCS5uYW1lCQk9ICJpaXMiLAorCQkuaWQJCT0gMiwKKwkJLmVuYWJsZQkJPSBzNXB2MzEwX2Nsa19pcF9wZXJpbF9jdHJsLAorCQkuY3RybGJpdAk9ICgxIDw8IDIxKSwKKwl9LCB7CisJCS5uYW1lCQk9ICJhYzk3IiwKKwkJLmlkCQk9IC0xLAorCQkuZW5hYmxlCQk9IHM1cHYzMTBfY2xrX2lwX3BlcmlsX2N0cmwsCisJCS5jdHJsYml0CT0gKDEgPDwgMjcpLAorCX0sIHsKIAkJLm5hbWUJCT0gImZpbWcyZCIsCiAJCS5pZAkJPSAtMSwKIAkJLmVuYWJsZQkJPSBzNXB2MzEwX2Nsa19pcF9pbWFnZV9jdHJsLApAQCAtOTkwLDYgKzEwMjAsMTcgQEAKIAkmY2xrX2RvdXRfbW1jNCwKIH07CiAKK3N0YXRpYyBpbnQgeHRhbF9yYXRlOworCitzdGF0aWMgdW5zaWduZWQgbG9uZyBzNXB2MzEwX2ZvdXRfYXBsbF9nZXRfcmF0ZShzdHJ1Y3QgY2xrICpjbGspCit7CisJcmV0dXJuIHM1cF9nZXRfcGxsNDV4eCh4dGFsX3JhdGUsIF9fcmF3X3JlYWRsKFM1UF9BUExMX0NPTjApLCBwbGxfNDUwOCk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgY2xrX29wcyBzNXB2MzEwX2ZvdXRfYXBsbF9vcHMgPSB7CisJLmdldF9yYXRlID0gczVwdjMxMF9mb3V0X2FwbGxfZ2V0X3JhdGUsCit9OworCiB2b2lkIF9faW5pdF9vcl9jcHVmcmVxIHM1cHYzMTBfc2V0dXBfY2xvY2tzKHZvaWQpCiB7CiAJc3RydWN0IGNsayAqeHRhbF9jbGs7CkBAIC0xMDEzLDYgKzEwNTQsOSBAQAogCUJVR19PTihJU19FUlIoeHRhbF9jbGspKTsKIAogCXh0YWwgPSBjbGtfZ2V0X3JhdGUoeHRhbF9jbGspOworCisJeHRhbF9yYXRlID0geHRhbDsKKwogCWNsa19wdXQoeHRhbF9jbGspOwogCiAJcHJpbnRrKEtFUk5fREVCVUcgIiVzOiB4dGFsIGlzICVsZFxuIiwgX19mdW5jX18sIHh0YWwpOwpAQCAtMTAyNiw3ICsxMDcwLDcgQEAKIAl2cGxsID0gczVwX2dldF9wbGw0Nnh4KHZwbGxzcmMsIF9fcmF3X3JlYWRsKFM1UF9WUExMX0NPTjApLAogCQkJCV9fcmF3X3JlYWRsKFM1UF9WUExMX0NPTjEpLCBwbGxfNDY1MCk7CiAKLQljbGtfZm91dF9hcGxsLnJhdGUgPSBhcGxsOworCWNsa19mb3V0X2FwbGwub3BzID0gJnM1cHYzMTBfZm91dF9hcGxsX29wczsKIAljbGtfZm91dF9tcGxsLnJhdGUgPSBtcGxsOwogCWNsa19mb3V0X2VwbGwucmF0ZSA9IGVwbGw7CiAJY2xrX2ZvdXRfdnBsbC5yYXRlID0gdnBsbDsKQEAgLTEwNjEsMTMgKzExMDUsOSBAQAogCiB2b2lkIF9faW5pdCBzNXB2MzEwX3JlZ2lzdGVyX2Nsb2Nrcyh2b2lkKQogewotCXN0cnVjdCBjbGsgKmNsa3A7Ci0JaW50IHJldDsKIAlpbnQgcHRyOwogCi0JcmV0ID0gczNjMjR4eF9yZWdpc3Rlcl9jbG9ja3MoY2xrcywgQVJSQVlfU0laRShjbGtzKSk7Ci0JaWYgKHJldCA+IDApCi0JCXByaW50ayhLRVJOX0VSUiAiRmFpbGVkIHRvIHJlZ2lzdGVyICV1IGNsb2Nrc1xuIiwgcmV0KTsKKwlzM2MyNHh4X3JlZ2lzdGVyX2Nsb2NrcyhjbGtzLCBBUlJBWV9TSVpFKGNsa3MpKTsKIAogCWZvciAocHRyID0gMDsgcHRyIDwgQVJSQVlfU0laRShzeXNjbGtzKTsgcHRyKyspCiAJCXMzY19yZWdpc3Rlcl9jbGtzcmMoc3lzY2xrc1twdHJdLCAxKTsKQEAgLTEwNzUsMTUgKzExMTUsOCBAQAogCXMzY19yZWdpc3Rlcl9jbGtzcmMoY2xrc3JjcywgQVJSQVlfU0laRShjbGtzcmNzKSk7CiAJczNjX3JlZ2lzdGVyX2Nsb2Nrcyhpbml0X2Nsb2NrcywgQVJSQVlfU0laRShpbml0X2Nsb2NrcykpOwogCi0JY2xrcCA9IGluaXRfY2xvY2tzX2Rpc2FibGU7Ci0JZm9yIChwdHIgPSAwOyBwdHIgPCBBUlJBWV9TSVpFKGluaXRfY2xvY2tzX2Rpc2FibGUpOyBwdHIrKywgY2xrcCsrKSB7Ci0JCXJldCA9IHMzYzI0eHhfcmVnaXN0ZXJfY2xvY2soY2xrcCk7Ci0JCWlmIChyZXQgPCAwKSB7Ci0JCQlwcmludGsoS0VSTl9FUlIgIkZhaWxlZCB0byByZWdpc3RlciBjbG9jayAlcyAoJWQpXG4iLAotCQkJICAgICAgIGNsa3AtPm5hbWUsIHJldCk7Ci0JCX0KLQkJKGNsa3AtPmVuYWJsZSkoY2xrcCwgMCk7Ci0JfQorCXMzY19yZWdpc3Rlcl9jbG9ja3MoaW5pdF9jbG9ja3Nfb2ZmLCBBUlJBWV9TSVpFKGluaXRfY2xvY2tzX29mZikpOworCXMzY19kaXNhYmxlX2Nsb2Nrcyhpbml0X2Nsb2Nrc19vZmYsIEFSUkFZX1NJWkUoaW5pdF9jbG9ja3Nfb2ZmKSk7CiAKIAlzM2NfcHdtY2xrX2luaXQoKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczVwdjMxMC9jcHUuYyBiL2FyY2gvYXJtL21hY2gtczVwdjMxMC9jcHUuYwppbmRleCA3MmFiMjg5Li4wZGIwZmI2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cHYzMTAvY3B1LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2NwdS5jCkBAIC00MSw2ICs0MSwxMSBAQAogCQkubGVuZ3RoCQk9IFNaXzEyOEssCiAJCS50eXBlCQk9IE1UX0RFVklDRSwKIAl9LCB7CisJCS52aXJ0dWFsCT0gKHVuc2lnbmVkIGxvbmcpUzVQX1ZBX1BNVSwKKwkJLnBmbgkJPSBfX3BoeXNfdG9fcGZuKFM1UFYzMTBfUEFfUE1VKSwKKwkJLmxlbmd0aAkJPSBTWl82NEssCisJCS50eXBlCQk9IE1UX0RFVklDRSwKKwl9LCB7CiAJCS52aXJ0dWFsCT0gKHVuc2lnbmVkIGxvbmcpUzVQX1ZBX0NPTUJJTkVSX0JBU0UsCiAJCS5wZm4JCT0gX19waHlzX3RvX3BmbihTNVBWMzEwX1BBX0NPTUJJTkVSKSwKIAkJLmxlbmd0aAkJPSBTWl80SywKQEAgLTcxLDYgKzc2LDExIEBACiAJCS5sZW5ndGgJCT0gU1pfMjU2LAogCQkudHlwZQkJPSBNVF9ERVZJQ0UsCiAJfSwgeworCQkudmlydHVhbAk9ICh1bnNpZ25lZCBsb25nKVM1UF9WQV9ETUMwLAorCQkucGZuCQk9IF9fcGh5c190b19wZm4oUzVQVjMxMF9QQV9ETUMwKSwKKwkJLmxlbmd0aAkJPSBTWl80SywKKwkJLnR5cGUJCT0gTVRfREVWSUNFLAorCX0sIHsKIAkJLnZpcnR1YWwJPSAodW5zaWduZWQgbG9uZylTM0NfVkFfVUFSVCwKIAkJLnBmbgkJPSBfX3BoeXNfdG9fcGZuKFMzQ19QQV9VQVJUKSwKIAkJLmxlbmd0aAkJPSBTWl81MTJLLApAQCAtMTIzLDYgKzEzMywxNSBAQAogCWdpY19pbml0KDAsIElSUV9MT0NBTFRJTUVSLCBTNVBfVkFfR0lDX0RJU1QsIFM1UF9WQV9HSUNfQ1BVKTsKIAogCWZvciAoaXJxID0gMDsgaXJxIDwgTUFYX0NPTUJJTkVSX05SOyBpcnErKykgeworCisJCS8qCisJCSAqIEZyb20gU1BJKDApIHRvIFNQSSgzOSkgYW5kIFNQSSg1MSksIFNQSSg1MykgYXJlCisJCSAqIGNvbm5lY3RlZCB0byB0aGUgaW50ZXJydXB0IGNvbWJpbmVyLiBUaGVzZSBpcnFzCisJCSAqIHNob3VsZCBiZSBpbml0aWFsaXplZCB0byBzdXBwb3J0IGNhc2NhZGUgaW50ZXJydXB0LgorCQkgKi8KKwkJaWYgKChpcnEgPj0gNDApICYmICEoaXJxID09IDUxKSAmJiAhKGlycSA9PSA1MykpCisJCQljb250aW51ZTsKKwogCQljb21iaW5lcl9pbml0KGlycSwgKHZvaWQgX19pb21lbSAqKVM1UF9WQV9DT01CSU5FUihpcnEpLAogCQkJCUNPTUJJTkVSX0lSUShpcnEsIDApKTsKIAkJY29tYmluZXJfY2FzY2FkZV9pcnEoaXJxLCBJUlFfU1BJKGlycSkpOwpAQCAtMTY0LDcgKzE4Myw3IEBACiAJX19yYXdfd3JpdGVsKEwyWDBfRFlOQU1JQ19DTEtfR0FUSU5HX0VOIHwgTDJYMF9TVE5EQllfTU9ERV9FTiwKIAkJICAgICBTNVBfVkFfTDJDQyArIEwyWDBfUE9XRVJfQ1RSTCk7CiAKLQlsMngwX2luaXQoUzVQX1ZBX0wyQ0MsIDB4N0MwNzAwMDEsIDB4QzIwMGZmZmYpOworCWwyeDBfaW5pdChTNVBfVkFfTDJDQywgMHg3QzQ3MDAwMSwgMHhDMjAwZmZmZik7CiAKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczVwdjMxMC9jcHVmcmVxLmMgYi9hcmNoL2FybS9tYWNoLXM1cHYzMTAvY3B1ZnJlcS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmIwNGNiYzcKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL2FybS9tYWNoLXM1cHYzMTAvY3B1ZnJlcS5jCkBAIC0wLDAgKzEsNTgwIEBACisvKiBsaW51eC9hcmNoL2FybS9tYWNoLXM1cHYzMTAvY3B1ZnJlcS5jCisgKgorICogQ29weXJpZ2h0IChjKSAyMDEwIFNhbXN1bmcgRWxlY3Ryb25pY3MgQ28uLCBMdGQuCisgKgkJaHR0cDovL3d3dy5zYW1zdW5nLmNvbQorICoKKyAqIFM1UFYzMTAgLSBDUFUgZnJlcXVlbmN5IHNjYWxpbmcgc3VwcG9ydAorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisqLworCisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KKyNpbmNsdWRlIDxsaW51eC9jbGsuaD4KKyNpbmNsdWRlIDxsaW51eC9pby5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9yZWd1bGF0b3IvY29uc3VtZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9jcHVmcmVxLmg+CisKKyNpbmNsdWRlIDxtYWNoL21hcC5oPgorI2luY2x1ZGUgPG1hY2gvcmVncy1jbG9jay5oPgorI2luY2x1ZGUgPG1hY2gvcmVncy1tZW0uaD4KKworI2luY2x1ZGUgPHBsYXQvY2xvY2suaD4KKyNpbmNsdWRlIDxwbGF0L3BtLmg+CisKK3N0YXRpYyBzdHJ1Y3QgY2xrICpjcHVfY2xrOworc3RhdGljIHN0cnVjdCBjbGsgKm1vdXRjb3JlOworc3RhdGljIHN0cnVjdCBjbGsgKm1vdXRfbXBsbDsKK3N0YXRpYyBzdHJ1Y3QgY2xrICptb3V0X2FwbGw7CisKKyNpZmRlZiBDT05GSUdfUkVHVUxBVE9SCitzdGF0aWMgc3RydWN0IHJlZ3VsYXRvciAqYXJtX3JlZ3VsYXRvcjsKK3N0YXRpYyBzdHJ1Y3QgcmVndWxhdG9yICppbnRfcmVndWxhdG9yOworI2VuZGlmCisKK3N0YXRpYyBzdHJ1Y3QgY3B1ZnJlcV9mcmVxcyBmcmVxczsKK3N0YXRpYyB1bnNpZ25lZCBpbnQgbWVtdHlwZTsKKworZW51bSBzNXB2MzEwX21lbW9yeV90eXBlIHsKKwlERFIyID0gNCwKKwlMUEREUjIsCisJRERSMywKK307CisKK2VudW0gY3B1ZnJlcV9sZXZlbF9pbmRleCB7CisJTDAsIEwxLCBMMiwgTDMsIENQVUZSRVFfTEVWRUxfRU5ELAorfTsKKworc3RhdGljIHN0cnVjdCBjcHVmcmVxX2ZyZXF1ZW5jeV90YWJsZSBzNXB2MzEwX2ZyZXFfdGFibGVbXSA9IHsKKwl7TDAsIDEwMDAqMTAwMH0sCisJe0wxLCA4MDAqMTAwMH0sCisJe0wyLCA0MDAqMTAwMH0sCisJe0wzLCAxMDAqMTAwMH0sCisJezAsIENQVUZSRVFfVEFCTEVfRU5EfSwKK307CisKK3N0YXRpYyB1bnNpZ25lZCBpbnQgY2xrZGl2X2NwdTBbQ1BVRlJFUV9MRVZFTF9FTkRdWzddID0geworCS8qCisJICogQ2xvY2sgZGl2aWRlciB2YWx1ZSBmb3IgZm9sbG93aW5nCisJICogeyBESVZDT1JFLCBESVZDT1JFTTAsIERJVkNPUkVNMSwgRElWUEVSSVBILAorCSAqCQlESVZBVEIsIERJVlBDTEtfREJHLCBESVZBUExMIH0KKwkgKi8KKworCS8qIEFSTSBMMDogMTAwME1IeiAqLworCXsgMCwgMywgNywgMywgMywgMCwgMSB9LAorCisJLyogQVJNIEwxOiA4MDBNSHogKi8KKwl7IDAsIDMsIDcsIDMsIDMsIDAsIDEgfSwKKworCS8qIEFSTSBMMjogNDAwTUh6ICovCisJeyAwLCAxLCAzLCAxLCAzLCAwLCAxIH0sCisKKwkvKiBBUk0gTDM6IDEwME1IeiAqLworCXsgMCwgMCwgMSwgMCwgMywgMSwgMSB9LAorfTsKKworc3RhdGljIHVuc2lnbmVkIGludCBjbGtkaXZfY3B1MVtDUFVGUkVRX0xFVkVMX0VORF1bMl0gPSB7CisJLyoKKwkgKiBDbG9jayBkaXZpZGVyIHZhbHVlIGZvciBmb2xsb3dpbmcKKwkgKiB7IERJVkNPUFksIERJVkhQTSB9CisJICovCisKKwkgLyogQVJNIEwwOiAxMDAwTUh6ICovCisJeyAzLCAwIH0sCisKKwkvKiBBUk0gTDE6IDgwME1IeiAqLworCXsgMywgMCB9LAorCisJLyogQVJNIEwyOiA0MDBNSHogKi8KKwl7IDMsIDAgfSwKKworCS8qIEFSTSBMMzogMTAwTUh6ICovCisJeyAzLCAwIH0sCit9OworCitzdGF0aWMgdW5zaWduZWQgaW50IGNsa2Rpdl9kbWMwW0NQVUZSRVFfTEVWRUxfRU5EXVs4XSA9IHsKKwkvKgorCSAqIENsb2NrIGRpdmlkZXIgdmFsdWUgZm9yIGZvbGxvd2luZworCSAqIHsgRElWQUNQLCBESVZBQ1BfUENMSywgRElWRFBIWSwgRElWRE1DLCBESVZETUNECisJICoJCURJVkRNQ1AsIERJVkNPUFkyLCBESVZDT1JFX1RJTUVSUyB9CisJICovCisKKwkvKiBETUMgTDA6IDQwME1IeiAqLworCXsgMywgMSwgMSwgMSwgMSwgMSwgMywgMSB9LAorCisJLyogRE1DIEwxOiA0MDBNSHogKi8KKwl7IDMsIDEsIDEsIDEsIDEsIDEsIDMsIDEgfSwKKworCS8qIERNQyBMMjogMjY2LjdNSHogKi8KKwl7IDcsIDEsIDEsIDIsIDEsIDEsIDMsIDEgfSwKKworCS8qIERNQyBMMzogMjAwTUh6ICovCisJeyA3LCAxLCAxLCAzLCAxLCAxLCAzLCAxIH0sCit9OworCitzdGF0aWMgdW5zaWduZWQgaW50IGNsa2Rpdl90b3BbQ1BVRlJFUV9MRVZFTF9FTkRdWzVdID0geworCS8qCisJICogQ2xvY2sgZGl2aWRlciB2YWx1ZSBmb3IgZm9sbG93aW5nCisJICogeyBESVZBQ0xLMjAwLCBESVZBQ0xLMTAwLCBESVZBQ0xLMTYwLCBESVZBQ0xLMTMzLCBESVZPTkVOQU5EIH0KKwkgKi8KKworCS8qIEFDTEsyMDAgTDA6IDIwME1IeiAqLworCXsgMywgNywgNCwgNSwgMSB9LAorCisJLyogQUNMSzIwMCBMMTogMjAwTUh6ICovCisJeyAzLCA3LCA0LCA1LCAxIH0sCisKKwkvKiBBQ0xLMjAwIEwyOiAxNjBNSHogKi8KKwl7IDQsIDcsIDUsIDcsIDEgfSwKKworCS8qIEFDTEsyMDAgTDM6IDEzMy4zTUh6ICovCisJeyA1LCA3LCA3LCA3LCAxIH0sCit9OworCitzdGF0aWMgdW5zaWduZWQgaW50IGNsa2Rpdl9scl9idXNbQ1BVRlJFUV9MRVZFTF9FTkRdWzJdID0geworCS8qCisJICogQ2xvY2sgZGl2aWRlciB2YWx1ZSBmb3IgZm9sbG93aW5nCisJICogeyBESVZHREwvUiwgRElWR1BML1IgfQorCSAqLworCisJLyogQUNMS19HREwvUiBMMDogMjAwTUh6ICovCisJeyAzLCAxIH0sCisKKwkvKiBBQ0xLX0dETC9SIEwxOiAyMDBNSHogKi8KKwl7IDMsIDEgfSwKKworCS8qIEFDTEtfR0RML1IgTDI6IDE2ME1IeiAqLworCXsgNCwgMSB9LAorCisJLyogQUNMS19HREwvUiBMMzogMTMzLjNNSHogKi8KKwl7IDUsIDEgfSwKK307CisKK3N0cnVjdCBjcHVmcmVxX3ZvbHRhZ2VfdGFibGUgeworCXVuc2lnbmVkIGludAlpbmRleDsJCS8qIGFueSAqLworCXVuc2lnbmVkIGludAlhcm1fdm9sdDsJLyogdVYgKi8KKwl1bnNpZ25lZCBpbnQJaW50X3ZvbHQ7Cit9OworCitzdGF0aWMgc3RydWN0IGNwdWZyZXFfdm9sdGFnZV90YWJsZSBzNXB2MzEwX3ZvbHRfdGFibGVbQ1BVRlJFUV9MRVZFTF9FTkRdID0geworCXsKKwkJLmluZGV4CQk9IEwwLAorCQkuYXJtX3ZvbHQJPSAxMjAwMDAwLAorCQkuaW50X3ZvbHQJPSAxMTAwMDAwLAorCX0sIHsKKwkJLmluZGV4CQk9IEwxLAorCQkuYXJtX3ZvbHQJPSAxMTAwMDAwLAorCQkuaW50X3ZvbHQJPSAxMTAwMDAwLAorCX0sIHsKKwkJLmluZGV4CQk9IEwyLAorCQkuYXJtX3ZvbHQJPSAxMDAwMDAwLAorCQkuaW50X3ZvbHQJPSAxMDAwMDAwLAorCX0sIHsKKwkJLmluZGV4CQk9IEwzLAorCQkuYXJtX3ZvbHQJPSA5MDAwMDAsCisJCS5pbnRfdm9sdAk9IDEwMDAwMDAsCisJfSwKK307CisKK3N0YXRpYyB1bnNpZ25lZCBpbnQgczVwdjMxMF9hcGxsX3Btc190YWJsZVtDUFVGUkVRX0xFVkVMX0VORF0gPSB7CisJLyogQVBMTCBGT1VUIEwwOiAxMDAwTUh6ICovCisJKCgyNTAgPDwgMTYpIHwgKDYgPDwgOCkgfCAxKSwKKworCS8qIEFQTEwgRk9VVCBMMTogODAwTUh6ICovCisJKCgyMDAgPDwgMTYpIHwgKDYgPDwgOCkgfCAxKSwKKworCS8qIEFQTEwgRk9VVCBMMiA6IDQwME1IeiAqLworCSgoMjAwIDw8IDE2KSB8ICg2IDw8IDgpIHwgMiksCisKKwkvKiBBUExMIEZPVVQgTDM6IDEwME1IeiAqLworCSgoMjAwIDw8IDE2KSB8ICg2IDw8IDgpIHwgNCksCit9OworCitpbnQgczVwdjMxMF92ZXJpZnlfc3BlZWQoc3RydWN0IGNwdWZyZXFfcG9saWN5ICpwb2xpY3kpCit7CisJcmV0dXJuIGNwdWZyZXFfZnJlcXVlbmN5X3RhYmxlX3ZlcmlmeShwb2xpY3ksIHM1cHYzMTBfZnJlcV90YWJsZSk7Cit9CisKK3Vuc2lnbmVkIGludCBzNXB2MzEwX2dldHNwZWVkKHVuc2lnbmVkIGludCBjcHUpCit7CisJcmV0dXJuIGNsa19nZXRfcmF0ZShjcHVfY2xrKSAvIDEwMDA7Cit9CisKK3ZvaWQgczVwdjMxMF9zZXRfY2xrZGl2KHVuc2lnbmVkIGludCBkaXZfaW5kZXgpCit7CisJdW5zaWduZWQgaW50IHRtcDsKKworCS8qIENoYW5nZSBEaXZpZGVyIC0gQ1BVMCAqLworCisJdG1wID0gX19yYXdfcmVhZGwoUzVQX0NMS0RJVl9DUFUpOworCisJdG1wICY9IH4oUzVQX0NMS0RJVl9DUFUwX0NPUkVfTUFTSyB8IFM1UF9DTEtESVZfQ1BVMF9DT1JFTTBfTUFTSyB8CisJCVM1UF9DTEtESVZfQ1BVMF9DT1JFTTFfTUFTSyB8IFM1UF9DTEtESVZfQ1BVMF9QRVJJUEhfTUFTSyB8CisJCVM1UF9DTEtESVZfQ1BVMF9BVEJfTUFTSyB8IFM1UF9DTEtESVZfQ1BVMF9QQ0xLREJHX01BU0sgfAorCQlTNVBfQ0xLRElWX0NQVTBfQVBMTF9NQVNLKTsKKworCXRtcCB8PSAoKGNsa2Rpdl9jcHUwW2Rpdl9pbmRleF1bMF0gPDwgUzVQX0NMS0RJVl9DUFUwX0NPUkVfU0hJRlQpIHwKKwkJKGNsa2Rpdl9jcHUwW2Rpdl9pbmRleF1bMV0gPDwgUzVQX0NMS0RJVl9DUFUwX0NPUkVNMF9TSElGVCkgfAorCQkoY2xrZGl2X2NwdTBbZGl2X2luZGV4XVsyXSA8PCBTNVBfQ0xLRElWX0NQVTBfQ09SRU0xX1NISUZUKSB8CisJCShjbGtkaXZfY3B1MFtkaXZfaW5kZXhdWzNdIDw8IFM1UF9DTEtESVZfQ1BVMF9QRVJJUEhfU0hJRlQpIHwKKwkJKGNsa2Rpdl9jcHUwW2Rpdl9pbmRleF1bNF0gPDwgUzVQX0NMS0RJVl9DUFUwX0FUQl9TSElGVCkgfAorCQkoY2xrZGl2X2NwdTBbZGl2X2luZGV4XVs1XSA8PCBTNVBfQ0xLRElWX0NQVTBfUENMS0RCR19TSElGVCkgfAorCQkoY2xrZGl2X2NwdTBbZGl2X2luZGV4XVs2XSA8PCBTNVBfQ0xLRElWX0NQVTBfQVBMTF9TSElGVCkpOworCisJX19yYXdfd3JpdGVsKHRtcCwgUzVQX0NMS0RJVl9DUFUpOworCisJZG8geworCQl0bXAgPSBfX3Jhd19yZWFkbChTNVBfQ0xLRElWX1NUQVRDUFUpOworCX0gd2hpbGUgKHRtcCAmIDB4MTExMTExMSk7CisKKwkvKiBDaGFuZ2UgRGl2aWRlciAtIENQVTEgKi8KKworCXRtcCA9IF9fcmF3X3JlYWRsKFM1UF9DTEtESVZfQ1BVMSk7CisKKwl0bXAgJj0gfigoMHg3IDw8IDQpIHwgMHg3KTsKKworCXRtcCB8PSAoKGNsa2Rpdl9jcHUxW2Rpdl9pbmRleF1bMF0gPDwgNCkgfAorCQkoY2xrZGl2X2NwdTFbZGl2X2luZGV4XVsxXSA8PCAwKSk7CisKKwlfX3Jhd193cml0ZWwodG1wLCBTNVBfQ0xLRElWX0NQVTEpOworCisJZG8geworCQl0bXAgPSBfX3Jhd19yZWFkbChTNVBfQ0xLRElWX1NUQVRDUFUxKTsKKwl9IHdoaWxlICh0bXAgJiAweDExKTsKKworCS8qIENoYW5nZSBEaXZpZGVyIC0gRE1DMCAqLworCisJdG1wID0gX19yYXdfcmVhZGwoUzVQX0NMS0RJVl9ETUMwKTsKKworCXRtcCAmPSB+KFM1UF9DTEtESVZfRE1DMF9BQ1BfTUFTSyB8IFM1UF9DTEtESVZfRE1DMF9BQ1BQQ0xLX01BU0sgfAorCQlTNVBfQ0xLRElWX0RNQzBfRFBIWV9NQVNLIHwgUzVQX0NMS0RJVl9ETUMwX0RNQ19NQVNLIHwKKwkJUzVQX0NMS0RJVl9ETUMwX0RNQ0RfTUFTSyB8IFM1UF9DTEtESVZfRE1DMF9ETUNQX01BU0sgfAorCQlTNVBfQ0xLRElWX0RNQzBfQ09QWTJfTUFTSyB8IFM1UF9DTEtESVZfRE1DMF9DT1JFVElfTUFTSyk7CisKKwl0bXAgfD0gKChjbGtkaXZfZG1jMFtkaXZfaW5kZXhdWzBdIDw8IFM1UF9DTEtESVZfRE1DMF9BQ1BfU0hJRlQpIHwKKwkJKGNsa2Rpdl9kbWMwW2Rpdl9pbmRleF1bMV0gPDwgUzVQX0NMS0RJVl9ETUMwX0FDUFBDTEtfU0hJRlQpIHwKKwkJKGNsa2Rpdl9kbWMwW2Rpdl9pbmRleF1bMl0gPDwgUzVQX0NMS0RJVl9ETUMwX0RQSFlfU0hJRlQpIHwKKwkJKGNsa2Rpdl9kbWMwW2Rpdl9pbmRleF1bM10gPDwgUzVQX0NMS0RJVl9ETUMwX0RNQ19TSElGVCkgfAorCQkoY2xrZGl2X2RtYzBbZGl2X2luZGV4XVs0XSA8PCBTNVBfQ0xLRElWX0RNQzBfRE1DRF9TSElGVCkgfAorCQkoY2xrZGl2X2RtYzBbZGl2X2luZGV4XVs1XSA8PCBTNVBfQ0xLRElWX0RNQzBfRE1DUF9TSElGVCkgfAorCQkoY2xrZGl2X2RtYzBbZGl2X2luZGV4XVs2XSA8PCBTNVBfQ0xLRElWX0RNQzBfQ09QWTJfU0hJRlQpIHwKKwkJKGNsa2Rpdl9kbWMwW2Rpdl9pbmRleF1bN10gPDwgUzVQX0NMS0RJVl9ETUMwX0NPUkVUSV9TSElGVCkpOworCisJX19yYXdfd3JpdGVsKHRtcCwgUzVQX0NMS0RJVl9ETUMwKTsKKworCWRvIHsKKwkJdG1wID0gX19yYXdfcmVhZGwoUzVQX0NMS0RJVl9TVEFUX0RNQzApOworCX0gd2hpbGUgKHRtcCAmIDB4MTExMTExMTEpOworCisJLyogQ2hhbmdlIERpdmlkZXIgLSBUT1AgKi8KKworCXRtcCA9IF9fcmF3X3JlYWRsKFM1UF9DTEtESVZfVE9QKTsKKworCXRtcCAmPSB+KFM1UF9DTEtESVZfVE9QX0FDTEsyMDBfTUFTSyB8IFM1UF9DTEtESVZfVE9QX0FDTEsxMDBfTUFTSyB8CisJCVM1UF9DTEtESVZfVE9QX0FDTEsxNjBfTUFTSyB8IFM1UF9DTEtESVZfVE9QX0FDTEsxMzNfTUFTSyB8CisJCVM1UF9DTEtESVZfVE9QX09ORU5BTkRfTUFTSyk7CisKKwl0bXAgfD0gKChjbGtkaXZfdG9wW2Rpdl9pbmRleF1bMF0gPDwgUzVQX0NMS0RJVl9UT1BfQUNMSzIwMF9TSElGVCkgfAorCQkoY2xrZGl2X3RvcFtkaXZfaW5kZXhdWzFdIDw8IFM1UF9DTEtESVZfVE9QX0FDTEsxMDBfU0hJRlQpIHwKKwkJKGNsa2Rpdl90b3BbZGl2X2luZGV4XVsyXSA8PCBTNVBfQ0xLRElWX1RPUF9BQ0xLMTYwX1NISUZUKSB8CisJCShjbGtkaXZfdG9wW2Rpdl9pbmRleF1bM10gPDwgUzVQX0NMS0RJVl9UT1BfQUNMSzEzM19TSElGVCkgfAorCQkoY2xrZGl2X3RvcFtkaXZfaW5kZXhdWzRdIDw8IFM1UF9DTEtESVZfVE9QX09ORU5BTkRfU0hJRlQpKTsKKworCV9fcmF3X3dyaXRlbCh0bXAsIFM1UF9DTEtESVZfVE9QKTsKKworCWRvIHsKKwkJdG1wID0gX19yYXdfcmVhZGwoUzVQX0NMS0RJVl9TVEFUX1RPUCk7CisJfSB3aGlsZSAodG1wICYgMHgxMTExMSk7CisKKwkvKiBDaGFuZ2UgRGl2aWRlciAtIExFRlRCVVMgKi8KKworCXRtcCA9IF9fcmF3X3JlYWRsKFM1UF9DTEtESVZfTEVGVEJVUyk7CisKKwl0bXAgJj0gfihTNVBfQ0xLRElWX0JVU19HRExSX01BU0sgfCBTNVBfQ0xLRElWX0JVU19HUExSX01BU0spOworCisJdG1wIHw9ICgoY2xrZGl2X2xyX2J1c1tkaXZfaW5kZXhdWzBdIDw8IFM1UF9DTEtESVZfQlVTX0dETFJfU0hJRlQpIHwKKwkJKGNsa2Rpdl9scl9idXNbZGl2X2luZGV4XVsxXSA8PCBTNVBfQ0xLRElWX0JVU19HUExSX1NISUZUKSk7CisKKwlfX3Jhd193cml0ZWwodG1wLCBTNVBfQ0xLRElWX0xFRlRCVVMpOworCisJZG8geworCQl0bXAgPSBfX3Jhd19yZWFkbChTNVBfQ0xLRElWX1NUQVRfTEVGVEJVUyk7CisJfSB3aGlsZSAodG1wICYgMHgxMSk7CisKKwkvKiBDaGFuZ2UgRGl2aWRlciAtIFJJR0hUQlVTICovCisKKwl0bXAgPSBfX3Jhd19yZWFkbChTNVBfQ0xLRElWX1JJR0hUQlVTKTsKKworCXRtcCAmPSB+KFM1UF9DTEtESVZfQlVTX0dETFJfTUFTSyB8IFM1UF9DTEtESVZfQlVTX0dQTFJfTUFTSyk7CisKKwl0bXAgfD0gKChjbGtkaXZfbHJfYnVzW2Rpdl9pbmRleF1bMF0gPDwgUzVQX0NMS0RJVl9CVVNfR0RMUl9TSElGVCkgfAorCQkoY2xrZGl2X2xyX2J1c1tkaXZfaW5kZXhdWzFdIDw8IFM1UF9DTEtESVZfQlVTX0dQTFJfU0hJRlQpKTsKKworCV9fcmF3X3dyaXRlbCh0bXAsIFM1UF9DTEtESVZfUklHSFRCVVMpOworCisJZG8geworCQl0bXAgPSBfX3Jhd19yZWFkbChTNVBfQ0xLRElWX1NUQVRfUklHSFRCVVMpOworCX0gd2hpbGUgKHRtcCAmIDB4MTEpOworfQorCitzdGF0aWMgdm9pZCBzNXB2MzEwX3NldF9hcGxsKHVuc2lnbmVkIGludCBpbmRleCkKK3sKKwl1bnNpZ25lZCBpbnQgdG1wOworCisJLyogMS4gTVVYX0NPUkVfU0VMID0gTVBMTCwgQVJNQ0xLIHVzZXMgTVBMTCBmb3IgbG9jayB0aW1lICovCisJY2xrX3NldF9wYXJlbnQobW91dGNvcmUsIG1vdXRfbXBsbCk7CisKKwlkbyB7CisJCXRtcCA9IChfX3Jhd19yZWFkbChTNVBfQ0xLTVVYX1NUQVRDUFUpCisJCQk+PiBTNVBfQ0xLU1JDX0NQVV9NVVhDT1JFX1NISUZUKTsKKwkJdG1wICY9IDB4NzsKKwl9IHdoaWxlICh0bXAgIT0gMHgyKTsKKworCS8qIDIuIFNldCBBUExMIExvY2sgdGltZSAqLworCV9fcmF3X3dyaXRlbChTNVBfQVBMTF9MT0NLVElNRSwgUzVQX0FQTExfTE9DSyk7CisKKwkvKiAzLiBDaGFuZ2UgUExMIFBNUyB2YWx1ZXMgKi8KKwl0bXAgPSBfX3Jhd19yZWFkbChTNVBfQVBMTF9DT04wKTsKKwl0bXAgJj0gfigoMHgzZmYgPDwgMTYpIHwgKDB4M2YgPDwgOCkgfCAoMHg3IDw8IDApKTsKKwl0bXAgfD0gczVwdjMxMF9hcGxsX3Btc190YWJsZVtpbmRleF07CisJX19yYXdfd3JpdGVsKHRtcCwgUzVQX0FQTExfQ09OMCk7CisKKwkvKiA0LiB3YWl0X2xvY2tfdGltZSAqLworCWRvIHsKKwkJdG1wID0gX19yYXdfcmVhZGwoUzVQX0FQTExfQ09OMCk7CisJfSB3aGlsZSAoISh0bXAgJiAoMHgxIDw8IFM1UF9BUExMQ09OMF9MT0NLRURfU0hJRlQpKSk7CisKKwkvKiA1LiBNVVhfQ09SRV9TRUwgPSBBUExMICovCisJY2xrX3NldF9wYXJlbnQobW91dGNvcmUsIG1vdXRfYXBsbCk7CisKKwlkbyB7CisJCXRtcCA9IF9fcmF3X3JlYWRsKFM1UF9DTEtNVVhfU1RBVENQVSk7CisJCXRtcCAmPSBTNVBfQ0xLTVVYX1NUQVRDUFVfTVVYQ09SRV9NQVNLOworCX0gd2hpbGUgKHRtcCAhPSAoMHgxIDw8IFM1UF9DTEtTUkNfQ1BVX01VWENPUkVfU0hJRlQpKTsKK30KKworc3RhdGljIHZvaWQgczVwdjMxMF9zZXRfZnJlcXVlbmN5KHVuc2lnbmVkIGludCBvbGRfaW5kZXgsIHVuc2lnbmVkIGludCBuZXdfaW5kZXgpCit7CisJdW5zaWduZWQgaW50IHRtcDsKKworCWlmIChvbGRfaW5kZXggPiBuZXdfaW5kZXgpIHsKKwkJLyogVGhlIGZyZXF1ZW5jeSBjaGFuZ2luZyB0byBMMCBuZWVkcyB0byBjaGFuZ2UgYXBsbCAqLworCQlpZiAoZnJlcXMubmV3ID09IHM1cHYzMTBfZnJlcV90YWJsZVtMMF0uZnJlcXVlbmN5KSB7CisJCQkvKiAxLiBDaGFuZ2UgdGhlIHN5c3RlbSBjbG9jayBkaXZpZGVyIHZhbHVlcyAqLworCQkJczVwdjMxMF9zZXRfY2xrZGl2KG5ld19pbmRleCk7CisKKwkJCS8qIDIuIENoYW5nZSB0aGUgYXBsbCBtLHAscyB2YWx1ZSAqLworCQkJczVwdjMxMF9zZXRfYXBsbChuZXdfaW5kZXgpOworCQl9IGVsc2UgeworCQkJLyogMS4gQ2hhbmdlIHRoZSBzeXN0ZW0gY2xvY2sgZGl2aWRlciB2YWx1ZXMgKi8KKwkJCXM1cHYzMTBfc2V0X2Nsa2RpdihuZXdfaW5kZXgpOworCisJCQkvKiAyLiBDaGFuZ2UganVzdCBzIHZhbHVlIGluIGFwbGwgbSxwLHMgdmFsdWUgKi8KKwkJCXRtcCA9IF9fcmF3X3JlYWRsKFM1UF9BUExMX0NPTjApOworCQkJdG1wICY9IH4oMHg3IDw8IDApOworCQkJdG1wIHw9IChzNXB2MzEwX2FwbGxfcG1zX3RhYmxlW25ld19pbmRleF0gJiAweDcpOworCQkJX19yYXdfd3JpdGVsKHRtcCwgUzVQX0FQTExfQ09OMCk7CisJCX0KKwl9CisKKwllbHNlIGlmIChvbGRfaW5kZXggPCBuZXdfaW5kZXgpIHsKKwkJLyogVGhlIGZyZXF1ZW5jeSBjaGFuZ2luZyBmcm9tIEwwIG5lZWRzIHRvIGNoYW5nZSBhcGxsICovCisJCWlmIChmcmVxcy5vbGQgPT0gczVwdjMxMF9mcmVxX3RhYmxlW0wwXS5mcmVxdWVuY3kpIHsKKwkJCS8qIDEuIENoYW5nZSB0aGUgYXBsbCBtLHAscyB2YWx1ZSAqLworCQkJczVwdjMxMF9zZXRfYXBsbChuZXdfaW5kZXgpOworCisJCQkvKiAyLiBDaGFuZ2UgdGhlIHN5c3RlbSBjbG9jayBkaXZpZGVyIHZhbHVlcyAqLworCQkJczVwdjMxMF9zZXRfY2xrZGl2KG5ld19pbmRleCk7CisJCX0gZWxzZSB7CisJCQkvKiAxLiBDaGFuZ2UganVzdCBzIHZhbHVlIGluIGFwbGwgbSxwLHMgdmFsdWUgKi8KKwkJCXRtcCA9IF9fcmF3X3JlYWRsKFM1UF9BUExMX0NPTjApOworCQkJdG1wICY9IH4oMHg3IDw8IDApOworCQkJdG1wIHw9IChzNXB2MzEwX2FwbGxfcG1zX3RhYmxlW25ld19pbmRleF0gJiAweDcpOworCQkJX19yYXdfd3JpdGVsKHRtcCwgUzVQX0FQTExfQ09OMCk7CisKKwkJCS8qIDIuIENoYW5nZSB0aGUgc3lzdGVtIGNsb2NrIGRpdmlkZXIgdmFsdWVzICovCisJCQlzNXB2MzEwX3NldF9jbGtkaXYobmV3X2luZGV4KTsKKwkJfQorCX0KK30KKworc3RhdGljIGludCBzNXB2MzEwX3RhcmdldChzdHJ1Y3QgY3B1ZnJlcV9wb2xpY3kgKnBvbGljeSwKKwkJCSAgdW5zaWduZWQgaW50IHRhcmdldF9mcmVxLAorCQkJICB1bnNpZ25lZCBpbnQgcmVsYXRpb24pCit7CisJdW5zaWduZWQgaW50IGluZGV4LCBvbGRfaW5kZXg7CisJdW5zaWduZWQgaW50IGFybV92b2x0LCBpbnRfdm9sdDsKKworCWZyZXFzLm9sZCA9IHM1cHYzMTBfZ2V0c3BlZWQocG9saWN5LT5jcHUpOworCisJaWYgKGNwdWZyZXFfZnJlcXVlbmN5X3RhYmxlX3RhcmdldChwb2xpY3ksIHM1cHYzMTBfZnJlcV90YWJsZSwKKwkJCQkJICAgZnJlcXMub2xkLCByZWxhdGlvbiwgJm9sZF9pbmRleCkpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKGNwdWZyZXFfZnJlcXVlbmN5X3RhYmxlX3RhcmdldChwb2xpY3ksIHM1cHYzMTBfZnJlcV90YWJsZSwKKwkJCQkJICAgdGFyZ2V0X2ZyZXEsIHJlbGF0aW9uLCAmaW5kZXgpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWZyZXFzLm5ldyA9IHM1cHYzMTBfZnJlcV90YWJsZVtpbmRleF0uZnJlcXVlbmN5OworCWZyZXFzLmNwdSA9IHBvbGljeS0+Y3B1OworCisJaWYgKGZyZXFzLm5ldyA9PSBmcmVxcy5vbGQpCisJCXJldHVybiAwOworCisJLyogZ2V0IHRoZSB2b2x0YWdlIHZhbHVlICovCisJYXJtX3ZvbHQgPSBzNXB2MzEwX3ZvbHRfdGFibGVbaW5kZXhdLmFybV92b2x0OworCWludF92b2x0ID0gczVwdjMxMF92b2x0X3RhYmxlW2luZGV4XS5pbnRfdm9sdDsKKworCWNwdWZyZXFfbm90aWZ5X3RyYW5zaXRpb24oJmZyZXFzLCBDUFVGUkVRX1BSRUNIQU5HRSk7CisKKwkvKiBjb250cm9sIHJlZ3VsYXRvciAqLworCWlmIChmcmVxcy5uZXcgPiBmcmVxcy5vbGQpIHsKKwkJLyogVm9sdGFnZSB1cCAqLworI2lmZGVmIENPTkZJR19SRUdVTEFUT1IKKwkJcmVndWxhdG9yX3NldF92b2x0YWdlKGFybV9yZWd1bGF0b3IsIGFybV92b2x0LCBhcm1fdm9sdCk7CisJCXJlZ3VsYXRvcl9zZXRfdm9sdGFnZShpbnRfcmVndWxhdG9yLCBpbnRfdm9sdCwgaW50X3ZvbHQpOworI2VuZGlmCisJfQorCisJLyogQ2xvY2sgQ29uZmlndXJhdGlvbiBQcm9jZWR1cmUgKi8KKwlzNXB2MzEwX3NldF9mcmVxdWVuY3kob2xkX2luZGV4LCBpbmRleCk7CisKKwkvKiBjb250cm9sIHJlZ3VsYXRvciAqLworCWlmIChmcmVxcy5uZXcgPCBmcmVxcy5vbGQpIHsKKwkJLyogVm9sdGFnZSBkb3duICovCisjaWZkZWYgQ09ORklHX1JFR1VMQVRPUgorCQlyZWd1bGF0b3Jfc2V0X3ZvbHRhZ2UoYXJtX3JlZ3VsYXRvciwgYXJtX3ZvbHQsIGFybV92b2x0KTsKKwkJcmVndWxhdG9yX3NldF92b2x0YWdlKGludF9yZWd1bGF0b3IsIGludF92b2x0LCBpbnRfdm9sdCk7CisjZW5kaWYKKwl9CisKKwljcHVmcmVxX25vdGlmeV90cmFuc2l0aW9uKCZmcmVxcywgQ1BVRlJFUV9QT1NUQ0hBTkdFKTsKKworCXJldHVybiAwOworfQorCisjaWZkZWYgQ09ORklHX1BNCitzdGF0aWMgaW50IHM1cHYzMTBfY3B1ZnJlcV9zdXNwZW5kKHN0cnVjdCBjcHVmcmVxX3BvbGljeSAqcG9saWN5LAorCQkJCSAgIHBtX21lc3NhZ2VfdCBwbXNnKQoreworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHM1cHYzMTBfY3B1ZnJlcV9yZXN1bWUoc3RydWN0IGNwdWZyZXFfcG9saWN5ICpwb2xpY3kpCit7CisJcmV0dXJuIDA7Cit9CisjZW5kaWYKKworc3RhdGljIGludCBzNXB2MzEwX2NwdWZyZXFfY3B1X2luaXQoc3RydWN0IGNwdWZyZXFfcG9saWN5ICpwb2xpY3kpCit7CisJcG9saWN5LT5jdXIgPSBwb2xpY3ktPm1pbiA9IHBvbGljeS0+bWF4ID0gczVwdjMxMF9nZXRzcGVlZChwb2xpY3ktPmNwdSk7CisKKwljcHVmcmVxX2ZyZXF1ZW5jeV90YWJsZV9nZXRfYXR0cihzNXB2MzEwX2ZyZXFfdGFibGUsIHBvbGljeS0+Y3B1KTsKKworCS8qIHNldCB0aGUgdHJhbnNpdGlvbiBsYXRlbmN5IHZhbHVlICovCisJcG9saWN5LT5jcHVpbmZvLnRyYW5zaXRpb25fbGF0ZW5jeSA9IDEwMDAwMDsKKworCS8qCisJICogUzVQVjMxMCBtdWx0aS1jb3JlIHByb2Nlc3NvcnMgaGFzIDIgY29yZXMKKwkgKiB0aGF0IHRoZSBmcmVxdWVuY3kgY2Fubm90IGJlIHNldCBpbmRlcGVuZGVudGx5LgorCSAqIEVhY2ggY3B1IGlzIGJvdW5kIHRvIHRoZSBzYW1lIHNwZWVkLgorCSAqIFNvIHRoZSBhZmZlY3RlZCBjcHUgaXMgYWxsIG9mIHRoZSBjcHVzLgorCSAqLworCWNwdW1hc2tfc2V0YWxsKHBvbGljeS0+Y3B1cyk7CisKKwlyZXR1cm4gY3B1ZnJlcV9mcmVxdWVuY3lfdGFibGVfY3B1aW5mbyhwb2xpY3ksIHM1cHYzMTBfZnJlcV90YWJsZSk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgY3B1ZnJlcV9kcml2ZXIgczVwdjMxMF9kcml2ZXIgPSB7CisJLmZsYWdzCQk9IENQVUZSRVFfU1RJQ0tZLAorCS52ZXJpZnkJCT0gczVwdjMxMF92ZXJpZnlfc3BlZWQsCisJLnRhcmdldAkJPSBzNXB2MzEwX3RhcmdldCwKKwkuZ2V0CQk9IHM1cHYzMTBfZ2V0c3BlZWQsCisJLmluaXQJCT0gczVwdjMxMF9jcHVmcmVxX2NwdV9pbml0LAorCS5uYW1lCQk9ICJzNXB2MzEwX2NwdWZyZXEiLAorI2lmZGVmIENPTkZJR19QTQorCS5zdXNwZW5kCT0gczVwdjMxMF9jcHVmcmVxX3N1c3BlbmQsCisJLnJlc3VtZQkJPSBzNXB2MzEwX2NwdWZyZXFfcmVzdW1lLAorI2VuZGlmCit9OworCitzdGF0aWMgaW50IF9faW5pdCBzNXB2MzEwX2NwdWZyZXFfaW5pdCh2b2lkKQoreworCWNwdV9jbGsgPSBjbGtfZ2V0KE5VTEwsICJhcm1jbGsiKTsKKwlpZiAoSVNfRVJSKGNwdV9jbGspKQorCQlyZXR1cm4gUFRSX0VSUihjcHVfY2xrKTsKKworCW1vdXRjb3JlID0gY2xrX2dldChOVUxMLCAibW91dGNvcmUiKTsKKwlpZiAoSVNfRVJSKG1vdXRjb3JlKSkKKwkJZ290byBvdXQ7CisKKwltb3V0X21wbGwgPSBjbGtfZ2V0KE5VTEwsICJtb3V0X21wbGwiKTsKKwlpZiAoSVNfRVJSKG1vdXRfbXBsbCkpCisJCWdvdG8gb3V0OworCisJbW91dF9hcGxsID0gY2xrX2dldChOVUxMLCAibW91dF9hcGxsIik7CisJaWYgKElTX0VSUihtb3V0X2FwbGwpKQorCQlnb3RvIG91dDsKKworI2lmZGVmIENPTkZJR19SRUdVTEFUT1IKKwlhcm1fcmVndWxhdG9yID0gcmVndWxhdG9yX2dldChOVUxMLCAidmRkX2FybSIpOworCWlmIChJU19FUlIoYXJtX3JlZ3VsYXRvcikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJmYWlsZWQgdG8gZ2V0IHJlc291cmNlICVzXG4iLCAidmRkX2FybSIpOworCQlnb3RvIG91dDsKKwl9CisKKwlpbnRfcmVndWxhdG9yID0gcmVndWxhdG9yX2dldChOVUxMLCAidmRkX2ludCIpOworCWlmIChJU19FUlIoaW50X3JlZ3VsYXRvcikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJmYWlsZWQgdG8gZ2V0IHJlc291cmNlICVzXG4iLCAidmRkX2ludCIpOworCQlnb3RvIG91dDsKKwl9CisjZW5kaWYKKworCS8qCisJICogQ2hlY2sgRFJBTSB0eXBlLgorCSAqIEJlY2F1c2UgRFZGUyBsZXZlbCBpcyBkaWZmZXJlbnQgYWNjb3JkaW5nIHRvIERSQU0gdHlwZS4KKwkgKi8KKwltZW10eXBlID0gX19yYXdfcmVhZGwoUzVQX1ZBX0RNQzAgKyBTNVBfRE1DMF9NRU1DT05fT0ZGU0VUKTsKKwltZW10eXBlID0gKG1lbXR5cGUgPj4gUzVQX0RNQzBfTUVNVFlQRV9TSElGVCk7CisJbWVtdHlwZSAmPSBTNVBfRE1DMF9NRU1UWVBFX01BU0s7CisKKwlpZiAoKG1lbXR5cGUgPCBERFIyKSAmJiAobWVtdHlwZSA+IEREUjMpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiJXM6IHdyb25nIG1lbXR5cGU9IDB4JXhcbiIsIF9fZnVuY19fLCBtZW10eXBlKTsKKwkJZ290byBvdXQ7CisJfSBlbHNlIHsKKwkJcHJpbnRrKEtFUk5fREVCVUcgIiVzOiBtZW10eXBlPSAweCV4XG4iLCBfX2Z1bmNfXywgbWVtdHlwZSk7CisJfQorCisJcmV0dXJuIGNwdWZyZXFfcmVnaXN0ZXJfZHJpdmVyKCZzNXB2MzEwX2RyaXZlcik7CisKK291dDoKKwlpZiAoIUlTX0VSUihjcHVfY2xrKSkKKwkJY2xrX3B1dChjcHVfY2xrKTsKKworCWlmICghSVNfRVJSKG1vdXRjb3JlKSkKKwkJY2xrX3B1dChtb3V0Y29yZSk7CisKKwlpZiAoIUlTX0VSUihtb3V0X21wbGwpKQorCQljbGtfcHV0KG1vdXRfbXBsbCk7CisKKwlpZiAoIUlTX0VSUihtb3V0X2FwbGwpKQorCQljbGtfcHV0KG1vdXRfYXBsbCk7CisKKyNpZmRlZiBDT05GSUdfUkVHVUxBVE9SCisJaWYgKCFJU19FUlIoYXJtX3JlZ3VsYXRvcikpCisJCXJlZ3VsYXRvcl9wdXQoYXJtX3JlZ3VsYXRvcik7CisKKwlpZiAoIUlTX0VSUihpbnRfcmVndWxhdG9yKSkKKwkJcmVndWxhdG9yX3B1dChpbnRfcmVndWxhdG9yKTsKKyNlbmRpZgorCisJcHJpbnRrKEtFUk5fRVJSICIlczogZmFpbGVkIGluaXRpYWxpemF0aW9uXG4iLCBfX2Z1bmNfXyk7CisKKwlyZXR1cm4gLUVJTlZBTDsKK30KK2xhdGVfaW5pdGNhbGwoczVwdjMxMF9jcHVmcmVxX2luaXQpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2Rldi1wZC5jIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2Rldi1wZC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU4YTUwYzIKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL2FybS9tYWNoLXM1cHYzMTAvZGV2LXBkLmMKQEAgLTAsMCArMSwxMzkgQEAKKy8qIGxpbnV4L2FyY2gvYXJtL21hY2gtczVwdjMxMC9kZXYtcGQuYworICoKKyAqIENvcHlyaWdodCAoYykgMjAxMCBTYW1zdW5nIEVsZWN0cm9uaWNzIENvLiwgTHRkLgorICoJCWh0dHA6Ly93d3cuc2Ftc3VuZy5jb20KKyAqCisgKiBTNVBWMzEwIC0gUG93ZXIgRG9tYWluIHN1cHBvcnQKKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorKi8KKworI2luY2x1ZGUgPGxpbnV4L2lvLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKworI2luY2x1ZGUgPG1hY2gvcmVncy1wbXUuaD4KKworI2luY2x1ZGUgPHBsYXQvcGQuaD4KKworc3RhdGljIGludCBzNXB2MzEwX3BkX2VuYWJsZShzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHNhbXN1bmdfcGRfaW5mbyAqcGRhdGEgPSAgZGV2LT5wbGF0Zm9ybV9kYXRhOworCXUzMiB0aW1lb3V0OworCisJX19yYXdfd3JpdGVsKFM1UF9JTlRfTE9DQUxfUFdSX0VOLCBwZGF0YS0+YmFzZSk7CisKKwkvKiBXYWl0IG1heCAxbXMgKi8KKwl0aW1lb3V0ID0gMTA7CisJd2hpbGUgKChfX3Jhd19yZWFkbChwZGF0YS0+YmFzZSArIDB4NCkgJiBTNVBfSU5UX0xPQ0FMX1BXUl9FTikKKwkJIT0gUzVQX0lOVF9MT0NBTF9QV1JfRU4pIHsKKwkJaWYgKHRpbWVvdXQgPT0gMCkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJQb3dlciBkb21haW4gJXMgZW5hYmxlIGZhaWxlZC5cbiIsCisJCQkJZGV2X25hbWUoZGV2KSk7CisJCQlyZXR1cm4gLUVUSU1FRE9VVDsKKwkJfQorCQl0aW1lb3V0LS07CisJCXVkZWxheSgxMDApOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHM1cHYzMTBfcGRfZGlzYWJsZShzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHNhbXN1bmdfcGRfaW5mbyAqcGRhdGEgPSAgZGV2LT5wbGF0Zm9ybV9kYXRhOworCXUzMiB0aW1lb3V0OworCisJX19yYXdfd3JpdGVsKDAsIHBkYXRhLT5iYXNlKTsKKworCS8qIFdhaXQgbWF4IDFtcyAqLworCXRpbWVvdXQgPSAxMDsKKwl3aGlsZSAoX19yYXdfcmVhZGwocGRhdGEtPmJhc2UgKyAweDQpICYgUzVQX0lOVF9MT0NBTF9QV1JfRU4pIHsKKwkJaWYgKHRpbWVvdXQgPT0gMCkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJQb3dlciBkb21haW4gJXMgZGlzYWJsZSBmYWlsZWQuXG4iLAorCQkJCWRldl9uYW1lKGRldikpOworCQkJcmV0dXJuIC1FVElNRURPVVQ7CisJCX0KKwkJdGltZW91dC0tOworCQl1ZGVsYXkoMTAwKTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RydWN0IHBsYXRmb3JtX2RldmljZSBzNXB2MzEwX2RldmljZV9wZFtdID0geworCXsKKwkJLm5hbWUJCT0gInNhbXN1bmctcGQiLAorCQkuaWQJCT0gMCwKKwkJLmRldiA9IHsKKwkJCS5wbGF0Zm9ybV9kYXRhID0gJihzdHJ1Y3Qgc2Ftc3VuZ19wZF9pbmZvKSB7CisJCQkJLmVuYWJsZQkJPSBzNXB2MzEwX3BkX2VuYWJsZSwKKwkJCQkuZGlzYWJsZQk9IHM1cHYzMTBfcGRfZGlzYWJsZSwKKwkJCQkuYmFzZQkJPSBTNVBfUE1VX01GQ19DT05GLAorCQkJfSwKKwkJfSwKKwl9LCB7CisJCS5uYW1lCQk9ICJzYW1zdW5nLXBkIiwKKwkJLmlkCQk9IDEsCisJCS5kZXYgPSB7CisJCQkucGxhdGZvcm1fZGF0YSA9ICYoc3RydWN0IHNhbXN1bmdfcGRfaW5mbykgeworCQkJCS5lbmFibGUJCT0gczVwdjMxMF9wZF9lbmFibGUsCisJCQkJLmRpc2FibGUJPSBzNXB2MzEwX3BkX2Rpc2FibGUsCisJCQkJLmJhc2UJCT0gUzVQX1BNVV9HM0RfQ09ORiwKKwkJCX0sCisJCX0sCisJfSwgeworCQkubmFtZQkJPSAic2Ftc3VuZy1wZCIsCisJCS5pZAkJPSAyLAorCQkuZGV2ID0geworCQkJLnBsYXRmb3JtX2RhdGEgPSAmKHN0cnVjdCBzYW1zdW5nX3BkX2luZm8pIHsKKwkJCQkuZW5hYmxlCQk9IHM1cHYzMTBfcGRfZW5hYmxlLAorCQkJCS5kaXNhYmxlCT0gczVwdjMxMF9wZF9kaXNhYmxlLAorCQkJCS5iYXNlCQk9IFM1UF9QTVVfTENEMF9DT05GLAorCQkJfSwKKwkJfSwKKwl9LCB7CisJCS5uYW1lCQk9ICJzYW1zdW5nLXBkIiwKKwkJLmlkCQk9IDMsCisJCS5kZXYgPSB7CisJCQkucGxhdGZvcm1fZGF0YSA9ICYoc3RydWN0IHNhbXN1bmdfcGRfaW5mbykgeworCQkJCS5lbmFibGUJCT0gczVwdjMxMF9wZF9lbmFibGUsCisJCQkJLmRpc2FibGUJPSBzNXB2MzEwX3BkX2Rpc2FibGUsCisJCQkJLmJhc2UJCT0gUzVQX1BNVV9MQ0QxX0NPTkYsCisJCQl9LAorCQl9LAorCX0sIHsKKwkJLm5hbWUJCT0gInNhbXN1bmctcGQiLAorCQkuaWQJCT0gNCwKKwkJLmRldiA9IHsKKwkJCS5wbGF0Zm9ybV9kYXRhID0gJihzdHJ1Y3Qgc2Ftc3VuZ19wZF9pbmZvKSB7CisJCQkJLmVuYWJsZQkJPSBzNXB2MzEwX3BkX2VuYWJsZSwKKwkJCQkuZGlzYWJsZQk9IHM1cHYzMTBfcGRfZGlzYWJsZSwKKwkJCQkuYmFzZQkJPSBTNVBfUE1VX1RWX0NPTkYsCisJCQl9LAorCQl9LAorCX0sIHsKKwkJLm5hbWUJCT0gInNhbXN1bmctcGQiLAorCQkuaWQJCT0gNSwKKwkJLmRldiA9IHsKKwkJCS5wbGF0Zm9ybV9kYXRhID0gJihzdHJ1Y3Qgc2Ftc3VuZ19wZF9pbmZvKSB7CisJCQkJLmVuYWJsZQkJPSBzNXB2MzEwX3BkX2VuYWJsZSwKKwkJCQkuZGlzYWJsZQk9IHM1cHYzMTBfcGRfZGlzYWJsZSwKKwkJCQkuYmFzZQkJPSBTNVBfUE1VX0NBTV9DT05GLAorCQkJfSwKKwkJfSwKKwl9LCB7CisJCS5uYW1lCQk9ICJzYW1zdW5nLXBkIiwKKwkJLmlkCQk9IDYsCisJCS5kZXYgPSB7CisJCQkucGxhdGZvcm1fZGF0YSA9ICYoc3RydWN0IHNhbXN1bmdfcGRfaW5mbykgeworCQkJCS5lbmFibGUJCT0gczVwdjMxMF9wZF9lbmFibGUsCisJCQkJLmRpc2FibGUJPSBzNXB2MzEwX3BkX2Rpc2FibGUsCisJCQkJLmJhc2UJCT0gUzVQX1BNVV9HUFNfQ09ORiwKKwkJCX0sCisJCX0sCisJfSwKK307CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cHYzMTAvZGV2LXN5c21tdS5jIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2Rldi1zeXNtbXUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lMWJiMjAwCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2Rldi1zeXNtbXUuYwpAQCAtMCwwICsxLDE4NyBAQAorLyogbGludXgvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2Rldi1zeXNtbXUuYworICoKKyAqIENvcHlyaWdodCAoYykgMjAxMCBTYW1zdW5nIEVsZWN0cm9uaWNzIENvLiwgTHRkLgorICoJCWh0dHA6Ly93d3cuc2Ftc3VuZy5jb20KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICovCisKKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgorCisjaW5jbHVkZSA8bWFjaC9tYXAuaD4KKyNpbmNsdWRlIDxtYWNoL2lycXMuaD4KKworc3RhdGljIHN0cnVjdCByZXNvdXJjZSBzNXB2MzEwX3N5c21tdV9yZXNvdXJjZVtdID0geworCVswXSA9IHsKKwkJLnN0YXJ0CT0gUzVQVjMxMF9QQV9TWVNNTVVfTURNQSwKKwkJLmVuZAk9IFM1UFYzMTBfUEFfU1lTTU1VX01ETUEgKyBTWl82NEsgLSAxLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX01FTSwKKwl9LAorCVsxXSA9IHsKKwkJLnN0YXJ0CT0gSVJRX1NZU01NVV9NRE1BMF8wLAorCQkuZW5kCT0gSVJRX1NZU01NVV9NRE1BMF8wLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorCVsyXSA9IHsKKwkJLnN0YXJ0CT0gUzVQVjMxMF9QQV9TWVNNTVVfU1NTLAorCQkuZW5kCT0gUzVQVjMxMF9QQV9TWVNNTVVfU1NTICsgU1pfNjRLIC0gMSwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9NRU0sCisJfSwKKwlbM10gPSB7CisJCS5zdGFydAk9IElSUV9TWVNNTVVfU1NTXzAsCisJCS5lbmQJPSBJUlFfU1lTTU1VX1NTU18wLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorCVs0XSA9IHsKKwkJLnN0YXJ0CT0gUzVQVjMxMF9QQV9TWVNNTVVfRklNQzAsCisJCS5lbmQJPSBTNVBWMzEwX1BBX1NZU01NVV9GSU1DMCArIFNaXzY0SyAtIDEsCisJCS5mbGFncwk9IElPUkVTT1VSQ0VfTUVNLAorCX0sCisJWzVdID0geworCQkuc3RhcnQJPSBJUlFfU1lTTU1VX0ZJTUMwXzAsCisJCS5lbmQJPSBJUlFfU1lTTU1VX0ZJTUMwXzAsCisJCS5mbGFncwk9IElPUkVTT1VSQ0VfSVJRLAorCX0sCisJWzZdID0geworCQkuc3RhcnQJPSBTNVBWMzEwX1BBX1NZU01NVV9GSU1DMSwKKwkJLmVuZAk9IFM1UFYzMTBfUEFfU1lTTU1VX0ZJTUMxICsgU1pfNjRLIC0gMSwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9NRU0sCisJfSwKKwlbN10gPSB7CisJCS5zdGFydAk9IElSUV9TWVNNTVVfRklNQzFfMCwKKwkJLmVuZAk9IElSUV9TWVNNTVVfRklNQzFfMCwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwlbOF0gPSB7CisJCS5zdGFydAk9IFM1UFYzMTBfUEFfU1lTTU1VX0ZJTUMyLAorCQkuZW5kCT0gUzVQVjMxMF9QQV9TWVNNTVVfRklNQzIgKyBTWl82NEsgLSAxLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX01FTSwKKwl9LAorCVs5XSA9IHsKKwkJLnN0YXJ0CT0gSVJRX1NZU01NVV9GSU1DMl8wLAorCQkuZW5kCT0gSVJRX1NZU01NVV9GSU1DMl8wLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorCVsxMF0gPSB7CisJCS5zdGFydAk9IFM1UFYzMTBfUEFfU1lTTU1VX0ZJTUMzLAorCQkuZW5kCT0gUzVQVjMxMF9QQV9TWVNNTVVfRklNQzMgKyBTWl82NEsgLSAxLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX01FTSwKKwl9LAorCVsxMV0gPSB7CisJCS5zdGFydAk9IElSUV9TWVNNTVVfRklNQzNfMCwKKwkJLmVuZAk9IElSUV9TWVNNTVVfRklNQzNfMCwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwlbMTJdID0geworCQkuc3RhcnQJPSBTNVBWMzEwX1BBX1NZU01NVV9KUEVHLAorCQkuZW5kCT0gUzVQVjMxMF9QQV9TWVNNTVVfSlBFRyArIFNaXzY0SyAtIDEsCisJCS5mbGFncwk9IElPUkVTT1VSQ0VfTUVNLAorCX0sCisJWzEzXSA9IHsKKwkJLnN0YXJ0CT0gSVJRX1NZU01NVV9KUEVHXzAsCisJCS5lbmQJPSBJUlFfU1lTTU1VX0pQRUdfMCwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwlbMTRdID0geworCQkuc3RhcnQJPSBTNVBWMzEwX1BBX1NZU01NVV9GSU1EMCwKKwkJLmVuZAk9IFM1UFYzMTBfUEFfU1lTTU1VX0ZJTUQwICsgU1pfNjRLIC0gMSwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9NRU0sCisJfSwKKwlbMTVdID0geworCQkuc3RhcnQJPSBJUlFfU1lTTU1VX0xDRDBfTTBfMCwKKwkJLmVuZAk9IElSUV9TWVNNTVVfTENEMF9NMF8wLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorCVsxNl0gPSB7CisJCS5zdGFydAk9IFM1UFYzMTBfUEFfU1lTTU1VX0ZJTUQxLAorCQkuZW5kCT0gUzVQVjMxMF9QQV9TWVNNTVVfRklNRDEgKyBTWl82NEsgLSAxLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX01FTSwKKwl9LAorCVsxN10gPSB7CisJCS5zdGFydAk9IElSUV9TWVNNTVVfTENEMV9NMV8wLAorCQkuZW5kCT0gSVJRX1NZU01NVV9MQ0QxX00xXzAsCisJCS5mbGFncwk9IElPUkVTT1VSQ0VfSVJRLAorCX0sCisJWzE4XSA9IHsKKwkJLnN0YXJ0CT0gUzVQVjMxMF9QQV9TWVNNTVVfUENJZSwKKwkJLmVuZAk9IFM1UFYzMTBfUEFfU1lTTU1VX1BDSWUgKyBTWl82NEsgLSAxLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX01FTSwKKwl9LAorCVsxOV0gPSB7CisJCS5zdGFydAk9IElSUV9TWVNNTVVfUENJRV8wLAorCQkuZW5kCT0gSVJRX1NZU01NVV9QQ0lFXzAsCisJCS5mbGFncwk9IElPUkVTT1VSQ0VfSVJRLAorCX0sCisJWzIwXSA9IHsKKwkJLnN0YXJ0CT0gUzVQVjMxMF9QQV9TWVNNTVVfRzJELAorCQkuZW5kCT0gUzVQVjMxMF9QQV9TWVNNTVVfRzJEICsgU1pfNjRLIC0gMSwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9NRU0sCisJfSwKKwlbMjFdID0geworCQkuc3RhcnQJPSBJUlFfU1lTTU1VXzJEXzAsCisJCS5lbmQJPSBJUlFfU1lTTU1VXzJEXzAsCisJCS5mbGFncwk9IElPUkVTT1VSQ0VfSVJRLAorCX0sCisJWzIyXSA9IHsKKwkJLnN0YXJ0CT0gUzVQVjMxMF9QQV9TWVNNTVVfUk9UQVRPUiwKKwkJLmVuZAk9IFM1UFYzMTBfUEFfU1lTTU1VX1JPVEFUT1IgKyBTWl82NEsgLSAxLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX01FTSwKKwl9LAorCVsyM10gPSB7CisJCS5zdGFydAk9IElSUV9TWVNNTVVfUk9UQVRPUl8wLAorCQkuZW5kCT0gSVJRX1NZU01NVV9ST1RBVE9SXzAsCisJCS5mbGFncwk9IElPUkVTT1VSQ0VfSVJRLAorCX0sCisJWzI0XSA9IHsKKwkJLnN0YXJ0CT0gUzVQVjMxMF9QQV9TWVNNTVVfTURNQTIsCisJCS5lbmQJPSBTNVBWMzEwX1BBX1NZU01NVV9NRE1BMiArIFNaXzY0SyAtIDEsCisJCS5mbGFncwk9IElPUkVTT1VSQ0VfTUVNLAorCX0sCisJWzI1XSA9IHsKKwkJLnN0YXJ0CT0gSVJRX1NZU01NVV9NRE1BMV8wLAorCQkuZW5kCT0gSVJRX1NZU01NVV9NRE1BMV8wLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorCVsyNl0gPSB7CisJCS5zdGFydAk9IFM1UFYzMTBfUEFfU1lTTU1VX1RWLAorCQkuZW5kCT0gUzVQVjMxMF9QQV9TWVNNTVVfVFYgKyBTWl82NEsgLSAxLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX01FTSwKKwl9LAorCVsyN10gPSB7CisJCS5zdGFydAk9IElSUV9TWVNNTVVfVFZfTTBfMCwKKwkJLmVuZAk9IElSUV9TWVNNTVVfVFZfTTBfMCwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwlbMjhdID0geworCQkuc3RhcnQJPSBTNVBWMzEwX1BBX1NZU01NVV9NRkNfTCwKKwkJLmVuZAk9IFM1UFYzMTBfUEFfU1lTTU1VX01GQ19MICsgU1pfNjRLIC0gMSwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9NRU0sCisJfSwKKwlbMjldID0geworCQkuc3RhcnQJPSBJUlFfU1lTTU1VX01GQ19NMF8wLAorCQkuZW5kCT0gSVJRX1NZU01NVV9NRkNfTTBfMCwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwlbMzBdID0geworCQkuc3RhcnQJPSBTNVBWMzEwX1BBX1NZU01NVV9NRkNfUiwKKwkJLmVuZAk9IFM1UFYzMTBfUEFfU1lTTU1VX01GQ19SICsgU1pfNjRLIC0gMSwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9NRU0sCisJfSwKKwlbMzFdID0geworCQkuc3RhcnQJPSBJUlFfU1lTTU1VX01GQ19NMV8wLAorCQkuZW5kCT0gSVJRX1NZU01NVV9NRkNfTTFfMCwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9JUlEsCisJfSwKK307CisKK3N0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgczVwdjMxMF9kZXZpY2Vfc3lzbW11ID0geworCS5uYW1lCQk9ICJzNXAtc3lzbW11IiwKKwkuaWQJCT0gMzIsCisJLm51bV9yZXNvdXJjZXMJPSBBUlJBWV9TSVpFKHM1cHYzMTBfc3lzbW11X3Jlc291cmNlKSwKKwkucmVzb3VyY2UJPSBzNXB2MzEwX3N5c21tdV9yZXNvdXJjZSwKK307CisKK0VYUE9SVF9TWU1CT0woczVwdjMxMF9kZXZpY2Vfc3lzbW11KTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczVwdjMxMC9ob3RwbHVnLmMgYi9hcmNoL2FybS9tYWNoLXM1cHYzMTAvaG90cGx1Zy5jCmluZGV4IGFmYTUzOTIuLmMyNDIzNWMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczVwdjMxMC9ob3RwbHVnLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2hvdHBsdWcuYwpAQCAtMzAsMTAgKzMwLDEwIEBACiAJICogVHVybiBvZmYgY29oZXJlbmN5CiAJICovCiAJIgltcmMJcDE1LCAwLCAlMCwgYzEsIGMwLCAxXG4iCi0JIgliaWMJJTAsICUwLCAlMlxuIgorCSIJYmljCSUwLCAlMCwgIzB4MjBcbiIKIAkiCW1jcglwMTUsIDAsICUwLCBjMSwgYzAsIDFcbiIKIAkiCW1yYwlwMTUsIDAsICUwLCBjMSwgYzAsIDBcbiIKLQkiCWJpYwklMCwgJTAsICMweDA0XG4iCisJIgliaWMJJTAsICUwLCAlMlxuIgogCSIJbWNyCXAxNSwgMCwgJTAsIGMxLCBjMCwgMFxuIgogCSAgOiAiPSZyIiAodikKIAkgIDogInIiICgwKSwgIklyIiAoQ1JfQykKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczVwdjMxMC9pbmNsdWRlL21hY2gvaXJxcy5oIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9pcnFzLmgKaW5kZXggM2MwNWM1OC4uNTM2YjBiNSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9pcnFzLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9pcnFzLmgKQEAgLTI1LDYgKzI1LDggQEAKIAogI2RlZmluZSBJUlFfU1BJKHgpCQlTNVBfSVJRKHgrMzIpCiAKKyNkZWZpbmUgSVJRX01DVDEJCUlSUV9TUEkoMzUpCisKICNkZWZpbmUgSVJRX0VJTlQwCQlJUlFfU1BJKDQwKQogI2RlZmluZSBJUlFfRUlOVDEJCUlSUV9TUEkoNDEpCiAjZGVmaW5lIElSUV9FSU5UMgkJSVJRX1NQSSg0MikKQEAgLTM2LDkgKzM4LDggQEAKICNkZWZpbmUgSVJRX0pQRUcJCUlSUV9TUEkoNDgpCiAjZGVmaW5lIElSUV8yRAkJCUlSUV9TUEkoNDkpCiAjZGVmaW5lIElSUV9QQ0lFCQlJUlFfU1BJKDUwKQotI2RlZmluZSBJUlFfU1lTVEVNX1RJTUVSCUlSUV9TUEkoNTEpCisjZGVmaW5lIElSUV9NQ1QwCQlJUlFfU1BJKDUxKQogI2RlZmluZSBJUlFfTUZDCQkJSVJRX1NQSSg1MikKLSNkZWZpbmUgSVJRX1dEVAkJCUlSUV9TUEkoNTMpCiAjZGVmaW5lIElSUV9BVURJT19TUwkJSVJRX1NQSSg1NCkKICNkZWZpbmUgSVJRX0FDOTcJCUlSUV9TUEkoNTUpCiAjZGVmaW5lIElSUV9TUERJRgkJSVJRX1NQSSg1NikKQEAgLTU0LDYgKzU1LDI0IEBACiAjZGVmaW5lIENPTUJJTkVSX0dST1VQKHgpCSgoeCkgKiBNQVhfSVJRX0lOX0NPTUJJTkVSICsgSVJRX1NQSSg2NCkpCiAjZGVmaW5lIENPTUJJTkVSX0lSUSh4LCB5KQkoQ09NQklORVJfR1JPVVAoeCkgKyB5KQogCisjZGVmaW5lIElSUV9TWVNNTVVfTURNQTBfMAlDT01CSU5FUl9JUlEoNCwgMCkKKyNkZWZpbmUgSVJRX1NZU01NVV9TU1NfMAlDT01CSU5FUl9JUlEoNCwgMSkKKyNkZWZpbmUgSVJRX1NZU01NVV9GSU1DMF8wCUNPTUJJTkVSX0lSUSg0LCAyKQorI2RlZmluZSBJUlFfU1lTTU1VX0ZJTUMxXzAJQ09NQklORVJfSVJRKDQsIDMpCisjZGVmaW5lIElSUV9TWVNNTVVfRklNQzJfMAlDT01CSU5FUl9JUlEoNCwgNCkKKyNkZWZpbmUgSVJRX1NZU01NVV9GSU1DM18wCUNPTUJJTkVSX0lSUSg0LCA1KQorI2RlZmluZSBJUlFfU1lTTU1VX0pQRUdfMAlDT01CSU5FUl9JUlEoNCwgNikKKyNkZWZpbmUgSVJRX1NZU01NVV8yRF8wCQlDT01CSU5FUl9JUlEoNCwgNykKKworI2RlZmluZSBJUlFfU1lTTU1VX1JPVEFUT1JfMAlDT01CSU5FUl9JUlEoNSwgMCkKKyNkZWZpbmUgSVJRX1NZU01NVV9NRE1BMV8wCUNPTUJJTkVSX0lSUSg1LCAxKQorI2RlZmluZSBJUlFfU1lTTU1VX0xDRDBfTTBfMAlDT01CSU5FUl9JUlEoNSwgMikKKyNkZWZpbmUgSVJRX1NZU01NVV9MQ0QxX00xXzAJQ09NQklORVJfSVJRKDUsIDMpCisjZGVmaW5lIElSUV9TWVNNTVVfVFZfTTBfMAlDT01CSU5FUl9JUlEoNSwgNCkKKyNkZWZpbmUgSVJRX1NZU01NVV9NRkNfTTBfMAlDT01CSU5FUl9JUlEoNSwgNSkKKyNkZWZpbmUgSVJRX1NZU01NVV9NRkNfTTFfMAlDT01CSU5FUl9JUlEoNSwgNikKKyNkZWZpbmUgSVJRX1NZU01NVV9QQ0lFXzAJQ09NQklORVJfSVJRKDUsIDcpCisKICNkZWZpbmUgSVJRX1BETUEwCQlDT01CSU5FUl9JUlEoMjEsIDApCiAjZGVmaW5lIElSUV9QRE1BMQkJQ09NQklORVJfSVJRKDIxLCAxKQogCkBAIC04Niw4ICsxMDUsMTMgQEAKICNkZWZpbmUgSVJRX0hTTU1DMgkJQ09NQklORVJfSVJRKDI5LCAyKQogI2RlZmluZSBJUlFfSFNNTUMzCQlDT01CSU5FUl9JUlEoMjksIDMpCiAKKyNkZWZpbmUgSVJRX01JUElfQ1NJUzAJCUNPTUJJTkVSX0lSUSgzMCwgMCkKKyNkZWZpbmUgSVJRX01JUElfQ1NJUzEJCUNPTUJJTkVSX0lSUSgzMCwgMSkKKwogI2RlZmluZSBJUlFfT05FTkFORF9BVURJCUNPTUJJTkVSX0lSUSgzNCwgMCkKIAorI2RlZmluZSBJUlFfTUNUX0wxCQlDT01CSU5FUl9JUlEoMzUsIDMpCisKICNkZWZpbmUgSVJRX0VJTlQ0CQlDT01CSU5FUl9JUlEoMzcsIDApCiAjZGVmaW5lIElSUV9FSU5UNQkJQ09NQklORVJfSVJRKDM3LCAxKQogI2RlZmluZSBJUlFfRUlOVDYJCUNPTUJJTkVSX0lSUSgzNywgMikKQEAgLTEwNCw3ICsxMjgsMTEgQEAKIAogI2RlZmluZSBJUlFfRUlOVDE2XzMxCQlDT01CSU5FUl9JUlEoMzksIDApCiAKLSNkZWZpbmUgTUFYX0NPTUJJTkVSX05SCQk0MAorI2RlZmluZSBJUlFfTUNUX0wwCQlDT01CSU5FUl9JUlEoNTEsIDApCisKKyNkZWZpbmUgSVJRX1dEVAkJCUNPTUJJTkVSX0lSUSg1MywgMCkKKworI2RlZmluZSBNQVhfQ09NQklORVJfTlIJCTU0CiAKICNkZWZpbmUgUzVQX0lSUV9FSU5UX0JBU0UJQ09NQklORVJfSVJRKE1BWF9DT01CSU5FUl9OUiwgMCkKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9tYXAuaCBiL2FyY2gvYXJtL21hY2gtczVwdjMxMC9pbmNsdWRlL21hY2gvbWFwLmgKaW5kZXggNTM5OTQ0Ni4uMzA2MGY3OCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9tYXAuaAorKysgYi9hcmNoL2FybS9tYWNoLXM1cHYzMTAvaW5jbHVkZS9tYWNoL21hcC5oCkBAIC0zOSwxMSArMzksMTUgQEAKICNkZWZpbmUgUzVQVjMxMF9QQV9TWVNDT04JCSgweDEwMDEwMDAwKQogI2RlZmluZSBTNVBfUEFfU1lTQ09OCQkJUzVQVjMxMF9QQV9TWVNDT04KIAorI2RlZmluZSBTNVBWMzEwX1BBX1BNVQkJCSgweDEwMDIwMDAwKQorCiAjZGVmaW5lIFM1UFYzMTBfUEFfQ01VCQkJKDB4MTAwMzAwMDApCiAKICNkZWZpbmUgUzVQVjMxMF9QQV9XQVRDSERPRwkJKDB4MTAwNjAwMDApCiAjZGVmaW5lIFM1UFYzMTBfUEFfUlRDCQkJKDB4MTAwNzAwMDApCiAKKyNkZWZpbmUgUzVQVjMxMF9QQV9ETUMwCQkJKDB4MTA0MDAwMDApCisKICNkZWZpbmUgUzVQVjMxMF9QQV9DT01CSU5FUgkJKDB4MTA0NDgwMDApCiAKICNkZWZpbmUgUzVQVjMxMF9QQV9DT1JFUEVSSQkJKDB4MTA1MDAwMDApCkBAIC02MSw5ICs2NSwxMyBAQAogI2RlZmluZSBTNVBWMzEwX1BBX0dQSU8yCQkoMHgxMTAwMDAwMCkKICNkZWZpbmUgUzVQVjMxMF9QQV9HUElPMwkJKDB4MDM4NjAwMDApCiAKKyNkZWZpbmUgUzVQVjMxMF9QQV9NSVBJX0NTSVMwCQkweDExODgwMDAwCisjZGVmaW5lIFM1UFYzMTBfUEFfTUlQSV9DU0lTMQkJMHgxMTg5MDAwMAorCiAjZGVmaW5lIFM1UFYzMTBfUEFfSFNNTUMoeCkJCSgweDEyNTEwMDAwICsgKCh4KSAqIDB4MTAwMDApKQogCiAjZGVmaW5lIFM1UFYzMTBfUEFfU1JPTUMJCSgweDEyNTcwMDAwKQorI2RlZmluZSBTNVBfUEFfU1JPTUMJCQlTNVBWMzEwX1BBX1NST01DCiAKIC8qIFMvUERJRiAqLwogI2RlZmluZSBTNVBWMzEwX1BBX1NQRElGCTB4RTExMDAwMDAKQEAgLTEwMCw2ICsxMDgsMjMgQEAKICNkZWZpbmUgUzVQVjMxMF9QQV9TRFJBTQkJKDB4NDAwMDAwMDApCiAjZGVmaW5lIFM1UF9QQV9TRFJBTQkJCVM1UFYzMTBfUEFfU0RSQU0KIAorI2RlZmluZSBTNVBWMzEwX1BBX1NZU01NVV9NRE1BCQkweDEwQTQwMDAwCisjZGVmaW5lIFM1UFYzMTBfUEFfU1lTTU1VX1NTUwkJMHgxMEE1MDAwMAorI2RlZmluZSBTNVBWMzEwX1BBX1NZU01NVV9GSU1DMAkJMHgxMUEyMDAwMAorI2RlZmluZSBTNVBWMzEwX1BBX1NZU01NVV9GSU1DMQkJMHgxMUEzMDAwMAorI2RlZmluZSBTNVBWMzEwX1BBX1NZU01NVV9GSU1DMgkJMHgxMUE0MDAwMAorI2RlZmluZSBTNVBWMzEwX1BBX1NZU01NVV9GSU1DMwkJMHgxMUE1MDAwMAorI2RlZmluZSBTNVBWMzEwX1BBX1NZU01NVV9KUEVHCQkweDExQTYwMDAwCisjZGVmaW5lIFM1UFYzMTBfUEFfU1lTTU1VX0ZJTUQwCQkweDExRTIwMDAwCisjZGVmaW5lIFM1UFYzMTBfUEFfU1lTTU1VX0ZJTUQxCQkweDEyMjIwMDAwCisjZGVmaW5lIFM1UFYzMTBfUEFfU1lTTU1VX1BDSWUJCTB4MTI2MjAwMDAKKyNkZWZpbmUgUzVQVjMxMF9QQV9TWVNNTVVfRzJECQkweDEyQTIwMDAwCisjZGVmaW5lIFM1UFYzMTBfUEFfU1lTTU1VX1JPVEFUT1IJMHgxMkEzMDAwMAorI2RlZmluZSBTNVBWMzEwX1BBX1NZU01NVV9NRE1BMgkJMHgxMkE0MDAwMAorI2RlZmluZSBTNVBWMzEwX1BBX1NZU01NVV9UVgkJMHgxMkUyMDAwMAorI2RlZmluZSBTNVBWMzEwX1BBX1NZU01NVV9NRkNfTAkJMHgxMzYyMDAwMAorI2RlZmluZSBTNVBWMzEwX1BBX1NZU01NVV9NRkNfUgkJMHgxMzYzMDAwMAorCiAvKiBjb21wYXRpYmlsdGl5IGRlZmluZXMuICovCiAjZGVmaW5lIFMzQ19QQV9VQVJUCQkJUzVQVjMxMF9QQV9VQVJUCiAjZGVmaW5lIFMzQ19QQV9IU01NQzAJCQlTNVBWMzEwX1BBX0hTTU1DKDApCkBAIC0xMTYsNSArMTQxLDcgQEAKICNkZWZpbmUgUzNDX1BBX0lJQzcJCQlTNVBWMzEwX1BBX0lJQyg3KQogI2RlZmluZSBTM0NfUEFfUlRDCQkJUzVQVjMxMF9QQV9SVEMKICNkZWZpbmUgUzNDX1BBX1dEVAkJCVM1UFYzMTBfUEFfV0FUQ0hET0cKKyNkZWZpbmUgUzVQX1BBX01JUElfQ1NJUzAJCVM1UFYzMTBfUEFfTUlQSV9DU0lTMAorI2RlZmluZSBTNVBfUEFfTUlQSV9DU0lTMQkJUzVQVjMxMF9QQV9NSVBJX0NTSVMxCiAKICNlbmRpZiAvKiBfX0FTTV9BUkNIX01BUF9IICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cHYzMTAvaW5jbHVkZS9tYWNoL3JlZ3MtY2xvY2suaCBiL2FyY2gvYXJtL21hY2gtczVwdjMxMC9pbmNsdWRlL21hY2gvcmVncy1jbG9jay5oCmluZGV4IGYxMDI4Y2EuLmI1YzRhZGEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczVwdjMxMC9pbmNsdWRlL21hY2gvcmVncy1jbG9jay5oCisrKyBiL2FyY2gvYXJtL21hY2gtczVwdjMxMC9pbmNsdWRlL21hY2gvcmVncy1jbG9jay5oCkBAIC0xOSw2ICsxOSwxMiBAQAogCiAjZGVmaW5lIFM1UF9JTkZPUk0wCQkJUzVQX0NMS1JFRygweDgwMCkKIAorI2RlZmluZSBTNVBfQ0xLRElWX0xFRlRCVVMJCVM1UF9DTEtSRUcoMHgwNDUwMCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9TVEFUX0xFRlRCVVMJCVM1UF9DTEtSRUcoMHgwNDYwMCkKKworI2RlZmluZSBTNVBfQ0xLRElWX1JJR0hUQlVTCQlTNVBfQ0xLUkVHKDB4MDg1MDApCisjZGVmaW5lIFM1UF9DTEtESVZfU1RBVF9SSUdIVEJVUwlTNVBfQ0xLUkVHKDB4MDg2MDApCisKICNkZWZpbmUgUzVQX0VQTExfQ09OMAkJCVM1UF9DTEtSRUcoMHgwQzExMCkKICNkZWZpbmUgUzVQX0VQTExfQ09OMQkJCVM1UF9DTEtSRUcoMHgwQzExNCkKICNkZWZpbmUgUzVQX1ZQTExfQ09OMAkJCVM1UF9DTEtSRUcoMHgwQzEyMCkKQEAgLTU4LDYgKzY0LDggQEAKICNkZWZpbmUgUzVQX0NMS1NSQ19NQVNLX1BFUklMMAkJUzVQX0NMS1JFRygweDBDMzUwKQogI2RlZmluZSBTNVBfQ0xLU1JDX01BU0tfUEVSSUwxCQlTNVBfQ0xLUkVHKDB4MEMzNTQpCiAKKyNkZWZpbmUgUzVQX0NMS0RJVl9TVEFUX1RPUAkJUzVQX0NMS1JFRygweDBDNjEwKQorCiAjZGVmaW5lIFM1UF9DTEtHQVRFX0lQX0NBTQkJUzVQX0NMS1JFRygweDBDOTIwKQogI2RlZmluZSBTNVBfQ0xLR0FURV9JUF9JTUFHRQkJUzVQX0NMS1JFRygweDBDOTMwKQogI2RlZmluZSBTNVBfQ0xLR0FURV9JUF9MQ0QwCQlTNVBfQ0xLUkVHKDB4MEM5MzQpCkBAIC02Niw4ICs3NCw5IEBACiAjZGVmaW5lIFM1UF9DTEtHQVRFX0lQX1BFUklMCQlTNVBfQ0xLUkVHKDB4MEM5NTApCiAjZGVmaW5lIFM1UF9DTEtHQVRFX0lQX1BFUklSCQlTNVBfQ0xLUkVHKDB4MEM5NjApCiAKLSNkZWZpbmUgUzVQX0NMS1NSQ19DT1JFCQkJUzVQX0NMS1JFRygweDEwMjAwKQotI2RlZmluZSBTNVBfQ0xLRElWX0NPUkUwCQlTNVBfQ0xLUkVHKDB4MTA1MDApCisjZGVmaW5lIFM1UF9DTEtTUkNfRE1DCQkJUzVQX0NMS1JFRygweDEwMjAwKQorI2RlZmluZSBTNVBfQ0xLRElWX0RNQzAJCQlTNVBfQ0xLUkVHKDB4MTA1MDApCisjZGVmaW5lIFM1UF9DTEtESVZfU1RBVF9ETUMwCQlTNVBfQ0xLUkVHKDB4MTA2MDApCiAKICNkZWZpbmUgUzVQX0FQTExfTE9DSwkJCVM1UF9DTEtSRUcoMHgxNDAwMCkKICNkZWZpbmUgUzVQX01QTExfTE9DSwkJCVM1UF9DTEtSRUcoMHgxNDAwNCkKQEAgLTgwLDEwICs4OSw3NyBAQAogI2RlZmluZSBTNVBfQ0xLTVVYX1NUQVRDUFUJCVM1UF9DTEtSRUcoMHgxNDQwMCkKIAogI2RlZmluZSBTNVBfQ0xLRElWX0NQVQkJCVM1UF9DTEtSRUcoMHgxNDUwMCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9DUFUxCQkJUzVQX0NMS1JFRygweDE0NTA0KQogI2RlZmluZSBTNVBfQ0xLRElWX1NUQVRDUFUJCVM1UF9DTEtSRUcoMHgxNDYwMCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9TVEFUQ1BVMQkJUzVQX0NMS1JFRygweDE0NjA0KQogCiAjZGVmaW5lIFM1UF9DTEtHQVRFX1NDTEtDUFUJCVM1UF9DTEtSRUcoMHgxNDgwMCkKIAorLyogQVBMTF9MT0NLICovCisjZGVmaW5lIFM1UF9BUExMX0xPQ0tUSU1FCQkoMHgxQzIwKQkvKiAzMDB1cyAqLworCisvKiBBUExMX0NPTjAgKi8KKyNkZWZpbmUgUzVQX0FQTExDT04wX0VOQUJMRV9TSElGVAkoMzEpCisjZGVmaW5lIFM1UF9BUExMQ09OMF9MT0NLRURfU0hJRlQJKDI5KQorI2RlZmluZSBTNVBfQVBMTF9WQUxfMTAwMAkJKCgyNTAgPDwgMTYpIHwgKDYgPDwgOCkgfCAxKQorI2RlZmluZSBTNVBfQVBMTF9WQUxfODAwCQkoKDIwMCA8PCAxNikgfCAoNiA8PCA4KSB8IDEpCisKKy8qIENMS19TUkNfQ1BVICovCisjZGVmaW5lIFM1UF9DTEtTUkNfQ1BVX01VWENPUkVfU0hJRlQJKDE2KQorI2RlZmluZSBTNVBfQ0xLTVVYX1NUQVRDUFVfTVVYQ09SRV9NQVNLCSgweDcgPDwgUzVQX0NMS1NSQ19DUFVfTVVYQ09SRV9TSElGVCkKKworLyogQ0xLRElWX0NQVTAgKi8KKyNkZWZpbmUgUzVQX0NMS0RJVl9DUFUwX0NPUkVfU0hJRlQJKDApCisjZGVmaW5lIFM1UF9DTEtESVZfQ1BVMF9DT1JFX01BU0sJKDB4NyA8PCBTNVBfQ0xLRElWX0NQVTBfQ09SRV9TSElGVCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9DUFUwX0NPUkVNMF9TSElGVAkoNCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9DUFUwX0NPUkVNMF9NQVNLCSgweDcgPDwgUzVQX0NMS0RJVl9DUFUwX0NPUkVNMF9TSElGVCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9DUFUwX0NPUkVNMV9TSElGVAkoOCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9DUFUwX0NPUkVNMV9NQVNLCSgweDcgPDwgUzVQX0NMS0RJVl9DUFUwX0NPUkVNMV9TSElGVCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9DUFUwX1BFUklQSF9TSElGVAkoMTIpCisjZGVmaW5lIFM1UF9DTEtESVZfQ1BVMF9QRVJJUEhfTUFTSwkoMHg3IDw8IFM1UF9DTEtESVZfQ1BVMF9QRVJJUEhfU0hJRlQpCisjZGVmaW5lIFM1UF9DTEtESVZfQ1BVMF9BVEJfU0hJRlQJKDE2KQorI2RlZmluZSBTNVBfQ0xLRElWX0NQVTBfQVRCX01BU0sJKDB4NyA8PCBTNVBfQ0xLRElWX0NQVTBfQVRCX1NISUZUKQorI2RlZmluZSBTNVBfQ0xLRElWX0NQVTBfUENMS0RCR19TSElGVAkoMjApCisjZGVmaW5lIFM1UF9DTEtESVZfQ1BVMF9QQ0xLREJHX01BU0sJKDB4NyA8PCBTNVBfQ0xLRElWX0NQVTBfUENMS0RCR19TSElGVCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9DUFUwX0FQTExfU0hJRlQJKDI0KQorI2RlZmluZSBTNVBfQ0xLRElWX0NQVTBfQVBMTF9NQVNLCSgweDcgPDwgUzVQX0NMS0RJVl9DUFUwX0FQTExfU0hJRlQpCisKKy8qIENMS0RJVl9ETUMwICovCisjZGVmaW5lIFM1UF9DTEtESVZfRE1DMF9BQ1BfU0hJRlQJKDApCisjZGVmaW5lIFM1UF9DTEtESVZfRE1DMF9BQ1BfTUFTSwkoMHg3IDw8IFM1UF9DTEtESVZfRE1DMF9BQ1BfU0hJRlQpCisjZGVmaW5lIFM1UF9DTEtESVZfRE1DMF9BQ1BQQ0xLX1NISUZUCSg0KQorI2RlZmluZSBTNVBfQ0xLRElWX0RNQzBfQUNQUENMS19NQVNLCSgweDcgPDwgUzVQX0NMS0RJVl9ETUMwX0FDUFBDTEtfU0hJRlQpCisjZGVmaW5lIFM1UF9DTEtESVZfRE1DMF9EUEhZX1NISUZUCSg4KQorI2RlZmluZSBTNVBfQ0xLRElWX0RNQzBfRFBIWV9NQVNLCSgweDcgPDwgUzVQX0NMS0RJVl9ETUMwX0RQSFlfU0hJRlQpCisjZGVmaW5lIFM1UF9DTEtESVZfRE1DMF9ETUNfU0hJRlQJKDEyKQorI2RlZmluZSBTNVBfQ0xLRElWX0RNQzBfRE1DX01BU0sJKDB4NyA8PCBTNVBfQ0xLRElWX0RNQzBfRE1DX1NISUZUKQorI2RlZmluZSBTNVBfQ0xLRElWX0RNQzBfRE1DRF9TSElGVAkoMTYpCisjZGVmaW5lIFM1UF9DTEtESVZfRE1DMF9ETUNEX01BU0sJKDB4NyA8PCBTNVBfQ0xLRElWX0RNQzBfRE1DRF9TSElGVCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9ETUMwX0RNQ1BfU0hJRlQJKDIwKQorI2RlZmluZSBTNVBfQ0xLRElWX0RNQzBfRE1DUF9NQVNLCSgweDcgPDwgUzVQX0NMS0RJVl9ETUMwX0RNQ1BfU0hJRlQpCisjZGVmaW5lIFM1UF9DTEtESVZfRE1DMF9DT1BZMl9TSElGVAkoMjQpCisjZGVmaW5lIFM1UF9DTEtESVZfRE1DMF9DT1BZMl9NQVNLCSgweDcgPDwgUzVQX0NMS0RJVl9ETUMwX0NPUFkyX1NISUZUKQorI2RlZmluZSBTNVBfQ0xLRElWX0RNQzBfQ09SRVRJX1NISUZUCSgyOCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9ETUMwX0NPUkVUSV9NQVNLCSgweDcgPDwgUzVQX0NMS0RJVl9ETUMwX0NPUkVUSV9TSElGVCkKKworLyogQ0xLRElWX1RPUCAqLworI2RlZmluZSBTNVBfQ0xLRElWX1RPUF9BQ0xLMjAwX1NISUZUCSgwKQorI2RlZmluZSBTNVBfQ0xLRElWX1RPUF9BQ0xLMjAwX01BU0sJKDB4NyA8PCBTNVBfQ0xLRElWX1RPUF9BQ0xLMjAwX1NISUZUKQorI2RlZmluZSBTNVBfQ0xLRElWX1RPUF9BQ0xLMTAwX1NISUZUCSg0KQorI2RlZmluZSBTNVBfQ0xLRElWX1RPUF9BQ0xLMTAwX01BU0sJKDB4ZiA8PCBTNVBfQ0xLRElWX1RPUF9BQ0xLMTAwX1NISUZUKQorI2RlZmluZSBTNVBfQ0xLRElWX1RPUF9BQ0xLMTYwX1NISUZUCSg4KQorI2RlZmluZSBTNVBfQ0xLRElWX1RPUF9BQ0xLMTYwX01BU0sJKDB4NyA8PCBTNVBfQ0xLRElWX1RPUF9BQ0xLMTYwX1NISUZUKQorI2RlZmluZSBTNVBfQ0xLRElWX1RPUF9BQ0xLMTMzX1NISUZUCSgxMikKKyNkZWZpbmUgUzVQX0NMS0RJVl9UT1BfQUNMSzEzM19NQVNLCSgweDcgPDwgUzVQX0NMS0RJVl9UT1BfQUNMSzEzM19TSElGVCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9UT1BfT05FTkFORF9TSElGVAkoMTYpCisjZGVmaW5lIFM1UF9DTEtESVZfVE9QX09ORU5BTkRfTUFTSwkoMHg3IDw8IFM1UF9DTEtESVZfVE9QX09ORU5BTkRfU0hJRlQpCisKKy8qIENMS0RJVl9MRUZUQlVTIC8gQ0xLRElWX1JJR0hUQlVTKi8KKyNkZWZpbmUgUzVQX0NMS0RJVl9CVVNfR0RMUl9TSElGVAkoMCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9CVVNfR0RMUl9NQVNLCSgweDcgPDwgUzVQX0NMS0RJVl9CVVNfR0RMUl9TSElGVCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9CVVNfR1BMUl9TSElGVAkoNCkKKyNkZWZpbmUgUzVQX0NMS0RJVl9CVVNfR1BMUl9NQVNLCSgweDcgPDwgUzVQX0NMS0RJVl9CVVNfR1BMUl9TSElGVCkKKwogLyogQ29tcGF0aWJpbGl0eSBkZWZpbmVzICovCiAKICNkZWZpbmUgUzVQX0VQTExfQ09OCQkJUzVQX0VQTExfQ09OMApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9yZWdzLW1lbS5oIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9yZWdzLW1lbS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjgzNDIyNzEKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL2FybS9tYWNoLXM1cHYzMTAvaW5jbHVkZS9tYWNoL3JlZ3MtbWVtLmgKQEAgLTAsMCArMSwyMyBAQAorLyogbGludXgvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9yZWdzLW1lbS5oCisgKgorICogQ29weXJpZ2h0IChjKSAyMDEwIFNhbXN1bmcgRWxlY3Ryb25pY3MgQ28uLCBMdGQuCisgKgkJaHR0cDovL3d3dy5zYW1zdW5nLmNvbQorICoKKyAqIFM1UFYzMTAgLSBTUk9NQyBhbmQgRE1DIHJlZ2lzdGVyIGRlZmluaXRpb25zCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyovCisKKyNpZm5kZWYgX19BU01fQVJDSF9SRUdTX01FTV9ICisjZGVmaW5lIF9fQVNNX0FSQ0hfUkVHU19NRU1fSCBfX0ZJTEVfXworCisjaW5jbHVkZSA8bWFjaC9tYXAuaD4KKworI2RlZmluZSBTNVBfRE1DMF9NRU1DT05fT0ZGU0VUCQkweDA0CisKKyNkZWZpbmUgUzVQX0RNQzBfTUVNVFlQRV9TSElGVAkJOAorI2RlZmluZSBTNVBfRE1DMF9NRU1UWVBFX01BU0sJCTB4RgorCisjZW5kaWYgLyogX19BU01fQVJDSF9SRUdTX01FTV9IICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cHYzMTAvaW5jbHVkZS9tYWNoL3JlZ3MtcG11LmggYi9hcmNoL2FybS9tYWNoLXM1cHYzMTAvaW5jbHVkZS9tYWNoL3JlZ3MtcG11LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmIzMzNkMAotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvYXJtL21hY2gtczVwdjMxMC9pbmNsdWRlL21hY2gvcmVncy1wbXUuaApAQCAtMCwwICsxLDMwIEBACisvKiBsaW51eC9hcmNoL2FybS9tYWNoLXM1cHYzMTAvaW5jbHVkZS9tYWNoL3JlZ3MtcG11LmgKKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMTAgU2Ftc3VuZyBFbGVjdHJvbmljcyBDby4sIEx0ZC4KKyAqCQlodHRwOi8vd3d3LnNhbXN1bmcuY29tCisgKgorICogUzVQVjMxMCAtIFBvd2VyIG1hbmFnZW1lbnQgdW5pdCBkZWZpbml0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyovCisKKyNpZm5kZWYgX19BU01fQVJDSF9SRUdTX1BNVV9ICisjZGVmaW5lIF9fQVNNX0FSQ0hfUkVHU19QTVVfSCBfX0ZJTEVfXworCisjaW5jbHVkZSA8bWFjaC9tYXAuaD4KKworI2RlZmluZSBTNVBfUE1VUkVHKHgpCQkJKFM1UF9WQV9QTVUgKyAoeCkpCisKKyNkZWZpbmUgUzVQX1BNVV9DQU1fQ09ORgkJUzVQX1BNVVJFRygweDNDMDApCisjZGVmaW5lIFM1UF9QTVVfVFZfQ09ORgkJUzVQX1BNVVJFRygweDNDMjApCisjZGVmaW5lIFM1UF9QTVVfTUZDX0NPTkYJCVM1UF9QTVVSRUcoMHgzQzQwKQorI2RlZmluZSBTNVBfUE1VX0czRF9DT05GCQlTNVBfUE1VUkVHKDB4M0M2MCkKKyNkZWZpbmUgUzVQX1BNVV9MQ0QwX0NPTkYJCVM1UF9QTVVSRUcoMHgzQzgwKQorI2RlZmluZSBTNVBfUE1VX0xDRDFfQ09ORgkJUzVQX1BNVVJFRygweDNDQTApCisjZGVmaW5lIFM1UF9QTVVfR1BTX0NPTkYJCVM1UF9QTVVSRUcoMHgzQ0UwKQorCisjZGVmaW5lIFM1UF9JTlRfTE9DQUxfUFdSX0VOCQkweDcKKworI2VuZGlmIC8qIF9fQVNNX0FSQ0hfUkVHU19QTVVfSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9yZWdzLXNyb20uaCBiL2FyY2gvYXJtL21hY2gtczVwdjMxMC9pbmNsdWRlL21hY2gvcmVncy1zcm9tLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDE4OThiM2UuLjAwMDAwMDAKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9yZWdzLXNyb20uaAorKysgL2Rldi9udWxsCkBAIC0xLDUwICswLDAgQEAKLS8qIGxpbnV4L2FyY2gvYXJtL21hY2gtczVwdjMxMC9pbmNsdWRlL21hY2gvcmVncy1zcm9tLmgKLSAqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMTAgU2Ftc3VuZyBFbGVjdHJvbmljcyBDby4sIEx0ZC4KLSAqCQlodHRwOi8vd3d3LnNhbXN1bmcuY29tCi0gKgotICogUzVQVjMxMCAtIFNST01DIHJlZ2lzdGVyIGRlZmluaXRpb25zCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSovCi0KLSNpZm5kZWYgX19BU01fQVJDSF9SRUdTX1NST01fSAotI2RlZmluZSBfX0FTTV9BUkNIX1JFR1NfU1JPTV9IIF9fRklMRV9fCi0KLSNpbmNsdWRlIDxtYWNoL21hcC5oPgotCi0jZGVmaW5lIFM1UFYzMTBfU1JPTVJFRyh4KQkoUzVQX1ZBX1NST01DICsgKHgpKQotCi0jZGVmaW5lIFM1UFYzMTBfU1JPTV9CVwkJUzVQVjMxMF9TUk9NUkVHKDB4MCkKLSNkZWZpbmUgUzVQVjMxMF9TUk9NX0JDMAlTNVBWMzEwX1NST01SRUcoMHg0KQotI2RlZmluZSBTNVBWMzEwX1NST01fQkMxCVM1UFYzMTBfU1JPTVJFRygweDgpCi0jZGVmaW5lIFM1UFYzMTBfU1JPTV9CQzIJUzVQVjMxMF9TUk9NUkVHKDB4YykKLSNkZWZpbmUgUzVQVjMxMF9TUk9NX0JDMwlTNVBWMzEwX1NST01SRUcoMHgxMCkKLQotLyogb25lIHJlZ2lzdGVyIEJXIGhvbGRzIDQgeCA0LWJpdCBwYWNrZWQgc2V0dGluZ3MgZm9yIE5DUzAgLSBOQ1MzICovCi0KLSNkZWZpbmUgUzVQVjMxMF9TUk9NX0JXX19EQVRBV0lEVEhfX1NISUZUCTAKLSNkZWZpbmUgUzVQVjMxMF9TUk9NX0JXX19BRERSTU9ERV9fU0hJRlQJMQotI2RlZmluZSBTNVBWMzEwX1NST01fQldfX1dBSVRFTkFCTEVfX1NISUZUCTIKLSNkZWZpbmUgUzVQVjMxMF9TUk9NX0JXX19CWVRFRU5BQkxFX19TSElGVAkzCi0KLSNkZWZpbmUgUzVQVjMxMF9TUk9NX0JXX19DU19NQVNLCQkweGYKLQotI2RlZmluZSBTNVBWMzEwX1NST01fQldfX05DUzBfX1NISUZUCQkwCi0jZGVmaW5lIFM1UFYzMTBfU1JPTV9CV19fTkNTMV9fU0hJRlQJCTQKLSNkZWZpbmUgUzVQVjMxMF9TUk9NX0JXX19OQ1MyX19TSElGVAkJOAotI2RlZmluZSBTNVBWMzEwX1NST01fQldfX05DUzNfX1NISUZUCQkxMgotCi0vKiBhcHBsaWVzIHRvIHNhbWUgdG8gQkNTMCAtIEJDUzMgKi8KLQotI2RlZmluZSBTNVBWMzEwX1NST01fQkNYX19QTUNfX1NISUZUCQkwCi0jZGVmaW5lIFM1UFYzMTBfU1JPTV9CQ1hfX1RBQ1BfX1NISUZUCQk0Ci0jZGVmaW5lIFM1UFYzMTBfU1JPTV9CQ1hfX1RDQUhfX1NISUZUCQk4Ci0jZGVmaW5lIFM1UFYzMTBfU1JPTV9CQ1hfX1RDT0hfX1NISUZUCQkxMgotI2RlZmluZSBTNVBWMzEwX1NST01fQkNYX19UQUNDX19TSElGVAkJMTYKLSNkZWZpbmUgUzVQVjMxMF9TUk9NX0JDWF9fVENPU19fU0hJRlQJCTI0Ci0jZGVmaW5lIFM1UFYzMTBfU1JPTV9CQ1hfX1RBQ1NfX1NISUZUCQkyOAotCi0jZW5kaWYgLyogX19BU01fQVJDSF9SRUdTX1NST01fSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9yZWdzLXN5c21tdS5oIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9yZWdzLXN5c21tdS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjBiMjhlODEKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL2FybS9tYWNoLXM1cHYzMTAvaW5jbHVkZS9tYWNoL3JlZ3Mtc3lzbW11LmgKQEAgLTAsMCArMSwyNCBAQAorLyogbGludXgvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9yZWdzLXN5c21tdS5oCisgKgorICogQ29weXJpZ2h0IChjKSAyMDEwIFNhbXN1bmcgRWxlY3Ryb25pY3MgQ28uLCBMdGQuCisgKgkJaHR0cDovL3d3dy5zYW1zdW5nLmNvbQorICoKKyAqIFM1UFYzMTAgLSBTeXN0ZW0gTU1VIHJlZ2lzdGVyCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyovCisKKyNpZm5kZWYgX19BU01fQVJDSF9SRUdTX1NZU01NVV9ICisjZGVmaW5lIF9fQVNNX0FSQ0hfUkVHU19TWVNNTVVfSCBfX0ZJTEVfXworCisjZGVmaW5lIFM1UF9NTVVfQ1RSTAkJCTB4MDAwCisjZGVmaW5lIFM1UF9NTVVfQ0ZHCQkJMHgwMDQKKyNkZWZpbmUgUzVQX01NVV9TVEFUVVMJCQkweDAwOAorI2RlZmluZSBTNVBfTU1VX0ZMVVNICQkJMHgwMEMKKyNkZWZpbmUgUzVQX1BUX0JBU0VfQUREUgkJMHgwMTQKKyNkZWZpbmUgUzVQX0lOVF9TVEFUVVMJCQkweDAxOAorI2RlZmluZSBTNVBfUEFHRV9GQVVMVF9BRERSCQkweDAyNAorCisjZW5kaWYgLyogX19BU01fQVJDSF9SRUdTX1NZU01NVV9IICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cHYzMTAvaW5jbHVkZS9tYWNoL3N5c21tdS5oIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9zeXNtbXUuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41OThmYzVjCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9zeXNtbXUuaApAQCAtMCwwICsxLDEyMiBAQAorLyogbGludXgvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2luY2x1ZGUvbWFjaC9zeXNtbXUuaAorICoKKyAqIENvcHlyaWdodCAoYykgMjAxMCBTYW1zdW5nIEVsZWN0cm9uaWNzIENvLiwgTHRkLgorICoJCWh0dHA6Ly93d3cuc2Ftc3VuZy5jb20vCisgKgorICogU2Ftc3VuZyBzeXNtbXUgZHJpdmVyIGZvciBTNVBWMzEwCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyovCisKKyNpZm5kZWYgX19BU01fQVJNX0FSQ0hfU1lTTU1VX0gKKyNkZWZpbmUgX19BU01fQVJNX0FSQ0hfU1lTTU1VX0ggX19GSUxFX18KKworI2RlZmluZSBTNVBWMzEwX1NZU01NVV9UT1RBTF9JUE5VTQkxNgorI2RlZmluZSBTNVBfU1lTTU1VX1RPVEFMX0lQTlVNCQlTNVBWMzEwX1NZU01NVV9UT1RBTF9JUE5VTQorCitlbnVtIHM1cHYzMTBfc3lzbW11X2lwcyB7CisJU1lTTU1VX01ETUEsCisJU1lTTU1VX1NTUywKKwlTWVNNTVVfRklNQzAsCisJU1lTTU1VX0ZJTUMxLAorCVNZU01NVV9GSU1DMiwKKwlTWVNNTVVfRklNQzMsCisJU1lTTU1VX0pQRUcsCisJU1lTTU1VX0ZJTUQwLAorCVNZU01NVV9GSU1EMSwKKwlTWVNNTVVfUENJZSwKKwlTWVNNTVVfRzJELAorCVNZU01NVV9ST1RBVE9SLAorCVNZU01NVV9NRE1BMiwKKwlTWVNNTVVfVFYsCisJU1lTTU1VX01GQ19MLAorCVNZU01NVV9NRkNfUiwKK307CisKK3N0YXRpYyBjaGFyICpzeXNtbXVfaXBzX25hbWVbUzVQVjMxMF9TWVNNTVVfVE9UQUxfSVBOVU1dID0geworCSJTWVNNTVVfTURNQSIJLAorCSJTWVNNTVVfU1NTIgksCisJIlNZU01NVV9GSU1DMCIJLAorCSJTWVNNTVVfRklNQzEiCSwKKwkiU1lTTU1VX0ZJTUMyIgksCisJIlNZU01NVV9GSU1DMyIJLAorCSJTWVNNTVVfSlBFRyIJLAorCSJTWVNNTVVfRklNRDAiCSwKKwkiU1lTTU1VX0ZJTUQxIgksCisJIlNZU01NVV9QQ0llIgksCisJIlNZU01NVV9HMkQiCSwKKwkiU1lTTU1VX1JPVEFUT1IiLAorCSJTWVNNTVVfTURNQTIiCSwKKwkiU1lTTU1VX1RWIgksCisJIlNZU01NVV9NRkNfTCIJLAorCSJTWVNNTVVfTUZDX1IiCSwKK307CisKK3R5cGVkZWYgZW51bSBzNXB2MzEwX3N5c21tdV9pcHMgc3lzbW11X2lwczsKKworc3RydWN0IHN5c21tdV90dF9pbmZvIHsKKwl1bnNpZ25lZCBsb25nICpwZ2Q7CisJdW5zaWduZWQgbG9uZyBwZ2RfcGFkZHI7CisJdW5zaWduZWQgbG9uZyAqcHRlOworfTsKKworc3RydWN0IHN5c21tdV9jb250cm9sbGVyIHsKKwljb25zdCBjaGFyCQkqbmFtZTsKKworCS8qIGNoYW5uZWxzIHJlZ2lzdGVycyAqLworCXZvaWQgX19pb21lbQkJKnJlZ3M7CisKKwkvKiBjaGFubmVsIGlycSAqLworCXVuc2lnbmVkIGludAkJaXJxOworCisJc3lzbW11X2lwcwkJaXBzOworCisJLyogVHJhbnNsYXRpb24gVGFibGUgSW5mby4gKi8KKwlzdHJ1Y3Qgc3lzbW11X3R0X2luZm8JKnR0X2luZm87CisKKwlzdHJ1Y3QgcmVzb3VyY2UJCSptZW07CisJc3RydWN0IGRldmljZQkJKmRldjsKKworCS8qIFN5c01NVSBjb250cm9sbGVyIGVuYWJsZSAtIHRydWUgOiBlbmFibGUgKi8KKwlib29sCQkJZW5hYmxlOworfTsKKworLyoqCisgKiBzNXBfc3lzbW11X2VuYWJsZSgpIC0gZW5hYmxlIHN5c3RlbSBtbXUgb2YgaXAKKyAqIEBpcHM6IFRoZSBpcCBjb25uZWN0ZWQgc3lzdGVtIG1tdS4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGVuYWJsZSBzeXN0ZW0gbW11IHRvIHRyYW5zZmVyIGFkZHJlc3MKKyAqIGZyb20gdmlydHVhbCBhZGRyZXNzIHRvIHBoeXNpY2FsIGFkZHJlc3MKKyAqLworaW50IHM1cF9zeXNtbXVfZW5hYmxlKHN5c21tdV9pcHMgaXBzKTsKKworLyoqCisgKiBzNXBfc3lzbW11X2Rpc2FibGUoKSAtIGRpc2FibGUgc3lzbW11IG1tdSBvZiBpcAorICogQGlwczogVGhlIGlwIGNvbm5lY3RlZCBzeXN0ZW0gbW11LgorICoKKyAqIFRoaXMgZnVuY3Rpb24gZGlzYWJsZSBzeXN0ZW0gbW11IHRvIHRyYW5zZmVyIGFkZHJlc3MKKyAqIGZyb20gdmlydHVhbCBhZGRyZXNzIHRvIHBoeXNpY2FsIGFkZHJlc3MKKyAqLworaW50IHM1cF9zeXNtbXVfZGlzYWJsZShzeXNtbXVfaXBzIGlwcyk7CisKKy8qKgorICogczVwX3N5c21tdV9zZXRfdGFibGViYXNlX3BnZCgpIC0gc2V0IHBhZ2UgdGFibGUgYmFzZSBhZGRyZXNzIHRvIHJlZmVyIHBhZ2UgdGFibGUKKyAqIEBpcHM6IFRoZSBpcCBjb25uZWN0ZWQgc3lzdGVtIG1tdS4KKyAqIEBwZ2Q6IFRoZSBwYWdlIHRhYmxlIGJhc2UgYWRkcmVzcy4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIHNldCBwYWdlIHRhYmxlIGJhc2UgYWRkcmVzcworICogV2hlbiBzeXN0ZW0gbW11IHRyYW5zZmVyIGFkZHJlc3MgZnJvbSB2aXJ0YXVsIGFkZHJlc3MgdG8gcGh5c2ljYWwgYWRkcmVzcywKKyAqIHN5c3RlbSBtbXUgcmVmZXIgYWRkcmVzcyBpbmZvcm1hdGlvbiBmcm9tIHBhZ2UgdGFibGUKKyAqLworaW50IHM1cF9zeXNtbXVfc2V0X3RhYmxlYmFzZV9wZ2Qoc3lzbW11X2lwcyBpcHMsIHVuc2lnbmVkIGxvbmcgcGdkKTsKKworLyoqCisgKiBzNXBfc3lzbW11X3RsYl9pbnZhbGlkYXRlKCkgLSBmbHVzaCBhbGwgVExCIGVudHJ5IGluIHN5c3RlbSBtbXUKKyAqIEBpcHM6IFRoZSBpcCBjb25uZWN0ZWQgc3lzdGVtIG1tdS4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGZsdXNoIGFsbCBUTEIgZW50cnkgaW4gc3lzdGVtIG1tdQorICovCitpbnQgczVwX3N5c21tdV90bGJfaW52YWxpZGF0ZShzeXNtbXVfaXBzIGlwcyk7CisjZW5kaWYgLyogX19BU01fQVJNX0FSQ0hfU1lTTU1VX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczVwdjMxMC9pcnEtY29tYmluZXIuYyBiL2FyY2gvYXJtL21hY2gtczVwdjMxMC9pcnEtY29tYmluZXIuYwppbmRleCBjM2Y4OGMzLi4xZWE0YTllIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cHYzMTAvaXJxLWNvbWJpbmVyLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL2lycS1jb21iaW5lci5jCkBAIC0yNCwyOSArMjQsMzIgQEAKIAogc3RydWN0IGNvbWJpbmVyX2NoaXBfZGF0YSB7CiAJdW5zaWduZWQgaW50IGlycV9vZmZzZXQ7CisJdW5zaWduZWQgaW50IGlycV9tYXNrOwogCXZvaWQgX19pb21lbSAqYmFzZTsKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgY29tYmluZXJfY2hpcF9kYXRhIGNvbWJpbmVyX2RhdGFbTUFYX0NPTUJJTkVSX05SXTsKIAotc3RhdGljIGlubGluZSB2b2lkIF9faW9tZW0gKmNvbWJpbmVyX2Jhc2UodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2lvbWVtICpjb21iaW5lcl9iYXNlKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3QgY29tYmluZXJfY2hpcF9kYXRhICpjb21iaW5lcl9kYXRhID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgY29tYmluZXJfY2hpcF9kYXRhICpjb21iaW5lcl9kYXRhID0KKwkJaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CisKIAlyZXR1cm4gY29tYmluZXJfZGF0YS0+YmFzZTsKIH0KIAotc3RhdGljIHZvaWQgY29tYmluZXJfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGNvbWJpbmVyX21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQl1MzIgbWFzayA9IDEgPDwgKGlycSAlIDMyKTsKKwl1MzIgbWFzayA9IDEgPDwgKGRhdGEtPmlycSAlIDMyKTsKIAotCV9fcmF3X3dyaXRlbChtYXNrLCBjb21iaW5lcl9iYXNlKGlycSkgKyBDT01CSU5FUl9FTkFCTEVfQ0xFQVIpOworCV9fcmF3X3dyaXRlbChtYXNrLCBjb21iaW5lcl9iYXNlKGRhdGEpICsgQ09NQklORVJfRU5BQkxFX0NMRUFSKTsKIH0KIAotc3RhdGljIHZvaWQgY29tYmluZXJfdW5tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgY29tYmluZXJfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JdTMyIG1hc2sgPSAxIDw8IChpcnEgJSAzMik7CisJdTMyIG1hc2sgPSAxIDw8IChkYXRhLT5pcnEgJSAzMik7CiAKLQlfX3Jhd193cml0ZWwobWFzaywgY29tYmluZXJfYmFzZShpcnEpICsgQ09NQklORVJfRU5BQkxFX1NFVCk7CisJX19yYXdfd3JpdGVsKG1hc2ssIGNvbWJpbmVyX2Jhc2UoZGF0YSkgKyBDT01CSU5FUl9FTkFCTEVfU0VUKTsKIH0KIAogc3RhdGljIHZvaWQgY29tYmluZXJfaGFuZGxlX2Nhc2NhZGVfaXJxKHVuc2lnbmVkIGludCBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKQEAgLTU3LDExICs2MCwxMiBAQAogCXVuc2lnbmVkIGxvbmcgc3RhdHVzOwogCiAJLyogcHJpbWFyeSBjb250cm9sbGVyIGFjaydpbmcgKi8KLQljaGlwLT5hY2soaXJxKTsKKwljaGlwLT5pcnFfYWNrKCZkZXNjLT5pcnFfZGF0YSk7CiAKIAlzcGluX2xvY2soJmlycV9jb250cm9sbGVyX2xvY2spOwogCXN0YXR1cyA9IF9fcmF3X3JlYWRsKGNoaXBfZGF0YS0+YmFzZSArIENPTUJJTkVSX0lOVF9TVEFUVVMpOwogCXNwaW5fdW5sb2NrKCZpcnFfY29udHJvbGxlcl9sb2NrKTsKKwlzdGF0dXMgJj0gY2hpcF9kYXRhLT5pcnFfbWFzazsKIAogCWlmIChzdGF0dXMgPT0gMCkKIAkJZ290byBvdXQ7CkBAIC03NiwxMyArODAsMTMgQEAKIAogIG91dDoKIAkvKiBwcmltYXJ5IGNvbnRyb2xsZXIgdW5tYXNraW5nICovCi0JY2hpcC0+dW5tYXNrKGlycSk7CisJY2hpcC0+aXJxX3VubWFzaygmZGVzYy0+aXJxX2RhdGEpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGNvbWJpbmVyX2NoaXAgPSB7CiAJLm5hbWUJCT0gIkNPTUJJTkVSIiwKLQkubWFzawkJPSBjb21iaW5lcl9tYXNrX2lycSwKLQkudW5tYXNrCQk9IGNvbWJpbmVyX3VubWFza19pcnEsCisJLmlycV9tYXNrCT0gY29tYmluZXJfbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBjb21iaW5lcl91bm1hc2tfaXJxLAogfTsKIAogdm9pZCBfX2luaXQgY29tYmluZXJfY2FzY2FkZV9pcnEodW5zaWduZWQgaW50IGNvbWJpbmVyX25yLCB1bnNpZ25lZCBpbnQgaXJxKQpAQCAtMTA0LDEwICsxMDgsMTIgQEAKIAogCWNvbWJpbmVyX2RhdGFbY29tYmluZXJfbnJdLmJhc2UgPSBiYXNlOwogCWNvbWJpbmVyX2RhdGFbY29tYmluZXJfbnJdLmlycV9vZmZzZXQgPSBpcnFfc3RhcnQ7CisJY29tYmluZXJfZGF0YVtjb21iaW5lcl9ucl0uaXJxX21hc2sgPSAweGZmIDw8ICgoY29tYmluZXJfbnIgJSA0KSA8PCAzKTsKIAogCS8qIERpc2FibGUgYWxsIGludGVycnVwdHMgKi8KIAotCV9fcmF3X3dyaXRlbCgweGZmZmZmZmZmLCBiYXNlICsgQ09NQklORVJfRU5BQkxFX0NMRUFSKTsKKwlfX3Jhd193cml0ZWwoY29tYmluZXJfZGF0YVtjb21iaW5lcl9ucl0uaXJxX21hc2ssCisJCSAgICAgYmFzZSArIENPTUJJTkVSX0VOQUJMRV9DTEVBUik7CiAKIAkvKiBTZXR1cCB0aGUgTGludXggSVJRIHN1YnN5c3RlbSAqLwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cHYzMTAvaXJxLWVpbnQuYyBiL2FyY2gvYXJtL21hY2gtczVwdjMxMC9pcnEtZWludC5jCmluZGV4IDU4Nzc1MDMuLjQ3N2JkOWUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczVwdjMxMC9pcnEtZWludC5jCisrKyBiL2FyY2gvYXJtL21hY2gtczVwdjMxMC9pcnEtZWludC5jCkBAIC00OCw0MiArNDgsNDMgQEAKIAlyZXR1cm4gcmV0OwogfQogCi1zdGF0aWMgaW5saW5lIHZvaWQgczVwdjMxMF9pcnFfZWludF9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgaW5saW5lIHZvaWQgczVwdjMxMF9pcnFfZWludF9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1MzIgbWFzazsKIAogCXNwaW5fbG9jaygmZWludF9sb2NrKTsKLQltYXNrID0gX19yYXdfcmVhZGwoUzVQX0VJTlRfTUFTSyhFSU5UX1JFR19OUihpcnEpKSk7Ci0JbWFzayB8PSBlaW50X2lycV90b19iaXQoaXJxKTsKLQlfX3Jhd193cml0ZWwobWFzaywgUzVQX0VJTlRfTUFTSyhFSU5UX1JFR19OUihpcnEpKSk7CisJbWFzayA9IF9fcmF3X3JlYWRsKFM1UF9FSU5UX01BU0soRUlOVF9SRUdfTlIoZGF0YS0+aXJxKSkpOworCW1hc2sgfD0gZWludF9pcnFfdG9fYml0KGRhdGEtPmlycSk7CisJX19yYXdfd3JpdGVsKG1hc2ssIFM1UF9FSU5UX01BU0soRUlOVF9SRUdfTlIoZGF0YS0+aXJxKSkpOwogCXNwaW5fdW5sb2NrKCZlaW50X2xvY2spOwogfQogCi1zdGF0aWMgdm9pZCBzNXB2MzEwX2lycV9laW50X3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgczVwdjMxMF9pcnFfZWludF91bm1hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewogCXUzMiBtYXNrOwogCiAJc3Bpbl9sb2NrKCZlaW50X2xvY2spOwotCW1hc2sgPSBfX3Jhd19yZWFkbChTNVBfRUlOVF9NQVNLKEVJTlRfUkVHX05SKGlycSkpKTsKLQltYXNrICY9IH4oZWludF9pcnFfdG9fYml0KGlycSkpOwotCV9fcmF3X3dyaXRlbChtYXNrLCBTNVBfRUlOVF9NQVNLKEVJTlRfUkVHX05SKGlycSkpKTsKKwltYXNrID0gX19yYXdfcmVhZGwoUzVQX0VJTlRfTUFTSyhFSU5UX1JFR19OUihkYXRhLT5pcnEpKSk7CisJbWFzayAmPSB+KGVpbnRfaXJxX3RvX2JpdChkYXRhLT5pcnEpKTsKKwlfX3Jhd193cml0ZWwobWFzaywgUzVQX0VJTlRfTUFTSyhFSU5UX1JFR19OUihkYXRhLT5pcnEpKSk7CiAJc3Bpbl91bmxvY2soJmVpbnRfbG9jayk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgdm9pZCBzNXB2MzEwX2lycV9laW50X2Fjayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIGlubGluZSB2b2lkIHM1cHYzMTBfaXJxX2VpbnRfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlfX3Jhd193cml0ZWwoZWludF9pcnFfdG9fYml0KGlycSksIFM1UF9FSU5UX1BFTkQoRUlOVF9SRUdfTlIoaXJxKSkpOworCV9fcmF3X3dyaXRlbChlaW50X2lycV90b19iaXQoZGF0YS0+aXJxKSwKKwkJICAgICBTNVBfRUlOVF9QRU5EKEVJTlRfUkVHX05SKGRhdGEtPmlycSkpKTsKIH0KIAotc3RhdGljIHZvaWQgczVwdjMxMF9pcnFfZWludF9tYXNrYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzNXB2MzEwX2lycV9laW50X21hc2thY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXM1cHYzMTBfaXJxX2VpbnRfbWFzayhpcnEpOwotCXM1cHYzMTBfaXJxX2VpbnRfYWNrKGlycSk7CisJczVwdjMxMF9pcnFfZWludF9tYXNrKGRhdGEpOworCXM1cHYzMTBfaXJxX2VpbnRfYWNrKGRhdGEpOwogfQogCi1zdGF0aWMgaW50IHM1cHYzMTBfaXJxX2VpbnRfc2V0X3R5cGUodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IHR5cGUpCitzdGF0aWMgaW50IHM1cHYzMTBfaXJxX2VpbnRfc2V0X3R5cGUoc3RydWN0IGlycV9kYXRhICpkYXRhLCB1bnNpZ25lZCBpbnQgdHlwZSkKIHsKLQlpbnQgb2ZmcyA9IEVJTlRfT0ZGU0VUKGlycSk7CisJaW50IG9mZnMgPSBFSU5UX09GRlNFVChkYXRhLT5pcnEpOwogCWludCBzaGlmdDsKIAl1MzIgY3RybCwgbWFzazsKIAl1MzIgbmV3dmFsdWUgPSAwOwpAQCAtMTE4LDEwICsxMTksMTAgQEAKIAltYXNrID0gMHg3IDw8IHNoaWZ0OwogCiAJc3Bpbl9sb2NrKCZlaW50X2xvY2spOwotCWN0cmwgPSBfX3Jhd19yZWFkbChTNVBfRUlOVF9DT04oRUlOVF9SRUdfTlIoaXJxKSkpOworCWN0cmwgPSBfX3Jhd19yZWFkbChTNVBfRUlOVF9DT04oRUlOVF9SRUdfTlIoZGF0YS0+aXJxKSkpOwogCWN0cmwgJj0gfm1hc2s7CiAJY3RybCB8PSBuZXd2YWx1ZSA8PCBzaGlmdDsKLQlfX3Jhd193cml0ZWwoY3RybCwgUzVQX0VJTlRfQ09OKEVJTlRfUkVHX05SKGlycSkpKTsKKwlfX3Jhd193cml0ZWwoY3RybCwgUzVQX0VJTlRfQ09OKEVJTlRfUkVHX05SKGRhdGEtPmlycSkpKTsKIAlzcGluX3VubG9jaygmZWludF9sb2NrKTsKIAogCXN3aXRjaCAob2ZmcykgewpAQCAtMTQ2LDEzICsxNDcsMTMgQEAKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzNXB2MzEwX2lycV9laW50ID0gewogCS5uYW1lCQk9ICJzNXB2MzEwLWVpbnQiLAotCS5tYXNrCQk9IHM1cHYzMTBfaXJxX2VpbnRfbWFzaywKLQkudW5tYXNrCQk9IHM1cHYzMTBfaXJxX2VpbnRfdW5tYXNrLAotCS5tYXNrX2Fjawk9IHM1cHYzMTBfaXJxX2VpbnRfbWFza2FjaywKLQkuYWNrCQk9IHM1cHYzMTBfaXJxX2VpbnRfYWNrLAotCS5zZXRfdHlwZQk9IHM1cHYzMTBfaXJxX2VpbnRfc2V0X3R5cGUsCisJLmlycV9tYXNrCT0gczVwdjMxMF9pcnFfZWludF9tYXNrLAorCS5pcnFfdW5tYXNrCT0gczVwdjMxMF9pcnFfZWludF91bm1hc2ssCisJLmlycV9tYXNrX2Fjawk9IHM1cHYzMTBfaXJxX2VpbnRfbWFza2FjaywKKwkuaXJxX2Fjawk9IHM1cHYzMTBfaXJxX2VpbnRfYWNrLAorCS5pcnFfc2V0X3R5cGUJPSBzNXB2MzEwX2lycV9laW50X3NldF90eXBlLAogI2lmZGVmIENPTkZJR19QTQotCS5zZXRfd2FrZQk9IHMzY19pcnFleHRfd2FrZSwKKwkuaXJxX3NldF93YWtlCT0gczNjX2lycWV4dF93YWtlLAogI2VuZGlmCiB9OwogCkBAIC0xOTIsMTQgKzE5MywxNCBAQAogCXUzMiAqaXJxX2RhdGEgPSBnZXRfaXJxX2RhdGEoaXJxKTsKIAlzdHJ1Y3QgaXJxX2NoaXAgKmNoaXAgPSBnZXRfaXJxX2NoaXAoaXJxKTsKIAotCWNoaXAtPm1hc2soaXJxKTsKKwljaGlwLT5pcnFfbWFzaygmZGVzYy0+aXJxX2RhdGEpOwogCi0JaWYgKGNoaXAtPmFjaykKLQkJY2hpcC0+YWNrKGlycSk7CisJaWYgKGNoaXAtPmlycV9hY2spCisJCWNoaXAtPmlycV9hY2soJmRlc2MtPmlycV9kYXRhKTsKIAogCWdlbmVyaWNfaGFuZGxlX2lycSgqaXJxX2RhdGEpOwogCi0JY2hpcC0+dW5tYXNrKGlycSk7CisJY2hpcC0+aXJxX3VubWFzaygmZGVzYy0+aXJxX2RhdGEpOwogfQogCiBpbnQgX19pbml0IHM1cHYzMTBfaW5pdF9pcnFfZWludCh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL21hY2gtc21ka2MyMTAuYyBiL2FyY2gvYXJtL21hY2gtczVwdjMxMC9tYWNoLXNtZGtjMjEwLmMKaW5kZXggMmI4ZDRmYy4uZDljYWIwMiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL21hY2gtc21ka2MyMTAuYworKysgYi9hcmNoL2FybS9tYWNoLXM1cHYzMTAvbWFjaC1zbWRrYzIxMC5jCkBAIC0xNCwxOCArMTQsMjEgQEAKICNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9zbXNjOTExeC5oPgogI2luY2x1ZGUgPGxpbnV4L2lvLmg+CisjaW5jbHVkZSA8bGludXgvaTJjLmg+CiAKICNpbmNsdWRlIDxhc20vbWFjaC9hcmNoLmg+CiAjaW5jbHVkZSA8YXNtL21hY2gtdHlwZXMuaD4KIAogI2luY2x1ZGUgPHBsYXQvcmVncy1zZXJpYWwuaD4KKyNpbmNsdWRlIDxwbGF0L3JlZ3Mtc3JvbS5oPgogI2luY2x1ZGUgPHBsYXQvczVwdjMxMC5oPgogI2luY2x1ZGUgPHBsYXQvY3B1Lmg+CiAjaW5jbHVkZSA8cGxhdC9kZXZzLmg+CiAjaW5jbHVkZSA8cGxhdC9zZGhjaS5oPgorI2luY2x1ZGUgPHBsYXQvaWljLmg+CisjaW5jbHVkZSA8cGxhdC9wZC5oPgogCiAjaW5jbHVkZSA8bWFjaC9tYXAuaD4KLSNpbmNsdWRlIDxtYWNoL3JlZ3Mtc3JvbS5oPgogCiAvKiBGb2xsb3dpbmcgYXJlIGRlZmF1bHQgdmFsdWVzIGZvciBVQ09OLCBVTENPTiBhbmQgVUZDT04gVUFSVCByZWdpc3RlcnMgKi8KICNkZWZpbmUgU01ES0MyMTBfVUNPTl9ERUZBVUxUCShTM0MyNDEwX1VDT05fVFhJTEVWRUwgfAlcCkBAIC0xMzksMTMgKzE0MiwyOSBAQAogCX0sCiB9OwogCitzdGF0aWMgc3RydWN0IGkyY19ib2FyZF9pbmZvIGkyY19kZXZzMVtdIF9faW5pdGRhdGEgPSB7CisJe0kyQ19CT0FSRF9JTkZPKCJ3bTg5OTQiLCAweDFhKSx9LAorfTsKKwogc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnNtZGtjMjEwX2RldmljZXNbXSBfX2luaXRkYXRhID0gewogCSZzM2NfZGV2aWNlX2hzbW1jMCwKIAkmczNjX2RldmljZV9oc21tYzEsCiAJJnMzY19kZXZpY2VfaHNtbWMyLAogCSZzM2NfZGV2aWNlX2hzbW1jMywKKwkmczNjX2RldmljZV9pMmMxLAogCSZzM2NfZGV2aWNlX3J0YywKIAkmczNjX2RldmljZV93ZHQsCisJJnM1cHYzMTBfZGV2aWNlX2FjOTcsCisJJnM1cHYzMTBfZGV2aWNlX2kyczAsCisJJnM1cHYzMTBfZGV2aWNlX3BkW1BEX01GQ10sCisJJnM1cHYzMTBfZGV2aWNlX3BkW1BEX0czRF0sCisJJnM1cHYzMTBfZGV2aWNlX3BkW1BEX0xDRDBdLAorCSZzNXB2MzEwX2RldmljZV9wZFtQRF9MQ0QxXSwKKwkmczVwdjMxMF9kZXZpY2VfcGRbUERfQ0FNXSwKKwkmczVwdjMxMF9kZXZpY2VfcGRbUERfVFZdLAorCSZzNXB2MzEwX2RldmljZV9wZFtQRF9HUFNdLAorCSZzNXB2MzEwX2RldmljZV9zeXNtbXUsCisJJnNhbXN1bmdfYXNvY19kbWEsCiAJJnNtZGtjMjEwX3Ntc2M5MTF4LAogfTsKIApAQCAtMTU0LDIzICsxNzMsMjIgQEAKIAl1MzIgY3MxOwogCiAJLyogY29uZmlndXJlIG5DUzEgd2lkdGggdG8gMTYgYml0cyAqLwotCWNzMSA9IF9fcmF3X3JlYWRsKFM1UFYzMTBfU1JPTV9CVykgJgotCQkgICAgfihTNVBWMzEwX1NST01fQldfX0NTX01BU0sgPDwKLQkJCQkgICAgUzVQVjMxMF9TUk9NX0JXX19OQ1MxX19TSElGVCk7Ci0JY3MxIHw9ICgoMSA8PCBTNVBWMzEwX1NST01fQldfX0RBVEFXSURUSF9fU0hJRlQpIHwKLQkJKDEgPDwgUzVQVjMxMF9TUk9NX0JXX19XQUlURU5BQkxFX19TSElGVCkgfAotCQkoMSA8PCBTNVBWMzEwX1NST01fQldfX0JZVEVFTkFCTEVfX1NISUZUKSkgPDwKLQkJUzVQVjMxMF9TUk9NX0JXX19OQ1MxX19TSElGVDsKLQlfX3Jhd193cml0ZWwoY3MxLCBTNVBWMzEwX1NST01fQlcpOworCWNzMSA9IF9fcmF3X3JlYWRsKFM1UF9TUk9NX0JXKSAmCisJCX4oUzVQX1NST01fQldfX0NTX01BU0sgPDwgUzVQX1NST01fQldfX05DUzFfX1NISUZUKTsKKwljczEgfD0gKCgxIDw8IFM1UF9TUk9NX0JXX19EQVRBV0lEVEhfX1NISUZUKSB8CisJCSgxIDw8IFM1UF9TUk9NX0JXX19XQUlURU5BQkxFX19TSElGVCkgfAorCQkoMSA8PCBTNVBfU1JPTV9CV19fQllURUVOQUJMRV9fU0hJRlQpKSA8PAorCQlTNVBfU1JPTV9CV19fTkNTMV9fU0hJRlQ7CisJX19yYXdfd3JpdGVsKGNzMSwgUzVQX1NST01fQlcpOwogCiAJLyogc2V0IHRpbWluZyBmb3IgbkNTMSBzdWl0YWJsZSBmb3IgZXRoZXJuZXQgY2hpcCAqLwotCV9fcmF3X3dyaXRlbCgoMHgxIDw8IFM1UFYzMTBfU1JPTV9CQ1hfX1BNQ19fU0hJRlQpIHwKLQkJICAgICAoMHg5IDw8IFM1UFYzMTBfU1JPTV9CQ1hfX1RBQ1BfX1NISUZUKSB8Ci0JCSAgICAgKDB4YyA8PCBTNVBWMzEwX1NST01fQkNYX19UQ0FIX19TSElGVCkgfAotCQkgICAgICgweDEgPDwgUzVQVjMxMF9TUk9NX0JDWF9fVENPSF9fU0hJRlQpIHwKLQkJICAgICAoMHg2IDw8IFM1UFYzMTBfU1JPTV9CQ1hfX1RBQ0NfX1NISUZUKSB8Ci0JCSAgICAgKDB4MSA8PCBTNVBWMzEwX1NST01fQkNYX19UQ09TX19TSElGVCkgfAotCQkgICAgICgweDEgPDwgUzVQVjMxMF9TUk9NX0JDWF9fVEFDU19fU0hJRlQpLCBTNVBWMzEwX1NST01fQkMxKTsKKwlfX3Jhd193cml0ZWwoKDB4MSA8PCBTNVBfU1JPTV9CQ1hfX1BNQ19fU0hJRlQpIHwKKwkJICAgICAoMHg5IDw8IFM1UF9TUk9NX0JDWF9fVEFDUF9fU0hJRlQpIHwKKwkJICAgICAoMHhjIDw8IFM1UF9TUk9NX0JDWF9fVENBSF9fU0hJRlQpIHwKKwkJICAgICAoMHgxIDw8IFM1UF9TUk9NX0JDWF9fVENPSF9fU0hJRlQpIHwKKwkJICAgICAoMHg2IDw8IFM1UF9TUk9NX0JDWF9fVEFDQ19fU0hJRlQpIHwKKwkJICAgICAoMHgxIDw8IFM1UF9TUk9NX0JDWF9fVENPU19fU0hJRlQpIHwKKwkJICAgICAoMHgxIDw8IFM1UF9TUk9NX0JDWF9fVEFDU19fU0hJRlQpLCBTNVBfU1JPTV9CQzEpOwogfQogCiBzdGF0aWMgdm9pZCBfX2luaXQgc21ka2MyMTBfbWFwX2lvKHZvaWQpCkBAIC0xODIsNiArMjAwLDkgQEAKIAogc3RhdGljIHZvaWQgX19pbml0IHNtZGtjMjEwX21hY2hpbmVfaW5pdCh2b2lkKQogeworCXMzY19pMmMxX3NldF9wbGF0ZGF0YShOVUxMKTsKKwlpMmNfcmVnaXN0ZXJfYm9hcmRfaW5mbygxLCBpMmNfZGV2czEsIEFSUkFZX1NJWkUoaTJjX2RldnMxKSk7CisKIAlzbWRrYzIxMF9zbXNjOTExeF9pbml0KCk7CiAKIAlzM2Nfc2RoY2kwX3NldF9wbGF0ZGF0YSgmc21ka2MyMTBfaHNtbWMwX3BkYXRhKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtczVwdjMxMC9tYWNoLXNtZGt2MzEwLmMgYi9hcmNoL2FybS9tYWNoLXM1cHYzMTAvbWFjaC1zbWRrdjMxMC5jCmluZGV4IDM1ODI2ZDYuLmIxY2RkYmYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtczVwdjMxMC9tYWNoLXNtZGt2MzEwLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL21hY2gtc21ka3YzMTAuYwpAQCAtMTQsMTggKzE0LDIxIEBACiAjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvc21zYzkxMXguaD4KICNpbmNsdWRlIDxsaW51eC9pby5oPgorI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgogCiAjaW5jbHVkZSA8YXNtL21hY2gvYXJjaC5oPgogI2luY2x1ZGUgPGFzbS9tYWNoLXR5cGVzLmg+CiAKICNpbmNsdWRlIDxwbGF0L3JlZ3Mtc2VyaWFsLmg+CisjaW5jbHVkZSA8cGxhdC9yZWdzLXNyb20uaD4KICNpbmNsdWRlIDxwbGF0L3M1cHYzMTAuaD4KICNpbmNsdWRlIDxwbGF0L2NwdS5oPgogI2luY2x1ZGUgPHBsYXQvZGV2cy5oPgogI2luY2x1ZGUgPHBsYXQvc2RoY2kuaD4KKyNpbmNsdWRlIDxwbGF0L2lpYy5oPgorI2luY2x1ZGUgPHBsYXQvcGQuaD4KIAogI2luY2x1ZGUgPG1hY2gvbWFwLmg+Ci0jaW5jbHVkZSA8bWFjaC9yZWdzLXNyb20uaD4KIAogLyogRm9sbG93aW5nIGFyZSBkZWZhdWx0IHZhbHVlcyBmb3IgVUNPTiwgVUxDT04gYW5kIFVGQ09OIFVBUlQgcmVnaXN0ZXJzICovCiAjZGVmaW5lIFNNREtWMzEwX1VDT05fREVGQVVMVAkoUzNDMjQxMF9VQ09OX1RYSUxFVkVMIHwJXApAQCAtMTM5LDEzICsxNDIsMjkgQEAKIAl9LAogfTsKIAorc3RhdGljIHN0cnVjdCBpMmNfYm9hcmRfaW5mbyBpMmNfZGV2czFbXSBfX2luaXRkYXRhID0geworCXtJMkNfQk9BUkRfSU5GTygid204OTk0IiwgMHgxYSksfSwKK307CisKIHN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpzbWRrdjMxMF9kZXZpY2VzW10gX19pbml0ZGF0YSA9IHsKIAkmczNjX2RldmljZV9oc21tYzAsCiAJJnMzY19kZXZpY2VfaHNtbWMxLAogCSZzM2NfZGV2aWNlX2hzbW1jMiwKIAkmczNjX2RldmljZV9oc21tYzMsCisJJnMzY19kZXZpY2VfaTJjMSwKIAkmczNjX2RldmljZV9ydGMsCiAJJnMzY19kZXZpY2Vfd2R0LAorCSZzNXB2MzEwX2RldmljZV9hYzk3LAorCSZzNXB2MzEwX2RldmljZV9pMnMwLAorCSZzNXB2MzEwX2RldmljZV9wZFtQRF9NRkNdLAorCSZzNXB2MzEwX2RldmljZV9wZFtQRF9HM0RdLAorCSZzNXB2MzEwX2RldmljZV9wZFtQRF9MQ0QwXSwKKwkmczVwdjMxMF9kZXZpY2VfcGRbUERfTENEMV0sCisJJnM1cHYzMTBfZGV2aWNlX3BkW1BEX0NBTV0sCisJJnM1cHYzMTBfZGV2aWNlX3BkW1BEX1RWXSwKKwkmczVwdjMxMF9kZXZpY2VfcGRbUERfR1BTXSwKKwkmczVwdjMxMF9kZXZpY2Vfc3lzbW11LAorCSZzYW1zdW5nX2Fzb2NfZG1hLAogCSZzbWRrdjMxMF9zbXNjOTExeCwKIH07CiAKQEAgLTE1NCwyMyArMTczLDIyIEBACiAJdTMyIGNzMTsKIAogCS8qIGNvbmZpZ3VyZSBuQ1MxIHdpZHRoIHRvIDE2IGJpdHMgKi8KLQljczEgPSBfX3Jhd19yZWFkbChTNVBWMzEwX1NST01fQlcpICYKLQkJICAgIH4oUzVQVjMxMF9TUk9NX0JXX19DU19NQVNLIDw8Ci0JCQkJICAgIFM1UFYzMTBfU1JPTV9CV19fTkNTMV9fU0hJRlQpOwotCWNzMSB8PSAoKDEgPDwgUzVQVjMxMF9TUk9NX0JXX19EQVRBV0lEVEhfX1NISUZUKSB8Ci0JCSgxIDw8IFM1UFYzMTBfU1JPTV9CV19fV0FJVEVOQUJMRV9fU0hJRlQpIHwKLQkJKDEgPDwgUzVQVjMxMF9TUk9NX0JXX19CWVRFRU5BQkxFX19TSElGVCkpIDw8Ci0JCVM1UFYzMTBfU1JPTV9CV19fTkNTMV9fU0hJRlQ7Ci0JX19yYXdfd3JpdGVsKGNzMSwgUzVQVjMxMF9TUk9NX0JXKTsKKwljczEgPSBfX3Jhd19yZWFkbChTNVBfU1JPTV9CVykgJgorCQl+KFM1UF9TUk9NX0JXX19DU19NQVNLIDw8IFM1UF9TUk9NX0JXX19OQ1MxX19TSElGVCk7CisJY3MxIHw9ICgoMSA8PCBTNVBfU1JPTV9CV19fREFUQVdJRFRIX19TSElGVCkgfAorCQkoMSA8PCBTNVBfU1JPTV9CV19fV0FJVEVOQUJMRV9fU0hJRlQpIHwKKwkJKDEgPDwgUzVQX1NST01fQldfX0JZVEVFTkFCTEVfX1NISUZUKSkgPDwKKwkJUzVQX1NST01fQldfX05DUzFfX1NISUZUOworCV9fcmF3X3dyaXRlbChjczEsIFM1UF9TUk9NX0JXKTsKIAogCS8qIHNldCB0aW1pbmcgZm9yIG5DUzEgc3VpdGFibGUgZm9yIGV0aGVybmV0IGNoaXAgKi8KLQlfX3Jhd193cml0ZWwoKDB4MSA8PCBTNVBWMzEwX1NST01fQkNYX19QTUNfX1NISUZUKSB8Ci0JCSAgICAgKDB4OSA8PCBTNVBWMzEwX1NST01fQkNYX19UQUNQX19TSElGVCkgfAotCQkgICAgICgweGMgPDwgUzVQVjMxMF9TUk9NX0JDWF9fVENBSF9fU0hJRlQpIHwKLQkJICAgICAoMHgxIDw8IFM1UFYzMTBfU1JPTV9CQ1hfX1RDT0hfX1NISUZUKSB8Ci0JCSAgICAgKDB4NiA8PCBTNVBWMzEwX1NST01fQkNYX19UQUNDX19TSElGVCkgfAotCQkgICAgICgweDEgPDwgUzVQVjMxMF9TUk9NX0JDWF9fVENPU19fU0hJRlQpIHwKLQkJICAgICAoMHgxIDw8IFM1UFYzMTBfU1JPTV9CQ1hfX1RBQ1NfX1NISUZUKSwgUzVQVjMxMF9TUk9NX0JDMSk7CisJX19yYXdfd3JpdGVsKCgweDEgPDwgUzVQX1NST01fQkNYX19QTUNfX1NISUZUKSB8CisJCSAgICAgKDB4OSA8PCBTNVBfU1JPTV9CQ1hfX1RBQ1BfX1NISUZUKSB8CisJCSAgICAgKDB4YyA8PCBTNVBfU1JPTV9CQ1hfX1RDQUhfX1NISUZUKSB8CisJCSAgICAgKDB4MSA8PCBTNVBfU1JPTV9CQ1hfX1RDT0hfX1NISUZUKSB8CisJCSAgICAgKDB4NiA8PCBTNVBfU1JPTV9CQ1hfX1RBQ0NfX1NISUZUKSB8CisJCSAgICAgKDB4MSA8PCBTNVBfU1JPTV9CQ1hfX1RDT1NfX1NISUZUKSB8CisJCSAgICAgKDB4MSA8PCBTNVBfU1JPTV9CQ1hfX1RBQ1NfX1NISUZUKSwgUzVQX1NST01fQkMxKTsKIH0KIAogc3RhdGljIHZvaWQgX19pbml0IHNtZGt2MzEwX21hcF9pbyh2b2lkKQpAQCAtMTgyLDYgKzIwMCw5IEBACiAKIHN0YXRpYyB2b2lkIF9faW5pdCBzbWRrdjMxMF9tYWNoaW5lX2luaXQodm9pZCkKIHsKKwlzM2NfaTJjMV9zZXRfcGxhdGRhdGEoTlVMTCk7CisJaTJjX3JlZ2lzdGVyX2JvYXJkX2luZm8oMSwgaTJjX2RldnMxLCBBUlJBWV9TSVpFKGkyY19kZXZzMSkpOworCiAJc21ka3YzMTBfc21zYzkxMXhfaW5pdCgpOwogCiAJczNjX3NkaGNpMF9zZXRfcGxhdGRhdGEoJnNtZGt2MzEwX2hzbW1jMF9wZGF0YSk7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXM1cHYzMTAvbWFjaC11bml2ZXJzYWxfYzIxMC5jIGIvYXJjaC9hcm0vbWFjaC1zNXB2MzEwL21hY2gtdW5pdmVyc2FsX2MyMTAuYwppbmRleCAxNmQ4ZmMwLi4zNmJjM2NmIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXM1cHYzMTAvbWFjaC11bml2ZXJzYWxfYzIxMC5jCisrKyBiL2FyY2gvYXJtL21hY2gtczVwdjMxMC9tYWNoLXVuaXZlcnNhbF9jMjEwLmMKQEAgLTEzLDYgKzEzLDkgQEAKICNpbmNsdWRlIDxsaW51eC9pMmMuaD4KICNpbmNsdWRlIDxsaW51eC9ncGlvX2tleXMuaD4KICNpbmNsdWRlIDxsaW51eC9ncGlvLmg+CisjaW5jbHVkZSA8bGludXgvcmVndWxhdG9yL21hY2hpbmUuaD4KKyNpbmNsdWRlIDxsaW51eC9yZWd1bGF0b3IvZml4ZWQuaD4KKyNpbmNsdWRlIDxsaW51eC9tbWMvaG9zdC5oPgogCiAjaW5jbHVkZSA8YXNtL21hY2gvYXJjaC5oPgogI2luY2x1ZGUgPGFzbS9tYWNoLXR5cGVzLmg+CkBAIC0yMSw2ICsyNCw3IEBACiAjaW5jbHVkZSA8cGxhdC9zNXB2MzEwLmg+CiAjaW5jbHVkZSA8cGxhdC9jcHUuaD4KICNpbmNsdWRlIDxwbGF0L2RldnMuaD4KKyNpbmNsdWRlIDxwbGF0L3NkaGNpLmg+CiAKICNpbmNsdWRlIDxtYWNoL21hcC5oPgogCkBAIC0xMTYsNiArMTIwLDczIEBACiAJfSwKIH07CiAKKy8qIGVNTUMgKi8KK3N0YXRpYyBzdHJ1Y3QgczNjX3NkaGNpX3BsYXRkYXRhIHVuaXZlcnNhbF9oc21tYzBfZGF0YSBfX2luaXRkYXRhID0geworCS5tYXhfd2lkdGgJCT0gOCwKKwkuaG9zdF9jYXBzCQk9IChNTUNfQ0FQXzhfQklUX0RBVEEgfCBNTUNfQ0FQXzRfQklUX0RBVEEgfAorCQkJCU1NQ19DQVBfTU1DX0hJR0hTUEVFRCB8IE1NQ19DQVBfU0RfSElHSFNQRUVEIHwKKwkJCQlNTUNfQ0FQX0RJU0FCTEUpLAorCS5jZF90eXBlCQk9IFMzQ19TREhDSV9DRF9QRVJNQU5FTlQsCisJLmNsa190eXBlCQk9IFMzQ19TREhDSV9DTEtfRElWX0VYVEVSTkFMLAorfTsKKworc3RhdGljIHN0cnVjdCByZWd1bGF0b3JfY29uc3VtZXJfc3VwcGx5IG1tYzBfc3VwcGxpZXNbXSA9IHsKKwlSRUdVTEFUT1JfU1VQUExZKCJ2bW1jIiwgInMzYy1zZGhjaS4wIiksCit9OworCitzdGF0aWMgc3RydWN0IHJlZ3VsYXRvcl9pbml0X2RhdGEgbW1jMF9maXhlZF92b2x0YWdlX2luaXRfZGF0YSA9IHsKKwkuY29uc3RyYWludHMJCT0geworCQkubmFtZQkJPSAiVk1FTV9WRERfMi44ViIsCisJCS52YWxpZF9vcHNfbWFzawk9IFJFR1VMQVRPUl9DSEFOR0VfU1RBVFVTLAorCX0sCisJLm51bV9jb25zdW1lcl9zdXBwbGllcwk9IEFSUkFZX1NJWkUobW1jMF9zdXBwbGllcyksCisJLmNvbnN1bWVyX3N1cHBsaWVzCT0gbW1jMF9zdXBwbGllcywKK307CisKK3N0YXRpYyBzdHJ1Y3QgZml4ZWRfdm9sdGFnZV9jb25maWcgbW1jMF9maXhlZF92b2x0YWdlX2NvbmZpZyA9IHsKKwkuc3VwcGx5X25hbWUJCT0gIk1BU1NNRU1PUllfRU4iLAorCS5taWNyb3ZvbHRzCQk9IDI4MDAwMDAsCisJLmdwaW8JCQk9IFM1UFYzMTBfR1BFMSgzKSwKKwkuZW5hYmxlX2hpZ2gJCT0gdHJ1ZSwKKwkuaW5pdF9kYXRhCQk9ICZtbWMwX2ZpeGVkX3ZvbHRhZ2VfaW5pdF9kYXRhLAorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgbW1jMF9maXhlZF92b2x0YWdlID0geworCS5uYW1lCQkJPSAicmVnLWZpeGVkLXZvbHRhZ2UiLAorCS5pZAkJCT0gMCwKKwkuZGV2CQkJPSB7CisJCS5wbGF0Zm9ybV9kYXRhCT0gJm1tYzBfZml4ZWRfdm9sdGFnZV9jb25maWcsCisJfSwKK307CisKKy8qIFNEICovCitzdGF0aWMgc3RydWN0IHMzY19zZGhjaV9wbGF0ZGF0YSB1bml2ZXJzYWxfaHNtbWMyX2RhdGEgX19pbml0ZGF0YSA9IHsKKwkubWF4X3dpZHRoCQk9IDQsCisJLmhvc3RfY2FwcwkJPSBNTUNfQ0FQXzRfQklUX0RBVEEgfAorCQkJCU1NQ19DQVBfTU1DX0hJR0hTUEVFRCB8IE1NQ19DQVBfU0RfSElHSFNQRUVEIHwKKwkJCQlNTUNfQ0FQX0RJU0FCTEUsCisJLmV4dF9jZF9ncGlvCQk9IFM1UFYzMTBfR1BYMyg0KSwgICAgICAvKiBYRUlOVF8yOCAqLworCS5leHRfY2RfZ3Bpb19pbnZlcnQJPSAxLAorCS5jZF90eXBlCQk9IFMzQ19TREhDSV9DRF9HUElPLAorCS5jbGtfdHlwZQkJPSBTM0NfU0RIQ0lfQ0xLX0RJVl9FWFRFUk5BTCwKK307CisKKy8qIFdpRmkgKi8KK3N0YXRpYyBzdHJ1Y3QgczNjX3NkaGNpX3BsYXRkYXRhIHVuaXZlcnNhbF9oc21tYzNfZGF0YSBfX2luaXRkYXRhID0geworCS5tYXhfd2lkdGgJCT0gNCwKKwkuaG9zdF9jYXBzCQk9IE1NQ19DQVBfNF9CSVRfREFUQSB8CisJCQkJTU1DX0NBUF9NTUNfSElHSFNQRUVEIHwgTU1DX0NBUF9TRF9ISUdIU1BFRUQgfAorCQkJCU1NQ19DQVBfRElTQUJMRSwKKwkuY2RfdHlwZQkJPSBTM0NfU0RIQ0lfQ0RfRVhURVJOQUwsCit9OworCitzdGF0aWMgdm9pZCBfX2luaXQgdW5pdmVyc2FsX3NkaGNpX2luaXQodm9pZCkKK3sKKwlzM2Nfc2RoY2kwX3NldF9wbGF0ZGF0YSgmdW5pdmVyc2FsX2hzbW1jMF9kYXRhKTsKKwlzM2Nfc2RoY2kyX3NldF9wbGF0ZGF0YSgmdW5pdmVyc2FsX2hzbW1jMl9kYXRhKTsKKwlzM2Nfc2RoY2kzX3NldF9wbGF0ZGF0YSgmdW5pdmVyc2FsX2hzbW1jM19kYXRhKTsKK30KKwogLyogSTJDMCAqLwogc3RhdGljIHN0cnVjdCBpMmNfYm9hcmRfaW5mbyBpMmMwX2RldnNbXSBfX2luaXRkYXRhID0gewogCS8qIENhbWVyYSwgVG8gYmUgdXBkYXRlZCAqLwpAQCAtMTI3LDYgKzE5OCwxMyBAQAogfTsKIAogc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnVuaXZlcnNhbF9kZXZpY2VzW10gX19pbml0ZGF0YSA9IHsKKwkvKiBTYW1zdW5nIFBsYXRmb3JtIERldmljZXMgKi8KKwkmbW1jMF9maXhlZF92b2x0YWdlLAorCSZzM2NfZGV2aWNlX2hzbW1jMCwKKwkmczNjX2RldmljZV9oc21tYzIsCisJJnMzY19kZXZpY2VfaHNtbWMzLAorCisJLyogVW5pdmVyc2FsIERldmljZXMgKi8KIAkmdW5pdmVyc2FsX2dwaW9fa2V5cywKIAkmczVwX2RldmljZV9vbmVuYW5kLAogfTsKQEAgLTE0MCw2ICsyMTgsOCBAQAogCiBzdGF0aWMgdm9pZCBfX2luaXQgdW5pdmVyc2FsX21hY2hpbmVfaW5pdCh2b2lkKQogeworCXVuaXZlcnNhbF9zZGhjaV9pbml0KCk7CisKIAlpMmNfcmVnaXN0ZXJfYm9hcmRfaW5mbygwLCBpMmMwX2RldnMsIEFSUkFZX1NJWkUoaTJjMF9kZXZzKSk7CiAJaTJjX3JlZ2lzdGVyX2JvYXJkX2luZm8oMSwgaTJjMV9kZXZzLCBBUlJBWV9TSVpFKGkyYzFfZGV2cykpOwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXNhMTEwMC9nZW5lcmljLmMgYi9hcmNoL2FybS9tYWNoLXNhMTEwMC9nZW5lcmljLmMKaW5kZXggNTlkMTRmMC4uZTIxZjM0NyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zYTExMDAvZ2VuZXJpYy5jCisrKyBiL2FyY2gvYXJtL21hY2gtc2ExMTAwL2dlbmVyaWMuYwpAQCAtMjEsNyArMjEsNiBAQAogI2luY2x1ZGUgPGFzbS9kaXY2NC5oPgogI2luY2x1ZGUgPG1hY2gvaGFyZHdhcmUuaD4KICNpbmNsdWRlIDxhc20vc3lzdGVtLmg+Ci0jaW5jbHVkZSA8YXNtL3BndGFibGUuaD4KICNpbmNsdWRlIDxhc20vbWFjaC9tYXAuaD4KICNpbmNsdWRlIDxhc20vbWFjaC9mbGFzaC5oPgogI2luY2x1ZGUgPGFzbS9pcnEuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtc2ExMTAwL2lycS5jIGIvYXJjaC9hcm0vbWFjaC1zYTExMDAvaXJxLmMKaW5kZXggMzA5M2Q0Ni4uM2Q4NWRmYSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zYTExMDAvaXJxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zYTExMDAvaXJxLmMKQEAgLTM3LDE0ICszNywxNCBAQAogI2RlZmluZSBHUElPXzExXzI3X0lSUShpKQkoKGkpIC0gMjEpCiAjZGVmaW5lIEdQSU8xMV8yN19NQVNLKGlycSkJKDEgPDwgR1BJT18xMV8yN19JUlEoaXJxKSkKIAotc3RhdGljIGludCBzYTExMDBfZ3Bpb190eXBlKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCB0eXBlKQorc3RhdGljIGludCBzYTExMDBfZ3Bpb190eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IHR5cGUpCiB7CiAJdW5zaWduZWQgaW50IG1hc2s7CiAKLQlpZiAoaXJxIDw9IDEwKQotCQltYXNrID0gMSA8PCBpcnE7CisJaWYgKGQtPmlycSA8PSAxMCkKKwkJbWFzayA9IDEgPDwgZC0+aXJxOwogCWVsc2UKLQkJbWFzayA9IEdQSU8xMV8yN19NQVNLKGlycSk7CisJCW1hc2sgPSBHUElPMTFfMjdfTUFTSyhkLT5pcnEpOwogCiAJaWYgKHR5cGUgPT0gSVJRX1RZUEVfUFJPQkUpIHsKIAkJaWYgKChHUElPX0lSUV9yaXNpbmdfZWRnZSB8IEdQSU9fSVJRX2ZhbGxpbmdfZWRnZSkgJiBtYXNrKQpAQCAtNzAsMzcgKzcwLDM3IEBACiAvKgogICogR1BJTyBJUlFzIG11c3QgYmUgYWNrbm93bGVkZ2VkLiAgVGhpcyBpcyBmb3IgSVJRcyBmcm9tIDAgdG8gMTAuCiAgKi8KLXN0YXRpYyB2b2lkIHNhMTEwMF9sb3dfZ3Bpb19hY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHNhMTEwMF9sb3dfZ3Bpb19hY2soc3RydWN0IGlycV9kYXRhICpkKQogewotCUdFRFIgPSAoMSA8PCBpcnEpOworCUdFRFIgPSAoMSA8PCBkLT5pcnEpOwogfQogCi1zdGF0aWMgdm9pZCBzYTExMDBfbG93X2dwaW9fbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc2ExMTAwX2xvd19ncGlvX21hc2soc3RydWN0IGlycV9kYXRhICpkKQogewotCUlDTVIgJj0gfigxIDw8IGlycSk7CisJSUNNUiAmPSB+KDEgPDwgZC0+aXJxKTsKIH0KIAotc3RhdGljIHZvaWQgc2ExMTAwX2xvd19ncGlvX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc2ExMTAwX2xvd19ncGlvX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JSUNNUiB8PSAxIDw8IGlycTsKKwlJQ01SIHw9IDEgPDwgZC0+aXJxOwogfQogCi1zdGF0aWMgaW50IHNhMTEwMF9sb3dfZ3Bpb193YWtlKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCBvbikKK3N0YXRpYyBpbnQgc2ExMTAwX2xvd19ncGlvX3dha2Uoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgb24pCiB7CiAJaWYgKG9uKQotCQlQV0VSIHw9IDEgPDwgaXJxOworCQlQV0VSIHw9IDEgPDwgZC0+aXJxOwogCWVsc2UKLQkJUFdFUiAmPSB+KDEgPDwgaXJxKTsKKwkJUFdFUiAmPSB+KDEgPDwgZC0+aXJxKTsKIAlyZXR1cm4gMDsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzYTExMDBfbG93X2dwaW9fY2hpcCA9IHsKIAkubmFtZQkJPSAiR1BJTy1sIiwKLQkuYWNrCQk9IHNhMTEwMF9sb3dfZ3Bpb19hY2ssCi0JLm1hc2sJCT0gc2ExMTAwX2xvd19ncGlvX21hc2ssCi0JLnVubWFzawkJPSBzYTExMDBfbG93X2dwaW9fdW5tYXNrLAotCS5zZXRfdHlwZQk9IHNhMTEwMF9ncGlvX3R5cGUsCi0JLnNldF93YWtlCT0gc2ExMTAwX2xvd19ncGlvX3dha2UsCisJLmlycV9hY2sJPSBzYTExMDBfbG93X2dwaW9fYWNrLAorCS5pcnFfbWFzawk9IHNhMTEwMF9sb3dfZ3Bpb19tYXNrLAorCS5pcnFfdW5tYXNrCT0gc2ExMTAwX2xvd19ncGlvX3VubWFzaywKKwkuaXJxX3NldF90eXBlCT0gc2ExMTAwX2dwaW9fdHlwZSwKKwkuaXJxX3NldF93YWtlCT0gc2ExMTAwX2xvd19ncGlvX3dha2UsCiB9OwogCiAvKgpAQCAtMTM5LDE2ICsxMzksMTYgQEAKICAqIEluIGFkZGl0aW9uLCB0aGUgSVJRcyBhcmUgYWxsIGNvbGxlY3RlZCB1cCBpbnRvIG9uZSBiaXQgaW4gdGhlCiAgKiBpbnRlcnJ1cHQgY29udHJvbGxlciByZWdpc3RlcnMuCiAgKi8KLXN0YXRpYyB2b2lkIHNhMTEwMF9oaWdoX2dwaW9fYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzYTExMDBfaGlnaF9ncGlvX2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JdW5zaWduZWQgaW50IG1hc2sgPSBHUElPMTFfMjdfTUFTSyhpcnEpOworCXVuc2lnbmVkIGludCBtYXNrID0gR1BJTzExXzI3X01BU0soZC0+aXJxKTsKIAogCUdFRFIgPSBtYXNrOwogfQogCi1zdGF0aWMgdm9pZCBzYTExMDBfaGlnaF9ncGlvX21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHNhMTEwMF9oaWdoX2dwaW9fbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JdW5zaWduZWQgaW50IG1hc2sgPSBHUElPMTFfMjdfTUFTSyhpcnEpOworCXVuc2lnbmVkIGludCBtYXNrID0gR1BJTzExXzI3X01BU0soZC0+aXJxKTsKIAogCUdQSU9fSVJRX21hc2sgJj0gfm1hc2s7CiAKQEAgLTE1Niw5ICsxNTYsOSBAQAogCUdGRVIgJj0gfm1hc2s7CiB9CiAKLXN0YXRpYyB2b2lkIHNhMTEwMF9oaWdoX2dwaW9fdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzYTExMDBfaGlnaF9ncGlvX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JdW5zaWduZWQgaW50IG1hc2sgPSBHUElPMTFfMjdfTUFTSyhpcnEpOworCXVuc2lnbmVkIGludCBtYXNrID0gR1BJTzExXzI3X01BU0soZC0+aXJxKTsKIAogCUdQSU9fSVJRX21hc2sgfD0gbWFzazsKIApAQCAtMTY2LDQ0ICsxNjYsNDQgQEAKIAlHRkVSID0gR1BJT19JUlFfZmFsbGluZ19lZGdlICYgR1BJT19JUlFfbWFzazsKIH0KIAotc3RhdGljIGludCBzYTExMDBfaGlnaF9ncGlvX3dha2UodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IG9uKQorc3RhdGljIGludCBzYTExMDBfaGlnaF9ncGlvX3dha2Uoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgb24pCiB7CiAJaWYgKG9uKQotCQlQV0VSIHw9IEdQSU8xMV8yN19NQVNLKGlycSk7CisJCVBXRVIgfD0gR1BJTzExXzI3X01BU0soZC0+aXJxKTsKIAllbHNlCi0JCVBXRVIgJj0gfkdQSU8xMV8yN19NQVNLKGlycSk7CisJCVBXRVIgJj0gfkdQSU8xMV8yN19NQVNLKGQtPmlycSk7CiAJcmV0dXJuIDA7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgc2ExMTAwX2hpZ2hfZ3Bpb19jaGlwID0gewogCS5uYW1lCQk9ICJHUElPLWgiLAotCS5hY2sJCT0gc2ExMTAwX2hpZ2hfZ3Bpb19hY2ssCi0JLm1hc2sJCT0gc2ExMTAwX2hpZ2hfZ3Bpb19tYXNrLAotCS51bm1hc2sJCT0gc2ExMTAwX2hpZ2hfZ3Bpb191bm1hc2ssCi0JLnNldF90eXBlCT0gc2ExMTAwX2dwaW9fdHlwZSwKLQkuc2V0X3dha2UJPSBzYTExMDBfaGlnaF9ncGlvX3dha2UsCisJLmlycV9hY2sJPSBzYTExMDBfaGlnaF9ncGlvX2FjaywKKwkuaXJxX21hc2sJPSBzYTExMDBfaGlnaF9ncGlvX21hc2ssCisJLmlycV91bm1hc2sJPSBzYTExMDBfaGlnaF9ncGlvX3VubWFzaywKKwkuaXJxX3NldF90eXBlCT0gc2ExMTAwX2dwaW9fdHlwZSwKKwkuaXJxX3NldF93YWtlCT0gc2ExMTAwX2hpZ2hfZ3Bpb193YWtlLAogfTsKIAogLyoKICAqIFdlIGRvbid0IG5lZWQgdG8gQUNLIElSUXMgb24gdGhlIFNBMTEwMCB1bmxlc3MgdGhleSdyZSBHUElPcwogICogdGhpcyBpcyBmb3IgaW50ZXJuYWwgSVJRcyBpLmUuIGZyb20gMTEgdG8gMzEuCiAgKi8KLXN0YXRpYyB2b2lkIHNhMTEwMF9tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc2ExMTAwX21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlJQ01SICY9IH4oMSA8PCBpcnEpOworCUlDTVIgJj0gfigxIDw8IGQtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIHNhMTEwMF91bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzYTExMDBfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JSUNNUiB8PSAoMSA8PCBpcnEpOworCUlDTVIgfD0gKDEgPDwgZC0+aXJxKTsKIH0KIAogLyoKICAqIEFwYXJ0IGZvcm0gR1BJT3MsIG9ubHkgdGhlIFJUQyBhbGFybSBjYW4gYmUgYSB3YWtldXAgZXZlbnQuCiAgKi8KLXN0YXRpYyBpbnQgc2ExMTAwX3NldF93YWtlKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCBvbikKK3N0YXRpYyBpbnQgc2ExMTAwX3NldF93YWtlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IG9uKQogewotCWlmIChpcnEgPT0gSVJRX1JUQ0Fscm0pIHsKKwlpZiAoZC0+aXJxID09IElSUV9SVENBbHJtKSB7CiAJCWlmIChvbikKIAkJCVBXRVIgfD0gUFdFUl9SVEM7CiAJCWVsc2UKQEAgLTIxNSwxMCArMjE1LDEwIEBACiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgc2ExMTAwX25vcm1hbF9jaGlwID0gewogCS5uYW1lCQk9ICJTQyIsCi0JLmFjawkJPSBzYTExMDBfbWFza19pcnEsCi0JLm1hc2sJCT0gc2ExMTAwX21hc2tfaXJxLAotCS51bm1hc2sJCT0gc2ExMTAwX3VubWFza19pcnEsCi0JLnNldF93YWtlCT0gc2ExMTAwX3NldF93YWtlLAorCS5pcnFfYWNrCT0gc2ExMTAwX21hc2tfaXJxLAorCS5pcnFfbWFzawk9IHNhMTEwMF9tYXNrX2lycSwKKwkuaXJxX3VubWFzawk9IHNhMTEwMF91bm1hc2tfaXJxLAorCS5pcnFfc2V0X3dha2UJPSBzYTExMDBfc2V0X3dha2UsCiB9OwogCiBzdGF0aWMgc3RydWN0IHJlc291cmNlIGlycV9yZXNvdXJjZSA9IHsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtc2ExMTAwL25lcG9uc2V0LmMgYi9hcmNoL2FybS9tYWNoLXNhMTEwMC9uZXBvbnNldC5jCmluZGV4IGM2MDFhNzUuLjRhYWQwMWYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtc2ExMTAwL25lcG9uc2V0LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zYTExMDAvbmVwb25zZXQuYwpAQCAtMzUsNyArMzUsNyBAQAogCQkvKgogCQkgKiBBY2tub3dsZWRnZSB0aGUgcGFyZW50IElSUS4KIAkJICovCi0JCWRlc2MtPmNoaXAtPmFjayhpcnEpOworCQlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfYWNrKCZkZXNjLT5pcnFfZGF0YSk7CiAKIAkJLyoKIAkJICogUmVhZCB0aGUgaW50ZXJydXB0IHJlYXNvbiByZWdpc3Rlci4gIExldCdzIGhhdmUgYWxsCkBAIC01Myw3ICs1Myw3IEBACiAJCSAqIHJlY2hlY2sgdGhlIHJlZ2lzdGVyIGZvciBhbnkgcGVuZGluZyBJUlFzLgogCQkgKi8KIAkJaWYgKGlyciAmIChJUlJfRVRIRVJORVQgfCBJUlJfVVNBUikpIHsKLQkJCWRlc2MtPmNoaXAtPm1hc2soaXJxKTsKKwkJCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9tYXNrKCZkZXNjLT5pcnFfZGF0YSk7CiAKIAkJCS8qCiAJCQkgKiBBY2sgdGhlIGludGVycnVwdCBub3cgdG8gcHJldmVudCByZS1lbnRlcmluZwpAQCAtNjEsNyArNjEsNyBAQAogCQkJICogc2luY2Ugd2UnbGwgY2hlY2sgdGhlIElSUiByZWdpc3RlciBwcmlvciB0bwogCQkJICogbGVhdmluZy4KIAkJCSAqLwotCQkJZGVzYy0+Y2hpcC0+YWNrKGlycSk7CisJCQlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfYWNrKCZkZXNjLT5pcnFfZGF0YSk7CiAKIAkJCWlmIChpcnIgJiBJUlJfRVRIRVJORVQpIHsKIAkJCQlnZW5lcmljX2hhbmRsZV9pcnEoSVJRX05FUE9OU0VUX1NNQzkxOTYpOwpAQCAtNzEsNyArNzEsNyBAQAogCQkJCWdlbmVyaWNfaGFuZGxlX2lycShJUlFfTkVQT05TRVRfVVNBUik7CiAJCQl9CiAKLQkJCWRlc2MtPmNoaXAtPnVubWFzayhpcnEpOworCQkJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX3VubWFzaygmZGVzYy0+aXJxX2RhdGEpOwogCQl9CiAKIAkJaWYgKGlyciAmIElSUl9TQTExMTEpIHsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtc2hhcmsvaXJxLmMgYi9hcmNoL2FybS9tYWNoLXNoYXJrL2lycS5jCmluZGV4IGMwNGViNmEuLjgzMWZjNjYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtc2hhcmsvaXJxLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zaGFyay9pcnEuYwpAQCAtMzAsMzUgKzMwLDM1IEBACiAgKiBUaGVzZSBoYXZlIHRvIGJlIHByb3RlY3RlZCBieSB0aGUgaXJxIGNvbnRyb2xsZXIgc3BpbmxvY2sKICAqIGJlZm9yZSBiZWluZyBjYWxsZWQuCiAgKi8KLXN0YXRpYyB2b2lkIHNoYXJrX2Rpc2FibGVfODI1OUFfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzaGFya19kaXNhYmxlXzgyNTlBX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdW5zaWduZWQgaW50IG1hc2s7Ci0JaWYgKGlycTw4KSB7Ci0JICBtYXNrID0gMSA8PCBpcnE7CisJaWYgKGQtPmlycTw4KSB7CisJICBtYXNrID0gMSA8PCBkLT5pcnE7CiAJICBjYWNoZWRfaXJxX21hc2tbMF0gfD0gbWFzazsKIAkgIG91dGIoY2FjaGVkX2lycV9tYXNrWzFdLDB4QTEpOwogCX0gZWxzZSB7Ci0JICBtYXNrID0gMSA8PCAoaXJxLTgpOworCSAgbWFzayA9IDEgPDwgKGQtPmlycS04KTsKIAkgIGNhY2hlZF9pcnFfbWFza1sxXSB8PSBtYXNrOwogCSAgb3V0YihjYWNoZWRfaXJxX21hc2tbMF0sMHgyMSk7CiAJfQogfQogCi1zdGF0aWMgdm9pZCBzaGFya19lbmFibGVfODI1OUFfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzaGFya19lbmFibGVfODI1OUFfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl1bnNpZ25lZCBpbnQgbWFzazsKLQlpZiAoaXJxPDgpIHsKLQkgIG1hc2sgPSB+KDEgPDwgaXJxKTsKKwlpZiAoZC0+aXJxPDgpIHsKKwkgIG1hc2sgPSB+KDEgPDwgZC0+aXJxKTsKIAkgIGNhY2hlZF9pcnFfbWFza1swXSAmPSBtYXNrOwogCSAgb3V0YihjYWNoZWRfaXJxX21hc2tbMF0sMHgyMSk7CiAJfSBlbHNlIHsKLQkgIG1hc2sgPSB+KDEgPDwgKGlycS04KSk7CisJICBtYXNrID0gfigxIDw8IChkLT5pcnEtOCkpOwogCSAgY2FjaGVkX2lycV9tYXNrWzFdICY9IG1hc2s7CiAJICBvdXRiKGNhY2hlZF9pcnFfbWFza1sxXSwweEExKTsKIAl9CiB9CiAKLXN0YXRpYyB2b2lkIHNoYXJrX2Fja184MjU5QV9pcnEodW5zaWduZWQgaW50IGlycSl7fQorc3RhdGljIHZvaWQgc2hhcmtfYWNrXzgyNTlBX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpe30KIAogc3RhdGljIGlycXJldHVybl90IGJvZ3VzX2ludChpbnQgaXJxLCB2b2lkICpkZXZfaWQpCiB7CkBAIC02OSwxMCArNjksMTAgQEAKIHN0YXRpYyBzdHJ1Y3QgaXJxYWN0aW9uIGNhc2NhZGU7CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgZmJfY2hpcCA9IHsKLQkubmFtZQk9ICJYVC1QSUMiLAotCS5hY2sJPSBzaGFya19hY2tfODI1OUFfaXJxLAotCS5tYXNrCT0gc2hhcmtfZGlzYWJsZV84MjU5QV9pcnEsCi0JLnVubWFzayA9IHNoYXJrX2VuYWJsZV84MjU5QV9pcnEsCisJLm5hbWUJCT0gIlhULVBJQyIsCisJLmlycV9hY2sJPSBzaGFya19hY2tfODI1OUFfaXJxLAorCS5pcnFfbWFzawk9IHNoYXJrX2Rpc2FibGVfODI1OUFfaXJxLAorCS5pcnFfdW5tYXNrCT0gc2hhcmtfZW5hYmxlXzgyNTlBX2lycSwKIH07CiAKIHZvaWQgX19pbml0IHNoYXJrX2luaXRfaXJxKHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL0tjb25maWcgYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL0tjb25maWcKaW5kZXggNGQxYjRjNS4uMGM4ZjZjZiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9LY29uZmlnCisrKyBiL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvS2NvbmZpZwpAQCAtNjAsNiArNjAsOCBAQAogCiBjb25maWcgTUFDSF9BRzVFVk0KIAlib29sICJBRzVFVk0gYm9hcmQiCisJc2VsZWN0IEFSQ0hfUkVRVUlSRV9HUElPTElCCisJc2VsZWN0IFNIX0xDRF9NSVBJX0RTSQogCWRlcGVuZHMgb24gQVJDSF9TSDczQTAKIAogY29uZmlnIE1BQ0hfTUFDS0VSRUwKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvYm9hcmQtYWc1ZXZtLmMgYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2JvYXJkLWFnNWV2bS5jCmluZGV4IGMxOGE3NDAuLjIxMjNiOTYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvYm9hcmQtYWc1ZXZtLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9ib2FyZC1hZzVldm0uYwpAQCAtMzQsOSArMzQsMTAgQEAKICNpbmNsdWRlIDxsaW51eC9pbnB1dC9zaF9rZXlzYy5oPgogI2luY2x1ZGUgPGxpbnV4L21tYy9ob3N0Lmg+CiAjaW5jbHVkZSA8bGludXgvbW1jL3NoX21tY2lmLmg+Ci0KKyNpbmNsdWRlIDxsaW51eC9zaF9jbGsuaD4KKyNpbmNsdWRlIDx2aWRlby9zaF9tb2JpbGVfbGNkYy5oPgorI2luY2x1ZGUgPHZpZGVvL3NoX21pcGlfZHNpLmg+CiAjaW5jbHVkZSA8c291bmQvc2hfZnNpLmg+Ci0KICNpbmNsdWRlIDxtYWNoL2hhcmR3YXJlLmg+CiAjaW5jbHVkZSA8bWFjaC9zaDczYTAuaD4KICNpbmNsdWRlIDxtYWNoL2NvbW1vbi5oPgpAQCAtMTgzLDExICsxODQsMTY1IEBACiAJLnJlc291cmNlCT0gc2hfbW1jaWZfcmVzb3VyY2VzLAogfTsKIAorLyogSXJEQSAqLworc3RhdGljIHN0cnVjdCByZXNvdXJjZSBpcmRhX3Jlc291cmNlc1tdID0geworCVswXSA9IHsKKwkJLnN0YXJ0CT0gMHhFNkQwMDAwMCwKKwkJLmVuZAk9IDB4RTZEMDFGRDQgLSAxLAorCQkuZmxhZ3MgID0gSU9SRVNPVVJDRV9NRU0sCisJfSwKKwlbMV0gPSB7CisJCS5zdGFydAk9IGdpY19zcGkoOTUpLAorCQkuZmxhZ3MgID0gSU9SRVNPVVJDRV9JUlEsCisJfSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGlyZGFfZGV2aWNlID0geworCS5uYW1lICAgICAgICAgICA9ICJzaF9pcmRhIiwKKwkuaWQJCT0gMCwKKwkucmVzb3VyY2UgICAgICAgPSBpcmRhX3Jlc291cmNlcywKKwkubnVtX3Jlc291cmNlcyAgPSBBUlJBWV9TSVpFKGlyZGFfcmVzb3VyY2VzKSwKK307CisKK3N0YXRpYyB1bnNpZ25lZCBjaGFyIGxjZF9iYWNrbGlnaHRfc2VxWzNdWzJdID0geworCXsgMHgwNCwgMHgwNyB9LAorCXsgMHgyMywgMHg4MCB9LAorCXsgMHgwMywgMHgwMSB9LAorfTsKKworc3RhdGljIHZvaWQgbGNkX2JhY2tsaWdodF9vbih2b2lkKQoreworCXN0cnVjdCBpMmNfYWRhcHRlciAqYTsKKwlzdHJ1Y3QgaTJjX21zZyBtc2c7CisJaW50IGs7CisKKwlhID0gaTJjX2dldF9hZGFwdGVyKDEpOworCWZvciAoayA9IDA7IGEgJiYgayA8IDM7IGsrKykgeworCQltc2cuYWRkciA9IDB4NmQ7CisJCW1zZy5idWYgPSAmbGNkX2JhY2tsaWdodF9zZXFba11bMF07CisJCW1zZy5sZW4gPSAyOworCQltc2cuZmxhZ3MgPSAwOworCQlpZiAoaTJjX3RyYW5zZmVyKGEsICZtc2csIDEpICE9IDEpCisJCQlicmVhazsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIGxjZF9iYWNrbGlnaHRfcmVzZXQodm9pZCkKK3sKKwlncGlvX3NldF92YWx1ZShHUElPX1BPUlQyMzUsIDApOworCW1kZWxheSgyNCk7CisJZ3Bpb19zZXRfdmFsdWUoR1BJT19QT1JUMjM1LCAxKTsKK30KKworc3RhdGljIHZvaWQgbGNkX29uKHZvaWQgKmJvYXJkX2RhdGEsIHN0cnVjdCBmYl9pbmZvICppbmZvKQoreworCWxjZF9iYWNrbGlnaHRfb24oKTsKK30KKworc3RhdGljIHZvaWQgbGNkX29mZih2b2lkICpib2FyZF9kYXRhKQoreworCWxjZF9iYWNrbGlnaHRfcmVzZXQoKTsKK30KKworLyogTENEQzAgKi8KK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZmJfdmlkZW9tb2RlIGxjZGMwX21vZGVzW10gPSB7CisJeworCQkubmFtZQkJPSAiUjYzMzAyKFFIRCkiLAorCQkueHJlcwkJPSA1NDQsCisJCS55cmVzCQk9IDk2MSwKKwkJLmxlZnRfbWFyZ2luCT0gNzIsCisJCS5yaWdodF9tYXJnaW4JPSA2MDAsCisJCS5oc3luY19sZW4JPSAxNiwKKwkJLnVwcGVyX21hcmdpbgk9IDgsCisJCS5sb3dlcl9tYXJnaW4JPSA4LAorCQkudnN5bmNfbGVuCT0gMiwKKwkJLnN5bmMJCT0gRkJfU1lOQ19WRVJUX0hJR0hfQUNUIHwgRkJfU1lOQ19IT1JfSElHSF9BQ1QsCisJfSwKK307CisKK3N0YXRpYyBzdHJ1Y3Qgc2hfbW9iaWxlX2xjZGNfaW5mbyBsY2RjMF9pbmZvID0geworCS5jbG9ja19zb3VyY2UgPSBMQ0RDX0NMS19QRVJJUEhFUkFMLAorCS5jaFswXSA9IHsKKwkJLmNoYW4gPSBMQ0RDX0NIQU5fTUFJTkxDRCwKKwkJLmludGVyZmFjZV90eXBlID0gUkdCMjQsCisJCS5jbG9ja19kaXZpZGVyID0gMSwKKwkJLmZsYWdzID0gTENEQ19GTEFHU19EV1BPTCwKKwkJLmxjZF9zaXplX2NmZy53aWR0aCA9IDQ0LAorCQkubGNkX3NpemVfY2ZnLmhlaWdodCA9IDc5LAorCQkuYnBwID0gMTYsCisJCS5sY2RfY2ZnID0gbGNkYzBfbW9kZXMsCisJCS5udW1fY2ZnID0gQVJSQVlfU0laRShsY2RjMF9tb2RlcyksCisJCS5ib2FyZF9jZmcgPSB7CisJCQkuZGlzcGxheV9vbiA9IGxjZF9vbiwKKwkJCS5kaXNwbGF5X29mZiA9IGxjZF9vZmYsCisJCX0sCisJfQorfTsKKworc3RhdGljIHN0cnVjdCByZXNvdXJjZSBsY2RjMF9yZXNvdXJjZXNbXSA9IHsKKwlbMF0gPSB7CisJCS5uYW1lCT0gIkxDREMwIiwKKwkJLnN0YXJ0CT0gMHhmZTk0MDAwMCwgLyogUDQtb25seSBzcGFjZSAqLworCQkuZW5kCT0gMHhmZTk0M2ZmZiwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9NRU0sCisJfSwKKwlbMV0gPSB7CisJCS5zdGFydAk9IGludGNzX2V2dDJpcnEoMHg1ODApLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgbGNkYzBfZGV2aWNlID0geworCS5uYW1lCQk9ICJzaF9tb2JpbGVfbGNkY19mYiIsCisJLm51bV9yZXNvdXJjZXMJPSBBUlJBWV9TSVpFKGxjZGMwX3Jlc291cmNlcyksCisJLnJlc291cmNlCT0gbGNkYzBfcmVzb3VyY2VzLAorCS5pZCAgICAgICAgICAgICA9IDAsCisJLmRldgk9IHsKKwkJLnBsYXRmb3JtX2RhdGEJPSAmbGNkYzBfaW5mbywKKwkJLmNvaGVyZW50X2RtYV9tYXNrID0gfjAsCisJfSwKK307CisKKy8qIE1JUEktRFNJICovCitzdGF0aWMgc3RydWN0IHJlc291cmNlIG1pcGlkc2kwX3Jlc291cmNlc1tdID0geworCVswXSA9IHsKKwkJLnN0YXJ0ICA9IDB4ZmVhYjAwMDAsCisJCS5lbmQgICAgPSAweGZlYWIzZmZmLAorCQkuZmxhZ3MgID0gSU9SRVNPVVJDRV9NRU0sCisJfSwKKwlbMV0gPSB7CisJCS5zdGFydCAgPSAweGZlYWI0MDAwLAorCQkuZW5kICAgID0gMHhmZWFiN2ZmZiwKKwkJLmZsYWdzICA9IElPUkVTT1VSQ0VfTUVNLAorCX0sCit9OworCitzdGF0aWMgc3RydWN0IHNoX21pcGlfZHNpX2luZm8gbWlwaWRzaTBfaW5mbyA9IHsKKwkuZGF0YV9mb3JtYXQJPSBNSVBJX1JHQjg4OCwKKwkubGNkX2NoYW4JPSAmbGNkYzBfaW5mby5jaFswXSwKKwkudnN5bndfb2Zmc2V0CT0gMjAsCisJLmNsa3NyYwkJPSAxLAorCS5mbGFncwkJPSBTSF9NSVBJX0RTSV9IU0FCTSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIG1pcGlkc2kwX2RldmljZSA9IHsKKwkubmFtZSAgICAgICAgICAgPSAic2gtbWlwaS1kc2kiLAorCS5udW1fcmVzb3VyY2VzICA9IEFSUkFZX1NJWkUobWlwaWRzaTBfcmVzb3VyY2VzKSwKKwkucmVzb3VyY2UgICAgICAgPSBtaXBpZHNpMF9yZXNvdXJjZXMsCisJLmlkICAgICAgICAgICAgID0gMCwKKwkuZGV2CT0geworCQkucGxhdGZvcm1fZGF0YQk9ICZtaXBpZHNpMF9pbmZvLAorCX0sCit9OworCiBzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSAqYWc1ZXZtX2RldmljZXNbXSBfX2luaXRkYXRhID0gewogCSZldGhfZGV2aWNlLAogCSZrZXlzY19kZXZpY2UsCiAJJmZzaV9kZXZpY2UsCiAJJm1tY19kZXZpY2UsCisJJmlyZGFfZGV2aWNlLAorCSZsY2RjMF9kZXZpY2UsCisJJm1pcGlkc2kwX2RldmljZSwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgbWFwX2Rlc2MgYWc1ZXZtX2lvX2Rlc2NbXSBfX2luaXRkYXRhID0gewpAQCAtMjI0LDYgKzM3OSw4IEBACiAJX19yYXdfd3JpdGV3KF9fcmF3X3JlYWR3KFBJTlRDUjBBKSB8ICgyPDwxMCksIFBJTlRDUjBBKTsKIH0KIAorI2RlZmluZSBEU0kwUEhZQ1IJMHhlNjE1MDA2YworCiBzdGF0aWMgdm9pZCBfX2luaXQgYWc1ZXZtX2luaXQodm9pZCkKIHsKIAlzaDczYTBfcGlubXV4X2luaXQoKTsKQEAgLTI4Nyw2ICs0NDQsMjUgQEAKIAlncGlvX3JlcXVlc3QoR1BJT19GTl9GU0lBSVNMRCwgTlVMTCk7CiAJZ3Bpb19yZXF1ZXN0KEdQSU9fRk5fRlNJQU9TTEQsIE5VTEwpOwogCisJLyogSXJEQSAqLworCWdwaW9fcmVxdWVzdChHUElPX0ZOX1BPUlQyNDFfSVJEQV9PVVQsIE5VTEwpOworCWdwaW9fcmVxdWVzdChHUElPX0ZOX1BPUlQyNDJfSVJEQV9JTiwgIE5VTEwpOworCWdwaW9fcmVxdWVzdChHUElPX0ZOX1BPUlQyNDNfSVJEQV9GSVJTRUwsIE5VTEwpOworCisJLyogTENEIHBhbmVsICovCisJZ3Bpb19yZXF1ZXN0KEdQSU9fUE9SVDIxNywgTlVMTCk7IC8qIFJFU0VUICovCisJZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KEdQSU9fUE9SVDIxNywgMCk7CisJbWRlbGF5KDEpOworCWdwaW9fc2V0X3ZhbHVlKEdQSU9fUE9SVDIxNywgMSk7CisKKwkvKiBMQ0QgYmFja2xpZ2h0IGNvbnRyb2xsZXIgKi8KKwlncGlvX3JlcXVlc3QoR1BJT19QT1JUMjM1LCBOVUxMKTsgLyogUkVTRVQgKi8KKwlncGlvX2RpcmVjdGlvbl9vdXRwdXQoR1BJT19QT1JUMjM1LCAwKTsKKwlsY2RfYmFja2xpZ2h0X3Jlc2V0KCk7CisKKwkvKiBNSVBJLURTSSBjbG9jayBzZXR1cCAqLworCV9fcmF3X3dyaXRlbCgweDJhODA5MDEwLCBEU0kwUEhZQ1IpOworCiAjaWZkZWYgQ09ORklHX0NBQ0hFX0wyWDAKIAkvKiBTaGFyZWQgYXR0cmlidXRlIG92ZXJyaWRlIGVuYWJsZSwgNjRLKjh3YXkgKi8KIAlsMngwX2luaXQoX19pbygweGYwMTAwMDAwKSwgMHgwMDQ2MDAwMCwgMHhjMjAwMGZmZik7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2JvYXJkLWczZXZtLmMgYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2JvYXJkLWczZXZtLmMKaW5kZXggNjg2YjMwNC4uZWY0NjEzYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9ib2FyZC1nM2V2bS5jCisrKyBiL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvYm9hcmQtZzNldm0uYwpAQCAtMzQ3LDcgKzM0Nyw2IEBACiAJZ3Bpb19yZXF1ZXN0KEdQSU9fRk5fSVJEQV9PVVQsIE5VTEwpOwogCWdwaW9fcmVxdWVzdChHUElPX0ZOX0lSREFfSU4sIE5VTEwpOwogCWdwaW9fcmVxdWVzdChHUElPX0ZOX0lSREFfRklSU0VMLCBOVUxMKTsKLQlzZXRfaXJxX3R5cGUoZXZ0MmlycSgweDQ4MCksIElSUV9UWVBFX0xFVkVMX0xPVyk7CiAKIAlzaDczNjdfYWRkX3N0YW5kYXJkX2RldmljZXMoKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9ib2FyZC1tYWNrZXJlbC5jIGIvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9ib2FyZC1tYWNrZXJlbC5jCmluZGV4IDdiMTVkMjEuLmZiNDIxM2EgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvYm9hcmQtbWFja2VyZWwuYworKysgYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2JvYXJkLW1hY2tlcmVsLmMKQEAgLTE2OSw5ICsxNjksOCBAQAogICoJU1cxCXwJU1czMwogICoJCXwgYml0MSB8IGJpdDIgfCBiaXQzIHwgYml0NAogICogLS0tLS0tLS0tLS0tLSstLS0tLS0rLS0tLS0tKy0tLS0tLSstLS0tLS0tCi0gKiBNTUMwCSAgT0ZGCXwgIE9GRiB8ICBPTiAgfCAgT04gIHwgIFgKLSAqIE1NQzEJICBPTgl8ICBPRkYgfCAgT04gIHwgIFggICB8IE9OCi0gKiBTREhJMSAgT0ZGCXwgIE9OICB8ICAgWCAgfCAgT0ZGIHwgT04KKyAqIE1NQzAgICBPRkYJfCAgT0ZGIHwgICBYICB8ICBPTiAgfCAgWCAgICAgICAoVXNlIE1NQ0lGKQorICogU0RISTEgIE9GRgl8ICBPTiAgfCAgIFggIHwgIE9GRiB8ICBYICAgICAgIChVc2UgTUZEX1NIX01PQklMRV9TREhJKQogICoKICAqLwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2Nsb2NrLXNoNzM3Mi5jIGIvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9jbG9jay1zaDczNzIuYwppbmRleCA5YWE4ZDY4Li5lOTczMWI1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2Nsb2NrLXNoNzM3Mi5jCisrKyBiL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvY2xvY2stc2g3MzcyLmMKQEAgLTIzNCw3ICsyMzQsOSBAQAogCiAJdmFsdWUgPSBfX3Jhd19yZWFkbChQTExDMkNSKSAmIH4oMHgzZiA8PCAyNCk7CiAKLQlfX3Jhd193cml0ZWwoKHZhbHVlICYgfjB4ODAwMDAwMDApIHwgKChpZHggKyAxOSkgPDwgMjQpLCBQTExDMkNSKTsKKwlfX3Jhd193cml0ZWwodmFsdWUgfCAoKGlkeCArIDE5KSA8PCAyNCksIFBMTEMyQ1IpOworCisJY2xrLT5yYXRlID0gY2xrLT5mcmVxX3RhYmxlW2lkeF0uZnJlcXVlbmN5OwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2Nsb2NrLXNoNzNhMC5jIGIvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9jbG9jay1zaDczYTAuYwppbmRleCA3MjBhNzE0Li5kZGQ0YTFiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2Nsb2NrLXNoNzNhMC5jCisrKyBiL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvY2xvY2stc2g3M2EwLmMKQEAgLTExOCw4ICsxMTgsMTYgQEAKIHsKIAl1bnNpZ25lZCBsb25nIG11bHQgPSAxOwogCi0JaWYgKF9fcmF3X3JlYWRsKFBMTEVDUikgJiAoMSA8PCBjbGstPmVuYWJsZV9iaXQpKQorCWlmIChfX3Jhd19yZWFkbChQTExFQ1IpICYgKDEgPDwgY2xrLT5lbmFibGVfYml0KSkgewogCQltdWx0ID0gKCgoX19yYXdfcmVhZGwoY2xrLT5lbmFibGVfcmVnKSA+PiAyNCkgJiAweDNmKSArIDEpOworCQkvKiBoYW5kbGUgQ0ZHIGJpdCBmb3IgUExMMSBhbmQgUExMMiAqLworCQlzd2l0Y2ggKGNsay0+ZW5hYmxlX2JpdCkgeworCQljYXNlIDE6CisJCWNhc2UgMjoKKwkJCWlmIChfX3Jhd19yZWFkbChjbGstPmVuYWJsZV9yZWcpICYgKDEgPDwgMjApKQorCQkJCW11bHQgKj0gMjsKKwkJfQorCX0KIAogCXJldHVybiBjbGstPnBhcmVudC0+cmF0ZSAqIG11bHQ7CiB9CkBAIC0yMTIsNyArMjIwLDcgQEAKIHN0YXRpYyBzdHJ1Y3QgY2xrIGRpdjRfY2xrc1tESVY0X05SXSA9IHsKIAlbRElWNF9JXSA9IERJVjQoRlJRQ1JBLCAyMCwgMHhmZmYsIENMS19FTkFCTEVfT05fSU5JVCksCiAJW0RJVjRfWkddID0gRElWNChGUlFDUkEsIDE2LCAweGJmZiwgQ0xLX0VOQUJMRV9PTl9JTklUKSwKLQlbRElWNF9NM10gPSBESVY0KEZSUUNSQSwgOCwgMHhmZmYsIENMS19FTkFCTEVfT05fSU5JVCksCisJW0RJVjRfTTNdID0gRElWNChGUlFDUkEsIDEyLCAweGZmZiwgQ0xLX0VOQUJMRV9PTl9JTklUKSwKIAlbRElWNF9CXSA9IERJVjQoRlJRQ1JBLCA4LCAweGZmZiwgQ0xLX0VOQUJMRV9PTl9JTklUKSwKIAlbRElWNF9NMV0gPSBESVY0KEZSUUNSQSwgNCwgMHhmZmYsIDApLAogCVtESVY0X00yXSA9IERJVjQoRlJRQ1JBLCAwLCAweGZmZiwgMCksCkBAIC0yNTUsMTAgKzI2MywxMCBAQAogfTsKIAogZW51bSB7IE1TVFAwMDEsCi0JTVNUUDEyNSwgTVNUUDExNiwKKwlNU1RQMTI1LCBNU1RQMTE4LCBNU1RQMTE2LCBNU1RQMTAwLAogCU1TVFAyMTksCiAJTVNUUDIwNywgTVNUUDIwNiwgTVNUUDIwNCwgTVNUUDIwMywgTVNUUDIwMiwgTVNUUDIwMSwgTVNUUDIwMCwKLQlNU1RQMzMxLCBNU1RQMzI5LCBNU1RQMzIzLCBNU1RQMzEyLAorCU1TVFAzMzEsIE1TVFAzMjksIE1TVFAzMjUsIE1TVFAzMjMsIE1TVFAzMTIsCiAJTVNUUDQxMSwgTVNUUDQxMCwgTVNUUDQwMywKIAlNU1RQX05SIH07CiAKQEAgLTI2OCw3ICsyNzYsOSBAQAogc3RhdGljIHN0cnVjdCBjbGsgbXN0cF9jbGtzW01TVFBfTlJdID0gewogCVtNU1RQMDAxXSA9IE1TVFAoJmRpdjRfY2xrc1tESVY0X0hQXSwgU01TVFBDUjAsIDEsIDApLCAvKiBJSUMyICovCiAJW01TVFAxMjVdID0gTVNUUCgmZGl2Nl9jbGtzW0RJVjZfU1VCXSwgU01TVFBDUjEsIDI1LCAwKSwgLyogVE1VMCAqLworCVtNU1RQMTE4XSA9IE1TVFAoJmRpdjRfY2xrc1tESVY0X0JdLCBTTVNUUENSMSwgMTgsIDApLCAvKiBEU0lUWDAgKi8KIAlbTVNUUDExNl0gPSBNU1RQKCZkaXY0X2Nsa3NbRElWNF9IUF0sIFNNU1RQQ1IxLCAxNiwgMCksIC8qIElJQzAgKi8KKwlbTVNUUDEwMF0gPSBNU1RQKCZkaXY0X2Nsa3NbRElWNF9CXSwgU01TVFBDUjEsIDAsIDApLCAvKiBMQ0RDMCAqLwogCVtNU1RQMjE5XSA9IE1TVFAoJmRpdjZfY2xrc1tESVY2X1NVQl0sIFNNU1RQQ1IyLCAxOSwgMCksIC8qIFNDSUZBNyAqLwogCVtNU1RQMjA3XSA9IE1TVFAoJmRpdjZfY2xrc1tESVY2X1NVQl0sIFNNU1RQQ1IyLCA3LCAwKSwgLyogU0NJRkE1ICovCiAJW01TVFAyMDZdID0gTVNUUCgmZGl2Nl9jbGtzW0RJVjZfU1VCXSwgU01TVFBDUjIsIDYsIDApLCAvKiBTQ0lGQiAqLwpAQCAtMjc5LDYgKzI4OSw3IEBACiAJW01TVFAyMDBdID0gTVNUUCgmZGl2Nl9jbGtzW0RJVjZfU1VCXSwgU01TVFBDUjIsIDAsIDApLCAvKiBTQ0lGQTQgKi8KIAlbTVNUUDMzMV0gPSBNU1RQKCZkaXY2X2Nsa3NbRElWNl9TVUJdLCBTTVNUUENSMywgMzEsIDApLCAvKiBTQ0lGQTYgKi8KIAlbTVNUUDMyOV0gPSBNU1RQKCZyX2NsaywgU01TVFBDUjMsIDI5LCAwKSwgLyogQ01UMTAgKi8KKwlbTVNUUDMyNV0gPSBNU1RQKCZkaXY2X2Nsa3NbRElWNl9TVUJdLCBTTVNUUENSMywgMjUsIDApLCAvKiBJckRBICovCiAJW01TVFAzMjNdID0gTVNUUCgmZGl2NF9jbGtzW0RJVjRfSFBdLCBTTVNUUENSMywgMjMsIDApLCAvKiBJSUMxICovCiAJW01TVFAzMTJdID0gTVNUUCgmZGl2NF9jbGtzW0RJVjRfSFBdLCBTTVNUUENSMywgMTIsIDApLCAvKiBNTUNJRjAgKi8KIAlbTVNUUDQxMV0gPSBNU1RQKCZkaXY0X2Nsa3NbRElWNF9IUF0sIFNNU1RQQ1I0LCAxMSwgMCksIC8qIElJQzMgKi8KQEAgLTI4OCwxNiArMjk5LDI1IEBACiAKICNkZWZpbmUgQ0xLREVWX0NPTl9JRChfaWQsIF9jbGspIHsgLmNvbl9pZCA9IF9pZCwgLmNsayA9IF9jbGsgfQogI2RlZmluZSBDTEtERVZfREVWX0lEKF9pZCwgX2NsaykgeyAuZGV2X2lkID0gX2lkLCAuY2xrID0gX2NsayB9CisjZGVmaW5lIENMS0RFVl9JQ0tfSUQoX2NpZCwgX2RpZCwgX2NsaykgeyAuY29uX2lkID0gX2NpZCwgLmRldl9pZCA9IF9kaWQsIC5jbGsgPSBfY2xrIH0KIAogc3RhdGljIHN0cnVjdCBjbGtfbG9va3VwIGxvb2t1cHNbXSA9IHsKIAkvKiBtYWluIGNsb2NrcyAqLwogCUNMS0RFVl9DT05fSUQoInJfY2xrIiwgJnJfY2xrKSwKIAorCS8qIERJVjYgY2xvY2tzICovCisJQ0xLREVWX0lDS19JRCgiZHNpdF9jbGsiLCAic2gtbWlwaS1kc2kuMCIsICZkaXY2X2Nsa3NbRElWNl9EU0lUXSksCisJQ0xLREVWX0lDS19JRCgiZHNpdF9jbGsiLCAic2gtbWlwaS1kc2kuMSIsICZkaXY2X2Nsa3NbRElWNl9EU0lUXSksCisJQ0xLREVWX0lDS19JRCgiZHNpMHBfY2xrIiwgInNoLW1pcGktZHNpLjAiLCAmZGl2Nl9jbGtzW0RJVjZfRFNJMFBdKSwKKwlDTEtERVZfSUNLX0lEKCJkc2kxcF9jbGsiLCAic2gtbWlwaS1kc2kuMSIsICZkaXY2X2Nsa3NbRElWNl9EU0kxUF0pLAorCiAJLyogTVNUUDMyIGNsb2NrcyAqLwogCUNMS0RFVl9ERVZfSUQoImkyYy1zaF9tb2JpbGUuMiIsICZtc3RwX2Nsa3NbTVNUUDAwMV0pLCAvKiBJMkMyICovCisJQ0xLREVWX0RFVl9JRCgic2hfbW9iaWxlX2xjZGNfZmIuMCIsICZtc3RwX2Nsa3NbTVNUUDEwMF0pLCAvKiBMQ0RDMCAqLwogCUNMS0RFVl9ERVZfSUQoInNoX3RtdS4wIiwgJm1zdHBfY2xrc1tNU1RQMTI1XSksIC8qIFRNVTAwICovCiAJQ0xLREVWX0RFVl9JRCgic2hfdG11LjEiLCAmbXN0cF9jbGtzW01TVFAxMjVdKSwgLyogVE1VMDEgKi8KIAlDTEtERVZfREVWX0lEKCJpMmMtc2hfbW9iaWxlLjAiLCAmbXN0cF9jbGtzW01TVFAxMTZdKSwgLyogSTJDMCAqLworCUNMS0RFVl9ERVZfSUQoInNoLW1pcGktZHNpLjAiLCAmbXN0cF9jbGtzW01TVFAxMThdKSwgLyogRFNJVFggKi8KIAlDTEtERVZfREVWX0lEKCJzaC1zY2kuNyIsICZtc3RwX2Nsa3NbTVNUUDIxOV0pLCAvKiBTQ0lGQTcgKi8KIAlDTEtERVZfREVWX0lEKCJzaC1zY2kuNSIsICZtc3RwX2Nsa3NbTVNUUDIwN10pLCAvKiBTQ0lGQTUgKi8KIAlDTEtERVZfREVWX0lEKCJzaC1zY2kuOCIsICZtc3RwX2Nsa3NbTVNUUDIwNl0pLCAvKiBTQ0lGQiAqLwpAQCAtMzA4LDYgKzMyOCw3IEBACiAJQ0xLREVWX0RFVl9JRCgic2gtc2NpLjQiLCAmbXN0cF9jbGtzW01TVFAyMDBdKSwgLyogU0NJRkE0ICovCiAJQ0xLREVWX0RFVl9JRCgic2gtc2NpLjYiLCAmbXN0cF9jbGtzW01TVFAzMzFdKSwgLyogU0NJRkE2ICovCiAJQ0xLREVWX0RFVl9JRCgic2hfY210LjEwIiwgJm1zdHBfY2xrc1tNU1RQMzI5XSksIC8qIENNVDEwICovCisJQ0xLREVWX0RFVl9JRCgic2hfaXJkYS4wIiwgJm1zdHBfY2xrc1tNU1RQMzI1XSksIC8qIElyREEgKi8KIAlDTEtERVZfREVWX0lEKCJpMmMtc2hfbW9iaWxlLjEiLCAmbXN0cF9jbGtzW01TVFAzMjNdKSwgLyogSTJDMSAqLwogCUNMS0RFVl9ERVZfSUQoInNoX21tY2lmLjAiLCAmbXN0cF9jbGtzW01TVFAzMTJdKSwgLyogTU1DSUYwICovCiAJQ0xLREVWX0RFVl9JRCgiaTJjLXNoX21vYmlsZS4zIiwgJm1zdHBfY2xrc1tNU1RQNDExXSksIC8qIEkyQzMgKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvaW50Yy1zaDczNzIuYyBiL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvaW50Yy1zaDczNzIuYwppbmRleCBmNzhhMWVhLi5jYTVmOWQxIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2ludGMtc2g3MzcyLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zaG1vYmlsZS9pbnRjLXNoNzM3Mi5jCkBAIC0zNjUsNiArMzY1LDcgQEAKIAogZW51bSB7CiAJVU5VU0VEX0lOVENTID0gMCwKKwlFTkFCTEVEX0lOVENTLAogCiAJSU5UQ1MsCiAKQEAgLTQxMyw3ICs0MTQsNyBAQAogCUNNVDQsCiAJRFNJVFgxX0RTSVRYMV8wLAogCURTSVRYMV9EU0lUWDFfMSwKLQkvKiBNRklTMiAqLworCU1GSVMyX0lOVENTLCAvKiBQcmlvcml0eSBhbHdheXMgZW5hYmxlZCB1c2luZyBFTkFCTEVEX0lOVENTICovCiAJQ1BPUlRTMlIsCiAJLyogQ0VDICovCiAJSlBVNkUsCkBAIC00NzcsNyArNDc4LDcgQEAKIAlJTlRDU19WRUNUKENNVDQsIDB4MTk4MCksCiAJSU5UQ1NfVkVDVChEU0lUWDFfRFNJVFgxXzAsIDB4MTlhMCksCiAJSU5UQ1NfVkVDVChEU0lUWDFfRFNJVFgxXzEsIDB4MTljMCksCi0JLyogTUZJUzIgKi8KKwlJTlRDU19WRUNUKE1GSVMyX0lOVENTLCAweDFhMDApLAogCUlOVENTX1ZFQ1QoQ1BPUlRTMlIsIDB4MWEyMCksCiAJLyogQ0VDICovCiAJSU5UQ1NfVkVDVChKUFU2RSwgMHgxYTgwKSwKQEAgLTU0Myw3ICs1NDQsNyBAQAogCSAgeyAwLCBUTVUxX1RVTkkyLCBUTVUxX1RVTkkxLCBUTVUxX1RVTkkwLAogCSAgICBDTVQ0LCBEU0lUWDFfRFNJVFgxXzAsIERTSVRYMV9EU0lUWDFfMSwgMCB9IH0sCiAJeyAweGZmZDUwMTljLCAweGZmZDUwMWRjLCA4LCAvKiBJTVI3U0EzIC8gSU1DUjdTQTMgKi8KLQkgIHsgMCwgQ1BPUlRTMlIsIDAsIDAsCisJICB7IE1GSVMyX0lOVENTLCBDUE9SVFMyUiwgMCwgMCwKIAkgICAgSlBVNkUsIDAsIDAsIDAgfSB9LAogCXsgMHhmZmQyMDEwNCwgMCwgMTYsIC8qIElOVEFNQVNLICovCiAJICB7IDAsIDAsIDAsIDAsIDAsIDAsIDAsIDAsCkBAIC01NzEsNyArNTcyLDggQEAKIAl7IDB4ZmZkNTAwMzAsIDAsIDE2LCA0LCAvKiBJUFJNUzMgKi8geyBUTVUxLCAwLCAwLCAwIH0gfSwKIAl7IDB4ZmZkNTAwMzQsIDAsIDE2LCA0LCAvKiBJUFJOUzMgKi8geyBDTVQ0LCBEU0lUWDFfRFNJVFgxXzAsCiAJCQkJCSAgICAgICBEU0lUWDFfRFNJVFgxXzEsIDAgfSB9LAotCXsgMHhmZmQ1MDAzOCwgMCwgMTYsIDQsIC8qIElQUk9TMyAqLyB7IDAsIENQT1JUUzJSLCAwLCAwIH0gfSwKKwl7IDB4ZmZkNTAwMzgsIDAsIDE2LCA0LCAvKiBJUFJPUzMgKi8geyBFTkFCTEVEX0lOVENTLCBDUE9SVFMyUiwKKwkJCQkJICAgICAgIDAsIDAgfSB9LAogCXsgMHhmZmQ1MDAzYywgMCwgMTYsIDQsIC8qIElQUlBTMyAqLyB7IEpQVTZFLCAwLCAwLCAwIH0gfSwKIH07CiAKQEAgLTU5MCw2ICs1OTIsNyBAQAogCiBzdGF0aWMgc3RydWN0IGludGNfZGVzYyBpbnRjc19kZXNjIF9faW5pdGRhdGEgPSB7CiAJLm5hbWUgPSAic2g3MzcyLWludGNzIiwKKwkuZm9yY2VfZW5hYmxlID0gRU5BQkxFRF9JTlRDUywKIAkucmVzb3VyY2UgPSBpbnRjc19yZXNvdXJjZXMsCiAJLm51bV9yZXNvdXJjZXMgPSBBUlJBWV9TSVpFKGludGNzX3Jlc291cmNlcyksCiAJLmh3ID0gSU5UQ19IV19ERVNDKGludGNzX3ZlY3RvcnMsIGludGNzX2dyb3VwcywgaW50Y3NfbWFza19yZWdpc3RlcnMsCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2ludGMtc2g3M2EwLmMgYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2ludGMtc2g3M2EwLmMKaW5kZXggMzIyZDhkNS4uNWQwZTE1MDMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtc2htb2JpbGUvaW50Yy1zaDczYTAuYworKysgYi9hcmNoL2FybS9tYWNoLXNobW9iaWxlL2ludGMtc2g3M2EwLmMKQEAgLTI1MiwxMCArMjUyLDExIEBACiAKIHZvaWQgX19pbml0IHNoNzNhMF9pbml0X2lycSh2b2lkKQogewotCXZvaWQgX19pb21lbSAqZ2ljX2Jhc2UgPSBfX2lvKDB4ZjAwMDEwMDApOworCXZvaWQgX19pb21lbSAqZ2ljX2Rpc3RfYmFzZSA9IF9faW8oMHhmMDAwMTAwMCk7CisJdm9pZCBfX2lvbWVtICpnaWNfY3B1X2Jhc2UgPSBfX2lvKDB4ZjAwMDAxMDApOwogCXZvaWQgX19pb21lbSAqaW50ZXZ0c2EgPSBpb3JlbWFwX25vY2FjaGUoMHhmZmQyMDEwMCwgUEFHRV9TSVpFKTsKIAotCWdpY19pbml0KDAsIDI5LCBnaWNfYmFzZSwgZ2ljX2Jhc2UpOworCWdpY19pbml0KDAsIDI5LCBnaWNfZGlzdF9iYXNlLCBnaWNfY3B1X2Jhc2UpOwogCiAJcmVnaXN0ZXJfaW50Y19jb250cm9sbGVyKCZpbnRjc19kZXNjKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1zdG1wMzc4eC9zdG1wMzc4eC5jIGIvYXJjaC9hcm0vbWFjaC1zdG1wMzc4eC9zdG1wMzc4eC5jCmluZGV4IGRkZDQ5YTcuLmMyZjlmZTA0IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXN0bXAzNzh4L3N0bXAzNzh4LmMKKysrIGIvYXJjaC9hcm0vbWFjaC1zdG1wMzc4eC9zdG1wMzc4eC5jCkBAIC00Nyw3ICs0Nyw3IEBACiAvKgogICogSVJRIGhhbmRsaW5nCiAgKi8KLXN0YXRpYyB2b2lkIHN0bXAzNzh4X2Fja19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHN0bXAzNzh4X2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCS8qIFRlbGwgSUNPTEwgdG8gcmVsZWFzZSBJUlEgbGluZSAqLwogCV9fcmF3X3dyaXRlbCgwLCBSRUdTX0lDT0xMX0JBU0UgKyBIV19JQ09MTF9WRUNUT1IpOwpAQCAtNjAsMjQgKzYwLDI0IEBACiAJKHZvaWQpX19yYXdfcmVhZGwoUkVHU19JQ09MTF9CQVNFICsgSFdfSUNPTExfU1RBVCk7CiB9CiAKLXN0YXRpYyB2b2lkIHN0bXAzNzh4X21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzdG1wMzc4eF9tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJLyogSVJRIGRpc2FibGUgKi8KIAlzdG1wM3h4eF9jbGVhcmwoQk1fSUNPTExfSU5URVJSVVBUbl9FTkFCTEUsCi0JCQlSRUdTX0lDT0xMX0JBU0UgKyBIV19JQ09MTF9JTlRFUlJVUFRuICsgaXJxICogMHgxMCk7CisJCQlSRUdTX0lDT0xMX0JBU0UgKyBIV19JQ09MTF9JTlRFUlJVUFRuICsgZC0+aXJxICogMHgxMCk7CiB9CiAKLXN0YXRpYyB2b2lkIHN0bXAzNzh4X3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHN0bXAzNzh4X3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCS8qIElSUSBlbmFibGUgKi8KIAlzdG1wM3h4eF9zZXRsKEJNX0lDT0xMX0lOVEVSUlVQVG5fRU5BQkxFLAotCQkgICAgICBSRUdTX0lDT0xMX0JBU0UgKyBIV19JQ09MTF9JTlRFUlJVUFRuICsgaXJxICogMHgxMCk7CisJCSAgICAgIFJFR1NfSUNPTExfQkFTRSArIEhXX0lDT0xMX0lOVEVSUlVQVG4gKyBkLT5pcnEgKiAweDEwKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzdG1wMzc4eF9jaGlwID0gewotCS5hY2sJPSBzdG1wMzc4eF9hY2tfaXJxLAotCS5tYXNrCT0gc3RtcDM3OHhfbWFza19pcnEsCi0JLnVubWFzayA9IHN0bXAzNzh4X3VubWFza19pcnEsCisJLmlycV9hY2sJPSBzdG1wMzc4eF9hY2tfaXJxLAorCS5pcnFfbWFzawk9IHN0bXAzNzh4X21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gc3RtcDM3OHhfdW5tYXNrX2lycSwKIH07CiAKIHZvaWQgX19pbml0IHN0bXAzNzh4X2luaXRfaXJxKHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXN0bXAzN3h4L3N0bXAzN3h4LmMgYi9hcmNoL2FybS9tYWNoLXN0bXAzN3h4L3N0bXAzN3h4LmMKaW5kZXggOGM3ZDZmYi4uYTlhZWQwNiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zdG1wMzd4eC9zdG1wMzd4eC5jCisrKyBiL2FyY2gvYXJtL21hY2gtc3RtcDM3eHgvc3RtcDM3eHguYwpAQCAtNDMsMTEgKzQzLDExIEBACiAvKgogICogSVJRIGhhbmRsaW5nCiAgKi8KLXN0YXRpYyB2b2lkIHN0bXAzN3h4X2Fja19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHN0bXAzN3h4X2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCS8qIERpc2FibGUgSVJRICovCi0Jc3RtcDN4eHhfY2xlYXJsKDB4MDQgPDwgKChpcnEgJSA0KSAqIDgpLAotCQlSRUdTX0lDT0xMX0JBU0UgKyBIV19JQ09MTF9QUklPUklUWW4gKyBpcnEgLyA0ICogMHgxMCk7CisJc3RtcDN4eHhfY2xlYXJsKDB4MDQgPDwgKChkLT5pcnEgJSA0KSAqIDgpLAorCQlSRUdTX0lDT0xMX0JBU0UgKyBIV19JQ09MTF9QUklPUklUWW4gKyBkLT5pcnEgLyA0ICogMHgxMCk7CiAKIAkvKiBBQ0sgY3VycmVudCBpbnRlcnJ1cHQgKi8KIAlfX3Jhd193cml0ZWwoMSwgUkVHU19JQ09MTF9CQVNFICsgSFdfSUNPTExfTEVWRUxBQ0spOwpAQCAtNTYsMjQgKzU2LDI0IEBACiAJKHZvaWQpX19yYXdfcmVhZGwoUkVHU19JQ09MTF9CQVNFICsgSFdfSUNPTExfU1RBVCk7CiB9CiAKLXN0YXRpYyB2b2lkIHN0bXAzN3h4X21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzdG1wMzd4eF9tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJLyogSVJRIGRpc2FibGUgKi8KLQlzdG1wM3h4eF9jbGVhcmwoMHgwNCA8PCAoKGlycSAlIDQpICogOCksCi0JCVJFR1NfSUNPTExfQkFTRSArIEhXX0lDT0xMX1BSSU9SSVRZbiArIGlycSAvIDQgKiAweDEwKTsKKwlzdG1wM3h4eF9jbGVhcmwoMHgwNCA8PCAoKGQtPmlycSAlIDQpICogOCksCisJCVJFR1NfSUNPTExfQkFTRSArIEhXX0lDT0xMX1BSSU9SSVRZbiArIGQtPmlycSAvIDQgKiAweDEwKTsKIH0KIAotc3RhdGljIHZvaWQgc3RtcDM3eHhfdW5tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc3RtcDM3eHhfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJLyogSVJRIGVuYWJsZSAqLwotCXN0bXAzeHh4X3NldGwoMHgwNCA8PCAoKGlycSAlIDQpICogOCksCi0JCVJFR1NfSUNPTExfQkFTRSArIEhXX0lDT0xMX1BSSU9SSVRZbiArIGlycSAvIDQgKiAweDEwKTsKKwlzdG1wM3h4eF9zZXRsKDB4MDQgPDwgKChkLT5pcnEgJSA0KSAqIDgpLAorCQlSRUdTX0lDT0xMX0JBU0UgKyBIV19JQ09MTF9QUklPUklUWW4gKyBkLT5pcnEgLyA0ICogMHgxMCk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgc3RtcDM3eHhfY2hpcCA9IHsKLQkuYWNrCT0gc3RtcDM3eHhfYWNrX2lycSwKLQkubWFzawk9IHN0bXAzN3h4X21hc2tfaXJxLAotCS51bm1hc2sgPSBzdG1wMzd4eF91bm1hc2tfaXJxLAorCS5pcnFfYWNrCT0gc3RtcDM3eHhfYWNrX2lycSwKKwkuaXJxX21hc2sJPSBzdG1wMzd4eF9tYXNrX2lycSwKKwkuaXJxX3VubWFzawk9IHN0bXAzN3h4X3VubWFza19pcnEsCiB9OwogCiB2b2lkIF9faW5pdCBzdG1wMzd4eF9pbml0X2lycSh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC10Y2M4ay9pcnEuYyBiL2FyY2gvYXJtL21hY2gtdGNjOGsvaXJxLmMKaW5kZXggMzQ1NzVjNC4uYWE5MjMxZiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC10Y2M4ay9pcnEuYworKysgYi9hcmNoL2FybS9tYWNoLXRjYzhrL2lycS5jCkBAIC0xOCw2NSArMTgsNjUgQEAKICNpbmNsdWRlICJjb21tb24uaCIKIAogLyogRGlzYWJsZSBJUlEgKi8KLXN0YXRpYyB2b2lkIHRjYzgwMDBfbWFza19hY2tfaXJxMCh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgdGNjODAwMF9tYXNrX2Fja19pcnEwKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlQSUMwX0lFTiAmPSB+KDEgPDwgaXJxKTsKLQlQSUMwX0NSRVEgfD0gICgxIDw8IGlycSk7CisJUElDMF9JRU4gJj0gfigxIDw8IGQtPmlycSk7CisJUElDMF9DUkVRIHw9ICAoMSA8PCBkLT5pcnEpOwogfQogCi1zdGF0aWMgdm9pZCB0Y2M4MDAwX21hc2tfYWNrX2lycTEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHRjYzgwMDBfbWFza19hY2tfaXJxMShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JUElDMV9JRU4gJj0gfigxIDw8IChpcnEgLSAzMikpOwotCVBJQzFfQ1JFUSB8PSAoMSA8PCAoaXJxIC0gMzIpKTsKKwlQSUMxX0lFTiAmPSB+KDEgPDwgKGQtPmlycSAtIDMyKSk7CisJUElDMV9DUkVRIHw9ICgxIDw8IChkLT5pcnEgLSAzMikpOwogfQogCi1zdGF0aWMgdm9pZCB0Y2M4MDAwX21hc2tfaXJxMCh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgdGNjODAwMF9tYXNrX2lycTAoc3RydWN0IGlycV9kYXRhICpkKQogewotCVBJQzBfSUVOICY9IH4oMSA8PCBpcnEpOworCVBJQzBfSUVOICY9IH4oMSA8PCBkLT5pcnEpOwogfQogCi1zdGF0aWMgdm9pZCB0Y2M4MDAwX21hc2tfaXJxMSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgdGNjODAwMF9tYXNrX2lycTEoc3RydWN0IGlycV9kYXRhICpkKQogewotCVBJQzFfSUVOICY9IH4oMSA8PCAoaXJxIC0gMzIpKTsKKwlQSUMxX0lFTiAmPSB+KDEgPDwgKGQtPmlycSAtIDMyKSk7CiB9CiAKLXN0YXRpYyB2b2lkIHRjYzgwMDBfYWNrX2lycTAodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHRjYzgwMDBfYWNrX2lycTAoc3RydWN0IGlycV9kYXRhICpkKQogewotCVBJQzBfQ1JFUSB8PSAgKDEgPDwgaXJxKTsKKwlQSUMwX0NSRVEgfD0gICgxIDw8IGQtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIHRjYzgwMDBfYWNrX2lycTEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHRjYzgwMDBfYWNrX2lycTEoc3RydWN0IGlycV9kYXRhICpkKQogewotCVBJQzFfQ1JFUSB8PSAoMSA8PCAoaXJxIC0gMzIpKTsKKwlQSUMxX0NSRVEgfD0gKDEgPDwgKGQtPmlycSAtIDMyKSk7CiB9CiAKIC8qIEVuYWJsZSBJUlEgKi8KLXN0YXRpYyB2b2lkIHRjYzgwMDBfdW5tYXNrX2lycTAodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHRjYzgwMDBfdW5tYXNrX2lycTAoc3RydWN0IGlycV9kYXRhICpkKQogewotCVBJQzBfSUVOIHw9ICgxIDw8IGlycSk7Ci0JUElDMF9JTlRPRU4gfD0gKDEgPDwgaXJxKTsKKwlQSUMwX0lFTiB8PSAoMSA8PCBkLT5pcnEpOworCVBJQzBfSU5UT0VOIHw9ICgxIDw8IGQtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIHRjYzgwMDBfdW5tYXNrX2lycTEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHRjYzgwMDBfdW5tYXNrX2lycTEoc3RydWN0IGlycV9kYXRhICpkKQogewotCVBJQzFfSUVOIHw9ICgxIDw8IChpcnEgLSAzMikpOwotCVBJQzFfSU5UT0VOIHw9ICgxIDw8IChpcnEgLSAzMikpOworCVBJQzFfSUVOIHw9ICgxIDw8IChkLT5pcnEgLSAzMikpOworCVBJQzFfSU5UT0VOIHw9ICgxIDw8IChkLT5pcnEgLSAzMikpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHRjYzgwMDBfaXJxX2NoaXAwID0gewogCS5uYW1lCQk9ICJ0Y2NfaXJxMCIsCi0JLm1hc2sJCT0gdGNjODAwMF9tYXNrX2lycTAsCi0JLmFjawkJPSB0Y2M4MDAwX2Fja19pcnEwLAotCS5tYXNrX2Fjawk9IHRjYzgwMDBfbWFza19hY2tfaXJxMCwKLQkudW5tYXNrCQk9IHRjYzgwMDBfdW5tYXNrX2lycTAsCisJLmlycV9tYXNrCT0gdGNjODAwMF9tYXNrX2lycTAsCisJLmlycV9hY2sJPSB0Y2M4MDAwX2Fja19pcnEwLAorCS5pcnFfbWFza19hY2sJPSB0Y2M4MDAwX21hc2tfYWNrX2lycTAsCisJLmlycV91bm1hc2sJPSB0Y2M4MDAwX3VubWFza19pcnEwLAogfTsKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCB0Y2M4MDAwX2lycV9jaGlwMSA9IHsKIAkubmFtZQkJPSAidGNjX2lycTEiLAotCS5tYXNrCQk9IHRjYzgwMDBfbWFza19pcnExLAotCS5hY2sJCT0gdGNjODAwMF9hY2tfaXJxMSwKLQkubWFza19hY2sJPSB0Y2M4MDAwX21hc2tfYWNrX2lycTEsCi0JLnVubWFzawkJPSB0Y2M4MDAwX3VubWFza19pcnExLAorCS5pcnFfbWFzawk9IHRjYzgwMDBfbWFza19pcnExLAorCS5pcnFfYWNrCT0gdGNjODAwMF9hY2tfaXJxMSwKKwkuaXJxX21hc2tfYWNrCT0gdGNjODAwMF9tYXNrX2Fja19pcnExLAorCS5pcnFfdW5tYXNrCT0gdGNjODAwMF91bm1hc2tfaXJxMSwKIH07CiAKIHZvaWQgX19pbml0IHRjYzhrX2luaXRfaXJxKHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXRlZ3JhL2dwaW8uYyBiL2FyY2gvYXJtL21hY2gtdGVncmEvZ3Bpby5jCmluZGV4IDA3NzUyNjUuLmFkODA0ODggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtdGVncmEvZ3Bpby5jCisrKyBiL2FyY2gvYXJtL21hY2gtdGVncmEvZ3Bpby5jCkBAIC0xNDIsMzEgKzE0MiwzMSBAQAogCS5uZ3BpbwkJCT0gVEVHUkFfTlJfR1BJT1MsCiB9OwogCi1zdGF0aWMgdm9pZCB0ZWdyYV9ncGlvX2lycV9hY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHRlZ3JhX2dwaW9faXJxX2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaW50IGdwaW8gPSBpcnEgLSBJTlRfR1BJT19CQVNFOworCWludCBncGlvID0gZC0+aXJxIC0gSU5UX0dQSU9fQkFTRTsKIAogCV9fcmF3X3dyaXRlbCgxIDw8IEdQSU9fQklUKGdwaW8pLCBHUElPX0lOVF9DTFIoZ3BpbykpOwogfQogCi1zdGF0aWMgdm9pZCB0ZWdyYV9ncGlvX2lycV9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB0ZWdyYV9ncGlvX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpbnQgZ3BpbyA9IGlycSAtIElOVF9HUElPX0JBU0U7CisJaW50IGdwaW8gPSBkLT5pcnEgLSBJTlRfR1BJT19CQVNFOwogCiAJdGVncmFfZ3Bpb19tYXNrX3dyaXRlKEdQSU9fTVNLX0lOVF9FTkIoZ3BpbyksIGdwaW8sIDApOwogfQogCi1zdGF0aWMgdm9pZCB0ZWdyYV9ncGlvX2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHRlZ3JhX2dwaW9faXJxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JaW50IGdwaW8gPSBpcnEgLSBJTlRfR1BJT19CQVNFOworCWludCBncGlvID0gZC0+aXJxIC0gSU5UX0dQSU9fQkFTRTsKIAogCXRlZ3JhX2dwaW9fbWFza193cml0ZShHUElPX01TS19JTlRfRU5CKGdwaW8pLCBncGlvLCAxKTsKIH0KIAotc3RhdGljIGludCB0ZWdyYV9ncGlvX2lycV9zZXRfdHlwZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgdHlwZSkKK3N0YXRpYyBpbnQgdGVncmFfZ3Bpb19pcnFfc2V0X3R5cGUoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgdHlwZSkKIHsKLQlpbnQgZ3BpbyA9IGlycSAtIElOVF9HUElPX0JBU0U7Ci0Jc3RydWN0IHRlZ3JhX2dwaW9fYmFuayAqYmFuayA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJaW50IGdwaW8gPSBkLT5pcnEgLSBJTlRfR1BJT19CQVNFOworCXN0cnVjdCB0ZWdyYV9ncGlvX2JhbmsgKmJhbmsgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKIAlpbnQgcG9ydCA9IEdQSU9fUE9SVChncGlvKTsKIAlpbnQgbHZsX3R5cGU7CiAJaW50IHZhbDsKQEAgLTIwNyw5ICsyMDcsOSBAQAogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmJhbmstPmx2bF9sb2NrW3BvcnRdLCBmbGFncyk7CiAKIAlpZiAodHlwZSAmIChJUlFfVFlQRV9MRVZFTF9MT1cgfCBJUlFfVFlQRV9MRVZFTF9ISUdIKSkKLQkJX19zZXRfaXJxX2hhbmRsZXJfdW5sb2NrZWQoaXJxLCBoYW5kbGVfbGV2ZWxfaXJxKTsKKwkJX19zZXRfaXJxX2hhbmRsZXJfdW5sb2NrZWQoZC0+aXJxLCBoYW5kbGVfbGV2ZWxfaXJxKTsKIAllbHNlIGlmICh0eXBlICYgKElSUV9UWVBFX0VER0VfRkFMTElORyB8IElSUV9UWVBFX0VER0VfUklTSU5HKSkKLQkJX19zZXRfaXJxX2hhbmRsZXJfdW5sb2NrZWQoaXJxLCBoYW5kbGVfZWRnZV9pcnEpOworCQlfX3NldF9pcnFfaGFuZGxlcl91bmxvY2tlZChkLT5pcnEsIGhhbmRsZV9lZGdlX2lycSk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTIyMSw3ICsyMjEsNyBAQAogCWludCBwaW47CiAJaW50IHVubWFza2VkID0gMDsKIAotCWRlc2MtPmNoaXAtPmFjayhpcnEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9hY2soJmRlc2MtPmlycV9kYXRhKTsKIAogCWJhbmsgPSBnZXRfaXJxX2RhdGEoaXJxKTsKIApAQCAtMjQwLDcgKzI0MCw3IEBACiAJCQkgKi8KIAkJCWlmIChsdmwgJiAoMHgxMDAgPDwgcGluKSkgewogCQkJCXVubWFza2VkID0gMTsKLQkJCQlkZXNjLT5jaGlwLT51bm1hc2soaXJxKTsKKwkJCQlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfdW5tYXNrKCZkZXNjLT5pcnFfZGF0YSk7CiAJCQl9CiAKIAkJCWdlbmVyaWNfaGFuZGxlX2lycShncGlvX3RvX2lycShncGlvICsgcGluKSk7CkBAIC0yNDgsNyArMjQ4LDcgQEAKIAl9CiAKIAlpZiAoIXVubWFza2VkKQotCQlkZXNjLT5jaGlwLT51bm1hc2soaXJxKTsKKwkJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX3VubWFzaygmZGVzYy0+aXJxX2RhdGEpOwogCiB9CiAKQEAgLTMxNiwyMSArMzE2LDIxIEBACiAJbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogfQogCi1zdGF0aWMgaW50IHRlZ3JhX2dwaW9fd2FrZV9lbmFibGUodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IGVuYWJsZSkKK3N0YXRpYyBpbnQgdGVncmFfZ3Bpb193YWtlX2VuYWJsZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCBlbmFibGUpCiB7Ci0Jc3RydWN0IHRlZ3JhX2dwaW9fYmFuayAqYmFuayA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IHRlZ3JhX2dwaW9fYmFuayAqYmFuayA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOwogCXJldHVybiBzZXRfaXJxX3dha2UoYmFuay0+aXJxLCBlbmFibGUpOwogfQogI2VuZGlmCiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgdGVncmFfZ3Bpb19pcnFfY2hpcCA9IHsKIAkubmFtZQkJPSAiR1BJTyIsCi0JLmFjawkJPSB0ZWdyYV9ncGlvX2lycV9hY2ssCi0JLm1hc2sJCT0gdGVncmFfZ3Bpb19pcnFfbWFzaywKLQkudW5tYXNrCQk9IHRlZ3JhX2dwaW9faXJxX3VubWFzaywKLQkuc2V0X3R5cGUJPSB0ZWdyYV9ncGlvX2lycV9zZXRfdHlwZSwKKwkuaXJxX2Fjawk9IHRlZ3JhX2dwaW9faXJxX2FjaywKKwkuaXJxX21hc2sJPSB0ZWdyYV9ncGlvX2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gdGVncmFfZ3Bpb19pcnFfdW5tYXNrLAorCS5pcnFfc2V0X3R5cGUJPSB0ZWdyYV9ncGlvX2lycV9zZXRfdHlwZSwKICNpZmRlZiBDT05GSUdfUE0KLQkuc2V0X3dha2UJPSB0ZWdyYV9ncGlvX3dha2VfZW5hYmxlLAorCS5pcnFfc2V0X3dha2UJPSB0ZWdyYV9ncGlvX3dha2VfZW5hYmxlLAogI2VuZGlmCiB9OwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXRlZ3JhL2hvdHBsdWcuYyBiL2FyY2gvYXJtL21hY2gtdGVncmEvaG90cGx1Zy5jCmluZGV4IGE1Y2IxY2UuLmYzMjk0MDQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtdGVncmEvaG90cGx1Zy5jCisrKyBiL2FyY2gvYXJtL21hY2gtdGVncmEvaG90cGx1Zy5jCkBAIC0yNiwxMCArMjYsMTAgQEAKIAkgKiBUdXJuIG9mZiBjb2hlcmVuY3kKIAkgKi8KIAkiCW1yYwlwMTUsIDAsICUwLCBjMSwgYzAsIDFcbiIKLQkiCWJpYwklMCwgJTAsICUyXG4iCisJIgliaWMJJTAsICUwLCAjMHgyMFxuIgogCSIJbWNyCXAxNSwgMCwgJTAsIGMxLCBjMCwgMVxuIgogCSIJbXJjCXAxNSwgMCwgJTAsIGMxLCBjMCwgMFxuIgotCSIJYmljCSUwLCAlMCwgIzB4MDRcbiIKKwkiCWJpYwklMCwgJTAsICUyXG4iCiAJIgltY3IJcDE1LCAwLCAlMCwgYzEsIGMwLCAwXG4iCiAJICA6ICI9JnIiICh2KQogCSAgOiAiciIgKDApLCAiSXIiIChDUl9DKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC10ZWdyYS9pbmNsdWRlL21hY2gvY2xrLmggYi9hcmNoL2FybS9tYWNoLXRlZ3JhL2luY2x1ZGUvbWFjaC9jbGsuaAppbmRleCBkNzcyMzk1Li5hMjE3ZjY4IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXRlZ3JhL2luY2x1ZGUvbWFjaC9jbGsuaAorKysgYi9hcmNoL2FybS9tYWNoLXRlZ3JhL2luY2x1ZGUvbWFjaC9jbGsuaApAQCAtMjAsNiArMjAsOCBAQAogI2lmbmRlZiBfX01BQ0hfQ0xLX0gKICNkZWZpbmUgX19NQUNIX0NMS19ICiAKK3N0cnVjdCBjbGs7CisKIHZvaWQgdGVncmFfcGVyaXBoX3Jlc2V0X2RlYXNzZXJ0KHN0cnVjdCBjbGsgKmMpOwogdm9pZCB0ZWdyYV9wZXJpcGhfcmVzZXRfYXNzZXJ0KHN0cnVjdCBjbGsgKmMpOwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXRlZ3JhL2luY2x1ZGUvbWFjaC9jbGtkZXYuaCBiL2FyY2gvYXJtL21hY2gtdGVncmEvaW5jbHVkZS9tYWNoL2Nsa2Rldi5oCmluZGV4IDQxMmY1YzYuLjY2Y2QzZjQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtdGVncmEvaW5jbHVkZS9tYWNoL2Nsa2Rldi5oCisrKyBiL2FyY2gvYXJtL21hY2gtdGVncmEvaW5jbHVkZS9tYWNoL2Nsa2Rldi5oCkBAIC0yMCw2ICsyMCw4IEBACiAjaWZuZGVmIF9fTUFDSF9DTEtERVZfSAogI2RlZmluZSBfX01BQ0hfQ0xLREVWX0gKIAorc3RydWN0IGNsazsKKwogc3RhdGljIGlubGluZSBpbnQgX19jbGtfZ2V0KHN0cnVjdCBjbGsgKmNsaykKIHsKIAlyZXR1cm4gMTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtdGVncmEvaW5jbHVkZS9tYWNoL2tiYy5oIGIvYXJjaC9hcm0vbWFjaC10ZWdyYS9pbmNsdWRlL21hY2gva2JjLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjZhZDI3NgotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvYXJtL21hY2gtdGVncmEvaW5jbHVkZS9tYWNoL2tiYy5oCkBAIC0wLDAgKzEsNjEgQEAKKy8qCisgKiBQbGF0Zm9ybSBkZWZpbml0aW9ucyBmb3IgdGVncmEta2JjIGtleWJvYXJkIGlucHV0IGRyaXZlcgorICoKKyAqIENvcHlyaWdodCAoYykgMjAxMC0yMDExLCBOVklESUEgQ29ycG9yYXRpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKKyAqIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mIE1FUkNIQU5UQUJJTElUWSBvcgorICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvcgorICogbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFsb25nCisgKiB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAorICogNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpZm5kZWYgQVNNQVJNX0FSQ0hfVEVHUkFfS0JDX0gKKyNkZWZpbmUgQVNNQVJNX0FSQ0hfVEVHUkFfS0JDX0gKKworI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisjaW5jbHVkZSA8bGludXgvaW5wdXQvbWF0cml4X2tleXBhZC5oPgorCisjaWZkZWYgQ09ORklHX0FSQ0hfVEVHUkFfMnhfU09DCisjZGVmaW5lIEtCQ19NQVhfR1BJTwkyNAorI2RlZmluZSBLQkNfTUFYX0tQRU5UCTgKKyNlbHNlCisjZGVmaW5lIEtCQ19NQVhfR1BJTwkyMAorI2RlZmluZSBLQkNfTUFYX0tQRU5UCTcKKyNlbmRpZgorCisjZGVmaW5lIEtCQ19NQVhfUk9XCTE2CisjZGVmaW5lIEtCQ19NQVhfQ09MCTgKKyNkZWZpbmUgS0JDX01BWF9LRVkJKEtCQ19NQVhfUk9XICogS0JDX01BWF9DT0wpCisKK3N0cnVjdCB0ZWdyYV9rYmNfcGluX2NmZyB7CisJYm9vbCBpc19yb3c7CisJdW5zaWduZWQgY2hhciBudW07Cit9OworCitzdHJ1Y3QgdGVncmFfa2JjX3dha2Vfa2V5IHsKKwl1OCByb3c6NDsKKwl1OCBjb2w6NDsKK307CisKK3N0cnVjdCB0ZWdyYV9rYmNfcGxhdGZvcm1fZGF0YSB7CisJdW5zaWduZWQgaW50IGRlYm91bmNlX2NudDsKKwl1bnNpZ25lZCBpbnQgcmVwZWF0X2NudDsKKworCXVuc2lnbmVkIGludCB3YWtlX2NudDsgLyogMDp3YWtlIG9uIGFueSBrZXkgPjE6d2FrZSBvbiB3YWtlX2NmZyAqLworCWNvbnN0IHN0cnVjdCB0ZWdyYV9rYmNfd2FrZV9rZXkgKndha2VfY2ZnOworCisJc3RydWN0IHRlZ3JhX2tiY19waW5fY2ZnIHBpbl9jZmdbS0JDX01BWF9HUElPXTsKKwljb25zdCBzdHJ1Y3QgbWF0cml4X2tleW1hcF9kYXRhICprZXltYXBfZGF0YTsKKworCWJvb2wgd2FrZXVwOworfTsKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC10ZWdyYS9pcnEuYyBiL2FyY2gvYXJtL21hY2gtdGVncmEvaXJxLmMKaW5kZXggNTQwN2RlMC4uMTdjNzRkMiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC10ZWdyYS9pcnEuYworKysgYi9hcmNoL2FybS9tYWNoLXRlZ3JhL2lycS5jCkBAIC00NiwzMCArNDYsMzAgQEAKICNkZWZpbmUgSUNUTFJfQ09QX0lFUl9DTFIJMHgzOAogI2RlZmluZSBJQ1RMUl9DT1BfSUVQX0NMQVNTCTB4M2MKIAotc3RhdGljIHZvaWQgKCpnaWNfbWFza19pcnEpKHVuc2lnbmVkIGludCBpcnEpOwotc3RhdGljIHZvaWQgKCpnaWNfdW5tYXNrX2lycSkodW5zaWduZWQgaW50IGlycSk7CitzdGF0aWMgdm9pZCAoKnRlZ3JhX2dpY19tYXNrX2lycSkoc3RydWN0IGlycV9kYXRhICpkKTsKK3N0YXRpYyB2b2lkICgqdGVncmFfZ2ljX3VubWFza19pcnEpKHN0cnVjdCBpcnFfZGF0YSAqZCk7CiAKLSNkZWZpbmUgaXJxX3RvX2ljdGxyKGlycSkgKCgoaXJxKS0zMikgPj4gNSkKKyNkZWZpbmUgaXJxX3RvX2ljdGxyKGlycSkgKCgoaXJxKSAtIDMyKSA+PiA1KQogc3RhdGljIHZvaWQgX19pb21lbSAqdGVncmFfaWN0bHJfYmFzZSA9IElPX0FERFJFU1MoVEVHUkFfUFJJTUFSWV9JQ1RMUl9CQVNFKTsKLSNkZWZpbmUgaWN0bHJfdG9fdmlydChpY3RscikgKHRlZ3JhX2ljdGxyX2Jhc2UgKyAoaWN0bHIpKjB4MTAwKQorI2RlZmluZSBpY3Rscl90b192aXJ0KGljdGxyKSAodGVncmFfaWN0bHJfYmFzZSArIChpY3RscikgKiAweDEwMCkKIAotc3RhdGljIHZvaWQgdGVncmFfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgdGVncmFfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jdm9pZCBfX2lvbWVtICphZGRyID0gaWN0bHJfdG9fdmlydChpcnFfdG9faWN0bHIoaXJxKSk7Ci0JZ2ljX21hc2tfaXJxKGlycSk7Ci0Jd3JpdGVsKDE8PChpcnEmMzEpLCBhZGRyK0lDVExSX0NQVV9JRVJfQ0xSKTsKKwl2b2lkIF9faW9tZW0gKmFkZHIgPSBpY3Rscl90b192aXJ0KGlycV90b19pY3RscihkLT5pcnEpKTsKKwl0ZWdyYV9naWNfbWFza19pcnEoZCk7CisJd3JpdGVsKDEgPDwgKGQtPmlycSAmIDMxKSwgYWRkcitJQ1RMUl9DUFVfSUVSX0NMUik7CiB9CiAKLXN0YXRpYyB2b2lkIHRlZ3JhX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgdGVncmFfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl2b2lkIF9faW9tZW0gKmFkZHIgPSBpY3Rscl90b192aXJ0KGlycV90b19pY3RscihpcnEpKTsKLQlnaWNfdW5tYXNrX2lycShpcnEpOwotCXdyaXRlbCgxPDwoaXJxJjMxKSwgYWRkcitJQ1RMUl9DUFVfSUVSX1NFVCk7CisJdm9pZCBfX2lvbWVtICphZGRyID0gaWN0bHJfdG9fdmlydChpcnFfdG9faWN0bHIoZC0+aXJxKSk7CisJdGVncmFfZ2ljX3VubWFza19pcnEoZCk7CisJd3JpdGVsKDE8PChkLT5pcnEmMzEpLCBhZGRyK0lDVExSX0NQVV9JRVJfU0VUKTsKIH0KIAogI2lmZGVmIENPTkZJR19QTQogCi1zdGF0aWMgaW50IHRlZ3JhX3NldF93YWtlKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCBvbikKK3N0YXRpYyBpbnQgdGVncmFfc2V0X3dha2Uoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgb24pCiB7CiAJcmV0dXJuIDA7CiB9CkBAIC03NywxMCArNzcsMTAgQEAKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCB0ZWdyYV9pcnEgPSB7CiAJLm5hbWUJCT0gIlBQSSIsCi0JLm1hc2sJCT0gdGVncmFfbWFzaywKLQkudW5tYXNrCQk9IHRlZ3JhX3VubWFzaywKKwkuaXJxX21hc2sJPSB0ZWdyYV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gdGVncmFfdW5tYXNrLAogI2lmZGVmIENPTkZJR19QTQotCS5zZXRfd2FrZQk9IHRlZ3JhX3NldF93YWtlLAorCS5pcnFfc2V0X3dha2UJPSB0ZWdyYV9zZXRfd2FrZSwKICNlbmRpZgogfTsKIApAQCAtOTgsMTEgKzk4LDExIEBACiAJCSBJT19BRERSRVNTKFRFR1JBX0FSTV9QRVJJRl9CQVNFICsgMHgxMDApKTsKIAogCWdpYyA9IGdldF9pcnFfY2hpcCgyOSk7Ci0JZ2ljX3VubWFza19pcnEgPSBnaWMtPnVubWFzazsKLQlnaWNfbWFza19pcnEgPSBnaWMtPm1hc2s7Ci0JdGVncmFfaXJxLmFjayA9IGdpYy0+YWNrOworCXRlZ3JhX2dpY191bm1hc2tfaXJxID0gZ2ljLT5pcnFfdW5tYXNrOworCXRlZ3JhX2dpY19tYXNrX2lycSA9IGdpYy0+aXJxX21hc2s7CisJdGVncmFfaXJxLmlycV9hY2sgPSBnaWMtPmlycV9hY2s7CiAjaWZkZWYgQ09ORklHX1NNUAotCXRlZ3JhX2lycS5zZXRfYWZmaW5pdHkgPSBnaWMtPnNldF9hZmZpbml0eTsKKwl0ZWdyYV9pcnEuaXJxX3NldF9hZmZpbml0eSA9IGdpYy0+aXJxX3NldF9hZmZpbml0eTsKICNlbmRpZgogCiAJZm9yIChpID0gSU5UX1BSSV9CQVNFOyBpIDwgSU5UX0dQSU9fQkFTRTsgaSsrKSB7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXZlcnNhdGlsZS9LY29uZmlnIGIvYXJjaC9hcm0vbWFjaC12ZXJzYXRpbGUvS2NvbmZpZwppbmRleCAzZjdiNWU5Li45Y2RlYzVhIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXZlcnNhdGlsZS9LY29uZmlnCisrKyBiL2FyY2gvYXJtL21hY2gtdmVyc2F0aWxlL0tjb25maWcKQEAgLTIsMTcgKzIsMTkgQEAKIAlkZXBlbmRzIG9uIEFSQ0hfVkVSU0FUSUxFCiAKIGNvbmZpZyBBUkNIX1ZFUlNBVElMRV9QQgotCWJvb2wgIlN1cHBvcnQgVmVyc2F0aWxlL1BCIHBsYXRmb3JtIgorCWJvb2wgIlN1cHBvcnQgVmVyc2F0aWxlIFBsYXRmb3JtIEJhc2Vib2FyZCBmb3IgQVJNOTI2RUotUyIKIAlzZWxlY3QgQ1BVX0FSTTkyNlQKIAlzZWxlY3QgTUlHSFRfSEFWRV9QQ0kKIAlkZWZhdWx0IHkKIAloZWxwCi0JICBJbmNsdWRlIHN1cHBvcnQgZm9yIHRoZSBBUk0oUikgVmVyc2F0aWxlL1BCIHBsYXRmb3JtLgorCSAgSW5jbHVkZSBzdXBwb3J0IGZvciB0aGUgQVJNKFIpIFZlcnNhdGlsZSBQbGF0Zm9ybSBCYXNlYm9hcmQKKwkgIGZvciB0aGUgQVJNOTI2RUotUy4KIAogY29uZmlnIE1BQ0hfVkVSU0FUSUxFX0FCCi0JYm9vbCAiU3VwcG9ydCBWZXJzYXRpbGUvQUIgcGxhdGZvcm0iCisJYm9vbCAiU3VwcG9ydCBWZXJzYXRpbGUgQXBwbGljYXRpb24gQmFzZWJvYXJkIGZvciBBUk05MjZFSi1TIgogCXNlbGVjdCBDUFVfQVJNOTI2VAogCWhlbHAKLQkgIEluY2x1ZGUgc3VwcG9ydCBmb3IgdGhlIEFSTShSKSBWZXJzYXRpbGUvQVAgcGxhdGZvcm0uCisJICBJbmNsdWRlIHN1cHBvcnQgZm9yIHRoZSBBUk0oUikgVmVyc2F0aWxlIEFwcGxpY2F0aW9uIEJhc2Vib2FyZAorCSAgZm9yIHRoZSBBUk05MjZFSi1TLgogCiBlbmRtZW51CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXZlcnNhdGlsZS9jb3JlLmMgYi9hcmNoL2FybS9tYWNoLXZlcnNhdGlsZS9jb3JlLmMKaW5kZXggMTNhODNlNC4uMTM2YzMyZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC12ZXJzYXRpbGUvY29yZS5jCisrKyBiL2FyY2gvYXJtL21hY2gtdmVyc2F0aWxlL2NvcmUuYwpAQCAtNjMsMjMgKzYzLDI1IEBACiAjZGVmaW5lIFZBX1ZJQ19CQVNFCQlfX2lvX2FkZHJlc3MoVkVSU0FUSUxFX1ZJQ19CQVNFKQogI2RlZmluZSBWQV9TSUNfQkFTRQkJX19pb19hZGRyZXNzKFZFUlNBVElMRV9TSUNfQkFTRSkKIAotc3RhdGljIHZvaWQgc2ljX21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzaWNfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCWlycSAtPSBJUlFfU0lDX1NUQVJUOworCXVuc2lnbmVkIGludCBpcnEgPSBkLT5pcnEgLSBJUlFfU0lDX1NUQVJUOworCiAJd3JpdGVsKDEgPDwgaXJxLCBWQV9TSUNfQkFTRSArIFNJQ19JUlFfRU5BQkxFX0NMRUFSKTsKIH0KIAotc3RhdGljIHZvaWQgc2ljX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHNpY191bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpcnEgLT0gSVJRX1NJQ19TVEFSVDsKKwl1bnNpZ25lZCBpbnQgaXJxID0gZC0+aXJxIC0gSVJRX1NJQ19TVEFSVDsKKwogCXdyaXRlbCgxIDw8IGlycSwgVkFfU0lDX0JBU0UgKyBTSUNfSVJRX0VOQUJMRV9TRVQpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHNpY19jaGlwID0gewotCS5uYW1lCT0gIlNJQyIsCi0JLmFjawk9IHNpY19tYXNrX2lycSwKLQkubWFzawk9IHNpY19tYXNrX2lycSwKLQkudW5tYXNrCT0gc2ljX3VubWFza19pcnEsCisJLm5hbWUJCT0gIlNJQyIsCisJLmlycV9hY2sJPSBzaWNfbWFza19pcnEsCisJLmlycV9tYXNrCT0gc2ljX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gc2ljX3VubWFza19pcnEsCiB9OwogCiBzdGF0aWMgdm9pZApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC12ZXhwcmVzcy9wbGF0c21wLmMgYi9hcmNoL2FybS9tYWNoLXZleHByZXNzL3BsYXRzbXAuYwppbmRleCBiMTY4N2I2Li42MzRiZjFkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXZleHByZXNzL3BsYXRzbXAuYworKysgYi9hcmNoL2FybS9tYWNoLXZleHByZXNzL3BsYXRzbXAuYwpAQCAtMzksNyArMzksNyBAQAogICogb2JzZXJ2ZXJzLCBpcnJlc3BlY3RpdmUgb2Ygd2hldGhlciB0aGV5J3JlIHRha2luZyBwYXJ0IGluIGNvaGVyZW5jeQogICogb3Igbm90LiAgVGhpcyBpcyBuZWNlc3NhcnkgZm9yIHRoZSBob3RwbHVnIGNvZGUgdG8gd29yayByZWxpYWJseS4KICAqLwotc3RhdGljIHZvaWQgd3JpdGVfcGVuX3JlbGVhc2UoaW50IHZhbCkKK3N0YXRpYyB2b2lkIF9fY3B1aW5pdCB3cml0ZV9wZW5fcmVsZWFzZShpbnQgdmFsKQogewogCXBlbl9yZWxlYXNlID0gdmFsOwogCXNtcF93bWIoKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtdmV4cHJlc3MvdjJtLmMgYi9hcmNoL2FybS9tYWNoLXZleHByZXNzL3YybS5jCmluZGV4IGE5ZWQzNDIuLjFlZGFlNjUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtdmV4cHJlc3MvdjJtLmMKKysrIGIvYXJjaC9hcm0vbWFjaC12ZXhwcmVzcy92Mm0uYwpAQCAtMTksNiArMTksNyBAQAogI2luY2x1ZGUgPGFzbS9tYWNoL3RpbWUuaD4KICNpbmNsdWRlIDxhc20vaGFyZHdhcmUvYXJtX3RpbWVyLmg+CiAjaW5jbHVkZSA8YXNtL2hhcmR3YXJlL3RpbWVyLXNwLmg+CisjaW5jbHVkZSA8YXNtL2hhcmR3YXJlL3NwODEwLmg+CiAKICNpbmNsdWRlIDxtYWNoL21vdGhlcmJvYXJkLmg+CiAKQEAgLTUwLDggKzUxLDE2IEBACiAKIHN0YXRpYyB2b2lkIF9faW5pdCB2Mm1fdGltZXJfaW5pdCh2b2lkKQogeworCXUzMiBzY2N0cmw7CisKIAl2ZXJzYXRpbGVfc2NoZWRfY2xvY2tfaW5pdChNTUlPX1AyVihWMk1fU1lTXzI0TUhaKSwgMjQwMDAwMDApOwogCisJLyogU2VsZWN0IDFNSHogVElNQ0xLIGFzIHRoZSByZWZlcmVuY2UgY2xvY2sgZm9yIFNQODA0IHRpbWVycyAqLworCXNjY3RybCA9IHJlYWRsKE1NSU9fUDJWKFYyTV9TWVNDVEwgKyBTQ0NUUkwpKTsKKwlzY2N0cmwgfD0gU0NDVFJMX1RJTUVSRU4wU0VMX1RJTUNMSzsKKwlzY2N0cmwgfD0gU0NDVFJMX1RJTUVSRU4xU0VMX1RJTUNMSzsKKwl3cml0ZWwoc2NjdHJsLCBNTUlPX1AyVihWMk1fU1lTQ1RMICsgU0NDVFJMKSk7CisKIAl3cml0ZWwoMCwgTU1JT19QMlYoVjJNX1RJTUVSMCkgKyBUSU1FUl9DVFJMKTsKIAl3cml0ZWwoMCwgTU1JT19QMlYoVjJNX1RJTUVSMSkgKyBUSU1FUl9DVFJMKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC13OTB4OTAwL2lycS5jIGIvYXJjaC9hcm0vbWFjaC13OTB4OTAwL2lycS5jCmluZGV4IDBjZTlkOGUuLjljMzUwMTAgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtdzkweDkwMC9pcnEuYworKysgYi9hcmNoL2FybS9tYWNoLXc5MHg5MDAvaXJxLmMKQEAgLTkyLDE1ICs5MiwxNSBAQAogCV9fcmF3X3dyaXRlbChyZWd2YWwsIFJFR19BSUNfR0VOKTsKIH0KIAotc3RhdGljIHZvaWQgbnVjOTAwX2lycV9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBudWM5MDBfaXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkKQogewogCXN0cnVjdCBncm91cF9pcnEgKmdyb3VwX2lycTsKIAogCWdyb3VwX2lycSA9IE5VTEw7CiAKLQlfX3Jhd193cml0ZWwoMSA8PCBpcnEsIFJFR19BSUNfTURDUik7CisJX19yYXdfd3JpdGVsKDEgPDwgZC0+aXJxLCBSRUdfQUlDX01EQ1IpOwogCi0Jc3dpdGNoIChpcnEpIHsKKwlzd2l0Y2ggKGQtPmlycSkgewogCWNhc2UgSVJRX0dST1VQMDoKIAkJZ3JvdXBfaXJxID0gJmdyb3VwX25pcnEwOwogCQlicmVhazsKQEAgLTE0MywyMCArMTQzLDIwIEBACiAgKiB0byBSRUdfQUlDX0VPU0NSIGZvciBBQ0sKICAqLwogCi1zdGF0aWMgdm9pZCBudWM5MDBfaXJxX2Fjayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbnVjOTAwX2lycV9hY2soc3RydWN0IGlycV9kYXRhICpkKQogewogCV9fcmF3X3dyaXRlbCgweDAxLCBSRUdfQUlDX0VPU0NSKTsKIH0KIAotc3RhdGljIHZvaWQgbnVjOTAwX2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG51YzkwMF9pcnFfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAlzdHJ1Y3QgZ3JvdXBfaXJxICpncm91cF9pcnE7CiAKIAlncm91cF9pcnEgPSBOVUxMOwogCi0JX19yYXdfd3JpdGVsKDEgPDwgaXJxLCBSRUdfQUlDX01FQ1IpOworCV9fcmF3X3dyaXRlbCgxIDw8IGQtPmlycSwgUkVHX0FJQ19NRUNSKTsKIAotCXN3aXRjaCAoaXJxKSB7CisJc3dpdGNoIChkLT5pcnEpIHsKIAljYXNlIElSUV9HUk9VUDA6CiAJCWdyb3VwX2lycSA9ICZncm91cF9uaXJxMDsKIAkJYnJlYWs7CkBAIC0xOTUsOSArMTk1LDkgQEAKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBudWM5MDBfaXJxX2NoaXAgPSB7Ci0JLmFjawkgICA9IG51YzkwMF9pcnFfYWNrLAotCS5tYXNrCSAgID0gbnVjOTAwX2lycV9tYXNrLAotCS51bm1hc2sJICAgPSBudWM5MDBfaXJxX3VubWFzaywKKwkuaXJxX2Fjawk9IG51YzkwMF9pcnFfYWNrLAorCS5pcnFfbWFzawk9IG51YzkwMF9pcnFfbWFzaywKKwkuaXJxX3VubWFzawk9IG51YzkwMF9pcnFfdW5tYXNrLAogfTsKIAogdm9pZCBfX2luaXQgbnVjOTAwX2luaXRfaXJxKHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tbS9LY29uZmlnIGIvYXJjaC9hcm0vbW0vS2NvbmZpZwppbmRleCBmY2MxZTYyLi45ZDMwYzZmIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9LY29uZmlnCisrKyBiL2FyY2gvYXJtL21tL0tjb25maWcKQEAgLTY0NCw3ICs2NDQsNyBAQAogCiBjb25maWcgU1dQX0VNVUxBVEUKIAlib29sICJFbXVsYXRlIFNXUC9TV1BCIGluc3RydWN0aW9ucyIKLQlkZXBlbmRzIG9uIENQVV9WNworCWRlcGVuZHMgb24gQ1BVX1Y3ICYmICFDUFVfVjYKIAlzZWxlY3QgSEFWRV9QUk9DX0NQVSBpZiBQUk9DX0ZTCiAJZGVmYXVsdCB5IGlmIFNNUAogCWhlbHAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21tL2RtYS1tYXBwaW5nLmMgYi9hcmNoL2FybS9tbS9kbWEtbWFwcGluZy5jCmluZGV4IDZiNDhlMGEuLjQ3NzFkYmEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21tL2RtYS1tYXBwaW5nLmMKKysrIGIvYXJjaC9hcm0vbW0vZG1hLW1hcHBpbmcuYwpAQCAtNTc3LDcgKzU3Nyw3IEBACiAgKiBkbWFfdW5tYXBfc2cgLSB1bm1hcCBhIHNldCBvZiBTRyBidWZmZXJzIG1hcHBlZCBieSBkbWFfbWFwX3NnCiAgKiBAZGV2OiB2YWxpZCBzdHJ1Y3QgZGV2aWNlIHBvaW50ZXIsIG9yIE5VTEwgZm9yIElTQSBhbmQgRUlTQS1saWtlIGRldmljZXMKICAqIEBzZzogbGlzdCBvZiBidWZmZXJzCi0gKiBAbmVudHM6IG51bWJlciBvZiBidWZmZXJzIHRvIHVubWFwIChyZXR1cm5lZCBmcm9tIGRtYV9tYXBfc2cpCisgKiBAbmVudHM6IG51bWJlciBvZiBidWZmZXJzIHRvIHVubWFwIChzYW1lIGFzIHdhcyBwYXNzZWQgdG8gZG1hX21hcF9zZykKICAqIEBkaXI6IERNQSB0cmFuc2ZlciBkaXJlY3Rpb24gKHNhbWUgYXMgd2FzIHBhc3NlZCB0byBkbWFfbWFwX3NnKQogICoKICAqIFVubWFwIGEgc2V0IG9mIHN0cmVhbWluZyBtb2RlIERNQSB0cmFuc2xhdGlvbnMuICBBZ2FpbiwgQ1BVIGFjY2VzcwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0vaW5pdC5jIGIvYXJjaC9hcm0vbW0vaW5pdC5jCmluZGV4IDUxNjQwNjkuLmNkZGQ2ODQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21tL2luaXQuYworKysgYi9hcmNoL2FybS9tbS9pbml0LmMKQEAgLTI5Nyw2ICsyOTcsMTIgQEAKIAltZW1ibG9ja19yZXNlcnZlKF9fcGEoX3N0ZXh0KSwgX2VuZCAtIF9zdGV4dCk7CiAjZW5kaWYKICNpZmRlZiBDT05GSUdfQkxLX0RFVl9JTklUUkQKKwlpZiAocGh5c19pbml0cmRfc2l6ZSAmJgorCSAgICBtZW1ibG9ja19pc19yZWdpb25fcmVzZXJ2ZWQocGh5c19pbml0cmRfc3RhcnQsIHBoeXNfaW5pdHJkX3NpemUpKSB7CisJCXByX2VycigiSU5JVFJEOiAweCUwOGx4KzB4JTA4bHggb3ZlcmxhcHMgaW4tdXNlIG1lbW9yeSByZWdpb24gLSBkaXNhYmxpbmcgaW5pdHJkXG4iLAorCQkgICAgICAgcGh5c19pbml0cmRfc3RhcnQsIHBoeXNfaW5pdHJkX3NpemUpOworCQlwaHlzX2luaXRyZF9zdGFydCA9IHBoeXNfaW5pdHJkX3NpemUgPSAwOworCX0KIAlpZiAocGh5c19pbml0cmRfc2l6ZSkgewogCQltZW1ibG9ja19yZXNlcnZlKHBoeXNfaW5pdHJkX3N0YXJ0LCBwaHlzX2luaXRyZF9zaXplKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0vcGdkLmMgYi9hcmNoL2FybS9tbS9wZ2QuYwppbmRleCA5MzI5MmExLi43MDkyNDRjIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9wZ2QuYworKysgYi9hcmNoL2FybS9tbS9wZ2QuYwpAQCAtNTAsNyArNTAsNyBAQAogCQlpZiAoIW5ld19wbWQpCiAJCQlnb3RvIG5vX3BtZDsKIAotCQluZXdfcHRlID0gcHRlX2FsbG9jX21hcChtbSwgbmV3X3BtZCwgMCk7CisJCW5ld19wdGUgPSBwdGVfYWxsb2NfbWFwKG1tLCBOVUxMLCBuZXdfcG1kLCAwKTsKIAkJaWYgKCFuZXdfcHRlKQogCQkJZ290byBub19wdGU7CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21tL3Byb2MtdjcuUyBiL2FyY2gvYXJtL21tL3Byb2MtdjcuUwppbmRleCBiNDlmYWIyLi4wYzExNzJiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9wcm9jLXY3LlMKKysrIGIvYXJjaC9hcm0vbW0vcHJvYy12Ny5TCkBAIC0xNTksNyArMTU5LDkgQEAKIAl0c3RuZQlyMSwgI0xfUFRFX1BSRVNFTlQKIAltb3ZlcQlyMywgIzAKIAotCXN0cglyMywgW3IwLCAjMjA0OF0hCisgQVJNKAlzdHIJcjMsIFtyMCwgIzIwNDhdISApCisgVEhVTUIoCWFkZAlyMCwgcjAsICMyMDQ4ICkKKyBUSFVNQigJc3RyCXIzLCBbcjBdICkKIAltY3IJcDE1LCAwLCByMCwgYzcsIGMxMCwgMQkJQCBmbHVzaF9wdGUKICNlbmRpZgogCW1vdglwYywgbHIKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtbXhjLzNkc19kZWJ1Z2JvYXJkLmMgYi9hcmNoL2FybS9wbGF0LW14Yy8zZHNfZGVidWdib2FyZC5jCmluZGV4IDYzOWM1NGEuLmM4NTZmYTMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtbXhjLzNkc19kZWJ1Z2JvYXJkLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1teGMvM2RzX2RlYnVnYm9hcmQuYwpAQCAtNjAsNyArNjAsNiBAQAogI2RlZmluZSBFWFBJT19JTlRfQlVUVE9OX0IJKE1YQ19CT0FSRF9JUlFfU1RBUlQgKyA0KQogCiBzdGF0aWMgdm9pZCBfX2lvbWVtICpicmRfaW87Ci1zdGF0aWMgdm9pZCBleHBpb19hY2tfaXJxKHUzMiBpcnEpOwogCiBzdGF0aWMgc3RydWN0IHJlc291cmNlIHNtc2M5MTF4X3Jlc291cmNlc1tdID0gewogCXsKQEAgLTkzLDcgKzkyLDggQEAKIAl1MzIgaW50X3ZhbGlkOwogCXUzMiBleHBpb19pcnE7CiAKLQlkZXNjLT5jaGlwLT5tYXNrKGlycSk7CS8qIGlycSA9IGdwaW8gaXJxIG51bWJlciAqLworCS8qIGlycSA9IGdwaW8gaXJxIG51bWJlciAqLworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9tYXNrKCZkZXNjLT5pcnFfZGF0YSk7CiAKIAlpbXJfdmFsID0gX19yYXdfcmVhZHcoYnJkX2lvICsgSU5UUl9NQVNLX1JFRyk7CiAJaW50X3ZhbGlkID0gX19yYXdfcmVhZHcoYnJkX2lvICsgSU5UUl9TVEFUVVNfUkVHKSAmIH5pbXJfdmFsOwpAQCAtMTEwLDM3ICsxMTAsMzcgQEAKIAkJCWQtPmhhbmRsZV9pcnEoZXhwaW9faXJxLCBkKTsKIAl9CiAKLQlkZXNjLT5jaGlwLT5hY2soaXJxKTsKLQlkZXNjLT5jaGlwLT51bm1hc2soaXJxKTsKKwlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfYWNrKCZkZXNjLT5pcnFfZGF0YSk7CisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX3VubWFzaygmZGVzYy0+aXJxX2RhdGEpOwogfQogCiAvKgogICogRGlzYWJsZSBhbiBleHBpbyBwaW4ncyBpbnRlcnJ1cHQgYnkgc2V0dGluZyB0aGUgYml0IGluIHRoZSBpbXIuCiAgKiBJcnEgaXMgYW4gZXhwaW8gdmlydHVhbCBpcnEgbnVtYmVyCiAgKi8KLXN0YXRpYyB2b2lkIGV4cGlvX21hc2tfaXJxKHUzMiBpcnEpCitzdGF0aWMgdm9pZCBleHBpb19tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJdTE2IHJlZzsKLQl1MzIgZXhwaW8gPSBNWENfSVJRX1RPX0VYUElPKGlycSk7CisJdTMyIGV4cGlvID0gTVhDX0lSUV9UT19FWFBJTyhkLT5pcnEpOwogCiAJcmVnID0gX19yYXdfcmVhZHcoYnJkX2lvICsgSU5UUl9NQVNLX1JFRyk7CiAJcmVnIHw9ICgxIDw8IGV4cGlvKTsKIAlfX3Jhd193cml0ZXcocmVnLCBicmRfaW8gKyBJTlRSX01BU0tfUkVHKTsKIH0KIAotc3RhdGljIHZvaWQgZXhwaW9fYWNrX2lycSh1MzIgaXJxKQorc3RhdGljIHZvaWQgZXhwaW9fYWNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JdTMyIGV4cGlvID0gTVhDX0lSUV9UT19FWFBJTyhpcnEpOworCXUzMiBleHBpbyA9IE1YQ19JUlFfVE9fRVhQSU8oZC0+aXJxKTsKIAogCV9fcmF3X3dyaXRldygxIDw8IGV4cGlvLCBicmRfaW8gKyBJTlRSX1JFU0VUX1JFRyk7CiAJX19yYXdfd3JpdGV3KDAsIGJyZF9pbyArIElOVFJfUkVTRVRfUkVHKTsKLQlleHBpb19tYXNrX2lycShpcnEpOworCWV4cGlvX21hc2tfaXJxKGQpOwogfQogCi1zdGF0aWMgdm9pZCBleHBpb191bm1hc2tfaXJxKHUzMiBpcnEpCitzdGF0aWMgdm9pZCBleHBpb191bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl1MTYgcmVnOwotCXUzMiBleHBpbyA9IE1YQ19JUlFfVE9fRVhQSU8oaXJxKTsKKwl1MzIgZXhwaW8gPSBNWENfSVJRX1RPX0VYUElPKGQtPmlycSk7CiAKIAlyZWcgPSBfX3Jhd19yZWFkdyhicmRfaW8gKyBJTlRSX01BU0tfUkVHKTsKIAlyZWcgJj0gfigxIDw8IGV4cGlvKTsKQEAgLTE0OCw5ICsxNDgsOSBAQAogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGV4cGlvX2lycV9jaGlwID0gewotCS5hY2sgPSBleHBpb19hY2tfaXJxLAotCS5tYXNrID0gZXhwaW9fbWFza19pcnEsCi0JLnVubWFzayA9IGV4cGlvX3VubWFza19pcnEsCisJLmlycV9hY2sgPSBleHBpb19hY2tfaXJxLAorCS5pcnFfbWFzayA9IGV4cGlvX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrID0gZXhwaW9fdW5tYXNrX2lycSwKIH07CiAKIGludCBfX2luaXQgbXhjX2V4cGlvX2luaXQodTMyIGJhc2UsIHUzMiBwX2lycSkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtbXhjL2F2aWMuYyBiL2FyY2gvYXJtL3BsYXQtbXhjL2F2aWMuYwppbmRleCA5YTRlOGEyLi5kZWIyODRiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW14Yy9hdmljLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1teGMvYXZpYy5jCkBAIC04OSwyMiArODksMjIgQEAKICNlbmRpZiAvKiBDT05GSUdfRklRICovCiAKIC8qIERpc2FibGUgaW50ZXJydXB0IG51bWJlciAiaXJxIiBpbiB0aGUgQVZJQyAqLwotc3RhdGljIHZvaWQgbXhjX21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBteGNfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCV9fcmF3X3dyaXRlbChpcnEsIGF2aWNfYmFzZSArIEFWSUNfSU5URElTTlVNKTsKKwlfX3Jhd193cml0ZWwoZC0+aXJxLCBhdmljX2Jhc2UgKyBBVklDX0lOVERJU05VTSk7CiB9CiAKIC8qIEVuYWJsZSBpbnRlcnJ1cHQgbnVtYmVyICJpcnEiIGluIHRoZSBBVklDICovCi1zdGF0aWMgdm9pZCBteGNfdW5tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbXhjX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCV9fcmF3X3dyaXRlbChpcnEsIGF2aWNfYmFzZSArIEFWSUNfSU5URU5OVU0pOworCV9fcmF3X3dyaXRlbChkLT5pcnEsIGF2aWNfYmFzZSArIEFWSUNfSU5URU5OVU0pOwogfQogCiBzdGF0aWMgc3RydWN0IG14Y19pcnFfY2hpcCBteGNfYXZpY19jaGlwID0gewogCS5iYXNlID0gewotCQkuYWNrID0gbXhjX21hc2tfaXJxLAotCQkubWFzayA9IG14Y19tYXNrX2lycSwKLQkJLnVubWFzayA9IG14Y191bm1hc2tfaXJxLAorCQkuaXJxX2FjayA9IG14Y19tYXNrX2lycSwKKwkJLmlycV9tYXNrID0gbXhjX21hc2tfaXJxLAorCQkuaXJxX3VubWFzayA9IG14Y191bm1hc2tfaXJxLAogCX0sCiAjaWZkZWYgQ09ORklHX01YQ19JUlFfUFJJT1IKIAkuc2V0X3ByaW9yaXR5ID0gYXZpY19pcnFfc2V0X3ByaW9yaXR5LApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1teGMvZGV2aWNlcy9LY29uZmlnIGIvYXJjaC9hcm0vcGxhdC1teGMvZGV2aWNlcy9LY29uZmlnCmluZGV4IDI1MzcxNjYuLmI5YWIxZDUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtbXhjL2RldmljZXMvS2NvbmZpZworKysgYi9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL0tjb25maWcKQEAgLTEsNiArMSw2IEBACiBjb25maWcgSU1YX0hBVkVfUExBVEZPUk1fRkVDCiAJYm9vbAotCWRlZmF1bHQgeSBpZiBBUkNIX01YMjUgfHwgU09DX0lNWDI3IHx8IFNPQ19JTVgzNSB8fCBTT0NfSU1YNTEKKwlkZWZhdWx0IHkgaWYgQVJDSF9NWDI1IHx8IFNPQ19JTVgyNyB8fCBTT0NfSU1YMzUgfHwgU09DX0lNWDUxIHx8IFNPQ19JTVg1MwogCiBjb25maWcgSU1YX0hBVkVfUExBVEZPUk1fRkxFWENBTgogCXNlbGVjdCBIQVZFX0NBTl9GTEVYQ0FOIGlmIENBTgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1teGMvZGV2aWNlcy9wbGF0Zm9ybS1mZWMuYyBiL2FyY2gvYXJtL3BsYXQtbXhjL2RldmljZXMvcGxhdGZvcm0tZmVjLmMKaW5kZXggMjY5ZWM3OC4uYjUwYzM1MSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1teGMvZGV2aWNlcy9wbGF0Zm9ybS1mZWMuYworKysgYi9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL3BsYXRmb3JtLWZlYy5jCkBAIC0zNiw2ICszNiwxMSBAQAogCWlteF9mZWNfZGF0YV9lbnRyeV9zaW5nbGUoTVg1MSk7CiAjZW5kaWYKIAorI2lmZGVmIENPTkZJR19TT0NfSU1YNTMKK2NvbnN0IHN0cnVjdCBpbXhfZmVjX2RhdGEgaW14NTNfZmVjX2RhdGEgX19pbml0Y29uc3QgPQorCWlteF9mZWNfZGF0YV9lbnRyeV9zaW5nbGUoTVg1Myk7CisjZW5kaWYKKwogc3RydWN0IHBsYXRmb3JtX2RldmljZSAqX19pbml0IGlteF9hZGRfZmVjKAogCQljb25zdCBzdHJ1Y3QgaW14X2ZlY19kYXRhICpkYXRhLAogCQljb25zdCBzdHJ1Y3QgZmVjX3BsYXRmb3JtX2RhdGEgKnBkYXRhKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1teGMvZGV2aWNlcy9wbGF0Zm9ybS1pbXgtaTJjLmMgYi9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL3BsYXRmb3JtLWlteC1pMmMuYwppbmRleCA3MmJhODgwLi43YmE5NGUxIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL3BsYXRmb3JtLWlteC1pMmMuYworKysgYi9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL3BsYXRmb3JtLWlteC1pMmMuYwpAQCAtNzgsNiArNzgsMTUgQEAKIH07CiAjZW5kaWYgLyogaWZkZWYgQ09ORklHX1NPQ19JTVg1MSAqLwogCisjaWZkZWYgQ09ORklHX1NPQ19JTVg1MworY29uc3Qgc3RydWN0IGlteF9pbXhfaTJjX2RhdGEgaW14NTNfaW14X2kyY19kYXRhW10gX19pbml0Y29uc3QgPSB7CisjZGVmaW5lIGlteDUzX2lteF9pMmNfZGF0YV9lbnRyeShfaWQsIF9od2lkKQkJCQlcCisJaW14X2lteF9pMmNfZGF0YV9lbnRyeShNWDUzLCBfaWQsIF9od2lkLCBTWl80SykKKwlpbXg1M19pbXhfaTJjX2RhdGFfZW50cnkoMCwgMSksCisJaW14NTNfaW14X2kyY19kYXRhX2VudHJ5KDEsIDIpLAorfTsKKyNlbmRpZiAvKiBpZmRlZiBDT05GSUdfU09DX0lNWDUxICovCisKIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKl9faW5pdCBpbXhfYWRkX2lteF9pMmMoCiAJCWNvbnN0IHN0cnVjdCBpbXhfaW14X2kyY19kYXRhICpkYXRhLAogCQljb25zdCBzdHJ1Y3QgaW14aTJjX3BsYXRmb3JtX2RhdGEgKnBkYXRhKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1teGMvZGV2aWNlcy9wbGF0Zm9ybS1pbXgta2V5cGFkLmMgYi9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL3BsYXRmb3JtLWlteC1rZXlwYWQuYwppbmRleCA0MDIzOGYwLi4yNjM2NjExIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL3BsYXRmb3JtLWlteC1rZXlwYWQuYworKysgYi9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL3BsYXRmb3JtLWlteC1rZXlwYWQuYwpAQCAtNDEsNiArNDEsMTEgQEAKIAlpbXhfaW14X2tleXBhZF9kYXRhX2VudHJ5X3NpbmdsZShNWDM1LCBTWl8xNik7CiAjZW5kaWYgLyogaWZkZWYgQ09ORklHX1NPQ19JTVgzNSAqLwogCisjaWZkZWYgQ09ORklHX1NPQ19JTVg1MQorY29uc3Qgc3RydWN0IGlteF9pbXhfa2V5cGFkX2RhdGEgaW14NTFfaW14X2tleXBhZF9kYXRhIF9faW5pdGNvbnN0ID0KKwlpbXhfaW14X2tleXBhZF9kYXRhX2VudHJ5X3NpbmdsZShNWDUxLCBTWl8xNik7CisjZW5kaWYgLyogaWZkZWYgQ09ORklHX1NPQ19JTVg1MSAqLworCiBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpfX2luaXQgaW14X2FkZF9pbXhfa2V5cGFkKAogCQljb25zdCBzdHJ1Y3QgaW14X2lteF9rZXlwYWRfZGF0YSAqZGF0YSwKIAkJY29uc3Qgc3RydWN0IG1hdHJpeF9rZXltYXBfZGF0YSAqcGRhdGEpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL3BsYXRmb3JtLW14Y19wd20uYyBiL2FyY2gvYXJtL3BsYXQtbXhjL2RldmljZXMvcGxhdGZvcm0tbXhjX3B3bS5jCmluZGV4IDNkOGViZGIuLmIwYzRhZTIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtbXhjL2RldmljZXMvcGxhdGZvcm0tbXhjX3B3bS5jCisrKyBiL2FyY2gvYXJtL3BsYXQtbXhjL2RldmljZXMvcGxhdGZvcm0tbXhjX3B3bS5jCkBAIC00MCw2ICs0MCwxNSBAQAogCWlteF9teGNfcHdtX2RhdGFfZW50cnlfc2luZ2xlKE1YMjcsIDAsICwgU1pfNEspOwogI2VuZGlmIC8qIGlmZGVmIENPTkZJR19TT0NfSU1YMjcgKi8KIAorI2lmZGVmIENPTkZJR19TT0NfSU1YNTEKK2NvbnN0IHN0cnVjdCBpbXhfbXhjX3B3bV9kYXRhIGlteDUxX214Y19wd21fZGF0YVtdIF9faW5pdGNvbnN0ID0geworI2RlZmluZSBpbXg1MV9teGNfcHdtX2RhdGFfZW50cnkoX2lkLCBfaHdpZCkJCQkJXAorCWlteF9teGNfcHdtX2RhdGFfZW50cnkoTVg1MSwgX2lkLCBfaHdpZCwgU1pfMTZLKQorCWlteDUxX214Y19wd21fZGF0YV9lbnRyeSgwLCAxKSwKKwlpbXg1MV9teGNfcHdtX2RhdGFfZW50cnkoMSwgMiksCit9OworI2VuZGlmIC8qIGlmZGVmIENPTkZJR19TT0NfSU1YNTEgKi8KKwogc3RydWN0IHBsYXRmb3JtX2RldmljZSAqX19pbml0IGlteF9hZGRfbXhjX3B3bSgKIAkJY29uc3Qgc3RydWN0IGlteF9teGNfcHdtX2RhdGEgKmRhdGEpCiB7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL3BsYXRmb3JtLXNkaGNpLWVzZGhjLWlteC5jIGIvYXJjaC9hcm0vcGxhdC1teGMvZGV2aWNlcy9wbGF0Zm9ybS1zZGhjaS1lc2RoYy1pbXguYwppbmRleCBiMzUyNTY0Li42YjI5NDBiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL3BsYXRmb3JtLXNkaGNpLWVzZGhjLWlteC5jCisrKyBiL2FyY2gvYXJtL3BsYXQtbXhjL2RldmljZXMvcGxhdGZvcm0tc2RoY2ktZXNkaGMtaW14LmMKQEAgLTUzLDYgKzUzLDE4IEBACiB9OwogI2VuZGlmIC8qIGlmZGVmIENPTkZJR19TT0NfSU1YNTEgKi8KIAorI2lmZGVmIENPTkZJR19TT0NfSU1YNTMKK2NvbnN0IHN0cnVjdCBpbXhfc2RoY2lfZXNkaGNfaW14X2RhdGEKK2lteDUzX3NkaGNpX2VzZGhjX2lteF9kYXRhW10gX19pbml0Y29uc3QgPSB7CisjZGVmaW5lIGlteDUzX3NkaGNpX2VzZGhjX2lteF9kYXRhX2VudHJ5KF9pZCwgX2h3aWQpCQkJXAorCWlteF9zZGhjaV9lc2RoY19pbXhfZGF0YV9lbnRyeShNWDUzLCBfaWQsIF9od2lkKQorCWlteDUzX3NkaGNpX2VzZGhjX2lteF9kYXRhX2VudHJ5KDAsIDEpLAorCWlteDUzX3NkaGNpX2VzZGhjX2lteF9kYXRhX2VudHJ5KDEsIDIpLAorCWlteDUzX3NkaGNpX2VzZGhjX2lteF9kYXRhX2VudHJ5KDIsIDMpLAorCWlteDUzX3NkaGNpX2VzZGhjX2lteF9kYXRhX2VudHJ5KDMsIDQpLAorfTsKKyNlbmRpZiAvKiBpZmRlZiBDT05GSUdfU09DX0lNWDUzICovCisKIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKl9faW5pdCBpbXhfYWRkX3NkaGNpX2VzZGhjX2lteCgKIAkJY29uc3Qgc3RydWN0IGlteF9zZGhjaV9lc2RoY19pbXhfZGF0YSAqZGF0YSwKIAkJY29uc3Qgc3RydWN0IGVzZGhjX3BsYXRmb3JtX2RhdGEgKnBkYXRhKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1teGMvZGV2aWNlcy9wbGF0Zm9ybS1zcGlfaW14LmMgYi9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL3BsYXRmb3JtLXNwaV9pbXguYwppbmRleCA4ZWE0OWFkLi4wMTNjODVmIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL3BsYXRmb3JtLXNwaV9pbXguYworKysgYi9hcmNoL2FybS9wbGF0LW14Yy9kZXZpY2VzL3BsYXRmb3JtLXNwaV9pbXguYwpAQCAtODEsNiArODEsMTggQEAKIH07CiAjZW5kaWYgLyogaWZkZWYgQ09ORklHX1NPQ19JTVg1MSAqLwogCisjaWZkZWYgQ09ORklHX1NPQ19JTVg1MworY29uc3Qgc3RydWN0IGlteF9zcGlfaW14X2RhdGEgaW14NTNfY3NwaV9kYXRhIF9faW5pdGNvbnN0ID0KKwlpbXhfc3BpX2lteF9kYXRhX2VudHJ5X3NpbmdsZShNWDUzLCBDU1BJLCAiaW14NTMtY3NwaSIsIDAsICwgU1pfNEspOworCitjb25zdCBzdHJ1Y3QgaW14X3NwaV9pbXhfZGF0YSBpbXg1M19lY3NwaV9kYXRhW10gX19pbml0Y29uc3QgPSB7CisjZGVmaW5lIGlteDUzX2Vjc3BpX2RhdGFfZW50cnkoX2lkLCBfaHdpZCkJCQkJXAorCWlteF9zcGlfaW14X2RhdGFfZW50cnkoTVg1MywgRUNTUEksICJpbXg1My1lY3NwaSIsIF9pZCwgX2h3aWQsIFNaXzRLKQorCWlteDUzX2Vjc3BpX2RhdGFfZW50cnkoMCwgMSksCisJaW14NTNfZWNzcGlfZGF0YV9lbnRyeSgxLCAyKSwKK307CisjZW5kaWYgLyogaWZkZWYgQ09ORklHX1NPQ19JTVg1MyAqLworCiBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpfX2luaXQgaW14X2FkZF9zcGlfaW14KAogCQljb25zdCBzdHJ1Y3QgaW14X3NwaV9pbXhfZGF0YSAqZGF0YSwKIAkJY29uc3Qgc3RydWN0IHNwaV9pbXhfbWFzdGVyICpwZGF0YSkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtbXhjL2dwaW8uYyBiL2FyY2gvYXJtL3BsYXQtbXhjL2dwaW8uYwppbmRleCBiYzJjN2JjLi5kMTdiM2M5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW14Yy9ncGlvLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1teGMvZ3Bpby5jCkBAIC02MywyOSArNjMsMjkgQEAKIAlfX3Jhd193cml0ZWwobCwgcG9ydC0+YmFzZSArIEdQSU9fSU1SKTsKIH0KIAotc3RhdGljIHZvaWQgZ3Bpb19hY2tfaXJxKHUzMiBpcnEpCitzdGF0aWMgdm9pZCBncGlvX2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXUzMiBncGlvID0gaXJxX3RvX2dwaW8oaXJxKTsKKwl1MzIgZ3BpbyA9IGlycV90b19ncGlvKGQtPmlycSk7CiAJX2NsZWFyX2dwaW9faXJxc3RhdHVzKCZteGNfZ3Bpb19wb3J0c1tncGlvIC8gMzJdLCBncGlvICYgMHgxZik7CiB9CiAKLXN0YXRpYyB2b2lkIGdwaW9fbWFza19pcnEodTMyIGlycSkKK3N0YXRpYyB2b2lkIGdwaW9fbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXUzMiBncGlvID0gaXJxX3RvX2dwaW8oaXJxKTsKKwl1MzIgZ3BpbyA9IGlycV90b19ncGlvKGQtPmlycSk7CiAJX3NldF9ncGlvX2lycWVuYWJsZSgmbXhjX2dwaW9fcG9ydHNbZ3BpbyAvIDMyXSwgZ3BpbyAmIDB4MWYsIDApOwogfQogCi1zdGF0aWMgdm9pZCBncGlvX3VubWFza19pcnEodTMyIGlycSkKK3N0YXRpYyB2b2lkIGdwaW9fdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JdTMyIGdwaW8gPSBpcnFfdG9fZ3BpbyhpcnEpOworCXUzMiBncGlvID0gaXJxX3RvX2dwaW8oZC0+aXJxKTsKIAlfc2V0X2dwaW9faXJxZW5hYmxlKCZteGNfZ3Bpb19wb3J0c1tncGlvIC8gMzJdLCBncGlvICYgMHgxZiwgMSk7CiB9CiAKIHN0YXRpYyBpbnQgbXhjX2dwaW9fZ2V0KHN0cnVjdCBncGlvX2NoaXAgKmNoaXAsIHVuc2lnbmVkIG9mZnNldCk7CiAKLXN0YXRpYyBpbnQgZ3Bpb19zZXRfaXJxX3R5cGUodTMyIGlycSwgdTMyIHR5cGUpCitzdGF0aWMgaW50IGdwaW9fc2V0X2lycV90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdTMyIHR5cGUpCiB7Ci0JdTMyIGdwaW8gPSBpcnFfdG9fZ3BpbyhpcnEpOworCXUzMiBncGlvID0gaXJxX3RvX2dwaW8oZC0+aXJxKTsKIAlzdHJ1Y3QgbXhjX2dwaW9fcG9ydCAqcG9ydCA9ICZteGNfZ3Bpb19wb3J0c1tncGlvIC8gMzJdOwogCXUzMiBiaXQsIHZhbDsKIAlpbnQgZWRnZTsKQEAgLTIxMSw5ICsyMTEsOSBAQAogICogQHBhcmFtICBlbmFibGUgICAgICAgZW5hYmxlIGFzIHdha2UtdXAgaWYgZXF1YWwgdG8gbm9uLXplcm8KICAqIEByZXR1cm4gICAgICAgVGhpcyBmdW5jdGlvbiByZXR1cm5zIDAgb24gc3VjY2Vzcy4KICAqLwotc3RhdGljIGludCBncGlvX3NldF93YWtlX2lycSh1MzIgaXJxLCB1MzIgZW5hYmxlKQorc3RhdGljIGludCBncGlvX3NldF93YWtlX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHUzMiBlbmFibGUpCiB7Ci0JdTMyIGdwaW8gPSBpcnFfdG9fZ3BpbyhpcnEpOworCXUzMiBncGlvID0gaXJxX3RvX2dwaW8oZC0+aXJxKTsKIAl1MzIgZ3Bpb19pZHggPSBncGlvICYgMHgxRjsKIAlzdHJ1Y3QgbXhjX2dwaW9fcG9ydCAqcG9ydCA9ICZteGNfZ3Bpb19wb3J0c1tncGlvIC8gMzJdOwogCkBAIC0yMzMsMTEgKzIzMywxMSBAQAogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGdwaW9faXJxX2NoaXAgPSB7Ci0JLmFjayA9IGdwaW9fYWNrX2lycSwKLQkubWFzayA9IGdwaW9fbWFza19pcnEsCi0JLnVubWFzayA9IGdwaW9fdW5tYXNrX2lycSwKLQkuc2V0X3R5cGUgPSBncGlvX3NldF9pcnFfdHlwZSwKLQkuc2V0X3dha2UgPSBncGlvX3NldF93YWtlX2lycSwKKwkuaXJxX2FjayA9IGdwaW9fYWNrX2lycSwKKwkuaXJxX21hc2sgPSBncGlvX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrID0gZ3Bpb191bm1hc2tfaXJxLAorCS5pcnFfc2V0X3R5cGUgPSBncGlvX3NldF9pcnFfdHlwZSwKKwkuaXJxX3NldF93YWtlID0gZ3Bpb19zZXRfd2FrZV9pcnEsCiB9OwogCiBzdGF0aWMgdm9pZCBfc2V0X2dwaW9fZGlyZWN0aW9uKHN0cnVjdCBncGlvX2NoaXAgKmNoaXAsIHVuc2lnbmVkIG9mZnNldCwKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtbXhjL2luY2x1ZGUvbWFjaC9pb211eC1teDUzLmggYi9hcmNoL2FybS9wbGF0LW14Yy9pbmNsdWRlL21hY2gvaW9tdXgtbXg1My5oCmluZGV4IDVkZWVlMDEuLjY4ZTExZDcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtbXhjL2luY2x1ZGUvbWFjaC9pb211eC1teDUzLmgKKysrIGIvYXJjaC9hcm0vcGxhdC1teGMvaW5jbHVkZS9tYWNoL2lvbXV4LW14NTMuaApAQCAtMzQsNyArMzQsNiBAQAogCUlPTVVYX0NPTkZJR19BTFQ2LAogCUlPTVVYX0NPTkZJR19BTFQ3LAogCUlPTVVYX0NPTkZJR19HUElPLCAvKiBhZGRlZCB0byBoZWxwIHVzZXIgdXNlIEdQSU8gbW9kZSAqLwotCUlPTVVYX0NPTkZJR19TSU9OID0gMHgxIDw8IDQsIC8qIExPT1BCQUNLOk1VWCBTSU9OIGJpdCAqLwogfSBpb211eF9waW5fY2ZnX3Q7CiAKIC8qIFRoZXNlIDIgZGVmaW5lcyBhcmUgZm9yIHBpbnMgdGhhdCBtYXkgbm90IGhhdmUgYSBtdXggcmVnaXN0ZXIsIGJ1dCBjb3VsZApAQCAtMTM1LDYgKzEzNCw5IEBACiAjZGVmaW5lIE1YNTNfUEFEX0VJTV9EMTZfX0dQSU9fM18xNgkJSU9NVVhfUEFEKDB4NDYwLCAweDExOCxJT01VWF9DT05GSUdfQUxUMSwgMHgwLCAwLCBOT19QQURfQ1RSTCkKICNkZWZpbmUgTVg1M19QQURfRUlNX0QxN19fR1BJT18zXzE3CQlJT01VWF9QQUQoMHg0NjQsIDB4MTFDLElPTVVYX0NPTkZJR19BTFQxLCAweDAsIDAsIE5PX1BBRF9DVFJMKQogI2RlZmluZSBNWDUzX1BBRF9FSU1fRDE4X19HUElPXzNfMTgJCUlPTVVYX1BBRCgweDQ2OCwgMHgxMjAsSU9NVVhfQ09ORklHX0FMVDEsIDB4MCwgMCwgTk9fUEFEX0NUUkwpCisjZGVmaW5lIE1YNTNfUEFEX0VJTV9EMTZfX0NTUEkxX1NDTEsJCUlPTVVYX1BBRCgweDQ2MCwgMHgxMTgsSU9NVVhfQ09ORklHX0FMVDQsIDB4NzljLCAzLCBOT19QQURfQ1RSTCkKKyNkZWZpbmUgTVg1M19QQURfRUlNX0QxN19fQ1NQSTFfTUlTTwkJSU9NVVhfUEFEKDB4NDY0LCAweDExQyxJT01VWF9DT05GSUdfQUxUNCwgMHg3YTAsIDMsIE5PX1BBRF9DVFJMKQorI2RlZmluZSBNWDUzX1BBRF9FSU1fRDE4X19DU1BJMV9NT1NJCQlJT01VWF9QQUQoMHg0NjgsIDB4MTIwLElPTVVYX0NPTkZJR19BTFQ0LCAweDdhNCwgMywgTk9fUEFEX0NUUkwpCiAjZGVmaW5lIE1YNTNfUEFEX0VJTV9EMTlfX0dQSU9fM18xOQkJSU9NVVhfUEFEKDB4NDZDLCAweDEyNCxJT01VWF9DT05GSUdfQUxUMSwgMHgwLCAwLCBOT19QQURfQ1RSTCkKICNkZWZpbmUgTVg1M19QQURfRUlNX0QyMF9fR1BJT18zXzIwCQlJT01VWF9QQUQoMHg0NzAsIDB4MTI4LElPTVVYX0NPTkZJR19BTFQxLCAweDAsIDAsIE5PX1BBRF9DVFJMKQogI2RlZmluZSBNWDUzX1BBRF9FSU1fRDIxX19HUElPXzNfMjEJCUlPTVVYX1BBRCgweDQ3NCwgMHgxMkMsSU9NVVhfQ09ORklHX0FMVDEsIDB4MCwgMCwgTk9fUEFEX0NUUkwpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LW14Yy9pbmNsdWRlL21hY2gvaW9tdXgtdjMuaCBiL2FyY2gvYXJtL3BsYXQtbXhjL2luY2x1ZGUvbWFjaC9pb211eC12My5oCmluZGV4IDIyNzdiMDEuLjgyNjIwYWYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtbXhjL2luY2x1ZGUvbWFjaC9pb211eC12My5oCisrKyBiL2FyY2gvYXJtL3BsYXQtbXhjL2luY2x1ZGUvbWFjaC9pb211eC12My5oCkBAIC0xMDUsNiArMTA1LDcgQEAKICNkZWZpbmUgUEFEX0NUTF9TUkVfRkFTVAkJKDEgPDwgMCkKICNkZWZpbmUgUEFEX0NUTF9TUkVfU0xPVwkJKDAgPDwgMCkKIAorI2RlZmluZSBJT01VWF9DT05GSUdfU0lPTgkJKDB4MSA8PCA0KQogCiAjZGVmaW5lIE1YNTFfTlVNX0dQSU9fUE9SVAk0CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtbXhjL2luY2x1ZGUvbWFjaC9teDUxLmggYi9hcmNoL2FybS9wbGF0LW14Yy9pbmNsdWRlL21hY2gvbXg1MS5oCmluZGV4IDg3MzgwN2YuLjFlYjMzOWUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtbXhjL2luY2x1ZGUvbWFjaC9teDUxLmgKKysrIGIvYXJjaC9hcm0vcGxhdC1teGMvaW5jbHVkZS9tYWNoL214NTEuaApAQCAtMzAxLDggKzMwMSw4IEBACiAjZGVmaW5lIE1YNTFfTVhDX0lOVF9HUElPNF9ISUdICQk1NwogI2RlZmluZSBNWDUxX01YQ19JTlRfV0RPRzEJCTU4CiAjZGVmaW5lIE1YNTFfTVhDX0lOVF9XRE9HMgkJNTkKLSNkZWZpbmUgTVg1MV9NWENfSU5UX0tQUAkJNjAKLSNkZWZpbmUgTVg1MV9NWENfSU5UX1BXTTEJCTYxCisjZGVmaW5lIE1YNTFfSU5UX0tQUAkJCTYwCisjZGVmaW5lIE1YNTFfSU5UX1BXTTEJCQk2MQogI2RlZmluZSBNWDUxX0lOVF9JMkMxCQkJNjIKICNkZWZpbmUgTVg1MV9JTlRfSTJDMgkJCTYzCiAjZGVmaW5lIE1YNTFfTVhDX0lOVF9IU19JMkMJCTY0CkBAIC0zMzUsNyArMzM1LDcgQEAKICNkZWZpbmUgTVg1MV9NWENfSU5UX1NQRElGCQk5MQogI2RlZmluZSBNWDUxX01YQ19JTlRfVFZFCQk5MgogI2RlZmluZSBNWDUxX01YQ19JTlRfRklSSQkJOTMKLSNkZWZpbmUgTVg1MV9NWENfSU5UX1BXTTIJCTk0CisjZGVmaW5lIE1YNTFfSU5UX1BXTTIJCQk5NAogI2RlZmluZSBNWDUxX01YQ19JTlRfU0xJTV9FWFAJCTk1CiAjZGVmaW5lIE1YNTFfSU5UX1NTSTMJCQk5NgogI2RlZmluZSBNWDUxX01YQ19JTlRfRU1JX0JPT1QJCTk3CmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LW14Yy9pbmNsdWRlL21hY2gvbXg1My5oIGIvYXJjaC9hcm0vcGxhdC1teGMvaW5jbHVkZS9tYWNoL214NTMuaAppbmRleCA5NTc3Y2RiLi5kN2E4ZTUyIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW14Yy9pbmNsdWRlL21hY2gvbXg1My5oCisrKyBiL2FyY2gvYXJtL3BsYXQtbXhjL2luY2x1ZGUvbWFjaC9teDUzLmgKQEAgLTUzLDEzICs1MywxMyBAQAogI2RlZmluZSBNWDUzX1NQQkEwX0JBU0VfQUREUgkJMHg1MDAwMDAwMAogI2RlZmluZSBNWDUzX1NQQkEwX1NJWkUJCVNaXzFNCiAKLSNkZWZpbmUgTVg1M19NTUNfU0RIQzFfQkFTRV9BRERSCShNWDUzX1NQQkEwX0JBU0VfQUREUiArIDB4MDAwMDQwMDApCi0jZGVmaW5lIE1YNTNfTU1DX1NESEMyX0JBU0VfQUREUgkoTVg1M19TUEJBMF9CQVNFX0FERFIgKyAweDAwMDA4MDAwKQorI2RlZmluZSBNWDUzX0VTREhDMV9CQVNFX0FERFIJKE1YNTNfU1BCQTBfQkFTRV9BRERSICsgMHgwMDAwNDAwMCkKKyNkZWZpbmUgTVg1M19FU0RIQzJfQkFTRV9BRERSCShNWDUzX1NQQkEwX0JBU0VfQUREUiArIDB4MDAwMDgwMDApCiAjZGVmaW5lIE1YNTNfVUFSVDNfQkFTRV9BRERSCQkoTVg1M19TUEJBMF9CQVNFX0FERFIgKyAweDAwMDBDMDAwKQotI2RlZmluZSBNWDUzX0NTUEkxX0JBU0VfQUREUgkJKE1YNTNfU1BCQTBfQkFTRV9BRERSICsgMHgwMDAxMDAwMCkKKyNkZWZpbmUgTVg1M19FQ1NQSTFfQkFTRV9BRERSCQkoTVg1M19TUEJBMF9CQVNFX0FERFIgKyAweDAwMDEwMDAwKQogI2RlZmluZSBNWDUzX1NTSTJfQkFTRV9BRERSCQkoTVg1M19TUEJBMF9CQVNFX0FERFIgKyAweDAwMDE0MDAwKQotI2RlZmluZSBNWDUzX01NQ19TREhDM19CQVNFX0FERFIJKE1YNTNfU1BCQTBfQkFTRV9BRERSICsgMHgwMDAyMDAwMCkKLSNkZWZpbmUgTVg1M19NTUNfU0RIQzRfQkFTRV9BRERSCShNWDUzX1NQQkEwX0JBU0VfQUREUiArIDB4MDAwMjQwMDApCisjZGVmaW5lIE1YNTNfRVNESEMzX0JBU0VfQUREUgkoTVg1M19TUEJBMF9CQVNFX0FERFIgKyAweDAwMDIwMDAwKQorI2RlZmluZSBNWDUzX0VTREhDNF9CQVNFX0FERFIJKE1YNTNfU1BCQTBfQkFTRV9BRERSICsgMHgwMDAyNDAwMCkKICNkZWZpbmUgTVg1M19TUERJRl9CQVNFX0FERFIJCShNWDUzX1NQQkEwX0JBU0VfQUREUiArIDB4MDAwMjgwMDApCiAjZGVmaW5lIE1YNTNfQVNSQ19CQVNFX0FERFIJCShNWDUzX1NQQkEwX0JBU0VfQUREUiArIDB4MDAwMkMwMDApCiAjZGVmaW5lIE1YNTNfQVRBX0RNQV9CQVNFX0FERFIJKE1YNTNfU1BCQTBfQkFTRV9BRERSICsgMHgwMDAzMDAwMCkKQEAgLTExNywxMiArMTE3LDEyIEBACiAjZGVmaW5lIE1YNTNfQVJNX0JBU0VfQUREUgkoTVg1M19BSVBTMl9CQVNFX0FERFIgKyAweDAwMEEwMDAwKQogI2RlZmluZSBNWDUzX09XSVJFX0JBU0VfQUREUgkoTVg1M19BSVBTMl9CQVNFX0FERFIgKyAweDAwMEE0MDAwKQogI2RlZmluZSBNWDUzX0ZJUklfQkFTRV9BRERSCShNWDUzX0FJUFMyX0JBU0VfQUREUiArIDB4MDAwQTgwMDApCi0jZGVmaW5lIE1YNTNfQ1NQSTJfQkFTRV9BRERSCShNWDUzX0FJUFMyX0JBU0VfQUREUiArIDB4MDAwQUMwMDApCisjZGVmaW5lIE1YNTNfRUNTUEkyX0JBU0VfQUREUgkoTVg1M19BSVBTMl9CQVNFX0FERFIgKyAweDAwMEFDMDAwKQogI2RlZmluZSBNWDUzX1NETUFfQkFTRV9BRERSCShNWDUzX0FJUFMyX0JBU0VfQUREUiArIDB4MDAwQjAwMDApCiAjZGVmaW5lIE1YNTNfU0NDX0JBU0VfQUREUgkoTVg1M19BSVBTMl9CQVNFX0FERFIgKyAweDAwMEI0MDAwKQogI2RlZmluZSBNWDUzX1JPTUNQX0JBU0VfQUREUgkoTVg1M19BSVBTMl9CQVNFX0FERFIgKyAweDAwMEI4MDAwKQogI2RlZmluZSBNWDUzX1JUSUNfQkFTRV9BRERSCShNWDUzX0FJUFMyX0JBU0VfQUREUiArIDB4MDAwQkMwMDApCi0jZGVmaW5lIE1YNTNfQ1NQSTNfQkFTRV9BRERSCShNWDUzX0FJUFMyX0JBU0VfQUREUiArIDB4MDAwQzAwMDApCisjZGVmaW5lIE1YNTNfQ1NQSV9CQVNFX0FERFIJKE1YNTNfQUlQUzJfQkFTRV9BRERSICsgMHgwMDBDMDAwMCkKICNkZWZpbmUgTVg1M19JMkMyX0JBU0VfQUREUgkoTVg1M19BSVBTMl9CQVNFX0FERFIgKyAweDAwMEM0MDAwKQogI2RlZmluZSBNWDUzX0kyQzFfQkFTRV9BRERSCShNWDUzX0FJUFMyX0JBU0VfQUREUiArIDB4MDAwQzgwMDApCiAjZGVmaW5lIE1YNTNfU1NJMV9CQVNFX0FERFIJKE1YNTNfQUlQUzJfQkFTRV9BRERSICsgMHgwMDBDQzAwMCkKQEAgLTEzNiw3ICsxMzYsNyBAQAogI2RlZmluZSBNWDUzX01JUElfSFNDX0JBU0VfQUREUgkoTVg1M19BSVBTMl9CQVNFX0FERFIgKyAweDAwMERDMDAwKQogI2RlZmluZSBNWDUzX01MQl9CQVNFX0FERFIJKE1YNTNfQUlQUzJfQkFTRV9BRERSICsgMHgwMDBFNDAwMCkKICNkZWZpbmUgTVg1M19TU0kzX0JBU0VfQUREUgkoTVg1M19BSVBTMl9CQVNFX0FERFIgKyAweDAwMEU4MDAwKQotI2RlZmluZSBNWDUzX01YQ19GRUNfQkFTRV9BRERSCShNWDUzX0FJUFMyX0JBU0VfQUREUiArIDB4MDAwRUMwMDApCisjZGVmaW5lIE1YNTNfRkVDX0JBU0VfQUREUgkoTVg1M19BSVBTMl9CQVNFX0FERFIgKyAweDAwMEVDMDAwKQogI2RlZmluZSBNWDUzX1RWRV9CQVNFX0FERFIJKE1YNTNfQUlQUzJfQkFTRV9BRERSICsgMHgwMDBGMDAwMCkKICNkZWZpbmUgTVg1M19WUFVfQkFTRV9BRERSCShNWDUzX0FJUFMyX0JBU0VfQUREUiArIDB4MDAwRjQwMDApCiAjZGVmaW5lIE1YNTNfU0FIQVJBX0JBU0VfQUREUgkoTVg1M19BSVBTMl9CQVNFX0FERFIgKyAweDAwMEY4MDAwKQpAQCAtMjI5LDEwICsyMjksMTAgQEAKICAqIEludGVycnVwdCBudW1iZXJzCiAgKi8KICNkZWZpbmUgTVg1M19JTlRfUkVTVjAJCTAKLSNkZWZpbmUgTVg1M19JTlRfTU1DX1NESEMxCTEKLSNkZWZpbmUgTVg1M19JTlRfTU1DX1NESEMyCTIKLSNkZWZpbmUgTVg1M19JTlRfTU1DX1NESEMzCTMKLSNkZWZpbmUgTVg1M19JTlRfTU1DX1NESEM0CTQKKyNkZWZpbmUgTVg1M19JTlRfRVNESEMxCTEKKyNkZWZpbmUgTVg1M19JTlRfRVNESEMyCTIKKyNkZWZpbmUgTVg1M19JTlRfRVNESEMzCTMKKyNkZWZpbmUgTVg1M19JTlRfRVNESEM0CTQKICNkZWZpbmUgTVg1M19JTlRfUkVTVjUJNQogI2RlZmluZSBNWDUzX0lOVF9TRE1BCTYKICNkZWZpbmUgTVg1M19JTlRfSU9NVVgJNwpAQCAtMjY0LDggKzI2NCw4IEBACiAjZGVmaW5lIE1YNTNfSU5UX1VBUlQzCTMzCiAjZGVmaW5lIE1YNTNfSU5UX1JFU1YzNAkzNAogI2RlZmluZSBNWDUzX0lOVF9SRVNWMzUJMzUKLSNkZWZpbmUgTVg1M19JTlRfQ1NQSTEJMzYKLSNkZWZpbmUgTVg1M19JTlRfQ1NQSTIJMzcKKyNkZWZpbmUgTVg1M19JTlRfRUNTUEkxCTM2CisjZGVmaW5lIE1YNTNfSU5UX0VDU1BJMgkzNwogI2RlZmluZSBNWDUzX0lOVF9DU1BJCTM4CiAjZGVmaW5lIE1YNTNfSU5UX0dQVAkzOQogI2RlZmluZSBNWDUzX0lOVF9FUElUMQk0MApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1teGMvaW5jbHVkZS9tYWNoL3VuY29tcHJlc3MuaCBiL2FyY2gvYXJtL3BsYXQtbXhjL2luY2x1ZGUvbWFjaC91bmNvbXByZXNzLmgKaW5kZXggM2E3MGViZi4uZmY0NjljNCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1teGMvaW5jbHVkZS9tYWNoL3VuY29tcHJlc3MuaAorKysgYi9hcmNoL2FybS9wbGF0LW14Yy9pbmNsdWRlL21hY2gvdW5jb21wcmVzcy5oCkBAIC05NSw2ICs5NSw3IEBACiAJY2FzZSBNQUNIX1RZUEVfTVgzNV8zRFM6CiAJY2FzZSBNQUNIX1RZUEVfUENNMDQzOgogCWNhc2UgTUFDSF9UWVBFX0xJTExZMTEzMToKKwljYXNlIE1BQ0hfVFlQRV9WUFIyMDA6CiAJCXVhcnRfYmFzZSA9IE1YM1hfVUFSVDFfQkFTRV9BRERSOwogCQlicmVhazsKIAljYXNlIE1BQ0hfVFlQRV9NQUdYX1pONToKQEAgLTEwMiw2ICsxMDMsNyBAQAogCQlicmVhazsKIAljYXNlIE1BQ0hfVFlQRV9NWDUxX0JBQkJBR0U6CiAJY2FzZSBNQUNIX1RZUEVfRVVLUkVBX0NQVUlNWDUxU0Q6CisJY2FzZSBNQUNIX1RZUEVfTVg1MV8zRFM6CiAJCXVhcnRfYmFzZSA9IE1YNTFfVUFSVDFfQkFTRV9BRERSOwogCQlicmVhazsKIAljYXNlIE1BQ0hfVFlQRV9NWDUwX1JEUDoKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtbXhjL3B3bS5jIGIvYXJjaC9hcm0vcGxhdC1teGMvcHdtLmMKaW5kZXggYzM2ZjI2My4uN2E2MWVmOCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1teGMvcHdtLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1teGMvcHdtLmMKQEAgLTU3LDcgKzU3LDcgQEAKIAlpZiAocHdtID09IE5VTEwgfHwgcGVyaW9kX25zID09IDAgfHwgZHV0eV9ucyA+IHBlcmlvZF9ucykKIAkJcmV0dXJuIC1FSU5WQUw7CiAKLQlpZiAoY3B1X2lzX214MjcoKSB8fCBjcHVfaXNfbXgzKCkgfHwgY3B1X2lzX214MjUoKSkgeworCWlmIChjcHVfaXNfbXgyNygpIHx8IGNwdV9pc19teDMoKSB8fCBjcHVfaXNfbXgyNSgpIHx8IGNwdV9pc19teDUxKCkpIHsKIAkJdW5zaWduZWQgbG9uZyBsb25nIGM7CiAJCXVuc2lnbmVkIGxvbmcgcGVyaW9kX2N5Y2xlcywgZHV0eV9jeWNsZXMsIHByZXNjYWxlOwogCQl1MzIgY3I7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LW14Yy90emljLmMgYi9hcmNoL2FybS9wbGF0LW14Yy90emljLmMKaW5kZXggZTY5ZWQ4YS4uYmMzYTZiZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1teGMvdHppYy5jCisrKyBiL2FyY2gvYXJtL3BsYXQtbXhjL3R6aWMuYwpAQCAtNjksNTAgKzY5LDUwIEBACiAjZW5kaWYKIAogLyoqCi0gKiB0emljX21hc2tfaXJxKCkgLSBEaXNhYmxlIGludGVycnVwdCBudW1iZXIgImlycSIgaW4gdGhlIFRaSUMKKyAqIHR6aWNfbWFza19pcnEoKSAtIERpc2FibGUgaW50ZXJydXB0IHNvdXJjZSAiZCIgaW4gdGhlIFRaSUMKICAqCi0gKiBAcGFyYW0gIGlycSAgICAgICAgICBpbnRlcnJ1cHQgc291cmNlIG51bWJlcgorICogQHBhcmFtICBkICAgICAgICAgICAgaW50ZXJydXB0IHNvdXJjZQogICovCi1zdGF0aWMgdm9pZCB0emljX21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB0emljX21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAlpbnQgaW5kZXgsIG9mZjsKIAotCWluZGV4ID0gaXJxID4+IDU7Ci0Jb2ZmID0gaXJxICYgMHgxRjsKKwlpbmRleCA9IGQtPmlycSA+PiA1OworCW9mZiA9IGQtPmlycSAmIDB4MUY7CiAJX19yYXdfd3JpdGVsKDEgPDwgb2ZmLCB0emljX2Jhc2UgKyBUWklDX0VOQ0xFQVIwKGluZGV4KSk7CiB9CiAKIC8qKgotICogdHppY191bm1hc2tfaXJxKCkgLSBFbmFibGUgaW50ZXJydXB0IG51bWJlciAiaXJxIiBpbiB0aGUgVFpJQworICogdHppY191bm1hc2tfaXJxKCkgLSBFbmFibGUgaW50ZXJydXB0IHNvdXJjZSAiZCIgaW4gdGhlIFRaSUMKICAqCi0gKiBAcGFyYW0gIGlycSAgICAgICAgICBpbnRlcnJ1cHQgc291cmNlIG51bWJlcgorICogQHBhcmFtICBkICAgICAgICAgICAgaW50ZXJydXB0IHNvdXJjZQogICovCi1zdGF0aWMgdm9pZCB0emljX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHR6aWNfdW5tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJaW50IGluZGV4LCBvZmY7CiAKLQlpbmRleCA9IGlycSA+PiA1OwotCW9mZiA9IGlycSAmIDB4MUY7CisJaW5kZXggPSBkLT5pcnEgPj4gNTsKKwlvZmYgPSBkLT5pcnEgJiAweDFGOwogCV9fcmF3X3dyaXRlbCgxIDw8IG9mZiwgdHppY19iYXNlICsgVFpJQ19FTlNFVDAoaW5kZXgpKTsKIH0KIAogc3RhdGljIHVuc2lnbmVkIGludCB3YWtldXBfaW50cls0XTsKIAogLyoqCi0gKiB0emljX3NldF93YWtlX2lycSgpIC0gU2V0IGludGVycnVwdCBudW1iZXIgImlycSIgaW4gdGhlIFRaSUMgYXMgYSB3YWtlLXVwIHNvdXJjZS4KKyAqIHR6aWNfc2V0X3dha2VfaXJxKCkgLSBTZXQgaW50ZXJydXB0IHNvdXJjZSAiZCIgaW4gdGhlIFRaSUMgYXMgYSB3YWtlLXVwIHNvdXJjZS4KICAqCi0gKiBAcGFyYW0gIGlycSAgICAgICAgICBpbnRlcnJ1cHQgc291cmNlIG51bWJlcgorICogQHBhcmFtICBkICAgICAgICAgICAgaW50ZXJydXB0IHNvdXJjZQogICogQHBhcmFtICBlbmFibGUgICAgICAgZW5hYmxlIGFzIHdha2UtdXAgaWYgZXF1YWwgdG8gbm9uLXplcm8KICAqIAkJCWRpc2JsZSBhcyB3YWtlLXVwIGlmIGVxdWFsIHRvIHplcm8KICAqCiAgKiBAcmV0dXJuICAgICAgIFRoaXMgZnVuY3Rpb24gcmV0dXJucyAwIG9uIHN1Y2Nlc3MuCiAgKi8KLXN0YXRpYyBpbnQgdHppY19zZXRfd2FrZV9pcnEodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IGVuYWJsZSkKK3N0YXRpYyBpbnQgdHppY19zZXRfd2FrZV9pcnEoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgZW5hYmxlKQogewogCXVuc2lnbmVkIGludCBpbmRleCwgb2ZmOwogCi0JaW5kZXggPSBpcnEgPj4gNTsKLQlvZmYgPSBpcnEgJiAweDFGOworCWluZGV4ID0gZC0+aXJxID4+IDU7CisJb2ZmID0gZC0+aXJxICYgMHgxRjsKIAogCWlmIChpbmRleCA+IDMpCiAJCXJldHVybiAtRUlOVkFMOwpAQCAtMTI4LDEwICsxMjgsMTAgQEAKIHN0YXRpYyBzdHJ1Y3QgbXhjX2lycV9jaGlwIG14Y190emljX2NoaXAgPSB7CiAJLmJhc2UgPSB7CiAJCS5uYW1lID0gIk1YQ19UWklDIiwKLQkJLmFjayA9IHR6aWNfbWFza19pcnEsCi0JCS5tYXNrID0gdHppY19tYXNrX2lycSwKLQkJLnVubWFzayA9IHR6aWNfdW5tYXNrX2lycSwKLQkJLnNldF93YWtlID0gdHppY19zZXRfd2FrZV9pcnEsCisJCS5pcnFfYWNrID0gdHppY19tYXNrX2lycSwKKwkJLmlycV9tYXNrID0gdHppY19tYXNrX2lycSwKKwkJLmlycV91bm1hc2sgPSB0emljX3VubWFza19pcnEsCisJCS5pcnFfc2V0X3dha2UgPSB0emljX3NldF93YWtlX2lycSwKIAl9LAogI2lmZGVmIENPTkZJR19GSVEKIAkuc2V0X2lycV9maXEgPSB0emljX3NldF9pcnFfZmlxLApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1ub21hZGlrL2dwaW8uYyBiL2FyY2gvYXJtL3BsYXQtbm9tYWRpay9ncGlvLmMKaW5kZXggZWRhNGUzYS4uMWU4OGVjYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1ub21hZGlrL2dwaW8uYworKysgYi9hcmNoL2FybS9wbGF0LW5vbWFkaWsvZ3Bpby5jCkBAIC0zNTYsMTMgKzM1NiwxMyBAQAogCXJldHVybiAxIDw8IChncGlvICUgMzIpOwogfQogCi1zdGF0aWMgdm9pZCBubWtfZ3Bpb19pcnFfYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBubWtfZ3Bpb19pcnFfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAlpbnQgZ3BpbzsKIAlzdHJ1Y3Qgbm1rX2dwaW9fY2hpcCAqbm1rX2NoaXA7CiAKLQlncGlvID0gTk9NQURJS19JUlFfVE9fR1BJTyhpcnEpOwotCW5ta19jaGlwID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlncGlvID0gTk9NQURJS19JUlFfVE9fR1BJTyhkLT5pcnEpOworCW5ta19jaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZCk7CiAJaWYgKCFubWtfY2hpcCkKIAkJcmV0dXJuOwogCXdyaXRlbChubWtfZ3Bpb19nZXRfYml0bWFzayhncGlvKSwgbm1rX2NoaXAtPmFkZHIgKyBOTUtfR1BJT19JQyk7CkBAIC00MDEsNyArNDAxLDcgQEAKIAl9CiB9CiAKLXN0YXRpYyBpbnQgbm1rX2dwaW9faXJxX21vZGlmeSh1bnNpZ25lZCBpbnQgaXJxLCBlbnVtIG5ta19ncGlvX2lycV90eXBlIHdoaWNoLAorc3RhdGljIGludCBubWtfZ3Bpb19pcnFfbW9kaWZ5KHN0cnVjdCBpcnFfZGF0YSAqZCwgZW51bSBubWtfZ3Bpb19pcnFfdHlwZSB3aGljaCwKIAkJCSAgICAgICBib29sIGVuYWJsZSkKIHsKIAlpbnQgZ3BpbzsKQEAgLTQwOSw4ICs0MDksOCBAQAogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJdTMyIGJpdG1hc2s7CiAKLQlncGlvID0gTk9NQURJS19JUlFfVE9fR1BJTyhpcnEpOwotCW5ta19jaGlwID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlncGlvID0gTk9NQURJS19JUlFfVE9fR1BJTyhkLT5pcnEpOworCW5ta19jaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZCk7CiAJYml0bWFzayA9IG5ta19ncGlvX2dldF9iaXRtYXNrKGdwaW8pOwogCWlmICghbm1rX2NoaXApCiAJCXJldHVybiAtRUlOVkFMOwpAQCAtNDIyLDI0ICs0MjIsMjQgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIHZvaWQgbm1rX2dwaW9faXJxX21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG5ta19ncGlvX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlubWtfZ3Bpb19pcnFfbW9kaWZ5KGlycSwgTk9STUFMLCBmYWxzZSk7CisJbm1rX2dwaW9faXJxX21vZGlmeShkLCBOT1JNQUwsIGZhbHNlKTsKIH0KIAotc3RhdGljIHZvaWQgbm1rX2dwaW9faXJxX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbm1rX2dwaW9faXJxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jbm1rX2dwaW9faXJxX21vZGlmeShpcnEsIE5PUk1BTCwgdHJ1ZSk7CisJbm1rX2dwaW9faXJxX21vZGlmeShkLCBOT1JNQUwsIHRydWUpOwogfQogCi1zdGF0aWMgaW50IG5ta19ncGlvX2lycV9zZXRfd2FrZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgb24pCitzdGF0aWMgaW50IG5ta19ncGlvX2lycV9zZXRfd2FrZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCBvbikKIHsKIAlzdHJ1Y3Qgbm1rX2dwaW9fY2hpcCAqbm1rX2NoaXA7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAlpbnQgZ3BpbzsKIAotCWdwaW8gPSBOT01BRElLX0lSUV9UT19HUElPKGlycSk7Ci0Jbm1rX2NoaXAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCWdwaW8gPSBOT01BRElLX0lSUV9UT19HUElPKGQtPmlycSk7CisJbm1rX2NoaXAgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKIAlpZiAoIW5ta19jaGlwKQogCQlyZXR1cm4gLUVJTlZBTDsKIApAQCAtNDU3LDkgKzQ1Nyw5IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgbm1rX2dwaW9faXJxX3NldF90eXBlKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCB0eXBlKQorc3RhdGljIGludCBubWtfZ3Bpb19pcnFfc2V0X3R5cGUoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgdHlwZSkKIHsKLQlzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MgPSBpcnFfdG9fZGVzYyhpcnEpOworCXN0cnVjdCBpcnFfZGVzYyAqZGVzYyA9IGlycV90b19kZXNjKGQtPmlycSk7CiAJYm9vbCBlbmFibGVkID0gIShkZXNjLT5zdGF0dXMgJiBJUlFfRElTQUJMRUQpOwogCWJvb2wgd2FrZSA9IGRlc2MtPndha2VfZGVwdGg7CiAJaW50IGdwaW87CkBAIC00NjcsOCArNDY3LDggQEAKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCXUzMiBiaXRtYXNrOwogCi0JZ3BpbyA9IE5PTUFESUtfSVJRX1RPX0dQSU8oaXJxKTsKLQlubWtfY2hpcCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJZ3BpbyA9IE5PTUFESUtfSVJRX1RPX0dQSU8oZC0+aXJxKTsKKwlubWtfY2hpcCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOwogCWJpdG1hc2sgPSBubWtfZ3Bpb19nZXRfYml0bWFzayhncGlvKTsKIAlpZiAoIW5ta19jaGlwKQogCQlyZXR1cm4gLUVJTlZBTDsKQEAgLTUwNywxMSArNTA3LDExIEBACiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbm1rX2dwaW9faXJxX2NoaXAgPSB7CiAJLm5hbWUJCT0gIk5vbWFkaWstR1BJTyIsCi0JLmFjawkJPSBubWtfZ3Bpb19pcnFfYWNrLAotCS5tYXNrCQk9IG5ta19ncGlvX2lycV9tYXNrLAotCS51bm1hc2sJCT0gbm1rX2dwaW9faXJxX3VubWFzaywKLQkuc2V0X3R5cGUJPSBubWtfZ3Bpb19pcnFfc2V0X3R5cGUsCi0JLnNldF93YWtlCT0gbm1rX2dwaW9faXJxX3NldF93YWtlLAorCS5pcnFfYWNrCT0gbm1rX2dwaW9faXJxX2FjaywKKwkuaXJxX21hc2sJPSBubWtfZ3Bpb19pcnFfbWFzaywKKwkuaXJxX3VubWFzawk9IG5ta19ncGlvX2lycV91bm1hc2ssCisJLmlycV9zZXRfdHlwZQk9IG5ta19ncGlvX2lycV9zZXRfdHlwZSwKKwkuaXJxX3NldF93YWtlCT0gbm1rX2dwaW9faXJxX3NldF93YWtlLAogfTsKIAogc3RhdGljIHZvaWQgbm1rX2dwaW9faXJxX2hhbmRsZXIodW5zaWduZWQgaW50IGlycSwgc3RydWN0IGlycV9kZXNjICpkZXNjKQpAQCAtNTIyLDEyICs1MjIsMTIgQEAKIAl1MzIgcGVuZGluZzsKIAl1bnNpZ25lZCBpbnQgZmlyc3RfaXJxOwogCi0JaWYgKGhvc3RfY2hpcC0+bWFza19hY2spCi0JCWhvc3RfY2hpcC0+bWFza19hY2soaXJxKTsKKwlpZiAoaG9zdF9jaGlwLT5pcnFfbWFza19hY2spCisJCWhvc3RfY2hpcC0+aXJxX21hc2tfYWNrKCZkZXNjLT5pcnFfZGF0YSk7CiAJZWxzZSB7Ci0JCWhvc3RfY2hpcC0+bWFzayhpcnEpOwotCQlpZiAoaG9zdF9jaGlwLT5hY2spCi0JCQlob3N0X2NoaXAtPmFjayhpcnEpOworCQlob3N0X2NoaXAtPmlycV9tYXNrKCZkZXNjLT5pcnFfZGF0YSk7CisJCWlmIChob3N0X2NoaXAtPmlycV9hY2spCisJCQlob3N0X2NoaXAtPmlycV9hY2soJmRlc2MtPmlycV9kYXRhKTsKIAl9CiAKIAlubWtfY2hpcCA9IGdldF9pcnFfZGF0YShpcnEpOwpAQCAtNTM3LDcgKzUzNyw3IEBACiAJCWdlbmVyaWNfaGFuZGxlX2lycShncGlvX2lycSk7CiAJfQogCi0JaG9zdF9jaGlwLT51bm1hc2soaXJxKTsKKwlob3N0X2NoaXAtPmlycV91bm1hc2soJmRlc2MtPmlycV9kYXRhKTsKIH0KIAogc3RhdGljIGludCBubWtfZ3Bpb19pbml0X2lycShzdHJ1Y3Qgbm1rX2dwaW9fY2hpcCAqbm1rX2NoaXApCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LW5vbWFkaWsvaW5jbHVkZS9wbGF0L3N0ZV9kbWE0MC5oIGIvYXJjaC9hcm0vcGxhdC1ub21hZGlrL2luY2x1ZGUvcGxhdC9zdGVfZG1hNDAuaAppbmRleCA3NGI2MmYxLi40ZDZkZDRjIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW5vbWFkaWsvaW5jbHVkZS9wbGF0L3N0ZV9kbWE0MC5oCisrKyBiL2FyY2gvYXJtL3BsYXQtbm9tYWRpay9pbmNsdWRlL3BsYXQvc3RlX2RtYTQwLmgKQEAgLTEzLDYgKzEzLDE0IEBACiAjaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiAKKy8qCisgKiBNYXhpdW0gc2l6ZSBmb3IgYSBzaW5nbGUgZG1hIGRlc2NyaXB0b3IKKyAqIFNpemUgaXMgbGltaXRlZCB0byAxNiBiaXRzLgorICogU2l6ZSBpcyBpbiB0aGUgdW5pdHMgb2YgYWRkci13aWR0aHMgKDEsMiw0LDggYnl0ZXMpCisgKiBMYXJnZXIgdHJhbnNmZXJzIHdpbGwgYmUgc3BsaXQgdXAgdG8gbXVsdGlwbGUgbGlua2VkIGRlc2MKKyAqLworI2RlZmluZSBTVEVETUE0MF9NQVhfU0VHX1NJWkUgMHhGRkZGCisKIC8qIGRldiB0eXBlcyBmb3IgbWVtY3B5ICovCiAjZGVmaW5lIFNURURNQTQwX0RFVl9EU1RfTUVNT1JZICgtMSkKICNkZWZpbmUJU1RFRE1BNDBfREVWX1NSQ19NRU1PUlkgKC0xKQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1vbWFwL0tjb25maWcgYi9hcmNoL2FybS9wbGF0LW9tYXAvS2NvbmZpZwppbmRleCAxOGZlM2NiLi5iNjMzM2FlIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW9tYXAvS2NvbmZpZworKysgYi9hcmNoL2FybS9wbGF0LW9tYXAvS2NvbmZpZwpAQCAtMTQ0LDEyICsxNDQsOSBAQAogY29uZmlnIE9NQVBfSU9NTVVfSVZBMgogCWJvb2wKIAotY2hvaWNlCi0JcHJvbXB0ICJTeXN0ZW0gdGltZXIiCi0JZGVmYXVsdCBPTUFQXzMyS19USU1FUiBpZiAhQVJDSF9PTUFQMTVYWAotCiBjb25maWcgT01BUF9NUFVfVElNRVIKIAlib29sICJVc2UgbXB1IHRpbWVyIgorCWRlcGVuZHMgb24gQVJDSF9PTUFQMQogCWhlbHAKIAkgIFNlbGVjdCB0aGlzIG9wdGlvbiBpZiB5b3Ugd2FudCB0byB1c2UgdGhlIE9NQVAgbXB1IHRpbWVyLiBUaGlzCiAJICB0aW1lciBwcm92aWRlcyBtb3JlIGludHJhLXRpY2sgcmVzb2x1dGlvbiB0aGFuIHRoZSAzMktIeiB0aW1lciwKQEAgLTE1OCw2ICsxNTUsNyBAQAogY29uZmlnIE9NQVBfMzJLX1RJTUVSCiAJYm9vbCAiVXNlIDMyS0h6IHRpbWVyIgogCWRlcGVuZHMgb24gQVJDSF9PTUFQMTZYWCB8fCBBUkNIX09NQVAyUExVUworCWRlZmF1bHQgeSBpZiAoQVJDSF9PTUFQMTZYWCB8fCBBUkNIX09NQVAyUExVUykKIAloZWxwCiAJICBTZWxlY3QgdGhpcyBvcHRpb24gaWYgeW91IHdhbnQgdG8gZW5hYmxlIHRoZSBPTUFQIDMyS0h6IHRpbWVyLgogCSAgVGhpcyB0aW1lciBzYXZlcyBwb3dlciBjb21wYXJlZCB0byB0aGUgT01BUF9NUFVfVElNRVIsIGFuZCBoYXMKQEAgLTE2NSw4ICsxNjMsNiBAQAogCSAgaW50cmEtdGljayByZXNvbHV0aW9uIHRoYW4gT01BUF9NUFVfVElNRVIuIFRoZSAzMktIeiB0aW1lciBpcwogCSAgY3VycmVudGx5IG9ubHkgYXZhaWxhYmxlIGZvciBPTUFQMTZYWCwgMjRYWCwgMzRYWCBhbmQgT01BUDQuCiAKLWVuZGNob2ljZQotCiBjb25maWcgT01BUDNfTDJfQVVYX1NFQ1VSRV9TQVZFX1JFU1RPUkUKIAlib29sICJPTUFQMyBIUy9FTVUgc2F2ZSBhbmQgcmVzdG9yZSBmb3IgTDIgQVVYIGNvbnRyb2wgcmVnaXN0ZXIiCiAJZGVwZW5kcyBvbiBBUkNIX09NQVAzICYmIFBNCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LW9tYXAvY291bnRlcl8zMmsuYyBiL2FyY2gvYXJtL3BsYXQtb21hcC9jb3VudGVyXzMyay5jCmluZGV4IGVhNDY0NDAuLjg2MmRkYTkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtb21hcC9jb3VudGVyXzMyay5jCisrKyBiL2FyY2gvYXJtL3BsYXQtb21hcC9jb3VudGVyXzMyay5jCkBAIC0zNiw4ICszNiw2IEBACiAKICNkZWZpbmUgT01BUDE2WFhfVElNRVJfMzJLX1NZTkNIUk9OSVpFRAkJMHhmZmZiYzQxMAogCi0jaWYgIShkZWZpbmVkKENPTkZJR19BUkNIX09NQVA3MzApIHx8IGRlZmluZWQoQ09ORklHX0FSQ0hfT01BUDE1WFgpKQotCiAjaW5jbHVkZSA8bGludXgvY2xvY2tzb3VyY2UuaD4KIAogLyoKQEAgLTEyMiwxMiArMTIwLDI0IEBACiAjZGVmaW5lIFNDX01VTFQJCTQwMDAwMDAwMDB1CiAjZGVmaW5lIFNDX1NISUZUCTE3CiAKLXVuc2lnbmVkIGxvbmcgbG9uZyBub3RyYWNlIHNjaGVkX2Nsb2NrKHZvaWQpCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgbG9uZyBub3RyYWNlIF9vbWFwXzMya19zY2hlZF9jbG9jayh2b2lkKQogewogCXUzMiBjeWMgPSBjbG9ja3NvdXJjZV8zMmsucmVhZCgmY2xvY2tzb3VyY2VfMzJrKTsKIAlyZXR1cm4gY3ljX3RvX2ZpeGVkX3NjaGVkX2Nsb2NrKCZjZCwgY3ljLCAodTMyKX4wLCBTQ19NVUxULCBTQ19TSElGVCk7CiB9CiAKKyNpZm5kZWYgQ09ORklHX09NQVBfTVBVX1RJTUVSCit1bnNpZ25lZCBsb25nIGxvbmcgbm90cmFjZSBzY2hlZF9jbG9jayh2b2lkKQoreworCXJldHVybiBfb21hcF8zMmtfc2NoZWRfY2xvY2soKTsKK30KKyNlbHNlCit1bnNpZ25lZCBsb25nIGxvbmcgbm90cmFjZSBvbWFwXzMya19zY2hlZF9jbG9jayh2b2lkKQoreworCXJldHVybiBfb21hcF8zMmtfc2NoZWRfY2xvY2soKTsKK30KKyNlbmRpZgorCiBzdGF0aWMgdm9pZCBub3RyYWNlIG9tYXBfdXBkYXRlX3NjaGVkX2Nsb2NrKHZvaWQpCiB7CiAJdTMyIGN5YyA9IGNsb2Nrc291cmNlXzMyay5yZWFkKCZjbG9ja3NvdXJjZV8zMmspOwpAQCAtMTYwLDcgKzE3MCw3IEBACiAJKnRzID0gKnRzcDsKIH0KIAotc3RhdGljIGludCBfX2luaXQgb21hcF9pbml0X2Nsb2Nrc291cmNlXzMyayh2b2lkKQoraW50IF9faW5pdCBvbWFwX2luaXRfY2xvY2tzb3VyY2VfMzJrKHZvaWQpCiB7CiAJc3RhdGljIGNoYXIgZXJyW10gX19pbml0ZGF0YSA9IEtFUk5fRVJSCiAJCQkiJXM6IGNhbid0IHJlZ2lzdGVyIGNsb2Nrc291cmNlIVxuIjsKQEAgLTE5NSw3ICsyMDUsMyBAQAogCX0KIAlyZXR1cm4gMDsKIH0KLWFyY2hfaW5pdGNhbGwob21hcF9pbml0X2Nsb2Nrc291cmNlXzMyayk7Ci0KLSNlbmRpZgkvKiAhKGRlZmluZWQoQ09ORklHX0FSQ0hfT01BUDczMCkgfHwgZGVmaW5lZChDT05GSUdfQVJDSF9PTUFQMTVYWCkpICovCi0KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtb21hcC9kbWEuYyBiL2FyY2gvYXJtL3BsYXQtb21hcC9kbWEuYwppbmRleCBjNGIyYjQ3Li44NTM2MzA4IDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW9tYXAvZG1hLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1vbWFwL2RtYS5jCkBAIC01Myw3ICs1Myw3IEBACiAjZW5kaWYKIAogI2RlZmluZSBPTUFQX0RNQV9BQ1RJVkUJCQkweDAxCi0jZGVmaW5lIE9NQVAyX0RNQV9DU1JfQ0xFQVJfTUFTSwkweGZmZQorI2RlZmluZSBPTUFQMl9ETUFfQ1NSX0NMRUFSX01BU0sJMHhmZmZmZmZmZgogCiAjZGVmaW5lIE9NQVBfRlVOQ19NVVhfQVJNX0JBU0UJCSgweGZmZmUxMDAwICsgMHhlYykKIApAQCAtMTg3Myw3ICsxODczLDcgQEAKIAkJcHJpbnRrKEtFUk5fSU5GTyAiRE1BIG1pc2FsaWduZWQgZXJyb3Igd2l0aCBkZXZpY2UgJWRcbiIsCiAJCSAgICAgICBkbWFfY2hhbltjaF0uZGV2X2lkKTsKIAotCXAtPmRtYV93cml0ZShPTUFQMl9ETUFfQ1NSX0NMRUFSX01BU0ssIENTUiwgY2gpOworCXAtPmRtYV93cml0ZShzdGF0dXMsIENTUiwgY2gpOwogCXAtPmRtYV93cml0ZSgxIDw8IGNoLCBJUlFTVEFUVVNfTDAsIGNoKTsKIAkvKiByZWFkIGJhY2sgdGhlIHJlZ2lzdGVyIHRvIGZsdXNoIHRoZSB3cml0ZSAqLwogCXAtPmRtYV9yZWFkKElSUVNUQVRVU19MMCwgY2gpOwpAQCAtMTg5MywxMCArMTg5Myw5IEBACiAJCQlPTUFQX0RNQV9DSEFJTl9JTkNRSEVBRChjaGFpbl9pZCk7CiAKIAkJc3RhdHVzID0gcC0+ZG1hX3JlYWQoQ1NSLCBjaCk7CisJCXAtPmRtYV93cml0ZShzdGF0dXMsIENTUiwgY2gpOwogCX0KIAotCXAtPmRtYV93cml0ZShzdGF0dXMsIENTUiwgY2gpOwotCiAJaWYgKGxpa2VseShkbWFfY2hhbltjaF0uY2FsbGJhY2sgIT0gTlVMTCkpCiAJCWRtYV9jaGFuW2NoXS5jYWxsYmFjayhjaCwgc3RhdHVzLCBkbWFfY2hhbltjaF0uZGF0YSk7CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtb21hcC9ncGlvLmMgYi9hcmNoL2FybS9wbGF0LW9tYXAvZ3Bpby5jCmluZGV4IDFmOThlMGIuLjk3MWQxODYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtb21hcC9ncGlvLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1vbWFwL2dwaW8uYwpAQCAtNzE4LDcgKzcxOCw3IEBACiAJY2FzZSBNRVRIT0RfR1BJT18yNFhYOgogCWNhc2UgTUVUSE9EX0dQSU9fNDRYWDoKIAkJc2V0XzI0eHhfZ3Bpb190cmlnZ2VyaW5nKGJhbmssIGdwaW8sIHRyaWdnZXIpOwotCQlicmVhazsKKwkJcmV0dXJuIDA7CiAjZW5kaWYKIAlkZWZhdWx0OgogCQlnb3RvIGJhZDsKQEAgLTcyOSwxNyArNzI5LDE3IEBACiAJcmV0dXJuIC1FSU5WQUw7CiB9CiAKLXN0YXRpYyBpbnQgZ3Bpb19pcnFfdHlwZSh1bnNpZ25lZCBpcnEsIHVuc2lnbmVkIHR5cGUpCitzdGF0aWMgaW50IGdwaW9faXJxX3R5cGUoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCB0eXBlKQogewogCXN0cnVjdCBncGlvX2JhbmsgKmJhbms7CiAJdW5zaWduZWQgZ3BpbzsKIAlpbnQgcmV0dmFsOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKLQlpZiAoIWNwdV9jbGFzc19pc19vbWFwMigpICYmIGlycSA+IElIX01QVUlPX0JBU0UpCi0JCWdwaW8gPSBPTUFQX01QVUlPKGlycSAtIElIX01QVUlPX0JBU0UpOworCWlmICghY3B1X2NsYXNzX2lzX29tYXAyKCkgJiYgZC0+aXJxID4gSUhfTVBVSU9fQkFTRSkKKwkJZ3BpbyA9IE9NQVBfTVBVSU8oZC0+aXJxIC0gSUhfTVBVSU9fQkFTRSk7CiAJZWxzZQotCQlncGlvID0gaXJxIC0gSUhfR1BJT19CQVNFOworCQlncGlvID0gZC0+aXJxIC0gSUhfR1BJT19CQVNFOwogCiAJaWYgKGNoZWNrX2dwaW8oZ3BpbykgPCAwKQogCQlyZXR1cm4gLUVJTlZBTDsKQEAgLTc1MiwxOSArNzUyLDIxIEBACiAJCQkmJiAodHlwZSAmIChJUlFfVFlQRV9MRVZFTF9MT1d8SVJRX1RZUEVfTEVWRUxfSElHSCkpKQogCQlyZXR1cm4gLUVJTlZBTDsKIAotCWJhbmsgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCWJhbmsgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKIAlzcGluX2xvY2tfaXJxc2F2ZSgmYmFuay0+bG9jaywgZmxhZ3MpOwogCXJldHZhbCA9IF9zZXRfZ3Bpb190cmlnZ2VyaW5nKGJhbmssIGdldF9ncGlvX2luZGV4KGdwaW8pLCB0eXBlKTsKIAlpZiAocmV0dmFsID09IDApIHsKLQkJaXJxX2Rlc2NbaXJxXS5zdGF0dXMgJj0gfklSUV9UWVBFX1NFTlNFX01BU0s7Ci0JCWlycV9kZXNjW2lycV0uc3RhdHVzIHw9IHR5cGU7CisJCXN0cnVjdCBpcnFfZGVzYyAqZGVzYyA9IGlycV90b19kZXNjKGQtPmlycSk7CisKKwkJZGVzYy0+c3RhdHVzICY9IH5JUlFfVFlQRV9TRU5TRV9NQVNLOworCQlkZXNjLT5zdGF0dXMgfD0gdHlwZTsKIAl9CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmFuay0+bG9jaywgZmxhZ3MpOwogCiAJaWYgKHR5cGUgJiAoSVJRX1RZUEVfTEVWRUxfTE9XIHwgSVJRX1RZUEVfTEVWRUxfSElHSCkpCi0JCV9fc2V0X2lycV9oYW5kbGVyX3VubG9ja2VkKGlycSwgaGFuZGxlX2xldmVsX2lycSk7CisJCV9fc2V0X2lycV9oYW5kbGVyX3VubG9ja2VkKGQtPmlycSwgaGFuZGxlX2xldmVsX2lycSk7CiAJZWxzZSBpZiAodHlwZSAmIChJUlFfVFlQRV9FREdFX0ZBTExJTkcgfCBJUlFfVFlQRV9FREdFX1JJU0lORykpCi0JCV9fc2V0X2lycV9oYW5kbGVyX3VubG9ja2VkKGlycSwgaGFuZGxlX2VkZ2VfaXJxKTsKKwkJX19zZXRfaXJxX2hhbmRsZXJfdW5sb2NrZWQoZC0+aXJxLCBoYW5kbGVfZWRnZV9pcnEpOwogCiAJcmV0dXJuIHJldHZhbDsKIH0KQEAgLTEwMjEsMTUgKzEwMjMsMTUgQEAKIH0KIAogLyogVXNlIGRpc2FibGVfaXJxX3dha2UoKSBhbmQgZW5hYmxlX2lycV93YWtlKCkgZnVuY3Rpb25zIGZyb20gZHJpdmVycyAqLwotc3RhdGljIGludCBncGlvX3dha2VfZW5hYmxlKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCBlbmFibGUpCitzdGF0aWMgaW50IGdwaW9fd2FrZV9lbmFibGUoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgZW5hYmxlKQogewotCXVuc2lnbmVkIGludCBncGlvID0gaXJxIC0gSUhfR1BJT19CQVNFOworCXVuc2lnbmVkIGludCBncGlvID0gZC0+aXJxIC0gSUhfR1BJT19CQVNFOwogCXN0cnVjdCBncGlvX2JhbmsgKmJhbms7CiAJaW50IHJldHZhbDsKIAogCWlmIChjaGVja19ncGlvKGdwaW8pIDwgMCkKIAkJcmV0dXJuIC1FTk9ERVY7Ci0JYmFuayA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJYmFuayA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOwogCXJldHZhbCA9IF9zZXRfZ3Bpb193YWtldXAoYmFuaywgZ2V0X2dwaW9faW5kZXgoZ3BpbyksIGVuYWJsZSk7CiAKIAlyZXR1cm4gcmV0dmFsOwpAQCAtMTE0Miw3ICsxMTQ0LDcgQEAKIAl1MzIgcmV0cmlnZ2VyID0gMDsKIAlpbnQgdW5tYXNrZWQgPSAwOwogCi0JZGVzYy0+Y2hpcC0+YWNrKGlycSk7CisJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX2FjaygmZGVzYy0+aXJxX2RhdGEpOwogCiAJYmFuayA9IGdldF9pcnFfZGF0YShpcnEpOwogI2lmZGVmIENPTkZJR19BUkNIX09NQVAxCkBAIC0xMTk5LDcgKzEyMDEsNyBAQAogCQljb25maWd1cmVkLCB3ZSBjb3VsZCB1bm1hc2sgR1BJTyBiYW5rIGludGVycnVwdCBpbW1lZGlhdGVseSAqLwogCQlpZiAoIWxldmVsX21hc2sgJiYgIXVubWFza2VkKSB7CiAJCQl1bm1hc2tlZCA9IDE7Ci0JCQlkZXNjLT5jaGlwLT51bm1hc2soaXJxKTsKKwkJCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV91bm1hc2soJmRlc2MtPmlycV9kYXRhKTsKIAkJfQogCiAJCWlzciB8PSByZXRyaWdnZXI7CkBAIC0xMjM1LDQxICsxMjM3LDQwIEBACiAJaW50ZXJydXB0ICovCiBleGl0OgogCWlmICghdW5tYXNrZWQpCi0JCWRlc2MtPmNoaXAtPnVubWFzayhpcnEpOwotCisJCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV91bm1hc2soJmRlc2MtPmlycV9kYXRhKTsKIH0KIAotc3RhdGljIHZvaWQgZ3Bpb19pcnFfc2h1dGRvd24odW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGdwaW9faXJxX3NodXRkb3duKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl1bnNpZ25lZCBpbnQgZ3BpbyA9IGlycSAtIElIX0dQSU9fQkFTRTsKLQlzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwl1bnNpZ25lZCBpbnQgZ3BpbyA9IGQtPmlycSAtIElIX0dQSU9fQkFTRTsKKwlzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZCk7CiAKIAlfcmVzZXRfZ3BpbyhiYW5rLCBncGlvKTsKIH0KIAotc3RhdGljIHZvaWQgZ3Bpb19hY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBncGlvX2Fja19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXVuc2lnbmVkIGludCBncGlvID0gaXJxIC0gSUhfR1BJT19CQVNFOwotCXN0cnVjdCBncGlvX2JhbmsgKmJhbmsgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXVuc2lnbmVkIGludCBncGlvID0gZC0+aXJxIC0gSUhfR1BJT19CQVNFOworCXN0cnVjdCBncGlvX2JhbmsgKmJhbmsgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKIAogCV9jbGVhcl9ncGlvX2lycXN0YXR1cyhiYW5rLCBncGlvKTsKIH0KIAotc3RhdGljIHZvaWQgZ3Bpb19tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgZ3Bpb19tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JdW5zaWduZWQgaW50IGdwaW8gPSBpcnEgLSBJSF9HUElPX0JBU0U7Ci0Jc3RydWN0IGdwaW9fYmFuayAqYmFuayA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJdW5zaWduZWQgaW50IGdwaW8gPSBkLT5pcnEgLSBJSF9HUElPX0JBU0U7CisJc3RydWN0IGdwaW9fYmFuayAqYmFuayA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOwogCiAJX3NldF9ncGlvX2lycWVuYWJsZShiYW5rLCBncGlvLCAwKTsKIAlfc2V0X2dwaW9fdHJpZ2dlcmluZyhiYW5rLCBnZXRfZ3Bpb19pbmRleChncGlvKSwgSVJRX1RZUEVfTk9ORSk7CiB9CiAKLXN0YXRpYyB2b2lkIGdwaW9fdW5tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgZ3Bpb191bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl1bnNpZ25lZCBpbnQgZ3BpbyA9IGlycSAtIElIX0dQSU9fQkFTRTsKLQlzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwl1bnNpZ25lZCBpbnQgZ3BpbyA9IGQtPmlycSAtIElIX0dQSU9fQkFTRTsKKwlzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZCk7CiAJdW5zaWduZWQgaW50IGlycV9tYXNrID0gMSA8PCBnZXRfZ3Bpb19pbmRleChncGlvKTsKLQlzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MgPSBpcnFfdG9fZGVzYyhpcnEpOworCXN0cnVjdCBpcnFfZGVzYyAqZGVzYyA9IGlycV90b19kZXNjKGQtPmlycSk7CiAJdTMyIHRyaWdnZXIgPSBkZXNjLT5zdGF0dXMgJiBJUlFfVFlQRV9TRU5TRV9NQVNLOwogCiAJaWYgKHRyaWdnZXIpCkBAIC0xMjg3LDEyICsxMjg4LDEyIEBACiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgZ3Bpb19pcnFfY2hpcCA9IHsKIAkubmFtZQkJPSAiR1BJTyIsCi0JLnNodXRkb3duCT0gZ3Bpb19pcnFfc2h1dGRvd24sCi0JLmFjawkJPSBncGlvX2Fja19pcnEsCi0JLm1hc2sJCT0gZ3Bpb19tYXNrX2lycSwKLQkudW5tYXNrCQk9IGdwaW9fdW5tYXNrX2lycSwKLQkuc2V0X3R5cGUJPSBncGlvX2lycV90eXBlLAotCS5zZXRfd2FrZQk9IGdwaW9fd2FrZV9lbmFibGUsCisJLmlycV9zaHV0ZG93bgk9IGdwaW9faXJxX3NodXRkb3duLAorCS5pcnFfYWNrCT0gZ3Bpb19hY2tfaXJxLAorCS5pcnFfbWFzawk9IGdwaW9fbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBncGlvX3VubWFza19pcnEsCisJLmlycV9zZXRfdHlwZQk9IGdwaW9faXJxX3R5cGUsCisJLmlycV9zZXRfd2FrZQk9IGdwaW9fd2FrZV9lbmFibGUsCiB9OwogCiAvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCkBAIC0xMzAxLDM2ICsxMzAyLDM2IEBACiAKIC8qIE1QVUlPIHVzZXMgdGhlIGFsd2F5cy1vbiAzMmsgY2xvY2sgKi8KIAotc3RhdGljIHZvaWQgbXB1aW9fYWNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbXB1aW9fYWNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7CiAJLyogVGhlIElTUiBpcyByZXNldCBhdXRvbWF0aWNhbGx5LCBzbyBkbyBub3RoaW5nIGhlcmUuICovCiB9CiAKLXN0YXRpYyB2b2lkIG1wdWlvX21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBtcHVpb19tYXNrX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JdW5zaWduZWQgaW50IGdwaW8gPSBPTUFQX01QVUlPKGlycSAtIElIX01QVUlPX0JBU0UpOwotCXN0cnVjdCBncGlvX2JhbmsgKmJhbmsgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXVuc2lnbmVkIGludCBncGlvID0gT01BUF9NUFVJTyhkLT5pcnEgLSBJSF9NUFVJT19CQVNFKTsKKwlzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZCk7CiAKIAlfc2V0X2dwaW9faXJxZW5hYmxlKGJhbmssIGdwaW8sIDApOwogfQogCi1zdGF0aWMgdm9pZCBtcHVpb191bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBtcHVpb191bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQl1bnNpZ25lZCBpbnQgZ3BpbyA9IE9NQVBfTVBVSU8oaXJxIC0gSUhfTVBVSU9fQkFTRSk7Ci0Jc3RydWN0IGdwaW9fYmFuayAqYmFuayA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJdW5zaWduZWQgaW50IGdwaW8gPSBPTUFQX01QVUlPKGQtPmlycSAtIElIX01QVUlPX0JBU0UpOworCXN0cnVjdCBncGlvX2JhbmsgKmJhbmsgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKIAogCV9zZXRfZ3Bpb19pcnFlbmFibGUoYmFuaywgZ3BpbywgMSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbXB1aW9faXJxX2NoaXAgPSB7CiAJLm5hbWUJCT0gIk1QVUlPIiwKLQkuYWNrCQk9IG1wdWlvX2Fja19pcnEsCi0JLm1hc2sJCT0gbXB1aW9fbWFza19pcnEsCi0JLnVubWFzawkJPSBtcHVpb191bm1hc2tfaXJxLAotCS5zZXRfdHlwZQk9IGdwaW9faXJxX3R5cGUsCisJLmlycV9hY2sJPSBtcHVpb19hY2tfaXJxLAorCS5pcnFfbWFzawk9IG1wdWlvX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gbXB1aW9fdW5tYXNrX2lycSwKKwkuaXJxX3NldF90eXBlCT0gZ3Bpb19pcnFfdHlwZSwKICNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMTZYWAogCS8qIFJFVklTSVQ6IGFzc3VtaW5nIG9ubHkgMTZ4eCBzdXBwb3J0cyBNUFVJTyB3YWtlIGV2ZW50cyAqLwotCS5zZXRfd2FrZQk9IGdwaW9fd2FrZV9lbmFibGUsCisJLmlycV9zZXRfd2FrZQk9IGdwaW9fd2FrZV9lbmFibGUsCiAjZW5kaWYKIH07CiAKQEAgLTE2NzEsNyArMTY3Miw5IEBACiAKIAlmb3IgKGogPSBiYW5rLT52aXJ0dWFsX2lycV9zdGFydDsKIAkJICAgICBqIDwgYmFuay0+dmlydHVhbF9pcnFfc3RhcnQgKyBiYW5rX3dpZHRoOyBqKyspIHsKLQkJbG9ja2RlcF9zZXRfY2xhc3MoJmlycV9kZXNjW2pdLmxvY2ssICZncGlvX2xvY2tfY2xhc3MpOworCQlzdHJ1Y3QgaXJxX2Rlc2MgKmQgPSBpcnFfdG9fZGVzYyhqKTsKKworCQlsb2NrZGVwX3NldF9jbGFzcygmZC0+bG9jaywgJmdwaW9fbG9ja19jbGFzcyk7CiAJCXNldF9pcnFfY2hpcF9kYXRhKGosIGJhbmspOwogCQlpZiAoYmFua19pc19tcHVpbyhiYW5rKSkKIAkJCXNldF9pcnFfY2hpcChqLCAmbXB1aW9faXJxX2NoaXApOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1vbWFwL2luY2x1ZGUvcGxhdC9jb21tb24uaCBiL2FyY2gvYXJtL3BsYXQtb21hcC9pbmNsdWRlL3BsYXQvY29tbW9uLmgKaW5kZXggNmI4MDg4ZS4uMjliMmFmYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1vbWFwL2luY2x1ZGUvcGxhdC9jb21tb24uaAorKysgYi9hcmNoL2FybS9wbGF0LW9tYXAvaW5jbHVkZS9wbGF0L2NvbW1vbi5oCkBAIC0zNSw2ICszNSw5IEBACiAKIGV4dGVybiB2b2lkIG9tYXBfbWFwX2NvbW1vbl9pbyh2b2lkKTsKIGV4dGVybiBzdHJ1Y3Qgc3lzX3RpbWVyIG9tYXBfdGltZXI7CitleHRlcm4gYm9vbCBvbWFwXzMya190aW1lcl9pbml0KHZvaWQpOworZXh0ZXJuIGludCBfX2luaXQgb21hcF9pbml0X2Nsb2Nrc291cmNlXzMyayh2b2lkKTsKK2V4dGVybiB1bnNpZ25lZCBsb25nIGxvbmcgbm90cmFjZSBvbWFwXzMya19zY2hlZF9jbG9jayh2b2lkKTsKIAogZXh0ZXJuIHZvaWQgb21hcF9yZXNlcnZlKHZvaWQpOwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LW9tYXAvaW5jbHVkZS9wbGF0L29uZW5hbmQuaCBiL2FyY2gvYXJtL3BsYXQtb21hcC9pbmNsdWRlL3BsYXQvb25lbmFuZC5oCmluZGV4IDcyZjQzM2QuLmFmZmU4N2UgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtb21hcC9pbmNsdWRlL3BsYXQvb25lbmFuZC5oCisrKyBiL2FyY2gvYXJtL3BsYXQtb21hcC9pbmNsdWRlL3BsYXQvb25lbmFuZC5oCkBAIC0yMyw2ICsyMyw3IEBACiAJaW50ICAgICAgICAgICAgICAgICAgICAgKCpvbmVuYW5kX3NldHVwKSh2b2lkIF9faW9tZW0gKiwgaW50IGZyZXEpOwogCWludAkJCWRtYV9jaGFubmVsOwogCXU4CQkJZmxhZ3M7CisJdTgJCQlyZWd1bGF0b3JfY2FuX3NsZWVwOwogfTsKIAogI2RlZmluZSBPTkVOQU5EX01BWF9QQVJUSVRJT05TIDgKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtb21hcC9pbmNsdWRlL3BsYXQvdm9sdGFnZS5oIGIvYXJjaC9hcm0vcGxhdC1vbWFwL2luY2x1ZGUvcGxhdC92b2x0YWdlLmgKaW5kZXggMGZmMTIzMy4uNWJkMjA0ZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1vbWFwL2luY2x1ZGUvcGxhdC92b2x0YWdlLmgKKysrIGIvYXJjaC9hcm0vcGxhdC1vbWFwL2luY2x1ZGUvcGxhdC92b2x0YWdlLmgKQEAgLTE0LDYgKzE0LDggQEAKICNpZm5kZWYgX19BUkNIX0FSTV9NQUNIX09NQVAyX1ZPTFRBR0VfSAogI2RlZmluZSBfX0FSQ0hfQVJNX01BQ0hfT01BUDJfVk9MVEFHRV9ICiAKKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KKwogI2RlZmluZSBWT0xUU0NBTEVfVlBGT1JDRVVQREFURQkJMQogI2RlZmluZSBWT0xUU0NBTEVfVkNCWVBBU1MJCTIKIApAQCAtNjUsOSArNjcsNiBAQAogCWNoYXIgKm5hbWU7CiB9OwogCi0vKiBBUEkgdG8gZ2V0IHRoZSB2b2x0YWdlZG9tYWluIHBvaW50ZXIgKi8KLXN0cnVjdCB2b2x0YWdlZG9tYWluICpvbWFwX3ZvbHRhZ2VfZG9tYWluX2xvb2t1cChjaGFyICpuYW1lKTsKLQogLyoqCiAgKiBzdHJ1Y3Qgb21hcF92b2x0X2RhdGEgLSBPbWFwIHZvbHRhZ2Ugc3BlY2lmaWMgZGF0YS4KICAqIEB2b2x0YWdlX25vbWluYWw6CVRoZSBwb3NzaWJsZSB2b2x0YWdlIHZhbHVlIGluIHVWCkBAIC0xMzEsMTYgKzEzMCwyNiBAQAogCQlzdHJ1Y3Qgb21hcF92b2x0X3BtaWNfaW5mbyAqcG1pY19pbmZvKTsKIHZvaWQgb21hcF9jaGFuZ2Vfdm9sdHNjYWxlX21ldGhvZChzdHJ1Y3Qgdm9sdGFnZWRvbWFpbiAqdm9sdGRtLAogCQlpbnQgdm9sdHNjYWxlX21ldGhvZCk7CisvKiBBUEkgdG8gZ2V0IHRoZSB2b2x0YWdlZG9tYWluIHBvaW50ZXIgKi8KK3N0cnVjdCB2b2x0YWdlZG9tYWluICpvbWFwX3ZvbHRhZ2VfZG9tYWluX2xvb2t1cChjaGFyICpuYW1lKTsKKwogaW50IG9tYXBfdm9sdGFnZV9sYXRlX2luaXQodm9pZCk7CiAjZWxzZQogc3RhdGljIGlubGluZSBpbnQgb21hcF92b2x0YWdlX3JlZ2lzdGVyX3BtaWMoc3RydWN0IHZvbHRhZ2Vkb21haW4gKnZvbHRkbSwKLQkJc3RydWN0IG9tYXBfdm9sdF9wbWljX2luZm8gKnBtaWNfaW5mbykge30KKwkJc3RydWN0IG9tYXBfdm9sdF9wbWljX2luZm8gKnBtaWNfaW5mbykKK3sKKwlyZXR1cm4gLUVJTlZBTDsKK30KIHN0YXRpYyBpbmxpbmUgIHZvaWQgb21hcF9jaGFuZ2Vfdm9sdHNjYWxlX21ldGhvZChzdHJ1Y3Qgdm9sdGFnZWRvbWFpbiAqdm9sdGRtLAogCQlpbnQgdm9sdHNjYWxlX21ldGhvZCkge30KIHN0YXRpYyBpbmxpbmUgaW50IG9tYXBfdm9sdGFnZV9sYXRlX2luaXQodm9pZCkKIHsKIAlyZXR1cm4gLUVJTlZBTDsKIH0KK3N0YXRpYyBpbmxpbmUgc3RydWN0IHZvbHRhZ2Vkb21haW4gKm9tYXBfdm9sdGFnZV9kb21haW5fbG9va3VwKGNoYXIgKm5hbWUpCit7CisJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7Cit9CiAjZW5kaWYKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LW9yaW9uL2dwaW8uYyBiL2FyY2gvYXJtL3BsYXQtb3Jpb24vZ3Bpby5jCmluZGV4IGU4MTQ4MDMuLjVmMzUyMjMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtb3Jpb24vZ3Bpby5jCisrKyBiL2FyY2gvYXJtL3BsYXQtb3Jpb24vZ3Bpby5jCkBAIC0yMzIsMjAgKzIzMiwxOSBAQAogICogICAgICAgIHBvbGFyaXR5ICAgIExFVkVMICAgICAgICAgIG1hc2sKICAqCiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLQotc3RhdGljIHZvaWQgZ3Bpb19pcnFfYWNrKHUzMiBpcnEpCitzdGF0aWMgdm9pZCBncGlvX2lycV9hY2soc3RydWN0IGlycV9kYXRhICpkKQogewotCWludCB0eXBlID0gaXJxX2Rlc2NbaXJxXS5zdGF0dXMgJiBJUlFfVFlQRV9TRU5TRV9NQVNLOworCWludCB0eXBlID0gaXJxX2Rlc2NbZC0+aXJxXS5zdGF0dXMgJiBJUlFfVFlQRV9TRU5TRV9NQVNLOwogCWlmICh0eXBlICYgKElSUV9UWVBFX0VER0VfUklTSU5HIHwgSVJRX1RZUEVfRURHRV9GQUxMSU5HKSkgewotCQlpbnQgcGluID0gaXJxX3RvX2dwaW8oaXJxKTsKKwkJaW50IHBpbiA9IGlycV90b19ncGlvKGQtPmlycSk7CiAJCXdyaXRlbCh+KDEgPDwgKHBpbiAmIDMxKSksIEdQSU9fRURHRV9DQVVTRShwaW4pKTsKIAl9CiB9CiAKLXN0YXRpYyB2b2lkIGdwaW9faXJxX21hc2sodTMyIGlycSkKK3N0YXRpYyB2b2lkIGdwaW9faXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkKQogewotCWludCBwaW4gPSBpcnFfdG9fZ3BpbyhpcnEpOwotCWludCB0eXBlID0gaXJxX2Rlc2NbaXJxXS5zdGF0dXMgJiBJUlFfVFlQRV9TRU5TRV9NQVNLOworCWludCBwaW4gPSBpcnFfdG9fZ3BpbyhkLT5pcnEpOworCWludCB0eXBlID0gaXJxX2Rlc2NbZC0+aXJxXS5zdGF0dXMgJiBJUlFfVFlQRV9TRU5TRV9NQVNLOwogCXUzMiByZWcgPSAodHlwZSAmIChJUlFfVFlQRV9FREdFX1JJU0lORyB8IElSUV9UWVBFX0VER0VfRkFMTElORykpID8KIAkJR1BJT19FREdFX01BU0socGluKSA6IEdQSU9fTEVWRUxfTUFTSyhwaW4pOwogCXUzMiB1ID0gcmVhZGwocmVnKTsKQEAgLTI1MywxMCArMjUyLDEwIEBACiAJd3JpdGVsKHUsIHJlZyk7CiB9CiAKLXN0YXRpYyB2b2lkIGdwaW9faXJxX3VubWFzayh1MzIgaXJxKQorc3RhdGljIHZvaWQgZ3Bpb19pcnFfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpbnQgcGluID0gaXJxX3RvX2dwaW8oaXJxKTsKLQlpbnQgdHlwZSA9IGlycV9kZXNjW2lycV0uc3RhdHVzICYgSVJRX1RZUEVfU0VOU0VfTUFTSzsKKwlpbnQgcGluID0gaXJxX3RvX2dwaW8oZC0+aXJxKTsKKwlpbnQgdHlwZSA9IGlycV9kZXNjW2QtPmlycV0uc3RhdHVzICYgSVJRX1RZUEVfU0VOU0VfTUFTSzsKIAl1MzIgcmVnID0gKHR5cGUgJiAoSVJRX1RZUEVfRURHRV9SSVNJTkcgfCBJUlFfVFlQRV9FREdFX0ZBTExJTkcpKSA/CiAJCUdQSU9fRURHRV9NQVNLKHBpbikgOiBHUElPX0xFVkVMX01BU0socGluKTsKIAl1MzIgdSA9IHJlYWRsKHJlZyk7CkBAIC0yNjQsMjAgKzI2MywyMCBAQAogCXdyaXRlbCh1LCByZWcpOwogfQogCi1zdGF0aWMgaW50IGdwaW9faXJxX3NldF90eXBlKHUzMiBpcnEsIHUzMiB0eXBlKQorc3RhdGljIGludCBncGlvX2lycV9zZXRfdHlwZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHUzMiB0eXBlKQogewotCWludCBwaW4gPSBpcnFfdG9fZ3BpbyhpcnEpOworCWludCBwaW4gPSBpcnFfdG9fZ3BpbyhkLT5pcnEpOwogCXN0cnVjdCBpcnFfZGVzYyAqZGVzYzsKIAl1MzIgdTsKIAogCXUgPSByZWFkbChHUElPX0lPX0NPTkYocGluKSkgJiAoMSA8PCAocGluICYgMzEpKTsKIAlpZiAoIXUpIHsKIAkJcHJpbnRrKEtFUk5fRVJSICJvcmlvbiBncGlvX2lycV9zZXRfdHlwZSBmYWlsZWQgIgotCQkJCSIoaXJxICVkLCBwaW4gJWQpLlxuIiwgaXJxLCBwaW4pOworCQkJCSIoaXJxICVkLCBwaW4gJWQpLlxuIiwgZC0+aXJxLCBwaW4pOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKLQlkZXNjID0gaXJxX2Rlc2MgKyBpcnE7CisJZGVzYyA9IGlycV9kZXNjICsgZC0+aXJxOwogCiAJLyoKIAkgKiBTZXQgZWRnZS9sZXZlbCB0eXBlLgpAQCAtMjg3LDcgKzI4Niw3IEBACiAJfSBlbHNlIGlmICh0eXBlICYgKElSUV9UWVBFX0xFVkVMX0hJR0ggfCBJUlFfVFlQRV9MRVZFTF9MT1cpKSB7CiAJCWRlc2MtPmhhbmRsZV9pcnEgPSBoYW5kbGVfbGV2ZWxfaXJxOwogCX0gZWxzZSB7Ci0JCXByaW50ayhLRVJOX0VSUiAiZmFpbGVkIHRvIHNldCBpcnE9JWQgKHR5cGU9JWQpXG4iLCBpcnEsIHR5cGUpOworCQlwcmludGsoS0VSTl9FUlIgImZhaWxlZCB0byBzZXQgaXJxPSVkICh0eXBlPSVkKVxuIiwgZC0+aXJxLCB0eXBlKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCkBAIC0zMjUsMTAgKzMyNCwxMCBAQAogCiBzdHJ1Y3QgaXJxX2NoaXAgb3Jpb25fZ3Bpb19pcnFfY2hpcCA9IHsKIAkubmFtZQkJPSAib3Jpb25fZ3Bpb19pcnEiLAotCS5hY2sJCT0gZ3Bpb19pcnFfYWNrLAotCS5tYXNrCQk9IGdwaW9faXJxX21hc2ssCi0JLnVubWFzawkJPSBncGlvX2lycV91bm1hc2ssCi0JLnNldF90eXBlCT0gZ3Bpb19pcnFfc2V0X3R5cGUsCisJLmlycV9hY2sJPSBncGlvX2lycV9hY2ssCisJLmlycV9tYXNrCT0gZ3Bpb19pcnFfbWFzaywKKwkuaXJxX3VubWFzawk9IGdwaW9faXJxX3VubWFzaywKKwkuaXJxX3NldF90eXBlCT0gZ3Bpb19pcnFfc2V0X3R5cGUsCiB9OwogCiB2b2lkIG9yaW9uX2dwaW9faXJxX2hhbmRsZXIoaW50IHBpbm9mZikKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtb3Jpb24vaXJxLmMgYi9hcmNoL2FybS9wbGF0LW9yaW9uL2lycS5jCmluZGV4IDNmOWQzNGYuLjdkMGM3ZWIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtb3Jpb24vaXJxLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1vcmlvbi9pcnEuYwpAQCAtMTQsMzEgKzE0LDMxIEBACiAjaW5jbHVkZSA8bGludXgvaW8uaD4KICNpbmNsdWRlIDxwbGF0L2lycS5oPgogCi1zdGF0aWMgdm9pZCBvcmlvbl9pcnFfbWFzayh1MzIgaXJxKQorc3RhdGljIHZvaWQgb3Jpb25faXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkKQogewotCXZvaWQgX19pb21lbSAqbWFza2FkZHIgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXZvaWQgX19pb21lbSAqbWFza2FkZHIgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKIAl1MzIgbWFzazsKIAogCW1hc2sgPSByZWFkbChtYXNrYWRkcik7Ci0JbWFzayAmPSB+KDEgPDwgKGlycSAmIDMxKSk7CisJbWFzayAmPSB+KDEgPDwgKGQtPmlycSAmIDMxKSk7CiAJd3JpdGVsKG1hc2ssIG1hc2thZGRyKTsKIH0KIAotc3RhdGljIHZvaWQgb3Jpb25faXJxX3VubWFzayh1MzIgaXJxKQorc3RhdGljIHZvaWQgb3Jpb25faXJxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jdm9pZCBfX2lvbWVtICptYXNrYWRkciA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJdm9pZCBfX2lvbWVtICptYXNrYWRkciA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOwogCXUzMiBtYXNrOwogCiAJbWFzayA9IHJlYWRsKG1hc2thZGRyKTsKLQltYXNrIHw9IDEgPDwgKGlycSAmIDMxKTsKKwltYXNrIHw9IDEgPDwgKGQtPmlycSAmIDMxKTsKIAl3cml0ZWwobWFzaywgbWFza2FkZHIpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG9yaW9uX2lycV9jaGlwID0gewogCS5uYW1lCQk9ICJvcmlvbl9pcnEiLAotCS5tYXNrCQk9IG9yaW9uX2lycV9tYXNrLAotCS5tYXNrX2Fjawk9IG9yaW9uX2lycV9tYXNrLAotCS51bm1hc2sJCT0gb3Jpb25faXJxX3VubWFzaywKKwkuaXJxX21hc2sJPSBvcmlvbl9pcnFfbWFzaywKKwkuaXJxX21hc2tfYWNrCT0gb3Jpb25faXJxX21hc2ssCisJLmlycV91bm1hc2sJPSBvcmlvbl9pcnFfdW5tYXNrLAogfTsKIAogdm9pZCBfX2luaXQgb3Jpb25faXJxX2luaXQodW5zaWduZWQgaW50IGlycV9zdGFydCwgdm9pZCBfX2lvbWVtICptYXNrYWRkcikKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtcHhhL2dwaW8uYyBiL2FyY2gvYXJtL3BsYXQtcHhhL2dwaW8uYwppbmRleCA5ODU0OGM2Li5lN2RlNmFlIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXB4YS9ncGlvLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1weGEvZ3Bpby5jCkBAIC0xNTUsMTAgKzE1NSwxMCBAQAogCV9fcmF3X3dyaXRlbChnZmVyLCBjLT5yZWdiYXNlICsgR0ZFUl9PRkZTRVQpOwogfQogCi1zdGF0aWMgaW50IHB4YV9ncGlvX2lycV90eXBlKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCB0eXBlKQorc3RhdGljIGludCBweGFfZ3Bpb19pcnFfdHlwZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCB0eXBlKQogewogCXN0cnVjdCBweGFfZ3Bpb19jaGlwICpjOwotCWludCBncGlvID0gaXJxX3RvX2dwaW8oaXJxKTsKKwlpbnQgZ3BpbyA9IGlycV90b19ncGlvKGQtPmlycSk7CiAJdW5zaWduZWQgbG9uZyBncGRyLCBtYXNrID0gR1BJT19iaXQoZ3Bpbyk7CiAKIAljID0gZ3Bpb190b19jaGlwKGdwaW8pOwpAQCAtMTk1LDcgKzE5NSw3IEBACiAKIAl1cGRhdGVfZWRnZV9kZXRlY3QoYyk7CiAKLQlwcl9kZWJ1ZygiJXM6IElSUSVkIChHUElPJWQpIC0gZWRnZSVzJXNcbiIsIF9fZnVuY19fLCBpcnEsIGdwaW8sCisJcHJfZGVidWcoIiVzOiBJUlElZCAoR1BJTyVkKSAtIGVkZ2UlcyVzXG4iLCBfX2Z1bmNfXywgZC0+aXJxLCBncGlvLAogCQkoKHR5cGUgJiBJUlFfVFlQRV9FREdFX1JJU0lORykgID8gIiByaXNpbmciICA6ICIiKSwKIAkJKCh0eXBlICYgSVJRX1RZUEVfRURHRV9GQUxMSU5HKSA/ICIgZmFsbGluZyIgOiAiIikpOwogCXJldHVybiAwOwpAQCAtMjI3LDE3ICsyMjcsMTcgQEAKIAl9IHdoaWxlIChsb29wKTsKIH0KIAotc3RhdGljIHZvaWQgcHhhX2Fja19tdXhlZF9ncGlvKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBweGFfYWNrX211eGVkX2dwaW8oc3RydWN0IGlycV9kYXRhICpkKQogewotCWludCBncGlvID0gaXJxX3RvX2dwaW8oaXJxKTsKKwlpbnQgZ3BpbyA9IGlycV90b19ncGlvKGQtPmlycSk7CiAJc3RydWN0IHB4YV9ncGlvX2NoaXAgKmMgPSBncGlvX3RvX2NoaXAoZ3Bpbyk7CiAKIAlfX3Jhd193cml0ZWwoR1BJT19iaXQoZ3BpbyksIGMtPnJlZ2Jhc2UgKyBHRURSX09GRlNFVCk7CiB9CiAKLXN0YXRpYyB2b2lkIHB4YV9tYXNrX211eGVkX2dwaW8odW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHB4YV9tYXNrX211eGVkX2dwaW8oc3RydWN0IGlycV9kYXRhICpkKQogewotCWludCBncGlvID0gaXJxX3RvX2dwaW8oaXJxKTsKKwlpbnQgZ3BpbyA9IGlycV90b19ncGlvKGQtPmlycSk7CiAJc3RydWN0IHB4YV9ncGlvX2NoaXAgKmMgPSBncGlvX3RvX2NoaXAoZ3Bpbyk7CiAJdWludDMyX3QgZ3JlciwgZ2ZlcjsKIApAQCAtMjQ5LDkgKzI0OSw5IEBACiAJX19yYXdfd3JpdGVsKGdmZXIsIGMtPnJlZ2Jhc2UgKyBHRkVSX09GRlNFVCk7CiB9CiAKLXN0YXRpYyB2b2lkIHB4YV91bm1hc2tfbXV4ZWRfZ3Bpbyh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgcHhhX3VubWFza19tdXhlZF9ncGlvKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlpbnQgZ3BpbyA9IGlycV90b19ncGlvKGlycSk7CisJaW50IGdwaW8gPSBpcnFfdG9fZ3BpbyhkLT5pcnEpOwogCXN0cnVjdCBweGFfZ3Bpb19jaGlwICpjID0gZ3Bpb190b19jaGlwKGdwaW8pOwogCiAJYy0+aXJxX21hc2sgfD0gR1BJT19iaXQoZ3Bpbyk7CkBAIC0yNjAsMTAgKzI2MCwxMCBAQAogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHB4YV9tdXhlZF9ncGlvX2NoaXAgPSB7CiAJLm5hbWUJCT0gIkdQSU8iLAotCS5hY2sJCT0gcHhhX2Fja19tdXhlZF9ncGlvLAotCS5tYXNrCQk9IHB4YV9tYXNrX211eGVkX2dwaW8sCi0JLnVubWFzawkJPSBweGFfdW5tYXNrX211eGVkX2dwaW8sCi0JLnNldF90eXBlCT0gcHhhX2dwaW9faXJxX3R5cGUsCisJLmlycV9hY2sJPSBweGFfYWNrX211eGVkX2dwaW8sCisJLmlycV9tYXNrCT0gcHhhX21hc2tfbXV4ZWRfZ3BpbywKKwkuaXJxX3VubWFzawk9IHB4YV91bm1hc2tfbXV4ZWRfZ3BpbywKKwkuaXJxX3NldF90eXBlCT0gcHhhX2dwaW9faXJxX3R5cGUsCiB9OwogCiB2b2lkIF9faW5pdCBweGFfaW5pdF9ncGlvKGludCBtdXhfaXJxLCBpbnQgc3RhcnQsIGludCBlbmQsIHNldF93YWtlX3QgZm4pCkBAIC0yOTEsNyArMjkxLDcgQEAKIAogCS8qIEluc3RhbGwgaGFuZGxlciBmb3IgR1BJTz49MiBlZGdlIGRldGVjdCBpbnRlcnJ1cHRzICovCiAJc2V0X2lycV9jaGFpbmVkX2hhbmRsZXIobXV4X2lycSwgcHhhX2dwaW9fZGVtdXhfaGFuZGxlcik7Ci0JcHhhX211eGVkX2dwaW9fY2hpcC5zZXRfd2FrZSA9IGZuOworCXB4YV9tdXhlZF9ncGlvX2NoaXAuaXJxX3NldF93YWtlID0gZm47CiB9CiAKICNpZmRlZiBDT05GSUdfUE0KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtcHhhL2luY2x1ZGUvcGxhdC9ncGlvLmggYi9hcmNoL2FybS9wbGF0LXB4YS9pbmNsdWRlL3BsYXQvZ3Bpby5oCmluZGV4IDQ0MjQ4Y2IuLjFkZGQyYjkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtcHhhL2luY2x1ZGUvcGxhdC9ncGlvLmgKKysrIGIvYXJjaC9hcm0vcGxhdC1weGEvaW5jbHVkZS9wbGF0L2dwaW8uaApAQCAtMSw2ICsxLDggQEAKICNpZm5kZWYgX19QTEFUX0dQSU9fSAogI2RlZmluZSBfX1BMQVRfR1BJT19ICiAKK3N0cnVjdCBpcnFfZGF0YTsKKwogLyoKICAqIFdlIGhhbmRsZSB0aGUgR1BJT3MgYnkgYmFua3MsIGVhY2ggYmFuayBjb3ZlcnMgdXAgdG8gMzIgR1BJT3Mgd2l0aAogICogb25lIHNldCBvZiByZWdpc3RlcnMuIFRoZSByZWdpc3RlciBvZmZzZXRzIGFyZSBvcmdhbml6ZWQgYmVsb3c6CkBAIC01Niw3ICs1OCw3IEBACiAgKi8KIGV4dGVybiBpbnQgcHhhX2xhc3RfZ3BpbzsKIAotdHlwZWRlZiBpbnQgKCpzZXRfd2FrZV90KSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgb24pOwordHlwZWRlZiBpbnQgKCpzZXRfd2FrZV90KShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCBvbik7CiAKIGV4dGVybiB2b2lkIHB4YV9pbml0X2dwaW8oaW50IG11eF9pcnEsIGludCBzdGFydCwgaW50IGVuZCwgc2V0X3dha2VfdCBmbik7CiAjZW5kaWYgLyogX19QTEFUX0dQSU9fSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1zM2MyNHh4L2RldnMuYyBiL2FyY2gvYXJtL3BsYXQtczNjMjR4eC9kZXZzLmMKaW5kZXggOGE0MmJjNC4uMjY4ZjNlZCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1zM2MyNHh4L2RldnMuYworKysgYi9hcmNoL2FybS9wbGF0LXMzYzI0eHgvZGV2cy5jCkBAIC0xOTQsNyArMTk0LDYgQEAKIAltZW1jcHkoJnMzYzI0MTB0c19pbmZvLCBoYXJkX3MzYzI0MTB0c19pbmZvLCBzaXplb2Yoc3RydWN0IHMzYzI0MTBfdHNfbWFjaF9pbmZvKSk7CiAJczNjX2RldmljZV90cy5kZXYucGxhdGZvcm1fZGF0YSA9ICZzM2MyNDEwdHNfaW5mbzsKIH0KLUVYUE9SVF9TWU1CT0woczNjMjR4eF90c19zZXRfcGxhdGRhdGEpOwogCiAvKiBVU0IgRGV2aWNlIChHYWRnZXQpKi8KIApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1zM2MyNHh4L2luY2x1ZGUvcGxhdC9pcnEuaCBiL2FyY2gvYXJtL3BsYXQtczNjMjR4eC9pbmNsdWRlL3BsYXQvaXJxLmgKaW5kZXggNjllMWJlOC4uZWMwODdkNiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1zM2MyNHh4L2luY2x1ZGUvcGxhdC9pcnEuaAorKysgYi9hcmNoL2FybS9wbGF0LXMzYzI0eHgvaW5jbHVkZS9wbGF0L2lycS5oCkBAIC0xMDcsOSArMTA3LDkgQEAKIC8qIGV4cG9ydGVkIGZvciB1c2UgaW4gYXJjaC9hcm0vbWFjaC1zM2MyNDEwICovCiAKICNpZmRlZiBDT05GSUdfUE0KLWV4dGVybiBpbnQgczNjX2lycV93YWtlKHVuc2lnbmVkIGludCBpcnFubywgdW5zaWduZWQgaW50IHN0YXRlKTsKK2V4dGVybiBpbnQgczNjX2lycV93YWtlKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSwgdW5zaWduZWQgaW50IHN0YXRlKTsKICNlbHNlCiAjZGVmaW5lIHMzY19pcnFfd2FrZSBOVUxMCiAjZW5kaWYKIAotZXh0ZXJuIGludCBzM2NfaXJxZXh0X3R5cGUodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IHR5cGUpOworZXh0ZXJuIGludCBzM2NfaXJxZXh0X3R5cGUoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgdHlwZSk7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXMzYzI0eHgvaXJxLXBtLmMgYi9hcmNoL2FybS9wbGF0LXMzYzI0eHgvaXJxLXBtLmMKaW5kZXggZWE4ZGVhMy4uYzM2MjRkOCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1zM2MyNHh4L2lycS1wbS5jCisrKyBiL2FyY2gvYXJtL3BsYXQtczNjMjR4eC9pcnEtcG0uYwpAQCAtMTUsMTEgKzE1LDE0IEBACiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiAjaW5jbHVkZSA8bGludXgvc3lzZGV2Lmg+CisjaW5jbHVkZSA8bGludXgvaXJxLmg+CiAKICNpbmNsdWRlIDxwbGF0L2NwdS5oPgogI2luY2x1ZGUgPHBsYXQvcG0uaD4KICNpbmNsdWRlIDxwbGF0L2lycS5oPgogCisjaW5jbHVkZSA8YXNtL2lycS5oPgorCiAvKiBzdGF0ZSBmb3IgSVJRcyBvdmVyIHNsZWVwICovCiAKIC8qIGRlZmF1bHQgaXMgdG8gYWxsb3cgZm9yIEVJTlQwLi5FSU5UMTUsIGFuZCBJUlFfUlRDIGFzIHdha2V1cCBzb3VyY2VzCkBAIC0zMCwxNSArMzMsMTUgQEAKIHVuc2lnbmVkIGxvbmcgczNjX2lycXdha2VfaW50YWxsb3cJPSAxTCA8PCAoSVJRX1JUQyAtIElSUV9FSU5UMCkgfCAweGZMOwogdW5zaWduZWQgbG9uZyBzM2NfaXJxd2FrZV9laW50YWxsb3cJPSAweDAwMDBmZmYwTDsKIAotaW50IHMzY19pcnFfd2FrZSh1bnNpZ25lZCBpbnQgaXJxbm8sIHVuc2lnbmVkIGludCBzdGF0ZSkKK2ludCBzM2NfaXJxX3dha2Uoc3RydWN0IGlycV9kYXRhICpkYXRhLCB1bnNpZ25lZCBpbnQgc3RhdGUpCiB7Ci0JdW5zaWduZWQgbG9uZyBpcnFiaXQgPSAxIDw8IChpcnFubyAtIElSUV9FSU5UMCk7CisJdW5zaWduZWQgbG9uZyBpcnFiaXQgPSAxIDw8IChkYXRhLT5pcnEgLSBJUlFfRUlOVDApOwogCiAJaWYgKCEoczNjX2lycXdha2VfaW50YWxsb3cgJiBpcnFiaXQpKQogCQlyZXR1cm4gLUVOT0VOVDsKIAogCXByaW50ayhLRVJOX0lORk8gIndha2UgJXMgZm9yIGlycSAlZFxuIiwKLQkgICAgICAgc3RhdGUgPyAiZW5hYmxlZCIgOiAiZGlzYWJsZWQiLCBpcnFubyk7CisJICAgICAgIHN0YXRlID8gImVuYWJsZWQiIDogImRpc2FibGVkIiwgZGF0YS0+aXJxKTsKIAogCWlmICghc3RhdGUpCiAJCXMzY19pcnF3YWtlX2ludG1hc2sgfD0gaXJxYml0OwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1zM2MyNHh4L2lycS5jIGIvYXJjaC9hcm0vcGxhdC1zM2MyNHh4L2lycS5jCmluZGV4IGFkMGQ0NGUuLjQ0MzRjYjUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtczNjMjR4eC9pcnEuYworKysgYi9hcmNoL2FybS9wbGF0LXMzYzI0eHgvaXJxLmMKQEAgLTM0LDMwICszNCwyOSBAQAogI2luY2x1ZGUgPHBsYXQvaXJxLmg+CiAKIHN0YXRpYyB2b2lkCi1zM2NfaXJxX21hc2sodW5zaWduZWQgaW50IGlycW5vKQorczNjX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKKwl1bnNpZ25lZCBpbnQgaXJxbm8gPSBkYXRhLT5pcnEgLSBJUlFfRUlOVDA7CiAJdW5zaWduZWQgbG9uZyBtYXNrOwogCi0JaXJxbm8gLT0gSVJRX0VJTlQwOwotCiAJbWFzayA9IF9fcmF3X3JlYWRsKFMzQzI0MTBfSU5UTVNLKTsKIAltYXNrIHw9IDFVTCA8PCBpcnFubzsKIAlfX3Jhd193cml0ZWwobWFzaywgUzNDMjQxMF9JTlRNU0spOwogfQogCiBzdGF0aWMgaW5saW5lIHZvaWQKLXMzY19pcnFfYWNrKHVuc2lnbmVkIGludCBpcnFubykKK3MzY19pcnFfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQl1bnNpZ25lZCBsb25nIGJpdHZhbCA9IDFVTCA8PCAoaXJxbm8gLSBJUlFfRUlOVDApOworCXVuc2lnbmVkIGxvbmcgYml0dmFsID0gMVVMIDw8IChkYXRhLT5pcnEgLSBJUlFfRUlOVDApOwogCiAJX19yYXdfd3JpdGVsKGJpdHZhbCwgUzNDMjQxMF9TUkNQTkQpOwogCV9fcmF3X3dyaXRlbChiaXR2YWwsIFMzQzI0MTBfSU5UUE5EKTsKIH0KIAogc3RhdGljIGlubGluZSB2b2lkCi1zM2NfaXJxX21hc2thY2sodW5zaWduZWQgaW50IGlycW5vKQorczNjX2lycV9tYXNrYWNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQl1bnNpZ25lZCBsb25nIGJpdHZhbCA9IDFVTCA8PCAoaXJxbm8gLSBJUlFfRUlOVDApOworCXVuc2lnbmVkIGxvbmcgYml0dmFsID0gMVVMIDw8IChkYXRhLT5pcnEgLSBJUlFfRUlOVDApOwogCXVuc2lnbmVkIGxvbmcgbWFzazsKIAogCW1hc2sgPSBfX3Jhd19yZWFkbChTM0MyNDEwX0lOVE1TSyk7CkBAIC02OSw4ICs2OCw5IEBACiAKIAogc3RhdGljIHZvaWQKLXMzY19pcnFfdW5tYXNrKHVuc2lnbmVkIGludCBpcnFubykKK3MzY19pcnFfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKKwl1bnNpZ25lZCBpbnQgaXJxbm8gPSBkYXRhLT5pcnE7CiAJdW5zaWduZWQgbG9uZyBtYXNrOwogCiAJaWYgKGlycW5vICE9IElSUV9USU1FUjQgJiYgaXJxbm8gIT0gSVJRX0VJTlQ4dDIzKQpAQCAtODUsNDAgKzg1LDM5IEBACiAKIHN0cnVjdCBpcnFfY2hpcCBzM2NfaXJxX2xldmVsX2NoaXAgPSB7CiAJLm5hbWUJCT0gInMzYy1sZXZlbCIsCi0JLmFjawkJPSBzM2NfaXJxX21hc2thY2ssCi0JLm1hc2sJCT0gczNjX2lycV9tYXNrLAotCS51bm1hc2sJCT0gczNjX2lycV91bm1hc2ssCi0JLnNldF93YWtlCT0gczNjX2lycV93YWtlCisJLmlycV9hY2sJPSBzM2NfaXJxX21hc2thY2ssCisJLmlycV9tYXNrCT0gczNjX2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gczNjX2lycV91bm1hc2ssCisJLmlycV9zZXRfd2FrZQk9IHMzY19pcnFfd2FrZQogfTsKIAogc3RydWN0IGlycV9jaGlwIHMzY19pcnFfY2hpcCA9IHsKIAkubmFtZQkJPSAiczNjIiwKLQkuYWNrCQk9IHMzY19pcnFfYWNrLAotCS5tYXNrCQk9IHMzY19pcnFfbWFzaywKLQkudW5tYXNrCQk9IHMzY19pcnFfdW5tYXNrLAotCS5zZXRfd2FrZQk9IHMzY19pcnFfd2FrZQorCS5pcnFfYWNrCT0gczNjX2lycV9hY2ssCisJLmlycV9tYXNrCT0gczNjX2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gczNjX2lycV91bm1hc2ssCisJLmlycV9zZXRfd2FrZQk9IHMzY19pcnFfd2FrZQogfTsKIAogc3RhdGljIHZvaWQKLXMzY19pcnFleHRfbWFzayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzM2NfaXJxZXh0X21hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogeworCXVuc2lnbmVkIGludCBpcnFubyA9IGRhdGEtPmlycSAtIEVYVElOVF9PRkY7CiAJdW5zaWduZWQgbG9uZyBtYXNrOwogCi0JaXJxbm8gLT0gRVhUSU5UX09GRjsKLQogCW1hc2sgPSBfX3Jhd19yZWFkbChTM0MyNFhYX0VJTlRNQVNLKTsKIAltYXNrIHw9ICggMVVMIDw8IGlycW5vKTsKIAlfX3Jhd193cml0ZWwobWFzaywgUzNDMjRYWF9FSU5UTUFTSyk7CiB9CiAKIHN0YXRpYyB2b2lkCi1zM2NfaXJxZXh0X2Fjayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzM2NfaXJxZXh0X2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7CiAJdW5zaWduZWQgbG9uZyByZXE7CiAJdW5zaWduZWQgbG9uZyBiaXQ7CiAJdW5zaWduZWQgbG9uZyBtYXNrOwogCi0JYml0ID0gMVVMIDw8IChpcnFubyAtIEVYVElOVF9PRkYpOworCWJpdCA9IDFVTCA8PCAoZGF0YS0+aXJxIC0gRVhUSU5UX09GRik7CiAKIAltYXNrID0gX19yYXdfcmVhZGwoUzNDMjRYWF9FSU5UTUFTSyk7CiAKQEAgLTEyOSw2NCArMTI4LDU3IEBACiAKIAkvKiBub3Qgc3VyZSBpZiB3ZSBzaG91bGQgYmUgYWNraW5nIHRoZSBwYXJlbnQgaXJxLi4uICovCiAKLQlpZiAoaXJxbm8gPD0gSVJRX0VJTlQ3ICkgeworCWlmIChkYXRhLT5pcnEgPD0gSVJRX0VJTlQ3KSB7CiAJCWlmICgocmVxICYgMHhmMCkgPT0gMCkKLQkJCXMzY19pcnFfYWNrKElSUV9FSU5UNHQ3KTsKKwkJCXMzY19pcnFfYWNrKGlycV9nZXRfaXJxX2RhdGEoSVJRX0VJTlQ0dDcpKTsKIAl9IGVsc2UgewogCQlpZiAoKHJlcSA+PiA4KSA9PSAwKQotCQkJczNjX2lycV9hY2soSVJRX0VJTlQ4dDIzKTsKKwkJCXMzY19pcnFfYWNrKGlycV9nZXRfaXJxX2RhdGEoSVJRX0VJTlQ4dDIzKSk7CiAJfQogfQogCiBzdGF0aWMgdm9pZAotczNjX2lycWV4dF91bm1hc2sodW5zaWduZWQgaW50IGlycW5vKQorczNjX2lycWV4dF91bm1hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogeworCXVuc2lnbmVkIGludCBpcnFubyA9IGRhdGEtPmlycSAtIEVYVElOVF9PRkY7CiAJdW5zaWduZWQgbG9uZyBtYXNrOwogCi0JaXJxbm8gLT0gRVhUSU5UX09GRjsKLQogCW1hc2sgPSBfX3Jhd19yZWFkbChTM0MyNFhYX0VJTlRNQVNLKTsKLQltYXNrICY9IH4oIDFVTCA8PCBpcnFubyk7CisJbWFzayAmPSB+KDFVTCA8PCBpcnFubyk7CiAJX19yYXdfd3JpdGVsKG1hc2ssIFMzQzI0WFhfRUlOVE1BU0spOwogfQogCiBpbnQKLXMzY19pcnFleHRfdHlwZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgdHlwZSkKK3MzY19pcnFleHRfdHlwZShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEsIHVuc2lnbmVkIGludCB0eXBlKQogewogCXZvaWQgX19pb21lbSAqZXh0aW50X3JlZzsKIAl2b2lkIF9faW9tZW0gKmdwY29uX3JlZzsKIAl1bnNpZ25lZCBsb25nIGdwY29uX29mZnNldCwgZXh0aW50X29mZnNldDsKIAl1bnNpZ25lZCBsb25nIG5ld3ZhbHVlID0gMCwgdmFsdWU7CiAKLQlpZiAoKGlycSA+PSBJUlFfRUlOVDApICYmIChpcnEgPD0gSVJRX0VJTlQzKSkKLQl7CisJaWYgKChkYXRhLT5pcnEgPj0gSVJRX0VJTlQwKSAmJiAoZGF0YS0+aXJxIDw9IElSUV9FSU5UMykpIHsKIAkJZ3Bjb25fcmVnID0gUzNDMjQxMF9HUEZDT047CiAJCWV4dGludF9yZWcgPSBTM0MyNFhYX0VYVElOVDA7Ci0JCWdwY29uX29mZnNldCA9IChpcnEgLSBJUlFfRUlOVDApICogMjsKLQkJZXh0aW50X29mZnNldCA9IChpcnEgLSBJUlFfRUlOVDApICogNDsKLQl9Ci0JZWxzZSBpZiAoKGlycSA+PSBJUlFfRUlOVDQpICYmIChpcnEgPD0gSVJRX0VJTlQ3KSkKLQl7CisJCWdwY29uX29mZnNldCA9IChkYXRhLT5pcnEgLSBJUlFfRUlOVDApICogMjsKKwkJZXh0aW50X29mZnNldCA9IChkYXRhLT5pcnEgLSBJUlFfRUlOVDApICogNDsKKwl9IGVsc2UgaWYgKChkYXRhLT5pcnEgPj0gSVJRX0VJTlQ0KSAmJiAoZGF0YS0+aXJxIDw9IElSUV9FSU5UNykpIHsKIAkJZ3Bjb25fcmVnID0gUzNDMjQxMF9HUEZDT047CiAJCWV4dGludF9yZWcgPSBTM0MyNFhYX0VYVElOVDA7Ci0JCWdwY29uX29mZnNldCA9IChpcnEgLSAoRVhUSU5UX09GRikpICogMjsKLQkJZXh0aW50X29mZnNldCA9IChpcnEgLSAoRVhUSU5UX09GRikpICogNDsKLQl9Ci0JZWxzZSBpZiAoKGlycSA+PSBJUlFfRUlOVDgpICYmIChpcnEgPD0gSVJRX0VJTlQxNSkpCi0JeworCQlncGNvbl9vZmZzZXQgPSAoZGF0YS0+aXJxIC0gKEVYVElOVF9PRkYpKSAqIDI7CisJCWV4dGludF9vZmZzZXQgPSAoZGF0YS0+aXJxIC0gKEVYVElOVF9PRkYpKSAqIDQ7CisJfSBlbHNlIGlmICgoZGF0YS0+aXJxID49IElSUV9FSU5UOCkgJiYgKGRhdGEtPmlycSA8PSBJUlFfRUlOVDE1KSkgewogCQlncGNvbl9yZWcgPSBTM0MyNDEwX0dQR0NPTjsKIAkJZXh0aW50X3JlZyA9IFMzQzI0WFhfRVhUSU5UMTsKLQkJZ3Bjb25fb2Zmc2V0ID0gKGlycSAtIElSUV9FSU5UOCkgKiAyOwotCQlleHRpbnRfb2Zmc2V0ID0gKGlycSAtIElSUV9FSU5UOCkgKiA0OwotCX0KLQllbHNlIGlmICgoaXJxID49IElSUV9FSU5UMTYpICYmIChpcnEgPD0gSVJRX0VJTlQyMykpCi0JeworCQlncGNvbl9vZmZzZXQgPSAoZGF0YS0+aXJxIC0gSVJRX0VJTlQ4KSAqIDI7CisJCWV4dGludF9vZmZzZXQgPSAoZGF0YS0+aXJxIC0gSVJRX0VJTlQ4KSAqIDQ7CisJfSBlbHNlIGlmICgoZGF0YS0+aXJxID49IElSUV9FSU5UMTYpICYmIChkYXRhLT5pcnEgPD0gSVJRX0VJTlQyMykpIHsKIAkJZ3Bjb25fcmVnID0gUzNDMjQxMF9HUEdDT047CiAJCWV4dGludF9yZWcgPSBTM0MyNFhYX0VYVElOVDI7Ci0JCWdwY29uX29mZnNldCA9IChpcnEgLSBJUlFfRUlOVDgpICogMjsKLQkJZXh0aW50X29mZnNldCA9IChpcnEgLSBJUlFfRUlOVDE2KSAqIDQ7Ci0JfSBlbHNlCisJCWdwY29uX29mZnNldCA9IChkYXRhLT5pcnEgLSBJUlFfRUlOVDgpICogMjsKKwkJZXh0aW50X29mZnNldCA9IChkYXRhLT5pcnEgLSBJUlFfRUlOVDE2KSAqIDQ7CisJfSBlbHNlIHsKIAkJcmV0dXJuIC0xOworCX0KIAogCS8qIFNldCB0aGUgR1BJTyB0byBleHRlcm5hbCBpbnRlcnJ1cHQgbW9kZSAqLwogCXZhbHVlID0gX19yYXdfcmVhZGwoZ3Bjb25fcmVnKTsKQEAgLTIzNCwyMCArMjI2LDIwIEBACiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgczNjX2lycWV4dF9jaGlwID0gewogCS5uYW1lCQk9ICJzM2MtZXh0IiwKLQkubWFzawkJPSBzM2NfaXJxZXh0X21hc2ssCi0JLnVubWFzawkJPSBzM2NfaXJxZXh0X3VubWFzaywKLQkuYWNrCQk9IHMzY19pcnFleHRfYWNrLAotCS5zZXRfdHlwZQk9IHMzY19pcnFleHRfdHlwZSwKLQkuc2V0X3dha2UJPSBzM2NfaXJxZXh0X3dha2UKKwkuaXJxX21hc2sJPSBzM2NfaXJxZXh0X21hc2ssCisJLmlycV91bm1hc2sJPSBzM2NfaXJxZXh0X3VubWFzaywKKwkuaXJxX2Fjawk9IHMzY19pcnFleHRfYWNrLAorCS5pcnFfc2V0X3R5cGUJPSBzM2NfaXJxZXh0X3R5cGUsCisJLmlycV9zZXRfd2FrZQk9IHMzY19pcnFleHRfd2FrZQogfTsKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2NfaXJxX2VpbnQwdDQgPSB7CiAJLm5hbWUJCT0gInMzYy1leHQwIiwKLQkuYWNrCQk9IHMzY19pcnFfYWNrLAotCS5tYXNrCQk9IHMzY19pcnFfbWFzaywKLQkudW5tYXNrCQk9IHMzY19pcnFfdW5tYXNrLAotCS5zZXRfd2FrZQk9IHMzY19pcnFfd2FrZSwKLQkuc2V0X3R5cGUJPSBzM2NfaXJxZXh0X3R5cGUsCisJLmlycV9hY2sJPSBzM2NfaXJxX2FjaywKKwkuaXJxX21hc2sJPSBzM2NfaXJxX21hc2ssCisJLmlycV91bm1hc2sJPSBzM2NfaXJxX3VubWFzaywKKwkuaXJxX3NldF93YWtlCT0gczNjX2lycV93YWtlLAorCS5pcnFfc2V0X3R5cGUJPSBzM2NfaXJxZXh0X3R5cGUsCiB9OwogCiAvKiBtYXNrIHZhbHVlcyBmb3IgdGhlIHBhcmVudCByZWdpc3RlcnMgZm9yIGVhY2ggb2YgdGhlIGludGVycnVwdCB0eXBlcyAqLwpAQCAtMjYxLDEwOSArMjUzLDEwOSBAQAogLyogVUFSVDAgKi8KIAogc3RhdGljIHZvaWQKLXMzY19pcnFfdWFydDBfbWFzayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzM2NfaXJxX3VhcnQwX21hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXMzY19pcnFzdWJfbWFzayhpcnFubywgSU5UTVNLX1VBUlQwLCA3KTsKKwlzM2NfaXJxc3ViX21hc2soZGF0YS0+aXJxLCBJTlRNU0tfVUFSVDAsIDcpOwogfQogCiBzdGF0aWMgdm9pZAotczNjX2lycV91YXJ0MF91bm1hc2sodW5zaWduZWQgaW50IGlycW5vKQorczNjX2lycV91YXJ0MF91bm1hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXMzY19pcnFzdWJfdW5tYXNrKGlycW5vLCBJTlRNU0tfVUFSVDApOworCXMzY19pcnFzdWJfdW5tYXNrKGRhdGEtPmlycSwgSU5UTVNLX1VBUlQwKTsKIH0KIAogc3RhdGljIHZvaWQKLXMzY19pcnFfdWFydDBfYWNrKHVuc2lnbmVkIGludCBpcnFubykKK3MzY19pcnFfdWFydDBfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX21hc2thY2soaXJxbm8sIElOVE1TS19VQVJUMCwgNyk7CisJczNjX2lycXN1Yl9tYXNrYWNrKGRhdGEtPmlycSwgSU5UTVNLX1VBUlQwLCA3KTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2NfaXJxX3VhcnQwID0gewogCS5uYW1lCQk9ICJzM2MtdWFydDAiLAotCS5tYXNrCQk9IHMzY19pcnFfdWFydDBfbWFzaywKLQkudW5tYXNrCQk9IHMzY19pcnFfdWFydDBfdW5tYXNrLAotCS5hY2sJCT0gczNjX2lycV91YXJ0MF9hY2ssCisJLmlycV9tYXNrCT0gczNjX2lycV91YXJ0MF9tYXNrLAorCS5pcnFfdW5tYXNrCT0gczNjX2lycV91YXJ0MF91bm1hc2ssCisJLmlycV9hY2sJPSBzM2NfaXJxX3VhcnQwX2FjaywKIH07CiAKIC8qIFVBUlQxICovCiAKIHN0YXRpYyB2b2lkCi1zM2NfaXJxX3VhcnQxX21hc2sodW5zaWduZWQgaW50IGlycW5vKQorczNjX2lycV91YXJ0MV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX21hc2soaXJxbm8sIElOVE1TS19VQVJUMSwgNyA8PCAzKTsKKwlzM2NfaXJxc3ViX21hc2soZGF0YS0+aXJxLCBJTlRNU0tfVUFSVDEsIDcgPDwgMyk7CiB9CiAKIHN0YXRpYyB2b2lkCi1zM2NfaXJxX3VhcnQxX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzM2NfaXJxX3VhcnQxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl91bm1hc2soaXJxbm8sIElOVE1TS19VQVJUMSk7CisJczNjX2lycXN1Yl91bm1hc2soZGF0YS0+aXJxLCBJTlRNU0tfVUFSVDEpOwogfQogCiBzdGF0aWMgdm9pZAotczNjX2lycV91YXJ0MV9hY2sodW5zaWduZWQgaW50IGlycW5vKQorczNjX2lycV91YXJ0MV9hY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXMzY19pcnFzdWJfbWFza2FjayhpcnFubywgSU5UTVNLX1VBUlQxLCA3IDw8IDMpOworCXMzY19pcnFzdWJfbWFza2FjayhkYXRhLT5pcnEsIElOVE1TS19VQVJUMSwgNyA8PCAzKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2NfaXJxX3VhcnQxID0gewogCS5uYW1lCQk9ICJzM2MtdWFydDEiLAotCS5tYXNrCQk9IHMzY19pcnFfdWFydDFfbWFzaywKLQkudW5tYXNrCQk9IHMzY19pcnFfdWFydDFfdW5tYXNrLAotCS5hY2sJCT0gczNjX2lycV91YXJ0MV9hY2ssCisJLmlycV9tYXNrCT0gczNjX2lycV91YXJ0MV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gczNjX2lycV91YXJ0MV91bm1hc2ssCisJLmlycV9hY2sJPSBzM2NfaXJxX3VhcnQxX2FjaywKIH07CiAKIC8qIFVBUlQyICovCiAKIHN0YXRpYyB2b2lkCi1zM2NfaXJxX3VhcnQyX21hc2sodW5zaWduZWQgaW50IGlycW5vKQorczNjX2lycV91YXJ0Ml9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzM2NfaXJxc3ViX21hc2soaXJxbm8sIElOVE1TS19VQVJUMiwgNyA8PCA2KTsKKwlzM2NfaXJxc3ViX21hc2soZGF0YS0+aXJxLCBJTlRNU0tfVUFSVDIsIDcgPDwgNik7CiB9CiAKIHN0YXRpYyB2b2lkCi1zM2NfaXJxX3VhcnQyX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzM2NfaXJxX3VhcnQyX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczNjX2lycXN1Yl91bm1hc2soaXJxbm8sIElOVE1TS19VQVJUMik7CisJczNjX2lycXN1Yl91bm1hc2soZGF0YS0+aXJxLCBJTlRNU0tfVUFSVDIpOwogfQogCiBzdGF0aWMgdm9pZAotczNjX2lycV91YXJ0Ml9hY2sodW5zaWduZWQgaW50IGlycW5vKQorczNjX2lycV91YXJ0Ml9hY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXMzY19pcnFzdWJfbWFza2FjayhpcnFubywgSU5UTVNLX1VBUlQyLCA3IDw8IDYpOworCXMzY19pcnFzdWJfbWFza2FjayhkYXRhLT5pcnEsIElOVE1TS19VQVJUMiwgNyA8PCA2KTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2NfaXJxX3VhcnQyID0gewogCS5uYW1lCQk9ICJzM2MtdWFydDIiLAotCS5tYXNrCQk9IHMzY19pcnFfdWFydDJfbWFzaywKLQkudW5tYXNrCQk9IHMzY19pcnFfdWFydDJfdW5tYXNrLAotCS5hY2sJCT0gczNjX2lycV91YXJ0Ml9hY2ssCisJLmlycV9tYXNrCT0gczNjX2lycV91YXJ0Ml9tYXNrLAorCS5pcnFfdW5tYXNrCT0gczNjX2lycV91YXJ0Ml91bm1hc2ssCisJLmlycV9hY2sJPSBzM2NfaXJxX3VhcnQyX2FjaywKIH07CiAKIC8qIEFEQyBhbmQgVG91Y2hzY3JlZW4gKi8KIAogc3RhdGljIHZvaWQKLXMzY19pcnFfYWRjX21hc2sodW5zaWduZWQgaW50IGlycW5vKQorczNjX2lycV9hZGNfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0JczNjX2lycXN1Yl9tYXNrKGlycW5vLCBJTlRNU0tfQURDUEFSRU5ULCAzIDw8IDkpOworCXMzY19pcnFzdWJfbWFzayhkLT5pcnEsIElOVE1TS19BRENQQVJFTlQsIDMgPDwgOSk7CiB9CiAKIHN0YXRpYyB2b2lkCi1zM2NfaXJxX2FkY191bm1hc2sodW5zaWduZWQgaW50IGlycW5vKQorczNjX2lycV9hZGNfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlzM2NfaXJxc3ViX3VubWFzayhpcnFubywgSU5UTVNLX0FEQ1BBUkVOVCk7CisJczNjX2lycXN1Yl91bm1hc2soZC0+aXJxLCBJTlRNU0tfQURDUEFSRU5UKTsKIH0KIAogc3RhdGljIHZvaWQKLXMzY19pcnFfYWRjX2Fjayh1bnNpZ25lZCBpbnQgaXJxbm8pCitzM2NfaXJxX2FkY19hY2soc3RydWN0IGlycV9kYXRhICpkKQogewotCXMzY19pcnFzdWJfYWNrKGlycW5vLCBJTlRNU0tfQURDUEFSRU5ULCAzIDw8IDkpOworCXMzY19pcnFzdWJfYWNrKGQtPmlycSwgSU5UTVNLX0FEQ1BBUkVOVCwgMyA8PCA5KTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2NfaXJxX2FkYyA9IHsKIAkubmFtZQkJPSAiczNjLWFkYyIsCi0JLm1hc2sJCT0gczNjX2lycV9hZGNfbWFzaywKLQkudW5tYXNrCQk9IHMzY19pcnFfYWRjX3VubWFzaywKLQkuYWNrCQk9IHMzY19pcnFfYWRjX2FjaywKKwkuaXJxX21hc2sJPSBzM2NfaXJxX2FkY19tYXNrLAorCS5pcnFfdW5tYXNrCT0gczNjX2lycV9hZGNfdW5tYXNrLAorCS5pcnFfYWNrCT0gczNjX2lycV9hZGNfYWNrLAogfTsKIAogLyogaXJxIGRlbXV4IGZvciBhZGMgKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtczNjMjR4eC9zM2MyNDQzLWNsb2NrLmMgYi9hcmNoL2FybS9wbGF0LXMzYzI0eHgvczNjMjQ0My1jbG9jay5jCmluZGV4IDQ2MWYwNzAuLjgyZjJkNGEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtczNjMjR4eC9zM2MyNDQzLWNsb2NrLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1zM2MyNHh4L3MzYzI0NDMtY2xvY2suYwpAQCAtMjcxLDcgKzI3MSw3IEBACiAJCS5jdHJsYml0CT0gUzNDMjQ0M19IQ0xLQ09OX0RNQTUsCiAJfSwgewogCQkubmFtZQkJPSAiaHNtbWMiLAotCQkuaWQJCT0gMCwKKwkJLmlkCQk9IDEsCiAJCS5wYXJlbnQJCT0gJmNsa19oLAogCQkuZW5hYmxlCQk9IHMzYzI0NDNfY2xrY29uX2VuYWJsZV9oLAogCQkuY3RybGJpdAk9IFMzQzI0NDNfSENMS0NPTl9IU01NQywKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtczVwL0tjb25maWcgYi9hcmNoL2FybS9wbGF0LXM1cC9LY29uZmlnCmluZGV4IDY1ZGJmYTguLjU1N2Y4YzUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtczVwL0tjb25maWcKKysrIGIvYXJjaC9hcm0vcGxhdC1zNXAvS2NvbmZpZwpAQCAtMzcsNiArMzcsMTQgQEAKIAloZWxwCiAJICBDb21tb24gY29kZSBmb3IgdGhlIEdQSU8gaW50ZXJydXB0cyAob3RoZXIgdGhhbiBleHRlcm5hbCBpbnRlcnJ1cHRzLikKIAorY29tbWVudCAiU3lzdGVtIE1NVSIKKworY29uZmlnIFM1UF9TWVNURU1fTU1VCisJYm9vbCAiUzVQIFNZU1RFTSBNTVUiCisJZGVwZW5kcyBvbiBBUkNIX1M1UFYzMTAKKwloZWxwCisJICBTYXkgWSBoZXJlIGlmIHlvdSB3YW50IHRvIGVuYWJsZSBTeXN0ZW0gTU1VCisKIGNvbmZpZyBTNVBfREVWX0ZJTUMwCiAJYm9vbAogCWhlbHAKQEAgLTU2LDMgKzY0LDEzIEBACiAJYm9vbAogCWhlbHAKIAkgIENvbXBpbGUgaW4gcGxhdGZvcm0gZGV2aWNlIGRlZmluaXRpb24gZm9yIE9uZU5BTkQgY29udHJvbGxlcgorCitjb25maWcgUzVQX0RFVl9DU0lTMAorCWJvb2wKKwloZWxwCisJICBDb21waWxlIGluIHBsYXRmb3JtIGRldmljZSBkZWZpbml0aW9ucyBmb3IgTUlQSS1DU0lTIGNoYW5uZWwgMAorCitjb25maWcgUzVQX0RFVl9DU0lTMQorCWJvb2wKKwloZWxwCisJICBDb21waWxlIGluIHBsYXRmb3JtIGRldmljZSBkZWZpbml0aW9ucyBmb3IgTUlQSS1DU0lTIGNoYW5uZWwgMQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1zNXAvTWFrZWZpbGUgYi9hcmNoL2FybS9wbGF0LXM1cC9NYWtlZmlsZQppbmRleCBkZTY1MjM4Li40YmQ1Y2Y5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXM1cC9NYWtlZmlsZQorKysgYi9hcmNoL2FybS9wbGF0LXM1cC9NYWtlZmlsZQpAQCAtMTksNiArMTksNyBAQAogb2JqLXkJCQkJKz0gaXJxLm8KIG9iai0kKENPTkZJR19TNVBfRVhUX0lOVCkJKz0gaXJxLWVpbnQubwogb2JqLSQoQ09ORklHX1M1UF9HUElPX0lOVCkJKz0gaXJxLWdwaW9pbnQubworb2JqLSQoQ09ORklHX1M1UF9TWVNURU1fTU1VKQkrPSBzeXNtbXUubwogb2JqLSQoQ09ORklHX1BNKQkJKz0gcG0ubwogb2JqLSQoQ09ORklHX1BNKQkJKz0gaXJxLXBtLm8KIApAQCAtMjgsMyArMjksNSBAQAogb2JqLSQoQ09ORklHX1M1UF9ERVZfRklNQzEpCSs9IGRldi1maW1jMS5vCiBvYmotJChDT05GSUdfUzVQX0RFVl9GSU1DMikJKz0gZGV2LWZpbWMyLm8KIG9iai0kKENPTkZJR19TNVBfREVWX09ORU5BTkQpCSs9IGRldi1vbmVuYW5kLm8KK29iai0kKENPTkZJR19TNVBfREVWX0NTSVMwKQkrPSBkZXYtY3NpczAubworb2JqLSQoQ09ORklHX1M1UF9ERVZfQ1NJUzEpCSs9IGRldi1jc2lzMS5vCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXM1cC9jcHUuYyBiL2FyY2gvYXJtL3BsYXQtczVwL2NwdS5jCmluZGV4IDc0ZjdmNWEuLjA0N2QzMWMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtczVwL2NwdS5jCisrKyBiL2FyY2gvYXJtL3BsYXQtczVwL2NwdS5jCkBAIC0xMDgsNiArMTA4LDExIEBACiAJCS5wZm4JCT0gX19waHlzX3RvX3BmbihTM0NfUEFfV0RUKSwKIAkJLmxlbmd0aAkJPSBTWl80SywKIAkJLnR5cGUJCT0gTVRfREVWSUNFLAorCX0sIHsKKwkJLnZpcnR1YWwJPSAodW5zaWduZWQgbG9uZylTNVBfVkFfU1JPTUMsCisJCS5wZm4JCT0gX19waHlzX3RvX3BmbihTNVBfUEFfU1JPTUMpLAorCQkubGVuZ3RoCQk9IFNaXzRLLAorCQkudHlwZQkJPSBNVF9ERVZJQ0UsCiAJfSwKIH07CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtczVwL2Rldi1jc2lzMC5jIGIvYXJjaC9hcm0vcGxhdC1zNXAvZGV2LWNzaXMwLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGZhYjFjOAotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvYXJtL3BsYXQtczVwL2Rldi1jc2lzMC5jCkBAIC0wLDAgKzEsMzQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgU2Ftc3VuZyBFbGVjdHJvbmljcworICoKKyAqIFM1UCBzZXJpZXMgZGV2aWNlIGRlZmluaXRpb24gZm9yIE1JUEktQ1NJUyBjaGFubmVsIDAKKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorKi8KKworI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPG1hY2gvbWFwLmg+CisKK3N0YXRpYyBzdHJ1Y3QgcmVzb3VyY2UgczVwX21pcGlfY3NpczBfcmVzb3VyY2VbXSA9IHsKKwlbMF0gPSB7CisJCS5zdGFydCA9IFM1UF9QQV9NSVBJX0NTSVMwLAorCQkuZW5kICAgPSBTNVBfUEFfTUlQSV9DU0lTMCArIFNaXzRLIC0gMSwKKwkJLmZsYWdzID0gSU9SRVNPVVJDRV9NRU0sCisJfSwKKwlbMV0gPSB7CisJCS5zdGFydCA9IElSUV9NSVBJX0NTSVMwLAorCQkuZW5kICAgPSBJUlFfTUlQSV9DU0lTMCwKKwkJLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCisJfQorfTsKKworc3RydWN0IHBsYXRmb3JtX2RldmljZSBzNXBfZGV2aWNlX21pcGlfY3NpczAgPSB7CisJLm5hbWUJCSAgPSAiczVwLW1pcGktY3NpcyIsCisJLmlkCQkgID0gMCwKKwkubnVtX3Jlc291cmNlcwkgID0gQVJSQVlfU0laRShzNXBfbWlwaV9jc2lzMF9yZXNvdXJjZSksCisJLnJlc291cmNlCSAgPSBzNXBfbWlwaV9jc2lzMF9yZXNvdXJjZSwKK307CmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXM1cC9kZXYtY3NpczEuYyBiL2FyY2gvYXJtL3BsYXQtczVwL2Rldi1jc2lzMS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUzMDUzZjIKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL2FybS9wbGF0LXM1cC9kZXYtY3NpczEuYwpAQCAtMCwwICsxLDM0IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIFNhbXN1bmcgRWxlY3Ryb25pY3MKKyAqCisgKiBTNVAgc2VyaWVzIGRldmljZSBkZWZpbml0aW9uIGZvciBNSVBJLUNTSVMgY2hhbm5lbCAxCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyovCisKKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxtYWNoL21hcC5oPgorCitzdGF0aWMgc3RydWN0IHJlc291cmNlIHM1cF9taXBpX2NzaXMxX3Jlc291cmNlW10gPSB7CisJWzBdID0geworCQkuc3RhcnQgPSBTNVBfUEFfTUlQSV9DU0lTMSwKKwkJLmVuZCAgID0gUzVQX1BBX01JUElfQ1NJUzEgKyBTWl80SyAtIDEsCisJCS5mbGFncyA9IElPUkVTT1VSQ0VfTUVNLAorCX0sCisJWzFdID0geworCQkuc3RhcnQgPSBJUlFfTUlQSV9DU0lTMSwKKwkJLmVuZCAgID0gSVJRX01JUElfQ1NJUzEsCisJCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAorCX0sCit9OworCitzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIHM1cF9kZXZpY2VfbWlwaV9jc2lzMSA9IHsKKwkubmFtZQkJICA9ICJzNXAtbWlwaS1jc2lzIiwKKwkuaWQJCSAgPSAxLAorCS5udW1fcmVzb3VyY2VzCSAgPSBBUlJBWV9TSVpFKHM1cF9taXBpX2NzaXMxX3Jlc291cmNlKSwKKwkucmVzb3VyY2UJICA9IHM1cF9taXBpX2NzaXMxX3Jlc291cmNlLAorfTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtczVwL2luY2x1ZGUvcGxhdC9jc2lzLmggYi9hcmNoL2FybS9wbGF0LXM1cC9pbmNsdWRlL3BsYXQvY3Npcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjUxZTMwOGMKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL2FybS9wbGF0LXM1cC9pbmNsdWRlL3BsYXQvY3Npcy5oCkBAIC0wLDAgKzEsMjggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgU2Ftc3VuZyBFbGVjdHJvbmljcworICoKKyAqIFM1UCBzZXJpZXMgTUlQSSBDU0kgc2xhdmUgZGV2aWNlIHN1cHBvcnQKKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICovCisKKyNpZm5kZWYgUExBVF9TNVBfQ1NJU19IXworI2RlZmluZSBQTEFUX1M1UF9DU0lTX0hfIF9fRklMRV9fCisKKy8qKgorICogc3RydWN0IHM1cF9wbGF0Zm9ybV9taXBpX2NzaXMgLSBwbGF0Zm9ybSBkYXRhIGZvciBNSVBJLUNTSVMKKyAqIEBjbGtfcmF0ZTogYnVzIGNsb2NrIGZyZXF1ZW5jeQorICogQGxhbmVzOiBudW1iZXIgb2YgZGF0YSBsYW5lcyB1c2VkCisgKiBAYWxpZ25tZW50OiBkYXRhIGFsaWdubWVudCBpbiBiaXRzCisgKiBAaHNfc2V0dGxlOiBIUy1SWCBzZXR0bGUgdGltZQorICovCitzdHJ1Y3QgczVwX3BsYXRmb3JtX21pcGlfY3NpcyB7CisJdW5zaWduZWQgbG9uZyBjbGtfcmF0ZTsKKwl1OCBsYW5lczsKKwl1OCBhbGlnbm1lbnQ7CisJdTggaHNfc2V0dGxlOworfTsKKworI2VuZGlmIC8qIFBMQVRfUzVQX0NTSVNfSF8gKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtczVwL2luY2x1ZGUvcGxhdC9tYXAtczVwLmggYi9hcmNoL2FybS9wbGF0LXM1cC9pbmNsdWRlL3BsYXQvbWFwLXM1cC5oCmluZGV4IGZlZjM1M2QuLmQ5NzNkMzkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtczVwL2luY2x1ZGUvcGxhdC9tYXAtczVwLmgKKysrIGIvYXJjaC9hcm0vcGxhdC1zNXAvaW5jbHVkZS9wbGF0L21hcC1zNXAuaApAQCAtMTUsNiArMTUsNyBAQAogCiAjZGVmaW5lIFM1UF9WQV9DSElQSUQJCVMzQ19BRERSKDB4MDIwMDAwMDApCiAjZGVmaW5lIFM1UF9WQV9DTVUJCVMzQ19BRERSKDB4MDIxMDAwMDApCisjZGVmaW5lIFM1UF9WQV9QTVUJCVMzQ19BRERSKDB4MDIxODAwMDApCiAjZGVmaW5lIFM1UF9WQV9HUElPCQlTM0NfQUREUigweDAyMjAwMDAwKQogI2RlZmluZSBTNVBfVkFfR1BJTzEJCVM1UF9WQV9HUElPCiAjZGVmaW5lIFM1UF9WQV9HUElPMgkJUzNDX0FERFIoMHgwMjI0MDAwMCkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtczVwL2luY2x1ZGUvcGxhdC9yZWdzLXNyb20uaCBiL2FyY2gvYXJtL3BsYXQtczVwL2luY2x1ZGUvcGxhdC9yZWdzLXNyb20uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mMTIxYWI1Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9hcm0vcGxhdC1zNXAvaW5jbHVkZS9wbGF0L3JlZ3Mtc3JvbS5oCkBAIC0wLDAgKzEsNTQgQEAKKy8qIGxpbnV4L2FyY2gvYXJtL3BsYXQtczVwL2luY2x1ZGUvcGxhdC9yZWdzLXNyb20uaAorICoKKyAqIENvcHlyaWdodCAoYykgMjAxMCBTYW1zdW5nIEVsZWN0cm9uaWNzIENvLiwgTHRkLgorICoJCWh0dHA6Ly93d3cuc2Ftc3VuZy5jb20KKyAqCisgKiBTNVAgU1JPTUMgcmVnaXN0ZXIgZGVmaW5pdGlvbnMKKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorKi8KKworI2lmbmRlZiBfX0FTTV9QTEFUX1M1UF9SRUdTX1NST01fSAorI2RlZmluZSBfX0FTTV9QTEFUX1M1UF9SRUdTX1NST01fSCBfX0ZJTEVfXworCisjaW5jbHVkZSA8bWFjaC9tYXAuaD4KKworI2RlZmluZSBTNVBfU1JPTVJFRyh4KQkJKFM1UF9WQV9TUk9NQyArICh4KSkKKworI2RlZmluZSBTNVBfU1JPTV9CVwkJUzVQX1NST01SRUcoMHgwKQorI2RlZmluZSBTNVBfU1JPTV9CQzAJCVM1UF9TUk9NUkVHKDB4NCkKKyNkZWZpbmUgUzVQX1NST01fQkMxCQlTNVBfU1JPTVJFRygweDgpCisjZGVmaW5lIFM1UF9TUk9NX0JDMgkJUzVQX1NST01SRUcoMHhjKQorI2RlZmluZSBTNVBfU1JPTV9CQzMJCVM1UF9TUk9NUkVHKDB4MTApCisjZGVmaW5lIFM1UF9TUk9NX0JDNAkJUzVQX1NST01SRUcoMHgxNCkKKyNkZWZpbmUgUzVQX1NST01fQkM1CQlTNVBfU1JPTVJFRygweDE4KQorCisvKiBvbmUgcmVnaXN0ZXIgQlcgaG9sZHMgNCB4IDQtYml0IHBhY2tlZCBzZXR0aW5ncyBmb3IgTkNTMCAtIE5DUzMgKi8KKworI2RlZmluZSBTNVBfU1JPTV9CV19fREFUQVdJRFRIX19TSElGVAkJMAorI2RlZmluZSBTNVBfU1JPTV9CV19fQUREUk1PREVfX1NISUZUCQkxCisjZGVmaW5lIFM1UF9TUk9NX0JXX19XQUlURU5BQkxFX19TSElGVAkJMgorI2RlZmluZSBTNVBfU1JPTV9CV19fQllURUVOQUJMRV9fU0hJRlQJCTMKKworI2RlZmluZSBTNVBfU1JPTV9CV19fQ1NfTUFTSwkJCTB4ZgorCisjZGVmaW5lIFM1UF9TUk9NX0JXX19OQ1MwX19TSElGVAkJMAorI2RlZmluZSBTNVBfU1JPTV9CV19fTkNTMV9fU0hJRlQJCTQKKyNkZWZpbmUgUzVQX1NST01fQldfX05DUzJfX1NISUZUCQk4CisjZGVmaW5lIFM1UF9TUk9NX0JXX19OQ1MzX19TSElGVAkJMTIKKyNkZWZpbmUgUzVQX1NST01fQldfX05DUzRfX1NISUZUCQkxNgorI2RlZmluZSBTNVBfU1JPTV9CV19fTkNTNV9fU0hJRlQJCTIwCisKKy8qIGFwcGxpZXMgdG8gc2FtZSB0byBCQ1MwIC0gQkNTMyAqLworCisjZGVmaW5lIFM1UF9TUk9NX0JDWF9fUE1DX19TSElGVAkJMAorI2RlZmluZSBTNVBfU1JPTV9CQ1hfX1RBQ1BfX1NISUZUCQk0CisjZGVmaW5lIFM1UF9TUk9NX0JDWF9fVENBSF9fU0hJRlQJCTgKKyNkZWZpbmUgUzVQX1NST01fQkNYX19UQ09IX19TSElGVAkJMTIKKyNkZWZpbmUgUzVQX1NST01fQkNYX19UQUNDX19TSElGVAkJMTYKKyNkZWZpbmUgUzVQX1NST01fQkNYX19UQ09TX19TSElGVAkJMjQKKyNkZWZpbmUgUzVQX1NST01fQkNYX19UQUNTX19TSElGVAkJMjgKKworI2VuZGlmIC8qIF9fQVNNX1BMQVRfUzVQX1JFR1NfU1JPTV9IICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXM1cC9pcnEtZWludC5jIGIvYXJjaC9hcm0vcGxhdC1zNXAvaXJxLWVpbnQuYwppbmRleCA3NTJmMWE2Li4yMjVhYTI1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXM1cC9pcnEtZWludC5jCisrKyBiL2FyY2gvYXJtL3BsYXQtczVwL2lycS1laW50LmMKQEAgLTI4LDM5ICsyOCw0MCBAQAogI2luY2x1ZGUgPHBsYXQvZ3Bpby1jZmcuaD4KICNpbmNsdWRlIDxtYWNoL3JlZ3MtZ3Bpby5oPgogCi1zdGF0aWMgaW5saW5lIHZvaWQgczVwX2lycV9laW50X21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyBpbmxpbmUgdm9pZCBzNXBfaXJxX2VpbnRfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7CiAJdTMyIG1hc2s7CiAKLQltYXNrID0gX19yYXdfcmVhZGwoUzVQX0VJTlRfTUFTSyhFSU5UX1JFR19OUihpcnEpKSk7Ci0JbWFzayB8PSBlaW50X2lycV90b19iaXQoaXJxKTsKLQlfX3Jhd193cml0ZWwobWFzaywgUzVQX0VJTlRfTUFTSyhFSU5UX1JFR19OUihpcnEpKSk7CisJbWFzayA9IF9fcmF3X3JlYWRsKFM1UF9FSU5UX01BU0soRUlOVF9SRUdfTlIoZGF0YS0+aXJxKSkpOworCW1hc2sgfD0gZWludF9pcnFfdG9fYml0KGRhdGEtPmlycSk7CisJX19yYXdfd3JpdGVsKG1hc2ssIFM1UF9FSU5UX01BU0soRUlOVF9SRUdfTlIoZGF0YS0+aXJxKSkpOwogfQogCi1zdGF0aWMgdm9pZCBzNXBfaXJxX2VpbnRfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzNXBfaXJxX2VpbnRfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1MzIgbWFzazsKIAotCW1hc2sgPSBfX3Jhd19yZWFkbChTNVBfRUlOVF9NQVNLKEVJTlRfUkVHX05SKGlycSkpKTsKLQltYXNrICY9IH4oZWludF9pcnFfdG9fYml0KGlycSkpOwotCV9fcmF3X3dyaXRlbChtYXNrLCBTNVBfRUlOVF9NQVNLKEVJTlRfUkVHX05SKGlycSkpKTsKKwltYXNrID0gX19yYXdfcmVhZGwoUzVQX0VJTlRfTUFTSyhFSU5UX1JFR19OUihkYXRhLT5pcnEpKSk7CisJbWFzayAmPSB+KGVpbnRfaXJxX3RvX2JpdChkYXRhLT5pcnEpKTsKKwlfX3Jhd193cml0ZWwobWFzaywgUzVQX0VJTlRfTUFTSyhFSU5UX1JFR19OUihkYXRhLT5pcnEpKSk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgdm9pZCBzNXBfaXJxX2VpbnRfYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgaW5saW5lIHZvaWQgczVwX2lycV9laW50X2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JX19yYXdfd3JpdGVsKGVpbnRfaXJxX3RvX2JpdChpcnEpLCBTNVBfRUlOVF9QRU5EKEVJTlRfUkVHX05SKGlycSkpKTsKKwlfX3Jhd193cml0ZWwoZWludF9pcnFfdG9fYml0KGRhdGEtPmlycSksCisJCSAgICAgUzVQX0VJTlRfUEVORChFSU5UX1JFR19OUihkYXRhLT5pcnEpKSk7CiB9CiAKLXN0YXRpYyB2b2lkIHM1cF9pcnFfZWludF9tYXNrYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzNXBfaXJxX2VpbnRfbWFza2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7CiAJLyogY29tcGlsZXIgc2hvdWxkIGluLWxpbmUgdGhlc2UgKi8KLQlzNXBfaXJxX2VpbnRfbWFzayhpcnEpOwotCXM1cF9pcnFfZWludF9hY2soaXJxKTsKKwlzNXBfaXJxX2VpbnRfbWFzayhkYXRhKTsKKwlzNXBfaXJxX2VpbnRfYWNrKGRhdGEpOwogfQogCi1zdGF0aWMgaW50IHM1cF9pcnFfZWludF9zZXRfdHlwZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgdHlwZSkKK3N0YXRpYyBpbnQgczVwX2lycV9laW50X3NldF90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSwgdW5zaWduZWQgaW50IHR5cGUpCiB7Ci0JaW50IG9mZnMgPSBFSU5UX09GRlNFVChpcnEpOworCWludCBvZmZzID0gRUlOVF9PRkZTRVQoZGF0YS0+aXJxKTsKIAlpbnQgc2hpZnQ7CiAJdTMyIGN0cmwsIG1hc2s7CiAJdTMyIG5ld3ZhbHVlID0gMDsKQEAgLTk0LDEwICs5NSwxMCBAQAogCXNoaWZ0ID0gKG9mZnMgJiAweDcpICogNDsKIAltYXNrID0gMHg3IDw8IHNoaWZ0OwogCi0JY3RybCA9IF9fcmF3X3JlYWRsKFM1UF9FSU5UX0NPTihFSU5UX1JFR19OUihpcnEpKSk7CisJY3RybCA9IF9fcmF3X3JlYWRsKFM1UF9FSU5UX0NPTihFSU5UX1JFR19OUihkYXRhLT5pcnEpKSk7CiAJY3RybCAmPSB+bWFzazsKIAljdHJsIHw9IG5ld3ZhbHVlIDw8IHNoaWZ0OwotCV9fcmF3X3dyaXRlbChjdHJsLCBTNVBfRUlOVF9DT04oRUlOVF9SRUdfTlIoaXJxKSkpOworCV9fcmF3X3dyaXRlbChjdHJsLCBTNVBfRUlOVF9DT04oRUlOVF9SRUdfTlIoZGF0YS0+aXJxKSkpOwogCiAJaWYgKCgwIDw9IG9mZnMpICYmIChvZmZzIDwgOCkpCiAJCXMzY19ncGlvX2NmZ3BpbihFSU5UX0dQSU9fMChvZmZzICYgMHg3KSwgRUlOVF9NT0RFKTsKQEAgLTExOSwxMyArMTIwLDEzIEBACiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgczVwX2lycV9laW50ID0gewogCS5uYW1lCQk9ICJzNXAtZWludCIsCi0JLm1hc2sJCT0gczVwX2lycV9laW50X21hc2ssCi0JLnVubWFzawkJPSBzNXBfaXJxX2VpbnRfdW5tYXNrLAotCS5tYXNrX2Fjawk9IHM1cF9pcnFfZWludF9tYXNrYWNrLAotCS5hY2sJCT0gczVwX2lycV9laW50X2FjaywKLQkuc2V0X3R5cGUJPSBzNXBfaXJxX2VpbnRfc2V0X3R5cGUsCisJLmlycV9tYXNrCT0gczVwX2lycV9laW50X21hc2ssCisJLmlycV91bm1hc2sJPSBzNXBfaXJxX2VpbnRfdW5tYXNrLAorCS5pcnFfbWFza19hY2sJPSBzNXBfaXJxX2VpbnRfbWFza2FjaywKKwkuaXJxX2Fjawk9IHM1cF9pcnFfZWludF9hY2ssCisJLmlycV9zZXRfdHlwZQk9IHM1cF9pcnFfZWludF9zZXRfdHlwZSwKICNpZmRlZiBDT05GSUdfUE0KLQkuc2V0X3dha2UJPSBzM2NfaXJxZXh0X3dha2UsCisJLmlycV9zZXRfd2FrZQk9IHMzY19pcnFleHRfd2FrZSwKICNlbmRpZgogfTsKIApAQCAtMTU5LDQyICsxNjAsNDMgQEAKIAlzNXBfaXJxX2RlbXV4X2VpbnQoSVJRX0VJTlQoMjQpKTsKIH0KIAotc3RhdGljIGlubGluZSB2b2lkIHM1cF9pcnFfdmljX2VpbnRfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIGlubGluZSB2b2lkIHM1cF9pcnFfdmljX2VpbnRfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jdm9pZCBfX2lvbWVtICpiYXNlID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwl2b2lkIF9faW9tZW0gKmJhc2UgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKIAotCXM1cF9pcnFfZWludF9tYXNrKGlycSk7Ci0Jd3JpdGVsKDEgPDwgRUlOVF9PRkZTRVQoaXJxKSwgYmFzZSArIFZJQ19JTlRfRU5BQkxFX0NMRUFSKTsKKwlzNXBfaXJxX2VpbnRfbWFzayhkYXRhKTsKKwl3cml0ZWwoMSA8PCBFSU5UX09GRlNFVChkYXRhLT5pcnEpLCBiYXNlICsgVklDX0lOVF9FTkFCTEVfQ0xFQVIpOwogfQogCi1zdGF0aWMgdm9pZCBzNXBfaXJxX3ZpY19laW50X3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgczVwX2lycV92aWNfZWludF91bm1hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXZvaWQgX19pb21lbSAqYmFzZSA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJdm9pZCBfX2lvbWVtICpiYXNlID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CiAKLQlzNXBfaXJxX2VpbnRfdW5tYXNrKGlycSk7Ci0Jd3JpdGVsKDEgPDwgRUlOVF9PRkZTRVQoaXJxKSwgYmFzZSArIFZJQ19JTlRfRU5BQkxFKTsKKwlzNXBfaXJxX2VpbnRfdW5tYXNrKGRhdGEpOworCXdyaXRlbCgxIDw8IEVJTlRfT0ZGU0VUKGRhdGEtPmlycSksIGJhc2UgKyBWSUNfSU5UX0VOQUJMRSk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgdm9pZCBzNXBfaXJxX3ZpY19laW50X2Fjayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIGlubGluZSB2b2lkIHM1cF9pcnFfdmljX2VpbnRfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlfX3Jhd193cml0ZWwoZWludF9pcnFfdG9fYml0KGlycSksIFM1UF9FSU5UX1BFTkQoRUlOVF9SRUdfTlIoaXJxKSkpOworCV9fcmF3X3dyaXRlbChlaW50X2lycV90b19iaXQoZGF0YS0+aXJxKSwKKwkJICAgICBTNVBfRUlOVF9QRU5EKEVJTlRfUkVHX05SKGRhdGEtPmlycSkpKTsKIH0KIAotc3RhdGljIHZvaWQgczVwX2lycV92aWNfZWludF9tYXNrYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzNXBfaXJxX3ZpY19laW50X21hc2thY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXM1cF9pcnFfdmljX2VpbnRfbWFzayhpcnEpOwotCXM1cF9pcnFfdmljX2VpbnRfYWNrKGlycSk7CisJczVwX2lycV92aWNfZWludF9tYXNrKGRhdGEpOworCXM1cF9pcnFfdmljX2VpbnRfYWNrKGRhdGEpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHM1cF9pcnFfdmljX2VpbnQgPSB7CiAJLm5hbWUJCT0gInM1cF92aWNfZWludCIsCi0JLm1hc2sJCT0gczVwX2lycV92aWNfZWludF9tYXNrLAotCS51bm1hc2sJCT0gczVwX2lycV92aWNfZWludF91bm1hc2ssCi0JLm1hc2tfYWNrCT0gczVwX2lycV92aWNfZWludF9tYXNrYWNrLAotCS5hY2sJCT0gczVwX2lycV92aWNfZWludF9hY2ssCi0JLnNldF90eXBlCT0gczVwX2lycV9laW50X3NldF90eXBlLAorCS5pcnFfbWFzawk9IHM1cF9pcnFfdmljX2VpbnRfbWFzaywKKwkuaXJxX3VubWFzawk9IHM1cF9pcnFfdmljX2VpbnRfdW5tYXNrLAorCS5pcnFfbWFza19hY2sJPSBzNXBfaXJxX3ZpY19laW50X21hc2thY2ssCisJLmlycV9hY2sJPSBzNXBfaXJxX3ZpY19laW50X2FjaywKKwkuaXJxX3NldF90eXBlCT0gczVwX2lycV9laW50X3NldF90eXBlLAogI2lmZGVmIENPTkZJR19QTQotCS5zZXRfd2FrZQk9IHMzY19pcnFleHRfd2FrZSwKKwkuaXJxX3NldF93YWtlCT0gczNjX2lycWV4dF93YWtlLAogI2VuZGlmCiB9OwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXM1cC9pcnEtZ3Bpb2ludC5jIGIvYXJjaC9hcm0vcGxhdC1zNXAvaXJxLWdwaW9pbnQuYwppbmRleCAwZTVkYzhjLi4zYjZiZjg5IDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXM1cC9pcnEtZ3Bpb2ludC5jCisrKyBiL2FyY2gvYXJtL3BsYXQtczVwL2lycS1ncGlvaW50LmMKQEAgLTMwLDkgKzMwLDkgQEAKIAogc3RhdGljIHN0cnVjdCBzM2NfZ3Bpb19jaGlwICppcnFfY2hpcHNbUzVQX0dQSU9JTlRfR1JPVVBfTUFYTlJdOwogCi1zdGF0aWMgaW50IHM1cF9ncGlvaW50X2dldF9ncm91cCh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIGludCBzNXBfZ3Bpb2ludF9nZXRfZ3JvdXAoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBncGlvX2NoaXAgKmNoaXAgPSBnZXRfaXJxX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgZ3Bpb19jaGlwICpjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9kYXRhKGRhdGEpOwogCXN0cnVjdCBzM2NfZ3Bpb19jaGlwICpzM2NfY2hpcCA9IGNvbnRhaW5lcl9vZihjaGlwLAogCQkJc3RydWN0IHMzY19ncGlvX2NoaXAsIGNoaXApOwogCWludCBncm91cDsKQEAgLTQ0LDIyICs0NCwyMiBAQAogCXJldHVybiBncm91cDsKIH0KIAotc3RhdGljIGludCBzNXBfZ3Bpb2ludF9nZXRfb2Zmc2V0KHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgaW50IHM1cF9ncGlvaW50X2dldF9vZmZzZXQoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBncGlvX2NoaXAgKmNoaXAgPSBnZXRfaXJxX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgZ3Bpb19jaGlwICpjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9kYXRhKGRhdGEpOwogCXN0cnVjdCBzM2NfZ3Bpb19jaGlwICpzM2NfY2hpcCA9IGNvbnRhaW5lcl9vZihjaGlwLAogCQkJc3RydWN0IHMzY19ncGlvX2NoaXAsIGNoaXApOwogCi0JcmV0dXJuIGlycSAtIHMzY19jaGlwLT5pcnFfYmFzZTsKKwlyZXR1cm4gZGF0YS0+aXJxIC0gczNjX2NoaXAtPmlycV9iYXNlOwogfQogCi1zdGF0aWMgdm9pZCBzNXBfZ3Bpb2ludF9hY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHM1cF9ncGlvaW50X2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7CiAJaW50IGdyb3VwLCBvZmZzZXQsIHBlbmRfb2Zmc2V0OwogCXVuc2lnbmVkIGludCB2YWx1ZTsKIAotCWdyb3VwID0gczVwX2dwaW9pbnRfZ2V0X2dyb3VwKGlycSk7Ci0Jb2Zmc2V0ID0gczVwX2dwaW9pbnRfZ2V0X29mZnNldChpcnEpOworCWdyb3VwID0gczVwX2dwaW9pbnRfZ2V0X2dyb3VwKGRhdGEpOworCW9mZnNldCA9IHM1cF9ncGlvaW50X2dldF9vZmZzZXQoZGF0YSk7CiAJcGVuZF9vZmZzZXQgPSBncm91cCA8PCAyOwogCiAJdmFsdWUgPSBfX3Jhd19yZWFkbChTNVBfR1BJT1JFRyhHUElPSU5UX1BFTkRfT0ZGU0VUKSArIHBlbmRfb2Zmc2V0KTsKQEAgLTY3LDEzICs2NywxMyBAQAogCV9fcmF3X3dyaXRlbCh2YWx1ZSwgUzVQX0dQSU9SRUcoR1BJT0lOVF9QRU5EX09GRlNFVCkgKyBwZW5kX29mZnNldCk7CiB9CiAKLXN0YXRpYyB2b2lkIHM1cF9ncGlvaW50X21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHM1cF9ncGlvaW50X21hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewogCWludCBncm91cCwgb2Zmc2V0LCBtYXNrX29mZnNldDsKIAl1bnNpZ25lZCBpbnQgdmFsdWU7CiAKLQlncm91cCA9IHM1cF9ncGlvaW50X2dldF9ncm91cChpcnEpOwotCW9mZnNldCA9IHM1cF9ncGlvaW50X2dldF9vZmZzZXQoaXJxKTsKKwlncm91cCA9IHM1cF9ncGlvaW50X2dldF9ncm91cChkYXRhKTsKKwlvZmZzZXQgPSBzNXBfZ3Bpb2ludF9nZXRfb2Zmc2V0KGRhdGEpOwogCW1hc2tfb2Zmc2V0ID0gZ3JvdXAgPDwgMjsKIAogCXZhbHVlID0gX19yYXdfcmVhZGwoUzVQX0dQSU9SRUcoR1BJT0lOVF9NQVNLX09GRlNFVCkgKyBtYXNrX29mZnNldCk7CkBAIC04MSwxMyArODEsMTMgQEAKIAlfX3Jhd193cml0ZWwodmFsdWUsIFM1UF9HUElPUkVHKEdQSU9JTlRfTUFTS19PRkZTRVQpICsgbWFza19vZmZzZXQpOwogfQogCi1zdGF0aWMgdm9pZCBzNXBfZ3Bpb2ludF91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHM1cF9ncGlvaW50X3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7CiAJaW50IGdyb3VwLCBvZmZzZXQsIG1hc2tfb2Zmc2V0OwogCXVuc2lnbmVkIGludCB2YWx1ZTsKIAotCWdyb3VwID0gczVwX2dwaW9pbnRfZ2V0X2dyb3VwKGlycSk7Ci0Jb2Zmc2V0ID0gczVwX2dwaW9pbnRfZ2V0X29mZnNldChpcnEpOworCWdyb3VwID0gczVwX2dwaW9pbnRfZ2V0X2dyb3VwKGRhdGEpOworCW9mZnNldCA9IHM1cF9ncGlvaW50X2dldF9vZmZzZXQoZGF0YSk7CiAJbWFza19vZmZzZXQgPSBncm91cCA8PCAyOwogCiAJdmFsdWUgPSBfX3Jhd19yZWFkbChTNVBfR1BJT1JFRyhHUElPSU5UX01BU0tfT0ZGU0VUKSArIG1hc2tfb2Zmc2V0KTsKQEAgLTk1LDE5ICs5NSwxOSBAQAogCV9fcmF3X3dyaXRlbCh2YWx1ZSwgUzVQX0dQSU9SRUcoR1BJT0lOVF9NQVNLX09GRlNFVCkgKyBtYXNrX29mZnNldCk7CiB9CiAKLXN0YXRpYyB2b2lkIHM1cF9ncGlvaW50X21hc2tfYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzNXBfZ3Bpb2ludF9tYXNrX2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JczVwX2dwaW9pbnRfbWFzayhpcnEpOwotCXM1cF9ncGlvaW50X2FjayhpcnEpOworCXM1cF9ncGlvaW50X21hc2soZGF0YSk7CisJczVwX2dwaW9pbnRfYWNrKGRhdGEpOwogfQogCi1zdGF0aWMgaW50IHM1cF9ncGlvaW50X3NldF90eXBlKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCB0eXBlKQorc3RhdGljIGludCBzNXBfZ3Bpb2ludF9zZXRfdHlwZShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEsIHVuc2lnbmVkIGludCB0eXBlKQogewogCWludCBncm91cCwgb2Zmc2V0LCBjb25fb2Zmc2V0OwogCXVuc2lnbmVkIGludCB2YWx1ZTsKIAotCWdyb3VwID0gczVwX2dwaW9pbnRfZ2V0X2dyb3VwKGlycSk7Ci0Jb2Zmc2V0ID0gczVwX2dwaW9pbnRfZ2V0X29mZnNldChpcnEpOworCWdyb3VwID0gczVwX2dwaW9pbnRfZ2V0X2dyb3VwKGRhdGEpOworCW9mZnNldCA9IHM1cF9ncGlvaW50X2dldF9vZmZzZXQoZGF0YSk7CiAJY29uX29mZnNldCA9IGdyb3VwIDw8IDI7CiAKIAlzd2l0Y2ggKHR5cGUpIHsKQEAgLTE0MiwxMSArMTQyLDExIEBACiAKIHN0cnVjdCBpcnFfY2hpcCBzNXBfZ3Bpb2ludCA9IHsKIAkubmFtZQkJPSAiczVwX2dwaW9pbnQiLAotCS5hY2sJCT0gczVwX2dwaW9pbnRfYWNrLAotCS5tYXNrCQk9IHM1cF9ncGlvaW50X21hc2ssCi0JLm1hc2tfYWNrCT0gczVwX2dwaW9pbnRfbWFza19hY2ssCi0JLnVubWFzawkJPSBzNXBfZ3Bpb2ludF91bm1hc2ssCi0JLnNldF90eXBlCT0gczVwX2dwaW9pbnRfc2V0X3R5cGUsCisJLmlycV9hY2sJPSBzNXBfZ3Bpb2ludF9hY2ssCisJLmlycV9tYXNrCT0gczVwX2dwaW9pbnRfbWFzaywKKwkuaXJxX21hc2tfYWNrCT0gczVwX2dwaW9pbnRfbWFza19hY2ssCisJLmlycV91bm1hc2sJPSBzNXBfZ3Bpb2ludF91bm1hc2ssCisJLmlycV9zZXRfdHlwZQk9IHM1cF9ncGlvaW50X3NldF90eXBlLAogfTsKIAogc3RhdGljIHZvaWQgczVwX2dwaW9pbnRfaGFuZGxlcih1bnNpZ25lZCBpbnQgaXJxLCBzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXM1cC9pcnEtcG0uYyBiL2FyY2gvYXJtL3BsYXQtczVwL2lycS1wbS5jCmluZGV4IGRjMzNiOWUuLjUyNTlhZDQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtczVwL2lycS1wbS5jCisrKyBiL2FyY2gvYXJtL3BsYXQtczVwL2lycS1wbS5jCkBAIC0zNywxNCArMzcsMTQgQEAKIHVuc2lnbmVkIGxvbmcgczNjX2lycXdha2VfaW50YWxsb3cJPSAweDAwMDAwMDA2TDsKIHVuc2lnbmVkIGxvbmcgczNjX2lycXdha2VfZWludGFsbG93CT0gMHhmZmZmZmZmZkw7CiAKLWludCBzM2NfaXJxX3dha2UodW5zaWduZWQgaW50IGlycW5vLCB1bnNpZ25lZCBpbnQgc3RhdGUpCitpbnQgczNjX2lycV93YWtlKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSwgdW5zaWduZWQgaW50IHN0YXRlKQogewogCXVuc2lnbmVkIGxvbmcgaXJxYml0OwogCi0Jc3dpdGNoIChpcnFubykgeworCXN3aXRjaCAoZGF0YS0+aXJxKSB7CiAJY2FzZSBJUlFfUlRDX1RJQzoKIAljYXNlIElSUV9SVENfQUxBUk06Ci0JCWlycWJpdCA9IDEgPDwgKGlycW5vICsgMSAtIElSUV9SVENfQUxBUk0pOworCQlpcnFiaXQgPSAxIDw8IChkYXRhLT5pcnEgKyAxIC0gSVJRX1JUQ19BTEFSTSk7CiAJCWlmICghc3RhdGUpCiAJCQlzM2NfaXJxd2FrZV9pbnRtYXNrIHw9IGlycWJpdDsKIAkJZWxzZQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1zNXAvc3lzbW11LmMgYi9hcmNoL2FybS9wbGF0LXM1cC9zeXNtbXUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mZmU4YTQ4Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9hcm0vcGxhdC1zNXAvc3lzbW11LmMKQEAgLTAsMCArMSwzMjYgQEAKKy8qIGxpbnV4L2FyY2gvYXJtL3BsYXQtczVwL3N5c21tdS5jCisgKgorICogQ29weXJpZ2h0IChjKSAyMDEwIFNhbXN1bmcgRWxlY3Ryb25pY3MgQ28uLCBMdGQuCisgKgkJaHR0cDovL3d3dy5zYW1zdW5nLmNvbQorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2lvLmg+CisjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CisjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisKKyNpbmNsdWRlIDxtYWNoL21hcC5oPgorI2luY2x1ZGUgPG1hY2gvcmVncy1zeXNtbXUuaD4KKyNpbmNsdWRlIDxtYWNoL3N5c21tdS5oPgorCitzdHJ1Y3Qgc3lzbW11X2NvbnRyb2xsZXIgczVwX3N5c21tdV9jbnRscnNbUzVQX1NZU01NVV9UT1RBTF9JUE5VTV07CisKK3ZvaWQgczVwX3N5c21tdV9yZWdpc3RlcihzdHJ1Y3Qgc3lzbW11X2NvbnRyb2xsZXIgKnN5c21tdWNvbnApCit7CisJdW5zaWduZWQgaW50IHJlZ19tbXVfY3RybDsKKwl1bnNpZ25lZCBpbnQgcmVnX21tdV9zdGF0dXM7CisJdW5zaWduZWQgaW50IHJlZ19wdF9iYXNlX2FkZHI7CisJdW5zaWduZWQgaW50IHJlZ19pbnRfc3RhdHVzOworCXVuc2lnbmVkIGludCByZWdfcGFnZV9mdF9hZGRyOworCisJcmVnX2ludF9zdGF0dXMgPSBfX3Jhd19yZWFkbChzeXNtbXVjb25wLT5yZWdzICsgUzVQX0lOVF9TVEFUVVMpOworCXJlZ19tbXVfY3RybCA9IF9fcmF3X3JlYWRsKHN5c21tdWNvbnAtPnJlZ3MgKyBTNVBfTU1VX0NUUkwpOworCXJlZ19tbXVfc3RhdHVzID0gX19yYXdfcmVhZGwoc3lzbW11Y29ucC0+cmVncyArIFM1UF9NTVVfU1RBVFVTKTsKKwlyZWdfcHRfYmFzZV9hZGRyID0gX19yYXdfcmVhZGwoc3lzbW11Y29ucC0+cmVncyArIFM1UF9QVF9CQVNFX0FERFIpOworCXJlZ19wYWdlX2Z0X2FkZHIgPSBfX3Jhd19yZWFkbChzeXNtbXVjb25wLT5yZWdzICsgUzVQX1BBR0VfRkFVTFRfQUREUik7CisKKwlwcmludGsoS0VSTl9JTkZPICIlczogaXBzOiVzXG4iLCBfX2Z1bmNfXywgc3lzbW11Y29ucC0+bmFtZSk7CisJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IE1NVV9DVFJMOjB4JVgsICIsIF9fZnVuY19fLCByZWdfbW11X2N0cmwpOworCXByaW50ayhLRVJOX0lORk8gIk1NVV9TVEFUVVM6MHglWCwgUFRfQkFTRV9BRERSOjB4JVhcbiIsIHJlZ19tbXVfc3RhdHVzLCByZWdfcHRfYmFzZV9hZGRyKTsKKwlwcmludGsoS0VSTl9JTkZPICIlczogSU5UX1NUQVRVUzoweCVYLCBQQUdFX0ZBVUxUX0FERFI6MHglWFxuIiwgX19mdW5jX18sIHJlZ19pbnRfc3RhdHVzLCByZWdfcGFnZV9mdF9hZGRyKTsKKworCXN3aXRjaCAocmVnX2ludF9zdGF0dXMgJiAweEZGKSB7CisJY2FzZSAweDE6CisJCXByaW50ayhLRVJOX0lORk8gIiVzOiBQYWdlIGZhdWx0XG4iLCBfX2Z1bmNfXyk7CisJCXByaW50ayhLRVJOX0lORk8gIiVzOiBWaXJ0dWFsIGFkZHJlc3MgY2F1c2luZyBsYXN0IHBhZ2UgZmF1bHQgb3IgYnVzIGVycm9yIDogMHgleFxuIiwgX19mdW5jX18gLCByZWdfcGFnZV9mdF9hZGRyKTsKKwkJYnJlYWs7CisJY2FzZSAweDI6CisJCXByaW50ayhLRVJOX0lORk8gIiVzOiBBUiBtdWx0aS1oaXQgZmF1bHRcbiIsIF9fZnVuY19fKTsKKwkJYnJlYWs7CisJY2FzZSAweDQ6CisJCXByaW50ayhLRVJOX0lORk8gIiVzOiBBVyBtdWx0aS1oaXQgZmF1bHRcbiIsIF9fZnVuY19fKTsKKwkJYnJlYWs7CisJY2FzZSAweDg6CisJCXByaW50ayhLRVJOX0lORk8gIiVzOiBCdXMgZXJyb3JcbiIsIF9fZnVuY19fKTsKKwkJYnJlYWs7CisJY2FzZSAweDEwOgorCQlwcmludGsoS0VSTl9JTkZPICIlczogQVIgU2VjdXJpdHkgcHJvdGVjdGlvbiBmYXVsdFxuIiwgX19mdW5jX18pOworCQlicmVhazsKKwljYXNlIDB4MjA6CisJCXByaW50ayhLRVJOX0lORk8gIiVzOiBBUiBBY2Nlc3MgcHJvdGVjdGlvbiBmYXVsdFxuIiwgX19mdW5jX18pOworCQlicmVhazsKKwljYXNlIDB4NDA6CisJCXByaW50ayhLRVJOX0lORk8gIiVzOiBBVyBTZWN1cml0eSBwcm90ZWN0aW9uIGZhdWx0XG4iLCBfX2Z1bmNfXyk7CisJCWJyZWFrOworCWNhc2UgMHg4MDoKKwkJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IEFXIEFjY2VzcyBwcm90ZWN0aW9uIGZhdWx0XG4iLCBfX2Z1bmNfXyk7CisJCWJyZWFrOworCX0KK30KKworc3RhdGljIGlycXJldHVybl90IHM1cF9zeXNtbXVfaXJxKGludCBpcnEsIHZvaWQgKmRldl9pZCkKK3sKKwl1bnNpZ25lZCBpbnQgaTsKKwl1bnNpZ25lZCBpbnQgcmVnX2ludF9zdGF0dXM7CisJc3RydWN0IHN5c21tdV9jb250cm9sbGVyICpzeXNtbXVjb25wOworCisJZm9yIChpID0gMDsgaSA8IFM1UF9TWVNNTVVfVE9UQUxfSVBOVU07IGkrKykgeworCQlzeXNtbXVjb25wID0gJnM1cF9zeXNtbXVfY250bHJzW2ldOworCisJCWlmIChzeXNtbXVjb25wLT5lbmFibGUgPT0gdHJ1ZSkgeworCQkJcmVnX2ludF9zdGF0dXMgPSBfX3Jhd19yZWFkbChzeXNtbXVjb25wLT5yZWdzICsgUzVQX0lOVF9TVEFUVVMpOworCisJCQlpZiAocmVnX2ludF9zdGF0dXMgJiAweEZGKQorCQkJCXM1cF9zeXNtbXVfcmVnaXN0ZXIoc3lzbW11Y29ucCk7CisJCX0KKwl9CisJcmV0dXJuIElSUV9IQU5ETEVEOworfQorCitpbnQgczVwX3N5c21tdV9zZXRfdGFibGViYXNlX3BnZChzeXNtbXVfaXBzIGlwcywgdW5zaWduZWQgbG9uZyBwZ2QpCit7CisJc3RydWN0IHN5c21tdV9jb250cm9sbGVyICpzeXNtbXVjb25wID0gTlVMTDsKKworCXN5c21tdWNvbnAgPSAmczVwX3N5c21tdV9jbnRscnNbaXBzXTsKKworCWlmIChzeXNtbXVjb25wID09IE5VTEwpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJmYWlsZWQgdG8gZ2V0IGlwJ3Mgc3lzbW11IGluZm9cbiIpOworCQlyZXR1cm4gMTsKKwl9CisKKwkvKiBTZXQgc3lzbW11IHBhZ2UgdGFibGUgYmFzZSBhZGRyZXNzICovCisJX19yYXdfd3JpdGVsKHBnZCwgc3lzbW11Y29ucC0+cmVncyArIFM1UF9QVF9CQVNFX0FERFIpOworCisJaWYgKHM1cF9zeXNtbXVfdGxiX2ludmFsaWRhdGUoaXBzKSAhPSAwKQorCQlwcmludGsoS0VSTl9FUlIgImZhaWxlZCBzNXBfc3lzbW11X3RsYl9pbnZhbGlkYXRlXG4iKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHM1cF9zeXNtbXVfc2V0X3RhYmxlYmFzZShzeXNtbXVfaXBzIGlwcykKK3sKKwl1bnNpZ25lZCBpbnQgcGc7CisJc3RydWN0IHN5c21tdV9jb250cm9sbGVyICpzeXNtbXVjb25wOworCisJc3lzbW11Y29ucCA9ICZzNXBfc3lzbW11X2NudGxyc1tpcHNdOworCisJaWYgKHN5c21tdWNvbnAgPT0gTlVMTCkgeworCQlwcmludGsoS0VSTl9FUlIgImZhaWxlZCB0byBnZXQgaXAncyBzeXNtbXUgaW5mb1xuIik7CisJCXJldHVybiAxOworCX0KKworCV9fYXNtX18oIm1yYwlwMTUsIDAsICUwLCBjMiwgYzAsIDAiCVwKKwkJOiAiPXIiIChwZykgOiA6ICJjYyIpOwkJXAorCQlwZyAmPSB+MHgzZmZmOworCisJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IENQMTUgVFRCUjAgOiAweCV4XG4iLCBfX2Z1bmNfXywgcGcpOworCisJLyogU2V0IHN5c21tdSBwYWdlIHRhYmxlIGJhc2UgYWRkcmVzcyAqLworCV9fcmF3X3dyaXRlbChwZywgc3lzbW11Y29ucC0+cmVncyArIFM1UF9QVF9CQVNFX0FERFIpOworCisJcmV0dXJuIDA7Cit9CisKK2ludCBzNXBfc3lzbW11X2VuYWJsZShzeXNtbXVfaXBzIGlwcykKK3sKKwl1bnNpZ25lZCBpbnQgcmVnOworCisJc3RydWN0IHN5c21tdV9jb250cm9sbGVyICpzeXNtbXVjb25wOworCisJc3lzbW11Y29ucCA9ICZzNXBfc3lzbW11X2NudGxyc1tpcHNdOworCisJaWYgKHN5c21tdWNvbnAgPT0gTlVMTCkgeworCQlwcmludGsoS0VSTl9FUlIgImZhaWxlZCB0byBnZXQgaXAncyBzeXNtbXUgaW5mb1xuIik7CisJCXJldHVybiAxOworCX0KKworCXM1cF9zeXNtbXVfc2V0X3RhYmxlYmFzZShpcHMpOworCisJLyogcmVwbGFjZW1lbnQgcG9saWN5IDogTFJVICovCisJcmVnID0gX19yYXdfcmVhZGwoc3lzbW11Y29ucC0+cmVncyArIFM1UF9NTVVfQ0ZHKTsKKwlyZWcgfD0gMHgxOworCV9fcmF3X3dyaXRlbChyZWcsIHN5c21tdWNvbnAtPnJlZ3MgKyBTNVBfTU1VX0NGRyk7CisKKwkvKiBFbmFibGUgaW50ZXJydXB0LCBFbmFibGUgTU1VICovCisJcmVnID0gX19yYXdfcmVhZGwoc3lzbW11Y29ucC0+cmVncyArIFM1UF9NTVVfQ1RSTCk7CisJcmVnIHw9ICgweDEgPDwgMikgfCAoMHgxIDw8IDApOworCisJX19yYXdfd3JpdGVsKHJlZywgc3lzbW11Y29ucC0+cmVncyArIFM1UF9NTVVfQ1RSTCk7CisKKwlzeXNtbXVjb25wLT5lbmFibGUgPSB0cnVlOworCisJcmV0dXJuIDA7Cit9CisKK2ludCBzNXBfc3lzbW11X2Rpc2FibGUoc3lzbW11X2lwcyBpcHMpCit7CisJdW5zaWduZWQgaW50IHJlZzsKKworCXN0cnVjdCBzeXNtbXVfY29udHJvbGxlciAqc3lzbW11Y29ucCA9IE5VTEw7CisKKwlpZiAoaXBzID4gUzVQX1NZU01NVV9UT1RBTF9JUE5VTSkKKwkJcHJpbnRrKEtFUk5fRVJSICJmYWlsZWQgdG8gZ2V0IGlwcyBwYXJhbWV0ZXJcbiIpOworCisJc3lzbW11Y29ucCA9ICZzNXBfc3lzbW11X2NudGxyc1tpcHNdOworCisJaWYgKHN5c21tdWNvbnAgPT0gTlVMTCkgeworCQlwcmludGsoS0VSTl9FUlIgImZhaWxlZCB0byBnZXQgaXAncyBzeXNtbXUgaW5mb1xuIik7CisJCXJldHVybiAxOworCX0KKworCXJlZyA9IF9fcmF3X3JlYWRsKHN5c21tdWNvbnAtPnJlZ3MgKyBTNVBfTU1VX0NGRyk7CisKKwkvKiByZXBsYWNlbWVudCBwb2xpY3kgOiBMUlUgKi8KKwlyZWcgfD0gMHgxOworCV9fcmF3X3dyaXRlbChyZWcsIHN5c21tdWNvbnAtPnJlZ3MgKyBTNVBfTU1VX0NGRyk7CisKKwlyZWcgPSBfX3Jhd19yZWFkbChzeXNtbXVjb25wLT5yZWdzICsgUzVQX01NVV9DVFJMKTsKKworCS8qIERpc2FibGUgTU1VICovCisJcmVnICY9IH4weDE7CisJX19yYXdfd3JpdGVsKHJlZywgc3lzbW11Y29ucC0+cmVncyArIFM1UF9NTVVfQ1RSTCk7CisKKwlzeXNtbXVjb25wLT5lbmFibGUgPSBmYWxzZTsKKworCXJldHVybiAwOworfQorCitpbnQgczVwX3N5c21tdV90bGJfaW52YWxpZGF0ZShzeXNtbXVfaXBzIGlwcykKK3sKKwl1bnNpZ25lZCBpbnQgcmVnOworCXN0cnVjdCBzeXNtbXVfY29udHJvbGxlciAqc3lzbW11Y29ucCA9IE5VTEw7CisKKwlzeXNtbXVjb25wID0gJnM1cF9zeXNtbXVfY250bHJzW2lwc107CisKKwlpZiAoc3lzbW11Y29ucCA9PSBOVUxMKSB7CisJCXByaW50ayhLRVJOX0VSUiAiZmFpbGVkIHRvIGdldCBpcCdzIHN5c21tdSBpbmZvXG4iKTsKKwkJcmV0dXJuIDE7CisJfQorCisJLyogc2V0IEJsb2NrIE1NVSBmb3IgZmx1c2ggVExCICovCisJcmVnID0gX19yYXdfcmVhZGwoc3lzbW11Y29ucC0+cmVncyArIFM1UF9NTVVfQ1RSTCk7CisJcmVnIHw9IDB4MSA8PCAxOworCV9fcmF3X3dyaXRlbChyZWcsIHN5c21tdWNvbnAtPnJlZ3MgKyBTNVBfTU1VX0NUUkwpOworCisJLyogZmx1c2ggYWxsIFRMQiBlbnRyeSAqLworCV9fcmF3X3dyaXRlbCgweDEsIHN5c21tdWNvbnAtPnJlZ3MgKyBTNVBfTU1VX0ZMVVNIKTsKKworCS8qIHNldCBVbi1ibG9jayBNTVUgYWZ0ZXIgZmx1c2ggVExCICovCisJcmVnID0gX19yYXdfcmVhZGwoc3lzbW11Y29ucC0+cmVncyArIFM1UF9NTVVfQ1RSTCk7CisJcmVnICY9IH4oMHgxIDw8IDEpOworCV9fcmF3X3dyaXRlbChyZWcsIHN5c21tdWNvbnAtPnJlZ3MgKyBTNVBfTU1VX0NUUkwpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgczVwX3N5c21tdV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCWludCBpOworCWludCByZXQ7CisJc3RydWN0IHJlc291cmNlICpyZXM7CisJc3RydWN0IHN5c21tdV9jb250cm9sbGVyICpzeXNtbXVjb25wOworCXN5c21tdV9pcHMgaXBzOworCisJZm9yIChpID0gMDsgaSA8IFM1UF9TWVNNTVVfVE9UQUxfSVBOVU07IGkrKykgeworCQlzeXNtbXVjb25wID0gJnM1cF9zeXNtbXVfY250bHJzW2ldOworCQlpZiAoc3lzbW11Y29ucCA9PSBOVUxMKSB7CisJCQlwcmludGsoS0VSTl9FUlIgImZhaWxlZCB0byBnZXQgaXAncyBzeXNtbXUgaW5mb1xuIik7CisJCQlyZXQgPSAtRU5PRU5UOworCQkJZ290byBlcnJfcmVzOworCQl9CisKKwkJc3lzbW11Y29ucC0+bmFtZSA9IHN5c21tdV9pcHNfbmFtZVtpXTsKKworCQlyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9NRU0sIGkpOworCQlpZiAoIXJlcykgeworCQkJcHJpbnRrKEtFUk5fRVJSICJmYWlsZWQgdG8gZ2V0IHN5c21tdSByZXNvdXJjZVxuIik7CisJCQlyZXQgPSAtRU5PREVWOworCQkJZ290byBlcnJfcmVzOworCQl9CisKKwkJc3lzbW11Y29ucC0+bWVtID0gcmVxdWVzdF9tZW1fcmVnaW9uKHJlcy0+c3RhcnQsCisJCQkJKChyZXMtPmVuZCkgLSAocmVzLT5zdGFydCkpICsgMSwgcGRldi0+bmFtZSk7CisJCWlmICghc3lzbW11Y29ucC0+bWVtKSB7CisJCQlwcl9lcnIoImZhaWxlZCB0byByZXF1ZXN0IHN5c21tdSBtZW1vcnkgcmVnaW9uXG4iKTsKKwkJCXJldCA9IC1FQlVTWTsKKwkJCWdvdG8gZXJyX3JlczsKKwkJfQorCisJCXN5c21tdWNvbnAtPnJlZ3MgPSBpb3JlbWFwKHJlcy0+c3RhcnQsIHJlcy0+ZW5kIC0gcmVzLT5zdGFydCArIDEpOworCQlpZiAoIXN5c21tdWNvbnAtPnJlZ3MpIHsKKwkJCXByX2VycigiZmFpbGVkIHRvIHN5c21tdSBpb3JlbWFwXG4iKTsKKwkJCXJldCA9IC1FTlhJTzsKKwkJCWdvdG8gZXJyX3JlZzsKKwkJfQorCisJCXN5c21tdWNvbnAtPmlycSA9IHBsYXRmb3JtX2dldF9pcnEocGRldiwgaSk7CisJCWlmIChzeXNtbXVjb25wLT5pcnEgPD0gMCkgeworCQkJcHJfZXJyKCJmYWlsZWQgdG8gZ2V0IHN5c21tdSBpcnEgcmVzb3VyY2VcbiIpOworCQkJcmV0ID0gLUVOT0VOVDsKKwkJCWdvdG8gZXJyX21hcDsKKwkJfQorCisJCXJldCA9IHJlcXVlc3RfaXJxKHN5c21tdWNvbnAtPmlycSwgczVwX3N5c21tdV9pcnEsIElSUUZfRElTQUJMRUQsIHBkZXYtPm5hbWUsIHN5c21tdWNvbnApOworCQlpZiAocmV0KSB7CisJCQlwcl9lcnIoImZhaWxlZCB0byByZXF1ZXN0IGlycVxuIik7CisJCQlyZXQgPSAtRU5PRU5UOworCQkJZ290byBlcnJfbWFwOworCQl9CisKKwkJaXBzID0gKHN5c21tdV9pcHMpaTsKKworCQlzeXNtbXVjb25wLT5pcHMgPSBpcHM7CisJfQorCisJcmV0dXJuIDA7CisKK2Vycl9yZWc6CisJcmVsZWFzZV9tZW1fcmVnaW9uKChyZXNvdXJjZV9zaXplX3Qpc3lzbW11Y29ucC0+bWVtLCAocmVzb3VyY2Vfc2l6ZV90KSgocmVzLT5lbmQpIC0gKHJlcy0+c3RhcnQpICsgMSkpOworZXJyX21hcDoKKwlpb3VubWFwKHN5c21tdWNvbnAtPnJlZ3MpOworZXJyX3JlczoKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IHM1cF9zeXNtbXVfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJcmV0dXJuIDA7Cit9CitpbnQgczVwX3N5c21tdV9ydW50aW1lX3N1c3BlbmQoc3RydWN0IGRldmljZSAqZGV2KQoreworCXJldHVybiAwOworfQorCitpbnQgczVwX3N5c21tdV9ydW50aW1lX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJcmV0dXJuIDA7Cit9CisKK2NvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIHM1cF9zeXNtbXVfcG1fb3BzID0geworCS5ydW50aW1lX3N1c3BlbmQJPSBzNXBfc3lzbW11X3J1bnRpbWVfc3VzcGVuZCwKKwkucnVudGltZV9yZXN1bWUJCT0gczVwX3N5c21tdV9ydW50aW1lX3Jlc3VtZSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIHM1cF9zeXNtbXVfZHJpdmVyID0geworCS5wcm9iZQkJPSBzNXBfc3lzbW11X3Byb2JlLAorCS5yZW1vdmUJCT0gczVwX3N5c21tdV9yZW1vdmUsCisJLmRyaXZlcgkJPSB7CisJCS5vd25lcgkJPSBUSElTX01PRFVMRSwKKwkJLm5hbWUJCT0gInM1cC1zeXNtbXUiLAorCQkucG0JCT0gJnM1cF9zeXNtbXVfcG1fb3BzLAorCX0KK307CisKK3N0YXRpYyBpbnQgX19pbml0IHM1cF9zeXNtbXVfaW5pdCh2b2lkKQoreworCXJldHVybiBwbGF0Zm9ybV9kcml2ZXJfcmVnaXN0ZXIoJnM1cF9zeXNtbXVfZHJpdmVyKTsKK30KK2FyY2hfaW5pdGNhbGwoczVwX3N5c21tdV9pbml0KTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9LY29uZmlnIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL0tjb25maWcKaW5kZXggZGNkNmVmZjRlLi4zMmJlMDVjIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvS2NvbmZpZworKysgYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvS2NvbmZpZwpAQCAtOTUsNiArOTUsMTIgQEAKIAloZWxwCiAJICBJbnRlcm5hbCBjb25maWd1cmF0aW9uIHRvIGVuYWJsZSB0aGUgY29ycmVjdCBHUElPIHB1bGwgaGVscGVyCiAKK2NvbmZpZyBTM0NfR1BJT19QVUxMX1MzQzI0NDMKKwlib29sCisJc2VsZWN0IFMzQ19HUElPX1BVTExfVVBET1dOCisJaGVscAorCSAgSW50ZXJuYWwgY29uZmlndXJhdGlvbiB0byBlbmFibGUgdGhlIGNvcnJlY3QgR1BJTyBwdWxsIGhlbHBlciBmb3IgUzNDMjQ0My1zdHlsZSBHUElPCisKIGNvbmZpZyBTM0NfR1BJT19QVUxMX0RPV04KIAlib29sCiAJaGVscApAQCAtMzMzLDQgKzMzOSwxMiBAQAogCSAgYW5kIGFib3ZlLiBUaGlzIGNvZGUgYWxsb3dzIGEgc2V0IG9mIGludGVycnVwdCB0byB3YWtldXAtbWFzawogCSAgbWFwcGluZ3MuIFNlZSA8cGxhdC93YWtldXAtbWFzay5oPgogCitjb21tZW50ICJQb3dlciBEb21haW4iCisKK2NvbmZpZyBTQU1TVU5HX1BECisJYm9vbCAiU2Ftc3VuZyBQb3dlciBEb21haW4iCisJZGVwZW5kcyBvbiBQTV9SVU5USU1FCisJaGVscAorCSAgU2F5IFkgaGVyZSBpZiB5b3Ugd2FudCB0byBjb250cm9sIFBvd2VyIERvbWFpbiBieSBSdW50aW1lIFBNLgorCiBlbmRpZgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL01ha2VmaWxlIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL01ha2VmaWxlCmluZGV4IDE5ZDhhMTYuLjI5OTMyZjggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9NYWtlZmlsZQorKysgYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvTWFrZWZpbGUKQEAgLTc0LDYgKzc0LDEwIEBACiAKIG9iai0kKENPTkZJR19TQU1TVU5HX1dBS0VNQVNLKQkrPSB3YWtldXAtbWFzay5vCiAKKyMgUEQgc3VwcG9ydAorCitvYmotJChDT05GSUdfU0FNU1VOR19QRCkJKz0gcGQubworCiAjIFBXTSBzdXBwb3J0CiAKIG9iai0kKENPTkZJR19IQVZFX1BXTSkJCSs9IHB3bS5vCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvY2xvY2suYyBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9jbG9jay5jCmluZGV4IGU4ZDIwYjAuLjc3Mjg5MjggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9jbG9jay5jCisrKyBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9jbG9jay5jCkBAIC0zOSw2ICszOSw5IEBACiAjaW5jbHVkZSA8bGludXgvY2xrLmg+CiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KICNpbmNsdWRlIDxsaW51eC9pby5oPgorI2lmIGRlZmluZWQoQ09ORklHX0RFQlVHX0ZTKQorI2luY2x1ZGUgPGxpbnV4L2RlYnVnZnMuaD4KKyNlbmRpZgogCiAjaW5jbHVkZSA8bWFjaC9oYXJkd2FyZS5oPgogI2luY2x1ZGUgPGFzbS9pcnEuaD4KQEAgLTQ0NywzICs0NTAsOTIgQEAKIAlyZXR1cm4gMDsKIH0KIAorI2lmIGRlZmluZWQoQ09ORklHX1BNX0RFQlVHKSAmJiBkZWZpbmVkKENPTkZJR19ERUJVR19GUykKKy8qIGRlYnVnZnMgc3VwcG9ydCB0byB0cmFjZSBjbG9jayB0cmVlIGhpZXJhcmNoeSBhbmQgYXR0cmlidXRlcyAqLworCitzdGF0aWMgc3RydWN0IGRlbnRyeSAqY2xrX2RlYnVnZnNfcm9vdDsKKworc3RhdGljIGludCBjbGtfZGVidWdmc19yZWdpc3Rlcl9vbmUoc3RydWN0IGNsayAqYykKK3sKKwlpbnQgZXJyOworCXN0cnVjdCBkZW50cnkgKmQsICpjaGlsZCwgKmNoaWxkX3RtcDsKKwlzdHJ1Y3QgY2xrICpwYSA9IGMtPnBhcmVudDsKKwljaGFyIHNbMjU1XTsKKwljaGFyICpwID0gczsKKworCXAgKz0gc3ByaW50ZihwLCAiJXMiLCBjLT5uYW1lKTsKKworCWlmIChjLT5pZCA+PSAwKQorCQlzcHJpbnRmKHAsICI6JWQiLCBjLT5pZCk7CisKKwlkID0gZGVidWdmc19jcmVhdGVfZGlyKHMsIHBhID8gcGEtPmRlbnQgOiBjbGtfZGVidWdmc19yb290KTsKKwlpZiAoIWQpCisJCXJldHVybiAtRU5PTUVNOworCisJYy0+ZGVudCA9IGQ7CisKKwlkID0gZGVidWdmc19jcmVhdGVfdTgoInVzZWNvdW50IiwgU19JUlVHTywgYy0+ZGVudCwgKHU4ICopJmMtPnVzYWdlKTsKKwlpZiAoIWQpIHsKKwkJZXJyID0gLUVOT01FTTsKKwkJZ290byBlcnJfb3V0OworCX0KKworCWQgPSBkZWJ1Z2ZzX2NyZWF0ZV91MzIoInJhdGUiLCBTX0lSVUdPLCBjLT5kZW50LCAodTMyICopJmMtPnJhdGUpOworCWlmICghZCkgeworCQllcnIgPSAtRU5PTUVNOworCQlnb3RvIGVycl9vdXQ7CisJfQorCXJldHVybiAwOworCitlcnJfb3V0OgorCWQgPSBjLT5kZW50OworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShjaGlsZCwgY2hpbGRfdG1wLCAmZC0+ZF9zdWJkaXJzLCBkX3UuZF9jaGlsZCkKKwkJZGVidWdmc19yZW1vdmUoY2hpbGQpOworCWRlYnVnZnNfcmVtb3ZlKGMtPmRlbnQpOworCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyBpbnQgY2xrX2RlYnVnZnNfcmVnaXN0ZXIoc3RydWN0IGNsayAqYykKK3sKKwlpbnQgZXJyOworCXN0cnVjdCBjbGsgKnBhID0gYy0+cGFyZW50OworCisJaWYgKHBhICYmICFwYS0+ZGVudCkgeworCQllcnIgPSBjbGtfZGVidWdmc19yZWdpc3RlcihwYSk7CisJCWlmIChlcnIpCisJCQlyZXR1cm4gZXJyOworCX0KKworCWlmICghYy0+ZGVudCkgeworCQllcnIgPSBjbGtfZGVidWdmc19yZWdpc3Rlcl9vbmUoYyk7CisJCWlmIChlcnIpCisJCQlyZXR1cm4gZXJyOworCX0KKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBfX2luaXQgY2xrX2RlYnVnZnNfaW5pdCh2b2lkKQoreworCXN0cnVjdCBjbGsgKmM7CisJc3RydWN0IGRlbnRyeSAqZDsKKwlpbnQgZXJyOworCisJZCA9IGRlYnVnZnNfY3JlYXRlX2RpcigiY2xvY2siLCBOVUxMKTsKKwlpZiAoIWQpCisJCXJldHVybiAtRU5PTUVNOworCWNsa19kZWJ1Z2ZzX3Jvb3QgPSBkOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShjLCAmY2xvY2tzLCBsaXN0KSB7CisJCWVyciA9IGNsa19kZWJ1Z2ZzX3JlZ2lzdGVyKGMpOworCQlpZiAoZXJyKQorCQkJZ290byBlcnJfb3V0OworCX0KKwlyZXR1cm4gMDsKKworZXJyX291dDoKKwlkZWJ1Z2ZzX3JlbW92ZV9yZWN1cnNpdmUoY2xrX2RlYnVnZnNfcm9vdCk7CisJcmV0dXJuIGVycjsKK30KK2xhdGVfaW5pdGNhbGwoY2xrX2RlYnVnZnNfaW5pdCk7CisKKyNlbmRpZiAvKiBkZWZpbmVkKENPTkZJR19QTV9ERUJVRykgJiYgZGVmaW5lZChDT05GSUdfREVCVUdfRlMpICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvZGV2LW5hbmQuYyBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9kZXYtbmFuZC5jCmluZGV4IDNhN2I4ODkuLjY5MjdhZTggMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9kZXYtbmFuZC5jCisrKyBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9kZXYtbmFuZC5jCkBAIC0xMjYsNSArMTI2LDMgQEAKIAogCXMzY19kZXZpY2VfbmFuZC5kZXYucGxhdGZvcm1fZGF0YSA9IG5wZDsKIH0KLQotRVhQT1JUX1NZTUJPTF9HUEwoczNjX25hbmRfc2V0X3BsYXRkYXRhKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9ncGlvLWNvbmZpZy5jIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2dwaW8tY29uZmlnLmMKaW5kZXggMGFhMzJmMi4uMWMwYjA0MCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2dwaW8tY29uZmlnLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2dwaW8tY29uZmlnLmMKQEAgLTI3OCw2ICsyNzgsNDggQEAKIAlwdXAgJj0gMHgzOwogCXJldHVybiAoX19mb3JjZSBzM2NfZ3Bpb19wdWxsX3QpcHVwOwogfQorCisjaWZkZWYgQ09ORklHX1MzQ19HUElPX1BVTExfUzNDMjQ0MworaW50IHMzY19ncGlvX3NldHB1bGxfczNjMjQ0MyhzdHJ1Y3QgczNjX2dwaW9fY2hpcCAqY2hpcCwKKwkJCQl1bnNpZ25lZCBpbnQgb2ZmLCBzM2NfZ3Bpb19wdWxsX3QgcHVsbCkKK3sKKwlzd2l0Y2ggKHB1bGwpIHsKKwljYXNlIFMzQ19HUElPX1BVTExfTk9ORToKKwkJcHVsbCA9IDB4MDE7CisJCWJyZWFrOworCWNhc2UgUzNDX0dQSU9fUFVMTF9VUDoKKwkJcHVsbCA9IDB4MDA7CisJCWJyZWFrOworCWNhc2UgUzNDX0dQSU9fUFVMTF9ET1dOOgorCQlwdWxsID0gMHgwMjsKKwkJYnJlYWs7CisJfQorCXJldHVybiBzM2NfZ3Bpb19zZXRwdWxsX3VwZG93bihjaGlwLCBvZmYsIHB1bGwpOworfQorCitzM2NfZ3Bpb19wdWxsX3QgczNjX2dwaW9fZ2V0cHVsbF9zM2MyNDQzKHN0cnVjdCBzM2NfZ3Bpb19jaGlwICpjaGlwLAorCQkJCQl1bnNpZ25lZCBpbnQgb2ZmKQoreworCXMzY19ncGlvX3B1bGxfdCBwdWxsOworCisJcHVsbCA9IHMzY19ncGlvX2dldHB1bGxfdXBkb3duKGNoaXAsIG9mZik7CisKKwlzd2l0Y2ggKHB1bGwpIHsKKwljYXNlIDB4MDA6CisJCXB1bGwgPSBTM0NfR1BJT19QVUxMX1VQOworCQlicmVhazsKKwljYXNlIDB4MDE6CisJY2FzZSAweDAzOgorCQlwdWxsID0gUzNDX0dQSU9fUFVMTF9OT05FOworCQlicmVhazsKKwljYXNlIDB4MDI6CisJCXB1bGwgPSBTM0NfR1BJT19QVUxMX0RPV047CisJCWJyZWFrOworCX0KKworCXJldHVybiBwdWxsOworfQorI2VuZGlmCiAjZW5kaWYKIAogI2lmIGRlZmluZWQoQ09ORklHX1MzQ19HUElPX1BVTExfVVApIHx8IGRlZmluZWQoQ09ORklHX1MzQ19HUElPX1BVTExfRE9XTikKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9ncGlvbGliLmMgYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvZ3Bpb2xpYi5jCmluZGV4IGMzNTQwODkuLmVhMzdjMDQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9ncGlvbGliLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2dwaW9saWIuYwpAQCAtMTk3LDMgKzE5NywxMCBAQAogCQlzM2NfZ3Bpb2xpYl9hZGQoY2hpcCk7CiAJfQogfQorCit2b2lkIF9faW5pdCBzYW1zdW5nX2dwaW9saWJfYWRkXzJiaXRfY2hpcHMoc3RydWN0IHMzY19ncGlvX2NoaXAgKmNoaXAsCisJCQkJCSAgIGludCBucl9jaGlwcykKK3sKKwlmb3IgKDsgbnJfY2hpcHMgPiAwOyBucl9jaGlwcy0tLCBjaGlwKyspCisJCXMzY19ncGlvbGliX2FkZChjaGlwKTsKK30KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvY2xvY2suaCBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvY2xvY2suaAppbmRleCAwZmJjZDBlLi45YTgyYjg4IDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L2Nsb2NrLmgKKysrIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9jbG9jay5oCkBAIC00Nyw2ICs0Nyw5IEBACiAKIAlzdHJ1Y3QgY2xrX29wcwkJKm9wczsKIAlpbnQJCSAgICAoKmVuYWJsZSkoc3RydWN0IGNsayAqLCBpbnQgZW5hYmxlKTsKKyNpZiBkZWZpbmVkKENPTkZJR19QTV9ERUJVRykgJiYgZGVmaW5lZChDT05GSUdfREVCVUdfRlMpCisJc3RydWN0IGRlbnRyeQkJKmRlbnQ7CS8qIEZvciB2aXNpYmxlIHRyZWUgaGllcmFyY2h5ICovCisjZW5kaWYKIH07CiAKIC8qIG90aGVyIGNsb2NrcyB3aGljaCBtYXkgYmUgcmVnaXN0ZXJlZCBieSBib2FyZCBzdXBwb3J0ICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L2RldnMuaCBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvZGV2cy5oCmluZGV4IGU5ZTNiNmUuLmI0ZDIwOGIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvZGV2cy5oCisrKyBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvZGV2cy5oCkBAIC0xMDQsNiArMTA0LDcgQEAKIGV4dGVybiBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIHM1cHYzMTBfZGV2aWNlX2kyczE7CiBleHRlcm4gc3RydWN0IHBsYXRmb3JtX2RldmljZSBzNXB2MzEwX2RldmljZV9pMnMyOwogZXh0ZXJuIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgczVwdjMxMF9kZXZpY2Vfc3BkaWY7CitleHRlcm4gc3RydWN0IHBsYXRmb3JtX2RldmljZSBzNXB2MzEwX2RldmljZV9wZFtdOwogCiBleHRlcm4gc3RydWN0IHBsYXRmb3JtX2RldmljZSBzNXA2NDQyX2RldmljZV9wY20wOwogZXh0ZXJuIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgczVwNjQ0Ml9kZXZpY2VfcGNtMTsKQEAgLTExNSw2ICsxMTYsOCBAQAogZXh0ZXJuIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgczVwNjQ0MF9kZXZpY2VfaWlzOwogCiBleHRlcm4gc3RydWN0IHBsYXRmb3JtX2RldmljZSBzNXA2NDUwX2RldmljZV9paXMwOworZXh0ZXJuIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgczVwNjQ1MF9kZXZpY2VfaWlzMTsKK2V4dGVybiBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIHM1cDY0NTBfZGV2aWNlX2lpczI7CiBleHRlcm4gc3RydWN0IHBsYXRmb3JtX2RldmljZSBzNXA2NDUwX2RldmljZV9wY20wOwogCiBleHRlcm4gc3RydWN0IHBsYXRmb3JtX2RldmljZSBzNXBjMTAwX2RldmljZV9hYzk3OwpAQCAtMTMxLDYgKzEzNCwxMSBAQAogZXh0ZXJuIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgczVwX2RldmljZV9maW1jMTsKIGV4dGVybiBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIHM1cF9kZXZpY2VfZmltYzI7CiAKK2V4dGVybiBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIHM1cF9kZXZpY2VfbWlwaV9jc2lzMDsKK2V4dGVybiBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIHM1cF9kZXZpY2VfbWlwaV9jc2lzMTsKKworZXh0ZXJuIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgczVwdjMxMF9kZXZpY2Vfc3lzbW11OworCiAvKiBzM2MyNDQwIHNwZWNpZmljIGRldmljZXMgKi8KIAogI2lmZGVmIENPTkZJR19DUFVfUzNDMjQ0MApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9ncGlvLWNmZy1oZWxwZXJzLmggYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L2dwaW8tY2ZnLWhlbHBlcnMuaAppbmRleCAwZDJjNTcwLi41NjAzZGIwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L2dwaW8tY2ZnLWhlbHBlcnMuaAorKysgYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L2dwaW8tY2ZnLWhlbHBlcnMuaApAQCAtMjQ0LDcgKzI0NCw3IEBACiAgKiBUaGlzIGhlbHBlciBmdW5jdGlvbiByZWFkcyB0aGUgc3RhdGUgb2YgdGhlIHB1bGwte3VwLGRvd259IHJlc2lzdG9yIGZvciB0aGUKICAqIGdpdmVuIEdQSU8gaW4gdGhlIHNhbWUgY2FzZSBhcyBzM2NfZ3Bpb19zZXRwdWxsX3Vwb3duLgogKi8KLWV4dGVybiBzM2NfZ3Bpb19wdWxsX3QgczNjX2dwaW9fZ2V0cHVsbF9zM2MyNHh4KHN0cnVjdCBzM2NfZ3Bpb19jaGlwICpjaGlwLAorZXh0ZXJuIHMzY19ncGlvX3B1bGxfdCBzM2NfZ3Bpb19nZXRwdWxsX3MzYzI0NDMoc3RydWN0IHMzY19ncGlvX2NoaXAgKmNoaXAsCiAJCQkJCQl1bnNpZ25lZCBpbnQgb2ZmKTsKIAogI2VuZGlmIC8qIF9fUExBVF9HUElPX0NGR19IRUxQRVJTX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvZ3Bpby1jb3JlLmggYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L2dwaW8tY29yZS5oCmluZGV4IDEzYTIyYjguLmRhYzM1ZDAgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvZ3Bpby1jb3JlLmgKKysrIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9ncGlvLWNvcmUuaApAQCAtMTE4LDYgKzExOCw4IEBACiAJCQkJCSAgIGludCBucl9jaGlwcyk7CiBleHRlcm4gdm9pZCBzYW1zdW5nX2dwaW9saWJfYWRkXzRiaXQyX2NoaXBzKHN0cnVjdCBzM2NfZ3Bpb19jaGlwICpjaGlwLAogCQkJCQkgICAgaW50IG5yX2NoaXBzKTsKK2V4dGVybiB2b2lkIHNhbXN1bmdfZ3Bpb2xpYl9hZGRfMmJpdF9jaGlwcyhzdHJ1Y3QgczNjX2dwaW9fY2hpcCAqY2hpcCwKKwkJCQkJICAgaW50IG5yX2NoaXBzKTsKIAogZXh0ZXJuIHZvaWQgc2Ftc3VuZ19ncGlvbGliX2FkZF80Yml0KHN0cnVjdCBzM2NfZ3Bpb19jaGlwICpjaGlwKTsKIGV4dGVybiB2b2lkIHNhbXN1bmdfZ3Bpb2xpYl9hZGRfNGJpdDIoc3RydWN0IHMzY19ncGlvX2NoaXAgKmNoaXApOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9wZC5oIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9wZC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjVmMGFkODUKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L3BkLmgKQEAgLTAsMCArMSwzMCBAQAorLyogbGludXgvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9wZC5oCisgKgorICogQ29weXJpZ2h0IChjKSAyMDEwIFNhbXN1bmcgRWxlY3Ryb25pY3MgQ28uLCBMdGQuCisgKgkJaHR0cDovL3d3dy5zYW1zdW5nLmNvbQorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisqLworCisjaWZuZGVmIF9fQVNNX1BMQVRfU0FNU1VOR19QRF9ICisjZGVmaW5lIF9fQVNNX1BMQVRfU0FNU1VOR19QRF9IIF9fRklMRV9fCisKK3N0cnVjdCBzYW1zdW5nX3BkX2luZm8geworCWludCAoKmVuYWJsZSkoc3RydWN0IGRldmljZSAqZGV2KTsKKwlpbnQgKCpkaXNhYmxlKShzdHJ1Y3QgZGV2aWNlICpkZXYpOworCXZvaWQgX19pb21lbSAqYmFzZTsKK307CisKK2VudW0gczVwdjMxMF9wZF9ibG9jayB7CisJUERfTUZDLAorCVBEX0czRCwKKwlQRF9MQ0QwLAorCVBEX0xDRDEsCisJUERfVFYsCisJUERfQ0FNLAorCVBEX0dQUworfTsKKworI2VuZGlmIC8qIF9fQVNNX1BMQVRfU0FNU1VOR19QRF9IICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L3BtLmggYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L3BtLmgKaW5kZXggMjQ1ODM2ZC4uMzA1MThjYyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9wbS5oCisrKyBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvcG0uaApAQCAtMTUsNiArMTUsMTAgQEAKICAqIG1hbmFnZW1lbnQKICovCiAKKyNpbmNsdWRlIDxsaW51eC9pcnEuaD4KKworc3RydWN0IHN5c19kZXZpY2U7CisKICNpZmRlZiBDT05GSUdfUE0KIAogZXh0ZXJuIF9faW5pdCBpbnQgczNjX3BtX2luaXQodm9pZCk7CkBAIC0xMDAsNyArMTA0LDcgQEAKIGV4dGVybiB2b2lkIHMzY19wbV9kb19yZXN0b3JlX2NvcmUoc3RydWN0IHNsZWVwX3NhdmUgKnB0ciwgaW50IGNvdW50KTsKIAogI2lmZGVmIENPTkZJR19QTQotZXh0ZXJuIGludCBzM2NfaXJxZXh0X3dha2UodW5zaWduZWQgaW50IGlycW5vLCB1bnNpZ25lZCBpbnQgc3RhdGUpOworZXh0ZXJuIGludCBzM2NfaXJxZXh0X3dha2Uoc3RydWN0IGlycV9kYXRhICpkYXRhLCB1bnNpZ25lZCBpbnQgc3RhdGUpOwogZXh0ZXJuIGludCBzM2MyNHh4X2lycV9zdXNwZW5kKHN0cnVjdCBzeXNfZGV2aWNlICpkZXYsIHBtX21lc3NhZ2VfdCBzdGF0ZSk7CiBleHRlcm4gaW50IHMzYzI0eHhfaXJxX3Jlc3VtZShzdHJ1Y3Qgc3lzX2RldmljZSAqZGV2KTsKICNlbHNlCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L3NkaGNpLmggYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaW5jbHVkZS9wbGF0L3NkaGNpLmgKaW5kZXggODU4NTNmOC4uNWE0MWEwYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2luY2x1ZGUvcGxhdC9zZGhjaS5oCisrKyBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pbmNsdWRlL3BsYXQvc2RoY2kuaApAQCAtMTA3LDYgKzEwNyw4IEBACiAKIC8qIEhlbHBlciBmdW5jdGlvbiBhdmFpbGFibGl0eSAqLwogCitleHRlcm4gdm9pZCBzM2MyNDE2X3NldHVwX3NkaGNpMF9jZmdfZ3BpbyhzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICosIGludCB3KTsKK2V4dGVybiB2b2lkIHMzYzI0MTZfc2V0dXBfc2RoY2kxX2NmZ19ncGlvKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKiwgaW50IHcpOwogZXh0ZXJuIHZvaWQgczNjNjR4eF9zZXR1cF9zZGhjaTBfY2ZnX2dwaW8oc3RydWN0IHBsYXRmb3JtX2RldmljZSAqLCBpbnQgdyk7CiBleHRlcm4gdm9pZCBzM2M2NHh4X3NldHVwX3NkaGNpMV9jZmdfZ3BpbyhzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICosIGludCB3KTsKIGV4dGVybiB2b2lkIHM1cGMxMDBfc2V0dXBfc2RoY2kwX2NmZ19ncGlvKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKiwgaW50IHcpOwpAQCAtMTIyLDYgKzEyNCwzOSBAQAogZXh0ZXJuIHZvaWQgczVwdjMxMF9zZXR1cF9zZGhjaTJfY2ZnX2dwaW8oc3RydWN0IHBsYXRmb3JtX2RldmljZSAqLCBpbnQgdyk7CiBleHRlcm4gdm9pZCBzNXB2MzEwX3NldHVwX3NkaGNpM19jZmdfZ3BpbyhzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICosIGludCB3KTsKIAorLyogUzNDMjQxNiBTREhDSSBzZXR1cCAqLworCisjaWZkZWYgQ09ORklHX1MzQzI0MTZfU0VUVVBfU0RIQ0kKK2V4dGVybiBjaGFyICpzM2MyNDE2X2hzbW1jX2Nsa3NyY3NbNF07CisKK2V4dGVybiB2b2lkIHMzYzI0MTZfc2V0dXBfc2RoY2lfY2ZnX2NhcmQoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqZGV2LAorCQkJCQkgICB2b2lkIF9faW9tZW0gKnIsCisJCQkJCSAgIHN0cnVjdCBtbWNfaW9zICppb3MsCisJCQkJCSAgIHN0cnVjdCBtbWNfY2FyZCAqY2FyZCk7CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBzM2MyNDE2X2RlZmF1bHRfc2RoY2kwKHZvaWQpCit7CisjaWZkZWYgQ09ORklHX1MzQ19ERVZfSFNNTUMKKwlzM2NfaHNtbWMwX2RlZl9wbGF0ZGF0YS5jbG9ja3MgPSBzM2MyNDE2X2hzbW1jX2Nsa3NyY3M7CisJczNjX2hzbW1jMF9kZWZfcGxhdGRhdGEuY2ZnX2dwaW8gPSBzM2MyNDE2X3NldHVwX3NkaGNpMF9jZmdfZ3BpbzsKKwlzM2NfaHNtbWMwX2RlZl9wbGF0ZGF0YS5jZmdfY2FyZCA9IHMzYzI0MTZfc2V0dXBfc2RoY2lfY2ZnX2NhcmQ7CisjZW5kaWYgLyogQ09ORklHX1MzQ19ERVZfSFNNTUMgKi8KK30KKworc3RhdGljIGlubGluZSB2b2lkIHMzYzI0MTZfZGVmYXVsdF9zZGhjaTEodm9pZCkKK3sKKyNpZmRlZiBDT05GSUdfUzNDX0RFVl9IU01NQzEKKwlzM2NfaHNtbWMxX2RlZl9wbGF0ZGF0YS5jbG9ja3MgPSBzM2MyNDE2X2hzbW1jX2Nsa3NyY3M7CisJczNjX2hzbW1jMV9kZWZfcGxhdGRhdGEuY2ZnX2dwaW8gPSBzM2MyNDE2X3NldHVwX3NkaGNpMV9jZmdfZ3BpbzsKKwlzM2NfaHNtbWMxX2RlZl9wbGF0ZGF0YS5jZmdfY2FyZCA9IHMzYzI0MTZfc2V0dXBfc2RoY2lfY2ZnX2NhcmQ7CisjZW5kaWYgLyogQ09ORklHX1MzQ19ERVZfSFNNTUMxICovCit9CisKKyNlbHNlCitzdGF0aWMgaW5saW5lIHZvaWQgczNjMjQxNl9kZWZhdWx0X3NkaGNpMCh2b2lkKSB7IH0KK3N0YXRpYyBpbmxpbmUgdm9pZCBzM2MyNDE2X2RlZmF1bHRfc2RoY2kxKHZvaWQpIHsgfQorCisjZW5kaWYgLyogQ09ORklHX1MzQzI0MTZfU0VUVVBfU0RIQ0kgKi8KIC8qIFMzQzY0WFggU0RIQ0kgc2V0dXAgKi8KIAogI2lmZGVmIENPTkZJR19TM0M2NFhYX1NFVFVQX1NESENJCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaXJxLXVhcnQuYyBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pcnEtdWFydC5jCmluZGV4IDRmOGMxMDIuLjRlNzcwMzUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pcnEtdWFydC5jCisrKyBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pcnEtdWFydC5jCkBAIC0yOCw5ICsyOCw5IEBACiAgKiBhcmUgY29uc2VjdXRpdmUgd2hlbiBsb29raW5nIHVwIHRoZSBpbnRlcnJ1cHQgaW4gdGhlIGRlbXV4IHJvdXRpbmVzLgogICovCiAKLXN0YXRpYyBpbmxpbmUgdm9pZCBfX2lvbWVtICpzM2NfaXJxX3VhcnRfYmFzZSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIGlubGluZSB2b2lkIF9faW9tZW0gKnMzY19pcnFfdWFydF9iYXNlKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3QgczNjX3VhcnRfaXJxICp1aXJxID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgczNjX3VhcnRfaXJxICp1aXJxID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CiAJcmV0dXJuIHVpcnEtPnJlZ3M7CiB9CiAKQEAgLTM5LDEwICszOSwxMCBAQAogCXJldHVybiBpcnEgJiAzOwogfQogCi1zdGF0aWMgdm9pZCBzM2NfaXJxX3VhcnRfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgczNjX2lycV91YXJ0X21hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXZvaWQgX19pb21lbSAqcmVncyA9IHMzY19pcnFfdWFydF9iYXNlKGlycSk7Ci0JdW5zaWduZWQgaW50IGJpdCA9IHMzY19pcnFfdWFydF9iaXQoaXJxKTsKKwl2b2lkIF9faW9tZW0gKnJlZ3MgPSBzM2NfaXJxX3VhcnRfYmFzZShkYXRhKTsKKwl1bnNpZ25lZCBpbnQgYml0ID0gczNjX2lycV91YXJ0X2JpdChkYXRhLT5pcnEpOwogCXUzMiByZWc7CiAKIAlyZWcgPSBfX3Jhd19yZWFkbChyZWdzICsgUzNDNjRYWF9VSU5UTSk7CkBAIC01MCwxMCArNTAsMTAgQEAKIAlfX3Jhd193cml0ZWwocmVnLCByZWdzICsgUzNDNjRYWF9VSU5UTSk7CiB9CiAKLXN0YXRpYyB2b2lkIHMzY19pcnFfdWFydF9tYXNrYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzM2NfaXJxX3VhcnRfbWFza2FjayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jdm9pZCBfX2lvbWVtICpyZWdzID0gczNjX2lycV91YXJ0X2Jhc2UoaXJxKTsKLQl1bnNpZ25lZCBpbnQgYml0ID0gczNjX2lycV91YXJ0X2JpdChpcnEpOworCXZvaWQgX19pb21lbSAqcmVncyA9IHMzY19pcnFfdWFydF9iYXNlKGRhdGEpOworCXVuc2lnbmVkIGludCBiaXQgPSBzM2NfaXJxX3VhcnRfYml0KGRhdGEtPmlycSk7CiAJdTMyIHJlZzsKIAogCXJlZyA9IF9fcmF3X3JlYWRsKHJlZ3MgKyBTM0M2NFhYX1VJTlRNKTsKQEAgLTYyLDEwICs2MiwxMCBAQAogCV9fcmF3X3dyaXRlbCgxIDw8IGJpdCwgcmVncyArIFMzQzY0WFhfVUlOVFApOwogfQogCi1zdGF0aWMgdm9pZCBzM2NfaXJxX3VhcnRfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzM2NfaXJxX3VhcnRfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQl2b2lkIF9faW9tZW0gKnJlZ3MgPSBzM2NfaXJxX3VhcnRfYmFzZShpcnEpOwotCXVuc2lnbmVkIGludCBiaXQgPSBzM2NfaXJxX3VhcnRfYml0KGlycSk7CisJdm9pZCBfX2lvbWVtICpyZWdzID0gczNjX2lycV91YXJ0X2Jhc2UoZGF0YSk7CisJdW5zaWduZWQgaW50IGJpdCA9IHMzY19pcnFfdWFydF9iaXQoZGF0YS0+aXJxKTsKIAl1MzIgcmVnOwogCiAJcmVnID0gX19yYXdfcmVhZGwocmVncyArIFMzQzY0WFhfVUlOVE0pOwpAQCAtNzMsMTcgKzczLDE3IEBACiAJX19yYXdfd3JpdGVsKHJlZywgcmVncyArIFMzQzY0WFhfVUlOVE0pOwogfQogCi1zdGF0aWMgdm9pZCBzM2NfaXJxX3VhcnRfYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzM2NfaXJxX3VhcnRfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQl2b2lkIF9faW9tZW0gKnJlZ3MgPSBzM2NfaXJxX3VhcnRfYmFzZShpcnEpOwotCXVuc2lnbmVkIGludCBiaXQgPSBzM2NfaXJxX3VhcnRfYml0KGlycSk7CisJdm9pZCBfX2lvbWVtICpyZWdzID0gczNjX2lycV91YXJ0X2Jhc2UoZGF0YSk7CisJdW5zaWduZWQgaW50IGJpdCA9IHMzY19pcnFfdWFydF9iaXQoZGF0YS0+aXJxKTsKIAogCV9fcmF3X3dyaXRlbCgxIDw8IGJpdCwgcmVncyArIFMzQzY0WFhfVUlOVFApOwogfQogCiBzdGF0aWMgdm9pZCBzM2NfaXJxX2RlbXV4X3VhcnQodW5zaWduZWQgaW50IGlycSwgc3RydWN0IGlycV9kZXNjICpkZXNjKQogewotCXN0cnVjdCBzM2NfdWFydF9pcnEgKnVpcnEgPSBkZXNjLT5oYW5kbGVyX2RhdGE7CisJc3RydWN0IHMzY191YXJ0X2lycSAqdWlycSA9IGRlc2MtPmlycV9kYXRhLmhhbmRsZXJfZGF0YTsKIAl1MzIgcGVuZCA9IF9fcmF3X3JlYWRsKHVpcnEtPnJlZ3MgKyBTM0M2NFhYX1VJTlRQKTsKIAlpbnQgYmFzZSA9IHVpcnEtPmJhc2VfaXJxOwogCkBAIC05OSwxMCArOTksMTAgQEAKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBzM2NfaXJxX3VhcnQgPSB7CiAJLm5hbWUJCT0gInMzYy11YXJ0IiwKLQkubWFzawkJPSBzM2NfaXJxX3VhcnRfbWFzaywKLQkudW5tYXNrCQk9IHMzY19pcnFfdWFydF91bm1hc2ssCi0JLm1hc2tfYWNrCT0gczNjX2lycV91YXJ0X21hc2thY2ssCi0JLmFjawkJPSBzM2NfaXJxX3VhcnRfYWNrLAorCS5pcnFfbWFzawk9IHMzY19pcnFfdWFydF9tYXNrLAorCS5pcnFfdW5tYXNrCT0gczNjX2lycV91YXJ0X3VubWFzaywKKwkuaXJxX21hc2tfYWNrCT0gczNjX2lycV91YXJ0X21hc2thY2ssCisJLmlycV9hY2sJPSBzM2NfaXJxX3VhcnRfYWNrLAogfTsKIAogc3RhdGljIHZvaWQgX19pbml0IHMzY19pbml0X3VhcnRfaXJxKHN0cnVjdCBzM2NfdWFydF9pcnEgKnVpcnEpCkBAIC0xMjQsNyArMTI0LDcgQEAKIAkJc2V0X2lycV9mbGFncyhpcnEsIElSUUZfVkFMSUQpOwogCX0KIAotCWRlc2MtPmhhbmRsZXJfZGF0YSA9IHVpcnE7CisJZGVzYy0+aXJxX2RhdGEuaGFuZGxlcl9kYXRhID0gdWlycTsKIAlzZXRfaXJxX2NoYWluZWRfaGFuZGxlcih1aXJxLT5wYXJlbnRfaXJxLCBzM2NfaXJxX2RlbXV4X3VhcnQpOwogfQogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaXJxLXZpYy10aW1lci5jIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL2lycS12aWMtdGltZXIuYwppbmRleCAwMjcwNTE5Li5kZDg2OTJhIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvaXJxLXZpYy10aW1lci5jCisrKyBiL2FyY2gvYXJtL3BsYXQtc2Ftc3VuZy9pcnEtdmljLXRpbWVyLmMKQEAgLTI0LDQzICsyNCw0NiBAQAogCiBzdGF0aWMgdm9pZCBzM2NfaXJxX2RlbXV4X3ZpY190aW1lcih1bnNpZ25lZCBpbnQgaXJxLCBzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MpCiB7Ci0JZ2VuZXJpY19oYW5kbGVfaXJxKChpbnQpZGVzYy0+aGFuZGxlcl9kYXRhKTsKKwlnZW5lcmljX2hhbmRsZV9pcnEoKGludClkZXNjLT5pcnFfZGF0YS5oYW5kbGVyX2RhdGEpOwogfQogCiAvKiBXZSBhc3N1bWUgdGhlIElSUV9USU1FUjAuLklSUV9USU1FUjQgcmFuZ2UgaXMgY29udGludW91cy4gKi8KIAotc3RhdGljIHZvaWQgczNjX2lycV90aW1lcl9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzM2NfaXJxX3RpbWVyX21hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewogCXUzMiByZWcgPSBfX3Jhd19yZWFkbChTM0M2NFhYX1RJTlRfQ1NUQVQpOworCXUzMiBtYXNrID0gKHUzMilkYXRhLT5jaGlwX2RhdGE7CiAKIAlyZWcgJj0gMHgxZjsgIC8qIG1hc2sgb3V0IHBlbmRpbmcgaW50ZXJydXB0cyAqLwotCXJlZyAmPSB+KDEgPDwgKGlycSAtIElSUV9USU1FUjApKTsKKwlyZWcgJj0gfm1hc2s7CiAJX19yYXdfd3JpdGVsKHJlZywgUzNDNjRYWF9USU5UX0NTVEFUKTsKIH0KIAotc3RhdGljIHZvaWQgczNjX2lycV90aW1lcl91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHMzY19pcnFfdGltZXJfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1MzIgcmVnID0gX19yYXdfcmVhZGwoUzNDNjRYWF9USU5UX0NTVEFUKTsKKwl1MzIgbWFzayA9ICh1MzIpZGF0YS0+Y2hpcF9kYXRhOwogCiAJcmVnICY9IDB4MWY7ICAvKiBtYXNrIG91dCBwZW5kaW5nIGludGVycnVwdHMgKi8KLQlyZWcgfD0gMSA8PCAoaXJxIC0gSVJRX1RJTUVSMCk7CisJcmVnIHw9IG1hc2s7CiAJX19yYXdfd3JpdGVsKHJlZywgUzNDNjRYWF9USU5UX0NTVEFUKTsKIH0KIAotc3RhdGljIHZvaWQgczNjX2lycV90aW1lcl9hY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHMzY19pcnFfdGltZXJfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1MzIgcmVnID0gX19yYXdfcmVhZGwoUzNDNjRYWF9USU5UX0NTVEFUKTsKKwl1MzIgbWFzayA9ICh1MzIpZGF0YS0+Y2hpcF9kYXRhOwogCiAJcmVnICY9IDB4MWY7Ci0JcmVnIHw9ICgxIDw8IDUpIDw8IChpcnEgLSBJUlFfVElNRVIwKTsKKwlyZWcgfD0gbWFzayA8PCA1OwogCV9fcmF3X3dyaXRlbChyZWcsIFMzQzY0WFhfVElOVF9DU1RBVCk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgczNjX2lycV90aW1lciA9IHsKIAkubmFtZQkJPSAiczNjLXRpbWVyIiwKLQkubWFzawkJPSBzM2NfaXJxX3RpbWVyX21hc2ssCi0JLnVubWFzawkJPSBzM2NfaXJxX3RpbWVyX3VubWFzaywKLQkuYWNrCQk9IHMzY19pcnFfdGltZXJfYWNrLAorCS5pcnFfbWFzawk9IHMzY19pcnFfdGltZXJfbWFzaywKKwkuaXJxX3VubWFzawk9IHMzY19pcnFfdGltZXJfdW5tYXNrLAorCS5pcnFfYWNrCT0gczNjX2lycV90aW1lcl9hY2ssCiB9OwogCiAvKioKQEAgLTc5LDggKzgyLDkgQEAKIAlzZXRfaXJxX2NoYWluZWRfaGFuZGxlcihwYXJlbnRfaXJxLCBzM2NfaXJxX2RlbXV4X3ZpY190aW1lcik7CiAKIAlzZXRfaXJxX2NoaXAodGltZXJfaXJxLCAmczNjX2lycV90aW1lcik7CisJc2V0X2lycV9jaGlwX2RhdGEodGltZXJfaXJxLCAodm9pZCAqKSgxIDw8ICh0aW1lcl9pcnEgLSBJUlFfVElNRVIwKSkpOwogCXNldF9pcnFfaGFuZGxlcih0aW1lcl9pcnEsIGhhbmRsZV9sZXZlbF9pcnEpOwogCXNldF9pcnFfZmxhZ3ModGltZXJfaXJxLCBJUlFGX1ZBTElEKTsKIAotCWRlc2MtPmhhbmRsZXJfZGF0YSA9ICh2b2lkICopdGltZXJfaXJxOworCWRlc2MtPmlycV9kYXRhLmhhbmRsZXJfZGF0YSA9ICh2b2lkICopdGltZXJfaXJxOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL3BkLmMgYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvcGQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lZmUxZDU2Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL3BkLmMKQEAgLTAsMCArMSw5NSBAQAorLyogbGludXgvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL3BkLmMKKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMTAgU2Ftc3VuZyBFbGVjdHJvbmljcyBDby4sIEx0ZC4KKyAqCQlodHRwOi8vd3d3LnNhbXN1bmcuY29tCisgKgorICogU2Ftc3VuZyBQb3dlciBkb21haW4gc3VwcG9ydAorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisqLworCisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgorI2luY2x1ZGUgPGxpbnV4L3BtX3J1bnRpbWUuaD4KKworI2luY2x1ZGUgPHBsYXQvcGQuaD4KKworc3RhdGljIGludCBzYW1zdW5nX3BkX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0IHNhbXN1bmdfcGRfaW5mbyAqcGRhdGEgPSBwZGV2LT5kZXYucGxhdGZvcm1fZGF0YTsKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2OworCisJaWYgKCFwZGF0YSkgeworCQlkZXZfZXJyKGRldiwgIm5vIGRldmljZSBkYXRhIHNwZWNpZmllZFxuIik7CisJCXJldHVybiAtRU5PRU5UOworCX0KKworCXBtX3J1bnRpbWVfc2V0X2FjdGl2ZShkZXYpOworCXBtX3J1bnRpbWVfZW5hYmxlKGRldik7CisKKwlkZXZfaW5mbyhkZXYsICJwb3dlciBkb21haW4gcmVnaXN0ZXJlZFxuIik7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgX19kZXZleGl0IHNhbXN1bmdfcGRfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKKworCXBtX3J1bnRpbWVfZGlzYWJsZShkZXYpOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHNhbXN1bmdfcGRfcnVudGltZV9zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3Qgc2Ftc3VuZ19wZF9pbmZvICpwZGF0YSA9IGRldi0+cGxhdGZvcm1fZGF0YTsKKwlpbnQgcmV0ID0gMDsKKworCWlmIChwZGF0YS0+ZGlzYWJsZSkKKwkJcmV0ID0gcGRhdGEtPmRpc2FibGUoZGV2KTsKKworCWRldl9kYmcoZGV2LCAic3VzcGVuZGVkXG4iKTsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IHNhbXN1bmdfcGRfcnVudGltZV9yZXN1bWUoc3RydWN0IGRldmljZSAqZGV2KQoreworCXN0cnVjdCBzYW1zdW5nX3BkX2luZm8gKnBkYXRhID0gZGV2LT5wbGF0Zm9ybV9kYXRhOworCWludCByZXQgPSAwOworCisJaWYgKHBkYXRhLT5lbmFibGUpCisJCXJldCA9IHBkYXRhLT5lbmFibGUoZGV2KTsKKworCWRldl9kYmcoZGV2LCAicmVzdW1lZFxuIik7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIHNhbXN1bmdfcGRfcG1fb3BzID0geworCS5ydW50aW1lX3N1c3BlbmQJPSBzYW1zdW5nX3BkX3J1bnRpbWVfc3VzcGVuZCwKKwkucnVudGltZV9yZXN1bWUJCT0gc2Ftc3VuZ19wZF9ydW50aW1lX3Jlc3VtZSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIHNhbXN1bmdfcGRfZHJpdmVyID0geworCS5kcml2ZXIJCT0geworCQkubmFtZQkJPSAic2Ftc3VuZy1wZCIsCisJCS5vd25lcgkJPSBUSElTX01PRFVMRSwKKwkJLnBtCQk9ICZzYW1zdW5nX3BkX3BtX29wcywKKwl9LAorCS5wcm9iZQkJPSBzYW1zdW5nX3BkX3Byb2JlLAorCS5yZW1vdmUJCT0gX19kZXZleGl0X3Aoc2Ftc3VuZ19wZF9yZW1vdmUpLAorfTsKKworc3RhdGljIGludCBfX2luaXQgc2Ftc3VuZ19wZF9pbml0KHZvaWQpCit7CisJaW50IHJldDsKKworCXJldCA9IHBsYXRmb3JtX2RyaXZlcl9yZWdpc3Rlcigmc2Ftc3VuZ19wZF9kcml2ZXIpOworCWlmIChyZXQpCisJCXByaW50ayhLRVJOX0VSUiAiJXM6IGZhaWxlZCB0byBhZGQgUEQgZHJpdmVyXG4iLCBfX2Z1bmNfXyk7CisKKwlyZXR1cm4gcmV0OworfQorYXJjaF9pbml0Y2FsbChzYW1zdW5nX3BkX2luaXQpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1zYW1zdW5nL3BtLmMgYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvcG0uYwppbmRleCA1YmYzZjJmLi4wMmQ1MzFmIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXNhbXN1bmcvcG0uYworKysgYi9hcmNoL2FybS9wbGF0LXNhbXN1bmcvcG0uYwpAQCAtMTM2LDE1ICsxMzYsMTUgQEAKIHVuc2lnbmVkIGxvbmcgczNjX2lycXdha2VfaW50bWFzawk9IDB4ZmZmZmZmZmZMOwogdW5zaWduZWQgbG9uZyBzM2NfaXJxd2FrZV9laW50bWFzawk9IDB4ZmZmZmZmZmZMOwogCi1pbnQgczNjX2lycWV4dF93YWtlKHVuc2lnbmVkIGludCBpcnFubywgdW5zaWduZWQgaW50IHN0YXRlKQoraW50IHMzY19pcnFleHRfd2FrZShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEsIHVuc2lnbmVkIGludCBzdGF0ZSkKIHsKLQl1bnNpZ25lZCBsb25nIGJpdCA9IDFMIDw8IElSUV9FSU5UX0JJVChpcnFubyk7CisJdW5zaWduZWQgbG9uZyBiaXQgPSAxTCA8PCBJUlFfRUlOVF9CSVQoZGF0YS0+aXJxKTsKIAogCWlmICghKHMzY19pcnF3YWtlX2VpbnRhbGxvdyAmIGJpdCkpCiAJCXJldHVybiAtRU5PRU5UOwogCiAJcHJpbnRrKEtFUk5fSU5GTyAid2FrZSAlcyBmb3IgaXJxICVkXG4iLAotCSAgICAgICBzdGF0ZSA/ICJlbmFibGVkIiA6ICJkaXNhYmxlZCIsIGlycW5vKTsKKwkgICAgICAgc3RhdGUgPyAiZW5hYmxlZCIgOiAiZGlzYWJsZWQiLCBkYXRhLT5pcnEpOwogCiAJaWYgKCFzdGF0ZSkKIAkJczNjX2lycXdha2VfZWludG1hc2sgfD0gYml0OwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vcGxhdC1zcGVhci9zaGlycS5jIGIvYXJjaC9hcm0vcGxhdC1zcGVhci9zaGlycS5jCmluZGV4IDIxNzJkNjkuLjc4MTg5MDMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtc3BlYXIvc2hpcnEuYworKysgYi9hcmNoL2FybS9wbGF0LXNwZWFyL3NoaXJxLmMKQEAgLTIwLDEwICsyMCwxMCBAQAogc3RydWN0IHNwZWFyX3NoaXJxICpzaGlycTsKIHN0YXRpYyBERUZJTkVfU1BJTkxPQ0sobG9jayk7CiAKLXN0YXRpYyB2b2lkIHNoaXJxX2lycV9tYXNrKHVuc2lnbmVkIGlycSkKK3N0YXRpYyB2b2lkIHNoaXJxX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKLQlzdHJ1Y3Qgc3BlYXJfc2hpcnEgKnNoaXJxID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQl1MzIgdmFsLCBpZCA9IGlycSAtIHNoaXJxLT5kZXZfY29uZmlnWzBdLnZpcnE7CisJc3RydWN0IHNwZWFyX3NoaXJxICpzaGlycSA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGQpOworCXUzMiB2YWwsIGlkID0gZC0+aXJxIC0gc2hpcnEtPmRldl9jb25maWdbMF0udmlycTsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJaWYgKChzaGlycS0+cmVncy5lbmJfcmVnID09IC0xKSB8fCBzaGlycS0+ZGV2X2NvbmZpZ1tpZF0uZW5iX21hc2sgPT0gLTEpCkBAIC0zOSwxMCArMzksMTAgQEAKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZsb2NrLCBmbGFncyk7CiB9CiAKLXN0YXRpYyB2b2lkIHNoaXJxX2lycV91bm1hc2sodW5zaWduZWQgaXJxKQorc3RhdGljIHZvaWQgc2hpcnFfaXJxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQpCiB7Ci0Jc3RydWN0IHNwZWFyX3NoaXJxICpzaGlycSA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7Ci0JdTMyIHZhbCwgaWQgPSBpcnEgLSBzaGlycS0+ZGV2X2NvbmZpZ1swXS52aXJxOworCXN0cnVjdCBzcGVhcl9zaGlycSAqc2hpcnEgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKKwl1MzIgdmFsLCBpZCA9IGQtPmlycSAtIHNoaXJxLT5kZXZfY29uZmlnWzBdLnZpcnE7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCWlmICgoc2hpcnEtPnJlZ3MuZW5iX3JlZyA9PSAtMSkgfHwgc2hpcnEtPmRldl9jb25maWdbaWRdLmVuYl9tYXNrID09IC0xKQpAQCAtNjAsOSArNjAsOSBAQAogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHNoaXJxX2NoaXAgPSB7CiAJLm5hbWUJCT0gInNwZWFyX3NoaXJxIiwKLQkuYWNrCQk9IHNoaXJxX2lycV9tYXNrLAotCS5tYXNrCQk9IHNoaXJxX2lycV9tYXNrLAotCS51bm1hc2sJCT0gc2hpcnFfaXJxX3VubWFzaywKKwkuaXJxX2Fjawk9IHNoaXJxX2lycV9tYXNrLAorCS5pcnFfbWFzawk9IHNoaXJxX2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCT0gc2hpcnFfaXJxX3VubWFzaywKIH07CiAKIHN0YXRpYyB2b2lkIHNoaXJxX2hhbmRsZXIodW5zaWduZWQgaXJxLCBzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MpCkBAIC03MCw3ICs3MCw3IEBACiAJdTMyIGksIHZhbCwgbWFzazsKIAlzdHJ1Y3Qgc3BlYXJfc2hpcnEgKnNoaXJxID0gZ2V0X2lycV9kYXRhKGlycSk7CiAKLQlkZXNjLT5jaGlwLT5hY2soaXJxKTsKKwlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfYWNrKCZkZXNjLT5pcnFfZGF0YSk7CiAJd2hpbGUgKCh2YWwgPSByZWFkbChzaGlycS0+cmVncy5iYXNlICsgc2hpcnEtPnJlZ3Muc3RhdHVzX3JlZykgJgogCQkJCXNoaXJxLT5yZWdzLnN0YXR1c19yZWdfbWFzaykpIHsKIAkJZm9yIChpID0gMDsgKGkgPCBzaGlycS0+ZGV2X2NvdW50KSAmJiB2YWw7IGkrKykgewpAQCAtOTIsNyArOTIsNyBAQAogCQkJd3JpdGVsKG1hc2ssIHNoaXJxLT5yZWdzLmJhc2UgKyBzaGlycS0+cmVncy5jbGVhcl9yZWcpOwogCQl9CiAJfQotCWRlc2MtPmNoaXAtPnVubWFzayhpcnEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV91bm1hc2soJmRlc2MtPmlycV9kYXRhKTsKIH0KIAogaW50IHNwZWFyX3NoaXJxX3JlZ2lzdGVyKHN0cnVjdCBzcGVhcl9zaGlycSAqc2hpcnEpCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXN0bXAzeHh4L2lycS5jIGIvYXJjaC9hcm0vcGxhdC1zdG1wM3h4eC9pcnEuYwppbmRleCAyMGRlNGUwLi5hYWExNjg2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXN0bXAzeHh4L2lycS5jCisrKyBiL2FyY2gvYXJtL3BsYXQtc3RtcDN4eHgvaXJxLmMKQEAgLTM0LDcgKzM0LDcgQEAKIAogCS8qIERpc2FibGUgYWxsIGludGVycnVwdHMgaW5pdGlhbGx5ICovCiAJZm9yIChpID0gMDsgaSA8IE5SX1JFQUxfSVJRUzsgaSsrKSB7Ci0JCWNoaXAtPm1hc2soaSk7CisJCWNoaXAtPmlycV9tYXNrKGlycV9nZXRfaXJxX2RhdGEoaSkpOwogCQlzZXRfaXJxX2NoaXAoaSwgY2hpcCk7CiAJCXNldF9pcnFfaGFuZGxlcihpLCBoYW5kbGVfbGV2ZWxfaXJxKTsKIAkJc2V0X2lycV9mbGFncyhpLCBJUlFGX1ZBTElEIHwgSVJRRl9QUk9CRSk7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXN0bXAzeHh4L3Bpbm11eC5jIGIvYXJjaC9hcm0vcGxhdC1zdG1wM3h4eC9waW5tdXguYwppbmRleCA2ZDZiMWE0Li42NmQ1YmFjIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LXN0bXAzeHh4L3Bpbm11eC5jCisrKyBiL2FyY2gvYXJtL3BsYXQtc3RtcDN4eHgvcGlubXV4LmMKQEAgLTM1MSwyNyArMzUxLDI3IEBACiB9CiBFWFBPUlRfU1lNQk9MKHN0bXAzeHh4X3JlbGVhc2VfcGluX2dyb3VwKTsKIAotc3RhdGljIGludCBzdG1wM3h4eF9pcnFfdG9fZ3BpbyhpbnQgaXJxLAorc3RhdGljIGludCBzdG1wM3h4eF9pcnFfZGF0YV90b19ncGlvKHN0cnVjdCBpcnFfZGF0YSAqZCwKIAlzdHJ1Y3Qgc3RtcDN4eHhfcGlubXV4X2JhbmsgKipiYW5rLCB1bnNpZ25lZCAqZ3BpbykKIHsKIAlzdHJ1Y3Qgc3RtcDN4eHhfcGlubXV4X2JhbmsgKnBtOwogCiAJZm9yIChwbSA9IHBpbm11eF9iYW5rczsgcG0gPCBwaW5tdXhfYmFua3MgKyBOUl9CQU5LUzsgcG0rKykKLQkJaWYgKHBtLT52aXJxIDw9IGlycSAmJiBpcnEgPCBwbS0+dmlycSArIDMyKSB7CisJCWlmIChwbS0+dmlycSA8PSBkLT5pcnEgJiYgZC0+aXJxIDwgcG0tPnZpcnEgKyAzMikgewogCQkJKmJhbmsgPSBwbTsKLQkJCSpncGlvID0gaXJxIC0gcG0tPnZpcnE7CisJCQkqZ3BpbyA9IGQtPmlycSAtIHBtLT52aXJxOwogCQkJcmV0dXJuIDA7CiAJCX0KIAlyZXR1cm4gLUVOT0VOVDsKIH0KIAotc3RhdGljIGludCBzdG1wM3h4eF9zZXRfaXJxdHlwZSh1bnNpZ25lZCBpcnEsIHVuc2lnbmVkIHR5cGUpCitzdGF0aWMgaW50IHN0bXAzeHh4X3NldF9pcnF0eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgdHlwZSkKIHsKIAlzdHJ1Y3Qgc3RtcDN4eHhfcGlubXV4X2JhbmsgKnBtOwogCXVuc2lnbmVkIGdwaW87CiAJaW50IGwsIHA7CiAKLQlzdG1wM3h4eF9pcnFfdG9fZ3BpbyhpcnEsICZwbSwgJmdwaW8pOworCXN0bXAzeHh4X2lycV9kYXRhX3RvX2dwaW8oZCwgJnBtLCAmZ3Bpbyk7CiAJc3dpdGNoICh0eXBlKSB7CiAJY2FzZSBJUlFfVFlQRV9FREdFX1JJU0lORzoKIAkJbCA9IDA7IHAgPSAxOyBicmVhazsKQEAgLTM5OCwzMyArMzk4LDMzIEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyB2b2lkIHN0bXAzeHh4X3Bpbl9hY2tfaXJxKHVuc2lnbmVkIGlycSkKK3N0YXRpYyB2b2lkIHN0bXAzeHh4X3Bpbl9hY2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZCkKIHsKIAl1MzIgc3RhdDsKIAlzdHJ1Y3Qgc3RtcDN4eHhfcGlubXV4X2JhbmsgKnBtOwogCXVuc2lnbmVkIGdwaW87CiAKLQlzdG1wM3h4eF9pcnFfdG9fZ3BpbyhpcnEsICZwbSwgJmdwaW8pOworCXN0bXAzeHh4X2lycV9kYXRhX3RvX2dwaW8oZCwgJnBtLCAmZ3Bpbyk7CiAJc3RhdCA9IF9fcmF3X3JlYWRsKHBtLT5pcnFzdGF0KSAmICgxIDw8IGdwaW8pOwogCXN0bXAzeHh4X2NsZWFybChzdGF0LCBwbS0+aXJxc3RhdCk7CiB9CiAKLXN0YXRpYyB2b2lkIHN0bXAzeHh4X3Bpbl9tYXNrX2lycSh1bnNpZ25lZCBpcnEpCitzdGF0aWMgdm9pZCBzdG1wM3h4eF9waW5fbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCXN0cnVjdCBzdG1wM3h4eF9waW5tdXhfYmFuayAqcG07CiAJdW5zaWduZWQgZ3BpbzsKIAotCXN0bXAzeHh4X2lycV90b19ncGlvKGlycSwgJnBtLCAmZ3Bpbyk7CisJc3RtcDN4eHhfaXJxX2RhdGFfdG9fZ3BpbyhkLCAmcG0sICZncGlvKTsKIAlzdG1wM3h4eF9jbGVhcmwoMSA8PCBncGlvLCBwbS0+aXJxZW4pOwogCXN0bXAzeHh4X2NsZWFybCgxIDw8IGdwaW8sIHBtLT5waW4yaXJxKTsKIH0KIAotc3RhdGljIHZvaWQgc3RtcDN4eHhfcGluX3VubWFza19pcnEodW5zaWduZWQgaXJxKQorc3RhdGljIHZvaWQgc3RtcDN4eHhfcGluX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewogCXN0cnVjdCBzdG1wM3h4eF9waW5tdXhfYmFuayAqcG07CiAJdW5zaWduZWQgZ3BpbzsKIAotCXN0bXAzeHh4X2lycV90b19ncGlvKGlycSwgJnBtLCAmZ3Bpbyk7CisJc3RtcDN4eHhfaXJxX2RhdGFfdG9fZ3BpbyhkLCAmcG0sICZncGlvKTsKIAlzdG1wM3h4eF9zZXRsKDEgPDwgZ3BpbywgcG0tPmlycWVuKTsKIAlzdG1wM3h4eF9zZXRsKDEgPDwgZ3BpbywgcG0tPnBpbjJpcnEpOwogfQpAQCAtNTAzLDEwICs1MDMsMTAgQEAKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBncGlvX2lycV9jaGlwID0gewotCS5hY2sJPSBzdG1wM3h4eF9waW5fYWNrX2lycSwKLQkubWFzawk9IHN0bXAzeHh4X3Bpbl9tYXNrX2lycSwKLQkudW5tYXNrCT0gc3RtcDN4eHhfcGluX3VubWFza19pcnEsCi0JLnNldF90eXBlID0gc3RtcDN4eHhfc2V0X2lycXR5cGUsCisJLmlycV9hY2sJPSBzdG1wM3h4eF9waW5fYWNrX2lycSwKKwkuaXJxX21hc2sJPSBzdG1wM3h4eF9waW5fbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBzdG1wM3h4eF9waW5fdW5tYXNrX2lycSwKKwkuaXJxX3NldF90eXBlCT0gc3RtcDN4eHhfc2V0X2lycXR5cGUsCiB9OwogCiBpbnQgX19pbml0IHN0bXAzeHh4X3Bpbm11eF9pbml0KGludCB2aXJ0dWFsX2lycV9zdGFydCkKQEAgLTUzMyw3ICs1MzMsNyBAQAogCQlwbS0+dmlycSA9IHZpcnR1YWxfaXJxX3N0YXJ0ICsgYiAqIDMyOwogCiAJCWZvciAodmlycSA9IHBtLT52aXJxOyB2aXJxIDwgcG0tPnZpcnE7IHZpcnErKykgewotCQkJZ3Bpb19pcnFfY2hpcC5tYXNrKHZpcnEpOworCQkJZ3Bpb19pcnFfY2hpcC5pcnFfbWFzayhpcnFfZ2V0X2lycV9kYXRhKHZpcnEpKTsKIAkJCXNldF9pcnFfY2hpcCh2aXJxLCAmZ3Bpb19pcnFfY2hpcCk7CiAJCQlzZXRfaXJxX2hhbmRsZXIodmlycSwgaGFuZGxlX2xldmVsX2lycSk7CiAJCQlzZXRfaXJxX2ZsYWdzKHZpcnEsIElSUUZfVkFMSUQpOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vdG9vbHMvbWFjaC10eXBlcyBiL2FyY2gvYXJtL3Rvb2xzL21hY2gtdHlwZXMKaW5kZXggMmZlYTg5Ny4uOWQ2ZmVhYSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vdG9vbHMvbWFjaC10eXBlcworKysgYi9hcmNoL2FybS90b29scy9tYWNoLXR5cGVzCkBAIC0xMiw3ICsxMiw3IEBACiAjCiAjICAgaHR0cDovL3d3dy5hcm0ubGludXgub3JnLnVrL2RldmVsb3Blci9tYWNoaW5lcy8/YWN0aW9uPW5ldwogIwotIyBMYXN0IHVwZGF0ZTogU3VuIERlYyAxMiAyMzoyNDoyNyAyMDEwCisjIExhc3QgdXBkYXRlOiBNb24gRmViIDcgMDg6NTk6MjcgMjAxMQogIwogIyBtYWNoaW5lX2lzX3h4eAlDT05GSUdfeHh4eAkJTUFDSF9UWVBFX3h4eAkJbnVtYmVyCiAjCkBAIC0yMjQwLDcgKzIyNDAsNyBAQAogdnNfdjIxMAkJCU1BQ0hfVlNfVjIxMAkJVlNfVjIxMAkJCTIyNTIKIHZzX3YyMTIJCQlNQUNIX1ZTX1YyMTIJCVZTX1YyMTIJCQkyMjUzCiBobXQJCQlNQUNIX0hNVAkJSE1UCQkJMjI1NAotc3VlbjMJCQlNQUNIX1NVRU4zCQlTVUVOMwkJCTIyNTUKK2ttX2tpcmt3b29kCQlNQUNIX0tNX0tJUktXT09ECUtNX0tJUktXT09ECQkyMjU1CiB2ZXNwZXIJCQlNQUNIX1ZFU1BFUgkJVkVTUEVSCQkJMjI1Ngogc3RyOQkJCU1BQ0hfU1RSOQkJU1RSOQkJCTIyNTcKIG9tYXAzX3dsX2ZmCQlNQUNIX09NQVAzX1dMX0ZGCU9NQVAzX1dMX0ZGCQkyMjU4CkBAIC0yOTg3LDcgKzI5ODcsNyBAQAogZWEyMAkJCU1BQ0hfRUEyMAkJRUEyMAkJCTMwMDIKIGF3bTIJCQlNQUNIX0FXTTIJCUFXTTIJCQkzMDAzCiB0aTgxNDhldm0JCU1BQ0hfVEk4MTQ4RVZNCQlUSTgxNDhFVk0JCTMwMDQKLXRlZ3JhX3NlYWJvYXJkCQlNQUNIX1RFR1JBX1NFQUJPQVJECVRFR1JBX1NFQUJPQVJECQkzMDA1CitzZWFib2FyZAkJTUFDSF9TRUFCT0FSRAkJU0VBQk9BUkQJCTMwMDUKIGxpbmtzdGF0aW9uX2NobHYyCU1BQ0hfTElOS1NUQVRJT05fQ0hMVjIJTElOS1NUQVRJT05fQ0hMVjIJMzAwNgogdGVyYV9wcm8yX3JhY2sJCU1BQ0hfVEVSQV9QUk8yX1JBQ0sJVEVSQV9QUk8yX1JBQ0sJCTMwMDcKIHJ1YnlzCQkJTUFDSF9SVUJZUwkJUlVCWVMJCQkzMDA4CkBAIC0zMTkwLDcgKzMxOTAsNyBAQAogaWNzX2lmX3ZvaXAJCU1BQ0hfSUNTX0lGX1ZPSVAJSUNTX0lGX1ZPSVAJCTMyMDYKIHdsZl9jcmFnZ182NDEwCQlNQUNIX1dMRl9DUkFHR182NDEwCVdMRl9DUkFHR182NDEwCQkzMjA3CiBwdW5pY2EJCQlNQUNIX1BVTklDQQkJUFVOSUNBCQkJMzIwOAotc2JjX250MjUwCQlNQUNIX1NCQ19OVDI1MAkJU0JDX05UMjUwCQkzMjA5Cit0cmltc2xpY2UJCU1BQ0hfVFJJTVNMSUNFCQlUUklNU0xJQ0UJCTMyMDkKIG14Mjdfd211bHRyYQkJTUFDSF9NWDI3X1dNVUxUUkEJTVgyN19XTVVMVFJBCQkzMjEwCiBtYWNrZXJlbAkJTUFDSF9NQUNLRVJFTAkJTUFDS0VSRUwJCTMyMTEKIGZhOXgyNwkJCU1BQ0hfRkE5WDI3CQlGQTlYMjcJCQkzMjEzCkBAIC0zMjE5LDMgKzMyMTksMTAwIEBACiBwY20wNDgJCQlNQUNIX1BDTTA0OAkJUENNMDQ4CQkJMzIzNgogZGRzCQkJTUFDSF9ERFMJCUREUwkJCTMyMzcKIGNoYWx0ZW5feGExCQlNQUNIX0NIQUxURU5fWEExCUNIQUxURU5fWEExCQkzMjM4Cit0czQ4eHgJCQlNQUNIX1RTNDhYWAkJVFM0OFhYCQkJMzIzOQordG9uZ2EyX3RmdHRpbWVyCQlNQUNIX1RPTkdBMl9URlRUSU1FUglUT05HQTJfVEZUVElNRVIJCTMyNDAKK3doaXN0bGVyCQlNQUNIX1dISVNUTEVSCQlXSElTVExFUgkJMzI0MQorYXNsX3Bob2VuaXgJCU1BQ0hfQVNMX1BIT0VOSVgJQVNMX1BIT0VOSVgJCTMyNDIKK2F0OTFzYW05MjYzb3RsaXRlCU1BQ0hfQVQ5MVNBTTkyNjNPVExJVEUJQVQ5MVNBTTkyNjNPVExJVEUJMzI0MworZGRwbHVnCQkJTUFDSF9ERFBMVUcJCUREUExVRwkJCTMyNDQKK2QycGx1ZwkJCU1BQ0hfRDJQTFVHCQlEMlBMVUcJCQkzMjQ1Citrem05ZAkJCU1BQ0hfS1pNOUQJCUtaTTlECQkJMzI0NgordmVyZGlfbHRlCQlNQUNIX1ZFUkRJX0xURQkJVkVSRElfTFRFCQkzMjQ3CituYW5vem9vbQkJTUFDSF9OQU5PWk9PTQkJTkFOT1pPT00JCTMyNDgKK2RtMzczMF9zb21fbHYJCU1BQ0hfRE0zNzMwX1NPTV9MVglETTM3MzBfU09NX0xWCQkzMjQ5CitkbTM3MzBfdG9ycGVkbwkJTUFDSF9ETTM3MzBfVE9SUEVETwlETTM3MzBfVE9SUEVETwkJMzI1MAorYW5jaG92eQkJCU1BQ0hfQU5DSE9WWQkJQU5DSE9WWQkJCTMyNTEKK3JlMnJldjIwCQlNQUNIX1JFMlJFVjIwCQlSRTJSRVYyMAkJMzI1MworcmUycmV2MjEJCU1BQ0hfUkUyUkVWMjEJCVJFMlJFVjIxCQkzMjU0CitjbnMyMXh4CQkJTUFDSF9DTlMyMVhYCQlDTlMyMVhYCQkJMzI1NQorcmlkZXIJCQlNQUNIX1JJREVSCQlSSURFUgkJCTMyNTcKK25zazMzMAkJCU1BQ0hfTlNLMzMwCQlOU0szMzAJCQkzMjU4CitjbnMyMTMzZXZiCQlNQUNIX0NOUzIxMzNFVkIJCUNOUzIxMzNFVkIJCTMyNTkKK3ozXzgxNnhfbW9kCQlNQUNIX1ozXzgxNlhfTU9ECVozXzgxNlhfTU9ECQkzMjYwCit6M184MTR4X21vZAkJTUFDSF9aM184MTRYX01PRAlaM184MTRYX01PRAkJMzI2MQorYmVlY3QJCQlNQUNIX0JFRUNUCQlCRUVDVAkJCTMyNjIKK2RtYV90aHVuZGVyYnVnCQlNQUNIX0RNQV9USFVOREVSQlVHCURNQV9USFVOREVSQlVHCQkzMjYzCitvbW5fYXQ5MXNhbTlnMjAJCU1BQ0hfT01OX0FUOTFTQU05RzIwCU9NTl9BVDkxU0FNOUcyMAkJMzI2NAorbXgyNV9lMnNfdWMJCU1BQ0hfTVgyNV9FMlNfVUMJTVgyNV9FMlNfVUMJCTMyNjUKK21pb25lCQkJTUFDSF9NSU9ORQkJTUlPTkUJCQkzMjY2Cit0b3A5MDAwX3RjdQkJTUFDSF9UT1A5MDAwX1RDVQlUT1A5MDAwX1RDVQkJMzI2NwordG9wOTAwMF9ic2wJCU1BQ0hfVE9QOTAwMF9CU0wJVE9QOTAwMF9CU0wJCTMyNjgKK2tpbmdkb20JCQlNQUNIX0tJTkdET00JCUtJTkdET00JCQkzMjY5Cithcm1hZGlsbG80NjAJCU1BQ0hfQVJNQURJTExPNDYwCUFSTUFESUxMTzQ2MAkJMzI3MAorbHEyCQkJTUFDSF9MUTIJCUxRMgkJCTMyNzEKK3N3ZWRhX3RtczIJCU1BQ0hfU1dFREFfVE1TMgkJU1dFREFfVE1TMgkJMzI3MgorbXg1M19sb2NvCQlNQUNIX01YNTNfTE9DTwkJTVg1M19MT0NPCQkzMjczCithY2VyX2E4CQkJTUFDSF9BQ0VSX0E4CQlBQ0VSX0E4CQkJMzI3NQorYWNlcl9nYXVndWluCQlNQUNIX0FDRVJfR0FVR1VJTglBQ0VSX0dBVUdVSU4JCTMyNzYKK2d1cHB5CQkJTUFDSF9HVVBQWQkJR1VQUFkJCQkzMjc3CitteDYxX2FyZAkJTUFDSF9NWDYxX0FSRAkJTVg2MV9BUkQJCTMyNzgKK3R4NTMJCQlNQUNIX1RYNTMJCVRYNTMJCQkzMjc5CitvbWFwbDEzOF9jYXNlX2EzCU1BQ0hfT01BUEwxMzhfQ0FTRV9BMwlPTUFQTDEzOF9DQVNFX0EzCTMyODAKK3VlbWQJCQlNQUNIX1VFTUQJCVVFTUQJCQkzMjgxCitjY3dteDUxbXV0CQlNQUNIX0NDV01YNTFNVVQJCUNDV01YNTFNVVQJCTMyODIKK3JvY2tob3BwZXIJCU1BQ0hfUk9DS0hPUFBFUgkJUk9DS0hPUFBFUgkJMzI4Mworbm9va2NvbG9yCQlNQUNIX05PT0tDT0xPUgkJTk9PS0NPTE9SCQkzMjg0Citoa2RrYzEwMAkJTUFDSF9IS0RLQzEwMAkJSEtES0MxMDAJCTMyODUKK3RzNDJ4eAkJCU1BQ0hfVFM0MlhYCQlUUzQyWFgJCQkzMjg2CithZWJsCQkJTUFDSF9BRUJMCQlBRUJMCQkJMzI4Nword2FyaW8JCQlNQUNIX1dBUklPCQlXQVJJTwkJCTMyODgKK2dmc19zcG0JCQlNQUNIX0dGU19TUE0JCUdGU19TUE0JCQkzMjg5CitjbV90MzczMAkJTUFDSF9DTV9UMzczMAkJQ01fVDM3MzAJCTMyOTAKK2lzYzMJCQlNQUNIX0lTQzMJCUlTQzMJCQkzMjkxCityYXNjYWwJCQlNQUNIX1JBU0NBTAkJUkFTQ0FMCQkJMzI5MgoraHJlZnY2MAkJCU1BQ0hfSFJFRlY2MAkJSFJFRlY2MAkJCTMyOTMKK3RwdF8yXzAJCQlNQUNIX1RQVF8yXzAJCVRQVF8yXzAJCQkzMjk0CitweXJhbWlkX3RkCQlNQUNIX1BZUkFNSURfVEQJCVBZUkFNSURfVEQJCTMyOTUKK3NwbGVuZG9yCQlNQUNIX1NQTEVORE9SCQlTUExFTkRPUgkJMzI5NgorZ3VmX3BsYW5ldAkJTUFDSF9HVUZfUExBTkVUCQlHVUZfUExBTkVUCQkzMjk3Cittc204eDYwX3F0CQlNQUNIX01TTThYNjBfUVQJCU1TTThYNjBfUVQJCTMyOTgKK2h0Y19oZF9taW5pCQlNQUNIX0hUQ19IRF9NSU5JCUhUQ19IRF9NSU5JCQkzMjk5CithdGhlbmUJCQlNQUNIX0FUSEVORQkJQVRIRU5FCQkJMzMwMAorZGVlcF9yX2VrXzEJCU1BQ0hfREVFUF9SX0VLXzEJREVFUF9SX0VLXzEJCTMzMDEKK3Zpdm93X2N0CQlNQUNIX1ZJVk9XX0NUCQlWSVZPV19DVAkJMzMwMgorbmVyeV8xMDAwCQlNQUNIX05FUllfMTAwMAkJTkVSWV8xMDAwCQkzMzAzCityZmwxMDkxNDVfc3NydgkJTUFDSF9SRkwxMDkxNDVfU1NSVglSRkwxMDkxNDVfU1NSVgkJMzMwNAorbm1oCQkJTUFDSF9OTUgJCU5NSAkJCTMzMDUKK3duODAydAkJCU1BQ0hfV044MDJUCQlXTjgwMlQJCQkzMzA2CitkcmFnb25ldAkJTUFDSF9EUkFHT05FVAkJRFJBR09ORVQJCTMzMDcKK2dlbmV2YV9iCQlNQUNIX0dFTkVWQV9CCQlHRU5FVkFfQgkJMzMwOAorYXQ5MXNhbTkyNjNkZXNrMTZsCU1BQ0hfQVQ5MVNBTTkyNjNERVNLMTZMCUFUOTFTQU05MjYzREVTSzE2TAkzMzA5CitiY21oYW5hX3N2CQlNQUNIX0JDTUhBTkFfU1YJCUJDTUhBTkFfU1YJCTMzMTAKK2JjbWhhbmFfdGFibGV0CQlNQUNIX0JDTUhBTkFfVEFCTEVUCUJDTUhBTkFfVEFCTEVUCQkzMzExCitrb2kJCQlNQUNIX0tPSQkJS09JCQkJMzMxMgordHM0ODAwCQkJTUFDSF9UUzQ4MDAJCVRTNDgwMAkJCTMzMTMKK3RxbWE5MjYzCQlNQUNIX1RRTUE5MjYzCQlUUU1BOTI2MwkJMzMxNAoraG9saWRheQkJCU1BQ0hfSE9MSURBWQkJSE9MSURBWQkJCTMzMTUKK2RtYV82NDEwCQlNQUNIX0RNQTY0MTAJCURNQTY0MTAJCQkzMzE2CitwY2F0c19vdmVybGF5CQlNQUNIX1BDQVRTX09WRVJMQVkJUENBVFNfT1ZFUkxBWQkJMzMxNworaHdndzY0MTAJCU1BQ0hfSFdHVzY0MTAJCUhXR1c2NDEwCQkzMzE4CitzaGVuemhvdQkJTUFDSF9TSEVOWkhPVQkJU0hFTlpIT1UJCTMzMTkKK2N3bWU5MjEwCQlNQUNIX0NXTUU5MjEwCQlDV01FOTIxMAkJMzMyMAorY3dtZTkyMTBqcwkJTUFDSF9DV01FOTIxMEpTCQlDV01FOTIxMEpTCQkzMzIxCitwZ3NfdjEJCQlNQUNIX1BHU19TSVRBUkEJCVBHU19TSVRBUkEJCTMzMjIKK2NvbGlicmlfdGVncmEyCQlNQUNIX0NPTElCUklfVEVHUkEyCUNPTElCUklfVEVHUkEyCQkzMzIzCit3MjEJCQlNQUNIX1cyMQkJVzIxCQkJMzMyNAorcG9seXNhdDEJCU1BQ0hfUE9MWVNBVDEJCVBPTFlTQVQxCQkzMzI1CitkYXRhd2F5CQkJTUFDSF9EQVRBV0FZCQlEQVRBV0FZCQkJMzMyNgorY29icmFsMTM4CQlNQUNIX0NPQlJBTDEzOAkJQ09CUkFMMTM4CQkzMzI3Cityb3ZlcnBjczgJCU1BQ0hfUk9WRVJQQ1M4CQlST1ZFUlBDUzgJCTMzMjgKK21hcnZlbGMJCQlNQUNIX01BUlZFTEMJCU1BUlZFTEMJCQkzMzI5CituYXZlZmloaWQJCU1BQ0hfTkFWRUZJSElECQlOQVZFRklISUQJCTMzMzAKK2RtMzY1X2N2MTAwCQlNQUNIX0RNMzY1X0NWMTAwCURNMzY1X0NWMTAwCQkzMzMxCithYmxlCQkJTUFDSF9BQkxFCQlBQkxFCQkJMzMzMgorbGVnYWN5CQkJTUFDSF9MRUdBQ1kJCUxFR0FDWQkJCTMzMzMKK2ljb25nCQkJTUFDSF9JQ09ORwkJSUNPTkcJCQkzMzM0Cityb3Zlcl9nOAkJTUFDSF9ST1ZFUl9HOAkJUk9WRVJfRzgJCTMzMzUKK3Q1Mzg4cAkJCU1BQ0hfVDUzODhQCQlUNTM4OFAJCQkzMzM2CitkaW5nbwkJCU1BQ0hfRElOR08JCURJTkdPCQkJMzMzNworZ29mbGV4aG9tZQkJTUFDSF9HT0ZMRVhIT01FCQlHT0ZMRVhIT01FCQkzMzM4CmRpZmYgLS1naXQgYS9hcmNoL2F2cjMyL0tjb25maWcgYi9hcmNoL2F2cjMyL0tjb25maWcKaW5kZXggMzEzYjEzMC4uY2QyMDYyZiAxMDA2NDQKLS0tIGEvYXJjaC9hdnIzMi9LY29uZmlnCisrKyBiL2FyY2gvYXZyMzIvS2NvbmZpZwpAQCAtMSw4ICsxLDggQEAKIGNvbmZpZyBBVlIzMgogCWRlZl9ib29sIHkKLQkjIFdpdGggRU1CRURERUQ9biwgd2UgZ2V0IGxvdHMgb2Ygc3R1ZmYgYXV0b21hdGljYWxseSBzZWxlY3RlZAorCSMgV2l0aCBFWFBFUlQ9biwgd2UgZ2V0IGxvdHMgb2Ygc3R1ZmYgYXV0b21hdGljYWxseSBzZWxlY3RlZAogCSMgdGhhdCB3ZSB1c3VhbGx5IGRvbid0IG5lZWQgb24gQVZSMzIuCi0Jc2VsZWN0IEVNQkVEREVECisJc2VsZWN0IEVYUEVSVAogCXNlbGVjdCBIQVZFX0NMSwogCXNlbGVjdCBIQVZFX09QUk9GSUxFCiAJc2VsZWN0IEhBVkVfS1BST0JFUwpkaWZmIC0tZ2l0IGEvYXJjaC9hdnIzMi9ib2FyZHMvYXRuZ3cxMDAvc2V0dXAuYyBiL2FyY2gvYXZyMzIvYm9hcmRzL2F0bmd3MTAwL3NldHVwLmMKaW5kZXggOGM2YTI0NC4uNjU5ZDExOSAxMDA2NDQKLS0tIGEvYXJjaC9hdnIzMi9ib2FyZHMvYXRuZ3cxMDAvc2V0dXAuYworKysgYi9hcmNoL2F2cjMyL2JvYXJkcy9hdG5ndzEwMC9zZXR1cC5jCkBAIC0xODgsNyArMTg4LDcgQEAKIAkgKi8KIAlyZWdzID0gKHZvaWQgX19pb21lbSBfX2ZvcmNlICopcmVzLT5zdGFydDsKIAlwY2xrID0gY2xrX2dldCgmcGRldi0+ZGV2LCAicGNsayIpOwotCWlmICghcGNsaykKKwlpZiAoSVNfRVJSKHBjbGspKQogCQlyZXR1cm47CiAKIAljbGtfZW5hYmxlKHBjbGspOwpkaWZmIC0tZ2l0IGEvYXJjaC9hdnIzMi9ib2FyZHMvYXRzdGsxMDAwL2F0c3RrMTAwMi5jIGIvYXJjaC9hdnIzMi9ib2FyZHMvYXRzdGsxMDAwL2F0c3RrMTAwMi5jCmluZGV4IDJhZGMyNjEuLjZjZTMwZmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXZyMzIvYm9hcmRzL2F0c3RrMTAwMC9hdHN0azEwMDIuYworKysgYi9hcmNoL2F2cjMyL2JvYXJkcy9hdHN0azEwMDAvYXRzdGsxMDAyLmMKQEAgLTIwMyw3ICsyMDMsNyBAQAogCSAqLwogCXJlZ3MgPSAodm9pZCBfX2lvbWVtIF9fZm9yY2UgKilyZXMtPnN0YXJ0OwogCXBjbGsgPSBjbGtfZ2V0KCZwZGV2LT5kZXYsICJwY2xrIik7Ci0JaWYgKCFwY2xrKQorCWlmIChJU19FUlIocGNsaykpCiAJCXJldHVybjsKIAogCWNsa19lbmFibGUocGNsayk7CmRpZmYgLS1naXQgYS9hcmNoL2F2cjMyL2JvYXJkcy9mYXZyLTMyL3NldHVwLmMgYi9hcmNoL2F2cjMyL2JvYXJkcy9mYXZyLTMyL3NldHVwLmMKaW5kZXggNzVmMTlmNC4uODZmYWI3NyAxMDA2NDQKLS0tIGEvYXJjaC9hdnIzMi9ib2FyZHMvZmF2ci0zMi9zZXR1cC5jCisrKyBiL2FyY2gvYXZyMzIvYm9hcmRzL2ZhdnItMzIvc2V0dXAuYwpAQCAtMjA2LDcgKzIwNiw3IEBACiAJICovCiAJcmVncyA9ICh2b2lkIF9faW9tZW0gX19mb3JjZSAqKXJlcy0+c3RhcnQ7CiAJcGNsayA9IGNsa19nZXQoJnBkZXYtPmRldiwgInBjbGsiKTsKLQlpZiAoIXBjbGspCisJaWYgKElTX0VSUihwY2xrKSkKIAkJcmV0dXJuOwogCiAJY2xrX2VuYWJsZShwY2xrKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXZyMzIvYm9hcmRzL2hhbW1lcmhlYWQvc2V0dXAuYyBiL2FyY2gvYXZyMzIvYm9hcmRzL2hhbW1lcmhlYWQvc2V0dXAuYwppbmRleCBkZDAwOTg3NS4uZGExNGZiZCAxMDA2NDQKLS0tIGEvYXJjaC9hdnIzMi9ib2FyZHMvaGFtbWVyaGVhZC9zZXR1cC5jCisrKyBiL2FyY2gvYXZyMzIvYm9hcmRzL2hhbW1lcmhlYWQvc2V0dXAuYwpAQCAtMTUwLDcgKzE1MCw3IEBACiAJcmVncyA9ICh2b2lkIF9faW9tZW0gX19mb3JjZSAqKXJlcy0+c3RhcnQ7CiAJcGNsayA9IGNsa19nZXQoJnBkZXYtPmRldiwgInBjbGsiKTsKIAotCWlmICghcGNsaykKKwlpZiAoSVNfRVJSKHBjbGspKQogCQlyZXR1cm47CiAKIAljbGtfZW5hYmxlKHBjbGspOwpkaWZmIC0tZ2l0IGEvYXJjaC9hdnIzMi9ib2FyZHMvbWVyaXNjL3NldHVwLmMgYi9hcmNoL2F2cjMyL2JvYXJkcy9tZXJpc2Mvc2V0dXAuYwppbmRleCA2MjNiMDc3Li5lNjFiYzk0IDEwMDY0NAotLS0gYS9hcmNoL2F2cjMyL2JvYXJkcy9tZXJpc2Mvc2V0dXAuYworKysgYi9hcmNoL2F2cjMyL2JvYXJkcy9tZXJpc2Mvc2V0dXAuYwpAQCAtMTM0LDcgKzEzNCw3IEBACiAKIAlyZWdzID0gKHZvaWQgX19pb21lbSBfX2ZvcmNlICopcmVzLT5zdGFydDsKIAlwY2xrID0gY2xrX2dldCgmcGRldi0+ZGV2LCAicGNsayIpOwotCWlmICghcGNsaykKKwlpZiAoSVNfRVJSKHBjbGspKQogCQlyZXR1cm47CiAKIAljbGtfZW5hYmxlKHBjbGspOwpkaWZmIC0tZ2l0IGEvYXJjaC9hdnIzMi9ib2FyZHMvbWltYzIwMC9zZXR1cC5jIGIvYXJjaC9hdnIzMi9ib2FyZHMvbWltYzIwMC9zZXR1cC5jCmluZGV4IDUyM2Q4ZTEuLmM0ZGE1Y2IgMTAwNjQ0Ci0tLSBhL2FyY2gvYXZyMzIvYm9hcmRzL21pbWMyMDAvc2V0dXAuYworKysgYi9hcmNoL2F2cjMyL2JvYXJkcy9taW1jMjAwL3NldHVwLmMKQEAgLTE2Miw3ICsxNjIsNyBAQAogCSAqLwogCXJlZ3MgPSAodm9pZCBfX2lvbWVtIF9fZm9yY2UgKilyZXMtPnN0YXJ0OwogCXBjbGsgPSBjbGtfZ2V0KCZwZGV2LT5kZXYsICJwY2xrIik7Ci0JaWYgKCFwY2xrKQorCWlmIChJU19FUlIocGNsaykpCiAJCXJldHVybjsKIAogCWNsa19lbmFibGUocGNsayk7CmRpZmYgLS1naXQgYS9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBfZGVmY29uZmlnIGIvYXJjaC9hdnIzMi9jb25maWdzL2F0bmd3MTAwX2RlZmNvbmZpZwppbmRleCA5ODU0MDEzLi42ZjljYTU2IDEwMDY0NAotLS0gYS9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBfZGVmY29uZmlnCisrKyBiL2FyY2gvYXZyMzIvY29uZmlncy9hdG5ndzEwMF9kZWZjb25maWcKQEAgLTIsMjAgKzIsMTcgQEAKICMgQ09ORklHX0xPQ0FMVkVSU0lPTl9BVVRPIGlzIG5vdCBzZXQKIENPTkZJR19TWVNWSVBDPXkKIENPTkZJR19QT1NJWF9NUVVFVUU9eQotQ09ORklHX0JTRF9QUk9DRVNTX0FDQ1Q9eQotQ09ORklHX0JTRF9QUk9DRVNTX0FDQ1RfVjM9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKLUNPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKK0NPTkZJR19SRUxBWT15CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfQkFTRV9GVUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0NPTVBBVF9CUksgaXMgbm90IHNldAogQ09ORklHX1BST0ZJTElORz15CiBDT05GSUdfT1BST0ZJTEU9bQotQ09ORklHX0tQUk9CRVM9eQorIyBDT05GSUdfS1BST0JFUyBpcyBub3Qgc2V0CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15Ci1DT05GSUdfTU9EVUxFX0ZPUkNFX1VOTE9BRD15CiAjIENPTkZJR19CTEtfREVWX0JTRyBpcyBub3Qgc2V0CiAjIENPTkZJR19JT1NDSEVEX0RFQURMSU5FIGlzIG5vdCBzZXQKIENPTkZJR19OT19IWj15CkBAIC0yOSw2ICsyNiw3IEBACiBDT05GSUdfQ1BVX0ZSRVFfREVGQVVMVF9HT1ZfT05ERU1BTkQ9eQogQ09ORklHX0NQVV9GUkVRX0dPVl9VU0VSU1BBQ0U9eQogQ09ORklHX0NQVV9GUkVRX0FUMzJBUD15CitDT05GSUdfQ09SRV9EVU1QX0RFRkFVTFRfRUxGX0hFQURFUlM9eQogQ09ORklHX05FVD15CiBDT05GSUdfUEFDS0VUPXkKIENPTkZJR19VTklYPXkKQEAgLTcyLDggKzcwLDggQEAKIENPTkZJR19CTEtfREVWX0xPT1A9bQogQ09ORklHX0JMS19ERVZfTkJEPW0KIENPTkZJR19CTEtfREVWX1JBTT1tCitDT05GSUdfTUlTQ19ERVZJQ0VTPXkKIENPTkZJR19BVE1FTF9UQ0xJQj15Ci1DT05GSUdfRUVQUk9NX0FUMjQ9bQogQ09ORklHX05FVERFVklDRVM9eQogQ09ORklHX1RVTj1tCiBDT05GSUdfTkVUX0VUSEVSTkVUPXkKQEAgLTEwNiw2ICsxMDQsNyBAQAogQ09ORklHX1dBVENIRE9HPXkKIENPTkZJR19BVDMyQVA3MDBYX1dEVD15CiBDT05GSUdfVVNCX0dBREdFVD15CitDT05GSUdfVVNCX0dBREdFVF9WQlVTX0RSQVc9MzUwCiBDT05GSUdfVVNCX1pFUk89bQogQ09ORklHX1VTQl9FVEg9bQogQ09ORklHX1VTQl9HQURHRVRGUz1tCkBAIC0xMTUsMTQgKzExNCwxMiBAQAogQ09ORklHX01NQz15CiBDT05GSUdfTU1DX1RFU1Q9bQogQ09ORklHX01NQ19BVE1FTE1DST15Ci1DT05GSUdfTU1DX1NQST1tCiBDT05GSUdfTkVXX0xFRFM9eQogQ09ORklHX0xFRFNfQ0xBU1M9eQogQ09ORklHX0xFRFNfR1BJTz15CiBDT05GSUdfTEVEU19UUklHR0VSUz15CiBDT05GSUdfTEVEU19UUklHR0VSX1RJTUVSPXkKIENPTkZJR19MRURTX1RSSUdHRVJfSEVBUlRCRUFUPXkKLUNPTkZJR19MRURTX1RSSUdHRVJfREVGQVVMVF9PTj15CiBDT05GSUdfUlRDX0NMQVNTPXkKIENPTkZJR19SVENfRFJWX0FUMzJBUDcwMFg9eQogQ09ORklHX0RNQURFVklDRVM9eQpAQCAtMTMwLDIxICsxMjcsMjMgQEAKIENPTkZJR19FWFQzX0ZTPXkKICMgQ09ORklHX0VYVDNfREVGQVVMVFNfVE9fT1JERVJFRCBpcyBub3Qgc2V0CiAjIENPTkZJR19FWFQzX0ZTX1hBVFRSIGlzIG5vdCBzZXQKK0NPTkZJR19FWFQ0X0ZTPXkKKyMgQ09ORklHX0VYVDRfRlNfWEFUVFIgaXMgbm90IHNldAogIyBDT05GSUdfRE5PVElGWSBpcyBub3Qgc2V0CiBDT05GSUdfRlVTRV9GUz1tCiBDT05GSUdfTVNET1NfRlM9bQogQ09ORklHX1ZGQVRfRlM9bQogQ09ORklHX0ZBVF9ERUZBVUxUX0NPREVQQUdFPTg1MAorQ09ORklHX1BST0NfS0NPUkU9eQogQ09ORklHX1RNUEZTPXkKLUNPTkZJR19DT05GSUdGU19GUz1tCitDT05GSUdfQ09ORklHRlNfRlM9eQogQ09ORklHX0pGRlMyX0ZTPXkKLUNPTkZJR19VRlNfRlM9eQorQ09ORklHX1VCSUZTX0ZTPXkKIENPTkZJR19ORlNfRlM9eQogQ09ORklHX05GU19WMz15CiBDT05GSUdfUk9PVF9ORlM9eQogQ09ORklHX05GU0Q9bQogQ09ORklHX05GU0RfVjM9eQotQ09ORklHX1NNQl9GUz1tCiBDT05GSUdfQ0lGUz1tCiBDT05GSUdfTkxTX0NPREVQQUdFXzQzNz1tCiBDT05GSUdfTkxTX0NPREVQQUdFXzg1MD1tCkBAIC0xNTUsNSArMTU0LDMgQEAKIENPTkZJR19ERUJVR19LRVJORUw9eQogQ09ORklHX0RFVEVDVF9IVU5HX1RBU0s9eQogQ09ORklHX0ZSQU1FX1BPSU5URVI9eQotIyBDT05GSUdfUkNVX0NQVV9TVEFMTF9ERVRFQ1RPUiBpcyBub3Qgc2V0Ci1DT05GSUdfQ1JZUFRPX1BDQkM9bQpkaWZmIC0tZ2l0IGEvYXJjaC9hdnIzMi9jb25maWdzL2F0bmd3MTAwX2V2a2xjZDEwMF9kZWZjb25maWcgYi9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBfZXZrbGNkMTAwX2RlZmNvbmZpZwppbmRleCA3Y2VkYTM1Li43ZWVjZTBhIDEwMDY0NAotLS0gYS9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBfZXZrbGNkMTAwX2RlZmNvbmZpZworKysgYi9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBfZXZrbGNkMTAwX2RlZmNvbmZpZwpAQCAtMiwyMCArMiwxNyBAQAogIyBDT05GSUdfTE9DQUxWRVJTSU9OX0FVVE8gaXMgbm90IHNldAogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX1BPU0lYX01RVUVVRT15Ci1DT05GSUdfQlNEX1BST0NFU1NfQUNDVD15Ci1DT05GSUdfQlNEX1BST0NFU1NfQUNDVF9WMz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQorQ09ORklHX1JFTEFZPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19CQVNFX0ZVTEwgaXMgbm90IHNldAogIyBDT05GSUdfQ09NUEFUX0JSSyBpcyBub3Qgc2V0CiBDT05GSUdfUFJPRklMSU5HPXkKIENPTkZJR19PUFJPRklMRT1tCi1DT05GSUdfS1BST0JFUz15CisjIENPTkZJR19LUFJPQkVTIGlzIG5vdCBzZXQKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKLUNPTkZJR19NT0RVTEVfRk9SQ0VfVU5MT0FEPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKICMgQ09ORklHX0lPU0NIRURfREVBRExJTkUgaXMgbm90IHNldAogQ09ORklHX05PX0haPXkKQEAgLTMxLDYgKzI4LDcgQEAKIENPTkZJR19DUFVfRlJFUV9ERUZBVUxUX0dPVl9PTkRFTUFORD15CiBDT05GSUdfQ1BVX0ZSRVFfR09WX1VTRVJTUEFDRT15CiBDT05GSUdfQ1BVX0ZSRVFfQVQzMkFQPXkKK0NPTkZJR19DT1JFX0RVTVBfREVGQVVMVF9FTEZfSEVBREVSUz15CiBDT05GSUdfTkVUPXkKIENPTkZJR19QQUNLRVQ9eQogQ09ORklHX1VOSVg9eQpAQCAtNzQsOCArNzIsMTAgQEAKIENPTkZJR19CTEtfREVWX0xPT1A9bQogQ09ORklHX0JMS19ERVZfTkJEPW0KIENPTkZJR19CTEtfREVWX1JBTT1tCitDT05GSUdfTUlTQ19ERVZJQ0VTPXkKIENPTkZJR19BVE1FTF9UQ0xJQj15CiBDT05GSUdfTkVUREVWSUNFUz15CitDT05GSUdfVFVOPW0KIENPTkZJR19ORVRfRVRIRVJORVQ9eQogQ09ORklHX01BQ0I9eQogIyBDT05GSUdfTkVUREVWXzEwMDAgaXMgbm90IHNldApAQCAtMTA0LDYgKzEwNCw3IEBACiBDT05GSUdfU1BJPXkKIENPTkZJR19TUElfQVRNRUw9eQogQ09ORklHX1NQSV9TUElERVY9bQorQ09ORklHX0dQSU9fU1lTRlM9eQogIyBDT05GSUdfSFdNT04gaXMgbm90IHNldAogQ09ORklHX1dBVENIRE9HPXkKIENPTkZJR19BVDMyQVA3MDBYX1dEVD15CkBAIC0xMjcsNiArMTI4LDcgQEAKIENPTkZJR19VU0JfR19TRVJJQUw9bQogQ09ORklHX1VTQl9DRENfQ09NUE9TSVRFPW0KIENPTkZJR19NTUM9eQorQ09ORklHX01NQ19URVNUPW0KIENPTkZJR19NTUNfQVRNRUxNQ0k9eQogQ09ORklHX05FV19MRURTPXkKIENPTkZJR19MRURTX0NMQVNTPXkKQEAgLTE0MSwxMSArMTQzLDE0IEBACiBDT05GSUdfRVhUM19GUz15CiAjIENPTkZJR19FWFQzX0RFRkFVTFRTX1RPX09SREVSRUQgaXMgbm90IHNldAogIyBDT05GSUdfRVhUM19GU19YQVRUUiBpcyBub3Qgc2V0CitDT05GSUdfRVhUNF9GUz15CisjIENPTkZJR19FWFQ0X0ZTX1hBVFRSIGlzIG5vdCBzZXQKICMgQ09ORklHX0ROT1RJRlkgaXMgbm90IHNldAogQ09ORklHX0ZVU0VfRlM9bQogQ09ORklHX01TRE9TX0ZTPW0KIENPTkZJR19WRkFUX0ZTPW0KIENPTkZJR19GQVRfREVGQVVMVF9DT0RFUEFHRT04NTAKK0NPTkZJR19QUk9DX0tDT1JFPXkKIENPTkZJR19UTVBGUz15CiBDT05GSUdfQ09ORklHRlNfRlM9eQogQ09ORklHX0pGRlMyX0ZTPXkKQEAgLTE1NSw3ICsxNjAsNiBAQAogQ09ORklHX1JPT1RfTkZTPXkKIENPTkZJR19ORlNEPW0KIENPTkZJR19ORlNEX1YzPXkKLUNPTkZJR19TTUJfRlM9bQogQ09ORklHX0NJRlM9bQogQ09ORklHX05MU19DT0RFUEFHRV80Mzc9bQogQ09ORklHX05MU19DT0RFUEFHRV84NTA9bQpAQCAtMTY2LDQgKzE3MCwzIEBACiBDT05GSUdfREVCVUdfS0VSTkVMPXkKIENPTkZJR19ERVRFQ1RfSFVOR19UQVNLPXkKIENPTkZJR19GUkFNRV9QT0lOVEVSPXkKLSMgQ09ORklHX1JDVV9DUFVfU1RBTExfREVURUNUT1IgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9hdnIzMi9jb25maWdzL2F0bmd3MTAwX2V2a2xjZDEwMV9kZWZjb25maWcgYi9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBfZXZrbGNkMTAxX2RlZmNvbmZpZwppbmRleCA3YmM1YjJjLi4zODdlYjlkIDEwMDY0NAotLS0gYS9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBfZXZrbGNkMTAxX2RlZmNvbmZpZworKysgYi9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBfZXZrbGNkMTAxX2RlZmNvbmZpZwpAQCAtMiwyMCArMiwxNyBAQAogIyBDT05GSUdfTE9DQUxWRVJTSU9OX0FVVE8gaXMgbm90IHNldAogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX1BPU0lYX01RVUVVRT15Ci1DT05GSUdfQlNEX1BST0NFU1NfQUNDVD15Ci1DT05GSUdfQlNEX1BST0NFU1NfQUNDVF9WMz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQorQ09ORklHX1JFTEFZPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19CQVNFX0ZVTEwgaXMgbm90IHNldAogIyBDT05GSUdfQ09NUEFUX0JSSyBpcyBub3Qgc2V0CiBDT05GSUdfUFJPRklMSU5HPXkKIENPTkZJR19PUFJPRklMRT1tCi1DT05GSUdfS1BST0JFUz15CisjIENPTkZJR19LUFJPQkVTIGlzIG5vdCBzZXQKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKLUNPTkZJR19NT0RVTEVfRk9SQ0VfVU5MT0FEPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKICMgQ09ORklHX0lPU0NIRURfREVBRExJTkUgaXMgbm90IHNldAogQ09ORklHX05PX0haPXkKQEAgLTMwLDYgKzI3LDcgQEAKIENPTkZJR19DUFVfRlJFUV9ERUZBVUxUX0dPVl9PTkRFTUFORD15CiBDT05GSUdfQ1BVX0ZSRVFfR09WX1VTRVJTUEFDRT15CiBDT05GSUdfQ1BVX0ZSRVFfQVQzMkFQPXkKK0NPTkZJR19DT1JFX0RVTVBfREVGQVVMVF9FTEZfSEVBREVSUz15CiBDT05GSUdfTkVUPXkKIENPTkZJR19QQUNLRVQ9eQogQ09ORklHX1VOSVg9eQpAQCAtNzMsOCArNzEsMTAgQEAKIENPTkZJR19CTEtfREVWX0xPT1A9bQogQ09ORklHX0JMS19ERVZfTkJEPW0KIENPTkZJR19CTEtfREVWX1JBTT1tCitDT05GSUdfTUlTQ19ERVZJQ0VTPXkKIENPTkZJR19BVE1FTF9UQ0xJQj15CiBDT05GSUdfTkVUREVWSUNFUz15CitDT05GSUdfVFVOPW0KIENPTkZJR19ORVRfRVRIRVJORVQ9eQogQ09ORklHX01BQ0I9eQogIyBDT05GSUdfTkVUREVWXzEwMDAgaXMgbm90IHNldApAQCAtMTAzLDYgKzEwMyw3IEBACiBDT05GSUdfU1BJPXkKIENPTkZJR19TUElfQVRNRUw9eQogQ09ORklHX1NQSV9TUElERVY9bQorQ09ORklHX0dQSU9fU1lTRlM9eQogIyBDT05GSUdfSFdNT04gaXMgbm90IHNldAogQ09ORklHX1dBVENIRE9HPXkKIENPTkZJR19BVDMyQVA3MDBYX1dEVD15CkBAIC0xMjYsNiArMTI3LDcgQEAKIENPTkZJR19VU0JfR19TRVJJQUw9bQogQ09ORklHX1VTQl9DRENfQ09NUE9TSVRFPW0KIENPTkZJR19NTUM9eQorQ09ORklHX01NQ19URVNUPW0KIENPTkZJR19NTUNfQVRNRUxNQ0k9eQogQ09ORklHX05FV19MRURTPXkKIENPTkZJR19MRURTX0NMQVNTPXkKQEAgLTE0MCwxMSArMTQyLDE0IEBACiBDT05GSUdfRVhUM19GUz15CiAjIENPTkZJR19FWFQzX0RFRkFVTFRTX1RPX09SREVSRUQgaXMgbm90IHNldAogIyBDT05GSUdfRVhUM19GU19YQVRUUiBpcyBub3Qgc2V0CitDT05GSUdfRVhUNF9GUz15CisjIENPTkZJR19FWFQ0X0ZTX1hBVFRSIGlzIG5vdCBzZXQKICMgQ09ORklHX0ROT1RJRlkgaXMgbm90IHNldAogQ09ORklHX0ZVU0VfRlM9bQogQ09ORklHX01TRE9TX0ZTPW0KIENPTkZJR19WRkFUX0ZTPW0KIENPTkZJR19GQVRfREVGQVVMVF9DT0RFUEFHRT04NTAKK0NPTkZJR19QUk9DX0tDT1JFPXkKIENPTkZJR19UTVBGUz15CiBDT05GSUdfQ09ORklHRlNfRlM9eQogQ09ORklHX0pGRlMyX0ZTPXkKQEAgLTE1NCw3ICsxNTksNiBAQAogQ09ORklHX1JPT1RfTkZTPXkKIENPTkZJR19ORlNEPW0KIENPTkZJR19ORlNEX1YzPXkKLUNPTkZJR19TTUJfRlM9bQogQ09ORklHX0NJRlM9bQogQ09ORklHX05MU19DT0RFUEFHRV80Mzc9bQogQ09ORklHX05MU19DT0RFUEFHRV84NTA9bQpAQCAtMTY1LDQgKzE2OSwzIEBACiBDT05GSUdfREVCVUdfS0VSTkVMPXkKIENPTkZJR19ERVRFQ1RfSFVOR19UQVNLPXkKIENPTkZJR19GUkFNRV9QT0lOVEVSPXkKLSMgQ09ORklHX1JDVV9DUFVfU1RBTExfREVURUNUT1IgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9hdnIzMi9jb25maWdzL2F0bmd3MTAwbWtpaV9kZWZjb25maWcgYi9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBta2lpX2RlZmNvbmZpZwppbmRleCA0YmQzNjgyLi5mMGZlMjM3IDEwMDY0NAotLS0gYS9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBta2lpX2RlZmNvbmZpZworKysgYi9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBta2lpX2RlZmNvbmZpZwpAQCAtMiwyMCArMiwxNyBAQAogIyBDT05GSUdfTE9DQUxWRVJTSU9OX0FVVE8gaXMgbm90IHNldAogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX1BPU0lYX01RVUVVRT15Ci1DT05GSUdfQlNEX1BST0NFU1NfQUNDVD15Ci1DT05GSUdfQlNEX1BST0NFU1NfQUNDVF9WMz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQorQ09ORklHX1JFTEFZPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19CQVNFX0ZVTEwgaXMgbm90IHNldAogIyBDT05GSUdfQ09NUEFUX0JSSyBpcyBub3Qgc2V0CiBDT05GSUdfUFJPRklMSU5HPXkKIENPTkZJR19PUFJPRklMRT1tCi1DT05GSUdfS1BST0JFUz15CisjIENPTkZJR19LUFJPQkVTIGlzIG5vdCBzZXQKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKLUNPTkZJR19NT0RVTEVfRk9SQ0VfVU5MT0FEPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKICMgQ09ORklHX0lPU0NIRURfREVBRExJTkUgaXMgbm90IHNldAogQ09ORklHX05PX0haPXkKQEAgLTI5LDYgKzI2LDcgQEAKIENPTkZJR19DUFVfRlJFUV9ERUZBVUxUX0dPVl9PTkRFTUFORD15CiBDT05GSUdfQ1BVX0ZSRVFfR09WX1VTRVJTUEFDRT15CiBDT05GSUdfQ1BVX0ZSRVFfQVQzMkFQPXkKK0NPTkZJR19DT1JFX0RVTVBfREVGQVVMVF9FTEZfSEVBREVSUz15CiBDT05GSUdfTkVUPXkKIENPTkZJR19QQUNLRVQ9eQogQ09ORklHX1VOSVg9eQpAQCAtNzQsNiArNzIsNyBAQAogQ09ORklHX0JMS19ERVZfTE9PUD1tCiBDT05GSUdfQkxLX0RFVl9OQkQ9bQogQ09ORklHX0JMS19ERVZfUkFNPW0KK0NPTkZJR19NSVNDX0RFVklDRVM9eQogQ09ORklHX0FUTUVMX1RDTElCPXkKIENPTkZJR19ORVRERVZJQ0VTPXkKIENPTkZJR19UVU49bQpAQCAtMTA3LDYgKzEwNiw3IEBACiBDT05GSUdfV0FUQ0hET0c9eQogQ09ORklHX0FUMzJBUDcwMFhfV0RUPXkKIENPTkZJR19VU0JfR0FER0VUPXkKK0NPTkZJR19VU0JfR0FER0VUX1ZCVVNfRFJBVz0zNTAKIENPTkZJR19VU0JfWkVSTz1tCiBDT05GSUdfVVNCX0VUSD1tCiBDT05GSUdfVVNCX0dBREdFVEZTPW0KQEAgLTExNiwxNCArMTE2LDEyIEBACiBDT05GSUdfTU1DPXkKIENPTkZJR19NTUNfVEVTVD1tCiBDT05GSUdfTU1DX0FUTUVMTUNJPXkKLUNPTkZJR19NTUNfU1BJPW0KIENPTkZJR19ORVdfTEVEUz15CiBDT05GSUdfTEVEU19DTEFTUz15CiBDT05GSUdfTEVEU19HUElPPXkKIENPTkZJR19MRURTX1RSSUdHRVJTPXkKIENPTkZJR19MRURTX1RSSUdHRVJfVElNRVI9eQogQ09ORklHX0xFRFNfVFJJR0dFUl9IRUFSVEJFQVQ9eQotQ09ORklHX0xFRFNfVFJJR0dFUl9ERUZBVUxUX09OPXkKIENPTkZJR19SVENfQ0xBU1M9eQogQ09ORklHX1JUQ19EUlZfQVQzMkFQNzAwWD15CiBDT05GSUdfRE1BREVWSUNFUz15CkBAIC0xMzEsMjEgKzEyOSwyMyBAQAogQ09ORklHX0VYVDNfRlM9eQogIyBDT05GSUdfRVhUM19ERUZBVUxUU19UT19PUkRFUkVEIGlzIG5vdCBzZXQKICMgQ09ORklHX0VYVDNfRlNfWEFUVFIgaXMgbm90IHNldAorQ09ORklHX0VYVDRfRlM9eQorIyBDT05GSUdfRVhUNF9GU19YQVRUUiBpcyBub3Qgc2V0CiAjIENPTkZJR19ETk9USUZZIGlzIG5vdCBzZXQKIENPTkZJR19GVVNFX0ZTPW0KIENPTkZJR19NU0RPU19GUz1tCiBDT05GSUdfVkZBVF9GUz1tCiBDT05GSUdfRkFUX0RFRkFVTFRfQ09ERVBBR0U9ODUwCitDT05GSUdfUFJPQ19LQ09SRT15CiBDT05GSUdfVE1QRlM9eQotQ09ORklHX0NPTkZJR0ZTX0ZTPW0KK0NPTkZJR19DT05GSUdGU19GUz15CiBDT05GSUdfSkZGUzJfRlM9eQotQ09ORklHX1VGU19GUz15CitDT05GSUdfVUJJRlNfRlM9eQogQ09ORklHX05GU19GUz15CiBDT05GSUdfTkZTX1YzPXkKIENPTkZJR19ST09UX05GUz15CiBDT05GSUdfTkZTRD1tCiBDT05GSUdfTkZTRF9WMz15Ci1DT05GSUdfU01CX0ZTPW0KIENPTkZJR19DSUZTPW0KIENPTkZJR19OTFNfQ09ERVBBR0VfNDM3PW0KIENPTkZJR19OTFNfQ09ERVBBR0VfODUwPW0KQEAgLTE1Niw1ICsxNTYsMyBAQAogQ09ORklHX0RFQlVHX0tFUk5FTD15CiBDT05GSUdfREVURUNUX0hVTkdfVEFTSz15CiBDT05GSUdfRlJBTUVfUE9JTlRFUj15Ci0jIENPTkZJR19SQ1VfQ1BVX1NUQUxMX0RFVEVDVE9SIGlzIG5vdCBzZXQKLUNPTkZJR19DUllQVE9fUENCQz1tCmRpZmYgLS1naXQgYS9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBta2lpX2V2a2xjZDEwMF9kZWZjb25maWcgYi9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBta2lpX2V2a2xjZDEwMF9kZWZjb25maWcKaW5kZXggZjg0MzdlZi4uZTRhN2MxZCAxMDA2NDQKLS0tIGEvYXJjaC9hdnIzMi9jb25maWdzL2F0bmd3MTAwbWtpaV9ldmtsY2QxMDBfZGVmY29uZmlnCisrKyBiL2FyY2gvYXZyMzIvY29uZmlncy9hdG5ndzEwMG1raWlfZXZrbGNkMTAwX2RlZmNvbmZpZwpAQCAtMiwyMCArMiwxNyBAQAogIyBDT05GSUdfTE9DQUxWRVJTSU9OX0FVVE8gaXMgbm90IHNldAogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX1BPU0lYX01RVUVVRT15Ci1DT05GSUdfQlNEX1BST0NFU1NfQUNDVD15Ci1DT05GSUdfQlNEX1BST0NFU1NfQUNDVF9WMz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQorQ09ORklHX1JFTEFZPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19CQVNFX0ZVTEwgaXMgbm90IHNldAogIyBDT05GSUdfQ09NUEFUX0JSSyBpcyBub3Qgc2V0CiBDT05GSUdfUFJPRklMSU5HPXkKIENPTkZJR19PUFJPRklMRT1tCi1DT05GSUdfS1BST0JFUz15CisjIENPTkZJR19LUFJPQkVTIGlzIG5vdCBzZXQKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKLUNPTkZJR19NT0RVTEVfRk9SQ0VfVU5MT0FEPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKICMgQ09ORklHX0lPU0NIRURfREVBRExJTkUgaXMgbm90IHNldAogQ09ORklHX05PX0haPXkKQEAgLTMyLDYgKzI5LDcgQEAKIENPTkZJR19DUFVfRlJFUV9ERUZBVUxUX0dPVl9PTkRFTUFORD15CiBDT05GSUdfQ1BVX0ZSRVFfR09WX1VTRVJTUEFDRT15CiBDT05GSUdfQ1BVX0ZSRVFfQVQzMkFQPXkKK0NPTkZJR19DT1JFX0RVTVBfREVGQVVMVF9FTEZfSEVBREVSUz15CiBDT05GSUdfTkVUPXkKIENPTkZJR19QQUNLRVQ9eQogQ09ORklHX1VOSVg9eQpAQCAtNzcsOCArNzUsMTAgQEAKIENPTkZJR19CTEtfREVWX0xPT1A9bQogQ09ORklHX0JMS19ERVZfTkJEPW0KIENPTkZJR19CTEtfREVWX1JBTT1tCitDT05GSUdfTUlTQ19ERVZJQ0VTPXkKIENPTkZJR19BVE1FTF9UQ0xJQj15CiBDT05GSUdfTkVUREVWSUNFUz15CitDT05GSUdfVFVOPW0KIENPTkZJR19ORVRfRVRIRVJORVQ9eQogQ09ORklHX01BQ0I9eQogIyBDT05GSUdfTkVUREVWXzEwMDAgaXMgbm90IHNldApAQCAtMTA3LDYgKzEwNyw3IEBACiBDT05GSUdfU1BJPXkKIENPTkZJR19TUElfQVRNRUw9eQogQ09ORklHX1NQSV9TUElERVY9bQorQ09ORklHX0dQSU9fU1lTRlM9eQogIyBDT05GSUdfSFdNT04gaXMgbm90IHNldAogQ09ORklHX1dBVENIRE9HPXkKIENPTkZJR19BVDMyQVA3MDBYX1dEVD15CkBAIC0xMzAsNiArMTMxLDcgQEAKIENPTkZJR19VU0JfR19TRVJJQUw9bQogQ09ORklHX1VTQl9DRENfQ09NUE9TSVRFPW0KIENPTkZJR19NTUM9eQorQ09ORklHX01NQ19URVNUPW0KIENPTkZJR19NTUNfQVRNRUxNQ0k9eQogQ09ORklHX05FV19MRURTPXkKIENPTkZJR19MRURTX0NMQVNTPXkKQEAgLTE0NCwxMSArMTQ2LDE0IEBACiBDT05GSUdfRVhUM19GUz15CiAjIENPTkZJR19FWFQzX0RFRkFVTFRTX1RPX09SREVSRUQgaXMgbm90IHNldAogIyBDT05GSUdfRVhUM19GU19YQVRUUiBpcyBub3Qgc2V0CitDT05GSUdfRVhUNF9GUz15CisjIENPTkZJR19FWFQ0X0ZTX1hBVFRSIGlzIG5vdCBzZXQKICMgQ09ORklHX0ROT1RJRlkgaXMgbm90IHNldAogQ09ORklHX0ZVU0VfRlM9bQogQ09ORklHX01TRE9TX0ZTPW0KIENPTkZJR19WRkFUX0ZTPW0KIENPTkZJR19GQVRfREVGQVVMVF9DT0RFUEFHRT04NTAKK0NPTkZJR19QUk9DX0tDT1JFPXkKIENPTkZJR19UTVBGUz15CiBDT05GSUdfQ09ORklHRlNfRlM9eQogQ09ORklHX0pGRlMyX0ZTPXkKQEAgLTE1OCw3ICsxNjMsNiBAQAogQ09ORklHX1JPT1RfTkZTPXkKIENPTkZJR19ORlNEPW0KIENPTkZJR19ORlNEX1YzPXkKLUNPTkZJR19TTUJfRlM9bQogQ09ORklHX0NJRlM9bQogQ09ORklHX05MU19DT0RFUEFHRV80Mzc9bQogQ09ORklHX05MU19DT0RFUEFHRV84NTA9bQpAQCAtMTY5LDQgKzE3MywzIEBACiBDT05GSUdfREVCVUdfS0VSTkVMPXkKIENPTkZJR19ERVRFQ1RfSFVOR19UQVNLPXkKIENPTkZJR19GUkFNRV9QT0lOVEVSPXkKLSMgQ09ORklHX1JDVV9DUFVfU1RBTExfREVURUNUT1IgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9hdnIzMi9jb25maWdzL2F0bmd3MTAwbWtpaV9ldmtsY2QxMDFfZGVmY29uZmlnIGIvYXJjaC9hdnIzMi9jb25maWdzL2F0bmd3MTAwbWtpaV9ldmtsY2QxMDFfZGVmY29uZmlnCmluZGV4IDdmNThmOTkuLjZmMzdmNzAgMTAwNjQ0Ci0tLSBhL2FyY2gvYXZyMzIvY29uZmlncy9hdG5ndzEwMG1raWlfZXZrbGNkMTAxX2RlZmNvbmZpZworKysgYi9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRuZ3cxMDBta2lpX2V2a2xjZDEwMV9kZWZjb25maWcKQEAgLTIsMjAgKzIsMTcgQEAKICMgQ09ORklHX0xPQ0FMVkVSU0lPTl9BVVRPIGlzIG5vdCBzZXQKIENPTkZJR19TWVNWSVBDPXkKIENPTkZJR19QT1NJWF9NUVVFVUU9eQotQ09ORklHX0JTRF9QUk9DRVNTX0FDQ1Q9eQotQ09ORklHX0JTRF9QUk9DRVNTX0FDQ1RfVjM9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKLUNPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKK0NPTkZJR19SRUxBWT15CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfQkFTRV9GVUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0NPTVBBVF9CUksgaXMgbm90IHNldAogQ09ORklHX1BST0ZJTElORz15CiBDT05GSUdfT1BST0ZJTEU9bQotQ09ORklHX0tQUk9CRVM9eQorIyBDT05GSUdfS1BST0JFUyBpcyBub3Qgc2V0CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15Ci1DT05GSUdfTU9EVUxFX0ZPUkNFX1VOTE9BRD15CiAjIENPTkZJR19CTEtfREVWX0JTRyBpcyBub3Qgc2V0CiAjIENPTkZJR19JT1NDSEVEX0RFQURMSU5FIGlzIG5vdCBzZXQKIENPTkZJR19OT19IWj15CkBAIC0zMSw2ICsyOCw3IEBACiBDT05GSUdfQ1BVX0ZSRVFfREVGQVVMVF9HT1ZfT05ERU1BTkQ9eQogQ09ORklHX0NQVV9GUkVRX0dPVl9VU0VSU1BBQ0U9eQogQ09ORklHX0NQVV9GUkVRX0FUMzJBUD15CitDT05GSUdfQ09SRV9EVU1QX0RFRkFVTFRfRUxGX0hFQURFUlM9eQogQ09ORklHX05FVD15CiBDT05GSUdfUEFDS0VUPXkKIENPTkZJR19VTklYPXkKQEAgLTc2LDggKzc0LDEwIEBACiBDT05GSUdfQkxLX0RFVl9MT09QPW0KIENPTkZJR19CTEtfREVWX05CRD1tCiBDT05GSUdfQkxLX0RFVl9SQU09bQorQ09ORklHX01JU0NfREVWSUNFUz15CiBDT05GSUdfQVRNRUxfVENMSUI9eQogQ09ORklHX05FVERFVklDRVM9eQorQ09ORklHX1RVTj1tCiBDT05GSUdfTkVUX0VUSEVSTkVUPXkKIENPTkZJR19NQUNCPXkKICMgQ09ORklHX05FVERFVl8xMDAwIGlzIG5vdCBzZXQKQEAgLTEwNiw2ICsxMDYsNyBAQAogQ09ORklHX1NQST15CiBDT05GSUdfU1BJX0FUTUVMPXkKIENPTkZJR19TUElfU1BJREVWPW0KK0NPTkZJR19HUElPX1NZU0ZTPXkKICMgQ09ORklHX0hXTU9OIGlzIG5vdCBzZXQKIENPTkZJR19XQVRDSERPRz15CiBDT05GSUdfQVQzMkFQNzAwWF9XRFQ9eQpAQCAtMTI5LDYgKzEzMCw3IEBACiBDT05GSUdfVVNCX0dfU0VSSUFMPW0KIENPTkZJR19VU0JfQ0RDX0NPTVBPU0lURT1tCiBDT05GSUdfTU1DPXkKK0NPTkZJR19NTUNfVEVTVD1tCiBDT05GSUdfTU1DX0FUTUVMTUNJPXkKIENPTkZJR19ORVdfTEVEUz15CiBDT05GSUdfTEVEU19DTEFTUz15CkBAIC0xNDMsMTEgKzE0NSwxNCBAQAogQ09ORklHX0VYVDNfRlM9eQogIyBDT05GSUdfRVhUM19ERUZBVUxUU19UT19PUkRFUkVEIGlzIG5vdCBzZXQKICMgQ09ORklHX0VYVDNfRlNfWEFUVFIgaXMgbm90IHNldAorQ09ORklHX0VYVDRfRlM9eQorIyBDT05GSUdfRVhUNF9GU19YQVRUUiBpcyBub3Qgc2V0CiAjIENPTkZJR19ETk9USUZZIGlzIG5vdCBzZXQKIENPTkZJR19GVVNFX0ZTPW0KIENPTkZJR19NU0RPU19GUz1tCiBDT05GSUdfVkZBVF9GUz1tCiBDT05GSUdfRkFUX0RFRkFVTFRfQ09ERVBBR0U9ODUwCitDT05GSUdfUFJPQ19LQ09SRT15CiBDT05GSUdfVE1QRlM9eQogQ09ORklHX0NPTkZJR0ZTX0ZTPXkKIENPTkZJR19KRkZTMl9GUz15CkBAIC0xNTcsNyArMTYyLDYgQEAKIENPTkZJR19ST09UX05GUz15CiBDT05GSUdfTkZTRD1tCiBDT05GSUdfTkZTRF9WMz15Ci1DT05GSUdfU01CX0ZTPW0KIENPTkZJR19DSUZTPW0KIENPTkZJR19OTFNfQ09ERVBBR0VfNDM3PW0KIENPTkZJR19OTFNfQ09ERVBBR0VfODUwPW0KQEAgLTE2OCw0ICsxNzIsMyBAQAogQ09ORklHX0RFQlVHX0tFUk5FTD15CiBDT05GSUdfREVURUNUX0hVTkdfVEFTSz15CiBDT05GSUdfRlJBTUVfUE9JTlRFUj15Ci0jIENPTkZJR19SQ1VfQ1BVX1NUQUxMX0RFVEVDVE9SIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYXZyMzIvY29uZmlncy9hdHN0azEwMDJfZGVmY29uZmlnIGIvYXJjaC9hdnIzMi9jb25maWdzL2F0c3RrMTAwMl9kZWZjb25maWcKaW5kZXggYWVjNGM0My4uNGZiMDFmNSAxMDA2NDQKLS0tIGEvYXJjaC9hdnIzMi9jb25maWdzL2F0c3RrMTAwMl9kZWZjb25maWcKKysrIGIvYXJjaC9hdnIzMi9jb25maWdzL2F0c3RrMTAwMl9kZWZjb25maWcKQEAgLTMsNyArMyw2IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfUE9TSVhfTVFVRVVFPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0Ci1DT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15CiBDT05GSUdfUkVMQVk9eQogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKQEAgLTExLDcgKzEwLDcgQEAKICMgQ09ORklHX0NPTVBBVF9CUksgaXMgbm90IHNldAogQ09ORklHX1BST0ZJTElORz15CiBDT05GSUdfT1BST0ZJTEU9bQotQ09ORklHX0tQUk9CRVM9eQorIyBDT05GSUdfS1BST0JFUyBpcyBub3Qgc2V0CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CiAjIENPTkZJR19CTEtfREVWX0JTRyBpcyBub3Qgc2V0CkBAIC0yNiw2ICsyNSw3IEBACiBDT05GSUdfQ1BVX0ZSRVFfREVGQVVMVF9HT1ZfT05ERU1BTkQ9eQogQ09ORklHX0NQVV9GUkVRX0dPVl9VU0VSU1BBQ0U9eQogQ09ORklHX0NQVV9GUkVRX0FUMzJBUD15CitDT05GSUdfQ09SRV9EVU1QX0RFRkFVTFRfRUxGX0hFQURFUlM9eQogQ09ORklHX05FVD15CiBDT05GSUdfUEFDS0VUPXkKIENPTkZJR19VTklYPXkKQEAgLTM1LDYgKzM1LDcgQEAKIENPTkZJR19JUF9QTlA9eQogQ09ORklHX0lQX1BOUF9ESENQPXkKIENPTkZJR19ORVRfSVBJUD1tCitDT05GSUdfTkVUX0lQR1JFX0RFTVVYPW0KIENPTkZJR19ORVRfSVBHUkU9bQogQ09ORklHX0lORVRfQUg9bQogQ09ORklHX0lORVRfRVNQPW0KQEAgLTU4LDE2ICs1OSwxNCBAQAogQ09ORklHX01URF9DRkk9eQogQ09ORklHX01URF9DRklfQU1EU1REPXkKIENPTkZJR19NVERfUEhZU01BUD15Ci1DT05GSUdfTVREX0RBVEFGTEFTSD1tCi1DT05GSUdfTVREX00yNVA4MD1tCiBDT05GSUdfTVREX1VCST15CiBDT05GSUdfQkxLX0RFVl9MT09QPW0KIENPTkZJR19CTEtfREVWX05CRD1tCiBDT05GSUdfQkxLX0RFVl9SQU09bQorQ09ORklHX01JU0NfREVWSUNFUz15CiBDT05GSUdfQVRNRUxfUFdNPW0KIENPTkZJR19BVE1FTF9UQ0xJQj15CiBDT05GSUdfQVRNRUxfU1NDPW0KLUNPTkZJR19FRVBST01fQVQyND1tCiAjIENPTkZJR19TQ1NJX1BST0NfRlMgaXMgbm90IHNldAogQ09ORklHX0JMS19ERVZfU0Q9bQogQ09ORklHX0JMS19ERVZfU1I9bQpAQCAtMTIwLDcgKzExOSw2IEBACiBDT05GSUdfU05EX1BDTV9PU1M9bQogIyBDT05GSUdfU05EX1NVUFBPUlRfT0xEX0FQSSBpcyBub3Qgc2V0CiAjIENPTkZJR19TTkRfVkVSQk9TRV9QUk9DRlMgaXMgbm90IHNldAotIyBDT05GSUdfU05EX0RSSVZFUlMgaXMgbm90IHNldAogQ09ORklHX1NORF9BVDczQzIxMz1tCiAjIENPTkZJR19ISURfU1VQUE9SVCBpcyBub3Qgc2V0CiBDT05GSUdfVVNCX0dBREdFVD15CkBAIC0xMzEsMTYgKzEyOSwxNSBAQAogQ09ORklHX1VTQl9HX1NFUklBTD1tCiBDT05GSUdfVVNCX0NEQ19DT01QT1NJVEU9bQogQ09ORklHX01NQz15CitDT05GSUdfTU1DX1RFU1Q9bQogQ09ORklHX01NQ19BVE1FTE1DST15Ci1DT05GSUdfTU1DX1NQST1tCiBDT05GSUdfTkVXX0xFRFM9eQotQ09ORklHX0xFRFNfQ0xBU1M9bQorQ09ORklHX0xFRFNfQ0xBU1M9eQogQ09ORklHX0xFRFNfQVRNRUxfUFdNPW0KIENPTkZJR19MRURTX0dQSU89bQogQ09ORklHX0xFRFNfVFJJR0dFUlM9eQogQ09ORklHX0xFRFNfVFJJR0dFUl9USU1FUj1tCiBDT05GSUdfTEVEU19UUklHR0VSX0hFQVJUQkVBVD1tCi1DT05GSUdfTEVEU19UUklHR0VSX0RFRkFVTFRfT049bQogQ09ORklHX1JUQ19DTEFTUz15CiBDT05GSUdfUlRDX0RSVl9BVDMyQVA3MDBYPXkKIENPTkZJR19ETUFERVZJQ0VTPXkKQEAgLTE0OSwyMCArMTQ2LDIzIEBACiAjIENPTkZJR19FWFQzX0RFRkFVTFRTX1RPX09SREVSRUQgaXMgbm90IHNldAogIyBDT05GSUdfRVhUM19GU19YQVRUUiBpcyBub3Qgc2V0CiBDT05GSUdfRVhUNF9GUz15CisjIENPTkZJR19FWFQ0X0ZTX1hBVFRSIGlzIG5vdCBzZXQKICMgQ09ORklHX0ROT1RJRlkgaXMgbm90IHNldAogQ09ORklHX0ZVU0VfRlM9bQogQ09ORklHX01TRE9TX0ZTPW0KIENPTkZJR19WRkFUX0ZTPW0KK0NPTkZJR19GQVRfREVGQVVMVF9DT0RFUEFHRT04NTAKIENPTkZJR19QUk9DX0tDT1JFPXkKIENPTkZJR19UTVBGUz15CitDT05GSUdfQ09ORklHRlNfRlM9eQogQ09ORklHX0pGRlMyX0ZTPXkKLSMgQ09ORklHX0pGRlMyX0ZTX1dSSVRFQlVGRkVSIGlzIG5vdCBzZXQKIENPTkZJR19VQklGU19GUz15Ci1DT05GSUdfTUlOSVhfRlM9bQogQ09ORklHX05GU19GUz15CiBDT05GSUdfTkZTX1YzPXkKIENPTkZJR19ST09UX05GUz15CitDT05GSUdfQ0lGUz1tCiBDT05GSUdfTkxTX0NPREVQQUdFXzQzNz1tCitDT05GSUdfTkxTX0NPREVQQUdFXzg1MD1tCiBDT05GSUdfTkxTX0lTTzg4NTlfMT1tCiBDT05GSUdfTkxTX1VURjg9bQogQ09ORklHX01BR0lDX1NZU1JRPXkKQEAgLTE3MCw2ICsxNzAsMyBAQAogQ09ORklHX0RFQlVHX0tFUk5FTD15CiBDT05GSUdfREVURUNUX0hVTkdfVEFTSz15CiBDT05GSUdfRlJBTUVfUE9JTlRFUj15Ci0jIENPTkZJR19SQ1VfQ1BVX1NUQUxMX0RFVEVDVE9SIGlzIG5vdCBzZXQKLSMgQ09ORklHX0NSWVBUT19IVyBpcyBub3Qgc2V0Ci1DT05GSUdfQ1JDX1QxMERJRj1tCmRpZmYgLS1naXQgYS9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRzdGsxMDAzX2RlZmNvbmZpZyBiL2FyY2gvYXZyMzIvY29uZmlncy9hdHN0azEwMDNfZGVmY29uZmlnCmluZGV4IDUwYmEzZGIuLjlmYWFmOWIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXZyMzIvY29uZmlncy9hdHN0azEwMDNfZGVmY29uZmlnCisrKyBiL2FyY2gvYXZyMzIvY29uZmlncy9hdHN0azEwMDNfZGVmY29uZmlnCkBAIC0yLDIyICsyLDE1IEBACiAjIENPTkZJR19MT0NBTFZFUlNJT05fQVVUTyBpcyBub3Qgc2V0CiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfUE9TSVhfTVFVRVVFPXkKLUNPTkZJR19CU0RfUFJPQ0VTU19BQ0NUPXkKLUNPTkZJR19CU0RfUFJPQ0VTU19BQ0NUX1YzPXkKLUNPTkZJR19UQVNLU1RBVFM9eQotQ09ORklHX1RBU0tfREVMQVlfQUNDVD15Ci1DT05GSUdfQVVESVQ9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKLUNPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKIENPTkZJR19SRUxBWT15CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfQkFTRV9GVUxMIGlzIG5vdCBzZXQKLSMgQ09ORklHX1NMVUJfREVCVUcgaXMgbm90IHNldAogIyBDT05GSUdfQ09NUEFUX0JSSyBpcyBub3Qgc2V0CiBDT05GSUdfUFJPRklMSU5HPXkKIENPTkZJR19PUFJPRklMRT1tCi1DT05GSUdfS1BST0JFUz15CisjIENPTkZJR19LUFJPQkVTIGlzIG5vdCBzZXQKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKQEAgLTMzLDYgKzI2LDcgQEAKIENPTkZJR19DUFVfRlJFUV9ERUZBVUxUX0dPVl9PTkRFTUFORD15CiBDT05GSUdfQ1BVX0ZSRVFfR09WX1VTRVJTUEFDRT15CiBDT05GSUdfQ1BVX0ZSRVFfQVQzMkFQPXkKK0NPTkZJR19DT1JFX0RVTVBfREVGQVVMVF9FTEZfSEVBREVSUz15CiBDT05GSUdfTkVUPXkKIENPTkZJR19QQUNLRVQ9eQogQ09ORklHX1VOSVg9eQpAQCAtNTQsMTggKzQ4LDE4IEBACiBDT05GSUdfTVREX0NGST15CiBDT05GSUdfTVREX0NGSV9BTURTVEQ9eQogQ09ORklHX01URF9QSFlTTUFQPXkKLUNPTkZJR19NVERfREFUQUZMQVNIPW0KLUNPTkZJR19NVERfTTI1UDgwPW0KK0NPTkZJR19NVERfVUJJPXkKIENPTkZJR19CTEtfREVWX0xPT1A9bQogQ09ORklHX0JMS19ERVZfTkJEPW0KIENPTkZJR19CTEtfREVWX1JBTT1tCitDT05GSUdfTUlTQ19ERVZJQ0VTPXkKIENPTkZJR19BVE1FTF9QV009bQogQ09ORklHX0FUTUVMX1RDTElCPXkKIENPTkZJR19BVE1FTF9TU0M9bQotQ09ORklHX0VFUFJPTV9BVDI0PW0KICMgQ09ORklHX1NDU0lfUFJPQ19GUyBpcyBub3Qgc2V0CiBDT05GSUdfQkxLX0RFVl9TRD1tCiBDT05GSUdfQkxLX0RFVl9TUj1tCisjIENPTkZJR19TQ1NJX0xPV0xFVkVMIGlzIG5vdCBzZXQKIENPTkZJR19BVEE9bQogIyBDT05GSUdfU0FUQV9QTVAgaXMgbm90IHNldAogQ09ORklHX1BBVEFfQVQzMj1tCkBAIC03Nyw2ICs3MSw3IEBACiBDT05GSUdfUFBQX0RFRkxBVEU9bQogQ09ORklHX1BQUF9CU0RDT01QPW0KIENPTkZJR19JTlBVVD1tCitDT05GSUdfSU5QVVRfRVZERVY9bQogIyBDT05GSUdfS0VZQk9BUkRfQVRLQkQgaXMgbm90IHNldAogQ09ORklHX0tFWUJPQVJEX0dQSU89bQogIyBDT05GSUdfTU9VU0VfUFMyIGlzIG5vdCBzZXQKQEAgLTEwNiw3ICsxMDEsNiBAQAogQ09ORklHX1NORF9BVDczQzIxMz1tCiAjIENPTkZJR19ISURfU1VQUE9SVCBpcyBub3Qgc2V0CiBDT05GSUdfVVNCX0dBREdFVD15Ci1DT05GSUdfVVNCX0dBREdFVF9ERUJVR19GUz15CiBDT05GSUdfVVNCX1pFUk89bQogQ09ORklHX1VTQl9FVEg9bQogQ09ORklHX1VTQl9HQURHRVRGUz1tCkBAIC0xMTYsMzYgKzExMCwzOSBAQAogQ09ORklHX01NQz15CiBDT05GSUdfTU1DX1RFU1Q9bQogQ09ORklHX01NQ19BVE1FTE1DST15Ci1DT05GSUdfTU1DX1NQST1tCiBDT05GSUdfTkVXX0xFRFM9eQogQ09ORklHX0xFRFNfQ0xBU1M9eQogQ09ORklHX0xFRFNfQVRNRUxfUFdNPW0KLUNPTkZJR19MRURTX0dQSU89eQorQ09ORklHX0xFRFNfR1BJTz1tCiBDT05GSUdfTEVEU19UUklHR0VSUz15Ci1DT05GSUdfTEVEU19UUklHR0VSX1RJTUVSPXkKLUNPTkZJR19MRURTX1RSSUdHRVJfSEVBUlRCRUFUPXkKLUNPTkZJR19MRURTX1RSSUdHRVJfREVGQVVMVF9PTj15CitDT05GSUdfTEVEU19UUklHR0VSX1RJTUVSPW0KK0NPTkZJR19MRURTX1RSSUdHRVJfSEVBUlRCRUFUPW0KIENPTkZJR19SVENfQ0xBU1M9eQogQ09ORklHX1JUQ19EUlZfQVQzMkFQNzAwWD15CiBDT05GSUdfRE1BREVWSUNFUz15Ci1DT05GSUdfRFdfRE1BQz15Ci1DT05GSUdfRVhUMl9GUz1tCi1DT05GSUdfRVhUM19GUz1tCitDT05GSUdfRVhUMl9GUz15CitDT05GSUdfRVhUM19GUz15CisjIENPTkZJR19FWFQzX0RFRkFVTFRTX1RPX09SREVSRUQgaXMgbm90IHNldAogIyBDT05GSUdfRVhUM19GU19YQVRUUiBpcyBub3Qgc2V0CitDT05GSUdfRVhUNF9GUz15CisjIENPTkZJR19FWFQ0X0ZTX1hBVFRSIGlzIG5vdCBzZXQKICMgQ09ORklHX0ROT1RJRlkgaXMgbm90IHNldAogQ09ORklHX0ZVU0VfRlM9bQogQ09ORklHX01TRE9TX0ZTPW0KIENPTkZJR19WRkFUX0ZTPW0KK0NPTkZJR19GQVRfREVGQVVMVF9DT0RFUEFHRT04NTAKIENPTkZJR19QUk9DX0tDT1JFPXkKIENPTkZJR19UTVBGUz15Ci1DT05GSUdfQ09ORklHRlNfRlM9bQorQ09ORklHX0NPTkZJR0ZTX0ZTPXkKIENPTkZJR19KRkZTMl9GUz15CitDT05GSUdfVUJJRlNfRlM9eQogIyBDT05GSUdfTkVUV09SS19GSUxFU1lTVEVNUyBpcyBub3Qgc2V0CiBDT05GSUdfTkxTX0NPREVQQUdFXzQzNz1tCitDT05GSUdfTkxTX0NPREVQQUdFXzg1MD1tCiBDT05GSUdfTkxTX0lTTzg4NTlfMT1tCiBDT05GSUdfTkxTX1VURjg9bQogQ09ORklHX01BR0lDX1NZU1JRPXkKIENPTkZJR19ERUJVR19GUz15CiBDT05GSUdfREVCVUdfS0VSTkVMPXkKK0NPTkZJR19ERVRFQ1RfSFVOR19UQVNLPXkKIENPTkZJR19GUkFNRV9QT0lOVEVSPXkKLUNPTkZJR19DUkNfVDEwRElGPW0KZGlmZiAtLWdpdCBhL2FyY2gvYXZyMzIvY29uZmlncy9hdHN0azEwMDRfZGVmY29uZmlnIGIvYXJjaC9hdnIzMi9jb25maWdzL2F0c3RrMTAwNF9kZWZjb25maWcKaW5kZXggMzI5ZTEwYi4uM2QyYTVkOCAxMDA2NDQKLS0tIGEvYXJjaC9hdnIzMi9jb25maWdzL2F0c3RrMTAwNF9kZWZjb25maWcKKysrIGIvYXJjaC9hdnIzMi9jb25maWdzL2F0c3RrMTAwNF9kZWZjb25maWcKQEAgLTEsMTkgKzEsMzIgQEAKIENPTkZJR19FWFBFUklNRU5UQUw9eQogIyBDT05GSUdfTE9DQUxWRVJTSU9OX0FVVE8gaXMgbm90IHNldAorQ09ORklHX1NZU1ZJUEM9eQorQ09ORklHX1BPU0lYX01RVUVVRT15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQorQ09ORklHX1JFTEFZPXkKK0NPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19CQVNFX0ZVTEwgaXMgbm90IHNldAotIyBDT05GSUdfRlVURVggaXMgbm90IHNldAotIyBDT05GSUdfRVBPTEwgaXMgbm90IHNldAotIyBDT05GSUdfU0lHTkFMRkQgaXMgbm90IHNldAotIyBDT05GSUdfVElNRVJGRCBpcyBub3Qgc2V0Ci0jIENPTkZJR19FVkVOVEZEIGlzIG5vdCBzZXQKICMgQ09ORklHX0NPTVBBVF9CUksgaXMgbm90IHNldAotQ09ORklHX1NMT0I9eQotIyBDT05GSUdfQkxPQ0sgaXMgbm90IHNldAorQ09ORklHX1BST0ZJTElORz15CitDT05GSUdfT1BST0ZJTEU9bQorIyBDT05GSUdfS1BST0JFUyBpcyBub3Qgc2V0CitDT05GSUdfTU9EVUxFUz15CitDT05GSUdfTU9EVUxFX1VOTE9BRD15CisjIENPTkZJR19CTEtfREVWX0JTRyBpcyBub3Qgc2V0CisjIENPTkZJR19JT1NDSEVEX0RFQURMSU5FIGlzIG5vdCBzZXQKK0NPTkZJR19OT19IWj15CitDT05GSUdfSElHSF9SRVNfVElNRVJTPXkKIENPTkZJR19CT0FSRF9BVFNUSzEwMDQ9eQogIyBDT05GSUdfT1dORVJTSElQX1RSQUNFIGlzIG5vdCBzZXQKK0NPTkZJR19OTUlfREVCVUdHSU5HPXkKK0NPTkZJR19QTT15CitDT05GSUdfQ1BVX0ZSRVE9eQorIyBDT05GSUdfQ1BVX0ZSRVFfU1RBVCBpcyBub3Qgc2V0CitDT05GSUdfQ1BVX0ZSRVFfREVGQVVMVF9HT1ZfT05ERU1BTkQ9eQorQ09ORklHX0NQVV9GUkVRX0dPVl9VU0VSU1BBQ0U9eQorQ09ORklHX0NQVV9GUkVRX0FUMzJBUD15CitDT05GSUdfQ09SRV9EVU1QX0RFRkFVTFRfRUxGX0hFQURFUlM9eQogQ09ORklHX05FVD15CiBDT05GSUdfUEFDS0VUPXkKIENPTkZJR19VTklYPXkKQEAgLTMxLDQwICs0NCwxMDQgQEAKIENPTkZJR19NVERfUEFSVElUSU9OUz15CiBDT05GSUdfTVREX0NNRExJTkVfUEFSVFM9eQogQ09ORklHX01URF9DSEFSPXkKK0NPTkZJR19NVERfQkxPQ0s9eQogQ09ORklHX01URF9DRkk9eQogQ09ORklHX01URF9DRklfQU1EU1REPXkKIENPTkZJR19NVERfUEhZU01BUD15Ci0jIENPTkZJR19NSVNDX0RFVklDRVMgaXMgbm90IHNldAotIyBDT05GSUdfSU5QVVQgaXMgbm90IHNldAorQ09ORklHX01URF9VQkk9eQorQ09ORklHX0JMS19ERVZfTE9PUD1tCitDT05GSUdfQkxLX0RFVl9OQkQ9bQorQ09ORklHX0JMS19ERVZfUkFNPW0KK0NPTkZJR19NSVNDX0RFVklDRVM9eQorQ09ORklHX0FUTUVMX1BXTT1tCitDT05GSUdfQVRNRUxfVENMSUI9eQorQ09ORklHX0FUTUVMX1NTQz1tCisjIENPTkZJR19TQ1NJX1BST0NfRlMgaXMgbm90IHNldAorQ09ORklHX0JMS19ERVZfU0Q9bQorQ09ORklHX0JMS19ERVZfU1I9bQorIyBDT05GSUdfU0NTSV9MT1dMRVZFTCBpcyBub3Qgc2V0CitDT05GSUdfQVRBPW0KKyMgQ09ORklHX1NBVEFfUE1QIGlzIG5vdCBzZXQKK0NPTkZJR19QQVRBX0FUMzI9bQorQ09ORklHX05FVERFVklDRVM9eQorIyBDT05GSUdfTkVUREVWXzEwMDAgaXMgbm90IHNldAorIyBDT05GSUdfTkVUREVWXzEwMDAwIGlzIG5vdCBzZXQKK0NPTkZJR19QUFA9bQorQ09ORklHX1BQUF9BU1lOQz1tCitDT05GSUdfUFBQX0RFRkxBVEU9bQorQ09ORklHX1BQUF9CU0RDT01QPW0KK0NPTkZJR19JTlBVVD1tCitDT05GSUdfSU5QVVRfRVZERVY9bQorIyBDT05GSUdfS0VZQk9BUkRfQVRLQkQgaXMgbm90IHNldAorQ09ORklHX0tFWUJPQVJEX0dQSU89bQorIyBDT05GSUdfTU9VU0VfUFMyIGlzIG5vdCBzZXQKK0NPTkZJR19NT1VTRV9HUElPPW0KICMgQ09ORklHX1NFUklPIGlzIG5vdCBzZXQKICMgQ09ORklHX1ZUIGlzIG5vdCBzZXQKICMgQ09ORklHX0RFVktNRU0gaXMgbm90IHNldAogQ09ORklHX1NFUklBTF9BVE1FTD15CiBDT05GSUdfU0VSSUFMX0FUTUVMX0NPTlNPTEU9eQotIyBDT05GSUdfU0VSSUFMX0FUTUVMX1BEQyBpcyBub3Qgc2V0CiAjIENPTkZJR19MRUdBQ1lfUFRZUyBpcyBub3Qgc2V0CiAjIENPTkZJR19IV19SQU5ET00gaXMgbm90IHNldAorQ09ORklHX0kyQz1tCitDT05GSUdfSTJDX0NIQVJERVY9bQorQ09ORklHX0kyQ19HUElPPW0KIENPTkZJR19TUEk9eQogQ09ORklHX1NQSV9BVE1FTD15CitDT05GSUdfU1BJX1NQSURFVj1tCitDT05GSUdfR1BJT19TWVNGUz15CiAjIENPTkZJR19IV01PTiBpcyBub3Qgc2V0CiBDT05GSUdfV0FUQ0hET0c9eQogQ09ORklHX0FUMzJBUDcwMFhfV0RUPXkKIENPTkZJR19GQj15CiBDT05GSUdfRkJfQVRNRUw9eQogQ09ORklHX0JBQ0tMSUdIVF9MQ0RfU1VQUE9SVD15CitDT05GSUdfTENEX0NMQVNTX0RFVklDRT15CiBDT05GSUdfTENEX0xUVjM1MFFWPXkKICMgQ09ORklHX0JBQ0tMSUdIVF9DTEFTU19ERVZJQ0UgaXMgbm90IHNldAogQ09ORklHX1VTQl9HQURHRVQ9eQotQ09ORklHX1VTQl9FVEg9eQotIyBDT05GSUdfVVNCX0VUSF9STkRJUyBpcyBub3Qgc2V0CitDT05GSUdfVVNCX1pFUk89bQorQ09ORklHX1VTQl9FVEg9bQorQ09ORklHX1VTQl9HQURHRVRGUz1tCitDT05GSUdfVVNCX0ZJTEVfU1RPUkFHRT1tCitDT05GSUdfVVNCX0dfU0VSSUFMPW0KK0NPTkZJR19VU0JfQ0RDX0NPTVBPU0lURT1tCitDT05GSUdfTU1DPXkKK0NPTkZJR19NTUNfVEVTVD1tCitDT05GSUdfTU1DX0FUTUVMTUNJPXkKK0NPTkZJR19ORVdfTEVEUz15CitDT05GSUdfTEVEU19DTEFTUz15CitDT05GSUdfTEVEU19BVE1FTF9QV009bQorQ09ORklHX0xFRFNfR1BJTz1tCitDT05GSUdfTEVEU19UUklHR0VSUz15CitDT05GSUdfTEVEU19UUklHR0VSX1RJTUVSPW0KK0NPTkZJR19MRURTX1RSSUdHRVJfSEVBUlRCRUFUPW0KIENPTkZJR19SVENfQ0xBU1M9eQotIyBDT05GSUdfUlRDX0lOVEZfUFJPQyBpcyBub3Qgc2V0CiBDT05GSUdfUlRDX0RSVl9BVDMyQVA3MDBYPXkKK0NPTkZJR19ETUFERVZJQ0VTPXkKK0NPTkZJR19FWFQyX0ZTPXkKK0NPTkZJR19FWFQzX0ZTPXkKKyMgQ09ORklHX0VYVDNfREVGQVVMVFNfVE9fT1JERVJFRCBpcyBub3Qgc2V0CisjIENPTkZJR19FWFQzX0ZTX1hBVFRSIGlzIG5vdCBzZXQKK0NPTkZJR19FWFQ0X0ZTPXkKKyMgQ09ORklHX0VYVDRfRlNfWEFUVFIgaXMgbm90IHNldAogIyBDT05GSUdfRE5PVElGWSBpcyBub3Qgc2V0CitDT05GSUdfRlVTRV9GUz1tCitDT05GSUdfTVNET1NfRlM9bQorQ09ORklHX1ZGQVRfRlM9bQorQ09ORklHX0ZBVF9ERUZBVUxUX0NPREVQQUdFPTg1MAogQ09ORklHX1BST0NfS0NPUkU9eQotIyBDT05GSUdfUFJPQ19QQUdFX01PTklUT1IgaXMgbm90IHNldAogQ09ORklHX1RNUEZTPXkKK0NPTkZJR19DT05GSUdGU19GUz15CiBDT05GSUdfSkZGUzJfRlM9eQotIyBDT05GSUdfSkZGUzJfRlNfV1JJVEVCVUZGRVIgaXMgbm90IHNldAorQ09ORklHX1VCSUZTX0ZTPXkKICMgQ09ORklHX05FVFdPUktfRklMRVNZU1RFTVMgaXMgbm90IHNldAorQ09ORklHX05MU19DT0RFUEFHRV80Mzc9bQorQ09ORklHX05MU19DT0RFUEFHRV84NTA9bQorQ09ORklHX05MU19JU084ODU5XzE9bQorQ09ORklHX05MU19VVEY4PW0KIENPTkZJR19NQUdJQ19TWVNSUT15CitDT05GSUdfREVCVUdfRlM9eQorQ09ORklHX0RFQlVHX0tFUk5FTD15CitDT05GSUdfREVURUNUX0hVTkdfVEFTSz15CitDT05GSUdfRlJBTUVfUE9JTlRFUj15CmRpZmYgLS1naXQgYS9hcmNoL2F2cjMyL2NvbmZpZ3MvYXRzdGsxMDA2X2RlZmNvbmZpZyBiL2FyY2gvYXZyMzIvY29uZmlncy9hdHN0azEwMDZfZGVmY29uZmlnCmluZGV4IGRiY2MxYjUuLjFlZDhmMjIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXZyMzIvY29uZmlncy9hdHN0azEwMDZfZGVmY29uZmlnCisrKyBiL2FyY2gvYXZyMzIvY29uZmlncy9hdHN0azEwMDZfZGVmY29uZmlnCkBAIC0zLDcgKzMsNiBAQAogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX1BPU0lYX01RVUVVRT15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQogQ09ORklHX1JFTEFZPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CkBAIC0xMSw3ICsxMCw3IEBACiAjIENPTkZJR19DT01QQVRfQlJLIGlzIG5vdCBzZXQKIENPTkZJR19QUk9GSUxJTkc9eQogQ09ORklHX09QUk9GSUxFPW0KLUNPTkZJR19LUFJPQkVTPXkKKyMgQ09ORklHX0tQUk9CRVMgaXMgbm90IHNldAogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQogIyBDT05GSUdfQkxLX0RFVl9CU0cgaXMgbm90IHNldApAQCAtMzcsNiArMzYsNyBAQAogQ09ORklHX0lQX1BOUD15CiBDT05GSUdfSVBfUE5QX0RIQ1A9eQogQ09ORklHX05FVF9JUElQPW0KK0NPTkZJR19ORVRfSVBHUkVfREVNVVg9bQogQ09ORklHX05FVF9JUEdSRT1tCiBDT05GSUdfSU5FVF9BSD1tCiBDT05GSUdfSU5FVF9FU1A9bQpAQCAtNjAsMTUgKzYwLDEzIEBACiBDT05GSUdfTVREX0NGST15CiBDT05GSUdfTVREX0NGSV9BTURTVEQ9eQogQ09ORklHX01URF9QSFlTTUFQPXkKLUNPTkZJR19NVERfREFUQUZMQVNIPW0KLUNPTkZJR19NVERfREFUQUZMQVNIX09UUD15Ci1DT05GSUdfTVREX00yNVA4MD1tCiBDT05GSUdfTVREX05BTkQ9eQogQ09ORklHX01URF9OQU5EX0FUTUVMPXkKIENPTkZJR19NVERfVUJJPXkKIENPTkZJR19CTEtfREVWX0xPT1A9bQogQ09ORklHX0JMS19ERVZfTkJEPW0KIENPTkZJR19CTEtfREVWX1JBTT1tCitDT05GSUdfTUlTQ19ERVZJQ0VTPXkKIENPTkZJR19BVE1FTF9QV009bQogQ09ORklHX0FUTUVMX1RDTElCPXkKIENPTkZJR19BVE1FTF9TU0M9bQpAQCAtMTMyLDE3ICsxMzAsMTcgQEAKIENPTkZJR19VU0JfR0FER0VURlM9bQogQ09ORklHX1VTQl9GSUxFX1NUT1JBR0U9bQogQ09ORklHX1VTQl9HX1NFUklBTD1tCitDT05GSUdfVVNCX0NEQ19DT01QT1NJVEU9bQogQ09ORklHX01NQz15CitDT05GSUdfTU1DX1RFU1Q9bQogQ09ORklHX01NQ19BVE1FTE1DST15Ci1DT05GSUdfTU1DX1NQST1tCiBDT05GSUdfTkVXX0xFRFM9eQotQ09ORklHX0xFRFNfQ0xBU1M9bQorQ09ORklHX0xFRFNfQ0xBU1M9eQogQ09ORklHX0xFRFNfQVRNRUxfUFdNPW0KIENPTkZJR19MRURTX0dQSU89bQogQ09ORklHX0xFRFNfVFJJR0dFUlM9eQogQ09ORklHX0xFRFNfVFJJR0dFUl9USU1FUj1tCiBDT05GSUdfTEVEU19UUklHR0VSX0hFQVJUQkVBVD1tCi1DT05GSUdfTEVEU19UUklHR0VSX0RFRkFVTFRfT049bQogQ09ORklHX1JUQ19DTEFTUz15CiBDT05GSUdfUlRDX0RSVl9BVDMyQVA3MDBYPXkKIENPTkZJR19ETUFERVZJQ0VTPXkKQEAgLTE1NiwxNSArMTU0LDE4IEBACiBDT05GSUdfRlVTRV9GUz1tCiBDT05GSUdfTVNET1NfRlM9bQogQ09ORklHX1ZGQVRfRlM9bQorQ09ORklHX0ZBVF9ERUZBVUxUX0NPREVQQUdFPTg1MAogQ09ORklHX1BST0NfS0NPUkU9eQogQ09ORklHX1RNUEZTPXkKK0NPTkZJR19DT05GSUdGU19GUz15CiBDT05GSUdfSkZGUzJfRlM9eQogQ09ORklHX1VCSUZTX0ZTPXkKLUNPTkZJR19NSU5JWF9GUz1tCiBDT05GSUdfTkZTX0ZTPXkKIENPTkZJR19ORlNfVjM9eQogQ09ORklHX1JPT1RfTkZTPXkKK0NPTkZJR19DSUZTPW0KIENPTkZJR19OTFNfQ09ERVBBR0VfNDM3PW0KK0NPTkZJR19OTFNfQ09ERVBBR0VfODUwPW0KIENPTkZJR19OTFNfSVNPODg1OV8xPW0KIENPTkZJR19OTFNfVVRGOD1tCiBDT05GSUdfTUFHSUNfU1lTUlE9eQpAQCAtMTcyLDcgKzE3MywzIEBACiBDT05GSUdfREVCVUdfS0VSTkVMPXkKIENPTkZJR19ERVRFQ1RfSFVOR19UQVNLPXkKIENPTkZJR19GUkFNRV9QT0lOVEVSPXkKLSMgQ09ORklHX1JDVV9DUFVfU1RBTExfREVURUNUT1IgaXMgbm90IHNldAotQ09ORklHX0NSWVBUT19GSVBTPXkKLSMgQ09ORklHX0NSWVBUT19IVyBpcyBub3Qgc2V0Ci1DT05GSUdfQ1JDX1QxMERJRj1tCmRpZmYgLS1naXQgYS9hcmNoL2F2cjMyL2NvbmZpZ3MvZmF2ci0zMl9kZWZjb25maWcgYi9hcmNoL2F2cjMyL2NvbmZpZ3MvZmF2ci0zMl9kZWZjb25maWcKaW5kZXggMGM4MTNiNi4uYWVhZGM5NSAxMDA2NDQKLS0tIGEvYXJjaC9hdnIzMi9jb25maWdzL2ZhdnItMzJfZGVmY29uZmlnCisrKyBiL2FyY2gvYXZyMzIvY29uZmlncy9mYXZyLTMyX2RlZmNvbmZpZwpAQCAtMTEsNyArMTEsNyBAQAogIyBDT05GSUdfQ09NUEFUX0JSSyBpcyBub3Qgc2V0CiBDT05GSUdfUFJPRklMSU5HPXkKIENPTkZJR19PUFJPRklMRT1tCi1DT05GSUdfS1BST0JFUz15CisjIENPTkZJR19LUFJPQkVTIGlzIG5vdCBzZXQKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYXZyMzIvY29uZmlncy9oYW1tZXJoZWFkX2RlZmNvbmZpZyBiL2FyY2gvYXZyMzIvY29uZmlncy9oYW1tZXJoZWFkX2RlZmNvbmZpZwppbmRleCBkY2MwMWYwLi4xNjkyYmVlIDEwMDY0NAotLS0gYS9hcmNoL2F2cjMyL2NvbmZpZ3MvaGFtbWVyaGVhZF9kZWZjb25maWcKKysrIGIvYXJjaC9hdnIzMi9jb25maWdzL2hhbW1lcmhlYWRfZGVmY29uZmlnCkBAIC0xMiw3ICsxMiw3IEBACiAjIENPTkZJR19DT01QQVRfQlJLIGlzIG5vdCBzZXQKIENPTkZJR19QUk9GSUxJTkc9eQogQ09ORklHX09QUk9GSUxFPW0KLUNPTkZJR19LUFJPQkVTPXkKKyMgQ09ORklHX0tQUk9CRVMgaXMgbm90IHNldAogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQogQ09ORklHX01PRFVMRV9GT1JDRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9hdnIzMi9pbmNsdWRlL2FzbS9wZ2FsbG9jLmggYi9hcmNoL2F2cjMyL2luY2x1ZGUvYXNtL3BnYWxsb2MuaAppbmRleCA5MmVjZDg0Li5iYzdlOGFlIDEwMDY0NAotLS0gYS9hcmNoL2F2cjMyL2luY2x1ZGUvYXNtL3BnYWxsb2MuaAorKysgYi9hcmNoL2F2cjMyL2luY2x1ZGUvYXNtL3BnYWxsb2MuaApAQCAtOCw2ICs4LDcgQEAKICNpZm5kZWYgX19BU01fQVZSMzJfUEdBTExPQ19ICiAjZGVmaW5lIF9fQVNNX0FWUjMyX1BHQUxMT0NfSAogCisjaW5jbHVkZSA8bGludXgvbW0uaD4KICNpbmNsdWRlIDxsaW51eC9xdWlja2xpc3QuaD4KICNpbmNsdWRlIDxhc20vcGFnZS5oPgogI2luY2x1ZGUgPGFzbS9wZ3RhYmxlLmg+CmRpZmYgLS1naXQgYS9hcmNoL2F2cjMyL2luY2x1ZGUvYXNtL3N5c2NhbGxzLmggYi9hcmNoL2F2cjMyL2luY2x1ZGUvYXNtL3N5c2NhbGxzLmgKaW5kZXggYWI2MDhiNy4uMjQ0ZjJhYyAxMDA2NDQKLS0tIGEvYXJjaC9hdnIzMi9pbmNsdWRlL2FzbS9zeXNjYWxscy5oCisrKyBiL2FyY2gvYXZyMzIvaW5jbHVkZS9hc20vc3lzY2FsbHMuaApAQCAtMTUsMjAgKzE1LDYgQEAKICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgogI2luY2x1ZGUgPGxpbnV4L3NpZ25hbC5oPgogCi0vKiBrZXJuZWwvcHJvY2Vzcy5jICovCi1hc21saW5rYWdlIGludCBzeXNfZm9yayhzdHJ1Y3QgcHRfcmVncyAqKTsKLWFzbWxpbmthZ2UgaW50IHN5c19jbG9uZSh1bnNpZ25lZCBsb25nLCB1bnNpZ25lZCBsb25nLAotCQkJIHVuc2lnbmVkIGxvbmcsIHVuc2lnbmVkIGxvbmcsCi0JCQkgc3RydWN0IHB0X3JlZ3MgKik7Ci1hc21saW5rYWdlIGludCBzeXNfdmZvcmsoc3RydWN0IHB0X3JlZ3MgKik7Ci1hc21saW5rYWdlIGludCBzeXNfZXhlY3ZlKGNvbnN0IGNoYXIgX191c2VyICosIGNoYXIgX191c2VyICpfX3VzZXIgKiwKLQkJCSAgY2hhciBfX3VzZXIgKl9fdXNlciAqLCBzdHJ1Y3QgcHRfcmVncyAqKTsKLQotLyoga2VybmVsL3NpZ25hbC5jICovCi1hc21saW5rYWdlIGludCBzeXNfc2lnYWx0c3RhY2soY29uc3Qgc3RhY2tfdCBfX3VzZXIgKiwgc3RhY2tfdCBfX3VzZXIgKiwKLQkJCSAgICAgICBzdHJ1Y3QgcHRfcmVncyAqKTsKLWFzbWxpbmthZ2UgaW50IHN5c19ydF9zaWdyZXR1cm4oc3RydWN0IHB0X3JlZ3MgKik7Ci0KIC8qIG1tL2NhY2hlLmMgKi8KIGFzbWxpbmthZ2UgaW50IHN5c19jYWNoZWZsdXNoKGludCwgdm9pZCBfX3VzZXIgKiwgc2l6ZV90KTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9hdnIzMi9rZXJuZWwvcHJvY2Vzcy5jIGIvYXJjaC9hdnIzMi9rZXJuZWwvcHJvY2Vzcy5jCmluZGV4IDljNDZhYWEuLmVmNWEyYTAgMTAwNjQ0Ci0tLSBhL2FyY2gvYXZyMzIva2VybmVsL3Byb2Nlc3MuYworKysgYi9hcmNoL2F2cjMyL2tlcm5lbC9wcm9jZXNzLmMKQEAgLTM2NywxNCArMzY3LDEzIEBACiB9CiAKIGFzbWxpbmthZ2UgaW50IHN5c19jbG9uZSh1bnNpZ25lZCBsb25nIGNsb25lX2ZsYWdzLCB1bnNpZ25lZCBsb25nIG5ld3NwLAotCQkJIHVuc2lnbmVkIGxvbmcgcGFyZW50X3RpZHB0ciwKLQkJCSB1bnNpZ25lZCBsb25nIGNoaWxkX3RpZHB0ciwgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCisJCXZvaWQgX191c2VyICpwYXJlbnRfdGlkcHRyLCB2b2lkIF9fdXNlciAqY2hpbGRfdGlkcHRyLAorCQlzdHJ1Y3QgcHRfcmVncyAqcmVncykKIHsKIAlpZiAoIW5ld3NwKQogCQluZXdzcCA9IHJlZ3MtPnNwOwotCXJldHVybiBkb19mb3JrKGNsb25lX2ZsYWdzLCBuZXdzcCwgcmVncywgMCwKLQkJICAgICAgIChpbnQgX191c2VyICopcGFyZW50X3RpZHB0ciwKLQkJICAgICAgIChpbnQgX191c2VyICopY2hpbGRfdGlkcHRyKTsKKwlyZXR1cm4gZG9fZm9yayhjbG9uZV9mbGFncywgbmV3c3AsIHJlZ3MsIDAsIHBhcmVudF90aWRwdHIsCisJCQljaGlsZF90aWRwdHIpOwogfQogCiBhc21saW5rYWdlIGludCBzeXNfdmZvcmsoc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCmRpZmYgLS1naXQgYS9hcmNoL2F2cjMyL2tlcm5lbC90aW1lLmMgYi9hcmNoL2F2cjMyL2tlcm5lbC90aW1lLmMKaW5kZXggNjY4ZWQyOC4uMDVhZDI5MSAxMDA2NDQKLS0tIGEvYXJjaC9hdnIzMi9rZXJuZWwvdGltZS5jCisrKyBiL2FyY2gvYXZyMzIva2VybmVsL3RpbWUuYwpAQCAtMzUsNyArMzUsNiBAQAogCS5yYXRpbmcJCT0gNTAsCiAJLnJlYWQJCT0gcmVhZF9jeWNsZV9jb3VudCwKIAkubWFzawkJPSBDTE9DS1NPVVJDRV9NQVNLKDMyKSwKLQkuc2hpZnQJCT0gMTYsCiAJLmZsYWdzCQk9IENMT0NLX1NPVVJDRV9JU19DT05USU5VT1VTLAogfTsKIApAQCAtMTIzLDkgKzEyMiw3IEBACiAKIAkvKiBmaWd1cmUgcmF0ZSBmb3IgY291bnRlciAqLwogCWNvdW50ZXJfaHogPSBjbGtfZ2V0X3JhdGUoYm9vdF9jcHVfZGF0YS5jbGspOwotCWNvdW50ZXIubXVsdCA9IGNsb2Nrc291cmNlX2h6Mm11bHQoY291bnRlcl9oeiwgY291bnRlci5zaGlmdCk7Ci0KLQlyZXQgPSBjbG9ja3NvdXJjZV9yZWdpc3RlcigmY291bnRlcik7CisJcmV0ID0gY2xvY2tzb3VyY2VfcmVnaXN0ZXJfaHooJmNvdW50ZXIsIGNvdW50ZXJfaHopOwogCWlmIChyZXQpCiAJCXByX2RlYnVnKCJ0aW1lcjogY291bGQgbm90IHJlZ2lzdGVyIGNsb2Nrc291cmNlOiAlZFxuIiwgcmV0KTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9LY29uZmlnIGIvYXJjaC9ibGFja2Zpbi9LY29uZmlnCmluZGV4IDBhMjIxZDQuLmMwOTU3N2QgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vS2NvbmZpZworKysgYi9hcmNoL2JsYWNrZmluL0tjb25maWcKQEAgLTMwLDYgKzMwLDkgQEAKIAlzZWxlY3QgSEFWRV9LRVJORUxfTFpPIGlmIFJBTUtFUk5FTAogCXNlbGVjdCBIQVZFX09QUk9GSUxFCiAJc2VsZWN0IEFSQ0hfV0FOVF9PUFRJT05BTF9HUElPTElCCisJc2VsZWN0IEhBVkVfR0VORVJJQ19IQVJESVJRUworCXNlbGVjdCBHRU5FUklDX0lSUV9QUk9CRQorCXNlbGVjdCBJUlFfUEVSX0NQVSBpZiBTTVAKIAogY29uZmlnIEdFTkVSSUNfQ1NVTQogCWRlZl9ib29sIHkKQEAgLTQ0LDE1ICs0Nyw2IEBACiBjb25maWcgR0VORVJJQ19GSU5EX05FWFRfQklUCiAJZGVmX2Jvb2wgeQogCi1jb25maWcgR0VORVJJQ19IQVJESVJRUwotCWRlZl9ib29sIHkKLQotY29uZmlnIEdFTkVSSUNfSVJRX1BST0JFCi0JZGVmX2Jvb2wgeQotCi1jb25maWcgR0VORVJJQ19IQVJESVJRU19OT19fRE9fSVJRCi0JZGVmX2Jvb2wgeQotCiBjb25maWcgR0VORVJJQ19HUElPCiAJZGVmX2Jvb2wgeQogCkBAIC0yNTQsMTEgKzI0OCw2IEBACiAJZGVwZW5kcyBvbiBTTVAgJiYgSE9UUExVRwogCWRlZmF1bHQgeQogCi1jb25maWcgSVJRX1BFUl9DUFUKLQlib29sCi0JZGVwZW5kcyBvbiBTTVAKLQlkZWZhdWx0IHkKLQogY29uZmlnIEhBVkVfTEVHQUNZX1BFUl9DUFVfQVJFQQogCWRlZl9ib29sIHkKIAlkZXBlbmRzIG9uIFNNUApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTE4Ri1FWkJSRF9kZWZjb25maWcgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MThGLUVaQlJEX2RlZmNvbmZpZwppbmRleCBjMGI5ODhlLi5kYjhkMzhhIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MThGLUVaQlJEX2RlZmNvbmZpZworKysgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MThGLUVaQlJEX2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfRUxGX0NPUkUgaXMgbm90IHNldAogIyBDT05GSUdfRlVURVggaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTI2LUVaQlJEX2RlZmNvbmZpZyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjUyNi1FWkJSRF9kZWZjb25maWcKaW5kZXggODY0YWY1Yi4uM2U1MGQ3OCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTI2LUVaQlJEX2RlZmNvbmZpZworKysgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MjYtRVpCUkRfZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19FTEZfQ09SRSBpcyBub3Qgc2V0CiAjIENPTkZJR19GVVRFWCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MjctQUQ3MTYwLUVWQUxfZGVmY29uZmlnIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTI3LUFENzE2MC1FVkFMX2RlZmNvbmZpZwppbmRleCA3YjZhMzM3Li4zNjJmNTlkIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MjctQUQ3MTYwLUVWQUxfZGVmY29uZmlnCisrKyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjUyNy1BRDcxNjAtRVZBTF9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKICMgQ09ORklHX0FJTyBpcyBub3Qgc2V0CiBDT05GSUdfU0xBQj15CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MjctRVpLSVQtVjJfZGVmY29uZmlnIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTI3LUVaS0lULVYyX2RlZmNvbmZpZwppbmRleCA0ZmFhNmI0Li4wMjNmZjBkIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MjctRVpLSVQtVjJfZGVmY29uZmlnCisrKyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjUyNy1FWktJVC1WMl9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKICMgQ09ORklHX0ZVVEVYIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjUyNy1FWktJVF9kZWZjb25maWcgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MjctRVpLSVRfZGVmY29uZmlnCmluZGV4IDlkODkzZWIuLjRlNWExMjEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjUyNy1FWktJVF9kZWZjb25maWcKKysrIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTI3LUVaS0lUX2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfRUxGX0NPUkUgaXMgbm90IHNldAogIyBDT05GSUdfRlVURVggaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTI3LVRMTDY1MjdNX2RlZmNvbmZpZyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjUyNy1UTEw2NTI3TV9kZWZjb25maWcKaW5kZXggOTdhMjc2Ny4uY2QwNjM2YiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTI3LVRMTDY1MjdNX2RlZmNvbmZpZworKysgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MjctVExMNjUyN01fZGVmY29uZmlnCkBAIC02LDcgKzYsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19FTEZfQ09SRSBpcyBub3Qgc2V0CiAjIENPTkZJR19GVVRFWCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MzMtRVpLSVRfZGVmY29uZmlnIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTMzLUVaS0lUX2RlZmNvbmZpZwppbmRleCBmODQ3NzQzLi45ZjhmYzg0IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MzMtRVpLSVRfZGVmY29uZmlnCisrKyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjUzMy1FWktJVF9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKICMgQ09ORklHX0ZVVEVYIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjUzMy1TVEFNUF9kZWZjb25maWcgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MzMtU1RBTVBfZGVmY29uZmlnCmluZGV4IDBlNzI2MmMuLmNjYzQzMmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjUzMy1TVEFNUF9kZWZjb25maWcKKysrIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTMzLVNUQU1QX2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfRUxGX0NPUkUgaXMgbm90IHNldAogIyBDT05GSUdfRlVURVggaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTM3LVNUQU1QX2RlZmNvbmZpZyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjUzNy1TVEFNUF9kZWZjb25maWcKaW5kZXggNGQxNGEwMC4uNTY2Njk1NCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTM3LVNUQU1QX2RlZmNvbmZpZworKysgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MzctU1RBTVBfZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19FTEZfQ09SRSBpcyBub3Qgc2V0CiAjIENPTkZJR19GVVRFWCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MzgtRVpLSVRfZGVmY29uZmlnIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTM4LUVaS0lUX2RlZmNvbmZpZwppbmRleCBmYmVlOWQ3Li5hYzIyMTI0IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1MzgtRVpLSVRfZGVmY29uZmlnCisrKyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjUzOC1FWktJVF9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKICMgQ09ORklHX0ZVVEVYIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjU0OC1FWktJVF9kZWZjb25maWcgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1NDgtRVpLSVRfZGVmY29uZmlnCmluZGV4IDA1ZGQxMWQuLjk0NDQwNGIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjU0OC1FWktJVF9kZWZjb25maWcKKysrIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTQ4LUVaS0lUX2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfRUxGX0NPUkUgaXMgbm90IHNldAogIyBDT05GSUdfRlVURVggaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTYxLUFDVklMT05fZGVmY29uZmlnIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTYxLUFDVklMT05fZGVmY29uZmlnCmluZGV4IGJjYjE0ZDEuLmI3Yzg0NTEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjU2MS1BQ1ZJTE9OX2RlZmNvbmZpZworKysgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1NjEtQUNWSUxPTl9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfRUxGX0NPUkUgaXMgbm90IHNldAogIyBDT05GSUdfRlVURVggaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTYxLUVaS0lULVNNUF9kZWZjb25maWcgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1NjEtRVpLSVQtU01QX2RlZmNvbmZpZwppbmRleCA0Y2Y0NTEwLi43ZTY3YmEzIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1NjEtRVpLSVQtU01QX2RlZmNvbmZpZworKysgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1NjEtRVpLSVQtU01QX2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfRUxGX0NPUkUgaXMgbm90IHNldAogIyBDT05GSUdfRlVURVggaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTYxLUVaS0lUX2RlZmNvbmZpZyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CRjU2MS1FWktJVF9kZWZjb25maWcKaW5kZXggODQzYWFhNS4uMTQxZTU5MyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JGNTYxLUVaS0lUX2RlZmNvbmZpZworKysgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQkY1NjEtRVpLSVRfZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19FTEZfQ09SRSBpcyBub3Qgc2V0CiAjIENPTkZJR19GVVRFWCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQmxhY2tTdGFtcF9kZWZjb25maWcgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQmxhY2tTdGFtcF9kZWZjb25maWcKaW5kZXggZGFlN2FkZi4uOTdlYmUwOSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0JsYWNrU3RhbXBfZGVmY29uZmlnCisrKyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9CbGFja1N0YW1wX2RlZmNvbmZpZwpAQCAtNiw3ICs2LDcgQEAKIENPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19FTEZfQ09SRSBpcyBub3Qgc2V0CiAjIENPTkZJR19GVVRFWCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQ00tQkY1MjdfZGVmY29uZmlnIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0NNLUJGNTI3X2RlZmNvbmZpZwppbmRleCBmMzQxNDI0Li5jMjQ1NzU0IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQ00tQkY1MjdfZGVmY29uZmlnCisrKyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9DTS1CRjUyN19kZWZjb25maWcKQEAgLTgsNyArOCw3IEBACiAjIENPTkZJR19SRF9HWklQIGlzIG5vdCBzZXQKIENPTkZJR19SRF9MWk1BPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKICMgQ09ORklHX0ZVVEVYIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9DTS1CRjUzM19kZWZjb25maWcgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQ00tQkY1MzNfZGVmY29uZmlnCmluZGV4IDhjN2UwOGYuLmJhZjFjMTUgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9DTS1CRjUzM19kZWZjb25maWcKKysrIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0NNLUJGNTMzX2RlZmNvbmZpZwpAQCAtNyw3ICs3LDcgQEAKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19SRF9HWklQIGlzIG5vdCBzZXQKIENPTkZJR19SRF9MWk1BPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1VJRDE2IGlzIG5vdCBzZXQKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9DTS1CRjUzN0VfZGVmY29uZmlnIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0NNLUJGNTM3RV9kZWZjb25maWcKaW5kZXggYmQzY2I3Ni4uNzA3Y2JmOCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0NNLUJGNTM3RV9kZWZjb25maWcKKysrIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0NNLUJGNTM3RV9kZWZjb25maWcKQEAgLTgsNyArOCw3IEBACiAjIENPTkZJR19SRF9HWklQIGlzIG5vdCBzZXQKIENPTkZJR19SRF9MWk1BPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1VJRDE2IGlzIG5vdCBzZXQKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9DTS1CRjUzN1VfZGVmY29uZmlnIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0NNLUJGNTM3VV9kZWZjb25maWcKaW5kZXggODIyMjRmMy4uNDU5NjkzNSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0NNLUJGNTM3VV9kZWZjb25maWcKKysrIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0NNLUJGNTM3VV9kZWZjb25maWcKQEAgLTgsNyArOCw3IEBACiAjIENPTkZJR19SRF9HWklQIGlzIG5vdCBzZXQKIENPTkZJR19SRF9MWk1BPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1VJRDE2IGlzIG5vdCBzZXQKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9DTS1CRjU0OF9kZWZjb25maWcgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQ00tQkY1NDhfZGVmY29uZmlnCmluZGV4IDQzMzU5OGMuLmRmMjY3NTggMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9DTS1CRjU0OF9kZWZjb25maWcKKysrIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0NNLUJGNTQ4X2RlZmNvbmZpZwpAQCAtOCw3ICs4LDcgQEAKICMgQ09ORklHX1JEX0daSVAgaXMgbm90IHNldAogQ09ORklHX1JEX0xaTUE9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfVUlEMTYgaXMgbm90IHNldAogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfRUxGX0NPUkUgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0NNLUJGNTYxX2RlZmNvbmZpZyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9DTS1CRjU2MV9kZWZjb25maWcKaW5kZXggZGVkN2Q4NC4uNmM3YjIxNSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0NNLUJGNTYxX2RlZmNvbmZpZworKysgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvQ00tQkY1NjFfZGVmY29uZmlnCkBAIC04LDcgKzgsNyBAQAogIyBDT05GSUdfUkRfR1pJUCBpcyBub3Qgc2V0CiBDT05GSUdfUkRfTFpNQT15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19VSUQxNiBpcyBub3Qgc2V0CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19FTEZfQ09SRSBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvRE5QNTM3MF9kZWZjb25maWcgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvRE5QNTM3MF9kZWZjb25maWcKaW5kZXggMGViYzdkOS4uZjUwMzEzNiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0ROUDUzNzBfZGVmY29uZmlnCisrKyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9ETlA1MzcwX2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19JS0NPTkZJR19QUk9DPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NMT0I9eQogIyBDT05GSUdfQkxLX0RFVl9CU0cgaXMgbm90IHNldAogIyBDT05GSUdfSU9TQ0hFRF9DRlEgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0g4NjA2X2RlZmNvbmZpZyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9IODYwNl9kZWZjb25maWcKaW5kZXggNzAwZmI3MC4uNzQ1MDEyNyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL0g4NjA2X2RlZmNvbmZpZworKysgYi9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvSDg2MDZfZGVmY29uZmlnCkBAIC0yLDcgKzIsNyBAQAogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKICMgQ09ORklHX0ZVVEVYIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9JUDBYX2RlZmNvbmZpZyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9JUDBYX2RlZmNvbmZpZwppbmRleCBiNDAxNTZkLi41ZTc5N2NmIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvSVAwWF9kZWZjb25maWcKKysrIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL0lQMFhfZGVmY29uZmlnCkBAIC0zLDcgKzMsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9QTkFWLTEwX2RlZmNvbmZpZyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9QTkFWLTEwX2RlZmNvbmZpZwppbmRleCBiZTg2NmQ5Li5hNTY2YTJmIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvUE5BVi0xMF9kZWZjb25maWcKKysrIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL1BOQVYtMTBfZGVmY29uZmlnCkBAIC0yLDcgKzIsNyBAQAogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKICMgQ09ORklHX0ZVVEVYIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9TUlYxX2RlZmNvbmZpZyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9TUlYxX2RlZmNvbmZpZwppbmRleCBiNjRiZGY3Li44NTM4MDk1IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvU1JWMV9kZWZjb25maWcKKysrIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL1NSVjFfZGVmY29uZmlnCkBAIC0zLDcgKzMsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiBDT05GSUdfS0FMTFNZTVNfQUxMPXkKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9UQ00tQkY1MThfZGVmY29uZmlnIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL1RDTS1CRjUxOF9kZWZjb25maWcKaW5kZXggMWJjY2Q5YS4uZDQ5NmFlOSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9jb25maWdzL1RDTS1CRjUxOF9kZWZjb25maWcKKysrIGIvYXJjaC9ibGFja2Zpbi9jb25maWdzL1RDTS1CRjUxOF9kZWZjb25maWcKQEAgLTcsNyArNyw3IEBACiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfUkRfR1pJUCBpcyBub3Qgc2V0CiBDT05GSUdfUkRfTFpNQT15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19FTEZfQ09SRSBpcyBub3Qgc2V0CiAjIENPTkZJR19GVVRFWCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2NvbmZpZ3MvVENNLUJGNTM3X2RlZmNvbmZpZyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9UQ00tQkY1MzdfZGVmY29uZmlnCmluZGV4IDAwY2U4OTkuLjY1ZjY0MjEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vY29uZmlncy9UQ00tQkY1MzdfZGVmY29uZmlnCisrKyBiL2FyY2gvYmxhY2tmaW4vY29uZmlncy9UQ00tQkY1MzdfZGVmY29uZmlnCkBAIC04LDcgKzgsNyBAQAogIyBDT05GSUdfUkRfR1pJUCBpcyBub3Qgc2V0CiBDT05GSUdfUkRfTFpNQT15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19VSUQxNiBpcyBub3Qgc2V0CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19FTEZfQ09SRSBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2JmaW5fc2VyaWFsLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2JmaW5fc2VyaWFsLmgKaW5kZXggMWZmOWYxNC4uN2RiYzY2NCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9iZmluX3NlcmlhbC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vYmZpbl9zZXJpYWwuaApAQCAtMTAsNiArMTAsNyBAQAogI2RlZmluZSBfX0JGSU5fQVNNX1NFUklBTF9IX18KIAogI2luY2x1ZGUgPGxpbnV4L3NlcmlhbF9jb3JlLmg+CisjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KICNpbmNsdWRlIDxtYWNoL2Fub21hbHkuaD4KICNpbmNsdWRlIDxtYWNoL2JmaW5fc2VyaWFsLmg+CiAKQEAgLTQxLDYgKzQyLDcgQEAKIAlzdHJ1Y3QgY2lyY19idWYgcnhfZG1hX2J1ZjsKIAlzdHJ1Y3QgdGltZXJfbGlzdCByeF9kbWFfdGltZXI7CiAJaW50IHJ4X2RtYV9ucm93czsKKwlzcGlubG9ja190IHJ4X2xvY2s7CiAJdW5zaWduZWQgaW50IHR4X2RtYV9jaGFubmVsOwogCXVuc2lnbmVkIGludCByeF9kbWFfY2hhbm5lbDsKIAlzdHJ1Y3Qgd29ya19zdHJ1Y3QgdHhfZG1hX3dvcmtxdWV1ZTsKZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9LY29uZmlnIGIvYXJjaC9jcmlzL0tjb25maWcKaW5kZXggNjEzZTYyOC4uMGE3YTRjMSAxMDA2NDQKLS0tIGEvYXJjaC9jcmlzL0tjb25maWcKKysrIGIvYXJjaC9jcmlzL0tjb25maWcKQEAgLTU0LDYgKzU0LDggQEAKIAlib29sCiAJZGVmYXVsdCB5CiAJc2VsZWN0IEhBVkVfSURFCisJc2VsZWN0IEhBVkVfR0VORVJJQ19IQVJESVJRUworCXNlbGVjdCBHRU5FUklDX0hBUkRJUlFTX05PX0RFUFJFQ0FURUQKIAogY29uZmlnIEhaCiAJaW50CkBAIC02NywxMCArNjksNiBAQAogCiBzb3VyY2UgImZzL0tjb25maWcuYmluZm10IgogCi1jb25maWcgR0VORVJJQ19IQVJESVJRUwotCWJvb2wKLQlkZWZhdWx0IHkKLQogY29uZmlnIEVUUkFYX0NNRExJTkUKIAlzdHJpbmcgIktlcm5lbCBjb21tYW5kIGxpbmUiCiAJZGVmYXVsdCAicm9vdD0vZGV2L210ZGJsb2NrMyIKZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9hcmNoLXYxMC9rZXJuZWwvaXJxLmMgYi9hcmNoL2NyaXMvYXJjaC12MTAva2VybmVsL2lycS5jCmluZGV4IGEwYzBkZjguLjczMjhhN2MgMTAwNjQ0Ci0tLSBhL2FyY2gvY3Jpcy9hcmNoLXYxMC9rZXJuZWwvaXJxLmMKKysrIGIvYXJjaC9jcmlzL2FyY2gtdjEwL2tlcm5lbC9pcnEuYwpAQCAtMTA0LDQzICsxMDQsMjEgQEAKIAlJUlEzMV9pbnRlcnJ1cHQKIH07CiAKLXN0YXRpYyB2b2lkIGVuYWJsZV9jcmlzdjEwX2lycSh1bnNpZ25lZCBpbnQgaXJxKTsKLQotc3RhdGljIHVuc2lnbmVkIGludCBzdGFydHVwX2NyaXN2MTBfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBlbmFibGVfY3Jpc3YxMF9pcnEoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCWVuYWJsZV9jcmlzdjEwX2lycShpcnEpOwotCXJldHVybiAwOworCWNyaXN2MTBfdW5tYXNrX2lycShkYXRhLT5pcnEpOwogfQogCi0jZGVmaW5lIHNodXRkb3duX2NyaXN2MTBfaXJxCWRpc2FibGVfY3Jpc3YxMF9pcnEKLQotc3RhdGljIHZvaWQgZW5hYmxlX2NyaXN2MTBfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBkaXNhYmxlX2NyaXN2MTBfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQljcmlzdjEwX3VubWFza19pcnEoaXJxKTsKLX0KLQotc3RhdGljIHZvaWQgZGlzYWJsZV9jcmlzdjEwX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWNyaXN2MTBfbWFza19pcnEoaXJxKTsKLX0KLQotc3RhdGljIHZvaWQgYWNrX2NyaXN2MTBfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci19Ci0KLXN0YXRpYyB2b2lkIGVuZF9jcmlzdjEwX2lycSh1bnNpZ25lZCBpbnQgaXJxKQoteworCWNyaXN2MTBfbWFza19pcnEoZGF0YS0+aXJxKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBjcmlzdjEwX2lycV90eXBlID0gewotCS5uYW1lID0gICAgICAgICJDUklTdjEwIiwKLQkuc3RhcnR1cCA9ICAgICBzdGFydHVwX2NyaXN2MTBfaXJxLAotCS5zaHV0ZG93biA9ICAgIHNodXRkb3duX2NyaXN2MTBfaXJxLAotCS5lbmFibGUgPSAgICAgIGVuYWJsZV9jcmlzdjEwX2lycSwKLQkuZGlzYWJsZSA9ICAgICBkaXNhYmxlX2NyaXN2MTBfaXJxLAotCS5hY2sgPSAgICAgICAgIGFja19jcmlzdjEwX2lycSwKLQkuZW5kID0gICAgICAgICBlbmRfY3Jpc3YxMF9pcnEsCi0JLnNldF9hZmZpbml0eSA9IE5VTEwKKwkubmFtZQkJPSAiQ1JJU3YxMCIsCisJLmlycV9zaHV0ZG93bgk9IGRpc2FibGVfY3Jpc3YxMF9pcnEsCisJLmlycV9lbmFibGUJPSBlbmFibGVfY3Jpc3YxMF9pcnEsCisJLmlycV9kaXNhYmxlCT0gZGlzYWJsZV9jcmlzdjEwX2lycSwKIH07CiAKIHZvaWQgd2VpcmRfaXJxKHZvaWQpOwpAQCAtMjIxLDcgKzE5OSw4IEBACiAKIAkvKiBJbml0aWFsaXplIElSUSBoYW5kbGVyIGRlc2NyaXB0b3JzLiAqLwogCWZvcihpID0gMjsgaSA8IE5SX0lSUVM7IGkrKykgewotCQlpcnFfZGVzY1tpXS5jaGlwID0gJmNyaXN2MTBfaXJxX3R5cGU7CisJCXNldF9pcnFfZGVzY19hbmRfaGFuZGxlcihpLCAmY3Jpc3YxMF9pcnFfdHlwZSwKKwkJCQkJIGhhbmRsZV9zaW1wbGVfaXJxKTsKIAkJc2V0X2ludF92ZWN0b3IoaSwgaW50ZXJydXB0W2ldKTsKIAl9CiAKZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9hcmNoLXYzMi9rZXJuZWwvaXJxLmMgYi9hcmNoL2NyaXMvYXJjaC12MzIva2VybmVsL2lycS5jCmluZGV4IDJlZDQ4YWUzZC4uMGFkOWRiNSAxMDA2NDQKLS0tIGEvYXJjaC9jcmlzL2FyY2gtdjMyL2tlcm5lbC9pcnEuYworKysgYi9hcmNoL2NyaXMvYXJjaC12MzIva2VybmVsL2lycS5jCkBAIC0yOTEsNTQgKzI5MSwzMyBAQAogfQogCiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQgc3RhcnR1cF9jcmlzdjMyX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgZW5hYmxlX2NyaXN2MzJfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQljcmlzdjMyX3VubWFza19pcnEoaXJxKTsKLQlyZXR1cm4gMDsKKwljcmlzdjMyX3VubWFza19pcnEoZGF0YS0+aXJxKTsKIH0KIAotc3RhdGljIHZvaWQgc2h1dGRvd25fY3Jpc3YzMl9pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGRpc2FibGVfY3Jpc3YzMl9pcnEoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCWNyaXN2MzJfbWFza19pcnEoaXJxKTsKKwljcmlzdjMyX21hc2tfaXJxKGRhdGEtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIGVuYWJsZV9jcmlzdjMyX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWNyaXN2MzJfdW5tYXNrX2lycShpcnEpOwotfQotCi1zdGF0aWMgdm9pZCBkaXNhYmxlX2NyaXN2MzJfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JY3Jpc3YzMl9tYXNrX2lycShpcnEpOwotfQotCi1zdGF0aWMgdm9pZCBhY2tfY3Jpc3YzMl9pcnEodW5zaWduZWQgaW50IGlycSkKLXsKLX0KLQotc3RhdGljIHZvaWQgZW5kX2NyaXN2MzJfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci19Ci0KLWludCBzZXRfYWZmaW5pdHlfY3Jpc3YzMl9pcnEodW5zaWduZWQgaW50IGlycSwgY29uc3Qgc3RydWN0IGNwdW1hc2sgKmRlc3QpCitzdGF0aWMgaW50IHNldF9hZmZpbml0eV9jcmlzdjMyX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEsCisJCQkJICAgIGNvbnN0IHN0cnVjdCBjcHVtYXNrICpkZXN0LCBib29sIGZvcmNlKQogewogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0Jc3Bpbl9sb2NrX2lycXNhdmUoJmlycV9sb2NrLCBmbGFncyk7Ci0JaXJxX2FsbG9jYXRpb25zW2lycSAtIEZJUlNUX0lSUV0ubWFzayA9ICpkZXN0OwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmlycV9sb2NrLCBmbGFncyk7CiAKKwlzcGluX2xvY2tfaXJxc2F2ZSgmaXJxX2xvY2ssIGZsYWdzKTsKKwlpcnFfYWxsb2NhdGlvbnNbZGF0YS0+aXJxIC0gRklSU1RfSVJRXS5tYXNrID0gKmRlc3Q7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaXJxX2xvY2ssIGZsYWdzKTsKIAlyZXR1cm4gMDsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBjcmlzdjMyX2lycV90eXBlID0gewotCS5uYW1lID0gICAgICAgICJDUklTdjMyIiwKLQkuc3RhcnR1cCA9ICAgICBzdGFydHVwX2NyaXN2MzJfaXJxLAotCS5zaHV0ZG93biA9ICAgIHNodXRkb3duX2NyaXN2MzJfaXJxLAotCS5lbmFibGUgPSAgICAgIGVuYWJsZV9jcmlzdjMyX2lycSwKLQkuZGlzYWJsZSA9ICAgICBkaXNhYmxlX2NyaXN2MzJfaXJxLAotCS5hY2sgPSAgICAgICAgIGFja19jcmlzdjMyX2lycSwKLQkuZW5kID0gICAgICAgICBlbmRfY3Jpc3YzMl9pcnEsCi0JLnNldF9hZmZpbml0eSA9IHNldF9hZmZpbml0eV9jcmlzdjMyX2lycQorCS5uYW1lCQkJPSAiQ1JJU3YzMiIsCisJLmlycV9zaHV0ZG93bgkJPSBkaXNhYmxlX2NyaXN2MzJfaXJxLAorCS5pcnFfZW5hYmxlCQk9IGVuYWJsZV9jcmlzdjMyX2lycSwKKwkuaXJxX2Rpc2FibGUJCT0gZGlzYWJsZV9jcmlzdjMyX2lycSwKKwkuaXJxX3NldF9hZmZpbml0eQk9IHNldF9hZmZpbml0eV9jcmlzdjMyX2lycSwKIH07CiAKIHZvaWQKQEAgLTQ3Miw3ICs0NTEsOCBAQAogCiAJLyogUG9pbnQgYWxsIElSUSdzIHRvIGJhZCBoYW5kbGVycy4gKi8KIAlmb3IgKGkgPSBGSVJTVF9JUlEsIGogPSAwOyBqIDwgTlJfSVJRUzsgaSsrLCBqKyspIHsKLQkJaXJxX2Rlc2Nbal0uY2hpcCA9ICZjcmlzdjMyX2lycV90eXBlOworCQlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoaiwgJmNyaXN2MzJfaXJxX3R5cGUsCisJCQkJCSBoYW5kbGVfc2ltcGxlX2lycSk7CiAJCXNldF9leGNlcHRpb25fdmVjdG9yKGksIGludGVycnVwdFtqXSk7CiAJfQogCmRpZmYgLS1naXQgYS9hcmNoL2NyaXMvY29uZmlncy9hcnRwZWNfM19kZWZjb25maWcgYi9hcmNoL2NyaXMvY29uZmlncy9hcnRwZWNfM19kZWZjb25maWcKaW5kZXggNTkwZjcyYy4uNzE4NTRkNCAxMDA2NDQKLS0tIGEvYXJjaC9jcmlzL2NvbmZpZ3MvYXJ0cGVjXzNfZGVmY29uZmlnCisrKyBiL2FyY2gvY3Jpcy9jb25maWdzL2FydHBlY18zX2RlZmNvbmZpZwpAQCAtMiw3ICsyLDcgQEAKICMgQ09ORklHX1NXQVAgaXMgbm90IHNldAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX0hPVFBMVUcgaXMgbm90IHNldAogIyBDT05GSUdfQkxLX0RFVl9CU0cgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9jcmlzL2NvbmZpZ3MvZXRyYXgtMTAwbHhfdjJfZGVmY29uZmlnIGIvYXJjaC9jcmlzL2NvbmZpZ3MvZXRyYXgtMTAwbHhfdjJfZGVmY29uZmlnCmluZGV4IDFiMjg1M2UuLmE4NWFhYmYgMTAwNjQ0Ci0tLSBhL2FyY2gvY3Jpcy9jb25maWdzL2V0cmF4LTEwMGx4X3YyX2RlZmNvbmZpZworKysgYi9hcmNoL2NyaXMvY29uZmlncy9ldHJheC0xMDBseF92Ml9kZWZjb25maWcKQEAgLTIsNyArMiw3IEBACiAjIENPTkZJR19TV0FQIGlzIG5vdCBzZXQKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9jb25maWdzL2V0cmF4ZnNfZGVmY29uZmlnIGIvYXJjaC9jcmlzL2NvbmZpZ3MvZXRyYXhmc19kZWZjb25maWcKaW5kZXggZjczZDM4Yy4uODdjNzIyNyAxMDA2NDQKLS0tIGEvYXJjaC9jcmlzL2NvbmZpZ3MvZXRyYXhmc19kZWZjb25maWcKKysrIGIvYXJjaC9jcmlzL2NvbmZpZ3MvZXRyYXhmc19kZWZjb25maWcKQEAgLTIsNyArMiw3IEBACiAjIENPTkZJR19TV0FQIGlzIG5vdCBzZXQKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9rZXJuZWwvaXJxLmMgYi9hcmNoL2NyaXMva2VybmVsL2lycS5jCmluZGV4IDQ2OWY3ZjkuLmMzNDY5NTIgMTAwNjQ0Ci0tLSBhL2FyY2gvY3Jpcy9rZXJuZWwvaXJxLmMKKysrIGIvYXJjaC9jcmlzL2tlcm5lbC9pcnEuYwpAQCAtNjIsNyArNjIsNyBAQAogCQlmb3JfZWFjaF9vbmxpbmVfY3B1KGopCiAJCQlzZXFfcHJpbnRmKHAsICIlMTB1ICIsIGtzdGF0X2lycXNfY3B1KGksIGopKTsKICNlbmRpZgotCQlzZXFfcHJpbnRmKHAsICIgJTE0cyIsIGlycV9kZXNjW2ldLmNoaXAtPm5hbWUpOworCQlzZXFfcHJpbnRmKHAsICIgJTE0cyIsIGlycV9kZXNjW2ldLmlycV9kYXRhLmNoaXAtPm5hbWUpOwogCQlzZXFfcHJpbnRmKHAsICIgICVzIiwgYWN0aW9uLT5uYW1lKTsKIAogCQlmb3IgKGFjdGlvbj1hY3Rpb24tPm5leHQ7IGFjdGlvbjsgYWN0aW9uID0gYWN0aW9uLT5uZXh0KQpAQCAtOTMsOCArOTMsOCBAQAogCQlwcmludGsoImRvX0lSUTogc3RhY2sgb3ZlcmZsb3c6ICVsWFxuIiwgc3ApOwogCQlzaG93X3N0YWNrKE5VTEwsICh1bnNpZ25lZCBsb25nICopc3ApOwogCX0KLQlfX2RvX0lSUShpcnEpOwotICAgICAgICBpcnFfZXhpdCgpOworCWdlbmVyaWNfaGFuZGxlX2lycShpcnEpOworCWlycV9leGl0KCk7CiAJc2V0X2lycV9yZWdzKG9sZF9yZWdzKTsKIH0KIApkaWZmIC0tZ2l0IGEvYXJjaC9mcnYvS2NvbmZpZyBiL2FyY2gvZnJ2L0tjb25maWcKaW5kZXggZjZiY2IwMy4uNzQ3NDk5YSAxMDA2NDQKLS0tIGEvYXJjaC9mcnYvS2NvbmZpZworKysgYi9hcmNoL2Zydi9LY29uZmlnCkBAIC01LDYgKzUsNyBAQAogCXNlbGVjdCBIQVZFX0FSQ0hfVFJBQ0VIT09LCiAJc2VsZWN0IEhBVkVfSVJRX1dPUksKIAlzZWxlY3QgSEFWRV9QRVJGX0VWRU5UUworCXNlbGVjdCBIQVZFX0dFTkVSSUNfSEFSRElSUVMKIAogY29uZmlnIFpPTkVfRE1BCiAJYm9vbApAQCAtMjksMTQgKzMwLDYgQEAKIAlib29sCiAJZGVmYXVsdCBuCiAKLWNvbmZpZyBHRU5FUklDX0hBUkRJUlFTCi0JYm9vbAotCWRlZmF1bHQgeQotCi1jb25maWcgR0VORVJJQ19IQVJESVJRU19OT19fRE9fSVJRCi0JYm9vbAotCWRlZmF1bHQgeQotCiBjb25maWcgVElNRV9MT1dfUkVTCiAJYm9vbAogCWRlZmF1bHQgeQpkaWZmIC0tZ2l0IGEvYXJjaC9mcnYvZGVmY29uZmlnIGIvYXJjaC9mcnYvZGVmY29uZmlnCmluZGV4IGI4ZWJlOWUuLmIxYjc5MjYgMTAwNjQ0Ci0tLSBhL2FyY2gvZnJ2L2RlZmNvbmZpZworKysgYi9hcmNoL2Zydi9kZWZjb25maWcKQEAgLTMsNyArMyw3IEBACiBDT05GSUdfUE9TSVhfTVFVRVVFPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKIENPTkZJR19NTVU9eQogQ09ORklHX0ZSVl9PVVRPRkxJTkVfQVRPTUlDX09QUz15CmRpZmYgLS1naXQgYS9hcmNoL2g4MzAwL0tjb25maWcgYi9hcmNoL2g4MzAwL0tjb25maWcKaW5kZXggNjVmODk3ZDguLjZkZjY5MmQgMTAwNjQ0Ci0tLSBhL2FyY2gvaDgzMDAvS2NvbmZpZworKysgYi9hcmNoL2g4MzAwL0tjb25maWcKQEAgLTIsNiArMiw4IEBACiAJYm9vbAogCWRlZmF1bHQgeQogCXNlbGVjdCBIQVZFX0lERQorCXNlbGVjdCBIQVZFX0dFTkVSSUNfSEFSRElSUVMKKwlzZWxlY3QgR0VORVJJQ19IQVJESVJRU19OT19ERVBSRUNBVEVECiAKIGNvbmZpZyBTWU1CT0xfUFJFRklYCiAJc3RyaW5nCkBAIC00NywxMCArNDksNiBAQAogCWJvb2wKIAlkZWZhdWx0IHkKIAotY29uZmlnIEdFTkVSSUNfSEFSRElSUVMKLQlib29sCi0JZGVmYXVsdCB5Ci0KIGNvbmZpZyBHRU5FUklDX0NBTElCUkFURV9ERUxBWQogCWJvb2wKIAlkZWZhdWx0IHkKZGlmZiAtLWdpdCBhL2FyY2gvaDgzMDAvZGVmY29uZmlnIGIvYXJjaC9oODMwMC9kZWZjb25maWcKaW5kZXggMzQyZjc3Ny4uMDQyNDI1YSAxMDA2NDQKLS0tIGEvYXJjaC9oODMwMC9kZWZjb25maWcKKysrIGIvYXJjaC9oODMwMC9kZWZjb25maWcKQEAgLTEsNyArMSw3IEBACiBDT05GSUdfRVhQRVJJTUVOVEFMPXkKICMgQ09ORklHX0xPQ0FMVkVSU0lPTl9BVVRPIGlzIG5vdCBzZXQKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19VSUQxNiBpcyBub3Qgc2V0CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL2g4MzAwL2tlcm5lbC9pcnEuYyBiL2FyY2gvaDgzMDAva2VybmVsL2lycS5jCmluZGV4IGMyNWRjMmMuLjc2NDNkMzkgMTAwNjQ0Ci0tLSBhL2FyY2gvaDgzMDAva2VybmVsL2lycS5jCisrKyBiL2FyY2gvaDgzMDAva2VybmVsL2lycS5jCkBAIC0zOCwzNCArMzgsMzAgQEAKIAlyZXR1cm4gKGlycSA+PSBFWFRfSVJRMCAmJiBpcnEgPD0gKEVYVF9JUlEwICsgRVhUX0lSUVMpKTsKIH0KIAotc3RhdGljIHZvaWQgaDgzMDBfZW5hYmxlX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaDgzMDBfZW5hYmxlX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JaWYgKGlzX2V4dF9pcnEoaXJxKSkKLQkJSUVSX1JFR1MgfD0gMSA8PCAoaXJxIC0gRVhUX0lSUTApOworCWlmIChpc19leHRfaXJxKGRhdGEtPmlycSkpCisJCUlFUl9SRUdTIHw9IDEgPDwgKGRhdGEtPmlycSAtIEVYVF9JUlEwKTsKIH0KIAotc3RhdGljIHZvaWQgaDgzMDBfZGlzYWJsZV9pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGg4MzAwX2Rpc2FibGVfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlpZiAoaXNfZXh0X2lycShpcnEpKQotCQlJRVJfUkVHUyAmPSB+KDEgPDwgKGlycSAtIEVYVF9JUlEwKSk7CisJaWYgKGlzX2V4dF9pcnEoZGF0YS0+aXJxKSkKKwkJSUVSX1JFR1MgJj0gfigxIDw8IChkYXRhLT5pcnEgLSBFWFRfSVJRMCkpOwogfQogCi1zdGF0aWMgdm9pZCBoODMwMF9lbmRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdW5zaWduZWQgaW50IGg4MzAwX3N0YXJ0dXBfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLX0KLQotc3RhdGljIHVuc2lnbmVkIGludCBoODMwMF9zdGFydHVwX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWlmIChpc19leHRfaXJxKGlycSkpCi0JCXJldHVybiBoODMwMF9lbmFibGVfaXJxX3BpbihpcnEpOworCWlmIChpc19leHRfaXJxKGRhdGEtPmlycSkpCisJCXJldHVybiBoODMwMF9lbmFibGVfaXJxX3BpbihkYXRhLT5pcnEpOwogCWVsc2UKIAkJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyB2b2lkIGg4MzAwX3NodXRkb3duX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaDgzMDBfc2h1dGRvd25faXJxKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlpZiAoaXNfZXh0X2lycShpcnEpKQotCQloODMwMF9kaXNhYmxlX2lycV9waW4oaXJxKTsKKwlpZiAoaXNfZXh0X2lycShkYXRhLT5pcnEpKQorCQloODMwMF9kaXNhYmxlX2lycV9waW4oZGF0YS0+aXJxKTsKIH0KIAogLyoKQEAgLTczLDEyICs2OSwxMCBAQAogICovCiBzdHJ1Y3QgaXJxX2NoaXAgaDgzMDBpcnFfY2hpcCA9IHsKIAkubmFtZQkJPSAiSDgzMDAtSU5UQyIsCi0JLnN0YXJ0dXAJPSBoODMwMF9zdGFydHVwX2lycSwKLQkuc2h1dGRvd24JPSBoODMwMF9zaHV0ZG93bl9pcnEsCi0JLmVuYWJsZQkJPSBoODMwMF9lbmFibGVfaXJxLAotCS5kaXNhYmxlCT0gaDgzMDBfZGlzYWJsZV9pcnEsCi0JLmFjawkJPSBOVUxMLAotCS5lbmQJCT0gaDgzMDBfZW5kX2lycSwKKwkuaXJxX3N0YXJ0dXAJPSBoODMwMF9zdGFydHVwX2lycSwKKwkuaXJxX3NodXRkb3duCT0gaDgzMDBfc2h1dGRvd25faXJxLAorCS5pcnFfZW5hYmxlCT0gaDgzMDBfZW5hYmxlX2lycSwKKwkuaXJxX2Rpc2FibGUJPSBoODMwMF9kaXNhYmxlX2lycSwKIH07CiAKICNpZiBkZWZpbmVkKENPTkZJR19SQU1LRVJORUwpCkBAIC0xNjAsMTggKzE1NCwxNCBAQAogCiAJc2V0dXBfdmVjdG9yKCk7CiAKLQlmb3IgKGMgPSAwOyBjIDwgTlJfSVJRUzsgYysrKSB7Ci0JCWlycV9kZXNjW2NdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQkJaXJxX2Rlc2NbY10uYWN0aW9uID0gTlVMTDsKLQkJaXJxX2Rlc2NbY10uZGVwdGggPSAxOwotCQlpcnFfZGVzY1tjXS5jaGlwID0gJmg4MzAwaXJxX2NoaXA7Ci0JfQorCWZvciAoYyA9IDA7IGMgPCBOUl9JUlFTOyBjKyspCisJCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihjLCAmaDgzMDBpcnFfY2hpcCwgaGFuZGxlX3NpbXBsZV9pcnEpOwogfQogCiBhc21saW5rYWdlIHZvaWQgZG9fSVJRKGludCBpcnEpCiB7CiAJaXJxX2VudGVyKCk7Ci0JX19kb19JUlEoaXJxKTsKKwlnZW5lcmljX2hhbmRsZV9pcnEoaXJxKTsKIAlpcnFfZXhpdCgpOwogfQogCkBAIC0xOTIsNyArMTgyLDcgQEAKIAkJCWdvdG8gdW5sb2NrOwogCQlzZXFfcHJpbnRmKHAsICIlM2Q6ICIsaSk7CiAJCXNlcV9wcmludGYocCwgIiUxMHUgIiwga3N0YXRfaXJxcyhpKSk7Ci0JCXNlcV9wcmludGYocCwgIiAlMTRzIiwgaXJxX2Rlc2NbaV0uY2hpcC0+bmFtZSk7CisJCXNlcV9wcmludGYocCwgIiAlMTRzIiwgaXJxX2Rlc2NbaV0uaXJxX2RhdGEuY2hpcC0+bmFtZSk7CiAJCXNlcV9wcmludGYocCwgIi0lLThzIiwgaXJxX2Rlc2NbaV0ubmFtZSk7CiAJCXNlcV9wcmludGYocCwgIiAgJXMiLCBhY3Rpb24tPm5hbWUpOwogCmRpZmYgLS1naXQgYS9hcmNoL2lhNjQvS2NvbmZpZyBiL2FyY2gvaWE2NC9LY29uZmlnCmluZGV4IGUwZjViNmQuLmZjZjNiNDMgMTAwNjQ0Ci0tLSBhL2FyY2gvaWE2NC9LY29uZmlnCisrKyBiL2FyY2gvaWE2NC9LY29uZmlnCkBAIC0yMiw2ICsyMiwxMCBAQAogCXNlbGVjdCBIQVZFX0tWTQogCXNlbGVjdCBIQVZFX0FSQ0hfVFJBQ0VIT09LCiAJc2VsZWN0IEhBVkVfRE1BX0FQSV9ERUJVRworCXNlbGVjdCBIQVZFX0dFTkVSSUNfSEFSRElSUVMKKwlzZWxlY3QgR0VORVJJQ19JUlFfUFJPQkUKKwlzZWxlY3QgR0VORVJJQ19QRU5ESU5HX0lSUSBpZiBTTVAKKwlzZWxlY3QgSVJRX1BFUl9DUFUKIAlkZWZhdWx0IHkKIAloZWxwCiAJICBUaGUgSXRhbml1bSBQcm9jZXNzb3IgRmFtaWx5IGlzIEludGVsJ3MgNjQtYml0IHN1Y2Nlc3NvciB0bwpAQCAtNjc4LDI4ICs2ODIsNiBAQAogCiBzb3VyY2UgImxpYi9LY29uZmlnIgogCi0jCi0jIFVzZSB0aGUgZ2VuZXJpYyBpbnRlcnJ1cHQgaGFuZGxpbmcgY29kZSBpbiBrZXJuZWwvaXJxLzoKLSMKLWNvbmZpZyBHRU5FUklDX0hBUkRJUlFTCi0JZGVmX2Jvb2wgeQotCi1jb25maWcgR0VORVJJQ19IQVJESVJRU19OT19fRE9fSVJRCi0JZGVmX2Jvb2wgeQotCi1jb25maWcgR0VORVJJQ19JUlFfUFJPQkUKLQlib29sCi0JZGVmYXVsdCB5Ci0KLWNvbmZpZyBHRU5FUklDX1BFTkRJTkdfSVJRCi0JYm9vbAotCWRlcGVuZHMgb24gR0VORVJJQ19IQVJESVJRUyAmJiBTTVAKLQlkZWZhdWx0IHkKLQotY29uZmlnIElSUV9QRVJfQ1BVCi0JYm9vbAotCWRlZmF1bHQgeQotCiBjb25maWcgSU9NTVVfSEVMUEVSCiAJZGVmX2Jvb2wgKElBNjRfSFBfWlgxIHx8IElBNjRfSFBfWlgxX1NXSU9UTEIgfHwgSUE2NF9HRU5FUklDIHx8IFNXSU9UTEIpCiAKZGlmZiAtLWdpdCBhL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9pby5oIGIvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL2lvLmgKaW5kZXggY2M4MzM1ZS4uZTVhNmMzNSAxMDA2NDQKLS0tIGEvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL2lvLmgKKysrIGIvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL2lvLmgKQEAgLTQyNiw2ICs0MjYsMTEgQEAKIGV4dGVybiB2b2lkIGlvdW5tYXAgKHZvbGF0aWxlIHZvaWQgX19pb21lbSAqYWRkcik7CiBleHRlcm4gdm9pZCBfX2lvbWVtICogZWFybHlfaW9yZW1hcCAodW5zaWduZWQgbG9uZyBwaHlzX2FkZHIsIHVuc2lnbmVkIGxvbmcgc2l6ZSk7CiBleHRlcm4gdm9pZCBlYXJseV9pb3VubWFwICh2b2xhdGlsZSB2b2lkIF9faW9tZW0gKmFkZHIsIHVuc2lnbmVkIGxvbmcgc2l6ZSk7CitzdGF0aWMgaW5saW5lIHZvaWQgX19pb21lbSAqIGlvcmVtYXBfY2FjaGUgKHVuc2lnbmVkIGxvbmcgcGh5c19hZGRyLCB1bnNpZ25lZCBsb25nIHNpemUpCit7CisJcmV0dXJuIGlvcmVtYXAocGh5c19hZGRyLCBzaXplKTsKK30KKwogCiAvKgogICogU3RyaW5nIHZlcnNpb24gb2YgSU8gbWVtb3J5IGFjY2VzcyBvcHM6CmRpZmYgLS1naXQgYS9hcmNoL2lhNjQvaW5jbHVkZS9hc20vcGFnZS5oIGIvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL3BhZ2UuaAppbmRleCA0MWI2ZDMxLi45NjFhMTZmIDEwMDY0NAotLS0gYS9hcmNoL2lhNjQvaW5jbHVkZS9hc20vcGFnZS5oCisrKyBiL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9wYWdlLmgKQEAgLTE4OSw2ICsxODksNyBAQAogIyBkZWZpbmUgcGdwcm90X3ZhbCh4KQkoKHgpLnBncHJvdCkKIAogIyBkZWZpbmUgX19wdGUoeCkJKChwdGVfdCkgeyAoeCkgfSApCisjIGRlZmluZSBfX3BtZCh4KQkoKHBtZF90KSB7ICh4KSB9ICkKICMgZGVmaW5lIF9fcGdwcm90KHgpCSgocGdwcm90X3QpIHsgKHgpIH0gKQogCiAjZWxzZSAvKiAhU1RSSUNUX01NX1RZUEVDSEVDS1MgKi8KZGlmZiAtLWdpdCBhL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9wcm9jZXNzb3IuaCBiL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9wcm9jZXNzb3IuaAppbmRleCAzNDhlNDRkLi4wM2FmZTc5IDEwMDY0NAotLS0gYS9hcmNoL2lhNjQvaW5jbHVkZS9hc20vcHJvY2Vzc29yLmgKKysrIGIvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL3Byb2Nlc3Nvci5oCkBAIC03MTcsOCArNzE3LDkgQEAKICNkZWZpbmUgc3Bpbl9sb2NrX3ByZWZldGNoKHgpCXByZWZldGNodyh4KQogCiBleHRlcm4gdW5zaWduZWQgbG9uZyBib290X29wdGlvbl9pZGxlX292ZXJyaWRlOwotZXh0ZXJuIHVuc2lnbmVkIGxvbmcgaWRsZV9oYWx0OwotZXh0ZXJuIHVuc2lnbmVkIGxvbmcgaWRsZV9ub213YWl0OworCitlbnVtIGlkbGVfYm9vdF9vdmVycmlkZSB7SURMRV9OT19PVkVSUklERT0wLCBJRExFX0hBTFQsIElETEVfRk9SQ0VfTVdBSVQsCisJCQkgSURMRV9OT01XQUlULCBJRExFX1BPTEx9OwogCiAjZW5kaWYgLyogIV9fQVNTRU1CTFlfXyAqLwogCmRpZmYgLS1naXQgYS9hcmNoL2lhNjQva2VybmVsL3BlcmZtb24uYyBiL2FyY2gvaWE2NC9rZXJuZWwvcGVyZm1vbi5jCmluZGV4IGFjNzZkYTAuLjg5YWNjYzYgMTAwNjQ0Ci0tLSBhL2FyY2gvaWE2NC9rZXJuZWwvcGVyZm1vbi5jCisrKyBiL2FyY2gvaWE2NC9rZXJuZWwvcGVyZm1vbi5jCkBAIC02MTgsNyArNjE4LDcgQEAKIH0KIAogLyogZm9yd2FyZCBkZWNsYXJhdGlvbiAqLwotc3RhdGljIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZGVudHJ5X29wZXJhdGlvbnMgcGZtZnNfZGVudHJ5X29wZXJhdGlvbnM7CitzdGF0aWMgY29uc3Qgc3RydWN0IGRlbnRyeV9vcGVyYXRpb25zIHBmbWZzX2RlbnRyeV9vcGVyYXRpb25zOwogCiBzdGF0aWMgc3RydWN0IGRlbnRyeSAqCiBwZm1mc19tb3VudChzdHJ1Y3QgZmlsZV9zeXN0ZW1fdHlwZSAqZnNfdHlwZSwgaW50IGZsYWdzLCBjb25zdCBjaGFyICpkZXZfbmFtZSwgdm9pZCAqZGF0YSkKZGlmZiAtLWdpdCBhL2FyY2gvaWE2NC9rZXJuZWwvcHJvY2Vzcy5jIGIvYXJjaC9pYTY0L2tlcm5lbC9wcm9jZXNzLmMKaW5kZXggMTZmMWM3Yi4uNmQzM2M1YyAxMDA2NDQKLS0tIGEvYXJjaC9pYTY0L2tlcm5lbC9wcm9jZXNzLmMKKysrIGIvYXJjaC9pYTY0L2tlcm5lbC9wcm9jZXNzLmMKQEAgLTUzLDEyICs1Myw4IEBACiAKIHZvaWQgKCppYTY0X21hcmtfaWRsZSkoaW50KTsKIAotdW5zaWduZWQgbG9uZyBib290X29wdGlvbl9pZGxlX292ZXJyaWRlID0gMDsKK3Vuc2lnbmVkIGxvbmcgYm9vdF9vcHRpb25faWRsZV9vdmVycmlkZSA9IElETEVfTk9fT1ZFUlJJREU7CiBFWFBPUlRfU1lNQk9MKGJvb3Rfb3B0aW9uX2lkbGVfb3ZlcnJpZGUpOwotdW5zaWduZWQgbG9uZyBpZGxlX2hhbHQ7Ci1FWFBPUlRfU1lNQk9MKGlkbGVfaGFsdCk7Ci11bnNpZ25lZCBsb25nIGlkbGVfbm9td2FpdDsKLUVYUE9SVF9TWU1CT0woaWRsZV9ub213YWl0KTsKIHZvaWQgKCpwbV9pZGxlKSAodm9pZCk7CiBFWFBPUlRfU1lNQk9MKHBtX2lkbGUpOwogdm9pZCAoKnBtX3Bvd2VyX29mZikgKHZvaWQpOwpkaWZmIC0tZ2l0IGEvYXJjaC9pYTY0L21tL2h1Z2V0bGJwYWdlLmMgYi9hcmNoL2lhNjQvbW0vaHVnZXRsYnBhZ2UuYwppbmRleCAxODQxZWU3Li41Y2E2NzRiIDEwMDY0NAotLS0gYS9hcmNoL2lhNjQvbW0vaHVnZXRsYnBhZ2UuYworKysgYi9hcmNoL2lhNjQvbW0vaHVnZXRsYnBhZ2UuYwpAQCAtMzgsNyArMzgsNyBAQAogCWlmIChwdWQpIHsKIAkJcG1kID0gcG1kX2FsbG9jKG1tLCBwdWQsIHRhZGRyKTsKIAkJaWYgKHBtZCkKLQkJCXB0ZSA9IHB0ZV9hbGxvY19tYXAobW0sIHBtZCwgdGFkZHIpOworCQkJcHRlID0gcHRlX2FsbG9jX21hcChtbSwgTlVMTCwgcG1kLCB0YWRkcik7CiAJfQogCXJldHVybiBwdGU7CiB9CmRpZmYgLS1naXQgYS9hcmNoL20zMnIvS2NvbmZpZyBiL2FyY2gvbTMyci9LY29uZmlnCmluZGV4IDVjMjkxZDYuLmVmNGMxZTQgMTAwNjQ0Ci0tLSBhL2FyY2gvbTMyci9LY29uZmlnCisrKyBiL2FyY2gvbTMyci9LY29uZmlnCkBAIC03LDYgKzcsOSBAQAogCXNlbGVjdCBIQVZFX0tFUk5FTF9HWklQCiAJc2VsZWN0IEhBVkVfS0VSTkVMX0JaSVAyCiAJc2VsZWN0IEhBVkVfS0VSTkVMX0xaTUEKKwlzZWxlY3QgSEFWRV9HRU5FUklDX0hBUkRJUlFTCisJc2VsZWN0IEdFTkVSSUNfSEFSRElSUVNfTk9fREVQUkVDQVRFRAorCXNlbGVjdCBHRU5FUklDX0lSUV9QUk9CRQogCiBjb25maWcgU0JVUwogCWJvb2wKQEAgLTE5LDE0ICsyMiw2IEBACiAJYm9vbAogCWRlZmF1bHQgeQogCi1jb25maWcgR0VORVJJQ19IQVJESVJRUwotCWJvb2wKLQlkZWZhdWx0IHkKLQotY29uZmlnIEdFTkVSSUNfSVJRX1BST0JFCi0JYm9vbAotCWRlZmF1bHQgeQotCiBjb25maWcgTk9fSU9QT1JUCiAJZGVmX2Jvb2wgeQogCmRpZmYgLS1naXQgYS9hcmNoL20zMnIvY29uZmlncy9tMzI3MDB1dC5zbXBfZGVmY29uZmlnIGIvYXJjaC9tMzJyL2NvbmZpZ3MvbTMyNzAwdXQuc21wX2RlZmNvbmZpZwppbmRleCA4MTZjM2VjLi5hM2Q3MjdlIDEwMDY0NAotLS0gYS9hcmNoL20zMnIvY29uZmlncy9tMzI3MDB1dC5zbXBfZGVmY29uZmlnCisrKyBiL2FyY2gvbTMyci9jb25maWdzL20zMjcwMHV0LnNtcF9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfSUtDT05GSUdfUFJPQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfRlVURVggaXMgbm90IHNldAogIyBDT05GSUdfRVBPTEwgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL2NvbmZpZ3MvbTMyNzAwdXQudXBfZGVmY29uZmlnIGIvYXJjaC9tMzJyL2NvbmZpZ3MvbTMyNzAwdXQudXBfZGVmY29uZmlnCmluZGV4IDg0Nzg1NjguLmI4MzM0MTYgMTAwNjQ0Ci0tLSBhL2FyY2gvbTMyci9jb25maWdzL20zMjcwMHV0LnVwX2RlZmNvbmZpZworKysgYi9hcmNoL20zMnIvY29uZmlncy9tMzI3MDB1dC51cF9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfSUtDT05GSUdfUFJPQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfRlVURVggaXMgbm90IHNldAogIyBDT05GSUdfRVBPTEwgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL2NvbmZpZ3MvbWFwcGkubm9tbXVfZGVmY29uZmlnIGIvYXJjaC9tMzJyL2NvbmZpZ3MvbWFwcGkubm9tbXVfZGVmY29uZmlnCmluZGV4IDM1NGE5NjQuLjdjOTBjZTIgMTAwNjQ0Ci0tLSBhL2FyY2gvbTMyci9jb25maWdzL21hcHBpLm5vbW11X2RlZmNvbmZpZworKysgYi9hcmNoL20zMnIvY29uZmlncy9tYXBwaS5ub21tdV9kZWZjb25maWcKQEAgLTMsNyArMyw3IEBACiBDT05GSUdfSUtDT05GSUc9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX0ZVVEVYIGlzIG5vdCBzZXQKICMgQ09ORklHX0VQT0xMIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvbTMyci9jb25maWdzL21hcHBpLnNtcF9kZWZjb25maWcgYi9hcmNoL20zMnIvY29uZmlncy9tYXBwaS5zbXBfZGVmY29uZmlnCmluZGV4IDkwMjIzMDcuLjM2N2QwN2MgMTAwNjQ0Ci0tLSBhL2FyY2gvbTMyci9jb25maWdzL21hcHBpLnNtcF9kZWZjb25maWcKKysrIGIvYXJjaC9tMzJyL2NvbmZpZ3MvbWFwcGkuc21wX2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE1CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfRlVURVggaXMgbm90IHNldAogIyBDT05GSUdfRVBPTEwgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL2NvbmZpZ3MvbWFwcGkudXBfZGVmY29uZmlnIGIvYXJjaC9tMzJyL2NvbmZpZ3MvbWFwcGkudXBfZGVmY29uZmlnCmluZGV4IDM3MjYwNjguLmNiMTEzODQgMTAwNjQ0Ci0tLSBhL2FyY2gvbTMyci9jb25maWdzL21hcHBpLnVwX2RlZmNvbmZpZworKysgYi9hcmNoL20zMnIvY29uZmlncy9tYXBwaS51cF9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX0ZVVEVYIGlzIG5vdCBzZXQKICMgQ09ORklHX0VQT0xMIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvbTMyci9jb25maWdzL21hcHBpMi5vcHNwX2RlZmNvbmZpZyBiL2FyY2gvbTMyci9jb25maWdzL21hcHBpMi5vcHNwX2RlZmNvbmZpZwppbmRleCA2MTM2ZmFkLi4zYmZmNzc5IDEwMDY0NAotLS0gYS9hcmNoL20zMnIvY29uZmlncy9tYXBwaTIub3BzcF9kZWZjb25maWcKKysrIGIvYXJjaC9tMzJyL2NvbmZpZ3MvbWFwcGkyLm9wc3BfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX0lLQ09ORklHPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19GVVRFWCBpcyBub3Qgc2V0CiAjIENPTkZJR19FUE9MTCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL20zMnIvY29uZmlncy9tYXBwaTIudmRlYzJfZGVmY29uZmlnIGIvYXJjaC9tMzJyL2NvbmZpZ3MvbWFwcGkyLnZkZWMyX2RlZmNvbmZpZwppbmRleCBkY2UxZmM3Li43NTI0NmM5IDEwMDY0NAotLS0gYS9hcmNoL20zMnIvY29uZmlncy9tYXBwaTIudmRlYzJfZGVmY29uZmlnCisrKyBiL2FyY2gvbTMyci9jb25maWdzL21hcHBpMi52ZGVjMl9kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfSUtDT05GSUc9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX0ZVVEVYIGlzIG5vdCBzZXQKICMgQ09ORklHX0VQT0xMIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvbTMyci9jb25maWdzL21hcHBpMy5zbXBfZGVmY29uZmlnIGIvYXJjaC9tMzJyL2NvbmZpZ3MvbWFwcGkzLnNtcF9kZWZjb25maWcKaW5kZXggYjIwNGUyZS4uMjdjZWZkNCAxMDA2NDQKLS0tIGEvYXJjaC9tMzJyL2NvbmZpZ3MvbWFwcGkzLnNtcF9kZWZjb25maWcKKysrIGIvYXJjaC9tMzJyL2NvbmZpZ3MvbWFwcGkzLnNtcF9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNQogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX0ZVVEVYIGlzIG5vdCBzZXQKICMgQ09ORklHX0VQT0xMIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvbTMyci9jb25maWdzL29ha3MzMnJfZGVmY29uZmlnIGIvYXJjaC9tMzJyL2NvbmZpZ3Mvb2FrczMycl9kZWZjb25maWcKaW5kZXggNWFhNGVhOS4uNTA4N2E1MSAxMDA2NDQKLS0tIGEvYXJjaC9tMzJyL2NvbmZpZ3Mvb2FrczMycl9kZWZjb25maWcKKysrIGIvYXJjaC9tMzJyL2NvbmZpZ3Mvb2FrczMycl9kZWZjb25maWcKQEAgLTIsNyArMiw3IEBACiBDT05GSUdfQlNEX1BST0NFU1NfQUNDVD15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfRlVURVggaXMgbm90IHNldAogIyBDT05GSUdfRVBPTEwgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL2NvbmZpZ3Mvb3BzcHV0X2RlZmNvbmZpZyBiL2FyY2gvbTMyci9jb25maWdzL29wc3B1dF9kZWZjb25maWcKaW5kZXggODQ5NGM2YS4uNTBjNmY1MiAxMDA2NDQKLS0tIGEvYXJjaC9tMzJyL2NvbmZpZ3Mvb3BzcHV0X2RlZmNvbmZpZworKysgYi9hcmNoL20zMnIvY29uZmlncy9vcHNwdXRfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX0lLQ09ORklHPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19GVVRFWCBpcyBub3Qgc2V0CiAjIENPTkZJR19FUE9MTCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL20zMnIvY29uZmlncy91c3J2X2RlZmNvbmZpZyBiL2FyY2gvbTMyci9jb25maWdzL3VzcnZfZGVmY29uZmlnCmluZGV4IDFkZjI5M2IuLmEzY2ZhYWUgMTAwNjQ0Ci0tLSBhL2FyY2gvbTMyci9jb25maWdzL3VzcnZfZGVmY29uZmlnCisrKyBiL2FyY2gvbTMyci9jb25maWdzL3VzcnZfZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTUKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfRVhUUkFfUEFTUz15CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL20zMnIva2VybmVsL2lycS5jIGIvYXJjaC9tMzJyL2tlcm5lbC9pcnEuYwppbmRleCA3ZGIyNmYxLi43NmVhZjM4IDEwMDY0NAotLS0gYS9hcmNoL20zMnIva2VybmVsL2lycS5jCisrKyBiL2FyY2gvbTMyci9rZXJuZWwvaXJxLmMKQEAgLTQwLDggKzQwLDEwIEBACiAJfQogCiAJaWYgKGkgPCBOUl9JUlFTKSB7Ci0JCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmaXJxX2Rlc2NbaV0ubG9jaywgZmxhZ3MpOwotCQlhY3Rpb24gPSBpcnFfZGVzY1tpXS5hY3Rpb247CisJCXN0cnVjdCBpcnFfZGVzYyAqZGVzYyA9IGlycV90b19kZXNjKGkpOworCisJCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmZGVzYy0+bG9jaywgZmxhZ3MpOworCQlhY3Rpb24gPSBkZXNjLT5hY3Rpb247CiAJCWlmICghYWN0aW9uKQogCQkJZ290byBza2lwOwogCQlzZXFfcHJpbnRmKHAsICIlM2Q6ICIsaSk7CkBAIC01MSw3ICs1Myw3IEBACiAJCWZvcl9lYWNoX29ubGluZV9jcHUoaikKIAkJCXNlcV9wcmludGYocCwgIiUxMHUgIiwga3N0YXRfaXJxc19jcHUoaSwgaikpOwogI2VuZGlmCi0JCXNlcV9wcmludGYocCwgIiAlMTRzIiwgaXJxX2Rlc2NbaV0uY2hpcC0+bmFtZSk7CisJCXNlcV9wcmludGYocCwgIiAlMTRzIiwgZGVzYy0+aXJxX2RhdGEuY2hpcC0+bmFtZSk7CiAJCXNlcV9wcmludGYocCwgIiAgJXMiLCBhY3Rpb24tPm5hbWUpOwogCiAJCWZvciAoYWN0aW9uPWFjdGlvbi0+bmV4dDsgYWN0aW9uOyBhY3Rpb24gPSBhY3Rpb24tPm5leHQpCkBAIC01OSw3ICs2MSw3IEBACiAKIAkJc2VxX3B1dGMocCwgJ1xuJyk7CiBza2lwOgotCQlyYXdfc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaXJxX2Rlc2NbaV0ubG9jaywgZmxhZ3MpOworCQlyYXdfc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGVzYy0+bG9jaywgZmxhZ3MpOwogCX0KIAlyZXR1cm4gMDsKIH0KQEAgLTc4LDcgKzgwLDcgQEAKICNpZmRlZiBDT05GSUdfREVCVUdfU1RBQ0tPVkVSRkxPVwogCS8qIEZJWE1FIE0zMlIgKi8KICNlbmRpZgotCV9fZG9fSVJRKGlycSk7CisJZ2VuZXJpY19oYW5kbGVfaXJxKGlycSk7CiAJaXJxX2V4aXQoKTsKIAlzZXRfaXJxX3JlZ3Mob2xkX3JlZ3MpOwogCmRpZmYgLS1naXQgYS9hcmNoL20zMnIvcGxhdGZvcm1zL20zMjEwNHV0L3NldHVwLmMgYi9hcmNoL20zMnIvcGxhdGZvcm1zL20zMjEwNHV0L3NldHVwLmMKaW5kZXggNDAyYTU5ZC4uNGE2OTNkMCAxMDA2NDQKLS0tIGEvYXJjaC9tMzJyL3BsYXRmb3Jtcy9tMzIxMDR1dC9zZXR1cC5jCisrKyBiL2FyY2gvbTMyci9wbGF0Zm9ybXMvbTMyMTA0dXQvc2V0dXAuYwpAQCAtMzksMzkgKzM5LDMwIEBACiAJb3V0bChkYXRhLCBwb3J0KTsKIH0KIAotc3RhdGljIHZvaWQgbWFza19hbmRfYWNrX20zMjEwNHV0KHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBtYXNrX20zMjEwNHV0X2lycShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZGlzYWJsZV9tMzIxMDR1dF9pcnEoaXJxKTsKKwlkaXNhYmxlX20zMjEwNHV0X2lycShkYXRhLT5pcnEpOwogfQogCi1zdGF0aWMgdm9pZCBlbmRfbTMyMTA0dXRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB1bm1hc2tfbTMyMTA0dXRfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQllbmFibGVfbTMyMTA0dXRfaXJxKGlycSk7CisJZW5hYmxlX20zMjEwNHV0X2lycShkYXRhLT5pcnEpOwogfQogCi1zdGF0aWMgdW5zaWduZWQgaW50IHN0YXJ0dXBfbTMyMTA0dXRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzaHV0ZG93bl9tMzIxMDR1dF9pcnEoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCWVuYWJsZV9tMzIxMDR1dF9pcnEoaXJxKTsKLQlyZXR1cm4gKDApOwotfQorCXVuc2lnbmVkIGludCBpcnEgPSBkYXRhLT5pcnE7CisJdW5zaWduZWQgbG9uZyBwb3J0ID0gaXJxMnBvcnQoaXJxKTsKIAotc3RhdGljIHZvaWQgc2h1dGRvd25fbTMyMTA0dXRfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JdW5zaWduZWQgbG9uZyBwb3J0OwotCi0JcG9ydCA9IGlycTJwb3J0KGlycSk7CiAJb3V0bChNMzJSX0lDVUNSX0lMRVZFTDcsIHBvcnQpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG0zMjEwNHV0X2lycV90eXBlID0KIHsKLQkubmFtZSA9ICJNMzIxMDRVVC1JUlEiLAotCS5zdGFydHVwID0gc3RhcnR1cF9tMzIxMDR1dF9pcnEsCi0JLnNodXRkb3duID0gc2h1dGRvd25fbTMyMTA0dXRfaXJxLAotCS5lbmFibGUgPSBlbmFibGVfbTMyMTA0dXRfaXJxLAotCS5kaXNhYmxlID0gZGlzYWJsZV9tMzIxMDR1dF9pcnEsCi0JLmFjayA9IG1hc2tfYW5kX2Fja19tMzIxMDR1dCwKLQkuZW5kID0gZW5kX20zMjEwNHV0X2lycQorCS5uYW1lCQk9ICJNMzIxMDRVVC1JUlEiLAorCS5pcnFfc2h1dGRvd24JPSBzaHV0ZG93bl9tMzIxMDR1dF9pcnEsCisJLmlycV91bm1hc2sJPSB1bm1hc2tfbTMyMTA0dXRfaXJxLAorCS5pcnFfbWFzawk9IG1hc2tfbTMyMTA0dXRfaXJxLAogfTsKIAogdm9pZCBfX2luaXQgaW5pdF9JUlEodm9pZCkKQEAgLTg1LDM2ICs3NiwyOSBAQAogCiAjaWYgZGVmaW5lZChDT05GSUdfU01DOTFYKQogCS8qIElOVCMwOiBMQU4gY29udHJvbGxlciBvbiBNMzIxMDRVVC1MQU4gKFNNQzkxQzExMSkqLwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDBdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQwXS5jaGlwID0gJm0zMjEwNHV0X2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDBdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UMF0uZGVwdGggPSAxOwotCWljdV9kYXRhW00zMlJfSVJRX0lOVDBdLmljdWNyID0gTTMyUl9JQ1VDUl9JRU4gfCBNMzJSX0lDVUNSX0lTTU9EMTE7IC8qICJIIiBsZXZlbCBzZW5zZSAqLworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9JTlQwLCAmbTMyMTA0dXRfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOworCS8qICJIIiBsZXZlbCBzZW5zZSAqLworCWN1X2RhdGFbTTMyUl9JUlFfSU5UMF0uaWN1Y3IgPSBNMzJSX0lDVUNSX0lFTiB8IE0zMlJfSUNVQ1JfSVNNT0QxMTsKIAlkaXNhYmxlX20zMjEwNHV0X2lycShNMzJSX0lSUV9JTlQwKTsKICNlbmRpZiAgLyogQ09ORklHX1NNQzkxWCAqLwogCiAJLyogTUZUMiA6IHN5c3RlbSB0aW1lciAqLwotCWlycV9kZXNjW00zMlJfSVJRX01GVDJdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9NRlQyXS5jaGlwID0gJm0zMjEwNHV0X2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX01GVDJdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfTUZUMl0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9NRlQyLCAmbTMyMTA0dXRfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX01GVDJdLmljdWNyID0gTTMyUl9JQ1VDUl9JRU47CiAJZGlzYWJsZV9tMzIxMDR1dF9pcnEoTTMyUl9JUlFfTUZUMik7CiAKICNpZmRlZiBDT05GSUdfU0VSSUFMX00zMlJfU0lPCiAJLyogU0lPMF9SIDogdWFydCByZWNlaXZlIGRhdGEgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1JdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1JdLmNoaXAgPSAmbTMyMTA0dXRfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfUl0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9TSU8wX1IsICZtMzIxMDR1dF9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfU0lPMF9SXS5pY3VjciA9IE0zMlJfSUNVQ1JfSUVOOwogCWRpc2FibGVfbTMyMTA0dXRfaXJxKE0zMlJfSVJRX1NJTzBfUik7CiAKIAkvKiBTSU8wX1MgOiB1YXJ0IHNlbmQgZGF0YSAqLwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uY2hpcCA9ICZtMzIxMDR1dF9pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1NdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9TXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX1NJTzBfUywgJm0zMjEwNHV0X2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9TSU8wX1NdLmljdWNyID0gTTMyUl9JQ1VDUl9JRU47CiAJZGlzYWJsZV9tMzIxMDR1dF9pcnEoTTMyUl9JUlFfU0lPMF9TKTsKICNlbmRpZiAvKiBDT05GSUdfU0VSSUFMX00zMlJfU0lPICovCmRpZmYgLS1naXQgYS9hcmNoL20zMnIvcGxhdGZvcm1zL20zMjcwMHV0L3NldHVwLmMgYi9hcmNoL20zMnIvcGxhdGZvcm1zL20zMjcwMHV0L3NldHVwLmMKaW5kZXggODBiMWEwMi4uMjA3NGJjYyAxMDA2NDQKLS0tIGEvYXJjaC9tMzJyL3BsYXRmb3Jtcy9tMzI3MDB1dC9zZXR1cC5jCisrKyBiL2FyY2gvbTMyci9wbGF0Zm9ybXMvbTMyNzAwdXQvc2V0dXAuYwpAQCAtNDUsMzkgKzQ1LDMwIEBACiAJb3V0bChkYXRhLCBwb3J0KTsKIH0KIAotc3RhdGljIHZvaWQgbWFza19hbmRfYWNrX20zMjcwMHV0KHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBtYXNrX20zMjcwMHV0KHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlkaXNhYmxlX20zMjcwMHV0X2lycShpcnEpOworCWRpc2FibGVfbTMyNzAwdXRfaXJxKGRhdGEtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIGVuZF9tMzI3MDB1dF9pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHVubWFza19tMzI3MDB1dChzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZW5hYmxlX20zMjcwMHV0X2lycShpcnEpOworCWVuYWJsZV9tMzI3MDB1dF9pcnEoZGF0YS0+aXJxKTsKIH0KIAotc3RhdGljIHVuc2lnbmVkIGludCBzdGFydHVwX20zMjcwMHV0X2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWVuYWJsZV9tMzI3MDB1dF9pcnEoaXJxKTsKLQlyZXR1cm4gKDApOwotfQotCi1zdGF0aWMgdm9pZCBzaHV0ZG93bl9tMzI3MDB1dF9pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHNodXRkb3duX20zMjcwMHV0KHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1bnNpZ25lZCBsb25nIHBvcnQ7CiAKLQlwb3J0ID0gaXJxMnBvcnQoaXJxKTsKKwlwb3J0ID0gaXJxMnBvcnQoZGF0YS0+aXJxKTsKIAlvdXRsKE0zMlJfSUNVQ1JfSUxFVkVMNywgcG9ydCk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbTMyNzAwdXRfaXJxX3R5cGUgPQogewotCS5uYW1lID0gIk0zMjcwMFVULUlSUSIsCi0JLnN0YXJ0dXAgPSBzdGFydHVwX20zMjcwMHV0X2lycSwKLQkuc2h1dGRvd24gPSBzaHV0ZG93bl9tMzI3MDB1dF9pcnEsCi0JLmVuYWJsZSA9IGVuYWJsZV9tMzI3MDB1dF9pcnEsCi0JLmRpc2FibGUgPSBkaXNhYmxlX20zMjcwMHV0X2lycSwKLQkuYWNrID0gbWFza19hbmRfYWNrX20zMjcwMHV0LAotCS5lbmQgPSBlbmRfbTMyNzAwdXRfaXJxCisJLm5hbWUJCT0gIk0zMjcwMFVULUlSUSIsCisJLmlycV9zaHV0ZG93bgk9IHNodXRkb3duX20zMjcwMHV0LAorCS5pcnFfbWFzawk9IG1hc2tfbTMyNzAwdXQsCisJLmlycV91bm1hc2sJPSB1bm1hc2tfbTMyNzAwdXQKIH07CiAKIC8qCkBAIC05OSw3ICs5MCw2IEBACiAJdW5zaWduZWQgaW50IHBsZGlycTsKIAogCXBsZGlycSA9IGlycTJwbGRpcnEoaXJxKTsKLS8vCWRpc2FibGVfbTMyNzAwdXRfaXJxKE0zMlJfSVJRX0lOVDEpOwogCXBvcnQgPSBwbGRpcnEycG9ydChwbGRpcnEpOwogCWRhdGEgPSBwbGRfaWN1X2RhdGFbcGxkaXJxXS5pY3VjcnxQTERfSUNVQ1JfSUxFVkVMNzsKIAlvdXR3KGRhdGEsIHBvcnQpOwpAQCAtMTExLDUwICsxMDEsMzggQEAKIAl1bnNpZ25lZCBpbnQgcGxkaXJxOwogCiAJcGxkaXJxID0gaXJxMnBsZGlycShpcnEpOwotLy8JZW5hYmxlX20zMjcwMHV0X2lycShNMzJSX0lSUV9JTlQxKTsKIAlwb3J0ID0gcGxkaXJxMnBvcnQocGxkaXJxKTsKIAlkYXRhID0gcGxkX2ljdV9kYXRhW3BsZGlycV0uaWN1Y3J8UExEX0lDVUNSX0lFTnxQTERfSUNVQ1JfSUxFVkVMNjsKIAlvdXR3KGRhdGEsIHBvcnQpOwogfQogCi1zdGF0aWMgdm9pZCBtYXNrX2FuZF9hY2tfbTMyNzAwdXRfcGxkKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBtYXNrX20zMjcwMHV0X3BsZChzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZGlzYWJsZV9tMzI3MDB1dF9wbGRfaXJxKGlycSk7Ci0vLwltYXNrX2FuZF9hY2tfbTMyNzAwdXQoTTMyUl9JUlFfSU5UMSk7CisJZGlzYWJsZV9tMzI3MDB1dF9wbGRfaXJxKGRhdGEtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIGVuZF9tMzI3MDB1dF9wbGRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB1bm1hc2tfbTMyNzAwdXRfcGxkKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQllbmFibGVfbTMyNzAwdXRfcGxkX2lycShpcnEpOwotCWVuZF9tMzI3MDB1dF9pcnEoTTMyUl9JUlFfSU5UMSk7CisJZW5hYmxlX20zMjcwMHV0X3BsZF9pcnEoZGF0YS0+aXJxKTsKKwllbmFibGVfbTMyNzAwdXRfaXJxKE0zMlJfSVJRX0lOVDEpOwogfQogCi1zdGF0aWMgdW5zaWduZWQgaW50IHN0YXJ0dXBfbTMyNzAwdXRfcGxkX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWVuYWJsZV9tMzI3MDB1dF9wbGRfaXJxKGlycSk7Ci0JcmV0dXJuICgwKTsKLX0KLQotc3RhdGljIHZvaWQgc2h1dGRvd25fbTMyNzAwdXRfcGxkX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc2h1dGRvd25fbTMyNzAwdXRfcGxkX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7CiAJdW5zaWduZWQgbG9uZyBwb3J0OwogCXVuc2lnbmVkIGludCBwbGRpcnE7CiAKLQlwbGRpcnEgPSBpcnEycGxkaXJxKGlycSk7Ci0vLwlzaHV0ZG93bl9tMzI3MDB1dF9pcnEoTTMyUl9JUlFfSU5UMSk7CisJcGxkaXJxID0gaXJxMnBsZGlycShkYXRhLT5pcnEpOwogCXBvcnQgPSBwbGRpcnEycG9ydChwbGRpcnEpOwogCW91dHcoUExEX0lDVUNSX0lMRVZFTDcsIHBvcnQpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG0zMjcwMHV0X3BsZF9pcnFfdHlwZSA9CiB7Ci0JLm5hbWUgPSAiTTMyNzAwVVQtUExELUlSUSIsCi0JLnN0YXJ0dXAgPSBzdGFydHVwX20zMjcwMHV0X3BsZF9pcnEsCi0JLnNodXRkb3duID0gc2h1dGRvd25fbTMyNzAwdXRfcGxkX2lycSwKLQkuZW5hYmxlID0gZW5hYmxlX20zMjcwMHV0X3BsZF9pcnEsCi0JLmRpc2FibGUgPSBkaXNhYmxlX20zMjcwMHV0X3BsZF9pcnEsCi0JLmFjayA9IG1hc2tfYW5kX2Fja19tMzI3MDB1dF9wbGQsCi0JLmVuZCA9IGVuZF9tMzI3MDB1dF9wbGRfaXJxCisJLm5hbWUJCT0gIk0zMjcwMFVULVBMRC1JUlEiLAorCS5pcnFfc2h1dGRvd24JPSBzaHV0ZG93bl9tMzI3MDB1dF9wbGRfaXJxLAorCS5pcnFfbWFzawk9IG1hc2tfbTMyNzAwdXRfcGxkLAorCS5pcnFfdW5tYXNrCT0gdW5tYXNrX20zMjcwMHV0X3BsZCwKIH07CiAKIC8qCkBAIC0xODgsNDIgKzE2NiwzMyBAQAogCW91dHcoZGF0YSwgcG9ydCk7CiB9CiAKLXN0YXRpYyB2b2lkIG1hc2tfYW5kX2Fja19tMzI3MDB1dF9sYW5wbGQodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1hc2tfbTMyNzAwdXRfbGFucGxkKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlkaXNhYmxlX20zMjcwMHV0X2xhbnBsZF9pcnEoaXJxKTsKKwlkaXNhYmxlX20zMjcwMHV0X2xhbnBsZF9pcnEoZGF0YS0+aXJxKTsKIH0KIAotc3RhdGljIHZvaWQgZW5kX20zMjcwMHV0X2xhbnBsZF9pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHVubWFza19tMzI3MDB1dF9sYW5wbGQoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCWVuYWJsZV9tMzI3MDB1dF9sYW5wbGRfaXJxKGlycSk7Ci0JZW5kX20zMjcwMHV0X2lycShNMzJSX0lSUV9JTlQwKTsKKwllbmFibGVfbTMyNzAwdXRfbGFucGxkX2lycShkYXRhLT5pcnEpOworCWVuYWJsZV9tMzI3MDB1dF9pcnEoTTMyUl9JUlFfSU5UMCk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQgc3RhcnR1cF9tMzI3MDB1dF9sYW5wbGRfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JZW5hYmxlX20zMjcwMHV0X2xhbnBsZF9pcnEoaXJxKTsKLQlyZXR1cm4gKDApOwotfQotCi1zdGF0aWMgdm9pZCBzaHV0ZG93bl9tMzI3MDB1dF9sYW5wbGRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzaHV0ZG93bl9tMzI3MDB1dF9sYW5wbGQoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewogCXVuc2lnbmVkIGxvbmcgcG9ydDsKIAl1bnNpZ25lZCBpbnQgcGxkaXJxOwogCi0JcGxkaXJxID0gaXJxMmxhbnBsZGlycShpcnEpOworCXBsZGlycSA9IGlycTJsYW5wbGRpcnEoZGF0YS0+aXJxKTsKIAlwb3J0ID0gbGFucGxkaXJxMnBvcnQocGxkaXJxKTsKIAlvdXR3KFBMRF9JQ1VDUl9JTEVWRUw3LCBwb3J0KTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBtMzI3MDB1dF9sYW5wbGRfaXJxX3R5cGUgPQogewotCS5uYW1lID0gIk0zMjcwMFVULVBMRC1MQU4tSVJRIiwKLQkuc3RhcnR1cCA9IHN0YXJ0dXBfbTMyNzAwdXRfbGFucGxkX2lycSwKLQkuc2h1dGRvd24gPSBzaHV0ZG93bl9tMzI3MDB1dF9sYW5wbGRfaXJxLAotCS5lbmFibGUgPSBlbmFibGVfbTMyNzAwdXRfbGFucGxkX2lycSwKLQkuZGlzYWJsZSA9IGRpc2FibGVfbTMyNzAwdXRfbGFucGxkX2lycSwKLQkuYWNrID0gbWFza19hbmRfYWNrX20zMjcwMHV0X2xhbnBsZCwKLQkuZW5kID0gZW5kX20zMjcwMHV0X2xhbnBsZF9pcnEKKwkubmFtZQkJPSAiTTMyNzAwVVQtUExELUxBTi1JUlEiLAorCS5pcnFfc2h1dGRvd24JPSBzaHV0ZG93bl9tMzI3MDB1dF9sYW5wbGQsCisJLmlycV9tYXNrCT0gbWFza19tMzI3MDB1dF9sYW5wbGQsCisJLmlycV91bm1hc2sJPSB1bm1hc2tfbTMyNzAwdXRfbGFucGxkLAogfTsKIAogLyoKQEAgLTI1NywxNDMgKzIyNiwxMTAgQEAKIAlvdXR3KGRhdGEsIHBvcnQpOwogfQogCi1zdGF0aWMgdm9pZCBtYXNrX2FuZF9hY2tfbTMyNzAwdXRfbGNkcGxkKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBtYXNrX20zMjcwMHV0X2xjZHBsZChzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZGlzYWJsZV9tMzI3MDB1dF9sY2RwbGRfaXJxKGlycSk7CisJZGlzYWJsZV9tMzI3MDB1dF9sY2RwbGRfaXJxKGRhdGEtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIGVuZF9tMzI3MDB1dF9sY2RwbGRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB1bm1hc2tfbTMyNzAwdXRfbGNkcGxkKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQllbmFibGVfbTMyNzAwdXRfbGNkcGxkX2lycShpcnEpOwotCWVuZF9tMzI3MDB1dF9pcnEoTTMyUl9JUlFfSU5UMik7CisJZW5hYmxlX20zMjcwMHV0X2xjZHBsZF9pcnEoZGF0YS0+aXJxKTsKKwllbmFibGVfbTMyNzAwdXRfaXJxKE0zMlJfSVJRX0lOVDIpOwogfQogCi1zdGF0aWMgdW5zaWduZWQgaW50IHN0YXJ0dXBfbTMyNzAwdXRfbGNkcGxkX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWVuYWJsZV9tMzI3MDB1dF9sY2RwbGRfaXJxKGlycSk7Ci0JcmV0dXJuICgwKTsKLX0KLQotc3RhdGljIHZvaWQgc2h1dGRvd25fbTMyNzAwdXRfbGNkcGxkX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc2h1dGRvd25fbTMyNzAwdXRfbGNkcGxkKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1bnNpZ25lZCBsb25nIHBvcnQ7CiAJdW5zaWduZWQgaW50IHBsZGlycTsKIAotCXBsZGlycSA9IGlycTJsY2RwbGRpcnEoaXJxKTsKKwlwbGRpcnEgPSBpcnEybGNkcGxkaXJxKGRhdGEtPmlycSk7CiAJcG9ydCA9IGxjZHBsZGlycTJwb3J0KHBsZGlycSk7CiAJb3V0dyhQTERfSUNVQ1JfSUxFVkVMNywgcG9ydCk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbTMyNzAwdXRfbGNkcGxkX2lycV90eXBlID0KIHsKLQkubmFtZSA9ICJNMzI3MDBVVC1QTEQtTENELUlSUSIsCi0JLnN0YXJ0dXAgPSBzdGFydHVwX20zMjcwMHV0X2xjZHBsZF9pcnEsCi0JLnNodXRkb3duID0gc2h1dGRvd25fbTMyNzAwdXRfbGNkcGxkX2lycSwKLQkuZW5hYmxlID0gZW5hYmxlX20zMjcwMHV0X2xjZHBsZF9pcnEsCi0JLmRpc2FibGUgPSBkaXNhYmxlX20zMjcwMHV0X2xjZHBsZF9pcnEsCi0JLmFjayA9IG1hc2tfYW5kX2Fja19tMzI3MDB1dF9sY2RwbGQsCi0JLmVuZCA9IGVuZF9tMzI3MDB1dF9sY2RwbGRfaXJxCisJLm5hbWUJCT0gIk0zMjcwMFVULVBMRC1MQ0QtSVJRIiwKKwkuaXJxX3NodXRkb3duCT0gc2h1dGRvd25fbTMyNzAwdXRfbGNkcGxkLAorCS5pcnFfbWFzawk9IG1hc2tfbTMyNzAwdXRfbGNkcGxkLAorCS5pcnFfdW5tYXNrCT0gdW5tYXNrX20zMjcwMHV0X2xjZHBsZCwKIH07CiAKIHZvaWQgX19pbml0IGluaXRfSVJRKHZvaWQpCiB7CiAjaWYgZGVmaW5lZChDT05GSUdfU01DOTFYKQogCS8qIElOVCMwOiBMQU4gY29udHJvbGxlciBvbiBNMzI3MDBVVC1MQU4gKFNNQzkxQzExMSkqLwotCWlycV9kZXNjW00zMjcwMFVUX0xBTl9JUlFfTEFOXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyNzAwVVRfTEFOX0lSUV9MQU5dLmNoaXAgPSAmbTMyNzAwdXRfbGFucGxkX2lycV90eXBlOwotCWlycV9kZXNjW00zMjcwMFVUX0xBTl9JUlFfTEFOXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMjcwMFVUX0xBTl9JUlFfTEFOXS5kZXB0aCA9IDE7CS8qIGRpc2FibGUgbmVzdGVkIGlycSAqLworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzI3MDBVVF9MQU5fSVJRX0xBTiwKKwkJCQkgJm0zMjcwMHV0X2xhbnBsZF9pcnFfdHlwZSwgaGFuZGxlX2xldmVsX2lycSk7CiAJbGFucGxkX2ljdV9kYXRhW2lycTJsYW5wbGRpcnEoTTMyNzAwVVRfTEFOX0lSUV9MQU4pXS5pY3VjciA9IFBMRF9JQ1VDUl9JRU58UExEX0lDVUNSX0lTTU9EMDI7CS8qICJIIiBlZGdlIHNlbnNlICovCiAJZGlzYWJsZV9tMzI3MDB1dF9sYW5wbGRfaXJxKE0zMjcwMFVUX0xBTl9JUlFfTEFOKTsKICNlbmRpZiAgLyogQ09ORklHX1NNQzkxWCAqLwogCiAJLyogTUZUMiA6IHN5c3RlbSB0aW1lciAqLwotCWlycV9kZXNjW00zMlJfSVJRX01GVDJdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9NRlQyXS5jaGlwID0gJm0zMjcwMHV0X2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX01GVDJdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfTUZUMl0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9NRlQyLCAmbTMyNzAwdXRfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX01GVDJdLmljdWNyID0gTTMyUl9JQ1VDUl9JRU47CiAJZGlzYWJsZV9tMzI3MDB1dF9pcnEoTTMyUl9JUlFfTUZUMik7CiAKIAkvKiBTSU8wIDogcmVjZWl2ZSAqLwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfUl0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfUl0uY2hpcCA9ICZtMzI3MDB1dF9pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1JdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX1NJTzBfUiwgJm0zMjcwMHV0X2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9TSU8wX1JdLmljdWNyID0gMDsKIAlkaXNhYmxlX20zMjcwMHV0X2lycShNMzJSX0lSUV9TSU8wX1IpOwogCiAJLyogU0lPMCA6IHNlbmQgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1NdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1NdLmNoaXAgPSAmbTMyNzAwdXRfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9TXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9TSU8wX1MsICZtMzI3MDB1dF9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfU0lPMF9TXS5pY3VjciA9IDA7CiAJZGlzYWJsZV9tMzI3MDB1dF9pcnEoTTMyUl9JUlFfU0lPMF9TKTsKIAogCS8qIFNJTzEgOiByZWNlaXZlICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9SXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9SXS5jaGlwID0gJm0zMjcwMHV0X2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfUl0uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1JdLmRlcHRoID0gMTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoTTMyUl9JUlFfU0lPMV9SLCAmbTMyNzAwdXRfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX1NJTzFfUl0uaWN1Y3IgPSAwOwogCWRpc2FibGVfbTMyNzAwdXRfaXJxKE0zMlJfSVJRX1NJTzFfUik7CiAKIAkvKiBTSU8xIDogc2VuZCAqLwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfU10uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfU10uY2hpcCA9ICZtMzI3MDB1dF9pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1NdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9TXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX1NJTzFfUywgJm0zMjcwMHV0X2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9TSU8xX1NdLmljdWNyID0gMDsKIAlkaXNhYmxlX20zMjcwMHV0X2lycShNMzJSX0lSUV9TSU8xX1MpOwogCiAJLyogRE1BMSA6ICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfRE1BMV0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX0RNQTFdLmNoaXAgPSAmbTMyNzAwdXRfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfRE1BMV0uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9ETUExXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX0RNQTEsICZtMzI3MDB1dF9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfRE1BMV0uaWN1Y3IgPSAwOwogCWRpc2FibGVfbTMyNzAwdXRfaXJxKE0zMlJfSVJRX0RNQTEpOwogCiAjaWZkZWYgQ09ORklHX1NFUklBTF9NMzJSX1BMRFNJTwogCS8qIElOVCMxOiBTSU8wIFJlY2VpdmUgb24gUExEICovCi0JaXJxX2Rlc2NbUExEX0lSUV9TSU8wX1JDVl0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW1BMRF9JUlFfU0lPMF9SQ1ZdLmNoaXAgPSAmbTMyNzAwdXRfcGxkX2lycV90eXBlOwotCWlycV9kZXNjW1BMRF9JUlFfU0lPMF9SQ1ZdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbUExEX0lSUV9TSU8wX1JDVl0uZGVwdGggPSAxOwkvKiBkaXNhYmxlIG5lc3RlZCBpcnEgKi8KKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoUExEX0lSUV9TSU8wX1JDViwgJm0zMjcwMHV0X3BsZF9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJcGxkX2ljdV9kYXRhW2lycTJwbGRpcnEoUExEX0lSUV9TSU8wX1JDVildLmljdWNyID0gUExEX0lDVUNSX0lFTnxQTERfSUNVQ1JfSVNNT0QwMzsKIAlkaXNhYmxlX20zMjcwMHV0X3BsZF9pcnEoUExEX0lSUV9TSU8wX1JDVik7CiAKIAkvKiBJTlQjMTogU0lPMCBTZW5kIG9uIFBMRCAqLwotCWlycV9kZXNjW1BMRF9JUlFfU0lPMF9TTkRdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tQTERfSVJRX1NJTzBfU05EXS5jaGlwID0gJm0zMjcwMHV0X3BsZF9pcnFfdHlwZTsKLQlpcnFfZGVzY1tQTERfSVJRX1NJTzBfU05EXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW1BMRF9JUlFfU0lPMF9TTkRdLmRlcHRoID0gMTsJLyogZGlzYWJsZSBuZXN0ZWQgaXJxICovCisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKFBMRF9JUlFfU0lPMF9TTkQsICZtMzI3MDB1dF9wbGRfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCXBsZF9pY3VfZGF0YVtpcnEycGxkaXJxKFBMRF9JUlFfU0lPMF9TTkQpXS5pY3VjciA9IFBMRF9JQ1VDUl9JRU58UExEX0lDVUNSX0lTTU9EMDM7CiAJZGlzYWJsZV9tMzI3MDB1dF9wbGRfaXJxKFBMRF9JUlFfU0lPMF9TTkQpOwogI2VuZGlmICAvKiBDT05GSUdfU0VSSUFMX00zMlJfUExEU0lPICovCiAKIAkvKiBJTlQjMTogQ0ZDIElSRVEgb24gUExEICovCi0JaXJxX2Rlc2NbUExEX0lSUV9DRklSRVFdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tQTERfSVJRX0NGSVJFUV0uY2hpcCA9ICZtMzI3MDB1dF9wbGRfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbUExEX0lSUV9DRklSRVFdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbUExEX0lSUV9DRklSRVFdLmRlcHRoID0gMTsJLyogZGlzYWJsZSBuZXN0ZWQgaXJxICovCisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKFBMRF9JUlFfQ0ZJUkVRLCAmbTMyNzAwdXRfcGxkX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlwbGRfaWN1X2RhdGFbaXJxMnBsZGlycShQTERfSVJRX0NGSVJFUSldLmljdWNyID0gUExEX0lDVUNSX0lFTnxQTERfSUNVQ1JfSVNNT0QwMTsJLyogJ0wnIGxldmVsIHNlbnNlICovCiAJZGlzYWJsZV9tMzI3MDB1dF9wbGRfaXJxKFBMRF9JUlFfQ0ZJUkVRKTsKIAogCS8qIElOVCMxOiBDRkMgSW5zZXJ0IG9uIFBMRCAqLwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZDX0lOU0VSVF0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZDX0lOU0VSVF0uY2hpcCA9ICZtMzI3MDB1dF9wbGRfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbUExEX0lSUV9DRkNfSU5TRVJUXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZDX0lOU0VSVF0uZGVwdGggPSAxOwkvKiBkaXNhYmxlIG5lc3RlZCBpcnEgKi8KKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoUExEX0lSUV9DRkNfSU5TRVJULCAmbTMyNzAwdXRfcGxkX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlwbGRfaWN1X2RhdGFbaXJxMnBsZGlycShQTERfSVJRX0NGQ19JTlNFUlQpXS5pY3VjciA9IFBMRF9JQ1VDUl9JRU58UExEX0lDVUNSX0lTTU9EMDA7CS8qICdMJyBlZGdlIHNlbnNlICovCiAJZGlzYWJsZV9tMzI3MDB1dF9wbGRfaXJxKFBMRF9JUlFfQ0ZDX0lOU0VSVCk7CiAKIAkvKiBJTlQjMTogQ0ZDIEVqZWN0IG9uIFBMRCAqLwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZDX0VKRUNUXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbUExEX0lSUV9DRkNfRUpFQ1RdLmNoaXAgPSAmbTMyNzAwdXRfcGxkX2lycV90eXBlOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZDX0VKRUNUXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZDX0VKRUNUXS5kZXB0aCA9IDE7CS8qIGRpc2FibGUgbmVzdGVkIGlycSAqLworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihQTERfSVJRX0NGQ19FSkVDVCwgJm0zMjcwMHV0X3BsZF9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJcGxkX2ljdV9kYXRhW2lycTJwbGRpcnEoUExEX0lSUV9DRkNfRUpFQ1QpXS5pY3VjciA9IFBMRF9JQ1VDUl9JRU58UExEX0lDVUNSX0lTTU9EMDI7CS8qICdIJyBlZGdlIHNlbnNlICovCiAJZGlzYWJsZV9tMzI3MDB1dF9wbGRfaXJxKFBMRF9JUlFfQ0ZDX0VKRUNUKTsKIApAQCAtNDEzLDEzICszNDksMTEgQEAKIAogI2lmIGRlZmluZWQoQ09ORklHX1VTQikKIAlvdXR3KFVTQkNSX09UR1MsIFVTQkNSKTsgCS8qIFVTQkNSOiBub24tT1RHICovCisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMjcwMFVUX0xDRF9JUlFfVVNCX0lOVDEsCisJCQkJICZtMzI3MDB1dF9sY2RwbGRfaXJxX3R5cGUsIGhhbmRsZV9sZXZlbF9pcnEpOwogCi0gICAgaXJxX2Rlc2NbTTMyNzAwVVRfTENEX0lSUV9VU0JfSU5UMV0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotICAgIGlycV9kZXNjW00zMjcwMFVUX0xDRF9JUlFfVVNCX0lOVDFdLmNoaXAgPSAmbTMyNzAwdXRfbGNkcGxkX2lycV90eXBlOwotICAgIGlycV9kZXNjW00zMjcwMFVUX0xDRF9JUlFfVVNCX0lOVDFdLmFjdGlvbiA9IDA7Ci0gICAgaXJxX2Rlc2NbTTMyNzAwVVRfTENEX0lSUV9VU0JfSU5UMV0uZGVwdGggPSAxOwotICAgIGxjZHBsZF9pY3VfZGF0YVtpcnEybGNkcGxkaXJxKE0zMjcwMFVUX0xDRF9JUlFfVVNCX0lOVDEpXS5pY3VjciA9IFBMRF9JQ1VDUl9JRU58UExEX0lDVUNSX0lTTU9EMDE7CS8qICJMIiBsZXZlbCBzZW5zZSAqLwotICAgIGRpc2FibGVfbTMyNzAwdXRfbGNkcGxkX2lycShNMzI3MDBVVF9MQ0RfSVJRX1VTQl9JTlQxKTsKKwlsY2RwbGRfaWN1X2RhdGFbaXJxMmxjZHBsZGlycShNMzI3MDBVVF9MQ0RfSVJRX1VTQl9JTlQxKV0uaWN1Y3IgPSBQTERfSUNVQ1JfSUVOfFBMRF9JQ1VDUl9JU01PRDAxOwkvKiAiTCIgbGV2ZWwgc2Vuc2UgKi8KKwlkaXNhYmxlX20zMjcwMHV0X2xjZHBsZF9pcnEoTTMyNzAwVVRfTENEX0lSUV9VU0JfSU5UMSk7CiAjZW5kaWYKIAkvKgogCSAqIElOVDIjIGlzIHVzZWQgZm9yIEJBVCwgVVNCLCBBVURJTwpAQCAtNDMyLDEwICszNjYsOCBAQAogCS8qCiAJICogSU5UMyMgaXMgdXNlZCBmb3IgQVIKIAkgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQzXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UM10uY2hpcCA9ICZtMzI3MDB1dF9pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQzXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDNdLmRlcHRoID0gMTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoTTMyUl9JUlFfSU5UMywgJm0zMjcwMHV0X2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9JTlQzXS5pY3VjciA9IE0zMlJfSUNVQ1JfSUVOfE0zMlJfSUNVQ1JfSVNNT0QxMDsKIAlkaXNhYmxlX20zMjcwMHV0X2lycShNMzJSX0lSUV9JTlQzKTsKICNlbmRpZgkvKiBDT05GSUdfVklERU9fTTMyUl9BUiAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL3BsYXRmb3Jtcy9tYXBwaS9zZXR1cC5jIGIvYXJjaC9tMzJyL3BsYXRmb3Jtcy9tYXBwaS9zZXR1cC5jCmluZGV4IGVhMDBjODQuLmNkZDhjNDUgMTAwNjQ0Ci0tLSBhL2FyY2gvbTMyci9wbGF0Zm9ybXMvbWFwcGkvc2V0dXAuYworKysgYi9hcmNoL20zMnIvcGxhdGZvcm1zL21hcHBpL3NldHVwLmMKQEAgLTM4LDQwICszOCwzMCBAQAogCW91dGwoZGF0YSwgcG9ydCk7CiB9CiAKLXN0YXRpYyB2b2lkIG1hc2tfYW5kX2Fja19tYXBwaSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbWFza19tYXBwaShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZGlzYWJsZV9tYXBwaV9pcnEoaXJxKTsKKwlkaXNhYmxlX21hcHBpX2lycShkYXRhLT5pcnEpOwogfQogCi1zdGF0aWMgdm9pZCBlbmRfbWFwcGlfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB1bm1hc2tfbWFwcGkoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCWlmICghKGlycV9kZXNjW2lycV0uc3RhdHVzICYgKElSUV9ESVNBQkxFRCB8IElSUV9JTlBST0dSRVNTKSkpCi0JCWVuYWJsZV9tYXBwaV9pcnEoaXJxKTsKKwllbmFibGVfbWFwcGlfaXJxKGRhdGEtPmlycSk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQgc3RhcnR1cF9tYXBwaV9pcnEodW5zaWduZWQgaW50IGlycSkKLXsKLQllbmFibGVfbWFwcGlfaXJxKGlycSk7Ci0JcmV0dXJuICgwKTsKLX0KLQotc3RhdGljIHZvaWQgc2h1dGRvd25fbWFwcGlfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzaHV0ZG93bl9tYXBwaShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7CiAJdW5zaWduZWQgbG9uZyBwb3J0OwogCi0JcG9ydCA9IGlycTJwb3J0KGlycSk7CisJcG9ydCA9IGlycTJwb3J0KGRhdGEtPmlycSk7CiAJb3V0bChNMzJSX0lDVUNSX0lMRVZFTDcsIHBvcnQpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG1hcHBpX2lycV90eXBlID0KIHsKLQkubmFtZSA9ICJNQVBQSS1JUlEiLAotCS5zdGFydHVwID0gc3RhcnR1cF9tYXBwaV9pcnEsCi0JLnNodXRkb3duID0gc2h1dGRvd25fbWFwcGlfaXJxLAotCS5lbmFibGUgPSBlbmFibGVfbWFwcGlfaXJxLAotCS5kaXNhYmxlID0gZGlzYWJsZV9tYXBwaV9pcnEsCi0JLmFjayA9IG1hc2tfYW5kX2Fja19tYXBwaSwKLQkuZW5kID0gZW5kX21hcHBpX2lycQorCS5uYW1lCQk9ICJNQVBQSS1JUlEiLAorCS5pcnFfc2h1dGRvd24JPSBzaHV0ZG93bl9tYXBwaSwKKwkuaXJxX21hc2sJPSBtYXNrX21hcHBpLAorCS5pcnFfdW5tYXNrCT0gdW5tYXNrX21hcHBpLAogfTsKIAogdm9pZCBfX2luaXQgaW5pdF9JUlEodm9pZCkKQEAgLTg1LDcwICs3NSw1NCBAQAogCiAjaWZkZWYgQ09ORklHX05FMjAwMAogCS8qIElOVDAgOiBMQU4gY29udHJvbGxlciAoUlRMODAxOUFTKSAqLwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDBdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQwXS5jaGlwID0gJm1hcHBpX2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDBdLmFjdGlvbiA9IE5VTEw7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UMF0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9JTlQwLCAmbWFwcGlfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX0lOVDBdLmljdWNyID0gTTMyUl9JQ1VDUl9JRU58TTMyUl9JQ1VDUl9JU01PRDExOwogCWRpc2FibGVfbWFwcGlfaXJxKE0zMlJfSVJRX0lOVDApOwogI2VuZGlmIC8qIENPTkZJR19NMzJSX05FMjAwMCAqLwogCiAJLyogTUZUMiA6IHN5c3RlbSB0aW1lciAqLwotCWlycV9kZXNjW00zMlJfSVJRX01GVDJdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9NRlQyXS5jaGlwID0gJm1hcHBpX2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX01GVDJdLmFjdGlvbiA9IE5VTEw7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfTUZUMl0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9NRlQyLCAmbWFwcGlfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX01GVDJdLmljdWNyID0gTTMyUl9JQ1VDUl9JRU47CiAJZGlzYWJsZV9tYXBwaV9pcnEoTTMyUl9JUlFfTUZUMik7CiAKICNpZmRlZiBDT05GSUdfU0VSSUFMX00zMlJfU0lPCiAJLyogU0lPMF9SIDogdWFydCByZWNlaXZlIGRhdGEgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1JdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1JdLmNoaXAgPSAmbWFwcGlfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5hY3Rpb24gPSBOVUxMOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfUl0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9TSU8wX1IsICZtYXBwaV9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfU0lPMF9SXS5pY3VjciA9IDA7CiAJZGlzYWJsZV9tYXBwaV9pcnEoTTMyUl9JUlFfU0lPMF9SKTsKIAogCS8qIFNJTzBfUyA6IHVhcnQgc2VuZCBkYXRhICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9TXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9TXS5jaGlwID0gJm1hcHBpX2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uYWN0aW9uID0gTlVMTDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1NdLmRlcHRoID0gMTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoTTMyUl9JUlFfU0lPMF9TLCAmbWFwcGlfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX1NJTzBfU10uaWN1Y3IgPSAwOwogCWRpc2FibGVfbWFwcGlfaXJxKE0zMlJfSVJRX1NJTzBfUyk7CiAKIAkvKiBTSU8xX1IgOiB1YXJ0IHJlY2VpdmUgZGF0YSAqLwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfUl0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfUl0uY2hpcCA9ICZtYXBwaV9pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1JdLmFjdGlvbiA9IE5VTEw7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9SXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX1NJTzFfUiwgJm1hcHBpX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9TSU8xX1JdLmljdWNyID0gMDsKIAlkaXNhYmxlX21hcHBpX2lycShNMzJSX0lSUV9TSU8xX1IpOwogCiAJLyogU0lPMV9TIDogdWFydCBzZW5kIGRhdGEgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1NdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1NdLmNoaXAgPSAmbWFwcGlfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9TXS5hY3Rpb24gPSBOVUxMOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfU10uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9TSU8xX1MsICZtYXBwaV9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfU0lPMV9TXS5pY3VjciA9IDA7CiAJZGlzYWJsZV9tYXBwaV9pcnEoTTMyUl9JUlFfU0lPMV9TKTsKICNlbmRpZiAvKiBDT05GSUdfU0VSSUFMX00zMlJfU0lPICovCiAKICNpZiBkZWZpbmVkKENPTkZJR19NMzJSX1BDQykKIAkvKiBJTlQxIDogcGNjYXJkMCBpbnRlcnJ1cHQgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQxXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UMV0uY2hpcCA9ICZtYXBwaV9pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQxXS5hY3Rpb24gPSBOVUxMOwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDFdLmRlcHRoID0gMTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoTTMyUl9JUlFfSU5UMSwgJm1hcHBpX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9JTlQxXS5pY3VjciA9IE0zMlJfSUNVQ1JfSUVOIHwgTTMyUl9JQ1VDUl9JU01PRDAwOwogCWRpc2FibGVfbWFwcGlfaXJxKE0zMlJfSVJRX0lOVDEpOwogCiAJLyogSU5UMiA6IHBjY2FyZDEgaW50ZXJydXB0ICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UMl0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDJdLmNoaXAgPSAmbWFwcGlfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UMl0uYWN0aW9uID0gTlVMTDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQyXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX0lOVDIsICZtYXBwaV9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfSU5UMl0uaWN1Y3IgPSBNMzJSX0lDVUNSX0lFTiB8IE0zMlJfSUNVQ1JfSVNNT0QwMDsKIAlkaXNhYmxlX21hcHBpX2lycShNMzJSX0lSUV9JTlQyKTsKICNlbmRpZiAvKiBDT05GSUdfTTMyUlBDQyAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL3BsYXRmb3Jtcy9tYXBwaTIvc2V0dXAuYyBiL2FyY2gvbTMyci9wbGF0Zm9ybXMvbWFwcGkyL3NldHVwLmMKaW5kZXggYzA0OTM3Ni4uOTExN2MzMCAxMDA2NDQKLS0tIGEvYXJjaC9tMzJyL3BsYXRmb3Jtcy9tYXBwaTIvc2V0dXAuYworKysgYi9hcmNoL20zMnIvcGxhdGZvcm1zL21hcHBpMi9zZXR1cC5jCkBAIC00NiwxMjYgKzQ2LDk3IEBACiAJb3V0bChkYXRhLCBwb3J0KTsKIH0KIAotc3RhdGljIHZvaWQgbWFza19hbmRfYWNrX21hcHBpMih1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbWFza19tYXBwaTIoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCWRpc2FibGVfbWFwcGkyX2lycShpcnEpOworCWRpc2FibGVfbWFwcGkyX2lycShkYXRhLT5pcnEpOwogfQogCi1zdGF0aWMgdm9pZCBlbmRfbWFwcGkyX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgdW5tYXNrX21hcHBpMihzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZW5hYmxlX21hcHBpMl9pcnEoaXJxKTsKKwllbmFibGVfbWFwcGkyX2lycShkYXRhLT5pcnEpOwogfQogCi1zdGF0aWMgdW5zaWduZWQgaW50IHN0YXJ0dXBfbWFwcGkyX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWVuYWJsZV9tYXBwaTJfaXJxKGlycSk7Ci0JcmV0dXJuICgwKTsKLX0KLQotc3RhdGljIHZvaWQgc2h1dGRvd25fbWFwcGkyX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc2h1dGRvd25fbWFwcGkyKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1bnNpZ25lZCBsb25nIHBvcnQ7CiAKLQlwb3J0ID0gaXJxMnBvcnQoaXJxKTsKKwlwb3J0ID0gaXJxMnBvcnQoZGF0YS0+aXJxKTsKIAlvdXRsKE0zMlJfSUNVQ1JfSUxFVkVMNywgcG9ydCk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbWFwcGkyX2lycV90eXBlID0KIHsKLQkubmFtZSA9ICJNQVBQSTItSVJRIiwKLQkuc3RhcnR1cCA9IHN0YXJ0dXBfbWFwcGkyX2lycSwKLQkuc2h1dGRvd24gPSBzaHV0ZG93bl9tYXBwaTJfaXJxLAotCS5lbmFibGUgPSBlbmFibGVfbWFwcGkyX2lycSwKLQkuZGlzYWJsZSA9IGRpc2FibGVfbWFwcGkyX2lycSwKLQkuYWNrID0gbWFza19hbmRfYWNrX21hcHBpMiwKLQkuZW5kID0gZW5kX21hcHBpMl9pcnEKKwkubmFtZQkJPSAiTUFQUEkyLUlSUSIsCisJLmlycV9zaHV0ZG93bgk9IHNodXRkb3duX21hcHBpMiwKKwkuaXJxX21hc2sJPSBtYXNrX21hcHBpMiwKKwkuaXJxX3VubWFzawk9IHVubWFza19tYXBwaTIsCiB9OwogCiB2b2lkIF9faW5pdCBpbml0X0lSUSh2b2lkKQogewogI2lmIGRlZmluZWQoQ09ORklHX1NNQzkxWCkKIAkvKiBJTlQwIDogTEFOIGNvbnRyb2xsZXIgKFNNQzkxMTExKSAqLwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDBdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQwXS5jaGlwID0gJm1hcHBpMl9pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQwXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDBdLmRlcHRoID0gMTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoTTMyUl9JUlFfSU5UMCwgJm1hcHBpMl9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfSU5UMF0uaWN1Y3IgPSBNMzJSX0lDVUNSX0lFTnxNMzJSX0lDVUNSX0lTTU9EMTA7CiAJZGlzYWJsZV9tYXBwaTJfaXJxKE0zMlJfSVJRX0lOVDApOwogI2VuZGlmICAvKiBDT05GSUdfU01DOTFYICovCiAKIAkvKiBNRlQyIDogc3lzdGVtIHRpbWVyICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfTUZUMl0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX01GVDJdLmNoaXAgPSAmbWFwcGkyX2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX01GVDJdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfTUZUMl0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9NRlQyLCAmbWFwcGkyX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9NRlQyXS5pY3VjciA9IE0zMlJfSUNVQ1JfSUVOOwogCWRpc2FibGVfbWFwcGkyX2lycShNMzJSX0lSUV9NRlQyKTsKIAogI2lmZGVmIENPTkZJR19TRVJJQUxfTTMyUl9TSU8KIAkvKiBTSU8wX1IgOiB1YXJ0IHJlY2VpdmUgZGF0YSAqLwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfUl0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfUl0uY2hpcCA9ICZtYXBwaTJfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfUl0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9TSU8wX1IsICZtYXBwaTJfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX1NJTzBfUl0uaWN1Y3IgPSAwOwogCWRpc2FibGVfbWFwcGkyX2lycShNMzJSX0lSUV9TSU8wX1IpOwogCiAJLyogU0lPMF9TIDogdWFydCBzZW5kIGRhdGEgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1NdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1NdLmNoaXAgPSAmbWFwcGkyX2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1NdLmRlcHRoID0gMTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoTTMyUl9JUlFfU0lPMF9TLCAmbWFwcGkyX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9TSU8wX1NdLmljdWNyID0gMDsKIAlkaXNhYmxlX21hcHBpMl9pcnEoTTMyUl9JUlFfU0lPMF9TKTsKIAkvKiBTSU8xX1IgOiB1YXJ0IHJlY2VpdmUgZGF0YSAqLwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfUl0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfUl0uY2hpcCA9ICZtYXBwaTJfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9SXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfUl0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9TSU8xX1IsICZtYXBwaTJfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX1NJTzFfUl0uaWN1Y3IgPSAwOwogCWRpc2FibGVfbWFwcGkyX2lycShNMzJSX0lSUV9TSU8xX1IpOwogCiAJLyogU0lPMV9TIDogdWFydCBzZW5kIGRhdGEgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1NdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1NdLmNoaXAgPSAmbWFwcGkyX2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfU10uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1NdLmRlcHRoID0gMTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoTTMyUl9JUlFfU0lPMV9TLCAmbWFwcGkyX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9TSU8xX1NdLmljdWNyID0gMDsKIAlkaXNhYmxlX21hcHBpMl9pcnEoTTMyUl9JUlFfU0lPMV9TKTsKICNlbmRpZiAgLyogQ09ORklHX00zMlJfVVNFX0RCR19DT05TT0xFICovCiAKICNpZiBkZWZpbmVkKENPTkZJR19VU0IpCiAJLyogSU5UMSA6IFVTQiBIb3N0IGNvbnRyb2xsZXIgaW50ZXJydXB0ICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UMV0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDFdLmNoaXAgPSAmbWFwcGkyX2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDFdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UMV0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9JTlQxLCAmbWFwcGkyX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9JTlQxXS5pY3VjciA9IE0zMlJfSUNVQ1JfSVNNT0QwMTsKIAlkaXNhYmxlX21hcHBpMl9pcnEoTTMyUl9JUlFfSU5UMSk7CiAjZW5kaWYgLyogQ09ORklHX1VTQiAqLwogCiAJLyogSUNVQ1I0MDogQ0ZDIElSRVEgKi8KLQlpcnFfZGVzY1tQTERfSVJRX0NGSVJFUV0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZJUkVRXS5jaGlwID0gJm1hcHBpMl9pcnFfdHlwZTsKLQlpcnFfZGVzY1tQTERfSVJRX0NGSVJFUV0uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tQTERfSVJRX0NGSVJFUV0uZGVwdGggPSAxOwkvKiBkaXNhYmxlIG5lc3RlZCBpcnEgKi8KKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoUExEX0lSUV9DRklSRVEsICZtYXBwaTJfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW1BMRF9JUlFfQ0ZJUkVRXS5pY3VjciA9IE0zMlJfSUNVQ1JfSUVOfE0zMlJfSUNVQ1JfSVNNT0QwMTsKIAlkaXNhYmxlX21hcHBpMl9pcnEoUExEX0lSUV9DRklSRVEpOwogCiAjaWYgZGVmaW5lZChDT05GSUdfTTMyUl9DRkMpCiAJLyogSUNVQ1I0MTogQ0ZDIEluc2VydCAqLwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZDX0lOU0VSVF0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZDX0lOU0VSVF0uY2hpcCA9ICZtYXBwaTJfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbUExEX0lSUV9DRkNfSU5TRVJUXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZDX0lOU0VSVF0uZGVwdGggPSAxOwkvKiBkaXNhYmxlIG5lc3RlZCBpcnEgKi8KKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoUExEX0lSUV9DRkNfSU5TRVJULCAmbWFwcGkyX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtQTERfSVJRX0NGQ19JTlNFUlRdLmljdWNyID0gTTMyUl9JQ1VDUl9JRU58TTMyUl9JQ1VDUl9JU01PRDAwOwogCWRpc2FibGVfbWFwcGkyX2lycShQTERfSVJRX0NGQ19JTlNFUlQpOwogCiAJLyogSUNVQ1I0MjogQ0ZDIEVqZWN0ICovCi0JaXJxX2Rlc2NbUExEX0lSUV9DRkNfRUpFQ1RdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tQTERfSVJRX0NGQ19FSkVDVF0uY2hpcCA9ICZtYXBwaTJfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbUExEX0lSUV9DRkNfRUpFQ1RdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbUExEX0lSUV9DRkNfRUpFQ1RdLmRlcHRoID0gMTsJLyogZGlzYWJsZSBuZXN0ZWQgaXJxICovCisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKFBMRF9JUlFfQ0ZDX0VKRUNULCAmbWFwcGkyX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtQTERfSVJRX0NGQ19FSkVDVF0uaWN1Y3IgPSBNMzJSX0lDVUNSX0lFTnxNMzJSX0lDVUNSX0lTTU9EMTA7CiAJZGlzYWJsZV9tYXBwaTJfaXJxKFBMRF9JUlFfQ0ZDX0VKRUNUKTsKICNlbmRpZiAvKiBDT05GSUdfTUFQUEkyX0NGQyAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL3BsYXRmb3Jtcy9tYXBwaTMvc2V0dXAuYyBiL2FyY2gvbTMyci9wbGF0Zm9ybXMvbWFwcGkzL3NldHVwLmMKaW5kZXggODgyZGUyNS4uYjQ0ZjVkZSAxMDA2NDQKLS0tIGEvYXJjaC9tMzJyL3BsYXRmb3Jtcy9tYXBwaTMvc2V0dXAuYworKysgYi9hcmNoL20zMnIvcGxhdGZvcm1zL21hcHBpMy9zZXR1cC5jCkBAIC00NiwxMjggKzQ2LDk4IEBACiAJb3V0bChkYXRhLCBwb3J0KTsKIH0KIAotc3RhdGljIHZvaWQgbWFza19hbmRfYWNrX21hcHBpMyh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbWFza19tYXBwaTMoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCWRpc2FibGVfbWFwcGkzX2lycShpcnEpOworCWRpc2FibGVfbWFwcGkzX2lycShkYXRhLT5pcnEpOwogfQogCi1zdGF0aWMgdm9pZCBlbmRfbWFwcGkzX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgdW5tYXNrX21hcHBpMyhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZW5hYmxlX21hcHBpM19pcnEoaXJxKTsKKwllbmFibGVfbWFwcGkzX2lycShkYXRhLT5pcnEpOwogfQogCi1zdGF0aWMgdW5zaWduZWQgaW50IHN0YXJ0dXBfbWFwcGkzX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWVuYWJsZV9tYXBwaTNfaXJxKGlycSk7Ci0JcmV0dXJuICgwKTsKLX0KLQotc3RhdGljIHZvaWQgc2h1dGRvd25fbWFwcGkzX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc2h1dGRvd25fbWFwcGkzKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1bnNpZ25lZCBsb25nIHBvcnQ7CiAKLQlwb3J0ID0gaXJxMnBvcnQoaXJxKTsKKwlwb3J0ID0gaXJxMnBvcnQoZGF0YS0+aXJxKTsKIAlvdXRsKE0zMlJfSUNVQ1JfSUxFVkVMNywgcG9ydCk7CiB9CiAKLXN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbWFwcGkzX2lycV90eXBlID0KLXsKLQkubmFtZSA9ICJNQVBQSTMtSVJRIiwKLQkuc3RhcnR1cCA9IHN0YXJ0dXBfbWFwcGkzX2lycSwKLQkuc2h1dGRvd24gPSBzaHV0ZG93bl9tYXBwaTNfaXJxLAotCS5lbmFibGUgPSBlbmFibGVfbWFwcGkzX2lycSwKLQkuZGlzYWJsZSA9IGRpc2FibGVfbWFwcGkzX2lycSwKLQkuYWNrID0gbWFza19hbmRfYWNrX21hcHBpMywKLQkuZW5kID0gZW5kX21hcHBpM19pcnEKK3N0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbWFwcGkzX2lycV90eXBlID0geworCS5uYW1lCQk9ICJNQVBQSTMtSVJRIiwKKwkuaXJxX3NodXRkb3duCT0gc2h1dGRvd25fbWFwcGkzLAorCS5pcnFfbWFzawk9IG1hc2tfbWFwcGkzLAorCS5pcnFfdW5tYXNrCT0gdW5tYXNrX21hcHBpMywKIH07CiAKIHZvaWQgX19pbml0IGluaXRfSVJRKHZvaWQpCiB7CiAjaWYgZGVmaW5lZChDT05GSUdfU01DOTFYKQogCS8qIElOVDAgOiBMQU4gY29udHJvbGxlciAoU01DOTExMTEpICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UMF0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDBdLmNoaXAgPSAmbWFwcGkzX2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDBdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UMF0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9JTlQwLCAmbWFwcGkzX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9JTlQwXS5pY3VjciA9IE0zMlJfSUNVQ1JfSUVOfE0zMlJfSUNVQ1JfSVNNT0QxMDsKIAlkaXNhYmxlX21hcHBpM19pcnEoTTMyUl9JUlFfSU5UMCk7CiAjZW5kaWYgIC8qIENPTkZJR19TTUM5MVggKi8KIAogCS8qIE1GVDIgOiBzeXN0ZW0gdGltZXIgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9NRlQyXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfTUZUMl0uY2hpcCA9ICZtYXBwaTNfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfTUZUMl0uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9NRlQyXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX01GVDIsICZtYXBwaTNfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX01GVDJdLmljdWNyID0gTTMyUl9JQ1VDUl9JRU47CiAJZGlzYWJsZV9tYXBwaTNfaXJxKE0zMlJfSVJRX01GVDIpOwogCiAjaWZkZWYgQ09ORklHX1NFUklBTF9NMzJSX1NJTwogCS8qIFNJTzBfUiA6IHVhcnQgcmVjZWl2ZSBkYXRhICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5jaGlwID0gJm1hcHBpM19pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1JdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX1NJTzBfUiwgJm1hcHBpM19pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfU0lPMF9SXS5pY3VjciA9IDA7CiAJZGlzYWJsZV9tYXBwaTNfaXJxKE0zMlJfSVJRX1NJTzBfUik7CiAKIAkvKiBTSU8wX1MgOiB1YXJ0IHNlbmQgZGF0YSAqLwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uY2hpcCA9ICZtYXBwaTNfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9TXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9TSU8wX1MsICZtYXBwaTNfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX1NJTzBfU10uaWN1Y3IgPSAwOwogCWRpc2FibGVfbWFwcGkzX2lycShNMzJSX0lSUV9TSU8wX1MpOwogCS8qIFNJTzFfUiA6IHVhcnQgcmVjZWl2ZSBkYXRhICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9SXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9SXS5jaGlwID0gJm1hcHBpM19pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1JdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9SXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX1NJTzFfUiwgJm1hcHBpM19pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfU0lPMV9SXS5pY3VjciA9IDA7CiAJZGlzYWJsZV9tYXBwaTNfaXJxKE0zMlJfSVJRX1NJTzFfUik7CiAKIAkvKiBTSU8xX1MgOiB1YXJ0IHNlbmQgZGF0YSAqLwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfU10uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfU10uY2hpcCA9ICZtYXBwaTNfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9TXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfU10uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9TSU8xX1MsICZtYXBwaTNfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX1NJTzFfU10uaWN1Y3IgPSAwOwogCWRpc2FibGVfbWFwcGkzX2lycShNMzJSX0lSUV9TSU8xX1MpOwogI2VuZGlmICAvKiBDT05GSUdfTTMyUl9VU0VfREJHX0NPTlNPTEUgKi8KIAogI2lmIGRlZmluZWQoQ09ORklHX1VTQikKIAkvKiBJTlQxIDogVVNCIEhvc3QgY29udHJvbGxlciBpbnRlcnJ1cHQgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQxXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UMV0uY2hpcCA9ICZtYXBwaTNfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UMV0uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQxXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX0lOVDEsICZtYXBwaTNfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX0lOVDFdLmljdWNyID0gTTMyUl9JQ1VDUl9JU01PRDAxOwogCWRpc2FibGVfbWFwcGkzX2lycShNMzJSX0lSUV9JTlQxKTsKICNlbmRpZiAvKiBDT05GSUdfVVNCICovCiAKIAkvKiBDRkMgSVJFUSAqLwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZJUkVRXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbUExEX0lSUV9DRklSRVFdLmNoaXAgPSAmbWFwcGkzX2lycV90eXBlOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZJUkVRXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZJUkVRXS5kZXB0aCA9IDE7CS8qIGRpc2FibGUgbmVzdGVkIGlycSAqLworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihQTERfSVJRX0NGSVJFUSwgJm1hcHBpM19pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbUExEX0lSUV9DRklSRVFdLmljdWNyID0gTTMyUl9JQ1VDUl9JRU58TTMyUl9JQ1VDUl9JU01PRDAxOwogCWRpc2FibGVfbWFwcGkzX2lycShQTERfSVJRX0NGSVJFUSk7CiAKICNpZiBkZWZpbmVkKENPTkZJR19NMzJSX0NGQykKIAkvKiBJQ1VDUjQxOiBDRkMgSW5zZXJ0ICYgZWplY3QgKi8KLQlpcnFfZGVzY1tQTERfSVJRX0NGQ19JTlNFUlRdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tQTERfSVJRX0NGQ19JTlNFUlRdLmNoaXAgPSAmbWFwcGkzX2lycV90eXBlOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZDX0lOU0VSVF0uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tQTERfSVJRX0NGQ19JTlNFUlRdLmRlcHRoID0gMTsJLyogZGlzYWJsZSBuZXN0ZWQgaXJxICovCisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKFBMRF9JUlFfQ0ZDX0lOU0VSVCwgJm1hcHBpM19pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbUExEX0lSUV9DRkNfSU5TRVJUXS5pY3VjciA9IE0zMlJfSUNVQ1JfSUVOfE0zMlJfSUNVQ1JfSVNNT0QwMDsKIAlkaXNhYmxlX21hcHBpM19pcnEoUExEX0lSUV9DRkNfSU5TRVJUKTsKIAogI2VuZGlmIC8qIENPTkZJR19NMzJSX0NGQyAqLwogCiAJLyogSURFIElSRVEgKi8KLQlpcnFfZGVzY1tQTERfSVJRX0lERUlSRVFdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tQTERfSVJRX0lERUlSRVFdLmNoaXAgPSAmbWFwcGkzX2lycV90eXBlOwotCWlycV9kZXNjW1BMRF9JUlFfSURFSVJFUV0uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tQTERfSVJRX0lERUlSRVFdLmRlcHRoID0gMTsJLyogZGlzYWJsZSBuZXN0ZWQgaXJxICovCisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKFBMRF9JUlFfSURFSVJFUSwgJm1hcHBpM19pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbUExEX0lSUV9JREVJUkVRXS5pY3VjciA9IE0zMlJfSUNVQ1JfSUVOfE0zMlJfSUNVQ1JfSVNNT0QxMDsKIAlkaXNhYmxlX21hcHBpM19pcnEoUExEX0lSUV9JREVJUkVRKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL3BsYXRmb3Jtcy9vYWtzMzJyL3NldHVwLmMgYi9hcmNoL20zMnIvcGxhdGZvcm1zL29ha3MzMnIvc2V0dXAuYwppbmRleCBkMTFkOTNiLi4xOWEwMmRiIDEwMDY0NAotLS0gYS9hcmNoL20zMnIvcGxhdGZvcm1zL29ha3MzMnIvc2V0dXAuYworKysgYi9hcmNoL20zMnIvcGxhdGZvcm1zL29ha3MzMnIvc2V0dXAuYwpAQCAtMzcsMzkgKzM3LDMwIEBACiAJb3V0bChkYXRhLCBwb3J0KTsKIH0KIAotc3RhdGljIHZvaWQgbWFza19hbmRfYWNrX21hcHBpKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBtYXNrX29ha3MzMnIoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCWRpc2FibGVfb2FrczMycl9pcnEoaXJxKTsKKwlkaXNhYmxlX29ha3MzMnJfaXJxKGRhdGEtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIGVuZF9vYWtzMzJyX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgdW5tYXNrX29ha3MzMnIoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCWVuYWJsZV9vYWtzMzJyX2lycShpcnEpOworCWVuYWJsZV9vYWtzMzJyX2lycShkYXRhLT5pcnEpOwogfQogCi1zdGF0aWMgdW5zaWduZWQgaW50IHN0YXJ0dXBfb2FrczMycl9pcnEodW5zaWduZWQgaW50IGlycSkKLXsKLQllbmFibGVfb2FrczMycl9pcnEoaXJxKTsKLQlyZXR1cm4gKDApOwotfQotCi1zdGF0aWMgdm9pZCBzaHV0ZG93bl9vYWtzMzJyX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc2h1dGRvd25fb2FrczMycihzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7CiAJdW5zaWduZWQgbG9uZyBwb3J0OwogCi0JcG9ydCA9IGlycTJwb3J0KGlycSk7CisJcG9ydCA9IGlycTJwb3J0KGRhdGEtPmlycSk7CiAJb3V0bChNMzJSX0lDVUNSX0lMRVZFTDcsIHBvcnQpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG9ha3MzMnJfaXJxX3R5cGUgPQogewotCS5uYW1lID0gIk9BS1MzMlItSVJRIiwKLQkuc3RhcnR1cCA9IHN0YXJ0dXBfb2FrczMycl9pcnEsCi0JLnNodXRkb3duID0gc2h1dGRvd25fb2FrczMycl9pcnEsCi0JLmVuYWJsZSA9IGVuYWJsZV9vYWtzMzJyX2lycSwKLQkuZGlzYWJsZSA9IGRpc2FibGVfb2FrczMycl9pcnEsCi0JLmFjayA9IG1hc2tfYW5kX2Fja19tYXBwaSwKLQkuZW5kID0gZW5kX29ha3MzMnJfaXJxCisJLm5hbWUJCT0gIk9BS1MzMlItSVJRIiwKKwkuaXJxX3NodXRkb3duCT0gc2h1dGRvd25fb2FrczMyciwKKwkuaXJxX21hc2sJPSBtYXNrX29ha3MzMnIsCisJLmlycV91bm1hc2sJPSB1bm1hc2tfb2FrczMyciwKIH07CiAKIHZvaWQgX19pbml0IGluaXRfSVJRKHZvaWQpCkBAIC04Myw1MiArNzQsNDAgQEAKIAogI2lmZGVmIENPTkZJR19ORTIwMDAKIAkvKiBJTlQzIDogTEFOIGNvbnRyb2xsZXIgKFJUTDgwMTlBUykgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQzXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UM10uY2hpcCA9ICZvYWtzMzJyX2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX0lOVDNdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UM10uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9JTlQzLCAmb2FrczMycl9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfSU5UM10uaWN1Y3IgPSBNMzJSX0lDVUNSX0lFTnxNMzJSX0lDVUNSX0lTTU9EMTA7CiAJZGlzYWJsZV9vYWtzMzJyX2lycShNMzJSX0lSUV9JTlQzKTsKICNlbmRpZiAvKiBDT05GSUdfTTMyUl9ORTIwMDAgKi8KIAogCS8qIE1GVDIgOiBzeXN0ZW0gdGltZXIgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9NRlQyXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfTUZUMl0uY2hpcCA9ICZvYWtzMzJyX2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX01GVDJdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfTUZUMl0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9NRlQyLCAmb2FrczMycl9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfTUZUMl0uaWN1Y3IgPSBNMzJSX0lDVUNSX0lFTjsKIAlkaXNhYmxlX29ha3MzMnJfaXJxKE0zMlJfSVJRX01GVDIpOwogCiAjaWZkZWYgQ09ORklHX1NFUklBTF9NMzJSX1NJTwogCS8qIFNJTzBfUiA6IHVhcnQgcmVjZWl2ZSBkYXRhICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5jaGlwID0gJm9ha3MzMnJfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfUl0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9TSU8wX1IsICZvYWtzMzJyX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9TSU8wX1JdLmljdWNyID0gMDsKIAlkaXNhYmxlX29ha3MzMnJfaXJxKE0zMlJfSVJRX1NJTzBfUik7CiAKIAkvKiBTSU8wX1MgOiB1YXJ0IHNlbmQgZGF0YSAqLwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uY2hpcCA9ICZvYWtzMzJyX2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1NdLmRlcHRoID0gMTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoTTMyUl9JUlFfU0lPMF9TLCAmb2FrczMycl9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfU0lPMF9TXS5pY3VjciA9IDA7CiAJZGlzYWJsZV9vYWtzMzJyX2lycShNMzJSX0lSUV9TSU8wX1MpOwogCiAJLyogU0lPMV9SIDogdWFydCByZWNlaXZlIGRhdGEgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1JdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1JdLmNoaXAgPSAmb2FrczMycl9pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1JdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9SXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX1NJTzFfUiwgJm9ha3MzMnJfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX1NJTzFfUl0uaWN1Y3IgPSAwOwogCWRpc2FibGVfb2FrczMycl9pcnEoTTMyUl9JUlFfU0lPMV9SKTsKIAogCS8qIFNJTzFfUyA6IHVhcnQgc2VuZCBkYXRhICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9TXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9TXS5jaGlwID0gJm9ha3MzMnJfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9TXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfU10uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9TSU8xX1MsICZvYWtzMzJyX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9TSU8xX1NdLmljdWNyID0gMDsKIAlkaXNhYmxlX29ha3MzMnJfaXJxKE0zMlJfSVJRX1NJTzFfUyk7CiAjZW5kaWYgLyogQ09ORklHX1NFUklBTF9NMzJSX1NJTyAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL3BsYXRmb3Jtcy9vcHNwdXQvc2V0dXAuYyBiL2FyY2gvbTMyci9wbGF0Zm9ybXMvb3BzcHV0L3NldHVwLmMKaW5kZXggNWYzNDAyYS4uMTI3MzE1NCAxMDA2NDQKLS0tIGEvYXJjaC9tMzJyL3BsYXRmb3Jtcy9vcHNwdXQvc2V0dXAuYworKysgYi9hcmNoL20zMnIvcGxhdGZvcm1zL29wc3B1dC9zZXR1cC5jCkBAIC00NiwzOSArNDYsMzAgQEAKIAlvdXRsKGRhdGEsIHBvcnQpOwogfQogCi1zdGF0aWMgdm9pZCBtYXNrX2FuZF9hY2tfb3BzcHV0KHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBtYXNrX29wc3B1dChzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZGlzYWJsZV9vcHNwdXRfaXJxKGlycSk7CisJZGlzYWJsZV9vcHNwdXRfaXJxKGRhdGEtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIGVuZF9vcHNwdXRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB1bm1hc2tfb3BzcHV0KHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQllbmFibGVfb3BzcHV0X2lycShpcnEpOworCWVuYWJsZV9vcHNwdXRfaXJxKGRhdGEtPmlycSk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQgc3RhcnR1cF9vcHNwdXRfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JZW5hYmxlX29wc3B1dF9pcnEoaXJxKTsKLQlyZXR1cm4gKDApOwotfQotCi1zdGF0aWMgdm9pZCBzaHV0ZG93bl9vcHNwdXRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzaHV0ZG93bl9vcHNwdXQoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewogCXVuc2lnbmVkIGxvbmcgcG9ydDsKIAotCXBvcnQgPSBpcnEycG9ydChpcnEpOworCXBvcnQgPSBpcnEycG9ydChkYXRhLT5pcnEpOwogCW91dGwoTTMyUl9JQ1VDUl9JTEVWRUw3LCBwb3J0KTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBvcHNwdXRfaXJxX3R5cGUgPQogewotCS5uYW1lID0gIk9QU1BVVC1JUlEiLAotCS5zdGFydHVwID0gc3RhcnR1cF9vcHNwdXRfaXJxLAotCS5zaHV0ZG93biA9IHNodXRkb3duX29wc3B1dF9pcnEsCi0JLmVuYWJsZSA9IGVuYWJsZV9vcHNwdXRfaXJxLAotCS5kaXNhYmxlID0gZGlzYWJsZV9vcHNwdXRfaXJxLAotCS5hY2sgPSBtYXNrX2FuZF9hY2tfb3BzcHV0LAotCS5lbmQgPSBlbmRfb3BzcHV0X2lycQorCS5uYW1lCQk9ICJPUFNQVVQtSVJRIiwKKwkuaXJxX3NodXRkb3duCT0gc2h1dGRvd25fb3BzcHV0LAorCS5pcnFfbWFzawk9IG1hc2tfb3BzcHV0LAorCS5pcnFfdW5tYXNrCT0gdW5tYXNrX29wc3B1dCwKIH07CiAKIC8qCkBAIC0xMDAsNyArOTEsNiBAQAogCXVuc2lnbmVkIGludCBwbGRpcnE7CiAKIAlwbGRpcnEgPSBpcnEycGxkaXJxKGlycSk7Ci0vLwlkaXNhYmxlX29wc3B1dF9pcnEoTTMyUl9JUlFfSU5UMSk7CiAJcG9ydCA9IHBsZGlycTJwb3J0KHBsZGlycSk7CiAJZGF0YSA9IHBsZF9pY3VfZGF0YVtwbGRpcnFdLmljdWNyfFBMRF9JQ1VDUl9JTEVWRUw3OwogCW91dHcoZGF0YSwgcG9ydCk7CkBAIC0xMTIsNTAgKzEwMiwzOCBAQAogCXVuc2lnbmVkIGludCBwbGRpcnE7CiAKIAlwbGRpcnEgPSBpcnEycGxkaXJxKGlycSk7Ci0vLwllbmFibGVfb3BzcHV0X2lycShNMzJSX0lSUV9JTlQxKTsKIAlwb3J0ID0gcGxkaXJxMnBvcnQocGxkaXJxKTsKIAlkYXRhID0gcGxkX2ljdV9kYXRhW3BsZGlycV0uaWN1Y3J8UExEX0lDVUNSX0lFTnxQTERfSUNVQ1JfSUxFVkVMNjsKIAlvdXR3KGRhdGEsIHBvcnQpOwogfQogCi1zdGF0aWMgdm9pZCBtYXNrX2FuZF9hY2tfb3BzcHV0X3BsZCh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbWFza19vcHNwdXRfcGxkKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlkaXNhYmxlX29wc3B1dF9wbGRfaXJxKGlycSk7Ci0vLwltYXNrX2FuZF9hY2tfb3BzcHV0KE0zMlJfSVJRX0lOVDEpOworCWRpc2FibGVfb3BzcHV0X3BsZF9pcnEoZGF0YS0+aXJxKTsKIH0KIAotc3RhdGljIHZvaWQgZW5kX29wc3B1dF9wbGRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB1bm1hc2tfb3BzcHV0X3BsZChzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZW5hYmxlX29wc3B1dF9wbGRfaXJxKGlycSk7Ci0JZW5kX29wc3B1dF9pcnEoTTMyUl9JUlFfSU5UMSk7CisJZW5hYmxlX29wc3B1dF9wbGRfaXJxKGRhdGEtPmlycSk7CisJZW5hYmxlX29wc3B1dF9pcnEoTTMyUl9JUlFfSU5UMSk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQgc3RhcnR1cF9vcHNwdXRfcGxkX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWVuYWJsZV9vcHNwdXRfcGxkX2lycShpcnEpOwotCXJldHVybiAoMCk7Ci19Ci0KLXN0YXRpYyB2b2lkIHNodXRkb3duX29wc3B1dF9wbGRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzaHV0ZG93bl9vcHNwdXRfcGxkKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1bnNpZ25lZCBsb25nIHBvcnQ7CiAJdW5zaWduZWQgaW50IHBsZGlycTsKIAotCXBsZGlycSA9IGlycTJwbGRpcnEoaXJxKTsKLS8vCXNodXRkb3duX29wc3B1dF9pcnEoTTMyUl9JUlFfSU5UMSk7CisJcGxkaXJxID0gaXJxMnBsZGlycShkYXRhLT5pcnEpOwogCXBvcnQgPSBwbGRpcnEycG9ydChwbGRpcnEpOwogCW91dHcoUExEX0lDVUNSX0lMRVZFTDcsIHBvcnQpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG9wc3B1dF9wbGRfaXJxX3R5cGUgPQogewotCS5uYW1lID0gIk9QU1BVVC1QTEQtSVJRIiwKLQkuc3RhcnR1cCA9IHN0YXJ0dXBfb3BzcHV0X3BsZF9pcnEsCi0JLnNodXRkb3duID0gc2h1dGRvd25fb3BzcHV0X3BsZF9pcnEsCi0JLmVuYWJsZSA9IGVuYWJsZV9vcHNwdXRfcGxkX2lycSwKLQkuZGlzYWJsZSA9IGRpc2FibGVfb3BzcHV0X3BsZF9pcnEsCi0JLmFjayA9IG1hc2tfYW5kX2Fja19vcHNwdXRfcGxkLAotCS5lbmQgPSBlbmRfb3BzcHV0X3BsZF9pcnEKKwkubmFtZQkJPSAiT1BTUFVULVBMRC1JUlEiLAorCS5pcnFfc2h1dGRvd24JPSBzaHV0ZG93bl9vcHNwdXRfcGxkLAorCS5pcnFfbWFzawk9IG1hc2tfb3BzcHV0X3BsZCwKKwkuaXJxX3VubWFzawk9IHVubWFza19vcHNwdXRfcGxkLAogfTsKIAogLyoKQEAgLTE4OSw0MiArMTY3LDMzIEBACiAJb3V0dyhkYXRhLCBwb3J0KTsKIH0KIAotc3RhdGljIHZvaWQgbWFza19hbmRfYWNrX29wc3B1dF9sYW5wbGQodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1hc2tfb3BzcHV0X2xhbnBsZChzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZGlzYWJsZV9vcHNwdXRfbGFucGxkX2lycShpcnEpOworCWRpc2FibGVfb3BzcHV0X2xhbnBsZF9pcnEoZGF0YS0+aXJxKTsKIH0KIAotc3RhdGljIHZvaWQgZW5kX29wc3B1dF9sYW5wbGRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB1bm1hc2tfb3BzcHV0X2xhbnBsZChzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZW5hYmxlX29wc3B1dF9sYW5wbGRfaXJxKGlycSk7Ci0JZW5kX29wc3B1dF9pcnEoTTMyUl9JUlFfSU5UMCk7CisJZW5hYmxlX29wc3B1dF9sYW5wbGRfaXJxKGRhdGEtPmlycSk7CisJZW5hYmxlX29wc3B1dF9pcnEoTTMyUl9JUlFfSU5UMCk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQgc3RhcnR1cF9vcHNwdXRfbGFucGxkX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWVuYWJsZV9vcHNwdXRfbGFucGxkX2lycShpcnEpOwotCXJldHVybiAoMCk7Ci19Ci0KLXN0YXRpYyB2b2lkIHNodXRkb3duX29wc3B1dF9sYW5wbGRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzaHV0ZG93bl9vcHNwdXRfbGFucGxkKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1bnNpZ25lZCBsb25nIHBvcnQ7CiAJdW5zaWduZWQgaW50IHBsZGlycTsKIAotCXBsZGlycSA9IGlycTJsYW5wbGRpcnEoaXJxKTsKKwlwbGRpcnEgPSBpcnEybGFucGxkaXJxKGRhdGEtPmlycSk7CiAJcG9ydCA9IGxhbnBsZGlycTJwb3J0KHBsZGlycSk7CiAJb3V0dyhQTERfSUNVQ1JfSUxFVkVMNywgcG9ydCk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgb3BzcHV0X2xhbnBsZF9pcnFfdHlwZSA9CiB7Ci0JLm5hbWUgPSAiT1BTUFVULVBMRC1MQU4tSVJRIiwKLQkuc3RhcnR1cCA9IHN0YXJ0dXBfb3BzcHV0X2xhbnBsZF9pcnEsCi0JLnNodXRkb3duID0gc2h1dGRvd25fb3BzcHV0X2xhbnBsZF9pcnEsCi0JLmVuYWJsZSA9IGVuYWJsZV9vcHNwdXRfbGFucGxkX2lycSwKLQkuZGlzYWJsZSA9IGRpc2FibGVfb3BzcHV0X2xhbnBsZF9pcnEsCi0JLmFjayA9IG1hc2tfYW5kX2Fja19vcHNwdXRfbGFucGxkLAotCS5lbmQgPSBlbmRfb3BzcHV0X2xhbnBsZF9pcnEKKwkubmFtZQkJPSAiT1BTUFVULVBMRC1MQU4tSVJRIiwKKwkuaXJxX3NodXRkb3duCT0gc2h1dGRvd25fb3BzcHV0X2xhbnBsZCwKKwkuaXJxX21hc2sJPSBtYXNrX29wc3B1dF9sYW5wbGQsCisJLmlycV91bm1hc2sJPSB1bm1hc2tfb3BzcHV0X2xhbnBsZCwKIH07CiAKIC8qCkBAIC0yNTgsMTQzICsyMjcsMTA5IEBACiAJb3V0dyhkYXRhLCBwb3J0KTsKIH0KIAotc3RhdGljIHZvaWQgbWFza19hbmRfYWNrX29wc3B1dF9sY2RwbGQodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1hc2tfb3BzcHV0X2xjZHBsZChzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZGlzYWJsZV9vcHNwdXRfbGNkcGxkX2lycShpcnEpOworCWRpc2FibGVfb3BzcHV0X2xjZHBsZF9pcnEoZGF0YS0+aXJxKTsKIH0KIAotc3RhdGljIHZvaWQgZW5kX29wc3B1dF9sY2RwbGRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB1bm1hc2tfb3BzcHV0X2xjZHBsZChzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZW5hYmxlX29wc3B1dF9sY2RwbGRfaXJxKGlycSk7Ci0JZW5kX29wc3B1dF9pcnEoTTMyUl9JUlFfSU5UMik7CisJZW5hYmxlX29wc3B1dF9sY2RwbGRfaXJxKGRhdGEtPmlycSk7CisJZW5hYmxlX29wc3B1dF9pcnEoTTMyUl9JUlFfSU5UMik7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQgc3RhcnR1cF9vcHNwdXRfbGNkcGxkX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWVuYWJsZV9vcHNwdXRfbGNkcGxkX2lycShpcnEpOwotCXJldHVybiAoMCk7Ci19Ci0KLXN0YXRpYyB2b2lkIHNodXRkb3duX29wc3B1dF9sY2RwbGRfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzaHV0ZG93bl9vcHNwdXRfbGNkcGxkKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1bnNpZ25lZCBsb25nIHBvcnQ7CiAJdW5zaWduZWQgaW50IHBsZGlycTsKIAotCXBsZGlycSA9IGlycTJsY2RwbGRpcnEoaXJxKTsKKwlwbGRpcnEgPSBpcnEybGNkcGxkaXJxKGRhdGEtPmlycSk7CiAJcG9ydCA9IGxjZHBsZGlycTJwb3J0KHBsZGlycSk7CiAJb3V0dyhQTERfSUNVQ1JfSUxFVkVMNywgcG9ydCk7CiB9CiAKLXN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgb3BzcHV0X2xjZHBsZF9pcnFfdHlwZSA9Ci17Ci0JIk9QU1BVVC1QTEQtTENELUlSUSIsCi0Jc3RhcnR1cF9vcHNwdXRfbGNkcGxkX2lycSwKLQlzaHV0ZG93bl9vcHNwdXRfbGNkcGxkX2lycSwKLQllbmFibGVfb3BzcHV0X2xjZHBsZF9pcnEsCi0JZGlzYWJsZV9vcHNwdXRfbGNkcGxkX2lycSwKLQltYXNrX2FuZF9hY2tfb3BzcHV0X2xjZHBsZCwKLQllbmRfb3BzcHV0X2xjZHBsZF9pcnEKK3N0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgb3BzcHV0X2xjZHBsZF9pcnFfdHlwZSA9IHsKKwkubmFtZQkJPSAiT1BTUFVULVBMRC1MQ0QtSVJRIiwKKwkuaXJxX3NodXRkb3duCT0gc2h1dGRvd25fb3BzcHV0X2xjZHBsZCwKKwkuaXJxX21hc2sJPSBtYXNrX29wc3B1dF9sY2RwbGQsCisJLmlycV91bm1hc2sJPSB1bm1hc2tfb3BzcHV0X2xjZHBsZCwKIH07CiAKIHZvaWQgX19pbml0IGluaXRfSVJRKHZvaWQpCiB7CiAjaWYgZGVmaW5lZChDT05GSUdfU01DOTFYKQogCS8qIElOVCMwOiBMQU4gY29udHJvbGxlciBvbiBPUFNQVVQtTEFOIChTTUM5MUMxMTEpKi8KLQlpcnFfZGVzY1tPUFNQVVRfTEFOX0lSUV9MQU5dLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tPUFNQVVRfTEFOX0lSUV9MQU5dLmNoaXAgPSAmb3BzcHV0X2xhbnBsZF9pcnFfdHlwZTsKLQlpcnFfZGVzY1tPUFNQVVRfTEFOX0lSUV9MQU5dLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbT1BTUFVUX0xBTl9JUlFfTEFOXS5kZXB0aCA9IDE7CS8qIGRpc2FibGUgbmVzdGVkIGlycSAqLworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihPUFNQVVRfTEFOX0lSUV9MQU4sICZvcHNwdXRfbGFucGxkX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlsYW5wbGRfaWN1X2RhdGFbaXJxMmxhbnBsZGlycShPUFNQVVRfTEFOX0lSUV9MQU4pXS5pY3VjciA9IFBMRF9JQ1VDUl9JRU58UExEX0lDVUNSX0lTTU9EMDI7CS8qICJIIiBlZGdlIHNlbnNlICovCiAJZGlzYWJsZV9vcHNwdXRfbGFucGxkX2lycShPUFNQVVRfTEFOX0lSUV9MQU4pOwogI2VuZGlmICAvKiBDT05GSUdfU01DOTFYICovCiAKIAkvKiBNRlQyIDogc3lzdGVtIHRpbWVyICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfTUZUMl0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX01GVDJdLmNoaXAgPSAmb3BzcHV0X2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX01GVDJdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfTUZUMl0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9NRlQyLCAmb3BzcHV0X2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9NRlQyXS5pY3VjciA9IE0zMlJfSUNVQ1JfSUVOOwogCWRpc2FibGVfb3BzcHV0X2lycShNMzJSX0lSUV9NRlQyKTsKIAogCS8qIFNJTzAgOiByZWNlaXZlICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5jaGlwID0gJm9wc3B1dF9pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1JdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX1NJTzBfUiwgJm9wc3B1dF9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfU0lPMF9SXS5pY3VjciA9IDA7CiAJZGlzYWJsZV9vcHNwdXRfaXJxKE0zMlJfSVJRX1NJTzBfUik7CiAKIAkvKiBTSU8wIDogc2VuZCAqLwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uY2hpcCA9ICZvcHNwdXRfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9TXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9TSU8wX1MsICZvcHNwdXRfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX1NJTzBfU10uaWN1Y3IgPSAwOwogCWRpc2FibGVfb3BzcHV0X2lycShNMzJSX0lSUV9TSU8wX1MpOwogCiAJLyogU0lPMSA6IHJlY2VpdmUgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1JdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1JdLmNoaXAgPSAmb3BzcHV0X2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfUl0uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1JdLmRlcHRoID0gMTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoTTMyUl9JUlFfU0lPMV9SLCAmb3BzcHV0X2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9TSU8xX1JdLmljdWNyID0gMDsKIAlkaXNhYmxlX29wc3B1dF9pcnEoTTMyUl9JUlFfU0lPMV9SKTsKIAogCS8qIFNJTzEgOiBzZW5kICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9TXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9TXS5jaGlwID0gJm9wc3B1dF9pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1NdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9TXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX1NJTzFfUywgJm9wc3B1dF9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfU0lPMV9TXS5pY3VjciA9IDA7CiAJZGlzYWJsZV9vcHNwdXRfaXJxKE0zMlJfSVJRX1NJTzFfUyk7CiAKIAkvKiBETUExIDogKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9ETUExXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfRE1BMV0uY2hpcCA9ICZvcHNwdXRfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfRE1BMV0uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9ETUExXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX0RNQTEsICZvcHNwdXRfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX0RNQTFdLmljdWNyID0gMDsKIAlkaXNhYmxlX29wc3B1dF9pcnEoTTMyUl9JUlFfRE1BMSk7CiAKICNpZmRlZiBDT05GSUdfU0VSSUFMX00zMlJfUExEU0lPCiAJLyogSU5UIzE6IFNJTzAgUmVjZWl2ZSBvbiBQTEQgKi8KLQlpcnFfZGVzY1tQTERfSVJRX1NJTzBfUkNWXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbUExEX0lSUV9TSU8wX1JDVl0uY2hpcCA9ICZvcHNwdXRfcGxkX2lycV90eXBlOwotCWlycV9kZXNjW1BMRF9JUlFfU0lPMF9SQ1ZdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbUExEX0lSUV9TSU8wX1JDVl0uZGVwdGggPSAxOwkvKiBkaXNhYmxlIG5lc3RlZCBpcnEgKi8KKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoUExEX0lSUV9TSU8wX1JDViwgJm9wc3B1dF9wbGRfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCXBsZF9pY3VfZGF0YVtpcnEycGxkaXJxKFBMRF9JUlFfU0lPMF9SQ1YpXS5pY3VjciA9IFBMRF9JQ1VDUl9JRU58UExEX0lDVUNSX0lTTU9EMDM7CiAJZGlzYWJsZV9vcHNwdXRfcGxkX2lycShQTERfSVJRX1NJTzBfUkNWKTsKIAogCS8qIElOVCMxOiBTSU8wIFNlbmQgb24gUExEICovCi0JaXJxX2Rlc2NbUExEX0lSUV9TSU8wX1NORF0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW1BMRF9JUlFfU0lPMF9TTkRdLmNoaXAgPSAmb3BzcHV0X3BsZF9pcnFfdHlwZTsKLQlpcnFfZGVzY1tQTERfSVJRX1NJTzBfU05EXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW1BMRF9JUlFfU0lPMF9TTkRdLmRlcHRoID0gMTsJLyogZGlzYWJsZSBuZXN0ZWQgaXJxICovCisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKFBMRF9JUlFfU0lPMF9TTkQsICZvcHNwdXRfcGxkX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlwbGRfaWN1X2RhdGFbaXJxMnBsZGlycShQTERfSVJRX1NJTzBfU05EKV0uaWN1Y3IgPSBQTERfSUNVQ1JfSUVOfFBMRF9JQ1VDUl9JU01PRDAzOwogCWRpc2FibGVfb3BzcHV0X3BsZF9pcnEoUExEX0lSUV9TSU8wX1NORCk7CiAjZW5kaWYgIC8qIENPTkZJR19TRVJJQUxfTTMyUl9QTERTSU8gKi8KIAogCS8qIElOVCMxOiBDRkMgSVJFUSBvbiBQTEQgKi8KLQlpcnFfZGVzY1tQTERfSVJRX0NGSVJFUV0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZJUkVRXS5jaGlwID0gJm9wc3B1dF9wbGRfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbUExEX0lSUV9DRklSRVFdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbUExEX0lSUV9DRklSRVFdLmRlcHRoID0gMTsJLyogZGlzYWJsZSBuZXN0ZWQgaXJxICovCisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKFBMRF9JUlFfQ0ZJUkVRLCAmb3BzcHV0X3BsZF9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJcGxkX2ljdV9kYXRhW2lycTJwbGRpcnEoUExEX0lSUV9DRklSRVEpXS5pY3VjciA9IFBMRF9JQ1VDUl9JRU58UExEX0lDVUNSX0lTTU9EMDE7CS8qICdMJyBsZXZlbCBzZW5zZSAqLwogCWRpc2FibGVfb3BzcHV0X3BsZF9pcnEoUExEX0lSUV9DRklSRVEpOwogCiAJLyogSU5UIzE6IENGQyBJbnNlcnQgb24gUExEICovCi0JaXJxX2Rlc2NbUExEX0lSUV9DRkNfSU5TRVJUXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbUExEX0lSUV9DRkNfSU5TRVJUXS5jaGlwID0gJm9wc3B1dF9wbGRfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbUExEX0lSUV9DRkNfSU5TRVJUXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZDX0lOU0VSVF0uZGVwdGggPSAxOwkvKiBkaXNhYmxlIG5lc3RlZCBpcnEgKi8KKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoUExEX0lSUV9DRkNfSU5TRVJULCAmb3BzcHV0X3BsZF9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJcGxkX2ljdV9kYXRhW2lycTJwbGRpcnEoUExEX0lSUV9DRkNfSU5TRVJUKV0uaWN1Y3IgPSBQTERfSUNVQ1JfSUVOfFBMRF9JQ1VDUl9JU01PRDAwOwkvKiAnTCcgZWRnZSBzZW5zZSAqLwogCWRpc2FibGVfb3BzcHV0X3BsZF9pcnEoUExEX0lSUV9DRkNfSU5TRVJUKTsKIAogCS8qIElOVCMxOiBDRkMgRWplY3Qgb24gUExEICovCi0JaXJxX2Rlc2NbUExEX0lSUV9DRkNfRUpFQ1RdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tQTERfSVJRX0NGQ19FSkVDVF0uY2hpcCA9ICZvcHNwdXRfcGxkX2lycV90eXBlOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZDX0VKRUNUXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW1BMRF9JUlFfQ0ZDX0VKRUNUXS5kZXB0aCA9IDE7CS8qIGRpc2FibGUgbmVzdGVkIGlycSAqLworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihQTERfSVJRX0NGQ19FSkVDVCwgJm9wc3B1dF9wbGRfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCXBsZF9pY3VfZGF0YVtpcnEycGxkaXJxKFBMRF9JUlFfQ0ZDX0VKRUNUKV0uaWN1Y3IgPSBQTERfSUNVQ1JfSUVOfFBMRF9JQ1VDUl9JU01PRDAyOwkvKiAnSCcgZWRnZSBzZW5zZSAqLwogCWRpc2FibGVfb3BzcHV0X3BsZF9pcnEoUExEX0lSUV9DRkNfRUpFQ1QpOwogCkBAIC00MTMsMTQgKzM0OCwxMSBAQAogCWVuYWJsZV9vcHNwdXRfaXJxKE0zMlJfSVJRX0lOVDEpOwogCiAjaWYgZGVmaW5lZChDT05GSUdfVVNCKQotCW91dHcoVVNCQ1JfT1RHUywgVVNCQ1IpOyAJLyogVVNCQ1I6IG5vbi1PVEcgKi8KLQotICAgIGlycV9kZXNjW09QU1BVVF9MQ0RfSVJRX1VTQl9JTlQxXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0gICAgaXJxX2Rlc2NbT1BTUFVUX0xDRF9JUlFfVVNCX0lOVDFdLmNoaXAgPSAmb3BzcHV0X2xjZHBsZF9pcnFfdHlwZTsKLSAgICBpcnFfZGVzY1tPUFNQVVRfTENEX0lSUV9VU0JfSU5UMV0uYWN0aW9uID0gMDsKLSAgICBpcnFfZGVzY1tPUFNQVVRfTENEX0lSUV9VU0JfSU5UMV0uZGVwdGggPSAxOwotICAgIGxjZHBsZF9pY3VfZGF0YVtpcnEybGNkcGxkaXJxKE9QU1BVVF9MQ0RfSVJRX1VTQl9JTlQxKV0uaWN1Y3IgPSBQTERfSUNVQ1JfSUVOfFBMRF9JQ1VDUl9JU01PRDAxOwkvKiAiTCIgbGV2ZWwgc2Vuc2UgKi8KLSAgICBkaXNhYmxlX29wc3B1dF9sY2RwbGRfaXJxKE9QU1BVVF9MQ0RfSVJRX1VTQl9JTlQxKTsKKwlvdXR3KFVTQkNSX09UR1MsIFVTQkNSKTsJLyogVVNCQ1I6IG5vbi1PVEcgKi8KKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoT1BTUFVUX0xDRF9JUlFfVVNCX0lOVDEsCisJCQkJICZvcHNwdXRfbGNkcGxkX2lycV90eXBlLCBoYW5kbGVfbGV2ZWxfaXJxKTsKKwlsY2RwbGRfaWN1X2RhdGFbaXJxMmxjZHBsZGlycShPUFNQVVRfTENEX0lSUV9VU0JfSU5UMSldLmljdWNyID0gUExEX0lDVUNSX0lFTnxQTERfSUNVQ1JfSVNNT0QwMTsJLyogIkwiIGxldmVsIHNlbnNlICovCisJZGlzYWJsZV9vcHNwdXRfbGNkcGxkX2lycShPUFNQVVRfTENEX0lSUV9VU0JfSU5UMSk7CiAjZW5kaWYKIAkvKgogCSAqIElOVDIjIGlzIHVzZWQgZm9yIEJBVCwgVVNCLCBBVURJTwpAQCAtNDMzLDEwICszNjUsOCBAQAogCS8qCiAJICogSU5UMyMgaXMgdXNlZCBmb3IgQVIKIAkgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQzXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UM10uY2hpcCA9ICZvcHNwdXRfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfSU5UM10uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9JTlQzXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX0lOVDMsICZvcHNwdXRfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX0lOVDNdLmljdWNyID0gTTMyUl9JQ1VDUl9JRU58TTMyUl9JQ1VDUl9JU01PRDEwOwogCWRpc2FibGVfb3BzcHV0X2lycShNMzJSX0lSUV9JTlQzKTsKICNlbmRpZiAvKiBDT05GSUdfVklERU9fTTMyUl9BUiAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL3BsYXRmb3Jtcy91c3J2L3NldHVwLmMgYi9hcmNoL20zMnIvcGxhdGZvcm1zL3VzcnYvc2V0dXAuYwppbmRleCAxYmVhYzdhLi5mM2NmZjI2IDEwMDY0NAotLS0gYS9hcmNoL20zMnIvcGxhdGZvcm1zL3VzcnYvc2V0dXAuYworKysgYi9hcmNoL20zMnIvcGxhdGZvcm1zL3VzcnYvc2V0dXAuYwpAQCAtMzcsMzkgKzM3LDMwIEBACiAJb3V0bChkYXRhLCBwb3J0KTsKIH0KIAotc3RhdGljIHZvaWQgbWFza19hbmRfYWNrX21hcHBpKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBtYXNrX21hcHBpKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlkaXNhYmxlX21hcHBpX2lycShpcnEpOworCWRpc2FibGVfbWFwcGlfaXJxKGRhdGEtPmlycSk7CiB9CiAKLXN0YXRpYyB2b2lkIGVuZF9tYXBwaV9pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHVubWFza19tYXBwaShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0JZW5hYmxlX21hcHBpX2lycShpcnEpOworCWVuYWJsZV9tYXBwaV9pcnEoZGF0YS0+aXJxKTsKIH0KIAotc3RhdGljIHVuc2lnbmVkIGludCBzdGFydHVwX21hcHBpX2lycSh1bnNpZ25lZCBpbnQgaXJxKQotewotCWVuYWJsZV9tYXBwaV9pcnEoaXJxKTsKLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIHZvaWQgc2h1dGRvd25fbWFwcGlfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBzaHV0ZG93bl9tYXBwaShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7CiAJdW5zaWduZWQgbG9uZyBwb3J0OwogCi0JcG9ydCA9IGlycTJwb3J0KGlycSk7CisJcG9ydCA9IGlycTJwb3J0KGRhdGEtPmlycSk7CiAJb3V0bChNMzJSX0lDVUNSX0lMRVZFTDcsIHBvcnQpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG1hcHBpX2lycV90eXBlID0KIHsKLQkubmFtZSA9ICJNMzI3MDAtSVJRIiwKLQkuc3RhcnR1cCA9IHN0YXJ0dXBfbWFwcGlfaXJxLAotCS5zaHV0ZG93biA9IHNodXRkb3duX21hcHBpX2lycSwKLQkuZW5hYmxlID0gZW5hYmxlX21hcHBpX2lycSwKLQkuZGlzYWJsZSA9IGRpc2FibGVfbWFwcGlfaXJxLAotCS5hY2sgPSBtYXNrX2FuZF9hY2tfbWFwcGksCi0JLmVuZCA9IGVuZF9tYXBwaV9pcnEKKwkubmFtZQkJPSAiTTMyNzAwLUlSUSIsCisJLmlycV9zaHV0ZG93bgk9IHNodXRkb3duX21hcHBpLAorCS5pcnFfbWFzawk9IG1hc2tfbWFwcGksCisJLmlycV91bm1hc2sJPSB1bm1hc2tfbWFwcGksCiB9OwogCiAvKgpAQCAtMTA3LDQyICs5OCwzMyBAQAogCW91dHcoZGF0YSwgcG9ydCk7CiB9CiAKLXN0YXRpYyB2b2lkIG1hc2tfYW5kX2Fja19tMzI3MDB1dF9wbGQodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1hc2tfbTMyNzAwdXRfcGxkKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlkaXNhYmxlX20zMjcwMHV0X3BsZF9pcnEoaXJxKTsKKwlkaXNhYmxlX20zMjcwMHV0X3BsZF9pcnEoZGF0YS0+aXJxKTsKIH0KIAotc3RhdGljIHZvaWQgZW5kX20zMjcwMHV0X3BsZF9pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHVubWFza19tMzI3MDB1dF9wbGQoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCWVuYWJsZV9tMzI3MDB1dF9wbGRfaXJxKGlycSk7Ci0JZW5kX21hcHBpX2lycShNMzJSX0lSUV9JTlQxKTsKKwllbmFibGVfbTMyNzAwdXRfcGxkX2lycShkYXRhLT5pcnEpOworCWVuYWJsZV9tYXBwaV9pcnEoTTMyUl9JUlFfSU5UMSk7CiB9CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQgc3RhcnR1cF9tMzI3MDB1dF9wbGRfaXJxKHVuc2lnbmVkIGludCBpcnEpCi17Ci0JZW5hYmxlX20zMjcwMHV0X3BsZF9pcnEoaXJxKTsKLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIHZvaWQgc2h1dGRvd25fbTMyNzAwdXRfcGxkX2lycSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc2h1dGRvd25fbTMyNzAwdXRfcGxkKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1bnNpZ25lZCBsb25nIHBvcnQ7CiAJdW5zaWduZWQgaW50IHBsZGlycTsKIAotCXBsZGlycSA9IGlycTJwbGRpcnEoaXJxKTsKKwlwbGRpcnEgPSBpcnEycGxkaXJxKGRhdGEtPmlycSk7CiAJcG9ydCA9IHBsZGlycTJwb3J0KHBsZGlycSk7CiAJb3V0dyhQTERfSUNVQ1JfSUxFVkVMNywgcG9ydCk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbTMyNzAwdXRfcGxkX2lycV90eXBlID0KIHsKLQkubmFtZSA9ICJVU1JWLVBMRC1JUlEiLAotCS5zdGFydHVwID0gc3RhcnR1cF9tMzI3MDB1dF9wbGRfaXJxLAotCS5zaHV0ZG93biA9IHNodXRkb3duX20zMjcwMHV0X3BsZF9pcnEsCi0JLmVuYWJsZSA9IGVuYWJsZV9tMzI3MDB1dF9wbGRfaXJxLAotCS5kaXNhYmxlID0gZGlzYWJsZV9tMzI3MDB1dF9wbGRfaXJxLAotCS5hY2sgPSBtYXNrX2FuZF9hY2tfbTMyNzAwdXRfcGxkLAotCS5lbmQgPSBlbmRfbTMyNzAwdXRfcGxkX2lycQorCS5uYW1lCQk9ICJVU1JWLVBMRC1JUlEiLAorCS5pcnFfc2h1dGRvd24JPSBzaHV0ZG93bl9tMzI3MDB1dF9wbGQsCisJLmlycV9tYXNrCT0gbWFza19tMzI3MDB1dF9wbGQsCisJLmlycV91bm1hc2sJPSB1bm1hc2tfbTMyNzAwdXRfcGxkLAogfTsKIAogdm9pZCBfX2luaXQgaW5pdF9JUlEodm9pZCkKQEAgLTE1Niw1MyArMTM4LDQyIEBACiAJCW9uY2UrKzsKIAogCS8qIE1GVDIgOiBzeXN0ZW0gdGltZXIgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9NRlQyXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfTUZUMl0uY2hpcCA9ICZtYXBwaV9pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9NRlQyXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMlJfSVJRX01GVDJdLmRlcHRoID0gMTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoTTMyUl9JUlFfTUZUMiwgJm1hcHBpX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9NRlQyXS5pY3VjciA9IE0zMlJfSUNVQ1JfSUVOOwogCWRpc2FibGVfbWFwcGlfaXJxKE0zMlJfSVJRX01GVDIpOwogCiAjaWYgZGVmaW5lZChDT05GSUdfU0VSSUFMX00zMlJfU0lPKQogCS8qIFNJTzBfUiA6IHVhcnQgcmVjZWl2ZSBkYXRhICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9SXS5jaGlwID0gJm1hcHBpX2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfUl0uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1JdLmRlcHRoID0gMTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoTTMyUl9JUlFfU0lPMF9SLCAmbWFwcGlfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX1NJTzBfUl0uaWN1Y3IgPSAwOwogCWRpc2FibGVfbWFwcGlfaXJxKE0zMlJfSVJRX1NJTzBfUik7CiAKIAkvKiBTSU8wX1MgOiB1YXJ0IHNlbmQgZGF0YSAqLwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzBfU10uY2hpcCA9ICZtYXBwaV9pcnFfdHlwZTsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8wX1NdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMF9TXS5kZXB0aCA9IDE7CisJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKE0zMlJfSVJRX1NJTzBfUywgJm1hcHBpX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlpY3VfZGF0YVtNMzJSX0lSUV9TSU8wX1NdLmljdWNyID0gMDsKIAlkaXNhYmxlX21hcHBpX2lycShNMzJSX0lSUV9TSU8wX1MpOwogCiAJLyogU0lPMV9SIDogdWFydCByZWNlaXZlIGRhdGEgKi8KLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1JdLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1JdLmNoaXAgPSAmbWFwcGlfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9SXS5hY3Rpb24gPSAwOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfUl0uZGVwdGggPSAxOworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihNMzJSX0lSUV9TSU8xX1IsICZtYXBwaV9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJaWN1X2RhdGFbTTMyUl9JUlFfU0lPMV9SXS5pY3VjciA9IDA7CiAJZGlzYWJsZV9tYXBwaV9pcnEoTTMyUl9JUlFfU0lPMV9SKTsKIAogCS8qIFNJTzFfUyA6IHVhcnQgc2VuZCBkYXRhICovCi0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9TXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbTTMyUl9JUlFfU0lPMV9TXS5jaGlwID0gJm1hcHBpX2lycV90eXBlOwotCWlycV9kZXNjW00zMlJfSVJRX1NJTzFfU10uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tNMzJSX0lSUV9TSU8xX1NdLmRlcHRoID0gMTsKKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoTTMyUl9JUlFfU0lPMV9TLCAmbWFwcGlfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCWljdV9kYXRhW00zMlJfSVJRX1NJTzFfU10uaWN1Y3IgPSAwOwogCWRpc2FibGVfbWFwcGlfaXJxKE0zMlJfSVJRX1NJTzFfUyk7CiAjZW5kaWYgIC8qIENPTkZJR19TRVJJQUxfTTMyUl9TSU8gKi8KIAogCS8qIElOVCM2Ny0jNzE6IENGQyMwIElSRVEgb24gUExEICovCiAJZm9yIChpID0gMCA7IGkgPCBDT05GSUdfTTMyUl9DRkNfTlVNIDsgaSsrICkgewotCQlpcnFfZGVzY1tQTERfSVJRX0NGMCArIGldLnN0YXR1cyA9IElSUV9ESVNBQkxFRDsKLQkJaXJxX2Rlc2NbUExEX0lSUV9DRjAgKyBpXS5jaGlwID0gJm0zMjcwMHV0X3BsZF9pcnFfdHlwZTsKLQkJaXJxX2Rlc2NbUExEX0lSUV9DRjAgKyBpXS5hY3Rpb24gPSAwOwotCQlpcnFfZGVzY1tQTERfSVJRX0NGMCArIGldLmRlcHRoID0gMTsJLyogZGlzYWJsZSBuZXN0ZWQgaXJxICovCisJCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihQTERfSVJRX0NGMCArIGksCisJCQkJCSAmbTMyNzAwdXRfcGxkX2lycV90eXBlLAorCQkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJCXBsZF9pY3VfZGF0YVtpcnEycGxkaXJxKFBMRF9JUlFfQ0YwICsgaSldLmljdWNyCiAJCQk9IFBMRF9JQ1VDUl9JU01PRDAxOwkvKiAnTCcgbGV2ZWwgc2Vuc2UgKi8KIAkJZGlzYWJsZV9tMzI3MDB1dF9wbGRfaXJxKFBMRF9JUlFfQ0YwICsgaSk7CkBAIC0yMTAsMTkgKzE4MSwxNSBAQAogCiAjaWYgZGVmaW5lZChDT05GSUdfU0VSSUFMXzgyNTApIHx8IGRlZmluZWQoQ09ORklHX1NFUklBTF84MjUwX01PRFVMRSkKIAkvKiBJTlQjNzY6IDE2NTUyRCMwIElSRVEgb24gUExEICovCi0JaXJxX2Rlc2NbUExEX0lSUV9VQVJUMF0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW1BMRF9JUlFfVUFSVDBdLmNoaXAgPSAmbTMyNzAwdXRfcGxkX2lycV90eXBlOwotCWlycV9kZXNjW1BMRF9JUlFfVUFSVDBdLmFjdGlvbiA9IDA7Ci0JaXJxX2Rlc2NbUExEX0lSUV9VQVJUMF0uZGVwdGggPSAxOwkvKiBkaXNhYmxlIG5lc3RlZCBpcnEgKi8KKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoUExEX0lSUV9VQVJUMCwgJm0zMjcwMHV0X3BsZF9pcnFfdHlwZSwKKwkJCQkgaGFuZGxlX2xldmVsX2lycSk7CiAJcGxkX2ljdV9kYXRhW2lycTJwbGRpcnEoUExEX0lSUV9VQVJUMCldLmljdWNyCiAJCT0gUExEX0lDVUNSX0lTTU9EMDM7CS8qICdIJyBsZXZlbCBzZW5zZSAqLwogCWRpc2FibGVfbTMyNzAwdXRfcGxkX2lycShQTERfSVJRX1VBUlQwKTsKIAogCS8qIElOVCM3NzogMTY1NTJEIzEgSVJFUSBvbiBQTEQgKi8KLQlpcnFfZGVzY1tQTERfSVJRX1VBUlQxXS5zdGF0dXMgPSBJUlFfRElTQUJMRUQ7Ci0JaXJxX2Rlc2NbUExEX0lSUV9VQVJUMV0uY2hpcCA9ICZtMzI3MDB1dF9wbGRfaXJxX3R5cGU7Ci0JaXJxX2Rlc2NbUExEX0lSUV9VQVJUMV0uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tQTERfSVJRX1VBUlQxXS5kZXB0aCA9IDE7CS8qIGRpc2FibGUgbmVzdGVkIGlycSAqLworCXNldF9pcnFfY2hpcF9hbmRfaGFuZGxlcihQTERfSVJRX1VBUlQxLCAmbTMyNzAwdXRfcGxkX2lycV90eXBlLAorCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKIAlwbGRfaWN1X2RhdGFbaXJxMnBsZGlycShQTERfSVJRX1VBUlQxKV0uaWN1Y3IKIAkJPSBQTERfSUNVQ1JfSVNNT0QwMzsJLyogJ0gnIGxldmVsIHNlbnNlICovCiAJZGlzYWJsZV9tMzI3MDB1dF9wbGRfaXJxKFBMRF9JUlFfVUFSVDEpOwpAQCAtMjMwLDEwICsxOTcsOCBAQAogCiAjaWYgZGVmaW5lZChDT05GSUdfSURDX0FLNDUyNCkgfHwgZGVmaW5lZChDT05GSUdfSURDX0FLNDUyNF9NT0RVTEUpCiAJLyogSU5UIzgwOiBBSzQ1MjQgSVJFUSBvbiBQTEQgKi8KLQlpcnFfZGVzY1tQTERfSVJRX1NORElOVF0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOwotCWlycV9kZXNjW1BMRF9JUlFfU05ESU5UXS5jaGlwID0gJm0zMjcwMHV0X3BsZF9pcnFfdHlwZTsKLQlpcnFfZGVzY1tQTERfSVJRX1NORElOVF0uYWN0aW9uID0gMDsKLQlpcnFfZGVzY1tQTERfSVJRX1NORElOVF0uZGVwdGggPSAxOwkvKiBkaXNhYmxlIG5lc3RlZCBpcnEgKi8KKwlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoUExEX0lSUV9TTkRJTlQsICZtMzI3MDB1dF9wbGRfaXJxX3R5cGUsCisJCQkJIGhhbmRsZV9sZXZlbF9pcnEpOwogCXBsZF9pY3VfZGF0YVtpcnEycGxkaXJxKFBMRF9JUlFfU05ESU5UKV0uaWN1Y3IKIAkJPSBQTERfSUNVQ1JfSVNNT0QwMTsJLyogJ0wnIGxldmVsIHNlbnNlICovCiAJZGlzYWJsZV9tMzI3MDB1dF9wbGRfaXJxKFBMRF9JUlFfU05ESU5UKTsKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9hbWlnYS9jb25maWcuYyBiL2FyY2gvbTY4ay9hbWlnYS9jb25maWcuYwppbmRleCBiMTU3N2Y3Li44MmE0YmI1IDEwMDY0NAotLS0gYS9hcmNoL202OGsvYW1pZ2EvY29uZmlnLmMKKysrIGIvYXJjaC9tNjhrL2FtaWdhL2NvbmZpZy5jCkBAIC02MTAsMTcgKzYxMCwxNyBAQAogCiBzdGF0aWMgaW50IF9faW5pdCBhbWlnYV9zYXZla21zZ19zZXR1cChjaGFyICphcmcpCiB7Ci0Jc3RhdGljIHN0cnVjdCByZXNvdXJjZSBkZWJ1Z19yZXMgPSB7IC5uYW1lID0gIkRlYnVnIiB9OwotCiAJaWYgKCFNQUNIX0lTX0FNSUdBIHx8IHN0cmNtcChhcmcsICJtZW0iKSkKLQkJZ290byBkb25lOworCQlyZXR1cm4gMDsKIAotCWlmICghQU1JR0FIV19QUkVTRU5UKENISVBfUkFNKSkgewotCQlwcmludGsoIldhcm5pbmc6IG5vIGNoaXByYW0gcHJlc2VudCBmb3IgZGVidWdnaW5nXG4iKTsKLQkJZ290byBkb25lOworCWlmIChhbWlnYV9jaGlwX3NpemUgPCBTQVZFS01TR19NQVhNRU0pIHsKKwkJcHJfZXJyKCJOb3QgZW5vdWdoIGNoaXByYW0gZm9yIGRlYnVnZ2luZ1xuIik7CisJCXJldHVybiAtRU5PTUVNOwogCX0KIAotCXNhdmVrbXNnID0gYW1pZ2FfY2hpcF9hbGxvY19yZXMoU0FWRUtNU0dfTUFYTUVNLCAmZGVidWdfcmVzKTsKKwkvKiBKdXN0IHN0ZWFsIHRoZSBibG9jaywgdGhlIGNoaXByYW0gYWxsb2NhdG9yIGlzbid0IGZ1bmN0aW9uYWwgeWV0ICovCisJYW1pZ2FfY2hpcF9zaXplIC09IFNBVkVLTVNHX01BWE1FTTsKKwlzYXZla21zZyA9ICh2b2lkICopWlRXT19WQUREUihDSElQX1BIWVNBRERSICsgYW1pZ2FfY2hpcF9zaXplKTsKIAlzYXZla21zZy0+bWFnaWMxID0gU0FWRUtNU0dfTUFHSUMxOwogCXNhdmVrbXNnLT5tYWdpYzIgPSBTQVZFS01TR19NQUdJQzI7CiAJc2F2ZWttc2ctPm1hZ2ljcHRyID0gWlRXT19QQUREUihzYXZla21zZyk7CkBAIC02MjgsOCArNjI4LDYgQEAKIAogCWFtaWdhX2NvbnNvbGVfZHJpdmVyLndyaXRlID0gYW1pZ2FfbWVtX2NvbnNvbGVfd3JpdGU7CiAJcmVnaXN0ZXJfY29uc29sZSgmYW1pZ2FfY29uc29sZV9kcml2ZXIpOwotCi1kb25lOgogCXJldHVybiAwOwogfQogCmRpZmYgLS1naXQgYS9hcmNoL202OGsvYXRhcmkvYXRhaW50cy5jIGIvYXJjaC9tNjhrL2F0YXJpL2F0YWludHMuYwppbmRleCAzOTQ3OGRkLi4yNmE4MDRlIDEwMDY0NAotLS0gYS9hcmNoL202OGsvYXRhcmkvYXRhaW50cy5jCisrKyBiL2FyY2gvbTY4ay9hdGFyaS9hdGFpbnRzLmMKQEAgLTM4OCw5ICszODgsOSBAQAogCX0KIAogCWlmIChBVEFSSUhXX1BSRVNFTlQoU0NDKSAmJiAhYXRhcmlfU0NDX3Jlc2V0X2RvbmUpIHsKLQkJc2NjLmNoYV9hX2N0cmwgPSA5OworCQlhdGFyaV9zY2MuY2hhX2FfY3RybCA9IDk7CiAJCU1GUERFTEFZKCk7Ci0JCXNjYy5jaGFfYV9jdHJsID0gKGNoYXIpIDB4YzA7IC8qIGhhcmR3YXJlIHJlc2V0ICovCisJCWF0YXJpX3NjYy5jaGFfYV9jdHJsID0gKGNoYXIpIDB4YzA7IC8qIGhhcmR3YXJlIHJlc2V0ICovCiAJfQogCiAJaWYgKEFUQVJJSFdfUFJFU0VOVChTQ1UpKSB7CmRpZmYgLS1naXQgYS9hcmNoL202OGsvYXRhcmkvY29uZmlnLmMgYi9hcmNoL202OGsvYXRhcmkvY29uZmlnLmMKaW5kZXggYWUyZDk2ZS4uNDIwM2QxMCAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2F0YXJpL2NvbmZpZy5jCisrKyBiL2FyY2gvbTY4ay9hdGFyaS9jb25maWcuYwpAQCAtMzE1LDcgKzMxNSw3IEBACiAJCUFUQVJJSFdfU0VUKFNDQ19ETUEpOwogCQlwcmludGsoIlNDQ19ETUEgIik7CiAJfQotCWlmIChzY2NfdGVzdCgmc2NjLmNoYV9hX2N0cmwpKSB7CisJaWYgKHNjY190ZXN0KCZhdGFyaV9zY2MuY2hhX2FfY3RybCkpIHsKIAkJQVRBUklIV19TRVQoU0NDKTsKIAkJcHJpbnRrKCJTQ0MgIik7CiAJfQpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL2F0YXJpL2RlYnVnLmMgYi9hcmNoL202OGsvYXRhcmkvZGVidWcuYwppbmRleCAyOGVmZGMzLi41YTQ4NDI0IDEwMDY0NAotLS0gYS9hcmNoL202OGsvYXRhcmkvZGVidWcuYworKysgYi9hcmNoL202OGsvYXRhcmkvZGVidWcuYwpAQCAtNTMsOSArNTMsOSBAQAogewogCWRvIHsKIAkJTUZQREVMQVkoKTsKLQl9IHdoaWxlICghKHNjYy5jaGFfYl9jdHJsICYgMHgwNCkpOyAvKiB3YWl0IGZvciB0eCBidWYgZW1wdHkgKi8KKwl9IHdoaWxlICghKGF0YXJpX3NjYy5jaGFfYl9jdHJsICYgMHgwNCkpOyAvKiB3YWl0IGZvciB0eCBidWYgZW1wdHkgKi8KIAlNRlBERUxBWSgpOwotCXNjYy5jaGFfYl9kYXRhID0gYzsKKwlhdGFyaV9zY2MuY2hhX2JfZGF0YSA9IGM7CiB9CiAKIHN0YXRpYyB2b2lkIGF0YXJpX3NjY19jb25zb2xlX3dyaXRlKHN0cnVjdCBjb25zb2xlICpjbywgY29uc3QgY2hhciAqc3RyLApAQCAtMTQwLDkgKzE0MCw5IEBACiB7CiAJZG8gewogCQlNRlBERUxBWSgpOwotCX0gd2hpbGUgKCEoc2NjLmNoYV9iX2N0cmwgJiAweDAxKSk7IC8qIHdhaXQgZm9yIHJ4IGJ1ZiBmaWxsZWQgKi8KKwl9IHdoaWxlICghKGF0YXJpX3NjYy5jaGFfYl9jdHJsICYgMHgwMSkpOyAvKiB3YWl0IGZvciByeCBidWYgZmlsbGVkICovCiAJTUZQREVMQVkoKTsKLQlyZXR1cm4gc2NjLmNoYV9iX2RhdGE7CisJcmV0dXJuIGF0YXJpX3NjYy5jaGFfYl9kYXRhOwogfQogCiBpbnQgYXRhcmlfbWlkaV9jb25zb2xlX3dhaXRfa2V5KHN0cnVjdCBjb25zb2xlICpjbykKQEAgLTE4NSw5ICsxODUsOSBAQAogCiAjZGVmaW5lIFNDQ19XUklURShyZWcsIHZhbCkJCQkJXAogCWRvIHsJCQkJCQlcCi0JCXNjYy5jaGFfYl9jdHJsID0gKHJlZyk7CQkJXAorCQlhdGFyaV9zY2MuY2hhX2JfY3RybCA9IChyZWcpOwkJXAogCQlNRlBERUxBWSgpOwkJCQlcCi0JCXNjYy5jaGFfYl9jdHJsID0gKHZhbCk7CQkJXAorCQlhdGFyaV9zY2MuY2hhX2JfY3RybCA9ICh2YWwpOwkJXAogCQlNRlBERUxBWSgpOwkJCQlcCiAJfSB3aGlsZSAoMCkKIApAQCAtMjQwLDcgKzI0MCw3IEBACiAJcmVnMyA9IChjZmxhZyAmIENTSVpFKSA9PSBDUzggPyAweGMwIDogMHg0MDsKIAlyZWc1ID0gKGNmbGFnICYgQ1NJWkUpID09IENTOCA/IDB4NjAgOiAweDIwIHwgMHg4MiAvKiBhc3NlcnQgRFRSL1JUUyAqLzsKIAotCSh2b2lkKXNjYy5jaGFfYl9jdHJsOwkJLyogcmVzZXQgcmVnIHBvaW50ZXIgKi8KKwkodm9pZClhdGFyaV9zY2MuY2hhX2JfY3RybDsJLyogcmVzZXQgcmVnIHBvaW50ZXIgKi8KIAlTQ0NfV1JJVEUoOSwgMHhjMCk7CQkvKiByZXNldCAqLwogCUxPTkdfREVMQVkoKTsJCQkvKiBleHRyYSBkZWxheSBhZnRlciBXUjkgYWNjZXNzICovCiAJU0NDX1dSSVRFKDQsIChjZmxhZyAmIFBBUkVOQikgPyAoKGNmbGFnICYgUEFST0REKSA/IDB4MDEgOiAweDAzKQpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2F0YXJpaHcuaCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9hdGFyaWh3LmgKaW5kZXggYTcxNGUxYS4uZjUxZjcwOSAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2F0YXJpaHcuaAorKysgYi9hcmNoL202OGsvaW5jbHVkZS9hc20vYXRhcmlody5oCkBAIC00NDksNyArNDQ5LDcgQEAKICAgdV9jaGFyIGNoYXJfZHVtbXkzOwogICB1X2NoYXIgY2hhX2JfZGF0YTsKICB9OwotIyBkZWZpbmUgc2NjICgoKih2b2xhdGlsZSBzdHJ1Y3QgU0NDKilTQ0NfQkFTKSkKKyMgZGVmaW5lIGF0YXJpX3NjYyAoKCoodm9sYXRpbGUgc3RydWN0IFNDQyopU0NDX0JBUykpCiAKIC8qIFRoZSBFU0NDIChaODUyMzApIGluIGFuIEF0YXJpIFNULiBUaGUgY2hhbm5lbHMgYXJlIHJldmVyc2VkISAqLwogIyBkZWZpbmUgc3RfZXNjYyAoKCoodm9sYXRpbGUgc3RydWN0IFNDQyopMHhmZmZmZmEzMSkpCmRpZmYgLS1naXQgYS9hcmNoL202OGsvaW5jbHVkZS9hc20vY2FjaGVmbHVzaF9uby5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2NhY2hlZmx1c2hfbm8uaAppbmRleCA3MDg1YmQ1Li5jYjg4YWE5IDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vY2FjaGVmbHVzaF9uby5oCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoX25vLmgKQEAgLTIsMjEgKzIsMjIgQEAKICNkZWZpbmUgX002OEtOT01NVV9DQUNIRUZMVVNIX0gKIAogLyoKLSAqIChDKSBDb3B5cmlnaHQgMjAwMC0yMDA0LCBHcmVnIFVuZ2VyZXIgPGdlcmdAc25hcGdlYXIuY29tPgorICogKEMpIENvcHlyaWdodCAyMDAwLTIwMTAsIEdyZWcgVW5nZXJlciA8Z2VyZ0BzbmFwZ2Vhci5jb20+CiAgKi8KICNpbmNsdWRlIDxsaW51eC9tbS5oPgorI2luY2x1ZGUgPGFzbS9tY2ZzaW0uaD4KIAogI2RlZmluZSBmbHVzaF9jYWNoZV9hbGwoKQkJCV9fZmx1c2hfY2FjaGVfYWxsKCkKICNkZWZpbmUgZmx1c2hfY2FjaGVfbW0obW0pCQkJZG8geyB9IHdoaWxlICgwKQogI2RlZmluZSBmbHVzaF9jYWNoZV9kdXBfbW0obW0pCQkJZG8geyB9IHdoaWxlICgwKQotI2RlZmluZSBmbHVzaF9jYWNoZV9yYW5nZSh2bWEsIHN0YXJ0LCBlbmQpCV9fZmx1c2hfY2FjaGVfYWxsKCkKKyNkZWZpbmUgZmx1c2hfY2FjaGVfcmFuZ2Uodm1hLCBzdGFydCwgZW5kKQlkbyB7IH0gd2hpbGUgKDApCiAjZGVmaW5lIGZsdXNoX2NhY2hlX3BhZ2Uodm1hLCB2bWFkZHIpCQlkbyB7IH0gd2hpbGUgKDApCi0jZGVmaW5lIGZsdXNoX2RjYWNoZV9yYW5nZShzdGFydCxsZW4pCQlfX2ZsdXNoX2NhY2hlX2FsbCgpCisjZGVmaW5lIGZsdXNoX2RjYWNoZV9yYW5nZShzdGFydCwgbGVuKQkJX19mbHVzaF9kY2FjaGVfYWxsKCkKICNkZWZpbmUgQVJDSF9JTVBMRU1FTlRTX0ZMVVNIX0RDQUNIRV9QQUdFIDAKICNkZWZpbmUgZmx1c2hfZGNhY2hlX3BhZ2UocGFnZSkJCQlkbyB7IH0gd2hpbGUgKDApCiAjZGVmaW5lIGZsdXNoX2RjYWNoZV9tbWFwX2xvY2sobWFwcGluZykJCWRvIHsgfSB3aGlsZSAoMCkKICNkZWZpbmUgZmx1c2hfZGNhY2hlX21tYXBfdW5sb2NrKG1hcHBpbmcpCWRvIHsgfSB3aGlsZSAoMCkKLSNkZWZpbmUgZmx1c2hfaWNhY2hlX3JhbmdlKHN0YXJ0LGxlbikJCV9fZmx1c2hfY2FjaGVfYWxsKCkKKyNkZWZpbmUgZmx1c2hfaWNhY2hlX3JhbmdlKHN0YXJ0LCBsZW4pCQlfX2ZsdXNoX2ljYWNoZV9hbGwoKQogI2RlZmluZSBmbHVzaF9pY2FjaGVfcGFnZSh2bWEscGcpCQlkbyB7IH0gd2hpbGUgKDApCiAjZGVmaW5lIGZsdXNoX2ljYWNoZV91c2VyX3JhbmdlKHZtYSxwZyxhZHIsbGVuKQlkbyB7IH0gd2hpbGUgKDApCiAjZGVmaW5lIGZsdXNoX2NhY2hlX3ZtYXAoc3RhcnQsIGVuZCkJCWRvIHsgfSB3aGlsZSAoMCkKQEAgLTI3LDY2ICsyOCw1MiBAQAogI2RlZmluZSBjb3B5X2Zyb21fdXNlcl9wYWdlKHZtYSwgcGFnZSwgdmFkZHIsIGRzdCwgc3JjLCBsZW4pIFwKIAltZW1jcHkoZHN0LCBzcmMsIGxlbikKIAordm9pZCBtY2ZfY2FjaGVfcHVzaCh2b2lkKTsKKwogc3RhdGljIGlubGluZSB2b2lkIF9fZmx1c2hfY2FjaGVfYWxsKHZvaWQpCiB7Ci0jaWYgZGVmaW5lZChDT05GSUdfTTU0MDcpIHx8IGRlZmluZWQoQ09ORklHX001NDh4KQotCS8qCi0JICoJVXNlIGNwdXNobCB0byBwdXNoIGFuZCBpbnZhbGlkYXRlIGFsbCBjYWNoZSBsaW5lcy4KLQkgKglHYXMgZG9lc24ndCBzZWVtIHRvIGtub3cgaG93IHRvIGdlbmVyYXRlIHRoZSBDb2xkRmlyZQotCSAqCWNwdXNobCBpbnN0cnVjdGlvbi4uLiBPaCB3ZWxsLCBiaXQgc3R1ZmYgaXQgZm9yIG5vdy4KLQkgKi8KKyNpZmRlZiBDQUNIRV9QVVNICisJbWNmX2NhY2hlX3B1c2goKTsKKyNlbmRpZgorI2lmZGVmIENBQ0hFX0lOVkFMSURBVEUKIAlfX2FzbV9fIF9fdm9sYXRpbGVfXyAoCi0JCSJub3Bcblx0IgotCQkiY2xybAklJWQwXG5cdCIKLQkJIjE6XG5cdCIKLQkJIm1vdmVsCSUlZDAsJSVhMFxuXHQiCi0JCSIyOlxuXHQiCi0JCSIud29yZAkweGY0Njhcblx0IgotCQkiYWRkbAkjMHgxMCwlJWEwXG5cdCIKLQkJImNtcGwJIzB4MDAwMDA4MDAsJSVhMFxuXHQiCi0JCSJibHQJMmJcblx0IgotCQkiYWRkcWwJIzEsJSVkMFxuXHQiCi0JCSJjbXBpbAkjNCwlJWQwXG5cdCIKLQkJImJuZQkxYlxuXHQiCi0JCSJtb3ZlbAkjMHhiNjA4ODUwMCwlJWQwXG5cdCIKLQkJIm1vdmVjCSUlZDAsJSVDQUNSXG5cdCIKLQkJOiA6IDogImQwIiwgImEwIiApOwotI2VuZGlmIC8qIENPTkZJR19NNTQwNyAqLwotI2lmIGRlZmluZWQoQ09ORklHX001MjN4KSB8fCBkZWZpbmVkKENPTkZJR19NNTI3eCkKLQlfX2FzbV9fIF9fdm9sYXRpbGVfXyAoCi0JCSJtb3ZlbAkjMHg4MTQwMDEwMCwgJSVkMFxuXHQiCisJCSJtb3ZlbAklMCwgJSVkMFxuXHQiCiAJCSJtb3ZlYwklJWQwLCAlJUNBQ1Jcblx0IgogCQkibm9wXG5cdCIKLQkJOiA6IDogImQwIiApOwotI2VuZGlmIC8qIENPTkZJR19NNTIzeCB8fCBDT05GSUdfTTUyN3ggKi8KLSNpZiBkZWZpbmVkKENPTkZJR19NNTI4eCkKLQlfX2FzbV9fIF9fdm9sYXRpbGVfXyAoCi0JCSJtb3ZlbAkjMHg4MTAwMDIwMCwgJSVkMFxuXHQiCi0JCSJtb3ZlYwklJWQwLCAlJUNBQ1Jcblx0IgotCQkibm9wXG5cdCIKLQkJOiA6IDogImQwIiApOwotI2VuZGlmIC8qIENPTkZJR19NNTI4eCAqLwotI2lmIGRlZmluZWQoQ09ORklHX001MjA2KSB8fCBkZWZpbmVkKENPTkZJR19NNTIwNmUpIHx8IGRlZmluZWQoQ09ORklHX001MjcyKQotCV9fYXNtX18gX192b2xhdGlsZV9fICgKLQkJIm1vdmVsCSMweDgxMDAwMTAwLCAlJWQwXG5cdCIKLQkJIm1vdmVjCSUlZDAsICUlQ0FDUlxuXHQiCi0JCSJub3Bcblx0IgotCQk6IDogOiAiZDAiICk7Ci0jZW5kaWYgLyogQ09ORklHX001MjA2IHx8IENPTkZJR19NNTIwNmUgfHwgQ09ORklHX001MjcyICovCi0jaWZkZWYgQ09ORklHX001MjQ5Ci0JX19hc21fXyBfX3ZvbGF0aWxlX18gKAotCQkibW92ZWwJIzB4YTEwMDAyMDAsICUlZDBcblx0IgotCQkibW92ZWMJJSVkMCwgJSVDQUNSXG5cdCIKLQkJIm5vcFxuXHQiCi0JCTogOiA6ICJkMCIgKTsKLSNlbmRpZiAvKiBDT05GSUdfTTUyNDkgKi8KLSNpZmRlZiBDT05GSUdfTTUzMngKLQlfX2FzbV9fIF9fdm9sYXRpbGVfXyAoCi0JCSJtb3ZlbAkjMHg4MTAwMDIwMCwgJSVkMFxuXHQiCi0JCSJtb3ZlYwklJWQwLCAlJUNBQ1Jcblx0IgotCQkibm9wXG5cdCIKLQkJOiA6IDogImQwIiApOwotI2VuZGlmIC8qIENPTkZJR19NNTMyeCAqLworCQk6IDogImkiIChDQUNIRV9JTlZBTElEQVRFKSA6ICJkMCIgKTsKKyNlbmRpZgogfQogCisvKgorICogU29tZSBDb2xkRmlyZSBwYXJ0cyBpbXBsZW1lbnQgc2VwYXJhdGUgaW5zdHJ1Y3Rpb24gYW5kIGRhdGEgY2FjaGVzLAorICogb24gdGhvc2Ugd2Ugc2hvdWxkIGp1c3QgZmx1c2ggdGhlIGFwcHJvcHJpYXRlIGNhY2hlLiBJZiB3ZSBkb24ndCBuZWVkCisgKiB0byBkbyBhbnkgc3BlY2lmaWMgZmx1c2hpbmcgdGhlbiB0aGlzIHdpbGwgYmUgb3B0aW1pemVkIGF3YXkuCisgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZCBfX2ZsdXNoX2ljYWNoZV9hbGwodm9pZCkKK3sKKyNpZmRlZiBDQUNIRV9JTlZBTElEQVRFSQorCV9fYXNtX18gX192b2xhdGlsZV9fICgKKwkJIm1vdmVsCSUwLCAlJWQwXG5cdCIKKwkJIm1vdmVjCSUlZDAsICUlQ0FDUlxuXHQiCisJCSJub3Bcblx0IgorCQk6IDogImkiIChDQUNIRV9JTlZBTElEQVRFSSkgOiAiZDAiICk7CisjZW5kaWYKK30KKworc3RhdGljIGlubGluZSB2b2lkIF9fZmx1c2hfZGNhY2hlX2FsbCh2b2lkKQoreworI2lmZGVmIENBQ0hFX1BVU0gKKwltY2ZfY2FjaGVfcHVzaCgpOworI2VuZGlmCisjaWZkZWYgQ0FDSEVfSU5WQUxJREFURUQKKwlfX2FzbV9fIF9fdm9sYXRpbGVfXyAoCisJCSJtb3ZlbAklMCwgJSVkMFxuXHQiCisJCSJtb3ZlYwklJWQwLCAlJUNBQ1Jcblx0IgorCQkibm9wXG5cdCIKKwkJOiA6ICJpIiAoQ0FDSEVfSU5WQUxJREFURUQpIDogImQwIiApOworI2Vsc2UKKwkvKiBGbHVzaCB0aGUgd3J0aXRlIGJ1ZmZlciAqLworCV9fYXNtX18gX192b2xhdGlsZV9fICggIm5vcCIgKTsKKyNlbmRpZgorfQogI2VuZGlmIC8qIF9NNjhLTk9NTVVfQ0FDSEVGTFVTSF9IICovCmRpZmYgLS1naXQgYS9hcmNoL202OGsvaW5jbHVkZS9hc20vY29sZGZpcmUuaCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9jb2xkZmlyZS5oCmluZGV4IDNiMGEzNGQuLjIxMzAyOGMgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9jb2xkZmlyZS5oCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9jb2xkZmlyZS5oCkBAIC0zMiw3ICszMiw3IEBACiAgKi8KICNkZWZpbmUJTUNGX01CQVIJMHgxMDAwMDAwMAogI2RlZmluZQlNQ0ZfTUJBUjIJMHg4MDAwMDAwMAotI2lmIGRlZmluZWQoQ09ORklHX001NDh4KQorI2lmIGRlZmluZWQoQ09ORklHX001NHh4KQogI2RlZmluZQlNQ0ZfSVBTQkFSCU1DRl9NQkFSCiAjZWxpZiBkZWZpbmVkKENPTkZJR19NNTIweCkKICNkZWZpbmUJTUNGX0lQU0JBUgkweEZDMDAwMDAwCmRpZmYgLS1naXQgYS9hcmNoL202OGsvaW5jbHVkZS9hc20vZW50cnlfbm8uaCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9lbnRyeV9uby5oCmluZGV4IDI2YmUyNzcuLjYyN2Q2OWIgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9lbnRyeV9uby5oCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9lbnRyeV9uby5oCkBAIC00MiwxMiArNDIsMTYgQEAKICAqLwogCiAjaWZkZWYgQ09ORklHX0NPTERGSVJFCisjaWZkZWYgQ09ORklHX0NPTERGSVJFX1NXX0E3CiAvKgotICogVGhpcyBpcyBtYWRlIGEgbGl0dGxlIG1vcmUgdHJpY2t5IG9uIHRoZSBDb2xkRmlyZS4gVGhlcmUgaXMgbm8KLSAqIHNlcGFyYXRlIGtlcm5lbCBhbmQgdXNlciBzdGFjayBwb2ludGVycy4gTmVlZCB0byBhcnRpZmljaWFsbHkKKyAqIFRoaXMgaXMgbWFkZSBhIGxpdHRsZSBtb3JlIHRyaWNreSBvbiBvbGRlciBDb2xkRmlyZXMuIFRoZXJlIGlzIG5vCisgKiBzZXBhcmF0ZSBzdXBlcnZpc29yIGFuZCB1c2VyIHN0YWNrIHBvaW50ZXJzLiBOZWVkIHRvIGFydGlmaWNpYWxseQogICogY29uc3RydWN0IGEgdXNwIGluIHNvZnR3YXJlLi4uIFdoZW4gZG9pbmcgdGhpcyB3ZSBuZWVkIHRvIGRpc2FibGUKLSAqIGludGVycnVwdHMsIG90aGVyd2lzZSBiYWQgdGhpbmdzIGNvdWxkIGhhcHBlbi4KKyAqIGludGVycnVwdHMsIG90aGVyd2lzZSBiYWQgdGhpbmdzIHdpbGwgaGFwcGVuLgogICovCisuZ2xvYmwgc3dfdXNwCisuZ2xvYmwgc3dfa3NwCisKIC5tYWNybyBTQVZFX0FMTAogCW1vdmUJIzB4MjcwMCwlc3IJCS8qIGRpc2FibGUgaW50cnMgKi8KIAlidHN0CSM1LCVzcEAoMikJCS8qIGZyb20gdXNlcj8gKi8KQEAgLTc0LDkgKzc4LDcgQEAKIAk3OgogLmVuZG0KIAotLm1hY3JvIFJFU1RPUkVfQUxMCi0JYnRzdAkjNSwlc3BAKFBUX1NSKQkJLyogZ29pbmcgdXNlcj8gKi8KLQlibmVzCThmCQkJLyogbm8sIHNraXAgKi8KKy5tYWNybyBSRVNUT1JFX1VTRVIKIAltb3ZlCSMweDI3MDAsJXNyCQkvKiBkaXNhYmxlIGludHJzICovCiAJbW92ZWwJc3dfdXNwLCVhMAkJLyogZ2V0IHVzcCAqLwogCW1vdmVsCSVzcEAoUFRfT0ZGX1BDKSwlYTBALQkvKiBjb3B5IGV4Y2VwdGlvbiBwcm9ncmFtIGNvdW50ZXIgKi8KQEAgLTkxLDE5ICs5MywyMiBAQAogCXN1YnFsCSM4LHN3X3VzcAkJLyogc2V0IGV4Y2VwdGlvbiAqLwogCW1vdmVsCXN3X3VzcCwlc3AJCS8qIHJlc3RvcmUgdXNwICovCiAJcnRlCi0JODoKLQltb3ZlbWwJJXNwQCwlZDEtJWQ1LyVhMC0lYTIKLQlsZWEJJXNwQCgzMiksJXNwCQkvKiBzcGFjZSBmb3IgOCByZWdzICovCi0JbW92ZWwJJXNwQCssJWQwCi0JYWRkcWwJIzQsJXNwCQkJLyogb3JpZyBkMCAqLwotCWFkZGwJJXNwQCssJXNwCQkvKiBzdGthZGogKi8KLQlydGUKIC5lbmRtCiAKKy5tYWNybyBSRFVTUAorCW1vdmVsCXN3X3VzcCwlYTIKKy5lbmRtCisKKy5tYWNybyBXUlVTUAorCW1vdmVsCSVhMCxzd191c3AKKy5lbmRtCisKKyNlbHNlIC8qICFDT05GSUdfQ09MREZJUkVfU1dfQTcgKi8KIC8qCi0gKiBRdWljayBleGNlcHRpb24gc2F2ZSwgdXNlIGN1cnJlbnQgc3RhY2sgb25seS4KKyAqIE1vZGVybiBDb2xkRmlyZSBwYXJ0cyBoYXZlIHNlcGFyYXRlIHN1cGVydmlzb3IgYW5kIHVzZXIgc3RhY2sKKyAqIHBvaW50ZXJzLiBTaW1wbGUgbG9hZCBhbmQgcmVzdG9yZSBtYWNyb3MgZm9yIHRoaXMgY2FzZS4KICAqLwotLm1hY3JvIFNBVkVfTE9DQUwKKy5tYWNybyBTQVZFX0FMTAogCW1vdmUJIzB4MjcwMCwlc3IJCS8qIGRpc2FibGUgaW50cnMgKi8KIAljbHJsCSVzcEAtCQkJLyogc3RrYWRqICovCiAJbW92ZWwJJWQwLCVzcEAtCQkvKiBvcmlnIGQwICovCkBAIC0xMTIsNyArMTE3LDcgQEAKIAltb3ZlbWwJJWQxLSVkNS8lYTAtJWEyLCVzcEAKIC5lbmRtCiAKLS5tYWNybyBSRVNUT1JFX0xPQ0FMCisubWFjcm8gUkVTVE9SRV9VU0VSCiAJbW92ZW1sCSVzcEAsJWQxLSVkNS8lYTAtJWEyCiAJbGVhCSVzcEAoMzIpLCVzcAkJLyogc3BhY2UgZm9yIDggcmVncyAqLwogCW1vdmVsCSVzcEArLCVkMApAQCAtMTIxLDYgKzEyNiwxOCBAQAogCXJ0ZQogLmVuZG0KIAorLm1hY3JvIFJEVVNQCisJLyptb3ZlCSV1c3AsJWEyKi8KKwkud29yZAkweDRlNmEKKy5lbmRtCisKKy5tYWNybyBXUlVTUAorCS8qbW92ZQklYTAsJXVzcCovCisJLndvcmQJMHg0ZTYwCisuZW5kbQorCisjZW5kaWYgLyogIUNPTkZJR19DT0xERklSRV9TV19BNyAqLworCiAubWFjcm8gU0FWRV9TV0lUQ0hfU1RBQ0sKIAlsZWEJJXNwQCgtMjQpLCVzcAkJLyogNiByZWdzICovCiAJbW92ZW1sCSVhMy0lYTYvJWQ2LSVkNywlc3BACkBAIC0xMzEsMTQgKzE0OCw2IEBACiAJbGVhCSVzcEAoMjQpLCVzcAkJLyogNiByZWdzICovCiAuZW5kbQogCi0vKgotICogU29mdHdhcmUgY29weSBvZiB0aGUgdXNlciBhbmQga2VybmVsIHN0YWNrIHBvaW50ZXJzLi4uIFVnaC4uLgotICogTmVlZCB0aGVzZSB0byBnZXQgYXJvdW5kIENvbGRGaXJlIG5vdCBoYXZpbmcgc2VwYXJhdGUga2VybmVsCi0gKiBhbmQgdXNlciBzdGFjayBwb2ludGVycy4KLSAqLwotLmdsb2JsIHN3X3VzcAotLmdsb2JsIHN3X2tzcAotCiAjZWxzZSAvKiAhQ09ORklHX0NPTERGSVJFICovCiAKIC8qCkBAIC0xNjcsNiArMTc2LDYgQEAKIAltb3ZlbWwJJXNwQCssJWEzLSVhNi8lZDYtJWQ3CiAuZW5kbQogCi0jZW5kaWYgLyogIUNPTkZJR19DT0xERklSRSAqLworI2VuZGlmIC8qICFDT0xERklSRV9TV19BNyAqLwogI2VuZGlmIC8qIF9fQVNTRU1CTFlfXyAqLwogI2VuZGlmIC8qIF9fTTY4S05PTU1VX0VOVFJZX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9ncGlvLmggYi9hcmNoL202OGsvaW5jbHVkZS9hc20vZ3Bpby5oCmluZGV4IDFiNTdhZGIuLmM2NGM3YjcgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9ncGlvLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2dwaW8uaApAQCAtMzcsNyArMzcsNyBAQAogI2lmIGRlZmluZWQoQ09ORklHX001MjA2KSB8fCBkZWZpbmVkKENPTkZJR19NNTIwNmUpIHx8IFwKICAgICBkZWZpbmVkKENPTkZJR19NNTIweCkgfHwgZGVmaW5lZChDT05GSUdfTTUyM3gpIHx8IFwKICAgICBkZWZpbmVkKENPTkZJR19NNTI3eCkgfHwgZGVmaW5lZChDT05GSUdfTTUyOHgpIHx8IFwKLSAgICBkZWZpbmVkKENPTkZJR19NNTMyeCkgfHwgZGVmaW5lZChDT05GSUdfTTU0OHgpCisgICAgZGVmaW5lZChDT05GSUdfTTUzMngpIHx8IGRlZmluZWQoQ09ORklHX001NHh4KQogCiAvKiBUaGVzZSBwYXJ0cyBoYXZlIEdQSU8gb3JnYW5pemVkIGJ5IDggYml0IHBvcnRzICovCiAKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9pb19uby5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2lvX25vLmgKaW5kZXggNmUyNDEzZS4uY2YyMGYzMCAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2lvX25vLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL2lvX25vLmgKQEAgLTE0NSw3ICsxNDUsNiBAQAogI2RlZmluZSBJT01BUF9XUklURVRIUk9VR0gJCTMKIAogZXh0ZXJuIHZvaWQgKl9faW9yZW1hcCh1bnNpZ25lZCBsb25nIHBoeXNhZGRyLCB1bnNpZ25lZCBsb25nIHNpemUsIGludCBjYWNoZWZsYWcpOwotZXh0ZXJuIHZvaWQgX19pb3VubWFwKHZvaWQgKmFkZHIsIHVuc2lnbmVkIGxvbmcgc2l6ZSk7CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCAqaW9yZW1hcCh1bnNpZ25lZCBsb25nIHBoeXNhZGRyLCB1bnNpZ25lZCBsb25nIHNpemUpCiB7CmRpZmYgLS1naXQgYS9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUyMDZzaW0uaCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTIwNnNpbS5oCmluZGV4IDljMzg0ZTIuLjU2MWIwM2I1IDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUyMDZzaW0uaAorKysgYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUyMDZzaW0uaApAQCAtMTIsNiArMTIsMTAgQEAKICNkZWZpbmUJbTUyMDZzaW1faAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKKyNkZWZpbmUJQ1BVX05BTUUJCSJDT0xERklSRShtNTIwNikiCisjZGVmaW5lCUNQVV9JTlNUUl9QRVJfSklGRlkJMworCisjaW5jbHVkZSA8YXNtL201Mnh4YWNyLmg+CiAKIC8qCiAgKglEZWZpbmUgdGhlIDUyMDYgU0lNIHJlZ2lzdGVyIHNldCBhZGRyZXNzZXMuCkBAIC04OCw2ICs5MiwxNCBAQAogI2RlZmluZQlNQ0ZTSU1fUEFERFIJCShNQ0ZfTUJBUiArIDB4MWM1KQkvKiBQYXJhbGxlbCBEaXJlY3Rpb24gKHIvdykgKi8KICNkZWZpbmUJTUNGU0lNX1BBREFUCQkoTUNGX01CQVIgKyAweDFjOSkJLyogUGFyYWxsZWwgUG9ydCBWYWx1ZSAoci93KSAqLwogCisjaWYgZGVmaW5lZChDT05GSUdfTkVUdGVsKQorI2RlZmluZQlNQ0ZVQVJUX0JBU0UxCQkweDE4MAkJLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQxICovCisjZGVmaW5lCU1DRlVBUlRfQkFTRTIJCTB4MTQwCQkvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDIgKi8KKyNlbHNlCisjZGVmaW5lCU1DRlVBUlRfQkFTRTEJCTB4MTQwCQkvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDEgKi8KKyNkZWZpbmUJTUNGVUFSVF9CQVNFMgkJMHgxODAJCS8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMiAqLworI2VuZGlmCisKIC8qCiAgKglEZWZpbmUgc3lzdGVtIHBlcmlwaGVyYWwgSVJRIHVzYWdlLgogICovCkBAIC05NSw3ICsxMDcsNyBAQAogI2RlZmluZQlNQ0ZfSVJRX1BST0ZJTEVSCTMxCQkvKiBUaW1lcjEsIExldmVsIDcgKi8KIAogLyoKLSAqIEdlbmVyaWMgR1BJTworICoJR2VuZXJpYyBHUElPCiAgKi8KICNkZWZpbmUgTUNGR1BJT19QSU5fTUFYCQk4CiAjZGVmaW5lIE1DRkdQSU9fSVJRX1ZFQ0JBU0UJLTEKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTIweHNpbS5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MjB4c2ltLmgKaW5kZXggZGI4MjRhNC4uODhlZDgyMyAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MjB4c2ltLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MjB4c2ltLmgKQEAgLTExLDYgKzExLDExIEBACiAjZGVmaW5lIG01MjB4c2ltX2gKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCisjZGVmaW5lCUNQVV9OQU1FCQkiQ09MREZJUkUobTUyMHgpIgorI2RlZmluZQlDUFVfSU5TVFJfUEVSX0pJRkZZCTMKKworI2luY2x1ZGUgPGFzbS9tNTJ4eGFjci5oPgorCiAvKgogICogIERlZmluZSB0aGUgNTIweCBTSU0gcmVnaXN0ZXIgc2V0IGFkZHJlc3Nlcy4KICAqLwpAQCAtNTQsNiArNTksOSBAQAogI2RlZmluZSBNQ0ZTSU1fU0RDUzAgICAgICAgIDB4MDAwYTgxMTAJLyogU0RSQU0gQ2hpcCBTZWxlY3QgMCBDb25maWd1cmF0aW9uICovCiAjZGVmaW5lIE1DRlNJTV9TRENTMSAgICAgICAgMHgwMDBhODExNAkvKiBTRFJBTSBDaGlwIFNlbGVjdCAxIENvbmZpZ3VyYXRpb24gKi8KIAorLyoKKyAqIEVQT1JUIGFuZCBHUElPIHJlZ2lzdGVycy4KKyAqLwogI2RlZmluZSBNQ0ZFUE9SVF9FUEREUgkJCTB4RkMwODgwMDIKICNkZWZpbmUgTUNGRVBPUlRfRVBEUgkJCTB4RkMwODgwMDQKICNkZWZpbmUgTUNGRVBPUlRfRVBQRFIJCQkweEZDMDg4MDA1CkBAIC05Nyw2ICsxMDUsNyBAQAogI2RlZmluZSBNQ0ZHUElPX1BDTFJSX1VBUlQJCTB4RkMwQTQwMkEKICNkZWZpbmUgTUNGR1BJT19QQ0xSUl9GRUNICQkweEZDMEE0MDJCCiAjZGVmaW5lIE1DRkdQSU9fUENMUlJfRkVDTAkJMHhGQzBBNDAyQworCiAvKgogICogR2VuZXJpYyBHUElPIHN1cHBvcnQKICAqLwpAQCAtMTA5LDcgKzExOCw2IEBACiAjZGVmaW5lIE1DRkdQSU9fUElOX01BWAkJCTgwCiAjZGVmaW5lIE1DRkdQSU9fSVJRX01BWAkJCTgKICNkZWZpbmUgTUNGR1BJT19JUlFfVkVDQkFTRQkJTUNGSU5UX1ZFQ0JBU0UKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAjZGVmaW5lIE1DRl9HUElPX1BBUl9VQVJUICAgICAgICAgICAgICAgICAgICgweEE0MDM2KQogI2RlZmluZSBNQ0ZfR1BJT19QQVJfRkVDSTJDICAgICAgICAgICAgICAgICAoMHhBNDAzMykKQEAgLTEyNiw2ICsxMzQsMTMgQEAKICNkZWZpbmUgTUNGX0dQSU9fUEFSX0ZFQ0kyQ19QQVJfU0NMX1VUWEQyICAgKDB4MDQpCiAKIC8qCisgKiAgVUFSVCBtb2R1bGUuCisgKi8KKyNkZWZpbmUgTUNGVUFSVF9CQVNFMQkJMHg2MDAwMAkJLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQxICovCisjZGVmaW5lIE1DRlVBUlRfQkFTRTIJCTB4NjQwMDAJCS8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMiAqLworI2RlZmluZSBNQ0ZVQVJUX0JBU0UzCQkweDY4MDAwCQkvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDIgKi8KKworLyoKICAqICBSZXNldCBDb250cm9sbCBVbml0LgogICovCiAjZGVmaW5lCU1DRl9SQ1IJCQkweEZDMEEwMDAwCmRpZmYgLS1naXQgYS9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUyM3hzaW0uaCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTIzeHNpbS5oCmluZGV4IGU4ZDA2YjIuLjRhZDdhMDAgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTIzeHNpbS5oCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTIzeHNpbS5oCkBAIC0xMSw2ICsxMSwxMCBAQAogI2RlZmluZQltNTIzeHNpbV9oCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAorI2RlZmluZQlDUFVfTkFNRQkJIkNPTERGSVJFKG01MjN4KSIKKyNkZWZpbmUJQ1BVX0lOU1RSX1BFUl9KSUZGWQkzCisKKyNpbmNsdWRlIDxhc20vbTUyeHhhY3IuaD4KIAogLyoKICAqCURlZmluZSB0aGUgNTIzeCBTSU0gcmVnaXN0ZXIgc2V0IGFkZHJlc3Nlcy4KQEAgLTUwLDYgKzU0LDEzIEBACiAjZGVmaW5lCU1DRl9SQ1JfU1dSRVNFVAkJMHg4MAkJLyogU29mdHdhcmUgcmVzZXQgYml0ICovCiAjZGVmaW5lCU1DRl9SQ1JfRlJDU1RPVVQJMHg0MAkJLyogRm9yY2UgZXh0ZXJuYWwgcmVzZXQgKi8KIAorLyoKKyAqICBVQVJUIG1vZHVsZS4KKyAqLworI2RlZmluZSBNQ0ZVQVJUX0JBU0UxCQkweDIwMCAgICAgICAgICAgLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQxICovCisjZGVmaW5lIE1DRlVBUlRfQkFTRTIJCTB4MjQwICAgICAgICAgICAvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDIgKi8KKyNkZWZpbmUgTUNGVUFSVF9CQVNFMwkJMHgyODAgICAgICAgICAgIC8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMyAqLworCiAjZGVmaW5lIE1DRkdQSU9fUE9EUl9BRERSCShNQ0ZfSVBTQkFSICsgMHgxMDAwMDApCiAjZGVmaW5lIE1DRkdQSU9fUE9EUl9EQVRBSAkoTUNGX0lQU0JBUiArIDB4MTAwMDAxKQogI2RlZmluZSBNQ0ZHUElPX1BPRFJfREFUQUwJKE1DRl9JUFNCQVIgKyAweDEwMDAwMikKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTI0OXNpbS5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MjQ5c2ltLmgKaW5kZXggNzliN2I0MC4uNDkwOGIxMSAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MjQ5c2ltLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MjQ5c2ltLmgKQEAgLTExLDYgKzExLDExIEBACiAjZGVmaW5lCW01MjQ5c2ltX2gKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCisjZGVmaW5lCUNQVV9OQU1FCQkiQ09MREZJUkUobTUyNDkpIgorI2RlZmluZQlDUFVfSU5TVFJfUEVSX0pJRkZZCTMKKworI2luY2x1ZGUgPGFzbS9tNTJ4eGFjci5oPgorCiAvKgogICoJRGVmaW5lIHRoZSA1MjQ5IFNJTSByZWdpc3RlciBzZXQgYWRkcmVzc2VzLgogICovCkBAIC01Niw2ICs2MSwxMSBAQAogI2RlZmluZSBNQ0ZTSU1fREFDUjEJCTB4MTEwCQkvKiBEUkFNIDEgQWRkciBhbmQgQ3RybCAoci93KSAqLwogI2RlZmluZSBNQ0ZTSU1fRE1SMQkJMHgxMTQJCS8qIERSQU0gMSBNYXNrIHJlZyAoci93KSAqLwogCisvKgorICoJVUFSVCBtb2R1bGUuCisgKi8KKyNkZWZpbmUgTUNGVUFSVF9CQVNFMQkJMHgxYzAgICAgICAgICAgIC8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMSAqLworI2RlZmluZSBNQ0ZVQVJUX0JBU0UyCQkweDIwMCAgICAgICAgICAgLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQyICovCiAKIC8qCiAgKglTb21lIHN5bWJvbCBkZWZpbmVzIGZvciB0aGUgYWJvdmUuLi4KZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTI3MnNpbS5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201Mjcyc2ltLmgKaW5kZXggZGYzMzMyYy4uYjdjYzUwYSAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201Mjcyc2ltLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201Mjcyc2ltLmgKQEAgLTEyLDYgKzEyLDExIEBACiAjZGVmaW5lCW01Mjcyc2ltX2gKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCisjZGVmaW5lCUNQVV9OQU1FCQkiQ09MREZJUkUobTUyNzIpIgorI2RlZmluZQlDUFVfSU5TVFJfUEVSX0pJRkZZCTMKKworI2luY2x1ZGUgPGFzbS9tNTJ4eGFjci5oPgorCiAvKgogICoJRGVmaW5lIHRoZSA1MjcyIFNJTSByZWdpc3RlciBzZXQgYWRkcmVzc2VzLgogICovCkBAIC02Miw2ICs2Nyw5IEBACiAjZGVmaW5lCU1DRlNJTV9EQ01SMQkJMHg1YwkJLyogRFJBTSAxIE1hc2sgcmVnIChyL3cpICovCiAjZGVmaW5lCU1DRlNJTV9EQ0NSMQkJMHg2MwkJLyogRFJBTSAxIENvbnRyb2wgcmVnIChyL3cpICovCiAKKyNkZWZpbmUJTUNGVUFSVF9CQVNFMQkJMHgxMDAJCS8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMSAqLworI2RlZmluZQlNQ0ZVQVJUX0JBU0UyCQkweDE0MAkJLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQyICovCisKICNkZWZpbmUJTUNGU0lNX1BBQ05UCQkoTUNGX01CQVIgKyAweDgwKSAvKiBQb3J0IEEgQ29udHJvbCAoci93KSAqLwogI2RlZmluZQlNQ0ZTSU1fUEFERFIJCShNQ0ZfTUJBUiArIDB4ODQpIC8qIFBvcnQgQSBEaXJlY3Rpb24gKHIvdykgKi8KICNkZWZpbmUJTUNGU0lNX1BBREFUCQkoTUNGX01CQVIgKyAweDg2KSAvKiBQb3J0IEEgRGF0YSAoci93KSAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201Mjd4c2ltLmggYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUyN3hzaW0uaAppbmRleCAxZmViNDZmLi5lODA0MmU4IDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUyN3hzaW0uaAorKysgYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUyN3hzaW0uaApAQCAtMTEsNiArMTEsMTAgQEAKICNkZWZpbmUJbTUyN3hzaW1faAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKKyNkZWZpbmUJQ1BVX05BTUUJCSJDT0xERklSRShtNTI3eCkiCisjZGVmaW5lCUNQVV9JTlNUUl9QRVJfSklGRlkJMworCisjaW5jbHVkZSA8YXNtL201Mnh4YWNyLmg+CiAKIC8qCiAgKglEZWZpbmUgdGhlIDUyNzAvNTI3MSBTSU0gcmVnaXN0ZXIgc2V0IGFkZHJlc3Nlcy4KQEAgLTU1LDYgKzU5LDEyIEBACiAjZGVmaW5lCU1DRlNJTV9ETVIxCQkweDVjCQkvKiBTRFJBTSBhZGRyZXNzIG1hc2sgMSAqLwogI2VuZGlmCiAKKy8qCisgKglVQVJUIG1vZHVsZS4KKyAqLworI2RlZmluZSBNQ0ZVQVJUX0JBU0UxCQkweDIwMCAgICAgICAgICAgLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQxICovCisjZGVmaW5lIE1DRlVBUlRfQkFTRTIJCTB4MjQwICAgICAgICAgICAvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDIgKi8KKyNkZWZpbmUgTUNGVUFSVF9CQVNFMwkJMHgyODAgICAgICAgICAgIC8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMyAqLwogCiAjaWZkZWYgQ09ORklHX001MjcxCiAjZGVmaW5lIE1DRkdQSU9fUE9EUl9BRERSCShNQ0ZfSVBTQkFSICsgMHgxMDAwMDApCmRpZmYgLS1naXQgYS9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUyOHhzaW0uaCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTI4eHNpbS5oCmluZGV4IDg5MWNiZWQuLmE2ZDJmNGQgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTI4eHNpbS5oCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTI4eHNpbS5oCkBAIC0xMSw2ICsxMSwxMCBAQAogI2RlZmluZQltNTI4eHNpbV9oCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAorI2RlZmluZQlDUFVfTkFNRQkJIkNPTERGSVJFKG01Mjh4KSIKKyNkZWZpbmUJQ1BVX0lOU1RSX1BFUl9KSUZGWQkzCisKKyNpbmNsdWRlIDxhc20vbTUyeHhhY3IuaD4KIAogLyoKICAqCURlZmluZSB0aGUgNTI4MC81MjgyIFNJTSByZWdpc3RlciBzZXQgYWRkcmVzc2VzLgpAQCAtNDIsNiArNDYsMTMgQEAKICNkZWZpbmUJTUNGU0lNX0RNUjEJCTB4NTQJCS8qIFNEUkFNIGFkZHJlc3MgbWFzayAxICovCiAKIC8qCisgKglVQVJUIG1vZHVsZS4KKyAqLworI2RlZmluZSBNQ0ZVQVJUX0JBU0UxCQkweDIwMCAgICAgICAgICAgLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQxICovCisjZGVmaW5lIE1DRlVBUlRfQkFTRTIJCTB4MjQwICAgICAgICAgICAvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDIgKi8KKyNkZWZpbmUgTUNGVUFSVF9CQVNFMwkJMHgyODAgICAgICAgICAgIC8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMyAqLworCisvKgogICogCUdQSU8gcmVnaXN0ZXJzCiAgKi8KICNkZWZpbmUgTUNGR1BJT19QT1JUQQkJKE1DRl9JUFNCQVIgKyAweDAwMTAwMDAwKQpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201Mnh4YWNyLmggYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUyeHhhY3IuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hYmMzOTFhCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201Mnh4YWNyLmgKQEAgLTAsMCArMSw5NCBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKy8qCisgKiBtNTJ4eGFjci5oIC0tIENvbGRGaXJlIHZlcnNpb24gMiBjb3JlIGNhY2hlIHN1cHBvcnQKKyAqCisgKiAoQykgQ29weXJpZ2h0IDIwMTAsIEdyZWcgVW5nZXJlciA8Z2VyZ0BzbmFwZ2Vhci5jb20+CisgKi8KKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisjaWZuZGVmIG01Mnh4YWNyX2gKKyNkZWZpbmUgbTUyeHhhY3JfaAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKy8qCisgKiBBbGwgdmFyaWVudHMgb2YgdGhlIENvbGRGaXJlIHVzaW5nIHZlcnNpb24gMiBjb3JlcyBoYXZlIGEgc2ltaWxhcgorICogY2FjaGUgc2V0dXAuIEFsdGhvdWdoIG5vdCBhYnNvbHV0ZWx5IGlkZW50aWNhbCB0aGUgY2FjaGUgcmVnaXN0ZXIKKyAqIGRlZmluaXRpb25zIGFyZSBjb21wYXRpYmxlIGZvciBhbGwgb2YgdGhlbS4gTW9zdGx5IHRoZXkgc3VwcG9ydCBhCisgKiBjb25maWd1cmFibGUgY2FjaGUgbWVtb3J5IHRoYXQgY2FuIGJlIGluc3RydWN0aW9uIG9ubHksIGRhdGEgb25seSwKKyAqIG9yIHNwbGl0IGluc3RydWN0aW9uIGFuZCBkYXRhLiBUaGUgZXhjZXB0aW9uIGlzIHRoZSB2ZXJ5IG9sZCB2ZXJzaW9uIDIKKyAqIGNvcmUgYmFzZWQgcGFydHMsIGxpa2UgdGhlIDUyMDYoZSksIDUyNDkgYW5kIDUyNzIsIHdoaWNoIGFyZSBpbnN0cnVjdGlvbgorICogY2FjaGUgb25seS4gQ2FjaGUgc2l6ZSB2YXJpZXMgZnJvbSAyayB1cCB0byAxNmsuCisgKi8KKworLyoKKyAqIERlZmluZSB0aGUgQ2FjaGUgQ29udHJvbCByZWdpc3RlciBmbGFncy4KKyAqLworI2RlZmluZSBDQUNSX0NFTkIJMHg4MDAwMDAwMAkvKiBFbmFibGUgY2FjaGUgKi8KKyNkZWZpbmUgQ0FDUl9DRFBJCTB4MTAwMDAwMDAJLyogRGlzYWJsZSBpbnZhbGlkYXRpb24gYnkgQ1BVU0hMICovCisjZGVmaW5lIENBQ1JfQ0ZSWgkweDA4MDAwMDAwCS8qIENhY2hlIGZyZWV6ZSBtb2RlICovCisjZGVmaW5lIENBQ1JfQ0lOVgkweDAxMDAwMDAwCS8qIEludmFsaWRhdGUgY2FjaGUgKi8KKyNkZWZpbmUgQ0FDUl9ESVNJCTB4MDA4MDAwMDAJLyogRGlzYWJsZSBpbnN0cnVjdGlvbiBjYWNoZSAqLworI2RlZmluZSBDQUNSX0RJU0QJMHgwMDQwMDAwMAkvKiBEaXNhYmxlIGRhdGEgY2FjaGUgKi8KKyNkZWZpbmUgQ0FDUl9JTlZJCTB4MDAyMDAwMDAJLyogSW52YWxpZGF0ZSBpbnN0cnVjdGlvbiBjYWNoZSAqLworI2RlZmluZSBDQUNSX0lOVkQJMHgwMDEwMDAwMAkvKiBJbnZhbGlkYXRlIGRhdGEgY2FjaGUgKi8KKyNkZWZpbmUgQ0FDUl9DRUlCCTB4MDAwMDA0MDAJLyogTm9uLWNhY2hhYmxlIGluc3RydWN0aW9uIGJ1cnN0ICovCisjZGVmaW5lIENBQ1JfRENNCTB4MDAwMDAyMDAJLyogRGVmYXVsdCBjYWNoZSBtb2RlICovCisjZGVmaW5lIENBQ1JfREJXRQkweDAwMDAwMTAwCS8qIEJ1ZmZlcmVkIHdyaXRlIGVuYWJsZSAqLworI2RlZmluZSBDQUNSX0RXUAkweDAwMDAwMDIwCS8qIFdyaXRlIHByb3RlY3Rpb24gKi8KKyNkZWZpbmUgQ0FDUl9FVVNQCTB4MDAwMDAwMTAJLyogRW5hYmxlIHNlcGFyYXRlIHVzZXIgYTcgKi8KKworLyoKKyAqIERlZmluZSB0aGUgQWNjZXNzIENvbnRyb2wgcmVnaXN0ZXIgZmxhZ3MuCisgKi8KKyNkZWZpbmUgQUNSX0JBU0VfUE9TCTI0CQkvKiBBZGRyZXNzIEJhc2UgKHVwcGVyIDggYml0cykgKi8KKyNkZWZpbmUgQUNSX01BU0tfUE9TCTE2CQkvKiBBZGRyZXNzIE1hc2sgKG5leHQgOCBiaXRzKSAqLworI2RlZmluZSBBQ1JfRU5BQkxFCTB4MDAwMDgwMDAJLyogRW5hYmxlIHRoaXMgQUNSICovCisjZGVmaW5lIEFDUl9VU0VSCTB4MDAwMDAwMDAJLyogQWxsb3cgb25seSB1c2VyIGFjY2Vzc2VzICovCisjZGVmaW5lIEFDUl9TVVBFUgkweDAwMDAyMDAwCS8qIEFsbG93IHN1cGVydmlzb3IgYWNjZXNzIG9ubHkgKi8KKyNkZWZpbmUgQUNSX0FOWQkJMHgwMDAwNDAwMAkvKiBBbGxvdyBhbnkgYWNjZXNzIHR5cGUgKi8KKyNkZWZpbmUgQUNSX0NFTkIJMHgwMDAwMDAwMAkvKiBDYWNoaW5nIG9mIHJlZ2lvbiBlbmFibGVkICovCisjZGVmaW5lIEFDUl9DRElTCTB4MDAwMDAwNDAJLyogQ2FjaGluZyBvZiByZWdpb24gZGlzYWJsZWQgKi8KKyNkZWZpbmUgQUNSX0JXRQkJMHgwMDAwMDAyMAkvKiBXcml0ZSBidWZmZXIgZW5hYmxlZCAqLworI2RlZmluZSBBQ1JfV1BST1RFQ1QJMHgwMDAwMDAwNAkvKiBXcml0ZSBwcm90ZWN0IHJlZ2lvbiAqLworCisvKgorICogU2V0IHRoZSBjYWNoZSBjb250cm9sbGVyIHNldHRpbmdzIHdlIHdpbGwgdXNlLiBPbiB0aGUgY29yZXMgdGhhdCBzdXBwb3J0CisgKiBhIHNwbGl0IGNhY2hlIGNvbmZpZ3VyYXRpb24gd2UgYWxsb3cgYWxsIHRoZSBjb21iaW5hdGlvbnMgYXQgS2NvbmZpZworICogdGltZS4gRm9yIHRob3NlIGNvcmVzIHRoYXQgb25seSBoYXZlIGFuIGluc3RydWN0aW9uIGNhY2hlIHdlIGp1c3Qgc2V0CisgKiB0aGF0IGFzIG9uLgorICovCisjaWYgZGVmaW5lZChDT05GSUdfQ0FDSEVfSSkKKyNkZWZpbmUgQ0FDSEVfVFlQRQkoQ0FDUl9ESVNEICsgQ0FDUl9FVVNQKQorI2RlZmluZSBDQUNIRV9JTlZUWVBFSQkwCisjZWxpZiBkZWZpbmVkKENPTkZJR19DQUNIRV9EKQorI2RlZmluZSBDQUNIRV9UWVBFCShDQUNSX0RJU0kgKyBDQUNSX0VVU1ApCisjZGVmaW5lIENBQ0hFX0lOVlRZUEVECTAKKyNlbGlmIGRlZmluZWQoQ09ORklHX0NBQ0hFX0JPVEgpCisjZGVmaW5lIENBQ0hFX1RZUEUJQ0FDUl9FVVNQCisjZGVmaW5lIENBQ0hFX0lOVlRZUEVJCUNBQ1JfSU5WSQorI2RlZmluZSBDQUNIRV9JTlZUWVBFRAlDQUNSX0lOVkQKKyNlbHNlCisvKiBUaGlzIGlzIHRoZSBpbnN0cnVjdGlvbiBjYWNoZSBvbmx5IGRldmljZXMgKG5vIHNwbGl0IGNhY2hlLCBubyBldXNwKSAqLworI2RlZmluZSBDQUNIRV9UWVBFCTAKKyNkZWZpbmUgQ0FDSEVfSU5WVFlQRUkJMAorI2VuZGlmCisKKyNkZWZpbmUgQ0FDSEVfSU5JVAkoQ0FDUl9DSU5WICsgQ0FDSEVfVFlQRSkKKyNkZWZpbmUgQ0FDSEVfTU9ERQkoQ0FDUl9DRU5CICsgQ0FDSEVfVFlQRSArIENBQ1JfRENNKQorCisjZGVmaW5lIENBQ0hFX0lOVkFMSURBVEUgIChDQUNIRV9NT0RFICsgQ0FDUl9DSU5WKQorI2lmIGRlZmluZWQoQ0FDSEVfSU5WVFlQRUkpCisjZGVmaW5lIENBQ0hFX0lOVkFMSURBVEVJIChDQUNIRV9NT0RFICsgQ0FDUl9DSU5WICsgQ0FDSEVfSU5WVFlQRUkpCisjZW5kaWYKKyNpZiBkZWZpbmVkKENBQ0hFX0lOVlRZUEVEKQorI2RlZmluZSBDQUNIRV9JTlZBTElEQVRFRCAoQ0FDSEVfTU9ERSArIENBQ1JfQ0lOViArIENBQ0hFX0lOVlRZUEVEKQorI2VuZGlmCisKKyNkZWZpbmUgQUNSMF9NT0RFCSgoQ09ORklHX1JBTUJBU0UgJiAweGZmMDAwMDAwKSArIFwKKwkJCSAoMHgwMDBmMDAwMCkgKyBcCisJCQkgKEFDUl9FTkFCTEUgKyBBQ1JfQU5ZICsgQUNSX0NFTkIgKyBBQ1JfQldFKSkKKyNkZWZpbmUgQUNSMV9NT0RFCTAKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisjZW5kaWYgIC8qIG01Mnh4c2ltX2ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTMwN3NpbS5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MzA3c2ltLmgKaW5kZXggYzY4MzBlNS4uMGJmNTczOSAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MzA3c2ltLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MzA3c2ltLmgKQEAgLTE0LDYgKzE0LDExIEBACiAjZGVmaW5lCW01MzA3c2ltX2gKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCisjZGVmaW5lCUNQVV9OQU1FCQkiQ09MREZJUkUobTUzMDcpIgorI2RlZmluZQlDUFVfSU5TVFJfUEVSX0pJRkZZCTMKKworI2luY2x1ZGUgPGFzbS9tNTN4eGFjci5oPgorCiAvKgogICoJRGVmaW5lIHRoZSA1MzA3IFNJTSByZWdpc3RlciBzZXQgYWRkcmVzc2VzLgogICovCkBAIC05NCw2ICs5OSwxNyBAQAogI2RlZmluZQlNQ0ZTSU1fUEFEQVQJCShNQ0ZfTUJBUiArIDB4MjQ4KQogCiAvKgorICogIFVBUlQgbW9kdWxlLgorICovCisjaWYgZGVmaW5lZChDT05GSUdfTkVUdGVsKSB8fCBkZWZpbmVkKENPTkZJR19TRUNVUkVFREdFTVAzKQorI2RlZmluZSBNQ0ZVQVJUX0JBU0UxCQkweDIwMCAgICAgICAgICAgLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQxICovCisjZGVmaW5lIE1DRlVBUlRfQkFTRTIJCTB4MWMwICAgICAgICAgICAvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDIgKi8KKyNlbHNlCisjZGVmaW5lIE1DRlVBUlRfQkFTRTEJCTB4MWMwICAgICAgICAgICAvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDEgKi8KKyNkZWZpbmUgTUNGVUFSVF9CQVNFMgkJMHgyMDAgICAgICAgICAgIC8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMiAqLworI2VuZGlmCisKKy8qCiAgKiBHZW5lcmljIEdQSU8gc3VwcG9ydAogICovCiAjZGVmaW5lIE1DRkdQSU9fUElOX01BWAkJCTE2CkBAIC0xNDYsMzIgKzE2Miw1IEBACiAjZGVmaW5lCU1DRl9JUlFfVElNRVIJCTMwCQkvKiBUaW1lcjAsIExldmVsIDYgKi8KICNkZWZpbmUJTUNGX0lSUV9QUk9GSUxFUgkzMQkJLyogVGltZXIxLCBMZXZlbCA3ICovCiAKLS8qCi0gKglEZWZpbmUgdGhlIENhY2hlIHJlZ2lzdGVyIGZsYWdzLgotICovCi0jZGVmaW5lCUNBQ1JfRUMJCQkoMTw8MzEpCi0jZGVmaW5lCUNBQ1JfRVNCCQkoMTw8MjkpCi0jZGVmaW5lCUNBQ1JfRFBJCQkoMTw8MjgpCi0jZGVmaW5lCUNBQ1JfSExDSwkJKDE8PDI3KQotI2RlZmluZQlDQUNSX0NJTlZBCQkoMTw8MjQpCi0jZGVmaW5lCUNBQ1JfRE5GQgkJKDE8PDEwKQotI2RlZmluZQlDQUNSX0RDTV9XVEhSVQkJKDA8PDgpCi0jZGVmaW5lCUNBQ1JfRENNX1dCQUNLCQkoMTw8OCkKLSNkZWZpbmUJQ0FDUl9EQ01fT0ZGX1BSRQkoMjw8OCkKLSNkZWZpbmUJQ0FDUl9EQ01fT0ZGX0lNUAkoMzw8OCkKLSNkZWZpbmUJQ0FDUl9EVwkJCSgxPDw1KQotCi0jZGVmaW5lCUFDUl9CQVNFX1BPUwkJMjQKLSNkZWZpbmUJQUNSX01BU0tfUE9TCQkxNgotI2RlZmluZQlBQ1JfRU5BQkxFCQkoMTw8MTUpCi0jZGVmaW5lCUFDUl9VU0VSCQkoMDw8MTMpCi0jZGVmaW5lCUFDUl9TVVBFUgkJKDE8PDEzKQotI2RlZmluZQlBQ1JfQU5ZCQkJKDI8PDEzKQotI2RlZmluZQlBQ1JfQ01fV1RIUlUJCSgwPDw1KQotI2RlZmluZQlBQ1JfQ01fV0JBQ0sJCSgxPDw1KQotI2RlZmluZQlBQ1JfQ01fT0ZGX1BSRQkJKDI8PDUpCi0jZGVmaW5lCUFDUl9DTV9PRkZfSU1QCQkoMzw8NSkKLSNkZWZpbmUJQUNSX1dQUk9URUNUCQkoMTw8MikKLQogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAjZW5kaWYJLyogbTUzMDdzaW1faCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201MzJ4c2ltLmggYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUzMnhzaW0uaAppbmRleCBjNGJmMWM4Li5lNjQ3MGY4IDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUzMnhzaW0uaAorKysgYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbTUzMnhzaW0uaApAQCAtOSw2ICs5LDExIEBACiAjZGVmaW5lCW01MzJ4c2ltX2gKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCisjZGVmaW5lCUNQVV9OQU1FCQkiQ09MREZJUkUobTUzMngpIgorI2RlZmluZQlDUFVfSU5TVFJfUEVSX0pJRkZZCTMKKworI2luY2x1ZGUgPGFzbS9tNTN4eGFjci5oPgorCiAjZGVmaW5lIE1DRl9SRUczMih4KSAoKih2b2xhdGlsZSB1bnNpZ25lZCBsb25nICAqKSh4KSkKICNkZWZpbmUgTUNGX1JFRzE2KHgpICgqKHZvbGF0aWxlIHVuc2lnbmVkIHNob3J0ICopKHgpKQogI2RlZmluZSBNQ0ZfUkVHMDgoeCkgKCoodm9sYXRpbGUgdW5zaWduZWQgY2hhciAgKikoeCkpCkBAIC03NCwzMSArNzksMTEgQEAKICNkZWZpbmUJTUNGX0lSUV9QUk9GSUxFUgkoNjQgKyAzMykJLyogVGltZXIxICovCiAKIC8qCi0gKglEZWZpbmUgdGhlIENhY2hlIHJlZ2lzdGVyIGZsYWdzLgorICogIFVBUlQgbW9kdWxlLgogICovCi0jZGVmaW5lCUNBQ1JfRUMJCQkoMTw8MzEpCi0jZGVmaW5lCUNBQ1JfRVNCCQkoMTw8MjkpCi0jZGVmaW5lCUNBQ1JfRFBJCQkoMTw8MjgpCi0jZGVmaW5lCUNBQ1JfSExDSwkJKDE8PDI3KQotI2RlZmluZQlDQUNSX0NJTlZBCQkoMTw8MjQpCi0jZGVmaW5lCUNBQ1JfRE5GQgkJKDE8PDEwKQotI2RlZmluZQlDQUNSX0RDTV9XVEhSVQkJKDA8PDgpCi0jZGVmaW5lCUNBQ1JfRENNX1dCQUNLCQkoMTw8OCkKLSNkZWZpbmUJQ0FDUl9EQ01fT0ZGX1BSRQkoMjw8OCkKLSNkZWZpbmUJQ0FDUl9EQ01fT0ZGX0lNUAkoMzw8OCkKLSNkZWZpbmUJQ0FDUl9EVwkJCSgxPDw1KQotCi0jZGVmaW5lCUFDUl9CQVNFX1BPUwkJMjQKLSNkZWZpbmUJQUNSX01BU0tfUE9TCQkxNgotI2RlZmluZQlBQ1JfRU5BQkxFCQkoMTw8MTUpCi0jZGVmaW5lCUFDUl9VU0VSCQkoMDw8MTMpCi0jZGVmaW5lCUFDUl9TVVBFUgkJKDE8PDEzKQotI2RlZmluZQlBQ1JfQU5ZCQkJKDI8PDEzKQotI2RlZmluZQlBQ1JfQ01fV1RIUlUJCSgwPDw1KQotI2RlZmluZQlBQ1JfQ01fV0JBQ0sJCSgxPDw1KQotI2RlZmluZQlBQ1JfQ01fT0ZGX1BSRQkJKDI8PDUpCi0jZGVmaW5lCUFDUl9DTV9PRkZfSU1QCQkoMzw8NSkKLSNkZWZpbmUJQUNSX1dQUk9URUNUCQkoMTw8MikKKyNkZWZpbmUgTUNGVUFSVF9CQVNFMQkJMHhGQzA2MDAwMAkvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDEgKi8KKyNkZWZpbmUgTUNGVUFSVF9CQVNFMgkJMHhGQzA2NDAwMAkvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDIgKi8KKyNkZWZpbmUgTUNGVUFSVF9CQVNFMwkJMHhGQzA2ODAwMAkvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDMgKi8KIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTN4eGFjci5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201M3h4YWNyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uY2Q5NTJiMAotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTN4eGFjci5oCkBAIC0wLDAgKzEsMTAxIEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworLyoKKyAqIG01M3h4YWNyLmggLS0gQ29sZEZpcmUgdmVyc2lvbiAzIGNvcmUgY2FjaGUgc3VwcG9ydAorICoKKyAqIChDKSBDb3B5cmlnaHQgMjAxMCwgR3JlZyBVbmdlcmVyIDxnZXJnQHNuYXBnZWFyLmNvbT4KKyAqLworCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKyNpZm5kZWYgbTUzeHhhY3JfaAorI2RlZmluZSBtNTN4eGFjcl9oCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworLyoKKyAqIEFsbCB2YXJpZW50cyBvZiB0aGUgQ29sZEZpcmUgdXNpbmcgdmVyc2lvbiAzIGNvcmVzIGhhdmUgYSBzaW1pbGFyCisgKiBjYWNoZSBzZXR1cC4gVGhleSBoYXZlIGEgdW5pZmllZCBpbnN0cnVjdGlvbiBhbmQgZGF0YSBjYWNoZSwgd2l0aAorICogY29uZmlndXJhYmxlIHdyaXRlLXRocm91Z2ggb3IgY29weS1iYWNrIG9wZXJhdGlvbi4KKyAqLworCisvKgorICogRGVmaW5lIHRoZSBDYWNoZSBDb250cm9sIHJlZ2lzdGVyIGZsYWdzLgorICovCisjZGVmaW5lIENBQ1JfRUMJCTB4ODAwMDAwMDAJLyogRW5hYmxlIGNhY2hlICovCisjZGVmaW5lIENBQ1JfRVNCCTB4MjAwMDAwMDAJLyogRW5hYmxlIHN0b3JlIGJ1ZmZlciAqLworI2RlZmluZSBDQUNSX0RQSQkweDEwMDAwMDAwCS8qIERpc2FibGUgaW52YWxpZGF0aW9uIGJ5IENQVVNITCAqLworI2RlZmluZSBDQUNSX0hMQ0sJMHgwODAwMDAwMAkvKiBIYWxmIGNhY2hlIGxvY2sgbW9kZSAqLworI2RlZmluZSBDQUNSX0NJTlZBCTB4MDEwMDAwMDAJLyogSW52YWxpZGF0ZSBjYWNoZSAqLworI2RlZmluZSBDQUNSX0RORkIJMHgwMDAwMDQwMAkvKiBJbmhpYml0ZWQgZmlsbCBidWZmZXIgKi8KKyNkZWZpbmUgQ0FDUl9EQ01fV1QJMHgwMDAwMDAwMAkvKiBDYWNoZWFibGUgd3JpdGUtdGhyb3VnaCAqLworI2RlZmluZSBDQUNSX0RDTV9DQgkweDAwMDAwMTAwCS8qIENhY2hlYWJsZSBjb3B5LWJhY2sgKi8KKyNkZWZpbmUgQ0FDUl9EQ01fUFJFCTB4MDAwMDAyMDAJLyogQ2FjaGUgaW5oaWJpdGVkLCBwcmVjaXNlICovCisjZGVmaW5lIENBQ1JfRENNX0lNUFJFCTB4MDAwMDAzMDAJLyogQ2FjaGUgaW5oaWJpdGVkLCBpbXByZWNpc2UgKi8KKyNkZWZpbmUgQ0FDUl9XUFJPVEVDVAkweDAwMDAwMDIwCS8qIFdyaXRlIHByb3RlY3QqLworI2RlZmluZSBDQUNSX0VVU1AJMHgwMDAwMDAxMAkvKiBFYW5ibGUgc2VwYXJhdGUgdXNlciBhNyAqLworCisvKgorICogRGVmaW5lIHRoZSBBY2Nlc3MgQ29udHJvbCByZWdpc3RlciBmbGFncy4KKyAqLworI2RlZmluZSBBQ1JfQkFTRV9QT1MJMjQJCS8qIEFkZHJlc3MgQmFzZSAodXBwZXIgOCBiaXRzKSAqLworI2RlZmluZSBBQ1JfTUFTS19QT1MJMTYJCS8qIEFkZHJlc3MgTWFzayAobmV4dCA4IGJpdHMpICovCisjZGVmaW5lIEFDUl9FTkFCTEUJMHgwMDAwODAwMAkvKiBFbmFibGUgdGhpcyBBQ1IgKi8KKyNkZWZpbmUgQUNSX1VTRVIJMHgwMDAwMDAwMAkvKiBBbGxvdyBvbmx5IHVzZXIgYWNjZXNzZXMgKi8KKyNkZWZpbmUgQUNSX1NVUEVSCTB4MDAwMDIwMDAJLyogQWxsb3cgc3VwZXJ2aXNvciBhY2Nlc3Mgb25seSAqLworI2RlZmluZSBBQ1JfQU5ZCQkweDAwMDA0MDAwCS8qIEFsbG93IGFueSBhY2Nlc3MgdHlwZSAqLworI2RlZmluZSBBQ1JfQ01fV1QJMHgwMDAwMDAwMAkvKiBDYWNoZWFibGUsIHdyaXRlLXRocm91Z2ggKi8KKyNkZWZpbmUgQUNSX0NNX0NCCTB4MDAwMDAwMjAJLyogQ2FjaGVhYmxlLCBjb3B5LWJhY2sgKi8KKyNkZWZpbmUgQUNSX0NNX1BSRQkweDAwMDAwMDQwCS8qIENhY2hlIGluaGliaXRlZCwgcHJlY2lzZSAqLworI2RlZmluZSBBQ1JfQ01fSU1QUkUJMHgwMDAwMDA2MAkvKiBDYWNoZSBpbmhpYml0ZWQsIGltcHJlY2lzZSAqLworI2RlZmluZSBBQ1JfV1BST1RFQ1QJMHgwMDAwMDAwNAkvKiBXcml0ZSBwcm90ZWN0IHJlZ2lvbiAqLworCisvKgorICogRGVmaW5lIHRoZSBjYWNoZSB0eXBlIGFuZCBhcnJhbmdlbWVudCAobmVlZGVkIGZvciBwdXNoZXMpLgorICovCisjaWYgZGVmaW5lZChDT05GSUdfTTUzMDcpCisjZGVmaW5lCUNBQ0hFX1NJWkUJMHgyMDAwCQkvKiA4ayBvZiB1bmlmaWVkIGNhY2hlICovCisjZGVmaW5lCUlDQUNIRV9TSVpFCUNBQ0hFX1NJWkUKKyNkZWZpbmUJRENBQ0hFX1NJWkUJQ0FDSEVfU0laRQorI2VsaWYgZGVmaW5lZChDT05GSUdfTTUzMngpCisjZGVmaW5lCUNBQ0hFX1NJWkUJMHg0MDAwCQkvKiAzMmsgb2YgdW5pZmllZCBjYWNoZSAqLworI2RlZmluZQlJQ0FDSEVfU0laRQlDQUNIRV9TSVpFCisjZGVmaW5lCURDQUNIRV9TSVpFCUNBQ0hFX1NJWkUKKyNlbmRpZgorCisjZGVmaW5lCUNBQ0hFX0xJTkVfU0laRQkxNgkJLyogMTYgYnl0ZSBsaW5lIHNpemUgKi8KKyNkZWZpbmUJQ0FDSEVfV0FZUwk0CQkvKiA0IHdheXMgLSBzZXQgYXNzb2NpYXRpdmUgKi8KKworLyoKKyAqIFNldCB0aGUgY2FjaGUgY29udHJvbGxlciBzZXR0aW5ncyB3ZSB3aWxsIHVzZS4gVGhpcyBkZWZhdWx0IGluIHRoZQorICogQ0FDUiBpcyBjYWNoZSBpbmhpYml0ZWQsIHdlIHVzZSB0aGUgQUNSIHJlZ2lzdGVyIHRvIHNldCBjYWNoZWluZworICogZW5hYmxlZCBvbiB0aGUgcmVnaW9ucyB3ZSB3YW50IChlZyBSQU0pLgorICovCisjaWYgZGVmaW5lZChDT05GSUdfQ0FDSEVfQ09QWUJBQ0spCisjZGVmaW5lIENBQ0hFX1RZUEUJQUNSX0NNX0NCCisjZGVmaW5lIENBQ0hFX1BVU0gKKyNlbHNlCisjZGVmaW5lIENBQ0hFX1RZUEUJQUNSX0NNX1dUCisjZW5kaWYKKworI2lmZGVmIENPTkZJR19DT0xERklSRV9TV19BNworI2RlZmluZSBDQUNIRV9NT0RFCShDQUNSX0VDICsgQ0FDUl9FU0IgKyBDQUNSX0RDTV9QUkUpCisjZWxzZQorI2RlZmluZSBDQUNIRV9NT0RFCShDQUNSX0VDICsgQ0FDUl9FU0IgKyBDQUNSX0RDTV9QUkUgKyBDQUNSX0VVU1ApCisjZW5kaWYKKworLyoKKyAqIFVuaWZpZWQgY2FjaGUgbWVhbnMgd2Ugd2lsbCBuZXZlciBuZWVkIHRvIGZsdXNoIGZvciBjb2hlcmVuY3kgb2YKKyAqIGluc3RydWN0aW9uIGZldGNoLiBXZSB3aWxsIG5lZWQgdG8gZmx1c2ggdG8gbWFpbnRhaW4gbWVtb3J5L0RNQQorICogY29oZXJlbmN5IHRob3VnaCBpbiBhbGwgY2FzZXMuIEFuZCBmb3IgY29weWJhY2sgY2FjaGVzIHdlIHdpbGwgbmVlZAorICogdG8gcHVzaCBjYWNoZWQgZGF0YSBhcyB3ZWxsLgorICovCisjZGVmaW5lIENBQ0hFX0lOSVQJICBDQUNSX0NJTlZBCisjZGVmaW5lIENBQ0hFX0lOVkFMSURBVEUgIENBQ1JfQ0lOVkEKKyNkZWZpbmUgQ0FDSEVfSU5WQUxJREFURUQgQ0FDUl9DSU5WQQorCisjZGVmaW5lIEFDUjBfTU9ERQkoKENPTkZJR19SQU1CQVNFICYgMHhmZjAwMDAwMCkgKyBcCisJCQkgKDB4MDAwZjAwMDApICsgXAorCQkJIChBQ1JfRU5BQkxFICsgQUNSX0FOWSArIENBQ0hFX1RZUEUpKQorI2RlZmluZSBBQ1IxX01PREUJMAorCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKyNlbmRpZiAgLyogbTUzeHhzaW1faCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201NDA3c2ltLmggYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbTU0MDdzaW0uaAppbmRleCBjMzk5YWJiLi43NWY1YzI4IDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vbTU0MDdzaW0uaAorKysgYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbTU0MDdzaW0uaApAQCAtMTQsNiArMTQsMTEgQEAKICNkZWZpbmUJbTU0MDdzaW1faAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKKyNkZWZpbmUJQ1BVX05BTUUJCSJDT0xERklSRShtNTQwNykiCisjZGVmaW5lCUNQVV9JTlNUUl9QRVJfSklGRlkJMworCisjaW5jbHVkZSA8YXNtL201NHh4YWNyLmg+CisKIC8qCiAgKglEZWZpbmUgdGhlIDU0MDcgU0lNIHJlZ2lzdGVyIHNldCBhZGRyZXNzZXMuCiAgKi8KQEAgLTczLDYgKzc4LDkgQEAKICNkZWZpbmUgTUNGU0lNX0RBQ1IxCQkweDExMAkJLyogRFJBTSAxIEFkZHIgYW5kIEN0cmwgKHIvdykgKi8KICNkZWZpbmUgTUNGU0lNX0RNUjEJCTB4MTE0CQkvKiBEUkFNIDEgTWFzayByZWcgKHIvdykgKi8KIAorI2RlZmluZSBNQ0ZVQVJUX0JBU0UxCQkweDFjMCAgICAgICAgICAgLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQxICovCisjZGVmaW5lIE1DRlVBUlRfQkFTRTIJCTB4MjAwICAgICAgICAgICAvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDIgKi8KKwogI2RlZmluZQlNQ0ZTSU1fUEFERFIJCShNQ0ZfTUJBUiArIDB4MjQ0KQogI2RlZmluZQlNQ0ZTSU1fUEFEQVQJCShNQ0ZfTUJBUiArIDB4MjQ4KQogCkBAIC0xMTcsMzkgKzEyNSw1IEBACiAjZGVmaW5lCU1DRl9JUlFfVElNRVIJCTMwCQkvKiBUaW1lcjAsIExldmVsIDYgKi8KICNkZWZpbmUJTUNGX0lSUV9QUk9GSUxFUgkzMQkJLyogVGltZXIxLCBMZXZlbCA3ICovCiAKLS8qCi0gKglEZWZpbmUgdGhlIENhY2hlIHJlZ2lzdGVyIGZsYWdzLgotICovCi0jZGVmaW5lCUNBQ1JfREVDCQkweDgwMDAwMDAwCS8qIEVuYWJsZSBkYXRhIGNhY2hlICovCi0jZGVmaW5lCUNBQ1JfRFdQCQkweDQwMDAwMDAwCS8qIERhdGEgd3JpdGUgcHJvdGVjdGlvbiAqLwotI2RlZmluZQlDQUNSX0RFU0IJCTB4MjAwMDAwMDAJLyogRW5hYmxlIGRhdGEgc3RvcmUgYnVmZmVyICovCi0jZGVmaW5lCUNBQ1JfRERQSQkJMHgxMDAwMDAwMAkvKiBEaXNhYmxlIENQVVNITCAqLwotI2RlZmluZQlDQUNSX0RIQ0xLCQkweDA4MDAwMDAwCS8qIEhhbGYgZGF0YSBjYWNoZSBsb2NrIG1vZGUgKi8KLSNkZWZpbmUJQ0FDUl9ERENNX1dUCQkweDAwMDAwMDAwCS8qIFdyaXRlIHRocm91Z2ggY2FjaGUqLwotI2RlZmluZQlDQUNSX0REQ01fQ1AJCTB4MDIwMDAwMDAJLyogQ29weWJhY2sgY2FjaGUgKi8KLSNkZWZpbmUJQ0FDUl9ERENNX1AJCTB4MDQwMDAwMDAJLyogTm8gY2FjaGUsIHByZWNpc2UgKi8KLSNkZWZpbmUJQ0FDUl9ERENNX0lNUAkJMHgwNjAwMDAwMAkvKiBObyBjYWNoZSwgaW1wcmVjaXNlICovCi0jZGVmaW5lCUNBQ1JfRENJTlZBCQkweDAxMDAwMDAwCS8qIEludmFsaWRhdGUgZGF0YSBjYWNoZSAqLwotI2RlZmluZQlDQUNSX0JFQwkJMHgwMDA4MDAwMAkvKiBFbmFibGUgYnJhbmNoIGNhY2hlICovCi0jZGVmaW5lCUNBQ1JfQkNJTlZBCQkweDAwMDQwMDAwCS8qIEludmFsaWRhdGUgYnJhbmNoIGNhY2hlICovCi0jZGVmaW5lCUNBQ1JfSUVDCQkweDAwMDA4MDAwCS8qIEVuYWJsZSBpbnN0cnVjdGlvbiBjYWNoZSAqLwotI2RlZmluZQlDQUNSX0RORkIJCTB4MDAwMDIwMDAJLyogSW5oaWJpdGVkIGZpbGwgYnVmZmVyICovCi0jZGVmaW5lCUNBQ1JfSURQSQkJMHgwMDAwMTAwMAkvKiBEaXNhYmxlIENQVVNITCAqLwotI2RlZmluZQlDQUNSX0lITENLCQkweDAwMDAwODAwCS8qIEludHJ1Y3Rpb24gY2FjaGUgaGFsZiBsb2NrICovCi0jZGVmaW5lCUNBQ1JfSURDTQkJMHgwMDAwMDQwMAkvKiBJbnRydWN0aW9uIGNhY2hlIGluaGliaXQgKi8KLSNkZWZpbmUJQ0FDUl9JQ0lOVkEJCTB4MDAwMDAxMDAJLyogSW52YWxpZGF0ZSBpbnN0ciBjYWNoZSAqLwotCi0jZGVmaW5lCUFDUl9CQVNFX1BPUwkJMjQJCS8qIEFkZHJlc3MgQmFzZSAqLwotI2RlZmluZQlBQ1JfTUFTS19QT1MJCTE2CQkvKiBBZGRyZXNzIE1hc2sgKi8KLSNkZWZpbmUJQUNSX0VOQUJMRQkJMHgwMDAwODAwMAkvKiBFbmFibGUgYWRkcmVzcyAqLwotI2RlZmluZQlBQ1JfVVNFUgkJMHgwMDAwMDAwMAkvKiBVc2VyIG1vZGUgYWNjZXNzIG9ubHkgKi8KLSNkZWZpbmUJQUNSX1NVUEVSCQkweDAwMDAyMDAwCS8qIFN1cGVydmlzb3IgbW9kZSBvbmx5ICovCi0jZGVmaW5lCUFDUl9BTlkJCQkweDAwMDA0MDAwCS8qIE1hdGNoIGFueSBhY2Nlc3MgbW9kZSAqLwotI2RlZmluZQlBQ1JfQ01fV1QJCTB4MDAwMDAwMDAJLyogV3JpdGUgdGhyb3VnaCBtb2RlICovCi0jZGVmaW5lCUFDUl9DTV9DUAkJMHgwMDAwMDAyMAkvKiBDb3B5YmFjayBtb2RlICovCi0jZGVmaW5lCUFDUl9DTV9PRkZfUFJFCQkweDAwMDAwMDQwCS8qIE5vIGNhY2hlLCBwcmVjaXNlICovCi0jZGVmaW5lCUFDUl9DTV9PRkZfSU1QCQkweDAwMDAwMDYwCS8qIE5vIGNhY2hlLCBpbXByZWNpc2UgKi8KLSNkZWZpbmUJQUNSX1dQUk9URUNUCQkweDAwMDAwMDA0CS8qIFdyaXRlIHByb3RlY3QgKi8KLQogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAjZW5kaWYJLyogbTU0MDdzaW1faCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201NHh4YWNyLmggYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbTU0eHhhY3IuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xNmExODM1Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201NHh4YWNyLmgKQEAgLTAsMCArMSw5NyBAQAorLyoKKyAqIEJpdCBkZWZpbml0aW9ucyBmb3IgdGhlIE1DRjU0eHggQUNSIGFuZCBDQUNSIHJlZ2lzdGVycy4KKyAqLworCisjaWZuZGVmCW01NHh4YWNyX2gKKyNkZWZpbmUgbTU0eHhhY3JfaAorCisvKgorICoJRGVmaW5lIHRoZSBDYWNoZSByZWdpc3RlciBmbGFncy4KKyAqLworI2RlZmluZSBDQUNSX0RFQwkweDgwMDAwMDAwCS8qIEVuYWJsZSBkYXRhIGNhY2hlICovCisjZGVmaW5lIENBQ1JfRFdQCTB4NDAwMDAwMDAJLyogRGF0YSB3cml0ZSBwcm90ZWN0aW9uICovCisjZGVmaW5lIENBQ1JfREVTQgkweDIwMDAwMDAwCS8qIEVuYWJsZSBkYXRhIHN0b3JlIGJ1ZmZlciAqLworI2RlZmluZSBDQUNSX0REUEkJMHgxMDAwMDAwMAkvKiBEaXNhYmxlIGludmFsaWRhdGlvbiBieSBDUFVTSEwgKi8KKyNkZWZpbmUgQ0FDUl9ESENMSwkweDA4MDAwMDAwCS8qIEhhbGYgZGF0YSBjYWNoZSBsb2NrIG1vZGUgKi8KKyNkZWZpbmUgQ0FDUl9ERENNX1dUCTB4MDAwMDAwMDAJLyogV3JpdGUgdGhyb3VnaCBjYWNoZSovCisjZGVmaW5lIENBQ1JfRERDTV9DUAkweDAyMDAwMDAwCS8qIENvcHliYWNrIGNhY2hlICovCisjZGVmaW5lIENBQ1JfRERDTV9QCTB4MDQwMDAwMDAJLyogTm8gY2FjaGUsIHByZWNpc2UgKi8KKyNkZWZpbmUgQ0FDUl9ERENNX0lNUAkweDA2MDAwMDAwCS8qIE5vIGNhY2hlLCBpbXByZWNpc2UgKi8KKyNkZWZpbmUgQ0FDUl9EQ0lOVkEJMHgwMTAwMDAwMAkvKiBJbnZhbGlkYXRlIGRhdGEgY2FjaGUgKi8KKyNkZWZpbmUgQ0FDUl9CRUMJMHgwMDA4MDAwMAkvKiBFbmFibGUgYnJhbmNoIGNhY2hlICovCisjZGVmaW5lIENBQ1JfQkNJTlZBCTB4MDAwNDAwMDAJLyogSW52YWxpZGF0ZSBicmFuY2ggY2FjaGUgKi8KKyNkZWZpbmUgQ0FDUl9JRUMJMHgwMDAwODAwMAkvKiBFbmFibGUgaW5zdHJ1Y3Rpb24gY2FjaGUgKi8KKyNkZWZpbmUgQ0FDUl9ETkZCCTB4MDAwMDIwMDAJLyogSW5oaWJpdGVkIGZpbGwgYnVmZmVyICovCisjZGVmaW5lIENBQ1JfSURQSQkweDAwMDAxMDAwCS8qIERpc2FibGUgQ1BVU0hMICovCisjZGVmaW5lIENBQ1JfSUhMQ0sJMHgwMDAwMDgwMAkvKiBJbnRydWN0aW9uIGNhY2hlIGhhbGYgbG9jayAqLworI2RlZmluZSBDQUNSX0lEQ00JMHgwMDAwMDQwMAkvKiBJbnRydWN0aW9uIGNhY2hlIGluaGliaXQgKi8KKyNkZWZpbmUgQ0FDUl9JQ0lOVkEJMHgwMDAwMDEwMAkvKiBJbnZhbGlkYXRlIGluc3RyIGNhY2hlICovCisjZGVmaW5lIENBQ1JfRVVTUAkweDAwMDAwMDIwCS8qIEVuYWJsZSBzZXBhcmF0ZSB1c2VyIGE3ICovCisKKyNkZWZpbmUgQUNSX0JBU0VfUE9TCTI0CQkvKiBBZGRyZXNzIEJhc2UgKi8KKyNkZWZpbmUgQUNSX01BU0tfUE9TCTE2CQkvKiBBZGRyZXNzIE1hc2sgKi8KKyNkZWZpbmUgQUNSX0VOQUJMRQkweDAwMDA4MDAwCS8qIEVuYWJsZSBhZGRyZXNzICovCisjZGVmaW5lIEFDUl9VU0VSCTB4MDAwMDAwMDAJLyogVXNlciBtb2RlIGFjY2VzcyBvbmx5ICovCisjZGVmaW5lIEFDUl9TVVBFUgkweDAwMDAyMDAwCS8qIFN1cGVydmlzb3IgbW9kZSBvbmx5ICovCisjZGVmaW5lIEFDUl9BTlkJCTB4MDAwMDQwMDAJLyogTWF0Y2ggYW55IGFjY2VzcyBtb2RlICovCisjZGVmaW5lIEFDUl9DTV9XVAkweDAwMDAwMDAwCS8qIFdyaXRlIHRocm91Z2ggbW9kZSAqLworI2RlZmluZSBBQ1JfQ01fQ1AJMHgwMDAwMDAyMAkvKiBDb3B5YmFjayBtb2RlICovCisjZGVmaW5lIEFDUl9DTV9PRkZfUFJFCTB4MDAwMDAwNDAJLyogTm8gY2FjaGUsIHByZWNpc2UgKi8KKyNkZWZpbmUgQUNSX0NNX09GRl9JTVAJMHgwMDAwMDA2MAkvKiBObyBjYWNoZSwgaW1wcmVjaXNlICovCisjZGVmaW5lIEFDUl9DTQkJMHgwMDAwMDA2MAkvKiBDYWNoZSBtb2RlIG1hc2sgKi8KKyNkZWZpbmUgQUNSX1dQUk9URUNUCTB4MDAwMDAwMDQJLyogV3JpdGUgcHJvdGVjdCAqLworCisjaWYgZGVmaW5lZChDT05GSUdfTTU0MDcpCisKKyNkZWZpbmUgSUNBQ0hFX1NJWkUgMHg0MDAwCS8qIGluc3RydWN0aW9uIC0gMTZrICovCisjZGVmaW5lIERDQUNIRV9TSVpFIDB4MjAwMAkvKiBkYXRhIC0gOGsgKi8KKworI2VsaWYgZGVmaW5lZChDT05GSUdfTTU0eHgpCisKKyNkZWZpbmUgSUNBQ0hFX1NJWkUgMHg4MDAwCS8qIGluc3RydWN0aW9uIC0gMzJrICovCisjZGVmaW5lIERDQUNIRV9TSVpFIDB4ODAwMAkvKiBkYXRhIC0gMzJrICovCisKKyNlbmRpZgorCisjZGVmaW5lIENBQ0hFX0xJTkVfU0laRSAweDAwMTAJLyogMTYgYnl0ZXMgKi8KKyNkZWZpbmUgQ0FDSEVfV0FZUyA0CQkvKiA0IHdheXMgKi8KKworLyoKKyAqCVZlcnNpb24gNCBjb3JlcyBoYXZlIGEgdHJ1ZSBoYXJ2YXJkIHN0eWxlIHNlcGFyYXRlIGluc3RydWN0aW9uCisgKglhbmQgZGF0YSBjYWNoZS4gRW5hYmxlIGRhdGEgYW5kIGluc3RydWN0aW9uIGNhY2hlcywgYWxzbyBlbmFibGUgd3JpdGUKKyAqCWJ1ZmZlcnMgYW5kIGJyYW5jaCBhY2NlbGVyYXRvci4KKyAqLworLyogYXR0ZW50aW9uIDogZW5hYmxpbmcgQ0FDUl9ERVNCIHJlcXVpcmVzIGEgIm5vcCIgdG8gZmx1c2ggdGhlIHN0b3JlIGJ1ZmZlciAqLworLyogdXNlICcrJyBpbnN0ZWFkIG9mICd8JyBmb3IgYXNzZW1ibGVyJ3Mgc2FrZSAqLworCisJLyogRW5hYmxlIGRhdGEgY2FjaGUgKi8KKwkvKiBFbmFibGUgZGF0YSBzdG9yZSBidWZmZXIgKi8KKwkvKiBvdXRzaWRlIEFDUnMgOiBObyBjYWNoZSwgcHJlY2lzZSAqLworCS8qIEVuYWJsZSBpbnN0cnVjdGlvbiticmFuY2ggY2FjaGVzICovCisjaWYgZGVmaW5lZChDT05GSUdfTTU0MDcpCisjZGVmaW5lIENBQ0hFX01PREUgKENBQ1JfREVDK0NBQ1JfREVTQitDQUNSX0REQ01fUCtDQUNSX0JFQytDQUNSX0lFQykKKyNlbHNlCisjZGVmaW5lIENBQ0hFX01PREUgKENBQ1JfREVDK0NBQ1JfREVTQitDQUNSX0REQ01fUCtDQUNSX0JFQytDQUNSX0lFQytDQUNSX0VVU1ApCisjZW5kaWYKKyNpZiBkZWZpbmVkKENPTkZJR19DQUNIRV9DT1BZQkFDSykKKyNkZWZpbmUgREFUQV9DQUNIRV9NT0RFIChBQ1JfRU5BQkxFK0FDUl9BTlkrQUNSX0NNX0NQKQorI2Vsc2UKKyNkZWZpbmUgREFUQV9DQUNIRV9NT0RFIChBQ1JfRU5BQkxFK0FDUl9BTlkrQUNSX0NNX1dUKQorI2VuZGlmCisjZGVmaW5lIElOU05fQ0FDSEVfTU9ERSAoQUNSX0VOQUJMRStBQ1JfQU5ZKQorCisjZGVmaW5lIENBQ0hFX0lOSVQJKENBQ1JfRENJTlZBK0NBQ1JfQkNJTlZBK0NBQ1JfSUNJTlZBKQorI2RlZmluZSBDQUNIRV9JTlZBTElEQVRFICAoQ0FDSEVfTU9ERStDQUNSX0RDSU5WQStDQUNSX0JDSU5WQStDQUNSX0lDSU5WQSkKKyNkZWZpbmUgQ0FDSEVfSU5WQUxJREFURUkgKENBQ0hFX01PREUrQ0FDUl9CQ0lOVkErQ0FDUl9JQ0lOVkEpCisjZGVmaW5lIENBQ0hFX0lOVkFMSURBVEVEIChDQUNIRV9NT0RFK0NBQ1JfRENJTlZBKQorI2RlZmluZSBBQ1IwX01PREUJKDB4MDAwZjAwMDArREFUQV9DQUNIRV9NT0RFKQorI2RlZmluZSBBQ1IxX01PREUJMAorI2RlZmluZSBBQ1IyX01PREUJKDB4MDAwZjAwMDArSU5TTl9DQUNIRV9NT0RFKQorI2RlZmluZSBBQ1IzX01PREUJMAorCisjaWYgKChEQVRBX0NBQ0hFX01PREUgJiBBQ1JfQ00pID09IEFDUl9DTV9DUCkKKy8qIENvcHliYWNrIGNhY2hlIG1vZGUgbXVzdCBwdXNoIGRpcnR5IGNhY2hlIGxpbmVzIGZpcnN0ICovCisjZGVmaW5lCUNBQ0hFX1BVU0gKKyNlbmRpZgorCisjZW5kaWYJLyogbTU0eHhhY3JfaCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201NDh4Z3B0LmggYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbTU0eHhncHQuaApzaW1pbGFyaXR5IGluZGV4IDk1JQpyZW5hbWUgZnJvbSBhcmNoL202OGsvaW5jbHVkZS9hc20vbTU0OHhncHQuaApyZW5hbWUgdG8gYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201NHh4Z3B0LmgKaW5kZXggMzNiMmVlZi4uZGY3NWRkOCAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201NDh4Z3B0LmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201NHh4Z3B0LmgKQEAgLTEsMTMgKzEsMTMgQEAKIC8qCi0gKiBGaWxlOgltNTQ4eGdwdC5oCi0gKiBQdXJwb3NlOglSZWdpc3RlciBhbmQgYml0IGRlZmluaXRpb25zIGZvciB0aGUgTUNGNTQ4WAorICogRmlsZToJbTU0eHhncHQuaAorICogUHVycG9zZToJUmVnaXN0ZXIgYW5kIGJpdCBkZWZpbml0aW9ucyBmb3IgdGhlIE1DRjU0WFgKICAqCiAgKiBOb3RlczoKICAqCiAgKi8KIAotI2lmbmRlZiBtNTQ4eGdwdF9oCi0jZGVmaW5lIG01NDh4Z3B0X2gKKyNpZm5kZWYgbTU0eHhncHRfaAorI2RlZmluZSBtNTR4eGdwdF9oCiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoKQEAgLTg3LDQgKzg3LDQgQEAKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCi0jZW5kaWYgLyogbTU0OHhncHRfaCAqLworI2VuZGlmIC8qIG01NHh4Z3B0X2ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTQ4eHNpbS5oIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201NHh4c2ltLmgKc2ltaWxhcml0eSBpbmRleCA3MyUKcmVuYW1lIGZyb20gYXJjaC9tNjhrL2luY2x1ZGUvYXNtL201NDh4c2ltLmgKcmVuYW1lIHRvIGFyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTR4eHNpbS5oCmluZGV4IDE0OTEzNWUuLjQ2MmFlNTMgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTQ4eHNpbS5oCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tNTR4eHNpbS5oCkBAIC0xLDExICsxLDE2IEBACiAvKgotICoJbTU0OHhzaW0uaCAtLSBDb2xkRmlyZSA1NDd4LzU0OHggU3lzdGVtIEludGVncmF0aW9uIFVuaXQgc3VwcG9ydC4KKyAqCW01NHh4c2ltLmggLS0gQ29sZEZpcmUgNTQ3eC81NDh4IFN5c3RlbSBJbnRlZ3JhdGlvbiBVbml0IHN1cHBvcnQuCiAgKi8KIAotI2lmbmRlZgltNTQ4eHNpbV9oCi0jZGVmaW5lIG01NDh4c2ltX2gKKyNpZm5kZWYJbTU0eHhzaW1faAorI2RlZmluZSBtNTR4eHNpbV9oCiAKLSNkZWZpbmUgTUNGSU5UX1ZFQ0JBU0UgICAgICA2NAorI2RlZmluZQlDUFVfTkFNRQkJIkNPTERGSVJFKG01NHh4KSIKKyNkZWZpbmUJQ1BVX0lOU1RSX1BFUl9KSUZGWQkyCisKKyNpbmNsdWRlIDxhc20vbTU0eHhhY3IuaD4KKworI2RlZmluZSBNQ0ZJTlRfVkVDQkFTRQkJNjQKIAogLyoKICAqICAgICAgSW50ZXJydXB0IENvbnRyb2xsZXIgUmVnaXN0ZXJzCkBAIC0yMiw2ICsyNywxNCBAQAogI2RlZmluZSBNQ0ZJTlRDX0lDUjAJCTB4NDAJCS8qIEJhc2UgSUNSIHJlZ2lzdGVyICovCiAKIC8qCisgKglVQVJUIG1vZHVsZS4KKyAqLworI2RlZmluZSBNQ0ZVQVJUX0JBU0UxCQkweDg2MDAJCS8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMSAqLworI2RlZmluZSBNQ0ZVQVJUX0JBU0UyCQkweDg3MDAJCS8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMiAqLworI2RlZmluZSBNQ0ZVQVJUX0JBU0UzCQkweDg4MDAJCS8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMyAqLworI2RlZmluZSBNQ0ZVQVJUX0JBU0U0CQkweDg5MDAJCS8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUNCAqLworCisvKgogICoJRGVmaW5lIHN5c3RlbSBwZXJpcGhlcmFsIElSUSB1c2FnZS4KICAqLwogI2RlZmluZSBNQ0ZfSVJRX1RJTUVSCQkoNjQgKyA1NCkJLyogU2xpY2UgVGltZXIgMCAqLwpAQCAtNTIsNCArNjUsNCBAQAogI2RlZmluZSBNQ0ZfUEFSX1BTQ19SVFNfUlRTCSgweDMwKQogI2RlZmluZSBNQ0ZfUEFSX1BTQ19DQU5SWAkoMHg0MCkKIAotI2VuZGlmCS8qIG01NDh4c2ltX2ggKi8KKyNlbmRpZgkvKiBtNTR4eHNpbV9oICovCmRpZmYgLS1naXQgYS9hcmNoL202OGsvaW5jbHVkZS9hc20vbWNmY2FjaGUuaCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tY2ZjYWNoZS5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmNDlkZmMwLi4wMDAwMDAwCi0tLSBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tY2ZjYWNoZS5oCisrKyAvZGV2L251bGwKQEAgLTEsMTUwICswLDAgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotCi0vKgotICoJbWNmY2FjaGUuaCAtLSBDb2xkRmlyZSBDUFUgY2FjaGUgc3VwcG9ydCBjb2RlCi0gKgotICoJKEMpIENvcHlyaWdodCAyMDA0LCBHcmVnIFVuZ2VyZXIgPGdlcmdAc25hcGdlYXIuY29tPgotICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotI2lmbmRlZglfX002OEtOT01NVV9NQ0ZDQUNIRV9ICi0jZGVmaW5lCV9fTTY4S05PTU1VX01DRkNBQ0hFX0gKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotCi0KLS8qCi0gKglUaGUgZGlmZmVyZW50IENvbGRGaXJlIGZhbWlsaWVzIGhhdmUgZGlmZmVyZW50IGNhY2hlIGFycmFuZ21lbnRzLgotICoJRXZlcnl0aGluZyBmcm9tIGEgc21hbGwgaW5zdHJ1Y3Rpb24gb25seSBjYWNoZSwgdG8gY29uZmlndXJhYmxlCi0gKglkYXRhIGFuZC9vciBpbnN0cnVjdGlvbiBjYWNoZSwgdG8gdW5pZmllZCBpbnN0cnVjdGlvbi9kYXRhLCB0byAKLSAqCWhhcnZhcmQgc3R5bGUgc2VwYXJhdGUgaW5zdHJ1Y3Rpb24gYW5kIGRhdGEgY2FjaGVzLgotICovCi0KLSNpZiBkZWZpbmVkKENPTkZJR19NNTIwNikgfHwgZGVmaW5lZChDT05GSUdfTTUyMDZlKSB8fCBkZWZpbmVkKENPTkZJR19NNTI3MikKLS8qCi0gKglTaW1wbGUgdmVyc2lvbiAyIGNvcmUgY2FjaGUuIFRoZXNlIGhhdmUgaW5zdHJ1Y3Rpb24gY2FjaGUgb25seSwKLSAqCXdlIGp1c3QgbmVlZCB0byBpbnZhbGlkYXRlIGl0IGFuZCBlbmFibGUgaXQuCi0gKi8KLS5tYWNybyBDQUNIRV9FTkFCTEUKLQltb3ZlbAkjMHgwMTAwMDAwMCwlZDAJCS8qIGludmFsaWRhdGUgY2FjaGUgY21kICovCi0JbW92ZWMJJWQwLCVDQUNSCQkvKiBkbyBpbnZhbGlkYXRlIGNhY2hlICovCi0JbW92ZWwJIzB4ODAwMDAxMDAsJWQwCQkvKiBzZXR1cCBjYWNoZSBtYXNrICovCi0JbW92ZWMJJWQwLCVDQUNSCQkvKiBlbmFibGUgY2FjaGUgKi8KLS5lbmRtCi0jZW5kaWYgLyogQ09ORklHX001MjA2IHx8IENPTkZJR19NNTIwNmUgfHwgQ09ORklHX001MjcyICovCi0KLSNpZiBkZWZpbmVkKENPTkZJR19NNTIzeCkgfHwgZGVmaW5lZChDT05GSUdfTTUyN3gpCi0vKgotICoJTmV3IHZlcnNpb24gMiBjb3JlcyBoYXZlIGEgY29uZmlndXJhYmxlIHNwbGl0IGNhY2hlIGFycmFuZ2VtZW50LgotICoJRm9yIG5vdyBJIGFtIGp1c3QgZW5hYmxpbmcgaW5zdHJ1Y3Rpb24gY2FjaGUgLSBidXQgdWx0aW1hdGVseSBJCi0gKgl0aGluayBhIHNwbGl0IGluc3RydWN0aW9uL2RhdGEgY2FjaGUgd291bGQgYmUgYmV0dGVyLgotICovCi0ubWFjcm8gQ0FDSEVfRU5BQkxFCi0JbW92ZWwJIzB4MDE0MDAwMDAsJWQwCi0JbW92ZWMJJWQwLCVDQUNSCQkvKiBpbnZhbGlkYXRlIGNhY2hlICovCi0Jbm9wCi0JbW92ZWwJIzB4MDAwMGMwMDAsJWQwCQkvKiBzZXQgU0RSQU0gY2FjaGVkIG9ubHkgKi8KLQltb3ZlYwklZDAsJUFDUjAKLQltb3ZlbAkjMHgwMDAwMDAwMCwlZDAJCS8qIG5vIG90aGVyIHJlZ2lvbnMgY2FjaGVkICovCi0JbW92ZWMJJWQwLCVBQ1IxCi0JbW92ZWwJIzB4ODA0MDAxMDAsJWQwCQkvKiBjb25maWd1cmUgY2FjaGUgKi8KLQltb3ZlYwklZDAsJUNBQ1IJCS8qIGVuYWJsZSBjYWNoZSAqLwotCW5vcAotLmVuZG0KLSNlbmRpZiAvKiBDT05GSUdfTTUyM3ggfHwgQ09ORklHX001Mjd4ICovCi0KLSNpZiBkZWZpbmVkKENPTkZJR19NNTI4eCkKLS5tYWNybyBDQUNIRV9FTkFCTEUKLQlub3AKLQltb3ZlbAkjMHgwMTAwMDAwMCwgJWQwCi0JbW92ZWMJJWQwLCAlQ0FDUgkJLyogSW52YWxpZGF0ZSBjYWNoZSAqLwotCW5vcAotCW1vdmVsCSMweDAwMDBjMDIwLCAlZDAJLyogU2V0IFNEUkFNIGNhY2hlZCBvbmx5ICovCi0JbW92ZWMJJWQwLCAlQUNSMAotCW1vdmVsCSMweDAwMDAwMDAwLCAlZDAJLyogTm8gb3RoZXIgcmVnaW9ucyBjYWNoZWQgKi8KLQltb3ZlYwklZDAsICVBQ1IxCi0JbW92ZWwJIzB4ODAwMDAyMDAsICVkMAkvKiBTZXR1cCBjYWNoZSBtYXNrICovCi0JbW92ZWMJJWQwLCAlQ0FDUgkJLyogRW5hYmxlIGNhY2hlICovCi0Jbm9wCi0uZW5kbQotI2VuZGlmIC8qIENPTkZJR19NNTI4eCAqLwotCi0jaWYgZGVmaW5lZChDT05GSUdfTTUyNDkpIHx8IGRlZmluZWQoQ09ORklHX001MzA3KQotLyoKLSAqCVRoZSB2ZXJzaW9uIDMgY29yZSBjYWNoZS4gT2RkbHkgZW5vdWdoIHRoZSB2ZXJzaW9uIDIgY29yZSA1MjQ5Ci0gKgloYXMgdGhlIHNhbWUgU0RSQU0gYW5kIGNhY2hlIHNldHVwIGFzIHRoZSB2ZXJzaW9uIDMgY29yZXMuCi0gKglUaGlzIGlzIGEgc2luZ2xlIHVuaWZpZWQgaW5zdHJ1Y3Rpb24vZGF0YSBjYWNoZS4KLSAqLwotLm1hY3JvIENBQ0hFX0VOQUJMRQotCW1vdmVsCSMweDAxMDAwMDAwLCVkMAkJLyogaW52YWxpZGF0ZSB3aG9sZSBjYWNoZSAqLwotCW1vdmVjCSVkMCwlQ0FDUgotCW5vcAotI2lmIGRlZmluZWQoREVCVUdHRVJfQ09NUEFUSUJMRV9DQUNIRSkgfHwgZGVmaW5lZChDT05GSUdfU0VDVVJFRURHRU1QMykKLQltb3ZlbAkjMHgwMDAwYzAwMCwlZDAJCS8qIHNldCBTRFJBTSBjYWNoZWQgKHdyaXRlLXRocnUpICovCi0jZWxzZQotCW1vdmVsCSMweDAwMDBjMDIwLCVkMAkJLyogc2V0IFNEUkFNIGNhY2hlZCAoY29weWJhY2spICovCi0jZW5kaWYKLQltb3ZlYwklZDAsJUFDUjAKLQltb3ZlbAkjMHgwMDAwMDAwMCwlZDAJCS8qIG5vIG90aGVyIHJlZ2lvbnMgY2FjaGVkICovCi0JbW92ZWMJJWQwLCVBQ1IxCi0JbW92ZWwJIzB4YTAwMDAyMDAsJWQwCQkvKiBlbmFibGUgY2FjaGUgKi8KLQltb3ZlYwklZDAsJUNBQ1IKLQlub3AKLS5lbmRtCi0jZW5kaWYgLyogQ09ORklHX001MjQ5IHx8IENPTkZJR19NNTMwNyAqLwotCi0jaWYgZGVmaW5lZChDT05GSUdfTTUzMngpCi0ubWFjcm8gQ0FDSEVfRU5BQkxFCi0JbW92ZWwJIzB4MDEwMDAwMDAsJWQwCQkvKiBpbnZhbGlkYXRlIGNhY2hlIGNtZCAqLwotCW1vdmVjCSVkMCwlQ0FDUgkJLyogZG8gaW52YWxpZGF0ZSBjYWNoZSAqLwotCW5vcAotCW1vdmVsCSMweDQwMDFDMDAwLCVkMAkJLyogc2V0IFNEUkFNIGNhY2hlZCAod3JpdGUtdGhydSkgKi8KLQltb3ZlYwklZDAsJUFDUjAKLQltb3ZlbAkjMHgwMDAwMDAwMCwlZDAJCS8qIG5vIG90aGVyIHJlZ2lvbnMgY2FjaGVkICovCi0JbW92ZWMJJWQwLCVBQ1IxCi0JbW92ZWwJIzB4ODAwMDAyMDAsJWQwCQkvKiBzZXR1cCBjYWNoZSBtYXNrICovCi0JbW92ZWMJJWQwLCVDQUNSCQkvKiBlbmFibGUgY2FjaGUgKi8KLQlub3AKLS5lbmRtCi0jZW5kaWYgLyogQ09ORklHX001MzJ4ICovCi0KLSNpZiBkZWZpbmVkKENPTkZJR19NNTQwNykgfHwgZGVmaW5lZChDT05GSUdfTTU0OHgpCi0vKgotICoJVmVyc2lvbiA0IGNvcmVzIGhhdmUgYSB0cnVlIGhhcnZhcmQgc3R5bGUgc2VwYXJhdGUgaW5zdHJ1Y3Rpb24KLSAqCWFuZCBkYXRhIGNhY2hlLiBJbnZhbGlkYXRlIGFuZCBlbmFibGUgY2FjaGUsIGFsc28gZW5hYmxlIHdyaXRlCi0gKglidWZmZXJzIGFuZCBicmFuY2ggYWNjZWxlcmF0b3IuCi0gKi8KLS5tYWNybyBDQUNIRV9FTkFCTEUKLQltb3ZlbAkjMHgwMTA0MDEwMCwlZDAJCS8qIGludmFsaWRhdGUgd2hvbGUgY2FjaGUgKi8KLQltb3ZlYwklZDAsJUNBQ1IKLQlub3AKLQltb3ZlbAkjMHgwMDBmYzAwMCwlZDAJCS8qIHNldCBTRFJBTSBjYWNoZWQgb25seSAqLwotCW1vdmVjCSVkMCwgJUFDUjAKLQltb3ZlbAkjMHgwMDAwMDAwMCwlZDAJCS8qIG5vIG90aGVyIHJlZ2lvbnMgY2FjaGVkICovCi0JbW92ZWMJJWQwLCAlQUNSMQotCW1vdmVsCSMweDAwMGZjMDAwLCVkMAkJLyogc2V0IFNEUkFNIGNhY2hlZCBvbmx5ICovCi0JbW92ZWMJJWQwLCAlQUNSMgotCW1vdmVsCSMweDAwMDAwMDAwLCVkMAkJLyogbm8gb3RoZXIgcmVnaW9ucyBjYWNoZWQgKi8KLQltb3ZlYwklZDAsICVBQ1IzCi0JbW92ZWwJIzB4YjYwODg0MDAsJWQwCQkvKiBlbmFibGUgY2FjaGVzICovCi0JbW92ZWMJJWQwLCVDQUNSCi0Jbm9wCi0uZW5kbQotI2VuZGlmIC8qIENPTkZJR19NNTQwNyAqLwotCi0jaWYgZGVmaW5lZChDT05GSUdfTTUyMHgpCi0ubWFjcm8gQ0FDSEVfRU5BQkxFCi0JbW92ZS5sCSMweDAxMDAwMDAwLCVkMAkJLyogaW52YWxpZGF0ZSB3aG9sZSBjYWNoZSAqLwotCW1vdmVjCSVkMCwlQ0FDUgotCW5vcAotCW1vdmUubAkjMHgwMDAwYzAwMCwlZDAJCS8qIHNldCBTRFJBTSBjYWNoZWQgKHdyaXRlLXRocnUpICovCi0JbW92ZWMJJWQwLCVBQ1IwCi0JbW92ZS5sCSMweDAwMDAwMDAwLCVkMAkJLyogbm8gb3RoZXIgcmVnaW9ucyBjYWNoZWQgKi8KLQltb3ZlYwklZDAsJUFDUjEKLQltb3ZlLmwJIzB4ODA0MDAwMDAsJWQwCQkvKiBlbmFibGUgOEsgaW5zdHJ1Y3Rpb24gY2FjaGUgKi8KLQltb3ZlYwklZDAsJUNBQ1IKLQlub3AKLS5lbmRtCi0jZW5kaWYgLyogQ09ORklHX001MjB4ICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotI2VuZGlmCS8qIF9fTTY4S05PTU1VX01DRkNBQ0hFX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tY2ZzaW0uaCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tY2ZzaW0uaAppbmRleCA2OTAxZmQ2Li5lYmQwMzA0IDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vbWNmc2ltLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL21jZnNpbS5oCkBAIC00MSw4ICs0MSw4IEBACiAjZWxpZiBkZWZpbmVkKENPTkZJR19NNTQwNykKICNpbmNsdWRlIDxhc20vbTU0MDdzaW0uaD4KICNpbmNsdWRlIDxhc20vbWNmaW50Yy5oPgotI2VsaWYgZGVmaW5lZChDT05GSUdfTTU0OHgpCi0jaW5jbHVkZSA8YXNtL201NDh4c2ltLmg+CisjZWxpZiBkZWZpbmVkKENPTkZJR19NNTR4eCkKKyNpbmNsdWRlIDxhc20vbTU0eHhzaW0uaD4KICNlbmRpZgogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tY2Z1YXJ0LmggYi9hcmNoL202OGsvaW5jbHVkZS9hc20vbWNmdWFydC5oCmluZGV4IGRiNzJlMmIuLjJhYmVkZmYgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9tY2Z1YXJ0LmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL21jZnVhcnQuaApAQCAtMTIsNDkgKzEyLDYgQEAKICNkZWZpbmUJbWNmdWFydF9oCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAotLyoKLSAqCURlZmluZSB0aGUgYmFzZSBhZGRyZXNzIG9mIHRoZSBVQVJUUyB3aXRoaW4gdGhlIE1CQVIgYWRkcmVzcwotICoJc3BhY2UuCi0gKi8KLSNpZiBkZWZpbmVkKENPTkZJR19NNTI3MikKLSNkZWZpbmUJTUNGVUFSVF9CQVNFMQkJMHgxMDAJCS8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMSAqLwotI2RlZmluZQlNQ0ZVQVJUX0JBU0UyCQkweDE0MAkJLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQyICovCi0jZWxpZiBkZWZpbmVkKENPTkZJR19NNTIwNikgfHwgZGVmaW5lZChDT05GSUdfTTUyMDZlKQotI2lmIGRlZmluZWQoQ09ORklHX05FVHRlbCkKLSNkZWZpbmUJTUNGVUFSVF9CQVNFMQkJMHgxODAJCS8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMSAqLwotI2RlZmluZQlNQ0ZVQVJUX0JBU0UyCQkweDE0MAkJLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQyICovCi0jZWxzZQotI2RlZmluZQlNQ0ZVQVJUX0JBU0UxCQkweDE0MAkJLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQxICovCi0jZGVmaW5lCU1DRlVBUlRfQkFTRTIJCTB4MTgwCQkvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDIgKi8KLSNlbmRpZgotI2VsaWYgZGVmaW5lZChDT05GSUdfTTUyM3gpIHx8IGRlZmluZWQoQ09ORklHX001Mjd4KSB8fCBkZWZpbmVkKENPTkZJR19NNTI4eCkKLSNkZWZpbmUgTUNGVUFSVF9CQVNFMQkJMHgyMDAgICAgICAgICAgIC8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMSAqLwotI2RlZmluZSBNQ0ZVQVJUX0JBU0UyCQkweDI0MCAgICAgICAgICAgLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQyICovCi0jZGVmaW5lIE1DRlVBUlRfQkFTRTMJCTB4MjgwICAgICAgICAgICAvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDMgKi8KLSNlbGlmIGRlZmluZWQoQ09ORklHX001MjQ5KSB8fCBkZWZpbmVkKENPTkZJR19NNTMwNykgfHwgZGVmaW5lZChDT05GSUdfTTU0MDcpCi0jaWYgZGVmaW5lZChDT05GSUdfTkVUdGVsKSB8fCBkZWZpbmVkKENPTkZJR19TRUNVUkVFREdFTVAzKQotI2RlZmluZSBNQ0ZVQVJUX0JBU0UxCQkweDIwMCAgICAgICAgICAgLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQxICovCi0jZGVmaW5lIE1DRlVBUlRfQkFTRTIJCTB4MWMwICAgICAgICAgICAvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDIgKi8KLSNlbHNlCi0jZGVmaW5lIE1DRlVBUlRfQkFTRTEJCTB4MWMwICAgICAgICAgICAvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDEgKi8KLSNkZWZpbmUgTUNGVUFSVF9CQVNFMgkJMHgyMDAgICAgICAgICAgIC8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMiAqLwotI2VuZGlmCi0jZWxpZiBkZWZpbmVkKENPTkZJR19NNTIweCkKLSNkZWZpbmUgTUNGVUFSVF9CQVNFMQkJMHg2MDAwMAkJLyogQmFzZSBhZGRyZXNzIG9mIFVBUlQxICovCi0jZGVmaW5lIE1DRlVBUlRfQkFTRTIJCTB4NjQwMDAJCS8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMiAqLwotI2RlZmluZSBNQ0ZVQVJUX0JBU0UzCQkweDY4MDAwCQkvKiBCYXNlIGFkZHJlc3Mgb2YgVUFSVDIgKi8KLSNlbGlmIGRlZmluZWQoQ09ORklHX001MzJ4KQotI2RlZmluZSBNQ0ZVQVJUX0JBU0UxCQkweGZjMDYwMDAwCS8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMSAqLwotI2RlZmluZSBNQ0ZVQVJUX0JBU0UyCQkweGZjMDY0MDAwCS8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMiAqLwotI2RlZmluZSBNQ0ZVQVJUX0JBU0UzCQkweGZjMDY4MDAwCS8qIEJhc2UgYWRkcmVzcyBvZiBVQVJUMyAqLwotI2VsaWYgZGVmaW5lZChDT05GSUdfTTU0OHgpCi0jZGVmaW5lIE1DRlVBUlRfQkFTRTEJCTB4ODYwMAkJLyogb24gTTU0OHggKi8KLSNkZWZpbmUgTUNGVUFSVF9CQVNFMgkJMHg4NzAwCQkvKiBvbiBNNTQ4eCAqLwotI2RlZmluZSBNQ0ZVQVJUX0JBU0UzCQkweDg4MDAJCS8qIG9uIE01NDh4ICovCi0jZGVmaW5lIE1DRlVBUlRfQkFTRTQJCTB4ODkwMAkJLyogb24gTTU0OHggKi8KLSNlbmRpZgotCi0KICNpbmNsdWRlIDxsaW51eC9zZXJpYWxfY29yZS5oPgogI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgogCkBAIC0yMTcsNyArMTc0LDcgQEAKICNkZWZpbmUJTUNGVUFSVF9VUkZfUlhTCQkweGMwCQkvKiBSZWNlaXZlciBzdGF0dXMgKi8KICNlbmRpZgogCi0jaWYgZGVmaW5lZChDT05GSUdfTTU0OHgpCisjaWYgZGVmaW5lZChDT05GSUdfTTU0eHgpCiAjZGVmaW5lIE1DRlVBUlRfVFhGSUZPU0laRQk1MTIKICNlbGlmIGRlZmluZWQoQ09ORklHX001MjcyKQogI2RlZmluZSBNQ0ZVQVJUX1RYRklGT1NJWkUJMjUKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9wcm9jZXNzb3IuaCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9wcm9jZXNzb3IuaAppbmRleCA3YTZhNzU5Li4yNzhjNjliIDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vcHJvY2Vzc29yLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL3Byb2Nlc3Nvci5oCkBAIC0yMCwyMyArMjAsMjYgQEAKIAogc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIHJkdXNwKHZvaWQpCiB7Ci0jaWZkZWYgQ09ORklHX0NPTERGSVJFCisjaWZkZWYgQ09ORklHX0NPTERGSVJFX1NXX0E3CiAJZXh0ZXJuIHVuc2lnbmVkIGludCBzd191c3A7CiAJcmV0dXJuIHN3X3VzcDsKICNlbHNlCi0JdW5zaWduZWQgbG9uZyB1c3A7Ci0JX19hc21fXyBfX3ZvbGF0aWxlX18oIm1vdmUgJS91c3AsJTAiIDogIj1hIiAodXNwKSk7CisJcmVnaXN0ZXIgdW5zaWduZWQgbG9uZyB1c3AgX19hc21fXygiYTAiKTsKKwkvKiBtb3ZlICV1c3AsJWEwICovCisJX19hc21fXyBfX3ZvbGF0aWxlX18oIi53b3JkIDB4NGU2OCIgOiAiPWEiICh1c3ApKTsKIAlyZXR1cm4gdXNwOwogI2VuZGlmCiB9CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCB3cnVzcCh1bnNpZ25lZCBsb25nIHVzcCkKIHsKLSNpZmRlZiBDT05GSUdfQ09MREZJUkUKKyNpZmRlZiBDT05GSUdfQ09MREZJUkVfU1dfQTcKIAlleHRlcm4gdW5zaWduZWQgaW50IHN3X3VzcDsKIAlzd191c3AgPSB1c3A7CiAjZWxzZQotCV9fYXNtX18gX192b2xhdGlsZV9fKCJtb3ZlICUwLCUvdXNwIiA6IDogImEiICh1c3ApKTsKKwlyZWdpc3RlciB1bnNpZ25lZCBsb25nIGEwIF9fYXNtX18oImEwIikgPSB1c3A7CisJLyogbW92ZSAlYTAsJXVzcCAqLworCV9fYXNtX18gX192b2xhdGlsZV9fKCIud29yZCAweDRlNjAiIDogOiAiYSIgKGEwKSApOwogI2VuZGlmCiB9CiAKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9zdHJpbmcuaCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9zdHJpbmcuaAppbmRleCAyOTM2ZGRhLi42NWIxMzEyIDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vc3RyaW5nLmgKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL3N0cmluZy5oCkBAIC04MSwxOCArODEsNiBAQAogCXN0cmNweShfX2QgKyBzdHJsZW4oX19kKSwgKHMpKTsJCVwKIH0pCiAKLSNkZWZpbmUgX19IQVZFX0FSQ0hfU1RSQ0hSCi1zdGF0aWMgaW5saW5lIGNoYXIgKnN0cmNocihjb25zdCBjaGFyICpzLCBpbnQgYykKLXsKLQljaGFyIHNjLCBjaCA9IGM7Ci0KLQlmb3IgKDsgKHNjID0gKnMrKykgIT0gY2g7ICkgewotCQlpZiAoIXNjKQotCQkJcmV0dXJuIE5VTEw7Ci0JfQotCXJldHVybiAoY2hhciAqKXMgLSAxOwotfQotCiAjaWZuZGVmIENPTkZJR19DT0xERklSRQogI2RlZmluZSBfX0hBVkVfQVJDSF9TVFJDTVAKIHN0YXRpYyBpbmxpbmUgaW50IHN0cmNtcChjb25zdCBjaGFyICpjcywgY29uc3QgY2hhciAqY3QpCmRpZmYgLS1naXQgYS9hcmNoL202OGtub21tdS9LY29uZmlnIGIvYXJjaC9tNjhrbm9tbXUvS2NvbmZpZwppbmRleCBmYTlmNzQ2Li44YjlkYWNhIDEwMDY0NAotLS0gYS9hcmNoL202OGtub21tdS9LY29uZmlnCisrKyBiL2FyY2gvbTY4a25vbW11L0tjb25maWcKQEAgLTIsNiArMiw3IEBACiAJYm9vbAogCWRlZmF1bHQgeQogCXNlbGVjdCBIQVZFX0lERQorCXNlbGVjdCBIQVZFX0dFTkVSSUNfSEFSRElSUVMKIAogY29uZmlnIE1NVQogCWJvb2wKQEAgLTQ4LDE0ICs0OSw2IEBACiAJYm9vbAogCWRlZmF1bHQgeQogCi1jb25maWcgR0VORVJJQ19IQVJESVJRUwotCWJvb2wKLQlkZWZhdWx0IHkKLQotY29uZmlnIEdFTkVSSUNfSEFSRElSUVNfTk9fX0RPX0lSUQotCWJvb2wKLQlkZWZhdWx0IHkKLQogY29uZmlnIEdFTkVSSUNfQ0FMSUJSQVRFX0RFTEFZCiAJYm9vbAogCWRlZmF1bHQgeQpAQCAtNzUsNiArNjgsMTYgQEAKIGNvbmZpZyBOT19JT1BPUlQKIAlkZWZfYm9vbCB5CiAKK2NvbmZpZyBDT0xERklSRV9TV19BNworCWJvb2wKKwlkZWZhdWx0IG4KKworY29uZmlnIEhBVkVfQ0FDSEVfU1BMSVQKKwlib29sCisKK2NvbmZpZyBIQVZFX0NBQ0hFX0NCCisJYm9vbAorCiBzb3VyY2UgImluaXQvS2NvbmZpZyIKIAogc291cmNlICJrZXJuZWwvS2NvbmZpZy5mcmVlemVyIgpAQCAtMTA3LDY5ICsxMTAsOTAgQEAKIAogY29uZmlnIE01MjA2CiAJYm9vbCAiTUNGNTIwNiIKKwlzZWxlY3QgQ09MREZJUkVfU1dfQTcKIAloZWxwCiAJICBNb3Rvcm9sYSBDb2xkRmlyZSA1MjA2IHByb2Nlc3NvciBzdXBwb3J0LgogCiBjb25maWcgTTUyMDZlCiAJYm9vbCAiTUNGNTIwNmUiCisJc2VsZWN0IENPTERGSVJFX1NXX0E3CiAJaGVscAogCSAgTW90b3JvbGEgQ29sZEZpcmUgNTIwNmUgcHJvY2Vzc29yIHN1cHBvcnQuCiAKIGNvbmZpZyBNNTIweAogCWJvb2wgIk1DRjUyMHgiCiAJc2VsZWN0IEdFTkVSSUNfQ0xPQ0tFVkVOVFMKKwlzZWxlY3QgSEFWRV9DQUNIRV9TUExJVAogCWhlbHAKIAkgICBGcmVlc2NhbGUgQ29sZGZpcmUgNTIwNy81MjA4IHByb2Nlc3NvciBzdXBwb3J0LgogCiBjb25maWcgTTUyM3gKIAlib29sICJNQ0Y1MjN4IgogCXNlbGVjdCBHRU5FUklDX0NMT0NLRVZFTlRTCisJc2VsZWN0IEhBVkVfQ0FDSEVfU1BMSVQKIAloZWxwCiAJICBGcmVlc2NhbGUgQ29sZGZpcmUgNTIzMC8xLzIvNC81IHByb2Nlc3NvciBzdXBwb3J0CiAKIGNvbmZpZyBNNTI0OQogCWJvb2wgIk1DRjUyNDkiCisJc2VsZWN0IENPTERGSVJFX1NXX0E3CiAJaGVscAogCSAgTW90b3JvbGEgQ29sZEZpcmUgNTI0OSBwcm9jZXNzb3Igc3VwcG9ydC4KIAogY29uZmlnIE01MjcxCiAJYm9vbCAiTUNGNTI3MSIKKwlzZWxlY3QgSEFWRV9DQUNIRV9TUExJVAogCWhlbHAKIAkgIEZyZWVzY2FsZSAoTW90b3JvbGEpIENvbGRGaXJlIDUyNzAvNTI3MSBwcm9jZXNzb3Igc3VwcG9ydC4KIAogY29uZmlnIE01MjcyCiAJYm9vbCAiTUNGNTI3MiIKKwlzZWxlY3QgQ09MREZJUkVfU1dfQTcKIAloZWxwCiAJICBNb3Rvcm9sYSBDb2xkRmlyZSA1MjcyIHByb2Nlc3NvciBzdXBwb3J0LgogCiBjb25maWcgTTUyNzUKIAlib29sICJNQ0Y1Mjc1IgorCXNlbGVjdCBIQVZFX0NBQ0hFX1NQTElUCiAJaGVscAogCSAgRnJlZXNjYWxlIChNb3Rvcm9sYSkgQ29sZEZpcmUgNTI3NC81Mjc1IHByb2Nlc3NvciBzdXBwb3J0LgogCiBjb25maWcgTTUyOHgKIAlib29sICJNQ0Y1Mjh4IgogCXNlbGVjdCBHRU5FUklDX0NMT0NLRVZFTlRTCisJc2VsZWN0IEhBVkVfQ0FDSEVfU1BMSVQKIAloZWxwCiAJICBNb3Rvcm9sYSBDb2xkRmlyZSA1MjgwLzUyODIgcHJvY2Vzc29yIHN1cHBvcnQuCiAKIGNvbmZpZyBNNTMwNwogCWJvb2wgIk1DRjUzMDciCisJc2VsZWN0IENPTERGSVJFX1NXX0E3CisJc2VsZWN0IEhBVkVfQ0FDSEVfQ0IKIAloZWxwCiAJICBNb3Rvcm9sYSBDb2xkRmlyZSA1MzA3IHByb2Nlc3NvciBzdXBwb3J0LgogCiBjb25maWcgTTUzMngKIAlib29sICJNQ0Y1MzJ4IgorCXNlbGVjdCBIQVZFX0NBQ0hFX0NCCiAJaGVscAogCSAgRnJlZXNjYWxlIChNb3Rvcm9sYSkgQ29sZEZpcmUgNTMyeCBwcm9jZXNzb3Igc3VwcG9ydC4KIAogY29uZmlnIE01NDA3CiAJYm9vbCAiTUNGNTQwNyIKKwlzZWxlY3QgQ09MREZJUkVfU1dfQTcKKwlzZWxlY3QgSEFWRV9DQUNIRV9DQgogCWhlbHAKIAkgIE1vdG9yb2xhIENvbGRGaXJlIDU0MDcgcHJvY2Vzc29yIHN1cHBvcnQuCiAKK2NvbmZpZyBNNTQ3eAorCWJvb2wgIk1DRjU0N3giCisJc2VsZWN0IEhBVkVfQ0FDSEVfQ0IKKwloZWxwCisJICBGcmVlc2NhbGUgQ29sZEZpcmUgNTQ3MC81NDcxLzU0NzIvNTQ3My81NDc0LzU0NzUgcHJvY2Vzc29yIHN1cHBvcnQuCisKIGNvbmZpZyBNNTQ4eAogCWJvb2wgIk1DRjU0OHgiCisJc2VsZWN0IEhBVkVfQ0FDSEVfQ0IKIAloZWxwCiAJICBGcmVlc2NhbGUgQ29sZEZpcmUgNTQ4MC81NDgxLzU0ODIvNTQ4My81NDg0LzU0ODUgcHJvY2Vzc29yIHN1cHBvcnQuCiAKQEAgLTE4MSw5ICsyMDUsMTQgQEAKIAlzZWxlY3QgR0VORVJJQ19DTE9DS0VWRU5UUwogCWRlZmF1bHQgeQogCitjb25maWcgTTU0eHgKKwlib29sCisJZGVwZW5kcyBvbiAoTTU0OHggfHwgTTU0N3gpCisJZGVmYXVsdCB5CisKIGNvbmZpZyBDT0xERklSRQogCWJvb2wKLQlkZXBlbmRzIG9uIChNNTIwNiB8fCBNNTIwNmUgfHwgTTUyMHggfHwgTTUyM3ggfHwgTTUyNDkgfHwgTTUyN3ggfHwgTTUyNzIgfHwgTTUyOHggfHwgTTUzMDcgfHwgTTUzMnggfHwgTTU0MDcgfHwgTTU0OHgpCisJZGVwZW5kcyBvbiAoTTUyMDYgfHwgTTUyMDZlIHx8IE01MjB4IHx8IE01MjN4IHx8IE01MjQ5IHx8IE01Mjd4IHx8IE01MjcyIHx8IE01Mjh4IHx8IE01MzA3IHx8IE01MzJ4IHx8IE01NDA3IHx8IE01NHh4KQogCXNlbGVjdCBHRU5FUklDX0dQSU8KIAlzZWxlY3QgQVJDSF9SRVFVSVJFX0dQSU9MSUIKIAlkZWZhdWx0IHkKQEAgLTIzMCw2ICsyNTksNDYgQEAKIAkgIEJ1aWxkIHN1cHBvcnQgZm9yIHRoZSBvbGRlciByZXZpc2lvbiBDb2xkRmlyZSA1MzA3IHNpbGljb24uCiAJICBTcGVjaWZpY2FsbHkgdGhpcyBpcyB0aGUgMUg1NUogbWFzayByZXZpc2lvbi4KIAoraWYgSEFWRV9DQUNIRV9TUExJVAorY2hvaWNlCisJcHJvbXB0ICJTcGxpdCBDYWNoZSBDb25maWd1cmF0aW9uIgorCWRlZmF1bHQgQ0FDSEVfSQorCitjb25maWcgQ0FDSEVfSQorCWJvb2wgIkluc3RydWN0aW9uIgorCWhlbHAKKwkgIFVzZSBhbGwgb2YgdGhlIENvbGRGaXJlIENQVSBjYWNoZSBtZW1vcnkgYXMgYW4gaW5zdHJ1Y3Rpb24gY2FjaGUuCisKK2NvbmZpZyBDQUNIRV9ECisJYm9vbCAiRGF0YSIKKwloZWxwCisJICBVc2UgYWxsIG9mIHRoZSBDb2xkRmlyZSBDUFUgY2FjaGUgbWVtb3J5IGFzIGEgZGF0YSBjYWNoZS4KKworY29uZmlnIENBQ0hFX0JPVEgKKwlib29sICJCb3RoIgorCWhlbHAKKwkgIFNwbGl0IHRoZSBDb2xkRmlyZSBDUFUgY2FjaGUsIGFuZCB1c2UgaGFsZiBhcyBhbiBpbnN0cnVjdGlvbiBjYWNoZQorCSAgYW5kIGhhbGYgYXMgYSBkYXRhIGNhY2hlLgorZW5kY2hvaWNlCitlbmRpZgorCitpZiBIQVZFX0NBQ0hFX0NCCitjaG9pY2UKKwlwcm9tcHQgIkRhdGEgY2FjaGUgbW9kZSIKKwlkZWZhdWx0IENBQ0hFX1dSSVRFVEhSVQorCitjb25maWcgQ0FDSEVfV1JJVEVUSFJVCisJYm9vbCAiV3JpdGUtdGhyb3VnaCIKKwloZWxwCisJICBUaGUgQ29sZEZpcmUgQ1BVIGNhY2hlIGlzIHNldCBpbnRvIFdyaXRlLXRocm91Z2ggbW9kZS4KKworY29uZmlnIENBQ0hFX0NPUFlCQUNLCisJYm9vbCAiQ29weS1iYWNrIgorCWhlbHAKKwkgIFRoZSBDb2xkRmlyZSBDUFUgY2FjaGUgaXMgc2V0IGludG8gQ29weS1iYWNrIG1vZGUuCitlbmRjaG9pY2UKK2VuZGlmCisKIGNvbW1lbnQgIlBsYXRmb3JtIgogCiBjb25maWcgUElMT1QzCkBAIC0yNDUsMTYgKzMxNCwxNiBAQAogCSAgU3VwcG9ydCB0aGUgYnVncyBvZiBYY29waWxvdC4KIAogY29uZmlnIFVDNTI3MgotICAgICAgICBib29sICdBcmN0dXJ1cyBOZXR3b3JrcyB1QzUyNzIgZGltbSBib2FyZCBzdXBwb3J0JwotICAgICAgICBkZXBlbmRzIG9uIE01MjcyCi0gICAgICAgIGhlbHAKLSAgICAgICAgICBTdXBwb3J0IGZvciB0aGUgQXJjdHVydXMgTmV0d29ya3MgdUM1MjcyIGRpbW0gYm9hcmQuCisJYm9vbCAnQXJjdHVydXMgTmV0d29ya3MgdUM1MjcyIGRpbW0gYm9hcmQgc3VwcG9ydCcKKwlkZXBlbmRzIG9uIE01MjcyCisJaGVscAorCSAgU3VwcG9ydCBmb3IgdGhlIEFyY3R1cnVzIE5ldHdvcmtzIHVDNTI3MiBkaW1tIGJvYXJkLgogCiBjb25maWcgVUM1MjgyCi0gICAgICAgYm9vbCAiQXJjdHVydXMgTmV0d29ya3MgdUM1MjgyIGJvYXJkIHN1cHBvcnQiCi0gICAgICAgICAgZGVwZW5kcyBvbiBNNTI4eAotICAgICAgIGhlbHAKLSAgICAgICAgICBTdXBwb3J0IGZvciB0aGUgQXJjdHVydXMgTmV0d29ya3MgdUM1MjgyIGRpbW0gYm9hcmQuCisJYm9vbCAiQXJjdHVydXMgTmV0d29ya3MgdUM1MjgyIGJvYXJkIHN1cHBvcnQiCisJZGVwZW5kcyBvbiBNNTI4eAorCWhlbHAKKwkgIFN1cHBvcnQgZm9yIHRoZSBBcmN0dXJ1cyBOZXR3b3JrcyB1QzUyODIgZGltbSBib2FyZC4KIAogY29uZmlnIFVDU0lNTQogCWJvb2wgInVDc2ltbSBtb2R1bGUgc3VwcG9ydCIKQEAgLTI3OSw3ICszNDgsNyBAQAogCWRlcGVuZHMgb24gKFVDU0lNTSB8fCBVQ0RJTU0gfHwgRFJBR0VOMikKIAloZWxwCiAJICBEaXNhYmxlIHRoZSBDUFUgaW50ZXJuYWwgcmVnaXN0ZXJzIHByb3RlY3Rpb24gaW4gdXNlciBtb2RlLAotICAgICAgICAgIHRvIGFsbG93IGEgdXNlciBhcHBsaWNhdGlvbiB0byByZWFkL3dyaXRlIHRoZW0uCisJICB0byBhbGxvdyBhIHVzZXIgYXBwbGljYXRpb24gdG8gcmVhZC93cml0ZSB0aGVtLgogCiBjb25maWcgSU5JVF9MQ0QKIAlib29sICJJbml0aWFsaXplIExDRCIKQEAgLTUxNyw3ICs1ODYsNyBAQAogCWRlcGVuZHMgb24gKFNPTTUyODJFTSkKIAogY29uZmlnIFNORUhBCi0gICAgICAgIGJvb2wKKwlib29sCiAJZGVmYXVsdCB5CiAJZGVwZW5kcyBvbiBDUFUxNkIKIApkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrbm9tbXUvTWFrZWZpbGUgYi9hcmNoL202OGtub21tdS9NYWtlZmlsZQppbmRleCAwMjZlZjE2Li41ODk2MTNmIDEwMDY0NAotLS0gYS9hcmNoL202OGtub21tdS9NYWtlZmlsZQorKysgYi9hcmNoL202OGtub21tdS9NYWtlZmlsZQpAQCAtMjUsNyArMjUsNyBAQAogcGxhdGZvcm0tJChDT05GSUdfTTUzMDcpCTo9IDUzMDcKIHBsYXRmb3JtLSQoQ09ORklHX001MzJ4KQk6PSA1MzJ4CiBwbGF0Zm9ybS0kKENPTkZJR19NNTQwNykJOj0gNTQwNwotcGxhdGZvcm0tJChDT05GSUdfTTU0OHgpCTo9IDU0OHgKK3BsYXRmb3JtLSQoQ09ORklHX001NHh4KQk6PSA1NHh4CiBQTEFURk9STSA6PSAkKHBsYXRmb3JtLXkpCiAKIGJvYXJkLSQoQ09ORklHX1BJTE9UKQkJOj0gcGlsb3QKQEAgLTc0LDcgKzc0LDcgQEAKIGNwdWNsYXNzLSQoQ09ORklHX001MzA3KQk6PSBjb2xkZmlyZQogY3B1Y2xhc3MtJChDT05GSUdfTTUzMngpCTo9IGNvbGRmaXJlCiBjcHVjbGFzcy0kKENPTkZJR19NNTQwNykJOj0gY29sZGZpcmUKLWNwdWNsYXNzLSQoQ09ORklHX001NDh4KQk6PSBjb2xkZmlyZQorY3B1Y2xhc3MtJChDT05GSUdfTTU0eHgpCTo9IGNvbGRmaXJlCiBjcHVjbGFzcy0kKENPTkZJR19NNjgzMjgpCTo9IDY4MzI4CiBjcHVjbGFzcy0kKENPTkZJR19NNjhFWjMyOCkJOj0gNjgzMjgKIGNwdWNsYXNzLSQoQ09ORklHX002OFZaMzI4KQk6PSA2ODMyOApAQCAtOTEsMTggKzkxLDE4IEBACiAjIFNvbWUgQ0ZMQUcgYWRkaXRpb25zIGJhc2VkIG9uIHNwZWNpZmljIENQVSB0eXBlLgogIwogY2ZsYWdzLSQoQ09ORklHX001MjA2KQkJOj0gJChjYWxsIGNjLW9wdGlvbiwtbWNwdT01MjA2LC1tNTIwMCkKLWNmbGFncy0kKENPTkZJR19NNTIwNmUpCQk6PSAkKGNhbGwgY2Mtb3B0aW9uLC1tNTIwNmUsLW01MjAwKQorY2ZsYWdzLSQoQ09ORklHX001MjA2ZSkJCTo9ICQoY2FsbCBjYy1vcHRpb24sLW1jcHU9NTIwNmUsLW01MjAwKQogY2ZsYWdzLSQoQ09ORklHX001MjB4KQkJOj0gJChjYWxsIGNjLW9wdGlvbiwtbWNwdT01MjA4LC1tNTIwMCkKIGNmbGFncy0kKENPTkZJR19NNTIzeCkJCTo9ICQoY2FsbCBjYy1vcHRpb24sLW1jcHU9NTIzeCwtbTUzMDcpCiBjZmxhZ3MtJChDT05GSUdfTTUyNDkpCQk6PSAkKGNhbGwgY2Mtb3B0aW9uLC1tY3B1PTUyNDksLW01MjAwKQogY2ZsYWdzLSQoQ09ORklHX001MjcxKQkJOj0gJChjYWxsIGNjLW9wdGlvbiwtbWNwdT01MjcxLC1tNTMwNykKIGNmbGFncy0kKENPTkZJR19NNTI3MikJCTo9ICQoY2FsbCBjYy1vcHRpb24sLW1jcHU9NTI3MiwtbTUzMDcpCiBjZmxhZ3MtJChDT05GSUdfTTUyNzUpCQk6PSAkKGNhbGwgY2Mtb3B0aW9uLC1tY3B1PTUyNzUsLW01MzA3KQotY2ZsYWdzLSQoQ09ORklHX001Mjh4KQkJOj0gJChjYWxsIGNjLW9wdGlvbiwtbTUyOHgsLW01MzA3KQotY2ZsYWdzLSQoQ09ORklHX001MzA3KQkJOj0gJChjYWxsIGNjLW9wdGlvbiwtbTUzMDcsLW01MjAwKQorY2ZsYWdzLSQoQ09ORklHX001Mjh4KQkJOj0gJChjYWxsIGNjLW9wdGlvbiwtbWNwdT01Mjh4LC1tNTMwNykKK2NmbGFncy0kKENPTkZJR19NNTMwNykJCTo9ICQoY2FsbCBjYy1vcHRpb24sLW1jcHU9NTMwNywtbTUyMDApCiBjZmxhZ3MtJChDT05GSUdfTTUzMngpCQk6PSAkKGNhbGwgY2Mtb3B0aW9uLC1tY3B1PTUzMngsLW01MzA3KQotY2ZsYWdzLSQoQ09ORklHX001NDA3KQkJOj0gJChjYWxsIGNjLW9wdGlvbiwtbTU0MDcsLW01MjAwKQotY2ZsYWdzLSQoQ09ORklHX001NDh4KQkJOj0gJChjYWxsIGNjLW9wdGlvbiwtbTU0MDcsLW01MjAwKQorY2ZsYWdzLSQoQ09ORklHX001NDA3KQkJOj0gJChjYWxsIGNjLW9wdGlvbiwtbWNwdT01NDA3LC1tNTIwMCkKK2NmbGFncy0kKENPTkZJR19NNTR4eCkJCTo9ICQoY2FsbCBjYy1vcHRpb24sLW1jcHU9NTQ3NSwtbTUyMDApCiBjZmxhZ3MtJChDT05GSUdfTTY4MzI4KQkJOj0gLW02ODAwMAogY2ZsYWdzLSQoQ09ORklHX002OEVaMzI4KQk6PSAtbTY4MDAwCiBjZmxhZ3MtJChDT05GSUdfTTY4VlozMjgpCTo9IC1tNjgwMDAKZGlmZiAtLWdpdCBhL2FyY2gvbTY4a25vbW11L2NvbmZpZ3MvbTUyMDhldmJfZGVmY29uZmlnIGIvYXJjaC9tNjhrbm9tbXUvY29uZmlncy9tNTIwOGV2Yl9kZWZjb25maWcKaW5kZXggNmFjMjk4MS4uMmY1NjU1YyAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrbm9tbXUvY29uZmlncy9tNTIwOGV2Yl9kZWZjb25maWcKKysrIGIvYXJjaC9tNjhrbm9tbXUvY29uZmlncy9tNTIwOGV2Yl9kZWZjb25maWcKQEAgLTEsNyArMSw3IEBACiBDT05GSUdfRVhQRVJJTUVOVEFMPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX0ZVVEVYIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvbTY4a25vbW11L2NvbmZpZ3MvbTUyNDlldmJfZGVmY29uZmlnIGIvYXJjaC9tNjhrbm9tbXUvY29uZmlncy9tNTI0OWV2Yl9kZWZjb25maWcKaW5kZXggMTQ5MzRmZi4uMTZkZjcyYiAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrbm9tbXUvY29uZmlncy9tNTI0OWV2Yl9kZWZjb25maWcKKysrIGIvYXJjaC9tNjhrbm9tbXUvY29uZmlncy9tNTI0OWV2Yl9kZWZjb25maWcKQEAgLTEsNyArMSw3IEBACiBDT05GSUdfRVhQRVJJTUVOVEFMPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX0ZVVEVYIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvbTY4a25vbW11L2NvbmZpZ3MvbTUyNzJjM19kZWZjb25maWcgYi9hcmNoL202OGtub21tdS9jb25maWdzL201MjcyYzNfZGVmY29uZmlnCmluZGV4IDU5ODVhM2IuLjRlNmVhNTAgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4a25vbW11L2NvbmZpZ3MvbTUyNzJjM19kZWZjb25maWcKKysrIGIvYXJjaC9tNjhrbm9tbXUvY29uZmlncy9tNTI3MmMzX2RlZmNvbmZpZwpAQCAtMSw3ICsxLDcgQEAKIENPTkZJR19FWFBFUklNRU5UQUw9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX0hPVFBMVUcgaXMgbm90IHNldAogIyBDT05GSUdfRlVURVggaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrbm9tbXUvY29uZmlncy9tNTI3NWV2Yl9kZWZjb25maWcgYi9hcmNoL202OGtub21tdS9jb25maWdzL201Mjc1ZXZiX2RlZmNvbmZpZwppbmRleCA1YTc4NTdlLi5mM2RkNzQxIDEwMDY0NAotLS0gYS9hcmNoL202OGtub21tdS9jb25maWdzL201Mjc1ZXZiX2RlZmNvbmZpZworKysgYi9hcmNoL202OGtub21tdS9jb25maWdzL201Mjc1ZXZiX2RlZmNvbmZpZwpAQCAtMSw3ICsxLDcgQEAKIENPTkZJR19FWFBFUklNRU5UQUw9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX0hPVFBMVUcgaXMgbm90IHNldAogIyBDT05GSUdfRlVURVggaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrbm9tbXUvY29uZmlncy9tNTMwN2MzX2RlZmNvbmZpZyBiL2FyY2gvbTY4a25vbW11L2NvbmZpZ3MvbTUzMDdjM19kZWZjb25maWcKaW5kZXggZTgxMDIwMS4uYmNlMGEyMCAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrbm9tbXUvY29uZmlncy9tNTMwN2MzX2RlZmNvbmZpZworKysgYi9hcmNoL202OGtub21tdS9jb25maWdzL201MzA3YzNfZGVmY29uZmlnCkBAIC0xLDcgKzEsNyBAQAogQ09ORklHX0VYUEVSSU1FTlRBTD15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfSE9UUExVRyBpcyBub3Qgc2V0CiAjIENPTkZJR19GVVRFWCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL202OGtub21tdS9jb25maWdzL201NDA3YzNfZGVmY29uZmlnIGIvYXJjaC9tNjhrbm9tbXUvY29uZmlncy9tNTQwN2MzX2RlZmNvbmZpZwppbmRleCA1YzEyNGE3Li42MThjYzMyIDEwMDY0NAotLS0gYS9hcmNoL202OGtub21tdS9jb25maWdzL201NDA3YzNfZGVmY29uZmlnCisrKyBiL2FyY2gvbTY4a25vbW11L2NvbmZpZ3MvbTU0MDdjM19kZWZjb25maWcKQEAgLTEsNyArMSw3IEBACiBDT05GSUdfRVhQRVJJTUVOVEFMPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX0ZVVEVYIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvbTY4a25vbW11L2RlZmNvbmZpZyBiL2FyY2gvbTY4a25vbW11L2RlZmNvbmZpZwppbmRleCA2YWMyOTgxLi4yZjU2NTVjIDEwMDY0NAotLS0gYS9hcmNoL202OGtub21tdS9kZWZjb25maWcKKysrIGIvYXJjaC9tNjhrbm9tbXUvZGVmY29uZmlnCkBAIC0xLDcgKzEsNyBAQAogQ09ORklHX0VYUEVSSU1FTlRBTD15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfSE9UUExVRyBpcyBub3Qgc2V0CiAjIENPTkZJR19GVVRFWCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL202OGtub21tdS9rZXJuZWwvc2V0dXAuYyBiL2FyY2gvbTY4a25vbW11L2tlcm5lbC9zZXR1cC5jCmluZGV4IGM2ODRhZGYuLjE2YjJkZTcgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4a25vbW11L2tlcm5lbC9zZXR1cC5jCisrKyBiL2FyY2gvbTY4a25vbW11L2tlcm5lbC9zZXR1cC5jCkBAIC01NSw1NSArNTUsMjkgQEAKIHZvaWQgKCptYWNoX3Bvd2VyX29mZikodm9pZCk7CiAKICNpZmRlZiBDT05GSUdfTTY4MzI4Ci0JI2RlZmluZSBDUFUgIk1DNjgzMjgiCisjZGVmaW5lIENQVV9OQU1FCSJNQzY4MzI4IgogI2VuZGlmCiAjaWZkZWYgQ09ORklHX002OEVaMzI4Ci0JI2RlZmluZSBDUFUgIk1DNjhFWjMyOCIKKyNkZWZpbmUgQ1BVX05BTUUJIk1DNjhFWjMyOCIKICNlbmRpZgogI2lmZGVmIENPTkZJR19NNjhWWjMyOAotCSNkZWZpbmUgQ1BVICJNQzY4VlozMjgiCisjZGVmaW5lIENQVV9OQU1FCSJNQzY4VlozMjgiCiAjZW5kaWYKICNpZmRlZiBDT05GSUdfTTY4MzYwCi0JI2RlZmluZSBDUFUgIk1DNjgzNjAiCisjZGVmaW5lIENQVV9OQU1FCSJNQzY4MzYwIgogI2VuZGlmCi0jaWYgZGVmaW5lZChDT05GSUdfTTUyMDYpCi0JI2RlZmluZQlDUFUgIkNPTERGSVJFKG01MjA2KSIKKyNpZm5kZWYgQ1BVX05BTUUKKyNkZWZpbmUJQ1BVX05BTUUJIlVOS05PV04iCiAjZW5kaWYKLSNpZiBkZWZpbmVkKENPTkZJR19NNTIwNmUpCi0JI2RlZmluZQlDUFUgIkNPTERGSVJFKG01MjA2ZSkiCi0jZW5kaWYKLSNpZiBkZWZpbmVkKENPTkZJR19NNTIweCkKLQkjZGVmaW5lIENQVSAiQ09MREZJUkUobTUyMHgpIgotI2VuZGlmCi0jaWYgZGVmaW5lZChDT05GSUdfTTUyM3gpCi0JI2RlZmluZSBDUFUgIkNPTERGSVJFKG01MjN4KSIKLSNlbmRpZgotI2lmIGRlZmluZWQoQ09ORklHX001MjQ5KQotCSNkZWZpbmUgQ1BVICJDT0xERklSRShtNTI0OSkiCi0jZW5kaWYKLSNpZiBkZWZpbmVkKENPTkZJR19NNTI3MSkKLQkjZGVmaW5lIENQVSAiQ09MREZJUkUobTUyNzAvNTI3MSkiCi0jZW5kaWYKLSNpZiBkZWZpbmVkKENPTkZJR19NNTI3MikKLQkjZGVmaW5lIENQVSAiQ09MREZJUkUobTUyNzIpIgotI2VuZGlmCi0jaWYgZGVmaW5lZChDT05GSUdfTTUyNzUpCi0JI2RlZmluZSBDUFUgIkNPTERGSVJFKG01Mjc0LzUyNzUpIgotI2VuZGlmCi0jaWYgZGVmaW5lZChDT05GSUdfTTUyOHgpCi0JI2RlZmluZSBDUFUgIkNPTERGSVJFKG01MjgwLzUyODIpIgotI2VuZGlmCi0jaWYgZGVmaW5lZChDT05GSUdfTTUzMDcpCi0JI2RlZmluZQlDUFUgIkNPTERGSVJFKG01MzA3KSIKLSNlbmRpZgotI2lmIGRlZmluZWQoQ09ORklHX001MzJ4KQotCSNkZWZpbmUJQ1BVICJDT0xERklSRShtNTMyeCkiCi0jZW5kaWYKLSNpZiBkZWZpbmVkKENPTkZJR19NNTQwNykKLQkjZGVmaW5lCUNQVSAiQ09MREZJUkUobTU0MDcpIgotI2VuZGlmCi0jaWZuZGVmIENQVQotCSNkZWZpbmUJQ1BVICJVTktOT1dOIgorCisvKgorICogRGlmZmVyZW50IGNvcmVzIGhhdmUgZGlmZmVyZW50IGluc3RydWN0aW9uIGV4ZWN1dGlvbiB0aW1pbmdzLgorICogVGhlIG9sZC90cmFkaXRpb25hbCA2ODAwMCBjb3JlcyBhcmUgYmFzaWNhbGx5IGFsbCB0aGUgc2FtZSwgYXQgMTYuCisgKiBUaGUgQ29sZEZpcmUgY29yZXMgdmFyeSBhIGxpdHRsZSwgdGhlaXIgdmFsdWVzIGFyZSBkZWZpbmVkIGluIHRoZWlyCisgKiBoZWFkZXJzLiBXZSBkZWZhdWx0IHRvIHRoZSBzdGFuZGFyZCA2ODAwMCB2YWx1ZSBoZXJlLgorICovCisjaWZuZGVmIENQVV9JTlNUUl9QRVJfSklGRlkKKyNkZWZpbmUJQ1BVX0lOU1RSX1BFUl9KSUZGWQkxNgogI2VuZGlmCiAKIGV4dGVybiBpbnQgX3N0ZXh0LCBfZXRleHQsIF9zZGF0YSwgX2VkYXRhLCBfc2JzcywgX2Vic3MsIF9lbmQ7CkBAIC0yMDgsNyArMTgyLDcgQEAKIAljb21tYW5kX2xpbmVbc2l6ZW9mKGNvbW1hbmRfbGluZSkgLSAxXSA9IDA7CiAjZW5kaWYgLyogQ09ORklHX1VCT09UICovCiAKLQlwcmludGsoS0VSTl9JTkZPICJceDBGXHJcblxudUNsaW51eC8iIENQVSAiXG4iKTsKKwlwcmludGsoS0VSTl9JTkZPICJceDBGXHJcblxudUNsaW51eC8iIENQVV9OQU1FICJcbiIpOwogCiAjaWZkZWYgQ09ORklHX1VDRElNTQogCXByaW50ayhLRVJOX0lORk8gInVDZGltbSBieSBMaW5lbywgSW5jLiA8d3d3LmxpbmVvLmNvbT5cbiIpOwpAQCAtMjU3LDExICsyMzEsNiBAQAogCW1lbWNweShib290X2NvbW1hbmRfbGluZSwgY29tbWFuZF9saW5lLCBDT01NQU5EX0xJTkVfU0laRSk7CiAJYm9vdF9jb21tYW5kX2xpbmVbQ09NTUFORF9MSU5FX1NJWkUtMV0gPSAwOwogCi0jaWZkZWYgREVCVUcKLQlpZiAoc3RybGVuKCpjbWRsaW5lX3ApKQotCQlwcmludGsoS0VSTl9ERUJVRyAiQ29tbWFuZCBsaW5lOiAnJXMnXG4iLCAqY21kbGluZV9wKTsKLSNlbmRpZgotCiAjaWYgZGVmaW5lZChDT05GSUdfRlJBTUVCVUZGRVJfQ09OU09MRSkgJiYgZGVmaW5lZChDT05GSUdfRFVNTVlfQ09OU09MRSkKIAljb25zd2l0Y2hwID0gJmR1bW15X2NvbjsKICNlbmRpZgpAQCAtMzAzLDE1ICsyNzIsMTAgQEAKIAljaGFyICpjcHUsICptbXUsICpmcHU7CiAJdV9sb25nIGNsb2NrZnJlcTsKIAotCWNwdSA9IENQVTsKKwljcHUgPSBDUFVfTkFNRTsKIAltbXUgPSAibm9uZSI7CiAJZnB1ID0gIm5vbmUiOwotCi0jaWZkZWYgQ09ORklHX0NPTERGSVJFCi0JY2xvY2tmcmVxID0gKGxvb3BzX3Blcl9qaWZmeSAqIEhaKSAqIDM7Ci0jZWxzZQotCWNsb2NrZnJlcSA9IChsb29wc19wZXJfamlmZnkgKiBIWikgKiAxNjsKLSNlbmRpZgorCWNsb2NrZnJlcSA9IChsb29wc19wZXJfamlmZnkgKiBIWikgKiBDUFVfSU5TVFJfUEVSX0pJRkZZOwogCiAJc2VxX3ByaW50ZihtLCAiQ1BVOlx0XHQlc1xuIgogCQkgICAgICAiTU1VOlx0XHQlc1xuIgpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrbm9tbXUvbW0vTWFrZWZpbGUgYi9hcmNoL202OGtub21tdS9tbS9NYWtlZmlsZQppbmRleCBmYzkxZjI1Li5iNTRhYjZiIDEwMDY0NAotLS0gYS9hcmNoL202OGtub21tdS9tbS9NYWtlZmlsZQorKysgYi9hcmNoL202OGtub21tdS9tbS9NYWtlZmlsZQpAQCAtMiw0ICsyLDQgQEAKICMgTWFrZWZpbGUgZm9yIHRoZSBsaW51eCBtNjhrbm9tbXUgc3BlY2lmaWMgcGFydHMgb2YgdGhlIG1lbW9yeSBtYW5hZ2VyLgogIwogCi1vYmoteSArPSBpbml0Lm8gZmF1bHQubyBtZW1vcnkubyBrbWFwLm8KK29iai15ICs9IGluaXQubyBrbWFwLm8KZGlmZiAtLWdpdCBhL2FyY2gvbTY4a25vbW11L21tL2ZhdWx0LmMgYi9hcmNoL202OGtub21tdS9tbS9mYXVsdC5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiYzA1Y2Y3Li4wMDAwMDAwCi0tLSBhL2FyY2gvbTY4a25vbW11L21tL2ZhdWx0LmMKKysrIC9kZXYvbnVsbApAQCAtMSw1NyArMCwwIEBACi0vKgotICogIGxpbnV4L2FyY2gvbTY4a25vbW11L21tL2ZhdWx0LmMKLSAqCi0gKiAgQ29weXJpZ2h0IChDKSAxOTk4ICBELiBKZWZmIERpb25uZSA8amVmZkBsaW5lby5jYT4sCi0gKiAgQ29weXJpZ2h0IChDKSAyMDAwICBMaW5lbywgSW5jLiAgKHd3dy5saW5lby5jb20pCi0gKgotICogIEJhc2VkIG9uOgotICoKLSAqICBsaW51eC9hcmNoL202OGsvbW0vZmF1bHQuYwotICoKLSAqICBDb3B5cmlnaHQgKEMpIDE5OTUgIEhhbWlzaCBNYWNkb25hbGQKLSAqLwotCi0jaW5jbHVkZSA8bGludXgvbW1hbi5oPgotI2luY2x1ZGUgPGxpbnV4L21tLmg+Ci0jaW5jbHVkZSA8bGludXgva2VybmVsLmg+Ci0jaW5jbHVkZSA8bGludXgvcHRyYWNlLmg+Ci0KLSNpbmNsdWRlIDxhc20vc3lzdGVtLmg+Ci0jaW5jbHVkZSA8YXNtL3BndGFibGUuaD4KLQotZXh0ZXJuIHZvaWQgZGllX2lmX2tlcm5lbChjaGFyICosIHN0cnVjdCBwdF9yZWdzICosIGxvbmcpOwotCi0vKgotICogVGhpcyByb3V0aW5lIGhhbmRsZXMgcGFnZSBmYXVsdHMuICBJdCBkZXRlcm1pbmVzIHRoZSBwcm9ibGVtLCBhbmQKLSAqIHRoZW4gcGFzc2VzIGl0IG9mZiB0byBvbmUgb2YgdGhlIGFwcHJvcHJpYXRlIHJvdXRpbmVzLgotICoKLSAqIGVycm9yX2NvZGU6Ci0gKgliaXQgMCA9PSAwIG1lYW5zIG5vIHBhZ2UgZm91bmQsIDEgbWVhbnMgcHJvdGVjdGlvbiBmYXVsdAotICoJYml0IDEgPT0gMCBtZWFucyByZWFkLCAxIG1lYW5zIHdyaXRlCi0gKgotICogSWYgdGhpcyByb3V0aW5lIGRldGVjdHMgYSBiYWQgYWNjZXNzLCBpdCByZXR1cm5zIDEsIG90aGVyd2lzZSBpdAotICogcmV0dXJucyAwLgotICovCi1hc21saW5rYWdlIGludCBkb19wYWdlX2ZhdWx0KHN0cnVjdCBwdF9yZWdzICpyZWdzLCB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCi0JCQkgICAgICB1bnNpZ25lZCBsb25nIGVycm9yX2NvZGUpCi17Ci0jaWZkZWYgREVCVUcKLQlwcmludGsoS0VSTl9ERUJVRyAicmVncy0+c3I9JSN4LCByZWdzLT5wYz0lI2x4LCBhZGRyZXNzPSUjbHgsICVsZFxuIiwKLQkJcmVncy0+c3IsIHJlZ3MtPnBjLCBhZGRyZXNzLCBlcnJvcl9jb2RlKTsKLSNlbmRpZgotCi0JLyoKLQkgKiBPb3BzLiBUaGUga2VybmVsIHRyaWVkIHRvIGFjY2VzcyBzb21lIGJhZCBwYWdlLiBXZSdsbCBoYXZlIHRvCi0JICogdGVybWluYXRlIHRoaW5ncyB3aXRoIGV4dHJlbWUgcHJlanVkaWNlLgotCSAqLwotCWlmICgodW5zaWduZWQgbG9uZykgYWRkcmVzcyA8IFBBR0VfU0laRSkKLQkJcHJpbnRrKEtFUk5fQUxFUlQgIlVuYWJsZSB0byBoYW5kbGUga2VybmVsIE5VTEwgcG9pbnRlciBkZXJlZmVyZW5jZSIpOwotCWVsc2UKLQkJcHJpbnRrKEtFUk5fQUxFUlQgIlVuYWJsZSB0byBoYW5kbGUga2VybmVsIGFjY2VzcyIpOwotCXByaW50ayhLRVJOX0FMRVJUICIgYXQgdmlydHVhbCBhZGRyZXNzICUwOGx4XG4iLCBhZGRyZXNzKTsKLQlkaWVfaWZfa2VybmVsKCJPb3BzIiwgcmVncywgZXJyb3JfY29kZSk7Ci0JZG9fZXhpdChTSUdLSUxMKTsKLQotCXJldHVybiAxOwotfQotCmRpZmYgLS1naXQgYS9hcmNoL202OGtub21tdS9tbS9rbWFwLmMgYi9hcmNoL202OGtub21tdS9tbS9rbWFwLmMKaW5kZXggOTAyYzFkZi4uZWNlOGQ1YSAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrbm9tbXUvbW0va21hcC5jCisrKyBiL2FyY2gvbTY4a25vbW11L21tL2ttYXAuYwpAQCAtMzYsMTUgKzM2LDYgQEAKIH0KIAogLyoKLSAqIF9faW91bm1hcCB1bm1hcHMgbmVhcmx5IGV2ZXJ5dGhpbmcsIHNvIGJlIGNhcmVmdWwKLSAqIGl0IGRvZXNuJ3QgZnJlZSBjdXJyZW50bHkgcG9pbnRlci9wYWdlIHRhYmxlcyBhbnltb3JlIGJ1dCBpdAotICogd2Fucyd0IHVzZWQgYW55d2F5IGFuZCBtaWdodCBiZSBhZGRlZCBsYXRlci4KLSAqLwotdm9pZCBfX2lvdW5tYXAodm9pZCAqYWRkciwgdW5zaWduZWQgbG9uZyBzaXplKQotewotfQotCi0vKgogICogU2V0IG5ldyBjYWNoZSBtb2RlIGZvciBzb21lIGtlcm5lbCBhZGRyZXNzIHNwYWNlLgogICogVGhlIGNhbGxlciBtdXN0IHB1c2ggZGF0YSBmb3IgdGhhdCByYW5nZSBpdHNlbGYsIGlmIHN1Y2ggZGF0YSBtYXkgYWxyZWFkeQogICogYmUgaW4gdGhlIGNhY2hlLgpkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrbm9tbXUvbW0vbWVtb3J5LmMgYi9hcmNoL202OGtub21tdS9tbS9tZW1vcnkuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOGY3OTQ5ZS4uMDAwMDAwMAotLS0gYS9hcmNoL202OGtub21tdS9tbS9tZW1vcnkuYworKysgL2Rldi9udWxsCkBAIC0xLDMzICswLDAgQEAKLS8qCi0gKiAgbGludXgvYXJjaC9tNjhrbm9tbXUvbW0vbWVtb3J5LmMKLSAqCi0gKiAgQ29weXJpZ2h0IChDKSAxOTk4ICBLZW5uZXRoIEFsYmFub3dza2kgPGtqYWhkc0BramFoZHMuY29tPiwKLSAqICBDb3B5cmlnaHQgKEMpIDE5OTktMjAwMiwgR3JlZyBVbmdlcmVyIChnZXJnQHNuYXBnZWFyLmNvbSkKLSAqCi0gKiAgQmFzZWQgb246Ci0gKgotICogIGxpbnV4L2FyY2gvbTY4ay9tbS9tZW1vcnkuYwotICoKLSAqICBDb3B5cmlnaHQgKEMpIDE5OTUgIEhhbWlzaCBNYWNkb25hbGQKLSAqLwotCi0jaW5jbHVkZSA8bGludXgvbW0uaD4KLSNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KLSNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KLSNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgotCi0jaW5jbHVkZSA8YXNtL3NlZ21lbnQuaD4KLSNpbmNsdWRlIDxhc20vcGFnZS5oPgotI2luY2x1ZGUgPGFzbS9wZ3RhYmxlLmg+Ci0jaW5jbHVkZSA8YXNtL3N5c3RlbS5oPgotCi0vKgotICogTWFwIHNvbWUgcGh5c2ljYWwgYWRkcmVzcyByYW5nZSBpbnRvIHRoZSBrZXJuZWwgYWRkcmVzcyBzcGFjZS4KLSAqLwotCi11bnNpZ25lZCBsb25nIGtlcm5lbF9tYXAodW5zaWduZWQgbG9uZyBwYWRkciwgdW5zaWduZWQgbG9uZyBzaXplLAotCQkJIGludCBub2NhY2hlZmxhZywgdW5zaWduZWQgbG9uZyAqbWVtYXZhaWxwICkKLXsKLQlyZXR1cm4gcGFkZHI7Ci19Ci0KZGlmZiAtLWdpdCBhL2FyY2gvbTY4a25vbW11L3BsYXRmb3JtLzU0OHgvTWFrZWZpbGUgYi9hcmNoL202OGtub21tdS9wbGF0Zm9ybS81NHh4L01ha2VmaWxlCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBhcmNoL202OGtub21tdS9wbGF0Zm9ybS81NDh4L01ha2VmaWxlCnJlbmFtZSB0byBhcmNoL202OGtub21tdS9wbGF0Zm9ybS81NHh4L01ha2VmaWxlCmRpZmYgLS1naXQgYS9hcmNoL202OGtub21tdS9wbGF0Zm9ybS81NDh4L2NvbmZpZy5jIGIvYXJjaC9tNjhrbm9tbXUvcGxhdGZvcm0vNTR4eC9jb25maWcuYwpzaW1pbGFyaXR5IGluZGV4IDc0JQpyZW5hbWUgZnJvbSBhcmNoL202OGtub21tdS9wbGF0Zm9ybS81NDh4L2NvbmZpZy5jCnJlbmFtZSB0byBhcmNoL202OGtub21tdS9wbGF0Zm9ybS81NHh4L2NvbmZpZy5jCmluZGV4IDk4ODg4NDYuLjc4MTMwOTggMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4a25vbW11L3BsYXRmb3JtLzU0OHgvY29uZmlnLmMKKysrIGIvYXJjaC9tNjhrbm9tbXUvcGxhdGZvcm0vNTR4eC9jb25maWcuYwpAQCAtMSw3ICsxLDcgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKglsaW51eC9hcmNoL202OGtub21tdS9wbGF0Zm9ybS81NDh4L2NvbmZpZy5jCisgKglsaW51eC9hcmNoL202OGtub21tdS9wbGF0Zm9ybS81NHh4L2NvbmZpZy5jCiAgKgogICoJQ29weXJpZ2h0IChDKSAyMDEwLCBQaGlsaXBwZSBEZSBNdXl0ZXIgPHBoZG1AbWFjcWVsLmJlPgogICovCkBAIC0xNSwxMyArMTUsMTMgQEAKICNpbmNsdWRlIDxsaW51eC9pby5oPgogI2luY2x1ZGUgPGFzbS9tYWNoZGVwLmg+CiAjaW5jbHVkZSA8YXNtL2NvbGRmaXJlLmg+Ci0jaW5jbHVkZSA8YXNtL201NDh4c2ltLmg+CisjaW5jbHVkZSA8YXNtL201NHh4c2ltLmg+CiAjaW5jbHVkZSA8YXNtL21jZnVhcnQuaD4KLSNpbmNsdWRlIDxhc20vbTU0OHhncHQuaD4KKyNpbmNsdWRlIDxhc20vbTU0eHhncHQuaD4KIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAotc3RhdGljIHN0cnVjdCBtY2ZfcGxhdGZvcm1fdWFydCBtNTQ4eF91YXJ0X3BsYXRmb3JtW10gPSB7CitzdGF0aWMgc3RydWN0IG1jZl9wbGF0Zm9ybV91YXJ0IG01NHh4X3VhcnRfcGxhdGZvcm1bXSA9IHsKIAl7CiAJCS5tYXBiYXNlCT0gTUNGX01CQVIgKyBNQ0ZVQVJUX0JBU0UxLAogCQkuaXJxCQk9IDY0ICsgMzUsCkBAIC00MCwyMCArNDAsMjAgQEAKIAl9LAogfTsKIAotc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgbTU0OHhfdWFydCA9IHsKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIG01NHh4X3VhcnQgPSB7CiAJLm5hbWUJCQk9ICJtY2Z1YXJ0IiwKIAkuaWQJCQk9IDAsCi0JLmRldi5wbGF0Zm9ybV9kYXRhCT0gbTU0OHhfdWFydF9wbGF0Zm9ybSwKKwkuZGV2LnBsYXRmb3JtX2RhdGEJPSBtNTR4eF91YXJ0X3BsYXRmb3JtLAogfTsKIAotc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKm01NDh4X2RldmljZXNbXSBfX2luaXRkYXRhID0gewotCSZtNTQ4eF91YXJ0LAorc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKm01NHh4X2RldmljZXNbXSBfX2luaXRkYXRhID0geworCSZtNTR4eF91YXJ0LAogfTsKIAogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCi1zdGF0aWMgdm9pZCBfX2luaXQgbTU0OHhfdWFydF9pbml0X2xpbmUoaW50IGxpbmUsIGludCBpcnEpCitzdGF0aWMgdm9pZCBfX2luaXQgbTU0eHhfdWFydF9pbml0X2xpbmUoaW50IGxpbmUsIGludCBpcnEpCiB7CiAJaW50IHJ0c19jdHM7CiAKQEAgLTcyLDE4ICs3MiwxOCBAQAogCQkJCQkJTUNGX01CQVIgKyBNQ0ZfUEFSX1BTQyhsaW5lKSk7CiB9CiAKLXN0YXRpYyB2b2lkIF9faW5pdCBtNTQ4eF91YXJ0c19pbml0KHZvaWQpCitzdGF0aWMgdm9pZCBfX2luaXQgbTU0eHhfdWFydHNfaW5pdCh2b2lkKQogewotCWNvbnN0IGludCBucmxpbmVzID0gQVJSQVlfU0laRShtNTQ4eF91YXJ0X3BsYXRmb3JtKTsKKwljb25zdCBpbnQgbnJsaW5lcyA9IEFSUkFZX1NJWkUobTU0eHhfdWFydF9wbGF0Zm9ybSk7CiAJaW50IGxpbmU7CiAKIAlmb3IgKGxpbmUgPSAwOyAobGluZSA8IG5ybGluZXMpOyBsaW5lKyspCi0JCW01NDh4X3VhcnRfaW5pdF9saW5lKGxpbmUsIG01NDh4X3VhcnRfcGxhdGZvcm1bbGluZV0uaXJxKTsKKwkJbTU0eHhfdWFydF9pbml0X2xpbmUobGluZSwgbTU0eHhfdWFydF9wbGF0Zm9ybVtsaW5lXS5pcnEpOwogfQogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCi1zdGF0aWMgdm9pZCBtY2Y1NDh4X3Jlc2V0KHZvaWQpCitzdGF0aWMgdm9pZCBtY2Y1NHh4X3Jlc2V0KHZvaWQpCiB7CiAJLyogZGlzYWJsZSBpbnRlcnJ1cHRzIGFuZCBlbmFibGUgdGhlIHdhdGNoZG9nICovCiAJYXNtKCJtb3ZldyAjMHgyNzAwLCAlc3JcbiIpOwpAQCAtOTcsOCArOTcsOCBAQAogCiB2b2lkIF9faW5pdCBjb25maWdfQlNQKGNoYXIgKmNvbW1hbmRwLCBpbnQgc2l6ZSkKIHsKLQltYWNoX3Jlc2V0ID0gbWNmNTQ4eF9yZXNldDsKLQltNTQ4eF91YXJ0c19pbml0KCk7CisJbWFjaF9yZXNldCA9IG1jZjU0eHhfcmVzZXQ7CisJbTU0eHhfdWFydHNfaW5pdCgpOwogfQogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwpAQCAtMTA2LDcgKzEwNiw3IEBACiBzdGF0aWMgaW50IF9faW5pdCBpbml0X0JTUCh2b2lkKQogewogCi0JcGxhdGZvcm1fYWRkX2RldmljZXMobTU0OHhfZGV2aWNlcywgQVJSQVlfU0laRShtNTQ4eF9kZXZpY2VzKSk7CisJcGxhdGZvcm1fYWRkX2RldmljZXMobTU0eHhfZGV2aWNlcywgQVJSQVlfU0laRShtNTR4eF9kZXZpY2VzKSk7CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL2FyY2gvbTY4a25vbW11L3BsYXRmb3JtLzY4MzI4L2ludHMuYyBiL2FyY2gvbTY4a25vbW11L3BsYXRmb3JtLzY4MzI4L2ludHMuYwppbmRleCA4NjU4NTI4Li4yYTNhZjE5IDEwMDY0NAotLS0gYS9hcmNoL202OGtub21tdS9wbGF0Zm9ybS82ODMyOC9pbnRzLmMKKysrIGIvYXJjaC9tNjhrbm9tbXUvcGxhdGZvcm0vNjgzMjgvaW50cy5jCkBAIC0xNzksOCArMTc5LDggQEAKIAlJTVIgPSB+MDsKIAogCWZvciAoaSA9IDA7IChpIDwgTlJfSVJRUyk7IGkrKykgewotCQlzZXRfaXJxX2NoaXAoaXJxLCAmaW50Y19pcnFfY2hpcCk7Ci0JCXNldF9pcnFfaGFuZGxlcihpcnEsIGhhbmRsZV9sZXZlbF9pcnEpOworCQlzZXRfaXJxX2NoaXAoaSwgJmludGNfaXJxX2NoaXApOworCQlzZXRfaXJxX2hhbmRsZXIoaSwgaGFuZGxlX2xldmVsX2lycSk7CiAJfQogfQogCmRpZmYgLS1naXQgYS9hcmNoL202OGtub21tdS9wbGF0Zm9ybS9jb2xkZmlyZS9NYWtlZmlsZSBiL2FyY2gvbTY4a25vbW11L3BsYXRmb3JtL2NvbGRmaXJlL01ha2VmaWxlCmluZGV4IDQ1ZjUwMWYuLmE4OTY3YmEgMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4a25vbW11L3BsYXRmb3JtL2NvbGRmaXJlL01ha2VmaWxlCisrKyBiL2FyY2gvbTY4a25vbW11L3BsYXRmb3JtL2NvbGRmaXJlL01ha2VmaWxlCkBAIC0xNCw3ICsxNCw3IEBACiAKIGFzZmxhZ3MtJChDT05GSUdfRlVMTERFQlVHKSA6PSAtRERFQlVHR0VSX0NPTVBBVElCTEVfQ0FDSEU9MQogCi1vYmotJChDT05GSUdfQ09MREZJUkUpCSs9IGNsay5vIGRtYS5vIGVudHJ5Lm8gdmVjdG9ycy5vCitvYmotJChDT05GSUdfQ09MREZJUkUpCSs9IGNhY2hlLm8gY2xrLm8gZG1hLm8gZW50cnkubyB2ZWN0b3JzLm8KIG9iai0kKENPTkZJR19NNTIwNikJKz0gdGltZXJzLm8gaW50Yy5vCiBvYmotJChDT05GSUdfTTUyMDZlKQkrPSB0aW1lcnMubyBpbnRjLm8KIG9iai0kKENPTkZJR19NNTIweCkJKz0gcGl0Lm8gaW50Yy1zaW1yLm8KQEAgLTI2LDcgKzI2LDcgQEAKIG9iai0kKENPTkZJR19NNTMwNykJKz0gdGltZXJzLm8gaW50Yy5vCiBvYmotJChDT05GSUdfTTUzMngpCSs9IHRpbWVycy5vIGludGMtc2ltci5vCiBvYmotJChDT05GSUdfTTU0MDcpCSs9IHRpbWVycy5vIGludGMubwotb2JqLSQoQ09ORklHX001NDh4KQkrPSBzbHRpbWVycy5vIGludGMtMi5vCitvYmotJChDT05GSUdfTTU0eHgpCSs9IHNsdGltZXJzLm8gaW50Yy0yLm8KIAogb2JqLXkJCQkrPSBwaW5tdXgubyBncGlvLm8KIGV4dHJhLXkgOj0gaGVhZC5vCmRpZmYgLS1naXQgYS9hcmNoL202OGtub21tdS9wbGF0Zm9ybS9jb2xkZmlyZS9jYWNoZS5jIGIvYXJjaC9tNjhrbm9tbXUvcGxhdGZvcm0vY29sZGZpcmUvY2FjaGUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yMzVkM2M0Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9tNjhrbm9tbXUvcGxhdGZvcm0vY29sZGZpcmUvY2FjaGUuYwpAQCAtMCwwICsxLDQ4IEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisvKgorICoJY2FjaGUuYyAtLSBnZW5lcmFsIENvbGRGaXJlIENhY2hlIG1haW50YWluZW5jZSBjb2RlCisgKgorICoJQ29weXJpZ2h0IChDKSAyMDEwLCBHcmVnIFVuZ2VyZXIgKGdlcmdAc25hcGdlYXIuY29tKQorICovCisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxhc20vY29sZGZpcmUuaD4KKyNpbmNsdWRlIDxhc20vbWNmc2ltLmg+CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisjaWZkZWYgQ0FDSEVfUFVTSAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworLyoKKyAqCVVzZSBjcHVzaGwgdG8gcHVzaCBhbGwgZGlydHkgY2FjaGUgbGluZXMgYmFjayB0byBtZW1vcnkuCisgKglPbGRlciB2ZXJzaW9ucyBvZiBHQVMgZG9uJ3Qgc2VlbSB0byBrbm93IGhvdyB0byBnZW5lcmF0ZSB0aGUKKyAqCUNvbGRGaXJlIGNwdXNobCBpbnN0cnVjdGlvbi4uLiBPaCB3ZWxsLCBiaXQgc3R1ZmYgaXQgZm9yIG5vdy4KKyAqLworCit2b2lkIG1jZl9jYWNoZV9wdXNoKHZvaWQpCit7CisJX19hc21fXyBfX3ZvbGF0aWxlX18gKAorCQkiY2xybAklJWQwXG5cdCIKKwkJIjE6XG5cdCIKKwkJIm1vdmVsCSUlZDAsJSVhMFxuXHQiCisJCSIyOlxuXHQiCisJCSIud29yZAkweGY0Njhcblx0IgorCQkiYWRkbAklMCwlJWEwXG5cdCIKKwkJImNtcGwJJTEsJSVhMFxuXHQiCisJCSJibHQJMmJcblx0IgorCQkiYWRkcWwJIzEsJSVkMFxuXHQiCisJCSJjbXBpbAklMiwlJWQwXG5cdCIKKwkJImJuZQkxYlxuXHQiCisJCTogLyogTm8gb3V0cHV0ICovCisJCTogImkiIChDQUNIRV9MSU5FX1NJWkUpLAorCQkgICJpIiAoRENBQ0hFX1NJWkUgLyBDQUNIRV9XQVlTKSwKKwkJICAiaSIgKENBQ0hFX1dBWVMpCisJCTogImQwIiwgImEwIiApOworfQorCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworI2VuZGlmIC8qIENBQ0hFX1BVU0ggKi8KKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCmRpZmYgLS1naXQgYS9hcmNoL202OGtub21tdS9wbGF0Zm9ybS9jb2xkZmlyZS9lbnRyeS5TIGIvYXJjaC9tNjhrbm9tbXUvcGxhdGZvcm0vY29sZGZpcmUvZW50cnkuUwppbmRleCBlMWRlYmM4Li40ZGRmYzNkYSAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrbm9tbXUvcGxhdGZvcm0vY29sZGZpcmUvZW50cnkuUworKysgYi9hcmNoL202OGtub21tdS9wbGF0Zm9ybS9jb2xkZmlyZS9lbnRyeS5TCkBAIC0zNiwxMyArMzYsMTYgQEAKICNpbmNsdWRlIDxhc20vYXNtLW9mZnNldHMuaD4KICNpbmNsdWRlIDxhc20vZW50cnkuaD4KIAorI2lmZGVmIENPTkZJR19DT0xERklSRV9TV19BNworLyoKKyAqCURlZmluZSBzb2Z0d2FyZSBjb3BpZXMgb2YgdGhlIHN1cGVydmlzb3IgYW5kIHVzZXIgc3RhY2sgcG9pbnRlcnMuCisgKi8KIC5ic3MKLQogc3dfa3NwOgogLmxvbmcJMAotCiBzd191c3A6CiAubG9uZwkwCisjZW5kaWYgLyogQ09ORklHX0NPTERGSVJFX1NXX0E3ICovCiAKIC50ZXh0CiAKQEAgLTUxLDcgKzU0LDYgQEAKIC5nbG9ibCByZXRfZnJvbV9leGNlcHRpb24KIC5nbG9ibCByZXRfZnJvbV9zaWduYWwKIC5nbG9ibCBzeXNfY2FsbF90YWJsZQotLmdsb2JsIHJldF9mcm9tX2ludGVycnVwdAogLmdsb2JsIGludGhhbmRsZXIKIC5nbG9ibCBmYXN0aGFuZGxlcgogCkBAIC0xNDAsMjAgKzE0Miw3IEBACiAJam5lCUx3b3JrX3RvX2RvCQkvKiBzdGlsbCB3b3JrIHRvIGRvICovCiAKIExyZXR1cm46Ci0JbW92ZQkjMHgyNzAwLCVzcgkJLyogZGlzYWJsZSBpbnRycyAqLwotCW1vdmVsCXN3X3VzcCwlYTAJCS8qIGdldCB1c3AgKi8KLQltb3ZlbAklc3BAKFBUX09GRl9QQyksJWEwQC0JLyogY29weSBleGNlcHRpb24gcHJvZ3JhbSBjb3VudGVyICovCi0JbW92ZWwJJXNwQChQVF9PRkZfRk9STUFUVkVDKSwlYTBALSAvKiBjb3B5IGV4Y2VwdGlvbiBmb3JtYXQvdmVjdG9yL3NyICovCi0JbW92ZW1sCSVzcEAsJWQxLSVkNS8lYTAtJWEyCi0JbGVhCSVzcEAoMzIpLCVzcAkJLyogc3BhY2UgZm9yIDggcmVncyAqLwotCW1vdmVsCSVzcEArLCVkMAotCWFkZHFsCSM0LCVzcAkJCS8qIG9yaWcgZDAgKi8KLQlhZGRsCSVzcEArLCVzcAkJLyogc3RrIGFkaiAqLwotCWFkZHFsCSM4LCVzcAkJCS8qIHJlbW92ZSBleGNlcHRpb24gKi8KLQltb3ZlbAklc3Asc3dfa3NwCQkvKiBzYXZlIGtzcCAqLwotCXN1YnFsCSM4LHN3X3VzcAkJLyogc2V0IGV4Y2VwdGlvbiAqLwotCW1vdmVsCXN3X3VzcCwlc3AJCS8qIHJlc3RvcmUgdXNwICovCi0JcnRlCisJUkVTVE9SRV9VU0VSCiAKIEx3b3JrX3RvX2RvOgogCW1vdmVsCSVhMEAoVElfRkxBR1MpLCVkMQkvKiBnZXQgdGhyZWFkX2luZm8tPmZsYWdzICovCkBAIC0xOTEsMzEgKzE4MCw3IEBACiAJamJzcglkb19JUlEJCQkvKiBjYWxsIGhpZ2ggbGV2ZWwgaXJxIGhhbmRsZXIgKi8KIAlsZWEJJXNwQCg4KSwlc3AJCS8qIHBvcCBhcmdzIG9mZiBzdGFjayAqLwogCi0JYnJhCXJldF9mcm9tX2ludGVycnVwdAkvKiB0aGlzIHdhcyBmYWxsdGhyb3VnaCAqLwotCi0vKgotICogVGhpcyBpcyB0aGUgZmFzdCBpbnRlcnJ1cHQgaGFuZGxlciAoZm9yIGNlcnRhaW4gaGFyZHdhcmUgaW50ZXJydXB0Ci0gKiBzb3VyY2VzKS4gVW5saWtlIHRoZSBub3JtYWwgaW50ZXJydXB0IGhhbmRsZXIgaXQganVzdCB1c2VzIHRoZQotICogY3VycmVudCBzdGFjayAoZG9lc24ndCBjYXJlIGlmIGl0IGlzIHVzZXIgb3Iga2VybmVsKS4gSXQgYWxzbwotICogZG9lc24ndCBib3RoZXIgZG9pbmcgdGhlIGJvdHRvbSBoYWxmIGhhbmRsZXJzLgotICovCi1FTlRSWShmYXN0aGFuZGxlcikKLQlTQVZFX0xPQ0FMCi0KLQltb3Zldwklc3BAKFBUX09GRl9GT1JNQVRWRUMpLCVkMAotCWFuZGwJIzB4MDNmYywlZDAJCS8qIG1hc2sgb3V0IHZlY3RvciBvbmx5ICovCi0KLQltb3ZlbAklc3AsJXNwQC0JCS8qIHB1c2ggcmVncyBhcmcgKi8KLQlsc3JsCSMyLCVkMAkJCS8qIGNhbGN1bGF0ZSByZWFsIHZlY3RvciAjICovCi0JbW92ZWwJJWQwLCVzcEAtCQkvKiBwdXNoIHZlY3RvciBudW1iZXIgKi8KLQlqYnNyCWRvX0lSUQkJCS8qIGNhbGwgaGlnaCBsZXZlbCBpcnEgaGFuZGxlciAqLwotCWxlYQklc3BAKDgpLCVzcAkJLyogcG9wIGFyZ3Mgb2ZmIHN0YWNrICovCi0KLQlSRVNUT1JFX0xPQ0FMCi0KLUVOVFJZKHJldF9mcm9tX2ludGVycnVwdCkKLQkvKiB0aGUgZmFzdGhhbmRsZXIgaXMgY29uZnVzaW5nIG1lLCBoYXZlbid0IHNlZW4gYW55IHVzZXIgKi8KLQlqbXAJcmV0X2Zyb21fZXhjZXB0aW9uCisJYnJhCXJldF9mcm9tX2V4Y2VwdGlvbgogCiAvKgogICogQmV3YXJlIC0gd2hlbiBlbnRlcmluZyByZXN1bWUsIHByZXYgKHRoZSBjdXJyZW50IHRhc2spIGlzCkBAIC0yMjYsOSArMTkxLDggQEAKICAqLwogRU5UUlkocmVzdW1lKQogCW1vdmVsCSVhMCwgJWQxCQkJLyogZ2V0IHByZXYgdGhyZWFkIGluIGQxICovCi0KLQltb3ZlbAlzd191c3AsJWQwCQkJLyogc2F2ZSB1c3AgKi8KLQltb3ZlbAklZDAsJWEwQChUQVNLX1RIUkVBRCtUSFJFQURfVVNQKQorCVJEVVNQCisJbW92ZWwJJWEyLCVhMEAoVEFTS19USFJFQUQrVEhSRUFEX1VTUCkKIAogCVNBVkVfU1dJVENIX1NUQUNLCiAJbW92ZWwJJXNwLCVhMEAoVEFTS19USFJFQUQrVEhSRUFEX0tTUCkgLyogc2F2ZSBrZXJuZWwgc3RhY2sgcG9pbnRlciAqLwpAQCAtMjM2LDUgKzIwMCw1IEBACiAJUkVTVE9SRV9TV0lUQ0hfU1RBQ0sKIAogCW1vdmVsCSVhMUAoVEFTS19USFJFQUQrVEhSRUFEX1VTUCksJWEwIC8qIHJlc3RvcmUgdGhyZWFkIHVzZXIgc3RhY2sgKi8KLQltb3ZlbAklYTAsIHN3X3VzcAorCVdSVVNQCiAJcnRzCmRpZmYgLS1naXQgYS9hcmNoL202OGtub21tdS9wbGF0Zm9ybS9jb2xkZmlyZS9oZWFkLlMgYi9hcmNoL202OGtub21tdS9wbGF0Zm9ybS9jb2xkZmlyZS9oZWFkLlMKaW5kZXggMGIyZDdjNy4uZDU5Nzc5MCAxMDA2NDQKLS0tIGEvYXJjaC9tNjhrbm9tbXUvcGxhdGZvcm0vY29sZGZpcmUvaGVhZC5TCisrKyBiL2FyY2gvbTY4a25vbW11L3BsYXRmb3JtL2NvbGRmaXJlL2hlYWQuUwpAQCAtMyw3ICszLDcgQEAKIC8qCiAgKgloZWFkLlMgLS0gY29tbW9uIHN0YXJ0dXAgY29kZSBmb3IgQ29sZEZpcmUgQ1BVcy4KICAqCi0gKgkoQykgQ29weXJpZ2h0IDE5OTktMjAwNiwgR3JlZyBVbmdlcmVyIDxnZXJnQHNuYXBnZWFyLmNvbT4uCisgKgkoQykgQ29weXJpZ2h0IDE5OTktMjAxMCwgR3JlZyBVbmdlcmVyIDxnZXJnQHNuYXBnZWFyLmNvbT4uCiAgKi8KIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwpAQCAtMTMsNyArMTMsNiBAQAogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxhc20vYXNtLW9mZnNldHMuaD4KICNpbmNsdWRlIDxhc20vY29sZGZpcmUuaD4KLSNpbmNsdWRlIDxhc20vbWNmY2FjaGUuaD4KICNpbmNsdWRlIDxhc20vbWNmc2ltLmg+CiAjaW5jbHVkZSA8YXNtL3RocmVhZF9pbmZvLmg+CiAKQEAgLTE3MywxMCArMTcyLDI3IEBACiAKIAkvKgogCSAqCU5vdyB0aGF0IHdlIGtub3cgd2hhdCB0aGUgbWVtb3J5IGlzLCBsZXRzIGVuYWJsZSBjYWNoZQotCSAqCWFuZCBnZXQgdGhpbmdzIG1vdmluZy4gVGhpcyBpcyBDb2xkZmlyZSBDUFUgc3BlY2lmaWMuCisJICoJYW5kIGdldCB0aGluZ3MgbW92aW5nLiBUaGlzIGlzIENvbGRmaXJlIENQVSBzcGVjaWZpYy4gTm90CisJICoJYWxsIHZlcnNpb24gY29yZXMgaGF2ZSBpZGVudGljYWwgY2FjaGUgcmVnaXN0ZXIgc2V0dXAuIEJ1dAorCSAqCWl0IGlzIHZlcnkgc2ltaWxhci4gRGVmaW5lIHRoZSBleGFjdCBzZXR0aW5ncyBpbiB0aGUgaGVhZGVycworCSAqCXRoZW4gdGhlIGNvZGUgaGVyZSBpcyB0aGUgc2FtZSBmb3IgYWxsLgogCSAqLwotCUNBQ0hFX0VOQUJMRQkJCQkvKiBlbmFibGUgQ1BVIGNhY2hlICovCi0KKwltb3ZlbAkjQ0FDSEVfSU5JVCwlZDAJCQkvKiBpbnZhbGlkYXRlIHdob2xlIGNhY2hlICovCisJbW92ZWMJJWQwLCVDQUNSCisJbm9wCisJbW92ZWwJI0FDUjBfTU9ERSwlZDAJCQkvKiBzZXQgUkFNIHJlZ2lvbiBmb3IgY2FjaGluZyAqLworCW1vdmVjCSVkMCwlQUNSMAorCW1vdmVsCSNBQ1IxX01PREUsJWQwCQkJLyogYW55dGhpbmcgZWxzZSB0byBjYWNoZT8gKi8KKwltb3ZlYwklZDAsJUFDUjEKKyNpZmRlZiBBQ1IyX01PREUKKwltb3ZlbAkjQUNSMl9NT0RFLCVkMAorCW1vdmVjCSVkMCwlQUNSMgorCW1vdmVsCSNBQ1IzX01PREUsJWQwCisJbW92ZWMJJWQwLCVBQ1IzCisjZW5kaWYKKwltb3ZlbAkjQ0FDSEVfTU9ERSwlZDAJCQkvKiBlbmFibGUgY2FjaGUgKi8KKwltb3ZlYwklZDAsJUNBQ1IKKwlub3AKIAogI2lmZGVmIENPTkZJR19ST01GU19GUwogCS8qCmRpZmYgLS1naXQgYS9hcmNoL21pY3JvYmxhemUvS2NvbmZpZyBiL2FyY2gvbWljcm9ibGF6ZS9LY29uZmlnCmluZGV4IDVmNTAxOGEuLjMxNjgwMDMgMTAwNjQ0Ci0tLSBhL2FyY2gvbWljcm9ibGF6ZS9LY29uZmlnCisrKyBiL2FyY2gvbWljcm9ibGF6ZS9LY29uZmlnCkBAIC0xNSw2ICsxNSw4IEBACiAJc2VsZWN0IFRSQUNJTkdfU1VQUE9SVAogCXNlbGVjdCBPRgogCXNlbGVjdCBPRl9FQVJMWV9GTEFUVFJFRQorCXNlbGVjdCBIQVZFX0dFTkVSSUNfSEFSRElSUVMKKwlzZWxlY3QgR0VORVJJQ19JUlFfUFJPQkUKIAogY29uZmlnIFNXQVAKIAlkZWZfYm9vbCBuCkBAIC0zNywxMiArMzksNiBAQAogY29uZmlnIEdFTkVSSUNfSFdFSUdIVAogCWRlZl9ib29sIHkKIAotY29uZmlnIEdFTkVSSUNfSEFSRElSUVMKLQlkZWZfYm9vbCB5Ci0KLWNvbmZpZyBHRU5FUklDX0lSUV9QUk9CRQotCWRlZl9ib29sIHkKLQogY29uZmlnIEdFTkVSSUNfQ0FMSUJSQVRFX0RFTEFZCiAJZGVmX2Jvb2wgeQogCkBAIC01Miw5ICs0OCw2IEBACiBjb25maWcgR0VORVJJQ19DTE9DS0VWRU5UUwogCWRlZl9ib29sIHkKIAotY29uZmlnIEdFTkVSSUNfSEFSRElSUVNfTk9fX0RPX0lSUQotCWRlZl9ib29sIHkKLQogY29uZmlnIEdFTkVSSUNfR1BJTwogCWRlZl9ib29sIHkKIApkaWZmIC0tZ2l0IGEvYXJjaC9taWNyb2JsYXplL2NvbmZpZ3MvbW11X2RlZmNvbmZpZyBiL2FyY2gvbWljcm9ibGF6ZS9jb25maWdzL21tdV9kZWZjb25maWcKaW5kZXggYWI4ZmJlNy4uYjNmNWVlYyAxMDA2NDQKLS0tIGEvYXJjaC9taWNyb2JsYXplL2NvbmZpZ3MvbW11X2RlZmNvbmZpZworKysgYi9hcmNoL21pY3JvYmxhemUvY29uZmlncy9tbXVfZGVmY29uZmlnCkBAIC03LDcgKzcsNyBAQAogQ09ORklHX0lOSVRSQU1GU19TT1VSQ0U9InJvb3Rmcy5jcGlvIgogQ09ORklHX0lOSVRSQU1GU19DT01QUkVTU0lPTl9HWklQPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19LQUxMU1lNU19BTEw9eQogQ09ORklHX0tBTExTWU1TX0VYVFJBX1BBU1M9eQogIyBDT05GSUdfSE9UUExVRyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL21pY3JvYmxhemUvY29uZmlncy9ub21tdV9kZWZjb25maWcgYi9hcmNoL21pY3JvYmxhemUvY29uZmlncy9ub21tdV9kZWZjb25maWcKaW5kZXggZWJjMTQzYy4uMDI0OWU0YiAxMDA2NDQKLS0tIGEvYXJjaC9taWNyb2JsYXplL2NvbmZpZ3Mvbm9tbXVfZGVmY29uZmlnCisrKyBiL2FyY2gvbWljcm9ibGF6ZS9jb25maWdzL25vbW11X2RlZmNvbmZpZwpAQCAtNiw3ICs2LDcgQEAKIENPTkZJR19JS0NPTkZJRz15CiBDT05GSUdfSUtDT05GSUdfUFJPQz15CiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfQUxMPXkKIENPTkZJR19LQUxMU1lNU19FWFRSQV9QQVNTPXkKICMgQ09ORklHX0hPVFBMVUcgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL2lycWZsYWdzLmggYi9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vaXJxZmxhZ3MuaAppbmRleCA1ZmQzMTkwLi5jNDUzMmYwIDEwMDY0NAotLS0gYS9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vaXJxZmxhZ3MuaAorKysgYi9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vaXJxZmxhZ3MuaApAQCAtMTIsNyArMTIsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CiAjaW5jbHVkZSA8YXNtL3JlZ2lzdGVycy5oPgogCi0jaWZkZWYgQ09ORklHX1hJTElOWF9NSUNST0JMQVpFMF9VU0VfTVNSX0lOU1RSCisjaWYgQ09ORklHX1hJTElOWF9NSUNST0JMQVpFMF9VU0VfTVNSX0lOU1RSCiAKIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyBhcmNoX2xvY2FsX2lycV9zYXZlKHZvaWQpCiB7CmRpZmYgLS1naXQgYS9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vcGd0YWJsZS5oIGIvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL3BndGFibGUuaAppbmRleCBjYWUyNjhjMi4uODg1NTc0YSAxMDA2NDQKLS0tIGEvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL3BndGFibGUuaAorKysgYi9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vcGd0YWJsZS5oCkBAIC00MTEsMjAgKzQxMSwxOSBAQAogc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIHB0ZV91cGRhdGUocHRlX3QgKnAsIHVuc2lnbmVkIGxvbmcgY2xyLAogCQkJCXVuc2lnbmVkIGxvbmcgc2V0KQogewotCXVuc2lnbmVkIGxvbmcgb2xkLCB0bXAsIG1zcjsKKwl1bnNpZ25lZCBsb25nIGZsYWdzLCBvbGQsIHRtcDsKIAotCV9fYXNtX18gX192b2xhdGlsZV9fKCJcCi0JbXNyY2xyCSUyLCAweDJcblwKLQlub3BcblwKLQlsdwklMCwgJTQsIHIwXG5cCi0JYW5kbgklMSwgJTAsICU1XG5cCi0Jb3IJJTEsICUxLCAlNlxuXAotCXN3CSUxLCAlNCwgcjBcblwKLQltdHMgICAgIHJtc3IsICUyXG5cCi0Jbm9wIgotCTogIj0mciIgKG9sZCksICI9JnIiICh0bXApLCAiPSZyIiAobXNyKSwgIj1tIiAoKnApCi0JOiAiciIgKCh1bnNpZ25lZCBsb25nKShwICsgMSkgLSA0KSwgInIiIChjbHIpLCAiciIgKHNldCksICJtIiAoKnApCi0JOiAiY2MiKTsKKwlyYXdfbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOworCisJX19hc21fXyBfX3ZvbGF0aWxlX18oCSJsdwklMCwgJTIsIHIwCVxuIgorCQkJCSJhbmRuCSUxLCAlMCwgJTMJXG4iCisJCQkJIm9yCSUxLCAlMSwgJTQJXG4iCisJCQkJInN3CSUxLCAlMiwgcjAJXG4iCisJCQk6ICI9JnIiIChvbGQpLCAiPSZyIiAodG1wKQorCQkJOiAiciIgKCh1bnNpZ25lZCBsb25nKShwICsgMSkgLSA0KSwgInIiIChjbHIpLCAiciIgKHNldCkKKwkJCTogImNjIik7CisKKwlyYXdfbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogCiAJcmV0dXJuIG9sZDsKIH0KQEAgLTQ0NCw4ICs0NDMsOSBAQAogCSpwdGVwID0gcHRlOwogfQogCi1zdGF0aWMgaW5saW5lIGludCBwdGVwX3Rlc3RfYW5kX2NsZWFyX3lvdW5nKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAotCQl1bnNpZ25lZCBsb25nIGFkZHIsIHB0ZV90ICpwdGVwKQorI2RlZmluZSBfX0hBVkVfQVJDSF9QVEVQX1RFU1RfQU5EX0NMRUFSX1lPVU5HCitzdGF0aWMgaW5saW5lIGludCBwdGVwX3Rlc3RfYW5kX2NsZWFyX3lvdW5nKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQl1bnNpZ25lZCBsb25nIGFkZHJlc3MsIHB0ZV90ICpwdGVwKQogewogCXJldHVybiAocHRlX3VwZGF0ZShwdGVwLCBfUEFHRV9BQ0NFU1NFRCwgMCkgJiBfUEFHRV9BQ0NFU1NFRCkgIT0gMDsKIH0KQEAgLTQ1Nyw2ICs0NTcsNyBAQAogCQkoX1BBR0VfRElSVFkgfCBfUEFHRV9IV1dSSVRFKSwgMCkgJiBfUEFHRV9ESVJUWSkgIT0gMDsKIH0KIAorI2RlZmluZSBfX0hBVkVfQVJDSF9QVEVQX0dFVF9BTkRfQ0xFQVIKIHN0YXRpYyBpbmxpbmUgcHRlX3QgcHRlcF9nZXRfYW5kX2NsZWFyKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAogCQl1bnNpZ25lZCBsb25nIGFkZHIsIHB0ZV90ICpwdGVwKQogewpkaWZmIC0tZ2l0IGEvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL3RsYi5oIGIvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL3RsYi5oCmluZGV4IGU4YWJkNGEuLjhhYTk3ODEgMTAwNjQ0Ci0tLSBhL2FyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS90bGIuaAorKysgYi9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vdGxiLmgKQEAgLTEzLDYgKzEzLDcgQEAKIAogI2RlZmluZSB0bGJfZmx1c2godGxiKQlmbHVzaF90bGJfbW0oKHRsYiktPm1tKQogCisjaW5jbHVkZSA8bGludXgvcGFnZW1hcC5oPgogI2luY2x1ZGUgPGFzbS1nZW5lcmljL3RsYi5oPgogCiAjaWZkZWYgQ09ORklHX01NVQpkaWZmIC0tZ2l0IGEvYXJjaC9taWNyb2JsYXplL2tlcm5lbC9jcHUvcHZyLmMgYi9hcmNoL21pY3JvYmxhemUva2VybmVsL2NwdS9wdnIuYwppbmRleCBlMDFhZmE2Li40ODhjMWVkIDEwMDY0NAotLS0gYS9hcmNoL21pY3JvYmxhemUva2VybmVsL2NwdS9wdnIuYworKysgYi9hcmNoL21pY3JvYmxhemUva2VybmVsL2NwdS9wdnIuYwpAQCAtMjcsNyArMjcsNyBAQAogCXJlZ2lzdGVyIHVuc2lnbmVkIHRtcCBfX2FzbV9fKCJyMyIpOwkJCVwKIAl0bXAgPSAweDA7CS8qIFByZXZlbnQgd2FybmluZyBhYm91dCB1bnVzZWQgKi8JXAogCV9fYXNtX18gX192b2xhdGlsZV9fICgJCQkJCVwKLQkJCSJtZnMJJTAsIHJwdnIiICNwdnJpZCAiOyIJXAorCQkJIm1mcwklMCwgcnB2ciIgI3B2cmlkICI7IgkJXAogCQkJOiAiPXIiICh0bXApIDogOiAibWVtb3J5Iik7IAkJXAogCXZhbCA9IHRtcDsJCQkJCQlcCiB9CkBAIC01NCw3ICs1NCw3IEBACiAJaWYgKCEoZmxhZ3MgJiBQVlJfTVNSX0JJVCkpCiAJCXJldHVybiAwOwogCi0JZ2V0X3NpbmdsZV9wdnIoMHgwMCwgcHZyMCk7CisJZ2V0X3NpbmdsZV9wdnIoMCwgcHZyMCk7CiAJcHJfZGVidWcoIiVzOiBwdnIwIGlzIDB4JTA4eFxuIiwgX19mdW5jX18sIHB2cjApOwogCiAJaWYgKHB2cjAgJiBQVlIwX1BWUl9GVUxMX01BU0spCmRpZmYgLS1naXQgYS9hcmNoL21pY3JvYmxhemUva2VybmVsL2hlYWQuUyBiL2FyY2gvbWljcm9ibGF6ZS9rZXJuZWwvaGVhZC5TCmluZGV4IDQyNDM0MDAuLjc3OGE1Y2UgMTAwNjQ0Ci0tLSBhL2FyY2gvbWljcm9ibGF6ZS9rZXJuZWwvaGVhZC5TCisrKyBiL2FyY2gvbWljcm9ibGF6ZS9rZXJuZWwvaGVhZC5TCkBAIC02MiwyMyArNjIsMzIgQEAKIAlhbmRpCXIxLCByMSwgfjIKIAltdHMJcm1zciwgcjEKIC8qCi0gKiBIZXJlIGlzIGNoZWNraW5nIG1lY2hhbmlzbSB3aGljaCBjaGVjayBpZiBNaWNyb2JsYXplIGhhcyBtc3IgaW5zdHJ1Y3Rpb25zCi0gKiBXZSBsb2FkIG1zciBhbmQgY29tcGFyZSBpdCB3aXRoIHByZXZpb3VzIHIxIHZhbHVlIC0gaWYgaXMgdGhlIHNhbWUsCi0gKiBtc3IgaW5zdHJ1Y3Rpb25zIHdvcmtzIGlmIG5vdCAtIGNwdSBkb24ndCBoYXZlIHRoZW0uCisgKiBBY2NvcmRpbmcgdG8gWGlsaW54LCBtc3JjbHIgaW5zdHJ1Y3Rpb24gYmVoYXZlcyBsaWtlICdtZnMgclgscnBjJworICogaWYgdGhlIG1zcmNsciBpbnN0cnVjdGlvbiBpcyBub3QgZW5hYmxlZC4gV2UgdXNlIHRoaXMgdG8gZGV0ZWN0CisgKiBpZiB0aGUgb3Bjb2RlIGlzIGF2YWlsYWJsZSwgYnkgaXNzdWluZyBtc3JjbHIgYW5kIHRoZW4gdGVzdGluZyB0aGUgcmVzdWx0LgorICogcjggPT0gMCAtIG1zciBpbnN0cnVjdGlvbnMgYXJlIGltcGxlbWVudGVkCisgKiByOCAhPSAwIC0gbXNyIGluc3RydWN0aW9ucyBhcmUgbm90IGltcGxlbWVudGVkCiAgKi8KLQkvKiByOD0wIC0gSSBoYXZlIG1zciBpbnN0ciwgMSAtIEkgZG9uJ3QgaGF2ZSB0aGVtICovCi0JcnN1YmkJcjAsIHIwLCAxCS8qIHNldCB0aGUgY2FycnkgYml0ICovCi0JbXNyY2xyCXIwLCAweDQJCS8qIHRyeSB0byBjbGVhciBpdCAqLwotCS8qIHJlYWQgdGhlIGNhcnJ5IGJpdCwgcjggd2lsbCBiZSAnMCcgaWYgbXNyY2xyIGV4aXN0cyAqLwotCWFkZGlrCXI4LCByMCwgMAorCW1zcmNscglyOCwgMCAvKiBjbGVhciBub3RoaW5nIC0ganVzdCByZWFkIG1zciBmb3IgdGVzdCAqLworCWNtcHUJcjgsIHI4LCByMSAvKiByMSBtdXN0IGNvbnRhaW4gbXNyIHJlZyBjb250ZW50ICovCiAKIC8qIHI3IG1heSBwb2ludCB0byBhbiBGRFQsIG9yIHRoZXJlIG1heSBiZSBvbmUgbGlua2VkIGluLgogICAgaWYgaXQncyBpbiByNywgd2UndmUgZ290IHRvIHNhdmUgaXQgYXdheSBBU0FQLgogICAgV2UgZW5zdXJlIHI3IHBvaW50cyB0byBhIHZhbGlkIEZEVCwganVzdCBpbiBjYXNlIHRoZSBib290bG9hZGVyCiAgICBpcyBicm9rZW4gb3Igbm9uLWV4aXN0ZW50ICovCiAJYmVxaQlyNywgbm9fZmR0X2FyZwkJCS8qIE5VTEwgcG9pbnRlcj8gIGRvbid0IGNvcHkgKi8KLQlsdwlyMTEsIHIwLCByNwkJCS8qIERvZXMgcjcgcG9pbnQgdG8gYSAqLwotCXJzdWJpCXIxMSwgcjExLCBPRl9EVF9IRUFERVIJCS8qIHZhbGlkIEZEVD8gKi8KKy8qIERvZXMgcjcgcG9pbnQgdG8gYSB2YWxpZCBGRFQ/IExvYWQgSEVBREVSIG1hZ2ljIG51bWJlciAqLworCS8qIFJ1biB0aW1lIEJpZy9MaXR0bGUgZW5kaWFuIHBsYXRmb3JtICovCisJLyogU2F2ZSAxIGFzIHdvcmQgYW5kIGxvYWQgYnl0ZSAtIDAgLSBCSUcsIDEgLSBMSVRUTEUgKi8KKwlhZGRpawlyMTEsIHIwLCAweDEgLyogQklHL0xJVFRMRSBjaGVja2luZyB2YWx1ZSAqLworCS8qIF9fYnNzX3N0YXJ0IHdpbGwgYmUgemVyb2VkIGxhdGVyIC0gaXQgaXMganVzdCB0ZW1wIGxvY2F0aW9uICovCisJc3dpCXIxMSwgcjAsIFRPUEhZUyhfX2Jzc19zdGFydCkKKwlsYnVpCXIxMSwgcjAsIFRPUEhZUyhfX2Jzc19zdGFydCkKKwliZXFpZAlyMTEsIGJpZ19lbmRpYW4gLyogRE8gTk9UIGJyZWFrIGRlbGF5IHN0b3AgZGVwZW5kZW5jeSAqLworCWx3CXIxMSwgcjAsIHI3IC8qIEJpZyBlbmRpYW4gbG9hZCBpbiBkZWxheSBzbG90ICovCisJbHdyCXIxMSwgcjAsIHI3IC8qIExpdHRsZSBlbmRpYW4gbG9hZCAqLworYmlnX2VuZGlhbjoKKwlyc3ViaQlyMTEsIHIxMSwgT0ZfRFRfSEVBREVSCS8qIENoZWNrIEZEVCBoZWFkZXIgKi8KIAliZXFpCXIxMSwgX3ByZXBhcmVfY29weV9mZHQKIAlvcglyNywgcjAsIHIwCQkvKiBjbGVhciBSNyB3aGVuIG5vdCB2YWxpZCBEVEIgKi8KIAlibmVpCXIxMSwgbm9fZmR0X2FyZwkJCS8qIE5vIC0gZ2V0IG91dCBvZiBoZXJlICovCmRpZmYgLS1naXQgYS9hcmNoL21pY3JvYmxhemUva2VybmVsL2h3X2V4Y2VwdGlvbl9oYW5kbGVyLlMgYi9hcmNoL21pY3JvYmxhemUva2VybmVsL2h3X2V4Y2VwdGlvbl9oYW5kbGVyLlMKaW5kZXggMjVmNmUwNy4uNzgyNjgwZCAxMDA2NDQKLS0tIGEvYXJjaC9taWNyb2JsYXplL2tlcm5lbC9od19leGNlcHRpb25faGFuZGxlci5TCisrKyBiL2FyY2gvbWljcm9ibGF6ZS9rZXJuZWwvaHdfZXhjZXB0aW9uX2hhbmRsZXIuUwpAQCAtMTQ3LDEwICsxNDcsNiBAQAogCSNpZiBDT05GSUdfWElMSU5YX01JQ1JPQkxBWkUwX1VTRV9CQVJSRUwgPiAwCiAJI2RlZmluZSBCU1JMSShyRCwgckEsIGltbSkJXAogCQlic3JsaSByRCwgckEsIGltbQotCSNlbGlmIENPTkZJR19YSUxJTlhfTUlDUk9CTEFaRTBfVVNFX0RJViA+IDAKLQkjZGVmaW5lIEJTUkxJKHJELCByQSwgaW1tKQlcCi0JCW9yaSByRCwgcjAsICgxIDw8IGltbSk7CVwKLQkJaWRpdnUgckQsIHJELCByQQogCSNlbHNlCiAJI2RlZmluZSBCU1JMSShyRCwgckEsIGltbSkgQlNSTEkgIyMgaW1tIChyRCwgckEpCiAJLyogT25seSB0aGUgdXNlZCBzaGlmdCBjb25zdGFudHMgZGVmaW5lZCBoZXJlIC0gYWRkIG1vcmUgaWYgbmVlZGVkICovCmRpZmYgLS1naXQgYS9hcmNoL21pY3JvYmxhemUva2VybmVsL3Byb20uYyBiL2FyY2gvbWljcm9ibGF6ZS9rZXJuZWwvcHJvbS5jCmluZGV4IGM4ODEzOTMuLmJjZWFhNTUgMTAwNjQ0Ci0tLSBhL2FyY2gvbWljcm9ibGF6ZS9rZXJuZWwvcHJvbS5jCisrKyBiL2FyY2gvbWljcm9ibGF6ZS9rZXJuZWwvcHJvbS5jCkBAIC00Nyw5ICs0Nyw5IEBACiAJbWVtYmxvY2tfYWRkKGJhc2UsIHNpemUpOwogfQogCi11NjQgX19pbml0IGVhcmx5X2luaXRfZHRfYWxsb2NfbWVtb3J5X2FyY2godTY0IHNpemUsIHU2NCBhbGlnbikKK3ZvaWQgKiBfX2luaXQgZWFybHlfaW5pdF9kdF9hbGxvY19tZW1vcnlfYXJjaCh1NjQgc2l6ZSwgdTY0IGFsaWduKQogewotCXJldHVybiBtZW1ibG9ja19hbGxvYyhzaXplLCBhbGlnbik7CisJcmV0dXJuIF9fdmEobWVtYmxvY2tfYWxsb2Moc2l6ZSwgYWxpZ24pKTsKIH0KIAogI2lmZGVmIENPTkZJR19FQVJMWV9QUklOVEsKZGlmZiAtLWdpdCBhL2FyY2gvbWljcm9ibGF6ZS9rZXJuZWwvc2V0dXAuYyBiL2FyY2gvbWljcm9ibGF6ZS9rZXJuZWwvc2V0dXAuYwppbmRleCBiYjE1NThlLi45MzEyZmJiIDEwMDY0NAotLS0gYS9hcmNoL21pY3JvYmxhemUva2VybmVsL3NldHVwLmMKKysrIGIvYXJjaC9taWNyb2JsYXplL2tlcm5lbC9zZXR1cC5jCkBAIC0xNjEsMTEgKzE2MSwxMSBAQAogI2lmIENPTkZJR19YSUxJTlhfTUlDUk9CTEFaRTBfVVNFX01TUl9JTlNUUgogCWlmIChtc3IpCiAJCWVwcmludGsoIiEhIVlvdXIga2VybmVsIGhhcyBzZXR1cCBNU1IgaW5zdHJ1Y3Rpb24gYnV0ICIKLQkJCQkiQ1BVIGRvbid0IGhhdmUgaXQgJWRcbiIsIG1zcik7CisJCQkJIkNQVSBkb24ndCBoYXZlIGl0ICV4XG4iLCBtc3IpOwogI2Vsc2UKIAlpZiAoIW1zcikKIAkJZXByaW50aygiISEhWW91ciBrZXJuZWwgbm90IHNldHVwIE1TUiBpbnN0cnVjdGlvbiBidXQgIgotCQkJCSJDUFUgaGF2ZSBpdCAlZFxuIiwgbXNyKTsKKwkJCQkiQ1BVIGhhdmUgaXQgJXhcbiIsIG1zcik7CiAjZW5kaWYKIAogCWZvciAoc3JjID0gX19pdnRfc3RhcnQ7IHNyYyA8IF9faXZ0X2VuZDsgc3JjKyssIGRzdCsrKQpkaWZmIC0tZ2l0IGEvYXJjaC9taWNyb2JsYXplL2xpYi9mYXN0Y29weS5TIGIvYXJjaC9taWNyb2JsYXplL2xpYi9mYXN0Y29weS5TCmluZGV4IGZkYzQ4YmIuLjYyMDIxZDcgMTAwNjQ0Ci0tLSBhL2FyY2gvbWljcm9ibGF6ZS9saWIvZmFzdGNvcHkuUworKysgYi9hcmNoL21pY3JvYmxhemUvbGliL2Zhc3Rjb3B5LlMKQEAgLTI5LDYgKzI5LDEwIEBACiAgKgliZXR3ZWVuIG1lbSBsb2NhdGlvbnMgd2l0aCBzaXplIG9mIHhmZXIgc3BlYydkIGluIGJ5dGVzCiAgKi8KIAorI2lmZGVmIF9fTUlDUk9CTEFaRUVMX18KKyNlcnJvciBNaWNyb2JsYXplIExFIG5vdCBzdXBwb3J0IEFTTSBvcHRpbWl6ZWQgbGliIGZ1bmMuIERpc2FibGUgT1BUX0xJQl9BU00uCisjZW5kaWYKKwogI2luY2x1ZGUgPGxpbnV4L2xpbmthZ2UuaD4KIAkudGV4dAogCS5nbG9ibAltZW1jcHkKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9LYnVpbGQucGxhdGZvcm1zIGIvYXJjaC9taXBzL0tidWlsZC5wbGF0Zm9ybXMKaW5kZXggNzg0MzliOC4uN2ZmOWI1NCAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL0tidWlsZC5wbGF0Zm9ybXMKKysrIGIvYXJjaC9taXBzL0tidWlsZC5wbGF0Zm9ybXMKQEAgLTIsNiArMiw3IEBACiAKIHBsYXRmb3JtcyArPSBhbGNoZW15CiBwbGF0Zm9ybXMgKz0gYXI3CitwbGF0Zm9ybXMgKz0gYXRoNzkKIHBsYXRmb3JtcyArPSBiY200N3h4CiBwbGF0Zm9ybXMgKz0gYmNtNjN4eAogcGxhdGZvcm1zICs9IGNhdml1bS1vY3Rlb24KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9LY29uZmlnIGIvYXJjaC9taXBzL0tjb25maWcKaW5kZXggZjQ4OWVjMy4uZjVlY2MwNSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL0tjb25maWcKKysrIGIvYXJjaC9taXBzL0tjb25maWcKQEAgLTIxLDYgKzIxLDcgQEAKIAlzZWxlY3QgSEFWRV9ETUFfQVBJX0RFQlVHCiAJc2VsZWN0IEhBVkVfR0VORVJJQ19IQVJESVJRUwogCXNlbGVjdCBHRU5FUklDX0lSUV9QUk9CRQorCXNlbGVjdCBIQVZFX0FSQ0hfSlVNUF9MQUJFTAogCiBtZW51ICJNYWNoaW5lIHNlbGVjdGlvbiIKIApAQCAtNjUsNiArNjYsMjIgQEAKIAkgIFN1cHBvcnQgZm9yIHRoZSBUZXhhcyBJbnN0cnVtZW50cyBBUjcgU3lzdGVtLW9uLWEtQ2hpcAogCSAgZmFtaWx5OiBUTkVURDcxMDAsIDcyMDAgYW5kIDczMDAuCiAKK2NvbmZpZyBBVEg3OQorCWJvb2wgIkF0aGVyb3MgQVI3MVhYL0FSNzI0WC9BUjkxM1ggYmFzZWQgYm9hcmRzIgorCXNlbGVjdCBBUkNIX1JFUVVJUkVfR1BJT0xJQgorCXNlbGVjdCBCT09UX1JBVworCXNlbGVjdCBDRVZUX1I0SworCXNlbGVjdCBDU1JDX1I0SworCXNlbGVjdCBETUFfTk9OQ09IRVJFTlQKKwlzZWxlY3QgSVJRX0NQVQorCXNlbGVjdCBNSVBTX01BQ0hJTkUKKwlzZWxlY3QgU1lTX0hBU19DUFVfTUlQUzMyX1IyCisJc2VsZWN0IFNZU19IQVNfRUFSTFlfUFJJTlRLCisJc2VsZWN0IFNZU19TVVBQT1JUU18zMkJJVF9LRVJORUwKKwlzZWxlY3QgU1lTX1NVUFBPUlRTX0JJR19FTkRJQU4KKwloZWxwCisJICBTdXBwb3J0IGZvciB0aGUgQXRoZXJvcyBBUjcxWFgvQVI3MjRYL0FSOTEzWCBTb0NzLgorCiBjb25maWcgQkNNNDdYWAogCWJvb2wgIkJyb2FkY29tIEJDTTQ3WFggYmFzZWQgYm9hcmRzIgogCXNlbGVjdCBDRVZUX1I0SwpAQCAtNzE3LDYgKzczNCw3IEBACiBlbmRjaG9pY2UKIAogc291cmNlICJhcmNoL21pcHMvYWxjaGVteS9LY29uZmlnIgorc291cmNlICJhcmNoL21pcHMvYXRoNzkvS2NvbmZpZyIKIHNvdXJjZSAiYXJjaC9taXBzL2JjbTYzeHgvS2NvbmZpZyIKIHNvdXJjZSAiYXJjaC9taXBzL2phenovS2NvbmZpZyIKIHNvdXJjZSAiYXJjaC9taXBzL2p6NDc0MC9LY29uZmlnIgpAQCAtNzc1LDkgKzc5Myw2IEBACiAJYm9vbAogCWRlZmF1bHQgeQogCi1jb25maWcgR0VORVJJQ19IQVJESVJRU19OT19fRE9fSVJRCi0JZGVmX2Jvb2wgeQotCiAjCiAjIFNlbGVjdCBzb21lIGNvbmZpZ3VyYXRpb24gb3B0aW9ucyBhdXRvbWF0aWNhbGx5IGJhc2VkIG9uIHVzZXIgc2VsZWN0aW9ucy4KICMKQEAgLTg4Myw2ICs4OTgsOSBAQAogY29uZmlnIFNZTkNfUjRLCiAJYm9vbAogCitjb25maWcgTUlQU19NQUNISU5FCisJZGVmX2Jvb2wgbgorCiBjb25maWcgTk9fSU9QT1JUCiAJZGVmX2Jvb2wgbgogCkBAIC0yNDAwLDQgKzI0MTgsMjAgQEAKIAogc291cmNlICJjcnlwdG8vS2NvbmZpZyIKIAorbWVudWNvbmZpZyBWSVJUVUFMSVpBVElPTgorCWJvb2wgIlZpcnR1YWxpemF0aW9uIgorCWRlZmF1bHQgbgorCS0tLWhlbHAtLS0KKwkgIFNheSBZIGhlcmUgdG8gZ2V0IHRvIHNlZSBvcHRpb25zIGZvciB1c2luZyB5b3VyIExpbnV4IGhvc3QgdG8gcnVuIG90aGVyCisJICBvcGVyYXRpbmcgc3lzdGVtcyBpbnNpZGUgdmlydHVhbCBtYWNoaW5lcyAoZ3Vlc3RzKS4KKwkgIFRoaXMgb3B0aW9uIGFsb25lIGRvZXMgbm90IGFkZCBhbnkga2VybmVsIGNvZGUuCisKKwkgIElmIHlvdSBzYXkgTiwgYWxsIG9wdGlvbnMgaW4gdGhpcyBzdWJtZW51IHdpbGwgYmUgc2tpcHBlZCBhbmQgZGlzYWJsZWQuCisKK2lmIFZJUlRVQUxJWkFUSU9OCisKK3NvdXJjZSBkcml2ZXJzL3ZpcnRpby9LY29uZmlnCisKK2VuZGlmICMgVklSVFVBTElaQVRJT04KKwogc291cmNlICJsaWIvS2NvbmZpZyIKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9LY29uZmlnLmRlYnVnIGIvYXJjaC9taXBzL0tjb25maWcuZGVidWcKaW5kZXggZjQzN2NkMS4uNTM1OGY5MCAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL0tjb25maWcuZGVidWcKKysrIGIvYXJjaC9taXBzL0tjb25maWcuZGVidWcKQEAgLTcsNyArNyw3IEBACiBzb3VyY2UgImxpYi9LY29uZmlnLmRlYnVnIgogCiBjb25maWcgRUFSTFlfUFJJTlRLCi0JYm9vbCAiRWFybHkgcHJpbnRrIiBpZiBFTUJFRERFRAorCWJvb2wgIkVhcmx5IHByaW50ayIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBTWVNfSEFTX0VBUkxZX1BSSU5USwogCWRlZmF1bHQgeQogCWhlbHAKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9hdGg3OS9LY29uZmlnIGIvYXJjaC9taXBzL2F0aDc5L0tjb25maWcKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjA1ODI4MgotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvbWlwcy9hdGg3OS9LY29uZmlnCkBAIC0wLDAgKzEsNTAgQEAKK2lmIEFUSDc5CisKK21lbnUgIkF0aGVyb3MgQVI3MVhYL0FSNzI0WC9BUjkxM1ggbWFjaGluZSBzZWxlY3Rpb24iCisKK2NvbmZpZyBBVEg3OV9NQUNIX0FQODEKKwlib29sICJBdGhlcm9zIEFQODEgcmVmZXJlbmNlIGJvYXJkIgorCXNlbGVjdCBTT0NfQVI5MTNYCisJc2VsZWN0IEFUSDc5X0RFVl9BUjkxM1hfV01BQworCXNlbGVjdCBBVEg3OV9ERVZfR1BJT19CVVRUT05TCisJc2VsZWN0IEFUSDc5X0RFVl9MRURTX0dQSU8KKwlzZWxlY3QgQVRINzlfREVWX1NQSQorCWhlbHAKKwkgIFNheSAnWScgaGVyZSBpZiB5b3Ugd2FudCB5b3VyIGtlcm5lbCB0byBzdXBwb3J0IHRoZQorCSAgQXRoZXJvcyBBUDgxIHJlZmVyZW5jZSBib2FyZC4KKworY29uZmlnIEFUSDc5X01BQ0hfUEI0NAorCWJvb2wgIkF0aGVyb3MgUEI0NCByZWZlcmVuY2UgYm9hcmQiCisJc2VsZWN0IFNPQ19BUjcxWFgKKwlzZWxlY3QgQVRINzlfREVWX0dQSU9fQlVUVE9OUworCXNlbGVjdCBBVEg3OV9ERVZfTEVEU19HUElPCisJc2VsZWN0IEFUSDc5X0RFVl9TUEkKKwloZWxwCisJICBTYXkgJ1knIGhlcmUgaWYgeW91IHdhbnQgeW91ciBrZXJuZWwgdG8gc3VwcG9ydCB0aGUKKwkgIEF0aGVyb3MgUEI0NCByZWZlcmVuY2UgYm9hcmQuCisKK2VuZG1lbnUKKworY29uZmlnIFNPQ19BUjcxWFgKKwlkZWZfYm9vbCBuCisKK2NvbmZpZyBTT0NfQVI3MjRYCisJZGVmX2Jvb2wgbgorCitjb25maWcgU09DX0FSOTEzWAorCWRlZl9ib29sIG4KKworY29uZmlnIEFUSDc5X0RFVl9BUjkxM1hfV01BQworCWRlcGVuZHMgb24gU09DX0FSOTEzWAorCWRlZl9ib29sIG4KKworY29uZmlnIEFUSDc5X0RFVl9HUElPX0JVVFRPTlMKKwlkZWZfYm9vbCBuCisKK2NvbmZpZyBBVEg3OV9ERVZfTEVEU19HUElPCisJZGVmX2Jvb2wgbgorCitjb25maWcgQVRINzlfREVWX1NQSQorCWRlZl9ib29sIG4KKworZW5kaWYKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9hdGg3OS9NYWtlZmlsZSBiL2FyY2gvbWlwcy9hdGg3OS9NYWtlZmlsZQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jMzNkNDY1Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2F0aDc5L01ha2VmaWxlCkBAIC0wLDAgKzEsMjggQEAKKyMKKyMgTWFrZWZpbGUgZm9yIHRoZSBBdGhlcm9zIEFSNzFYWC9BUjcyNFgvQVI5MTNYIHNwZWNpZmljIHBhcnRzIG9mIHRoZSBrZXJuZWwKKyMKKyMgQ29weXJpZ2h0IChDKSAyMDA4LTIwMTEgR2Fib3IgSnVob3MgPGp1aG9zZ0BvcGVud3J0Lm9yZz4KKyMgQ29weXJpZ2h0IChDKSAyMDA4IEltcmUgS2Fsb3ogPGthbG96QG9wZW53cnQub3JnPgorIworIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorIyB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQKKyMgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKworb2JqLXkJOj0gcHJvbS5vIHNldHVwLm8gaXJxLm8gY29tbW9uLm8gY2xvY2subyBncGlvLm8KKworb2JqLSQoQ09ORklHX0VBUkxZX1BSSU5USykJCSs9IGVhcmx5X3ByaW50ay5vCisKKyMKKyMgRGV2aWNlcworIworb2JqLXkJCQkJCSs9IGRldi1jb21tb24ubworb2JqLSQoQ09ORklHX0FUSDc5X0RFVl9BUjkxM1hfV01BQykJKz0gZGV2LWFyOTEzeC13bWFjLm8KK29iai0kKENPTkZJR19BVEg3OV9ERVZfR1BJT19CVVRUT05TKQkrPSBkZXYtZ3Bpby1idXR0b25zLm8KK29iai0kKENPTkZJR19BVEg3OV9ERVZfTEVEU19HUElPKQkrPSBkZXYtbGVkcy1ncGlvLm8KK29iai0kKENPTkZJR19BVEg3OV9ERVZfU1BJKQkJKz0gZGV2LXNwaS5vCisKKyMKKyMgTWFjaGluZXMKKyMKK29iai0kKENPTkZJR19BVEg3OV9NQUNIX0FQODEpCQkrPSBtYWNoLWFwODEubworb2JqLSQoQ09ORklHX0FUSDc5X01BQ0hfUEI0NCkJCSs9IG1hY2gtcGI0NC5vCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvYXRoNzkvUGxhdGZvcm0gYi9hcmNoL21pcHMvYXRoNzkvUGxhdGZvcm0KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMmJkNjYzNgotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvbWlwcy9hdGg3OS9QbGF0Zm9ybQpAQCAtMCwwICsxLDcgQEAKKyMKKyMgQXRoZXJvcyBBUjcxeHgvQVI3MjR4L0FSOTEzeAorIworCitwbGF0Zm9ybS0kKENPTkZJR19BVEg3OSkJKz0gYXRoNzkvCitjZmxhZ3MtJChDT05GSUdfQVRINzkpCQkrPSAtSSQoc3JjdHJlZSkvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtYXRoNzkKK2xvYWQtJChDT05GSUdfQVRINzkpCQk9IDB4ZmZmZmZmZmY4MDA2MDAwMApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2F0aDc5L2Nsb2NrLmMgYi9hcmNoL21pcHMvYXRoNzkvY2xvY2suYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ODBiZGU5Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2F0aDc5L2Nsb2NrLmMKQEAgLTAsMCArMSwxODMgQEAKKy8qCisgKiAgQXRoZXJvcyBBUjcxWFgvQVI3MjRYL0FSOTEzWCBjb21tb24gcm91dGluZXMKKyAqCisgKiAgQ29weXJpZ2h0IChDKSAyMDExIEdhYm9yIEp1aG9zIDxqdWhvc2dAb3BlbndydC5vcmc+CisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkCisgKiAgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqLworCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgorI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgorCisjaW5jbHVkZSA8YXNtL21hY2gtYXRoNzkvYXRoNzkuaD4KKyNpbmNsdWRlIDxhc20vbWFjaC1hdGg3OS9hcjcxeHhfcmVncy5oPgorI2luY2x1ZGUgImNvbW1vbi5oIgorCisjZGVmaW5lIEFSNzFYWF9CQVNFX0ZSRVEJNDAwMDAwMDAKKyNkZWZpbmUgQVI3MjRYX0JBU0VfRlJFUQk1MDAwMDAwCisjZGVmaW5lIEFSOTEzWF9CQVNFX0ZSRVEJNTAwMDAwMAorCitzdHJ1Y3QgY2xrIHsKKwl1bnNpZ25lZCBsb25nIHJhdGU7Cit9OworCitzdGF0aWMgc3RydWN0IGNsayBhdGg3OV9yZWZfY2xrOworc3RhdGljIHN0cnVjdCBjbGsgYXRoNzlfY3B1X2NsazsKK3N0YXRpYyBzdHJ1Y3QgY2xrIGF0aDc5X2Rkcl9jbGs7CitzdGF0aWMgc3RydWN0IGNsayBhdGg3OV9haGJfY2xrOworc3RhdGljIHN0cnVjdCBjbGsgYXRoNzlfd2R0X2NsazsKK3N0YXRpYyBzdHJ1Y3QgY2xrIGF0aDc5X3VhcnRfY2xrOworCitzdGF0aWMgdm9pZCBfX2luaXQgYXI3MXh4X2Nsb2Nrc19pbml0KHZvaWQpCit7CisJdTMyIHBsbDsKKwl1MzIgZnJlcTsKKwl1MzIgZGl2OworCisJYXRoNzlfcmVmX2Nsay5yYXRlID0gQVI3MVhYX0JBU0VfRlJFUTsKKworCXBsbCA9IGF0aDc5X3BsbF9ycihBUjcxWFhfUExMX1JFR19DUFVfQ09ORklHKTsKKworCWRpdiA9ICgocGxsID4+IEFSNzFYWF9QTExfRElWX1NISUZUKSAmIEFSNzFYWF9QTExfRElWX01BU0spICsgMTsKKwlmcmVxID0gZGl2ICogYXRoNzlfcmVmX2Nsay5yYXRlOworCisJZGl2ID0gKChwbGwgPj4gQVI3MVhYX0NQVV9ESVZfU0hJRlQpICYgQVI3MVhYX0NQVV9ESVZfTUFTSykgKyAxOworCWF0aDc5X2NwdV9jbGsucmF0ZSA9IGZyZXEgLyBkaXY7CisKKwlkaXYgPSAoKHBsbCA+PiBBUjcxWFhfRERSX0RJVl9TSElGVCkgJiBBUjcxWFhfRERSX0RJVl9NQVNLKSArIDE7CisJYXRoNzlfZGRyX2Nsay5yYXRlID0gZnJlcSAvIGRpdjsKKworCWRpdiA9ICgoKHBsbCA+PiBBUjcxWFhfQUhCX0RJVl9TSElGVCkgJiBBUjcxWFhfQUhCX0RJVl9NQVNLKSArIDEpICogMjsKKwlhdGg3OV9haGJfY2xrLnJhdGUgPSBhdGg3OV9jcHVfY2xrLnJhdGUgLyBkaXY7CisKKwlhdGg3OV93ZHRfY2xrLnJhdGUgPSBhdGg3OV9haGJfY2xrLnJhdGU7CisJYXRoNzlfdWFydF9jbGsucmF0ZSA9IGF0aDc5X2FoYl9jbGsucmF0ZTsKK30KKworc3RhdGljIHZvaWQgX19pbml0IGFyNzI0eF9jbG9ja3NfaW5pdCh2b2lkKQoreworCXUzMiBwbGw7CisJdTMyIGZyZXE7CisJdTMyIGRpdjsKKworCWF0aDc5X3JlZl9jbGsucmF0ZSA9IEFSNzI0WF9CQVNFX0ZSRVE7CisJcGxsID0gYXRoNzlfcGxsX3JyKEFSNzI0WF9QTExfUkVHX0NQVV9DT05GSUcpOworCisJZGl2ID0gKChwbGwgPj4gQVI3MjRYX1BMTF9ESVZfU0hJRlQpICYgQVI3MjRYX1BMTF9ESVZfTUFTSyk7CisJZnJlcSA9IGRpdiAqIGF0aDc5X3JlZl9jbGsucmF0ZTsKKworCWRpdiA9ICgocGxsID4+IEFSNzI0WF9QTExfUkVGX0RJVl9TSElGVCkgJiBBUjcyNFhfUExMX1JFRl9ESVZfTUFTSyk7CisJZnJlcSAqPSBkaXY7CisKKwlhdGg3OV9jcHVfY2xrLnJhdGUgPSBmcmVxOworCisJZGl2ID0gKChwbGwgPj4gQVI3MjRYX0REUl9ESVZfU0hJRlQpICYgQVI3MjRYX0REUl9ESVZfTUFTSykgKyAxOworCWF0aDc5X2Rkcl9jbGsucmF0ZSA9IGZyZXEgLyBkaXY7CisKKwlkaXYgPSAoKChwbGwgPj4gQVI3MjRYX0FIQl9ESVZfU0hJRlQpICYgQVI3MjRYX0FIQl9ESVZfTUFTSykgKyAxKSAqIDI7CisJYXRoNzlfYWhiX2Nsay5yYXRlID0gYXRoNzlfY3B1X2Nsay5yYXRlIC8gZGl2OworCisJYXRoNzlfd2R0X2Nsay5yYXRlID0gYXRoNzlfYWhiX2Nsay5yYXRlOworCWF0aDc5X3VhcnRfY2xrLnJhdGUgPSBhdGg3OV9haGJfY2xrLnJhdGU7Cit9CisKK3N0YXRpYyB2b2lkIF9faW5pdCBhcjkxM3hfY2xvY2tzX2luaXQodm9pZCkKK3sKKwl1MzIgcGxsOworCXUzMiBmcmVxOworCXUzMiBkaXY7CisKKwlhdGg3OV9yZWZfY2xrLnJhdGUgPSBBUjkxM1hfQkFTRV9GUkVROworCXBsbCA9IGF0aDc5X3BsbF9ycihBUjkxM1hfUExMX1JFR19DUFVfQ09ORklHKTsKKworCWRpdiA9ICgocGxsID4+IEFSOTEzWF9QTExfRElWX1NISUZUKSAmIEFSOTEzWF9QTExfRElWX01BU0spOworCWZyZXEgPSBkaXYgKiBhdGg3OV9yZWZfY2xrLnJhdGU7CisKKwlhdGg3OV9jcHVfY2xrLnJhdGUgPSBmcmVxOworCisJZGl2ID0gKChwbGwgPj4gQVI5MTNYX0REUl9ESVZfU0hJRlQpICYgQVI5MTNYX0REUl9ESVZfTUFTSykgKyAxOworCWF0aDc5X2Rkcl9jbGsucmF0ZSA9IGZyZXEgLyBkaXY7CisKKwlkaXYgPSAoKChwbGwgPj4gQVI5MTNYX0FIQl9ESVZfU0hJRlQpICYgQVI5MTNYX0FIQl9ESVZfTUFTSykgKyAxKSAqIDI7CisJYXRoNzlfYWhiX2Nsay5yYXRlID0gYXRoNzlfY3B1X2Nsay5yYXRlIC8gZGl2OworCisJYXRoNzlfd2R0X2Nsay5yYXRlID0gYXRoNzlfYWhiX2Nsay5yYXRlOworCWF0aDc5X3VhcnRfY2xrLnJhdGUgPSBhdGg3OV9haGJfY2xrLnJhdGU7Cit9CisKK3ZvaWQgX19pbml0IGF0aDc5X2Nsb2Nrc19pbml0KHZvaWQpCit7CisJaWYgKHNvY19pc19hcjcxeHgoKSkKKwkJYXI3MXh4X2Nsb2Nrc19pbml0KCk7CisJZWxzZSBpZiAoc29jX2lzX2FyNzI0eCgpKQorCQlhcjcyNHhfY2xvY2tzX2luaXQoKTsKKwllbHNlIGlmIChzb2NfaXNfYXI5MTN4KCkpCisJCWFyOTEzeF9jbG9ja3NfaW5pdCgpOworCWVsc2UKKwkJQlVHKCk7CisKKwlwcl9pbmZvKCJDbG9ja3M6IENQVTolbHUuJTAzbHVNSHosIEREUjolbHUuJTAzbHVNSHosIEFIQjolbHUuJTAzbHVNSHosICIKKwkJIlJlZjolbHUuJTAzbHVNSHoiLAorCQlhdGg3OV9jcHVfY2xrLnJhdGUgLyAxMDAwMDAwLAorCQkoYXRoNzlfY3B1X2Nsay5yYXRlIC8gMTAwMCkgJSAxMDAwLAorCQlhdGg3OV9kZHJfY2xrLnJhdGUgLyAxMDAwMDAwLAorCQkoYXRoNzlfZGRyX2Nsay5yYXRlIC8gMTAwMCkgJSAxMDAwLAorCQlhdGg3OV9haGJfY2xrLnJhdGUgLyAxMDAwMDAwLAorCQkoYXRoNzlfYWhiX2Nsay5yYXRlIC8gMTAwMCkgJSAxMDAwLAorCQlhdGg3OV9yZWZfY2xrLnJhdGUgLyAxMDAwMDAwLAorCQkoYXRoNzlfcmVmX2Nsay5yYXRlIC8gMTAwMCkgJSAxMDAwKTsKK30KKworLyoKKyAqIExpbnV4IGNsb2NrIEFQSQorICovCitzdHJ1Y3QgY2xrICpjbGtfZ2V0KHN0cnVjdCBkZXZpY2UgKmRldiwgY29uc3QgY2hhciAqaWQpCit7CisJaWYgKCFzdHJjbXAoaWQsICJyZWYiKSkKKwkJcmV0dXJuICZhdGg3OV9yZWZfY2xrOworCisJaWYgKCFzdHJjbXAoaWQsICJjcHUiKSkKKwkJcmV0dXJuICZhdGg3OV9jcHVfY2xrOworCisJaWYgKCFzdHJjbXAoaWQsICJkZHIiKSkKKwkJcmV0dXJuICZhdGg3OV9kZHJfY2xrOworCisJaWYgKCFzdHJjbXAoaWQsICJhaGIiKSkKKwkJcmV0dXJuICZhdGg3OV9haGJfY2xrOworCisJaWYgKCFzdHJjbXAoaWQsICJ3ZHQiKSkKKwkJcmV0dXJuICZhdGg3OV93ZHRfY2xrOworCisJaWYgKCFzdHJjbXAoaWQsICJ1YXJ0IikpCisJCXJldHVybiAmYXRoNzlfdWFydF9jbGs7CisKKwlyZXR1cm4gRVJSX1BUUigtRU5PRU5UKTsKK30KK0VYUE9SVF9TWU1CT0woY2xrX2dldCk7CisKK2ludCBjbGtfZW5hYmxlKHN0cnVjdCBjbGsgKmNsaykKK3sKKwlyZXR1cm4gMDsKK30KK0VYUE9SVF9TWU1CT0woY2xrX2VuYWJsZSk7CisKK3ZvaWQgY2xrX2Rpc2FibGUoc3RydWN0IGNsayAqY2xrKQoreworfQorRVhQT1JUX1NZTUJPTChjbGtfZGlzYWJsZSk7CisKK3Vuc2lnbmVkIGxvbmcgY2xrX2dldF9yYXRlKHN0cnVjdCBjbGsgKmNsaykKK3sKKwlyZXR1cm4gY2xrLT5yYXRlOworfQorRVhQT1JUX1NZTUJPTChjbGtfZ2V0X3JhdGUpOworCit2b2lkIGNsa19wdXQoc3RydWN0IGNsayAqY2xrKQoreworfQorRVhQT1JUX1NZTUJPTChjbGtfcHV0KTsKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9hdGg3OS9jb21tb24uYyBiL2FyY2gvbWlwcy9hdGg3OS9jb21tb24uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41OGY2MGU3Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2F0aDc5L2NvbW1vbi5jCkBAIC0wLDAgKzEsOTcgQEAKKy8qCisgKiAgQXRoZXJvcyBBUjcxWFgvQVI3MjRYL0FSOTEzWCBjb21tb24gcm91dGluZXMKKyAqCisgKiAgQ29weXJpZ2h0IChDKSAyMDA4LTIwMTAgR2Fib3IgSnVob3MgPGp1aG9zZ0BvcGVud3J0Lm9yZz4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDggSW1yZSBLYWxveiA8a2Fsb3pAb3BlbndydC5vcmc+CisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkCisgKiAgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqLworCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgorCisjaW5jbHVkZSA8YXNtL21hY2gtYXRoNzkvYXRoNzkuaD4KKyNpbmNsdWRlIDxhc20vbWFjaC1hdGg3OS9hcjcxeHhfcmVncy5oPgorI2luY2x1ZGUgImNvbW1vbi5oIgorCitzdGF0aWMgREVGSU5FX1NQSU5MT0NLKGF0aDc5X2RldmljZV9yZXNldF9sb2NrKTsKKwordTMyIGF0aDc5X2NwdV9mcmVxOworRVhQT1JUX1NZTUJPTF9HUEwoYXRoNzlfY3B1X2ZyZXEpOworCit1MzIgYXRoNzlfYWhiX2ZyZXE7CitFWFBPUlRfU1lNQk9MX0dQTChhdGg3OV9haGJfZnJlcSk7CisKK3UzMiBhdGg3OV9kZHJfZnJlcTsKK0VYUE9SVF9TWU1CT0xfR1BMKGF0aDc5X2Rkcl9mcmVxKTsKKworZW51bSBhdGg3OV9zb2NfdHlwZSBhdGg3OV9zb2M7CisKK3ZvaWQgX19pb21lbSAqYXRoNzlfcGxsX2Jhc2U7Cit2b2lkIF9faW9tZW0gKmF0aDc5X3Jlc2V0X2Jhc2U7CitFWFBPUlRfU1lNQk9MX0dQTChhdGg3OV9yZXNldF9iYXNlKTsKK3ZvaWQgX19pb21lbSAqYXRoNzlfZGRyX2Jhc2U7CisKK3ZvaWQgYXRoNzlfZGRyX3diX2ZsdXNoKHUzMiByZWcpCit7CisJdm9pZCBfX2lvbWVtICpmbHVzaF9yZWcgPSBhdGg3OV9kZHJfYmFzZSArIHJlZzsKKworCS8qIEZsdXNoIHRoZSBERFIgd3JpdGUgYnVmZmVyLiAqLworCV9fcmF3X3dyaXRlbCgweDEsIGZsdXNoX3JlZyk7CisJd2hpbGUgKF9fcmF3X3JlYWRsKGZsdXNoX3JlZykgJiAweDEpCisJCTsKKworCS8qIEl0IG11c3QgYmUgcnVuIHR3aWNlLiAqLworCV9fcmF3X3dyaXRlbCgweDEsIGZsdXNoX3JlZyk7CisJd2hpbGUgKF9fcmF3X3JlYWRsKGZsdXNoX3JlZykgJiAweDEpCisJCTsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKGF0aDc5X2Rkcl93Yl9mbHVzaCk7CisKK3ZvaWQgYXRoNzlfZGV2aWNlX3Jlc2V0X3NldCh1MzIgbWFzaykKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXUzMiByZWc7CisJdTMyIHQ7CisKKwlpZiAoc29jX2lzX2FyNzF4eCgpKQorCQlyZWcgPSBBUjcxWFhfUkVTRVRfUkVHX1JFU0VUX01PRFVMRTsKKwllbHNlIGlmIChzb2NfaXNfYXI3MjR4KCkpCisJCXJlZyA9IEFSNzI0WF9SRVNFVF9SRUdfUkVTRVRfTU9EVUxFOworCWVsc2UgaWYgKHNvY19pc19hcjkxM3goKSkKKwkJcmVnID0gQVI5MTNYX1JFU0VUX1JFR19SRVNFVF9NT0RVTEU7CisJZWxzZQorCQlCVUcoKTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZhdGg3OV9kZXZpY2VfcmVzZXRfbG9jaywgZmxhZ3MpOworCXQgPSBhdGg3OV9yZXNldF9ycihyZWcpOworCWF0aDc5X3Jlc2V0X3dyKHJlZywgdCB8IG1hc2spOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmF0aDc5X2RldmljZV9yZXNldF9sb2NrLCBmbGFncyk7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChhdGg3OV9kZXZpY2VfcmVzZXRfc2V0KTsKKwordm9pZCBhdGg3OV9kZXZpY2VfcmVzZXRfY2xlYXIodTMyIG1hc2spCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwl1MzIgcmVnOworCXUzMiB0OworCisJaWYgKHNvY19pc19hcjcxeHgoKSkKKwkJcmVnID0gQVI3MVhYX1JFU0VUX1JFR19SRVNFVF9NT0RVTEU7CisJZWxzZSBpZiAoc29jX2lzX2FyNzI0eCgpKQorCQlyZWcgPSBBUjcyNFhfUkVTRVRfUkVHX1JFU0VUX01PRFVMRTsKKwllbHNlIGlmIChzb2NfaXNfYXI5MTN4KCkpCisJCXJlZyA9IEFSOTEzWF9SRVNFVF9SRUdfUkVTRVRfTU9EVUxFOworCWVsc2UKKwkJQlVHKCk7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmYXRoNzlfZGV2aWNlX3Jlc2V0X2xvY2ssIGZsYWdzKTsKKwl0ID0gYXRoNzlfcmVzZXRfcnIocmVnKTsKKwlhdGg3OV9yZXNldF93cihyZWcsIHQgJiB+bWFzayk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYXRoNzlfZGV2aWNlX3Jlc2V0X2xvY2ssIGZsYWdzKTsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKGF0aDc5X2RldmljZV9yZXNldF9jbGVhcik7CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvYXRoNzkvY29tbW9uLmggYi9hcmNoL21pcHMvYXRoNzkvY29tbW9uLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTYxOTA2YwotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvbWlwcy9hdGg3OS9jb21tb24uaApAQCAtMCwwICsxLDMxIEBACisvKgorICogIEF0aGVyb3MgQVI3MVhYL0FSNzI0WC9BUjkxM1ggY29tbW9uIGRlZmluaXRpb25zCisgKgorICogIENvcHlyaWdodCAoQykgMjAwOC0yMDExIEdhYm9yIEp1aG9zIDxqdWhvc2dAb3BlbndydC5vcmc+CisgKiAgQ29weXJpZ2h0IChDKSAyMDA4IEltcmUgS2Fsb3ogPGthbG96QG9wZW53cnQub3JnPgorICoKKyAqICBQYXJ0cyBvZiB0aGlzIGZpbGUgYXJlIGJhc2VkIG9uIEF0aGVyb3MnIDIuNi4xNSBCU1AKKyAqCisgKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqICB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQKKyAqICBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICovCisKKyNpZm5kZWYgX19BVEg3OV9DT01NT05fSAorI2RlZmluZSBfX0FUSDc5X0NPTU1PTl9ICisKKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKworI2RlZmluZSBBVEg3OV9NRU1fU0laRV9NSU4JKDIgKiAxMDI0ICogMTAyNCkKKyNkZWZpbmUgQVRINzlfTUVNX1NJWkVfTUFYCSgxMjggKiAxMDI0ICogMTAyNCkKKwordm9pZCBhdGg3OV9jbG9ja3NfaW5pdCh2b2lkKTsKK3ZvaWQgYXRoNzlfZGRyX3diX2ZsdXNoKHVuc2lnbmVkIGludCByZWcpOworCit2b2lkIGF0aDc5X2dwaW9fZnVuY3Rpb25fZW5hYmxlKHUzMiBtYXNrKTsKK3ZvaWQgYXRoNzlfZ3Bpb19mdW5jdGlvbl9kaXNhYmxlKHUzMiBtYXNrKTsKK3ZvaWQgYXRoNzlfZ3Bpb19mdW5jdGlvbl9zZXR1cCh1MzIgc2V0LCB1MzIgY2xlYXIpOwordm9pZCBhdGg3OV9ncGlvX2luaXQodm9pZCk7CisKKyNlbmRpZiAvKiBfX0FUSDc5X0NPTU1PTl9IICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvYXRoNzkvZGV2LWFyOTEzeC13bWFjLmMgYi9hcmNoL21pcHMvYXRoNzkvZGV2LWFyOTEzeC13bWFjLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDhmNDI1YQotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvbWlwcy9hdGg3OS9kZXYtYXI5MTN4LXdtYWMuYwpAQCAtMCwwICsxLDYwIEBACisvKgorICogIEF0aGVyb3MgQVI5MTNYIFNvQyBidWlsdC1pbiBXTUFDIGRldmljZSBzdXBwb3J0CisgKgorICogIENvcHlyaWdodCAoQykgMjAwOC0yMDEwIEdhYm9yIEp1aG9zIDxqdWhvc2dAb3BlbndydC5vcmc+CisgKiAgQ29weXJpZ2h0IChDKSAyMDA4IEltcmUgS2Fsb3ogPGthbG96QG9wZW53cnQub3JnPgorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZAorICogIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L2lycS5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L2F0aDlrX3BsYXRmb3JtLmg+CisKKyNpbmNsdWRlIDxhc20vbWFjaC1hdGg3OS9hdGg3OS5oPgorI2luY2x1ZGUgPGFzbS9tYWNoLWF0aDc5L2FyNzF4eF9yZWdzLmg+CisjaW5jbHVkZSAiZGV2LWFyOTEzeC13bWFjLmgiCisKK3N0YXRpYyBzdHJ1Y3QgYXRoOWtfcGxhdGZvcm1fZGF0YSBhcjkxM3hfd21hY19kYXRhOworCitzdGF0aWMgc3RydWN0IHJlc291cmNlIGFyOTEzeF93bWFjX3Jlc291cmNlc1tdID0geworCXsKKwkJLnN0YXJ0CT0gQVI5MTNYX1dNQUNfQkFTRSwKKwkJLmVuZAk9IEFSOTEzWF9XTUFDX0JBU0UgKyBBUjkxM1hfV01BQ19TSVpFIC0gMSwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9NRU0sCisJfSwgeworCQkuc3RhcnQJPSBBVEg3OV9DUFVfSVJRX0lQMiwKKwkJLmVuZAk9IEFUSDc5X0NQVV9JUlFfSVAyLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgYXI5MTN4X3dtYWNfZGV2aWNlID0geworCS5uYW1lCQk9ICJhdGg5ayIsCisJLmlkCQk9IC0xLAorCS5yZXNvdXJjZQk9IGFyOTEzeF93bWFjX3Jlc291cmNlcywKKwkubnVtX3Jlc291cmNlcwk9IEFSUkFZX1NJWkUoYXI5MTN4X3dtYWNfcmVzb3VyY2VzKSwKKwkuZGV2ID0geworCQkucGxhdGZvcm1fZGF0YSA9ICZhcjkxM3hfd21hY19kYXRhLAorCX0sCit9OworCit2b2lkIF9faW5pdCBhdGg3OV9yZWdpc3Rlcl9hcjkxM3hfd21hYyh1OCAqY2FsX2RhdGEpCit7CisJaWYgKGNhbF9kYXRhKQorCQltZW1jcHkoYXI5MTN4X3dtYWNfZGF0YS5lZXByb21fZGF0YSwgY2FsX2RhdGEsCisJCSAgICAgICBzaXplb2YoYXI5MTN4X3dtYWNfZGF0YS5lZXByb21fZGF0YSkpOworCisJLyogcmVzZXQgdGhlIFdNQUMgKi8KKwlhdGg3OV9kZXZpY2VfcmVzZXRfc2V0KEFSOTEzWF9SRVNFVF9BTUJBMldNQUMpOworCW1kZWxheSgxMCk7CisKKwlhdGg3OV9kZXZpY2VfcmVzZXRfY2xlYXIoQVI5MTNYX1JFU0VUX0FNQkEyV01BQyk7CisJbWRlbGF5KDEwKTsKKworCXBsYXRmb3JtX2RldmljZV9yZWdpc3RlcigmYXI5MTN4X3dtYWNfZGV2aWNlKTsKK30KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9hdGg3OS9kZXYtYXI5MTN4LXdtYWMuaCBiL2FyY2gvbWlwcy9hdGg3OS9kZXYtYXI5MTN4LXdtYWMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41NzlkNTYyCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2F0aDc5L2Rldi1hcjkxM3gtd21hYy5oCkBAIC0wLDAgKzEsMTcgQEAKKy8qCisgKiAgQXRoZXJvcyBBUjkxM1ggU29DIGJ1aWx0LWluIFdNQUMgZGV2aWNlIHN1cHBvcnQKKyAqCisgKiAgQ29weXJpZ2h0IChDKSAyMDA4LTIwMTAgR2Fib3IgSnVob3MgPGp1aG9zZ0BvcGVud3J0Lm9yZz4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDggSW1yZSBLYWxveiA8a2Fsb3pAb3BlbndydC5vcmc+CisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkCisgKiAgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqLworCisjaWZuZGVmIF9BVEg3OV9ERVZfQVI5MTNYX1dNQUNfSAorI2RlZmluZSBfQVRINzlfREVWX0FSOTEzWF9XTUFDX0gKKwordm9pZCBhdGg3OV9yZWdpc3Rlcl9hcjkxM3hfd21hYyh1OCAqY2FsX2RhdGEpOworCisjZW5kaWYgLyogX0FUSDc5X0RFVl9BUjkxM1hfV01BQ19IICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvYXRoNzkvZGV2LWNvbW1vbi5jIGIvYXJjaC9taXBzL2F0aDc5L2Rldi1jb21tb24uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zYjgyZTMyCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2F0aDc5L2Rldi1jb21tb24uYwpAQCAtMCwwICsxLDc3IEBACisvKgorICogIEF0aGVyb3MgQVI3MVhYL0FSNzI0WC9BUjkxM1ggY29tbW9uIGRldmljZXMKKyAqCisgKiAgQ29weXJpZ2h0IChDKSAyMDA4LTIwMTEgR2Fib3IgSnVob3MgPGp1aG9zZ0BvcGVud3J0Lm9yZz4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDggSW1yZSBLYWxveiA8a2Fsb3pAb3BlbndydC5vcmc+CisgKgorICogIFBhcnRzIG9mIHRoaXMgZmlsZSBhcmUgYmFzZWQgb24gQXRoZXJvcycgMi42LjE1IEJTUAorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZAorICogIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9zZXJpYWxfODI1MC5oPgorI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgorI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgorCisjaW5jbHVkZSA8YXNtL21hY2gtYXRoNzkvYXRoNzkuaD4KKyNpbmNsdWRlIDxhc20vbWFjaC1hdGg3OS9hcjcxeHhfcmVncy5oPgorI2luY2x1ZGUgImNvbW1vbi5oIgorI2luY2x1ZGUgImRldi1jb21tb24uaCIKKworc3RhdGljIHN0cnVjdCByZXNvdXJjZSBhdGg3OV91YXJ0X3Jlc291cmNlc1tdID0geworCXsKKwkJLnN0YXJ0CT0gQVI3MVhYX1VBUlRfQkFTRSwKKwkJLmVuZAk9IEFSNzFYWF9VQVJUX0JBU0UgKyBBUjcxWFhfVUFSVF9TSVpFIC0gMSwKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9NRU0sCisJfSwKK307CisKKyNkZWZpbmUgQVI3MVhYX1VBUlRfRkxBR1MgKFVQRl9CT09UX0FVVE9DT05GIHwgVVBGX1NLSVBfVEVTVCB8IFVQRl9JT1JFTUFQKQorc3RhdGljIHN0cnVjdCBwbGF0X3NlcmlhbDgyNTBfcG9ydCBhdGg3OV91YXJ0X2RhdGFbXSA9IHsKKwl7CisJCS5tYXBiYXNlCT0gQVI3MVhYX1VBUlRfQkFTRSwKKwkJLmlycQkJPSBBVEg3OV9NSVNDX0lSUV9VQVJULAorCQkuZmxhZ3MJCT0gQVI3MVhYX1VBUlRfRkxBR1MsCisJCS5pb3R5cGUJCT0gVVBJT19NRU0zMiwKKwkJLnJlZ3NoaWZ0CT0gMiwKKwl9LCB7CisJCS8qIHRlcm1pbmF0aW5nIGVudHJ5ICovCisJfQorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgYXRoNzlfdWFydF9kZXZpY2UgPSB7CisJLm5hbWUJCT0gInNlcmlhbDgyNTAiLAorCS5pZAkJPSBQTEFUODI1MF9ERVZfUExBVEZPUk0sCisJLnJlc291cmNlCT0gYXRoNzlfdWFydF9yZXNvdXJjZXMsCisJLm51bV9yZXNvdXJjZXMJPSBBUlJBWV9TSVpFKGF0aDc5X3VhcnRfcmVzb3VyY2VzKSwKKwkuZGV2ID0geworCQkucGxhdGZvcm1fZGF0YQk9IGF0aDc5X3VhcnRfZGF0YQorCX0sCit9OworCit2b2lkIF9faW5pdCBhdGg3OV9yZWdpc3Rlcl91YXJ0KHZvaWQpCit7CisJc3RydWN0IGNsayAqY2xrOworCisJY2xrID0gY2xrX2dldChOVUxMLCAidWFydCIpOworCWlmIChJU19FUlIoY2xrKSkKKwkJcGFuaWMoInVuYWJsZSB0byBnZXQgVUFSVCBjbG9jaywgZXJyPSVsZCIsIFBUUl9FUlIoY2xrKSk7CisKKwlhdGg3OV91YXJ0X2RhdGFbMF0udWFydGNsayA9IGNsa19nZXRfcmF0ZShjbGspOworCXBsYXRmb3JtX2RldmljZV9yZWdpc3RlcigmYXRoNzlfdWFydF9kZXZpY2UpOworfQorCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSBhdGg3OV93ZHRfZGV2aWNlID0geworCS5uYW1lCQk9ICJhdGg3OS13ZHQiLAorCS5pZAkJPSAtMSwKK307CisKK3ZvaWQgX19pbml0IGF0aDc5X3JlZ2lzdGVyX3dkdCh2b2lkKQoreworCXBsYXRmb3JtX2RldmljZV9yZWdpc3RlcigmYXRoNzlfd2R0X2RldmljZSk7Cit9CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvYXRoNzkvZGV2LWNvbW1vbi5oIGIvYXJjaC9taXBzL2F0aDc5L2Rldi1jb21tb24uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wZjUxNGUxCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2F0aDc5L2Rldi1jb21tb24uaApAQCAtMCwwICsxLDE4IEBACisvKgorICogIEF0aGVyb3MgQVI3MVhYL0FSNzI0WC9BUjkxM1ggY29tbW9uIGRldmljZXMKKyAqCisgKiAgQ29weXJpZ2h0IChDKSAyMDA4LTIwMTAgR2Fib3IgSnVob3MgPGp1aG9zZ0BvcGVud3J0Lm9yZz4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDggSW1yZSBLYWxveiA8a2Fsb3pAb3BlbndydC5vcmc+CisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkCisgKiAgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqLworCisjaWZuZGVmIF9BVEg3OV9ERVZfQ09NTU9OX0gKKyNkZWZpbmUgX0FUSDc5X0RFVl9DT01NT05fSAorCit2b2lkIGF0aDc5X3JlZ2lzdGVyX3VhcnQodm9pZCk7Cit2b2lkIGF0aDc5X3JlZ2lzdGVyX3dkdCh2b2lkKTsKKworI2VuZGlmIC8qIF9BVEg3OV9ERVZfQ09NTU9OX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9hdGg3OS9kZXYtZ3Bpby1idXR0b25zLmMgYi9hcmNoL21pcHMvYXRoNzkvZGV2LWdwaW8tYnV0dG9ucy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjRiMDE2OGEKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL21pcHMvYXRoNzkvZGV2LWdwaW8tYnV0dG9ucy5jCkBAIC0wLDAgKzEsNTggQEAKKy8qCisgKiAgQXRoZXJvcyBBUjcxWFgvQVI3MjRYL0FSOTEzWCBHUElPIGJ1dHRvbiBzdXBwb3J0CisgKgorICogIENvcHlyaWdodCAoQykgMjAwOC0yMDEwIEdhYm9yIEp1aG9zIDxqdWhvc2dAb3BlbndydC5vcmc+CisgKiAgQ29weXJpZ2h0IChDKSAyMDA4IEltcmUgS2Fsb3ogPGthbG96QG9wZW53cnQub3JnPgorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZAorICogIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKi8KKworI2luY2x1ZGUgImxpbnV4L2luaXQuaCIKKyNpbmNsdWRlICJsaW51eC9zbGFiLmgiCisjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisKKyNpbmNsdWRlICJkZXYtZ3Bpby1idXR0b25zLmgiCisKK3ZvaWQgX19pbml0IGF0aDc5X3JlZ2lzdGVyX2dwaW9fa2V5c19wb2xsZWQoaW50IGlkLAorCQkJCQkgICAgdW5zaWduZWQgcG9sbF9pbnRlcnZhbCwKKwkJCQkJICAgIHVuc2lnbmVkIG5idXR0b25zLAorCQkJCQkgICAgc3RydWN0IGdwaW9fa2V5c19idXR0b24gKmJ1dHRvbnMpCit7CisJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldjsKKwlzdHJ1Y3QgZ3Bpb19rZXlzX3BsYXRmb3JtX2RhdGEgcGRhdGE7CisJc3RydWN0IGdwaW9fa2V5c19idXR0b24gKnA7CisJaW50IGVycjsKKworCXAgPSBrbWFsbG9jKG5idXR0b25zICogc2l6ZW9mKCpwKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFwKQorCQlyZXR1cm47CisKKwltZW1jcHkocCwgYnV0dG9ucywgbmJ1dHRvbnMgKiBzaXplb2YoKnApKTsKKworCXBkZXYgPSBwbGF0Zm9ybV9kZXZpY2VfYWxsb2MoImdwaW8ta2V5cy1wb2xsZWQiLCBpZCk7CisJaWYgKCFwZGV2KQorCQlnb3RvIGVycl9mcmVlX2J1dHRvbnM7CisKKwltZW1zZXQoJnBkYXRhLCAwLCBzaXplb2YocGRhdGEpKTsKKwlwZGF0YS5wb2xsX2ludGVydmFsID0gcG9sbF9pbnRlcnZhbDsKKwlwZGF0YS5uYnV0dG9ucyA9IG5idXR0b25zOworCXBkYXRhLmJ1dHRvbnMgPSBwOworCisJZXJyID0gcGxhdGZvcm1fZGV2aWNlX2FkZF9kYXRhKHBkZXYsICZwZGF0YSwgc2l6ZW9mKHBkYXRhKSk7CisJaWYgKGVycikKKwkJZ290byBlcnJfcHV0X3BkZXY7CisKKwllcnIgPSBwbGF0Zm9ybV9kZXZpY2VfYWRkKHBkZXYpOworCWlmIChlcnIpCisJCWdvdG8gZXJyX3B1dF9wZGV2OworCisJcmV0dXJuOworCitlcnJfcHV0X3BkZXY6CisJcGxhdGZvcm1fZGV2aWNlX3B1dChwZGV2KTsKKworZXJyX2ZyZWVfYnV0dG9uczoKKwlrZnJlZShwKTsKK30KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9hdGg3OS9kZXYtZ3Bpby1idXR0b25zLmggYi9hcmNoL21pcHMvYXRoNzkvZGV2LWdwaW8tYnV0dG9ucy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQ4MTg0N2EKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL21pcHMvYXRoNzkvZGV2LWdwaW8tYnV0dG9ucy5oCkBAIC0wLDAgKzEsMjMgQEAKKy8qCisgKiAgQXRoZXJvcyBBUjcxWFgvQVI3MjRYL0FSOTEzWCBHUElPIGJ1dHRvbiBzdXBwb3J0CisgKgorICogIENvcHlyaWdodCAoQykgMjAwOC0yMDEwIEdhYm9yIEp1aG9zIDxqdWhvc2dAb3BlbndydC5vcmc+CisgKiAgQ29weXJpZ2h0IChDKSAyMDA4IEltcmUgS2Fsb3ogPGthbG96QG9wZW53cnQub3JnPgorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZAorICogIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKi8KKworI2lmbmRlZiBfQVRINzlfREVWX0dQSU9fQlVUVE9OU19ICisjZGVmaW5lIF9BVEg3OV9ERVZfR1BJT19CVVRUT05TX0gKKworI2luY2x1ZGUgPGxpbnV4L2lucHV0Lmg+CisjaW5jbHVkZSA8bGludXgvZ3Bpb19rZXlzLmg+CisKK3ZvaWQgYXRoNzlfcmVnaXN0ZXJfZ3Bpb19rZXlzX3BvbGxlZChpbnQgaWQsCisJCQkJICAgICB1bnNpZ25lZCBwb2xsX2ludGVydmFsLAorCQkJCSAgICAgdW5zaWduZWQgbmJ1dHRvbnMsCisJCQkJICAgICBzdHJ1Y3QgZ3Bpb19rZXlzX2J1dHRvbiAqYnV0dG9ucyk7CisKKyNlbmRpZiAvKiBfQVRINzlfREVWX0dQSU9fQlVUVE9OU19IICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvYXRoNzkvZGV2LWxlZHMtZ3Bpby5jIGIvYXJjaC9taXBzL2F0aDc5L2Rldi1sZWRzLWdwaW8uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jZGFkZTY4Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2F0aDc5L2Rldi1sZWRzLWdwaW8uYwpAQCAtMCwwICsxLDU2IEBACisvKgorICogIEF0aGVyb3MgQVI3MVhYL0FSNzI0WC9BUjkxM1ggY29tbW9uIEdQSU8gTEVEcyBzdXBwb3J0CisgKgorICogIENvcHlyaWdodCAoQykgMjAwOC0yMDEwIEdhYm9yIEp1aG9zIDxqdWhvc2dAb3BlbndydC5vcmc+CisgKiAgQ29weXJpZ2h0IChDKSAyMDA4IEltcmUgS2Fsb3ogPGthbG96QG9wZW53cnQub3JnPgorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZAorICogIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisKKyNpbmNsdWRlICJkZXYtbGVkcy1ncGlvLmgiCisKK3ZvaWQgX19pbml0IGF0aDc5X3JlZ2lzdGVyX2xlZHNfZ3BpbyhpbnQgaWQsCisJCQkJICAgICB1bnNpZ25lZCBudW1fbGVkcywKKwkJCQkgICAgIHN0cnVjdCBncGlvX2xlZCAqbGVkcykKK3sKKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2OworCXN0cnVjdCBncGlvX2xlZF9wbGF0Zm9ybV9kYXRhIHBkYXRhOworCXN0cnVjdCBncGlvX2xlZCAqcDsKKwlpbnQgZXJyOworCisJcCA9IGttYWxsb2MobnVtX2xlZHMgKiBzaXplb2YoKnApLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXApCisJCXJldHVybjsKKworCW1lbWNweShwLCBsZWRzLCBudW1fbGVkcyAqIHNpemVvZigqcCkpOworCisJcGRldiA9IHBsYXRmb3JtX2RldmljZV9hbGxvYygibGVkcy1ncGlvIiwgaWQpOworCWlmICghcGRldikKKwkJZ290byBlcnJfZnJlZV9sZWRzOworCisJbWVtc2V0KCZwZGF0YSwgMCwgc2l6ZW9mKHBkYXRhKSk7CisJcGRhdGEubnVtX2xlZHMgPSBudW1fbGVkczsKKwlwZGF0YS5sZWRzID0gcDsKKworCWVyciA9IHBsYXRmb3JtX2RldmljZV9hZGRfZGF0YShwZGV2LCAmcGRhdGEsIHNpemVvZihwZGF0YSkpOworCWlmIChlcnIpCisJCWdvdG8gZXJyX3B1dF9wZGV2OworCisJZXJyID0gcGxhdGZvcm1fZGV2aWNlX2FkZChwZGV2KTsKKwlpZiAoZXJyKQorCQlnb3RvIGVycl9wdXRfcGRldjsKKworCXJldHVybjsKKworZXJyX3B1dF9wZGV2OgorCXBsYXRmb3JtX2RldmljZV9wdXQocGRldik7CisKK2Vycl9mcmVlX2xlZHM6CisJa2ZyZWUocCk7Cit9CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvYXRoNzkvZGV2LWxlZHMtZ3Bpby5oIGIvYXJjaC9taXBzL2F0aDc5L2Rldi1sZWRzLWdwaW8uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ZTVkODg1Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2F0aDc5L2Rldi1sZWRzLWdwaW8uaApAQCAtMCwwICsxLDIxIEBACisvKgorICogIEF0aGVyb3MgQVI3MVhYL0FSNzI0WC9BUjkxM1ggY29tbW9uIEdQSU8gTEVEcyBzdXBwb3J0CisgKgorICogIENvcHlyaWdodCAoQykgMjAwOC0yMDEwIEdhYm9yIEp1aG9zIDxqdWhvc2dAb3BlbndydC5vcmc+CisgKiAgQ29weXJpZ2h0IChDKSAyMDA4IEltcmUgS2Fsb3ogPGthbG96QG9wZW53cnQub3JnPgorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZAorICogIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKi8KKworI2lmbmRlZiBfQVRINzlfREVWX0xFRFNfR1BJT19ICisjZGVmaW5lIF9BVEg3OV9ERVZfTEVEU19HUElPX0gKKworI2luY2x1ZGUgPGxpbnV4L2xlZHMuaD4KKwordm9pZCBhdGg3OV9yZWdpc3Rlcl9sZWRzX2dwaW8oaW50IGlkLAorCQkJICAgICAgdW5zaWduZWQgbnVtX2xlZHMsCisJCQkgICAgICBzdHJ1Y3QgZ3Bpb19sZWQgKmxlZHMpOworCisjZW5kaWYgLyogX0FUSDc5X0RFVl9MRURTX0dQSU9fSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2F0aDc5L2Rldi1zcGkuYyBiL2FyY2gvbWlwcy9hdGg3OS9kZXYtc3BpLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYWEzMDE2MwotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvbWlwcy9hdGg3OS9kZXYtc3BpLmMKQEAgLTAsMCArMSwzOCBAQAorLyoKKyAqICBBdGhlcm9zIEFSNzFYWC9BUjcyNFgvQVI5MTNYIFNQSSBjb250cm9sbGVyIGRldmljZQorICoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDgtMjAxMCBHYWJvciBKdWhvcyA8anVob3NnQG9wZW53cnQub3JnPgorICogIENvcHlyaWdodCAoQykgMjAwOCBJbXJlIEthbG96IDxrYWxvekBvcGVud3J0Lm9yZz4KKyAqCisgKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqICB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQKKyAqICBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICovCisKKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxhc20vbWFjaC1hdGg3OS9hcjcxeHhfcmVncy5oPgorI2luY2x1ZGUgImRldi1zcGkuaCIKKworc3RhdGljIHN0cnVjdCByZXNvdXJjZSBhdGg3OV9zcGlfcmVzb3VyY2VzW10gPSB7CisJeworCQkuc3RhcnQJPSBBUjcxWFhfU1BJX0JBU0UsCisJCS5lbmQJPSBBUjcxWFhfU1BJX0JBU0UgKyBBUjcxWFhfU1BJX1NJWkUgLSAxLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX01FTSwKKwl9LAorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgYXRoNzlfc3BpX2RldmljZSA9IHsKKwkubmFtZQkJPSAiYXRoNzktc3BpIiwKKwkuaWQJCT0gLTEsCisJLnJlc291cmNlCT0gYXRoNzlfc3BpX3Jlc291cmNlcywKKwkubnVtX3Jlc291cmNlcwk9IEFSUkFZX1NJWkUoYXRoNzlfc3BpX3Jlc291cmNlcyksCit9OworCit2b2lkIF9faW5pdCBhdGg3OV9yZWdpc3Rlcl9zcGkoc3RydWN0IGF0aDc5X3NwaV9wbGF0Zm9ybV9kYXRhICpwZGF0YSwKKwkJCSAgICAgICBzdHJ1Y3Qgc3BpX2JvYXJkX2luZm8gY29uc3QgKmluZm8sCisJCQkgICAgICAgdW5zaWduZWQgbikKK3sKKwlzcGlfcmVnaXN0ZXJfYm9hcmRfaW5mbyhpbmZvLCBuKTsKKwlhdGg3OV9zcGlfZGV2aWNlLmRldi5wbGF0Zm9ybV9kYXRhID0gcGRhdGE7CisJcGxhdGZvcm1fZGV2aWNlX3JlZ2lzdGVyKCZhdGg3OV9zcGlfZGV2aWNlKTsKK30KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9hdGg3OS9kZXYtc3BpLmggYi9hcmNoL21pcHMvYXRoNzkvZGV2LXNwaS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ3MzI1NjUKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL21pcHMvYXRoNzkvZGV2LXNwaS5oCkBAIC0wLDAgKzEsMjIgQEAKKy8qCisgKiAgQXRoZXJvcyBBUjcxWFgvQVI3MjRYL0FSOTEzWCBTUEkgY29udHJvbGxlciBkZXZpY2UKKyAqCisgKiAgQ29weXJpZ2h0IChDKSAyMDA4LTIwMTAgR2Fib3IgSnVob3MgPGp1aG9zZ0BvcGVud3J0Lm9yZz4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDggSW1yZSBLYWxveiA8a2Fsb3pAb3BlbndydC5vcmc+CisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkCisgKiAgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqLworCisjaWZuZGVmIF9BVEg3OV9ERVZfU1BJX0gKKyNkZWZpbmUgX0FUSDc5X0RFVl9TUElfSAorCisjaW5jbHVkZSA8bGludXgvc3BpL3NwaS5oPgorI2luY2x1ZGUgPGFzbS9tYWNoLWF0aDc5L2F0aDc5X3NwaV9wbGF0Zm9ybS5oPgorCit2b2lkIGF0aDc5X3JlZ2lzdGVyX3NwaShzdHJ1Y3QgYXRoNzlfc3BpX3BsYXRmb3JtX2RhdGEgKnBkYXRhLAorCQkJIHN0cnVjdCBzcGlfYm9hcmRfaW5mbyBjb25zdCAqaW5mbywKKwkJCSB1bnNpZ25lZCBuKTsKKworI2VuZGlmIC8qIF9BVEg3OV9ERVZfU1BJX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9hdGg3OS9lYXJseV9wcmludGsuYyBiL2FyY2gvbWlwcy9hdGg3OS9lYXJseV9wcmludGsuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43NDk5YjBlCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2F0aDc5L2Vhcmx5X3ByaW50ay5jCkBAIC0wLDAgKzEsMzYgQEAKKy8qCisgKiAgQXRoZXJvcyBBUjcxWFgvQVI3MjRYL0FSOTEzWCBTb0MgZWFybHkgcHJpbnRrIHN1cHBvcnQKKyAqCisgKiAgQ29weXJpZ2h0IChDKSAyMDA4LTIwMTAgR2Fib3IgSnVob3MgPGp1aG9zZ0BvcGVud3J0Lm9yZz4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDggSW1yZSBLYWxveiA8a2Fsb3pAb3BlbndydC5vcmc+CisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkCisgKiAgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqLworCisjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9zZXJpYWxfcmVnLmg+CisjaW5jbHVkZSA8YXNtL2FkZHJzcGFjZS5oPgorCisjaW5jbHVkZSA8YXNtL21hY2gtYXRoNzkvYXI3MXh4X3JlZ3MuaD4KKworc3RhdGljIGlubGluZSB2b2lkIHByb21fd2FpdF90aHJlKHZvaWQgX19pb21lbSAqYmFzZSkKK3sKKwl1MzIgbHNyOworCisJZG8geworCQlsc3IgPSBfX3Jhd19yZWFkbChiYXNlICsgVUFSVF9MU1IgKiA0KTsKKwkJaWYgKGxzciAmIFVBUlRfTFNSX1RIUkUpCisJCQlicmVhazsKKwl9IHdoaWxlICgxKTsKK30KKwordm9pZCBwcm9tX3B1dGNoYXIodW5zaWduZWQgY2hhciBjaCkKK3sKKwl2b2lkIF9faW9tZW0gKmJhc2UgPSAodm9pZCBfX2lvbWVtICopKEtTRUcxQUREUihBUjcxWFhfVUFSVF9CQVNFKSk7CisKKwlwcm9tX3dhaXRfdGhyZShiYXNlKTsKKwlfX3Jhd193cml0ZWwoY2gsIGJhc2UgKyBVQVJUX1RYICogNCk7CisJcHJvbV93YWl0X3RocmUoYmFzZSk7Cit9CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvYXRoNzkvZ3Bpby5jIGIvYXJjaC9taXBzL2F0aDc5L2dwaW8uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hMGM0MjZiCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2F0aDc5L2dwaW8uYwpAQCAtMCwwICsxLDE5NyBAQAorLyoKKyAqICBBdGhlcm9zIEFSNzFYWC9BUjcyNFgvQVI5MTNYIEdQSU8gQVBJIHN1cHBvcnQKKyAqCisgKiAgQ29weXJpZ2h0IChDKSAyMDA4LTIwMTAgR2Fib3IgSnVob3MgPGp1aG9zZ0BvcGVud3J0Lm9yZz4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDggSW1yZSBLYWxveiA8a2Fsb3pAb3BlbndydC5vcmc+CisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkCisgKiAgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqLworCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KKyNpbmNsdWRlIDxsaW51eC9pby5oPgorI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgorI2luY2x1ZGUgPGxpbnV4L2dwaW8uaD4KKworI2luY2x1ZGUgPGFzbS9tYWNoLWF0aDc5L2FyNzF4eF9yZWdzLmg+CisjaW5jbHVkZSA8YXNtL21hY2gtYXRoNzkvYXRoNzkuaD4KKyNpbmNsdWRlICJjb21tb24uaCIKKworc3RhdGljIHZvaWQgX19pb21lbSAqYXRoNzlfZ3Bpb19iYXNlOworc3RhdGljIHVuc2lnbmVkIGxvbmcgYXRoNzlfZ3Bpb19jb3VudDsKK3N0YXRpYyBERUZJTkVfU1BJTkxPQ0soYXRoNzlfZ3Bpb19sb2NrKTsKKworc3RhdGljIHZvaWQgX19hdGg3OV9ncGlvX3NldF92YWx1ZSh1bnNpZ25lZCBncGlvLCBpbnQgdmFsdWUpCit7CisJdm9pZCBfX2lvbWVtICpiYXNlID0gYXRoNzlfZ3Bpb19iYXNlOworCisJaWYgKHZhbHVlKQorCQlfX3Jhd193cml0ZWwoMSA8PCBncGlvLCBiYXNlICsgQVI3MVhYX0dQSU9fUkVHX1NFVCk7CisJZWxzZQorCQlfX3Jhd193cml0ZWwoMSA8PCBncGlvLCBiYXNlICsgQVI3MVhYX0dQSU9fUkVHX0NMRUFSKTsKK30KKworc3RhdGljIGludCBfX2F0aDc5X2dwaW9fZ2V0X3ZhbHVlKHVuc2lnbmVkIGdwaW8pCit7CisJcmV0dXJuIChfX3Jhd19yZWFkbChhdGg3OV9ncGlvX2Jhc2UgKyBBUjcxWFhfR1BJT19SRUdfSU4pID4+IGdwaW8pICYgMTsKK30KKworc3RhdGljIGludCBhdGg3OV9ncGlvX2dldF92YWx1ZShzdHJ1Y3QgZ3Bpb19jaGlwICpjaGlwLCB1bnNpZ25lZCBvZmZzZXQpCit7CisJcmV0dXJuIF9fYXRoNzlfZ3Bpb19nZXRfdmFsdWUob2Zmc2V0KTsKK30KKworc3RhdGljIHZvaWQgYXRoNzlfZ3Bpb19zZXRfdmFsdWUoc3RydWN0IGdwaW9fY2hpcCAqY2hpcCwKKwkJCQkgIHVuc2lnbmVkIG9mZnNldCwgaW50IHZhbHVlKQoreworCV9fYXRoNzlfZ3Bpb19zZXRfdmFsdWUob2Zmc2V0LCB2YWx1ZSk7Cit9CisKK3N0YXRpYyBpbnQgYXRoNzlfZ3Bpb19kaXJlY3Rpb25faW5wdXQoc3RydWN0IGdwaW9fY2hpcCAqY2hpcCwKKwkJCQkgICAgICAgdW5zaWduZWQgb2Zmc2V0KQoreworCXZvaWQgX19pb21lbSAqYmFzZSA9IGF0aDc5X2dwaW9fYmFzZTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmF0aDc5X2dwaW9fbG9jaywgZmxhZ3MpOworCisJX19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKGJhc2UgKyBBUjcxWFhfR1BJT19SRUdfT0UpICYgfigxIDw8IG9mZnNldCksCisJCSAgICAgYmFzZSArIEFSNzFYWF9HUElPX1JFR19PRSk7CisKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZhdGg3OV9ncGlvX2xvY2ssIGZsYWdzKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGF0aDc5X2dwaW9fZGlyZWN0aW9uX291dHB1dChzdHJ1Y3QgZ3Bpb19jaGlwICpjaGlwLAorCQkJCQl1bnNpZ25lZCBvZmZzZXQsIGludCB2YWx1ZSkKK3sKKwl2b2lkIF9faW9tZW0gKmJhc2UgPSBhdGg3OV9ncGlvX2Jhc2U7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZhdGg3OV9ncGlvX2xvY2ssIGZsYWdzKTsKKworCWlmICh2YWx1ZSkKKwkJX19yYXdfd3JpdGVsKDEgPDwgb2Zmc2V0LCBiYXNlICsgQVI3MVhYX0dQSU9fUkVHX1NFVCk7CisJZWxzZQorCQlfX3Jhd193cml0ZWwoMSA8PCBvZmZzZXQsIGJhc2UgKyBBUjcxWFhfR1BJT19SRUdfQ0xFQVIpOworCisJX19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKGJhc2UgKyBBUjcxWFhfR1BJT19SRUdfT0UpIHwgKDEgPDwgb2Zmc2V0KSwKKwkJICAgICBiYXNlICsgQVI3MVhYX0dQSU9fUkVHX09FKTsKKworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmF0aDc5X2dwaW9fbG9jaywgZmxhZ3MpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgZ3Bpb19jaGlwIGF0aDc5X2dwaW9fY2hpcCA9IHsKKwkubGFiZWwJCQk9ICJhdGg3OSIsCisJLmdldAkJCT0gYXRoNzlfZ3Bpb19nZXRfdmFsdWUsCisJLnNldAkJCT0gYXRoNzlfZ3Bpb19zZXRfdmFsdWUsCisJLmRpcmVjdGlvbl9pbnB1dAk9IGF0aDc5X2dwaW9fZGlyZWN0aW9uX2lucHV0LAorCS5kaXJlY3Rpb25fb3V0cHV0CT0gYXRoNzlfZ3Bpb19kaXJlY3Rpb25fb3V0cHV0LAorCS5iYXNlCQkJPSAwLAorfTsKKwordm9pZCBhdGg3OV9ncGlvX2Z1bmN0aW9uX2VuYWJsZSh1MzIgbWFzaykKK3sKKwl2b2lkIF9faW9tZW0gKmJhc2UgPSBhdGg3OV9ncGlvX2Jhc2U7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZhdGg3OV9ncGlvX2xvY2ssIGZsYWdzKTsKKworCV9fcmF3X3dyaXRlbChfX3Jhd19yZWFkbChiYXNlICsgQVI3MVhYX0dQSU9fUkVHX0ZVTkMpIHwgbWFzaywKKwkJICAgICBiYXNlICsgQVI3MVhYX0dQSU9fUkVHX0ZVTkMpOworCS8qIGZsdXNoIHdyaXRlICovCisJX19yYXdfcmVhZGwoYmFzZSArIEFSNzFYWF9HUElPX1JFR19GVU5DKTsKKworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmF0aDc5X2dwaW9fbG9jaywgZmxhZ3MpOworfQorCit2b2lkIGF0aDc5X2dwaW9fZnVuY3Rpb25fZGlzYWJsZSh1MzIgbWFzaykKK3sKKwl2b2lkIF9faW9tZW0gKmJhc2UgPSBhdGg3OV9ncGlvX2Jhc2U7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZhdGg3OV9ncGlvX2xvY2ssIGZsYWdzKTsKKworCV9fcmF3X3dyaXRlbChfX3Jhd19yZWFkbChiYXNlICsgQVI3MVhYX0dQSU9fUkVHX0ZVTkMpICYgfm1hc2ssCisJCSAgICAgYmFzZSArIEFSNzFYWF9HUElPX1JFR19GVU5DKTsKKwkvKiBmbHVzaCB3cml0ZSAqLworCV9fcmF3X3JlYWRsKGJhc2UgKyBBUjcxWFhfR1BJT19SRUdfRlVOQyk7CisKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZhdGg3OV9ncGlvX2xvY2ssIGZsYWdzKTsKK30KKwordm9pZCBhdGg3OV9ncGlvX2Z1bmN0aW9uX3NldHVwKHUzMiBzZXQsIHUzMiBjbGVhcikKK3sKKwl2b2lkIF9faW9tZW0gKmJhc2UgPSBhdGg3OV9ncGlvX2Jhc2U7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZhdGg3OV9ncGlvX2xvY2ssIGZsYWdzKTsKKworCV9fcmF3X3dyaXRlbCgoX19yYXdfcmVhZGwoYmFzZSArIEFSNzFYWF9HUElPX1JFR19GVU5DKSAmIH5jbGVhcikgfCBzZXQsCisJCSAgICAgYmFzZSArIEFSNzFYWF9HUElPX1JFR19GVU5DKTsKKwkvKiBmbHVzaCB3cml0ZSAqLworCV9fcmF3X3JlYWRsKGJhc2UgKyBBUjcxWFhfR1BJT19SRUdfRlVOQyk7CisKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZhdGg3OV9ncGlvX2xvY2ssIGZsYWdzKTsKK30KKwordm9pZCBfX2luaXQgYXRoNzlfZ3Bpb19pbml0KHZvaWQpCit7CisJaW50IGVycjsKKworCWlmIChzb2NfaXNfYXI3MXh4KCkpCisJCWF0aDc5X2dwaW9fY291bnQgPSBBUjcxWFhfR1BJT19DT1VOVDsKKwllbHNlIGlmIChzb2NfaXNfYXI3MjR4KCkpCisJCWF0aDc5X2dwaW9fY291bnQgPSBBUjcyNFhfR1BJT19DT1VOVDsKKwllbHNlIGlmIChzb2NfaXNfYXI5MTN4KCkpCisJCWF0aDc5X2dwaW9fY291bnQgPSBBUjkxM1hfR1BJT19DT1VOVDsKKwllbHNlCisJCUJVRygpOworCisJYXRoNzlfZ3Bpb19iYXNlID0gaW9yZW1hcF9ub2NhY2hlKEFSNzFYWF9HUElPX0JBU0UsIEFSNzFYWF9HUElPX1NJWkUpOworCWF0aDc5X2dwaW9fY2hpcC5uZ3BpbyA9IGF0aDc5X2dwaW9fY291bnQ7CisKKwllcnIgPSBncGlvY2hpcF9hZGQoJmF0aDc5X2dwaW9fY2hpcCk7CisJaWYgKGVycikKKwkJcGFuaWMoImNhbm5vdCBhZGQgQVI3MXh4IEdQSU8gY2hpcCwgZXJyb3I9JWQiLCBlcnIpOworfQorCitpbnQgZ3Bpb19nZXRfdmFsdWUodW5zaWduZWQgZ3BpbykKK3sKKwlpZiAoZ3BpbyA8IGF0aDc5X2dwaW9fY291bnQpCisJCXJldHVybiBfX2F0aDc5X2dwaW9fZ2V0X3ZhbHVlKGdwaW8pOworCisJcmV0dXJuIF9fZ3Bpb19nZXRfdmFsdWUoZ3Bpbyk7Cit9CitFWFBPUlRfU1lNQk9MKGdwaW9fZ2V0X3ZhbHVlKTsKKwordm9pZCBncGlvX3NldF92YWx1ZSh1bnNpZ25lZCBncGlvLCBpbnQgdmFsdWUpCit7CisJaWYgKGdwaW8gPCBhdGg3OV9ncGlvX2NvdW50KQorCQlfX2F0aDc5X2dwaW9fc2V0X3ZhbHVlKGdwaW8sIHZhbHVlKTsKKwllbHNlCisJCV9fZ3Bpb19zZXRfdmFsdWUoZ3BpbywgdmFsdWUpOworfQorRVhQT1JUX1NZTUJPTChncGlvX3NldF92YWx1ZSk7CisKK2ludCBncGlvX3RvX2lycSh1bnNpZ25lZCBncGlvKQoreworCS8qIEZJWE1FICovCisJcmV0dXJuIC1FSU5WQUw7Cit9CitFWFBPUlRfU1lNQk9MKGdwaW9fdG9faXJxKTsKKworaW50IGlycV90b19ncGlvKHVuc2lnbmVkIGlycSkKK3sKKwkvKiBGSVhNRSAqLworCXJldHVybiAtRUlOVkFMOworfQorRVhQT1JUX1NZTUJPTChpcnFfdG9fZ3Bpbyk7CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvYXRoNzkvaXJxLmMgYi9hcmNoL21pcHMvYXRoNzkvaXJxLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMWJmN2Y3MQotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvbWlwcy9hdGg3OS9pcnEuYwpAQCAtMCwwICsxLDE4NyBAQAorLyoKKyAqICBBdGhlcm9zIEFSNzF4eC9BUjcyNHgvQVI5MTN4IHNwZWNpZmljIGludGVycnVwdCBoYW5kbGluZworICoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDgtMjAxMCBHYWJvciBKdWhvcyA8anVob3NnQG9wZW53cnQub3JnPgorICogIENvcHlyaWdodCAoQykgMjAwOCBJbXJlIEthbG96IDxrYWxvekBvcGVud3J0Lm9yZz4KKyAqCisgKiAgUGFydHMgb2YgdGhpcyBmaWxlIGFyZSBiYXNlZCBvbiBBdGhlcm9zJyAyLjYuMTUgQlNQCisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkCisgKiAgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqLworCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgorI2luY2x1ZGUgPGxpbnV4L2lycS5oPgorCisjaW5jbHVkZSA8YXNtL2lycV9jcHUuaD4KKyNpbmNsdWRlIDxhc20vbWlwc3JlZ3MuaD4KKworI2luY2x1ZGUgPGFzbS9tYWNoLWF0aDc5L2F0aDc5Lmg+CisjaW5jbHVkZSA8YXNtL21hY2gtYXRoNzkvYXI3MXh4X3JlZ3MuaD4KKyNpbmNsdWRlICJjb21tb24uaCIKKworc3RhdGljIHVuc2lnbmVkIGludCBhdGg3OV9pcDJfZmx1c2hfcmVnOworc3RhdGljIHVuc2lnbmVkIGludCBhdGg3OV9pcDNfZmx1c2hfcmVnOworCitzdGF0aWMgdm9pZCBhdGg3OV9taXNjX2lycV9oYW5kbGVyKHVuc2lnbmVkIGludCBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKK3sKKwl2b2lkIF9faW9tZW0gKmJhc2UgPSBhdGg3OV9yZXNldF9iYXNlOworCXUzMiBwZW5kaW5nOworCisJcGVuZGluZyA9IF9fcmF3X3JlYWRsKGJhc2UgKyBBUjcxWFhfUkVTRVRfUkVHX01JU0NfSU5UX1NUQVRVUykgJgorCQkgIF9fcmF3X3JlYWRsKGJhc2UgKyBBUjcxWFhfUkVTRVRfUkVHX01JU0NfSU5UX0VOQUJMRSk7CisKKwlpZiAocGVuZGluZyAmIE1JU0NfSU5UX1VBUlQpCisJCWdlbmVyaWNfaGFuZGxlX2lycShBVEg3OV9NSVNDX0lSUV9VQVJUKTsKKworCWVsc2UgaWYgKHBlbmRpbmcgJiBNSVNDX0lOVF9ETUEpCisJCWdlbmVyaWNfaGFuZGxlX2lycShBVEg3OV9NSVNDX0lSUV9ETUEpOworCisJZWxzZSBpZiAocGVuZGluZyAmIE1JU0NfSU5UX1BFUkZDKQorCQlnZW5lcmljX2hhbmRsZV9pcnEoQVRINzlfTUlTQ19JUlFfUEVSRkMpOworCisJZWxzZSBpZiAocGVuZGluZyAmIE1JU0NfSU5UX1RJTUVSKQorCQlnZW5lcmljX2hhbmRsZV9pcnEoQVRINzlfTUlTQ19JUlFfVElNRVIpOworCisJZWxzZSBpZiAocGVuZGluZyAmIE1JU0NfSU5UX09IQ0kpCisJCWdlbmVyaWNfaGFuZGxlX2lycShBVEg3OV9NSVNDX0lSUV9PSENJKTsKKworCWVsc2UgaWYgKHBlbmRpbmcgJiBNSVNDX0lOVF9FUlJPUikKKwkJZ2VuZXJpY19oYW5kbGVfaXJxKEFUSDc5X01JU0NfSVJRX0VSUk9SKTsKKworCWVsc2UgaWYgKHBlbmRpbmcgJiBNSVNDX0lOVF9HUElPKQorCQlnZW5lcmljX2hhbmRsZV9pcnEoQVRINzlfTUlTQ19JUlFfR1BJTyk7CisKKwllbHNlIGlmIChwZW5kaW5nICYgTUlTQ19JTlRfV0RPRykKKwkJZ2VuZXJpY19oYW5kbGVfaXJxKEFUSDc5X01JU0NfSVJRX1dET0cpOworCisJZWxzZQorCQlzcHVyaW91c19pbnRlcnJ1cHQoKTsKK30KKworc3RhdGljIHZvaWQgYXI3MXh4X21pc2NfaXJxX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQoreworCXZvaWQgX19pb21lbSAqYmFzZSA9IGF0aDc5X3Jlc2V0X2Jhc2U7CisJdTMyIHQ7CisKKwlpcnEgLT0gQVRINzlfTUlTQ19JUlFfQkFTRTsKKworCXQgPSBfX3Jhd19yZWFkbChiYXNlICsgQVI3MVhYX1JFU0VUX1JFR19NSVNDX0lOVF9FTkFCTEUpOworCV9fcmF3X3dyaXRlbCh0IHwgKDEgPDwgaXJxKSwgYmFzZSArIEFSNzFYWF9SRVNFVF9SRUdfTUlTQ19JTlRfRU5BQkxFKTsKKworCS8qIGZsdXNoIHdyaXRlICovCisJX19yYXdfcmVhZGwoYmFzZSArIEFSNzFYWF9SRVNFVF9SRUdfTUlTQ19JTlRfRU5BQkxFKTsKK30KKworc3RhdGljIHZvaWQgYXI3MXh4X21pc2NfaXJxX21hc2sodW5zaWduZWQgaW50IGlycSkKK3sKKwl2b2lkIF9faW9tZW0gKmJhc2UgPSBhdGg3OV9yZXNldF9iYXNlOworCXUzMiB0OworCisJaXJxIC09IEFUSDc5X01JU0NfSVJRX0JBU0U7CisKKwl0ID0gX19yYXdfcmVhZGwoYmFzZSArIEFSNzFYWF9SRVNFVF9SRUdfTUlTQ19JTlRfRU5BQkxFKTsKKwlfX3Jhd193cml0ZWwodCAmIH4oMSA8PCBpcnEpLCBiYXNlICsgQVI3MVhYX1JFU0VUX1JFR19NSVNDX0lOVF9FTkFCTEUpOworCisJLyogZmx1c2ggd3JpdGUgKi8KKwlfX3Jhd19yZWFkbChiYXNlICsgQVI3MVhYX1JFU0VUX1JFR19NSVNDX0lOVF9FTkFCTEUpOworfQorCitzdGF0aWMgdm9pZCBhcjcyNHhfbWlzY19pcnFfYWNrKHVuc2lnbmVkIGludCBpcnEpCit7CisJdm9pZCBfX2lvbWVtICpiYXNlID0gYXRoNzlfcmVzZXRfYmFzZTsKKwl1MzIgdDsKKworCWlycSAtPSBBVEg3OV9NSVNDX0lSUV9CQVNFOworCisJdCA9IF9fcmF3X3JlYWRsKGJhc2UgKyBBUjcxWFhfUkVTRVRfUkVHX01JU0NfSU5UX1NUQVRVUyk7CisJX19yYXdfd3JpdGVsKHQgJiB+KDEgPDwgaXJxKSwgYmFzZSArIEFSNzFYWF9SRVNFVF9SRUdfTUlTQ19JTlRfU1RBVFVTKTsKKworCS8qIGZsdXNoIHdyaXRlICovCisJX19yYXdfcmVhZGwoYmFzZSArIEFSNzFYWF9SRVNFVF9SRUdfTUlTQ19JTlRfU1RBVFVTKTsKK30KKworc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBhdGg3OV9taXNjX2lycV9jaGlwID0geworCS5uYW1lCQk9ICJNSVNDIiwKKwkudW5tYXNrCQk9IGFyNzF4eF9taXNjX2lycV91bm1hc2ssCisJLm1hc2sJCT0gYXI3MXh4X21pc2NfaXJxX21hc2ssCit9OworCitzdGF0aWMgdm9pZCBfX2luaXQgYXRoNzlfbWlzY19pcnFfaW5pdCh2b2lkKQoreworCXZvaWQgX19pb21lbSAqYmFzZSA9IGF0aDc5X3Jlc2V0X2Jhc2U7CisJaW50IGk7CisKKwlfX3Jhd193cml0ZWwoMCwgYmFzZSArIEFSNzFYWF9SRVNFVF9SRUdfTUlTQ19JTlRfRU5BQkxFKTsKKwlfX3Jhd193cml0ZWwoMCwgYmFzZSArIEFSNzFYWF9SRVNFVF9SRUdfTUlTQ19JTlRfU1RBVFVTKTsKKworCWlmIChzb2NfaXNfYXI3MXh4KCkgfHwgc29jX2lzX2FyOTEzeCgpKQorCQlhdGg3OV9taXNjX2lycV9jaGlwLm1hc2tfYWNrID0gYXI3MXh4X21pc2NfaXJxX21hc2s7CisJZWxzZSBpZiAoc29jX2lzX2FyNzI0eCgpKQorCQlhdGg3OV9taXNjX2lycV9jaGlwLmFjayA9IGFyNzI0eF9taXNjX2lycV9hY2s7CisJZWxzZQorCQlCVUcoKTsKKworCWZvciAoaSA9IEFUSDc5X01JU0NfSVJRX0JBU0U7CisJICAgICBpIDwgQVRINzlfTUlTQ19JUlFfQkFTRSArIEFUSDc5X01JU0NfSVJRX0NPVU5UOyBpKyspIHsKKwkJaXJxX2Rlc2NbaV0uc3RhdHVzID0gSVJRX0RJU0FCTEVEOworCQlzZXRfaXJxX2NoaXBfYW5kX2hhbmRsZXIoaSwgJmF0aDc5X21pc2NfaXJxX2NoaXAsCisJCQkJCSBoYW5kbGVfbGV2ZWxfaXJxKTsKKwl9CisKKwlzZXRfaXJxX2NoYWluZWRfaGFuZGxlcihBVEg3OV9DUFVfSVJRX01JU0MsIGF0aDc5X21pc2NfaXJxX2hhbmRsZXIpOworfQorCithc21saW5rYWdlIHZvaWQgcGxhdF9pcnFfZGlzcGF0Y2godm9pZCkKK3sKKwl1bnNpZ25lZCBsb25nIHBlbmRpbmc7CisKKwlwZW5kaW5nID0gcmVhZF9jMF9zdGF0dXMoKSAmIHJlYWRfYzBfY2F1c2UoKSAmIFNUMF9JTTsKKworCWlmIChwZW5kaW5nICYgU1RBVFVTRl9JUDcpCisJCWRvX0lSUShBVEg3OV9DUFVfSVJRX1RJTUVSKTsKKworCWVsc2UgaWYgKHBlbmRpbmcgJiBTVEFUVVNGX0lQMikgeworCQlhdGg3OV9kZHJfd2JfZmx1c2goYXRoNzlfaXAyX2ZsdXNoX3JlZyk7CisJCWRvX0lSUShBVEg3OV9DUFVfSVJRX0lQMik7CisJfQorCisJZWxzZSBpZiAocGVuZGluZyAmIFNUQVRVU0ZfSVA0KQorCQlkb19JUlEoQVRINzlfQ1BVX0lSUV9HRTApOworCisJZWxzZSBpZiAocGVuZGluZyAmIFNUQVRVU0ZfSVA1KQorCQlkb19JUlEoQVRINzlfQ1BVX0lSUV9HRTEpOworCisJZWxzZSBpZiAocGVuZGluZyAmIFNUQVRVU0ZfSVAzKSB7CisJCWF0aDc5X2Rkcl93Yl9mbHVzaChhdGg3OV9pcDNfZmx1c2hfcmVnKTsKKwkJZG9fSVJRKEFUSDc5X0NQVV9JUlFfVVNCKTsKKwl9CisKKwllbHNlIGlmIChwZW5kaW5nICYgU1RBVFVTRl9JUDYpCisJCWRvX0lSUShBVEg3OV9DUFVfSVJRX01JU0MpOworCisJZWxzZQorCQlzcHVyaW91c19pbnRlcnJ1cHQoKTsKK30KKwordm9pZCBfX2luaXQgYXJjaF9pbml0X2lycSh2b2lkKQoreworCWlmIChzb2NfaXNfYXI3MXh4KCkpIHsKKwkJYXRoNzlfaXAyX2ZsdXNoX3JlZyA9IEFSNzFYWF9ERFJfUkVHX0ZMVVNIX1BDSTsKKwkJYXRoNzlfaXAzX2ZsdXNoX3JlZyA9IEFSNzFYWF9ERFJfUkVHX0ZMVVNIX1VTQjsKKwl9IGVsc2UgaWYgKHNvY19pc19hcjcyNHgoKSkgeworCQlhdGg3OV9pcDJfZmx1c2hfcmVnID0gQVI3MjRYX0REUl9SRUdfRkxVU0hfUENJRTsKKwkJYXRoNzlfaXAzX2ZsdXNoX3JlZyA9IEFSNzI0WF9ERFJfUkVHX0ZMVVNIX1VTQjsKKwl9IGVsc2UgaWYgKHNvY19pc19hcjkxM3goKSkgeworCQlhdGg3OV9pcDJfZmx1c2hfcmVnID0gQVI5MTNYX0REUl9SRUdfRkxVU0hfV01BQzsKKwkJYXRoNzlfaXAzX2ZsdXNoX3JlZyA9IEFSOTEzWF9ERFJfUkVHX0ZMVVNIX1VTQjsKKwl9IGVsc2UKKwkJQlVHKCk7CisKKwljcDBfcGVyZmNvdW50X2lycSA9IEFUSDc5X01JU0NfSVJRX1BFUkZDOworCW1pcHNfY3B1X2lycV9pbml0KCk7CisJYXRoNzlfbWlzY19pcnFfaW5pdCgpOworfQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2F0aDc5L21hY2gtYXA4MS5jIGIvYXJjaC9taXBzL2F0aDc5L21hY2gtYXA4MS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmVlZTRjMTIKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL21pcHMvYXRoNzkvbWFjaC1hcDgxLmMKQEAgLTAsMCArMSw5OCBAQAorLyoKKyAqICBBdGhlcm9zIEFQODEgYm9hcmQgc3VwcG9ydAorICoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDktMjAxMCBHYWJvciBKdWhvcyA8anVob3NnQG9wZW53cnQub3JnPgorICogIENvcHlyaWdodCAoQykgMjAwOSBJbXJlIEthbG96IDxrYWxvekBvcGVud3J0Lm9yZz4KKyAqCisgKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqICB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQKKyAqICBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICovCisKKyNpbmNsdWRlICJtYWNodHlwZXMuaCIKKyNpbmNsdWRlICJkZXYtYXI5MTN4LXdtYWMuaCIKKyNpbmNsdWRlICJkZXYtZ3Bpby1idXR0b25zLmgiCisjaW5jbHVkZSAiZGV2LWxlZHMtZ3Bpby5oIgorI2luY2x1ZGUgImRldi1zcGkuaCIKKworI2RlZmluZSBBUDgxX0dQSU9fTEVEX1NUQVRVUwkxCisjZGVmaW5lIEFQODFfR1BJT19MRURfQU9TUwkzCisjZGVmaW5lIEFQODFfR1BJT19MRURfV0xBTgk2CisjZGVmaW5lIEFQODFfR1BJT19MRURfUE9XRVIJMTQKKworI2RlZmluZSBBUDgxX0dQSU9fQlROX1NXNAkxMgorI2RlZmluZSBBUDgxX0dQSU9fQlROX1NXMQkyMQorCisjZGVmaW5lIEFQODFfS0VZU19QT0xMX0lOVEVSVkFMCQkyMAkvKiBtc2VjcyAqLworI2RlZmluZSBBUDgxX0tFWVNfREVCT1VOQ0VfSU5URVJWQUwJKDMgKiBBUDgxX0tFWVNfUE9MTF9JTlRFUlZBTCkKKworI2RlZmluZSBBUDgxX0NBTF9EQVRBX0FERFIJMHgxZmZmMTAwMAorCitzdGF0aWMgc3RydWN0IGdwaW9fbGVkIGFwODFfbGVkc19ncGlvW10gX19pbml0ZGF0YSA9IHsKKwl7CisJCS5uYW1lCQk9ICJhcDgxOmdyZWVuOnN0YXR1cyIsCisJCS5ncGlvCQk9IEFQODFfR1BJT19MRURfU1RBVFVTLAorCQkuYWN0aXZlX2xvdwk9IDEsCisJfSwgeworCQkubmFtZQkJPSAiYXA4MTphbWJlcjphb3NzIiwKKwkJLmdwaW8JCT0gQVA4MV9HUElPX0xFRF9BT1NTLAorCQkuYWN0aXZlX2xvdwk9IDEsCisJfSwgeworCQkubmFtZQkJPSAiYXA4MTpncmVlbjp3bGFuIiwKKwkJLmdwaW8JCT0gQVA4MV9HUElPX0xFRF9XTEFOLAorCQkuYWN0aXZlX2xvdwk9IDEsCisJfSwgeworCQkubmFtZQkJPSAiYXA4MTpncmVlbjpwb3dlciIsCisJCS5ncGlvCQk9IEFQODFfR1BJT19MRURfUE9XRVIsCisJCS5hY3RpdmVfbG93CT0gMSwKKwl9Cit9OworCitzdGF0aWMgc3RydWN0IGdwaW9fa2V5c19idXR0b24gYXA4MV9ncGlvX2tleXNbXSBfX2luaXRkYXRhID0geworCXsKKwkJLmRlc2MJCT0gInN3MSIsCisJCS50eXBlCQk9IEVWX0tFWSwKKwkJLmNvZGUJCT0gQlROXzAsCisJCS5kZWJvdW5jZV9pbnRlcnZhbCA9IEFQODFfS0VZU19ERUJPVU5DRV9JTlRFUlZBTCwKKwkJLmdwaW8JCT0gQVA4MV9HUElPX0JUTl9TVzEsCisJCS5hY3RpdmVfbG93CT0gMSwKKwl9ICwgeworCQkuZGVzYwkJPSAic3c0IiwKKwkJLnR5cGUJCT0gRVZfS0VZLAorCQkuY29kZQkJPSBCVE5fMSwKKwkJLmRlYm91bmNlX2ludGVydmFsID0gQVA4MV9LRVlTX0RFQk9VTkNFX0lOVEVSVkFMLAorCQkuZ3BpbwkJPSBBUDgxX0dQSU9fQlROX1NXNCwKKwkJLmFjdGl2ZV9sb3cJPSAxLAorCX0KK307CisKK3N0YXRpYyBzdHJ1Y3Qgc3BpX2JvYXJkX2luZm8gYXA4MV9zcGlfaW5mb1tdID0geworCXsKKwkJLmJ1c19udW0JPSAwLAorCQkuY2hpcF9zZWxlY3QJPSAwLAorCQkubWF4X3NwZWVkX2h6CT0gMjUwMDAwMDAsCisJCS5tb2RhbGlhcwk9ICJtMjVwNjQiLAorCX0KK307CisKK3N0YXRpYyBzdHJ1Y3QgYXRoNzlfc3BpX3BsYXRmb3JtX2RhdGEgYXA4MV9zcGlfZGF0YSA9IHsKKwkuYnVzX251bQk9IDAsCisJLm51bV9jaGlwc2VsZWN0CT0gMSwKK307CisKK3N0YXRpYyB2b2lkIF9faW5pdCBhcDgxX3NldHVwKHZvaWQpCit7CisJdTggKmNhbF9kYXRhID0gKHU4ICopIEtTRUcxQUREUihBUDgxX0NBTF9EQVRBX0FERFIpOworCisJYXRoNzlfcmVnaXN0ZXJfbGVkc19ncGlvKC0xLCBBUlJBWV9TSVpFKGFwODFfbGVkc19ncGlvKSwKKwkJCQkgYXA4MV9sZWRzX2dwaW8pOworCWF0aDc5X3JlZ2lzdGVyX2dwaW9fa2V5c19wb2xsZWQoLTEsIEFQODFfS0VZU19QT0xMX0lOVEVSVkFMLAorCQkJCQlBUlJBWV9TSVpFKGFwODFfZ3Bpb19rZXlzKSwKKwkJCQkJYXA4MV9ncGlvX2tleXMpOworCWF0aDc5X3JlZ2lzdGVyX3NwaSgmYXA4MV9zcGlfZGF0YSwgYXA4MV9zcGlfaW5mbywKKwkJCSAgIEFSUkFZX1NJWkUoYXA4MV9zcGlfaW5mbykpOworCWF0aDc5X3JlZ2lzdGVyX2FyOTEzeF93bWFjKGNhbF9kYXRhKTsKK30KKworTUlQU19NQUNISU5FKEFUSDc5X01BQ0hfQVA4MSwgIkFQODEiLCAiQXRoZXJvcyBBUDgxIHJlZmVyZW5jZSBib2FyZCIsCisJICAgICBhcDgxX3NldHVwKTsKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9hdGg3OS9tYWNoLXBiNDQuYyBiL2FyY2gvbWlwcy9hdGg3OS9tYWNoLXBiNDQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lYzdiN2ExCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2F0aDc5L21hY2gtcGI0NC5jCkBAIC0wLDAgKzEsMTE4IEBACisvKgorICogIEF0aGVyb3MgUEI0NCByZWZlcmVuY2UgYm9hcmQgc3VwcG9ydAorICoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDktMjAxMCBHYWJvciBKdWhvcyA8anVob3NnQG9wZW53cnQub3JnPgorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZAorICogIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9pMmMuaD4KKyNpbmNsdWRlIDxsaW51eC9pMmMtZ3Bpby5oPgorI2luY2x1ZGUgPGxpbnV4L2kyYy9wY2Y4NTd4Lmg+CisKKyNpbmNsdWRlICJtYWNodHlwZXMuaCIKKyNpbmNsdWRlICJkZXYtZ3Bpby1idXR0b25zLmgiCisjaW5jbHVkZSAiZGV2LWxlZHMtZ3Bpby5oIgorI2luY2x1ZGUgImRldi1zcGkuaCIKKworI2RlZmluZSBQQjQ0X0dQSU9fSTJDX1NDTAkwCisjZGVmaW5lIFBCNDRfR1BJT19JMkNfU0RBCTEKKworI2RlZmluZSBQQjQ0X0dQSU9fRVhQX0JBU0UJMTYKKyNkZWZpbmUgUEI0NF9HUElPX1NXX1JFU0VUCShQQjQ0X0dQSU9fRVhQX0JBU0UgKyA2KQorI2RlZmluZSBQQjQ0X0dQSU9fU1dfSlVNUAkoUEI0NF9HUElPX0VYUF9CQVNFICsgOCkKKyNkZWZpbmUgUEI0NF9HUElPX0xFRF9KVU1QMQkoUEI0NF9HUElPX0VYUF9CQVNFICsgOSkKKyNkZWZpbmUgUEI0NF9HUElPX0xFRF9KVU1QMgkoUEI0NF9HUElPX0VYUF9CQVNFICsgMTApCisKKyNkZWZpbmUgUEI0NF9LRVlTX1BPTExfSU5URVJWQUwJCTIwCS8qIG1zZWNzICovCisjZGVmaW5lIFBCNDRfS0VZU19ERUJPVU5DRV9JTlRFUlZBTAkoMyAqIFBCNDRfS0VZU19QT0xMX0lOVEVSVkFMKQorCitzdGF0aWMgc3RydWN0IGkyY19ncGlvX3BsYXRmb3JtX2RhdGEgcGI0NF9pMmNfZ3Bpb19kYXRhID0geworCS5zZGFfcGluICAgICAgICA9IFBCNDRfR1BJT19JMkNfU0RBLAorCS5zY2xfcGluICAgICAgICA9IFBCNDRfR1BJT19JMkNfU0NMLAorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgcGI0NF9pMmNfZ3Bpb19kZXZpY2UgPSB7CisJLm5hbWUJCT0gImkyYy1ncGlvIiwKKwkuaWQJCT0gMCwKKwkuZGV2ID0geworCQkucGxhdGZvcm1fZGF0YQk9ICZwYjQ0X2kyY19ncGlvX2RhdGEsCisJfQorfTsKKworc3RhdGljIHN0cnVjdCBwY2Y4NTd4X3BsYXRmb3JtX2RhdGEgcGI0NF9wY2Y4NTd4X2RhdGEgPSB7CisJLmdwaW9fYmFzZQk9IFBCNDRfR1BJT19FWFBfQkFTRSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgaTJjX2JvYXJkX2luZm8gcGI0NF9pMmNfYm9hcmRfaW5mb1tdIF9faW5pdGRhdGEgPSB7CisJeworCQlJMkNfQk9BUkRfSU5GTygicGNmODU3NSIsIDB4MjApLAorCQkucGxhdGZvcm1fZGF0YSAgPSAmcGI0NF9wY2Y4NTd4X2RhdGEsCisJfSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgZ3Bpb19sZWQgcGI0NF9sZWRzX2dwaW9bXSBfX2luaXRkYXRhID0geworCXsKKwkJLm5hbWUJCT0gInBiNDQ6YW1iZXI6anVtcDEiLAorCQkuZ3BpbwkJPSBQQjQ0X0dQSU9fTEVEX0pVTVAxLAorCQkuYWN0aXZlX2xvdwk9IDEsCisJfSwgeworCQkubmFtZQkJPSAicGI0NDpncmVlbjpqdW1wMiIsCisJCS5ncGlvCQk9IFBCNDRfR1BJT19MRURfSlVNUDIsCisJCS5hY3RpdmVfbG93CT0gMSwKKwl9LAorfTsKKworc3RhdGljIHN0cnVjdCBncGlvX2tleXNfYnV0dG9uIHBiNDRfZ3Bpb19rZXlzW10gX19pbml0ZGF0YSA9IHsKKwl7CisJCS5kZXNjCQk9ICJzb2Z0X3Jlc2V0IiwKKwkJLnR5cGUJCT0gRVZfS0VZLAorCQkuY29kZQkJPSBLRVlfUkVTVEFSVCwKKwkJLmRlYm91bmNlX2ludGVydmFsID0gUEI0NF9LRVlTX0RFQk9VTkNFX0lOVEVSVkFMLAorCQkuZ3BpbwkJPSBQQjQ0X0dQSU9fU1dfUkVTRVQsCisJCS5hY3RpdmVfbG93CT0gMSwKKwl9ICwgeworCQkuZGVzYwkJPSAianVtcHN0YXJ0IiwKKwkJLnR5cGUJCT0gRVZfS0VZLAorCQkuY29kZQkJPSBLRVlfV1BTX0JVVFRPTiwKKwkJLmRlYm91bmNlX2ludGVydmFsID0gUEI0NF9LRVlTX0RFQk9VTkNFX0lOVEVSVkFMLAorCQkuZ3BpbwkJPSBQQjQ0X0dQSU9fU1dfSlVNUCwKKwkJLmFjdGl2ZV9sb3cJPSAxLAorCX0KK307CisKK3N0YXRpYyBzdHJ1Y3Qgc3BpX2JvYXJkX2luZm8gcGI0NF9zcGlfaW5mb1tdID0geworCXsKKwkJLmJ1c19udW0JPSAwLAorCQkuY2hpcF9zZWxlY3QJPSAwLAorCQkubWF4X3NwZWVkX2h6CT0gMjUwMDAwMDAsCisJCS5tb2RhbGlhcwk9ICJtMjVwNjQiLAorCX0sCit9OworCitzdGF0aWMgc3RydWN0IGF0aDc5X3NwaV9wbGF0Zm9ybV9kYXRhIHBiNDRfc3BpX2RhdGEgPSB7CisJLmJ1c19udW0JCT0gMCwKKwkubnVtX2NoaXBzZWxlY3QJCT0gMSwKK307CisKK3N0YXRpYyB2b2lkIF9faW5pdCBwYjQ0X2luaXQodm9pZCkKK3sKKwlpMmNfcmVnaXN0ZXJfYm9hcmRfaW5mbygwLCBwYjQ0X2kyY19ib2FyZF9pbmZvLAorCQkJCUFSUkFZX1NJWkUocGI0NF9pMmNfYm9hcmRfaW5mbykpOworCXBsYXRmb3JtX2RldmljZV9yZWdpc3RlcigmcGI0NF9pMmNfZ3Bpb19kZXZpY2UpOworCisJYXRoNzlfcmVnaXN0ZXJfbGVkc19ncGlvKC0xLCBBUlJBWV9TSVpFKHBiNDRfbGVkc19ncGlvKSwKKwkJCQkgcGI0NF9sZWRzX2dwaW8pOworCWF0aDc5X3JlZ2lzdGVyX2dwaW9fa2V5c19wb2xsZWQoLTEsIFBCNDRfS0VZU19QT0xMX0lOVEVSVkFMLAorCQkJCQlBUlJBWV9TSVpFKHBiNDRfZ3Bpb19rZXlzKSwKKwkJCQkJcGI0NF9ncGlvX2tleXMpOworCWF0aDc5X3JlZ2lzdGVyX3NwaSgmcGI0NF9zcGlfZGF0YSwgcGI0NF9zcGlfaW5mbywKKwkJCSAgIEFSUkFZX1NJWkUocGI0NF9zcGlfaW5mbykpOworfQorCitNSVBTX01BQ0hJTkUoQVRINzlfTUFDSF9QQjQ0LCAiUEI0NCIsICJBdGhlcm9zIFBCNDQgcmVmZXJlbmNlIGJvYXJkIiwKKwkgICAgIHBiNDRfaW5pdCk7CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvYXRoNzkvbWFjaHR5cGVzLmggYi9hcmNoL21pcHMvYXRoNzkvbWFjaHR5cGVzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzk0MGZlNAotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvbWlwcy9hdGg3OS9tYWNodHlwZXMuaApAQCAtMCwwICsxLDIzIEBACisvKgorICogIEF0aGVyb3MgQVI3MVhYL0FSNzI0WC9BUjkxM1ggbWFjaGluZSB0eXBlIGRlZmluaXRpb25zCisgKgorICogIENvcHlyaWdodCAoQykgMjAwOC0yMDEwIEdhYm9yIEp1aG9zIDxqdWhvc2dAb3BlbndydC5vcmc+CisgKiAgQ29weXJpZ2h0IChDKSAyMDA4IEltcmUgS2Fsb3ogPGthbG96QG9wZW53cnQub3JnPgorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZAorICogIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKi8KKworI2lmbmRlZiBfQVRINzlfTUFDSFRZUEVfSAorI2RlZmluZSBfQVRINzlfTUFDSFRZUEVfSAorCisjaW5jbHVkZSA8YXNtL21pcHNfbWFjaGluZS5oPgorCitlbnVtIGF0aDc5X21hY2hfdHlwZSB7CisJQVRINzlfTUFDSF9HRU5FUklDID0gMCwKKwlBVEg3OV9NQUNIX0FQODEsCQkvKiBBdGhlcm9zIEFQODEgcmVmZXJlbmNlIGJvYXJkICovCisJQVRINzlfTUFDSF9QQjQ0LAkJLyogQXRoZXJvcyBQQjQ0IHJlZmVyZW5jZSBib2FyZCAqLworfTsKKworI2VuZGlmIC8qIF9BVEg3OV9NQUNIVFlQRV9IICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvYXRoNzkvcHJvbS5jIGIvYXJjaC9taXBzL2F0aDc5L3Byb20uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lOWNiZDdjCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2F0aDc5L3Byb20uYwpAQCAtMCwwICsxLDU3IEBACisvKgorICogIEF0aGVyb3MgQVI3MVhYL0FSNzI0WC9BUjkxM1ggc3BlY2lmaWMgcHJvbSByb3V0aW5lcworICoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDgtMjAxMCBHYWJvciBKdWhvcyA8anVob3NnQG9wZW53cnQub3JnPgorICogIENvcHlyaWdodCAoQykgMjAwOCBJbXJlIEthbG96IDxrYWxvekBvcGVud3J0Lm9yZz4KKyAqCisgKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqICB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQKKyAqICBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICovCisKKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KKworI2luY2x1ZGUgPGFzbS9ib290aW5mby5oPgorI2luY2x1ZGUgPGFzbS9hZGRyc3BhY2UuaD4KKworI2luY2x1ZGUgImNvbW1vbi5oIgorCitzdGF0aWMgaW5saW5lIGludCBpc192YWxpZF9yYW1fYWRkcih2b2lkICphZGRyKQoreworCWlmICgoKHUzMikgYWRkciA+IEtTRUcwKSAmJgorCSAgICAoKHUzMikgYWRkciA8IChLU0VHMCArIEFUSDc5X01FTV9TSVpFX01BWCkpKQorCQlyZXR1cm4gMTsKKworCWlmICgoKHUzMikgYWRkciA+IEtTRUcxKSAmJgorCSAgICAoKHUzMikgYWRkciA8IChLU0VHMSArIEFUSDc5X01FTV9TSVpFX01BWCkpKQorCQlyZXR1cm4gMTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgX19pbml0IHZvaWQgYXRoNzlfcHJvbV9pbml0X2NtZGxpbmUoaW50IGFyZ2MsIGNoYXIgKiphcmd2KQoreworCWludCBpOworCisJaWYgKCFpc192YWxpZF9yYW1fYWRkcihhcmd2KSkKKwkJcmV0dXJuOworCisJZm9yIChpID0gMDsgaSA8IGFyZ2M7IGkrKykKKwkJaWYgKGlzX3ZhbGlkX3JhbV9hZGRyKGFyZ3ZbaV0pKSB7CisJCQlzdHJsY2F0KGFyY3NfY21kbGluZSwgIiAiLCBzaXplb2YoYXJjc19jbWRsaW5lKSk7CisJCQlzdHJsY2F0KGFyY3NfY21kbGluZSwgYXJndltpXSwgc2l6ZW9mKGFyY3NfY21kbGluZSkpOworCQl9Cit9CisKK3ZvaWQgX19pbml0IHByb21faW5pdCh2b2lkKQoreworCWF0aDc5X3Byb21faW5pdF9jbWRsaW5lKGZ3X2FyZzAsIChjaGFyICoqKWZ3X2FyZzEpOworfQorCit2b2lkIF9faW5pdCBwcm9tX2ZyZWVfcHJvbV9tZW1vcnkodm9pZCkKK3sKKwkvKiBXZSBkbyBub3QgaGF2ZSB0byBwcm9tIG1lbW9yeSB0byBmcmVlICovCit9CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvYXRoNzkvc2V0dXAuYyBiL2FyY2gvbWlwcy9hdGg3OS9zZXR1cC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjE1OWI0MmYKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL21pcHMvYXRoNzkvc2V0dXAuYwpAQCAtMCwwICsxLDIwNiBAQAorLyoKKyAqICBBdGhlcm9zIEFSNzFYWC9BUjcyNFgvQVI5MTNYIHNwZWNpZmljIHNldHVwCisgKgorICogIENvcHlyaWdodCAoQykgMjAwOC0yMDExIEdhYm9yIEp1aG9zIDxqdWhvc2dAb3BlbndydC5vcmc+CisgKiAgQ29weXJpZ2h0IChDKSAyMDA4IEltcmUgS2Fsb3ogPGthbG96QG9wZW53cnQub3JnPgorICoKKyAqICBQYXJ0cyBvZiB0aGlzIGZpbGUgYXJlIGJhc2VkIG9uIEF0aGVyb3MnIDIuNi4xNSBCU1AKKyAqCisgKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqICB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQKKyAqICBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICovCisKKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvYm9vdG1lbS5oPgorI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgorI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgorCisjaW5jbHVkZSA8YXNtL2Jvb3RpbmZvLmg+CisjaW5jbHVkZSA8YXNtL3RpbWUuaD4JCS8qIGZvciBtaXBzX2hwdF9mcmVxdWVuY3kgKi8KKyNpbmNsdWRlIDxhc20vcmVib290Lmg+CQkvKiBmb3IgX21hY2hpbmVfe3Jlc3RhcnQsaGFsdH0gKi8KKyNpbmNsdWRlIDxhc20vbWlwc19tYWNoaW5lLmg+CisKKyNpbmNsdWRlIDxhc20vbWFjaC1hdGg3OS9hdGg3OS5oPgorI2luY2x1ZGUgPGFzbS9tYWNoLWF0aDc5L2FyNzF4eF9yZWdzLmg+CisjaW5jbHVkZSAiY29tbW9uLmgiCisjaW5jbHVkZSAiZGV2LWNvbW1vbi5oIgorI2luY2x1ZGUgIm1hY2h0eXBlcy5oIgorCisjZGVmaW5lIEFUSDc5X1NZU19UWVBFX0xFTgk2NAorCisjZGVmaW5lIEFSNzFYWF9CQVNFX0ZSRVEJNDAwMDAwMDAKKyNkZWZpbmUgQVI3MjRYX0JBU0VfRlJFUQk1MDAwMDAwCisjZGVmaW5lIEFSOTEzWF9CQVNFX0ZSRVEJNTAwMDAwMAorCitzdGF0aWMgY2hhciBhdGg3OV9zeXNfdHlwZVtBVEg3OV9TWVNfVFlQRV9MRU5dOworCitzdGF0aWMgdm9pZCBhdGg3OV9yZXN0YXJ0KGNoYXIgKmNvbW1hbmQpCit7CisJYXRoNzlfZGV2aWNlX3Jlc2V0X3NldChBUjcxWFhfUkVTRVRfRlVMTF9DSElQKTsKKwlmb3IgKDs7KQorCQlpZiAoY3B1X3dhaXQpCisJCQljcHVfd2FpdCgpOworfQorCitzdGF0aWMgdm9pZCBhdGg3OV9oYWx0KHZvaWQpCit7CisJd2hpbGUgKDEpCisJCWNwdV93YWl0KCk7Cit9CisKK3N0YXRpYyB2b2lkIF9faW5pdCBhdGg3OV9kZXRlY3RfbWVtX3NpemUodm9pZCkKK3sKKwl1bnNpZ25lZCBsb25nIHNpemU7CisKKwlmb3IgKHNpemUgPSBBVEg3OV9NRU1fU0laRV9NSU47IHNpemUgPCBBVEg3OV9NRU1fU0laRV9NQVg7CisJICAgICBzaXplIDw8PSAxKSB7CisJCWlmICghbWVtY21wKGF0aDc5X2RldGVjdF9tZW1fc2l6ZSwKKwkJCSAgICBhdGg3OV9kZXRlY3RfbWVtX3NpemUgKyBzaXplLCAxMDI0KSkKKwkJCWJyZWFrOworCX0KKworCWFkZF9tZW1vcnlfcmVnaW9uKDAsIHNpemUsIEJPT1RfTUVNX1JBTSk7Cit9CisKK3N0YXRpYyB2b2lkIF9faW5pdCBhdGg3OV9kZXRlY3Rfc3lzX3R5cGUodm9pZCkKK3sKKwljaGFyICpjaGlwID0gIj8/Pz8iOworCXUzMiBpZDsKKwl1MzIgbWFqb3I7CisJdTMyIG1pbm9yOworCXUzMiByZXYgPSAwOworCisJaWQgPSBhdGg3OV9yZXNldF9ycihBUjcxWFhfUkVTRVRfUkVHX1JFVl9JRCk7CisJbWFqb3IgPSBpZCAmIFJFVl9JRF9NQUpPUl9NQVNLOworCisJc3dpdGNoIChtYWpvcikgeworCWNhc2UgUkVWX0lEX01BSk9SX0FSNzFYWDoKKwkJbWlub3IgPSBpZCAmIEFSNzFYWF9SRVZfSURfTUlOT1JfTUFTSzsKKwkJcmV2ID0gaWQgPj4gQVI3MVhYX1JFVl9JRF9SRVZJU0lPTl9TSElGVDsKKwkJcmV2ICY9IEFSNzFYWF9SRVZfSURfUkVWSVNJT05fTUFTSzsKKwkJc3dpdGNoIChtaW5vcikgeworCQljYXNlIEFSNzFYWF9SRVZfSURfTUlOT1JfQVI3MTMwOgorCQkJYXRoNzlfc29jID0gQVRINzlfU09DX0FSNzEzMDsKKwkJCWNoaXAgPSAiNzEzMCI7CisJCQlicmVhazsKKworCQljYXNlIEFSNzFYWF9SRVZfSURfTUlOT1JfQVI3MTQxOgorCQkJYXRoNzlfc29jID0gQVRINzlfU09DX0FSNzE0MTsKKwkJCWNoaXAgPSAiNzE0MSI7CisJCQlicmVhazsKKworCQljYXNlIEFSNzFYWF9SRVZfSURfTUlOT1JfQVI3MTYxOgorCQkJYXRoNzlfc29jID0gQVRINzlfU09DX0FSNzE2MTsKKwkJCWNoaXAgPSAiNzE2MSI7CisJCQlicmVhazsKKwkJfQorCQlicmVhazsKKworCWNhc2UgUkVWX0lEX01BSk9SX0FSNzI0MDoKKwkJYXRoNzlfc29jID0gQVRINzlfU09DX0FSNzI0MDsKKwkJY2hpcCA9ICI3MjQwIjsKKwkJcmV2ID0gKGlkICYgQVI3MjRYX1JFVl9JRF9SRVZJU0lPTl9NQVNLKTsKKwkJYnJlYWs7CisKKwljYXNlIFJFVl9JRF9NQUpPUl9BUjcyNDE6CisJCWF0aDc5X3NvYyA9IEFUSDc5X1NPQ19BUjcyNDE7CisJCWNoaXAgPSAiNzI0MSI7CisJCXJldiA9IChpZCAmIEFSNzI0WF9SRVZfSURfUkVWSVNJT05fTUFTSyk7CisJCWJyZWFrOworCisJY2FzZSBSRVZfSURfTUFKT1JfQVI3MjQyOgorCQlhdGg3OV9zb2MgPSBBVEg3OV9TT0NfQVI3MjQyOworCQljaGlwID0gIjcyNDIiOworCQlyZXYgPSAoaWQgJiBBUjcyNFhfUkVWX0lEX1JFVklTSU9OX01BU0spOworCQlicmVhazsKKworCWNhc2UgUkVWX0lEX01BSk9SX0FSOTEzWDoKKwkJbWlub3IgPSBpZCAmIEFSOTEzWF9SRVZfSURfTUlOT1JfTUFTSzsKKwkJcmV2ID0gaWQgPj4gQVI5MTNYX1JFVl9JRF9SRVZJU0lPTl9TSElGVDsKKwkJcmV2ICY9IEFSOTEzWF9SRVZfSURfUkVWSVNJT05fTUFTSzsKKwkJc3dpdGNoIChtaW5vcikgeworCQljYXNlIEFSOTEzWF9SRVZfSURfTUlOT1JfQVI5MTMwOgorCQkJYXRoNzlfc29jID0gQVRINzlfU09DX0FSOTEzMDsKKwkJCWNoaXAgPSAiOTEzMCI7CisJCQlicmVhazsKKworCQljYXNlIEFSOTEzWF9SRVZfSURfTUlOT1JfQVI5MTMyOgorCQkJYXRoNzlfc29jID0gQVRINzlfU09DX0FSOTEzMjsKKwkJCWNoaXAgPSAiOTEzMiI7CisJCQlicmVhazsKKwkJfQorCQlicmVhazsKKworCWRlZmF1bHQ6CisJCXBhbmljKCJhdGg3OTogdW5rbm93biBTb0MsIGlkOjB4JTA4eFxuIiwgaWQpOworCX0KKworCXNwcmludGYoYXRoNzlfc3lzX3R5cGUsICJBdGhlcm9zIEFSJXMgcmV2ICV1IiwgY2hpcCwgcmV2KTsKKwlwcl9pbmZvKCJTb0M6ICVzXG4iLCBhdGg3OV9zeXNfdHlwZSk7Cit9CisKK2NvbnN0IGNoYXIgKmdldF9zeXN0ZW1fdHlwZSh2b2lkKQoreworCXJldHVybiBhdGg3OV9zeXNfdHlwZTsKK30KKwordW5zaWduZWQgaW50IF9fY3B1aW5pdCBnZXRfYzBfY29tcGFyZV9pbnQodm9pZCkKK3sKKwlyZXR1cm4gQ1AwX0xFR0FDWV9DT01QQVJFX0lSUTsKK30KKwordm9pZCBfX2luaXQgcGxhdF9tZW1fc2V0dXAodm9pZCkKK3sKKwlzZXRfaW9fcG9ydF9iYXNlKEtTRUcxKTsKKworCWF0aDc5X3Jlc2V0X2Jhc2UgPSBpb3JlbWFwX25vY2FjaGUoQVI3MVhYX1JFU0VUX0JBU0UsCisJCQkJCSAgIEFSNzFYWF9SRVNFVF9TSVpFKTsKKwlhdGg3OV9wbGxfYmFzZSA9IGlvcmVtYXBfbm9jYWNoZShBUjcxWFhfUExMX0JBU0UsCisJCQkJCSBBUjcxWFhfUExMX1NJWkUpOworCWF0aDc5X2Rkcl9iYXNlID0gaW9yZW1hcF9ub2NhY2hlKEFSNzFYWF9ERFJfQ1RSTF9CQVNFLAorCQkJCQkgQVI3MVhYX0REUl9DVFJMX1NJWkUpOworCisJYXRoNzlfZGV0ZWN0X3N5c190eXBlKCk7CisJYXRoNzlfZGV0ZWN0X21lbV9zaXplKCk7CisJYXRoNzlfY2xvY2tzX2luaXQoKTsKKworCV9tYWNoaW5lX3Jlc3RhcnQgPSBhdGg3OV9yZXN0YXJ0OworCV9tYWNoaW5lX2hhbHQgPSBhdGg3OV9oYWx0OworCXBtX3Bvd2VyX29mZiA9IGF0aDc5X2hhbHQ7Cit9CisKK3ZvaWQgX19pbml0IHBsYXRfdGltZV9pbml0KHZvaWQpCit7CisJc3RydWN0IGNsayAqY2xrOworCisJY2xrID0gY2xrX2dldChOVUxMLCAiY3B1Iik7CisJaWYgKElTX0VSUihjbGspKQorCQlwYW5pYygidW5hYmxlIHRvIGdldCBDUFUgY2xvY2ssIGVycj0lbGQiLCBQVFJfRVJSKGNsaykpOworCisJbWlwc19ocHRfZnJlcXVlbmN5ID0gY2xrX2dldF9yYXRlKGNsaykgLyAyOworfQorCitzdGF0aWMgaW50IF9faW5pdCBhdGg3OV9zZXR1cCh2b2lkKQoreworCWF0aDc5X2dwaW9faW5pdCgpOworCWF0aDc5X3JlZ2lzdGVyX3VhcnQoKTsKKwlhdGg3OV9yZWdpc3Rlcl93ZHQoKTsKKworCW1pcHNfbWFjaGluZV9zZXR1cCgpOworCisJcmV0dXJuIDA7Cit9CisKK2FyY2hfaW5pdGNhbGwoYXRoNzlfc2V0dXApOworCitzdGF0aWMgdm9pZCBfX2luaXQgYXRoNzlfZ2VuZXJpY19pbml0KHZvaWQpCit7CisJLyogTm90aGluZyB0byBkbyAqLworfQorCitNSVBTX01BQ0hJTkUoQVRINzlfTUFDSF9HRU5FUklDLAorCSAgICAgIkdlbmVyaWMiLAorCSAgICAgIkdlbmVyaWMgQVI3MVhYL0FSNzI0WC9BUjkxM1ggYmFzZWQgYm9hcmQiLAorCSAgICAgYXRoNzlfZ2VuZXJpY19pbml0KTsKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jb25maWdzL2FyN19kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9hcjdfZGVmY29uZmlnCmluZGV4IGM3OGM3ZTcuLjZjZDVhNTEgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jb25maWdzL2FyN19kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3MvYXI3X2RlZmNvbmZpZwpAQCAtMTQsNyArMTQsNyBAQAogQ09ORklHX1JFTEFZPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiBDT05GSUdfUkRfTFpNQT15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19FTEZfQ09SRSBpcyBub3Qgc2V0CiAjIENPTkZJR19QQ1NQS1JfUExBVEZPUk0gaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvYmNtNDd4eF9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9iY200N3h4X2RlZmNvbmZpZwppbmRleCA5MjdkNThiLi4yMmZkZjJmIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9iY200N3h4X2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9iY200N3h4X2RlZmNvbmZpZwpAQCAtMjEsNyArMjEsNyBAQAogQ09ORklHX1JFTEFZPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiBDT05GSUdfUkRfTFpNQT15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9iY202M3h4X2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL2JjbTYzeHhfZGVmY29uZmlnCmluZGV4IGI4MDZhNGUuLjkxOTAwNTEgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jb25maWdzL2JjbTYzeHhfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL2JjbTYzeHhfZGVmY29uZmlnCkBAIC0xMCw3ICsxMCw3IEBACiAjIENPTkZJR19TV0FQIGlzIG5vdCBzZXQKIENPTkZJR19USU5ZX1JDVT15CiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19QQ1NQS1JfUExBVEZPUk0gaXMgbm90IHNldAogIyBDT05GSUdfRlVURVggaXMgbm90IHNldAogIyBDT05GSUdfRVBPTEwgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvYmlnc3VyX2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL2JpZ3N1cl9kZWZjb25maWcKaW5kZXggOTc0OWJjOC4uMWNkZmY2YiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvYmlnc3VyX2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9iaWdzdXJfZGVmY29uZmlnCkBAIC0yNiw3ICsyNiw3IEBACiBDT05GSUdfTkVUX05TPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19QQ1NQS1JfUExBVEZPUk0gaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvY2FwY2VsbGFfZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3MvY2FwY2VsbGFfZGVmY29uZmlnCmluZGV4IDUwMmE4ZTkuLjUxMzVkYzAgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jb25maWdzL2NhcGNlbGxhX2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9jYXBjZWxsYV9kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvY2F2aXVtLW9jdGVvbl9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9jYXZpdW0tb2N0ZW9uX2RlZmNvbmZpZwppbmRleCAzNTY3YjZmLi43NTE2NWRmIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9jYXZpdW0tb2N0ZW9uX2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9jYXZpdW0tb2N0ZW9uX2RlZmNvbmZpZwpAQCAtMTUsNyArMTUsNyBAQAogQ09ORklHX1JFTEFZPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19QQ1NQS1JfUExBVEZPUk0gaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvY29iYWx0X2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL2NvYmFsdF9kZWZjb25maWcKaW5kZXggNmM0ZjdlOS4uNTQxOWFkYiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvY29iYWx0X2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9jb2JhbHRfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19SRUxBWT15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CiAjIENPTkZJR19CTEtfREVWX0JTRyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9kYjEwMDBfZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3MvZGIxMDAwX2RlZmNvbmZpZwppbmRleCBkZGExNThiLi40MDQ0YzllIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9kYjEwMDBfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL2RiMTAwMF9kZWZjb25maWcKQEAgLTExLDcgKzExLDcgQEAKIENPTkZJR19USU5ZX1JDVT15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfUENTUEtSX1BMQVRGT1JNIGlzIG5vdCBzZXQKICMgQ09ORklHX1ZNX0VWRU5UX0NPVU5URVJTIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jb25maWdzL2RiMTEwMF9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9kYjExMDBfZGVmY29uZmlnCmluZGV4IDdlNGZjNzYuLmM2YjQ5OTMgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jb25maWdzL2RiMTEwMF9kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3MvZGIxMTAwX2RlZmNvbmZpZwpAQCAtMTEsNyArMTEsNyBAQAogQ09ORklHX1BPU0lYX01RVUVVRT15CiBDT05GSUdfVElOWV9SQ1U9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX1BDU1BLUl9QTEFURk9STSBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9kYjEyMDBfZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3MvZGIxMjAwX2RlZmNvbmZpZwppbmRleCA2ZmUyMDVmLi4xZjY5MjQ5IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9kYjEyMDBfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL2RiMTIwMF9kZWZjb25maWcKQEAgLTEyLDcgKzEyLDcgQEAKIENPTkZJR19QT1NJWF9NUVVFVUU9eQogQ09ORklHX1RJTllfUkNVPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19QQ1NQS1JfUExBVEZPUk0gaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvZGIxNTAwX2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL2RiMTUwMF9kZWZjb25maWcKaW5kZXggYTc0MWM1NTQuLmI2ZTIxYzcgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jb25maWdzL2RiMTUwMF9kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3MvZGIxNTAwX2RlZmNvbmZpZwpAQCAtMTAsNyArMTAsNyBAQAogQ09ORklHX0tFUk5FTF9MWk1BPXkKIENPTkZJR19TWVNWSVBDPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19QQ1NQS1JfUExBVEZPUk0gaXMgbm90IHNldAogIyBDT05GSUdfVk1fRVZFTlRfQ09VTlRFUlMgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvZGIxNTUwX2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL2RiMTU1MF9kZWZjb25maWcKaW5kZXggY2QzMmRkOC4uNzk4YTU1MyAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvZGIxNTUwX2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9kYjE1NTBfZGVmY29uZmlnCkBAIC0xMSw3ICsxMSw3IEBACiBDT05GSUdfUE9TSVhfTVFVRVVFPXkKIENPTkZJR19USU5ZX1JDVT15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfUENTUEtSX1BMQVRGT1JNIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jb25maWdzL2RlY3N0YXRpb25fZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3MvZGVjc3RhdGlvbl9kZWZjb25maWcKaW5kZXggYjE1YmZkMS4uODdkMDM0MCAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvZGVjc3RhdGlvbl9kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3MvZGVjc3RhdGlvbl9kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfSE9UUExVRyBpcyBub3Qgc2V0CiBDT05GSUdfU0xBQj15CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9lNTVfZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3MvZTU1X2RlZmNvbmZpZwppbmRleCAwYjYwYzA2Li4wMTI2ZTY2IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9lNTVfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL2U1NV9kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfSE9UUExVRyBpcyBub3Qgc2V0CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9mdWxvb25nMmVfZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3MvZnVsb29uZzJlX2RlZmNvbmZpZwppbmRleCA2Mzk0NGExLi5lNWI3M2RlIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9mdWxvb25nMmVfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL2Z1bG9vbmcyZV9kZWZjb25maWcKQEAgLTE3LDcgKzE3LDcgQEAKIENPTkZJR19VU0VSX05TPXkKIENPTkZJR19QSURfTlM9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfUENTUEtSX1BMQVRGT1JNIGlzIG5vdCBzZXQKICMgQ09ORklHX0NPTVBBVF9CUksgaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvZ3ByX2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL2dwcl9kZWZjb25maWcKaW5kZXggNTNlZGMxMy4uNDhhNDBhZSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvZ3ByX2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9ncHJfZGVmY29uZmlnCkBAIC0xMSw3ICsxMSw3IEBACiBDT05GSUdfUkVMQVk9eQogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19TTEFCPXkKIENPTkZJR19QUk9GSUxJTkc9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvaXAyMl9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9pcDIyX2RlZmNvbmZpZwppbmRleCAzNmRlMTk5Li5kMTYwNjU2IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9pcDIyX2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9pcDIyX2RlZmNvbmZpZwpAQCAtMTcsNyArMTcsNyBAQAogQ09ORklHX1VTRVJfTlM9eQogQ09ORklHX1BJRF9OUz15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX1BDU1BLUl9QTEFURk9STSBpcyBub3Qgc2V0CiAjIENPTkZJR19DT01QQVRfQlJLIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jb25maWdzL2lwMjdfZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3MvaXAyN19kZWZjb25maWcKaW5kZXggNGIxNmM0OC4uMGUzNmFiYyAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvaXAyN19kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3MvaXAyN19kZWZjb25maWcKQEAgLTE1LDcgKzE1LDcgQEAKIENPTkZJR19DUFVTRVRTPXkKIENPTkZJR19SRUxBWT15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19QQ1NQS1JfUExBVEZPUk0gaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvaXAyOF9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9pcDI4X2RlZmNvbmZpZwppbmRleCA5OGYyYzc3Li40ZGJmNjI2IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9pcDI4X2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9pcDI4X2RlZmNvbmZpZwpAQCAtOCw3ICs4LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfUkVMQVk9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfSE9UUExVRyBpcyBub3Qgc2V0CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9pcDMyX2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL2lwMzJfZGVmY29uZmlnCmluZGV4IDViZWE5OWIuLjdiYmQ1MjEgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jb25maWdzL2lwMzJfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL2lwMzJfZGVmY29uZmlnCkBAIC0xMCw3ICsxMCw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQogQ09ORklHX1JFTEFZPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19TTEFCPXkKIENPTkZJR19QUk9GSUxJTkc9eQogQ09ORklHX09QUk9GSUxFPW0KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jb25maWdzL2phenpfZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3MvamF6el9kZWZjb25maWcKaW5kZXggNmFlNDZiYy4uOTJhNjBhZSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvamF6el9kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3MvamF6el9kZWZjb25maWcKQEAgLTEwLDcgKzEwLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfUkVMQVk9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3Mvam1yMzkyN19kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9qbXIzOTI3X2RlZmNvbmZpZwppbmRleCBiZjI0ZTkzLi5kYjU3MDVlIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9qbXIzOTI3X2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9qbXIzOTI3X2RlZmNvbmZpZwpAQCAtNCw3ICs0LDcgQEAKIENPTkZJR19TWVNWSVBDPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX1BDU1BLUl9QTEFURk9STSBpcyBub3Qgc2V0CiBDT05GSUdfU0xBQj15CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9sYXNhdF9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9sYXNhdF9kZWZjb25maWcKaW5kZXggNjQ0NzI2MS4uZDlmM2RiMiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvbGFzYXRfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL2xhc2F0X2RlZmNvbmZpZwpAQCAtOCw3ICs4LDcgQEAKIENPTkZJR19FWFBFUklNRU5UQUw9eQogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX0hPVFBMVUcgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvbGVtb3RlMmZfZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3MvbGVtb3RlMmZfZGVmY29uZmlnCmluZGV4IGY3MDMzZjMuLjE2N2MxZDAgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jb25maWdzL2xlbW90ZTJmX2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9sZW1vdGUyZl9kZWZjb25maWcKQEAgLTIxLDcgKzIxLDcgQEAKIENPTkZJR19SRF9CWklQMj15CiBDT05GSUdfUkRfTFpNQT15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfUFJPRklMSU5HPXkKIENPTkZJR19PUFJPRklMRT1tCiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9tYWx0YV9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9tYWx0YV9kZWZjb25maWcKaW5kZXggYjQ1NWQwZi4uNzI3MGYzMSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvbWFsdGFfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL21hbHRhX2RlZmNvbmZpZwpAQCAtMTUsNyArMTUsNyBAQAogQ09ORklHX0lQQ19OUz15CiBDT05GSUdfUElEX05TPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0NPTVBBVF9CUksgaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQpAQCAtMzY5LDcgKzM2OSwxMCBAQAogQ09ORklHX1NFUklBTF84MjUwPXkKIENPTkZJR19TRVJJQUxfODI1MF9DT05TT0xFPXkKICMgQ09ORklHX0hXTU9OIGlzIG5vdCBzZXQKK0NPTkZJR19GQj15CitDT05GSUdfRkJfQ0lSUlVTPXkKICMgQ09ORklHX1ZHQV9DT05TT0xFIGlzIG5vdCBzZXQKK0NPTkZJR19GUkFNRUJVRkZFUl9DT05TT0xFPXkKIENPTkZJR19ISUQ9bQogQ09ORklHX0xFRFNfQ0xBU1M9bQogQ09ORklHX0xFRFNfVFJJR0dFUl9USU1FUj1tCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9tYXJrZWluc19kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9tYXJrZWluc19kZWZjb25maWcKaW5kZXggODZiZjAwMS4uOWM5YTEyMyAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvbWFya2VpbnNfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL21hcmtlaW5zX2RlZmNvbmZpZwpAQCAtOSw3ICs5LDcgQEAKIENPTkZJR19JS0NPTkZJR19QUk9DPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9taXBzc2ltX2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL21pcHNzaW1fZGVmY29uZmlnCmluZGV4IDQ5MjVmNTAuLmI1YWQ3MzggMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jb25maWdzL21pcHNzaW1fZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL21pcHNzaW1fZGVmY29uZmlnCkBAIC03LDcgKzcsNyBAQAogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19TTEFCPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jb25maWdzL21wYzMweF9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9tcGMzMHhfZGVmY29uZmlnCmluZGV4IGVmYjc3OWYuLmMxNmRlOTggMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jb25maWdzL21wYzMweF9kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3MvbXBjMzB4X2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfUkVMQVk9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvbXNwNzF4eF9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9tc3A3MXh4X2RlZmNvbmZpZwppbmRleCBhYjA1MTQ1Li5kMTE0MmU5IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9tc3A3MXh4X2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9tc3A3MXh4X2RlZmNvbmZpZwpAQCAtOCw3ICs4LDcgQEAKIENPTkZJR19TWVNWSVBDPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TSE1FTSBpcyBub3Qgc2V0CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9tdHgxX2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL210eDFfZGVmY29uZmlnCmluZGV4IDgxNDY5OTc1Li5hOTdhNDJjNiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvbXR4MV9kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3MvbXR4MV9kZWZjb25maWcKQEAgLTExLDcgKzExLDcgQEAKIENPTkZJR19SRUxBWT15CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NMQUI9eQogQ09ORklHX1BST0ZJTElORz15CiBDT05GSUdfT1BST0ZJTEU9bQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvcGIxMTAwX2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL3BiMTEwMF9kZWZjb25maWcKaW5kZXggMTU5N2FhMS4uNzVlYjFiMSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvcGIxMTAwX2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9wYjExMDBfZGVmY29uZmlnCkBAIC0xMSw3ICsxMSw3IEBACiBDT05GSUdfUE9TSVhfTVFVRVVFPXkKIENPTkZJR19USU5ZX1JDVT15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfUENTUEtSX1BMQVRGT1JNIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jb25maWdzL3BiMTIwMF9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9wYjEyMDBfZGVmY29uZmlnCmluZGV4IDk2ZjBkNDMuLmRjYmUyNzAgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jb25maWdzL3BiMTIwMF9kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3MvcGIxMjAwX2RlZmNvbmZpZwpAQCAtMTIsNyArMTIsNyBAQAogQ09ORklHX1BPU0lYX01RVUVVRT15CiBDT05GSUdfVElOWV9SQ1U9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX1BDU1BLUl9QTEFURk9STSBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9wYjE1MDBfZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3MvcGIxNTAwX2RlZmNvbmZpZwppbmRleCBiNGJmZDQ4Li5mYTAwNDg3IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9wYjE1MDBfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL3BiMTUwMF9kZWZjb25maWcKQEAgLTExLDcgKzExLDcgQEAKIENPTkZJR19QT1NJWF9NUVVFVUU9eQogQ09ORklHX1RJTllfUkNVPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19QQ1NQS1JfUExBVEZPUk0gaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvcGIxNTUwX2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL3BiMTU1MF9kZWZjb25maWcKaW5kZXggNWE2NjAwMi4uZTgzZDY0OSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvcGIxNTUwX2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9wYjE1NTBfZGVmY29uZmlnCkBAIC0xMSw3ICsxMSw3IEBACiBDT05GSUdfUE9TSVhfTVFVRVVFPXkKIENPTkZJR19USU5ZX1JDVT15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfUENTUEtSX1BMQVRGT1JNIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jb25maWdzL3BueDgzMzUtc3RiMjI1X2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL3BueDgzMzUtc3RiMjI1X2RlZmNvbmZpZwppbmRleCAzOTkyNmExLi5mMjkyNTc2IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9wbng4MzM1LXN0YjIyNV9kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3MvcG54ODMzNS1zdGIyMjVfZGVmY29uZmlnCkBAIC0xMSw3ICsxMSw3IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvcG54ODU1MC1qYnNfZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3MvcG54ODU1MC1qYnNfZGVmY29uZmlnCmluZGV4IDMzNzZiYzguLjFkMWYyMDYgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jb25maWdzL3BueDg1NTAtamJzX2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy9wbng4NTUwLWpic19kZWZjb25maWcKQEAgLTYsNyArNiw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKIENPTkZJR19TTEFCPXkKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jb25maWdzL3BueDg1NTAtc3RiODEwX2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL3BueDg1NTAtc3RiODEwX2RlZmNvbmZpZwppbmRleCA2NTE0ZjFiLi4xNWM2NmE1IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9wbng4NTUwLXN0YjgxMF9kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3MvcG54ODU1MC1zdGI4MTBfZGVmY29uZmlnCkBAIC02LDcgKzYsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKIENPTkZJR19TTEFCPXkKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jb25maWdzL3Bvd2VydHZfZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3MvcG93ZXJ0dl9kZWZjb25maWcKaW5kZXggZjFmNThlOTEuLjNiMGI2ZTggMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jb25maWdzL3Bvd2VydHZfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL3Bvd2VydHZfZGVmY29uZmlnCkBAIC0xNCw3ICsxNCw3IEBACiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfUkRfR1pJUCBpcyBub3Qgc2V0CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiBDT05GSUdfS0FMTFNZTVNfQUxMPXkKICMgQ09ORklHX1BDU1BLUl9QTEFURk9STSBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9yYjUzMl9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9yYjUzMl9kZWZjb25maWcKaW5kZXggZDY0NTdiYy4uNTU5MDJkOSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvcmI1MzJfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL3JiNTMyX2RlZmNvbmZpZwpAQCAtMTMsNyArMTMsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19FTEZfQ09SRSBpcyBub3Qgc2V0CiAjIENPTkZJR19WTV9FVkVOVF9DT1VOVEVSUyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9yYnR4NDl4eF9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9yYnR4NDl4eF9kZWZjb25maWcKaW5kZXggMjlhY2ZhYi4uOWNiYTg1NiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvcmJ0eDQ5eHhfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL3JidHg0OXh4X2RlZmNvbmZpZwpAQCAtMTIsNyArMTIsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX1BDU1BLUl9QTEFURk9STSBpcyBub3Qgc2V0CiAjIENPTkZJR19FUE9MTCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9ybTIwMF9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy9ybTIwMF9kZWZjb25maWcKaW5kZXggMmIzZTQ3Ni4uMmMwMjMwZSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3Mvcm0yMDBfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL3JtMjAwX2RlZmNvbmZpZwpAQCAtMTIsNyArMTIsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19SRUxBWT15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy9zYjEyNTAtc3dhcm1fZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3Mvc2IxMjUwLXN3YXJtX2RlZmNvbmZpZwppbmRleCA2NDg0MGQ3Li41YjA0NjNlIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy9zYjEyNTAtc3dhcm1fZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL3NiMTI1MC1zd2FybV9kZWZjb25maWcKQEAgLTE1LDcgKzE1LDcgQEAKIENPTkZJR19OQU1FU1BBQ0VTPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19DT01QQVRfQlJLIGlzIG5vdCBzZXQKIENPTkZJR19TTEFCPXkKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jb25maWdzL3RiMDIxOV9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy90YjAyMTlfZGVmY29uZmlnCmluZGV4IGQ5YmUzN2YuLjMwMDM2YjQgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9jb25maWdzL3RiMDIxOV9kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3MvdGIwMjE5X2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19QQ1NQS1JfUExBVEZPUk0gaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3MvdGIwMjI2X2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL3RiMDIyNl9kZWZjb25maWcKaW5kZXggM2QyNWRkMC4uODFiZmExZCAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MvdGIwMjI2X2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy90YjAyMjZfZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1BDU1BLUl9QTEFURk9STSBpcyBub3Qgc2V0CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy90YjAyODdfZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3MvdGIwMjg3X2RlZmNvbmZpZwppbmRleCBiZTY5N2M5Li5jNDE1YzRmIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvY29uZmlncy90YjAyODdfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL3RiMDI4N19kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfUENTUEtSX1BMQVRGT1JNIGlzIG5vdCBzZXQKIENPTkZJR19TTEFCPXkKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9jb25maWdzL3dvcmtwYWRfZGVmY29uZmlnIGIvYXJjaC9taXBzL2NvbmZpZ3Mvd29ya3BhZF9kZWZjb25maWcKaW5kZXggN2VjOTI4Ny4uZWU0YjJiZSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3Mvd29ya3BhZF9kZWZjb25maWcKKysrIGIvYXJjaC9taXBzL2NvbmZpZ3Mvd29ya3BhZF9kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2NvbmZpZ3Mvd3JwcG1jX2RlZmNvbmZpZyBiL2FyY2gvbWlwcy9jb25maWdzL3dycHBtY19kZWZjb25maWcKaW5kZXggYTIzMWI3My4uNDRhNDUxYiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3Mvd3JwcG1jX2RlZmNvbmZpZworKysgYi9hcmNoL21pcHMvY29uZmlncy93cnBwbWNfZGVmY29uZmlnCkBAIC03LDcgKzcsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfRVhUUkFfUEFTUz15CiAjIENPTkZJR19FUE9MTCBpcyBub3Qgc2V0CiBDT05GSUdfU0xBQj15CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvY29uZmlncy95b3NlbWl0ZV9kZWZjb25maWcgYi9hcmNoL21pcHMvY29uZmlncy95b3NlbWl0ZV9kZWZjb25maWcKaW5kZXggYWIzYTNkYy4uZjcyZDMwNSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2NvbmZpZ3MveW9zZW1pdGVfZGVmY29uZmlnCisrKyBiL2FyY2gvbWlwcy9jb25maWdzL3lvc2VtaXRlX2RlZmNvbmZpZwpAQCAtOCw3ICs4LDcgQEAKIENPTkZJR19JS0NPTkZJR19QUk9DPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfUkVMQVk9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL2NhY2hlLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vY2FjaGUuaAppbmRleCAzN2YxNzVjLi42NTBhYzliIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vY2FjaGUuaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vY2FjaGUuaApAQCAtMTcsNCArMTcsNiBAQAogI2RlZmluZSBTTVBfQ0FDSEVfU0hJRlQJCUwxX0NBQ0hFX1NISUZUCiAjZGVmaW5lIFNNUF9DQUNIRV9CWVRFUwkJTDFfQ0FDSEVfQllURVMKIAorI2RlZmluZSBfX3JlYWRfbW9zdGx5IF9fYXR0cmlidXRlX18oKF9fc2VjdGlvbl9fKCIuZGF0YS5yZWFkX21vc3RseSIpKSkKKwogI2VuZGlmIC8qIF9BU01fQ0FDSEVfSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL2NwdS1pbmZvLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vY3B1LWluZm8uaAppbmRleCBiMzlkZWYzLi5jNDU0NTUwIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vY3B1LWluZm8uaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vY3B1LWluZm8uaApAQCAtNzgsNiArNzgsNyBAQAogCXVuc2lnbmVkIGludAkJd2F0Y2hfcmVnX3VzZV9jbnQ7IC8qIFVzYWJsZSBieSBwdHJhY2UgKi8KICNkZWZpbmUgTlVNX1dBVENIX1JFR1MgNAogCXUxNgkJCXdhdGNoX3JlZ19tYXNrc1tOVU1fV0FUQ0hfUkVHU107CisJdW5zaWduZWQgaW50CQlrc2NyYXRjaF9tYXNrOyAvKiBVc2FibGUgS1NjcmF0Y2ggbWFzay4gKi8KIH0gX19hdHRyaWJ1dGVfXygoYWxpZ25lZChTTVBfQ0FDSEVfQllURVMpKSk7CiAKIGV4dGVybiBzdHJ1Y3QgY3B1aW5mb19taXBzIGNwdV9kYXRhW107CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vaW5zdC5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL2luc3QuaAppbmRleCA0NDRmZjcxLi43ZWJmYzM5IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vaW5zdC5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9pbnN0LmgKQEAgLTcyLDYgKzcyLDcgQEAKIGVudW0gc3BlYzNfb3AgewogCWV4dF9vcCwgZGV4dG1fb3AsIGRleHR1X29wLCBkZXh0X29wLAogCWluc19vcCwgZGluc21fb3AsIGRpbnN1X29wLCBkaW5zX29wLAorCWx4X29wID0gMHgwYSwKIAlic2hmbF9vcCA9IDB4MjAsCiAJZGJzaGZsX29wID0gMHgyNCwKIAlyZGh3cl9vcCA9IDB4M2IKQEAgLTE3OSw2ICsxODAsMTkgQEAKIH07CiAKIC8qCisgKiBmdW5jIGZpZWxkIGZvciBzcGVjaWFsMyBseCBvcGNvZGVzIChDYXZpdW0gT2N0ZW9uKS4KKyAqLworZW51bSBseF9mdW5jIHsKKwlsd3hfb3AJPSAweDAwLAorCWxoeF9vcAk9IDB4MDQsCisJbGJ1eF9vcAk9IDB4MDYsCisJbGR4X29wCT0gMHgwOCwKKwlsd3V4X29wCT0gMHgxMCwKKwlsaHV4X29wCT0gMHgxNCwKKwlsYnhfb3AJPSAweDE2LAorfTsKKworLyoKICAqIERhbW4gLi4uICBiaXRmaWVsZHMgZGVwZW5kIGZyb20gYnl0ZW9yZGVyIDotKAogICovCiAjaWZkZWYgX19NSVBTRUJfXwpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL2p1bXBfbGFiZWwuaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9qdW1wX2xhYmVsLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzYyMmNjZgotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9qdW1wX2xhYmVsLmgKQEAgLTAsMCArMSw0OCBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlLiAgU2VlIHRoZSBmaWxlICJDT1BZSU5HIiBpbiB0aGUgbWFpbiBkaXJlY3Rvcnkgb2YgdGhpcyBhcmNoaXZlCisgKiBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIENvcHlyaWdodCAoYykgMjAxMCBDYXZpdW0gTmV0d29ya3MsIEluYy4KKyAqLworI2lmbmRlZiBfQVNNX01JUFNfSlVNUF9MQUJFTF9ICisjZGVmaW5lIF9BU01fTUlQU19KVU1QX0xBQkVMX0gKKworI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisKKyNpZmRlZiBfX0tFUk5FTF9fCisKKyNkZWZpbmUgSlVNUF9MQUJFTF9OT1BfU0laRSA0CisKKyNpZmRlZiBDT05GSUdfNjRCSVQKKyNkZWZpbmUgV09SRF9JTlNOICIuZHdvcmQiCisjZWxzZQorI2RlZmluZSBXT1JEX0lOU04gIi53b3JkIgorI2VuZGlmCisKKyNkZWZpbmUgSlVNUF9MQUJFTChrZXksIGxhYmVsKQkJCQkJCVwKKwlkbyB7CQkJCQkJCQlcCisJCWFzbSBnb3RvKCIxOlx0bm9wXG5cdCIJCQkJCVwKKwkJCSJub3Bcblx0IgkJCQkJXAorCQkJIi5wdXNoc2VjdGlvbiBfX2p1bXBfdGFibGUsICBcImFcIlxuXHQiCQlcCisJCQlXT1JEX0lOU04gIiAxYiwgJWxbIiAjbGFiZWwgIl0sICUwXG5cdCIJCVwKKwkJCSIucG9wc2VjdGlvblxuXHQiCQkJCVwKKwkJCTogOiAgImkiIChrZXkpIDogIDogbGFiZWwpOwkJCVwKKwl9IHdoaWxlICgwKQorCisKKyNlbmRpZiAvKiBfX0tFUk5FTF9fICovCisKKyNpZmRlZiBDT05GSUdfNjRCSVQKK3R5cGVkZWYgdTY0IGp1bXBfbGFiZWxfdDsKKyNlbHNlCit0eXBlZGVmIHUzMiBqdW1wX2xhYmVsX3Q7CisjZW5kaWYKKworc3RydWN0IGp1bXBfZW50cnkgeworCWp1bXBfbGFiZWxfdCBjb2RlOworCWp1bXBfbGFiZWxfdCB0YXJnZXQ7CisJanVtcF9sYWJlbF90IGtleTsKK307CisKKyNlbmRpZiAvKiBfQVNNX01JUFNfSlVNUF9MQUJFTF9IICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1hdGg3OS9hcjcxeHhfcmVncy5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtYXRoNzkvYXI3MXh4X3JlZ3MuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jZGExYzgwCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtYXRoNzkvYXI3MXh4X3JlZ3MuaApAQCAtMCwwICsxLDIzMyBAQAorLyoKKyAqICBBdGhlcm9zIEFSNzFYWC9BUjcyNFgvQVI5MTNYIFNvQyByZWdpc3RlciBkZWZpbml0aW9ucworICoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDgtMjAxMCBHYWJvciBKdWhvcyA8anVob3NnQG9wZW53cnQub3JnPgorICogIENvcHlyaWdodCAoQykgMjAwOCBJbXJlIEthbG96IDxrYWxvekBvcGVud3J0Lm9yZz4KKyAqCisgKiAgUGFydHMgb2YgdGhpcyBmaWxlIGFyZSBiYXNlZCBvbiBBdGhlcm9zJyAyLjYuMTUgQlNQCisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkCisgKiAgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqLworCisjaWZuZGVmIF9fQVNNX01BQ0hfQVI3MVhYX1JFR1NfSAorI2RlZmluZSBfX0FTTV9NQUNIX0FSNzFYWF9SRUdTX0gKKworI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L2lvLmg+CisjaW5jbHVkZSA8bGludXgvYml0b3BzLmg+CisKKyNkZWZpbmUgQVI3MVhYX0FQQl9CQVNFCQkweDE4MDAwMDAwCisjZGVmaW5lIEFSNzFYWF9TUElfQkFTRQkJMHgxZjAwMDAwMAorI2RlZmluZSBBUjcxWFhfU1BJX1NJWkUJCTB4MDEwMDAwMDAKKworI2RlZmluZSBBUjcxWFhfRERSX0NUUkxfQkFTRQkoQVI3MVhYX0FQQl9CQVNFICsgMHgwMDAwMDAwMCkKKyNkZWZpbmUgQVI3MVhYX0REUl9DVFJMX1NJWkUJMHgxMDAKKyNkZWZpbmUgQVI3MVhYX1VBUlRfQkFTRQkoQVI3MVhYX0FQQl9CQVNFICsgMHgwMDAyMDAwMCkKKyNkZWZpbmUgQVI3MVhYX1VBUlRfU0laRQkweDEwMAorI2RlZmluZSBBUjcxWFhfR1BJT19CQVNFICAgICAgICAoQVI3MVhYX0FQQl9CQVNFICsgMHgwMDA0MDAwMCkKKyNkZWZpbmUgQVI3MVhYX0dQSU9fU0laRSAgICAgICAgMHgxMDAKKyNkZWZpbmUgQVI3MVhYX1BMTF9CQVNFCQkoQVI3MVhYX0FQQl9CQVNFICsgMHgwMDA1MDAwMCkKKyNkZWZpbmUgQVI3MVhYX1BMTF9TSVpFCQkweDEwMAorI2RlZmluZSBBUjcxWFhfUkVTRVRfQkFTRQkoQVI3MVhYX0FQQl9CQVNFICsgMHgwMDA2MDAwMCkKKyNkZWZpbmUgQVI3MVhYX1JFU0VUX1NJWkUJMHgxMDAKKworI2RlZmluZSBBUjkxM1hfV01BQ19CQVNFCShBUjcxWFhfQVBCX0JBU0UgKyAweDAwMEMwMDAwKQorI2RlZmluZSBBUjkxM1hfV01BQ19TSVpFCTB4MzAwMDAKKworLyoKKyAqIEREUl9DVFJMIGJsb2NrCisgKi8KKyNkZWZpbmUgQVI3MVhYX0REUl9SRUdfUENJX1dJTjAJCTB4N2MKKyNkZWZpbmUgQVI3MVhYX0REUl9SRUdfUENJX1dJTjEJCTB4ODAKKyNkZWZpbmUgQVI3MVhYX0REUl9SRUdfUENJX1dJTjIJCTB4ODQKKyNkZWZpbmUgQVI3MVhYX0REUl9SRUdfUENJX1dJTjMJCTB4ODgKKyNkZWZpbmUgQVI3MVhYX0REUl9SRUdfUENJX1dJTjQJCTB4OGMKKyNkZWZpbmUgQVI3MVhYX0REUl9SRUdfUENJX1dJTjUJCTB4OTAKKyNkZWZpbmUgQVI3MVhYX0REUl9SRUdfUENJX1dJTjYJCTB4OTQKKyNkZWZpbmUgQVI3MVhYX0REUl9SRUdfUENJX1dJTjcJCTB4OTgKKyNkZWZpbmUgQVI3MVhYX0REUl9SRUdfRkxVU0hfR0UwCTB4OWMKKyNkZWZpbmUgQVI3MVhYX0REUl9SRUdfRkxVU0hfR0UxCTB4YTAKKyNkZWZpbmUgQVI3MVhYX0REUl9SRUdfRkxVU0hfVVNCCTB4YTQKKyNkZWZpbmUgQVI3MVhYX0REUl9SRUdfRkxVU0hfUENJCTB4YTgKKworI2RlZmluZSBBUjcyNFhfRERSX1JFR19GTFVTSF9HRTAJMHg3YworI2RlZmluZSBBUjcyNFhfRERSX1JFR19GTFVTSF9HRTEJMHg4MAorI2RlZmluZSBBUjcyNFhfRERSX1JFR19GTFVTSF9VU0IJMHg4NAorI2RlZmluZSBBUjcyNFhfRERSX1JFR19GTFVTSF9QQ0lFCTB4ODgKKworI2RlZmluZSBBUjkxM1hfRERSX1JFR19GTFVTSF9HRTAJMHg3YworI2RlZmluZSBBUjkxM1hfRERSX1JFR19GTFVTSF9HRTEJMHg4MAorI2RlZmluZSBBUjkxM1hfRERSX1JFR19GTFVTSF9VU0IJMHg4NAorI2RlZmluZSBBUjkxM1hfRERSX1JFR19GTFVTSF9XTUFDCTB4ODgKKworLyoKKyAqIFBMTCBibG9jaworICovCisjZGVmaW5lIEFSNzFYWF9QTExfUkVHX0NQVV9DT05GSUcJMHgwMAorI2RlZmluZSBBUjcxWFhfUExMX1JFR19TRUNfQ09ORklHCTB4MDQKKyNkZWZpbmUgQVI3MVhYX1BMTF9SRUdfRVRIMF9JTlRfQ0xPQ0sJMHgxMAorI2RlZmluZSBBUjcxWFhfUExMX1JFR19FVEgxX0lOVF9DTE9DSwkweDE0CisKKyNkZWZpbmUgQVI3MVhYX1BMTF9ESVZfU0hJRlQJCTMKKyNkZWZpbmUgQVI3MVhYX1BMTF9ESVZfTUFTSwkJMHgxZgorI2RlZmluZSBBUjcxWFhfQ1BVX0RJVl9TSElGVAkJMTYKKyNkZWZpbmUgQVI3MVhYX0NQVV9ESVZfTUFTSwkJMHgzCisjZGVmaW5lIEFSNzFYWF9ERFJfRElWX1NISUZUCQkxOAorI2RlZmluZSBBUjcxWFhfRERSX0RJVl9NQVNLCQkweDMKKyNkZWZpbmUgQVI3MVhYX0FIQl9ESVZfU0hJRlQJCTIwCisjZGVmaW5lIEFSNzFYWF9BSEJfRElWX01BU0sJCTB4NworCisjZGVmaW5lIEFSNzI0WF9QTExfUkVHX0NQVV9DT05GSUcJMHgwMAorI2RlZmluZSBBUjcyNFhfUExMX1JFR19QQ0lFX0NPTkZJRwkweDE4CisKKyNkZWZpbmUgQVI3MjRYX1BMTF9ESVZfU0hJRlQJCTAKKyNkZWZpbmUgQVI3MjRYX1BMTF9ESVZfTUFTSwkJMHgzZmYKKyNkZWZpbmUgQVI3MjRYX1BMTF9SRUZfRElWX1NISUZUCTEwCisjZGVmaW5lIEFSNzI0WF9QTExfUkVGX0RJVl9NQVNLCQkweGYKKyNkZWZpbmUgQVI3MjRYX0FIQl9ESVZfU0hJRlQJCTE5CisjZGVmaW5lIEFSNzI0WF9BSEJfRElWX01BU0sJCTB4MQorI2RlZmluZSBBUjcyNFhfRERSX0RJVl9TSElGVAkJMjIKKyNkZWZpbmUgQVI3MjRYX0REUl9ESVZfTUFTSwkJMHgzCisKKyNkZWZpbmUgQVI5MTNYX1BMTF9SRUdfQ1BVX0NPTkZJRwkweDAwCisjZGVmaW5lIEFSOTEzWF9QTExfUkVHX0VUSF9DT05GSUcJMHgwNAorI2RlZmluZSBBUjkxM1hfUExMX1JFR19FVEgwX0lOVF9DTE9DSwkweDE0CisjZGVmaW5lIEFSOTEzWF9QTExfUkVHX0VUSDFfSU5UX0NMT0NLCTB4MTgKKworI2RlZmluZSBBUjkxM1hfUExMX0RJVl9TSElGVAkJMAorI2RlZmluZSBBUjkxM1hfUExMX0RJVl9NQVNLCQkweDNmZgorI2RlZmluZSBBUjkxM1hfRERSX0RJVl9TSElGVAkJMjIKKyNkZWZpbmUgQVI5MTNYX0REUl9ESVZfTUFTSwkJMHgzCisjZGVmaW5lIEFSOTEzWF9BSEJfRElWX1NISUZUCQkxOQorI2RlZmluZSBBUjkxM1hfQUhCX0RJVl9NQVNLCQkweDEKKworLyoKKyAqIFJFU0VUIGJsb2NrCisgKi8KKyNkZWZpbmUgQVI3MVhYX1JFU0VUX1JFR19USU1FUgkJCTB4MDAKKyNkZWZpbmUgQVI3MVhYX1JFU0VUX1JFR19USU1FUl9SRUxPQUQJCTB4MDQKKyNkZWZpbmUgQVI3MVhYX1JFU0VUX1JFR19XRE9HX0NUUkwJCTB4MDgKKyNkZWZpbmUgQVI3MVhYX1JFU0VUX1JFR19XRE9HCQkJMHgwYworI2RlZmluZSBBUjcxWFhfUkVTRVRfUkVHX01JU0NfSU5UX1NUQVRVUwkweDEwCisjZGVmaW5lIEFSNzFYWF9SRVNFVF9SRUdfTUlTQ19JTlRfRU5BQkxFCTB4MTQKKyNkZWZpbmUgQVI3MVhYX1JFU0VUX1JFR19QQ0lfSU5UX1NUQVRVUwkJMHgxOAorI2RlZmluZSBBUjcxWFhfUkVTRVRfUkVHX1BDSV9JTlRfRU5BQkxFCQkweDFjCisjZGVmaW5lIEFSNzFYWF9SRVNFVF9SRUdfR0xPQkFMX0lOVF9TVEFUVVMJMHgyMAorI2RlZmluZSBBUjcxWFhfUkVTRVRfUkVHX1JFU0VUX01PRFVMRQkJMHgyNAorI2RlZmluZSBBUjcxWFhfUkVTRVRfUkVHX1BFUkZDX0NUUkwJCTB4MmMKKyNkZWZpbmUgQVI3MVhYX1JFU0VUX1JFR19QRVJGQzAJCQkweDMwCisjZGVmaW5lIEFSNzFYWF9SRVNFVF9SRUdfUEVSRkMxCQkJMHgzNAorI2RlZmluZSBBUjcxWFhfUkVTRVRfUkVHX1JFVl9JRAkJCTB4OTAKKworI2RlZmluZSBBUjkxM1hfUkVTRVRfUkVHX0dMT0JBTF9JTlRfU1RBVFVTCTB4MTgKKyNkZWZpbmUgQVI5MTNYX1JFU0VUX1JFR19SRVNFVF9NT0RVTEUJCTB4MWMKKyNkZWZpbmUgQVI5MTNYX1JFU0VUX1JFR19QRVJGX0NUUkwJCTB4MjAKKyNkZWZpbmUgQVI5MTNYX1JFU0VUX1JFR19QRVJGQzAJCQkweDI0CisjZGVmaW5lIEFSOTEzWF9SRVNFVF9SRUdfUEVSRkMxCQkJMHgyOAorCisjZGVmaW5lIEFSNzI0WF9SRVNFVF9SRUdfUkVTRVRfTU9EVUxFCQkweDFjCisKKyNkZWZpbmUgTUlTQ19JTlRfRE1BCQkJQklUKDcpCisjZGVmaW5lIE1JU0NfSU5UX09IQ0kJCQlCSVQoNikKKyNkZWZpbmUgTUlTQ19JTlRfUEVSRkMJCQlCSVQoNSkKKyNkZWZpbmUgTUlTQ19JTlRfV0RPRwkJCUJJVCg0KQorI2RlZmluZSBNSVNDX0lOVF9VQVJUCQkJQklUKDMpCisjZGVmaW5lIE1JU0NfSU5UX0dQSU8JCQlCSVQoMikKKyNkZWZpbmUgTUlTQ19JTlRfRVJST1IJCQlCSVQoMSkKKyNkZWZpbmUgTUlTQ19JTlRfVElNRVIJCQlCSVQoMCkKKworI2RlZmluZSBBUjcxWFhfUkVTRVRfRVhURVJOQUwJCUJJVCgyOCkKKyNkZWZpbmUgQVI3MVhYX1JFU0VUX0ZVTExfQ0hJUAkJQklUKDI0KQorI2RlZmluZSBBUjcxWFhfUkVTRVRfQ1BVX05NSQkJQklUKDIxKQorI2RlZmluZSBBUjcxWFhfUkVTRVRfQ1BVX0NPTEQJCUJJVCgyMCkKKyNkZWZpbmUgQVI3MVhYX1JFU0VUX0RNQQkJQklUKDE5KQorI2RlZmluZSBBUjcxWFhfUkVTRVRfU0xJQwkJQklUKDE4KQorI2RlZmluZSBBUjcxWFhfUkVTRVRfU1RFUkVPCQlCSVQoMTcpCisjZGVmaW5lIEFSNzFYWF9SRVNFVF9ERFIJCUJJVCgxNikKKyNkZWZpbmUgQVI3MVhYX1JFU0VUX0dFMV9NQUMJCUJJVCgxMykKKyNkZWZpbmUgQVI3MVhYX1JFU0VUX0dFMV9QSFkJCUJJVCgxMikKKyNkZWZpbmUgQVI3MVhYX1JFU0VUX1VTQlNVU19PVkVSUklERQlCSVQoMTApCisjZGVmaW5lIEFSNzFYWF9SRVNFVF9HRTBfTUFDCQlCSVQoOSkKKyNkZWZpbmUgQVI3MVhYX1JFU0VUX0dFMF9QSFkJCUJJVCg4KQorI2RlZmluZSBBUjcxWFhfUkVTRVRfVVNCX09IQ0lfRExMCUJJVCg2KQorI2RlZmluZSBBUjcxWFhfUkVTRVRfVVNCX0hPU1QJCUJJVCg1KQorI2RlZmluZSBBUjcxWFhfUkVTRVRfVVNCX1BIWQkJQklUKDQpCisjZGVmaW5lIEFSNzFYWF9SRVNFVF9QQ0lfQlVTCQlCSVQoMSkKKyNkZWZpbmUgQVI3MVhYX1JFU0VUX1BDSV9DT1JFCQlCSVQoMCkKKworI2RlZmluZSBBUjcyNFhfUkVTRVRfR0UxX01ESU8JCUJJVCgyMykKKyNkZWZpbmUgQVI3MjRYX1JFU0VUX0dFMF9NRElPCQlCSVQoMjIpCisjZGVmaW5lIEFSNzI0WF9SRVNFVF9QQ0lFX1BIWV9TRVJJQUwJQklUKDEwKQorI2RlZmluZSBBUjcyNFhfUkVTRVRfUENJRV9QSFkJCUJJVCg3KQorI2RlZmluZSBBUjcyNFhfUkVTRVRfUENJRQkJQklUKDYpCisjZGVmaW5lIEFSNzI0WF9SRVNFVF9PSENJX0RMTAkJQklUKDMpCisKKyNkZWZpbmUgQVI5MTNYX1JFU0VUX0FNQkEyV01BQwkJQklUKDIyKQorCisjZGVmaW5lIFJFVl9JRF9NQUpPUl9NQVNLCQkweGZmZjAKKyNkZWZpbmUgUkVWX0lEX01BSk9SX0FSNzFYWAkJMHgwMGEwCisjZGVmaW5lIFJFVl9JRF9NQUpPUl9BUjkxM1gJCTB4MDBiMAorI2RlZmluZSBSRVZfSURfTUFKT1JfQVI3MjQwCQkweDAwYzAKKyNkZWZpbmUgUkVWX0lEX01BSk9SX0FSNzI0MQkJMHgwMTAwCisjZGVmaW5lIFJFVl9JRF9NQUpPUl9BUjcyNDIJCTB4MTEwMAorCisjZGVmaW5lIEFSNzFYWF9SRVZfSURfTUlOT1JfTUFTSwkweDMKKyNkZWZpbmUgQVI3MVhYX1JFVl9JRF9NSU5PUl9BUjcxMzAJMHgwCisjZGVmaW5lIEFSNzFYWF9SRVZfSURfTUlOT1JfQVI3MTQxCTB4MQorI2RlZmluZSBBUjcxWFhfUkVWX0lEX01JTk9SX0FSNzE2MQkweDIKKyNkZWZpbmUgQVI3MVhYX1JFVl9JRF9SRVZJU0lPTl9NQVNLCTB4MworI2RlZmluZSBBUjcxWFhfUkVWX0lEX1JFVklTSU9OX1NISUZUCTIKKworI2RlZmluZSBBUjkxM1hfUkVWX0lEX01JTk9SX01BU0sJMHgzCisjZGVmaW5lIEFSOTEzWF9SRVZfSURfTUlOT1JfQVI5MTMwCTB4MAorI2RlZmluZSBBUjkxM1hfUkVWX0lEX01JTk9SX0FSOTEzMgkweDEKKyNkZWZpbmUgQVI5MTNYX1JFVl9JRF9SRVZJU0lPTl9NQVNLCTB4MworI2RlZmluZSBBUjkxM1hfUkVWX0lEX1JFVklTSU9OX1NISUZUCTIKKworI2RlZmluZSBBUjcyNFhfUkVWX0lEX1JFVklTSU9OX01BU0sJMHgzCisKKy8qCisgKiBTUEkgYmxvY2sKKyAqLworI2RlZmluZSBBUjcxWFhfU1BJX1JFR19GUwkweDAwCS8qIEZ1bmN0aW9uIFNlbGVjdCAqLworI2RlZmluZSBBUjcxWFhfU1BJX1JFR19DVFJMCTB4MDQJLyogU1BJIENvbnRyb2wgKi8KKyNkZWZpbmUgQVI3MVhYX1NQSV9SRUdfSU9DCTB4MDgJLyogU1BJIEkvTyBDb250cm9sICovCisjZGVmaW5lIEFSNzFYWF9TUElfUkVHX1JEUwkweDBjCS8qIFJlYWQgRGF0YSBTaGlmdCAqLworCisjZGVmaW5lIEFSNzFYWF9TUElfRlNfR1BJTwlCSVQoMCkJLyogRW5hYmxlIEdQSU8gbW9kZSAqLworCisjZGVmaW5lIEFSNzFYWF9TUElfQ1RSTF9SRAlCSVQoNikJLyogUmVtYXAgRGlzYWJsZSAqLworI2RlZmluZSBBUjcxWFhfU1BJX0NUUkxfRElWX01BU0sgMHgzZgorCisjZGVmaW5lIEFSNzFYWF9TUElfSU9DX0RPCUJJVCgwKQkvKiBEYXRhIE91dCBwaW4gKi8KKyNkZWZpbmUgQVI3MVhYX1NQSV9JT0NfQ0xLCUJJVCg4KQkvKiBDTEsgcGluICovCisjZGVmaW5lIEFSNzFYWF9TUElfSU9DX0NTKG4pCUJJVCgxNiArIChuKSkKKyNkZWZpbmUgQVI3MVhYX1NQSV9JT0NfQ1MwCUFSNzFYWF9TUElfSU9DX0NTKDApCisjZGVmaW5lIEFSNzFYWF9TUElfSU9DX0NTMQlBUjcxWFhfU1BJX0lPQ19DUygxKQorI2RlZmluZSBBUjcxWFhfU1BJX0lPQ19DUzIJQVI3MVhYX1NQSV9JT0NfQ1MoMikKKyNkZWZpbmUgQVI3MVhYX1NQSV9JT0NfQ1NfQUxMCShBUjcxWFhfU1BJX0lPQ19DUzAgfCBBUjcxWFhfU1BJX0lPQ19DUzEgfCBcCisJCQkJIEFSNzFYWF9TUElfSU9DX0NTMikKKworLyoKKyAqIEdQSU8gYmxvY2sKKyAqLworI2RlZmluZSBBUjcxWFhfR1BJT19SRUdfT0UJCTB4MDAKKyNkZWZpbmUgQVI3MVhYX0dQSU9fUkVHX0lOCQkweDA0CisjZGVmaW5lIEFSNzFYWF9HUElPX1JFR19PVVQJCTB4MDgKKyNkZWZpbmUgQVI3MVhYX0dQSU9fUkVHX1NFVAkJMHgwYworI2RlZmluZSBBUjcxWFhfR1BJT19SRUdfQ0xFQVIJCTB4MTAKKyNkZWZpbmUgQVI3MVhYX0dQSU9fUkVHX0lOVF9NT0RFCTB4MTQKKyNkZWZpbmUgQVI3MVhYX0dQSU9fUkVHX0lOVF9UWVBFCTB4MTgKKyNkZWZpbmUgQVI3MVhYX0dQSU9fUkVHX0lOVF9QT0xBUklUWQkweDFjCisjZGVmaW5lIEFSNzFYWF9HUElPX1JFR19JTlRfUEVORElORwkweDIwCisjZGVmaW5lIEFSNzFYWF9HUElPX1JFR19JTlRfRU5BQkxFCTB4MjQKKyNkZWZpbmUgQVI3MVhYX0dQSU9fUkVHX0ZVTkMJCTB4MjgKKworI2RlZmluZSBBUjcxWFhfR1BJT19DT1VOVAkJMTYKKyNkZWZpbmUgQVI3MjRYX0dQSU9fQ09VTlQJCTE4CisjZGVmaW5lIEFSOTEzWF9HUElPX0NPVU5UCQkyMgorCisjZW5kaWYgLyogX19BU01fTUFDSF9BUjcxWFhfUkVHU19IICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1hdGg3OS9hdGg3OS5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtYXRoNzkvYXRoNzkuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42YTlmMTY4Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtYXRoNzkvYXRoNzkuaApAQCAtMCwwICsxLDk2IEBACisvKgorICogIEF0aGVyb3MgQVI3MVhYL0FSNzI0WC9BUjkxM1ggY29tbW9uIGRlZmluaXRpb25zCisgKgorICogIENvcHlyaWdodCAoQykgMjAwOC0yMDExIEdhYm9yIEp1aG9zIDxqdWhvc2dAb3BlbndydC5vcmc+CisgKiAgQ29weXJpZ2h0IChDKSAyMDA4IEltcmUgS2Fsb3ogPGthbG96QG9wZW53cnQub3JnPgorICoKKyAqICBQYXJ0cyBvZiB0aGlzIGZpbGUgYXJlIGJhc2VkIG9uIEF0aGVyb3MnIDIuNi4xNSBCU1AKKyAqCisgKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqICB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQKKyAqICBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICovCisKKyNpZm5kZWYgX19BU01fTUFDSF9BVEg3OV9ICisjZGVmaW5lIF9fQVNNX01BQ0hfQVRINzlfSAorCisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9pby5oPgorCitlbnVtIGF0aDc5X3NvY190eXBlIHsKKwlBVEg3OV9TT0NfVU5LTk9XTiwKKwlBVEg3OV9TT0NfQVI3MTMwLAorCUFUSDc5X1NPQ19BUjcxNDEsCisJQVRINzlfU09DX0FSNzE2MSwKKwlBVEg3OV9TT0NfQVI3MjQwLAorCUFUSDc5X1NPQ19BUjcyNDEsCisJQVRINzlfU09DX0FSNzI0MiwKKwlBVEg3OV9TT0NfQVI5MTMwLAorCUFUSDc5X1NPQ19BUjkxMzIKK307CisKK2V4dGVybiBlbnVtIGF0aDc5X3NvY190eXBlIGF0aDc5X3NvYzsKKworc3RhdGljIGlubGluZSBpbnQgc29jX2lzX2FyNzF4eCh2b2lkKQoreworCXJldHVybiAoYXRoNzlfc29jID09IEFUSDc5X1NPQ19BUjcxMzAgfHwKKwkJYXRoNzlfc29jID09IEFUSDc5X1NPQ19BUjcxNDEgfHwKKwkJYXRoNzlfc29jID09IEFUSDc5X1NPQ19BUjcxNjEpOworfQorCitzdGF0aWMgaW5saW5lIGludCBzb2NfaXNfYXI3MjR4KHZvaWQpCit7CisJcmV0dXJuIChhdGg3OV9zb2MgPT0gQVRINzlfU09DX0FSNzI0MCB8fAorCQlhdGg3OV9zb2MgPT0gQVRINzlfU09DX0FSNzI0MSB8fAorCQlhdGg3OV9zb2MgPT0gQVRINzlfU09DX0FSNzI0Mik7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHNvY19pc19hcjcyNDAodm9pZCkKK3sKKwlyZXR1cm4gKGF0aDc5X3NvYyA9PSBBVEg3OV9TT0NfQVI3MjQwKTsKK30KKworc3RhdGljIGlubGluZSBpbnQgc29jX2lzX2FyNzI0MSh2b2lkKQoreworCXJldHVybiAoYXRoNzlfc29jID09IEFUSDc5X1NPQ19BUjcyNDEpOworfQorCitzdGF0aWMgaW5saW5lIGludCBzb2NfaXNfYXI3MjQyKHZvaWQpCit7CisJcmV0dXJuIChhdGg3OV9zb2MgPT0gQVRINzlfU09DX0FSNzI0Mik7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHNvY19pc19hcjkxM3godm9pZCkKK3sKKwlyZXR1cm4gKGF0aDc5X3NvYyA9PSBBVEg3OV9TT0NfQVI5MTMwIHx8CisJCWF0aDc5X3NvYyA9PSBBVEg3OV9TT0NfQVI5MTMyKTsKK30KKworZXh0ZXJuIHZvaWQgX19pb21lbSAqYXRoNzlfZGRyX2Jhc2U7CitleHRlcm4gdm9pZCBfX2lvbWVtICphdGg3OV9wbGxfYmFzZTsKK2V4dGVybiB2b2lkIF9faW9tZW0gKmF0aDc5X3Jlc2V0X2Jhc2U7CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBhdGg3OV9wbGxfd3IodW5zaWduZWQgcmVnLCB1MzIgdmFsKQoreworCV9fcmF3X3dyaXRlbCh2YWwsIGF0aDc5X3BsbF9iYXNlICsgcmVnKTsKK30KKworc3RhdGljIGlubGluZSB1MzIgYXRoNzlfcGxsX3JyKHVuc2lnbmVkIHJlZykKK3sKKwlyZXR1cm4gX19yYXdfcmVhZGwoYXRoNzlfcGxsX2Jhc2UgKyByZWcpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgYXRoNzlfcmVzZXRfd3IodW5zaWduZWQgcmVnLCB1MzIgdmFsKQoreworCV9fcmF3X3dyaXRlbCh2YWwsIGF0aDc5X3Jlc2V0X2Jhc2UgKyByZWcpOworfQorCitzdGF0aWMgaW5saW5lIHUzMiBhdGg3OV9yZXNldF9ycih1bnNpZ25lZCByZWcpCit7CisJcmV0dXJuIF9fcmF3X3JlYWRsKGF0aDc5X3Jlc2V0X2Jhc2UgKyByZWcpOworfQorCit2b2lkIGF0aDc5X2RldmljZV9yZXNldF9zZXQodTMyIG1hc2spOwordm9pZCBhdGg3OV9kZXZpY2VfcmVzZXRfY2xlYXIodTMyIG1hc2spOworCisjZW5kaWYgLyogX19BU01fTUFDSF9BVEg3OV9IICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1hdGg3OS9hdGg3OV9zcGlfcGxhdGZvcm0uaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLWF0aDc5L2F0aDc5X3NwaV9wbGF0Zm9ybS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmFhMjI4M2UKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1hdGg3OS9hdGg3OV9zcGlfcGxhdGZvcm0uaApAQCAtMCwwICsxLDIzIEBACisvKgorICogIFBsYXRmb3JtIGRhdGEgZGVmaW5pdGlvbiBmb3IgQXRoZXJvcyBBUjcxWFgvQVI3MjRYL0FSOTEzWCBTUEkgY29udHJvbGxlcgorICoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDgtMjAxMCBHYWJvciBKdWhvcyA8anVob3NnQG9wZW53cnQub3JnPgorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZAorICogIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKi8KKworI2lmbmRlZiBfQVRINzlfU1BJX1BMQVRGT1JNX0gKKyNkZWZpbmUgX0FUSDc5X1NQSV9QTEFURk9STV9ICisKK3N0cnVjdCBhdGg3OV9zcGlfcGxhdGZvcm1fZGF0YSB7CisJdW5zaWduZWQJYnVzX251bTsKKwl1bnNpZ25lZAludW1fY2hpcHNlbGVjdDsKK307CisKK3N0cnVjdCBhdGg3OV9zcGlfY29udHJvbGxlcl9kYXRhIHsKKwl1bnNpZ25lZAlncGlvOworfTsKKworI2VuZGlmIC8qIF9BVEg3OV9TUElfUExBVEZPUk1fSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtYXRoNzkvY3B1LWZlYXR1cmUtb3ZlcnJpZGVzLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1hdGg3OS9jcHUtZmVhdHVyZS1vdmVycmlkZXMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40NDc2ZmEwCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtYXRoNzkvY3B1LWZlYXR1cmUtb3ZlcnJpZGVzLmgKQEAgLTAsMCArMSw1NiBAQAorLyoKKyAqICBBdGhlcm9zIEFSNzFYWC9BUjcyNFgvQVI5MTNYIHNwZWNpZmljIENQVSBmZWF0dXJlIG92ZXJyaWRlcworICoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDgtMjAxMCBHYWJvciBKdWhvcyA8anVob3NnQG9wZW53cnQub3JnPgorICogIENvcHlyaWdodCAoQykgMjAwOCBJbXJlIEthbG96IDxrYWxvekBvcGVud3J0Lm9yZz4KKyAqCisgKiAgVGhpcyBmaWxlIHdhcyBkZXJpdmVkIGZyb206IGluY2x1ZGUvYXNtLW1pcHMvY3B1LWZlYXR1cmVzLmgKKyAqCUNvcHlyaWdodCAoQykgMjAwMywgMjAwNCBSYWxmIEJhZWNobGUKKyAqCUNvcHlyaWdodCAoQykgMjAwNCBNYWNpZWogVy4gUm96eWNraQorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZAorICogIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKgorICovCisjaWZuZGVmIF9fQVNNX01BQ0hfQVRINzlfQ1BVX0ZFQVRVUkVfT1ZFUlJJREVTX0gKKyNkZWZpbmUgX19BU01fTUFDSF9BVEg3OV9DUFVfRkVBVFVSRV9PVkVSUklERVNfSAorCisjZGVmaW5lIGNwdV9oYXNfdGxiCQkxCisjZGVmaW5lIGNwdV9oYXNfNGtleAkJMQorI2RlZmluZSBjcHVfaGFzXzNrX2NhY2hlCTAKKyNkZWZpbmUgY3B1X2hhc180a19jYWNoZQkxCisjZGVmaW5lIGNwdV9oYXNfdHgzOV9jYWNoZQkwCisjZGVmaW5lIGNwdV9oYXNfc2IxX2NhY2hlCTAKKyNkZWZpbmUgY3B1X2hhc19mcHUJCTAKKyNkZWZpbmUgY3B1X2hhc18zMmZwcgkJMAorI2RlZmluZSBjcHVfaGFzX2NvdW50ZXIJCTEKKyNkZWZpbmUgY3B1X2hhc193YXRjaAkJMQorI2RlZmluZSBjcHVfaGFzX2RpdmVjCQkxCisKKyNkZWZpbmUgY3B1X2hhc19wcmVmZXRjaAkxCisjZGVmaW5lIGNwdV9oYXNfZWp0YWcJCTEKKyNkZWZpbmUgY3B1X2hhc19sbHNjCQkxCisKKyNkZWZpbmUgY3B1X2hhc19taXBzMTYJCTEKKyNkZWZpbmUgY3B1X2hhc19tZG14CQkwCisjZGVmaW5lIGNwdV9oYXNfbWlwczNkCQkwCisjZGVmaW5lIGNwdV9oYXNfc21hcnRtaXBzCTAKKworI2RlZmluZSBjcHVfaGFzX21pcHMzMnIxCTEKKyNkZWZpbmUgY3B1X2hhc19taXBzMzJyMgkxCisjZGVmaW5lIGNwdV9oYXNfbWlwczY0cjEJMAorI2RlZmluZSBjcHVfaGFzX21pcHM2NHIyCTAKKworI2RlZmluZSBjcHVfaGFzX2RzcAkJMAorI2RlZmluZSBjcHVfaGFzX21pcHNtdAkJMAorCisjZGVmaW5lIGNwdV9oYXNfNjRiaXRzCQkwCisjZGVmaW5lIGNwdV9oYXNfNjRiaXRfemVyb19yZWcJMAorI2RlZmluZSBjcHVfaGFzXzY0Yml0X2dwX3JlZ3MJMAorI2RlZmluZSBjcHVfaGFzXzY0Yml0X2FkZHJlc3NlcwkwCisKKyNkZWZpbmUgY3B1X2RjYWNoZV9saW5lX3NpemUoKQkzMgorI2RlZmluZSBjcHVfaWNhY2hlX2xpbmVfc2l6ZSgpCTMyCisKKyNlbmRpZiAvKiBfX0FTTV9NQUNIX0FUSDc5X0NQVV9GRUFUVVJFX09WRVJSSURFU19IICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1hdGg3OS9ncGlvLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1hdGg3OS9ncGlvLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjBkY2I2MgotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLWF0aDc5L2dwaW8uaApAQCAtMCwwICsxLDI2IEBACisvKgorICogIEF0aGVyb3MgQVI3MVhYL0FSNzI0WC9BUjkxM1ggR1BJTyBBUEkgZGVmaW5pdGlvbnMKKyAqCisgKiAgQ29weXJpZ2h0IChDKSAyMDA4LTIwMTAgR2Fib3IgSnVob3MgPGp1aG9zZ0BvcGVud3J0Lm9yZz4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDggSW1yZSBLYWxveiA8a2Fsb3pAb3BlbndydC5vcmc+CisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkCisgKiAgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqCisgKi8KKworI2lmbmRlZiBfX0FTTV9NQUNIX0FUSDc5X0dQSU9fSAorI2RlZmluZSBfX0FTTV9NQUNIX0FUSDc5X0dQSU9fSAorCisjZGVmaW5lIEFSQ0hfTlJfR1BJT1MJNjQKKyNpbmNsdWRlIDxhc20tZ2VuZXJpYy9ncGlvLmg+CisKK2ludCBncGlvX3RvX2lycSh1bnNpZ25lZCBncGlvKTsKK2ludCBpcnFfdG9fZ3Bpbyh1bnNpZ25lZCBpcnEpOworaW50IGdwaW9fZ2V0X3ZhbHVlKHVuc2lnbmVkIGdwaW8pOwordm9pZCBncGlvX3NldF92YWx1ZSh1bnNpZ25lZCBncGlvLCBpbnQgdmFsdWUpOworCisjZGVmaW5lIGdwaW9fY2Fuc2xlZXAJX19ncGlvX2NhbnNsZWVwCisKKyNlbmRpZiAvKiBfX0FTTV9NQUNIX0FUSDc5X0dQSU9fSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtYXRoNzkvaXJxLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1hdGg3OS9pcnEuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xODliYzZlCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21hY2gtYXRoNzkvaXJxLmgKQEAgLTAsMCArMSwzNiBAQAorLyoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDgtMjAxMCBHYWJvciBKdWhvcyA8anVob3NnQG9wZW53cnQub3JnPgorICogIENvcHlyaWdodCAoQykgMjAwOCBJbXJlIEthbG96IDxrYWxvekBvcGVud3J0Lm9yZz4KKyAqCisgKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqICB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQKKyAqICBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICovCisjaWZuZGVmIF9fQVNNX01BQ0hfQVRINzlfSVJRX0gKKyNkZWZpbmUgX19BU01fTUFDSF9BVEg3OV9JUlFfSAorCisjZGVmaW5lIE1JUFNfQ1BVX0lSUV9CQVNFCTAKKyNkZWZpbmUgTlJfSVJRUwkJCTE2CisKKyNkZWZpbmUgQVRINzlfTUlTQ19JUlFfQkFTRQk4CisjZGVmaW5lIEFUSDc5X01JU0NfSVJRX0NPVU5UCTgKKworI2RlZmluZSBBVEg3OV9DUFVfSVJRX0lQMgkoTUlQU19DUFVfSVJRX0JBU0UgKyAyKQorI2RlZmluZSBBVEg3OV9DUFVfSVJRX1VTQgkoTUlQU19DUFVfSVJRX0JBU0UgKyAzKQorI2RlZmluZSBBVEg3OV9DUFVfSVJRX0dFMAkoTUlQU19DUFVfSVJRX0JBU0UgKyA0KQorI2RlZmluZSBBVEg3OV9DUFVfSVJRX0dFMQkoTUlQU19DUFVfSVJRX0JBU0UgKyA1KQorI2RlZmluZSBBVEg3OV9DUFVfSVJRX01JU0MJKE1JUFNfQ1BVX0lSUV9CQVNFICsgNikKKyNkZWZpbmUgQVRINzlfQ1BVX0lSUV9USU1FUgkoTUlQU19DUFVfSVJRX0JBU0UgKyA3KQorCisjZGVmaW5lIEFUSDc5X01JU0NfSVJRX1RJTUVSCShBVEg3OV9NSVNDX0lSUV9CQVNFICsgMCkKKyNkZWZpbmUgQVRINzlfTUlTQ19JUlFfRVJST1IJKEFUSDc5X01JU0NfSVJRX0JBU0UgKyAxKQorI2RlZmluZSBBVEg3OV9NSVNDX0lSUV9HUElPCShBVEg3OV9NSVNDX0lSUV9CQVNFICsgMikKKyNkZWZpbmUgQVRINzlfTUlTQ19JUlFfVUFSVAkoQVRINzlfTUlTQ19JUlFfQkFTRSArIDMpCisjZGVmaW5lIEFUSDc5X01JU0NfSVJRX1dET0cJKEFUSDc5X01JU0NfSVJRX0JBU0UgKyA0KQorI2RlZmluZSBBVEg3OV9NSVNDX0lSUV9QRVJGQwkoQVRINzlfTUlTQ19JUlFfQkFTRSArIDUpCisjZGVmaW5lIEFUSDc5X01JU0NfSVJRX09IQ0kJKEFUSDc5X01JU0NfSVJRX0JBU0UgKyA2KQorI2RlZmluZSBBVEg3OV9NSVNDX0lSUV9ETUEJKEFUSDc5X01JU0NfSVJRX0JBU0UgKyA3KQorCisjaW5jbHVkZV9uZXh0IDxpcnEuaD4KKworI2VuZGlmIC8qIF9fQVNNX01BQ0hfQVRINzlfSVJRX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLWF0aDc5L2tlcm5lbC1lbnRyeS1pbml0LmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1hdGg3OS9rZXJuZWwtZW50cnktaW5pdC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ4ZDA0NmIKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1hdGg3OS9rZXJuZWwtZW50cnktaW5pdC5oCkBAIC0wLDAgKzEsMzIgQEAKKy8qCisgKiAgQXRoZXJvcyBBUjcxWFgvQVI3MjRYL0FSOTEzWCBzcGVjaWZpYyBrZXJuZWwgZW50cnkgc2V0dXAKKyAqCisgKiAgQ29weXJpZ2h0IChDKSAyMDA5IEdhYm9yIEp1aG9zIDxqdWhvc2dAb3BlbndydC5vcmc+CisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkCisgKiAgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqCisgKi8KKyNpZm5kZWYgX19BU01fTUFDSF9BVEg3OV9LRVJORUxfRU5UUllfSAorI2RlZmluZSBfX0FTTV9NQUNIX0FUSDc5X0tFUk5FTF9FTlRSWV9ICisKKwkvKgorCSAqIFNvbWUgYm9vdGxvYWRlcnMgc2V0IHRoZSAnS3NlZzAgY29oZXJlbmN5IGFsZ29yaXRobScgdG8KKwkgKiAnQ2FjaGVhYmxlLCBub25jb2hlcmVudCwgd3JpdGUtdGhyb3VnaCwgbm8gd3JpdGUgYWxsb2NhdGUnCisJICogYW5kIHRoaXMgY2F1c2UgcGVyZm9ybWFuY2UgaXNzdWVzLiBMZXQncyBnbyBhbmQgY2hhbmdlIGl0IHRvCisJICogJ0NhY2hlYWJsZSwgbm9uY29oZXJlbnQsIHdyaXRlLWJhY2ssIHdyaXRlIGFsbG9jYXRlJworCSAqLworCS5tYWNybwlrZXJuZWxfZW50cnlfc2V0dXAKKwltZmMwCXQwLCBDUDBfQ09ORklHCisJbGkJdDEsIH5DT05GX0NNX0NNQVNLCisJYW5kCXQwLCB0MQorCW9yaQl0MCwgQ09ORl9DTV9DQUNIQUJMRV9OT05DT0hFUkVOVAorCW10YzAJdDAsIENQMF9DT05GSUcKKwlub3AKKwkuZW5kbQorCisJLm1hY3JvCXNtcF9zbGF2ZV9zZXR1cAorCS5lbmRtCisKKyNlbmRpZiAvKiBfX0FTTV9NQUNIX0FUSDc5X0tFUk5FTF9FTlRSWV9IICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1hdGg3OS93YXIuaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLWF0aDc5L3dhci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjMyM2Q5ZjEKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1hdGg3OS93YXIuaApAQCAtMCwwICsxLDI1IEBACisvKgorICogVGhpcyBmaWxlIGlzIHN1YmplY3QgdG8gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UuICBTZWUgdGhlIGZpbGUgIkNPUFlJTkciIGluIHRoZSBtYWluIGRpcmVjdG9yeSBvZiB0aGlzIGFyY2hpdmUKKyAqIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDAyLCAyMDA0LCAyMDA3IGJ5IFJhbGYgQmFlY2hsZSA8cmFsZkBsaW51eC1taXBzLm9yZz4KKyAqLworI2lmbmRlZiBfX0FTTV9NQUNIX0FUSDc5X1dBUl9ICisjZGVmaW5lIF9fQVNNX01BQ0hfQVRINzlfV0FSX0gKKworI2RlZmluZSBSNDYwMF9WMV9JTkRFWF9JQ0FDSEVPUF9XQVIJMAorI2RlZmluZSBSNDYwMF9WMV9ISVRfQ0FDSEVPUF9XQVIJMAorI2RlZmluZSBSNDYwMF9WMl9ISVRfQ0FDSEVPUF9XQVIJMAorI2RlZmluZSBSNTQzMl9DUDBfSU5URVJSVVBUX1dBUgkJMAorI2RlZmluZSBCQ00xMjUwX00zX1dBUgkJCTAKKyNkZWZpbmUgU0lCWVRFXzE5NTZfV0FSCQkJMAorI2RlZmluZSBNSVBTNEtfSUNBQ0hFX1JFRklMTF9XQVIJMAorI2RlZmluZSBNSVBTX0NBQ0hFX1NZTkNfV0FSCQkwCisjZGVmaW5lIFRYNDlYWF9JQ0FDSEVfSU5ERVhfSU5WX1dBUgkwCisjZGVmaW5lIFJNOTAwMF9DREVYX1NNUF9XQVIJCTAKKyNkZWZpbmUgSUNBQ0hFX1JFRklMTFNfV09SS0FST1VORF9XQVIJMAorI2RlZmluZSBSMTAwMDBfTExTQ19XQVIJCQkwCisjZGVmaW5lIE1JUFMzNEtfTUlTU0VEX0lUTEJfV0FSCQkwCisKKyNlbmRpZiAvKiBfX0FTTV9NQUNIX0FUSDc5X1dBUl9IICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWlwc19tYWNoaW5lLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWlwc19tYWNoaW5lLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzYzYmIzNQotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9taXBzX21hY2hpbmUuaApAQCAtMCwwICsxLDU0IEBACisvKgorICogIENvcHlyaWdodCAoQykgMjAwOC0yMDEwIEdhYm9yIEp1aG9zIDxqdWhvc2dAb3BlbndydC5vcmc+CisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkCisgKiAgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqCisgKi8KKworI2lmbmRlZiBfX0FTTV9NSVBTX01BQ0hJTkVfSAorI2RlZmluZSBfX0FTTV9NSVBTX01BQ0hJTkVfSAorCisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L3N0ZGRlZi5oPgorCisjaW5jbHVkZSA8YXNtL2Jvb3RpbmZvLmg+CisKK3N0cnVjdCBtaXBzX21hY2hpbmUgeworCXVuc2lnbmVkIGxvbmcJCW1hY2hfdHlwZTsKKwljb25zdCBjaGFyCQkqbWFjaF9pZDsKKwljb25zdCBjaGFyCQkqbWFjaF9uYW1lOworCXZvaWQJCQkoKm1hY2hfc2V0dXApKHZvaWQpOworfTsKKworI2RlZmluZSBNSVBTX01BQ0hJTkUoX3R5cGUsIF9pZCwgX25hbWUsIF9zZXR1cCkJCQlcCitzdGF0aWMgY29uc3QgY2hhciBtYWNoaW5lX25hbWVfIyNfdHlwZVtdIF9faW5pdGNvbnN0CQlcCisJCQlfX2FsaWduZWQoMSkgPSBfbmFtZTsJCQlcCitzdGF0aWMgY29uc3QgY2hhciBtYWNoaW5lX2lkXyMjX3R5cGVbXSBfX2luaXRjb25zdAkJXAorCQkJX19hbGlnbmVkKDEpID0gX2lkOwkJCVwKK3N0YXRpYyBzdHJ1Y3QgbWlwc19tYWNoaW5lIG1hY2hpbmVfIyNfdHlwZQkJCVwKKwkJX191c2VkIF9fc2VjdGlvbigubWlwcy5tYWNoaW5lcy5pbml0KSA9CQlcCit7CQkJCQkJCQlcCisJLm1hY2hfdHlwZQk9IF90eXBlLAkJCQlcCisJLm1hY2hfaWQJPSBtYWNoaW5lX2lkXyMjX3R5cGUsCQkJXAorCS5tYWNoX25hbWUJPSBtYWNoaW5lX25hbWVfIyNfdHlwZSwJCQlcCisJLm1hY2hfc2V0dXAJPSBfc2V0dXAsCQkJCVwKK307CisKK2V4dGVybiBsb25nIF9fbWlwc19tYWNoaW5lc19zdGFydDsKK2V4dGVybiBsb25nIF9fbWlwc19tYWNoaW5lc19lbmQ7CisKKyNpZmRlZiBDT05GSUdfTUlQU19NQUNISU5FCitpbnQgIG1pcHNfbWFjaHR5cGVfc2V0dXAoY2hhciAqaWQpIF9faW5pdDsKK3ZvaWQgbWlwc19tYWNoaW5lX3NldHVwKHZvaWQpIF9faW5pdDsKK3ZvaWQgbWlwc19zZXRfbWFjaGluZV9uYW1lKGNvbnN0IGNoYXIgKm5hbWUpIF9faW5pdDsKK2NoYXIgKm1pcHNfZ2V0X21hY2hpbmVfbmFtZSh2b2lkKTsKKyNlbHNlCitzdGF0aWMgaW5saW5lIGludCBtaXBzX21hY2h0eXBlX3NldHVwKGNoYXIgKmlkKSB7IHJldHVybiAxOyB9CitzdGF0aWMgaW5saW5lIHZvaWQgbWlwc19tYWNoaW5lX3NldHVwKHZvaWQpIHsgfQorc3RhdGljIGlubGluZSB2b2lkIG1pcHNfc2V0X21hY2hpbmVfbmFtZShjb25zdCBjaGFyICpuYW1lKSB7IH0KK3N0YXRpYyBpbmxpbmUgY2hhciAqbWlwc19nZXRfbWFjaGluZV9uYW1lKHZvaWQpIHsgcmV0dXJuIE5VTEw7IH0KKyNlbmRpZiAvKiBDT05GSUdfTUlQU19NQUNISU5FICovCisKKyNlbmRpZiAvKiBfX0FTTV9NSVBTX01BQ0hJTkVfSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21tYW4uaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tbWFuLmgKaW5kZXggYzg5MmJmYi4uNzg1YjRlYSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21tYW4uaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbW1hbi5oCkBAIC03Nyw2ICs3Nyw5IEBACiAjZGVmaW5lIE1BRFZfVU5NRVJHRUFCTEUgMTMJCS8qIEtTTSBtYXkgbm90IG1lcmdlIGlkZW50aWNhbCBwYWdlcyAqLwogI2RlZmluZSBNQURWX0hXUE9JU09OICAgIDEwMAkJLyogcG9pc29uIGEgcGFnZSBmb3IgdGVzdGluZyAqLwogCisjZGVmaW5lIE1BRFZfSFVHRVBBR0UJMTQJCS8qIFdvcnRoIGJhY2tpbmcgd2l0aCBodWdlcGFnZXMgKi8KKyNkZWZpbmUgTUFEVl9OT0hVR0VQQUdFCTE1CQkvKiBOb3Qgd29ydGggYmFja2luZyB3aXRoIGh1Z2VwYWdlcyAqLworCiAvKiBjb21wYXRpYmlsaXR5IGZsYWdzICovCiAjZGVmaW5lIE1BUF9GSUxFCTAKIApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL21tdV9jb250ZXh0LmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbW11X2NvbnRleHQuaAppbmRleCBkOTU5MjczLi43M2MwZDQ1IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbW11X2NvbnRleHQuaAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vbW11X2NvbnRleHQuaApAQCAtMjksMTMgKzI5LDcgQEAKICNkZWZpbmUgVExCTUlTU19IQU5ETEVSX1NFVFVQX1BHRChwZ2QpCQkJCVwKIAl0bGJtaXNzX2hhbmRsZXJfc2V0dXBfcGdkKCh1bnNpZ25lZCBsb25nKShwZ2QpKQogCi1zdGF0aWMgaW5saW5lIHZvaWQgdGxibWlzc19oYW5kbGVyX3NldHVwX3BnZCh1bnNpZ25lZCBsb25nIHBnZCkKLXsKLQkvKiBDaGVjayBmb3Igc3dhcHBlcl9wZ19kaXIgYW5kIGNvbnZlcnQgdG8gcGh5c2ljYWwgYWRkcmVzcy4gKi8KLQlpZiAoKHBnZCAmIENLU0VHMykgPT0gQ0tTRUcwKQotCQlwZ2QgPSBDUEhZU0FERFIocGdkKTsKLQl3cml0ZV9jMF9jb250ZXh0KHBnZCA8PCAxMSk7Ci19CitleHRlcm4gdm9pZCB0bGJtaXNzX2hhbmRsZXJfc2V0dXBfcGdkKHVuc2lnbmVkIGxvbmcgcGdkKTsKIAogI2RlZmluZSBUTEJNSVNTX0hBTkRMRVJfU0VUVVAoKQkJCQkJCVwKIAlkbyB7CQkJCQkJCQlcCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vdWFzbS5oIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL3Vhc20uaAppbmRleCA4OTIwNjJkLi5kY2JkNGJiIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vdWFzbS5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS91YXNtLmgKQEAgLTExNSw3ICsxMTUsMTIgQEAKIElwX3UzdTF1MihfeG9yKTsKIElwX3UydTF1MyhfeG9yaSk7CiBJcF91MnUxbXNidTMoX2RpbnMpOworSXBfdTJ1MW1zYnUzKF9kaW5zbSk7CiBJcF91MShfc3lzY2FsbCk7CitJcF91MXUyczMoX2JiaXQwKTsKK0lwX3UxdTJzMyhfYmJpdDEpOworSXBfdTN1MXUyKF9sd3gpOworSXBfdTN1MXUyKF9sZHgpOwogCiAvKiBIYW5kbGUgbGFiZWxzLiAqLwogc3RydWN0IHVhc21fbGFiZWwgewpAQCAtMTUzLDYgKzE1OCw3IEBACiAjIGRlZmluZSBVQVNNX2lfU1VCVShidWYsIHJzLCBydCwgcmQpIHVhc21faV9kc3VidShidWYsIHJzLCBydCwgcmQpCiAjIGRlZmluZSBVQVNNX2lfTEwoYnVmLCBycywgcnQsIG9mZikgdWFzbV9pX2xsZChidWYsIHJzLCBydCwgb2ZmKQogIyBkZWZpbmUgVUFTTV9pX1NDKGJ1ZiwgcnMsIHJ0LCBvZmYpIHVhc21faV9zY2QoYnVmLCBycywgcnQsIG9mZikKKyMgZGVmaW5lIFVBU01faV9MV1goYnVmLCBycywgcnQsIHJkKSB1YXNtX2lfbGR4KGJ1ZiwgcnMsIHJ0LCByZCkKICNlbHNlCiAjIGRlZmluZSBVQVNNX2lfTFcoYnVmLCBycywgcnQsIG9mZikgdWFzbV9pX2x3KGJ1ZiwgcnMsIHJ0LCBvZmYpCiAjIGRlZmluZSBVQVNNX2lfU1coYnVmLCBycywgcnQsIG9mZikgdWFzbV9pX3N3KGJ1ZiwgcnMsIHJ0LCBvZmYpCkBAIC0xNjcsNiArMTczLDcgQEAKICMgZGVmaW5lIFVBU01faV9TVUJVKGJ1ZiwgcnMsIHJ0LCByZCkgdWFzbV9pX3N1YnUoYnVmLCBycywgcnQsIHJkKQogIyBkZWZpbmUgVUFTTV9pX0xMKGJ1ZiwgcnMsIHJ0LCBvZmYpIHVhc21faV9sbChidWYsIHJzLCBydCwgb2ZmKQogIyBkZWZpbmUgVUFTTV9pX1NDKGJ1ZiwgcnMsIHJ0LCBvZmYpIHVhc21faV9zYyhidWYsIHJzLCBydCwgb2ZmKQorIyBkZWZpbmUgVUFTTV9pX0xXWChidWYsIHJzLCBydCwgcmQpIHVhc21faV9sd3goYnVmLCBycywgcnQsIHJkKQogI2VuZGlmCiAKICNkZWZpbmUgdWFzbV9pX2IoYnVmLCBvZmYpIHVhc21faV9iZXEoYnVmLCAwLCAwLCBvZmYpCmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL01ha2VmaWxlIGIvYXJjaC9taXBzL2tlcm5lbC9NYWtlZmlsZQppbmRleCAyMmIyZTBlLi5jZWRlZTJiIDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2VybmVsL01ha2VmaWxlCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvTWFrZWZpbGUKQEAgLTk1LDYgKzk1LDcgQEAKIG9iai0kKENPTkZJR19LRVhFQykJCSs9IG1hY2hpbmVfa2V4ZWMubyByZWxvY2F0ZV9rZXJuZWwubwogb2JqLSQoQ09ORklHX0VBUkxZX1BSSU5USykJKz0gZWFybHlfcHJpbnRrLm8KIG9iai0kKENPTkZJR19TUElOTE9DS19URVNUKQkrPSBzcGlubG9ja190ZXN0Lm8KK29iai0kKENPTkZJR19NSVBTX01BQ0hJTkUpCSs9IG1pcHNfbWFjaGluZS5vCiAKIG9iai0kKENPTkZJR19PRikJCSs9IHByb20ubwogCkBAIC0xMDYsNCArMTA3LDYgQEAKIAogb2JqLSQoQ09ORklHX0hXX1BFUkZfRVZFTlRTKQkrPSBwZXJmX2V2ZW50Lm8KIAorb2JqLSQoQ09ORklHX0pVTVBfTEFCRUwpCSs9IGp1bXBfbGFiZWwubworCiBDUFBGTEFHU192bWxpbnV4LmxkcwkJOj0gJChLQlVJTERfQ0ZMQUdTKQpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2tlcm5lbC9jcHUtcHJvYmUuYyBiL2FyY2gvbWlwcy9rZXJuZWwvY3B1LXByb2JlLmMKaW5kZXggNjhkYWU3Yi4uZjY1ZDRjOCAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2tlcm5lbC9jcHUtcHJvYmUuYworKysgYi9hcmNoL21pcHMva2VybmVsL2NwdS1wcm9iZS5jCkBAIC03MzksNiArNzM5LDggQEAKIAkgICAgJiYgY3B1X2hhc190bGIpCiAJCWMtPnRsYnNpemUgKz0gKGNvbmZpZzQgJiBNSVBTX0NPTkY0X01NVVNJWkVFWFQpICogMHg0MDsKIAorCWMtPmtzY3JhdGNoX21hc2sgPSAoY29uZmlnNCA+PiAxNikgJiAweGZmOworCiAJcmV0dXJuIGNvbmZpZzQgJiBNSVBTX0NPTkZfTTsKIH0KIApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2tlcm5lbC9qdW1wX2xhYmVsLmMgYi9hcmNoL21pcHMva2VybmVsL2p1bXBfbGFiZWwuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42MDAxNjEwCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2tlcm5lbC9qdW1wX2xhYmVsLmMKQEAgLTAsMCArMSw1NCBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlLiAgU2VlIHRoZSBmaWxlICJDT1BZSU5HIiBpbiB0aGUgbWFpbiBkaXJlY3Rvcnkgb2YgdGhpcyBhcmNoaXZlCisgKiBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIENvcHlyaWdodCAoYykgMjAxMCBDYXZpdW0gTmV0d29ya3MsIEluYy4KKyAqLworCisjaW5jbHVkZSA8bGludXgvanVtcF9sYWJlbC5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L21lbW9yeS5oPgorI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9jcHUuaD4KKworI2luY2x1ZGUgPGFzbS9jYWNoZWZsdXNoLmg+CisjaW5jbHVkZSA8YXNtL2luc3QuaD4KKworI2lmZGVmIEhBVkVfSlVNUF9MQUJFTAorCisjZGVmaW5lIEpfUkFOR0VfTUFTSyAoKDF1bCA8PCAyOCkgLSAxKQorCit2b2lkIGFyY2hfanVtcF9sYWJlbF90cmFuc2Zvcm0oc3RydWN0IGp1bXBfZW50cnkgKmUsCisJCQkgICAgICAgZW51bSBqdW1wX2xhYmVsX3R5cGUgdHlwZSkKK3sKKwl1bmlvbiBtaXBzX2luc3RydWN0aW9uIGluc247CisJdW5pb24gbWlwc19pbnN0cnVjdGlvbiAqaW5zbl9wID0KKwkJKHVuaW9uIG1pcHNfaW5zdHJ1Y3Rpb24gKikodW5zaWduZWQgbG9uZyllLT5jb2RlOworCisJLyogSnVtcCBvbmx5IHdvcmtzIHdpdGhpbiBhIDI1Nk1CIGFsaWduZWQgcmVnaW9uLiAqLworCUJVR19PTigoZS0+dGFyZ2V0ICYgfkpfUkFOR0VfTUFTSykgIT0gKGUtPmNvZGUgJiB+Sl9SQU5HRV9NQVNLKSk7CisKKwkvKiBUYXJnZXQgbXVzdCBoYXZlIDQgYnl0ZSBhbGlnbm1lbnQuICovCisJQlVHX09OKChlLT50YXJnZXQgJiAzKSAhPSAwKTsKKworCWlmICh0eXBlID09IEpVTVBfTEFCRUxfRU5BQkxFKSB7CisJCWluc24ual9mb3JtYXQub3Bjb2RlID0gal9vcDsKKwkJaW5zbi5qX2Zvcm1hdC50YXJnZXQgPSAoZS0+dGFyZ2V0ICYgSl9SQU5HRV9NQVNLKSA+PiAyOworCX0gZWxzZSB7CisJCWluc24ud29yZCA9IDA7IC8qIG5vcCAqLworCX0KKworCWdldF9vbmxpbmVfY3B1cygpOworCW11dGV4X2xvY2soJnRleHRfbXV0ZXgpOworCSppbnNuX3AgPSBpbnNuOworCisJZmx1c2hfaWNhY2hlX3JhbmdlKCh1bnNpZ25lZCBsb25nKWluc25fcCwKKwkJCSAgICh1bnNpZ25lZCBsb25nKWluc25fcCArIHNpemVvZigqaW5zbl9wKSk7CisKKwltdXRleF91bmxvY2soJnRleHRfbXV0ZXgpOworCXB1dF9vbmxpbmVfY3B1cygpOworfQorCisjZW5kaWYgLyogSEFWRV9KVU1QX0xBQkVMICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL21pcHNfbWFjaGluZS5jIGIvYXJjaC9taXBzL2tlcm5lbC9taXBzX21hY2hpbmUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40MTFhMDU4Ci0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9taXBzL2tlcm5lbC9taXBzX21hY2hpbmUuYwpAQCAtMCwwICsxLDg2IEBACisvKgorICogIENvcHlyaWdodCAoQykgMjAwOC0yMDEwIEdhYm9yIEp1aG9zIDxqdWhvc2dAb3BlbndydC5vcmc+CisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkCisgKiAgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqCisgKi8KKyNpbmNsdWRlIDxsaW51eC9tbS5oPgorI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKworI2luY2x1ZGUgPGFzbS9taXBzX21hY2hpbmUuaD4KKworc3RhdGljIHN0cnVjdCBtaXBzX21hY2hpbmUgKm1pcHNfbWFjaGluZSBfX2luaXRkYXRhOworc3RhdGljIGNoYXIgKm1pcHNfbWFjaGluZV9uYW1lID0gIlVua25vd24iOworCisjZGVmaW5lIGZvcl9lYWNoX21hY2hpbmUobWFjaCkgXAorCWZvciAoKG1hY2gpID0gKHN0cnVjdCBtaXBzX21hY2hpbmUgKikmX19taXBzX21hY2hpbmVzX3N0YXJ0OyBcCisJICAgICAobWFjaCkgJiYgXAorCSAgICAgKHVuc2lnbmVkIGxvbmcpKG1hY2gpIDwgKHVuc2lnbmVkIGxvbmcpJl9fbWlwc19tYWNoaW5lc19lbmQ7IFwKKwkgICAgIChtYWNoKSsrKQorCitfX2luaXQgdm9pZCBtaXBzX3NldF9tYWNoaW5lX25hbWUoY29uc3QgY2hhciAqbmFtZSkKK3sKKwljaGFyICpwOworCisJaWYgKG5hbWUgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJcCA9IGtzdHJkdXAobmFtZSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFwKQorCQlwcl9lcnIoIk1JUFM6IG5vIG1lbW9yeSBmb3IgbWFjaGluZV9uYW1lXG4iKTsKKworCW1pcHNfbWFjaGluZV9uYW1lID0gcDsKK30KKworY2hhciAqbWlwc19nZXRfbWFjaGluZV9uYW1lKHZvaWQpCit7CisJcmV0dXJuIG1pcHNfbWFjaGluZV9uYW1lOworfQorCitfX2luaXQgaW50IG1pcHNfbWFjaHR5cGVfc2V0dXAoY2hhciAqaWQpCit7CisJc3RydWN0IG1pcHNfbWFjaGluZSAqbWFjaDsKKworCWZvcl9lYWNoX21hY2hpbmUobWFjaCkgeworCQlpZiAobWFjaC0+bWFjaF9pZCA9PSBOVUxMKQorCQkJY29udGludWU7CisKKwkJaWYgKHN0cmNtcChtYWNoLT5tYWNoX2lkLCBpZCkgPT0gMCkgeworCQkJbWlwc19tYWNodHlwZSA9IG1hY2gtPm1hY2hfdHlwZTsKKwkJCXJldHVybiAwOworCQl9CisJfQorCisJcHJfZXJyKCJNSVBTOiBubyBtYWNoaW5lIGZvdW5kIGZvciBpZCAnJXMnLCBzdXBwb3J0ZWQgbWFjaGluZXM6XG4iLCBpZCk7CisJcHJfZXJyKCIlLTI0cyAlc1xuIiwgImlkIiwgIm5hbWUiKTsKKwlmb3JfZWFjaF9tYWNoaW5lKG1hY2gpCisJCXByX2VycigiJS0yNHMgJXNcbiIsIG1hY2gtPm1hY2hfaWQsIG1hY2gtPm1hY2hfbmFtZSk7CisKKwlyZXR1cm4gMTsKK30KKworX19zZXR1cCgibWFjaHR5cGU9IiwgbWlwc19tYWNodHlwZV9zZXR1cCk7CisKK19faW5pdCB2b2lkIG1pcHNfbWFjaGluZV9zZXR1cCh2b2lkKQoreworCXN0cnVjdCBtaXBzX21hY2hpbmUgKm1hY2g7CisKKwlmb3JfZWFjaF9tYWNoaW5lKG1hY2gpIHsKKwkJaWYgKG1pcHNfbWFjaHR5cGUgPT0gbWFjaC0+bWFjaF90eXBlKSB7CisJCQltaXBzX21hY2hpbmUgPSBtYWNoOworCQkJYnJlYWs7CisJCX0KKwl9CisKKwlpZiAoIW1pcHNfbWFjaGluZSkKKwkJcmV0dXJuOworCisJbWlwc19zZXRfbWFjaGluZV9uYW1lKG1pcHNfbWFjaGluZS0+bWFjaF9uYW1lKTsKKwlwcl9pbmZvKCJNSVBTOiBtYWNoaW5lIGlzICVzXG4iLCBtaXBzX21hY2hpbmVfbmFtZSk7CisKKwlpZiAobWlwc19tYWNoaW5lLT5tYWNoX3NldHVwKQorCQltaXBzX21hY2hpbmUtPm1hY2hfc2V0dXAoKTsKK30KZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9rZXJuZWwvbW9kdWxlLmMgYi9hcmNoL21pcHMva2VybmVsL21vZHVsZS5jCmluZGV4IDZmNTFkZGEuLmRkOTQwYjcgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9rZXJuZWwvbW9kdWxlLmMKKysrIGIvYXJjaC9taXBzL2tlcm5lbC9tb2R1bGUuYwpAQCAtMzAsNiArMzAsOCBAQAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CisjaW5jbHVkZSA8bGludXgvanVtcF9sYWJlbC5oPgorCiAjaW5jbHVkZSA8YXNtL3BndGFibGUuaD4JLyogTU9EVUxFX1NUQVJUICovCiAKIHN0cnVjdCBtaXBzX2hpMTYgewpAQCAtNDYsMTcgKzQ4LDkgQEAKIHZvaWQgKm1vZHVsZV9hbGxvYyh1bnNpZ25lZCBsb25nIHNpemUpCiB7CiAjaWZkZWYgTU9EVUxFX1NUQVJUCi0Jc3RydWN0IHZtX3N0cnVjdCAqYXJlYTsKLQotCXNpemUgPSBQQUdFX0FMSUdOKHNpemUpOwotCWlmICghc2l6ZSkKLQkJcmV0dXJuIE5VTEw7Ci0KLQlhcmVhID0gX19nZXRfdm1fYXJlYShzaXplLCBWTV9BTExPQywgTU9EVUxFX1NUQVJULCBNT0RVTEVfRU5EKTsKLQlpZiAoIWFyZWEpCi0JCXJldHVybiBOVUxMOwotCi0JcmV0dXJuIF9fdm1hbGxvY19hcmVhKGFyZWEsIEdGUF9LRVJORUwsIFBBR0VfS0VSTkVMKTsKKwlyZXR1cm4gX192bWFsbG9jX25vZGVfcmFuZ2Uoc2l6ZSwgMSwgTU9EVUxFX1NUQVJULCBNT0RVTEVfRU5ELAorCQkJCUdGUF9LRVJORUwsIFBBR0VfS0VSTkVMLCAtMSwKKwkJCQlfX2J1aWx0aW5fcmV0dXJuX2FkZHJlc3MoMCkpOwogI2Vsc2UKIAlpZiAoc2l6ZSA9PSAwKQogCQlyZXR1cm4gTlVMTDsKQEAgLTM5MCw2ICszODQsOSBAQAogCWNvbnN0IEVsZl9TaGRyICpzOwogCWNoYXIgKnNlY3N0cmluZ3MgPSAodm9pZCAqKWhkciArIHNlY2hkcnNbaGRyLT5lX3Noc3RybmR4XS5zaF9vZmZzZXQ7CiAKKwkvKiBNYWtlIGp1bXAgbGFiZWwgbm9wcy4gKi8KKwlqdW1wX2xhYmVsX2FwcGx5X25vcHMobWUpOworCiAJSU5JVF9MSVNUX0hFQUQoJm1lLT5hcmNoLmRiZV9saXN0KTsKIAlmb3IgKHMgPSBzZWNoZHJzOyBzIDwgc2VjaGRycyArIGhkci0+ZV9zaG51bTsgcysrKSB7CiAJCWlmIChzdHJjbXAoIl9fZGJlX3RhYmxlIiwgc2Vjc3RyaW5ncyArIHMtPnNoX25hbWUpICE9IDApCmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL3Byb2MuYyBiL2FyY2gvbWlwcy9rZXJuZWwvcHJvYy5jCmluZGV4IDI2MTA5YzQuLmUzMDk2NjUgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9rZXJuZWwvcHJvYy5jCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvcHJvYy5jCkBAIC0xMiw2ICsxMiw3IEBACiAjaW5jbHVkZSA8YXNtL2NwdS1mZWF0dXJlcy5oPgogI2luY2x1ZGUgPGFzbS9taXBzcmVncy5oPgogI2luY2x1ZGUgPGFzbS9wcm9jZXNzb3IuaD4KKyNpbmNsdWRlIDxhc20vbWlwc19tYWNoaW5lLmg+CiAKIHVuc2lnbmVkIGludCB2Y2VkX2NvdW50LCB2Y2VpX2NvdW50OwogCkBAIC0zMSw4ICszMiwxMiBAQAogCS8qCiAJICogRm9yIHRoZSBmaXJzdCBwcm9jZXNzb3IgYWxzbyBwcmludCB0aGUgc3lzdGVtIHR5cGUKIAkgKi8KLQlpZiAobiA9PSAwKQorCWlmIChuID09IDApIHsKIAkJc2VxX3ByaW50ZihtLCAic3lzdGVtIHR5cGVcdFx0OiAlc1xuIiwgZ2V0X3N5c3RlbV90eXBlKCkpOworCQlpZiAobWlwc19nZXRfbWFjaGluZV9uYW1lKCkpCisJCQlzZXFfcHJpbnRmKG0sICJtYWNoaW5lXHRcdFx0OiAlc1xuIiwKKwkJCQkgICBtaXBzX2dldF9tYWNoaW5lX25hbWUoKSk7CisJfQogCiAJc2VxX3ByaW50ZihtLCAicHJvY2Vzc29yXHRcdDogJWxkXG4iLCBuKTsKIAlzcHJpbnRmKGZtdCwgImNwdSBtb2RlbFx0XHQ6ICUlcyBWJSVkLiUlZCVzXG4iLApAQCAtNjksNiArNzQsOCBAQAogCQkpOwogCXNlcV9wcmludGYobSwgInNoYWRvdyByZWdpc3RlciBzZXRzXHQ6ICVkXG4iLAogCQkgICAgICAgY3B1X2RhdGFbbl0uc3JzZXRzKTsKKwlzZXFfcHJpbnRmKG0sICJrc2NyYXRjaCByZWdpc3RlcnNcdDogJWRcbiIsCisJCSAgIGh3ZWlnaHQ4KGNwdV9kYXRhW25dLmtzY3JhdGNoX21hc2spKTsKIAlzZXFfcHJpbnRmKG0sICJjb3JlXHRcdFx0OiAlZFxuIiwgY3B1X2RhdGFbbl0uY29yZSk7CiAKIAlzcHJpbnRmKGZtdCwgIlZDRSUlYyBleGNlcHRpb25zXHRcdDogJXNcbiIsCmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL3Byb20uYyBiL2FyY2gvbWlwcy9rZXJuZWwvcHJvbS5jCmluZGV4IDlkYmU1ODMuLmExOTgxMWU5IDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2VybmVsL3Byb20uYworKysgYi9hcmNoL21pcHMva2VybmVsL3Byb20uYwpAQCAtNDUsMTEgKzQ1LDkgQEAKIAlyZXR1cm4gZnJlZV9ib290bWVtKGFkZHIsIHNpemUpOwogfQogCi11NjQgX19pbml0IGVhcmx5X2luaXRfZHRfYWxsb2NfbWVtb3J5X2FyY2godTY0IHNpemUsIHU2NCBhbGlnbikKK3ZvaWQgKiBfX2luaXQgZWFybHlfaW5pdF9kdF9hbGxvY19tZW1vcnlfYXJjaCh1NjQgc2l6ZSwgdTY0IGFsaWduKQogewotCXJldHVybiB2aXJ0X3RvX3BoeXMoCi0JCV9fYWxsb2NfYm9vdG1lbShzaXplLCBhbGlnbiwgX19wYShNQVhfRE1BX0FERFJFU1MpKQotCQkpOworCXJldHVybiBfX2FsbG9jX2Jvb3RtZW0oc2l6ZSwgYWxpZ24sIF9fcGEoTUFYX0RNQV9BRERSRVNTKSk7CiB9CiAKICNpZmRlZiBDT05GSUdfQkxLX0RFVl9JTklUUkQKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9rZXJuZWwvc2V0dXAuYyBiL2FyY2gvbWlwcy9rZXJuZWwvc2V0dXAuYwppbmRleCBhY2QzZjJjLi44YWQxZDU2IDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2VybmVsL3NldHVwLmMKKysrIGIvYXJjaC9taXBzL2tlcm5lbC9zZXR1cC5jCkBAIC03MCw3ICs3MCw3IEBACiAgKiBtaXBzX2lvX3BvcnRfYmFzZSBpcyB0aGUgYmVnaW4gb2YgdGhlIGFkZHJlc3Mgc3BhY2UgdG8gd2hpY2ggeDg2IHN0eWxlCiAgKiBJL08gcG9ydHMgYXJlIG1hcHBlZC4KICAqLwotY29uc3QgdW5zaWduZWQgbG9uZyBtaXBzX2lvX3BvcnRfYmFzZSBfX3JlYWRfbW9zdGx5ID0gLTE7Citjb25zdCB1bnNpZ25lZCBsb25nIG1pcHNfaW9fcG9ydF9iYXNlID0gLTE7CiBFWFBPUlRfU1lNQk9MKG1pcHNfaW9fcG9ydF9iYXNlKTsKIAogc3RhdGljIHN0cnVjdCByZXNvdXJjZSBjb2RlX3Jlc291cmNlID0geyAubmFtZSA9ICJLZXJuZWwgY29kZSIsIH07CmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL3RyYXBzLmMgYi9hcmNoL21pcHMva2VybmVsL3RyYXBzLmMKaW5kZXggZTk3MTA0My4uNzEzNTBmNyAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2tlcm5lbC90cmFwcy5jCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvdHJhcHMuYwpAQCAtMTU5Miw3ICsxNTkyLDYgQEAKICNlbmRpZiAvKiBDT05GSUdfTUlQU19NVF9TTVRDICovCiAKIAljcHVfZGF0YVtjcHVdLmFzaWRfY2FjaGUgPSBBU0lEX0ZJUlNUX1ZFUlNJT047Ci0JVExCTUlTU19IQU5ETEVSX1NFVFVQKCk7CiAKIAlhdG9taWNfaW5jKCZpbml0X21tLm1tX2NvdW50KTsKIAljdXJyZW50LT5hY3RpdmVfbW0gPSAmaW5pdF9tbTsKQEAgLTE2MTQsNiArMTYxMyw3IEBACiAJCXdyaXRlX2MwX3dpcmVkKDApOwogCX0KICNlbmRpZiAvKiBDT05GSUdfTUlQU19NVF9TTVRDICovCisJVExCTUlTU19IQU5ETEVSX1NFVFVQKCk7CiB9CiAKIC8qIEluc3RhbGwgQ1BVIGV4Y2VwdGlvbiBoYW5kbGVyICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMva2VybmVsL3ZtbGludXgubGRzLlMgYi9hcmNoL21pcHMva2VybmVsL3ZtbGludXgubGRzLlMKaW5kZXggZjI1ZGY3My4uNTcwNjA3YiAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2tlcm5lbC92bWxpbnV4Lmxkcy5TCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvdm1saW51eC5sZHMuUwpAQCAtOTgsNiArOTgsMTMgQEAKIAlJTklUX1RFWFRfU0VDVElPTihQQUdFX1NJWkUpCiAJSU5JVF9EQVRBX1NFQ1RJT04oMTYpCiAKKwkuID0gQUxJR04oNCk7CisJLm1pcHMubWFjaGluZXMuaW5pdCA6IEFUKEFERFIoLm1pcHMubWFjaGluZXMuaW5pdCkgLSBMT0FEX09GRlNFVCkgeworCQlfX21pcHNfbWFjaGluZXNfc3RhcnQgPSAuOworCQkqKC5taXBzLm1hY2hpbmVzLmluaXQpCisJCV9fbWlwc19tYWNoaW5lc19lbmQgPSAuOworCX0KKwogCS8qIC5leGl0LnRleHQgaXMgZGlzY2FyZGVkIGF0IHJ1bnRpbWUsIG5vdCBsaW5rIHRpbWUsIHRvIGRlYWwgd2l0aAogCSAqIHJlZmVyZW5jZXMgZnJvbSAucm9kYXRhCiAJICovCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvbW0vdGxiZXguYyBiL2FyY2gvbWlwcy9tbS90bGJleC5jCmluZGV4IDkzODE2ZjMuLjA4M2QzNDEgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9tbS90bGJleC5jCisrKyBiL2FyY2gvbWlwcy9tbS90bGJleC5jCkBAIC0yNiw4ICsyNiwxMCBAQAogI2luY2x1ZGUgPGxpbnV4L3NtcC5oPgogI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9jYWNoZS5oPgogCi0jaW5jbHVkZSA8YXNtL21tdV9jb250ZXh0Lmg+CisjaW5jbHVkZSA8YXNtL2NhY2hlZmx1c2guaD4KKyNpbmNsdWRlIDxhc20vcGd0YWJsZS5oPgogI2luY2x1ZGUgPGFzbS93YXIuaD4KICNpbmNsdWRlIDxhc20vdWFzbS5oPgogCkBAIC02Myw2ICs2NSw1MiBAQAogCXJldHVybiBSMTAwMDBfTExTQ19XQVI7CiB9CiAKK3N0YXRpYyBpbnQgdXNlX2JiaXRfaW5zbnModm9pZCkKK3sKKwlzd2l0Y2ggKGN1cnJlbnRfY3B1X3R5cGUoKSkgeworCWNhc2UgQ1BVX0NBVklVTV9PQ1RFT046CisJY2FzZSBDUFVfQ0FWSVVNX09DVEVPTl9QTFVTOgorCWNhc2UgQ1BVX0NBVklVTV9PQ1RFT04yOgorCQlyZXR1cm4gMTsKKwlkZWZhdWx0OgorCQlyZXR1cm4gMDsKKwl9Cit9CisKK3N0YXRpYyBpbnQgdXNlX2x3eF9pbnNucyh2b2lkKQoreworCXN3aXRjaCAoY3VycmVudF9jcHVfdHlwZSgpKSB7CisJY2FzZSBDUFVfQ0FWSVVNX09DVEVPTjI6CisJCXJldHVybiAxOworCWRlZmF1bHQ6CisJCXJldHVybiAwOworCX0KK30KKyNpZiBkZWZpbmVkKENPTkZJR19DQVZJVU1fT0NURU9OX0NWTVNFR19TSVpFKSAmJiBcCisgICAgQ09ORklHX0NBVklVTV9PQ1RFT05fQ1ZNU0VHX1NJWkUgPiAwCitzdGF0aWMgYm9vbCBzY3JhdGNocGFkX2F2YWlsYWJsZSh2b2lkKQoreworCXJldHVybiB0cnVlOworfQorc3RhdGljIGludCBzY3JhdGNocGFkX29mZnNldChpbnQgaSkKK3sKKwkvKgorCSAqIENWTVNFRyBzdGFydHMgYXQgYWRkcmVzcyAtMzI3NjggYW5kIGV4dGVuZHMgZm9yCisJICogQ0FWSVVNX09DVEVPTl9DVk1TRUdfU0laRSAxMjggYnl0ZSBjYWNoZSBsaW5lcy4KKwkgKi8KKwlpICs9IDE7IC8qIEtlcm5lbCB1c2Ugc3RhcnRzIGF0IHRoZSB0b3AgYW5kIHdvcmtzIGRvd24uICovCisJcmV0dXJuIENPTkZJR19DQVZJVU1fT0NURU9OX0NWTVNFR19TSVpFICogMTI4IC0gKDggKiBpKSAtIDMyNzY4OworfQorI2Vsc2UKK3N0YXRpYyBib29sIHNjcmF0Y2hwYWRfYXZhaWxhYmxlKHZvaWQpCit7CisJcmV0dXJuIGZhbHNlOworfQorc3RhdGljIGludCBzY3JhdGNocGFkX29mZnNldChpbnQgaSkKK3sKKwlCVUcoKTsKK30KKyNlbmRpZgogLyoKICAqIEZvdW5kIGJ5IGV4cGVyaW1lbnQ6IEF0IGxlYXN0IHNvbWUgcmV2aXNpb25zIG9mIHRoZSA0a2MgdGhyb3cgdW5kZXIKICAqIHNvbWUgY2lyY3Vtc3RhbmNlcyBhIG1hY2hpbmUgY2hlY2sgZXhjZXB0aW9uLCB0cmlnZ2VyZWQgYnkgaW52YWxpZApAQCAtMTczLDExICsyMjEsNDEgQEAKIHN0YXRpYyBpbnQgY2hlY2tfZm9yX2hpZ2hfc2VnYml0cyBfX2NwdWluaXRkYXRhOwogI2VuZGlmCiAKK3N0YXRpYyBpbnQgY2hlY2tfZm9yX2hpZ2hfc2VnYml0cyBfX2NwdWluaXRkYXRhOworCitzdGF0aWMgdW5zaWduZWQgaW50IGtzY3JhdGNoX3VzZWRfbWFzayBfX2NwdWluaXRkYXRhOworCitzdGF0aWMgaW50IF9fY3B1aW5pdCBhbGxvY2F0ZV9rc2NyYXRjaCh2b2lkKQoreworCWludCByOworCXVuc2lnbmVkIGludCBhID0gY3B1X2RhdGFbMF0ua3NjcmF0Y2hfbWFzayAmIH5rc2NyYXRjaF91c2VkX21hc2s7CisKKwlyID0gZmZzKGEpOworCisJaWYgKHIgPT0gMCkKKwkJcmV0dXJuIC0xOworCisJci0tOyAvKiBtYWtlIGl0IHplcm8gYmFzZWQgKi8KKworCWtzY3JhdGNoX3VzZWRfbWFzayB8PSAoMSA8PCByKTsKKworCXJldHVybiByOworfQorCitzdGF0aWMgaW50IHNjcmF0Y2hfcmVnIF9fY3B1aW5pdGRhdGE7CitzdGF0aWMgaW50IHBnZF9yZWcgX19jcHVpbml0ZGF0YTsKK2VudW0gdm1hbGxvYzY0X21vZGUge25vdF9yZWZpbGwsIHJlZmlsbF9zY3JhdGNoLCByZWZpbGxfbm9zY3JhdGNofTsKKwogI2lmbmRlZiBDT05GSUdfTUlQU19QR0RfQzBfQ09OVEVYVAorCiAvKgogICogQ09ORklHX01JUFNfUEdEX0MwX0NPTlRFWFQgaW1wbGllcyA2NCBiaXQgYW5kIGxhY2sgb2YgcGdkX2N1cnJlbnQsCiAgKiB3ZSBjYW5ub3QgZG8gcjMwMDAgdW5kZXIgdGhlc2UgY2lyY3Vtc3RhbmNlcy4KKyAqCisgKiBEZWNsYXJlIHBnZF9jdXJyZW50IGhlcmUgaW5zdGVhZCBvZiBpbmNsdWRpbmcgbW11X2NvbnRleHQuaCB0byBhdm9pZCB0eXBlCisgKiBjb25mbGljdHMgZm9yIHRsYm1pc3NfaGFuZGxlcl9zZXR1cF9wZ2QKICAqLworZXh0ZXJuIHVuc2lnbmVkIGxvbmcgcGdkX2N1cnJlbnRbXTsKIAogLyoKICAqIFRoZSBSMzAwMCBUTEIgaGFuZGxlciBpcyBzaW1wbGUuCkBAIC00NDAsMjEgKzUxOCw0MyBAQAogc3RhdGljIF9fY3B1aW5pdCB2b2lkIGJ1aWxkX3Jlc3RvcmVfcGFnZW1hc2sodTMyICoqcCwKIAkJCQkJICAgICBzdHJ1Y3QgdWFzbV9yZWxvYyAqKnIsCiAJCQkJCSAgICAgdW5zaWduZWQgaW50IHRtcCwKLQkJCQkJICAgICBlbnVtIGxhYmVsX2lkIGxpZCkKKwkJCQkJICAgICBlbnVtIGxhYmVsX2lkIGxpZCwKKwkJCQkJICAgICBpbnQgcmVzdG9yZV9zY3JhdGNoKQogewotCS8qIFJlc2V0IGRlZmF1bHQgcGFnZSBzaXplICovCi0JaWYgKFBNX0RFRkFVTFRfTUFTSyA+PiAxNikgewotCQl1YXNtX2lfbHVpKHAsIHRtcCwgUE1fREVGQVVMVF9NQVNLID4+IDE2KTsKLQkJdWFzbV9pX29yaShwLCB0bXAsIHRtcCwgUE1fREVGQVVMVF9NQVNLICYgMHhmZmZmKTsKLQkJdWFzbV9pbF9iKHAsIHIsIGxpZCk7Ci0JCXVhc21faV9tdGMwKHAsIHRtcCwgQzBfUEFHRU1BU0spOwotCX0gZWxzZSBpZiAoUE1fREVGQVVMVF9NQVNLKSB7Ci0JCXVhc21faV9vcmkocCwgdG1wLCAwLCBQTV9ERUZBVUxUX01BU0spOwotCQl1YXNtX2lsX2IocCwgciwgbGlkKTsKLQkJdWFzbV9pX210YzAocCwgdG1wLCBDMF9QQUdFTUFTSyk7CisJaWYgKHJlc3RvcmVfc2NyYXRjaCkgeworCQkvKiBSZXNldCBkZWZhdWx0IHBhZ2Ugc2l6ZSAqLworCQlpZiAoUE1fREVGQVVMVF9NQVNLID4+IDE2KSB7CisJCQl1YXNtX2lfbHVpKHAsIHRtcCwgUE1fREVGQVVMVF9NQVNLID4+IDE2KTsKKwkJCXVhc21faV9vcmkocCwgdG1wLCB0bXAsIFBNX0RFRkFVTFRfTUFTSyAmIDB4ZmZmZik7CisJCQl1YXNtX2lfbXRjMChwLCB0bXAsIEMwX1BBR0VNQVNLKTsKKwkJCXVhc21faWxfYihwLCByLCBsaWQpOworCQl9IGVsc2UgaWYgKFBNX0RFRkFVTFRfTUFTSykgeworCQkJdWFzbV9pX29yaShwLCB0bXAsIDAsIFBNX0RFRkFVTFRfTUFTSyk7CisJCQl1YXNtX2lfbXRjMChwLCB0bXAsIEMwX1BBR0VNQVNLKTsKKwkJCXVhc21faWxfYihwLCByLCBsaWQpOworCQl9IGVsc2UgeworCQkJdWFzbV9pX210YzAocCwgMCwgQzBfUEFHRU1BU0spOworCQkJdWFzbV9pbF9iKHAsIHIsIGxpZCk7CisJCX0KKwkJaWYgKHNjcmF0Y2hfcmVnID4gMCkKKwkJCVVBU01faV9NRkMwKHAsIDEsIDMxLCBzY3JhdGNoX3JlZyk7CisJCWVsc2UKKwkJCVVBU01faV9MVyhwLCAxLCBzY3JhdGNocGFkX29mZnNldCgwKSwgMCk7CiAJfSBlbHNlIHsKLQkJdWFzbV9pbF9iKHAsIHIsIGxpZCk7Ci0JCXVhc21faV9tdGMwKHAsIDAsIEMwX1BBR0VNQVNLKTsKKwkJLyogUmVzZXQgZGVmYXVsdCBwYWdlIHNpemUgKi8KKwkJaWYgKFBNX0RFRkFVTFRfTUFTSyA+PiAxNikgeworCQkJdWFzbV9pX2x1aShwLCB0bXAsIFBNX0RFRkFVTFRfTUFTSyA+PiAxNik7CisJCQl1YXNtX2lfb3JpKHAsIHRtcCwgdG1wLCBQTV9ERUZBVUxUX01BU0sgJiAweGZmZmYpOworCQkJdWFzbV9pbF9iKHAsIHIsIGxpZCk7CisJCQl1YXNtX2lfbXRjMChwLCB0bXAsIEMwX1BBR0VNQVNLKTsKKwkJfSBlbHNlIGlmIChQTV9ERUZBVUxUX01BU0spIHsKKwkJCXVhc21faV9vcmkocCwgdG1wLCAwLCBQTV9ERUZBVUxUX01BU0spOworCQkJdWFzbV9pbF9iKHAsIHIsIGxpZCk7CisJCQl1YXNtX2lfbXRjMChwLCB0bXAsIEMwX1BBR0VNQVNLKTsKKwkJfSBlbHNlIHsKKwkJCXVhc21faWxfYihwLCByLCBsaWQpOworCQkJdWFzbV9pX210YzAocCwgMCwgQzBfUEFHRU1BU0spOworCQl9CiAJfQogfQogCkBAIC00NjIsNyArNTYyLDggQEAKIAkJCQkJCSBzdHJ1Y3QgdWFzbV9sYWJlbCAqKmwsCiAJCQkJCQkgc3RydWN0IHVhc21fcmVsb2MgKipyLAogCQkJCQkJIHVuc2lnbmVkIGludCB0bXAsCi0JCQkJCQkgZW51bSB0bGJfd3JpdGVfZW50cnkgd21vZGUpCisJCQkJCQkgZW51bSB0bGJfd3JpdGVfZW50cnkgd21vZGUsCisJCQkJCQkgaW50IHJlc3RvcmVfc2NyYXRjaCkKIHsKIAkvKiBTZXQgaHVnZSBwYWdlIHRsYiBlbnRyeSBzaXplICovCiAJdWFzbV9pX2x1aShwLCB0bXAsIFBNX0hVR0VfTUFTSyA+PiAxNik7CkBAIC00NzEsNyArNTcyLDcgQEAKIAogCWJ1aWxkX3RsYl93cml0ZV9lbnRyeShwLCBsLCByLCB3bW9kZSk7CiAKLQlidWlsZF9yZXN0b3JlX3BhZ2VtYXNrKHAsIHIsIHRtcCwgbGFiZWxfbGVhdmUpOworCWJ1aWxkX3Jlc3RvcmVfcGFnZW1hc2socCwgciwgdG1wLCBsYWJlbF9sZWF2ZSwgcmVzdG9yZV9zY3JhdGNoKTsKIH0KIAogLyoKQEAgLTQ4Miw4ICs1ODMsMTIgQEAKIAkJdW5zaWduZWQgaW50IHBtZCwgaW50IGxpZCkKIHsKIAlVQVNNX2lfTFcocCwgdG1wLCAwLCBwbWQpOwotCXVhc21faV9hbmRpKHAsIHRtcCwgdG1wLCBfUEFHRV9IVUdFKTsKLQl1YXNtX2lsX2JuZXoocCwgciwgdG1wLCBsaWQpOworCWlmICh1c2VfYmJpdF9pbnNucygpKSB7CisJCXVhc21faWxfYmJpdDEocCwgciwgdG1wLCBpbG9nMihfUEFHRV9IVUdFKSwgbGlkKTsKKwl9IGVsc2UgeworCQl1YXNtX2lfYW5kaShwLCB0bXAsIHRtcCwgX1BBR0VfSFVHRSk7CisJCXVhc21faWxfYm5leihwLCByLCB0bXAsIGxpZCk7CisJfQogfQogCiBzdGF0aWMgX19jcHVpbml0IHZvaWQgYnVpbGRfaHVnZV91cGRhdGVfZW50cmllcyh1MzIgKipwLApAQCAtNTMyLDcgKzYzNyw3IEBACiAJVUFTTV9pX1NXKHAsIHB0ZSwgMCwgcHRyKTsKICNlbmRpZgogCWJ1aWxkX2h1Z2VfdXBkYXRlX2VudHJpZXMocCwgcHRlLCBwdHIpOwotCWJ1aWxkX2h1Z2VfdGxiX3dyaXRlX2VudHJ5KHAsIGwsIHIsIHB0ZSwgdGxiX2luZGV4ZWQpOworCWJ1aWxkX2h1Z2VfdGxiX3dyaXRlX2VudHJ5KHAsIGwsIHIsIHB0ZSwgdGxiX2luZGV4ZWQsIDApOwogfQogI2VuZGlmIC8qIENPTkZJR19IVUdFVExCX1BBR0UgKi8KIApAQCAtNTczLDEzICs2NzgsMjIgQEAKIAkvKiBObyB1YXNtX2lfbm9wIG5lZWRlZCBoZXJlLCBzaW5jZSB0aGUgbmV4dCBpbnNuIGRvZXNuJ3QgdG91Y2ggVE1QLiAqLwogCiAjaWZkZWYgQ09ORklHX01JUFNfUEdEX0MwX0NPTlRFWFQKLQkvKgotCSAqICZwZ2QgPDwgMTEgc3RvcmVkIGluIENPTlRFWFQgWzIzLi42M10uCi0JICovCi0JVUFTTV9pX01GQzAocCwgcHRyLCBDMF9DT05URVhUKTsKLQl1YXNtX2lfZGlucyhwLCBwdHIsIDAsIDAsIDIzKTsgLyogQ2xlYXIgbG93ZXIgMjMgYml0cyBvZiBjb250ZXh0LiAqLwotCXVhc21faV9vcmkocCwgcHRyLCBwdHIsIDB4NTQwKTsgLyogMSAwICAxIDAgMSAgPDwgNiAgeGtwaHlzIGNhY2hlZCAqLwotCXVhc21faV9kcm90cihwLCBwdHIsIHB0ciwgMTEpOworCWlmIChwZ2RfcmVnICE9IC0xKSB7CisJCS8qIHBnZCBpcyBpbiBwZ2RfcmVnICovCisJCVVBU01faV9NRkMwKHAsIHB0ciwgMzEsIHBnZF9yZWcpOworCX0gZWxzZSB7CisJCS8qCisJCSAqICZwZ2QgPDwgMTEgc3RvcmVkIGluIENPTlRFWFQgWzIzLi42M10uCisJCSAqLworCQlVQVNNX2lfTUZDMChwLCBwdHIsIEMwX0NPTlRFWFQpOworCisJCS8qIENsZWFyIGxvd2VyIDIzIGJpdHMgb2YgY29udGV4dC4gKi8KKwkJdWFzbV9pX2RpbnMocCwgcHRyLCAwLCAwLCAyMyk7CisKKwkJLyogMSAwICAxIDAgMSAgPDwgNiAgeGtwaHlzIGNhY2hlZCAqLworCQl1YXNtX2lfb3JpKHAsIHB0ciwgcHRyLCAweDU0MCk7CisJCXVhc21faV9kcm90cihwLCBwdHIsIHB0ciwgMTEpOworCX0KICNlbGlmIGRlZmluZWQoQ09ORklHX1NNUCkKICMgaWZkZWYgIENPTkZJR19NSVBTX01UX1NNVEMKIAkvKgpAQCAtNjIwLDcgKzczNCw2IEBACiAjZW5kaWYKIH0KIAotZW51bSB2bWFsbG9jNjRfbW9kZSB7bm90X3JlZmlsbCwgcmVmaWxsfTsKIC8qCiAgKiBCVkFERFIgaXMgdGhlIGZhdWx0aW5nIGFkZHJlc3MsIFBUUiBpcyBzY3JhdGNoLgogICogUFRSIHdpbGwgaG9sZCB0aGUgcGdkIGZvciB2bWFsbG9jLgpAQCAtNjM4LDcgKzc1MSw3IEBACiAKIAl1YXNtX2xfdm1hbGxvYyhsLCAqcCk7CiAKLQlpZiAobW9kZSA9PSByZWZpbGwgJiYgY2hlY2tfZm9yX2hpZ2hfc2VnYml0cykgeworCWlmIChtb2RlICE9IG5vdF9yZWZpbGwgJiYgY2hlY2tfZm9yX2hpZ2hfc2VnYml0cykgewogCQlpZiAoc2luZ2xlX2luc25fc3dwZCkgewogCQkJdWFzbV9pbF9ibHR6KHAsIHIsIGJ2YWRkciwgbGFiZWxfdm1hbGxvY19kb25lKTsKIAkJCXVhc21faV9sdWkocCwgcHRyLCB1YXNtX3JlbF9oaShzd3BkKSk7CkBAIC02NjEsNyArNzc0LDcgQEAKIAkJCQl1YXNtX2lfZGFkZGl1KHAsIHB0ciwgcHRyLCB1YXNtX3JlbF9sbyhzd3BkKSk7CiAJCX0KIAl9Ci0JaWYgKG1vZGUgPT0gcmVmaWxsICYmIGNoZWNrX2Zvcl9oaWdoX3NlZ2JpdHMpIHsKKwlpZiAobW9kZSAhPSBub3RfcmVmaWxsICYmIGNoZWNrX2Zvcl9oaWdoX3NlZ2JpdHMpIHsKIAkJdWFzbV9sX2xhcmdlX3NlZ2JpdHNfZmF1bHQobCwgKnApOwogCQkvKgogCQkgKiBXZSBnZXQgaGVyZSBpZiB3ZSBhcmUgYW4geHNzZWcgYWRkcmVzcywgb3IgaWYgd2UgYXJlCkBAIC02NzcsNyArNzkwLDE1IEBACiAJCSAqLwogCQlVQVNNX2lfTEEocCwgcHRyLCAodW5zaWduZWQgbG9uZyl0bGJfZG9fcGFnZV9mYXVsdF8wKTsKIAkJdWFzbV9pX2pyKHAsIHB0cik7Ci0JCXVhc21faV9ub3AocCk7CisKKwkJaWYgKG1vZGUgPT0gcmVmaWxsX3NjcmF0Y2gpIHsKKwkJCWlmIChzY3JhdGNoX3JlZyA+IDApCisJCQkJVUFTTV9pX01GQzAocCwgMSwgMzEsIHNjcmF0Y2hfcmVnKTsKKwkJCWVsc2UKKwkJCQlVQVNNX2lfTFcocCwgMSwgc2NyYXRjaHBhZF9vZmZzZXQoMCksIDApOworCQl9IGVsc2UgeworCQkJdWFzbV9pX25vcChwKTsKKwkJfQogCX0KIH0KIApAQCAtODM0LDYgKzk1NSwxODUgQEAKICNlbmRpZgogfQogCitzdHJ1Y3QgbWlwc19odWdlX3RsYl9pbmZvIHsKKwlpbnQgaHVnZV9wdGU7CisJaW50IHJlc3RvcmVfc2NyYXRjaDsKK307CisKK3N0YXRpYyBzdHJ1Y3QgbWlwc19odWdlX3RsYl9pbmZvIF9fY3B1aW5pdAorYnVpbGRfZmFzdF90bGJfcmVmaWxsX2hhbmRsZXIgKHUzMiAqKnAsIHN0cnVjdCB1YXNtX2xhYmVsICoqbCwKKwkJCSAgICAgICBzdHJ1Y3QgdWFzbV9yZWxvYyAqKnIsIHVuc2lnbmVkIGludCB0bXAsCisJCQkgICAgICAgdW5zaWduZWQgaW50IHB0ciwgaW50IGMwX3NjcmF0Y2gpCit7CisJc3RydWN0IG1pcHNfaHVnZV90bGJfaW5mbyBydjsKKwl1bnNpZ25lZCBpbnQgZXZlbiwgb2RkOworCWludCB2bWFsbG9jX2JyYW5jaF9kZWxheV9maWxsZWQgPSAwOworCWNvbnN0IGludCBzY3JhdGNoID0gMTsgLyogT3VyIGV4dHJhIHdvcmtpbmcgcmVnaXN0ZXIgKi8KKworCXJ2Lmh1Z2VfcHRlID0gc2NyYXRjaDsKKwlydi5yZXN0b3JlX3NjcmF0Y2ggPSAwOworCisJaWYgKGNoZWNrX2Zvcl9oaWdoX3NlZ2JpdHMpIHsKKwkJVUFTTV9pX01GQzAocCwgdG1wLCBDMF9CQURWQUREUik7CisKKwkJaWYgKHBnZF9yZWcgIT0gLTEpCisJCQlVQVNNX2lfTUZDMChwLCBwdHIsIDMxLCBwZ2RfcmVnKTsKKwkJZWxzZQorCQkJVUFTTV9pX01GQzAocCwgcHRyLCBDMF9DT05URVhUKTsKKworCQlpZiAoYzBfc2NyYXRjaCA+PSAwKQorCQkJVUFTTV9pX01UQzAocCwgc2NyYXRjaCwgMzEsIGMwX3NjcmF0Y2gpOworCQllbHNlCisJCQlVQVNNX2lfU1cocCwgc2NyYXRjaCwgc2NyYXRjaHBhZF9vZmZzZXQoMCksIDApOworCisJCXVhc21faV9kc3JsX3NhZmUocCwgc2NyYXRjaCwgdG1wLAorCQkJCSBQR0RJUl9TSElGVCArIFBHRF9PUkRFUiArIFBBR0VfU0hJRlQgLSAzKTsKKwkJdWFzbV9pbF9ibmV6KHAsIHIsIHNjcmF0Y2gsIGxhYmVsX3ZtYWxsb2MpOworCisJCWlmIChwZ2RfcmVnID09IC0xKSB7CisJCQl2bWFsbG9jX2JyYW5jaF9kZWxheV9maWxsZWQgPSAxOworCQkJLyogQ2xlYXIgbG93ZXIgMjMgYml0cyBvZiBjb250ZXh0LiAqLworCQkJdWFzbV9pX2RpbnMocCwgcHRyLCAwLCAwLCAyMyk7CisJCX0KKwl9IGVsc2UgeworCQlpZiAocGdkX3JlZyAhPSAtMSkKKwkJCVVBU01faV9NRkMwKHAsIHB0ciwgMzEsIHBnZF9yZWcpOworCQllbHNlCisJCQlVQVNNX2lfTUZDMChwLCBwdHIsIEMwX0NPTlRFWFQpOworCisJCVVBU01faV9NRkMwKHAsIHRtcCwgQzBfQkFEVkFERFIpOworCisJCWlmIChjMF9zY3JhdGNoID49IDApCisJCQlVQVNNX2lfTVRDMChwLCBzY3JhdGNoLCAzMSwgYzBfc2NyYXRjaCk7CisJCWVsc2UKKwkJCVVBU01faV9TVyhwLCBzY3JhdGNoLCBzY3JhdGNocGFkX29mZnNldCgwKSwgMCk7CisKKwkJaWYgKHBnZF9yZWcgPT0gLTEpCisJCQkvKiBDbGVhciBsb3dlciAyMyBiaXRzIG9mIGNvbnRleHQuICovCisJCQl1YXNtX2lfZGlucyhwLCBwdHIsIDAsIDAsIDIzKTsKKworCQl1YXNtX2lsX2JsdHoocCwgciwgdG1wLCBsYWJlbF92bWFsbG9jKTsKKwl9CisKKwlpZiAocGdkX3JlZyA9PSAtMSkgeworCQl2bWFsbG9jX2JyYW5jaF9kZWxheV9maWxsZWQgPSAxOworCQkvKiAxIDAgIDEgMCAxICA8PCA2ICB4a3BoeXMgY2FjaGVkICovCisJCXVhc21faV9vcmkocCwgcHRyLCBwdHIsIDB4NTQwKTsKKwkJdWFzbV9pX2Ryb3RyKHAsIHB0ciwgcHRyLCAxMSk7CisJfQorCisjaWZkZWYgX19QQUdFVEFCTEVfUE1EX0ZPTERFRAorI2RlZmluZSBMT0NfUFRFUCBzY3JhdGNoCisjZWxzZQorI2RlZmluZSBMT0NfUFRFUCBwdHIKKyNlbmRpZgorCisJaWYgKCF2bWFsbG9jX2JyYW5jaF9kZWxheV9maWxsZWQpCisJCS8qIGdldCBwZ2Qgb2Zmc2V0IGluIGJ5dGVzICovCisJCXVhc21faV9kc3JsX3NhZmUocCwgc2NyYXRjaCwgdG1wLCBQR0RJUl9TSElGVCAtIDMpOworCisJdWFzbV9sX3ZtYWxsb2NfZG9uZShsLCAqcCk7CisKKwkvKgorCSAqICAgICAgICAgICAgICAgICAgICAgICAgIHRtcCAgICAgICAgICBwdHIKKwkgKiBmYWxsLXRocm91Z2ggY2FzZSA9ICAgYmFkdmFkZHIgICpwZ2RfY3VycmVudAorCSAqIHZtYWxsb2MgY2FzZSAgICAgID0gICBiYWR2YWRkciAgc3dhcHBlcl9wZ19kaXIKKwkgKi8KKworCWlmICh2bWFsbG9jX2JyYW5jaF9kZWxheV9maWxsZWQpCisJCS8qIGdldCBwZ2Qgb2Zmc2V0IGluIGJ5dGVzICovCisJCXVhc21faV9kc3JsX3NhZmUocCwgc2NyYXRjaCwgdG1wLCBQR0RJUl9TSElGVCAtIDMpOworCisjaWZkZWYgX19QQUdFVEFCTEVfUE1EX0ZPTERFRAorCUdFVF9DT05URVhUKHAsIHRtcCk7IC8qIGdldCBjb250ZXh0IHJlZyAqLworI2VuZGlmCisJdWFzbV9pX2FuZGkocCwgc2NyYXRjaCwgc2NyYXRjaCwgKFBUUlNfUEVSX1BHRCAtIDEpIDw8IDMpOworCisJaWYgKHVzZV9sd3hfaW5zbnMoKSkgeworCQlVQVNNX2lfTFdYKHAsIExPQ19QVEVQLCBzY3JhdGNoLCBwdHIpOworCX0gZWxzZSB7CisJCXVhc21faV9kYWRkdShwLCBwdHIsIHB0ciwgc2NyYXRjaCk7IC8qIGFkZCBpbiBwZ2Qgb2Zmc2V0ICovCisJCXVhc21faV9sZChwLCBMT0NfUFRFUCwgMCwgcHRyKTsgLyogZ2V0IHBtZCBwb2ludGVyICovCisJfQorCisjaWZuZGVmIF9fUEFHRVRBQkxFX1BNRF9GT0xERUQKKwkvKiBnZXQgcG1kIG9mZnNldCBpbiBieXRlcyAqLworCXVhc21faV9kc3JsX3NhZmUocCwgc2NyYXRjaCwgdG1wLCBQTURfU0hJRlQgLSAzKTsKKwl1YXNtX2lfYW5kaShwLCBzY3JhdGNoLCBzY3JhdGNoLCAoUFRSU19QRVJfUE1EIC0gMSkgPDwgMyk7CisJR0VUX0NPTlRFWFQocCwgdG1wKTsgLyogZ2V0IGNvbnRleHQgcmVnICovCisKKwlpZiAodXNlX2x3eF9pbnNucygpKSB7CisJCVVBU01faV9MV1gocCwgc2NyYXRjaCwgc2NyYXRjaCwgcHRyKTsKKwl9IGVsc2UgeworCQl1YXNtX2lfZGFkZHUocCwgcHRyLCBwdHIsIHNjcmF0Y2gpOyAvKiBhZGQgaW4gcG1kIG9mZnNldCAqLworCQlVQVNNX2lfTFcocCwgc2NyYXRjaCwgMCwgcHRyKTsKKwl9CisjZW5kaWYKKwkvKiBBZGp1c3QgdGhlIGNvbnRleHQgZHVyaW5nIHRoZSBsb2FkIGxhdGVuY3kuICovCisJYnVpbGRfYWRqdXN0X2NvbnRleHQocCwgdG1wKTsKKworI2lmZGVmIENPTkZJR19IVUdFVExCX1BBR0UKKwl1YXNtX2lsX2JiaXQxKHAsIHIsIHNjcmF0Y2gsIGlsb2cyKF9QQUdFX0hVR0UpLCBsYWJlbF90bGJfaHVnZV91cGRhdGUpOworCS8qCisJICogVGhlIGluIHRoZSBMV1ggY2FzZSB3ZSBkb24ndCB3YW50IHRvIGRvIHRoZSBsb2FkIGluIHRoZQorCSAqIGRlbGF5IHNsb3QuICBJdCBjYW5ub3QgaXNzdWUgaW4gdGhlIHNhbWUgY3ljbGUgYW5kIG1heSBiZQorCSAqIHNwZWN1bGF0aXZlIGFuZCB1bm5lZWRlZC4KKwkgKi8KKwlpZiAodXNlX2x3eF9pbnNucygpKQorCQl1YXNtX2lfbm9wKHApOworI2VuZGlmIC8qIENPTkZJR19IVUdFVExCX1BBR0UgKi8KKworCisJLyogYnVpbGRfdXBkYXRlX2VudHJpZXMgKi8KKwlpZiAodXNlX2x3eF9pbnNucygpKSB7CisJCWV2ZW4gPSBwdHI7CisJCW9kZCA9IHRtcDsKKwkJVUFTTV9pX0xXWChwLCBldmVuLCBzY3JhdGNoLCB0bXApOworCQlVQVNNX2lfQURESVUocCwgdG1wLCB0bXAsIHNpemVvZihwdGVfdCkpOworCQlVQVNNX2lfTFdYKHAsIG9kZCwgc2NyYXRjaCwgdG1wKTsKKwl9IGVsc2UgeworCQlVQVNNX2lfQUREVShwLCBwdHIsIHNjcmF0Y2gsIHRtcCk7IC8qIGFkZCBpbiBvZmZzZXQgKi8KKwkJZXZlbiA9IHRtcDsKKwkJb2RkID0gcHRyOworCQlVQVNNX2lfTFcocCwgZXZlbiwgMCwgcHRyKTsgLyogZ2V0IGV2ZW4gcHRlICovCisJCVVBU01faV9MVyhwLCBvZGQsIHNpemVvZihwdGVfdCksIHB0cik7IC8qIGdldCBvZGQgcHRlICovCisJfQorCWlmIChrZXJuZWxfdXNlc19zbWFydG1pcHNfcml4aSkgeworCQl1YXNtX2lfZHNybF9zYWZlKHAsIGV2ZW4sIGV2ZW4sIGlsb2cyKF9QQUdFX05PX0VYRUMpKTsKKwkJdWFzbV9pX2Rzcmxfc2FmZShwLCBvZGQsIG9kZCwgaWxvZzIoX1BBR0VfTk9fRVhFQykpOworCQl1YXNtX2lfZHJvdHIocCwgZXZlbiwgZXZlbiwKKwkJCSAgICAgaWxvZzIoX1BBR0VfR0xPQkFMKSAtIGlsb2cyKF9QQUdFX05PX0VYRUMpKTsKKwkJVUFTTV9pX01UQzAocCwgZXZlbiwgQzBfRU5UUllMTzApOyAvKiBsb2FkIGl0ICovCisJCXVhc21faV9kcm90cihwLCBvZGQsIG9kZCwKKwkJCSAgICAgaWxvZzIoX1BBR0VfR0xPQkFMKSAtIGlsb2cyKF9QQUdFX05PX0VYRUMpKTsKKwl9IGVsc2UgeworCQl1YXNtX2lfZHNybF9zYWZlKHAsIGV2ZW4sIGV2ZW4sIGlsb2cyKF9QQUdFX0dMT0JBTCkpOworCQlVQVNNX2lfTVRDMChwLCBldmVuLCBDMF9FTlRSWUxPMCk7IC8qIGxvYWQgaXQgKi8KKwkJdWFzbV9pX2Rzcmxfc2FmZShwLCBvZGQsIG9kZCwgaWxvZzIoX1BBR0VfR0xPQkFMKSk7CisJfQorCVVBU01faV9NVEMwKHAsIG9kZCwgQzBfRU5UUllMTzEpOyAvKiBsb2FkIGl0ICovCisKKwlpZiAoYzBfc2NyYXRjaCA+PSAwKSB7CisJCVVBU01faV9NRkMwKHAsIHNjcmF0Y2gsIDMxLCBjMF9zY3JhdGNoKTsKKwkJYnVpbGRfdGxiX3dyaXRlX2VudHJ5KHAsIGwsIHIsIHRsYl9yYW5kb20pOworCQl1YXNtX2xfbGVhdmUobCwgKnApOworCQlydi5yZXN0b3JlX3NjcmF0Y2ggPSAxOworCX0gZWxzZSBpZiAoUEFHRV9TSElGVCA9PSAxNCB8fCBQQUdFX1NISUZUID09IDEzKSAgeworCQlidWlsZF90bGJfd3JpdGVfZW50cnkocCwgbCwgciwgdGxiX3JhbmRvbSk7CisJCXVhc21fbF9sZWF2ZShsLCAqcCk7CisJCVVBU01faV9MVyhwLCBzY3JhdGNoLCBzY3JhdGNocGFkX29mZnNldCgwKSwgMCk7CisJfSBlbHNlIHsKKwkJVUFTTV9pX0xXKHAsIHNjcmF0Y2gsIHNjcmF0Y2hwYWRfb2Zmc2V0KDApLCAwKTsKKwkJYnVpbGRfdGxiX3dyaXRlX2VudHJ5KHAsIGwsIHIsIHRsYl9yYW5kb20pOworCQl1YXNtX2xfbGVhdmUobCwgKnApOworCQlydi5yZXN0b3JlX3NjcmF0Y2ggPSAxOworCX0KKworCXVhc21faV9lcmV0KHApOyAvKiByZXR1cm4gZnJvbSB0cmFwICovCisKKwlyZXR1cm4gcnY7Cit9CisKIC8qCiAgKiBGb3IgYSA2NC1iaXQga2VybmVsLCB3ZSBhcmUgdXNpbmcgdGhlIDY0LWJpdCBYVExCIHJlZmlsbCBleGNlcHRpb24KICAqIGJlY2F1c2UgRVhMID09IDAuICBJZiB3ZSB3cmFwLCB3ZSBjYW4gYWxzbyB1c2UgdGhlIDMyIGluc3RydWN0aW9uCkBAIC04NDksNTQgKzExNDksNjcgQEAKIAlzdHJ1Y3QgdWFzbV9yZWxvYyAqciA9IHJlbG9jczsKIAl1MzIgKmY7CiAJdW5zaWduZWQgaW50IGZpbmFsX2xlbjsKKwlzdHJ1Y3QgbWlwc19odWdlX3RsYl9pbmZvIGh0bGJfaW5mbzsKKwllbnVtIHZtYWxsb2M2NF9tb2RlIHZtYWxsb2NfbW9kZTsKIAogCW1lbXNldCh0bGJfaGFuZGxlciwgMCwgc2l6ZW9mKHRsYl9oYW5kbGVyKSk7CiAJbWVtc2V0KGxhYmVscywgMCwgc2l6ZW9mKGxhYmVscykpOwogCW1lbXNldChyZWxvY3MsIDAsIHNpemVvZihyZWxvY3MpKTsKIAltZW1zZXQoZmluYWxfaGFuZGxlciwgMCwgc2l6ZW9mKGZpbmFsX2hhbmRsZXIpKTsKIAotCS8qCi0JICogY3JlYXRlIHRoZSBwbGFpbiBsaW5lYXIgaGFuZGxlcgotCSAqLwotCWlmIChiY20xMjUwX20zX3dhcigpKSB7Ci0JCXVuc2lnbmVkIGludCBzZWdiaXRzID0gNDQ7CisJaWYgKHNjcmF0Y2hfcmVnID09IDApCisJCXNjcmF0Y2hfcmVnID0gYWxsb2NhdGVfa3NjcmF0Y2goKTsKIAotCQl1YXNtX2lfZG1mYzAoJnAsIEswLCBDMF9CQURWQUREUik7Ci0JCXVhc21faV9kbWZjMCgmcCwgSzEsIEMwX0VOVFJZSEkpOwotCQl1YXNtX2lfeG9yKCZwLCBLMCwgSzAsIEsxKTsKLQkJdWFzbV9pX2Rzcmxfc2FmZSgmcCwgSzEsIEswLCA2Mik7Ci0JCXVhc21faV9kc3JsX3NhZmUoJnAsIEswLCBLMCwgMTIgKyAxKTsKLQkJdWFzbV9pX2RzbGxfc2FmZSgmcCwgSzAsIEswLCA2NCArIDEyICsgMSAtIHNlZ2JpdHMpOwotCQl1YXNtX2lfb3IoJnAsIEswLCBLMCwgSzEpOwotCQl1YXNtX2lsX2JuZXooJnAsICZyLCBLMCwgbGFiZWxfbGVhdmUpOwotCQkvKiBObyBuZWVkIGZvciB1YXNtX2lfbm9wICovCi0JfQorCWlmICgoc2NyYXRjaF9yZWcgPiAwIHx8IHNjcmF0Y2hwYWRfYXZhaWxhYmxlKCkpICYmIHVzZV9iYml0X2luc25zKCkpIHsKKwkJaHRsYl9pbmZvID0gYnVpbGRfZmFzdF90bGJfcmVmaWxsX2hhbmRsZXIoJnAsICZsLCAmciwgSzAsIEsxLAorCQkJCQkJCSAgc2NyYXRjaF9yZWcpOworCQl2bWFsbG9jX21vZGUgPSByZWZpbGxfc2NyYXRjaDsKKwl9IGVsc2UgeworCQlodGxiX2luZm8uaHVnZV9wdGUgPSBLMDsKKwkJaHRsYl9pbmZvLnJlc3RvcmVfc2NyYXRjaCA9IDA7CisJCXZtYWxsb2NfbW9kZSA9IHJlZmlsbF9ub3NjcmF0Y2g7CisJCS8qCisJCSAqIGNyZWF0ZSB0aGUgcGxhaW4gbGluZWFyIGhhbmRsZXIKKwkJICovCisJCWlmIChiY20xMjUwX20zX3dhcigpKSB7CisJCQl1bnNpZ25lZCBpbnQgc2VnYml0cyA9IDQ0OworCisJCQl1YXNtX2lfZG1mYzAoJnAsIEswLCBDMF9CQURWQUREUik7CisJCQl1YXNtX2lfZG1mYzAoJnAsIEsxLCBDMF9FTlRSWUhJKTsKKwkJCXVhc21faV94b3IoJnAsIEswLCBLMCwgSzEpOworCQkJdWFzbV9pX2Rzcmxfc2FmZSgmcCwgSzEsIEswLCA2Mik7CisJCQl1YXNtX2lfZHNybF9zYWZlKCZwLCBLMCwgSzAsIDEyICsgMSk7CisJCQl1YXNtX2lfZHNsbF9zYWZlKCZwLCBLMCwgSzAsIDY0ICsgMTIgKyAxIC0gc2VnYml0cyk7CisJCQl1YXNtX2lfb3IoJnAsIEswLCBLMCwgSzEpOworCQkJdWFzbV9pbF9ibmV6KCZwLCAmciwgSzAsIGxhYmVsX2xlYXZlKTsKKwkJCS8qIE5vIG5lZWQgZm9yIHVhc21faV9ub3AgKi8KKwkJfQogCiAjaWZkZWYgQ09ORklHXzY0QklUCi0JYnVpbGRfZ2V0X3BtZGU2NCgmcCwgJmwsICZyLCBLMCwgSzEpOyAvKiBnZXQgcG1kIGluIEsxICovCisJCWJ1aWxkX2dldF9wbWRlNjQoJnAsICZsLCAmciwgSzAsIEsxKTsgLyogZ2V0IHBtZCBpbiBLMSAqLwogI2Vsc2UKLQlidWlsZF9nZXRfcGdkZTMyKCZwLCBLMCwgSzEpOyAvKiBnZXQgcGdkIGluIEsxICovCisJCWJ1aWxkX2dldF9wZ2RlMzIoJnAsIEswLCBLMSk7IC8qIGdldCBwZ2QgaW4gSzEgKi8KICNlbmRpZgogCiAjaWZkZWYgQ09ORklHX0hVR0VUTEJfUEFHRQotCWJ1aWxkX2lzX2h1Z2VfcHRlKCZwLCAmciwgSzAsIEsxLCBsYWJlbF90bGJfaHVnZV91cGRhdGUpOworCQlidWlsZF9pc19odWdlX3B0ZSgmcCwgJnIsIEswLCBLMSwgbGFiZWxfdGxiX2h1Z2VfdXBkYXRlKTsKICNlbmRpZgogCi0JYnVpbGRfZ2V0X3B0ZXAoJnAsIEswLCBLMSk7Ci0JYnVpbGRfdXBkYXRlX2VudHJpZXMoJnAsIEswLCBLMSk7Ci0JYnVpbGRfdGxiX3dyaXRlX2VudHJ5KCZwLCAmbCwgJnIsIHRsYl9yYW5kb20pOwotCXVhc21fbF9sZWF2ZSgmbCwgcCk7Ci0JdWFzbV9pX2VyZXQoJnApOyAvKiByZXR1cm4gZnJvbSB0cmFwICovCi0KKwkJYnVpbGRfZ2V0X3B0ZXAoJnAsIEswLCBLMSk7CisJCWJ1aWxkX3VwZGF0ZV9lbnRyaWVzKCZwLCBLMCwgSzEpOworCQlidWlsZF90bGJfd3JpdGVfZW50cnkoJnAsICZsLCAmciwgdGxiX3JhbmRvbSk7CisJCXVhc21fbF9sZWF2ZSgmbCwgcCk7CisJCXVhc21faV9lcmV0KCZwKTsgLyogcmV0dXJuIGZyb20gdHJhcCAqLworCX0KICNpZmRlZiBDT05GSUdfSFVHRVRMQl9QQUdFCiAJdWFzbV9sX3RsYl9odWdlX3VwZGF0ZSgmbCwgcCk7Ci0JVUFTTV9pX0xXKCZwLCBLMCwgMCwgSzEpOwotCWJ1aWxkX2h1Z2VfdXBkYXRlX2VudHJpZXMoJnAsIEswLCBLMSk7Ci0JYnVpbGRfaHVnZV90bGJfd3JpdGVfZW50cnkoJnAsICZsLCAmciwgSzAsIHRsYl9yYW5kb20pOworCWJ1aWxkX2h1Z2VfdXBkYXRlX2VudHJpZXMoJnAsIGh0bGJfaW5mby5odWdlX3B0ZSwgSzEpOworCWJ1aWxkX2h1Z2VfdGxiX3dyaXRlX2VudHJ5KCZwLCAmbCwgJnIsIEswLCB0bGJfcmFuZG9tLAorCQkJCSAgIGh0bGJfaW5mby5yZXN0b3JlX3NjcmF0Y2gpOwogI2VuZGlmCiAKICNpZmRlZiBDT05GSUdfNjRCSVQKLQlidWlsZF9nZXRfcGdkX3ZtYWxsb2M2NCgmcCwgJmwsICZyLCBLMCwgSzEsIHJlZmlsbCk7CisJYnVpbGRfZ2V0X3BnZF92bWFsbG9jNjQoJnAsICZsLCAmciwgSzAsIEsxLCB2bWFsbG9jX21vZGUpOwogI2VuZGlmCiAKIAkvKgpAQCAtMTAxNCw2ICsxMzI3LDU1IEBACiB1MzIgaGFuZGxlX3RsYmxbRkFTVFBBVEhfU0laRV0gX19jYWNoZWxpbmVfYWxpZ25lZDsKIHUzMiBoYW5kbGVfdGxic1tGQVNUUEFUSF9TSVpFXSBfX2NhY2hlbGluZV9hbGlnbmVkOwogdTMyIGhhbmRsZV90bGJtW0ZBU1RQQVRIX1NJWkVdIF9fY2FjaGVsaW5lX2FsaWduZWQ7CisjaWZkZWYgQ09ORklHX01JUFNfUEdEX0MwX0NPTlRFWFQKK3UzMiB0bGJtaXNzX2hhbmRsZXJfc2V0dXBfcGdkWzE2XSBfX2NhY2hlbGluZV9hbGlnbmVkOworCitzdGF0aWMgdm9pZCBfX2NwdWluaXQgYnVpbGRfcjQwMDBfc2V0dXBfcGdkKHZvaWQpCit7CisJY29uc3QgaW50IGEwID0gNDsKKwljb25zdCBpbnQgYTEgPSA1OworCXUzMiAqcCA9IHRsYm1pc3NfaGFuZGxlcl9zZXR1cF9wZ2Q7CisJc3RydWN0IHVhc21fbGFiZWwgKmwgPSBsYWJlbHM7CisJc3RydWN0IHVhc21fcmVsb2MgKnIgPSByZWxvY3M7CisKKwltZW1zZXQodGxibWlzc19oYW5kbGVyX3NldHVwX3BnZCwgMCwgc2l6ZW9mKHRsYm1pc3NfaGFuZGxlcl9zZXR1cF9wZ2QpKTsKKwltZW1zZXQobGFiZWxzLCAwLCBzaXplb2YobGFiZWxzKSk7CisJbWVtc2V0KHJlbG9jcywgMCwgc2l6ZW9mKHJlbG9jcykpOworCisJcGdkX3JlZyA9IGFsbG9jYXRlX2tzY3JhdGNoKCk7CisKKwlpZiAocGdkX3JlZyA9PSAtMSkgeworCQkvKiBQR0QgPDwgMTEgaW4gYzBfQ29udGV4dCAqLworCQkvKgorCQkgKiBJZiBpdCBpcyBhIGNrc2VnMCBhZGRyZXNzLCBjb252ZXJ0IHRvIGEgcGh5c2ljYWwKKwkJICogYWRkcmVzcy4gIFNoaWZ0aW5nIHJpZ2h0IGJ5IDI5IGFuZCBhZGRpbmcgNCB3aWxsCisJCSAqIHJlc3VsdCBpbiB6ZXJvIGZvciB0aGVzZSBhZGRyZXNzZXMuCisJCSAqCisJCSAqLworCQlVQVNNX2lfU1JBKCZwLCBhMSwgYTAsIDI5KTsKKwkJVUFTTV9pX0FERElVKCZwLCBhMSwgYTEsIDQpOworCQl1YXNtX2lsX2JuZXooJnAsICZyLCBhMSwgbGFiZWxfdGxibF9nb2Fyb3VuZDEpOworCQl1YXNtX2lfbm9wKCZwKTsKKwkJdWFzbV9pX2RpbnNtKCZwLCBhMCwgMCwgMjksIDY0IC0gMjkpOworCQl1YXNtX2xfdGxibF9nb2Fyb3VuZDEoJmwsIHApOworCQlVQVNNX2lfU0xMKCZwLCBhMCwgYTAsIDExKTsKKwkJdWFzbV9pX2pyKCZwLCAzMSk7CisJCVVBU01faV9NVEMwKCZwLCBhMCwgQzBfQ09OVEVYVCk7CisJfSBlbHNlIHsKKwkJLyogUEdEIGluIGMwX0tTY3JhdGNoICovCisJCXVhc21faV9qcigmcCwgMzEpOworCQlVQVNNX2lfTVRDMCgmcCwgYTAsIDMxLCBwZ2RfcmVnKTsKKwl9CisJaWYgKHAgLSB0bGJtaXNzX2hhbmRsZXJfc2V0dXBfcGdkID4gQVJSQVlfU0laRSh0bGJtaXNzX2hhbmRsZXJfc2V0dXBfcGdkKSkKKwkJcGFuaWMoInRsYm1pc3NfaGFuZGxlcl9zZXR1cF9wZ2Qgc3BhY2UgZXhjZWVkZWQiKTsKKwl1YXNtX3Jlc29sdmVfcmVsb2NzKHJlbG9jcywgbGFiZWxzKTsKKwlwcl9kZWJ1ZygiV3JvdGUgdGxibWlzc19oYW5kbGVyX3NldHVwX3BnZCAoJXUgaW5zdHJ1Y3Rpb25zKS5cbiIsCisJCSAodW5zaWduZWQgaW50KShwIC0gdGxibWlzc19oYW5kbGVyX3NldHVwX3BnZCkpOworCisJZHVtcF9oYW5kbGVyKHRsYm1pc3NfaGFuZGxlcl9zZXR1cF9wZ2QsCisJCSAgICAgQVJSQVlfU0laRSh0bGJtaXNzX2hhbmRsZXJfc2V0dXBfcGdkKSk7Cit9CisjZW5kaWYKIAogc3RhdGljIHZvaWQgX19jcHVpbml0CiBpUFRFX0xXKHUzMiAqKnAsIHVuc2lnbmVkIGludCBwdGUsIHVuc2lnbmVkIGludCBwdHIpCkBAIC0xMTAwLDE0ICsxNDYyLDIwIEBACiAJCSAgdW5zaWduZWQgaW50IHB0ZSwgdW5zaWduZWQgaW50IHB0ciwgZW51bSBsYWJlbF9pZCBsaWQpCiB7CiAJaWYgKGtlcm5lbF91c2VzX3NtYXJ0bWlwc19yaXhpKSB7Ci0JCXVhc21faV9hbmRpKHAsIHB0ZSwgcHRlLCBfUEFHRV9QUkVTRU5UKTsKLQkJdWFzbV9pbF9iZXF6KHAsIHIsIHB0ZSwgbGlkKTsKKwkJaWYgKHVzZV9iYml0X2luc25zKCkpIHsKKwkJCXVhc21faWxfYmJpdDAocCwgciwgcHRlLCBpbG9nMihfUEFHRV9QUkVTRU5UKSwgbGlkKTsKKwkJCXVhc21faV9ub3AocCk7CisJCX0gZWxzZSB7CisJCQl1YXNtX2lfYW5kaShwLCBwdGUsIHB0ZSwgX1BBR0VfUFJFU0VOVCk7CisJCQl1YXNtX2lsX2JlcXoocCwgciwgcHRlLCBsaWQpOworCQkJaVBURV9MVyhwLCBwdGUsIHB0cik7CisJCX0KIAl9IGVsc2UgewogCQl1YXNtX2lfYW5kaShwLCBwdGUsIHB0ZSwgX1BBR0VfUFJFU0VOVCB8IF9QQUdFX1JFQUQpOwogCQl1YXNtX2lfeG9yaShwLCBwdGUsIHB0ZSwgX1BBR0VfUFJFU0VOVCB8IF9QQUdFX1JFQUQpOwogCQl1YXNtX2lsX2JuZXoocCwgciwgcHRlLCBsaWQpOworCQlpUFRFX0xXKHAsIHB0ZSwgcHRyKTsKIAl9Ci0JaVBURV9MVyhwLCBwdGUsIHB0cik7CiB9CiAKIC8qIE1ha2UgUFRFIHZhbGlkLCBzdG9yZSByZXN1bHQgaW4gUFRSLiAqLwpAQCAtMTEyOCwxMCArMTQ5NiwxNyBAQAogYnVpbGRfcHRlX3dyaXRhYmxlKHUzMiAqKnAsIHN0cnVjdCB1YXNtX3JlbG9jICoqciwKIAkJICAgdW5zaWduZWQgaW50IHB0ZSwgdW5zaWduZWQgaW50IHB0ciwgZW51bSBsYWJlbF9pZCBsaWQpCiB7Ci0JdWFzbV9pX2FuZGkocCwgcHRlLCBwdGUsIF9QQUdFX1BSRVNFTlQgfCBfUEFHRV9XUklURSk7Ci0JdWFzbV9pX3hvcmkocCwgcHRlLCBwdGUsIF9QQUdFX1BSRVNFTlQgfCBfUEFHRV9XUklURSk7Ci0JdWFzbV9pbF9ibmV6KHAsIHIsIHB0ZSwgbGlkKTsKLQlpUFRFX0xXKHAsIHB0ZSwgcHRyKTsKKwlpZiAodXNlX2JiaXRfaW5zbnMoKSkgeworCQl1YXNtX2lsX2JiaXQwKHAsIHIsIHB0ZSwgaWxvZzIoX1BBR0VfUFJFU0VOVCksIGxpZCk7CisJCXVhc21faV9ub3AocCk7CisJCXVhc21faWxfYmJpdDAocCwgciwgcHRlLCBpbG9nMihfUEFHRV9XUklURSksIGxpZCk7CisJCXVhc21faV9ub3AocCk7CisJfSBlbHNlIHsKKwkJdWFzbV9pX2FuZGkocCwgcHRlLCBwdGUsIF9QQUdFX1BSRVNFTlQgfCBfUEFHRV9XUklURSk7CisJCXVhc21faV94b3JpKHAsIHB0ZSwgcHRlLCBfUEFHRV9QUkVTRU5UIHwgX1BBR0VfV1JJVEUpOworCQl1YXNtX2lsX2JuZXoocCwgciwgcHRlLCBsaWQpOworCQlpUFRFX0xXKHAsIHB0ZSwgcHRyKTsKKwl9CiB9CiAKIC8qIE1ha2UgUFRFIHdyaXRhYmxlLCB1cGRhdGUgc29mdHdhcmUgc3RhdHVzIGJpdHMgYXMgd2VsbCwgdGhlbiBzdG9yZQpAQCAtMTE1NSwxMiArMTUzMCwxOSBAQAogYnVpbGRfcHRlX21vZGlmaWFibGUodTMyICoqcCwgc3RydWN0IHVhc21fcmVsb2MgKipyLAogCQkgICAgIHVuc2lnbmVkIGludCBwdGUsIHVuc2lnbmVkIGludCBwdHIsIGVudW0gbGFiZWxfaWQgbGlkKQogewotCXVhc21faV9hbmRpKHAsIHB0ZSwgcHRlLCBfUEFHRV9XUklURSk7Ci0JdWFzbV9pbF9iZXF6KHAsIHIsIHB0ZSwgbGlkKTsKLQlpUFRFX0xXKHAsIHB0ZSwgcHRyKTsKKwlpZiAodXNlX2JiaXRfaW5zbnMoKSkgeworCQl1YXNtX2lsX2JiaXQwKHAsIHIsIHB0ZSwgaWxvZzIoX1BBR0VfV1JJVEUpLCBsaWQpOworCQl1YXNtX2lfbm9wKHApOworCX0gZWxzZSB7CisJCXVhc21faV9hbmRpKHAsIHB0ZSwgcHRlLCBfUEFHRV9XUklURSk7CisJCXVhc21faWxfYmVxeihwLCByLCBwdGUsIGxpZCk7CisJCWlQVEVfTFcocCwgcHRlLCBwdHIpOworCX0KIH0KIAogI2lmbmRlZiBDT05GSUdfTUlQU19QR0RfQzBfQ09OVEVYVAorCisKIC8qCiAgKiBSMzAwMCBzdHlsZSBUTEIgbG9hZC9zdG9yZS9tb2RpZnkgaGFuZGxlcnMuCiAgKi8KQEAgLTE0MDIsMTQgKzE3ODQsMjMgQEAKIAkJICogSWYgdGhlIHBhZ2UgaXMgbm90IF9QQUdFX1ZBTElELCBSSSBvciBYSSBjb3VsZCBub3QKIAkJICogaGF2ZSB0cmlnZ2VyZWQgaXQuICBTa2lwIHRoZSBleHBlbnNpdmUgdGVzdC4uCiAJCSAqLwotCQl1YXNtX2lfYW5kaSgmcCwgSzAsIEswLCBfUEFHRV9WQUxJRCk7Ci0JCXVhc21faWxfYmVxeigmcCwgJnIsIEswLCBsYWJlbF90bGJsX2dvYXJvdW5kMSk7CisJCWlmICh1c2VfYmJpdF9pbnNucygpKSB7CisJCQl1YXNtX2lsX2JiaXQwKCZwLCAmciwgSzAsIGlsb2cyKF9QQUdFX1ZBTElEKSwKKwkJCQkgICAgICBsYWJlbF90bGJsX2dvYXJvdW5kMSk7CisJCX0gZWxzZSB7CisJCQl1YXNtX2lfYW5kaSgmcCwgSzAsIEswLCBfUEFHRV9WQUxJRCk7CisJCQl1YXNtX2lsX2JlcXooJnAsICZyLCBLMCwgbGFiZWxfdGxibF9nb2Fyb3VuZDEpOworCQl9CiAJCXVhc21faV9ub3AoJnApOwogCiAJCXVhc21faV90bGJyKCZwKTsKIAkJLyogRXhhbWluZSAgZW50cnlsbyAwIG9yIDEgYmFzZWQgb24gcHRyLiAqLwotCQl1YXNtX2lfYW5kaSgmcCwgSzAsIEsxLCBzaXplb2YocHRlX3QpKTsKLQkJdWFzbV9pX2JlcXooJnAsIEswLCA4KTsKKwkJaWYgKHVzZV9iYml0X2luc25zKCkpIHsKKwkJCXVhc21faV9iYml0MCgmcCwgSzEsIGlsb2cyKHNpemVvZihwdGVfdCkpLCA4KTsKKwkJfSBlbHNlIHsKKwkJCXVhc21faV9hbmRpKCZwLCBLMCwgSzEsIHNpemVvZihwdGVfdCkpOworCQkJdWFzbV9pX2JlcXooJnAsIEswLCA4KTsKKwkJfQogCiAJCVVBU01faV9NRkMwKCZwLCBLMCwgQzBfRU5UUllMTzApOyAvKiBsb2FkIGl0IGluIHRoZSBkZWxheSBzbG90Ki8KIAkJVUFTTV9pX01GQzAoJnAsIEswLCBDMF9FTlRSWUxPMSk7IC8qIGxvYWQgaXQgaWYgcHRyIGlzIG9kZCAqLwpAQCAtMTQxNywxMiArMTgwOCwxOCBAQAogCQkgKiBJZiB0aGUgZW50cnlMbyAobm93IGluIEswKSBpcyB2YWxpZCAoYml0IDEpLCBSSSBvcgogCQkgKiBYSSBtdXN0IGhhdmUgdHJpZ2dlcmVkIGl0LgogCQkgKi8KLQkJdWFzbV9pX2FuZGkoJnAsIEswLCBLMCwgMik7Ci0JCXVhc21faWxfYm5leigmcCwgJnIsIEswLCBsYWJlbF9ub3BhZ2VfdGxibCk7Ci0KLQkJdWFzbV9sX3RsYmxfZ29hcm91bmQxKCZsLCBwKTsKLQkJLyogUmVsb2FkIHRoZSBQVEUgdmFsdWUgKi8KLQkJaVBURV9MVygmcCwgSzAsIEsxKTsKKwkJaWYgKHVzZV9iYml0X2luc25zKCkpIHsKKwkJCXVhc21faWxfYmJpdDEoJnAsICZyLCBLMCwgMSwgbGFiZWxfbm9wYWdlX3RsYmwpOworCQkJLyogUmVsb2FkIHRoZSBQVEUgdmFsdWUgKi8KKwkJCWlQVEVfTFcoJnAsIEswLCBLMSk7CisJCQl1YXNtX2xfdGxibF9nb2Fyb3VuZDEoJmwsIHApOworCQl9IGVsc2UgeworCQkJdWFzbV9pX2FuZGkoJnAsIEswLCBLMCwgMik7CisJCQl1YXNtX2lsX2JuZXooJnAsICZyLCBLMCwgbGFiZWxfbm9wYWdlX3RsYmwpOworCQkJdWFzbV9sX3RsYmxfZ29hcm91bmQxKCZsLCBwKTsKKwkJCS8qIFJlbG9hZCB0aGUgUFRFIHZhbHVlICovCisJCQlpUFRFX0xXKCZwLCBLMCwgSzEpOworCQl9CiAJfQogCWJ1aWxkX21ha2VfdmFsaWQoJnAsICZyLCBLMCwgSzEpOwogCWJ1aWxkX3I0MDAwX3RsYmNoYW5nZV9oYW5kbGVyX3RhaWwoJnAsICZsLCAmciwgSzAsIEsxKTsKQEAgLTE0NDIsMjMgKzE4MzksMzUgQEAKIAkJICogSWYgdGhlIHBhZ2UgaXMgbm90IF9QQUdFX1ZBTElELCBSSSBvciBYSSBjb3VsZCBub3QKIAkJICogaGF2ZSB0cmlnZ2VyZWQgaXQuICBTa2lwIHRoZSBleHBlbnNpdmUgdGVzdC4uCiAJCSAqLwotCQl1YXNtX2lfYW5kaSgmcCwgSzAsIEswLCBfUEFHRV9WQUxJRCk7Ci0JCXVhc21faWxfYmVxeigmcCwgJnIsIEswLCBsYWJlbF90bGJsX2dvYXJvdW5kMik7CisJCWlmICh1c2VfYmJpdF9pbnNucygpKSB7CisJCQl1YXNtX2lsX2JiaXQwKCZwLCAmciwgSzAsIGlsb2cyKF9QQUdFX1ZBTElEKSwKKwkJCQkgICAgICBsYWJlbF90bGJsX2dvYXJvdW5kMik7CisJCX0gZWxzZSB7CisJCQl1YXNtX2lfYW5kaSgmcCwgSzAsIEswLCBfUEFHRV9WQUxJRCk7CisJCQl1YXNtX2lsX2JlcXooJnAsICZyLCBLMCwgbGFiZWxfdGxibF9nb2Fyb3VuZDIpOworCQl9CiAJCXVhc21faV9ub3AoJnApOwogCiAJCXVhc21faV90bGJyKCZwKTsKIAkJLyogRXhhbWluZSAgZW50cnlsbyAwIG9yIDEgYmFzZWQgb24gcHRyLiAqLwotCQl1YXNtX2lfYW5kaSgmcCwgSzAsIEsxLCBzaXplb2YocHRlX3QpKTsKLQkJdWFzbV9pX2JlcXooJnAsIEswLCA4KTsKLQorCQlpZiAodXNlX2JiaXRfaW5zbnMoKSkgeworCQkJdWFzbV9pX2JiaXQwKCZwLCBLMSwgaWxvZzIoc2l6ZW9mKHB0ZV90KSksIDgpOworCQl9IGVsc2UgeworCQkJdWFzbV9pX2FuZGkoJnAsIEswLCBLMSwgc2l6ZW9mKHB0ZV90KSk7CisJCQl1YXNtX2lfYmVxeigmcCwgSzAsIDgpOworCQl9CiAJCVVBU01faV9NRkMwKCZwLCBLMCwgQzBfRU5UUllMTzApOyAvKiBsb2FkIGl0IGluIHRoZSBkZWxheSBzbG90Ki8KIAkJVUFTTV9pX01GQzAoJnAsIEswLCBDMF9FTlRSWUxPMSk7IC8qIGxvYWQgaXQgaWYgcHRyIGlzIG9kZCAqLwogCQkvKgogCQkgKiBJZiB0aGUgZW50cnlMbyAobm93IGluIEswKSBpcyB2YWxpZCAoYml0IDEpLCBSSSBvcgogCQkgKiBYSSBtdXN0IGhhdmUgdHJpZ2dlcmVkIGl0LgogCQkgKi8KLQkJdWFzbV9pX2FuZGkoJnAsIEswLCBLMCwgMik7Ci0JCXVhc21faWxfYmVxeigmcCwgJnIsIEswLCBsYWJlbF90bGJsX2dvYXJvdW5kMik7CisJCWlmICh1c2VfYmJpdF9pbnNucygpKSB7CisJCQl1YXNtX2lsX2JiaXQwKCZwLCAmciwgSzAsIDEsIGxhYmVsX3RsYmxfZ29hcm91bmQyKTsKKwkJfSBlbHNlIHsKKwkJCXVhc21faV9hbmRpKCZwLCBLMCwgSzAsIDIpOworCQkJdWFzbV9pbF9iZXF6KCZwLCAmciwgSzAsIGxhYmVsX3RsYmxfZ29hcm91bmQyKTsKKwkJfQogCQkvKiBSZWxvYWQgdGhlIFBURSB2YWx1ZSAqLwogCQlpUFRFX0xXKCZwLCBLMCwgSzEpOwogCkBAIC0xNDY2LDcgKzE4NzUsNyBAQAogCQkgKiBXZSBjbG9iYmVyZWQgQzBfUEFHRU1BU0ssIHJlc3RvcmUgaXQuICBPbiB0aGUgb3RoZXIgYnJhbmNoCiAJCSAqIGl0IGlzIHJlc3RvcmVkIGluIGJ1aWxkX2h1Z2VfdGxiX3dyaXRlX2VudHJ5LgogCQkgKi8KLQkJYnVpbGRfcmVzdG9yZV9wYWdlbWFzaygmcCwgJnIsIEswLCBsYWJlbF9ub3BhZ2VfdGxibCk7CisJCWJ1aWxkX3Jlc3RvcmVfcGFnZW1hc2soJnAsICZyLCBLMCwgbGFiZWxfbm9wYWdlX3RsYmwsIDApOwogCiAJCXVhc21fbF90bGJsX2dvYXJvdW5kMigmbCwgcCk7CiAJfQpAQCAtMTYyMywxMyArMjAzMiwxNiBAQAogCQlicmVhazsKIAogCWRlZmF1bHQ6Ci0JCWJ1aWxkX3I0MDAwX3RsYl9yZWZpbGxfaGFuZGxlcigpOwogCQlpZiAoIXJ1bl9vbmNlKSB7CisjaWZkZWYgQ09ORklHX01JUFNfUEdEX0MwX0NPTlRFWFQKKwkJCWJ1aWxkX3I0MDAwX3NldHVwX3BnZCgpOworI2VuZGlmCiAJCQlidWlsZF9yNDAwMF90bGJfbG9hZF9oYW5kbGVyKCk7CiAJCQlidWlsZF9yNDAwMF90bGJfc3RvcmVfaGFuZGxlcigpOwogCQkJYnVpbGRfcjQwMDBfdGxiX21vZGlmeV9oYW5kbGVyKCk7CiAJCQlydW5fb25jZSsrOwogCQl9CisJCWJ1aWxkX3I0MDAwX3RsYl9yZWZpbGxfaGFuZGxlcigpOwogCX0KIH0KIApAQCAtMTY0MSw0ICsyMDUzLDggQEAKIAkJCSAgICh1bnNpZ25lZCBsb25nKWhhbmRsZV90bGJzICsgc2l6ZW9mKGhhbmRsZV90bGJzKSk7CiAJbG9jYWxfZmx1c2hfaWNhY2hlX3JhbmdlKCh1bnNpZ25lZCBsb25nKWhhbmRsZV90bGJtLAogCQkJICAgKHVuc2lnbmVkIGxvbmcpaGFuZGxlX3RsYm0gKyBzaXplb2YoaGFuZGxlX3RsYm0pKTsKKyNpZmRlZiBDT05GSUdfTUlQU19QR0RfQzBfQ09OVEVYVAorCWxvY2FsX2ZsdXNoX2ljYWNoZV9yYW5nZSgodW5zaWduZWQgbG9uZyl0bGJtaXNzX2hhbmRsZXJfc2V0dXBfcGdkLAorCQkJICAgKHVuc2lnbmVkIGxvbmcpdGxibWlzc19oYW5kbGVyX3NldHVwX3BnZCArIHNpemVvZihoYW5kbGVfdGxibSkpOworI2VuZGlmCiB9CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvbW0vdWFzbS5jIGIvYXJjaC9taXBzL21tL3Vhc20uYwppbmRleCAyM2FmZGViLi41ZmExODUxIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvbW0vdWFzbS5jCisrKyBiL2FyY2gvbWlwcy9tbS91YXNtLmMKQEAgLTY4LDcgKzY4LDggQEAKIAlpbnNuX3ByZWYsIGluc25fcmZlLCBpbnNuX3NjLCBpbnNuX3NjZCwgaW5zbl9zZCwgaW5zbl9zbGwsCiAJaW5zbl9zcmEsIGluc25fc3JsLCBpbnNuX3JvdHIsIGluc25fc3VidSwgaW5zbl9zdywgaW5zbl90bGJwLAogCWluc25fdGxiciwgaW5zbl90bGJ3aSwgaW5zbl90bGJ3ciwgaW5zbl94b3IsIGluc25feG9yaSwKLQlpbnNuX2RpbnMsIGluc25fc3lzY2FsbCwgaW5zbl9iYml0MCwgaW5zbl9iYml0MQorCWluc25fZGlucywgaW5zbl9kaW5zbSwgaW5zbl9zeXNjYWxsLCBpbnNuX2JiaXQwLCBpbnNuX2JiaXQxLAorCWluc25fbHd4LCBpbnNuX2xkeAogfTsKIAogc3RydWN0IGluc24gewpAQCAtMTQyLDkgKzE0MywxMiBAQAogCXsgaW5zbl94b3IsICBNKHNwZWNfb3AsIDAsIDAsIDAsIDAsIHhvcl9vcCksICBSUyB8IFJUIHwgUkQgfSwKIAl7IGluc25feG9yaSwgIE0oeG9yaV9vcCwgMCwgMCwgMCwgMCwgMCksICBSUyB8IFJUIHwgVUlNTSB9LAogCXsgaW5zbl9kaW5zLCBNKHNwZWMzX29wLCAwLCAwLCAwLCAwLCBkaW5zX29wKSwgUlMgfCBSVCB8IFJEIHwgUkUgfSwKKwl7IGluc25fZGluc20sIE0oc3BlYzNfb3AsIDAsIDAsIDAsIDAsIGRpbnNtX29wKSwgUlMgfCBSVCB8IFJEIHwgUkUgfSwKIAl7IGluc25fc3lzY2FsbCwgTShzcGVjX29wLCAwLCAwLCAwLCAwLCBzeXNjYWxsX29wKSwgU0NJTU19LAogCXsgaW5zbl9iYml0MCwgTShsd2MyX29wLCAwLCAwLCAwLCAwLCAwKSwgUlMgfCBSVCB8IEJJTU0gfSwKIAl7IGluc25fYmJpdDEsIE0oc3djMl9vcCwgMCwgMCwgMCwgMCwgMCksIFJTIHwgUlQgfCBCSU1NIH0sCisJeyBpbnNuX2x3eCwgTShzcGVjM19vcCwgMCwgMCwgMCwgbHd4X29wLCBseF9vcCksIFJTIHwgUlQgfCBSRCB9LAorCXsgaW5zbl9sZHgsIE0oc3BlYzNfb3AsIDAsIDAsIDAsIGxkeF9vcCwgbHhfb3ApLCBSUyB8IFJUIHwgUkQgfSwKIAl7IGluc25faW52YWxpZCwgMCwgMCB9CiB9OwogCkBAIC0xNTIsOTEgKzE1Niw4MyBAQAogCiBzdGF0aWMgaW5saW5lIF9fdWFzbWluaXQgdTMyIGJ1aWxkX3JzKHUzMiBhcmcpCiB7Ci0JaWYgKGFyZyAmIH5SU19NQVNLKQotCQlwcmludGsoS0VSTl9XQVJOSU5HICJNaWNyby1hc3NlbWJsZXIgZmllbGQgb3ZlcmZsb3dcbiIpOworCVdBUk4oYXJnICYgflJTX01BU0ssIEtFUk5fV0FSTklORyAiTWljcm8tYXNzZW1ibGVyIGZpZWxkIG92ZXJmbG93XG4iKTsKIAogCXJldHVybiAoYXJnICYgUlNfTUFTSykgPDwgUlNfU0g7CiB9CiAKIHN0YXRpYyBpbmxpbmUgX191YXNtaW5pdCB1MzIgYnVpbGRfcnQodTMyIGFyZykKIHsKLQlpZiAoYXJnICYgflJUX01BU0spCi0JCXByaW50ayhLRVJOX1dBUk5JTkcgIk1pY3JvLWFzc2VtYmxlciBmaWVsZCBvdmVyZmxvd1xuIik7CisJV0FSTihhcmcgJiB+UlRfTUFTSywgS0VSTl9XQVJOSU5HICJNaWNyby1hc3NlbWJsZXIgZmllbGQgb3ZlcmZsb3dcbiIpOwogCiAJcmV0dXJuIChhcmcgJiBSVF9NQVNLKSA8PCBSVF9TSDsKIH0KIAogc3RhdGljIGlubGluZSBfX3Vhc21pbml0IHUzMiBidWlsZF9yZCh1MzIgYXJnKQogewotCWlmIChhcmcgJiB+UkRfTUFTSykKLQkJcHJpbnRrKEtFUk5fV0FSTklORyAiTWljcm8tYXNzZW1ibGVyIGZpZWxkIG92ZXJmbG93XG4iKTsKKwlXQVJOKGFyZyAmIH5SRF9NQVNLLCBLRVJOX1dBUk5JTkcgIk1pY3JvLWFzc2VtYmxlciBmaWVsZCBvdmVyZmxvd1xuIik7CiAKIAlyZXR1cm4gKGFyZyAmIFJEX01BU0spIDw8IFJEX1NIOwogfQogCiBzdGF0aWMgaW5saW5lIF9fdWFzbWluaXQgdTMyIGJ1aWxkX3JlKHUzMiBhcmcpCiB7Ci0JaWYgKGFyZyAmIH5SRV9NQVNLKQotCQlwcmludGsoS0VSTl9XQVJOSU5HICJNaWNyby1hc3NlbWJsZXIgZmllbGQgb3ZlcmZsb3dcbiIpOworCVdBUk4oYXJnICYgflJFX01BU0ssIEtFUk5fV0FSTklORyAiTWljcm8tYXNzZW1ibGVyIGZpZWxkIG92ZXJmbG93XG4iKTsKIAogCXJldHVybiAoYXJnICYgUkVfTUFTSykgPDwgUkVfU0g7CiB9CiAKIHN0YXRpYyBpbmxpbmUgX191YXNtaW5pdCB1MzIgYnVpbGRfc2ltbShzMzIgYXJnKQogewotCWlmIChhcmcgPiAweDdmZmYgfHwgYXJnIDwgLTB4ODAwMCkKLQkJcHJpbnRrKEtFUk5fV0FSTklORyAiTWljcm8tYXNzZW1ibGVyIGZpZWxkIG92ZXJmbG93XG4iKTsKKwlXQVJOKGFyZyA+IDB4N2ZmZiB8fCBhcmcgPCAtMHg4MDAwLAorCSAgICAgS0VSTl9XQVJOSU5HICJNaWNyby1hc3NlbWJsZXIgZmllbGQgb3ZlcmZsb3dcbiIpOwogCiAJcmV0dXJuIGFyZyAmIDB4ZmZmZjsKIH0KIAogc3RhdGljIGlubGluZSBfX3Vhc21pbml0IHUzMiBidWlsZF91aW1tKHUzMiBhcmcpCiB7Ci0JaWYgKGFyZyAmIH5JTU1fTUFTSykKLQkJcHJpbnRrKEtFUk5fV0FSTklORyAiTWljcm8tYXNzZW1ibGVyIGZpZWxkIG92ZXJmbG93XG4iKTsKKwlXQVJOKGFyZyAmIH5JTU1fTUFTSywgS0VSTl9XQVJOSU5HICJNaWNyby1hc3NlbWJsZXIgZmllbGQgb3ZlcmZsb3dcbiIpOwogCiAJcmV0dXJuIGFyZyAmIElNTV9NQVNLOwogfQogCiBzdGF0aWMgaW5saW5lIF9fdWFzbWluaXQgdTMyIGJ1aWxkX2JpbW0oczMyIGFyZykKIHsKLQlpZiAoYXJnID4gMHgxZmZmZiB8fCBhcmcgPCAtMHgyMDAwMCkKLQkJcHJpbnRrKEtFUk5fV0FSTklORyAiTWljcm8tYXNzZW1ibGVyIGZpZWxkIG92ZXJmbG93XG4iKTsKKwlXQVJOKGFyZyA+IDB4MWZmZmYgfHwgYXJnIDwgLTB4MjAwMDAsCisJICAgICBLRVJOX1dBUk5JTkcgIk1pY3JvLWFzc2VtYmxlciBmaWVsZCBvdmVyZmxvd1xuIik7CiAKLQlpZiAoYXJnICYgMHgzKQotCQlwcmludGsoS0VSTl9XQVJOSU5HICJJbnZhbGlkIG1pY3JvLWFzc2VtYmxlciBicmFuY2ggdGFyZ2V0XG4iKTsKKwlXQVJOKGFyZyAmIDB4MywgS0VSTl9XQVJOSU5HICJJbnZhbGlkIG1pY3JvLWFzc2VtYmxlciBicmFuY2ggdGFyZ2V0XG4iKTsKIAogCXJldHVybiAoKGFyZyA8IDApID8gKDEgPDwgMTUpIDogMCkgfCAoKGFyZyA+PiAyKSAmIDB4N2ZmZik7CiB9CiAKIHN0YXRpYyBpbmxpbmUgX191YXNtaW5pdCB1MzIgYnVpbGRfamltbSh1MzIgYXJnKQogewotCWlmIChhcmcgJiB+KChKSU1NX01BU0spIDw8IDIpKQotCQlwcmludGsoS0VSTl9XQVJOSU5HICJNaWNyby1hc3NlbWJsZXIgZmllbGQgb3ZlcmZsb3dcbiIpOworCVdBUk4oYXJnICYgfihKSU1NX01BU0sgPDwgMiksCisJICAgICBLRVJOX1dBUk5JTkcgIk1pY3JvLWFzc2VtYmxlciBmaWVsZCBvdmVyZmxvd1xuIik7CiAKIAlyZXR1cm4gKGFyZyA+PiAyKSAmIEpJTU1fTUFTSzsKIH0KIAogc3RhdGljIGlubGluZSBfX3Vhc21pbml0IHUzMiBidWlsZF9zY2ltbSh1MzIgYXJnKQogewotCWlmIChhcmcgJiB+U0NJTU1fTUFTSykKLQkJcHJpbnRrKEtFUk5fV0FSTklORyAiTWljcm8tYXNzZW1ibGVyIGZpZWxkIG92ZXJmbG93XG4iKTsKKwlXQVJOKGFyZyAmIH5TQ0lNTV9NQVNLLAorCSAgICAgS0VSTl9XQVJOSU5HICJNaWNyby1hc3NlbWJsZXIgZmllbGQgb3ZlcmZsb3dcbiIpOwogCiAJcmV0dXJuIChhcmcgJiBTQ0lNTV9NQVNLKSA8PCBTQ0lNTV9TSDsKIH0KIAogc3RhdGljIGlubGluZSBfX3Vhc21pbml0IHUzMiBidWlsZF9mdW5jKHUzMiBhcmcpCiB7Ci0JaWYgKGFyZyAmIH5GVU5DX01BU0spCi0JCXByaW50ayhLRVJOX1dBUk5JTkcgIk1pY3JvLWFzc2VtYmxlciBmaWVsZCBvdmVyZmxvd1xuIik7CisJV0FSTihhcmcgJiB+RlVOQ19NQVNLLCBLRVJOX1dBUk5JTkcgIk1pY3JvLWFzc2VtYmxlciBmaWVsZCBvdmVyZmxvd1xuIik7CiAKIAlyZXR1cm4gYXJnICYgRlVOQ19NQVNLOwogfQogCiBzdGF0aWMgaW5saW5lIF9fdWFzbWluaXQgdTMyIGJ1aWxkX3NldCh1MzIgYXJnKQogewotCWlmIChhcmcgJiB+U0VUX01BU0spCi0JCXByaW50ayhLRVJOX1dBUk5JTkcgIk1pY3JvLWFzc2VtYmxlciBmaWVsZCBvdmVyZmxvd1xuIik7CisJV0FSTihhcmcgJiB+U0VUX01BU0ssIEtFUk5fV0FSTklORyAiTWljcm8tYXNzZW1ibGVyIGZpZWxkIG92ZXJmbG93XG4iKTsKIAogCXJldHVybiBhcmcgJiBTRVRfTUFTSzsKIH0KQEAgLTM0MCw2ICszMzYsMTMgQEAKIH0JCQkJCQkJXAogVUFTTV9FWFBPUlRfU1lNQk9MKHVhc21faSMjb3ApOwogCisjZGVmaW5lIElfdTJ1MW1zYjMydTMob3ApCQkJCVwKK0lwX3UydTFtc2J1MyhvcCkJCQkJCVwKK3sJCQkJCQkJXAorCWJ1aWxkX2luc24oYnVmLCBpbnNuIyNvcCwgYiwgYSwgYytkLTMzLCBjKTsJXAorfQkJCQkJCQlcCitVQVNNX0VYUE9SVF9TWU1CT0wodWFzbV9pIyNvcCk7CisKICNkZWZpbmUgSV91MXUyKG9wKQkJCQkJXAogSXBfdTF1MihvcCkJCQkJCQlcCiB7CQkJCQkJCVwKQEAgLTQyMiw5ICs0MjUsMTIgQEAKIElfdTN1MXUyKF94b3IpCiBJX3UydTF1MyhfeG9yaSkKIElfdTJ1MW1zYnUzKF9kaW5zKTsKK0lfdTJ1MW1zYjMydTMoX2RpbnNtKTsKIElfdTEoX3N5c2NhbGwpOwogSV91MXUyczMoX2JiaXQwKTsKIElfdTF1MnMzKF9iYml0MSk7CitJX3UzdTF1MihfbHd4KQorSV91M3UxdTIoX2xkeCkKIAogI2lmZGVmIENPTkZJR19DUFVfQ0FWSVVNX09DVEVPTgogI2luY2x1ZGUgPGFzbS9vY3Rlb24vb2N0ZW9uLmg+CmRpZmYgLS1naXQgYS9hcmNoL21pcHMvc2lieXRlL2NvbW1vbi9zYl90YnByb2YuYyBiL2FyY2gvbWlwcy9zaWJ5dGUvY29tbW9uL3NiX3RicHJvZi5jCmluZGV4IDg3Y2NkYjQuLjQ4ODUzYWIgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9zaWJ5dGUvY29tbW9uL3NiX3RicHJvZi5jCisrKyBiL2FyY2gvbWlwcy9zaWJ5dGUvY29tbW9uL3NiX3RicHJvZi5jCkBAIC00MTAsMTQgKzQxMCwxMyBAQAogCQlyZXR1cm4gLUVCVVNZOwogCiAJbWVtc2V0KCZzYnAsIDAsIHNpemVvZihzdHJ1Y3Qgc2Jwcm9mX3RiKSk7Ci0Jc2JwLnNicHJvZl90YmJ1ZiA9IHZtYWxsb2MoTUFYX1RCU0FNUExFX0JZVEVTKTsKKwlzYnAuc2Jwcm9mX3RiYnVmID0gdnphbGxvYyhNQVhfVEJTQU1QTEVfQllURVMpOwogCWlmICghc2JwLnNicHJvZl90YmJ1ZikgewogCQlzYnAub3BlbiA9IFNCX0NMT1NFRDsKIAkJd21iKCk7CiAJCXJldHVybiAtRU5PTUVNOwogCX0KIAotCW1lbXNldChzYnAuc2Jwcm9mX3RiYnVmLCAwLCBNQVhfVEJTQU1QTEVfQllURVMpOwogCWluaXRfd2FpdHF1ZXVlX2hlYWQoJnNicC50Yl9zeW5jKTsKIAlpbml0X3dhaXRxdWV1ZV9oZWFkKCZzYnAudGJfcmVhZCk7CiAJbXV0ZXhfaW5pdCgmc2JwLmxvY2spOwpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL3R4eDkvZ2VuZXJpYy9wY2kuYyBiL2FyY2gvbWlwcy90eHg5L2dlbmVyaWMvcGNpLmMKaW5kZXggOTZlNjlhMC4uODVhODdkZSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL3R4eDkvZ2VuZXJpYy9wY2kuYworKysgYi9hcmNoL21pcHMvdHh4OS9nZW5lcmljL3BjaS5jCkBAIC0yMTMsMTEgKzIxMyw4IEBACiAKIAlwY2ljLT5tZW1fb2Zmc2V0ID0gMDsJLyogYnVzYWRkciA9PSBwaHlzYWRkciAqLwogCi0JcHJpbnRrKEtFUk5fSU5GTyAiUENJOiBJTyAweCUwOGxseC0weCUwOGxseCBNRU0gMHglMDhsbHgtMHglMDhsbHhcbiIsCi0JICAgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpcGNpYy0+bWVtX3Jlc291cmNlWzFdLnN0YXJ0LAotCSAgICAgICAodW5zaWduZWQgbG9uZyBsb25nKXBjaWMtPm1lbV9yZXNvdXJjZVsxXS5lbmQsCi0JICAgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpcGNpYy0+bWVtX3Jlc291cmNlWzBdLnN0YXJ0LAotCSAgICAgICAodW5zaWduZWQgbG9uZyBsb25nKXBjaWMtPm1lbV9yZXNvdXJjZVswXS5lbmQpOworCXByaW50ayhLRVJOX0lORk8gIlBDSTogSU8gJXBSIE1FTSAlcFJcbiIsCisJICAgICAgICZwY2ljLT5tZW1fcmVzb3VyY2VbMV0sICZwY2ljLT5tZW1fcmVzb3VyY2VbMF0pOwogCiAJLyogcmVnaXN0ZXJfcGNpX2NvbnRyb2xsZXIoKSB3aWxsIHJlcXVlc3QgTUVNIHJlc291cmNlICovCiAJcmVsZWFzZV9yZXNvdXJjZSgmcGNpYy0+bWVtX3Jlc291cmNlWzBdKTsKZGlmZiAtLWdpdCBhL2FyY2gvbW4xMDMwMC9LY29uZmlnIGIvYXJjaC9tbjEwMzAwL0tjb25maWcKaW5kZXggOGVkNDFjZi4uMjQzYmZhMiAxMDA2NDQKLS0tIGEvYXJjaC9tbjEwMzAwL0tjb25maWcKKysrIGIvYXJjaC9tbjEwMzAwL0tjb25maWcKQEAgLTEsNiArMSw3IEBACiBjb25maWcgTU4xMDMwMAogCWRlZl9ib29sIHkKIAlzZWxlY3QgSEFWRV9PUFJPRklMRQorCXNlbGVjdCBHRU5FUklDX0hBUkRJUlFTCiAKIGNvbmZpZyBBTTMzXzIKIAlkZWZfYm9vbCBuCkBAIC0zNCw5ICszNSw2IEBACiBjb25maWcgUldTRU1fWENIR0FERF9BTEdPUklUSE0KIAlib29sCiAKLWNvbmZpZyBHRU5FUklDX0hBUkRJUlFTX05PX19ET19JUlEKLQlkZWZfYm9vbCB5Ci0KIGNvbmZpZyBHRU5FUklDX0NBTElCUkFURV9ERUxBWQogCWRlZl9ib29sIHkKIApAQCAtNzksMTAgKzc3LDYgQEAKIGNvbmZpZyBBUkNIX0hBU19JTE9HMl9VMzIKIAlkZWZfYm9vbCB5CiAKLSMgVXNlIHRoZSBnZW5lcmljIGludGVycnVwdCBoYW5kbGluZyBjb2RlIGluIGtlcm5lbC9pcnEvCi1jb25maWcgR0VORVJJQ19IQVJESVJRUwotCWRlZl9ib29sIHkKLQogY29uZmlnIEhPVFBMVUdfQ1BVCiAJZGVmX2Jvb2wgbgogCmRpZmYgLS1naXQgYS9hcmNoL21uMTAzMDAvY29uZmlncy9hc2IyMzAzX2RlZmNvbmZpZyBiL2FyY2gvbW4xMDMwMC9jb25maWdzL2FzYjIzMDNfZGVmY29uZmlnCmluZGV4IDNmNzQ5YjYuLjFmZDQxZWMgMTAwNjQ0Ci0tLSBhL2FyY2gvbW4xMDMwMC9jb25maWdzL2FzYjIzMDNfZGVmY29uZmlnCisrKyBiL2FyY2gvbW4xMDMwMC9jb25maWdzL2FzYjIzMDNfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX1RJTllfUkNVPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX1ZNX0VWRU5UX0NPVU5URVJTIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvbW4xMDMwMC9jb25maWdzL2FzYjIzNjRfZGVmY29uZmlnIGIvYXJjaC9tbjEwMzAwL2NvbmZpZ3MvYXNiMjM2NF9kZWZjb25maWcKaW5kZXggODNjZTJmMi4uMzFkNzYyNiAxMDA2NDQKLS0tIGEvYXJjaC9tbjEwMzAwL2NvbmZpZ3MvYXNiMjM2NF9kZWZjb25maWcKKysrIGIvYXJjaC9tbjEwMzAwL2NvbmZpZ3MvYXNiMjM2NF9kZWZjb25maWcKQEAgLTE1LDcgKzE1LDcgQEAKIENPTkZJR19SRVNPVVJDRV9DT1VOVEVSUz15CiBDT05GSUdfUkVMQVk9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfVk1fRVZFTlRfQ09VTlRFUlMgaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wYXJpc2MvS2NvbmZpZyBiL2FyY2gvcGFyaXNjL0tjb25maWcKaW5kZXggMDg4ODY3NS4uZmVkMjk0NiAxMDA2NDQKLS0tIGEvYXJjaC9wYXJpc2MvS2NvbmZpZworKysgYi9hcmNoL3BhcmlzYy9LY29uZmlnCkBAIC0xMiw3ICsxMiwxMCBAQAogCXNlbGVjdCBIQVZFX0lSUV9XT1JLCiAJc2VsZWN0IEhBVkVfUEVSRl9FVkVOVFMKIAlzZWxlY3QgR0VORVJJQ19BVE9NSUM2NCBpZiAhNjRCSVQKLQlzZWxlY3QgR0VORVJJQ19IQVJESVJRU19OT19fRE9fSVJRCisJc2VsZWN0IEhBVkVfR0VORVJJQ19IQVJESVJRUworCXNlbGVjdCBHRU5FUklDX0lSUV9QUk9CRQorCXNlbGVjdCBJUlFfUEVSX0NQVQorCiAJaGVscAogCSAgVGhlIFBBLVJJU0MgbWljcm9wcm9jZXNzb3IgaXMgZGVzaWduZWQgYnkgSGV3bGV0dC1QYWNrYXJkIGFuZCB1c2VkCiAJICBpbiBtYW55IG9mIHRoZWlyIHdvcmtzdGF0aW9ucyAmIHNlcnZlcnMgKEhQOTAwMCA3MDAgYW5kIDgwMCBzZXJpZXMsCkBAIC02NiwyMiArNjksOSBAQAogCWRlcGVuZHMgb24gU01QCiAJZGVmYXVsdCB5CiAKLWNvbmZpZyBHRU5FUklDX0hBUkRJUlFTCi0JZGVmX2Jvb2wgeQotCi1jb25maWcgR0VORVJJQ19JUlFfUFJPQkUKLQlkZWZfYm9vbCB5Ci0KIGNvbmZpZyBIQVZFX0xBVEVOQ1lUT1BfU1VQUE9SVAogICAgICAgICBkZWZfYm9vbCB5CiAKLWNvbmZpZyBJUlFfUEVSX0NQVQotCWJvb2wKLQlkZWZhdWx0IHkKLQotY29uZmlnIEdFTkVSSUNfSEFSRElSUVNfTk9fX0RPX0lSUQotCWRlZl9ib29sIHkKLQogIyB1bmxlc3MgeW91IHdhbnQgdG8gaW1wbGVtZW50IEFDUEkgb24gUEEtUklTQyAuLi4gOy0pCiBjb25maWcgUE0KIAlib29sCmRpZmYgLS1naXQgYS9hcmNoL3BhcmlzYy9jb25maWdzL2E1MDBfZGVmY29uZmlnIGIvYXJjaC9wYXJpc2MvY29uZmlncy9hNTAwX2RlZmNvbmZpZwppbmRleCBmOTMwNWYzLi5iNjQ3YjE4IDEwMDY0NAotLS0gYS9hcmNoL3BhcmlzYy9jb25maWdzL2E1MDBfZGVmY29uZmlnCisrKyBiL2FyY2gvcGFyaXNjL2NvbmZpZ3MvYTUwMF9kZWZjb25maWcKQEAgLTgsNyArOCw3IEBACiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX0tBTExTWU1TX0FMTD15CiBDT05GSUdfU0xBQj15CiBDT05GSUdfUFJPRklMSU5HPXkKZGlmZiAtLWdpdCBhL2FyY2gvcGFyaXNjL2NvbmZpZ3MvYzMwMDBfZGVmY29uZmlnIGIvYXJjaC9wYXJpc2MvY29uZmlncy9jMzAwMF9kZWZjb25maWcKaW5kZXggNjI4ZDNlMC4uMzExY2EzNiAxMDA2NDQKLS0tIGEvYXJjaC9wYXJpc2MvY29uZmlncy9jMzAwMF9kZWZjb25maWcKKysrIGIvYXJjaC9wYXJpc2MvY29uZmlncy9jMzAwMF9kZWZjb25maWcKQEAgLTYsNyArNiw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNgogQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX0tBTExTWU1TX0FMTD15CiBDT05GSUdfU0xBQj15CiBDT05GSUdfUFJPRklMSU5HPXkKZGlmZiAtLWdpdCBhL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL21tYW4uaCBiL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL21tYW4uaAppbmRleCA5NzQ5YzhhLi5mNWI3YmY1IDEwMDY0NAotLS0gYS9hcmNoL3BhcmlzYy9pbmNsdWRlL2FzbS9tbWFuLmgKKysrIGIvYXJjaC9wYXJpc2MvaW5jbHVkZS9hc20vbW1hbi5oCkBAIC01OSw2ICs1OSw5IEBACiAjZGVmaW5lIE1BRFZfTUVSR0VBQkxFICAgNjUJCS8qIEtTTSBtYXkgbWVyZ2UgaWRlbnRpY2FsIHBhZ2VzICovCiAjZGVmaW5lIE1BRFZfVU5NRVJHRUFCTEUgNjYJCS8qIEtTTSBtYXkgbm90IG1lcmdlIGlkZW50aWNhbCBwYWdlcyAqLwogCisjZGVmaW5lIE1BRFZfSFVHRVBBR0UJNjcJCS8qIFdvcnRoIGJhY2tpbmcgd2l0aCBodWdlcGFnZXMgKi8KKyNkZWZpbmUgTUFEVl9OT0hVR0VQQUdFCTY4CQkvKiBOb3Qgd29ydGggYmFja2luZyB3aXRoIGh1Z2VwYWdlcyAqLworCiAvKiBjb21wYXRpYmlsaXR5IGZsYWdzICovCiAjZGVmaW5lIE1BUF9GSUxFCTAKICNkZWZpbmUgTUFQX1ZBUklBQkxFCTAKZGlmZiAtLWdpdCBhL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL3BndGFibGUuaCBiL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL3BndGFibGUuaAppbmRleCA4NjVmMzdhLi42ZjFmNjVkIDEwMDY0NAotLS0gYS9hcmNoL3BhcmlzYy9pbmNsdWRlL2FzbS9wZ3RhYmxlLmgKKysrIGIvYXJjaC9wYXJpc2MvaW5jbHVkZS9hc20vcGd0YWJsZS5oCkBAIC0xMCwxMSArMTAsMTMgQEAKICAqIHdlIHNpbXVsYXRlIGFuIHg4Ni1zdHlsZSBwYWdlIHRhYmxlIGZvciB0aGUgbGludXggbW0gY29kZQogICovCiAKLSNpbmNsdWRlIDxsaW51eC9tbS5oPgkJLyogZm9yIHZtX2FyZWFfc3RydWN0ICovCiAjaW5jbHVkZSA8bGludXgvYml0b3BzLmg+CisjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KICNpbmNsdWRlIDxhc20vcHJvY2Vzc29yLmg+CiAjaW5jbHVkZSA8YXNtL2NhY2hlLmg+CiAKK3N0cnVjdCB2bV9hcmVhX3N0cnVjdDsKKwogLyoKICAqIGtlcm5fYWRkcl92YWxpZChBRERSKSB0ZXN0cyBpZiBBRERSIGlzIHBvaW50aW5nIHRvIHZhbGlkIGtlcm5lbAogICogbWVtb3J5LiAgRm9yIHRoZSByZXR1cm4gdmFsdWUgdG8gYmUgbWVhbmluZ2Z1bCwgQUREUiBtdXN0IGJlID49CmRpZmYgLS1naXQgYS9hcmNoL3BhcmlzYy9rZXJuZWwvZmlybXdhcmUuYyBiL2FyY2gvcGFyaXNjL2tlcm5lbC9maXJtd2FyZS5jCmluZGV4IGRmOTcxZmEuLjQ4OTZlZDAgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFyaXNjL2tlcm5lbC9maXJtd2FyZS5jCisrKyBiL2FyY2gvcGFyaXNjL2tlcm5lbC9maXJtd2FyZS5jCkBAIC0xMTI2LDE1ICsxMTI2LDEzIEBACiAJdW5zaWduZWQgaW50IGk7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCWZvciAoaSA9IDA7IGkgPCBjb3VudCAmJiBpIDwgNzk7KSB7CisJZm9yIChpID0gMDsgaSA8IGNvdW50OykgewogCQlzd2l0Y2goc3RyW2ldKSB7CiAJCWNhc2UgJ1xuJzoKIAkJCWlvZGNfZGJ1ZltpKzBdID0gJ1xyJzsKIAkJCWlvZGNfZGJ1ZltpKzFdID0gJ1xuJzsKIAkJCWkgKz0gMjsKIAkJCWdvdG8gcHJpbnQ7Ci0JCWNhc2UgJ1xiJzoJLyogQlMgKi8KLQkJCWktLTsgLyogb3ZlcndyaXRlIGxhc3QgKi8KIAkJZGVmYXVsdDoKIAkJCWlvZGNfZGJ1ZltpXSA9IHN0cltpXTsKIAkJCWkrKzsKQEAgLTExNDIsMTUgKzExNDAsNiBAQAogCQl9CiAJfQogCi0JLyogaWYgd2UncmUgYXQgdGhlIGVuZCBvZiBsaW5lLCBhbmQgbm90IGFscmVhZHkgaW5zZXJ0aW5nIGEgbmV3bGluZSwKLQkgKiBpbnNlcnQgb25lIGFueXdheS4gaW9kYyBjb25zb2xlIGRvZXNuJ3QgY2xhaW0gdG8gc3VwcG9ydCA+NzkgY2hhcgotCSAqIGxpbmVzLiBkb24ndCBhY2NvdW50IGZvciB0aGlzIGluIHRoZSByZXR1cm4gdmFsdWUuCi0JICovCi0JaWYgKGkgPT0gNzkgJiYgaW9kY19kYnVmW2ktMV0gIT0gJ1xuJykgewotCQlpb2RjX2RidWZbaSswXSA9ICdccic7Ci0JCWlvZGNfZGJ1ZltpKzFdID0gJ1xuJzsKLQl9Ci0KIHByaW50OgogICAgICAgICBzcGluX2xvY2tfaXJxc2F2ZSgmcGRjX2xvY2ssIGZsYWdzKTsKICAgICAgICAgcmVhbDMyX2NhbGwoUEFHRTAtPm1lbV9jb25zLmlvZGNfaW8sCmRpZmYgLS1naXQgYS9hcmNoL3BhcmlzYy9rZXJuZWwvcGRjX2NvbnMuYyBiL2FyY2gvcGFyaXNjL2tlcm5lbC9wZGNfY29ucy5jCmluZGV4IDExYmRkNjguLmZjNzcwYmUgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFyaXNjL2tlcm5lbC9wZGNfY29ucy5jCisrKyBiL2FyY2gvcGFyaXNjL2tlcm5lbC9wZGNfY29ucy5jCkBAIC0xNjksMTEgKzE2OSwxMSBAQAogCiAJc3RydWN0IGNvbnNvbGUgKnRtcDsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlmb3JfZWFjaF9jb25zb2xlKHRtcCkKIAkJaWYgKHRtcCA9PSAmcGRjX2NvbnMpCiAJCQlicmVhazsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCWlmICghdG1wKSB7CiAJCXByaW50ayhLRVJOX0lORk8gIlBEQyBjb25zb2xlIGRyaXZlciBub3QgcmVnaXN0ZXJlZCBhbnltb3JlLCBub3QgY3JlYXRpbmcgJXNcbiIsIHBkY19jb25zLm5hbWUpOwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL0tjb25maWcgYi9hcmNoL3Bvd2VycGMvS2NvbmZpZwppbmRleCA5NTlmMzhjLi43ZDY5ZTliIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvS2NvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvS2NvbmZpZwpAQCAtMzYsMjQgKzM2LDEyIEBACiBjb25maWcgR0VORVJJQ19DTE9DS0VWRU5UUwogCWRlZl9ib29sIHkKIAotY29uZmlnIEdFTkVSSUNfSEFSRElSUVMKLQlib29sCi0JZGVmYXVsdCB5Ci0KLWNvbmZpZyBHRU5FUklDX0hBUkRJUlFTX05PX19ET19JUlEKLQlib29sCi0JZGVmYXVsdCB5Ci0KIGNvbmZpZyBIQVZFX1NFVFVQX1BFUl9DUFVfQVJFQQogCWRlZl9ib29sIFBQQzY0CiAKIGNvbmZpZyBORUVEX1BFUl9DUFVfRU1CRURfRklSU1RfQ0hVTksKIAlkZWZfYm9vbCBQUEM2NAogCi1jb25maWcgSVJRX1BFUl9DUFUKLQlib29sCi0JZGVmYXVsdCB5Ci0KIGNvbmZpZyBOUl9JUlFTCiAJaW50ICJOdW1iZXIgb2YgdmlydHVhbCBpbnRlcnJ1cHQgbnVtYmVycyIKIAlyYW5nZSAzMiAzMjc2OApAQCAtMTQzLDYgKzEzMSw5IEBACiAJc2VsZWN0IEhBVkVfUEVSRl9FVkVOVFMKIAlzZWxlY3QgSEFWRV9SRUdTX0FORF9TVEFDS19BQ0NFU1NfQVBJCiAJc2VsZWN0IEhBVkVfSFdfQlJFQUtQT0lOVCBpZiBQRVJGX0VWRU5UUyAmJiBQUENfQk9PSzNTXzY0CisJc2VsZWN0IEhBVkVfR0VORVJJQ19IQVJESVJRUworCXNlbGVjdCBIQVZFX1NQQVJTRV9JUlEKKwlzZWxlY3QgSVJRX1BFUl9DUFUKIAogY29uZmlnIEVBUkxZX1BSSU5USwogCWJvb2wKQEAgLTM5MiwxOSArMzgzLDYgQEAKIAkgIENQVS4gIEdlbmVyYWxseSBzYXlpbmcgWSBpcyBzYWZlLCBhbHRob3VnaCBzb21lIHByb2JsZW1zIGhhdmUgYmVlbgogCSAgcmVwb3J0ZWQgd2l0aCBTTVAgUG93ZXIgTWFjaW50b3NoZXMgd2l0aCB0aGlzIG9wdGlvbiBlbmFibGVkLgogCi1jb25maWcgU1BBUlNFX0lSUQotCWJvb2wgIlN1cHBvcnQgc3BhcnNlIGlycSBudW1iZXJpbmciCi0JZGVmYXVsdCBuCi0JaGVscAotCSAgVGhpcyBlbmFibGVzIHN1cHBvcnQgZm9yIHNwYXJzZSBpcnFzLiBUaGlzIGlzIHVzZWZ1bCBmb3IgZGlzdHJvCi0JICBrZXJuZWxzIHRoYXQgd2FudCB0byBkZWZpbmUgYSBoaWdoIENPTkZJR19OUl9DUFVTIHZhbHVlIGJ1dCBzdGlsbAotCSAgd2FudCB0byBoYXZlIGxvdyBrZXJuZWwgbWVtb3J5IGZvb3RwcmludCBvbiBzbWFsbGVyIG1hY2hpbmVzLgotCi0JICAoIFNwYXJzZSBJUlFzIGNhbiBhbHNvIGJlIGJlbmVmaWNpYWwgb24gTlVNQSBib3hlcywgYXMgdGhleSBzcHJlYWQKLQkgICAgb3V0IHRoZSBpcnFfZGVzY1tdIGFycmF5IGluIGEgbW9yZSBOVU1BLWZyaWVuZGx5IHdheS4gKQotCi0JICBJZiB5b3UgZG9uJ3Qga25vdyB3aGF0IHRvIGRvIGhlcmUsIHNheSBOLgotCiBjb25maWcgTlVNQQogCWJvb2wgIk5VTUEgc3VwcG9ydCIKIAlkZXBlbmRzIG9uIFBQQzY0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvYm9vdC9NYWtlZmlsZSBiL2FyY2gvcG93ZXJwYy9ib290L01ha2VmaWxlCmluZGV4IDk2ZGVlYzYuLjg5MTc4MTYgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9ib290L01ha2VmaWxlCisrKyBiL2FyY2gvcG93ZXJwYy9ib290L01ha2VmaWxlCkBAIC0zNjgsNyArMzY4LDcgQEAKIGV4dHJhLWluc3RhbGxlZAkJOj0gJChwYXRzdWJzdCAkKG9iaikvJSwgJChERVNURElSKSQoV1JBUFBFUl9PQkpESVIpLyUsICQoZXh0cmEteSkpCiBob3N0cHJvZ3MtaW5zdGFsbGVkCTo9ICQocGF0c3Vic3QgJSwgJChERVNURElSKSQoV1JBUFBFUl9CSU5ESVIpLyUsICQoaG9zdHByb2dzLXkpKQogd3JhcHBlci1pbnN0YWxsZWQJOj0gJChERVNURElSKSQoV1JBUFBFUl9CSU5ESVIpL3dyYXBwZXIKLWR0cy1pbnN0YWxsZWQJCTo9ICQocGF0c3Vic3QgJChvYmopL2R0cy8lLCAkKERFU1RESVIpJChXUkFQUEVSX0RUU0RJUikvJSwgJCh3aWxkY2FyZCAkKG9iaikvZHRzLyouZHRzKSkKK2R0cy1pbnN0YWxsZWQJCTo9ICQocGF0c3Vic3QgJChkdHN0cmVlKS8lLCAkKERFU1RESVIpJChXUkFQUEVSX0RUU0RJUikvJSwgJCh3aWxkY2FyZCAkKGR0c3RyZWUpLyouZHRzKSkKIAogYWxsLWluc3RhbGxlZAkJOj0gJChleHRyYS1pbnN0YWxsZWQpICQoaG9zdHByb2dzLWluc3RhbGxlZCkgJCh3cmFwcGVyLWluc3RhbGxlZCkgJChkdHMtaW5zdGFsbGVkKQogCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvYm9vdC9kdHMvbXBjODMwOHJkYi5kdHMgYi9hcmNoL3Bvd2VycGMvYm9vdC9kdHMvbXBjODMwOHJkYi5kdHMKaW5kZXggZDNkYjAyZi4uYTBiZDE4OCAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2Jvb3QvZHRzL21wYzgzMDhyZGIuZHRzCisrKyBiL2FyY2gvcG93ZXJwYy9ib290L2R0cy9tcGM4MzA4cmRiLmR0cwpAQCAtMTA5LDcgKzEwOSw3IEBACiAJCSNhZGRyZXNzLWNlbGxzID0gPDE+OwogCQkjc2l6ZS1jZWxscyA9IDwxPjsKIAkJZGV2aWNlX3R5cGUgPSAic29jIjsKLQkJY29tcGF0aWJsZSA9ICJmc2wsbXBjODMxNS1pbW1yIiwgInNpbXBsZS1idXMiOworCQljb21wYXRpYmxlID0gImZzbCxtcGM4MzA4LWltbXIiLCAic2ltcGxlLWJ1cyI7CiAJCXJhbmdlcyA9IDwwIDB4ZTAwMDAwMDAgMHgwMDEwMDAwMD47CiAJCXJlZyA9IDwweGUwMDAwMDAwIDB4MDAwMDAyMDA+OwogCQlidXMtZnJlcXVlbmN5ID0gPDA+OwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2Jvb3QvZHRzL3AxMDIyZHMuZHRzIGIvYXJjaC9wb3dlcnBjL2Jvb3QvZHRzL3AxMDIyZHMuZHRzCmluZGV4IDJiYmVjYmIuLjY5NDIyZWIgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9ib290L2R0cy9wMTAyMmRzLmR0cworKysgYi9hcmNoL3Bvd2VycGMvYm9vdC9kdHMvcDEwMjJkcy5kdHMKQEAgLTI5MSwxMyArMjkxLDEzIEBACiAJCQlyYW5nZXMgPSA8MHgwIDB4YzEwMCAweDIwMD47CiAJCQljZWxsLWluZGV4ID0gPDE+OwogCQkJZG1hMDA6IGRtYS1jaGFubmVsQDAgewotCQkJCWNvbXBhdGlibGUgPSAiZnNsLGVsb3BsdXMtZG1hLWNoYW5uZWwiOworCQkJCWNvbXBhdGlibGUgPSAiZnNsLHNzaS1kbWEtY2hhbm5lbCI7CiAJCQkJcmVnID0gPDB4MCAweDgwPjsKIAkJCQljZWxsLWluZGV4ID0gPDA+OwogCQkJCWludGVycnVwdHMgPSA8NzYgMj47CiAJCQl9OwogCQkJZG1hMDE6IGRtYS1jaGFubmVsQDgwIHsKLQkJCQljb21wYXRpYmxlID0gImZzbCxlbG9wbHVzLWRtYS1jaGFubmVsIjsKKwkJCQljb21wYXRpYmxlID0gImZzbCxzc2ktZG1hLWNoYW5uZWwiOwogCQkJCXJlZyA9IDwweDgwIDB4ODA+OwogCQkJCWNlbGwtaW5kZXggPSA8MT47CiAJCQkJaW50ZXJydXB0cyA9IDw3NyAyPjsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQweC9hY2FkaWFfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDB4L2FjYWRpYV9kZWZjb25maWcKaW5kZXggOTdmZWRjZS4uNDE4MmM3NyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDB4L2FjYWRpYV9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDB4L2FjYWRpYV9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19LQUxMU1lNU19BTEw9eQogQ09ORklHX0tBTExTWU1TX0VYVFJBX1BBU1M9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDB4L2VwNDA1X2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQweC9lcDQwNV9kZWZjb25maWcKaW5kZXggMzNiM2MyNC4uMmRiYjI5MyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDB4L2VwNDA1X2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy80MHgvZXA0MDVfZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfQUxMPXkKIENPTkZJR19LQUxMU1lNU19FWFRSQV9QQVNTPXkKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQweC9oY3U0X2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQweC9oY3U0X2RlZmNvbmZpZwppbmRleCA0NjEzMDc5Li5lYmViNGFjIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy80MHgvaGN1NF9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDB4L2hjdTRfZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfQUxMPXkKIENPTkZJR19LQUxMU1lNU19FWFRSQV9QQVNTPXkKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQweC9raWxhdWVhX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQweC9raWxhdWVhX2RlZmNvbmZpZwppbmRleCAzNGI4YzFhLi41MzJlYTlkIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy80MHgva2lsYXVlYV9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDB4L2tpbGF1ZWFfZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfQUxMPXkKIENPTkZJR19LQUxMU1lNU19FWFRSQV9QQVNTPXkKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQweC9tYWthbHVfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDB4L21ha2FsdV9kZWZjb25maWcKaW5kZXggNjUxYmUwOS4uM2MxNDJhYyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDB4L21ha2FsdV9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDB4L21ha2FsdV9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19LQUxMU1lNU19BTEw9eQogQ09ORklHX0tBTExTWU1TX0VYVFJBX1BBU1M9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDB4L3dhbG51dF9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy80MHgvd2FsbnV0X2RlZmNvbmZpZwppbmRleCBkZWQ0NTVlLi5mZjU3ZDQ4IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy80MHgvd2FsbnV0X2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy80MHgvd2FsbnV0X2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX0tBTExTWU1TX0FMTD15CiBDT05GSUdfS0FMTFNZTVNfRVhUUkFfUEFTUz15CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvYXJjaGVzX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9hcmNoZXNfZGVmY29uZmlnCmluZGV4IDYzNzQ2YTAuLjNlZDE2ZDUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9hcmNoZXNfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9hcmNoZXNfZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CiAjIENPTkZJR19CTEtfREVWX0JTRyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvYmFtYm9vX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9iYW1ib29fZGVmY29uZmlnCmluZGV4IGY1ZjJhNGUuLmIxYjdkMmMgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9iYW1ib29fZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9iYW1ib29fZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CiAjIENPTkZJR19CTEtfREVWX0JTRyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvYmx1ZXN0b25lX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9ibHVlc3RvbmVfZGVmY29uZmlnCmluZGV4IGFjNjViNDguLjMwYTBhOGUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9ibHVlc3RvbmVfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9ibHVlc3RvbmVfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX1BPU0lYX01RVUVVRT15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1ZNX0VWRU5UX0NPVU5URVJTIGlzIG5vdCBzZXQKICMgQ09ORklHX1BDSV9RVUlSS1MgaXMgbm90IHNldAogIyBDT05GSUdfQ09NUEFUX0JSSyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvY2FueW9ubGFuZHNfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDR4L2NhbnlvbmxhbmRzX2RlZmNvbmZpZwppbmRleCAxN2U0ZGQ5Li5hNDY5NDJhIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvY2FueW9ubGFuZHNfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9jYW55b25sYW5kc19kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9lYm9ueV9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvZWJvbnlfZGVmY29uZmlnCmluZGV4IGZlZGQwM2YuLjA3ZDc3ZTUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9lYm9ueV9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDR4L2Vib255X2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX0tBTExTWU1TX0FMTD15CiBDT05GSUdfS0FMTFNZTVNfRVhUUkFfUEFTUz15CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvZWlnZXJfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDR4L2VpZ2VyX2RlZmNvbmZpZwppbmRleCBlYmZmNzAxLi4yY2U3ZTlhIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvZWlnZXJfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9laWdlcl9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9pY29uX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9pY29uX2RlZmNvbmZpZwppbmRleCA4NjVlOTNmLi4xODczMGZmIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvaWNvbl9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDR4L2ljb25fZGVmY29uZmlnCkBAIC02LDcgKzYsNyBAQAogQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9pc3M0NzYtc21wX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9pc3M0NzYtc21wX2RlZmNvbmZpZwppbmRleCA4ZWNlNGM3Li45MmY4NjNhIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvaXNzNDc2LXNtcF9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDR4L2lzczQ3Ni1zbXBfZGVmY29uZmlnCkBAIC03LDcgKzcsNyBAQAogQ09ORklHX1NZU0ZTX0RFUFJFQ0FURURfVjI9eQogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19LQUxMU1lNU19BTEw9eQogQ09ORklHX0tBTExTWU1TX0VYVFJBX1BBU1M9eQogQ09ORklHX1BST0ZJTElORz15CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgva2F0bWFpX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9rYXRtYWlfZGVmY29uZmlnCmluZGV4IDRjYTliNDguLjM0YzA5MTQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9rYXRtYWlfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9rYXRtYWlfZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CiAjIENPTkZJR19CTEtfREVWX0JTRyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvcmFpbmllcl9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvcmFpbmllcl9kZWZjb25maWcKaW5kZXggZTNiNjVkMi4uMjFjMzNmYSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDR4L3JhaW5pZXJfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9yYWluaWVyX2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQogIyBDT05GSUdfQkxLX0RFVl9CU0cgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDR4L3JlZHdvb2RfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDR4L3JlZHdvb2RfZGVmY29uZmlnCmluZGV4IDY0Y2QwZjMuLjAxY2MyYjEgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9yZWR3b29kX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvcmVkd29vZF9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9zYW00NDBlcF9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvc2FtNDQwZXBfZGVmY29uZmlnCmluZGV4IDAxZDAzMzYuLmRmY2ZmZWQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9zYW00NDBlcF9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDR4L3NhbTQ0MGVwX2RlZmNvbmZpZwpAQCAtNiw3ICs2LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQogIyBDT05GSUdfQkxLX0RFVl9CU0cgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDR4L3NlcXVvaWFfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDR4L3NlcXVvaWFfZGVmY29uZmlnCmluZGV4IDg5YjJmOTYuLjQ3ZTM5OWYgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC9zZXF1b2lhX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvc2VxdW9pYV9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC90YWlzaGFuX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC90YWlzaGFuX2RlZmNvbmZpZwppbmRleCBlMzM4NmNmLi5hNmEwMDJlIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvdGFpc2hhbl9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDR4L3RhaXNoYW5fZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CiAjIENPTkZJR19CTEtfREVWX0JTRyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvd2FycF9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy80NHgvd2FycF9kZWZjb25maWcKaW5kZXggOWMxM2I5ZC4uNmNmOWQ2NiAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNDR4L3dhcnBfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzQ0eC93YXJwX2RlZmNvbmZpZwpAQCAtOCw3ICs4LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQogIyBDT05GSUdfQkxLX0RFVl9CU0cgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNTJ4eC9jbTUyMDBfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNTJ4eC9jbTUyMDBfZGVmY29uZmlnCmluZGV4IGYyMzRjNGQuLjY5YjU3ZGEgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzUyeHgvY201MjAwX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy81Mnh4L2NtNTIwMF9kZWZjb25maWcKQEAgLTMsNyArMyw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX0VQT0xMIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzUyeHgvbGl0ZTUyMDBiX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzUyeHgvbGl0ZTUyMDBiX2RlZmNvbmZpZwppbmRleCBhNGE3OTVjLi5mMzYzOGFlIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy81Mnh4L2xpdGU1MjAwYl9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNTJ4eC9saXRlNTIwMGJfZGVmY29uZmlnCkBAIC0zLDcgKzMsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19FUE9MTCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy81Mnh4L21vdGlvbnByb19kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy81Mnh4L21vdGlvbnByb19kZWZjb25maWcKaW5kZXggMjBkNTNhMS4uNjgyOGVkYSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNTJ4eC9tb3Rpb25wcm9fZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzUyeHgvbW90aW9ucHJvX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfRVBPTEwgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNTJ4eC9wY20wMzBfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNTJ4eC9wY20wMzBfZGVmY29uZmlnCmluZGV4IDZiZDU4MzMuLjdmN2U0YTggMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzUyeHgvcGNtMDMwX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy81Mnh4L3BjbTAzMF9kZWZjb25maWcKQEAgLTgsNyArOCw3IEBACiBDT05GSUdfSUtDT05GSUdfUFJPQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfVk1fRVZFTlRfQ09VTlRFUlMgaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNTJ4eC90cW01MjAwX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzUyeHgvdHFtNTIwMF9kZWZjb25maWcKaW5kZXggM2ExZjcwMi4uOTU5Y2QyYyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvNTJ4eC90cW01MjAwX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy81Mnh4L3RxbTUyMDBfZGVmY29uZmlnCkBAIC0zLDcgKzMsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19FUE9MTCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L2FzcDgzNDdfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9hc3A4MzQ3X2RlZmNvbmZpZwppbmRleCBlZWQ0MmQ4Li5kMjc2MmQ5IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L2FzcDgzNDdfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzgzeHgvYXNwODM0N19kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzgzeHgva21ldGVyMV9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L2ttZXRlcjFfZGVmY29uZmlnCmluZGV4IGU0M2VjYjIuLjdhN2I3MzEgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzgzeHgva21ldGVyMV9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9rbWV0ZXIxX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19TWVNWSVBDPXkKIENPTkZJR19QT1NJWF9NUVVFVUU9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0hPVFBMVUcgaXMgbm90IHNldAogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9tcGM4MzEzX3JkYl9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzMTNfcmRiX2RlZmNvbmZpZwppbmRleCBjMmU2YWI1Li5jNjgzYmNlIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzMTNfcmRiX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzMTNfcmRiX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9tcGM4MzE1X3JkYl9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzMTVfcmRiX2RlZmNvbmZpZwppbmRleCAxZDNiMjAwLi5hNzIxY2QzIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzMTVfcmRiX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzMTVfcmRiX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9tcGM4MzJ4X21kc19kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzMnhfbWRzX2RlZmNvbmZpZwppbmRleCA5MWZlNzNiLi5hNTY5OWExIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzMnhfbWRzX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzMnhfbWRzX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9tcGM4MzJ4X3JkYl9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzMnhfcmRiX2RlZmNvbmZpZwppbmRleCA2ZDMwMGYyLi5iNGRhMWE3IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzMnhfcmRiX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzMnhfcmRiX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9tcGM4MzR4X2l0eF9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzNHhfaXR4X2RlZmNvbmZpZwppbmRleCBiMjM2YTY3Li4yOTFmODIyIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzNHhfaXR4X2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzNHhfaXR4X2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9tcGM4MzR4X2l0eGdwX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzgzeHgvbXBjODM0eF9pdHhncF9kZWZjb25maWcKaW5kZXggMDAxZGVhZC4uZjhiMjI4YSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9tcGM4MzR4X2l0eGdwX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzNHhfaXR4Z3BfZGVmY29uZmlnCkBAIC0zLDcgKzMsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzNHhfbWRzX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzgzeHgvbXBjODM0eF9tZHNfZGVmY29uZmlnCmluZGV4IDlkY2NlZmNhLi45OTY2MGMwIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzNHhfbWRzX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzNHhfbWRzX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9tcGM4MzZ4X21kc19kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzNnhfbWRzX2RlZmNvbmZpZwppbmRleCBkNGIxNjVkLi4xMGI1YzRjIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzNnhfbWRzX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzNnhfbWRzX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9tcGM4MzZ4X3Jka19kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzNnhfcmRrX2RlZmNvbmZpZwppbmRleCA4OWJhNjcyLi40NTkyNWQ3IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzNnhfcmRrX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzNnhfcmRrX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9tcGM4Mzd4X21kc19kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzN3hfbWRzX2RlZmNvbmZpZwppbmRleCAyZWE2YjQwLi5mMzY3OTg1IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzN3hfbWRzX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzN3hfbWRzX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9tcGM4Mzd4X3JkYl9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzN3hfcmRiX2RlZmNvbmZpZwppbmRleCBiZmZlM2M3Li40MTRlZGEzIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzN3hfcmRiX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L21wYzgzN3hfcmRiX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9zYmM4MzR4X2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzgzeHgvc2JjODM0eF9kZWZjb25maWcKaW5kZXggZmE1YzllZS4uNmQ2NDYzZiAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODN4eC9zYmM4MzR4X2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84M3h4L3NiYzgzNHhfZGVmY29uZmlnCkBAIC0zLDcgKzMsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L2tzaTg1NjBfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC9rc2k4NTYwX2RlZmNvbmZpZwppbmRleCAzODViMWFmLi44ZjdjMTA2IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L2tzaTg1NjBfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgva3NpODU2MF9kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKIENPTkZJR19LU0k4NTYwPXkKIENPTkZJR19DUE0yPXkKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvbXBjODU0MF9hZHNfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC9tcGM4NTQwX2Fkc19kZWZjb25maWcKaW5kZXggMjIyYjcwNC4uNTVlMDcyNSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC9tcGM4NTQwX2Fkc19kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC9tcGM4NTQwX2Fkc19kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKIENPTkZJR19NUEM4NTQwX0FEUz15CiBDT05GSUdfTk9fSFo9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC9tcGM4NTYwX2Fkc19kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L21wYzg1NjBfYWRzX2RlZmNvbmZpZwppbmRleCA2MTk3MDJkLi5kNzI0MDk1IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L21wYzg1NjBfYWRzX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L21wYzg1NjBfYWRzX2RlZmNvbmZpZwpAQCAtNCw3ICs0LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfQkxLX0RFVl9CU0cgaXMgbm90IHNldAogQ09ORklHX01QQzg1NjBfQURTPXkKIENPTkZJR19CSU5GTVRfTUlTQz15CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L21wYzg1eHhfY2RzX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvbXBjODV4eF9jZHNfZGVmY29uZmlnCmluZGV4IDZiZjU2ZTguLjRiNDRiZWEgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvbXBjODV4eF9jZHNfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvbXBjODV4eF9jZHNfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19CTEtfREVWX0JTRyBpcyBub3Qgc2V0CiBDT05GSUdfTVBDODV4eF9DRFM9eQogQ09ORklHX05PX0haPXkKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvc2JjODU0OF9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3NiYzg1NDhfZGVmY29uZmlnCmluZGV4IGE5YTE3ZDAuLjViMmI2NTEgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvc2JjODU0OF9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC9zYmM4NTQ4X2RlZmNvbmZpZwpAQCAtNCw3ICs0LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NMQUI9eQogIyBDT05GSUdfQkxLX0RFVl9CU0cgaXMgbm90IHNldAogQ09ORklHX1NCQzg1NDg9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC9zYmM4NTYwX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvc2JjODU2MF9kZWZjb25maWcKaW5kZXggODIwZTMyZC4uZjdmZGIwMyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC9zYmM4NTYwX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3NiYzg1NjBfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfU0xBQj15CiAjIENPTkZJR19CTEtfREVWX0JTRyBpcyBub3Qgc2V0CiBDT05GSUdfU0JDODU2MD15CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3NvY3JhdGVzX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvc29jcmF0ZXNfZGVmY29uZmlnCmluZGV4IGI2ZGIzZjQuLjc3NTA2YjUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvc29jcmF0ZXNfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvc29jcmF0ZXNfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTYKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX0VQT0xMIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvc3R4X2dwM19kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3N0eF9ncDNfZGVmY29uZmlnCmluZGV4IDMzM2E0MWJkMi4uNWQ0ZGIxNSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC9zdHhfZ3AzX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3N0eF9ncDNfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVkVSU0lPTlM9eQogIyBDT05GSUdfQkxLX0RFVl9CU0cgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC90cW04NTQwX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvdHFtODU0MF9kZWZjb25maWcKaW5kZXggMzNkYjM1Mi4uZGRjYjlmMyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC90cW04NTQwX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3RxbTg1NDBfZGVmY29uZmlnCkBAIC00LDcgKzQsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19LQUxMU1lNUyBpcyBub3Qgc2V0CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX0VQT0xMIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvdHFtODU0MV9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3RxbTg1NDFfZGVmY29uZmlnCmluZGV4IGYwYzIwZGYuLjk4MWFiZDYgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvdHFtODU0MV9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC90cW04NTQxX2RlZmNvbmZpZwpAQCAtNCw3ICs0LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfSE9UUExVRyBpcyBub3Qgc2V0CiAjIENPTkZJR19FUE9MTCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3RxbTg1NDhfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC90cW04NTQ4X2RlZmNvbmZpZwppbmRleCBhODgzNDUwLi4zN2IzZDcyIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3RxbTg1NDhfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvdHFtODU0OF9kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvdHFtODU1NV9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3RxbTg1NTVfZGVmY29uZmlnCmluZGV4IGZmOTVmOTAuLjM1OTNiMzIgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvdHFtODU1NV9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC90cW04NTU1X2RlZmNvbmZpZwpAQCAtNCw3ICs0LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfSE9UUExVRyBpcyBub3Qgc2V0CiAjIENPTkZJR19FUE9MTCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3RxbTg1NjBfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC90cW04NTYwX2RlZmNvbmZpZwppbmRleCA4ZDZjOTBlLi5kZTQxM2FjIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3RxbTg1NjBfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzg1eHgvdHFtODU2MF9kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0tBTExTWU1TIGlzIG5vdCBzZXQKICMgQ09ORklHX0hPVFBMVUcgaXMgbm90IHNldAogIyBDT05GSUdfRVBPTEwgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODV4eC94ZXNfbXBjODV4eF9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3hlc19tcGM4NXh4X2RlZmNvbmZpZwppbmRleCBmNTNlZmU0Li41ZWEzMTI0IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3hlc19tcGM4NXh4X2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84NXh4L3hlc19tcGM4NXh4X2RlZmNvbmZpZwpAQCAtMTEsNyArMTEsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfQUxMPXkKIENPTkZJR19LQUxMU1lNU19FWFRSQV9QQVNTPXkKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg2eHgvZ2VmX3BwYzlhX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzg2eHgvZ2VmX3BwYzlhX2RlZmNvbmZpZwppbmRleCA0MzJlYmMyLi40YjI0NDEyIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84Nnh4L2dlZl9wcGM5YV9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODZ4eC9nZWZfcHBjOWFfZGVmY29uZmlnCkBAIC0xMSw3ICsxMSw3IEBACiBDT05GSUdfUkVMQVk9eQogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19TTEFCPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg2eHgvZ2VmX3NiYzMxMF9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84Nnh4L2dlZl9zYmMzMTBfZGVmY29uZmlnCmluZGV4IGNlNWU5MTkuLmEzNjBiYTQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg2eHgvZ2VmX3NiYzMxMF9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODZ4eC9nZWZfc2JjMzEwX2RlZmNvbmZpZwpAQCAtMTEsNyArMTEsNyBAQAogQ09ORklHX1JFTEFZPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy84Nnh4L2dlZl9zYmM2MTBfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODZ4eC9nZWZfc2JjNjEwX2RlZmNvbmZpZwppbmRleCA1ODllNzFlLi5iZTI4MjlkIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84Nnh4L2dlZl9zYmM2MTBfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzg2eHgvZ2VmX3NiYzYxMF9kZWZjb25maWcKQEAgLTExLDcgKzExLDcgQEAKIENPTkZJR19SRUxBWT15CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NMQUI9eQogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODZ4eC9tcGM4NjEwX2hwY2RfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODZ4eC9tcGM4NjEwX2hwY2RfZGVmY29uZmlnCmluZGV4IDMyMWZiNDcuLjAzNmJmYjIgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg2eHgvbXBjODYxMF9ocGNkX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84Nnh4L21wYzg2MTBfaHBjZF9kZWZjb25maWcKQEAgLTYsNyArNiw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19LQUxMU1lNU19FWFRSQV9QQVNTPXkKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzLzg2eHgvbXBjODY0MV9ocGNuX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzLzg2eHgvbXBjODY0MV9ocGNuX2RlZmNvbmZpZwppbmRleCBiNWU0NjM5Li4wYzljN2VkIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84Nnh4L21wYzg2NDFfaHBjbl9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODZ4eC9tcGM4NjQxX2hwY25fZGVmY29uZmlnCkBAIC0xMCw3ICsxMCw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19LQUxMU1lNU19BTEw9eQogQ09ORklHX0tBTExTWU1TX0VYVFJBX1BBU1M9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvODZ4eC9zYmM4NjQxZF9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84Nnh4L3NiYzg2NDFkX2RlZmNvbmZpZwppbmRleCA3MTE0NWMzLi4wYTkyY2EwIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy84Nnh4L3NiYzg2NDFkX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy84Nnh4L3NiYzg2NDFkX2RlZmNvbmZpZwpAQCAtMTEsNyArMTEsNyBAQAogQ09ORklHX1JFTEFZPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfU0xBQj15CiBDT05GSUdfTU9EVUxFUz15CiBDT05GSUdfTU9EVUxFX1VOTE9BRD15CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy9hZGRlcjg3NV9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy9hZGRlcjg3NV9kZWZjb25maWcKaW5kZXggY2E4NGM3Zi4uNjkxMjg3NCAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvYWRkZXI4NzVfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL2FkZGVyODc1X2RlZmNvbmZpZwpAQCAtNCw3ICs0LDcgQEAKIENPTkZJR19TWVNWSVBDPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19FTEZfQ09SRSBpcyBub3Qgc2V0CiAjIENPTkZJR19CQVNFX0ZVTEwgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvZTU1eHhfc21wX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL2U1NXh4X3NtcF9kZWZjb25maWcKaW5kZXggOTRkMTIwZS4uMDZmOTU0OSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvZTU1eHhfc21wX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy9lNTV4eF9zbXBfZGVmY29uZmlnCkBAIC0xMiw3ICsxMiw3IEBACiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX0tBTExTWU1TX0FMTD15CiBDT05GSUdfS0FMTFNZTVNfRVhUUkFfUEFTUz15CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy9lcDgyNDhlX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL2VwODI0OGVfZGVmY29uZmlnCmluZGV4IDI2NzdiMDguLmZjZWZmYjNjIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy9lcDgyNDhlX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy9lcDgyNDhlX2RlZmNvbmZpZwpAQCAtMiw3ICsyLDcgQEAKIENPTkZJR19JS0NPTkZJRz15CiBDT05GSUdfSUtDT05GSUdfUFJPQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX0tBTExTWU1TX0FMTD15CiBDT05GSUdfU0xBQj15CiAjIENPTkZJR19JT1NDSEVEX0NGUSBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy9lcDg4eGNfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvZXA4OHhjX2RlZmNvbmZpZwppbmRleCBmOWEzMTEyLi4yMTlmZDQ3IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy9lcDg4eGNfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL2VwODh4Y19kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfRUxGX0NPUkUgaXMgbm90IHNldAogIyBDT05GSUdfQkFTRV9GVUxMIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzL2dhbWVjdWJlX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL2dhbWVjdWJlX2RlZmNvbmZpZwppbmRleCBmY2YwYTM5Li5lNzRkM2E0IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy9nYW1lY3ViZV9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvZ2FtZWN1YmVfZGVmY29uZmlnCkBAIC02LDcgKzYsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19FTEZfQ09SRSBpcyBub3Qgc2V0CiBDT05GSUdfUEVSRl9DT1VOVEVSUz15CiAjIENPTkZJR19WTV9FVkVOVF9DT1VOVEVSUyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy9ob2xseV9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy9ob2xseV9kZWZjb25maWcKaW5kZXggYjliNjNhNi4uOTRlYmZlZSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvaG9sbHlfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL2hvbGx5X2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX01PRFVMRVM9eQogIyBDT05GSUdfQkxLX0RFVl9CU0cgaXMgbm90IHNldAogIyBDT05GSUdfUFBDX0NIUlAgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbWdjb2dlX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL21nY29nZV9kZWZjb25maWcKaW5kZXggYzRlZDI1NS4uMzk1MThlOSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbWdjb2dlX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy9tZ2NvZ2VfZGVmY29uZmlnCkBAIC0zLDcgKzMsNyBAQAogQ09ORklHX0lLQ09ORklHX1BST0M9eQogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfQUxMPXkKIENPTkZJR19TTEFCPXkKICMgQ09ORklHX0lPU0NIRURfQ0ZRIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzL21nc3V2ZF9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy9tZ3N1dmRfZGVmY29uZmlnCmluZGV4IGYyNzZjN2MuLjJhNDkwNjIgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzL21nc3V2ZF9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbWdzdXZkX2RlZmNvbmZpZwpAQCAtNCw3ICs0LDcgQEAKIENPTkZJR19TWVNWSVBDPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiAjIENPTkZJR19TWVNDVExfU1lTQ0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKICMgQ09ORklHX0JVRyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy9tcGM3NDQ4X2hwYzJfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjNzQ0OF9ocGMyX2RlZmNvbmZpZwppbmRleCAzYjk0NzA4Li43NWYwYmJmIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy9tcGM3NDQ4X2hwYzJfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL21wYzc0NDhfaHBjMl9kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0JMS19ERVZfQlNHIGlzIG5vdCBzZXQKICMgQ09ORklHX1BQQ19DSFJQIGlzIG5vdCBzZXQKICMgQ09ORklHX1BQQ19QTUFDIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzL21wYzgyNzJfYWRzX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL21wYzgyNzJfYWRzX2RlZmNvbmZpZwppbmRleCBjN2Q2OGZmLi42YTIyNDAwIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy9tcGM4MjcyX2Fkc19kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODI3Ml9hZHNfZGVmY29uZmlnCkBAIC0yLDcgKzIsNyBAQAogQ09ORklHX0lLQ09ORklHPXkKIENPTkZJR19JS0NPTkZJR19QUk9DPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfQUxMPXkKICMgQ09ORklHX1BQQ19DSFJQIGlzIG5vdCBzZXQKICMgQ09ORklHX1BQQ19QTUFDIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzL21wYzgzeHhfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODN4eF9kZWZjb25maWcKaW5kZXggNWIxYjEwZi4uNWFhYzlhOCAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODN4eF9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODN4eF9kZWZjb25maWcKQEAgLTMsNyArMyw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19TTEFCPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzL21wYzg1eHhfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODV4eF9kZWZjb25maWcKaW5kZXggM2FlYjU5NC4uOTlhMTlkMSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODV4eF9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODV4eF9kZWZjb25maWcKQEAgLTEwLDcgKzEwLDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX0tBTExTWU1TX0FMTD15CiBDT05GSUdfS0FMTFNZTVNfRVhUUkFfUEFTUz15CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy9tcGM4NXh4X3NtcF9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy9tcGM4NXh4X3NtcF9kZWZjb25maWcKaW5kZXggZDYyYzgwMS4uYzYzNmYyMyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODV4eF9zbXBfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL21wYzg1eHhfc21wX2RlZmNvbmZpZwpAQCAtMTIsNyArMTIsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfQUxMPXkKIENPTkZJR19LQUxMU1lNU19FWFRSQV9QQVNTPXkKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzL21wYzg2Nl9hZHNfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODY2X2Fkc19kZWZjb25maWcKaW5kZXggNjY4MjE1Yy4uNWMyNTg4MiAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODY2X2Fkc19kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODY2X2Fkc19kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfSE9UUExVRyBpcyBub3Qgc2V0CiAjIENPTkZJR19CVUcgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODZ4eF9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy9tcGM4Nnh4X2RlZmNvbmZpZwppbmRleCA2M2I5MGQ0Li41NWI1NDMxIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy9tcGM4Nnh4X2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy9tcGM4Nnh4X2RlZmNvbmZpZwpAQCAtMTAsNyArMTAsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19CTEtfREVWX0lOSVRSRD15CiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfQUxMPXkKIENPTkZJR19LQUxMU1lNU19FWFRSQV9QQVNTPXkKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzL21wYzg4NV9hZHNfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODg1X2Fkc19kZWZjb25maWcKaW5kZXggZjliODM0OC4uOWUxNDZjZCAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODg1X2Fkc19kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvbXBjODg1X2Fkc19kZWZjb25maWcKQEAgLTQsNyArNCw3IEBACiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfU1lTQ1RMX1NZU0NBTEwgaXMgbm90IHNldAogIyBDT05GSUdfRUxGX0NPUkUgaXMgbm90IHNldAogIyBDT05GSUdfQkFTRV9GVUxMIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzL3BwYzQweF9kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy9wcGM0MHhfZGVmY29uZmlnCmluZGV4IDkzZDc0MjUuLmJmZDYzNGIgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzL3BwYzQweF9kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvcHBjNDB4X2RlZmNvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX0tBTExTWU1TX0FMTD15CiBDT05GSUdfS0FMTFNZTVNfRVhUUkFfUEFTUz15CiBDT05GSUdfTU9EVUxFUz15CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy9wcGM0NHhfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvcHBjNDR4X2RlZmNvbmZpZwppbmRleCAyZmEwNWY3Li40NzEzMzIwIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy9wcGM0NHhfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL3BwYzQ0eF9kZWZjb25maWcKQEAgLTUsNyArNSw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKIENPTkZJR19LQUxMU1lNU19BTEw9eQogQ09ORklHX0tBTExTWU1TX0VYVFJBX1BBU1M9eQogQ09ORklHX01PRFVMRVM9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvcHEyZmFkc19kZWZjb25maWcgYi9hcmNoL3Bvd2VycGMvY29uZmlncy9wcTJmYWRzX2RlZmNvbmZpZwppbmRleCBhNDM1M2JlLi5iYWFkOGRiIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy9wcTJmYWRzX2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy9wcTJmYWRzX2RlZmNvbmZpZwpAQCAtMyw3ICszLDcgQEAKIENPTkZJR19JS0NPTkZJR19QUk9DPXkKIENPTkZJR19MT0dfQlVGX1NISUZUPTE0CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX0tBTExTWU1TX0FMTD15CiAjIENPTkZJR19QUENfQ0hSUCBpcyBub3Qgc2V0CiAjIENPTkZJR19QUENfUE1BQyBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy9wczNfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvcHMzX2RlZmNvbmZpZwppbmRleCA0OWNmZmUwLi5jYWJhOTE5IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy9wczNfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL3BzM19kZWZjb25maWcKQEAgLTgsNyArOCw3IEBACiBDT05GSUdfUE9TSVhfTVFVRVVFPXkKIENPTkZJR19OQU1FU1BBQ0VTPXkKIENPTkZJR19CTEtfREVWX0lOSVRSRD15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfS0FMTFNZTVNfRVhUUkFfUEFTUz15CiAjIENPTkZJR19QRVJGX0VWRU5UUyBpcyBub3Qgc2V0CiAjIENPTkZJR19DT01QQVRfQlJLIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzL3BzZXJpZXNfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvcHNlcmllc19kZWZjb25maWcKaW5kZXggZjg3ZjBlMS4uOWMzZjIyYyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvcHNlcmllc19kZWZjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvcHNlcmllc19kZWZjb25maWcKQEAgLTIsNyArMiw3IEBACiBDT05GSUdfQUxUSVZFQz15CiBDT05GSUdfVlNYPXkKIENPTkZJR19TTVA9eQotQ09ORklHX05SX0NQVVM9MTI4CitDT05GSUdfTlJfQ1BVUz0xMDI0CiBDT05GSUdfRVhQRVJJTUVOVEFMPXkKIENPTkZJR19TWVNWSVBDPXkKIENPTkZJR19QT1NJWF9NUVVFVUU9eQpAQCAtNDUsNiArNDUsOCBAQAogQ09ORklHX0lSUV9BTExfQ1BVUz15CiBDT05GSUdfTUVNT1JZX0hPVFBMVUc9eQogQ09ORklHX01FTU9SWV9IT1RSRU1PVkU9eQorQ09ORklHX1BQQ182NEtfUEFHRVM9eQorQ09ORklHX1BQQ19TVUJQQUdFX1BST1Q9eQogQ09ORklHX1NDSEVEX1NNVD15CiBDT05GSUdfSE9UUExVR19QQ0k9bQogQ09ORklHX0hPVFBMVUdfUENJX1JQQT1tCkBAIC0xODQsNiArMTg2LDcgQEAKIENPTkZJR19FMTAwMD15CiBDT05GSUdfRTEwMDBFPXkKIENPTkZJR19USUdPTjM9eQorQ09ORklHX0JOWDI9bQogQ09ORklHX0NIRUxTSU9fVDE9bQogQ09ORklHX0NIRUxTSU9fVDM9bQogQ09ORklHX0VIRUE9eQpAQCAtMzExLDkgKzMxNCw3IEBACiAjIENPTkZJR19SQ1VfQ1BVX1NUQUxMX0RFVEVDVE9SIGlzIG5vdCBzZXQKIENPTkZJR19MQVRFTkNZVE9QPXkKIENPTkZJR19TWVNDVExfU1lTQ0FMTF9DSEVDSz15Ci1DT05GSUdfSVJRU09GRl9UUkFDRVI9eQogQ09ORklHX1NDSEVEX1RSQUNFUj15Ci1DT05GSUdfU1RBQ0tfVFJBQ0VSPXkKIENPTkZJR19CTEtfREVWX0lPX1RSQUNFPXkKIENPTkZJR19ERUJVR19TVEFDS09WRVJGTE9XPXkKIENPTkZJR19ERUJVR19TVEFDS19VU0FHRT15CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy9zdG9yY2VudGVyX2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL3N0b3JjZW50ZXJfZGVmY29uZmlnCmluZGV4IDRmMGMxMGEuLmViYjJhNjYgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9jb25maWdzL3N0b3JjZW50ZXJfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL3N0b3JjZW50ZXJfZGVmY29uZmlnCkBAIC0xLDcgKzEsNyBAQAogQ09ORklHX0VYUEVSSU1FTlRBTD15CiBDT05GSUdfU1lTVklQQz15CiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogQ09ORklHX01PRFVMRVM9eQogQ09ORklHX01PRFVMRV9VTkxPQUQ9eQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvdHFtOHh4X2RlZmNvbmZpZyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL3RxbTh4eF9kZWZjb25maWcKaW5kZXggZDBhNWI2Ny4uODYxNmZkZSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvdHFtOHh4X2RlZmNvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy90cW04eHhfZGVmY29uZmlnCkBAIC01LDcgKzUsNyBAQAogQ09ORklHX0xPR19CVUZfU0hJRlQ9MTQKIENPTkZJR19TWVNGU19ERVBSRUNBVEVEX1YyPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKICMgQ09ORklHX0JBU0VfRlVMTCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvY29uZmlncy93aWlfZGVmY29uZmlnIGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3Mvd2lpX2RlZmNvbmZpZwppbmRleCBiYjhiYTc1Li4xNzUyOTVmIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy93aWlfZGVmY29uZmlnCisrKyBiL2FyY2gvcG93ZXJwYy9jb25maWdzL3dpaV9kZWZjb25maWcKQEAgLTcsNyArNyw3IEBACiBDT05GSUdfTE9HX0JVRl9TSElGVD0xNAogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19FTUJFRERFRD15CitDT05GSUdfRVhQRVJUPXkKICMgQ09ORklHX0VMRl9DT1JFIGlzIG5vdCBzZXQKIENPTkZJR19QRVJGX0NPVU5URVJTPXkKICMgQ09ORklHX1ZNX0VWRU5UX0NPVU5URVJTIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9mZWF0dXJlLWZpeHVwcy5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2ZlYXR1cmUtZml4dXBzLmgKaW5kZXggOTZhN2QwNi4uOTIxYTg0NyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2ZlYXR1cmUtZml4dXBzLmgKKysrIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2ZlYXR1cmUtZml4dXBzLmgKQEAgLTM3LDE4ICszNywyMSBAQAogCS5hbGlnbiAyOwkJCQkJXAogbGFiZWwjIzM6CiAKLSNkZWZpbmUgTUFLRV9GVFJfU0VDVElPTl9FTlRSWShtc2ssIHZhbCwgbGFiZWwsIHNlY3QpCVwKLWxhYmVsIyM0OgkJCQkJCVwKLQkucG9wc2VjdGlvbjsJCQkJCVwKLQkucHVzaHNlY3Rpb24gc2VjdCwiYSI7CQkJCVwKLQkuYWxpZ24gMzsJCQkJCVwKLWxhYmVsIyM1OgkJCQkJICAgICAgIAlcCi0JRlRSX0VOVFJZX0xPTkcgbXNrOwkJCQlcCi0JRlRSX0VOVFJZX0xPTkcgdmFsOwkJCQlcCi0JRlRSX0VOVFJZX09GRlNFVCBsYWJlbCMjMWItbGFiZWwjIzViOwkJXAotCUZUUl9FTlRSWV9PRkZTRVQgbGFiZWwjIzJiLWxhYmVsIyM1YjsJIAlcCi0JRlRSX0VOVFJZX09GRlNFVCBsYWJlbCMjM2ItbGFiZWwjIzViOwkJXAotCUZUUl9FTlRSWV9PRkZTRVQgbGFiZWwjIzRiLWxhYmVsIyM1YjsJIAlcCisjZGVmaW5lIE1BS0VfRlRSX1NFQ1RJT05fRU5UUlkobXNrLCB2YWwsIGxhYmVsLCBzZWN0KQkJXAorbGFiZWwjIzQ6CQkJCQkJCVwKKwkucG9wc2VjdGlvbjsJCQkJCQlcCisJLnB1c2hzZWN0aW9uIHNlY3QsImEiOwkJCQkJXAorCS5hbGlnbiAzOwkJCQkJCVwKK2xhYmVsIyM1OgkJCQkJCQlcCisJRlRSX0VOVFJZX0xPTkcgbXNrOwkJCQkJXAorCUZUUl9FTlRSWV9MT05HIHZhbDsJCQkJCVwKKwlGVFJfRU5UUllfT0ZGU0VUIGxhYmVsIyMxYi1sYWJlbCMjNWI7CQkJXAorCUZUUl9FTlRSWV9PRkZTRVQgbGFiZWwjIzJiLWxhYmVsIyM1YjsJCQlcCisJRlRSX0VOVFJZX09GRlNFVCBsYWJlbCMjM2ItbGFiZWwjIzViOwkJCVwKKwlGVFJfRU5UUllfT0ZGU0VUIGxhYmVsIyM0Yi1sYWJlbCMjNWI7CQkJXAorCS5pZmd0IChsYWJlbCMjNGItbGFiZWwjIzNiKS0obGFiZWwjIzJiLWxhYmVsIyMxYik7CVwKKwkuZXJyb3IgIkZlYXR1cmUgc2VjdGlvbiBlbHNlIGNhc2UgbGFyZ2VyIHRoYW4gYm9keSI7CVwKKwkuZW5kaWY7CQkJCQkJCVwKIAkucG9wc2VjdGlvbjsKIAogCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vaW1tYXBfcWUuaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9pbW1hcF9xZS5oCmluZGV4IDRlMTBmNTAuLjBlZGI2ODQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9pbW1hcF9xZS5oCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9pbW1hcF9xZS5oCkBAIC00NjcsMTMgKzQ2NywyMiBAQAogZXh0ZXJuIHN0cnVjdCBxZV9pbW1hcCBfX2lvbWVtICpxZV9pbW1yOwogZXh0ZXJuIHBoeXNfYWRkcl90IGdldF9xZV9iYXNlKHZvaWQpOwogCi1zdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgaW1tcmJhcl92aXJ0X3RvX3BoeXModm9pZCAqYWRkcmVzcykKKy8qCisgKiBSZXR1cm5zIHRoZSBvZmZzZXQgd2l0aGluIHRoZSBRRSBhZGRyZXNzIHNwYWNlIG9mIHRoZSBnaXZlbiBwb2ludGVyLgorICoKKyAqIE5vdGUgdGhhdCB0aGUgUUUgZG9lcyBub3Qgc3VwcG9ydCAzNi1iaXQgcGh5c2ljYWwgYWRkcmVzc2VzLCBzbyBpZgorICogZ2V0X3FlX2Jhc2UoKSByZXR1cm5zIGEgbnVtYmVyIGFib3ZlIDRHQiwgdGhlIGNhbGxlciB3aWxsIHByb2JhYmx5IGZhaWwuCisgKi8KK3N0YXRpYyBpbmxpbmUgcGh5c19hZGRyX3QgaW1tcmJhcl92aXJ0X3RvX3BoeXModm9pZCAqYWRkcmVzcykKIHsKLQlpZiAoICgodTMyKWFkZHJlc3MgPj0gKHUzMilxZV9pbW1yKSAmJgotCQkJKCh1MzIpYWRkcmVzcyA8ICgodTMyKXFlX2ltbXIgKyBRRV9JTU1BUF9TSVpFKSkgKQotCQlyZXR1cm4gKHVuc2lnbmVkIGxvbmcpKGFkZHJlc3MgLSAodTMyKXFlX2ltbXIgKwotCQkJCSh1MzIpZ2V0X3FlX2Jhc2UoKSk7Ci0JcmV0dXJuICh1bnNpZ25lZCBsb25nKXZpcnRfdG9fcGh5cyhhZGRyZXNzKTsKKwl2b2lkICpxID0gKHZvaWQgKilxZV9pbW1yOworCisJLyogSXMgaXQgYSBNVVJBTSBhZGRyZXNzPyAqLworCWlmICgoYWRkcmVzcyA+PSBxKSAmJiAoYWRkcmVzcyA8IChxICsgUUVfSU1NQVBfU0laRSkpKQorCQlyZXR1cm4gZ2V0X3FlX2Jhc2UoKSArIChhZGRyZXNzIC0gcSk7CisKKwkvKiBJdCdzIGFuIGFkZHJlc3MgcmV0dXJuZWQgYnkga21hbGxvYyAqLworCXJldHVybiB2aXJ0X3RvX3BoeXMoYWRkcmVzcyk7CiB9CiAKICNlbmRpZiAvKiBfX0tFUk5FTF9fICovCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vaXJxZmxhZ3MuaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9pcnFmbGFncy5oCmluZGV4IGI4NWQ4ZGQuLmIwYjA2ZDggMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9pcnFmbGFncy5oCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9pcnFmbGFncy5oCkBAIC0xMiwyNCArMTIsNDQgQEAKIAogI2Vsc2UKICNpZmRlZiBDT05GSUdfVFJBQ0VfSVJRRkxBR1MKKyNpZmRlZiBDT05GSUdfSVJRU09GRl9UUkFDRVIKKy8qCisgKiBTaW5jZSB0aGUgZnRyYWNlIGlycXNvZmYgbGF0ZW5jeSB0cmFjZSBjaGVja3MgQ0FMTEVSX0FERFIxLAorICogd2hpY2ggaXMgdGhlIHN0YWNrIGZyYW1lIGhlcmUsIHdlIG5lZWQgdG8gZm9yY2UgYSBzdGFjayBmcmFtZQorICogaW4gY2FzZSB3ZSBjYW1lIGZyb20gdXNlciBzcGFjZS4KKyAqLworI2RlZmluZSBUUkFDRV9XSVRIX0ZSQU1FX0JVRkZFUihmdW5jKQkJXAorCW1mbHIJcjA7CQkJCVwKKwlzdGR1CXIxLCAtMzIocjEpOwkJCVwKKwlzdGQJcjAsIDE2KHIxKTsJCQlcCisJc3RkdQlyMSwgLTMyKHIxKTsJCQlcCisJYmwgZnVuYzsJCQkJXAorCWxkCXIxLCAwKHIxKTsJCQlcCisJbGQJcjEsIDAocjEpOworI2Vsc2UKKyNkZWZpbmUgVFJBQ0VfV0lUSF9GUkFNRV9CVUZGRVIoZnVuYykJCVwKKwlibCBmdW5jOworI2VuZGlmCisKIC8qCiAgKiBNb3N0IG9mIHRoZSBDUFUncyBJUlEtc3RhdGUgdHJhY2luZyBpcyBkb25lIGZyb20gYXNzZW1ibHkgY29kZTsgd2UKICAqIGhhdmUgdG8gY2FsbCBhIEMgZnVuY3Rpb24gc28gY2FsbCBhIHdyYXBwZXIgdGhhdCBzYXZlcyBhbGwgdGhlCiAgKiBDLWNsb2JiZXJlZCByZWdpc3RlcnMuCiAgKi8KLSNkZWZpbmUgVFJBQ0VfRU5BQkxFX0lOVFMJYmwgLnRyYWNlX2hhcmRpcnFzX29uCi0jZGVmaW5lIFRSQUNFX0RJU0FCTEVfSU5UUwlibCAudHJhY2VfaGFyZGlycXNfb2ZmCi0jZGVmaW5lIFRSQUNFX0FORF9SRVNUT1JFX0lSUV9QQVJUSUFMKGVuLHNraXApCVwKLQljbXBkaQllbiwwOwkJCQlcCi0JYm5lCTk1ZjsJCQkJXAotCXN0YgllbixQQUNBU09GVElSUUVOKHIxMyk7CQlcCi0JYmwJLnRyYWNlX2hhcmRpcnFzX29mZjsJCVwKLQliCXNraXA7CQkJCVwKLTk1OglibAkudHJhY2VfaGFyZGlycXNfb247CQlcCisjZGVmaW5lIFRSQUNFX0VOQUJMRV9JTlRTCVRSQUNFX1dJVEhfRlJBTUVfQlVGRkVSKC50cmFjZV9oYXJkaXJxc19vbikKKyNkZWZpbmUgVFJBQ0VfRElTQUJMRV9JTlRTCVRSQUNFX1dJVEhfRlJBTUVfQlVGRkVSKC50cmFjZV9oYXJkaXJxc19vZmYpCisKKyNkZWZpbmUgVFJBQ0VfQU5EX1JFU1RPUkVfSVJRX1BBUlRJQUwoZW4sc2tpcCkJCVwKKwljbXBkaQllbiwwOwkJCQkJXAorCWJuZQk5NWY7CQkJCQlcCisJc3RiCWVuLFBBQ0FTT0ZUSVJRRU4ocjEzKTsJCQlcCisJVFJBQ0VfV0lUSF9GUkFNRV9CVUZGRVIoLnRyYWNlX2hhcmRpcnFzX29mZikJXAorCWIJc2tpcDsJCQkJCVwKKzk1OglUUkFDRV9XSVRIX0ZSQU1FX0JVRkZFUigudHJhY2VfaGFyZGlycXNfb24pCVwKIAlsaQllbiwxOwogI2RlZmluZSBUUkFDRV9BTkRfUkVTVE9SRV9JUlEoZW4pCQlcCiAJVFJBQ0VfQU5EX1JFU1RPUkVfSVJRX1BBUlRJQUwoZW4sOTZmKTsJXAotCXN0YgllbixQQUNBU09GVElSUUVOKHIxMyk7CSAgICAgICAgXAorCXN0YgllbixQQUNBU09GVElSUUVOKHIxMyk7CQlcCiA5NjoKICNlbHNlCiAjZGVmaW5lIFRSQUNFX0VOQUJMRV9JTlRTCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vbWFjaGRlcC5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL21hY2hkZXAuaAppbmRleCA4NDMzZDM2Li45OTFkNTk5IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vbWFjaGRlcC5oCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9tYWNoZGVwLmgKQEAgLTExNiw5ICsxMTYsNiBAQAogCSAqIElmIGZvciBzb21lIHJlYXNvbiB0aGVyZSBpcyBubyBpcnEsIGJ1dCB0aGUgaW50ZXJydXB0CiAJICogc2hvdWxkbid0IGJlIGNvdW50ZWQgYXMgc3B1cmlvdXMsIHJldHVybiBOT19JUlFfSUdOT1JFLiAqLwogCXVuc2lnbmVkIGludAkoKmdldF9pcnEpKHZvaWQpOwotI2lmZGVmIENPTkZJR19LRVhFQwotCXZvaWQJCSgqa2V4ZWNfY3B1X2Rvd24pKGludCBjcmFzaF9zaHV0ZG93biwgaW50IHNlY29uZGFyeSk7Ci0jZW5kaWYKIAogCS8qIFBDSSBzdHVmZiAqLwogCS8qIENhbGxlZCBhZnRlciBzY2FubmluZyB0aGUgYnVzLCBiZWZvcmUgYWxsb2NhdGluZyByZXNvdXJjZXMgKi8KQEAgLTIzNSwxMSArMjMyLDcgQEAKIAl2b2lkICgqbWFjaGluZV9zaHV0ZG93bikodm9pZCk7CiAKICNpZmRlZiBDT05GSUdfS0VYRUMKLQkvKiBDYWxsZWQgdG8gZG8gdGhlIG1pbmltYWwgc2h1dGRvd24gbmVlZGVkIHRvIHJ1biBhIGtleGVjJ2Qga2VybmVsCi0JICogdG8gcnVuIHN1Y2Nlc3NmdWxseS4KLQkgKiBYWFggU2hvdWxkIHdlIG1vdmUgdGhpcyBvbmUgb3V0IG9mIGtleGVjIHNjb3BlPwotCSAqLwotCXZvaWQgKCptYWNoaW5lX2NyYXNoX3NodXRkb3duKShzdHJ1Y3QgcHRfcmVncyAqcmVncyk7CisJdm9pZCAoKmtleGVjX2NwdV9kb3duKShpbnQgY3Jhc2hfc2h1dGRvd24sIGludCBzZWNvbmRhcnkpOwogCiAJLyogQ2FsbGVkIHRvIGRvIHdoYXQgZXZlcnkgc2V0dXAgaXMgbmVlZGVkIG9uIGltYWdlIGFuZCB0aGUKIAkgKiByZWJvb3QgY29kZSBidWZmZXIuIFJldHVybnMgMCBvbiBzdWNjZXNzLgpAQCAtMjQ3LDE1ICsyNDAsNiBAQAogCSAqIGNsYWltcyB0byBzdXBwb3J0IGtleGVjLgogCSAqLwogCWludCAoKm1hY2hpbmVfa2V4ZWNfcHJlcGFyZSkoc3RydWN0IGtpbWFnZSAqaW1hZ2UpOwotCi0JLyogQ2FsbGVkIHRvIGhhbmRsZSBhbnkgbWFjaGluZSBzcGVjaWZpYyBjbGVhbnVwIG9uIGltYWdlICovCi0Jdm9pZCAoKm1hY2hpbmVfa2V4ZWNfY2xlYW51cCkoc3RydWN0IGtpbWFnZSAqaW1hZ2UpOwotCi0JLyogQ2FsbGVkIHRvIHBlcmZvcm0gdGhlIF9yZWFsXyBrZXhlYy4KLQkgKiBEbyBOT1QgYWxsb2NhdGUgbWVtb3J5IG9yIGZhaWwgaGVyZS4gV2UgYXJlIHBhc3QgdGhlIHBvaW50IG9mCi0JICogbm8gcmV0dXJuLgotCSAqLwotCXZvaWQgKCptYWNoaW5lX2tleGVjKShzdHJ1Y3Qga2ltYWdlICppbWFnZSk7CiAjZW5kaWYgLyogQ09ORklHX0tFWEVDICovCiAKICNpZmRlZiBDT05GSUdfU1VTUEVORApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL21tdS1ib29rM2UuaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9tbXUtYm9vazNlLmgKaW5kZXggOGVhZWQ4MS4uMTcxOTRmYyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL21tdS1ib29rM2UuaAorKysgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vbW11LWJvb2szZS5oCkBAIC00MCw4ICs0MCw4IEBACiAKIC8qIE1BUyByZWdpc3RlcnMgYml0IGRlZmluaXRpb25zICovCiAKLSNkZWZpbmUgTUFTMF9UTEJTRUwoeCkJCSgoeCA8PCAyOCkgJiAweDMwMDAwMDAwKQotI2RlZmluZSBNQVMwX0VTRUwoeCkJCSgoeCA8PCAxNikgJiAweDBGRkYwMDAwKQorI2RlZmluZSBNQVMwX1RMQlNFTCh4KQkJKCgoeCkgPDwgMjgpICYgMHgzMDAwMDAwMCkKKyNkZWZpbmUgTUFTMF9FU0VMKHgpCQkoKCh4KSA8PCAxNikgJiAweDBGRkYwMDAwKQogI2RlZmluZSBNQVMwX05WKHgpCQkoKHgpICYgMHgwMDAwMEZGRikKICNkZWZpbmUgTUFTMF9IRVMJCTB4MDAwMDQwMDAKICNkZWZpbmUgTUFTMF9XUV9BTExXQVlTCQkweDAwMDAwMDAwCkBAIC01MCwxMiArNTAsMTIgQEAKIAogI2RlZmluZSBNQVMxX1ZBTElECQkweDgwMDAwMDAwCiAjZGVmaW5lIE1BUzFfSVBST1QJCTB4NDAwMDAwMDAKLSNkZWZpbmUgTUFTMV9USUQoeCkJCSgoeCA8PCAxNikgJiAweDNGRkYwMDAwKQorI2RlZmluZSBNQVMxX1RJRCh4KQkJKCgoeCkgPDwgMTYpICYgMHgzRkZGMDAwMCkKICNkZWZpbmUgTUFTMV9JTkQJCTB4MDAwMDIwMDAKICNkZWZpbmUgTUFTMV9UUwkJCTB4MDAwMDEwMDAKICNkZWZpbmUgTUFTMV9UU0laRV9NQVNLCQkweDAwMDAwZjgwCiAjZGVmaW5lIE1BUzFfVFNJWkVfU0hJRlQJNwotI2RlZmluZSBNQVMxX1RTSVpFKHgpCQkoKHggPDwgTUFTMV9UU0laRV9TSElGVCkgJiBNQVMxX1RTSVpFX01BU0spCisjZGVmaW5lIE1BUzFfVFNJWkUoeCkJCSgoKHgpIDw8IE1BUzFfVFNJWkVfU0hJRlQpICYgTUFTMV9UU0laRV9NQVNLKQogCiAjZGVmaW5lIE1BUzJfRVBOCQkweEZGRkZGMDAwCiAjZGVmaW5lIE1BUzJfWDAJCQkweDAwMDAwMDQwCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcGFnZS5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3BhZ2UuaAppbmRleCA1M2I2NGJlLi5kYTRiMjAwIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcGFnZS5oCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9wYWdlLmgKQEAgLTEwMSw3ICsxMDEsNyBAQAogCiAjaWZkZWYgQ09ORklHX0ZMQVRNRU0KICNkZWZpbmUgQVJDSF9QRk5fT0ZGU0VUCQkoTUVNT1JZX1NUQVJUID4+IFBBR0VfU0hJRlQpCi0jZGVmaW5lIHBmbl92YWxpZChwZm4pCQkoKHBmbikgPj0gQVJDSF9QRk5fT0ZGU0VUICYmIChwZm4pIDwgKEFSQ0hfUEZOX09GRlNFVCArIG1heF9tYXBucikpCisjZGVmaW5lIHBmbl92YWxpZChwZm4pCQkoKHBmbikgPj0gQVJDSF9QRk5fT0ZGU0VUICYmIChwZm4pIDwgbWF4X21hcG5yKQogI2VuZGlmCiAKICNkZWZpbmUgdmlydF90b19wYWdlKGthZGRyKQlwZm5fdG9fcGFnZShfX3BhKGthZGRyKSA+PiBQQUdFX1NISUZUKQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3JlZy5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3JlZy5oCmluZGV4IGZmMDAwNWVlYy4uMTI1ZmMxYSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3JlZy5oCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9yZWcuaApAQCAtMjgzLDYgKzI4Myw3IEBACiAjZGVmaW5lIEhJRDBfTk9QVEkJKDE8PDApCQkvKiBOby1vcCBkY2J0IGFuZCBkY2JzdCBpbnN0ci4gKi8KIAogI2RlZmluZSBTUFJOX0hJRDEJMHgzRjEJCS8qIEhhcmR3YXJlIEltcGxlbWVudGF0aW9uIFJlZ2lzdGVyIDEgKi8KKyNpZmRlZiBDT05GSUdfNnh4CiAjZGVmaW5lIEhJRDFfRU1DUAkoMTw8MzEpCQkvKiA3NDUwIE1hY2hpbmUgQ2hlY2sgUGluIEVuYWJsZSAqLwogI2RlZmluZSBISUQxX0RGUwkoMTw8MjIpCQkvKiA3NDQ3QSBEeW5hbWljIEZyZXF1ZW5jeSBTY2FsaW5nICovCiAjZGVmaW5lIEhJRDFfUEMwCSgxPDwxNikJCS8qIDc0NTAgUExMX0NGR1swXSAqLwpAQCAtMjkyLDYgKzI5Myw3IEBACiAjZGVmaW5lIEhJRDFfU1lOQ0JFCSgxPDwxMSkJCS8qIDc0NTAgQUJFIGZvciBzeW5jLCBlaWVpbyAqLwogI2RlZmluZSBISUQxX0FCRQkoMTw8MTApCQkvKiA3NDUwIEFkZHJlc3MgQnJvYWRjYXN0IEVuYWJsZSAqLwogI2RlZmluZSBISUQxX1BTCQkoMTw8MTYpCQkvKiA3NTBGWCBQTEwgc2VsZWN0aW9uICovCisjZW5kaWYKICNkZWZpbmUgU1BSTl9ISUQyCTB4M0Y4CQkvKiBIYXJkd2FyZSBJbXBsZW1lbnRhdGlvbiBSZWdpc3RlciAyICovCiAjZGVmaW5lIFNQUk5fSElEMl9HRUtLTwkweDM5OAkJLyogR2Vra28gSElEMiBSZWdpc3RlciAqLwogI2RlZmluZSBTUFJOX0lBQlIJMHgzRjIJLyogSW5zdHJ1Y3Rpb24gQWRkcmVzcyBCcmVha3BvaW50IFJlZ2lzdGVyICovCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcmVnX2Jvb2tlLmggYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vcmVnX2Jvb2tlLmgKaW5kZXggNjY3YTQ5OC4uZTY4YzY5YiAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3JlZ19ib29rZS5oCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9yZWdfYm9va2UuaApAQCAtMjQ2LDYgKzI0NiwyMCBAQAogCQkJCQlzdG9yZSBvciBjYWNoZSBsaW5lIHB1c2ggKi8KICNlbmRpZgogCisvKiBCaXQgZGVmaW5pdGlvbnMgZm9yIHRoZSBISUQxICovCisjaWZkZWYgQ09ORklHX0U1MDAKKy8qIGU1MDB2MS92MiAqLworI2RlZmluZSBISUQxX1BMTF9DRkdfTUFTSyAweGZjMDAwMDAwCS8qIFBMTF9DRkcgaW5wdXQgcGlucyAqLworI2RlZmluZSBISUQxX1JGWEUJMHgwMDAyMDAwMAkvKiBSZWFkIGZhdWx0IGV4Y2VwdGlvbiBlbmFibGUgKi8KKyNkZWZpbmUgSElEMV9SMURQRQkweDAwMDA4MDAwCS8qIFIxIGRhdGEgYnVzIHBhcml0eSBlbmFibGUgKi8KKyNkZWZpbmUgSElEMV9SMkRQRQkweDAwMDA0MDAwCS8qIFIyIGRhdGEgYnVzIHBhcml0eSBlbmFibGUgKi8KKyNkZWZpbmUgSElEMV9BU1RNRQkweDAwMDAyMDAwCS8qIEFkZHJlc3MgYnVzIHN0cmVhbWluZyBtb2RlIGVuYWJsZSAqLworI2RlZmluZSBISUQxX0FCRQkweDAwMDAxMDAwCS8qIEFkZHJlc3MgYnJvYWRjYXN0IGVuYWJsZSAqLworI2RlZmluZSBISUQxX01QWFRUCTB4MDAwMDA0MDAJLyogTVBYIHJlLW1hcCB0cmFuc2ZlciB0eXBlICovCisjZGVmaW5lIEhJRDFfQVRTCTB4MDAwMDAwODAJLyogQXRvbWljIHN0YXR1cyAqLworI2RlZmluZSBISUQxX01JRF9NQVNLCTB4MDAwMDAwMGYJLyogTUlEIGlucHV0IHBpbnMgKi8KKyNlbmRpZgorCiAvKiBCaXQgZGVmaW5pdGlvbnMgZm9yIHRoZSBEQlNSLiAqLwogLyoKICAqIERCU1IgYml0cyB3aGljaCBoYXZlIGNvbmZsaWN0aW5nIGRlZmluaXRpb25zIG9uIHRydWUgQm9vayBFIHZlcnN1cyBJQk0gNDB4LgpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3NwdS5oIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3NwdS5oCmluZGV4IDBhYjhkODY5Li4wYzhiMzVkIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vc3B1LmgKKysrIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL3NwdS5oCkBAIC0yMDMsMTQgKzIwMyw2IEBACiB2b2lkIHNwdV9zZXR1cF9rZXJuZWxfc2xicyhzdHJ1Y3Qgc3B1ICpzcHUsIHN0cnVjdCBzcHVfbHNjc2EgKmxzY3NhLAogCQl2b2lkICpjb2RlLCBpbnQgY29kZV9zaXplKTsKIAotI2lmZGVmIENPTkZJR19LRVhFQwotdm9pZCBjcmFzaF9yZWdpc3Rlcl9zcHVzKHN0cnVjdCBsaXN0X2hlYWQgKmxpc3QpOwotI2Vsc2UKLXN0YXRpYyBpbmxpbmUgdm9pZCBjcmFzaF9yZWdpc3Rlcl9zcHVzKHN0cnVjdCBsaXN0X2hlYWQgKmxpc3QpCi17Ci19Ci0jZW5kaWYKLQogZXh0ZXJuIHZvaWQgc3B1X2ludmFsaWRhdGVfc2xicyhzdHJ1Y3Qgc3B1ICpzcHUpOwogZXh0ZXJuIHZvaWQgc3B1X2Fzc29jaWF0ZV9tbShzdHJ1Y3Qgc3B1ICpzcHUsIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKIGludCBzcHVfNjRrX3BhZ2VzX2F2YWlsYWJsZSh2b2lkKTsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvY3B1X3NldHVwXzZ4eC5TIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9jcHVfc2V0dXBfNnh4LlMKaW5kZXggNTVjYmE0YS4uZjhjZDlmYiAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9jcHVfc2V0dXBfNnh4LlMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9jcHVfc2V0dXBfNnh4LlMKQEAgLTE4LDcgKzE4LDcgQEAKICNpbmNsdWRlIDxhc20vbW11Lmg+CiAKIF9HTE9CQUwoX19zZXR1cF9jcHVfNjAzKQotCW1mbHIJcjQKKwltZmxyCXI1CiBCRUdJTl9NTVVfRlRSX1NFQ1RJT04KIAlsaQlyMTAsMAogCW10c3ByCVNQUk5fU1BSR182MDNfTFJVLHIxMAkJLyogaW5pdCBTVyBMUlUgdHJhY2tpbmcgKi8KQEAgLTI3LDYwICsyNyw2MCBAQAogCWJsCV9faW5pdF9mcHVfcmVnaXN0ZXJzCiBFTkRfRlRSX1NFQ1RJT05fSUZDTFIoQ1BVX0ZUUl9GUFVfVU5BVkFJTEFCTEUpCiAJYmwJc2V0dXBfY29tbW9uX2NhY2hlcwotCW10bHIJcjQKKwltdGxyCXI1CiAJYmxyCiBfR0xPQkFMKF9fc2V0dXBfY3B1XzYwNCkKLQltZmxyCXI0CisJbWZscglyNQogCWJsCXNldHVwX2NvbW1vbl9jYWNoZXMKIAlibAlzZXR1cF82MDRfaGlkMAotCW10bHIJcjQKKwltdGxyCXI1CiAJYmxyCiBfR0xPQkFMKF9fc2V0dXBfY3B1Xzc1MCkKLQltZmxyCXI0CisJbWZscglyNQogCWJsCV9faW5pdF9mcHVfcmVnaXN0ZXJzCiAJYmwJc2V0dXBfY29tbW9uX2NhY2hlcwogCWJsCXNldHVwXzc1MF83NDAwX2hpZDAKLQltdGxyCXI0CisJbXRscglyNQogCWJscgogX0dMT0JBTChfX3NldHVwX2NwdV83NTBjeCkKLQltZmxyCXI0CisJbWZscglyNQogCWJsCV9faW5pdF9mcHVfcmVnaXN0ZXJzCiAJYmwJc2V0dXBfY29tbW9uX2NhY2hlcwogCWJsCXNldHVwXzc1MF83NDAwX2hpZDAKIAlibAlzZXR1cF83NTBjeAotCW10bHIJcjQKKwltdGxyCXI1CiAJYmxyCiBfR0xPQkFMKF9fc2V0dXBfY3B1Xzc1MGZ4KQotCW1mbHIJcjQKKwltZmxyCXI1CiAJYmwJX19pbml0X2ZwdV9yZWdpc3RlcnMKIAlibAlzZXR1cF9jb21tb25fY2FjaGVzCiAJYmwJc2V0dXBfNzUwXzc0MDBfaGlkMAogCWJsCXNldHVwXzc1MGZ4Ci0JbXRscglyNAorCW10bHIJcjUKIAlibHIKIF9HTE9CQUwoX19zZXR1cF9jcHVfNzQwMCkKLQltZmxyCXI0CisJbWZscglyNQogCWJsCV9faW5pdF9mcHVfcmVnaXN0ZXJzCiAJYmwJc2V0dXBfNzQwMF93b3JrYXJvdW5kcwogCWJsCXNldHVwX2NvbW1vbl9jYWNoZXMKIAlibAlzZXR1cF83NTBfNzQwMF9oaWQwCi0JbXRscglyNAorCW10bHIJcjUKIAlibHIKIF9HTE9CQUwoX19zZXR1cF9jcHVfNzQxMCkKLQltZmxyCXI0CisJbWZscglyNQogCWJsCV9faW5pdF9mcHVfcmVnaXN0ZXJzCiAJYmwJc2V0dXBfNzQxMF93b3JrYXJvdW5kcwogCWJsCXNldHVwX2NvbW1vbl9jYWNoZXMKIAlibAlzZXR1cF83NTBfNzQwMF9oaWQwCiAJbGkJcjMsMAogCW10c3ByCVNQUk5fTDJDUjIscjMKLQltdGxyCXI0CisJbXRscglyNQogCWJscgogX0dMT0JBTChfX3NldHVwX2NwdV83NDV4KQotCW1mbHIJcjQKKwltZmxyCXI1CiAJYmwJc2V0dXBfY29tbW9uX2NhY2hlcwogCWJsCXNldHVwXzc0NXhfc3BlY2lmaWNzCi0JbXRscglyNAorCW10bHIJcjUKIAlibHIKIAogLyogRW5hYmxlIGNhY2hlcyBmb3IgNjAzJ3MsIDYwNCwgNzUwICYgNzQwMCAqLwpAQCAtMTk0LDEwICsxOTQsMTAgQEAKIAljcm9yCTQqY3IwK2VxLDQqY3IwK2VxLDQqY3IxK2VxCiAJY3Jvcgk0KmNyMCtlcSw0KmNyMCtlcSw0KmNyMitlcQogCWJuZWxyCi0JbHd6CXI2LENQVV9TUEVDX0ZFQVRVUkVTKHI1KQorCWx3eglyNixDUFVfU1BFQ19GRUFUVVJFUyhyNCkKIAlsaQlyNyxDUFVfRlRSX0NBTl9OQVAKIAlhbmRjCXI2LHI2LHI3Ci0Jc3R3CXI2LENQVV9TUEVDX0ZFQVRVUkVTKHI1KQorCXN0dwlyNixDUFVfU1BFQ19GRUFUVVJFUyhyNCkKIAlibHIKIAogLyogNzUwZnggc3BlY2lmaWMKQEAgLTIyNSwxMiArMjI1LDEyIEBACiAJYW5kaXMuCXIxMSxyMTEsTDNDUl9MM0VAaAogCWJlcQkxZgogRU5EX0ZUUl9TRUNUSU9OX0lGU0VUKENQVV9GVFJfTDNDUikKLQlsd3oJcjYsQ1BVX1NQRUNfRkVBVFVSRVMocjUpCisJbHd6CXI2LENQVV9TUEVDX0ZFQVRVUkVTKHI0KQogCWFuZGkuCXIwLHI2LENQVV9GVFJfTDNfRElTQUJMRV9OQVAKIAliZXEJMWYKIAlsaQlyNyxDUFVfRlRSX0NBTl9OQVAKIAlhbmRjCXI2LHI2LHI3Ci0Jc3R3CXI2LENQVV9TUEVDX0ZFQVRVUkVTKHI1KQorCXN0dwlyNixDUFVfU1BFQ19GRUFUVVJFUyhyNCkKIDE6CiAJbWZzcHIJcjExLFNQUk5fSElEMAogCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL2NwdV9zZXR1cF9mc2xfYm9va2UuUyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvY3B1X3NldHVwX2ZzbF9ib29rZS5TCmluZGV4IDg5NGU2NGYuLjVjNTE4YWQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvY3B1X3NldHVwX2ZzbF9ib29rZS5TCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvY3B1X3NldHVwX2ZzbF9ib29rZS5TCkBAIC02NCw2ICs2NCwxMiBAQAogCWJsCV9fZTUwMF9pY2FjaGVfc2V0dXAKIAlibAlfX2U1MDBfZGNhY2hlX3NldHVwCiAJYmwJX19zZXR1cF9lNTAwX2l2b3JzCisjaWZkZWYgQ09ORklHX1JBUElESU8KKwkvKiBFbnN1cmUgdGhhdCBSRlhFIGlzIHNldCAqLworCW1mc3ByCXIzLFNQUk5fSElEMQorCW9yaXMJcjMscjMsSElEMV9SRlhFQGgKKwltdHNwcglTUFJOX0hJRDEscjMKKyNlbmRpZgogCW10bHIJcjQKIAlibHIKIF9HTE9CQUwoX19zZXR1cF9jcHVfZTUwMG1jKQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9jcHV0YWJsZS5jIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9jcHV0YWJsZS5jCmluZGV4IGJlNWFiMTguLmU4ZTkxNWMgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvY3B1dGFibGUuYworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL2NwdXRhYmxlLmMKQEAgLTExNiw3ICsxMTYsNiBAQAogCQkucG1jX3R5cGUJCT0gUFBDX1BNQ19JQk0sCiAJCS5vcHJvZmlsZV9jcHVfdHlwZQk9ICJwcGM2NC9wb3dlcjMiLAogCQkub3Byb2ZpbGVfdHlwZQkJPSBQUENfT1BST0ZJTEVfUlM2NCwKLQkJLm1hY2hpbmVfY2hlY2sJCT0gbWFjaGluZV9jaGVja19nZW5lcmljLAogCQkucGxhdGZvcm0JCT0gInBvd2VyMyIsCiAJfSwKIAl7CS8qIFBvd2VyMysgKi8KQEAgLTEzMiw3ICsxMzEsNiBAQAogCQkucG1jX3R5cGUJCT0gUFBDX1BNQ19JQk0sCiAJCS5vcHJvZmlsZV9jcHVfdHlwZQk9ICJwcGM2NC9wb3dlcjMiLAogCQkub3Byb2ZpbGVfdHlwZQkJPSBQUENfT1BST0ZJTEVfUlM2NCwKLQkJLm1hY2hpbmVfY2hlY2sJCT0gbWFjaGluZV9jaGVja19nZW5lcmljLAogCQkucGxhdGZvcm0JCT0gInBvd2VyMyIsCiAJfSwKIAl7CS8qIE5vcnRoc3RhciAqLwpAQCAtMTQ4LDcgKzE0Niw2IEBACiAJCS5wbWNfdHlwZQkJPSBQUENfUE1DX0lCTSwKIAkJLm9wcm9maWxlX2NwdV90eXBlCT0gInBwYzY0L3JzNjQiLAogCQkub3Byb2ZpbGVfdHlwZQkJPSBQUENfT1BST0ZJTEVfUlM2NCwKLQkJLm1hY2hpbmVfY2hlY2sJCT0gbWFjaGluZV9jaGVja19nZW5lcmljLAogCQkucGxhdGZvcm0JCT0gInJzNjQiLAogCX0sCiAJewkvKiBQdWxzYXIgKi8KQEAgLTE2NCw3ICsxNjEsNiBAQAogCQkucG1jX3R5cGUJCT0gUFBDX1BNQ19JQk0sCiAJCS5vcHJvZmlsZV9jcHVfdHlwZQk9ICJwcGM2NC9yczY0IiwKIAkJLm9wcm9maWxlX3R5cGUJCT0gUFBDX09QUk9GSUxFX1JTNjQsCi0JCS5tYWNoaW5lX2NoZWNrCQk9IG1hY2hpbmVfY2hlY2tfZ2VuZXJpYywKIAkJLnBsYXRmb3JtCQk9ICJyczY0IiwKIAl9LAogCXsJLyogSS1zdGFyICovCkBAIC0xODAsNyArMTc2LDYgQEAKIAkJLnBtY190eXBlCQk9IFBQQ19QTUNfSUJNLAogCQkub3Byb2ZpbGVfY3B1X3R5cGUJPSAicHBjNjQvcnM2NCIsCiAJCS5vcHJvZmlsZV90eXBlCQk9IFBQQ19PUFJPRklMRV9SUzY0LAotCQkubWFjaGluZV9jaGVjawkJPSBtYWNoaW5lX2NoZWNrX2dlbmVyaWMsCiAJCS5wbGF0Zm9ybQkJPSAicnM2NCIsCiAJfSwKIAl7CS8qIFMtc3RhciAqLwpAQCAtMTk2LDcgKzE5MSw2IEBACiAJCS5wbWNfdHlwZQkJPSBQUENfUE1DX0lCTSwKIAkJLm9wcm9maWxlX2NwdV90eXBlCT0gInBwYzY0L3JzNjQiLAogCQkub3Byb2ZpbGVfdHlwZQkJPSBQUENfT1BST0ZJTEVfUlM2NCwKLQkJLm1hY2hpbmVfY2hlY2sJCT0gbWFjaGluZV9jaGVja19nZW5lcmljLAogCQkucGxhdGZvcm0JCT0gInJzNjQiLAogCX0sCiAJewkvKiBQb3dlcjQgKi8KQEAgLTIxMiw3ICsyMDYsNiBAQAogCQkucG1jX3R5cGUJCT0gUFBDX1BNQ19JQk0sCiAJCS5vcHJvZmlsZV9jcHVfdHlwZQk9ICJwcGM2NC9wb3dlcjQiLAogCQkub3Byb2ZpbGVfdHlwZQkJPSBQUENfT1BST0ZJTEVfUE9XRVI0LAotCQkubWFjaGluZV9jaGVjawkJPSBtYWNoaW5lX2NoZWNrX2dlbmVyaWMsCiAJCS5wbGF0Zm9ybQkJPSAicG93ZXI0IiwKIAl9LAogCXsJLyogUG93ZXI0KyAqLwpAQCAtMjI4LDcgKzIyMSw2IEBACiAJCS5wbWNfdHlwZQkJPSBQUENfUE1DX0lCTSwKIAkJLm9wcm9maWxlX2NwdV90eXBlCT0gInBwYzY0L3Bvd2VyNCIsCiAJCS5vcHJvZmlsZV90eXBlCQk9IFBQQ19PUFJPRklMRV9QT1dFUjQsCi0JCS5tYWNoaW5lX2NoZWNrCQk9IG1hY2hpbmVfY2hlY2tfZ2VuZXJpYywKIAkJLnBsYXRmb3JtCQk9ICJwb3dlcjQiLAogCX0sCiAJewkvKiBQUEM5NzAgKi8KQEAgLTI0Nyw3ICsyMzksNiBAQAogCQkuY3B1X3Jlc3RvcmUJCT0gX19yZXN0b3JlX2NwdV9wcGM5NzAsCiAJCS5vcHJvZmlsZV9jcHVfdHlwZQk9ICJwcGM2NC85NzAiLAogCQkub3Byb2ZpbGVfdHlwZQkJPSBQUENfT1BST0ZJTEVfUE9XRVI0LAotCQkubWFjaGluZV9jaGVjawkJPSBtYWNoaW5lX2NoZWNrX2dlbmVyaWMsCiAJCS5wbGF0Zm9ybQkJPSAicHBjOTcwIiwKIAl9LAogCXsJLyogUFBDOTcwRlggKi8KQEAgLTI2Niw3ICsyNTcsNiBAQAogCQkuY3B1X3Jlc3RvcmUJCT0gX19yZXN0b3JlX2NwdV9wcGM5NzAsCiAJCS5vcHJvZmlsZV9jcHVfdHlwZQk9ICJwcGM2NC85NzAiLAogCQkub3Byb2ZpbGVfdHlwZQkJPSBQUENfT1BST0ZJTEVfUE9XRVI0LAotCQkubWFjaGluZV9jaGVjawkJPSBtYWNoaW5lX2NoZWNrX2dlbmVyaWMsCiAJCS5wbGF0Zm9ybQkJPSAicHBjOTcwIiwKIAl9LAogCXsJLyogUFBDOTcwTVAgREQxLjAgLSBubyBERUVQTkFQLCB1c2UgcmVndWxhciA5NzAgaW5pdCAqLwpAQCAtMjg1LDcgKzI3NSw2IEBACiAJCS5jcHVfcmVzdG9yZQkJPSBfX3Jlc3RvcmVfY3B1X3BwYzk3MCwKIAkJLm9wcm9maWxlX2NwdV90eXBlCT0gInBwYzY0Lzk3ME1QIiwKIAkJLm9wcm9maWxlX3R5cGUJCT0gUFBDX09QUk9GSUxFX1BPV0VSNCwKLQkJLm1hY2hpbmVfY2hlY2sJCT0gbWFjaGluZV9jaGVja19nZW5lcmljLAogCQkucGxhdGZvcm0JCT0gInBwYzk3MCIsCiAJfSwKIAl7CS8qIFBQQzk3ME1QICovCkBAIC0zMDQsNyArMjkzLDYgQEAKIAkJLmNwdV9yZXN0b3JlCQk9IF9fcmVzdG9yZV9jcHVfcHBjOTcwLAogCQkub3Byb2ZpbGVfY3B1X3R5cGUJPSAicHBjNjQvOTcwTVAiLAogCQkub3Byb2ZpbGVfdHlwZQkJPSBQUENfT1BST0ZJTEVfUE9XRVI0LAotCQkubWFjaGluZV9jaGVjawkJPSBtYWNoaW5lX2NoZWNrX2dlbmVyaWMsCiAJCS5wbGF0Zm9ybQkJPSAicHBjOTcwIiwKIAl9LAogCXsJLyogUFBDOTcwR1ggKi8KQEAgLTMyMiw3ICszMTAsNiBAQAogCQkuY3B1X3NldHVwCQk9IF9fc2V0dXBfY3B1X3BwYzk3MCwKIAkJLm9wcm9maWxlX2NwdV90eXBlCT0gInBwYzY0Lzk3MCIsCiAJCS5vcHJvZmlsZV90eXBlCQk9IFBQQ19PUFJPRklMRV9QT1dFUjQsCi0JCS5tYWNoaW5lX2NoZWNrCQk9IG1hY2hpbmVfY2hlY2tfZ2VuZXJpYywKIAkJLnBsYXRmb3JtCQk9ICJwcGM5NzAiLAogCX0sCiAJewkvKiBQb3dlcjUgR1IgKi8KQEAgLTM0Myw3ICszMzAsNiBAQAogCQkgKi8KIAkJLm9wcm9maWxlX21tY3JhX3NpaHYJPSBNTUNSQV9TSUhWLAogCQkub3Byb2ZpbGVfbW1jcmFfc2lwcgk9IE1NQ1JBX1NJUFIsCi0JCS5tYWNoaW5lX2NoZWNrCQk9IG1hY2hpbmVfY2hlY2tfZ2VuZXJpYywKIAkJLnBsYXRmb3JtCQk9ICJwb3dlcjUiLAogCX0sCiAJewkvKiBQb3dlcjUrKyAqLwpAQCAtMzYwLDcgKzM0Niw2IEBACiAJCS5vcHJvZmlsZV90eXBlCQk9IFBQQ19PUFJPRklMRV9QT1dFUjQsCiAJCS5vcHJvZmlsZV9tbWNyYV9zaWh2CT0gTU1DUkFfU0lIViwKIAkJLm9wcm9maWxlX21tY3JhX3NpcHIJPSBNTUNSQV9TSVBSLAotCQkubWFjaGluZV9jaGVjawkJPSBtYWNoaW5lX2NoZWNrX2dlbmVyaWMsCiAJCS5wbGF0Zm9ybQkJPSAicG93ZXI1KyIsCiAJfSwKIAl7CS8qIFBvd2VyNSBHUyAqLwpAQCAtMzc4LDcgKzM2Myw2IEBACiAJCS5vcHJvZmlsZV90eXBlCQk9IFBQQ19PUFJPRklMRV9QT1dFUjQsCiAJCS5vcHJvZmlsZV9tbWNyYV9zaWh2CT0gTU1DUkFfU0lIViwKIAkJLm9wcm9maWxlX21tY3JhX3NpcHIJPSBNTUNSQV9TSVBSLAotCQkubWFjaGluZV9jaGVjawkJPSBtYWNoaW5lX2NoZWNrX2dlbmVyaWMsCiAJCS5wbGF0Zm9ybQkJPSAicG93ZXI1KyIsCiAJfSwKIAl7CS8qIFBPV0VSNiBpbiBQNSsgbW9kZTsgMi4wNC1jb21wbGlhbnQgcHJvY2Vzc29yICovCkBAIC0zOTAsNyArMzc0LDYgQEAKIAkJLm1tdV9mZWF0dXJlcwkJPSBNTVVfRlRSX0hQVEVfVEFCTEUsCiAJCS5pY2FjaGVfYnNpemUJCT0gMTI4LAogCQkuZGNhY2hlX2JzaXplCQk9IDEyOCwKLQkJLm1hY2hpbmVfY2hlY2sJCT0gbWFjaGluZV9jaGVja19nZW5lcmljLAogCQkub3Byb2ZpbGVfY3B1X3R5cGUJPSAicHBjNjQvaWJtLWNvbXBhdC12MSIsCiAJCS5vcHJvZmlsZV90eXBlCQk9IFBQQ19PUFJPRklMRV9QT1dFUjQsCiAJCS5wbGF0Zm9ybQkJPSAicG93ZXI1KyIsCkBAIC00MTMsNyArMzk2LDYgQEAKIAkJLm9wcm9maWxlX21tY3JhX3NpcHIJPSBQT1dFUjZfTU1DUkFfU0lQUiwKIAkJLm9wcm9maWxlX21tY3JhX2NsZWFyCT0gUE9XRVI2X01NQ1JBX1RIUk0gfAogCQkJUE9XRVI2X01NQ1JBX09USEVSLAotCQkubWFjaGluZV9jaGVjawkJPSBtYWNoaW5lX2NoZWNrX2dlbmVyaWMsCiAJCS5wbGF0Zm9ybQkJPSAicG93ZXI2eCIsCiAJfSwKIAl7CS8qIDIuMDUtY29tcGxpYW50IHByb2Nlc3NvciwgaS5lLiBQb3dlcjYgImFyY2hpdGVjdGVkIiBtb2RlICovCkBAIC00MjUsNyArNDA3LDYgQEAKIAkJLm1tdV9mZWF0dXJlcwkJPSBNTVVfRlRSX0hQVEVfVEFCTEUsCiAJCS5pY2FjaGVfYnNpemUJCT0gMTI4LAogCQkuZGNhY2hlX2JzaXplCQk9IDEyOCwKLQkJLm1hY2hpbmVfY2hlY2sJCT0gbWFjaGluZV9jaGVja19nZW5lcmljLAogCQkub3Byb2ZpbGVfY3B1X3R5cGUJPSAicHBjNjQvaWJtLWNvbXBhdC12MSIsCiAJCS5vcHJvZmlsZV90eXBlCQk9IFBQQ19PUFJPRklMRV9QT1dFUjQsCiAJCS5wbGF0Zm9ybQkJPSAicG93ZXI2IiwKQEAgLTQ0MCw3ICs0MjEsNiBAQAogCQkJTU1VX0ZUUl9UTEJJRV8yMDYsCiAJCS5pY2FjaGVfYnNpemUJCT0gMTI4LAogCQkuZGNhY2hlX2JzaXplCQk9IDEyOCwKLQkJLm1hY2hpbmVfY2hlY2sJCT0gbWFjaGluZV9jaGVja19nZW5lcmljLAogCQkub3Byb2ZpbGVfdHlwZQkJPSBQUENfT1BST0ZJTEVfUE9XRVI0LAogCQkub3Byb2ZpbGVfY3B1X3R5cGUJPSAicHBjNjQvaWJtLWNvbXBhdC12MSIsCiAJCS5wbGF0Zm9ybQkJPSAicG93ZXI3IiwKQEAgLTQ5Miw3ICs0NzIsNiBAQAogCQkucG1jX3R5cGUJCT0gUFBDX1BNQ19JQk0sCiAJCS5vcHJvZmlsZV9jcHVfdHlwZQk9ICJwcGM2NC9jZWxsLWJlIiwKIAkJLm9wcm9maWxlX3R5cGUJCT0gUFBDX09QUk9GSUxFX0NFTEwsCi0JCS5tYWNoaW5lX2NoZWNrCQk9IG1hY2hpbmVfY2hlY2tfZ2VuZXJpYywKIAkJLnBsYXRmb3JtCQk9ICJwcGMtY2VsbC1iZSIsCiAJfSwKIAl7CS8qIFBBIFNlbWkgUEE2VCAqLwpAQCAtNTEwLDcgKzQ4OSw2IEBACiAJCS5jcHVfcmVzdG9yZQkJPSBfX3Jlc3RvcmVfY3B1X3BhNnQsCiAJCS5vcHJvZmlsZV9jcHVfdHlwZQk9ICJwcGM2NC9wYTZ0IiwKIAkJLm9wcm9maWxlX3R5cGUJCT0gUFBDX09QUk9GSUxFX1BBNlQsCi0JCS5tYWNoaW5lX2NoZWNrCQk9IG1hY2hpbmVfY2hlY2tfZ2VuZXJpYywKIAkJLnBsYXRmb3JtCQk9ICJwYTZ0IiwKIAl9LAogCXsJLyogZGVmYXVsdCBtYXRjaCAqLwpAQCAtNTI0LDcgKzUwMiw2IEBACiAJCS5kY2FjaGVfYnNpemUJCT0gMTI4LAogCQkubnVtX3BtY3MJCT0gNiwKIAkJLnBtY190eXBlCQk9IFBQQ19QTUNfSUJNLAotCQkubWFjaGluZV9jaGVjawkJPSBtYWNoaW5lX2NoZWNrX2dlbmVyaWMsCiAJCS5wbGF0Zm9ybQkJPSAicG93ZXI0IiwKIAl9CiAjZW5kaWYJLyogQ09ORklHX1BQQ19CT09LM1NfNjQgKi8KQEAgLTIwOTksOCArMjA3Niw4IEBACiAJICogcG9pbnRlciBvbiBwcGM2NCBhbmQgYm9va2UgYXMgd2UgYXJlIHJ1bm5pbmcgYXQgMCBpbiByZWFsIG1vZGUKIAkgKiBvbiBwcGM2NCBhbmQgcmVsb2Nfb2Zmc2V0IGlzIGFsd2F5cyAwIG9uIGJvb2tlLgogCSAqLwotCWlmIChzLT5jcHVfc2V0dXApIHsKLQkJcy0+Y3B1X3NldHVwKG9mZnNldCwgcyk7CisJaWYgKHQtPmNwdV9zZXR1cCkgeworCQl0LT5jcHVfc2V0dXAob2Zmc2V0LCB0KTsKIAl9CiAjZW5kaWYgLyogQ09ORklHX1BQQzY0IHx8IENPTkZJR19CT09LRSAqLwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9jcmFzaC5jIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9jcmFzaC5jCmluZGV4IDgzMmM4YzQuLjNkNTY5ZTIgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvY3Jhc2guYworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL2NyYXNoLmMKQEAgLTQ4LDcgKzQ4LDcgQEAKIHN0YXRpYyBjcHVtYXNrX3QgY3B1c19pbl9jcmFzaCA9IENQVV9NQVNLX05PTkU7CiBjcHVtYXNrX3QgY3B1c19pbl9zciA9IENQVV9NQVNLX05PTkU7CiAKLSNkZWZpbmUgQ1JBU0hfSEFORExFUl9NQVggMgorI2RlZmluZSBDUkFTSF9IQU5ETEVSX01BWCAzCiAvKiBOVUxMIHRlcm1pbmF0ZWQgbGlzdCBvZiBzaHV0ZG93biBoYW5kbGVzICovCiBzdGF0aWMgY3Jhc2hfc2h1dGRvd25fdCBjcmFzaF9zaHV0ZG93bl9oYW5kbGVzW0NSQVNIX0hBTkRMRVJfTUFYKzFdOwogc3RhdGljIERFRklORV9TUElOTE9DSyhjcmFzaF9oYW5kbGVyc19sb2NrKTsKQEAgLTEyNSw3ICsxMjUsNyBAQAogCXNtcF93bWIoKTsKIAogCS8qCi0JICogRklYTUU6IFVudGlsIHdlIHdpbGwgaGF2ZSB0aGUgd2F5IHRvIHN0b3Agb3RoZXIgQ1BVU3MgcmVsaWFiYWxseSwKKwkgKiBGSVhNRTogVW50aWwgd2Ugd2lsbCBoYXZlIHRoZSB3YXkgdG8gc3RvcCBvdGhlciBDUFVzIHJlbGlhYmx5LAogCSAqIHRoZSBjcmFzaCBDUFUgd2lsbCBzZW5kIGFuIElQSSBhbmQgd2FpdCBmb3Igb3RoZXIgQ1BVcyB0bwogCSAqIHJlc3BvbmQuCiAJICogRGVsYXkgb2YgYXQgbGVhc3QgMTAgc2Vjb25kcy4KQEAgLTI1NCw3MiArMjU0LDYgQEAKIAljcHVzX2luX3NyID0gQ1BVX01BU0tfTk9ORTsKIH0KICNlbmRpZgotI2lmZGVmIENPTkZJR19TUFVfQkFTRQotCi0jaW5jbHVkZSA8YXNtL3NwdS5oPgotI2luY2x1ZGUgPGFzbS9zcHVfcHJpdjEuaD4KLQotc3RydWN0IGNyYXNoX3NwdV9pbmZvIHsKLQlzdHJ1Y3Qgc3B1ICpzcHU7Ci0JdTMyIHNhdmVkX3NwdV9ydW5jbnRsX1JXOwotCXUzMiBzYXZlZF9zcHVfc3RhdHVzX1I7Ci0JdTMyIHNhdmVkX3NwdV9ucGNfUlc7Ci0JdTY0IHNhdmVkX21mY19zcjFfUlc7Ci0JdTY0IHNhdmVkX21mY19kYXI7Ci0JdTY0IHNhdmVkX21mY19kc2lzcjsKLX07Ci0KLSNkZWZpbmUgQ1JBU0hfTlVNX1NQVVMJMTYJLyogRW5vdWdoIGZvciBjdXJyZW50IGhhcmR3YXJlICovCi1zdGF0aWMgc3RydWN0IGNyYXNoX3NwdV9pbmZvIGNyYXNoX3NwdV9pbmZvW0NSQVNIX05VTV9TUFVTXTsKLQotc3RhdGljIHZvaWQgY3Jhc2hfa2V4ZWNfc3RvcF9zcHVzKHZvaWQpCi17Ci0Jc3RydWN0IHNwdSAqc3B1OwotCWludCBpOwotCXU2NCB0bXA7Ci0KLQlmb3IgKGkgPSAwOyBpIDwgQ1JBU0hfTlVNX1NQVVM7IGkrKykgewotCQlpZiAoIWNyYXNoX3NwdV9pbmZvW2ldLnNwdSkKLQkJCWNvbnRpbnVlOwotCi0JCXNwdSA9IGNyYXNoX3NwdV9pbmZvW2ldLnNwdTsKLQotCQljcmFzaF9zcHVfaW5mb1tpXS5zYXZlZF9zcHVfcnVuY250bF9SVyA9Ci0JCQlpbl9iZTMyKCZzcHUtPnByb2JsZW0tPnNwdV9ydW5jbnRsX1JXKTsKLQkJY3Jhc2hfc3B1X2luZm9baV0uc2F2ZWRfc3B1X3N0YXR1c19SID0KLQkJCWluX2JlMzIoJnNwdS0+cHJvYmxlbS0+c3B1X3N0YXR1c19SKTsKLQkJY3Jhc2hfc3B1X2luZm9baV0uc2F2ZWRfc3B1X25wY19SVyA9Ci0JCQlpbl9iZTMyKCZzcHUtPnByb2JsZW0tPnNwdV9ucGNfUlcpOwotCi0JCWNyYXNoX3NwdV9pbmZvW2ldLnNhdmVkX21mY19kYXIgICAgPSBzcHVfbWZjX2Rhcl9nZXQoc3B1KTsKLQkJY3Jhc2hfc3B1X2luZm9baV0uc2F2ZWRfbWZjX2RzaXNyICA9IHNwdV9tZmNfZHNpc3JfZ2V0KHNwdSk7Ci0JCXRtcCA9IHNwdV9tZmNfc3IxX2dldChzcHUpOwotCQljcmFzaF9zcHVfaW5mb1tpXS5zYXZlZF9tZmNfc3IxX1JXID0gdG1wOwotCi0JCXRtcCAmPSB+TUZDX1NUQVRFMV9NQVNURVJfUlVOX0NPTlRST0xfTUFTSzsKLQkJc3B1X21mY19zcjFfc2V0KHNwdSwgdG1wKTsKLQotCQlfX2RlbGF5KDIwMCk7Ci0JfQotfQotCi12b2lkIGNyYXNoX3JlZ2lzdGVyX3NwdXMoc3RydWN0IGxpc3RfaGVhZCAqbGlzdCkKLXsKLQlzdHJ1Y3Qgc3B1ICpzcHU7Ci0KLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHNwdSwgbGlzdCwgZnVsbF9saXN0KSB7Ci0JCWlmIChXQVJOX09OKHNwdS0+bnVtYmVyID49IENSQVNIX05VTV9TUFVTKSkKLQkJCWNvbnRpbnVlOwotCi0JCWNyYXNoX3NwdV9pbmZvW3NwdS0+bnVtYmVyXS5zcHUgPSBzcHU7Ci0JfQotfQotCi0jZWxzZQotc3RhdGljIGlubGluZSB2b2lkIGNyYXNoX2tleGVjX3N0b3Bfc3B1cyh2b2lkKQotewotfQotI2VuZGlmIC8qIENPTkZJR19TUFVfQkFTRSAqLwogCiAvKgogICogUmVnaXN0ZXIgYSBmdW5jdGlvbiB0byBiZSBjYWxsZWQgb24gc2h1dGRvd24uICBPbmx5IHVzZSB0aGlzIGlmIHlvdQpAQCAtNDM5LDggKzM3Myw2IEBACiAJY3Jhc2hfc2h1dGRvd25fY3B1ID0gLTE7CiAJX19kZWJ1Z2dlcl9mYXVsdF9oYW5kbGVyID0gb2xkX2hhbmRsZXI7CiAKLQljcmFzaF9rZXhlY19zdG9wX3NwdXMoKTsKLQogCWlmIChwcGNfbWQua2V4ZWNfY3B1X2Rvd24pCiAJCXBwY19tZC5rZXhlY19jcHVfZG93bigxLCAwKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvZW50cnlfMzIuUyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvZW50cnlfMzIuUwppbmRleCBjMjJkYzFlLi41NjIxMmJjIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL2VudHJ5XzMyLlMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9lbnRyeV8zMi5TCkBAIC04ODAsNyArODgwLDE4IEBACiAJICovCiAJYW5kaS4JcjEwLHI5LE1TUl9FRQogCWJlcQkxZgorCS8qCisJICogU2luY2UgdGhlIGZ0cmFjZSBpcnFzb2ZmIGxhdGVuY3kgdHJhY2UgY2hlY2tzIENBTExFUl9BRERSMSwKKwkgKiB3aGljaCBpcyB0aGUgc3RhY2sgZnJhbWUgaGVyZSwgd2UgbmVlZCB0byBmb3JjZSBhIHN0YWNrIGZyYW1lCisJICogaW4gY2FzZSB3ZSBjYW1lIGZyb20gdXNlciBzcGFjZS4KKwkgKi8KKwlzdHd1CXIxLC0zMihyMSkKKwltZmxyCXIwCisJc3R3CXIwLDQocjEpCisJc3R3dQlyMSwtMzIocjEpCiAJYmwJdHJhY2VfaGFyZGlycXNfb24KKwlsd3oJcjEsMChyMSkKKwlsd3oJcjEsMChyMSkKIAlsd3oJcjksX01TUihyMSkKIDE6CiAjZW5kaWYgLyogQ09ORklHX1RSQUNFX0lSUUZMQUdTICovCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL21hY2hpbmVfa2V4ZWMuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvbWFjaGluZV9rZXhlYy5jCmluZGV4IGRmN2UyMGMuLjQ5YTE3MGEgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvbWFjaGluZV9rZXhlYy5jCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvbWFjaGluZV9rZXhlYy5jCkBAIC0xNSw2ICsxNSw3IEBACiAjaW5jbHVkZSA8bGludXgvbWVtYmxvY2suaD4KICNpbmNsdWRlIDxsaW51eC9vZi5oPgogI2luY2x1ZGUgPGxpbnV4L2lycS5oPgorI2luY2x1ZGUgPGxpbnV4L2Z0cmFjZS5oPgogCiAjaW5jbHVkZSA8YXNtL21hY2hkZXAuaD4KICNpbmNsdWRlIDxhc20vcHJvbS5oPgpAQCAtNDQsMTAgKzQ1LDcgQEAKIAogdm9pZCBtYWNoaW5lX2NyYXNoX3NodXRkb3duKHN0cnVjdCBwdF9yZWdzICpyZWdzKQogewotCWlmIChwcGNfbWQubWFjaGluZV9jcmFzaF9zaHV0ZG93bikKLQkJcHBjX21kLm1hY2hpbmVfY3Jhc2hfc2h1dGRvd24ocmVncyk7Ci0JZWxzZQotCQlkZWZhdWx0X21hY2hpbmVfY3Jhc2hfc2h1dGRvd24ocmVncyk7CisJZGVmYXVsdF9tYWNoaW5lX2NyYXNoX3NodXRkb3duKHJlZ3MpOwogfQogCiAvKgpAQCAtNjUsOCArNjMsNiBAQAogCiB2b2lkIG1hY2hpbmVfa2V4ZWNfY2xlYW51cChzdHJ1Y3Qga2ltYWdlICppbWFnZSkKIHsKLQlpZiAocHBjX21kLm1hY2hpbmVfa2V4ZWNfY2xlYW51cCkKLQkJcHBjX21kLm1hY2hpbmVfa2V4ZWNfY2xlYW51cChpbWFnZSk7CiB9CiAKIHZvaWQgYXJjaF9jcmFzaF9zYXZlX3ZtY29yZWluZm8odm9pZCkKQEAgLTg3LDEwICs4MywxMyBAQAogICovCiB2b2lkIG1hY2hpbmVfa2V4ZWMoc3RydWN0IGtpbWFnZSAqaW1hZ2UpCiB7Ci0JaWYgKHBwY19tZC5tYWNoaW5lX2tleGVjKQotCQlwcGNfbWQubWFjaGluZV9rZXhlYyhpbWFnZSk7Ci0JZWxzZQotCQlkZWZhdWx0X21hY2hpbmVfa2V4ZWMoaW1hZ2UpOworCWludCBzYXZlX2Z0cmFjZV9lbmFibGVkOworCisJc2F2ZV9mdHJhY2VfZW5hYmxlZCA9IF9fZnRyYWNlX2VuYWJsZWRfc2F2ZSgpOworCisJZGVmYXVsdF9tYWNoaW5lX2tleGVjKGltYWdlKTsKKworCV9fZnRyYWNlX2VuYWJsZWRfcmVzdG9yZShzYXZlX2Z0cmFjZV9lbmFibGVkKTsKIAogCS8qIEZhbGwgYmFjayB0byBub3JtYWwgcmVzdGFydCBpZiB3ZSdyZSBzdGlsbCBhbGl2ZS4gKi8KIAltYWNoaW5lX3Jlc3RhcnQoTlVMTCk7CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL3BlcmZfZXZlbnQuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGVyZl9ldmVudC5jCmluZGV4IDU2NzQ4MDcuLmFiNmY2YmUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGVyZl9ldmVudC5jCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGVyZl9ldmVudC5jCkBAIC0xMjEyLDYgKzEyMTIsNyBAQAogCQkJaWYgKGxlZnQgPD0gMCkKIAkJCQlsZWZ0ID0gcGVyaW9kOwogCQkJcmVjb3JkID0gMTsKKwkJCWV2ZW50LT5ody5sYXN0X3BlcmlvZCA9IGV2ZW50LT5ody5zYW1wbGVfcGVyaW9kOwogCQl9CiAJCWlmIChsZWZ0IDwgMHg4MDAwMDAwMExMKQogCQkJdmFsID0gMHg4MDAwMDAwMExMIC0gbGVmdDsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGVyZl9ldmVudF9mc2xfZW1iLmMgYi9hcmNoL3Bvd2VycGMva2VybmVsL3BlcmZfZXZlbnRfZnNsX2VtYi5jCmluZGV4IDRkY2Y1ZjguLmIwZGM4ZjcgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGVyZl9ldmVudF9mc2xfZW1iLmMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9wZXJmX2V2ZW50X2ZzbF9lbWIuYwpAQCAtNTk2LDYgKzU5Niw3IEBACiAJCQlpZiAobGVmdCA8PSAwKQogCQkJCWxlZnQgPSBwZXJpb2Q7CiAJCQlyZWNvcmQgPSAxOworCQkJZXZlbnQtPmh3Lmxhc3RfcGVyaW9kID0gZXZlbnQtPmh3LnNhbXBsZV9wZXJpb2Q7CiAJCX0KIAkJaWYgKGxlZnQgPCAweDgwMDAwMDAwTEwpCiAJCQl2YWwgPSAweDgwMDAwMDAwTEwgLSBsZWZ0OwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9wcm9jZXNzLmMgYi9hcmNoL3Bvd2VycGMva2VybmVsL3Byb2Nlc3MuYwppbmRleCA4NDkwNmQzLi43YTFkNWNiIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL3Byb2Nlc3MuYworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL3Byb2Nlc3MuYwpAQCAtNjMxLDcgKzYzMSw3IEBACiAjaWZkZWYgQ09ORklHX1BQQ19BRFZfREVCVUdfUkVHUwogCQlwcmludGsoIkRFQVI6ICJSRUciLCBFU1I6ICJSRUciXG4iLCByZWdzLT5kYXIsIHJlZ3MtPmRzaXNyKTsKICNlbHNlCi0JCXByaW50aygiREFSOiAiUkVHIiwgRFNJU1I6ICJSRUciXG4iLCByZWdzLT5kYXIsIHJlZ3MtPmRzaXNyKTsKKwkJcHJpbnRrKCJEQVI6ICJSRUciLCBEU0lTUjogJTA4bHhcbiIsIHJlZ3MtPmRhciwgcmVncy0+ZHNpc3IpOwogI2VuZGlmCiAJcHJpbnRrKCJUQVNLID0gJXBbJWRdICclcycgVEhSRUFEOiAlcCIsCiAJICAgICAgIGN1cnJlbnQsIHRhc2tfcGlkX25yKGN1cnJlbnQpLCBjdXJyZW50LT5jb21tLCB0YXNrX3RocmVhZF9pbmZvKGN1cnJlbnQpKTsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvcHJvbS5jIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9wcm9tLmMKaW5kZXggOWUzMTMyZC4uNzE4NWYwZCAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9wcm9tLmMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9wcm9tLmMKQEAgLTUxOSw5ICs1MTksOSBAQAogCW1lbWJsb2NrX2FkZChiYXNlLCBzaXplKTsKIH0KIAotdTY0IF9faW5pdCBlYXJseV9pbml0X2R0X2FsbG9jX21lbW9yeV9hcmNoKHU2NCBzaXplLCB1NjQgYWxpZ24pCit2b2lkICogX19pbml0IGVhcmx5X2luaXRfZHRfYWxsb2NfbWVtb3J5X2FyY2godTY0IHNpemUsIHU2NCBhbGlnbikKIHsKLQlyZXR1cm4gbWVtYmxvY2tfYWxsb2Moc2l6ZSwgYWxpZ24pOworCXJldHVybiBfX3ZhKG1lbWJsb2NrX2FsbG9jKHNpemUsIGFsaWduKSk7CiB9CiAKICNpZmRlZiBDT05GSUdfQkxLX0RFVl9JTklUUkQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvcnRhc19mbGFzaC5jIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9ydGFzX2ZsYXNoLmMKaW5kZXggMmI0NDJlNi4uYmY1ZjVjZSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9ydGFzX2ZsYXNoLmMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9ydGFzX2ZsYXNoLmMKQEAgLTI1NiwzMSArMjU2LDE2IEBACiAJc3RydWN0IHByb2NfZGlyX2VudHJ5ICpkcCA9IFBERShmaWxlLT5mX3BhdGguZGVudHJ5LT5kX2lub2RlKTsKIAlzdHJ1Y3QgcnRhc191cGRhdGVfZmxhc2hfdCAqdWY7CiAJY2hhciBtc2dbUlRBU19NU0dfTUFYTEVOXTsKLQlpbnQgbXNnbGVuOwogCi0JdWYgPSAoc3RydWN0IHJ0YXNfdXBkYXRlX2ZsYXNoX3QgKikgZHAtPmRhdGE7CisJdWYgPSBkcC0+ZGF0YTsKIAogCWlmICghc3RyY21wKGRwLT5uYW1lLCBGSVJNV0FSRV9GTEFTSF9OQU1FKSkgewogCQlnZXRfZmxhc2hfc3RhdHVzX21zZyh1Zi0+c3RhdHVzLCBtc2cpOwogCX0gZWxzZSB7CSAgIC8qIEZJUk1XQVJFX1VQREFURV9OQU1FICovCiAJCXNwcmludGYobXNnLCAiJWRcbiIsIHVmLT5zdGF0dXMpOwogCX0KLQltc2dsZW4gPSBzdHJsZW4obXNnKTsKLQlpZiAobXNnbGVuID4gY291bnQpCi0JCW1zZ2xlbiA9IGNvdW50OwogCi0JaWYgKHBwb3MgJiYgKnBwb3MgIT0gMCkKLQkJcmV0dXJuIDA7CS8qIGJlIGNoZWFwICovCi0KLQlpZiAoIWFjY2Vzc19vayhWRVJJRllfV1JJVEUsIGJ1ZiwgbXNnbGVuKSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlpZiAoY29weV90b191c2VyKGJ1ZiwgbXNnLCBtc2dsZW4pKQotCQlyZXR1cm4gLUVGQVVMVDsKLQotCWlmIChwcG9zKQotCQkqcHBvcyA9IG1zZ2xlbjsKLQlyZXR1cm4gbXNnbGVuOworCXJldHVybiBzaW1wbGVfcmVhZF9mcm9tX2J1ZmZlcihidWYsIGNvdW50LCBwcG9zLCBtc2csIHN0cmxlbihtc2cpKTsKIH0KIAogLyogY29uc3RydWN0b3IgZm9yIGZsYXNoX2Jsb2NrX2NhY2hlICovCkBAIC0zOTQsMjYgKzM3OSwxMyBAQAogCWNoYXIgbXNnW1JUQVNfTVNHX01BWExFTl07CiAJaW50IG1zZ2xlbjsKIAotCWFyZ3NfYnVmID0gKHN0cnVjdCBydGFzX21hbmFnZV9mbGFzaF90ICopIGRwLT5kYXRhOworCWFyZ3NfYnVmID0gZHAtPmRhdGE7CiAJaWYgKGFyZ3NfYnVmID09IE5VTEwpCiAJCXJldHVybiAwOwogCiAJbXNnbGVuID0gc3ByaW50Zihtc2csICIlZFxuIiwgYXJnc19idWYtPnN0YXR1cyk7Ci0JaWYgKG1zZ2xlbiA+IGNvdW50KQotCQltc2dsZW4gPSBjb3VudDsKIAotCWlmIChwcG9zICYmICpwcG9zICE9IDApCi0JCXJldHVybiAwOwkvKiBiZSBjaGVhcCAqLwotCi0JaWYgKCFhY2Nlc3Nfb2soVkVSSUZZX1dSSVRFLCBidWYsIG1zZ2xlbikpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JaWYgKGNvcHlfdG9fdXNlcihidWYsIG1zZywgbXNnbGVuKSkKLQkJcmV0dXJuIC1FRkFVTFQ7Ci0KLQlpZiAocHBvcykKLQkJKnBwb3MgPSBtc2dsZW47Ci0JcmV0dXJuIG1zZ2xlbjsKKwlyZXR1cm4gc2ltcGxlX3JlYWRfZnJvbV9idWZmZXIoYnVmLCBjb3VudCwgcHBvcywgbXNnLCBtc2dsZW4pOwogfQogCiBzdGF0aWMgc3NpemVfdCBtYW5hZ2VfZmxhc2hfd3JpdGUoc3RydWN0IGZpbGUgKmZpbGUsIGNvbnN0IGNoYXIgX191c2VyICpidWYsCkBAIC00OTUsMjQgKzQ2NywxMSBAQAogCWNoYXIgbXNnW1JUQVNfTVNHX01BWExFTl07CiAJaW50IG1zZ2xlbjsKIAotCWFyZ3NfYnVmID0gKHN0cnVjdCBydGFzX3ZhbGlkYXRlX2ZsYXNoX3QgKikgZHAtPmRhdGE7CisJYXJnc19idWYgPSBkcC0+ZGF0YTsKIAotCWlmIChwcG9zICYmICpwcG9zICE9IDApCi0JCXJldHVybiAwOwkvKiBiZSBjaGVhcCAqLwotCQogCW1zZ2xlbiA9IGdldF92YWxpZGF0ZV9mbGFzaF9tc2coYXJnc19idWYsIG1zZyk7Ci0JaWYgKG1zZ2xlbiA+IGNvdW50KQotCQltc2dsZW4gPSBjb3VudDsKIAotCWlmICghYWNjZXNzX29rKFZFUklGWV9XUklURSwgYnVmLCBtc2dsZW4pKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCWlmIChjb3B5X3RvX3VzZXIoYnVmLCBtc2csIG1zZ2xlbikpCi0JCXJldHVybiAtRUZBVUxUOwotCi0JaWYgKHBwb3MpCi0JCSpwcG9zID0gbXNnbGVuOwotCXJldHVybiBtc2dsZW47CisJcmV0dXJuIHNpbXBsZV9yZWFkX2Zyb21fYnVmZmVyKGJ1ZiwgY291bnQsIHBwb3MsIG1zZywgbXNnbGVuKTsKIH0KIAogc3RhdGljIHNzaXplX3QgdmFsaWRhdGVfZmxhc2hfd3JpdGUoc3RydWN0IGZpbGUgKmZpbGUsIGNvbnN0IGNoYXIgX191c2VyICpidWYsCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL3J0YXNkLmMgYi9hcmNoL3Bvd2VycGMva2VybmVsL3J0YXNkLmMKaW5kZXggMDQzOGY4MS4uMDQ5ZGJlYyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9ydGFzZC5jCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcnRhc2QuYwpAQCAtMTYwLDcgKzE2MCw3IEBACiAJLyogcnRhcyBmaXhlZCBoZWFkZXIgKi8KIAlsZW4gPSA4OwogCWVyciA9IChzdHJ1Y3QgcnRhc19lcnJvcl9sb2cgKilidWY7Ci0JaWYgKGVyci0+ZXh0ZW5kZWRfbG9nX2xlbmd0aCkgeworCWlmIChlcnItPmV4dGVuZGVkICYmIGVyci0+ZXh0ZW5kZWRfbG9nX2xlbmd0aCkgewogCiAJCS8qIGV4dGVuZGVkIGhlYWRlciAqLwogCQlsZW4gKz0gZXJyLT5leHRlbmRlZF9sb2dfbGVuZ3RoOwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC90aW1lLmMgYi9hcmNoL3Bvd2VycGMva2VybmVsL3RpbWUuYwppbmRleCAwOWU0ZGVhLi4wOWQzMWRiIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL3RpbWUuYworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL3RpbWUuYwpAQCAtMjY1LDExICsyNjUsMjYgQEAKIHsKIAl1NjQgc3N0LCB1c3Q7CiAKLQlzc3QgPSBzY2FuX2Rpc3BhdGNoX2xvZyhnZXRfcGFjYSgpLT5zdGFydHRpbWVfdXNlcik7Ci0JdXN0ID0gc2Nhbl9kaXNwYXRjaF9sb2coZ2V0X3BhY2EoKS0+c3RhcnR0aW1lKTsKLQlnZXRfcGFjYSgpLT5zeXN0ZW1fdGltZSAtPSBzc3Q7Ci0JZ2V0X3BhY2EoKS0+dXNlcl90aW1lIC09IHVzdDsKLQlnZXRfcGFjYSgpLT5zdG9sZW5fdGltZSArPSB1c3QgKyBzc3Q7CisJdTggc2F2ZV9zb2Z0X2VuYWJsZWQgPSBsb2NhbF9wYWNhLT5zb2Z0X2VuYWJsZWQ7CisJdTggc2F2ZV9oYXJkX2VuYWJsZWQgPSBsb2NhbF9wYWNhLT5oYXJkX2VuYWJsZWQ7CisKKwkvKiBXZSBhcmUgY2FsbGVkIGVhcmx5IGluIHRoZSBleGNlcHRpb24gZW50cnksIGJlZm9yZQorCSAqIHNvZnQvaGFyZF9lbmFibGVkIGFyZSBzeW5jJ2VkIHRvIHRoZSBleHBlY3RlZCBzdGF0ZQorCSAqIGZvciB0aGUgZXhjZXB0aW9uLiBXZSBhcmUgaGFyZCBkaXNhYmxlZCBidXQgdGhlIFBBQ0EKKwkgKiBuZWVkcyB0byByZWZsZWN0IHRoYXQgc28gdmFyaW91cyBkZWJ1ZyBzdHVmZiBkb2Vzbid0CisJICogY29tcGxhaW4KKwkgKi8KKwlsb2NhbF9wYWNhLT5zb2Z0X2VuYWJsZWQgPSAwOworCWxvY2FsX3BhY2EtPmhhcmRfZW5hYmxlZCA9IDA7CisKKwlzc3QgPSBzY2FuX2Rpc3BhdGNoX2xvZyhsb2NhbF9wYWNhLT5zdGFydHRpbWVfdXNlcik7CisJdXN0ID0gc2Nhbl9kaXNwYXRjaF9sb2cobG9jYWxfcGFjYS0+c3RhcnR0aW1lKTsKKwlsb2NhbF9wYWNhLT5zeXN0ZW1fdGltZSAtPSBzc3Q7CisJbG9jYWxfcGFjYS0+dXNlcl90aW1lIC09IHVzdDsKKwlsb2NhbF9wYWNhLT5zdG9sZW5fdGltZSArPSB1c3QgKyBzc3Q7CisKKwlsb2NhbF9wYWNhLT5zb2Z0X2VuYWJsZWQgPSBzYXZlX3NvZnRfZW5hYmxlZDsKKwlsb2NhbF9wYWNhLT5oYXJkX2VuYWJsZWQgPSBzYXZlX2hhcmRfZW5hYmxlZDsKIH0KIAogc3RhdGljIGlubGluZSB1NjQgY2FsY3VsYXRlX3N0b2xlbl90aW1lKHU2NCBzdG9wX3RiKQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC90cmFwcy5jIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC90cmFwcy5jCmluZGV4IDFiMmNkYzguLmJkNzRmYWMgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvdHJhcHMuYworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL3RyYXBzLmMKQEAgLTYyNiwxMiArNjI2LDYgQEAKIAlpZiAocmVjb3ZlciA+IDApCiAJCXJldHVybjsKIAotCWlmICh1c2VyX21vZGUocmVncykpIHsKLQkJcmVncy0+bXNyIHw9IE1TUl9SSTsKLQkJX2V4Y2VwdGlvbihTSUdCVVMsIHJlZ3MsIEJVU19BRFJFUlIsIHJlZ3MtPm5pcCk7Ci0JCXJldHVybjsKLQl9Ci0KICNpZiBkZWZpbmVkKENPTkZJR184eHgpICYmIGRlZmluZWQoQ09ORklHX1BDSSkKIAkvKiB0aGUgcXNwYW4gcGNpIHJlYWQgcm91dGluZXMgY2FuIGNhdXNlIG1hY2hpbmUgY2hlY2tzIC0tIENvcnQKIAkgKgpAQCAtNjQzLDE2ICs2MzcsMTIgQEAKIAlyZXR1cm47CiAjZW5kaWYKIAotCWlmIChkZWJ1Z2dlcl9mYXVsdF9oYW5kbGVyKHJlZ3MpKSB7Ci0JCXJlZ3MtPm1zciB8PSBNU1JfUkk7CisJaWYgKGRlYnVnZ2VyX2ZhdWx0X2hhbmRsZXIocmVncykpCiAJCXJldHVybjsKLQl9CiAKIAlpZiAoY2hlY2tfaW9fYWNjZXNzKHJlZ3MpKQogCQlyZXR1cm47CiAKLQlpZiAoZGVidWdnZXJfZmF1bHRfaGFuZGxlcihyZWdzKSkKLQkJcmV0dXJuOwogCWRpZSgiTWFjaGluZSBjaGVjayIsIHJlZ3MsIFNJR0JVUyk7CiAKIAkvKiBNdXN0IGRpZSBpZiB0aGUgaW50ZXJydXB0IGlzIG5vdCByZWNvdmVyYWJsZSAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2xpYi9mZWF0dXJlLWZpeHVwcy10ZXN0LlMgYi9hcmNoL3Bvd2VycGMvbGliL2ZlYXR1cmUtZml4dXBzLXRlc3QuUwppbmRleCBjYjczNzQ4Li5mNDYxMzExIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvbGliL2ZlYXR1cmUtZml4dXBzLXRlc3QuUworKysgYi9hcmNoL3Bvd2VycGMvbGliL2ZlYXR1cmUtZml4dXBzLXRlc3QuUwpAQCAtMTcyLDYgKzE3MiwyNSBAQAogMzoJb3IJMywzLDMKIAogCisjaWYgMAorLyogVGVzdCB0aGF0IGlmIHdlIGhhdmUgYSBsYXJnZXIgZWxzZSBjYXNlIHRoZSBhc3NlbWJsZXIgc3BvdHMgaXQgYW5kCisgKiByZXBvcnRzIGFuIGVycm9yLiAjaWYgMCdlZCBzbyBhcyBub3QgdG8gYnJlYWsgdGhlIGJ1aWxkIG5vcm1hbGx5LgorICovCitmdHJfZml4dXBfdGVzdDc6CisJb3IJMSwxLDEKK0JFR0lOX0ZUUl9TRUNUSU9OCisJb3IJMiwyLDIKKwlvcgkyLDIsMgorCW9yCTIsMiwyCitGVFJfU0VDVElPTl9FTFNFCisJb3IJMywzLDMKKwlvcgkzLDMsMworCW9yCTMsMywzCisJb3IJMywzLDMKK0FMVF9GVFJfU0VDVElPTl9FTkQoMCwgMSkKKwlvcgkxLDEsMQorI2VuZGlmCisKICNkZWZpbmUJTUFLRV9NQUNST19URVNUKFRZUEUpCQkJCQkJXAogZ2xvYmwoZnRyX2ZpeHVwX3Rlc3RfICMjVFlQRSMjX21hY3JvcykJCQkJCVwKIAlvcgkxLDEsMTsJCQkJCQkJXApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL21tL2d1cC5jIGIvYXJjaC9wb3dlcnBjL21tL2d1cC5jCmluZGV4IGQ3ZWZkYmYuLmZlYzEzMjAgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9tbS9ndXAuYworKysgYi9hcmNoL3Bvd2VycGMvbW0vZ3VwLmMKQEAgLTE2LDYgKzE2LDE2IEBACiAKICNpZmRlZiBfX0hBVkVfQVJDSF9QVEVfU1BFQ0lBTAogCitzdGF0aWMgaW5saW5lIHZvaWQgZ2V0X2h1Z2VfcGFnZV90YWlsKHN0cnVjdCBwYWdlICpwYWdlKQoreworCS8qCisJICogX19zcGxpdF9odWdlX3BhZ2VfcmVmY291bnQoKSBjYW5ub3QgcnVuCisJICogZnJvbSB1bmRlciB1cy4KKwkgKi8KKwlWTV9CVUdfT04oYXRvbWljX3JlYWQoJnBhZ2UtPl9jb3VudCkgPCAwKTsKKwlhdG9taWNfaW5jKCZwYWdlLT5fY291bnQpOworfQorCiAvKgogICogVGhlIHBlcmZvcm1hbmNlIGNyaXRpY2FsIGxlYWYgZnVuY3Rpb25zIGFyZSBtYWRlIG5vaW5saW5lIG90aGVyd2lzZSBnY2MKICAqIGlubGluZXMgZXZlcnl0aGluZyBpbnRvIGEgc2luZ2xlIGZ1bmN0aW9uIHdoaWNoIHJlc3VsdHMgaW4gdG9vIG11Y2gKQEAgLTQ3LDYgKzU3LDggQEAKIAkJCXB1dF9wYWdlKHBhZ2UpOwogCQkJcmV0dXJuIDA7CiAJCX0KKwkJaWYgKFBhZ2VUYWlsKHBhZ2UpKQorCQkJZ2V0X2h1Z2VfcGFnZV90YWlsKHBhZ2UpOwogCQlwYWdlc1sqbnJdID0gcGFnZTsKIAkJKCpucikrKzsKIApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL21tL251bWEuYyBiL2FyY2gvcG93ZXJwYy9tbS9udW1hLmMKaW5kZXggYmY1Y2I5MS4uZmQ0ODEyMyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL21tL251bWEuYworKysgYi9hcmNoL3Bvd2VycGMvbW0vbnVtYS5jCkBAIC0xODYsNyArMTg2LDcgQEAKIAlkYmcoInJlbW92aW5nIGNwdSAlbHUgZnJvbSBub2RlICVkXG4iLCBjcHUsIG5vZGUpOwogCiAJaWYgKGNwdW1hc2tfdGVzdF9jcHUoY3B1LCBub2RlX3RvX2NwdW1hc2tfbWFwW25vZGVdKSkgewotCQljcHVtYXNrX3NldF9jcHUoY3B1LCBub2RlX3RvX2NwdW1hc2tfbWFwW25vZGVdKTsKKwkJY3B1bWFza19jbGVhcl9jcHUoY3B1LCBub2RlX3RvX2NwdW1hc2tfbWFwW25vZGVdKTsKIAl9IGVsc2UgewogCQlwcmludGsoS0VSTl9FUlIgIldBUk5JTkc6IGNwdSAlbHUgbm90IGZvdW5kIGluIG5vZGUgJWRcbiIsCiAJCSAgICAgICBjcHUsIG5vZGUpOwpAQCAtMTI4OSwxMCArMTI4OSw5IEBACiB9CiAjZW5kaWYgLyogQ09ORklHX01FTU9SWV9IT1RQTFVHICovCiAKLS8qIFZydHVhbCBQcm9jZXNzb3IgSG9tZSBOb2RlIChWUEhOKSBzdXBwb3J0ICovCisvKiBWaXJ0dWFsIFByb2Nlc3NvciBIb21lIE5vZGUgKFZQSE4pIHN1cHBvcnQgKi8KICNpZmRlZiBDT05GSUdfUFBDX1NQTFBBUgotI2RlZmluZSBWUEhOX05SX0NIQU5HRV9DVFJTICg4KQotc3RhdGljIHU4IHZwaG5fY3B1X2NoYW5nZV9jb3VudHNbTlJfQ1BVU11bVlBITl9OUl9DSEFOR0VfQ1RSU107CitzdGF0aWMgdTggdnBobl9jcHVfY2hhbmdlX2NvdW50c1tOUl9DUFVTXVtNQVhfRElTVEFOQ0VfUkVGX1BPSU5UU107CiBzdGF0aWMgY3B1bWFza190IGNwdV9hc3NvY2lhdGl2aXR5X2NoYW5nZXNfbWFzazsKIHN0YXRpYyBpbnQgdnBobl9lbmFibGVkOwogc3RhdGljIHZvaWQgc2V0X3RvcG9sb2d5X3RpbWVyKHZvaWQpOwpAQCAtMTMwMywxNiArMTMwMiwxOCBAQAogICovCiBzdGF0aWMgdm9pZCBzZXR1cF9jcHVfYXNzb2NpYXRpdml0eV9jaGFuZ2VfY291bnRlcnModm9pZCkKIHsKLQlpbnQgY3B1ID0gMDsKKwlpbnQgY3B1OworCisJLyogVGhlIFZQSE4gZmVhdHVyZSBzdXBwb3J0cyBhIG1heGltdW0gb2YgOCByZWZlcmVuY2UgcG9pbnRzICovCisJQlVJTERfQlVHX09OKE1BWF9ESVNUQU5DRV9SRUZfUE9JTlRTID4gOCk7CiAKIAlmb3JfZWFjaF9wb3NzaWJsZV9jcHUoY3B1KSB7Ci0JCWludCBpID0gMDsKKwkJaW50IGk7CiAJCXU4ICpjb3VudHMgPSB2cGhuX2NwdV9jaGFuZ2VfY291bnRzW2NwdV07CiAJCXZvbGF0aWxlIHU4ICpoeXBlcnZpc29yX2NvdW50cyA9IGxwcGFjYVtjcHVdLnZwaG5fYXNzb2NfY291bnRzOwogCi0JCWZvciAoaSA9IDA7IGkgPCBWUEhOX05SX0NIQU5HRV9DVFJTOyBpKyspIHsKKwkJZm9yIChpID0gMDsgaSA8IGRpc3RhbmNlX3JlZl9wb2ludHNfZGVwdGg7IGkrKykKIAkJCWNvdW50c1tpXSA9IGh5cGVydmlzb3JfY291bnRzW2ldOwotCQl9CiAJfQogfQogCkBAIC0xMzI5LDcgKzEzMzAsNyBAQAogICovCiBzdGF0aWMgaW50IHVwZGF0ZV9jcHVfYXNzb2NpYXRpdml0eV9jaGFuZ2VzX21hc2sodm9pZCkKIHsKLQlpbnQgY3B1ID0gMCwgbnJfY3B1cyA9IDA7CisJaW50IGNwdSwgbnJfY3B1cyA9IDA7CiAJY3B1bWFza190ICpjaGFuZ2VzID0gJmNwdV9hc3NvY2lhdGl2aXR5X2NoYW5nZXNfbWFzazsKIAogCWNwdW1hc2tfY2xlYXIoY2hhbmdlcyk7CkBAIC0xMzM5LDggKzEzNDAsOCBAQAogCQl1OCAqY291bnRzID0gdnBobl9jcHVfY2hhbmdlX2NvdW50c1tjcHVdOwogCQl2b2xhdGlsZSB1OCAqaHlwZXJ2aXNvcl9jb3VudHMgPSBscHBhY2FbY3B1XS52cGhuX2Fzc29jX2NvdW50czsKIAotCQlmb3IgKGkgPSAwOyBpIDwgVlBITl9OUl9DSEFOR0VfQ1RSUzsgaSsrKSB7Ci0JCQlpZiAoaHlwZXJ2aXNvcl9jb3VudHNbaV0gPiBjb3VudHNbaV0pIHsKKwkJZm9yIChpID0gMDsgaSA8IGRpc3RhbmNlX3JlZl9wb2ludHNfZGVwdGg7IGkrKykgeworCQkJaWYgKGh5cGVydmlzb3JfY291bnRzW2ldICE9IGNvdW50c1tpXSkgewogCQkJCWNvdW50c1tpXSA9IGh5cGVydmlzb3JfY291bnRzW2ldOwogCQkJCWNoYW5nZWQgPSAxOwogCQkJfQpAQCAtMTM1NCw4ICsxMzU1LDExIEBACiAJcmV0dXJuIG5yX2NwdXM7CiB9CiAKLS8qIDYgNjQtYml0IHJlZ2lzdGVycyB1bnBhY2tlZCBpbnRvIDEyIDMyLWJpdCBhc3NvY2lhdGl2aXR5IHZhbHVlcyAqLwotI2RlZmluZSBWUEhOX0FTU09DX0JVRlNJWkUgKDYqc2l6ZW9mKHU2NCkvc2l6ZW9mKHUzMikpCisvKgorICogNiA2NC1iaXQgcmVnaXN0ZXJzIHVucGFja2VkIGludG8gMTIgMzItYml0IGFzc29jaWF0aXZpdHkgdmFsdWVzLiBUbyBmb3JtCisgKiB0aGUgY29tcGxldGUgcHJvcGVydHkgd2UgaGF2ZSB0byBhZGQgdGhlIGxlbmd0aCBpbiB0aGUgZmlyc3QgY2VsbC4KKyAqLworI2RlZmluZSBWUEhOX0FTU09DX0JVRlNJWkUgKDYqc2l6ZW9mKHU2NCkvc2l6ZW9mKHUzMikgKyAxKQogCiAvKgogICogQ29udmVydCB0aGUgYXNzb2NpYXRpdml0eSBkb21haW4gbnVtYmVycyByZXR1cm5lZCBmcm9tIHRoZSBoeXBlcnZpc29yCkBAIC0xMzYzLDE1ICsxMzY3LDE0IEBACiAgKi8KIHN0YXRpYyBpbnQgdnBobl91bnBhY2tfYXNzb2NpYXRpdml0eShjb25zdCBsb25nICpwYWNrZWQsIHVuc2lnbmVkIGludCAqdW5wYWNrZWQpCiB7Ci0JaW50IGkgPSAwOwotCWludCBucl9hc3NvY19kb21zID0gMDsKKwlpbnQgaSwgbnJfYXNzb2NfZG9tcyA9IDA7CiAJY29uc3QgdTE2ICpmaWVsZCA9IChjb25zdCB1MTYqKSBwYWNrZWQ7CiAKICNkZWZpbmUgVlBITl9GSUVMRF9VTlVTRUQJKDB4ZmZmZikKICNkZWZpbmUgVlBITl9GSUVMRF9NU0IJCSgweDgwMDApCiAjZGVmaW5lIFZQSE5fRklFTERfTUFTSwkJKH5WUEhOX0ZJRUxEX01TQikKIAotCWZvciAoaSA9IDA7IGkgPCBWUEhOX0FTU09DX0JVRlNJWkU7IGkrKykgeworCWZvciAoaSA9IDE7IGkgPCBWUEhOX0FTU09DX0JVRlNJWkU7IGkrKykgewogCQlpZiAoKmZpZWxkID09IFZQSE5fRklFTERfVU5VU0VEKSB7CiAJCQkvKiBBbGwgc2lnbmlmaWNhbnQgZmllbGRzIHByb2Nlc3NlZCwgYW5kIHJlbWFpbmluZwogCQkJICogZmllbGRzIGNvbnRhaW4gdGhlIHJlc2VydmVkIHZhbHVlIG9mIGFsbCAxJ3MuCkBAIC0xMzc5LDE0ICsxMzgyLDEyIEBACiAJCQkgKi8KIAkJCXVucGFja2VkW2ldID0gKigodTMyKilmaWVsZCk7CiAJCQlmaWVsZCArPSAyOwotCQl9Ci0JCWVsc2UgaWYgKCpmaWVsZCAmIFZQSE5fRklFTERfTVNCKSB7CisJCX0gZWxzZSBpZiAoKmZpZWxkICYgVlBITl9GSUVMRF9NU0IpIHsKIAkJCS8qIERhdGEgaXMgaW4gdGhlIGxvd2VyIDE1IGJpdHMgb2YgdGhpcyBmaWVsZCAqLwogCQkJdW5wYWNrZWRbaV0gPSAqZmllbGQgJiBWUEhOX0ZJRUxEX01BU0s7CiAJCQlmaWVsZCsrOwogCQkJbnJfYXNzb2NfZG9tcysrOwotCQl9Ci0JCWVsc2UgeworCQl9IGVsc2UgewogCQkJLyogRGF0YSBpcyBpbiB0aGUgbG93ZXIgMTUgYml0cyBvZiB0aGlzIGZpZWxkCiAJCQkgKiBjb25jYXRlbmF0ZWQgd2l0aCB0aGUgbmV4dCAxNiBiaXQgZmllbGQKIAkJCSAqLwpAQCAtMTM5Niw2ICsxMzk3LDkgQEAKIAkJfQogCX0KIAorCS8qIFRoZSBmaXJzdCBjZWxsIGNvbnRhaW5zIHRoZSBsZW5ndGggb2YgdGhlIHByb3BlcnR5ICovCisJdW5wYWNrZWRbMF0gPSBucl9hc3NvY19kb21zOworCiAJcmV0dXJuIG5yX2Fzc29jX2RvbXM7CiB9CiAKQEAgLTE0MDUsNyArMTQwOSw3IEBACiAgKi8KIHN0YXRpYyBsb25nIGhjYWxsX3ZwaG4odW5zaWduZWQgbG9uZyBjcHUsIHVuc2lnbmVkIGludCAqYXNzb2NpYXRpdml0eSkKIHsKLQlsb25nIHJjID0gMDsKKwlsb25nIHJjOwogCWxvbmcgcmV0YnVmW1BMUEFSX0hDQUxMOV9CVUZTSVpFXSA9IHswfTsKIAl1NjQgZmxhZ3MgPSAxOwogCWludCBod2NwdSA9IGdldF9oYXJkX3NtcF9wcm9jZXNzb3JfaWQoY3B1KTsKQEAgLTE0MTksNyArMTQyMyw3IEBACiBzdGF0aWMgbG9uZyB2cGhuX2dldF9hc3NvY2lhdGl2aXR5KHVuc2lnbmVkIGxvbmcgY3B1LAogCQkJCQl1bnNpZ25lZCBpbnQgKmFzc29jaWF0aXZpdHkpCiB7Ci0JbG9uZyByYyA9IDA7CisJbG9uZyByYzsKIAogCXJjID0gaGNhbGxfdnBobihjcHUsIGFzc29jaWF0aXZpdHkpOwogCkBAIC0xNDQ1LDkgKzE0NDksOSBAQAogICovCiBpbnQgYXJjaF91cGRhdGVfY3B1X3RvcG9sb2d5KHZvaWQpCiB7Ci0JaW50IGNwdSA9IDAsIG5pZCA9IDAsIG9sZF9uaWQgPSAwOworCWludCBjcHUsIG5pZCwgb2xkX25pZDsKIAl1bnNpZ25lZCBpbnQgYXNzb2NpYXRpdml0eVtWUEhOX0FTU09DX0JVRlNJWkVdID0gezB9OwotCXN0cnVjdCBzeXNfZGV2aWNlICpzeXNkZXYgPSBOVUxMOworCXN0cnVjdCBzeXNfZGV2aWNlICpzeXNkZXY7CiAKIAlmb3JfZWFjaF9jcHVfbWFzayhjcHUsIGNwdV9hc3NvY2lhdGl2aXR5X2NoYW5nZXNfbWFzaykgewogCQl2cGhuX2dldF9hc3NvY2lhdGl2aXR5KGNwdSwgYXNzb2NpYXRpdml0eSk7CkBAIC0xNTEyLDcgKzE1MTYsOCBAQAogewogCWludCByYyA9IDA7CiAKLQlpZiAoZmlybXdhcmVfaGFzX2ZlYXR1cmUoRldfRkVBVFVSRV9WUEhOKSkgeworCWlmIChmaXJtd2FyZV9oYXNfZmVhdHVyZShGV19GRUFUVVJFX1ZQSE4pICYmCisJICAgIGdldF9scHBhY2EoKS0+c2hhcmVkX3Byb2MpIHsKIAkJdnBobl9lbmFibGVkID0gMTsKIAkJc2V0dXBfY3B1X2Fzc29jaWF0aXZpdHlfY2hhbmdlX2NvdW50ZXJzKCk7CiAJCWluaXRfdGltZXJfZGVmZXJyYWJsZSgmdG9wb2xvZ3lfdGltZXIpOwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy84M3h4L21wYzgzMHhfcmRiLmMgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zLzgzeHgvbXBjODMweF9yZGIuYwppbmRleCA2NjFkMzU0Li5kMGM0ZTE1IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zLzgzeHgvbXBjODMweF9yZGIuYworKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zLzgzeHgvbXBjODMweF9yZGIuYwpAQCAtNTcsMTIgKzU3LDEyIEBACiAJaXBpY19zZXRfZGVmYXVsdF9wcmlvcml0eSgpOwogfQogCi1zdHJ1Y3QgY29uc3QgY2hhciAqYm9hcmRbXSBfX2luaXRkYXRhID0geworc3RhdGljIGNvbnN0IGNoYXIgKmJvYXJkW10gX19pbml0ZGF0YSA9IHsKIAkiTVBDODMwOFJEQiIsCiAJImZzbCxtcGM4MzA4cmRiIiwKIAkiZGVueCxtcGM4MzA4X3AxbSIsCiAJTlVMTAotfQorfTsKIAogLyoKICAqIENhbGxlZCB2ZXJ5IGVhcmx5LCBNTVUgaXMgb2ZmLCBkZXZpY2UtdHJlZSBpc24ndCB1bmZsYXR0ZW5lZApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy84M3h4L21wYzgzMXhfcmRiLmMgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zLzgzeHgvbXBjODMxeF9yZGIuYwppbmRleCBiNTRjZDczLi5mODU5ZWFkIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zLzgzeHgvbXBjODMxeF9yZGIuYworKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zLzgzeHgvbXBjODMxeF9yZGIuYwpAQCAtNjAsMTEgKzYwLDExIEBACiAJaXBpY19zZXRfZGVmYXVsdF9wcmlvcml0eSgpOwogfQogCi1zdHJ1Y3QgY29uc3QgY2hhciAqYm9hcmRbXSBfX2luaXRkYXRhID0geworc3RhdGljIGNvbnN0IGNoYXIgKmJvYXJkW10gX19pbml0ZGF0YSA9IHsKIAkiTVBDODMxM0VSREIiLAogCSJmc2wsbXBjODMxNWVyZGIiLAogCU5VTEwKLX0KK307CiAKIC8qCiAgKiBDYWxsZWQgdmVyeSBlYXJseSwgTU1VIGlzIG9mZiwgZGV2aWNlLXRyZWUgaXNuJ3QgdW5mbGF0dGVuZWQKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvODN4eC9tcGM4M3h4LmggYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zLzgzeHgvbXBjODN4eC5oCmluZGV4IDBmZWE4ODEuLjgyYTQzNDUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvODN4eC9tcGM4M3h4LmgKKysrIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy84M3h4L21wYzgzeHguaApAQCAtMzUsNiArMzUsOCBAQAogCiAvKiBzeXN0ZW0gaS9vIGNvbmZpZ3VyYXRpb24gcmVnaXN0ZXIgaGlnaCAqLwogI2RlZmluZSBNUEM4M1hYX1NJQ1JIX09GRlMgICAgICAgICAweDExOAorI2RlZmluZSBNUEM4MzA4X1NJQ1JIX1VTQl9NQVNLICAgICAweDAwMGMwMDAwCisjZGVmaW5lIE1QQzgzMDhfU0lDUkhfVVNCX1VMUEkgICAgIDB4MDAwNDAwMDAKICNkZWZpbmUgTVBDODM0WF9TSUNSSF9VU0JfVVRNSSAgICAgMHgwMDAyMDAwMAogI2RlZmluZSBNUEM4MzFYX1NJQ1JIX1VTQl9NQVNLICAgICAweDAwMDAwMGUwCiAjZGVmaW5lIE1QQzgzMVhfU0lDUkhfVVNCX1VMUEkgICAgIDB4MDAwMDAwYTAKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvODN4eC91c2IuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvODN4eC91c2IuYwppbmRleCAzYmE0YmI3Li4yYzY0MTY0IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zLzgzeHgvdXNiLmMKKysrIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy84M3h4L3VzYi5jCkBAIC0xMjcsNyArMTI3LDggQEAKIAogCS8qIENvbmZpZ3VyZSBjbG9jayAqLwogCWltbXJfbm9kZSA9IG9mX2dldF9wYXJlbnQobnApOwotCWlmIChpbW1yX25vZGUgJiYgb2ZfZGV2aWNlX2lzX2NvbXBhdGlibGUoaW1tcl9ub2RlLCAiZnNsLG1wYzgzMTUtaW1tciIpKQorCWlmIChpbW1yX25vZGUgJiYgKG9mX2RldmljZV9pc19jb21wYXRpYmxlKGltbXJfbm9kZSwgImZzbCxtcGM4MzE1LWltbXIiKSB8fAorCQkJb2ZfZGV2aWNlX2lzX2NvbXBhdGlibGUoaW1tcl9ub2RlLCAiZnNsLG1wYzgzMDgtaW1tciIpKSkKIAkJY2xyc2V0Yml0c19iZTMyKGltbWFwICsgTVBDODNYWF9TQ0NSX09GRlMsCiAJCSAgICAgICAgICAgICAgICBNUEM4MzE1X1NDQ1JfVVNCX01BU0ssCiAJCSAgICAgICAgICAgICAgICBNUEM4MzE1X1NDQ1JfVVNCX0RSQ01fMDEpOwpAQCAtMTM4LDcgKzEzOSwxMSBAQAogCiAJLyogQ29uZmlndXJlIHBpbiBtdXggZm9yIFVMUEkuICBUaGVyZSBpcyBubyBwaW4gbXV4IGZvciBVVE1JICovCiAJaWYgKHByb3AgJiYgIXN0cmNtcChwcm9wLCAidWxwaSIpKSB7Ci0JCWlmIChvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShpbW1yX25vZGUsICJmc2wsbXBjODMxNS1pbW1yIikpIHsKKwkJaWYgKG9mX2RldmljZV9pc19jb21wYXRpYmxlKGltbXJfbm9kZSwgImZzbCxtcGM4MzA4LWltbXIiKSkgeworCQkJY2xyc2V0Yml0c19iZTMyKGltbWFwICsgTVBDODNYWF9TSUNSSF9PRkZTLAorCQkJCQlNUEM4MzA4X1NJQ1JIX1VTQl9NQVNLLAorCQkJCQlNUEM4MzA4X1NJQ1JIX1VTQl9VTFBJKTsKKwkJfSBlbHNlIGlmIChvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShpbW1yX25vZGUsICJmc2wsbXBjODMxNS1pbW1yIikpIHsKIAkJCWNscnNldGJpdHNfYmUzMihpbW1hcCArIE1QQzgzWFhfU0lDUkxfT0ZGUywKIAkJCQkJTVBDODMxNV9TSUNSTF9VU0JfTUFTSywKIAkJCQkJTVBDODMxNV9TSUNSTF9VU0JfVUxQSSk7CkBAIC0xNzMsNiArMTc4LDkgQEAKIAkJICAgICAhc3RyY21wKHByb3AsICJ1dG1pIikpKSB7CiAJCXUzMiByZWZzZWw7CiAKKwkJaWYgKG9mX2RldmljZV9pc19jb21wYXRpYmxlKGltbXJfbm9kZSwgImZzbCxtcGM4MzA4LWltbXIiKSkKKwkJCWdvdG8gb3V0OworCiAJCWlmIChvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShpbW1yX25vZGUsICJmc2wsbXBjODMxNS1pbW1yIikpCiAJCQlyZWZzZWwgPSBDT05UUk9MX1JFRlNFTF8yNE1IWjsKIAkJZWxzZQpAQCAtMTg2LDkgKzE5NCwxMSBAQAogCQl0ZW1wID0gQ09OVFJPTF9QSFlfQ0xLX1NFTF9VTFBJOwogI2lmZGVmIENPTkZJR19VU0JfT1RHCiAJCS8qIFNldCBPVEdfUE9SVCAqLwotCQlkcl9tb2RlID0gb2ZfZ2V0X3Byb3BlcnR5KG5wLCAiZHJfbW9kZSIsIE5VTEwpOwotCQlpZiAoZHJfbW9kZSAmJiAhc3RyY21wKGRyX21vZGUsICJvdGciKSkKLQkJCXRlbXAgfD0gQ09OVFJPTF9PVEdfUE9SVDsKKwkJaWYgKCFvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShpbW1yX25vZGUsICJmc2wsbXBjODMwOC1pbW1yIikpIHsKKwkJCWRyX21vZGUgPSBvZl9nZXRfcHJvcGVydHkobnAsICJkcl9tb2RlIiwgTlVMTCk7CisJCQlpZiAoZHJfbW9kZSAmJiAhc3RyY21wKGRyX21vZGUsICJvdGciKSkKKwkJCQl0ZW1wIHw9IENPTlRST0xfT1RHX1BPUlQ7CisJCX0KICNlbmRpZiAvKiBDT05GSUdfVVNCX09URyAqLwogCQlvdXRfYmUzMih1c2JfcmVncyArIEZTTF9VU0IyX0NPTlRST0xfT0ZGUywgdGVtcCk7CiAJfSBlbHNlIHsKQEAgLTE5Niw2ICsyMDYsNyBAQAogCQlyZXQgPSAtRUlOVkFMOwogCX0KIAorb3V0OgogCWlvdW5tYXAodXNiX3JlZ3MpOwogCW9mX25vZGVfcHV0KG5wKTsKIAlyZXR1cm4gcmV0OwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9jZWxsL2NwdWZyZXFfc3B1ZGVtYW5kLmMgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvY3B1ZnJlcV9zcHVkZW1hbmQuYwppbmRleCA5NjhjMWMwLi5kODA5ODM2IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvY3B1ZnJlcV9zcHVkZW1hbmQuYworKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvY3B1ZnJlcV9zcHVkZW1hbmQuYwpAQCAtMzksOCArMzksNiBAQAogfTsKIHN0YXRpYyBERUZJTkVfUEVSX0NQVShzdHJ1Y3Qgc3B1X2dvdl9pbmZvX3N0cnVjdCwgc3B1X2dvdl9pbmZvKTsKIAotc3RhdGljIHN0cnVjdCB3b3JrcXVldWVfc3RydWN0ICprc3B1Z292X3dxOwotCiBzdGF0aWMgaW50IGNhbGNfZnJlcShzdHJ1Y3Qgc3B1X2dvdl9pbmZvX3N0cnVjdCAqaW5mbykKIHsKIAlpbnQgY3B1OwpAQCAtNzEsMTQgKzY5LDE0IEBACiAJX19jcHVmcmVxX2RyaXZlcl90YXJnZXQoaW5mby0+cG9saWN5LCB0YXJnZXRfZnJlcSwgQ1BVRlJFUV9SRUxBVElPTl9IKTsKIAogCWRlbGF5ID0gdXNlY3NfdG9famlmZmllcyhpbmZvLT5wb2xsX2ludCk7Ci0JcXVldWVfZGVsYXllZF93b3JrX29uKGluZm8tPnBvbGljeS0+Y3B1LCBrc3B1Z292X3dxLCAmaW5mby0+d29yaywgZGVsYXkpOworCXNjaGVkdWxlX2RlbGF5ZWRfd29ya19vbihpbmZvLT5wb2xpY3ktPmNwdSwgJmluZm8tPndvcmssIGRlbGF5KTsKIH0KIAogc3RhdGljIHZvaWQgc3B1X2dvdl9pbml0X3dvcmsoc3RydWN0IHNwdV9nb3ZfaW5mb19zdHJ1Y3QgKmluZm8pCiB7CiAJaW50IGRlbGF5ID0gdXNlY3NfdG9famlmZmllcyhpbmZvLT5wb2xsX2ludCk7CiAJSU5JVF9ERUxBWUVEX1dPUktfREVGRVJSQUJMRSgmaW5mby0+d29yaywgc3B1X2dvdl93b3JrKTsKLQlxdWV1ZV9kZWxheWVkX3dvcmtfb24oaW5mby0+cG9saWN5LT5jcHUsIGtzcHVnb3Zfd3EsICZpbmZvLT53b3JrLCBkZWxheSk7CisJc2NoZWR1bGVfZGVsYXllZF93b3JrX29uKGluZm8tPnBvbGljeS0+Y3B1LCAmaW5mby0+d29yaywgZGVsYXkpOwogfQogCiBzdGF0aWMgdm9pZCBzcHVfZ292X2NhbmNlbF93b3JrKHN0cnVjdCBzcHVfZ292X2luZm9fc3RydWN0ICppbmZvKQpAQCAtMTUyLDI3ICsxNTAsMTUgQEAKIHsKIAlpbnQgcmV0OwogCi0Ja3NwdWdvdl93cSA9IGNyZWF0ZV93b3JrcXVldWUoImtzcHVnb3YiKTsKLQlpZiAoIWtzcHVnb3Zfd3EpIHsKLQkJcHJpbnRrKEtFUk5fRVJSICJjcmVhdGlvbiBvZiBrc3B1Z292IGZhaWxlZFxuIik7Ci0JCXJldCA9IC1FRkFVTFQ7Ci0JCWdvdG8gb3V0OwotCX0KLQogCXJldCA9IGNwdWZyZXFfcmVnaXN0ZXJfZ292ZXJub3IoJnNwdV9nb3Zlcm5vcik7Ci0JaWYgKHJldCkgeworCWlmIChyZXQpCiAJCXByaW50ayhLRVJOX0VSUiAicmVnaXN0cmF0aW9uIG9mIGdvdmVybm9yIGZhaWxlZFxuIik7Ci0JCWRlc3Ryb3lfd29ya3F1ZXVlKGtzcHVnb3Zfd3EpOwotCQlnb3RvIG91dDsKLQl9Ci1vdXQ6CiAJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIHZvaWQgX19leGl0IHNwdV9nb3ZfZXhpdCh2b2lkKQogewogCWNwdWZyZXFfdW5yZWdpc3Rlcl9nb3Zlcm5vcigmc3B1X2dvdmVybm9yKTsKLQlkZXN0cm95X3dvcmtxdWV1ZShrc3B1Z292X3dxKTsKIH0KIAogCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvcXBhY2Vfc2V0dXAuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9xcGFjZV9zZXR1cC5jCmluZGV4IDFiNTc0OTAuLmQzMWM1OTQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9xcGFjZV9zZXR1cC5jCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9xcGFjZV9zZXR1cC5jCkBAIC0xNDUsOSArMTQ1LDQgQEAKIAkuY2FsaWJyYXRlX2RlY3IJCT0gZ2VuZXJpY19jYWxpYnJhdGVfZGVjciwKIAkucHJvZ3Jlc3MJCT0gcXBhY2VfcHJvZ3Jlc3MsCiAJLmluaXRfSVJRCQk9IGlpY19pbml0X0lSUSwKLSNpZmRlZiBDT05GSUdfS0VYRUMKLQkubWFjaGluZV9rZXhlYwkJPSBkZWZhdWx0X21hY2hpbmVfa2V4ZWMsCi0JLm1hY2hpbmVfa2V4ZWNfcHJlcGFyZQk9IGRlZmF1bHRfbWFjaGluZV9rZXhlY19wcmVwYXJlLAotCS5tYWNoaW5lX2NyYXNoX3NodXRkb3duCT0gZGVmYXVsdF9tYWNoaW5lX2NyYXNoX3NodXRkb3duLAotI2VuZGlmCiB9OwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9jZWxsL3NwdV9iYXNlLmMgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvc3B1X2Jhc2UuYwppbmRleCA4NTQ3ZTg2Li5hY2ZhY2NlIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvc3B1X2Jhc2UuYworKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvc3B1X2Jhc2UuYwpAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgPGFzbS9zcHVfY3NhLmg+CiAjaW5jbHVkZSA8YXNtL3htb24uaD4KICNpbmNsdWRlIDxhc20vcHJvbS5oPgorI2luY2x1ZGUgPGFzbS9rZXhlYy5oPgogCiBjb25zdCBzdHJ1Y3Qgc3B1X21hbmFnZW1lbnRfb3BzICpzcHVfbWFuYWdlbWVudF9vcHM7CiBFWFBPUlRfU1lNQk9MX0dQTChzcHVfbWFuYWdlbWVudF9vcHMpOwpAQCAtNzI3LDYgKzcyOCw3NSBAQAogCiBzdGF0aWMgU1lTREVWX0FUVFIoc3RhdCwgMDY0NCwgc3B1X3N0YXRfc2hvdywgTlVMTCk7CiAKKyNpZmRlZiBDT05GSUdfS0VYRUMKKworc3RydWN0IGNyYXNoX3NwdV9pbmZvIHsKKwlzdHJ1Y3Qgc3B1ICpzcHU7CisJdTMyIHNhdmVkX3NwdV9ydW5jbnRsX1JXOworCXUzMiBzYXZlZF9zcHVfc3RhdHVzX1I7CisJdTMyIHNhdmVkX3NwdV9ucGNfUlc7CisJdTY0IHNhdmVkX21mY19zcjFfUlc7CisJdTY0IHNhdmVkX21mY19kYXI7CisJdTY0IHNhdmVkX21mY19kc2lzcjsKK307CisKKyNkZWZpbmUgQ1JBU0hfTlVNX1NQVVMJMTYJLyogRW5vdWdoIGZvciBjdXJyZW50IGhhcmR3YXJlICovCitzdGF0aWMgc3RydWN0IGNyYXNoX3NwdV9pbmZvIGNyYXNoX3NwdV9pbmZvW0NSQVNIX05VTV9TUFVTXTsKKworc3RhdGljIHZvaWQgY3Jhc2hfa2V4ZWNfc3RvcF9zcHVzKHZvaWQpCit7CisJc3RydWN0IHNwdSAqc3B1OworCWludCBpOworCXU2NCB0bXA7CisKKwlmb3IgKGkgPSAwOyBpIDwgQ1JBU0hfTlVNX1NQVVM7IGkrKykgeworCQlpZiAoIWNyYXNoX3NwdV9pbmZvW2ldLnNwdSkKKwkJCWNvbnRpbnVlOworCisJCXNwdSA9IGNyYXNoX3NwdV9pbmZvW2ldLnNwdTsKKworCQljcmFzaF9zcHVfaW5mb1tpXS5zYXZlZF9zcHVfcnVuY250bF9SVyA9CisJCQlpbl9iZTMyKCZzcHUtPnByb2JsZW0tPnNwdV9ydW5jbnRsX1JXKTsKKwkJY3Jhc2hfc3B1X2luZm9baV0uc2F2ZWRfc3B1X3N0YXR1c19SID0KKwkJCWluX2JlMzIoJnNwdS0+cHJvYmxlbS0+c3B1X3N0YXR1c19SKTsKKwkJY3Jhc2hfc3B1X2luZm9baV0uc2F2ZWRfc3B1X25wY19SVyA9CisJCQlpbl9iZTMyKCZzcHUtPnByb2JsZW0tPnNwdV9ucGNfUlcpOworCisJCWNyYXNoX3NwdV9pbmZvW2ldLnNhdmVkX21mY19kYXIgICAgPSBzcHVfbWZjX2Rhcl9nZXQoc3B1KTsKKwkJY3Jhc2hfc3B1X2luZm9baV0uc2F2ZWRfbWZjX2RzaXNyICA9IHNwdV9tZmNfZHNpc3JfZ2V0KHNwdSk7CisJCXRtcCA9IHNwdV9tZmNfc3IxX2dldChzcHUpOworCQljcmFzaF9zcHVfaW5mb1tpXS5zYXZlZF9tZmNfc3IxX1JXID0gdG1wOworCisJCXRtcCAmPSB+TUZDX1NUQVRFMV9NQVNURVJfUlVOX0NPTlRST0xfTUFTSzsKKwkJc3B1X21mY19zcjFfc2V0KHNwdSwgdG1wKTsKKworCQlfX2RlbGF5KDIwMCk7CisJfQorfQorCitzdGF0aWMgdm9pZCBjcmFzaF9yZWdpc3Rlcl9zcHVzKHN0cnVjdCBsaXN0X2hlYWQgKmxpc3QpCit7CisJc3RydWN0IHNwdSAqc3B1OworCWludCByZXQ7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHNwdSwgbGlzdCwgZnVsbF9saXN0KSB7CisJCWlmIChXQVJOX09OKHNwdS0+bnVtYmVyID49IENSQVNIX05VTV9TUFVTKSkKKwkJCWNvbnRpbnVlOworCisJCWNyYXNoX3NwdV9pbmZvW3NwdS0+bnVtYmVyXS5zcHUgPSBzcHU7CisJfQorCisJcmV0ID0gY3Jhc2hfc2h1dGRvd25fcmVnaXN0ZXIoJmNyYXNoX2tleGVjX3N0b3Bfc3B1cyk7CisJaWYgKHJldCkKKwkJcHJpbnRrKEtFUk5fRVJSICJDb3VsZCBub3QgcmVnaXN0ZXIgU1BVIGNyYXNoIGhhbmRsZXIiKTsKK30KKworI2Vsc2UKK3N0YXRpYyBpbmxpbmUgdm9pZCBjcmFzaF9yZWdpc3Rlcl9zcHVzKHN0cnVjdCBsaXN0X2hlYWQgKmxpc3QpCit7Cit9CisjZW5kaWYKKwogc3RhdGljIGludCBfX2luaXQgaW5pdF9zcHVfYmFzZSh2b2lkKQogewogCWludCBpLCByZXQgPSAwOwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9jZWxsL3NwdWZzL2ZpbGUuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9zcHVmcy9maWxlLmMKaW5kZXggMDJmN2IxMS4uM2M3YzNmOCAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9jZWxsL3NwdWZzL2ZpbGUuYworKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvc3B1ZnMvZmlsZS5jCkBAIC0yMTksMjQgKzIxOSwxNyBAQAogCWxvZmZfdCBwb3MgPSAqcHBvczsKIAlpbnQgcmV0OwogCi0JaWYgKHBvcyA8IDApCi0JCXJldHVybiAtRUlOVkFMOwogCWlmIChwb3MgPiBMU19TSVpFKQogCQlyZXR1cm4gLUVGQklHOwotCWlmIChzaXplID4gTFNfU0laRSAtIHBvcykKLQkJc2l6ZSA9IExTX1NJWkUgLSBwb3M7CiAKIAlyZXQgPSBzcHVfYWNxdWlyZShjdHgpOwogCWlmIChyZXQpCiAJCXJldHVybiByZXQ7CiAKIAlsb2NhbF9zdG9yZSA9IGN0eC0+b3BzLT5nZXRfbHMoY3R4KTsKLQlyZXQgPSBjb3B5X2Zyb21fdXNlcihsb2NhbF9zdG9yZSArIHBvcywgYnVmZmVyLCBzaXplKTsKKwlzaXplID0gc2ltcGxlX3dyaXRlX3RvX2J1ZmZlcihsb2NhbF9zdG9yZSwgTFNfU0laRSwgcHBvcywgYnVmZmVyLCBzaXplKTsKIAlzcHVfcmVsZWFzZShjdHgpOwogCi0JaWYgKHJldCkKLQkJcmV0dXJuIC1FRkFVTFQ7Ci0JKnBwb3MgPSBwb3MgKyBzaXplOwogCXJldHVybiBzaXplOwogfQogCkBAIC01NzQsMTggKzU2NywxNSBAQAogCWlmICgqcG9zID49IHNpemVvZihsc2NzYS0+Z3BycykpCiAJCXJldHVybiAtRUZCSUc7CiAKLQlzaXplID0gbWluX3Qoc3NpemVfdCwgc2l6ZW9mKGxzY3NhLT5ncHJzKSAtICpwb3MsIHNpemUpOwotCSpwb3MgKz0gc2l6ZTsKLQogCXJldCA9IHNwdV9hY3F1aXJlX3NhdmVkKGN0eCk7CiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKIAotCXJldCA9IGNvcHlfZnJvbV91c2VyKChjaGFyICopbHNjc2EtPmdwcnMgKyAqcG9zIC0gc2l6ZSwKLQkJCSAgICAgYnVmZmVyLCBzaXplKSA/IC1FRkFVTFQgOiBzaXplOworCXNpemUgPSBzaW1wbGVfd3JpdGVfdG9fYnVmZmVyKGxzY3NhLT5ncHJzLCBzaXplb2YobHNjc2EtPmdwcnMpLCBwb3MsCisJCQkJCWJ1ZmZlciwgc2l6ZSk7CiAKIAlzcHVfcmVsZWFzZV9zYXZlZChjdHgpOwotCXJldHVybiByZXQ7CisJcmV0dXJuIHNpemU7CiB9CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHNwdWZzX3JlZ3NfZm9wcyA9IHsKQEAgLTYzMCwxOCArNjIwLDE1IEBACiAJaWYgKCpwb3MgPj0gc2l6ZW9mKGxzY3NhLT5mcGNyKSkKIAkJcmV0dXJuIC1FRkJJRzsKIAotCXNpemUgPSBtaW5fdChzc2l6ZV90LCBzaXplb2YobHNjc2EtPmZwY3IpIC0gKnBvcywgc2l6ZSk7Ci0KIAlyZXQgPSBzcHVfYWNxdWlyZV9zYXZlZChjdHgpOwogCWlmIChyZXQpCiAJCXJldHVybiByZXQ7CiAKLQkqcG9zICs9IHNpemU7Ci0JcmV0ID0gY29weV9mcm9tX3VzZXIoKGNoYXIgKikmbHNjc2EtPmZwY3IgKyAqcG9zIC0gc2l6ZSwKLQkJCSAgICAgYnVmZmVyLCBzaXplKSA/IC1FRkFVTFQgOiBzaXplOworCXNpemUgPSBzaW1wbGVfd3JpdGVfdG9fYnVmZmVyKCZsc2NzYS0+ZnBjciwgc2l6ZW9mKGxzY3NhLT5mcGNyKSwgcG9zLAorCQkJCQlidWZmZXIsIHNpemUpOwogCiAJc3B1X3JlbGVhc2Vfc2F2ZWQoY3R4KTsKLQlyZXR1cm4gcmV0OworCXJldHVybiBzaXplOwogfQogCiBzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBzcHVmc19mcGNyX2ZvcHMgPSB7CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2VtYmVkZGVkNnh4L2dhbWVjdWJlLmMgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2VtYmVkZGVkNnh4L2dhbWVjdWJlLmMKaW5kZXggMTEwNmZkOS4uYTEzOGUxNCAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9lbWJlZGRlZDZ4eC9nYW1lY3ViZS5jCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvZW1iZWRkZWQ2eHgvZ2FtZWN1YmUuYwpAQCAtNzUsMTQgKzc1LDYgQEAKIAlmbGlwcGVyX3F1aWVzY2UoKTsKIH0KIAotI2lmZGVmIENPTkZJR19LRVhFQwotc3RhdGljIGludCBnYW1lY3ViZV9rZXhlY19wcmVwYXJlKHN0cnVjdCBraW1hZ2UgKmltYWdlKQotewotCXJldHVybiAwOwotfQotI2VuZGlmIC8qIENPTkZJR19LRVhFQyAqLwotCi0KIGRlZmluZV9tYWNoaW5lKGdhbWVjdWJlKSB7CiAJLm5hbWUJCQk9ICJnYW1lY3ViZSIsCiAJLnByb2JlCQkJPSBnYW1lY3ViZV9wcm9iZSwKQEAgLTk1LDkgKzg3LDYgQEAKIAkuY2FsaWJyYXRlX2RlY3IJCT0gZ2VuZXJpY19jYWxpYnJhdGVfZGVjciwKIAkucHJvZ3Jlc3MJCT0gdWRiZ19wcm9ncmVzcywKIAkubWFjaGluZV9zaHV0ZG93bgk9IGdhbWVjdWJlX3NodXRkb3duLAotI2lmZGVmIENPTkZJR19LRVhFQwotCS5tYWNoaW5lX2tleGVjX3ByZXBhcmUJPSBnYW1lY3ViZV9rZXhlY19wcmVwYXJlLAotI2VuZGlmCiB9OwogCiAKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvZW1iZWRkZWQ2eHgvd2lpLmMgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2VtYmVkZGVkNnh4L3dpaS5jCmluZGV4IDY0OTQ3M2EuLjFiNWRjMWEgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvZW1iZWRkZWQ2eHgvd2lpLmMKKysrIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9lbWJlZGRlZDZ4eC93aWkuYwpAQCAtMTgsNyArMTgsNiBAQAogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxsaW51eC9pcnEuaD4KICNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgotI2luY2x1ZGUgPGxpbnV4L2tleGVjLmg+CiAjaW5jbHVkZSA8bGludXgvb2ZfcGxhdGZvcm0uaD4KICNpbmNsdWRlIDxsaW51eC9tZW1ibG9jay5oPgogI2luY2x1ZGUgPG1tL21tdV9kZWNsLmg+CkBAIC0yMjYsMTMgKzIyNSw2IEBACiAJZmxpcHBlcl9xdWllc2NlKCk7CiB9CiAKLSNpZmRlZiBDT05GSUdfS0VYRUMKLXN0YXRpYyBpbnQgd2lpX21hY2hpbmVfa2V4ZWNfcHJlcGFyZShzdHJ1Y3Qga2ltYWdlICppbWFnZSkKLXsKLQlyZXR1cm4gMDsKLX0KLSNlbmRpZiAvKiBDT05GSUdfS0VYRUMgKi8KLQogZGVmaW5lX21hY2hpbmUod2lpKSB7CiAJLm5hbWUJCQk9ICJ3aWkiLAogCS5wcm9iZQkJCT0gd2lpX3Byb2JlLApAQCAtMjQ2LDkgKzIzOCw2IEBACiAJLmNhbGlicmF0ZV9kZWNyCQk9IGdlbmVyaWNfY2FsaWJyYXRlX2RlY3IsCiAJLnByb2dyZXNzCQk9IHVkYmdfcHJvZ3Jlc3MsCiAJLm1hY2hpbmVfc2h1dGRvd24JPSB3aWlfc2h1dGRvd24sCi0jaWZkZWYgQ09ORklHX0tFWEVDCi0JLm1hY2hpbmVfa2V4ZWNfcHJlcGFyZQk9IHdpaV9tYWNoaW5lX2tleGVjX3ByZXBhcmUsCi0jZW5kaWYKIH07CiAKIHN0YXRpYyBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIHdpaV9vZl9idXNbXSA9IHsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvaXNlcmllcy9LY29uZmlnIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9pc2VyaWVzL0tjb25maWcKaW5kZXggNDdhMjBjZi4uZTViYzlmNyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9pc2VyaWVzL0tjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9pc2VyaWVzL0tjb25maWcKQEAgLTIsNyArMiw3IEBACiAJYm9vbCAiSUJNIExlZ2FjeSBpU2VyaWVzIgogCWRlcGVuZHMgb24gUFBDNjQgJiYgUFBDX0JPT0szUwogCXNlbGVjdCBQUENfSU5ESVJFQ1RfSU8KLQlzZWxlY3QgUFBDX1BDSV9DSE9JQ0UgaWYgRU1CRURERUQKKwlzZWxlY3QgUFBDX1BDSV9DSE9JQ0UgaWYgRVhQRVJUCiAKIG1lbnUgImlTZXJpZXMgZGV2aWNlIGRyaXZlcnMiCiAJZGVwZW5kcyBvbiBQUENfSVNFUklFUwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wc2VyaWVzL0tjb25maWcgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3BzZXJpZXMvS2NvbmZpZwppbmRleCA1ZDFiNzQzLi41YjNkYTRiIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3BzZXJpZXMvS2NvbmZpZworKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3BzZXJpZXMvS2NvbmZpZwpAQCAtMTAsNyArMTAsNyBAQAogCXNlbGVjdCBSVEFTX0VSUk9SX0xPR0dJTkcKIAlzZWxlY3QgUFBDX1VEQkdfMTY1NTAKIAlzZWxlY3QgUFBDX05BVElWRQotCXNlbGVjdCBQUENfUENJX0NIT0lDRSBpZiBFTUJFRERFRAorCXNlbGVjdCBQUENfUENJX0NIT0lDRSBpZiBFWFBFUlQKIAlkZWZhdWx0IHkKIAogY29uZmlnIFBQQ19TUExQQVIKQEAgLTI0LDkgKzI0LDkgQEAKIAkgIHR3byBvciBtb3JlIHBhcnRpdGlvbnMuCiAKIGNvbmZpZyBFRUgKLQlib29sICJQQ0kgRXh0ZW5kZWQgRXJyb3IgSGFuZGxpbmcgKEVFSCkiIGlmIEVNQkVEREVECisJYm9vbCAiUENJIEV4dGVuZGVkIEVycm9yIEhhbmRsaW5nIChFRUgpIiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFBQQ19QU0VSSUVTICYmIFBDSQotCWRlZmF1bHQgeSBpZiAhRU1CRURERUQKKwlkZWZhdWx0IHkgaWYgIUVYUEVSVAogCiBjb25maWcgUFNFUklFU19NU0kKICAgICAgICBib29sCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3BzZXJpZXMva2V4ZWMuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9rZXhlYy5jCmluZGV4IDUzY2JkNTMuLjc3ZDM4YTUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9rZXhlYy5jCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9rZXhlYy5jCkBAIC02MSwxMyArNjEsMyBAQAogewogCXBwY19tZC5rZXhlY19jcHVfZG93biA9IHBzZXJpZXNfa2V4ZWNfY3B1X2Rvd25feGljczsKIH0KLQotc3RhdGljIGludCBfX2luaXQgcHNlcmllc19rZXhlY19zZXR1cCh2b2lkKQotewotCXBwY19tZC5tYWNoaW5lX2tleGVjID0gZGVmYXVsdF9tYWNoaW5lX2tleGVjOwotCXBwY19tZC5tYWNoaW5lX2tleGVjX3ByZXBhcmUgPSBkZWZhdWx0X21hY2hpbmVfa2V4ZWNfcHJlcGFyZTsKLQlwcGNfbWQubWFjaGluZV9jcmFzaF9zaHV0ZG93biA9IGRlZmF1bHRfbWFjaGluZV9jcmFzaF9zaHV0ZG93bjsKLQotCXJldHVybiAwOwotfQotbWFjaGluZV9kZXZpY2VfaW5pdGNhbGwocHNlcmllcywgcHNlcmllc19rZXhlY19zZXR1cCk7CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3BzZXJpZXMvbHBhci5jIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wc2VyaWVzL2xwYXIuYwppbmRleCA1ZDNlYTlmLi5jYTVkNTg5IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3BzZXJpZXMvbHBhci5jCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9scGFyLmMKQEAgLTcxMyw2ICs3MTMsMTMgQEAKIC8qIE5COiByZWcvdW5yZWcgYXJlIGNhbGxlZCB3aGlsZSBndWFyZGVkIHdpdGggdGhlIHRyYWNlcG9pbnRzX211dGV4ICovCiBleHRlcm4gbG9uZyBoY2FsbF90cmFjZXBvaW50X3JlZmNvdW50OwogCisvKiAKKyAqIFNpbmNlIHRoZSB0cmFjaW5nIGNvZGUgbWlnaHQgZXhlY3V0ZSBoY2FsbHMgd2UgbmVlZCB0byBndWFyZCBhZ2FpbnN0CisgKiByZWN1cnNpb24uIE9uZSBleGFtcGxlIG9mIHRoaXMgYXJlIHNwaW5sb2NrcyBjYWxsaW5nIEhfWUlFTEQgb24KKyAqIHNoYXJlZCBwcm9jZXNzb3IgcGFydGl0aW9ucy4KKyAqLworc3RhdGljIERFRklORV9QRVJfQ1BVKHVuc2lnbmVkIGludCwgaGNhbGxfdHJhY2VfZGVwdGgpOworCiB2b2lkIGhjYWxsX3RyYWNlcG9pbnRfcmVnZnVuYyh2b2lkKQogewogCWhjYWxsX3RyYWNlcG9pbnRfcmVmY291bnQrKzsKQEAgLTcyNSwxMiArNzMyLDQyIEBACiAKIHZvaWQgX190cmFjZV9oY2FsbF9lbnRyeSh1bnNpZ25lZCBsb25nIG9wY29kZSwgdW5zaWduZWQgbG9uZyAqYXJncykKIHsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXVuc2lnbmVkIGludCAqZGVwdGg7CisKKwlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CisKKwlkZXB0aCA9ICZfX2dldF9jcHVfdmFyKGhjYWxsX3RyYWNlX2RlcHRoKTsKKworCWlmICgqZGVwdGgpCisJCWdvdG8gb3V0OworCisJKCpkZXB0aCkrKzsKIAl0cmFjZV9oY2FsbF9lbnRyeShvcGNvZGUsIGFyZ3MpOworCSgqZGVwdGgpLS07CisKK291dDoKKwlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CiB9CiAKIHZvaWQgX190cmFjZV9oY2FsbF9leGl0KGxvbmcgb3Bjb2RlLCB1bnNpZ25lZCBsb25nIHJldHZhbCwKIAkJCXVuc2lnbmVkIGxvbmcgKnJldGJ1ZikKIHsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXVuc2lnbmVkIGludCAqZGVwdGg7CisKKwlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CisKKwlkZXB0aCA9ICZfX2dldF9jcHVfdmFyKGhjYWxsX3RyYWNlX2RlcHRoKTsKKworCWlmICgqZGVwdGgpCisJCWdvdG8gb3V0OworCisJKCpkZXB0aCkrKzsKIAl0cmFjZV9oY2FsbF9leGl0KG9wY29kZSwgcmV0dmFsLCByZXRidWYpOworCSgqZGVwdGgpLS07CisKK291dDoKKwlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CiB9CiAjZW5kaWYKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9yYXMuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9yYXMuYwppbmRleCBhNGZjNmRhLi5jNTVkN2FkIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3BzZXJpZXMvcmFzLmMKKysrIGIvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wc2VyaWVzL3Jhcy5jCkBAIC01NCw3ICs1NCw4IEBACiBzdGF0aWMgdW5zaWduZWQgY2hhciByYXNfbG9nX2J1ZltSVEFTX0VSUk9SX0xPR19NQVhdOwogc3RhdGljIERFRklORV9TUElOTE9DSyhyYXNfbG9nX2J1Zl9sb2NrKTsKIAotc3RhdGljIGNoYXIgbWNlX2RhdGFfYnVmW1JUQVNfRVJST1JfTE9HX01BWF07CitzdGF0aWMgY2hhciBnbG9iYWxfbWNlX2RhdGFfYnVmW1JUQVNfRVJST1JfTE9HX01BWF07CitzdGF0aWMgREVGSU5FX1BFUl9DUFUoX191NjQsIG1jZV9kYXRhX2J1Zik7CiAKIHN0YXRpYyBpbnQgcmFzX2dldF9zZW5zb3Jfc3RhdGVfdG9rZW47CiBzdGF0aWMgaW50IHJhc19jaGVja19leGNlcHRpb25fdG9rZW47CkBAIC0xOTYsMTIgKzE5NywyNCBAQAogCXJldHVybiBJUlFfSEFORExFRDsKIH0KIAotLyogR2V0IHRoZSBlcnJvciBpbmZvcm1hdGlvbiBmb3IgZXJyb3JzIGNvbWluZyB0aHJvdWdoIHRoZQorLyoKKyAqIFNvbWUgdmVyc2lvbnMgb2YgRldOTUkgcGxhY2UgdGhlIGJ1ZmZlciBpbnNpZGUgdGhlIDRrQiBwYWdlIHN0YXJ0aW5nIGF0CisgKiAweDcwMDAuIE90aGVyIHZlcnNpb25zIHBsYWNlIGl0IGluc2lkZSB0aGUgcnRhcyBidWZmZXIuIFdlIGNoZWNrIGJvdGguCisgKi8KKyNkZWZpbmUgVkFMSURfRldOTUlfQlVGRkVSKEEpIFwKKwkoKCgoQSkgPj0gMHg3MDAwKSAmJiAoKEEpIDwgMHg3ZmYwKSkgfHwgXAorCSgoKEEpID49IHJ0YXMuYmFzZSkgJiYgKChBKSA8IChydGFzLmJhc2UgKyBydGFzLnNpemUgLSAxNikpKSkKKworLyoKKyAqIEdldCB0aGUgZXJyb3IgaW5mb3JtYXRpb24gZm9yIGVycm9ycyBjb21pbmcgdGhyb3VnaCB0aGUKICAqIEZXTk1JIHZlY3RvcnMuICBUaGUgcHRfcmVncycgcjMgd2lsbCBiZSB1cGRhdGVkIHRvIHJlZmxlY3QKICAqIHRoZSBhY3R1YWwgcjMgaWYgcG9zc2libGUsIGFuZCBhIHB0ciB0byB0aGUgZXJyb3IgbG9nIGVudHJ5CiAgKiB3aWxsIGJlIHJldHVybmVkIGlmIGZvdW5kLgogICoKLSAqIFRoZSBtY2VfZGF0YV9idWYgZG9lcyBub3QgaGF2ZSBhbnkgbG9ja3Mgb3IgcHJvdGVjdGlvbiBhcm91bmQgaXQsCisgKiBJZiB0aGUgUlRBUyBlcnJvciBpcyBub3Qgb2YgdGhlIGV4dGVuZGVkIHR5cGUsIHRoZW4gd2UgcHV0IGl0IGluIGEgcGVyCisgKiBjcHUgNjRiaXQgYnVmZmVyLiBJZiBpdCBpcyB0aGUgZXh0ZW5kZWQgdHlwZSB3ZSB1c2UgZ2xvYmFsX21jZV9kYXRhX2J1Zi4KKyAqCisgKiBUaGUgZ2xvYmFsX21jZV9kYXRhX2J1ZiBkb2VzIG5vdCBoYXZlIGFueSBsb2NrcyBvciBwcm90ZWN0aW9uIGFyb3VuZCBpdCwKICAqIGlmIGEgc2Vjb25kIG1hY2hpbmUgY2hlY2sgY29tZXMgaW4sIG9yIGEgc3lzdGVtIHJlc2V0IGlzIGRvbmUKICAqIGJlZm9yZSB3ZSBoYXZlIGxvZ2dlZCB0aGUgZXJyb3IsIHRoZW4gd2Ugd2lsbCBnZXQgY29ycnVwdGlvbiBpbiB0aGUKICAqIGVycm9yIGxvZy4gIFRoaXMgaXMgcHJlZmVyYWJsZSBvdmVyIGhvbGRpbmcgb2ZmIG9uIGNhbGxpbmcKQEAgLTIxMCwyMCArMjIzLDMxIEBACiAgKi8KIHN0YXRpYyBzdHJ1Y3QgcnRhc19lcnJvcl9sb2cgKmZ3bm1pX2dldF9lcnJpbmZvKHN0cnVjdCBwdF9yZWdzICpyZWdzKQogewotCXVuc2lnbmVkIGxvbmcgZXJyZGF0YSA9IHJlZ3MtPmdwclszXTsKLQlzdHJ1Y3QgcnRhc19lcnJvcl9sb2cgKmVycmhkciA9IE5VTEw7CiAJdW5zaWduZWQgbG9uZyAqc2F2ZXA7CisJc3RydWN0IHJ0YXNfZXJyb3JfbG9nICpoLCAqZXJyaGRyID0gTlVMTDsKIAotCWlmICgoZXJyZGF0YSA+PSAweDcwMDAgJiYgZXJyZGF0YSA8IDB4N2ZmZjApIHx8Ci0JICAgIChlcnJkYXRhID49IHJ0YXMuYmFzZSAmJiBlcnJkYXRhIDwgcnRhcy5iYXNlICsgcnRhcy5zaXplIC0gMTYpKSB7Ci0JCXNhdmVwID0gX192YShlcnJkYXRhKTsKLQkJcmVncy0+Z3ByWzNdID0gc2F2ZXBbMF07CS8qIHJlc3RvcmUgb3JpZ2luYWwgcjMgKi8KLQkJbWVtc2V0KG1jZV9kYXRhX2J1ZiwgMCwgUlRBU19FUlJPUl9MT0dfTUFYKTsKLQkJbWVtY3B5KG1jZV9kYXRhX2J1ZiwgKGNoYXIgKikoc2F2ZXAgKyAxKSwgUlRBU19FUlJPUl9MT0dfTUFYKTsKLQkJZXJyaGRyID0gKHN0cnVjdCBydGFzX2Vycm9yX2xvZyAqKW1jZV9kYXRhX2J1ZjsKLQl9IGVsc2UgewotCQlwcmludGsoIkZXTk1JOiBjb3JydXB0IHIzXG4iKTsKKwlpZiAoIVZBTElEX0ZXTk1JX0JVRkZFUihyZWdzLT5ncHJbM10pKSB7CisJCXByaW50ayhLRVJOX0VSUiAiRldOTUk6IGNvcnJ1cHQgcjNcbiIpOworCQlyZXR1cm4gTlVMTDsKIAl9CisKKwlzYXZlcCA9IF9fdmEocmVncy0+Z3ByWzNdKTsKKwlyZWdzLT5ncHJbM10gPSBzYXZlcFswXTsJLyogcmVzdG9yZSBvcmlnaW5hbCByMyAqLworCisJLyogSWYgaXQgaXNuJ3QgYW4gZXh0ZW5kZWQgbG9nIHdlIGNhbiB1c2UgdGhlIHBlciBjcHUgNjRiaXQgYnVmZmVyICovCisJaCA9IChzdHJ1Y3QgcnRhc19lcnJvcl9sb2cgKikmc2F2ZXBbMV07CisJaWYgKCFoLT5leHRlbmRlZCkgeworCQltZW1jcHkoJl9fZ2V0X2NwdV92YXIobWNlX2RhdGFfYnVmKSwgaCwgc2l6ZW9mKF9fdTY0KSk7CisJCWVycmhkciA9IChzdHJ1Y3QgcnRhc19lcnJvcl9sb2cgKikmX19nZXRfY3B1X3ZhcihtY2VfZGF0YV9idWYpOworCX0gZWxzZSB7CisJCWludCBsZW47CisKKwkJbGVuID0gbWF4X3QoaW50LCA4K2gtPmV4dGVuZGVkX2xvZ19sZW5ndGgsIFJUQVNfRVJST1JfTE9HX01BWCk7CisJCW1lbXNldChnbG9iYWxfbWNlX2RhdGFfYnVmLCAwLCBSVEFTX0VSUk9SX0xPR19NQVgpOworCQltZW1jcHkoZ2xvYmFsX21jZV9kYXRhX2J1ZiwgaCwgbGVuKTsKKwkJZXJyaGRyID0gKHN0cnVjdCBydGFzX2Vycm9yX2xvZyAqKWdsb2JhbF9tY2VfZGF0YV9idWY7CisJfQorCiAJcmV0dXJuIGVycmhkcjsKIH0KIApAQCAtMjM1LDcgKzI1OSw3IEBACiB7CiAJaW50IHJldCA9IHJ0YXNfY2FsbChydGFzX3Rva2VuKCJpYm0sbm1pLWludGVybG9jayIpLCAwLCAxLCBOVUxMKTsKIAlpZiAocmV0ICE9IDApCi0JCXByaW50aygiRldOTUk6IG5taS1pbnRlcmxvY2sgZmFpbGVkOiAlZFxuIiwgcmV0KTsKKwkJcHJpbnRrKEtFUk5fRVJSICJGV05NSTogbm1pLWludGVybG9jayBmYWlsZWQ6ICVkXG4iLCByZXQpOwogfQogCiBpbnQgcFNlcmllc19zeXN0ZW1fcmVzZXRfZXhjZXB0aW9uKHN0cnVjdCBwdF9yZWdzICpyZWdzKQpAQCAtMjU5LDMxICsyODMsNDMgQEAKICAqIFJldHVybiAxIGlmIGNvcnJlY3RlZCAob3IgZGVsaXZlcmVkIGEgc2lnbmFsKS4KICAqIFJldHVybiAwIGlmIHRoZXJlIGlzIG5vdGhpbmcgd2UgY2FuIGRvLgogICovCi1zdGF0aWMgaW50IHJlY292ZXJfbWNlKHN0cnVjdCBwdF9yZWdzICpyZWdzLCBzdHJ1Y3QgcnRhc19lcnJvcl9sb2cgKiBlcnIpCitzdGF0aWMgaW50IHJlY292ZXJfbWNlKHN0cnVjdCBwdF9yZWdzICpyZWdzLCBzdHJ1Y3QgcnRhc19lcnJvcl9sb2cgKmVycikKIHsKLQlpbnQgbm9uZmF0YWwgPSAwOworCWludCByZWNvdmVyZWQgPSAwOwogCi0JaWYgKGVyci0+ZGlzcG9zaXRpb24gPT0gUlRBU19ESVNQX0ZVTExZX1JFQ09WRVJFRCkgeworCWlmICghKHJlZ3MtPm1zciAmIE1TUl9SSSkpIHsKKwkJLyogSWYgTVNSX1JJIGlzbid0IHNldCwgd2UgY2Fubm90IHJlY292ZXIgKi8KKwkJcmVjb3ZlcmVkID0gMDsKKworCX0gZWxzZSBpZiAoZXJyLT5kaXNwb3NpdGlvbiA9PSBSVEFTX0RJU1BfRlVMTFlfUkVDT1ZFUkVEKSB7CiAJCS8qIFBsYXRmb3JtIGNvcnJlY3RlZCBpdHNlbGYgKi8KLQkJbm9uZmF0YWwgPSAxOwotCX0gZWxzZSBpZiAoKHJlZ3MtPm1zciAmIE1TUl9SSSkgJiYKLQkJICAgdXNlcl9tb2RlKHJlZ3MpICYmCi0JCSAgIGVyci0+c2V2ZXJpdHkgPT0gUlRBU19TRVZFUklUWV9FUlJPUl9TWU5DICYmCi0JCSAgIGVyci0+ZGlzcG9zaXRpb24gPT0gUlRBU19ESVNQX05PVF9SRUNPVkVSRUQgJiYKLQkJICAgZXJyLT50YXJnZXQgPT0gUlRBU19UQVJHRVRfTUVNT1JZICYmCi0JCSAgIGVyci0+dHlwZSA9PSBSVEFTX1RZUEVfRUNDX1VOQ09SUiAmJgotCQkgICAhKGN1cnJlbnQtPnBpZCA9PSAwIHx8IGlzX2dsb2JhbF9pbml0KGN1cnJlbnQpKSkgewotCQkvKiBLaWxsIG9mZiBhIHVzZXIgcHJvY2VzcyB3aXRoIGFuIEVDQyBlcnJvciAqLwotCQlwcmludGsoS0VSTl9FUlIgIk1DRTogdW5jb3JyZWN0YWJsZSBlY2MgZXJyb3IgZm9yIHBpZCAlZFxuIiwKLQkJICAgICAgIGN1cnJlbnQtPnBpZCk7Ci0JCS8qIFhYWCBzb21ldGhpbmcgYmV0dGVyIGZvciBFQ0MgZXJyb3I/ICovCi0JCV9leGNlcHRpb24oU0lHQlVTLCByZWdzLCBCVVNfQURSRVJSLCByZWdzLT5uaXApOwotCQlub25mYXRhbCA9IDE7CisJCXJlY292ZXJlZCA9IDE7CisKKwl9IGVsc2UgaWYgKGVyci0+ZGlzcG9zaXRpb24gPT0gUlRBU19ESVNQX0xJTUlURURfUkVDT1ZFUlkpIHsKKwkJLyogUGxhdGZvcm0gY29ycmVjdGVkIGl0c2VsZiBidXQgY291bGQgYmUgZGVncmFkZWQgKi8KKwkJcHJpbnRrKEtFUk5fRVJSICJNQ0U6IGxpbWl0ZWQgcmVjb3ZlcnksIHN5c3RlbSBtYXkgIgorCQkgICAgICAgImJlIGRlZ3JhZGVkXG4iKTsKKwkJcmVjb3ZlcmVkID0gMTsKKworCX0gZWxzZSBpZiAodXNlcl9tb2RlKHJlZ3MpICYmICFpc19nbG9iYWxfaW5pdChjdXJyZW50KSAmJgorCQkgICBlcnItPnNldmVyaXR5ID09IFJUQVNfU0VWRVJJVFlfRVJST1JfU1lOQykgeworCisJCS8qCisJCSAqIElmIHdlIHJlY2VpdmVkIGEgc3luY2hyb25vdXMgZXJyb3Igd2hlbiBpbiB1c2Vyc3BhY2UKKwkJICoga2lsbCB0aGUgdGFzay4gRmlybXdhcmUgbWF5IHJlcG9ydCBkZXRhaWxzIG9mIHRoZSBmYWlsCisJCSAqIGFzeW5jaHJvbm91c2x5LCBzbyB3ZSBjYW4ndCByZWx5IG9uIHRoZSB0YXJnZXQgYW5kIHR5cGUKKwkJICogZmllbGRzIGJlaW5nIHZhbGlkIGhlcmUuCisJCSAqLworCQlwcmludGsoS0VSTl9FUlIgIk1DRTogdW5jb3JyZWN0YWJsZSBlcnJvciwga2lsbGluZyB0YXNrICIKKwkJICAgICAgICIlczolZFxuIiwgY3VycmVudC0+Y29tbSwgY3VycmVudC0+cGlkKTsKKworCQlfZXhjZXB0aW9uKFNJR0JVUywgcmVncywgQlVTX01DRUVSUl9BUiwgcmVncy0+bmlwKTsKKwkJcmVjb3ZlcmVkID0gMTsKIAl9CiAKLQlsb2dfZXJyb3IoKGNoYXIgKillcnIsIEVSUl9UWVBFX1JUQVNfTE9HLCAhbm9uZmF0YWwpOworCWxvZ19lcnJvcigoY2hhciAqKWVyciwgRVJSX1RZUEVfUlRBU19MT0csIDApOwogCi0JcmV0dXJuIG5vbmZhdGFsOworCXJldHVybiByZWNvdmVyZWQ7CiB9CiAKIC8qCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvc3lzZGV2L2ZzbF9yaW8uYyBiL2FyY2gvcG93ZXJwYy9zeXNkZXYvZnNsX3Jpby5jCmluZGV4IDlmOTliZWYuLjhjNmNhYjAgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9zeXNkZXYvZnNsX3Jpby5jCisrKyBiL2FyY2gvcG93ZXJwYy9zeXNkZXYvZnNsX3Jpby5jCkBAIC0xNTU1LDggKzE1NTUsNiBAQAogCXNhdmVkX21jaGVja19leGNlcHRpb24gPSBwcGNfbWQubWFjaGluZV9jaGVja19leGNlcHRpb247CiAJcHBjX21kLm1hY2hpbmVfY2hlY2tfZXhjZXB0aW9uID0gZnNsX3Jpb19tY2hlY2tfZXhjZXB0aW9uOwogI2VuZGlmCi0JLyogRW5zdXJlIHRoYXQgUkZYRSBpcyBzZXQgKi8KLQltdHNwcihTUFJOX0hJRDEsIChtZnNwcihTUFJOX0hJRDEpIHwgMHgyMDAwMCkpOwogCiAJcmV0dXJuIDA7CiBlcnI6CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvc3lzZGV2L21waWMuYyBiL2FyY2gvcG93ZXJwYy9zeXNkZXYvbXBpYy5jCmluZGV4IDdjMTM0MjYuLmIwYzg0NjkgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9zeXNkZXYvbXBpYy5jCisrKyBiL2FyY2gvcG93ZXJwYy9zeXNkZXYvbXBpYy5jCkBAIC02NzQsNyArNjc0LDggQEAKIAkvKiBtYWtlIHN1cmUgbWFzayBnZXRzIHRvIGNvbnRyb2xsZXIgYmVmb3JlIHdlIHJldHVybiB0byB1c2VyICovCiAJZG8gewogCQlpZiAoIWxvb3BzLS0pIHsKLQkJCXByaW50ayhLRVJOX0VSUiAibXBpY19lbmFibGVfaXJxIHRpbWVvdXRcbiIpOworCQkJcHJpbnRrKEtFUk5fRVJSICIlczogdGltZW91dCBvbiBod2lycSAldVxuIiwKKwkJCSAgICAgICBfX2Z1bmNfXywgc3JjKTsKIAkJCWJyZWFrOwogCQl9CiAJfSB3aGlsZShtcGljX2lycV9yZWFkKHNyYywgTVBJQ19JTkZPKElSUV9WRUNUT1JfUFJJKSkgJiBNUElDX1ZFQ1BSSV9NQVNLKTsKQEAgLTY5NSw3ICs2OTYsOCBAQAogCS8qIG1ha2Ugc3VyZSBtYXNrIGdldHMgdG8gY29udHJvbGxlciBiZWZvcmUgd2UgcmV0dXJuIHRvIHVzZXIgKi8KIAlkbyB7CiAJCWlmICghbG9vcHMtLSkgewotCQkJcHJpbnRrKEtFUk5fRVJSICJtcGljX2VuYWJsZV9pcnEgdGltZW91dFxuIik7CisJCQlwcmludGsoS0VSTl9FUlIgIiVzOiB0aW1lb3V0IG9uIGh3aXJxICV1XG4iLAorCQkJICAgICAgIF9fZnVuY19fLCBzcmMpOwogCQkJYnJlYWs7CiAJCX0KIAl9IHdoaWxlKCEobXBpY19pcnFfcmVhZChzcmMsIE1QSUNfSU5GTyhJUlFfVkVDVE9SX1BSSSkpICYgTVBJQ19WRUNQUklfTUFTSykpOwpkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL0tjb25maWcgYi9hcmNoL3MzOTAvS2NvbmZpZwppbmRleCBmZjE5ZWZkLi42MzZiY2I4IDEwMDY0NAotLS0gYS9hcmNoL3MzOTAvS2NvbmZpZworKysgYi9hcmNoL3MzOTAvS2NvbmZpZwpAQCAtNDA2LDcgKzQwNiw3IEBACiAJICBJZiB1bnN1cmUsIHNheSBZLgogCiBjb25maWcgQ0hTQ19TQ0gKLQlkZWZfdHJpc3RhdGUgeQorCWRlZl90cmlzdGF0ZSBtCiAJcHJvbXB0ICJTdXBwb3J0IGZvciBDSFNDIHN1YmNoYW5uZWxzIgogCWhlbHAKIAkgIFRoaXMgZHJpdmVyIGFsbG93cyB1c2FnZSBvZiBDSFNDIHN1YmNoYW5uZWxzLiBBIENIU0Mgc3ViY2hhbm5lbApkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2RlZmNvbmZpZyBiL2FyY2gvczM5MC9kZWZjb25maWcKaW5kZXggZDc5Njk3MS4uMjljODJjNiAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2RlZmNvbmZpZworKysgYi9hcmNoL3MzOTAvZGVmY29uZmlnCkBAIC01LDEwICs1LDIxIEBACiBDT05GSUdfUkNVX1RSQUNFPXkKIENPTkZJR19JS0NPTkZJRz15CiBDT05GSUdfSUtDT05GSUdfUFJPQz15CitDT05GSUdfQ0dST1VQUz15CitDT05GSUdfQ1BVU0VUUz15CitDT05GSUdfQ0dST1VQX0NQVUFDQ1Q9eQorQ09ORklHX1JFU09VUkNFX0NPVU5URVJTPXkKK0NPTkZJR19DR1JPVVBfTUVNX1JFU19DVExSPXkKK0NPTkZJR19DR1JPVVBfTUVNX1JFU19DVExSX1NXQVA9eQorQ09ORklHX0NHUk9VUF9TQ0hFRD15CitDT05GSUdfUlRfR1JPVVBfU0NIRUQ9eQorQ09ORklHX0JMS19DR1JPVVA9eQogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKICMgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKLUNPTkZJR19QRVJGX0VWRU5UUz15CisjIENPTkZJR19DT01QQVRfQlJLIGlzIG5vdCBzZXQKIENPTkZJR19TTEFCPXkKK0NPTkZJR19QUk9GSUxJTkc9eQorQ09ORklHX09QUk9GSUxFPXkKIENPTkZJR19LUFJPQkVTPXkKIENPTkZJR19NT0RVTEVTPXkKIENPTkZJR19NT0RVTEVfVU5MT0FEPXkKQEAgLTE5LDcgKzMwLDkgQEAKIENPTkZJR19QUkVFTVBUPXkKIENPTkZJR19NRU1PUllfSE9UUExVRz15CiBDT05GSUdfTUVNT1JZX0hPVFJFTU9WRT15CitDT05GSUdfS1NNPXkKIENPTkZJR19CSU5GTVRfTUlTQz1tCitDT05GSUdfQ01NPW0KIENPTkZJR19IWl8xMDA9eQogQ09ORklHX0tFWEVDPXkKIENPTkZJR19QTT15CkBAIC0xMDUsNiArMTE4LDcgQEAKIENPTkZJR19ERUJVR19OT1RJRklFUlM9eQogIyBDT05GSUdfUkNVX0NQVV9TVEFMTF9ERVRFQ1RPUiBpcyBub3Qgc2V0CiBDT05GSUdfS1BST0JFU19TQU5JVFlfVEVTVD15CitDT05GSUdfREVCVUdfRk9SQ0VfV0VBS19QRVJfQ1BVPXkKIENPTkZJR19DUFVfTk9USUZJRVJfRVJST1JfSU5KRUNUPW0KIENPTkZJR19MQVRFTkNZVE9QPXkKIENPTkZJR19TWVNDVExfU1lTQ0FMTF9DSEVDSz15CmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oIGIvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaAppbmRleCA0MDVjYzk3Li43ZTFmNzc2IDEwMDY0NAotLS0gYS9hcmNoL3MzOTAvaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oCisrKyBiL2FyY2gvczM5MC9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmgKQEAgLTEsMjkgKzEsOCBAQAogI2lmbmRlZiBfUzM5MF9DQUNIRUZMVVNIX0gKICNkZWZpbmUgX1MzOTBfQ0FDSEVGTFVTSF9ICiAKLS8qIEtlZXAgaW5jbHVkZXMgdGhlIHNhbWUgYWNyb3NzIGFyY2hlcy4gICovCi0jaW5jbHVkZSA8bGludXgvbW0uaD4KLQogLyogQ2FjaGVzIGFyZW4ndCBicmFpbi1kZWFkIG9uIHRoZSBzMzkwLiAqLwotI2RlZmluZSBmbHVzaF9jYWNoZV9hbGwoKQkJCWRvIHsgfSB3aGlsZSAoMCkKLSNkZWZpbmUgZmx1c2hfY2FjaGVfbW0obW0pCQkJZG8geyB9IHdoaWxlICgwKQotI2RlZmluZSBmbHVzaF9jYWNoZV9kdXBfbW0obW0pCQkJZG8geyB9IHdoaWxlICgwKQotI2RlZmluZSBmbHVzaF9jYWNoZV9yYW5nZSh2bWEsIHN0YXJ0LCBlbmQpCWRvIHsgfSB3aGlsZSAoMCkKLSNkZWZpbmUgZmx1c2hfY2FjaGVfcGFnZSh2bWEsIHZtYWRkciwgcGZuKQlkbyB7IH0gd2hpbGUgKDApCi0jZGVmaW5lIEFSQ0hfSU1QTEVNRU5UU19GTFVTSF9EQ0FDSEVfUEFHRSAwCi0jZGVmaW5lIGZsdXNoX2RjYWNoZV9wYWdlKHBhZ2UpCQkJZG8geyB9IHdoaWxlICgwKQotI2RlZmluZSBmbHVzaF9kY2FjaGVfbW1hcF9sb2NrKG1hcHBpbmcpCQlkbyB7IH0gd2hpbGUgKDApCi0jZGVmaW5lIGZsdXNoX2RjYWNoZV9tbWFwX3VubG9jayhtYXBwaW5nKQlkbyB7IH0gd2hpbGUgKDApCi0jZGVmaW5lIGZsdXNoX2ljYWNoZV9yYW5nZShzdGFydCwgZW5kKQkJZG8geyB9IHdoaWxlICgwKQotI2RlZmluZSBmbHVzaF9pY2FjaGVfcGFnZSh2bWEscGcpCQlkbyB7IH0gd2hpbGUgKDApCi0jZGVmaW5lIGZsdXNoX2ljYWNoZV91c2VyX3JhbmdlKHZtYSxwZyxhZHIsbGVuKQlkbyB7IH0gd2hpbGUgKDApCi0jZGVmaW5lIGZsdXNoX2NhY2hlX3ZtYXAoc3RhcnQsIGVuZCkJCWRvIHsgfSB3aGlsZSAoMCkKLSNkZWZpbmUgZmx1c2hfY2FjaGVfdnVubWFwKHN0YXJ0LCBlbmQpCQlkbyB7IH0gd2hpbGUgKDApCi0KLSNkZWZpbmUgY29weV90b191c2VyX3BhZ2Uodm1hLCBwYWdlLCB2YWRkciwgZHN0LCBzcmMsIGxlbikgXAotCW1lbWNweShkc3QsIHNyYywgbGVuKQotI2RlZmluZSBjb3B5X2Zyb21fdXNlcl9wYWdlKHZtYSwgcGFnZSwgdmFkZHIsIGRzdCwgc3JjLCBsZW4pIFwKLQltZW1jcHkoZHN0LCBzcmMsIGxlbikKKyNpbmNsdWRlIDxhc20tZ2VuZXJpYy9jYWNoZWZsdXNoLmg+CiAKICNpZmRlZiBDT05GSUdfREVCVUdfUEFHRUFMTE9DCiB2b2lkIGtlcm5lbF9tYXBfcGFnZXMoc3RydWN0IHBhZ2UgKnBhZ2UsIGludCBudW1wYWdlcywgaW50IGVuYWJsZSk7CmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvaW5jbHVkZS9hc20vY29tcGF0LmggYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vY29tcGF0LmgKaW5kZXggYTg3NWMyZi4uZGEzNTljYSAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL2NvbXBhdC5oCisrKyBiL2FyY2gvczM5MC9pbmNsdWRlL2FzbS9jb21wYXQuaApAQCAtMTY5LDcgKzE2OSw3IEBACiAKIHN0YXRpYyBpbmxpbmUgaW50IGlzX2NvbXBhdF90YXNrKHZvaWQpCiB7Ci0JcmV0dXJuIHRlc3RfdGhyZWFkX2ZsYWcoVElGXzMxQklUKTsKKwlyZXR1cm4gaXNfMzJiaXRfdGFzaygpOwogfQogCiAjZWxzZQpkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL2VsZi5oIGIvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL2VsZi5oCmluZGV4IDM1NGQ0MjYuLjEwYzAyOWMgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9pbmNsdWRlL2FzbS9lbGYuaAorKysgYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vZWxmLmgKQEAgLTE2MSw3ICsxNjEsOSBAQAogICAgdXNlIG9mIHRoaXMgaXMgdG8gaW52b2tlICIuL2xkLnNvIHNvbWVwcm9nIiB0byB0ZXN0IG91dCBhIG5ldyB2ZXJzaW9uIG9mCiAgICB0aGUgbG9hZGVyLiAgV2UgbmVlZCB0byBtYWtlIHN1cmUgdGhhdCBpdCBpcyBvdXQgb2YgdGhlIHdheSBvZiB0aGUgcHJvZ3JhbQogICAgdGhhdCBpdCB3aWxsICJleGVjIiwgYW5kIHRoYXQgdGhlcmUgaXMgc3VmZmljaWVudCByb29tIGZvciB0aGUgYnJrLiAgKi8KLSNkZWZpbmUgRUxGX0VUX0RZTl9CQVNFCQkoU1RBQ0tfVE9QIC8gMyAqIDIpCisKK2V4dGVybiB1bnNpZ25lZCBsb25nIHJhbmRvbWl6ZV9ldF9keW4odW5zaWduZWQgbG9uZyBiYXNlKTsKKyNkZWZpbmUgRUxGX0VUX0RZTl9CQVNFCQkocmFuZG9taXplX2V0X2R5bihTVEFDS19UT1AgLyAzICogMikpCiAKIC8qIFRoaXMgeWllbGRzIGEgbWFzayB0aGF0IHVzZXIgcHJvZ3JhbXMgY2FuIHVzZSB0byBmaWd1cmUgb3V0IHdoYXQKICAgIGluc3RydWN0aW9uIHNldCB0aGlzIENQVSBzdXBwb3J0cy4gKi8KQEAgLTIwNiw2ICsyMDgsOCBAQAogCWN1cnJlbnQtPm1tLT5jb250ZXh0Lm5vZXhlYyA9PSAwOwkJXAogfSkKIAorI2RlZmluZSBTVEFDS19STkRfTUFTSwkweDdmZlVMCisKICNkZWZpbmUgQVJDSF9ETElORk8JCQkJCQkJICAgIFwKIGRvIHsJCQkJCQkJCQkgICAgXAogCWlmICh2ZHNvX2VuYWJsZWQpCQkJCQkJICAgIFwKQEAgLTIxOCw0ICsyMjIsNyBAQAogI2RlZmluZSBBUkNIX0hBU19TRVRVUF9BRERJVElPTkFMX1BBR0VTIDEKIGludCBhcmNoX3NldHVwX2FkZGl0aW9uYWxfcGFnZXMoc3RydWN0IGxpbnV4X2JpbnBybSAqLCBpbnQpOwogCitleHRlcm4gdW5zaWduZWQgbG9uZyBhcmNoX3JhbmRvbWl6ZV9icmsoc3RydWN0IG1tX3N0cnVjdCAqbW0pOworI2RlZmluZSBhcmNoX3JhbmRvbWl6ZV9icmsgYXJjaF9yYW5kb21pemVfYnJrCisKICNlbmRpZgpkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL3N5c3RlbS5oIGIvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL3N5c3RlbS5oCmluZGV4IDY3MTBiMGUuLjhmOGQ3NTkgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9pbmNsdWRlL2FzbS9zeXN0ZW0uaAorKysgYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vc3lzdGVtLmgKQEAgLTQ0OSw3ICs0NDksNyBAQAogZXh0ZXJuIHZvaWQgKCpfbWFjaGluZV9oYWx0KSh2b2lkKTsKIGV4dGVybiB2b2lkICgqX21hY2hpbmVfcG93ZXJfb2ZmKSh2b2lkKTsKIAotI2RlZmluZSBhcmNoX2FsaWduX3N0YWNrKHgpICh4KQorZXh0ZXJuIHVuc2lnbmVkIGxvbmcgYXJjaF9hbGlnbl9zdGFjayh1bnNpZ25lZCBsb25nIHNwKTsKIAogc3RhdGljIGlubGluZSBpbnQgdHByb3QodW5zaWduZWQgbG9uZyBhZGRyKQogewpkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL3RocmVhZF9pbmZvLmggYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vdGhyZWFkX2luZm8uaAppbmRleCBlYmM3NzA5Li5hZDEzODJmIDEwMDY0NAotLS0gYS9hcmNoL3MzOTAvaW5jbHVkZS9hc20vdGhyZWFkX2luZm8uaAorKysgYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vdGhyZWFkX2luZm8uaApAQCAtMTE4LDYgKzExOCwxMiBAQAogI2RlZmluZSBfVElGX1NJTkdMRV9TVEVQCSgxPDxUSUZfRlJFRVpFKQogI2RlZmluZSBfVElGX0ZSRUVaRQkJKDE8PFRJRl9GUkVFWkUpCiAKKyNpZmRlZiBDT05GSUdfNjRCSVQKKyNkZWZpbmUgaXNfMzJiaXRfdGFzaygpCQkodGVzdF90aHJlYWRfZmxhZyhUSUZfMzFCSVQpKQorI2Vsc2UKKyNkZWZpbmUgaXNfMzJiaXRfdGFzaygpCQkoMSkKKyNlbmRpZgorCiAjZW5kaWYgLyogX19LRVJORUxfXyAqLwogCiAjZGVmaW5lIFBSRUVNUFRfQUNUSVZFCQkweDQwMDAwMDAKZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9pbmNsdWRlL2FzbS90bGIuaCBiL2FyY2gvczM5MC9pbmNsdWRlL2FzbS90bGIuaAppbmRleCBmMWY2NDRmLi45MDc0YTU0IDEwMDY0NAotLS0gYS9hcmNoL3MzOTAvaW5jbHVkZS9hc20vdGxiLmgKKysrIGIvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL3RsYi5oCkBAIC0yMiw2ICsyMiw3IEBACiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L21tLmg+CisjaW5jbHVkZSA8bGludXgvcGFnZW1hcC5oPgogI2luY2x1ZGUgPGxpbnV4L3N3YXAuaD4KICNpbmNsdWRlIDxhc20vcHJvY2Vzc29yLmg+CiAjaW5jbHVkZSA8YXNtL3BnYWxsb2MuaD4KZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9rZXJuZWwvcHJvY2Vzcy5jIGIvYXJjaC9zMzkwL2tlcm5lbC9wcm9jZXNzLmMKaW5kZXggNmJhNDIyMi4uYTg5NWU2OSAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2tlcm5lbC9wcm9jZXNzLmMKKysrIGIvYXJjaC9zMzkwL2tlcm5lbC9wcm9jZXNzLmMKQEAgLTMwLDkgKzMwLDExIEBACiAjaW5jbHVkZSA8bGludXgvdGljay5oPgogI2luY2x1ZGUgPGxpbnV4L2VsZmNvcmUuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWxfc3RhdC5oPgorI2luY2x1ZGUgPGxpbnV4L3BlcnNvbmFsaXR5Lmg+CiAjaW5jbHVkZSA8bGludXgvc3lzY2FsbHMuaD4KICNpbmNsdWRlIDxsaW51eC9jb21wYXQuaD4KICNpbmNsdWRlIDxsaW51eC9rcHJvYmVzLmg+CisjaW5jbHVkZSA8bGludXgvcmFuZG9tLmg+CiAjaW5jbHVkZSA8YXNtL2NvbXBhdC5oPgogI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CiAjaW5jbHVkZSA8YXNtL3BndGFibGUuaD4KQEAgLTMzMiwzICszMzQsMzkgQEAKIAl9CiAJcmV0dXJuIDA7CiB9CisKK3Vuc2lnbmVkIGxvbmcgYXJjaF9hbGlnbl9zdGFjayh1bnNpZ25lZCBsb25nIHNwKQoreworCWlmICghKGN1cnJlbnQtPnBlcnNvbmFsaXR5ICYgQUREUl9OT19SQU5ET01JWkUpICYmIHJhbmRvbWl6ZV92YV9zcGFjZSkKKwkJc3AgLT0gZ2V0X3JhbmRvbV9pbnQoKSAmIH5QQUdFX01BU0s7CisJcmV0dXJuIHNwICYgfjB4ZjsKK30KKworc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIGJya19ybmQodm9pZCkKK3sKKwkvKiA4TUIgZm9yIDMyYml0LCAxR0IgZm9yIDY0Yml0ICovCisJaWYgKGlzXzMyYml0X3Rhc2soKSkKKwkJcmV0dXJuIChnZXRfcmFuZG9tX2ludCgpICYgMHg3ZmZVTCkgPDwgUEFHRV9TSElGVDsKKwllbHNlCisJCXJldHVybiAoZ2V0X3JhbmRvbV9pbnQoKSAmIDB4M2ZmZmZVTCkgPDwgUEFHRV9TSElGVDsKK30KKwordW5zaWduZWQgbG9uZyBhcmNoX3JhbmRvbWl6ZV9icmsoc3RydWN0IG1tX3N0cnVjdCAqbW0pCit7CisJdW5zaWduZWQgbG9uZyByZXQgPSBQQUdFX0FMSUdOKG1tLT5icmsgKyBicmtfcm5kKCkpOworCisJaWYgKHJldCA8IG1tLT5icmspCisJCXJldHVybiBtbS0+YnJrOworCXJldHVybiByZXQ7Cit9CisKK3Vuc2lnbmVkIGxvbmcgcmFuZG9taXplX2V0X2R5bih1bnNpZ25lZCBsb25nIGJhc2UpCit7CisJdW5zaWduZWQgbG9uZyByZXQgPSBQQUdFX0FMSUdOKGJhc2UgKyBicmtfcm5kKCkpOworCisJaWYgKCEoY3VycmVudC0+ZmxhZ3MgJiBQRl9SQU5ET01JWkUpKQorCQlyZXR1cm4gYmFzZTsKKwlpZiAocmV0IDwgYmFzZSkKKwkJcmV0dXJuIGJhc2U7CisJcmV0dXJuIHJldDsKK30KZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9rZXJuZWwvdmRzby5jIGIvYXJjaC9zMzkwL2tlcm5lbC92ZHNvLmMKaW5kZXggZTMxNTBkZC4uZjQzOGQ3NCAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2tlcm5lbC92ZHNvLmMKKysrIGIvYXJjaC9zMzkwL2tlcm5lbC92ZHNvLmMKQEAgLTIwMyw3ICsyMDMsNiBAQAogCWlmICghdXNlc19pbnRlcnApCiAJCXJldHVybiAwOwogCi0JdmRzb19iYXNlID0gbW0tPm1tYXBfYmFzZTsKICNpZmRlZiBDT05GSUdfNjRCSVQKIAl2ZHNvX3BhZ2VsaXN0ID0gdmRzbzY0X3BhZ2VsaXN0OwogCXZkc29fcGFnZXMgPSB2ZHNvNjRfcGFnZXM7CkBAIC0yMzMsOCArMjMyLDcgQEAKIAkgKiBmYWlsIGFuZCBlbmQgdXAgcHV0dGluZyBpdCBlbHNld2hlcmUuCiAJICovCiAJZG93bl93cml0ZSgmbW0tPm1tYXBfc2VtKTsKLQl2ZHNvX2Jhc2UgPSBnZXRfdW5tYXBwZWRfYXJlYShOVUxMLCB2ZHNvX2Jhc2UsCi0JCQkJICAgICAgdmRzb19wYWdlcyA8PCBQQUdFX1NISUZULCAwLCAwKTsKKwl2ZHNvX2Jhc2UgPSBnZXRfdW5tYXBwZWRfYXJlYShOVUxMLCAwLCB2ZHNvX3BhZ2VzIDw8IFBBR0VfU0hJRlQsIDAsIDApOwogCWlmIChJU19FUlJfVkFMVUUodmRzb19iYXNlKSkgewogCQlyYyA9IHZkc29fYmFzZTsKIAkJZ290byBvdXRfdXA7CmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvbGliL3VhY2Nlc3Nfc3RkLmMgYi9hcmNoL3MzOTAvbGliL3VhY2Nlc3Nfc3RkLmMKaW5kZXggMDdkZWFlZS4uYTZjNGY3ZSAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2xpYi91YWNjZXNzX3N0ZC5jCisrKyBiL2FyY2gvczM5MC9saWIvdWFjY2Vzc19zdGQuYwpAQCAtMTI1LDkgKzEyNSw5IEBACiAJdW5zaWduZWQgbG9uZyB0bXAxOwogCiAJYXNtIHZvbGF0aWxlKAorCQkiICAgc2FjZiAgMjU2XG4iCiAJCSIgICJBSEkiICAlMCwtMVxuIgogCQkiICAgam8gICAgNWZcbiIKLQkJIiAgIHNhY2YgIDI1NlxuIgogCQkiICAgYnJhcyAgJTMsM2ZcbiIKIAkJIjA6IkFISSIgICUwLDI1N1xuIgogCQkiMTogbXZjICAgMCgxLCUxKSwwKCUyKVxuIgpAQCAtMTQyLDkgKzE0Miw4IEBACiAJCSIzOiJBSEkiICAlMCwtMjU2XG4iCiAJCSIgICBqbm0gICAyYlxuIgogCQkiNDogZXggICAgJTAsMWItMGIoJTMpXG4iCi0JCSIgICBzYWNmICAwXG4iCiAJCSI1OiAiU0xSIiAgJTAsJTBcbiIKLQkJIjY6XG4iCisJCSI2OiBzYWNmICAwXG4iCiAJCUVYX1RBQkxFKDFiLDZiKSBFWF9UQUJMRSgyYiwwYikgRVhfVEFCTEUoNGIsMGIpCiAJCTogIithIiAoc2l6ZSksICIrYSIgKHRvKSwgIithIiAoZnJvbSksICI9YSIgKHRtcDEpCiAJCTogOiAiY2MiLCAibWVtb3J5Iik7CkBAIC0xNTYsOSArMTU1LDkgQEAKIAl1bnNpZ25lZCBsb25nIHRtcDEsIHRtcDI7CiAKIAlhc20gdm9sYXRpbGUoCisJCSIgICBzYWNmICAyNTZcbiIKIAkJIiAgIkFISSIgICUwLC0xXG4iCiAJCSIgICBqbyAgICA1ZlxuIgotCQkiICAgc2FjZiAgMjU2XG4iCiAJCSIgICBicmFzICAlMywzZlxuIgogCQkiICAgeGMgICAgMCgxLCUxKSwwKCUxKVxuIgogCQkiMDoiQUhJIiAgJTAsMjU3XG4iCkBAIC0xNzgsOSArMTc3LDggQEAKIAkJIjM6IkFISSIgICUwLC0yNTZcbiIKIAkJIiAgIGpubSAgIDJiXG4iCiAJCSI0OiBleCAgICAlMCwwKCUzKVxuIgotCQkiICAgc2FjZiAgMFxuIgogCQkiNTogIlNMUiIgICUwLCUwXG4iCi0JCSI2OlxuIgorCQkiNjogc2FjZiAgMFxuIgogCQlFWF9UQUJMRSgxYiw2YikgRVhfVEFCTEUoMmIsMGIpIEVYX1RBQkxFKDRiLDBiKQogCQk6ICIrYSIgKHNpemUpLCAiK2EiICh0byksICI9YSIgKHRtcDEpLCAiPWEiICh0bXAyKQogCQk6IDogImNjIiwgIm1lbW9yeSIpOwpkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL21tL21tYXAuYyBiL2FyY2gvczM5MC9tbS9tbWFwLmMKaW5kZXggODY5ZWZiYS4uYzlhOWY3ZiAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL21tL21tYXAuYworKysgYi9hcmNoL3MzOTAvbW0vbW1hcC5jCkBAIC0yNywxNyArMjcsNDQgQEAKICNpbmNsdWRlIDxsaW51eC9wZXJzb25hbGl0eS5oPgogI2luY2x1ZGUgPGxpbnV4L21tLmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvcmFuZG9tLmg+CiAjaW5jbHVkZSA8YXNtL3BnYWxsb2MuaD4KICNpbmNsdWRlIDxhc20vY29tcGF0Lmg+CiAKK3N0YXRpYyB1bnNpZ25lZCBsb25nIHN0YWNrX21heHJhbmRvbV9zaXplKHZvaWQpCit7CisJaWYgKCEoY3VycmVudC0+ZmxhZ3MgJiBQRl9SQU5ET01JWkUpKQorCQlyZXR1cm4gMDsKKwlpZiAoY3VycmVudC0+cGVyc29uYWxpdHkgJiBBRERSX05PX1JBTkRPTUlaRSkKKwkJcmV0dXJuIDA7CisJcmV0dXJuIFNUQUNLX1JORF9NQVNLIDw8IFBBR0VfU0hJRlQ7Cit9CisKIC8qCiAgKiBUb3Agb2YgbW1hcCBhcmVhIChqdXN0IGJlbG93IHRoZSBwcm9jZXNzIHN0YWNrKS4KICAqCi0gKiBMZWF2ZSBhbiBhdCBsZWFzdCB+MTI4IE1CIGhvbGUuCisgKiBMZWF2ZSBhdCBsZWFzdCBhIH4zMiBNQiBob2xlLgogICovCi0jZGVmaW5lIE1JTl9HQVAgKDEyOCoxMDI0KjEwMjQpCisjZGVmaW5lIE1JTl9HQVAgKDMyKjEwMjQqMTAyNCkKICNkZWZpbmUgTUFYX0dBUCAoU1RBQ0tfVE9QLzYqNSkKIAorc3RhdGljIGlubGluZSBpbnQgbW1hcF9pc19sZWdhY3kodm9pZCkKK3sKKwlpZiAoY3VycmVudC0+cGVyc29uYWxpdHkgJiBBRERSX0NPTVBBVF9MQVlPVVQpCisJCXJldHVybiAxOworCWlmIChybGltaXQoUkxJTUlUX1NUQUNLKSA9PSBSTElNX0lORklOSVRZKQorCQlyZXR1cm4gMTsKKwlyZXR1cm4gc3lzY3RsX2xlZ2FjeV92YV9sYXlvdXQ7Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBsb25nIG1tYXBfcm5kKHZvaWQpCit7CisJaWYgKCEoY3VycmVudC0+ZmxhZ3MgJiBQRl9SQU5ET01JWkUpKQorCQlyZXR1cm4gMDsKKwkvKiA4TUIgcmFuZG9taXphdGlvbiBmb3IgbW1hcF9iYXNlICovCisJcmV0dXJuIChnZXRfcmFuZG9tX2ludCgpICYgMHg3ZmZVTCkgPDwgUEFHRV9TSElGVDsKK30KKwogc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIG1tYXBfYmFzZSh2b2lkKQogewogCXVuc2lnbmVkIGxvbmcgZ2FwID0gcmxpbWl0KFJMSU1JVF9TVEFDSyk7CkBAIC00NiwyMiArNzMsOCBAQAogCQlnYXAgPSBNSU5fR0FQOwogCWVsc2UgaWYgKGdhcCA+IE1BWF9HQVApCiAJCWdhcCA9IE1BWF9HQVA7Ci0KLQlyZXR1cm4gU1RBQ0tfVE9QIC0gKGdhcCAmIFBBR0VfTUFTSyk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgaW50IG1tYXBfaXNfbGVnYWN5KHZvaWQpCi17Ci0jaWZkZWYgQ09ORklHXzY0QklUCi0JLyoKLQkgKiBGb3JjZSBzdGFuZGFyZCBhbGxvY2F0aW9uIGZvciA2NCBiaXQgcHJvZ3JhbXMuCi0JICovCi0JaWYgKCFpc19jb21wYXRfdGFzaygpKQotCQlyZXR1cm4gMTsKLSNlbmRpZgotCXJldHVybiBzeXNjdGxfbGVnYWN5X3ZhX2xheW91dCB8fAotCSAgICAoY3VycmVudC0+cGVyc29uYWxpdHkgJiBBRERSX0NPTVBBVF9MQVlPVVQpIHx8Ci0JICAgIHJsaW1pdChSTElNSVRfU1RBQ0spID09IFJMSU1fSU5GSU5JVFk7CisJZ2FwICY9IFBBR0VfTUFTSzsKKwlyZXR1cm4gU1RBQ0tfVE9QIC0gc3RhY2tfbWF4cmFuZG9tX3NpemUoKSAtIG1tYXBfcm5kKCkgLSBnYXA7CiB9CiAKICNpZm5kZWYgQ09ORklHXzY0QklUCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvbW0vcGd0YWJsZS5jIGIvYXJjaC9zMzkwL21tL3BndGFibGUuYwppbmRleCAwYzcxOWM2Li5lMTg1MGMyIDEwMDY0NAotLS0gYS9hcmNoL3MzOTAvbW0vcGd0YWJsZS5jCisrKyBiL2FyY2gvczM5MC9tbS9wZ3RhYmxlLmMKQEAgLTMzNiw3ICszMzYsOCBAQAogCXBhZ2UtPmZsYWdzIF49IGJpdHM7CiAJaWYgKHBhZ2UtPmZsYWdzICYgRlJBR19NQVNLKSB7CiAJCS8qIFBhZ2Ugbm93IGhhcyBzb21lIGZyZWUgcGd0YWJsZSBmcmFnbWVudHMuICovCi0JCWxpc3RfbW92ZSgmcGFnZS0+bHJ1LCAmbW0tPmNvbnRleHQucGd0YWJsZV9saXN0KTsKKwkJaWYgKCFsaXN0X2VtcHR5KCZwYWdlLT5scnUpKQorCQkJbGlzdF9tb3ZlKCZwYWdlLT5scnUsICZtbS0+Y29udGV4dC5wZ3RhYmxlX2xpc3QpOwogCQlwYWdlID0gTlVMTDsKIAl9IGVsc2UKIAkJLyogQWxsIGZyYWdtZW50cyBvZiB0aGUgNEsgcGFnZSBoYXZlIGJlZW4gZnJlZWQuICovCmRpZmYgLS1naXQgYS9hcmNoL3Njb3JlL0tjb25maWcgYi9hcmNoL3Njb3JlL0tjb25maWcKaW5kZXggNDI5M2ZkY2IuLjI3YjIyOTUgMTAwNjQ0Ci0tLSBhL2FyY2gvc2NvcmUvS2NvbmZpZworKysgYi9hcmNoL3Njb3JlL0tjb25maWcKQEAgLTEsNSArMSw5IEBACiBtZW51ICJNYWNoaW5lIHNlbGVjdGlvbiIKIAorY29uZmlnIFNDT1JFCisgICAgICAgZGVmX2Jvb2wgeQorICAgICAgIHNlbGVjdCBIQVZFX0dFTkVSSUNfSEFSRElSUVMKKwogY2hvaWNlCiAJcHJvbXB0ICJTeXN0ZW0gdHlwZSIKIAlkZWZhdWx0IE1BQ0hfU1BDVDY2MDAKQEAgLTUzLDkgKzU3LDYgQEAKIGNvbmZpZyBTQ0hFRF9OT19OT19PTUlUX0ZSQU1FX1BPSU5URVIKIAlkZWZfYm9vbCB5CiAKLWNvbmZpZyBHRU5FUklDX0hBUkRJUlFTX05PX19ET19JUlEKLQlkZWZfYm9vbCB5Ci0KIGNvbmZpZyBHRU5FUklDX1NZU0NBTExfVEFCTEUKIAlkZWZfYm9vbCB5CiAKQEAgLTY4LDkgKzY5LDYgQEAKIGNvbmZpZyAzMkJJVAogCWRlZl9ib29sIHkKIAotY29uZmlnIEdFTkVSSUNfSEFSRElSUVMKLQlkZWZfYm9vbCB5Ci0KIGNvbmZpZyBBUkNIX0ZMQVRNRU1fRU5BQkxFCiAJZGVmX2Jvb2wgeQogCmRpZmYgLS1naXQgYS9hcmNoL3Njb3JlL2NvbmZpZ3Mvc3BjdDY2MDBfZGVmY29uZmlnIGIvYXJjaC9zY29yZS9jb25maWdzL3NwY3Q2NjAwX2RlZmNvbmZpZwppbmRleCA5ODgzYzUwLi5kZjFlZGJmIDEwMDY0NAotLS0gYS9hcmNoL3Njb3JlL2NvbmZpZ3Mvc3BjdDY2MDBfZGVmY29uZmlnCisrKyBiL2FyY2gvc2NvcmUvY29uZmlncy9zcGN0NjYwMF9kZWZjb25maWcKQEAgLTksNyArOSw3IEBACiBDT05GSUdfU1lTRlNfREVQUkVDQVRFRF9WMj15CiBDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQogIyBDT05GSUdfQ0NfT1BUSU1JWkVfRk9SX1NJWkUgaXMgbm90IHNldAotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfS0FMTFNZTVMgaXMgbm90IHNldAogIyBDT05GSUdfSE9UUExVRyBpcyBub3Qgc2V0CiBDT05GSUdfU0xBQj15CmRpZmYgLS1naXQgYS9hcmNoL3NoL0tjb25maWcgYi9hcmNoL3NoL0tjb25maWcKaW5kZXggZmZmMjUyMi4uOGE5MDExZCAxMDA2NDQKLS0tIGEvYXJjaC9zaC9LY29uZmlnCisrKyBiL2FyY2gvc2gvS2NvbmZpZwpAQCAtMSw2ICsxLDYgQEAKIGNvbmZpZyBTVVBFUkgKIAlkZWZfYm9vbCB5Ci0Jc2VsZWN0IEVNQkVEREVECisJc2VsZWN0IEVYUEVSVAogCXNlbGVjdCBDTEtERVZfTE9PS1VQCiAJc2VsZWN0IEhBVkVfSURFIGlmIEhBU19JT1BPUlQKIAlzZWxlY3QgSEFWRV9NRU1CTE9DSwpAQCAtMTUsNiArMTUsNyBAQAogCXNlbGVjdCBIQVZFX0tFUk5FTF9HWklQCiAJc2VsZWN0IEhBVkVfS0VSTkVMX0JaSVAyCiAJc2VsZWN0IEhBVkVfS0VSTkVMX0xaTUEKKwlzZWxlY3QgSEFWRV9LRVJORUxfWFoKIAlzZWxlY3QgSEFWRV9LRVJORUxfTFpPCiAJc2VsZWN0IEhBVkVfU1lTQ0FMTF9UUkFDRVBPSU5UUwogCXNlbGVjdCBIQVZFX1JFR1NfQU5EX1NUQUNLX0FDQ0VTU19BUEkKZGlmZiAtLWdpdCBhL2FyY2gvc2gvTWFrZWZpbGUgYi9hcmNoL3NoL01ha2VmaWxlCmluZGV4IDljOGM2ZTEuLmUzZDgxNzAgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvTWFrZWZpbGUKKysrIGIvYXJjaC9zaC9NYWtlZmlsZQpAQCAtMjAwLDcgKzIwMCw3IEBACiBsaWJzLSQoQ09ORklHX1NVUEVSSDMyKQkJOj0gYXJjaC9zaC9saWIvCSQobGlicy15KQogbGlicy0kKENPTkZJR19TVVBFUkg2NCkJCTo9IGFyY2gvc2gvbGliNjQvICQobGlicy15KQogCi1CT09UX1RBUkdFVFMgPSB1SW1hZ2UgdUltYWdlLmJ6MiB1SW1hZ2UuZ3ogdUltYWdlLmx6bWEgdUltYWdlLmx6byBcCitCT09UX1RBUkdFVFMgPSB1SW1hZ2UgdUltYWdlLmJ6MiB1SW1hZ2UuZ3ogdUltYWdlLmx6bWEgdUltYWdlLnh6IHVJbWFnZS5sem8gXAogCSAgICAgICB1SW1hZ2Uuc3JlYyB1SW1hZ2UuYmluIHpJbWFnZSB2bWxpbnV4LmJpbiB2bWxpbnV4LnNyZWMgXAogCSAgICAgICByb21JbWFnZQogUEhPTlkgKz0gJChCT09UX1RBUkdFVFMpCkBAIC0yMzAsNSArMjMwLDYgQEAKIAlAZWNobyAnKiB1SW1hZ2UuZ3oJICAgICAgICAgICAtIEtlcm5lbC1vbmx5IGltYWdlIGZvciBVLUJvb3QgKGd6aXApJwogCUBlY2hvICcgIHVJbWFnZS5iejIJICAgICAgICAgICAtIEtlcm5lbC1vbmx5IGltYWdlIGZvciBVLUJvb3QgKGJ6aXAyKScKIAlAZWNobyAnICB1SW1hZ2UubHptYQkgICAgICAgICAgIC0gS2VybmVsLW9ubHkgaW1hZ2UgZm9yIFUtQm9vdCAobHptYSknCisJQGVjaG8gJyAgdUltYWdlLnh6CSAgICAgICAgICAgLSBLZXJuZWwtb25seSBpbWFnZSBmb3IgVS1Cb290ICh4eiknCiAJQGVjaG8gJyAgdUltYWdlLmx6bwkgICAgICAgICAgIC0gS2VybmVsLW9ubHkgaW1hZ2UgZm9yIFUtQm9vdCAobHpvKScKIGVuZGVmCmRpZmYgLS1naXQgYS9hcmNoL3NoL2JvYXJkcy9tYWNoLWVjb3ZlYzI0L3NldHVwLmMgYi9hcmNoL3NoL2JvYXJkcy9tYWNoLWVjb3ZlYzI0L3NldHVwLmMKaW5kZXggMzNiNjYyOS4uNzAxNjY3YSAxMDA2NDQKLS0tIGEvYXJjaC9zaC9ib2FyZHMvbWFjaC1lY292ZWMyNC9zZXR1cC5jCisrKyBiL2FyY2gvc2gvYm9hcmRzL21hY2gtZWNvdmVjMjQvc2V0dXAuYwpAQCAtMTI5NCw2ICsxMjk0LDcgQEAKIAlpMmNfcmVnaXN0ZXJfYm9hcmRfaW5mbygxLCBpMmMxX2RldmljZXMsCiAJCQkJQVJSQVlfU0laRShpMmMxX2RldmljZXMpKTsKIAorI2lmIGRlZmluZWQoQ09ORklHX1ZJREVPX1NIX1ZPVSkgfHwgZGVmaW5lZChDT05GSUdfVklERU9fU0hfVk9VX01PRFVMRSkKIAkvKiBWT1UgKi8KIAlncGlvX3JlcXVlc3QoR1BJT19GTl9EVl9EMTUsIE5VTEwpOwogCWdwaW9fcmVxdWVzdChHUElPX0ZOX0RWX0QxNCwgTlVMTCk7CkBAIC0xMzI1LDYgKzEzMjYsNyBAQAogCiAJLyogUmVtb3ZlIHJlc2V0ICovCiAJZ3Bpb19zZXRfdmFsdWUoR1BJT19QVEc0LCAxKTsKKyNlbmRpZgogCiAJcmV0dXJuIHBsYXRmb3JtX2FkZF9kZXZpY2VzKGVjb3ZlY19kZXZpY2VzLAogCQkJCSAgICBBUlJBWV9TSVpFKGVjb3ZlY19kZXZpY2VzKSk7CmRpZmYgLS1naXQgYS9hcmNoL3NoL2Jvb3QvTWFrZWZpbGUgYi9hcmNoL3NoL2Jvb3QvTWFrZWZpbGUKaW5kZXggMWNlNjM2Mi4uYmE1MTVkOCAxMDA2NDQKLS0tIGEvYXJjaC9zaC9ib290L01ha2VmaWxlCisrKyBiL2FyY2gvc2gvYm9vdC9NYWtlZmlsZQpAQCAtMjQsMTIgKzI0LDEzIEBACiBzdWZmaXgtJChDT05GSUdfS0VSTkVMX0daSVApCTo9IGd6CiBzdWZmaXgtJChDT05GSUdfS0VSTkVMX0JaSVAyKQk6PSBiejIKIHN1ZmZpeC0kKENPTkZJR19LRVJORUxfTFpNQSkJOj0gbHptYQorc3VmZml4LSQoQ09ORklHX0tFUk5FTF9YWikJOj0geHoKIHN1ZmZpeC0kKENPTkZJR19LRVJORUxfTFpPKQk6PSBsem8KIAogdGFyZ2V0cyA6PSB6SW1hZ2Ugdm1saW51eC5zcmVjIHJvbUltYWdlIHVJbWFnZSB1SW1hZ2Uuc3JlYyB1SW1hZ2UuZ3ogXAotCSAgIHVJbWFnZS5iejIgdUltYWdlLmx6bWEgdUltYWdlLmx6byB1SW1hZ2UuYmluCisJICAgdUltYWdlLmJ6MiB1SW1hZ2UubHptYSB1SW1hZ2UueHogdUltYWdlLmx6byB1SW1hZ2UuYmluCiBleHRyYS15ICs9IHZtbGludXguYmluIHZtbGludXguYmluLmd6IHZtbGludXguYmluLmJ6MiB2bWxpbnV4LmJpbi5sem1hIFwKLQkgICB2bWxpbnV4LmJpbi5sem8KKwkgICB2bWxpbnV4LmJpbi54eiB2bWxpbnV4LmJpbi5sem8KIHN1YmRpci0gOj0gY29tcHJlc3NlZCByb21pbWFnZQogCiAkKG9iaikvekltYWdlOiAkKG9iaikvY29tcHJlc3NlZC92bWxpbnV4IEZPUkNFCkBAIC03Niw2ICs3Nyw5IEBACiAkKG9iaikvdm1saW51eC5iaW4ubHptYTogJChvYmopL3ZtbGludXguYmluIEZPUkNFCiAJJChjYWxsIGlmX2NoYW5nZWQsbHptYSkKIAorJChvYmopL3ZtbGludXguYmluLnh6OiAkKG9iaikvdm1saW51eC5iaW4gRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCx4emtlcm4pCisKICQob2JqKS92bWxpbnV4LmJpbi5sem86ICQob2JqKS92bWxpbnV4LmJpbiBGT1JDRQogCSQoY2FsbCBpZl9jaGFuZ2VkLGx6bykKIApAQCAtODgsNiArOTIsOSBAQAogJChvYmopL3VJbWFnZS5sem1hOiAkKG9iaikvdm1saW51eC5iaW4ubHptYQogCSQoY2FsbCBpZl9jaGFuZ2VkLHVpbWFnZSxsem1hKQogCiskKG9iaikvdUltYWdlLnh6OiAkKG9iaikvdm1saW51eC5iaW4ueHoKKwkkKGNhbGwgaWZfY2hhbmdlZCx1aW1hZ2UseHopCisKICQob2JqKS91SW1hZ2UubHpvOiAkKG9iaikvdm1saW51eC5iaW4ubHpvCiAJJChjYWxsIGlmX2NoYW5nZWQsdWltYWdlLGx6bykKIApkaWZmIC0tZ2l0IGEvYXJjaC9zaC9ib290L2NvbXByZXNzZWQvTWFrZWZpbGUgYi9hcmNoL3NoL2Jvb3QvY29tcHJlc3NlZC9NYWtlZmlsZQppbmRleCBjZmE1YTA4Li5lMGIwMjkzIDEwMDY0NAotLS0gYS9hcmNoL3NoL2Jvb3QvY29tcHJlc3NlZC9NYWtlZmlsZQorKysgYi9hcmNoL3NoL2Jvb3QvY29tcHJlc3NlZC9NYWtlZmlsZQpAQCAtNiw3ICs2LDcgQEAKIAogdGFyZ2V0cwkJOj0gdm1saW51eCB2bWxpbnV4LmJpbiB2bWxpbnV4LmJpbi5neiBcCiAJCSAgIHZtbGludXguYmluLmJ6MiB2bWxpbnV4LmJpbi5sem1hIFwKLQkJICAgdm1saW51eC5iaW4ubHpvIFwKKwkJICAgdm1saW51eC5iaW4ueHogdm1saW51eC5iaW4ubHpvIFwKIAkJICAgaGVhZF8kKEJJVFMpLm8gbWlzYy5vIHBpZ2d5Lm8KIAogT0JKRUNUUyA9ICQob2JqKS9oZWFkXyQoQklUUykubyAkKG9iaikvbWlzYy5vICQob2JqKS9jYWNoZS5vCkBAIC01MCw2ICs1MCw4IEBACiAJJChjYWxsIGlmX2NoYW5nZWQsYnppcDIpCiAkKG9iaikvdm1saW51eC5iaW4ubHptYTogJCh2bWxpbnV4LmJpbi5hbGwteSkgRk9SQ0UKIAkkKGNhbGwgaWZfY2hhbmdlZCxsem1hKQorJChvYmopL3ZtbGludXguYmluLnh6OiAkKHZtbGludXguYmluLmFsbC15KSBGT1JDRQorCSQoY2FsbCBpZl9jaGFuZ2VkLHh6a2VybikKICQob2JqKS92bWxpbnV4LmJpbi5sem86ICQodm1saW51eC5iaW4uYWxsLXkpIEZPUkNFCiAJJChjYWxsIGlmX2NoYW5nZWQsbHpvKQogCmRpZmYgLS1naXQgYS9hcmNoL3NoL2Jvb3QvY29tcHJlc3NlZC9taXNjLmMgYi9hcmNoL3NoL2Jvb3QvY29tcHJlc3NlZC9taXNjLmMKaW5kZXggMjcxNDBhNi4uOTU0NzBhNCAxMDA2NDQKLS0tIGEvYXJjaC9zaC9ib290L2NvbXByZXNzZWQvbWlzYy5jCisrKyBiL2FyY2gvc2gvYm9vdC9jb21wcmVzc2VkL21pc2MuYwpAQCAtNjEsNiArNjEsMTAgQEAKICNpbmNsdWRlICIuLi8uLi8uLi8uLi9saWIvZGVjb21wcmVzc191bmx6bWEuYyIKICNlbmRpZgogCisjaWZkZWYgQ09ORklHX0tFUk5FTF9YWgorI2luY2x1ZGUgIi4uLy4uLy4uLy4uL2xpYi9kZWNvbXByZXNzX3VueHouYyIKKyNlbmRpZgorCiAjaWZkZWYgQ09ORklHX0tFUk5FTF9MWk8KICNpbmNsdWRlICIuLi8uLi8uLi8uLi9saWIvZGVjb21wcmVzc191bmx6by5jIgogI2VuZGlmCmRpZmYgLS1naXQgYS9hcmNoL3NoL2luY2x1ZGUvYXNtL3BndGFibGUuaCBiL2FyY2gvc2gvaW5jbHVkZS9hc20vcGd0YWJsZS5oCmluZGV4IDA4M2VhMDYuLmRiODU5MTYgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvaW5jbHVkZS9hc20vcGd0YWJsZS5oCisrKyBiL2FyY2gvc2gvaW5jbHVkZS9hc20vcGd0YWJsZS5oCkBAIC0xMzQsNiArMTM0LDcgQEAKIGV4dGVybiB2b2lkIHBndGFibGVfY2FjaGVfaW5pdCh2b2lkKTsKIAogc3RydWN0IHZtX2FyZWFfc3RydWN0Oworc3RydWN0IG1tX3N0cnVjdDsKIAogZXh0ZXJuIHZvaWQgX191cGRhdGVfY2FjaGUoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCiAJCQkgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsIHB0ZV90IHB0ZSk7CmRpZmYgLS1naXQgYS9hcmNoL3NoL2tlcm5lbC9jcHUvc2g0L3NldHVwLXNoNzc1MC5jIGIvYXJjaC9zaC9rZXJuZWwvY3B1L3NoNC9zZXR1cC1zaDc3NTAuYwppbmRleCBjMmIwYWFhLi42NzI5NDRmIDEwMDY0NAotLS0gYS9hcmNoL3NoL2tlcm5lbC9jcHUvc2g0L3NldHVwLXNoNzc1MC5jCisrKyBiL2FyY2gvc2gva2VybmVsL2NwdS9zaDQvc2V0dXAtc2g3NzUwLmMKQEAgLTIzMCwxMCArMjMwLDEwIEBACiBzdGF0aWMgaW50IF9faW5pdCBzaDc3NTBfZGV2aWNlc19zZXR1cCh2b2lkKQogewogCWlmIChtYWNoX2lzX3J0czc3NTFyMmQoKSkgewotCQlwbGF0Zm9ybV9yZWdpc3Rlcl9kZXZpY2UoJnNjaWZfZGV2aWNlKTsKKwkJcGxhdGZvcm1fZGV2aWNlX3JlZ2lzdGVyKCZzY2lmX2RldmljZSk7CiAJfSBlbHNlIHsKLQkJcGxhdGZvcm1fcmVnaXN0ZXJfZGV2aWNlKCZzY2lfZGV2aWNlKTsKLQkJcGxhdGZvcm1fcmVnaXN0ZXJfZGV2aWNlKCZzY2lmX2RldmljZSk7CisJCXBsYXRmb3JtX2RldmljZV9yZWdpc3Rlcigmc2NpX2RldmljZSk7CisJCXBsYXRmb3JtX2RldmljZV9yZWdpc3Rlcigmc2NpZl9kZXZpY2UpOwogCX0KIAogCXJldHVybiBwbGF0Zm9ybV9hZGRfZGV2aWNlcyhzaDc3NTBfZGV2aWNlcywKZGlmZiAtLWdpdCBhL2FyY2gvc2gva2VybmVsL2NwdS9zaG1vYmlsZS9jcHVpZGxlLmMgYi9hcmNoL3NoL2tlcm5lbC9jcHUvc2htb2JpbGUvY3B1aWRsZS5jCmluZGV4IDgzOTcyYWEuLmMxOWUyYTkgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gva2VybmVsL2NwdS9zaG1vYmlsZS9jcHVpZGxlLmMKKysrIGIvYXJjaC9zaC9rZXJuZWwvY3B1L3NobW9iaWxlL2NwdWlkbGUuYwpAQCAtODEsNyArODEsNiBAQAogCXN0YXRlLT50YXJnZXRfcmVzaWRlbmN5ID0gMSAqIDI7CiAJc3RhdGUtPnBvd2VyX3VzYWdlID0gMzsKIAlzdGF0ZS0+ZmxhZ3MgPSAwOwotCXN0YXRlLT5mbGFncyB8PSBDUFVJRExFX0ZMQUdfU0hBTExPVzsKIAlzdGF0ZS0+ZmxhZ3MgfD0gQ1BVSURMRV9GTEFHX1RJTUVfVkFMSUQ7CiAJc3RhdGUtPmVudGVyID0gY3B1aWRsZV9zbGVlcF9lbnRlcjsKIApkaWZmIC0tZ2l0IGEvYXJjaC9zaC9rZXJuZWwvdG9wb2xvZ3kuYyBiL2FyY2gvc2gva2VybmVsL3RvcG9sb2d5LmMKaW5kZXggOTQ4ZmRiNi4uMzhlODYyOCAxMDA2NDQKLS0tIGEvYXJjaC9zaC9rZXJuZWwvdG9wb2xvZ3kuYworKysgYi9hcmNoL3NoL2tlcm5lbC90b3BvbG9neS5jCkBAIC0xNyw2ICsxNyw3IEBACiBzdGF0aWMgREVGSU5FX1BFUl9DUFUoc3RydWN0IGNwdSwgY3B1X2RldmljZXMpOwogCiBjcHVtYXNrX3QgY3B1X2NvcmVfbWFwW05SX0NQVVNdOworRVhQT1JUX1NZTUJPTChjcHVfY29yZV9tYXApOwogCiBzdGF0aWMgY3B1bWFza190IGNwdV9jb3JlZ3JvdXBfbWFwKHVuc2lnbmVkIGludCBjcHUpCiB7CmRpZmYgLS1naXQgYS9hcmNoL3NoL21tL2h1Z2V0bGJwYWdlLmMgYi9hcmNoL3NoL21tL2h1Z2V0bGJwYWdlLmMKaW5kZXggOTE2M2RiMy4uZDc3NjIzNCAxMDA2NDQKLS0tIGEvYXJjaC9zaC9tbS9odWdldGxicGFnZS5jCisrKyBiL2FyY2gvc2gvbW0vaHVnZXRsYnBhZ2UuYwpAQCAtMzUsNyArMzUsNyBAQAogCQlpZiAocHVkKSB7CiAJCQlwbWQgPSBwbWRfYWxsb2MobW0sIHB1ZCwgYWRkcik7CiAJCQlpZiAocG1kKQotCQkJCXB0ZSA9IHB0ZV9hbGxvY19tYXAobW0sIHBtZCwgYWRkcik7CisJCQkJcHRlID0gcHRlX2FsbG9jX21hcChtbSwgTlVMTCwgcG1kLCBhZGRyKTsKIAkJfQogCX0KIApkaWZmIC0tZ2l0IGEvYXJjaC9zcGFyYy9LY29uZmlnIGIvYXJjaC9zcGFyYy9LY29uZmlnCmluZGV4IDQ1ZDljODcuLjk1Njk1ZTkgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMvS2NvbmZpZworKysgYi9hcmNoL3NwYXJjL0tjb25maWcKQEAgLTUwLDYgKzUwLDcgQEAKIAlzZWxlY3QgUlRDX0RSVl9TVEFSRklSRQogCXNlbGVjdCBIQVZFX1BFUkZfRVZFTlRTCiAJc2VsZWN0IFBFUkZfVVNFX1ZNQUxMT0MKKwlzZWxlY3QgSEFWRV9HRU5FUklDX0hBUkRJUlFTCiAKIGNvbmZpZyBBUkNIX0RFRkNPTkZJRwogCXN0cmluZwpAQCAtMTA3LDEwICsxMDgsNiBAQAogY29uZmlnIE5FRURfUEVSX0NQVV9QQUdFX0ZJUlNUX0NIVU5LCiAJZGVmX2Jvb2wgeSBpZiBTUEFSQzY0CiAKLWNvbmZpZyBHRU5FUklDX0hBUkRJUlFTX05PX19ET19JUlEKLQlib29sCi0JZGVmX2Jvb2wgeSBpZiBTUEFSQzY0Ci0KIGNvbmZpZyBNTVUKIAlib29sCiAJZGVmYXVsdCB5CkBAIC0yNzYsMTAgKzI3Myw2IEBACiAJICBjYW4gYmUgY29udHJvbGxlZCB0aHJvdWdoIC9zeXMvZGV2aWNlcy9zeXN0ZW0vY3B1L2NwdSMuCiAJICBTYXkgTiBpZiB5b3Ugd2FudCB0byBkaXNhYmxlIENQVSBob3RwbHVnLgogCi1jb25maWcgR0VORVJJQ19IQVJESVJRUwotCWJvb2wKLQlkZWZhdWx0IHkgaWYgU1BBUkM2NAotCiBzb3VyY2UgImtlcm5lbC90aW1lL0tjb25maWciCiAKIGlmIFNQQVJDNjQKZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMva2VybmVsL21vZHVsZS5jIGIvYXJjaC9zcGFyYy9rZXJuZWwvbW9kdWxlLmMKaW5kZXggZWUzYzdkZC4uOGQzNDhjNCAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9rZXJuZWwvbW9kdWxlLmMKKysrIGIvYXJjaC9zcGFyYy9rZXJuZWwvbW9kdWxlLmMKQEAgLTIzLDE3ICsyMywxMSBAQAogCiBzdGF0aWMgdm9pZCAqbW9kdWxlX21hcCh1bnNpZ25lZCBsb25nIHNpemUpCiB7Ci0Jc3RydWN0IHZtX3N0cnVjdCAqYXJlYTsKLQotCXNpemUgPSBQQUdFX0FMSUdOKHNpemUpOwotCWlmICghc2l6ZSB8fCBzaXplID4gTU9EVUxFU19MRU4pCisJaWYgKFBBR0VfQUxJR04oc2l6ZSkgPiBNT0RVTEVTX0xFTikKIAkJcmV0dXJuIE5VTEw7Ci0KLQlhcmVhID0gX19nZXRfdm1fYXJlYShzaXplLCBWTV9BTExPQywgTU9EVUxFU19WQUREUiwgTU9EVUxFU19FTkQpOwotCWlmICghYXJlYSkKLQkJcmV0dXJuIE5VTEw7Ci0KLQlyZXR1cm4gX192bWFsbG9jX2FyZWEoYXJlYSwgR0ZQX0tFUk5FTCwgUEFHRV9LRVJORUwpOworCXJldHVybiBfX3ZtYWxsb2Nfbm9kZV9yYW5nZShzaXplLCAxLCBNT0RVTEVTX1ZBRERSLCBNT0RVTEVTX0VORCwKKwkJCQlHRlBfS0VSTkVMLCBQQUdFX0tFUk5FTCwgLTEsCisJCQkJX19idWlsdGluX3JldHVybl9hZGRyZXNzKDApKTsKIH0KIAogc3RhdGljIGNoYXIgKmRvdDJ1bmRlcnNjb3JlKGNoYXIgKm5hbWUpCmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL21tL2dlbmVyaWNfMzIuYyBiL2FyY2gvc3BhcmMvbW0vZ2VuZXJpY18zMi5jCmluZGV4IDVlZGNhYzEuLmU2MDY3YjcgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMvbW0vZ2VuZXJpY18zMi5jCisrKyBiL2FyY2gvc3BhcmMvbW0vZ2VuZXJpY18zMi5jCkBAIC01MCw3ICs1MCw3IEBACiAJCWVuZCA9IFBHRElSX1NJWkU7CiAJb2Zmc2V0IC09IGFkZHJlc3M7CiAJZG8gewotCQlwdGVfdCAqIHB0ZSA9IHB0ZV9hbGxvY19tYXAobW0sIHBtZCwgYWRkcmVzcyk7CisJCXB0ZV90ICpwdGUgPSBwdGVfYWxsb2NfbWFwKG1tLCBOVUxMLCBwbWQsIGFkZHJlc3MpOwogCQlpZiAoIXB0ZSkKIAkJCXJldHVybiAtRU5PTUVNOwogCQlpb19yZW1hcF9wdGVfcmFuZ2UobW0sIHB0ZSwgYWRkcmVzcywgZW5kIC0gYWRkcmVzcywgYWRkcmVzcyArIG9mZnNldCwgcHJvdCwgc3BhY2UpOwpkaWZmIC0tZ2l0IGEvYXJjaC9zcGFyYy9tbS9nZW5lcmljXzY0LmMgYi9hcmNoL3NwYXJjL21tL2dlbmVyaWNfNjQuYwppbmRleCAwNGYyYmY0Li4zY2IwMGRmIDEwMDY0NAotLS0gYS9hcmNoL3NwYXJjL21tL2dlbmVyaWNfNjQuYworKysgYi9hcmNoL3NwYXJjL21tL2dlbmVyaWNfNjQuYwpAQCAtOTIsNyArOTIsNyBAQAogCQllbmQgPSBQR0RJUl9TSVpFOwogCW9mZnNldCAtPSBhZGRyZXNzOwogCWRvIHsKLQkJcHRlX3QgKiBwdGUgPSBwdGVfYWxsb2NfbWFwKG1tLCBwbWQsIGFkZHJlc3MpOworCQlwdGVfdCAqcHRlID0gcHRlX2FsbG9jX21hcChtbSwgTlVMTCwgcG1kLCBhZGRyZXNzKTsKIAkJaWYgKCFwdGUpCiAJCQlyZXR1cm4gLUVOT01FTTsKIAkJaW9fcmVtYXBfcHRlX3JhbmdlKG1tLCBwdGUsIGFkZHJlc3MsIGVuZCAtIGFkZHJlc3MsIGFkZHJlc3MgKyBvZmZzZXQsIHByb3QsIHNwYWNlKTsKZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMvbW0vaHVnZXRsYnBhZ2UuYyBiL2FyY2gvc3BhcmMvbW0vaHVnZXRsYnBhZ2UuYwppbmRleCA1ZmRkZGYxLi5mNGU5NzY0IDEwMDY0NAotLS0gYS9hcmNoL3NwYXJjL21tL2h1Z2V0bGJwYWdlLmMKKysrIGIvYXJjaC9zcGFyYy9tbS9odWdldGxicGFnZS5jCkBAIC0yMTQsNyArMjE0LDcgQEAKIAlpZiAocHVkKSB7CiAJCXBtZCA9IHBtZF9hbGxvYyhtbSwgcHVkLCBhZGRyKTsKIAkJaWYgKHBtZCkKLQkJCXB0ZSA9IHB0ZV9hbGxvY19tYXAobW0sIHBtZCwgYWRkcik7CisJCQlwdGUgPSBwdGVfYWxsb2NfbWFwKG1tLCBOVUxMLCBwbWQsIGFkZHIpOwogCX0KIAlyZXR1cm4gcHRlOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC90aWxlL0tjb25maWcgYi9hcmNoL3RpbGUvS2NvbmZpZwppbmRleCBlMTFiNWZjLi4wODk0OGU0IDEwMDY0NAotLS0gYS9hcmNoL3RpbGUvS2NvbmZpZworKysgYi9hcmNoL3RpbGUvS2NvbmZpZwpAQCAtMSwyNSArMSwzNCBAQAogIyBGb3IgYSBkZXNjcmlwdGlvbiBvZiB0aGUgc3ludGF4IG9mIHRoaXMgY29uZmlndXJhdGlvbiBmaWxlLAogIyBzZWUgRG9jdW1lbnRhdGlvbi9rYnVpbGQvY29uZmlnLWxhbmd1YWdlLnR4dC4KIAorY29uZmlnIFRJTEUKKwlkZWZfYm9vbCB5CisJc2VsZWN0IEhBVkVfS1ZNIGlmICFUSUxFR1gKKwlzZWxlY3QgR0VORVJJQ19GSU5EX0ZJUlNUX0JJVAorCXNlbGVjdCBHRU5FUklDX0ZJTkRfTkVYVF9CSVQKKwlzZWxlY3QgVVNFX0dFTkVSSUNfU01QX0hFTFBFUlMKKwlzZWxlY3QgQ0NfT1BUSU1JWkVfRk9SX1NJWkUKKwlzZWxlY3QgSEFWRV9HRU5FUklDX0hBUkRJUlFTCisJc2VsZWN0IEdFTkVSSUNfSVJRX1BST0JFCisJc2VsZWN0IEdFTkVSSUNfUEVORElOR19JUlEgaWYgU01QCisKKyMgRklYTUU6IGludmVzdGlnYXRlIHdoZXRoZXIgd2UgbmVlZC93YW50IHRoZXNlIG9wdGlvbnMuCisjCXNlbGVjdCBIQVZFX0lPUkVNQVBfUFJPVAorIyAgICAgICBzZWxlY3QgSEFWRV9PUFRQUk9CRVMKKyMgICAgICAgc2VsZWN0IEhBVkVfUkVHU19BTkRfU1RBQ0tfQUNDRVNTX0FQSQorIyAgICAgICBzZWxlY3QgSEFWRV9IV19CUkVBS1BPSU5UCisjICAgICAgIHNlbGVjdCBQRVJGX0VWRU5UUworIyAgICAgICBzZWxlY3QgSEFWRV9VU0VSX1JFVFVSTl9OT1RJRklFUgorIyAgICAgICBjb25maWcgTk9fQk9PVE1FTQorIyAgICAgICBjb25maWcgQVJDSF9TVVBQT1JUU19ERUJVR19QQUdFQUxMT0MKKyMgICAgICAgY29uZmlnIEhVR0VUTEJfUEFHRV9TSVpFX1ZBUklBQkxFCisKIGNvbmZpZyBNTVUKIAlkZWZfYm9vbCB5CiAKIGNvbmZpZyBHRU5FUklDX0NTVU0KIAlkZWZfYm9vbCB5CiAKLWNvbmZpZyBHRU5FUklDX0hBUkRJUlFTCi0JZGVmX2Jvb2wgeQotCi1jb25maWcgR0VORVJJQ19IQVJESVJRU19OT19fRE9fSVJRCi0JZGVmX2Jvb2wgeQotCi1jb25maWcgR0VORVJJQ19JUlFfUFJPQkUKLQlkZWZfYm9vbCB5Ci0KLWNvbmZpZyBHRU5FUklDX1BFTkRJTkdfSVJRCi0JZGVmX2Jvb2wgeQotCWRlcGVuZHMgb24gR0VORVJJQ19IQVJESVJRUyAmJiBTTVAKLQogY29uZmlnIFNFTUFQSE9SRV9TTEVFUEVSUwogCWRlZl9ib29sIHkKIApAQCAtOTcsMjYgKzEwNiw2IEBACiAJc2VsZWN0IEhWQ19EUklWRVIKIAlkZWZfYm9vbCB5CiAKLWNvbmZpZyBUSUxFCi0JZGVmX2Jvb2wgeQotCXNlbGVjdCBIQVZFX0tWTSBpZiAhVElMRUdYCi0Jc2VsZWN0IEdFTkVSSUNfRklORF9GSVJTVF9CSVQKLQlzZWxlY3QgR0VORVJJQ19GSU5EX05FWFRfQklUCi0Jc2VsZWN0IFVTRV9HRU5FUklDX1NNUF9IRUxQRVJTCi0Jc2VsZWN0IENDX09QVElNSVpFX0ZPUl9TSVpFCi0KLSMgRklYTUU6IGludmVzdGlnYXRlIHdoZXRoZXIgd2UgbmVlZC93YW50IHRoZXNlIG9wdGlvbnMuCi0jCXNlbGVjdCBIQVZFX0lPUkVNQVBfUFJPVAotIyAgICAgICBzZWxlY3QgSEFWRV9PUFRQUk9CRVMKLSMgICAgICAgc2VsZWN0IEhBVkVfUkVHU19BTkRfU1RBQ0tfQUNDRVNTX0FQSQotIyAgICAgICBzZWxlY3QgSEFWRV9IV19CUkVBS1BPSU5UCi0jICAgICAgIHNlbGVjdCBQRVJGX0VWRU5UUwotIyAgICAgICBzZWxlY3QgSEFWRV9VU0VSX1JFVFVSTl9OT1RJRklFUgotIyAgICAgICBjb25maWcgTk9fQk9PVE1FTQotIyAgICAgICBjb25maWcgQVJDSF9TVVBQT1JUU19ERUJVR19QQUdFQUxMT0MKLSMgICAgICAgY29uZmlnIEhVR0VUTEJfUEFHRV9TSVpFX1ZBUklBQkxFCi0KLQogIyBQbGVhc2Ugbm90ZTogVElMRS1HeCBzdXBwb3J0IGlzIG5vdCB5ZXQgZmluYWxpemVkOyB0aGlzIGlzCiAjIHRoZSBwcmVsaW1pbmFyeSBzdXBwb3J0LiAgVElMRS1HeCBkcml2ZXJzIGFyZSBvbmx5IHByb3ZpZGVkCiAjIHdpdGggdGhlIGFscGhhIG9yIGJldGEgdGVzdCB2ZXJzaW9ucyBmb3IgVGlsZXJhIGN1c3RvbWVycy4KQEAgLTIyMCw3ICsyMDksNyBAQAogCiBjaG9pY2UKIAlkZXBlbmRzIG9uICFUSUxFR1gKLQlwcm9tcHQgIk1lbW9yeSBzcGxpdCIgaWYgRU1CRURERUQKKwlwcm9tcHQgIk1lbW9yeSBzcGxpdCIgaWYgRVhQRVJUCiAJZGVmYXVsdCBWTVNQTElUXzNHCiAJLS0taGVscC0tLQogCSAgU2VsZWN0IHRoZSBkZXNpcmVkIHNwbGl0IGJldHdlZW4ga2VybmVsIGFuZCB1c2VyIG1lbW9yeS4KZGlmZiAtLWdpdCBhL2FyY2gvdGlsZS9LY29uZmlnLmRlYnVnIGIvYXJjaC90aWxlL0tjb25maWcuZGVidWcKaW5kZXggYTgxZjBmYi4uOWJjMTYxYSAxMDA2NDQKLS0tIGEvYXJjaC90aWxlL0tjb25maWcuZGVidWcKKysrIGIvYXJjaC90aWxlL0tjb25maWcuZGVidWcKQEAgLTMsNyArMyw3IEBACiBzb3VyY2UgImxpYi9LY29uZmlnLmRlYnVnIgogCiBjb25maWcgRUFSTFlfUFJJTlRLCi0JYm9vbCAiRWFybHkgcHJpbnRrIiBpZiBFTUJFRERFRCAmJiBERUJVR19LRVJORUwKKwlib29sICJFYXJseSBwcmludGsiIGlmIEVYUEVSVCAmJiBERUJVR19LRVJORUwKIAlkZWZhdWx0IHkKIAloZWxwCiAJICBXcml0ZSBrZXJuZWwgbG9nIG91dHB1dCBkaXJlY3RseSB2aWEgdGhlIGh5cGVydmlzb3IgY29uc29sZS4KZGlmZiAtLWdpdCBhL2FyY2gvdGlsZS9jb25maWdzL3RpbGVfZGVmY29uZmlnIGIvYXJjaC90aWxlL2NvbmZpZ3MvdGlsZV9kZWZjb25maWcKaW5kZXggOTE5YzU0YS4uMGZlNTQ0NDUgMTAwNjQ0Ci0tLSBhL2FyY2gvdGlsZS9jb25maWdzL3RpbGVfZGVmY29uZmlnCisrKyBiL2FyY2gvdGlsZS9jb25maWdzL3RpbGVfZGVmY29uZmlnCkBAIC0zLDcgKzMsNyBAQAogQ09ORklHX1NZU1ZJUEM9eQogQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKIENPTkZJR19JTklUUkFNRlNfU09VUkNFPSJ1c3IvY29udGVudHMudHh0IgotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogIyBDT05GSUdfQ09NUEFUX0JSSyBpcyBub3Qgc2V0CiBDT05GSUdfUFJPRklMSU5HPXkKIENPTkZJR19NT0RVTEVTPXkKZGlmZiAtLWdpdCBhL2FyY2gvdW0vS2NvbmZpZy5jb21tb24gYi9hcmNoL3VtL0tjb25maWcuY29tbW9uCmluZGV4IDA0OWQwNDguLmUzNTFlMTQgMTAwNjQ0Ci0tLSBhL2FyY2gvdW0vS2NvbmZpZy5jb21tb24KKysrIGIvYXJjaC91bS9LY29uZmlnLmNvbW1vbgpAQCAtMywxNCArMywxMCBAQAogCW9wdGlvbiBkZWZjb25maWdfbGlzdAogCWRlZmF1bHQgImFyY2gvJEFSQ0gvZGVmY29uZmlnIgogCi0jIFVNTCB1c2VzIHRoZSBnZW5lcmljIElSUSBzdWJzeXN0ZW0KLWNvbmZpZyBHRU5FUklDX0hBUkRJUlFTCi0JYm9vbAotCWRlZmF1bHQgeQotCiBjb25maWcgVU1MCiAJYm9vbAogCWRlZmF1bHQgeQorCXNlbGVjdCBIQVZFX0dFTkVSSUNfSEFSRElSUVMKIAogY29uZmlnIE1NVQogCWJvb2wKZGlmZiAtLWdpdCBhL2FyY2gvdW0vS2NvbmZpZy51bSBiL2FyY2gvdW0vS2NvbmZpZy51bQppbmRleCBmOGQxZDBkLi45MGE0MzhhIDEwMDY0NAotLS0gYS9hcmNoL3VtL0tjb25maWcudW0KKysrIGIvYXJjaC91bS9LY29uZmlnLnVtCkBAIC0xMjAsOSArMTIwLDYgQEAKIAogCSAgSWYgeW91IGRvbid0IGtub3cgd2hhdCB0byBkbywgc2F5IE4uCiAKLWNvbmZpZyBHRU5FUklDX0hBUkRJUlFTX05PX19ET19JUlEKLQlkZWZfYm9vbCB5Ci0KIGNvbmZpZyBOUl9DUFVTCiAJaW50ICJNYXhpbXVtIG51bWJlciBvZiBDUFVzICgyLTMyKSIKIAlyYW5nZSAyIDMyCmRpZmYgLS1naXQgYS9hcmNoL3VtL2RlZmNvbmZpZyBiL2FyY2gvdW0vZGVmY29uZmlnCmluZGV4IDU2NGYzZGUuLjlmNzYzNGYgMTAwNjQ0Ci0tLSBhL2FyY2gvdW0vZGVmY29uZmlnCisrKyBiL2FyY2gvdW0vZGVmY29uZmlnCkBAIC0xMzMsNyArMTMzLDcgQEAKICMgQ09ORklHX0JMS19ERVZfSU5JVFJEIGlzIG5vdCBzZXQKIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRT15CiBDT05GSUdfU1lTQ1RMPXkKLSMgQ09ORklHX0VNQkVEREVEIGlzIG5vdCBzZXQKKyMgQ09ORklHX0VYUEVSVCBpcyBub3Qgc2V0CiBDT05GSUdfVUlEMTY9eQogQ09ORklHX1NZU0NUTF9TWVNDQUxMPXkKIENPTkZJR19LQUxMU1lNUz15CmRpZmYgLS1naXQgYS9hcmNoL3VtL2tlcm5lbC9za2FzL21tdS5jIGIvYXJjaC91bS9rZXJuZWwvc2thcy9tbXUuYwppbmRleCAzZDA5OWY5Li4xYWVlNTg3IDEwMDY0NAotLS0gYS9hcmNoL3VtL2tlcm5lbC9za2FzL21tdS5jCisrKyBiL2FyY2gvdW0va2VybmVsL3NrYXMvbW11LmMKQEAgLTMxLDcgKzMxLDcgQEAKIAlpZiAoIXBtZCkKIAkJZ290byBvdXRfcG1kOwogCi0JcHRlID0gcHRlX2FsbG9jX21hcChtbSwgcG1kLCBwcm9jKTsKKwlwdGUgPSBwdGVfYWxsb2NfbWFwKG1tLCBOVUxMLCBwbWQsIHByb2MpOwogCWlmICghcHRlKQogCQlnb3RvIG91dF9wdGU7CiAKZGlmZiAtLWdpdCBhL2FyY2gveDg2L0tjb25maWcgYi9hcmNoL3g4Ni9LY29uZmlnCmluZGV4IDM2ZWQyZTIuLmQ1ZWQ5NGQgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L0tjb25maWcKKysrIGIvYXJjaC94ODYvS2NvbmZpZwpAQCAtNjI3LDExICs2MjcsMTEgQEAKICAgICAgICAgIGFzIGl0IGlzIG9mZi1jaGlwLiBBUEIgdGltZXJzIGFyZSBhbHdheXMgcnVubmluZyByZWdhcmRsZXNzIG9mIENQVQogICAgICAgICAgQyBzdGF0ZXMsIHRoZXkgYXJlIHVzZWQgYXMgcGVyIENQVSBjbG9ja2V2ZW50IGRldmljZSB3aGVuIHBvc3NpYmxlLgogCi0jIE1hcmsgYXMgZW1iZWRkZWQgYmVjYXVzZSB0b28gbWFueSBwZW9wbGUgZ290IGl0IHdyb25nLgorIyBNYXJrIGFzIGV4cGVydCBiZWNhdXNlIHRvbyBtYW55IHBlb3BsZSBnb3QgaXQgd3JvbmcuCiAjIFRoZSBjb2RlIGRpc2FibGVzIGl0c2VsZiB3aGVuIG5vdCBuZWVkZWQuCiBjb25maWcgRE1JCiAJZGVmYXVsdCB5Ci0JYm9vbCAiRW5hYmxlIERNSSBzY2FubmluZyIgaWYgRU1CRURERUQKKwlib29sICJFbmFibGUgRE1JIHNjYW5uaW5nIiBpZiBFWFBFUlQKIAktLS1oZWxwLS0tCiAJICBFbmFibGVkIHNjYW5uaW5nIG9mIERNSSB0byBpZGVudGlmeSBtYWNoaW5lIHF1aXJrcy4gU2F5IFkKIAkgIGhlcmUgdW5sZXNzIHlvdSBoYXZlIHZlcmlmaWVkIHRoYXQgeW91ciBzZXR1cCBpcyBub3QKQEAgLTYzOSw3ICs2MzksNyBAQAogCSAgQklPUyBjb2RlLgogCiBjb25maWcgR0FSVF9JT01NVQotCWJvb2wgIkdBUlQgSU9NTVUgc3VwcG9ydCIgaWYgRU1CRURERUQKKwlib29sICJHQVJUIElPTU1VIHN1cHBvcnQiIGlmIEVYUEVSVAogCWRlZmF1bHQgeQogCXNlbGVjdCBTV0lPVExCCiAJZGVwZW5kcyBvbiBYODZfNjQgJiYgUENJICYmIEFNRF9OQgpAQCAtODg5LDcgKzg4OSw3IEBACiAJZGVwZW5kcyBvbiBYODZfTUNFX0lOVEVMCiAKIGNvbmZpZyBWTTg2Ci0JYm9vbCAiRW5hYmxlIFZNODYgc3VwcG9ydCIgaWYgRU1CRURERUQKKwlib29sICJFbmFibGUgVk04NiBzdXBwb3J0IiBpZiBFWFBFUlQKIAlkZWZhdWx0IHkKIAlkZXBlbmRzIG9uIFg4Nl8zMgogCS0tLWhlbHAtLS0KQEAgLTEwNzMsNyArMTA3Myw3IEBACiAKIGNob2ljZQogCWRlcGVuZHMgb24gRVhQRVJJTUVOVEFMCi0JcHJvbXB0ICJNZW1vcnkgc3BsaXQiIGlmIEVNQkVEREVECisJcHJvbXB0ICJNZW1vcnkgc3BsaXQiIGlmIEVYUEVSVAogCWRlZmF1bHQgVk1TUExJVF8zRwogCWRlcGVuZHMgb24gWDg2XzMyCiAJLS0taGVscC0tLQpAQCAtMTEzNSw3ICsxMTM1LDcgQEAKIAlkZWZfYm9vbCBYODZfNjQgfHwgSElHSE1FTTY0RwogCiBjb25maWcgRElSRUNUX0dCUEFHRVMKLQlib29sICJFbmFibGUgMUdCIHBhZ2VzIGZvciBrZXJuZWwgcGFnZXRhYmxlcyIgaWYgRU1CRURERUQKKwlib29sICJFbmFibGUgMUdCIHBhZ2VzIGZvciBrZXJuZWwgcGFnZXRhYmxlcyIgaWYgRVhQRVJUCiAJZGVmYXVsdCB5CiAJZGVwZW5kcyBvbiBYODZfNjQKIAktLS1oZWxwLS0tCkBAIC0xMzY5LDcgKzEzNjksNyBAQAogCiBjb25maWcgTVRSUgogCWRlZl9ib29sIHkKLQlwcm9tcHQgIk1UUlIgKE1lbW9yeSBUeXBlIFJhbmdlIFJlZ2lzdGVyKSBzdXBwb3J0IiBpZiBFTUJFRERFRAorCXByb21wdCAiTVRSUiAoTWVtb3J5IFR5cGUgUmFuZ2UgUmVnaXN0ZXIpIHN1cHBvcnQiIGlmIEVYUEVSVAogCS0tLWhlbHAtLS0KIAkgIE9uIEludGVsIFA2IGZhbWlseSBwcm9jZXNzb3JzIChQZW50aXVtIFBybywgUGVudGl1bSBJSSBhbmQgbGF0ZXIpCiAJICB0aGUgTWVtb3J5IFR5cGUgUmFuZ2UgUmVnaXN0ZXJzIChNVFJScykgbWF5IGJlIHVzZWQgdG8gY29udHJvbApAQCAtMTQzNSw3ICsxNDM1LDcgQEAKIAogY29uZmlnIFg4Nl9QQVQKIAlkZWZfYm9vbCB5Ci0JcHJvbXB0ICJ4ODYgUEFUIHN1cHBvcnQiIGlmIEVNQkVEREVECisJcHJvbXB0ICJ4ODYgUEFUIHN1cHBvcnQiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gTVRSUgogCS0tLWhlbHAtLS0KIAkgIFVzZSBQQVQgYXR0cmlidXRlcyB0byBzZXR1cCBwYWdlIGxldmVsIGNhY2hlIGNvbnRyb2wuCkBAIC0xNTM5LDcgKzE1MzksNyBAQAogCSAgY29kZSBpbiBwaHlzaWNhbCBhZGRyZXNzIG1vZGUgdmlhIEtFWEVDCiAKIGNvbmZpZyBQSFlTSUNBTF9TVEFSVAotCWhleCAiUGh5c2ljYWwgYWRkcmVzcyB3aGVyZSB0aGUga2VybmVsIGlzIGxvYWRlZCIgaWYgKEVNQkVEREVEIHx8IENSQVNIX0RVTVApCisJaGV4ICJQaHlzaWNhbCBhZGRyZXNzIHdoZXJlIHRoZSBrZXJuZWwgaXMgbG9hZGVkIiBpZiAoRVhQRVJUIHx8IENSQVNIX0RVTVApCiAJZGVmYXVsdCAiMHgxMDAwMDAwIgogCS0tLWhlbHAtLS0KIAkgIFRoaXMgZ2l2ZXMgdGhlIHBoeXNpY2FsIGFkZHJlc3Mgd2hlcmUgdGhlIGtlcm5lbCBpcyBsb2FkZWQuCkBAIC0xOTM0LDEzICsxOTM0LDE5IEBACiAJZGVwZW5kcyBvbiBYODZfNjQgJiYgUENJICYmIEFDUEkKIAogY29uZmlnIFBDSV9DTkIyMExFX1FVSVJLCi0JYm9vbCAiUmVhZCBDTkIyMExFIEhvc3QgQnJpZGdlIFdpbmRvd3MiCi0JZGVwZW5kcyBvbiBQQ0kKKwlib29sICJSZWFkIENOQjIwTEUgSG9zdCBCcmlkZ2UgV2luZG93cyIgaWYgRVhQRVJUCisJZGVmYXVsdCBuCisJZGVwZW5kcyBvbiBQQ0kgJiYgRVhQRVJJTUVOVEFMCiAJaGVscAogCSAgUmVhZCB0aGUgUENJIHdpbmRvd3Mgb3V0IG9mIHRoZSBDTkIyMExFIGhvc3QgYnJpZGdlLiBUaGlzIGFsbG93cwogCSAgUENJIGhvdHBsdWcgdG8gd29yayBvbiBzeXN0ZW1zIHdpdGggdGhlIENOQjIwTEUgY2hpcHNldCB3aGljaCBkbwogCSAgbm90IGhhdmUgQUNQSS4KIAorCSAgVGhlcmUncyBubyBwdWJsaWMgc3BlYyBmb3IgdGhpcyBjaGlwc2V0LCBhbmQgdGhpcyBmdW5jdGlvbmFsaXR5CisJICBpcyBrbm93biB0byBiZSBpbmNvbXBsZXRlLgorCisJICBZb3Ugc2hvdWxkIHNheSBOIHVubGVzcyB5b3Uga25vdyB5b3UgbmVlZCB0aGlzLgorCiBjb25maWcgRE1BUgogCWJvb2wgIlN1cHBvcnQgZm9yIERNQSBSZW1hcHBpbmcgRGV2aWNlcyAoRVhQRVJJTUVOVEFMKSIKIAlkZXBlbmRzIG9uIFBDSV9NU0kgJiYgQUNQSSAmJiBFWFBFUklNRU5UQUwKQEAgLTIwNjIsMTMgKzIwNjgsMTQgQEAKIAlib29sICJPbmUgTGFwdG9wIFBlciBDaGlsZCBzdXBwb3J0IgogCXNlbGVjdCBHUElPTElCCiAJc2VsZWN0IE9MUENfT1BFTkZJUk1XQVJFCisJZGVwZW5kcyBvbiAhWDg2XzY0ICYmICFYODZfUEFFCiAJLS0taGVscC0tLQogCSAgQWRkIHN1cHBvcnQgZm9yIGRldGVjdGluZyB0aGUgdW5pcXVlIGZlYXR1cmVzIG9mIHRoZSBPTFBDCiAJICBYTyBoYXJkd2FyZS4KIAogY29uZmlnIE9MUENfWE8xCiAJdHJpc3RhdGUgIk9MUEMgWE8tMSBzdXBwb3J0IgotCWRlcGVuZHMgb24gT0xQQyAmJiBQQ0kKKwlkZXBlbmRzIG9uIE9MUEMgJiYgTUZEX0NTNTUzNQogCS0tLWhlbHAtLS0KIAkgIEFkZCBzdXBwb3J0IGZvciBub24tZXNzZW50aWFsIGZlYXR1cmVzIG9mIHRoZSBPTFBDIFhPLTEgbGFwdG9wLgogCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9LY29uZmlnLmNwdSBiL2FyY2gveDg2L0tjb25maWcuY3B1CmluZGV4IDE1NTg4YTAuLjI4M2M1YTYgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L0tjb25maWcuY3B1CisrKyBiL2FyY2gveDg2L0tjb25maWcuY3B1CkBAIC00MjQsNyArNDI0LDcgQEAKIAlkZXBlbmRzIG9uICEoTUs2IHx8IE1XSU5DSElQQzYgfHwgTVdJTkNISVAzRCB8fCBNQ1lSSVhJSUkgfHwgTTU4Nk1NWCB8fCBNNTg2VFNDIHx8IE01ODYgfHwgTTQ4NiB8fCBNMzg2KSAmJiAhVU1MCiAKIG1lbnVjb25maWcgUFJPQ0VTU09SX1NFTEVDVAotCWJvb2wgIlN1cHBvcnRlZCBwcm9jZXNzb3IgdmVuZG9ycyIgaWYgRU1CRURERUQKKwlib29sICJTdXBwb3J0ZWQgcHJvY2Vzc29yIHZlbmRvcnMiIGlmIEVYUEVSVAogCS0tLWhlbHAtLS0KIAkgIFRoaXMgbGV0cyB5b3UgY2hvb3NlIHdoYXQgeDg2IHZlbmRvciBzdXBwb3J0IGNvZGUgeW91ciBrZXJuZWwKIAkgIHdpbGwgaW5jbHVkZS4KZGlmZiAtLWdpdCBhL2FyY2gveDg2L0tjb25maWcuZGVidWcgYi9hcmNoL3g4Ni9LY29uZmlnLmRlYnVnCmluZGV4IDQ1MTQzYmIuLjYxNWUxODggMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L0tjb25maWcuZGVidWcKKysrIGIvYXJjaC94ODYvS2NvbmZpZy5kZWJ1ZwpAQCAtMzEsNyArMzEsNyBAQAogCSAgc2VlIGVycm9ycy4gRGlzYWJsZSB0aGlzIGlmIHlvdSB3YW50IHNpbGVudCBib290dXAuCiAKIGNvbmZpZyBFQVJMWV9QUklOVEsKLQlib29sICJFYXJseSBwcmludGsiIGlmIEVNQkVEREVECisJYm9vbCAiRWFybHkgcHJpbnRrIiBpZiBFWFBFUlQKIAlkZWZhdWx0IHkKIAktLS1oZWxwLS0tCiAJICBXcml0ZSBrZXJuZWwgbG9nIG91dHB1dCBkaXJlY3RseSBpbnRvIHRoZSBWR0EgYnVmZmVyIG9yIHRvIGEgc2VyaWFsCkBAIC0xMzgsNyArMTM4LDcgQEAKIAogY29uZmlnIERPVUJMRUZBVUxUCiAJZGVmYXVsdCB5Ci0JYm9vbCAiRW5hYmxlIGRvdWJsZWZhdWx0IGV4Y2VwdGlvbiBoYW5kbGVyIiBpZiBFTUJFRERFRAorCWJvb2wgIkVuYWJsZSBkb3VibGVmYXVsdCBleGNlcHRpb24gaGFuZGxlciIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBYODZfMzIKIAktLS1oZWxwLS0tCiAJICBUaGlzIG9wdGlvbiBhbGxvd3MgdHJhcHBpbmcgb2YgcmFyZSBkb3VibGVmYXVsdCBleGNlcHRpb25zIHRoYXQKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaAppbmRleCA2M2UzNWVjLi42MmYwODQ0IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oCkBAIC0xLDQ4ICsxLDggQEAKICNpZm5kZWYgX0FTTV9YODZfQ0FDSEVGTFVTSF9ICiAjZGVmaW5lIF9BU01fWDg2X0NBQ0hFRkxVU0hfSAogCi0vKiBLZWVwIGluY2x1ZGVzIHRoZSBzYW1lIGFjcm9zcyBhcmNoZXMuICAqLwotI2luY2x1ZGUgPGxpbnV4L21tLmg+Ci0KIC8qIENhY2hlcyBhcmVuJ3QgYnJhaW4tZGVhZCBvbiB0aGUgaW50ZWwuICovCi1zdGF0aWMgaW5saW5lIHZvaWQgZmx1c2hfY2FjaGVfYWxsKHZvaWQpIHsgfQotc3RhdGljIGlubGluZSB2b2lkIGZsdXNoX2NhY2hlX21tKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKSB7IH0KLXN0YXRpYyBpbmxpbmUgdm9pZCBmbHVzaF9jYWNoZV9kdXBfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0pIHsgfQotc3RhdGljIGlubGluZSB2b2lkIGZsdXNoX2NhY2hlX3JhbmdlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAotCQkJCSAgICAgdW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWduZWQgbG9uZyBlbmQpIHsgfQotc3RhdGljIGlubGluZSB2b2lkIGZsdXNoX2NhY2hlX3BhZ2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCi0JCQkJICAgIHVuc2lnbmVkIGxvbmcgdm1hZGRyLCB1bnNpZ25lZCBsb25nIHBmbikgeyB9Ci0jZGVmaW5lIEFSQ0hfSU1QTEVNRU5UU19GTFVTSF9EQ0FDSEVfUEFHRSAwCi1zdGF0aWMgaW5saW5lIHZvaWQgZmx1c2hfZGNhY2hlX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpIHsgfQotc3RhdGljIGlubGluZSB2b2lkIGZsdXNoX2RjYWNoZV9tbWFwX2xvY2soc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmcpIHsgfQotc3RhdGljIGlubGluZSB2b2lkIGZsdXNoX2RjYWNoZV9tbWFwX3VubG9jayhzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqbWFwcGluZykgeyB9Ci1zdGF0aWMgaW5saW5lIHZvaWQgZmx1c2hfaWNhY2hlX3JhbmdlKHVuc2lnbmVkIGxvbmcgc3RhcnQsCi0JCQkJICAgICAgdW5zaWduZWQgbG9uZyBlbmQpIHsgfQotc3RhdGljIGlubGluZSB2b2lkIGZsdXNoX2ljYWNoZV9wYWdlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAotCQkJCSAgICAgc3RydWN0IHBhZ2UgKnBhZ2UpIHsgfQotc3RhdGljIGlubGluZSB2b2lkIGZsdXNoX2ljYWNoZV91c2VyX3JhbmdlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAotCQkJCQkgICBzdHJ1Y3QgcGFnZSAqcGFnZSwKLQkJCQkJICAgdW5zaWduZWQgbG9uZyBhZGRyLAotCQkJCQkgICB1bnNpZ25lZCBsb25nIGxlbikgeyB9Ci1zdGF0aWMgaW5saW5lIHZvaWQgZmx1c2hfY2FjaGVfdm1hcCh1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIGVuZCkgeyB9Ci1zdGF0aWMgaW5saW5lIHZvaWQgZmx1c2hfY2FjaGVfdnVubWFwKHVuc2lnbmVkIGxvbmcgc3RhcnQsCi0JCQkJICAgICAgdW5zaWduZWQgbG9uZyBlbmQpIHsgfQotCi1zdGF0aWMgaW5saW5lIHZvaWQgY29weV90b191c2VyX3BhZ2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCi0JCQkJICAgICBzdHJ1Y3QgcGFnZSAqcGFnZSwgdW5zaWduZWQgbG9uZyB2YWRkciwKLQkJCQkgICAgIHZvaWQgKmRzdCwgY29uc3Qgdm9pZCAqc3JjLAotCQkJCSAgICAgdW5zaWduZWQgbG9uZyBsZW4pCi17Ci0JbWVtY3B5KGRzdCwgc3JjLCBsZW4pOwotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQgY29weV9mcm9tX3VzZXJfcGFnZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKLQkJCQkgICAgICAgc3RydWN0IHBhZ2UgKnBhZ2UsIHVuc2lnbmVkIGxvbmcgdmFkZHIsCi0JCQkJICAgICAgIHZvaWQgKmRzdCwgY29uc3Qgdm9pZCAqc3JjLAotCQkJCSAgICAgICB1bnNpZ25lZCBsb25nIGxlbikKLXsKLQltZW1jcHkoZHN0LCBzcmMsIGxlbik7Ci19CisjaW5jbHVkZSA8YXNtLWdlbmVyaWMvY2FjaGVmbHVzaC5oPgogCiAjaWZkZWYgQ09ORklHX1g4Nl9QQVQKIC8qCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9jcHUuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2NwdS5oCmluZGV4IDRmYWIyNGQuLjZlNmU3NTUgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL2NwdS5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2NwdS5oCkBAIC0zMiw1ICszMiw2IEBACiAKIERFQ0xBUkVfUEVSX0NQVShpbnQsIGNwdV9zdGF0ZSk7CiAKK2ludCBfX2NwdWluaXQgbXdhaXRfdXNhYmxlKGNvbnN0IHN0cnVjdCBjcHVpbmZvX3g4NiAqKTsKIAogI2VuZGlmIC8qIF9BU01fWDg2X0NQVV9IICovCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9qdW1wX2xhYmVsLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9qdW1wX2xhYmVsLmgKaW5kZXggZjUyZDQyZS4uNTc0ZGJjMiAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vanVtcF9sYWJlbC5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2p1bXBfbGFiZWwuaApAQCAtMTQsNyArMTQsNyBAQAogCWRvIHsJCQkJCQkJXAogCQlhc20gZ290bygiMToiCQkJCQlcCiAJCQlKVU1QX0xBQkVMX0lOSVRJQUxfTk9QCQkJXAotCQkJIi5wdXNoc2VjdGlvbiBfX2p1bXBfdGFibGUsICBcImFcIiBcblx0IlwKKwkJCSIucHVzaHNlY3Rpb24gX19qdW1wX3RhYmxlLCAgXCJhd1wiIFxuXHQiXAogCQkJX0FTTV9QVFIgIjFiLCAlbFsiICNsYWJlbCAiXSwgJWMwIFxuXHQiIFwKIAkJCSIucG9wc2VjdGlvbiBcblx0IgkJCVwKIAkJCTogOiAgImkiIChrZXkpIDogIDogbGFiZWwpOwkJXApkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9hc20va3ZtX2hvc3QuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKaW5kZXggYWE3NWYyMS4uZmZkN2Y4ZCAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20va3ZtX2hvc3QuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9rdm1faG9zdC5oCkBAIC04MjIsNiArODIyLDcgQEAKICNkZWZpbmUgS1ZNX0FSQ0hfV0FOVF9NTVVfTk9USUZJRVIKIGludCBrdm1fdW5tYXBfaHZhKHN0cnVjdCBrdm0gKmt2bSwgdW5zaWduZWQgbG9uZyBodmEpOwogaW50IGt2bV9hZ2VfaHZhKHN0cnVjdCBrdm0gKmt2bSwgdW5zaWduZWQgbG9uZyBodmEpOworaW50IGt2bV90ZXN0X2FnZV9odmEoc3RydWN0IGt2bSAqa3ZtLCB1bnNpZ25lZCBsb25nIGh2YSk7CiB2b2lkIGt2bV9zZXRfc3B0ZV9odmEoc3RydWN0IGt2bSAqa3ZtLCB1bnNpZ25lZCBsb25nIGh2YSwgcHRlX3QgcHRlKTsKIGludCBjcHVpZF9tYXhwaHlhZGRyKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSk7CiBpbnQga3ZtX2NwdV9oYXNfaW50ZXJydXB0KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSk7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9tbXVfY29udGV4dC5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vbW11X2NvbnRleHQuaAppbmRleCA0YTJkNGUwLi44YjUzOTNlIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9tbXVfY29udGV4dC5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL21tdV9jb250ZXh0LmgKQEAgLTM2LDggKzM2LDYgQEAKIAl1bnNpZ25lZCBjcHUgPSBzbXBfcHJvY2Vzc29yX2lkKCk7CiAKIAlpZiAobGlrZWx5KHByZXYgIT0gbmV4dCkpIHsKLQkJLyogc3RvcCBmbHVzaCBpcGlzIGZvciB0aGUgcHJldmlvdXMgbW0gKi8KLQkJY3B1bWFza19jbGVhcl9jcHUoY3B1LCBtbV9jcHVtYXNrKHByZXYpKTsKICNpZmRlZiBDT05GSUdfU01QCiAJCXBlcmNwdV93cml0ZShjcHVfdGxic3RhdGUuc3RhdGUsIFRMQlNUQVRFX09LKTsKIAkJcGVyY3B1X3dyaXRlKGNwdV90bGJzdGF0ZS5hY3RpdmVfbW0sIG5leHQpOwpAQCAtNDcsNiArNDUsOSBAQAogCQkvKiBSZS1sb2FkIHBhZ2UgdGFibGVzICovCiAJCWxvYWRfY3IzKG5leHQtPnBnZCk7CiAKKwkJLyogc3RvcCBmbHVzaCBpcGlzIGZvciB0aGUgcHJldmlvdXMgbW0gKi8KKwkJY3B1bWFza19jbGVhcl9jcHUoY3B1LCBtbV9jcHVtYXNrKHByZXYpKTsKKwogCQkvKgogCQkgKiBsb2FkIHRoZSBMRFQsIGlmIHRoZSBMRFQgaXMgZGlmZmVyZW50OgogCQkgKi8KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL251bWFfMzIuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL251bWFfMzIuaAppbmRleCBhMzcyMjkwLi5iMGVmMmI0IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9udW1hXzMyLmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vbnVtYV8zMi5oCkBAIC0xLDYgKzEsOCBAQAogI2lmbmRlZiBfQVNNX1g4Nl9OVU1BXzMyX0gKICNkZWZpbmUgX0FTTV9YODZfTlVNQV8zMl9ICiAKK2V4dGVybiBpbnQgbnVtYV9vZmY7CisKIGV4dGVybiBpbnQgcHhtX3RvX25pZChpbnQgcHhtKTsKIGV4dGVybiB2b2lkIG51bWFfcmVtb3ZlX2NwdShpbnQgY3B1KTsKIApkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9hc20vbnVtYV82NC5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vbnVtYV82NC5oCmluZGV4IDVhZTg3MjguLjA0OTNiZTMgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL251bWFfNjQuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9udW1hXzY0LmgKQEAgLTQwLDYgKzQwLDcgQEAKICNpZmRlZiBDT05GSUdfTlVNQV9FTVUKICNkZWZpbmUgRkFLRV9OT0RFX01JTl9TSVpFCSgodTY0KTMyIDw8IDIwKQogI2RlZmluZSBGQUtFX05PREVfTUlOX0hBU0hfTUFTSwkofihGQUtFX05PREVfTUlOX1NJWkUgLSAxVUwpKQordm9pZCBudW1hX2VtdV9jbWRsaW5lKGNoYXIgKik7CiAjZW5kaWYgLyogQ09ORklHX05VTUFfRU1VICovCiAjZWxzZQogc3RhdGljIGlubGluZSB2b2lkIGluaXRfY3B1X3RvX25vZGUodm9pZCkJCXsgfQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9hc20vcGFyYXZpcnQuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BhcmF2aXJ0LmgKaW5kZXggNzcwOWMxMi4uZWJiYzRkOCAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vcGFyYXZpcnQuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJhdmlydC5oCkBAIC00MzUsNiArNDM1LDExIEBACiB7CiAJUFZPUF9WQ0FMTDMocHZfbW11X29wcy5wdGVfdXBkYXRlLCBtbSwgYWRkciwgcHRlcCk7CiB9CitzdGF0aWMgaW5saW5lIHZvaWQgcG1kX3VwZGF0ZShzdHJ1Y3QgbW1fc3RydWN0ICptbSwgdW5zaWduZWQgbG9uZyBhZGRyLAorCQkJICAgICAgcG1kX3QgKnBtZHApCit7CisJUFZPUF9WQ0FMTDMocHZfbW11X29wcy5wbWRfdXBkYXRlLCBtbSwgYWRkciwgcG1kcCk7Cit9CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBwdGVfdXBkYXRlX2RlZmVyKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCB1bnNpZ25lZCBsb25nIGFkZHIsCiAJCQkJICAgIHB0ZV90ICpwdGVwKQpAQCAtNDQyLDYgKzQ0NywxMiBAQAogCVBWT1BfVkNBTEwzKHB2X21tdV9vcHMucHRlX3VwZGF0ZV9kZWZlciwgbW0sIGFkZHIsIHB0ZXApOwogfQogCitzdGF0aWMgaW5saW5lIHZvaWQgcG1kX3VwZGF0ZV9kZWZlcihzdHJ1Y3QgbW1fc3RydWN0ICptbSwgdW5zaWduZWQgbG9uZyBhZGRyLAorCQkJCSAgICBwbWRfdCAqcG1kcCkKK3sKKwlQVk9QX1ZDQUxMMyhwdl9tbXVfb3BzLnBtZF91cGRhdGVfZGVmZXIsIG1tLCBhZGRyLCBwbWRwKTsKK30KKwogc3RhdGljIGlubGluZSBwdGVfdCBfX3B0ZShwdGV2YWxfdCB2YWwpCiB7CiAJcHRldmFsX3QgcmV0OwpAQCAtNTQzLDYgKzU1NCwxOSBAQAogCQlQVk9QX1ZDQUxMNChwdl9tbXVfb3BzLnNldF9wdGVfYXQsIG1tLCBhZGRyLCBwdGVwLCBwdGUucHRlKTsKIH0KIAorI2lmZGVmIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRQorc3RhdGljIGlubGluZSB2b2lkIHNldF9wbWRfYXQoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHVuc2lnbmVkIGxvbmcgYWRkciwKKwkJCSAgICAgIHBtZF90ICpwbWRwLCBwbWRfdCBwbWQpCit7CisJaWYgKHNpemVvZihwbWR2YWxfdCkgPiBzaXplb2YobG9uZykpCisJCS8qIDUgYXJnIHdvcmRzICovCisJCXB2X21tdV9vcHMuc2V0X3BtZF9hdChtbSwgYWRkciwgcG1kcCwgcG1kKTsKKwllbHNlCisJCVBWT1BfVkNBTEw0KHB2X21tdV9vcHMuc2V0X3BtZF9hdCwgbW0sIGFkZHIsIHBtZHAsCisJCQkgICAgbmF0aXZlX3BtZF92YWwocG1kKSk7Cit9CisjZW5kaWYKKwogc3RhdGljIGlubGluZSB2b2lkIHNldF9wbWQocG1kX3QgKnBtZHAsIHBtZF90IHBtZCkKIHsKIAlwbWR2YWxfdCB2YWwgPSBuYXRpdmVfcG1kX3ZhbChwbWQpOwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9hc20vcGFyYXZpcnRfdHlwZXMuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BhcmF2aXJ0X3R5cGVzLmgKaW5kZXggYjgyYmFjOS4uODI4ODUwOSAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vcGFyYXZpcnRfdHlwZXMuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJhdmlydF90eXBlcy5oCkBAIC0yNjUsMTAgKzI2NSwxNiBAQAogCXZvaWQgKCpzZXRfcHRlX2F0KShzdHJ1Y3QgbW1fc3RydWN0ICptbSwgdW5zaWduZWQgbG9uZyBhZGRyLAogCQkJICAgcHRlX3QgKnB0ZXAsIHB0ZV90IHB0ZXZhbCk7CiAJdm9pZCAoKnNldF9wbWQpKHBtZF90ICpwbWRwLCBwbWRfdCBwbWR2YWwpOworCXZvaWQgKCpzZXRfcG1kX2F0KShzdHJ1Y3QgbW1fc3RydWN0ICptbSwgdW5zaWduZWQgbG9uZyBhZGRyLAorCQkJICAgcG1kX3QgKnBtZHAsIHBtZF90IHBtZHZhbCk7CiAJdm9pZCAoKnB0ZV91cGRhdGUpKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCB1bnNpZ25lZCBsb25nIGFkZHIsCiAJCQkgICBwdGVfdCAqcHRlcCk7CiAJdm9pZCAoKnB0ZV91cGRhdGVfZGVmZXIpKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAogCQkJCSB1bnNpZ25lZCBsb25nIGFkZHIsIHB0ZV90ICpwdGVwKTsKKwl2b2lkICgqcG1kX3VwZGF0ZSkoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHVuc2lnbmVkIGxvbmcgYWRkciwKKwkJCSAgIHBtZF90ICpwbWRwKTsKKwl2b2lkICgqcG1kX3VwZGF0ZV9kZWZlcikoc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkJIHVuc2lnbmVkIGxvbmcgYWRkciwgcG1kX3QgKnBtZHApOwogCiAJcHRlX3QgKCpwdGVwX21vZGlmeV9wcm90X3N0YXJ0KShzdHJ1Y3QgbW1fc3RydWN0ICptbSwgdW5zaWduZWQgbG9uZyBhZGRyLAogCQkJCQlwdGVfdCAqcHRlcCk7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wZXJjcHUuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BlcmNwdS5oCmluZGV4IDhlZTQ1MTYuLjdlMTcyOTUgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BlcmNwdS5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BlcmNwdS5oCkBAIC0yNzMsMzQgKzI3MywzNCBAQAogCXR5cGVvZih2YXIpIHB4b19uZXdfXyA9IChudmFsKTsJCQkJCVwKIAlzd2l0Y2ggKHNpemVvZih2YXIpKSB7CQkJCQkJXAogCWNhc2UgMToJCQkJCQkJCVwKLQkJYXNtKCJcbjE6bW92ICJfX3BlcmNwdV9hcmcoMSkiLCUlYWwiCQkJXAotCQkgICAgIlxuXHRjbXB4Y2hnYiAlMiwgIl9fcGVyY3B1X2FyZygxKQkJCVwKKwkJYXNtKCJcblx0bW92ICJfX3BlcmNwdV9hcmcoMSkiLCUlYWwiCQkJXAorCQkgICAgIlxuMTpcdGNtcHhjaGdiICUyLCAiX19wZXJjcHVfYXJnKDEpCQlcCiAJCSAgICAiXG5cdGpueiAxYiIJCQkJCVwKLQkJCSAgICA6ICI9YSIgKHB4b19yZXRfXyksICIrbSIgKHZhcikJCVwKKwkJCSAgICA6ICI9JmEiIChweG9fcmV0X18pLCAiK20iICh2YXIpCQlcCiAJCQkgICAgOiAicSIgKHB4b19uZXdfXykJCQkJXAogCQkJICAgIDogIm1lbW9yeSIpOwkJCQlcCiAJCWJyZWFrOwkJCQkJCQlcCiAJY2FzZSAyOgkJCQkJCQkJXAotCQlhc20oIlxuMTptb3YgIl9fcGVyY3B1X2FyZygxKSIsJSVheCIJCQlcCi0JCSAgICAiXG5cdGNtcHhjaGd3ICUyLCAiX19wZXJjcHVfYXJnKDEpCQkJXAorCQlhc20oIlxuXHRtb3YgIl9fcGVyY3B1X2FyZygxKSIsJSVheCIJCQlcCisJCSAgICAiXG4xOlx0Y21weGNoZ3cgJTIsICJfX3BlcmNwdV9hcmcoMSkJCVwKIAkJICAgICJcblx0am56IDFiIgkJCQkJXAotCQkJICAgIDogIj1hIiAocHhvX3JldF9fKSwgIittIiAodmFyKQkJXAorCQkJICAgIDogIj0mYSIgKHB4b19yZXRfXyksICIrbSIgKHZhcikJCVwKIAkJCSAgICA6ICJyIiAocHhvX25ld19fKQkJCQlcCiAJCQkgICAgOiAibWVtb3J5Iik7CQkJCVwKIAkJYnJlYWs7CQkJCQkJCVwKIAljYXNlIDQ6CQkJCQkJCQlcCi0JCWFzbSgiXG4xOm1vdiAiX19wZXJjcHVfYXJnKDEpIiwlJWVheCIJCQlcCi0JCSAgICAiXG5cdGNtcHhjaGdsICUyLCAiX19wZXJjcHVfYXJnKDEpCQkJXAorCQlhc20oIlxuXHRtb3YgIl9fcGVyY3B1X2FyZygxKSIsJSVlYXgiCQkJXAorCQkgICAgIlxuMTpcdGNtcHhjaGdsICUyLCAiX19wZXJjcHVfYXJnKDEpCQlcCiAJCSAgICAiXG5cdGpueiAxYiIJCQkJCVwKLQkJCSAgICA6ICI9YSIgKHB4b19yZXRfXyksICIrbSIgKHZhcikJCVwKKwkJCSAgICA6ICI9JmEiIChweG9fcmV0X18pLCAiK20iICh2YXIpCQlcCiAJCQkgICAgOiAiciIgKHB4b19uZXdfXykJCQkJXAogCQkJICAgIDogIm1lbW9yeSIpOwkJCQlcCiAJCWJyZWFrOwkJCQkJCQlcCiAJY2FzZSA4OgkJCQkJCQkJXAotCQlhc20oIlxuMTptb3YgIl9fcGVyY3B1X2FyZygxKSIsJSVyYXgiCQkJXAotCQkgICAgIlxuXHRjbXB4Y2hncSAlMiwgIl9fcGVyY3B1X2FyZygxKQkJCVwKKwkJYXNtKCJcblx0bW92ICJfX3BlcmNwdV9hcmcoMSkiLCUlcmF4IgkJCVwKKwkJICAgICJcbjE6XHRjbXB4Y2hncSAlMiwgIl9fcGVyY3B1X2FyZygxKQkJXAogCQkgICAgIlxuXHRqbnogMWIiCQkJCQlcCi0JCQkgICAgOiAiPWEiIChweG9fcmV0X18pLCAiK20iICh2YXIpCQlcCisJCQkgICAgOiAiPSZhIiAocHhvX3JldF9fKSwgIittIiAodmFyKQkJXAogCQkJICAgIDogInIiIChweG9fbmV3X18pCQkJCVwKIAkJCSAgICA6ICJtZW1vcnkiKTsJCQkJXAogCQlicmVhazsJCQkJCQkJXApAQCAtNDE0LDggKzQxNCw2IEBACiAjZGVmaW5lIHRoaXNfY3B1X3hjaGdfMShwY3AsIG52YWwpCXBlcmNwdV94Y2hnX29wKHBjcCwgbnZhbCkKICNkZWZpbmUgdGhpc19jcHVfeGNoZ18yKHBjcCwgbnZhbCkJcGVyY3B1X3hjaGdfb3AocGNwLCBudmFsKQogI2RlZmluZSB0aGlzX2NwdV94Y2hnXzQocGNwLCBudmFsKQlwZXJjcHVfeGNoZ19vcChwY3AsIG52YWwpCi0jZGVmaW5lIHRoaXNfY3B1X3hjaGdfOChwY3AsIG52YWwpCXBlcmNwdV94Y2hnX29wKHBjcCwgbnZhbCkKLSNkZWZpbmUgdGhpc19jcHVfY21weGNoZ184KHBjcCwgb3ZhbCwgbnZhbCkJcGVyY3B1X2NtcHhjaGdfb3AocGNwLCBvdmFsLCBudmFsKQogCiAjZGVmaW5lIGlycXNhZmVfY3B1X2FkZF8xKHBjcCwgdmFsKQlwZXJjcHVfYWRkX29wKChwY3ApLCB2YWwpCiAjZGVmaW5lIGlycXNhZmVfY3B1X2FkZF8yKHBjcCwgdmFsKQlwZXJjcHVfYWRkX29wKChwY3ApLCB2YWwpCkBAIC00MzIsOCArNDMwLDYgQEAKICNkZWZpbmUgaXJxc2FmZV9jcHVfeGNoZ18xKHBjcCwgbnZhbCkJcGVyY3B1X3hjaGdfb3AocGNwLCBudmFsKQogI2RlZmluZSBpcnFzYWZlX2NwdV94Y2hnXzIocGNwLCBudmFsKQlwZXJjcHVfeGNoZ19vcChwY3AsIG52YWwpCiAjZGVmaW5lIGlycXNhZmVfY3B1X3hjaGdfNChwY3AsIG52YWwpCXBlcmNwdV94Y2hnX29wKHBjcCwgbnZhbCkKLSNkZWZpbmUgaXJxc2FmZV9jcHVfeGNoZ184KHBjcCwgbnZhbCkJcGVyY3B1X3hjaGdfb3AocGNwLCBudmFsKQotI2RlZmluZSBpcnFzYWZlX2NwdV9jbXB4Y2hnXzgocGNwLCBvdmFsLCBudmFsKQlwZXJjcHVfY21weGNoZ19vcChwY3AsIG92YWwsIG52YWwpCiAKICNpZm5kZWYgQ09ORklHX00zODYKICNkZWZpbmUgX190aGlzX2NwdV9hZGRfcmV0dXJuXzEocGNwLCB2YWwpIHBlcmNwdV9hZGRfcmV0dXJuX29wKHBjcCwgdmFsKQpAQCAtNDc1LDExICs0NzEsMTUgQEAKICNkZWZpbmUgdGhpc19jcHVfb3JfOChwY3AsIHZhbCkJCXBlcmNwdV90b19vcCgib3IiLCAocGNwKSwgdmFsKQogI2RlZmluZSB0aGlzX2NwdV94b3JfOChwY3AsIHZhbCkJcGVyY3B1X3RvX29wKCJ4b3IiLCAocGNwKSwgdmFsKQogI2RlZmluZSB0aGlzX2NwdV9hZGRfcmV0dXJuXzgocGNwLCB2YWwpCXBlcmNwdV9hZGRfcmV0dXJuX29wKHBjcCwgdmFsKQorI2RlZmluZSB0aGlzX2NwdV94Y2hnXzgocGNwLCBudmFsKQlwZXJjcHVfeGNoZ19vcChwY3AsIG52YWwpCisjZGVmaW5lIHRoaXNfY3B1X2NtcHhjaGdfOChwY3AsIG92YWwsIG52YWwpCXBlcmNwdV9jbXB4Y2hnX29wKHBjcCwgb3ZhbCwgbnZhbCkKIAogI2RlZmluZSBpcnFzYWZlX2NwdV9hZGRfOChwY3AsIHZhbCkJcGVyY3B1X2FkZF9vcCgocGNwKSwgdmFsKQogI2RlZmluZSBpcnFzYWZlX2NwdV9hbmRfOChwY3AsIHZhbCkJcGVyY3B1X3RvX29wKCJhbmQiLCAocGNwKSwgdmFsKQogI2RlZmluZSBpcnFzYWZlX2NwdV9vcl84KHBjcCwgdmFsKQlwZXJjcHVfdG9fb3AoIm9yIiwgKHBjcCksIHZhbCkKICNkZWZpbmUgaXJxc2FmZV9jcHVfeG9yXzgocGNwLCB2YWwpCXBlcmNwdV90b19vcCgieG9yIiwgKHBjcCksIHZhbCkKKyNkZWZpbmUgaXJxc2FmZV9jcHVfeGNoZ184KHBjcCwgbnZhbCkJcGVyY3B1X3hjaGdfb3AocGNwLCBudmFsKQorI2RlZmluZSBpcnFzYWZlX2NwdV9jbXB4Y2hnXzgocGNwLCBvdmFsLCBudmFsKQlwZXJjcHVfY21weGNoZ19vcChwY3AsIG92YWwsIG52YWwpCiAjZW5kaWYKIAogLyogVGhpcyBpcyBub3QgYXRvbWljIGFnYWluc3Qgb3RoZXIgQ1BVcyAtLSBDUFUgcHJlZW1wdGlvbiBuZWVkcyB0byBiZSBvZmYgKi8KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BndGFibGUtMmxldmVsLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wZ3RhYmxlLTJsZXZlbC5oCmluZGV4IDIzMzQ5ODIuLjk4MzkxZGIgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BndGFibGUtMmxldmVsLmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vcGd0YWJsZS0ybGV2ZWwuaApAQCAtNDYsNiArNDYsMTUgQEAKICNkZWZpbmUgbmF0aXZlX3B0ZXBfZ2V0X2FuZF9jbGVhcih4cCkgbmF0aXZlX2xvY2FsX3B0ZXBfZ2V0X2FuZF9jbGVhcih4cCkKICNlbmRpZgogCisjaWZkZWYgQ09ORklHX1NNUAorc3RhdGljIGlubGluZSBwbWRfdCBuYXRpdmVfcG1kcF9nZXRfYW5kX2NsZWFyKHBtZF90ICp4cCkKK3sKKwlyZXR1cm4gX19wbWQoeGNoZygocG1kdmFsX3QgKil4cCwgMCkpOworfQorI2Vsc2UKKyNkZWZpbmUgbmF0aXZlX3BtZHBfZ2V0X2FuZF9jbGVhcih4cCkgbmF0aXZlX2xvY2FsX3BtZHBfZ2V0X2FuZF9jbGVhcih4cCkKKyNlbmRpZgorCiAvKgogICogQml0cyBfUEFHRV9CSVRfUFJFU0VOVCwgX1BBR0VfQklUX0ZJTEUgYW5kIF9QQUdFX0JJVF9QUk9UTk9ORSBhcmUgdGFrZW4sCiAgKiBzcGxpdCB1cCB0aGUgMjkgYml0cyBvZiBvZmZzZXQgaW50byB0aGlzIHJhbmdlOgpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9hc20vcGd0YWJsZS0zbGV2ZWwuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BndGFibGUtM2xldmVsLmgKaW5kZXggMTc3YjAxNi4uOTRiOTc5ZCAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vcGd0YWJsZS0zbGV2ZWwuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wZ3RhYmxlLTNsZXZlbC5oCkBAIC0xMDQsNiArMTA0LDI5IEBACiAjZGVmaW5lIG5hdGl2ZV9wdGVwX2dldF9hbmRfY2xlYXIoeHApIG5hdGl2ZV9sb2NhbF9wdGVwX2dldF9hbmRfY2xlYXIoeHApCiAjZW5kaWYKIAorI2lmZGVmIENPTkZJR19TTVAKK3VuaW9uIHNwbGl0X3BtZCB7CisJc3RydWN0IHsKKwkJdTMyIHBtZF9sb3c7CisJCXUzMiBwbWRfaGlnaDsKKwl9OworCXBtZF90IHBtZDsKK307CitzdGF0aWMgaW5saW5lIHBtZF90IG5hdGl2ZV9wbWRwX2dldF9hbmRfY2xlYXIocG1kX3QgKnBtZHApCit7CisJdW5pb24gc3BsaXRfcG1kIHJlcywgKm9yaWcgPSAodW5pb24gc3BsaXRfcG1kICopcG1kcDsKKworCS8qIHhjaGcgYWN0cyBhcyBhIGJhcnJpZXIgYmVmb3JlIHNldHRpbmcgb2YgdGhlIGhpZ2ggYml0cyAqLworCXJlcy5wbWRfbG93ID0geGNoZygmb3JpZy0+cG1kX2xvdywgMCk7CisJcmVzLnBtZF9oaWdoID0gb3JpZy0+cG1kX2hpZ2g7CisJb3JpZy0+cG1kX2hpZ2ggPSAwOworCisJcmV0dXJuIHJlcy5wbWQ7Cit9CisjZWxzZQorI2RlZmluZSBuYXRpdmVfcG1kcF9nZXRfYW5kX2NsZWFyKHhwKSBuYXRpdmVfbG9jYWxfcG1kcF9nZXRfYW5kX2NsZWFyKHhwKQorI2VuZGlmCisKIC8qCiAgKiBCaXRzIDAsIDYgYW5kIDcgYXJlIHRha2VuIGluIHRoZSBsb3cgcGFydCBvZiB0aGUgcHRlLAogICogcHV0IHRoZSAzMiBiaXRzIG9mIG9mZnNldCBpbnRvIHRoZSBoaWdoIHBhcnQuCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wZ3RhYmxlLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wZ3RhYmxlLmgKaW5kZXggYWRhODIzYS4uMTg2MDFjOCAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vcGd0YWJsZS5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BndGFibGUuaApAQCAtMzUsNiArMzUsNyBAQAogI2Vsc2UgIC8qICFDT05GSUdfUEFSQVZJUlQgKi8KICNkZWZpbmUgc2V0X3B0ZShwdGVwLCBwdGUpCQluYXRpdmVfc2V0X3B0ZShwdGVwLCBwdGUpCiAjZGVmaW5lIHNldF9wdGVfYXQobW0sIGFkZHIsIHB0ZXAsIHB0ZSkJbmF0aXZlX3NldF9wdGVfYXQobW0sIGFkZHIsIHB0ZXAsIHB0ZSkKKyNkZWZpbmUgc2V0X3BtZF9hdChtbSwgYWRkciwgcG1kcCwgcG1kKQluYXRpdmVfc2V0X3BtZF9hdChtbSwgYWRkciwgcG1kcCwgcG1kKQogCiAjZGVmaW5lIHNldF9wdGVfYXRvbWljKHB0ZXAsIHB0ZSkJCQkJCVwKIAluYXRpdmVfc2V0X3B0ZV9hdG9taWMocHRlcCwgcHRlKQpAQCAtNTksNiArNjAsOCBAQAogCiAjZGVmaW5lIHB0ZV91cGRhdGUobW0sIGFkZHIsIHB0ZXApICAgICAgICAgICAgICBkbyB7IH0gd2hpbGUgKDApCiAjZGVmaW5lIHB0ZV91cGRhdGVfZGVmZXIobW0sIGFkZHIsIHB0ZXApICAgICAgICBkbyB7IH0gd2hpbGUgKDApCisjZGVmaW5lIHBtZF91cGRhdGUobW0sIGFkZHIsIHB0ZXApICAgICAgICAgICAgICBkbyB7IH0gd2hpbGUgKDApCisjZGVmaW5lIHBtZF91cGRhdGVfZGVmZXIobW0sIGFkZHIsIHB0ZXApICAgICAgICBkbyB7IH0gd2hpbGUgKDApCiAKICNkZWZpbmUgcGdkX3ZhbCh4KQluYXRpdmVfcGdkX3ZhbCh4KQogI2RlZmluZSBfX3BnZCh4KQluYXRpdmVfbWFrZV9wZ2QoeCkKQEAgLTk0LDYgKzk3LDExIEBACiAJcmV0dXJuIHB0ZV9mbGFncyhwdGUpICYgX1BBR0VfQUNDRVNTRUQ7CiB9CiAKK3N0YXRpYyBpbmxpbmUgaW50IHBtZF95b3VuZyhwbWRfdCBwbWQpCit7CisJcmV0dXJuIHBtZF9mbGFncyhwbWQpICYgX1BBR0VfQUNDRVNTRUQ7Cit9CisKIHN0YXRpYyBpbmxpbmUgaW50IHB0ZV93cml0ZShwdGVfdCBwdGUpCiB7CiAJcmV0dXJuIHB0ZV9mbGFncyhwdGUpICYgX1BBR0VfUlc7CkBAIC0xNDIsNiArMTUwLDIzIEBACiAJCShfUEFHRV9QU0UgfCBfUEFHRV9QUkVTRU5UKTsKIH0KIAorI2lmZGVmIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRQorc3RhdGljIGlubGluZSBpbnQgcG1kX3RyYW5zX3NwbGl0dGluZyhwbWRfdCBwbWQpCit7CisJcmV0dXJuIHBtZF92YWwocG1kKSAmIF9QQUdFX1NQTElUVElORzsKK30KKworc3RhdGljIGlubGluZSBpbnQgcG1kX3RyYW5zX2h1Z2UocG1kX3QgcG1kKQoreworCXJldHVybiBwbWRfdmFsKHBtZCkgJiBfUEFHRV9QU0U7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IGhhc190cmFuc3BhcmVudF9odWdlcGFnZSh2b2lkKQoreworCXJldHVybiBjcHVfaGFzX3BzZTsKK30KKyNlbmRpZiAvKiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UgKi8KKwogc3RhdGljIGlubGluZSBwdGVfdCBwdGVfc2V0X2ZsYWdzKHB0ZV90IHB0ZSwgcHRldmFsX3Qgc2V0KQogewogCXB0ZXZhbF90IHYgPSBuYXRpdmVfcHRlX3ZhbChwdGUpOwpAQCAtMjE2LDYgKzI0MSw1NSBAQAogCXJldHVybiBwdGVfc2V0X2ZsYWdzKHB0ZSwgX1BBR0VfU1BFQ0lBTCk7CiB9CiAKK3N0YXRpYyBpbmxpbmUgcG1kX3QgcG1kX3NldF9mbGFncyhwbWRfdCBwbWQsIHBtZHZhbF90IHNldCkKK3sKKwlwbWR2YWxfdCB2ID0gbmF0aXZlX3BtZF92YWwocG1kKTsKKworCXJldHVybiBfX3BtZCh2IHwgc2V0KTsKK30KKworc3RhdGljIGlubGluZSBwbWRfdCBwbWRfY2xlYXJfZmxhZ3MocG1kX3QgcG1kLCBwbWR2YWxfdCBjbGVhcikKK3sKKwlwbWR2YWxfdCB2ID0gbmF0aXZlX3BtZF92YWwocG1kKTsKKworCXJldHVybiBfX3BtZCh2ICYgfmNsZWFyKTsKK30KKworc3RhdGljIGlubGluZSBwbWRfdCBwbWRfbWtvbGQocG1kX3QgcG1kKQoreworCXJldHVybiBwbWRfY2xlYXJfZmxhZ3MocG1kLCBfUEFHRV9BQ0NFU1NFRCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgcG1kX3QgcG1kX3dycHJvdGVjdChwbWRfdCBwbWQpCit7CisJcmV0dXJuIHBtZF9jbGVhcl9mbGFncyhwbWQsIF9QQUdFX1JXKTsKK30KKworc3RhdGljIGlubGluZSBwbWRfdCBwbWRfbWtkaXJ0eShwbWRfdCBwbWQpCit7CisJcmV0dXJuIHBtZF9zZXRfZmxhZ3MocG1kLCBfUEFHRV9ESVJUWSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgcG1kX3QgcG1kX21raHVnZShwbWRfdCBwbWQpCit7CisJcmV0dXJuIHBtZF9zZXRfZmxhZ3MocG1kLCBfUEFHRV9QU0UpOworfQorCitzdGF0aWMgaW5saW5lIHBtZF90IHBtZF9ta3lvdW5nKHBtZF90IHBtZCkKK3sKKwlyZXR1cm4gcG1kX3NldF9mbGFncyhwbWQsIF9QQUdFX0FDQ0VTU0VEKTsKK30KKworc3RhdGljIGlubGluZSBwbWRfdCBwbWRfbWt3cml0ZShwbWRfdCBwbWQpCit7CisJcmV0dXJuIHBtZF9zZXRfZmxhZ3MocG1kLCBfUEFHRV9SVyk7Cit9CisKK3N0YXRpYyBpbmxpbmUgcG1kX3QgcG1kX21rbm90cHJlc2VudChwbWRfdCBwbWQpCit7CisJcmV0dXJuIHBtZF9jbGVhcl9mbGFncyhwbWQsIF9QQUdFX1BSRVNFTlQpOworfQorCiAvKgogICogTWFzayBvdXQgdW5zdXBwb3J0ZWQgYml0cyBpbiBhIHByZXNlbnQgcGdwcm90LiAgTm9uLXByZXNlbnQgcGdwcm90cwogICogY2FuIHVzZSB0aG9zZSBiaXRzIGZvciBvdGhlciBwdXJwb3Nlcywgc28gbGVhdmUgdGhlbSBiZS4KQEAgLTI1Niw2ICszMzAsMTYgQEAKIAlyZXR1cm4gX19wdGUodmFsKTsKIH0KIAorc3RhdGljIGlubGluZSBwbWRfdCBwbWRfbW9kaWZ5KHBtZF90IHBtZCwgcGdwcm90X3QgbmV3cHJvdCkKK3sKKwlwbWR2YWxfdCB2YWwgPSBwbWRfdmFsKHBtZCk7CisKKwl2YWwgJj0gX0hQQUdFX0NIR19NQVNLOworCXZhbCB8PSBtYXNzYWdlX3BncHJvdChuZXdwcm90KSAmIH5fSFBBR0VfQ0hHX01BU0s7CisKKwlyZXR1cm4gX19wbWQodmFsKTsKK30KKwogLyogbXByb3RlY3QgbmVlZHMgdG8gcHJlc2VydmUgUEFUIGJpdHMgd2hlbiB1cGRhdGluZyB2bV9wYWdlX3Byb3QgKi8KICNkZWZpbmUgcGdwcm90X21vZGlmeSBwZ3Byb3RfbW9kaWZ5CiBzdGF0aWMgaW5saW5lIHBncHJvdF90IHBncHJvdF9tb2RpZnkocGdwcm90X3Qgb2xkcHJvdCwgcGdwcm90X3QgbmV3cHJvdCkKQEAgLTM1MCw3ICs0MzQsNyBAQAogICogQ3VycmVudGx5IHN0dWNrIGFzIGEgbWFjcm8gZHVlIHRvIGluZGlyZWN0IGZvcndhcmQgcmVmZXJlbmNlIHRvCiAgKiBsaW51eC9tbXpvbmUuaCdzIF9fc2VjdGlvbl9tZW1fbWFwX2FkZHIoKSBkZWZpbml0aW9uOgogICovCi0jZGVmaW5lIHBtZF9wYWdlKHBtZCkJcGZuX3RvX3BhZ2UocG1kX3ZhbChwbWQpID4+IFBBR0VfU0hJRlQpCisjZGVmaW5lIHBtZF9wYWdlKHBtZCkJcGZuX3RvX3BhZ2UoKHBtZF92YWwocG1kKSAmIFBURV9QRk5fTUFTSykgPj4gUEFHRV9TSElGVCkKIAogLyoKICAqIHRoZSBwbWQgcGFnZSBjYW4gYmUgdGhvdWdodCBvZiBhbiBhcnJheSBsaWtlIHRoaXM6IHBtZF90W1BUUlNfUEVSX1BNRF0KQEAgLTUyNCwxMiArNjA4LDI2IEBACiAJcmV0dXJuIHJlczsKIH0KIAorc3RhdGljIGlubGluZSBwbWRfdCBuYXRpdmVfbG9jYWxfcG1kcF9nZXRfYW5kX2NsZWFyKHBtZF90ICpwbWRwKQoreworCXBtZF90IHJlcyA9ICpwbWRwOworCisJbmF0aXZlX3BtZF9jbGVhcihwbWRwKTsKKwlyZXR1cm4gcmVzOworfQorCiBzdGF0aWMgaW5saW5lIHZvaWQgbmF0aXZlX3NldF9wdGVfYXQoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHVuc2lnbmVkIGxvbmcgYWRkciwKIAkJCQkgICAgIHB0ZV90ICpwdGVwICwgcHRlX3QgcHRlKQogewogCW5hdGl2ZV9zZXRfcHRlKHB0ZXAsIHB0ZSk7CiB9CiAKK3N0YXRpYyBpbmxpbmUgdm9pZCBuYXRpdmVfc2V0X3BtZF9hdChzdHJ1Y3QgbW1fc3RydWN0ICptbSwgdW5zaWduZWQgbG9uZyBhZGRyLAorCQkJCSAgICAgcG1kX3QgKnBtZHAgLCBwbWRfdCBwbWQpCit7CisJbmF0aXZlX3NldF9wbWQocG1kcCwgcG1kKTsKK30KKwogI2lmbmRlZiBDT05GSUdfUEFSQVZJUlQKIC8qCiAgKiBSdWxlcyBmb3IgdXNpbmcgcHRlX3VwZGF0ZSAtIGl0IG11c3QgYmUgY2FsbGVkIGFmdGVyIGFueSBQVEUgdXBkYXRlIHdoaWNoCkBAIC02MDcsNiArNzA1LDQ5IEBACiAKICNkZWZpbmUgZmx1c2hfdGxiX2ZpeF9zcHVyaW91c19mYXVsdCh2bWEsIGFkZHJlc3MpCiAKKyNkZWZpbmUgbWtfcG1kKHBhZ2UsIHBncHJvdCkgICBwZm5fcG1kKHBhZ2VfdG9fcGZuKHBhZ2UpLCAocGdwcm90KSkKKworI2RlZmluZSAgX19IQVZFX0FSQ0hfUE1EUF9TRVRfQUNDRVNTX0ZMQUdTCitleHRlcm4gaW50IHBtZHBfc2V0X2FjY2Vzc19mbGFncyhzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCQkgdW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwbWRfdCAqcG1kcCwKKwkJCQkgcG1kX3QgZW50cnksIGludCBkaXJ0eSk7CisKKyNkZWZpbmUgX19IQVZFX0FSQ0hfUE1EUF9URVNUX0FORF9DTEVBUl9ZT1VORworZXh0ZXJuIGludCBwbWRwX3Rlc3RfYW5kX2NsZWFyX3lvdW5nKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJCSAgICAgdW5zaWduZWQgbG9uZyBhZGRyLCBwbWRfdCAqcG1kcCk7CisKKyNkZWZpbmUgX19IQVZFX0FSQ0hfUE1EUF9DTEVBUl9ZT1VOR19GTFVTSAorZXh0ZXJuIGludCBwbWRwX2NsZWFyX2ZsdXNoX3lvdW5nKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJCSAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwbWRfdCAqcG1kcCk7CisKKworI2RlZmluZSBfX0hBVkVfQVJDSF9QTURQX1NQTElUVElOR19GTFVTSAorZXh0ZXJuIHZvaWQgcG1kcF9zcGxpdHRpbmdfZmx1c2goc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCQkJIHVuc2lnbmVkIGxvbmcgYWRkciwgcG1kX3QgKnBtZHApOworCisjZGVmaW5lIF9fSEFWRV9BUkNIX1BNRF9XUklURQorc3RhdGljIGlubGluZSBpbnQgcG1kX3dyaXRlKHBtZF90IHBtZCkKK3sKKwlyZXR1cm4gcG1kX2ZsYWdzKHBtZCkgJiBfUEFHRV9SVzsKK30KKworI2RlZmluZSBfX0hBVkVfQVJDSF9QTURQX0dFVF9BTkRfQ0xFQVIKK3N0YXRpYyBpbmxpbmUgcG1kX3QgcG1kcF9nZXRfYW5kX2NsZWFyKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCB1bnNpZ25lZCBsb25nIGFkZHIsCisJCQkJICAgICAgIHBtZF90ICpwbWRwKQoreworCXBtZF90IHBtZCA9IG5hdGl2ZV9wbWRwX2dldF9hbmRfY2xlYXIocG1kcCk7CisJcG1kX3VwZGF0ZShtbSwgYWRkciwgcG1kcCk7CisJcmV0dXJuIHBtZDsKK30KKworI2RlZmluZSBfX0hBVkVfQVJDSF9QTURQX1NFVF9XUlBST1RFQ1QKK3N0YXRpYyBpbmxpbmUgdm9pZCBwbWRwX3NldF93cnByb3RlY3Qoc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkJICAgICAgdW5zaWduZWQgbG9uZyBhZGRyLCBwbWRfdCAqcG1kcCkKK3sKKwljbGVhcl9iaXQoX1BBR0VfQklUX1JXLCAodW5zaWduZWQgbG9uZyAqKXBtZHApOworCXBtZF91cGRhdGUobW0sIGFkZHIsIHBtZHApOworfQorCiAvKgogICogY2xvbmVfcGdkX3JhbmdlKHBnZF90ICpkc3QsIHBnZF90ICpzcmMsIGludCBjb3VudCk7CiAgKgpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9hc20vcGd0YWJsZV82NC5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vcGd0YWJsZV82NC5oCmluZGV4IGY4NmRhMjAuLjk3NWY3MDkgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BndGFibGVfNjQuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wZ3RhYmxlXzY0LmgKQEAgLTU5LDYgKzU5LDE2IEBACiAJbmF0aXZlX3NldF9wdGUocHRlcCwgcHRlKTsKIH0KIAorc3RhdGljIGlubGluZSB2b2lkIG5hdGl2ZV9zZXRfcG1kKHBtZF90ICpwbWRwLCBwbWRfdCBwbWQpCit7CisJKnBtZHAgPSBwbWQ7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBuYXRpdmVfcG1kX2NsZWFyKHBtZF90ICpwbWQpCit7CisJbmF0aXZlX3NldF9wbWQocG1kLCBuYXRpdmVfbWFrZV9wbWQoMCkpOworfQorCiBzdGF0aWMgaW5saW5lIHB0ZV90IG5hdGl2ZV9wdGVwX2dldF9hbmRfY2xlYXIocHRlX3QgKnhwKQogewogI2lmZGVmIENPTkZJR19TTVAKQEAgLTcyLDE0ICs4MiwxNyBAQAogI2VuZGlmCiB9CiAKLXN0YXRpYyBpbmxpbmUgdm9pZCBuYXRpdmVfc2V0X3BtZChwbWRfdCAqcG1kcCwgcG1kX3QgcG1kKQorc3RhdGljIGlubGluZSBwbWRfdCBuYXRpdmVfcG1kcF9nZXRfYW5kX2NsZWFyKHBtZF90ICp4cCkKIHsKLQkqcG1kcCA9IHBtZDsKLX0KLQotc3RhdGljIGlubGluZSB2b2lkIG5hdGl2ZV9wbWRfY2xlYXIocG1kX3QgKnBtZCkKLXsKLQluYXRpdmVfc2V0X3BtZChwbWQsIG5hdGl2ZV9tYWtlX3BtZCgwKSk7CisjaWZkZWYgQ09ORklHX1NNUAorCXJldHVybiBuYXRpdmVfbWFrZV9wbWQoeGNoZygmeHAtPnBtZCwgMCkpOworI2Vsc2UKKwkvKiBuYXRpdmVfbG9jYWxfcG1kcF9nZXRfYW5kX2NsZWFyLAorCSAgIGJ1dCBkdXBsaWNhdGVkIGJlY2F1c2Ugb2YgY3ljbGljIGRlcGVuZGVuY3kgKi8KKwlwbWRfdCByZXQgPSAqeHA7CisJbmF0aXZlX3BtZF9jbGVhcih4cCk7CisJcmV0dXJuIHJldDsKKyNlbmRpZgogfQogCiBzdGF0aWMgaW5saW5lIHZvaWQgbmF0aXZlX3NldF9wdWQocHVkX3QgKnB1ZHAsIHB1ZF90IHB1ZCkKQEAgLTE2OCw2ICsxODEsNyBAQAogI2RlZmluZQlrY19vZmZzZXRfdG9fdmFkZHIobykgKChvKSB8IH5fX1ZJUlRVQUxfTUFTSykKIAogI2RlZmluZSBfX0hBVkVfQVJDSF9QVEVfU0FNRQorCiAjZW5kaWYgLyogIV9fQVNTRU1CTFlfXyAqLwogCiAjZW5kaWYgLyogX0FTTV9YODZfUEdUQUJMRV82NF9IICovCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wZ3RhYmxlX3R5cGVzLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wZ3RhYmxlX3R5cGVzLmgKaW5kZXggZDFmNGE3Ni4uN2RiNzcyMyAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vcGd0YWJsZV90eXBlcy5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BndGFibGVfdHlwZXMuaApAQCAtMjIsNiArMjIsNyBAQAogI2RlZmluZSBfUEFHRV9CSVRfUEFUX0xBUkdFCTEyCS8qIE9uIDJNQiBvciAxR0IgcGFnZXMgKi8KICNkZWZpbmUgX1BBR0VfQklUX1NQRUNJQUwJX1BBR0VfQklUX1VOVVNFRDEKICNkZWZpbmUgX1BBR0VfQklUX0NQQV9URVNUCV9QQUdFX0JJVF9VTlVTRUQxCisjZGVmaW5lIF9QQUdFX0JJVF9TUExJVFRJTkcJX1BBR0VfQklUX1VOVVNFRDEgLyogb25seSB2YWxpZCBvbiBhIFBTRSBwbWQgKi8KICNkZWZpbmUgX1BBR0VfQklUX05YICAgICAgICAgICA2MyAgICAgICAvKiBObyBleGVjdXRlOiBvbmx5IHZhbGlkIGFmdGVyIGNwdWlkIGNoZWNrICovCiAKIC8qIElmIF9QQUdFX0JJVF9QUkVTRU5UIGlzIGNsZWFyLCB3ZSB1c2UgdGhlc2U6ICovCkBAIC00NSw2ICs0Niw3IEBACiAjZGVmaW5lIF9QQUdFX1BBVF9MQVJHRSAoX0FUKHB0ZXZhbF90LCAxKSA8PCBfUEFHRV9CSVRfUEFUX0xBUkdFKQogI2RlZmluZSBfUEFHRV9TUEVDSUFMCShfQVQocHRldmFsX3QsIDEpIDw8IF9QQUdFX0JJVF9TUEVDSUFMKQogI2RlZmluZSBfUEFHRV9DUEFfVEVTVAkoX0FUKHB0ZXZhbF90LCAxKSA8PCBfUEFHRV9CSVRfQ1BBX1RFU1QpCisjZGVmaW5lIF9QQUdFX1NQTElUVElORwkoX0FUKHB0ZXZhbF90LCAxKSA8PCBfUEFHRV9CSVRfU1BMSVRUSU5HKQogI2RlZmluZSBfX0hBVkVfQVJDSF9QVEVfU1BFQ0lBTAogCiAjaWZkZWYgQ09ORklHX0tNRU1DSEVDSwpAQCAtNzAsNiArNzIsNyBAQAogLyogU2V0IG9mIGJpdHMgbm90IGNoYW5nZWQgaW4gcHRlX21vZGlmeSAqLwogI2RlZmluZSBfUEFHRV9DSEdfTUFTSwkoUFRFX1BGTl9NQVNLIHwgX1BBR0VfUENEIHwgX1BBR0VfUFdUIHwJCVwKIAkJCSBfUEFHRV9TUEVDSUFMIHwgX1BBR0VfQUNDRVNTRUQgfCBfUEFHRV9ESVJUWSkKKyNkZWZpbmUgX0hQQUdFX0NIR19NQVNLIChfUEFHRV9DSEdfTUFTSyB8IF9QQUdFX1BTRSkKIAogI2RlZmluZSBfUEFHRV9DQUNIRV9NQVNLCShfUEFHRV9QQ0QgfCBfUEFHRV9QV1QpCiAjZGVmaW5lIF9QQUdFX0NBQ0hFX1dCCQkoMCkKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3Byb2Nlc3Nvci5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vcHJvY2Vzc29yLmgKaW5kZXggNTNmZDFkNS4uNDU2MzZjZSAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vcHJvY2Vzc29yLmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vcHJvY2Vzc29yLmgKQEAgLTc2MSwxMCArNzYxLDExIEBACiBleHRlcm4gdm9pZCBpbml0X2MxZV9tYXNrKHZvaWQpOwogCiBleHRlcm4gdW5zaWduZWQgbG9uZwkJYm9vdF9vcHRpb25faWRsZV9vdmVycmlkZTsKLWV4dGVybiB1bnNpZ25lZCBsb25nCQlpZGxlX2hhbHQ7Ci1leHRlcm4gdW5zaWduZWQgbG9uZwkJaWRsZV9ub213YWl0OwogZXh0ZXJuIGJvb2wJCQljMWVfZGV0ZWN0ZWQ7CiAKK2VudW0gaWRsZV9ib290X292ZXJyaWRlIHtJRExFX05PX09WRVJSSURFPTAsIElETEVfSEFMVCwgSURMRV9OT01XQUlULAorCQkJIElETEVfUE9MTCwgSURMRV9GT1JDRV9NV0FJVH07CisKIGV4dGVybiB2b2lkIGVuYWJsZV9zZXBfY3B1KHZvaWQpOwogZXh0ZXJuIGludCBzeXNlbnRlcl9zZXR1cCh2b2lkKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9hc20vc21wLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9zbXAuaAppbmRleCA0YzJmNjNjLi4xZjQ2OTUxIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9zbXAuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9zbXAuaApAQCAtNDAsMTAgKzQwLDcgQEAKIERFQ0xBUkVfRUFSTFlfUEVSX0NQVSh1MTYsIHg4Nl9iaW9zX2NwdV9hcGljaWQpOwogCiAvKiBTdGF0aWMgc3RhdGUgaW4gaGVhZC5TIHVzZWQgdG8gc2V0IHVwIGEgQ1BVICovCi1leHRlcm4gc3RydWN0IHsKLQl2b2lkICpzcDsKLQl1bnNpZ25lZCBzaG9ydCBzczsKLX0gc3RhY2tfc3RhcnQ7CitleHRlcm4gdW5zaWduZWQgbG9uZyBzdGFja19zdGFydDsgLyogSW5pdGlhbCBzdGFjayBwb2ludGVyIGFkZHJlc3MgKi8KIAogc3RydWN0IHNtcF9vcHMgewogCXZvaWQgKCpzbXBfcHJlcGFyZV9ib290X2NwdSkodm9pZCk7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9zeXN0ZW1fNjQuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3N5c3RlbV82NC5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxMTU5ZTA5Li4wMDAwMDAwCi0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3N5c3RlbV82NC5oCisrKyAvZGV2L251bGwKQEAgLTEsMjIgKzAsMCBAQAotI2lmbmRlZiBfQVNNX1g4Nl9TWVNURU1fNjRfSAotI2RlZmluZSBfQVNNX1g4Nl9TWVNURU1fNjRfSAotCi0jaW5jbHVkZSA8YXNtL3NlZ21lbnQuaD4KLSNpbmNsdWRlIDxhc20vY21weGNoZy5oPgotCi0KLXN0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyByZWFkX2NyOCh2b2lkKQotewotCXVuc2lnbmVkIGxvbmcgY3I4OwotCWFzbSB2b2xhdGlsZSgibW92cSAlJWNyOCwlMCIgOiAiPXIiIChjcjgpKTsKLQlyZXR1cm4gY3I4OwotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQgd3JpdGVfY3I4KHVuc2lnbmVkIGxvbmcgdmFsKQotewotCWFzbSB2b2xhdGlsZSgibW92cSAlMCwlJWNyOCIgOjogInIiICh2YWwpIDogIm1lbW9yeSIpOwotfQotCi0jaW5jbHVkZSA8bGludXgvaXJxZmxhZ3MuaD4KLQotI2VuZGlmIC8qIF9BU01fWDg2X1NZU1RFTV82NF9IICovCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS94ZW4vcGFnZS5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20veGVuL3BhZ2UuaAppbmRleCA4NzYwY2M2Li5mMjViZGYyIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS94ZW4vcGFnZS5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3hlbi9wYWdlLmgKQEAgLTQyLDYgKzQyLDExIEBACiBleHRlcm4gdW5zaWduZWQgbG9uZyBnZXRfcGh5c190b19tYWNoaW5lKHVuc2lnbmVkIGxvbmcgcGZuKTsKIGV4dGVybiBib29sIHNldF9waHlzX3RvX21hY2hpbmUodW5zaWduZWQgbG9uZyBwZm4sIHVuc2lnbmVkIGxvbmcgbWZuKTsKIAorZXh0ZXJuIGludCBtMnBfYWRkX292ZXJyaWRlKHVuc2lnbmVkIGxvbmcgbWZuLCBzdHJ1Y3QgcGFnZSAqcGFnZSk7CitleHRlcm4gaW50IG0ycF9yZW1vdmVfb3ZlcnJpZGUoc3RydWN0IHBhZ2UgKnBhZ2UpOworZXh0ZXJuIHN0cnVjdCBwYWdlICptMnBfZmluZF9vdmVycmlkZSh1bnNpZ25lZCBsb25nIG1mbik7CitleHRlcm4gdW5zaWduZWQgbG9uZyBtMnBfZmluZF9vdmVycmlkZV9wZm4odW5zaWduZWQgbG9uZyBtZm4sIHVuc2lnbmVkIGxvbmcgcGZuKTsKKwogc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIHBmbl90b19tZm4odW5zaWduZWQgbG9uZyBwZm4pCiB7CiAJdW5zaWduZWQgbG9uZyBtZm47CkBAIC03Miw5ICs3Nyw2IEBACiAJaWYgKHhlbl9mZWF0dXJlKFhFTkZFQVRfYXV0b190cmFuc2xhdGVkX3BoeXNtYXApKQogCQlyZXR1cm4gbWZuOwogCi0JaWYgKHVubGlrZWx5KChtZm4gPj4gbWFjaGluZV90b19waHlzX29yZGVyKSAhPSAwKSkKLQkJcmV0dXJuIH4wOwotCiAJcGZuID0gMDsKIAkvKgogCSAqIFRoZSBhcnJheSBhY2Nlc3MgY2FuIGZhaWwgKGUuZy4sIGRldmljZSBzcGFjZSBiZXlvbmQgZW5kIG9mIFJBTSkuCkBAIC04Myw2ICs4NSwxNCBAQAogCSAqLwogCV9fZ2V0X3VzZXIocGZuLCAmbWFjaGluZV90b19waHlzX21hcHBpbmdbbWZuXSk7CiAKKwkvKgorCSAqIElmIHRoaXMgYXBwZWFycyB0byBiZSBhIGZvcmVpZ24gbWZuIChiZWNhdXNlIHRoZSBwZm4KKwkgKiBkb2Vzbid0IG1hcCBiYWNrIHRvIHRoZSBtZm4pLCB0aGVuIGNoZWNrIHRoZSBsb2NhbCBvdmVycmlkZQorCSAqIHRhYmxlIHRvIHNlZSBpZiB0aGVyZSdzIGEgYmV0dGVyIHBmbiB0byB1c2UuCisJICovCisJaWYgKGdldF9waHlzX3RvX21hY2hpbmUocGZuKSAhPSBtZm4pCisJCXBmbiA9IG0ycF9maW5kX292ZXJyaWRlX3BmbihtZm4sIHBmbik7CisKIAlyZXR1cm4gcGZuOwogfQogCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvYWNwaS9ib290LmMgYi9hcmNoL3g4Ni9rZXJuZWwvYWNwaS9ib290LmMKaW5kZXggZWM4ODFjNi4uYjNhNzExMyAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL2FjcGkvYm9vdC5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9hY3BpL2Jvb3QuYwpAQCAtNTA5LDYgKzUwOSw3IEBACiAKIAlyZXR1cm4gMDsKIH0KK0VYUE9SVF9TWU1CT0xfR1BMKGFjcGlfZ3NpX3RvX2lycSk7CiAKIGludCBhY3BpX2lzYV9pcnFfdG9fZ3NpKHVuc2lnbmVkIGlzYV9pcnEsIHUzMiAqZ3NpKQogewpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL2FjcGkvc2xlZXAuYyBiL2FyY2gveDg2L2tlcm5lbC9hY3BpL3NsZWVwLmMKaW5kZXggNjlmZDcyYS4uNjhkMTUzNyAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL2FjcGkvc2xlZXAuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvYWNwaS9zbGVlcC5jCkBAIC0xMiwxMCArMTIsOCBAQAogI2luY2x1ZGUgPGxpbnV4L2NwdW1hc2suaD4KICNpbmNsdWRlIDxhc20vc2VnbWVudC5oPgogI2luY2x1ZGUgPGFzbS9kZXNjLmg+Ci0KLSNpZmRlZiBDT05GSUdfWDg2XzMyCiAjaW5jbHVkZSA8YXNtL3BndGFibGUuaD4KLSNlbmRpZgorI2luY2x1ZGUgPGFzbS9jYWNoZWZsdXNoLmg+CiAKICNpbmNsdWRlICJyZWFsbW9kZS93YWtldXAuaCIKICNpbmNsdWRlICJzbGVlcC5oIgpAQCAtMTAwLDcgKzk4LDcgQEAKICNlbHNlIC8qIENPTkZJR182NEJJVCAqLwogCWhlYWRlci0+dHJhbXBvbGluZV9zZWdtZW50ID0gc2V0dXBfdHJhbXBvbGluZSgpID4+IDQ7CiAjaWZkZWYgQ09ORklHX1NNUAotCXN0YWNrX3N0YXJ0LnNwID0gdGVtcF9zdGFjayArIHNpemVvZih0ZW1wX3N0YWNrKTsKKwlzdGFja19zdGFydCA9ICh1bnNpZ25lZCBsb25nKXRlbXBfc3RhY2sgKyBzaXplb2YodGVtcF9zdGFjayk7CiAJZWFybHlfZ2R0X2Rlc2NyLmFkZHJlc3MgPQogCQkJKHVuc2lnbmVkIGxvbmcpZ2V0X2NwdV9nZHRfdGFibGUoc21wX3Byb2Nlc3Nvcl9pZCgpKTsKIAlpbml0aWFsX2dzID0gcGVyX2NwdV9vZmZzZXQoc21wX3Byb2Nlc3Nvcl9pZCgpKTsKQEAgLTE0OSw2ICsxNDcsMTUgQEAKIAltZW1ibG9ja194ODZfcmVzZXJ2ZV9yYW5nZShtZW0sIG1lbSArIFdBS0VVUF9TSVpFLCAiQUNQSSBXQUtFVVAiKTsKIH0KIAoraW50IF9faW5pdCBhY3BpX2NvbmZpZ3VyZV93YWtldXBfbWVtb3J5KHZvaWQpCit7CisJaWYgKGFjcGlfcmVhbG1vZGUpCisJCXNldF9tZW1vcnlfeChhY3BpX3JlYWxtb2RlLCBXQUtFVVBfU0laRSA+PiBQQUdFX1NISUZUKTsKKworCXJldHVybiAwOworfQorYXJjaF9pbml0Y2FsbChhY3BpX2NvbmZpZ3VyZV93YWtldXBfbWVtb3J5KTsKKwogCiBzdGF0aWMgaW50IF9faW5pdCBhY3BpX3NsZWVwX3NldHVwKGNoYXIgKnN0cikKIHsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9hcGJfdGltZXIuYyBiL2FyY2gveDg2L2tlcm5lbC9hcGJfdGltZXIuYwppbmRleCA3YzlhYjU5Li41MWVmMzFhIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvYXBiX3RpbWVyLmMKKysrIGIvYXJjaC94ODYva2VybmVsL2FwYl90aW1lci5jCkBAIC0zMTMsMTQgKzMxMywxNiBAQAogCWlmIChhZGV2LT5pcnEgPT0gMCkKIAkJcmV0dXJuOwogCisJaXJxX21vZGlmeV9zdGF0dXMoYWRldi0+aXJxLCAwLCBJUlFfTU9WRV9QQ05UWFQpOworCWlycV9zZXRfYWZmaW5pdHkoYWRldi0+aXJxLCBjcHVtYXNrX29mKGFkZXYtPmNwdSkpOworCS8qIEFQQiB0aW1lciBpcnFzIGFyZSBzZXQgdXAgYXMgbXBfaXJxcywgdGltZXIgaXMgZWRnZSB0eXBlICovCisJX19zZXRfaXJxX2hhbmRsZXIoYWRldi0+aXJxLCBoYW5kbGVfZWRnZV9pcnEsIDAsICJlZGdlIik7CisKIAlpZiAoc3lzdGVtX3N0YXRlID09IFNZU1RFTV9CT09USU5HKSB7Ci0JCWlycV9tb2RpZnlfc3RhdHVzKGFkZXYtPmlycSwgMCwgSVJRX01PVkVfUENOVFhUKTsKLQkJaXJxX3NldF9hZmZpbml0eShhZGV2LT5pcnEsIGNwdW1hc2tfb2YoYWRldi0+Y3B1KSk7Ci0JCS8qIEFQQiB0aW1lciBpcnFzIGFyZSBzZXQgdXAgYXMgbXBfaXJxcywgdGltZXIgaXMgZWRnZSB0eXBlICovCi0JCV9fc2V0X2lycV9oYW5kbGVyKGFkZXYtPmlycSwgaGFuZGxlX2VkZ2VfaXJxLCAwLCAiZWRnZSIpOwogCQlpZiAocmVxdWVzdF9pcnEoYWRldi0+aXJxLCBhcGJ0X2ludGVycnVwdF9oYW5kbGVyLAotCQkJCUlSUUZfVElNRVIgfCBJUlFGX0RJU0FCTEVEIHwgSVJRRl9OT0JBTEFOQ0lORywKLQkJCQlhZGV2LT5uYW1lLCBhZGV2KSkgeworCQkJCQlJUlFGX1RJTUVSIHwgSVJRRl9ESVNBQkxFRCB8CisJCQkJCUlSUUZfTk9CQUxBTkNJTkcsCisJCQkJCWFkZXYtPm5hbWUsIGFkZXYpKSB7CiAJCQlwcmludGsoS0VSTl9FUlIgIkZhaWxlZCByZXF1ZXN0IElSUSBmb3IgQVBCVCVkXG4iLAogCQkJICAgICAgIGFkZXYtPm51bSk7CiAJCX0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9jcHUvaW50ZWxfY2FjaGVpbmZvLmMgYi9hcmNoL3g4Ni9rZXJuZWwvY3B1L2ludGVsX2NhY2hlaW5mby5jCmluZGV4IDcyODNlOTguLmVjMmMxOWEgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC9jcHUvaW50ZWxfY2FjaGVpbmZvLmMKKysrIGIvYXJjaC94ODYva2VybmVsL2NwdS9pbnRlbF9jYWNoZWluZm8uYwpAQCAtNDUsNiArNDUsNyBAQAogCXsgMHgwYSwgTFZMXzFfREFUQSwgOCB9LAkvKiAyIHdheSBzZXQgYXNzb2MsIDMyIGJ5dGUgbGluZSBzaXplICovCiAJeyAweDBjLCBMVkxfMV9EQVRBLCAxNiB9LAkvKiA0LXdheSBzZXQgYXNzb2MsIDMyIGJ5dGUgbGluZSBzaXplICovCiAJeyAweDBkLCBMVkxfMV9EQVRBLCAxNiB9LAkvKiA0LXdheSBzZXQgYXNzb2MsIDY0IGJ5dGUgbGluZSBzaXplICovCisJeyAweDBlLCBMVkxfMV9EQVRBLCAyNCB9LAkvKiA2LXdheSBzZXQgYXNzb2MsIDY0IGJ5dGUgbGluZSBzaXplICovCiAJeyAweDIxLCBMVkxfMiwgICAgICAyNTYgfSwJLyogOC13YXkgc2V0IGFzc29jLCA2NCBieXRlIGxpbmUgc2l6ZSAqLwogCXsgMHgyMiwgTFZMXzMsICAgICAgNTEyIH0sCS8qIDQtd2F5IHNldCBhc3NvYywgc2VjdG9yZWQgY2FjaGUsIDY0IGJ5dGUgbGluZSBzaXplICovCiAJeyAweDIzLCBMVkxfMywgICAgICBNQigxKSB9LAkvKiA4LXdheSBzZXQgYXNzb2MsIHNlY3RvcmVkIGNhY2hlLCA2NCBieXRlIGxpbmUgc2l6ZSAqLwpAQCAtNjYsNiArNjcsNyBAQAogCXsgMHg0NSwgTFZMXzIsICAgICAgTUIoMikgfSwJLyogNC13YXkgc2V0IGFzc29jLCAzMiBieXRlIGxpbmUgc2l6ZSAqLwogCXsgMHg0NiwgTFZMXzMsICAgICAgTUIoNCkgfSwJLyogNC13YXkgc2V0IGFzc29jLCA2NCBieXRlIGxpbmUgc2l6ZSAqLwogCXsgMHg0NywgTFZMXzMsICAgICAgTUIoOCkgfSwJLyogOC13YXkgc2V0IGFzc29jLCA2NCBieXRlIGxpbmUgc2l6ZSAqLworCXsgMHg0OCwgTFZMXzIsICAgICAgTUIoMykgfSwJLyogMTItd2F5IHNldCBhc3NvYywgNjQgYnl0ZSBsaW5lIHNpemUgKi8KIAl7IDB4NDksIExWTF8zLCAgICAgIE1CKDQpIH0sCS8qIDE2LXdheSBzZXQgYXNzb2MsIDY0IGJ5dGUgbGluZSBzaXplICovCiAJeyAweDRhLCBMVkxfMywgICAgICBNQig2KSB9LAkvKiAxMi13YXkgc2V0IGFzc29jLCA2NCBieXRlIGxpbmUgc2l6ZSAqLwogCXsgMHg0YiwgTFZMXzMsICAgICAgTUIoOCkgfSwJLyogMTYtd2F5IHNldCBhc3NvYywgNjQgYnl0ZSBsaW5lIHNpemUgKi8KQEAgLTg3LDYgKzg5LDcgQEAKIAl7IDB4N2MsIExWTF8yLCAgICAgIE1CKDEpIH0sCS8qIDgtd2F5IHNldCBhc3NvYywgc2VjdG9yZWQgY2FjaGUsIDY0IGJ5dGUgbGluZSBzaXplICovCiAJeyAweDdkLCBMVkxfMiwgICAgICBNQigyKSB9LAkvKiA4LXdheSBzZXQgYXNzb2MsIDY0IGJ5dGUgbGluZSBzaXplICovCiAJeyAweDdmLCBMVkxfMiwgICAgICA1MTIgfSwJLyogMi13YXkgc2V0IGFzc29jLCA2NCBieXRlIGxpbmUgc2l6ZSAqLworCXsgMHg4MCwgTFZMXzIsICAgICAgNTEyIH0sCS8qIDgtd2F5IHNldCBhc3NvYywgNjQgYnl0ZSBsaW5lIHNpemUgKi8KIAl7IDB4ODIsIExWTF8yLCAgICAgIDI1NiB9LAkvKiA4LXdheSBzZXQgYXNzb2MsIDMyIGJ5dGUgbGluZSBzaXplICovCiAJeyAweDgzLCBMVkxfMiwgICAgICA1MTIgfSwJLyogOC13YXkgc2V0IGFzc29jLCAzMiBieXRlIGxpbmUgc2l6ZSAqLwogCXsgMHg4NCwgTFZMXzIsICAgICAgTUIoMSkgfSwJLyogOC13YXkgc2V0IGFzc29jLCAzMiBieXRlIGxpbmUgc2l6ZSAqLwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL2NwdS9tY2hlY2svdGhlcm1fdGhyb3QuYyBiL2FyY2gveDg2L2tlcm5lbC9jcHUvbWNoZWNrL3RoZXJtX3Rocm90LmMKaW5kZXggZTEyMjQ2Zi4uNmY4YzVlOSAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL2NwdS9tY2hlY2svdGhlcm1fdGhyb3QuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvY3B1L21jaGVjay90aGVybV90aHJvdC5jCkBAIC01OSw2ICs1OSw3IEBACiAKIC8qIENhbGxiYWNrIHRvIGhhbmRsZSBjb3JlIHRocmVzaG9sZCBpbnRlcnJ1cHRzICovCiBpbnQgKCpwbGF0Zm9ybV90aGVybWFsX25vdGlmeSkoX191NjQgbXNyX3ZhbCk7CitFWFBPUlRfU1lNQk9MKHBsYXRmb3JtX3RoZXJtYWxfbm90aWZ5KTsKIAogc3RhdGljIERFRklORV9QRVJfQ1BVKHN0cnVjdCB0aGVybWFsX3N0YXRlLCB0aGVybWFsX3N0YXRlKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL2NwdS9tdHJyL21haW4uYyBiL2FyY2gveDg2L2tlcm5lbC9jcHUvbXRyci9tYWluLmMKaW5kZXggMDFjMGYzZS4uYmViYWJlYyAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL2NwdS9tdHJyL21haW4uYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvY3B1L210cnIvbWFpbi5jCkBAIC03OTMsMTMgKzc5MywyMSBAQAogfQogCiAvKgotICogTVRSUiBpbml0aWFsaXphdGlvbiBmb3IgYWxsIEFQJ3MKKyAqIERlbGF5ZWQgTVRSUiBpbml0aWFsaXphdGlvbiBmb3IgYWxsIEFQJ3MKICAqLwogdm9pZCBtdHJyX2Fwc19pbml0KHZvaWQpCiB7CiAJaWYgKCF1c2VfaW50ZWwoKSkKIAkJcmV0dXJuOwogCisJLyoKKwkgKiBDaGVjayBpZiBzb21lb25lIGhhcyByZXF1ZXN0ZWQgdGhlIGRlbGF5IG9mIEFQIE1UUlIgaW5pdGlhbGl6YXRpb24sCisJICogYnkgZG9pbmcgc2V0X210cnJfYXBzX2RlbGF5ZWRfaW5pdCgpLCBwcmlvciB0byB0aGlzIHBvaW50LiBJZiBub3QsCisJICogdGhlbiB3ZSBhcmUgZG9uZS4KKwkgKi8KKwlpZiAoIW10cnJfYXBzX2RlbGF5ZWRfaW5pdCkKKwkJcmV0dXJuOworCiAJc2V0X210cnIofjBVLCAwLCAwLCAwKTsKIAltdHJyX2Fwc19kZWxheWVkX2luaXQgPSBmYWxzZTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9jcHUvcGVyZl9ldmVudF9wNC5jIGIvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmX2V2ZW50X3A0LmMKaW5kZXggZTU2YjliZi4uZjdhMDk5MyAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmX2V2ZW50X3A0LmMKKysrIGIvYXJjaC94ODYva2VybmVsL2NwdS9wZXJmX2V2ZW50X3A0LmMKQEAgLTY4Miw3ICs2ODIsNyBAQAogCSAqIGlmIGFuIGV2ZW50IGlzIHNoYXJlZCBhY2Nyb3NzIHRoZSBsb2dpY2FsIHRocmVhZHMKIAkgKiB0aGUgdXNlciBuZWVkcyBzcGVjaWFsIHBlcm1pc3Npb25zIHRvIGJlIGFibGUgdG8gdXNlIGl0CiAJICovCi0JaWYgKHA0X2V2ZW50X2JpbmRfbWFwW3ZdLnNoYXJlZCkgeworCWlmIChwNF9odF9hY3RpdmUoKSAmJiBwNF9ldmVudF9iaW5kX21hcFt2XS5zaGFyZWQpIHsKIAkJaWYgKHBlcmZfcGFyYW5vaWRfY3B1KCkgJiYgIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCiAJCQlyZXR1cm4gLUVBQ0NFUzsKIAl9CkBAIC03MjcsNyArNzI3LDggQEAKIAkJZXZlbnQtPmh3LmNvbmZpZyA9IHA0X3NldF9odF9iaXQoZXZlbnQtPmh3LmNvbmZpZyk7CiAKIAlpZiAoZXZlbnQtPmF0dHIudHlwZSA9PSBQRVJGX1RZUEVfUkFXKSB7Ci0KKwkJc3RydWN0IHA0X2V2ZW50X2JpbmQgKmJpbmQ7CisJCXVuc2lnbmVkIGludCBlc2VsOwogCQkvKgogCQkgKiBDbGVhciBiaXRzIHdlIHJlc2VydmUgdG8gYmUgbWFuYWdlZCBieSBrZXJuZWwgaXRzZWxmCiAJCSAqIGFuZCBuZXZlciBhbGxvd2VkIGZyb20gYSB1c2VyIHNwYWNlCkBAIC03NDMsNiArNzQ0LDEzIEBACiAJCSAqIGJpdHMgc2luY2Ugd2Uga2VlcCBhZGRpdGlvbmFsIGluZm8gaGVyZSAoZm9yIGNhY2hlIGV2ZW50cyBhbmQgZXRjKQogCQkgKi8KIAkJZXZlbnQtPmh3LmNvbmZpZyB8PSBldmVudC0+YXR0ci5jb25maWc7CisJCWJpbmQgPSBwNF9jb25maWdfZ2V0X2JpbmQoZXZlbnQtPmF0dHIuY29uZmlnKTsKKwkJaWYgKCFiaW5kKSB7CisJCQlyYyA9IC1FSU5WQUw7CisJCQlnb3RvIG91dDsKKwkJfQorCQllc2VsID0gUDRfT1BDT0RFX0VTRUwoYmluZC0+b3Bjb2RlKTsKKwkJZXZlbnQtPmh3LmNvbmZpZyB8PSBwNF9jb25maWdfcGFja19jY2NyKFA0X0NDQ1JfRVNFTChlc2VsKSk7CiAJfQogCiAJcmMgPSB4ODZfc2V0dXBfcGVyZmN0cihldmVudCk7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvZHVtcHN0YWNrLmMgYi9hcmNoL3g4Ni9rZXJuZWwvZHVtcHN0YWNrLmMKaW5kZXggZDZmYjE0Ni4uZGYyMDcyMyAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL2R1bXBzdGFjay5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9kdW1wc3RhY2suYwpAQCAtMjM0LDYgKzIzNCw3IEBACiAJYnVzdF9zcGlubG9ja3MoMSk7CiAJcmV0dXJuIGZsYWdzOwogfQorRVhQT1JUX1NZTUJPTF9HUEwob29wc19iZWdpbik7CiAKIHZvaWQgX19rcHJvYmVzIG9vcHNfZW5kKHVuc2lnbmVkIGxvbmcgZmxhZ3MsIHN0cnVjdCBwdF9yZWdzICpyZWdzLCBpbnQgc2lnbnIpCiB7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvZHVtcHN0YWNrXzY0LmMgYi9hcmNoL3g4Ni9rZXJuZWwvZHVtcHN0YWNrXzY0LmMKaW5kZXggNjQxMDEzMy4uYTZiNmZjZiAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL2R1bXBzdGFja182NC5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9kdW1wc3RhY2tfNjQuYwpAQCAtMTQ5LDEzICsxNDksMTMgQEAKIAl1bnNpZ25lZCB1c2VkID0gMDsKIAlzdHJ1Y3QgdGhyZWFkX2luZm8gKnRpbmZvOwogCWludCBncmFwaCA9IDA7CisJdW5zaWduZWQgbG9uZyBkdW1teTsKIAl1bnNpZ25lZCBsb25nIGJwOwogCiAJaWYgKCF0YXNrKQogCQl0YXNrID0gY3VycmVudDsKIAogCWlmICghc3RhY2spIHsKLQkJdW5zaWduZWQgbG9uZyBkdW1teTsKIAkJc3RhY2sgPSAmZHVtbXk7CiAJCWlmICh0YXNrICYmIHRhc2sgIT0gY3VycmVudCkKIAkJCXN0YWNrID0gKHVuc2lnbmVkIGxvbmcgKil0YXNrLT50aHJlYWQuc3A7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvZTgyMC5jIGIvYXJjaC94ODYva2VybmVsL2U4MjAuYwppbmRleCAwYzJiN2VmLi4yOTRmMjZkIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvZTgyMC5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9lODIwLmMKQEAgLTE0LDYgKzE0LDcgQEAKICNpbmNsdWRlIDxsaW51eC9ib290bWVtLmg+CiAjaW5jbHVkZSA8bGludXgvcGZuLmg+CiAjaW5jbHVkZSA8bGludXgvc3VzcGVuZC5oPgorI2luY2x1ZGUgPGxpbnV4L2FjcGkuaD4KICNpbmNsdWRlIDxsaW51eC9maXJtd2FyZS1tYXAuaD4KICNpbmNsdWRlIDxsaW51eC9tZW1ibG9jay5oPgogCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvaGVhZF8zMi5TIGIvYXJjaC94ODYva2VybmVsL2hlYWRfMzIuUwppbmRleCBmYzI5M2RjLi43NjdkNmM0IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvaGVhZF8zMi5TCisrKyBiL2FyY2gveDg2L2tlcm5lbC9oZWFkXzMyLlMKQEAgLTg1LDYgKzg1LDggQEAKICAqLwogX19IRUFECiBFTlRSWShzdGFydHVwXzMyKQorCW1vdmwgcGEoc3RhY2tfc3RhcnQpLCVlY3gKKwkKIAkvKiB0ZXN0IEtFRVBfU0VHTUVOVFMgZmxhZyB0byBzZWUgaWYgdGhlIGJvb3Rsb2FkZXIgaXMgYXNraW5nCiAJCXVzIHRvIG5vdCByZWxvYWQgc2VnbWVudHMgKi8KIAl0ZXN0YiAkKDE8PDYpLCBCUF9sb2FkZmxhZ3MoJWVzaSkKQEAgLTk5LDcgKzEwMSw5IEBACiAJbW92bCAlZWF4LCVlcwogCW1vdmwgJWVheCwlZnMKIAltb3ZsICVlYXgsJWdzCisJbW92bCAlZWF4LCVzcwogMjoKKwlsZWFsIC1fX1BBR0VfT0ZGU0VUKCVlY3gpLCVlc3AKIAogLyoKICAqIENsZWFyIEJTUyBmaXJzdCBzbyB0aGF0IHRoZXJlIGFyZSBubyBzdXJwcmlzZXMuLi4KQEAgLTE0NSw4ICsxNDksNiBAQAogICogX2Jya19lbmQgaXMgc2V0IHVwIHRvIHBvaW50IHRvIHRoZSBmaXJzdCAic2FmZSIgbG9jYXRpb24uCiAgKiBNYXBwaW5ncyBhcmUgY3JlYXRlZCBib3RoIGF0IHZpcnR1YWwgYWRkcmVzcyAwIChpZGVudGl0eSBtYXBwaW5nKQogICogYW5kIFBBR0VfT0ZGU0VUIGZvciB1cCB0byBfZW5kLgotICoKLSAqIE5vdGUgdGhhdCB0aGUgc3RhY2sgaXMgbm90IHlldCBzZXQgdXAhCiAgKi8KICNpZmRlZiBDT05GSUdfWDg2X1BBRQogCkBAIC0yODIsNiArMjg0LDkgQEAKIAltb3ZsICVlYXgsJWVzCiAJbW92bCAlZWF4LCVmcwogCW1vdmwgJWVheCwlZ3MKKwltb3ZsIHBhKHN0YWNrX3N0YXJ0KSwlZWN4CisJbW92bCAlZWF4LCVzcworCWxlYWwgLV9fUEFHRV9PRkZTRVQoJWVjeCksJWVzcAogI2VuZGlmIC8qIENPTkZJR19TTVAgKi8KIGRlZmF1bHRfZW50cnk6CiAKQEAgLTM0Nyw4ICszNTIsOCBAQAogCW1vdmwgJWVheCwlY3IwCQkvKiAuLmFuZCBzZXQgcGFnaW5nIChQRykgYml0ICovCiAJbGptcCAkX19CT09UX0NTLCQxZgkvKiBDbGVhciBwcmVmZXRjaCBhbmQgbm9ybWFsaXplICVlaXAgKi8KIDE6Ci0JLyogU2V0IHVwIHRoZSBzdGFjayBwb2ludGVyICovCi0JbHNzIHN0YWNrX3N0YXJ0LCVlc3AKKwkvKiBTaGlmdCB0aGUgc3RhY2sgcG9pbnRlciB0byBhIHZpcnR1YWwgYWRkcmVzcyAqLworCWFkZGwgJF9fUEFHRV9PRkZTRVQsICVlc3AKIAogLyoKICAqIEluaXRpYWxpemUgZWZsYWdzLiAgU29tZSBCSU9TJ3MgbGVhdmUgYml0cyBsaWtlIE5UIHNldC4gIFRoaXMgd291bGQKQEAgLTM2MCw5ICszNjUsNyBAQAogCiAjaWZkZWYgQ09ORklHX1NNUAogCWNtcGIgJDAsIHJlYWR5Ci0JanogIDFmCQkJCS8qIEluaXRpYWwgQ1BVIGNsZWFucyBCU1MgKi8KLQlqbXAgY2hlY2tDUFV0eXBlCi0xOgorCWpueiBjaGVja0NQVXR5cGUKICNlbmRpZiAvKiBDT05GSUdfU01QICovCiAKIC8qCkBAIC00NzAsMTQgKzQ3Myw3IEBACiAKIAljbGQJCQkjIGdjYzIgd2FudHMgdGhlIGRpcmVjdGlvbiBmbGFnIGNsZWFyZWQgYXQgYWxsIHRpbWVzCiAJcHVzaGwgJDAJCSMgZmFrZSByZXR1cm4gYWRkcmVzcyBmb3IgdW53aW5kZXIKLSNpZmRlZiBDT05GSUdfU01QCi0JbW92YiByZWFkeSwgJWNsCiAJbW92YiAkMSwgcmVhZHkKLQljbXBiICQwLCVjbAkJIyB0aGUgZmlyc3QgQ1BVIGNhbGxzIHN0YXJ0X2tlcm5lbAotCWplICAgMWYKLQltb3ZsIChzdGFja19zdGFydCksICVlc3AKLTE6Ci0jZW5kaWYgLyogQ09ORklHX1NNUCAqLwogCWptcCAqKGluaXRpYWxfY29kZSkKIAogLyoKQEAgLTY3MCwxNSArNjY2LDE1IEBACiAjZW5kaWYKIAogLmRhdGEKKy5iYWxpZ24gNAogRU5UUlkoc3RhY2tfc3RhcnQpCiAJLmxvbmcgaW5pdF90aHJlYWRfdW5pb24rVEhSRUFEX1NJWkUKLQkubG9uZyBfX0JPT1RfRFMKLQotcmVhZHk6CS5ieXRlIDAKIAogZWFybHlfcmVjdXJzaW9uX2ZsYWc6CiAJLmxvbmcgMAogCityZWFkeToJLmJ5dGUgMAorCiBpbnRfbXNnOgogCS5hc2NpeiAiVW5rbm93biBpbnRlcnJ1cHQgb3IgZmF1bHQgYXQ6ICVwICVwICVwXG4iCiAKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9pcnFfMzIuYyBiL2FyY2gveDg2L2tlcm5lbC9pcnFfMzIuYwppbmRleCA0OGZmNmRjLi45OTc0ZDIxIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvaXJxXzMyLmMKKysrIGIvYXJjaC94ODYva2VybmVsL2lycV8zMi5jCkBAIC0xMjksOCArMTI5LDcgQEAKIAlpcnFjdHggPSBwYWdlX2FkZHJlc3MoYWxsb2NfcGFnZXNfbm9kZShjcHVfdG9fbm9kZShjcHUpLAogCQkJCQkgICAgICAgVEhSRUFEX0ZMQUdTLAogCQkJCQkgICAgICAgVEhSRUFEX09SREVSKSk7Ci0JaXJxY3R4LT50aW5mby50YXNrCQk9IE5VTEw7Ci0JaXJxY3R4LT50aW5mby5leGVjX2RvbWFpbgk9IE5VTEw7CisJbWVtc2V0KCZpcnFjdHgtPnRpbmZvLCAwLCBzaXplb2Yoc3RydWN0IHRocmVhZF9pbmZvKSk7CiAJaXJxY3R4LT50aW5mby5jcHUJCT0gY3B1OwogCWlycWN0eC0+dGluZm8ucHJlZW1wdF9jb3VudAk9IEhBUkRJUlFfT0ZGU0VUOwogCWlycWN0eC0+dGluZm8uYWRkcl9saW1pdAk9IE1BS0VfTU1fU0VHKDApOwpAQCAtMTQwLDEwICsxMzksOCBAQAogCWlycWN0eCA9IHBhZ2VfYWRkcmVzcyhhbGxvY19wYWdlc19ub2RlKGNwdV90b19ub2RlKGNwdSksCiAJCQkJCSAgICAgICBUSFJFQURfRkxBR1MsCiAJCQkJCSAgICAgICBUSFJFQURfT1JERVIpKTsKLQlpcnFjdHgtPnRpbmZvLnRhc2sJCT0gTlVMTDsKLQlpcnFjdHgtPnRpbmZvLmV4ZWNfZG9tYWluCT0gTlVMTDsKKwltZW1zZXQoJmlycWN0eC0+dGluZm8sIDAsIHNpemVvZihzdHJ1Y3QgdGhyZWFkX2luZm8pKTsKIAlpcnFjdHgtPnRpbmZvLmNwdQkJPSBjcHU7Ci0JaXJxY3R4LT50aW5mby5wcmVlbXB0X2NvdW50CT0gMDsKIAlpcnFjdHgtPnRpbmZvLmFkZHJfbGltaXQJPSBNQUtFX01NX1NFRygwKTsKIAogCXBlcl9jcHUoc29mdGlycV9jdHgsIGNwdSkgPSBpcnFjdHg7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvbW9kdWxlLmMgYi9hcmNoL3g4Ni9rZXJuZWwvbW9kdWxlLmMKaW5kZXggOGYyOTU2MC4uYWIyM2YxYSAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL21vZHVsZS5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9tb2R1bGUuYwpAQCAtMzcsMjAgKzM3LDExIEBACiAKIHZvaWQgKm1vZHVsZV9hbGxvYyh1bnNpZ25lZCBsb25nIHNpemUpCiB7Ci0Jc3RydWN0IHZtX3N0cnVjdCAqYXJlYTsKLQotCWlmICghc2l6ZSkKKwlpZiAoUEFHRV9BTElHTihzaXplKSA+IE1PRFVMRVNfTEVOKQogCQlyZXR1cm4gTlVMTDsKLQlzaXplID0gUEFHRV9BTElHTihzaXplKTsKLQlpZiAoc2l6ZSA+IE1PRFVMRVNfTEVOKQotCQlyZXR1cm4gTlVMTDsKLQotCWFyZWEgPSBfX2dldF92bV9hcmVhKHNpemUsIFZNX0FMTE9DLCBNT0RVTEVTX1ZBRERSLCBNT0RVTEVTX0VORCk7Ci0JaWYgKCFhcmVhKQotCQlyZXR1cm4gTlVMTDsKLQotCXJldHVybiBfX3ZtYWxsb2NfYXJlYShhcmVhLCBHRlBfS0VSTkVMIHwgX19HRlBfSElHSE1FTSwKLQkJCQkJUEFHRV9LRVJORUxfRVhFQyk7CisJcmV0dXJuIF9fdm1hbGxvY19ub2RlX3JhbmdlKHNpemUsIDEsIE1PRFVMRVNfVkFERFIsIE1PRFVMRVNfRU5ELAorCQkJCUdGUF9LRVJORUwgfCBfX0dGUF9ISUdITUVNLCBQQUdFX0tFUk5FTF9FWEVDLAorCQkJCS0xLCBfX2J1aWx0aW5fcmV0dXJuX2FkZHJlc3MoMCkpOwogfQogCiAvKiBGcmVlIG1lbW9yeSByZXR1cm5lZCBmcm9tIG1vZHVsZV9hbGxvYyAqLwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL3BhcmF2aXJ0LmMgYi9hcmNoL3g4Ni9rZXJuZWwvcGFyYXZpcnQuYwppbmRleCBjNWIyNTAwLi44NjllMWFlIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvcGFyYXZpcnQuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvcGFyYXZpcnQuYwpAQCAtNDIxLDggKzQyMSwxMSBAQAogCS5zZXRfcHRlID0gbmF0aXZlX3NldF9wdGUsCiAJLnNldF9wdGVfYXQgPSBuYXRpdmVfc2V0X3B0ZV9hdCwKIAkuc2V0X3BtZCA9IG5hdGl2ZV9zZXRfcG1kLAorCS5zZXRfcG1kX2F0ID0gbmF0aXZlX3NldF9wbWRfYXQsCiAJLnB0ZV91cGRhdGUgPSBwYXJhdmlydF9ub3AsCiAJLnB0ZV91cGRhdGVfZGVmZXIgPSBwYXJhdmlydF9ub3AsCisJLnBtZF91cGRhdGUgPSBwYXJhdmlydF9ub3AsCisJLnBtZF91cGRhdGVfZGVmZXIgPSBwYXJhdmlydF9ub3AsCiAKIAkucHRlcF9tb2RpZnlfcHJvdF9zdGFydCA9IF9fcHRlcF9tb2RpZnlfcHJvdF9zdGFydCwKIAkucHRlcF9tb2RpZnlfcHJvdF9jb21taXQgPSBfX3B0ZXBfbW9kaWZ5X3Byb3RfY29tbWl0LApkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL3Byb2Nlc3MuYyBiL2FyY2gveDg2L2tlcm5lbC9wcm9jZXNzLmMKaW5kZXggMDljMDhhMS4uZTc2NGZjMCAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL3Byb2Nlc3MuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvcHJvY2Vzcy5jCkBAIC0xNCw2ICsxNCw3IEBACiAjaW5jbHVkZSA8bGludXgvdXRzbmFtZS5oPgogI2luY2x1ZGUgPHRyYWNlL2V2ZW50cy9wb3dlci5oPgogI2luY2x1ZGUgPGxpbnV4L2h3X2JyZWFrcG9pbnQuaD4KKyNpbmNsdWRlIDxhc20vY3B1Lmg+CiAjaW5jbHVkZSA8YXNtL3N5c3RlbS5oPgogI2luY2x1ZGUgPGFzbS9hcGljLmg+CiAjaW5jbHVkZSA8YXNtL3N5c2NhbGxzLmg+CkBAIC0yMiwxMSArMjMsNiBAQAogI2luY2x1ZGUgPGFzbS9pMzg3Lmg+CiAjaW5jbHVkZSA8YXNtL2RlYnVncmVnLmg+CiAKLXVuc2lnbmVkIGxvbmcgaWRsZV9oYWx0OwotRVhQT1JUX1NZTUJPTChpZGxlX2hhbHQpOwotdW5zaWduZWQgbG9uZyBpZGxlX25vbXdhaXQ7Ci1FWFBPUlRfU1lNQk9MKGlkbGVfbm9td2FpdCk7Ci0KIHN0cnVjdCBrbWVtX2NhY2hlICp0YXNrX3hzdGF0ZV9jYWNoZXA7CiBFWFBPUlRfU1lNQk9MX0dQTCh0YXNrX3hzdGF0ZV9jYWNoZXApOwogCkBAIC0zMjcsNyArMzIzLDcgQEAKIC8qCiAgKiBJZGxlIHJlbGF0ZWQgdmFyaWFibGVzIGFuZCBmdW5jdGlvbnMKICAqLwotdW5zaWduZWQgbG9uZyBib290X29wdGlvbl9pZGxlX292ZXJyaWRlID0gMDsKK3Vuc2lnbmVkIGxvbmcgYm9vdF9vcHRpb25faWRsZV9vdmVycmlkZSA9IElETEVfTk9fT1ZFUlJJREU7CiBFWFBPUlRfU1lNQk9MKGJvb3Rfb3B0aW9uX2lkbGVfb3ZlcnJpZGUpOwogCiAvKgpAQCAtMzg2LDYgKzM4Miw4IEBACiAJCWVsc2UKIAkJCWxvY2FsX2lycV9lbmFibGUoKTsKIAkJY3VycmVudF90aHJlYWRfaW5mbygpLT5zdGF0dXMgfD0gVFNfUE9MTElORzsKKwkJdHJhY2VfcG93ZXJfZW5kKHNtcF9wcm9jZXNzb3JfaWQoKSk7CisJCXRyYWNlX2NwdV9pZGxlKFBXUl9FVkVOVF9FWElULCBzbXBfcHJvY2Vzc29yX2lkKCkpOwogCX0gZWxzZSB7CiAJCWxvY2FsX2lycV9lbmFibGUoKTsKIAkJLyogbG9vcCBpcyBkb25lIGJ5IHRoZSBjYWxsZXIgKi8KQEAgLTQ0Myw4ICs0NDEsNiBAQAogICovCiB2b2lkIG13YWl0X2lkbGVfd2l0aF9oaW50cyh1bnNpZ25lZCBsb25nIGF4LCB1bnNpZ25lZCBsb25nIGN4KQogewotCXRyYWNlX3Bvd2VyX3N0YXJ0KFBPV0VSX0NTVEFURSwgKGF4Pj40KSsxLCBzbXBfcHJvY2Vzc29yX2lkKCkpOwotCXRyYWNlX2NwdV9pZGxlKChheD4+NCkrMSwgc21wX3Byb2Nlc3Nvcl9pZCgpKTsKIAlpZiAoIW5lZWRfcmVzY2hlZCgpKSB7CiAJCWlmIChjcHVfaGFzKF9fdGhpc19jcHVfcHRyKCZjcHVfaW5mbyksIFg4Nl9GRUFUVVJFX0NMRkxVU0hfTU9OSVRPUikpCiAJCQljbGZsdXNoKCh2b2lkICopJmN1cnJlbnRfdGhyZWFkX2luZm8oKS0+ZmxhZ3MpOwpAQCAtNDcxLDYgKzQ2Nyw4IEBACiAJCQlfX3N0aV9td2FpdCgwLCAwKTsKIAkJZWxzZQogCQkJbG9jYWxfaXJxX2VuYWJsZSgpOworCQl0cmFjZV9wb3dlcl9lbmQoc21wX3Byb2Nlc3Nvcl9pZCgpKTsKKwkJdHJhY2VfY3B1X2lkbGUoUFdSX0VWRU5UX0VYSVQsIHNtcF9wcm9jZXNzb3JfaWQoKSk7CiAJfSBlbHNlCiAJCWxvY2FsX2lycV9lbmFibGUoKTsKIH0KQEAgLTUwMywxNyArNTAxLDE2IEBACiAgKgogICogaWRsZT1td2FpdCBvdmVycmlkZXMgdGhpcyBkZWNpc2lvbiBhbmQgZm9yY2VzIHRoZSB1c2FnZSBvZiBtd2FpdC4KICAqLwotc3RhdGljIGludCBfX2NwdWluaXRkYXRhIGZvcmNlX213YWl0OwogCiAjZGVmaW5lIE1XQUlUX0lORk8JCQkweDA1CiAjZGVmaW5lIE1XQUlUX0VDWF9FWFRFTkRFRF9JTkZPCQkweDAxCiAjZGVmaW5lIE1XQUlUX0VEWF9DMQkJCTB4ZjAKIAotc3RhdGljIGludCBfX2NwdWluaXQgbXdhaXRfdXNhYmxlKGNvbnN0IHN0cnVjdCBjcHVpbmZvX3g4NiAqYykKK2ludCBfX2NwdWluaXQgbXdhaXRfdXNhYmxlKGNvbnN0IHN0cnVjdCBjcHVpbmZvX3g4NiAqYykKIHsKIAl1MzIgZWF4LCBlYngsIGVjeCwgZWR4OwogCi0JaWYgKGZvcmNlX213YWl0KQorCWlmIChib290X29wdGlvbl9pZGxlX292ZXJyaWRlID09IElETEVfRk9SQ0VfTVdBSVQpCiAJCXJldHVybiAxOwogCiAJaWYgKGMtPmNwdWlkX2xldmVsIDwgTVdBSVRfSU5GTykKQEAgLTYzMyw5ICs2MzAsMTAgQEAKIAlpZiAoIXN0cmNtcChzdHIsICJwb2xsIikpIHsKIAkJcHJpbnRrKCJ1c2luZyBwb2xsaW5nIGlkbGUgdGhyZWFkcy5cbiIpOwogCQlwbV9pZGxlID0gcG9sbF9pZGxlOwotCX0gZWxzZSBpZiAoIXN0cmNtcChzdHIsICJtd2FpdCIpKQotCQlmb3JjZV9td2FpdCA9IDE7Ci0JZWxzZSBpZiAoIXN0cmNtcChzdHIsICJoYWx0IikpIHsKKwkJYm9vdF9vcHRpb25faWRsZV9vdmVycmlkZSA9IElETEVfUE9MTDsKKwl9IGVsc2UgaWYgKCFzdHJjbXAoc3RyLCAibXdhaXQiKSkgeworCQlib290X29wdGlvbl9pZGxlX292ZXJyaWRlID0gSURMRV9GT1JDRV9NV0FJVDsKKwl9IGVsc2UgaWYgKCFzdHJjbXAoc3RyLCAiaGFsdCIpKSB7CiAJCS8qCiAJCSAqIFdoZW4gdGhlIGJvb3Qgb3B0aW9uIG9mIGlkbGU9aGFsdCBpcyBhZGRlZCwgaGFsdCBpcwogCQkgKiBmb3JjZWQgdG8gYmUgdXNlZCBmb3IgQ1BVIGlkbGUuIEluIHN1Y2ggY2FzZSBDUFUgQzIvQzMKQEAgLTY0NCw4ICs2NDIsNyBAQAogCQkgKiB0aGUgYm9vdF9vcHRpb25faWRsZV9vdmVycmlkZS4KIAkJICovCiAJCXBtX2lkbGUgPSBkZWZhdWx0X2lkbGU7Ci0JCWlkbGVfaGFsdCA9IDE7Ci0JCXJldHVybiAwOworCQlib290X29wdGlvbl9pZGxlX292ZXJyaWRlID0gSURMRV9IQUxUOwogCX0gZWxzZSBpZiAoIXN0cmNtcChzdHIsICJub213YWl0IikpIHsKIAkJLyoKIAkJICogSWYgdGhlIGJvb3Qgb3B0aW9uIG9mICJpZGxlPW5vbXdhaXQiIGlzIGFkZGVkLApAQCAtNjUzLDEyICs2NTAsMTAgQEAKIAkJICogc3RhdGVzLiBJbiBzdWNoIGNhc2UgaXQgd29uJ3QgdG91Y2ggdGhlIHZhcmlhYmxlCiAJCSAqIG9mIGJvb3Rfb3B0aW9uX2lkbGVfb3ZlcnJpZGUuCiAJCSAqLwotCQlpZGxlX25vbXdhaXQgPSAxOwotCQlyZXR1cm4gMDsKKwkJYm9vdF9vcHRpb25faWRsZV9vdmVycmlkZSA9IElETEVfTk9NV0FJVDsKIAl9IGVsc2UKIAkJcmV0dXJuIC0xOwogCi0JYm9vdF9vcHRpb25faWRsZV9vdmVycmlkZSA9IDE7CiAJcmV0dXJuIDA7CiB9CiBlYXJseV9wYXJhbSgiaWRsZSIsIGlkbGVfc2V0dXApOwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL3Byb2Nlc3NfMzIuYyBiL2FyY2gveDg2L2tlcm5lbC9wcm9jZXNzXzMyLmMKaW5kZXggNGI5YmVmYS4uOGQxMjg3OCAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL3Byb2Nlc3NfMzIuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvcHJvY2Vzc18zMi5jCkBAIC01Nyw4ICs1Nyw2IEBACiAjaW5jbHVkZSA8YXNtL3N5c2NhbGxzLmg+CiAjaW5jbHVkZSA8YXNtL2RlYnVncmVnLmg+CiAKLSNpbmNsdWRlIDx0cmFjZS9ldmVudHMvcG93ZXIuaD4KLQogYXNtbGlua2FnZSB2b2lkIHJldF9mcm9tX2Zvcmsodm9pZCkgX19hc21fXygicmV0X2Zyb21fZm9yayIpOwogCiAvKgpAQCAtMTEzLDggKzExMSw2IEBACiAJCQlzdG9wX2NyaXRpY2FsX3RpbWluZ3MoKTsKIAkJCXBtX2lkbGUoKTsKIAkJCXN0YXJ0X2NyaXRpY2FsX3RpbWluZ3MoKTsKLQkJCXRyYWNlX3Bvd2VyX2VuZChzbXBfcHJvY2Vzc29yX2lkKCkpOwotCQkJdHJhY2VfY3B1X2lkbGUoUFdSX0VWRU5UX0VYSVQsIHNtcF9wcm9jZXNzb3JfaWQoKSk7CiAJCX0KIAkJdGlja19ub2h6X3Jlc3RhcnRfc2NoZWRfdGljaygpOwogCQlwcmVlbXB0X2VuYWJsZV9ub19yZXNjaGVkKCk7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvcHJvY2Vzc182NC5jIGIvYXJjaC94ODYva2VybmVsL3Byb2Nlc3NfNjQuYwppbmRleCA0YzgxOGE3Li5iZDM4N2U4IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvcHJvY2Vzc182NC5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9wcm9jZXNzXzY0LmMKQEAgLTUxLDggKzUxLDYgQEAKICNpbmNsdWRlIDxhc20vc3lzY2FsbHMuaD4KICNpbmNsdWRlIDxhc20vZGVidWdyZWcuaD4KIAotI2luY2x1ZGUgPHRyYWNlL2V2ZW50cy9wb3dlci5oPgotCiBhc21saW5rYWdlIGV4dGVybiB2b2lkIHJldF9mcm9tX2Zvcmsodm9pZCk7CiAKIERFRklORV9QRVJfQ1BVKHVuc2lnbmVkIGxvbmcsIG9sZF9yc3ApOwpAQCAtMTQxLDEwICsxMzksNiBAQAogCQkJcG1faWRsZSgpOwogCQkJc3RhcnRfY3JpdGljYWxfdGltaW5ncygpOwogCi0JCQl0cmFjZV9wb3dlcl9lbmQoc21wX3Byb2Nlc3Nvcl9pZCgpKTsKLQkJCXRyYWNlX2NwdV9pZGxlKFBXUl9FVkVOVF9FWElULAotCQkJCSAgICAgICBzbXBfcHJvY2Vzc29yX2lkKCkpOwotCiAJCQkvKiBJbiBtYW55IGNhc2VzIHRoZSBpbnRlcnJ1cHQgdGhhdCBlbmRlZCBpZGxlCiAJCQkgICBoYXMgYWxyZWFkeSBjYWxsZWQgZXhpdF9pZGxlLiBCdXQgc29tZSBpZGxlCiAJCQkgICBsb29wcyBjYW4gYmUgd29rZW4gdXAgd2l0aG91dCBpbnRlcnJ1cHQuICovCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvc21wYm9vdC5jIGIvYXJjaC94ODYva2VybmVsL3NtcGJvb3QuYwppbmRleCA3NjNkZjc3Li4wMzI3M2I2IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvc21wYm9vdC5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9zbXBib290LmMKQEAgLTYzOCw3ICs2MzgsNyBAQAogCSAqIHRhcmdldCBwcm9jZXNzb3Igc3RhdGUuCiAJICovCiAJc3RhcnR1cF9pcGlfaG9vayhwaHlzX2FwaWNpZCwgKHVuc2lnbmVkIGxvbmcpIHN0YXJ0X3NlY29uZGFyeSwKLQkJCSAodW5zaWduZWQgbG9uZylzdGFja19zdGFydC5zcCk7CisJCQkgc3RhY2tfc3RhcnQpOwogCiAJLyoKIAkgKiBSdW4gU1RBUlRVUCBJUEkgbG9vcC4KQEAgLTc4NSw3ICs3ODUsNyBAQAogI2VuZGlmCiAJZWFybHlfZ2R0X2Rlc2NyLmFkZHJlc3MgPSAodW5zaWduZWQgbG9uZylnZXRfY3B1X2dkdF90YWJsZShjcHUpOwogCWluaXRpYWxfY29kZSA9ICh1bnNpZ25lZCBsb25nKXN0YXJ0X3NlY29uZGFyeTsKLQlzdGFja19zdGFydC5zcCA9ICh2b2lkICopIGNfaWRsZS5pZGxlLT50aHJlYWQuc3A7CisJc3RhY2tfc3RhcnQgID0gY19pZGxlLmlkbGUtPnRocmVhZC5zcDsKIAogCS8qIHN0YXJ0X2lwIGhhZCBiZXR0ZXIgYmUgcGFnZS1hbGlnbmVkISAqLwogCXN0YXJ0X2lwID0gc2V0dXBfdHJhbXBvbGluZSgpOwpAQCAtMTQwMiw4ICsxNDAyLDkgQEAKIAl1bnNpZ25lZCBpbnQgaGlnaGVzdF9zdWJjc3RhdGUgPSAwOwogCWludCBpOwogCXZvaWQgKm13YWl0X3B0cjsKKwlzdHJ1Y3QgY3B1aW5mb194ODYgKmMgPSBfX3RoaXNfY3B1X3B0cigmY3B1X2luZm8pOwogCi0JaWYgKCFjcHVfaGFzKF9fdGhpc19jcHVfcHRyKCZjcHVfaW5mbyksIFg4Nl9GRUFUVVJFX01XQUlUKSkKKwlpZiAoIShjcHVfaGFzKGMsIFg4Nl9GRUFUVVJFX01XQUlUKSAmJiBtd2FpdF91c2FibGUoYykpKQogCQlyZXR1cm47CiAJaWYgKCFjcHVfaGFzKF9fdGhpc19jcHVfcHRyKCZjcHVfaW5mbyksIFg4Nl9GRUFUVVJFX0NMRkxTSCkpCiAJCXJldHVybjsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC90Ym9vdC5jIGIvYXJjaC94ODYva2VybmVsL3Rib290LmMKaW5kZXggYzJmMWIyNi4uOTk4ZTk3MiAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL3Rib290LmMKKysrIGIvYXJjaC94ODYva2VybmVsL3Rib290LmMKQEAgLTEzMyw3ICsxMzMsNyBAQAogCXBtZCA9IHBtZF9hbGxvYygmdGJvb3RfbW0sIHB1ZCwgdmFkZHIpOwogCWlmICghcG1kKQogCQlyZXR1cm4gLTE7Ci0JcHRlID0gcHRlX2FsbG9jX21hcCgmdGJvb3RfbW0sIHBtZCwgdmFkZHIpOworCXB0ZSA9IHB0ZV9hbGxvY19tYXAoJnRib290X21tLCBOVUxMLCBwbWQsIHZhZGRyKTsKIAlpZiAoIXB0ZSkKIAkJcmV0dXJuIC0xOwogCXNldF9wdGVfYXQoJnRib290X21tLCB2YWRkciwgcHRlLCBwZm5fcHRlKHBmbiwgcHJvdCkpOwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL3RzYy5jIGIvYXJjaC94ODYva2VybmVsL3RzYy5jCmluZGV4IDgyM2Y3OWEuLmZmZTU3NTUgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC90c2MuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvdHNjLmMKQEAgLTQ2NCw3ICs0NjQsNyBAQAogCQl0c2NfcGl0X21pbiA9IG1pbih0c2NfcGl0X21pbiwgdHNjX3BpdF9raHopOwogCiAJCS8qIGhwZXQgb3IgcG10aW1lciBhdmFpbGFibGUgPyAqLwotCQlpZiAoIWhwZXQgJiYgIXJlZjEgJiYgIXJlZjIpCisJCWlmIChyZWYxID09IHJlZjIpCiAJCQljb250aW51ZTsKIAogCQkvKiBDaGVjaywgd2hldGhlciB0aGUgc2FtcGxpbmcgd2FzIGRpc3R1cmJlZCBieSBhbiBTTUkgKi8KQEAgLTkzNSw3ICs5MzUsNyBAQAogCXRzY19zdG9wID0gdHNjX3JlYWRfcmVmcygmcmVmX3N0b3AsIGhwZXQpOwogCiAJLyogaHBldCBvciBwbXRpbWVyIGF2YWlsYWJsZSA/ICovCi0JaWYgKCFocGV0ICYmICFyZWZfc3RhcnQgJiYgIXJlZl9zdG9wKQorCWlmIChyZWZfc3RhcnQgPT0gcmVmX3N0b3ApCiAJCWdvdG8gb3V0OwogCiAJLyogQ2hlY2ssIHdoZXRoZXIgdGhlIHNhbXBsaW5nIHdhcyBkaXN0dXJiZWQgYnkgYW4gU01JICovCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvdm04Nl8zMi5jIGIvYXJjaC94ODYva2VybmVsL3ZtODZfMzIuYwppbmRleCA2MWZiOTg1Li44NjNmODc1IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvdm04Nl8zMi5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC92bTg2XzMyLmMKQEAgLTE3OSw2ICsxNzksNyBAQAogCWlmIChwdWRfbm9uZV9vcl9jbGVhcl9iYWQocHVkKSkKIAkJZ290byBvdXQ7CiAJcG1kID0gcG1kX29mZnNldChwdWQsIDB4QTAwMDApOworCXNwbGl0X2h1Z2VfcGFnZV9wbWQobW0sIHBtZCk7CiAJaWYgKHBtZF9ub25lX29yX2NsZWFyX2JhZChwbWQpKQogCQlnb3RvIG91dDsKIAlwdGUgPSBwdGVfb2Zmc2V0X21hcF9sb2NrKG1tLCBwbWQsIDB4QTAwMDAsICZwdGwpOwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva3ZtL21tdS5jIGIvYXJjaC94ODYva3ZtL21tdS5jCmluZGV4IDljYWZiYjQuLmYwMmI4ZWQgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2t2bS9tbXUuYworKysgYi9hcmNoL3g4Ni9rdm0vbW11LmMKQEAgLTU1NCwxNCArNTU0LDE4IEBACiAJcmV0dXJuIHJldDsKIH0KIAotc3RhdGljIGludCBtYXBwaW5nX2xldmVsKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgZ2ZuX3QgbGFyZ2VfZ2ZuKQorc3RhdGljIGJvb2wgbWFwcGluZ19sZXZlbF9kaXJ0eV9iaXRtYXAoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBnZm5fdCBsYXJnZV9nZm4pCiB7CiAJc3RydWN0IGt2bV9tZW1vcnlfc2xvdCAqc2xvdDsKLQlpbnQgaG9zdF9sZXZlbCwgbGV2ZWwsIG1heF9sZXZlbDsKLQogCXNsb3QgPSBnZm5fdG9fbWVtc2xvdCh2Y3B1LT5rdm0sIGxhcmdlX2dmbik7CiAJaWYgKHNsb3QgJiYgc2xvdC0+ZGlydHlfYml0bWFwKQotCQlyZXR1cm4gUFRfUEFHRV9UQUJMRV9MRVZFTDsKKwkJcmV0dXJuIHRydWU7CisJcmV0dXJuIGZhbHNlOworfQorCitzdGF0aWMgaW50IG1hcHBpbmdfbGV2ZWwoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBnZm5fdCBsYXJnZV9nZm4pCit7CisJaW50IGhvc3RfbGV2ZWwsIGxldmVsLCBtYXhfbGV2ZWw7CiAKIAlob3N0X2xldmVsID0gaG9zdF9tYXBwaW5nX2xldmVsKHZjcHUtPmt2bSwgbGFyZ2VfZ2ZuKTsKIApAQCAtOTQxLDYgKzk0NSwzNSBAQAogCXJldHVybiB5b3VuZzsKIH0KIAorc3RhdGljIGludCBrdm1fdGVzdF9hZ2Vfcm1hcHAoc3RydWN0IGt2bSAqa3ZtLCB1bnNpZ25lZCBsb25nICpybWFwcCwKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgZGF0YSkKK3sKKwl1NjQgKnNwdGU7CisJaW50IHlvdW5nID0gMDsKKworCS8qCisJICogSWYgdGhlcmUncyBubyBhY2Nlc3MgYml0IGluIHRoZSBzZWNvbmRhcnkgcHRlIHNldCBieSB0aGUKKwkgKiBoYXJkd2FyZSBpdCdzIHVwIHRvIGd1cC1mYXN0L2d1cCB0byBzZXQgdGhlIGFjY2VzcyBiaXQgaW4KKwkgKiB0aGUgcHJpbWFyeSBwdGUgb3IgaW4gdGhlIHBhZ2Ugc3RydWN0dXJlLgorCSAqLworCWlmICghc2hhZG93X2FjY2Vzc2VkX21hc2spCisJCWdvdG8gb3V0OworCisJc3B0ZSA9IHJtYXBfbmV4dChrdm0sIHJtYXBwLCBOVUxMKTsKKwl3aGlsZSAoc3B0ZSkgeworCQl1NjQgX3NwdGUgPSAqc3B0ZTsKKwkJQlVHX09OKCEoX3NwdGUgJiBQVF9QUkVTRU5UX01BU0spKTsKKwkJeW91bmcgPSBfc3B0ZSAmIFBUX0FDQ0VTU0VEX01BU0s7CisJCWlmICh5b3VuZykgeworCQkJeW91bmcgPSAxOworCQkJYnJlYWs7CisJCX0KKwkJc3B0ZSA9IHJtYXBfbmV4dChrdm0sIHJtYXBwLCBzcHRlKTsKKwl9CitvdXQ6CisJcmV0dXJuIHlvdW5nOworfQorCiAjZGVmaW5lIFJNQVBfUkVDWUNMRV9USFJFU0hPTEQgMTAwMAogCiBzdGF0aWMgdm9pZCBybWFwX3JlY3ljbGUoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCB1NjQgKnNwdGUsIGdmbl90IGdmbikKQEAgLTk2MSw2ICs5OTQsMTEgQEAKIAlyZXR1cm4ga3ZtX2hhbmRsZV9odmEoa3ZtLCBodmEsIDAsIGt2bV9hZ2Vfcm1hcHApOwogfQogCitpbnQga3ZtX3Rlc3RfYWdlX2h2YShzdHJ1Y3Qga3ZtICprdm0sIHVuc2lnbmVkIGxvbmcgaHZhKQoreworCXJldHVybiBrdm1faGFuZGxlX2h2YShrdm0sIGh2YSwgMCwga3ZtX3Rlc3RfYWdlX3JtYXBwKTsKK30KKwogI2lmZGVmIE1NVV9ERUJVRwogc3RhdGljIGludCBpc19lbXB0eV9zaGFkb3dfcGFnZSh1NjQgKnNwdCkKIHsKQEAgLTIyODEsNiArMjMxOSw0OCBAQAogCXJldHVybiAxOwogfQogCitzdGF0aWMgdm9pZCB0cmFuc3BhcmVudF9odWdlcGFnZV9hZGp1c3Qoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LAorCQkJCQlnZm5fdCAqZ2ZucCwgcGZuX3QgKnBmbnAsIGludCAqbGV2ZWxwKQoreworCXBmbl90IHBmbiA9ICpwZm5wOworCWdmbl90IGdmbiA9ICpnZm5wOworCWludCBsZXZlbCA9ICpsZXZlbHA7CisKKwkvKgorCSAqIENoZWNrIGlmIGl0J3MgYSB0cmFuc3BhcmVudCBodWdlcGFnZS4gSWYgdGhpcyB3b3VsZCBiZSBhbgorCSAqIGh1Z2V0bGJmcyBwYWdlLCBsZXZlbCB3b3VsZG4ndCBiZSBzZXQgdG8KKwkgKiBQVF9QQUdFX1RBQkxFX0xFVkVMIGFuZCB0aGVyZSB3b3VsZCBiZSBubyBhZGp1c3RtZW50IGRvbmUKKwkgKiBoZXJlLgorCSAqLworCWlmICghaXNfZXJyb3JfcGZuKHBmbikgJiYgIWt2bV9pc19tbWlvX3BmbihwZm4pICYmCisJICAgIGxldmVsID09IFBUX1BBR0VfVEFCTEVfTEVWRUwgJiYKKwkgICAgUGFnZVRyYW5zQ29tcG91bmQocGZuX3RvX3BhZ2UocGZuKSkgJiYKKwkgICAgIWhhc193cnByb3RlY3RlZF9wYWdlKHZjcHUtPmt2bSwgZ2ZuLCBQVF9ESVJFQ1RPUllfTEVWRUwpKSB7CisJCXVuc2lnbmVkIGxvbmcgbWFzazsKKwkJLyoKKwkJICogbW11X25vdGlmaWVyX3JldHJ5IHdhcyBzdWNjZXNzZnVsIGFuZCB3ZSBob2xkIHRoZQorCQkgKiBtbXVfbG9jayBoZXJlLCBzbyB0aGUgcG1kIGNhbid0IGJlY29tZSBzcGxpdHRpbmcKKwkJICogZnJvbSB1bmRlciB1cywgYW5kIGluIHR1cm4KKwkJICogX19zcGxpdF9odWdlX3BhZ2VfcmVmY291bnQoKSBjYW4ndCBydW4gZnJvbSB1bmRlcgorCQkgKiB1cyBhbmQgd2UgY2FuIHNhZmVseSB0cmFuc2ZlciB0aGUgcmVmY291bnQgZnJvbQorCQkgKiBQR190YWlsIHRvIFBHX2hlYWQgYXMgd2Ugc3dpdGNoIHRoZSBwZm4gdG8gdGFpbCB0bworCQkgKiBoZWFkLgorCQkgKi8KKwkJKmxldmVscCA9IGxldmVsID0gUFRfRElSRUNUT1JZX0xFVkVMOworCQltYXNrID0gS1ZNX1BBR0VTX1BFUl9IUEFHRShsZXZlbCkgLSAxOworCQlWTV9CVUdfT04oKGdmbiAmIG1hc2spICE9IChwZm4gJiBtYXNrKSk7CisJCWlmIChwZm4gJiBtYXNrKSB7CisJCQlnZm4gJj0gfm1hc2s7CisJCQkqZ2ZucCA9IGdmbjsKKwkJCWt2bV9yZWxlYXNlX3Bmbl9jbGVhbihwZm4pOworCQkJcGZuICY9IH5tYXNrOworCQkJaWYgKCFnZXRfcGFnZV91bmxlc3NfemVybyhwZm5fdG9fcGFnZShwZm4pKSkKKwkJCQlCVUcoKTsKKwkJCSpwZm5wID0gcGZuOworCQl9CisJfQorfQorCiBzdGF0aWMgYm9vbCB0cnlfYXN5bmNfcGYoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBib29sIHByZWZhdWx0LCBnZm5fdCBnZm4sCiAJCQkgZ3ZhX3QgZ3ZhLCBwZm5fdCAqcGZuLCBib29sIHdyaXRlLCBib29sICp3cml0YWJsZSk7CiAKQEAgLTIyODksMjAgKzIzNjksMjUgQEAKIHsKIAlpbnQgcjsKIAlpbnQgbGV2ZWw7CisJaW50IGZvcmNlX3B0X2xldmVsOwogCXBmbl90IHBmbjsKIAl1bnNpZ25lZCBsb25nIG1tdV9zZXE7CiAJYm9vbCBtYXBfd3JpdGFibGU7CiAKLQlsZXZlbCA9IG1hcHBpbmdfbGV2ZWwodmNwdSwgZ2ZuKTsKKwlmb3JjZV9wdF9sZXZlbCA9IG1hcHBpbmdfbGV2ZWxfZGlydHlfYml0bWFwKHZjcHUsIGdmbik7CisJaWYgKGxpa2VseSghZm9yY2VfcHRfbGV2ZWwpKSB7CisJCWxldmVsID0gbWFwcGluZ19sZXZlbCh2Y3B1LCBnZm4pOworCQkvKgorCQkgKiBUaGlzIHBhdGggYnVpbGRzIGEgUEFFIHBhZ2V0YWJsZSAtIHNvIHdlIGNhbiBtYXAKKwkJICogMm1iIHBhZ2VzIGF0IG1heGltdW0uIFRoZXJlZm9yZSBjaGVjayBpZiB0aGUgbGV2ZWwKKwkJICogaXMgbGFyZ2VyIHRoYW4gdGhhdC4KKwkJICovCisJCWlmIChsZXZlbCA+IFBUX0RJUkVDVE9SWV9MRVZFTCkKKwkJCWxldmVsID0gUFRfRElSRUNUT1JZX0xFVkVMOwogCi0JLyoKLQkgKiBUaGlzIHBhdGggYnVpbGRzIGEgUEFFIHBhZ2V0YWJsZSAtIHNvIHdlIGNhbiBtYXAgMm1iIHBhZ2VzIGF0Ci0JICogbWF4aW11bS4gVGhlcmVmb3JlIGNoZWNrIGlmIHRoZSBsZXZlbCBpcyBsYXJnZXIgdGhhbiB0aGF0LgotCSAqLwotCWlmIChsZXZlbCA+IFBUX0RJUkVDVE9SWV9MRVZFTCkKLQkJbGV2ZWwgPSBQVF9ESVJFQ1RPUllfTEVWRUw7Ci0KLQlnZm4gJj0gfihLVk1fUEFHRVNfUEVSX0hQQUdFKGxldmVsKSAtIDEpOworCQlnZm4gJj0gfihLVk1fUEFHRVNfUEVSX0hQQUdFKGxldmVsKSAtIDEpOworCX0gZWxzZQorCQlsZXZlbCA9IFBUX1BBR0VfVEFCTEVfTEVWRUw7CiAKIAltbXVfc2VxID0gdmNwdS0+a3ZtLT5tbXVfbm90aWZpZXJfc2VxOwogCXNtcF9ybWIoKTsKQEAgLTIzMTgsNiArMjQwMyw4IEBACiAJaWYgKG1tdV9ub3RpZmllcl9yZXRyeSh2Y3B1LCBtbXVfc2VxKSkKIAkJZ290byBvdXRfdW5sb2NrOwogCWt2bV9tbXVfZnJlZV9zb21lX3BhZ2VzKHZjcHUpOworCWlmIChsaWtlbHkoIWZvcmNlX3B0X2xldmVsKSkKKwkJdHJhbnNwYXJlbnRfaHVnZXBhZ2VfYWRqdXN0KHZjcHUsICZnZm4sICZwZm4sICZsZXZlbCk7CiAJciA9IF9fZGlyZWN0X21hcCh2Y3B1LCB2LCB3cml0ZSwgbWFwX3dyaXRhYmxlLCBsZXZlbCwgZ2ZuLCBwZm4sCiAJCQkgcHJlZmF1bHQpOwogCXNwaW5fdW5sb2NrKCZ2Y3B1LT5rdm0tPm1tdV9sb2NrKTsKQEAgLTI2NTUsNiArMjc0Miw3IEBACiAJcGZuX3QgcGZuOwogCWludCByOwogCWludCBsZXZlbDsKKwlpbnQgZm9yY2VfcHRfbGV2ZWw7CiAJZ2ZuX3QgZ2ZuID0gZ3BhID4+IFBBR0VfU0hJRlQ7CiAJdW5zaWduZWQgbG9uZyBtbXVfc2VxOwogCWludCB3cml0ZSA9IGVycm9yX2NvZGUgJiBQRkVSUl9XUklURV9NQVNLOwpAQCAtMjY2Nyw5ICsyNzU1LDEyIEBACiAJaWYgKHIpCiAJCXJldHVybiByOwogCi0JbGV2ZWwgPSBtYXBwaW5nX2xldmVsKHZjcHUsIGdmbik7Ci0KLQlnZm4gJj0gfihLVk1fUEFHRVNfUEVSX0hQQUdFKGxldmVsKSAtIDEpOworCWZvcmNlX3B0X2xldmVsID0gbWFwcGluZ19sZXZlbF9kaXJ0eV9iaXRtYXAodmNwdSwgZ2ZuKTsKKwlpZiAobGlrZWx5KCFmb3JjZV9wdF9sZXZlbCkpIHsKKwkJbGV2ZWwgPSBtYXBwaW5nX2xldmVsKHZjcHUsIGdmbik7CisJCWdmbiAmPSB+KEtWTV9QQUdFU19QRVJfSFBBR0UobGV2ZWwpIC0gMSk7CisJfSBlbHNlCisJCWxldmVsID0gUFRfUEFHRV9UQUJMRV9MRVZFTDsKIAogCW1tdV9zZXEgPSB2Y3B1LT5rdm0tPm1tdV9ub3RpZmllcl9zZXE7CiAJc21wX3JtYigpOwpAQCAtMjY4NCw2ICsyNzc1LDggQEAKIAlpZiAobW11X25vdGlmaWVyX3JldHJ5KHZjcHUsIG1tdV9zZXEpKQogCQlnb3RvIG91dF91bmxvY2s7CiAJa3ZtX21tdV9mcmVlX3NvbWVfcGFnZXModmNwdSk7CisJaWYgKGxpa2VseSghZm9yY2VfcHRfbGV2ZWwpKQorCQl0cmFuc3BhcmVudF9odWdlcGFnZV9hZGp1c3QodmNwdSwgJmdmbiwgJnBmbiwgJmxldmVsKTsKIAlyID0gX19kaXJlY3RfbWFwKHZjcHUsIGdwYSwgd3JpdGUsIG1hcF93cml0YWJsZSwKIAkJCSBsZXZlbCwgZ2ZuLCBwZm4sIHByZWZhdWx0KTsKIAlzcGluX3VubG9jaygmdmNwdS0+a3ZtLT5tbXVfbG9jayk7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rdm0vcGFnaW5nX3RtcGwuaCBiL2FyY2gveDg2L2t2bS9wYWdpbmdfdG1wbC5oCmluZGV4IDUzMjEwZjEuLjZiY2NjMjQgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2t2bS9wYWdpbmdfdG1wbC5oCisrKyBiL2FyY2gveDg2L2t2bS9wYWdpbmdfdG1wbC5oCkBAIC01NTAsNiArNTUwLDcgQEAKIAlpbnQgcjsKIAlwZm5fdCBwZm47CiAJaW50IGxldmVsID0gUFRfUEFHRV9UQUJMRV9MRVZFTDsKKwlpbnQgZm9yY2VfcHRfbGV2ZWw7CiAJdW5zaWduZWQgbG9uZyBtbXVfc2VxOwogCWJvb2wgbWFwX3dyaXRhYmxlOwogCkBAIC01NzcsNyArNTc4LDExIEBACiAJCXJldHVybiAwOwogCX0KIAotCWlmICh3YWxrZXIubGV2ZWwgPj0gUFRfRElSRUNUT1JZX0xFVkVMKSB7CisJaWYgKHdhbGtlci5sZXZlbCA+PSBQVF9ESVJFQ1RPUllfTEVWRUwpCisJCWZvcmNlX3B0X2xldmVsID0gbWFwcGluZ19sZXZlbF9kaXJ0eV9iaXRtYXAodmNwdSwgd2Fsa2VyLmdmbik7CisJZWxzZQorCQlmb3JjZV9wdF9sZXZlbCA9IDE7CisJaWYgKCFmb3JjZV9wdF9sZXZlbCkgewogCQlsZXZlbCA9IG1pbih3YWxrZXIubGV2ZWwsIG1hcHBpbmdfbGV2ZWwodmNwdSwgd2Fsa2VyLmdmbikpOwogCQl3YWxrZXIuZ2ZuID0gd2Fsa2VyLmdmbiAmIH4oS1ZNX1BBR0VTX1BFUl9IUEFHRShsZXZlbCkgLSAxKTsKIAl9CkBAIC01OTksNiArNjA0LDggQEAKIAogCXRyYWNlX2t2bV9tbXVfYXVkaXQodmNwdSwgQVVESVRfUFJFX1BBR0VfRkFVTFQpOwogCWt2bV9tbXVfZnJlZV9zb21lX3BhZ2VzKHZjcHUpOworCWlmICghZm9yY2VfcHRfbGV2ZWwpCisJCXRyYW5zcGFyZW50X2h1Z2VwYWdlX2FkanVzdCh2Y3B1LCAmd2Fsa2VyLmdmbiwgJnBmbiwgJmxldmVsKTsKIAlzcHRlcCA9IEZOQU1FKGZldGNoKSh2Y3B1LCBhZGRyLCAmd2Fsa2VyLCB1c2VyX2ZhdWx0LCB3cml0ZV9mYXVsdCwKIAkJCSAgICAgbGV2ZWwsICZ3cml0ZV9wdCwgcGZuLCBtYXBfd3JpdGFibGUsIHByZWZhdWx0KTsKIAkodm9pZClzcHRlcDsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2t2bS9zdm0uYyBiL2FyY2gveDg2L2t2bS9zdm0uYwppbmRleCAyNWJkMWJjLi41NGNlMjQ2IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rdm0vc3ZtLmMKKysrIGIvYXJjaC94ODYva3ZtL3N2bS5jCkBAIC0xMTUwLDggKzExNTAsOCBAQAogCWt2bV9sb2FkX2xkdChzdm0tPmhvc3QubGR0KTsKICNpZmRlZiBDT05GSUdfWDg2XzY0CiAJbG9hZHNlZ21lbnQoZnMsIHN2bS0+aG9zdC5mcyk7Ci0JbG9hZF9nc19pbmRleChzdm0tPmhvc3QuZ3MpOwogCXdybXNybChNU1JfS0VSTkVMX0dTX0JBU0UsIGN1cnJlbnQtPnRocmVhZC5ncyk7CisJbG9hZF9nc19pbmRleChzdm0tPmhvc3QuZ3MpOwogI2Vsc2UKIAlsb2Fkc2VnbWVudChncywgc3ZtLT5ob3N0LmdzKTsKICNlbmRpZgpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvbGd1ZXN0L0tjb25maWcgYi9hcmNoL3g4Ni9sZ3Vlc3QvS2NvbmZpZwppbmRleCAzODcxODA0Li42ZTEyMWEyIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9sZ3Vlc3QvS2NvbmZpZworKysgYi9hcmNoL3g4Ni9sZ3Vlc3QvS2NvbmZpZwpAQCAtMiw2ICsyLDcgQEAKIAlib29sICJMZ3Vlc3QgZ3Vlc3Qgc3VwcG9ydCIKIAlzZWxlY3QgUEFSQVZJUlQKIAlkZXBlbmRzIG9uIFg4Nl8zMgorCXNlbGVjdCBWSVJUVUFMSVpBVElPTgogCXNlbGVjdCBWSVJUSU8KIAlzZWxlY3QgVklSVElPX1JJTkcKIAlzZWxlY3QgVklSVElPX0NPTlNPTEUKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2xndWVzdC9ib290LmMgYi9hcmNoL3g4Ni9sZ3Vlc3QvYm9vdC5jCmluZGV4IDQ5OTZjZjUuLmViYTY4N2YwIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9sZ3Vlc3QvYm9vdC5jCisrKyBiL2FyY2gveDg2L2xndWVzdC9ib290LmMKQEAgLTgyNCw3ICs4MjQsNyBAQAogCiAJZm9yIChpID0gRklSU1RfRVhURVJOQUxfVkVDVE9SOyBpIDwgTlJfVkVDVE9SUzsgaSsrKSB7CiAJCS8qIFNvbWUgc3lzdGVtcyBtYXAgInZlY3RvcnMiIHRvIGludGVycnVwdHMgd2VpcmRseS4gIE5vdCB1cyEgKi8KLQkJX19nZXRfY3B1X3Zhcih2ZWN0b3JfaXJxKVtpXSA9IGkgLSBGSVJTVF9FWFRFUk5BTF9WRUNUT1I7CisJCV9fdGhpc19jcHVfd3JpdGUodmVjdG9yX2lycVtpXSwgaSAtIEZJUlNUX0VYVEVSTkFMX1ZFQ1RPUik7CiAJCWlmIChpICE9IFNZU0NBTExfVkVDVE9SKQogCQkJc2V0X2ludHJfZ2F0ZShpLCBpbnRlcnJ1cHRbaSAtIEZJUlNUX0VYVEVSTkFMX1ZFQ1RPUl0pOwogCX0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL2d1cC5jIGIvYXJjaC94ODYvbW0vZ3VwLmMKaW5kZXggNzM4ZTY1OS4uZGJlMzRiOSAxMDA2NDQKLS0tIGEvYXJjaC94ODYvbW0vZ3VwLmMKKysrIGIvYXJjaC94ODYvbW0vZ3VwLmMKQEAgLTgsNiArOCw3IEBACiAjaW5jbHVkZSA8bGludXgvbW0uaD4KICNpbmNsdWRlIDxsaW51eC92bXN0YXQuaD4KICNpbmNsdWRlIDxsaW51eC9oaWdobWVtLmg+CisjaW5jbHVkZSA8bGludXgvc3dhcC5oPgogCiAjaW5jbHVkZSA8YXNtL3BndGFibGUuaD4KIApAQCAtODksNiArOTAsNyBAQAogCQlWTV9CVUdfT04oIXBmbl92YWxpZChwdGVfcGZuKHB0ZSkpKTsKIAkJcGFnZSA9IHB0ZV9wYWdlKHB0ZSk7CiAJCWdldF9wYWdlKHBhZ2UpOworCQlTZXRQYWdlUmVmZXJlbmNlZChwYWdlKTsKIAkJcGFnZXNbKm5yXSA9IHBhZ2U7CiAJCSgqbnIpKys7CiAKQEAgLTEwMyw2ICsxMDUsMTcgQEAKIAlWTV9CVUdfT04ocGFnZSAhPSBjb21wb3VuZF9oZWFkKHBhZ2UpKTsKIAlWTV9CVUdfT04ocGFnZV9jb3VudChwYWdlKSA9PSAwKTsKIAlhdG9taWNfYWRkKG5yLCAmcGFnZS0+X2NvdW50KTsKKwlTZXRQYWdlUmVmZXJlbmNlZChwYWdlKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGdldF9odWdlX3BhZ2VfdGFpbChzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwkvKgorCSAqIF9fc3BsaXRfaHVnZV9wYWdlX3JlZmNvdW50KCkgY2Fubm90IHJ1bgorCSAqIGZyb20gdW5kZXIgdXMuCisJICovCisJVk1fQlVHX09OKGF0b21pY19yZWFkKCZwYWdlLT5fY291bnQpIDwgMCk7CisJYXRvbWljX2luYygmcGFnZS0+X2NvdW50KTsKIH0KIAogc3RhdGljIG5vaW5saW5lIGludCBndXBfaHVnZV9wbWQocG1kX3QgcG1kLCB1bnNpZ25lZCBsb25nIGFkZHIsCkBAIC0xMjgsNiArMTQxLDggQEAKIAlkbyB7CiAJCVZNX0JVR19PTihjb21wb3VuZF9oZWFkKHBhZ2UpICE9IGhlYWQpOwogCQlwYWdlc1sqbnJdID0gcGFnZTsKKwkJaWYgKFBhZ2VUYWlsKHBhZ2UpKQorCQkJZ2V0X2h1Z2VfcGFnZV90YWlsKHBhZ2UpOwogCQkoKm5yKSsrOwogCQlwYWdlKys7CiAJCXJlZnMrKzsKQEAgLTE0OCw3ICsxNjMsMTggQEAKIAkJcG1kX3QgcG1kID0gKnBtZHA7CiAKIAkJbmV4dCA9IHBtZF9hZGRyX2VuZChhZGRyLCBlbmQpOwotCQlpZiAocG1kX25vbmUocG1kKSkKKwkJLyoKKwkJICogVGhlIHBtZF90cmFuc19zcGxpdHRpbmcoKSBjaGVjayBiZWxvdyBleHBsYWlucyB3aHkKKwkJICogcG1kcF9zcGxpdHRpbmdfZmx1c2ggaGFzIHRvIGZsdXNoIHRoZSB0bGIsIHRvIHN0b3AKKwkJICogdGhpcyBndXAtZmFzdCBjb2RlIGZyb20gcnVubmluZyB3aGlsZSB3ZSBzZXQgdGhlCisJCSAqIHNwbGl0dGluZyBiaXQgaW4gdGhlIHBtZC4gUmV0dXJuaW5nIHplcm8gd2lsbCB0YWtlCisJCSAqIHRoZSBzbG93IHBhdGggdGhhdCB3aWxsIGNhbGwgd2FpdF9zcGxpdF9odWdlX3BhZ2UoKQorCQkgKiBpZiB0aGUgcG1kIGlzIHN0aWxsIGluIHNwbGl0dGluZyBzdGF0ZS4gZ3VwLWZhc3QKKwkJICogY2FuJ3QgYmVjYXVzZSBpdCBoYXMgaXJxIGRpc2FibGVkIGFuZAorCQkgKiB3YWl0X3NwbGl0X2h1Z2VfcGFnZSgpIHdvdWxkIG5ldmVyIHJldHVybiBhcyB0aGUKKwkJICogdGxiIGZsdXNoIElQSSB3b3VsZG4ndCBydW4uCisJCSAqLworCQlpZiAocG1kX25vbmUocG1kKSB8fCBwbWRfdHJhbnNfc3BsaXR0aW5nKHBtZCkpCiAJCQlyZXR1cm4gMDsKIAkJaWYgKHVubGlrZWx5KHBtZF9sYXJnZShwbWQpKSkgewogCQkJaWYgKCFndXBfaHVnZV9wbWQocG1kLCBhZGRyLCBuZXh0LCB3cml0ZSwgcGFnZXMsIG5yKSkKZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL251bWEuYyBiL2FyY2gveDg2L21tL251bWEuYwppbmRleCA3ODdjNTJjLi5lYmY2ZDc4IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9tbS9udW1hLmMKKysrIGIvYXJjaC94ODYvbW0vbnVtYS5jCkBAIC0yLDYgKzIsMjggQEAKICNpbmNsdWRlIDxsaW51eC90b3BvbG9neS5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2Jvb3RtZW0uaD4KKyNpbmNsdWRlIDxhc20vbnVtYS5oPgorI2luY2x1ZGUgPGFzbS9hY3BpLmg+CisKK2ludCBfX2luaXRkYXRhIG51bWFfb2ZmOworCitzdGF0aWMgX19pbml0IGludCBudW1hX3NldHVwKGNoYXIgKm9wdCkKK3sKKwlpZiAoIW9wdCkKKwkJcmV0dXJuIC1FSU5WQUw7CisJaWYgKCFzdHJuY21wKG9wdCwgIm9mZiIsIDMpKQorCQludW1hX29mZiA9IDE7CisjaWZkZWYgQ09ORklHX05VTUFfRU1VCisJaWYgKCFzdHJuY21wKG9wdCwgImZha2U9IiwgNSkpCisJCW51bWFfZW11X2NtZGxpbmUob3B0ICsgNSk7CisjZW5kaWYKKyNpZmRlZiBDT05GSUdfQUNQSV9OVU1BCisJaWYgKCFzdHJuY21wKG9wdCwgIm5vYWNwaSIsIDYpKQorCQlhY3BpX251bWEgPSAtMTsKKyNlbmRpZgorCXJldHVybiAwOworfQorZWFybHlfcGFyYW0oIm51bWEiLCBudW1hX3NldHVwKTsKIAogLyoKICAqIFdoaWNoIGxvZ2ljYWwgQ1BVcyBhcmUgb24gd2hpY2ggbm9kZXMKZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL251bWFfNjQuYyBiL2FyY2gveDg2L21tL251bWFfNjQuYwppbmRleCAxZTcyMTAyLi45NWVhMTU1IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9tbS9udW1hXzY0LmMKKysrIGIvYXJjaC94ODYvbW0vbnVtYV82NC5jCkBAIC0zMCw3ICszMCw2IEBACiAJWzAgLi4uIE1BWF9MT0NBTF9BUElDLTFdID0gTlVNQV9OT19OT0RFCiB9OwogCi1pbnQgbnVtYV9vZmYgX19pbml0ZGF0YTsKIHN0YXRpYyB1bnNpZ25lZCBsb25nIF9faW5pdGRhdGEgbm9kZW1hcF9hZGRyOwogc3RhdGljIHVuc2lnbmVkIGxvbmcgX19pbml0ZGF0YSBub2RlbWFwX3NpemU7CiAKQEAgLTI2Myw2ICsyNjIsMTEgQEAKIHN0YXRpYyBzdHJ1Y3QgYm9vdG5vZGUgcGh5c25vZGVzW01BWF9OVU1OT0RFU10gX19jcHVpbml0ZGF0YTsKIHN0YXRpYyBjaGFyICpjbWRsaW5lIF9faW5pdGRhdGE7CiAKK3ZvaWQgX19pbml0IG51bWFfZW11X2NtZGxpbmUoY2hhciAqc3RyKQoreworCWNtZGxpbmUgPSBzdHI7Cit9CisKIHN0YXRpYyBpbnQgX19pbml0IHNldHVwX3BoeXNub2Rlcyh1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIGVuZCwKIAkJCQkJaW50IGFjcGksIGludCBhbWQpCiB7CkBAIC02NzAsMjQgKzY3NCw2IEBACiAJcmV0dXJuIHBhZ2VzOwogfQogCi1zdGF0aWMgX19pbml0IGludCBudW1hX3NldHVwKGNoYXIgKm9wdCkKLXsKLQlpZiAoIW9wdCkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0JaWYgKCFzdHJuY21wKG9wdCwgIm9mZiIsIDMpKQotCQludW1hX29mZiA9IDE7Ci0jaWZkZWYgQ09ORklHX05VTUFfRU1VCi0JaWYgKCFzdHJuY21wKG9wdCwgImZha2U9IiwgNSkpCi0JCWNtZGxpbmUgPSBvcHQgKyA1OwotI2VuZGlmCi0jaWZkZWYgQ09ORklHX0FDUElfTlVNQQotCWlmICghc3RybmNtcChvcHQsICJub2FjcGkiLCA2KSkKLQkJYWNwaV9udW1hID0gLTE7Ci0jZW5kaWYKLQlyZXR1cm4gMDsKLX0KLWVhcmx5X3BhcmFtKCJudW1hIiwgbnVtYV9zZXR1cCk7Ci0KICNpZmRlZiBDT05GSUdfTlVNQQogCiBzdGF0aWMgX19pbml0IGludCBmaW5kX25lYXJfb25saW5lX25vZGUoaW50IG5vZGUpCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9tbS9wYWdlYXR0ci5jIGIvYXJjaC94ODYvbW0vcGFnZWF0dHIuYwppbmRleCA4YjgzMGNhLi5kMzQzYjNjIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9tbS9wYWdlYXR0ci5jCisrKyBiL2FyY2gveDg2L21tL3BhZ2VhdHRyLmMKQEAgLTI1Niw3ICsyNTYsNiBAQAogCQkJCSAgIHVuc2lnbmVkIGxvbmcgcGZuKQogewogCXBncHJvdF90IGZvcmJpZGRlbiA9IF9fcGdwcm90KDApOwotCXBncHJvdF90IHJlcXVpcmVkID0gX19wZ3Byb3QoMCk7CiAKIAkvKgogCSAqIFRoZSBCSU9TIGFyZWEgYmV0d2VlbiA2NDBrIGFuZCAxTWIgbmVlZHMgdG8gYmUgZXhlY3V0YWJsZSBmb3IKQEAgLTI4MiwxMiArMjgxLDYgQEAKIAlpZiAod2l0aGluKHBmbiwgX19wYSgodW5zaWduZWQgbG9uZylfX3N0YXJ0X3JvZGF0YSkgPj4gUEFHRV9TSElGVCwKIAkJICAgX19wYSgodW5zaWduZWQgbG9uZylfX2VuZF9yb2RhdGEpID4+IFBBR0VfU0hJRlQpKQogCQlwZ3Byb3RfdmFsKGZvcmJpZGRlbikgfD0gX1BBR0VfUlc7Ci0JLyoKLQkgKiAuZGF0YSBhbmQgLmJzcyBzaG91bGQgYWx3YXlzIGJlIHdyaXRhYmxlLgotCSAqLwotCWlmICh3aXRoaW4oYWRkcmVzcywgKHVuc2lnbmVkIGxvbmcpX3NkYXRhLCAodW5zaWduZWQgbG9uZylfZWRhdGEpIHx8Ci0JICAgIHdpdGhpbihhZGRyZXNzLCAodW5zaWduZWQgbG9uZylfX2Jzc19zdGFydCwgKHVuc2lnbmVkIGxvbmcpX19ic3Nfc3RvcCkpCi0JCXBncHJvdF92YWwocmVxdWlyZWQpIHw9IF9QQUdFX1JXOwogCiAjaWYgZGVmaW5lZChDT05GSUdfWDg2XzY0KSAmJiBkZWZpbmVkKENPTkZJR19ERUJVR19ST0RBVEEpCiAJLyoKQEAgLTMyNyw3ICszMjAsNiBAQAogI2VuZGlmCiAKIAlwcm90ID0gX19wZ3Byb3QocGdwcm90X3ZhbChwcm90KSAmIH5wZ3Byb3RfdmFsKGZvcmJpZGRlbikpOwotCXByb3QgPSBfX3BncHJvdChwZ3Byb3RfdmFsKHByb3QpIHwgcGdwcm90X3ZhbChyZXF1aXJlZCkpOwogCiAJcmV0dXJuIHByb3Q7CiB9CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9tbS9wZ3RhYmxlLmMgYi9hcmNoL3g4Ni9tbS9wZ3RhYmxlLmMKaW5kZXggOGJlOGM3ZC4uNTAwMjQyZCAxMDA2NDQKLS0tIGEvYXJjaC94ODYvbW0vcGd0YWJsZS5jCisrKyBiL2FyY2gveDg2L21tL3BndGFibGUuYwpAQCAtMzIwLDYgKzMyMCwyNSBAQAogCXJldHVybiBjaGFuZ2VkOwogfQogCisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCitpbnQgcG1kcF9zZXRfYWNjZXNzX2ZsYWdzKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsIHBtZF90ICpwbWRwLAorCQkJICBwbWRfdCBlbnRyeSwgaW50IGRpcnR5KQoreworCWludCBjaGFuZ2VkID0gIXBtZF9zYW1lKCpwbWRwLCBlbnRyeSk7CisKKwlWTV9CVUdfT04oYWRkcmVzcyAmIH5IUEFHRV9QTURfTUFTSyk7CisKKwlpZiAoY2hhbmdlZCAmJiBkaXJ0eSkgeworCQkqcG1kcCA9IGVudHJ5OworCQlwbWRfdXBkYXRlX2RlZmVyKHZtYS0+dm1fbW0sIGFkZHJlc3MsIHBtZHApOworCQlmbHVzaF90bGJfcmFuZ2Uodm1hLCBhZGRyZXNzLCBhZGRyZXNzICsgSFBBR0VfUE1EX1NJWkUpOworCX0KKworCXJldHVybiBjaGFuZ2VkOworfQorI2VuZGlmCisKIGludCBwdGVwX3Rlc3RfYW5kX2NsZWFyX3lvdW5nKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAogCQkJICAgICAgdW5zaWduZWQgbG9uZyBhZGRyLCBwdGVfdCAqcHRlcCkKIHsKQEAgLTMzNSw2ICszNTQsMjMgQEAKIAlyZXR1cm4gcmV0OwogfQogCisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCitpbnQgcG1kcF90ZXN0X2FuZF9jbGVhcl95b3VuZyhzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgYWRkciwgcG1kX3QgKnBtZHApCit7CisJaW50IHJldCA9IDA7CisKKwlpZiAocG1kX3lvdW5nKCpwbWRwKSkKKwkJcmV0ID0gdGVzdF9hbmRfY2xlYXJfYml0KF9QQUdFX0JJVF9BQ0NFU1NFRCwKKwkJCQkJICh1bnNpZ25lZCBsb25nICopcG1kcCk7CisKKwlpZiAocmV0KQorCQlwbWRfdXBkYXRlKHZtYS0+dm1fbW0sIGFkZHIsIHBtZHApOworCisJcmV0dXJuIHJldDsKK30KKyNlbmRpZgorCiBpbnQgcHRlcF9jbGVhcl9mbHVzaF95b3VuZyhzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKIAkJCSAgIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywgcHRlX3QgKnB0ZXApCiB7CkBAIC0zNDcsNiArMzgzLDM2IEBACiAJcmV0dXJuIHlvdW5nOwogfQogCisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCitpbnQgcG1kcF9jbGVhcl9mbHVzaF95b3VuZyhzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCSAgIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywgcG1kX3QgKnBtZHApCit7CisJaW50IHlvdW5nOworCisJVk1fQlVHX09OKGFkZHJlc3MgJiB+SFBBR0VfUE1EX01BU0spOworCisJeW91bmcgPSBwbWRwX3Rlc3RfYW5kX2NsZWFyX3lvdW5nKHZtYSwgYWRkcmVzcywgcG1kcCk7CisJaWYgKHlvdW5nKQorCQlmbHVzaF90bGJfcmFuZ2Uodm1hLCBhZGRyZXNzLCBhZGRyZXNzICsgSFBBR0VfUE1EX1NJWkUpOworCisJcmV0dXJuIHlvdW5nOworfQorCit2b2lkIHBtZHBfc3BsaXR0aW5nX2ZsdXNoKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsIHBtZF90ICpwbWRwKQoreworCWludCBzZXQ7CisJVk1fQlVHX09OKGFkZHJlc3MgJiB+SFBBR0VfUE1EX01BU0spOworCXNldCA9ICF0ZXN0X2FuZF9zZXRfYml0KF9QQUdFX0JJVF9TUExJVFRJTkcsCisJCQkJKHVuc2lnbmVkIGxvbmcgKilwbWRwKTsKKwlpZiAoc2V0KSB7CisJCXBtZF91cGRhdGUodm1hLT52bV9tbSwgYWRkcmVzcywgcG1kcCk7CisJCS8qIG5lZWQgdGxiIGZsdXNoIG9ubHkgdG8gc2VyaWFsaXplIGFnYWluc3QgZ3VwLWZhc3QgKi8KKwkJZmx1c2hfdGxiX3JhbmdlKHZtYSwgYWRkcmVzcywgYWRkcmVzcyArIEhQQUdFX1BNRF9TSVpFKTsKKwl9Cit9CisjZW5kaWYKKwogLyoqCiAgKiByZXNlcnZlX3RvcF9hZGRyZXNzIC0gcmVzZXJ2ZXMgYSBob2xlIGluIHRoZSB0b3Agb2Yga2VybmVsIGFkZHJlc3Mgc3BhY2UKICAqIEByZXNlcnZlIC0gc2l6ZSBvZiBob2xlIHRvIHJlc2VydmUKZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL3NyYXRfMzIuYyBiL2FyY2gveDg2L21tL3NyYXRfMzIuYwppbmRleCBmMTY0MzQ1Li5hZTk2ZTdiOCAxMDA2NDQKLS0tIGEvYXJjaC94ODYvbW0vc3JhdF8zMi5jCisrKyBiL2FyY2gveDg2L21tL3NyYXRfMzIuYwpAQCAtNTksNyArNTksNiBAQAogc3RhdGljIGludCBfX2luaXRkYXRhIG51bV9tZW1vcnlfY2h1bmtzOyAvKiB0b3RhbCBudW1iZXIgb2YgbWVtb3J5IGNodW5rcyAqLwogc3RhdGljIHU4IF9faW5pdGRhdGEgYXBpY2lkX3RvX3B4bVtNQVhfQVBJQ0lEXTsKIAotaW50IG51bWFfb2ZmIF9faW5pdGRhdGE7CiBpbnQgYWNwaV9udW1hIF9faW5pdGRhdGE7CiAKIHN0YXRpYyBfX2luaXQgdm9pZCBiYWRfc3JhdCh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvcGNpL2Jyb2FkY29tX2J1cy5jIGIvYXJjaC94ODYvcGNpL2Jyb2FkY29tX2J1cy5jCmluZGV4IDA4NDZhNWIuLmFiODI2OWIgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L3BjaS9icm9hZGNvbV9idXMuYworKysgYi9hcmNoL3g4Ni9wY2kvYnJvYWRjb21fYnVzLmMKQEAgLTksNiArOSw3IEBACiAgKiBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgogICovCiAKKyNpbmNsdWRlIDxsaW51eC9hY3BpLmg+CiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KICNpbmNsdWRlIDxsaW51eC9kbWkuaD4KICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KQEAgLTI1LDEyICsyNiwxNCBAQAogCXU4IGZidXMsIGxidXM7CiAJaW50IGk7CiAKKyNpZmRlZiBDT05GSUdfQUNQSQogCS8qCi0JICogVGhlIHg4Nl9wY2lfcm9vdF9idXNfcmVzX3F1aXJrcygpIGZ1bmN0aW9uIGFscmVhZHkgcmVmdXNlcyB0byB1c2UKLQkgKiB0aGlzIGluZm9ybWF0aW9uIGlmIEFDUEkgX0NSUyB3YXMgdXNlZC4gVGhlcmVmb3JlLCB3ZSBkb24ndCBib3RoZXIKLQkgKiBjaGVja2luZyBpZiBBQ1BJIGlzIGVuYWJsZWQsIGFuZCBqdXN0IGdlbmVyYXRlIHRoZSBpbmZvcm1hdGlvbgotCSAqIGZvciBib3RoIHRoZSBBQ1BJIF9DUlMgYW5kIG5vIEFDUEkgY2FzZXMuCisJICogV2Ugc2hvdWxkIGdldCBob3N0IGJyaWRnZSBpbmZvcm1hdGlvbiBmcm9tIEFDUEkgdW5sZXNzIHRoZSBCSU9TCisJICogZG9lc24ndCBzdXBwb3J0IGl0LgogCSAqLworCWlmIChhY3BpX29zX2dldF9yb290X3BvaW50ZXIoKSkKKwkJcmV0dXJuOworI2VuZGlmCiAKIAlpbmZvID0gJnBjaV9yb290X2luZm9bcGNpX3Jvb3RfbnVtXTsKIAlwY2lfcm9vdF9udW0rKzsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L3BjaS9jb21tb24uYyBiL2FyY2gveDg2L3BjaS9jb21tb24uYwppbmRleCBmN2M4YTM5Li41ZmU3NTAyIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9wY2kvY29tbW9uLmMKKysrIGIvYXJjaC94ODYvcGNpL2NvbW1vbi5jCkBAIC0yMiw2ICsyMiw3IEBACiAKIHVuc2lnbmVkIGludCBwY2lfZWFybHlfZHVtcF9yZWdzOwogc3RhdGljIGludCBwY2lfYmZfc29ydDsKK3N0YXRpYyBpbnQgc21iaW9zX3R5cGVfYjFfZmxhZzsKIGludCBwY2lfcm91dGVpcnE7CiBpbnQgbm9pb2FwaWNxdWlyazsKICNpZmRlZiBDT05GSUdfWDg2X1JFUk9VVEVfRk9SX0JST0tFTl9CT09UX0lSUVMKQEAgLTE4NSw2ICsxODYsMzkgQEAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIHZvaWQgX19kZXZpbml0IHJlYWRfZG1pX3R5cGVfYjEoY29uc3Qgc3RydWN0IGRtaV9oZWFkZXIgKmRtLAorCQkJCSAgICAgICB2b2lkICpwcml2YXRlX2RhdGEpCit7CisJdTggKmQgPSAodTggKilkbSArIDQ7CisKKwlpZiAoZG0tPnR5cGUgIT0gMHhCMSkKKwkJcmV0dXJuOworCXN3aXRjaCAoKCgqKHUzMiAqKWQpID4+IDkpICYgMHgwMykgeworCWNhc2UgMHgwMDoKKwkJcHJpbnRrKEtFUk5fSU5GTyAiZG1pIHR5cGUgMHhCMSByZWNvcmQgLSB1bmtub3duIGZsYWdcbiIpOworCQlicmVhazsKKwljYXNlIDB4MDE6IC8qIHNldCBwY2k9YmZzb3J0ICovCisJCXNtYmlvc190eXBlX2IxX2ZsYWcgPSAxOworCQlicmVhazsKKwljYXNlIDB4MDI6IC8qIGRvIG5vdCBzZXQgcGNpPWJmc29ydCAqLworCQlzbWJpb3NfdHlwZV9iMV9mbGFnID0gMjsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYnJlYWs7CisJfQorfQorCitzdGF0aWMgaW50IF9fZGV2aW5pdCBmaW5kX3NvcnRfbWV0aG9kKGNvbnN0IHN0cnVjdCBkbWlfc3lzdGVtX2lkICpkKQoreworCWRtaV93YWxrKHJlYWRfZG1pX3R5cGVfYjEsIE5VTEwpOworCisJaWYgKHNtYmlvc190eXBlX2IxX2ZsYWcgPT0gMSkgeworCQlzZXRfYmZfc29ydChkKTsKKwkJcmV0dXJuIDA7CisJfQorCXJldHVybiAtMTsKK30KKwogLyoKICAqIEVuYWJsZSByZW51bWJlcmluZyBvZiBQQ0kgYnVzIyByYW5nZXMgdG8gcmVhY2ggYWxsIFBDSSBidXNzZXMgKENhcmRidXMpCiAgKi8KQEAgLTIxMyw2ICsyNDcsMTMgQEAKIAl9LAogI2VuZGlmCQkvKiBfX2kzODZfXyAqLwogCXsKKwkJLmNhbGxiYWNrID0gZmluZF9zb3J0X21ldGhvZCwKKwkJLmlkZW50ID0gIkRlbGwgU3lzdGVtIiwKKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJEZWxsIEluYyIpLAorCQl9LAorCX0sCisJewogCQkuY2FsbGJhY2sgPSBzZXRfYmZfc29ydCwKIAkJLmlkZW50ID0gIkRlbGwgUG93ZXJFZGdlIDE5NTAiLAogCQkubWF0Y2hlcyA9IHsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L3BjaS9pcnEuYyBiL2FyY2gveDg2L3BjaS9pcnEuYwppbmRleCA5ZjliZmI3Li44N2U2YzgzIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9wY2kvaXJxLmMKKysrIGIvYXJjaC94ODYvcGNpL2lycS5jCkBAIC01ODksNyArNTg5LDggQEAKIAljYXNlIFBDSV9ERVZJQ0VfSURfSU5URUxfSUNIMTBfMToKIAljYXNlIFBDSV9ERVZJQ0VfSURfSU5URUxfSUNIMTBfMjoKIAljYXNlIFBDSV9ERVZJQ0VfSURfSU5URUxfSUNIMTBfMzoKLQljYXNlIFBDSV9ERVZJQ0VfSURfSU5URUxfUEFUU0JVUkdfTFBDOgorCWNhc2UgUENJX0RFVklDRV9JRF9JTlRFTF9QQVRTQlVSR19MUENfMDoKKwljYXNlIFBDSV9ERVZJQ0VfSURfSU5URUxfUEFUU0JVUkdfTFBDXzE6CiAJCXItPm5hbWUgPSAiUElJWC9JQ0giOwogCQlyLT5nZXQgPSBwaXJxX3BpaXhfZ2V0OwogCQlyLT5zZXQgPSBwaXJxX3BpaXhfc2V0OwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvcGxhdGZvcm0vb2xwYy9vbHBjLXhvMS5jIGIvYXJjaC94ODYvcGxhdGZvcm0vb2xwYy9vbHBjLXhvMS5jCmluZGV4IGY1NDQyYzAuLjEyNzc3NTYgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L3BsYXRmb3JtL29scGMvb2xwYy14bzEuYworKysgYi9hcmNoL3g4Ni9wbGF0Zm9ybS9vbHBjL29scGMteG8xLmMKQEAgLTEsNiArMSw3IEBACiAvKgogICogU3VwcG9ydCBmb3IgZmVhdHVyZXMgb2YgdGhlIE9MUEMgWE8tMSBsYXB0b3AKICAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgQW5kcmVzIFNhbG9tb24gPGRpbGluZ2VyQHF1ZXVlZC5uZXQ+CiAgKiBDb3B5cmlnaHQgKEMpIDIwMTAgT25lIExhcHRvcCBwZXIgQ2hpbGQKICAqIENvcHlyaWdodCAoQykgMjAwNiBSZWQgSGF0LCBJbmMuCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQWR2YW5jZWQgTWljcm8gRGV2aWNlcywgSW5jLgpAQCAtMTIsOCArMTMsNiBAQAogICovCiAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KLSNpbmNsdWRlIDxsaW51eC9wY2kuaD4KLSNpbmNsdWRlIDxsaW51eC9wY2lfaWRzLmg+CiAjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvcG0uaD4KIApAQCAtMjIsOSArMjEsNiBAQAogCiAjZGVmaW5lIERSVl9OQU1FICJvbHBjLXhvMSIKIAotI2RlZmluZSBQTVNfQkFSCQk0Ci0jZGVmaW5lIEFDUElfQkFSCTUKLQogLyogUE1DIHJlZ2lzdGVycyAoUE1TIGJsb2NrKSAqLwogI2RlZmluZSBQTV9TQ0xLCQkweDEwCiAjZGVmaW5lIFBNX0lOX1NMUENUTAkweDIwCkBAIC01Nyw2NSArNTMsNjcgQEAKIAlvdXRsKDB4MDAwMDIwMDAsIGFjcGlfYmFzZSArIFBNMV9DTlQpOwogfQogCi0vKiBSZWFkIHRoZSBiYXNlIGFkZHJlc3NlcyBmcm9tIHRoZSBQQ0kgQkFSIGluZm8gKi8KLXN0YXRpYyBpbnQgX19kZXZpbml0IHNldHVwX2Jhc2VzKHN0cnVjdCBwY2lfZGV2ICpwZGV2KQotewotCWludCByOwotCi0JciA9IHBjaV9lbmFibGVfZGV2aWNlX2lvKHBkZXYpOwotCWlmIChyKSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgImNhbid0IGVuYWJsZSBkZXZpY2UgSU9cbiIpOwotCQlyZXR1cm4gcjsKLQl9Ci0KLQlyID0gcGNpX3JlcXVlc3RfcmVnaW9uKHBkZXYsIEFDUElfQkFSLCBEUlZfTkFNRSk7Ci0JaWYgKHIpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAiY2FuJ3QgYWxsb2MgUENJIEJBUiAjJWRcbiIsIEFDUElfQkFSKTsKLQkJcmV0dXJuIHI7Ci0JfQotCi0JciA9IHBjaV9yZXF1ZXN0X3JlZ2lvbihwZGV2LCBQTVNfQkFSLCBEUlZfTkFNRSk7Ci0JaWYgKHIpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAiY2FuJ3QgYWxsb2MgUENJIEJBUiAjJWRcbiIsIFBNU19CQVIpOwotCQlwY2lfcmVsZWFzZV9yZWdpb24ocGRldiwgQUNQSV9CQVIpOwotCQlyZXR1cm4gcjsKLQl9Ci0KLQlhY3BpX2Jhc2UgPSBwY2lfcmVzb3VyY2Vfc3RhcnQocGRldiwgQUNQSV9CQVIpOwotCXBtc19iYXNlID0gcGNpX3Jlc291cmNlX3N0YXJ0KHBkZXYsIFBNU19CQVIpOwotCi0JcmV0dXJuIDA7Ci19Ci0KIHN0YXRpYyBpbnQgX19kZXZpbml0IG9scGNfeG8xX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiB7Ci0Jc3RydWN0IHBjaV9kZXYgKnBjaWRldjsKLQlpbnQgcjsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKIAotCXBjaWRldiA9IHBjaV9nZXRfZGV2aWNlKFBDSV9WRU5ET1JfSURfQU1ELCBQQ0lfREVWSUNFX0lEX0FNRF9DUzU1MzZfSVNBLAotCQkJCU5VTEwpOwotCWlmICghcGRldikKKwkvKiBkb24ndCBydW4gb24gbm9uLVhPcyAqLworCWlmICghbWFjaGluZV9pc19vbHBjKCkpCiAJCXJldHVybiAtRU5PREVWOwogCi0JciA9IHNldHVwX2Jhc2VzKHBjaWRldik7Ci0JaWYgKHIpCi0JCXJldHVybiByOworCXJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNFX0lPLCAwKTsKKwlpZiAoIXJlcykgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW4ndCBmZXRjaCBkZXZpY2UgcmVzb3VyY2UgaW5mb1xuIik7CisJCXJldHVybiAtRUlPOworCX0KIAotCXBtX3Bvd2VyX29mZiA9IHhvMV9wb3dlcl9vZmY7CisJaWYgKCFyZXF1ZXN0X3JlZ2lvbihyZXMtPnN0YXJ0LCByZXNvdXJjZV9zaXplKHJlcyksIERSVl9OQU1FKSkgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW4ndCByZXF1ZXN0IHJlZ2lvblxuIik7CisJCXJldHVybiAtRUlPOworCX0KIAotCXByaW50ayhLRVJOX0lORk8gIk9MUEMgWE8tMSBzdXBwb3J0IHJlZ2lzdGVyZWRcbiIpOworCWlmIChzdHJjbXAocGRldi0+bmFtZSwgImNzNTUzNS1wbXMiKSA9PSAwKQorCQlwbXNfYmFzZSA9IHJlcy0+c3RhcnQ7CisJZWxzZSBpZiAoc3RyY21wKHBkZXYtPm5hbWUsICJjczU1MzUtYWNwaSIpID09IDApCisJCWFjcGlfYmFzZSA9IHJlcy0+c3RhcnQ7CisKKwkvKiBJZiB3ZSBoYXZlIGJvdGggYWRkcmVzc2VzLCB3ZSBjYW4gb3ZlcnJpZGUgdGhlIHBvd2Vyb2ZmIGhvb2sgKi8KKwlpZiAocG1zX2Jhc2UgJiYgYWNwaV9iYXNlKSB7CisJCXBtX3Bvd2VyX29mZiA9IHhvMV9wb3dlcl9vZmY7CisJCXByaW50ayhLRVJOX0lORk8gIk9MUEMgWE8tMSBzdXBwb3J0IHJlZ2lzdGVyZWRcbiIpOworCX0KKwogCXJldHVybiAwOwogfQogCiBzdGF0aWMgaW50IF9fZGV2ZXhpdCBvbHBjX3hvMV9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIHsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnI7CisKKwlyID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfSU8sIDApOworCXJlbGVhc2VfcmVnaW9uKHItPnN0YXJ0LCByZXNvdXJjZV9zaXplKHIpKTsKKworCWlmIChzdHJjbXAocGRldi0+bmFtZSwgImNzNTUzNS1wbXMiKSA9PSAwKQorCQlwbXNfYmFzZSA9IDA7CisJZWxzZSBpZiAoc3RyY21wKHBkZXYtPm5hbWUsICJjczU1MzUtYWNwaSIpID09IDApCisJCWFjcGlfYmFzZSA9IDA7CisKIAlwbV9wb3dlcl9vZmYgPSBOVUxMOwogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBvbHBjX3hvMV9kcml2ZXIgPSB7CitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBjczU1MzVfcG1zX2RydiA9IHsKIAkuZHJpdmVyID0gewotCQkubmFtZSA9IERSVl9OQU1FLAorCQkubmFtZSA9ICJjczU1MzUtcG1zIiwKKwkJLm93bmVyID0gVEhJU19NT0RVTEUsCisJfSwKKwkucHJvYmUgPSBvbHBjX3hvMV9wcm9iZSwKKwkucmVtb3ZlID0gX19kZXZleGl0X3Aob2xwY194bzFfcmVtb3ZlKSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGNzNTUzNV9hY3BpX2RydiA9IHsKKwkuZHJpdmVyID0geworCQkubmFtZSA9ICJjczU1MzUtYWNwaSIsCiAJCS5vd25lciA9IFRISVNfTU9EVUxFLAogCX0sCiAJLnByb2JlID0gb2xwY194bzFfcHJvYmUsCkBAIC0xMjQsMTIgKzEyMiwyMyBAQAogCiBzdGF0aWMgaW50IF9faW5pdCBvbHBjX3hvMV9pbml0KHZvaWQpCiB7Ci0JcmV0dXJuIHBsYXRmb3JtX2RyaXZlcl9yZWdpc3Rlcigmb2xwY194bzFfZHJpdmVyKTsKKwlpbnQgcjsKKworCXIgPSBwbGF0Zm9ybV9kcml2ZXJfcmVnaXN0ZXIoJmNzNTUzNV9wbXNfZHJ2KTsKKwlpZiAocikKKwkJcmV0dXJuIHI7CisKKwlyID0gcGxhdGZvcm1fZHJpdmVyX3JlZ2lzdGVyKCZjczU1MzVfYWNwaV9kcnYpOworCWlmIChyKQorCQlwbGF0Zm9ybV9kcml2ZXJfdW5yZWdpc3RlcigmY3M1NTM1X3Btc19kcnYpOworCisJcmV0dXJuIHI7CiB9CiAKIHN0YXRpYyB2b2lkIF9fZXhpdCBvbHBjX3hvMV9leGl0KHZvaWQpCiB7Ci0JcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIoJm9scGNfeG8xX2RyaXZlcik7CisJcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIoJmNzNTUzNV9hY3BpX2Rydik7CisJcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIoJmNzNTUzNV9wbXNfZHJ2KTsKIH0KIAogTU9EVUxFX0FVVEhPUigiRGFuaWVsIERyYWtlIDxkc2RAbGFwdG9wLm9yZz4iKTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L3hlbi9NYWtlZmlsZSBiL2FyY2gveDg2L3hlbi9NYWtlZmlsZQppbmRleCA3NzkzODUxLi4xN2M1NjVkIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni94ZW4vTWFrZWZpbGUKKysrIGIvYXJjaC94ODYveGVuL01ha2VmaWxlCkBAIC0xMiw3ICsxMiw4IEBACiAKIG9iai15CQk6PSBlbmxpZ2h0ZW4ubyBzZXR1cC5vIG11bHRpY2FsbHMubyBtbXUubyBpcnEubyBcCiAJCQl0aW1lLm8geGVuLWFzbS5vIHhlbi1hc21fJChCSVRTKS5vIFwKLQkJCWdyYW50LXRhYmxlLm8gc3VzcGVuZC5vIHBsYXRmb3JtLXBjaS11bnBsdWcubworCQkJZ3JhbnQtdGFibGUubyBzdXNwZW5kLm8gcGxhdGZvcm0tcGNpLXVucGx1Zy5vIFwKKwkJCXAybS5vCiAKIG9iai0kKENPTkZJR19TTVApCQkrPSBzbXAubwogb2JqLSQoQ09ORklHX1BBUkFWSVJUX1NQSU5MT0NLUykrPSBzcGlubG9jay5vCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni94ZW4vZW5saWdodGVuLmMgYi9hcmNoL3g4Ni94ZW4vZW5saWdodGVuLmMKaW5kZXggN2U4ZDNiYy4uNTA1NDJlZiAxMDA2NDQKLS0tIGEvYXJjaC94ODYveGVuL2VubGlnaHRlbi5jCisrKyBiL2FyY2gveDg2L3hlbi9lbmxpZ2h0ZW4uYwpAQCAtMTE5NCw3ICsxMTk0LDcgQEAKIAlwZXJfY3B1KHhlbl92Y3B1LCAwKSA9ICZIWVBFUlZJU09SX3NoYXJlZF9pbmZvLT52Y3B1X2luZm9bMF07CiAKIAlsb2NhbF9pcnFfZGlzYWJsZSgpOwotCWVhcmx5X2Jvb3RfaXJxc19vZmYoKTsKKwllYXJseV9ib290X2lycXNfZGlzYWJsZWQgPSB0cnVlOwogCiAJbWVtYmxvY2tfaW5pdCgpOwogCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni94ZW4vaXJxLmMgYi9hcmNoL3g4Ni94ZW4vaXJxLmMKaW5kZXggOWQzMDEwNS4uNmE2ZmU4OSAxMDA2NDQKLS0tIGEvYXJjaC94ODYveGVuL2lycS5jCisrKyBiL2FyY2gveDg2L3hlbi9pcnEuYwpAQCAtMTI2LDcgKzEyNiw3IEBACiAjZW5kaWYKIH07CiAKLXZvaWQgX19pbml0IHhlbl9pbml0X2lycV9vcHMoKQordm9pZCBfX2luaXQgeGVuX2luaXRfaXJxX29wcyh2b2lkKQogewogCXB2X2lycV9vcHMgPSB4ZW5faXJxX29wczsKIAl4ODZfaW5pdC5pcnFzLmludHJfaW5pdCA9IHhlbl9pbml0X0lSUTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L3hlbi9tbXUuYyBiL2FyY2gveDg2L3hlbi9tbXUuYwppbmRleCA0NDkyNGU1Li41ZTkyYjYxIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni94ZW4vbW11LmMKKysrIGIvYXJjaC94ODYveGVuL21tdS5jCkBAIC0xNzMsMzcxICsxNzMsNiBAQAogICovCiAjZGVmaW5lIFVTRVJfTElNSVQJKChTVEFDS19UT1BfTUFYICsgUEdESVJfU0laRSAtIDEpICYgUEdESVJfTUFTSykKIAotLyoKLSAqIFhlbiBsZWF2ZXMgdGhlIHJlc3BvbnNpYmlsaXR5IGZvciBtYWludGFpbmluZyBwMm0gbWFwcGluZ3MgdG8gdGhlCi0gKiBndWVzdHMgdGhlbXNlbHZlcywgYnV0IGl0IG11c3QgYWxzbyBhY2Nlc3MgYW5kIHVwZGF0ZSB0aGUgcDJtIGFycmF5Ci0gKiBkdXJpbmcgc3VzcGVuZC9yZXN1bWUgd2hlbiBhbGwgdGhlIHBhZ2VzIGFyZSByZWFsbG9jYXRlZC4KLSAqCi0gKiBUaGUgcDJtIHRhYmxlIGlzIGxvZ2ljYWxseSBhIGZsYXQgYXJyYXksIGJ1dCB3ZSBpbXBsZW1lbnQgaXQgYXMgYQotICogdGhyZWUtbGV2ZWwgdHJlZSB0byBhbGxvdyB0aGUgYWRkcmVzcyBzcGFjZSB0byBiZSBzcGFyc2UuCi0gKgotICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgWGVuCi0gKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotICogICAgIHAybV90b3AgICAgICAgICAgICAgIHAybV90b3BfbWZuCi0gKiAgICAgICAvICBcICAgICAgICAgICAgICAgICAgIC8gICBcCi0gKiBwMm1fbWlkIHAybV9taWQJcDJtX21pZF9tZm4gcDJtX21pZF9tZm4KLSAqICAgIC8gXCAgICAgIC8gXCAgICAgICAgIC8gICAgICAgICAgIC8KLSAqICBwMm0gcDJtIHAybSBwMm0gcDJtIHAybSBwMm0gLi4uCi0gKgotICogVGhlIHAybV9taWRfbWZuIHBhZ2VzIGFyZSBtYXBwZWQgYnkgcDJtX3RvcF9tZm5fcC4KLSAqCi0gKiBUaGUgcDJtX3RvcCBhbmQgcDJtX3RvcF9tZm4gbGV2ZWxzIGFyZSBsaW1pdGVkIHRvIDEgcGFnZSwgc28gdGhlCi0gKiBtYXhpbXVtIHJlcHJlc2VudGFibGUgcHNldWRvLXBoeXNpY2FsIGFkZHJlc3Mgc3BhY2UgaXM6Ci0gKiAgUDJNX1RPUF9QRVJfUEFHRSAqIFAyTV9NSURfUEVSX1BBR0UgKiBQMk1fUEVSX1BBR0UgcGFnZXMKLSAqCi0gKiBQMk1fUEVSX1BBR0UgZGVwZW5kcyBvbiB0aGUgYXJjaGl0ZWN0dXJlLCBhcyBhIG1mbiBpcyBhbHdheXMKLSAqIHVuc2lnbmVkIGxvbmcgKDggYnl0ZXMgb24gNjQtYml0LCA0IGJ5dGVzIG9uIDMyKSwgbGVhZGluZyB0bwotICogNTEyIGFuZCAxMDI0IGVudHJpZXMgcmVzcGVjdGl2ZWx5LiAKLSAqLwotCi11bnNpZ25lZCBsb25nIHhlbl9tYXhfcDJtX3BmbiBfX3JlYWRfbW9zdGx5OwotCi0jZGVmaW5lIFAyTV9QRVJfUEFHRQkJKFBBR0VfU0laRSAvIHNpemVvZih1bnNpZ25lZCBsb25nKSkKLSNkZWZpbmUgUDJNX01JRF9QRVJfUEFHRQkoUEFHRV9TSVpFIC8gc2l6ZW9mKHVuc2lnbmVkIGxvbmcgKikpCi0jZGVmaW5lIFAyTV9UT1BfUEVSX1BBR0UJKFBBR0VfU0laRSAvIHNpemVvZih1bnNpZ25lZCBsb25nICoqKSkKLQotI2RlZmluZSBNQVhfUDJNX1BGTgkJKFAyTV9UT1BfUEVSX1BBR0UgKiBQMk1fTUlEX1BFUl9QQUdFICogUDJNX1BFUl9QQUdFKQotCi0vKiBQbGFjZWhvbGRlcnMgZm9yIGhvbGVzIGluIHRoZSBhZGRyZXNzIHNwYWNlICovCi1zdGF0aWMgUkVTRVJWRV9CUktfQVJSQVkodW5zaWduZWQgbG9uZywgcDJtX21pc3NpbmcsIFAyTV9QRVJfUEFHRSk7Ci1zdGF0aWMgUkVTRVJWRV9CUktfQVJSQVkodW5zaWduZWQgbG9uZyAqLCBwMm1fbWlkX21pc3NpbmcsIFAyTV9NSURfUEVSX1BBR0UpOwotc3RhdGljIFJFU0VSVkVfQlJLX0FSUkFZKHVuc2lnbmVkIGxvbmcsIHAybV9taWRfbWlzc2luZ19tZm4sIFAyTV9NSURfUEVSX1BBR0UpOwotCi1zdGF0aWMgUkVTRVJWRV9CUktfQVJSQVkodW5zaWduZWQgbG9uZyAqKiwgcDJtX3RvcCwgUDJNX1RPUF9QRVJfUEFHRSk7Ci1zdGF0aWMgUkVTRVJWRV9CUktfQVJSQVkodW5zaWduZWQgbG9uZywgcDJtX3RvcF9tZm4sIFAyTV9UT1BfUEVSX1BBR0UpOwotc3RhdGljIFJFU0VSVkVfQlJLX0FSUkFZKHVuc2lnbmVkIGxvbmcgKiwgcDJtX3RvcF9tZm5fcCwgUDJNX1RPUF9QRVJfUEFHRSk7Ci0KLVJFU0VSVkVfQlJLKHAybV9taWQsIFBBR0VfU0laRSAqIChNQVhfRE9NQUlOX1BBR0VTIC8gKFAyTV9QRVJfUEFHRSAqIFAyTV9NSURfUEVSX1BBR0UpKSk7Ci1SRVNFUlZFX0JSSyhwMm1fbWlkX21mbiwgUEFHRV9TSVpFICogKE1BWF9ET01BSU5fUEFHRVMgLyAoUDJNX1BFUl9QQUdFICogUDJNX01JRF9QRVJfUEFHRSkpKTsKLQotc3RhdGljIGlubGluZSB1bnNpZ25lZCBwMm1fdG9wX2luZGV4KHVuc2lnbmVkIGxvbmcgcGZuKQotewotCUJVR19PTihwZm4gPj0gTUFYX1AyTV9QRk4pOwotCXJldHVybiBwZm4gLyAoUDJNX01JRF9QRVJfUEFHRSAqIFAyTV9QRVJfUEFHRSk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdW5zaWduZWQgcDJtX21pZF9pbmRleCh1bnNpZ25lZCBsb25nIHBmbikKLXsKLQlyZXR1cm4gKHBmbiAvIFAyTV9QRVJfUEFHRSkgJSBQMk1fTUlEX1BFUl9QQUdFOwotfQotCi1zdGF0aWMgaW5saW5lIHVuc2lnbmVkIHAybV9pbmRleCh1bnNpZ25lZCBsb25nIHBmbikKLXsKLQlyZXR1cm4gcGZuICUgUDJNX1BFUl9QQUdFOwotfQotCi1zdGF0aWMgdm9pZCBwMm1fdG9wX2luaXQodW5zaWduZWQgbG9uZyAqKip0b3ApCi17Ci0JdW5zaWduZWQgaTsKLQotCWZvciAoaSA9IDA7IGkgPCBQMk1fVE9QX1BFUl9QQUdFOyBpKyspCi0JCXRvcFtpXSA9IHAybV9taWRfbWlzc2luZzsKLX0KLQotc3RhdGljIHZvaWQgcDJtX3RvcF9tZm5faW5pdCh1bnNpZ25lZCBsb25nICp0b3ApCi17Ci0JdW5zaWduZWQgaTsKLQotCWZvciAoaSA9IDA7IGkgPCBQMk1fVE9QX1BFUl9QQUdFOyBpKyspCi0JCXRvcFtpXSA9IHZpcnRfdG9fbWZuKHAybV9taWRfbWlzc2luZ19tZm4pOwotfQotCi1zdGF0aWMgdm9pZCBwMm1fdG9wX21mbl9wX2luaXQodW5zaWduZWQgbG9uZyAqKnRvcCkKLXsKLQl1bnNpZ25lZCBpOwotCi0JZm9yIChpID0gMDsgaSA8IFAyTV9UT1BfUEVSX1BBR0U7IGkrKykKLQkJdG9wW2ldID0gcDJtX21pZF9taXNzaW5nX21mbjsKLX0KLQotc3RhdGljIHZvaWQgcDJtX21pZF9pbml0KHVuc2lnbmVkIGxvbmcgKiptaWQpCi17Ci0JdW5zaWduZWQgaTsKLQotCWZvciAoaSA9IDA7IGkgPCBQMk1fTUlEX1BFUl9QQUdFOyBpKyspCi0JCW1pZFtpXSA9IHAybV9taXNzaW5nOwotfQotCi1zdGF0aWMgdm9pZCBwMm1fbWlkX21mbl9pbml0KHVuc2lnbmVkIGxvbmcgKm1pZCkKLXsKLQl1bnNpZ25lZCBpOwotCi0JZm9yIChpID0gMDsgaSA8IFAyTV9NSURfUEVSX1BBR0U7IGkrKykKLQkJbWlkW2ldID0gdmlydF90b19tZm4ocDJtX21pc3NpbmcpOwotfQotCi1zdGF0aWMgdm9pZCBwMm1faW5pdCh1bnNpZ25lZCBsb25nICpwMm0pCi17Ci0JdW5zaWduZWQgaTsKLQotCWZvciAoaSA9IDA7IGkgPCBQMk1fTUlEX1BFUl9QQUdFOyBpKyspCi0JCXAybVtpXSA9IElOVkFMSURfUDJNX0VOVFJZOwotfQotCi0vKgotICogQnVpbGQgdGhlIHBhcmFsbGVsIHAybV90b3BfbWZuIGFuZCBwMm1fbWlkX21mbiBzdHJ1Y3R1cmVzCi0gKgotICogVGhpcyBpcyBjYWxsZWQgYm90aCBhdCBib290IHRpbWUsIGFuZCBhZnRlciByZXN1bWluZyBmcm9tIHN1c3BlbmQ6Ci0gKiAtIEF0IGJvb3QgdGltZSB3ZSdyZSBjYWxsZWQgdmVyeSBlYXJseSwgYW5kIG11c3QgdXNlIGV4dGVuZF9icmsoKQotICogICB0byBhbGxvY2F0ZSBtZW1vcnkuCi0gKgotICogLSBBZnRlciByZXN1bWUgd2UncmUgY2FsbGVkIGZyb20gd2l0aGluIHN0b3BfbWFjaGluZSwgYnV0IHRoZSBtZm4KLSAqICAgdHJlZSBzaG91bGQgYWxyZWF5IGJlIGNvbXBsZXRlbHkgYWxsb2NhdGVkLgotICovCi12b2lkIHhlbl9idWlsZF9tZm5fbGlzdF9saXN0KHZvaWQpCi17Ci0JdW5zaWduZWQgbG9uZyBwZm47Ci0KLQkvKiBQcmUtaW5pdGlhbGl6ZSBwMm1fdG9wX21mbiB0byBiZSBjb21wbGV0ZWx5IG1pc3NpbmcgKi8KLQlpZiAocDJtX3RvcF9tZm4gPT0gTlVMTCkgewotCQlwMm1fbWlkX21pc3NpbmdfbWZuID0gZXh0ZW5kX2JyayhQQUdFX1NJWkUsIFBBR0VfU0laRSk7Ci0JCXAybV9taWRfbWZuX2luaXQocDJtX21pZF9taXNzaW5nX21mbik7Ci0KLQkJcDJtX3RvcF9tZm5fcCA9IGV4dGVuZF9icmsoUEFHRV9TSVpFLCBQQUdFX1NJWkUpOwotCQlwMm1fdG9wX21mbl9wX2luaXQocDJtX3RvcF9tZm5fcCk7Ci0KLQkJcDJtX3RvcF9tZm4gPSBleHRlbmRfYnJrKFBBR0VfU0laRSwgUEFHRV9TSVpFKTsKLQkJcDJtX3RvcF9tZm5faW5pdChwMm1fdG9wX21mbik7Ci0JfSBlbHNlIHsKLQkJLyogUmVpbml0aWFsaXNlLCBtZm4ncyBhbGwgY2hhbmdlIGFmdGVyIG1pZ3JhdGlvbiAqLwotCQlwMm1fbWlkX21mbl9pbml0KHAybV9taWRfbWlzc2luZ19tZm4pOwotCX0KLQotCWZvciAocGZuID0gMDsgcGZuIDwgeGVuX21heF9wMm1fcGZuOyBwZm4gKz0gUDJNX1BFUl9QQUdFKSB7Ci0JCXVuc2lnbmVkIHRvcGlkeCA9IHAybV90b3BfaW5kZXgocGZuKTsKLQkJdW5zaWduZWQgbWlkaWR4ID0gcDJtX21pZF9pbmRleChwZm4pOwotCQl1bnNpZ25lZCBsb25nICoqbWlkOwotCQl1bnNpZ25lZCBsb25nICptaWRfbWZuX3A7Ci0KLQkJbWlkID0gcDJtX3RvcFt0b3BpZHhdOwotCQltaWRfbWZuX3AgPSBwMm1fdG9wX21mbl9wW3RvcGlkeF07Ci0KLQkJLyogRG9uJ3QgYm90aGVyIGFsbG9jYXRpbmcgYW55IG1mbiBtaWQgbGV2ZWxzIGlmCi0JCSAqIHRoZXkncmUganVzdCBtaXNzaW5nLCBqdXN0IHVwZGF0ZSB0aGUgc3RvcmVkIG1mbiwKLQkJICogc2luY2UgYWxsIGNvdWxkIGhhdmUgY2hhbmdlZCBvdmVyIGEgbWlncmF0ZS4KLQkJICovCi0JCWlmIChtaWQgPT0gcDJtX21pZF9taXNzaW5nKSB7Ci0JCQlCVUdfT04obWlkaWR4KTsKLQkJCUJVR19PTihtaWRfbWZuX3AgIT0gcDJtX21pZF9taXNzaW5nX21mbik7Ci0JCQlwMm1fdG9wX21mblt0b3BpZHhdID0gdmlydF90b19tZm4ocDJtX21pZF9taXNzaW5nX21mbik7Ci0JCQlwZm4gKz0gKFAyTV9NSURfUEVSX1BBR0UgLSAxKSAqIFAyTV9QRVJfUEFHRTsKLQkJCWNvbnRpbnVlOwotCQl9Ci0KLQkJaWYgKG1pZF9tZm5fcCA9PSBwMm1fbWlkX21pc3NpbmdfbWZuKSB7Ci0JCQkvKgotCQkJICogWFhYIGJvb3QtdGltZSBvbmx5ISAgV2Ugc2hvdWxkIG5ldmVyIGZpbmQKLQkJCSAqIG1pc3NpbmcgcGFydHMgb2YgdGhlIG1mbiB0cmVlIGFmdGVyCi0JCQkgKiBydW50aW1lLiAgZXh0ZW5kX2JyaygpIHdpbGwgQlVHIGlmIHdlIGNhbGwKLQkJCSAqIGl0IHRvbyBsYXRlLgotCQkJICovCi0JCQltaWRfbWZuX3AgPSBleHRlbmRfYnJrKFBBR0VfU0laRSwgUEFHRV9TSVpFKTsKLQkJCXAybV9taWRfbWZuX2luaXQobWlkX21mbl9wKTsKLQotCQkJcDJtX3RvcF9tZm5fcFt0b3BpZHhdID0gbWlkX21mbl9wOwotCQl9Ci0KLQkJcDJtX3RvcF9tZm5bdG9waWR4XSA9IHZpcnRfdG9fbWZuKG1pZF9tZm5fcCk7Ci0JCW1pZF9tZm5fcFttaWRpZHhdID0gdmlydF90b19tZm4obWlkW21pZGlkeF0pOwotCX0KLX0KLQotdm9pZCB4ZW5fc2V0dXBfbWZuX2xpc3RfbGlzdCh2b2lkKQotewotCUJVR19PTihIWVBFUlZJU09SX3NoYXJlZF9pbmZvID09ICZ4ZW5fZHVtbXlfc2hhcmVkX2luZm8pOwotCi0JSFlQRVJWSVNPUl9zaGFyZWRfaW5mby0+YXJjaC5wZm5fdG9fbWZuX2ZyYW1lX2xpc3RfbGlzdCA9Ci0JCXZpcnRfdG9fbWZuKHAybV90b3BfbWZuKTsKLQlIWVBFUlZJU09SX3NoYXJlZF9pbmZvLT5hcmNoLm1heF9wZm4gPSB4ZW5fbWF4X3AybV9wZm47Ci19Ci0KLS8qIFNldCB1cCBwMm1fdG9wIHRvIHBvaW50IHRvIHRoZSBkb21haW4tYnVpbGRlciBwcm92aWRlZCBwMm0gcGFnZXMgKi8KLXZvaWQgX19pbml0IHhlbl9idWlsZF9keW5hbWljX3BoeXNfdG9fbWFjaGluZSh2b2lkKQotewotCXVuc2lnbmVkIGxvbmcgKm1mbl9saXN0ID0gKHVuc2lnbmVkIGxvbmcgKil4ZW5fc3RhcnRfaW5mby0+bWZuX2xpc3Q7Ci0JdW5zaWduZWQgbG9uZyBtYXhfcGZuID0gbWluKE1BWF9ET01BSU5fUEFHRVMsIHhlbl9zdGFydF9pbmZvLT5ucl9wYWdlcyk7Ci0JdW5zaWduZWQgbG9uZyBwZm47Ci0KLQl4ZW5fbWF4X3AybV9wZm4gPSBtYXhfcGZuOwotCi0JcDJtX21pc3NpbmcgPSBleHRlbmRfYnJrKFBBR0VfU0laRSwgUEFHRV9TSVpFKTsKLQlwMm1faW5pdChwMm1fbWlzc2luZyk7Ci0KLQlwMm1fbWlkX21pc3NpbmcgPSBleHRlbmRfYnJrKFBBR0VfU0laRSwgUEFHRV9TSVpFKTsKLQlwMm1fbWlkX2luaXQocDJtX21pZF9taXNzaW5nKTsKLQotCXAybV90b3AgPSBleHRlbmRfYnJrKFBBR0VfU0laRSwgUEFHRV9TSVpFKTsKLQlwMm1fdG9wX2luaXQocDJtX3RvcCk7Ci0KLQkvKgotCSAqIFRoZSBkb21haW4gYnVpbGRlciBnaXZlcyB1cyBhIHByZS1jb25zdHJ1Y3RlZCBwMm0gYXJyYXkgaW4KLQkgKiBtZm5fbGlzdCBmb3IgYWxsIHRoZSBwYWdlcyBpbml0aWFsbHkgZ2l2ZW4gdG8gdXMsIHNvIHdlIGp1c3QKLQkgKiBuZWVkIHRvIGdyYWZ0IHRoYXQgaW50byBvdXIgdHJlZSBzdHJ1Y3R1cmUuCi0JICovCi0JZm9yIChwZm4gPSAwOyBwZm4gPCBtYXhfcGZuOyBwZm4gKz0gUDJNX1BFUl9QQUdFKSB7Ci0JCXVuc2lnbmVkIHRvcGlkeCA9IHAybV90b3BfaW5kZXgocGZuKTsKLQkJdW5zaWduZWQgbWlkaWR4ID0gcDJtX21pZF9pbmRleChwZm4pOwotCi0JCWlmIChwMm1fdG9wW3RvcGlkeF0gPT0gcDJtX21pZF9taXNzaW5nKSB7Ci0JCQl1bnNpZ25lZCBsb25nICoqbWlkID0gZXh0ZW5kX2JyayhQQUdFX1NJWkUsIFBBR0VfU0laRSk7Ci0JCQlwMm1fbWlkX2luaXQobWlkKTsKLQotCQkJcDJtX3RvcFt0b3BpZHhdID0gbWlkOwotCQl9Ci0KLQkJcDJtX3RvcFt0b3BpZHhdW21pZGlkeF0gPSAmbWZuX2xpc3RbcGZuXTsKLQl9Ci19Ci0KLXVuc2lnbmVkIGxvbmcgZ2V0X3BoeXNfdG9fbWFjaGluZSh1bnNpZ25lZCBsb25nIHBmbikKLXsKLQl1bnNpZ25lZCB0b3BpZHgsIG1pZGlkeCwgaWR4OwotCi0JaWYgKHVubGlrZWx5KHBmbiA+PSBNQVhfUDJNX1BGTikpCi0JCXJldHVybiBJTlZBTElEX1AyTV9FTlRSWTsKLQotCXRvcGlkeCA9IHAybV90b3BfaW5kZXgocGZuKTsKLQltaWRpZHggPSBwMm1fbWlkX2luZGV4KHBmbik7Ci0JaWR4ID0gcDJtX2luZGV4KHBmbik7Ci0KLQlyZXR1cm4gcDJtX3RvcFt0b3BpZHhdW21pZGlkeF1baWR4XTsKLX0KLUVYUE9SVF9TWU1CT0xfR1BMKGdldF9waHlzX3RvX21hY2hpbmUpOwotCi1zdGF0aWMgdm9pZCAqYWxsb2NfcDJtX3BhZ2Uodm9pZCkKLXsKLQlyZXR1cm4gKHZvaWQgKilfX2dldF9mcmVlX3BhZ2UoR0ZQX0tFUk5FTCB8IF9fR0ZQX1JFUEVBVCk7Ci19Ci0KLXN0YXRpYyB2b2lkIGZyZWVfcDJtX3BhZ2Uodm9pZCAqcCkKLXsKLQlmcmVlX3BhZ2UoKHVuc2lnbmVkIGxvbmcpcCk7Ci19Ci0KLS8qIAotICogRnVsbHkgYWxsb2NhdGUgdGhlIHAybSBzdHJ1Y3R1cmUgZm9yIGEgZ2l2ZW4gcGZuLiAgV2UgbmVlZCB0byBjaGVjawotICogdGhhdCBib3RoIHRoZSB0b3AgYW5kIG1pZCBsZXZlbHMgYXJlIGFsbG9jYXRlZCwgYW5kIG1ha2Ugc3VyZSB0aGUKLSAqIHBhcmFsbGVsIG1mbiB0cmVlIGlzIGtlcHQgaW4gc3luYy4gIFdlIG1heSByYWNlIHdpdGggb3RoZXIgY3B1cywgc28KLSAqIHRoZSBuZXcgcGFnZXMgYXJlIGluc3RhbGxlZCB3aXRoIGNtcHhjaGc7IGlmIHdlIGxvc2UgdGhlIHJhY2UgdGhlbgotICogc2ltcGx5IGZyZWUgdGhlIHBhZ2Ugd2UgYWxsb2NhdGVkIGFuZCB1c2UgdGhlIG9uZSB0aGF0J3MgdGhlcmUuCi0gKi8KLXN0YXRpYyBib29sIGFsbG9jX3AybSh1bnNpZ25lZCBsb25nIHBmbikKLXsKLQl1bnNpZ25lZCB0b3BpZHgsIG1pZGlkeDsKLQl1bnNpZ25lZCBsb25nICoqKnRvcF9wLCAqKm1pZDsKLQl1bnNpZ25lZCBsb25nICp0b3BfbWZuX3AsICptaWRfbWZuOwotCi0JdG9waWR4ID0gcDJtX3RvcF9pbmRleChwZm4pOwotCW1pZGlkeCA9IHAybV9taWRfaW5kZXgocGZuKTsKLQotCXRvcF9wID0gJnAybV90b3BbdG9waWR4XTsKLQltaWQgPSAqdG9wX3A7Ci0KLQlpZiAobWlkID09IHAybV9taWRfbWlzc2luZykgewotCQkvKiBNaWQgbGV2ZWwgaXMgbWlzc2luZywgYWxsb2NhdGUgYSBuZXcgb25lICovCi0JCW1pZCA9IGFsbG9jX3AybV9wYWdlKCk7Ci0JCWlmICghbWlkKQotCQkJcmV0dXJuIGZhbHNlOwotCi0JCXAybV9taWRfaW5pdChtaWQpOwotCi0JCWlmIChjbXB4Y2hnKHRvcF9wLCBwMm1fbWlkX21pc3NpbmcsIG1pZCkgIT0gcDJtX21pZF9taXNzaW5nKQotCQkJZnJlZV9wMm1fcGFnZShtaWQpOwotCX0KLQotCXRvcF9tZm5fcCA9ICZwMm1fdG9wX21mblt0b3BpZHhdOwotCW1pZF9tZm4gPSBwMm1fdG9wX21mbl9wW3RvcGlkeF07Ci0KLQlCVUdfT04odmlydF90b19tZm4obWlkX21mbikgIT0gKnRvcF9tZm5fcCk7Ci0KLQlpZiAobWlkX21mbiA9PSBwMm1fbWlkX21pc3NpbmdfbWZuKSB7Ci0JCS8qIFNlcGFyYXRlbHkgY2hlY2sgdGhlIG1pZCBtZm4gbGV2ZWwgKi8KLQkJdW5zaWduZWQgbG9uZyBtaXNzaW5nX21mbjsKLQkJdW5zaWduZWQgbG9uZyBtaWRfbWZuX21mbjsKLQotCQltaWRfbWZuID0gYWxsb2NfcDJtX3BhZ2UoKTsKLQkJaWYgKCFtaWRfbWZuKQotCQkJcmV0dXJuIGZhbHNlOwotCi0JCXAybV9taWRfbWZuX2luaXQobWlkX21mbik7Ci0KLQkJbWlzc2luZ19tZm4gPSB2aXJ0X3RvX21mbihwMm1fbWlkX21pc3NpbmdfbWZuKTsKLQkJbWlkX21mbl9tZm4gPSB2aXJ0X3RvX21mbihtaWRfbWZuKTsKLQkJaWYgKGNtcHhjaGcodG9wX21mbl9wLCBtaXNzaW5nX21mbiwgbWlkX21mbl9tZm4pICE9IG1pc3NpbmdfbWZuKQotCQkJZnJlZV9wMm1fcGFnZShtaWRfbWZuKTsKLQkJZWxzZQotCQkJcDJtX3RvcF9tZm5fcFt0b3BpZHhdID0gbWlkX21mbjsKLQl9Ci0KLQlpZiAocDJtX3RvcFt0b3BpZHhdW21pZGlkeF0gPT0gcDJtX21pc3NpbmcpIHsKLQkJLyogcDJtIGxlYWYgcGFnZSBpcyBtaXNzaW5nICovCi0JCXVuc2lnbmVkIGxvbmcgKnAybTsKLQotCQlwMm0gPSBhbGxvY19wMm1fcGFnZSgpOwotCQlpZiAoIXAybSkKLQkJCXJldHVybiBmYWxzZTsKLQotCQlwMm1faW5pdChwMm0pOwotCi0JCWlmIChjbXB4Y2hnKCZtaWRbbWlkaWR4XSwgcDJtX21pc3NpbmcsIHAybSkgIT0gcDJtX21pc3NpbmcpCi0JCQlmcmVlX3AybV9wYWdlKHAybSk7Ci0JCWVsc2UKLQkJCW1pZF9tZm5bbWlkaWR4XSA9IHZpcnRfdG9fbWZuKHAybSk7Ci0JfQotCi0JcmV0dXJuIHRydWU7Ci19Ci0KLS8qIFRyeSB0byBpbnN0YWxsIHAybSBtYXBwaW5nOyBmYWlsIGlmIGludGVybWVkaWF0ZSBiaXRzIG1pc3NpbmcgKi8KLWJvb2wgX19zZXRfcGh5c190b19tYWNoaW5lKHVuc2lnbmVkIGxvbmcgcGZuLCB1bnNpZ25lZCBsb25nIG1mbikKLXsKLQl1bnNpZ25lZCB0b3BpZHgsIG1pZGlkeCwgaWR4OwotCi0JaWYgKHVubGlrZWx5KHBmbiA+PSBNQVhfUDJNX1BGTikpIHsKLQkJQlVHX09OKG1mbiAhPSBJTlZBTElEX1AyTV9FTlRSWSk7Ci0JCXJldHVybiB0cnVlOwotCX0KLQotCXRvcGlkeCA9IHAybV90b3BfaW5kZXgocGZuKTsKLQltaWRpZHggPSBwMm1fbWlkX2luZGV4KHBmbik7Ci0JaWR4ID0gcDJtX2luZGV4KHBmbik7Ci0KLQlpZiAocDJtX3RvcFt0b3BpZHhdW21pZGlkeF0gPT0gcDJtX21pc3NpbmcpCi0JCXJldHVybiBtZm4gPT0gSU5WQUxJRF9QMk1fRU5UUlk7Ci0KLQlwMm1fdG9wW3RvcGlkeF1bbWlkaWR4XVtpZHhdID0gbWZuOwotCi0JcmV0dXJuIHRydWU7Ci19Ci0KLWJvb2wgc2V0X3BoeXNfdG9fbWFjaGluZSh1bnNpZ25lZCBsb25nIHBmbiwgdW5zaWduZWQgbG9uZyBtZm4pCi17Ci0JaWYgKHVubGlrZWx5KHhlbl9mZWF0dXJlKFhFTkZFQVRfYXV0b190cmFuc2xhdGVkX3BoeXNtYXApKSkgewotCQlCVUdfT04ocGZuICE9IG1mbiAmJiBtZm4gIT0gSU5WQUxJRF9QMk1fRU5UUlkpOwotCQlyZXR1cm4gdHJ1ZTsKLQl9Ci0KLQlpZiAodW5saWtlbHkoIV9fc2V0X3BoeXNfdG9fbWFjaGluZShwZm4sIG1mbikpKSAgewotCQlpZiAoIWFsbG9jX3AybShwZm4pKQotCQkJcmV0dXJuIGZhbHNlOwotCi0JCWlmICghX19zZXRfcGh5c190b19tYWNoaW5lKHBmbiwgbWZuKSkKLQkJCXJldHVybiBmYWxzZTsKLQl9Ci0KLQlyZXR1cm4gdHJ1ZTsKLX0KLQogdW5zaWduZWQgbG9uZyBhcmJpdHJhcnlfdmlydF90b19tZm4odm9pZCAqdmFkZHIpCiB7CiAJeG1hZGRyX3QgbWFkZHIgPSBhcmJpdHJhcnlfdmlydF90b19tYWNoaW5lKHZhZGRyKTsKQEAgLTU2Niw2ICsyMDEsNyBAQAogCW9mZnNldCA9IGFkZHJlc3MgJiB+UEFHRV9NQVNLOwogCXJldHVybiBYTUFERFIoKChwaHlzX2FkZHJfdClwdGVfbWZuKCpwdGUpIDw8IFBBR0VfU0hJRlQpICsgb2Zmc2V0KTsKIH0KK0VYUE9SVF9TWU1CT0xfR1BMKGFyYml0cmFyeV92aXJ0X3RvX21hY2hpbmUpOwogCiB2b2lkIG1ha2VfbG93bWVtX3BhZ2VfcmVhZG9ubHkodm9pZCAqdmFkZHIpCiB7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni94ZW4vcDJtLmMgYi9hcmNoL3g4Ni94ZW4vcDJtLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmQxMmQ3YwotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gveDg2L3hlbi9wMm0uYwpAQCAtMCwwICsxLDUyMiBAQAorLyoKKyAqIFhlbiBsZWF2ZXMgdGhlIHJlc3BvbnNpYmlsaXR5IGZvciBtYWludGFpbmluZyBwMm0gbWFwcGluZ3MgdG8gdGhlCisgKiBndWVzdHMgdGhlbXNlbHZlcywgYnV0IGl0IG11c3QgYWxzbyBhY2Nlc3MgYW5kIHVwZGF0ZSB0aGUgcDJtIGFycmF5CisgKiBkdXJpbmcgc3VzcGVuZC9yZXN1bWUgd2hlbiBhbGwgdGhlIHBhZ2VzIGFyZSByZWFsbG9jYXRlZC4KKyAqCisgKiBUaGUgcDJtIHRhYmxlIGlzIGxvZ2ljYWxseSBhIGZsYXQgYXJyYXksIGJ1dCB3ZSBpbXBsZW1lbnQgaXQgYXMgYQorICogdGhyZWUtbGV2ZWwgdHJlZSB0byBhbGxvdyB0aGUgYWRkcmVzcyBzcGFjZSB0byBiZSBzcGFyc2UuCisgKgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgWGVuCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAorICogICAgIHAybV90b3AgICAgICAgICAgICAgIHAybV90b3BfbWZuCisgKiAgICAgICAvICBcICAgICAgICAgICAgICAgICAgIC8gICBcCisgKiBwMm1fbWlkIHAybV9taWQJcDJtX21pZF9tZm4gcDJtX21pZF9tZm4KKyAqICAgIC8gXCAgICAgIC8gXCAgICAgICAgIC8gICAgICAgICAgIC8KKyAqICBwMm0gcDJtIHAybSBwMm0gcDJtIHAybSBwMm0gLi4uCisgKgorICogVGhlIHAybV9taWRfbWZuIHBhZ2VzIGFyZSBtYXBwZWQgYnkgcDJtX3RvcF9tZm5fcC4KKyAqCisgKiBUaGUgcDJtX3RvcCBhbmQgcDJtX3RvcF9tZm4gbGV2ZWxzIGFyZSBsaW1pdGVkIHRvIDEgcGFnZSwgc28gdGhlCisgKiBtYXhpbXVtIHJlcHJlc2VudGFibGUgcHNldWRvLXBoeXNpY2FsIGFkZHJlc3Mgc3BhY2UgaXM6CisgKiAgUDJNX1RPUF9QRVJfUEFHRSAqIFAyTV9NSURfUEVSX1BBR0UgKiBQMk1fUEVSX1BBR0UgcGFnZXMKKyAqCisgKiBQMk1fUEVSX1BBR0UgZGVwZW5kcyBvbiB0aGUgYXJjaGl0ZWN0dXJlLCBhcyBhIG1mbiBpcyBhbHdheXMKKyAqIHVuc2lnbmVkIGxvbmcgKDggYnl0ZXMgb24gNjQtYml0LCA0IGJ5dGVzIG9uIDMyKSwgbGVhZGluZyB0bworICogNTEyIGFuZCAxMDI0IGVudHJpZXMgcmVzcGVjdGl2ZWx5LiAKKyAqLworCisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KKyNpbmNsdWRlIDxsaW51eC9oYXNoLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KKworI2luY2x1ZGUgPGFzbS9jYWNoZS5oPgorI2luY2x1ZGUgPGFzbS9zZXR1cC5oPgorCisjaW5jbHVkZSA8YXNtL3hlbi9wYWdlLmg+CisjaW5jbHVkZSA8YXNtL3hlbi9oeXBlcmNhbGwuaD4KKyNpbmNsdWRlIDxhc20veGVuL2h5cGVydmlzb3IuaD4KKworI2luY2x1ZGUgInhlbi1vcHMuaCIKKworc3RhdGljIHZvaWQgX19pbml0IG0ycF9vdmVycmlkZV9pbml0KHZvaWQpOworCit1bnNpZ25lZCBsb25nIHhlbl9tYXhfcDJtX3BmbiBfX3JlYWRfbW9zdGx5OworCisjZGVmaW5lIFAyTV9QRVJfUEFHRQkJKFBBR0VfU0laRSAvIHNpemVvZih1bnNpZ25lZCBsb25nKSkKKyNkZWZpbmUgUDJNX01JRF9QRVJfUEFHRQkoUEFHRV9TSVpFIC8gc2l6ZW9mKHVuc2lnbmVkIGxvbmcgKikpCisjZGVmaW5lIFAyTV9UT1BfUEVSX1BBR0UJKFBBR0VfU0laRSAvIHNpemVvZih1bnNpZ25lZCBsb25nICoqKSkKKworI2RlZmluZSBNQVhfUDJNX1BGTgkJKFAyTV9UT1BfUEVSX1BBR0UgKiBQMk1fTUlEX1BFUl9QQUdFICogUDJNX1BFUl9QQUdFKQorCisvKiBQbGFjZWhvbGRlcnMgZm9yIGhvbGVzIGluIHRoZSBhZGRyZXNzIHNwYWNlICovCitzdGF0aWMgUkVTRVJWRV9CUktfQVJSQVkodW5zaWduZWQgbG9uZywgcDJtX21pc3NpbmcsIFAyTV9QRVJfUEFHRSk7CitzdGF0aWMgUkVTRVJWRV9CUktfQVJSQVkodW5zaWduZWQgbG9uZyAqLCBwMm1fbWlkX21pc3NpbmcsIFAyTV9NSURfUEVSX1BBR0UpOworc3RhdGljIFJFU0VSVkVfQlJLX0FSUkFZKHVuc2lnbmVkIGxvbmcsIHAybV9taWRfbWlzc2luZ19tZm4sIFAyTV9NSURfUEVSX1BBR0UpOworCitzdGF0aWMgUkVTRVJWRV9CUktfQVJSQVkodW5zaWduZWQgbG9uZyAqKiwgcDJtX3RvcCwgUDJNX1RPUF9QRVJfUEFHRSk7CitzdGF0aWMgUkVTRVJWRV9CUktfQVJSQVkodW5zaWduZWQgbG9uZywgcDJtX3RvcF9tZm4sIFAyTV9UT1BfUEVSX1BBR0UpOworc3RhdGljIFJFU0VSVkVfQlJLX0FSUkFZKHVuc2lnbmVkIGxvbmcgKiwgcDJtX3RvcF9tZm5fcCwgUDJNX1RPUF9QRVJfUEFHRSk7CisKK1JFU0VSVkVfQlJLKHAybV9taWQsIFBBR0VfU0laRSAqIChNQVhfRE9NQUlOX1BBR0VTIC8gKFAyTV9QRVJfUEFHRSAqIFAyTV9NSURfUEVSX1BBR0UpKSk7CitSRVNFUlZFX0JSSyhwMm1fbWlkX21mbiwgUEFHRV9TSVpFICogKE1BWF9ET01BSU5fUEFHRVMgLyAoUDJNX1BFUl9QQUdFICogUDJNX01JRF9QRVJfUEFHRSkpKTsKKworc3RhdGljIGlubGluZSB1bnNpZ25lZCBwMm1fdG9wX2luZGV4KHVuc2lnbmVkIGxvbmcgcGZuKQoreworCUJVR19PTihwZm4gPj0gTUFYX1AyTV9QRk4pOworCXJldHVybiBwZm4gLyAoUDJNX01JRF9QRVJfUEFHRSAqIFAyTV9QRVJfUEFHRSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdW5zaWduZWQgcDJtX21pZF9pbmRleCh1bnNpZ25lZCBsb25nIHBmbikKK3sKKwlyZXR1cm4gKHBmbiAvIFAyTV9QRVJfUEFHRSkgJSBQMk1fTUlEX1BFUl9QQUdFOworfQorCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIHAybV9pbmRleCh1bnNpZ25lZCBsb25nIHBmbikKK3sKKwlyZXR1cm4gcGZuICUgUDJNX1BFUl9QQUdFOworfQorCitzdGF0aWMgdm9pZCBwMm1fdG9wX2luaXQodW5zaWduZWQgbG9uZyAqKip0b3ApCit7CisJdW5zaWduZWQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBQMk1fVE9QX1BFUl9QQUdFOyBpKyspCisJCXRvcFtpXSA9IHAybV9taWRfbWlzc2luZzsKK30KKworc3RhdGljIHZvaWQgcDJtX3RvcF9tZm5faW5pdCh1bnNpZ25lZCBsb25nICp0b3ApCit7CisJdW5zaWduZWQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBQMk1fVE9QX1BFUl9QQUdFOyBpKyspCisJCXRvcFtpXSA9IHZpcnRfdG9fbWZuKHAybV9taWRfbWlzc2luZ19tZm4pOworfQorCitzdGF0aWMgdm9pZCBwMm1fdG9wX21mbl9wX2luaXQodW5zaWduZWQgbG9uZyAqKnRvcCkKK3sKKwl1bnNpZ25lZCBpOworCisJZm9yIChpID0gMDsgaSA8IFAyTV9UT1BfUEVSX1BBR0U7IGkrKykKKwkJdG9wW2ldID0gcDJtX21pZF9taXNzaW5nX21mbjsKK30KKworc3RhdGljIHZvaWQgcDJtX21pZF9pbml0KHVuc2lnbmVkIGxvbmcgKiptaWQpCit7CisJdW5zaWduZWQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBQMk1fTUlEX1BFUl9QQUdFOyBpKyspCisJCW1pZFtpXSA9IHAybV9taXNzaW5nOworfQorCitzdGF0aWMgdm9pZCBwMm1fbWlkX21mbl9pbml0KHVuc2lnbmVkIGxvbmcgKm1pZCkKK3sKKwl1bnNpZ25lZCBpOworCisJZm9yIChpID0gMDsgaSA8IFAyTV9NSURfUEVSX1BBR0U7IGkrKykKKwkJbWlkW2ldID0gdmlydF90b19tZm4ocDJtX21pc3NpbmcpOworfQorCitzdGF0aWMgdm9pZCBwMm1faW5pdCh1bnNpZ25lZCBsb25nICpwMm0pCit7CisJdW5zaWduZWQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBQMk1fTUlEX1BFUl9QQUdFOyBpKyspCisJCXAybVtpXSA9IElOVkFMSURfUDJNX0VOVFJZOworfQorCisvKgorICogQnVpbGQgdGhlIHBhcmFsbGVsIHAybV90b3BfbWZuIGFuZCBwMm1fbWlkX21mbiBzdHJ1Y3R1cmVzCisgKgorICogVGhpcyBpcyBjYWxsZWQgYm90aCBhdCBib290IHRpbWUsIGFuZCBhZnRlciByZXN1bWluZyBmcm9tIHN1c3BlbmQ6CisgKiAtIEF0IGJvb3QgdGltZSB3ZSdyZSBjYWxsZWQgdmVyeSBlYXJseSwgYW5kIG11c3QgdXNlIGV4dGVuZF9icmsoKQorICogICB0byBhbGxvY2F0ZSBtZW1vcnkuCisgKgorICogLSBBZnRlciByZXN1bWUgd2UncmUgY2FsbGVkIGZyb20gd2l0aGluIHN0b3BfbWFjaGluZSwgYnV0IHRoZSBtZm4KKyAqICAgdHJlZSBzaG91bGQgYWxyZWF5IGJlIGNvbXBsZXRlbHkgYWxsb2NhdGVkLgorICovCit2b2lkIHhlbl9idWlsZF9tZm5fbGlzdF9saXN0KHZvaWQpCit7CisJdW5zaWduZWQgbG9uZyBwZm47CisKKwkvKiBQcmUtaW5pdGlhbGl6ZSBwMm1fdG9wX21mbiB0byBiZSBjb21wbGV0ZWx5IG1pc3NpbmcgKi8KKwlpZiAocDJtX3RvcF9tZm4gPT0gTlVMTCkgeworCQlwMm1fbWlkX21pc3NpbmdfbWZuID0gZXh0ZW5kX2JyayhQQUdFX1NJWkUsIFBBR0VfU0laRSk7CisJCXAybV9taWRfbWZuX2luaXQocDJtX21pZF9taXNzaW5nX21mbik7CisKKwkJcDJtX3RvcF9tZm5fcCA9IGV4dGVuZF9icmsoUEFHRV9TSVpFLCBQQUdFX1NJWkUpOworCQlwMm1fdG9wX21mbl9wX2luaXQocDJtX3RvcF9tZm5fcCk7CisKKwkJcDJtX3RvcF9tZm4gPSBleHRlbmRfYnJrKFBBR0VfU0laRSwgUEFHRV9TSVpFKTsKKwkJcDJtX3RvcF9tZm5faW5pdChwMm1fdG9wX21mbik7CisJfSBlbHNlIHsKKwkJLyogUmVpbml0aWFsaXNlLCBtZm4ncyBhbGwgY2hhbmdlIGFmdGVyIG1pZ3JhdGlvbiAqLworCQlwMm1fbWlkX21mbl9pbml0KHAybV9taWRfbWlzc2luZ19tZm4pOworCX0KKworCWZvciAocGZuID0gMDsgcGZuIDwgeGVuX21heF9wMm1fcGZuOyBwZm4gKz0gUDJNX1BFUl9QQUdFKSB7CisJCXVuc2lnbmVkIHRvcGlkeCA9IHAybV90b3BfaW5kZXgocGZuKTsKKwkJdW5zaWduZWQgbWlkaWR4ID0gcDJtX21pZF9pbmRleChwZm4pOworCQl1bnNpZ25lZCBsb25nICoqbWlkOworCQl1bnNpZ25lZCBsb25nICptaWRfbWZuX3A7CisKKwkJbWlkID0gcDJtX3RvcFt0b3BpZHhdOworCQltaWRfbWZuX3AgPSBwMm1fdG9wX21mbl9wW3RvcGlkeF07CisKKwkJLyogRG9uJ3QgYm90aGVyIGFsbG9jYXRpbmcgYW55IG1mbiBtaWQgbGV2ZWxzIGlmCisJCSAqIHRoZXkncmUganVzdCBtaXNzaW5nLCBqdXN0IHVwZGF0ZSB0aGUgc3RvcmVkIG1mbiwKKwkJICogc2luY2UgYWxsIGNvdWxkIGhhdmUgY2hhbmdlZCBvdmVyIGEgbWlncmF0ZS4KKwkJICovCisJCWlmIChtaWQgPT0gcDJtX21pZF9taXNzaW5nKSB7CisJCQlCVUdfT04obWlkaWR4KTsKKwkJCUJVR19PTihtaWRfbWZuX3AgIT0gcDJtX21pZF9taXNzaW5nX21mbik7CisJCQlwMm1fdG9wX21mblt0b3BpZHhdID0gdmlydF90b19tZm4ocDJtX21pZF9taXNzaW5nX21mbik7CisJCQlwZm4gKz0gKFAyTV9NSURfUEVSX1BBR0UgLSAxKSAqIFAyTV9QRVJfUEFHRTsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJaWYgKG1pZF9tZm5fcCA9PSBwMm1fbWlkX21pc3NpbmdfbWZuKSB7CisJCQkvKgorCQkJICogWFhYIGJvb3QtdGltZSBvbmx5ISAgV2Ugc2hvdWxkIG5ldmVyIGZpbmQKKwkJCSAqIG1pc3NpbmcgcGFydHMgb2YgdGhlIG1mbiB0cmVlIGFmdGVyCisJCQkgKiBydW50aW1lLiAgZXh0ZW5kX2JyaygpIHdpbGwgQlVHIGlmIHdlIGNhbGwKKwkJCSAqIGl0IHRvbyBsYXRlLgorCQkJICovCisJCQltaWRfbWZuX3AgPSBleHRlbmRfYnJrKFBBR0VfU0laRSwgUEFHRV9TSVpFKTsKKwkJCXAybV9taWRfbWZuX2luaXQobWlkX21mbl9wKTsKKworCQkJcDJtX3RvcF9tZm5fcFt0b3BpZHhdID0gbWlkX21mbl9wOworCQl9CisKKwkJcDJtX3RvcF9tZm5bdG9waWR4XSA9IHZpcnRfdG9fbWZuKG1pZF9tZm5fcCk7CisJCW1pZF9tZm5fcFttaWRpZHhdID0gdmlydF90b19tZm4obWlkW21pZGlkeF0pOworCX0KK30KKwordm9pZCB4ZW5fc2V0dXBfbWZuX2xpc3RfbGlzdCh2b2lkKQoreworCUJVR19PTihIWVBFUlZJU09SX3NoYXJlZF9pbmZvID09ICZ4ZW5fZHVtbXlfc2hhcmVkX2luZm8pOworCisJSFlQRVJWSVNPUl9zaGFyZWRfaW5mby0+YXJjaC5wZm5fdG9fbWZuX2ZyYW1lX2xpc3RfbGlzdCA9CisJCXZpcnRfdG9fbWZuKHAybV90b3BfbWZuKTsKKwlIWVBFUlZJU09SX3NoYXJlZF9pbmZvLT5hcmNoLm1heF9wZm4gPSB4ZW5fbWF4X3AybV9wZm47Cit9CisKKy8qIFNldCB1cCBwMm1fdG9wIHRvIHBvaW50IHRvIHRoZSBkb21haW4tYnVpbGRlciBwcm92aWRlZCBwMm0gcGFnZXMgKi8KK3ZvaWQgX19pbml0IHhlbl9idWlsZF9keW5hbWljX3BoeXNfdG9fbWFjaGluZSh2b2lkKQoreworCXVuc2lnbmVkIGxvbmcgKm1mbl9saXN0ID0gKHVuc2lnbmVkIGxvbmcgKil4ZW5fc3RhcnRfaW5mby0+bWZuX2xpc3Q7CisJdW5zaWduZWQgbG9uZyBtYXhfcGZuID0gbWluKE1BWF9ET01BSU5fUEFHRVMsIHhlbl9zdGFydF9pbmZvLT5ucl9wYWdlcyk7CisJdW5zaWduZWQgbG9uZyBwZm47CisKKwl4ZW5fbWF4X3AybV9wZm4gPSBtYXhfcGZuOworCisJcDJtX21pc3NpbmcgPSBleHRlbmRfYnJrKFBBR0VfU0laRSwgUEFHRV9TSVpFKTsKKwlwMm1faW5pdChwMm1fbWlzc2luZyk7CisKKwlwMm1fbWlkX21pc3NpbmcgPSBleHRlbmRfYnJrKFBBR0VfU0laRSwgUEFHRV9TSVpFKTsKKwlwMm1fbWlkX2luaXQocDJtX21pZF9taXNzaW5nKTsKKworCXAybV90b3AgPSBleHRlbmRfYnJrKFBBR0VfU0laRSwgUEFHRV9TSVpFKTsKKwlwMm1fdG9wX2luaXQocDJtX3RvcCk7CisKKwkvKgorCSAqIFRoZSBkb21haW4gYnVpbGRlciBnaXZlcyB1cyBhIHByZS1jb25zdHJ1Y3RlZCBwMm0gYXJyYXkgaW4KKwkgKiBtZm5fbGlzdCBmb3IgYWxsIHRoZSBwYWdlcyBpbml0aWFsbHkgZ2l2ZW4gdG8gdXMsIHNvIHdlIGp1c3QKKwkgKiBuZWVkIHRvIGdyYWZ0IHRoYXQgaW50byBvdXIgdHJlZSBzdHJ1Y3R1cmUuCisJICovCisJZm9yIChwZm4gPSAwOyBwZm4gPCBtYXhfcGZuOyBwZm4gKz0gUDJNX1BFUl9QQUdFKSB7CisJCXVuc2lnbmVkIHRvcGlkeCA9IHAybV90b3BfaW5kZXgocGZuKTsKKwkJdW5zaWduZWQgbWlkaWR4ID0gcDJtX21pZF9pbmRleChwZm4pOworCisJCWlmIChwMm1fdG9wW3RvcGlkeF0gPT0gcDJtX21pZF9taXNzaW5nKSB7CisJCQl1bnNpZ25lZCBsb25nICoqbWlkID0gZXh0ZW5kX2JyayhQQUdFX1NJWkUsIFBBR0VfU0laRSk7CisJCQlwMm1fbWlkX2luaXQobWlkKTsKKworCQkJcDJtX3RvcFt0b3BpZHhdID0gbWlkOworCQl9CisKKwkJLyoKKwkJICogQXMgbG9uZyBhcyB0aGUgbWZuX2xpc3QgaGFzIGVub3VnaCBlbnRyaWVzIHRvIGNvbXBsZXRlbHkKKwkJICogZmlsbCBhIHAybSBwYWdlLCBwb2ludGluZyBpbnRvIHRoZSBhcnJheSBpcyBvay4gQnV0IGlmCisJCSAqIG5vdCB0aGUgZW50cmllcyBiZXlvbmQgdGhlIGxhc3QgcGZuIHdpbGwgYmUgdW5kZWZpbmVkLgorCQkgKi8KKwkJaWYgKHVubGlrZWx5KHBmbiArIFAyTV9QRVJfUEFHRSA+IG1heF9wZm4pKSB7CisJCQl1bnNpZ25lZCBsb25nIHAybWlkeDsKKworCQkJcDJtaWR4ID0gbWF4X3BmbiAlIFAyTV9QRVJfUEFHRTsKKwkJCWZvciAoIDsgcDJtaWR4IDwgUDJNX1BFUl9QQUdFOyBwMm1pZHgrKykKKwkJCQltZm5fbGlzdFtwZm4gKyBwMm1pZHhdID0gSU5WQUxJRF9QMk1fRU5UUlk7CisJCX0KKwkJcDJtX3RvcFt0b3BpZHhdW21pZGlkeF0gPSAmbWZuX2xpc3RbcGZuXTsKKwl9CisKKwltMnBfb3ZlcnJpZGVfaW5pdCgpOworfQorCit1bnNpZ25lZCBsb25nIGdldF9waHlzX3RvX21hY2hpbmUodW5zaWduZWQgbG9uZyBwZm4pCit7CisJdW5zaWduZWQgdG9waWR4LCBtaWRpZHgsIGlkeDsKKworCWlmICh1bmxpa2VseShwZm4gPj0gTUFYX1AyTV9QRk4pKQorCQlyZXR1cm4gSU5WQUxJRF9QMk1fRU5UUlk7CisKKwl0b3BpZHggPSBwMm1fdG9wX2luZGV4KHBmbik7CisJbWlkaWR4ID0gcDJtX21pZF9pbmRleChwZm4pOworCWlkeCA9IHAybV9pbmRleChwZm4pOworCisJcmV0dXJuIHAybV90b3BbdG9waWR4XVttaWRpZHhdW2lkeF07Cit9CitFWFBPUlRfU1lNQk9MX0dQTChnZXRfcGh5c190b19tYWNoaW5lKTsKKworc3RhdGljIHZvaWQgKmFsbG9jX3AybV9wYWdlKHZvaWQpCit7CisJcmV0dXJuICh2b2lkICopX19nZXRfZnJlZV9wYWdlKEdGUF9LRVJORUwgfCBfX0dGUF9SRVBFQVQpOworfQorCitzdGF0aWMgdm9pZCBmcmVlX3AybV9wYWdlKHZvaWQgKnApCit7CisJZnJlZV9wYWdlKCh1bnNpZ25lZCBsb25nKXApOworfQorCisvKiAKKyAqIEZ1bGx5IGFsbG9jYXRlIHRoZSBwMm0gc3RydWN0dXJlIGZvciBhIGdpdmVuIHBmbi4gIFdlIG5lZWQgdG8gY2hlY2sKKyAqIHRoYXQgYm90aCB0aGUgdG9wIGFuZCBtaWQgbGV2ZWxzIGFyZSBhbGxvY2F0ZWQsIGFuZCBtYWtlIHN1cmUgdGhlCisgKiBwYXJhbGxlbCBtZm4gdHJlZSBpcyBrZXB0IGluIHN5bmMuICBXZSBtYXkgcmFjZSB3aXRoIG90aGVyIGNwdXMsIHNvCisgKiB0aGUgbmV3IHBhZ2VzIGFyZSBpbnN0YWxsZWQgd2l0aCBjbXB4Y2hnOyBpZiB3ZSBsb3NlIHRoZSByYWNlIHRoZW4KKyAqIHNpbXBseSBmcmVlIHRoZSBwYWdlIHdlIGFsbG9jYXRlZCBhbmQgdXNlIHRoZSBvbmUgdGhhdCdzIHRoZXJlLgorICovCitzdGF0aWMgYm9vbCBhbGxvY19wMm0odW5zaWduZWQgbG9uZyBwZm4pCit7CisJdW5zaWduZWQgdG9waWR4LCBtaWRpZHg7CisJdW5zaWduZWQgbG9uZyAqKip0b3BfcCwgKiptaWQ7CisJdW5zaWduZWQgbG9uZyAqdG9wX21mbl9wLCAqbWlkX21mbjsKKworCXRvcGlkeCA9IHAybV90b3BfaW5kZXgocGZuKTsKKwltaWRpZHggPSBwMm1fbWlkX2luZGV4KHBmbik7CisKKwl0b3BfcCA9ICZwMm1fdG9wW3RvcGlkeF07CisJbWlkID0gKnRvcF9wOworCisJaWYgKG1pZCA9PSBwMm1fbWlkX21pc3NpbmcpIHsKKwkJLyogTWlkIGxldmVsIGlzIG1pc3NpbmcsIGFsbG9jYXRlIGEgbmV3IG9uZSAqLworCQltaWQgPSBhbGxvY19wMm1fcGFnZSgpOworCQlpZiAoIW1pZCkKKwkJCXJldHVybiBmYWxzZTsKKworCQlwMm1fbWlkX2luaXQobWlkKTsKKworCQlpZiAoY21weGNoZyh0b3BfcCwgcDJtX21pZF9taXNzaW5nLCBtaWQpICE9IHAybV9taWRfbWlzc2luZykKKwkJCWZyZWVfcDJtX3BhZ2UobWlkKTsKKwl9CisKKwl0b3BfbWZuX3AgPSAmcDJtX3RvcF9tZm5bdG9waWR4XTsKKwltaWRfbWZuID0gcDJtX3RvcF9tZm5fcFt0b3BpZHhdOworCisJQlVHX09OKHZpcnRfdG9fbWZuKG1pZF9tZm4pICE9ICp0b3BfbWZuX3ApOworCisJaWYgKG1pZF9tZm4gPT0gcDJtX21pZF9taXNzaW5nX21mbikgeworCQkvKiBTZXBhcmF0ZWx5IGNoZWNrIHRoZSBtaWQgbWZuIGxldmVsICovCisJCXVuc2lnbmVkIGxvbmcgbWlzc2luZ19tZm47CisJCXVuc2lnbmVkIGxvbmcgbWlkX21mbl9tZm47CisKKwkJbWlkX21mbiA9IGFsbG9jX3AybV9wYWdlKCk7CisJCWlmICghbWlkX21mbikKKwkJCXJldHVybiBmYWxzZTsKKworCQlwMm1fbWlkX21mbl9pbml0KG1pZF9tZm4pOworCisJCW1pc3NpbmdfbWZuID0gdmlydF90b19tZm4ocDJtX21pZF9taXNzaW5nX21mbik7CisJCW1pZF9tZm5fbWZuID0gdmlydF90b19tZm4obWlkX21mbik7CisJCWlmIChjbXB4Y2hnKHRvcF9tZm5fcCwgbWlzc2luZ19tZm4sIG1pZF9tZm5fbWZuKSAhPSBtaXNzaW5nX21mbikKKwkJCWZyZWVfcDJtX3BhZ2UobWlkX21mbik7CisJCWVsc2UKKwkJCXAybV90b3BfbWZuX3BbdG9waWR4XSA9IG1pZF9tZm47CisJfQorCisJaWYgKHAybV90b3BbdG9waWR4XVttaWRpZHhdID09IHAybV9taXNzaW5nKSB7CisJCS8qIHAybSBsZWFmIHBhZ2UgaXMgbWlzc2luZyAqLworCQl1bnNpZ25lZCBsb25nICpwMm07CisKKwkJcDJtID0gYWxsb2NfcDJtX3BhZ2UoKTsKKwkJaWYgKCFwMm0pCisJCQlyZXR1cm4gZmFsc2U7CisKKwkJcDJtX2luaXQocDJtKTsKKworCQlpZiAoY21weGNoZygmbWlkW21pZGlkeF0sIHAybV9taXNzaW5nLCBwMm0pICE9IHAybV9taXNzaW5nKQorCQkJZnJlZV9wMm1fcGFnZShwMm0pOworCQllbHNlCisJCQltaWRfbWZuW21pZGlkeF0gPSB2aXJ0X3RvX21mbihwMm0pOworCX0KKworCXJldHVybiB0cnVlOworfQorCisvKiBUcnkgdG8gaW5zdGFsbCBwMm0gbWFwcGluZzsgZmFpbCBpZiBpbnRlcm1lZGlhdGUgYml0cyBtaXNzaW5nICovCitib29sIF9fc2V0X3BoeXNfdG9fbWFjaGluZSh1bnNpZ25lZCBsb25nIHBmbiwgdW5zaWduZWQgbG9uZyBtZm4pCit7CisJdW5zaWduZWQgdG9waWR4LCBtaWRpZHgsIGlkeDsKKworCWlmICh1bmxpa2VseShwZm4gPj0gTUFYX1AyTV9QRk4pKSB7CisJCUJVR19PTihtZm4gIT0gSU5WQUxJRF9QMk1fRU5UUlkpOworCQlyZXR1cm4gdHJ1ZTsKKwl9CisKKwl0b3BpZHggPSBwMm1fdG9wX2luZGV4KHBmbik7CisJbWlkaWR4ID0gcDJtX21pZF9pbmRleChwZm4pOworCWlkeCA9IHAybV9pbmRleChwZm4pOworCisJaWYgKHAybV90b3BbdG9waWR4XVttaWRpZHhdID09IHAybV9taXNzaW5nKQorCQlyZXR1cm4gbWZuID09IElOVkFMSURfUDJNX0VOVFJZOworCisJcDJtX3RvcFt0b3BpZHhdW21pZGlkeF1baWR4XSA9IG1mbjsKKworCXJldHVybiB0cnVlOworfQorCitib29sIHNldF9waHlzX3RvX21hY2hpbmUodW5zaWduZWQgbG9uZyBwZm4sIHVuc2lnbmVkIGxvbmcgbWZuKQoreworCWlmICh1bmxpa2VseSh4ZW5fZmVhdHVyZShYRU5GRUFUX2F1dG9fdHJhbnNsYXRlZF9waHlzbWFwKSkpIHsKKwkJQlVHX09OKHBmbiAhPSBtZm4gJiYgbWZuICE9IElOVkFMSURfUDJNX0VOVFJZKTsKKwkJcmV0dXJuIHRydWU7CisJfQorCisJaWYgKHVubGlrZWx5KCFfX3NldF9waHlzX3RvX21hY2hpbmUocGZuLCBtZm4pKSkgIHsKKwkJaWYgKCFhbGxvY19wMm0ocGZuKSkKKwkJCXJldHVybiBmYWxzZTsKKworCQlpZiAoIV9fc2V0X3BoeXNfdG9fbWFjaGluZShwZm4sIG1mbikpCisJCQlyZXR1cm4gZmFsc2U7CisJfQorCisJcmV0dXJuIHRydWU7Cit9CisKKyNkZWZpbmUgTTJQX09WRVJSSURFX0hBU0hfU0hJRlQJMTAKKyNkZWZpbmUgTTJQX09WRVJSSURFX0hBU0gJKDEgPDwgTTJQX09WRVJSSURFX0hBU0hfU0hJRlQpCisKK3N0YXRpYyBSRVNFUlZFX0JSS19BUlJBWShzdHJ1Y3QgbGlzdF9oZWFkLCBtMnBfb3ZlcnJpZGVzLCBNMlBfT1ZFUlJJREVfSEFTSCk7CitzdGF0aWMgREVGSU5FX1NQSU5MT0NLKG0ycF9vdmVycmlkZV9sb2NrKTsKKworc3RhdGljIHZvaWQgX19pbml0IG0ycF9vdmVycmlkZV9pbml0KHZvaWQpCit7CisJdW5zaWduZWQgaTsKKworCW0ycF9vdmVycmlkZXMgPSBleHRlbmRfYnJrKHNpemVvZigqbTJwX292ZXJyaWRlcykgKiBNMlBfT1ZFUlJJREVfSEFTSCwKKwkJCQkgICBzaXplb2YodW5zaWduZWQgbG9uZykpOworCisJZm9yIChpID0gMDsgaSA8IE0yUF9PVkVSUklERV9IQVNIOyBpKyspCisJCUlOSVRfTElTVF9IRUFEKCZtMnBfb3ZlcnJpZGVzW2ldKTsKK30KKworc3RhdGljIHVuc2lnbmVkIGxvbmcgbWZuX2hhc2godW5zaWduZWQgbG9uZyBtZm4pCit7CisJcmV0dXJuIGhhc2hfbG9uZyhtZm4sIE0yUF9PVkVSUklERV9IQVNIX1NISUZUKTsKK30KKworLyogQWRkIGFuIE1GTiBvdmVycmlkZSBmb3IgYSBwYXJ0aWN1bGFyIHBhZ2UgKi8KK2ludCBtMnBfYWRkX292ZXJyaWRlKHVuc2lnbmVkIGxvbmcgbWZuLCBzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXVuc2lnbmVkIGxvbmcgcGZuOworCXVuc2lnbmVkIGxvbmcgYWRkcmVzczsKKwl1bnNpZ25lZCBsZXZlbDsKKwlwdGVfdCAqcHRlcCA9IE5VTEw7CisKKwlwZm4gPSBwYWdlX3RvX3BmbihwYWdlKTsKKwlpZiAoIVBhZ2VIaWdoTWVtKHBhZ2UpKSB7CisJCWFkZHJlc3MgPSAodW5zaWduZWQgbG9uZylfX3ZhKHBmbiA8PCBQQUdFX1NISUZUKTsKKwkJcHRlcCA9IGxvb2t1cF9hZGRyZXNzKGFkZHJlc3MsICZsZXZlbCk7CisKKwkJaWYgKFdBUk4ocHRlcCA9PSBOVUxMIHx8IGxldmVsICE9IFBHX0xFVkVMXzRLLAorCQkJCQkibTJwX2FkZF9vdmVycmlkZTogcGZuICVseCBub3QgbWFwcGVkIiwgcGZuKSkKKwkJCXJldHVybiAtRUlOVkFMOworCX0KKworCXBhZ2UtPnByaXZhdGUgPSBtZm47CisJcGFnZS0+aW5kZXggPSBwZm5fdG9fbWZuKHBmbik7CisKKwlfX3NldF9waHlzX3RvX21hY2hpbmUocGZuLCBGT1JFSUdOX0ZSQU1FKG1mbikpOworCWlmICghUGFnZUhpZ2hNZW0ocGFnZSkpCisJCS8qIEp1c3QgemFwIG9sZCBtYXBwaW5nIGZvciBub3cgKi8KKwkJcHRlX2NsZWFyKCZpbml0X21tLCBhZGRyZXNzLCBwdGVwKTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZtMnBfb3ZlcnJpZGVfbG9jaywgZmxhZ3MpOworCWxpc3RfYWRkKCZwYWdlLT5scnUsICAmbTJwX292ZXJyaWRlc1ttZm5faGFzaChtZm4pXSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmbTJwX292ZXJyaWRlX2xvY2ssIGZsYWdzKTsKKworCXJldHVybiAwOworfQorCitpbnQgbTJwX3JlbW92ZV9vdmVycmlkZShzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXVuc2lnbmVkIGxvbmcgbWZuOworCXVuc2lnbmVkIGxvbmcgcGZuOworCXVuc2lnbmVkIGxvbmcgYWRkcmVzczsKKwl1bnNpZ25lZCBsZXZlbDsKKwlwdGVfdCAqcHRlcCA9IE5VTEw7CisKKwlwZm4gPSBwYWdlX3RvX3BmbihwYWdlKTsKKwltZm4gPSBnZXRfcGh5c190b19tYWNoaW5lKHBmbik7CisJaWYgKG1mbiA9PSBJTlZBTElEX1AyTV9FTlRSWSB8fCAhKG1mbiAmIEZPUkVJR05fRlJBTUVfQklUKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoIVBhZ2VIaWdoTWVtKHBhZ2UpKSB7CisJCWFkZHJlc3MgPSAodW5zaWduZWQgbG9uZylfX3ZhKHBmbiA8PCBQQUdFX1NISUZUKTsKKwkJcHRlcCA9IGxvb2t1cF9hZGRyZXNzKGFkZHJlc3MsICZsZXZlbCk7CisKKwkJaWYgKFdBUk4ocHRlcCA9PSBOVUxMIHx8IGxldmVsICE9IFBHX0xFVkVMXzRLLAorCQkJCQkibTJwX3JlbW92ZV9vdmVycmlkZTogcGZuICVseCBub3QgbWFwcGVkIiwgcGZuKSkKKwkJCXJldHVybiAtRUlOVkFMOworCX0KKworCXNwaW5fbG9ja19pcnFzYXZlKCZtMnBfb3ZlcnJpZGVfbG9jaywgZmxhZ3MpOworCWxpc3RfZGVsKCZwYWdlLT5scnUpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm0ycF9vdmVycmlkZV9sb2NrLCBmbGFncyk7CisJX19zZXRfcGh5c190b19tYWNoaW5lKHBmbiwgcGFnZS0+aW5kZXgpOworCisJaWYgKCFQYWdlSGlnaE1lbShwYWdlKSkKKwkJc2V0X3B0ZV9hdCgmaW5pdF9tbSwgYWRkcmVzcywgcHRlcCwKKwkJCQlwZm5fcHRlKHBmbiwgUEFHRV9LRVJORUwpKTsKKwkJLyogTm8gdGxiIGZsdXNoIG5lY2Vzc2FyeSBiZWNhdXNlIHRoZSBjYWxsZXIgYWxyZWFkeQorCQkgKiBsZWZ0IHRoZSBwdGUgdW5tYXBwZWQuICovCisKKwlyZXR1cm4gMDsKK30KKworc3RydWN0IHBhZ2UgKm0ycF9maW5kX292ZXJyaWRlKHVuc2lnbmVkIGxvbmcgbWZuKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJc3RydWN0IGxpc3RfaGVhZCAqYnVja2V0ID0gJm0ycF9vdmVycmlkZXNbbWZuX2hhc2gobWZuKV07CisJc3RydWN0IHBhZ2UgKnAsICpyZXQ7CisKKwlyZXQgPSBOVUxMOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJm0ycF9vdmVycmlkZV9sb2NrLCBmbGFncyk7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHAsIGJ1Y2tldCwgbHJ1KSB7CisJCWlmIChwLT5wcml2YXRlID09IG1mbikgeworCQkJcmV0ID0gcDsKKwkJCWJyZWFrOworCQl9CisJfQorCisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmbTJwX292ZXJyaWRlX2xvY2ssIGZsYWdzKTsKKworCXJldHVybiByZXQ7Cit9CisKK3Vuc2lnbmVkIGxvbmcgbTJwX2ZpbmRfb3ZlcnJpZGVfcGZuKHVuc2lnbmVkIGxvbmcgbWZuLCB1bnNpZ25lZCBsb25nIHBmbikKK3sKKwlzdHJ1Y3QgcGFnZSAqcCA9IG0ycF9maW5kX292ZXJyaWRlKG1mbik7CisJdW5zaWduZWQgbG9uZyByZXQgPSBwZm47CisKKwlpZiAocCkKKwkJcmV0ID0gcGFnZV90b19wZm4ocCk7CisKKwlyZXR1cm4gcmV0OworfQorRVhQT1JUX1NZTUJPTF9HUEwobTJwX2ZpbmRfb3ZlcnJpZGVfcGZuKTsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L3hlbi9zZXR1cC5jIGIvYXJjaC94ODYveGVuL3NldHVwLmMKaW5kZXggYjVhN2Y5Mi4uYThhNjZhNSAxMDA2NDQKLS0tIGEvYXJjaC94ODYveGVuL3NldHVwLmMKKysrIGIvYXJjaC94ODYveGVuL3NldHVwLmMKQEAgLTE3OSw4ICsxNzksMTMgQEAKIAllODIwLm5yX21hcCA9IDA7CiAJeGVuX2V4dHJhX21lbV9zdGFydCA9IG1lbV9lbmQ7CiAJZm9yIChpID0gMDsgaSA8IG1lbW1hcC5ucl9lbnRyaWVzOyBpKyspIHsKLQkJdW5zaWduZWQgbG9uZyBsb25nIGVuZCA9IG1hcFtpXS5hZGRyICsgbWFwW2ldLnNpemU7CisJCXVuc2lnbmVkIGxvbmcgbG9uZyBlbmQ7CiAKKwkJLyogR3VhcmQgYWdhaW5zdCBub24tcGFnZSBhbGlnbmVkIEU4MjAgZW50cmllcy4gKi8KKwkJaWYgKG1hcFtpXS50eXBlID09IEU4MjBfUkFNKQorCQkJbWFwW2ldLnNpemUgLT0gKG1hcFtpXS5zaXplICsgbWFwW2ldLmFkZHIpICUgUEFHRV9TSVpFOworCisJCWVuZCA9IG1hcFtpXS5hZGRyICsgbWFwW2ldLnNpemU7CiAJCWlmIChtYXBbaV0udHlwZSA9PSBFODIwX1JBTSAmJiBlbmQgPiBtZW1fZW5kKSB7CiAJCQkvKiBSQU0gb2ZmIHRoZSBlbmQgLSBtYXkgYmUgcGFydGlhbGx5IGluY2x1ZGVkICovCiAJCQl1NjQgZGVsdGEgPSBtaW4obWFwW2ldLnNpemUsIGVuZCAtIG1lbV9lbmQpOwpAQCAtMzUwLDYgKzM1NSw3IEBACiAJYm9vdF9jcHVfZGF0YS5obHRfd29ya3Nfb2sgPSAxOwogI2VuZGlmCiAJcG1faWRsZSA9IGRlZmF1bHRfaWRsZTsKKwlib290X29wdGlvbl9pZGxlX292ZXJyaWRlID0gSURMRV9IQUxUOwogCiAJZmlkZGxlX3Zkc28oKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gveHRlbnNhL2NvbmZpZ3MvY29tbW9uX2RlZmNvbmZpZyBiL2FyY2gveHRlbnNhL2NvbmZpZ3MvY29tbW9uX2RlZmNvbmZpZwppbmRleCAxZDIzMGVlLi5iOTAwMzhlIDEwMDY0NAotLS0gYS9hcmNoL3h0ZW5zYS9jb25maWdzL2NvbW1vbl9kZWZjb25maWcKKysrIGIvYXJjaC94dGVuc2EvY29uZmlncy9jb21tb25fZGVmY29uZmlnCkBAIC0zMiw3ICszMiw3IEBACiAjIENPTkZJR19IT1RQTFVHIGlzIG5vdCBzZXQKIENPTkZJR19LT0JKRUNUX1VFVkVOVD15CiAjIENPTkZJR19JS0NPTkZJRyBpcyBub3Qgc2V0Ci0jIENPTkZJR19FTUJFRERFRCBpcyBub3Qgc2V0CisjIENPTkZJR19FWFBFUlQgaXMgbm90IHNldAogQ09ORklHX0tBTExTWU1TPXkKICMgQ09ORklHX0tBTExTWU1TX0FMTCBpcyBub3Qgc2V0CiAjIENPTkZJR19LQUxMU1lNU19FWFRSQV9QQVNTIGlzIG5vdCBzZXQKZGlmZiAtLWdpdCBhL2FyY2gveHRlbnNhL2NvbmZpZ3MvaXNzX2RlZmNvbmZpZyBiL2FyY2gveHRlbnNhL2NvbmZpZ3MvaXNzX2RlZmNvbmZpZwppbmRleCA3MzY4MTY0Li4wMjM0Y2QxIDEwMDY0NAotLS0gYS9hcmNoL3h0ZW5zYS9jb25maWdzL2lzc19kZWZjb25maWcKKysrIGIvYXJjaC94dGVuc2EvY29uZmlncy9pc3NfZGVmY29uZmlnCkBAIC01NSw3ICs1NSw3IEBACiAjIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfU0laRSBpcyBub3Qgc2V0CiBDT05GSUdfU1lTQ1RMPXkKIENPTkZJR19BTk9OX0lOT0RFUz15Ci1DT05GSUdfRU1CRURERUQ9eQorQ09ORklHX0VYUEVSVD15CiBDT05GSUdfU1lTQ1RMX1NZU0NBTEw9eQogQ09ORklHX0tBTExTWU1TPXkKICMgQ09ORklHX0tBTExTWU1TX0FMTCBpcyBub3Qgc2V0CmRpZmYgLS1naXQgYS9hcmNoL3h0ZW5zYS9jb25maWdzL3M2MTA1X2RlZmNvbmZpZyBiL2FyY2gveHRlbnNhL2NvbmZpZ3MvczYxMDVfZGVmY29uZmlnCmluZGV4IDUzMzRmMjMuLjQyYjdmZWIgMTAwNjQ0Ci0tLSBhL2FyY2gveHRlbnNhL2NvbmZpZ3MvczYxMDVfZGVmY29uZmlnCisrKyBiL2FyY2gveHRlbnNhL2NvbmZpZ3MvczYxMDVfZGVmY29uZmlnCkBAIC01NSw3ICs1NSw3IEBACiBDT05GSUdfSU5JVFJBTUZTX1NPVVJDRT0iIgogQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFPXkKIENPTkZJR19TWVNDVEw9eQotQ09ORklHX0VNQkVEREVEPXkKK0NPTkZJR19FWFBFUlQ9eQogQ09ORklHX1NZU0NUTF9TWVNDQUxMPXkKIENPTkZJR19LQUxMU1lNUz15CiAjIENPTkZJR19LQUxMU1lNU19BTEwgaXMgbm90IHNldApkaWZmIC0tZ2l0IGEvYXJjaC94dGVuc2EvaW5jbHVkZS9hc20vbW1hbi5oIGIvYXJjaC94dGVuc2EvaW5jbHVkZS9hc20vbW1hbi5oCmluZGV4IGZjYTRkYjQuLjMwNzg5MDEgMTAwNjQ0Ci0tLSBhL2FyY2gveHRlbnNhL2luY2x1ZGUvYXNtL21tYW4uaAorKysgYi9hcmNoL3h0ZW5zYS9pbmNsdWRlL2FzbS9tbWFuLmgKQEAgLTgzLDYgKzgzLDkgQEAKICNkZWZpbmUgTUFEVl9NRVJHRUFCTEUgICAxMgkJLyogS1NNIG1heSBtZXJnZSBpZGVudGljYWwgcGFnZXMgKi8KICNkZWZpbmUgTUFEVl9VTk1FUkdFQUJMRSAxMwkJLyogS1NNIG1heSBub3QgbWVyZ2UgaWRlbnRpY2FsIHBhZ2VzICovCiAKKyNkZWZpbmUgTUFEVl9IVUdFUEFHRQkxNAkJLyogV29ydGggYmFja2luZyB3aXRoIGh1Z2VwYWdlcyAqLworI2RlZmluZSBNQURWX05PSFVHRVBBR0UJMTUJCS8qIE5vdCB3b3J0aCBiYWNraW5nIHdpdGggaHVnZXBhZ2VzICovCisKIC8qIGNvbXBhdGliaWxpdHkgZmxhZ3MgKi8KICNkZWZpbmUgTUFQX0ZJTEUJMAogCmRpZmYgLS1naXQgYS9ibG9jay9LY29uZmlnIGIvYmxvY2svS2NvbmZpZwppbmRleCA2YzkyMTNlLi42MGJlMWUwIDEwMDY0NAotLS0gYS9ibG9jay9LY29uZmlnCisrKyBiL2Jsb2NrL0tjb25maWcKQEAgLTIsNyArMiw3IEBACiAjIEJsb2NrIGxheWVyIGNvcmUgY29uZmlndXJhdGlvbgogIwogbWVudWNvbmZpZyBCTE9DSwotICAgICAgIGJvb2wgIkVuYWJsZSB0aGUgYmxvY2sgbGF5ZXIiIGlmIEVNQkVEREVECisgICAgICAgYm9vbCAiRW5hYmxlIHRoZSBibG9jayBsYXllciIgaWYgRVhQRVJUCiAgICAgICAgZGVmYXVsdCB5CiAgICAgICAgaGVscAogCSBQcm92aWRlIGJsb2NrIGxheWVyIHN1cHBvcnQgZm9yIHRoZSBrZXJuZWwuCmRpZmYgLS1naXQgYS9ibG9jay9ibGstdGhyb3R0bGUuYyBiL2Jsb2NrL2Jsay10aHJvdHRsZS5jCmluZGV4IDM4MWIwOWIuLmE4OTA0M2EgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2Jsay10aHJvdHRsZS5jCisrKyBiL2Jsb2NrL2Jsay10aHJvdHRsZS5jCkBAIC0xNjgsNyArMTY4LDE1IEBACiAJICogdHJlZSBvZiBibGtnIChpbnN0ZWFkIG9mIHRyYXZlcnNpbmcgdGhyb3VnaCBoYXNoIGxpc3QgYWxsCiAJICogdGhlIHRpbWUuCiAJICovCi0JdGcgPSB0Z19vZl9ibGtnKGJsa2lvY2dfbG9va3VwX2dyb3VwKGJsa2NnLCBrZXkpKTsKKworCS8qCisJICogVGhpcyBpcyB0aGUgY29tbW9uIGNhc2Ugd2hlbiB0aGVyZSBhcmUgbm8gYmxraW8gY2dyb3Vwcy4KKyAJICogQXZvaWQgbG9va3VwIGluIHRoaXMgY2FzZQorIAkgKi8KKwlpZiAoYmxrY2cgPT0gJmJsa2lvX3Jvb3RfY2dyb3VwKQorCQl0ZyA9ICZ0ZC0+cm9vdF90ZzsKKwllbHNlCisJCXRnID0gdGdfb2ZfYmxrZyhibGtpb2NnX2xvb2t1cF9ncm91cChibGtjZywga2V5KSk7CiAKIAkvKiBGaWxsIGluIGRldmljZSBkZXRhaWxzIGZvciByb290IGdyb3VwICovCiAJaWYgKHRnICYmICF0Zy0+YmxrZy5kZXYgJiYgYmRpLT5kZXYgJiYgZGV2X25hbWUoYmRpLT5kZXYpKSB7CmRpZmYgLS1naXQgYS9ibG9jay9jZnEtaW9zY2hlZC5jIGIvYmxvY2svY2ZxLWlvc2NoZWQuYwppbmRleCA4NDI3Njk3Li43YmU0Yzc5IDEwMDY0NAotLS0gYS9ibG9jay9jZnEtaW9zY2hlZC5jCisrKyBiL2Jsb2NrL2NmcS1pb3NjaGVkLmMKQEAgLTU5OCw4ICs1OTgsOCBAQAogCXJldHVybiBjZnFfdGFyZ2V0X2xhdGVuY3kgKiBjZnFnLT53ZWlnaHQgLyBzdC0+dG90YWxfd2VpZ2h0OwogfQogCi1zdGF0aWMgaW5saW5lIHZvaWQKLWNmcV9zZXRfcHJpb19zbGljZShzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQsIHN0cnVjdCBjZnFfcXVldWUgKmNmcXEpCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkCitjZnFfc2NhbGVkX2NmcXFfc2xpY2Uoc3RydWN0IGNmcV9kYXRhICpjZnFkLCBzdHJ1Y3QgY2ZxX3F1ZXVlICpjZnFxKQogewogCXVuc2lnbmVkIHNsaWNlID0gY2ZxX3ByaW9fdG9fc2xpY2UoY2ZxZCwgY2ZxcSk7CiAJaWYgKGNmcWQtPmNmcV9sYXRlbmN5KSB7CkBAIC02MjUsNiArNjI1LDE0IEBACiAJCQkJICAgIGxvd19zbGljZSk7CiAJCX0KIAl9CisJcmV0dXJuIHNsaWNlOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK2NmcV9zZXRfcHJpb19zbGljZShzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQsIHN0cnVjdCBjZnFfcXVldWUgKmNmcXEpCit7CisJdW5zaWduZWQgc2xpY2UgPSBjZnFfc2NhbGVkX2NmcXFfc2xpY2UoY2ZxZCwgY2ZxcSk7CisKIAljZnFxLT5zbGljZV9zdGFydCA9IGppZmZpZXM7CiAJY2ZxcS0+c2xpY2VfZW5kID0gamlmZmllcyArIHNsaWNlOwogCWNmcXEtPmFsbG9jYXRlZF9zbGljZSA9IHNsaWNlOwpAQCAtMTY2MSw4ICsxNjY5LDExIEBACiAJLyoKIAkgKiBzdG9yZSB3aGF0IHdhcyBsZWZ0IG9mIHRoaXMgc2xpY2UsIGlmIHRoZSBxdWV1ZSBpZGxlZC90aW1lZCBvdXQKIAkgKi8KLQlpZiAodGltZWRfb3V0ICYmICFjZnFfY2ZxcV9zbGljZV9uZXcoY2ZxcSkpIHsKLQkJY2ZxcS0+c2xpY2VfcmVzaWQgPSBjZnFxLT5zbGljZV9lbmQgLSBqaWZmaWVzOworCWlmICh0aW1lZF9vdXQpIHsKKwkJaWYgKGNmcV9jZnFxX3NsaWNlX25ldyhjZnFxKSkKKwkJCWNmcXEtPnNsaWNlX3Jlc2lkID0gY2ZxX3NjYWxlZF9jZnFxX3NsaWNlKGNmcWQsIGNmcXEpOworCQllbHNlCisJCQljZnFxLT5zbGljZV9yZXNpZCA9IGNmcXEtPnNsaWNlX2VuZCAtIGppZmZpZXM7CiAJCWNmcV9sb2dfY2ZxcShjZnFkLCBjZnFxLCAicmVzaWQ9JWxkIiwgY2ZxcS0+c2xpY2VfcmVzaWQpOwogCX0KIApAQCAtMzI4NCwxMCArMzI5NSwxOSBAQAogICovCiBzdGF0aWMgdm9pZCBjZnFfcHJlZW1wdF9xdWV1ZShzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQsIHN0cnVjdCBjZnFfcXVldWUgKmNmcXEpCiB7CisJc3RydWN0IGNmcV9xdWV1ZSAqb2xkX2NmcXEgPSBjZnFkLT5hY3RpdmVfcXVldWU7CisKIAljZnFfbG9nX2NmcXEoY2ZxZCwgY2ZxcSwgInByZWVtcHQiKTsKIAljZnFfc2xpY2VfZXhwaXJlZChjZnFkLCAxKTsKIAogCS8qCisJICogd29ya2xvYWQgdHlwZSBpcyBjaGFuZ2VkLCBkb24ndCBzYXZlIHNsaWNlLCBvdGhlcndpc2UgcHJlZW1wdAorCSAqIGRvZXNuJ3QgaGFwcGVuCisJICovCisJaWYgKGNmcXFfdHlwZShvbGRfY2ZxcSkgIT0gY2ZxcV90eXBlKGNmcXEpKQorCQljZnFxLT5jZnFnLT5zYXZlZF93b3JrbG9hZF9zbGljZSA9IDA7CisKKwkvKgogCSAqIFB1dCB0aGUgbmV3IHF1ZXVlIGF0IHRoZSBmcm9udCBvZiB0aGUgb2YgdGhlIGN1cnJlbnQgbGlzdCwKIAkgKiBzbyB3ZSBrbm93IHRoYXQgaXQgd2lsbCBiZSBzZWxlY3RlZCBuZXh0LgogCSAqLwpAQCAtMzQxMiw2ICszNDMyLDEwIEBACiB7CiAJc3RydWN0IGNmcV9pb19jb250ZXh0ICpjaWMgPSBjZnFkLT5hY3RpdmVfY2ljOwogCisJLyogSWYgdGhlIHF1ZXVlIGFscmVhZHkgaGFzIHJlcXVlc3RzLCBkb24ndCB3YWl0ICovCisJaWYgKCFSQl9FTVBUWV9ST09UKCZjZnFxLT5zb3J0X2xpc3QpKQorCQlyZXR1cm4gZmFsc2U7CisKIAkvKiBJZiB0aGVyZSBhcmUgb3RoZXIgcXVldWVzIGluIHRoZSBncm91cCwgZG9uJ3Qgd2FpdCAqLwogCWlmIChjZnFxLT5jZnFnLT5ucl9jZnFxID4gMSkKIAkJcmV0dXJuIGZhbHNlOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9LY29uZmlnIGIvZHJpdmVycy9LY29uZmlnCmluZGV4IGRkMGE1YjUuLjliZmI3MWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvS2NvbmZpZworKysgYi9kcml2ZXJzL0tjb25maWcKQEAgLTI2LDYgKzI2LDggQEAKIAogc291cmNlICJkcml2ZXJzL21kL0tjb25maWciCiAKK3NvdXJjZSAiZHJpdmVycy90YXJnZXQvS2NvbmZpZyIKKwogc291cmNlICJkcml2ZXJzL21lc3NhZ2UvZnVzaW9uL0tjb25maWciCiAKIHNvdXJjZSAiZHJpdmVycy9maXJld2lyZS9LY29uZmlnIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9NYWtlZmlsZSBiL2RyaXZlcnMvTWFrZWZpbGUKaW5kZXggZWY1MTMyNC4uYjQyM2JiMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9NYWtlZmlsZQorKysgYi9kcml2ZXJzL01ha2VmaWxlCkBAIC0yNCw3ICsyNCw3IEBACiAjIHJlZ3VsYXRvcnMgZWFybHksIHNpbmNlIHNvbWUgc3Vic3lzdGVtcyByZWx5IG9uIHRoZW0gdG8gaW5pdGlhbGl6ZQogb2JqLSQoQ09ORklHX1JFR1VMQVRPUikJCSs9IHJlZ3VsYXRvci8KIAotIyBjaGFyLyBjb21lcyBiZWZvcmUgc2VyaWFsLyBldGMgc28gdGhhdCB0aGUgVlQgY29uc29sZSBpcyB0aGUgYm9vdC10aW1lCisjIHR0eS8gY29tZXMgYmVmb3JlIGNoYXIvIHNvIHRoYXQgdGhlIFZUIGNvbnNvbGUgaXMgdGhlIGJvb3QtdGltZQogIyBkZWZhdWx0Lgogb2JqLXkJCQkJKz0gdHR5Lwogb2JqLXkJCQkJKz0gY2hhci8KQEAgLTM4LDcgKzM4LDYgQEAKIG9iai0kKENPTkZJR19GQl9JODEwKSAgICAgICAgICAgKz0gdmlkZW8vaTgxMC8KIG9iai0kKENPTkZJR19GQl9JTlRFTCkgICAgICAgICAgKz0gdmlkZW8vaW50ZWxmYi8KIAotb2JqLXkJCQkJKz0gc2VyaWFsLwogb2JqLSQoQ09ORklHX1BBUlBPUlQpCQkrPSBwYXJwb3J0Lwogb2JqLXkJCQkJKz0gYmFzZS8gYmxvY2svIG1pc2MvIG1mZC8gbmZjLwogb2JqLSQoQ09ORklHX05VQlVTKQkJKz0gbnVidXMvCkBAIC00Niw2ICs0NSw3IEBACiBvYmotJChDT05GSUdfSURFKQkJKz0gaWRlLwogb2JqLSQoQ09ORklHX1NDU0kpCQkrPSBzY3NpLwogb2JqLSQoQ09ORklHX0FUQSkJCSs9IGF0YS8KK29iai0kKENPTkZJR19UQVJHRVRfQ09SRSkJKz0gdGFyZ2V0Lwogb2JqLSQoQ09ORklHX01URCkJCSs9IG10ZC8KIG9iai0kKENPTkZJR19TUEkpCQkrPSBzcGkvCiBvYmoteQkJCQkrPSBuZXQvCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvS2NvbmZpZyBiL2RyaXZlcnMvYWNwaS9LY29uZmlnCmluZGV4IDNmMzQ4OWMuLjJhYTA0MmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9LY29uZmlnCisrKyBiL2RyaXZlcnMvYWNwaS9LY29uZmlnCkBAIC01MSwxMiArNTEsNyBAQAogCSAgRm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LCB0aGlzIG9wdGlvbiBhbGxvd3MKIAkgIGRlcHJlY2F0ZWQgL3Byb2MvYWNwaS8gZmlsZXMgdG8gZXhpc3QsIGV2ZW4gd2hlbgogCSAgdGhleSBoYXZlIGJlZW4gcmVwbGFjZWQgYnkgZnVuY3Rpb25zIGluIC9zeXMuCi0JICBUaGUgZGVwcmVjYXRlZCBmaWxlcyAoYW5kIHRoZWlyIHJlcGxhY2VtZW50cykgaW5jbHVkZToKIAotCSAgL3Byb2MvYWNwaS9wcm9jZXNzb3IvKi90aHJvdHRsaW5nICgvc3lzL2NsYXNzL3RoZXJtYWwvCi0JCWNvb2xpbmdfZGV2aWNlKi8qKQotCSAgL3Byb2MvYWNwaS92aWRlby8qL2JyaWdodG5lc3MgKC9zeXMvY2xhc3MvYmFja2xpZ2h0LykKLQkgIC9wcm9jL2FjcGkvdGhlcm1hbF96b25lLyovKiAoL3N5cy9jbGFzcy90aGVybWFsLykKIAkgIFRoaXMgb3B0aW9uIGhhcyBubyBlZmZlY3Qgb24gL3Byb2MvYWNwaS8gZmlsZXMKIAkgIGFuZCBmdW5jdGlvbnMgd2hpY2ggZG8gbm90IHlldCBleGlzdCBpbiAvc3lzLgogCkBAIC03NCw2ICs2OSw4IEBACiAJICAvcHJvYy9hY3BpL2FjX2FkYXB0ZXIvKiAoc3lzL2NsYXNzL3Bvd2VyX3N1cHBseS8qKQogCSAgVGhpcyBvcHRpb24gaGFzIG5vIGVmZmVjdCBvbiAvcHJvYy9hY3BpLyBkaXJlY3RvcmllcwogCSAgYW5kIGZ1bmN0aW9ucywgd2hpY2ggZG8gbm90IHlldCBleGlzdCBpbiAvc3lzCisJICBUaGlzIG9wdGlvbiwgdG9nZXRoZXIgd2l0aCB0aGUgcHJvYyBkaXJlY3Rvcmllcywgd2lsbCBiZQorCSAgZGVsZXRlZCBpbiAyLjYuMzkuCiAKIAkgIFNheSBOIHRvIGRlbGV0ZSBwb3dlciAvcHJvYy9hY3BpLyBkaXJlY3RvcmllcyB0aGF0IGhhdmUgbW92ZWQgdG8gL3N5cy8KIApAQCAtMjA5LDYgKzIwNiwxNyBAQAogCiAJICBUbyBjb21waWxlIHRoaXMgZHJpdmVyIGFzIGEgbW9kdWxlLCBjaG9vc2UgTSBoZXJlOgogCSAgdGhlIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCBwcm9jZXNzb3IuCitjb25maWcgQUNQSV9JUE1JCisJdHJpc3RhdGUgIklQTUkiCisJZGVwZW5kcyBvbiBFWFBFUklNRU5UQUwgJiYgSVBNSV9TSSAmJiBJUE1JX0hBTkRMRVIKKwlkZWZhdWx0IG4KKwloZWxwCisJICBUaGlzIGRyaXZlciBlbmFibGVzIHRoZSBBQ1BJIHRvIGFjY2VzcyB0aGUgQk1DIGNvbnRyb2xsZXIuIEFuZCBpdAorCSAgdXNlcyB0aGUgSVBNSSByZXF1ZXN0L3Jlc3BvbnNlIG1lc3NhZ2UgdG8gY29tbXVuaWNhdGUgd2l0aCBCTUMKKwkgIGNvbnRyb2xsZXIsIHdoaWNoIGNhbiBiZSBmb3VuZCBvbiBvbiB0aGUgc2VydmVyLgorCisJICBUbyBjb21waWxlIHRoaXMgZHJpdmVyIGFzIGEgbW9kdWxlLCBjaG9vc2UgTSBoZXJlOgorCSAgdGhlIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCBhcyBhY3BpX2lwbWkuCiAKIGNvbmZpZyBBQ1BJX0hPVFBMVUdfQ1BVCiAJYm9vbApAQCAtMzEwLDcgKzMxOCw3IEBACiAJICB0aGUgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIHBjaV9zbG90LgogCiBjb25maWcgWDg2X1BNX1RJTUVSCi0JYm9vbCAiUG93ZXIgTWFuYWdlbWVudCBUaW1lciBTdXBwb3J0IiBpZiBFTUJFRERFRAorCWJvb2wgIlBvd2VyIE1hbmFnZW1lbnQgVGltZXIgU3VwcG9ydCIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBYODYKIAlkZWZhdWx0IHkKIAloZWxwCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvTWFrZWZpbGUgYi9kcml2ZXJzL2FjcGkvTWFrZWZpbGUKaW5kZXggM2QwMzFkMC4uZDExM2ZhNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvYWNwaS9NYWtlZmlsZQpAQCAtMjQsNyArMjQsNyBAQAogIyBzbGVlcCByZWxhdGVkIGZpbGVzCiBhY3BpLXkJCQkJKz0gd2FrZXVwLm8KIGFjcGkteQkJCQkrPSBzbGVlcC5vCi1hY3BpLSQoQ09ORklHX0FDUElfU0xFRVApCSs9IHByb2MubworYWNwaS0kKENPTkZJR19BQ1BJX1NMRUVQKQkrPSBwcm9jLm8gbnZzLm8KIAogCiAjCkBAIC02OSw1ICs2OSw2IEBACiBwcm9jZXNzb3ItJChDT05GSUdfQ1BVX0ZSRVEpCSs9IHByb2Nlc3Nvcl9wZXJmbGliLm8KIAogb2JqLSQoQ09ORklHX0FDUElfUFJPQ0VTU09SX0FHR1JFR0FUT1IpICs9IGFjcGlfcGFkLm8KK29iai0kKENPTkZJR19BQ1BJX0lQTUkpCQkrPSBhY3BpX2lwbWkubwogCiBvYmotJChDT05GSUdfQUNQSV9BUEVJKQkJKz0gYXBlaS8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hYy5jIGIvZHJpdmVycy9hY3BpL2FjLmMKaW5kZXggMjVkM2FhZS4uNThjM2Y3NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjLmMKQEAgLTE5Nyw3ICsxOTcsOCBAQAogewogCXN0cnVjdCBwcm9jX2Rpcl9lbnRyeSAqZW50cnkgPSBOVUxMOwogCi0KKwlwcmludGsoS0VSTl9XQVJOSU5HIFBSRUZJWCAiRGVwcmVjYXRlZCBwcm9jZnMgSS9GIGZvciBBQyBpcyBsb2FkZWQsIgorCQkJIiBwbGVhc2UgcmV0cnkgd2l0aCBDT05GSUdfQUNQSV9QUk9DRlNfUE9XRVIgY2xlYXJlZFxuIik7CiAJaWYgKCFhY3BpX2RldmljZV9kaXIoZGV2aWNlKSkgewogCQlhY3BpX2RldmljZV9kaXIoZGV2aWNlKSA9IHByb2NfbWtkaXIoYWNwaV9kZXZpY2VfYmlkKGRldmljZSksCiAJCQkJCQkgICAgIGFjcGlfYWNfZGlyKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpX2lwbWkuYyBiL2RyaXZlcnMvYWNwaS9hY3BpX2lwbWkuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mNDBhY2VmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9hY3BpL2FjcGlfaXBtaS5jCkBAIC0wLDAgKzEsNTI1IEBACisvKgorICogIGFjcGlfaXBtaS5jIC0gQUNQSSBJUE1JIG9wcmVnaW9uCisgKgorICogIENvcHlyaWdodCAoQykgMjAxMCBJbnRlbCBDb3Jwb3JhdGlvbgorICogIENvcHlyaWdodCAoQykgMjAxMCBaaGFvIFlha3VpIDx5YWt1aS56aGFvQGludGVsLmNvbT4KKyAqCisgKiB+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0CisgKiAgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiAgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhbG9uZworICogIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCisgKiAgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNyBVU0EuCisgKgorICogfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKyAqLworCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9wcm9jX2ZzLmg+CisjaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9saXN0Lmg+CisjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KKyNpbmNsdWRlIDxsaW51eC9pby5oPgorI2luY2x1ZGUgPGFjcGkvYWNwaV9idXMuaD4KKyNpbmNsdWRlIDxhY3BpL2FjcGlfZHJpdmVycy5oPgorI2luY2x1ZGUgPGxpbnV4L2lwbWkuaD4KKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9wbnAuaD4KKworTU9EVUxFX0FVVEhPUigiWmhhbyBZYWt1aSIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJBQ1BJIElQTUkgT3ByZWdpb24gZHJpdmVyIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CisKKyNkZWZpbmUgSVBNSV9GTEFHU19IQU5ETEVSX0lOU1RBTEwJMAorCisjZGVmaW5lIEFDUElfSVBNSV9PSwkJCTAKKyNkZWZpbmUgQUNQSV9JUE1JX1RJTUVPVVQJCTB4MTAKKyNkZWZpbmUgQUNQSV9JUE1JX1VOS05PV04JCTB4MDcKKy8qIHRoZSBJUE1JIHRpbWVvdXQgaXMgNXMgKi8KKyNkZWZpbmUgSVBNSV9USU1FT1VUCQkJKDUgKiBIWikKKworc3RydWN0IGFjcGlfaXBtaV9kZXZpY2UgeworCS8qIHRoZSBkZXZpY2UgbGlzdCBhdHRhY2hlZCB0byBkcml2ZXJfZGF0YS5pcG1pX2RldmljZXMgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIGhlYWQ7CisJLyogdGhlIElQTUkgcmVxdWVzdCBtZXNzYWdlIGxpc3QgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIHR4X21zZ19saXN0OworCXN0cnVjdCBtdXRleAl0eF9tc2dfbG9jazsKKwlhY3BpX2hhbmRsZSBoYW5kbGU7CisJc3RydWN0IHBucF9kZXYgKnBucF9kZXY7CisJaXBtaV91c2VyX3QJdXNlcl9pbnRlcmZhY2U7CisJaW50IGlwbWlfaWZudW07IC8qIElQTUkgaW50ZXJmYWNlIG51bWJlciAqLworCWxvbmcgY3Vycl9tc2dpZDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXN0cnVjdCBpcG1pX3NtaV9pbmZvIHNtaV9kYXRhOworfTsKKworc3RydWN0IGlwbWlfZHJpdmVyX2RhdGEgeworCXN0cnVjdCBsaXN0X2hlYWQJaXBtaV9kZXZpY2VzOworCXN0cnVjdCBpcG1pX3NtaV93YXRjaGVyCWJtY19ldmVudHM7CisJc3RydWN0IGlwbWlfdXNlcl9obmRsCWlwbWlfaG5kbHJzOworCXN0cnVjdCBtdXRleAkJaXBtaV9sb2NrOworfTsKKworc3RydWN0IGFjcGlfaXBtaV9tc2cgeworCXN0cnVjdCBsaXN0X2hlYWQgaGVhZDsKKwkvKgorCSAqIEdlbmVyYWwgc3BlYWtpbmcgdGhlIGFkZHIgdHlwZSBzaG91bGQgYmUgU0lfQUREUl9UWVBFLiBBbmQKKwkgKiB0aGUgYWRkciBjaGFubmVsIHNob3VsZCBiZSBCTUMuCisJICogSW4gZmFjdCBpdCBjYW4gYWxzbyBiZSBJUE1CIHR5cGUuIEJ1dCB3ZSB3aWxsIGhhdmUgdG8KKwkgKiBwYXJzZSBpdCBmcm9tIHRoZSBOZXRmbiBjb21tYW5kIGJ1ZmZlci4gSXQgaXMgc28gY29tcGxleAorCSAqIHRoYXQgaXQgaXMgc2tpcHBlZC4KKwkgKi8KKwlzdHJ1Y3QgaXBtaV9hZGRyIGFkZHI7CisJbG9uZyB0eF9tc2dpZDsKKwkvKiBpdCBpcyB1c2VkIHRvIHRyYWNrIHdoZXRoZXIgdGhlIElQTUkgbWVzc2FnZSBpcyBmaW5pc2hlZCAqLworCXN0cnVjdCBjb21wbGV0aW9uIHR4X2NvbXBsZXRlOworCXN0cnVjdCBrZXJuZWxfaXBtaV9tc2cgdHhfbWVzc2FnZTsKKwlpbnQJbXNnX2RvbmU7CisJLyogdHggZGF0YSAuIEFuZCBjb3B5IGl0IGZyb20gQUNQSSBvYmplY3QgYnVmZmVyICovCisJdTgJdHhfZGF0YVs2NF07CisJaW50CXR4X2xlbjsKKwl1OAlyeF9kYXRhWzY0XTsKKwlpbnQJcnhfbGVuOworCXN0cnVjdCBhY3BpX2lwbWlfZGV2aWNlICpkZXZpY2U7Cit9OworCisvKiBJUE1JIHJlcXVlc3QvcmVzcG9uc2UgYnVmZmVyIHBlciBBQ1BJIDQuMCwgc2VjIDUuNS4yLjQuMy4yICovCitzdHJ1Y3QgYWNwaV9pcG1pX2J1ZmZlciB7CisJdTggc3RhdHVzOworCXU4IGxlbmd0aDsKKwl1OCBkYXRhWzY0XTsKK307CisKK3N0YXRpYyB2b2lkIGlwbWlfcmVnaXN0ZXJfYm1jKGludCBpZmFjZSwgc3RydWN0IGRldmljZSAqZGV2KTsKK3N0YXRpYyB2b2lkIGlwbWlfYm1jX2dvbmUoaW50IGlmYWNlKTsKK3N0YXRpYyB2b2lkIGlwbWlfbXNnX2hhbmRsZXIoc3RydWN0IGlwbWlfcmVjdl9tc2cgKm1zZywgdm9pZCAqdXNlcl9tc2dfZGF0YSk7CitzdGF0aWMgdm9pZCBhY3BpX2FkZF9pcG1pX2RldmljZShzdHJ1Y3QgYWNwaV9pcG1pX2RldmljZSAqaXBtaV9kZXZpY2UpOworc3RhdGljIHZvaWQgYWNwaV9yZW1vdmVfaXBtaV9kZXZpY2Uoc3RydWN0IGFjcGlfaXBtaV9kZXZpY2UgKmlwbWlfZGV2aWNlKTsKKworc3RhdGljIHN0cnVjdCBpcG1pX2RyaXZlcl9kYXRhIGRyaXZlcl9kYXRhID0geworCS5pcG1pX2RldmljZXMgPSBMSVNUX0hFQURfSU5JVChkcml2ZXJfZGF0YS5pcG1pX2RldmljZXMpLAorCS5ibWNfZXZlbnRzID0geworCQkub3duZXIgPSBUSElTX01PRFVMRSwKKwkJLm5ld19zbWkgPSBpcG1pX3JlZ2lzdGVyX2JtYywKKwkJLnNtaV9nb25lID0gaXBtaV9ibWNfZ29uZSwKKwl9LAorCS5pcG1pX2huZGxycyA9IHsKKwkJLmlwbWlfcmVjdl9obmRsID0gaXBtaV9tc2dfaGFuZGxlciwKKwl9LAorfTsKKworc3RhdGljIHN0cnVjdCBhY3BpX2lwbWlfbXNnICphY3BpX2FsbG9jX2lwbWlfbXNnKHN0cnVjdCBhY3BpX2lwbWlfZGV2aWNlICppcG1pKQoreworCXN0cnVjdCBhY3BpX2lwbWlfbXNnICppcG1pX21zZzsKKwlzdHJ1Y3QgcG5wX2RldiAqcG5wX2RldiA9IGlwbWktPnBucF9kZXY7CisKKwlpcG1pX21zZyA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBhY3BpX2lwbWlfbXNnKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFpcG1pX21zZykJeworCQlkZXZfd2FybigmcG5wX2Rldi0+ZGV2LCAiQ2FuJ3QgYWxsb2NhdGUgbWVtb3J5IGZvciBpcG1pX21zZ1xuIik7CisJCXJldHVybiBOVUxMOworCX0KKwlpbml0X2NvbXBsZXRpb24oJmlwbWlfbXNnLT50eF9jb21wbGV0ZSk7CisJSU5JVF9MSVNUX0hFQUQoJmlwbWlfbXNnLT5oZWFkKTsKKwlpcG1pX21zZy0+ZGV2aWNlID0gaXBtaTsKKwlyZXR1cm4gaXBtaV9tc2c7Cit9CisKKyNkZWZpbmUJCUlQTUlfT1BfUkdOX05FVEZOKG9mZnNldCkJKChvZmZzZXQgPj4gOCkgJiAweGZmKQorI2RlZmluZQkJSVBNSV9PUF9SR05fQ01EKG9mZnNldCkJCShvZmZzZXQgJiAweGZmKQorc3RhdGljIHZvaWQgYWNwaV9mb3JtYXRfaXBtaV9tc2coc3RydWN0IGFjcGlfaXBtaV9tc2cgKnR4X21zZywKKwkJCQlhY3BpX3BoeXNpY2FsX2FkZHJlc3MgYWRkcmVzcywKKwkJCQlhY3BpX2ludGVnZXIgKnZhbHVlKQoreworCXN0cnVjdCBrZXJuZWxfaXBtaV9tc2cgKm1zZzsKKwlzdHJ1Y3QgYWNwaV9pcG1pX2J1ZmZlciAqYnVmZmVyOworCXN0cnVjdCBhY3BpX2lwbWlfZGV2aWNlICpkZXZpY2U7CisKKwltc2cgPSAmdHhfbXNnLT50eF9tZXNzYWdlOworCS8qCisJICogSVBNSSBuZXR3b3JrIGZ1bmN0aW9uIGFuZCBjb21tYW5kIGFyZSBlbmNvZGVkIGluIHRoZSBhZGRyZXNzCisJICogd2l0aGluIHRoZSBJUE1JIE9wUmVnaW9uOyBzZWUgQUNQSSA0LjAsIHNlYyA1LjUuMi40LjMuCisJICovCisJbXNnLT5uZXRmbiA9IElQTUlfT1BfUkdOX05FVEZOKGFkZHJlc3MpOworCW1zZy0+Y21kID0gSVBNSV9PUF9SR05fQ01EKGFkZHJlc3MpOworCW1zZy0+ZGF0YSA9IHR4X21zZy0+dHhfZGF0YTsKKwkvKgorCSAqIHZhbHVlIGlzIHRoZSBwYXJhbWV0ZXIgcGFzc2VkIGJ5IHRoZSBJUE1JIG9wcmVnaW9uIHNwYWNlIGhhbmRsZXIuCisJICogSXQgcG9pbnRzIHRvIHRoZSBJUE1JIHJlcXVlc3QgbWVzc2FnZSBidWZmZXIKKwkgKi8KKwlidWZmZXIgPSAoc3RydWN0IGFjcGlfaXBtaV9idWZmZXIgKil2YWx1ZTsKKwkvKiBjb3B5IHRoZSB0eCBtZXNzYWdlIGRhdGEgKi8KKwltc2ctPmRhdGFfbGVuID0gYnVmZmVyLT5sZW5ndGg7CisJbWVtY3B5KHR4X21zZy0+dHhfZGF0YSwgYnVmZmVyLT5kYXRhLCBtc2ctPmRhdGFfbGVuKTsKKwkvKgorCSAqIG5vdyB0aGUgZGVmYXVsdCB0eXBlIGlzIFNZU1RFTV9JTlRFUkZBQ0UgYW5kIGNoYW5uZWwgdHlwZSBpcyBCTUMuCisJICogSWYgdGhlIG5ldGZuIGlzIEFQUF9SRVFVRVNUIGFuZCB0aGUgY21kIGlzIFNFTkRfTUVTU0FHRSwKKwkgKiB0aGUgYWRkciB0eXBlIHNob3VsZCBiZSBjaGFuZ2VkIHRvIElQTUIuIFRoZW4gd2Ugd2lsbCBoYXZlIHRvIHBhcnNlCisJICogdGhlIElQTUkgcmVxdWVzdCBtZXNzYWdlIGJ1ZmZlciB0byBnZXQgdGhlIElQTUIgYWRkcmVzcy4KKwkgKiBJZiBzbywgcGxlYXNlIGZpeCBtZS4KKwkgKi8KKwl0eF9tc2ctPmFkZHIuYWRkcl90eXBlID0gSVBNSV9TWVNURU1fSU5URVJGQUNFX0FERFJfVFlQRTsKKwl0eF9tc2ctPmFkZHIuY2hhbm5lbCA9IElQTUlfQk1DX0NIQU5ORUw7CisJdHhfbXNnLT5hZGRyLmRhdGFbMF0gPSAwOworCisJLyogR2V0IHRoZSBtc2dpZCAqLworCWRldmljZSA9IHR4X21zZy0+ZGV2aWNlOworCW11dGV4X2xvY2soJmRldmljZS0+dHhfbXNnX2xvY2spOworCWRldmljZS0+Y3Vycl9tc2dpZCsrOworCXR4X21zZy0+dHhfbXNnaWQgPSBkZXZpY2UtPmN1cnJfbXNnaWQ7CisJbXV0ZXhfdW5sb2NrKCZkZXZpY2UtPnR4X21zZ19sb2NrKTsKK30KKworc3RhdGljIHZvaWQgYWNwaV9mb3JtYXRfaXBtaV9yZXNwb25zZShzdHJ1Y3QgYWNwaV9pcG1pX21zZyAqbXNnLAorCQlhY3BpX2ludGVnZXIgKnZhbHVlLCBpbnQgcmVtX3RpbWUpCit7CisJc3RydWN0IGFjcGlfaXBtaV9idWZmZXIgKmJ1ZmZlcjsKKworCS8qCisJICogdmFsdWUgaXMgYWxzbyB1c2VkIGFzIG91dHB1dCBwYXJhbWV0ZXIuIEl0IHJlcHJlc2VudHMgdGhlIHJlc3BvbnNlCisJICogSVBNSSBtZXNzYWdlIHJldHVybmVkIGJ5IElQTUkgY29tbWFuZC4KKwkgKi8KKwlidWZmZXIgPSAoc3RydWN0IGFjcGlfaXBtaV9idWZmZXIgKil2YWx1ZTsKKwlpZiAoIXJlbV90aW1lICYmICFtc2ctPm1zZ19kb25lKSB7CisJCWJ1ZmZlci0+c3RhdHVzID0gQUNQSV9JUE1JX1RJTUVPVVQ7CisJCXJldHVybjsKKwl9CisJLyoKKwkgKiBJZiB0aGUgZmxhZyBvZiBtc2dfZG9uZSBpcyBub3Qgc2V0IG9yIHRoZSByZWN2IGxlbmd0aCBpcyB6ZXJvLCBpdAorCSAqIG1lYW5zIHRoYXQgdGhlIElQTUkgY29tbWFuZCBpcyBub3QgZXhlY3V0ZWQgY29ycmVjdGx5LgorCSAqIFRoZSBzdGF0dXMgY29kZSB3aWxsIGJlIEFDUElfSVBNSV9VTktOT1dOLgorCSAqLworCWlmICghbXNnLT5tc2dfZG9uZSB8fCAhbXNnLT5yeF9sZW4pIHsKKwkJYnVmZmVyLT5zdGF0dXMgPSBBQ1BJX0lQTUlfVU5LTk9XTjsKKwkJcmV0dXJuOworCX0KKwkvKgorCSAqIElmIHRoZSBJUE1JIHJlc3BvbnNlIG1lc3NhZ2UgaXMgb2J0YWluZWQgY29ycmVjdGx5LCB0aGUgc3RhdHVzIGNvZGUKKwkgKiB3aWxsIGJlIEFDUElfSVBNSV9PSworCSAqLworCWJ1ZmZlci0+c3RhdHVzID0gQUNQSV9JUE1JX09LOworCWJ1ZmZlci0+bGVuZ3RoID0gbXNnLT5yeF9sZW47CisJbWVtY3B5KGJ1ZmZlci0+ZGF0YSwgbXNnLT5yeF9kYXRhLCBtc2ctPnJ4X2xlbik7Cit9CisKK3N0YXRpYyB2b2lkIGlwbWlfZmx1c2hfdHhfbXNnKHN0cnVjdCBhY3BpX2lwbWlfZGV2aWNlICppcG1pKQoreworCXN0cnVjdCBhY3BpX2lwbWlfbXNnICp0eF9tc2csICp0ZW1wOworCWludCBjb3VudCA9IEhaIC8gMTA7CisJc3RydWN0IHBucF9kZXYgKnBucF9kZXYgPSBpcG1pLT5wbnBfZGV2OworCisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHR4X21zZywgdGVtcCwgJmlwbWktPnR4X21zZ19saXN0LCBoZWFkKSB7CisJCS8qIHdha2UgdXAgdGhlIHNsZWVwIHRocmVhZCBvbiB0aGUgVHggbXNnICovCisJCWNvbXBsZXRlKCZ0eF9tc2ctPnR4X2NvbXBsZXRlKTsKKwl9CisKKwkvKiB3YWl0IGZvciBhYm91dCAxMDBtcyB0byBmbHVzaCB0aGUgdHggbWVzc2FnZSBsaXN0ICovCisJd2hpbGUgKGNvdW50LS0pIHsKKwkJaWYgKGxpc3RfZW1wdHkoJmlwbWktPnR4X21zZ19saXN0KSkKKwkJCWJyZWFrOworCQlzY2hlZHVsZV90aW1lb3V0KDEpOworCX0KKwlpZiAoIWxpc3RfZW1wdHkoJmlwbWktPnR4X21zZ19saXN0KSkKKwkJZGV2X3dhcm4oJnBucF9kZXYtPmRldiwgInR4IG1zZyBsaXN0IGlzIG5vdCBOVUxMXG4iKTsKK30KKworc3RhdGljIHZvaWQgaXBtaV9tc2dfaGFuZGxlcihzdHJ1Y3QgaXBtaV9yZWN2X21zZyAqbXNnLCB2b2lkICp1c2VyX21zZ19kYXRhKQoreworCXN0cnVjdCBhY3BpX2lwbWlfZGV2aWNlICppcG1pX2RldmljZSA9IHVzZXJfbXNnX2RhdGE7CisJaW50IG1zZ19mb3VuZCA9IDA7CisJc3RydWN0IGFjcGlfaXBtaV9tc2cgKnR4X21zZzsKKwlzdHJ1Y3QgcG5wX2RldiAqcG5wX2RldiA9IGlwbWlfZGV2aWNlLT5wbnBfZGV2OworCisJaWYgKG1zZy0+dXNlciAhPSBpcG1pX2RldmljZS0+dXNlcl9pbnRlcmZhY2UpIHsKKwkJZGV2X3dhcm4oJnBucF9kZXYtPmRldiwgIlVuZXhwZWN0ZWQgcmVzcG9uc2UgaXMgcmV0dXJuZWQuICIKKwkJCSJyZXR1cm5lZCB1c2VyICVwLCBleHBlY3RlZCB1c2VyICVwXG4iLAorCQkJbXNnLT51c2VyLCBpcG1pX2RldmljZS0+dXNlcl9pbnRlcmZhY2UpOworCQlpcG1pX2ZyZWVfcmVjdl9tc2cobXNnKTsKKwkJcmV0dXJuOworCX0KKwltdXRleF9sb2NrKCZpcG1pX2RldmljZS0+dHhfbXNnX2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnkodHhfbXNnLCAmaXBtaV9kZXZpY2UtPnR4X21zZ19saXN0LCBoZWFkKSB7CisJCWlmIChtc2ctPm1zZ2lkID09IHR4X21zZy0+dHhfbXNnaWQpIHsKKwkJCW1zZ19mb3VuZCA9IDE7CisJCQlicmVhazsKKwkJfQorCX0KKworCW11dGV4X3VubG9jaygmaXBtaV9kZXZpY2UtPnR4X21zZ19sb2NrKTsKKwlpZiAoIW1zZ19mb3VuZCkgeworCQlkZXZfd2FybigmcG5wX2Rldi0+ZGV2LCAiVW5leHBlY3RlZCByZXNwb25zZSAobXNnIGlkICVsZCkgaXMgIgorCQkJInJldHVybmVkLlxuIiwgbXNnLT5tc2dpZCk7CisJCWlwbWlfZnJlZV9yZWN2X21zZyhtc2cpOworCQlyZXR1cm47CisJfQorCisJaWYgKG1zZy0+bXNnLmRhdGFfbGVuKSB7CisJCS8qIGNvcHkgdGhlIHJlc3BvbnNlIGRhdGEgdG8gUnhfZGF0YSBidWZmZXIgKi8KKwkJbWVtY3B5KHR4X21zZy0+cnhfZGF0YSwgbXNnLT5tc2dfZGF0YSwgbXNnLT5tc2cuZGF0YV9sZW4pOworCQl0eF9tc2ctPnJ4X2xlbiA9IG1zZy0+bXNnLmRhdGFfbGVuOworCQl0eF9tc2ctPm1zZ19kb25lID0gMTsKKwl9CisJY29tcGxldGUoJnR4X21zZy0+dHhfY29tcGxldGUpOworCWlwbWlfZnJlZV9yZWN2X21zZyhtc2cpOworfTsKKworc3RhdGljIHZvaWQgaXBtaV9yZWdpc3Rlcl9ibWMoaW50IGlmYWNlLCBzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IGFjcGlfaXBtaV9kZXZpY2UgKmlwbWlfZGV2aWNlLCAqdGVtcDsKKwlzdHJ1Y3QgcG5wX2RldiAqcG5wX2RldjsKKwlpcG1pX3VzZXJfdAkJdXNlcjsKKwlpbnQgZXJyOworCXN0cnVjdCBpcG1pX3NtaV9pbmZvIHNtaV9kYXRhOworCWFjcGlfaGFuZGxlIGhhbmRsZTsKKworCWVyciA9IGlwbWlfZ2V0X3NtaV9pbmZvKGlmYWNlLCAmc21pX2RhdGEpOworCisJaWYgKGVycikKKwkJcmV0dXJuOworCisJaWYgKHNtaV9kYXRhLmFkZHJfc3JjICE9IFNJX0FDUEkpIHsKKwkJcHV0X2RldmljZShzbWlfZGF0YS5kZXYpOworCQlyZXR1cm47CisJfQorCisJaGFuZGxlID0gc21pX2RhdGEuYWRkcl9pbmZvLmFjcGlfaW5mby5hY3BpX2hhbmRsZTsKKworCW11dGV4X2xvY2soJmRyaXZlcl9kYXRhLmlwbWlfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeSh0ZW1wLCAmZHJpdmVyX2RhdGEuaXBtaV9kZXZpY2VzLCBoZWFkKSB7CisJCS8qCisJCSAqIGlmIHRoZSBjb3JyZXNwb25kaW5nIEFDUEkgaGFuZGxlIGlzIGFscmVhZHkgYWRkZWQKKwkJICogdG8gdGhlIGRldmljZSBsaXN0LCBkb24ndCBhZGQgaXQgYWdhaW4uCisJCSAqLworCQlpZiAodGVtcC0+aGFuZGxlID09IGhhbmRsZSkKKwkJCWdvdG8gb3V0OworCX0KKworCWlwbWlfZGV2aWNlID0ga3phbGxvYyhzaXplb2YoKmlwbWlfZGV2aWNlKSwgR0ZQX0tFUk5FTCk7CisKKwlpZiAoIWlwbWlfZGV2aWNlKQorCQlnb3RvIG91dDsKKworCXBucF9kZXYgPSB0b19wbnBfZGV2KHNtaV9kYXRhLmRldik7CisJaXBtaV9kZXZpY2UtPmhhbmRsZSA9IGhhbmRsZTsKKwlpcG1pX2RldmljZS0+cG5wX2RldiA9IHBucF9kZXY7CisKKwllcnIgPSBpcG1pX2NyZWF0ZV91c2VyKGlmYWNlLCAmZHJpdmVyX2RhdGEuaXBtaV9obmRscnMsCisJCQkJCWlwbWlfZGV2aWNlLCAmdXNlcik7CisJaWYgKGVycikgeworCQlkZXZfd2FybigmcG5wX2Rldi0+ZGV2LCAiQ2FuJ3QgY3JlYXRlIElQTUkgdXNlciBpbnRlcmZhY2VcbiIpOworCQlrZnJlZShpcG1pX2RldmljZSk7CisJCWdvdG8gb3V0OworCX0KKwlhY3BpX2FkZF9pcG1pX2RldmljZShpcG1pX2RldmljZSk7CisJaXBtaV9kZXZpY2UtPnVzZXJfaW50ZXJmYWNlID0gdXNlcjsKKwlpcG1pX2RldmljZS0+aXBtaV9pZm51bSA9IGlmYWNlOworCW11dGV4X3VubG9jaygmZHJpdmVyX2RhdGEuaXBtaV9sb2NrKTsKKwltZW1jcHkoJmlwbWlfZGV2aWNlLT5zbWlfZGF0YSwgJnNtaV9kYXRhLCBzaXplb2Yoc3RydWN0IGlwbWlfc21pX2luZm8pKTsKKwlyZXR1cm47CisKK291dDoKKwltdXRleF91bmxvY2soJmRyaXZlcl9kYXRhLmlwbWlfbG9jayk7CisJcHV0X2RldmljZShzbWlfZGF0YS5kZXYpOworCXJldHVybjsKK30KKworc3RhdGljIHZvaWQgaXBtaV9ibWNfZ29uZShpbnQgaWZhY2UpCit7CisJc3RydWN0IGFjcGlfaXBtaV9kZXZpY2UgKmlwbWlfZGV2aWNlLCAqdGVtcDsKKworCW11dGV4X2xvY2soJmRyaXZlcl9kYXRhLmlwbWlfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKGlwbWlfZGV2aWNlLCB0ZW1wLAorCQkJCSZkcml2ZXJfZGF0YS5pcG1pX2RldmljZXMsIGhlYWQpIHsKKwkJaWYgKGlwbWlfZGV2aWNlLT5pcG1pX2lmbnVtICE9IGlmYWNlKQorCQkJY29udGludWU7CisKKwkJYWNwaV9yZW1vdmVfaXBtaV9kZXZpY2UoaXBtaV9kZXZpY2UpOworCQlwdXRfZGV2aWNlKGlwbWlfZGV2aWNlLT5zbWlfZGF0YS5kZXYpOworCQlrZnJlZShpcG1pX2RldmljZSk7CisJCWJyZWFrOworCX0KKwltdXRleF91bmxvY2soJmRyaXZlcl9kYXRhLmlwbWlfbG9jayk7Cit9CisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICoJCQlBZGRyZXNzIFNwYWNlIE1hbmFnZW1lbnQKKyAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCisvKgorICogVGhpcyBpcyB0aGUgSVBNSSBvcHJlZ2lvbiBzcGFjZSBoYW5kbGVyLgorICogQGZ1bmN0aW9uOiBpbmRpY2F0ZXMgdGhlIHJlYWQvd3JpdGUuIEluIGZhY3QgYXMgdGhlIElQTUkgbWVzc2FnZSBpcyBkcml2ZW4KKyAqIGJ5IGNvbW1hbmQsIG9ubHkgd3JpdGUgaXMgbWVhbmluZ2Z1bC4KKyAqIEBhZGRyZXNzOiBUaGlzIGNvbnRhaW5zIHRoZSBuZXRmbi9jb21tYW5kIG9mIElQTUkgcmVxdWVzdCBtZXNzYWdlLgorICogQGJpdHMgICA6IG5vdCB1c2VkLgorICogQHZhbHVlICA6IGl0IGlzIGFuIGluL291dCBwYXJhbWV0ZXIuIEl0IHBvaW50cyB0byB0aGUgSVBNSSBtZXNzYWdlIGJ1ZmZlci4KKyAqCSAgICAgQmVmb3JlIHRoZSBJUE1JIG1lc3NhZ2UgaXMgc2VudCwgaXQgcmVwcmVzZW50cyB0aGUgYWN0dWFsIHJlcXVlc3QKKyAqCSAgICAgSVBNSSBtZXNzYWdlLiBBZnRlciB0aGUgSVBNSSBtZXNzYWdlIGlzIGZpbmlzaGVkLCBpdCByZXByZXNlbnRzCisgKgkgICAgIHRoZSByZXNwb25zZSBJUE1JIG1lc3NhZ2UgcmV0dXJuZWQgYnkgSVBNSSBjb21tYW5kLgorICogQGhhbmRsZXJfY29udGV4dDogSVBNSSBkZXZpY2UgY29udGV4dC4KKyAqLworCitzdGF0aWMgYWNwaV9zdGF0dXMKK2FjcGlfaXBtaV9zcGFjZV9oYW5kbGVyKHUzMiBmdW5jdGlvbiwgYWNwaV9waHlzaWNhbF9hZGRyZXNzIGFkZHJlc3MsCisJCSAgICAgIHUzMiBiaXRzLCBhY3BpX2ludGVnZXIgKnZhbHVlLAorCQkgICAgICB2b2lkICpoYW5kbGVyX2NvbnRleHQsIHZvaWQgKnJlZ2lvbl9jb250ZXh0KQoreworCXN0cnVjdCBhY3BpX2lwbWlfbXNnICp0eF9tc2c7CisJc3RydWN0IGFjcGlfaXBtaV9kZXZpY2UgKmlwbWlfZGV2aWNlID0gaGFuZGxlcl9jb250ZXh0OworCWludCBlcnIsIHJlbV90aW1lOworCWFjcGlfc3RhdHVzIHN0YXR1czsKKwkvKgorCSAqIElQTUkgb3ByZWdpb24gbWVzc2FnZS4KKwkgKiBJUE1JIG1lc3NhZ2UgaXMgZmlyc3RseSB3cml0dGVuIHRvIHRoZSBCTUMgYW5kIHN5c3RlbSBzb2Z0d2FyZQorCSAqIGNhbiBnZXQgdGhlIHJlc3Bzb25zZS4gU28gaXQgaXMgdW5tZWFuaW5nZnVsIGZvciB0aGUgcmVhZCBhY2Nlc3MKKwkgKiBvZiBJUE1JIG9wcmVnaW9uLgorCSAqLworCWlmICgoZnVuY3Rpb24gJiBBQ1BJX0lPX01BU0spID09IEFDUElfUkVBRCkKKwkJcmV0dXJuIEFFX1RZUEU7CisKKwlpZiAoIWlwbWlfZGV2aWNlLT51c2VyX2ludGVyZmFjZSkKKwkJcmV0dXJuIEFFX05PVF9FWElTVDsKKworCXR4X21zZyA9IGFjcGlfYWxsb2NfaXBtaV9tc2coaXBtaV9kZXZpY2UpOworCWlmICghdHhfbXNnKQorCQlyZXR1cm4gQUVfTk9fTUVNT1JZOworCisJYWNwaV9mb3JtYXRfaXBtaV9tc2codHhfbXNnLCBhZGRyZXNzLCB2YWx1ZSk7CisJbXV0ZXhfbG9jaygmaXBtaV9kZXZpY2UtPnR4X21zZ19sb2NrKTsKKwlsaXN0X2FkZF90YWlsKCZ0eF9tc2ctPmhlYWQsICZpcG1pX2RldmljZS0+dHhfbXNnX2xpc3QpOworCW11dGV4X3VubG9jaygmaXBtaV9kZXZpY2UtPnR4X21zZ19sb2NrKTsKKwllcnIgPSBpcG1pX3JlcXVlc3Rfc2V0dGltZShpcG1pX2RldmljZS0+dXNlcl9pbnRlcmZhY2UsCisJCQkJCSZ0eF9tc2ctPmFkZHIsCisJCQkJCXR4X21zZy0+dHhfbXNnaWQsCisJCQkJCSZ0eF9tc2ctPnR4X21lc3NhZ2UsCisJCQkJCU5VTEwsIDAsIDAsIDApOworCWlmIChlcnIpIHsKKwkJc3RhdHVzID0gQUVfRVJST1I7CisJCWdvdG8gZW5kX2xhYmVsOworCX0KKwlyZW1fdGltZSA9IHdhaXRfZm9yX2NvbXBsZXRpb25fdGltZW91dCgmdHhfbXNnLT50eF9jb21wbGV0ZSwKKwkJCQkJSVBNSV9USU1FT1VUKTsKKwlhY3BpX2Zvcm1hdF9pcG1pX3Jlc3BvbnNlKHR4X21zZywgdmFsdWUsIHJlbV90aW1lKTsKKwlzdGF0dXMgPSBBRV9PSzsKKworZW5kX2xhYmVsOgorCW11dGV4X2xvY2soJmlwbWlfZGV2aWNlLT50eF9tc2dfbG9jayk7CisJbGlzdF9kZWwoJnR4X21zZy0+aGVhZCk7CisJbXV0ZXhfdW5sb2NrKCZpcG1pX2RldmljZS0+dHhfbXNnX2xvY2spOworCWtmcmVlKHR4X21zZyk7CisJcmV0dXJuIHN0YXR1czsKK30KKworc3RhdGljIHZvaWQgaXBtaV9yZW1vdmVfc3BhY2VfaGFuZGxlcihzdHJ1Y3QgYWNwaV9pcG1pX2RldmljZSAqaXBtaSkKK3sKKwlpZiAoIXRlc3RfYml0KElQTUlfRkxBR1NfSEFORExFUl9JTlNUQUxMLCAmaXBtaS0+ZmxhZ3MpKQorCQlyZXR1cm47CisKKwlhY3BpX3JlbW92ZV9hZGRyZXNzX3NwYWNlX2hhbmRsZXIoaXBtaS0+aGFuZGxlLAorCQkJCUFDUElfQURSX1NQQUNFX0lQTUksICZhY3BpX2lwbWlfc3BhY2VfaGFuZGxlcik7CisKKwljbGVhcl9iaXQoSVBNSV9GTEFHU19IQU5ETEVSX0lOU1RBTEwsICZpcG1pLT5mbGFncyk7Cit9CisKK3N0YXRpYyBpbnQgaXBtaV9pbnN0YWxsX3NwYWNlX2hhbmRsZXIoc3RydWN0IGFjcGlfaXBtaV9kZXZpY2UgKmlwbWkpCit7CisJYWNwaV9zdGF0dXMgc3RhdHVzOworCisJaWYgKHRlc3RfYml0KElQTUlfRkxBR1NfSEFORExFUl9JTlNUQUxMLCAmaXBtaS0+ZmxhZ3MpKQorCQlyZXR1cm4gMDsKKworCXN0YXR1cyA9IGFjcGlfaW5zdGFsbF9hZGRyZXNzX3NwYWNlX2hhbmRsZXIoaXBtaS0+aGFuZGxlLAorCQkJCQkJICAgIEFDUElfQURSX1NQQUNFX0lQTUksCisJCQkJCQkgICAgJmFjcGlfaXBtaV9zcGFjZV9oYW5kbGVyLAorCQkJCQkJICAgIE5VTEwsIGlwbWkpOworCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgeworCQlzdHJ1Y3QgcG5wX2RldiAqcG5wX2RldiA9IGlwbWktPnBucF9kZXY7CisJCWRldl93YXJuKCZwbnBfZGV2LT5kZXYsICJDYW4ndCByZWdpc3RlciBJUE1JIG9wcmVnaW9uIHNwYWNlICIKKwkJCSJoYW5kbGVcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJc2V0X2JpdChJUE1JX0ZMQUdTX0hBTkRMRVJfSU5TVEFMTCwgJmlwbWktPmZsYWdzKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgYWNwaV9hZGRfaXBtaV9kZXZpY2Uoc3RydWN0IGFjcGlfaXBtaV9kZXZpY2UgKmlwbWlfZGV2aWNlKQoreworCisJSU5JVF9MSVNUX0hFQUQoJmlwbWlfZGV2aWNlLT5oZWFkKTsKKworCW11dGV4X2luaXQoJmlwbWlfZGV2aWNlLT50eF9tc2dfbG9jayk7CisJSU5JVF9MSVNUX0hFQUQoJmlwbWlfZGV2aWNlLT50eF9tc2dfbGlzdCk7CisJaXBtaV9pbnN0YWxsX3NwYWNlX2hhbmRsZXIoaXBtaV9kZXZpY2UpOworCisJbGlzdF9hZGRfdGFpbCgmaXBtaV9kZXZpY2UtPmhlYWQsICZkcml2ZXJfZGF0YS5pcG1pX2RldmljZXMpOworfQorCitzdGF0aWMgdm9pZCBhY3BpX3JlbW92ZV9pcG1pX2RldmljZShzdHJ1Y3QgYWNwaV9pcG1pX2RldmljZSAqaXBtaV9kZXZpY2UpCit7CisJLyoKKwkgKiBJZiB0aGUgSVBNSSB1c2VyIGludGVyZmFjZSBpcyBjcmVhdGVkLCBpdCBzaG91bGQgYmUKKwkgKiBkZXN0cm95ZWQuCisJICovCisJaWYgKGlwbWlfZGV2aWNlLT51c2VyX2ludGVyZmFjZSkgeworCQlpcG1pX2Rlc3Ryb3lfdXNlcihpcG1pX2RldmljZS0+dXNlcl9pbnRlcmZhY2UpOworCQlpcG1pX2RldmljZS0+dXNlcl9pbnRlcmZhY2UgPSBOVUxMOworCX0KKwkvKiBmbHVzaCB0aGUgVHhfbXNnIGxpc3QgKi8KKwlpZiAoIWxpc3RfZW1wdHkoJmlwbWlfZGV2aWNlLT50eF9tc2dfbGlzdCkpCisJCWlwbWlfZmx1c2hfdHhfbXNnKGlwbWlfZGV2aWNlKTsKKworCWxpc3RfZGVsKCZpcG1pX2RldmljZS0+aGVhZCk7CisJaXBtaV9yZW1vdmVfc3BhY2VfaGFuZGxlcihpcG1pX2RldmljZSk7Cit9CisKK3N0YXRpYyBpbnQgX19pbml0IGFjcGlfaXBtaV9pbml0KHZvaWQpCit7CisJaW50IHJlc3VsdCA9IDA7CisKKwlpZiAoYWNwaV9kaXNhYmxlZCkKKwkJcmV0dXJuIHJlc3VsdDsKKworCW11dGV4X2luaXQoJmRyaXZlcl9kYXRhLmlwbWlfbG9jayk7CisKKwlyZXN1bHQgPSBpcG1pX3NtaV93YXRjaGVyX3JlZ2lzdGVyKCZkcml2ZXJfZGF0YS5ibWNfZXZlbnRzKTsKKworCXJldHVybiByZXN1bHQ7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBhY3BpX2lwbWlfZXhpdCh2b2lkKQoreworCXN0cnVjdCBhY3BpX2lwbWlfZGV2aWNlICppcG1pX2RldmljZSwgKnRlbXA7CisKKwlpZiAoYWNwaV9kaXNhYmxlZCkKKwkJcmV0dXJuOworCisJaXBtaV9zbWlfd2F0Y2hlcl91bnJlZ2lzdGVyKCZkcml2ZXJfZGF0YS5ibWNfZXZlbnRzKTsKKworCS8qCisJICogV2hlbiBvbmUgc21pX3dhdGNoZXIgaXMgdW5yZWdpc3RlcmVkLCBpdCBpcyBvbmx5IGRlbGV0ZWQKKwkgKiBmcm9tIHRoZSBzbWlfd2F0Y2hlciBsaXN0LiBCdXQgdGhlIHNtaV9nb25lIGNhbGxiYWNrIGZ1bmN0aW9uCisJICogaXMgbm90IGNhbGxlZC4gU28gZXhwbGljaXRseSB1bmluc3RhbGwgdGhlIEFDUEkgSVBNSSBvcmVnaW9uCisJICogaGFuZGxlciBhbmQgZnJlZSBpdC4KKwkgKi8KKwltdXRleF9sb2NrKCZkcml2ZXJfZGF0YS5pcG1pX2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShpcG1pX2RldmljZSwgdGVtcCwKKwkJCQkmZHJpdmVyX2RhdGEuaXBtaV9kZXZpY2VzLCBoZWFkKSB7CisJCWFjcGlfcmVtb3ZlX2lwbWlfZGV2aWNlKGlwbWlfZGV2aWNlKTsKKwkJcHV0X2RldmljZShpcG1pX2RldmljZS0+c21pX2RhdGEuZGV2KTsKKwkJa2ZyZWUoaXBtaV9kZXZpY2UpOworCX0KKwltdXRleF91bmxvY2soJmRyaXZlcl9kYXRhLmlwbWlfbG9jayk7Cit9CisKK21vZHVsZV9pbml0KGFjcGlfaXBtaV9pbml0KTsKK21vZHVsZV9leGl0KGFjcGlfaXBtaV9leGl0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvTWFrZWZpbGUgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL01ha2VmaWxlCmluZGV4IGE3ZTFkMWEuLmVlYzJlYWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9NYWtlZmlsZQpAQCAtMTQsNyArMTQsNyBAQAogCiBhY3BpLXkgKz0gZXZldmVudC5vICBldnJlZ2lvbi5vICBldnNjaS5vICAgIGV2eGZldm50Lm8gXAogCSBldm1pc2MubyAgIGV2cmduaW5pLm8gIGV2eGZhY2UubyAgZXZ4ZnJlZ24ubyBcCi0JIGV2Z3BlLm8gICAgZXZncGVibGsubyBldmdwZWluaXQubyAgZXZncGV1dGlsLm8KKwkgZXZncGUubyAgICBldmdwZWJsay5vIGV2Z3BlaW5pdC5vICBldmdwZXV0aWwubyBldnhmZ3BlLm8KIAogYWNwaS15ICs9IGV4Y29uZmlnLm8gIGV4ZmllbGQubyAgZXhuYW1lcy5vICAgZXhvcGFyZzYubyAgZXhyZXNvbHYubyAgZXhzdG9yb2Iub1wKIAkgZXhjb252cnQubyAgZXhmbGRpby5vICBleG9wYXJnMS5vICBleHByZXAubyAgICBleHJlc29wLm8gICBleHN5c3RlbS5vXApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2NvbW1vbi5oIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY2NvbW1vbi5oCmluZGV4IDNlNTBjNzQuLmUwYmExN2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNjb21tb24uaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjY29tbW9uLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjY29uZmlnLmggYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjY29uZmlnLmgKaW5kZXggYjE3ZDhkZS4uYWI4NzM5NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2NvbmZpZy5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNjb25maWcuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNkZWJ1Zy5oIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY2RlYnVnLmgKaW5kZXggNzJlOWQ1ZS4uZWIwYjFmOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2RlYnVnLmgKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY2RlYnVnLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjZGlzcGF0LmggYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjZGlzcGF0LmgKaW5kZXggODk0YTBmZi4uNjY2MjcxYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2Rpc3BhdC5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNkaXNwYXQuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNldmVudHMuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNldmVudHMuaAppbmRleCBhNmY5OWNjLi40MWQyNDdkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjZXZlbnRzLmgKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY2V2ZW50cy5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtNTEsOCArNTEsNiBAQAogCiBhY3BpX3N0YXR1cyBhY3BpX2V2X2luc3RhbGxfeHJ1cHRfaGFuZGxlcnModm9pZCk7CiAKLWFjcGlfc3RhdHVzIGFjcGlfZXZfaW5zdGFsbF9mYWR0X2dwZXModm9pZCk7Ci0KIHUzMiBhY3BpX2V2X2ZpeGVkX2V2ZW50X2RldGVjdCh2b2lkKTsKIAogLyoKQEAgLTgyLDkgKzgwLDkgQEAKIAogYWNwaV9zdGF0dXMgYWNwaV9ldl9lbmFibGVfZ3BlKHN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbyk7CiAKLWFjcGlfc3RhdHVzIGFjcGlfcmF3X2VuYWJsZV9ncGUoc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvKTsKK2FjcGlfc3RhdHVzIGFjcGlfZXZfYWRkX2dwZV9yZWZlcmVuY2Uoc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvKTsKIAotYWNwaV9zdGF0dXMgYWNwaV9yYXdfZGlzYWJsZV9ncGUoc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvKTsKK2FjcGlfc3RhdHVzIGFjcGlfZXZfcmVtb3ZlX2dwZV9yZWZlcmVuY2Uoc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvKTsKIAogc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmFjcGlfZXZfZ2V0X2dwZV9ldmVudF9pbmZvKGFjcGlfaGFuZGxlIGdwZV9kZXZpY2UsCiAJCQkJCQkgICAgICAgdTMyIGdwZV9udW1iZXIpOwpAQCAtOTMsNiArOTEsOCBAQAogCQkJCQkJICAgICBzdHJ1Y3QgYWNwaV9ncGVfYmxvY2tfaW5mbwogCQkJCQkJICAgICAqZ3BlX2Jsb2NrKTsKIAorYWNwaV9zdGF0dXMgYWNwaV9ldl9maW5pc2hfZ3BlKHN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbyk7CisKIC8qCiAgKiBldmdwZWJsayAtIFVwcGVyLWxldmVsIEdQRSBibG9jayBzdXBwb3J0CiAgKi8KQEAgLTEwNywxMiArMTA3LDEzIEBACiBhY3BpX3N0YXR1cwogYWNwaV9ldl9pbml0aWFsaXplX2dwZV9ibG9jayhzdHJ1Y3QgYWNwaV9ncGVfeHJ1cHRfaW5mbyAqZ3BlX3hydXB0X2luZm8sCiAJCQkgICAgIHN0cnVjdCBhY3BpX2dwZV9ibG9ja19pbmZvICpncGVfYmxvY2ssCi0JCQkgICAgIHZvaWQgKmlnbm9yZWQpOworCQkJICAgICB2b2lkICpjb250ZXh0KTsKIAogYWNwaV9zdGF0dXMgYWNwaV9ldl9kZWxldGVfZ3BlX2Jsb2NrKHN0cnVjdCBhY3BpX2dwZV9ibG9ja19pbmZvICpncGVfYmxvY2spOwogCiB1MzIKLWFjcGlfZXZfZ3BlX2Rpc3BhdGNoKHN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbywKK2FjcGlfZXZfZ3BlX2Rpc3BhdGNoKHN0cnVjdCBhY3BpX25hbWVzcGFjZV9ub2RlICpncGVfZGV2aWNlLAorCQkgICAgIHN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbywKIAkJICAgICB1MzIgZ3BlX251bWJlcik7CiAKIC8qCkBAIC0xMjYsMTAgKzEyNyw2IEBACiBhY3BpX2V2X21hdGNoX2dwZV9tZXRob2QoYWNwaV9oYW5kbGUgb2JqX2hhbmRsZSwKIAkJCSB1MzIgbGV2ZWwsIHZvaWQgKmNvbnRleHQsIHZvaWQgKipyZXR1cm5fdmFsdWUpOwogCi1hY3BpX3N0YXR1cwotYWNwaV9ldl9tYXRjaF9wcndfYW5kX2dwZShhY3BpX2hhbmRsZSBvYmpfaGFuZGxlLAotCQkJICB1MzIgbGV2ZWwsIHZvaWQgKmNvbnRleHQsIHZvaWQgKipyZXR1cm5fdmFsdWUpOwotCiAvKgogICogZXZncGV1dGlsIC0gR1BFIHV0aWxpdGllcwogICovCkBAIC0xMzgsNiArMTM1LDEwIEBACiAKIHU4IGFjcGlfZXZfdmFsaWRfZ3BlX2V2ZW50KHN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbyk7CiAKK2FjcGlfc3RhdHVzCithY3BpX2V2X2dldF9ncGVfZGV2aWNlKHN0cnVjdCBhY3BpX2dwZV94cnVwdF9pbmZvICpncGVfeHJ1cHRfaW5mbywKKwkJICAgICAgIHN0cnVjdCBhY3BpX2dwZV9ibG9ja19pbmZvICpncGVfYmxvY2ssIHZvaWQgKmNvbnRleHQpOworCiBzdHJ1Y3QgYWNwaV9ncGVfeHJ1cHRfaW5mbyAqYWNwaV9ldl9nZXRfZ3BlX3hydXB0X2Jsb2NrKHUzMiBpbnRlcnJ1cHRfbnVtYmVyKTsKIAogYWNwaV9zdGF0dXMgYWNwaV9ldl9kZWxldGVfZ3BlX3hydXB0KHN0cnVjdCBhY3BpX2dwZV94cnVwdF9pbmZvICpncGVfeHJ1cHQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2dsb2JhbC5oIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY2dsb2JhbC5oCmluZGV4IGFkODhmY2EuLjgyYTFiZDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNnbG9iYWwuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjZ2xvYmFsLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC0xNDYsNiArMTQ2LDkgQEAKIAogZXh0ZXJuIHUzMiBhY3BpX2dibF9uZXN0aW5nX2xldmVsOwogCitBQ1BJX0VYVEVSTiB1MzIgYWNwaV9ncGVfY291bnQ7CitBQ1BJX0VYVEVSTiB1MzIgYWNwaV9maXhlZF9ldmVudF9jb3VudFtBQ1BJX05VTV9GSVhFRF9FVkVOVFNdOworCiAvKiBTdXBwb3J0IGZvciBkeW5hbWljIGNvbnRyb2wgbWV0aG9kIHRyYWNpbmcgbWVjaGFuaXNtICovCiAKIEFDUElfRVhURVJOIHUzMiBhY3BpX2dibF9vcmlnaW5hbF9kYmdfbGV2ZWw7CkBAIC0yMjUsOCArMjI4LDEwIEBACiAgKi8KIEFDUElfRVhURVJOIHNwaW5sb2NrX3QgX2FjcGlfZ2JsX2dwZV9sb2NrOwkvKiBGb3IgR1BFIGRhdGEgc3RydWN0cyBhbmQgcmVnaXN0ZXJzICovCiBBQ1BJX0VYVEVSTiBzcGlubG9ja190IF9hY3BpX2dibF9oYXJkd2FyZV9sb2NrOwkvKiBGb3IgQUNQSSBIL1cgZXhjZXB0IEdQRSByZWdpc3RlcnMgKi8KK0FDUElfRVhURVJOIHNwaW5sb2NrX3QgX2FjcGlfZXZfZ2xvYmFsX2xvY2tfcGVuZGluZ19sb2NrOyAvKiBGb3IgZ2xvYmFsIGxvY2sgKi8KICNkZWZpbmUgYWNwaV9nYmxfZ3BlX2xvY2sJJl9hY3BpX2dibF9ncGVfbG9jawogI2RlZmluZSBhY3BpX2dibF9oYXJkd2FyZV9sb2NrCSZfYWNwaV9nYmxfaGFyZHdhcmVfbG9jaworI2RlZmluZSBhY3BpX2V2X2dsb2JhbF9sb2NrX3BlbmRpbmdfbG9jayAmX2FjcGlfZXZfZ2xvYmFsX2xvY2tfcGVuZGluZ19sb2NrCiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoKQEAgLTM3MCw3ICszNzUsOSBAQAogQUNQSV9FWFRFUk4gc3RydWN0IGFjcGlfZ3BlX3hydXB0X2luZm8gKmFjcGlfZ2JsX2dwZV94cnVwdF9saXN0X2hlYWQ7CiBBQ1BJX0VYVEVSTiBzdHJ1Y3QgYWNwaV9ncGVfYmxvY2tfaW5mbwogKmFjcGlfZ2JsX2dwZV9mYWR0X2Jsb2Nrc1tBQ1BJX01BWF9HUEVfQkxPQ0tTXTsKLUFDUElfRVhURVJOIHU4IGFjcGlfYWxsX2dwZXNfaW5pdGlhbGl6ZWQ7CitBQ1BJX0VYVEVSTiB1OCBhY3BpX2dibF9hbGxfZ3Blc19pbml0aWFsaXplZDsKK0FDUElfRVhURVJOIEFDUElfR0JMX0VWRU5UX0hBTkRMRVIgYWNwaV9nYmxfZ2xvYmFsX2V2ZW50X2hhbmRsZXI7CitBQ1BJX0VYVEVSTiB2b2lkICphY3BpX2dibF9nbG9iYWxfZXZlbnRfaGFuZGxlcl9jb250ZXh0OwogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjaHdhcmUuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNod2FyZS5oCmluZGV4IDE2NzQ3MGEuLmU3MjEzYmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNod2FyZS5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNod2FyZS5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtOTQsNyArOTQsNyBAQAogCQkJICAgICBzdHJ1Y3QgYWNwaV9ncGVfcmVnaXN0ZXJfaW5mbyAqZ3BlX3JlZ2lzdGVyX2luZm8pOwogCiBhY3BpX3N0YXR1cwotYWNwaV9od19sb3dfc2V0X2dwZShzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbyAqZ3BlX2V2ZW50X2luZm8sIHU4IGFjdGlvbik7CithY3BpX2h3X2xvd19zZXRfZ3BlKHN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbywgdTMyIGFjdGlvbik7CiAKIGFjcGlfc3RhdHVzCiBhY3BpX2h3X2Rpc2FibGVfZ3BlX2Jsb2NrKHN0cnVjdCBhY3BpX2dwZV94cnVwdF9pbmZvICpncGVfeHJ1cHRfaW5mbywKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNpbnRlcnAuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNpbnRlcnAuaAppbmRleCAwNDllMjAzLi4zNzMxZTFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjaW50ZXJwLmgKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY2ludGVycC5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY2xvY2FsLmggYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjbG9jYWwuaAppbmRleCAyY2ViMGMwLi41NDc4NGJiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjbG9jYWwuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjbG9jYWwuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTQwOCwxNyArNDA4LDE4IEBACiAKIC8qIERpc3BhdGNoIGluZm8gZm9yIGVhY2ggR1BFIC0tIGVpdGhlciBhIG1ldGhvZCBvciBoYW5kbGVyLCBjYW5ub3QgYmUgYm90aCAqLwogCi1zdHJ1Y3QgYWNwaV9oYW5kbGVyX2luZm8gewotCWFjcGlfZXZlbnRfaGFuZGxlciBhZGRyZXNzOwkvKiBBZGRyZXNzIG9mIGhhbmRsZXIsIGlmIGFueSAqLworc3RydWN0IGFjcGlfZ3BlX2hhbmRsZXJfaW5mbyB7CisJYWNwaV9ncGVfaGFuZGxlciBhZGRyZXNzOwkvKiBBZGRyZXNzIG9mIGhhbmRsZXIsIGlmIGFueSAqLwogCXZvaWQgKmNvbnRleHQ7CQkvKiBDb250ZXh0IHRvIGJlIHBhc3NlZCB0byBoYW5kbGVyICovCiAJc3RydWN0IGFjcGlfbmFtZXNwYWNlX25vZGUgKm1ldGhvZF9ub2RlOwkvKiBNZXRob2Qgbm9kZSBmb3IgdGhpcyBHUEUgbGV2ZWwgKHNhdmVkKSAqLwotCXU4IG9yaWdfZmxhZ3M7CQkvKiBPcmlnaW5hbCBtaXNjIGluZm8gYWJvdXQgdGhpcyBHUEUgKi8KLQl1OCBvcmlnX2VuYWJsZWQ7CS8qIFNldCBpZiB0aGUgR1BFIHdhcyBvcmlnaW5hbGx5IGVuYWJsZWQgKi8KKwl1OCBvcmlnaW5hbF9mbGFnczsgICAgICAvKiBPcmlnaW5hbCAocHJlLWhhbmRsZXIpIEdQRSBpbmZvICovCisJdTggb3JpZ2luYWxseV9lbmFibGVkOyAgLyogVHJ1ZSBpZiBHUEUgd2FzIG9yaWdpbmFsbHkgZW5hYmxlZCAqLwogfTsKIAogdW5pb24gYWNwaV9ncGVfZGlzcGF0Y2hfaW5mbyB7CiAJc3RydWN0IGFjcGlfbmFtZXNwYWNlX25vZGUgKm1ldGhvZF9ub2RlOwkvKiBNZXRob2Qgbm9kZSBmb3IgdGhpcyBHUEUgbGV2ZWwgKi8KLQlzdHJ1Y3QgYWNwaV9oYW5kbGVyX2luZm8gKmhhbmRsZXI7CisJc3RydWN0IGFjcGlfZ3BlX2hhbmRsZXJfaW5mbyAqaGFuZGxlcjsgIC8qIEluc3RhbGxlZCBHUEUgaGFuZGxlciAqLworCXN0cnVjdCBhY3BpX25hbWVzcGFjZV9ub2RlICpkZXZpY2Vfbm9kZTsgICAgICAgIC8qIFBhcmVudCBfUFJXIGRldmljZSBmb3IgaW1wbGljaXQgbm90aWZ5ICovCiB9OwogCiAvKgpAQCAtNDU4LDcgKzQ1OSw3IEBACiAJdTMyIHJlZ2lzdGVyX2NvdW50OwkvKiBOdW1iZXIgb2YgcmVnaXN0ZXIgcGFpcnMgaW4gYmxvY2sgKi8KIAl1MTYgZ3BlX2NvdW50OwkJLyogTnVtYmVyIG9mIGluZGl2aWR1YWwgR1BFcyBpbiBibG9jayAqLwogCXU4IGJsb2NrX2Jhc2VfbnVtYmVyOwkvKiBCYXNlIEdQRSBudW1iZXIgZm9yIHRoaXMgYmxvY2sgKi8KLQl1OCBpbml0aWFsaXplZDsgICAgICAgICAvKiBJZiBzZXQsIHRoZSBHUEUgYmxvY2sgaGFzIGJlZW4gaW5pdGlhbGl6ZWQgKi8KKwl1OCBpbml0aWFsaXplZDsgICAgICAgICAvKiBUUlVFIGlmIHRoaXMgYmxvY2sgaXMgaW5pdGlhbGl6ZWQgKi8KIH07CiAKIC8qIEluZm9ybWF0aW9uIGFib3V0IEdQRSBpbnRlcnJ1cHQgaGFuZGxlcnMsIG9uZSBwZXIgZWFjaCBpbnRlcnJ1cHQgbGV2ZWwgdXNlZCBmb3IgR1BFcyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY21hY3Jvcy5oIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY21hY3Jvcy5oCmluZGV4IDhkNWM5ZTAuLmI3NDkxZWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNtYWNyb3MuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjbWFjcm9zLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjbmFtZXNwLmggYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjbmFtZXNwLmgKaW5kZXggZDQ0ZDNiYy4uNzlhNTk4YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY25hbWVzcC5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNuYW1lc3AuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNvYmplY3QuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNvYmplY3QuaAppbmRleCA5NjJhM2NjLi4xMDU1NzY5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2Fjb2JqZWN0LmgKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY29iamVjdC5oCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtOTcsOCArOTcsNiBAQAogI2RlZmluZSBBT1BPQkpfT0JKRUNUX0lOSVRJQUxJWkVEICAgMHgwOAkvKiBSZWdpb24gaXMgaW5pdGlhbGl6ZWQsIF9SRUcgd2FzIHJ1biAqLwogI2RlZmluZSBBT1BPQkpfU0VUVVBfQ09NUExFVEUgICAgICAgMHgxMAkvKiBSZWdpb24gc2V0dXAgaXMgY29tcGxldGUgKi8KICNkZWZpbmUgQU9QT0JKX0lOVkFMSUQgICAgICAgICAgICAgIDB4MjAJLyogSG9zdCBPUyB3b24ndCBhbGxvdyBhIFJlZ2lvbiBhZGRyZXNzICovCi0jZGVmaW5lIEFPUE9CSl9NT0RVTEVfTEVWRUwgICAgICAgICAweDQwCS8qIE1ldGhvZCBpcyBhY3R1YWxseSBtb2R1bGUtbGV2ZWwgY29kZSAqLwotI2RlZmluZSBBT1BPQkpfTU9ESUZJRURfTkFNRVNQQUNFICAgMHg4MAkvKiBNZXRob2QgbW9kaWZpZWQgdGhlIG5hbWVzcGFjZSAqLwogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgpAQCAtMTc1LDcgKzE3Myw3IEBACiB9OwogCiBzdHJ1Y3QgYWNwaV9vYmplY3RfbWV0aG9kIHsKLQlBQ1BJX09CSkVDVF9DT01NT05fSEVBREVSIHU4IG1ldGhvZF9mbGFnczsKKwlBQ1BJX09CSkVDVF9DT01NT05fSEVBREVSIHU4IGluZm9fZmxhZ3M7CiAJdTggcGFyYW1fY291bnQ7CiAJdTggc3luY19sZXZlbDsKIAl1bmlvbiBhY3BpX29wZXJhbmRfb2JqZWN0ICptdXRleDsKQEAgLTE4MywxMyArMTgxLDIxIEBACiAJdW5pb24gewogCQlBQ1BJX0lOVEVSTkFMX01FVEhPRCBpbXBsZW1lbnRhdGlvbjsKIAkJdW5pb24gYWNwaV9vcGVyYW5kX29iamVjdCAqaGFuZGxlcjsKLQl9IGV4dHJhOworCX0gZGlzcGF0Y2g7CiAKIAl1MzIgYW1sX2xlbmd0aDsKIAl1OCB0aHJlYWRfY291bnQ7CiAJYWNwaV9vd25lcl9pZCBvd25lcl9pZDsKIH07CiAKKy8qIEZsYWdzIGZvciBpbmZvX2ZsYWdzIGZpZWxkIGFib3ZlICovCisKKyNkZWZpbmUgQUNQSV9NRVRIT0RfTU9EVUxFX0xFVkVMICAgICAgICAweDAxCS8qIE1ldGhvZCBpcyBhY3R1YWxseSBtb2R1bGUtbGV2ZWwgY29kZSAqLworI2RlZmluZSBBQ1BJX01FVEhPRF9JTlRFUk5BTF9PTkxZICAgICAgIDB4MDIJLyogTWV0aG9kIGlzIGltcGxlbWVudGVkIGludGVybmFsbHkgKF9PU0kpICovCisjZGVmaW5lIEFDUElfTUVUSE9EX1NFUklBTElaRUQgICAgICAgICAgMHgwNAkvKiBNZXRob2QgaXMgc2VyaWFsaXplZCAqLworI2RlZmluZSBBQ1BJX01FVEhPRF9TRVJJQUxJWkVEX1BFTkRJTkcgIDB4MDgJLyogTWV0aG9kIGlzIHRvIGJlIG1hcmtlZCBzZXJpYWxpemVkICovCisjZGVmaW5lIEFDUElfTUVUSE9EX01PRElGSUVEX05BTUVTUEFDRSAgMHgxMAkvKiBNZXRob2QgbW9kaWZpZWQgdGhlIG5hbWVzcGFjZSAqLworCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgogICogT2JqZWN0cyB0aGF0IGNhbiBiZSBub3RpZmllZC4gIEFsbCBzaGFyZSBhIGNvbW1vbiBub3RpZnlfaW5mbyBhcmVhLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY29wY29kZS5oIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY29wY29kZS5oCmluZGV4IDhjMTVmZjQuLmJiMmNjZmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNvcGNvZGUuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2Fjb3Bjb2RlLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjcGFyc2VyLmggYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjcGFyc2VyLmgKaW5kZXggZDBiYjBmZC4uNWVhMWUwNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY3BhcnNlci5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNwYXJzZXIuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNwcmVkZWYuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNwcmVkZWYuaAppbmRleCAxMDk5OGQzLi45NGU3M2M5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjcHJlZGVmLmgKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY3ByZWRlZi5oCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY3Jlc3JjLmggYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjcmVzcmMuaAppbmRleCA1MjhiY2JhLi5mMDhiNTViIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjcmVzcmMuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjcmVzcmMuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNzdHJ1Y3QuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWNzdHJ1Y3QuaAppbmRleCA2ZTVkZDk3Li4xNjIzYjI0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2Fjc3RydWN0LmgKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY3N0cnVjdC5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hY3RhYmxlcy5oIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hY3RhYmxlcy5oCmluZGV4IDYyYTU3NmUuLjk2N2YwODEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWN0YWJsZXMuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjdGFibGVzLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FjdXRpbHMuaCBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWN1dGlscy5oCmluZGV4IDcyZTQxODMuLjk5YzE0MGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWN1dGlscy5oCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvYWN1dGlscy5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hbWxjb2RlLmggYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FtbGNvZGUuaAppbmRleCAxZjQ4NGJhLi5mNGYwOTk4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2FtbGNvZGUuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FtbGNvZGUuaApAQCAtNyw3ICs3LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTQ4MCwxNiArNDgwLDEwIEBACiAJQU1MX0ZJRUxEX0FUVFJJQl9TTUJfQkxPQ0tfQ0FMTCA9IDB4MEQKIH0gQU1MX0FDQ0VTU19BVFRSSUJVVEU7CiAKLS8qIEJpdCBmaWVsZHMgaW4gbWV0aG9kX2ZsYWdzIGJ5dGUgKi8KKy8qIEJpdCBmaWVsZHMgaW4gdGhlIEFNTCBtZXRob2RfZmxhZ3MgYnl0ZSAqLwogCiAjZGVmaW5lIEFNTF9NRVRIT0RfQVJHX0NPVU5UICAgICAgICAweDA3CiAjZGVmaW5lIEFNTF9NRVRIT0RfU0VSSUFMSVpFRCAgICAgICAweDA4CiAjZGVmaW5lIEFNTF9NRVRIT0RfU1lOQ19MRVZFTCAgICAgICAweEYwCiAKLS8qIE1FVEhPRF9GTEFHU19BUkdfQ09VTlQgaXMgbm90IHVzZWQgaW50ZXJuYWxseSwgZGVmaW5lIGFkZGl0aW9uYWwgZmxhZ3MgKi8KLQotI2RlZmluZSBBTUxfTUVUSE9EX0lOVEVSTkFMX09OTFkgICAgMHgwMQotI2RlZmluZSBBTUxfTUVUSE9EX1JFU0VSVkVEMSAgICAgICAgMHgwMgotI2RlZmluZSBBTUxfTUVUSE9EX1JFU0VSVkVEMiAgICAgICAgMHgwNAotCiAjZW5kaWYJCQkJLyogX19BTUxDT0RFX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9hbWxyZXNyYy5oIGIvZHJpdmVycy9hY3BpL2FjcGljYS9hbWxyZXNyYy5oCmluZGV4IDBlNTc5OGYuLjU5MTIyY2QgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvYW1scmVzcmMuaAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2FtbHJlc3JjLmgKQEAgLTYsNyArNiw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2RzZmllbGQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNmaWVsZC5jCmluZGV4IDM0N2JlZTEuLjM0YmU2MGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNmaWVsZC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNmaWVsZC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc2luaXQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNpbml0LmMKaW5kZXggY2M0YTM4Yy4uYTc3MThiZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc2luaXQuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2RzaW5pdC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc21ldGhvZC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc21ldGhvZC5jCmluZGV4IGQ5NGRkODkuLjVkNzk3NzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNtZXRob2QuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2RzbWV0aG9kLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC00Myw3ICs0Myw2IEBACiAKICNpbmNsdWRlIDxhY3BpL2FjcGkuaD4KICNpbmNsdWRlICJhY2NvbW1vbi5oIgotI2luY2x1ZGUgImFtbGNvZGUuaCIKICNpbmNsdWRlICJhY2Rpc3BhdC5oIgogI2luY2x1ZGUgImFjaW50ZXJwLmgiCiAjaW5jbHVkZSAiYWNuYW1lc3AuaCIKQEAgLTIwMSw3ICsyMDAsNyBAQAogCS8qCiAJICogSWYgdGhpcyBtZXRob2QgaXMgc2VyaWFsaXplZCwgd2UgbmVlZCB0byBhY3F1aXJlIHRoZSBtZXRob2QgbXV0ZXguCiAJICovCi0JaWYgKG9ial9kZXNjLT5tZXRob2QubWV0aG9kX2ZsYWdzICYgQU1MX01FVEhPRF9TRVJJQUxJWkVEKSB7CisJaWYgKG9ial9kZXNjLT5tZXRob2QuaW5mb19mbGFncyAmIEFDUElfTUVUSE9EX1NFUklBTElaRUQpIHsKIAkJLyoKIAkJICogQ3JlYXRlIGEgbXV0ZXggZm9yIHRoZSBtZXRob2QgaWYgaXQgaXMgZGVmaW5lZCB0byBiZSBTZXJpYWxpemVkCiAJCSAqIGFuZCBhIG11dGV4IGhhcyBub3QgYWxyZWFkeSBiZWVuIGNyZWF0ZWQuIFdlIGRlZmVyIHRoZSBtdXRleCBjcmVhdGlvbgpAQCAtNDEzLDggKzQxMiw5IEBACiAKIAkvKiBJbnZva2UgYW4gaW50ZXJuYWwgbWV0aG9kIGlmIG5lY2Vzc2FyeSAqLwogCi0JaWYgKG9ial9kZXNjLT5tZXRob2QubWV0aG9kX2ZsYWdzICYgQU1MX01FVEhPRF9JTlRFUk5BTF9PTkxZKSB7Ci0JCXN0YXR1cyA9IG9ial9kZXNjLT5tZXRob2QuZXh0cmEuaW1wbGVtZW50YXRpb24obmV4dF93YWxrX3N0YXRlKTsKKwlpZiAob2JqX2Rlc2MtPm1ldGhvZC5pbmZvX2ZsYWdzICYgQUNQSV9NRVRIT0RfSU5URVJOQUxfT05MWSkgeworCQlzdGF0dXMgPQorCQkgICAgb2JqX2Rlc2MtPm1ldGhvZC5kaXNwYXRjaC5pbXBsZW1lbnRhdGlvbihuZXh0X3dhbGtfc3RhdGUpOwogCQlpZiAoc3RhdHVzID09IEFFX09LKSB7CiAJCQlzdGF0dXMgPSBBRV9DVFJMX1RFUk1JTkFURTsKIAkJfQpAQCAtNTc5LDExICs1NzksMTQgQEAKIAogCQkvKgogCQkgKiBEZWxldGUgYW55IG5hbWVzcGFjZSBvYmplY3RzIGNyZWF0ZWQgYW55d2hlcmUgd2l0aGluIHRoZQotCQkgKiBuYW1lc3BhY2UgYnkgdGhlIGV4ZWN1dGlvbiBvZiB0aGlzIG1ldGhvZC4gVW5sZXNzIHRoaXMgbWV0aG9kCi0JCSAqIGlzIGEgbW9kdWxlLWxldmVsIGV4ZWN1dGFibGUgY29kZSBtZXRob2QsIGluIHdoaWNoIGNhc2Ugd2UKLQkJICogd2FudCBtYWtlIHRoZSBvYmplY3RzIHBlcm1hbmVudC4KKwkJICogbmFtZXNwYWNlIGJ5IHRoZSBleGVjdXRpb24gb2YgdGhpcyBtZXRob2QuIFVubGVzczoKKwkJICogMSkgVGhpcyBtZXRob2QgaXMgYSBtb2R1bGUtbGV2ZWwgZXhlY3V0YWJsZSBjb2RlIG1ldGhvZCwgaW4gd2hpY2gKKwkJICogICAgY2FzZSB3ZSB3YW50IG1ha2UgdGhlIG9iamVjdHMgcGVybWFuZW50LgorCQkgKiAyKSBUaGVyZSBhcmUgb3RoZXIgdGhyZWFkcyBleGVjdXRpbmcgdGhlIG1ldGhvZCwgaW4gd2hpY2ggY2FzZSB3ZQorCQkgKiAgICB3aWxsIHdhaXQgdW50aWwgdGhlIGxhc3QgdGhyZWFkIGhhcyBjb21wbGV0ZWQuCiAJCSAqLwotCQlpZiAoIShtZXRob2RfZGVzYy0+bWV0aG9kLmZsYWdzICYgQU9QT0JKX01PRFVMRV9MRVZFTCkpIHsKKwkJaWYgKCEobWV0aG9kX2Rlc2MtPm1ldGhvZC5pbmZvX2ZsYWdzICYgQUNQSV9NRVRIT0RfTU9EVUxFX0xFVkVMKQorCQkgICAgJiYgKG1ldGhvZF9kZXNjLT5tZXRob2QudGhyZWFkX2NvdW50ID09IDEpKSB7CiAKIAkJCS8qIERlbGV0ZSBhbnkgZGlyZWN0IGNoaWxkcmVuIG9mIChjcmVhdGVkIGJ5KSB0aGlzIG1ldGhvZCAqLwogCkBAIC01OTMsMTIgKzU5NiwxNyBAQAogCQkJLyoKIAkJCSAqIERlbGV0ZSBhbnkgb2JqZWN0cyB0aGF0IHdlcmUgY3JlYXRlZCBieSB0aGlzIG1ldGhvZAogCQkJICogZWxzZXdoZXJlIGluIHRoZSBuYW1lc3BhY2UgKGlmIGFueSB3ZXJlIGNyZWF0ZWQpLgorCQkJICogVXNlIG9mIHRoZSBBQ1BJX01FVEhPRF9NT0RJRklFRF9OQU1FU1BBQ0Ugb3B0aW1pemVzIHRoZQorCQkJICogZGVsZXRpb24gc3VjaCB0aGF0IHdlIGRvbid0IGhhdmUgdG8gcGVyZm9ybSBhbiBlbnRpcmUKKwkJCSAqIG5hbWVzcGFjZSB3YWxrIGZvciBldmVyeSBjb250cm9sIG1ldGhvZCBleGVjdXRpb24uCiAJCQkgKi8KIAkJCWlmIChtZXRob2RfZGVzYy0+bWV0aG9kLgotCQkJICAgIGZsYWdzICYgQU9QT0JKX01PRElGSUVEX05BTUVTUEFDRSkgeworCQkJICAgIGluZm9fZmxhZ3MgJiBBQ1BJX01FVEhPRF9NT0RJRklFRF9OQU1FU1BBQ0UpIHsKIAkJCQlhY3BpX25zX2RlbGV0ZV9uYW1lc3BhY2VfYnlfb3duZXIobWV0aG9kX2Rlc2MtPgogCQkJCQkJCQkgIG1ldGhvZC4KIAkJCQkJCQkJICBvd25lcl9pZCk7CisJCQkJbWV0aG9kX2Rlc2MtPm1ldGhvZC5pbmZvX2ZsYWdzICY9CisJCQkJICAgIH5BQ1BJX01FVEhPRF9NT0RJRklFRF9OQU1FU1BBQ0U7CiAJCQl9CiAJCX0KIAl9CkBAIC02MjksMTkgKzYzNyw0MyBAQAogCQkgKiBTZXJpYWxpemVkIGlmIGl0IGFwcGVhcnMgdGhhdCB0aGUgbWV0aG9kIGlzIGluY29ycmVjdGx5IHdyaXR0ZW4gYW5kCiAJCSAqIGRvZXMgbm90IHN1cHBvcnQgbXVsdGlwbGUgdGhyZWFkIGV4ZWN1dGlvbi4gVGhlIGJlc3QgZXhhbXBsZSBvZiB0aGlzCiAJCSAqIGlzIGlmIHN1Y2ggYSBtZXRob2QgY3JlYXRlcyBuYW1lc3BhY2Ugb2JqZWN0cyBhbmQgYmxvY2tzLiBBIHNlY29uZAotCQkgKiB0aHJlYWQgd2lsbCBmYWlsIHdpdGggYW4gQUVfQUxSRUFEWV9FWElTVFMgZXhjZXB0aW9uCisJCSAqIHRocmVhZCB3aWxsIGZhaWwgd2l0aCBhbiBBRV9BTFJFQURZX0VYSVNUUyBleGNlcHRpb24uCiAJCSAqCiAJCSAqIFRoaXMgY29kZSBpcyBoZXJlIGJlY2F1c2Ugd2UgbXVzdCB3YWl0IHVudGlsIHRoZSBsYXN0IHRocmVhZCBleGl0cwotCQkgKiBiZWZvcmUgY3JlYXRpbmcgdGhlIHN5bmNocm9uaXphdGlvbiBzZW1hcGhvcmUuCisJCSAqIGJlZm9yZSBtYXJraW5nIHRoZSBtZXRob2QgYXMgc2VyaWFsaXplZC4KIAkJICovCi0JCWlmICgobWV0aG9kX2Rlc2MtPm1ldGhvZC5tZXRob2RfZmxhZ3MgJiBBTUxfTUVUSE9EX1NFUklBTElaRUQpCi0JCSAgICAmJiAoIW1ldGhvZF9kZXNjLT5tZXRob2QubXV0ZXgpKSB7Ci0JCQkodm9pZClhY3BpX2RzX2NyZWF0ZV9tZXRob2RfbXV0ZXgobWV0aG9kX2Rlc2MpOworCQlpZiAobWV0aG9kX2Rlc2MtPm1ldGhvZC4KKwkJICAgIGluZm9fZmxhZ3MgJiBBQ1BJX01FVEhPRF9TRVJJQUxJWkVEX1BFTkRJTkcpIHsKKwkJCWlmICh3YWxrX3N0YXRlKSB7CisJCQkJQUNQSV9JTkZPKChBRV9JTkZPLAorCQkJCQkgICAiTWFya2luZyBtZXRob2QgJTQuNHMgYXMgU2VyaWFsaXplZCBiZWNhdXNlIG9mIEFFX0FMUkVBRFlfRVhJU1RTIGVycm9yIiwKKwkJCQkJICAgd2Fsa19zdGF0ZS0+bWV0aG9kX25vZGUtPm5hbWUuCisJCQkJCSAgIGFzY2lpKSk7CisJCQl9CisKKwkJCS8qCisJCQkgKiBNZXRob2QgdHJpZWQgdG8gY3JlYXRlIGFuIG9iamVjdCB0d2ljZSBhbmQgd2FzIG1hcmtlZCBhcworCQkJICogInBlbmRpbmcgc2VyaWFsaXplZCIuIFRoZSBwcm9iYWJsZSBjYXVzZSBpcyB0aGF0IHRoZSBtZXRob2QKKwkJCSAqIGNhbm5vdCBoYW5kbGUgcmVlbnRyYW5jeS4KKwkJCSAqCisJCQkgKiBUaGUgbWV0aG9kIHdhcyBjcmVhdGVkIGFzIG5vdF9zZXJpYWxpemVkLCBidXQgaXQgdHJpZWQgdG8gY3JlYXRlCisJCQkgKiBhIG5hbWVkIG9iamVjdCBhbmQgdGhlbiBibG9ja2VkLCBjYXVzaW5nIHRoZSBzZWNvbmQgdGhyZWFkCisJCQkgKiBlbnRyYW5jZSB0byBiZWdpbiBhbmQgdGhlbiBmYWlsLiBXb3JrYXJvdW5kIHRoaXMgcHJvYmxlbSBieQorCQkJICogbWFya2luZyB0aGUgbWV0aG9kIHBlcm1hbmVudGx5IGFzIFNlcmlhbGl6ZWQgd2hlbiB0aGUgbGFzdAorCQkJICogdGhyZWFkIGV4aXRzIGhlcmUuCisJCQkgKi8KKwkJCW1ldGhvZF9kZXNjLT5tZXRob2QuaW5mb19mbGFncyAmPQorCQkJICAgIH5BQ1BJX01FVEhPRF9TRVJJQUxJWkVEX1BFTkRJTkc7CisJCQltZXRob2RfZGVzYy0+bWV0aG9kLmluZm9fZmxhZ3MgfD0KKwkJCSAgICBBQ1BJX01FVEhPRF9TRVJJQUxJWkVEOworCQkJbWV0aG9kX2Rlc2MtPm1ldGhvZC5zeW5jX2xldmVsID0gMDsKIAkJfQogCiAJCS8qIE5vIG1vcmUgdGhyZWFkcywgd2UgY2FuIGZyZWUgdGhlIG93bmVyX2lkICovCiAKLQkJaWYgKCEobWV0aG9kX2Rlc2MtPm1ldGhvZC5mbGFncyAmIEFPUE9CSl9NT0RVTEVfTEVWRUwpKSB7CisJCWlmICghCisJCSAgICAobWV0aG9kX2Rlc2MtPm1ldGhvZC4KKwkJICAgICBpbmZvX2ZsYWdzICYgQUNQSV9NRVRIT0RfTU9EVUxFX0xFVkVMKSkgewogCQkJYWNwaV91dF9yZWxlYXNlX293bmVyX2lkKCZtZXRob2RfZGVzYy0+bWV0aG9kLm93bmVyX2lkKTsKIAkJfQogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNtdGhkYXQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNtdGhkYXQuYwppbmRleCA4MDk1MzA2Li45MDVjZTI5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2RzbXRoZGF0LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc210aGRhdC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNvYmplY3QuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNvYmplY3QuYwppbmRleCA4ZTg1ZjU0Li5mNDJlMTdlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzb2JqZWN0LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc29iamVjdC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc29wY29kZS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc29wY29kZS5jCmluZGV4IDdjMGU3NDIuLmJiZWNmMjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHNvcGNvZGUuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzb3Bjb2RlLmMKQEAgLTYsNyArNiw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2RzdXRpbHMuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN1dGlscy5jCmluZGV4IDE1MTM1YzIuLjJjNDc3Y2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN1dGlscy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN1dGlscy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN3ZXhlYy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc3dleGVjLmMKaW5kZXggNmIwYjVkMC4uZmU0MGU0YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc3dleGVjLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc3dleGVjLmMKQEAgLTYsNyArNiw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzd2xvYWQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN3bG9hZC5jCmluZGV4IDE0MGE5ZDAuLjUyNTY2ZmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN3bG9hZC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN3bG9hZC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc3dzY29wZS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9kc3dzY29wZS5jCmluZGV4IGQxZTcwMTcuLjc2YTY2MWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN3c2NvcGUuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzd3Njb3BlLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzd3N0YXRlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2Rzd3N0YXRlLmMKaW5kZXggODMxNTVkZC4uYTZjMzc0ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9kc3dzdGF0ZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZHN3c3RhdGUuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZldmVudC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldmV2ZW50LmMKaW5kZXggYzYxYzMwMzkuLmQ0NThiMDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZldmVudC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZldmVudC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtMjE3LDkgKzIxNywxNyBAQAogCQkgICAgIHN0YXR1c19iaXRfbWFzaykKIAkJICAgICYmIChmaXhlZF9lbmFibGUgJiBhY3BpX2dibF9maXhlZF9ldmVudF9pbmZvW2ldLgogCQkJZW5hYmxlX2JpdF9tYXNrKSkgeworCQkJLyoKKwkJCSAqIEZvdW5kIGFuIGFjdGl2ZSAoc2lnbmFsbGVkKSBldmVudC4gSW52b2tlIGdsb2JhbCBldmVudAorCQkJICogaGFuZGxlciBpZiBwcmVzZW50LgorCQkJICovCisJCQlhY3BpX2ZpeGVkX2V2ZW50X2NvdW50W2ldKys7CisJCQlpZiAoYWNwaV9nYmxfZ2xvYmFsX2V2ZW50X2hhbmRsZXIpIHsKKwkJCQlhY3BpX2dibF9nbG9iYWxfZXZlbnRfaGFuZGxlcgorCQkJCSAgICAoQUNQSV9FVkVOVF9UWVBFX0ZJWEVELCBOVUxMLCBpLAorCQkJCSAgICAgYWNwaV9nYmxfZ2xvYmFsX2V2ZW50X2hhbmRsZXJfY29udGV4dCk7CisJCQl9CiAKLQkJCS8qIEZvdW5kIGFuIGFjdGl2ZSAoc2lnbmFsbGVkKSBldmVudCAqLwotCQkJYWNwaV9vc19maXhlZF9ldmVudF9jb3VudChpKTsKIAkJCWludF9zdGF0dXMgfD0gYWNwaV9ldl9maXhlZF9ldmVudF9kaXNwYXRjaChpKTsKIAkJfQogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZncGUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZncGUuYwppbmRleCBmMjI2ZWFjLi4xNDk4OGE4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2Z3BlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldmdwZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtNTIsNiArNTIsOCBAQAogLyogTG9jYWwgcHJvdG90eXBlcyAqLwogc3RhdGljIHZvaWQgQUNQSV9TWVNURU1fWEZBQ0UgYWNwaV9ldl9hc3luY2hfZXhlY3V0ZV9ncGVfbWV0aG9kKHZvaWQgKmNvbnRleHQpOwogCitzdGF0aWMgdm9pZCBBQ1BJX1NZU1RFTV9YRkFDRSBhY3BpX2V2X2FzeW5jaF9lbmFibGVfZ3BlKHZvaWQgKmNvbnRleHQpOworCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoKICAqIEZVTkNUSU9OOiAgICBhY3BpX2V2X3VwZGF0ZV9ncGVfZW5hYmxlX21hc2sKQEAgLTEwMiw3ICsxMDQsNyBAQAogICoKICAqIFJFVFVSTjogICAgICBTdGF0dXMKICAqCi0gKiBERVNDUklQVElPTjogQ2xlYXIgdGhlIGdpdmVuIEdQRSBmcm9tIHN0YWxlIGV2ZW50cyBhbmQgZW5hYmxlIGl0LgorICogREVTQ1JJUFRJT046IENsZWFyIGEgR1BFIG9mIHN0YWxlIGV2ZW50cyBhbmQgZW5hYmxlIGl0LgogICoKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiBhY3BpX3N0YXR1cwpAQCAtMTEzLDEyICsxMTUsMTMgQEAKIAlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGV2X2VuYWJsZV9ncGUpOwogCiAJLyoKLQkgKiBXZSB3aWxsIG9ubHkgYWxsb3cgYSBHUEUgdG8gYmUgZW5hYmxlZCBpZiBpdCBoYXMgZWl0aGVyIGFuCi0JICogYXNzb2NpYXRlZCBtZXRob2QgKF9MeHgvX0V4eCkgb3IgYSBoYW5kbGVyLiBPdGhlcndpc2UsIHRoZQotCSAqIEdQRSB3aWxsIGJlIGltbWVkaWF0ZWx5IGRpc2FibGVkIGJ5IGFjcGlfZXZfZ3BlX2Rpc3BhdGNoIHRoZQotCSAqIGZpcnN0IHRpbWUgaXQgZmlyZXMuCisJICogV2Ugd2lsbCBvbmx5IGFsbG93IGEgR1BFIHRvIGJlIGVuYWJsZWQgaWYgaXQgaGFzIGVpdGhlciBhbiBhc3NvY2lhdGVkCisJICogbWV0aG9kIChfTHh4L19FeHgpIG9yIGEgaGFuZGxlciwgb3IgaXMgdXNpbmcgdGhlIGltcGxpY2l0IG5vdGlmeQorCSAqIGZlYXR1cmUuIE90aGVyd2lzZSwgdGhlIEdQRSB3aWxsIGJlIGltbWVkaWF0ZWx5IGRpc2FibGVkIGJ5CisJICogYWNwaV9ldl9ncGVfZGlzcGF0Y2ggdGhlIGZpcnN0IHRpbWUgaXQgZmlyZXMuCiAJICovCi0JaWYgKCEoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfRElTUEFUQ0hfTUFTSykpIHsKKwlpZiAoKGdwZV9ldmVudF9pbmZvLT5mbGFncyAmIEFDUElfR1BFX0RJU1BBVENIX01BU0spID09CisJICAgIEFDUElfR1BFX0RJU1BBVENIX05PTkUpIHsKIAkJcmV0dXJuX0FDUElfU1RBVFVTKEFFX05PX0hBTkRMRVIpOwogCX0KIApAQCAtMTM3LDkgKzE0MCw5IEBACiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgotICogRlVOQ1RJT046ICAgIGFjcGlfcmF3X2VuYWJsZV9ncGUKKyAqIEZVTkNUSU9OOiAgICBhY3BpX2V2X2FkZF9ncGVfcmVmZXJlbmNlCiAgKgotICogUEFSQU1FVEVSUzogIGdwZV9ldmVudF9pbmZvICAtIEdQRSB0byBlbmFibGUKKyAqIFBBUkFNRVRFUlM6ICBncGVfZXZlbnRfaW5mbyAgICAgICAgICAtIEFkZCBhIHJlZmVyZW5jZSB0byB0aGlzIEdQRQogICoKICAqIFJFVFVSTjogICAgICBTdGF0dXMKICAqCkBAIC0xNDgsMTYgKzE1MSwyMSBAQAogICoKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKLWFjcGlfc3RhdHVzIGFjcGlfcmF3X2VuYWJsZV9ncGUoc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvKQorYWNwaV9zdGF0dXMgYWNwaV9ldl9hZGRfZ3BlX3JlZmVyZW5jZShzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbyAqZ3BlX2V2ZW50X2luZm8pCiB7CiAJYWNwaV9zdGF0dXMgc3RhdHVzID0gQUVfT0s7CiAKKwlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGV2X2FkZF9ncGVfcmVmZXJlbmNlKTsKKwogCWlmIChncGVfZXZlbnRfaW5mby0+cnVudGltZV9jb3VudCA9PSBBQ1BJX1VJTlQ4X01BWCkgewogCQlyZXR1cm5fQUNQSV9TVEFUVVMoQUVfTElNSVQpOwogCX0KIAogCWdwZV9ldmVudF9pbmZvLT5ydW50aW1lX2NvdW50Kys7CiAJaWYgKGdwZV9ldmVudF9pbmZvLT5ydW50aW1lX2NvdW50ID09IDEpIHsKKworCQkvKiBFbmFibGUgb24gZmlyc3QgcmVmZXJlbmNlICovCisKIAkJc3RhdHVzID0gYWNwaV9ldl91cGRhdGVfZ3BlX2VuYWJsZV9tYXNrKGdwZV9ldmVudF9pbmZvKTsKIAkJaWYgKEFDUElfU1VDQ0VTUyhzdGF0dXMpKSB7CiAJCQlzdGF0dXMgPSBhY3BpX2V2X2VuYWJsZV9ncGUoZ3BlX2V2ZW50X2luZm8pOwpAQCAtMTczLDkgKzE4MSw5IEBACiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgotICogRlVOQ1RJT046ICAgIGFjcGlfcmF3X2Rpc2FibGVfZ3BlCisgKiBGVU5DVElPTjogICAgYWNwaV9ldl9yZW1vdmVfZ3BlX3JlZmVyZW5jZQogICoKLSAqIFBBUkFNRVRFUlM6ICBncGVfZXZlbnRfaW5mbyAgLSBHUEUgdG8gZGlzYWJsZQorICogUEFSQU1FVEVSUzogIGdwZV9ldmVudF9pbmZvICAgICAgICAgIC0gUmVtb3ZlIGEgcmVmZXJlbmNlIHRvIHRoaXMgR1BFCiAgKgogICogUkVUVVJOOiAgICAgIFN0YXR1cwogICoKQEAgLTE4NCwxNiArMTkyLDIxIEBACiAgKgogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAotYWNwaV9zdGF0dXMgYWNwaV9yYXdfZGlzYWJsZV9ncGUoc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvKQorYWNwaV9zdGF0dXMgYWNwaV9ldl9yZW1vdmVfZ3BlX3JlZmVyZW5jZShzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbyAqZ3BlX2V2ZW50X2luZm8pCiB7CiAJYWNwaV9zdGF0dXMgc3RhdHVzID0gQUVfT0s7CiAKKwlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGV2X3JlbW92ZV9ncGVfcmVmZXJlbmNlKTsKKwogCWlmICghZ3BlX2V2ZW50X2luZm8tPnJ1bnRpbWVfY291bnQpIHsKIAkJcmV0dXJuX0FDUElfU1RBVFVTKEFFX0xJTUlUKTsKIAl9CiAKIAlncGVfZXZlbnRfaW5mby0+cnVudGltZV9jb3VudC0tOwogCWlmICghZ3BlX2V2ZW50X2luZm8tPnJ1bnRpbWVfY291bnQpIHsKKworCQkvKiBEaXNhYmxlIG9uIGxhc3QgcmVmZXJlbmNlICovCisKIAkJc3RhdHVzID0gYWNwaV9ldl91cGRhdGVfZ3BlX2VuYWJsZV9tYXNrKGdwZV9ldmVudF9pbmZvKTsKIAkJaWYgKEFDUElfU1VDQ0VTUyhzdGF0dXMpKSB7CiAJCQlzdGF0dXMgPSBhY3BpX2h3X2xvd19zZXRfZ3BlKGdwZV9ldmVudF9pbmZvLApAQCAtMzc5LDcgKzM5Miw3IEBACiAJCQl9CiAKIAkJCUFDUElfREVCVUdfUFJJTlQoKEFDUElfREJfSU5URVJSVVBUUywKLQkJCQkJICAiUmVhZCBHUEUgUmVnaXN0ZXIgYXQgR1BFJVg6IFN0YXR1cz0lMDJYLCBFbmFibGU9JTAyWFxuIiwKKwkJCQkJICAiUmVhZCBHUEUgUmVnaXN0ZXIgYXQgR1BFJTAyWDogU3RhdHVzPSUwMlgsIEVuYWJsZT0lMDJYXG4iLAogCQkJCQkgIGdwZV9yZWdpc3Rlcl9pbmZvLT5iYXNlX2dwZV9udW1iZXIsCiAJCQkJCSAgc3RhdHVzX3JlZywgZW5hYmxlX3JlZykpOwogCkBAIC00MDUsNyArNDE4LDkgQEAKIAkJCQkJICogb3IgbWV0aG9kLgogCQkJCQkgKi8KIAkJCQkJaW50X3N0YXR1cyB8PQotCQkJCQkgICAgYWNwaV9ldl9ncGVfZGlzcGF0Y2goJmdwZV9ibG9jay0+CisJCQkJCSAgICBhY3BpX2V2X2dwZV9kaXNwYXRjaChncGVfYmxvY2stPgorCQkJCQkJCQkgbm9kZSwKKwkJCQkJCQkJICZncGVfYmxvY2stPgogCQkJCQkJZXZlbnRfaW5mb1soKGFjcGlfc2l6ZSkgaSAqIEFDUElfR1BFX1JFR0lTVEVSX1dJRFRIKSArIGpdLCBqICsgZ3BlX3JlZ2lzdGVyX2luZm8tPmJhc2VfZ3BlX251bWJlcik7CiAJCQkJfQogCQkJfQpAQCAtNDM1LDE5ICs0NTAsMjggQEAKICAqICAgICAgICAgICAgICBhbiBpbnRlcnJ1cHQgaGFuZGxlci4KICAqCiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotc3RhdGljIHZvaWQgYWNwaV9ldl9hc3luY2hfZW5hYmxlX2dwZSh2b2lkICpjb250ZXh0KTsKIAogc3RhdGljIHZvaWQgQUNQSV9TWVNURU1fWEZBQ0UgYWNwaV9ldl9hc3luY2hfZXhlY3V0ZV9ncGVfbWV0aG9kKHZvaWQgKmNvbnRleHQpCiB7Ci0Jc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvID0gKHZvaWQgKiljb250ZXh0OworCXN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbyA9IGNvbnRleHQ7CiAJYWNwaV9zdGF0dXMgc3RhdHVzOwotCXN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvIGxvY2FsX2dwZV9ldmVudF9pbmZvOworCXN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpsb2NhbF9ncGVfZXZlbnRfaW5mbzsKIAlzdHJ1Y3QgYWNwaV9ldmFsdWF0ZV9pbmZvICppbmZvOwogCiAJQUNQSV9GVU5DVElPTl9UUkFDRShldl9hc3luY2hfZXhlY3V0ZV9ncGVfbWV0aG9kKTsKIAorCS8qIEFsbG9jYXRlIGEgbG9jYWwgR1BFIGJsb2NrICovCisKKwlsb2NhbF9ncGVfZXZlbnRfaW5mbyA9CisJICAgIEFDUElfQUxMT0NBVEVfWkVST0VEKHNpemVvZihzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbykpOworCWlmICghbG9jYWxfZ3BlX2V2ZW50X2luZm8pIHsKKwkJQUNQSV9FWENFUFRJT04oKEFFX0lORk8sIEFFX05PX01FTU9SWSwgIndoaWxlIGhhbmRsaW5nIGEgR1BFIikpOworCQlyZXR1cm5fVk9JRDsKKwl9CisKIAlzdGF0dXMgPSBhY3BpX3V0X2FjcXVpcmVfbXV0ZXgoQUNQSV9NVFhfRVZFTlRTKTsKIAlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKKwkJQUNQSV9GUkVFKGxvY2FsX2dwZV9ldmVudF9pbmZvKTsKIAkJcmV0dXJuX1ZPSUQ7CiAJfQogCkBAIC00NTUsNiArNDc5LDcgQEAKIAogCWlmICghYWNwaV9ldl92YWxpZF9ncGVfZXZlbnQoZ3BlX2V2ZW50X2luZm8pKSB7CiAJCXN0YXR1cyA9IGFjcGlfdXRfcmVsZWFzZV9tdXRleChBQ1BJX01UWF9FVkVOVFMpOworCQlBQ1BJX0ZSRUUobG9jYWxfZ3BlX2V2ZW50X2luZm8pOwogCQlyZXR1cm5fVk9JRDsKIAl9CiAKQEAgLTQ2Miw3ICs0ODcsNyBAQAogCSAqIFRha2UgYSBzbmFwc2hvdCBvZiB0aGUgR1BFIGluZm8gZm9yIHRoaXMgbGV2ZWwgLSB3ZSBjb3B5IHRoZSBpbmZvIHRvCiAJICogcHJldmVudCBhIHJhY2UgY29uZGl0aW9uIHdpdGggcmVtb3ZlX2hhbmRsZXIvcmVtb3ZlX2Jsb2NrLgogCSAqLwotCUFDUElfTUVNQ1BZKCZsb2NhbF9ncGVfZXZlbnRfaW5mbywgZ3BlX2V2ZW50X2luZm8sCisJQUNQSV9NRU1DUFkobG9jYWxfZ3BlX2V2ZW50X2luZm8sIGdwZV9ldmVudF9pbmZvLAogCQkgICAgc2l6ZW9mKHN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvKSk7CiAKIAlzdGF0dXMgPSBhY3BpX3V0X3JlbGVhc2VfbXV0ZXgoQUNQSV9NVFhfRVZFTlRTKTsKQEAgLTQ3MCwxMiArNDk1LDI2IEBACiAJCXJldHVybl9WT0lEOwogCX0KIAotCS8qCi0JICogTXVzdCBjaGVjayBmb3IgY29udHJvbCBtZXRob2QgdHlwZSBkaXNwYXRjaCBvbmUgbW9yZSB0aW1lIHRvIGF2b2lkIGEKLQkgKiByYWNlIHdpdGggZXZfZ3BlX2luc3RhbGxfaGFuZGxlcgotCSAqLwotCWlmICgobG9jYWxfZ3BlX2V2ZW50X2luZm8uZmxhZ3MgJiBBQ1BJX0dQRV9ESVNQQVRDSF9NQVNLKSA9PQotCSAgICBBQ1BJX0dQRV9ESVNQQVRDSF9NRVRIT0QpIHsKKwkvKiBEbyB0aGUgY29ycmVjdCBkaXNwYXRjaCAtIG5vcm1hbCBtZXRob2Qgb3IgaW1wbGljaXQgbm90aWZ5ICovCisKKwlzd2l0Y2ggKGxvY2FsX2dwZV9ldmVudF9pbmZvLT5mbGFncyAmIEFDUElfR1BFX0RJU1BBVENIX01BU0spIHsKKwljYXNlIEFDUElfR1BFX0RJU1BBVENIX05PVElGWToKKworCQkvKgorCQkgKiBJbXBsaWNpdCBub3RpZnkuCisJCSAqIERpc3BhdGNoIGEgREVWSUNFX1dBS0Ugbm90aWZ5IHRvIHRoZSBhcHByb3ByaWF0ZSBoYW5kbGVyLgorCQkgKiBOT1RFOiB0aGUgcmVxdWVzdCBpcyBxdWV1ZWQgZm9yIGV4ZWN1dGlvbiBhZnRlciB0aGlzIG1ldGhvZAorCQkgKiBjb21wbGV0ZXMuIFRoZSBub3RpZnkgaGFuZGxlcnMgYXJlIE5PVCBpbnZva2VkIHN5bmNocm9ub3VzbHkKKwkJICogZnJvbSB0aGlzIHRocmVhZCAtLSBiZWNhdXNlIGhhbmRsZXJzIG1heSBpbiB0dXJuIHJ1biBvdGhlcgorCQkgKiBjb250cm9sIG1ldGhvZHMuCisJCSAqLworCQlzdGF0dXMgPQorCQkgICAgYWNwaV9ldl9xdWV1ZV9ub3RpZnlfcmVxdWVzdChsb2NhbF9ncGVfZXZlbnRfaW5mby0+ZGlzcGF0Y2guCisJCQkJCQkgZGV2aWNlX25vZGUsCisJCQkJCQkgQUNQSV9OT1RJRllfREVWSUNFX1dBS0UpOworCQlicmVhazsKKworCWNhc2UgQUNQSV9HUEVfRElTUEFUQ0hfTUVUSE9EOgogCiAJCS8qIEFsbG9jYXRlIHRoZSBldmFsdWF0aW9uIGluZm9ybWF0aW9uIGJsb2NrICovCiAKQEAgLTQ4OCw3ICs1MjcsNyBAQAogCQkJICogY29udHJvbCBtZXRob2QgdGhhdCBjb3JyZXNwb25kcyB0byB0aGlzIEdQRQogCQkJICovCiAJCQlpbmZvLT5wcmVmaXhfbm9kZSA9Ci0JCQkgICAgbG9jYWxfZ3BlX2V2ZW50X2luZm8uZGlzcGF0Y2gubWV0aG9kX25vZGU7CisJCQkgICAgbG9jYWxfZ3BlX2V2ZW50X2luZm8tPmRpc3BhdGNoLm1ldGhvZF9ub2RlOwogCQkJaW5mby0+ZmxhZ3MgPSBBQ1BJX0lHTk9SRV9SRVRVUk5fVkFMVUU7CiAKIAkJCXN0YXR1cyA9IGFjcGlfbnNfZXZhbHVhdGUoaW5mbyk7CkBAIC00OTksNDYgKzUzOCw5OCBAQAogCQkJQUNQSV9FWENFUFRJT04oKEFFX0lORk8sIHN0YXR1cywKIAkJCQkJIndoaWxlIGV2YWx1YXRpbmcgR1BFIG1ldGhvZCBbJTQuNHNdIiwKIAkJCQkJYWNwaV91dF9nZXRfbm9kZV9uYW1lCi0JCQkJCShsb2NhbF9ncGVfZXZlbnRfaW5mby5kaXNwYXRjaC4KKwkJCQkJKGxvY2FsX2dwZV9ldmVudF9pbmZvLT5kaXNwYXRjaC4KIAkJCQkJIG1ldGhvZF9ub2RlKSkpOwogCQl9CisKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQlyZXR1cm5fVk9JRDsgICAgLyogU2hvdWxkIG5ldmVyIGhhcHBlbiAqLwogCX0KKwogCS8qIERlZmVyIGVuYWJsaW5nIG9mIEdQRSB1bnRpbCBhbGwgbm90aWZ5IGhhbmRsZXJzIGFyZSBkb25lICovCi0JYWNwaV9vc19leGVjdXRlKE9TTF9OT1RJRllfSEFORExFUiwgYWNwaV9ldl9hc3luY2hfZW5hYmxlX2dwZSwKLQkJCQlncGVfZXZlbnRfaW5mbyk7CisKKwlzdGF0dXMgPSBhY3BpX29zX2V4ZWN1dGUoT1NMX05PVElGWV9IQU5ETEVSLAorCQkJCSBhY3BpX2V2X2FzeW5jaF9lbmFibGVfZ3BlLAorCQkJCSBsb2NhbF9ncGVfZXZlbnRfaW5mbyk7CisJaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKSB7CisJCUFDUElfRlJFRShsb2NhbF9ncGVfZXZlbnRfaW5mbyk7CisJfQogCXJldHVybl9WT0lEOwogfQogCi1zdGF0aWMgdm9pZCBhY3BpX2V2X2FzeW5jaF9lbmFibGVfZ3BlKHZvaWQgKmNvbnRleHQpCisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKgorICogRlVOQ1RJT046ICAgIGFjcGlfZXZfYXN5bmNoX2VuYWJsZV9ncGUKKyAqCisgKiBQQVJBTUVURVJTOiAgQ29udGV4dCAoZ3BlX2V2ZW50X2luZm8pIC0gSW5mbyBmb3IgdGhpcyBHUEUKKyAqICAgICAgICAgICAgICBDYWxsYmFjayBmcm9tIGFjcGlfb3NfZXhlY3V0ZQorICoKKyAqIFJFVFVSTjogICAgICBOb25lCisgKgorICogREVTQ1JJUFRJT046IEFzeW5jaHJvbm91cyBjbGVhci9lbmFibGUgZm9yIEdQRS4gVGhpcyBhbGxvd3MgdGhlIEdQRSB0bworICogICAgICAgICAgICAgIGNvbXBsZXRlIChpLmUuLCBmaW5pc2ggZXhlY3V0aW9uIG9mIE5vdGlmeSkKKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCitzdGF0aWMgdm9pZCBBQ1BJX1NZU1RFTV9YRkFDRSBhY3BpX2V2X2FzeW5jaF9lbmFibGVfZ3BlKHZvaWQgKmNvbnRleHQpCiB7CiAJc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvID0gY29udGV4dDsKKworCSh2b2lkKWFjcGlfZXZfZmluaXNoX2dwZShncGVfZXZlbnRfaW5mbyk7CisKKwlBQ1BJX0ZSRUUoZ3BlX2V2ZW50X2luZm8pOworCXJldHVybjsKK30KKworCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICoKKyAqIEZVTkNUSU9OOiAgICBhY3BpX2V2X2ZpbmlzaF9ncGUKKyAqCisgKiBQQVJBTUVURVJTOiAgZ3BlX2V2ZW50X2luZm8gICAgICAtIEluZm8gZm9yIHRoaXMgR1BFCisgKgorICogUkVUVVJOOiAgICAgIFN0YXR1cworICoKKyAqIERFU0NSSVBUSU9OOiBDbGVhci9FbmFibGUgYSBHUEUuIENvbW1vbiBjb2RlIHRoYXQgaXMgdXNlZCBhZnRlciBleGVjdXRpb24KKyAqICAgICAgICAgICAgICBvZiBhIEdQRSBtZXRob2Qgb3IgYSBzeW5jaHJvbm91cyBvciBhc3luY2hyb25vdXMgR1BFIGhhbmRsZXIuCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworYWNwaV9zdGF0dXMgYWNwaV9ldl9maW5pc2hfZ3BlKHN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbykKK3sKIAlhY3BpX3N0YXR1cyBzdGF0dXM7CisKIAlpZiAoKGdwZV9ldmVudF9pbmZvLT5mbGFncyAmIEFDUElfR1BFX1hSVVBUX1RZUEVfTUFTSykgPT0KIAkgICAgQUNQSV9HUEVfTEVWRUxfVFJJR0dFUkVEKSB7CiAJCS8qCi0JCSAqIEdQRSBpcyBsZXZlbC10cmlnZ2VyZWQsIHdlIGNsZWFyIHRoZSBHUEUgc3RhdHVzIGJpdCBhZnRlciBoYW5kbGluZwotCQkgKiB0aGUgZXZlbnQuCisJCSAqIEdQRSBpcyBsZXZlbC10cmlnZ2VyZWQsIHdlIGNsZWFyIHRoZSBHUEUgc3RhdHVzIGJpdCBhZnRlcgorCQkgKiBoYW5kbGluZyB0aGUgZXZlbnQuCiAJCSAqLwogCQlzdGF0dXMgPSBhY3BpX2h3X2NsZWFyX2dwZShncGVfZXZlbnRfaW5mbyk7CiAJCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgewotCQkJcmV0dXJuX1ZPSUQ7CisJCQlyZXR1cm4gKHN0YXR1cyk7CiAJCX0KIAl9CiAKIAkvKgotCSAqIEVuYWJsZSB0aGlzIEdQRSwgY29uZGl0aW9uYWxseS4gVGhpcyBtZWFucyB0aGF0IHRoZSBHUEUgd2lsbCBvbmx5IGJlCi0JICogcGh5c2ljYWxseSBlbmFibGVkIGlmIHRoZSBlbmFibGVfZm9yX3J1biBiaXQgaXMgc2V0IGluIHRoZSBldmVudF9pbmZvCisJICogRW5hYmxlIHRoaXMgR1BFLCBjb25kaXRpb25hbGx5LiBUaGlzIG1lYW5zIHRoYXQgdGhlIEdQRSB3aWxsCisJICogb25seSBiZSBwaHlzaWNhbGx5IGVuYWJsZWQgaWYgdGhlIGVuYWJsZV9mb3JfcnVuIGJpdCBpcyBzZXQKKwkgKiBpbiB0aGUgZXZlbnRfaW5mby4KIAkgKi8KLQkodm9pZClhY3BpX2h3X2xvd19zZXRfZ3BlKGdwZV9ldmVudF9pbmZvLCBBQ1BJX0dQRV9DT05EX0VOQUJMRSk7Ci0KLQlyZXR1cm5fVk9JRDsKKwkodm9pZClhY3BpX2h3X2xvd19zZXRfZ3BlKGdwZV9ldmVudF9pbmZvLCBBQ1BJX0dQRV9DT05ESVRJT05BTF9FTkFCTEUpOworCXJldHVybiAoQUVfT0spOwogfQogCisKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgogICogRlVOQ1RJT046ICAgIGFjcGlfZXZfZ3BlX2Rpc3BhdGNoCiAgKgotICogUEFSQU1FVEVSUzogIGdwZV9ldmVudF9pbmZvICAtIEluZm8gZm9yIHRoaXMgR1BFCisgKiBQQVJBTUVURVJTOiAgZ3BlX2RldmljZSAgICAgIC0gRGV2aWNlIG5vZGUuIE5VTEwgZm9yIEdQRTAvR1BFMQorICogICAgICAgICAgICAgIGdwZV9ldmVudF9pbmZvICAtIEluZm8gZm9yIHRoaXMgR1BFCiAgKiAgICAgICAgICAgICAgZ3BlX251bWJlciAgICAgIC0gTnVtYmVyIHJlbGF0aXZlIHRvIHRoZSBwYXJlbnQgR1BFIGJsb2NrCiAgKgogICogUkVUVVJOOiAgICAgIElOVEVSUlVQVF9IQU5ETEVEIG9yIElOVEVSUlVQVF9OT1RfSEFORExFRApAQCAtNTUxLDEzICs2NDIsMjIgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIHUzMgotYWNwaV9ldl9ncGVfZGlzcGF0Y2goc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvLCB1MzIgZ3BlX251bWJlcikKK2FjcGlfZXZfZ3BlX2Rpc3BhdGNoKHN0cnVjdCBhY3BpX25hbWVzcGFjZV9ub2RlICpncGVfZGV2aWNlLAorCQkgICAgc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvLCB1MzIgZ3BlX251bWJlcikKIHsKIAlhY3BpX3N0YXR1cyBzdGF0dXM7CisJdTMyIHJldHVybl92YWx1ZTsKIAogCUFDUElfRlVOQ1RJT05fVFJBQ0UoZXZfZ3BlX2Rpc3BhdGNoKTsKIAotCWFjcGlfb3NfZ3BlX2NvdW50KGdwZV9udW1iZXIpOworCS8qIEludm9rZSBnbG9iYWwgZXZlbnQgaGFuZGxlciBpZiBwcmVzZW50ICovCisKKwlhY3BpX2dwZV9jb3VudCsrOworCWlmIChhY3BpX2dibF9nbG9iYWxfZXZlbnRfaGFuZGxlcikgeworCQlhY3BpX2dibF9nbG9iYWxfZXZlbnRfaGFuZGxlcihBQ1BJX0VWRU5UX1RZUEVfR1BFLCBncGVfZGV2aWNlLAorCQkJCQkgICAgICBncGVfbnVtYmVyLAorCQkJCQkgICAgICBhY3BpX2dibF9nbG9iYWxfZXZlbnRfaGFuZGxlcl9jb250ZXh0KTsKKwl9CiAKIAkvKgogCSAqIElmIGVkZ2UtdHJpZ2dlcmVkLCBjbGVhciB0aGUgR1BFIHN0YXR1cyBiaXQgbm93LiBOb3RlIHRoYXQKQEAgLTU2OCw1OSArNjY4LDU1IEBACiAJCXN0YXR1cyA9IGFjcGlfaHdfY2xlYXJfZ3BlKGdwZV9ldmVudF9pbmZvKTsKIAkJaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKSB7CiAJCQlBQ1BJX0VYQ0VQVElPTigoQUVfSU5GTywgc3RhdHVzLAotCQkJCQkiVW5hYmxlIHRvIGNsZWFyIEdQRVsweCUyWF0iLAotCQkJCQlncGVfbnVtYmVyKSk7CisJCQkJCSJVbmFibGUgdG8gY2xlYXIgR1BFJTAyWCIsIGdwZV9udW1iZXIpKTsKIAkJCXJldHVybl9VSU5UMzIoQUNQSV9JTlRFUlJVUFRfTk9UX0hBTkRMRUQpOwogCQl9CiAJfQogCiAJLyoKLQkgKiBEaXNwYXRjaCB0aGUgR1BFIHRvIGVpdGhlciBhbiBpbnN0YWxsZWQgaGFuZGxlciwgb3IgdGhlIGNvbnRyb2wgbWV0aG9kCi0JICogYXNzb2NpYXRlZCB3aXRoIHRoaXMgR1BFIChfTHh4IG9yIF9FeHgpLiBJZiBhIGhhbmRsZXIgZXhpc3RzLCB3ZSBpbnZva2UKLQkgKiBpdCBhbmQgZG8gbm90IGF0dGVtcHQgdG8gcnVuIHRoZSBtZXRob2QuIElmIHRoZXJlIGlzIG5laXRoZXIgYSBoYW5kbGVyCi0JICogbm9yIGEgbWV0aG9kLCB3ZSBkaXNhYmxlIHRoaXMgR1BFIHRvIHByZXZlbnQgZnVydGhlciBzdWNoIHBvaW50bGVzcwotCSAqIGV2ZW50cyBmcm9tIGZpcmluZy4KKwkgKiBBbHdheXMgZGlzYWJsZSB0aGUgR1BFIHNvIHRoYXQgaXQgZG9lcyBub3Qga2VlcCBmaXJpbmcgYmVmb3JlCisJICogYW55IGFzeW5jaHJvbm91cyBhY3Rpdml0eSBjb21wbGV0ZXMgKGVpdGhlciBmcm9tIHRoZSBleGVjdXRpb24KKwkgKiBvZiBhIEdQRSBtZXRob2Qgb3IgYW4gYXN5bmNocm9ub3VzIEdQRSBoYW5kbGVyLikKKwkgKgorCSAqIElmIHRoZXJlIGlzIG5vIGhhbmRsZXIgb3IgbWV0aG9kIHRvIHJ1biwganVzdCBkaXNhYmxlIHRoZQorCSAqIEdQRSBhbmQgbGVhdmUgaXQgZGlzYWJsZWQgcGVybWFuZW50bHkgdG8gcHJldmVudCBmdXJ0aGVyIHN1Y2gKKwkgKiBwb2ludGxlc3MgZXZlbnRzIGZyb20gZmlyaW5nLgorCSAqLworCXN0YXR1cyA9IGFjcGlfaHdfbG93X3NldF9ncGUoZ3BlX2V2ZW50X2luZm8sIEFDUElfR1BFX0RJU0FCTEUpOworCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgeworCQlBQ1BJX0VYQ0VQVElPTigoQUVfSU5GTywgc3RhdHVzLAorCQkJCSJVbmFibGUgdG8gZGlzYWJsZSBHUEUlMDJYIiwgZ3BlX251bWJlcikpOworCQlyZXR1cm5fVUlOVDMyKEFDUElfSU5URVJSVVBUX05PVF9IQU5ETEVEKTsKKwl9CisKKwkvKgorCSAqIERpc3BhdGNoIHRoZSBHUEUgdG8gZWl0aGVyIGFuIGluc3RhbGxlZCBoYW5kbGVyIG9yIHRoZSBjb250cm9sCisJICogbWV0aG9kIGFzc29jaWF0ZWQgd2l0aCB0aGlzIEdQRSAoX0x4eCBvciBfRXh4KS4gSWYgYSBoYW5kbGVyCisJICogZXhpc3RzLCB3ZSBpbnZva2UgaXQgYW5kIGRvIG5vdCBhdHRlbXB0IHRvIHJ1biB0aGUgbWV0aG9kLgorCSAqIElmIHRoZXJlIGlzIG5laXRoZXIgYSBoYW5kbGVyIG5vciBhIG1ldGhvZCwgbGVhdmUgdGhlIEdQRQorCSAqIGRpc2FibGVkLgogCSAqLwogCXN3aXRjaCAoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfRElTUEFUQ0hfTUFTSykgewogCWNhc2UgQUNQSV9HUEVfRElTUEFUQ0hfSEFORExFUjoKIAotCQkvKgotCQkgKiBJbnZva2UgdGhlIGluc3RhbGxlZCBoYW5kbGVyIChhdCBpbnRlcnJ1cHQgbGV2ZWwpCi0JCSAqIElnbm9yZSByZXR1cm4gc3RhdHVzIGZvciBub3cuCi0JCSAqIFRCRDogbGVhdmUgR1BFIGRpc2FibGVkIG9uIGVycm9yPwotCQkgKi8KLQkJKHZvaWQpZ3BlX2V2ZW50X2luZm8tPmRpc3BhdGNoLmhhbmRsZXItPmFkZHJlc3MoZ3BlX2V2ZW50X2luZm8tPgotCQkJCQkJCQlkaXNwYXRjaC4KLQkJCQkJCQkJaGFuZGxlci0+Ci0JCQkJCQkJCWNvbnRleHQpOworCQkvKiBJbnZva2UgdGhlIGluc3RhbGxlZCBoYW5kbGVyIChhdCBpbnRlcnJ1cHQgbGV2ZWwpICovCiAKLQkJLyogSXQgaXMgbm93IHNhZmUgdG8gY2xlYXIgbGV2ZWwtdHJpZ2dlcmVkIGV2ZW50cy4gKi8KKwkJcmV0dXJuX3ZhbHVlID0KKwkJICAgIGdwZV9ldmVudF9pbmZvLT5kaXNwYXRjaC5oYW5kbGVyLT5hZGRyZXNzKGdwZV9kZXZpY2UsCisJCQkJCQkJICAgICAgZ3BlX251bWJlciwKKwkJCQkJCQkgICAgICBncGVfZXZlbnRfaW5mby0+CisJCQkJCQkJICAgICAgZGlzcGF0Y2guaGFuZGxlci0+CisJCQkJCQkJICAgICAgY29udGV4dCk7CiAKLQkJaWYgKChncGVfZXZlbnRfaW5mby0+ZmxhZ3MgJiBBQ1BJX0dQRV9YUlVQVF9UWVBFX01BU0spID09Ci0JCSAgICBBQ1BJX0dQRV9MRVZFTF9UUklHR0VSRUQpIHsKLQkJCXN0YXR1cyA9IGFjcGlfaHdfY2xlYXJfZ3BlKGdwZV9ldmVudF9pbmZvKTsKLQkJCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgewotCQkJCUFDUElfRVhDRVBUSU9OKChBRV9JTkZPLCBzdGF0dXMsCi0JCQkJCSJVbmFibGUgdG8gY2xlYXIgR1BFWzB4JTJYXSIsCi0JCQkJCQlncGVfbnVtYmVyKSk7Ci0JCQkJcmV0dXJuX1VJTlQzMihBQ1BJX0lOVEVSUlVQVF9OT1RfSEFORExFRCk7Ci0JCQl9CisJCS8qIElmIHJlcXVlc3RlZCwgY2xlYXIgKGlmIGxldmVsLXRyaWdnZXJlZCkgYW5kIHJlZW5hYmxlIHRoZSBHUEUgKi8KKworCQlpZiAocmV0dXJuX3ZhbHVlICYgQUNQSV9SRUVOQUJMRV9HUEUpIHsKKwkJCSh2b2lkKWFjcGlfZXZfZmluaXNoX2dwZShncGVfZXZlbnRfaW5mbyk7CiAJCX0KIAkJYnJlYWs7CiAKIAljYXNlIEFDUElfR1BFX0RJU1BBVENIX01FVEhPRDoKLQotCQkvKgotCQkgKiBEaXNhYmxlIHRoZSBHUEUsIHNvIGl0IGRvZXNuJ3Qga2VlcCBmaXJpbmcgYmVmb3JlIHRoZSBtZXRob2QgaGFzIGEKLQkJICogY2hhbmNlIHRvIHJ1biAoaXQgcnVucyBhc3luY2hyb25vdXNseSB3aXRoIGludGVycnVwdHMgZW5hYmxlZCkuCi0JCSAqLwotCQlzdGF0dXMgPSBhY3BpX2h3X2xvd19zZXRfZ3BlKGdwZV9ldmVudF9pbmZvLCBBQ1BJX0dQRV9ESVNBQkxFKTsKLQkJaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKSB7Ci0JCQlBQ1BJX0VYQ0VQVElPTigoQUVfSU5GTywgc3RhdHVzLAotCQkJCQkiVW5hYmxlIHRvIGRpc2FibGUgR1BFWzB4JTJYXSIsCi0JCQkJCWdwZV9udW1iZXIpKTsKLQkJCXJldHVybl9VSU5UMzIoQUNQSV9JTlRFUlJVUFRfTk9UX0hBTkRMRUQpOwotCQl9CisJY2FzZSBBQ1BJX0dQRV9ESVNQQVRDSF9OT1RJRlk6CiAKIAkJLyoKIAkJICogRXhlY3V0ZSB0aGUgbWV0aG9kIGFzc29jaWF0ZWQgd2l0aCB0aGUgR1BFCkBAIC02MzEsNyArNzI3LDcgQEAKIAkJCQkJIGdwZV9ldmVudF9pbmZvKTsKIAkJaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKSB7CiAJCQlBQ1BJX0VYQ0VQVElPTigoQUVfSU5GTywgc3RhdHVzLAotCQkJCQkiVW5hYmxlIHRvIHF1ZXVlIGhhbmRsZXIgZm9yIEdQRVsweCUyWF0gLSBldmVudCBkaXNhYmxlZCIsCisJCQkJCSJVbmFibGUgdG8gcXVldWUgaGFuZGxlciBmb3IgR1BFJTJYIC0gZXZlbnQgZGlzYWJsZWQiLAogCQkJCQlncGVfbnVtYmVyKSk7CiAJCX0KIAkJYnJlYWs7CkBAIC02NDQsMjAgKzc0MCw5IEBACiAJCSAqIGEgR1BFIHRvIGJlIGVuYWJsZWQgaWYgaXQgaGFzIG5vIGhhbmRsZXIgb3IgbWV0aG9kLgogCQkgKi8KIAkJQUNQSV9FUlJPUigoQUVfSU5GTywKLQkJCSAgICAiTm8gaGFuZGxlciBvciBtZXRob2QgZm9yIEdQRVsweCUyWF0sIGRpc2FibGluZyBldmVudCIsCisJCQkgICAgIk5vIGhhbmRsZXIgb3IgbWV0aG9kIGZvciBHUEUlMDJYLCBkaXNhYmxpbmcgZXZlbnQiLAogCQkJICAgIGdwZV9udW1iZXIpKTsKIAotCQkvKgotCQkgKiBEaXNhYmxlIHRoZSBHUEUuIFRoZSBHUEUgd2lsbCByZW1haW4gZGlzYWJsZWQgYSBoYW5kbGVyCi0JCSAqIGlzIGluc3RhbGxlZCBvciBBQ1BJQ0EgaXMgcmVzdGFydGVkLgotCQkgKi8KLQkJc3RhdHVzID0gYWNwaV9od19sb3dfc2V0X2dwZShncGVfZXZlbnRfaW5mbywgQUNQSV9HUEVfRElTQUJMRSk7Ci0JCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgewotCQkJQUNQSV9FWENFUFRJT04oKEFFX0lORk8sIHN0YXR1cywKLQkJCQkJIlVuYWJsZSB0byBkaXNhYmxlIEdQRVsweCUyWF0iLAotCQkJCQlncGVfbnVtYmVyKSk7Ci0JCQlyZXR1cm5fVUlOVDMyKEFDUElfSU5URVJSVVBUX05PVF9IQU5ETEVEKTsKLQkJfQogCQlicmVhazsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZncGVibGsuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZncGVibGsuYwppbmRleCAwMjBhZGQzLi5jYTJjNDFhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2Z3BlYmxrLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldmdwZWJsay5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtMzYxLDkgKzM2MSw5IEBACiAKIAlncGVfYmxvY2stPm5vZGUgPSBncGVfZGV2aWNlOwogCWdwZV9ibG9jay0+Z3BlX2NvdW50ID0gKHUxNikocmVnaXN0ZXJfY291bnQgKiBBQ1BJX0dQRV9SRUdJU1RFUl9XSURUSCk7CisJZ3BlX2Jsb2NrLT5pbml0aWFsaXplZCA9IEZBTFNFOwogCWdwZV9ibG9jay0+cmVnaXN0ZXJfY291bnQgPSByZWdpc3Rlcl9jb3VudDsKIAlncGVfYmxvY2stPmJsb2NrX2Jhc2VfbnVtYmVyID0gZ3BlX2Jsb2NrX2Jhc2VfbnVtYmVyOwotCWdwZV9ibG9jay0+aW5pdGlhbGl6ZWQgPSBGQUxTRTsKIAogCUFDUElfTUVNQ1BZKCZncGVfYmxvY2stPmJsb2NrX2FkZHJlc3MsIGdwZV9ibG9ja19hZGRyZXNzLAogCQkgICAgc2l6ZW9mKHN0cnVjdCBhY3BpX2dlbmVyaWNfYWRkcmVzcykpOwpAQCAtMzg2LDcgKzM4Niw3IEBACiAJCXJldHVybl9BQ1BJX1NUQVRVUyhzdGF0dXMpOwogCX0KIAotCWFjcGlfYWxsX2dwZXNfaW5pdGlhbGl6ZWQgPSBGQUxTRTsKKwlhY3BpX2dibF9hbGxfZ3Blc19pbml0aWFsaXplZCA9IEZBTFNFOwogCiAJLyogRmluZCBhbGwgR1BFIG1ldGhvZHMgKF9MeHggb3JfRXh4KSBmb3IgdGhpcyBibG9jayAqLwogCkBAIC00MjMsMTQgKzQyMywxMiBAQAogICoKICAqIEZVTkNUSU9OOiAgICBhY3BpX2V2X2luaXRpYWxpemVfZ3BlX2Jsb2NrCiAgKgotICogUEFSQU1FVEVSUzogIGdwZV9kZXZpY2UgICAgICAgICAgLSBIYW5kbGUgdG8gdGhlIHBhcmVudCBHUEUgYmxvY2sKLSAqICAgICAgICAgICAgICBncGVfYmxvY2sgICAgICAgICAgIC0gR3BlIEJsb2NrIGluZm8KKyAqIFBBUkFNRVRFUlM6ICBhY3BpX2dwZV9jYWxsYmFjawogICoKICAqIFJFVFVSTjogICAgICBTdGF0dXMKICAqCi0gKiBERVNDUklQVElPTjogSW5pdGlhbGl6ZSBhbmQgZW5hYmxlIGEgR1BFIGJsb2NrLiBGaXJzdCBmaW5kIGFuZCBydW4gYW55Ci0gKiAgICAgICAgICAgICAgX1BSVCBtZXRob2RzIGFzc29jaWF0ZWQgd2l0aCB0aGUgYmxvY2ssIHRoZW4gZW5hYmxlIHRoZQotICogICAgICAgICAgICAgIGFwcHJvcHJpYXRlIEdQRXMuCisgKiBERVNDUklQVElPTjogSW5pdGlhbGl6ZSBhbmQgZW5hYmxlIGEgR1BFIGJsb2NrLiBFbmFibGUgR1BFcyB0aGF0IGhhdmUKKyAqICAgICAgICAgICAgICBhc3NvY2lhdGVkIG1ldGhvZHMuCiAgKiAgICAgICAgICAgICAgTm90ZTogQXNzdW1lcyBuYW1lc3BhY2UgaXMgbG9ja2VkLgogICoKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCkBAIC00NTAsOCArNDQ4LDggQEAKIAlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGV2X2luaXRpYWxpemVfZ3BlX2Jsb2NrKTsKIAogCS8qCi0JICogSWdub3JlIGEgbnVsbCBHUEUgYmxvY2sgKGUuZy4sIGlmIG5vIEdQRSBibG9jayAxIGV4aXN0cykgYW5kCi0JICogR1BFIGJsb2NrcyB0aGF0IGhhdmUgYmVlbiBpbml0aWFsaXplZCBhbHJlYWR5LgorCSAqIElnbm9yZSBhIG51bGwgR1BFIGJsb2NrIChlLmcuLCBpZiBubyBHUEUgYmxvY2sgMSBleGlzdHMpLCBhbmQKKwkgKiBhbnkgR1BFIGJsb2NrcyB0aGF0IGhhdmUgYmVlbiBpbml0aWFsaXplZCBhbHJlYWR5LgogCSAqLwogCWlmICghZ3BlX2Jsb2NrIHx8IGdwZV9ibG9jay0+aW5pdGlhbGl6ZWQpIHsKIAkJcmV0dXJuX0FDUElfU1RBVFVTKEFFX09LKTsKQEAgLTQ1OSw4ICs0NTcsOCBAQAogCiAJLyoKIAkgKiBFbmFibGUgYWxsIEdQRXMgdGhhdCBoYXZlIGEgY29ycmVzcG9uZGluZyBtZXRob2QgYW5kIGhhdmUgdGhlCi0JICogQUNQSV9HUEVfQ0FOX1dBS0UgZmxhZyB1bnNldC4gIEFueSBvdGhlciBHUEVzIHdpdGhpbiB0aGlzIGJsb2NrIG11c3QKLQkgKiBiZSBlbmFibGVkIHZpYSB0aGUgYWNwaV9lbmFibGVfZ3BlKCkgaW50ZXJmYWNlLgorCSAqIEFDUElfR1BFX0NBTl9XQUtFIGZsYWcgdW5zZXQuIEFueSBvdGhlciBHUEVzIHdpdGhpbiB0aGlzIGJsb2NrCisJICogbXVzdCBiZSBlbmFibGVkIHZpYSB0aGUgYWNwaV9lbmFibGVfZ3BlKCkgaW50ZXJmYWNlLgogCSAqLwogCWdwZV9lbmFibGVkX2NvdW50ID0gMDsKIApAQCAtNDcyLDE0ICs0NzAsMTkgQEAKIAkJCWdwZV9pbmRleCA9IChpICogQUNQSV9HUEVfUkVHSVNURVJfV0lEVEgpICsgajsKIAkJCWdwZV9ldmVudF9pbmZvID0gJmdwZV9ibG9jay0+ZXZlbnRfaW5mb1tncGVfaW5kZXhdOwogCi0JCQkvKiBJZ25vcmUgR1BFcyB0aGF0IGhhdmUgbm8gY29ycmVzcG9uZGluZyBfTHh4L19FeHggbWV0aG9kICovCi0KLQkJCWlmICghKGdwZV9ldmVudF9pbmZvLT5mbGFncyAmIEFDUElfR1BFX0RJU1BBVENIX01FVEhPRCkKKwkJCS8qCisJCQkgKiBJZ25vcmUgR1BFcyB0aGF0IGhhdmUgbm8gY29ycmVzcG9uZGluZyBfTHh4L19FeHggbWV0aG9kCisJCQkgKiBhbmQgR1BFcyB0aGF0IGFyZSB1c2VkIHRvIHdha2UgdGhlIHN5c3RlbQorCQkJICovCisJCQlpZiAoKChncGVfZXZlbnRfaW5mby0+ZmxhZ3MgJiBBQ1BJX0dQRV9ESVNQQVRDSF9NQVNLKSA9PQorCQkJICAgICBBQ1BJX0dQRV9ESVNQQVRDSF9OT05FKQorCQkJICAgIHx8ICgoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfRElTUEFUQ0hfTUFTSykKKwkJCQk9PSBBQ1BJX0dQRV9ESVNQQVRDSF9IQU5ETEVSKQogCQkJICAgIHx8IChncGVfZXZlbnRfaW5mby0+ZmxhZ3MgJiBBQ1BJX0dQRV9DQU5fV0FLRSkpIHsKIAkJCQljb250aW51ZTsKIAkJCX0KIAotCQkJc3RhdHVzID0gYWNwaV9yYXdfZW5hYmxlX2dwZShncGVfZXZlbnRfaW5mbyk7CisJCQlzdGF0dXMgPSBhY3BpX2V2X2FkZF9ncGVfcmVmZXJlbmNlKGdwZV9ldmVudF9pbmZvKTsKIAkJCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgewogCQkJCUFDUElfRVhDRVBUSU9OKChBRV9JTkZPLCBzdGF0dXMsCiAJCQkJCSJDb3VsZCBub3QgZW5hYmxlIEdQRSAweCUwMlgiLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldmdwZWluaXQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZncGVpbml0LmMKaW5kZXggNGM4ZGVhNS4uY2U5YWE5ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldmdwZWluaXQuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2Z3BlaW5pdC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtNDUsMTEgKzQ1LDI3IEBACiAjaW5jbHVkZSAiYWNjb21tb24uaCIKICNpbmNsdWRlICJhY2V2ZW50cy5oIgogI2luY2x1ZGUgImFjbmFtZXNwLmgiCi0jaW5jbHVkZSAiYWNpbnRlcnAuaCIKIAogI2RlZmluZSBfQ09NUE9ORU5UICAgICAgICAgIEFDUElfRVZFTlRTCiBBQ1BJX01PRFVMRV9OQU1FKCJldmdwZWluaXQiKQogCisvKgorICogTm90ZTogSGlzdG9yeSBvZiBfUFJXIHN1cHBvcnQgaW4gQUNQSUNBCisgKgorICogT3JpZ2luYWxseSAoMjAwMCAtIDIwMTApLCB0aGUgR1BFIGluaXRpYWxpemF0aW9uIGNvZGUgcGVyZm9ybWVkIGEgd2FsayBvZgorICogdGhlIGVudGlyZSBuYW1lc3BhY2UgdG8gZXhlY3V0ZSB0aGUgX1BSVyBtZXRob2RzIGFuZCBkZXRlY3QgYWxsIEdQRXMKKyAqIGNhcGFibGUgb2Ygd2FraW5nIHRoZSBzeXN0ZW0uCisgKgorICogQXMgb2YgMTAvMjAxMCwgdGhlIF9QUlcgbWV0aG9kIGV4ZWN1dGlvbiBoYXMgYmVlbiByZW1vdmVkIHNpbmNlIGl0IGlzCisgKiBhY3R1YWxseSB1bm5lY2Vzc2FyeS4gVGhlIGhvc3QgT1MgbXVzdCBpbiBmYWN0IGV4ZWN1dGUgYWxsIF9QUlcgbWV0aG9kcworICogaW4gb3JkZXIgdG8gaWRlbnRpZnkgdGhlIGRldmljZS9wb3dlci1yZXNvdXJjZSBkZXBlbmRlbmNpZXMuIFdlIG5vdyBwdXQKKyAqIHRoZSBvbnVzIG9uIHRoZSBob3N0IE9TIHRvIGlkZW50aWZ5IHRoZSB3YWtlIEdQRXMgYXMgcGFydCBvZiB0aGlzIHByb2Nlc3MKKyAqIGFuZCB0byBpbmZvcm0gQUNQSUNBIG9mIHRoZXNlIEdQRXMgdmlhIHRoZSBhY3BpX3NldHVwX2dwZV9mb3Jfd2FrZSBpbnRlcmZhY2UuIFRoaXMKKyAqIG5vdCBvbmx5IHJlZHVjZXMgdGhlIGNvbXBsZXhpdHkgb2YgdGhlIEFDUElDQSBpbml0aWFsaXphdGlvbiBjb2RlLCBidXQgaW4KKyAqIHNvbWUgY2FzZXMgKG9uIHN5c3RlbXMgd2l0aCB2ZXJ5IGxhcmdlIG5hbWVzcGFjZXMpIGl0IHNob3VsZCByZWR1Y2UgdGhlCisgKiBrZXJuZWwgYm9vdCB0aW1lIGFzIHdlbGwuCisgKi8KKwogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqCiAgKiBGVU5DVElPTjogICAgYWNwaV9ldl9ncGVfaW5pdGlhbGl6ZQpAQCAtMjIyLDcgKzIzOCw3IEBACiAJYWNwaV9zdGF0dXMgc3RhdHVzID0gQUVfT0s7CiAKIAkvKgotCSAqIDIpIEZpbmQgYW55IF9MeHgvX0V4eCBHUEUgbWV0aG9kcyB0aGF0IGhhdmUganVzdCBiZWVuIGxvYWRlZC4KKwkgKiBGaW5kIGFueSBfTHh4L19FeHggR1BFIG1ldGhvZHMgdGhhdCBoYXZlIGp1c3QgYmVlbiBsb2FkZWQuCiAJICoKIAkgKiBBbnkgR1BFcyB0aGF0IGNvcnJlc3BvbmQgdG8gbmV3IF9MeHgvX0V4eCBtZXRob2RzIGFyZSBpbW1lZGlhdGVseQogCSAqIGVuYWJsZWQuCkBAIC0yMzUsOSArMjUxLDkgQEAKIAkJcmV0dXJuOwogCX0KIAorCXdhbGtfaW5mby5jb3VudCA9IDA7CiAJd2Fsa19pbmZvLm93bmVyX2lkID0gdGFibGVfb3duZXJfaWQ7CiAJd2Fsa19pbmZvLmV4ZWN1dGVfYnlfb3duZXJfaWQgPSBUUlVFOwotCXdhbGtfaW5mby5jb3VudCA9IDA7CiAKIAkvKiBXYWxrIHRoZSBpbnRlcnJ1cHQgbGV2ZWwgZGVzY3JpcHRvciBsaXN0ICovCiAKQEAgLTI5OCw3ICszMTQsNyBAQAogICogICAgICAgICAgICAgICAgICB4eCAgICAgLSBpcyB0aGUgR1BFIG51bWJlciBbaW4gSEVYXQogICoKICAqIElmIHdhbGtfaW5mby0+ZXhlY3V0ZV9ieV9vd25lcl9pZCBpcyBUUlVFLCB3ZSBvbmx5IGV4ZWN1dGUgZXhhbWluZSBHUEUgbWV0aG9kcwotICogICAgd2l0aCB0aGF0IG93bmVyLgorICogd2l0aCB0aGF0IG93bmVyLgogICoKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKQEAgLTQxNSw2ICs0MzEsNyBAQAogCSAqIEFkZCB0aGUgR1BFIGluZm9ybWF0aW9uIGZyb20gYWJvdmUgdG8gdGhlIGdwZV9ldmVudF9pbmZvIGJsb2NrIGZvcgogCSAqIHVzZSBkdXJpbmcgZGlzcGF0Y2ggb2YgdGhpcyBHUEUuCiAJICovCisJZ3BlX2V2ZW50X2luZm8tPmZsYWdzICY9IH4oQUNQSV9HUEVfRElTUEFUQ0hfTUFTSyk7CiAJZ3BlX2V2ZW50X2luZm8tPmZsYWdzIHw9ICh1OCkodHlwZSB8IEFDUElfR1BFX0RJU1BBVENIX01FVEhPRCk7CiAJZ3BlX2V2ZW50X2luZm8tPmRpc3BhdGNoLm1ldGhvZF9ub2RlID0gbWV0aG9kX25vZGU7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZncGV1dGlsLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2Z3BldXRpbC5jCmluZGV4IDE5YTBlNTEuLjgwYTgxZDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZncGV1dGlsLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldmdwZXV0aWwuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTE1NCw2ICsxNTQsNDUgQEAKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqCisgKiBGVU5DVElPTjogICAgYWNwaV9ldl9nZXRfZ3BlX2RldmljZQorICoKKyAqIFBBUkFNRVRFUlM6ICBHUEVfV0FMS19DQUxMQkFDSworICoKKyAqIFJFVFVSTjogICAgICBTdGF0dXMKKyAqCisgKiBERVNDUklQVElPTjogTWF0Y2hlcyB0aGUgaW5wdXQgR1BFIGluZGV4ICgwLWN1cnJlbnRfZ3BlX2NvdW50KSB3aXRoIGEgR1BFCisgKiAgICAgICAgICAgICAgYmxvY2sgZGV2aWNlLiBOVUxMIGlmIHRoZSBHUEUgaXMgb25lIG9mIHRoZSBGQURULWRlZmluZWQgR1BFcy4KKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCithY3BpX3N0YXR1cworYWNwaV9ldl9nZXRfZ3BlX2RldmljZShzdHJ1Y3QgYWNwaV9ncGVfeHJ1cHRfaW5mbyAqZ3BlX3hydXB0X2luZm8sCisJCSAgICAgICBzdHJ1Y3QgYWNwaV9ncGVfYmxvY2tfaW5mbyAqZ3BlX2Jsb2NrLCB2b2lkICpjb250ZXh0KQoreworCXN0cnVjdCBhY3BpX2dwZV9kZXZpY2VfaW5mbyAqaW5mbyA9IGNvbnRleHQ7CisKKwkvKiBJbmNyZW1lbnQgSW5kZXggYnkgdGhlIG51bWJlciBvZiBHUEVzIGluIHRoaXMgYmxvY2sgKi8KKworCWluZm8tPm5leHRfYmxvY2tfYmFzZV9pbmRleCArPSBncGVfYmxvY2stPmdwZV9jb3VudDsKKworCWlmIChpbmZvLT5pbmRleCA8IGluZm8tPm5leHRfYmxvY2tfYmFzZV9pbmRleCkgeworCQkvKgorCQkgKiBUaGUgR1BFIGluZGV4IGlzIHdpdGhpbiB0aGlzIGJsb2NrLCBnZXQgdGhlIG5vZGUuIExlYXZlIHRoZSBub2RlCisJCSAqIE5VTEwgZm9yIHRoZSBGQURULWRlZmluZWQgR1BFcworCQkgKi8KKwkJaWYgKChncGVfYmxvY2stPm5vZGUpLT50eXBlID09IEFDUElfVFlQRV9ERVZJQ0UpIHsKKwkJCWluZm8tPmdwZV9kZXZpY2UgPSBncGVfYmxvY2stPm5vZGU7CisJCX0KKworCQlpbmZvLT5zdGF0dXMgPSBBRV9PSzsKKwkJcmV0dXJuIChBRV9DVFJMX0VORCk7CisJfQorCisJcmV0dXJuIChBRV9PSyk7Cit9CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKgogICogRlVOQ1RJT046ICAgIGFjcGlfZXZfZ2V0X2dwZV94cnVwdF9ibG9jawogICoKICAqIFBBUkFNRVRFUlM6ICBpbnRlcnJ1cHRfbnVtYmVyICAgICAtIEludGVycnVwdCBmb3IgYSBHUEUgYmxvY2sKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZtaXNjLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2bWlzYy5jCmluZGV4IGZjYWVkOWYuLjdkYzgwOTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZtaXNjLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldm1pc2MuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTI4NCw0MSArMjg0LDM5IEBACiAgKiBSRVRVUk46ICAgICAgQUNQSV9JTlRFUlJVUFRfSEFORExFRAogICoKICAqIERFU0NSSVBUSU9OOiBJbnZva2VkIGRpcmVjdGx5IGZyb20gdGhlIFNDSSBoYW5kbGVyIHdoZW4gYSBnbG9iYWwgbG9jawotICogICAgICAgICAgICAgIHJlbGVhc2UgaW50ZXJydXB0IG9jY3Vycy4gQXR0ZW1wdCB0byBhY3F1aXJlIHRoZSBnbG9iYWwgbG9jaywKLSAqICAgICAgICAgICAgICBpZiBzdWNjZXNzZnVsLCBzaWduYWwgdGhlIHRocmVhZCB3YWl0aW5nIGZvciB0aGUgbG9jay4KKyAqICAgICAgICAgICAgICByZWxlYXNlIGludGVycnVwdCBvY2N1cnMuICBJZiB0aGVyZSdzIGEgdGhyZWFkIHdhaXRpbmcgZm9yCisgKiAgICAgICAgICAgICAgdGhlIGdsb2JhbCBsb2NrLCBzaWduYWwgaXQuCiAgKgogICogTk9URTogQXNzdW1lcyB0aGF0IHRoZSBzZW1hcGhvcmUgY2FuIGJlIHNpZ25hbGVkIGZyb20gaW50ZXJydXB0IGxldmVsLiBJZgogICogdGhpcyBpcyBub3QgcG9zc2libGUgZm9yIHNvbWUgcmVhc29uLCBhIHNlcGFyYXRlIHRocmVhZCB3aWxsIGhhdmUgdG8gYmUKICAqIHNjaGVkdWxlZCB0byBkbyB0aGlzLgogICoKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCitzdGF0aWMgdTggYWNwaV9ldl9nbG9iYWxfbG9ja19wZW5kaW5nOwogCiBzdGF0aWMgdTMyIGFjcGlfZXZfZ2xvYmFsX2xvY2tfaGFuZGxlcih2b2lkICpjb250ZXh0KQogewotCXU4IGFjcXVpcmVkID0gRkFMU0U7CisJYWNwaV9zdGF0dXMgc3RhdHVzOworCWFjcGlfY3B1X2ZsYWdzIGZsYWdzOwogCi0JLyoKLQkgKiBBdHRlbXB0IHRvIGdldCB0aGUgbG9jay4KLQkgKgotCSAqIElmIHdlIGRvbid0IGdldCBpdCBub3csIGl0IHdpbGwgYmUgbWFya2VkIHBlbmRpbmcgYW5kIHdlIHdpbGwKLQkgKiB0YWtlIGFub3RoZXIgaW50ZXJydXB0IHdoZW4gaXQgYmVjb21lcyBmcmVlLgotCSAqLwotCUFDUElfQUNRVUlSRV9HTE9CQUxfTE9DSyhhY3BpX2dibF9GQUNTLCBhY3F1aXJlZCk7Ci0JaWYgKGFjcXVpcmVkKSB7CisJZmxhZ3MgPSBhY3BpX29zX2FjcXVpcmVfbG9jayhhY3BpX2V2X2dsb2JhbF9sb2NrX3BlbmRpbmdfbG9jayk7CiAKLQkJLyogR290IHRoZSBsb2NrLCBub3cgd2FrZSBhbGwgdGhyZWFkcyB3YWl0aW5nIGZvciBpdCAqLwotCi0JCWFjcGlfZ2JsX2dsb2JhbF9sb2NrX2FjcXVpcmVkID0gVFJVRTsKLQkJLyogU2VuZCBhIHVuaXQgdG8gdGhlIHNlbWFwaG9yZSAqLwotCi0JCWlmIChBQ1BJX0ZBSUxVUkUKLQkJICAgIChhY3BpX29zX3NpZ25hbF9zZW1hcGhvcmUKLQkJICAgICAoYWNwaV9nYmxfZ2xvYmFsX2xvY2tfc2VtYXBob3JlLCAxKSkpIHsKLQkJCUFDUElfRVJST1IoKEFFX0lORk8sCi0JCQkJICAgICJDb3VsZCBub3Qgc2lnbmFsIEdsb2JhbCBMb2NrIHNlbWFwaG9yZSIpKTsKLQkJfQorCWlmICghYWNwaV9ldl9nbG9iYWxfbG9ja19wZW5kaW5nKSB7CisJCWdvdG8gb3V0OwogCX0KIAorCS8qIFNlbmQgYSB1bml0IHRvIHRoZSBzZW1hcGhvcmUgKi8KKworCXN0YXR1cyA9IGFjcGlfb3Nfc2lnbmFsX3NlbWFwaG9yZShhY3BpX2dibF9nbG9iYWxfbG9ja19zZW1hcGhvcmUsIDEpOworCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgeworCQlBQ1BJX0VSUk9SKChBRV9JTkZPLCAiQ291bGQgbm90IHNpZ25hbCBHbG9iYWwgTG9jayBzZW1hcGhvcmUiKSk7CisJfQorCisJYWNwaV9ldl9nbG9iYWxfbG9ja19wZW5kaW5nID0gRkFMU0U7CisKKyBvdXQ6CisJYWNwaV9vc19yZWxlYXNlX2xvY2soYWNwaV9ldl9nbG9iYWxfbG9ja19wZW5kaW5nX2xvY2ssIGZsYWdzKTsKKwogCXJldHVybiAoQUNQSV9JTlRFUlJVUFRfSEFORExFRCk7CiB9CiAKQEAgLTQxNSw2ICs0MTMsNyBAQAogCiBhY3BpX3N0YXR1cyBhY3BpX2V2X2FjcXVpcmVfZ2xvYmFsX2xvY2sodTE2IHRpbWVvdXQpCiB7CisJYWNwaV9jcHVfZmxhZ3MgZmxhZ3M7CiAJYWNwaV9zdGF0dXMgc3RhdHVzID0gQUVfT0s7CiAJdTggYWNxdWlyZWQgPSBGQUxTRTsKIApAQCAtNDY3LDMyICs0NjYsNDcgQEAKIAkJcmV0dXJuX0FDUElfU1RBVFVTKEFFX09LKTsKIAl9CiAKLQkvKiBBdHRlbXB0IHRvIGFjcXVpcmUgdGhlIGFjdHVhbCBoYXJkd2FyZSBsb2NrICovCisJZmxhZ3MgPSBhY3BpX29zX2FjcXVpcmVfbG9jayhhY3BpX2V2X2dsb2JhbF9sb2NrX3BlbmRpbmdfbG9jayk7CiAKLQlBQ1BJX0FDUVVJUkVfR0xPQkFMX0xPQ0soYWNwaV9nYmxfRkFDUywgYWNxdWlyZWQpOwotCWlmIChhY3F1aXJlZCkgeworCWRvIHsKIAotCQkvKiBXZSBnb3QgdGhlIGxvY2sgKi8KKwkJLyogQXR0ZW1wdCB0byBhY3F1aXJlIHRoZSBhY3R1YWwgaGFyZHdhcmUgbG9jayAqLwogCisJCUFDUElfQUNRVUlSRV9HTE9CQUxfTE9DSyhhY3BpX2dibF9GQUNTLCBhY3F1aXJlZCk7CisJCWlmIChhY3F1aXJlZCkgeworCQkJYWNwaV9nYmxfZ2xvYmFsX2xvY2tfYWNxdWlyZWQgPSBUUlVFOworCisJCQlBQ1BJX0RFQlVHX1BSSU5UKChBQ1BJX0RCX0VYRUMsCisJCQkJCSAgIkFjcXVpcmVkIGhhcmR3YXJlIEdsb2JhbCBMb2NrXG4iKSk7CisJCQlicmVhazsKKwkJfQorCisJCWFjcGlfZXZfZ2xvYmFsX2xvY2tfcGVuZGluZyA9IFRSVUU7CisKKwkJYWNwaV9vc19yZWxlYXNlX2xvY2soYWNwaV9ldl9nbG9iYWxfbG9ja19wZW5kaW5nX2xvY2ssIGZsYWdzKTsKKworCQkvKgorCQkgKiBEaWQgbm90IGdldCB0aGUgbG9jay4gVGhlIHBlbmRpbmcgYml0IHdhcyBzZXQgYWJvdmUsIGFuZCB3ZQorCQkgKiBtdXN0IHdhaXQgdW50aWwgd2UgZ2V0IHRoZSBnbG9iYWwgbG9jayByZWxlYXNlZCBpbnRlcnJ1cHQuCisJCSAqLwogCQlBQ1BJX0RFQlVHX1BSSU5UKChBQ1BJX0RCX0VYRUMsCi0JCQkJICAiQWNxdWlyZWQgaGFyZHdhcmUgR2xvYmFsIExvY2tcbiIpKTsKKwkJCQkgICJXYWl0aW5nIGZvciBoYXJkd2FyZSBHbG9iYWwgTG9ja1xuIikpOwogCi0JCWFjcGlfZ2JsX2dsb2JhbF9sb2NrX2FjcXVpcmVkID0gVFJVRTsKLQkJcmV0dXJuX0FDUElfU1RBVFVTKEFFX09LKTsKLQl9CisJCS8qCisJCSAqIFdhaXQgZm9yIGhhbmRzaGFrZSB3aXRoIHRoZSBnbG9iYWwgbG9jayBpbnRlcnJ1cHQgaGFuZGxlci4KKwkJICogVGhpcyBpbnRlcmZhY2UgcmVsZWFzZXMgdGhlIGludGVycHJldGVyIGlmIHdlIG11c3Qgd2FpdC4KKwkJICovCisJCXN0YXR1cyA9IGFjcGlfZXhfc3lzdGVtX3dhaXRfc2VtYXBob3JlKAorCQkJCQkJYWNwaV9nYmxfZ2xvYmFsX2xvY2tfc2VtYXBob3JlLAorCQkJCQkJQUNQSV9XQUlUX0ZPUkVWRVIpOwogCi0JLyoKLQkgKiBEaWQgbm90IGdldCB0aGUgbG9jay4gVGhlIHBlbmRpbmcgYml0IHdhcyBzZXQgYWJvdmUsIGFuZCB3ZSBtdXN0IG5vdwotCSAqIHdhaXQgdW50aWwgd2UgZ2V0IHRoZSBnbG9iYWwgbG9jayByZWxlYXNlZCBpbnRlcnJ1cHQuCi0JICovCi0JQUNQSV9ERUJVR19QUklOVCgoQUNQSV9EQl9FWEVDLCAiV2FpdGluZyBmb3IgaGFyZHdhcmUgR2xvYmFsIExvY2tcbiIpKTsKKwkJZmxhZ3MgPSBhY3BpX29zX2FjcXVpcmVfbG9jayhhY3BpX2V2X2dsb2JhbF9sb2NrX3BlbmRpbmdfbG9jayk7CiAKLQkvKgotCSAqIFdhaXQgZm9yIGhhbmRzaGFrZSB3aXRoIHRoZSBnbG9iYWwgbG9jayBpbnRlcnJ1cHQgaGFuZGxlci4KLQkgKiBUaGlzIGludGVyZmFjZSByZWxlYXNlcyB0aGUgaW50ZXJwcmV0ZXIgaWYgd2UgbXVzdCB3YWl0LgotCSAqLwotCXN0YXR1cyA9IGFjcGlfZXhfc3lzdGVtX3dhaXRfc2VtYXBob3JlKGFjcGlfZ2JsX2dsb2JhbF9sb2NrX3NlbWFwaG9yZSwKLQkJCQkJICAgICAgIEFDUElfV0FJVF9GT1JFVkVSKTsKKwl9IHdoaWxlIChBQ1BJX1NVQ0NFU1Moc3RhdHVzKSk7CisKKwlhY3BpX2V2X2dsb2JhbF9sb2NrX3BlbmRpbmcgPSBGQUxTRTsKKworCWFjcGlfb3NfcmVsZWFzZV9sb2NrKGFjcGlfZXZfZ2xvYmFsX2xvY2tfcGVuZGluZ19sb2NrLCBmbGFncyk7CiAKIAlyZXR1cm5fQUNQSV9TVEFUVVMoc3RhdHVzKTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZyZWdpb24uYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZyZWdpb24uYwppbmRleCA5OGZkMjEwLi43ODVhNWVlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2cmVnaW9uLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldnJlZ2lvbi5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldnJnbmluaS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldnJnbmluaS5jCmluZGV4IDBiNDdhNmQuLjk2NTljZWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZyZ25pbmkuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2cmduaW5pLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC01OTAsOSArNTkwLDkgQEAKIAkJCQkgKiBTZWUgYWNwaV9uc19leGVjX21vZHVsZV9jb2RlCiAJCQkJICovCiAJCQkJaWYgKG9ial9kZXNjLT5tZXRob2QuCi0JCQkJICAgIGZsYWdzICYgQU9QT0JKX01PRFVMRV9MRVZFTCkgeworCQkJCSAgICBpbmZvX2ZsYWdzICYgQUNQSV9NRVRIT0RfTU9EVUxFX0xFVkVMKSB7CiAJCQkJCWhhbmRsZXJfb2JqID0KLQkJCQkJICAgIG9ial9kZXNjLT5tZXRob2QuZXh0cmEuaGFuZGxlcjsKKwkJCQkJICAgIG9ial9kZXNjLT5tZXRob2QuZGlzcGF0Y2guaGFuZGxlcjsKIAkJCQl9CiAJCQkJYnJlYWs7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZzY2kuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZzY2kuYwppbmRleCA4ZGZiYWE5Li4yZWJkNDBlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2c2NpLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldnNjaS5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZ4ZmFjZS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldnhmYWNlLmMKaW5kZXggMzZhZjIyMi4uZTExNDE0MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldnhmYWNlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldnhmYWNlLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC05Miw2ICs5Miw1NyBAQAogCiBBQ1BJX0VYUE9SVF9TWU1CT0woYWNwaV9pbnN0YWxsX2V4Y2VwdGlvbl9oYW5kbGVyKQogI2VuZGlmCQkJCS8qICBBQ1BJX0ZVVFVSRV9VU0FHRSAgKi8KKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqCisgKiBGVU5DVElPTjogICAgYWNwaV9pbnN0YWxsX2dsb2JhbF9ldmVudF9oYW5kbGVyCisgKgorICogUEFSQU1FVEVSUzogIEhhbmRsZXIgICAgICAgICAtIFBvaW50ZXIgdG8gdGhlIGdsb2JhbCBldmVudCBoYW5kbGVyIGZ1bmN0aW9uCisgKiAgICAgICAgICAgICAgQ29udGV4dCAgICAgICAgIC0gVmFsdWUgcGFzc2VkIHRvIHRoZSBoYW5kbGVyIG9uIGVhY2ggZXZlbnQKKyAqCisgKiBSRVRVUk46ICAgICAgU3RhdHVzCisgKgorICogREVTQ1JJUFRJT046IFNhdmVzIHRoZSBwb2ludGVyIHRvIHRoZSBoYW5kbGVyIGZ1bmN0aW9uLiBUaGUgZ2xvYmFsIGhhbmRsZXIKKyAqICAgICAgICAgICAgICBpcyBpbnZva2VkIHVwb24gZWFjaCBpbmNvbWluZyBHUEUgYW5kIEZpeGVkIEV2ZW50LiBJdCBpcworICogICAgICAgICAgICAgIGludm9rZWQgYXQgaW50ZXJydXB0IGxldmVsIGF0IHRoZSB0aW1lIG9mIHRoZSBldmVudCBkaXNwYXRjaC4KKyAqICAgICAgICAgICAgICBDYW4gYmUgdXNlZCB0byB1cGRhdGUgZXZlbnQgY291bnRlcnMsIGV0Yy4KKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworYWNwaV9zdGF0dXMKK2FjcGlfaW5zdGFsbF9nbG9iYWxfZXZlbnRfaGFuZGxlcihBQ1BJX0dCTF9FVkVOVF9IQU5ETEVSIGhhbmRsZXIsIHZvaWQgKmNvbnRleHQpCit7CisJYWNwaV9zdGF0dXMgc3RhdHVzOworCisJQUNQSV9GVU5DVElPTl9UUkFDRShhY3BpX2luc3RhbGxfZ2xvYmFsX2V2ZW50X2hhbmRsZXIpOworCisJLyogUGFyYW1ldGVyIHZhbGlkYXRpb24gKi8KKworCWlmICghaGFuZGxlcikgeworCQlyZXR1cm5fQUNQSV9TVEFUVVMoQUVfQkFEX1BBUkFNRVRFUik7CisJfQorCisJc3RhdHVzID0gYWNwaV91dF9hY3F1aXJlX211dGV4KEFDUElfTVRYX0VWRU5UUyk7CisJaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKSB7CisJCXJldHVybl9BQ1BJX1NUQVRVUyhzdGF0dXMpOworCX0KKworCS8qIERvbid0IGFsbG93IHR3byBoYW5kbGVycy4gKi8KKworCWlmIChhY3BpX2dibF9nbG9iYWxfZXZlbnRfaGFuZGxlcikgeworCQlzdGF0dXMgPSBBRV9BTFJFQURZX0VYSVNUUzsKKwkJZ290byBjbGVhbnVwOworCX0KKworCWFjcGlfZ2JsX2dsb2JhbF9ldmVudF9oYW5kbGVyID0gaGFuZGxlcjsKKwlhY3BpX2dibF9nbG9iYWxfZXZlbnRfaGFuZGxlcl9jb250ZXh0ID0gY29udGV4dDsKKworICAgICAgY2xlYW51cDoKKwkodm9pZClhY3BpX3V0X3JlbGVhc2VfbXV0ZXgoQUNQSV9NVFhfRVZFTlRTKTsKKwlyZXR1cm5fQUNQSV9TVEFUVVMoc3RhdHVzKTsKK30KKworQUNQSV9FWFBPUlRfU1lNQk9MKGFjcGlfaW5zdGFsbF9nbG9iYWxfZXZlbnRfaGFuZGxlcikKKwogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqCiAgKiBGVU5DVElPTjogICAgYWNwaV9pbnN0YWxsX2ZpeGVkX2V2ZW50X2hhbmRsZXIKQEAgLTY3MSwxMCArNzIyLDEwIEBACiBhY3BpX3N0YXR1cwogYWNwaV9pbnN0YWxsX2dwZV9oYW5kbGVyKGFjcGlfaGFuZGxlIGdwZV9kZXZpY2UsCiAJCQkgdTMyIGdwZV9udW1iZXIsCi0JCQkgdTMyIHR5cGUsIGFjcGlfZXZlbnRfaGFuZGxlciBhZGRyZXNzLCB2b2lkICpjb250ZXh0KQorCQkJIHUzMiB0eXBlLCBhY3BpX2dwZV9oYW5kbGVyIGFkZHJlc3MsIHZvaWQgKmNvbnRleHQpCiB7CiAJc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvOwotCXN0cnVjdCBhY3BpX2hhbmRsZXJfaW5mbyAqaGFuZGxlcjsKKwlzdHJ1Y3QgYWNwaV9ncGVfaGFuZGxlcl9pbmZvICpoYW5kbGVyOwogCWFjcGlfc3RhdHVzIHN0YXR1czsKIAlhY3BpX2NwdV9mbGFncyBmbGFnczsKIApAQCAtNjkzLDcgKzc0NCw3IEBACiAKIAkvKiBBbGxvY2F0ZSBtZW1vcnkgZm9yIHRoZSBoYW5kbGVyIG9iamVjdCAqLwogCi0JaGFuZGxlciA9IEFDUElfQUxMT0NBVEVfWkVST0VEKHNpemVvZihzdHJ1Y3QgYWNwaV9oYW5kbGVyX2luZm8pKTsKKwloYW5kbGVyID0gQUNQSV9BTExPQ0FURV9aRVJPRUQoc2l6ZW9mKHN0cnVjdCBhY3BpX2dwZV9oYW5kbGVyX2luZm8pKTsKIAlpZiAoIWhhbmRsZXIpIHsKIAkJc3RhdHVzID0gQUVfTk9fTUVNT1JZOwogCQlnb3RvIHVubG9ja19hbmRfZXhpdDsKQEAgLTcyMiw3ICs3NzMsNyBAQAogCWhhbmRsZXItPmFkZHJlc3MgPSBhZGRyZXNzOwogCWhhbmRsZXItPmNvbnRleHQgPSBjb250ZXh0OwogCWhhbmRsZXItPm1ldGhvZF9ub2RlID0gZ3BlX2V2ZW50X2luZm8tPmRpc3BhdGNoLm1ldGhvZF9ub2RlOwotCWhhbmRsZXItPm9yaWdfZmxhZ3MgPSBncGVfZXZlbnRfaW5mby0+ZmxhZ3MgJgorCWhhbmRsZXItPm9yaWdpbmFsX2ZsYWdzID0gZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYKIAkJCShBQ1BJX0dQRV9YUlVQVF9UWVBFX01BU0sgfCBBQ1BJX0dQRV9ESVNQQVRDSF9NQVNLKTsKIAogCS8qCkBAIC03MzEsMTAgKzc4MiwxMCBAQAogCSAqIGRpc2FibGVkIG5vdyB0byBhdm9pZCBzcHVyaW91cyBleGVjdXRpb24gb2YgdGhlIGhhbmRsZXIuCiAJICovCiAKLQlpZiAoKGhhbmRsZXItPm9yaWdfZmxhZ3MgJiBBQ1BJX0dQRV9ESVNQQVRDSF9NRVRIT0QpCisJaWYgKChoYW5kbGVyLT5vcmlnaW5hbF9mbGFncyAmIEFDUElfR1BFX0RJU1BBVENIX01FVEhPRCkKIAkgICAgJiYgZ3BlX2V2ZW50X2luZm8tPnJ1bnRpbWVfY291bnQpIHsKLQkJaGFuZGxlci0+b3JpZ19lbmFibGVkID0gMTsKLQkJKHZvaWQpYWNwaV9yYXdfZGlzYWJsZV9ncGUoZ3BlX2V2ZW50X2luZm8pOworCQloYW5kbGVyLT5vcmlnaW5hbGx5X2VuYWJsZWQgPSAxOworCQkodm9pZClhY3BpX2V2X3JlbW92ZV9ncGVfcmVmZXJlbmNlKGdwZV9ldmVudF9pbmZvKTsKIAl9CiAKIAkvKiBJbnN0YWxsIHRoZSBoYW5kbGVyICovCkBAIC03NzcsMTAgKzgyOCwxMCBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIGFjcGlfc3RhdHVzCiBhY3BpX3JlbW92ZV9ncGVfaGFuZGxlcihhY3BpX2hhbmRsZSBncGVfZGV2aWNlLAotCQkJdTMyIGdwZV9udW1iZXIsIGFjcGlfZXZlbnRfaGFuZGxlciBhZGRyZXNzKQorCQkJdTMyIGdwZV9udW1iZXIsIGFjcGlfZ3BlX2hhbmRsZXIgYWRkcmVzcykKIHsKIAlzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbyAqZ3BlX2V2ZW50X2luZm87Ci0Jc3RydWN0IGFjcGlfaGFuZGxlcl9pbmZvICpoYW5kbGVyOworCXN0cnVjdCBhY3BpX2dwZV9oYW5kbGVyX2luZm8gKmhhbmRsZXI7CiAJYWNwaV9zdGF0dXMgc3RhdHVzOwogCWFjcGlfY3B1X2ZsYWdzIGZsYWdzOwogCkBAIC04MzUsNyArODg2LDcgQEAKIAlncGVfZXZlbnRfaW5mby0+ZGlzcGF0Y2gubWV0aG9kX25vZGUgPSBoYW5kbGVyLT5tZXRob2Rfbm9kZTsKIAlncGVfZXZlbnRfaW5mby0+ZmxhZ3MgJj0KIAkJfihBQ1BJX0dQRV9YUlVQVF9UWVBFX01BU0sgfCBBQ1BJX0dQRV9ESVNQQVRDSF9NQVNLKTsKLQlncGVfZXZlbnRfaW5mby0+ZmxhZ3MgfD0gaGFuZGxlci0+b3JpZ19mbGFnczsKKwlncGVfZXZlbnRfaW5mby0+ZmxhZ3MgfD0gaGFuZGxlci0+b3JpZ2luYWxfZmxhZ3M7CiAKIAkvKgogCSAqIElmIHRoZSBHUEUgd2FzIHByZXZpb3VzbHkgYXNzb2NpYXRlZCB3aXRoIGEgbWV0aG9kIGFuZCBpdCB3YXMKQEAgLTg0Myw5ICs4OTQsOSBAQAogCSAqIHBvc3QtaW5pdGlhbGl6YXRpb24gY29uZmlndXJhdGlvbi4KIAkgKi8KIAotCWlmICgoaGFuZGxlci0+b3JpZ19mbGFncyAmIEFDUElfR1BFX0RJU1BBVENIX01FVEhPRCkKLQkgICAgJiYgaGFuZGxlci0+b3JpZ19lbmFibGVkKQotCQkodm9pZClhY3BpX3Jhd19lbmFibGVfZ3BlKGdwZV9ldmVudF9pbmZvKTsKKwlpZiAoKGhhbmRsZXItPm9yaWdpbmFsX2ZsYWdzICYgQUNQSV9HUEVfRElTUEFUQ0hfTUVUSE9EKQorCSAgICAmJiBoYW5kbGVyLT5vcmlnaW5hbGx5X2VuYWJsZWQpCisJCSh2b2lkKWFjcGlfZXZfYWRkX2dwZV9yZWZlcmVuY2UoZ3BlX2V2ZW50X2luZm8pOwogCiAJLyogTm93IHdlIGNhbiBmcmVlIHRoZSBoYW5kbGVyIG9iamVjdCAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2eGZldm50LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2eGZldm50LmMKaW5kZXggYTFkYWJlMy4uYzU3YjVjNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldnhmZXZudC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZ4ZmV2bnQuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTQzLDE4ICs0MywxMSBAQAogCiAjaW5jbHVkZSA8YWNwaS9hY3BpLmg+CiAjaW5jbHVkZSAiYWNjb21tb24uaCIKLSNpbmNsdWRlICJhY2V2ZW50cy5oIgotI2luY2x1ZGUgImFjbmFtZXNwLmgiCiAjaW5jbHVkZSAiYWN0YWJsZXMuaCIKIAogI2RlZmluZSBfQ09NUE9ORU5UICAgICAgICAgIEFDUElfRVZFTlRTCiBBQ1BJX01PRFVMRV9OQU1FKCJldnhmZXZudCIpCiAKLS8qIExvY2FsIHByb3RvdHlwZXMgKi8KLXN0YXRpYyBhY3BpX3N0YXR1cwotYWNwaV9ldl9nZXRfZ3BlX2RldmljZShzdHJ1Y3QgYWNwaV9ncGVfeHJ1cHRfaW5mbyAqZ3BlX3hydXB0X2luZm8sCi0JCSAgICAgICBzdHJ1Y3QgYWNwaV9ncGVfYmxvY2tfaW5mbyAqZ3BlX2Jsb2NrLCB2b2lkICpjb250ZXh0KTsKLQogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqCiAgKiBGVU5DVElPTjogICAgYWNwaV9lbmFibGUKQEAgLTIxMywxODUgKzIwNiw2IEBACiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKgotICogRlVOQ1RJT046ICAgIGFjcGlfZ3BlX3dha2V1cAotICoKLSAqIFBBUkFNRVRFUlM6ICBncGVfZGV2aWNlICAgICAgLSBQYXJlbnQgR1BFIERldmljZS4gTlVMTCBmb3IgR1BFMC9HUEUxCi0gKiAgICAgICAgICAgICAgZ3BlX251bWJlciAgICAgIC0gR1BFIGxldmVsIHdpdGhpbiB0aGUgR1BFIGJsb2NrCi0gKiAgICAgICAgICAgICAgQWN0aW9uICAgICAgICAgIC0gRW5hYmxlIG9yIERpc2FibGUKLSAqCi0gKiBSRVRVUk46ICAgICAgU3RhdHVzCi0gKgotICogREVTQ1JJUFRJT046IFNldCBvciBjbGVhciB0aGUgR1BFJ3Mgd2FrZXVwIGVuYWJsZSBtYXNrIGJpdC4KLSAqCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotYWNwaV9zdGF0dXMgYWNwaV9ncGVfd2FrZXVwKGFjcGlfaGFuZGxlIGdwZV9kZXZpY2UsIHUzMiBncGVfbnVtYmVyLCB1OCBhY3Rpb24pCi17Ci0JYWNwaV9zdGF0dXMgc3RhdHVzID0gQUVfT0s7Ci0Jc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvOwotCXN0cnVjdCBhY3BpX2dwZV9yZWdpc3Rlcl9pbmZvICpncGVfcmVnaXN0ZXJfaW5mbzsKLQlhY3BpX2NwdV9mbGFncyBmbGFnczsKLQl1MzIgcmVnaXN0ZXJfYml0OwotCi0JQUNQSV9GVU5DVElPTl9UUkFDRShhY3BpX2dwZV93YWtldXApOwotCi0JZmxhZ3MgPSBhY3BpX29zX2FjcXVpcmVfbG9jayhhY3BpX2dibF9ncGVfbG9jayk7Ci0KLQkvKiBFbnN1cmUgdGhhdCB3ZSBoYXZlIGEgdmFsaWQgR1BFIG51bWJlciAqLwotCi0JZ3BlX2V2ZW50X2luZm8gPSBhY3BpX2V2X2dldF9ncGVfZXZlbnRfaW5mbyhncGVfZGV2aWNlLCBncGVfbnVtYmVyKTsKLQlpZiAoIWdwZV9ldmVudF9pbmZvIHx8ICEoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfQ0FOX1dBS0UpKSB7Ci0JCXN0YXR1cyA9IEFFX0JBRF9QQVJBTUVURVI7Ci0JCWdvdG8gdW5sb2NrX2FuZF9leGl0OwotCX0KLQotCWdwZV9yZWdpc3Rlcl9pbmZvID0gZ3BlX2V2ZW50X2luZm8tPnJlZ2lzdGVyX2luZm87Ci0JaWYgKCFncGVfcmVnaXN0ZXJfaW5mbykgewotCQlzdGF0dXMgPSBBRV9OT1RfRVhJU1Q7Ci0JCWdvdG8gdW5sb2NrX2FuZF9leGl0OwotCX0KLQotCXJlZ2lzdGVyX2JpdCA9Ci0JICAgIGFjcGlfaHdfZ2V0X2dwZV9yZWdpc3Rlcl9iaXQoZ3BlX2V2ZW50X2luZm8sIGdwZV9yZWdpc3Rlcl9pbmZvKTsKLQotCS8qIFBlcmZvcm0gdGhlIGFjdGlvbiAqLwotCi0Jc3dpdGNoIChhY3Rpb24pIHsKLQljYXNlIEFDUElfR1BFX0VOQUJMRToKLQkJQUNQSV9TRVRfQklUKGdwZV9yZWdpc3Rlcl9pbmZvLT5lbmFibGVfZm9yX3dha2UsCi0JCQkgICAgICh1OClyZWdpc3Rlcl9iaXQpOwotCQlicmVhazsKLQotCWNhc2UgQUNQSV9HUEVfRElTQUJMRToKLQkJQUNQSV9DTEVBUl9CSVQoZ3BlX3JlZ2lzdGVyX2luZm8tPmVuYWJsZV9mb3Jfd2FrZSwKLQkJCSAgICAgICAodTgpcmVnaXN0ZXJfYml0KTsKLQkJYnJlYWs7Ci0KLQlkZWZhdWx0OgotCQlBQ1BJX0VSUk9SKChBRV9JTkZPLCAiJXUsIEludmFsaWQgYWN0aW9uIiwgYWN0aW9uKSk7Ci0JCXN0YXR1cyA9IEFFX0JBRF9QQVJBTUVURVI7Ci0JCWJyZWFrOwotCX0KLQotdW5sb2NrX2FuZF9leGl0OgotCWFjcGlfb3NfcmVsZWFzZV9sb2NrKGFjcGlfZ2JsX2dwZV9sb2NrLCBmbGFncyk7Ci0JcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Ci19Ci0KLUFDUElfRVhQT1JUX1NZTUJPTChhY3BpX2dwZV93YWtldXApCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKgotICogRlVOQ1RJT046ICAgIGFjcGlfZW5hYmxlX2dwZQotICoKLSAqIFBBUkFNRVRFUlM6ICBncGVfZGV2aWNlICAgICAgLSBQYXJlbnQgR1BFIERldmljZS4gTlVMTCBmb3IgR1BFMC9HUEUxCi0gKiAgICAgICAgICAgICAgZ3BlX251bWJlciAgICAgIC0gR1BFIGxldmVsIHdpdGhpbiB0aGUgR1BFIGJsb2NrCi0gKgotICogUkVUVVJOOiAgICAgIFN0YXR1cwotICoKLSAqIERFU0NSSVBUSU9OOiBBZGQgYSByZWZlcmVuY2UgdG8gYSBHUEUuIE9uIHRoZSBmaXJzdCByZWZlcmVuY2UsIHRoZSBHUEUgaXMKLSAqICAgICAgICAgICAgICBoYXJkd2FyZS1lbmFibGVkLgotICoKLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi1hY3BpX3N0YXR1cyBhY3BpX2VuYWJsZV9ncGUoYWNwaV9oYW5kbGUgZ3BlX2RldmljZSwgdTMyIGdwZV9udW1iZXIpCi17Ci0JYWNwaV9zdGF0dXMgc3RhdHVzID0gQUVfQkFEX1BBUkFNRVRFUjsKLQlzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbyAqZ3BlX2V2ZW50X2luZm87Ci0JYWNwaV9jcHVfZmxhZ3MgZmxhZ3M7Ci0KLQlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGFjcGlfZW5hYmxlX2dwZSk7Ci0KLQlmbGFncyA9IGFjcGlfb3NfYWNxdWlyZV9sb2NrKGFjcGlfZ2JsX2dwZV9sb2NrKTsKLQotCS8qIEVuc3VyZSB0aGF0IHdlIGhhdmUgYSB2YWxpZCBHUEUgbnVtYmVyICovCi0KLQlncGVfZXZlbnRfaW5mbyA9IGFjcGlfZXZfZ2V0X2dwZV9ldmVudF9pbmZvKGdwZV9kZXZpY2UsIGdwZV9udW1iZXIpOwotCWlmIChncGVfZXZlbnRfaW5mbykgewotCQlzdGF0dXMgPSBhY3BpX3Jhd19lbmFibGVfZ3BlKGdwZV9ldmVudF9pbmZvKTsKLQl9Ci0KLQlhY3BpX29zX3JlbGVhc2VfbG9jayhhY3BpX2dibF9ncGVfbG9jaywgZmxhZ3MpOwotCXJldHVybl9BQ1BJX1NUQVRVUyhzdGF0dXMpOwotfQotQUNQSV9FWFBPUlRfU1lNQk9MKGFjcGlfZW5hYmxlX2dwZSkKLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqCi0gKiBGVU5DVElPTjogICAgYWNwaV9kaXNhYmxlX2dwZQotICoKLSAqIFBBUkFNRVRFUlM6ICBncGVfZGV2aWNlICAgICAgLSBQYXJlbnQgR1BFIERldmljZS4gTlVMTCBmb3IgR1BFMC9HUEUxCi0gKiAgICAgICAgICAgICAgZ3BlX251bWJlciAgICAgIC0gR1BFIGxldmVsIHdpdGhpbiB0aGUgR1BFIGJsb2NrCi0gKgotICogUkVUVVJOOiAgICAgIFN0YXR1cwotICoKLSAqIERFU0NSSVBUSU9OOiBSZW1vdmUgYSByZWZlcmVuY2UgdG8gYSBHUEUuIFdoZW4gdGhlIGxhc3QgcmVmZXJlbmNlIGlzCi0gKiAgICAgICAgICAgICAgcmVtb3ZlZCwgb25seSB0aGVuIGlzIHRoZSBHUEUgZGlzYWJsZWQgKGZvciBydW50aW1lIEdQRXMpLCBvcgotICogICAgICAgICAgICAgIHRoZSBHUEUgbWFzayBiaXQgZGlzYWJsZWQgKGZvciB3YWtlIEdQRXMpCi0gKgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLWFjcGlfc3RhdHVzIGFjcGlfZGlzYWJsZV9ncGUoYWNwaV9oYW5kbGUgZ3BlX2RldmljZSwgdTMyIGdwZV9udW1iZXIpCi17Ci0JYWNwaV9zdGF0dXMgc3RhdHVzID0gQUVfQkFEX1BBUkFNRVRFUjsKLQlzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbyAqZ3BlX2V2ZW50X2luZm87Ci0JYWNwaV9jcHVfZmxhZ3MgZmxhZ3M7Ci0KLQlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGFjcGlfZGlzYWJsZV9ncGUpOwotCi0JZmxhZ3MgPSBhY3BpX29zX2FjcXVpcmVfbG9jayhhY3BpX2dibF9ncGVfbG9jayk7Ci0KLQkvKiBFbnN1cmUgdGhhdCB3ZSBoYXZlIGEgdmFsaWQgR1BFIG51bWJlciAqLwotCi0JZ3BlX2V2ZW50X2luZm8gPSBhY3BpX2V2X2dldF9ncGVfZXZlbnRfaW5mbyhncGVfZGV2aWNlLCBncGVfbnVtYmVyKTsKLQlpZiAoZ3BlX2V2ZW50X2luZm8pIHsKLQkJc3RhdHVzID0gYWNwaV9yYXdfZGlzYWJsZV9ncGUoZ3BlX2V2ZW50X2luZm8pIDsKLQl9Ci0KLQlhY3BpX29zX3JlbGVhc2VfbG9jayhhY3BpX2dibF9ncGVfbG9jaywgZmxhZ3MpOwotCXJldHVybl9BQ1BJX1NUQVRVUyhzdGF0dXMpOwotfQotQUNQSV9FWFBPUlRfU1lNQk9MKGFjcGlfZGlzYWJsZV9ncGUpCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKgotICogRlVOQ1RJT046ICAgIGFjcGlfZ3BlX2Nhbl93YWtlCi0gKgotICogUEFSQU1FVEVSUzogIGdwZV9kZXZpY2UgICAgICAtIFBhcmVudCBHUEUgRGV2aWNlLiBOVUxMIGZvciBHUEUwL0dQRTEKLSAqICAgICAgICAgICAgICBncGVfbnVtYmVyICAgICAgLSBHUEUgbGV2ZWwgd2l0aGluIHRoZSBHUEUgYmxvY2sKLSAqCi0gKiBSRVRVUk46ICAgICAgU3RhdHVzCi0gKgotICogREVTQ1JJUFRJT046IFNldCB0aGUgQUNQSV9HUEVfQ0FOX1dBS0UgZmxhZyBmb3IgdGhlIGdpdmVuIEdQRS4gIElmIHRoZSBHUEUKLSAqICAgICAgICAgICAgICBoYXMgYSBjb3JyZXNwb25kaW5nIG1ldGhvZCBhbmQgaXMgY3VycmVudGx5IGVuYWJsZWQsIGRpc2FibGUgaXQKLSAqICAgICAgICAgICAgICAoR1BFcyB3aXRoIGNvcnJlc3BvbmRpbmcgbWV0aG9kcyBhcmUgZW5hYmxlZCB1bmNvbmRpdGlvbmFsbHkKLSAqICAgICAgICAgICAgICBkdXJpbmcgaW5pdGlhbGl6YXRpb24sIGJ1dCBHUEVzIHRoYXQgY2FuIHdha2UgdXAgYXJlIGV4cGVjdGVkCi0gKiAgICAgICAgICAgICAgdG8gYmUgaW5pdGlhbGx5IGRpc2FibGVkKS4KLSAqCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotYWNwaV9zdGF0dXMgYWNwaV9ncGVfY2FuX3dha2UoYWNwaV9oYW5kbGUgZ3BlX2RldmljZSwgdTMyIGdwZV9udW1iZXIpCi17Ci0JYWNwaV9zdGF0dXMgc3RhdHVzID0gQUVfT0s7Ci0Jc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvOwotCWFjcGlfY3B1X2ZsYWdzIGZsYWdzOwotCi0JQUNQSV9GVU5DVElPTl9UUkFDRShhY3BpX2dwZV9jYW5fd2FrZSk7Ci0KLQlmbGFncyA9IGFjcGlfb3NfYWNxdWlyZV9sb2NrKGFjcGlfZ2JsX2dwZV9sb2NrKTsKLQotCS8qIEVuc3VyZSB0aGF0IHdlIGhhdmUgYSB2YWxpZCBHUEUgbnVtYmVyICovCi0KLQlncGVfZXZlbnRfaW5mbyA9IGFjcGlfZXZfZ2V0X2dwZV9ldmVudF9pbmZvKGdwZV9kZXZpY2UsIGdwZV9udW1iZXIpOwotCWlmIChncGVfZXZlbnRfaW5mbykgewotCQlncGVfZXZlbnRfaW5mby0+ZmxhZ3MgfD0gQUNQSV9HUEVfQ0FOX1dBS0U7Ci0JfSBlbHNlIHsKLQkJc3RhdHVzID0gQUVfQkFEX1BBUkFNRVRFUjsKLQl9Ci0KLQlhY3BpX29zX3JlbGVhc2VfbG9jayhhY3BpX2dibF9ncGVfbG9jaywgZmxhZ3MpOwotCXJldHVybl9BQ1BJX1NUQVRVUyhzdGF0dXMpOwotfQotQUNQSV9FWFBPUlRfU1lNQk9MKGFjcGlfZ3BlX2Nhbl93YWtlKQotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICoKICAqIEZVTkNUSU9OOiAgICBhY3BpX2Rpc2FibGVfZXZlbnQKICAqCiAgKiBQQVJBTUVURVJTOiAgRXZlbnQgICAgICAgICAgIC0gVGhlIGZpeGVkIGV2ZW50dG8gYmUgZW5hYmxlZApAQCAtNDgzLDQ0ICsyOTcsNiBAQAogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICoKLSAqIEZVTkNUSU9OOiAgICBhY3BpX2NsZWFyX2dwZQotICoKLSAqIFBBUkFNRVRFUlM6ICBncGVfZGV2aWNlICAgICAgLSBQYXJlbnQgR1BFIERldmljZS4gTlVMTCBmb3IgR1BFMC9HUEUxCi0gKiAgICAgICAgICAgICAgZ3BlX251bWJlciAgICAgIC0gR1BFIGxldmVsIHdpdGhpbiB0aGUgR1BFIGJsb2NrCi0gKgotICogUkVUVVJOOiAgICAgIFN0YXR1cwotICoKLSAqIERFU0NSSVBUSU9OOiBDbGVhciBhbiBBQ1BJIGV2ZW50IChnZW5lcmFsIHB1cnBvc2UpCi0gKgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLWFjcGlfc3RhdHVzIGFjcGlfY2xlYXJfZ3BlKGFjcGlfaGFuZGxlIGdwZV9kZXZpY2UsIHUzMiBncGVfbnVtYmVyKQotewotCWFjcGlfc3RhdHVzIHN0YXR1cyA9IEFFX09LOwotCXN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbzsKLQlhY3BpX2NwdV9mbGFncyBmbGFnczsKLQotCUFDUElfRlVOQ1RJT05fVFJBQ0UoYWNwaV9jbGVhcl9ncGUpOwotCi0JZmxhZ3MgPSBhY3BpX29zX2FjcXVpcmVfbG9jayhhY3BpX2dibF9ncGVfbG9jayk7Ci0KLQkvKiBFbnN1cmUgdGhhdCB3ZSBoYXZlIGEgdmFsaWQgR1BFIG51bWJlciAqLwotCi0JZ3BlX2V2ZW50X2luZm8gPSBhY3BpX2V2X2dldF9ncGVfZXZlbnRfaW5mbyhncGVfZGV2aWNlLCBncGVfbnVtYmVyKTsKLQlpZiAoIWdwZV9ldmVudF9pbmZvKSB7Ci0JCXN0YXR1cyA9IEFFX0JBRF9QQVJBTUVURVI7Ci0JCWdvdG8gdW5sb2NrX2FuZF9leGl0OwotCX0KLQotCXN0YXR1cyA9IGFjcGlfaHdfY2xlYXJfZ3BlKGdwZV9ldmVudF9pbmZvKTsKLQotICAgICAgdW5sb2NrX2FuZF9leGl0OgotCWFjcGlfb3NfcmVsZWFzZV9sb2NrKGFjcGlfZ2JsX2dwZV9sb2NrLCBmbGFncyk7Ci0JcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Ci19Ci0KLUFDUElfRVhQT1JUX1NZTUJPTChhY3BpX2NsZWFyX2dwZSkKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKgogICogRlVOQ1RJT046ICAgIGFjcGlfZ2V0X2V2ZW50X3N0YXR1cwogICoKICAqIFBBUkFNRVRFUlM6ICBFdmVudCAgICAgICAgICAgLSBUaGUgZml4ZWQgZXZlbnQKQEAgLTU3NSwzNzkgKzM1MSwzIEBACiB9CiAKIEFDUElfRVhQT1JUX1NZTUJPTChhY3BpX2dldF9ldmVudF9zdGF0dXMpCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKgotICogRlVOQ1RJT046ICAgIGFjcGlfZ2V0X2dwZV9zdGF0dXMKLSAqCi0gKiBQQVJBTUVURVJTOiAgZ3BlX2RldmljZSAgICAgIC0gUGFyZW50IEdQRSBEZXZpY2UuIE5VTEwgZm9yIEdQRTAvR1BFMQotICogICAgICAgICAgICAgIGdwZV9udW1iZXIgICAgICAtIEdQRSBsZXZlbCB3aXRoaW4gdGhlIEdQRSBibG9jawotICogICAgICAgICAgICAgIGV2ZW50X3N0YXR1cyAgICAtIFdoZXJlIHRoZSBjdXJyZW50IHN0YXR1cyBvZiB0aGUgZXZlbnQgd2lsbAotICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJlIHJldHVybmVkCi0gKgotICogUkVUVVJOOiAgICAgIFN0YXR1cwotICoKLSAqIERFU0NSSVBUSU9OOiBHZXQgc3RhdHVzIG9mIGFuIGV2ZW50IChnZW5lcmFsIHB1cnBvc2UpCi0gKgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLWFjcGlfc3RhdHVzCi1hY3BpX2dldF9ncGVfc3RhdHVzKGFjcGlfaGFuZGxlIGdwZV9kZXZpY2UsCi0JCSAgICB1MzIgZ3BlX251bWJlciwgYWNwaV9ldmVudF9zdGF0dXMgKmV2ZW50X3N0YXR1cykKLXsKLQlhY3BpX3N0YXR1cyBzdGF0dXMgPSBBRV9PSzsKLQlzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbyAqZ3BlX2V2ZW50X2luZm87Ci0JYWNwaV9jcHVfZmxhZ3MgZmxhZ3M7Ci0KLQlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGFjcGlfZ2V0X2dwZV9zdGF0dXMpOwotCi0JZmxhZ3MgPSBhY3BpX29zX2FjcXVpcmVfbG9jayhhY3BpX2dibF9ncGVfbG9jayk7Ci0KLQkvKiBFbnN1cmUgdGhhdCB3ZSBoYXZlIGEgdmFsaWQgR1BFIG51bWJlciAqLwotCi0JZ3BlX2V2ZW50X2luZm8gPSBhY3BpX2V2X2dldF9ncGVfZXZlbnRfaW5mbyhncGVfZGV2aWNlLCBncGVfbnVtYmVyKTsKLQlpZiAoIWdwZV9ldmVudF9pbmZvKSB7Ci0JCXN0YXR1cyA9IEFFX0JBRF9QQVJBTUVURVI7Ci0JCWdvdG8gdW5sb2NrX2FuZF9leGl0OwotCX0KLQotCS8qIE9idGFpbiBzdGF0dXMgb24gdGhlIHJlcXVlc3RlZCBHUEUgbnVtYmVyICovCi0KLQlzdGF0dXMgPSBhY3BpX2h3X2dldF9ncGVfc3RhdHVzKGdwZV9ldmVudF9pbmZvLCBldmVudF9zdGF0dXMpOwotCi0JaWYgKGdwZV9ldmVudF9pbmZvLT5mbGFncyAmIEFDUElfR1BFX0RJU1BBVENIX01BU0spCi0JCSpldmVudF9zdGF0dXMgfD0gQUNQSV9FVkVOVF9GTEFHX0hBTkRMRTsKLQotICAgICAgdW5sb2NrX2FuZF9leGl0OgotCWFjcGlfb3NfcmVsZWFzZV9sb2NrKGFjcGlfZ2JsX2dwZV9sb2NrLCBmbGFncyk7Ci0JcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Ci19Ci0KLUFDUElfRVhQT1JUX1NZTUJPTChhY3BpX2dldF9ncGVfc3RhdHVzKQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqCi0gKiBGVU5DVElPTjogICAgYWNwaV9pbnN0YWxsX2dwZV9ibG9jawotICoKLSAqIFBBUkFNRVRFUlM6ICBncGVfZGV2aWNlICAgICAgICAgIC0gSGFuZGxlIHRvIHRoZSBwYXJlbnQgR1BFIEJsb2NrIERldmljZQotICogICAgICAgICAgICAgIGdwZV9ibG9ja19hZGRyZXNzICAgLSBBZGRyZXNzIGFuZCBzcGFjZV9pRAotICogICAgICAgICAgICAgIHJlZ2lzdGVyX2NvdW50ICAgICAgLSBOdW1iZXIgb2YgR1BFIHJlZ2lzdGVyIHBhaXJzIGluIHRoZSBibG9jawotICogICAgICAgICAgICAgIGludGVycnVwdF9udW1iZXIgICAgLSBIL1cgaW50ZXJydXB0IGZvciB0aGUgYmxvY2sKLSAqCi0gKiBSRVRVUk46ICAgICAgU3RhdHVzCi0gKgotICogREVTQ1JJUFRJT046IENyZWF0ZSBhbmQgSW5zdGFsbCBhIGJsb2NrIG9mIEdQRSByZWdpc3RlcnMKLSAqCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotYWNwaV9zdGF0dXMKLWFjcGlfaW5zdGFsbF9ncGVfYmxvY2soYWNwaV9oYW5kbGUgZ3BlX2RldmljZSwKLQkJICAgICAgIHN0cnVjdCBhY3BpX2dlbmVyaWNfYWRkcmVzcyAqZ3BlX2Jsb2NrX2FkZHJlc3MsCi0JCSAgICAgICB1MzIgcmVnaXN0ZXJfY291bnQsIHUzMiBpbnRlcnJ1cHRfbnVtYmVyKQotewotCWFjcGlfc3RhdHVzIHN0YXR1cyA9IEFFX09LOwotCXVuaW9uIGFjcGlfb3BlcmFuZF9vYmplY3QgKm9ial9kZXNjOwotCXN0cnVjdCBhY3BpX25hbWVzcGFjZV9ub2RlICpub2RlOwotCXN0cnVjdCBhY3BpX2dwZV9ibG9ja19pbmZvICpncGVfYmxvY2s7Ci0KLQlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGFjcGlfaW5zdGFsbF9ncGVfYmxvY2spOwotCi0JaWYgKCghZ3BlX2RldmljZSkgfHwgKCFncGVfYmxvY2tfYWRkcmVzcykgfHwgKCFyZWdpc3Rlcl9jb3VudCkpIHsKLQkJcmV0dXJuX0FDUElfU1RBVFVTKEFFX0JBRF9QQVJBTUVURVIpOwotCX0KLQotCXN0YXR1cyA9IGFjcGlfdXRfYWNxdWlyZV9tdXRleChBQ1BJX01UWF9OQU1FU1BBQ0UpOwotCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgewotCQlyZXR1cm4gKHN0YXR1cyk7Ci0JfQotCi0Jbm9kZSA9IGFjcGlfbnNfdmFsaWRhdGVfaGFuZGxlKGdwZV9kZXZpY2UpOwotCWlmICghbm9kZSkgewotCQlzdGF0dXMgPSBBRV9CQURfUEFSQU1FVEVSOwotCQlnb3RvIHVubG9ja19hbmRfZXhpdDsKLQl9Ci0KLQkvKgotCSAqIEZvciB1c2VyLWluc3RhbGxlZCBHUEUgQmxvY2sgRGV2aWNlcywgdGhlIGdwZV9ibG9ja19iYXNlX251bWJlcgotCSAqIGlzIGFsd2F5cyB6ZXJvCi0JICovCi0Jc3RhdHVzID0KLQkgICAgYWNwaV9ldl9jcmVhdGVfZ3BlX2Jsb2NrKG5vZGUsIGdwZV9ibG9ja19hZGRyZXNzLCByZWdpc3Rlcl9jb3VudCwgMCwKLQkJCQkgICAgIGludGVycnVwdF9udW1iZXIsICZncGVfYmxvY2spOwotCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgewotCQlnb3RvIHVubG9ja19hbmRfZXhpdDsKLQl9Ci0KLQkvKiBJbnN0YWxsIGJsb2NrIGluIHRoZSBkZXZpY2Vfb2JqZWN0IGF0dGFjaGVkIHRvIHRoZSBub2RlICovCi0KLQlvYmpfZGVzYyA9IGFjcGlfbnNfZ2V0X2F0dGFjaGVkX29iamVjdChub2RlKTsKLQlpZiAoIW9ial9kZXNjKSB7Ci0KLQkJLyoKLQkJICogTm8gb2JqZWN0LCBjcmVhdGUgYSBuZXcgb25lIChEZXZpY2Ugbm9kZXMgZG8gbm90IGFsd2F5cyBoYXZlCi0JCSAqIGFuIGF0dGFjaGVkIG9iamVjdCkKLQkJICovCi0JCW9ial9kZXNjID0gYWNwaV91dF9jcmVhdGVfaW50ZXJuYWxfb2JqZWN0KEFDUElfVFlQRV9ERVZJQ0UpOwotCQlpZiAoIW9ial9kZXNjKSB7Ci0JCQlzdGF0dXMgPSBBRV9OT19NRU1PUlk7Ci0JCQlnb3RvIHVubG9ja19hbmRfZXhpdDsKLQkJfQotCi0JCXN0YXR1cyA9Ci0JCSAgICBhY3BpX25zX2F0dGFjaF9vYmplY3Qobm9kZSwgb2JqX2Rlc2MsIEFDUElfVFlQRV9ERVZJQ0UpOwotCi0JCS8qIFJlbW92ZSBsb2NhbCByZWZlcmVuY2UgdG8gdGhlIG9iamVjdCAqLwotCi0JCWFjcGlfdXRfcmVtb3ZlX3JlZmVyZW5jZShvYmpfZGVzYyk7Ci0KLQkJaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKSB7Ci0JCQlnb3RvIHVubG9ja19hbmRfZXhpdDsKLQkJfQotCX0KLQotCS8qIE5vdyBpbnN0YWxsIHRoZSBHUEUgYmxvY2sgaW4gdGhlIGRldmljZV9vYmplY3QgKi8KLQotCW9ial9kZXNjLT5kZXZpY2UuZ3BlX2Jsb2NrID0gZ3BlX2Jsb2NrOwotCi0gICAgICB1bmxvY2tfYW5kX2V4aXQ6Ci0JKHZvaWQpYWNwaV91dF9yZWxlYXNlX211dGV4KEFDUElfTVRYX05BTUVTUEFDRSk7Ci0JcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Ci19Ci0KLUFDUElfRVhQT1JUX1NZTUJPTChhY3BpX2luc3RhbGxfZ3BlX2Jsb2NrKQotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICoKLSAqIEZVTkNUSU9OOiAgICBhY3BpX3JlbW92ZV9ncGVfYmxvY2sKLSAqCi0gKiBQQVJBTUVURVJTOiAgZ3BlX2RldmljZSAgICAgICAgICAtIEhhbmRsZSB0byB0aGUgcGFyZW50IEdQRSBCbG9jayBEZXZpY2UKLSAqCi0gKiBSRVRVUk46ICAgICAgU3RhdHVzCi0gKgotICogREVTQ1JJUFRJT046IFJlbW92ZSBhIHByZXZpb3VzbHkgaW5zdGFsbGVkIGJsb2NrIG9mIEdQRSByZWdpc3RlcnMKLSAqCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotYWNwaV9zdGF0dXMgYWNwaV9yZW1vdmVfZ3BlX2Jsb2NrKGFjcGlfaGFuZGxlIGdwZV9kZXZpY2UpCi17Ci0JdW5pb24gYWNwaV9vcGVyYW5kX29iamVjdCAqb2JqX2Rlc2M7Ci0JYWNwaV9zdGF0dXMgc3RhdHVzOwotCXN0cnVjdCBhY3BpX25hbWVzcGFjZV9ub2RlICpub2RlOwotCi0JQUNQSV9GVU5DVElPTl9UUkFDRShhY3BpX3JlbW92ZV9ncGVfYmxvY2spOwotCi0JaWYgKCFncGVfZGV2aWNlKSB7Ci0JCXJldHVybl9BQ1BJX1NUQVRVUyhBRV9CQURfUEFSQU1FVEVSKTsKLQl9Ci0KLQlzdGF0dXMgPSBhY3BpX3V0X2FjcXVpcmVfbXV0ZXgoQUNQSV9NVFhfTkFNRVNQQUNFKTsKLQlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKLQkJcmV0dXJuIChzdGF0dXMpOwotCX0KLQotCW5vZGUgPSBhY3BpX25zX3ZhbGlkYXRlX2hhbmRsZShncGVfZGV2aWNlKTsKLQlpZiAoIW5vZGUpIHsKLQkJc3RhdHVzID0gQUVfQkFEX1BBUkFNRVRFUjsKLQkJZ290byB1bmxvY2tfYW5kX2V4aXQ7Ci0JfQotCi0JLyogR2V0IHRoZSBkZXZpY2Vfb2JqZWN0IGF0dGFjaGVkIHRvIHRoZSBub2RlICovCi0KLQlvYmpfZGVzYyA9IGFjcGlfbnNfZ2V0X2F0dGFjaGVkX29iamVjdChub2RlKTsKLQlpZiAoIW9ial9kZXNjIHx8ICFvYmpfZGVzYy0+ZGV2aWNlLmdwZV9ibG9jaykgewotCQlyZXR1cm5fQUNQSV9TVEFUVVMoQUVfTlVMTF9PQkpFQ1QpOwotCX0KLQotCS8qIERlbGV0ZSB0aGUgR1BFIGJsb2NrIChidXQgbm90IHRoZSBkZXZpY2Vfb2JqZWN0KSAqLwotCi0Jc3RhdHVzID0gYWNwaV9ldl9kZWxldGVfZ3BlX2Jsb2NrKG9ial9kZXNjLT5kZXZpY2UuZ3BlX2Jsb2NrKTsKLQlpZiAoQUNQSV9TVUNDRVNTKHN0YXR1cykpIHsKLQkJb2JqX2Rlc2MtPmRldmljZS5ncGVfYmxvY2sgPSBOVUxMOwotCX0KLQotICAgICAgdW5sb2NrX2FuZF9leGl0OgotCSh2b2lkKWFjcGlfdXRfcmVsZWFzZV9tdXRleChBQ1BJX01UWF9OQU1FU1BBQ0UpOwotCXJldHVybl9BQ1BJX1NUQVRVUyhzdGF0dXMpOwotfQotCi1BQ1BJX0VYUE9SVF9TWU1CT0woYWNwaV9yZW1vdmVfZ3BlX2Jsb2NrKQotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICoKLSAqIEZVTkNUSU9OOiAgICBhY3BpX2dldF9ncGVfZGV2aWNlCi0gKgotICogUEFSQU1FVEVSUzogIEluZGV4ICAgICAgICAgICAgICAgLSBTeXN0ZW0gR1BFIGluZGV4ICgwLWN1cnJlbnRfZ3BlX2NvdW50KQotICogICAgICAgICAgICAgIGdwZV9kZXZpY2UgICAgICAgICAgLSBXaGVyZSB0aGUgcGFyZW50IEdQRSBEZXZpY2UgaXMgcmV0dXJuZWQKLSAqCi0gKiBSRVRVUk46ICAgICAgU3RhdHVzCi0gKgotICogREVTQ1JJUFRJT046IE9idGFpbiB0aGUgR1BFIGRldmljZSBhc3NvY2lhdGVkIHdpdGggdGhlIGlucHV0IGluZGV4LiBBIE5VTEwKLSAqICAgICAgICAgICAgICBncGUgZGV2aWNlIGluZGljYXRlcyB0aGF0IHRoZSBncGUgbnVtYmVyIGlzIGNvbnRhaW5lZCBpbiBvbmUgb2YKLSAqICAgICAgICAgICAgICB0aGUgRkFEVC1kZWZpbmVkIGdwZSBibG9ja3MuIE90aGVyd2lzZSwgdGhlIEdQRSBibG9jayBkZXZpY2UuCi0gKgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLWFjcGlfc3RhdHVzCi1hY3BpX2dldF9ncGVfZGV2aWNlKHUzMiBpbmRleCwgYWNwaV9oYW5kbGUgKmdwZV9kZXZpY2UpCi17Ci0Jc3RydWN0IGFjcGlfZ3BlX2RldmljZV9pbmZvIGluZm87Ci0JYWNwaV9zdGF0dXMgc3RhdHVzOwotCi0JQUNQSV9GVU5DVElPTl9UUkFDRShhY3BpX2dldF9ncGVfZGV2aWNlKTsKLQotCWlmICghZ3BlX2RldmljZSkgewotCQlyZXR1cm5fQUNQSV9TVEFUVVMoQUVfQkFEX1BBUkFNRVRFUik7Ci0JfQotCi0JaWYgKGluZGV4ID49IGFjcGlfY3VycmVudF9ncGVfY291bnQpIHsKLQkJcmV0dXJuX0FDUElfU1RBVFVTKEFFX05PVF9FWElTVCk7Ci0JfQotCi0JLyogU2V0dXAgYW5kIHdhbGsgdGhlIEdQRSBsaXN0ICovCi0KLQlpbmZvLmluZGV4ID0gaW5kZXg7Ci0JaW5mby5zdGF0dXMgPSBBRV9OT1RfRVhJU1Q7Ci0JaW5mby5ncGVfZGV2aWNlID0gTlVMTDsKLQlpbmZvLm5leHRfYmxvY2tfYmFzZV9pbmRleCA9IDA7Ci0KLQlzdGF0dXMgPSBhY3BpX2V2X3dhbGtfZ3BlX2xpc3QoYWNwaV9ldl9nZXRfZ3BlX2RldmljZSwgJmluZm8pOwotCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgewotCQlyZXR1cm5fQUNQSV9TVEFUVVMoc3RhdHVzKTsKLQl9Ci0KLQkqZ3BlX2RldmljZSA9IGluZm8uZ3BlX2RldmljZTsKLQlyZXR1cm5fQUNQSV9TVEFUVVMoaW5mby5zdGF0dXMpOwotfQotCi1BQ1BJX0VYUE9SVF9TWU1CT0woYWNwaV9nZXRfZ3BlX2RldmljZSkKLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqCi0gKiBGVU5DVElPTjogICAgYWNwaV9ldl9nZXRfZ3BlX2RldmljZQotICoKLSAqIFBBUkFNRVRFUlM6ICBHUEVfV0FMS19DQUxMQkFDSwotICoKLSAqIFJFVFVSTjogICAgICBTdGF0dXMKLSAqCi0gKiBERVNDUklQVElPTjogTWF0Y2hlcyB0aGUgaW5wdXQgR1BFIGluZGV4ICgwLWN1cnJlbnRfZ3BlX2NvdW50KSB3aXRoIGEgR1BFCi0gKiAgICAgICAgICAgICAgYmxvY2sgZGV2aWNlLiBOVUxMIGlmIHRoZSBHUEUgaXMgb25lIG9mIHRoZSBGQURULWRlZmluZWQgR1BFcy4KLSAqCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotc3RhdGljIGFjcGlfc3RhdHVzCi1hY3BpX2V2X2dldF9ncGVfZGV2aWNlKHN0cnVjdCBhY3BpX2dwZV94cnVwdF9pbmZvICpncGVfeHJ1cHRfaW5mbywKLQkJICAgICAgIHN0cnVjdCBhY3BpX2dwZV9ibG9ja19pbmZvICpncGVfYmxvY2ssIHZvaWQgKmNvbnRleHQpCi17Ci0Jc3RydWN0IGFjcGlfZ3BlX2RldmljZV9pbmZvICppbmZvID0gY29udGV4dDsKLQotCS8qIEluY3JlbWVudCBJbmRleCBieSB0aGUgbnVtYmVyIG9mIEdQRXMgaW4gdGhpcyBibG9jayAqLwotCi0JaW5mby0+bmV4dF9ibG9ja19iYXNlX2luZGV4ICs9IGdwZV9ibG9jay0+Z3BlX2NvdW50OwotCi0JaWYgKGluZm8tPmluZGV4IDwgaW5mby0+bmV4dF9ibG9ja19iYXNlX2luZGV4KSB7Ci0JCS8qCi0JCSAqIFRoZSBHUEUgaW5kZXggaXMgd2l0aGluIHRoaXMgYmxvY2ssIGdldCB0aGUgbm9kZS4gTGVhdmUgdGhlIG5vZGUKLQkJICogTlVMTCBmb3IgdGhlIEZBRFQtZGVmaW5lZCBHUEVzCi0JCSAqLwotCQlpZiAoKGdwZV9ibG9jay0+bm9kZSktPnR5cGUgPT0gQUNQSV9UWVBFX0RFVklDRSkgewotCQkJaW5mby0+Z3BlX2RldmljZSA9IGdwZV9ibG9jay0+bm9kZTsKLQkJfQotCi0JCWluZm8tPnN0YXR1cyA9IEFFX09LOwotCQlyZXR1cm4gKEFFX0NUUkxfRU5EKTsKLQl9Ci0KLQlyZXR1cm4gKEFFX09LKTsKLX0KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICoKLSAqIEZVTkNUSU9OOiAgICBhY3BpX2Rpc2FibGVfYWxsX2dwZXMKLSAqCi0gKiBQQVJBTUVURVJTOiAgTm9uZQotICoKLSAqIFJFVFVSTjogICAgICBTdGF0dXMKLSAqCi0gKiBERVNDUklQVElPTjogRGlzYWJsZSBhbmQgY2xlYXIgYWxsIEdQRXMgaW4gYWxsIEdQRSBibG9ja3MKLSAqCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotCi1hY3BpX3N0YXR1cyBhY3BpX2Rpc2FibGVfYWxsX2dwZXModm9pZCkKLXsKLQlhY3BpX3N0YXR1cyBzdGF0dXM7Ci0KLQlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGFjcGlfZGlzYWJsZV9hbGxfZ3Blcyk7Ci0KLQlzdGF0dXMgPSBhY3BpX3V0X2FjcXVpcmVfbXV0ZXgoQUNQSV9NVFhfRVZFTlRTKTsKLQlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKLQkJcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Ci0JfQotCi0Jc3RhdHVzID0gYWNwaV9od19kaXNhYmxlX2FsbF9ncGVzKCk7Ci0JKHZvaWQpYWNwaV91dF9yZWxlYXNlX211dGV4KEFDUElfTVRYX0VWRU5UUyk7Ci0KLQlyZXR1cm5fQUNQSV9TVEFUVVMoc3RhdHVzKTsKLX0KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotICoKLSAqIEZVTkNUSU9OOiAgICBhY3BpX2VuYWJsZV9hbGxfcnVudGltZV9ncGVzCi0gKgotICogUEFSQU1FVEVSUzogIE5vbmUKLSAqCi0gKiBSRVRVUk46ICAgICAgU3RhdHVzCi0gKgotICogREVTQ1JJUFRJT046IEVuYWJsZSBhbGwgInJ1bnRpbWUiIEdQRXMsIGluIGFsbCBHUEUgYmxvY2tzCi0gKgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLQotYWNwaV9zdGF0dXMgYWNwaV9lbmFibGVfYWxsX3J1bnRpbWVfZ3Blcyh2b2lkKQotewotCWFjcGlfc3RhdHVzIHN0YXR1czsKLQotCUFDUElfRlVOQ1RJT05fVFJBQ0UoYWNwaV9lbmFibGVfYWxsX3J1bnRpbWVfZ3Blcyk7Ci0KLQlzdGF0dXMgPSBhY3BpX3V0X2FjcXVpcmVfbXV0ZXgoQUNQSV9NVFhfRVZFTlRTKTsKLQlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKLQkJcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Ci0JfQotCi0Jc3RhdHVzID0gYWNwaV9od19lbmFibGVfYWxsX3J1bnRpbWVfZ3BlcygpOwotCSh2b2lkKWFjcGlfdXRfcmVsZWFzZV9tdXRleChBQ1BJX01UWF9FVkVOVFMpOwotCi0JcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Ci19Ci0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqCi0gKiBGVU5DVElPTjogICAgYWNwaV91cGRhdGVfZ3BlcwotICoKLSAqIFBBUkFNRVRFUlM6ICBOb25lCi0gKgotICogUkVUVVJOOiAgICAgIE5vbmUKLSAqCi0gKiBERVNDUklQVElPTjogRW5hYmxlIGFsbCBHUEVzIHRoYXQgaGF2ZSBhc3NvY2lhdGVkIF9MeHggb3IgX0V4eCBtZXRob2RzIGFuZAotICogICAgICAgICAgICAgIGFyZSBub3QgcG9pbnRlZCB0byBieSBhbnkgZGV2aWNlIF9QUlcgbWV0aG9kcyBpbmRpY2F0aW5nIHRoYXQKLSAqICAgICAgICAgICAgICB0aGVzZSBHUEVzIGFyZSBnZW5lcmFsbHkgaW50ZW5kZWQgZm9yIHN5c3RlbSBvciBkZXZpY2Ugd2FrZXVwCi0gKiAgICAgICAgICAgICAgKHN1Y2ggR1BFcyBoYXZlIHRvIGJlIGVuYWJsZWQgZGlyZWN0bHkgd2hlbiB0aGUgZGV2aWNlcyB3aG9zZQotICogICAgICAgICAgICAgIF9QUlcgbWV0aG9kcyBwb2ludCB0byB0aGVtIGFyZSBzZXQgdXAgZm9yIHdha2V1cCBzaWduYWxpbmcpLgotICoKLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi0KLWFjcGlfc3RhdHVzIGFjcGlfdXBkYXRlX2dwZXModm9pZCkKLXsKLQlhY3BpX3N0YXR1cyBzdGF0dXM7Ci0KLQlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGFjcGlfdXBkYXRlX2dwZXMpOwotCi0Jc3RhdHVzID0gYWNwaV91dF9hY3F1aXJlX211dGV4KEFDUElfTVRYX0VWRU5UUyk7Ci0JaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKSB7Ci0JCXJldHVybl9BQ1BJX1NUQVRVUyhzdGF0dXMpOwotCX0gZWxzZSBpZiAoYWNwaV9hbGxfZ3Blc19pbml0aWFsaXplZCkgewotCQlnb3RvIHVubG9jazsKLQl9Ci0KLQlzdGF0dXMgPSBhY3BpX2V2X3dhbGtfZ3BlX2xpc3QoYWNwaV9ldl9pbml0aWFsaXplX2dwZV9ibG9jaywgTlVMTCk7Ci0JaWYgKEFDUElfU1VDQ0VTUyhzdGF0dXMpKSB7Ci0JCWFjcGlfYWxsX2dwZXNfaW5pdGlhbGl6ZWQgPSBUUlVFOwotCX0KLQotdW5sb2NrOgotCSh2b2lkKWFjcGlfdXRfcmVsZWFzZV9tdXRleChBQ1BJX01UWF9FVkVOVFMpOwotCi0JcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Ci19CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2eGZncGUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZ4ZmdwZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmU5NTYyYTcKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2eGZncGUuYwpAQCAtMCwwICsxLDY2OSBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICoKKyAqIE1vZHVsZSBOYW1lOiBldnhmZ3BlIC0gRXh0ZXJuYWwgSW50ZXJmYWNlcyBmb3IgR2VuZXJhbCBQdXJwb3NlIEV2ZW50cyAoR1BFcykKKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zLCBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLAorICogICAgd2l0aG91dCBtb2RpZmljYXRpb24uCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgYXQgbWluaW11bSBhIGRpc2NsYWltZXIKKyAqICAgIHN1YnN0YW50aWFsbHkgc2ltaWxhciB0byB0aGUgIk5PIFdBUlJBTlRZIiBkaXNjbGFpbWVyIGJlbG93CisgKiAgICAoIkRpc2NsYWltZXIiKSBhbmQgYW55IHJlZGlzdHJpYnV0aW9uIG11c3QgYmUgY29uZGl0aW9uZWQgdXBvbgorICogICAgaW5jbHVkaW5nIGEgc3Vic3RhbnRpYWxseSBzaW1pbGFyIERpc2NsYWltZXIgcmVxdWlyZW1lbnQgZm9yIGZ1cnRoZXIKKyAqICAgIGJpbmFyeSByZWRpc3RyaWJ1dGlvbi4KKyAqIDMuIE5laXRoZXIgdGhlIG5hbWVzIG9mIHRoZSBhYm92ZS1saXN0ZWQgY29weXJpZ2h0IGhvbGRlcnMgbm9yIHRoZSBuYW1lcworICogICAgb2YgYW55IGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZAorICogICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIEFsdGVybmF0aXZlbHksIHRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlICgiR1BMIikgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZQorICogU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqCisgKiBOTyBXQVJSQU5UWQorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRJQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIEhPTERFUlMgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMCisgKiBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUworICogT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pCisgKiBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsCisgKiBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcKKyAqIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRQorICogUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLgorICovCisKKyNpbmNsdWRlIDxhY3BpL2FjcGkuaD4KKyNpbmNsdWRlICJhY2NvbW1vbi5oIgorI2luY2x1ZGUgImFjZXZlbnRzLmgiCisjaW5jbHVkZSAiYWNuYW1lc3AuaCIKKworI2RlZmluZSBfQ09NUE9ORU5UICAgICAgICAgIEFDUElfRVZFTlRTCitBQ1BJX01PRFVMRV9OQU1FKCJldnhmZ3BlIikKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICoKKyAqIEZVTkNUSU9OOiAgICBhY3BpX3VwZGF0ZV9hbGxfZ3BlcworICoKKyAqIFBBUkFNRVRFUlM6ICBOb25lCisgKgorICogUkVUVVJOOiAgICAgIFN0YXR1cworICoKKyAqIERFU0NSSVBUSU9OOiBDb21wbGV0ZSBHUEUgaW5pdGlhbGl6YXRpb24gYW5kIGVuYWJsZSBhbGwgR1BFcyB0aGF0IGhhdmUKKyAqICAgICAgICAgICAgICBhc3NvY2lhdGVkIF9MeHggb3IgX0V4eCBtZXRob2RzIGFuZCBhcmUgbm90IHBvaW50ZWQgdG8gYnkgYW55CisgKiAgICAgICAgICAgICAgZGV2aWNlIF9QUlcgbWV0aG9kcyAodGhpcyBpbmRpY2F0ZXMgdGhhdCB0aGVzZSBHUEVzIGFyZQorICogICAgICAgICAgICAgIGdlbmVyYWxseSBpbnRlbmRlZCBmb3Igc3lzdGVtIG9yIGRldmljZSB3YWtldXAuIFN1Y2ggR1BFcworICogICAgICAgICAgICAgIGhhdmUgdG8gYmUgZW5hYmxlZCBkaXJlY3RseSB3aGVuIHRoZSBkZXZpY2VzIHdob3NlIF9QUlcKKyAqICAgICAgICAgICAgICBtZXRob2RzIHBvaW50IHRvIHRoZW0gYXJlIHNldCB1cCBmb3Igd2FrZXVwIHNpZ25hbGluZy4pCisgKgorICogTk9URTogU2hvdWxkIGJlIGNhbGxlZCBhZnRlciBhbnkgR1BFcyBhcmUgYWRkZWQgdG8gdGhlIHN5c3RlbS4gUHJpbWFyaWx5LAorICogYWZ0ZXIgdGhlIHN5c3RlbSBfUFJXIG1ldGhvZHMgaGF2ZSBiZWVuIHJ1biwgYnV0IGFsc28gYWZ0ZXIgYSBHUEUgQmxvY2sKKyAqIERldmljZSBoYXMgYmVlbiBhZGRlZCBvciBpZiBhbnkgbmV3IEdQRSBtZXRob2RzIGhhdmUgYmVlbiBhZGRlZCB2aWEgYQorICogZHluYW1pYyB0YWJsZSBsb2FkLgorICoKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKK2FjcGlfc3RhdHVzIGFjcGlfdXBkYXRlX2FsbF9ncGVzKHZvaWQpCit7CisJYWNwaV9zdGF0dXMgc3RhdHVzOworCisJQUNQSV9GVU5DVElPTl9UUkFDRShhY3BpX3VwZGF0ZV9hbGxfZ3Blcyk7CisKKwlzdGF0dXMgPSBhY3BpX3V0X2FjcXVpcmVfbXV0ZXgoQUNQSV9NVFhfRVZFTlRTKTsKKwlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKKwkJcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7CisJfQorCisJaWYgKGFjcGlfZ2JsX2FsbF9ncGVzX2luaXRpYWxpemVkKSB7CisJCWdvdG8gdW5sb2NrX2FuZF9leGl0OworCX0KKworCXN0YXR1cyA9IGFjcGlfZXZfd2Fsa19ncGVfbGlzdChhY3BpX2V2X2luaXRpYWxpemVfZ3BlX2Jsb2NrLCBOVUxMKTsKKwlpZiAoQUNQSV9TVUNDRVNTKHN0YXR1cykpIHsKKwkJYWNwaV9nYmxfYWxsX2dwZXNfaW5pdGlhbGl6ZWQgPSBUUlVFOworCX0KKwordW5sb2NrX2FuZF9leGl0OgorCSh2b2lkKWFjcGlfdXRfcmVsZWFzZV9tdXRleChBQ1BJX01UWF9FVkVOVFMpOworCisJcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Cit9CisKK0FDUElfRVhQT1JUX1NZTUJPTChhY3BpX3VwZGF0ZV9hbGxfZ3BlcykKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqCisgKiBGVU5DVElPTjogICAgYWNwaV9lbmFibGVfZ3BlCisgKgorICogUEFSQU1FVEVSUzogIGdwZV9kZXZpY2UgICAgICAtIFBhcmVudCBHUEUgRGV2aWNlLiBOVUxMIGZvciBHUEUwL0dQRTEKKyAqICAgICAgICAgICAgICBncGVfbnVtYmVyICAgICAgLSBHUEUgbGV2ZWwgd2l0aGluIHRoZSBHUEUgYmxvY2sKKyAqCisgKiBSRVRVUk46ICAgICAgU3RhdHVzCisgKgorICogREVTQ1JJUFRJT046IEFkZCBhIHJlZmVyZW5jZSB0byBhIEdQRS4gT24gdGhlIGZpcnN0IHJlZmVyZW5jZSwgdGhlIEdQRSBpcworICogICAgICAgICAgICAgIGhhcmR3YXJlLWVuYWJsZWQuCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworYWNwaV9zdGF0dXMgYWNwaV9lbmFibGVfZ3BlKGFjcGlfaGFuZGxlIGdwZV9kZXZpY2UsIHUzMiBncGVfbnVtYmVyKQoreworCWFjcGlfc3RhdHVzIHN0YXR1cyA9IEFFX0JBRF9QQVJBTUVURVI7CisJc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvOworCWFjcGlfY3B1X2ZsYWdzIGZsYWdzOworCisJQUNQSV9GVU5DVElPTl9UUkFDRShhY3BpX2VuYWJsZV9ncGUpOworCisJZmxhZ3MgPSBhY3BpX29zX2FjcXVpcmVfbG9jayhhY3BpX2dibF9ncGVfbG9jayk7CisKKwkvKiBFbnN1cmUgdGhhdCB3ZSBoYXZlIGEgdmFsaWQgR1BFIG51bWJlciAqLworCisJZ3BlX2V2ZW50X2luZm8gPSBhY3BpX2V2X2dldF9ncGVfZXZlbnRfaW5mbyhncGVfZGV2aWNlLCBncGVfbnVtYmVyKTsKKwlpZiAoZ3BlX2V2ZW50X2luZm8pIHsKKwkJc3RhdHVzID0gYWNwaV9ldl9hZGRfZ3BlX3JlZmVyZW5jZShncGVfZXZlbnRfaW5mbyk7CisJfQorCisJYWNwaV9vc19yZWxlYXNlX2xvY2soYWNwaV9nYmxfZ3BlX2xvY2ssIGZsYWdzKTsKKwlyZXR1cm5fQUNQSV9TVEFUVVMoc3RhdHVzKTsKK30KK0FDUElfRVhQT1JUX1NZTUJPTChhY3BpX2VuYWJsZV9ncGUpCisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKgorICogRlVOQ1RJT046ICAgIGFjcGlfZGlzYWJsZV9ncGUKKyAqCisgKiBQQVJBTUVURVJTOiAgZ3BlX2RldmljZSAgICAgIC0gUGFyZW50IEdQRSBEZXZpY2UuIE5VTEwgZm9yIEdQRTAvR1BFMQorICogICAgICAgICAgICAgIGdwZV9udW1iZXIgICAgICAtIEdQRSBsZXZlbCB3aXRoaW4gdGhlIEdQRSBibG9jaworICoKKyAqIFJFVFVSTjogICAgICBTdGF0dXMKKyAqCisgKiBERVNDUklQVElPTjogUmVtb3ZlIGEgcmVmZXJlbmNlIHRvIGEgR1BFLiBXaGVuIHRoZSBsYXN0IHJlZmVyZW5jZSBpcworICogICAgICAgICAgICAgIHJlbW92ZWQsIG9ubHkgdGhlbiBpcyB0aGUgR1BFIGRpc2FibGVkIChmb3IgcnVudGltZSBHUEVzKSwgb3IKKyAqICAgICAgICAgICAgICB0aGUgR1BFIG1hc2sgYml0IGRpc2FibGVkIChmb3Igd2FrZSBHUEVzKQorICoKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKK2FjcGlfc3RhdHVzIGFjcGlfZGlzYWJsZV9ncGUoYWNwaV9oYW5kbGUgZ3BlX2RldmljZSwgdTMyIGdwZV9udW1iZXIpCit7CisJYWNwaV9zdGF0dXMgc3RhdHVzID0gQUVfQkFEX1BBUkFNRVRFUjsKKwlzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbyAqZ3BlX2V2ZW50X2luZm87CisJYWNwaV9jcHVfZmxhZ3MgZmxhZ3M7CisKKwlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGFjcGlfZGlzYWJsZV9ncGUpOworCisJZmxhZ3MgPSBhY3BpX29zX2FjcXVpcmVfbG9jayhhY3BpX2dibF9ncGVfbG9jayk7CisKKwkvKiBFbnN1cmUgdGhhdCB3ZSBoYXZlIGEgdmFsaWQgR1BFIG51bWJlciAqLworCisJZ3BlX2V2ZW50X2luZm8gPSBhY3BpX2V2X2dldF9ncGVfZXZlbnRfaW5mbyhncGVfZGV2aWNlLCBncGVfbnVtYmVyKTsKKwlpZiAoZ3BlX2V2ZW50X2luZm8pIHsKKwkJc3RhdHVzID0gYWNwaV9ldl9yZW1vdmVfZ3BlX3JlZmVyZW5jZShncGVfZXZlbnRfaW5mbykgOworCX0KKworCWFjcGlfb3NfcmVsZWFzZV9sb2NrKGFjcGlfZ2JsX2dwZV9sb2NrLCBmbGFncyk7CisJcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Cit9CitBQ1BJX0VYUE9SVF9TWU1CT0woYWNwaV9kaXNhYmxlX2dwZSkKKworCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICoKKyAqIEZVTkNUSU9OOiAgICBhY3BpX3NldHVwX2dwZV9mb3Jfd2FrZQorICoKKyAqIFBBUkFNRVRFUlM6ICB3YWtlX2RldmljZSAgICAgICAgIC0gRGV2aWNlIGFzc29jaWF0ZWQgd2l0aCB0aGUgR1BFICh2aWEgX1BSVykKKyAqICAgICAgICAgICAgICBncGVfZGV2aWNlICAgICAgICAgIC0gUGFyZW50IEdQRSBEZXZpY2UuIE5VTEwgZm9yIEdQRTAvR1BFMQorICogICAgICAgICAgICAgIGdwZV9udW1iZXIgICAgICAgICAgLSBHUEUgbGV2ZWwgd2l0aGluIHRoZSBHUEUgYmxvY2sKKyAqCisgKiBSRVRVUk46ICAgICAgU3RhdHVzCisgKgorICogREVTQ1JJUFRJT046IE1hcmsgYSBHUEUgYXMgaGF2aW5nIHRoZSBhYmlsaXR5IHRvIHdha2UgdGhlIHN5c3RlbS4gVGhpcworICogICAgICAgICAgICAgIGludGVyZmFjZSBpcyBpbnRlbmRlZCB0byBiZSB1c2VkIGFzIHRoZSBob3N0IGV4ZWN1dGVzIHRoZQorICogICAgICAgICAgICAgIF9QUlcgbWV0aG9kcyAoUG93ZXIgUmVzb3VyY2VzIGZvciBXYWtlKSBpbiB0aGUgc3lzdGVtIHRhYmxlcy4KKyAqICAgICAgICAgICAgICBFYWNoIF9QUlcgYXBwZWFycyB1bmRlciBhIERldmljZSBPYmplY3QgKFRoZSB3YWtlX2RldmljZSksIGFuZAorICogICAgICAgICAgICAgIGNvbnRhaW5zIHRoZSBpbmZvIGZvciB0aGUgd2FrZSBHUEUgYXNzb2NpYXRlZCB3aXRoIHRoZQorICogICAgICAgICAgICAgIHdha2VfZGV2aWNlLgorICoKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCithY3BpX3N0YXR1cworYWNwaV9zZXR1cF9ncGVfZm9yX3dha2UoYWNwaV9oYW5kbGUgd2FrZV9kZXZpY2UsCisJCQlhY3BpX2hhbmRsZSBncGVfZGV2aWNlLCB1MzIgZ3BlX251bWJlcikKK3sKKwlhY3BpX3N0YXR1cyBzdGF0dXMgPSBBRV9CQURfUEFSQU1FVEVSOworCXN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbzsKKwlzdHJ1Y3QgYWNwaV9uYW1lc3BhY2Vfbm9kZSAqZGV2aWNlX25vZGU7CisJYWNwaV9jcHVfZmxhZ3MgZmxhZ3M7CisKKwlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGFjcGlfc2V0dXBfZ3BlX2Zvcl93YWtlKTsKKworCS8qIFBhcmFtZXRlciBWYWxpZGF0aW9uICovCisKKwlpZiAoIXdha2VfZGV2aWNlKSB7CisJCS8qCisJCSAqIEJ5IGZvcmNpbmcgd2FrZV9kZXZpY2UgdG8gYmUgdmFsaWQsIHdlIGF1dG9tYXRpY2FsbHkgZW5hYmxlIHRoZQorCQkgKiBpbXBsaWNpdCBub3RpZnkgZmVhdHVyZSBvbiBhbGwgaG9zdHMuCisJCSAqLworCQlyZXR1cm5fQUNQSV9TVEFUVVMoQUVfQkFEX1BBUkFNRVRFUik7CisJfQorCisJLyogVmFsaWRhdGUgd2FrZV9kZXZpY2UgaXMgb2YgdHlwZSBEZXZpY2UgKi8KKworCWRldmljZV9ub2RlID0gQUNQSV9DQVNUX1BUUihzdHJ1Y3QgYWNwaV9uYW1lc3BhY2Vfbm9kZSwgd2FrZV9kZXZpY2UpOworCWlmIChkZXZpY2Vfbm9kZS0+dHlwZSAhPSBBQ1BJX1RZUEVfREVWSUNFKSB7CisJCXJldHVybl9BQ1BJX1NUQVRVUyhBRV9CQURfUEFSQU1FVEVSKTsKKwl9CisKKwlmbGFncyA9IGFjcGlfb3NfYWNxdWlyZV9sb2NrKGFjcGlfZ2JsX2dwZV9sb2NrKTsKKworCS8qIEVuc3VyZSB0aGF0IHdlIGhhdmUgYSB2YWxpZCBHUEUgbnVtYmVyICovCisKKwlncGVfZXZlbnRfaW5mbyA9IGFjcGlfZXZfZ2V0X2dwZV9ldmVudF9pbmZvKGdwZV9kZXZpY2UsIGdwZV9udW1iZXIpOworCWlmIChncGVfZXZlbnRfaW5mbykgeworCQkvKgorCQkgKiBJZiB0aGVyZSBpcyBubyBtZXRob2Qgb3IgaGFuZGxlciBmb3IgdGhpcyBHUEUsIHRoZW4gdGhlCisJCSAqIHdha2VfZGV2aWNlIHdpbGwgYmUgbm90aWZpZWQgd2hlbmV2ZXIgdGhpcyBHUEUgZmlyZXMgKGFrYQorCQkgKiAiaW1wbGljaXQgbm90aWZ5IikgTm90ZTogVGhlIEdQRSBpcyBhc3N1bWVkIHRvIGJlCisJCSAqIGxldmVsLXRyaWdnZXJlZCAoZm9yIHdpbmRvd3MgY29tcGF0aWJpbGl0eSkuCisJCSAqLworCQlpZiAoKGdwZV9ldmVudF9pbmZvLT5mbGFncyAmIEFDUElfR1BFX0RJU1BBVENIX01BU0spID09CisJCSAgICBBQ1BJX0dQRV9ESVNQQVRDSF9OT05FKSB7CisJCQlncGVfZXZlbnRfaW5mby0+ZmxhZ3MgPQorCQkJICAgIChBQ1BJX0dQRV9ESVNQQVRDSF9OT1RJRlkgfAorCQkJICAgICBBQ1BJX0dQRV9MRVZFTF9UUklHR0VSRUQpOworCQkJZ3BlX2V2ZW50X2luZm8tPmRpc3BhdGNoLmRldmljZV9ub2RlID0gZGV2aWNlX25vZGU7CisJCX0KKworCQlncGVfZXZlbnRfaW5mby0+ZmxhZ3MgfD0gQUNQSV9HUEVfQ0FOX1dBS0U7CisJCXN0YXR1cyA9IEFFX09LOworCX0KKworCWFjcGlfb3NfcmVsZWFzZV9sb2NrKGFjcGlfZ2JsX2dwZV9sb2NrLCBmbGFncyk7CisJcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Cit9CitBQ1BJX0VYUE9SVF9TWU1CT0woYWNwaV9zZXR1cF9ncGVfZm9yX3dha2UpCisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKgorICogRlVOQ1RJT046ICAgIGFjcGlfc2V0X2dwZV93YWtlX21hc2sKKyAqCisgKiBQQVJBTUVURVJTOiAgZ3BlX2RldmljZSAgICAgIC0gUGFyZW50IEdQRSBEZXZpY2UuIE5VTEwgZm9yIEdQRTAvR1BFMQorICogICAgICAgICAgICAgIGdwZV9udW1iZXIgICAgICAtIEdQRSBsZXZlbCB3aXRoaW4gdGhlIEdQRSBibG9jaworICogICAgICAgICAgICAgIEFjdGlvbiAgICAgICAgICAtIEVuYWJsZSBvciBEaXNhYmxlCisgKgorICogUkVUVVJOOiAgICAgIFN0YXR1cworICoKKyAqIERFU0NSSVBUSU9OOiBTZXQgb3IgY2xlYXIgdGhlIEdQRSdzIHdha2V1cCBlbmFibGUgbWFzayBiaXQuIFRoZSBHUEUgbXVzdAorICogICAgICAgICAgICAgIGFscmVhZHkgYmUgbWFya2VkIGFzIGEgV0FLRSBHUEUuCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworYWNwaV9zdGF0dXMgYWNwaV9zZXRfZ3BlX3dha2VfbWFzayhhY3BpX2hhbmRsZSBncGVfZGV2aWNlLCB1MzIgZ3BlX251bWJlciwgdTggYWN0aW9uKQoreworCWFjcGlfc3RhdHVzIHN0YXR1cyA9IEFFX09LOworCXN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbzsKKwlzdHJ1Y3QgYWNwaV9ncGVfcmVnaXN0ZXJfaW5mbyAqZ3BlX3JlZ2lzdGVyX2luZm87CisJYWNwaV9jcHVfZmxhZ3MgZmxhZ3M7CisJdTMyIHJlZ2lzdGVyX2JpdDsKKworCUFDUElfRlVOQ1RJT05fVFJBQ0UoYWNwaV9zZXRfZ3BlX3dha2VfbWFzayk7CisKKwlmbGFncyA9IGFjcGlfb3NfYWNxdWlyZV9sb2NrKGFjcGlfZ2JsX2dwZV9sb2NrKTsKKworCS8qCisJICogRW5zdXJlIHRoYXQgd2UgaGF2ZSBhIHZhbGlkIEdQRSBudW1iZXIgYW5kIHRoYXQgdGhpcyBHUEUgaXMgaW4KKwkgKiBmYWN0IGEgd2FrZSBHUEUKKwkgKi8KKwlncGVfZXZlbnRfaW5mbyA9IGFjcGlfZXZfZ2V0X2dwZV9ldmVudF9pbmZvKGdwZV9kZXZpY2UsIGdwZV9udW1iZXIpOworCWlmICghZ3BlX2V2ZW50X2luZm8pIHsKKwkJc3RhdHVzID0gQUVfQkFEX1BBUkFNRVRFUjsKKwkJZ290byB1bmxvY2tfYW5kX2V4aXQ7CisJfQorCisJaWYgKCEoZ3BlX2V2ZW50X2luZm8tPmZsYWdzICYgQUNQSV9HUEVfQ0FOX1dBS0UpKSB7CisJCXN0YXR1cyA9IEFFX1RZUEU7CisJCWdvdG8gdW5sb2NrX2FuZF9leGl0OworCX0KKworCWdwZV9yZWdpc3Rlcl9pbmZvID0gZ3BlX2V2ZW50X2luZm8tPnJlZ2lzdGVyX2luZm87CisJaWYgKCFncGVfcmVnaXN0ZXJfaW5mbykgeworCQlzdGF0dXMgPSBBRV9OT1RfRVhJU1Q7CisJCWdvdG8gdW5sb2NrX2FuZF9leGl0OworCX0KKworCXJlZ2lzdGVyX2JpdCA9CisJICAgIGFjcGlfaHdfZ2V0X2dwZV9yZWdpc3Rlcl9iaXQoZ3BlX2V2ZW50X2luZm8sIGdwZV9yZWdpc3Rlcl9pbmZvKTsKKworCS8qIFBlcmZvcm0gdGhlIGFjdGlvbiAqLworCisJc3dpdGNoIChhY3Rpb24pIHsKKwljYXNlIEFDUElfR1BFX0VOQUJMRToKKwkJQUNQSV9TRVRfQklUKGdwZV9yZWdpc3Rlcl9pbmZvLT5lbmFibGVfZm9yX3dha2UsCisJCQkgICAgICh1OClyZWdpc3Rlcl9iaXQpOworCQlicmVhazsKKworCWNhc2UgQUNQSV9HUEVfRElTQUJMRToKKwkJQUNQSV9DTEVBUl9CSVQoZ3BlX3JlZ2lzdGVyX2luZm8tPmVuYWJsZV9mb3Jfd2FrZSwKKwkJCSAgICAgICAodTgpcmVnaXN0ZXJfYml0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQlBQ1BJX0VSUk9SKChBRV9JTkZPLCAiJXUsIEludmFsaWQgYWN0aW9uIiwgYWN0aW9uKSk7CisJCXN0YXR1cyA9IEFFX0JBRF9QQVJBTUVURVI7CisJCWJyZWFrOworCX0KKwordW5sb2NrX2FuZF9leGl0OgorCWFjcGlfb3NfcmVsZWFzZV9sb2NrKGFjcGlfZ2JsX2dwZV9sb2NrLCBmbGFncyk7CisJcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Cit9CisKK0FDUElfRVhQT1JUX1NZTUJPTChhY3BpX3NldF9ncGVfd2FrZV9tYXNrKQorCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICoKKyAqIEZVTkNUSU9OOiAgICBhY3BpX2NsZWFyX2dwZQorICoKKyAqIFBBUkFNRVRFUlM6ICBncGVfZGV2aWNlICAgICAgLSBQYXJlbnQgR1BFIERldmljZS4gTlVMTCBmb3IgR1BFMC9HUEUxCisgKiAgICAgICAgICAgICAgZ3BlX251bWJlciAgICAgIC0gR1BFIGxldmVsIHdpdGhpbiB0aGUgR1BFIGJsb2NrCisgKgorICogUkVUVVJOOiAgICAgIFN0YXR1cworICoKKyAqIERFU0NSSVBUSU9OOiBDbGVhciBhbiBBQ1BJIGV2ZW50IChnZW5lcmFsIHB1cnBvc2UpCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KK2FjcGlfc3RhdHVzIGFjcGlfY2xlYXJfZ3BlKGFjcGlfaGFuZGxlIGdwZV9kZXZpY2UsIHUzMiBncGVfbnVtYmVyKQoreworCWFjcGlfc3RhdHVzIHN0YXR1cyA9IEFFX09LOworCXN0cnVjdCBhY3BpX2dwZV9ldmVudF9pbmZvICpncGVfZXZlbnRfaW5mbzsKKwlhY3BpX2NwdV9mbGFncyBmbGFnczsKKworCUFDUElfRlVOQ1RJT05fVFJBQ0UoYWNwaV9jbGVhcl9ncGUpOworCisJZmxhZ3MgPSBhY3BpX29zX2FjcXVpcmVfbG9jayhhY3BpX2dibF9ncGVfbG9jayk7CisKKwkvKiBFbnN1cmUgdGhhdCB3ZSBoYXZlIGEgdmFsaWQgR1BFIG51bWJlciAqLworCisJZ3BlX2V2ZW50X2luZm8gPSBhY3BpX2V2X2dldF9ncGVfZXZlbnRfaW5mbyhncGVfZGV2aWNlLCBncGVfbnVtYmVyKTsKKwlpZiAoIWdwZV9ldmVudF9pbmZvKSB7CisJCXN0YXR1cyA9IEFFX0JBRF9QQVJBTUVURVI7CisJCWdvdG8gdW5sb2NrX2FuZF9leGl0OworCX0KKworCXN0YXR1cyA9IGFjcGlfaHdfY2xlYXJfZ3BlKGdwZV9ldmVudF9pbmZvKTsKKworICAgICAgdW5sb2NrX2FuZF9leGl0OgorCWFjcGlfb3NfcmVsZWFzZV9sb2NrKGFjcGlfZ2JsX2dwZV9sb2NrLCBmbGFncyk7CisJcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Cit9CisKK0FDUElfRVhQT1JUX1NZTUJPTChhY3BpX2NsZWFyX2dwZSkKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqCisgKiBGVU5DVElPTjogICAgYWNwaV9nZXRfZ3BlX3N0YXR1cworICoKKyAqIFBBUkFNRVRFUlM6ICBncGVfZGV2aWNlICAgICAgLSBQYXJlbnQgR1BFIERldmljZS4gTlVMTCBmb3IgR1BFMC9HUEUxCisgKiAgICAgICAgICAgICAgZ3BlX251bWJlciAgICAgIC0gR1BFIGxldmVsIHdpdGhpbiB0aGUgR1BFIGJsb2NrCisgKiAgICAgICAgICAgICAgZXZlbnRfc3RhdHVzICAgIC0gV2hlcmUgdGhlIGN1cnJlbnQgc3RhdHVzIG9mIHRoZSBldmVudCB3aWxsCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYmUgcmV0dXJuZWQKKyAqCisgKiBSRVRVUk46ICAgICAgU3RhdHVzCisgKgorICogREVTQ1JJUFRJT046IEdldCB0aGUgY3VycmVudCBzdGF0dXMgb2YgYSBHUEUgKHNpZ25hbGxlZC9ub3Rfc2lnbmFsbGVkKQorICoKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCithY3BpX3N0YXR1cworYWNwaV9nZXRfZ3BlX3N0YXR1cyhhY3BpX2hhbmRsZSBncGVfZGV2aWNlLAorCQkgICAgdTMyIGdwZV9udW1iZXIsIGFjcGlfZXZlbnRfc3RhdHVzICpldmVudF9zdGF0dXMpCit7CisJYWNwaV9zdGF0dXMgc3RhdHVzID0gQUVfT0s7CisJc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvOworCWFjcGlfY3B1X2ZsYWdzIGZsYWdzOworCisJQUNQSV9GVU5DVElPTl9UUkFDRShhY3BpX2dldF9ncGVfc3RhdHVzKTsKKworCWZsYWdzID0gYWNwaV9vc19hY3F1aXJlX2xvY2soYWNwaV9nYmxfZ3BlX2xvY2spOworCisJLyogRW5zdXJlIHRoYXQgd2UgaGF2ZSBhIHZhbGlkIEdQRSBudW1iZXIgKi8KKworCWdwZV9ldmVudF9pbmZvID0gYWNwaV9ldl9nZXRfZ3BlX2V2ZW50X2luZm8oZ3BlX2RldmljZSwgZ3BlX251bWJlcik7CisJaWYgKCFncGVfZXZlbnRfaW5mbykgeworCQlzdGF0dXMgPSBBRV9CQURfUEFSQU1FVEVSOworCQlnb3RvIHVubG9ja19hbmRfZXhpdDsKKwl9CisKKwkvKiBPYnRhaW4gc3RhdHVzIG9uIHRoZSByZXF1ZXN0ZWQgR1BFIG51bWJlciAqLworCisJc3RhdHVzID0gYWNwaV9od19nZXRfZ3BlX3N0YXR1cyhncGVfZXZlbnRfaW5mbywgZXZlbnRfc3RhdHVzKTsKKworCWlmIChncGVfZXZlbnRfaW5mby0+ZmxhZ3MgJiBBQ1BJX0dQRV9ESVNQQVRDSF9NQVNLKQorCQkqZXZlbnRfc3RhdHVzIHw9IEFDUElfRVZFTlRfRkxBR19IQU5ETEU7CisKKyAgICAgIHVubG9ja19hbmRfZXhpdDoKKwlhY3BpX29zX3JlbGVhc2VfbG9jayhhY3BpX2dibF9ncGVfbG9jaywgZmxhZ3MpOworCXJldHVybl9BQ1BJX1NUQVRVUyhzdGF0dXMpOworfQorCitBQ1BJX0VYUE9SVF9TWU1CT0woYWNwaV9nZXRfZ3BlX3N0YXR1cykKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICoKKyAqIEZVTkNUSU9OOiAgICBhY3BpX2Rpc2FibGVfYWxsX2dwZXMKKyAqCisgKiBQQVJBTUVURVJTOiAgTm9uZQorICoKKyAqIFJFVFVSTjogICAgICBTdGF0dXMKKyAqCisgKiBERVNDUklQVElPTjogRGlzYWJsZSBhbmQgY2xlYXIgYWxsIEdQRXMgaW4gYWxsIEdQRSBibG9ja3MKKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCithY3BpX3N0YXR1cyBhY3BpX2Rpc2FibGVfYWxsX2dwZXModm9pZCkKK3sKKwlhY3BpX3N0YXR1cyBzdGF0dXM7CisKKwlBQ1BJX0ZVTkNUSU9OX1RSQUNFKGFjcGlfZGlzYWJsZV9hbGxfZ3Blcyk7CisKKwlzdGF0dXMgPSBhY3BpX3V0X2FjcXVpcmVfbXV0ZXgoQUNQSV9NVFhfRVZFTlRTKTsKKwlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKKwkJcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7CisJfQorCisJc3RhdHVzID0gYWNwaV9od19kaXNhYmxlX2FsbF9ncGVzKCk7CisJKHZvaWQpYWNwaV91dF9yZWxlYXNlX211dGV4KEFDUElfTVRYX0VWRU5UUyk7CisKKwlyZXR1cm5fQUNQSV9TVEFUVVMoc3RhdHVzKTsKK30KKworQUNQSV9FWFBPUlRfU1lNQk9MKGFjcGlfZGlzYWJsZV9hbGxfZ3BlcykKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICoKKyAqIEZVTkNUSU9OOiAgICBhY3BpX2VuYWJsZV9hbGxfcnVudGltZV9ncGVzCisgKgorICogUEFSQU1FVEVSUzogIE5vbmUKKyAqCisgKiBSRVRVUk46ICAgICAgU3RhdHVzCisgKgorICogREVTQ1JJUFRJT046IEVuYWJsZSBhbGwgInJ1bnRpbWUiIEdQRXMsIGluIGFsbCBHUEUgYmxvY2tzCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworYWNwaV9zdGF0dXMgYWNwaV9lbmFibGVfYWxsX3J1bnRpbWVfZ3Blcyh2b2lkKQoreworCWFjcGlfc3RhdHVzIHN0YXR1czsKKworCUFDUElfRlVOQ1RJT05fVFJBQ0UoYWNwaV9lbmFibGVfYWxsX3J1bnRpbWVfZ3Blcyk7CisKKwlzdGF0dXMgPSBhY3BpX3V0X2FjcXVpcmVfbXV0ZXgoQUNQSV9NVFhfRVZFTlRTKTsKKwlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKKwkJcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7CisJfQorCisJc3RhdHVzID0gYWNwaV9od19lbmFibGVfYWxsX3J1bnRpbWVfZ3BlcygpOworCSh2b2lkKWFjcGlfdXRfcmVsZWFzZV9tdXRleChBQ1BJX01UWF9FVkVOVFMpOworCisJcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7Cit9CisKK0FDUElfRVhQT1JUX1NZTUJPTChhY3BpX2VuYWJsZV9hbGxfcnVudGltZV9ncGVzKQorCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICoKKyAqIEZVTkNUSU9OOiAgICBhY3BpX2luc3RhbGxfZ3BlX2Jsb2NrCisgKgorICogUEFSQU1FVEVSUzogIGdwZV9kZXZpY2UgICAgICAgICAgLSBIYW5kbGUgdG8gdGhlIHBhcmVudCBHUEUgQmxvY2sgRGV2aWNlCisgKiAgICAgICAgICAgICAgZ3BlX2Jsb2NrX2FkZHJlc3MgICAtIEFkZHJlc3MgYW5kIHNwYWNlX2lECisgKiAgICAgICAgICAgICAgcmVnaXN0ZXJfY291bnQgICAgICAtIE51bWJlciBvZiBHUEUgcmVnaXN0ZXIgcGFpcnMgaW4gdGhlIGJsb2NrCisgKiAgICAgICAgICAgICAgaW50ZXJydXB0X251bWJlciAgICAtIEgvVyBpbnRlcnJ1cHQgZm9yIHRoZSBibG9jaworICoKKyAqIFJFVFVSTjogICAgICBTdGF0dXMKKyAqCisgKiBERVNDUklQVElPTjogQ3JlYXRlIGFuZCBJbnN0YWxsIGEgYmxvY2sgb2YgR1BFIHJlZ2lzdGVycy4gVGhlIEdQRXMgYXJlIG5vdAorICogICAgICAgICAgICAgIGVuYWJsZWQgaGVyZS4KKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworYWNwaV9zdGF0dXMKK2FjcGlfaW5zdGFsbF9ncGVfYmxvY2soYWNwaV9oYW5kbGUgZ3BlX2RldmljZSwKKwkJICAgICAgIHN0cnVjdCBhY3BpX2dlbmVyaWNfYWRkcmVzcyAqZ3BlX2Jsb2NrX2FkZHJlc3MsCisJCSAgICAgICB1MzIgcmVnaXN0ZXJfY291bnQsIHUzMiBpbnRlcnJ1cHRfbnVtYmVyKQoreworCWFjcGlfc3RhdHVzIHN0YXR1czsKKwl1bmlvbiBhY3BpX29wZXJhbmRfb2JqZWN0ICpvYmpfZGVzYzsKKwlzdHJ1Y3QgYWNwaV9uYW1lc3BhY2Vfbm9kZSAqbm9kZTsKKwlzdHJ1Y3QgYWNwaV9ncGVfYmxvY2tfaW5mbyAqZ3BlX2Jsb2NrOworCisJQUNQSV9GVU5DVElPTl9UUkFDRShhY3BpX2luc3RhbGxfZ3BlX2Jsb2NrKTsKKworCWlmICgoIWdwZV9kZXZpY2UpIHx8ICghZ3BlX2Jsb2NrX2FkZHJlc3MpIHx8ICghcmVnaXN0ZXJfY291bnQpKSB7CisJCXJldHVybl9BQ1BJX1NUQVRVUyhBRV9CQURfUEFSQU1FVEVSKTsKKwl9CisKKwlzdGF0dXMgPSBhY3BpX3V0X2FjcXVpcmVfbXV0ZXgoQUNQSV9NVFhfTkFNRVNQQUNFKTsKKwlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKKwkJcmV0dXJuIChzdGF0dXMpOworCX0KKworCW5vZGUgPSBhY3BpX25zX3ZhbGlkYXRlX2hhbmRsZShncGVfZGV2aWNlKTsKKwlpZiAoIW5vZGUpIHsKKwkJc3RhdHVzID0gQUVfQkFEX1BBUkFNRVRFUjsKKwkJZ290byB1bmxvY2tfYW5kX2V4aXQ7CisJfQorCisJLyoKKwkgKiBGb3IgdXNlci1pbnN0YWxsZWQgR1BFIEJsb2NrIERldmljZXMsIHRoZSBncGVfYmxvY2tfYmFzZV9udW1iZXIKKwkgKiBpcyBhbHdheXMgemVybworCSAqLworCXN0YXR1cyA9CisJICAgIGFjcGlfZXZfY3JlYXRlX2dwZV9ibG9jayhub2RlLCBncGVfYmxvY2tfYWRkcmVzcywgcmVnaXN0ZXJfY291bnQsIDAsCisJCQkJICAgICBpbnRlcnJ1cHRfbnVtYmVyLCAmZ3BlX2Jsb2NrKTsKKwlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKKwkJZ290byB1bmxvY2tfYW5kX2V4aXQ7CisJfQorCisJLyogSW5zdGFsbCBibG9jayBpbiB0aGUgZGV2aWNlX29iamVjdCBhdHRhY2hlZCB0byB0aGUgbm9kZSAqLworCisJb2JqX2Rlc2MgPSBhY3BpX25zX2dldF9hdHRhY2hlZF9vYmplY3Qobm9kZSk7CisJaWYgKCFvYmpfZGVzYykgeworCisJCS8qCisJCSAqIE5vIG9iamVjdCwgY3JlYXRlIGEgbmV3IG9uZSAoRGV2aWNlIG5vZGVzIGRvIG5vdCBhbHdheXMgaGF2ZQorCQkgKiBhbiBhdHRhY2hlZCBvYmplY3QpCisJCSAqLworCQlvYmpfZGVzYyA9IGFjcGlfdXRfY3JlYXRlX2ludGVybmFsX29iamVjdChBQ1BJX1RZUEVfREVWSUNFKTsKKwkJaWYgKCFvYmpfZGVzYykgeworCQkJc3RhdHVzID0gQUVfTk9fTUVNT1JZOworCQkJZ290byB1bmxvY2tfYW5kX2V4aXQ7CisJCX0KKworCQlzdGF0dXMgPQorCQkgICAgYWNwaV9uc19hdHRhY2hfb2JqZWN0KG5vZGUsIG9ial9kZXNjLCBBQ1BJX1RZUEVfREVWSUNFKTsKKworCQkvKiBSZW1vdmUgbG9jYWwgcmVmZXJlbmNlIHRvIHRoZSBvYmplY3QgKi8KKworCQlhY3BpX3V0X3JlbW92ZV9yZWZlcmVuY2Uob2JqX2Rlc2MpOworCisJCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgeworCQkJZ290byB1bmxvY2tfYW5kX2V4aXQ7CisJCX0KKwl9CisKKwkvKiBOb3cgaW5zdGFsbCB0aGUgR1BFIGJsb2NrIGluIHRoZSBkZXZpY2Vfb2JqZWN0ICovCisKKwlvYmpfZGVzYy0+ZGV2aWNlLmdwZV9ibG9jayA9IGdwZV9ibG9jazsKKworICAgICAgdW5sb2NrX2FuZF9leGl0OgorCSh2b2lkKWFjcGlfdXRfcmVsZWFzZV9tdXRleChBQ1BJX01UWF9OQU1FU1BBQ0UpOworCXJldHVybl9BQ1BJX1NUQVRVUyhzdGF0dXMpOworfQorCitBQ1BJX0VYUE9SVF9TWU1CT0woYWNwaV9pbnN0YWxsX2dwZV9ibG9jaykKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqCisgKiBGVU5DVElPTjogICAgYWNwaV9yZW1vdmVfZ3BlX2Jsb2NrCisgKgorICogUEFSQU1FVEVSUzogIGdwZV9kZXZpY2UgICAgICAgICAgLSBIYW5kbGUgdG8gdGhlIHBhcmVudCBHUEUgQmxvY2sgRGV2aWNlCisgKgorICogUkVUVVJOOiAgICAgIFN0YXR1cworICoKKyAqIERFU0NSSVBUSU9OOiBSZW1vdmUgYSBwcmV2aW91c2x5IGluc3RhbGxlZCBibG9jayBvZiBHUEUgcmVnaXN0ZXJzCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KK2FjcGlfc3RhdHVzIGFjcGlfcmVtb3ZlX2dwZV9ibG9jayhhY3BpX2hhbmRsZSBncGVfZGV2aWNlKQoreworCXVuaW9uIGFjcGlfb3BlcmFuZF9vYmplY3QgKm9ial9kZXNjOworCWFjcGlfc3RhdHVzIHN0YXR1czsKKwlzdHJ1Y3QgYWNwaV9uYW1lc3BhY2Vfbm9kZSAqbm9kZTsKKworCUFDUElfRlVOQ1RJT05fVFJBQ0UoYWNwaV9yZW1vdmVfZ3BlX2Jsb2NrKTsKKworCWlmICghZ3BlX2RldmljZSkgeworCQlyZXR1cm5fQUNQSV9TVEFUVVMoQUVfQkFEX1BBUkFNRVRFUik7CisJfQorCisJc3RhdHVzID0gYWNwaV91dF9hY3F1aXJlX211dGV4KEFDUElfTVRYX05BTUVTUEFDRSk7CisJaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKSB7CisJCXJldHVybiAoc3RhdHVzKTsKKwl9CisKKwlub2RlID0gYWNwaV9uc192YWxpZGF0ZV9oYW5kbGUoZ3BlX2RldmljZSk7CisJaWYgKCFub2RlKSB7CisJCXN0YXR1cyA9IEFFX0JBRF9QQVJBTUVURVI7CisJCWdvdG8gdW5sb2NrX2FuZF9leGl0OworCX0KKworCS8qIEdldCB0aGUgZGV2aWNlX29iamVjdCBhdHRhY2hlZCB0byB0aGUgbm9kZSAqLworCisJb2JqX2Rlc2MgPSBhY3BpX25zX2dldF9hdHRhY2hlZF9vYmplY3Qobm9kZSk7CisJaWYgKCFvYmpfZGVzYyB8fCAhb2JqX2Rlc2MtPmRldmljZS5ncGVfYmxvY2spIHsKKwkJcmV0dXJuX0FDUElfU1RBVFVTKEFFX05VTExfT0JKRUNUKTsKKwl9CisKKwkvKiBEZWxldGUgdGhlIEdQRSBibG9jayAoYnV0IG5vdCB0aGUgZGV2aWNlX29iamVjdCkgKi8KKworCXN0YXR1cyA9IGFjcGlfZXZfZGVsZXRlX2dwZV9ibG9jayhvYmpfZGVzYy0+ZGV2aWNlLmdwZV9ibG9jayk7CisJaWYgKEFDUElfU1VDQ0VTUyhzdGF0dXMpKSB7CisJCW9ial9kZXNjLT5kZXZpY2UuZ3BlX2Jsb2NrID0gTlVMTDsKKwl9CisKKyAgICAgIHVubG9ja19hbmRfZXhpdDoKKwkodm9pZClhY3BpX3V0X3JlbGVhc2VfbXV0ZXgoQUNQSV9NVFhfTkFNRVNQQUNFKTsKKwlyZXR1cm5fQUNQSV9TVEFUVVMoc3RhdHVzKTsKK30KKworQUNQSV9FWFBPUlRfU1lNQk9MKGFjcGlfcmVtb3ZlX2dwZV9ibG9jaykKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqCisgKiBGVU5DVElPTjogICAgYWNwaV9nZXRfZ3BlX2RldmljZQorICoKKyAqIFBBUkFNRVRFUlM6ICBJbmRleCAgICAgICAgICAgICAgIC0gU3lzdGVtIEdQRSBpbmRleCAoMC1jdXJyZW50X2dwZV9jb3VudCkKKyAqICAgICAgICAgICAgICBncGVfZGV2aWNlICAgICAgICAgIC0gV2hlcmUgdGhlIHBhcmVudCBHUEUgRGV2aWNlIGlzIHJldHVybmVkCisgKgorICogUkVUVVJOOiAgICAgIFN0YXR1cworICoKKyAqIERFU0NSSVBUSU9OOiBPYnRhaW4gdGhlIEdQRSBkZXZpY2UgYXNzb2NpYXRlZCB3aXRoIHRoZSBpbnB1dCBpbmRleC4gQSBOVUxMCisgKiAgICAgICAgICAgICAgZ3BlIGRldmljZSBpbmRpY2F0ZXMgdGhhdCB0aGUgZ3BlIG51bWJlciBpcyBjb250YWluZWQgaW4gb25lIG9mCisgKiAgICAgICAgICAgICAgdGhlIEZBRFQtZGVmaW5lZCBncGUgYmxvY2tzLiBPdGhlcndpc2UsIHRoZSBHUEUgYmxvY2sgZGV2aWNlLgorICoKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCithY3BpX3N0YXR1cworYWNwaV9nZXRfZ3BlX2RldmljZSh1MzIgaW5kZXgsIGFjcGlfaGFuZGxlICpncGVfZGV2aWNlKQoreworCXN0cnVjdCBhY3BpX2dwZV9kZXZpY2VfaW5mbyBpbmZvOworCWFjcGlfc3RhdHVzIHN0YXR1czsKKworCUFDUElfRlVOQ1RJT05fVFJBQ0UoYWNwaV9nZXRfZ3BlX2RldmljZSk7CisKKwlpZiAoIWdwZV9kZXZpY2UpIHsKKwkJcmV0dXJuX0FDUElfU1RBVFVTKEFFX0JBRF9QQVJBTUVURVIpOworCX0KKworCWlmIChpbmRleCA+PSBhY3BpX2N1cnJlbnRfZ3BlX2NvdW50KSB7CisJCXJldHVybl9BQ1BJX1NUQVRVUyhBRV9OT1RfRVhJU1QpOworCX0KKworCS8qIFNldHVwIGFuZCB3YWxrIHRoZSBHUEUgbGlzdCAqLworCisJaW5mby5pbmRleCA9IGluZGV4OworCWluZm8uc3RhdHVzID0gQUVfTk9UX0VYSVNUOworCWluZm8uZ3BlX2RldmljZSA9IE5VTEw7CisJaW5mby5uZXh0X2Jsb2NrX2Jhc2VfaW5kZXggPSAwOworCisJc3RhdHVzID0gYWNwaV9ldl93YWxrX2dwZV9saXN0KGFjcGlfZXZfZ2V0X2dwZV9kZXZpY2UsICZpbmZvKTsKKwlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKKwkJcmV0dXJuX0FDUElfU1RBVFVTKHN0YXR1cyk7CisJfQorCisJKmdwZV9kZXZpY2UgPSBBQ1BJX0NBU1RfUFRSKGFjcGlfaGFuZGxlLCBpbmZvLmdwZV9kZXZpY2UpOworCXJldHVybl9BQ1BJX1NUQVRVUyhpbmZvLnN0YXR1cyk7Cit9CisKK0FDUElfRVhQT1JUX1NZTUJPTChhY3BpX2dldF9ncGVfZGV2aWNlKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9ldnhmcmVnbi5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9ldnhmcmVnbi5jCmluZGV4IGNlOTMxNGYuLmViNzM4NjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXZ4ZnJlZ24uYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V2eGZyZWduLmMKQEAgLTYsNyArNiw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4Y29uZmlnLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4Y29uZmlnLmMKaW5kZXggMTg4MzIyMC4uNzQ1YTQyYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leGNvbmZpZy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhjb25maWcuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhjb252cnQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhjb252cnQuYwppbmRleCBiNzNiYzUwLi43NDE2MmExIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4Y29udnJ0LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leGNvbnZydC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leGNyZWF0ZS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leGNyZWF0ZS5jCmluZGV4IDNjNjFiNDguLmU3YjM3MmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhjcmVhdGUuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4Y3JlYXRlLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC00ODIsMTMgKzQ4MiwxMSBAQAogCW9ial9kZXNjLT5tZXRob2QuYW1sX2xlbmd0aCA9IGFtbF9sZW5ndGg7CiAKIAkvKgotCSAqIERpc2Fzc2VtYmxlIHRoZSBtZXRob2QgZmxhZ3MuIFNwbGl0IG9mZiB0aGUgQXJnIENvdW50Ci0JICogZm9yIGVmZmljaWVuY3kKKwkgKiBEaXNhc3NlbWJsZSB0aGUgbWV0aG9kIGZsYWdzLiBTcGxpdCBvZmYgdGhlIGFyZ19jb3VudCwgU2VyaWFsaXplZAorCSAqIGZsYWcsIGFuZCBzeW5jX2xldmVsIGZvciBlZmZpY2llbmN5LgogCSAqLwogCW1ldGhvZF9mbGFncyA9ICh1OCkgb3BlcmFuZFsxXS0+aW50ZWdlci52YWx1ZTsKIAotCW9ial9kZXNjLT5tZXRob2QubWV0aG9kX2ZsYWdzID0KLQkgICAgKHU4KSAobWV0aG9kX2ZsYWdzICYgfkFNTF9NRVRIT0RfQVJHX0NPVU5UKTsKIAlvYmpfZGVzYy0+bWV0aG9kLnBhcmFtX2NvdW50ID0KIAkgICAgKHU4KSAobWV0aG9kX2ZsYWdzICYgQU1MX01FVEhPRF9BUkdfQ09VTlQpOwogCkBAIC00OTcsNiArNDk1LDggQEAKIAkgKiBjcmVhdGVkIGZvciB0aGlzIG1ldGhvZCB3aGVuIGl0IGlzIHBhcnNlZC4KIAkgKi8KIAlpZiAobWV0aG9kX2ZsYWdzICYgQU1MX01FVEhPRF9TRVJJQUxJWkVEKSB7CisJCW9ial9kZXNjLT5tZXRob2QuaW5mb19mbGFncyA9IEFDUElfTUVUSE9EX1NFUklBTElaRUQ7CisKIAkJLyoKIAkJICogQUNQSSAxLjA6IHN5bmNfbGV2ZWwgPSAwCiAJCSAqIEFDUEkgMi4wOiBzeW5jX2xldmVsID0gc3luY19sZXZlbCBpbiBtZXRob2QgZGVjbGFyYXRpb24KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhkZWJ1Zy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leGRlYnVnLmMKaW5kZXggYmU4Yzk4Yi4uYzdhMmYxZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leGRlYnVnLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leGRlYnVnLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4ZHVtcC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leGR1bXAuYwppbmRleCBmMDY3YmJiLi42MWI4YzBlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4ZHVtcC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhkdW1wLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC0xMjIsNyArMTIyLDcgQEAKIAogc3RhdGljIHN0cnVjdCBhY3BpX2V4ZHVtcF9pbmZvIGFjcGlfZXhfZHVtcF9tZXRob2RbOV0gPSB7CiAJe0FDUElfRVhEX0lOSVQsIEFDUElfRVhEX1RBQkxFX1NJWkUoYWNwaV9leF9kdW1wX21ldGhvZCksIE5VTEx9LAotCXtBQ1BJX0VYRF9VSU5UOCwgQUNQSV9FWERfT0ZGU0VUKG1ldGhvZC5tZXRob2RfZmxhZ3MpLCAiTWV0aG9kIEZsYWdzIn0sCisJe0FDUElfRVhEX1VJTlQ4LCBBQ1BJX0VYRF9PRkZTRVQobWV0aG9kLmluZm9fZmxhZ3MpLCAiSW5mbyBGbGFncyJ9LAogCXtBQ1BJX0VYRF9VSU5UOCwgQUNQSV9FWERfT0ZGU0VUKG1ldGhvZC5wYXJhbV9jb3VudCksCiAJICJQYXJhbWV0ZXIgQ291bnQifSwKIAl7QUNQSV9FWERfVUlOVDgsIEFDUElfRVhEX09GRlNFVChtZXRob2Quc3luY19sZXZlbCksICJTeW5jIExldmVsIn0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4ZmllbGQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhmaWVsZC5jCmluZGV4IGYxN2QyZmYuLjBiZGUyMjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhmaWVsZC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhmaWVsZC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leGZsZGlvLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4ZmxkaW8uYwppbmRleCAzODI5M2ZkLi42Yzc5YzI5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4ZmxkaW8uYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4ZmxkaW8uYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhtaXNjLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4bWlzYy5jCmluZGV4IDk1ZGI0YmUwLi43MDNkODhlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4bWlzYy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhtaXNjLmMKQEAgLTYsNyArNiw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4bXV0ZXguYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhtdXRleC5jCmluZGV4IDZhZjE0ZTQuLmJlMWM1NmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhtdXRleC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhtdXRleC5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leG5hbWVzLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4bmFtZXMuYwppbmRleCBkMTFlNTM5Li40OWVjMDQ5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4bmFtZXMuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4bmFtZXMuYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhvcGFyZzEuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhvcGFyZzEuYwppbmRleCA4NGU0ZDE4Li4yMzZlYWQxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4b3BhcmcxLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leG9wYXJnMS5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leG9wYXJnMi5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leG9wYXJnMi5jCmluZGV4IDEwZTEwNGMuLjI1NzFiNGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhvcGFyZzIuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4b3BhcmcyLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4b3BhcmczLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4b3BhcmczLmMKaW5kZXggN2EwOGQyMy4uMWI0OGQ5ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leG9wYXJnMy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhvcGFyZzMuYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhvcGFyZzYuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhvcGFyZzYuYwppbmRleCA0YjUwNzMwLi5mNGEyNzg3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4b3Bhcmc2LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leG9wYXJnNi5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHByZXAuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhwcmVwLmMKaW5kZXggN2FhZTI5Zi4uY2M5NWUyMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHByZXAuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4cHJlcC5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHJlZ2lvbi5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leHJlZ2lvbi5jCmluZGV4IGRlMTdlMTAuLmYwZDVlMTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhyZWdpb24uYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4cmVnaW9uLmMKQEAgLTYsNyArNiw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4cmVzbnRlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4cmVzbnRlLmMKaW5kZXggMWZhNDI4OS4uNTU5OTdlNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHJlc250ZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhyZXNudGUuYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhyZXNvbHYuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhyZXNvbHYuYwppbmRleCA3Y2EzNWVhLi5kYjUwMmNkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4cmVzb2x2LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leHJlc29sdi5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHJlc29wLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4cmVzb3AuYwppbmRleCA4Yzk3Y2ZkLi5lM2JiMDBjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4cmVzb3AuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4cmVzb3AuYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhzdG9yZS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leHN0b3JlLmMKaW5kZXggMTYyNDQzNi4uYzBjODg0MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHN0b3JlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leHN0b3JlLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4c3RvcmVuLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4c3RvcmVuLmMKaW5kZXggZDRhZjY4NC4uYTk3OTAxNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHN0b3Jlbi5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhzdG9yZW4uYwpAQCAtNyw3ICs3LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhzdG9yb2IuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhzdG9yb2IuYwppbmRleCBlOTcyYjY2Li5kYzY2NWNjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4c3Rvcm9iLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leHN0b3JvYi5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9leHN5c3RlbS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9leHN5c3RlbS5jCmluZGV4IDY3NWFhYTkuLmRmNjZlN2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXhzeXN0ZW0uYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4c3lzdGVtLmMKQEAgLTYsNyArNiw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2V4dXRpbHMuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXh1dGlscy5jCmluZGV4IDQwOTM1MjIuLjhhZDkzMTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXh1dGlscy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvZXh1dGlscy5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9od2FjcGkuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHdhY3BpLmMKaW5kZXggYjQ0Mjc0YS4uZmMzODBkMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9od2FjcGkuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3YWNwaS5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9od2dwZS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9od2dwZS5jCmluZGV4IDE0NzUwZGIuLmY2MTBkODggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHdncGUuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3Z3BlLmMKQEAgLTYsNyArNiw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC02MiwxMCArNjIsMTAgQEAKICAqIFBBUkFNRVRFUlM6CWdwZV9ldmVudF9pbmZvCSAgICAtIEluZm8gYmxvY2sgZm9yIHRoZSBHUEUKICAqCQlncGVfcmVnaXN0ZXJfaW5mbyAgIC0gSW5mbyBibG9jayBmb3IgdGhlIEdQRSByZWdpc3RlcgogICoKLSAqIFJFVFVSTjoJU3RhdHVzCisgKiBSRVRVUk46CVJlZ2lzdGVyIG1hc2sgd2l0aCBhIG9uZSBpbiB0aGUgR1BFIGJpdCBwb3NpdGlvbgogICoKLSAqIERFU0NSSVBUSU9OOglDb21wdXRlIEdQRSBlbmFibGUgbWFzayB3aXRoIG9uZSBiaXQgY29ycmVzcG9uZGluZyB0byB0aGUgZ2l2ZW4KLSAqCQlHUEUgc2V0LgorICogREVTQ1JJUFRJT046IENvbXB1dGUgdGhlIHJlZ2lzdGVyIG1hc2sgZm9yIHRoaXMgR1BFLiBPbmUgYml0IGlzIHNldCBpbiB0aGUKKyAqICAgICAgICAgICAgICBjb3JyZWN0IHBvc2l0aW9uIGZvciB0aGUgaW5wdXQgR1BFLgogICoKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKQEAgLTg1LDEyICs4NSwxMiBAQAogICoKICAqIFJFVFVSTjoJU3RhdHVzCiAgKgotICogREVTQ1JJUFRJT046IEVuYWJsZSBvciBkaXNhYmxlIGEgc2luZ2xlIEdQRSBpbiBpdHMgZW5hYmxlIHJlZ2lzdGVyLgorICogREVTQ1JJUFRJT046IEVuYWJsZSBvciBkaXNhYmxlIGEgc2luZ2xlIEdQRSBpbiB0aGUgcGFyZW50IGVuYWJsZSByZWdpc3Rlci4KICAqCiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiBhY3BpX3N0YXR1cwotYWNwaV9od19sb3dfc2V0X2dwZShzdHJ1Y3QgYWNwaV9ncGVfZXZlbnRfaW5mbyAqZ3BlX2V2ZW50X2luZm8sIHU4IGFjdGlvbikKK2FjcGlfaHdfbG93X3NldF9ncGUoc3RydWN0IGFjcGlfZ3BlX2V2ZW50X2luZm8gKmdwZV9ldmVudF9pbmZvLCB1MzIgYWN0aW9uKQogewogCXN0cnVjdCBhY3BpX2dwZV9yZWdpc3Rlcl9pbmZvICpncGVfcmVnaXN0ZXJfaW5mbzsKIAlhY3BpX3N0YXR1cyBzdGF0dXM7CkBAIC0xMTMsMTQgKzExMywyMCBAQAogCQlyZXR1cm4gKHN0YXR1cyk7CiAJfQogCi0JLyogU2V0IG90IGNsZWFyIGp1c3QgdGhlIGJpdCB0aGF0IGNvcnJlc3BvbmRzIHRvIHRoaXMgR1BFICovCisJLyogU2V0IG9yIGNsZWFyIGp1c3QgdGhlIGJpdCB0aGF0IGNvcnJlc3BvbmRzIHRvIHRoaXMgR1BFICovCiAKIAlyZWdpc3Rlcl9iaXQgPSBhY3BpX2h3X2dldF9ncGVfcmVnaXN0ZXJfYml0KGdwZV9ldmVudF9pbmZvLAogCQkJCQkJZ3BlX3JlZ2lzdGVyX2luZm8pOwogCXN3aXRjaCAoYWN0aW9uKSB7Ci0JY2FzZSBBQ1BJX0dQRV9DT05EX0VOQUJMRToKLQkJaWYgKCEocmVnaXN0ZXJfYml0ICYgZ3BlX3JlZ2lzdGVyX2luZm8tPmVuYWJsZV9mb3JfcnVuKSkKKwljYXNlIEFDUElfR1BFX0NPTkRJVElPTkFMX0VOQUJMRToKKworCQkvKiBPbmx5IGVuYWJsZSBpZiB0aGUgZW5hYmxlX2Zvcl9ydW4gYml0IGlzIHNldCAqLworCisJCWlmICghKHJlZ2lzdGVyX2JpdCAmIGdwZV9yZWdpc3Rlcl9pbmZvLT5lbmFibGVfZm9yX3J1bikpIHsKIAkJCXJldHVybiAoQUVfQkFEX1BBUkFNRVRFUik7CisJCX0KKworCQkvKmxpbnQgLWZhbGx0aHJvdWdoICovCiAKIAljYXNlIEFDUElfR1BFX0VOQUJMRToKIAkJQUNQSV9TRVRfQklUKGVuYWJsZV9tYXNrLCByZWdpc3Rlcl9iaXQpOwpAQCAtMTMxLDcgKzEzNyw3IEBACiAJCWJyZWFrOwogCiAJZGVmYXVsdDoKLQkJQUNQSV9FUlJPUigoQUVfSU5GTywgIkludmFsaWQgYWN0aW9uXG4iKSk7CisJCUFDUElfRVJST1IoKEFFX0lORk8sICJJbnZhbGlkIEdQRSBBY3Rpb24sICV1XG4iLCBhY3Rpb24pKTsKIAkJcmV0dXJuIChBRV9CQURfUEFSQU1FVEVSKTsKIAl9CiAKQEAgLTE2OCwxMyArMTc0LDEzIEBACiAJCXJldHVybiAoQUVfTk9UX0VYSVNUKTsKIAl9CiAKLQlyZWdpc3Rlcl9iaXQgPSBhY3BpX2h3X2dldF9ncGVfcmVnaXN0ZXJfYml0KGdwZV9ldmVudF9pbmZvLAotCQkJCQkJZ3BlX3JlZ2lzdGVyX2luZm8pOwotCiAJLyoKIAkgKiBXcml0ZSBhIG9uZSB0byB0aGUgYXBwcm9wcmlhdGUgYml0IGluIHRoZSBzdGF0dXMgcmVnaXN0ZXIgdG8KIAkgKiBjbGVhciB0aGlzIEdQRS4KIAkgKi8KKwlyZWdpc3Rlcl9iaXQgPQorCSAgICBhY3BpX2h3X2dldF9ncGVfcmVnaXN0ZXJfYml0KGdwZV9ldmVudF9pbmZvLCBncGVfcmVnaXN0ZXJfaW5mbyk7CisKIAlzdGF0dXMgPSBhY3BpX2h3X3dyaXRlKHJlZ2lzdGVyX2JpdCwKIAkJCSAgICAgICAmZ3BlX3JlZ2lzdGVyX2luZm8tPnN0YXR1c19hZGRyZXNzKTsKIApAQCAtMjAxLDggKzIwNyw4IEBACiAJdTMyIGluX2J5dGU7CiAJdTMyIHJlZ2lzdGVyX2JpdDsKIAlzdHJ1Y3QgYWNwaV9ncGVfcmVnaXN0ZXJfaW5mbyAqZ3BlX3JlZ2lzdGVyX2luZm87Ci0JYWNwaV9zdGF0dXMgc3RhdHVzOwogCWFjcGlfZXZlbnRfc3RhdHVzIGxvY2FsX2V2ZW50X3N0YXR1cyA9IDA7CisJYWNwaV9zdGF0dXMgc3RhdHVzOwogCiAJQUNQSV9GVU5DVElPTl9FTlRSWSgpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3cGNpLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3cGNpLmMKaW5kZXggYWQyMWM3ZC4uMDUwZmQyMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9od3BjaS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHdwY2kuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3cmVncy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9od3JlZ3MuYwppbmRleCA1ZDEyNzNiLi41NWFjY2I3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3cmVncy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHdyZWdzLmMKQEAgLTcsNyArNyw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9od3NsZWVwLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3c2xlZXAuYwppbmRleCAzNzk2ODExLi4yYWMyOGJiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3c2xlZXAuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3c2xlZXAuYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHd0aW1lci5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9od3RpbWVyLmMKaW5kZXggMWVmOGUwYi4uOWM4ZWI3MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9od3RpbWVyLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9od3RpbWVyLmMKQEAgLTYsNyArNiw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3dmFsaWQuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHd2YWxpZC5jCmluZGV4IGUxZDljNzcuLjVmMTYwNTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHd2YWxpZC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvaHd2YWxpZC5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9od3hmYWNlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3eGZhY2UuYwppbmRleCA1MGNjM2JlLi42Zjk4ZDIxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3eGZhY2UuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL2h3eGZhY2UuYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNhY2Nlc3MuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNhY2Nlc3MuYwppbmRleCAwY2Q5MjViLi5kOTMxNzJmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zYWNjZXNzLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc2FjY2Vzcy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTE2Myw5ICsxNjMsOSBAQAogI2Vsc2UKIAkJCQkvKiBNYXJrIHRoaXMgYXMgYSB2ZXJ5IFNQRUNJQUwgbWV0aG9kICovCiAKLQkJCQlvYmpfZGVzYy0+bWV0aG9kLm1ldGhvZF9mbGFncyA9Ci0JCQkJICAgIEFNTF9NRVRIT0RfSU5URVJOQUxfT05MWTsKLQkJCQlvYmpfZGVzYy0+bWV0aG9kLmV4dHJhLmltcGxlbWVudGF0aW9uID0KKwkJCQlvYmpfZGVzYy0+bWV0aG9kLmluZm9fZmxhZ3MgPQorCQkJCSAgICBBQ1BJX01FVEhPRF9JTlRFUk5BTF9PTkxZOworCQkJCW9ial9kZXNjLT5tZXRob2QuZGlzcGF0Y2guaW1wbGVtZW50YXRpb24gPQogCQkJCSAgICBhY3BpX3V0X29zaV9pbXBsZW1lbnRhdGlvbjsKICNlbmRpZgogCQkJCWJyZWFrOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2FsbG9jLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zYWxsb2MuYwppbmRleCAxZTVmZjgwLi4xZDBlZjE1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zYWxsb2MuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zYWxsb2MuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC0yMzQsOCArMjM0LDggQEAKIAkJCSAqIG1vZGlmaWVkIHRoZSBuYW1lc3BhY2UuIFRoaXMgaXMgdXNlZCBmb3IgY2xlYW51cCB3aGVuIHRoZQogCQkJICogbWV0aG9kIGV4aXRzLgogCQkJICovCi0JCQl3YWxrX3N0YXRlLT5tZXRob2RfZGVzYy0+bWV0aG9kLmZsYWdzIHw9Ci0JCQkgICAgQU9QT0JKX01PRElGSUVEX05BTUVTUEFDRTsKKwkJCXdhbGtfc3RhdGUtPm1ldGhvZF9kZXNjLT5tZXRob2QuaW5mb19mbGFncyB8PQorCQkJICAgIEFDUElfTUVUSE9EX01PRElGSUVEX05BTUVTUEFDRTsKIAkJfQogCX0KIApAQCAtMzQxLDYgKzM0MSw3IEBACiB7CiAJc3RydWN0IGFjcGlfbmFtZXNwYWNlX25vZGUgKmNoaWxkX25vZGUgPSBOVUxMOwogCXUzMiBsZXZlbCA9IDE7CisJYWNwaV9zdGF0dXMgc3RhdHVzOwogCiAJQUNQSV9GVU5DVElPTl9UUkFDRShuc19kZWxldGVfbmFtZXNwYWNlX3N1YnRyZWUpOwogCkBAIC0zNDgsNiArMzQ5LDEzIEBACiAJCXJldHVybl9WT0lEOwogCX0KIAorCS8qIExvY2sgbmFtZXNwYWNlIGZvciBwb3NzaWJsZSB1cGRhdGUgKi8KKworCXN0YXR1cyA9IGFjcGlfdXRfYWNxdWlyZV9tdXRleChBQ1BJX01UWF9OQU1FU1BBQ0UpOworCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkgeworCQlyZXR1cm5fVk9JRDsKKwl9CisKIAkvKgogCSAqIFRyYXZlcnNlIHRoZSB0cmVlIG9mIG9iamVjdHMgdW50aWwgd2UgYnViYmxlIGJhY2sgdXAKIAkgKiB0byB3aGVyZSB3ZSBzdGFydGVkLgpAQCAtMzk3LDYgKzQwNSw3IEBACiAJCX0KIAl9CiAKKwkodm9pZClhY3BpX3V0X3JlbGVhc2VfbXV0ZXgoQUNQSV9NVFhfTkFNRVNQQUNFKTsKIAlyZXR1cm5fVk9JRDsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2R1bXAuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNkdW1wLmMKaW5kZXggYTU0ZGMzOS4uYjY4M2NjMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2R1bXAuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zZHVtcC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtNjI0LDkgKzYyNCwyMiBAQAogCQkgICAgIGFjcGlfb3duZXJfaWQgb3duZXJfaWQsIGFjcGlfaGFuZGxlIHN0YXJ0X2hhbmRsZSkKIHsKIAlzdHJ1Y3QgYWNwaV93YWxrX2luZm8gaW5mbzsKKwlhY3BpX3N0YXR1cyBzdGF0dXM7CiAKIAlBQ1BJX0ZVTkNUSU9OX0VOVFJZKCk7CiAKKwkvKgorCSAqIEp1c3QgbG9jayB0aGUgZW50aXJlIG5hbWVzcGFjZSBmb3IgdGhlIGR1cmF0aW9uIG9mIHRoZSBkdW1wLgorCSAqIFdlIGRvbid0IHdhbnQgYW55IGNoYW5nZXMgdG8gdGhlIG5hbWVzcGFjZSBkdXJpbmcgdGhpcyB0aW1lLAorCSAqIGVzcGVjaWFsbHkgdGhlIHRlbXBvcmFyeSBub2RlcyBzaW5jZSB3ZSBhcmUgZ29pbmcgdG8gZGlzcGxheQorCSAqIHRoZW0gYWxzby4KKwkgKi8KKwlzdGF0dXMgPSBhY3BpX3V0X2FjcXVpcmVfbXV0ZXgoQUNQSV9NVFhfTkFNRVNQQUNFKTsKKwlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKKwkJYWNwaV9vc19wcmludGYoIkNvdWxkIG5vdCBhY3F1aXJlIG5hbWVzcGFjZSBtdXRleFxuIik7CisJCXJldHVybjsKKwl9CisKIAlpbmZvLmRlYnVnX2xldmVsID0gQUNQSV9MVl9UQUJMRVM7CiAJaW5mby5vd25lcl9pZCA9IG93bmVyX2lkOwogCWluZm8uZGlzcGxheV90eXBlID0gZGlzcGxheV90eXBlOwpAQCAtNjM2LDYgKzY0OSw4IEBACiAJCQkJICAgICBBQ1BJX05TX1dBTEtfVEVNUF9OT0RFUywKIAkJCQkgICAgIGFjcGlfbnNfZHVtcF9vbmVfb2JqZWN0LCBOVUxMLAogCQkJCSAgICAgKHZvaWQgKikmaW5mbywgTlVMTCk7CisKKwkodm9pZClhY3BpX3V0X3JlbGVhc2VfbXV0ZXgoQUNQSV9NVFhfTkFNRVNQQUNFKTsKIH0KICNlbmRpZgkJCQkvKiBBQ1BJX0ZVVFVSRV9VU0FHRSAqLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zZHVtcGR2LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zZHVtcGR2LmMKaW5kZXggZDJhOTc5Mi4uMmVkMjk0YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc2R1bXBkdi5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNkdW1wZHYuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNldmFsLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zZXZhbC5jCmluZGV4IGY1MjgyOWMuLmMxYmQwMmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNldmFsLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc2V2YWwuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC0zODksNyArMzg5LDcgQEAKIAkgKiBhY3BpX2dibF9yb290X25vZGUtPk9iamVjdCBpcyBOVUxMIGF0IFBBU1MxLgogCSAqLwogCWlmICgodHlwZSA9PSBBQ1BJX1RZUEVfREVWSUNFKSAmJiBwYXJlbnRfbm9kZS0+b2JqZWN0KSB7Ci0JCW1ldGhvZF9vYmotPm1ldGhvZC5leHRyYS5oYW5kbGVyID0KKwkJbWV0aG9kX29iai0+bWV0aG9kLmRpc3BhdGNoLmhhbmRsZXIgPQogCQkgICAgcGFyZW50X25vZGUtPm9iamVjdC0+ZGV2aWNlLmhhbmRsZXI7CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zaW5pdC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc2luaXQuYwppbmRleCAwY2FjN2VjLi5mZDdjNjM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zaW5pdC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNpbml0LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zbG9hZC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc2xvYWQuYwppbmRleCBkZjE4YmU5Li41ZjdkYzY5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zbG9hZC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNsb2FkLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zbmFtZXMuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNuYW1lcy5jCmluZGV4IGQzMTA0YWYuLmQ1ZmE1MjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNuYW1lcy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNuYW1lcy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNvYmplY3QuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNvYmplY3QuYwppbmRleCA0MWE5MjEzLi4zYmI4YmYxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zb2JqZWN0LmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc29iamVjdC5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNwYXJzZS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc3BhcnNlLmMKaW5kZXggNTgwOGM4OS4uYjMyMzRmYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3BhcnNlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc3BhcnNlLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zcHJlZGVmLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zcHJlZGVmLmMKaW5kZXggNzA5NmJjZC4uOWZiMDNmYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3ByZWRlZi5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNwcmVkZWYuYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNyZXBhaXIuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNyZXBhaXIuYwppbmRleCBkMWMxMzY2Li4xZDc2YWM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zcmVwYWlyLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc3JlcGFpci5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3JlcGFpcjIuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNyZXBhaXIyLmMKaW5kZXggNGVmOWY0My4uOTczODgzYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3JlcGFpcjIuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zcmVwYWlyMi5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3NlYXJjaC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc3NlYXJjaC5jCmluZGV4IDQxMTAyYTguLjI4YjBkN2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnNzZWFyY2guYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zc2VhcmNoLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3V0aWxzLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zdXRpbHMuYwppbmRleCBhN2Q2YWQ5Li5jYjFiMTA0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zdXRpbHMuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zdXRpbHMuYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnN3YWxrLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zd2Fsay5jCmluZGV4IDJjZDViZTguLjM0NWYwYzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnN3YWxrLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc3dhbGsuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnN4ZmV2YWwuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnN4ZmV2YWwuYwppbmRleCBlYmVmOGE3Li5jNTNmMDA0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zeGZldmFsLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc3hmZXZhbC5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnN4Zm5hbWUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvbnN4Zm5hbWUuYwppbmRleCBiMDFlNDVhLi4zZmQ0NTI2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zeGZuYW1lLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9uc3hmbmFtZS5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtNjAzLDEwICs2MDMsOSBAQAogCW1ldGhvZF9vYmotPm1ldGhvZC5wYXJhbV9jb3VudCA9ICh1OCkKIAkgICAgKG1ldGhvZF9mbGFncyAmIEFNTF9NRVRIT0RfQVJHX0NPVU5UKTsKIAotCW1ldGhvZF9vYmotPm1ldGhvZC5tZXRob2RfZmxhZ3MgPSAodTgpCi0JICAgIChtZXRob2RfZmxhZ3MgJiB+QU1MX01FVEhPRF9BUkdfQ09VTlQpOwotCiAJaWYgKG1ldGhvZF9mbGFncyAmIEFNTF9NRVRIT0RfU0VSSUFMSVpFRCkgeworCQltZXRob2Rfb2JqLT5tZXRob2QuaW5mb19mbGFncyA9IEFDUElfTUVUSE9EX1NFUklBTElaRUQ7CisKIAkJbWV0aG9kX29iai0+bWV0aG9kLnN5bmNfbGV2ZWwgPSAodTgpCiAJCSAgICAoKG1ldGhvZF9mbGFncyAmIEFNTF9NRVRIT0RfU1lOQ19MRVZFTCkgPj4gNCk7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9uc3hmb2JqLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zeGZvYmouYwppbmRleCBhMWYwNGU5Li5kYjc2NjBmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL25zeGZvYmouYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL25zeGZvYmouYwpAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzYXJncy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc2FyZ3MuYwppbmRleCA3ZGYxYTRjLi5lMWZhZDBlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzYXJncy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNhcmdzLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzbG9vcC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc2xvb3AuYwppbmRleCAyZjJlNzc2Li4wMWRkNzBkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzbG9vcC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNsb29wLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC02NTUsNyArNjU1LDcgQEAKIAkJbWV0aG9kX29iai0+bWV0aG9kLmFtbF9zdGFydCA9IGFtbF9zdGFydDsKIAkJbWV0aG9kX29iai0+bWV0aG9kLmFtbF9sZW5ndGggPSBhbWxfbGVuZ3RoOwogCQltZXRob2Rfb2JqLT5tZXRob2Qub3duZXJfaWQgPSBvd25lcl9pZDsKLQkJbWV0aG9kX29iai0+bWV0aG9kLmZsYWdzIHw9IEFPUE9CSl9NT0RVTEVfTEVWRUw7CisJCW1ldGhvZF9vYmotPm1ldGhvZC5pbmZvX2ZsYWdzIHw9IEFDUElfTUVUSE9EX01PRFVMRV9MRVZFTDsKIAogCQkvKgogCQkgKiBTYXZlIHRoZSBwYXJlbnQgbm9kZSBpbiBuZXh0X29iamVjdC4gVGhpcyBpcyBjaGVhdGluZywgYnV0IHdlCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3Bzb3Bjb2RlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3Bzb3Bjb2RlLmMKaW5kZXggMmIwYzNiZS4uYmVkMDhkZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9wc29wY29kZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNvcGNvZGUuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNwYXJzZS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc3BhcnNlLmMKaW5kZXggOGQ4MTU0Mi4uOWJiMGNiZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9wc3BhcnNlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc3BhcnNlLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC01NSw3ICs1NSw2IEBACiAjaW5jbHVkZSAiYWNwYXJzZXIuaCIKICNpbmNsdWRlICJhY2Rpc3BhdC5oIgogI2luY2x1ZGUgImFtbGNvZGUuaCIKLSNpbmNsdWRlICJhY25hbWVzcC5oIgogI2luY2x1ZGUgImFjaW50ZXJwLmgiCiAKICNkZWZpbmUgX0NPTVBPTkVOVCAgICAgICAgICBBQ1BJX1BBUlNFUgpAQCAtNTM5LDI0ICs1MzgsMTYgQEAKIAkJCS8qIENoZWNrIGZvciBwb3NzaWJsZSBtdWx0aS10aHJlYWQgcmVlbnRyYW5jeSBwcm9ibGVtICovCiAKIAkJCWlmICgoc3RhdHVzID09IEFFX0FMUkVBRFlfRVhJU1RTKSAmJgotCQkJICAgICghd2Fsa19zdGF0ZS0+bWV0aG9kX2Rlc2MtPm1ldGhvZC5tdXRleCkpIHsKLQkJCQlBQ1BJX0lORk8oKEFFX0lORk8sCi0JCQkJCSAgICJNYXJraW5nIG1ldGhvZCAlNC40cyBhcyBTZXJpYWxpemVkIGJlY2F1c2Ugb2YgQUVfQUxSRUFEWV9FWElTVFMgZXJyb3IiLAotCQkJCQkgICB3YWxrX3N0YXRlLT5tZXRob2Rfbm9kZS0+bmFtZS4KLQkJCQkJICAgYXNjaWkpKTsKLQorCQkJICAgICghKHdhbGtfc3RhdGUtPm1ldGhvZF9kZXNjLT5tZXRob2QuCisJCQkgICAgICAgaW5mb19mbGFncyAmIEFDUElfTUVUSE9EX1NFUklBTElaRUQpKSkgewogCQkJCS8qCi0JCQkJICogTWV0aG9kIHRyaWVkIHRvIGNyZWF0ZSBhbiBvYmplY3QgdHdpY2UuIFRoZSBwcm9iYWJsZSBjYXVzZSBpcwotCQkJCSAqIHRoYXQgdGhlIG1ldGhvZCBjYW5ub3QgaGFuZGxlIHJlZW50cmFuY3kuCi0JCQkJICoKLQkJCQkgKiBUaGUgbWV0aG9kIGlzIG1hcmtlZCBub3Rfc2VyaWFsaXplZCwgYnV0IGl0IHRyaWVkIHRvIGNyZWF0ZQotCQkJCSAqIGEgbmFtZWQgb2JqZWN0LCBjYXVzaW5nIHRoZSBzZWNvbmQgdGhyZWFkIGVudHJhbmNlIHRvIGZhaWwuCi0JCQkJICogV29ya2Fyb3VuZCB0aGlzIHByb2JsZW0gYnkgbWFya2luZyB0aGUgbWV0aG9kIHBlcm1hbmVudGx5Ci0JCQkJICogYXMgU2VyaWFsaXplZC4KKwkJCQkgKiBNZXRob2QgaXMgbm90IHNlcmlhbGl6ZWQgYW5kIHRyaWVkIHRvIGNyZWF0ZSBhbiBvYmplY3QKKwkJCQkgKiB0d2ljZS4gVGhlIHByb2JhYmxlIGNhdXNlIGlzIHRoYXQgdGhlIG1ldGhvZCBjYW5ub3QKKwkJCQkgKiBoYW5kbGUgcmVlbnRyYW5jeS4gTWFyayBhcyAicGVuZGluZyBzZXJpYWxpemVkIiBub3csIGFuZAorCQkJCSAqIHRoZW4gbWFyayAic2VyaWFsaXplZCIgd2hlbiB0aGUgbGFzdCB0aHJlYWQgZXhpdHMuCiAJCQkJICovCi0JCQkJd2Fsa19zdGF0ZS0+bWV0aG9kX2Rlc2MtPm1ldGhvZC5tZXRob2RfZmxhZ3MgfD0KLQkJCQkgICAgQU1MX01FVEhPRF9TRVJJQUxJWkVEOwotCQkJCXdhbGtfc3RhdGUtPm1ldGhvZF9kZXNjLT5tZXRob2Quc3luY19sZXZlbCA9IDA7CisJCQkJd2Fsa19zdGF0ZS0+bWV0aG9kX2Rlc2MtPm1ldGhvZC5pbmZvX2ZsYWdzIHw9CisJCQkJICAgIEFDUElfTUVUSE9EX1NFUklBTElaRURfUEVORElORzsKIAkJCX0KIAkJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3Bzc2NvcGUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNzY29wZS5jCmluZGV4IDQwZTJiMjcuLmE1ZmFhMTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNzY29wZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHNzY29wZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9wc3RyZWUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHN0cmVlLmMKaW5kZXggZDRiOTcwYy4uZjE0NjRjMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9wc3RyZWUuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzdHJlZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9wc3V0aWxzLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzdXRpbHMuYwppbmRleCBmZTI5ZWVlLi43ZWRhNzg1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzdXRpbHMuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3BzdXRpbHMuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHN3YWxrLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3Bzd2Fsay5jCmluZGV4IDhhYmI5NjIuLjMzMTJkNjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHN3YWxrLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc3dhbGsuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcHN4ZmFjZS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc3hmYWNlLmMKaW5kZXggYzQyZjA2Ny4uODA4NjgwNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9wc3hmYWNlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9wc3hmYWNlLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CkBAIC00Nyw3ICs0Nyw2IEBACiAjaW5jbHVkZSAiYWNkaXNwYXQuaCIKICNpbmNsdWRlICJhY2ludGVycC5oIgogI2luY2x1ZGUgImFjdGFibGVzLmgiCi0jaW5jbHVkZSAiYW1sY29kZS5oIgogCiAjZGVmaW5lIF9DT01QT05FTlQgICAgICAgICAgQUNQSV9QQVJTRVIKIEFDUElfTU9EVUxFX05BTUUoInBzeGZhY2UiKQpAQCAtMjg1LDE1ICsyODQsMTUgQEAKIAkJZ290byBjbGVhbnVwOwogCX0KIAotCWlmIChpbmZvLT5vYmpfZGVzYy0+bWV0aG9kLmZsYWdzICYgQU9QT0JKX01PRFVMRV9MRVZFTCkgeworCWlmIChpbmZvLT5vYmpfZGVzYy0+bWV0aG9kLmluZm9fZmxhZ3MgJiBBQ1BJX01FVEhPRF9NT0RVTEVfTEVWRUwpIHsKIAkJd2Fsa19zdGF0ZS0+cGFyc2VfZmxhZ3MgfD0gQUNQSV9QQVJTRV9NT0RVTEVfTEVWRUw7CiAJfQogCiAJLyogSW52b2tlIGFuIGludGVybmFsIG1ldGhvZCBpZiBuZWNlc3NhcnkgKi8KIAotCWlmIChpbmZvLT5vYmpfZGVzYy0+bWV0aG9kLm1ldGhvZF9mbGFncyAmIEFNTF9NRVRIT0RfSU5URVJOQUxfT05MWSkgeworCWlmIChpbmZvLT5vYmpfZGVzYy0+bWV0aG9kLmluZm9fZmxhZ3MgJiBBQ1BJX01FVEhPRF9JTlRFUk5BTF9PTkxZKSB7CiAJCXN0YXR1cyA9Ci0JCSAgICBpbmZvLT5vYmpfZGVzYy0+bWV0aG9kLmV4dHJhLmltcGxlbWVudGF0aW9uKHdhbGtfc3RhdGUpOworCQkgICAgaW5mby0+b2JqX2Rlc2MtPm1ldGhvZC5kaXNwYXRjaC5pbXBsZW1lbnRhdGlvbih3YWxrX3N0YXRlKTsKIAkJaW5mby0+cmV0dXJuX29iamVjdCA9IHdhbGtfc3RhdGUtPnJldHVybl9kZXNjOwogCiAJCS8qIENsZWFudXAgc3RhdGVzICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzYWRkci5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc2FkZHIuYwppbmRleCAyMjZjODA2Li45ZTY2ZjkwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzYWRkci5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNhZGRyLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc2NhbGMuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNjYWxjLmMKaW5kZXggZDZlYmY3ZS4uM2E4YTg5ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc2NhbGMuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzY2FsYy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNjcmVhdGUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNjcmVhdGUuYwppbmRleCBjODBhMmVlLi40Y2U2ZTExIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzY3JlYXRlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc2NyZWF0ZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNkdW1wLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzZHVtcC5jCmluZGV4IGY4NTliMDMuLjMzZGI3NTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNkdW1wLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc2R1bXAuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzaW5mby5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc2luZm8uYwppbmRleCAxZmQ4NjhiLi5mOWVhNjA4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzaW5mby5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNpbmZvLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc2lvLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzaW8uYwppbmRleCAzM2JmZjE3Li4wYzdlZmVmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzaW8uYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzaW8uYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzaXJxLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzaXJxLmMKaW5kZXggNTQ1ZGE0MC4uNTBiOGFkMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc2lycS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNpcnEuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzbGlzdC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc2xpc3QuYwppbmRleCA3MzM1ZjIyLi4xYmZjZWY3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzbGlzdC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNsaXN0LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc21lbW9yeS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc21lbW9yeS5jCmluZGV4IDg4N2I4YmEuLjdjYzZkODYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNtZW1vcnkuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzbWVtb3J5LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc21pc2MuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnNtaXNjLmMKaW5kZXggZjhjZDllOC4uNDEwMjY0YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc21pc2MuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzbWlzYy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvcnN1dGlscy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc3V0aWxzLmMKaW5kZXggNDkxMTkxZS4uMjMxODExZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc3V0aWxzLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS9yc3V0aWxzLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS9yc3hmYWNlLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzeGZhY2UuYwppbmRleCA5ZjZhNmU3Li4yZmY2NTdhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzeGZhY2UuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3JzeGZhY2UuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3RiZmFkdC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS90YmZhZHQuYwppbmRleCBkMmZmNDMyLi40MjhkNDRlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3RiZmFkdC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJmYWR0LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3RiZmluZC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS90YmZpbmQuYwppbmRleCA5ODlkNWM4Li5hNTVjYjJiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3RiZmluZC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJmaW5kLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3RiaW5zdGFsLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3RiaW5zdGFsLmMKaW5kZXggODNkN2FmOC4uNDhkYjA5NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS90Ymluc3RhbC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJpbnN0YWwuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJ1dGlscy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS90YnV0aWxzLmMKaW5kZXggMzRmOWMyYi4uMGYyZDM5NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS90YnV0aWxzLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS90YnV0aWxzLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3RieGZhY2UuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJ4ZmFjZS5jCmluZGV4IDRhOGI5ZTYuLjRiNzA4NWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJ4ZmFjZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJ4ZmFjZS5jCkBAIC02LDcgKzYsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS90Ynhmcm9vdC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS90Ynhmcm9vdC5jCmluZGV4IGZkMmMwN2QuLjdlYjZjNmMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdGJ4ZnJvb3QuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3RieGZyb290LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0YWxsb2MuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRhbGxvYy5jCmluZGV4IDhmMDg5NjIuLjBhNjk3MzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRhbGxvYy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRhbGxvYy5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGNvcHkuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRjb3B5LmMKaW5kZXggNmZlZjgzZi4uYWRlZDI5OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGNvcHkuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0Y29weS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGRlYnVnLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0ZGVidWcuYwppbmRleCBmMjFjNDg2Li5hOWJjZDgxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0ZGVidWcuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0ZGVidWcuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRkZWxldGUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRkZWxldGUuYwppbmRleCBlZDc5NGNkLi4zMWY1YTc4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0ZGVsZXRlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGRlbGV0ZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRldmFsLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0ZXZhbC5jCmluZGV4IDIyZjU5ZWYuLjE4ZjczYzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRldmFsLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGV2YWwuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRnbG9iYWwuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRnbG9iYWwuYwppbmRleCBlODdiYzY3Li45N2RkOWJiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0Z2xvYmFsLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGdsb2JhbC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtNzY4LDcgKzc2OCw3IEBACiAJYWNwaV9nYmxfZ3BlX2ZhZHRfYmxvY2tzWzBdID0gTlVMTDsKIAlhY3BpX2dibF9ncGVfZmFkdF9ibG9ja3NbMV0gPSBOVUxMOwogCWFjcGlfY3VycmVudF9ncGVfY291bnQgPSAwOwotCWFjcGlfYWxsX2dwZXNfaW5pdGlhbGl6ZWQgPSBGQUxTRTsKKwlhY3BpX2dibF9hbGxfZ3Blc19pbml0aWFsaXplZCA9IEZBTFNFOwogCiAJLyogR2xvYmFsIGhhbmRsZXJzICovCiAKQEAgLTc3OCw2ICs3NzgsNyBAQAogCWFjcGlfZ2JsX2luaXRfaGFuZGxlciA9IE5VTEw7CiAJYWNwaV9nYmxfdGFibGVfaGFuZGxlciA9IE5VTEw7CiAJYWNwaV9nYmxfaW50ZXJmYWNlX2hhbmRsZXIgPSBOVUxMOworCWFjcGlfZ2JsX2dsb2JhbF9ldmVudF9oYW5kbGVyID0gTlVMTDsKIAogCS8qIEdsb2JhbCBMb2NrIHN1cHBvcnQgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGlkcy5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGlkcy5jCmluZGV4IGQyOTA2MzIuLmI2NzllYTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRpZHMuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0aWRzLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0aW5pdC5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGluaXQuYwppbmRleCBjMWIxYzgwLi4xOTFiNjgyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0aW5pdC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRpbml0LmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0bG9jay5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dGxvY2suYwppbmRleCBiMDgxY2Q0Li5mNmJiNzVjNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dGxvY2suYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0bG9jay5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dG1hdGguYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRtYXRoLmMKaW5kZXggNDljZjdiNy4uY2U0ODFkYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dG1hdGguYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0bWF0aC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRtaXNjLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0bWlzYy5jCmluZGV4IGM3ZDBlMDUuLmMzM2E4NTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRtaXNjLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dG1pc2MuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0bXV0ZXguYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRtdXRleC5jCmluZGV4IGQ5ZWZhNDkuLmE5NDZjNjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRtdXRleC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRtdXRleC5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTg1LDYgKzg1LDcgQEAKIAogCXNwaW5fbG9ja19pbml0KGFjcGlfZ2JsX2dwZV9sb2NrKTsKIAlzcGluX2xvY2tfaW5pdChhY3BpX2dibF9oYXJkd2FyZV9sb2NrKTsKKwlzcGluX2xvY2tfaW5pdChhY3BpX2V2X2dsb2JhbF9sb2NrX3BlbmRpbmdfbG9jayk7CiAKIAkvKiBNdXRleCBmb3IgX09TSSBzdXBwb3J0ICovCiAJc3RhdHVzID0gYWNwaV9vc19jcmVhdGVfbXV0ZXgoJmFjcGlfZ2JsX29zaV9tdXRleCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0b2JqZWN0LmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0b2JqZWN0LmMKaW5kZXggZmQxZmEyNy4uMTg4MzQwYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dG9iamVjdC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRvYmplY3QuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRvc2kuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRvc2kuYwppbmRleCAxOGM1OWE4Li4xZmIxMGNiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0b3NpLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dG9zaS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjcGljYS91dHJlc3JjLmMgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0cmVzcmMuYwppbmRleCA3OTY1OTE5Li44NGUwNTE4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0cmVzcmMuYworKysgYi9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0cmVzcmMuYwpAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0c3RhdGUuYyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRzdGF0ZS5jCmluZGV4IGQzNWQxMDkuLjMwYzIxZTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRzdGF0ZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXRzdGF0ZS5jCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXR4ZmFjZS5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHhmYWNlLmMKaW5kZXggMWY0ODRjOS4uOThhZDEyNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FjcGljYS91dHhmYWNlLmMKKysrIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHhmYWNlLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0eGZlcnJvci5jIGIvZHJpdmVycy9hY3BpL2FjcGljYS91dHhmZXJyb3IuYwppbmRleCA2ZjEyZTMxLi45MTZhZTA5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaWNhL3V0eGZlcnJvci5jCisrKyBiL2RyaXZlcnMvYWNwaS9hY3BpY2EvdXR4ZmVycm9yLmMKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FwZWkvYXBlaS1pbnRlcm5hbC5oIGIvZHJpdmVycy9hY3BpL2FwZWkvYXBlaS1pbnRlcm5hbC5oCmluZGV4IDE4ZGYxZTkuLmVmMDU4MWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hcGVpL2FwZWktaW50ZXJuYWwuaAorKysgYi9kcml2ZXJzL2FjcGkvYXBlaS9hcGVpLWludGVybmFsLmgKQEAgLTEwOSw2ICsxMDksOCBAQAogCQlyZXR1cm4gc2l6ZW9mKCplc3RhdHVzKSArIGVzdGF0dXMtPmRhdGFfbGVuZ3RoOwogfQogCit2b2lkIGFwZWlfZXN0YXR1c19wcmludChjb25zdCBjaGFyICpwZngsCisJCQljb25zdCBzdHJ1Y3QgYWNwaV9oZXN0X2dlbmVyaWNfc3RhdHVzICplc3RhdHVzKTsKIGludCBhcGVpX2VzdGF0dXNfY2hlY2tfaGVhZGVyKGNvbnN0IHN0cnVjdCBhY3BpX2hlc3RfZ2VuZXJpY19zdGF0dXMgKmVzdGF0dXMpOwogaW50IGFwZWlfZXN0YXR1c19jaGVjayhjb25zdCBzdHJ1Y3QgYWNwaV9oZXN0X2dlbmVyaWNfc3RhdHVzICplc3RhdHVzKTsKICNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FwZWkvY3Blci5jIGIvZHJpdmVycy9hY3BpL2FwZWkvY3Blci5jCmluZGV4IGY0Y2YyZmMuLjMxNDY0YTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9hcGVpL2NwZXIuYworKysgYi9kcml2ZXJzL2FjcGkvYXBlaS9jcGVyLmMKQEAgLTQ2LDYgKzQ2LDMxNyBAQAogfQogRVhQT1JUX1NZTUJPTF9HUEwoY3Blcl9uZXh0X3JlY29yZF9pZCk7CiAKK3N0YXRpYyBjb25zdCBjaGFyICpjcGVyX3NldmVyaXR5X3N0cnNbXSA9IHsKKwkicmVjb3ZlcmFibGUiLAorCSJmYXRhbCIsCisJImNvcnJlY3RlZCIsCisJImluZm8iLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKmNwZXJfc2V2ZXJpdHlfc3RyKHVuc2lnbmVkIGludCBzZXZlcml0eSkKK3sKKwlyZXR1cm4gc2V2ZXJpdHkgPCBBUlJBWV9TSVpFKGNwZXJfc2V2ZXJpdHlfc3RycykgPworCQljcGVyX3NldmVyaXR5X3N0cnNbc2V2ZXJpdHldIDogInVua25vd24iOworfQorCisvKgorICogY3Blcl9wcmludF9iaXRzIC0gcHJpbnQgc3RyaW5ncyBmb3Igc2V0IGJpdHMKKyAqIEBwZng6IHByZWZpeCBmb3IgZWFjaCBsaW5lLCBpbmNsdWRpbmcgbG9nIGxldmVsIGFuZCBwcmVmaXggc3RyaW5nCisgKiBAYml0czogYml0IG1hc2sKKyAqIEBzdHJzOiBzdHJpbmcgYXJyYXksIGluZGV4ZWQgYnkgYml0IHBvc2l0aW9uCisgKiBAc3Ryc19zaXplOiBzaXplIG9mIHRoZSBzdHJpbmcgYXJyYXk6IEBzdHJzCisgKgorICogRm9yIGVhY2ggc2V0IGJpdCBpbiBAYml0cywgcHJpbnQgdGhlIGNvcnJlc3BvbmRpbmcgc3RyaW5nIGluIEBzdHJzLgorICogSWYgdGhlIG91dHB1dCBsZW5ndGggaXMgbG9uZ2VyIHRoYW4gODAsIG11bHRpcGxlIGxpbmUgd2lsbCBiZQorICogcHJpbnRlZCwgd2l0aCBAcGZ4IGlzIHByaW50ZWQgYXQgdGhlIGJlZ2lubmluZyBvZiBlYWNoIGxpbmUuCisgKi8KK3N0YXRpYyB2b2lkIGNwZXJfcHJpbnRfYml0cyhjb25zdCBjaGFyICpwZngsIHVuc2lnbmVkIGludCBiaXRzLAorCQkJICAgIGNvbnN0IGNoYXIgKnN0cnNbXSwgdW5zaWduZWQgaW50IHN0cnNfc2l6ZSkKK3sKKwlpbnQgaSwgbGVuID0gMDsKKwljb25zdCBjaGFyICpzdHI7CisJY2hhciBidWZbODRdOworCisJZm9yIChpID0gMDsgaSA8IHN0cnNfc2l6ZTsgaSsrKSB7CisJCWlmICghKGJpdHMgJiAoMVUgPDwgaSkpKQorCQkJY29udGludWU7CisJCXN0ciA9IHN0cnNbaV07CisJCWlmIChsZW4gJiYgbGVuICsgc3RybGVuKHN0cikgKyAyID4gODApIHsKKwkJCXByaW50aygiJXNcbiIsIGJ1Zik7CisJCQlsZW4gPSAwOworCQl9CisJCWlmICghbGVuKQorCQkJbGVuID0gc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIiVzJXMiLCBwZngsIHN0cik7CisJCWVsc2UKKwkJCWxlbiArPSBzbnByaW50ZihidWYrbGVuLCBzaXplb2YoYnVmKS1sZW4sICIsICVzIiwgc3RyKTsKKwl9CisJaWYgKGxlbikKKwkJcHJpbnRrKCIlc1xuIiwgYnVmKTsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKmNwZXJfcHJvY190eXBlX3N0cnNbXSA9IHsKKwkiSUEzMi9YNjQiLAorCSJJQTY0IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICpjcGVyX3Byb2NfaXNhX3N0cnNbXSA9IHsKKwkiSUEzMiIsCisJIklBNjQiLAorCSJYNjQiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKmNwZXJfcHJvY19lcnJvcl90eXBlX3N0cnNbXSA9IHsKKwkiY2FjaGUgZXJyb3IiLAorCSJUTEIgZXJyb3IiLAorCSJidXMgZXJyb3IiLAorCSJtaWNyby1hcmNoaXRlY3R1cmFsIGVycm9yIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICpjcGVyX3Byb2Nfb3Bfc3Ryc1tdID0geworCSJ1bmtub3duIG9yIGdlbmVyaWMiLAorCSJkYXRhIHJlYWQiLAorCSJkYXRhIHdyaXRlIiwKKwkiaW5zdHJ1Y3Rpb24gZXhlY3V0aW9uIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICpjcGVyX3Byb2NfZmxhZ19zdHJzW10gPSB7CisJInJlc3RhcnRhYmxlIiwKKwkicHJlY2lzZSBJUCIsCisJIm92ZXJmbG93IiwKKwkiY29ycmVjdGVkIiwKK307CisKK3N0YXRpYyB2b2lkIGNwZXJfcHJpbnRfcHJvY19nZW5lcmljKGNvbnN0IGNoYXIgKnBmeCwKKwkJCQkgICAgY29uc3Qgc3RydWN0IGNwZXJfc2VjX3Byb2NfZ2VuZXJpYyAqcHJvYykKK3sKKwlpZiAocHJvYy0+dmFsaWRhdGlvbl9iaXRzICYgQ1BFUl9QUk9DX1ZBTElEX1RZUEUpCisJCXByaW50aygiJXMiInByb2Nlc3Nvcl90eXBlOiAlZCwgJXNcbiIsIHBmeCwgcHJvYy0+cHJvY190eXBlLAorCQkgICAgICAgcHJvYy0+cHJvY190eXBlIDwgQVJSQVlfU0laRShjcGVyX3Byb2NfdHlwZV9zdHJzKSA/CisJCSAgICAgICBjcGVyX3Byb2NfdHlwZV9zdHJzW3Byb2MtPnByb2NfdHlwZV0gOiAidW5rbm93biIpOworCWlmIChwcm9jLT52YWxpZGF0aW9uX2JpdHMgJiBDUEVSX1BST0NfVkFMSURfSVNBKQorCQlwcmludGsoIiVzIiJwcm9jZXNzb3JfaXNhOiAlZCwgJXNcbiIsIHBmeCwgcHJvYy0+cHJvY19pc2EsCisJCSAgICAgICBwcm9jLT5wcm9jX2lzYSA8IEFSUkFZX1NJWkUoY3Blcl9wcm9jX2lzYV9zdHJzKSA/CisJCSAgICAgICBjcGVyX3Byb2NfaXNhX3N0cnNbcHJvYy0+cHJvY19pc2FdIDogInVua25vd24iKTsKKwlpZiAocHJvYy0+dmFsaWRhdGlvbl9iaXRzICYgQ1BFUl9QUk9DX1ZBTElEX0VSUk9SX1RZUEUpIHsKKwkJcHJpbnRrKCIlcyIiZXJyb3JfdHlwZTogMHglMDJ4XG4iLCBwZngsIHByb2MtPnByb2NfZXJyb3JfdHlwZSk7CisJCWNwZXJfcHJpbnRfYml0cyhwZngsIHByb2MtPnByb2NfZXJyb3JfdHlwZSwKKwkJCQljcGVyX3Byb2NfZXJyb3JfdHlwZV9zdHJzLAorCQkJCUFSUkFZX1NJWkUoY3Blcl9wcm9jX2Vycm9yX3R5cGVfc3RycykpOworCX0KKwlpZiAocHJvYy0+dmFsaWRhdGlvbl9iaXRzICYgQ1BFUl9QUk9DX1ZBTElEX09QRVJBVElPTikKKwkJcHJpbnRrKCIlcyIib3BlcmF0aW9uOiAlZCwgJXNcbiIsIHBmeCwgcHJvYy0+b3BlcmF0aW9uLAorCQkgICAgICAgcHJvYy0+b3BlcmF0aW9uIDwgQVJSQVlfU0laRShjcGVyX3Byb2Nfb3Bfc3RycykgPworCQkgICAgICAgY3Blcl9wcm9jX29wX3N0cnNbcHJvYy0+b3BlcmF0aW9uXSA6ICJ1bmtub3duIik7CisJaWYgKHByb2MtPnZhbGlkYXRpb25fYml0cyAmIENQRVJfUFJPQ19WQUxJRF9GTEFHUykgeworCQlwcmludGsoIiVzIiJmbGFnczogMHglMDJ4XG4iLCBwZngsIHByb2MtPmZsYWdzKTsKKwkJY3Blcl9wcmludF9iaXRzKHBmeCwgcHJvYy0+ZmxhZ3MsIGNwZXJfcHJvY19mbGFnX3N0cnMsCisJCQkJQVJSQVlfU0laRShjcGVyX3Byb2NfZmxhZ19zdHJzKSk7CisJfQorCWlmIChwcm9jLT52YWxpZGF0aW9uX2JpdHMgJiBDUEVSX1BST0NfVkFMSURfTEVWRUwpCisJCXByaW50aygiJXMiImxldmVsOiAlZFxuIiwgcGZ4LCBwcm9jLT5sZXZlbCk7CisJaWYgKHByb2MtPnZhbGlkYXRpb25fYml0cyAmIENQRVJfUFJPQ19WQUxJRF9WRVJTSU9OKQorCQlwcmludGsoIiVzIiJ2ZXJzaW9uX2luZm86IDB4JTAxNmxseFxuIiwgcGZ4LCBwcm9jLT5jcHVfdmVyc2lvbik7CisJaWYgKHByb2MtPnZhbGlkYXRpb25fYml0cyAmIENQRVJfUFJPQ19WQUxJRF9JRCkKKwkJcHJpbnRrKCIlcyIicHJvY2Vzc29yX2lkOiAweCUwMTZsbHhcbiIsIHBmeCwgcHJvYy0+cHJvY19pZCk7CisJaWYgKHByb2MtPnZhbGlkYXRpb25fYml0cyAmIENQRVJfUFJPQ19WQUxJRF9UQVJHRVRfQUREUkVTUykKKwkJcHJpbnRrKCIlcyIidGFyZ2V0X2FkZHJlc3M6IDB4JTAxNmxseFxuIiwKKwkJICAgICAgIHBmeCwgcHJvYy0+dGFyZ2V0X2FkZHIpOworCWlmIChwcm9jLT52YWxpZGF0aW9uX2JpdHMgJiBDUEVSX1BST0NfVkFMSURfUkVRVUVTVE9SX0lEKQorCQlwcmludGsoIiVzIiJyZXF1ZXN0b3JfaWQ6IDB4JTAxNmxseFxuIiwKKwkJICAgICAgIHBmeCwgcHJvYy0+cmVxdWVzdG9yX2lkKTsKKwlpZiAocHJvYy0+dmFsaWRhdGlvbl9iaXRzICYgQ1BFUl9QUk9DX1ZBTElEX1JFU1BPTkRFUl9JRCkKKwkJcHJpbnRrKCIlcyIicmVzcG9uZGVyX2lkOiAweCUwMTZsbHhcbiIsCisJCSAgICAgICBwZngsIHByb2MtPnJlc3BvbmRlcl9pZCk7CisJaWYgKHByb2MtPnZhbGlkYXRpb25fYml0cyAmIENQRVJfUFJPQ19WQUxJRF9JUCkKKwkJcHJpbnRrKCIlcyIiSVA6IDB4JTAxNmxseFxuIiwgcGZ4LCBwcm9jLT5pcCk7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFyICpjcGVyX21lbV9lcnJfdHlwZV9zdHJzW10gPSB7CisJInVua25vd24iLAorCSJubyBlcnJvciIsCisJInNpbmdsZS1iaXQgRUNDIiwKKwkibXVsdGktYml0IEVDQyIsCisJInNpbmdsZS1zeW1ib2wgY2hpcGtpbGwgRUNDIiwKKwkibXVsdGktc3ltYm9sIGNoaXBraWxsIEVDQyIsCisJIm1hc3RlciBhYm9ydCIsCisJInRhcmdldCBhYm9ydCIsCisJInBhcml0eSBlcnJvciIsCisJIndhdGNoZG9nIHRpbWVvdXQiLAorCSJpbnZhbGlkIGFkZHJlc3MiLAorCSJtaXJyb3IgQnJva2VuIiwKKwkibWVtb3J5IHNwYXJpbmciLAorCSJzY3J1YiBjb3JyZWN0ZWQgZXJyb3IiLAorCSJzY3J1YiB1bmNvcnJlY3RlZCBlcnJvciIsCit9OworCitzdGF0aWMgdm9pZCBjcGVyX3ByaW50X21lbShjb25zdCBjaGFyICpwZngsIGNvbnN0IHN0cnVjdCBjcGVyX3NlY19tZW1fZXJyICptZW0pCit7CisJaWYgKG1lbS0+dmFsaWRhdGlvbl9iaXRzICYgQ1BFUl9NRU1fVkFMSURfRVJST1JfU1RBVFVTKQorCQlwcmludGsoIiVzIiJlcnJvcl9zdGF0dXM6IDB4JTAxNmxseFxuIiwgcGZ4LCBtZW0tPmVycm9yX3N0YXR1cyk7CisJaWYgKG1lbS0+dmFsaWRhdGlvbl9iaXRzICYgQ1BFUl9NRU1fVkFMSURfUEhZU0lDQUxfQUREUkVTUykKKwkJcHJpbnRrKCIlcyIicGh5c2ljYWxfYWRkcmVzczogMHglMDE2bGx4XG4iLAorCQkgICAgICAgcGZ4LCBtZW0tPnBoeXNpY2FsX2FkZHIpOworCWlmIChtZW0tPnZhbGlkYXRpb25fYml0cyAmIENQRVJfTUVNX1ZBTElEX1BIWVNJQ0FMX0FERFJFU1NfTUFTSykKKwkJcHJpbnRrKCIlcyIicGh5c2ljYWxfYWRkcmVzc19tYXNrOiAweCUwMTZsbHhcbiIsCisJCSAgICAgICBwZngsIG1lbS0+cGh5c2ljYWxfYWRkcl9tYXNrKTsKKwlpZiAobWVtLT52YWxpZGF0aW9uX2JpdHMgJiBDUEVSX01FTV9WQUxJRF9OT0RFKQorCQlwcmludGsoIiVzIiJub2RlOiAlZFxuIiwgcGZ4LCBtZW0tPm5vZGUpOworCWlmIChtZW0tPnZhbGlkYXRpb25fYml0cyAmIENQRVJfTUVNX1ZBTElEX0NBUkQpCisJCXByaW50aygiJXMiImNhcmQ6ICVkXG4iLCBwZngsIG1lbS0+Y2FyZCk7CisJaWYgKG1lbS0+dmFsaWRhdGlvbl9iaXRzICYgQ1BFUl9NRU1fVkFMSURfTU9EVUxFKQorCQlwcmludGsoIiVzIiJtb2R1bGU6ICVkXG4iLCBwZngsIG1lbS0+bW9kdWxlKTsKKwlpZiAobWVtLT52YWxpZGF0aW9uX2JpdHMgJiBDUEVSX01FTV9WQUxJRF9CQU5LKQorCQlwcmludGsoIiVzIiJiYW5rOiAlZFxuIiwgcGZ4LCBtZW0tPmJhbmspOworCWlmIChtZW0tPnZhbGlkYXRpb25fYml0cyAmIENQRVJfTUVNX1ZBTElEX0RFVklDRSkKKwkJcHJpbnRrKCIlcyIiZGV2aWNlOiAlZFxuIiwgcGZ4LCBtZW0tPmRldmljZSk7CisJaWYgKG1lbS0+dmFsaWRhdGlvbl9iaXRzICYgQ1BFUl9NRU1fVkFMSURfUk9XKQorCQlwcmludGsoIiVzIiJyb3c6ICVkXG4iLCBwZngsIG1lbS0+cm93KTsKKwlpZiAobWVtLT52YWxpZGF0aW9uX2JpdHMgJiBDUEVSX01FTV9WQUxJRF9DT0xVTU4pCisJCXByaW50aygiJXMiImNvbHVtbjogJWRcbiIsIHBmeCwgbWVtLT5jb2x1bW4pOworCWlmIChtZW0tPnZhbGlkYXRpb25fYml0cyAmIENQRVJfTUVNX1ZBTElEX0JJVF9QT1NJVElPTikKKwkJcHJpbnRrKCIlcyIiYml0X3Bvc2l0aW9uOiAlZFxuIiwgcGZ4LCBtZW0tPmJpdF9wb3MpOworCWlmIChtZW0tPnZhbGlkYXRpb25fYml0cyAmIENQRVJfTUVNX1ZBTElEX1JFUVVFU1RPUl9JRCkKKwkJcHJpbnRrKCIlcyIicmVxdWVzdG9yX2lkOiAweCUwMTZsbHhcbiIsIHBmeCwgbWVtLT5yZXF1ZXN0b3JfaWQpOworCWlmIChtZW0tPnZhbGlkYXRpb25fYml0cyAmIENQRVJfTUVNX1ZBTElEX1JFU1BPTkRFUl9JRCkKKwkJcHJpbnRrKCIlcyIicmVzcG9uZGVyX2lkOiAweCUwMTZsbHhcbiIsIHBmeCwgbWVtLT5yZXNwb25kZXJfaWQpOworCWlmIChtZW0tPnZhbGlkYXRpb25fYml0cyAmIENQRVJfTUVNX1ZBTElEX1RBUkdFVF9JRCkKKwkJcHJpbnRrKCIlcyIidGFyZ2V0X2lkOiAweCUwMTZsbHhcbiIsIHBmeCwgbWVtLT50YXJnZXRfaWQpOworCWlmIChtZW0tPnZhbGlkYXRpb25fYml0cyAmIENQRVJfTUVNX1ZBTElEX0VSUk9SX1RZUEUpIHsKKwkJdTggZXR5cGUgPSBtZW0tPmVycm9yX3R5cGU7CisJCXByaW50aygiJXMiImVycm9yX3R5cGU6ICVkLCAlc1xuIiwgcGZ4LCBldHlwZSwKKwkJICAgICAgIGV0eXBlIDwgQVJSQVlfU0laRShjcGVyX21lbV9lcnJfdHlwZV9zdHJzKSA/CisJCSAgICAgICBjcGVyX21lbV9lcnJfdHlwZV9zdHJzW2V0eXBlXSA6ICJ1bmtub3duIik7CisJfQorfQorCitzdGF0aWMgY29uc3QgY2hhciAqY3Blcl9wY2llX3BvcnRfdHlwZV9zdHJzW10gPSB7CisJIlBDSWUgZW5kIHBvaW50IiwKKwkibGVnYWN5IFBDSSBlbmQgcG9pbnQiLAorCSJ1bmtub3duIiwKKwkidW5rbm93biIsCisJInJvb3QgcG9ydCIsCisJInVwc3RyZWFtIHN3aXRjaCBwb3J0IiwKKwkiZG93bnN0cmVhbSBzd2l0Y2ggcG9ydCIsCisJIlBDSWUgdG8gUENJL1BDSS1YIGJyaWRnZSIsCisJIlBDSS9QQ0ktWCB0byBQQ0llIGJyaWRnZSIsCisJInJvb3QgY29tcGxleCBpbnRlZ3JhdGVkIGVuZHBvaW50IGRldmljZSIsCisJInJvb3QgY29tcGxleCBldmVudCBjb2xsZWN0b3IiLAorfTsKKworc3RhdGljIHZvaWQgY3Blcl9wcmludF9wY2llKGNvbnN0IGNoYXIgKnBmeCwgY29uc3Qgc3RydWN0IGNwZXJfc2VjX3BjaWUgKnBjaWUpCit7CisJaWYgKHBjaWUtPnZhbGlkYXRpb25fYml0cyAmIENQRVJfUENJRV9WQUxJRF9QT1JUX1RZUEUpCisJCXByaW50aygiJXMiInBvcnRfdHlwZTogJWQsICVzXG4iLCBwZngsIHBjaWUtPnBvcnRfdHlwZSwKKwkJICAgICAgIHBjaWUtPnBvcnRfdHlwZSA8IEFSUkFZX1NJWkUoY3Blcl9wY2llX3BvcnRfdHlwZV9zdHJzKSA/CisJCSAgICAgICBjcGVyX3BjaWVfcG9ydF90eXBlX3N0cnNbcGNpZS0+cG9ydF90eXBlXSA6ICJ1bmtub3duIik7CisJaWYgKHBjaWUtPnZhbGlkYXRpb25fYml0cyAmIENQRVJfUENJRV9WQUxJRF9WRVJTSU9OKQorCQlwcmludGsoIiVzIiJ2ZXJzaW9uOiAlZC4lZFxuIiwgcGZ4LAorCQkgICAgICAgcGNpZS0+dmVyc2lvbi5tYWpvciwgcGNpZS0+dmVyc2lvbi5taW5vcik7CisJaWYgKHBjaWUtPnZhbGlkYXRpb25fYml0cyAmIENQRVJfUENJRV9WQUxJRF9DT01NQU5EX1NUQVRVUykKKwkJcHJpbnRrKCIlcyIiY29tbWFuZDogMHglMDR4LCBzdGF0dXM6IDB4JTA0eFxuIiwgcGZ4LAorCQkgICAgICAgcGNpZS0+Y29tbWFuZCwgcGNpZS0+c3RhdHVzKTsKKwlpZiAocGNpZS0+dmFsaWRhdGlvbl9iaXRzICYgQ1BFUl9QQ0lFX1ZBTElEX0RFVklDRV9JRCkgeworCQljb25zdCBfX3U4ICpwOworCQlwcmludGsoIiVzIiJkZXZpY2VfaWQ6ICUwNHg6JTAyeDolMDJ4LiV4XG4iLCBwZngsCisJCSAgICAgICBwY2llLT5kZXZpY2VfaWQuc2VnbWVudCwgcGNpZS0+ZGV2aWNlX2lkLmJ1cywKKwkJICAgICAgIHBjaWUtPmRldmljZV9pZC5kZXZpY2UsIHBjaWUtPmRldmljZV9pZC5mdW5jdGlvbik7CisJCXByaW50aygiJXMiInNsb3Q6ICVkXG4iLCBwZngsCisJCSAgICAgICBwY2llLT5kZXZpY2VfaWQuc2xvdCA+PiBDUEVSX1BDSUVfU0xPVF9TSElGVCk7CisJCXByaW50aygiJXMiInNlY29uZGFyeV9idXM6IDB4JTAyeFxuIiwgcGZ4LAorCQkgICAgICAgcGNpZS0+ZGV2aWNlX2lkLnNlY29uZGFyeV9idXMpOworCQlwcmludGsoIiVzIiJ2ZW5kb3JfaWQ6IDB4JTA0eCwgZGV2aWNlX2lkOiAweCUwNHhcbiIsIHBmeCwKKwkJICAgICAgIHBjaWUtPmRldmljZV9pZC52ZW5kb3JfaWQsIHBjaWUtPmRldmljZV9pZC5kZXZpY2VfaWQpOworCQlwID0gcGNpZS0+ZGV2aWNlX2lkLmNsYXNzX2NvZGU7CisJCXByaW50aygiJXMiImNsYXNzX2NvZGU6ICUwMnglMDJ4JTAyeFxuIiwgcGZ4LCBwWzBdLCBwWzFdLCBwWzJdKTsKKwl9CisJaWYgKHBjaWUtPnZhbGlkYXRpb25fYml0cyAmIENQRVJfUENJRV9WQUxJRF9TRVJJQUxfTlVNQkVSKQorCQlwcmludGsoIiVzIiJzZXJpYWwgbnVtYmVyOiAweCUwNHgsIDB4JTA0eFxuIiwgcGZ4LAorCQkgICAgICAgcGNpZS0+c2VyaWFsX251bWJlci5sb3dlciwgcGNpZS0+c2VyaWFsX251bWJlci51cHBlcik7CisJaWYgKHBjaWUtPnZhbGlkYXRpb25fYml0cyAmIENQRVJfUENJRV9WQUxJRF9CUklER0VfQ09OVFJPTF9TVEFUVVMpCisJCXByaW50aygKKwkiJXMiImJyaWRnZTogc2Vjb25kYXJ5X3N0YXR1czogMHglMDR4LCBjb250cm9sOiAweCUwNHhcbiIsCisJcGZ4LCBwY2llLT5icmlkZ2Uuc2Vjb25kYXJ5X3N0YXR1cywgcGNpZS0+YnJpZGdlLmNvbnRyb2wpOworfQorCitzdGF0aWMgY29uc3QgY2hhciAqYXBlaV9lc3RhdHVzX3NlY3Rpb25fZmxhZ19zdHJzW10gPSB7CisJInByaW1hcnkiLAorCSJjb250YWlubWVudCB3YXJuaW5nIiwKKwkicmVzZXQiLAorCSJ0aHJlc2hvbGQgZXhjZWVkZWQiLAorCSJyZXNvdXJjZSBub3QgYWNjZXNzaWJsZSIsCisJImxhdGVudCBlcnJvciIsCit9OworCitzdGF0aWMgdm9pZCBhcGVpX2VzdGF0dXNfcHJpbnRfc2VjdGlvbigKKwljb25zdCBjaGFyICpwZngsIGNvbnN0IHN0cnVjdCBhY3BpX2hlc3RfZ2VuZXJpY19kYXRhICpnZGF0YSwgaW50IHNlY19ubykKK3sKKwl1dWlkX2xlICpzZWNfdHlwZSA9ICh1dWlkX2xlICopZ2RhdGEtPnNlY3Rpb25fdHlwZTsKKwlfX3UxNiBzZXZlcml0eTsKKworCXNldmVyaXR5ID0gZ2RhdGEtPmVycm9yX3NldmVyaXR5OworCXByaW50aygiJXMiInNlY3Rpb246ICVkLCBzZXZlcml0eTogJWQsICVzXG4iLCBwZngsIHNlY19ubywgc2V2ZXJpdHksCisJICAgICAgIGNwZXJfc2V2ZXJpdHlfc3RyKHNldmVyaXR5KSk7CisJcHJpbnRrKCIlcyIiZmxhZ3M6IDB4JTAyeFxuIiwgcGZ4LCBnZGF0YS0+ZmxhZ3MpOworCWNwZXJfcHJpbnRfYml0cyhwZngsIGdkYXRhLT5mbGFncywgYXBlaV9lc3RhdHVzX3NlY3Rpb25fZmxhZ19zdHJzLAorCQkJQVJSQVlfU0laRShhcGVpX2VzdGF0dXNfc2VjdGlvbl9mbGFnX3N0cnMpKTsKKwlpZiAoZ2RhdGEtPnZhbGlkYXRpb25fYml0cyAmIENQRVJfU0VDX1ZBTElEX0ZSVV9JRCkKKwkJcHJpbnRrKCIlcyIiZnJ1X2lkOiAlcFVsXG4iLCBwZngsICh1dWlkX2xlICopZ2RhdGEtPmZydV9pZCk7CisJaWYgKGdkYXRhLT52YWxpZGF0aW9uX2JpdHMgJiBDUEVSX1NFQ19WQUxJRF9GUlVfVEVYVCkKKwkJcHJpbnRrKCIlcyIiZnJ1X3RleHQ6ICUuMjBzXG4iLCBwZngsIGdkYXRhLT5mcnVfdGV4dCk7CisKKwlpZiAoIXV1aWRfbGVfY21wKCpzZWNfdHlwZSwgQ1BFUl9TRUNfUFJPQ19HRU5FUklDKSkgeworCQlzdHJ1Y3QgY3Blcl9zZWNfcHJvY19nZW5lcmljICpwcm9jX2VyciA9ICh2b2lkICopKGdkYXRhICsgMSk7CisJCXByaW50aygiJXMiInNlY3Rpb25fdHlwZTogZ2VuZXJhbCBwcm9jZXNzb3IgZXJyb3JcbiIsIHBmeCk7CisJCWlmIChnZGF0YS0+ZXJyb3JfZGF0YV9sZW5ndGggPj0gc2l6ZW9mKCpwcm9jX2VycikpCisJCQljcGVyX3ByaW50X3Byb2NfZ2VuZXJpYyhwZngsIHByb2NfZXJyKTsKKwkJZWxzZQorCQkJZ290byBlcnJfc2VjdGlvbl90b29fc21hbGw7CisJfSBlbHNlIGlmICghdXVpZF9sZV9jbXAoKnNlY190eXBlLCBDUEVSX1NFQ19QTEFURk9STV9NRU0pKSB7CisJCXN0cnVjdCBjcGVyX3NlY19tZW1fZXJyICptZW1fZXJyID0gKHZvaWQgKikoZ2RhdGEgKyAxKTsKKwkJcHJpbnRrKCIlcyIic2VjdGlvbl90eXBlOiBtZW1vcnkgZXJyb3JcbiIsIHBmeCk7CisJCWlmIChnZGF0YS0+ZXJyb3JfZGF0YV9sZW5ndGggPj0gc2l6ZW9mKCptZW1fZXJyKSkKKwkJCWNwZXJfcHJpbnRfbWVtKHBmeCwgbWVtX2Vycik7CisJCWVsc2UKKwkJCWdvdG8gZXJyX3NlY3Rpb25fdG9vX3NtYWxsOworCX0gZWxzZSBpZiAoIXV1aWRfbGVfY21wKCpzZWNfdHlwZSwgQ1BFUl9TRUNfUENJRSkpIHsKKwkJc3RydWN0IGNwZXJfc2VjX3BjaWUgKnBjaWUgPSAodm9pZCAqKShnZGF0YSArIDEpOworCQlwcmludGsoIiVzIiJzZWN0aW9uX3R5cGU6IFBDSWUgZXJyb3JcbiIsIHBmeCk7CisJCWlmIChnZGF0YS0+ZXJyb3JfZGF0YV9sZW5ndGggPj0gc2l6ZW9mKCpwY2llKSkKKwkJCWNwZXJfcHJpbnRfcGNpZShwZngsIHBjaWUpOworCQllbHNlCisJCQlnb3RvIGVycl9zZWN0aW9uX3Rvb19zbWFsbDsKKwl9IGVsc2UKKwkJcHJpbnRrKCIlcyIic2VjdGlvbiB0eXBlOiB1bmtub3duLCAlcFVsXG4iLCBwZngsIHNlY190eXBlKTsKKworCXJldHVybjsKKworZXJyX3NlY3Rpb25fdG9vX3NtYWxsOgorCXByX2VycihGV19XQVJOICJlcnJvciBzZWN0aW9uIGxlbmd0aCBpcyB0b28gc21hbGxcbiIpOworfQorCit2b2lkIGFwZWlfZXN0YXR1c19wcmludChjb25zdCBjaGFyICpwZngsCisJCQljb25zdCBzdHJ1Y3QgYWNwaV9oZXN0X2dlbmVyaWNfc3RhdHVzICplc3RhdHVzKQoreworCXN0cnVjdCBhY3BpX2hlc3RfZ2VuZXJpY19kYXRhICpnZGF0YTsKKwl1bnNpZ25lZCBpbnQgZGF0YV9sZW4sIGdlZGF0YV9sZW47CisJaW50IHNlY19ubyA9IDA7CisJX191MTYgc2V2ZXJpdHk7CisKKwlwcmludGsoIiVzIiJBUEVJIGdlbmVyaWMgaGFyZHdhcmUgZXJyb3Igc3RhdHVzXG4iLCBwZngpOworCXNldmVyaXR5ID0gZXN0YXR1cy0+ZXJyb3Jfc2V2ZXJpdHk7CisJcHJpbnRrKCIlcyIic2V2ZXJpdHk6ICVkLCAlc1xuIiwgcGZ4LCBzZXZlcml0eSwKKwkgICAgICAgY3Blcl9zZXZlcml0eV9zdHIoc2V2ZXJpdHkpKTsKKwlkYXRhX2xlbiA9IGVzdGF0dXMtPmRhdGFfbGVuZ3RoOworCWdkYXRhID0gKHN0cnVjdCBhY3BpX2hlc3RfZ2VuZXJpY19kYXRhICopKGVzdGF0dXMgKyAxKTsKKwl3aGlsZSAoZGF0YV9sZW4gPiBzaXplb2YoKmdkYXRhKSkgeworCQlnZWRhdGFfbGVuID0gZ2RhdGEtPmVycm9yX2RhdGFfbGVuZ3RoOworCQlhcGVpX2VzdGF0dXNfcHJpbnRfc2VjdGlvbihwZngsIGdkYXRhLCBzZWNfbm8pOworCQlkYXRhX2xlbiAtPSBnZWRhdGFfbGVuICsgc2l6ZW9mKCpnZGF0YSk7CisJCXNlY19ubysrOworCX0KK30KK0VYUE9SVF9TWU1CT0xfR1BMKGFwZWlfZXN0YXR1c19wcmludCk7CisKIGludCBhcGVpX2VzdGF0dXNfY2hlY2tfaGVhZGVyKGNvbnN0IHN0cnVjdCBhY3BpX2hlc3RfZ2VuZXJpY19zdGF0dXMgKmVzdGF0dXMpCiB7CiAJaWYgKGVzdGF0dXMtPmRhdGFfbGVuZ3RoICYmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYXBlaS9naGVzLmMgYi9kcml2ZXJzL2FjcGkvYXBlaS9naGVzLmMKaW5kZXggMGQ1MDVlNS4uZDFkNDg0ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FwZWkvZ2hlcy5jCisrKyBiL2RyaXZlcnMvYWNwaS9hcGVpL2doZXMuYwpAQCAtMTIsMTAgKzEyLDYgQEAKICAqIEZvciBtb3JlIGluZm9ybWF0aW9uIGFib3V0IEdlbmVyaWMgSGFyZHdhcmUgRXJyb3IgU291cmNlLCBwbGVhc2UKICAqIHJlZmVyIHRvIEFDUEkgU3BlY2lmaWNhdGlvbiB2ZXJzaW9uIDQuMCwgc2VjdGlvbiAxNy4zLjIuNgogICoKLSAqIE5vdywgb25seSBTQ0kgbm90aWZpY2F0aW9uIHR5cGUgYW5kIG1lbW9yeSBlcnJvcnMgYXJlCi0gKiBzdXBwb3J0ZWQuIE1vcmUgbm90aWZpY2F0aW9uIHR5cGUgYW5kIGhhcmR3YXJlIGVycm9yIHR5cGUgd2lsbCBiZQotICogYWRkZWQgbGF0ZXIuCi0gKgogICogQ29weXJpZ2h0IDIwMTAgSW50ZWwgQ29ycC4KICAqICAgQXV0aG9yOiBIdWFuZyBZaW5nIDx5aW5nLmh1YW5nQGludGVsLmNvbT4KICAqCkBAIC0zOSwxNCArMzUsMTggQEAKICNpbmNsdWRlIDxsaW51eC9hY3BpLmg+CiAjaW5jbHVkZSA8bGludXgvaW8uaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC90aW1lci5oPgogI2luY2x1ZGUgPGxpbnV4L2NwZXIuaD4KICNpbmNsdWRlIDxsaW51eC9rZGVidWcuaD4KICNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9tdXRleC5oPgorI2luY2x1ZGUgPGxpbnV4L3JhdGVsaW1pdC5oPgorI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KICNpbmNsdWRlIDxhY3BpL2FwZWkuaD4KICNpbmNsdWRlIDxhY3BpL2F0b21pY2lvLmg+CiAjaW5jbHVkZSA8YWNwaS9oZWQuaD4KICNpbmNsdWRlIDxhc20vbWNlLmg+CisjaW5jbHVkZSA8YXNtL3RsYmZsdXNoLmg+CiAKICNpbmNsdWRlICJhcGVpLWludGVybmFsLmgiCiAKQEAgLTU1LDQyICs1NSwxMzEgQEAKICNkZWZpbmUgR0hFU19FU1RBVFVTX01BWF9TSVpFCQk2NTUzNgogCiAvKgotICogT25lIHN0cnVjdCBnaGVzIGlzIGNyZWF0ZWQgZm9yIGVhY2ggZ2VuZXJpYyBoYXJkd2FyZSBlcnJvcgotICogc291cmNlLgotICoKKyAqIE9uZSBzdHJ1Y3QgZ2hlcyBpcyBjcmVhdGVkIGZvciBlYWNoIGdlbmVyaWMgaGFyZHdhcmUgZXJyb3Igc291cmNlLgogICogSXQgcHJvdmlkZXMgdGhlIGNvbnRleHQgZm9yIEFQRUkgaGFyZHdhcmUgZXJyb3IgdGltZXIvSVJRL1NDSS9OTUkKLSAqIGhhbmRsZXIuIEhhbmRsZXIgZm9yIG9uZSBnZW5lcmljIGhhcmR3YXJlIGVycm9yIHNvdXJjZSBpcyBvbmx5Ci0gKiB0cmlnZ2VyZWQgYWZ0ZXIgdGhlIHByZXZpb3VzIG9uZSBpcyBkb25lLiBTbyBoYW5kbGVyIGNhbiB1c2VzCi0gKiBzdHJ1Y3QgZ2hlcyB3aXRob3V0IGxvY2tpbmcuCisgKiBoYW5kbGVyLgogICoKICAqIGVzdGF0dXM6IG1lbW9yeSBidWZmZXIgZm9yIGVycm9yIHN0YXR1cyBibG9jaywgYWxsb2NhdGVkIGR1cmluZwogICogSEVTVCBwYXJzaW5nLgogICovCiAjZGVmaW5lIEdIRVNfVE9fQ0xFQVIJCTB4MDAwMQorI2RlZmluZSBHSEVTX0VYSVRJTkcJCTB4MDAwMgogCiBzdHJ1Y3QgZ2hlcyB7CiAJc3RydWN0IGFjcGlfaGVzdF9nZW5lcmljICpnZW5lcmljOwogCXN0cnVjdCBhY3BpX2hlc3RfZ2VuZXJpY19zdGF0dXMgKmVzdGF0dXM7Ci0Jc3RydWN0IGxpc3RfaGVhZCBsaXN0OwogCXU2NCBidWZmZXJfcGFkZHI7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKKwl1bmlvbiB7CisJCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKKwkJc3RydWN0IHRpbWVyX2xpc3QgdGltZXI7CisJCXVuc2lnbmVkIGludCBpcnE7CisJfTsKIH07CiAKK3N0YXRpYyBpbnQgZ2hlc19wYW5pY190aW1lb3V0CV9fcmVhZF9tb3N0bHkgPSAzMDsKKwogLyoKLSAqIEVycm9yIHNvdXJjZSBsaXN0cywgb25lIGxpc3QgZm9yIGVhY2ggbm90aWZpY2F0aW9uIG1ldGhvZC4gVGhlCi0gKiBtZW1iZXJzIGluIGxpc3RzIGFyZSBzdHJ1Y3QgZ2hlcy4KKyAqIEFsbCBlcnJvciBzb3VyY2VzIG5vdGlmaWVkIHdpdGggU0NJIHNoYXJlcyBvbmUgbm90aWZpZXIgZnVuY3Rpb24sCisgKiBzbyB0aGV5IG5lZWQgdG8gYmUgbGlua2VkIGFuZCBjaGVja2VkIG9uZSBieSBvbmUuICBUaGlzIGlzIGFwcGxpZWQKKyAqIHRvIE5NSSB0b28uCiAgKgotICogVGhlIGxpc3QgbWVtYmVycyBhcmUgb25seSBhZGRlZCBpbiBIRVNUIHBhcnNpbmcgYW5kIGRlbGV0ZWQgZHVyaW5nCi0gKiBtb2R1bGVfZXhpdCwgdGhhdCBpcywgc2luZ2xlLXRocmVhZGVkLiBTbyBubyBsb2NrIGlzIG5lZWRlZCBmb3IKLSAqIHRoYXQuCi0gKgotICogQnV0IHRoZSBtdXR1YWwgZXhjbHVzaW9uIGlzIG5lZWRlZCBiZXR3ZWVuIG1lbWJlcnMgYWRkaW5nL2RlbGV0aW5nCi0gKiBhbmQgdGltZXIvSVJRL1NDSS9OTUkgaGFuZGxlciwgd2hpY2ggbWF5IHRyYXZlcnNlIHRoZSBsaXN0LiBSQ1UgaXMKLSAqIHVzZWQgZm9yIHRoYXQuCisgKiBSQ1UgaXMgdXNlZCBmb3IgdGhlc2UgbGlzdHMsIHNvIGdoZXNfbGlzdF9tdXRleCBpcyBvbmx5IHVzZWQgZm9yCisgKiBsaXN0IGNoYW5naW5nLCBub3QgZm9yIHRyYXZlcnNpbmcuCiAgKi8KIHN0YXRpYyBMSVNUX0hFQUQoZ2hlc19zY2kpOworc3RhdGljIExJU1RfSEVBRChnaGVzX25taSk7CiBzdGF0aWMgREVGSU5FX01VVEVYKGdoZXNfbGlzdF9tdXRleCk7CiAKKy8qCisgKiBOTUkgbWF5IGJlIHRyaWdnZXJlZCBvbiBhbnkgQ1BVLCBzbyBnaGVzX25taV9sb2NrIGlzIHVzZWQgZm9yCisgKiBtdXR1YWwgZXhjbHVzaW9uLgorICovCitzdGF0aWMgREVGSU5FX1JBV19TUElOTE9DSyhnaGVzX25taV9sb2NrKTsKKworLyoKKyAqIEJlY2F1c2UgdGhlIG1lbW9yeSBhcmVhIHVzZWQgdG8gdHJhbnNmZXIgaGFyZHdhcmUgZXJyb3IgaW5mb3JtYXRpb24KKyAqIGZyb20gQklPUyB0byBMaW51eCBjYW4gYmUgZGV0ZXJtaW5lZCBvbmx5IGluIE5NSSwgSVJRIG9yIHRpbWVyCisgKiBoYW5kbGVyLCBidXQgZ2VuZXJhbCBpb3JlbWFwIGNhbiBub3QgYmUgdXNlZCBpbiBhdG9taWMgY29udGV4dCwgc28KKyAqIGEgc3BlY2lhbCB2ZXJzaW9uIG9mIGF0b21pYyBpb3JlbWFwIGlzIGltcGxlbWVudGVkIGZvciB0aGF0LgorICovCisKKy8qCisgKiBUd28gdmlydHVhbCBwYWdlcyBhcmUgdXNlZCwgb25lIGZvciBOTUkgY29udGV4dCwgdGhlIG90aGVyIGZvcgorICogSVJRL1BST0NFU1MgY29udGV4dAorICovCisjZGVmaW5lIEdIRVNfSU9SRU1BUF9QQUdFUwkJMgorI2RlZmluZSBHSEVTX0lPUkVNQVBfTk1JX1BBR0UoYmFzZSkJKGJhc2UpCisjZGVmaW5lIEdIRVNfSU9SRU1BUF9JUlFfUEFHRShiYXNlKQkoKGJhc2UpICsgUEFHRV9TSVpFKQorCisvKiB2aXJ0dWFsIG1lbW9yeSBhcmVhIGZvciBhdG9taWMgaW9yZW1hcCAqLworc3RhdGljIHN0cnVjdCB2bV9zdHJ1Y3QgKmdoZXNfaW9yZW1hcF9hcmVhOworLyoKKyAqIFRoZXNlIDIgc3BpbmxvY2sgaXMgdXNlZCB0byBwcmV2ZW50IGF0b21pYyBpb3JlbWFwIHZpcnR1YWwgbWVtb3J5CisgKiBhcmVhIGZyb20gYmVpbmcgbWFwcGVkIHNpbXVsdGFuZW91c2x5LgorICovCitzdGF0aWMgREVGSU5FX1JBV19TUElOTE9DSyhnaGVzX2lvcmVtYXBfbG9ja19ubWkpOworc3RhdGljIERFRklORV9TUElOTE9DSyhnaGVzX2lvcmVtYXBfbG9ja19pcnEpOworCitzdGF0aWMgaW50IGdoZXNfaW9yZW1hcF9pbml0KHZvaWQpCit7CisJZ2hlc19pb3JlbWFwX2FyZWEgPSBfX2dldF92bV9hcmVhKFBBR0VfU0laRSAqIEdIRVNfSU9SRU1BUF9QQUdFUywKKwkJVk1fSU9SRU1BUCwgVk1BTExPQ19TVEFSVCwgVk1BTExPQ19FTkQpOworCWlmICghZ2hlc19pb3JlbWFwX2FyZWEpIHsKKwkJcHJfZXJyKEdIRVNfUEZYICJGYWlsZWQgdG8gYWxsb2NhdGUgdmlydHVhbCBtZW1vcnkgYXJlYSBmb3IgYXRvbWljIGlvcmVtYXAuXG4iKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIGdoZXNfaW9yZW1hcF9leGl0KHZvaWQpCit7CisJZnJlZV92bV9hcmVhKGdoZXNfaW9yZW1hcF9hcmVhKTsKK30KKworc3RhdGljIHZvaWQgX19pb21lbSAqZ2hlc19pb3JlbWFwX3Bmbl9ubWkodTY0IHBmbikKK3sKKwl1bnNpZ25lZCBsb25nIHZhZGRyOworCisJdmFkZHIgPSAodW5zaWduZWQgbG9uZylHSEVTX0lPUkVNQVBfTk1JX1BBR0UoZ2hlc19pb3JlbWFwX2FyZWEtPmFkZHIpOworCWlvcmVtYXBfcGFnZV9yYW5nZSh2YWRkciwgdmFkZHIgKyBQQUdFX1NJWkUsCisJCQkgICBwZm4gPDwgUEFHRV9TSElGVCwgUEFHRV9LRVJORUwpOworCisJcmV0dXJuICh2b2lkIF9faW9tZW0gKil2YWRkcjsKK30KKworc3RhdGljIHZvaWQgX19pb21lbSAqZ2hlc19pb3JlbWFwX3Bmbl9pcnEodTY0IHBmbikKK3sKKwl1bnNpZ25lZCBsb25nIHZhZGRyOworCisJdmFkZHIgPSAodW5zaWduZWQgbG9uZylHSEVTX0lPUkVNQVBfSVJRX1BBR0UoZ2hlc19pb3JlbWFwX2FyZWEtPmFkZHIpOworCWlvcmVtYXBfcGFnZV9yYW5nZSh2YWRkciwgdmFkZHIgKyBQQUdFX1NJWkUsCisJCQkgICBwZm4gPDwgUEFHRV9TSElGVCwgUEFHRV9LRVJORUwpOworCisJcmV0dXJuICh2b2lkIF9faW9tZW0gKil2YWRkcjsKK30KKworc3RhdGljIHZvaWQgZ2hlc19pb3VubWFwX25taSh2b2lkIF9faW9tZW0gKnZhZGRyX3B0cikKK3sKKwl1bnNpZ25lZCBsb25nIHZhZGRyID0gKHVuc2lnbmVkIGxvbmcgX19mb3JjZSl2YWRkcl9wdHI7CisJdm9pZCAqYmFzZSA9IGdoZXNfaW9yZW1hcF9hcmVhLT5hZGRyOworCisJQlVHX09OKHZhZGRyICE9ICh1bnNpZ25lZCBsb25nKUdIRVNfSU9SRU1BUF9OTUlfUEFHRShiYXNlKSk7CisJdW5tYXBfa2VybmVsX3JhbmdlX25vZmx1c2godmFkZHIsIFBBR0VfU0laRSk7CisJX19mbHVzaF90bGJfb25lKHZhZGRyKTsKK30KKworc3RhdGljIHZvaWQgZ2hlc19pb3VubWFwX2lycSh2b2lkIF9faW9tZW0gKnZhZGRyX3B0cikKK3sKKwl1bnNpZ25lZCBsb25nIHZhZGRyID0gKHVuc2lnbmVkIGxvbmcgX19mb3JjZSl2YWRkcl9wdHI7CisJdm9pZCAqYmFzZSA9IGdoZXNfaW9yZW1hcF9hcmVhLT5hZGRyOworCisJQlVHX09OKHZhZGRyICE9ICh1bnNpZ25lZCBsb25nKUdIRVNfSU9SRU1BUF9JUlFfUEFHRShiYXNlKSk7CisJdW5tYXBfa2VybmVsX3JhbmdlX25vZmx1c2godmFkZHIsIFBBR0VfU0laRSk7CisJX19mbHVzaF90bGJfb25lKHZhZGRyKTsKK30KKwogc3RhdGljIHN0cnVjdCBnaGVzICpnaGVzX25ldyhzdHJ1Y3QgYWNwaV9oZXN0X2dlbmVyaWMgKmdlbmVyaWMpCiB7CiAJc3RydWN0IGdoZXMgKmdoZXM7CkBAIC0xMDEsNyArMTkwLDYgQEAKIAlpZiAoIWdoZXMpCiAJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwogCWdoZXMtPmdlbmVyaWMgPSBnZW5lcmljOwotCUlOSVRfTElTVF9IRUFEKCZnaGVzLT5saXN0KTsKIAlyYyA9IGFjcGlfcHJlX21hcF9nYXIoJmdlbmVyaWMtPmVycm9yX3N0YXR1c19hZGRyZXNzKTsKIAlpZiAocmMpCiAJCWdvdG8gZXJyX2ZyZWU7CkBAIC0xNTgsMjIgKzI0Niw0MSBAQAogCX0KIH0KIAotLyogU0NJIGhhbmRsZXIgcnVuIGluIHdvcmsgcXVldWUsIHNvIGlvcmVtYXAgY2FuIGJlIHVzZWQgaGVyZSAqLwotc3RhdGljIGludCBnaGVzX2NvcHlfdG9mcm9tX3BoeXModm9pZCAqYnVmZmVyLCB1NjQgcGFkZHIsIHUzMiBsZW4sCi0JCQkJIGludCBmcm9tX3BoeXMpCitzdGF0aWMgdm9pZCBnaGVzX2NvcHlfdG9mcm9tX3BoeXModm9pZCAqYnVmZmVyLCB1NjQgcGFkZHIsIHUzMiBsZW4sCisJCQkJICBpbnQgZnJvbV9waHlzKQogewotCXZvaWQgKnZhZGRyOworCXZvaWQgX19pb21lbSAqdmFkZHI7CisJdW5zaWduZWQgbG9uZyBmbGFncyA9IDA7CisJaW50IGluX25taSA9IGluX25taSgpOworCXU2NCBvZmZzZXQ7CisJdTMyIHRydW5rOwogCi0JdmFkZHIgPSBpb3JlbWFwX2NhY2hlKHBhZGRyLCBsZW4pOwotCWlmICghdmFkZHIpCi0JCXJldHVybiAtRU5PTUVNOwotCWlmIChmcm9tX3BoeXMpCi0JCW1lbWNweShidWZmZXIsIHZhZGRyLCBsZW4pOwotCWVsc2UKLQkJbWVtY3B5KHZhZGRyLCBidWZmZXIsIGxlbik7Ci0JaW91bm1hcCh2YWRkcik7Ci0KLQlyZXR1cm4gMDsKKwl3aGlsZSAobGVuID4gMCkgeworCQlvZmZzZXQgPSBwYWRkciAtIChwYWRkciAmIFBBR0VfTUFTSyk7CisJCWlmIChpbl9ubWkpIHsKKwkJCXJhd19zcGluX2xvY2soJmdoZXNfaW9yZW1hcF9sb2NrX25taSk7CisJCQl2YWRkciA9IGdoZXNfaW9yZW1hcF9wZm5fbm1pKHBhZGRyID4+IFBBR0VfU0hJRlQpOworCQl9IGVsc2UgeworCQkJc3Bpbl9sb2NrX2lycXNhdmUoJmdoZXNfaW9yZW1hcF9sb2NrX2lycSwgZmxhZ3MpOworCQkJdmFkZHIgPSBnaGVzX2lvcmVtYXBfcGZuX2lycShwYWRkciA+PiBQQUdFX1NISUZUKTsKKwkJfQorCQl0cnVuayA9IFBBR0VfU0laRSAtIG9mZnNldDsKKwkJdHJ1bmsgPSBtaW4odHJ1bmssIGxlbik7CisJCWlmIChmcm9tX3BoeXMpCisJCQltZW1jcHlfZnJvbWlvKGJ1ZmZlciwgdmFkZHIgKyBvZmZzZXQsIHRydW5rKTsKKwkJZWxzZQorCQkJbWVtY3B5X3RvaW8odmFkZHIgKyBvZmZzZXQsIGJ1ZmZlciwgdHJ1bmspOworCQlsZW4gLT0gdHJ1bms7CisJCXBhZGRyICs9IHRydW5rOworCQlidWZmZXIgKz0gdHJ1bms7CisJCWlmIChpbl9ubWkpIHsKKwkJCWdoZXNfaW91bm1hcF9ubWkodmFkZHIpOworCQkJcmF3X3NwaW5fdW5sb2NrKCZnaGVzX2lvcmVtYXBfbG9ja19ubWkpOworCQl9IGVsc2UgeworCQkJZ2hlc19pb3VubWFwX2lycSh2YWRkcik7CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZnaGVzX2lvcmVtYXBfbG9ja19pcnEsIGZsYWdzKTsKKwkJfQorCX0KIH0KIAogc3RhdGljIGludCBnaGVzX3JlYWRfZXN0YXR1cyhzdHJ1Y3QgZ2hlcyAqZ2hlcywgaW50IHNpbGVudCkKQEAgLTE5NCwxMCArMzAxLDggQEAKIAlpZiAoIWJ1Zl9wYWRkcikKIAkJcmV0dXJuIC1FTk9FTlQ7CiAKLQlyYyA9IGdoZXNfY29weV90b2Zyb21fcGh5cyhnaGVzLT5lc3RhdHVzLCBidWZfcGFkZHIsCi0JCQkJICAgc2l6ZW9mKCpnaGVzLT5lc3RhdHVzKSwgMSk7Ci0JaWYgKHJjKQotCQlyZXR1cm4gcmM7CisJZ2hlc19jb3B5X3RvZnJvbV9waHlzKGdoZXMtPmVzdGF0dXMsIGJ1Zl9wYWRkciwKKwkJCSAgICAgIHNpemVvZigqZ2hlcy0+ZXN0YXR1cyksIDEpOwogCWlmICghZ2hlcy0+ZXN0YXR1cy0+YmxvY2tfc3RhdHVzKQogCQlyZXR1cm4gLUVOT0VOVDsKIApAQCAtMjEyLDE3ICszMTcsMTUgQEAKIAkJZ290byBlcnJfcmVhZF9ibG9jazsKIAlpZiAoYXBlaV9lc3RhdHVzX2NoZWNrX2hlYWRlcihnaGVzLT5lc3RhdHVzKSkKIAkJZ290byBlcnJfcmVhZF9ibG9jazsKLQlyYyA9IGdoZXNfY29weV90b2Zyb21fcGh5cyhnaGVzLT5lc3RhdHVzICsgMSwKLQkJCQkgICBidWZfcGFkZHIgKyBzaXplb2YoKmdoZXMtPmVzdGF0dXMpLAotCQkJCSAgIGxlbiAtIHNpemVvZigqZ2hlcy0+ZXN0YXR1cyksIDEpOwotCWlmIChyYykKLQkJcmV0dXJuIHJjOworCWdoZXNfY29weV90b2Zyb21fcGh5cyhnaGVzLT5lc3RhdHVzICsgMSwKKwkJCSAgICAgIGJ1Zl9wYWRkciArIHNpemVvZigqZ2hlcy0+ZXN0YXR1cyksCisJCQkgICAgICBsZW4gLSBzaXplb2YoKmdoZXMtPmVzdGF0dXMpLCAxKTsKIAlpZiAoYXBlaV9lc3RhdHVzX2NoZWNrKGdoZXMtPmVzdGF0dXMpKQogCQlnb3RvIGVycl9yZWFkX2Jsb2NrOwogCXJjID0gMDsKIAogZXJyX3JlYWRfYmxvY2s6Ci0JaWYgKHJjICYmICFzaWxlbnQpCisJaWYgKHJjICYmICFzaWxlbnQgJiYgcHJpbnRrX3JhdGVsaW1pdCgpKQogCQlwcl93YXJuaW5nKEZXX1dBUk4gR0hFU19QRlgKIAkJCSAgICJGYWlsZWQgdG8gcmVhZCBlcnJvciBzdGF0dXMgYmxvY2shXG4iKTsKIAlyZXR1cm4gcmM7CkBAIC0yNTUsMTEgKzM1OCwyNiBAQAogCQl9CiAjZW5kaWYKIAl9Cit9CiAKLQlpZiAoIXByb2Nlc3NlZCAmJiBwcmludGtfcmF0ZWxpbWl0KCkpCi0JCXByX3dhcm5pbmcoR0hFU19QRlgKLQkJIlVua25vd24gZXJyb3IgcmVjb3JkIGZyb20gZ2VuZXJpYyBoYXJkd2FyZSBlcnJvciBzb3VyY2U6ICVkXG4iLAotCQkJICAgZ2hlcy0+Z2VuZXJpYy0+aGVhZGVyLnNvdXJjZV9pZCk7CitzdGF0aWMgdm9pZCBnaGVzX3ByaW50X2VzdGF0dXMoY29uc3QgY2hhciAqcGZ4LCBzdHJ1Y3QgZ2hlcyAqZ2hlcykKK3sKKwkvKiBOb3QgbW9yZSB0aGFuIDIgbWVzc2FnZXMgZXZlcnkgNSBzZWNvbmRzICovCisJc3RhdGljIERFRklORV9SQVRFTElNSVRfU1RBVEUocmF0ZWxpbWl0LCA1KkhaLCAyKTsKKworCWlmIChwZnggPT0gTlVMTCkgeworCQlpZiAoZ2hlc19zZXZlcml0eShnaGVzLT5lc3RhdHVzLT5lcnJvcl9zZXZlcml0eSkgPD0KKwkJICAgIEdIRVNfU0VWX0NPUlJFQ1RFRCkKKwkJCXBmeCA9IEtFUk5fV0FSTklORyBIV19FUlI7CisJCWVsc2UKKwkJCXBmeCA9IEtFUk5fRVJSIEhXX0VSUjsKKwl9CisJaWYgKF9fcmF0ZWxpbWl0KCZyYXRlbGltaXQpKSB7CisJCXByaW50aygKKwkiJXMiIkhhcmR3YXJlIGVycm9yIGZyb20gQVBFSSBHZW5lcmljIEhhcmR3YXJlIEVycm9yIFNvdXJjZTogJWRcbiIsCisJcGZ4LCBnaGVzLT5nZW5lcmljLT5oZWFkZXIuc291cmNlX2lkKTsKKwkJYXBlaV9lc3RhdHVzX3ByaW50KHBmeCwgZ2hlcy0+ZXN0YXR1cyk7CisJfQogfQogCiBzdGF0aWMgaW50IGdoZXNfcHJvYyhzdHJ1Y3QgZ2hlcyAqZ2hlcykKQEAgLTI2OSw2ICszODcsNyBAQAogCXJjID0gZ2hlc19yZWFkX2VzdGF0dXMoZ2hlcywgMCk7CiAJaWYgKHJjKQogCQlnb3RvIG91dDsKKwlnaGVzX3ByaW50X2VzdGF0dXMoTlVMTCwgZ2hlcyk7CiAJZ2hlc19kb19wcm9jKGdoZXMpOwogCiBvdXQ6CkBAIC0yNzYsNiArMzk1LDQyIEBACiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyB2b2lkIGdoZXNfYWRkX3RpbWVyKHN0cnVjdCBnaGVzICpnaGVzKQoreworCXN0cnVjdCBhY3BpX2hlc3RfZ2VuZXJpYyAqZyA9IGdoZXMtPmdlbmVyaWM7CisJdW5zaWduZWQgbG9uZyBleHBpcmU7CisKKwlpZiAoIWctPm5vdGlmeS5wb2xsX2ludGVydmFsKSB7CisJCXByX3dhcm5pbmcoRldfV0FSTiBHSEVTX1BGWCAiUG9sbCBpbnRlcnZhbCBpcyAwIGZvciBnZW5lcmljIGhhcmR3YXJlIGVycm9yIHNvdXJjZTogJWQsIGRpc2FibGVkLlxuIiwKKwkJCSAgIGctPmhlYWRlci5zb3VyY2VfaWQpOworCQlyZXR1cm47CisJfQorCWV4cGlyZSA9IGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKGctPm5vdGlmeS5wb2xsX2ludGVydmFsKTsKKwlnaGVzLT50aW1lci5leHBpcmVzID0gcm91bmRfamlmZmllc19yZWxhdGl2ZShleHBpcmUpOworCWFkZF90aW1lcigmZ2hlcy0+dGltZXIpOworfQorCitzdGF0aWMgdm9pZCBnaGVzX3BvbGxfZnVuYyh1bnNpZ25lZCBsb25nIGRhdGEpCit7CisJc3RydWN0IGdoZXMgKmdoZXMgPSAodm9pZCAqKWRhdGE7CisKKwlnaGVzX3Byb2MoZ2hlcyk7CisJaWYgKCEoZ2hlcy0+ZmxhZ3MgJiBHSEVTX0VYSVRJTkcpKQorCQlnaGVzX2FkZF90aW1lcihnaGVzKTsKK30KKworc3RhdGljIGlycXJldHVybl90IGdoZXNfaXJxX2Z1bmMoaW50IGlycSwgdm9pZCAqZGF0YSkKK3sKKwlzdHJ1Y3QgZ2hlcyAqZ2hlcyA9IGRhdGE7CisJaW50IHJjOworCisJcmMgPSBnaGVzX3Byb2MoZ2hlcyk7CisJaWYgKHJjKQorCQlyZXR1cm4gSVJRX05PTkU7CisKKwlyZXR1cm4gSVJRX0hBTkRMRUQ7Cit9CisKIHN0YXRpYyBpbnQgZ2hlc19ub3RpZnlfc2NpKHN0cnVjdCBub3RpZmllcl9ibG9jayAqdGhpcywKIAkJCQkgIHVuc2lnbmVkIGxvbmcgZXZlbnQsIHZvaWQgKmRhdGEpCiB7CkBAIC0yOTIsMTAgKzQ0Nyw2MyBAQAogCXJldHVybiByZXQ7CiB9CiAKK3N0YXRpYyBpbnQgZ2hlc19ub3RpZnlfbm1pKHN0cnVjdCBub3RpZmllcl9ibG9jayAqdGhpcywKKwkJCQkgIHVuc2lnbmVkIGxvbmcgY21kLCB2b2lkICpkYXRhKQoreworCXN0cnVjdCBnaGVzICpnaGVzLCAqZ2hlc19nbG9iYWwgPSBOVUxMOworCWludCBzZXYsIHNldl9nbG9iYWwgPSAtMTsKKwlpbnQgcmV0ID0gTk9USUZZX0RPTkU7CisKKwlpZiAoY21kICE9IERJRV9OTUkpCisJCXJldHVybiByZXQ7CisKKwlyYXdfc3Bpbl9sb2NrKCZnaGVzX25taV9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShnaGVzLCAmZ2hlc19ubWksIGxpc3QpIHsKKwkJaWYgKGdoZXNfcmVhZF9lc3RhdHVzKGdoZXMsIDEpKSB7CisJCQlnaGVzX2NsZWFyX2VzdGF0dXMoZ2hlcyk7CisJCQljb250aW51ZTsKKwkJfQorCQlzZXYgPSBnaGVzX3NldmVyaXR5KGdoZXMtPmVzdGF0dXMtPmVycm9yX3NldmVyaXR5KTsKKwkJaWYgKHNldiA+IHNldl9nbG9iYWwpIHsKKwkJCXNldl9nbG9iYWwgPSBzZXY7CisJCQlnaGVzX2dsb2JhbCA9IGdoZXM7CisJCX0KKwkJcmV0ID0gTk9USUZZX1NUT1A7CisJfQorCisJaWYgKHJldCA9PSBOT1RJRllfRE9ORSkKKwkJZ290byBvdXQ7CisKKwlpZiAoc2V2X2dsb2JhbCA+PSBHSEVTX1NFVl9QQU5JQykgeworCQlvb3BzX2JlZ2luKCk7CisJCWdoZXNfcHJpbnRfZXN0YXR1cyhLRVJOX0VNRVJHIEhXX0VSUiwgZ2hlc19nbG9iYWwpOworCQkvKiByZWJvb3QgdG8gbG9nIHRoZSBlcnJvciEgKi8KKwkJaWYgKHBhbmljX3RpbWVvdXQgPT0gMCkKKwkJCXBhbmljX3RpbWVvdXQgPSBnaGVzX3BhbmljX3RpbWVvdXQ7CisJCXBhbmljKCJGYXRhbCBoYXJkd2FyZSBlcnJvciEiKTsKKwl9CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShnaGVzLCAmZ2hlc19ubWksIGxpc3QpIHsKKwkJaWYgKCEoZ2hlcy0+ZmxhZ3MgJiBHSEVTX1RPX0NMRUFSKSkKKwkJCWNvbnRpbnVlOworCQkvKiBEbyBub3QgcHJpbnQgZXN0YXR1cyBiZWNhdXNlIHByaW50ayBpcyBub3QgTk1JIHNhZmUgKi8KKwkJZ2hlc19kb19wcm9jKGdoZXMpOworCQlnaGVzX2NsZWFyX2VzdGF0dXMoZ2hlcyk7CisJfQorCitvdXQ6CisJcmF3X3NwaW5fdW5sb2NrKCZnaGVzX25taV9sb2NrKTsKKwlyZXR1cm4gcmV0OworfQorCiBzdGF0aWMgc3RydWN0IG5vdGlmaWVyX2Jsb2NrIGdoZXNfbm90aWZpZXJfc2NpID0gewogCS5ub3RpZmllcl9jYWxsID0gZ2hlc19ub3RpZnlfc2NpLAogfTsKIAorc3RhdGljIHN0cnVjdCBub3RpZmllcl9ibG9jayBnaGVzX25vdGlmaWVyX25taSA9IHsKKwkubm90aWZpZXJfY2FsbCA9IGdoZXNfbm90aWZ5X25taSwKK307CisKIHN0YXRpYyBpbnQgX19kZXZpbml0IGdoZXNfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqZ2hlc19kZXYpCiB7CiAJc3RydWN0IGFjcGlfaGVzdF9nZW5lcmljICpnZW5lcmljOwpAQCAtMzA2LDE4ICs1MTQsMjcgQEAKIAlpZiAoIWdlbmVyaWMtPmVuYWJsZWQpCiAJCXJldHVybiAtRU5PREVWOwogCi0JaWYgKGdlbmVyaWMtPmVycm9yX2Jsb2NrX2xlbmd0aCA8Ci0JICAgIHNpemVvZihzdHJ1Y3QgYWNwaV9oZXN0X2dlbmVyaWNfc3RhdHVzKSkgewotCQlwcl93YXJuaW5nKEZXX0JVRyBHSEVTX1BGWAotIkludmFsaWQgZXJyb3IgYmxvY2sgbGVuZ3RoOiAldSBmb3IgZ2VuZXJpYyBoYXJkd2FyZSBlcnJvciBzb3VyY2U6ICVkXG4iLAotCQkJICAgZ2VuZXJpYy0+ZXJyb3JfYmxvY2tfbGVuZ3RoLAorCXN3aXRjaCAoZ2VuZXJpYy0+bm90aWZ5LnR5cGUpIHsKKwljYXNlIEFDUElfSEVTVF9OT1RJRllfUE9MTEVEOgorCWNhc2UgQUNQSV9IRVNUX05PVElGWV9FWFRFUk5BTDoKKwljYXNlIEFDUElfSEVTVF9OT1RJRllfU0NJOgorCWNhc2UgQUNQSV9IRVNUX05PVElGWV9OTUk6CisJCWJyZWFrOworCWNhc2UgQUNQSV9IRVNUX05PVElGWV9MT0NBTDoKKwkJcHJfd2FybmluZyhHSEVTX1BGWCAiR2VuZXJpYyBoYXJkd2FyZSBlcnJvciBzb3VyY2U6ICVkIG5vdGlmaWVkIHZpYSBsb2NhbCBpbnRlcnJ1cHQgaXMgbm90IHN1cHBvcnRlZCFcbiIsCiAJCQkgICBnZW5lcmljLT5oZWFkZXIuc291cmNlX2lkKTsKIAkJZ290byBlcnI7CisJZGVmYXVsdDoKKwkJcHJfd2FybmluZyhGV19XQVJOIEdIRVNfUEZYICJVbmtub3duIG5vdGlmaWNhdGlvbiB0eXBlOiAldSBmb3IgZ2VuZXJpYyBoYXJkd2FyZSBlcnJvciBzb3VyY2U6ICVkXG4iLAorCQkJICAgZ2VuZXJpYy0+bm90aWZ5LnR5cGUsIGdlbmVyaWMtPmhlYWRlci5zb3VyY2VfaWQpOworCQlnb3RvIGVycjsKIAl9Ci0JaWYgKGdlbmVyaWMtPnJlY29yZHNfdG9fcHJlYWxsb2NhdGUgPT0gMCkgewotCQlwcl93YXJuaW5nKEZXX0JVRyBHSEVTX1BGWAotIkludmFsaWQgcmVjb3JkcyB0byBwcmVhbGxvY2F0ZTogJXUgZm9yIGdlbmVyaWMgaGFyZHdhcmUgZXJyb3Igc291cmNlOiAlZFxuIiwKLQkJCSAgIGdlbmVyaWMtPnJlY29yZHNfdG9fcHJlYWxsb2NhdGUsCisKKwlyYyA9IC1FSU87CisJaWYgKGdlbmVyaWMtPmVycm9yX2Jsb2NrX2xlbmd0aCA8CisJICAgIHNpemVvZihzdHJ1Y3QgYWNwaV9oZXN0X2dlbmVyaWNfc3RhdHVzKSkgeworCQlwcl93YXJuaW5nKEZXX0JVRyBHSEVTX1BGWCAiSW52YWxpZCBlcnJvciBibG9jayBsZW5ndGg6ICV1IGZvciBnZW5lcmljIGhhcmR3YXJlIGVycm9yIHNvdXJjZTogJWRcbiIsCisJCQkgICBnZW5lcmljLT5lcnJvcl9ibG9ja19sZW5ndGgsCiAJCQkgICBnZW5lcmljLT5oZWFkZXIuc291cmNlX2lkKTsKIAkJZ290byBlcnI7CiAJfQpAQCAtMzI3LDM4ICs1NDQsNDMgQEAKIAkJZ2hlcyA9IE5VTEw7CiAJCWdvdG8gZXJyOwogCX0KLQlpZiAoZ2VuZXJpYy0+bm90aWZ5LnR5cGUgPT0gQUNQSV9IRVNUX05PVElGWV9TQ0kpIHsKKwlzd2l0Y2ggKGdlbmVyaWMtPm5vdGlmeS50eXBlKSB7CisJY2FzZSBBQ1BJX0hFU1RfTk9USUZZX1BPTExFRDoKKwkJZ2hlcy0+dGltZXIuZnVuY3Rpb24gPSBnaGVzX3BvbGxfZnVuYzsKKwkJZ2hlcy0+dGltZXIuZGF0YSA9ICh1bnNpZ25lZCBsb25nKWdoZXM7CisJCWluaXRfdGltZXJfZGVmZXJyYWJsZSgmZ2hlcy0+dGltZXIpOworCQlnaGVzX2FkZF90aW1lcihnaGVzKTsKKwkJYnJlYWs7CisJY2FzZSBBQ1BJX0hFU1RfTk9USUZZX0VYVEVSTkFMOgorCQkvKiBFeHRlcm5hbCBpbnRlcnJ1cHQgdmVjdG9yIGlzIEdTSSAqLworCQlpZiAoYWNwaV9nc2lfdG9faXJxKGdlbmVyaWMtPm5vdGlmeS52ZWN0b3IsICZnaGVzLT5pcnEpKSB7CisJCQlwcl9lcnIoR0hFU19QRlggIkZhaWxlZCB0byBtYXAgR1NJIHRvIElSUSBmb3IgZ2VuZXJpYyBoYXJkd2FyZSBlcnJvciBzb3VyY2U6ICVkXG4iLAorCQkJICAgICAgIGdlbmVyaWMtPmhlYWRlci5zb3VyY2VfaWQpOworCQkJZ290byBlcnI7CisJCX0KKwkJaWYgKHJlcXVlc3RfaXJxKGdoZXMtPmlycSwgZ2hlc19pcnFfZnVuYywKKwkJCQkwLCAiR0hFUyBJUlEiLCBnaGVzKSkgeworCQkJcHJfZXJyKEdIRVNfUEZYICJGYWlsZWQgdG8gcmVnaXN0ZXIgSVJRIGZvciBnZW5lcmljIGhhcmR3YXJlIGVycm9yIHNvdXJjZTogJWRcbiIsCisJCQkgICAgICAgZ2VuZXJpYy0+aGVhZGVyLnNvdXJjZV9pZCk7CisJCQlnb3RvIGVycjsKKwkJfQorCQlicmVhazsKKwljYXNlIEFDUElfSEVTVF9OT1RJRllfU0NJOgogCQltdXRleF9sb2NrKCZnaGVzX2xpc3RfbXV0ZXgpOwogCQlpZiAobGlzdF9lbXB0eSgmZ2hlc19zY2kpKQogCQkJcmVnaXN0ZXJfYWNwaV9oZWRfbm90aWZpZXIoJmdoZXNfbm90aWZpZXJfc2NpKTsKIAkJbGlzdF9hZGRfcmN1KCZnaGVzLT5saXN0LCAmZ2hlc19zY2kpOwogCQltdXRleF91bmxvY2soJmdoZXNfbGlzdF9tdXRleCk7Ci0JfSBlbHNlIHsKLQkJdW5zaWduZWQgY2hhciAqbm90aWZ5ID0gTlVMTDsKLQotCQlzd2l0Y2ggKGdlbmVyaWMtPm5vdGlmeS50eXBlKSB7Ci0JCWNhc2UgQUNQSV9IRVNUX05PVElGWV9QT0xMRUQ6Ci0JCQlub3RpZnkgPSAiUE9MTCI7Ci0JCQlicmVhazsKLQkJY2FzZSBBQ1BJX0hFU1RfTk9USUZZX0VYVEVSTkFMOgotCQljYXNlIEFDUElfSEVTVF9OT1RJRllfTE9DQUw6Ci0JCQlub3RpZnkgPSAiSVJRIjsKLQkJCWJyZWFrOwotCQljYXNlIEFDUElfSEVTVF9OT1RJRllfTk1JOgotCQkJbm90aWZ5ID0gIk5NSSI7Ci0JCQlicmVhazsKLQkJfQotCQlpZiAobm90aWZ5KSB7Ci0JCQlwcl93YXJuaW5nKEdIRVNfUEZYCi0iR2VuZXJpYyBoYXJkd2FyZSBlcnJvciBzb3VyY2U6ICVkIG5vdGlmaWVkIHZpYSAlcyBpcyBub3Qgc3VwcG9ydGVkIVxuIiwKLQkJCQkgICBnZW5lcmljLT5oZWFkZXIuc291cmNlX2lkLCBub3RpZnkpOwotCQl9IGVsc2UgewotCQkJcHJfd2FybmluZyhGV19XQVJOIEdIRVNfUEZYCi0iVW5rbm93biBub3RpZmljYXRpb24gdHlwZTogJXUgZm9yIGdlbmVyaWMgaGFyZHdhcmUgZXJyb3Igc291cmNlOiAlZFxuIiwKLQkJCWdlbmVyaWMtPm5vdGlmeS50eXBlLCBnZW5lcmljLT5oZWFkZXIuc291cmNlX2lkKTsKLQkJfQotCQlyYyA9IC1FTk9ERVY7Ci0JCWdvdG8gZXJyOworCQlicmVhazsKKwljYXNlIEFDUElfSEVTVF9OT1RJRllfTk1JOgorCQltdXRleF9sb2NrKCZnaGVzX2xpc3RfbXV0ZXgpOworCQlpZiAobGlzdF9lbXB0eSgmZ2hlc19ubWkpKQorCQkJcmVnaXN0ZXJfZGllX25vdGlmaWVyKCZnaGVzX25vdGlmaWVyX25taSk7CisJCWxpc3RfYWRkX3JjdSgmZ2hlcy0+bGlzdCwgJmdoZXNfbm1pKTsKKwkJbXV0ZXhfdW5sb2NrKCZnaGVzX2xpc3RfbXV0ZXgpOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlCVUcoKTsKIAl9CiAJcGxhdGZvcm1fc2V0X2RydmRhdGEoZ2hlc19kZXYsIGdoZXMpOwogCkBAIC0zNzksNyArNjAxLDE0IEBACiAJZ2hlcyA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKGdoZXNfZGV2KTsKIAlnZW5lcmljID0gZ2hlcy0+Z2VuZXJpYzsKIAorCWdoZXMtPmZsYWdzIHw9IEdIRVNfRVhJVElORzsKIAlzd2l0Y2ggKGdlbmVyaWMtPm5vdGlmeS50eXBlKSB7CisJY2FzZSBBQ1BJX0hFU1RfTk9USUZZX1BPTExFRDoKKwkJZGVsX3RpbWVyX3N5bmMoJmdoZXMtPnRpbWVyKTsKKwkJYnJlYWs7CisJY2FzZSBBQ1BJX0hFU1RfTk9USUZZX0VYVEVSTkFMOgorCQlmcmVlX2lycShnaGVzLT5pcnEsIGdoZXMpOworCQlicmVhazsKIAljYXNlIEFDUElfSEVTVF9OT1RJRllfU0NJOgogCQltdXRleF9sb2NrKCZnaGVzX2xpc3RfbXV0ZXgpOwogCQlsaXN0X2RlbF9yY3UoJmdoZXMtPmxpc3QpOwpAQCAtMzg3LDEyICs2MTYsMjMgQEAKIAkJCXVucmVnaXN0ZXJfYWNwaV9oZWRfbm90aWZpZXIoJmdoZXNfbm90aWZpZXJfc2NpKTsKIAkJbXV0ZXhfdW5sb2NrKCZnaGVzX2xpc3RfbXV0ZXgpOwogCQlicmVhazsKKwljYXNlIEFDUElfSEVTVF9OT1RJRllfTk1JOgorCQltdXRleF9sb2NrKCZnaGVzX2xpc3RfbXV0ZXgpOworCQlsaXN0X2RlbF9yY3UoJmdoZXMtPmxpc3QpOworCQlpZiAobGlzdF9lbXB0eSgmZ2hlc19ubWkpKQorCQkJdW5yZWdpc3Rlcl9kaWVfbm90aWZpZXIoJmdoZXNfbm90aWZpZXJfbm1pKTsKKwkJbXV0ZXhfdW5sb2NrKCZnaGVzX2xpc3RfbXV0ZXgpOworCQkvKgorCQkgKiBUbyBzeW5jaHJvbml6ZSB3aXRoIE5NSSBoYW5kbGVyLCBnaGVzIGNhbiBvbmx5IGJlCisJCSAqIGZyZWVkIGFmdGVyIE5NSSBoYW5kbGVyIGZpbmlzaGVzLgorCQkgKi8KKwkJc3luY2hyb25pemVfcmN1KCk7CisJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCUJVRygpOwogCQlicmVhazsKIAl9CiAKLQlzeW5jaHJvbml6ZV9yY3UoKTsKIAlnaGVzX2ZpbmkoZ2hlcyk7CiAJa2ZyZWUoZ2hlcyk7CiAKQEAgLTQxMiw2ICs2NTIsOCBAQAogCiBzdGF0aWMgaW50IF9faW5pdCBnaGVzX2luaXQodm9pZCkKIHsKKwlpbnQgcmM7CisKIAlpZiAoYWNwaV9kaXNhYmxlZCkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKQEAgLTQyMCwxMiArNjYyLDI1IEBACiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAotCXJldHVybiBwbGF0Zm9ybV9kcml2ZXJfcmVnaXN0ZXIoJmdoZXNfcGxhdGZvcm1fZHJpdmVyKTsKKwlyYyA9IGdoZXNfaW9yZW1hcF9pbml0KCk7CisJaWYgKHJjKQorCQlnb3RvIGVycjsKKworCXJjID0gcGxhdGZvcm1fZHJpdmVyX3JlZ2lzdGVyKCZnaGVzX3BsYXRmb3JtX2RyaXZlcik7CisJaWYgKHJjKQorCQlnb3RvIGVycl9pb3JlbWFwX2V4aXQ7CisKKwlyZXR1cm4gMDsKK2Vycl9pb3JlbWFwX2V4aXQ6CisJZ2hlc19pb3JlbWFwX2V4aXQoKTsKK2VycjoKKwlyZXR1cm4gcmM7CiB9CiAKIHN0YXRpYyB2b2lkIF9fZXhpdCBnaGVzX2V4aXQodm9pZCkKIHsKIAlwbGF0Zm9ybV9kcml2ZXJfdW5yZWdpc3RlcigmZ2hlc19wbGF0Zm9ybV9kcml2ZXIpOworCWdoZXNfaW9yZW1hcF9leGl0KCk7CiB9CiAKIG1vZHVsZV9pbml0KGdoZXNfaW5pdCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYXBlaS9oZXN0LmMgYi9kcml2ZXJzL2FjcGkvYXBlaS9oZXN0LmMKaW5kZXggZGFhN2JjNi4uYWJkYTM3OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2FwZWkvaGVzdC5jCisrKyBiL2RyaXZlcnMvYWNwaS9hcGVpL2hlc3QuYwpAQCAtMTk1LDI0ICsxOTUsMjQgQEAKIAogX19zZXR1cCgiaGVzdF9kaXNhYmxlIiwgc2V0dXBfaGVzdF9kaXNhYmxlKTsKIAotc3RhdGljIGludCBfX2luaXQgaGVzdF9pbml0KHZvaWQpCit2b2lkIF9faW5pdCBhY3BpX2hlc3RfaW5pdCh2b2lkKQogewogCWFjcGlfc3RhdHVzIHN0YXR1czsKIAlpbnQgcmMgPSAtRU5PREVWOwogCXVuc2lnbmVkIGludCBnaGVzX2NvdW50ID0gMDsKIAorCWlmIChoZXN0X2Rpc2FibGUpIHsKKwkJcHJfaW5mbyhIRVNUX1BGWCAiVGFibGUgcGFyc2luZyBkaXNhYmxlZC5cbiIpOworCQlyZXR1cm47CisJfQorCiAJaWYgKGFjcGlfZGlzYWJsZWQpCiAJCWdvdG8gZXJyOwogCi0JaWYgKGhlc3RfZGlzYWJsZSkgewotCQlwcl9pbmZvKEhFU1RfUEZYICJIRVNUIHRhYmxpbmcgcGFyc2luZyBpcyBkaXNhYmxlZC5cbiIpOwotCQlnb3RvIGVycjsKLQl9Ci0KIAlzdGF0dXMgPSBhY3BpX2dldF90YWJsZShBQ1BJX1NJR19IRVNULCAwLAogCQkJCShzdHJ1Y3QgYWNwaV90YWJsZV9oZWFkZXIgKiopJmhlc3RfdGFiKTsKIAlpZiAoc3RhdHVzID09IEFFX05PVF9GT1VORCkgewotCQlwcl9pbmZvKEhFU1RfUEZYICJUYWJsZSBpcyBub3QgZm91bmQhXG4iKTsKKwkJcHJfaW5mbyhIRVNUX1BGWCAiVGFibGUgbm90IGZvdW5kLlxuIik7CiAJCWdvdG8gZXJyOwogCX0gZWxzZSBpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKIAkJY29uc3QgY2hhciAqbXNnID0gYWNwaV9mb3JtYXRfZXhjZXB0aW9uKHN0YXR1cyk7CkBAIC0yMjYsMTUgKzIyNiwxMSBAQAogCQlnb3RvIGVycjsKIAogCXJjID0gaGVzdF9naGVzX2Rldl9yZWdpc3RlcihnaGVzX2NvdW50KTsKLQlpZiAocmMpCi0JCWdvdG8gZXJyOworCWlmICghcmMpIHsKKwkJcHJfaW5mbyhIRVNUX1BGWCAiVGFibGUgcGFyc2luZyBoYXMgYmVlbiBpbml0aWFsaXplZC5cbiIpOworCQlyZXR1cm47CisJfQogCi0JcHJfaW5mbyhIRVNUX1BGWCAiSEVTVCB0YWJsZSBwYXJzaW5nIGlzIGluaXRpYWxpemVkLlxuIik7Ci0KLQlyZXR1cm4gMDsKIGVycjoKIAloZXN0X2Rpc2FibGUgPSAxOwotCXJldHVybiByYzsKIH0KLQotc3Vic3lzX2luaXRjYWxsKGhlc3RfaW5pdCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYmF0dGVyeS5jIGIvZHJpdmVycy9hY3BpL2JhdHRlcnkuYwppbmRleCA5NTY0OWQzLi5hYzFhNTk5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYmF0dGVyeS5jCisrKyBiL2RyaXZlcnMvYWNwaS9iYXR0ZXJ5LmMKQEAgLTYzMSw2ICs2MzEsMTcgQEAKIAlyZXR1cm4gcmVzdWx0OwogfQogCitzdGF0aWMgdm9pZCBhY3BpX2JhdHRlcnlfcmVmcmVzaChzdHJ1Y3QgYWNwaV9iYXR0ZXJ5ICpiYXR0ZXJ5KQoreworCWlmICghYmF0dGVyeS0+YmF0LmRldikKKwkJcmV0dXJuOworCisJYWNwaV9iYXR0ZXJ5X2dldF9pbmZvKGJhdHRlcnkpOworCS8qIFRoZSBiYXR0ZXJ5IG1heSBoYXZlIGNoYW5nZWQgaXRzIHJlcG9ydGluZyB1bml0cy4gKi8KKwlzeXNmc19yZW1vdmVfYmF0dGVyeShiYXR0ZXJ5KTsKKwlzeXNmc19hZGRfYmF0dGVyeShiYXR0ZXJ5KTsKK30KKwogLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEZTIEludGVyZmFjZSAoL3Byb2MpCiAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwpAQCAtODY4LDYgKzg3OSw4IEBACiAJc3RydWN0IHByb2NfZGlyX2VudHJ5ICplbnRyeSA9IE5VTEw7CiAJaW50IGk7CiAKKwlwcmludGsoS0VSTl9XQVJOSU5HIFBSRUZJWCAiRGVwcmVjYXRlZCBwcm9jZnMgSS9GIGZvciBiYXR0ZXJ5IGlzIGxvYWRlZCwiCisJCQkiIHBsZWFzZSByZXRyeSB3aXRoIENPTkZJR19BQ1BJX1BST0NGU19QT1dFUiBjbGVhcmVkXG4iKTsKIAlpZiAoIWFjcGlfZGV2aWNlX2RpcihkZXZpY2UpKSB7CiAJCWFjcGlfZGV2aWNlX2RpcihkZXZpY2UpID0gcHJvY19ta2RpcihhY3BpX2RldmljZV9iaWQoZGV2aWNlKSwKIAkJCQkJCSAgICAgYWNwaV9iYXR0ZXJ5X2Rpcik7CkBAIC05MTQsNiArOTI3LDggQEAKIAlpZiAoIWJhdHRlcnkpCiAJCXJldHVybjsKIAlvbGQgPSBiYXR0ZXJ5LT5iYXQuZGV2OworCWlmIChldmVudCA9PSBBQ1BJX0JBVFRFUllfTk9USUZZX0lORk8pCisJCWFjcGlfYmF0dGVyeV9yZWZyZXNoKGJhdHRlcnkpOwogCWFjcGlfYmF0dGVyeV91cGRhdGUoYmF0dGVyeSk7CiAJYWNwaV9idXNfZ2VuZXJhdGVfcHJvY19ldmVudChkZXZpY2UsIGV2ZW50LAogCQkJCSAgICAgYWNwaV9iYXR0ZXJ5X3ByZXNlbnQoYmF0dGVyeSkpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2J1cy5jIGIvZHJpdmVycy9hY3BpL2J1cy5jCmluZGV4IGQ2OGJkNjEuLjdjZWQ2MWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9idXMuYworKysgYi9kcml2ZXJzL2FjcGkvYnVzLmMKQEAgLTUyLDIyICs1Miw2IEBACiAKICNkZWZpbmUgU1RSVUNUX1RPX0lOVChzKQkoKigoaW50KikmcykpCiAKLXN0YXRpYyBpbnQgc2V0X3Bvd2VyX25vY2hlY2soY29uc3Qgc3RydWN0IGRtaV9zeXN0ZW1faWQgKmlkKQotewotCXByaW50ayhLRVJOX05PVElDRSBQUkVGSVggIiVzIGRldGVjdGVkIC0gIgotCQkiZGlzYWJsZSBwb3dlciBjaGVjayBpbiBwb3dlciB0cmFuc2l0aW9uXG4iLCBpZC0+aWRlbnQpOwotCWFjcGlfcG93ZXJfbm9jaGVjayA9IDE7Ci0JcmV0dXJuIDA7Ci19Ci1zdGF0aWMgc3RydWN0IGRtaV9zeXN0ZW1faWQgX19jcHVpbml0ZGF0YSBwb3dlcl9ub2NoZWNrX2RtaV90YWJsZVtdID0gewotCXsKLQlzZXRfcG93ZXJfbm9jaGVjaywgIkhQIFBhdmlsaW9uIDA1IiwgewotCURNSV9NQVRDSChETUlfQklPU19WRU5ET1IsICJQaG9lbml4IFRlY2hub2xvZ2llcyBMVEQiKSwKLQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJIUCBQYXZpbGlvbiAwNSIpLAotCURNSV9NQVRDSChETUlfUFJPRFVDVF9WRVJTSU9OLCAiMjAwMTIxMVJFMTAxR0xFTkQiKSB9LCBOVUxMfSwKLQl7fSwKLX07Ci0KIAogI2lmZGVmIENPTkZJR19YODYKIHN0YXRpYyBpbnQgc2V0X2NvcHlfZHNkdChjb25zdCBzdHJ1Y3QgZG1pX3N5c3RlbV9pZCAqaWQpCkBAIC0xOTYsMzMgKzE4MCwyNCBAQAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUG93ZXIgTWFuYWdlbWVudAogICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KIAotaW50IGFjcGlfYnVzX2dldF9wb3dlcihhY3BpX2hhbmRsZSBoYW5kbGUsIGludCAqc3RhdGUpCitzdGF0aWMgaW50IF9fYWNwaV9idXNfZ2V0X3Bvd2VyKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlLCBpbnQgKnN0YXRlKQogewogCWludCByZXN1bHQgPSAwOwogCWFjcGlfc3RhdHVzIHN0YXR1cyA9IDA7Ci0Jc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UgPSBOVUxMOwogCXVuc2lnbmVkIGxvbmcgbG9uZyBwc2MgPSAwOwogCi0KLQlyZXN1bHQgPSBhY3BpX2J1c19nZXRfZGV2aWNlKGhhbmRsZSwgJmRldmljZSk7Ci0JaWYgKHJlc3VsdCkKLQkJcmV0dXJuIHJlc3VsdDsKKwlpZiAoIWRldmljZSB8fCAhc3RhdGUpCisJCXJldHVybiAtRUlOVkFMOwogCiAJKnN0YXRlID0gQUNQSV9TVEFURV9VTktOT1dOOwogCi0JaWYgKCFkZXZpY2UtPmZsYWdzLnBvd2VyX21hbmFnZWFibGUpIHsKLQkJLyogVEJEOiBOb24tcmVjdXJzaXZlIGFsZ29yaXRobSBmb3Igd2Fsa2luZyB1cCBoaWVyYXJjaHkgKi8KLQkJaWYgKGRldmljZS0+cGFyZW50KQotCQkJKnN0YXRlID0gZGV2aWNlLT5wYXJlbnQtPnBvd2VyLnN0YXRlOwotCQllbHNlCi0JCQkqc3RhdGUgPSBBQ1BJX1NUQVRFX0QwOwotCX0gZWxzZSB7CisJaWYgKGRldmljZS0+ZmxhZ3MucG93ZXJfbWFuYWdlYWJsZSkgewogCQkvKgogCQkgKiBHZXQgdGhlIGRldmljZSdzIHBvd2VyIHN0YXRlIGVpdGhlciBkaXJlY3RseSAodmlhIF9QU0MpIG9yCiAJCSAqIGluZGlyZWN0bHkgKHZpYSBwb3dlciByZXNvdXJjZXMpLgogCQkgKi8KIAkJaWYgKGRldmljZS0+cG93ZXIuZmxhZ3MucG93ZXJfcmVzb3VyY2VzKSB7Ci0JCQlyZXN1bHQgPSBhY3BpX3Bvd2VyX2dldF9pbmZlcnJlZF9zdGF0ZShkZXZpY2UpOworCQkJcmVzdWx0ID0gYWNwaV9wb3dlcl9nZXRfaW5mZXJyZWRfc3RhdGUoZGV2aWNlLCBzdGF0ZSk7CiAJCQlpZiAocmVzdWx0KQogCQkJCXJldHVybiByZXN1bHQ7CiAJCX0gZWxzZSBpZiAoZGV2aWNlLT5wb3dlci5mbGFncy5leHBsaWNpdF9nZXQpIHsKQEAgLTIzMCw1OSArMjA1LDMzIEBACiAJCQkJCQkgICAgICAgTlVMTCwgJnBzYyk7CiAJCQlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpCiAJCQkJcmV0dXJuIC1FTk9ERVY7Ci0JCQlkZXZpY2UtPnBvd2VyLnN0YXRlID0gKGludClwc2M7CisJCQkqc3RhdGUgPSAoaW50KXBzYzsKIAkJfQotCi0JCSpzdGF0ZSA9IGRldmljZS0+cG93ZXIuc3RhdGU7CisJfSBlbHNlIHsKKwkJLyogVEJEOiBOb24tcmVjdXJzaXZlIGFsZ29yaXRobSBmb3Igd2Fsa2luZyB1cCBoaWVyYXJjaHkuICovCisJCSpzdGF0ZSA9IGRldmljZS0+cGFyZW50ID8KKwkJCWRldmljZS0+cGFyZW50LT5wb3dlci5zdGF0ZSA6IEFDUElfU1RBVEVfRDA7CiAJfQogCiAJQUNQSV9ERUJVR19QUklOVCgoQUNQSV9EQl9JTkZPLCAiRGV2aWNlIFslc10gcG93ZXIgc3RhdGUgaXMgRCVkXG4iLAotCQkJICBkZXZpY2UtPnBucC5idXNfaWQsIGRldmljZS0+cG93ZXIuc3RhdGUpKTsKKwkJCSAgZGV2aWNlLT5wbnAuYnVzX2lkLCAqc3RhdGUpKTsKIAogCXJldHVybiAwOwogfQogCi1FWFBPUlRfU1lNQk9MKGFjcGlfYnVzX2dldF9wb3dlcik7CiAKLWludCBhY3BpX2J1c19zZXRfcG93ZXIoYWNwaV9oYW5kbGUgaGFuZGxlLCBpbnQgc3RhdGUpCitzdGF0aWMgaW50IF9fYWNwaV9idXNfc2V0X3Bvd2VyKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlLCBpbnQgc3RhdGUpCiB7CiAJaW50IHJlc3VsdCA9IDA7CiAJYWNwaV9zdGF0dXMgc3RhdHVzID0gQUVfT0s7Ci0Jc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UgPSBOVUxMOwogCWNoYXIgb2JqZWN0X25hbWVbNV0gPSB7ICdfJywgJ1AnLCAnUycsICcwJyArIHN0YXRlLCAnXDAnIH07CiAKLQotCXJlc3VsdCA9IGFjcGlfYnVzX2dldF9kZXZpY2UoaGFuZGxlLCAmZGV2aWNlKTsKLQlpZiAocmVzdWx0KQotCQlyZXR1cm4gcmVzdWx0OwotCi0JaWYgKChzdGF0ZSA8IEFDUElfU1RBVEVfRDApIHx8IChzdGF0ZSA+IEFDUElfU1RBVEVfRDMpKQorCWlmICghZGV2aWNlIHx8IChzdGF0ZSA8IEFDUElfU1RBVEVfRDApIHx8IChzdGF0ZSA+IEFDUElfU1RBVEVfRDMpKQogCQlyZXR1cm4gLUVJTlZBTDsKIAogCS8qIE1ha2Ugc3VyZSB0aGlzIGlzIGEgdmFsaWQgdGFyZ2V0IHN0YXRlICovCiAKLQlpZiAoIWRldmljZS0+ZmxhZ3MucG93ZXJfbWFuYWdlYWJsZSkgewotCQlBQ1BJX0RFQlVHX1BSSU5UKChBQ1BJX0RCX0lORk8sICJEZXZpY2UgYFslc10nIGlzIG5vdCBwb3dlciBtYW5hZ2VhYmxlXG4iLAotCQkJCWtvYmplY3RfbmFtZSgmZGV2aWNlLT5kZXYua29iaikpKTsKLQkJcmV0dXJuIC1FTk9ERVY7Ci0JfQotCS8qCi0JICogR2V0IGRldmljZSdzIGN1cnJlbnQgcG93ZXIgc3RhdGUKLQkgKi8KLQlpZiAoIWFjcGlfcG93ZXJfbm9jaGVjaykgewotCQkvKgotCQkgKiBNYXliZSB0aGUgaW5jb3JyZWN0IHBvd2VyIHN0YXRlIGlzIHJldHVybmVkIG9uIHRoZSBib2d1cwotCQkgKiBiaW9zLCB3aGljaCBpcyBkaWZmZXJlbnQgd2l0aCB0aGUgcmVhbCBwb3dlciBzdGF0ZS4KLQkJICogRm9yIGV4YW1wbGU6IHRoZSBiaW9zIHJldHVybnMgRDAgc3RhdGUgYW5kIHRoZSByZWFsIHBvd2VyCi0JCSAqIHN0YXRlIGlzIEQzLiBPUyBleHBlY3RzIHRvIHNldCB0aGUgZGV2aWNlIHRvIEQwIHN0YXRlLiBJbgotCQkgKiBzdWNoIGNhc2UgaWYgT1MgdXNlcyB0aGUgcG93ZXIgc3RhdGUgcmV0dXJuZWQgYnkgdGhlIEJJT1MsCi0JCSAqIHRoZSBkZXZpY2UgY2FuJ3QgYmUgdHJhbnNpc3RlZCB0byB0aGUgY29ycmVjdCBwb3dlciBzdGF0ZS4KLQkJICogU28gaWYgdGhlIGFjcGlfcG93ZXJfbm9jaGVjayBpcyBzZXQsIGl0IGlzIHVubmVjZXNzYXJ5IHRvCi0JCSAqIGdldCB0aGUgcG93ZXIgc3RhdGUgYnkgY2FsbGluZyBhY3BpX2J1c19nZXRfcG93ZXIuCi0JCSAqLwotCQlhY3BpX2J1c19nZXRfcG93ZXIoZGV2aWNlLT5oYW5kbGUsICZkZXZpY2UtPnBvd2VyLnN0YXRlKTsKLQl9Ci0JaWYgKChzdGF0ZSA9PSBkZXZpY2UtPnBvd2VyLnN0YXRlKSAmJiAhZGV2aWNlLT5mbGFncy5mb3JjZV9wb3dlcl9zdGF0ZSkgeworCWlmIChzdGF0ZSA9PSBkZXZpY2UtPnBvd2VyLnN0YXRlKSB7CiAJCUFDUElfREVCVUdfUFJJTlQoKEFDUElfREJfSU5GTywgIkRldmljZSBpcyBhbHJlYWR5IGF0IEQlZFxuIiwKIAkJCQkgIHN0YXRlKSk7CiAJCXJldHVybiAwOwpAQCAtMzUxLDggKzMwMCw3NSBAQAogCXJldHVybiByZXN1bHQ7CiB9CiAKKworaW50IGFjcGlfYnVzX3NldF9wb3dlcihhY3BpX2hhbmRsZSBoYW5kbGUsIGludCBzdGF0ZSkKK3sKKwlzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZTsKKwlpbnQgcmVzdWx0OworCisJcmVzdWx0ID0gYWNwaV9idXNfZ2V0X2RldmljZShoYW5kbGUsICZkZXZpY2UpOworCWlmIChyZXN1bHQpCisJCXJldHVybiByZXN1bHQ7CisKKwlpZiAoIWRldmljZS0+ZmxhZ3MucG93ZXJfbWFuYWdlYWJsZSkgeworCQlBQ1BJX0RFQlVHX1BSSU5UKChBQ1BJX0RCX0lORk8sCisJCQkJIkRldmljZSBbJXNdIGlzIG5vdCBwb3dlciBtYW5hZ2VhYmxlXG4iLAorCQkJCWRldl9uYW1lKCZkZXZpY2UtPmRldikpKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCisJcmV0dXJuIF9fYWNwaV9idXNfc2V0X3Bvd2VyKGRldmljZSwgc3RhdGUpOworfQogRVhQT1JUX1NZTUJPTChhY3BpX2J1c19zZXRfcG93ZXIpOwogCisKK2ludCBhY3BpX2J1c19pbml0X3Bvd2VyKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlKQoreworCWludCBzdGF0ZTsKKwlpbnQgcmVzdWx0OworCisJaWYgKCFkZXZpY2UpCisJCXJldHVybiAtRUlOVkFMOworCisJZGV2aWNlLT5wb3dlci5zdGF0ZSA9IEFDUElfU1RBVEVfVU5LTk9XTjsKKworCXJlc3VsdCA9IF9fYWNwaV9idXNfZ2V0X3Bvd2VyKGRldmljZSwgJnN0YXRlKTsKKwlpZiAocmVzdWx0KQorCQlyZXR1cm4gcmVzdWx0OworCisJaWYgKGRldmljZS0+cG93ZXIuZmxhZ3MucG93ZXJfcmVzb3VyY2VzKQorCQlyZXN1bHQgPSBhY3BpX3Bvd2VyX29uX3Jlc291cmNlcyhkZXZpY2UsIHN0YXRlKTsKKworCWlmICghcmVzdWx0KQorCQlkZXZpY2UtPnBvd2VyLnN0YXRlID0gc3RhdGU7CisKKwlyZXR1cm4gcmVzdWx0OworfQorCisKK2ludCBhY3BpX2J1c191cGRhdGVfcG93ZXIoYWNwaV9oYW5kbGUgaGFuZGxlLCBpbnQgKnN0YXRlX3ApCit7CisJc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2U7CisJaW50IHN0YXRlOworCWludCByZXN1bHQ7CisKKwlyZXN1bHQgPSBhY3BpX2J1c19nZXRfZGV2aWNlKGhhbmRsZSwgJmRldmljZSk7CisJaWYgKHJlc3VsdCkKKwkJcmV0dXJuIHJlc3VsdDsKKworCXJlc3VsdCA9IF9fYWNwaV9idXNfZ2V0X3Bvd2VyKGRldmljZSwgJnN0YXRlKTsKKwlpZiAocmVzdWx0KQorCQlyZXR1cm4gcmVzdWx0OworCisJcmVzdWx0ID0gX19hY3BpX2J1c19zZXRfcG93ZXIoZGV2aWNlLCBzdGF0ZSk7CisJaWYgKCFyZXN1bHQgJiYgc3RhdGVfcCkKKwkJKnN0YXRlX3AgPSBzdGF0ZTsKKworCXJldHVybiByZXN1bHQ7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChhY3BpX2J1c191cGRhdGVfcG93ZXIpOworCisKIGJvb2wgYWNwaV9idXNfcG93ZXJfbWFuYWdlYWJsZShhY3BpX2hhbmRsZSBoYW5kbGUpCiB7CiAJc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2U7CkBAIC0xMDIzLDE1ICsxMDM5LDggQEAKIAlpZiAoYWNwaV9kaXNhYmxlZCkKIAkJcmV0dXJuIHJlc3VsdDsKIAotCS8qCi0JICogSWYgdGhlIGxhcHRvcCBmYWxscyBpbnRvIHRoZSBETUkgY2hlY2sgdGFibGUsIHRoZSBwb3dlciBzdGF0ZSBjaGVjawotCSAqIHdpbGwgYmUgZGlzYWJsZWQgaW4gdGhlIGNvdXJzZSBvZiBkZXZpY2UgcG93ZXIgdHJhbnNpdGlvbi4KLQkgKi8KLQlkbWlfY2hlY2tfc3lzdGVtKHBvd2VyX25vY2hlY2tfZG1pX3RhYmxlKTsKLQogCWFjcGlfc2Nhbl9pbml0KCk7CiAJYWNwaV9lY19pbml0KCk7Ci0JYWNwaV9wb3dlcl9pbml0KCk7CiAJYWNwaV9kZWJ1Z2ZzX2luaXQoKTsKIAlhY3BpX3NsZWVwX3Byb2NfaW5pdCgpOwogCWFjcGlfd2FrZXVwX2RldmljZV9pbml0KCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYnV0dG9uLmMgYi9kcml2ZXJzL2FjcGkvYnV0dG9uLmMKaW5kZXggNzFlZjljZC4uNzZiYmI3OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2J1dHRvbi5jCisrKyBiL2RyaXZlcnMvYWNwaS9idXR0b24uYwpAQCAtMjc5LDYgKzI3OSw5IEBACiAJaW5wdXRfcmVwb3J0X3N3aXRjaChidXR0b24tPmlucHV0LCBTV19MSUQsICFzdGF0ZSk7CiAJaW5wdXRfc3luYyhidXR0b24tPmlucHV0KTsKIAorCWlmIChzdGF0ZSkKKwkJcG1fd2FrZXVwX2V2ZW50KCZkZXZpY2UtPmRldiwgMCk7CisKIAlyZXQgPSBibG9ja2luZ19ub3RpZmllcl9jYWxsX2NoYWluKCZhY3BpX2xpZF9ub3RpZmllciwgc3RhdGUsIGRldmljZSk7CiAJaWYgKHJldCA9PSBOT1RJRllfRE9ORSkKIAkJcmV0ID0gYmxvY2tpbmdfbm90aWZpZXJfY2FsbF9jaGFpbigmYWNwaV9saWRfbm90aWZpZXIsIHN0YXRlLApAQCAtMzE0LDYgKzMxNyw4IEBACiAJCQlpbnB1dF9zeW5jKGlucHV0KTsKIAkJCWlucHV0X3JlcG9ydF9rZXkoaW5wdXQsIGtleWNvZGUsIDApOwogCQkJaW5wdXRfc3luYyhpbnB1dCk7CisKKwkJCXBtX3dha2V1cF9ldmVudCgmZGV2aWNlLT5kZXYsIDApOwogCQl9CiAKIAkJYWNwaV9idXNfZ2VuZXJhdGVfcHJvY19ldmVudChkZXZpY2UsIGV2ZW50LCArK2J1dHRvbi0+cHVzaGVkKTsKQEAgLTQyNiw3ICs0MzEsNyBAQAogCQlhY3BpX2VuYWJsZV9ncGUoZGV2aWNlLT53YWtldXAuZ3BlX2RldmljZSwKIAkJCQlkZXZpY2UtPndha2V1cC5ncGVfbnVtYmVyKTsKIAkJZGV2aWNlLT53YWtldXAucnVuX3dha2VfY291bnQrKzsKLQkJZGV2aWNlLT53YWtldXAuc3RhdGUuZW5hYmxlZCA9IDE7CisJCWRldmljZV9zZXRfd2FrZXVwX2VuYWJsZSgmZGV2aWNlLT5kZXYsIHRydWUpOwogCX0KIAogCXByaW50ayhLRVJOX0lORk8gUFJFRklYICIlcyBbJXNdXG4iLCBuYW1lLCBhY3BpX2RldmljZV9iaWQoZGV2aWNlKSk7CkBAIC00NDksNyArNDU0LDcgQEAKIAkJYWNwaV9kaXNhYmxlX2dwZShkZXZpY2UtPndha2V1cC5ncGVfZGV2aWNlLAogCQkJCWRldmljZS0+d2FrZXVwLmdwZV9udW1iZXIpOwogCQlkZXZpY2UtPndha2V1cC5ydW5fd2FrZV9jb3VudC0tOwotCQlkZXZpY2UtPndha2V1cC5zdGF0ZS5lbmFibGVkID0gMDsKKwkJZGV2aWNlX3NldF93YWtldXBfZW5hYmxlKCZkZXZpY2UtPmRldiwgZmFsc2UpOwogCX0KIAogCWFjcGlfYnV0dG9uX3JlbW92ZV9mcyhkZXZpY2UpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2RvY2suYyBiL2RyaXZlcnMvYWNwaS9kb2NrLmMKaW5kZXggODE1MTRhNC4uMTg2NGFkMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2RvY2suYworKysgYi9kcml2ZXJzL2FjcGkvZG9jay5jCkBAIC03MjUsNyArNzI1LDcgQEAKIAkJCWNvbXBsZXRlX2RvY2soZHMpOwogCQkJZG9ja19ldmVudChkcywgZXZlbnQsIERPQ0tfRVZFTlQpOwogCQkJZG9ja19sb2NrKGRzLCAxKTsKLQkJCWFjcGlfdXBkYXRlX2dwZXMoKTsKKwkJCWFjcGlfdXBkYXRlX2FsbF9ncGVzKCk7CiAJCQlicmVhazsKIAkJfQogCQlpZiAoZG9ja19wcmVzZW50KGRzKSB8fCBkb2NrX2luX3Byb2dyZXNzKGRzKSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9lYy5jIGIvZHJpdmVycy9hY3BpL2VjLmMKaW5kZXggMzAyYjMxZS4uZmE4NDhjNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2VjLmMKKysrIGIvZHJpdmVycy9hY3BpL2VjLmMKQEAgLTYwNiw3ICs2MDYsOCBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgdTMyIGFjcGlfZWNfZ3BlX2hhbmRsZXIodm9pZCAqZGF0YSkKK3N0YXRpYyB1MzIgYWNwaV9lY19ncGVfaGFuZGxlcihhY3BpX2hhbmRsZSBncGVfZGV2aWNlLAorCXUzMiBncGVfbnVtYmVyLCB2b2lkICpkYXRhKQogewogCXN0cnVjdCBhY3BpX2VjICplYyA9IGRhdGE7CiAKQEAgLTYxOCw3ICs2MTksNyBAQAogCQl3YWtlX3VwKCZlYy0+d2FpdCk7CiAJCWVjX2NoZWNrX3NjaShlYywgYWNwaV9lY19yZWFkX3N0YXR1cyhlYykpOwogCX0KLQlyZXR1cm4gQUNQSV9JTlRFUlJVUFRfSEFORExFRDsKKwlyZXR1cm4gQUNQSV9JTlRFUlJVUFRfSEFORExFRCB8IEFDUElfUkVFTkFCTEVfR1BFOwogfQogCiAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2Zhbi5jIGIvZHJpdmVycy9hY3BpL2Zhbi5jCmluZGV4IDYwMDQ5MDguLjQ2NzQ3OWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9mYW4uYworKysgYi9kcml2ZXJzL2FjcGkvZmFuLmMKQEAgLTg2LDcgKzg2LDcgQEAKIAlpZiAoIWRldmljZSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKLQlyZXN1bHQgPSBhY3BpX2J1c19nZXRfcG93ZXIoZGV2aWNlLT5oYW5kbGUsICZhY3BpX3N0YXRlKTsKKwlyZXN1bHQgPSBhY3BpX2J1c191cGRhdGVfcG93ZXIoZGV2aWNlLT5oYW5kbGUsICZhY3BpX3N0YXRlKTsKIAlpZiAocmVzdWx0KQogCQlyZXR1cm4gcmVzdWx0OwogCkBAIC0xMjMsNyArMTIzLDYgQEAKIHN0YXRpYyBpbnQgYWNwaV9mYW5fYWRkKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlKQogewogCWludCByZXN1bHQgPSAwOwotCWludCBzdGF0ZSA9IDA7CiAJc3RydWN0IHRoZXJtYWxfY29vbGluZ19kZXZpY2UgKmNkZXY7CiAKIAlpZiAoIWRldmljZSkKQEAgLTEzMiwxNiArMTMxLDEyIEBACiAJc3RyY3B5KGFjcGlfZGV2aWNlX25hbWUoZGV2aWNlKSwgIkZhbiIpOwogCXN0cmNweShhY3BpX2RldmljZV9jbGFzcyhkZXZpY2UpLCBBQ1BJX0ZBTl9DTEFTUyk7CiAKLQlyZXN1bHQgPSBhY3BpX2J1c19nZXRfcG93ZXIoZGV2aWNlLT5oYW5kbGUsICZzdGF0ZSk7CisJcmVzdWx0ID0gYWNwaV9idXNfdXBkYXRlX3Bvd2VyKGRldmljZS0+aGFuZGxlLCBOVUxMKTsKIAlpZiAocmVzdWx0KSB7Ci0JCXByaW50ayhLRVJOX0VSUiBQUkVGSVggIlJlYWRpbmcgcG93ZXIgc3RhdGVcbiIpOworCQlwcmludGsoS0VSTl9FUlIgUFJFRklYICJTZXR0aW5nIGluaXRpYWwgcG93ZXIgc3RhdGVcbiIpOwogCQlnb3RvIGVuZDsKIAl9CiAKLQlkZXZpY2UtPmZsYWdzLmZvcmNlX3Bvd2VyX3N0YXRlID0gMTsKLQlhY3BpX2J1c19zZXRfcG93ZXIoZGV2aWNlLT5oYW5kbGUsIHN0YXRlKTsKLQlkZXZpY2UtPmZsYWdzLmZvcmNlX3Bvd2VyX3N0YXRlID0gMDsKLQogCWNkZXYgPSB0aGVybWFsX2Nvb2xpbmdfZGV2aWNlX3JlZ2lzdGVyKCJGYW4iLCBkZXZpY2UsCiAJCQkJCQkmZmFuX2Nvb2xpbmdfb3BzKTsKIAlpZiAoSVNfRVJSKGNkZXYpKSB7CkBAIC0yMDAsMjIgKzE5NSwxNCBAQAogCiBzdGF0aWMgaW50IGFjcGlfZmFuX3Jlc3VtZShzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSkKIHsKLQlpbnQgcmVzdWx0ID0gMDsKLQlpbnQgcG93ZXJfc3RhdGUgPSAwOworCWludCByZXN1bHQ7CiAKIAlpZiAoIWRldmljZSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKLQlyZXN1bHQgPSBhY3BpX2J1c19nZXRfcG93ZXIoZGV2aWNlLT5oYW5kbGUsICZwb3dlcl9zdGF0ZSk7Ci0JaWYgKHJlc3VsdCkgewotCQlwcmludGsoS0VSTl9FUlIgUFJFRklYCi0JCQkJICAiRXJyb3IgcmVhZGluZyBmYW4gcG93ZXIgc3RhdGVcbiIpOwotCQlyZXR1cm4gcmVzdWx0OwotCX0KLQotCWRldmljZS0+ZmxhZ3MuZm9yY2VfcG93ZXJfc3RhdGUgPSAxOwotCWFjcGlfYnVzX3NldF9wb3dlcihkZXZpY2UtPmhhbmRsZSwgcG93ZXJfc3RhdGUpOwotCWRldmljZS0+ZmxhZ3MuZm9yY2VfcG93ZXJfc3RhdGUgPSAwOworCXJlc3VsdCA9IGFjcGlfYnVzX3VwZGF0ZV9wb3dlcihkZXZpY2UtPmhhbmRsZSwgTlVMTCk7CisJaWYgKHJlc3VsdCkKKwkJcHJpbnRrKEtFUk5fRVJSIFBSRUZJWCAiRXJyb3IgdXBkYXRpbmcgZmFuIHBvd2VyIHN0YXRlXG4iKTsKIAogCXJldHVybiByZXN1bHQ7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvZ2x1ZS5jIGIvZHJpdmVycy9hY3BpL2dsdWUuYwppbmRleCA3OGIwMTY0Li43YzQ3ZWQ1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvZ2x1ZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9nbHVlLmMKQEAgLTE2NywxMSArMTY3LDggQEAKIAkJCQkiZmlybXdhcmVfbm9kZSIpOwogCQlyZXQgPSBzeXNmc19jcmVhdGVfbGluaygmYWNwaV9kZXYtPmRldi5rb2JqLCAmZGV2LT5rb2JqLAogCQkJCSJwaHlzaWNhbF9ub2RlIik7Ci0JCWlmIChhY3BpX2Rldi0+d2FrZXVwLmZsYWdzLnZhbGlkKSB7CisJCWlmIChhY3BpX2Rldi0+d2FrZXVwLmZsYWdzLnZhbGlkKQogCQkJZGV2aWNlX3NldF93YWtldXBfY2FwYWJsZShkZXYsIHRydWUpOwotCQkJZGV2aWNlX3NldF93YWtldXBfZW5hYmxlKGRldiwKLQkJCQkJCWFjcGlfZGV2LT53YWtldXAuc3RhdGUuZW5hYmxlZCk7Ci0JCX0KIAl9CiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9pbnRlcm5hbC5oIGIvZHJpdmVycy9hY3BpL2ludGVybmFsLmgKaW5kZXggYTIxMmJmZS4uYjFjYzgxYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2ludGVybmFsLmgKKysrIGIvZHJpdmVycy9hY3BpL2ludGVybmFsLmgKQEAgLTQxLDkgKzQxLDEwIEBACiBpbnQgYWNwaV9wb3dlcl9pbml0KHZvaWQpOwogaW50IGFjcGlfZGV2aWNlX3NsZWVwX3dha2Uoc3RydWN0IGFjcGlfZGV2aWNlICpkZXYsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnQgZW5hYmxlLCBpbnQgc2xlZXBfc3RhdGUsIGludCBkZXZfc3RhdGUpOwotaW50IGFjcGlfcG93ZXJfZ2V0X2luZmVycmVkX3N0YXRlKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlKTsKK2ludCBhY3BpX3Bvd2VyX2dldF9pbmZlcnJlZF9zdGF0ZShzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSwgaW50ICpzdGF0ZSk7CitpbnQgYWNwaV9wb3dlcl9vbl9yZXNvdXJjZXMoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UsIGludCBzdGF0ZSk7CiBpbnQgYWNwaV9wb3dlcl90cmFuc2l0aW9uKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlLCBpbnQgc3RhdGUpOwotZXh0ZXJuIGludCBhY3BpX3Bvd2VyX25vY2hlY2s7CitpbnQgYWNwaV9idXNfaW5pdF9wb3dlcihzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSk7CiAKIGludCBhY3BpX3dha2V1cF9kZXZpY2VfaW5pdCh2b2lkKTsKIHZvaWQgYWNwaV9lYXJseV9wcm9jZXNzb3Jfc2V0X3BkYyh2b2lkKTsKQEAgLTgyLDggKzgzLDE2IEBACiAKICNpZmRlZiBDT05GSUdfQUNQSV9TTEVFUAogaW50IGFjcGlfc2xlZXBfcHJvY19pbml0KHZvaWQpOworaW50IHN1c3BlbmRfbnZzX2FsbG9jKHZvaWQpOwordm9pZCBzdXNwZW5kX252c19mcmVlKHZvaWQpOworaW50IHN1c3BlbmRfbnZzX3NhdmUodm9pZCk7Cit2b2lkIHN1c3BlbmRfbnZzX3Jlc3RvcmUodm9pZCk7CiAjZWxzZQogc3RhdGljIGlubGluZSBpbnQgYWNwaV9zbGVlcF9wcm9jX2luaXQodm9pZCkgeyByZXR1cm4gMDsgfQorc3RhdGljIGlubGluZSBpbnQgc3VzcGVuZF9udnNfYWxsb2Modm9pZCkgeyByZXR1cm4gMDsgfQorc3RhdGljIGlubGluZSB2b2lkIHN1c3BlbmRfbnZzX2ZyZWUodm9pZCkge30KK3N0YXRpYyBpbmxpbmUgaW50IHN1c3BlbmRfbnZzX3NhdmUodm9pZCkgeyByZXR1cm4gMDsgfQorc3RhdGljIGlubGluZSB2b2lkIHN1c3BlbmRfbnZzX3Jlc3RvcmUodm9pZCkge30KICNlbmRpZgogCiAjZW5kaWYgLyogX0FDUElfSU5URVJOQUxfSF8gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9udW1hLmMgYi9kcml2ZXJzL2FjcGkvbnVtYS5jCmluZGV4IGQ5OTI2YWYuLjVlYjI1ZWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9udW1hLmMKKysrIGIvZHJpdmVycy9hY3BpL251bWEuYwpAQCAtMjc1LDIzICsyNzUsMTkgQEAKIGludCBfX2luaXQgYWNwaV9udW1hX2luaXQodm9pZCkKIHsKIAlpbnQgcmV0ID0gMDsKLQlpbnQgbnJfY3B1X2VudHJpZXMgPSBucl9jcHVfaWRzOwogCi0jaWZkZWYgQ09ORklHX1g4NgogCS8qCiAJICogU2hvdWxkIG5vdCBsaW1pdCBudW1iZXIgd2l0aCBjcHUgbnVtIHRoYXQgaXMgZnJvbSBOUl9DUFVTIG9yIG5yX2NwdXM9CiAJICogU1JBVCBjcHUgZW50cmllcyBjb3VsZCBoYXZlIGRpZmZlcmVudCBvcmRlciB3aXRoIHRoYXQgaW4gTUFEVC4KIAkgKiBTbyBnbyBvdmVyIGFsbCBjcHUgZW50cmllcyBpbiBTUkFUIHRvIGdldCBhcGljaWQgdG8gbm9kZSBtYXBwaW5nLgogCSAqLwotCW5yX2NwdV9lbnRyaWVzID0gTUFYX0xPQ0FMX0FQSUM7Ci0jZW5kaWYKIAogCS8qIFNSQVQ6IFN0YXRpYyBSZXNvdXJjZSBBZmZpbml0eSBUYWJsZSAqLwogCWlmICghYWNwaV90YWJsZV9wYXJzZShBQ1BJX1NJR19TUkFULCBhY3BpX3BhcnNlX3NyYXQpKSB7CiAJCWFjcGlfdGFibGVfcGFyc2Vfc3JhdChBQ1BJX1NSQVRfVFlQRV9YMkFQSUNfQ1BVX0FGRklOSVRZLAotCQkJCSAgICAgYWNwaV9wYXJzZV94MmFwaWNfYWZmaW5pdHksIG5yX2NwdV9lbnRyaWVzKTsKKwkJCQkgICAgIGFjcGlfcGFyc2VfeDJhcGljX2FmZmluaXR5LCAwKTsKIAkJYWNwaV90YWJsZV9wYXJzZV9zcmF0KEFDUElfU1JBVF9UWVBFX0NQVV9BRkZJTklUWSwKLQkJCQkgICAgIGFjcGlfcGFyc2VfcHJvY2Vzc29yX2FmZmluaXR5LCBucl9jcHVfZW50cmllcyk7CisJCQkJICAgICBhY3BpX3BhcnNlX3Byb2Nlc3Nvcl9hZmZpbml0eSwgMCk7CiAJCXJldCA9IGFjcGlfdGFibGVfcGFyc2Vfc3JhdChBQ1BJX1NSQVRfVFlQRV9NRU1PUllfQUZGSU5JVFksCiAJCQkJCSAgICBhY3BpX3BhcnNlX21lbW9yeV9hZmZpbml0eSwKIAkJCQkJICAgIE5SX05PREVfTUVNQkxLUyk7CmRpZmYgLS1naXQgYS9rZXJuZWwvcG93ZXIvbnZzLmMgYi9kcml2ZXJzL2FjcGkvbnZzLmMKc2ltaWxhcml0eSBpbmRleCA4NyUKcmVuYW1lIGZyb20ga2VybmVsL3Bvd2VyL252cy5jCnJlbmFtZSB0byBkcml2ZXJzL2FjcGkvbnZzLmMKaW5kZXggMTgzNmRiNi4uZmE1YTFkZiAxMDA2NDQKLS0tIGEva2VybmVsL3Bvd2VyL252cy5jCisrKyBiL2RyaXZlcnMvYWNwaS9udnMuYwpAQCAtMSw3ICsxLDcgQEAKIC8qCi0gKiBsaW51eC9rZXJuZWwvcG93ZXIvaGliZXJuYXRlX252cy5jIC0gUm91dGluZXMgZm9yIGhhbmRsaW5nIE5WUyBtZW1vcnkKKyAqIG52cy5jIC0gUm91dGluZXMgZm9yIHNhdmluZyBhbmQgcmVzdG9yaW5nIEFDUEkgTlZTIG1lbW9yeSByZWdpb24KICAqCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDgsMjAwOSBSYWZhZWwgSi4gV3lzb2NraSA8cmp3QHNpc2sucGw+LCBOb3ZlbGwgSW5jLgorICogQ29weXJpZ2h0IChDKSAyMDA4LTIwMTEgUmFmYWVsIEouIFd5c29ja2kgPHJqd0BzaXNrLnBsPiwgTm92ZWxsIEluYy4KICAqCiAgKiBUaGlzIGZpbGUgaXMgcmVsZWFzZWQgdW5kZXIgdGhlIEdQTHYyLgogICovCkBAIC0xMSw3ICsxMSw5IEBACiAjaW5jbHVkZSA8bGludXgvbGlzdC5oPgogI2luY2x1ZGUgPGxpbnV4L21tLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgotI2luY2x1ZGUgPGxpbnV4L3N1c3BlbmQuaD4KKyNpbmNsdWRlIDxsaW51eC9hY3BpLmg+CisjaW5jbHVkZSA8bGludXgvYWNwaV9pby5oPgorI2luY2x1ZGUgPGFjcGkvYWNwaW9zeGYuaD4KIAogLyoKICAqIFBsYXRmb3JtcywgbGlrZSBBQ1BJLCBtYXkgd2FudCB1cyB0byBzYXZlIHNvbWUgbWVtb3J5IHVzZWQgYnkgdGhlbSBkdXJpbmcKQEAgLTEwNSw3ICsxMDcsNyBAQAogLyoqCiAgKglzdXNwZW5kX252c19zYXZlIC0gc2F2ZSBOVlMgbWVtb3J5IHJlZ2lvbnMKICAqLwotdm9pZCBzdXNwZW5kX252c19zYXZlKHZvaWQpCitpbnQgc3VzcGVuZF9udnNfc2F2ZSh2b2lkKQogewogCXN0cnVjdCBudnNfcGFnZSAqZW50cnk7CiAKQEAgLTExMyw5ICsxMTUsMTYgQEAKIAogCWxpc3RfZm9yX2VhY2hfZW50cnkoZW50cnksICZudnNfbGlzdCwgbm9kZSkKIAkJaWYgKGVudHJ5LT5kYXRhKSB7Ci0JCQllbnRyeS0+a2FkZHIgPSBpb3JlbWFwKGVudHJ5LT5waHlzX3N0YXJ0LCBlbnRyeS0+c2l6ZSk7CisJCQllbnRyeS0+a2FkZHIgPSBhY3BpX29zX2lvcmVtYXAoZW50cnktPnBoeXNfc3RhcnQsCisJCQkJCQkgICAgZW50cnktPnNpemUpOworCQkJaWYgKCFlbnRyeS0+a2FkZHIpIHsKKwkJCQlzdXNwZW5kX252c19mcmVlKCk7CisJCQkJcmV0dXJuIC1FTk9NRU07CisJCQl9CiAJCQltZW1jcHkoZW50cnktPmRhdGEsIGVudHJ5LT5rYWRkciwgZW50cnktPnNpemUpOwogCQl9CisKKwlyZXR1cm4gMDsKIH0KIAogLyoqCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvb3NsLmMgYi9kcml2ZXJzL2FjcGkvb3NsLmMKaW5kZXggMDU1ZDdiNy4uYjA5MzE4MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL29zbC5jCisrKyBiL2RyaXZlcnMvYWNwaS9vc2wuYwpAQCAtMzgsNiArMzgsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgogI2luY2x1ZGUgPGxpbnV4L25taS5oPgogI2luY2x1ZGUgPGxpbnV4L2FjcGkuaD4KKyNpbmNsdWRlIDxsaW51eC9hY3BpX2lvLmg+CiAjaW5jbHVkZSA8bGludXgvZWZpLmg+CiAjaW5jbHVkZSA8bGludXgvaW9wb3J0Lmg+CiAjaW5jbHVkZSA8bGludXgvbGlzdC5oPgpAQCAtMzAyLDkgKzMwMywxMCBAQAogYWNwaV9vc19tYXBfbWVtb3J5KGFjcGlfcGh5c2ljYWxfYWRkcmVzcyBwaHlzLCBhY3BpX3NpemUgc2l6ZSkKIHsKIAlzdHJ1Y3QgYWNwaV9pb3JlbWFwICptYXAsICp0bXBfbWFwOwotCXVuc2lnbmVkIGxvbmcgZmxhZ3MsIHBnX3N6OworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJdm9pZCBfX2lvbWVtICp2aXJ0OwotCXBoeXNfYWRkcl90IHBnX29mZjsKKwlhY3BpX3BoeXNpY2FsX2FkZHJlc3MgcGdfb2ZmOworCWFjcGlfc2l6ZSBwZ19zejsKIAogCWlmIChwaHlzID4gVUxPTkdfTUFYKSB7CiAJCXByaW50ayhLRVJOX0VSUiBQUkVGSVggIkNhbm5vdCBtYXAgbWVtb3J5IHRoYXQgaGlnaFxuIik7CkBAIC0zMjAsNyArMzIyLDcgQEAKIAogCXBnX29mZiA9IHJvdW5kX2Rvd24ocGh5cywgUEFHRV9TSVpFKTsKIAlwZ19zeiA9IHJvdW5kX3VwKHBoeXMgKyBzaXplLCBQQUdFX1NJWkUpIC0gcGdfb2ZmOwotCXZpcnQgPSBpb3JlbWFwKHBnX29mZiwgcGdfc3opOworCXZpcnQgPSBhY3BpX29zX2lvcmVtYXAocGdfb2ZmLCBwZ19zeik7CiAJaWYgKCF2aXJ0KSB7CiAJCWtmcmVlKG1hcCk7CiAJCXJldHVybiBOVUxMOwpAQCAtNjQyLDcgKzY0NCw3IEBACiAJdmlydF9hZGRyID0gYWNwaV9tYXBfdmFkZHJfbG9va3VwKHBoeXNfYWRkciwgc2l6ZSk7CiAJcmN1X3JlYWRfdW5sb2NrKCk7CiAJaWYgKCF2aXJ0X2FkZHIpIHsKLQkJdmlydF9hZGRyID0gaW9yZW1hcChwaHlzX2FkZHIsIHNpemUpOworCQl2aXJ0X2FkZHIgPSBhY3BpX29zX2lvcmVtYXAocGh5c19hZGRyLCBzaXplKTsKIAkJdW5tYXAgPSAxOwogCX0KIAlpZiAoIXZhbHVlKQpAQCAtNjc4LDcgKzY4MCw3IEBACiAJdmlydF9hZGRyID0gYWNwaV9tYXBfdmFkZHJfbG9va3VwKHBoeXNfYWRkciwgc2l6ZSk7CiAJcmN1X3JlYWRfdW5sb2NrKCk7CiAJaWYgKCF2aXJ0X2FkZHIpIHsKLQkJdmlydF9hZGRyID0gaW9yZW1hcChwaHlzX2FkZHIsIHNpemUpOworCQl2aXJ0X2FkZHIgPSBhY3BpX29zX2lvcmVtYXAocGh5c19hZGRyLCBzaXplKTsKIAkJdW5tYXAgPSAxOwogCX0KIApAQCAtMTIzMyw4ICsxMjM1LDcgQEAKIGludCBhY3BpX2NoZWNrX3Jlc291cmNlX2NvbmZsaWN0KGNvbnN0IHN0cnVjdCByZXNvdXJjZSAqcmVzKQogewogCXN0cnVjdCBhY3BpX3Jlc19saXN0ICpyZXNfbGlzdF9lbGVtOwotCWludCBpb3BvcnQ7Ci0JaW50IGNsYXNoID0gMDsKKwlpbnQgaW9wb3J0ID0gMCwgY2xhc2ggPSAwOwogCiAJaWYgKGFjcGlfZW5mb3JjZV9yZXNvdXJjZXMgPT0gRU5GT1JDRV9SRVNPVVJDRVNfTk8pCiAJCXJldHVybiAwOwpAQCAtMTI2NCw5ICsxMjY1LDEzIEBACiAJaWYgKGNsYXNoKSB7CiAJCWlmIChhY3BpX2VuZm9yY2VfcmVzb3VyY2VzICE9IEVORk9SQ0VfUkVTT1VSQ0VTX05PKSB7CiAJCQlwcmludGsoS0VSTl9XQVJOSU5HICJBQ1BJOiByZXNvdXJjZSAlcyAlcFIiCi0JCQkgICAgICAgIiBjb25mbGljdHMgd2l0aCBBQ1BJIHJlZ2lvbiAlcyAlcFJcbiIsCisJCQkgICAgICAgIiBjb25mbGljdHMgd2l0aCBBQ1BJIHJlZ2lvbiAlcyAiCisJCQkgICAgICAgIlslcyAweCV6eC0weCV6eF1cbiIsCiAJCQkgICAgICAgcmVzLT5uYW1lLCByZXMsIHJlc19saXN0X2VsZW0tPm5hbWUsCi0JCQkgICAgICAgcmVzX2xpc3RfZWxlbSk7CisJCQkgICAgICAgKHJlc19saXN0X2VsZW0tPnJlc291cmNlX3R5cGUgPT0KKwkJCQlBQ1BJX0FEUl9TUEFDRV9TWVNURU1fSU8pID8gImlvIiA6ICJtZW0iLAorCQkJICAgICAgIChzaXplX3QpIHJlc19saXN0X2VsZW0tPnN0YXJ0LAorCQkJICAgICAgIChzaXplX3QpIHJlc19saXN0X2VsZW0tPmVuZCk7CiAJCQlpZiAoYWNwaV9lbmZvcmNlX3Jlc291cmNlcyA9PSBFTkZPUkNFX1JFU09VUkNFU19MQVgpCiAJCQkJcHJpbnRrKEtFUk5fTk9USUNFICJBQ1BJOiBUaGlzIGNvbmZsaWN0IG1heSIKIAkJCQkgICAgICAgIiBjYXVzZSByYW5kb20gcHJvYmxlbXMgYW5kIHN5c3RlbSIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9wY2lfcm9vdC5jIGIvZHJpdmVycy9hY3BpL3BjaV9yb290LmMKaW5kZXggOTY2NjhhZC4uODUyNDkzOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL3BjaV9yb290LmMKKysrIGIvZHJpdmVycy9hY3BpL3BjaV9yb290LmMKQEAgLTM2LDYgKzM2LDcgQEAKICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8YWNwaS9hY3BpX2J1cy5oPgogI2luY2x1ZGUgPGFjcGkvYWNwaV9kcml2ZXJzLmg+CisjaW5jbHVkZSA8YWNwaS9hcGVpLmg+CiAKICNkZWZpbmUgUFJFRklYICJBQ1BJOiAiCiAKQEAgLTQ3LDYgKzQ4LDExIEBACiBzdGF0aWMgaW50IGFjcGlfcGNpX3Jvb3RfcmVtb3ZlKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlLCBpbnQgdHlwZSk7CiBzdGF0aWMgaW50IGFjcGlfcGNpX3Jvb3Rfc3RhcnQoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpOwogCisjZGVmaW5lIEFDUElfUENJRV9SRVFfU1VQUE9SVCAoT1NDX0VYVF9QQ0lfQ09ORklHX1NVUFBPUlQgXAorCQkJCXwgT1NDX0FDVElWRV9TVEFURV9QV1JfU1VQUE9SVCBcCisJCQkJfCBPU0NfQ0xPQ0tfUFdSX0NBUEFCSUxJVFlfU1VQUE9SVCBcCisJCQkJfCBPU0NfTVNJX1NVUFBPUlQpCisKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgYWNwaV9kZXZpY2VfaWQgcm9vdF9kZXZpY2VfaWRzW10gPSB7CiAJeyJQTlAwQTAzIiwgMH0sCiAJeyIiLCAwfSwKQEAgLTU2Niw2ICs1NzIsMzMgQEAKIAlpZiAoZmxhZ3MgIT0gYmFzZV9mbGFncykKIAkJYWNwaV9wY2lfb3NjX3N1cHBvcnQocm9vdCwgZmxhZ3MpOwogCisJaWYgKCFwY2llX3BvcnRzX2Rpc2FibGVkCisJICAgICYmIChmbGFncyAmIEFDUElfUENJRV9SRVFfU1VQUE9SVCkgPT0gQUNQSV9QQ0lFX1JFUV9TVVBQT1JUKSB7CisJCWZsYWdzID0gT1NDX1BDSV9FWFBSRVNTX0NBUF9TVFJVQ1RVUkVfQ09OVFJPTAorCQkJfCBPU0NfUENJX0VYUFJFU1NfTkFUSVZFX0hQX0NPTlRST0wKKwkJCXwgT1NDX1BDSV9FWFBSRVNTX1BNRV9DT05UUk9MOworCisJCWlmIChwY2lfYWVyX2F2YWlsYWJsZSgpKSB7CisJCQlpZiAoYWVyX2FjcGlfZmlybXdhcmVfZmlyc3QoKSkKKwkJCQlkZXZfZGJnKHJvb3QtPmJ1cy0+YnJpZGdlLAorCQkJCQkiUENJZSBlcnJvcnMgaGFuZGxlZCBieSBCSU9TLlxuIik7CisJCQllbHNlCisJCQkJZmxhZ3MgfD0gT1NDX1BDSV9FWFBSRVNTX0FFUl9DT05UUk9MOworCQl9CisKKwkJZGV2X2luZm8ocm9vdC0+YnVzLT5icmlkZ2UsCisJCQkiUmVxdWVzdGluZyBBQ1BJIF9PU0MgY29udHJvbCAoMHglMDJ4KVxuIiwgZmxhZ3MpOworCisJCXN0YXR1cyA9IGFjcGlfcGNpX29zY19jb250cm9sX3NldChkZXZpY2UtPmhhbmRsZSwgJmZsYWdzLAorCQkJCQlPU0NfUENJX0VYUFJFU1NfQ0FQX1NUUlVDVFVSRV9DT05UUk9MKTsKKwkJaWYgKEFDUElfU1VDQ0VTUyhzdGF0dXMpKQorCQkJZGV2X2luZm8ocm9vdC0+YnVzLT5icmlkZ2UsCisJCQkJIkFDUEkgX09TQyBjb250cm9sICgweCUwMngpIGdyYW50ZWRcbiIsIGZsYWdzKTsKKwkJZWxzZQorCQkJZGV2X2RiZyhyb290LT5idXMtPmJyaWRnZSwKKwkJCQkiQUNQSSBfT1NDIHJlcXVlc3QgZmFpbGVkIChjb2RlICVkKVxuIiwgc3RhdHVzKTsKKwl9CisKIAlwY2lfYWNwaV9hZGRfYnVzX3BtX25vdGlmaWVyKGRldmljZSwgcm9vdC0+YnVzKTsKIAlpZiAoZGV2aWNlLT53YWtldXAuZmxhZ3MucnVuX3dha2UpCiAJCWRldmljZV9zZXRfcnVuX3dha2Uocm9vdC0+YnVzLT5icmlkZ2UsIHRydWUpOwpAQCAtNjAwLDYgKzYzMyw4IEBACiAKIHN0YXRpYyBpbnQgX19pbml0IGFjcGlfcGNpX3Jvb3RfaW5pdCh2b2lkKQogeworCWFjcGlfaGVzdF9pbml0KCk7CisKIAlpZiAoYWNwaV9wY2lfZGlzYWJsZWQpCiAJCXJldHVybiAwOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvcG93ZXIuYyBiL2RyaXZlcnMvYWNwaS9wb3dlci5jCmluZGV4IDRjOWMyZmIuLjlhYzJhOWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9wb3dlci5jCisrKyBiL2RyaXZlcnMvYWNwaS9wb3dlci5jCkBAIC01Niw5ICs1Niw2IEBACiAjZGVmaW5lIEFDUElfUE9XRVJfUkVTT1VSQ0VfU1RBVEVfT04JMHgwMQogI2RlZmluZSBBQ1BJX1BPV0VSX1JFU09VUkNFX1NUQVRFX1VOS05PV04gMHhGRgogCi1pbnQgYWNwaV9wb3dlcl9ub2NoZWNrOwotbW9kdWxlX3BhcmFtX25hbWVkKHBvd2VyX25vY2hlY2ssIGFjcGlfcG93ZXJfbm9jaGVjaywgYm9vbCwgMDAwKTsKLQogc3RhdGljIGludCBhY3BpX3Bvd2VyX2FkZChzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSk7CiBzdGF0aWMgaW50IGFjcGlfcG93ZXJfcmVtb3ZlKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlLCBpbnQgdHlwZSk7CiBzdGF0aWMgaW50IGFjcGlfcG93ZXJfcmVzdW1lKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlKTsKQEAgLTE0OCw5ICsxNDUsOCBAQAogCiBzdGF0aWMgaW50IGFjcGlfcG93ZXJfZ2V0X2xpc3Rfc3RhdGUoc3RydWN0IGFjcGlfaGFuZGxlX2xpc3QgKmxpc3QsIGludCAqc3RhdGUpCiB7Ci0JaW50IHJlc3VsdCA9IDAsIHN0YXRlMTsKLQl1MzIgaSA9IDA7Ci0KKwlpbnQgY3VyX3N0YXRlOworCWludCBpID0gMDsKIAogCWlmICghbGlzdCB8fCAhc3RhdGUpCiAJCXJldHVybiAtRUlOVkFMOwpAQCAtMTU4LDI1ICsxNTQsMzMgQEAKIAkvKiBUaGUgc3RhdGUgb2YgdGhlIGxpc3QgaXMgJ29uJyBJRkYgYWxsIHJlc291cmNlcyBhcmUgJ29uJy4gKi8KIAogCWZvciAoaSA9IDA7IGkgPCBsaXN0LT5jb3VudDsgaSsrKSB7Ci0JCS8qCi0JCSAqIFRoZSBzdGF0ZSBvZiB0aGUgcG93ZXIgcmVzb3VyY2UgY2FuIGJlIG9idGFpbmVkIGJ5Ci0JCSAqIHVzaW5nIHRoZSBBQ1BJIGhhbmRsZS4gSW4gc3VjaCBjYXNlIGl0IGlzIHVubmVjZXNzYXJ5IHRvCi0JCSAqIGdldCB0aGUgUG93ZXIgcmVzb3VyY2UgZmlyc3QgYW5kIHRoZW4gZ2V0IGl0cyBzdGF0ZSBhZ2Fpbi4KLQkJICovCi0JCXJlc3VsdCA9IGFjcGlfcG93ZXJfZ2V0X3N0YXRlKGxpc3QtPmhhbmRsZXNbaV0sICZzdGF0ZTEpOworCQlzdHJ1Y3QgYWNwaV9wb3dlcl9yZXNvdXJjZSAqcmVzb3VyY2U7CisJCWFjcGlfaGFuZGxlIGhhbmRsZSA9IGxpc3QtPmhhbmRsZXNbaV07CisJCWludCByZXN1bHQ7CisKKwkJcmVzdWx0ID0gYWNwaV9wb3dlcl9nZXRfY29udGV4dChoYW5kbGUsICZyZXNvdXJjZSk7CiAJCWlmIChyZXN1bHQpCiAJCQlyZXR1cm4gcmVzdWx0OwogCi0JCSpzdGF0ZSA9IHN0YXRlMTsKKwkJbXV0ZXhfbG9jaygmcmVzb3VyY2UtPnJlc291cmNlX2xvY2spOwogCi0JCWlmICgqc3RhdGUgIT0gQUNQSV9QT1dFUl9SRVNPVVJDRV9TVEFURV9PTikKKwkJcmVzdWx0ID0gYWNwaV9wb3dlcl9nZXRfc3RhdGUoaGFuZGxlLCAmY3VyX3N0YXRlKTsKKworCQltdXRleF91bmxvY2soJnJlc291cmNlLT5yZXNvdXJjZV9sb2NrKTsKKworCQlpZiAocmVzdWx0KQorCQkJcmV0dXJuIHJlc3VsdDsKKworCQlpZiAoY3VyX3N0YXRlICE9IEFDUElfUE9XRVJfUkVTT1VSQ0VfU1RBVEVfT04pCiAJCQlicmVhazsKIAl9CiAKIAlBQ1BJX0RFQlVHX1BSSU5UKChBQ1BJX0RCX0lORk8sICJSZXNvdXJjZSBsaXN0IGlzICVzXG4iLAotCQkJICAqc3RhdGUgPyAib24iIDogIm9mZiIpKTsKKwkJCSAgY3VyX3N0YXRlID8gIm9uIiA6ICJvZmYiKSk7CiAKLQlyZXR1cm4gcmVzdWx0OworCSpzdGF0ZSA9IGN1cl9zdGF0ZTsKKworCXJldHVybiAwOwogfQogCiBzdGF0aWMgaW50IF9fYWNwaV9wb3dlcl9vbihzdHJ1Y3QgYWNwaV9wb3dlcl9yZXNvdXJjZSAqcmVzb3VyY2UpCkBAIC0yMjIsNyArMjI2LDcgQEAKIAlyZXR1cm4gcmVzdWx0OwogfQogCi1zdGF0aWMgaW50IGFjcGlfcG93ZXJfb2ZmX2RldmljZShhY3BpX2hhbmRsZSBoYW5kbGUpCitzdGF0aWMgaW50IGFjcGlfcG93ZXJfb2ZmKGFjcGlfaGFuZGxlIGhhbmRsZSkKIHsKIAlpbnQgcmVzdWx0ID0gMDsKIAlhY3BpX3N0YXR1cyBzdGF0dXMgPSBBRV9PSzsKQEAgLTI2Niw2ICsyNzAsMzUgQEAKIAlyZXR1cm4gcmVzdWx0OwogfQogCitzdGF0aWMgdm9pZCBfX2FjcGlfcG93ZXJfb2ZmX2xpc3Qoc3RydWN0IGFjcGlfaGFuZGxlX2xpc3QgKmxpc3QsIGludCBudW1fcmVzKQoreworCWludCBpOworCisJZm9yIChpID0gbnVtX3JlcyAtIDE7IGkgPj0gMCA7IGktLSkKKwkJYWNwaV9wb3dlcl9vZmYobGlzdC0+aGFuZGxlc1tpXSk7Cit9CisKK3N0YXRpYyB2b2lkIGFjcGlfcG93ZXJfb2ZmX2xpc3Qoc3RydWN0IGFjcGlfaGFuZGxlX2xpc3QgKmxpc3QpCit7CisJX19hY3BpX3Bvd2VyX29mZl9saXN0KGxpc3QsIGxpc3QtPmNvdW50KTsKK30KKworc3RhdGljIGludCBhY3BpX3Bvd2VyX29uX2xpc3Qoc3RydWN0IGFjcGlfaGFuZGxlX2xpc3QgKmxpc3QpCit7CisJaW50IHJlc3VsdCA9IDA7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgbGlzdC0+Y291bnQ7IGkrKykgeworCQlyZXN1bHQgPSBhY3BpX3Bvd2VyX29uKGxpc3QtPmhhbmRsZXNbaV0pOworCQlpZiAocmVzdWx0KSB7CisJCQlfX2FjcGlfcG93ZXJfb2ZmX2xpc3QobGlzdCwgaSk7CisJCQlicmVhazsKKwkJfQorCX0KKworCXJldHVybiByZXN1bHQ7Cit9CisKIC8qKgogICogYWNwaV9kZXZpY2Vfc2xlZXBfd2FrZSAtIGV4ZWN1dGUgX0RTVyAoRGV2aWNlIFNsZWVwIFdha2UpIG9yIChkZXByZWNhdGVkIGluCiAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgQUNQSSAzLjApIF9QU1cgKFBvd2VyIFN0YXRlIFdha2UpCkBAIC00MDQsOCArNDM3LDcgQEAKIAogCS8qIENsb3NlIHBvd2VyIHJlc291cmNlICovCiAJZm9yIChpID0gMDsgaSA8IGRldi0+d2FrZXVwLnJlc291cmNlcy5jb3VudDsgaSsrKSB7Ci0JCWludCByZXQgPSBhY3BpX3Bvd2VyX29mZl9kZXZpY2UoCi0JCQkJZGV2LT53YWtldXAucmVzb3VyY2VzLmhhbmRsZXNbaV0pOworCQlpbnQgcmV0ID0gYWNwaV9wb3dlcl9vZmYoZGV2LT53YWtldXAucmVzb3VyY2VzLmhhbmRsZXNbaV0pOwogCQlpZiAocmV0KSB7CiAJCQlwcmludGsoS0VSTl9FUlIgUFJFRklYICJUcmFuc2l0aW9uIHBvd2VyIHN0YXRlXG4iKTsKIAkJCWRldi0+d2FrZXVwLmZsYWdzLnZhbGlkID0gMDsKQEAgLTQyMywxOSArNDU1LDE2IEBACiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIERldmljZSBQb3dlciBNYW5hZ2VtZW50CiAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwogCi1pbnQgYWNwaV9wb3dlcl9nZXRfaW5mZXJyZWRfc3RhdGUoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpCitpbnQgYWNwaV9wb3dlcl9nZXRfaW5mZXJyZWRfc3RhdGUoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UsIGludCAqc3RhdGUpCiB7CiAJaW50IHJlc3VsdCA9IDA7CiAJc3RydWN0IGFjcGlfaGFuZGxlX2xpc3QgKmxpc3QgPSBOVUxMOwogCWludCBsaXN0X3N0YXRlID0gMDsKIAlpbnQgaSA9IDA7CiAKLQotCWlmICghZGV2aWNlKQorCWlmICghZGV2aWNlIHx8ICFzdGF0ZSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKLQlkZXZpY2UtPnBvd2VyLnN0YXRlID0gQUNQSV9TVEFURV9VTktOT1dOOwotCiAJLyoKIAkgKiBXZSBrbm93IGEgZGV2aWNlJ3MgaW5mZXJyZWQgcG93ZXIgc3RhdGUgd2hlbiBhbGwgdGhlIHJlc291cmNlcwogCSAqIHJlcXVpcmVkIGZvciBhIGdpdmVuIEQtc3RhdGUgYXJlICdvbicuCkBAIC00NTAsMjIgKzQ3OSwyNiBAQAogCQkJcmV0dXJuIHJlc3VsdDsKIAogCQlpZiAobGlzdF9zdGF0ZSA9PSBBQ1BJX1BPV0VSX1JFU09VUkNFX1NUQVRFX09OKSB7Ci0JCQlkZXZpY2UtPnBvd2VyLnN0YXRlID0gaTsKKwkJCSpzdGF0ZSA9IGk7CiAJCQlyZXR1cm4gMDsKIAkJfQogCX0KIAotCWRldmljZS0+cG93ZXIuc3RhdGUgPSBBQ1BJX1NUQVRFX0QzOwotCisJKnN0YXRlID0gQUNQSV9TVEFURV9EMzsKIAlyZXR1cm4gMDsKIH0KIAoraW50IGFjcGlfcG93ZXJfb25fcmVzb3VyY2VzKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlLCBpbnQgc3RhdGUpCit7CisJaWYgKCFkZXZpY2UgfHwgc3RhdGUgPCBBQ1BJX1NUQVRFX0QwIHx8IHN0YXRlID4gQUNQSV9TVEFURV9EMykKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlyZXR1cm4gYWNwaV9wb3dlcl9vbl9saXN0KCZkZXZpY2UtPnBvd2VyLnN0YXRlc1tzdGF0ZV0ucmVzb3VyY2VzKTsKK30KKwogaW50IGFjcGlfcG93ZXJfdHJhbnNpdGlvbihzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSwgaW50IHN0YXRlKQogewotCWludCByZXN1bHQgPSAwOwotCXN0cnVjdCBhY3BpX2hhbmRsZV9saXN0ICpjbCA9IE5VTEw7CS8qIEN1cnJlbnQgUmVzb3VyY2VzICovCi0Jc3RydWN0IGFjcGlfaGFuZGxlX2xpc3QgKnRsID0gTlVMTDsJLyogVGFyZ2V0IFJlc291cmNlcyAqLwotCWludCBpID0gMDsKKwlpbnQgcmVzdWx0OwogCiAJaWYgKCFkZXZpY2UgfHwgKHN0YXRlIDwgQUNQSV9TVEFURV9EMCkgfHwgKHN0YXRlID4gQUNQSV9TVEFURV9EMykpCiAJCXJldHVybiAtRUlOVkFMOwpAQCAtNDc3LDM3ICs1MTAsMjAgQEAKIAkgICAgfHwgKGRldmljZS0+cG93ZXIuc3RhdGUgPiBBQ1BJX1NUQVRFX0QzKSkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKLQljbCA9ICZkZXZpY2UtPnBvd2VyLnN0YXRlc1tkZXZpY2UtPnBvd2VyLnN0YXRlXS5yZXNvdXJjZXM7Ci0JdGwgPSAmZGV2aWNlLT5wb3dlci5zdGF0ZXNbc3RhdGVdLnJlc291cmNlczsKLQogCS8qIFRCRDogUmVzb3VyY2VzIG11c3QgYmUgb3JkZXJlZC4gKi8KIAogCS8qCiAJICogRmlyc3Qgd2UgcmVmZXJlbmNlIGFsbCBwb3dlciByZXNvdXJjZXMgcmVxdWlyZWQgaW4gdGhlIHRhcmdldCBsaXN0Ci0JICogKGUuZy4gc28gdGhlIGRldmljZSBkb2Vzbid0IGxvc2UgcG93ZXIgd2hpbGUgdHJhbnNpdGlvbmluZykuCisJICogKGUuZy4gc28gdGhlIGRldmljZSBkb2Vzbid0IGxvc2UgcG93ZXIgd2hpbGUgdHJhbnNpdGlvbmluZykuICBUaGVuLAorCSAqIHdlIGRlcmVmZXJlbmNlIGFsbCBwb3dlciByZXNvdXJjZXMgdXNlZCBpbiB0aGUgY3VycmVudCBsaXN0LgogCSAqLwotCWZvciAoaSA9IDA7IGkgPCB0bC0+Y291bnQ7IGkrKykgewotCQlyZXN1bHQgPSBhY3BpX3Bvd2VyX29uKHRsLT5oYW5kbGVzW2ldKTsKLQkJaWYgKHJlc3VsdCkKLQkJCWdvdG8gZW5kOwotCX0KKwlyZXN1bHQgPSBhY3BpX3Bvd2VyX29uX2xpc3QoJmRldmljZS0+cG93ZXIuc3RhdGVzW3N0YXRlXS5yZXNvdXJjZXMpOworCWlmICghcmVzdWx0KQorCQlhY3BpX3Bvd2VyX29mZl9saXN0KAorCQkJJmRldmljZS0+cG93ZXIuc3RhdGVzW2RldmljZS0+cG93ZXIuc3RhdGVdLnJlc291cmNlcyk7CiAKLQkvKgotCSAqIFRoZW4gd2UgZGVyZWZlcmVuY2UgYWxsIHBvd2VyIHJlc291cmNlcyB1c2VkIGluIHRoZSBjdXJyZW50IGxpc3QuCi0JICovCi0JZm9yIChpID0gMDsgaSA8IGNsLT5jb3VudDsgaSsrKSB7Ci0JCXJlc3VsdCA9IGFjcGlfcG93ZXJfb2ZmX2RldmljZShjbC0+aGFuZGxlc1tpXSk7Ci0JCWlmIChyZXN1bHQpCi0JCQlnb3RvIGVuZDsKLQl9Ci0KLSAgICAgZW5kOgotCWlmIChyZXN1bHQpCi0JCWRldmljZS0+cG93ZXIuc3RhdGUgPSBBQ1BJX1NUQVRFX1VOS05PV047Ci0JZWxzZSB7Ci0JLyogV2Ugc2hvdWxkbid0IGNoYW5nZSB0aGUgc3RhdGUgdGlsbCBhbGwgYWJvdmUgb3BlcmF0aW9ucyBzdWNjZWVkICovCi0JCWRldmljZS0+cG93ZXIuc3RhdGUgPSBzdGF0ZTsKLQl9CisJLyogV2Ugc2hvdWxkbid0IGNoYW5nZSB0aGUgc3RhdGUgdW5sZXNzIHRoZSBhYm92ZSBvcGVyYXRpb25zIHN1Y2NlZWQuICovCisJZGV2aWNlLT5wb3dlci5zdGF0ZSA9IHJlc3VsdCA/IEFDUElfU1RBVEVfVU5LTk9XTiA6IHN0YXRlOwogCiAJcmV0dXJuIHJlc3VsdDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9wcm9jLmMgYi9kcml2ZXJzL2FjcGkvcHJvYy5jCmluZGV4IGFmYWQ2NzcuLmY1Zjk4NjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9wcm9jLmMKKysrIGIvZHJpdmVycy9hY3BpL3Byb2MuYwpAQCAtMzExLDcgKzMxMSw5IEBACiAJCQkgICBkZXYtPnBucC5idXNfaWQsCiAJCQkgICAodTMyKSBkZXYtPndha2V1cC5zbGVlcF9zdGF0ZSwKIAkJCSAgIGRldi0+d2FrZXVwLmZsYWdzLnJ1bl93YWtlID8gJyonIDogJyAnLAotCQkJICAgZGV2LT53YWtldXAuc3RhdGUuZW5hYmxlZCA/ICJlbmFibGVkIiA6ICJkaXNhYmxlZCIpOworCQkJICAgKGRldmljZV9tYXlfd2FrZXVwKCZkZXYtPmRldikKKwkJCSAgICAgfHwgKGxkZXYgJiYgZGV2aWNlX21heV93YWtldXAobGRldikpKSA/CisJCQkgICAgICAgImVuYWJsZWQiIDogImRpc2FibGVkIik7CiAJCWlmIChsZGV2KQogCQkJc2VxX3ByaW50ZihzZXEsICIlczolcyIsCiAJCQkJICAgbGRldi0+YnVzID8gbGRldi0+YnVzLT5uYW1lIDogIm5vLWJ1cyIsCkBAIC0zMjgsOCArMzMwLDEwIEBACiB7CiAJc3RydWN0IGRldmljZSAqZGV2ID0gYWNwaV9nZXRfcGh5c2ljYWxfZGV2aWNlKGFkZXYtPmhhbmRsZSk7CiAKLQlpZiAoZGV2ICYmIGRldmljZV9jYW5fd2FrZXVwKGRldikpCi0JCWRldmljZV9zZXRfd2FrZXVwX2VuYWJsZShkZXYsIGFkZXYtPndha2V1cC5zdGF0ZS5lbmFibGVkKTsKKwlpZiAoZGV2ICYmIGRldmljZV9jYW5fd2FrZXVwKGRldikpIHsKKwkJYm9vbCBlbmFibGUgPSAhZGV2aWNlX21heV93YWtldXAoZGV2KTsKKwkJZGV2aWNlX3NldF93YWtldXBfZW5hYmxlKGRldiwgZW5hYmxlKTsKKwl9CiB9CiAKIHN0YXRpYyBzc2l6ZV90CkBAIC0zNDEsNyArMzQ1LDYgQEAKIAljaGFyIHN0cmJ1Zls1XTsKIAljaGFyIHN0cls1XSA9ICIiOwogCXVuc2lnbmVkIGludCBsZW4gPSBjb3VudDsKLQlzdHJ1Y3QgYWNwaV9kZXZpY2UgKmZvdW5kX2RldiA9IE5VTEw7CiAKIAlpZiAobGVuID4gNCkKIAkJbGVuID0gNDsKQEAgLTM2MSwzMyArMzY0LDEzIEBACiAJCQljb250aW51ZTsKIAogCQlpZiAoIXN0cm5jbXAoZGV2LT5wbnAuYnVzX2lkLCBzdHIsIDQpKSB7Ci0JCQlkZXYtPndha2V1cC5zdGF0ZS5lbmFibGVkID0KLQkJCSAgICBkZXYtPndha2V1cC5zdGF0ZS5lbmFibGVkID8gMCA6IDE7Ci0JCQlmb3VuZF9kZXYgPSBkZXY7Ci0JCQlicmVhazsKLQkJfQotCX0KLQlpZiAoZm91bmRfZGV2KSB7Ci0JCXBoeXNpY2FsX2RldmljZV9lbmFibGVfd2FrZXVwKGZvdW5kX2Rldik7Ci0JCWxpc3RfZm9yX2VhY2hfc2FmZShub2RlLCBuZXh0LCAmYWNwaV93YWtldXBfZGV2aWNlX2xpc3QpIHsKLQkJCXN0cnVjdCBhY3BpX2RldmljZSAqZGV2ID0gY29udGFpbmVyX29mKG5vZGUsCi0JCQkJCQkJICAgICAgIHN0cnVjdAotCQkJCQkJCSAgICAgICBhY3BpX2RldmljZSwKLQkJCQkJCQkgICAgICAgd2FrZXVwX2xpc3QpOwotCi0JCQlpZiAoKGRldiAhPSBmb3VuZF9kZXYpICYmCi0JCQkgICAgKGRldi0+d2FrZXVwLmdwZV9udW1iZXIgPT0KLQkJCSAgICAgZm91bmRfZGV2LT53YWtldXAuZ3BlX251bWJlcikKLQkJCSAgICAmJiAoZGV2LT53YWtldXAuZ3BlX2RldmljZSA9PQotCQkJCWZvdW5kX2Rldi0+d2FrZXVwLmdwZV9kZXZpY2UpKSB7Ci0JCQkJcHJpbnRrKEtFUk5fV0FSTklORwotCQkJCSAgICAgICAiQUNQSTogJyVzJyBhbmQgJyVzJyBoYXZlIHRoZSBzYW1lIEdQRSwgIgotCQkJCSAgICAgICAiY2FuJ3QgZGlzYWJsZS9lbmFibGUgb25lIHNlcGFyYXRlbHlcbiIsCi0JCQkJICAgICAgIGRldi0+cG5wLmJ1c19pZCwgZm91bmRfZGV2LT5wbnAuYnVzX2lkKTsKLQkJCQlkZXYtPndha2V1cC5zdGF0ZS5lbmFibGVkID0KLQkJCQkgICAgZm91bmRfZGV2LT53YWtldXAuc3RhdGUuZW5hYmxlZDsKKwkJCWlmIChkZXZpY2VfY2FuX3dha2V1cCgmZGV2LT5kZXYpKSB7CisJCQkJYm9vbCBlbmFibGUgPSAhZGV2aWNlX21heV93YWtldXAoJmRldi0+ZGV2KTsKKwkJCQlkZXZpY2Vfc2V0X3dha2V1cF9lbmFibGUoJmRldi0+ZGV2LCBlbmFibGUpOworCQkJfSBlbHNlIHsKIAkJCQlwaHlzaWNhbF9kZXZpY2VfZW5hYmxlX3dha2V1cChkZXYpOwogCQkJfQorCQkJYnJlYWs7CiAJCX0KIAl9CiAJbXV0ZXhfdW5sb2NrKCZhY3BpX2RldmljZV9sb2NrKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9wcm9jZXNzb3JfY29yZS5jIGIvZHJpdmVycy9hY3BpL3Byb2Nlc3Nvcl9jb3JlLmMKaW5kZXggYmVjNTYxYy4uM2MxYTJmZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL3Byb2Nlc3Nvcl9jb3JlLmMKKysrIGIvZHJpdmVycy9hY3BpL3Byb2Nlc3Nvcl9jb3JlLmMKQEAgLTIzLDcgKzIzLDcgQEAKIHsKIAlwcmludGsoS0VSTl9OT1RJQ0UgUFJFRklYICIlcyBkZXRlY3RlZCAtICIKIAkJImRpc2FibGluZyBtd2FpdCBmb3IgQ1BVIEMtc3RhdGVzXG4iLCBpZC0+aWRlbnQpOwotCWlkbGVfbm9td2FpdCA9IDE7CisJYm9vdF9vcHRpb25faWRsZV9vdmVycmlkZSA9IElETEVfTk9NV0FJVDsKIAlyZXR1cm4gMDsKIH0KIApAQCAtMjgzLDcgKzI4Myw3IEBACiB7CiAJYWNwaV9zdGF0dXMgc3RhdHVzID0gQUVfT0s7CiAKLQlpZiAoaWRsZV9ub213YWl0KSB7CisJaWYgKGJvb3Rfb3B0aW9uX2lkbGVfb3ZlcnJpZGUgPT0gSURMRV9OT01XQUlUKSB7CiAJCS8qCiAJCSAqIElmIG13YWl0IGlzIGRpc2FibGVkIGZvciBDUFUgQy1zdGF0ZXMsIHRoZSBDMkMzX0ZGSCBhY2Nlc3MKIAkJICogbW9kZSB3aWxsIGJlIGRpc2FibGVkIGluIHRoZSBwYXJhbWV0ZXIgb2YgX1BEQyBvYmplY3QuCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvcHJvY2Vzc29yX2RyaXZlci5jIGIvZHJpdmVycy9hY3BpL3Byb2Nlc3Nvcl9kcml2ZXIuYwppbmRleCA4NWU0ODA0Li4zNjBhNzRlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvcHJvY2Vzc29yX2RyaXZlci5jCisrKyBiL2RyaXZlcnMvYWNwaS9wcm9jZXNzb3JfZHJpdmVyLmMKQEAgLTQwLDEwICs0MCw2IEBACiAjaW5jbHVkZSA8bGludXgvcG0uaD4KICNpbmNsdWRlIDxsaW51eC9jcHVmcmVxLmg+CiAjaW5jbHVkZSA8bGludXgvY3B1Lmg+Ci0jaWZkZWYgQ09ORklHX0FDUElfUFJPQ0ZTCi0jaW5jbHVkZSA8bGludXgvcHJvY19mcy5oPgotI2luY2x1ZGUgPGxpbnV4L3NlcV9maWxlLmg+Ci0jZW5kaWYKICNpbmNsdWRlIDxsaW51eC9kbWkuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGVwYXJhbS5oPgogI2luY2x1ZGUgPGxpbnV4L2NwdWlkbGUuaD4KQEAgLTI0Niw1MyArMjQyLDYgQEAKIAlyZXR1cm4gcmVzdWx0OwogfQogCi0jaWZkZWYgQ09ORklHX0FDUElfUFJPQ0ZTCi1zdGF0aWMgc3RydWN0IHByb2NfZGlyX2VudHJ5ICphY3BpX3Byb2Nlc3Nvcl9kaXIgPSBOVUxMOwotCi1zdGF0aWMgaW50IF9fY3B1aW5pdCBhY3BpX3Byb2Nlc3Nvcl9hZGRfZnMoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpCi17Ci0Jc3RydWN0IHByb2NfZGlyX2VudHJ5ICplbnRyeSA9IE5VTEw7Ci0KLQotCWlmICghYWNwaV9kZXZpY2VfZGlyKGRldmljZSkpIHsKLQkJYWNwaV9kZXZpY2VfZGlyKGRldmljZSkgPSBwcm9jX21rZGlyKGFjcGlfZGV2aWNlX2JpZChkZXZpY2UpLAotCQkJCQkJICAgICBhY3BpX3Byb2Nlc3Nvcl9kaXIpOwotCQlpZiAoIWFjcGlfZGV2aWNlX2RpcihkZXZpY2UpKQotCQkJcmV0dXJuIC1FTk9ERVY7Ci0JfQotCi0JLyogJ3Rocm90dGxpbmcnIFtSL1ddICovCi0JZW50cnkgPSBwcm9jX2NyZWF0ZV9kYXRhKEFDUElfUFJPQ0VTU09SX0ZJTEVfVEhST1RUTElORywKLQkJCQkgU19JRlJFRyB8IFNfSVJVR08gfCBTX0lXVVNSLAotCQkJCSBhY3BpX2RldmljZV9kaXIoZGV2aWNlKSwKLQkJCQkgJmFjcGlfcHJvY2Vzc29yX3Rocm90dGxpbmdfZm9wcywKLQkJCQkgYWNwaV9kcml2ZXJfZGF0YShkZXZpY2UpKTsKLQlpZiAoIWVudHJ5KQotCQlyZXR1cm4gLUVJTzsKLQlyZXR1cm4gMDsKLX0KLXN0YXRpYyBpbnQgYWNwaV9wcm9jZXNzb3JfcmVtb3ZlX2ZzKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlKQotewotCi0JaWYgKGFjcGlfZGV2aWNlX2RpcihkZXZpY2UpKSB7Ci0JCXJlbW92ZV9wcm9jX2VudHJ5KEFDUElfUFJPQ0VTU09SX0ZJTEVfVEhST1RUTElORywKLQkJCQkgIGFjcGlfZGV2aWNlX2RpcihkZXZpY2UpKTsKLQkJcmVtb3ZlX3Byb2NfZW50cnkoYWNwaV9kZXZpY2VfYmlkKGRldmljZSksIGFjcGlfcHJvY2Vzc29yX2Rpcik7Ci0JCWFjcGlfZGV2aWNlX2RpcihkZXZpY2UpID0gTlVMTDsKLQl9Ci0KLQlyZXR1cm4gMDsKLX0KLSNlbHNlCi1zdGF0aWMgaW5saW5lIGludCBhY3BpX3Byb2Nlc3Nvcl9hZGRfZnMoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpCi17Ci0JcmV0dXJuIDA7Ci19Ci1zdGF0aWMgaW5saW5lIGludCBhY3BpX3Byb2Nlc3Nvcl9yZW1vdmVfZnMoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpCi17Ci0JcmV0dXJuIDA7Ci19Ci0jZW5kaWYKIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBEcml2ZXIgSW50ZXJmYWNlCiAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwpAQCAtNDc4LDggKzQyNywxMyBAQAogCWlmIChhY3Rpb24gPT0gQ1BVX09OTElORSAmJiBwcikgewogCQlhY3BpX3Byb2Nlc3Nvcl9wcGNfaGFzX2NoYW5nZWQocHIsIDApOwogCQlhY3BpX3Byb2Nlc3Nvcl9jc3RfaGFzX2NoYW5nZWQocHIpOworCQlhY3BpX3Byb2Nlc3Nvcl9yZWV2YWx1YXRlX3RzdGF0ZShwciwgYWN0aW9uKTsKIAkJYWNwaV9wcm9jZXNzb3JfdHN0YXRlX2hhc19jaGFuZ2VkKHByKTsKIAl9CisJaWYgKGFjdGlvbiA9PSBDUFVfREVBRCAmJiBwcikgeworCQkvKiBpbnZhbGlkYXRlIHRoZSBmbGFnLnRocm90dGxpbmcgYWZ0ZXIgb25lIENQVSBpcyBvZmZsaW5lICovCisJCWFjcGlfcHJvY2Vzc29yX3JlZXZhbHVhdGVfdHN0YXRlKHByLCBhY3Rpb24pOworCX0KIAlyZXR1cm4gTk9USUZZX09LOwogfQogCkBAIC01MzcsMTQgKzQ5MSwxMCBAQAogCiAJcGVyX2NwdShwcm9jZXNzb3JzLCBwci0+aWQpID0gcHI7CiAKLQlyZXN1bHQgPSBhY3BpX3Byb2Nlc3Nvcl9hZGRfZnMoZGV2aWNlKTsKLQlpZiAocmVzdWx0KQotCQlnb3RvIGVycl9mcmVlX2NwdW1hc2s7Ci0KIAlzeXNkZXYgPSBnZXRfY3B1X3N5c2Rldihwci0+aWQpOwogCWlmIChzeXNmc19jcmVhdGVfbGluaygmZGV2aWNlLT5kZXYua29iaiwgJnN5c2Rldi0+a29iaiwgInN5c2RldiIpKSB7CiAJCXJlc3VsdCA9IC1FRkFVTFQ7Ci0JCWdvdG8gZXJyX3JlbW92ZV9mczsKKwkJZ290byBlcnJfZnJlZV9jcHVtYXNrOwogCX0KIAogI2lmZGVmIENPTkZJR19DUFVfRlJFUQpAQCAtNTkwLDggKzU0MCw2IEBACiAJdGhlcm1hbF9jb29saW5nX2RldmljZV91bnJlZ2lzdGVyKHByLT5jZGV2KTsKIGVycl9wb3dlcl9leGl0OgogCWFjcGlfcHJvY2Vzc29yX3Bvd2VyX2V4aXQocHIsIGRldmljZSk7Ci1lcnJfcmVtb3ZlX2ZzOgotCWFjcGlfcHJvY2Vzc29yX3JlbW92ZV9mcyhkZXZpY2UpOwogZXJyX2ZyZWVfY3B1bWFzazoKIAlmcmVlX2NwdW1hc2tfdmFyKHByLT50aHJvdHRsaW5nLnNoYXJlZF9jcHVfbWFwKTsKIApAQCAtNjIwLDggKzU2OCw2IEBACiAKIAlzeXNmc19yZW1vdmVfbGluaygmZGV2aWNlLT5kZXYua29iaiwgInN5c2RldiIpOwogCi0JYWNwaV9wcm9jZXNzb3JfcmVtb3ZlX2ZzKGRldmljZSk7Ci0KIAlpZiAocHItPmNkZXYpIHsKIAkJc3lzZnNfcmVtb3ZlX2xpbmsoJmRldmljZS0+ZGV2LmtvYmosICJ0aGVybWFsX2Nvb2xpbmciKTsKIAkJc3lzZnNfcmVtb3ZlX2xpbmsoJnByLT5jZGV2LT5kZXZpY2Uua29iaiwgImRldmljZSIpOwpAQCAtODU0LDEyICs4MDAsNiBAQAogCiAJbWVtc2V0KCZlcnJhdGEsIDAsIHNpemVvZihlcnJhdGEpKTsKIAotI2lmZGVmIENPTkZJR19BQ1BJX1BST0NGUwotCWFjcGlfcHJvY2Vzc29yX2RpciA9IHByb2NfbWtkaXIoQUNQSV9QUk9DRVNTT1JfQ0xBU1MsIGFjcGlfcm9vdF9kaXIpOwotCWlmICghYWNwaV9wcm9jZXNzb3JfZGlyKQotCQlyZXR1cm4gLUVOT01FTTsKLSNlbmRpZgotCiAJaWYgKCFjcHVpZGxlX3JlZ2lzdGVyX2RyaXZlcigmYWNwaV9pZGxlX2RyaXZlcikpIHsKIAkJcHJpbnRrKEtFUk5fREVCVUcgIkFDUEk6ICVzIHJlZ2lzdGVyZWQgd2l0aCBjcHVpZGxlXG4iLAogCQkJYWNwaV9pZGxlX2RyaXZlci5uYW1lKTsKQEAgLTg4NSwxMCArODI1LDYgQEAKIG91dF9jcHVpZGxlOgogCWNwdWlkbGVfdW5yZWdpc3Rlcl9kcml2ZXIoJmFjcGlfaWRsZV9kcml2ZXIpOwogCi0jaWZkZWYgQ09ORklHX0FDUElfUFJPQ0ZTCi0JcmVtb3ZlX3Byb2NfZW50cnkoQUNQSV9QUk9DRVNTT1JfQ0xBU1MsIGFjcGlfcm9vdF9kaXIpOwotI2VuZGlmCi0KIAlyZXR1cm4gcmVzdWx0OwogfQogCkBAIC05MDcsMTAgKzg0Myw2IEBACiAKIAljcHVpZGxlX3VucmVnaXN0ZXJfZHJpdmVyKCZhY3BpX2lkbGVfZHJpdmVyKTsKIAotI2lmZGVmIENPTkZJR19BQ1BJX1BST0NGUwotCXJlbW92ZV9wcm9jX2VudHJ5KEFDUElfUFJPQ0VTU09SX0NMQVNTLCBhY3BpX3Jvb3RfZGlyKTsKLSNlbmRpZgotCiAJcmV0dXJuOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvcHJvY2Vzc29yX2lkbGUuYyBiL2RyaXZlcnMvYWNwaS9wcm9jZXNzb3JfaWRsZS5jCmluZGV4IGE3NjViODIuLmQ2MTViN2QgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9wcm9jZXNzb3JfaWRsZS5jCisrKyBiL2RyaXZlcnMvYWNwaS9wcm9jZXNzb3JfaWRsZS5jCkBAIC03OSw2ICs3OSwxMyBAQAogc3RhdGljIHVuc2lnbmVkIGludCBsYXRlbmN5X2ZhY3RvciBfX3JlYWRfbW9zdGx5ID0gMjsKIG1vZHVsZV9wYXJhbShsYXRlbmN5X2ZhY3RvciwgdWludCwgMDY0NCk7CiAKK3N0YXRpYyBpbnQgZGlzYWJsZWRfYnlfaWRsZV9ib290X3BhcmFtKHZvaWQpCit7CisJcmV0dXJuIGJvb3Rfb3B0aW9uX2lkbGVfb3ZlcnJpZGUgPT0gSURMRV9QT0xMIHx8CisJCWJvb3Rfb3B0aW9uX2lkbGVfb3ZlcnJpZGUgPT0gSURMRV9GT1JDRV9NV0FJVCB8fAorCQlib290X29wdGlvbl9pZGxlX292ZXJyaWRlID09IElETEVfSEFMVDsKK30KKwogLyoKICAqIElCTSBUaGlua1BhZCBSNDBlIGNyYXNoZXMgbXlzdGVyaW91c2x5IHdoZW4gZ29pbmcgaW50byBDMiBvciBDMy4KICAqIEZvciBub3cgZGlzYWJsZSB0aGlzLiBQcm9iYWJseSBhIGJ1ZyBzb21ld2hlcmUgZWxzZS4KQEAgLTQ1NSw3ICs0NjIsNyBAQAogCQkJCWNvbnRpbnVlOwogCQkJfQogCQkJaWYgKGN4LnR5cGUgPT0gQUNQSV9TVEFURV9DMSAmJgotCQkJCQkoaWRsZV9oYWx0IHx8IGlkbGVfbm9td2FpdCkpIHsKKwkJCSAgICAoYm9vdF9vcHRpb25faWRsZV9vdmVycmlkZSA9PSBJRExFX05PTVdBSVQpKSB7CiAJCQkJLyoKIAkJCQkgKiBJbiBtb3N0IGNhc2VzIHRoZSBDMSBzcGFjZV9pZCBvYnRhaW5lZCBmcm9tCiAJCQkJICogX0NTVCBvYmplY3QgaXMgRklYRURfSEFSRFdBUkUgYWNjZXNzIG1vZGUuCkBAIC0xMDE2LDcgKzEwMjMsNiBAQAogCQlzdGF0ZS0+ZmxhZ3MgPSAwOwogCQlzd2l0Y2ggKGN4LT50eXBlKSB7CiAJCQljYXNlIEFDUElfU1RBVEVfQzE6Ci0JCQlzdGF0ZS0+ZmxhZ3MgfD0gQ1BVSURMRV9GTEFHX1NIQUxMT1c7CiAJCQlpZiAoY3gtPmVudHJ5X21ldGhvZCA9PSBBQ1BJX0NTVEFURV9GRkgpCiAJCQkJc3RhdGUtPmZsYWdzIHw9IENQVUlETEVfRkxBR19USU1FX1ZBTElEOwogCkBAIC0xMDI1LDE2ICsxMDMxLDEzIEBACiAJCQlicmVhazsKIAogCQkJY2FzZSBBQ1BJX1NUQVRFX0MyOgotCQkJc3RhdGUtPmZsYWdzIHw9IENQVUlETEVfRkxBR19CQUxBTkNFRDsKIAkJCXN0YXRlLT5mbGFncyB8PSBDUFVJRExFX0ZMQUdfVElNRV9WQUxJRDsKIAkJCXN0YXRlLT5lbnRlciA9IGFjcGlfaWRsZV9lbnRlcl9zaW1wbGU7CiAJCQlkZXYtPnNhZmVfc3RhdGUgPSBzdGF0ZTsKIAkJCWJyZWFrOwogCiAJCQljYXNlIEFDUElfU1RBVEVfQzM6Ci0JCQlzdGF0ZS0+ZmxhZ3MgfD0gQ1BVSURMRV9GTEFHX0RFRVA7CiAJCQlzdGF0ZS0+ZmxhZ3MgfD0gQ1BVSURMRV9GTEFHX1RJTUVfVkFMSUQ7Ci0JCQlzdGF0ZS0+ZmxhZ3MgfD0gQ1BVSURMRV9GTEFHX0NIRUNLX0JNOwogCQkJc3RhdGUtPmVudGVyID0gcHItPmZsYWdzLmJtX2NoZWNrID8KIAkJCQkJYWNwaV9pZGxlX2VudGVyX2JtIDoKIAkJCQkJYWNwaV9pZGxlX2VudGVyX3NpbXBsZTsKQEAgLTEwNTgsNyArMTA2MSw3IEBACiB7CiAJaW50IHJldCA9IDA7CiAKLQlpZiAoYm9vdF9vcHRpb25faWRsZV9vdmVycmlkZSkKKwlpZiAoZGlzYWJsZWRfYnlfaWRsZV9ib290X3BhcmFtKCkpCiAJCXJldHVybiAwOwogCiAJaWYgKCFwcikKQEAgLTEwODksMTkgKzEwOTIsMTAgQEAKIAlhY3BpX3N0YXR1cyBzdGF0dXMgPSAwOwogCXN0YXRpYyBpbnQgZmlyc3RfcnVuOwogCi0JaWYgKGJvb3Rfb3B0aW9uX2lkbGVfb3ZlcnJpZGUpCisJaWYgKGRpc2FibGVkX2J5X2lkbGVfYm9vdF9wYXJhbSgpKQogCQlyZXR1cm4gMDsKIAogCWlmICghZmlyc3RfcnVuKSB7Ci0JCWlmIChpZGxlX2hhbHQpIHsKLQkJCS8qCi0JCQkgKiBXaGVuIHRoZSBib290IG9wdGlvbiBvZiAiaWRsZT1oYWx0IiBpcyBhZGRlZCwgaGFsdAotCQkJICogaXMgdXNlZCBmb3IgQ1BVIElETEUuCi0JCQkgKiBJbiBzdWNoIGNhc2UgQzIvQzMgaXMgbWVhbmluZ2xlc3MuIFNvIHRoZSBtYXhfY3N0YXRlCi0JCQkgKiBpcyBzZXQgdG8gb25lLgotCQkJICovCi0JCQltYXhfY3N0YXRlID0gMTsKLQkJfQogCQlkbWlfY2hlY2tfc3lzdGVtKHByb2Nlc3Nvcl9wb3dlcl9kbWlfdGFibGUpOwogCQltYXhfY3N0YXRlID0gYWNwaV9wcm9jZXNzb3JfY3N0YXRlX2NoZWNrKG1heF9jc3RhdGUpOwogCQlpZiAobWF4X2NzdGF0ZSA8IEFDUElfQ19TVEFURVNfTUFYKQpAQCAtMTE0Miw3ICsxMTM2LDcgQEAKIGludCBhY3BpX3Byb2Nlc3Nvcl9wb3dlcl9leGl0KHN0cnVjdCBhY3BpX3Byb2Nlc3NvciAqcHIsCiAJCQkgICAgICBzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSkKIHsKLQlpZiAoYm9vdF9vcHRpb25faWRsZV9vdmVycmlkZSkKKwlpZiAoZGlzYWJsZWRfYnlfaWRsZV9ib290X3BhcmFtKCkpCiAJCXJldHVybiAwOwogCiAJY3B1aWRsZV91bnJlZ2lzdGVyX2RldmljZSgmcHItPnBvd2VyLmRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvcHJvY2Vzc29yX3Rocm90dGxpbmcuYyBiL2RyaXZlcnMvYWNwaS9wcm9jZXNzb3JfdGhyb3R0bGluZy5jCmluZGV4IGZmMzYzMjcuLmZhODRlOTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9wcm9jZXNzb3JfdGhyb3R0bGluZy5jCisrKyBiL2RyaXZlcnMvYWNwaS9wcm9jZXNzb3JfdGhyb3R0bGluZy5jCkBAIC0zMiwxMCArMzIsNiBAQAogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L2NwdWZyZXEuaD4KLSNpZmRlZiBDT05GSUdfQUNQSV9QUk9DRlMKLSNpbmNsdWRlIDxsaW51eC9wcm9jX2ZzLmg+Ci0jaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KLSNlbmRpZgogCiAjaW5jbHVkZSA8YXNtL2lvLmg+CiAjaW5jbHVkZSA8YXNtL3VhY2Nlc3MuaD4KQEAgLTM3MCw2ICszNjYsNTggQEAKIH0KIAogLyoKKyAqIFRoaXMgZnVuY3Rpb24gaXMgdXNlZCB0byByZWV2YWx1YXRlIHdoZXRoZXIgdGhlIFQtc3RhdGUgaXMgdmFsaWQKKyAqIGFmdGVyIG9uZSBDUFUgaXMgb25saW5lZC9vZmZsaW5lZC4KKyAqIEl0IGlzIG5vdGVkIHRoYXQgaXQgd29uJ3QgcmVldmFsdWF0ZSB0aGUgZm9sbG93aW5nIHByb3BlcnRpZXMgZm9yCisgKiB0aGUgVC1zdGF0ZS4KKyAqCTEuIENvbnRyb2wgbWV0aG9kLgorICoJMi4gdGhlIG51bWJlciBvZiBzdXBwb3J0ZWQgVC1zdGF0ZQorICoJMy4gVFNEIGRvbWFpbgorICovCit2b2lkIGFjcGlfcHJvY2Vzc29yX3JlZXZhbHVhdGVfdHN0YXRlKHN0cnVjdCBhY3BpX3Byb2Nlc3NvciAqcHIsCisJCQkJCXVuc2lnbmVkIGxvbmcgYWN0aW9uKQoreworCWludCByZXN1bHQgPSAwOworCisJaWYgKGFjdGlvbiA9PSBDUFVfREVBRCkgeworCQkvKiBXaGVuIG9uZSBDUFUgaXMgb2ZmbGluZSwgdGhlIFQtc3RhdGUgdGhyb3R0bGluZworCQkgKiB3aWxsIGJlIGludmFsaWRhdGVkLgorCQkgKi8KKwkJcHItPmZsYWdzLnRocm90dGxpbmcgPSAwOworCQlyZXR1cm47CisJfQorCS8qIHRoZSBmb2xsb3dpbmcgaXMgdG8gcmVjaGVjayB3aGV0aGVyIHRoZSBULXN0YXRlIGlzIHZhbGlkIGZvcgorCSAqIHRoZSBvbmxpbmUgQ1BVCisJICovCisJaWYgKCFwci0+dGhyb3R0bGluZy5zdGF0ZV9jb3VudCkgeworCQkvKiBJZiB0aGUgbnVtYmVyIG9mIFQtc3RhdGUgaXMgaW52YWxpZCwgaXQgaXMKKwkJICogaW52YWxpZGF0ZWQuCisJCSAqLworCQlwci0+ZmxhZ3MudGhyb3R0bGluZyA9IDA7CisJCXJldHVybjsKKwl9CisJcHItPmZsYWdzLnRocm90dGxpbmcgPSAxOworCisJLyogRGlzYWJsZSB0aHJvdHRsaW5nIChpZiBlbmFibGVkKS4gIFdlJ2xsIGxldCBzdWJzZXF1ZW50CisJICogcG9saWN5IChlLmcudGhlcm1hbCkgZGVjaWRlIHRvIGxvd2VyIHBlcmZvcm1hbmNlIGlmIGl0CisJICogc28gY2hvb3NlcywgYnV0IGZvciBub3cgd2UnbGwgY3JhbmsgdXAgdGhlIHNwZWVkLgorCSAqLworCisJcmVzdWx0ID0gYWNwaV9wcm9jZXNzb3JfZ2V0X3Rocm90dGxpbmcocHIpOworCWlmIChyZXN1bHQpCisJCWdvdG8gZW5kOworCisJaWYgKHByLT50aHJvdHRsaW5nLnN0YXRlKSB7CisJCXJlc3VsdCA9IGFjcGlfcHJvY2Vzc29yX3NldF90aHJvdHRsaW5nKHByLCAwLCBmYWxzZSk7CisJCWlmIChyZXN1bHQpCisJCQlnb3RvIGVuZDsKKwl9CisKK2VuZDoKKwlpZiAocmVzdWx0KQorCQlwci0+ZmxhZ3MudGhyb3R0bGluZyA9IDA7Cit9CisvKgogICogX1BUQyAtIFByb2Nlc3NvciBUaHJvdHRsaW5nIENvbnRyb2wgKGFuZCBzdGF0dXMpIHJlZ2lzdGVyIGxvY2F0aW9uCiAgKi8KIHN0YXRpYyBpbnQgYWNwaV9wcm9jZXNzb3JfZ2V0X3Rocm90dGxpbmdfY29udHJvbChzdHJ1Y3QgYWNwaV9wcm9jZXNzb3IgKnByKQpAQCAtODc2LDcgKzkyNCwxMSBAQAogCSAqLwogCWNwdW1hc2tfY29weShzYXZlZF9tYXNrLCAmY3VycmVudC0+Y3B1c19hbGxvd2VkKTsKIAkvKiBGSVhNRTogdXNlIHdvcmtfb25fY3B1KCkgKi8KLQlzZXRfY3B1c19hbGxvd2VkX3B0cihjdXJyZW50LCBjcHVtYXNrX29mKHByLT5pZCkpOworCWlmIChzZXRfY3B1c19hbGxvd2VkX3B0cihjdXJyZW50LCBjcHVtYXNrX29mKHByLT5pZCkpKSB7CisJCS8qIENhbid0IG1pZ3JhdGUgdG8gdGhlIHRhcmdldCBwci0+aWQgQ1BVLiBFeGl0ICovCisJCWZyZWVfY3B1bWFza192YXIoc2F2ZWRfbWFzayk7CisJCXJldHVybiAtRU5PREVWOworCX0KIAlyZXQgPSBwci0+dGhyb3R0bGluZy5hY3BpX3Byb2Nlc3Nvcl9nZXRfdGhyb3R0bGluZyhwcik7CiAJLyogcmVzdG9yZSB0aGUgcHJldmlvdXMgc3RhdGUgKi8KIAlzZXRfY3B1c19hbGxvd2VkX3B0cihjdXJyZW50LCBzYXZlZF9tYXNrKTsKQEAgLTEwNTEsNiArMTEwMywxNCBAQAogCQlyZXR1cm4gLUVOT01FTTsKIAl9CiAKKwlpZiAoY3B1X2lzX29mZmxpbmUocHItPmlkKSkgeworCQkvKgorCQkgKiB0aGUgY3B1IHBvaW50ZWQgYnkgcHItPmlkIGlzIG9mZmxpbmUuIFVubmVjZXNzYXJ5IHRvIGNoYW5nZQorCQkgKiB0aGUgdGhyb3R0bGluZyBzdGF0ZSBhbnkgbW9yZS4KKwkJICovCisJCXJldHVybiAtRU5PREVWOworCX0KKwogCWNwdW1hc2tfY29weShzYXZlZF9tYXNrLCAmY3VycmVudC0+Y3B1c19hbGxvd2VkKTsKIAl0X3N0YXRlLnRhcmdldF9zdGF0ZSA9IHN0YXRlOwogCXBfdGhyb3R0bGluZyA9ICYocHItPnRocm90dGxpbmcpOwpAQCAtMTA3NCw3ICsxMTM0LDExIEBACiAJICovCiAJaWYgKHBfdGhyb3R0bGluZy0+c2hhcmVkX3R5cGUgPT0gRE9NQUlOX0NPT1JEX1RZUEVfU1dfQU5ZKSB7CiAJCS8qIEZJWE1FOiB1c2Ugd29ya19vbl9jcHUoKSAqLwotCQlzZXRfY3B1c19hbGxvd2VkX3B0cihjdXJyZW50LCBjcHVtYXNrX29mKHByLT5pZCkpOworCQlpZiAoc2V0X2NwdXNfYWxsb3dlZF9wdHIoY3VycmVudCwgY3B1bWFza19vZihwci0+aWQpKSkgeworCQkJLyogQ2FuJ3QgbWlncmF0ZSB0byB0aGUgcHItPmlkIENQVS4gRXhpdCAqLworCQkJcmV0ID0gLUVOT0RFVjsKKwkJCWdvdG8gZXhpdDsKKwkJfQogCQlyZXQgPSBwX3Rocm90dGxpbmctPmFjcGlfcHJvY2Vzc29yX3NldF90aHJvdHRsaW5nKHByLAogCQkJCQkJdF9zdGF0ZS50YXJnZXRfc3RhdGUsIGZvcmNlKTsKIAl9IGVsc2UgewpAQCAtMTEwNiw3ICsxMTcwLDggQEAKIAkJCX0KIAkJCXRfc3RhdGUuY3B1ID0gaTsKIAkJCS8qIEZJWE1FOiB1c2Ugd29ya19vbl9jcHUoKSAqLwotCQkJc2V0X2NwdXNfYWxsb3dlZF9wdHIoY3VycmVudCwgY3B1bWFza19vZihpKSk7CisJCQlpZiAoc2V0X2NwdXNfYWxsb3dlZF9wdHIoY3VycmVudCwgY3B1bWFza19vZihpKSkpCisJCQkJY29udGludWU7CiAJCQlyZXQgPSBtYXRjaF9wci0+dGhyb3R0bGluZy4KIAkJCQlhY3BpX3Byb2Nlc3Nvcl9zZXRfdGhyb3R0bGluZygKIAkJCQltYXRjaF9wciwgdF9zdGF0ZS50YXJnZXRfc3RhdGUsIGZvcmNlKTsKQEAgLTExMjYsNiArMTE5MSw3IEBACiAJLyogcmVzdG9yZSB0aGUgcHJldmlvdXMgc3RhdGUgKi8KIAkvKiBGSVhNRTogdXNlIHdvcmtfb25fY3B1KCkgKi8KIAlzZXRfY3B1c19hbGxvd2VkX3B0cihjdXJyZW50LCBzYXZlZF9tYXNrKTsKK2V4aXQ6CiAJZnJlZV9jcHVtYXNrX3ZhcihvbmxpbmVfdGhyb3R0bGluZ19jcHVzKTsKIAlmcmVlX2NwdW1hc2tfdmFyKHNhdmVkX21hc2spOwogCXJldHVybiByZXQ7CkBAIC0xMjE2LDExMyArMTI4MiwzIEBACiAJcmV0dXJuIHJlc3VsdDsKIH0KIAotI2lmZGVmIENPTkZJR19BQ1BJX1BST0NGUwotLyogcHJvYyBpbnRlcmZhY2UgKi8KLXN0YXRpYyBpbnQgYWNwaV9wcm9jZXNzb3JfdGhyb3R0bGluZ19zZXFfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwKLQkJCQkJICAgICAgdm9pZCAqb2Zmc2V0KQotewotCXN0cnVjdCBhY3BpX3Byb2Nlc3NvciAqcHIgPSBzZXEtPnByaXZhdGU7Ci0JaW50IGkgPSAwOwotCWludCByZXN1bHQgPSAwOwotCi0JaWYgKCFwcikKLQkJZ290byBlbmQ7Ci0KLQlpZiAoIShwci0+dGhyb3R0bGluZy5zdGF0ZV9jb3VudCA+IDApKSB7Ci0JCXNlcV9wdXRzKHNlcSwgIjxub3Qgc3VwcG9ydGVkPlxuIik7Ci0JCWdvdG8gZW5kOwotCX0KLQotCXJlc3VsdCA9IGFjcGlfcHJvY2Vzc29yX2dldF90aHJvdHRsaW5nKHByKTsKLQotCWlmIChyZXN1bHQpIHsKLQkJc2VxX3B1dHMoc2VxLAotCQkJICJDb3VsZCBub3QgZGV0ZXJtaW5lIGN1cnJlbnQgdGhyb3R0bGluZyBzdGF0ZS5cbiIpOwotCQlnb3RvIGVuZDsKLQl9Ci0KLQlzZXFfcHJpbnRmKHNlcSwgInN0YXRlIGNvdW50OiAgICAgICAgICAgICAlZFxuIgotCQkgICAiYWN0aXZlIHN0YXRlOiAgICAgICAgICAgIFQlZFxuIgotCQkgICAic3RhdGUgYXZhaWxhYmxlOiBUJWQgdG8gVCVkXG4iLAotCQkgICBwci0+dGhyb3R0bGluZy5zdGF0ZV9jb3VudCwgcHItPnRocm90dGxpbmcuc3RhdGUsCi0JCSAgIHByLT50aHJvdHRsaW5nX3BsYXRmb3JtX2xpbWl0LAotCQkgICBwci0+dGhyb3R0bGluZy5zdGF0ZV9jb3VudCAtIDEpOwotCi0Jc2VxX3B1dHMoc2VxLCAic3RhdGVzOlxuIik7Ci0JaWYgKHByLT50aHJvdHRsaW5nLmFjcGlfcHJvY2Vzc29yX2dldF90aHJvdHRsaW5nID09Ci0JCQlhY3BpX3Byb2Nlc3Nvcl9nZXRfdGhyb3R0bGluZ19mYWR0KSB7Ci0JCWZvciAoaSA9IDA7IGkgPCBwci0+dGhyb3R0bGluZy5zdGF0ZV9jb3VudDsgaSsrKQotCQkJc2VxX3ByaW50ZihzZXEsICIgICAlY1QlZDogICAgICAgICAgICAgICAgICAlMDJkJSVcbiIsCi0JCQkJICAgKGkgPT0gcHItPnRocm90dGxpbmcuc3RhdGUgPyAnKicgOiAnICcpLCBpLAotCQkJCSAgIChwci0+dGhyb3R0bGluZy5zdGF0ZXNbaV0ucGVyZm9ybWFuY2UgPyBwci0+Ci0JCQkJICAgIHRocm90dGxpbmcuc3RhdGVzW2ldLnBlcmZvcm1hbmNlIC8gMTAgOiAwKSk7Ci0JfSBlbHNlIHsKLQkJZm9yIChpID0gMDsgaSA8IHByLT50aHJvdHRsaW5nLnN0YXRlX2NvdW50OyBpKyspCi0JCQlzZXFfcHJpbnRmKHNlcSwgIiAgICVjVCVkOiAgICAgICAgICAgICAgICAgICUwMmQlJVxuIiwKLQkJCQkgICAoaSA9PSBwci0+dGhyb3R0bGluZy5zdGF0ZSA/ICcqJyA6ICcgJyksIGksCi0JCQkJICAgKGludClwci0+dGhyb3R0bGluZy5zdGF0ZXNfdHNzW2ldLgotCQkJCSAgIGZyZXFwZXJjZW50YWdlKTsKLQl9Ci0KLSAgICAgIGVuZDoKLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIGludCBhY3BpX3Byb2Nlc3Nvcl90aHJvdHRsaW5nX29wZW5fZnMoc3RydWN0IGlub2RlICppbm9kZSwKLQkJCQkJICAgICBzdHJ1Y3QgZmlsZSAqZmlsZSkKLXsKLQlyZXR1cm4gc2luZ2xlX29wZW4oZmlsZSwgYWNwaV9wcm9jZXNzb3JfdGhyb3R0bGluZ19zZXFfc2hvdywKLQkJCSAgIFBERShpbm9kZSktPmRhdGEpOwotfQotCi1zdGF0aWMgc3NpemVfdCBhY3BpX3Byb2Nlc3Nvcl93cml0ZV90aHJvdHRsaW5nKHN0cnVjdCBmaWxlICpmaWxlLAotCQkJCQkgICAgICAgY29uc3QgY2hhciBfX3VzZXIgKiBidWZmZXIsCi0JCQkJCSAgICAgICBzaXplX3QgY291bnQsIGxvZmZfdCAqIGRhdGEpCi17Ci0JaW50IHJlc3VsdCA9IDA7Ci0Jc3RydWN0IHNlcV9maWxlICptID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwotCXN0cnVjdCBhY3BpX3Byb2Nlc3NvciAqcHIgPSBtLT5wcml2YXRlOwotCWNoYXIgc3RhdGVfc3RyaW5nWzVdID0gIiI7Ci0JY2hhciAqY2hhcnAgPSBOVUxMOwotCXNpemVfdCBzdGF0ZV92YWwgPSAwOwotCWNoYXIgdG1wYnVmWzVdID0gIiI7Ci0KLQlpZiAoIXByIHx8IChjb3VudCA+IHNpemVvZihzdGF0ZV9zdHJpbmcpIC0gMSkpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JaWYgKGNvcHlfZnJvbV91c2VyKHN0YXRlX3N0cmluZywgYnVmZmVyLCBjb3VudCkpCi0JCXJldHVybiAtRUZBVUxUOwotCi0Jc3RhdGVfc3RyaW5nW2NvdW50XSA9ICdcMCc7Ci0JaWYgKChjb3VudCA+IDApICYmIChzdGF0ZV9zdHJpbmdbY291bnQtMV0gPT0gJ1xuJykpCi0JCXN0YXRlX3N0cmluZ1tjb3VudC0xXSA9ICdcMCc7Ci0KLQljaGFycCA9IHN0YXRlX3N0cmluZzsKLQlpZiAoKHN0YXRlX3N0cmluZ1swXSA9PSAndCcpIHx8IChzdGF0ZV9zdHJpbmdbMF0gPT0gJ1QnKSkKLQkJY2hhcnArKzsKLQotCXN0YXRlX3ZhbCA9IHNpbXBsZV9zdHJ0b3VsKGNoYXJwLCBOVUxMLCAwKTsKLQlpZiAoc3RhdGVfdmFsID49IHByLT50aHJvdHRsaW5nLnN0YXRlX2NvdW50KQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCXNucHJpbnRmKHRtcGJ1ZiwgNSwgIiV6dSIsIHN0YXRlX3ZhbCk7Ci0KLQlpZiAoc3RyY21wKHRtcGJ1ZiwgY2hhcnApICE9IDApCi0JCXJldHVybiAtRUlOVkFMOwotCi0JcmVzdWx0ID0gYWNwaV9wcm9jZXNzb3Jfc2V0X3Rocm90dGxpbmcocHIsIHN0YXRlX3ZhbCwgZmFsc2UpOwotCWlmIChyZXN1bHQpCi0JCXJldHVybiByZXN1bHQ7Ci0KLQlyZXR1cm4gY291bnQ7Ci19Ci0KLWNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgYWNwaV9wcm9jZXNzb3JfdGhyb3R0bGluZ19mb3BzID0gewotCS5vd25lciA9IFRISVNfTU9EVUxFLAotCS5vcGVuID0gYWNwaV9wcm9jZXNzb3JfdGhyb3R0bGluZ19vcGVuX2ZzLAotCS5yZWFkID0gc2VxX3JlYWQsCi0JLndyaXRlID0gYWNwaV9wcm9jZXNzb3Jfd3JpdGVfdGhyb3R0bGluZywKLQkubGxzZWVrID0gc2VxX2xzZWVrLAotCS5yZWxlYXNlID0gc2luZ2xlX3JlbGVhc2UsCi19OwotI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvc2JzLmMgYi9kcml2ZXJzL2FjcGkvc2JzLmMKaW5kZXggZTVkYmVkYi4uNTFhZTM3OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL3Nicy5jCisrKyBiL2RyaXZlcnMvYWNwaS9zYnMuYwpAQCAtNDg0LDYgKzQ4NCw4IEBACiAJCWNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgKnN0YXRlX2ZvcHMsCiAJCWNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgKmFsYXJtX2ZvcHMsIHZvaWQgKmRhdGEpCiB7CisJcHJpbnRrKEtFUk5fV0FSTklORyBQUkVGSVggIkRlcHJlY2F0ZWQgcHJvY2ZzIEkvRiBmb3IgU0JTIGlzIGxvYWRlZCwiCisJCQkiIHBsZWFzZSByZXRyeSB3aXRoIENPTkZJR19BQ1BJX1BST0NGU19QT1dFUiBjbGVhcmVkXG4iKTsKIAlpZiAoISpkaXIpIHsKIAkJKmRpciA9IHByb2NfbWtkaXIoZGlyX25hbWUsIHBhcmVudF9kaXIpOwogCQlpZiAoISpkaXIpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9zY2FuLmMgYi9kcml2ZXJzL2FjcGkvc2Nhbi5jCmluZGV4IDI5ZWY1MDUuLmI5OWU2MjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9zY2FuLmMKKysrIGIvZHJpdmVycy9hY3BpL3NjYW4uYwpAQCAtNzc4LDcgKzc3OCw3IEBACiAJCXdha2V1cC0+cmVzb3VyY2VzLmhhbmRsZXNbaV0gPSBlbGVtZW50LT5yZWZlcmVuY2UuaGFuZGxlOwogCX0KIAotCWFjcGlfZ3BlX2Nhbl93YWtlKHdha2V1cC0+Z3BlX2RldmljZSwgd2FrZXVwLT5ncGVfbnVtYmVyKTsKKwlhY3BpX3NldHVwX2dwZV9mb3Jfd2FrZShoYW5kbGUsIHdha2V1cC0+Z3BlX2RldmljZSwgd2FrZXVwLT5ncGVfbnVtYmVyKTsKIAogIG91dDoKIAlrZnJlZShidWZmZXIucG9pbnRlcik7CkBAIC04MDMsNyArODAzLDcgQEAKIAkvKiBQb3dlciBidXR0b24sIExpZCBzd2l0Y2ggYWx3YXlzIGVuYWJsZSB3YWtldXAgKi8KIAlpZiAoIWFjcGlfbWF0Y2hfZGV2aWNlX2lkcyhkZXZpY2UsIGJ1dHRvbl9kZXZpY2VfaWRzKSkgewogCQlkZXZpY2UtPndha2V1cC5mbGFncy5ydW5fd2FrZSA9IDE7Ci0JCWRldmljZS0+d2FrZXVwLmZsYWdzLmFsd2F5c19lbmFibGVkID0gMTsKKwkJZGV2aWNlX3NldF93YWtldXBfY2FwYWJsZSgmZGV2aWNlLT5kZXYsIHRydWUpOwogCQlyZXR1cm47CiAJfQogCkBAIC04MTUsMTYgKzgxNSwyMiBAQAogCQkJCSEhKGV2ZW50X3N0YXR1cyAmIEFDUElfRVZFTlRfRkxBR19IQU5ETEUpOwogfQogCi1zdGF0aWMgaW50IGFjcGlfYnVzX2dldF93YWtldXBfZGV2aWNlX2ZsYWdzKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlKQorc3RhdGljIHZvaWQgYWNwaV9idXNfZ2V0X3dha2V1cF9kZXZpY2VfZmxhZ3Moc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpCiB7CisJYWNwaV9oYW5kbGUgdGVtcDsKIAlhY3BpX3N0YXR1cyBzdGF0dXMgPSAwOwogCWludCBwc3dfZXJyb3I7CiAKKwkvKiBQcmVzZW5jZSBvZiBfUFJXIGluZGljYXRlcyB3YWtlIGNhcGFibGUgKi8KKwlzdGF0dXMgPSBhY3BpX2dldF9oYW5kbGUoZGV2aWNlLT5oYW5kbGUsICJfUFJXIiwgJnRlbXApOworCWlmIChBQ1BJX0ZBSUxVUkUoc3RhdHVzKSkKKwkJcmV0dXJuOworCiAJc3RhdHVzID0gYWNwaV9idXNfZXh0cmFjdF93YWtldXBfZGV2aWNlX3Bvd2VyX3BhY2thZ2UoZGV2aWNlLT5oYW5kbGUsCiAJCQkJCQkJICAgICAgJmRldmljZS0+d2FrZXVwKTsKIAlpZiAoQUNQSV9GQUlMVVJFKHN0YXR1cykpIHsKIAkJQUNQSV9FWENFUFRJT04oKEFFX0lORk8sIHN0YXR1cywgIkV4dHJhY3RpbmcgX1BSVyBwYWNrYWdlIikpOwotCQlnb3RvIGVuZDsKKwkJcmV0dXJuOwogCX0KIAogCWRldmljZS0+d2FrZXVwLmZsYWdzLnZhbGlkID0gMTsKQEAgLTg0MCwxMyArODQ2LDEwIEBACiAJaWYgKHBzd19lcnJvcikKIAkJQUNQSV9ERUJVR19QUklOVCgoQUNQSV9EQl9JTkZPLAogCQkJCSJlcnJvciBpbiBfRFNXIG9yIF9QU1cgZXZhbHVhdGlvblxuIikpOwotCi1lbmQ6Ci0JaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKQotCQlkZXZpY2UtPmZsYWdzLndha2VfY2FwYWJsZSA9IDA7Ci0JcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyB2b2lkIGFjcGlfYnVzX2FkZF9wb3dlcl9yZXNvdXJjZShhY3BpX2hhbmRsZSBoYW5kbGUpOworCiBzdGF0aWMgaW50IGFjcGlfYnVzX2dldF9wb3dlcl9mbGFncyhzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSkKIHsKIAlhY3BpX3N0YXR1cyBzdGF0dXMgPSAwOwpAQCAtODc1LDggKzg3OCwxMiBAQAogCQlhY3BpX2V2YWx1YXRlX3JlZmVyZW5jZShkZXZpY2UtPmhhbmRsZSwgb2JqZWN0X25hbWUsIE5VTEwsCiAJCQkJCSZwcy0+cmVzb3VyY2VzKTsKIAkJaWYgKHBzLT5yZXNvdXJjZXMuY291bnQpIHsKKwkJCWludCBqOworCiAJCQlkZXZpY2UtPnBvd2VyLmZsYWdzLnBvd2VyX3Jlc291cmNlcyA9IDE7CiAJCQlwcy0+ZmxhZ3MudmFsaWQgPSAxOworCQkJZm9yIChqID0gMDsgaiA8IHBzLT5yZXNvdXJjZXMuY291bnQ7IGorKykKKwkJCQlhY3BpX2J1c19hZGRfcG93ZXJfcmVzb3VyY2UocHMtPnJlc291cmNlcy5oYW5kbGVzW2pdKTsKIAkJfQogCiAJCS8qIEV2YWx1YXRlICJfUFN4IiB0byBzZWUgaWYgd2UgY2FuIGRvIGV4cGxpY2l0IHNldHMgKi8KQEAgLTkwMSwxMCArOTA4LDcgQEAKIAlkZXZpY2UtPnBvd2VyLnN0YXRlc1tBQ1BJX1NUQVRFX0QzXS5mbGFncy52YWxpZCA9IDE7CiAJZGV2aWNlLT5wb3dlci5zdGF0ZXNbQUNQSV9TVEFURV9EM10ucG93ZXIgPSAwOwogCi0JLyogVEJEOiBTeXN0ZW0gd2FrZSBzdXBwb3J0IGFuZCByZXNvdXJjZSByZXF1aXJlbWVudHMuICovCi0KLQlkZXZpY2UtPnBvd2VyLnN0YXRlID0gQUNQSV9TVEFURV9VTktOT1dOOwotCWFjcGlfYnVzX2dldF9wb3dlcihkZXZpY2UtPmhhbmRsZSwgJihkZXZpY2UtPnBvd2VyLnN0YXRlKSk7CisJYWNwaV9idXNfaW5pdF9wb3dlcihkZXZpY2UpOwogCiAJcmV0dXJuIDA7CiB9CkBAIC05NDcsMTEgKzk1MSw2IEBACiAJaWYgKEFDUElfU1VDQ0VTUyhzdGF0dXMpKQogCQlkZXZpY2UtPmZsYWdzLnBvd2VyX21hbmFnZWFibGUgPSAxOwogCi0JLyogUHJlc2VuY2Ugb2YgX1BSVyBpbmRpY2F0ZXMgd2FrZSBjYXBhYmxlICovCi0Jc3RhdHVzID0gYWNwaV9nZXRfaGFuZGxlKGRldmljZS0+aGFuZGxlLCAiX1BSVyIsICZ0ZW1wKTsKLQlpZiAoQUNQSV9TVUNDRVNTKHN0YXR1cykpCi0JCWRldmljZS0+ZmxhZ3Mud2FrZV9jYXBhYmxlID0gMTsKLQogCS8qIFRCRDogUGVyZm9ybWFuY2UgbWFuYWdlbWVudCAqLwogCiAJcmV0dXJuIDA7CkBAIC0xMjc4LDExICsxMjc3LDcgQEAKIAkgKiBXYWtldXAgZGV2aWNlIG1hbmFnZW1lbnQKIAkgKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAJICovCi0JaWYgKGRldmljZS0+ZmxhZ3Mud2FrZV9jYXBhYmxlKSB7Ci0JCXJlc3VsdCA9IGFjcGlfYnVzX2dldF93YWtldXBfZGV2aWNlX2ZsYWdzKGRldmljZSk7Ci0JCWlmIChyZXN1bHQpCi0JCQlnb3RvIGVuZDsKLQl9CisJYWNwaV9idXNfZ2V0X3dha2V1cF9kZXZpY2VfZmxhZ3MoZGV2aWNlKTsKIAogCS8qCiAJICogUGVyZm9ybWFuY2UgTWFuYWdlbWVudApAQCAtMTMyNiw2ICsxMzIxLDIwIEBACiAjZGVmaW5lIEFDUElfU1RBX0RFRkFVTFQgKEFDUElfU1RBX0RFVklDRV9QUkVTRU5UIHwgQUNQSV9TVEFfREVWSUNFX0VOQUJMRUQgfCBcCiAJCQkgIEFDUElfU1RBX0RFVklDRV9VSSAgICAgIHwgQUNQSV9TVEFfREVWSUNFX0ZVTkNUSU9OSU5HKQogCitzdGF0aWMgdm9pZCBhY3BpX2J1c19hZGRfcG93ZXJfcmVzb3VyY2UoYWNwaV9oYW5kbGUgaGFuZGxlKQoreworCXN0cnVjdCBhY3BpX2J1c19vcHMgb3BzID0geworCQkuYWNwaV9vcF9hZGQgPSAxLAorCQkuYWNwaV9vcF9zdGFydCA9IDEsCisJfTsKKwlzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSA9IE5VTEw7CisKKwlhY3BpX2J1c19nZXRfZGV2aWNlKGhhbmRsZSwgJmRldmljZSk7CisJaWYgKCFkZXZpY2UpCisJCWFjcGlfYWRkX3NpbmdsZV9vYmplY3QoJmRldmljZSwgaGFuZGxlLCBBQ1BJX0JVU19UWVBFX1BPV0VSLAorCQkJCQlBQ1BJX1NUQV9ERUZBVUxULCAmb3BzKTsKK30KKwogc3RhdGljIGludCBhY3BpX2J1c190eXBlX2FuZF9zdGF0dXMoYWNwaV9oYW5kbGUgaGFuZGxlLCBpbnQgKnR5cGUsCiAJCQkJICAgIHVuc2lnbmVkIGxvbmcgbG9uZyAqc3RhKQogewpAQCAtMTM3MSw3ICsxMzgwLDYgQEAKIAlzdHJ1Y3QgYWNwaV9idXNfb3BzICpvcHMgPSBjb250ZXh0OwogCWludCB0eXBlOwogCXVuc2lnbmVkIGxvbmcgbG9uZyBzdGE7Ci0Jc3RydWN0IGFjcGlfZGV2aWNlX3dha2V1cCB3YWtldXA7CiAJc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2U7CiAJYWNwaV9zdGF0dXMgc3RhdHVzOwogCWludCByZXN1bHQ7CkBAIC0xMzgyLDcgKzEzOTAsMTMgQEAKIAogCWlmICghKHN0YSAmIEFDUElfU1RBX0RFVklDRV9QUkVTRU5UKSAmJgogCSAgICAhKHN0YSAmIEFDUElfU1RBX0RFVklDRV9GVU5DVElPTklORykpIHsKLQkJYWNwaV9idXNfZXh0cmFjdF93YWtldXBfZGV2aWNlX3Bvd2VyX3BhY2thZ2UoaGFuZGxlLCAmd2FrZXVwKTsKKwkJc3RydWN0IGFjcGlfZGV2aWNlX3dha2V1cCB3YWtldXA7CisJCWFjcGlfaGFuZGxlIHRlbXA7CisKKwkJc3RhdHVzID0gYWNwaV9nZXRfaGFuZGxlKGhhbmRsZSwgIl9QUlciLCAmdGVtcCk7CisJCWlmIChBQ1BJX1NVQ0NFU1Moc3RhdHVzKSkKKwkJCWFjcGlfYnVzX2V4dHJhY3Rfd2FrZXVwX2RldmljZV9wb3dlcl9wYWNrYWdlKGhhbmRsZSwKKwkJCQkJCQkJICAgICAmd2FrZXVwKTsKIAkJcmV0dXJuIEFFX0NUUkxfREVQVEg7CiAJfQogCkBAIC0xNDY3LDcgKzE0ODEsNyBAQAogCiAJcmVzdWx0ID0gYWNwaV9idXNfc2NhbihkZXZpY2UtPmhhbmRsZSwgJm9wcywgTlVMTCk7CiAKLQlhY3BpX3VwZGF0ZV9ncGVzKCk7CisJYWNwaV91cGRhdGVfYWxsX2dwZXMoKTsKIAogCXJldHVybiByZXN1bHQ7CiB9CkBAIC0xNTczLDYgKzE1ODcsOCBAQAogCQlwcmludGsoS0VSTl9FUlIgUFJFRklYICJDb3VsZCBub3QgcmVnaXN0ZXIgYnVzIHR5cGVcbiIpOwogCX0KIAorCWFjcGlfcG93ZXJfaW5pdCgpOworCiAJLyoKIAkgKiBFbnVtZXJhdGUgZGV2aWNlcyBpbiB0aGUgQUNQSSBuYW1lc3BhY2UuCiAJICovCkBAIC0xNTg0LDcgKzE2MDAsNyBAQAogCWlmIChyZXN1bHQpCiAJCWFjcGlfZGV2aWNlX3VucmVnaXN0ZXIoYWNwaV9yb290LCBBQ1BJX0JVU19SRU1PVkFMX05PUk1BTCk7CiAJZWxzZQotCQlhY3BpX3VwZGF0ZV9ncGVzKCk7CisJCWFjcGlfdXBkYXRlX2FsbF9ncGVzKCk7CiAKIAlyZXR1cm4gcmVzdWx0OwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL3NsZWVwLmMgYi9kcml2ZXJzL2FjcGkvc2xlZXAuYwppbmRleCBjNDIzMjMxLi5kNmE4Y2QxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvc2xlZXAuYworKysgYi9kcml2ZXJzL2FjcGkvc2xlZXAuYwpAQCAtMTI0LDggKzEyNCw3IEBACiBzdGF0aWMgaW50IGFjcGlfcG1fcHJlX3N1c3BlbmQodm9pZCkKIHsKIAlhY3BpX3BtX2ZyZWV6ZSgpOwotCXN1c3BlbmRfbnZzX3NhdmUoKTsKLQlyZXR1cm4gMDsKKwlyZXR1cm4gc3VzcGVuZF9udnNfc2F2ZSgpOwogfQogCiAvKioKQEAgLTE1MSw3ICsxNTAsNyBAQAogewogCWludCBlcnJvciA9IF9fYWNwaV9wbV9wcmVwYXJlKCk7CiAJaWYgKCFlcnJvcikKLQkJYWNwaV9wbV9wcmVfc3VzcGVuZCgpOworCQllcnJvciA9IGFjcGlfcG1fcHJlX3N1c3BlbmQoKTsKIAogCXJldHVybiBlcnJvcjsKIH0KQEAgLTE2Nyw2ICsxNjYsNyBAQAogCXUzMiBhY3BpX3N0YXRlID0gYWNwaV90YXJnZXRfc2xlZXBfc3RhdGU7CiAKIAlhY3BpX2VjX3VuYmxvY2tfdHJhbnNhY3Rpb25zKCk7CisJc3VzcGVuZF9udnNfZnJlZSgpOwogCiAJaWYgKGFjcGlfc3RhdGUgPT0gQUNQSV9TVEFURV9TMCkKIAkJcmV0dXJuOwpAQCAtMTg3LDcgKzE4Nyw2IEBACiAgKi8KIHN0YXRpYyB2b2lkIGFjcGlfcG1fZW5kKHZvaWQpCiB7Ci0Jc3VzcGVuZF9udnNfZnJlZSgpOwogCS8qCiAJICogVGhpcyBpcyBuZWNlc3NhcnkgaW4gY2FzZSBhY3BpX3BtX2ZpbmlzaCgpIGlzIG5vdCBjYWxsZWQgZHVyaW5nIGEKIAkgKiBmYWlsaW5nIHRyYW5zaXRpb24gdG8gYSBzbGVlcCBzdGF0ZS4KQEAgLTQzNSw2ICs0MzQsMTQgQEAKIAkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJWR04tTlcxMzBEIiksCiAJCX0sCiAJfSwKKwl7CisJLmNhbGxiYWNrID0gaW5pdF9udnNfbm9zYXZlLAorCS5pZGVudCA9ICJBdmVyYXRlYyBBVjEwMjAtRUQyIiwKKwkubWF0Y2hlcyA9IHsKKwkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiQVZFUkFURUMiKSwKKwkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICIxMDAwIFNlcmllcyIpLAorCQl9LAorCX0sCiAJe30sCiB9OwogI2VuZGlmIC8qIENPTkZJR19TVVNQRU5EICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvc3lzZnMuYyBiL2RyaXZlcnMvYWNwaS9zeXNmcy5jCmluZGV4IGY4NTg4ZjguLjYxODkxZTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9zeXNmcy5jCisrKyBiL2RyaXZlcnMvYWNwaS9zeXNmcy5jCkBAIC00MzgsNyArNDM4LDcgQEAKIAlyZXR1cm47CiB9CiAKLXZvaWQgYWNwaV9vc19ncGVfY291bnQodTMyIGdwZV9udW1iZXIpCitzdGF0aWMgdm9pZCBncGVfY291bnQodTMyIGdwZV9udW1iZXIpCiB7CiAJYWNwaV9ncGVfY291bnQrKzsKIApAQCAtNDU0LDcgKzQ1NCw3IEBACiAJcmV0dXJuOwogfQogCi12b2lkIGFjcGlfb3NfZml4ZWRfZXZlbnRfY291bnQodTMyIGV2ZW50X251bWJlcikKK3N0YXRpYyB2b2lkIGZpeGVkX2V2ZW50X2NvdW50KHUzMiBldmVudF9udW1iZXIpCiB7CiAJaWYgKCFhbGxfY291bnRlcnMpCiAJCXJldHVybjsKQEAgLTQ2OCw2ICs0NjgsMTYgQEAKIAlyZXR1cm47CiB9CiAKK3N0YXRpYyB2b2lkIGFjcGlfZ2JsX2V2ZW50X2hhbmRsZXIodTMyIGV2ZW50X3R5cGUsIGFjcGlfaGFuZGxlIGRldmljZSwKKwl1MzIgZXZlbnRfbnVtYmVyLCB2b2lkICpjb250ZXh0KQoreworCWlmIChldmVudF90eXBlID09IEFDUElfRVZFTlRfVFlQRV9HUEUpCisJCWdwZV9jb3VudChldmVudF9udW1iZXIpOworCisJaWYgKGV2ZW50X3R5cGUgPT0gQUNQSV9FVkVOVF9UWVBFX0ZJWEVEKQorCQlmaXhlZF9ldmVudF9jb3VudChldmVudF9udW1iZXIpOworfQorCiBzdGF0aWMgaW50IGdldF9zdGF0dXModTMyIGluZGV4LCBhY3BpX2V2ZW50X3N0YXR1cyAqc3RhdHVzLAogCQkgICAgICBhY3BpX2hhbmRsZSAqaGFuZGxlKQogewpAQCAtNjAxLDYgKzYxMSw3IEBACiAKIHZvaWQgYWNwaV9pcnFfc3RhdHNfaW5pdCh2b2lkKQogeworCWFjcGlfc3RhdHVzIHN0YXR1czsKIAlpbnQgaTsKIAogCWlmIChhbGxfY291bnRlcnMpCkBAIC02MTksNiArNjMwLDEwIEBACiAJaWYgKGFsbF9jb3VudGVycyA9PSBOVUxMKQogCQlnb3RvIGZhaWw7CiAKKwlzdGF0dXMgPSBhY3BpX2luc3RhbGxfZ2xvYmFsX2V2ZW50X2hhbmRsZXIoYWNwaV9nYmxfZXZlbnRfaGFuZGxlciwgTlVMTCk7CisJaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKQorCQlnb3RvIGZhaWw7CisKIAljb3VudGVyX2F0dHJzID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGtvYmpfYXR0cmlidXRlKSAqIChudW1fY291bnRlcnMpLAogCQkJCUdGUF9LRVJORUwpOwogCWlmIChjb3VudGVyX2F0dHJzID09IE5VTEwpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvdGhlcm1hbC5jIGIvZHJpdmVycy9hY3BpL3RoZXJtYWwuYwppbmRleCA1YTI3YjBhLi4yNjA3ZTE3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvdGhlcm1hbC5jCisrKyBiL2RyaXZlcnMvYWNwaS90aGVybWFsLmMKQEAgLTEwNTksOCArMTA1OSw5IEBACiAJCQlicmVhazsKIAkJdHotPnRyaXBzLmFjdGl2ZVtpXS5mbGFncy5lbmFibGVkID0gMTsKIAkJZm9yIChqID0gMDsgaiA8IHR6LT50cmlwcy5hY3RpdmVbaV0uZGV2aWNlcy5jb3VudDsgaisrKSB7Ci0JCQlyZXN1bHQgPSBhY3BpX2J1c19nZXRfcG93ZXIodHotPnRyaXBzLmFjdGl2ZVtpXS5kZXZpY2VzLgotCQkJICAgIGhhbmRsZXNbal0sICZwb3dlcl9zdGF0ZSk7CisJCQlyZXN1bHQgPSBhY3BpX2J1c191cGRhdGVfcG93ZXIoCisJCQkJCXR6LT50cmlwcy5hY3RpdmVbaV0uZGV2aWNlcy5oYW5kbGVzW2pdLAorCQkJCQkmcG93ZXJfc3RhdGUpOwogCQkJaWYgKHJlc3VsdCB8fCAocG93ZXJfc3RhdGUgIT0gQUNQSV9TVEFURV9EMCkpIHsKIAkJCQl0ei0+dHJpcHMuYWN0aXZlW2ldLmZsYWdzLmVuYWJsZWQgPSAwOwogCQkJCWJyZWFrOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL3ZpZGVvLmMgYi9kcml2ZXJzL2FjcGkvdmlkZW8uYwppbmRleCAxNWEwZmRlLi45MGY4Zjc2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvdmlkZW8uYworKysgYi9kcml2ZXJzL2FjcGkvdmlkZW8uYwpAQCAtMzMsNyArMzMsNiBAQAogI2luY2x1ZGUgPGxpbnV4L2lucHV0Lmg+CiAjaW5jbHVkZSA8bGludXgvYmFja2xpZ2h0Lmg+CiAjaW5jbHVkZSA8bGludXgvdGhlcm1hbC5oPgotI2luY2x1ZGUgPGxpbnV4L3ZpZGVvX291dHB1dC5oPgogI2luY2x1ZGUgPGxpbnV4L3NvcnQuaD4KICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KICNpbmNsdWRlIDxsaW51eC9wY2lfaWRzLmg+CkBAIC04MSw2ICs4MCwxMyBAQAogc3RhdGljIGludCBhbGxvd19kdXBsaWNhdGVzOwogbW9kdWxlX3BhcmFtKGFsbG93X2R1cGxpY2F0ZXMsIGJvb2wsIDA2NDQpOwogCisvKgorICogU29tZSBCSU9TZXMgY2xhaW0gdGhleSB1c2UgbWluaW11bSBiYWNrbGlnaHQgYXQgYm9vdCwKKyAqIGFuZCB0aGlzIG1heSBicmluZyBkaW1taW5nIHNjcmVlbiBhZnRlciBib290CisgKi8KK3N0YXRpYyBpbnQgdXNlX2Jpb3NfaW5pdGlhbF9iYWNrbGlnaHQgPSAxOworbW9kdWxlX3BhcmFtKHVzZV9iaW9zX2luaXRpYWxfYmFja2xpZ2h0LCBib29sLCAwNjQ0KTsKKwogc3RhdGljIGludCByZWdpc3Rlcl9jb3VudCA9IDA7CiBzdGF0aWMgaW50IGFjcGlfdmlkZW9fYnVzX2FkZChzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSk7CiBzdGF0aWMgaW50IGFjcGlfdmlkZW9fYnVzX3JlbW92ZShzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSwgaW50IHR5cGUpOwpAQCAtMTcyLDkgKzE3OCw2IEBACiAJdTggX0JRQzoxOwkJLyogR2V0IGN1cnJlbnQgYnJpZ2h0bmVzcyBsZXZlbCAqLwogCXU4IF9CQ1E6MTsJCS8qIFNvbWUgYnVnZ3kgQklPUyB1c2VzIF9CQ1EgaW5zdGVhZCBvZiBfQlFDICovCiAJdTggX0REQzoxOwkJLypSZXR1cm4gdGhlIEVESUQgZm9yIHRoaXMgZGV2aWNlICovCi0JdTggX0RDUzoxOwkJLypSZXR1cm4gc3RhdHVzIG9mIG91dHB1dCBkZXZpY2UgKi8KLQl1OCBfREdTOjE7CQkvKlF1ZXJ5IGdyYXBoaWNzIHN0YXRlICovCi0JdTggX0RTUzoxOwkJLypEZXZpY2Ugc3RhdGUgc2V0ICovCiB9OwogCiBzdHJ1Y3QgYWNwaV92aWRlb19icmlnaHRuZXNzX2ZsYWdzIHsKQEAgLTIwMiw3ICsyMDUsNiBAQAogCXN0cnVjdCBhY3BpX3ZpZGVvX2RldmljZV9icmlnaHRuZXNzICpicmlnaHRuZXNzOwogCXN0cnVjdCBiYWNrbGlnaHRfZGV2aWNlICpiYWNrbGlnaHQ7CiAJc3RydWN0IHRoZXJtYWxfY29vbGluZ19kZXZpY2UgKmNvb2xpbmdfZGV2OwotCXN0cnVjdCBvdXRwdXRfZGV2aWNlICpvdXRwdXRfZGV2OwogfTsKIAogc3RhdGljIGNvbnN0IGNoYXIgZGV2aWNlX2RlY29kZVtdWzMwXSA9IHsKQEAgLTIyNiwxMCArMjI4LDYgQEAKIAkJCQkgICAgIHUzMiBsZXZlbF9jdXJyZW50LCB1MzIgZXZlbnQpOwogc3RhdGljIGludCBhY3BpX3ZpZGVvX3N3aXRjaF9icmlnaHRuZXNzKHN0cnVjdCBhY3BpX3ZpZGVvX2RldmljZSAqZGV2aWNlLAogCQkJCQkgaW50IGV2ZW50KTsKLXN0YXRpYyBpbnQgYWNwaV92aWRlb19kZXZpY2VfZ2V0X3N0YXRlKHN0cnVjdCBhY3BpX3ZpZGVvX2RldmljZSAqZGV2aWNlLAotCQkJICAgIHVuc2lnbmVkIGxvbmcgbG9uZyAqc3RhdGUpOwotc3RhdGljIGludCBhY3BpX3ZpZGVvX291dHB1dF9nZXQoc3RydWN0IG91dHB1dF9kZXZpY2UgKm9kKTsKLXN0YXRpYyBpbnQgYWNwaV92aWRlb19kZXZpY2Vfc2V0X3N0YXRlKHN0cnVjdCBhY3BpX3ZpZGVvX2RldmljZSAqZGV2aWNlLCBpbnQgc3RhdGUpOwogCiAvKmJhY2tsaWdodCBkZXZpY2Ugc3lzZnMgc3VwcG9ydCovCiBzdGF0aWMgaW50IGFjcGlfdmlkZW9fZ2V0X2JyaWdodG5lc3Moc3RydWN0IGJhY2tsaWdodF9kZXZpY2UgKmJkKQpAQCAtMjY1LDMwICsyNjMsNiBAQAogCS51cGRhdGVfc3RhdHVzICA9IGFjcGlfdmlkZW9fc2V0X2JyaWdodG5lc3MsCiB9OwogCi0vKnZpZGVvIG91dHB1dCBkZXZpY2Ugc3lzZnMgc3VwcG9ydCovCi1zdGF0aWMgaW50IGFjcGlfdmlkZW9fb3V0cHV0X2dldChzdHJ1Y3Qgb3V0cHV0X2RldmljZSAqb2QpCi17Ci0JdW5zaWduZWQgbG9uZyBsb25nIHN0YXRlOwotCXN0cnVjdCBhY3BpX3ZpZGVvX2RldmljZSAqdmQgPQotCQkoc3RydWN0IGFjcGlfdmlkZW9fZGV2aWNlICopZGV2X2dldF9kcnZkYXRhKCZvZC0+ZGV2KTsKLQlhY3BpX3ZpZGVvX2RldmljZV9nZXRfc3RhdGUodmQsICZzdGF0ZSk7Ci0JcmV0dXJuIChpbnQpc3RhdGU7Ci19Ci0KLXN0YXRpYyBpbnQgYWNwaV92aWRlb19vdXRwdXRfc2V0KHN0cnVjdCBvdXRwdXRfZGV2aWNlICpvZCkKLXsKLQl1bnNpZ25lZCBsb25nIHN0YXRlID0gb2QtPnJlcXVlc3Rfc3RhdGU7Ci0Jc3RydWN0IGFjcGlfdmlkZW9fZGV2aWNlICp2ZD0KLQkJKHN0cnVjdCBhY3BpX3ZpZGVvX2RldmljZSAqKWRldl9nZXRfZHJ2ZGF0YSgmb2QtPmRldik7Ci0JcmV0dXJuIGFjcGlfdmlkZW9fZGV2aWNlX3NldF9zdGF0ZSh2ZCwgc3RhdGUpOwotfQotCi1zdGF0aWMgc3RydWN0IG91dHB1dF9wcm9wZXJ0aWVzIGFjcGlfb3V0cHV0X3Byb3BlcnRpZXMgPSB7Ci0JLnNldF9zdGF0ZSA9IGFjcGlfdmlkZW9fb3V0cHV0X3NldCwKLQkuZ2V0X3N0YXR1cyA9IGFjcGlfdmlkZW9fb3V0cHV0X2dldCwKLX07Ci0KLQogLyogdGhlcm1hbCBjb29saW5nIGRldmljZSBjYWxsYmFja3MgKi8KIHN0YXRpYyBpbnQgdmlkZW9fZ2V0X21heF9zdGF0ZShzdHJ1Y3QgdGhlcm1hbF9jb29saW5nX2RldmljZSAqY29vbGluZ19kZXYsIHVuc2lnbmVkCiAJCQkgICAgICAgbG9uZyAqc3RhdGUpCkBAIC0zNDQsMzQgKzMxOCw2IEBACiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVmlkZW8gTWFuYWdlbWVudAogICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KIAotLyogZGV2aWNlICovCi0KLXN0YXRpYyBpbnQKLWFjcGlfdmlkZW9fZGV2aWNlX2dldF9zdGF0ZShzdHJ1Y3QgYWNwaV92aWRlb19kZXZpY2UgKmRldmljZSwKLQkJCSAgICB1bnNpZ25lZCBsb25nIGxvbmcgKnN0YXRlKQotewotCWludCBzdGF0dXM7Ci0KLQlzdGF0dXMgPSBhY3BpX2V2YWx1YXRlX2ludGVnZXIoZGV2aWNlLT5kZXYtPmhhbmRsZSwgIl9EQ1MiLCBOVUxMLCBzdGF0ZSk7Ci0KLQlyZXR1cm4gc3RhdHVzOwotfQotCi1zdGF0aWMgaW50Ci1hY3BpX3ZpZGVvX2RldmljZV9zZXRfc3RhdGUoc3RydWN0IGFjcGlfdmlkZW9fZGV2aWNlICpkZXZpY2UsIGludCBzdGF0ZSkKLXsKLQlpbnQgc3RhdHVzOwotCXVuaW9uIGFjcGlfb2JqZWN0IGFyZzAgPSB7IEFDUElfVFlQRV9JTlRFR0VSIH07Ci0Jc3RydWN0IGFjcGlfb2JqZWN0X2xpc3QgYXJncyA9IHsgMSwgJmFyZzAgfTsKLQl1bnNpZ25lZCBsb25nIGxvbmcgcmV0OwotCi0KLQlhcmcwLmludGVnZXIudmFsdWUgPSBzdGF0ZTsKLQlzdGF0dXMgPSBhY3BpX2V2YWx1YXRlX2ludGVnZXIoZGV2aWNlLT5kZXYtPmhhbmRsZSwgIl9EU1MiLCAmYXJncywgJnJldCk7Ci0KLQlyZXR1cm4gc3RhdHVzOwotfQotCiBzdGF0aWMgaW50CiBhY3BpX3ZpZGVvX2RldmljZV9sY2RfcXVlcnlfbGV2ZWxzKHN0cnVjdCBhY3BpX3ZpZGVvX2RldmljZSAqZGV2aWNlLAogCQkJCSAgIHVuaW9uIGFjcGlfb2JqZWN0ICoqbGV2ZWxzKQpAQCAtNzY2LDkgKzcxMiwxMSBAQAogCQkgKiB3aGVuIGludm9rZWQgZm9yIHRoZSBmaXJzdCB0aW1lLCBpLmUuIGxldmVsX29sZCBpcyBpbnZhbGlkLgogCQkgKiBzZXQgdGhlIGJhY2tsaWdodCB0byBtYXhfbGV2ZWwgaW4gdGhpcyBjYXNlCiAJCSAqLwotCQlmb3IgKGkgPSAyOyBpIDwgYnItPmNvdW50OyBpKyspCi0JCQlpZiAobGV2ZWxfb2xkID09IGJyLT5sZXZlbHNbaV0pCi0JCQkJbGV2ZWwgPSBsZXZlbF9vbGQ7CisJCWlmICh1c2VfYmlvc19pbml0aWFsX2JhY2tsaWdodCkgeworCQkJZm9yIChpID0gMjsgaSA8IGJyLT5jb3VudDsgaSsrKQorCQkJCWlmIChsZXZlbF9vbGQgPT0gYnItPmxldmVsc1tpXSkKKwkJCQkJbGV2ZWwgPSBsZXZlbF9vbGQ7CisJCX0KIAkJZ290byBzZXRfbGV2ZWw7CiAJfQogCkBAIC04MzEsMTUgKzc3OSw2IEBACiAJaWYgKEFDUElfU1VDQ0VTUyhhY3BpX2dldF9oYW5kbGUoZGV2aWNlLT5kZXYtPmhhbmRsZSwgIl9EREMiLCAmaF9kdW1teTEpKSkgewogCQlkZXZpY2UtPmNhcC5fRERDID0gMTsKIAl9Ci0JaWYgKEFDUElfU1VDQ0VTUyhhY3BpX2dldF9oYW5kbGUoZGV2aWNlLT5kZXYtPmhhbmRsZSwgIl9EQ1MiLCAmaF9kdW1teTEpKSkgewotCQlkZXZpY2UtPmNhcC5fRENTID0gMTsKLQl9Ci0JaWYgKEFDUElfU1VDQ0VTUyhhY3BpX2dldF9oYW5kbGUoZGV2aWNlLT5kZXYtPmhhbmRsZSwgIl9ER1MiLCAmaF9kdW1teTEpKSkgewotCQlkZXZpY2UtPmNhcC5fREdTID0gMTsKLQl9Ci0JaWYgKEFDUElfU1VDQ0VTUyhhY3BpX2dldF9oYW5kbGUoZGV2aWNlLT5kZXYtPmhhbmRsZSwgIl9EU1MiLCAmaF9kdW1teTEpKSkgewotCQlkZXZpY2UtPmNhcC5fRFNTID0gMTsKLQl9CiAKIAlpZiAoYWNwaV92aWRlb19iYWNrbGlnaHRfc3VwcG9ydCgpKSB7CiAJCXN0cnVjdCBiYWNrbGlnaHRfcHJvcGVydGllcyBwcm9wczsKQEAgLTkwNCwyMSArODQzLDYgQEAKIAkJCXByaW50ayhLRVJOX0VSUiBQUkVGSVggIkNyZWF0ZSBzeXNmcyBsaW5rXG4iKTsKIAogCX0KLQotCWlmIChhY3BpX3ZpZGVvX2Rpc3BsYXlfc3dpdGNoX3N1cHBvcnQoKSkgewotCi0JCWlmIChkZXZpY2UtPmNhcC5fRENTICYmIGRldmljZS0+Y2FwLl9EU1MpIHsKLQkJCXN0YXRpYyBpbnQgY291bnQ7Ci0JCQljaGFyICpuYW1lOwotCQkJbmFtZSA9IGthc3ByaW50ZihHRlBfS0VSTkVMLCAiYWNwaV92aWRlbyVkIiwgY291bnQpOwotCQkJaWYgKCFuYW1lKQotCQkJCXJldHVybjsKLQkJCWNvdW50Kys7Ci0JCQlkZXZpY2UtPm91dHB1dF9kZXYgPSB2aWRlb19vdXRwdXRfcmVnaXN0ZXIobmFtZSwKLQkJCQkJTlVMTCwgZGV2aWNlLCAmYWNwaV9vdXRwdXRfcHJvcGVydGllcyk7Ci0JCQlrZnJlZShuYW1lKTsKLQkJfQotCX0KIH0KIAogLyoKQEAgLTEzNjAsNiArMTI4NCw5IEBACiAJCWlmICghdmlkZW9fZGV2aWNlKQogCQkJY29udGludWU7CiAKKwkJaWYgKCF2aWRlb19kZXZpY2UtPmNhcC5fRERDKQorCQkJY29udGludWU7CisKIAkJaWYgKHR5cGUpIHsKIAkJCXN3aXRjaCAodHlwZSkgewogCQkJY2FzZSBBQ1BJX1ZJREVPX0RJU1BMQVlfQ1JUOgpAQCAtMTQ1Miw3ICsxMzc5LDYgQEAKIAkJdGhlcm1hbF9jb29saW5nX2RldmljZV91bnJlZ2lzdGVyKGRldmljZS0+Y29vbGluZ19kZXYpOwogCQlkZXZpY2UtPmNvb2xpbmdfZGV2ID0gTlVMTDsKIAl9Ci0JdmlkZW9fb3V0cHV0X3VucmVnaXN0ZXIoZGV2aWNlLT5vdXRwdXRfZGV2KTsKIAogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL3ZpZGVvX2RldGVjdC5jIGIvZHJpdmVycy9hY3BpL3ZpZGVvX2RldGVjdC5jCmluZGV4IGI4MzY3NjEuLjQyZDNkNzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS92aWRlb19kZXRlY3QuYworKysgYi9kcml2ZXJzL2FjcGkvdmlkZW9fZGV0ZWN0LmMKQEAgLTE3LDE1ICsxNywxNCBAQAogICogY2FwYWJpbGl0aWVzIHRoZSBncmFwaGljcyBjYXJkcyBwbHVnZ2VkIGluIHN1cHBvcnQuIFRoZSBjaGVjayBmb3IgZ2VuZXJhbAogICogdmlkZW8gY2FwYWJpbGl0aWVzIHdpbGwgYmUgdHJpZ2dlcmVkIGJ5IHRoZSBmaXJzdCBjYWxsZXIgb2YKICAqIGFjcGlfdmlkZW9fZ2V0X2NhcGFiaWxpdGllcyhOVUxMKTsgd2hpY2ggd2lsbCBoYXBwZW4gd2hlbiB0aGUgZmlyc3QKLSAqIGJhY2tsaWdodCAob3IgZGlzcGxheSBvdXRwdXQpIHN3aXRjaGluZyBzdXBwb3J0aW5nIGRyaXZlciBjYWxsczoKKyAqIGJhY2tsaWdodCBzd2l0Y2hpbmcgc3VwcG9ydGluZyBkcml2ZXIgY2FsbHM6CiAgKiBhY3BpX3ZpZGVvX2JhY2tsaWdodF9zdXBwb3J0KCk7CiAgKgogICogRGVwZW5kaW5nIG9uIHdoZXRoZXIgQUNQSSBncmFwaGljcyBleHRlbnNpb25zIChjbXAuIEFDUEkgc3BlYyBBcHBlbmRpeCBCKQogICogYXJlIGF2YWlsYWJsZSwgdmlkZW8ua28gc2hvdWxkIGJlIHVzZWQgdG8gaGFuZGxlIHRoZSBkZXZpY2UuCiAgKgogICogT3RoZXJ3aXNlIHZlbmRvciBzcGVjaWZpYyBkcml2ZXJzIGxpa2UgdGhpbmtwYWRfYWNwaSwgYXN1c19hY3BpLAotICogc29ueV9hY3BpLC4uLiBjYW4gdGFrZSBjYXJlIGFib3V0IGJhY2tsaWdodCBicmlnaHRuZXNzIGFuZCBkaXNwbGF5IG91dHB1dAotICogc3dpdGNoaW5nLgorICogc29ueV9hY3BpLC4uLiBjYW4gdGFrZSBjYXJlIGFib3V0IGJhY2tsaWdodCBicmlnaHRuZXNzLgogICoKICAqIElmIENPTkZJR19BQ1BJX1ZJREVPIGlzIG5laXRoZXIgc2V0IGFzICJjb21waWxlZCBpbiIgKHkpIG5vciBhcyBhIG1vZHVsZSAobSkKICAqIHRoaXMgZmlsZSB3aWxsIG5vdCBiZSBjb21waWxlZCwgYWNwaV92aWRlb19nZXRfY2FwYWJpbGl0aWVzKCkgYW5kCkBAIC04MywxMSArODIsNiBAQAogCWlmICghZGV2aWNlKQogCQlyZXR1cm4gMDsKIAotCS8qIElzIHRoaXMgZGV2aWNlIGFibGUgdG8gc3VwcG9ydCB2aWRlbyBzd2l0Y2hpbmcgPyAqLwotCWlmIChBQ1BJX1NVQ0NFU1MoYWNwaV9nZXRfaGFuZGxlKGRldmljZS0+aGFuZGxlLCAiX0RPRCIsICZoX2R1bW15KSkgfHwKLQkgICAgQUNQSV9TVUNDRVNTKGFjcGlfZ2V0X2hhbmRsZShkZXZpY2UtPmhhbmRsZSwgIl9ET1MiLCAmaF9kdW1teSkpKQotCQl2aWRlb19jYXBzIHw9IEFDUElfVklERU9fT1VUUFVUX1NXSVRDSElORzsKLQogCS8qIElzIHRoaXMgZGV2aWNlIGFibGUgdG8gcmV0cmlldmUgYSB2aWRlbyBST00gPyAqLwogCWlmIChBQ1BJX1NVQ0NFU1MoYWNwaV9nZXRfaGFuZGxlKGRldmljZS0+aGFuZGxlLCAiX1JPTSIsICZoX2R1bW15KSkpCiAJCXZpZGVvX2NhcHMgfD0gQUNQSV9WSURFT19ST01fQVZBSUxBQkxFOwpAQCAtMTYxLDggKzE1NSw2IEBACiAJCSAqCiAJCSAqICAgaWYgKGRtaV9uYW1lX2luX3ZlbmRvcnMoIlhZIikpIHsKIAkJICoJYWNwaV92aWRlb19zdXBwb3J0IHw9Ci0JCSAqCQlBQ1BJX1ZJREVPX09VVFBVVF9TV0lUQ0hJTkdfRE1JX1ZFTkRPUjsKLQkJICoJYWNwaV92aWRlb19zdXBwb3J0IHw9CiAJCSAqCQlBQ1BJX1ZJREVPX0JBQ0tMSUdIVF9ETUlfVkVORE9SOwogCQkgKn0KIAkJICovCkBAIC0yMTIsMzMgKzIwNCw4IEBACiBFWFBPUlRfU1lNQk9MKGFjcGlfdmlkZW9fYmFja2xpZ2h0X3N1cHBvcnQpOwogCiAvKgotICogUmV0dXJucyB0cnVlIGlmIHZpZGVvLmtvIGNhbiBkbyBkaXNwbGF5IG91dHB1dCBzd2l0Y2hpbmcuCi0gKiBUaGlzIGRvZXMgbm90IHdvcmsgd2VsbC9hdCBhbGwgd2l0aCBiaW5hcnkgZ3JhcGhpY3MgZHJpdmVycwotICogd2hpY2ggZGlzYWJsZSBzeXN0ZW0gaW8gcmFuZ2VzIGFuZCBkbyBpdCBvbiB0aGVpciBvd24uCi0gKi8KLWludCBhY3BpX3ZpZGVvX2Rpc3BsYXlfc3dpdGNoX3N1cHBvcnQodm9pZCkKLXsKLQlpZiAoIWFjcGlfdmlkZW9fY2Fwc19jaGVja2VkKQotCQlhY3BpX3ZpZGVvX2dldF9jYXBhYmlsaXRpZXMoTlVMTCk7Ci0KLQlpZiAoYWNwaV92aWRlb19zdXBwb3J0ICYgQUNQSV9WSURFT19PVVRQVVRfU1dJVENISU5HX0ZPUkNFX1ZFTkRPUikKLQkJcmV0dXJuIDA7Ci0JZWxzZSBpZiAoYWNwaV92aWRlb19zdXBwb3J0ICYgQUNQSV9WSURFT19PVVRQVVRfU1dJVENISU5HX0ZPUkNFX1ZJREVPKQotCQlyZXR1cm4gMTsKLQotCWlmIChhY3BpX3ZpZGVvX3N1cHBvcnQgJiBBQ1BJX1ZJREVPX09VVFBVVF9TV0lUQ0hJTkdfRE1JX1ZFTkRPUikKLQkJcmV0dXJuIDA7Ci0JZWxzZSBpZiAoYWNwaV92aWRlb19zdXBwb3J0ICYgQUNQSV9WSURFT19PVVRQVVRfU1dJVENISU5HX0RNSV9WSURFTykKLQkJcmV0dXJuIDE7Ci0KLQlyZXR1cm4gYWNwaV92aWRlb19zdXBwb3J0ICYgQUNQSV9WSURFT19PVVRQVVRfU1dJVENISU5HOwotfQotRVhQT1JUX1NZTUJPTChhY3BpX3ZpZGVvX2Rpc3BsYXlfc3dpdGNoX3N1cHBvcnQpOwotCi0vKgotICogVXNlIGFjcGlfZGlzcGxheV9vdXRwdXQ9dmVuZG9yL3ZpZGVvIG9yIGFjcGlfYmFja2xpZ2h0PXZlbmRvci92aWRlbwotICogVG8gZm9yY2UgdGhhdCBiYWNrbGlnaHQgb3IgZGlzcGxheSBvdXRwdXQgc3dpdGNoaW5nIGlzIHByb2Nlc3NlZCBieSB2ZW5kb3IKLSAqIHNwZWNpZmljIGFjcGkgZHJpdmVycyBvciB2aWRlby5rbyBkcml2ZXIuCisgKiBVc2UgYWNwaV9iYWNrbGlnaHQ9dmVuZG9yL3ZpZGVvIHRvIGZvcmNlIHRoYXQgYmFja2xpZ2h0IHN3aXRjaGluZworICogaXMgcHJvY2Vzc2VkIGJ5IHZlbmRvciBzcGVjaWZpYyBhY3BpIGRyaXZlcnMgb3IgdmlkZW8ua28gZHJpdmVyLgogICovCiBzdGF0aWMgaW50IF9faW5pdCBhY3BpX2JhY2tsaWdodChjaGFyICpzdHIpCiB7CkBAIC0yNTUsMTkgKzIyMiwzIEBACiAJcmV0dXJuIDE7CiB9CiBfX3NldHVwKCJhY3BpX2JhY2tsaWdodD0iLCBhY3BpX2JhY2tsaWdodCk7Ci0KLXN0YXRpYyBpbnQgX19pbml0IGFjcGlfZGlzcGxheV9vdXRwdXQoY2hhciAqc3RyKQotewotCWlmIChzdHIgPT0gTlVMTCB8fCAqc3RyID09ICdcMCcpCi0JCXJldHVybiAxOwotCWVsc2UgewotCQlpZiAoIXN0cmNtcCgidmVuZG9yIiwgc3RyKSkKLQkJCWFjcGlfdmlkZW9fc3VwcG9ydCB8PQotCQkJCUFDUElfVklERU9fT1VUUFVUX1NXSVRDSElOR19GT1JDRV9WRU5ET1I7Ci0JCWlmICghc3RyY21wKCJ2aWRlbyIsIHN0cikpCi0JCQlhY3BpX3ZpZGVvX3N1cHBvcnQgfD0KLQkJCQlBQ1BJX1ZJREVPX09VVFBVVF9TV0lUQ0hJTkdfRk9SQ0VfVklERU87Ci0JfQotCXJldHVybiAxOwotfQotX19zZXR1cCgiYWNwaV9kaXNwbGF5X291dHB1dD0iLCBhY3BpX2Rpc3BsYXlfb3V0cHV0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS93YWtldXAuYyBiL2RyaXZlcnMvYWNwaS93YWtldXAuYwppbmRleCBmNjJhNTBjLi5lZDY1MDE0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvd2FrZXVwLmMKKysrIGIvZHJpdmVycy9hY3BpL3dha2V1cC5jCkBAIC0zNywxNSArMzcsMTYgQEAKIAkJCWNvbnRhaW5lcl9vZihub2RlLCBzdHJ1Y3QgYWNwaV9kZXZpY2UsIHdha2V1cF9saXN0KTsKIAogCQlpZiAoIWRldi0+d2FrZXVwLmZsYWdzLnZhbGlkCi0JCSAgICB8fCAhKGRldi0+d2FrZXVwLnN0YXRlLmVuYWJsZWQgfHwgZGV2LT53YWtldXAucHJlcGFyZV9jb3VudCkKLQkJICAgIHx8IHNsZWVwX3N0YXRlID4gKHUzMikgZGV2LT53YWtldXAuc2xlZXBfc3RhdGUpCisJCSAgICB8fCBzbGVlcF9zdGF0ZSA+ICh1MzIpIGRldi0+d2FrZXVwLnNsZWVwX3N0YXRlCisJCSAgICB8fCAhKGRldmljZV9tYXlfd2FrZXVwKCZkZXYtPmRldikKKwkJICAgICAgICB8fCBkZXYtPndha2V1cC5wcmVwYXJlX2NvdW50KSkKIAkJCWNvbnRpbnVlOwogCi0JCWlmIChkZXYtPndha2V1cC5zdGF0ZS5lbmFibGVkKQorCQlpZiAoZGV2aWNlX21heV93YWtldXAoJmRldi0+ZGV2KSkKIAkJCWFjcGlfZW5hYmxlX3dha2V1cF9kZXZpY2VfcG93ZXIoZGV2LCBzbGVlcF9zdGF0ZSk7CiAKIAkJLyogVGhlIHdha2UtdXAgcG93ZXIgc2hvdWxkIGhhdmUgYmVlbiBlbmFibGVkIGFscmVhZHkuICovCi0JCWFjcGlfZ3BlX3dha2V1cChkZXYtPndha2V1cC5ncGVfZGV2aWNlLCBkZXYtPndha2V1cC5ncGVfbnVtYmVyLAorCQlhY3BpX3NldF9ncGVfd2FrZV9tYXNrKGRldi0+d2FrZXVwLmdwZV9kZXZpY2UsIGRldi0+d2FrZXVwLmdwZV9udW1iZXIsCiAJCQkJQUNQSV9HUEVfRU5BQkxFKTsKIAl9CiB9CkBAIC02MywxNCArNjQsMTUgQEAKIAkJCWNvbnRhaW5lcl9vZihub2RlLCBzdHJ1Y3QgYWNwaV9kZXZpY2UsIHdha2V1cF9saXN0KTsKIAogCQlpZiAoIWRldi0+d2FrZXVwLmZsYWdzLnZhbGlkCi0JCSAgICB8fCAhKGRldi0+d2FrZXVwLnN0YXRlLmVuYWJsZWQgfHwgZGV2LT53YWtldXAucHJlcGFyZV9jb3VudCkKLQkJICAgIHx8IChzbGVlcF9zdGF0ZSA+ICh1MzIpIGRldi0+d2FrZXVwLnNsZWVwX3N0YXRlKSkKKwkJICAgIHx8IHNsZWVwX3N0YXRlID4gKHUzMikgZGV2LT53YWtldXAuc2xlZXBfc3RhdGUKKwkJICAgIHx8ICEoZGV2aWNlX21heV93YWtldXAoJmRldi0+ZGV2KQorCQkgICAgICAgIHx8IGRldi0+d2FrZXVwLnByZXBhcmVfY291bnQpKQogCQkJY29udGludWU7CiAKLQkJYWNwaV9ncGVfd2FrZXVwKGRldi0+d2FrZXVwLmdwZV9kZXZpY2UsIGRldi0+d2FrZXVwLmdwZV9udW1iZXIsCisJCWFjcGlfc2V0X2dwZV93YWtlX21hc2soZGV2LT53YWtldXAuZ3BlX2RldmljZSwgZGV2LT53YWtldXAuZ3BlX251bWJlciwKIAkJCQlBQ1BJX0dQRV9ESVNBQkxFKTsKIAotCQlpZiAoZGV2LT53YWtldXAuc3RhdGUuZW5hYmxlZCkKKwkJaWYgKGRldmljZV9tYXlfd2FrZXVwKCZkZXYtPmRldikpCiAJCQlhY3BpX2Rpc2FibGVfd2FrZXVwX2RldmljZV9wb3dlcihkZXYpOwogCX0KIH0KQEAgLTg0LDggKzg2LDggQEAKIAkJc3RydWN0IGFjcGlfZGV2aWNlICpkZXYgPSBjb250YWluZXJfb2Yobm9kZSwKIAkJCQkJCSAgICAgICBzdHJ1Y3QgYWNwaV9kZXZpY2UsCiAJCQkJCQkgICAgICAgd2FrZXVwX2xpc3QpOwotCQlpZiAoZGV2LT53YWtldXAuZmxhZ3MuYWx3YXlzX2VuYWJsZWQpCi0JCQlkZXYtPndha2V1cC5zdGF0ZS5lbmFibGVkID0gMTsKKwkJaWYgKGRldmljZV9jYW5fd2FrZXVwKCZkZXYtPmRldikpCisJCQlkZXZpY2Vfc2V0X3dha2V1cF9lbmFibGUoJmRldi0+ZGV2LCB0cnVlKTsKIAl9CiAJbXV0ZXhfdW5sb2NrKCZhY3BpX2RldmljZV9sb2NrKTsKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL0tjb25maWcgYi9kcml2ZXJzL2F0YS9LY29uZmlnCmluZGV4IGM2YjI5OGQuLmMyMzI4YWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL0tjb25maWcKKysrIGIvZHJpdmVycy9hdGEvS2NvbmZpZwpAQCAtNzgzLDcgKzc4Myw3IEBACiAKIGNvbmZpZyBQQVRBX1BMQVRGT1JNCiAJdHJpc3RhdGUgIkdlbmVyaWMgcGxhdGZvcm0gZGV2aWNlIFBBVEEgc3VwcG9ydCIKLQlkZXBlbmRzIG9uIEVNQkVEREVEIHx8IFBQQyB8fCBIQVZFX1BBVEFfUExBVEZPUk0KKwlkZXBlbmRzIG9uIEVYUEVSVCB8fCBQUEMgfHwgSEFWRV9QQVRBX1BMQVRGT1JNCiAJaGVscAogCSAgVGhpcyBvcHRpb24gZW5hYmxlcyBzdXBwb3J0IGZvciBnZW5lcmljIGRpcmVjdGx5IGNvbm5lY3RlZCBBVEEKIAkgIGRldmljZXMgY29tbW9ubHkgZm91bmQgb24gZW1iZWRkZWQgc3lzdGVtcy4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL2FoY2kuYyBiL2RyaXZlcnMvYXRhL2FoY2kuYwppbmRleCAzMjg4MjYzLi5iOGQ5NmNlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9haGNpLmMKKysrIGIvZHJpdmVycy9hdGEvYWhjaS5jCkBAIC0yNjAsNiArMjYwLDcgQEAKIAl7IFBDSV9WREVWSUNFKElOVEVMLCAweDFkMDIpLCBib2FyZF9haGNpIH0sIC8qIFBCRyBBSENJICovCiAJeyBQQ0lfVkRFVklDRShJTlRFTCwgMHgxZDA0KSwgYm9hcmRfYWhjaSB9LCAvKiBQQkcgUkFJRCAqLwogCXsgUENJX1ZERVZJQ0UoSU5URUwsIDB4MWQwNiksIGJvYXJkX2FoY2kgfSwgLyogUEJHIFJBSUQgKi8KKwl7IFBDSV9WREVWSUNFKElOVEVMLCAweDIzMjMpLCBib2FyZF9haGNpIH0sIC8qIERIODl4eENDIEFIQ0kgKi8KIAogCS8qIEpNaWNyb24gMzYwLzEvMy81LzYsIG1hdGNoIGNsYXNzIHRvIGF2b2lkIElERSBmdW5jdGlvbiAqLwogCXsgUENJX1ZFTkRPUl9JRF9KTUlDUk9OLCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELApAQCAtMzc5LDYgKzM4MCw4IEBACiAJeyBQQ0lfVkRFVklDRShNQVJWRUxMLCAweDYxNDUpLCBib2FyZF9haGNpX212IH0sCS8qIDYxNDUgKi8KIAl7IFBDSV9WREVWSUNFKE1BUlZFTEwsIDB4NjEyMSksIGJvYXJkX2FoY2lfbXYgfSwJLyogNjEyMSAqLwogCXsgUENJX0RFVklDRSgweDFiNGIsIDB4OTEyMyksCisJICAuY2xhc3MgPSBQQ0lfQ0xBU1NfU1RPUkFHRV9TQVRBX0FIQ0ksCisJICAuY2xhc3NfbWFzayA9IDB4ZmZmZmZmLAogCSAgLmRyaXZlcl9kYXRhID0gYm9hcmRfYWhjaV95ZXNfZmJzIH0sCQkJLyogODhzZTkxMjggKi8KIAogCS8qIFByb21pc2UgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL2xpYmF0YS1jb3JlLmMgYi9kcml2ZXJzL2F0YS9saWJhdGEtY29yZS5jCmluZGV4IGEzMWZlOTYuLmQ0ZTUyZTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL2xpYmF0YS1jb3JlLmMKKysrIGIvZHJpdmVycy9hdGEvbGliYXRhLWNvcmUuYwpAQCAtNDEzOCw2ICs0MTM4LDcgQEAKIAkgKiBkZXZpY2UgYW5kIGNvbnRyb2xsZXIgYXJlIFNBVEEuCiAJICovCiAJeyAiUElPTkVFUiBEVkQtUlcgIERWUlREMDgiLAkiMS4wMCIsCUFUQV9IT1JLQUdFX05PU0VUWEZFUiB9LAorCXsgIlBJT05FRVIgRFZELVJXICBEVlItMjEyRCIsCSIxLjI4IiwgQVRBX0hPUktBR0VfTk9TRVRYRkVSIH0sCiAKIAkvKiBFbmQgTWFya2VyICovCiAJeyB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9saWJhdGEtc2NzaS5jIGIvZHJpdmVycy9hdGEvbGliYXRhLXNjc2kuYwppbmRleCA1ZGVmYzc0Li42MDBmNjM1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9saWJhdGEtc2NzaS5jCisrKyBiL2RyaXZlcnMvYXRhL2xpYmF0YS1zY3NpLmMKQEAgLTEwOTksOSArMTA5OSw5IEBACiAJCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gc2Rldi0+cmVxdWVzdF9xdWV1ZTsKIAkJdm9pZCAqYnVmOwogCi0JCS8qIHNldCB0aGUgbWluIGFsaWdubWVudCBhbmQgcGFkZGluZyAqLwotCQlibGtfcXVldWVfdXBkYXRlX2RtYV9hbGlnbm1lbnQoc2Rldi0+cmVxdWVzdF9xdWV1ZSwKLQkJCQkJICAgICAgIEFUQV9ETUFfUEFEX1NaIC0gMSk7CisJCXNkZXYtPnNlY3Rvcl9zaXplID0gQVRBX1NFQ1RfU0laRTsKKworCQkvKiBzZXQgRE1BIHBhZGRpbmcgKi8KIAkJYmxrX3F1ZXVlX3VwZGF0ZV9kbWFfcGFkKHNkZXYtPnJlcXVlc3RfcXVldWUsCiAJCQkJCSBBVEFfRE1BX1BBRF9TWiAtIDEpOwogCkBAIC0xMTE1LDEzICsxMTE1LDI1IEBACiAKIAkJYmxrX3F1ZXVlX2RtYV9kcmFpbihxLCBhdGFwaV9kcmFpbl9uZWVkZWQsIGJ1ZiwgQVRBUElfTUFYX0RSQUlOKTsKIAl9IGVsc2UgewotCQkvKiBBVEEgZGV2aWNlcyBtdXN0IGJlIHNlY3RvciBhbGlnbmVkICovCiAJCXNkZXYtPnNlY3Rvcl9zaXplID0gYXRhX2lkX2xvZ2ljYWxfc2VjdG9yX3NpemUoZGV2LT5pZCk7Ci0JCWJsa19xdWV1ZV91cGRhdGVfZG1hX2FsaWdubWVudChzZGV2LT5yZXF1ZXN0X3F1ZXVlLAotCQkJCQkgICAgICAgc2Rldi0+c2VjdG9yX3NpemUgLSAxKTsKIAkJc2Rldi0+bWFuYWdlX3N0YXJ0X3N0b3AgPSAxOwogCX0KIAorCS8qCisJICogYXRhX3Bpb19zZWN0b3JzKCkgZXhwZWN0cyBidWZmZXIgZm9yIGVhY2ggc2VjdG9yIHRvIG5vdCBjcm9zcworCSAqIHBhZ2UgYm91bmRhcnkuICBFbmZvcmNlIGl0IGJ5IHJlcXVpcmluZyBidWZmZXJzIHRvIGJlIHNlY3RvcgorCSAqIGFsaWduZWQsIHdoaWNoIHdvcmtzIGlmZiBzZWN0b3Jfc2l6ZSBpcyBub3QgbGFyZ2VyIHRoYW4KKwkgKiBQQUdFX1NJWkUuICBBVEFQSSBkZXZpY2VzIGFsc28gbmVlZCB0aGUgYWxpZ25tZW50IGFzCisJICogSURFTlRJRllfUEFDS0VUIGlzIGV4ZWN1dGVkIGFzIEFUQV9QUk9UX1BJTy4KKwkgKi8KKwlpZiAoc2Rldi0+c2VjdG9yX3NpemUgPiBQQUdFX1NJWkUpCisJCWF0YV9kZXZfcHJpbnRrKGRldiwgS0VSTl9XQVJOSU5HLAorCQkJInNlY3Rvcl9zaXplPSV1ID4gUEFHRV9TSVpFLCBQSU8gbWF5IG1hbGZ1bmN0aW9uXG4iLAorCQkJc2Rldi0+c2VjdG9yX3NpemUpOworCisJYmxrX3F1ZXVlX3VwZGF0ZV9kbWFfYWxpZ25tZW50KHNkZXYtPnJlcXVlc3RfcXVldWUsCisJCQkJICAgICAgIHNkZXYtPnNlY3Rvcl9zaXplIC0gMSk7CisKIAlpZiAoZGV2LT5mbGFncyAmIEFUQV9ERkxBR19BTikKIAkJc2V0X2JpdChTREVWX0VWVF9NRURJQV9DSEFOR0UsIHNkZXYtPnN1cHBvcnRlZF9ldmVudHMpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9wYXRhX2hwdDM2Ni5jIGIvZHJpdmVycy9hdGEvcGF0YV9ocHQzNjYuYwppbmRleCBkN2U1N2RiLi41MzhlYzM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9wYXRhX2hwdDM2Ni5jCisrKyBiL2RyaXZlcnMvYXRhL3BhdGFfaHB0MzY2LmMKQEAgLTI1LDcgKzI1LDcgQEAKICNpbmNsdWRlIDxsaW51eC9saWJhdGEuaD4KIAogI2RlZmluZSBEUlZfTkFNRQkicGF0YV9ocHQzNjYiCi0jZGVmaW5lIERSVl9WRVJTSU9OCSIwLjYuOSIKKyNkZWZpbmUgRFJWX1ZFUlNJT04JIjAuNi4xMCIKIAogc3RydWN0IGhwdF9jbG9jayB7CiAJdTgJeGZlcl9tb2RlOwpAQCAtMTYwLDggKzE2MCw4IEBACiAKIAl3aGlsZSAobGlzdFtpXSAhPSBOVUxMKSB7CiAJCWlmICghc3RyY21wKGxpc3RbaV0sIG1vZGVsX251bSkpIHsKLQkJCXByaW50ayhLRVJOX1dBUk5JTkcgRFJWX05BTUUgIjogJXMgaXMgbm90IHN1cHBvcnRlZCBmb3IgJXMuXG4iLAotCQkJCW1vZGVzdHIsIGxpc3RbaV0pOworCQkJcHJfd2FybmluZyhEUlZfTkFNRSAiOiAlcyBpcyBub3Qgc3VwcG9ydGVkIGZvciAlcy5cbiIsCisJCQkJICAgbW9kZXN0ciwgbGlzdFtpXSk7CiAJCQlyZXR1cm4gMTsKIAkJfQogCQlpKys7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9wYXRhX2hwdDM3eC5jIGIvZHJpdmVycy9hdGEvcGF0YV9ocHQzN3guYwppbmRleCBlZmRkMThiLi40YzViNTE4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9wYXRhX2hwdDM3eC5jCisrKyBiL2RyaXZlcnMvYXRhL3BhdGFfaHB0Mzd4LmMKQEAgLTI0LDcgKzI0LDcgQEAKICNpbmNsdWRlIDxsaW51eC9saWJhdGEuaD4KIAogI2RlZmluZSBEUlZfTkFNRQkicGF0YV9ocHQzN3giCi0jZGVmaW5lIERSVl9WRVJTSU9OCSIwLjYuMTgiCisjZGVmaW5lIERSVl9WRVJTSU9OCSIwLjYuMjIiCiAKIHN0cnVjdCBocHRfY2xvY2sgewogCXU4CXhmZXJfc3BlZWQ7CkBAIC0yMjksOCArMjI5LDggQEAKIAogCXdoaWxlIChsaXN0W2ldICE9IE5VTEwpIHsKIAkJaWYgKCFzdHJjbXAobGlzdFtpXSwgbW9kZWxfbnVtKSkgewotCQkJcHJpbnRrKEtFUk5fV0FSTklORyBEUlZfTkFNRSAiOiAlcyBpcyBub3Qgc3VwcG9ydGVkIGZvciAlcy5cbiIsCi0JCQkJbW9kZXN0ciwgbGlzdFtpXSk7CisJCQlwcl93YXJuaW5nKERSVl9OQU1FICI6ICVzIGlzIG5vdCBzdXBwb3J0ZWQgZm9yICVzLlxuIiwKKwkJCQkgICBtb2Rlc3RyLCBsaXN0W2ldKTsKIAkJCXJldHVybiAxOwogCQl9CiAJCWkrKzsKQEAgLTY0Miw3ICs2NDIsNiBAQAogc3RhdGljIHN0cnVjdCBhdGFfcG9ydF9vcGVyYXRpb25zIGhwdDM3NF9mbjFfcG9ydF9vcHMgPSB7CiAJLmluaGVyaXRzCT0gJmhwdDM3Ml9wb3J0X29wcywKIAkuY2FibGVfZGV0ZWN0CT0gaHB0Mzc0X2ZuMV9jYWJsZV9kZXRlY3QsCi0JLnByZXJlc2V0CT0gaHB0Mzd4X3ByZV9yZXNldCwKIH07CiAKIC8qKgpAQCAtODAzLDcgKzgwMiw3IEBACiAJCS51ZG1hX21hc2sgPSBBVEFfVURNQTYsCiAJCS5wb3J0X29wcyA9ICZocHQzMDJfcG9ydF9vcHMKIAl9OwotCS8qIEhQVDM3NCAtIFVETUExMDAsIGZ1bmN0aW9uIDEgdXNlcyBkaWZmZXJlbnQgcHJlcmVzZXQgbWV0aG9kICovCisJLyogSFBUMzc0IC0gVURNQTEwMCwgZnVuY3Rpb24gMSB1c2VzIGRpZmZlcmVudCBjYWJsZV9kZXRlY3QgbWV0aG9kICovCiAJc3RhdGljIGNvbnN0IHN0cnVjdCBhdGFfcG9ydF9pbmZvIGluZm9faHB0Mzc0X2ZuMCA9IHsKIAkJLmZsYWdzID0gQVRBX0ZMQUdfU0xBVkVfUE9TUywKIAkJLnBpb19tYXNrID0gQVRBX1BJTzQsCkBAIC04MzgsNyArODM3LDggQEAKIAlpZiAocmMpCiAJCXJldHVybiByYzsKIAotCWlmIChkZXYtPmRldmljZSA9PSBQQ0lfREVWSUNFX0lEX1RUSV9IUFQzNjYpIHsKKwlzd2l0Y2ggKGRldi0+ZGV2aWNlKSB7CisJY2FzZSBQQ0lfREVWSUNFX0lEX1RUSV9IUFQzNjY6CiAJCS8qIE1heSBiZSBhIGxhdGVyIGNoaXAgaW4gZGlzZ3Vpc2UuIENoZWNrICovCiAJCS8qIE9sZGVyIGNoaXBzIGFyZSBpbiB0aGUgSFBUMzY2IGRyaXZlci4gSWdub3JlIHRoZW0gKi8KIAkJaWYgKHJldiA8IDMpCkBAIC04NjMsNTQgKzg2Myw1MCBAQAogCQkJY2hpcF90YWJsZSA9ICZocHQzNzI7CiAJCQlicmVhazsKIAkJZGVmYXVsdDoKLQkJCXByaW50ayhLRVJOX0VSUiAicGF0YV9ocHQzN3g6IFVua25vd24gSFBUMzY2IHN1YnR5cGUsICIKKwkJCXByX2VycihEUlZfTkFNRSAiOiBVbmtub3duIEhQVDM2NiBzdWJ0eXBlLCAiCiAJCQkgICAgICAgInBsZWFzZSByZXBvcnQgKCVkKS5cbiIsIHJldik7CiAJCQlyZXR1cm4gLUVOT0RFVjsKIAkJfQotCX0gZWxzZSB7Ci0JCXN3aXRjaCAoZGV2LT5kZXZpY2UpIHsKLQkJY2FzZSBQQ0lfREVWSUNFX0lEX1RUSV9IUFQzNzI6Ci0JCQkvKiAzNzJOIGlmIHJldiA+PSAyICovCi0JCQlpZiAocmV2ID49IDIpCi0JCQkJcmV0dXJuIC1FTk9ERVY7Ci0JCQlwcGlbMF0gPSAmaW5mb19ocHQzNzI7Ci0JCQljaGlwX3RhYmxlID0gJmhwdDM3MmE7Ci0JCQlicmVhazsKLQkJY2FzZSBQQ0lfREVWSUNFX0lEX1RUSV9IUFQzMDI6Ci0JCQkvKiAzMDJOIGlmIHJldiA+IDEgKi8KLQkJCWlmIChyZXYgPiAxKQotCQkJCXJldHVybiAtRU5PREVWOwotCQkJcHBpWzBdID0gJmluZm9faHB0MzAyOwotCQkJLyogQ2hlY2sgdGhpcyAqLwotCQkJY2hpcF90YWJsZSA9ICZocHQzMDI7Ci0JCQlicmVhazsKLQkJY2FzZSBQQ0lfREVWSUNFX0lEX1RUSV9IUFQzNzE6Ci0JCQlpZiAocmV2ID4gMSkKLQkJCQlyZXR1cm4gLUVOT0RFVjsKLQkJCXBwaVswXSA9ICZpbmZvX2hwdDMwMjsKLQkJCWNoaXBfdGFibGUgPSAmaHB0MzcxOwotCQkJLyoKLQkJCSAqIFNpbmdsZSBjaGFubmVsIGRldmljZSwgbWFzdGVyIGlzIG5vdCBwcmVzZW50Ci0JCQkgKiBidXQgdGhlIEJJT1MgKG9yIHVzIGZvciBub24geDg2KSBtdXN0IG1hcmsgaXQKLQkJCSAqIGFic2VudAotCQkJICovCi0JCQlwY2lfcmVhZF9jb25maWdfYnl0ZShkZXYsIDB4NTAsICZtY3IxKTsKLQkJCW1jcjEgJj0gfjB4MDQ7Ci0JCQlwY2lfd3JpdGVfY29uZmlnX2J5dGUoZGV2LCAweDUwLCBtY3IxKTsKLQkJCWJyZWFrOwotCQljYXNlIFBDSV9ERVZJQ0VfSURfVFRJX0hQVDM3NDoKLQkJCWNoaXBfdGFibGUgPSAmaHB0Mzc0OwotCQkJaWYgKCEoUENJX0ZVTkMoZGV2LT5kZXZmbikgJiAxKSkKLQkJCQkqcHBpID0gJmluZm9faHB0Mzc0X2ZuMDsKLQkJCWVsc2UKLQkJCQkqcHBpID0gJmluZm9faHB0Mzc0X2ZuMTsKLQkJCWJyZWFrOwotCQlkZWZhdWx0OgotCQkJcHJpbnRrKEtFUk5fRVJSCi0JCQkgICAgICAgInBhdGFfaHB0Mzd4OiBQQ0kgdGFibGUgaXMgYm9ndXMsIHBsZWFzZSByZXBvcnQgKCVkKS5cbiIsCi0JCQkgICAgICAgZGV2LT5kZXZpY2UpOwotCQkJCXJldHVybiAtRU5PREVWOwotCQl9CisJCWJyZWFrOworCWNhc2UgUENJX0RFVklDRV9JRF9UVElfSFBUMzcyOgorCQkvKiAzNzJOIGlmIHJldiA+PSAyICovCisJCWlmIChyZXYgPj0gMikKKwkJCXJldHVybiAtRU5PREVWOworCQlwcGlbMF0gPSAmaW5mb19ocHQzNzI7CisJCWNoaXBfdGFibGUgPSAmaHB0MzcyYTsKKwkJYnJlYWs7CisJY2FzZSBQQ0lfREVWSUNFX0lEX1RUSV9IUFQzMDI6CisJCS8qIDMwMk4gaWYgcmV2ID4gMSAqLworCQlpZiAocmV2ID4gMSkKKwkJCXJldHVybiAtRU5PREVWOworCQlwcGlbMF0gPSAmaW5mb19ocHQzMDI7CisJCS8qIENoZWNrIHRoaXMgKi8KKwkJY2hpcF90YWJsZSA9ICZocHQzMDI7CisJCWJyZWFrOworCWNhc2UgUENJX0RFVklDRV9JRF9UVElfSFBUMzcxOgorCQlpZiAocmV2ID4gMSkKKwkJCXJldHVybiAtRU5PREVWOworCQlwcGlbMF0gPSAmaW5mb19ocHQzMDI7CisJCWNoaXBfdGFibGUgPSAmaHB0MzcxOworCQkvKgorCQkgKiBTaW5nbGUgY2hhbm5lbCBkZXZpY2UsIG1hc3RlciBpcyBub3QgcHJlc2VudCBidXQgdGhlIEJJT1MKKwkJICogKG9yIHVzIGZvciBub24geDg2KSBtdXN0IG1hcmsgaXQgYWJzZW50CisJCSAqLworCQlwY2lfcmVhZF9jb25maWdfYnl0ZShkZXYsIDB4NTAsICZtY3IxKTsKKwkJbWNyMSAmPSB+MHgwNDsKKwkJcGNpX3dyaXRlX2NvbmZpZ19ieXRlKGRldiwgMHg1MCwgbWNyMSk7CisJCWJyZWFrOworCWNhc2UgUENJX0RFVklDRV9JRF9UVElfSFBUMzc0OgorCQljaGlwX3RhYmxlID0gJmhwdDM3NDsKKwkJaWYgKCEoUENJX0ZVTkMoZGV2LT5kZXZmbikgJiAxKSkKKwkJCSpwcGkgPSAmaW5mb19ocHQzNzRfZm4wOworCQllbHNlCisJCQkqcHBpID0gJmluZm9faHB0Mzc0X2ZuMTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcHJfZXJyKERSVl9OQU1FICI6IFBDSSB0YWJsZSBpcyBib2d1cywgcGxlYXNlIHJlcG9ydCAoJWQpLlxuIiwKKwkJICAgICAgIGRldi0+ZGV2aWNlKTsKKwkJcmV0dXJuIC1FTk9ERVY7CiAJfQogCS8qIE9rIHNvIHRoaXMgaXMgYSBjaGlwIHdlIHN1cHBvcnQgKi8KIApAQCAtOTU3LDggKzk1Myw3IEBACiAJCXU4IHNyOwogCQl1MzIgdG90YWwgPSAwOwogCi0JCXByaW50ayhLRVJOX1dBUk5JTkcKLQkJICAgICAgICJwYXRhX2hwdDM3eDogQklPUyBoYXMgbm90IHNldCB0aW1pbmcgY2xvY2tzLlxuIik7CisJCXByX3dhcm5pbmcoRFJWX05BTUUgIjogQklPUyBoYXMgbm90IHNldCB0aW1pbmcgY2xvY2tzLlxuIik7CiAKIAkJLyogVGhpcyBpcyB0aGUgcHJvY2VzcyB0aGUgSFBUMzcxIEJJT1MgaXMgcmVwb3J0ZWQgdG8gdXNlICovCiAJCWZvciAoaSA9IDA7IGkgPCAxMjg7IGkrKykgewpAQCAtMTAxNCw3ICsxMDA5LDcgQEAKIAkJCQkJICAgICAgIChmX2hpZ2ggPDwgMTYpIHwgZl9sb3cgfCAweDEwMCk7CiAJCX0KIAkJaWYgKGFkanVzdCA9PSA4KSB7Ci0JCQlwcmludGsoS0VSTl9FUlIgInBhdGFfaHB0Mzd4OiBEUExMIGRpZCBub3Qgc3RhYmlsaXplIVxuIik7CisJCQlwcl9lcnIoRFJWX05BTUUgIjogRFBMTCBkaWQgbm90IHN0YWJpbGl6ZSFcbiIpOwogCQkJcmV0dXJuIC1FTk9ERVY7CiAJCX0KIAkJaWYgKGRwbGwgPT0gMykKQEAgLTEwMjIsOCArMTAxNyw4IEBACiAJCWVsc2UKIAkJCXByaXZhdGVfZGF0YSA9ICh2b2lkICopaHB0Mzd4X3RpbWluZ3NfNTA7CiAKLQkJcHJpbnRrKEtFUk5fSU5GTyAicGF0YV9ocHQzN3g6IGJ1cyBjbG9jayAlZE1IeiwgdXNpbmcgJWRNSHogRFBMTC5cbiIsCi0JCSAgICAgICBNSHpbY2xvY2tfc2xvdF0sIE1IeltkcGxsXSk7CisJCXByX2luZm8oRFJWX05BTUUgIjogYnVzIGNsb2NrICVkTUh6LCB1c2luZyAlZE1IeiBEUExMLlxuIiwKKwkJCU1IeltjbG9ja19zbG90XSwgTUh6W2RwbGxdKTsKIAl9IGVsc2UgewogCQlwcml2YXRlX2RhdGEgPSAodm9pZCAqKWNoaXBfdGFibGUtPmNsb2Nrc1tjbG9ja19zbG90XTsKIAkJLyoKQEAgLTEwMzYsOCArMTAzMSw5IEBACiAJCQlwcGlbMF0gPSAmaW5mb19ocHQzNzBfMzM7CiAJCWlmIChjbG9ja19zbG90IDwgMiAmJiBwcGlbMF0gPT0gJmluZm9faHB0MzcwYSkKIAkJCXBwaVswXSA9ICZpbmZvX2hwdDM3MGFfMzM7Ci0JCXByaW50ayhLRVJOX0lORk8gInBhdGFfaHB0Mzd4OiAlcyB1c2luZyAlZE1IeiBidXMgY2xvY2suXG4iLAotCQkgICAgICAgY2hpcF90YWJsZS0+bmFtZSwgTUh6W2Nsb2NrX3Nsb3RdKTsKKworCQlwcl9pbmZvKERSVl9OQU1FICI6ICVzIHVzaW5nICVkTUh6IGJ1cyBjbG9jay5cbiIsCisJCQljaGlwX3RhYmxlLT5uYW1lLCBNSHpbY2xvY2tfc2xvdF0pOwogCX0KIAogCS8qIE5vdyBraWNrIG9mZiBBVEEgc2V0IHVwICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9wYXRhX2hwdDN4Mm4uYyBiL2RyaXZlcnMvYXRhL3BhdGFfaHB0M3gybi5jCmluZGV4IGQyMjM5YmIuLmVjYTY4Y2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL3BhdGFfaHB0M3gybi5jCisrKyBiL2RyaXZlcnMvYXRhL3BhdGFfaHB0M3gybi5jCkBAIC0yNSw3ICsyNSw3IEBACiAjaW5jbHVkZSA8bGludXgvbGliYXRhLmg+CiAKICNkZWZpbmUgRFJWX05BTUUJInBhdGFfaHB0M3gybiIKLSNkZWZpbmUgRFJWX1ZFUlNJT04JIjAuMy4xMyIKKyNkZWZpbmUgRFJWX1ZFUlNJT04JIjAuMy4xNCIKIAogZW51bSB7CiAJSFBUX1BDSV9GQVNUCT0JKDEgPDwgMzEpLApAQCAtNDE4LDcgKzQxOCw3IEBACiAJCXUxNiBzcjsKIAkJdTMyIHRvdGFsID0gMDsKIAotCQlwcmludGsoS0VSTl9XQVJOSU5HICJwYXRhX2hwdDN4Mm46IEJJT1MgY2xvY2sgZGF0YSBub3Qgc2V0LlxuIik7CisJCXByX3dhcm5pbmcoRFJWX05BTUUgIjogQklPUyBjbG9jayBkYXRhIG5vdCBzZXQuXG4iKTsKIAogCQkvKiBUaGlzIGlzIHRoZSBwcm9jZXNzIHRoZSBIUFQzNzEgQklPUyBpcyByZXBvcnRlZCB0byB1c2UgKi8KIAkJZm9yIChpID0gMDsgaSA8IDEyODsgaSsrKSB7CkBAIC01MjgsOCArNTI4LDcgQEAKIAkJcHBpWzBdID0gJmluZm9faHB0MzcybjsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKLQkJcHJpbnRrKEtFUk5fRVJSCi0JCSAgICAgICAicGF0YV9ocHQzeDJuOiBQQ0kgdGFibGUgaXMgYm9ndXMgcGxlYXNlIHJlcG9ydCAoJWQpLlxuIiwKKwkJcHJfZXJyKERSVl9OQU1FICI6IFBDSSB0YWJsZSBpcyBib2d1cywgcGxlYXNlIHJlcG9ydCAoJWQpLlxuIiwKIAkJICAgICAgIGRldi0+ZGV2aWNlKTsKIAkJcmV0dXJuIC1FTk9ERVY7CiAJfQpAQCAtNTc5LDEyICs1NzgsMTEgQEAKIAkJcGNpX3dyaXRlX2NvbmZpZ19kd29yZChkZXYsIDB4NUMsIChmX2hpZ2ggPDwgMTYpIHwgZl9sb3cpOwogCX0KIAlpZiAoYWRqdXN0ID09IDgpIHsKLQkJcHJpbnRrKEtFUk5fRVJSICJwYXRhX2hwdDN4Mm46IERQTEwgZGlkIG5vdCBzdGFiaWxpemUhXG4iKTsKKwkJcHJfZXJyKERSVl9OQU1FICI6IERQTEwgZGlkIG5vdCBzdGFiaWxpemUhXG4iKTsKIAkJcmV0dXJuIC1FTk9ERVY7CiAJfQogCi0JcHJpbnRrKEtFUk5fSU5GTyAicGF0YV9ocHQzN3g6IGJ1cyBjbG9jayAlZE1IeiwgdXNpbmcgNjZNSHogRFBMTC5cbiIsCi0JICAgICAgIHBjaV9taHopOworCXByX2luZm8oRFJWX05BTUUgIjogYnVzIGNsb2NrICVkTUh6LCB1c2luZyA2Nk1IeiBEUExMLlxuIiwgcGNpX21oeik7CiAKIAkvKgogCSAqIFNldCBvdXIgcHJpdmF0ZSBkYXRhIHVwLiBXZSBvbmx5IG5lZWQgYSBmZXcgZmxhZ3MKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL3BhdGFfbXBjNTJ4eC5jIGIvZHJpdmVycy9hdGEvcGF0YV9tcGM1Mnh4LmMKaW5kZXggOGNjNTM2ZS4uZDdkODAyNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdGEvcGF0YV9tcGM1Mnh4LmMKKysrIGIvZHJpdmVycy9hdGEvcGF0YV9tcGM1Mnh4LmMKQEAgLTYxMCw3ICs2MTAsNyBAQAogfTsKIAogc3RhdGljIHN0cnVjdCBhdGFfcG9ydF9vcGVyYXRpb25zIG1wYzUyeHhfYXRhX3BvcnRfb3BzID0gewotCS5pbmhlcml0cwkJPSAmYXRhX3NmZl9wb3J0X29wcywKKwkuaW5oZXJpdHMJCT0gJmF0YV9ibWRtYV9wb3J0X29wcywKIAkuc2ZmX2Rldl9zZWxlY3QJCT0gbXBjNTJ4eF9hdGFfZGV2X3NlbGVjdCwKIAkuc2V0X3Bpb21vZGUJCT0gbXBjNTJ4eF9hdGFfc2V0X3Bpb21vZGUsCiAJLnNldF9kbWFtb2RlCQk9IG1wYzUyeHhfYXRhX3NldF9kbWFtb2RlLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdG0vaWR0NzcxMDUuYyBiL2RyaXZlcnMvYXRtL2lkdDc3MTA1LmMKaW5kZXggYmNhOWNiOC4uNDg3YTU0NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdG0vaWR0NzcxMDUuYworKysgYi9kcml2ZXJzL2F0bS9pZHQ3NzEwNS5jCkBAIC0xNTEsNyArMTUxLDcgQEAKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpZHQ3NzEwNV9wcml2X2xvY2ssIGZsYWdzKTsKIAlpZiAoYXJnID09IE5VTEwpCiAJCXJldHVybiAwOwotCXJldHVybiBjb3B5X3RvX3VzZXIoYXJnLCAmUFJJVihkZXYpLT5zdGF0cywKKwlyZXR1cm4gY29weV90b191c2VyKGFyZywgJnN0YXRzLAogCQkgICAgc2l6ZW9mKHN0cnVjdCBpZHQ3NzEwNV9zdGF0cykpID8gLUVGQVVMVCA6IDA7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmFzZS9LY29uZmlnIGIvZHJpdmVycy9iYXNlL0tjb25maWcKaW5kZXggZmQ5NjM0NS4uZDU3ZThkMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9iYXNlL0tjb25maWcKKysrIGIvZHJpdmVycy9iYXNlL0tjb25maWcKQEAgLTcwLDcgKzcwLDcgQEAKIAkgIElmIHVuc3VyZSBzYXkgWSBoZXJlLgogCiBjb25maWcgRldfTE9BREVSCi0JdHJpc3RhdGUgIlVzZXJzcGFjZSBmaXJtd2FyZSBsb2FkaW5nIHN1cHBvcnQiIGlmIEVNQkVEREVECisJdHJpc3RhdGUgIlVzZXJzcGFjZSBmaXJtd2FyZSBsb2FkaW5nIHN1cHBvcnQiIGlmIEVYUEVSVAogCWRlZmF1bHQgeQogCS0tLWhlbHAtLS0KIAkgIFRoaXMgb3B0aW9uIGlzIHByb3ZpZGVkIGZvciB0aGUgY2FzZSB3aGVyZSBubyBpbi1rZXJuZWwtdHJlZSBtb2R1bGVzCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jhc2Uvbm9kZS5jIGIvZHJpdmVycy9iYXNlL25vZGUuYwppbmRleCBjZTAxMmE5Li4zNmI0MzA1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jhc2Uvbm9kZS5jCisrKyBiL2RyaXZlcnMvYmFzZS9ub2RlLmMKQEAgLTExNywxMiArMTE3LDIxIEBACiAJCSAgICAgICAiTm9kZSAlZCBXcml0ZWJhY2tUbXA6ICAgJThsdSBrQlxuIgogCQkgICAgICAgIk5vZGUgJWQgU2xhYjogICAgICAgICAgICU4bHUga0JcbiIKIAkJICAgICAgICJOb2RlICVkIFNSZWNsYWltYWJsZTogICAlOGx1IGtCXG4iCi0JCSAgICAgICAiTm9kZSAlZCBTVW5yZWNsYWltOiAgICAgJThsdSBrQlxuIiwKKwkJICAgICAgICJOb2RlICVkIFNVbnJlY2xhaW06ICAgICAlOGx1IGtCXG4iCisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCisJCSAgICAgICAiTm9kZSAlZCBBbm9uSHVnZVBhZ2VzOiAgJThsdSBrQlxuIgorI2VuZGlmCisJCQksCiAJCSAgICAgICBuaWQsIEsobm9kZV9wYWdlX3N0YXRlKG5pZCwgTlJfRklMRV9ESVJUWSkpLAogCQkgICAgICAgbmlkLCBLKG5vZGVfcGFnZV9zdGF0ZShuaWQsIE5SX1dSSVRFQkFDSykpLAogCQkgICAgICAgbmlkLCBLKG5vZGVfcGFnZV9zdGF0ZShuaWQsIE5SX0ZJTEVfUEFHRVMpKSwKIAkJICAgICAgIG5pZCwgSyhub2RlX3BhZ2Vfc3RhdGUobmlkLCBOUl9GSUxFX01BUFBFRCkpLAotCQkgICAgICAgbmlkLCBLKG5vZGVfcGFnZV9zdGF0ZShuaWQsIE5SX0FOT05fUEFHRVMpKSwKKwkJICAgICAgIG5pZCwgSyhub2RlX3BhZ2Vfc3RhdGUobmlkLCBOUl9BTk9OX1BBR0VTKQorI2lmZGVmIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRQorCQkJKyBub2RlX3BhZ2Vfc3RhdGUobmlkLCBOUl9BTk9OX1RSQU5TUEFSRU5UX0hVR0VQQUdFUykgKgorCQkJSFBBR0VfUE1EX05SCisjZW5kaWYKKwkJICAgICAgICksCiAJCSAgICAgICBuaWQsIEsobm9kZV9wYWdlX3N0YXRlKG5pZCwgTlJfU0hNRU0pKSwKIAkJICAgICAgIG5pZCwgbm9kZV9wYWdlX3N0YXRlKG5pZCwgTlJfS0VSTkVMX1NUQUNLKSAqCiAJCQkJVEhSRUFEX1NJWkUgLyAxMDI0LApAQCAtMTMzLDcgKzE0MiwxMyBAQAogCQkgICAgICAgbmlkLCBLKG5vZGVfcGFnZV9zdGF0ZShuaWQsIE5SX1NMQUJfUkVDTEFJTUFCTEUpICsKIAkJCQlub2RlX3BhZ2Vfc3RhdGUobmlkLCBOUl9TTEFCX1VOUkVDTEFJTUFCTEUpKSwKIAkJICAgICAgIG5pZCwgSyhub2RlX3BhZ2Vfc3RhdGUobmlkLCBOUl9TTEFCX1JFQ0xBSU1BQkxFKSksCi0JCSAgICAgICBuaWQsIEsobm9kZV9wYWdlX3N0YXRlKG5pZCwgTlJfU0xBQl9VTlJFQ0xBSU1BQkxFKSkpOworCQkgICAgICAgbmlkLCBLKG5vZGVfcGFnZV9zdGF0ZShuaWQsIE5SX1NMQUJfVU5SRUNMQUlNQUJMRSkpCisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCisJCQksIG5pZCwKKwkJCUsobm9kZV9wYWdlX3N0YXRlKG5pZCwgTlJfQU5PTl9UUkFOU1BBUkVOVF9IVUdFUEFHRVMpICoKKwkJCUhQQUdFX1BNRF9OUikKKyNlbmRpZgorCQkgICAgICAgKTsKIAluICs9IGh1Z2V0bGJfcmVwb3J0X25vZGVfbWVtaW5mbyhuaWQsIGJ1ZiArIG4pOwogCXJldHVybiBuOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9iYXNlL3Bvd2VyL3J1bnRpbWUuYyBiL2RyaXZlcnMvYmFzZS9wb3dlci9ydW50aW1lLmMKaW5kZXggNjU2NDkzYS4uNDI2MTViNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9iYXNlL3Bvd2VyL3J1bnRpbWUuYworKysgYi9kcml2ZXJzL2Jhc2UvcG93ZXIvcnVudGltZS5jCkBAIC00MDcsMTIgKzQwNywxNSBAQAogCQlnb3RvIG91dDsKIAl9CiAKKwkvKiBNYXliZSB0aGUgcGFyZW50IGlzIG5vdyBhYmxlIHRvIHN1c3BlbmQuICovCiAJaWYgKHBhcmVudCAmJiAhcGFyZW50LT5wb3dlci5pZ25vcmVfY2hpbGRyZW4gJiYgIWRldi0+cG93ZXIuaXJxX3NhZmUpIHsKLQkJc3Bpbl91bmxvY2tfaXJxKCZkZXYtPnBvd2VyLmxvY2spOworCQlzcGluX3VubG9jaygmZGV2LT5wb3dlci5sb2NrKTsKIAotCQlwbV9yZXF1ZXN0X2lkbGUocGFyZW50KTsKKwkJc3Bpbl9sb2NrKCZwYXJlbnQtPnBvd2VyLmxvY2spOworCQlycG1faWRsZShwYXJlbnQsIFJQTV9BU1lOQyk7CisJCXNwaW5fdW5sb2NrKCZwYXJlbnQtPnBvd2VyLmxvY2spOwogCi0JCXNwaW5fbG9ja19pcnEoJmRldi0+cG93ZXIubG9jayk7CisJCXNwaW5fbG9jaygmZGV2LT5wb3dlci5sb2NrKTsKIAl9CiAKICBvdXQ6CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL01ha2VmaWxlIGIvZHJpdmVycy9ibG9jay9NYWtlZmlsZQppbmRleCBkN2Y0NjNkLi40MDUyOGJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvYmxvY2svTWFrZWZpbGUKQEAgLTM5LDQgKzM5LDQgQEAKIG9iai0kKENPTkZJR19CTEtfREVWX0RSQkQpICAgICArPSBkcmJkLwogb2JqLSQoQ09ORklHX0JMS19ERVZfUkJEKSAgICAgKz0gcmJkLm8KIAotc3dpbV9tb2Qtb2Jqcwk6PSBzd2ltLm8gc3dpbV9hc20ubworc3dpbV9tb2QteQk6PSBzd2ltLm8gc3dpbV9hc20ubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay9hb2UvTWFrZWZpbGUgYi9kcml2ZXJzL2Jsb2NrL2FvZS9NYWtlZmlsZQppbmRleCBlNzZkOTk3Li4wNmVhODJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL2FvZS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2Jsb2NrL2FvZS9NYWtlZmlsZQpAQCAtMyw0ICszLDQgQEAKICMKIAogb2JqLSQoQ09ORklHX0FUQV9PVkVSX0VUSCkJKz0gYW9lLm8KLWFvZS1vYmpzIDo9IGFvZWJsay5vIGFvZWNoci5vIGFvZWNtZC5vIGFvZWRldi5vIGFvZW1haW4ubyBhb2VuZXQubworYW9lLXkgOj0gYW9lYmxrLm8gYW9lY2hyLm8gYW9lY21kLm8gYW9lZGV2Lm8gYW9lbWFpbi5vIGFvZW5ldC5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2NjaXNzLmMgYi9kcml2ZXJzL2Jsb2NrL2NjaXNzLmMKaW5kZXggNTE2ZDViYi4uOTI3OTI3MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9jY2lzcy5jCisrKyBiL2RyaXZlcnMvYmxvY2svY2Npc3MuYwpAQCAtMjgzMyw3ICsyODMzLDcgQEAKIAlzZWN0b3JfdCB0b3RhbF9zaXplOwogCUlucXVpcnlEYXRhX3N0cnVjdCAqaW5xX2J1ZmYgPSBOVUxMOwogCi0JZm9yIChsb2d2b2wgPSAwOyBsb2d2b2wgPCBDSVNTX01BWF9MVU47IGxvZ3ZvbCsrKSB7CisJZm9yIChsb2d2b2wgPSAwOyBsb2d2b2wgPD0gaC0+aGlnaGVzdF9sdW47IGxvZ3ZvbCsrKSB7CiAJCWlmICghaC0+ZHJ2W2xvZ3ZvbF0pCiAJCQljb250aW51ZTsKIAkJaWYgKG1lbWNtcChoLT5kcnZbbG9ndm9sXS0+THVuSUQsIGRydi0+THVuSUQsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2xvb3AuYyBiL2RyaXZlcnMvYmxvY2svbG9vcC5jCmluZGV4IDQ0ZTE4YzAuLjQ5ZTZhNTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2svbG9vcC5jCisrKyBiL2RyaXZlcnMvYmxvY2svbG9vcC5jCkBAIC0xNjQxLDYgKzE2NDEsOSBAQAogCiBzdGF0aWMgdm9pZCBsb29wX2ZyZWUoc3RydWN0IGxvb3BfZGV2aWNlICpsbykKIHsKKwlpZiAoIWxvLT5sb19xdWV1ZS0+cXVldWVfbG9jaykKKwkJbG8tPmxvX3F1ZXVlLT5xdWV1ZV9sb2NrID0gJmxvLT5sb19xdWV1ZS0+X19xdWV1ZV9sb2NrOworCiAJYmxrX2NsZWFudXBfcXVldWUobG8tPmxvX3F1ZXVlKTsKIAlwdXRfZGlzayhsby0+bG9fZGlzayk7CiAJbGlzdF9kZWwoJmxvLT5sb19saXN0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svbmJkLmMgYi9kcml2ZXJzL2Jsb2NrL25iZC5jCmluZGV4IGEzMmZiNDEuLmU2ZmM3MTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2svbmJkLmMKKysrIGIvZHJpdmVycy9ibG9jay9uYmQuYwpAQCAtNTMsNyArNTMsNiBAQAogI2RlZmluZSBEQkdfQkxLREVWICAgICAgMHgwMTAwCiAjZGVmaW5lIERCR19SWCAgICAgICAgICAweDAyMDAKICNkZWZpbmUgREJHX1RYICAgICAgICAgIDB4MDQwMAotc3RhdGljIERFRklORV9NVVRFWChuYmRfbXV0ZXgpOwogc3RhdGljIHVuc2lnbmVkIGludCBkZWJ1Z2ZsYWdzOwogI2VuZGlmIC8qIE5ERUJVRyAqLwogCkBAIC03MTgsMTEgKzcxNyw5IEBACiAJZHByaW50ayhEQkdfSU9DVEwsICIlczogbmJkX2lvY3RsIGNtZD0lcygweCV4KSBhcmc9JWx1XG4iLAogCQkJbG8tPmRpc2stPmRpc2tfbmFtZSwgaW9jdGxfY21kX3RvX2FzY2lpKGNtZCksIGNtZCwgYXJnKTsKIAotCW11dGV4X2xvY2soJm5iZF9tdXRleCk7CiAJbXV0ZXhfbG9jaygmbG8tPnR4X2xvY2spOwogCWVycm9yID0gX19uYmRfaW9jdGwoYmRldiwgbG8sIGNtZCwgYXJnKTsKIAltdXRleF91bmxvY2soJmxvLT50eF9sb2NrKTsKLQltdXRleF91bmxvY2soJm5iZF9tdXRleCk7CiAKIAlyZXR1cm4gZXJyb3I7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2JsdWV0b290aC9hdGgzay5jIGIvZHJpdmVycy9ibHVldG9vdGgvYXRoM2suYwppbmRleCA5NDllZDA5Li5hMTI2ZTYxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2JsdWV0b290aC9hdGgzay5jCisrKyBiL2RyaXZlcnMvYmx1ZXRvb3RoL2F0aDNrLmMKQEAgLTQ3LDMzICs0NywxNiBAQAogI2RlZmluZSBVU0JfUkVRX0RGVV9ETkxPQUQJMQogI2RlZmluZSBCVUxLX1NJWkUJCTQwOTYKIAotc3RydWN0IGF0aDNrX2RhdGEgewotCXN0cnVjdCB1c2JfZGV2aWNlICp1ZGV2OwotCXU4ICpmd19kYXRhOwotCXUzMiBmd19zaXplOwotCXUzMiBmd19zZW50OwotfTsKLQotc3RhdGljIGludCBhdGgza19sb2FkX2Zpcm13YXJlKHN0cnVjdCBhdGgza19kYXRhICpkYXRhLAotCQkJCXVuc2lnbmVkIGNoYXIgKmZpcm13YXJlLAotCQkJCWludCBjb3VudCkKK3N0YXRpYyBpbnQgYXRoM2tfbG9hZF9maXJtd2FyZShzdHJ1Y3QgdXNiX2RldmljZSAqdWRldiwKKwkJCQljb25zdCBzdHJ1Y3QgZmlybXdhcmUgKmZpcm13YXJlKQogewogCXU4ICpzZW5kX2J1ZjsKIAlpbnQgZXJyLCBwaXBlLCBsZW4sIHNpemUsIHNlbnQgPSAwOworCWludCBjb3VudCA9IGZpcm13YXJlLT5zaXplOwogCi0JQlRfREJHKCJhdGgzayAlcCB1ZGV2ICVwIiwgZGF0YSwgZGF0YS0+dWRldik7CisJQlRfREJHKCJ1ZGV2ICVwIiwgdWRldik7CiAKLQlwaXBlID0gdXNiX3NuZGN0cmxwaXBlKGRhdGEtPnVkZXYsIDApOwotCi0JaWYgKCh1c2JfY29udHJvbF9tc2coZGF0YS0+dWRldiwgcGlwZSwKLQkJCQlVU0JfUkVRX0RGVV9ETkxPQUQsCi0JCQkJVVNCX1RZUEVfVkVORE9SLCAwLCAwLAotCQkJCWZpcm13YXJlLCAyMCwgVVNCX0NUUkxfU0VUX1RJTUVPVVQpKSA8IDApIHsKLQkJQlRfRVJSKCJDYW4ndCBjaGFuZ2UgdG8gbG9hZGluZyBjb25maWd1cmF0aW9uIGVyciIpOwotCQlyZXR1cm4gLUVCVVNZOwotCX0KLQlzZW50ICs9IDIwOwotCWNvdW50IC09IDIwOworCXBpcGUgPSB1c2Jfc25kY3RybHBpcGUodWRldiwgMCk7CiAKIAlzZW5kX2J1ZiA9IGttYWxsb2MoQlVMS19TSVpFLCBHRlBfQVRPTUlDKTsKIAlpZiAoIXNlbmRfYnVmKSB7CkBAIC04MSwxMiArNjQsMjMgQEAKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQogCisJbWVtY3B5KHNlbmRfYnVmLCBmaXJtd2FyZS0+ZGF0YSwgMjApOworCWlmICgoZXJyID0gdXNiX2NvbnRyb2xfbXNnKHVkZXYsIHBpcGUsCisJCQkJVVNCX1JFUV9ERlVfRE5MT0FELAorCQkJCVVTQl9UWVBFX1ZFTkRPUiwgMCwgMCwKKwkJCQlzZW5kX2J1ZiwgMjAsIFVTQl9DVFJMX1NFVF9USU1FT1VUKSkgPCAwKSB7CisJCUJUX0VSUigiQ2FuJ3QgY2hhbmdlIHRvIGxvYWRpbmcgY29uZmlndXJhdGlvbiBlcnIiKTsKKwkJZ290byBlcnJvcjsKKwl9CisJc2VudCArPSAyMDsKKwljb3VudCAtPSAyMDsKKwogCXdoaWxlIChjb3VudCkgewogCQlzaXplID0gbWluX3QodWludCwgY291bnQsIEJVTEtfU0laRSk7Ci0JCXBpcGUgPSB1c2Jfc25kYnVsa3BpcGUoZGF0YS0+dWRldiwgMHgwMik7Ci0JCW1lbWNweShzZW5kX2J1ZiwgZmlybXdhcmUgKyBzZW50LCBzaXplKTsKKwkJcGlwZSA9IHVzYl9zbmRidWxrcGlwZSh1ZGV2LCAweDAyKTsKKwkJbWVtY3B5KHNlbmRfYnVmLCBmaXJtd2FyZS0+ZGF0YSArIHNlbnQsIHNpemUpOwogCi0JCWVyciA9IHVzYl9idWxrX21zZyhkYXRhLT51ZGV2LCBwaXBlLCBzZW5kX2J1Ziwgc2l6ZSwKKwkJZXJyID0gdXNiX2J1bGtfbXNnKHVkZXYsIHBpcGUsIHNlbmRfYnVmLCBzaXplLAogCQkJCQkmbGVuLCAzMDAwKTsKIAogCQlpZiAoZXJyIHx8IChsZW4gIT0gc2l6ZSkpIHsKQEAgLTExMiw1NyArMTA2LDI4IEBACiB7CiAJY29uc3Qgc3RydWN0IGZpcm13YXJlICpmaXJtd2FyZTsKIAlzdHJ1Y3QgdXNiX2RldmljZSAqdWRldiA9IGludGVyZmFjZV90b191c2JkZXYoaW50Zik7Ci0Jc3RydWN0IGF0aDNrX2RhdGEgKmRhdGE7Ci0JaW50IHNpemU7CiAKIAlCVF9EQkcoImludGYgJXAgaWQgJXAiLCBpbnRmLCBpZCk7CiAKIAlpZiAoaW50Zi0+Y3VyX2FsdHNldHRpbmctPmRlc2MuYkludGVyZmFjZU51bWJlciAhPSAwKQogCQlyZXR1cm4gLUVOT0RFVjsKIAotCWRhdGEgPSBremFsbG9jKHNpemVvZigqZGF0YSksIEdGUF9LRVJORUwpOwotCWlmICghZGF0YSkKLQkJcmV0dXJuIC1FTk9NRU07Ci0KLQlkYXRhLT51ZGV2ID0gdWRldjsKLQogCWlmIChyZXF1ZXN0X2Zpcm13YXJlKCZmaXJtd2FyZSwgImF0aDNrLTEuZnciLCAmdWRldi0+ZGV2KSA8IDApIHsKLQkJa2ZyZWUoZGF0YSk7CiAJCXJldHVybiAtRUlPOwogCX0KIAotCXNpemUgPSBtYXhfdCh1aW50LCBmaXJtd2FyZS0+c2l6ZSwgNDA5Nik7Ci0JZGF0YS0+ZndfZGF0YSA9IGttYWxsb2Moc2l6ZSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFkYXRhLT5md19kYXRhKSB7CisJaWYgKGF0aDNrX2xvYWRfZmlybXdhcmUodWRldiwgZmlybXdhcmUpKSB7CiAJCXJlbGVhc2VfZmlybXdhcmUoZmlybXdhcmUpOwotCQlrZnJlZShkYXRhKTsKLQkJcmV0dXJuIC1FTk9NRU07Ci0JfQotCi0JbWVtY3B5KGRhdGEtPmZ3X2RhdGEsIGZpcm13YXJlLT5kYXRhLCBmaXJtd2FyZS0+c2l6ZSk7Ci0JZGF0YS0+Zndfc2l6ZSA9IGZpcm13YXJlLT5zaXplOwotCWRhdGEtPmZ3X3NlbnQgPSAwOwotCXJlbGVhc2VfZmlybXdhcmUoZmlybXdhcmUpOwotCi0JdXNiX3NldF9pbnRmZGF0YShpbnRmLCBkYXRhKTsKLQlpZiAoYXRoM2tfbG9hZF9maXJtd2FyZShkYXRhLCBkYXRhLT5md19kYXRhLCBkYXRhLT5md19zaXplKSkgewotCQl1c2Jfc2V0X2ludGZkYXRhKGludGYsIE5VTEwpOwotCQlrZnJlZShkYXRhLT5md19kYXRhKTsKLQkJa2ZyZWUoZGF0YSk7CiAJCXJldHVybiAtRUlPOwogCX0KKwlyZWxlYXNlX2Zpcm13YXJlKGZpcm13YXJlKTsKIAogCXJldHVybiAwOwogfQogCiBzdGF0aWMgdm9pZCBhdGgza19kaXNjb25uZWN0KHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRmKQogewotCXN0cnVjdCBhdGgza19kYXRhICpkYXRhID0gdXNiX2dldF9pbnRmZGF0YShpbnRmKTsKLQogCUJUX0RCRygiYXRoM2tfZGlzY29ubmVjdCBpbnRmICVwIiwgaW50Zik7Ci0KLQlrZnJlZShkYXRhLT5md19kYXRhKTsKLQlrZnJlZShkYXRhKTsKIH0KIAogc3RhdGljIHN0cnVjdCB1c2JfZHJpdmVyIGF0aDNrX2RyaXZlciA9IHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2Ryb20vY2Ryb20uYyBiL2RyaXZlcnMvY2Ryb20vY2Ryb20uYwppbmRleCAxNDAzM2EzLi5lMmM0OGE3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Nkcm9tL2Nkcm9tLmMKKysrIGIvZHJpdmVycy9jZHJvbS9jZHJvbS5jCkBAIC00MDksNyArNDA5LDggQEAKIAl9CiAKIAlFTlNVUkUoZHJpdmVfc3RhdHVzLCBDRENfRFJJVkVfU1RBVFVTICk7Ci0JRU5TVVJFKG1lZGlhX2NoYW5nZWQsIENEQ19NRURJQV9DSEFOR0VEKTsKKwlpZiAoY2RvLT5jaGVja19ldmVudHMgPT0gTlVMTCAmJiBjZG8tPm1lZGlhX2NoYW5nZWQgPT0gTlVMTCkKKwkJKmNoYW5nZV9jYXBhYmlsaXR5ID0gfihDRENfTUVESUFfQ0hBTkdFRCB8IENEQ19TRUxFQ1RfRElTQyk7CiAJRU5TVVJFKHRyYXlfbW92ZSwgQ0RDX0NMT1NFX1RSQVkgfCBDRENfT1BFTl9UUkFZKTsKIAlFTlNVUkUobG9ja19kb29yLCBDRENfTE9DSyk7CiAJRU5TVVJFKHNlbGVjdF9zcGVlZCwgQ0RDX1NFTEVDVF9TUEVFRCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvS2NvbmZpZyBiL2RyaXZlcnMvY2hhci9LY29uZmlnCmluZGV4IDBmMTc1YTguLmI3OTgwYTgzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvS2NvbmZpZworKysgYi9kcml2ZXJzL2NoYXIvS2NvbmZpZwpAQCAtNSw3ICs1LDcgQEAKIG1lbnUgIkNoYXJhY3RlciBkZXZpY2VzIgogCiBjb25maWcgVlQKLQlib29sICJWaXJ0dWFsIHRlcm1pbmFsIiBpZiBFTUJFRERFRAorCWJvb2wgIlZpcnR1YWwgdGVybWluYWwiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gIVMzOTAKIAlzZWxlY3QgSU5QVVQKIAlkZWZhdWx0IHkKQEAgLTM5LDEzICszOSwxMyBAQAogY29uZmlnIENPTlNPTEVfVFJBTlNMQVRJT05TCiAJZGVwZW5kcyBvbiBWVAogCWRlZmF1bHQgeQotCWJvb2wgIkVuYWJsZSBjaGFyYWN0ZXIgdHJhbnNsYXRpb25zIGluIGNvbnNvbGUiIGlmIEVNQkVEREVECisJYm9vbCAiRW5hYmxlIGNoYXJhY3RlciB0cmFuc2xhdGlvbnMgaW4gY29uc29sZSIgaWYgRVhQRVJUCiAJLS0taGVscC0tLQogCSAgVGhpcyBlbmFibGVzIHN1cHBvcnQgZm9yIGZvbnQgbWFwcGluZyBhbmQgVW5pY29kZSB0cmFuc2xhdGlvbgogCSAgb24gdmlydHVhbCBjb25zb2xlcy4KIAogY29uZmlnIFZUX0NPTlNPTEUKLQlib29sICJTdXBwb3J0IGZvciBjb25zb2xlIG9uIHZpcnR1YWwgdGVybWluYWwiIGlmIEVNQkVEREVECisJYm9vbCAiU3VwcG9ydCBmb3IgY29uc29sZSBvbiB2aXJ0dWFsIHRlcm1pbmFsIiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFZUCiAJZGVmYXVsdCB5CiAJLS0taGVscC0tLQpAQCAtNDI2LDEwICs0MjYsMTAgQEAKICAgICAgICAgIElmIHlvdSBoYXZlIGFuIFNHSSBBbHRpeCB3aXRoIGFuIGF0dGFjaGVkIFNBQnJpY2sKICAgICAgICAgIHNheSBZIG9yIE0gaGVyZSwgb3RoZXJ3aXNlIHNheSBOLgogCi1zb3VyY2UgImRyaXZlcnMvc2VyaWFsL0tjb25maWciCitzb3VyY2UgImRyaXZlcnMvdHR5L3NlcmlhbC9LY29uZmlnIgogCiBjb25maWcgVU5JWDk4X1BUWVMKLQlib29sICJVbml4OTggUFRZIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiVW5peDk4IFBUWSBzdXBwb3J0IiBpZiBFWFBFUlQKIAlkZWZhdWx0IHkKIAktLS1oZWxwLS0tCiAJICBBIHBzZXVkbyB0ZXJtaW5hbCAoUFRZKSBpcyBhIHNvZnR3YXJlIGRldmljZSBjb25zaXN0aW5nIG9mIHR3bwpAQCAtNDk1LDcgKzQ5NSw3IEBACiAKIGNvbmZpZyBUVFlfUFJJTlRLCiAJYm9vbCAiVFRZIGRyaXZlciB0byBvdXRwdXQgdXNlciBtZXNzYWdlcyB2aWEgcHJpbnRrIgotCWRlcGVuZHMgb24gRU1CRURERUQKKwlkZXBlbmRzIG9uIEVYUEVSVAogCWRlZmF1bHQgbgogCS0tLWhlbHAtLS0KIAkgIElmIHlvdSBzYXkgWSBoZXJlLCB0aGUgc3VwcG9ydCBmb3Igd3JpdGluZyB1c2VyIG1lc3NhZ2VzIChpLmUuCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvTWFrZWZpbGUgYi9kcml2ZXJzL2NoYXIvTWFrZWZpbGUKaW5kZXggMWU5ZGZmYi4uODIzOGY4OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvY2hhci9NYWtlZmlsZQpAQCAtMzAsMTcgKzMwLDYgQEAKIG9iai0kKENPTkZJR19BTUlHQV9CVUlMVElOX1NFUklBTCkgKz0gYW1pc2VyaWFsLm8KIG9iai0kKENPTkZJR19TWCkJCSs9IHN4Lm8gZ2VuZXJpY19zZXJpYWwubwogb2JqLSQoQ09ORklHX1JJTykJCSs9IHJpby8gZ2VuZXJpY19zZXJpYWwubwotb2JqLSQoQ09ORklHX0hWQ19DT05TT0xFKQkrPSBodmNfdmlvLm8gaHZzaS5vCi1vYmotJChDT05GSUdfSFZDX0lTRVJJRVMpCSs9IGh2Y19pc2VyaWVzLm8KLW9iai0kKENPTkZJR19IVkNfUlRBUykJCSs9IGh2Y19ydGFzLm8KLW9iai0kKENPTkZJR19IVkNfVElMRSkJCSs9IGh2Y190aWxlLm8KLW9iai0kKENPTkZJR19IVkNfRENDKQkJKz0gaHZjX2RjYy5vCi1vYmotJChDT05GSUdfSFZDX0JFQVQpCQkrPSBodmNfYmVhdC5vCi1vYmotJChDT05GSUdfSFZDX0RSSVZFUikJKz0gaHZjX2NvbnNvbGUubwotb2JqLSQoQ09ORklHX0hWQ19JUlEpCQkrPSBodmNfaXJxLm8KLW9iai0kKENPTkZJR19IVkNfWEVOKQkJKz0gaHZjX3hlbi5vCi1vYmotJChDT05GSUdfSFZDX0lVQ1YpCQkrPSBodmNfaXVjdi5vCi1vYmotJChDT05GSUdfSFZDX1VEQkcpCQkrPSBodmNfdWRiZy5vCiBvYmotJChDT05GSUdfVklSVElPX0NPTlNPTEUpCSs9IHZpcnRpb19jb25zb2xlLm8KIG9iai0kKENPTkZJR19SQVdfRFJJVkVSKQkrPSByYXcubwogb2JqLSQoQ09ORklHX1NHSV9TTlNDKQkJKz0gc25zYy5vIHNuc2NfZXZlbnQubwpAQCAtNDgsNyArMzcsNiBAQAogb2JqLSQoQ09ORklHX01NVElNRVIpCQkrPSBtbXRpbWVyLm8KIG9iai0kKENPTkZJR19VVl9NTVRJTUVSKQkrPSB1dl9tbXRpbWVyLm8KIG9iai0kKENPTkZJR19WSU9UQVBFKQkJKz0gdmlvdGFwZS5vCi1vYmotJChDT05GSUdfSFZDUykJCSs9IGh2Y3Mubwogb2JqLSQoQ09ORklHX0lCTV9CU1IpCQkrPSBic3Iubwogb2JqLSQoQ09ORklHX1NHSV9NQkNTKQkJKz0gbWJjcy5vCiBvYmotJChDT05GSUdfQlJJUV9QQU5FTCkJKz0gYnJpcV9wYW5lbC5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvYWdwL0tjb25maWcgYi9kcml2ZXJzL2NoYXIvYWdwL0tjb25maWcKaW5kZXggZmNkODY3ZC4uZDhiMWI1NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL2FncC9LY29uZmlnCisrKyBiL2RyaXZlcnMvY2hhci9hZ3AvS2NvbmZpZwpAQCAtNTAsNyArNTAsNyBAQAogCiBjb25maWcgQUdQX0FNRAogCXRyaXN0YXRlICJBTUQgSXJvbmdhdGUsIDc2MSwgYW5kIDc2MiBjaGlwc2V0IHN1cHBvcnQiCi0JZGVwZW5kcyBvbiBBR1AgJiYgKFg4Nl8zMiB8fCBBTFBIQSkKKwlkZXBlbmRzIG9uIEFHUCAmJiBYODZfMzIKIAloZWxwCiAJICBUaGlzIG9wdGlvbiBnaXZlcyB5b3UgQUdQIHN1cHBvcnQgZm9yIHRoZSBHTFggY29tcG9uZW50IG9mCiAJICBYIG9uIEFNRCBJcm9uZ2F0ZSwgNzYxLCBhbmQgNzYyIGNoaXBzZXRzLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2FncC9hbWQtazctYWdwLmMgYi9kcml2ZXJzL2NoYXIvYWdwL2FtZC1rNy1hZ3AuYwppbmRleCBiMWI0MzYyLi40NTY4MWMwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvYWdwL2FtZC1rNy1hZ3AuYworKysgYi9kcml2ZXJzL2NoYXIvYWdwL2FtZC1rNy1hZ3AuYwpAQCAtNDEsMjIgKzQxLDggQEAKIAlpZiAocGFnZV9tYXAtPnJlYWwgPT0gTlVMTCkKIAkJcmV0dXJuIC1FTk9NRU07CiAKLSNpZm5kZWYgQ09ORklHX1g4NgotCVNldFBhZ2VSZXNlcnZlZCh2aXJ0X3RvX3BhZ2UocGFnZV9tYXAtPnJlYWwpKTsKLQlnbG9iYWxfY2FjaGVfZmx1c2goKTsKLQlwYWdlX21hcC0+cmVtYXBwZWQgPSBpb3JlbWFwX25vY2FjaGUodmlydF90b19waHlzKHBhZ2VfbWFwLT5yZWFsKSwKLQkJCQkJICAgIFBBR0VfU0laRSk7Ci0JaWYgKHBhZ2VfbWFwLT5yZW1hcHBlZCA9PSBOVUxMKSB7Ci0JCUNsZWFyUGFnZVJlc2VydmVkKHZpcnRfdG9fcGFnZShwYWdlX21hcC0+cmVhbCkpOwotCQlmcmVlX3BhZ2UoKHVuc2lnbmVkIGxvbmcpIHBhZ2VfbWFwLT5yZWFsKTsKLQkJcGFnZV9tYXAtPnJlYWwgPSBOVUxMOwotCQlyZXR1cm4gLUVOT01FTTsKLQl9Ci0JZ2xvYmFsX2NhY2hlX2ZsdXNoKCk7Ci0jZWxzZQogCXNldF9tZW1vcnlfdWMoKHVuc2lnbmVkIGxvbmcpcGFnZV9tYXAtPnJlYWwsIDEpOwogCXBhZ2VfbWFwLT5yZW1hcHBlZCA9IHBhZ2VfbWFwLT5yZWFsOwotI2VuZGlmCiAKIAlmb3IgKGkgPSAwOyBpIDwgUEFHRV9TSVpFIC8gc2l6ZW9mKHVuc2lnbmVkIGxvbmcpOyBpKyspIHsKIAkJd3JpdGVsKGFncF9icmlkZ2UtPnNjcmF0Y2hfcGFnZSwgcGFnZV9tYXAtPnJlbWFwcGVkK2kpOwpAQCAtNjgsMTIgKzU0LDcgQEAKIAogc3RhdGljIHZvaWQgYW1kX2ZyZWVfcGFnZV9tYXAoc3RydWN0IGFtZF9wYWdlX21hcCAqcGFnZV9tYXApCiB7Ci0jaWZuZGVmIENPTkZJR19YODYKLQlpb3VubWFwKHBhZ2VfbWFwLT5yZW1hcHBlZCk7Ci0JQ2xlYXJQYWdlUmVzZXJ2ZWQodmlydF90b19wYWdlKHBhZ2VfbWFwLT5yZWFsKSk7Ci0jZWxzZQogCXNldF9tZW1vcnlfd2IoKHVuc2lnbmVkIGxvbmcpcGFnZV9tYXAtPnJlYWwsIDEpOwotI2VuZGlmCiAJZnJlZV9wYWdlKCh1bnNpZ25lZCBsb25nKSBwYWdlX21hcC0+cmVhbCk7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9hZ3AvaW50ZWwtYWdwLmMgYi9kcml2ZXJzL2NoYXIvYWdwL2ludGVsLWFncC5jCmluZGV4IDA3ZTk3OTYuLmIwYTBkY2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci9hZ3AvaW50ZWwtYWdwLmMKKysrIGIvZHJpdmVycy9jaGFyL2FncC9pbnRlbC1hZ3AuYwpAQCAtNzE3LDggKzcxNyw4IEBACiAJeyBQQ0lfREVWSUNFX0lEX0lOVEVMXzgyODIwX1VQX0hCLCAiaTgyMCIsICZpbnRlbF84MjBfZHJpdmVyIH0sCiAJeyBQQ0lfREVWSUNFX0lEX0lOVEVMXzgyODMwX0hCLCAiODMwTSIsICZpbnRlbF84MzBtcF9kcml2ZXIgfSwKIAl7IFBDSV9ERVZJQ0VfSURfSU5URUxfODI4NDBfSEIsICJpODQwIiwgJmludGVsXzg0MF9kcml2ZXIgfSwKLQl7IFBDSV9ERVZJQ0VfSURfSU5URUxfODI4NDVfSEIsICI4NDVHIiwgJmludGVsXzg0NV9kcml2ZXIgfSwKLQl7IFBDSV9ERVZJQ0VfSURfSU5URUxfODI4NDVHX0hCLCAiODMwTSIsICZpbnRlbF84NDVfZHJpdmVyIH0sCisJeyBQQ0lfREVWSUNFX0lEX0lOVEVMXzgyODQ1X0hCLCAiaTg0NSIsICZpbnRlbF84NDVfZHJpdmVyIH0sCisJeyBQQ0lfREVWSUNFX0lEX0lOVEVMXzgyODQ1R19IQiwgIjg0NUciLCAmaW50ZWxfODQ1X2RyaXZlciB9LAogCXsgUENJX0RFVklDRV9JRF9JTlRFTF84Mjg1MF9IQiwgImk4NTAiLCAmaW50ZWxfODUwX2RyaXZlciB9LAogCXsgUENJX0RFVklDRV9JRF9JTlRFTF84Mjg1NF9IQiwgIjg1NCIsICZpbnRlbF84NDVfZHJpdmVyIH0sCiAJeyBQQ0lfREVWSUNFX0lEX0lOVEVMXzgyODU1UE1fSEIsICI4NTVQTSIsICZpbnRlbF84NDVfZHJpdmVyIH0sCkBAIC03NzQsMjAgKzc3NCwxNCBAQAogCWRldl9pbmZvKCZwZGV2LT5kZXYsICJJbnRlbCAlcyBDaGlwc2V0XG4iLCBpbnRlbF9hZ3BfY2hpcHNldHNbaV0ubmFtZSk7CiAKIAkvKgotCSogSWYgdGhlIGRldmljZSBoYXMgbm90IGJlZW4gcHJvcGVybHkgc2V0dXAsIHRoZSBmb2xsb3dpbmcgd2lsbCBjYXRjaAotCSogdGhlIHByb2JsZW0gYW5kIHNob3VsZCBzdG9wIHRoZSBzeXN0ZW0gZnJvbSBjcmFzaGluZy4KLQkqIDIwMDMwNjEwIC0gaGFtaXNoQHpvdC5vcmcKLQkqLwotCWlmIChwY2lfZW5hYmxlX2RldmljZShwZGV2KSkgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW4ndCBlbmFibGUgUENJIGRldmljZVxuIik7Ci0JCWFncF9wdXRfYnJpZGdlKGJyaWRnZSk7Ci0JCXJldHVybiAtRU5PREVWOwotCX0KLQotCS8qCiAJKiBUaGUgZm9sbG93aW5nIGZpeGVzIHRoZSBjYXNlIHdoZXJlIHRoZSBCSU9TIGhhcyAiZm9yZ290dGVuIiB0bwogCSogcHJvdmlkZSBhbiBhZGRyZXNzIHJhbmdlIGZvciB0aGUgR0FSVC4KIAkqIDIwMDMwNjEwIC0gaGFtaXNoQHpvdC5vcmcKKwkqIFRoaXMgaGFwcGVucyBiZWZvcmUgcGNpX2VuYWJsZV9kZXZpY2UoKSBpbnRlbnRpb25hbGx5OworCSogY2FsbGluZyBwY2lfZW5hYmxlX2RldmljZSgpIGJlZm9yZSBhc3NpZ25pbmcgdGhlIHJlc291cmNlCisJKiB3aWxsIHJlc3VsdCBpbiB0aGUgR0FSVCBiZWluZyBkaXNhYmxlZCBvbiBtYWNoaW5lcyB3aXRoIHN1Y2gKKwkqIEJJT1NzICh0aGUgR0FSVCBlbmRzIHVwIHdpdGggYSBCQVIgc3RhcnRpbmcgYXQgMCwgd2hpY2gKKwkqIGNvbmZsaWN0cyBhIGxvdCBvZiBvdGhlciBkZXZpY2VzKS4KIAkqLwogCXIgPSAmcGRldi0+cmVzb3VyY2VbMF07CiAJaWYgKCFyLT5zdGFydCAmJiByLT5lbmQpIHsKQEAgLTc5OCw2ICs3OTIsMTcgQEAKIAkJfQogCX0KIAorCS8qCisJKiBJZiB0aGUgZGV2aWNlIGhhcyBub3QgYmVlbiBwcm9wZXJseSBzZXR1cCwgdGhlIGZvbGxvd2luZyB3aWxsIGNhdGNoCisJKiB0aGUgcHJvYmxlbSBhbmQgc2hvdWxkIHN0b3AgdGhlIHN5c3RlbSBmcm9tIGNyYXNoaW5nLgorCSogMjAwMzA2MTAgLSBoYW1pc2hAem90Lm9yZworCSovCisJaWYgKHBjaV9lbmFibGVfZGV2aWNlKHBkZXYpKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgImNhbid0IGVuYWJsZSBQQ0kgZGV2aWNlXG4iKTsKKwkJYWdwX3B1dF9icmlkZ2UoYnJpZGdlKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCiAJLyogRmlsbCBpbiB0aGUgbW9kZSByZWdpc3RlciAqLwogCWlmIChjYXBfcHRyKSB7CiAJCXBjaV9yZWFkX2NvbmZpZ19kd29yZChwZGV2LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2FncC9pbnRlbC1ndHQuYyBiL2RyaXZlcnMvY2hhci9hZ3AvaW50ZWwtZ3R0LmMKaW5kZXggZTkyMWI2OS4uZmFiM2QzMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL2FncC9pbnRlbC1ndHQuYworKysgYi9kcml2ZXJzL2NoYXIvYWdwL2ludGVsLWd0dC5jCkBAIC02OCw2ICs2OCw3IEBACiAJcGh5c19hZGRyX3QgZ21hX2J1c19hZGRyOwogCXUzMiBQR0VUQkxfc2F2ZTsKIAl1MzIgX19pb21lbSAqZ3R0OwkJLyogSTkxNUcgKi8KKwlib29sIGNsZWFyX2Zha2VfYWdwOyAvKiBvbiBmaXJzdCBhY2Nlc3MgdmlhIGFncCwgZmlsbCB3aXRoIHNjcmF0Y2ggKi8KIAlpbnQgbnVtX2RjYWNoZV9lbnRyaWVzOwogCXVuaW9uIHsKIAkJdm9pZCBfX2lvbWVtICppOXh4X2ZsdXNoX3BhZ2U7CkBAIC04NjksMjEgKzg3MCwxMiBAQAogCiBzdGF0aWMgaW50IGludGVsX2Zha2VfYWdwX2NvbmZpZ3VyZSh2b2lkKQogewotCWludCBpOwotCiAJaWYgKCFpbnRlbF9lbmFibGVfZ3R0KCkpCiAJICAgIHJldHVybiAtRUlPOwogCisJaW50ZWxfcHJpdmF0ZS5jbGVhcl9mYWtlX2FncCA9IHRydWU7CiAJYWdwX2JyaWRnZS0+Z2FydF9idXNfYWRkciA9IGludGVsX3ByaXZhdGUuZ21hX2J1c19hZGRyOwogCi0JZm9yIChpID0gMDsgaSA8IGludGVsX3ByaXZhdGUuYmFzZS5ndHRfdG90YWxfZW50cmllczsgaSsrKSB7Ci0JCWludGVsX3ByaXZhdGUuZHJpdmVyLT53cml0ZV9lbnRyeShpbnRlbF9wcml2YXRlLnNjcmF0Y2hfcGFnZV9kbWEsCi0JCQkJCQkgIGksIDApOwotCX0KLQlyZWFkbChpbnRlbF9wcml2YXRlLmd0dCtpLTEpOwkvKiBQQ0kgUG9zdGluZy4gKi8KLQotCWdsb2JhbF9jYWNoZV9mbHVzaCgpOwotCiAJcmV0dXJuIDA7CiB9CiAKQEAgLTk0NSw2ICs5MzcsMTMgQEAKIHsKIAlpbnQgcmV0ID0gLUVJTlZBTDsKIAorCWlmIChpbnRlbF9wcml2YXRlLmNsZWFyX2Zha2VfYWdwKSB7CisJCWludCBzdGFydCA9IGludGVsX3ByaXZhdGUuYmFzZS5zdG9sZW5fc2l6ZSAvIFBBR0VfU0laRTsKKwkJaW50IGVuZCA9IGludGVsX3ByaXZhdGUuYmFzZS5ndHRfbWFwcGFibGVfZW50cmllczsKKwkJaW50ZWxfZ3R0X2NsZWFyX3JhbmdlKHN0YXJ0LCBlbmQgLSBzdGFydCk7CisJCWludGVsX3ByaXZhdGUuY2xlYXJfZmFrZV9hZ3AgPSBmYWxzZTsKKwl9CisKIAlpZiAoSU5URUxfR1RUX0dFTiA9PSAxICYmIHR5cGUgPT0gQUdQX0RDQUNIRV9NRU1PUlkpCiAJCXJldHVybiBpODEwX2luc2VydF9kY2FjaGVfZW50cmllcyhtZW0sIHBnX3N0YXJ0LCB0eXBlKTsKIApAQCAtMTM2MSw3ICsxMzYwLDcgQEAKIAkJJmk4MXhfZ3R0X2RyaXZlcn0sCiAJeyBQQ0lfREVWSUNFX0lEX0lOVEVMXzgyODMwX0NHQywgIjgzME0iLAogCQkmaTh4eF9ndHRfZHJpdmVyfSwKLQl7IFBDSV9ERVZJQ0VfSURfSU5URUxfODI4NDVHX0lHLCAiODMwTSIsCisJeyBQQ0lfREVWSUNFX0lEX0lOVEVMXzgyODQ1R19JRywgIjg0NUciLAogCQkmaTh4eF9ndHRfZHJpdmVyfSwKIAl7IFBDSV9ERVZJQ0VfSURfSU5URUxfODI4NTRfSUcsICI4NTQiLAogCQkmaTh4eF9ndHRfZHJpdmVyfSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9iZmluX2p0YWdfY29tbS5jIGIvZHJpdmVycy9jaGFyL2JmaW5fanRhZ19jb21tLmMKaW5kZXggZTM5N2RmMy4uMTY0MDI0NDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci9iZmluX2p0YWdfY29tbS5jCisrKyBiL2RyaXZlcnMvY2hhci9iZmluX2p0YWdfY29tbS5jCkBAIC0xODMsMTYgKzE4MywxNiBAQAogfQogCiAjaWZuZGVmIENPTkZJR19CRklOX0pUQUdfQ09NTV9DT05TT0xFCi0jIGRlZmluZSBhY3F1aXJlX2NvbnNvbGVfc2VtKCkKLSMgZGVmaW5lIHJlbGVhc2VfY29uc29sZV9zZW0oKQorIyBkZWZpbmUgY29uc29sZV9sb2NrKCkKKyMgZGVmaW5lIGNvbnNvbGVfdW5sb2NrKCkKICNlbmRpZgogc3RhdGljIGludAogYmZpbl9qY193cml0ZShzdHJ1Y3QgdHR5X3N0cnVjdCAqdHR5LCBjb25zdCB1bnNpZ25lZCBjaGFyICpidWYsIGludCBjb3VudCkKIHsKIAlpbnQgaTsKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJaSA9IGJmaW5famNfY2lyY193cml0ZShidWYsIGNvdW50KTsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAl3YWtlX3VwX3Byb2Nlc3MoYmZpbl9qY19rdGhyZWFkKTsKIAlyZXR1cm4gaTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9pcG1pL2lwbWlfbXNnaGFuZGxlci5jIGIvZHJpdmVycy9jaGFyL2lwbWkvaXBtaV9tc2doYW5kbGVyLmMKaW5kZXggMmZlNzJmOC4uMzgyMjNlOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL2lwbWkvaXBtaV9tc2doYW5kbGVyLmMKKysrIGIvZHJpdmVycy9jaGFyL2lwbWkvaXBtaV9tc2doYW5kbGVyLmMKQEAgLTk3MCw2ICs5NzAsMzMgQEAKIH0KIEVYUE9SVF9TWU1CT0woaXBtaV9jcmVhdGVfdXNlcik7CiAKK2ludCBpcG1pX2dldF9zbWlfaW5mbyhpbnQgaWZfbnVtLCBzdHJ1Y3QgaXBtaV9zbWlfaW5mbyAqZGF0YSkKK3sKKwlpbnQgICAgICAgICAgIHJ2ID0gMDsKKwlpcG1pX3NtaV90ICAgIGludGY7CisJc3RydWN0IGlwbWlfc21pX2hhbmRsZXJzICpoYW5kbGVyczsKKworCW11dGV4X2xvY2soJmlwbWlfaW50ZXJmYWNlc19tdXRleCk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9yY3UoaW50ZiwgJmlwbWlfaW50ZXJmYWNlcywgbGluaykgeworCQlpZiAoaW50Zi0+aW50Zl9udW0gPT0gaWZfbnVtKQorCQkJZ290byBmb3VuZDsKKwl9CisJLyogTm90IGZvdW5kLCByZXR1cm4gYW4gZXJyb3IgKi8KKwlydiA9IC1FSU5WQUw7CisJbXV0ZXhfdW5sb2NrKCZpcG1pX2ludGVyZmFjZXNfbXV0ZXgpOworCXJldHVybiBydjsKKworZm91bmQ6CisJaGFuZGxlcnMgPSBpbnRmLT5oYW5kbGVyczsKKwlydiA9IC1FTk9TWVM7CisJaWYgKGhhbmRsZXJzLT5nZXRfc21pX2luZm8pCisJCXJ2ID0gaGFuZGxlcnMtPmdldF9zbWlfaW5mbyhpbnRmLT5zZW5kX2luZm8sIGRhdGEpOworCW11dGV4X3VubG9jaygmaXBtaV9pbnRlcmZhY2VzX211dGV4KTsKKworCXJldHVybiBydjsKK30KK0VYUE9SVF9TWU1CT0woaXBtaV9nZXRfc21pX2luZm8pOworCiBzdGF0aWMgdm9pZCBmcmVlX3VzZXIoc3RydWN0IGtyZWYgKnJlZikKIHsKIAlpcG1pX3VzZXJfdCB1c2VyID0gY29udGFpbmVyX29mKHJlZiwgc3RydWN0IGlwbWlfdXNlciwgcmVmY291bnQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2lwbWkvaXBtaV9zaV9pbnRmLmMgYi9kcml2ZXJzL2NoYXIvaXBtaS9pcG1pX3NpX2ludGYuYwppbmRleCBmMjdjMDRlLi43ODU1ZjlmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvaXBtaS9pcG1pX3NpX2ludGYuYworKysgYi9kcml2ZXJzL2NoYXIvaXBtaS9pcG1pX3NpX2ludGYuYwpAQCAtNTcsNiArNTcsNyBAQAogI2luY2x1ZGUgPGFzbS9pcnEuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC9yY3VwZGF0ZS5oPgorI2luY2x1ZGUgPGxpbnV4L2lwbWkuaD4KICNpbmNsdWRlIDxsaW51eC9pcG1pX3NtaS5oPgogI2luY2x1ZGUgPGFzbS9pby5oPgogI2luY2x1ZGUgImlwbWlfc2lfc20uaCIKQEAgLTEwOSwxMCArMTEwLDYgQEAKIH07CiBzdGF0aWMgY2hhciAqc2lfdG9fc3RyW10gPSB7ICJrY3MiLCAic21pYyIsICJidCIgfTsKIAotZW51bSBpcG1pX2FkZHJfc3JjIHsKLQlTSV9JTlZBTElEID0gMCwgU0lfSE9UTU9ELCBTSV9IQVJEQ09ERUQsIFNJX1NQTUksIFNJX0FDUEksIFNJX1NNQklPUywKLQlTSV9QQ0ksCVNJX0RFVklDRVRSRUUsIFNJX0RFRkFVTFQKLX07CiBzdGF0aWMgY2hhciAqaXBtaV9hZGRyX3NyY190b19zdHJbXSA9IHsgTlVMTCwgImhvdG1vZCIsICJoYXJkY29kZWQiLCAiU1BNSSIsCiAJCQkJCSJBQ1BJIiwgIlNNQklPUyIsICJQQ0kiLAogCQkJCQkiZGV2aWNlLXRyZWUiLCAiZGVmYXVsdCIgfTsKQEAgLTI5Myw2ICsyOTAsNyBAQAogCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGhyZWFkOwogCiAJc3RydWN0IGxpc3RfaGVhZCBsaW5rOworCXVuaW9uIGlwbWlfc21pX2luZm9fdW5pb24gYWRkcl9pbmZvOwogfTsKIAogI2RlZmluZSBzbWlfaW5jX3N0YXQoc21pLCBzdGF0KSBcCkBAIC0zMjIsNiArMzIwLDcgQEAKIHN0YXRpYyBpbnQgYWRkX3NtaShzdHJ1Y3Qgc21pX2luZm8gKnNtaSk7CiBzdGF0aWMgaW50IHRyeV9zbWlfaW5pdChzdHJ1Y3Qgc21pX2luZm8gKnNtaSk7CiBzdGF0aWMgdm9pZCBjbGVhbnVwX29uZV9zaShzdHJ1Y3Qgc21pX2luZm8gKnRvX2NsZWFuKTsKK3N0YXRpYyB2b2lkIGNsZWFudXBfaXBtaV9zaSh2b2lkKTsKIAogc3RhdGljIEFUT01JQ19OT1RJRklFUl9IRUFEKHhhY3Rpb25fbm90aWZpZXJfbGlzdCk7CiBzdGF0aWMgaW50IHJlZ2lzdGVyX3hhY3Rpb25fbm90aWZpZXIoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpuYikKQEAgLTExODgsNiArMTE4NywxOCBAQAogCXJldHVybiAwOwogfQogCitzdGF0aWMgaW50IGdldF9zbWlfaW5mbyh2b2lkICpzZW5kX2luZm8sIHN0cnVjdCBpcG1pX3NtaV9pbmZvICpkYXRhKQoreworCXN0cnVjdCBzbWlfaW5mbyAqc21pID0gc2VuZF9pbmZvOworCisJZGF0YS0+YWRkcl9zcmMgPSBzbWktPmFkZHJfc291cmNlOworCWRhdGEtPmRldiA9IHNtaS0+ZGV2OworCWRhdGEtPmFkZHJfaW5mbyA9IHNtaS0+YWRkcl9pbmZvOworCWdldF9kZXZpY2Uoc21pLT5kZXYpOworCisJcmV0dXJuIDA7Cit9CisKIHN0YXRpYyB2b2lkIHNldF9tYWludGVuYW5jZV9tb2RlKHZvaWQgKnNlbmRfaW5mbywgaW50IGVuYWJsZSkKIHsKIAlzdHJ1Y3Qgc21pX2luZm8gICAqc21pX2luZm8gPSBzZW5kX2luZm87CkBAIC0xMTk5LDYgKzEyMTAsNyBAQAogc3RhdGljIHN0cnVjdCBpcG1pX3NtaV9oYW5kbGVycyBoYW5kbGVycyA9IHsKIAkub3duZXIgICAgICAgICAgICAgICAgICA9IFRISVNfTU9EVUxFLAogCS5zdGFydF9wcm9jZXNzaW5nICAgICAgID0gc21pX3N0YXJ0X3Byb2Nlc3NpbmcsCisJLmdldF9zbWlfaW5mbwkJPSBnZXRfc21pX2luZm8sCiAJLnNlbmRlcgkJCT0gc2VuZGVyLAogCS5yZXF1ZXN0X2V2ZW50cwkJPSByZXF1ZXN0X2V2ZW50cywKIAkuc2V0X21haW50ZW5hbmNlX21vZGUgICA9IHNldF9tYWludGVuYW5jZV9tb2RlLApAQCAtMTkzMCw3ICsxOTQyLDggQEAKIHN0YXRpYyBpbnQgYWNwaV9mYWlsdXJlOwogCiAvKiBGb3IgR1BFLXR5cGUgaW50ZXJydXB0cy4gKi8KLXN0YXRpYyB1MzIgaXBtaV9hY3BpX2dwZSh2b2lkICpjb250ZXh0KQorc3RhdGljIHUzMiBpcG1pX2FjcGlfZ3BlKGFjcGlfaGFuZGxlIGdwZV9kZXZpY2UsCisJdTMyIGdwZV9udW1iZXIsIHZvaWQgKmNvbnRleHQpCiB7CiAJc3RydWN0IHNtaV9pbmZvICpzbWlfaW5mbyA9IGNvbnRleHQ7CiAJdW5zaWduZWQgbG9uZyAgIGZsYWdzOwpAQCAtMjE1OCw2ICsyMTcxLDcgQEAKIAlwcmludGsoS0VSTl9JTkZPIFBGWCAicHJvYmluZyB2aWEgQUNQSVxuIik7CiAKIAloYW5kbGUgPSBhY3BpX2Rldi0+aGFuZGxlOworCWluZm8tPmFkZHJfaW5mby5hY3BpX2luZm8uYWNwaV9oYW5kbGUgPSBoYW5kbGU7CiAKIAkvKiBfSUZUIHRlbGxzIHVzIHRoZSBpbnRlcmZhY2UgdHlwZTogS0NTLCBCVCwgZXRjICovCiAJc3RhdHVzID0gYWNwaV9ldmFsdWF0ZV9pbnRlZ2VyKGhhbmRsZSwgIl9JRlQiLCBOVUxMLCAmdG1wKTsKQEAgLTM0MzcsMTYgKzM0NTEsNyBAQAogCW11dGV4X2xvY2soJnNtaV9pbmZvc19sb2NrKTsKIAlpZiAodW5sb2FkX3doZW5fZW1wdHkgJiYgbGlzdF9lbXB0eSgmc21pX2luZm9zKSkgewogCQltdXRleF91bmxvY2soJnNtaV9pbmZvc19sb2NrKTsKLSNpZmRlZiBDT05GSUdfUENJCi0JCWlmIChwY2lfcmVnaXN0ZXJlZCkKLQkJCXBjaV91bnJlZ2lzdGVyX2RyaXZlcigmaXBtaV9wY2lfZHJpdmVyKTsKLSNlbmRpZgotCi0jaWZkZWYgQ09ORklHX1BQQ19PRgotCQlpZiAob2ZfcmVnaXN0ZXJlZCkKLQkJCW9mX3VucmVnaXN0ZXJfcGxhdGZvcm1fZHJpdmVyKCZpcG1pX29mX3BsYXRmb3JtX2RyaXZlcik7Ci0jZW5kaWYKLQkJZHJpdmVyX3VucmVnaXN0ZXIoJmlwbWlfZHJpdmVyLmRyaXZlcik7CisJCWNsZWFudXBfaXBtaV9zaSgpOwogCQlwcmludGsoS0VSTl9XQVJOSU5HIFBGWAogCQkgICAgICAgIlVuYWJsZSB0byBmaW5kIGFueSBTeXN0ZW0gSW50ZXJmYWNlKHMpXG4iKTsKIAkJcmV0dXJuIC1FTk9ERVY7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvdHBtL3RwbS5jIGIvZHJpdmVycy9jaGFyL3RwbS90cG0uYwppbmRleCAxZjQ2ZjFjLi5mYWY1YTJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvdHBtL3RwbS5jCisrKyBiL2RyaXZlcnMvY2hhci90cG0vdHBtLmMKQEAgLTM2NCwxMiArMzY0LDE0IEBACiAJCSAgICB0cG1fcHJvdGVjdGVkX29yZGluYWxfZHVyYXRpb25bb3JkaW5hbCAmCiAJCQkJCQkgICBUUE1fUFJPVEVDVEVEX09SRElOQUxfTUFTS107CiAKLQlpZiAoZHVyYXRpb25faWR4ICE9IFRQTV9VTkRFRklORUQpCisJaWYgKGR1cmF0aW9uX2lkeCAhPSBUUE1fVU5ERUZJTkVEKSB7CiAJCWR1cmF0aW9uID0gY2hpcC0+dmVuZG9yLmR1cmF0aW9uW2R1cmF0aW9uX2lkeF07Ci0JaWYgKGR1cmF0aW9uIDw9IDApCisJCS8qIGlmIGR1cmF0aW9uIGlzIDAsIGl0J3MgYmVjYXVzZSBjaGlwLT52ZW5kb3IuZHVyYXRpb24gd2Fzbid0ICovCisJCS8qIGZpbGxlZCB5ZXQsIHNvIHdlIHNldCB0aGUgbG93ZXN0IHRpbWVvdXQganVzdCB0byBnaXZlIGVub3VnaCAqLworCQkvKiB0aW1lIGZvciB0cG1fZ2V0X3RpbWVvdXRzKCkgdG8gc3VjY2VlZCAqLworCQlyZXR1cm4gKGR1cmF0aW9uIDw9IDAgPyBIWiA6IGR1cmF0aW9uKTsKKwl9IGVsc2UKIAkJcmV0dXJuIDIgKiA2MCAqIEhaOwotCWVsc2UKLQkJcmV0dXJuIGR1cmF0aW9uOwogfQogRVhQT1JUX1NZTUJPTF9HUEwodHBtX2NhbGNfb3JkaW5hbF9kdXJhdGlvbik7CiAKQEAgLTU3NSw5ICs1NzcsMTEgQEAKIAlpZiAocmMpCiAJCXJldHVybjsKIAotCWlmIChiZTMyX3RvX2NwdSh0cG1fY21kLmhlYWRlci5vdXQucmV0dXJuX2NvZGUpCi0JICAgICE9IDMgKiBzaXplb2YodTMyKSkKKwlpZiAoYmUzMl90b19jcHUodHBtX2NtZC5oZWFkZXIub3V0LnJldHVybl9jb2RlKSAhPSAwIHx8CisJICAgIGJlMzJfdG9fY3B1KHRwbV9jbWQuaGVhZGVyLm91dC5sZW5ndGgpCisJICAgICE9IHNpemVvZih0cG1fY21kLmhlYWRlci5vdXQpICsgc2l6ZW9mKHUzMikgKyAzICogc2l6ZW9mKHUzMikpCiAJCXJldHVybjsKKwogCWR1cmF0aW9uX2NhcCA9ICZ0cG1fY21kLnBhcmFtcy5nZXRjYXBfb3V0LmNhcC5kdXJhdGlvbjsKIAljaGlwLT52ZW5kb3IuZHVyYXRpb25bVFBNX1NIT1JUXSA9CiAJICAgIHVzZWNzX3RvX2ppZmZpZXMoYmUzMl90b19jcHUoZHVyYXRpb25fY2FwLT50cG1fc2hvcnQpKTsKQEAgLTkzNyw2ICs5NDEsMTggQEAKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKHRwbV9zaG93X2NhcHNfMV8yKTsKIAorc3NpemVfdCB0cG1fc2hvd190aW1lb3V0cyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQkJICBjaGFyICpidWYpCit7CisJc3RydWN0IHRwbV9jaGlwICpjaGlwID0gZGV2X2dldF9kcnZkYXRhKGRldik7CisKKwlyZXR1cm4gc3ByaW50ZihidWYsICIlZCAlZCAlZFxuIiwKKwkgICAgICAgICAgICAgICBqaWZmaWVzX3RvX3VzZWNzKGNoaXAtPnZlbmRvci5kdXJhdGlvbltUUE1fU0hPUlRdKSwKKwkgICAgICAgICAgICAgICBqaWZmaWVzX3RvX3VzZWNzKGNoaXAtPnZlbmRvci5kdXJhdGlvbltUUE1fTUVESVVNXSksCisJICAgICAgICAgICAgICAgamlmZmllc190b191c2VjcyhjaGlwLT52ZW5kb3IuZHVyYXRpb25bVFBNX0xPTkddKSk7Cit9CitFWFBPUlRfU1lNQk9MX0dQTCh0cG1fc2hvd190aW1lb3V0cyk7CisKIHNzaXplX3QgdHBtX3N0b3JlX2NhbmNlbChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAogCQkJY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvdHBtL3RwbS5oIGIvZHJpdmVycy9jaGFyL3RwbS90cG0uaAppbmRleCA3MmRkYjAzLi5kODRmZjc3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvdHBtL3RwbS5oCisrKyBiL2RyaXZlcnMvY2hhci90cG0vdHBtLmgKQEAgLTU2LDYgKzU2LDggQEAKIAkJCQljaGFyICopOwogZXh0ZXJuIHNzaXplX3QgdHBtX3Nob3dfdGVtcF9kZWFjdGl2YXRlZChzdHJ1Y3QgZGV2aWNlICosCiAJCQkJCSBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqKTsKK2V4dGVybiBzc2l6ZV90IHRwbV9zaG93X3RpbWVvdXRzKHN0cnVjdCBkZXZpY2UgKiwKKwkJCQkgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNoYXIgKik7CiAKIHN0cnVjdCB0cG1fY2hpcDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL3RwbS90cG1fdGlzLmMgYi9kcml2ZXJzL2NoYXIvdHBtL3RwbV90aXMuYwppbmRleCBjMTdhMzA1Li4wZDFkMzhlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvdHBtL3RwbV90aXMuYworKysgYi9kcml2ZXJzL2NoYXIvdHBtL3RwbV90aXMuYwpAQCAtMzc2LDYgKzM3Niw3IEBACiAJCSAgIE5VTEwpOwogc3RhdGljIERFVklDRV9BVFRSKGNhcHMsIFNfSVJVR08sIHRwbV9zaG93X2NhcHNfMV8yLCBOVUxMKTsKIHN0YXRpYyBERVZJQ0VfQVRUUihjYW5jZWwsIFNfSVdVU1IgfCBTX0lXR1JQLCBOVUxMLCB0cG1fc3RvcmVfY2FuY2VsKTsKK3N0YXRpYyBERVZJQ0VfQVRUUih0aW1lb3V0cywgU19JUlVHTywgdHBtX3Nob3dfdGltZW91dHMsIE5VTEwpOwogCiBzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSAqdGlzX2F0dHJzW10gPSB7CiAJJmRldl9hdHRyX3B1YmVrLmF0dHIsCkBAIC0zODUsNyArMzg2LDggQEAKIAkmZGV2X2F0dHJfb3duZWQuYXR0ciwKIAkmZGV2X2F0dHJfdGVtcF9kZWFjdGl2YXRlZC5hdHRyLAogCSZkZXZfYXR0cl9jYXBzLmF0dHIsCi0JJmRldl9hdHRyX2NhbmNlbC5hdHRyLCBOVUxMLAorCSZkZXZfYXR0cl9jYW5jZWwuYXR0ciwKKwkmZGV2X2F0dHJfdGltZW91dHMuYXR0ciwgTlVMTCwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwIHRpc19hdHRyX2dycCA9IHsKQEAgLTQ5Myw5ICs0OTUsNiBAQAogCQkgIjEuMiBUUE0gKGRldmljZS1pZCAweCVYLCByZXYtaWQgJWQpXG4iLAogCQkgdmVuZG9yID4+IDE2LCBpb3JlYWQ4KGNoaXAtPnZlbmRvci5pb2Jhc2UgKyBUUE1fUklEKDApKSk7CiAKLQlpZiAoaXNfaXRwbSh0b19wbnBfZGV2KGRldikpKQotCQlpdHBtID0gMTsKLQogCWlmIChpdHBtKQogCQlkZXZfaW5mbyhkZXYsICJJbnRlbCBpVFBNIHdvcmthcm91bmQgZW5hYmxlZFxuIik7CiAKQEAgLTYzNyw2ICs2MzYsOSBAQAogCWVsc2UKIAkJaW50ZXJydXB0cyA9IDA7CiAKKwlpZiAoaXNfaXRwbShwbnBfZGV2KSkKKwkJaXRwbSA9IDE7CisKIAlyZXR1cm4gdHBtX3Rpc19pbml0KCZwbnBfZGV2LT5kZXYsIHN0YXJ0LCBsZW4sIGlycSk7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci92aXJ0aW9fY29uc29sZS5jIGIvZHJpdmVycy9jaGFyL3ZpcnRpb19jb25zb2xlLmMKaW5kZXggODk2YTJjZS4uNDkwMzkzMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL3ZpcnRpb19jb25zb2xlLmMKKysrIGIvZHJpdmVycy9jaGFyL3ZpcnRpb19jb25zb2xlLmMKQEAgLTEsNiArMSw3IEBACiAvKgogICogQ29weXJpZ2h0IChDKSAyMDA2LCAyMDA3LCAyMDA5IFJ1c3R5IFJ1c3NlbGwsIElCTSBDb3Jwb3JhdGlvbgotICogQ29weXJpZ2h0IChDKSAyMDA5LCAyMDEwIFJlZCBIYXQsIEluYy4KKyAqIENvcHlyaWdodCAoQykgMjAwOSwgMjAxMCwgMjAxMSBSZWQgSGF0LCBJbmMuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDksIDIwMTAsIDIwMTEgQW1pdCBTaGFoIDxhbWl0LnNoYWhAcmVkaGF0LmNvbT4KICAqCiAgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQogICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKQEAgLTMxLDcgKzMyLDcgQEAKICNpbmNsdWRlIDxsaW51eC92aXJ0aW9fY29uc29sZS5oPgogI2luY2x1ZGUgPGxpbnV4L3dhaXQuaD4KICNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KLSNpbmNsdWRlICJodmNfY29uc29sZS5oIgorI2luY2x1ZGUgIi4uL3R0eS9odmMvaHZjX2NvbnNvbGUuaCIKIAogLyoKICAqIFRoaXMgaXMgYSBnbG9iYWwgc3RydWN0IGZvciBzdG9yaW5nIGNvbW1vbiBkYXRhIGZvciBhbGwgdGhlIGRldmljZXMKQEAgLTE0NjIsNiArMTQ2MywxNyBAQAogCXNwaW5fdW5sb2NrKCZwb3J0ZGV2LT5jdnFfbG9jayk7CiB9CiAKK3N0YXRpYyB2b2lkIG91dF9pbnRyKHN0cnVjdCB2aXJ0cXVldWUgKnZxKQoreworCXN0cnVjdCBwb3J0ICpwb3J0OworCisJcG9ydCA9IGZpbmRfcG9ydF9ieV92cSh2cS0+dmRldi0+cHJpdiwgdnEpOworCWlmICghcG9ydCkKKwkJcmV0dXJuOworCisJd2FrZV91cF9pbnRlcnJ1cHRpYmxlKCZwb3J0LT53YWl0cXVldWUpOworfQorCiBzdGF0aWMgdm9pZCBpbl9pbnRyKHN0cnVjdCB2aXJ0cXVldWUgKnZxKQogewogCXN0cnVjdCBwb3J0ICpwb3J0OwpAQCAtMTU2Niw3ICsxNTc4LDcgQEAKIAkgKi8KIAlqID0gMDsKIAlpb19jYWxsYmFja3Nbal0gPSBpbl9pbnRyOwotCWlvX2NhbGxiYWNrc1tqICsgMV0gPSBOVUxMOworCWlvX2NhbGxiYWNrc1tqICsgMV0gPSBvdXRfaW50cjsKIAlpb19uYW1lc1tqXSA9ICJpbnB1dCI7CiAJaW9fbmFtZXNbaiArIDFdID0gIm91dHB1dCI7CiAJaiArPSAyOwpAQCAtMTU4MCw3ICsxNTkyLDcgQEAKIAkJZm9yIChpID0gMTsgaSA8IG5yX3BvcnRzOyBpKyspIHsKIAkJCWogKz0gMjsKIAkJCWlvX2NhbGxiYWNrc1tqXSA9IGluX2ludHI7Ci0JCQlpb19jYWxsYmFja3NbaiArIDFdID0gTlVMTDsKKwkJCWlvX2NhbGxiYWNrc1tqICsgMV0gPSBvdXRfaW50cjsKIAkJCWlvX25hbWVzW2pdID0gImlucHV0IjsKIAkJCWlvX25hbWVzW2ogKyAxXSA9ICJvdXRwdXQiOwogCQl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Nsb2Nrc291cmNlL2FjcGlfcG0uYyBiL2RyaXZlcnMvY2xvY2tzb3VyY2UvYWNwaV9wbS5jCmluZGV4IGNmYjBmNTIuLmVmZmU3OTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2xvY2tzb3VyY2UvYWNwaV9wbS5jCisrKyBiL2RyaXZlcnMvY2xvY2tzb3VyY2UvYWNwaV9wbS5jCkBAIC0yMDIsMTcgKzIwMiwyMSBAQAogCQkJcHJpbnRrKEtFUk5fSU5GTyAiUE0tVGltZXIgaGFkIGluY29uc2lzdGVudCByZXN1bHRzOiIKIAkJCSAgICAgICAiIDB4JSNsbHgsIDB4JSNsbHggLSBhYm9ydGluZy5cbiIsCiAJCQkgICAgICAgdmFsdWUxLCB2YWx1ZTIpOworCQkJcG10bXJfaW9wb3J0ID0gMDsKIAkJCXJldHVybiAtRUlOVkFMOwogCQl9CiAJCWlmIChpID09IEFDUElfUE1fUkVBRF9DSEVDS1MpIHsKIAkJCXByaW50ayhLRVJOX0lORk8gIlBNLVRpbWVyIGZhaWxlZCBjb25zaXN0ZW5jeSBjaGVjayAiCiAJCQkgICAgICAgIiAoMHglI2xseCkgLSBhYm9ydGluZy5cbiIsIHZhbHVlMSk7CisJCQlwbXRtcl9pb3BvcnQgPSAwOwogCQkJcmV0dXJuIC1FTk9ERVY7CiAJCX0KIAl9CiAKLQlpZiAodmVyaWZ5X3BtdG1yX3JhdGUoKSAhPSAwKQorCWlmICh2ZXJpZnlfcG10bXJfcmF0ZSgpICE9IDApeworCQlwbXRtcl9pb3BvcnQgPSAwOwogCQlyZXR1cm4gLUVOT0RFVjsKKwl9CiAKIAlyZXR1cm4gY2xvY2tzb3VyY2VfcmVnaXN0ZXJfaHooJmNsb2Nrc291cmNlX2FjcGlfcG0sCiAJCQkJCQlQTVRNUl9USUNLU19QRVJfU0VDKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2xvY2tzb3VyY2UvdGNiX2Nsa3NyYy5jIGIvZHJpdmVycy9jbG9ja3NvdXJjZS90Y2JfY2xrc3JjLmMKaW5kZXggMDFiODg2ZS4uNzljNDdlOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9jbG9ja3NvdXJjZS90Y2JfY2xrc3JjLmMKKysrIGIvZHJpdmVycy9jbG9ja3NvdXJjZS90Y2JfY2xrc3JjLmMKQEAgLTE5Niw5ICsxOTYsOSBAQAogCWNsa2V2dC5jbGtldnQubWluX2RlbHRhX25zID0gY2xvY2tldmVudF9kZWx0YTJucygxLCAmY2xrZXZ0LmNsa2V2dCkgKyAxOwogCWNsa2V2dC5jbGtldnQuY3B1bWFzayA9IGNwdW1hc2tfb2YoMCk7CiAKLQlzZXR1cF9pcnEoaXJxLCAmdGNfaXJxYWN0aW9uKTsKLQogCWNsb2NrZXZlbnRzX3JlZ2lzdGVyX2RldmljZSgmY2xrZXZ0LmNsa2V2dCk7CisKKwlzZXR1cF9pcnEoaXJxLCAmdGNfaXJxYWN0aW9uKTsKIH0KIAogI2Vsc2UgLyogIUNPTkZJR19HRU5FUklDX0NMT0NLRVZFTlRTICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NwdWZyZXEvS2NvbmZpZyBiL2RyaXZlcnMvY3B1ZnJlcS9LY29uZmlnCmluZGV4IGE4YzhkOWMuLmNhOGVlODAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY3B1ZnJlcS9LY29uZmlnCisrKyBiL2RyaXZlcnMvY3B1ZnJlcS9LY29uZmlnCkBAIC03MSw3ICs3MSw3IEBACiAKIGNvbmZpZyBDUFVfRlJFUV9ERUZBVUxUX0dPVl9QT1dFUlNBVkUKIAlib29sICJwb3dlcnNhdmUiCi0JZGVwZW5kcyBvbiBFTUJFRERFRAorCWRlcGVuZHMgb24gRVhQRVJUCiAJc2VsZWN0IENQVV9GUkVRX0dPVl9QT1dFUlNBVkUKIAloZWxwCiAJICBVc2UgdGhlIENQVUZyZXEgZ292ZXJub3IgJ3Bvd2Vyc2F2ZScgYXMgZGVmYXVsdC4gVGhpcyBzZXRzCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NwdWlkbGUvY3B1aWRsZS5jIGIvZHJpdmVycy9jcHVpZGxlL2NwdWlkbGUuYwppbmRleCAzODY4ODhmLi5iZjUwOTI0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2NwdWlkbGUvY3B1aWRsZS5jCisrKyBiL2RyaXZlcnMvY3B1aWRsZS9jcHVpZGxlLmMKQEAgLTk2LDcgKzk2LDE1IEBACiAKIAkvKiBlbnRlciB0aGUgc3RhdGUgYW5kIHVwZGF0ZSBzdGF0cyAqLwogCWRldi0+bGFzdF9zdGF0ZSA9IHRhcmdldF9zdGF0ZTsKKworCXRyYWNlX3Bvd2VyX3N0YXJ0KFBPV0VSX0NTVEFURSwgbmV4dF9zdGF0ZSwgZGV2LT5jcHUpOworCXRyYWNlX2NwdV9pZGxlKG5leHRfc3RhdGUsIGRldi0+Y3B1KTsKKwogCWRldi0+bGFzdF9yZXNpZGVuY3kgPSB0YXJnZXRfc3RhdGUtPmVudGVyKGRldiwgdGFyZ2V0X3N0YXRlKTsKKworCXRyYWNlX3Bvd2VyX2VuZChkZXYtPmNwdSk7CisJdHJhY2VfY3B1X2lkbGUoUFdSX0VWRU5UX0VYSVQsIGRldi0+Y3B1KTsKKwogCWlmIChkZXYtPmxhc3Rfc3RhdGUpCiAJCXRhcmdldF9zdGF0ZSA9IGRldi0+bGFzdF9zdGF0ZTsKIApAQCAtMTA2LDggKzExNCw2IEBACiAJLyogZ2l2ZSB0aGUgZ292ZXJub3IgYW4gb3Bwb3J0dW5pdHkgdG8gcmVmbGVjdCBvbiB0aGUgb3V0Y29tZSAqLwogCWlmIChjcHVpZGxlX2N1cnJfZ292ZXJub3ItPnJlZmxlY3QpCiAJCWNwdWlkbGVfY3Vycl9nb3Zlcm5vci0+cmVmbGVjdChkZXYpOwotCXRyYWNlX3Bvd2VyX2VuZChzbXBfcHJvY2Vzc29yX2lkKCkpOwotCXRyYWNlX2NwdV9pZGxlKFBXUl9FVkVOVF9FWElULCBzbXBfcHJvY2Vzc29yX2lkKCkpOwogfQogCiAvKioKQEAgLTE1NSw2ICsxNjEsNDUgQEAKIAogRVhQT1JUX1NZTUJPTF9HUEwoY3B1aWRsZV9yZXN1bWVfYW5kX3VubG9jayk7CiAKKyNpZmRlZiBDT05GSUdfQVJDSF9IQVNfQ1BVX1JFTEFYCitzdGF0aWMgaW50IHBvbGxfaWRsZShzdHJ1Y3QgY3B1aWRsZV9kZXZpY2UgKmRldiwgc3RydWN0IGNwdWlkbGVfc3RhdGUgKnN0KQoreworCWt0aW1lX3QJdDEsIHQyOworCXM2NCBkaWZmOworCWludCByZXQ7CisKKwl0MSA9IGt0aW1lX2dldCgpOworCWxvY2FsX2lycV9lbmFibGUoKTsKKwl3aGlsZSAoIW5lZWRfcmVzY2hlZCgpKQorCQljcHVfcmVsYXgoKTsKKworCXQyID0ga3RpbWVfZ2V0KCk7CisJZGlmZiA9IGt0aW1lX3RvX3VzKGt0aW1lX3N1Yih0MiwgdDEpKTsKKwlpZiAoZGlmZiA+IElOVF9NQVgpCisJCWRpZmYgPSBJTlRfTUFYOworCisJcmV0ID0gKGludCkgZGlmZjsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCBwb2xsX2lkbGVfaW5pdChzdHJ1Y3QgY3B1aWRsZV9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgY3B1aWRsZV9zdGF0ZSAqc3RhdGUgPSAmZGV2LT5zdGF0ZXNbMF07CisKKwljcHVpZGxlX3NldF9zdGF0ZWRhdGEoc3RhdGUsIE5VTEwpOworCisJc25wcmludGYoc3RhdGUtPm5hbWUsIENQVUlETEVfTkFNRV9MRU4sICJQT0xMIik7CisJc25wcmludGYoc3RhdGUtPmRlc2MsIENQVUlETEVfREVTQ19MRU4sICJDUFVJRExFIENPUkUgUE9MTCBJRExFIik7CisJc3RhdGUtPmV4aXRfbGF0ZW5jeSA9IDA7CisJc3RhdGUtPnRhcmdldF9yZXNpZGVuY3kgPSAwOworCXN0YXRlLT5wb3dlcl91c2FnZSA9IC0xOworCXN0YXRlLT5mbGFncyA9IDA7CisJc3RhdGUtPmVudGVyID0gcG9sbF9pZGxlOworfQorI2Vsc2UKK3N0YXRpYyB2b2lkIHBvbGxfaWRsZV9pbml0KHN0cnVjdCBjcHVpZGxlX2RldmljZSAqZGV2KSB7fQorI2VuZGlmIC8qIENPTkZJR19BUkNIX0hBU19DUFVfUkVMQVggKi8KKwogLyoqCiAgKiBjcHVpZGxlX2VuYWJsZV9kZXZpY2UgLSBlbmFibGVzIGlkbGUgUE0gZm9yIGEgQ1BVCiAgKiBAZGV2OiB0aGUgQ1BVCkBAIC0xNzksNiArMjI0LDggQEAKIAkJCXJldHVybiByZXQ7CiAJfQogCisJcG9sbF9pZGxlX2luaXQoZGV2KTsKKwogCWlmICgocmV0ID0gY3B1aWRsZV9hZGRfc3RhdGVfc3lzZnMoZGV2KSkpCiAJCXJldHVybiByZXQ7CiAKQEAgLTIzMyw0NSArMjgwLDYgQEAKIAogRVhQT1JUX1NZTUJPTF9HUEwoY3B1aWRsZV9kaXNhYmxlX2RldmljZSk7CiAKLSNpZmRlZiBDT05GSUdfQVJDSF9IQVNfQ1BVX1JFTEFYCi1zdGF0aWMgaW50IHBvbGxfaWRsZShzdHJ1Y3QgY3B1aWRsZV9kZXZpY2UgKmRldiwgc3RydWN0IGNwdWlkbGVfc3RhdGUgKnN0KQotewotCWt0aW1lX3QJdDEsIHQyOwotCXM2NCBkaWZmOwotCWludCByZXQ7Ci0KLQl0MSA9IGt0aW1lX2dldCgpOwotCWxvY2FsX2lycV9lbmFibGUoKTsKLQl3aGlsZSAoIW5lZWRfcmVzY2hlZCgpKQotCQljcHVfcmVsYXgoKTsKLQotCXQyID0ga3RpbWVfZ2V0KCk7Ci0JZGlmZiA9IGt0aW1lX3RvX3VzKGt0aW1lX3N1Yih0MiwgdDEpKTsKLQlpZiAoZGlmZiA+IElOVF9NQVgpCi0JCWRpZmYgPSBJTlRfTUFYOwotCi0JcmV0ID0gKGludCkgZGlmZjsKLQlyZXR1cm4gcmV0OwotfQotCi1zdGF0aWMgdm9pZCBwb2xsX2lkbGVfaW5pdChzdHJ1Y3QgY3B1aWRsZV9kZXZpY2UgKmRldikKLXsKLQlzdHJ1Y3QgY3B1aWRsZV9zdGF0ZSAqc3RhdGUgPSAmZGV2LT5zdGF0ZXNbMF07Ci0KLQljcHVpZGxlX3NldF9zdGF0ZWRhdGEoc3RhdGUsIE5VTEwpOwotCi0Jc25wcmludGYoc3RhdGUtPm5hbWUsIENQVUlETEVfTkFNRV9MRU4sICJDMCIpOwotCXNucHJpbnRmKHN0YXRlLT5kZXNjLCBDUFVJRExFX0RFU0NfTEVOLCAiQ1BVSURMRSBDT1JFIFBPTEwgSURMRSIpOwotCXN0YXRlLT5leGl0X2xhdGVuY3kgPSAwOwotCXN0YXRlLT50YXJnZXRfcmVzaWRlbmN5ID0gMDsKLQlzdGF0ZS0+cG93ZXJfdXNhZ2UgPSAtMTsKLQlzdGF0ZS0+ZmxhZ3MgPSBDUFVJRExFX0ZMQUdfUE9MTDsKLQlzdGF0ZS0+ZW50ZXIgPSBwb2xsX2lkbGU7Ci19Ci0jZWxzZQotc3RhdGljIHZvaWQgcG9sbF9pZGxlX2luaXQoc3RydWN0IGNwdWlkbGVfZGV2aWNlICpkZXYpIHt9Ci0jZW5kaWYgLyogQ09ORklHX0FSQ0hfSEFTX0NQVV9SRUxBWCAqLwotCiAvKioKICAqIF9fY3B1aWRsZV9yZWdpc3Rlcl9kZXZpY2UgLSBpbnRlcm5hbCByZWdpc3RlciBmdW5jdGlvbiBjYWxsZWQgYmVmb3JlIHJlZ2lzdGVyCiAgKiBhbmQgZW5hYmxlIHJvdXRpbmVzCkBAIC0yOTIsOCArMzAwLDYgQEAKIAogCWluaXRfY29tcGxldGlvbigmZGV2LT5rb2JqX3VucmVnaXN0ZXIpOwogCi0JcG9sbF9pZGxlX2luaXQoZGV2KTsKLQogCS8qCiAJICogY3B1aWRsZSBkcml2ZXIgc2hvdWxkIHNldCB0aGUgZGV2LT5wb3dlcl9zcGVjaWZpZWQgYml0CiAJICogYmVmb3JlIHJlZ2lzdGVyaW5nIHRoZSBkZXZpY2UgaWYgdGhlIGRyaXZlciBwcm92aWRlcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvS2NvbmZpZyBiL2RyaXZlcnMvZG1hL0tjb25maWcKaW5kZXggZWYxMzg3My4uMWMyODgxNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEvS2NvbmZpZworKysgYi9kcml2ZXJzL2RtYS9LY29uZmlnCkBAIC0yMDAsMTEgKzIwMCwxNiBAQAogCSAgcGxhdGZvcm1fZGF0YSBmb3IgYSBkbWEtcGwzMzAgZGV2aWNlLgogCiBjb25maWcgUENIX0RNQQotCXRyaXN0YXRlICJUb3BjbGlmZiAoSW50ZWwgRUcyMFQpIFBDSCBETUEgc3VwcG9ydCIKKwl0cmlzdGF0ZSAiSW50ZWwgRUcyMFQgUENIIC8gT0tJIFNFTUlDT05EVUNUT1IgTUw3MjEzIElPSCBETUEgc3VwcG9ydCIKIAlkZXBlbmRzIG9uIFBDSSAmJiBYODYKIAlzZWxlY3QgRE1BX0VOR0lORQogCWhlbHAKLQkgIEVuYWJsZSBzdXBwb3J0IGZvciB0aGUgVG9wY2xpZmYgKEludGVsIEVHMjBUKSBQQ0ggRE1BIGVuZ2luZS4KKwkgIEVuYWJsZSBzdXBwb3J0IGZvciBJbnRlbCBFRzIwVCBQQ0ggRE1BIGVuZ2luZS4KKworCSAgVGhpcyBkcml2ZXIgYWxzbyBjYW4gYmUgdXNlZCBmb3IgT0tJIFNFTUlDT05EVUNUT1IgTUw3MjEzIElPSChJbnB1dC8KKwkgIE91dHB1dCBIdWIpIHdoaWNoIGlzIGZvciBJVkkoSW4tVmVoaWNsZSBJbmZvdGFpbm1lbnQpIHVzZS4KKwkgIE1MNzIxMyBpcyBjb21wYW5pb24gY2hpcCBmb3IgSW50ZWwgQXRvbSBFNnh4IHNlcmllcy4KKwkgIE1MNzIxMyBpcyBjb21wbGV0ZWx5IGNvbXBhdGlibGUgZm9yIEludGVsIEVHMjBUIFBDSC4KIAogY29uZmlnIElNWF9TRE1BCiAJdHJpc3RhdGUgImkuTVggU0RNQSBzdXBwb3J0IgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvYW1iYS1wbDA4eC5jIGIvZHJpdmVycy9kbWEvYW1iYS1wbDA4eC5jCmluZGV4IGI2MDVjYzkuLjI5N2Y0OGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hL2FtYmEtcGwwOHguYworKysgYi9kcml2ZXJzL2RtYS9hbWJhLXBsMDh4LmMKQEAgLTE5LDE0ICsxOSwxNCBAQAogICogdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDU5CiAgKiBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgIDAyMTExLTEzMDcsIFVTQS4KICAqCi0gKiBUaGUgZnVsbCBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBpcyBpaW4gdGhpcyBkaXN0cmlidXRpb24gaW4gdGhlCi0gKiBmaWxlIGNhbGxlZCBDT1BZSU5HLgorICogVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4gdGhlIGZpbGUKKyAqIGNhbGxlZCBDT1BZSU5HLgogICoKICAqIERvY3VtZW50YXRpb246IEFSTSBEREkgMDE5NkcgPT0gUEwwODAKLSAqIERvY3VtZW50YXRpb246IEFSTSBEREkgMDIxOEUJPT0gUEwwODEKKyAqIERvY3VtZW50YXRpb246IEFSTSBEREkgMDIxOEUgPT0gUEwwODEKICAqCi0gKiBQTDA4MCAmIFBMMDgxIGJvdGggaGF2ZSAxNiBzZXRzIG9mIERNQSBzaWduYWxzIHRoYXQgY2FuIGJlIHJvdXRlZCB0bwotICogYW55IGNoYW5uZWwuCisgKiBQTDA4MCAmIFBMMDgxIGJvdGggaGF2ZSAxNiBzZXRzIG9mIERNQSBzaWduYWxzIHRoYXQgY2FuIGJlIHJvdXRlZCB0byBhbnkKKyAqIGNoYW5uZWwuCiAgKgogICogVGhlIFBMMDgwIGhhcyA4IGNoYW5uZWxzIGF2YWlsYWJsZSBmb3Igc2ltdWx0YW5lb3VzIHVzZSwgYW5kIHRoZSBQTDA4MQogICogaGFzIG9ubHkgdHdvIGNoYW5uZWxzLiBTbyBvbiB0aGVzZSBETUEgY29udHJvbGxlcnMgdGhlIG51bWJlciBvZiBjaGFubmVscwpAQCAtNTMsNyArNTMsMjMgQEAKICAqCiAgKiBBU1NVTUVTIGRlZmF1bHQgKGxpdHRsZSkgZW5kaWFubmVzcyBmb3IgRE1BIHRyYW5zZmVycwogICoKLSAqIE9ubHkgRE1BQyBmbG93IGNvbnRyb2wgaXMgaW1wbGVtZW50ZWQKKyAqIFRoZSBQTDA4eCBoYXMgdHdvIGZsb3cgY29udHJvbCBzZXR0aW5nczoKKyAqICAtIERNQUMgZmxvdyBjb250cm9sOiB0aGUgdHJhbnNmZXIgc2l6ZSBkZWZpbmVzIHRoZSBudW1iZXIgb2YgdHJhbnNmZXJzCisgKiAgICB3aGljaCBvY2N1ciBmb3IgdGhlIGN1cnJlbnQgTExJIGVudHJ5LCBhbmQgdGhlIERNQUMgcmFpc2VzIFRDIGF0IHRoZQorICogICAgZW5kIG9mIGV2ZXJ5IExMSSBlbnRyeS4gIE9ic2VydmVkIGJlaGF2aW91ciBzaG93cyB0aGUgRE1BQyBsaXN0ZW5pbmcKKyAqICAgIHRvIGJvdGggdGhlIEJSRVEgYW5kIFNSRVEgc2lnbmFscyAoY29udHJhcnkgdG8gZG9jdW1lbnRlZCksCisgKiAgICB0cmFuc2ZlcnJpbmcgZGF0YSBpZiBlaXRoZXIgaXMgYWN0aXZlLiAgVGhlIExCUkVRIGFuZCBMU1JFUSBzaWduYWxzCisgKiAgICBhcmUgaWdub3JlZC4KKyAqCisgKiAgLSBQZXJpcGhlcmFsIGZsb3cgY29udHJvbDogdGhlIHRyYW5zZmVyIHNpemUgaXMgaWdub3JlZCAoYW5kIHNob3VsZCBiZQorICogICAgemVybykuICBUaGUgZGF0YSBpcyB0cmFuc2ZlcnJlZCBmcm9tIHRoZSBjdXJyZW50IExMSSBlbnRyeSwgdW50aWwKKyAqICAgIGFmdGVyIHRoZSBmaW5hbCB0cmFuc2ZlciBzaWduYWxsZWQgYnkgTEJSRVEgb3IgTFNSRVEuICBUaGUgRE1BQworICogICAgd2lsbCB0aGVuIG1vdmUgdG8gdGhlIG5leHQgTExJIGVudHJ5LgorICoKKyAqIE9ubHkgdGhlIGZvcm1lciB3b3JrcyBzYW5lbHkgd2l0aCBzY2F0dGVyIGxpc3RzLCBzbyB3ZSBvbmx5IGltcGxlbWVudAorICogdGhlIERNQUMgZmxvdyBjb250cm9sIG1ldGhvZC4gIEhvd2V2ZXIsIHBlcmlwaGVyYWxzIHdoaWNoIHVzZSB0aGUgTEJSRVEKKyAqIGFuZCBMU1JFUSBzaWduYWxzIChlZywgTU1DSSkgYXJlIHVuYWJsZSB0byB1c2UgdGhpcyBtb2RlLCB3aGljaCB0aHJvdWdoCisgKiB0aGVzZSBoYXJkd2FyZSByZXN0cmljdGlvbnMgcHJldmVudHMgdGhlbSBmcm9tIHVzaW5nIHNjYXR0ZXIgRE1BLgogICoKICAqIEdsb2JhbCBUT0RPOgogICogLSBCcmVhayBvdXQgY29tbW9uIGNvZGUgZnJvbSBhcmNoL2FybS9tYWNoLXMzYzY0eHggYW5kIHNoYXJlCkBAIC02MSw1MCArNzcsMzkgQEAKICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Ci0jaW5jbHVkZSA8bGludXgvcGNpLmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L2RtYXBvb2wuaD4KLSNpbmNsdWRlIDxsaW51eC9hbWJhL2J1cy5oPgogI2luY2x1ZGUgPGxpbnV4L2RtYWVuZ2luZS5oPgorI2luY2x1ZGUgPGxpbnV4L2FtYmEvYnVzLmg+CiAjaW5jbHVkZSA8bGludXgvYW1iYS9wbDA4eC5oPgogI2luY2x1ZGUgPGxpbnV4L2RlYnVnZnMuaD4KICNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgogCiAjaW5jbHVkZSA8YXNtL2hhcmR3YXJlL3BsMDgwLmg+Ci0jaW5jbHVkZSA8YXNtL2RtYS5oPgotI2luY2x1ZGUgPGFzbS9tYWNoL2RtYS5oPgotI2luY2x1ZGUgPGFzbS9hdG9taWMuaD4KLSNpbmNsdWRlIDxhc20vcHJvY2Vzc29yLmg+Ci0jaW5jbHVkZSA8YXNtL2NhY2hlZmx1c2guaD4KIAogI2RlZmluZSBEUklWRVJfTkFNRQkicGwwOHhkbWFjIgogCiAvKioKLSAqIHN0cnVjdCB2ZW5kb3JfZGF0YSAtIHZlbmRvci1zcGVjaWZpYyBjb25maWcgcGFyYW1ldGVycwotICogZm9yIFBMMDh4IGRlcml2YXRlcwotICogQG5hbWU6IHRoZSBuYW1lIG9mIHRoaXMgc3BlY2lmaWMgdmFyaWFudAorICogc3RydWN0IHZlbmRvcl9kYXRhIC0gdmVuZG9yLXNwZWNpZmljIGNvbmZpZyBwYXJhbWV0ZXJzIGZvciBQTDA4eCBkZXJpdmF0aXZlcwogICogQGNoYW5uZWxzOiB0aGUgbnVtYmVyIG9mIGNoYW5uZWxzIGF2YWlsYWJsZSBpbiB0aGlzIHZhcmlhbnQKLSAqIEBkdWFsbWFzdGVyOiB3aGV0aGVyIHRoaXMgdmVyc2lvbiBzdXBwb3J0cyBkdWFsIEFIQiBtYXN0ZXJzCi0gKiBvciBub3QuCisgKiBAZHVhbG1hc3Rlcjogd2hldGhlciB0aGlzIHZlcnNpb24gc3VwcG9ydHMgZHVhbCBBSEIgbWFzdGVycyBvciBub3QuCiAgKi8KIHN0cnVjdCB2ZW5kb3JfZGF0YSB7Ci0JY2hhciAqbmFtZTsKIAl1OCBjaGFubmVsczsKIAlib29sIGR1YWxtYXN0ZXI7CiB9OwogCiAvKgogICogUEwwOFggcHJpdmF0ZSBkYXRhIHN0cnVjdHVyZXMKLSAqIEFuIExMSSBzdHJ1Y3QgLSBzZWUgcGwwOHggVFJNCi0gKiBOb3RlIHRoYXQgbmV4dCB1c2VzIGJpdFswXSBhcyBhIGJ1cyBiaXQsCi0gKiBzdGFydCAmIGVuZCBkbyBub3QgLSB0aGVpciBidXMgYml0IGluZm8KLSAqIGlzIGluIGNjdGwKKyAqIEFuIExMSSBzdHJ1Y3QgLSBzZWUgUEwwOHggVFJNLiAgTm90ZSB0aGF0IG5leHQgdXNlcyBiaXRbMF0gYXMgYSBidXMgYml0LAorICogc3RhcnQgJiBlbmQgZG8gbm90IC0gdGhlaXIgYnVzIGJpdCBpbmZvIGlzIGluIGNjdGwuICBBbHNvIG5vdGUgdGhhdCB0aGVzZQorICogYXJlIGZpeGVkIDMyLWJpdCBxdWFudGl0aWVzLgogICovCi1zdHJ1Y3QgbGxpIHsKLQlkbWFfYWRkcl90IHNyYzsKLQlkbWFfYWRkcl90IGRzdDsKLQlkbWFfYWRkcl90IG5leHQ7CitzdHJ1Y3QgcGwwOHhfbGxpIHsKKwl1MzIgc3JjOworCXUzMiBkc3Q7CisJdTMyIGxsaTsKIAl1MzIgY2N0bDsKIH07CiAKQEAgLTExOSw2ICsxMjQsOCBAQAogICogQHBoeV9jaGFuczogYXJyYXkgb2YgZGF0YSBmb3IgdGhlIHBoeXNpY2FsIGNoYW5uZWxzCiAgKiBAcG9vbDogYSBwb29sIGZvciB0aGUgTExJIGRlc2NyaXB0b3JzCiAgKiBAcG9vbF9jdHI6IGNvdW50ZXIgb2YgTExJcyBpbiB0aGUgcG9vbAorICogQGxsaV9idXNlczogYml0bWFzayB0byBvciBpbiB0byBMTEkgcG9pbnRlciBzZWxlY3RpbmcgQUhCIHBvcnQgZm9yIExMSSBmZXRjaGVzCisgKiBAbWVtX2J1c2VzOiBzZXQgdG8gaW5kaWNhdGUgbWVtb3J5IHRyYW5zZmVycyBvbiBBSEIyLgogICogQGxvY2s6IGEgc3BpbmxvY2sgZm9yIHRoaXMgc3RydWN0CiAgKi8KIHN0cnVjdCBwbDA4eF9kcml2ZXJfZGF0YSB7CkBAIC0xMjYsMTEgKzEzMywxMyBAQAogCXN0cnVjdCBkbWFfZGV2aWNlIG1lbWNweTsKIAl2b2lkIF9faW9tZW0gKmJhc2U7CiAJc3RydWN0IGFtYmFfZGV2aWNlICphZGV2OwotCXN0cnVjdCB2ZW5kb3JfZGF0YSAqdmQ7CisJY29uc3Qgc3RydWN0IHZlbmRvcl9kYXRhICp2ZDsKIAlzdHJ1Y3QgcGwwOHhfcGxhdGZvcm1fZGF0YSAqcGQ7CiAJc3RydWN0IHBsMDh4X3BoeV9jaGFuICpwaHlfY2hhbnM7CiAJc3RydWN0IGRtYV9wb29sICpwb29sOwogCWludCBwb29sX2N0cjsKKwl1OCBsbGlfYnVzZXM7CisJdTggbWVtX2J1c2VzOwogCXNwaW5sb2NrX3QgbG9jazsKIH07CiAKQEAgLTE1Miw5ICsxNjEsOSBAQAogLyogU2l6ZSAoYnl0ZXMpIG9mIGVhY2ggTExJIGJ1ZmZlciBhbGxvY2F0ZWQgZm9yIG9uZSB0cmFuc2ZlciAqLwogIyBkZWZpbmUgUEwwOFhfTExJX1RTRlJfU0laRQkweDIwMDAKIAotLyogTWF4aW1pbXVtIHRpbWVzIHdlIGNhbGwgZG1hX3Bvb2xfYWxsb2Mgb24gdGhpcyBwb29sIHdpdGhvdXQgZnJlZWluZyAqLworLyogTWF4aW11bSB0aW1lcyB3ZSBjYWxsIGRtYV9wb29sX2FsbG9jIG9uIHRoaXMgcG9vbCB3aXRob3V0IGZyZWVpbmcgKi8KICNkZWZpbmUgUEwwOFhfTUFYX0FMTE9DUwkweDQwCi0jZGVmaW5lIE1BWF9OVU1fVFNGUl9MTElTCShQTDA4WF9MTElfVFNGUl9TSVpFL3NpemVvZihzdHJ1Y3QgbGxpKSkKKyNkZWZpbmUgTUFYX05VTV9UU0ZSX0xMSVMJKFBMMDhYX0xMSV9UU0ZSX1NJWkUvc2l6ZW9mKHN0cnVjdCBwbDA4eF9sbGkpKQogI2RlZmluZSBQTDA4WF9BTElHTgkJOAogCiBzdGF0aWMgaW5saW5lIHN0cnVjdCBwbDA4eF9kbWFfY2hhbiAqdG9fcGwwOHhfY2hhbihzdHJ1Y3QgZG1hX2NoYW4gKmNoYW4pCkBAIC0xNjIsNiArMTcxLDExIEBACiAJcmV0dXJuIGNvbnRhaW5lcl9vZihjaGFuLCBzdHJ1Y3QgcGwwOHhfZG1hX2NoYW4sIGNoYW4pOwogfQogCitzdGF0aWMgaW5saW5lIHN0cnVjdCBwbDA4eF90eGQgKnRvX3BsMDh4X3R4ZChzdHJ1Y3QgZG1hX2FzeW5jX3R4X2Rlc2NyaXB0b3IgKnR4KQoreworCXJldHVybiBjb250YWluZXJfb2YodHgsIHN0cnVjdCBwbDA4eF90eGQsIHR4KTsKK30KKwogLyoKICAqIFBoeXNpY2FsIGNoYW5uZWwgaGFuZGxpbmcKICAqLwpAQCAtMTc3LDg4ICsxOTEsNDcgQEAKIAogLyoKICAqIFNldCB0aGUgaW5pdGlhbCBETUEgcmVnaXN0ZXIgdmFsdWVzIGkuZS4gdGhvc2UgZm9yIHRoZSBmaXJzdCBMTEkKLSAqIFRoZSBuZXh0IGxsaSBwb2ludGVyIGFuZCB0aGUgY29uZmlndXJhdGlvbiBpbnRlcnJ1cHQgYml0IGhhdmUKLSAqIGJlZW4gc2V0IHdoZW4gdGhlIExMSXMgd2VyZSBjb25zdHJ1Y3RlZAorICogVGhlIG5leHQgTExJIHBvaW50ZXIgYW5kIHRoZSBjb25maWd1cmF0aW9uIGludGVycnVwdCBiaXQgaGF2ZQorICogYmVlbiBzZXQgd2hlbiB0aGUgTExJcyB3ZXJlIGNvbnN0cnVjdGVkLiAgUG9rZSB0aGVtIGludG8gdGhlIGhhcmR3YXJlCisgKiBhbmQgc3RhcnQgdGhlIHRyYW5zZmVyLgogICovCi1zdGF0aWMgdm9pZCBwbDA4eF9zZXRfY3JlZ3Moc3RydWN0IHBsMDh4X2RyaXZlcl9kYXRhICpwbDA4eCwKLQkJCSAgICBzdHJ1Y3QgcGwwOHhfcGh5X2NoYW4gKmNoKQorc3RhdGljIHZvaWQgcGwwOHhfc3RhcnRfdHhkKHN0cnVjdCBwbDA4eF9kbWFfY2hhbiAqcGxjaGFuLAorCXN0cnVjdCBwbDA4eF90eGQgKnR4ZCkKIHsKLQkvKiBXYWl0IGZvciBjaGFubmVsIGluYWN0aXZlICovCi0Jd2hpbGUgKHBsMDh4X3BoeV9jaGFubmVsX2J1c3koY2gpKQotCQk7Ci0KLQlkZXZfdmRiZygmcGwwOHgtPmFkZXYtPmRldiwKLQkJIldSSVRFIGNoYW5uZWwgJWQ6IGNzcmM9JTA4eCwgY2RzdD0lMDh4LCAiCi0JCSAiY2N0bD0lMDh4LCBjbGxpPSUwOHgsIGNjZmc9JTA4eFxuIiwKLQkJY2gtPmlkLAotCQljaC0+Y3NyYywKLQkJY2gtPmNkc3QsCi0JCWNoLT5jY3RsLAotCQljaC0+Y2xsaSwKLQkJY2gtPmNjZmcpOwotCi0Jd3JpdGVsKGNoLT5jc3JjLCBjaC0+YmFzZSArIFBMMDgwX0NIX1NSQ19BRERSKTsKLQl3cml0ZWwoY2gtPmNkc3QsIGNoLT5iYXNlICsgUEwwODBfQ0hfRFNUX0FERFIpOwotCXdyaXRlbChjaC0+Y2xsaSwgY2gtPmJhc2UgKyBQTDA4MF9DSF9MTEkpOwotCXdyaXRlbChjaC0+Y2N0bCwgY2gtPmJhc2UgKyBQTDA4MF9DSF9DT05UUk9MKTsKLQl3cml0ZWwoY2gtPmNjZmcsIGNoLT5iYXNlICsgUEwwODBfQ0hfQ09ORklHKTsKLX0KLQotc3RhdGljIGlubGluZSB2b2lkIHBsMDh4X2NvbmZpZ19waHljaGFuX2Zvcl90eGQoc3RydWN0IHBsMDh4X2RtYV9jaGFuICpwbGNoYW4pCi17Ci0Jc3RydWN0IHBsMDh4X2NoYW5uZWxfZGF0YSAqY2QgPSBwbGNoYW4tPmNkOworCXN0cnVjdCBwbDA4eF9kcml2ZXJfZGF0YSAqcGwwOHggPSBwbGNoYW4tPmhvc3Q7CiAJc3RydWN0IHBsMDh4X3BoeV9jaGFuICpwaHljaGFuID0gcGxjaGFuLT5waHljaGFuOwotCXN0cnVjdCBwbDA4eF90eGQgKnR4ZCA9IHBsY2hhbi0+YXQ7Ci0KLQkvKiBDb3B5IHRoZSBiYXNpYyBjb250cm9sIHJlZ2lzdGVyIGNhbGN1bGF0ZWQgYXQgdHJhbnNmZXIgY29uZmlnICovCi0JcGh5Y2hhbi0+Y3NyYyA9IHR4ZC0+Y3NyYzsKLQlwaHljaGFuLT5jZHN0ID0gdHhkLT5jZHN0OwotCXBoeWNoYW4tPmNsbGkgPSB0eGQtPmNsbGk7Ci0JcGh5Y2hhbi0+Y2N0bCA9IHR4ZC0+Y2N0bDsKLQotCS8qIEFzc2lnbiB0aGUgc2lnbmFsIHRvIHRoZSBwcm9wZXIgY29udHJvbCByZWdpc3RlcnMgKi8KLQlwaHljaGFuLT5jY2ZnID0gY2QtPmNjZmc7Ci0JcGh5Y2hhbi0+Y2NmZyAmPSB+UEwwODBfQ09ORklHX1NSQ19TRUxfTUFTSzsKLQlwaHljaGFuLT5jY2ZnICY9IH5QTDA4MF9DT05GSUdfRFNUX1NFTF9NQVNLOwotCS8qIElmIGl0IHdhc24ndCBzZXQgZnJvbSBBTUJBLCBpZ25vcmUgaXQgKi8KLQlpZiAodHhkLT5kaXJlY3Rpb24gPT0gRE1BX1RPX0RFVklDRSkKLQkJLyogU2VsZWN0IHNpZ25hbCBhcyBkZXN0aW5hdGlvbiAqLwotCQlwaHljaGFuLT5jY2ZnIHw9Ci0JCQkocGh5Y2hhbi0+c2lnbmFsIDw8IFBMMDgwX0NPTkZJR19EU1RfU0VMX1NISUZUKTsKLQllbHNlIGlmICh0eGQtPmRpcmVjdGlvbiA9PSBETUFfRlJPTV9ERVZJQ0UpCi0JCS8qIFNlbGVjdCBzaWduYWwgYXMgc291cmNlICovCi0JCXBoeWNoYW4tPmNjZmcgfD0KLQkJCShwaHljaGFuLT5zaWduYWwgPDwgUEwwODBfQ09ORklHX1NSQ19TRUxfU0hJRlQpOwotCS8qIEFsd2F5cyBlbmFibGUgZXJyb3IgaW50ZXJydXB0cyAqLwotCXBoeWNoYW4tPmNjZmcgfD0gUEwwODBfQ09ORklHX0VSUl9JUlFfTUFTSzsKLQkvKiBBbHdheXMgZW5hYmxlIHRlcm1pbmFsIGludGVycnVwdHMgKi8KLQlwaHljaGFuLT5jY2ZnIHw9IFBMMDgwX0NPTkZJR19UQ19JUlFfTUFTSzsKLX0KLQotLyoKLSAqIEVuYWJsZSB0aGUgRE1BIGNoYW5uZWwKLSAqIEFzc3VtZXMgYWxsIG90aGVyIGNvbmZpZ3VyYXRpb24gYml0cyBoYXZlIGJlZW4gc2V0Ci0gKiBhcyBkZXNpcmVkIGJlZm9yZSB0aGlzIGNvZGUgaXMgY2FsbGVkCi0gKi8KLXN0YXRpYyB2b2lkIHBsMDh4X2VuYWJsZV9waHlfY2hhbihzdHJ1Y3QgcGwwOHhfZHJpdmVyX2RhdGEgKnBsMDh4LAotCQkJCSAgc3RydWN0IHBsMDh4X3BoeV9jaGFuICpjaCkKLXsKKwlzdHJ1Y3QgcGwwOHhfbGxpICpsbGkgPSAmdHhkLT5sbGlzX3ZhWzBdOwogCXUzMiB2YWw7CiAKLQkvKgotCSAqIERvIG5vdCBhY2Nlc3MgY29uZmlnIHJlZ2lzdGVyIHVudGlsIGNoYW5uZWwgc2hvd3MgYXMgZGlzYWJsZWQKLQkgKi8KLQl3aGlsZSAocmVhZGwocGwwOHgtPmJhc2UgKyBQTDA4MF9FTl9DSEFOKSAmICgxIDw8IGNoLT5pZCkpCi0JCTsKKwlwbGNoYW4tPmF0ID0gdHhkOwogCi0JLyoKLQkgKiBEbyBub3QgYWNjZXNzIGNvbmZpZyByZWdpc3RlciB1bnRpbCBjaGFubmVsIHNob3dzIGFzIGluYWN0aXZlCi0JICovCi0JdmFsID0gcmVhZGwoY2gtPmJhc2UgKyBQTDA4MF9DSF9DT05GSUcpOworCS8qIFdhaXQgZm9yIGNoYW5uZWwgaW5hY3RpdmUgKi8KKwl3aGlsZSAocGwwOHhfcGh5X2NoYW5uZWxfYnVzeShwaHljaGFuKSkKKwkJY3B1X3JlbGF4KCk7CisKKwlkZXZfdmRiZygmcGwwOHgtPmFkZXYtPmRldiwKKwkJIldSSVRFIGNoYW5uZWwgJWQ6IGNzcmM9MHglMDh4LCBjZHN0PTB4JTA4eCwgIgorCQkiY2xsaT0weCUwOHgsIGNjdGw9MHglMDh4LCBjY2ZnPTB4JTA4eFxuIiwKKwkJcGh5Y2hhbi0+aWQsIGxsaS0+c3JjLCBsbGktPmRzdCwgbGxpLT5sbGksIGxsaS0+Y2N0bCwKKwkJdHhkLT5jY2ZnKTsKKworCXdyaXRlbChsbGktPnNyYywgcGh5Y2hhbi0+YmFzZSArIFBMMDgwX0NIX1NSQ19BRERSKTsKKwl3cml0ZWwobGxpLT5kc3QsIHBoeWNoYW4tPmJhc2UgKyBQTDA4MF9DSF9EU1RfQUREUik7CisJd3JpdGVsKGxsaS0+bGxpLCBwaHljaGFuLT5iYXNlICsgUEwwODBfQ0hfTExJKTsKKwl3cml0ZWwobGxpLT5jY3RsLCBwaHljaGFuLT5iYXNlICsgUEwwODBfQ0hfQ09OVFJPTCk7CisJd3JpdGVsKHR4ZC0+Y2NmZywgcGh5Y2hhbi0+YmFzZSArIFBMMDgwX0NIX0NPTkZJRyk7CisKKwkvKiBFbmFibGUgdGhlIERNQSBjaGFubmVsICovCisJLyogRG8gbm90IGFjY2VzcyBjb25maWcgcmVnaXN0ZXIgdW50aWwgY2hhbm5lbCBzaG93cyBhcyBkaXNhYmxlZCAqLworCXdoaWxlIChyZWFkbChwbDA4eC0+YmFzZSArIFBMMDgwX0VOX0NIQU4pICYgKDEgPDwgcGh5Y2hhbi0+aWQpKQorCQljcHVfcmVsYXgoKTsKKworCS8qIERvIG5vdCBhY2Nlc3MgY29uZmlnIHJlZ2lzdGVyIHVudGlsIGNoYW5uZWwgc2hvd3MgYXMgaW5hY3RpdmUgKi8KKwl2YWwgPSByZWFkbChwaHljaGFuLT5iYXNlICsgUEwwODBfQ0hfQ09ORklHKTsKIAl3aGlsZSAoKHZhbCAmIFBMMDgwX0NPTkZJR19BQ1RJVkUpIHx8ICh2YWwgJiBQTDA4MF9DT05GSUdfRU5BQkxFKSkKLQkJdmFsID0gcmVhZGwoY2gtPmJhc2UgKyBQTDA4MF9DSF9DT05GSUcpOworCQl2YWwgPSByZWFkbChwaHljaGFuLT5iYXNlICsgUEwwODBfQ0hfQ09ORklHKTsKIAotCXdyaXRlbCh2YWwgfCBQTDA4MF9DT05GSUdfRU5BQkxFLCBjaC0+YmFzZSArIFBMMDgwX0NIX0NPTkZJRyk7CisJd3JpdGVsKHZhbCB8IFBMMDgwX0NPTkZJR19FTkFCTEUsIHBoeWNoYW4tPmJhc2UgKyBQTDA4MF9DSF9DT05GSUcpOwogfQogCiAvKgpAQCAtMjY2LDEwICsyMzksOCBAQAogICoKICAqIERpc2FibGluZyBpbmRpdmlkdWFsIGNoYW5uZWxzIGNvdWxkIGxvc2UgZGF0YS4KICAqCi0gKiBEaXNhYmxlIHRoZSBwZXJpcGhlcmFsIERNQSBhZnRlciBkaXNhYmxpbmcgdGhlIERNQUMKLSAqIGluIG9yZGVyIHRvIGFsbG93IHRoZSBETUFDIEZJRk8gdG8gZHJhaW4sIGFuZAotICogaGVuY2UgYWxsb3cgdGhlIGNoYW5uZWwgdG8gc2hvdyBpbmFjdGl2ZQotICoKKyAqIERpc2FibGUgdGhlIHBlcmlwaGVyYWwgRE1BIGFmdGVyIGRpc2FibGluZyB0aGUgRE1BQyBpbiBvcmRlciB0byBhbGxvdworICogdGhlIERNQUMgRklGTyB0byBkcmFpbiwgYW5kIGhlbmNlIGFsbG93IHRoZSBjaGFubmVsIHRvIHNob3cgaW5hY3RpdmUKICAqLwogc3RhdGljIHZvaWQgcGwwOHhfcGF1c2VfcGh5X2NoYW4oc3RydWN0IHBsMDh4X3BoeV9jaGFuICpjaCkKIHsKQEAgLTI4Miw3ICsyNTMsNyBAQAogCiAJLyogV2FpdCBmb3IgY2hhbm5lbCBpbmFjdGl2ZSAqLwogCXdoaWxlIChwbDA4eF9waHlfY2hhbm5lbF9idXN5KGNoKSkKLQkJOworCQljcHVfcmVsYXgoKTsKIH0KIAogc3RhdGljIHZvaWQgcGwwOHhfcmVzdW1lX3BoeV9jaGFuKHN0cnVjdCBwbDA4eF9waHlfY2hhbiAqY2gpCkBAIC0zMzMsNTQgKzMwNCw1NiBAQAogc3RhdGljIHUzMiBwbDA4eF9nZXRieXRlc19jaGFuKHN0cnVjdCBwbDA4eF9kbWFfY2hhbiAqcGxjaGFuKQogewogCXN0cnVjdCBwbDA4eF9waHlfY2hhbiAqY2g7Ci0Jc3RydWN0IHBsMDh4X3R4ZCAqdHhkaSA9IE5VTEw7CiAJc3RydWN0IHBsMDh4X3R4ZCAqdHhkOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0JdTMyIGJ5dGVzID0gMDsKKwlzaXplX3QgYnl0ZXMgPSAwOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJnBsY2hhbi0+bG9jaywgZmxhZ3MpOwotCiAJY2ggPSBwbGNoYW4tPnBoeWNoYW47CiAJdHhkID0gcGxjaGFuLT5hdDsKIAogCS8qCi0JICogTmV4dCBmb2xsb3cgdGhlIExMSXMgdG8gZ2V0IHRoZSBudW1iZXIgb2YgcGVuZGluZyBieXRlcyBpbiB0aGUKLQkgKiBjdXJyZW50bHkgYWN0aXZlIHRyYW5zYWN0aW9uLgorCSAqIEZvbGxvdyB0aGUgTExJcyB0byBnZXQgdGhlIG51bWJlciBvZiByZW1haW5pbmcKKwkgKiBieXRlcyBpbiB0aGUgY3VycmVudGx5IGFjdGl2ZSB0cmFuc2FjdGlvbi4KIAkgKi8KIAlpZiAoY2ggJiYgdHhkKSB7Ci0JCXN0cnVjdCBsbGkgKmxsaXNfdmEgPSB0eGQtPmxsaXNfdmE7Ci0JCXN0cnVjdCBsbGkgKmxsaXNfYnVzID0gKHN0cnVjdCBsbGkgKikgdHhkLT5sbGlzX2J1czsKLQkJdTMyIGNsbGkgPSByZWFkbChjaC0+YmFzZSArIFBMMDgwX0NIX0xMSSk7CisJCXUzMiBjbGxpID0gcmVhZGwoY2gtPmJhc2UgKyBQTDA4MF9DSF9MTEkpICYgflBMMDgwX0xMSV9MTV9BSEIyOwogCi0JCS8qIEZpcnN0IGdldCB0aGUgYnl0ZXMgaW4gdGhlIGN1cnJlbnQgYWN0aXZlIExMSSAqLworCQkvKiBGaXJzdCBnZXQgdGhlIHJlbWFpbmluZyBieXRlcyBpbiB0aGUgYWN0aXZlIHRyYW5zZmVyICovCiAJCWJ5dGVzID0gZ2V0X2J5dGVzX2luX2NjdGwocmVhZGwoY2gtPmJhc2UgKyBQTDA4MF9DSF9DT05UUk9MKSk7CiAKIAkJaWYgKGNsbGkpIHsKLQkJCWludCBpID0gMDsKKwkJCXN0cnVjdCBwbDA4eF9sbGkgKmxsaXNfdmEgPSB0eGQtPmxsaXNfdmE7CisJCQlkbWFfYWRkcl90IGxsaXNfYnVzID0gdHhkLT5sbGlzX2J1czsKKwkJCWludCBpbmRleDsKIAotCQkJLyogRm9yd2FyZCB0byB0aGUgTExJIHBvaW50ZWQgdG8gYnkgY2xsaSAqLwotCQkJd2hpbGUgKChjbGxpICE9ICh1MzIpICYobGxpc19idXNbaV0pKSAmJgotCQkJICAgICAgIChpIDwgTUFYX05VTV9UU0ZSX0xMSVMpKQotCQkJCWkrKzsKKwkJCUJVR19PTihjbGxpIDwgbGxpc19idXMgfHwgY2xsaSA+PSBsbGlzX2J1cyArCisJCQkJc2l6ZW9mKHN0cnVjdCBwbDA4eF9sbGkpICogTUFYX05VTV9UU0ZSX0xMSVMpOwogCi0JCQl3aGlsZSAoY2xsaSkgewotCQkJCWJ5dGVzICs9IGdldF9ieXRlc19pbl9jY3RsKGxsaXNfdmFbaV0uY2N0bCk7CisJCQkvKgorCQkJICogTG9jYXRlIHRoZSBuZXh0IExMSSAtIGFzIHRoaXMgaXMgYW4gYXJyYXksCisJCQkgKiBpdCdzIHNpbXBsZSBtYXRocyB0byBmaW5kLgorCQkJICovCisJCQlpbmRleCA9IChjbGxpIC0gbGxpc19idXMpIC8gc2l6ZW9mKHN0cnVjdCBwbDA4eF9sbGkpOworCisJCQlmb3IgKDsgaW5kZXggPCBNQVhfTlVNX1RTRlJfTExJUzsgaW5kZXgrKykgeworCQkJCWJ5dGVzICs9IGdldF9ieXRlc19pbl9jY3RsKGxsaXNfdmFbaW5kZXhdLmNjdGwpOworCiAJCQkJLyoKLQkJCQkgKiBBIGNsbGkgb2YgMHgwMDAwMDAwMCB3aWxsIHRlcm1pbmF0ZSB0aGUKLQkJCQkgKiBMTEkgbGlzdAorCQkJCSAqIEEgTExJIHBvaW50ZXIgb2YgMCB0ZXJtaW5hdGVzIHRoZSBMTEkgbGlzdAogCQkJCSAqLwotCQkJCWNsbGkgPSBsbGlzX3ZhW2ldLm5leHQ7Ci0JCQkJaSsrOworCQkJCWlmICghbGxpc192YVtpbmRleF0ubGxpKQorCQkJCQlicmVhazsKIAkJCX0KIAkJfQogCX0KIAogCS8qIFN1bSB1cCBhbGwgcXVldWVkIHRyYW5zYWN0aW9ucyAqLwotCWlmICghbGlzdF9lbXB0eSgmcGxjaGFuLT5kZXNjX2xpc3QpKSB7Ci0JCWxpc3RfZm9yX2VhY2hfZW50cnkodHhkaSwgJnBsY2hhbi0+ZGVzY19saXN0LCBub2RlKSB7CisJaWYgKCFsaXN0X2VtcHR5KCZwbGNoYW4tPnBlbmRfbGlzdCkpIHsKKwkJc3RydWN0IHBsMDh4X3R4ZCAqdHhkaTsKKwkJbGlzdF9mb3JfZWFjaF9lbnRyeSh0eGRpLCAmcGxjaGFuLT5wZW5kX2xpc3QsIG5vZGUpIHsKIAkJCWJ5dGVzICs9IHR4ZGktPmxlbjsKIAkJfQotCiAJfQogCiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcGxjaGFuLT5sb2NrLCBmbGFncyk7CkBAIC0zOTAsNiArMzYzLDEwIEBACiAKIC8qCiAgKiBBbGxvY2F0ZSBhIHBoeXNpY2FsIGNoYW5uZWwgZm9yIGEgdmlydHVhbCBjaGFubmVsCisgKgorICogVHJ5IHRvIGxvY2F0ZSBhIHBoeXNpY2FsIGNoYW5uZWwgdG8gYmUgdXNlZCBmb3IgdGhpcyB0cmFuc2Zlci4gSWYgYWxsCisgKiBhcmUgdGFrZW4gcmV0dXJuIE5VTEwgYW5kIHRoZSByZXF1ZXN0ZXIgd2lsbCBoYXZlIHRvIGNvcGUgYnkgdXNpbmcKKyAqIHNvbWUgZmFsbGJhY2sgUElPIG1vZGUgb3IgcmV0cnlpbmcgbGF0ZXIuCiAgKi8KIHN0YXRpYyBzdHJ1Y3QgcGwwOHhfcGh5X2NoYW4gKgogcGwwOHhfZ2V0X3BoeV9jaGFubmVsKHN0cnVjdCBwbDA4eF9kcml2ZXJfZGF0YSAqcGwwOHgsCkBAIC0zOTksMTIgKzM3Niw2IEBACiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAlpbnQgaTsKIAotCS8qCi0JICogVHJ5IHRvIGxvY2F0ZSBhIHBoeXNpY2FsIGNoYW5uZWwgdG8gYmUgdXNlZCBmb3IKLQkgKiB0aGlzIHRyYW5zZmVyLiBJZiBhbGwgYXJlIHRha2VuIHJldHVybiBOVUxMIGFuZAotCSAqIHRoZSByZXF1ZXN0ZXIgd2lsbCBoYXZlIHRvIGNvcGUgYnkgdXNpbmcgc29tZSBmYWxsYmFjawotCSAqIFBJTyBtb2RlIG9yIHJldHJ5aW5nIGxhdGVyLgotCSAqLwogCWZvciAoaSA9IDA7IGkgPCBwbDA4eC0+dmQtPmNoYW5uZWxzOyBpKyspIHsKIAkJY2ggPSAmcGwwOHgtPnBoeV9jaGFuc1tpXTsKIApAQCAtNDY1LDExICs0MzYsMTEgQEAKIH0KIAogc3RhdGljIGlubGluZSB1MzIgcGwwOHhfY2N0bF9iaXRzKHUzMiBjY3RsLCB1OCBzcmN3aWR0aCwgdTggZHN0d2lkdGgsCi0JCQkJICB1MzIgdHNpemUpCisJCQkJICBzaXplX3QgdHNpemUpCiB7CiAJdTMyIHJldGJpdHMgPSBjY3RsOwogCi0JLyogUmVtb3ZlIGFsbCBzcmMsIGRzdCBhbmQgdHJhbnNmZXJzaXplIGJpdHMgKi8KKwkvKiBSZW1vdmUgYWxsIHNyYywgZHN0IGFuZCB0cmFuc2ZlciBzaXplIGJpdHMgKi8KIAlyZXRiaXRzICY9IH5QTDA4MF9DT05UUk9MX0RXSURUSF9NQVNLOwogCXJldGJpdHMgJj0gflBMMDgwX0NPTlRST0xfU1dJRFRIX01BU0s7CiAJcmV0Yml0cyAmPSB+UEwwODBfQ09OVFJPTF9UUkFOU0ZFUl9TSVpFX01BU0s7CkBAIC01MDksOTUgKzQ4MCw4NyBAQAogCXJldHVybiByZXRiaXRzOwogfQogCitzdHJ1Y3QgcGwwOHhfbGxpX2J1aWxkX2RhdGEgeworCXN0cnVjdCBwbDA4eF90eGQgKnR4ZDsKKwlzdHJ1Y3QgcGwwOHhfZHJpdmVyX2RhdGEgKnBsMDh4OworCXN0cnVjdCBwbDA4eF9idXNfZGF0YSBzcmNidXM7CisJc3RydWN0IHBsMDh4X2J1c19kYXRhIGRzdGJ1czsKKwlzaXplX3QgcmVtYWluZGVyOworfTsKKwogLyoKLSAqIEF1dG9zZWxlY3QgYSBtYXN0ZXIgYnVzIHRvIHVzZSBmb3IgdGhlIHRyYW5zZmVyCi0gKiB0aGlzIHByZWZlcnMgdGhlIGRlc3RpbmF0aW9uIGJ1cyBpZiBib3RoIGF2YWlsYWJsZQotICogaWYgZml4ZWQgYWRkcmVzcyBvbiBvbmUgYnVzIHRoZSBvdGhlciB3aWxsIGJlIGNob3NlbgorICogQXV0b3NlbGVjdCBhIG1hc3RlciBidXMgdG8gdXNlIGZvciB0aGUgdHJhbnNmZXIgdGhpcyBwcmVmZXJzIHRoZQorICogZGVzdGluYXRpb24gYnVzIGlmIGJvdGggYXZhaWxhYmxlIGlmIGZpeGVkIGFkZHJlc3Mgb24gb25lIGJ1cyB0aGUKKyAqIG90aGVyIHdpbGwgYmUgY2hvc2VuCiAgKi8KLXZvaWQgcGwwOHhfY2hvb3NlX21hc3Rlcl9idXMoc3RydWN0IHBsMDh4X2J1c19kYXRhICpzcmNfYnVzLAotCXN0cnVjdCBwbDA4eF9idXNfZGF0YSAqZHN0X2J1cywgc3RydWN0IHBsMDh4X2J1c19kYXRhICoqbWJ1cywKLQlzdHJ1Y3QgcGwwOHhfYnVzX2RhdGEgKipzYnVzLCB1MzIgY2N0bCkKK3N0YXRpYyB2b2lkIHBsMDh4X2Nob29zZV9tYXN0ZXJfYnVzKHN0cnVjdCBwbDA4eF9sbGlfYnVpbGRfZGF0YSAqYmQsCisJc3RydWN0IHBsMDh4X2J1c19kYXRhICoqbWJ1cywgc3RydWN0IHBsMDh4X2J1c19kYXRhICoqc2J1cywgdTMyIGNjdGwpCiB7CiAJaWYgKCEoY2N0bCAmIFBMMDgwX0NPTlRST0xfRFNUX0lOQ1IpKSB7Ci0JCSptYnVzID0gc3JjX2J1czsKLQkJKnNidXMgPSBkc3RfYnVzOworCQkqbWJ1cyA9ICZiZC0+c3JjYnVzOworCQkqc2J1cyA9ICZiZC0+ZHN0YnVzOwogCX0gZWxzZSBpZiAoIShjY3RsICYgUEwwODBfQ09OVFJPTF9TUkNfSU5DUikpIHsKLQkJKm1idXMgPSBkc3RfYnVzOwotCQkqc2J1cyA9IHNyY19idXM7CisJCSptYnVzID0gJmJkLT5kc3RidXM7CisJCSpzYnVzID0gJmJkLT5zcmNidXM7CiAJfSBlbHNlIHsKLQkJaWYgKGRzdF9idXMtPmJ1c3dpZHRoID09IDQpIHsKLQkJCSptYnVzID0gZHN0X2J1czsKLQkJCSpzYnVzID0gc3JjX2J1czsKLQkJfSBlbHNlIGlmIChzcmNfYnVzLT5idXN3aWR0aCA9PSA0KSB7Ci0JCQkqbWJ1cyA9IHNyY19idXM7Ci0JCQkqc2J1cyA9IGRzdF9idXM7Ci0JCX0gZWxzZSBpZiAoZHN0X2J1cy0+YnVzd2lkdGggPT0gMikgewotCQkJKm1idXMgPSBkc3RfYnVzOwotCQkJKnNidXMgPSBzcmNfYnVzOwotCQl9IGVsc2UgaWYgKHNyY19idXMtPmJ1c3dpZHRoID09IDIpIHsKLQkJCSptYnVzID0gc3JjX2J1czsKLQkJCSpzYnVzID0gZHN0X2J1czsKKwkJaWYgKGJkLT5kc3RidXMuYnVzd2lkdGggPT0gNCkgeworCQkJKm1idXMgPSAmYmQtPmRzdGJ1czsKKwkJCSpzYnVzID0gJmJkLT5zcmNidXM7CisJCX0gZWxzZSBpZiAoYmQtPnNyY2J1cy5idXN3aWR0aCA9PSA0KSB7CisJCQkqbWJ1cyA9ICZiZC0+c3JjYnVzOworCQkJKnNidXMgPSAmYmQtPmRzdGJ1czsKKwkJfSBlbHNlIGlmIChiZC0+ZHN0YnVzLmJ1c3dpZHRoID09IDIpIHsKKwkJCSptYnVzID0gJmJkLT5kc3RidXM7CisJCQkqc2J1cyA9ICZiZC0+c3JjYnVzOworCQl9IGVsc2UgaWYgKGJkLT5zcmNidXMuYnVzd2lkdGggPT0gMikgeworCQkJKm1idXMgPSAmYmQtPnNyY2J1czsKKwkJCSpzYnVzID0gJmJkLT5kc3RidXM7CiAJCX0gZWxzZSB7Ci0JCQkvKiBzcmNfYnVzLT5idXN3aWR0aCA9PSAxICovCi0JCQkqbWJ1cyA9IGRzdF9idXM7Ci0JCQkqc2J1cyA9IHNyY19idXM7CisJCQkvKiBiZC0+c3JjYnVzLmJ1c3dpZHRoID09IDEgKi8KKwkJCSptYnVzID0gJmJkLT5kc3RidXM7CisJCQkqc2J1cyA9ICZiZC0+c3JjYnVzOwogCQl9CiAJfQogfQogCiAvKgotICogRmlsbHMgaW4gb25lIExMSSBmb3IgYSBjZXJ0YWluIHRyYW5zZmVyIGRlc2NyaXB0b3IKLSAqIGFuZCBhZHZhbmNlIHRoZSBjb3VudGVyCisgKiBGaWxscyBpbiBvbmUgTExJIGZvciBhIGNlcnRhaW4gdHJhbnNmZXIgZGVzY3JpcHRvciBhbmQgYWR2YW5jZSB0aGUgY291bnRlcgogICovCi1pbnQgcGwwOHhfZmlsbF9sbGlfZm9yX2Rlc2Moc3RydWN0IHBsMDh4X2RyaXZlcl9kYXRhICpwbDA4eCwKLQkJCSAgICBzdHJ1Y3QgcGwwOHhfdHhkICp0eGQsIGludCBudW1fbGxpcywgaW50IGxlbiwKLQkJCSAgICB1MzIgY2N0bCwgdTMyICpyZW1haW5kZXIpCitzdGF0aWMgdm9pZCBwbDA4eF9maWxsX2xsaV9mb3JfZGVzYyhzdHJ1Y3QgcGwwOHhfbGxpX2J1aWxkX2RhdGEgKmJkLAorCWludCBudW1fbGxpcywgaW50IGxlbiwgdTMyIGNjdGwpCiB7Ci0Jc3RydWN0IGxsaSAqbGxpc192YSA9IHR4ZC0+bGxpc192YTsKLQlzdHJ1Y3QgbGxpICpsbGlzX2J1cyA9IChzdHJ1Y3QgbGxpICopIHR4ZC0+bGxpc19idXM7CisJc3RydWN0IHBsMDh4X2xsaSAqbGxpc192YSA9IGJkLT50eGQtPmxsaXNfdmE7CisJZG1hX2FkZHJfdCBsbGlzX2J1cyA9IGJkLT50eGQtPmxsaXNfYnVzOwogCiAJQlVHX09OKG51bV9sbGlzID49IE1BWF9OVU1fVFNGUl9MTElTKTsKIAotCWxsaXNfdmFbbnVtX2xsaXNdLmNjdGwJCT0gY2N0bDsKLQlsbGlzX3ZhW251bV9sbGlzXS5zcmMJCT0gdHhkLT5zcmNidXMuYWRkcjsKLQlsbGlzX3ZhW251bV9sbGlzXS5kc3QJCT0gdHhkLT5kc3RidXMuYWRkcjsKLQotCS8qCi0JICogT24gdmVyc2lvbnMgd2l0aCBkdWFsIG1hc3RlcnMsIHlvdSBjYW4gb3B0aW9uYWxseSBBTkQgb24KLQkgKiBQTDA4MF9MTElfTE1fQUhCMiB0byB0aGUgTExJIHRvIHRlbGwgdGhlIGhhcmR3YXJlIHRvIHJlYWQKLQkgKiBpbiBuZXcgTExJcyB3aXRoIHRoYXQgY29udHJvbGxlciwgYnV0IHdlIGFsd2F5cyB0cnkgdG8KLQkgKiBjaG9vc2UgQUhCMSB0byBwb2ludCBpbnRvIG1lbW9yeS4gVGhlIGlkZWEgaXMgdG8gaGF2ZSBBSEIyCi0JICogZml4ZWQgb24gdGhlIHBlcmlwaGVyYWwgYW5kIEFIQjEgbWVzc2luZyBhcm91bmQgaW4gdGhlCi0JICogbWVtb3J5LiBTbyB3ZSBkb24ndCBtYW5pcHVsYXRlIHRoaXMgYml0IGN1cnJlbnRseS4KLQkgKi8KLQotCWxsaXNfdmFbbnVtX2xsaXNdLm5leHQgPQotCQkoZG1hX2FkZHJfdCkoKHUzMikgJihsbGlzX2J1c1tudW1fbGxpcyArIDFdKSk7CisJbGxpc192YVtudW1fbGxpc10uY2N0bCA9IGNjdGw7CisJbGxpc192YVtudW1fbGxpc10uc3JjID0gYmQtPnNyY2J1cy5hZGRyOworCWxsaXNfdmFbbnVtX2xsaXNdLmRzdCA9IGJkLT5kc3RidXMuYWRkcjsKKwlsbGlzX3ZhW251bV9sbGlzXS5sbGkgPSBsbGlzX2J1cyArIChudW1fbGxpcyArIDEpICogc2l6ZW9mKHN0cnVjdCBwbDA4eF9sbGkpOworCWlmIChiZC0+cGwwOHgtPmxsaV9idXNlcyAmIFBMMDhYX0FIQjIpCisJCWxsaXNfdmFbbnVtX2xsaXNdLmxsaSB8PSBQTDA4MF9MTElfTE1fQUhCMjsKIAogCWlmIChjY3RsICYgUEwwODBfQ09OVFJPTF9TUkNfSU5DUikKLQkJdHhkLT5zcmNidXMuYWRkciArPSBsZW47CisJCWJkLT5zcmNidXMuYWRkciArPSBsZW47CiAJaWYgKGNjdGwgJiBQTDA4MF9DT05UUk9MX0RTVF9JTkNSKQotCQl0eGQtPmRzdGJ1cy5hZGRyICs9IGxlbjsKKwkJYmQtPmRzdGJ1cy5hZGRyICs9IGxlbjsKIAotCSpyZW1haW5kZXIgLT0gbGVuOworCUJVR19PTihiZC0+cmVtYWluZGVyIDwgbGVuKTsKIAotCXJldHVybiBudW1fbGxpcyArIDE7CisJYmQtPnJlbWFpbmRlciAtPSBsZW47CiB9CiAKIC8qCi0gKiBSZXR1cm4gbnVtYmVyIG9mIGJ5dGVzIHRvIGZpbGwgdG8gYm91bmRhcnksIG9yIGxlbgorICogUmV0dXJuIG51bWJlciBvZiBieXRlcyB0byBmaWxsIHRvIGJvdW5kYXJ5LCBvciBsZW4uCisgKiBUaGlzIGNhbGN1bGF0aW9uIHdvcmtzIGZvciBhbnkgdmFsdWUgb2YgYWRkci4KICAqLwotc3RhdGljIGlubGluZSB1MzIgcGwwOHhfcHJlX2JvdW5kYXJ5KHUzMiBhZGRyLCB1MzIgbGVuKQorc3RhdGljIGlubGluZSBzaXplX3QgcGwwOHhfcHJlX2JvdW5kYXJ5KHUzMiBhZGRyLCBzaXplX3QgbGVuKQogewotCXUzMiBib3VuZGFyeTsKKwlzaXplX3QgYm91bmRhcnlfbGVuID0gUEwwOFhfQk9VTkRBUllfU0laRSAtCisJCQkoYWRkciAmIChQTDA4WF9CT1VOREFSWV9TSVpFIC0gMSkpOwogCi0JYm91bmRhcnkgPSAoKGFkZHIgPj4gUEwwOFhfQk9VTkRBUllfU0hJRlQpICsgMSkKLQkJPDwgUEwwOFhfQk9VTkRBUllfU0hJRlQ7Ci0KLQlpZiAoYm91bmRhcnkgPCBhZGRyICsgbGVuKQotCQlyZXR1cm4gYm91bmRhcnkgLSBhZGRyOwotCWVsc2UKLQkJcmV0dXJuIGxlbjsKKwlyZXR1cm4gbWluKGJvdW5kYXJ5X2xlbiwgbGVuKTsKIH0KIAogLyoKQEAgLTYwOCwyMCArNTcxLDEzIEBACiBzdGF0aWMgaW50IHBsMDh4X2ZpbGxfbGxpc19mb3JfZGVzYyhzdHJ1Y3QgcGwwOHhfZHJpdmVyX2RhdGEgKnBsMDh4LAogCQkJICAgICAgc3RydWN0IHBsMDh4X3R4ZCAqdHhkKQogewotCXN0cnVjdCBwbDA4eF9jaGFubmVsX2RhdGEgKmNkID0gdHhkLT5jZDsKIAlzdHJ1Y3QgcGwwOHhfYnVzX2RhdGEgKm1idXMsICpzYnVzOwotCXUzMiByZW1haW5kZXI7CisJc3RydWN0IHBsMDh4X2xsaV9idWlsZF9kYXRhIGJkOwogCWludCBudW1fbGxpcyA9IDA7CiAJdTMyIGNjdGw7Ci0JaW50IG1heF9ieXRlc19wZXJfbGxpOwotCWludCB0b3RhbF9ieXRlcyA9IDA7Ci0Jc3RydWN0IGxsaSAqbGxpc192YTsKLQlzdHJ1Y3QgbGxpICpsbGlzX2J1czsKLQotCWlmICghdHhkKSB7Ci0JCWRldl9lcnIoJnBsMDh4LT5hZGV2LT5kZXYsICIlcyBubyBkZXNjcmlwdG9yXG4iLCBfX2Z1bmNfXyk7Ci0JCXJldHVybiAwOwotCX0KKwlzaXplX3QgbWF4X2J5dGVzX3Blcl9sbGk7CisJc2l6ZV90IHRvdGFsX2J5dGVzID0gMDsKKwlzdHJ1Y3QgcGwwOHhfbGxpICpsbGlzX3ZhOwogCiAJdHhkLT5sbGlzX3ZhID0gZG1hX3Bvb2xfYWxsb2MocGwwOHgtPnBvb2wsIEdGUF9OT1dBSVQsCiAJCQkJICAgICAgJnR4ZC0+bGxpc19idXMpOwpAQCAtNjMyLDEyMSArNTg4LDc5IEBACiAKIAlwbDA4eC0+cG9vbF9jdHIrKzsKIAotCS8qCi0JICogSW5pdGlhbGl6ZSBidXMgdmFsdWVzIGZvciB0aGlzIHRyYW5zZmVyCi0JICogZnJvbSB0aGUgcGFzc2VkIG9wdGltYWwgdmFsdWVzCi0JICovCi0JaWYgKCFjZCkgewotCQlkZXZfZXJyKCZwbDA4eC0+YWRldi0+ZGV2LCAiJXMgbm8gY2hhbm5lbCBkYXRhXG4iLCBfX2Z1bmNfXyk7Ci0JCXJldHVybiAwOwotCX0KKwkvKiBHZXQgdGhlIGRlZmF1bHQgQ0NUTCAqLworCWNjdGwgPSB0eGQtPmNjdGw7CiAKLQkvKiBHZXQgdGhlIGRlZmF1bHQgQ0NUTCBmcm9tIHRoZSBwbGF0Zm9ybSBkYXRhICovCi0JY2N0bCA9IGNkLT5jY3RsOwotCi0JLyoKLQkgKiBPbiB0aGUgUEwwODAgd2UgaGF2ZSB0d28gYnVzIG1hc3RlcnMgYW5kIHdlCi0JICogc2hvdWxkIHNlbGVjdCBvbmUgZm9yIHNvdXJjZSBhbmQgb25lIGZvcgotCSAqIGRlc3RpbmF0aW9uLiBXZSB0cnkgdG8gdXNlIEFIQjIgZm9yIHRoZQotCSAqIGJ1cyB3aGljaCBkb2VzIG5vdCBpbmNyZW1lbnQgKHR5cGljYWxseSB0aGUKLQkgKiBwZXJpcGhlcmFsKSBlbHNlIHdlIGp1c3QgY2hvb3NlIHNvbWV0aGluZy4KLQkgKi8KLQljY3RsICY9IH4oUEwwODBfQ09OVFJPTF9EU1RfQUhCMiB8IFBMMDgwX0NPTlRST0xfU1JDX0FIQjIpOwotCWlmIChwbDA4eC0+dmQtPmR1YWxtYXN0ZXIpIHsKLQkJaWYgKGNjdGwgJiBQTDA4MF9DT05UUk9MX1NSQ19JTkNSKQotCQkJLyogU291cmNlIGluY3JlbWVudHMsIHVzZSBBSEIyIGZvciBkZXN0aW5hdGlvbiAqLwotCQkJY2N0bCB8PSBQTDA4MF9DT05UUk9MX0RTVF9BSEIyOwotCQllbHNlIGlmIChjY3RsICYgUEwwODBfQ09OVFJPTF9EU1RfSU5DUikKLQkJCS8qIERlc3RpbmF0aW9uIGluY3JlbWVudHMsIHVzZSBBSEIyIGZvciBzb3VyY2UgKi8KLQkJCWNjdGwgfD0gUEwwODBfQ09OVFJPTF9TUkNfQUhCMjsKLQkJZWxzZQotCQkJLyogSnVzdCBwaWNrIHNvbWV0aGluZywgc291cmNlIEFIQjEgZGVzdCBBSEIyICovCi0JCQljY3RsIHw9IFBMMDgwX0NPTlRST0xfRFNUX0FIQjI7Ci0JfQorCWJkLnR4ZCA9IHR4ZDsKKwliZC5wbDA4eCA9IHBsMDh4OworCWJkLnNyY2J1cy5hZGRyID0gdHhkLT5zcmNfYWRkcjsKKwliZC5kc3RidXMuYWRkciA9IHR4ZC0+ZHN0X2FkZHI7CiAKIAkvKiBGaW5kIG1heGltdW0gd2lkdGggb2YgdGhlIHNvdXJjZSBidXMgKi8KLQl0eGQtPnNyY2J1cy5tYXh3aWR0aCA9CisJYmQuc3JjYnVzLm1heHdpZHRoID0KIAkJcGwwOHhfZ2V0X2J5dGVzX2Zvcl9jY3RsKChjY3RsICYgUEwwODBfQ09OVFJPTF9TV0lEVEhfTUFTSykgPj4KIAkJCQkgICAgICAgUEwwODBfQ09OVFJPTF9TV0lEVEhfU0hJRlQpOwogCiAJLyogRmluZCBtYXhpbXVtIHdpZHRoIG9mIHRoZSBkZXN0aW5hdGlvbiBidXMgKi8KLQl0eGQtPmRzdGJ1cy5tYXh3aWR0aCA9CisJYmQuZHN0YnVzLm1heHdpZHRoID0KIAkJcGwwOHhfZ2V0X2J5dGVzX2Zvcl9jY3RsKChjY3RsICYgUEwwODBfQ09OVFJPTF9EV0lEVEhfTUFTSykgPj4KIAkJCQkgICAgICAgUEwwODBfQ09OVFJPTF9EV0lEVEhfU0hJRlQpOwogCiAJLyogU2V0IHVwIHRoZSBidXMgd2lkdGhzIHRvIHRoZSBtYXhpbXVtICovCi0JdHhkLT5zcmNidXMuYnVzd2lkdGggPSB0eGQtPnNyY2J1cy5tYXh3aWR0aDsKLQl0eGQtPmRzdGJ1cy5idXN3aWR0aCA9IHR4ZC0+ZHN0YnVzLm1heHdpZHRoOworCWJkLnNyY2J1cy5idXN3aWR0aCA9IGJkLnNyY2J1cy5tYXh3aWR0aDsKKwliZC5kc3RidXMuYnVzd2lkdGggPSBiZC5kc3RidXMubWF4d2lkdGg7CiAJZGV2X3ZkYmcoJnBsMDh4LT5hZGV2LT5kZXYsCiAJCSAiJXMgc291cmNlIGJ1cyBpcyAlZCBieXRlcyB3aWRlLCBkZXN0IGJ1cyBpcyAlZCBieXRlcyB3aWRlXG4iLAotCQkgX19mdW5jX18sIHR4ZC0+c3JjYnVzLmJ1c3dpZHRoLCB0eGQtPmRzdGJ1cy5idXN3aWR0aCk7CisJCSBfX2Z1bmNfXywgYmQuc3JjYnVzLmJ1c3dpZHRoLCBiZC5kc3RidXMuYnVzd2lkdGgpOwogCiAKIAkvKgogCSAqIEJ5dGVzIHRyYW5zZmVycmVkID09IHRzaXplICogTUlOKGJ1c3dpZHRocyksIG5vdCBtYXgoYnVzd2lkdGhzKQogCSAqLwotCW1heF9ieXRlc19wZXJfbGxpID0gbWluKHR4ZC0+c3JjYnVzLmJ1c3dpZHRoLCB0eGQtPmRzdGJ1cy5idXN3aWR0aCkgKgorCW1heF9ieXRlc19wZXJfbGxpID0gbWluKGJkLnNyY2J1cy5idXN3aWR0aCwgYmQuZHN0YnVzLmJ1c3dpZHRoKSAqCiAJCVBMMDgwX0NPTlRST0xfVFJBTlNGRVJfU0laRV9NQVNLOwogCWRldl92ZGJnKCZwbDA4eC0+YWRldi0+ZGV2LAotCQkgIiVzIG1heCBieXRlcyBwZXIgbGxpID0gJWRcbiIsCisJCSAiJXMgbWF4IGJ5dGVzIHBlciBsbGkgPSAlenVcbiIsCiAJCSBfX2Z1bmNfXywgbWF4X2J5dGVzX3Blcl9sbGkpOwogCiAJLyogV2UgbmVlZCB0byBjb3VudCB0aGlzIGRvd24gdG8gemVybyAqLwotCXJlbWFpbmRlciA9IHR4ZC0+bGVuOworCWJkLnJlbWFpbmRlciA9IHR4ZC0+bGVuOwogCWRldl92ZGJnKCZwbDA4eC0+YWRldi0+ZGV2LAotCQkgIiVzIHJlbWFpbmRlciA9ICVkXG4iLAotCQkgX19mdW5jX18sIHJlbWFpbmRlcik7CisJCSAiJXMgcmVtYWluZGVyID0gJXp1XG4iLAorCQkgX19mdW5jX18sIGJkLnJlbWFpbmRlcik7CiAKIAkvKgogCSAqIENob29zZSBidXMgdG8gYWxpZ24gdG8KIAkgKiAtIHByZWZlcnMgZGVzdGluYXRpb24gYnVzIGlmIGJvdGggYXZhaWxhYmxlCiAJICogLSBpZiBmaXhlZCBhZGRyZXNzIG9uIG9uZSBidXMgY2hvb3NlcyBvdGhlcgotCSAqIC0gbW9kaWZpZXMgY2N0bCB0byBjaG9vc2UgYW4gYXByb3ByaWF0ZSBtYXN0ZXIKIAkgKi8KLQlwbDA4eF9jaG9vc2VfbWFzdGVyX2J1cygmdHhkLT5zcmNidXMsICZ0eGQtPmRzdGJ1cywKLQkJCQkmbWJ1cywgJnNidXMsIGNjdGwpOwotCi0KLQkvKgotCSAqIFRoZSBsb3dlc3QgYml0IG9mIHRoZSBMTEkgcmVnaXN0ZXIKLQkgKiBpcyBhbHNvIHVzZWQgdG8gaW5kaWNhdGUgd2hpY2ggbWFzdGVyIHRvCi0JICogdXNlIGZvciByZWFkaW5nIHRoZSBMTElzLgotCSAqLworCXBsMDh4X2Nob29zZV9tYXN0ZXJfYnVzKCZiZCwgJm1idXMsICZzYnVzLCBjY3RsKTsKIAogCWlmICh0eGQtPmxlbiA8IG1idXMtPmJ1c3dpZHRoKSB7Ci0JCS8qCi0JCSAqIExlc3MgdGhhbiBhIGJ1cyB3aWR0aCBhdmFpbGFibGUKLQkJICogLSBzZW5kIGFzIHNpbmdsZSBieXRlcwotCQkgKi8KLQkJd2hpbGUgKHJlbWFpbmRlcikgeworCQkvKiBMZXNzIHRoYW4gYSBidXMgd2lkdGggYXZhaWxhYmxlIC0gc2VuZCBhcyBzaW5nbGUgYnl0ZXMgKi8KKwkJd2hpbGUgKGJkLnJlbWFpbmRlcikgewogCQkJZGV2X3ZkYmcoJnBsMDh4LT5hZGV2LT5kZXYsCiAJCQkJICIlcyBzaW5nbGUgYnl0ZSBMTElzIGZvciBhIHRyYW5zZmVyIG9mICIKLQkJCQkgImxlc3MgdGhhbiBhIGJ1cyB3aWR0aCAocmVtYWluICUwOHgpXG4iLAotCQkJCSBfX2Z1bmNfXywgcmVtYWluZGVyKTsKKwkJCQkgImxlc3MgdGhhbiBhIGJ1cyB3aWR0aCAocmVtYWluIDB4JTA4eClcbiIsCisJCQkJIF9fZnVuY19fLCBiZC5yZW1haW5kZXIpOwogCQkJY2N0bCA9IHBsMDh4X2NjdGxfYml0cyhjY3RsLCAxLCAxLCAxKTsKLQkJCW51bV9sbGlzID0KLQkJCQlwbDA4eF9maWxsX2xsaV9mb3JfZGVzYyhwbDA4eCwgdHhkLCBudW1fbGxpcywgMSwKLQkJCQkJY2N0bCwgJnJlbWFpbmRlcik7CisJCQlwbDA4eF9maWxsX2xsaV9mb3JfZGVzYygmYmQsIG51bV9sbGlzKyssIDEsIGNjdGwpOwogCQkJdG90YWxfYnl0ZXMrKzsKIAkJfQogCX0gZWxzZSB7Ci0JCS8qCi0JCSAqICBNYWtlIG9uZSBieXRlIExMSXMgdW50aWwgbWFzdGVyIGJ1cyBpcyBhbGlnbmVkCi0JCSAqICAtIHNsYXZlIHdpbGwgdGhlbiBiZSBhbGlnbmVkIGFsc28KLQkJICovCisJCS8qIE1ha2Ugb25lIGJ5dGUgTExJcyB1bnRpbCBtYXN0ZXIgYnVzIGlzIGFsaWduZWQgKi8KIAkJd2hpbGUgKChtYnVzLT5hZGRyKSAlIChtYnVzLT5idXN3aWR0aCkpIHsKIAkJCWRldl92ZGJnKCZwbDA4eC0+YWRldi0+ZGV2LAogCQkJCSIlcyBhZGp1c3RtZW50IGxsaSBmb3IgbGVzcyB0aGFuIGJ1cyB3aWR0aCAiCi0JCQkJICIocmVtYWluICUwOHgpXG4iLAotCQkJCSBfX2Z1bmNfXywgcmVtYWluZGVyKTsKKwkJCQkgIihyZW1haW4gMHglMDh4KVxuIiwKKwkJCQkgX19mdW5jX18sIGJkLnJlbWFpbmRlcik7CiAJCQljY3RsID0gcGwwOHhfY2N0bF9iaXRzKGNjdGwsIDEsIDEsIDEpOwotCQkJbnVtX2xsaXMgPSBwbDA4eF9maWxsX2xsaV9mb3JfZGVzYwotCQkJCShwbDA4eCwgdHhkLCBudW1fbGxpcywgMSwgY2N0bCwgJnJlbWFpbmRlcik7CisJCQlwbDA4eF9maWxsX2xsaV9mb3JfZGVzYygmYmQsIG51bV9sbGlzKyssIDEsIGNjdGwpOwogCQkJdG90YWxfYnl0ZXMrKzsKIAkJfQogCiAJCS8qCi0JCSAqICBNYXN0ZXIgbm93IGFsaWduZWQKKwkJICogTWFzdGVyIG5vdyBhbGlnbmVkCiAJCSAqIC0gaWYgc2xhdmUgaXMgbm90IHRoZW4gd2UgbXVzdCBzZXQgaXRzIHdpZHRoIGRvd24KIAkJICovCiAJCWlmIChzYnVzLT5hZGRyICUgc2J1cy0+YnVzd2lkdGgpIHsKQEAgLTc2MSw2MyArNjc1LDUxIEBACiAJCSAqIE1ha2UgbGFyZ2VzdCBwb3NzaWJsZSBMTElzIHVudGlsIGxlc3MgdGhhbiBvbmUgYnVzCiAJCSAqIHdpZHRoIGxlZnQKIAkJICovCi0JCXdoaWxlIChyZW1haW5kZXIgPiAobWJ1cy0+YnVzd2lkdGggLSAxKSkgewotCQkJaW50IGxsaV9sZW4sIHRhcmdldF9sZW47Ci0JCQlpbnQgdHNpemU7Ci0JCQlpbnQgb2RkX2J5dGVzOworCQl3aGlsZSAoYmQucmVtYWluZGVyID4gKG1idXMtPmJ1c3dpZHRoIC0gMSkpIHsKKwkJCXNpemVfdCBsbGlfbGVuLCB0YXJnZXRfbGVuLCB0c2l6ZSwgb2RkX2J5dGVzOwogCiAJCQkvKgogCQkJICogSWYgZW5vdWdoIGxlZnQgdHJ5IHRvIHNlbmQgbWF4IHBvc3NpYmxlLAogCQkJICogb3RoZXJ3aXNlIHRyeSB0byBzZW5kIHRoZSByZW1haW5kZXIKIAkJCSAqLwotCQkJdGFyZ2V0X2xlbiA9IHJlbWFpbmRlcjsKLQkJCWlmIChyZW1haW5kZXIgPiBtYXhfYnl0ZXNfcGVyX2xsaSkKLQkJCQl0YXJnZXRfbGVuID0gbWF4X2J5dGVzX3Blcl9sbGk7CisJCQl0YXJnZXRfbGVuID0gbWluKGJkLnJlbWFpbmRlciwgbWF4X2J5dGVzX3Blcl9sbGkpOwogCiAJCQkvKgotCQkJICogU2V0IGJ1cyBsZW5ndGhzIGZvciBpbmNyZW1lbnRpbmcgYnVzc2VzCi0JCQkgKiB0byBudW1iZXIgb2YgYnl0ZXMgd2hpY2ggZmlsbCB0byBuZXh0IG1lbW9yeQotCQkJICogYm91bmRhcnkKKwkJCSAqIFNldCBidXMgbGVuZ3RocyBmb3IgaW5jcmVtZW50aW5nIGJ1c2VzIHRvIHRoZQorCQkJICogbnVtYmVyIG9mIGJ5dGVzIHdoaWNoIGZpbGwgdG8gbmV4dCBtZW1vcnkgYm91bmRhcnksCisJCQkgKiBsaW1pdGluZyBvbiB0aGUgdGFyZ2V0IGxlbmd0aCBjYWxjdWxhdGVkIGFib3ZlLgogCQkJICovCiAJCQlpZiAoY2N0bCAmIFBMMDgwX0NPTlRST0xfU1JDX0lOQ1IpCi0JCQkJdHhkLT5zcmNidXMuZmlsbF9ieXRlcyA9Ci0JCQkJCXBsMDh4X3ByZV9ib3VuZGFyeSgKLQkJCQkJCXR4ZC0+c3JjYnVzLmFkZHIsCi0JCQkJCQlyZW1haW5kZXIpOworCQkJCWJkLnNyY2J1cy5maWxsX2J5dGVzID0KKwkJCQkJcGwwOHhfcHJlX2JvdW5kYXJ5KGJkLnNyY2J1cy5hZGRyLAorCQkJCQkJdGFyZ2V0X2xlbik7CiAJCQllbHNlCi0JCQkJdHhkLT5zcmNidXMuZmlsbF9ieXRlcyA9Ci0JCQkJCW1heF9ieXRlc19wZXJfbGxpOworCQkJCWJkLnNyY2J1cy5maWxsX2J5dGVzID0gdGFyZ2V0X2xlbjsKIAogCQkJaWYgKGNjdGwgJiBQTDA4MF9DT05UUk9MX0RTVF9JTkNSKQotCQkJCXR4ZC0+ZHN0YnVzLmZpbGxfYnl0ZXMgPQotCQkJCQlwbDA4eF9wcmVfYm91bmRhcnkoCi0JCQkJCQl0eGQtPmRzdGJ1cy5hZGRyLAotCQkJCQkJcmVtYWluZGVyKTsKKwkJCQliZC5kc3RidXMuZmlsbF9ieXRlcyA9CisJCQkJCXBsMDh4X3ByZV9ib3VuZGFyeShiZC5kc3RidXMuYWRkciwKKwkJCQkJCXRhcmdldF9sZW4pOwogCQkJZWxzZQotCQkJCXR4ZC0+ZHN0YnVzLmZpbGxfYnl0ZXMgPQotCQkJCQkJbWF4X2J5dGVzX3Blcl9sbGk7CisJCQkJYmQuZHN0YnVzLmZpbGxfYnl0ZXMgPSB0YXJnZXRfbGVuOwogCi0JCQkvKgotCQkJICogIEZpbmQgdGhlIG5lYXJlc3QKLQkJCSAqLwotCQkJbGxpX2xlbgk9IG1pbih0eGQtPnNyY2J1cy5maWxsX2J5dGVzLAotCQkJCXR4ZC0+ZHN0YnVzLmZpbGxfYnl0ZXMpOworCQkJLyogRmluZCB0aGUgbmVhcmVzdCAqLworCQkJbGxpX2xlbgk9IG1pbihiZC5zcmNidXMuZmlsbF9ieXRlcywKKwkJCQkgICAgICBiZC5kc3RidXMuZmlsbF9ieXRlcyk7CiAKLQkJCUJVR19PTihsbGlfbGVuID4gcmVtYWluZGVyKTsKKwkJCUJVR19PTihsbGlfbGVuID4gYmQucmVtYWluZGVyKTsKIAogCQkJaWYgKGxsaV9sZW4gPD0gMCkgewogCQkJCWRldl9lcnIoJnBsMDh4LT5hZGV2LT5kZXYsCi0JCQkJCSIlcyBsbGlfbGVuIGlzICVkLCA8PSAwXG4iLAorCQkJCQkiJXMgbGxpX2xlbiBpcyAlenUsIDw9IDBcbiIsCiAJCQkJCQlfX2Z1bmNfXywgbGxpX2xlbik7CiAJCQkJcmV0dXJuIDA7CiAJCQl9CiAKIAkJCWlmIChsbGlfbGVuID09IHRhcmdldF9sZW4pIHsKIAkJCQkvKgotCQkJCSAqIENhbiBzZW5kIHdoYXQgd2Ugd2FudGVkCi0JCQkJICovCi0JCQkJLyoKLQkJCQkgKiAgTWFpbnRhaW4gYWxpZ25tZW50CisJCQkJICogQ2FuIHNlbmQgd2hhdCB3ZSB3YW50ZWQuCisJCQkJICogTWFpbnRhaW4gYWxpZ25tZW50CiAJCQkJICovCiAJCQkJbGxpX2xlbgk9IChsbGlfbGVuL21idXMtPmJ1c3dpZHRoKSAqCiAJCQkJCQkJbWJ1cy0+YnVzd2lkdGg7CkBAIC04MjUsMTcgKzcyNywxNCBAQAogCQkJfSBlbHNlIHsKIAkJCQkvKgogCQkJCSAqIFNvIG5vdyB3ZSBrbm93IGhvdyBtYW55IGJ5dGVzIHRvIHRyYW5zZmVyCi0JCQkJICogdG8gZ2V0IHRvIHRoZSBuZWFyZXN0IGJvdW5kYXJ5Ci0JCQkJICogVGhlIG5leHQgbGxpIHdpbGwgcGFzdCB0aGUgYm91bmRhcnkKLQkJCQkgKiAtIGhvd2V2ZXIgd2UgbWF5IGJlIHdvcmtpbmcgdG8gYSBib3VuZGFyeQotCQkJCSAqICAgb24gdGhlIHNsYXZlIGJ1cwotCQkJCSAqICAgV2UgbmVlZCB0byBlbnN1cmUgdGhlIG1hc3RlciBzdGF5cyBhbGlnbmVkCisJCQkJICogdG8gZ2V0IHRvIHRoZSBuZWFyZXN0IGJvdW5kYXJ5LiAgVGhlIG5leHQKKwkJCQkgKiBMTEkgd2lsbCBwYXN0IHRoZSBib3VuZGFyeS4gIEhvd2V2ZXIsIHdlCisJCQkJICogbWF5IGJlIHdvcmtpbmcgdG8gYSBib3VuZGFyeSBvbiB0aGUgc2xhdmUKKwkJCQkgKiBidXMuICBXZSBuZWVkIHRvIGVuc3VyZSB0aGUgbWFzdGVyIHN0YXlzCisJCQkJICogYWxpZ25lZCwgYW5kIHRoYXQgd2UgYXJlIHdvcmtpbmcgaW4KKwkJCQkgKiBtdWx0aXBsZXMgb2YgdGhlIGJ1cyB3aWR0aHMuCiAJCQkJICovCiAJCQkJb2RkX2J5dGVzID0gbGxpX2xlbiAlIG1idXMtPmJ1c3dpZHRoOwotCQkJCS8qCi0JCQkJICogLSBhbmQgdGhhdCB3ZSBhcmUgd29ya2luZyBpbiBtdWx0aXBsZXMKLQkJCQkgKiAgIG9mIHRoZSBidXMgd2lkdGhzCi0JCQkJICovCiAJCQkJbGxpX2xlbiAtPSBvZGRfYnl0ZXM7CiAKIAkJCX0KQEAgLTg1NSw0MSArNzU0LDM4IEBACiAKIAkJCQlpZiAodGFyZ2V0X2xlbiAhPSBsbGlfbGVuKSB7CiAJCQkJCWRldl92ZGJnKCZwbDA4eC0+YWRldi0+ZGV2LAotCQkJCQkiJXMgY2FuJ3Qgc2VuZCB3aGF0IHdlIHdhbnQuIERlc2lyZWQgJTA4eCwgbGxpIG9mICUwOHggYnl0ZXMgaW4gdHhkIG9mICUwOHhcbiIsCisJCQkJCSIlcyBjYW4ndCBzZW5kIHdoYXQgd2Ugd2FudC4gRGVzaXJlZCAweCUwOHp4LCBsbGkgb2YgMHglMDh6eCBieXRlcyBpbiB0eGQgb2YgMHglMDh6eFxuIiwKIAkJCQkJX19mdW5jX18sIHRhcmdldF9sZW4sIGxsaV9sZW4sIHR4ZC0+bGVuKTsKIAkJCQl9CiAKIAkJCQljY3RsID0gcGwwOHhfY2N0bF9iaXRzKGNjdGwsCi0JCQkJCQkgICAgICAgdHhkLT5zcmNidXMuYnVzd2lkdGgsCi0JCQkJCQkgICAgICAgdHhkLT5kc3RidXMuYnVzd2lkdGgsCisJCQkJCQkgICAgICAgYmQuc3JjYnVzLmJ1c3dpZHRoLAorCQkJCQkJICAgICAgIGJkLmRzdGJ1cy5idXN3aWR0aCwKIAkJCQkJCSAgICAgICB0c2l6ZSk7CiAKIAkJCQlkZXZfdmRiZygmcGwwOHgtPmFkZXYtPmRldiwKLQkJCQkJIiVzIGZpbGwgbGxpIHdpdGggc2luZ2xlIGxsaSBjaHVuayBvZiBzaXplICUwOHggKHJlbWFpbmRlciAlMDh4KVxuIiwKLQkJCQkJX19mdW5jX18sIGxsaV9sZW4sIHJlbWFpbmRlcik7Ci0JCQkJbnVtX2xsaXMgPSBwbDA4eF9maWxsX2xsaV9mb3JfZGVzYyhwbDA4eCwgdHhkLAotCQkJCQkJbnVtX2xsaXMsIGxsaV9sZW4sIGNjdGwsCi0JCQkJCQkmcmVtYWluZGVyKTsKKwkJCQkJIiVzIGZpbGwgbGxpIHdpdGggc2luZ2xlIGxsaSBjaHVuayBvZiBzaXplIDB4JTA4enggKHJlbWFpbmRlciAweCUwOHp4KVxuIiwKKwkJCQkJX19mdW5jX18sIGxsaV9sZW4sIGJkLnJlbWFpbmRlcik7CisJCQkJcGwwOHhfZmlsbF9sbGlfZm9yX2Rlc2MoJmJkLCBudW1fbGxpcysrLAorCQkJCQlsbGlfbGVuLCBjY3RsKTsKIAkJCQl0b3RhbF9ieXRlcyArPSBsbGlfbGVuOwogCQkJfQogCiAKIAkJCWlmIChvZGRfYnl0ZXMpIHsKIAkJCQkvKgotCQkJCSAqIENyZWVwIHBhc3QgdGhlIGJvdW5kYXJ5LAotCQkJCSAqIG1haW50YWluaW5nIG1hc3RlciBhbGlnbm1lbnQKKwkJCQkgKiBDcmVlcCBwYXN0IHRoZSBib3VuZGFyeSwgbWFpbnRhaW5pbmcKKwkJCQkgKiBtYXN0ZXIgYWxpZ25tZW50CiAJCQkJICovCiAJCQkJaW50IGo7CiAJCQkJZm9yIChqID0gMDsgKGogPCBtYnVzLT5idXN3aWR0aCkKLQkJCQkJCSYmIChyZW1haW5kZXIpOyBqKyspIHsKKwkJCQkJCSYmIChiZC5yZW1haW5kZXIpOyBqKyspIHsKIAkJCQkJY2N0bCA9IHBsMDh4X2NjdGxfYml0cyhjY3RsLCAxLCAxLCAxKTsKIAkJCQkJZGV2X3ZkYmcoJnBsMDh4LT5hZGV2LT5kZXYsCi0JCQkJCQkiJXMgYWxpZ24gd2l0aCBib3VuZGFyZHksIHNpbmdsZSBieXRlIChyZW1haW4gJTA4eClcbiIsCi0JCQkJCQlfX2Z1bmNfXywgcmVtYWluZGVyKTsKLQkJCQkJbnVtX2xsaXMgPQotCQkJCQkJcGwwOHhfZmlsbF9sbGlfZm9yX2Rlc2MocGwwOHgsCi0JCQkJCQkJdHhkLCBudW1fbGxpcywgMSwKLQkJCQkJCQljY3RsLCAmcmVtYWluZGVyKTsKKwkJCQkJCSIlcyBhbGlnbiB3aXRoIGJvdW5kYXJ5LCBzaW5nbGUgYnl0ZSAocmVtYWluIDB4JTA4engpXG4iLAorCQkJCQkJX19mdW5jX18sIGJkLnJlbWFpbmRlcik7CisJCQkJCXBsMDh4X2ZpbGxfbGxpX2Zvcl9kZXNjKCZiZCwKKwkJCQkJCW51bV9sbGlzKyssIDEsIGNjdGwpOwogCQkJCQl0b3RhbF9ieXRlcysrOwogCQkJCX0KIAkJCX0KQEAgLTg5OCwyNSArNzk0LDE4IEBACiAJCS8qCiAJCSAqIFNlbmQgYW55IG9kZCBieXRlcwogCQkgKi8KLQkJaWYgKHJlbWFpbmRlciA8IDApIHsKLQkJCWRldl9lcnIoJnBsMDh4LT5hZGV2LT5kZXYsICIlcyByZW1haW5kZXIgbm90IGZpdHRlZCAweCUwOHggYnl0ZXNcbiIsCi0JCQkJCV9fZnVuY19fLCByZW1haW5kZXIpOwotCQkJcmV0dXJuIDA7Ci0JCX0KLQotCQl3aGlsZSAocmVtYWluZGVyKSB7CisJCXdoaWxlIChiZC5yZW1haW5kZXIpIHsKIAkJCWNjdGwgPSBwbDA4eF9jY3RsX2JpdHMoY2N0bCwgMSwgMSwgMSk7CiAJCQlkZXZfdmRiZygmcGwwOHgtPmFkZXYtPmRldiwKLQkJCQkiJXMgYWxpZ24gd2l0aCBib3VuZGFyZHksIHNpbmdsZSBvZGQgYnl0ZSAocmVtYWluICVkKVxuIiwKLQkJCQlfX2Z1bmNfXywgcmVtYWluZGVyKTsKLQkJCW51bV9sbGlzID0gcGwwOHhfZmlsbF9sbGlfZm9yX2Rlc2MocGwwOHgsIHR4ZCwgbnVtX2xsaXMsCi0JCQkJCTEsIGNjdGwsICZyZW1haW5kZXIpOworCQkJCSIlcyBhbGlnbiB3aXRoIGJvdW5kYXJ5LCBzaW5nbGUgb2RkIGJ5dGUgKHJlbWFpbiAlenUpXG4iLAorCQkJCV9fZnVuY19fLCBiZC5yZW1haW5kZXIpOworCQkJcGwwOHhfZmlsbF9sbGlfZm9yX2Rlc2MoJmJkLCBudW1fbGxpcysrLCAxLCBjY3RsKTsKIAkJCXRvdGFsX2J5dGVzKys7CiAJCX0KIAl9CiAJaWYgKHRvdGFsX2J5dGVzICE9IHR4ZC0+bGVuKSB7CiAJCWRldl9lcnIoJnBsMDh4LT5hZGV2LT5kZXYsCi0JCQkiJXMgc2l6ZSBvZiBlbmNvZGVkIGxsaTpzIGRvbid0IG1hdGNoIHRvdGFsIHR4ZCwgdHJhbnNmZXJyZWQgMHglMDh4IGZyb20gc2l6ZSAweCUwOHhcbiIsCisJCQkiJXMgc2l6ZSBvZiBlbmNvZGVkIGxsaTpzIGRvbid0IG1hdGNoIHRvdGFsIHR4ZCwgdHJhbnNmZXJyZWQgMHglMDh6eCBmcm9tIHNpemUgMHglMDh6eFxuIiwKIAkJCV9fZnVuY19fLCB0b3RhbF9ieXRlcywgdHhkLT5sZW4pOwogCQlyZXR1cm4gMDsKIAl9CkBAIC05MjcsNDEgKzgxNiwxMiBAQAogCQkJX19mdW5jX18sICh1MzIpIE1BWF9OVU1fVFNGUl9MTElTKTsKIAkJcmV0dXJuIDA7CiAJfQotCS8qCi0JICogRGVjaWRlIHdoZXRoZXIgdGhpcyBpcyBhIGxvb3Agb3IgYSB0ZXJtaW5hdGVkIHRyYW5zZmVyCi0JICovCisKIAlsbGlzX3ZhID0gdHhkLT5sbGlzX3ZhOwotCWxsaXNfYnVzID0gKHN0cnVjdCBsbGkgKikgdHhkLT5sbGlzX2J1czsKLQotCWlmIChjZC0+Y2lyY3VsYXJfYnVmZmVyKSB7Ci0JCS8qCi0JCSAqIExvb3AgdGhlIGNpcmN1bGFyIGJ1ZmZlciBzbyB0aGF0IHRoZSBuZXh0IGVsZW1lbnQKLQkJICogcG9pbnRzIGJhY2sgdG8gdGhlIGJlZ2lubmluZyBvZiB0aGUgTExJLgotCQkgKi8KLQkJbGxpc192YVtudW1fbGxpcyAtIDFdLm5leHQgPQotCQkJKGRtYV9hZGRyX3QpKCh1bnNpZ25lZCBpbnQpJihsbGlzX2J1c1swXSkpOwotCX0gZWxzZSB7Ci0JCS8qCi0JCSAqIE9uIG5vbi1jaXJjdWxhciBidWZmZXJzLCB0aGUgZmluYWwgTExJIHRlcm1pbmF0ZXMKLQkJICogdGhlIExMSS4KLQkJICovCi0JCWxsaXNfdmFbbnVtX2xsaXMgLSAxXS5uZXh0ID0gMDsKLQkJLyoKLQkJICogVGhlIGZpbmFsIExMSSBlbGVtZW50IHNoYWxsIGFsc28gZmlyZSBhbiBpbnRlcnJ1cHQKLQkJICovCi0JCWxsaXNfdmFbbnVtX2xsaXMgLSAxXS5jY3RsIHw9IFBMMDgwX0NPTlRST0xfVENfSVJRX0VOOwotCX0KLQotCS8qIE5vdyBzdG9yZSB0aGUgY2hhbm5lbCByZWdpc3RlciB2YWx1ZXMgKi8KLQl0eGQtPmNzcmMgPSBsbGlzX3ZhWzBdLnNyYzsKLQl0eGQtPmNkc3QgPSBsbGlzX3ZhWzBdLmRzdDsKLQlpZiAobnVtX2xsaXMgPiAxKQotCQl0eGQtPmNsbGkgPSBsbGlzX3ZhWzBdLm5leHQ7Ci0JZWxzZQotCQl0eGQtPmNsbGkgPSAwOwotCi0JdHhkLT5jY3RsID0gbGxpc192YVswXS5jY3RsOwotCS8qIGNjZmcgd2lsbCBiZSBzZXQgYXQgcGh5c2ljYWwgY2hhbm5lbCBhbGxvY2F0aW9uIHRpbWUgKi8KKwkvKiBUaGUgZmluYWwgTExJIHRlcm1pbmF0ZXMgdGhlIExMSS4gKi8KKwlsbGlzX3ZhW251bV9sbGlzIC0gMV0ubGxpID0gMDsKKwkvKiBUaGUgZmluYWwgTExJIGVsZW1lbnQgc2hhbGwgYWxzbyBmaXJlIGFuIGludGVycnVwdC4gKi8KKwlsbGlzX3ZhW251bV9sbGlzIC0gMV0uY2N0bCB8PSBQTDA4MF9DT05UUk9MX1RDX0lSUV9FTjsKIAogI2lmZGVmIFZFUkJPU0VfREVCVUcKIAl7CkBAIC05NjksMTMgKzgyOSwxMyBAQAogCiAJCWZvciAoaSA9IDA7IGkgPCBudW1fbGxpczsgaSsrKSB7CiAJCQlkZXZfdmRiZygmcGwwOHgtPmFkZXYtPmRldiwKLQkJCQkgImxsaSAlZCBAJXA6IGNzcmM9JTA4eCwgY2RzdD0lMDh4LCBjY3RsPSUwOHgsIGNsbGk9JTA4eFxuIiwKKwkJCQkgImxsaSAlZCBAJXA6IGNzcmM9MHglMDh4LCBjZHN0PTB4JTA4eCwgY2N0bD0weCUwOHgsIGNsbGk9MHglMDh4XG4iLAogCQkJCSBpLAogCQkJCSAmbGxpc192YVtpXSwKIAkJCQkgbGxpc192YVtpXS5zcmMsCiAJCQkJIGxsaXNfdmFbaV0uZHN0LAogCQkJCSBsbGlzX3ZhW2ldLmNjdGwsCi0JCQkJIGxsaXNfdmFbaV0ubmV4dAorCQkJCSBsbGlzX3ZhW2ldLmxsaQogCQkJCSk7CiAJCX0KIAl9CkBAIC05ODgsMTQgKzg0OCw4IEBACiBzdGF0aWMgdm9pZCBwbDA4eF9mcmVlX3R4ZChzdHJ1Y3QgcGwwOHhfZHJpdmVyX2RhdGEgKnBsMDh4LAogCQkJICAgc3RydWN0IHBsMDh4X3R4ZCAqdHhkKQogewotCWlmICghdHhkKQotCQlkZXZfZXJyKCZwbDA4eC0+YWRldi0+ZGV2LAotCQkJIiVzIG5vIGRlc2NyaXB0b3IgdG8gZnJlZVxuIiwKLQkJCV9fZnVuY19fKTsKLQogCS8qIEZyZWUgdGhlIExMSSAqLwotCWRtYV9wb29sX2ZyZWUocGwwOHgtPnBvb2wsIHR4ZC0+bGxpc192YSwKLQkJICAgICAgdHhkLT5sbGlzX2J1cyk7CisJZG1hX3Bvb2xfZnJlZShwbDA4eC0+cG9vbCwgdHhkLT5sbGlzX3ZhLCB0eGQtPmxsaXNfYnVzKTsKIAogCXBsMDh4LT5wb29sX2N0ci0tOwogCkBAIC0xMDA4LDEzICs4NjIsMTIgQEAKIAlzdHJ1Y3QgcGwwOHhfdHhkICp0eGRpID0gTlVMTDsKIAlzdHJ1Y3QgcGwwOHhfdHhkICpuZXh0OwogCi0JaWYgKCFsaXN0X2VtcHR5KCZwbGNoYW4tPmRlc2NfbGlzdCkpIHsKKwlpZiAoIWxpc3RfZW1wdHkoJnBsY2hhbi0+cGVuZF9saXN0KSkgewogCQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUodHhkaSwKLQkJCQkJIG5leHQsICZwbGNoYW4tPmRlc2NfbGlzdCwgbm9kZSkgeworCQkJCQkgbmV4dCwgJnBsY2hhbi0+cGVuZF9saXN0LCBub2RlKSB7CiAJCQlsaXN0X2RlbCgmdHhkaS0+bm9kZSk7CiAJCQlwbDA4eF9mcmVlX3R4ZChwbDA4eCwgdHhkaSk7CiAJCX0KLQogCX0KIH0KIApAQCAtMTA2OSw2ICs5MjIsMTIgQEAKIAkJCXJldHVybiAtRUJVU1k7CiAJCX0KIAkJY2gtPnNpZ25hbCA9IHJldDsKKworCQkvKiBBc3NpZ24gdGhlIGZsb3cgY29udHJvbCBzaWduYWwgdG8gdGhpcyBjaGFubmVsICovCisJCWlmICh0eGQtPmRpcmVjdGlvbiA9PSBETUFfVE9fREVWSUNFKQorCQkJdHhkLT5jY2ZnIHw9IGNoLT5zaWduYWwgPDwgUEwwODBfQ09ORklHX0RTVF9TRUxfU0hJRlQ7CisJCWVsc2UgaWYgKHR4ZC0+ZGlyZWN0aW9uID09IERNQV9GUk9NX0RFVklDRSkKKwkJCXR4ZC0+Y2NmZyB8PSBjaC0+c2lnbmFsIDw8IFBMMDgwX0NPTkZJR19TUkNfU0VMX1NISUZUOwogCX0KIAogCWRldl9kYmcoJnBsMDh4LT5hZGV2LT5kZXYsICJhbGxvY2F0ZWQgcGh5c2ljYWwgY2hhbm5lbCAlZCBhbmQgc2lnbmFsICVkIGZvciB4ZmVyIG9uICVzXG4iLApAQCAtMTA3NiwxOSArOTM1LDU0IEBACiAJCSBjaC0+c2lnbmFsLAogCQkgcGxjaGFuLT5uYW1lKTsKIAorCXBsY2hhbi0+cGh5Y2hhbl9ob2xkKys7CiAJcGxjaGFuLT5waHljaGFuID0gY2g7CiAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIHZvaWQgcmVsZWFzZV9waHlfY2hhbm5lbChzdHJ1Y3QgcGwwOHhfZG1hX2NoYW4gKnBsY2hhbikKK3sKKwlzdHJ1Y3QgcGwwOHhfZHJpdmVyX2RhdGEgKnBsMDh4ID0gcGxjaGFuLT5ob3N0OworCisJaWYgKChwbGNoYW4tPnBoeWNoYW4tPnNpZ25hbCA+PSAwKSAmJiBwbDA4eC0+cGQtPnB1dF9zaWduYWwpIHsKKwkJcGwwOHgtPnBkLT5wdXRfc2lnbmFsKHBsY2hhbik7CisJCXBsY2hhbi0+cGh5Y2hhbi0+c2lnbmFsID0gLTE7CisJfQorCXBsMDh4X3B1dF9waHlfY2hhbm5lbChwbDA4eCwgcGxjaGFuLT5waHljaGFuKTsKKwlwbGNoYW4tPnBoeWNoYW4gPSBOVUxMOworfQorCiBzdGF0aWMgZG1hX2Nvb2tpZV90IHBsMDh4X3R4X3N1Ym1pdChzdHJ1Y3QgZG1hX2FzeW5jX3R4X2Rlc2NyaXB0b3IgKnR4KQogewogCXN0cnVjdCBwbDA4eF9kbWFfY2hhbiAqcGxjaGFuID0gdG9fcGwwOHhfY2hhbih0eC0+Y2hhbik7CisJc3RydWN0IHBsMDh4X3R4ZCAqdHhkID0gdG9fcGwwOHhfdHhkKHR4KTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwogCi0JYXRvbWljX2luYygmcGxjaGFuLT5sYXN0X2lzc3VlZCk7Ci0JdHgtPmNvb2tpZSA9IGF0b21pY19yZWFkKCZwbGNoYW4tPmxhc3RfaXNzdWVkKTsKLQkvKiBUaGlzIHVubG9jayBmb2xsb3dzIHRoZSBsb2NrIGluIHRoZSBwcmVwKCkgZnVuY3Rpb24gKi8KLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwbGNoYW4tPmxvY2ssIHBsY2hhbi0+bG9ja2ZsYWdzKTsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmcGxjaGFuLT5sb2NrLCBmbGFncyk7CisKKwlwbGNoYW4tPmNoYW4uY29va2llICs9IDE7CisJaWYgKHBsY2hhbi0+Y2hhbi5jb29raWUgPCAwKQorCQlwbGNoYW4tPmNoYW4uY29va2llID0gMTsKKwl0eC0+Y29va2llID0gcGxjaGFuLT5jaGFuLmNvb2tpZTsKKworCS8qIFB1dCB0aGlzIG9udG8gdGhlIHBlbmRpbmcgbGlzdCAqLworCWxpc3RfYWRkX3RhaWwoJnR4ZC0+bm9kZSwgJnBsY2hhbi0+cGVuZF9saXN0KTsKKworCS8qCisJICogSWYgdGhlcmUgd2FzIG5vIHBoeXNpY2FsIGNoYW5uZWwgYXZhaWxhYmxlIGZvciB0aGlzIG1lbWNweSwKKwkgKiBzdGFjayB0aGUgcmVxdWVzdCB1cCBhbmQgaW5kaWNhdGUgdGhhdCB0aGUgY2hhbm5lbCBpcyB3YWl0aW5nCisJICogZm9yIGEgZnJlZSBwaHlzaWNhbCBjaGFubmVsLgorCSAqLworCWlmICghcGxjaGFuLT5zbGF2ZSAmJiAhcGxjaGFuLT5waHljaGFuKSB7CisJCS8qIERvIHRoaXMgbWVtY3B5IHdoZW5ldmVyIHRoZXJlIGlzIGEgY2hhbm5lbCByZWFkeSAqLworCQlwbGNoYW4tPnN0YXRlID0gUEwwOFhfQ0hBTl9XQUlUSU5HOworCQlwbGNoYW4tPndhaXRpbmcgPSB0eGQ7CisJfSBlbHNlIHsKKwkJcGxjaGFuLT5waHljaGFuX2hvbGQtLTsKKwl9CisKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwbGNoYW4tPmxvY2ssIGZsYWdzKTsKIAogCXJldHVybiB0eC0+Y29va2llOwogfQpAQCAtMTEwMiwxMCArOTk2LDkgQEAKIH0KIAogLyoKLSAqIENvZGUgYWNjZXNzaW5nIGRtYV9hc3luY19pc19jb21wbGV0ZSgpIGluIGEgdGlnaHQgbG9vcAotICogbWF5IGdpdmUgcHJvYmxlbXMgLSBjb3VsZCBzY2hlZHVsZSB3aGVyZSBpbmRpY2F0ZWQuCi0gKiBJZiBzbGF2ZXMgYXJlIHJlbHlpbmcgb24gaW50ZXJydXB0cyB0byBzaWduYWwgY29tcGxldGlvbiB0aGlzCi0gKiBmdW5jdGlvbiBtdXN0IG5vdCBiZSBjYWxsZWQgd2l0aCBpbnRlcnJ1cHRzIGRpc2FibGVkCisgKiBDb2RlIGFjY2Vzc2luZyBkbWFfYXN5bmNfaXNfY29tcGxldGUoKSBpbiBhIHRpZ2h0IGxvb3AgbWF5IGdpdmUgcHJvYmxlbXMuCisgKiBJZiBzbGF2ZXMgYXJlIHJlbHlpbmcgb24gaW50ZXJydXB0cyB0byBzaWduYWwgY29tcGxldGlvbiB0aGlzIGZ1bmN0aW9uCisgKiBtdXN0IG5vdCBiZSBjYWxsZWQgd2l0aCBpbnRlcnJ1cHRzIGRpc2FibGVkLgogICovCiBzdGF0aWMgZW51bSBkbWFfc3RhdHVzCiBwbDA4eF9kbWFfdHhfc3RhdHVzKHN0cnVjdCBkbWFfY2hhbiAqY2hhbiwKQEAgLTExMTgsNyArMTAxMSw3IEBACiAJZW51bSBkbWFfc3RhdHVzIHJldDsKIAl1MzIgYnl0ZXNsZWZ0ID0gMDsKIAotCWxhc3RfdXNlZCA9IGF0b21pY19yZWFkKCZwbGNoYW4tPmxhc3RfaXNzdWVkKTsKKwlsYXN0X3VzZWQgPSBwbGNoYW4tPmNoYW4uY29va2llOwogCWxhc3RfY29tcGxldGUgPSBwbGNoYW4tPmxjOwogCiAJcmV0ID0gZG1hX2FzeW5jX2lzX2NvbXBsZXRlKGNvb2tpZSwgbGFzdF9jb21wbGV0ZSwgbGFzdF91c2VkKTsKQEAgLTExMjgsMTMgKzEwMjEsOSBAQAogCX0KIAogCS8qCi0JICogc2NoZWR1bGUoKTsgY291bGQgYmUgaW5zZXJ0ZWQgaGVyZQotCSAqLwotCi0JLyoKIAkgKiBUaGlzIGNvb2tpZSBub3QgY29tcGxldGUgeWV0CiAJICovCi0JbGFzdF91c2VkID0gYXRvbWljX3JlYWQoJnBsY2hhbi0+bGFzdF9pc3N1ZWQpOworCWxhc3RfdXNlZCA9IHBsY2hhbi0+Y2hhbi5jb29raWU7CiAJbGFzdF9jb21wbGV0ZSA9IHBsY2hhbi0+bGM7CiAKIAkvKiBHZXQgbnVtYmVyIG9mIGJ5dGVzIGxlZnQgaW4gdGhlIGFjdGl2ZSB0cmFuc2FjdGlvbnMgYW5kIHF1ZXVlICovCkBAIC0xMTk5LDM3ICsxMDg4LDM1IEBACiAJfSwKIH07CiAKLXN0YXRpYyB2b2lkIGRtYV9zZXRfcnVudGltZV9jb25maWcoc3RydWN0IGRtYV9jaGFuICpjaGFuLAotCQkJICAgICAgIHN0cnVjdCBkbWFfc2xhdmVfY29uZmlnICpjb25maWcpCitzdGF0aWMgaW50IGRtYV9zZXRfcnVudGltZV9jb25maWcoc3RydWN0IGRtYV9jaGFuICpjaGFuLAorCQkJCSAgc3RydWN0IGRtYV9zbGF2ZV9jb25maWcgKmNvbmZpZykKIHsKIAlzdHJ1Y3QgcGwwOHhfZG1hX2NoYW4gKnBsY2hhbiA9IHRvX3BsMDh4X2NoYW4oY2hhbik7CiAJc3RydWN0IHBsMDh4X2RyaXZlcl9kYXRhICpwbDA4eCA9IHBsY2hhbi0+aG9zdDsKIAlzdHJ1Y3QgcGwwOHhfY2hhbm5lbF9kYXRhICpjZCA9IHBsY2hhbi0+Y2Q7CiAJZW51bSBkbWFfc2xhdmVfYnVzd2lkdGggYWRkcl93aWR0aDsKKwlkbWFfYWRkcl90IGFkZHI7CiAJdTMyIG1heGJ1cnN0OwogCXUzMiBjY3RsID0gMDsKLQkvKiBNYXNrIG91dCBhbGwgZXhjZXB0IHNyYyBhbmQgZHN0IGNoYW5uZWwgKi8KLQl1MzIgY2NmZyA9IGNkLT5jY2ZnICYgMHgwMDAwMDNERVU7Ci0JaW50IGkgPSAwOworCWludCBpOworCisJaWYgKCFwbGNoYW4tPnNsYXZlKQorCQlyZXR1cm4gLUVJTlZBTDsKIAogCS8qIFRyYW5zZmVyIGRpcmVjdGlvbiAqLwogCXBsY2hhbi0+cnVudGltZV9kaXJlY3Rpb24gPSBjb25maWctPmRpcmVjdGlvbjsKIAlpZiAoY29uZmlnLT5kaXJlY3Rpb24gPT0gRE1BX1RPX0RFVklDRSkgewotCQlwbGNoYW4tPnJ1bnRpbWVfYWRkciA9IGNvbmZpZy0+ZHN0X2FkZHI7Ci0JCWNjdGwgfD0gUEwwODBfQ09OVFJPTF9TUkNfSU5DUjsKLQkJY2NmZyB8PSBQTDA4MF9GTE9XX01FTTJQRVIgPDwgUEwwODBfQ09ORklHX0ZMT1dfQ09OVFJPTF9TSElGVDsKKwkJYWRkciA9IGNvbmZpZy0+ZHN0X2FkZHI7CiAJCWFkZHJfd2lkdGggPSBjb25maWctPmRzdF9hZGRyX3dpZHRoOwogCQltYXhidXJzdCA9IGNvbmZpZy0+ZHN0X21heGJ1cnN0OwogCX0gZWxzZSBpZiAoY29uZmlnLT5kaXJlY3Rpb24gPT0gRE1BX0ZST01fREVWSUNFKSB7Ci0JCXBsY2hhbi0+cnVudGltZV9hZGRyID0gY29uZmlnLT5zcmNfYWRkcjsKLQkJY2N0bCB8PSBQTDA4MF9DT05UUk9MX0RTVF9JTkNSOwotCQljY2ZnIHw9IFBMMDgwX0ZMT1dfUEVSMk1FTSA8PCBQTDA4MF9DT05GSUdfRkxPV19DT05UUk9MX1NISUZUOworCQlhZGRyID0gY29uZmlnLT5zcmNfYWRkcjsKIAkJYWRkcl93aWR0aCA9IGNvbmZpZy0+c3JjX2FkZHJfd2lkdGg7CiAJCW1heGJ1cnN0ID0gY29uZmlnLT5zcmNfbWF4YnVyc3Q7CiAJfSBlbHNlIHsKIAkJZGV2X2VycigmcGwwOHgtPmFkZXYtPmRldiwKIAkJCSJiYWQgcnVudGltZV9jb25maWc6IGFsaWVuIHRyYW5zZmVyIGRpcmVjdGlvblxuIik7Ci0JCXJldHVybjsKKwkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCiAJc3dpdGNoIChhZGRyX3dpZHRoKSB7CkBAIC0xMjQ4LDQyICsxMTM1LDQwIEBACiAJZGVmYXVsdDoKIAkJZGV2X2VycigmcGwwOHgtPmFkZXYtPmRldiwKIAkJCSJiYWQgcnVudGltZV9jb25maWc6IGFsaWVuIGFkZHJlc3Mgd2lkdGhcbiIpOwotCQlyZXR1cm47CisJCXJldHVybiAtRUlOVkFMOwogCX0KIAogCS8qCiAJICogTm93IGRlY2lkZSBvbiBhIG1heGJ1cnN0OgotCSAqIElmIHRoaXMgY2hhbm5lbCB3aWxsIG9ubHkgcmVxdWVzdCBzaW5nbGUgdHJhbnNmZXJzLCBzZXQKLQkgKiB0aGlzIGRvd24gdG8gT05FIGVsZW1lbnQuCisJICogSWYgdGhpcyBjaGFubmVsIHdpbGwgb25seSByZXF1ZXN0IHNpbmdsZSB0cmFuc2ZlcnMsIHNldCB0aGlzCisJICogZG93biB0byBPTkUgZWxlbWVudC4gIEFsc28gc2VsZWN0IG9uZSBlbGVtZW50IGlmIG5vIG1heGJ1cnN0CisJICogaXMgc3BlY2lmaWVkLgogCSAqLwotCWlmIChwbGNoYW4tPmNkLT5zaW5nbGUpIHsKKwlpZiAocGxjaGFuLT5jZC0+c2luZ2xlIHx8IG1heGJ1cnN0ID09IDApIHsKIAkJY2N0bCB8PSAoUEwwODBfQlNJWkVfMSA8PCBQTDA4MF9DT05UUk9MX1NCX1NJWkVfU0hJRlQpIHwKIAkJCShQTDA4MF9CU0laRV8xIDw8IFBMMDgwX0NPTlRST0xfREJfU0laRV9TSElGVCk7CiAJfSBlbHNlIHsKLQkJd2hpbGUgKGkgPCBBUlJBWV9TSVpFKGJ1cnN0X3NpemVzKSkgeworCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShidXJzdF9zaXplcyk7IGkrKykKIAkJCWlmIChidXJzdF9zaXplc1tpXS5idXJzdHdvcmRzIDw9IG1heGJ1cnN0KQogCQkJCWJyZWFrOwotCQkJaSsrOwotCQl9CiAJCWNjdGwgfD0gYnVyc3Rfc2l6ZXNbaV0ucmVnOwogCX0KIAotCS8qIEFjY2VzcyB0aGUgY2VsbCBpbiBwcml2aWxlZ2VkIG1vZGUsIG5vbi1idWZmZXJhYmxlLCBub24tY2FjaGVhYmxlICovCi0JY2N0bCAmPSB+UEwwODBfQ09OVFJPTF9QUk9UX01BU0s7Ci0JY2N0bCB8PSBQTDA4MF9DT05UUk9MX1BST1RfU1lTOworCXBsY2hhbi0+cnVudGltZV9hZGRyID0gYWRkcjsKIAogCS8qIE1vZGlmeSB0aGUgZGVmYXVsdCBjaGFubmVsIGRhdGEgdG8gZml0IFByaW1lQ2VsbCByZXF1ZXN0ICovCiAJY2QtPmNjdGwgPSBjY3RsOwotCWNkLT5jY2ZnID0gY2NmZzsKIAogCWRldl9kYmcoJnBsMDh4LT5hZGV2LT5kZXYsCiAJCSJjb25maWd1cmVkIGNoYW5uZWwgJXMgKCVzKSBmb3IgJXMsIGRhdGEgd2lkdGggJWQsICIKLQkJIm1heGJ1cnN0ICVkIHdvcmRzLCBMRSwgQ0NUTD0lMDh4LCBDQ0ZHPSUwOHhcbiIsCisJCSJtYXhidXJzdCAlZCB3b3JkcywgTEUsIENDVEw9MHglMDh4XG4iLAogCQlkbWFfY2hhbl9uYW1lKGNoYW4pLCBwbGNoYW4tPm5hbWUsCiAJCShjb25maWctPmRpcmVjdGlvbiA9PSBETUFfRlJPTV9ERVZJQ0UpID8gIlJYIiA6ICJUWCIsCiAJCWFkZHJfd2lkdGgsCiAJCW1heGJ1cnN0LAotCQljY3RsLCBjY2ZnKTsKKwkJY2N0bCk7CisKKwlyZXR1cm4gMDsKIH0KIAogLyoKQEAgLTEyOTMsMzUgKzExNzgsMjYgQEAKIHN0YXRpYyB2b2lkIHBsMDh4X2lzc3VlX3BlbmRpbmcoc3RydWN0IGRtYV9jaGFuICpjaGFuKQogewogCXN0cnVjdCBwbDA4eF9kbWFfY2hhbiAqcGxjaGFuID0gdG9fcGwwOHhfY2hhbihjaGFuKTsKLQlzdHJ1Y3QgcGwwOHhfZHJpdmVyX2RhdGEgKnBsMDh4ID0gcGxjaGFuLT5ob3N0OwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmcGxjaGFuLT5sb2NrLCBmbGFncyk7Ci0JLyogU29tZXRoaW5nIGlzIGFscmVhZHkgYWN0aXZlICovCi0JaWYgKHBsY2hhbi0+YXQpIHsKLQkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBsY2hhbi0+bG9jaywgZmxhZ3MpOwotCQkJcmV0dXJuOworCS8qIFNvbWV0aGluZyBpcyBhbHJlYWR5IGFjdGl2ZSwgb3Igd2UncmUgd2FpdGluZyBmb3IgYSBjaGFubmVsLi4uICovCisJaWYgKHBsY2hhbi0+YXQgfHwgcGxjaGFuLT5zdGF0ZSA9PSBQTDA4WF9DSEFOX1dBSVRJTkcpIHsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcGxjaGFuLT5sb2NrLCBmbGFncyk7CisJCXJldHVybjsKIAl9CiAKLQkvKiBEaWRuJ3QgZ2V0IGEgcGh5c2ljYWwgY2hhbm5lbCBzbyB3YWl0aW5nIGZvciBpdCAuLi4gKi8KLQlpZiAocGxjaGFuLT5zdGF0ZSA9PSBQTDA4WF9DSEFOX1dBSVRJTkcpCi0JCXJldHVybjsKLQogCS8qIFRha2UgdGhlIGZpcnN0IGVsZW1lbnQgaW4gdGhlIHF1ZXVlIGFuZCBleGVjdXRlIGl0ICovCi0JaWYgKCFsaXN0X2VtcHR5KCZwbGNoYW4tPmRlc2NfbGlzdCkpIHsKKwlpZiAoIWxpc3RfZW1wdHkoJnBsY2hhbi0+cGVuZF9saXN0KSkgewogCQlzdHJ1Y3QgcGwwOHhfdHhkICpuZXh0OwogCi0JCW5leHQgPSBsaXN0X2ZpcnN0X2VudHJ5KCZwbGNoYW4tPmRlc2NfbGlzdCwKKwkJbmV4dCA9IGxpc3RfZmlyc3RfZW50cnkoJnBsY2hhbi0+cGVuZF9saXN0LAogCQkJCQlzdHJ1Y3QgcGwwOHhfdHhkLAogCQkJCQlub2RlKTsKIAkJbGlzdF9kZWwoJm5leHQtPm5vZGUpOwotCQlwbGNoYW4tPmF0ID0gbmV4dDsKIAkJcGxjaGFuLT5zdGF0ZSA9IFBMMDhYX0NIQU5fUlVOTklORzsKIAotCQkvKiBDb25maWd1cmUgdGhlIHBoeXNpY2FsIGNoYW5uZWwgZm9yIHRoZSBhY3RpdmUgdHhkICovCi0JCXBsMDh4X2NvbmZpZ19waHljaGFuX2Zvcl90eGQocGxjaGFuKTsKLQkJcGwwOHhfc2V0X2NyZWdzKHBsMDh4LCBwbGNoYW4tPnBoeWNoYW4pOwotCQlwbDA4eF9lbmFibGVfcGh5X2NoYW4ocGwwOHgsIHBsY2hhbi0+cGh5Y2hhbik7CisJCXBsMDh4X3N0YXJ0X3R4ZChwbGNoYW4sIG5leHQpOwogCX0KIAogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBsY2hhbi0+bG9jaywgZmxhZ3MpOwpAQCAtMTMzMCwzMCArMTIwNiwxNyBAQAogc3RhdGljIGludCBwbDA4eF9wcmVwX2NoYW5uZWxfcmVzb3VyY2VzKHN0cnVjdCBwbDA4eF9kbWFfY2hhbiAqcGxjaGFuLAogCQkJCQlzdHJ1Y3QgcGwwOHhfdHhkICp0eGQpCiB7Ci0JaW50IG51bV9sbGlzOwogCXN0cnVjdCBwbDA4eF9kcml2ZXJfZGF0YSAqcGwwOHggPSBwbGNoYW4tPmhvc3Q7Ci0JaW50IHJldDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCBudW1fbGxpcywgcmV0OwogCiAJbnVtX2xsaXMgPSBwbDA4eF9maWxsX2xsaXNfZm9yX2Rlc2MocGwwOHgsIHR4ZCk7Ci0KLQlpZiAoIW51bV9sbGlzKQorCWlmICghbnVtX2xsaXMpIHsKKwkJa2ZyZWUodHhkKTsKIAkJcmV0dXJuIC1FSU5WQUw7CisJfQogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJnBsY2hhbi0+bG9jaywgcGxjaGFuLT5sb2NrZmxhZ3MpOwotCi0JLyoKLQkgKiBJZiB0aGlzIGRldmljZSBpcyBub3QgdXNpbmcgYSBjaXJjdWxhciBidWZmZXIgdGhlbgotCSAqIHF1ZXVlIHRoaXMgbmV3IGRlc2NyaXB0b3IgZm9yIHRyYW5zZmVyLgotCSAqIFRoZSBkZXNjcmlwdG9yIGZvciBhIGNpcmN1bGFyIGJ1ZmZlciBjb250aW51ZXMKLQkgKiB0byBiZSB1c2VkIHVudGlsIHRoZSBjaGFubmVsIGlzIGZyZWVkLgotCSAqLwotCWlmICh0eGQtPmNkLT5jaXJjdWxhcl9idWZmZXIpCi0JCWRldl9lcnIoJnBsMDh4LT5hZGV2LT5kZXYsCi0JCQkiJXMgYXR0ZW1wdGluZyB0byBxdWV1ZSBhIGNpcmN1bGFyIGJ1ZmZlclxuIiwKLQkJCV9fZnVuY19fKTsKLQllbHNlCi0JCWxpc3RfYWRkX3RhaWwoJnR4ZC0+bm9kZSwKLQkJCSAgICAgICZwbGNoYW4tPmRlc2NfbGlzdCk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJnBsY2hhbi0+bG9jaywgZmxhZ3MpOwogCiAJLyoKIAkgKiBTZWUgaWYgd2UgYWxyZWFkeSBoYXZlIGEgcGh5c2ljYWwgY2hhbm5lbCBhbGxvY2F0ZWQsCkBAIC0xMzYyLDQ1ICsxMjI1LDc0IEBACiAJcmV0ID0gcHJlcF9waHlfY2hhbm5lbChwbGNoYW4sIHR4ZCk7CiAJaWYgKHJldCkgewogCQkvKgotCQkgKiBObyBwaHlzaWNhbCBjaGFubmVsIGF2YWlsYWJsZSwgd2Ugd2lsbAotCQkgKiBzdGFjayB1cCB0aGUgbWVtY3B5IGNoYW5uZWxzIHVudGlsIHRoZXJlIGlzIGEgY2hhbm5lbAotCQkgKiBhdmFpbGFibGUgdG8gaGFuZGxlIGl0IHdoZXJlYXMgc2xhdmUgdHJhbnNmZXJzIG1heQotCQkgKiBoYXZlIGJlZW4gZGVuaWVkIGR1ZSB0byBwbGF0Zm9ybSBjaGFubmVsIG11eGluZyByZXN0cmljdGlvbnMKLQkJICogYW5kIHNpbmNlIHRoZXJlIGlzIG5vIGd1YXJhbnRlZSB0aGF0IHRoaXMgd2lsbCBldmVyIGJlCi0JCSAqIHJlc29sdmVkLCBhbmQgc2luY2UgdGhlIHNpZ25hbCBtdXN0IGJlIGFxdWlyZWQgQUZURVIKLQkJICogYXF1aXJpbmcgdGhlIHBoeXNpY2FsIGNoYW5uZWwsIHdlIHdpbGwgbGV0IHRoZW0gYmUgTkFDSzplZAotCQkgKiB3aXRoIC1FQlVTWSBoZXJlLiBUaGUgZHJpdmVycyBjYW4gYWx3YXkgcmV0cnkgdGhlIHByZXAoKQotCQkgKiBjYWxsIGlmIHRoZXkgYXJlIGVhZ2VyIG9uIGRvaW5nIHRoaXMgdXNpbmcgRE1BLgorCQkgKiBObyBwaHlzaWNhbCBjaGFubmVsIHdhcyBhdmFpbGFibGUuCisJCSAqCisJCSAqIG1lbWNweSB0cmFuc2ZlcnMgY2FuIGJlIHNvcnRlZCBvdXQgYXQgc3VibWlzc2lvbiB0aW1lLgorCQkgKgorCQkgKiBTbGF2ZSB0cmFuc2ZlcnMgbWF5IGhhdmUgYmVlbiBkZW5pZWQgZHVlIHRvIHBsYXRmb3JtCisJCSAqIGNoYW5uZWwgbXV4aW5nIHJlc3RyaWN0aW9ucy4gIFNpbmNlIHRoZXJlIGlzIG5vIGd1YXJhbnRlZQorCQkgKiB0aGF0IHRoaXMgd2lsbCBldmVyIGJlIHJlc29sdmVkLCBhbmQgdGhlIHNpZ25hbCBtdXN0IGJlCisJCSAqIGFjcXVpcmVkIEFGVEVSIGFjcXVpcmluZyB0aGUgcGh5c2ljYWwgY2hhbm5lbCwgd2Ugd2lsbCBsZXQKKwkJICogdGhlbSBiZSBOQUNLOmVkIHdpdGggLUVCVVNZIGhlcmUuIFRoZSBkcml2ZXJzIGNhbiByZXRyeQorCQkgKiB0aGUgcHJlcCgpIGNhbGwgaWYgdGhleSBhcmUgZWFnZXIgb24gZG9pbmcgdGhpcyB1c2luZyBETUEuCiAJCSAqLwogCQlpZiAocGxjaGFuLT5zbGF2ZSkgewogCQkJcGwwOHhfZnJlZV90eGRfbGlzdChwbDA4eCwgcGxjaGFuKTsKLQkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBsY2hhbi0+bG9jaywgcGxjaGFuLT5sb2NrZmxhZ3MpOworCQkJcGwwOHhfZnJlZV90eGQocGwwOHgsIHR4ZCk7CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwbGNoYW4tPmxvY2ssIGZsYWdzKTsKIAkJCXJldHVybiAtRUJVU1k7CiAJCX0KLQkJLyogRG8gdGhpcyBtZW1jcHkgd2hlbmV2ZXIgdGhlcmUgaXMgYSBjaGFubmVsIHJlYWR5ICovCi0JCXBsY2hhbi0+c3RhdGUgPSBQTDA4WF9DSEFOX1dBSVRJTkc7Ci0JCXBsY2hhbi0+d2FpdGluZyA9IHR4ZDsKIAl9IGVsc2UKIAkJLyoKLQkJICogRWxzZSB3ZSdyZSBhbGwgc2V0LCBwYXVzZWQgYW5kIHJlYWR5IHRvIHJvbGwsCi0JCSAqIHN0YXR1cyB3aWxsIHN3aXRjaCB0byBQTDA4WF9DSEFOX1JVTk5JTkcgd2hlbgotCQkgKiB3ZSBjYWxsIGlzc3VlX3BlbmRpbmcoKS4gSWYgdGhlcmUgaXMgc29tZXRoaW5nCi0JCSAqIHJ1bm5pbmcgb24gdGhlIGNoYW5uZWwgYWxyZWFkeSB3ZSBkb24ndCBjaGFuZ2UKLQkJICogaXRzIHN0YXRlLgorCQkgKiBFbHNlIHdlJ3JlIGFsbCBzZXQsIHBhdXNlZCBhbmQgcmVhZHkgdG8gcm9sbCwgc3RhdHVzCisJCSAqIHdpbGwgc3dpdGNoIHRvIFBMMDhYX0NIQU5fUlVOTklORyB3aGVuIHdlIGNhbGwKKwkJICogaXNzdWVfcGVuZGluZygpLiBJZiB0aGVyZSBpcyBzb21ldGhpbmcgcnVubmluZyBvbiB0aGUKKwkJICogY2hhbm5lbCBhbHJlYWR5IHdlIGRvbid0IGNoYW5nZSBpdHMgc3RhdGUuCiAJCSAqLwogCQlpZiAocGxjaGFuLT5zdGF0ZSA9PSBQTDA4WF9DSEFOX0lETEUpCiAJCQlwbGNoYW4tPnN0YXRlID0gUEwwOFhfQ0hBTl9QQVVTRUQ7CiAKLQkvKgotCSAqIE5vdGljZSB0aGF0IHdlIGxlYXZlIHBsY2hhbi0+bG9jayBsb2NrZWQgb24gcHVycG9zZToKLQkgKiBpdCB3aWxsIGJlIHVubG9ja2VkIGluIHRoZSBzdWJzZXF1ZW50IHR4X3N1Ym1pdCgpCi0JICogY2FsbC4gVGhpcyBpcyBhIGNvbnNlcXVlbmNlIG9mIHRoZSBjdXJyZW50IEFQSS4KLQkgKi8KKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwbGNoYW4tPmxvY2ssIGZsYWdzKTsKIAogCXJldHVybiAwOwogfQogCiAvKgorICogR2l2ZW4gdGhlIHNvdXJjZSBhbmQgZGVzdGluYXRpb24gYXZhaWxhYmxlIGJ1cyBtYXNrcywgc2VsZWN0IHdoaWNoCisgKiB3aWxsIGJlIHJvdXRlZCB0byBlYWNoIHBvcnQuICBXZSB0cnkgdG8gaGF2ZSBzb3VyY2UgYW5kIGRlc3RpbmF0aW9uCisgKiBvbiBzZXBhcmF0ZSBwb3J0cywgYnV0IGFsd2F5cyByZXNwZWN0IHRoZSBhbGxvd2FibGUgc2V0dGluZ3MuCisgKi8KK3N0YXRpYyB1MzIgcGwwOHhfc2VsZWN0X2J1cyhzdHJ1Y3QgcGwwOHhfZHJpdmVyX2RhdGEgKnBsMDh4LCB1OCBzcmMsIHU4IGRzdCkKK3sKKwl1MzIgY2N0bCA9IDA7CisKKwlpZiAoIShkc3QgJiBQTDA4WF9BSEIxKSB8fCAoKGRzdCAmIFBMMDhYX0FIQjIpICYmIChzcmMgJiBQTDA4WF9BSEIxKSkpCisJCWNjdGwgfD0gUEwwODBfQ09OVFJPTF9EU1RfQUhCMjsKKwlpZiAoIShzcmMgJiBQTDA4WF9BSEIxKSB8fCAoKHNyYyAmIFBMMDhYX0FIQjIpICYmICEoZHN0ICYgUEwwOFhfQUhCMikpKQorCQljY3RsIHw9IFBMMDgwX0NPTlRST0xfU1JDX0FIQjI7CisKKwlyZXR1cm4gY2N0bDsKK30KKworc3RhdGljIHN0cnVjdCBwbDA4eF90eGQgKnBsMDh4X2dldF90eGQoc3RydWN0IHBsMDh4X2RtYV9jaGFuICpwbGNoYW4sCisJdW5zaWduZWQgbG9uZyBmbGFncykKK3sKKwlzdHJ1Y3QgcGwwOHhfdHhkICp0eGQgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgcGwwOHhfdHhkKSwgR0ZQX05PV0FJVCk7CisKKwlpZiAodHhkKSB7CisJCWRtYV9hc3luY190eF9kZXNjcmlwdG9yX2luaXQoJnR4ZC0+dHgsICZwbGNoYW4tPmNoYW4pOworCQl0eGQtPnR4LmZsYWdzID0gZmxhZ3M7CisJCXR4ZC0+dHgudHhfc3VibWl0ID0gcGwwOHhfdHhfc3VibWl0OworCQlJTklUX0xJU1RfSEVBRCgmdHhkLT5ub2RlKTsKKworCQkvKiBBbHdheXMgZW5hYmxlIGVycm9yIGFuZCB0ZXJtaW5hbCBpbnRlcnJ1cHRzICovCisJCXR4ZC0+Y2NmZyA9IFBMMDgwX0NPTkZJR19FUlJfSVJRX01BU0sgfAorCQkJICAgIFBMMDgwX0NPTkZJR19UQ19JUlFfTUFTSzsKKwl9CisJcmV0dXJuIHR4ZDsKK30KKworLyoKICAqIEluaXRpYWxpemUgYSBkZXNjcmlwdG9yIHRvIGJlIHVzZWQgYnkgbWVtY3B5IHN1Ym1pdAogICovCiBzdGF0aWMgc3RydWN0IGRtYV9hc3luY190eF9kZXNjcmlwdG9yICpwbDA4eF9wcmVwX2RtYV9tZW1jcHkoCkBAIC0xNDEyLDQwICsxMzA0LDM4IEBACiAJc3RydWN0IHBsMDh4X3R4ZCAqdHhkOwogCWludCByZXQ7CiAKLQl0eGQgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgcGwwOHhfdHhkKSwgR0ZQX05PV0FJVCk7CisJdHhkID0gcGwwOHhfZ2V0X3R4ZChwbGNoYW4sIGZsYWdzKTsKIAlpZiAoIXR4ZCkgewogCQlkZXZfZXJyKCZwbDA4eC0+YWRldi0+ZGV2LAogCQkJIiVzIG5vIG1lbW9yeSBmb3IgZGVzY3JpcHRvclxuIiwgX19mdW5jX18pOwogCQlyZXR1cm4gTlVMTDsKIAl9CiAKLQlkbWFfYXN5bmNfdHhfZGVzY3JpcHRvcl9pbml0KCZ0eGQtPnR4LCBjaGFuKTsKIAl0eGQtPmRpcmVjdGlvbiA9IERNQV9OT05FOwotCXR4ZC0+c3JjYnVzLmFkZHIgPSBzcmM7Ci0JdHhkLT5kc3RidXMuYWRkciA9IGRlc3Q7Ci0KLQkvKiBTZXQgcGxhdGZvcm0gZGF0YSBmb3IgbTJtICovCi0JdHhkLT5jZCA9ICZwbDA4eC0+cGQtPm1lbWNweV9jaGFubmVsOwotCS8qIEJvdGggdG8gYmUgaW5jcmVtZW50ZWQgb3IgdGhlIGNvZGUgd2lsbCBicmVhayAqLwotCXR4ZC0+Y2QtPmNjdGwgfD0gUEwwODBfQ09OVFJPTF9TUkNfSU5DUiB8IFBMMDgwX0NPTlRST0xfRFNUX0lOQ1I7Ci0JdHhkLT50eC50eF9zdWJtaXQgPSBwbDA4eF90eF9zdWJtaXQ7Ci0JdHhkLT50eC5jYWxsYmFjayA9IE5VTEw7Ci0JdHhkLT50eC5jYWxsYmFja19wYXJhbSA9IE5VTEw7CisJdHhkLT5zcmNfYWRkciA9IHNyYzsKKwl0eGQtPmRzdF9hZGRyID0gZGVzdDsKIAl0eGQtPmxlbiA9IGxlbjsKIAotCUlOSVRfTElTVF9IRUFEKCZ0eGQtPm5vZGUpOworCS8qIFNldCBwbGF0Zm9ybSBkYXRhIGZvciBtMm0gKi8KKwl0eGQtPmNjZmcgfD0gUEwwODBfRkxPV19NRU0yTUVNIDw8IFBMMDgwX0NPTkZJR19GTE9XX0NPTlRST0xfU0hJRlQ7CisJdHhkLT5jY3RsID0gcGwwOHgtPnBkLT5tZW1jcHlfY2hhbm5lbC5jY3RsICYKKwkJCX4oUEwwODBfQ09OVFJPTF9EU1RfQUhCMiB8IFBMMDgwX0NPTlRST0xfU1JDX0FIQjIpOworCisJLyogQm90aCB0byBiZSBpbmNyZW1lbnRlZCBvciB0aGUgY29kZSB3aWxsIGJyZWFrICovCisJdHhkLT5jY3RsIHw9IFBMMDgwX0NPTlRST0xfU1JDX0lOQ1IgfCBQTDA4MF9DT05UUk9MX0RTVF9JTkNSOworCisJaWYgKHBsMDh4LT52ZC0+ZHVhbG1hc3RlcikKKwkJdHhkLT5jY3RsIHw9IHBsMDh4X3NlbGVjdF9idXMocGwwOHgsCisJCQkJCXBsMDh4LT5tZW1fYnVzZXMsIHBsMDh4LT5tZW1fYnVzZXMpOworCiAJcmV0ID0gcGwwOHhfcHJlcF9jaGFubmVsX3Jlc291cmNlcyhwbGNoYW4sIHR4ZCk7CiAJaWYgKHJldCkKIAkJcmV0dXJuIE5VTEw7Ci0JLyoKLQkgKiBOQjogdGhlIGNoYW5uZWwgbG9jayBpcyBoZWxkIGF0IHRoaXMgcG9pbnQgc28gdHhfc3VibWl0KCkKLQkgKiBtdXN0IGJlIGNhbGxlZCBpbiBkaXJlY3Qgc3VjY2Vzc2lvbi4KLQkgKi8KIAogCXJldHVybiAmdHhkLT50eDsKIH0KIAotc3RydWN0IGRtYV9hc3luY190eF9kZXNjcmlwdG9yICpwbDA4eF9wcmVwX3NsYXZlX3NnKAorc3RhdGljIHN0cnVjdCBkbWFfYXN5bmNfdHhfZGVzY3JpcHRvciAqcGwwOHhfcHJlcF9zbGF2ZV9zZygKIAkJc3RydWN0IGRtYV9jaGFuICpjaGFuLCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnbCwKIAkJdW5zaWduZWQgaW50IHNnX2xlbiwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyZWN0aW9uLAogCQl1bnNpZ25lZCBsb25nIGZsYWdzKQpAQCAtMTQ1Myw2ICsxMzQzLDcgQEAKIAlzdHJ1Y3QgcGwwOHhfZG1hX2NoYW4gKnBsY2hhbiA9IHRvX3BsMDh4X2NoYW4oY2hhbik7CiAJc3RydWN0IHBsMDh4X2RyaXZlcl9kYXRhICpwbDA4eCA9IHBsY2hhbi0+aG9zdDsKIAlzdHJ1Y3QgcGwwOHhfdHhkICp0eGQ7CisJdTggc3JjX2J1c2VzLCBkc3RfYnVzZXM7CiAJaW50IHJldDsKIAogCS8qCkBAIC0xNDY3LDE0ICsxMzU4LDEyIEBACiAJZGV2X2RiZygmcGwwOHgtPmFkZXYtPmRldiwgIiVzIHByZXBhcmUgdHJhbnNhY3Rpb24gb2YgJWQgYnl0ZXMgZnJvbSAlc1xuIiwKIAkJX19mdW5jX18sIHNnbC0+bGVuZ3RoLCBwbGNoYW4tPm5hbWUpOwogCi0JdHhkID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHBsMDh4X3R4ZCksIEdGUF9OT1dBSVQpOworCXR4ZCA9IHBsMDh4X2dldF90eGQocGxjaGFuLCBmbGFncyk7CiAJaWYgKCF0eGQpIHsKIAkJZGV2X2VycigmcGwwOHgtPmFkZXYtPmRldiwgIiVzIG5vIHR4ZFxuIiwgX19mdW5jX18pOwogCQlyZXR1cm4gTlVMTDsKIAl9CiAKLQlkbWFfYXN5bmNfdHhfZGVzY3JpcHRvcl9pbml0KCZ0eGQtPnR4LCBjaGFuKTsKLQogCWlmIChkaXJlY3Rpb24gIT0gcGxjaGFuLT5ydW50aW1lX2RpcmVjdGlvbikKIAkJZGV2X2VycigmcGwwOHgtPmFkZXYtPmRldiwgIiVzIERNQSBzZXR1cCBkb2VzIG5vdCBtYXRjaCAiCiAJCQkidGhlIGRpcmVjdGlvbiBjb25maWd1cmVkIGZvciB0aGUgUHJpbWVDZWxsXG4iLApAQCAtMTQ4NiwzNyArMTM3NSw0NyBAQAogCSAqIGNoYW5uZWwgdGFyZ2V0IGFkZHJlc3MgZHluYW1pY2FsbHkgYXQgcnVudGltZS4KIAkgKi8KIAl0eGQtPmRpcmVjdGlvbiA9IGRpcmVjdGlvbjsKKwl0eGQtPmxlbiA9IHNnbC0+bGVuZ3RoOworCisJdHhkLT5jY3RsID0gcGxjaGFuLT5jZC0+Y2N0bCAmCisJCQl+KFBMMDgwX0NPTlRST0xfU1JDX0FIQjIgfCBQTDA4MF9DT05UUk9MX0RTVF9BSEIyIHwKKwkJCSAgUEwwODBfQ09OVFJPTF9TUkNfSU5DUiB8IFBMMDgwX0NPTlRST0xfRFNUX0lOQ1IgfAorCQkJICBQTDA4MF9DT05UUk9MX1BST1RfTUFTSyk7CisKKwkvKiBBY2Nlc3MgdGhlIGNlbGwgaW4gcHJpdmlsZWdlZCBtb2RlLCBub24tYnVmZmVyYWJsZSwgbm9uLWNhY2hlYWJsZSAqLworCXR4ZC0+Y2N0bCB8PSBQTDA4MF9DT05UUk9MX1BST1RfU1lTOworCiAJaWYgKGRpcmVjdGlvbiA9PSBETUFfVE9fREVWSUNFKSB7Ci0JCXR4ZC0+c3JjYnVzLmFkZHIgPSBzZ2wtPmRtYV9hZGRyZXNzOworCQl0eGQtPmNjZmcgfD0gUEwwODBfRkxPV19NRU0yUEVSIDw8IFBMMDgwX0NPTkZJR19GTE9XX0NPTlRST0xfU0hJRlQ7CisJCXR4ZC0+Y2N0bCB8PSBQTDA4MF9DT05UUk9MX1NSQ19JTkNSOworCQl0eGQtPnNyY19hZGRyID0gc2dsLT5kbWFfYWRkcmVzczsKIAkJaWYgKHBsY2hhbi0+cnVudGltZV9hZGRyKQotCQkJdHhkLT5kc3RidXMuYWRkciA9IHBsY2hhbi0+cnVudGltZV9hZGRyOworCQkJdHhkLT5kc3RfYWRkciA9IHBsY2hhbi0+cnVudGltZV9hZGRyOwogCQllbHNlCi0JCQl0eGQtPmRzdGJ1cy5hZGRyID0gcGxjaGFuLT5jZC0+YWRkcjsKKwkJCXR4ZC0+ZHN0X2FkZHIgPSBwbGNoYW4tPmNkLT5hZGRyOworCQlzcmNfYnVzZXMgPSBwbDA4eC0+bWVtX2J1c2VzOworCQlkc3RfYnVzZXMgPSBwbGNoYW4tPmNkLT5wZXJpcGhfYnVzZXM7CiAJfSBlbHNlIGlmIChkaXJlY3Rpb24gPT0gRE1BX0ZST01fREVWSUNFKSB7CisJCXR4ZC0+Y2NmZyB8PSBQTDA4MF9GTE9XX1BFUjJNRU0gPDwgUEwwODBfQ09ORklHX0ZMT1dfQ09OVFJPTF9TSElGVDsKKwkJdHhkLT5jY3RsIHw9IFBMMDgwX0NPTlRST0xfRFNUX0lOQ1I7CiAJCWlmIChwbGNoYW4tPnJ1bnRpbWVfYWRkcikKLQkJCXR4ZC0+c3JjYnVzLmFkZHIgPSBwbGNoYW4tPnJ1bnRpbWVfYWRkcjsKKwkJCXR4ZC0+c3JjX2FkZHIgPSBwbGNoYW4tPnJ1bnRpbWVfYWRkcjsKIAkJZWxzZQotCQkJdHhkLT5zcmNidXMuYWRkciA9IHBsY2hhbi0+Y2QtPmFkZHI7Ci0JCXR4ZC0+ZHN0YnVzLmFkZHIgPSBzZ2wtPmRtYV9hZGRyZXNzOworCQkJdHhkLT5zcmNfYWRkciA9IHBsY2hhbi0+Y2QtPmFkZHI7CisJCXR4ZC0+ZHN0X2FkZHIgPSBzZ2wtPmRtYV9hZGRyZXNzOworCQlzcmNfYnVzZXMgPSBwbGNoYW4tPmNkLT5wZXJpcGhfYnVzZXM7CisJCWRzdF9idXNlcyA9IHBsMDh4LT5tZW1fYnVzZXM7CiAJfSBlbHNlIHsKIAkJZGV2X2VycigmcGwwOHgtPmFkZXYtPmRldiwKIAkJCSIlcyBkaXJlY3Rpb24gdW5zdXBwb3J0ZWRcbiIsIF9fZnVuY19fKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQotCXR4ZC0+Y2QgPSBwbGNoYW4tPmNkOwotCXR4ZC0+dHgudHhfc3VibWl0ID0gcGwwOHhfdHhfc3VibWl0OwotCXR4ZC0+dHguY2FsbGJhY2sgPSBOVUxMOwotCXR4ZC0+dHguY2FsbGJhY2tfcGFyYW0gPSBOVUxMOwotCXR4ZC0+bGVuID0gc2dsLT5sZW5ndGg7Ci0JSU5JVF9MSVNUX0hFQUQoJnR4ZC0+bm9kZSk7CisKKwl0eGQtPmNjdGwgfD0gcGwwOHhfc2VsZWN0X2J1cyhwbDA4eCwgc3JjX2J1c2VzLCBkc3RfYnVzZXMpOwogCiAJcmV0ID0gcGwwOHhfcHJlcF9jaGFubmVsX3Jlc291cmNlcyhwbGNoYW4sIHR4ZCk7CiAJaWYgKHJldCkKIAkJcmV0dXJuIE5VTEw7Ci0JLyoKLQkgKiBOQjogdGhlIGNoYW5uZWwgbG9jayBpcyBoZWxkIGF0IHRoaXMgcG9pbnQgc28gdHhfc3VibWl0KCkKLQkgKiBtdXN0IGJlIGNhbGxlZCBpbiBkaXJlY3Qgc3VjY2Vzc2lvbi4KLQkgKi8KIAogCXJldHVybiAmdHhkLT50eDsKIH0KQEAgLTE1MzEsMTAgKzE0MzAsOCBAQAogCiAJLyogQ29udHJvbHMgYXBwbGljYWJsZSB0byBpbmFjdGl2ZSBjaGFubmVscyAqLwogCWlmIChjbWQgPT0gRE1BX1NMQVZFX0NPTkZJRykgewotCQlkbWFfc2V0X3J1bnRpbWVfY29uZmlnKGNoYW4sCi0JCQkJICAgICAgIChzdHJ1Y3QgZG1hX3NsYXZlX2NvbmZpZyAqKQotCQkJCSAgICAgICBhcmcpOwotCQlyZXR1cm4gMDsKKwkJcmV0dXJuIGRtYV9zZXRfcnVudGltZV9jb25maWcoY2hhbiwKKwkJCQkJICAgICAgKHN0cnVjdCBkbWFfc2xhdmVfY29uZmlnICopYXJnKTsKIAl9CiAKIAkvKgpAQCAtMTU1OCwxNiArMTQ1NSw4IEBACiAJCQkgKiBNYXJrIHBoeXNpY2FsIGNoYW5uZWwgYXMgZnJlZSBhbmQgZnJlZSBhbnkgc2xhdmUKIAkJCSAqIHNpZ25hbAogCQkJICovCi0JCQlpZiAoKHBsY2hhbi0+cGh5Y2hhbi0+c2lnbmFsID49IDApICYmCi0JCQkgICAgcGwwOHgtPnBkLT5wdXRfc2lnbmFsKSB7Ci0JCQkJcGwwOHgtPnBkLT5wdXRfc2lnbmFsKHBsY2hhbik7Ci0JCQkJcGxjaGFuLT5waHljaGFuLT5zaWduYWwgPSAtMTsKLQkJCX0KLQkJCXBsMDh4X3B1dF9waHlfY2hhbm5lbChwbDA4eCwgcGxjaGFuLT5waHljaGFuKTsKLQkJCXBsY2hhbi0+cGh5Y2hhbiA9IE5VTEw7CisJCQlyZWxlYXNlX3BoeV9jaGFubmVsKHBsY2hhbik7CiAJCX0KLQkJLyogU3RvcCBhbnkgcGVuZGluZyB0YXNrbGV0ICovCi0JCXRhc2tsZXRfZGlzYWJsZSgmcGxjaGFuLT50YXNrbGV0KTsKIAkJLyogRGVxdWV1ZSBqb2JzIGFuZCBmcmVlIExMSXMgKi8KIAkJaWYgKHBsY2hhbi0+YXQpIHsKIAkJCXBsMDh4X2ZyZWVfdHhkKHBsMDh4LCBwbGNoYW4tPmF0KTsKQEAgLTE2MDksMTAgKzE0OTgsOSBAQAogCiAvKgogICogSnVzdCBjaGVjayB0aGF0IHRoZSBkZXZpY2UgaXMgdGhlcmUgYW5kIGFjdGl2ZQotICogVE9ETzogdHVybiB0aGlzIGJpdCBvbi9vZmYgZGVwZW5kaW5nIG9uIHRoZSBudW1iZXIgb2YKLSAqIHBoeXNpY2FsIGNoYW5uZWxzIGFjdHVhbGx5IHVzZWQsIGlmIGl0IGlzIHplcm8uLi4gd2VsbAotICogc2h1dCBpdCBvZmYuIFRoYXQgd2lsbCBzYXZlIHNvbWUgcG93ZXIuIEN1dCB0aGUgY2xvY2sKLSAqIGF0IHRoZSBzYW1lIHRpbWUuCisgKiBUT0RPOiB0dXJuIHRoaXMgYml0IG9uL29mZiBkZXBlbmRpbmcgb24gdGhlIG51bWJlciBvZiBwaHlzaWNhbCBjaGFubmVscworICogYWN0dWFsbHkgdXNlZCwgaWYgaXQgaXMgemVyby4uLiB3ZWxsIHNodXQgaXQgb2ZmLiBUaGF0IHdpbGwgc2F2ZSBzb21lCisgKiBwb3dlci4gQ3V0IHRoZSBjbG9jayBhdCB0aGUgc2FtZSB0aW1lLgogICovCiBzdGF0aWMgdm9pZCBwbDA4eF9lbnN1cmVfb24oc3RydWN0IHBsMDh4X2RyaXZlcl9kYXRhICpwbDA4eCkKIHsKQEAgLTE2MjAsNzggKzE1MDgsNjYgQEAKIAogCXZhbCA9IHJlYWRsKHBsMDh4LT5iYXNlICsgUEwwODBfQ09ORklHKTsKIAl2YWwgJj0gfihQTDA4MF9DT05GSUdfTTJfQkUgfCBQTDA4MF9DT05GSUdfTTFfQkUgfCBQTDA4MF9DT05GSUdfRU5BQkxFKTsKLQkvKiBXZSBpbXBsaWN0bHkgY2xlYXIgYml0IDEgYW5kIHRoYXQgbWVhbnMgbGl0dGxlLWVuZGlhbiBtb2RlICovCisJLyogV2UgaW1wbGljaXRseSBjbGVhciBiaXQgMSBhbmQgdGhhdCBtZWFucyBsaXR0bGUtZW5kaWFuIG1vZGUgKi8KIAl2YWwgfD0gUEwwODBfQ09ORklHX0VOQUJMRTsKIAl3cml0ZWwodmFsLCBwbDA4eC0+YmFzZSArIFBMMDgwX0NPTkZJRyk7CiB9CiAKK3N0YXRpYyB2b2lkIHBsMDh4X3VubWFwX2J1ZmZlcnMoc3RydWN0IHBsMDh4X3R4ZCAqdHhkKQoreworCXN0cnVjdCBkZXZpY2UgKmRldiA9IHR4ZC0+dHguY2hhbi0+ZGV2aWNlLT5kZXY7CisKKwlpZiAoISh0eGQtPnR4LmZsYWdzICYgRE1BX0NPTVBMX1NLSVBfU1JDX1VOTUFQKSkgeworCQlpZiAodHhkLT50eC5mbGFncyAmIERNQV9DT01QTF9TUkNfVU5NQVBfU0lOR0xFKQorCQkJZG1hX3VubWFwX3NpbmdsZShkZXYsIHR4ZC0+c3JjX2FkZHIsIHR4ZC0+bGVuLAorCQkJCURNQV9UT19ERVZJQ0UpOworCQllbHNlCisJCQlkbWFfdW5tYXBfcGFnZShkZXYsIHR4ZC0+c3JjX2FkZHIsIHR4ZC0+bGVuLAorCQkJCURNQV9UT19ERVZJQ0UpOworCX0KKwlpZiAoISh0eGQtPnR4LmZsYWdzICYgRE1BX0NPTVBMX1NLSVBfREVTVF9VTk1BUCkpIHsKKwkJaWYgKHR4ZC0+dHguZmxhZ3MgJiBETUFfQ09NUExfREVTVF9VTk1BUF9TSU5HTEUpCisJCQlkbWFfdW5tYXBfc2luZ2xlKGRldiwgdHhkLT5kc3RfYWRkciwgdHhkLT5sZW4sCisJCQkJRE1BX0ZST01fREVWSUNFKTsKKwkJZWxzZQorCQkJZG1hX3VubWFwX3BhZ2UoZGV2LCB0eGQtPmRzdF9hZGRyLCB0eGQtPmxlbiwKKwkJCQlETUFfRlJPTV9ERVZJQ0UpOworCX0KK30KKwogc3RhdGljIHZvaWQgcGwwOHhfdGFza2xldCh1bnNpZ25lZCBsb25nIGRhdGEpCiB7CiAJc3RydWN0IHBsMDh4X2RtYV9jaGFuICpwbGNoYW4gPSAoc3RydWN0IHBsMDh4X2RtYV9jaGFuICopIGRhdGE7Ci0Jc3RydWN0IHBsMDh4X3BoeV9jaGFuICpwaHljaGFuID0gcGxjaGFuLT5waHljaGFuOwogCXN0cnVjdCBwbDA4eF9kcml2ZXJfZGF0YSAqcGwwOHggPSBwbGNoYW4tPmhvc3Q7CisJc3RydWN0IHBsMDh4X3R4ZCAqdHhkOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKLQlpZiAoIXBsY2hhbikKLQkJQlVHKCk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJnBsY2hhbi0+bG9jaywgZmxhZ3MpOwogCi0Jc3Bpbl9sb2NrKCZwbGNoYW4tPmxvY2spOworCXR4ZCA9IHBsY2hhbi0+YXQ7CisJcGxjaGFuLT5hdCA9IE5VTEw7CiAKLQlpZiAocGxjaGFuLT5hdCkgewotCQlkbWFfYXN5bmNfdHhfY2FsbGJhY2sgY2FsbGJhY2sgPQotCQkJcGxjaGFuLT5hdC0+dHguY2FsbGJhY2s7Ci0JCXZvaWQgKmNhbGxiYWNrX3BhcmFtID0KLQkJCXBsY2hhbi0+YXQtPnR4LmNhbGxiYWNrX3BhcmFtOwotCi0JCS8qCi0JCSAqIFVwZGF0ZSBsYXN0IGNvbXBsZXRlZAotCQkgKi8KLQkJcGxjaGFuLT5sYyA9Ci0JCQkocGxjaGFuLT5hdC0+dHguY29va2llKTsKLQotCQkvKgotCQkgKiBDYWxsYmFjayB0byBzaWduYWwgY29tcGxldGlvbgotCQkgKi8KLQkJaWYgKGNhbGxiYWNrKQotCQkJY2FsbGJhY2soY2FsbGJhY2tfcGFyYW0pOwotCi0JCS8qCi0JCSAqIERldmljZSBjYWxsYmFja3Mgc2hvdWxkIE5PVCBjbGVhcgotCQkgKiB0aGUgY3VycmVudCB0cmFuc2FjdGlvbiBvbiB0aGUgY2hhbm5lbAotCQkgKiBMaW51czogc29tZXRpbWVzIHRoZXkgc2hvdWxkPwotCQkgKi8KLQkJaWYgKCFwbGNoYW4tPmF0KQotCQkJQlVHKCk7Ci0KLQkJLyoKLQkJICogRnJlZSB0aGUgZGVzY3JpcHRvciBpZiBpdCdzIG5vdCBmb3IgYSBkZXZpY2UKLQkJICogdXNpbmcgYSBjaXJjdWxhciBidWZmZXIKLQkJICovCi0JCWlmICghcGxjaGFuLT5hdC0+Y2QtPmNpcmN1bGFyX2J1ZmZlcikgewotCQkJcGwwOHhfZnJlZV90eGQocGwwOHgsIHBsY2hhbi0+YXQpOwotCQkJcGxjaGFuLT5hdCA9IE5VTEw7Ci0JCX0KLQkJLyoKLQkJICogZWxzZSBkZXNjcmlwdG9yIGZvciBjaXJjdWxhcgotCQkgKiBidWZmZXJzIG9ubHkgZnJlZWQgd2hlbgotCQkgKiBjbGllbnQgaGFzIGRpc2FibGVkIGRtYQotCQkgKi8KKwlpZiAodHhkKSB7CisJCS8qIFVwZGF0ZSBsYXN0IGNvbXBsZXRlZCAqLworCQlwbGNoYW4tPmxjID0gdHhkLT50eC5jb29raWU7CiAJfQotCS8qCi0JICogSWYgYSBuZXcgZGVzY3JpcHRvciBpcyBxdWV1ZWQsIHNldCBpdCB1cAotCSAqIHBsY2hhbi0+YXQgaXMgTlVMTCBoZXJlCi0JICovCi0JaWYgKCFsaXN0X2VtcHR5KCZwbGNoYW4tPmRlc2NfbGlzdCkpIHsKKworCS8qIElmIGEgbmV3IGRlc2NyaXB0b3IgaXMgcXVldWVkLCBzZXQgaXQgdXAgcGxjaGFuLT5hdCBpcyBOVUxMIGhlcmUgKi8KKwlpZiAoIWxpc3RfZW1wdHkoJnBsY2hhbi0+cGVuZF9saXN0KSkgewogCQlzdHJ1Y3QgcGwwOHhfdHhkICpuZXh0OwogCi0JCW5leHQgPSBsaXN0X2ZpcnN0X2VudHJ5KCZwbGNoYW4tPmRlc2NfbGlzdCwKKwkJbmV4dCA9IGxpc3RfZmlyc3RfZW50cnkoJnBsY2hhbi0+cGVuZF9saXN0LAogCQkJCQlzdHJ1Y3QgcGwwOHhfdHhkLAogCQkJCQlub2RlKTsKIAkJbGlzdF9kZWwoJm5leHQtPm5vZGUpOwotCQlwbGNoYW4tPmF0ID0gbmV4dDsKLQkJLyogQ29uZmlndXJlIHRoZSBwaHlzaWNhbCBjaGFubmVsIGZvciB0aGUgbmV4dCB0eGQgKi8KLQkJcGwwOHhfY29uZmlnX3BoeWNoYW5fZm9yX3R4ZChwbGNoYW4pOwotCQlwbDA4eF9zZXRfY3JlZ3MocGwwOHgsIHBsY2hhbi0+cGh5Y2hhbik7Ci0JCXBsMDh4X2VuYWJsZV9waHlfY2hhbihwbDA4eCwgcGxjaGFuLT5waHljaGFuKTsKKworCQlwbDA4eF9zdGFydF90eGQocGxjaGFuLCBuZXh0KTsKKwl9IGVsc2UgaWYgKHBsY2hhbi0+cGh5Y2hhbl9ob2xkKSB7CisJCS8qCisJCSAqIFRoaXMgY2hhbm5lbCBpcyBzdGlsbCBpbiB1c2UgLSB3ZSBoYXZlIGEgbmV3IHR4ZCBiZWluZworCQkgKiBwcmVwYXJlZCBhbmQgd2lsbCBzb29uIGJlIHF1ZXVlZC4gIERvbid0IGdpdmUgdXAgdGhlCisJCSAqIHBoeXNpY2FsIGNoYW5uZWwuCisJCSAqLwogCX0gZWxzZSB7CiAJCXN0cnVjdCBwbDA4eF9kbWFfY2hhbiAqd2FpdGluZyA9IE5VTEw7CiAKQEAgLTE2OTksMjAgKzE1NzUsMTQgQEAKIAkJICogTm8gbW9yZSBqb2JzLCBzbyBmcmVlIHVwIHRoZSBwaHlzaWNhbCBjaGFubmVsCiAJCSAqIEZyZWUgYW55IGFsbG9jYXRlZCBzaWduYWwgb24gc2xhdmUgdHJhbnNmZXJzIHRvbwogCQkgKi8KLQkJaWYgKChwaHljaGFuLT5zaWduYWwgPj0gMCkgJiYgcGwwOHgtPnBkLT5wdXRfc2lnbmFsKSB7Ci0JCQlwbDA4eC0+cGQtPnB1dF9zaWduYWwocGxjaGFuKTsKLQkJCXBoeWNoYW4tPnNpZ25hbCA9IC0xOwotCQl9Ci0JCXBsMDh4X3B1dF9waHlfY2hhbm5lbChwbDA4eCwgcGh5Y2hhbik7Ci0JCXBsY2hhbi0+cGh5Y2hhbiA9IE5VTEw7CisJCXJlbGVhc2VfcGh5X2NoYW5uZWwocGxjaGFuKTsKIAkJcGxjaGFuLT5zdGF0ZSA9IFBMMDhYX0NIQU5fSURMRTsKIAogCQkvKgotCQkgKiBBbmQgTk9XIGJlZm9yZSBhbnlvbmUgZWxzZSBjYW4gZ3JhYiB0aGF0IGZyZWU6ZAotCQkgKiB1cCBwaHlzaWNhbCBjaGFubmVsLCBzZWUgaWYgdGhlcmUgaXMgc29tZSBtZW1jcHkKLQkJICogcGVuZGluZyB0aGF0IHNlcmlvdXNseSBuZWVkcyB0byBzdGFydCBiZWNhdXNlIG9mCi0JCSAqIGJlaW5nIHN0YWNrZWQgdXAgd2hpbGUgd2Ugd2VyZSBjaG9raW5nIHRoZQotCQkgKiBwaHlzaWNhbCBjaGFubmVscyB3aXRoIGRhdGEuCisJCSAqIEFuZCBOT1cgYmVmb3JlIGFueW9uZSBlbHNlIGNhbiBncmFiIHRoYXQgZnJlZTpkIHVwCisJCSAqIHBoeXNpY2FsIGNoYW5uZWwsIHNlZSBpZiB0aGVyZSBpcyBzb21lIG1lbWNweSBwZW5kaW5nCisJCSAqIHRoYXQgc2VyaW91c2x5IG5lZWRzIHRvIHN0YXJ0IGJlY2F1c2Ugb2YgYmVpbmcgc3RhY2tlZAorCQkgKiB1cCB3aGlsZSB3ZSB3ZXJlIGNob2tpbmcgdGhlIHBoeXNpY2FsIGNoYW5uZWxzIHdpdGggZGF0YS4KIAkJICovCiAJCWxpc3RfZm9yX2VhY2hfZW50cnkod2FpdGluZywgJnBsMDh4LT5tZW1jcHkuY2hhbm5lbHMsCiAJCQkJICAgIGNoYW4uZGV2aWNlX25vZGUpIHsKQEAgLTE3MjQsNiArMTU5NCw3IEBACiAJCQkJcmV0ID0gcHJlcF9waHlfY2hhbm5lbCh3YWl0aW5nLAogCQkJCQkJICAgICAgIHdhaXRpbmctPndhaXRpbmcpOwogCQkJCUJVR19PTihyZXQpOworCQkJCXdhaXRpbmctPnBoeWNoYW5faG9sZC0tOwogCQkJCXdhaXRpbmctPnN0YXRlID0gUEwwOFhfQ0hBTl9SVU5OSU5HOwogCQkJCXdhaXRpbmctPndhaXRpbmcgPSBOVUxMOwogCQkJCXBsMDh4X2lzc3VlX3BlbmRpbmcoJndhaXRpbmctPmNoYW4pOwpAQCAtMTczMiw3ICsxNjAzLDI1IEBACiAJCX0KIAl9CiAKLQlzcGluX3VubG9jaygmcGxjaGFuLT5sb2NrKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwbGNoYW4tPmxvY2ssIGZsYWdzKTsKKworCWlmICh0eGQpIHsKKwkJZG1hX2FzeW5jX3R4X2NhbGxiYWNrIGNhbGxiYWNrID0gdHhkLT50eC5jYWxsYmFjazsKKwkJdm9pZCAqY2FsbGJhY2tfcGFyYW0gPSB0eGQtPnR4LmNhbGxiYWNrX3BhcmFtOworCisJCS8qIERvbid0IHRyeSB0byB1bm1hcCBidWZmZXJzIG9uIHNsYXZlIGNoYW5uZWxzICovCisJCWlmICghcGxjaGFuLT5zbGF2ZSkKKwkJCXBsMDh4X3VubWFwX2J1ZmZlcnModHhkKTsKKworCQkvKiBGcmVlIHRoZSBkZXNjcmlwdG9yICovCisJCXNwaW5fbG9ja19pcnFzYXZlKCZwbGNoYW4tPmxvY2ssIGZsYWdzKTsKKwkJcGwwOHhfZnJlZV90eGQocGwwOHgsIHR4ZCk7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBsY2hhbi0+bG9jaywgZmxhZ3MpOworCisJCS8qIENhbGxiYWNrIHRvIHNpZ25hbCBjb21wbGV0aW9uICovCisJCWlmIChjYWxsYmFjaykKKwkJCWNhbGxiYWNrKGNhbGxiYWNrX3BhcmFtKTsKKwl9CiB9CiAKIHN0YXRpYyBpcnFyZXR1cm5fdCBwbDA4eF9pcnEoaW50IGlycSwgdm9pZCAqZGV2KQpAQCAtMTc0NCw5ICsxNjMzLDcgQEAKIAogCXZhbCA9IHJlYWRsKHBsMDh4LT5iYXNlICsgUEwwODBfRVJSX1NUQVRVUyk7CiAJaWYgKHZhbCkgewotCQkvKgotCQkgKiBBbiBlcnJvciBpbnRlcnJ1cHQgKG9uIG9uZSBvciBtb3JlIGNoYW5uZWxzKQotCQkgKi8KKwkJLyogQW4gZXJyb3IgaW50ZXJydXB0IChvbiBvbmUgb3IgbW9yZSBjaGFubmVscykgKi8KIAkJZGV2X2VycigmcGwwOHgtPmFkZXYtPmRldiwKIAkJCSIlcyBlcnJvciBpbnRlcnJ1cHQsIHJlZ2lzdGVyIHZhbHVlIDB4JTA4eFxuIiwKIAkJCQlfX2Z1bmNfXywgdmFsKTsKQEAgLTE3NzAsOSArMTY1Nyw3IEBACiAJCQltYXNrIHw9ICgxIDw8IGkpOwogCQl9CiAJfQotCS8qCi0JICogQ2xlYXIgb25seSB0aGUgdGVybWluYWwgaW50ZXJydXB0cyBvbiBjaGFubmVscyB3ZSBwcm9jZXNzZWQKLQkgKi8KKwkvKiBDbGVhciBvbmx5IHRoZSB0ZXJtaW5hbCBpbnRlcnJ1cHRzIG9uIGNoYW5uZWxzIHdlIHByb2Nlc3NlZCAqLwogCXdyaXRlbChtYXNrLCBwbDA4eC0+YmFzZSArIFBMMDgwX1RDX0NMRUFSKTsKIAogCXJldHVybiBtYXNrID8gSVJRX0hBTkRMRUQgOiBJUlFfTk9ORTsKQEAgLTE3OTEsNiArMTY3Niw3IEBACiAJaW50IGk7CiAKIAlJTklUX0xJU1RfSEVBRCgmZG1hZGV2LT5jaGFubmVscyk7CisKIAkvKgogCSAqIFJlZ2lzdGVyIGFzIG1hbnkgbWFueSBtZW1jcHkgYXMgd2UgaGF2ZSBwaHlzaWNhbCBjaGFubmVscywKIAkgKiB3ZSB3b24ndCBhbHdheXMgYmUgYWJsZSB0byB1c2UgYWxsIGJ1dCB0aGUgY29kZSB3aWxsIGhhdmUKQEAgLTE4MTksMTYgKzE3MDUsMjMgQEAKIAkJCQlyZXR1cm4gLUVOT01FTTsKIAkJCX0KIAkJfQorCQlpZiAoY2hhbi0+Y2QtPmNpcmN1bGFyX2J1ZmZlcikgeworCQkJZGV2X2VycigmcGwwOHgtPmFkZXYtPmRldiwKKwkJCQkiY2hhbm5lbCAlczogY2lyY3VsYXIgYnVmZmVycyBub3Qgc3VwcG9ydGVkXG4iLAorCQkJCWNoYW4tPm5hbWUpOworCQkJa2ZyZWUoY2hhbik7CisJCQljb250aW51ZTsKKwkJfQogCQlkZXZfaW5mbygmcGwwOHgtPmFkZXYtPmRldiwKIAkJCSAiaW5pdGlhbGl6ZSB2aXJ0dWFsIGNoYW5uZWwgXCIlc1wiXG4iLAogCQkJIGNoYW4tPm5hbWUpOwogCiAJCWNoYW4tPmNoYW4uZGV2aWNlID0gZG1hZGV2OwotCQlhdG9taWNfc2V0KCZjaGFuLT5sYXN0X2lzc3VlZCwgMCk7Ci0JCWNoYW4tPmxjID0gYXRvbWljX3JlYWQoJmNoYW4tPmxhc3RfaXNzdWVkKTsKKwkJY2hhbi0+Y2hhbi5jb29raWUgPSAwOworCQljaGFuLT5sYyA9IDA7CiAKIAkJc3Bpbl9sb2NrX2luaXQoJmNoYW4tPmxvY2spOwotCQlJTklUX0xJU1RfSEVBRCgmY2hhbi0+ZGVzY19saXN0KTsKKwkJSU5JVF9MSVNUX0hFQUQoJmNoYW4tPnBlbmRfbGlzdCk7CiAJCXRhc2tsZXRfaW5pdCgmY2hhbi0+dGFza2xldCwgcGwwOHhfdGFza2xldCwKIAkJCSAgICAgKHVuc2lnbmVkIGxvbmcpIGNoYW4pOwogCkBAIC0xODk4LDcgKzE3OTEsNyBAQAogCXNlcV9wcmludGYocywgIkNIQU5ORUw6XHRTVEFURTpcbiIpOwogCXNlcV9wcmludGYocywgIi0tLS0tLS0tXHQtLS0tLS1cbiIpOwogCWxpc3RfZm9yX2VhY2hfZW50cnkoY2hhbiwgJnBsMDh4LT5tZW1jcHkuY2hhbm5lbHMsIGNoYW4uZGV2aWNlX25vZGUpIHsKLQkJc2VxX3ByaW50ZihzLCAiJXNcdFx0XCVzXG4iLCBjaGFuLT5uYW1lLAorCQlzZXFfcHJpbnRmKHMsICIlc1x0XHQlc1xuIiwgY2hhbi0+bmFtZSwKIAkJCSAgIHBsMDh4X3N0YXRlX3N0cihjaGFuLT5zdGF0ZSkpOwogCX0KIApAQCAtMTkwNiw3ICsxNzk5LDcgQEAKIAlzZXFfcHJpbnRmKHMsICJDSEFOTkVMOlx0U1RBVEU6XG4iKTsKIAlzZXFfcHJpbnRmKHMsICItLS0tLS0tLVx0LS0tLS0tXG4iKTsKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNoYW4sICZwbDA4eC0+c2xhdmUuY2hhbm5lbHMsIGNoYW4uZGV2aWNlX25vZGUpIHsKLQkJc2VxX3ByaW50ZihzLCAiJXNcdFx0XCVzXG4iLCBjaGFuLT5uYW1lLAorCQlzZXFfcHJpbnRmKHMsICIlc1x0XHQlc1xuIiwgY2hhbi0+bmFtZSwKIAkJCSAgIHBsMDh4X3N0YXRlX3N0cihjaGFuLT5zdGF0ZSkpOwogCX0KIApAQCAtMTk0Miw3ICsxODM1LDcgQEAKIHN0YXRpYyBpbnQgcGwwOHhfcHJvYmUoc3RydWN0IGFtYmFfZGV2aWNlICphZGV2LCBzdHJ1Y3QgYW1iYV9pZCAqaWQpCiB7CiAJc3RydWN0IHBsMDh4X2RyaXZlcl9kYXRhICpwbDA4eDsKLQlzdHJ1Y3QgdmVuZG9yX2RhdGEgKnZkID0gaWQtPmRhdGE7CisJY29uc3Qgc3RydWN0IHZlbmRvcl9kYXRhICp2ZCA9IGlkLT5kYXRhOwogCWludCByZXQgPSAwOwogCWludCBpOwogCkBAIC0xOTkwLDYgKzE4ODMsMTQgQEAKIAlwbDA4eC0+YWRldiA9IGFkZXY7CiAJcGwwOHgtPnZkID0gdmQ7CiAKKwkvKiBCeSBkZWZhdWx0LCBBSEIxIG9ubHkuICBJZiBkdWFsbWFzdGVyLCBmcm9tIHBsYXRmb3JtICovCisJcGwwOHgtPmxsaV9idXNlcyA9IFBMMDhYX0FIQjE7CisJcGwwOHgtPm1lbV9idXNlcyA9IFBMMDhYX0FIQjE7CisJaWYgKHBsMDh4LT52ZC0+ZHVhbG1hc3RlcikgeworCQlwbDA4eC0+bGxpX2J1c2VzID0gcGwwOHgtPnBkLT5sbGlfYnVzZXM7CisJCXBsMDh4LT5tZW1fYnVzZXMgPSBwbDA4eC0+cGQtPm1lbV9idXNlczsKKwl9CisKIAkvKiBBIERNQSBtZW1vcnkgcG9vbCBmb3IgTExJcywgYWxpZ24gb24gMS1ieXRlIGJvdW5kYXJ5ICovCiAJcGwwOHgtPnBvb2wgPSBkbWFfcG9vbF9jcmVhdGUoRFJJVkVSX05BTUUsICZwbDA4eC0+YWRldi0+ZGV2LAogCQkJUEwwOFhfTExJX1RTRlJfU0laRSwgUEwwOFhfQUxJR04sIDApOwpAQCAtMjAwOSwxNCArMTkxMCwxMiBAQAogCS8qIFR1cm4gb24gdGhlIFBMMDh4ICovCiAJcGwwOHhfZW5zdXJlX29uKHBsMDh4KTsKIAotCS8qCi0JICogQXR0YWNoIHRoZSBpbnRlcnJ1cHQgaGFuZGxlcgotCSAqLworCS8qIEF0dGFjaCB0aGUgaW50ZXJydXB0IGhhbmRsZXIgKi8KIAl3cml0ZWwoMHgwMDAwMDBGRiwgcGwwOHgtPmJhc2UgKyBQTDA4MF9FUlJfQ0xFQVIpOwogCXdyaXRlbCgweDAwMDAwMEZGLCBwbDA4eC0+YmFzZSArIFBMMDgwX1RDX0NMRUFSKTsKIAogCXJldCA9IHJlcXVlc3RfaXJxKGFkZXYtPmlycVswXSwgcGwwOHhfaXJxLCBJUlFGX0RJU0FCTEVELAotCQkJICB2ZC0+bmFtZSwgcGwwOHgpOworCQkJICBEUklWRVJfTkFNRSwgcGwwOHgpOwogCWlmIChyZXQpIHsKIAkJZGV2X2VycigmYWRldi0+ZGV2LCAiJXMgZmFpbGVkIHRvIHJlcXVlc3QgaW50ZXJydXB0ICVkXG4iLAogCQkJX19mdW5jX18sIGFkZXYtPmlycVswXSk7CkBAIC0yMDg3LDggKzE5ODYsOSBAQAogCiAJYW1iYV9zZXRfZHJ2ZGF0YShhZGV2LCBwbDA4eCk7CiAJaW5pdF9wbDA4eF9kZWJ1Z2ZzKHBsMDh4KTsKLQlkZXZfaW5mbygmcGwwOHgtPmFkZXYtPmRldiwgIkFSTShSKSAlcyBETUEgYmxvY2sgaW5pdGlhbGl6ZWQgQCUwOHhcbiIsCi0JCXZkLT5uYW1lLCBhZGV2LT5yZXMuc3RhcnQpOworCWRldl9pbmZvKCZwbDA4eC0+YWRldi0+ZGV2LCAiRE1BOiBQTCUwM3ggcmV2JXUgYXQgMHglMDhsbHggaXJxICVkXG4iLAorCQkgYW1iYV9wYXJ0KGFkZXYpLCBhbWJhX3JldihhZGV2KSwKKwkJICh1bnNpZ25lZCBsb25nIGxvbmcpYWRldi0+cmVzLnN0YXJ0LCBhZGV2LT5pcnFbMF0pOwogCXJldHVybiAwOwogCiBvdXRfbm9fc2xhdmVfcmVnOgpAQCAtMjExNSwxMyArMjAxNSwxMSBAQAogCiAvKiBQTDA4MCBoYXMgOCBjaGFubmVscyBhbmQgdGhlIFBMMDgwIGhhdmUganVzdCAyICovCiBzdGF0aWMgc3RydWN0IHZlbmRvcl9kYXRhIHZlbmRvcl9wbDA4MCA9IHsKLQkubmFtZSA9ICJQTDA4MCIsCiAJLmNoYW5uZWxzID0gOCwKIAkuZHVhbG1hc3RlciA9IHRydWUsCiB9OwogCiBzdGF0aWMgc3RydWN0IHZlbmRvcl9kYXRhIHZlbmRvcl9wbDA4MSA9IHsKLQkubmFtZSA9ICJQTDA4MSIsCiAJLmNoYW5uZWxzID0gMiwKIAkuZHVhbG1hc3RlciA9IGZhbHNlLAogfTsKQEAgLTIxNjAsNyArMjA1OCw3IEBACiAJcmV0dmFsID0gYW1iYV9kcml2ZXJfcmVnaXN0ZXIoJnBsMDh4X2FtYmFfZHJpdmVyKTsKIAlpZiAocmV0dmFsKQogCQlwcmludGsoS0VSTl9XQVJOSU5HIERSSVZFUl9OQU1FCi0JCSAgICAgICAiZmFpbGVkIHRvIHJlZ2lzdGVyIGFzIGFuIGFtYmEgZGV2aWNlICglZClcbiIsCisJCSAgICAgICAiZmFpbGVkIHRvIHJlZ2lzdGVyIGFzIGFuIEFNQkEgZGV2aWNlICglZClcbiIsCiAJCSAgICAgICByZXR2YWwpOwogCXJldHVybiByZXR2YWw7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS9hdF9oZG1hYy5jIGIvZHJpdmVycy9kbWEvYXRfaGRtYWMuYwppbmRleCBlYTBlZTgxLi4zZDdkNzA1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2RtYS9hdF9oZG1hYy5jCisrKyBiL2RyaXZlcnMvZG1hL2F0X2hkbWFjLmMKQEAgLTI1Myw3ICsyNTMsNyBAQAogCS8qIG1vdmUgbXlzZWxmIHRvIGZyZWVfbGlzdCAqLwogCWxpc3RfbW92ZSgmZGVzYy0+ZGVzY19ub2RlLCAmYXRjaGFuLT5mcmVlX2xpc3QpOwogCi0JLyogdW5tYXAgZG1hIGFkZHJlc3NlcyAqLworCS8qIHVubWFwIGRtYSBhZGRyZXNzZXMgKG5vdCBvbiBzbGF2ZSBjaGFubmVscykgKi8KIAlpZiAoIWF0Y2hhbi0+Y2hhbl9jb21tb24ucHJpdmF0ZSkgewogCQlzdHJ1Y3QgZGV2aWNlICpwYXJlbnQgPSBjaGFuMnBhcmVudCgmYXRjaGFuLT5jaGFuX2NvbW1vbik7CiAJCWlmICghKHR4ZC0+ZmxhZ3MgJiBETUFfQ09NUExfU0tJUF9ERVNUX1VOTUFQKSkgewpAQCAtNTgzLDcgKzU4Myw2IEBACiAJCWRlc2MtPmxsaS5jdHJsYiA9IGN0cmxiOwogCiAJCWRlc2MtPnR4ZC5jb29raWUgPSAwOwotCQlhc3luY190eF9hY2soJmRlc2MtPnR4ZCk7CiAKIAkJaWYgKCFmaXJzdCkgewogCQkJZmlyc3QgPSBkZXNjOwpAQCAtNjA0LDcgKzYwMyw3IEBACiAJLyogc2V0IGVuZC1vZi1saW5rIHRvIHRoZSBsYXN0IGxpbmsgZGVzY3JpcHRvciBvZiBsaXN0Ki8KIAlzZXRfZGVzY19lb2woZGVzYyk7CiAKLQlkZXNjLT50eGQuZmxhZ3MgPSBmbGFnczsgLyogY2xpZW50IGlzIGluIGNvbnRyb2wgb2YgdGhpcyBhY2sgKi8KKwlmaXJzdC0+dHhkLmZsYWdzID0gZmxhZ3M7IC8qIGNsaWVudCBpcyBpbiBjb250cm9sIG9mIHRoaXMgYWNrICovCiAKIAlyZXR1cm4gJmZpcnN0LT50eGQ7CiAKQEAgLTY3MCw3ICs2NjksNyBAQAogCQkJaWYgKCFkZXNjKQogCQkJCWdvdG8gZXJyX2Rlc2NfZ2V0OwogCi0JCQltZW0gPSBzZ19waHlzKHNnKTsKKwkJCW1lbSA9IHNnX2RtYV9hZGRyZXNzKHNnKTsKIAkJCWxlbiA9IHNnX2RtYV9sZW4oc2cpOwogCQkJbWVtX3dpZHRoID0gMjsKIAkJCWlmICh1bmxpa2VseShtZW0gJiAzIHx8IGxlbiAmIDMpKQpAQCAtNzEyLDcgKzcxMSw3IEBACiAJCQlpZiAoIWRlc2MpCiAJCQkJZ290byBlcnJfZGVzY19nZXQ7CiAKLQkJCW1lbSA9IHNnX3BoeXMoc2cpOworCQkJbWVtID0gc2dfZG1hX2FkZHJlc3Moc2cpOwogCQkJbGVuID0gc2dfZG1hX2xlbihzZyk7CiAJCQltZW1fd2lkdGggPSAyOwogCQkJaWYgKHVubGlrZWx5KG1lbSAmIDMgfHwgbGVuICYgMykpCkBAIC03NDksOCArNzQ4LDggQEAKIAlmaXJzdC0+dHhkLmNvb2tpZSA9IC1FQlVTWTsKIAlmaXJzdC0+bGVuID0gdG90YWxfbGVuOwogCi0JLyogbGFzdCBsaW5rIGRlc2NyaXB0b3Igb2YgbGlzdCBpcyByZXNwb25zaWJsZSBvZiBmbGFncyAqLwotCXByZXYtPnR4ZC5mbGFncyA9IGZsYWdzOyAvKiBjbGllbnQgaXMgaW4gY29udHJvbCBvZiB0aGlzIGFjayAqLworCS8qIGZpcnN0IGxpbmsgZGVzY3JpcHRvciBvZiBsaXN0IGlzIHJlc3BvbnNpYmxlIG9mIGZsYWdzICovCisJZmlyc3QtPnR4ZC5mbGFncyA9IGZsYWdzOyAvKiBjbGllbnQgaXMgaW4gY29udHJvbCBvZiB0aGlzIGFjayAqLwogCiAJcmV0dXJuICZmaXJzdC0+dHhkOwogCkBAIC04NTQsMTEgKzg1MywxMSBAQAogCiAJZGV2X3ZkYmcoY2hhbjJkZXYoY2hhbiksICJpc3N1ZV9wZW5kaW5nXG4iKTsKIAorCXNwaW5fbG9ja19iaCgmYXRjaGFuLT5sb2NrKTsKIAlpZiAoIWF0Y19jaGFuX2lzX2VuYWJsZWQoYXRjaGFuKSkgewotCQlzcGluX2xvY2tfYmgoJmF0Y2hhbi0+bG9jayk7CiAJCWF0Y19hZHZhbmNlX3dvcmsoYXRjaGFuKTsKLQkJc3Bpbl91bmxvY2tfYmgoJmF0Y2hhbi0+bG9jayk7CiAJfQorCXNwaW5fdW5sb2NrX2JoKCZhdGNoYW4tPmxvY2spOwogfQogCiAvKioKQEAgLTEyMTAsNyArMTIwOSw3IEBACiB7CiAJcmV0dXJuIHBsYXRmb3JtX2RyaXZlcl9wcm9iZSgmYXRfZG1hX2RyaXZlciwgYXRfZG1hX3Byb2JlKTsKIH0KLW1vZHVsZV9pbml0KGF0X2RtYV9pbml0KTsKK3N1YnN5c19pbml0Y2FsbChhdF9kbWFfaW5pdCk7CiAKIHN0YXRpYyB2b2lkIF9fZXhpdCBhdF9kbWFfZXhpdCh2b2lkKQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvZnNsZG1hLmMgYi9kcml2ZXJzL2RtYS9mc2xkbWEuYwppbmRleCBlNWUxNzJkMi4uNGRlOTQ3YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEvZnNsZG1hLmMKKysrIGIvZHJpdmVycy9kbWEvZnNsZG1hLmMKQEAgLTEsNyArMSw3IEBACiAvKgogICogRnJlZXNjYWxlIE1QQzg1eHgsIE1QQzgzeHggRE1BIEVuZ2luZSBzdXBwb3J0CiAgKgotICogQ29weXJpZ2h0IChDKSAyMDA3IEZyZWVzY2FsZSBTZW1pY29uZHVjdG9yLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDctMjAxMCBGcmVlc2NhbGUgU2VtaWNvbmR1Y3RvciwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIEF1dGhvcjoKICAqICAgWmhhbmcgV2VpIDx3ZWkuemhhbmdAZnJlZXNjYWxlLmNvbT4sIEp1bCAyMDA3CkBAIC0xMzI0LDYgKzEzMjQsOCBAQAogCWZkZXYtPmNvbW1vbi5kZXZpY2VfY29udHJvbCA9IGZzbF9kbWFfZGV2aWNlX2NvbnRyb2w7CiAJZmRldi0+Y29tbW9uLmRldiA9ICZvcC0+ZGV2OwogCisJZG1hX3NldF9tYXNrKCYob3AtPmRldiksIERNQV9CSVRfTUFTSygzNikpOworCiAJZGV2X3NldF9kcnZkYXRhKCZvcC0+ZGV2LCBmZGV2KTsKIAogCS8qCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS9pbnRlbF9taWRfZG1hLmMgYi9kcml2ZXJzL2RtYS9pbnRlbF9taWRfZG1hLmMKaW5kZXggNzgyNjYzOC4uNzk4ZjQ2YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEvaW50ZWxfbWlkX2RtYS5jCisrKyBiL2RyaXZlcnMvZG1hL2ludGVsX21pZF9kbWEuYwpAQCAtNjY0LDExICs2NjQsMjAgQEAKIAkvKmNhbGN1bGF0ZSBDVExfTE8qLwogCWN0bF9sby5jdGxfbG8gPSAwOwogCWN0bF9sby5jdGx4LmludF9lbiA9IDE7Ci0JY3RsX2xvLmN0bHguZHN0X3RyX3dpZHRoID0gbWlkcy0+ZG1hX3NsYXZlLmRzdF9hZGRyX3dpZHRoOwotCWN0bF9sby5jdGx4LnNyY190cl93aWR0aCA9IG1pZHMtPmRtYV9zbGF2ZS5zcmNfYWRkcl93aWR0aDsKIAljdGxfbG8uY3RseC5kc3RfbXNpemUgPSBtaWRzLT5kbWFfc2xhdmUuc3JjX21heGJ1cnN0OwogCWN0bF9sby5jdGx4LnNyY19tc2l6ZSA9IG1pZHMtPmRtYV9zbGF2ZS5kc3RfbWF4YnVyc3Q7CiAKKwkvKgorCSAqIEhlcmUgd2UgbmVlZCBzb21lIHRyYW5zbGF0aW9uIGZyb20gImVudW0gZG1hX3NsYXZlX2J1c3dpZHRoIgorCSAqIHRvIHRoZSBmb3JtYXQgZm9yIG91ciBkbWEgY29udHJvbGxlcgorCSAqCQlzdGFuZGFyZAlpbnRlbF9taWRfZG1hYydzIGZvcm1hdAorCSAqCQkgMSBCeXRlCQkJMGIwMDAKKwkgKgkJIDIgQnl0ZXMJCTBiMDAxCisJICoJCSA0IEJ5dGVzCQkwYjAxMAorCSAqLworCWN0bF9sby5jdGx4LmRzdF90cl93aWR0aCA9IG1pZHMtPmRtYV9zbGF2ZS5kc3RfYWRkcl93aWR0aCAvIDI7CisJY3RsX2xvLmN0bHguc3JjX3RyX3dpZHRoID0gbWlkcy0+ZG1hX3NsYXZlLnNyY19hZGRyX3dpZHRoIC8gMjsKKwogCWlmIChtaWRzLT5jZmdfbW9kZSA9PSBMTldfRE1BX01FTV9UT19NRU0pIHsKIAkJY3RsX2xvLmN0bHgudHRfZmMgPSAwOwogCQljdGxfbG8uY3RseC5zaW5jID0gMDsKQEAgLTc0Niw4ICs3NTUsMTggQEAKIAlCVUdfT04oIW1pZHMpOwogCiAJaWYgKCFtaWRjLT5kbWEtPnBpbXJfbWFzaykgewotCQlwcl9kZWJ1ZygiTURNQTogU0cgbGlzdCBpcyBub3Qgc3VwcG9ydGVkIGJ5IHRoaXMgY29udHJvbGxlclxuIik7Ci0JCXJldHVybiAgTlVMTDsKKwkJLyogV2UgY2FuIHN0aWxsIGhhbmRsZSBzZyBsaXN0IHdpdGggb25seSBvbmUgaXRlbSAqLworCQlpZiAoc2dfbGVuID09IDEpIHsKKwkJCXR4ZCA9IGludGVsX21pZF9kbWFfcHJlcF9tZW1jcHkoY2hhbiwKKwkJCQkJCW1pZHMtPmRtYV9zbGF2ZS5kc3RfYWRkciwKKwkJCQkJCW1pZHMtPmRtYV9zbGF2ZS5zcmNfYWRkciwKKwkJCQkJCXNnbC0+bGVuZ3RoLAorCQkJCQkJZmxhZ3MpOworCQkJcmV0dXJuIHR4ZDsKKwkJfSBlbHNlIHsKKwkJCXByX3dhcm4oIk1ETUE6IFNHIGxpc3QgaXMgbm90IHN1cHBvcnRlZCBieSB0aGlzIGNvbnRyb2xsZXJcbiIpOworCQkJcmV0dXJuICBOVUxMOworCQl9CiAJfQogCiAJcHJfZGVidWcoIk1ETUE6IFNHIExlbmd0aCA9ICVkLCBkaXJlY3Rpb24gPSAlZCwgRmxhZ3MgPSAlI2x4XG4iLApAQCAtNzU4LDYgKzc3Nyw3IEBACiAJCXByX2VycigiTURNQTogUHJlcCBtZW1jcHkgZmFpbGVkXG4iKTsKIAkJcmV0dXJuIE5VTEw7CiAJfQorCiAJZGVzYyA9IHRvX2ludGVsX21pZF9kbWFfZGVzYyh0eGQpOwogCWRlc2MtPmRpcm4gPSBkaXJlY3Rpb247CiAJY3RsX2xvLmN0bF9sbyA9IGRlc2MtPmN0bF9sbzsKQEAgLTEwMjEsMTEgKzEwNDEsNiBAQAogCiAJLypETUEgSW50ZXJydXB0Ki8KIAlwcl9kZWJ1ZygiTURNQTpHb3QgYW4gaW50ZXJydXB0IG9uIGlycSAlZFxuIiwgaXJxKTsKLQlpZiAoIW1pZCkgewotCQlwcl9lcnIoIkVSUl9NRE1BOm51bGwgcG9pbnRlciBtaWRcbiIpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KIAlwcl9kZWJ1ZygiTURNQTogU3RhdHVzICV4LCBNYXNrICV4XG4iLCB0ZnJfc3RhdHVzLCBtaWQtPmludHJfbWFzayk7CiAJdGZyX3N0YXR1cyAmPSBtaWQtPmludHJfbWFzazsKIAlpZiAodGZyX3N0YXR1cykgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvaW9wLWFkbWEuYyBiL2RyaXZlcnMvZG1hL2lvcC1hZG1hLmMKaW5kZXggMTYxYzQ1Mi4uYzZiMDFmNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEvaW9wLWFkbWEuYworKysgYi9kcml2ZXJzL2RtYS9pb3AtYWRtYS5jCkBAIC0xMjYxLDcgKzEyNjEsNyBAQAogCXJldHVybiBlcnI7CiB9CiAKLSNpZmRlZiBDT05GSUdfTURfUkFJRDZfUFEKKyNpZmRlZiBDT05GSUdfUkFJRDZfUFEKIHN0YXRpYyBpbnQgX19kZXZpbml0CiBpb3BfYWRtYV9wcV96ZXJvX3N1bV9zZWxmX3Rlc3Qoc3RydWN0IGlvcF9hZG1hX2RldmljZSAqZGV2aWNlKQogewpAQCAtMTU4NCw3ICsxNTg0LDcgQEAKIAogCWlmIChkbWFfaGFzX2NhcChETUFfUFEsIGRtYV9kZXYtPmNhcF9tYXNrKSAmJgogCSAgICBkbWFfaGFzX2NhcChETUFfUFFfVkFMLCBkbWFfZGV2LT5jYXBfbWFzaykpIHsKLQkJI2lmZGVmIENPTkZJR19NRF9SQUlENl9QUQorCQkjaWZkZWYgQ09ORklHX1JBSUQ2X1BRCiAJCXJldCA9IGlvcF9hZG1hX3BxX3plcm9fc3VtX3NlbGZfdGVzdChhZGV2KTsKIAkJZGV2X2RiZygmcGRldi0+ZGV2LCAicHEgc2VsZiB0ZXN0IHJldHVybmVkICVkXG4iLCByZXQpOwogCQkjZWxzZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvcGNoX2RtYS5jIGIvZHJpdmVycy9kbWEvcGNoX2RtYS5jCmluZGV4IGMwNjRjODkuLjFjMzg0MTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hL3BjaF9kbWEuYworKysgYi9kcml2ZXJzL2RtYS9wY2hfZG1hLmMKQEAgLTEsNiArMSw3IEBACiAvKgogICogVG9wY2xpZmYgUENIIERNQSBjb250cm9sbGVyIGRyaXZlcgogICogQ29weXJpZ2h0IChjKSAyMDEwIEludGVsIENvcnBvcmF0aW9uCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgT0tJIFNFTUlDT05EVUNUT1IgQ08uLCBMVEQuCiAgKgogICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCkBAIC05MjEsMTIgKzkyMiwxOSBAQAogfQogCiAvKiBQQ0kgRGV2aWNlIElEIG9mIERNQSBkZXZpY2UgKi8KLSNkZWZpbmUgUENJX0RFVklDRV9JRF9QQ0hfRE1BXzhDSCAgICAgICAgMHg4ODEwCi0jZGVmaW5lIFBDSV9ERVZJQ0VfSURfUENIX0RNQV80Q0ggICAgICAgIDB4ODgxNQorI2RlZmluZSBQQ0lfVkVORE9SX0lEX1JPSE0gICAgICAgICAgICAgMHgxMERCCisjZGVmaW5lIFBDSV9ERVZJQ0VfSURfRUcyMFRfUENIX0RNQV84Q0ggICAgICAgIDB4ODgxMAorI2RlZmluZSBQQ0lfREVWSUNFX0lEX0VHMjBUX1BDSF9ETUFfNENIICAgICAgICAweDg4MTUKKyNkZWZpbmUgUENJX0RFVklDRV9JRF9NTDcyMTNfRE1BMV84Q0gJMHg4MDI2CisjZGVmaW5lIFBDSV9ERVZJQ0VfSURfTUw3MjEzX0RNQTJfOENICTB4ODAyQgorI2RlZmluZSBQQ0lfREVWSUNFX0lEX01MNzIxM19ETUEzXzRDSAkweDgwMzQKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkIHBjaF9kbWFfaWRfdGFibGVbXSA9IHsKLQl7IFBDSV9WREVWSUNFKElOVEVMLCBQQ0lfREVWSUNFX0lEX1BDSF9ETUFfOENIKSwgOCB9LAotCXsgUENJX1ZERVZJQ0UoSU5URUwsIFBDSV9ERVZJQ0VfSURfUENIX0RNQV80Q0gpLCA0IH0sCisJeyBQQ0lfVkRFVklDRShJTlRFTCwgUENJX0RFVklDRV9JRF9FRzIwVF9QQ0hfRE1BXzhDSCksIDggfSwKKwl7IFBDSV9WREVWSUNFKElOVEVMLCBQQ0lfREVWSUNFX0lEX0VHMjBUX1BDSF9ETUFfNENIKSwgNCB9LAorCXsgUENJX1ZERVZJQ0UoUk9ITSwgUENJX0RFVklDRV9JRF9NTDcyMTNfRE1BMV84Q0gpLCA4fSwgLyogVUFSVCBWaWRlbyAqLworCXsgUENJX1ZERVZJQ0UoUk9ITSwgUENJX0RFVklDRV9JRF9NTDcyMTNfRE1BMl84Q0gpLCA4fSwgLyogUENNSUYgU1BJICovCisJeyBQQ0lfVkRFVklDRShST0hNLCBQQ0lfREVWSUNFX0lEX01MNzIxM19ETUEzXzRDSCksIDR9LCAvKiBGUEdBICovCiAJeyAwLCB9LAogfTsKIApAQCAtOTU0LDYgKzk2Miw3IEBACiBtb2R1bGVfaW5pdChwY2hfZG1hX2luaXQpOwogbW9kdWxlX2V4aXQocGNoX2RtYV9leGl0KTsKIAotTU9EVUxFX0RFU0NSSVBUSU9OKCJUb3BjbGlmZiBQQ0ggRE1BIGNvbnRyb2xsZXIgZHJpdmVyIik7CitNT0RVTEVfREVTQ1JJUFRJT04oIkludGVsIEVHMjBUIFBDSCAvIE9LSSBTRU1JQ09ORFVDVE9SIE1MNzIxMyBJT0ggIgorCQkgICAiRE1BIGNvbnRyb2xsZXIgZHJpdmVyIik7CiBNT0RVTEVfQVVUSE9SKCJZb25nIFdhbmcgPHlvbmcueS53YW5nQGludGVsLmNvbT4iKTsKIE1PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hL3N0ZV9kbWE0MC5jIGIvZHJpdmVycy9kbWEvc3RlX2RtYTQwLmMKaW5kZXggZmFiNjhhNS4uNmUxZDQ2YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEvc3RlX2RtYTQwLmMKKysrIGIvZHJpdmVycy9kbWEvc3RlX2RtYTQwLmMKQEAgLTEsNSArMSw2IEBACiAvKgotICogQ29weXJpZ2h0IChDKSBTVC1Fcmljc3NvbiBTQSAyMDA3LTIwMTAKKyAqIENvcHlyaWdodCAoQykgRXJpY3Nzb24gQUIgMjAwNy0yMDA4CisgKiBDb3B5cmlnaHQgKEMpIFNULUVyaWNzc29uIFNBIDIwMDgtMjAxMAogICogQXV0aG9yOiBQZXIgRm9ybGluIDxwZXIuZm9ybGluQHN0ZXJpY3Nzb24uY29tPiBmb3IgU1QtRXJpY3Nzb24KICAqIEF1dGhvcjogSm9uYXMgQWFiZXJnIDxqb25hcy5hYmVyZ0BzdGVyaWNzc29uLmNvbT4gZm9yIFNULUVyaWNzc29uCiAgKiBMaWNlbnNlIHRlcm1zOiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSB2ZXJzaW9uIDIKQEAgLTU1NCw4ICs1NTUsNjYgQEAKIAlyZXR1cm4gZDsKIH0KIAotLyogU3VwcG9ydCBmdW5jdGlvbnMgZm9yIGxvZ2ljYWwgY2hhbm5lbHMgKi8KK3N0YXRpYyBpbnQgZDQwX3BzaXplXzJfYnVyc3Rfc2l6ZShib29sIGlzX2xvZywgaW50IHBzaXplKQoreworCWlmIChpc19sb2cpIHsKKwkJaWYgKHBzaXplID09IFNURURNQTQwX1BTSVpFX0xPR18xKQorCQkJcmV0dXJuIDE7CisJfSBlbHNlIHsKKwkJaWYgKHBzaXplID09IFNURURNQTQwX1BTSVpFX1BIWV8xKQorCQkJcmV0dXJuIDE7CisJfQogCisJcmV0dXJuIDIgPDwgcHNpemU7Cit9CisKKy8qCisgKiBUaGUgZG1hIG9ubHkgc3VwcG9ydHMgdHJhbnNtaXR0aW5nIHBhY2thZ2VzIHVwIHRvCisgKiBTVEVETUE0MF9NQVhfU0VHX1NJWkUgPDwgZGF0YV93aWR0aC4gQ2FsY3VsYXRlIHRoZSB0b3RhbCBudW1iZXIgb2YKKyAqIGRtYSBlbGVtZW50cyByZXF1aXJlZCB0byBzZW5kIHRoZSBlbnRpcmUgc2cgbGlzdAorICovCitzdGF0aWMgaW50IGQ0MF9zaXplXzJfZG1hbGVuKGludCBzaXplLCB1MzIgZGF0YV93aWR0aDEsIHUzMiBkYXRhX3dpZHRoMikKK3sKKwlpbnQgZG1hbGVuOworCXUzMiBtYXhfdyA9IG1heChkYXRhX3dpZHRoMSwgZGF0YV93aWR0aDIpOworCXUzMiBtaW5fdyA9IG1pbihkYXRhX3dpZHRoMSwgZGF0YV93aWR0aDIpOworCXUzMiBzZWdfbWF4ID0gQUxJR04oU1RFRE1BNDBfTUFYX1NFR19TSVpFIDw8IG1pbl93LCAxIDw8IG1heF93KTsKKworCWlmIChzZWdfbWF4ID4gU1RFRE1BNDBfTUFYX1NFR19TSVpFKQorCQlzZWdfbWF4IC09ICgxIDw8IG1heF93KTsKKworCWlmICghSVNfQUxJR05FRChzaXplLCAxIDw8IG1heF93KSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoc2l6ZSA8PSBzZWdfbWF4KQorCQlkbWFsZW4gPSAxOworCWVsc2UgeworCQlkbWFsZW4gPSBzaXplIC8gc2VnX21heDsKKwkJaWYgKGRtYWxlbiAqIHNlZ19tYXggPCBzaXplKQorCQkJZG1hbGVuKys7CisJfQorCXJldHVybiBkbWFsZW47Cit9CisKK3N0YXRpYyBpbnQgZDQwX3NnXzJfZG1hbGVuKHN0cnVjdCBzY2F0dGVybGlzdCAqc2dsLCBpbnQgc2dfbGVuLAorCQkJICAgdTMyIGRhdGFfd2lkdGgxLCB1MzIgZGF0YV93aWR0aDIpCit7CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZzsKKwlpbnQgaTsKKwlpbnQgbGVuID0gMDsKKwlpbnQgcmV0OworCisJZm9yX2VhY2hfc2coc2dsLCBzZywgc2dfbGVuLCBpKSB7CisJCXJldCA9IGQ0MF9zaXplXzJfZG1hbGVuKHNnX2RtYV9sZW4oc2cpLAorCQkJCQlkYXRhX3dpZHRoMSwgZGF0YV93aWR0aDIpOworCQlpZiAocmV0IDwgMCkKKwkJCXJldHVybiByZXQ7CisJCWxlbiArPSByZXQ7CisJfQorCXJldHVybiBsZW47Cit9CisKKy8qIFN1cHBvcnQgZnVuY3Rpb25zIGZvciBsb2dpY2FsIGNoYW5uZWxzICovCiAKIHN0YXRpYyBpbnQgZDQwX2NoYW5uZWxfZXhlY3V0ZV9jb21tYW5kKHN0cnVjdCBkNDBfY2hhbiAqZDQwYywKIAkJCQkgICAgICAgZW51bSBkNDBfY29tbWFuZCBjb21tYW5kKQpAQCAtMTI0MSw2ICsxMzAwLDIxIEBACiAJCXJlcyA9IC1FSU5WQUw7CiAJfQogCisJaWYgKGQ0MF9wc2l6ZV8yX2J1cnN0X3NpemUoaXNfbG9nLCBjb25mLT5zcmNfaW5mby5wc2l6ZSkgKgorCSAgICAoMSA8PCBjb25mLT5zcmNfaW5mby5kYXRhX3dpZHRoKSAhPQorCSAgICBkNDBfcHNpemVfMl9idXJzdF9zaXplKGlzX2xvZywgY29uZi0+ZHN0X2luZm8ucHNpemUpICoKKwkgICAgKDEgPDwgY29uZi0+ZHN0X2luZm8uZGF0YV93aWR0aCkpIHsKKwkJLyoKKwkJICogVGhlIERNQUMgaGFyZHdhcmUgb25seSBzdXBwb3J0cworCQkgKiBzcmMgKGJ1cnN0IHggd2lkdGgpID09IGRzdCAoYnVyc3QgeCB3aWR0aCkKKwkJICovCisKKwkJZGV2X2VycigmZDQwYy0+Y2hhbi5kZXYtPmRldmljZSwKKwkJCSJbJXNdIHNyYyAoYnVyc3QgeCB3aWR0aCkgIT0gZHN0IChidXJzdCB4IHdpZHRoKVxuIiwKKwkJCV9fZnVuY19fKTsKKwkJcmVzID0gLUVJTlZBTDsKKwl9CisKIAlyZXR1cm4gcmVzOwogfQogCkBAIC0xNjM4LDEzICsxNzEyLDIxIEBACiAJaWYgKGQ0MGQgPT0gTlVMTCkKIAkJZ290byBlcnI7CiAKLQlkNDBkLT5sbGlfbGVuID0gc2dsX2xlbjsKKwlkNDBkLT5sbGlfbGVuID0gZDQwX3NnXzJfZG1hbGVuKHNnbF9kc3QsIHNnbF9sZW4sCisJCQkJCWQ0MGMtPmRtYV9jZmcuc3JjX2luZm8uZGF0YV93aWR0aCwKKwkJCQkJZDQwYy0+ZG1hX2NmZy5kc3RfaW5mby5kYXRhX3dpZHRoKTsKKwlpZiAoZDQwZC0+bGxpX2xlbiA8IDApIHsKKwkJZGV2X2VycigmZDQwYy0+Y2hhbi5kZXYtPmRldmljZSwKKwkJCSJbJXNdIFVuYWxpZ25lZCBzaXplXG4iLCBfX2Z1bmNfXyk7CisJCWdvdG8gZXJyOworCX0KKwogCWQ0MGQtPmxsaV9jdXJyZW50ID0gMDsKIAlkNDBkLT50eGQuZmxhZ3MgPSBkbWFfZmxhZ3M7CiAKIAlpZiAoZDQwYy0+bG9nX251bSAhPSBENDBfUEhZX0NIQU4pIHsKIAotCQlpZiAoZDQwX3Bvb2xfbGxpX2FsbG9jKGQ0MGQsIHNnbF9sZW4sIHRydWUpIDwgMCkgeworCQlpZiAoZDQwX3Bvb2xfbGxpX2FsbG9jKGQ0MGQsIGQ0MGQtPmxsaV9sZW4sIHRydWUpIDwgMCkgewogCQkJZGV2X2VycigmZDQwYy0+Y2hhbi5kZXYtPmRldmljZSwKIAkJCQkiWyVzXSBPdXQgb2YgbWVtb3J5XG4iLCBfX2Z1bmNfXyk7CiAJCQlnb3RvIGVycjsKQEAgLTE2NTQsMTUgKzE3MzYsMTcgQEAKIAkJCQkJIHNnbF9sZW4sCiAJCQkJCSBkNDBkLT5sbGlfbG9nLnNyYywKIAkJCQkJIGQ0MGMtPmxvZ19kZWYubGNzcDEsCi0JCQkJCSBkNDBjLT5kbWFfY2ZnLnNyY19pbmZvLmRhdGFfd2lkdGgpOworCQkJCQkgZDQwYy0+ZG1hX2NmZy5zcmNfaW5mby5kYXRhX3dpZHRoLAorCQkJCQkgZDQwYy0+ZG1hX2NmZy5kc3RfaW5mby5kYXRhX3dpZHRoKTsKIAogCQkodm9pZCkgZDQwX2xvZ19zZ190b19sbGkoc2dsX2RzdCwKIAkJCQkJIHNnbF9sZW4sCiAJCQkJCSBkNDBkLT5sbGlfbG9nLmRzdCwKIAkJCQkJIGQ0MGMtPmxvZ19kZWYubGNzcDMsCi0JCQkJCSBkNDBjLT5kbWFfY2ZnLmRzdF9pbmZvLmRhdGFfd2lkdGgpOworCQkJCQkgZDQwYy0+ZG1hX2NmZy5kc3RfaW5mby5kYXRhX3dpZHRoLAorCQkJCQkgZDQwYy0+ZG1hX2NmZy5zcmNfaW5mby5kYXRhX3dpZHRoKTsKIAl9IGVsc2UgewotCQlpZiAoZDQwX3Bvb2xfbGxpX2FsbG9jKGQ0MGQsIHNnbF9sZW4sIGZhbHNlKSA8IDApIHsKKwkJaWYgKGQ0MF9wb29sX2xsaV9hbGxvYyhkNDBkLCBkNDBkLT5sbGlfbGVuLCBmYWxzZSkgPCAwKSB7CiAJCQlkZXZfZXJyKCZkNDBjLT5jaGFuLmRldi0+ZGV2aWNlLAogCQkJCSJbJXNdIE91dCBvZiBtZW1vcnlcbiIsIF9fZnVuY19fKTsKIAkJCWdvdG8gZXJyOwpAQCAtMTY3NSw2ICsxNzU5LDcgQEAKIAkJCQkJdmlydF90b19waHlzKGQ0MGQtPmxsaV9waHkuc3JjKSwKIAkJCQkJZDQwYy0+c3JjX2RlZl9jZmcsCiAJCQkJCWQ0MGMtPmRtYV9jZmcuc3JjX2luZm8uZGF0YV93aWR0aCwKKwkJCQkJZDQwYy0+ZG1hX2NmZy5kc3RfaW5mby5kYXRhX3dpZHRoLAogCQkJCQlkNDBjLT5kbWFfY2ZnLnNyY19pbmZvLnBzaXplKTsKIAogCQlpZiAocmVzIDwgMCkKQEAgLTE2ODcsNiArMTc3Miw3IEBACiAJCQkJCXZpcnRfdG9fcGh5cyhkNDBkLT5sbGlfcGh5LmRzdCksCiAJCQkJCWQ0MGMtPmRzdF9kZWZfY2ZnLAogCQkJCQlkNDBjLT5kbWFfY2ZnLmRzdF9pbmZvLmRhdGFfd2lkdGgsCisJCQkJCWQ0MGMtPmRtYV9jZmcuc3JjX2luZm8uZGF0YV93aWR0aCwKIAkJCQkJZDQwYy0+ZG1hX2NmZy5kc3RfaW5mby5wc2l6ZSk7CiAKIAkJaWYgKHJlcyA8IDApCkBAIC0xODI2LDcgKzE5MTIsNiBAQAogCXN0cnVjdCBkNDBfY2hhbiAqZDQwYyA9IGNvbnRhaW5lcl9vZihjaGFuLCBzdHJ1Y3QgZDQwX2NoYW4sCiAJCQkJCSAgICAgY2hhbik7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKLQlpbnQgZXJyID0gMDsKIAogCWlmIChkNDBjLT5waHlfY2hhbiA9PSBOVUxMKSB7CiAJCWRldl9lcnIoJmQ0MGMtPmNoYW4uZGV2LT5kZXZpY2UsCkBAIC0xODQ0LDYgKzE5MjksMTUgQEAKIAl9CiAKIAlkNDBkLT50eGQuZmxhZ3MgPSBkbWFfZmxhZ3M7CisJZDQwZC0+bGxpX2xlbiA9IGQ0MF9zaXplXzJfZG1hbGVuKHNpemUsCisJCQkJCSAgZDQwYy0+ZG1hX2NmZy5zcmNfaW5mby5kYXRhX3dpZHRoLAorCQkJCQkgIGQ0MGMtPmRtYV9jZmcuZHN0X2luZm8uZGF0YV93aWR0aCk7CisJaWYgKGQ0MGQtPmxsaV9sZW4gPCAwKSB7CisJCWRldl9lcnIoJmQ0MGMtPmNoYW4uZGV2LT5kZXZpY2UsCisJCQkiWyVzXSBVbmFsaWduZWQgc2l6ZVxuIiwgX19mdW5jX18pOworCQlnb3RvIGVycjsKKwl9CisKIAogCWRtYV9hc3luY190eF9kZXNjcmlwdG9yX2luaXQoJmQ0MGQtPnR4ZCwgY2hhbik7CiAKQEAgLTE4NTEsMzcgKzE5NDUsNDAgQEAKIAogCWlmIChkNDBjLT5sb2dfbnVtICE9IEQ0MF9QSFlfQ0hBTikgewogCi0JCWlmIChkNDBfcG9vbF9sbGlfYWxsb2MoZDQwZCwgMSwgdHJ1ZSkgPCAwKSB7CisJCWlmIChkNDBfcG9vbF9sbGlfYWxsb2MoZDQwZCwgZDQwZC0+bGxpX2xlbiwgdHJ1ZSkgPCAwKSB7CiAJCQlkZXZfZXJyKCZkNDBjLT5jaGFuLmRldi0+ZGV2aWNlLAogCQkJCSJbJXNdIE91dCBvZiBtZW1vcnlcbiIsIF9fZnVuY19fKTsKIAkJCWdvdG8gZXJyOwogCQl9Ci0JCWQ0MGQtPmxsaV9sZW4gPSAxOwogCQlkNDBkLT5sbGlfY3VycmVudCA9IDA7CiAKLQkJZDQwX2xvZ19maWxsX2xsaShkNDBkLT5sbGlfbG9nLnNyYywKLQkJCQkgc3JjLAotCQkJCSBzaXplLAotCQkJCSBkNDBjLT5sb2dfZGVmLmxjc3AxLAotCQkJCSBkNDBjLT5kbWFfY2ZnLnNyY19pbmZvLmRhdGFfd2lkdGgsCi0JCQkJIHRydWUpOworCQlpZiAoZDQwX2xvZ19idWZfdG9fbGxpKGQ0MGQtPmxsaV9sb2cuc3JjLAorCQkJCSAgICAgICBzcmMsCisJCQkJICAgICAgIHNpemUsCisJCQkJICAgICAgIGQ0MGMtPmxvZ19kZWYubGNzcDEsCisJCQkJICAgICAgIGQ0MGMtPmRtYV9jZmcuc3JjX2luZm8uZGF0YV93aWR0aCwKKwkJCQkgICAgICAgZDQwYy0+ZG1hX2NmZy5kc3RfaW5mby5kYXRhX3dpZHRoLAorCQkJCSAgICAgICB0cnVlKSA9PSBOVUxMKQorCQkJZ290byBlcnI7CiAKLQkJZDQwX2xvZ19maWxsX2xsaShkNDBkLT5sbGlfbG9nLmRzdCwKLQkJCQkgZHN0LAotCQkJCSBzaXplLAotCQkJCSBkNDBjLT5sb2dfZGVmLmxjc3AzLAotCQkJCSBkNDBjLT5kbWFfY2ZnLmRzdF9pbmZvLmRhdGFfd2lkdGgsCi0JCQkJIHRydWUpOworCQlpZiAoZDQwX2xvZ19idWZfdG9fbGxpKGQ0MGQtPmxsaV9sb2cuZHN0LAorCQkJCSAgICAgICBkc3QsCisJCQkJICAgICAgIHNpemUsCisJCQkJICAgICAgIGQ0MGMtPmxvZ19kZWYubGNzcDMsCisJCQkJICAgICAgIGQ0MGMtPmRtYV9jZmcuZHN0X2luZm8uZGF0YV93aWR0aCwKKwkJCQkgICAgICAgZDQwYy0+ZG1hX2NmZy5zcmNfaW5mby5kYXRhX3dpZHRoLAorCQkJCSAgICAgICB0cnVlKSA9PSBOVUxMKQorCQkJZ290byBlcnI7CiAKIAl9IGVsc2UgewogCi0JCWlmIChkNDBfcG9vbF9sbGlfYWxsb2MoZDQwZCwgMSwgZmFsc2UpIDwgMCkgeworCQlpZiAoZDQwX3Bvb2xfbGxpX2FsbG9jKGQ0MGQsIGQ0MGQtPmxsaV9sZW4sIGZhbHNlKSA8IDApIHsKIAkJCWRldl9lcnIoJmQ0MGMtPmNoYW4uZGV2LT5kZXZpY2UsCiAJCQkJIlslc10gT3V0IG9mIG1lbW9yeVxuIiwgX19mdW5jX18pOwogCQkJZ290byBlcnI7CiAJCX0KIAotCQllcnIgPSBkNDBfcGh5X2ZpbGxfbGxpKGQ0MGQtPmxsaV9waHkuc3JjLAorCQlpZiAoZDQwX3BoeV9idWZfdG9fbGxpKGQ0MGQtPmxsaV9waHkuc3JjLAogCQkJCSAgICAgICBzcmMsCiAJCQkJICAgICAgIHNpemUsCiAJCQkJICAgICAgIGQ0MGMtPmRtYV9jZmcuc3JjX2luZm8ucHNpemUsCkBAIC0xODg5LDExICsxOTg2LDExIEBACiAJCQkJICAgICAgIGQ0MGMtPnNyY19kZWZfY2ZnLAogCQkJCSAgICAgICB0cnVlLAogCQkJCSAgICAgICBkNDBjLT5kbWFfY2ZnLnNyY19pbmZvLmRhdGFfd2lkdGgsCi0JCQkJICAgICAgIGZhbHNlKTsKLQkJaWYgKGVycikKLQkJCWdvdG8gZXJyX2ZpbGxfbGxpOworCQkJCSAgICAgICBkNDBjLT5kbWFfY2ZnLmRzdF9pbmZvLmRhdGFfd2lkdGgsCisJCQkJICAgICAgIGZhbHNlKSA9PSBOVUxMKQorCQkJZ290byBlcnI7CiAKLQkJZXJyID0gZDQwX3BoeV9maWxsX2xsaShkNDBkLT5sbGlfcGh5LmRzdCwKKwkJaWYgKGQ0MF9waHlfYnVmX3RvX2xsaShkNDBkLT5sbGlfcGh5LmRzdCwKIAkJCQkgICAgICAgZHN0LAogCQkJCSAgICAgICBzaXplLAogCQkJCSAgICAgICBkNDBjLT5kbWFfY2ZnLmRzdF9pbmZvLnBzaXplLApAQCAtMTkwMSwxMCArMTk5OCw5IEBACiAJCQkJICAgICAgIGQ0MGMtPmRzdF9kZWZfY2ZnLAogCQkJCSAgICAgICB0cnVlLAogCQkJCSAgICAgICBkNDBjLT5kbWFfY2ZnLmRzdF9pbmZvLmRhdGFfd2lkdGgsCi0JCQkJICAgICAgIGZhbHNlKTsKLQotCQlpZiAoZXJyKQotCQkJZ290byBlcnJfZmlsbF9sbGk7CisJCQkJICAgICAgIGQ0MGMtPmRtYV9jZmcuc3JjX2luZm8uZGF0YV93aWR0aCwKKwkJCQkgICAgICAgZmFsc2UpID09IE5VTEwpCisJCQlnb3RvIGVycjsKIAogCQkodm9pZCkgZG1hX21hcF9zaW5nbGUoZDQwYy0+YmFzZS0+ZGV2LCBkNDBkLT5sbGlfcGh5LnNyYywKIAkJCQkgICAgICBkNDBkLT5sbGlfcG9vbC5zaXplLCBETUFfVE9fREVWSUNFKTsKQEAgLTE5MTMsOSArMjAwOSw2IEBACiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZDQwYy0+bG9jaywgZmxhZ3MpOwogCXJldHVybiAmZDQwZC0+dHhkOwogCi1lcnJfZmlsbF9sbGk6Ci0JZGV2X2VycigmZDQwYy0+Y2hhbi5kZXYtPmRldmljZSwKLQkJIlslc10gRmFpbGVkIGZpbGxpbmcgaW4gUEhZIExMSVxuIiwgX19mdW5jX18pOwogZXJyOgogCWlmIChkNDBkKQogCQlkNDBfZGVzY19mcmVlKGQ0MGMsIGQ0MGQpOwpAQCAtMTk0NSwxMyArMjAzOCwyMSBAQAogCWRtYV9hZGRyX3QgZGV2X2FkZHIgPSAwOwogCWludCB0b3RhbF9zaXplOwogCi0JaWYgKGQ0MF9wb29sX2xsaV9hbGxvYyhkNDBkLCBzZ19sZW4sIHRydWUpIDwgMCkgeworCWQ0MGQtPmxsaV9sZW4gPSBkNDBfc2dfMl9kbWFsZW4oc2dsLCBzZ19sZW4sCisJCQkJCWQ0MGMtPmRtYV9jZmcuc3JjX2luZm8uZGF0YV93aWR0aCwKKwkJCQkJZDQwYy0+ZG1hX2NmZy5kc3RfaW5mby5kYXRhX3dpZHRoKTsKKwlpZiAoZDQwZC0+bGxpX2xlbiA8IDApIHsKKwkJZGV2X2VycigmZDQwYy0+Y2hhbi5kZXYtPmRldmljZSwKKwkJCSJbJXNdIFVuYWxpZ25lZCBzaXplXG4iLCBfX2Z1bmNfXyk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCWlmIChkNDBfcG9vbF9sbGlfYWxsb2MoZDQwZCwgZDQwZC0+bGxpX2xlbiwgdHJ1ZSkgPCAwKSB7CiAJCWRldl9lcnIoJmQ0MGMtPmNoYW4uZGV2LT5kZXZpY2UsCiAJCQkiWyVzXSBPdXQgb2YgbWVtb3J5XG4iLCBfX2Z1bmNfXyk7CiAJCXJldHVybiAtRU5PTUVNOwogCX0KIAotCWQ0MGQtPmxsaV9sZW4gPSBzZ19sZW47CiAJZDQwZC0+bGxpX2N1cnJlbnQgPSAwOwogCiAJaWYgKGRpcmVjdGlvbiA9PSBETUFfRlJPTV9ERVZJQ0UpCkBAIC0xOTkzLDEzICsyMDk0LDIxIEBACiAJZG1hX2FkZHJfdCBkc3RfZGV2X2FkZHI7CiAJaW50IHJlczsKIAotCWlmIChkNDBfcG9vbF9sbGlfYWxsb2MoZDQwZCwgc2dsX2xlbiwgZmFsc2UpIDwgMCkgeworCWQ0MGQtPmxsaV9sZW4gPSBkNDBfc2dfMl9kbWFsZW4oc2dsLCBzZ2xfbGVuLAorCQkJCQlkNDBjLT5kbWFfY2ZnLnNyY19pbmZvLmRhdGFfd2lkdGgsCisJCQkJCWQ0MGMtPmRtYV9jZmcuZHN0X2luZm8uZGF0YV93aWR0aCk7CisJaWYgKGQ0MGQtPmxsaV9sZW4gPCAwKSB7CisJCWRldl9lcnIoJmQ0MGMtPmNoYW4uZGV2LT5kZXZpY2UsCisJCQkiWyVzXSBVbmFsaWduZWQgc2l6ZVxuIiwgX19mdW5jX18pOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlpZiAoZDQwX3Bvb2xfbGxpX2FsbG9jKGQ0MGQsIGQ0MGQtPmxsaV9sZW4sIGZhbHNlKSA8IDApIHsKIAkJZGV2X2VycigmZDQwYy0+Y2hhbi5kZXYtPmRldmljZSwKIAkJCSJbJXNdIE91dCBvZiBtZW1vcnlcbiIsIF9fZnVuY19fKTsKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQogCi0JZDQwZC0+bGxpX2xlbiA9IHNnbF9sZW47CiAJZDQwZC0+bGxpX2N1cnJlbnQgPSAwOwogCiAJaWYgKGRpcmVjdGlvbiA9PSBETUFfRlJPTV9ERVZJQ0UpIHsKQEAgLTIwMjQsNiArMjEzMyw3IEBACiAJCQkJdmlydF90b19waHlzKGQ0MGQtPmxsaV9waHkuc3JjKSwKIAkJCQlkNDBjLT5zcmNfZGVmX2NmZywKIAkJCQlkNDBjLT5kbWFfY2ZnLnNyY19pbmZvLmRhdGFfd2lkdGgsCisJCQkJZDQwYy0+ZG1hX2NmZy5kc3RfaW5mby5kYXRhX3dpZHRoLAogCQkJCWQ0MGMtPmRtYV9jZmcuc3JjX2luZm8ucHNpemUpOwogCWlmIChyZXMgPCAwKQogCQlyZXR1cm4gcmVzOwpAQCAtMjAzNSw2ICsyMTQ1LDcgQEAKIAkJCQl2aXJ0X3RvX3BoeXMoZDQwZC0+bGxpX3BoeS5kc3QpLAogCQkJCWQ0MGMtPmRzdF9kZWZfY2ZnLAogCQkJCWQ0MGMtPmRtYV9jZmcuZHN0X2luZm8uZGF0YV93aWR0aCwKKwkJCQlkNDBjLT5kbWFfY2ZnLnNyY19pbmZvLmRhdGFfd2lkdGgsCiAJCQkJZDQwYy0+ZG1hX2NmZy5kc3RfaW5mby5wc2l6ZSk7CiAJaWYgKHJlcyA8IDApCiAJCXJldHVybiByZXM7CkBAIC0yMjQ0LDYgKzIzNTUsOCBAQAogCQkJcHNpemUgPSBTVEVETUE0MF9QU0laRV9QSFlfODsKIAkJZWxzZSBpZiAoY29uZmlnX21heGJ1cnN0ID49IDQpCiAJCQlwc2l6ZSA9IFNURURNQTQwX1BTSVpFX1BIWV80OworCQllbHNlIGlmIChjb25maWdfbWF4YnVyc3QgPj0gMikKKwkJCXBzaXplID0gU1RFRE1BNDBfUFNJWkVfUEhZXzI7CiAJCWVsc2UKIAkJCXBzaXplID0gU1RFRE1BNDBfUFNJWkVfUEhZXzE7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvc3RlX2RtYTQwX2xsLmMgYi9kcml2ZXJzL2RtYS9zdGVfZG1hNDBfbGwuYwppbmRleCA4NTU3Y2I4Li4wYjA5NmEzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2RtYS9zdGVfZG1hNDBfbGwuYworKysgYi9kcml2ZXJzL2RtYS9zdGVfZG1hNDBfbGwuYwpAQCAtMSw2ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIFNULUVyaWNzc29uIFNBIDIwMDctMjAxMAotICogQXV0aG9yOiBQZXIgRnJpZGVuIDxwZXIuZnJpZGVuQHN0ZXJpY3Nzb24uY29tPiBmb3IgU1QtRXJpY3Nzb24KKyAqIEF1dGhvcjogUGVyIEZvcmxpbiA8cGVyLmZvcmxpbkBzdGVyaWNzc29uLmNvbT4gZm9yIFNULUVyaWNzc29uCiAgKiBBdXRob3I6IEpvbmFzIEFhYmVyZyA8am9uYXMuYWJlcmdAc3Rlcmljc3Nvbi5jb20+IGZvciBTVC1Fcmljc3NvbgogICogTGljZW5zZSB0ZXJtczogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgdmVyc2lvbiAyCiAgKi8KQEAgLTEyMiwxNSArMTIyLDE1IEBACiAJKmRzdF9jZmcgPSBkc3Q7CiB9CiAKLWludCBkNDBfcGh5X2ZpbGxfbGxpKHN0cnVjdCBkNDBfcGh5X2xsaSAqbGxpLAotCQkgICAgIGRtYV9hZGRyX3QgZGF0YSwKLQkJICAgICB1MzIgZGF0YV9zaXplLAotCQkgICAgIGludCBwc2l6ZSwKLQkJICAgICBkbWFfYWRkcl90IG5leHRfbGxpLAotCQkgICAgIHUzMiByZWdfY2ZnLAotCQkgICAgIGJvb2wgdGVybV9pbnQsCi0JCSAgICAgdTMyIGRhdGFfd2lkdGgsCi0JCSAgICAgYm9vbCBpc19kZXZpY2UpCitzdGF0aWMgaW50IGQ0MF9waHlfZmlsbF9sbGkoc3RydWN0IGQ0MF9waHlfbGxpICpsbGksCisJCQkgICAgZG1hX2FkZHJfdCBkYXRhLAorCQkJICAgIHUzMiBkYXRhX3NpemUsCisJCQkgICAgaW50IHBzaXplLAorCQkJICAgIGRtYV9hZGRyX3QgbmV4dF9sbGksCisJCQkgICAgdTMyIHJlZ19jZmcsCisJCQkgICAgYm9vbCB0ZXJtX2ludCwKKwkJCSAgICB1MzIgZGF0YV93aWR0aCwKKwkJCSAgICBib29sIGlzX2RldmljZSkKIHsKIAlpbnQgbnVtX2VsZW1zOwogCkBAIC0xMzksMTMgKzEzOSw2IEBACiAJZWxzZQogCQludW1fZWxlbXMgPSAyIDw8IHBzaXplOwogCi0JLyoKLQkgKiBTaXplIGlzIDE2Yml0LiBkYXRhX3dpZHRoIGlzIDgsIDE2LCAzMiBvciA2NCBiaXQKLQkgKiBCbG9jayBsYXJnZSB0aGFuIDY0IEtpQiBtdXN0IGJlIHNwbGl0LgotCSAqLwotCWlmIChkYXRhX3NpemUgPiAoMHhmZmZmIDw8IGRhdGFfd2lkdGgpKQotCQlyZXR1cm4gLUVJTlZBTDsKLQogCS8qIE11c3QgYmUgYWxpZ25lZCAqLwogCWlmICghSVNfQUxJR05FRChkYXRhLCAweDEgPDwgZGF0YV93aWR0aCkpCiAJCXJldHVybiAtRUlOVkFMOwpAQCAtMTg3LDU1ICsxODAsMTE4IEBACiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyBpbnQgZDQwX3NlZ19zaXplKGludCBzaXplLCBpbnQgZGF0YV93aWR0aDEsIGludCBkYXRhX3dpZHRoMikKK3sKKwl1MzIgbWF4X3cgPSBtYXgoZGF0YV93aWR0aDEsIGRhdGFfd2lkdGgyKTsKKwl1MzIgbWluX3cgPSBtaW4oZGF0YV93aWR0aDEsIGRhdGFfd2lkdGgyKTsKKwl1MzIgc2VnX21heCA9IEFMSUdOKFNURURNQTQwX01BWF9TRUdfU0laRSA8PCBtaW5fdywgMSA8PCBtYXhfdyk7CisKKwlpZiAoc2VnX21heCA+IFNURURNQTQwX01BWF9TRUdfU0laRSkKKwkJc2VnX21heCAtPSAoMSA8PCBtYXhfdyk7CisKKwlpZiAoc2l6ZSA8PSBzZWdfbWF4KQorCQlyZXR1cm4gc2l6ZTsKKworCWlmIChzaXplIDw9IDIgKiBzZWdfbWF4KQorCQlyZXR1cm4gQUxJR04oc2l6ZSAvIDIsIDEgPDwgbWF4X3cpOworCisJcmV0dXJuIHNlZ19tYXg7Cit9CisKK3N0cnVjdCBkNDBfcGh5X2xsaSAqZDQwX3BoeV9idWZfdG9fbGxpKHN0cnVjdCBkNDBfcGh5X2xsaSAqbGxpLAorCQkJCSAgICAgICBkbWFfYWRkcl90IGFkZHIsCisJCQkJICAgICAgIHUzMiBzaXplLAorCQkJCSAgICAgICBpbnQgcHNpemUsCisJCQkJICAgICAgIGRtYV9hZGRyX3QgbGxpX3BoeXMsCisJCQkJICAgICAgIHUzMiByZWdfY2ZnLAorCQkJCSAgICAgICBib29sIHRlcm1faW50LAorCQkJCSAgICAgICB1MzIgZGF0YV93aWR0aDEsCisJCQkJICAgICAgIHUzMiBkYXRhX3dpZHRoMiwKKwkJCQkgICAgICAgYm9vbCBpc19kZXZpY2UpCit7CisJaW50IGVycjsKKwlkbWFfYWRkcl90IG5leHQgPSBsbGlfcGh5czsKKwlpbnQgc2l6ZV9yZXN0ID0gc2l6ZTsKKwlpbnQgc2l6ZV9zZWcgPSAwOworCisJZG8geworCQlzaXplX3NlZyA9IGQ0MF9zZWdfc2l6ZShzaXplX3Jlc3QsIGRhdGFfd2lkdGgxLCBkYXRhX3dpZHRoMik7CisJCXNpemVfcmVzdCAtPSBzaXplX3NlZzsKKworCQlpZiAodGVybV9pbnQgJiYgc2l6ZV9yZXN0ID09IDApCisJCQluZXh0ID0gMDsKKwkJZWxzZQorCQkJbmV4dCA9IEFMSUdOKG5leHQgKyBzaXplb2Yoc3RydWN0IGQ0MF9waHlfbGxpKSwKKwkJCQkgICAgIEQ0MF9MTElfQUxJR04pOworCisJCWVyciA9IGQ0MF9waHlfZmlsbF9sbGkobGxpLAorCQkJCSAgICAgICBhZGRyLAorCQkJCSAgICAgICBzaXplX3NlZywKKwkJCQkgICAgICAgcHNpemUsCisJCQkJICAgICAgIG5leHQsCisJCQkJICAgICAgIHJlZ19jZmcsCisJCQkJICAgICAgICFuZXh0LAorCQkJCSAgICAgICBkYXRhX3dpZHRoMSwKKwkJCQkgICAgICAgaXNfZGV2aWNlKTsKKworCQlpZiAoZXJyKQorCQkJZ290byBlcnI7CisKKwkJbGxpKys7CisJCWlmICghaXNfZGV2aWNlKQorCQkJYWRkciArPSBzaXplX3NlZzsKKwl9IHdoaWxlIChzaXplX3Jlc3QpOworCisJcmV0dXJuIGxsaTsKKworIGVycjoKKwlyZXR1cm4gTlVMTDsKK30KKwogaW50IGQ0MF9waHlfc2dfdG9fbGxpKHN0cnVjdCBzY2F0dGVybGlzdCAqc2csCiAJCSAgICAgIGludCBzZ19sZW4sCiAJCSAgICAgIGRtYV9hZGRyX3QgdGFyZ2V0LAotCQkgICAgICBzdHJ1Y3QgZDQwX3BoeV9sbGkgKmxsaSwKKwkJICAgICAgc3RydWN0IGQ0MF9waHlfbGxpICpsbGlfc2csCiAJCSAgICAgIGRtYV9hZGRyX3QgbGxpX3BoeXMsCiAJCSAgICAgIHUzMiByZWdfY2ZnLAotCQkgICAgICB1MzIgZGF0YV93aWR0aCwKKwkJICAgICAgdTMyIGRhdGFfd2lkdGgxLAorCQkgICAgICB1MzIgZGF0YV93aWR0aDIsCiAJCSAgICAgIGludCBwc2l6ZSkKIHsKIAlpbnQgdG90YWxfc2l6ZSA9IDA7CiAJaW50IGk7CiAJc3RydWN0IHNjYXR0ZXJsaXN0ICpjdXJyZW50X3NnID0gc2c7Ci0JZG1hX2FkZHJfdCBuZXh0X2xsaV9waHlzOwogCWRtYV9hZGRyX3QgZHN0OwotCWludCBlcnIgPSAwOworCXN0cnVjdCBkNDBfcGh5X2xsaSAqbGxpID0gbGxpX3NnOworCWRtYV9hZGRyX3QgbF9waHlzID0gbGxpX3BoeXM7CiAKIAlmb3JfZWFjaF9zZyhzZywgY3VycmVudF9zZywgc2dfbGVuLCBpKSB7CiAKIAkJdG90YWxfc2l6ZSArPSBzZ19kbWFfbGVuKGN1cnJlbnRfc2cpOwogCi0JCS8qIElmIHRoaXMgc2NhdHRlciBsaXN0IGVudHJ5IGlzIHRoZSBsYXN0IG9uZSwgbm8gbmV4dCBsaW5rICovCi0JCWlmIChzZ19sZW4gLSAxID09IGkpCi0JCQluZXh0X2xsaV9waHlzID0gMDsKLQkJZWxzZQotCQkJbmV4dF9sbGlfcGh5cyA9IEFMSUdOKGxsaV9waHlzICsgKGkgKyAxKSAqCi0JCQkJCSAgICAgIHNpemVvZihzdHJ1Y3QgZDQwX3BoeV9sbGkpLAotCQkJCQkgICAgICBENDBfTExJX0FMSUdOKTsKLQogCQlpZiAodGFyZ2V0KQogCQkJZHN0ID0gdGFyZ2V0OwogCQllbHNlCiAJCQlkc3QgPSBzZ19waHlzKGN1cnJlbnRfc2cpOwogCi0JCWVyciA9IGQ0MF9waHlfZmlsbF9sbGkoJmxsaVtpXSwKLQkJCQkgICAgICAgZHN0LAotCQkJCSAgICAgICBzZ19kbWFfbGVuKGN1cnJlbnRfc2cpLAotCQkJCSAgICAgICBwc2l6ZSwKLQkJCQkgICAgICAgbmV4dF9sbGlfcGh5cywKLQkJCQkgICAgICAgcmVnX2NmZywKLQkJCQkgICAgICAgIW5leHRfbGxpX3BoeXMsCi0JCQkJICAgICAgIGRhdGFfd2lkdGgsCi0JCQkJICAgICAgIHRhcmdldCA9PSBkc3QpOwotCQlpZiAoZXJyKQotCQkJZ290byBlcnI7CisJCWxfcGh5cyA9IEFMSUdOKGxsaV9waHlzICsgKGxsaSAtIGxsaV9zZykgKgorCQkJICAgICAgIHNpemVvZihzdHJ1Y3QgZDQwX3BoeV9sbGkpLCBENDBfTExJX0FMSUdOKTsKKworCQlsbGkgPSBkNDBfcGh5X2J1Zl90b19sbGkobGxpLAorCQkJCQkgZHN0LAorCQkJCQkgc2dfZG1hX2xlbihjdXJyZW50X3NnKSwKKwkJCQkJIHBzaXplLAorCQkJCQkgbF9waHlzLAorCQkJCQkgcmVnX2NmZywKKwkJCQkJIHNnX2xlbiAtIDEgPT0gaSwKKwkJCQkJIGRhdGFfd2lkdGgxLAorCQkJCQkgZGF0YV93aWR0aDIsCisJCQkJCSB0YXJnZXQgPT0gZHN0KTsKKwkJaWYgKGxsaSA9PSBOVUxMKQorCQkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCiAJcmV0dXJuIHRvdGFsX3NpemU7Ci1lcnI6Ci0JcmV0dXJuIGVycjsKIH0KIAogCkBAIC0zMTUsMTcgKzM3MSwyMCBAQAogCXdyaXRlbChsbGlfZHN0LT5sY3NwMTMsICZsY2xhWzFdLmxjc3AxMyk7CiB9CiAKLXZvaWQgZDQwX2xvZ19maWxsX2xsaShzdHJ1Y3QgZDQwX2xvZ19sbGkgKmxsaSwKLQkJICAgICAgZG1hX2FkZHJfdCBkYXRhLCB1MzIgZGF0YV9zaXplLAotCQkgICAgICB1MzIgcmVnX2NmZywKLQkJICAgICAgdTMyIGRhdGFfd2lkdGgsCi0JCSAgICAgIGJvb2wgYWRkcl9pbmMpCitzdGF0aWMgdm9pZCBkNDBfbG9nX2ZpbGxfbGxpKHN0cnVjdCBkNDBfbG9nX2xsaSAqbGxpLAorCQkJICAgICBkbWFfYWRkcl90IGRhdGEsIHUzMiBkYXRhX3NpemUsCisJCQkgICAgIHUzMiByZWdfY2ZnLAorCQkJICAgICB1MzIgZGF0YV93aWR0aCwKKwkJCSAgICAgYm9vbCBhZGRyX2luYykKIHsKIAlsbGktPmxjc3AxMyA9IHJlZ19jZmc7CiAKIAkvKiBUaGUgbnVtYmVyIG9mIGVsZW1lbnRzIHRvIHRyYW5zZmVyICovCiAJbGxpLT5sY3NwMDIgPSAoKGRhdGFfc2l6ZSA+PiBkYXRhX3dpZHRoKSA8PAogCQkgICAgICAgRDQwX01FTV9MQ1NQMF9FQ05UX1BPUykgJiBENDBfTUVNX0xDU1AwX0VDTlRfTUFTSzsKKworCUJVR19PTigoZGF0YV9zaXplID4+IGRhdGFfd2lkdGgpID4gU1RFRE1BNDBfTUFYX1NFR19TSVpFKTsKKwogCS8qIDE2IExTQnMgYWRkcmVzcyBvZiB0aGUgY3VycmVudCBlbGVtZW50ICovCiAJbGxpLT5sY3NwMDIgfD0gZGF0YSAmIEQ0MF9NRU1fTENTUDBfU1BUUl9NQVNLOwogCS8qIDE2IE1TQnMgYWRkcmVzcyBvZiB0aGUgY3VycmVudCBlbGVtZW50ICovCkBAIC0zNDgsNTUgKzQwNyw5NCBAQAogCWludCB0b3RhbF9zaXplID0gMDsKIAlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKmN1cnJlbnRfc2cgPSBzZzsKIAlpbnQgaTsKKwlzdHJ1Y3QgZDQwX2xvZ19sbGkgKmxsaV9zcmMgPSBsbGktPnNyYzsKKwlzdHJ1Y3QgZDQwX2xvZ19sbGkgKmxsaV9kc3QgPSBsbGktPmRzdDsKIAogCWZvcl9lYWNoX3NnKHNnLCBjdXJyZW50X3NnLCBzZ19sZW4sIGkpIHsKIAkJdG90YWxfc2l6ZSArPSBzZ19kbWFfbGVuKGN1cnJlbnRfc2cpOwogCiAJCWlmIChkaXJlY3Rpb24gPT0gRE1BX1RPX0RFVklDRSkgewotCQkJZDQwX2xvZ19maWxsX2xsaSgmbGxpLT5zcmNbaV0sCi0JCQkJCSBzZ19waHlzKGN1cnJlbnRfc2cpLAotCQkJCQkgc2dfZG1hX2xlbihjdXJyZW50X3NnKSwKLQkJCQkJIGxjc3AtPmxjc3AxLCBzcmNfZGF0YV93aWR0aCwKLQkJCQkJIHRydWUpOwotCQkJZDQwX2xvZ19maWxsX2xsaSgmbGxpLT5kc3RbaV0sCi0JCQkJCSBkZXZfYWRkciwKLQkJCQkJIHNnX2RtYV9sZW4oY3VycmVudF9zZyksCi0JCQkJCSBsY3NwLT5sY3NwMywgZHN0X2RhdGFfd2lkdGgsCi0JCQkJCSBmYWxzZSk7CisJCQlsbGlfc3JjID0KKwkJCQlkNDBfbG9nX2J1Zl90b19sbGkobGxpX3NyYywKKwkJCQkJCSAgIHNnX3BoeXMoY3VycmVudF9zZyksCisJCQkJCQkgICBzZ19kbWFfbGVuKGN1cnJlbnRfc2cpLAorCQkJCQkJICAgbGNzcC0+bGNzcDEsIHNyY19kYXRhX3dpZHRoLAorCQkJCQkJICAgZHN0X2RhdGFfd2lkdGgsCisJCQkJCQkgICB0cnVlKTsKKwkJCWxsaV9kc3QgPQorCQkJCWQ0MF9sb2dfYnVmX3RvX2xsaShsbGlfZHN0LAorCQkJCQkJICAgZGV2X2FkZHIsCisJCQkJCQkgICBzZ19kbWFfbGVuKGN1cnJlbnRfc2cpLAorCQkJCQkJICAgbGNzcC0+bGNzcDMsIGRzdF9kYXRhX3dpZHRoLAorCQkJCQkJICAgc3JjX2RhdGFfd2lkdGgsCisJCQkJCQkgICBmYWxzZSk7CiAJCX0gZWxzZSB7Ci0JCQlkNDBfbG9nX2ZpbGxfbGxpKCZsbGktPmRzdFtpXSwKLQkJCQkJIHNnX3BoeXMoY3VycmVudF9zZyksCi0JCQkJCSBzZ19kbWFfbGVuKGN1cnJlbnRfc2cpLAotCQkJCQkgbGNzcC0+bGNzcDMsIGRzdF9kYXRhX3dpZHRoLAotCQkJCQkgdHJ1ZSk7Ci0JCQlkNDBfbG9nX2ZpbGxfbGxpKCZsbGktPnNyY1tpXSwKLQkJCQkJIGRldl9hZGRyLAotCQkJCQkgc2dfZG1hX2xlbihjdXJyZW50X3NnKSwKLQkJCQkJIGxjc3AtPmxjc3AxLCBzcmNfZGF0YV93aWR0aCwKLQkJCQkJIGZhbHNlKTsKKwkJCWxsaV9kc3QgPQorCQkJCWQ0MF9sb2dfYnVmX3RvX2xsaShsbGlfZHN0LAorCQkJCQkJICAgc2dfcGh5cyhjdXJyZW50X3NnKSwKKwkJCQkJCSAgIHNnX2RtYV9sZW4oY3VycmVudF9zZyksCisJCQkJCQkgICBsY3NwLT5sY3NwMywgZHN0X2RhdGFfd2lkdGgsCisJCQkJCQkgICBzcmNfZGF0YV93aWR0aCwKKwkJCQkJCSAgIHRydWUpOworCQkJbGxpX3NyYyA9CisJCQkJZDQwX2xvZ19idWZfdG9fbGxpKGxsaV9zcmMsCisJCQkJCQkgICBkZXZfYWRkciwKKwkJCQkJCSAgIHNnX2RtYV9sZW4oY3VycmVudF9zZyksCisJCQkJCQkgICBsY3NwLT5sY3NwMSwgc3JjX2RhdGFfd2lkdGgsCisJCQkJCQkgICBkc3RfZGF0YV93aWR0aCwKKwkJCQkJCSAgIGZhbHNlKTsKIAkJfQogCX0KIAlyZXR1cm4gdG90YWxfc2l6ZTsKIH0KIAorc3RydWN0IGQ0MF9sb2dfbGxpICpkNDBfbG9nX2J1Zl90b19sbGkoc3RydWN0IGQ0MF9sb2dfbGxpICpsbGlfc2csCisJCQkJICAgICAgIGRtYV9hZGRyX3QgYWRkciwKKwkJCQkgICAgICAgaW50IHNpemUsCisJCQkJICAgICAgIHUzMiBsY3NwMTMsIC8qIHNyYyBvciBkc3QqLworCQkJCSAgICAgICB1MzIgZGF0YV93aWR0aDEsCisJCQkJICAgICAgIHUzMiBkYXRhX3dpZHRoMiwKKwkJCQkgICAgICAgYm9vbCBhZGRyX2luYykKK3sKKwlzdHJ1Y3QgZDQwX2xvZ19sbGkgKmxsaSA9IGxsaV9zZzsKKwlpbnQgc2l6ZV9yZXN0ID0gc2l6ZTsKKwlpbnQgc2l6ZV9zZWcgPSAwOworCisJZG8geworCQlzaXplX3NlZyA9IGQ0MF9zZWdfc2l6ZShzaXplX3Jlc3QsIGRhdGFfd2lkdGgxLCBkYXRhX3dpZHRoMik7CisJCXNpemVfcmVzdCAtPSBzaXplX3NlZzsKKworCQlkNDBfbG9nX2ZpbGxfbGxpKGxsaSwKKwkJCQkgYWRkciwKKwkJCQkgc2l6ZV9zZWcsCisJCQkJIGxjc3AxMywgZGF0YV93aWR0aDEsCisJCQkJIGFkZHJfaW5jKTsKKwkJaWYgKGFkZHJfaW5jKQorCQkJYWRkciArPSBzaXplX3NlZzsKKwkJbGxpKys7CisJfSB3aGlsZSAoc2l6ZV9yZXN0KTsKKworCXJldHVybiBsbGk7Cit9CisKIGludCBkNDBfbG9nX3NnX3RvX2xsaShzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLAogCQkgICAgICBpbnQgc2dfbGVuLAogCQkgICAgICBzdHJ1Y3QgZDQwX2xvZ19sbGkgKmxsaV9zZywKIAkJICAgICAgdTMyIGxjc3AxMywgLyogc3JjIG9yIGRzdCovCi0JCSAgICAgIHUzMiBkYXRhX3dpZHRoKQorCQkgICAgICB1MzIgZGF0YV93aWR0aDEsIHUzMiBkYXRhX3dpZHRoMikKIHsKIAlpbnQgdG90YWxfc2l6ZSA9IDA7CiAJc3RydWN0IHNjYXR0ZXJsaXN0ICpjdXJyZW50X3NnID0gc2c7CiAJaW50IGk7CisJc3RydWN0IGQ0MF9sb2dfbGxpICpsbGkgPSBsbGlfc2c7CiAKIAlmb3JfZWFjaF9zZyhzZywgY3VycmVudF9zZywgc2dfbGVuLCBpKSB7CiAJCXRvdGFsX3NpemUgKz0gc2dfZG1hX2xlbihjdXJyZW50X3NnKTsKLQotCQlkNDBfbG9nX2ZpbGxfbGxpKCZsbGlfc2dbaV0sCi0JCQkJIHNnX3BoeXMoY3VycmVudF9zZyksCi0JCQkJIHNnX2RtYV9sZW4oY3VycmVudF9zZyksCi0JCQkJIGxjc3AxMywgZGF0YV93aWR0aCwKLQkJCQkgdHJ1ZSk7CisJCWxsaSA9IGQ0MF9sb2dfYnVmX3RvX2xsaShsbGksCisJCQkJCSBzZ19waHlzKGN1cnJlbnRfc2cpLAorCQkJCQkgc2dfZG1hX2xlbihjdXJyZW50X3NnKSwKKwkJCQkJIGxjc3AxMywKKwkJCQkJIGRhdGFfd2lkdGgxLCBkYXRhX3dpZHRoMiwgdHJ1ZSk7CiAJfQogCXJldHVybiB0b3RhbF9zaXplOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEvc3RlX2RtYTQwX2xsLmggYi9kcml2ZXJzL2RtYS9zdGVfZG1hNDBfbGwuaAppbmRleCA5ZTQxOWI5Li45Y2M0MzQ5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2RtYS9zdGVfZG1hNDBfbGwuaAorKysgYi9kcml2ZXJzL2RtYS9zdGVfZG1hNDBfbGwuaApAQCAtMjkyLDE4ICsyOTIsMjAgQEAKIAkJICAgICAgc3RydWN0IGQ0MF9waHlfbGxpICpsbGksCiAJCSAgICAgIGRtYV9hZGRyX3QgbGxpX3BoeXMsCiAJCSAgICAgIHUzMiByZWdfY2ZnLAotCQkgICAgICB1MzIgZGF0YV93aWR0aCwKKwkJICAgICAgdTMyIGRhdGFfd2lkdGgxLAorCQkgICAgICB1MzIgZGF0YV93aWR0aDIsCiAJCSAgICAgIGludCBwc2l6ZSk7CiAKLWludCBkNDBfcGh5X2ZpbGxfbGxpKHN0cnVjdCBkNDBfcGh5X2xsaSAqbGxpLAotCQkgICAgIGRtYV9hZGRyX3QgZGF0YSwKLQkJICAgICB1MzIgZGF0YV9zaXplLAotCQkgICAgIGludCBwc2l6ZSwKLQkJICAgICBkbWFfYWRkcl90IG5leHRfbGxpLAotCQkgICAgIHUzMiByZWdfY2ZnLAotCQkgICAgIGJvb2wgdGVybV9pbnQsCi0JCSAgICAgdTMyIGRhdGFfd2lkdGgsCi0JCSAgICAgYm9vbCBpc19kZXZpY2UpOworc3RydWN0IGQ0MF9waHlfbGxpICpkNDBfcGh5X2J1Zl90b19sbGkoc3RydWN0IGQ0MF9waHlfbGxpICpsbGksCisJCQkJICAgICAgIGRtYV9hZGRyX3QgZGF0YSwKKwkJCQkgICAgICAgdTMyIGRhdGFfc2l6ZSwKKwkJCQkgICAgICAgaW50IHBzaXplLAorCQkJCSAgICAgICBkbWFfYWRkcl90IG5leHRfbGxpLAorCQkJCSAgICAgICB1MzIgcmVnX2NmZywKKwkJCQkgICAgICAgYm9vbCB0ZXJtX2ludCwKKwkJCQkgICAgICAgdTMyIGRhdGFfd2lkdGgxLAorCQkJCSAgICAgICB1MzIgZGF0YV93aWR0aDIsCisJCQkJICAgICAgIGJvb2wgaXNfZGV2aWNlKTsKIAogdm9pZCBkNDBfcGh5X2xsaV93cml0ZSh2b2lkIF9faW9tZW0gKnZpcnRiYXNlLAogCQkgICAgICAgdTMyIHBoeV9jaGFuX251bSwKQEAgLTMxMiwxMiArMzE0LDEyIEBACiAKIC8qIExvZ2ljYWwgY2hhbm5lbHMgKi8KIAotdm9pZCBkNDBfbG9nX2ZpbGxfbGxpKHN0cnVjdCBkNDBfbG9nX2xsaSAqbGxpLAotCQkgICAgICBkbWFfYWRkcl90IGRhdGEsCi0JCSAgICAgIHUzMiBkYXRhX3NpemUsCi0JCSAgICAgIHUzMiByZWdfY2ZnLAotCQkgICAgICB1MzIgZGF0YV93aWR0aCwKLQkJICAgICAgYm9vbCBhZGRyX2luYyk7CitzdHJ1Y3QgZDQwX2xvZ19sbGkgKmQ0MF9sb2dfYnVmX3RvX2xsaShzdHJ1Y3QgZDQwX2xvZ19sbGkgKmxsaV9zZywKKwkJCQkgICAgICAgZG1hX2FkZHJfdCBhZGRyLAorCQkJCSAgICAgICBpbnQgc2l6ZSwKKwkJCQkgICAgICAgdTMyIGxjc3AxMywgLyogc3JjIG9yIGRzdCovCisJCQkJICAgICAgIHUzMiBkYXRhX3dpZHRoMSwgdTMyIGRhdGFfd2lkdGgyLAorCQkJCSAgICAgICBib29sIGFkZHJfaW5jKTsKIAogaW50IGQ0MF9sb2dfc2dfdG9fZGV2KHN0cnVjdCBzY2F0dGVybGlzdCAqc2csCiAJCSAgICAgIGludCBzZ19sZW4sCkBAIC0zMzIsNyArMzM0LDcgQEAKIAkJICAgICAgaW50IHNnX2xlbiwKIAkJICAgICAgc3RydWN0IGQ0MF9sb2dfbGxpICpsbGlfc2csCiAJCSAgICAgIHUzMiBsY3NwMTMsIC8qIHNyYyBvciBkc3QqLwotCQkgICAgICB1MzIgZGF0YV93aWR0aCk7CisJCSAgICAgIHUzMiBkYXRhX3dpZHRoMSwgdTMyIGRhdGFfd2lkdGgyKTsKIAogdm9pZCBkNDBfbG9nX2xsaV9sY3BhX3dyaXRlKHN0cnVjdCBkNDBfbG9nX2xsaV9mdWxsICpsY3BhLAogCQkJICAgIHN0cnVjdCBkNDBfbG9nX2xsaSAqbGxpX2RzdCwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZWRhYy9hbWQ2NF9lZGFjLmMgYi9kcml2ZXJzL2VkYWMvYW1kNjRfZWRhYy5jCmluZGV4IDRhNWVjYzUuLjIzZTAzNTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZWRhYy9hbWQ2NF9lZGFjLmMKKysrIGIvZHJpdmVycy9lZGFjL2FtZDY0X2VkYWMuYwpAQCAtODI2LDggKzgyNiw2IEBACiAvKiBEaXNwbGF5IGFuZCBkZWNvZGUgdmFyaW91cyBOQiByZWdpc3RlcnMgZm9yIGRlYnVnIHB1cnBvc2VzLiAqLwogc3RhdGljIHZvaWQgYW1kNjRfZHVtcF9taXNjX3JlZ3Moc3RydWN0IGFtZDY0X3B2dCAqcHZ0KQogewotCWludCBnYW5nZWQ7Ci0KIAlkZWJ1Z2YxKCJGM3hFOCAoTkIgQ2FwKTogMHglMDh4XG4iLCBwdnQtPm5iY2FwKTsKIAogCWRlYnVnZjEoIiAgTkIgdHdvIGNoYW5uZWwgRFJBTSBjYXBhYmxlOiAlc1xuIiwKQEAgLTg1MSwyOCArODQ5LDE5IEBACiAJZGVidWdmMSgiICBEcmFtSG9sZVZhbGlkOiAlc1xuIiwKIAkJKHB2dC0+ZGhhciAmIERIQVJfVkFMSUQpID8gInllcyIgOiAibm8iKTsKIAorCWFtZDY0X2RlYnVnX2Rpc3BsYXlfZGltbV9zaXplcygwLCBwdnQpOworCiAJLyogZXZlcnl0aGluZyBiZWxvdyB0aGlzIHBvaW50IGlzIEZhbTEwaCBhbmQgYWJvdmUgKi8KLQlpZiAoYm9vdF9jcHVfZGF0YS54ODYgPT0gMHhmKSB7Ci0JCWFtZDY0X2RlYnVnX2Rpc3BsYXlfZGltbV9zaXplcygwLCBwdnQpOworCWlmIChib290X2NwdV9kYXRhLng4NiA9PSAweGYpCiAJCXJldHVybjsKLQl9CisKKwlhbWQ2NF9kZWJ1Z19kaXNwbGF5X2RpbW1fc2l6ZXMoMSwgcHZ0KTsKIAogCWFtZDY0X2luZm8oInVzaW5nICVzIHN5bmRyb21lcy5cbiIsICgocHZ0LT5zeW5fdHlwZSA9PSA4KSA/ICJ4OCIgOiAieDQiKSk7CiAKIAkvKiBPbmx5IGlmIE5PVCBnYW5nZWQgZG9lcyBkY2xyMSBoYXZlIHZhbGlkIGluZm8gKi8KIAlpZiAoIWRjdF9nYW5naW5nX2VuYWJsZWQocHZ0KSkKIAkJYW1kNjRfZHVtcF9kcmFtY2ZnX2xvdyhwdnQtPmRjbHIxLCAxKTsKLQotCS8qCi0JICogRGV0ZXJtaW5lIGlmIGdhbmdlZCBhbmQgdGhlbiBkdW1wIG1lbW9yeSBzaXplcyBmb3IgZmlyc3QgY29udHJvbGxlciwKLQkgKiBhbmQgaWYgTk9UIGdhbmdlZCBkdW1wIGluZm8gZm9yIDJuZCBjb250cm9sbGVyLgotCSAqLwotCWdhbmdlZCA9IGRjdF9nYW5naW5nX2VuYWJsZWQocHZ0KTsKLQotCWFtZDY0X2RlYnVnX2Rpc3BsYXlfZGltbV9zaXplcygwLCBwdnQpOwotCi0JaWYgKCFnYW5nZWQpCi0JCWFtZDY0X2RlYnVnX2Rpc3BsYXlfZGltbV9zaXplcygxLCBwdnQpOwogfQogCiAvKiBSZWFkIGluIGJvdGggb2YgREJBTSByZWdpc3RlcnMgKi8KQEAgLTE2NDQsMTEgKzE2MzMsMTAgQEAKIAkJICAgICAgIFdBUk5fT04oY3RybCAhPSAwKTsKIAl9CiAKLQlkZWJ1Z2YxKCJGMnglZDgwIChEUkFNIEJhbmsgQWRkcmVzcyBNYXBwaW5nKTogMHglMDh4XG4iLAotCQljdHJsLCBjdHJsID8gcHZ0LT5kYmFtMSA6IHB2dC0+ZGJhbTApOworCWRiYW0gPSAoY3RybCAmJiAhZGN0X2dhbmdpbmdfZW5hYmxlZChwdnQpKSA/IHB2dC0+ZGJhbTEgOiBwdnQtPmRiYW0wOworCWRjc2IgPSAoY3RybCAmJiAhZGN0X2dhbmdpbmdfZW5hYmxlZChwdnQpKSA/IHB2dC0+ZGNzYjEgOiBwdnQtPmRjc2IwOwogCi0JZGJhbSA9IGN0cmwgPyBwdnQtPmRiYW0xIDogcHZ0LT5kYmFtMDsKLQlkY3NiID0gY3RybCA/IHB2dC0+ZGNzYjEgOiBwdnQtPmRjc2IwOworCWRlYnVnZjEoIkYyeCVkODAgKERSQU0gQmFuayBBZGRyZXNzIE1hcHBpbmcpOiAweCUwOHhcbiIsIGN0cmwsIGRiYW0pOwogCiAJZWRhY19wcmludGsoS0VSTl9ERUJVRywgRURBQ19NQywgIkRDVCVkIGNoaXAgc2VsZWN0czpcbiIsIGN0cmwpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2ZpcmV3aXJlL0tjb25maWcgYi9kcml2ZXJzL2ZpcmV3aXJlL0tjb25maWcKaW5kZXggNjhmOTQyYy4uMGM1Njk4OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9maXJld2lyZS9LY29uZmlnCisrKyBiL2RyaXZlcnMvZmlyZXdpcmUvS2NvbmZpZwpAQCAtNDksMTUgKzQ5LDEzIEBACiAJICBjb25maWd1cmF0aW9uIHNlY3Rpb24uCiAKIGNvbmZpZyBGSVJFV0lSRV9ORVQKLQl0cmlzdGF0ZSAiSVAgbmV0d29ya2luZyBvdmVyIDEzOTQgKEVYUEVSSU1FTlRBTCkiCi0JZGVwZW5kcyBvbiBGSVJFV0lSRSAmJiBJTkVUICYmIEVYUEVSSU1FTlRBTAorCXRyaXN0YXRlICJJUCBuZXR3b3JraW5nIG92ZXIgMTM5NCIKKwlkZXBlbmRzIG9uIEZJUkVXSVJFICYmIElORVQKIAloZWxwCiAJICBUaGlzIGVuYWJsZXMgSVB2NCBvdmVyIElFRUUgMTM5NCwgcHJvdmlkaW5nIElQIGNvbm5lY3Rpdml0eSB3aXRoCiAJICBvdGhlciBpbXBsZW1lbnRhdGlvbnMgb2YgUkZDIDI3MzQgYXMgZm91bmQgb24gc2V2ZXJhbCBvcGVyYXRpbmcKIAkgIHN5c3RlbXMuICBNdWx0aWNhc3Qgc3VwcG9ydCBpcyBjdXJyZW50bHkgbGltaXRlZC4KIAotCSAgTk9URSwgdGhpcyBkcml2ZXIgaXMgbm90IHN0YWJsZSB5ZXQhCi0KIAkgIFRvIGNvbXBpbGUgdGhpcyBkcml2ZXIgYXMgYSBtb2R1bGUsIHNheSBNIGhlcmU6ICBUaGUgbW9kdWxlIHdpbGwgYmUKIAkgIGNhbGxlZCBmaXJld2lyZS1uZXQuCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZmlyZXdpcmUvY29yZS1jYXJkLmMgYi9kcml2ZXJzL2ZpcmV3aXJlL2NvcmUtY2FyZC5jCmluZGV4IGJlMDQ5MjMuLjI0ZmYzNTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZmlyZXdpcmUvY29yZS1jYXJkLmMKKysrIGIvZHJpdmVycy9maXJld2lyZS9jb3JlLWNhcmQuYwpAQCAtNzUsNiArNzUsOCBAQAogI2RlZmluZSBCSUJfSVJNQwkJKCgxKSA8PCAzMSkKICNkZWZpbmUgTk9ERV9DQVBBQklMSVRJRVMJMHgwYzAwODNjMCAvKiBwZXIgSUVFRSAxMzk0IGNsYXVzZSA4LjMuMi42LjUuMiAqLwogCisjZGVmaW5lIENBTk9OX09VSQkJMHgwMDAwODUKKwogc3RhdGljIHZvaWQgZ2VuZXJhdGVfY29uZmlnX3JvbShzdHJ1Y3QgZndfY2FyZCAqY2FyZCwgX19iZTMyICpjb25maWdfcm9tKQogewogCXN0cnVjdCBmd19kZXNjcmlwdG9yICpkZXNjOwpAQCAtMjg0LDYgKzI4Niw3IEBACiAJYm9vbCByb290X2RldmljZV9pc19ydW5uaW5nOwogCWJvb2wgcm9vdF9kZXZpY2VfaXNfY21jOwogCWJvb2wgaXJtX2lzXzEzOTRfMTk5NV9vbmx5OworCWJvb2wga2VlcF90aGlzX2lybTsKIAogCXNwaW5fbG9ja19pcnEoJmNhcmQtPmxvY2spOwogCkBAIC0zMDUsNiArMzA4LDEwIEBACiAJaXJtX2lzXzEzOTRfMTk5NV9vbmx5ID0gaXJtX2RldmljZSAmJiBpcm1fZGV2aWNlLT5jb25maWdfcm9tICYmCiAJCQkoaXJtX2RldmljZS0+Y29uZmlnX3JvbVsyXSAmIDB4MDAwMDAwZjApID09IDA7CiAKKwkvKiBDYW5vbiBNVjVpIHdvcmtzIHVucmVsaWFibHkgaWYgaXQgaXMgbm90IHJvb3Qgbm9kZS4gKi8KKwlrZWVwX3RoaXNfaXJtID0gaXJtX2RldmljZSAmJiBpcm1fZGV2aWNlLT5jb25maWdfcm9tICYmCisJCQlpcm1fZGV2aWNlLT5jb25maWdfcm9tWzNdID4+IDggPT0gQ0FOT05fT1VJOworCiAJcm9vdF9pZCAgPSByb290X25vZGUtPm5vZGVfaWQ7CiAJaXJtX2lkICAgPSBjYXJkLT5pcm1fbm9kZS0+bm9kZV9pZDsKIAlsb2NhbF9pZCA9IGNhcmQtPmxvY2FsX25vZGUtPm5vZGVfaWQ7CkBAIC0zMzMsNyArMzQwLDcgQEAKIAkJCWdvdG8gcGlja19tZTsKIAkJfQogCi0JCWlmIChpcm1faXNfMTM5NF8xOTk1X29ubHkpIHsKKwkJaWYgKGlybV9pc18xMzk0XzE5OTVfb25seSAmJiAha2VlcF90aGlzX2lybSkgewogCQkJbmV3X3Jvb3RfaWQgPSBsb2NhbF9pZDsKIAkJCWZ3X25vdGlmeSgiJXMsIG1ha2luZyBsb2NhbCBub2RlICglMDJ4KSByb290LlxuIiwKIAkJCQkgICJJUk0gaXMgbm90IDEzOTRhIGNvbXBsaWFudCIsIG5ld19yb290X2lkKTsKQEAgLTM4Miw3ICszODksNyBAQAogCiAJCXNwaW5fbG9ja19pcnEoJmNhcmQtPmxvY2spOwogCi0JCWlmIChyY29kZSAhPSBSQ09ERV9DT01QTEVURSkgeworCQlpZiAocmNvZGUgIT0gUkNPREVfQ09NUExFVEUgJiYgIWtlZXBfdGhpc19pcm0pIHsKIAkJCS8qCiAJCQkgKiBUaGUgbG9jayByZXF1ZXN0IGZhaWxlZCwgbWF5YmUgdGhlIElSTQogCQkJICogaXNuJ3QgcmVhbGx5IElSTSBjYXBhYmxlIGFmdGVyIGFsbC4gTGV0J3MKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZmlyZXdpcmUvbmV0LmMgYi9kcml2ZXJzL2ZpcmV3aXJlL25ldC5jCmluZGV4IGMyZTE5NGMuLjdlZDA4ZmQxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2ZpcmV3aXJlL25ldC5jCisrKyBiL2RyaXZlcnMvZmlyZXdpcmUvbmV0LmMKQEAgLTE5MSw2ICsxOTEsNyBAQAogCXN0cnVjdCBmd25ldF9kZXZpY2UgKmRldjsKIAl1NjQgZ3VpZDsKIAl1NjQgZmlmbzsKKwlfX2JlMzIgaXA7CiAKIAkvKiBndWFyZGVkIGJ5IGRldi0+bG9jayAqLwogCXN0cnVjdCBsaXN0X2hlYWQgcGRfbGlzdDsgLyogcmVjZWl2ZWQgcGFydGlhbCBkYXRhZ3JhbXMgKi8KQEAgLTU3MCw2ICs1NzEsOCBAQAogCQkJCXBlZXItPnNwZWVkID0gc3NwZDsKIAkJCWlmIChwZWVyLT5tYXhfcGF5bG9hZCA+IG1heF9wYXlsb2FkKQogCQkJCXBlZXItPm1heF9wYXlsb2FkID0gbWF4X3BheWxvYWQ7CisKKwkJCXBlZXItPmlwID0gYXJwMTM5NC0+c2lwOwogCQl9CiAJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRldi0+bG9jaywgZmxhZ3MpOwogCkBAIC0xNDcwLDYgKzE0NzMsNyBAQAogCXBlZXItPmRldiA9IGRldjsKIAlwZWVyLT5ndWlkID0gKHU2NClkZXZpY2UtPmNvbmZpZ19yb21bM10gPDwgMzIgfCBkZXZpY2UtPmNvbmZpZ19yb21bNF07CiAJcGVlci0+ZmlmbyA9IEZXTkVUX05PX0ZJRk9fQUREUjsKKwlwZWVyLT5pcCA9IDA7CiAJSU5JVF9MSVNUX0hFQUQoJnBlZXItPnBkX2xpc3QpOwogCXBlZXItPnBkZ19zaXplID0gMDsKIAlwZWVyLT5kYXRhZ3JhbV9sYWJlbCA9IDA7CkBAIC0xNTg5LDEwICsxNTkzLDEzIEBACiAKIAltdXRleF9sb2NrKCZmd25ldF9kZXZpY2VfbXV0ZXgpOwogCisJbmV0ID0gZGV2LT5uZXRkZXY7CisJaWYgKG5ldCAmJiBwZWVyLT5pcCkKKwkJYXJwX2ludmFsaWRhdGUobmV0LCBwZWVyLT5pcCk7CisKIAlmd25ldF9yZW1vdmVfcGVlcihwZWVyLCBkZXYpOwogCiAJaWYgKGxpc3RfZW1wdHkoJmRldi0+cGVlcl9saXN0KSkgewotCQluZXQgPSBkZXYtPm5ldGRldjsKIAkJdW5yZWdpc3Rlcl9uZXRkZXYobmV0KTsKIAogCQlpZiAoZGV2LT5sb2NhbF9maWZvICE9IEZXTkVUX05PX0ZJRk9fQUREUikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZmlybXdhcmUvS2NvbmZpZyBiL2RyaXZlcnMvZmlybXdhcmUvS2NvbmZpZwppbmRleCBlOGI2YTEzLi5lNzEwNDI0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Zpcm13YXJlL0tjb25maWcKKysrIGIvZHJpdmVycy9maXJtd2FyZS9LY29uZmlnCkBAIC0yNyw3ICsyNyw3IEBACiAJICB1c2luZyB0aGUga2VybmVsIHBhcmFtZXRlciAnZWRkPXtvbnxza2lwbWJyfG9mZn0nLgogCiBjb25maWcgRklSTVdBUkVfTUVNTUFQCi0gICAgYm9vbCAiQWRkIGZpcm13YXJlLXByb3ZpZGVkIG1lbW9yeSBtYXAgdG8gc3lzZnMiIGlmIEVNQkVEREVECisgICAgYm9vbCAiQWRkIGZpcm13YXJlLXByb3ZpZGVkIG1lbW9yeSBtYXAgdG8gc3lzZnMiIGlmIEVYUEVSVAogICAgIGRlZmF1bHQgWDg2CiAgICAgaGVscAogICAgICAgQWRkIHRoZSBmaXJtd2FyZS1wcm92aWRlZCAodW5tb2RpZmllZCkgbWVtb3J5IG1hcCB0byAvc3lzL2Zpcm13YXJlL21lbW1hcC4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9jczU1MzUtZ3Bpby5jIGIvZHJpdmVycy9ncGlvL2NzNTUzNS1ncGlvLmMKaW5kZXggODE1ZDk4YjIuLjBkMDVlYTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3Bpby9jczU1MzUtZ3Bpby5jCisrKyBiL2RyaXZlcnMvZ3Bpby9jczU1MzUtZ3Bpby5jCkBAIC0xMSwxNCArMTEsMTMgQEAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgotI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgogI2luY2x1ZGUgPGxpbnV4L2dwaW8uaD4KICNpbmNsdWRlIDxsaW51eC9pby5oPgogI2luY2x1ZGUgPGxpbnV4L2NzNTUzNS5oPgogI2luY2x1ZGUgPGFzbS9tc3IuaD4KIAogI2RlZmluZSBEUlZfTkFNRSAiY3M1NTM1LWdwaW8iCi0jZGVmaW5lIEdQSU9fQkFSIDEKIAogLyoKICAqIFNvbWUgR1BJTyBwaW5zCkBAIC00Nyw3ICs0Niw3IEBACiAJc3RydWN0IGdwaW9fY2hpcCBjaGlwOwogCXJlc291cmNlX3NpemVfdCBiYXNlOwogCi0Jc3RydWN0IHBjaV9kZXYgKnBkZXY7CisJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldjsKIAlzcGlubG9ja190IGxvY2s7CiB9IGNzNTUzNV9ncGlvX2NoaXA7CiAKQEAgLTMwMSwxMCArMzAwLDEwIEBACiAJfSwKIH07CiAKLXN0YXRpYyBpbnQgX19pbml0IGNzNTUzNV9ncGlvX3Byb2JlKHN0cnVjdCBwY2lfZGV2ICpwZGV2LAotCQljb25zdCBzdHJ1Y3QgcGNpX2RldmljZV9pZCAqcGNpX2lkKQorc3RhdGljIGludCBfX2RldmluaXQgY3M1NTM1X2dwaW9fcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIHsKLQlpbnQgZXJyOworCXN0cnVjdCByZXNvdXJjZSAqcmVzOworCWludCBlcnIgPSAtRUlPOwogCXVsb25nIG1hc2tfb3JpZyA9IG1hc2s7CiAKIAkvKiBUaGVyZSBhcmUgdHdvIHdheXMgdG8gZ2V0IHRoZSBHUElPIGJhc2UgYWRkcmVzczsgb25lIGlzIGJ5CkBAIC0zMTQsMjUgKzMxMywyMyBAQAogCSAqIGl0IHR1cm5zIG91dCB0byBiZSB1bnJlbGlhYmxlIGluIHRoZSBmYWNlIG9mIGNyYXBweSBCSU9TZXMsIHdlCiAJICogY2FuIGFsd2F5cyBnbyBiYWNrIHRvIHVzaW5nIE1TUnMuLiAqLwogCi0JZXJyID0gcGNpX2VuYWJsZV9kZXZpY2VfaW8ocGRldik7Ci0JaWYgKGVycikgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW4ndCBlbmFibGUgZGV2aWNlIElPXG4iKTsKKwlyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9JTywgMCk7CisJaWYgKCFyZXMpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiY2FuJ3QgZmV0Y2ggZGV2aWNlIHJlc291cmNlIGluZm9cbiIpOwogCQlnb3RvIGRvbmU7CiAJfQogCi0JZXJyID0gcGNpX3JlcXVlc3RfcmVnaW9uKHBkZXYsIEdQSU9fQkFSLCBEUlZfTkFNRSk7Ci0JaWYgKGVycikgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW4ndCBhbGxvYyBQQ0kgQkFSICMlZFxuIiwgR1BJT19CQVIpOworCWlmICghcmVxdWVzdF9yZWdpb24ocmVzLT5zdGFydCwgcmVzb3VyY2Vfc2l6ZShyZXMpLCBwZGV2LT5uYW1lKSkgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW4ndCByZXF1ZXN0IHJlZ2lvblxuIik7CiAJCWdvdG8gZG9uZTsKIAl9CiAKIAkvKiBzZXQgdXAgdGhlIGRyaXZlci1zcGVjaWZpYyBzdHJ1Y3QgKi8KLQljczU1MzVfZ3Bpb19jaGlwLmJhc2UgPSBwY2lfcmVzb3VyY2Vfc3RhcnQocGRldiwgR1BJT19CQVIpOworCWNzNTUzNV9ncGlvX2NoaXAuYmFzZSA9IHJlcy0+c3RhcnQ7CiAJY3M1NTM1X2dwaW9fY2hpcC5wZGV2ID0gcGRldjsKIAlzcGluX2xvY2tfaW5pdCgmY3M1NTM1X2dwaW9fY2hpcC5sb2NrKTsKIAotCWRldl9pbmZvKCZwZGV2LT5kZXYsICJhbGxvY2F0ZWQgUENJIEJBUiAjJWQ6IGJhc2UgMHglbGx4XG4iLCBHUElPX0JBUiwKLQkJCSh1bnNpZ25lZCBsb25nIGxvbmcpIGNzNTUzNV9ncGlvX2NoaXAuYmFzZSk7CisJZGV2X2luZm8oJnBkZXYtPmRldiwgInJlc2VydmVkIHJlc291cmNlIHJlZ2lvbiAlcFJcbiIsIHJlcyk7CiAKIAkvKiBtYXNrIG91dCByZXNlcnZlZCBwaW5zICovCiAJbWFzayAmPSAweDFGN0ZGRkZGOwpAQCAtMzUwLDc4ICszNDcsNDkgQEAKIAlpZiAoZXJyKQogCQlnb3RvIHJlbGVhc2VfcmVnaW9uOwogCi0JZGV2X2luZm8oJnBkZXYtPmRldiwgRFJWX05BTUUgIjogR1BJTyBzdXBwb3J0IHN1Y2Nlc3NmdWxseSBsb2FkZWQuXG4iKTsKKwlkZXZfaW5mbygmcGRldi0+ZGV2LCAiR1BJTyBzdXBwb3J0IHN1Y2Nlc3NmdWxseSBsb2FkZWQuXG4iKTsKIAlyZXR1cm4gMDsKIAogcmVsZWFzZV9yZWdpb246Ci0JcGNpX3JlbGVhc2VfcmVnaW9uKHBkZXYsIEdQSU9fQkFSKTsKKwlyZWxlYXNlX3JlZ2lvbihyZXMtPnN0YXJ0LCByZXNvdXJjZV9zaXplKHJlcykpOwogZG9uZToKIAlyZXR1cm4gZXJyOwogfQogCi1zdGF0aWMgdm9pZCBfX2V4aXQgY3M1NTM1X2dwaW9fcmVtb3ZlKHN0cnVjdCBwY2lfZGV2ICpwZGV2KQorc3RhdGljIGludCBfX2RldmV4aXQgY3M1NTM1X2dwaW9fcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiB7CisJc3RydWN0IHJlc291cmNlICpyOwogCWludCBlcnI7CiAKIAllcnIgPSBncGlvY2hpcF9yZW1vdmUoJmNzNTUzNV9ncGlvX2NoaXAuY2hpcCk7CiAJaWYgKGVycikgewogCQkvKiB1aGg/ICovCiAJCWRldl9lcnIoJnBkZXYtPmRldiwgInVuYWJsZSB0byByZW1vdmUgZ3Bpb19jaGlwP1xuIik7CisJCXJldHVybiBlcnI7CiAJfQotCXBjaV9yZWxlYXNlX3JlZ2lvbihwZGV2LCBHUElPX0JBUik7CisKKwlyID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfSU8sIDApOworCXJlbGVhc2VfcmVnaW9uKHItPnN0YXJ0LCByZXNvdXJjZV9zaXplKHIpKTsKKwlyZXR1cm4gMDsKIH0KIAotc3RhdGljIHN0cnVjdCBwY2lfZGV2aWNlX2lkIGNzNTUzNV9ncGlvX3BjaV90YmxbXSA9IHsKLQl7IFBDSV9ERVZJQ0UoUENJX1ZFTkRPUl9JRF9OUywgUENJX0RFVklDRV9JRF9OU19DUzU1MzVfSVNBKSB9LAotCXsgUENJX0RFVklDRShQQ0lfVkVORE9SX0lEX0FNRCwgUENJX0RFVklDRV9JRF9BTURfQ1M1NTM2X0lTQSkgfSwKLQl7IDAsIH0sCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBjczU1MzVfZ3Bpb19kcnYgPSB7CisJLmRyaXZlciA9IHsKKwkJLm5hbWUgPSBEUlZfTkFNRSwKKwkJLm93bmVyID0gVEhJU19NT0RVTEUsCisJfSwKKwkucHJvYmUgPSBjczU1MzVfZ3Bpb19wcm9iZSwKKwkucmVtb3ZlID0gX19kZXZleGl0X3AoY3M1NTM1X2dwaW9fcmVtb3ZlKSwKIH07Ci1NT0RVTEVfREVWSUNFX1RBQkxFKHBjaSwgY3M1NTM1X2dwaW9fcGNpX3RibCk7Ci0KLS8qCi0gKiBXZSBjYW4ndCB1c2UgdGhlIHN0YW5kYXJkIFBDSSBkcml2ZXIgcmVnaXN0cmF0aW9uIHN0dWZmIGhlcmUsIHNpbmNlCi0gKiB0aGF0IGFsbG93cyBvbmx5IG9uZSBkcml2ZXIgdG8gYmluZCB0byBlYWNoIFBDSSBkZXZpY2UgKGFuZCB3ZSB3YW50Ci0gKiBtdWx0aXBsZSBkcml2ZXJzIHRvIGJlIGFibGUgdG8gYmluZCB0byB0aGUgZGV2aWNlKS4gIEluc3RlYWQsIG1hbnVhbGx5Ci0gKiBzY2FuIGZvciB0aGUgUENJIGRldmljZSwgcmVxdWVzdCBhIHNpbmdsZSByZWdpb24sIGFuZCBrZWVwIHRyYWNrIG9mIHRoZQotICogZGV2aWNlcyB0aGF0IHdlJ3JlIHVzaW5nLgotICovCi0KLXN0YXRpYyBpbnQgX19pbml0IGNzNTUzNV9ncGlvX3NjYW5fcGNpKHZvaWQpCi17Ci0Jc3RydWN0IHBjaV9kZXYgKnBkZXY7Ci0JaW50IGVyciA9IC1FTk9ERVY7Ci0JaW50IGk7Ci0KLQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShjczU1MzVfZ3Bpb19wY2lfdGJsKTsgaSsrKSB7Ci0JCXBkZXYgPSBwY2lfZ2V0X2RldmljZShjczU1MzVfZ3Bpb19wY2lfdGJsW2ldLnZlbmRvciwKLQkJCQljczU1MzVfZ3Bpb19wY2lfdGJsW2ldLmRldmljZSwgTlVMTCk7Ci0JCWlmIChwZGV2KSB7Ci0JCQllcnIgPSBjczU1MzVfZ3Bpb19wcm9iZShwZGV2LCAmY3M1NTM1X2dwaW9fcGNpX3RibFtpXSk7Ci0JCQlpZiAoZXJyKQotCQkJCXBjaV9kZXZfcHV0KHBkZXYpOwotCi0JCQkvKiB3ZSBvbmx5IHN1cHBvcnQgYSBzaW5nbGUgQ1M1NTM1LzYgc291dGhicmlkZ2UgKi8KLQkJCWJyZWFrOwotCQl9Ci0JfQotCi0JcmV0dXJuIGVycjsKLX0KLQotc3RhdGljIHZvaWQgX19leGl0IGNzNTUzNV9ncGlvX2ZyZWVfcGNpKHZvaWQpCi17Ci0JY3M1NTM1X2dwaW9fcmVtb3ZlKGNzNTUzNV9ncGlvX2NoaXAucGRldik7Ci0JcGNpX2Rldl9wdXQoY3M1NTM1X2dwaW9fY2hpcC5wZGV2KTsKLX0KIAogc3RhdGljIGludCBfX2luaXQgY3M1NTM1X2dwaW9faW5pdCh2b2lkKQogewotCXJldHVybiBjczU1MzVfZ3Bpb19zY2FuX3BjaSgpOworCXJldHVybiBwbGF0Zm9ybV9kcml2ZXJfcmVnaXN0ZXIoJmNzNTUzNV9ncGlvX2Rydik7CiB9CiAKIHN0YXRpYyB2b2lkIF9fZXhpdCBjczU1MzVfZ3Bpb19leGl0KHZvaWQpCiB7Ci0JY3M1NTM1X2dwaW9fZnJlZV9wY2koKTsKKwlwbGF0Zm9ybV9kcml2ZXJfdW5yZWdpc3RlcigmY3M1NTM1X2dwaW9fZHJ2KTsKIH0KIAogbW9kdWxlX2luaXQoY3M1NTM1X2dwaW9faW5pdCk7CkBAIC00MzAsMyArMzk4LDQgQEAKIE1PRFVMRV9BVVRIT1IoIkFuZHJlcyBTYWxvbW9uIDxkaWxpbmdlckBxdWV1ZWQubmV0PiIpOwogTU9EVUxFX0RFU0NSSVBUSU9OKCJBTUQgQ1M1NTM1L0NTNTUzNiBHUElPIGRyaXZlciIpOwogTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FMSUFTKCJwbGF0Zm9ybToiIERSVl9OQU1FKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9sYW5nd2VsbF9ncGlvLmMgYi9kcml2ZXJzL2dwaW8vbGFuZ3dlbGxfZ3Bpby5jCmluZGV4IGQ4MWNjNzQuLjU0ZDcwYTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3Bpby9sYW5nd2VsbF9ncGlvLmMKKysrIGIvZHJpdmVycy9ncGlvL2xhbmd3ZWxsX2dwaW8uYwpAQCAtMTg3LDcgKzE4Nyw3IEBACiAKIHN0YXRpYyB2b2lkIGxud19pcnFfaGFuZGxlcih1bnNpZ25lZCBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKIHsKLQlzdHJ1Y3QgbG53X2dwaW8gKmxudyA9IChzdHJ1Y3QgbG53X2dwaW8gKilnZXRfaXJxX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgbG53X2dwaW8gKmxudyA9IGdldF9pcnFfZGF0YShpcnEpOwogCXUzMiBiYXNlLCBncGlvOwogCXZvaWQgX19pb21lbSAqZ2VkcjsKIAl1MzIgZ2Vkcl92OwpAQCAtMjA2LDcgKzIwNiwxMiBAQAogCQkvKiBjbGVhciB0aGUgZWRnZSBkZXRlY3Qgc3RhdHVzIGJpdCAqLwogCQl3cml0ZWwoZ2Vkcl92LCBnZWRyKTsKIAl9Ci0JZGVzYy0+Y2hpcC0+ZW9pKGlycSk7CisKKwlpZiAoZGVzYy0+Y2hpcC0+aXJxX2VvaSkKKwkJZGVzYy0+Y2hpcC0+aXJxX2VvaShpcnFfZ2V0X2lycV9kYXRhKGlycSkpOworCWVsc2UKKwkJZGV2X3dhcm4obG53LT5jaGlwLmRldiwgIm1pc3NpbmcgRU9JIGhhbmRsZXIgZm9yIGlycSAlZFxuIiwgaXJxKTsKKwogfQogCiBzdGF0aWMgaW50IF9fZGV2aW5pdCBsbndfZ3Bpb19wcm9iZShzdHJ1Y3QgcGNpX2RldiAqcGRldiwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9wY2E5NTN4LmMgYi9kcml2ZXJzL2dwaW8vcGNhOTUzeC5jCmluZGV4IGEyNjE5NzIuLmI0NzM0MjllIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vcGNhOTUzeC5jCisrKyBiL2RyaXZlcnMvZ3Bpby9wY2E5NTN4LmMKQEAgLTYwLDYgKzYwLDcgQEAKIAl1bnNpZ25lZCBncGlvX3N0YXJ0OwogCXVpbnQxNl90IHJlZ19vdXRwdXQ7CiAJdWludDE2X3QgcmVnX2RpcmVjdGlvbjsKKwlzdHJ1Y3QgbXV0ZXggaTJjX2xvY2s7CiAKICNpZmRlZiBDT05GSUdfR1BJT19QQ0E5NTNYX0lSUQogCXN0cnVjdCBtdXRleCBpcnFfbG9jazsKQEAgLTExOSwxMyArMTIwLDE3IEBACiAKIAljaGlwID0gY29udGFpbmVyX29mKGdjLCBzdHJ1Y3QgcGNhOTUzeF9jaGlwLCBncGlvX2NoaXApOwogCisJbXV0ZXhfbG9jaygmY2hpcC0+aTJjX2xvY2spOwogCXJlZ192YWwgPSBjaGlwLT5yZWdfZGlyZWN0aW9uIHwgKDF1IDw8IG9mZik7CiAJcmV0ID0gcGNhOTUzeF93cml0ZV9yZWcoY2hpcCwgUENBOTUzWF9ESVJFQ1RJT04sIHJlZ192YWwpOwogCWlmIChyZXQpCi0JCXJldHVybiByZXQ7CisJCWdvdG8gZXhpdDsKIAogCWNoaXAtPnJlZ19kaXJlY3Rpb24gPSByZWdfdmFsOwotCXJldHVybiAwOworCXJldCA9IDA7CitleGl0OgorCW11dGV4X3VubG9jaygmY2hpcC0+aTJjX2xvY2spOworCXJldHVybiByZXQ7CiB9CiAKIHN0YXRpYyBpbnQgcGNhOTUzeF9ncGlvX2RpcmVjdGlvbl9vdXRwdXQoc3RydWN0IGdwaW9fY2hpcCAqZ2MsCkBAIC0xMzcsNiArMTQyLDcgQEAKIAogCWNoaXAgPSBjb250YWluZXJfb2YoZ2MsIHN0cnVjdCBwY2E5NTN4X2NoaXAsIGdwaW9fY2hpcCk7CiAKKwltdXRleF9sb2NrKCZjaGlwLT5pMmNfbG9jayk7CiAJLyogc2V0IG91dHB1dCBsZXZlbCAqLwogCWlmICh2YWwpCiAJCXJlZ192YWwgPSBjaGlwLT5yZWdfb3V0cHV0IHwgKDF1IDw8IG9mZik7CkBAIC0xNDUsNyArMTUxLDcgQEAKIAogCXJldCA9IHBjYTk1M3hfd3JpdGVfcmVnKGNoaXAsIFBDQTk1M1hfT1VUUFVULCByZWdfdmFsKTsKIAlpZiAocmV0KQotCQlyZXR1cm4gcmV0OworCQlnb3RvIGV4aXQ7CiAKIAljaGlwLT5yZWdfb3V0cHV0ID0gcmVnX3ZhbDsKIApAQCAtMTUzLDEwICsxNTksMTMgQEAKIAlyZWdfdmFsID0gY2hpcC0+cmVnX2RpcmVjdGlvbiAmIH4oMXUgPDwgb2ZmKTsKIAlyZXQgPSBwY2E5NTN4X3dyaXRlX3JlZyhjaGlwLCBQQ0E5NTNYX0RJUkVDVElPTiwgcmVnX3ZhbCk7CiAJaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKKwkJZ290byBleGl0OwogCiAJY2hpcC0+cmVnX2RpcmVjdGlvbiA9IHJlZ192YWw7Ci0JcmV0dXJuIDA7CisJcmV0ID0gMDsKK2V4aXQ6CisJbXV0ZXhfdW5sb2NrKCZjaGlwLT5pMmNfbG9jayk7CisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIGludCBwY2E5NTN4X2dwaW9fZ2V0X3ZhbHVlKHN0cnVjdCBncGlvX2NoaXAgKmdjLCB1bnNpZ25lZCBvZmYpCkBAIC0xNjcsNyArMTc2LDkgQEAKIAogCWNoaXAgPSBjb250YWluZXJfb2YoZ2MsIHN0cnVjdCBwY2E5NTN4X2NoaXAsIGdwaW9fY2hpcCk7CiAKKwltdXRleF9sb2NrKCZjaGlwLT5pMmNfbG9jayk7CiAJcmV0ID0gcGNhOTUzeF9yZWFkX3JlZyhjaGlwLCBQQ0E5NTNYX0lOUFVULCAmcmVnX3ZhbCk7CisJbXV0ZXhfdW5sb2NrKCZjaGlwLT5pMmNfbG9jayk7CiAJaWYgKHJldCA8IDApIHsKIAkJLyogTk9URTogIGRpYWdub3N0aWMgYWxyZWFkeSBlbWl0dGVkOyB0aGF0J3MgYWxsIHdlIHNob3VsZAogCQkgKiBkbyB1bmxlc3MgZ3Bpb18qX3ZhbHVlX2NhbnNsZWVwKCkgY2FsbHMgYmVjb21lIGRpZmZlcmVudApAQCAtMTg3LDYgKzE5OCw3IEBACiAKIAljaGlwID0gY29udGFpbmVyX29mKGdjLCBzdHJ1Y3QgcGNhOTUzeF9jaGlwLCBncGlvX2NoaXApOwogCisJbXV0ZXhfbG9jaygmY2hpcC0+aTJjX2xvY2spOwogCWlmICh2YWwpCiAJCXJlZ192YWwgPSBjaGlwLT5yZWdfb3V0cHV0IHwgKDF1IDw8IG9mZik7CiAJZWxzZQpAQCAtMTk0LDkgKzIwNiwxMSBAQAogCiAJcmV0ID0gcGNhOTUzeF93cml0ZV9yZWcoY2hpcCwgUENBOTUzWF9PVVRQVVQsIHJlZ192YWwpOwogCWlmIChyZXQpCi0JCXJldHVybjsKKwkJZ290byBleGl0OwogCiAJY2hpcC0+cmVnX291dHB1dCA9IHJlZ192YWw7CitleGl0OgorCW11dGV4X3VubG9jaygmY2hpcC0+aTJjX2xvY2spOwogfQogCiBzdGF0aWMgdm9pZCBwY2E5NTN4X3NldHVwX2dwaW8oc3RydWN0IHBjYTk1M3hfY2hpcCAqY2hpcCwgaW50IGdwaW9zKQpAQCAtNTE3LDYgKzUzMSw4IEBACiAKIAljaGlwLT5uYW1lcyA9IHBkYXRhLT5uYW1lczsKIAorCW11dGV4X2luaXQoJmNoaXAtPmkyY19sb2NrKTsKKwogCS8qIGluaXRpYWxpemUgY2FjaGVkIHJlZ2lzdGVycyBmcm9tIHRoZWlyIG9yaWdpbmFsIHZhbHVlcy4KIAkgKiB3ZSBjYW4ndCBzaGFyZSB0aGlzIGNoaXAgd2l0aCBhbm90aGVyIGkyYyBtYXN0ZXIuCiAJICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwaW8vdGltYmdwaW8uYyBiL2RyaXZlcnMvZ3Bpby90aW1iZ3Bpby5jCmluZGV4IDM0OTEzMWUuLjU4YzhmMzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3Bpby90aW1iZ3Bpby5jCisrKyBiL2RyaXZlcnMvZ3Bpby90aW1iZ3Bpby5jCkBAIC0xOTMsMTMgKzE5MywxMyBAQAogCXJldHVybiByZXQ7CiB9CiAKLXN0YXRpYyB2b2lkIHRpbWJncGlvX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKK3N0YXRpYyB2b2lkIHRpbWJncGlvX2lycSh1bnNpZ25lZCBpbnQgaXJxLCBzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MpCiB7Ci0Jc3RydWN0IHRpbWJncGlvICp0Z3BpbyA9IGlycV9kYXRhX2dldF9pcnFfZGF0YShkKTsKKwlzdHJ1Y3QgdGltYmdwaW8gKnRncGlvID0gZ2V0X2lycV9kYXRhKGlycSk7CiAJdW5zaWduZWQgbG9uZyBpcHI7CiAJaW50IG9mZnNldDsKIAotCWRlc2MtPmlycV9kYXRhLmNoaXAtPmFjayhpcnFfZ2V0X2lycV9kYXRhKGQpKTsKKwlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfYWNrKGlycV9nZXRfaXJxX2RhdGEoaXJxKSk7CiAJaXByID0gaW9yZWFkMzIodGdwaW8tPm1lbWJhc2UgKyBUR1BJT19JUFIpOwogCWlvd3JpdGUzMihpcHIsIHRncGlvLT5tZW1iYXNlICsgVEdQSU9fSUNSKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL0tjb25maWcgYi9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZwppbmRleCA3YWY0NDM2Li4wOTAyZDQ0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZworKysgYi9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZwpAQCAtMjMsNyArMjMsNyBAQAogCXRyaXN0YXRlCiAJZGVwZW5kcyBvbiBEUk0KIAlzZWxlY3QgRkIKLQlzZWxlY3QgRlJBTUVCVUZGRVJfQ09OU09MRSBpZiAhRU1CRURERUQKKwlzZWxlY3QgRlJBTUVCVUZGRVJfQ09OU09MRSBpZiAhRVhQRVJUCiAJaGVscAogCSAgRkIgYW5kIENSVEMgaGVscGVycyBmb3IgS01TIGRyaXZlcnMuCiAKQEAgLTEwMCwxNCArMTAwLDE2IEBACiBjb25maWcgRFJNX0k5MTUKIAl0cmlzdGF0ZSAiaTkxNSBkcml2ZXIiCiAJZGVwZW5kcyBvbiBBR1BfSU5URUwKKwkjIHdlIG5lZWQgc2htZnMgZm9yIHRoZSBzd2FwcGFibGUgYmFja2luZyBzdG9yZSwgYW5kIGluIHBhcnRpY3VsYXIKKwkjIHRoZSBzaG1lbV9yZWFkcGFnZSgpIHdoaWNoIGRlcGVuZHMgdXBvbiB0bXBmcwogCXNlbGVjdCBTSE1FTQorCXNlbGVjdCBUTVBGUwogCXNlbGVjdCBEUk1fS01TX0hFTFBFUgogCXNlbGVjdCBGQl9DRkJfRklMTFJFQ1QKIAlzZWxlY3QgRkJfQ0ZCX0NPUFlBUkVBCiAJc2VsZWN0IEZCX0NGQl9JTUFHRUJMSVQKIAkjIGk5MTUgZGVwZW5kcyBvbiBBQ1BJX1ZJREVPIHdoZW4gQUNQSSBpcyBlbmFibGVkCiAJIyBidXQgZm9yIHNlbGVjdCB0byB3b3JrLCBuZWVkIHRvIHNlbGVjdCBBQ1BJX1ZJREVPJ3MgZGVwZW5kZW5jaWVzLCBpY2sKLQlzZWxlY3QgVklERU9fT1VUUFVUX0NPTlRST0wgaWYgQUNQSQogCXNlbGVjdCBCQUNLTElHSFRfQ0xBU1NfREVWSUNFIGlmIEFDUEkKIAlzZWxlY3QgSU5QVVQgaWYgQUNQSQogCXNlbGVjdCBBQ1BJX1ZJREVPIGlmIEFDUEkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fY3J0Yy5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9jcnRjLmMKaW5kZXggMmJhYTY3MC4uNjU0ZmFhOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9jcnRjLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9jcnRjLmMKQEAgLTI2NzQsMyArMjY3NCwyMyBAQAogCW11dGV4X3VubG9jaygmZGV2LT5tb2RlX2NvbmZpZy5tdXRleCk7CiAJcmV0dXJuIHJldDsKIH0KKwordm9pZCBkcm1fbW9kZV9jb25maWdfcmVzZXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGM7CisJc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyOworCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3I7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNydGMsICZkZXYtPm1vZGVfY29uZmlnLmNydGNfbGlzdCwgaGVhZCkKKwkJaWYgKGNydGMtPmZ1bmNzLT5yZXNldCkKKwkJCWNydGMtPmZ1bmNzLT5yZXNldChjcnRjKTsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkoZW5jb2RlciwgJmRldi0+bW9kZV9jb25maWcuZW5jb2Rlcl9saXN0LCBoZWFkKQorCQlpZiAoZW5jb2Rlci0+ZnVuY3MtPnJlc2V0KQorCQkJZW5jb2Rlci0+ZnVuY3MtPnJlc2V0KGVuY29kZXIpOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShjb25uZWN0b3IsICZkZXYtPm1vZGVfY29uZmlnLmNvbm5lY3Rvcl9saXN0LCBoZWFkKQorCQlpZiAoY29ubmVjdG9yLT5mdW5jcy0+cmVzZXQpCisJCQljb25uZWN0b3ItPmZ1bmNzLT5yZXNldChjb25uZWN0b3IpOworfQorRVhQT1JUX1NZTUJPTChkcm1fbW9kZV9jb25maWdfcmVzZXQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9jcnRjX2hlbHBlci5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9jcnRjX2hlbHBlci5jCmluZGV4IDk1MmIzZDQuLjkyMzY5NjU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2NydGNfaGVscGVyLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9jcnRjX2hlbHBlci5jCkBAIC0zNDMsMTMgKzM0MywxMiBAQAogCXN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2RlcjsKIAlib29sIHJldCA9IHRydWU7CiAKLQlhZGp1c3RlZF9tb2RlID0gZHJtX21vZGVfZHVwbGljYXRlKGRldiwgbW9kZSk7Ci0KIAljcnRjLT5lbmFibGVkID0gZHJtX2hlbHBlcl9jcnRjX2luX3VzZShjcnRjKTsKLQogCWlmICghY3J0Yy0+ZW5hYmxlZCkKIAkJcmV0dXJuIHRydWU7CiAKKwlhZGp1c3RlZF9tb2RlID0gZHJtX21vZGVfZHVwbGljYXRlKGRldiwgbW9kZSk7CisKIAlzYXZlZF9od21vZGUgPSBjcnRjLT5od21vZGU7CiAJc2F2ZWRfbW9kZSA9IGNydGMtPm1vZGU7CiAJc2F2ZWRfeCA9IGNydGMtPng7CkBAIC00MzcsMTAgKzQzNiw5IEBACiAJICovCiAJZHJtX2NhbGNfdGltZXN0YW1waW5nX2NvbnN0YW50cyhjcnRjKTsKIAotCS8qIFhYWCBmcmVlIGFkanVzdGVkbW9kZSAqLwotCWRybV9tb2RlX2Rlc3Ryb3koZGV2LCBhZGp1c3RlZF9tb2RlKTsKIAkvKiBGSVhNRTogYWRkIHN1YnBpeGVsIG9yZGVyICovCiBkb25lOgorCWRybV9tb2RlX2Rlc3Ryb3koZGV2LCBhZGp1c3RlZF9tb2RlKTsKIAlpZiAoIXJldCkgewogCQljcnRjLT5od21vZGUgPSBzYXZlZF9od21vZGU7CiAJCWNydGMtPm1vZGUgPSBzYXZlZF9tb2RlOwpAQCAtNDk3LDE0ICs0OTUsMTcgQEAKIAogCWNydGNfZnVuY3MgPSBzZXQtPmNydGMtPmhlbHBlcl9wcml2YXRlOwogCisJaWYgKCFzZXQtPm1vZGUpCisJCXNldC0+ZmIgPSBOVUxMOworCiAJaWYgKHNldC0+ZmIpIHsKIAkJRFJNX0RFQlVHX0tNUygiW0NSVEM6JWRdIFtGQjolZF0gI2Nvbm5lY3RvcnM9JWQgKHggeSkgKCVpICVpKVxuIiwKIAkJCQlzZXQtPmNydGMtPmJhc2UuaWQsIHNldC0+ZmItPmJhc2UuaWQsCiAJCQkJKGludClzZXQtPm51bV9jb25uZWN0b3JzLCBzZXQtPngsIHNldC0+eSk7CiAJfSBlbHNlIHsKLQkJRFJNX0RFQlVHX0tNUygiW0NSVEM6JWRdIFtOT0ZCXSAjY29ubmVjdG9ycz0lZCAoeCB5KSAoJWkgJWkpXG4iLAotCQkJCXNldC0+Y3J0Yy0+YmFzZS5pZCwgKGludClzZXQtPm51bV9jb25uZWN0b3JzLAotCQkJCXNldC0+eCwgc2V0LT55KTsKKwkJRFJNX0RFQlVHX0tNUygiW0NSVEM6JWRdIFtOT0ZCXVxuIiwgc2V0LT5jcnRjLT5iYXNlLmlkKTsKKwkJc2V0LT5tb2RlID0gTlVMTDsKKwkJc2V0LT5udW1fY29ubmVjdG9ycyA9IDA7CiAJfQogCiAJZGV2ID0gc2V0LT5jcnRjLT5kZXY7CkBAIC02NDksOCArNjUwLDggQEAKIAkJbW9kZV9jaGFuZ2VkID0gdHJ1ZTsKIAogCWlmIChtb2RlX2NoYW5nZWQpIHsKLQkJc2V0LT5jcnRjLT5lbmFibGVkID0gKHNldC0+bW9kZSAhPSBOVUxMKTsKLQkJaWYgKHNldC0+bW9kZSAhPSBOVUxMKSB7CisJCXNldC0+Y3J0Yy0+ZW5hYmxlZCA9IGRybV9oZWxwZXJfY3J0Y19pbl91c2Uoc2V0LT5jcnRjKTsKKwkJaWYgKHNldC0+Y3J0Yy0+ZW5hYmxlZCkgewogCQkJRFJNX0RFQlVHX0tNUygiYXR0ZW1wdGluZyB0byBzZXQgbW9kZSBmcm9tIgogCQkJCQkiIHVzZXJzcGFjZVxuIik7CiAJCQlkcm1fbW9kZV9kZWJ1Z19wcmludG1vZGVsaW5lKHNldC0+bW9kZSk7CkBAIC02NjUsNiArNjY2LDEyIEBACiAJCQkJcmV0ID0gLUVJTlZBTDsKIAkJCQlnb3RvIGZhaWw7CiAJCQl9CisJCQlEUk1fREVCVUdfS01TKCJTZXR0aW5nIGNvbm5lY3RvciBEUE1TIHN0YXRlIHRvIG9uXG4iKTsKKwkJCWZvciAoaSA9IDA7IGkgPCBzZXQtPm51bV9jb25uZWN0b3JzOyBpKyspIHsKKwkJCQlEUk1fREVCVUdfS01TKCJcdFtDT05ORUNUT1I6JWQ6JXNdIHNldCBEUE1TIG9uXG4iLCBzZXQtPmNvbm5lY3RvcnNbaV0tPmJhc2UuaWQsCisJCQkJCSAgICAgIGRybV9nZXRfY29ubmVjdG9yX25hbWUoc2V0LT5jb25uZWN0b3JzW2ldKSk7CisJCQkJc2V0LT5jb25uZWN0b3JzW2ldLT5kcG1zID0gRFJNX01PREVfRFBNU19PTjsKKwkJCX0KIAkJfQogCQlkcm1faGVscGVyX2Rpc2FibGVfdW51c2VkX2Z1bmN0aW9ucyhkZXYpOwogCX0gZWxzZSBpZiAoZmJfY2hhbmdlZCkgewpAQCAtNjgxLDEyICs2ODgsNiBAQAogCQkJZ290byBmYWlsOwogCQl9CiAJfQotCURSTV9ERUJVR19LTVMoIlNldHRpbmcgY29ubmVjdG9yIERQTVMgc3RhdGUgdG8gb25cbiIpOwotCWZvciAoaSA9IDA7IGkgPCBzZXQtPm51bV9jb25uZWN0b3JzOyBpKyspIHsKLQkJRFJNX0RFQlVHX0tNUygiXHRbQ09OTkVDVE9SOiVkOiVzXSBzZXQgRFBNUyBvblxuIiwgc2V0LT5jb25uZWN0b3JzW2ldLT5iYXNlLmlkLAotCQkJICAgICAgZHJtX2dldF9jb25uZWN0b3JfbmFtZShzZXQtPmNvbm5lY3RvcnNbaV0pKTsKLQkJc2V0LT5jb25uZWN0b3JzW2ldLT5kcG1zID0gRFJNX01PREVfRFBNU19PTjsKLQl9CiAKIAlrZnJlZShzYXZlX2Nvbm5lY3RvcnMpOwogCWtmcmVlKHNhdmVfZW5jb2RlcnMpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9mYl9oZWxwZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZmJfaGVscGVyLmMKaW5kZXggMDMwN2Q2MC4uNjk3N2ExYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9mYl9oZWxwZXIuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2ZiX2hlbHBlci5jCkBAIC02MDcsMjUgKzYwNyw2IEBACiB9CiBFWFBPUlRfU1lNQk9MKGRybV9mYl9oZWxwZXJfZmluaSk7CiAKLXZvaWQgZHJtX2ZiX2hlbHBlcl9maWxsX2ZpeChzdHJ1Y3QgZmJfaW5mbyAqaW5mbywgc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIpCi17Ci0JaW5mby0+Zml4LnR5cGUgPSBGQl9UWVBFX1BBQ0tFRF9QSVhFTFM7Ci0JaW5mby0+Zml4LnZpc3VhbCA9IGZiLT5kZXB0aCA9PSA4ID8gRkJfVklTVUFMX1BTRVVET0NPTE9SIDoKLQkJRkJfVklTVUFMX1RSVUVDT0xPUjsKLQlpbmZvLT5maXgubW1pb19zdGFydCA9IDA7Ci0JaW5mby0+Zml4Lm1taW9fbGVuID0gMDsKLQlpbmZvLT5maXgudHlwZV9hdXggPSAwOwotCWluZm8tPmZpeC54cGFuc3RlcCA9IDE7IC8qIGRvaW5nIGl0IGluIGh3ICovCi0JaW5mby0+Zml4LnlwYW5zdGVwID0gMTsgLyogZG9pbmcgaXQgaW4gaHcgKi8KLQlpbmZvLT5maXgueXdyYXBzdGVwID0gMDsKLQlpbmZvLT5maXguYWNjZWwgPSBGQl9BQ0NFTF9OT05FOwotCWluZm8tPmZpeC50eXBlX2F1eCA9IDA7Ci0KLQlpbmZvLT5maXgubGluZV9sZW5ndGggPSBmYi0+cGl0Y2g7Ci0JcmV0dXJuOwotfQotRVhQT1JUX1NZTUJPTChkcm1fZmJfaGVscGVyX2ZpbGxfZml4KTsKLQogc3RhdGljIGludCBzZXRjb2xyZWcoc3RydWN0IGRybV9jcnRjICpjcnRjLCB1MTYgcmVkLCB1MTYgZ3JlZW4sCiAJCSAgICAgdTE2IGJsdWUsIHUxNiByZWdubywgc3RydWN0IGZiX2luZm8gKmluZm8pCiB7CkBAIC04MzUsNyArODE2LDYgQEAKIAkJCW11dGV4X3VubG9jaygmZGV2LT5tb2RlX2NvbmZpZy5tdXRleCk7CiAJCQlyZXR1cm4gcmV0OwogCQl9Ci0JCWRybV9mYl9oZWxwZXJfZmlsbF9maXgoaW5mbywgZmJfaGVscGVyLT5mYik7CiAJfQogCW11dGV4X3VubG9jaygmZGV2LT5tb2RlX2NvbmZpZy5tdXRleCk7CiAKQEAgLTk3Myw3ICs5NTMsNiBAQAogCiAJaWYgKG5ld19mYikgewogCQlpbmZvLT52YXIucGl4Y2xvY2sgPSAwOwotCQlkcm1fZmJfaGVscGVyX2ZpbGxfZml4KGluZm8sIGZiX2hlbHBlci0+ZmIpOwogCQlpZiAocmVnaXN0ZXJfZnJhbWVidWZmZXIoaW5mbykgPCAwKSB7CiAJCQlyZXR1cm4gLUVJTlZBTDsKIAkJfQpAQCAtMTAwMCw2ICs5NzksMjYgQEAKIH0KIEVYUE9SVF9TWU1CT0woZHJtX2ZiX2hlbHBlcl9zaW5nbGVfZmJfcHJvYmUpOwogCit2b2lkIGRybV9mYl9oZWxwZXJfZmlsbF9maXgoc3RydWN0IGZiX2luZm8gKmluZm8sIHVpbnQzMl90IHBpdGNoLAorCQkJICAgIHVpbnQzMl90IGRlcHRoKQoreworCWluZm8tPmZpeC50eXBlID0gRkJfVFlQRV9QQUNLRURfUElYRUxTOworCWluZm8tPmZpeC52aXN1YWwgPSBkZXB0aCA9PSA4ID8gRkJfVklTVUFMX1BTRVVET0NPTE9SIDoKKwkJRkJfVklTVUFMX1RSVUVDT0xPUjsKKwlpbmZvLT5maXgubW1pb19zdGFydCA9IDA7CisJaW5mby0+Zml4Lm1taW9fbGVuID0gMDsKKwlpbmZvLT5maXgudHlwZV9hdXggPSAwOworCWluZm8tPmZpeC54cGFuc3RlcCA9IDE7IC8qIGRvaW5nIGl0IGluIGh3ICovCisJaW5mby0+Zml4LnlwYW5zdGVwID0gMTsgLyogZG9pbmcgaXQgaW4gaHcgKi8KKwlpbmZvLT5maXgueXdyYXBzdGVwID0gMDsKKwlpbmZvLT5maXguYWNjZWwgPSBGQl9BQ0NFTF9OT05FOworCWluZm8tPmZpeC50eXBlX2F1eCA9IDA7CisKKwlpbmZvLT5maXgubGluZV9sZW5ndGggPSBwaXRjaDsKKwlyZXR1cm47Cit9CitFWFBPUlRfU1lNQk9MKGRybV9mYl9oZWxwZXJfZmlsbF9maXgpOworCiB2b2lkIGRybV9mYl9oZWxwZXJfZmlsbF92YXIoc3RydWN0IGZiX2luZm8gKmluZm8sIHN0cnVjdCBkcm1fZmJfaGVscGVyICpmYl9oZWxwZXIsCiAJCQkgICAgdWludDMyX3QgZmJfd2lkdGgsIHVpbnQzMl90IGZiX2hlaWdodCkKIHsKQEAgLTE1MzQsMTEgKzE1MzMsMTEgQEAKIH0KIEVYUE9SVF9TWU1CT0woZHJtX2ZiX2hlbHBlcl9ob3RwbHVnX2V2ZW50KTsKIAotLyogVGhlIEtjb25maWcgRFJNX0tNU19IRUxQRVIgc2VsZWN0cyBGUkFNRUJVRkZFUl9DT05TT0xFIChpZiAhRU1CRURERUQpCisvKiBUaGUgS2NvbmZpZyBEUk1fS01TX0hFTFBFUiBzZWxlY3RzIEZSQU1FQlVGRkVSX0NPTlNPTEUgKGlmICFFWFBFUlQpCiAgKiBidXQgdGhlIG1vZHVsZSBkb2Vzbid0IGRlcGVuZCBvbiBhbnkgZmIgY29uc29sZSBzeW1ib2xzLiAgQXQgbGVhc3QKICAqIGF0dGVtcHQgdG8gbG9hZCBmYmNvbiB0byBhdm9pZCBsZWF2aW5nIHRoZSBzeXN0ZW0gd2l0aG91dCBhIHVzYWJsZSBjb25zb2xlLgogICovCi0jaWYgZGVmaW5lZChDT05GSUdfRlJBTUVCVUZGRVJfQ09OU09MRV9NT0RVTEUpICYmICFkZWZpbmVkKENPTkZJR19FTUJFRERFRCkKKyNpZiBkZWZpbmVkKENPTkZJR19GUkFNRUJVRkZFUl9DT05TT0xFX01PRFVMRSkgJiYgIWRlZmluZWQoQ09ORklHX0VYUEVSVCkKIHN0YXRpYyBpbnQgX19pbml0IGRybV9mYl9oZWxwZXJfbW9kaW5pdCh2b2lkKQogewogCWNvbnN0IGNoYXIgKm5hbWUgPSAiZmJjb24iOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9pcnEuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1faXJxLmMKaW5kZXggMDA1NGU5NS4uM2RhZGZhMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9pcnEuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2lycS5jCkBAIC0xMjUwLDcgKzEyNTAsNyBAQAogICogRHJpdmVycyBzaG91bGQgY2FsbCB0aGlzIHJvdXRpbmUgaW4gdGhlaXIgdmJsYW5rIGludGVycnVwdCBoYW5kbGVycyB0bwogICogdXBkYXRlIHRoZSB2YmxhbmsgY291bnRlciBhbmQgc2VuZCBhbnkgc2lnbmFscyB0aGF0IG1heSBiZSBwZW5kaW5nLgogICovCi12b2lkIGRybV9oYW5kbGVfdmJsYW5rKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIGludCBjcnRjKQorYm9vbCBkcm1faGFuZGxlX3ZibGFuayhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBpbnQgY3J0YykKIHsKIAl1MzIgdmJsY291bnQ7CiAJczY0IGRpZmZfbnM7CkBAIC0xMjU4LDcgKzEyNTgsNyBAQAogCXVuc2lnbmVkIGxvbmcgaXJxZmxhZ3M7CiAKIAlpZiAoIWRldi0+bnVtX2NydGNzKQotCQlyZXR1cm47CisJCXJldHVybiBmYWxzZTsKIAogCS8qIE5lZWQgdGltZXN0YW1wIGxvY2sgdG8gcHJldmVudCBjb25jdXJyZW50IGV4ZWN1dGlvbiB3aXRoCiAJICogdmJsYW5rIGVuYWJsZS9kaXNhYmxlLCBhcyB0aGlzIHdvdWxkIGNhdXNlIGluY29uc2lzdGVudApAQCAtMTI2OSw3ICsxMjY5LDcgQEAKIAkvKiBWYmxhbmsgaXJxIGhhbmRsaW5nIGRpc2FibGVkLiBOb3RoaW5nIHRvIGRvLiAqLwogCWlmICghZGV2LT52YmxhbmtfZW5hYmxlZFtjcnRjXSkgewogCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXYtPnZibGFua190aW1lX2xvY2ssIGlycWZsYWdzKTsKLQkJcmV0dXJuOworCQlyZXR1cm4gZmFsc2U7CiAJfQogCiAJLyogRmV0Y2ggY29ycmVzcG9uZGluZyB0aW1lc3RhbXAgZm9yIHRoaXMgdmJsYW5rIGludGVydmFsIGZyb20KQEAgLTEzMTEsNSArMTMxMSw2IEBACiAJZHJtX2hhbmRsZV92YmxhbmtfZXZlbnRzKGRldiwgY3J0Yyk7CiAKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXYtPnZibGFua190aW1lX2xvY2ssIGlycWZsYWdzKTsKKwlyZXR1cm4gdHJ1ZTsKIH0KIEVYUE9SVF9TWU1CT0woZHJtX2hhbmRsZV92YmxhbmspOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kZWJ1Z2ZzLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RlYnVnZnMuYwppbmRleCAxOWEzZDU4Li4zNjAxNDY2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RlYnVnZnMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RlYnVnZnMuYwpAQCAtNzAzLDcgKzcwMyw3IEBACiAJc2VxX3ByaW50ZihtLCAiJXMgWyVkXTpcbiIsIG5hbWUsIGNvdW50KTsKIAogCXdoaWxlIChjb3VudC0tKSB7Ci0JCXNlcV9wcmludGYobSwgIiAgJTA4eCAlOHpkICUwNHggJTA0eCAlMDh4JXMlcyVzJXMlcyVzIiwKKwkJc2VxX3ByaW50ZihtLCAiICAlMDh4ICU4dSAlMDR4ICUwNHggJTA4eCVzJXMlcyVzJXMlcyIsCiAJCQkgICBlcnItPmd0dF9vZmZzZXQsCiAJCQkgICBlcnItPnNpemUsCiAJCQkgICBlcnItPnJlYWRfZG9tYWlucywKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZG1hLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RtYS5jCmluZGV4IDg0NGYzYzkuLjE3YmQ3NjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZG1hLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kbWEuYwpAQCAtMTUyLDcgKzE1Miw3IEBACiB7CiAJZHJtX2k5MTVfcHJpdmF0ZV90ICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7CiAJc3RydWN0IGRybV9pOTE1X21hc3Rlcl9wcml2YXRlICptYXN0ZXJfcHJpdiA9IGRldi0+cHJpbWFyeS0+bWFzdGVyLT5kcml2ZXJfcHJpdjsKLQlzdHJ1Y3QgaW50ZWxfcmluZ19idWZmZXIgKnJpbmcgPSBMUF9SSU5HKGRldl9wcml2KTsKKwlpbnQgcmV0OwogCiAJbWFzdGVyX3ByaXYtPnNhcmVhID0gZHJtX2dldHNhcmVhKGRldik7CiAJaWYgKG1hc3Rlcl9wcml2LT5zYXJlYSkgewpAQCAtMTYzLDMzICsxNjMsMjIgQEAKIAl9CiAKIAlpZiAoaW5pdC0+cmluZ19zaXplICE9IDApIHsKLQkJaWYgKHJpbmctPm9iaiAhPSBOVUxMKSB7CisJCWlmIChMUF9SSU5HKGRldl9wcml2KS0+b2JqICE9IE5VTEwpIHsKIAkJCWk5MTVfZG1hX2NsZWFudXAoZGV2KTsKIAkJCURSTV9FUlJPUigiQ2xpZW50IHRyaWVkIHRvIGluaXRpYWxpemUgcmluZ2J1ZmZlciBpbiAiCiAJCQkJICAiR0VNIG1vZGVcbiIpOwogCQkJcmV0dXJuIC1FSU5WQUw7CiAJCX0KIAotCQlyaW5nLT5zaXplID0gaW5pdC0+cmluZ19zaXplOwotCi0JCXJpbmctPm1hcC5vZmZzZXQgPSBpbml0LT5yaW5nX3N0YXJ0OwotCQlyaW5nLT5tYXAuc2l6ZSA9IGluaXQtPnJpbmdfc2l6ZTsKLQkJcmluZy0+bWFwLnR5cGUgPSAwOwotCQlyaW5nLT5tYXAuZmxhZ3MgPSAwOwotCQlyaW5nLT5tYXAubXRyciA9IDA7Ci0KLQkJZHJtX2NvcmVfaW9yZW1hcF93YygmcmluZy0+bWFwLCBkZXYpOwotCi0JCWlmIChyaW5nLT5tYXAuaGFuZGxlID09IE5VTEwpIHsKKwkJcmV0ID0gaW50ZWxfcmVuZGVyX3JpbmdfaW5pdF9kcmkoZGV2LAorCQkJCQkJIGluaXQtPnJpbmdfc3RhcnQsCisJCQkJCQkgaW5pdC0+cmluZ19zaXplKTsKKwkJaWYgKHJldCkgewogCQkJaTkxNV9kbWFfY2xlYW51cChkZXYpOwotCQkJRFJNX0VSUk9SKCJjYW4gbm90IGlvcmVtYXAgdmlydHVhbCBhZGRyZXNzIGZvciIKLQkJCQkgICIgcmluZyBidWZmZXJcbiIpOwotCQkJcmV0dXJuIC1FTk9NRU07CisJCQlyZXR1cm4gcmV0OwogCQl9CiAJfQogCi0JcmluZy0+dmlydHVhbF9zdGFydCA9IHJpbmctPm1hcC5oYW5kbGU7Ci0KIAlkZXZfcHJpdi0+Y3BwID0gaW5pdC0+Y3BwOwogCWRldl9wcml2LT5iYWNrX29mZnNldCA9IGluaXQtPmJhY2tfb2Zmc2V0OwogCWRldl9wcml2LT5mcm9udF9vZmZzZXQgPSBpbml0LT5mcm9udF9vZmZzZXQ7CkBAIC0xMjI2LDkgKzEyMTUsMTUgQEAKIAlpZiAocmV0KQogCQlEUk1fSU5GTygiZmFpbGVkIHRvIGZpbmQgVkJJT1MgdGFibGVzXG4iKTsKIAotCS8qIGlmIHdlIGhhdmUgPiAxIFZHQSBjYXJkcywgdGhlbiBkaXNhYmxlIHRoZSByYWRlb24gVkdBIHJlc291cmNlcyAqLworCS8qIElmIHdlIGhhdmUgPiAxIFZHQSBjYXJkcywgdGhlbiB3ZSBuZWVkIHRvIGFyYml0cmF0ZSBhY2Nlc3MKKwkgKiB0byB0aGUgY29tbW9uIFZHQSByZXNvdXJjZXMuCisJICoKKwkgKiBJZiB3ZSBhcmUgYSBzZWNvbmRhcnkgZGlzcGxheSBjb250cm9sbGVyICghUENJX0RJU1BMQVlfQ0xBU1NfVkdBKSwKKwkgKiB0aGVuIHdlIGRvIG5vdCB0YWtlIHBhcnQgaW4gVkdBIGFyYml0cmF0aW9uIGFuZCB0aGUKKwkgKiB2Z2FfY2xpZW50X3JlZ2lzdGVyKCkgZmFpbHMgd2l0aCAtRU5PREVWLgorCSAqLwogCXJldCA9IHZnYV9jbGllbnRfcmVnaXN0ZXIoZGV2LT5wZGV2LCBkZXYsIE5VTEwsIGk5MTVfdmdhX3NldF9kZWNvZGUpOwotCWlmIChyZXQpCisJaWYgKHJldCAmJiByZXQgIT0gLUVOT0RFVikKIAkJZ290byBjbGVhbnVwX3JpbmdidWZmZXI7CiAKIAlpbnRlbF9yZWdpc3Rlcl9kc21faGFuZGxlcigpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmMKaW5kZXggMGRlNzVhMi4uY2ZiNTZkMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jCkBAIC00OSw2ICs0OSw5IEBACiB1bnNpZ25lZCBpbnQgaTkxNV9sdmRzX2Rvd25jbG9jayA9IDA7CiBtb2R1bGVfcGFyYW1fbmFtZWQobHZkc19kb3duY2xvY2ssIGk5MTVfbHZkc19kb3duY2xvY2ssIGludCwgMDQwMCk7CiAKK3Vuc2lnbmVkIGludCBpOTE1X3BhbmVsX3VzZV9zc2MgPSAxOworbW9kdWxlX3BhcmFtX25hbWVkKGx2ZHNfdXNlX3NzYywgaTkxNV9wYW5lbF91c2Vfc3NjLCBpbnQsIDA2MDApOworCiBib29sIGk5MTVfdHJ5X3Jlc2V0ID0gdHJ1ZTsKIG1vZHVsZV9wYXJhbV9uYW1lZChyZXNldCwgaTkxNV90cnlfcmVzZXQsIGJvb2wsIDA2MDApOwogCkBAIC01Nyw3ICs2MCw3IEBACiAKICNkZWZpbmUgSU5URUxfVkdBX0RFVklDRShpZCwgaW5mbykgewkJXAogCS5jbGFzcyA9IFBDSV9DTEFTU19ESVNQTEFZX1ZHQSA8PCA4LAlcCi0JLmNsYXNzX21hc2sgPSAweGZmZmYwMCwJCQlcCisJLmNsYXNzX21hc2sgPSAweGZmMDAwMCwJCQlcCiAJLnZlbmRvciA9IDB4ODA4NiwJCQlcCiAJLmRldmljZSA9IGlkLAkJCQlcCiAJLnN1YnZlbmRvciA9IFBDSV9BTllfSUQsCQlcCkBAIC0zNTEsNiArMzU0LDcgQEAKIAkJZXJyb3IgPSBpOTE1X2dlbV9pbml0X3JpbmdidWZmZXIoZGV2KTsKIAkJbXV0ZXhfdW5sb2NrKCZkZXYtPnN0cnVjdF9tdXRleCk7CiAKKwkJZHJtX21vZGVfY29uZmlnX3Jlc2V0KGRldik7CiAJCWRybV9pcnFfaW5zdGFsbChkZXYpOwogCiAJCS8qIFJlc3VtZSB0aGUgbW9kZXNldCBmb3IgZXZlcnkgYWN0aXZhdGVkIENSVEMgKi8KQEAgLTUzOSw2ICs1NDMsNyBAQAogCiAJCW11dGV4X3VubG9jaygmZGV2LT5zdHJ1Y3RfbXV0ZXgpOwogCQlkcm1faXJxX3VuaW5zdGFsbChkZXYpOworCQlkcm1fbW9kZV9jb25maWdfcmVzZXQoZGV2KTsKIAkJZHJtX2lycV9pbnN0YWxsKGRldik7CiAJCW11dGV4X2xvY2soJmRldi0+c3RydWN0X211dGV4KTsKIAl9CkBAIC01NjMsNiArNTY4LDE0IEBACiBzdGF0aWMgaW50IF9fZGV2aW5pdAogaTkxNV9wY2lfcHJvYmUoc3RydWN0IHBjaV9kZXYgKnBkZXYsIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICplbnQpCiB7CisJLyogT25seSBiaW5kIHRvIGZ1bmN0aW9uIDAgb2YgdGhlIGRldmljZS4gRWFybHkgZ2VuZXJhdGlvbnMKKwkgKiB1c2VkIGZ1bmN0aW9uIDEgYXMgYSBwbGFjZWhvbGRlciBmb3IgbXVsdGktaGVhZC4gVGhpcyBjYXVzZXMKKwkgKiB1cyBjb25mdXNpb24gaW5zdGVhZCwgZXNwZWNpYWxseSBvbiB0aGUgc3lzdGVtcyB3aGVyZSBib3RoCisJICogZnVuY3Rpb25zIGhhdmUgdGhlIHNhbWUgUENJLUlEIQorCSAqLworCWlmIChQQ0lfRlVOQyhwZGV2LT5kZXZmbikpCisJCXJldHVybiAtRU5PREVWOworCiAJcmV0dXJuIGRybV9nZXRfcGNpX2RldihwZGV2LCBlbnQsICZkcml2ZXIpOwogfQogCkBAIC03NDksNiArNzYyLDkgQEAKIAkJZHJpdmVyLmRyaXZlcl9mZWF0dXJlcyAmPSB+RFJJVkVSX01PREVTRVQ7CiAjZW5kaWYKIAorCWlmICghKGRyaXZlci5kcml2ZXJfZmVhdHVyZXMgJiBEUklWRVJfTU9ERVNFVCkpCisJCWRyaXZlci5nZXRfdmJsYW5rX3RpbWVzdGFtcCA9IE5VTEw7CisKIAlyZXR1cm4gZHJtX2luaXQoJmRyaXZlcik7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCmluZGV4IDM4NWZjN2UuLmEwMTQ5YzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaApAQCAtNTQzLDggKzU0MywxMSBAQAogCQkvKiogTGlzdCBvZiBhbGwgb2JqZWN0cyBpbiBndHRfc3BhY2UuIFVzZWQgdG8gcmVzdG9yZSBndHQKIAkJICogbWFwcGluZ3Mgb24gcmVzdW1lICovCiAJCXN0cnVjdCBsaXN0X2hlYWQgZ3R0X2xpc3Q7Ci0JCS8qKiBFbmQgb2YgbWFwcGFibGUgcGFydCBvZiBHVFQgKi8KKworCQkvKiogVXNhYmxlIHBvcnRpb24gb2YgdGhlIEdUVCBmb3IgR0VNICovCisJCXVuc2lnbmVkIGxvbmcgZ3R0X3N0YXJ0OwogCQl1bnNpZ25lZCBsb25nIGd0dF9tYXBwYWJsZV9lbmQ7CisJCXVuc2lnbmVkIGxvbmcgZ3R0X2VuZDsKIAogCQlzdHJ1Y3QgaW9fbWFwcGluZyAqZ3R0X21hcHBpbmc7CiAJCWludCBndHRfbXRycjsKQEAgLTk1NCw2ICs5NTcsNyBAQAogZXh0ZXJuIHVuc2lnbmVkIGludCBpOTE1X2ZicGVyY3J0YzsKIGV4dGVybiB1bnNpZ25lZCBpbnQgaTkxNV9wb3dlcnNhdmU7CiBleHRlcm4gdW5zaWduZWQgaW50IGk5MTVfbHZkc19kb3duY2xvY2s7CitleHRlcm4gdW5zaWduZWQgaW50IGk5MTVfcGFuZWxfdXNlX3NzYzsKIAogZXh0ZXJuIGludCBpOTE1X3N1c3BlbmQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgcG1fbWVzc2FnZV90IHN0YXRlKTsKIGV4dGVybiBpbnQgaTkxNV9yZXN1bWUoc3RydWN0IGRybV9kZXZpY2UgKmRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYwppbmRleCAzZGZjODQ4Li5jZjRmNzRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKQEAgLTE0MCwxMiArMTQwLDE2IEBACiB7CiAJZHJtX2k5MTVfcHJpdmF0ZV90ICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7CiAKLQlkcm1fbW1faW5pdCgmZGV2X3ByaXYtPm1tLmd0dF9zcGFjZSwgc3RhcnQsCi0JCSAgICBlbmQgLSBzdGFydCk7CisJZHJtX21tX2luaXQoJmRldl9wcml2LT5tbS5ndHRfc3BhY2UsIHN0YXJ0LCBlbmQgLSBzdGFydCk7CiAKKwlkZXZfcHJpdi0+bW0uZ3R0X3N0YXJ0ID0gc3RhcnQ7CisJZGV2X3ByaXYtPm1tLmd0dF9tYXBwYWJsZV9lbmQgPSBtYXBwYWJsZV9lbmQ7CisJZGV2X3ByaXYtPm1tLmd0dF9lbmQgPSBlbmQ7CiAJZGV2X3ByaXYtPm1tLmd0dF90b3RhbCA9IGVuZCAtIHN0YXJ0OwogCWRldl9wcml2LT5tbS5tYXBwYWJsZV9ndHRfdG90YWwgPSBtaW4oZW5kLCBtYXBwYWJsZV9lbmQpIC0gc3RhcnQ7Ci0JZGV2X3ByaXYtPm1tLmd0dF9tYXBwYWJsZV9lbmQgPSBtYXBwYWJsZV9lbmQ7CisKKwkvKiBUYWtlIG92ZXIgdGhpcyBwb3J0aW9uIG9mIHRoZSBHVFQgKi8KKwlpbnRlbF9ndHRfY2xlYXJfcmFuZ2Uoc3RhcnQgLyBQQUdFX1NJWkUsIChlbmQtc3RhcnQpIC8gUEFHRV9TSVpFKTsKIH0KIAogaW50CkBAIC0xODU3LDcgKzE4NjEsNyBAQAogCiAJc2Vxbm8gPSByaW5nLT5nZXRfc2Vxbm8ocmluZyk7CiAKLQlmb3IgKGkgPSAwOyBpIDwgSTkxNV9OVU1fUklOR1M7IGkrKykKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShyaW5nLT5zeW5jX3NlcW5vKTsgaSsrKQogCQlpZiAoc2Vxbm8gPj0gcmluZy0+c3luY19zZXFub1tpXSkKIAkJCXJpbmctPnN5bmNfc2Vxbm9baV0gPSAwOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9leGVjYnVmZmVyLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9leGVjYnVmZmVyLmMKaW5kZXggZTY5ODM0My4uZDJmNDQ1ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1fZXhlY2J1ZmZlci5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX2V4ZWNidWZmZXIuYwpAQCAtNDY0LDggKzQ2NCw2IEBACiAJaW50IHJldDsKIAogCWxpc3RfZm9yX2VhY2hfZW50cnkob2JqLCBvYmplY3RzLCBleGVjX2xpc3QpIHsKLQkJb2JqLT5iYXNlLnBlbmRpbmdfcmVhZF9kb21haW5zID0gMDsKLQkJb2JqLT5iYXNlLnBlbmRpbmdfd3JpdGVfZG9tYWluID0gMDsKIAkJcmV0ID0gaTkxNV9nZW1fZXhlY2J1ZmZlcl9yZWxvY2F0ZV9vYmplY3Qob2JqLCBlYik7CiAJCWlmIChyZXQpCiAJCQlyZXR1cm4gcmV0OwpAQCAtNTA1LDYgKzUwMyw5IEBACiAJCQlsaXN0X21vdmUoJm9iai0+ZXhlY19saXN0LCAmb3JkZXJlZF9vYmplY3RzKTsKIAkJZWxzZQogCQkJbGlzdF9tb3ZlX3RhaWwoJm9iai0+ZXhlY19saXN0LCAmb3JkZXJlZF9vYmplY3RzKTsKKworCQlvYmotPmJhc2UucGVuZGluZ19yZWFkX2RvbWFpbnMgPSAwOworCQlvYmotPmJhc2UucGVuZGluZ193cml0ZV9kb21haW4gPSAwOwogCX0KIAlsaXN0X3NwbGljZSgmb3JkZXJlZF9vYmplY3RzLCBvYmplY3RzKTsKIApAQCAtNjM2LDYgKzYzNyw3IEBACiB7CiAJc3RydWN0IGRybV9pOTE1X2dlbV9yZWxvY2F0aW9uX2VudHJ5ICpyZWxvYzsKIAlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqOworCWludCAqcmVsb2Nfb2Zmc2V0OwogCWludCBpLCB0b3RhbCwgcmV0OwogCiAJLyogV2UgbWF5IHByb2Nlc3MgYW5vdGhlciBleGVjYnVmZmVyIGR1cmluZyB0aGUgdW5sb2NrLi4uICovCkBAIC02NTMsOCArNjU1LDExIEBACiAJZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspCiAJCXRvdGFsICs9IGV4ZWNbaV0ucmVsb2NhdGlvbl9jb3VudDsKIAorCXJlbG9jX29mZnNldCA9IGRybV9tYWxsb2NfYWIoY291bnQsIHNpemVvZigqcmVsb2Nfb2Zmc2V0KSk7CiAJcmVsb2MgPSBkcm1fbWFsbG9jX2FiKHRvdGFsLCBzaXplb2YoKnJlbG9jKSk7Ci0JaWYgKHJlbG9jID09IE5VTEwpIHsKKwlpZiAocmVsb2MgPT0gTlVMTCB8fCByZWxvY19vZmZzZXQgPT0gTlVMTCkgeworCQlkcm1fZnJlZV9sYXJnZShyZWxvYyk7CisJCWRybV9mcmVlX2xhcmdlKHJlbG9jX29mZnNldCk7CiAJCW11dGV4X2xvY2soJmRldi0+c3RydWN0X211dGV4KTsKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQpAQCAtNjcyLDYgKzY3Nyw3IEBACiAJCQlnb3RvIGVycjsKIAkJfQogCisJCXJlbG9jX29mZnNldFtpXSA9IHRvdGFsOwogCQl0b3RhbCArPSBleGVjW2ldLnJlbG9jYXRpb25fY291bnQ7CiAJfQogCkBAIC03MDUsMTcgKzcxMSwxMiBAQAogCWlmIChyZXQpCiAJCWdvdG8gZXJyOwogCi0JdG90YWwgPSAwOwogCWxpc3RfZm9yX2VhY2hfZW50cnkob2JqLCBvYmplY3RzLCBleGVjX2xpc3QpIHsKLQkJb2JqLT5iYXNlLnBlbmRpbmdfcmVhZF9kb21haW5zID0gMDsKLQkJb2JqLT5iYXNlLnBlbmRpbmdfd3JpdGVfZG9tYWluID0gMDsKKwkJaW50IG9mZnNldCA9IG9iai0+ZXhlY19lbnRyeSAtIGV4ZWM7CiAJCXJldCA9IGk5MTVfZ2VtX2V4ZWNidWZmZXJfcmVsb2NhdGVfb2JqZWN0X3Nsb3cob2JqLCBlYiwKLQkJCQkJCQkgICAgICAgcmVsb2MgKyB0b3RhbCk7CisJCQkJCQkJICAgICAgIHJlbG9jICsgcmVsb2Nfb2Zmc2V0W29mZnNldF0pOwogCQlpZiAocmV0KQogCQkJZ290byBlcnI7Ci0KLQkJdG90YWwgKz0gZXhlYy0+cmVsb2NhdGlvbl9jb3VudDsKLQkJZXhlYysrOwogCX0KIAogCS8qIExlYXZlIHRoZSB1c2VyIHJlbG9jYXRpb25zIGFzIGFyZSwgdGhpcyBpcyB0aGUgcGFpbmZ1bGx5IHNsb3cgcGF0aCwKQEAgLTcyNiw2ICs3MjcsNyBAQAogCiBlcnI6CiAJZHJtX2ZyZWVfbGFyZ2UocmVsb2MpOworCWRybV9mcmVlX2xhcmdlKHJlbG9jX29mZnNldCk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtNzcwLDcgKzc3Miw4IEBACiAJaWYgKGZyb20gPT0gTlVMTCB8fCB0byA9PSBmcm9tKQogCQlyZXR1cm4gMDsKIAotCWlmIChJTlRFTF9JTkZPKG9iai0+YmFzZS5kZXYpLT5nZW4gPCA2KQorCS8qIFhYWCBncHUgc2VtYXBob3JlcyBhcmUgY3VycmVudGx5IGNhdXNpbmcgaGFyZCBoYW5ncyBvbiBTTkIgbW9iaWxlICovCisJaWYgKElOVEVMX0lORk8ob2JqLT5iYXNlLmRldiktPmdlbiA8IDYgfHwgSVNfTU9CSUxFKG9iai0+YmFzZS5kZXYpKQogCQlyZXR1cm4gaTkxNV9nZW1fb2JqZWN0X3dhaXRfcmVuZGVyaW5nKG9iaiwgdHJ1ZSk7CiAKIAlpZHggPSBpbnRlbF9yaW5nX3N5bmNfaW5kZXgoZnJvbSwgdG8pOwpAQCAtMTE3Miw3ICsxMTc1LDcgQEAKIAkJZ290byBlcnI7CiAKIAlzZXFubyA9IGk5MTVfZ2VtX25leHRfcmVxdWVzdF9zZXFubyhkZXYsIHJpbmcpOwotCWZvciAoaSA9IDA7IGkgPCBJOTE1X05VTV9SSU5HUy0xOyBpKyspIHsKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShyaW5nLT5zeW5jX3NlcW5vKTsgaSsrKSB7CiAJCWlmIChzZXFubyA8IHJpbmctPnN5bmNfc2Vxbm9baV0pIHsKIAkJCS8qIFRoZSBHUFUgY2FuIG5vdCBoYW5kbGUgaXRzIHNlbWFwaG9yZSB2YWx1ZSB3cmFwcGluZywKIAkJCSAqIHNvIGV2ZXJ5IGJpbGxpb24gb3Igc28gZXhlY2J1ZmZlcnMsIHdlIG5lZWQgdG8gc3RhbGwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX2d0dC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1fZ3R0LmMKaW5kZXggNzA0MzNhZS4uYjBhYmRjNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1fZ3R0LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1fZ3R0LmMKQEAgLTM0LDYgKzM0LDEwIEBACiAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKIAlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqOwogCisJLyogRmlyc3QgZmlsbCBvdXIgcG9ydGlvbiBvZiB0aGUgR1RUIHdpdGggc2NyYXRjaCBwYWdlcyAqLworCWludGVsX2d0dF9jbGVhcl9yYW5nZShkZXZfcHJpdi0+bW0uZ3R0X3N0YXJ0IC8gUEFHRV9TSVpFLAorCQkJICAgICAgKGRldl9wcml2LT5tbS5ndHRfZW5kIC0gZGV2X3ByaXYtPm1tLmd0dF9zdGFydCkgLyBQQUdFX1NJWkUpOworCiAJbGlzdF9mb3JfZWFjaF9lbnRyeShvYmosICZkZXZfcHJpdi0+bW0uZ3R0X2xpc3QsIGd0dF9saXN0KSB7CiAJCWk5MTVfZ2VtX2NsZmx1c2hfb2JqZWN0KG9iaik7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfaXJxLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2lycS5jCmluZGV4IGU0MThlOGIuLjk3Zjk0NmRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2lycS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfaXJxLmMKQEAgLTI3NCwyNCArMjc0LDM1IEBACiAJcmV0dXJuIHJldDsKIH0KIAotaW50IGk5MTVfZ2V0X3ZibGFua190aW1lc3RhbXAoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgaW50IGNydGMsCitpbnQgaTkxNV9nZXRfdmJsYW5rX3RpbWVzdGFtcChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBpbnQgcGlwZSwKIAkJCSAgICAgIGludCAqbWF4X2Vycm9yLAogCQkJICAgICAgc3RydWN0IHRpbWV2YWwgKnZibGFua190aW1lLAogCQkJICAgICAgdW5zaWduZWQgZmxhZ3MpCiB7Ci0Jc3RydWN0IGRybV9jcnRjICpkcm1jcnRjOworCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7CisJc3RydWN0IGRybV9jcnRjICpjcnRjOwogCi0JaWYgKGNydGMgPCAwIHx8IGNydGMgPj0gZGV2LT5udW1fY3J0Y3MpIHsKLQkJRFJNX0VSUk9SKCJJbnZhbGlkIGNydGMgJWRcbiIsIGNydGMpOworCWlmIChwaXBlIDwgMCB8fCBwaXBlID49IGRldl9wcml2LT5udW1fcGlwZSkgeworCQlEUk1fRVJST1IoIkludmFsaWQgY3J0YyAlZFxuIiwgcGlwZSk7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAogCS8qIEdldCBkcm1fY3J0YyB0byB0aW1lc3RhbXA6ICovCi0JZHJtY3J0YyA9IGludGVsX2dldF9jcnRjX2Zvcl9waXBlKGRldiwgY3J0Yyk7CisJY3J0YyA9IGludGVsX2dldF9jcnRjX2Zvcl9waXBlKGRldiwgcGlwZSk7CisJaWYgKGNydGMgPT0gTlVMTCkgeworCQlEUk1fRVJST1IoIkludmFsaWQgY3J0YyAlZFxuIiwgcGlwZSk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCWlmICghY3J0Yy0+ZW5hYmxlZCkgeworCQlEUk1fREVCVUdfS01TKCJjcnRjICVkIGlzIGRpc2FibGVkXG4iLCBwaXBlKTsKKwkJcmV0dXJuIC1FQlVTWTsKKwl9CiAKIAkvKiBIZWxwZXIgcm91dGluZSBpbiBEUk0gY29yZSBkb2VzIGFsbCB0aGUgd29yazogKi8KLQlyZXR1cm4gZHJtX2NhbGNfdmJsdGltZXN0YW1wX2Zyb21fc2Nhbm91dHBvcyhkZXYsIGNydGMsIG1heF9lcnJvciwKLQkJCQkJCSAgICAgdmJsYW5rX3RpbWUsIGZsYWdzLCBkcm1jcnRjKTsKKwlyZXR1cm4gZHJtX2NhbGNfdmJsdGltZXN0YW1wX2Zyb21fc2Nhbm91dHBvcyhkZXYsIHBpcGUsIG1heF9lcnJvciwKKwkJCQkJCSAgICAgdmJsYW5rX3RpbWUsIGZsYWdzLAorCQkJCQkJICAgICBjcnRjKTsKIH0KIAogLyoKQEAgLTM0OCw4ICszNTksMTIgQEAKIAkJCXN0cnVjdCBpbnRlbF9yaW5nX2J1ZmZlciAqcmluZykKIHsKIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwotCXUzMiBzZXFubyA9IHJpbmctPmdldF9zZXFubyhyaW5nKTsKKwl1MzIgc2Vxbm87CiAKKwlpZiAocmluZy0+b2JqID09IE5VTEwpCisJCXJldHVybjsKKworCXNlcW5vID0gcmluZy0+Z2V0X3NlcW5vKHJpbmcpOwogCXRyYWNlX2k5MTVfZ2VtX3JlcXVlc3RfY29tcGxldGUoZGV2LCBzZXFubyk7CiAKIAlyaW5nLT5pcnFfc2Vxbm8gPSBzZXFubzsKQEAgLTcyMCw3ICs3MzUsNyBAQAogCQlpZiAob2JqLT5yaW5nICE9IHJpbmcpCiAJCQljb250aW51ZTsKIAotCQlpZiAoIWk5MTVfc2Vxbm9fcGFzc2VkKG9iai0+bGFzdF9yZW5kZXJpbmdfc2Vxbm8sIHNlcW5vKSkKKwkJaWYgKGk5MTVfc2Vxbm9fcGFzc2VkKHNlcW5vLCBvYmotPmxhc3RfcmVuZGVyaW5nX3NlcW5vKSkKIAkJCWNvbnRpbnVlOwogCiAJCWlmICgob2JqLT5iYXNlLnJlYWRfZG9tYWlucyAmIEk5MTVfR0VNX0RPTUFJTl9DT01NQU5EKSA9PSAwKQpAQCAtODMxLDYgKzg0Niw4IEBACiAJCWkrKzsKIAllcnJvci0+cGlubmVkX2JvX2NvdW50ID0gaSAtIGVycm9yLT5hY3RpdmVfYm9fY291bnQ7CiAKKwllcnJvci0+YWN0aXZlX2JvID0gTlVMTDsKKwllcnJvci0+cGlubmVkX2JvID0gTlVMTDsKIAlpZiAoaSkgewogCQllcnJvci0+YWN0aXZlX2JvID0ga21hbGxvYyhzaXplb2YoKmVycm9yLT5hY3RpdmVfYm8pKmksCiAJCQkJCSAgIEdGUF9BVE9NSUMpOwpAQCAtMTE3OSwxOCArMTE5NiwxOCBAQAogCQkJCWludGVsX2ZpbmlzaF9wYWdlX2ZsaXBfcGxhbmUoZGV2LCAxKTsKIAkJfQogCi0JCWlmIChwaXBlYV9zdGF0cyAmIHZibGFua19zdGF0dXMpIHsKKwkJaWYgKHBpcGVhX3N0YXRzICYgdmJsYW5rX3N0YXR1cyAmJgorCQkgICAgZHJtX2hhbmRsZV92YmxhbmsoZGV2LCAwKSkgewogCQkJdmJsYW5rKys7Ci0JCQlkcm1faGFuZGxlX3ZibGFuayhkZXYsIDApOwogCQkJaWYgKCFkZXZfcHJpdi0+ZmxpcF9wZW5kaW5nX2lzX2RvbmUpIHsKIAkJCQlpOTE1X3BhZ2VmbGlwX3N0YWxsX2NoZWNrKGRldiwgMCk7CiAJCQkJaW50ZWxfZmluaXNoX3BhZ2VfZmxpcChkZXYsIDApOwogCQkJfQogCQl9CiAKLQkJaWYgKHBpcGViX3N0YXRzICYgdmJsYW5rX3N0YXR1cykgeworCQlpZiAocGlwZWJfc3RhdHMgJiB2Ymxhbmtfc3RhdHVzICYmCisJCSAgICBkcm1faGFuZGxlX3ZibGFuayhkZXYsIDEpKSB7CiAJCQl2YmxhbmsrKzsKLQkJCWRybV9oYW5kbGVfdmJsYW5rKGRldiwgMSk7CiAJCQlpZiAoIWRldl9wcml2LT5mbGlwX3BlbmRpbmdfaXNfZG9uZSkgewogCQkJCWk5MTVfcGFnZWZsaXBfc3RhbGxfY2hlY2soZGV2LCAxKTsKIAkJCQlpbnRlbF9maW5pc2hfcGFnZV9mbGlwKGRldiwgMSk7CkBAIC0xMjc4LDEyICsxMjk1LDEyIEBACiAJaWYgKG1hc3Rlcl9wcml2LT5zYXJlYV9wcml2KQogCQltYXN0ZXJfcHJpdi0+c2FyZWFfcHJpdi0+cGVyZl9ib3hlcyB8PSBJOTE1X0JPWF9XQUlUOwogCi0JcmV0ID0gLUVOT0RFVjsKIAlpZiAocmluZy0+aXJxX2dldChyaW5nKSkgewogCQlEUk1fV0FJVF9PTihyZXQsIHJpbmctPmlycV9xdWV1ZSwgMyAqIERSTV9IWiwKIAkJCSAgICBSRUFEX0JSRUFEQ1JVTUIoZGV2X3ByaXYpID49IGlycV9ucik7CiAJCXJpbmctPmlycV9wdXQocmluZyk7Ci0JfQorCX0gZWxzZSBpZiAod2FpdF9mb3IoUkVBRF9CUkVBRENSVU1CKGRldl9wcml2KSA+PSBpcnFfbnIsIDMwMDApKQorCQlyZXQgPSAtRUJVU1k7CiAKIAlpZiAocmV0ID09IC1FQlVTWSkgewogCQlEUk1fRVJST1IoIkVCVVNZIC0tIHJlYzogJWQgZW1pdHRlZDogJWRcbiIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3JlZy5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9yZWcuaAppbmRleCA0MGE0MDdmLi41Y2ZjNjg5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3JlZy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfcmVnLmgKQEAgLTUxMyw2ICs1MTMsMTAgQEAKICNkZWZpbmUgICBHRU42X0JMSVRURVJfU1lOQ19TVEFUVVMJCQkoMSA8PCAyNCkKICNkZWZpbmUgICBHRU42X0JMSVRURVJfVVNFUl9JTlRFUlJVUFQJCQkoMSA8PCAyMikKIAorI2RlZmluZSBHRU42X0JMSVRURVJfRUNPU0tQRAkweDIyMWQwCisjZGVmaW5lICAgR0VONl9CTElUVEVSX0xPQ0tfU0hJRlQJCQkxNgorI2RlZmluZSAgIEdFTjZfQkxJVFRFUl9GQkNfTk9USUZZCQkJKDE8PDMpCisKICNkZWZpbmUgR0VONl9CU0RfU0xFRVBfUFNNSV9DT05UUk9MCTB4MTIwNTAKICNkZWZpbmUgICBHRU42X0JTRF9TTEVFUF9QU01JX0NPTlRST0xfUkNfSUxETF9NRVNTQUdFX01PRElGWV9NQVNLCSgxIDw8IDE2KQogI2RlZmluZSAgIEdFTjZfQlNEX1NMRUVQX1BTTUlfQ09OVFJPTF9SQ19JTERMX01FU1NBR0VfRElTQUJMRQkJKDEgPDwgMCkKQEAgLTI2MjYsNiArMjYzMCw4IEBACiAjZGVmaW5lIERJU1BMQVlfUE9SVF9QTExfQklPU18yICAgICAgICAgMHg0NjAxNAogCiAjZGVmaW5lIFBDSF9EU1BDTEtfR0FURV9ECTB4NDIwMjAKKyMgZGVmaW5lIERQRkNVTklUX0NMT0NLX0dBVEVfRElTQUJMRQkJKDEgPDwgOSkKKyMgZGVmaW5lIERQRkNSVU5JVF9DTE9DS19HQVRFX0RJU0FCTEUJCSgxIDw8IDgpCiAjIGRlZmluZSBEUEZEVU5JVF9DTE9DS19HQVRFX0RJU0FCTEUJCSgxIDw8IDcpCiAjIGRlZmluZSBEUEFSQlVOSVRfQ0xPQ0tfR0FURV9ESVNBQkxFCQkoMSA8PCA1KQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9iaW9zLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9iaW9zLmMKaW5kZXggYjBiMTIwMC4uMGI0NDk1NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfYmlvcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Jpb3MuYwpAQCAtMjY0LDE3ICsyNjQsMTIgQEAKIAkJZGV2X3ByaXYtPmludF9jcnRfc3VwcG9ydCA9IGdlbmVyYWwtPmludF9jcnRfc3VwcG9ydDsKIAkJZGV2X3ByaXYtPmx2ZHNfdXNlX3NzYyA9IGdlbmVyYWwtPmVuYWJsZV9zc2M7CiAKLQkJaWYgKGRldl9wcml2LT5sdmRzX3VzZV9zc2MpIHsKLQkJCWlmIChJU19JODVYKGRldikpCi0JCQkJZGV2X3ByaXYtPmx2ZHNfc3NjX2ZyZXEgPQotCQkJCQlnZW5lcmFsLT5zc2NfZnJlcSA/IDY2IDogNDg7Ci0JCQllbHNlIGlmIChJU19HRU41KGRldikgfHwgSVNfR0VONihkZXYpKQotCQkJCWRldl9wcml2LT5sdmRzX3NzY19mcmVxID0KLQkJCQkJZ2VuZXJhbC0+c3NjX2ZyZXEgPyAxMDAgOiAxMjA7Ci0JCQllbHNlCi0JCQkJZGV2X3ByaXYtPmx2ZHNfc3NjX2ZyZXEgPQotCQkJCQlnZW5lcmFsLT5zc2NfZnJlcSA/IDEwMCA6IDk2OwotCQl9CisJCWlmIChJU19JODVYKGRldikpCisJCQlkZXZfcHJpdi0+bHZkc19zc2NfZnJlcSA9IGdlbmVyYWwtPnNzY19mcmVxID8gNjYgOiA0ODsKKwkJZWxzZSBpZiAoSVNfR0VONShkZXYpIHx8IElTX0dFTjYoZGV2KSkKKwkJCWRldl9wcml2LT5sdmRzX3NzY19mcmVxID0gZ2VuZXJhbC0+c3NjX2ZyZXEgPyAxMDAgOiAxMjA7CisJCWVsc2UKKwkJCWRldl9wcml2LT5sdmRzX3NzY19mcmVxID0gZ2VuZXJhbC0+c3NjX2ZyZXEgPyAxMDAgOiA5NjsKIAl9CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2NydC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfY3J0LmMKaW5kZXggMTcwMzViOC4uOGE3N2ZmNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfY3J0LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfY3J0LmMKQEAgLTUzNSw2ICs1MzUsMTUgQEAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIHZvaWQgaW50ZWxfY3J0X3Jlc2V0KHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IpCit7CisJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGNvbm5lY3Rvci0+ZGV2OworCXN0cnVjdCBpbnRlbF9jcnQgKmNydCA9IGludGVsX2F0dGFjaGVkX2NydChjb25uZWN0b3IpOworCisJaWYgKEhBU19QQ0hfU1BMSVQoZGV2KSkKKwkJY3J0LT5mb3JjZV9ob3RwbHVnX3JlcXVpcmVkID0gMTsKK30KKwogLyoKICAqIFJvdXRpbmVzIGZvciBjb250cm9sbGluZyBzdHVmZiBvbiB0aGUgYW5hbG9nIHBvcnQKICAqLwpAQCAtNTQ4LDYgKzU1Nyw3IEBACiB9OwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9jb25uZWN0b3JfZnVuY3MgaW50ZWxfY3J0X2Nvbm5lY3Rvcl9mdW5jcyA9IHsKKwkucmVzZXQgPSBpbnRlbF9jcnRfcmVzZXQsCiAJLmRwbXMgPSBkcm1faGVscGVyX2Nvbm5lY3Rvcl9kcG1zLAogCS5kZXRlY3QgPSBpbnRlbF9jcnRfZGV0ZWN0LAogCS5maWxsX21vZGVzID0gZHJtX2hlbHBlcl9wcm9iZV9zaW5nbGVfY29ubmVjdG9yX21vZGVzLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCmluZGV4IDI1ZDk2ODguLjdlNDJhYTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKQEAgLTEyMTMsNiArMTIxMywyNiBAQAogCXJldHVybiBJOTE1X1JFQUQoRFBGQ19DT05UUk9MKSAmIERQRkNfQ1RMX0VOOwogfQogCitzdGF0aWMgdm9pZCBzYW5keWJyaWRnZV9ibGl0X2ZiY191cGRhdGUoc3RydWN0IGRybV9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOworCXUzMiBibHRfZWNvc2twZDsKKworCS8qIE1ha2Ugc3VyZSBibGl0dGVyIG5vdGlmaWVzIEZCQyBvZiB3cml0ZXMgKi8KKwlfX2dlbjZfZm9yY2Vfd2FrZV9nZXQoZGV2X3ByaXYpOworCWJsdF9lY29za3BkID0gSTkxNV9SRUFEKEdFTjZfQkxJVFRFUl9FQ09TS1BEKTsKKwlibHRfZWNvc2twZCB8PSBHRU42X0JMSVRURVJfRkJDX05PVElGWSA8PAorCQlHRU42X0JMSVRURVJfTE9DS19TSElGVDsKKwlJOTE1X1dSSVRFKEdFTjZfQkxJVFRFUl9FQ09TS1BELCBibHRfZWNvc2twZCk7CisJYmx0X2Vjb3NrcGQgfD0gR0VONl9CTElUVEVSX0ZCQ19OT1RJRlk7CisJSTkxNV9XUklURShHRU42X0JMSVRURVJfRUNPU0tQRCwgYmx0X2Vjb3NrcGQpOworCWJsdF9lY29za3BkICY9IH4oR0VONl9CTElUVEVSX0ZCQ19OT1RJRlkgPDwKKwkJCSBHRU42X0JMSVRURVJfTE9DS19TSElGVCk7CisJSTkxNV9XUklURShHRU42X0JMSVRURVJfRUNPU0tQRCwgYmx0X2Vjb3NrcGQpOworCVBPU1RJTkdfUkVBRChHRU42X0JMSVRURVJfRUNPU0tQRCk7CisJX19nZW42X2ZvcmNlX3dha2VfcHV0KGRldl9wcml2KTsKK30KKwogc3RhdGljIHZvaWQgaXJvbmxha2VfZW5hYmxlX2ZiYyhzdHJ1Y3QgZHJtX2NydGMgKmNydGMsIHVuc2lnbmVkIGxvbmcgaW50ZXJ2YWwpCiB7CiAJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGNydGMtPmRldjsKQEAgLTEyNjYsNiArMTI4Niw3IEBACiAJCUk5MTVfV1JJVEUoU05CX0RQRkNfQ1RMX1NBLAogCQkJICAgU05CX0NQVV9GRU5DRV9FTkFCTEUgfCBkZXZfcHJpdi0+Y2ZiX2ZlbmNlKTsKIAkJSTkxNV9XUklURShEUEZDX0NQVV9GRU5DRV9PRkZTRVQsIGNydGMtPnkpOworCQlzYW5keWJyaWRnZV9ibGl0X2ZiY191cGRhdGUoZGV2KTsKIAl9CiAKIAlEUk1fREVCVUdfS01TKCJlbmFibGVkIGZiYyBvbiBwbGFuZSAlZFxuIiwgaW50ZWxfY3J0Yy0+cGxhbmUpOwpAQCAtMzgyMiw2ICszODQzLDExIEBACiAJCQkJICAgIHNyX2hkaXNwbGF5LCBzcl9odG90YWwsIHBpeGVsX3NpemUpOwogfQogCitzdGF0aWMgaW5saW5lIGJvb2wgaW50ZWxfcGFuZWxfdXNlX3NzYyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCit7CisJcmV0dXJuIGRldl9wcml2LT5sdmRzX3VzZV9zc2MgJiYgaTkxNV9wYW5lbF91c2Vfc3NjOworfQorCiBzdGF0aWMgaW50IGludGVsX2NydGNfbW9kZV9zZXQoc3RydWN0IGRybV9jcnRjICpjcnRjLAogCQkJICAgICAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlLAogCQkJICAgICAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICphZGp1c3RlZF9tb2RlLApAQCAtMzg4NCw3ICszOTEwLDcgQEAKIAkJbnVtX2Nvbm5lY3RvcnMrKzsKIAl9CiAKLQlpZiAoaXNfbHZkcyAmJiBkZXZfcHJpdi0+bHZkc191c2Vfc3NjICYmIG51bV9jb25uZWN0b3JzIDwgMikgeworCWlmIChpc19sdmRzICYmIGludGVsX3BhbmVsX3VzZV9zc2MoZGV2X3ByaXYpICYmIG51bV9jb25uZWN0b3JzIDwgMikgewogCQlyZWZjbGsgPSBkZXZfcHJpdi0+bHZkc19zc2NfZnJlcSAqIDEwMDA7CiAJCURSTV9ERUJVR19LTVMoInVzaW5nIFNTQyByZWZlcmVuY2UgY2xvY2sgb2YgJWQgTUh6XG4iLAogCQkJICAgICAgcmVmY2xrIC8gMTAwMCk7CkBAIC00MDU5LDcgKzQwODUsNyBAQAogCQl1ZGVsYXkoMjAwKTsKIAogCQlpZiAoaGFzX2VkcF9lbmNvZGVyKSB7Ci0JCQlpZiAoZGV2X3ByaXYtPmx2ZHNfdXNlX3NzYykgeworCQkJaWYgKGludGVsX3BhbmVsX3VzZV9zc2MoZGV2X3ByaXYpKSB7CiAJCQkJdGVtcCB8PSBEUkVGX1NTQzFfRU5BQkxFOwogCQkJCUk5MTVfV1JJVEUoUENIX0RSRUZfQ09OVFJPTCwgdGVtcCk7CiAKQEAgLTQwNzAsMTMgKzQwOTYsMTMgQEAKIAogCQkJLyogRW5hYmxlIENQVSBzb3VyY2Ugb24gQ1BVIGF0dGFjaGVkIGVEUCAqLwogCQkJaWYgKCFpbnRlbF9lbmNvZGVyX2lzX3BjaF9lZHAoJmhhc19lZHBfZW5jb2Rlci0+YmFzZSkpIHsKLQkJCQlpZiAoZGV2X3ByaXYtPmx2ZHNfdXNlX3NzYykKKwkJCQlpZiAoaW50ZWxfcGFuZWxfdXNlX3NzYyhkZXZfcHJpdikpCiAJCQkJCXRlbXAgfD0gRFJFRl9DUFVfU09VUkNFX09VVFBVVF9ET1dOU1BSRUFEOwogCQkJCWVsc2UKIAkJCQkJdGVtcCB8PSBEUkVGX0NQVV9TT1VSQ0VfT1VUUFVUX05PTlNQUkVBRDsKIAkJCX0gZWxzZSB7CiAJCQkJLyogRW5hYmxlIFNTQyBvbiBQQ0ggZURQIGlmIG5lZWRlZCAqLwotCQkJCWlmIChkZXZfcHJpdi0+bHZkc191c2Vfc3NjKSB7CisJCQkJaWYgKGludGVsX3BhbmVsX3VzZV9zc2MoZGV2X3ByaXYpKSB7CiAJCQkJCURSTV9FUlJPUigiZW5hYmxpbmcgU1NDIG9uIFBDSFxuIik7CiAJCQkJCXRlbXAgfD0gRFJFRl9TVVBFUlNQUkVBRF9TT1VSQ0VfRU5BQkxFOwogCQkJCX0KQEAgLTQxMDQsNyArNDEzMCw3IEBACiAJCWludCBmYWN0b3IgPSAyMTsKIAogCQlpZiAoaXNfbHZkcykgewotCQkJaWYgKChkZXZfcHJpdi0+bHZkc191c2Vfc3NjICYmCisJCQlpZiAoKGludGVsX3BhbmVsX3VzZV9zc2MoZGV2X3ByaXYpICYmCiAJCQkgICAgIGRldl9wcml2LT5sdmRzX3NzY19mcmVxID09IDEwMCkgfHwKIAkJCSAgICAoSTkxNV9SRUFEKFBDSF9MVkRTKSAmIExWRFNfQ0xLQl9QT1dFUl9NQVNLKSA9PSBMVkRTX0NMS0JfUE9XRVJfVVApCiAJCQkJZmFjdG9yID0gMjU7CkBAIC00MTgzLDcgKzQyMDksNyBAQAogCQkvKiBYWFg6IGp1c3QgbWF0Y2hpbmcgQklPUyBmb3Igbm93ICovCiAJCS8qCWRwbGwgfD0gUExMX1JFRl9JTlBVVF9UVkNMS0lOQkM7ICovCiAJCWRwbGwgfD0gMzsKLQllbHNlIGlmIChpc19sdmRzICYmIGRldl9wcml2LT5sdmRzX3VzZV9zc2MgJiYgbnVtX2Nvbm5lY3RvcnMgPCAyKQorCWVsc2UgaWYgKGlzX2x2ZHMgJiYgaW50ZWxfcGFuZWxfdXNlX3NzYyhkZXZfcHJpdikgJiYgbnVtX2Nvbm5lY3RvcnMgPCAyKQogCQlkcGxsIHw9IFBMTEJfUkVGX0lOUFVUX1NQUkVBRFNQRUNUUlVNSU47CiAJZWxzZQogCQlkcGxsIHw9IFBMTF9SRUZfSU5QVVRfRFJFRkNMSzsKQEAgLTU1MjUsNiArNTU1MSwxOCBAQAogCXJldHVybiByZXQ7CiB9CiAKK3N0YXRpYyB2b2lkIGludGVsX2NydGNfcmVzZXQoc3RydWN0IGRybV9jcnRjICpjcnRjKQoreworCXN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjID0gdG9faW50ZWxfY3J0YyhjcnRjKTsKKworCS8qIFJlc2V0IGZsYWdzIGJhY2sgdG8gdGhlICd1bmtub3duJyBzdGF0dXMgc28gdGhhdCB0aGV5CisJICogd2lsbCBiZSBjb3JyZWN0bHkgc2V0IG9uIHRoZSBpbml0aWFsIG1vZGVzZXQuCisJICovCisJaW50ZWxfY3J0Yy0+Y3Vyc29yX2FkZHIgPSAwOworCWludGVsX2NydGMtPmRwbXNfbW9kZSA9IC0xOworCWludGVsX2NydGMtPmFjdGl2ZSA9IHRydWU7IC8qIGZvcmNlIHRoZSBwaXBlIG9mZiBvbiBzZXR1cF9pbml0X2NvbmZpZyAqLworfQorCiBzdGF0aWMgc3RydWN0IGRybV9jcnRjX2hlbHBlcl9mdW5jcyBpbnRlbF9oZWxwZXJfZnVuY3MgPSB7CiAJLmRwbXMgPSBpbnRlbF9jcnRjX2RwbXMsCiAJLm1vZGVfZml4dXAgPSBpbnRlbF9jcnRjX21vZGVfZml4dXAsCkBAIC01NTM2LDYgKzU1NzQsNyBAQAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fY3J0Y19mdW5jcyBpbnRlbF9jcnRjX2Z1bmNzID0geworCS5yZXNldCA9IGludGVsX2NydGNfcmVzZXQsCiAJLmN1cnNvcl9zZXQgPSBpbnRlbF9jcnRjX2N1cnNvcl9zZXQsCiAJLmN1cnNvcl9tb3ZlID0gaW50ZWxfY3J0Y19jdXJzb3JfbW92ZSwKIAkuZ2FtbWFfc2V0ID0gaW50ZWxfY3J0Y19nYW1tYV9zZXQsCkBAIC01NjI2LDkgKzU2NjUsNyBAQAogCWRldl9wcml2LT5wbGFuZV90b19jcnRjX21hcHBpbmdbaW50ZWxfY3J0Yy0+cGxhbmVdID0gJmludGVsX2NydGMtPmJhc2U7CiAJZGV2X3ByaXYtPnBpcGVfdG9fY3J0Y19tYXBwaW5nW2ludGVsX2NydGMtPnBpcGVdID0gJmludGVsX2NydGMtPmJhc2U7CiAKLQlpbnRlbF9jcnRjLT5jdXJzb3JfYWRkciA9IDA7Ci0JaW50ZWxfY3J0Yy0+ZHBtc19tb2RlID0gLTE7Ci0JaW50ZWxfY3J0Yy0+YWN0aXZlID0gdHJ1ZTsgLyogZm9yY2UgdGhlIHBpcGUgb2ZmIG9uIHNldHVwX2luaXRfY29uZmlnICovCisJaW50ZWxfY3J0Y19yZXNldCgmaW50ZWxfY3J0Yy0+YmFzZSk7CiAKIAlpZiAoSEFTX1BDSF9TUExJVChkZXYpKSB7CiAJCWludGVsX2hlbHBlcl9mdW5jcy5wcmVwYXJlID0gaXJvbmxha2VfY3J0Y19wcmVwYXJlOwpAQCAtNjI4MSw3ICs2MzE4LDkgQEAKIAogCQlpZiAoSVNfR0VONShkZXYpKSB7CiAJCQkvKiBSZXF1aXJlZCBmb3IgRkJDICovCi0JCQlkc3BjbGtfZ2F0ZSB8PSBEUEZEVU5JVF9DTE9DS19HQVRFX0RJU0FCTEU7CisJCQlkc3BjbGtfZ2F0ZSB8PSBEUEZDVU5JVF9DTE9DS19HQVRFX0RJU0FCTEUgfAorCQkJCURQRkNSVU5JVF9DTE9DS19HQVRFX0RJU0FCTEUgfAorCQkJCURQRkRVTklUX0NMT0NLX0dBVEVfRElTQUJMRTsKIAkJCS8qIFJlcXVpcmVkIGZvciBDeFNSICovCiAJCQlkc3BjbGtfZ2F0ZSB8PSBEUEFSQlVOSVRfQ0xPQ0tfR0FURV9ESVNBQkxFOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9mYi5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZmIuYwppbmRleCBlZTE0NWEyLi41MTI3ODI3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9mYi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2ZiLmMKQEAgLTE0OCw2ICsxNDgsNyBAQAogCiAvLwltZW1zZXQoaW5mby0+c2NyZWVuX2Jhc2UsIDAsIHNpemUpOwogCisJZHJtX2ZiX2hlbHBlcl9maWxsX2ZpeChpbmZvLCBmYi0+cGl0Y2gsIGZiLT5kZXB0aCk7CiAJZHJtX2ZiX2hlbHBlcl9maWxsX3ZhcihpbmZvLCAmaWZiZGV2LT5oZWxwZXIsIHNpemVzLT5mYl93aWR0aCwgc2l6ZXMtPmZiX2hlaWdodCk7CiAKIAlpbmZvLT5waXhtYXAuc2l6ZSA9IDY0KjEwMjQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9sdmRzLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9sdmRzLmMKaW5kZXggOGY0ZjZiZC4uYWNlOGQ1ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfbHZkcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2x2ZHMuYwpAQCAtNzA0LDYgKzcwNCwxNCBAQAogCX0sCiAJewogCQkuY2FsbGJhY2sgPSBpbnRlbF9ub19sdmRzX2RtaV9jYWxsYmFjaywKKwkJLmlkZW50ID0gIkFPcGVuIGk5MTVHTW0tSEZTIiwKKwkJLm1hdGNoZXMgPSB7CisJCQlETUlfTUFUQ0goRE1JX0JPQVJEX1ZFTkRPUiwgIkFPcGVuIiksCisJCQlETUlfTUFUQ0goRE1JX0JPQVJEX05BTUUsICJpOTE1R01tLUhGUyIpLAorCQl9LAorCX0sCisJeworCQkuY2FsbGJhY2sgPSBpbnRlbF9ub19sdmRzX2RtaV9jYWxsYmFjaywKIAkJLmlkZW50ID0gIkFvcGVuIGk5NDVHVHQtVkZBIiwKIAkJLm1hdGNoZXMgPSB7CiAJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfVkVSU0lPTiwgIkFPMDAwMDFKVyIpLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfb3ByZWdpb24uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX29wcmVnaW9uLmMKaW5kZXggZjI5NWE3YS4uNjRmZDY0NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfb3ByZWdpb24uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9vcHJlZ2lvbi5jCkBAIC0yNiw2ICsyNiw3IEBACiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2FjcGkuaD4KKyNpbmNsdWRlIDxsaW51eC9hY3BpX2lvLmg+CiAjaW5jbHVkZSA8YWNwaS92aWRlby5oPgogCiAjaW5jbHVkZSAiZHJtUC5oIgpAQCAtNDc2LDcgKzQ3Nyw3IEBACiAJCXJldHVybiAtRU5PVFNVUFA7CiAJfQogCi0JYmFzZSA9IGlvcmVtYXAoYXNscywgT1BSRUdJT05fU0laRSk7CisJYmFzZSA9IGFjcGlfb3NfaW9yZW1hcChhc2xzLCBPUFJFR0lPTl9TSVpFKTsKIAlpZiAoIWJhc2UpCiAJCXJldHVybiAtRU5PTUVNOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wYW5lbC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFuZWwuYwppbmRleCBlMDBkMjAwLi5jNjU5OTJkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wYW5lbC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BhbmVsLmMKQEAgLTI3OCw2ICsyNzgsNiBAQAogewogCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7CiAKLQlkZXZfcHJpdi0+YmFja2xpZ2h0X2xldmVsID0gaW50ZWxfcGFuZWxfZ2V0X21heF9iYWNrbGlnaHQoZGV2KTsKKwlkZXZfcHJpdi0+YmFja2xpZ2h0X2xldmVsID0gaW50ZWxfcGFuZWxfZ2V0X2JhY2tsaWdodChkZXYpOwogCWRldl9wcml2LT5iYWNrbGlnaHRfZW5hYmxlZCA9IGRldl9wcml2LT5iYWNrbGlnaHRfbGV2ZWwgIT0gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JpbmdidWZmZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JpbmdidWZmZXIuYwppbmRleCAwM2UzMzcwLi42MjE4ZmE5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9yaW5nYnVmZmVyLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmluZ2J1ZmZlci5jCkBAIC0zNCw2ICszNCwxNCBAQAogI2luY2x1ZGUgImk5MTVfdHJhY2UuaCIKICNpbmNsdWRlICJpbnRlbF9kcnYuaCIKIAorc3RhdGljIGlubGluZSBpbnQgcmluZ19zcGFjZShzdHJ1Y3QgaW50ZWxfcmluZ19idWZmZXIgKnJpbmcpCit7CisJaW50IHNwYWNlID0gKHJpbmctPmhlYWQgJiBIRUFEX0FERFIpIC0gKHJpbmctPnRhaWwgKyA4KTsKKwlpZiAoc3BhY2UgPCAwKQorCQlzcGFjZSArPSByaW5nLT5zaXplOworCXJldHVybiBzcGFjZTsKK30KKwogc3RhdGljIHUzMiBpOTE1X2dlbV9nZXRfc2Vxbm8oc3RydWN0IGRybV9kZXZpY2UgKmRldikKIHsKIAlkcm1faTkxNV9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKQEAgLTIwNCwxMSArMjEyLDkgQEAKIAlpZiAoIWRybV9jb3JlX2NoZWNrX2ZlYXR1cmUocmluZy0+ZGV2LCBEUklWRVJfTU9ERVNFVCkpCiAJCWk5MTVfa2VybmVsX2xvc3RfY29udGV4dChyaW5nLT5kZXYpOwogCWVsc2UgewotCQlyaW5nLT5oZWFkID0gSTkxNV9SRUFEX0hFQUQocmluZykgJiBIRUFEX0FERFI7CisJCXJpbmctPmhlYWQgPSBJOTE1X1JFQURfSEVBRChyaW5nKTsKIAkJcmluZy0+dGFpbCA9IEk5MTVfUkVBRF9UQUlMKHJpbmcpICYgVEFJTF9BRERSOwotCQlyaW5nLT5zcGFjZSA9IHJpbmctPmhlYWQgLSAocmluZy0+dGFpbCArIDgpOwotCQlpZiAocmluZy0+c3BhY2UgPCAwKQotCQkJcmluZy0+c3BhY2UgKz0gcmluZy0+c2l6ZTsKKwkJcmluZy0+c3BhY2UgPSByaW5nX3NwYWNlKHJpbmcpOwogCX0KIAogCXJldHVybiAwOwpAQCAtOTIxLDcgKzkyNyw3IEBACiAJfQogCiAJcmluZy0+dGFpbCA9IDA7Ci0JcmluZy0+c3BhY2UgPSByaW5nLT5oZWFkIC0gODsKKwlyaW5nLT5zcGFjZSA9IHJpbmdfc3BhY2UocmluZyk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTkzMywyMCArOTM5LDIyIEBACiAJdW5zaWduZWQgbG9uZyBlbmQ7CiAJdTMyIGhlYWQ7CiAKKwkvKiBJZiB0aGUgcmVwb3J0ZWQgaGVhZCBwb3NpdGlvbiBoYXMgd3JhcHBlZCBvciBoYXNuJ3QgYWR2YW5jZWQsCisJICogZmFsbGJhY2sgdG8gdGhlIHNsb3cgYW5kIGFjY3VyYXRlIHBhdGguCisJICovCisJaGVhZCA9IGludGVsX3JlYWRfc3RhdHVzX3BhZ2UocmluZywgNCk7CisJaWYgKGhlYWQgPiByaW5nLT5oZWFkKSB7CisJCXJpbmctPmhlYWQgPSBoZWFkOworCQlyaW5nLT5zcGFjZSA9IHJpbmdfc3BhY2UocmluZyk7CisJCWlmIChyaW5nLT5zcGFjZSA+PSBuKQorCQkJcmV0dXJuIDA7CisJfQorCiAJdHJhY2VfaTkxNV9yaW5nX3dhaXRfYmVnaW4gKGRldik7CiAJZW5kID0gamlmZmllcyArIDMgKiBIWjsKIAlkbyB7Ci0JCS8qIElmIHRoZSByZXBvcnRlZCBoZWFkIHBvc2l0aW9uIGhhcyB3cmFwcGVkIG9yIGhhc24ndCBhZHZhbmNlZCwKLQkJICogZmFsbGJhY2sgdG8gdGhlIHNsb3cgYW5kIGFjY3VyYXRlIHBhdGguCi0JCSAqLwotCQloZWFkID0gaW50ZWxfcmVhZF9zdGF0dXNfcGFnZShyaW5nLCA0KTsKLQkJaWYgKGhlYWQgPCByaW5nLT5hY3R1YWxfaGVhZCkKLQkJCWhlYWQgPSBJOTE1X1JFQURfSEVBRChyaW5nKTsKLQkJcmluZy0+YWN0dWFsX2hlYWQgPSBoZWFkOwotCQlyaW5nLT5oZWFkID0gaGVhZCAmIEhFQURfQUREUjsKLQkJcmluZy0+c3BhY2UgPSByaW5nLT5oZWFkIC0gKHJpbmctPnRhaWwgKyA4KTsKLQkJaWYgKHJpbmctPnNwYWNlIDwgMCkKLQkJCXJpbmctPnNwYWNlICs9IHJpbmctPnNpemU7CisJCXJpbmctPmhlYWQgPSBJOTE1X1JFQURfSEVBRChyaW5nKTsKKwkJcmluZy0+c3BhY2UgPSByaW5nX3NwYWNlKHJpbmcpOwogCQlpZiAocmluZy0+c3BhY2UgPj0gbikgewogCQkJdHJhY2VfaTkxNV9yaW5nX3dhaXRfZW5kKGRldik7CiAJCQlyZXR1cm4gMDsKQEAgLTEyOTEsNiArMTI5OSw0OCBAQAogCXJldHVybiBpbnRlbF9pbml0X3JpbmdfYnVmZmVyKGRldiwgcmluZyk7CiB9CiAKK2ludCBpbnRlbF9yZW5kZXJfcmluZ19pbml0X2RyaShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB1NjQgc3RhcnQsIHUzMiBzaXplKQoreworCWRybV9pOTE1X3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOworCXN0cnVjdCBpbnRlbF9yaW5nX2J1ZmZlciAqcmluZyA9ICZkZXZfcHJpdi0+cmluZ1tSQ1NdOworCisJKnJpbmcgPSByZW5kZXJfcmluZzsKKwlpZiAoSU5URUxfSU5GTyhkZXYpLT5nZW4gPj0gNikgeworCQlyaW5nLT5hZGRfcmVxdWVzdCA9IGdlbjZfYWRkX3JlcXVlc3Q7CisJCXJpbmctPmlycV9nZXQgPSBnZW42X3JlbmRlcl9yaW5nX2dldF9pcnE7CisJCXJpbmctPmlycV9wdXQgPSBnZW42X3JlbmRlcl9yaW5nX3B1dF9pcnE7CisJfSBlbHNlIGlmIChJU19HRU41KGRldikpIHsKKwkJcmluZy0+YWRkX3JlcXVlc3QgPSBwY19yZW5kZXJfYWRkX3JlcXVlc3Q7CisJCXJpbmctPmdldF9zZXFubyA9IHBjX3JlbmRlcl9nZXRfc2Vxbm87CisJfQorCisJcmluZy0+ZGV2ID0gZGV2OworCUlOSVRfTElTVF9IRUFEKCZyaW5nLT5hY3RpdmVfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJnJpbmctPnJlcXVlc3RfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJnJpbmctPmdwdV93cml0ZV9saXN0KTsKKworCXJpbmctPnNpemUgPSBzaXplOworCXJpbmctPmVmZmVjdGl2ZV9zaXplID0gcmluZy0+c2l6ZTsKKwlpZiAoSVNfSTgzMChyaW5nLT5kZXYpKQorCQlyaW5nLT5lZmZlY3RpdmVfc2l6ZSAtPSAxMjg7CisKKwlyaW5nLT5tYXAub2Zmc2V0ID0gc3RhcnQ7CisJcmluZy0+bWFwLnNpemUgPSBzaXplOworCXJpbmctPm1hcC50eXBlID0gMDsKKwlyaW5nLT5tYXAuZmxhZ3MgPSAwOworCXJpbmctPm1hcC5tdHJyID0gMDsKKworCWRybV9jb3JlX2lvcmVtYXBfd2MoJnJpbmctPm1hcCwgZGV2KTsKKwlpZiAocmluZy0+bWFwLmhhbmRsZSA9PSBOVUxMKSB7CisJCURSTV9FUlJPUigiY2FuIG5vdCBpb3JlbWFwIHZpcnR1YWwgYWRkcmVzcyBmb3IiCisJCQkgICIgcmluZyBidWZmZXJcbiIpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwlyaW5nLT52aXJ0dWFsX3N0YXJ0ID0gKHZvaWQgX19mb3JjZSBfX2lvbWVtICopcmluZy0+bWFwLmhhbmRsZTsKKwlyZXR1cm4gMDsKK30KKwogaW50IGludGVsX2luaXRfYnNkX3JpbmdfYnVmZmVyKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiB7CiAJZHJtX2k5MTVfcHJpdmF0ZV90ICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9yaW5nYnVmZmVyLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9yaW5nYnVmZmVyLmgKaW5kZXggYmU5MDg3ZS4uNmQ2ZmRlOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcmluZ2J1ZmZlci5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JpbmdidWZmZXIuaApAQCAtNDcsNyArNDcsNiBAQAogCXN0cnVjdAkJZHJtX2RldmljZSAqZGV2OwogCXN0cnVjdAkJZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqOwogCi0JdTMyCQlhY3R1YWxfaGVhZDsKIAl1MzIJCWhlYWQ7CiAJdTMyCQl0YWlsOwogCWludAkJc3BhY2U7CkBAIC0xNjcsNCArMTY2LDcgQEAKIHUzMiBpbnRlbF9yaW5nX2dldF9hY3RpdmVfaGVhZChzdHJ1Y3QgaW50ZWxfcmluZ19idWZmZXIgKnJpbmcpOwogdm9pZCBpbnRlbF9yaW5nX3NldHVwX3N0YXR1c19wYWdlKHN0cnVjdCBpbnRlbF9yaW5nX2J1ZmZlciAqcmluZyk7CiAKKy8qIERSSSB3YXJ0cyAqLworaW50IGludGVsX3JlbmRlcl9yaW5nX2luaXRfZHJpKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHU2NCBzdGFydCwgdTMyIHNpemUpOworCiAjZW5kaWYgLyogX0lOVEVMX1JJTkdCVUZGRVJfSF8gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Nkdm8uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Nkdm8uYwppbmRleCA0NWNkMzc2Li42YTA5YzE0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9zZHZvLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfc2R2by5jCkBAIC00NzMsMjAgKzQ3Myw2IEBACiAJCXJldHVybiBmYWxzZTsKIAl9CiAKLQlpID0gMzsKLQl3aGlsZSAoc3RhdHVzID09IFNEVk9fQ01EX1NUQVRVU19QRU5ESU5HICYmIGktLSkgewotCQlpZiAoIWludGVsX3Nkdm9fcmVhZF9ieXRlKGludGVsX3Nkdm8sCi0JCQkJCSAgU0RWT19JMkNfQ01EX1NUQVRVUywKLQkJCQkJICAmc3RhdHVzKSkKLQkJCXJldHVybiBmYWxzZTsKLQl9Ci0JaWYgKHN0YXR1cyAhPSBTRFZPX0NNRF9TVEFUVVNfU1VDQ0VTUykgewotCQlEUk1fREVCVUdfS01TKCJjb21tYW5kIHJldHVybnMgcmVzcG9uc2UgJXMgWyVkXVxuIiwKLQkJCSAgICAgIHN0YXR1cyA8PSBTRFZPX0NNRF9TVEFUVVNfU0NBTElOR19OT1RfU1VQUCA/IGNtZF9zdGF0dXNfbmFtZXNbc3RhdHVzXSA6ICI/Pz8iLAotCQkJICAgICAgc3RhdHVzKTsKLQkJcmV0dXJuIGZhbHNlOwotCX0KLQogCXJldHVybiB0cnVlOwogfQogCkBAIC00OTcsNiArNDgzLDggQEAKIAl1OCBzdGF0dXM7CiAJaW50IGk7CiAKKwlEUk1fREVCVUdfS01TKCIlczogUjogIiwgU0RWT19OQU1FKGludGVsX3Nkdm8pKTsKKwogCS8qCiAJICogVGhlIGRvY3VtZW50YXRpb24gc3RhdGVzIHRoYXQgYWxsIGNvbW1hbmRzIHdpbGwgYmUKIAkgKiBwcm9jZXNzZWQgd2l0aGluIDE1wrVzLCBhbmQgdGhhdCB3ZSBuZWVkIG9ubHkgcG9sbApAQCAtNTA1LDE0ICs0OTMsMTkgQEAKIAkgKgogCSAqIENoZWNrIDUgdGltZXMgaW4gY2FzZSB0aGUgaGFyZHdhcmUgZmFpbGVkIHRvIHJlYWQgdGhlIGRvY3MuCiAJICovCi0JZG8geworCWlmICghaW50ZWxfc2R2b19yZWFkX2J5dGUoaW50ZWxfc2R2bywKKwkJCQkgIFNEVk9fSTJDX0NNRF9TVEFUVVMsCisJCQkJICAmc3RhdHVzKSkKKwkJZ290byBsb2dfZmFpbDsKKworCXdoaWxlIChzdGF0dXMgPT0gU0RWT19DTURfU1RBVFVTX1BFTkRJTkcgJiYgcmV0cnktLSkgeworCQl1ZGVsYXkoMTUpOwogCQlpZiAoIWludGVsX3Nkdm9fcmVhZF9ieXRlKGludGVsX3Nkdm8sCiAJCQkJCSAgU0RWT19JMkNfQ01EX1NUQVRVUywKIAkJCQkJICAmc3RhdHVzKSkKLQkJCXJldHVybiBmYWxzZTsKLQl9IHdoaWxlIChzdGF0dXMgPT0gU0RWT19DTURfU1RBVFVTX1BFTkRJTkcgJiYgLS1yZXRyeSk7CisJCQlnb3RvIGxvZ19mYWlsOworCX0KIAotCURSTV9ERUJVR19LTVMoIiVzOiBSOiAiLCBTRFZPX05BTUUoaW50ZWxfc2R2bykpOwogCWlmIChzdGF0dXMgPD0gU0RWT19DTURfU1RBVFVTX1NDQUxJTkdfTk9UX1NVUFApCiAJCURSTV9MT0dfS01TKCIoJXMpIiwgY21kX3N0YXR1c19uYW1lc1tzdGF0dXNdKTsKIAllbHNlCkBAIC01MzMsNyArNTI2LDcgQEAKIAlyZXR1cm4gdHJ1ZTsKIAogbG9nX2ZhaWw6Ci0JRFJNX0xPR19LTVMoIlxuIik7CisJRFJNX0xPR19LTVMoIi4uLiBmYWlsZWRcbiIpOwogCXJldHVybiBmYWxzZTsKIH0KIApAQCAtNTUwLDYgKzU0Myw3IEBACiBzdGF0aWMgYm9vbCBpbnRlbF9zZHZvX3NldF9jb250cm9sX2J1c19zd2l0Y2goc3RydWN0IGludGVsX3Nkdm8gKmludGVsX3Nkdm8sCiAJCQkJCSAgICAgIHU4IGRkY19idXMpCiB7CisJLyogVGhpcyBtdXN0IGJlIHRoZSBpbW1lZGlhdGVseSBwcmVjZWRpbmcgd3JpdGUgYmVmb3JlIHRoZSBpMmMgeGZlciAqLwogCXJldHVybiBpbnRlbF9zZHZvX3dyaXRlX2NtZChpbnRlbF9zZHZvLAogCQkJCSAgICBTRFZPX0NNRF9TRVRfQ09OVFJPTF9CVVNfU1dJVENILAogCQkJCSAgICAmZGRjX2J1cywgMSk7CkBAIC01NTcsNyArNTUxLDEwIEBACiAKIHN0YXRpYyBib29sIGludGVsX3Nkdm9fc2V0X3ZhbHVlKHN0cnVjdCBpbnRlbF9zZHZvICppbnRlbF9zZHZvLCB1OCBjbWQsIGNvbnN0IHZvaWQgKmRhdGEsIGludCBsZW4pCiB7Ci0JcmV0dXJuIGludGVsX3Nkdm9fd3JpdGVfY21kKGludGVsX3Nkdm8sIGNtZCwgZGF0YSwgbGVuKTsKKwlpZiAoIWludGVsX3Nkdm9fd3JpdGVfY21kKGludGVsX3Nkdm8sIGNtZCwgZGF0YSwgbGVuKSkKKwkJcmV0dXJuIGZhbHNlOworCisJcmV0dXJuIGludGVsX3Nkdm9fcmVhZF9yZXNwb25zZShpbnRlbF9zZHZvLCBOVUxMLCAwKTsKIH0KIAogc3RhdGljIGJvb2wKQEAgLTg1OSwxOCArODU2LDIxIEBACiAKIAlpbnRlbF9kaXBfaW5mb2ZyYW1lX2NzdW0oJmF2aV9pZik7CiAKLQlpZiAoIWludGVsX3Nkdm9fd3JpdGVfY21kKGludGVsX3Nkdm8sIFNEVk9fQ01EX1NFVF9IQlVGX0lOREVYLAorCWlmICghaW50ZWxfc2R2b19zZXRfdmFsdWUoaW50ZWxfc2R2bywKKwkJCQkgIFNEVk9fQ01EX1NFVF9IQlVGX0lOREVYLAogCQkJCSAgc2V0X2J1Zl9pbmRleCwgMikpCiAJCXJldHVybiBmYWxzZTsKIAogCWZvciAoaSA9IDA7IGkgPCBzaXplb2YoYXZpX2lmKTsgaSArPSA4KSB7Ci0JCWlmICghaW50ZWxfc2R2b193cml0ZV9jbWQoaW50ZWxfc2R2bywgU0RWT19DTURfU0VUX0hCVUZfREFUQSwKKwkJaWYgKCFpbnRlbF9zZHZvX3NldF92YWx1ZShpbnRlbF9zZHZvLAorCQkJCQkgIFNEVk9fQ01EX1NFVF9IQlVGX0RBVEEsCiAJCQkJCSAgZGF0YSwgOCkpCiAJCQlyZXR1cm4gZmFsc2U7CiAJCWRhdGErKzsKIAl9CiAKLQlyZXR1cm4gaW50ZWxfc2R2b193cml0ZV9jbWQoaW50ZWxfc2R2bywgU0RWT19DTURfU0VUX0hCVUZfVFhSQVRFLAorCXJldHVybiBpbnRlbF9zZHZvX3NldF92YWx1ZShpbnRlbF9zZHZvLAorCQkJCSAgICBTRFZPX0NNRF9TRVRfSEJVRl9UWFJBVEUsCiAJCQkJICAgICZ0eF9yYXRlLCAxKTsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvS2NvbmZpZyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L0tjb25maWcKaW5kZXggMjFkNmMyOS4uZGU3MDk1OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvS2NvbmZpZworKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9LY29uZmlnCkBAIC04LDcgKzgsNyBAQAogCXNlbGVjdCBGQl9DRkJfQ09QWUFSRUEKIAlzZWxlY3QgRkJfQ0ZCX0lNQUdFQkxJVAogCXNlbGVjdCBGQgotCXNlbGVjdCBGUkFNRUJVRkZFUl9DT05TT0xFIGlmICFFTUJFRERFRAorCXNlbGVjdCBGUkFNRUJVRkZFUl9DT05TT0xFIGlmICFFWFBFUlQKIAlzZWxlY3QgRkJfQkFDS0xJR0hUIGlmIERSTV9OT1VWRUFVX0JBQ0tMSUdIVAogCXNlbGVjdCBBQ1BJX1ZJREVPIGlmIEFDUEkgJiYgWDg2ICYmIEJBQ0tMSUdIVF9DTEFTU19ERVZJQ0UgJiYgVklERU9fT1VUUFVUX0NPTlRST0wgJiYgSU5QVVQKIAloZWxwCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2Jpb3MuYyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfYmlvcy5jCmluZGV4IDJhZWY1Y2QuLjQ5ZTVlOTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfYmlvcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfYmlvcy5jCkBAIC02MzEwLDYgKzYzMTAsOSBAQAogc3RhdGljIGJvb2wKIGFwcGx5X2RjYl9lbmNvZGVyX3F1aXJrcyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBpbnQgaWR4LCB1MzIgKmNvbm4sIHUzMiAqY29uZikKIHsKKwlzdHJ1Y3QgZHJtX25vdXZlYXVfcHJpdmF0ZSAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOworCXN0cnVjdCBkY2JfdGFibGUgKmRjYiA9ICZkZXZfcHJpdi0+dmJpb3MuZGNiOworCiAJLyogRGVsbCBQcmVjaXNpb24gTTYzMDAKIAkgKiAgIERDQiBlbnRyeSAyOiAwMjAyNTMxMiAwMDAwMDAxMAogCSAqICAgRENCIGVudHJ5IDM6IDAyMDI2MzEyIDAwMDAwMDIwCkBAIC02MzI3LDYgKzYzMzAsMTggQEAKIAkJCXJldHVybiBmYWxzZTsKIAl9CiAKKwkvKiBHZUZvcmNlMyBUaSAyMDAKKwkgKgorCSAqIERDQiByZXBvcnRzIGFuIExWRFMgb3V0cHV0IHRoYXQgc2hvdWxkIGJlIFRNRFM6CisJICogICBEQ0IgZW50cnkgMTogZjIwMDUwMTQgZmZmZmZmZmYKKwkgKi8KKwlpZiAobnZfbWF0Y2hfZGV2aWNlKGRldiwgMHgwMjAxLCAweDE0NjIsIDB4ODg1MSkpIHsKKwkJaWYgKCpjb25uID09IDB4ZjIwMDUwMTQgJiYgKmNvbmYgPT0gMHhmZmZmZmZmZikgeworCQkJZmFicmljYXRlX2RjYl9vdXRwdXQoZGNiLCBPVVRQVVRfVE1EUywgMSwgMSwgMSk7CisJCQlyZXR1cm4gZmFsc2U7CisJCX0KKwl9CisKIAlyZXR1cm4gdHJ1ZTsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9kcnYuYyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfZHJ2LmMKaW5kZXggMTNiYjY3Mi4uZjY1OGEwNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9kcnYuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2Rydi5jCkBAIC0yMzQsOSArMjM0LDkgQEAKIAkJcGNpX3NldF9wb3dlcl9zdGF0ZShwZGV2LCBQQ0lfRDNob3QpOwogCX0KIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlub3V2ZWF1X2ZiY29uX3NldF9zdXNwZW5kKGRldiwgMSk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJbm91dmVhdV9mYmNvbl9yZXN0b3JlX2FjY2VsKGRldik7CiAJcmV0dXJuIDA7CiAKQEAgLTM1OSw5ICszNTksOSBAQAogCQludl9jcnRjLT5sdXQuZGVwdGggPSAwOwogCX0KIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlub3V2ZWF1X2ZiY29uX3NldF9zdXNwZW5kKGRldiwgMCk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAlub3V2ZWF1X2ZiY29uX3pmaWxsX2FsbChkZXYpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2Rydi5oIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9kcnYuaAppbmRleCA0NmUzMjU3Li45ODIxZmNhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2Rydi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfZHJ2LmgKQEAgLTE2MCw2ICsxNjAsNyBAQAogI2RlZmluZSBOVk9CSl9GTEFHX1pFUk9fQUxMT0MJCSgxIDw8IDEpCiAjZGVmaW5lIE5WT0JKX0ZMQUdfWkVST19GUkVFCQkoMSA8PCAyKQogI2RlZmluZSBOVk9CSl9GTEFHX1ZNCQkJKDEgPDwgMykKKyNkZWZpbmUgTlZPQkpfRkxBR19WTV9VU0VSCQkoMSA8PCA0KQogCiAjZGVmaW5lIE5WT0JKX0NJTlNUX0dMT0JBTAkweGRlYWRiZWVmCiAKQEAgLTg0Nyw5ICs4NDgsNiBAQAogCQkJCSAgICAgc3RydWN0IG5vdXZlYXVfZmVuY2UgKmZlbmNlKTsKIGV4dGVybiBjb25zdCBzdHJ1Y3QgdHRtX21lbV90eXBlX21hbmFnZXJfZnVuYyBub3V2ZWF1X3ZyYW1fbWFuYWdlcjsKIAotLyogbnZjMF92cmFtLmMgKi8KLWV4dGVybiBjb25zdCBzdHJ1Y3QgdHRtX21lbV90eXBlX21hbmFnZXJfZnVuYyBudmMwX3ZyYW1fbWFuYWdlcjsKLQogLyogbm91dmVhdV9ub3RpZmllci5jICovCiBleHRlcm4gaW50ICBub3V2ZWF1X25vdGlmaWVyX2luaXRfY2hhbm5lbChzdHJ1Y3Qgbm91dmVhdV9jaGFubmVsICopOwogZXh0ZXJuIHZvaWQgbm91dmVhdV9ub3RpZmllcl90YWtlZG93bl9jaGFubmVsKHN0cnVjdCBub3V2ZWF1X2NoYW5uZWwgKik7CkBAIC0xNTc2LDYgKzE1NzQsMjAgQEAKIAkJZGV2LT5wZGV2LT5zdWJzeXN0ZW1fZGV2aWNlID09IHN1Yl9kZXZpY2U7CiB9CiAKKy8qIHJldHVybnMgMSBpZiBkZXZpY2UgaXMgb25lIG9mIHRoZSBudjR4IHVzaW5nIHRoZSAweDQ0OTcgb2JqZWN0IGNsYXNzLAorICogaGVscGZ1bCB0byBkZXRlcm1pbmUgYSBudW1iZXIgb2Ygb3RoZXIgaGFyZHdhcmUgZmVhdHVyZXMKKyAqLworc3RhdGljIGlubGluZSBpbnQKK252NDRfZ3JhcGhfY2xhc3Moc3RydWN0IGRybV9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgZHJtX25vdXZlYXVfcHJpdmF0ZSAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOworCisJaWYgKChkZXZfcHJpdi0+Y2hpcHNldCAmIDB4ZjApID09IDB4NjApCisJCXJldHVybiAxOworCisJcmV0dXJuICEoMHgwYmFmICYgKDEgPDwgKGRldl9wcml2LT5jaGlwc2V0ICYgMHgwZikpKTsKK30KKwogLyogbWVtb3J5IHR5cGUvYWNjZXNzIGZsYWdzLCBkbyBub3QgbWF0Y2ggaGFyZHdhcmUgdmFsdWVzICovCiAjZGVmaW5lIE5WX01FTV9BQ0NFU1NfUk8gIDEKICNkZWZpbmUgTlZfTUVNX0FDQ0VTU19XTyAgMgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9mYmNvbi5jIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9mYmNvbi5jCmluZGV4IGEyNmQwNDcuLjYwNzY5ZDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfZmJjb24uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X2ZiY29uLmMKQEAgLTM1MiwxMyArMzUyLDE0IEBACiAJCQkgICAgICBGQklORk9fSFdBQ0NFTF9JTUFHRUJMSVQ7CiAJaW5mby0+ZmxhZ3MgfD0gRkJJTkZPX0NBTl9GT1JDRV9PVVRQVVQ7CiAJaW5mby0+ZmJvcHMgPSAmbm91dmVhdV9mYmNvbl9zd19vcHM7Ci0JaW5mby0+Zml4LnNtZW1fc3RhcnQgPSBkZXYtPm1vZGVfY29uZmlnLmZiX2Jhc2UgKwotCQkJICAgICAgIChudmJvLT5iby5tZW0uc3RhcnQgPDwgUEFHRV9TSElGVCk7CisJaW5mby0+Zml4LnNtZW1fc3RhcnQgPSBudmJvLT5iby5tZW0uYnVzLmJhc2UgKworCQkJICAgICAgIG52Ym8tPmJvLm1lbS5idXMub2Zmc2V0OwogCWluZm8tPmZpeC5zbWVtX2xlbiA9IHNpemU7CiAKIAlpbmZvLT5zY3JlZW5fYmFzZSA9IG52Ym9fa21hcF9vYmpfaW92aXJ0dWFsKG5vdXZlYXVfZmItPm52Ym8pOwogCWluZm8tPnNjcmVlbl9zaXplID0gc2l6ZTsKIAorCWRybV9mYl9oZWxwZXJfZmlsbF9maXgoaW5mbywgZmItPnBpdGNoLCBmYi0+ZGVwdGgpOwogCWRybV9mYl9oZWxwZXJfZmlsbF92YXIoaW5mbywgJm5mYmRldi0+aGVscGVyLCBzaXplcy0+ZmJfd2lkdGgsIHNpemVzLT5mYl9oZWlnaHQpOwogCiAJLyogU2V0IGFwZXJ0dXJlIGJhc2Uvc2l6ZSBmb3IgdmVzYWZiIHRha2VvdmVyICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X21lbS5jIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9tZW0uYwppbmRleCA2OTA0NGViLi4yNjM0N2I3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X21lbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfbWVtLmMKQEAgLTc0MiwzMCArNzQyLDI0IEBACiB7CiAJc3RydWN0IG5vdXZlYXVfbW0gKm1tID0gbWFuLT5wcml2OwogCXN0cnVjdCBub3V2ZWF1X21tX25vZGUgKnI7Ci0JdTY0IHRvdGFsID0gMCwgdHRvdGFsWzNdID0ge30sIHR1c2VkWzNdID0ge30sIHRmcmVlWzNdID0ge307Ci0JaW50IGk7CisJdTMyIHRvdGFsID0gMCwgZnJlZSA9IDA7CiAKIAltdXRleF9sb2NrKCZtbS0+bXV0ZXgpOwogCWxpc3RfZm9yX2VhY2hfZW50cnkociwgJm1tLT5ub2RlcywgbmxfZW50cnkpIHsKLQkJcHJpbnRrKEtFUk5fREVCVUcgIiVzICVzLSVkOiAweCUwMTBsbHggMHglMDEwbGx4XG4iLAotCQkgICAgICAgcHJlZml4LCByLT5mcmVlID8gImZyZWUiIDogInVzZWQiLCByLT50eXBlLAotCQkgICAgICAgKCh1NjQpci0+b2Zmc2V0IDw8IDEyKSwKKwkJcHJpbnRrKEtFUk5fREVCVUcgIiVzICVkOiAweCUwMTBsbHggMHglMDEwbGx4XG4iLAorCQkgICAgICAgcHJlZml4LCByLT50eXBlLCAoKHU2NClyLT5vZmZzZXQgPDwgMTIpLAogCQkgICAgICAgKCgodTY0KXItPm9mZnNldCArIHItPmxlbmd0aCkgPDwgMTIpKTsKKwogCQl0b3RhbCArPSByLT5sZW5ndGg7Ci0JCXR0b3RhbFtyLT50eXBlXSArPSByLT5sZW5ndGg7Ci0JCWlmIChyLT5mcmVlKQotCQkJdGZyZWVbci0+dHlwZV0gKz0gci0+bGVuZ3RoOwotCQllbHNlCi0JCQl0dXNlZFtyLT50eXBlXSArPSByLT5sZW5ndGg7CisJCWlmICghci0+dHlwZSkKKwkJCWZyZWUgKz0gci0+bGVuZ3RoOwogCX0KIAltdXRleF91bmxvY2soJm1tLT5tdXRleCk7CiAKLQlwcmludGsoS0VSTl9ERUJVRyAiJXMgIHRvdGFsOiAweCUwMTBsbHhcbiIsIHByZWZpeCwgdG90YWwgPDwgMTIpOwotCWZvciAoaSA9IDA7IGkgPCAzOyBpKyspIHsKLQkJcHJpbnRrKEtFUk5fREVCVUcgIiVzIHR5cGUgJWQ6IDB4JTAxMGxseCwgIgotCQkJCSAgInVzZWQgMHglMDEwbGx4LCBmcmVlIDB4JTAxMGxseFxuIiwgcHJlZml4LAotCQkgICAgICAgaSwgdHRvdGFsW2ldIDw8IDEyLCB0dXNlZFtpXSA8PCAxMiwgdGZyZWVbaV0gPDwgMTIpOwotCX0KKwlwcmludGsoS0VSTl9ERUJVRyAiJXMgIHRvdGFsOiAweCUwMTBsbHggZnJlZTogMHglMDEwbGx4XG4iLAorCSAgICAgICBwcmVmaXgsICh1NjQpdG90YWwgPDwgMTIsICh1NjQpZnJlZSA8PCAxMik7CisJcHJpbnRrKEtFUk5fREVCVUcgIiVzICBibG9jazogMHglMDh4XG4iLAorCSAgICAgICBwcmVmaXgsIG1tLT5ibG9ja19zaXplIDw8IDEyKTsKIH0KIAogY29uc3Qgc3RydWN0IHR0bV9tZW1fdHlwZV9tYW5hZ2VyX2Z1bmMgbm91dmVhdV92cmFtX21hbmFnZXIgPSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X21tLmMgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X21tLmMKaW5kZXggY2RiYjExZS4uODg0NGI1MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9tbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfbW0uYwpAQCAtNDgsMTc1ICs0OCw3NiBAQAogCiAJYi0+b2Zmc2V0ID0gYS0+b2Zmc2V0OwogCWItPmxlbmd0aCA9IHNpemU7Ci0JYi0+ZnJlZSAgID0gYS0+ZnJlZTsKIAliLT50eXBlICAgPSBhLT50eXBlOwogCWEtPm9mZnNldCArPSBzaXplOwogCWEtPmxlbmd0aCAtPSBzaXplOwogCWxpc3RfYWRkX3RhaWwoJmItPm5sX2VudHJ5LCAmYS0+bmxfZW50cnkpOwotCWlmIChiLT5mcmVlKQorCWlmIChiLT50eXBlID09IDApCiAJCWxpc3RfYWRkX3RhaWwoJmItPmZsX2VudHJ5LCAmYS0+ZmxfZW50cnkpOwogCXJldHVybiBiOwogfQogCi1zdGF0aWMgc3RydWN0IG5vdXZlYXVfbW1fbm9kZSAqCi1ub3V2ZWF1X21tX21lcmdlKHN0cnVjdCBub3V2ZWF1X21tICpybW0sIHN0cnVjdCBub3V2ZWF1X21tX25vZGUgKnRoaXMpCi17Ci0Jc3RydWN0IG5vdXZlYXVfbW1fbm9kZSAqcHJldiwgKm5leHQ7Ci0KLQkvKiB0cnkgdG8gbWVyZ2Ugd2l0aCBmcmVlIGFkamFjZW50IGVudHJpZXMgb2Ygc2FtZSB0eXBlICovCi0JcHJldiA9IGxpc3RfZW50cnkodGhpcy0+bmxfZW50cnkucHJldiwgc3RydWN0IG5vdXZlYXVfbW1fbm9kZSwgbmxfZW50cnkpOwotCWlmICh0aGlzLT5ubF9lbnRyeS5wcmV2ICE9ICZybW0tPm5vZGVzKSB7Ci0JCWlmIChwcmV2LT5mcmVlICYmIHByZXYtPnR5cGUgPT0gdGhpcy0+dHlwZSkgewotCQkJcHJldi0+bGVuZ3RoICs9IHRoaXMtPmxlbmd0aDsKLQkJCXJlZ2lvbl9wdXQocm1tLCB0aGlzKTsKLQkJCXRoaXMgPSBwcmV2OwotCQl9Ci0JfQotCi0JbmV4dCA9IGxpc3RfZW50cnkodGhpcy0+bmxfZW50cnkubmV4dCwgc3RydWN0IG5vdXZlYXVfbW1fbm9kZSwgbmxfZW50cnkpOwotCWlmICh0aGlzLT5ubF9lbnRyeS5uZXh0ICE9ICZybW0tPm5vZGVzKSB7Ci0JCWlmIChuZXh0LT5mcmVlICYmIG5leHQtPnR5cGUgPT0gdGhpcy0+dHlwZSkgewotCQkJbmV4dC0+b2Zmc2V0ICA9IHRoaXMtPm9mZnNldDsKLQkJCW5leHQtPmxlbmd0aCArPSB0aGlzLT5sZW5ndGg7Ci0JCQlyZWdpb25fcHV0KHJtbSwgdGhpcyk7Ci0JCQl0aGlzID0gbmV4dDsKLQkJfQotCX0KLQotCXJldHVybiB0aGlzOwotfQorI2RlZmluZSBub2RlKHJvb3QsIGRpcikgKChyb290KS0+bmxfZW50cnkuZGlyID09ICZybW0tPm5vZGVzKSA/IE5VTEwgOiBcCisJbGlzdF9lbnRyeSgocm9vdCktPm5sX2VudHJ5LmRpciwgc3RydWN0IG5vdXZlYXVfbW1fbm9kZSwgbmxfZW50cnkpCiAKIHZvaWQKIG5vdXZlYXVfbW1fcHV0KHN0cnVjdCBub3V2ZWF1X21tICpybW0sIHN0cnVjdCBub3V2ZWF1X21tX25vZGUgKnRoaXMpCiB7Ci0JdTMyIGJsb2NrX3MsIGJsb2NrX2w7CisJc3RydWN0IG5vdXZlYXVfbW1fbm9kZSAqcHJldiA9IG5vZGUodGhpcywgcHJldik7CisJc3RydWN0IG5vdXZlYXVfbW1fbm9kZSAqbmV4dCA9IG5vZGUodGhpcywgbmV4dCk7CiAKLQl0aGlzLT5mcmVlID0gdHJ1ZTsKIAlsaXN0X2FkZCgmdGhpcy0+ZmxfZW50cnksICZybW0tPmZyZWUpOwotCXRoaXMgPSBub3V2ZWF1X21tX21lcmdlKHJtbSwgdGhpcyk7Ci0KLQkvKiBhbnkgZW50aXJlbHkgZnJlZSBibG9ja3Mgbm93PyAgd2UnbGwgd2FudCB0byByZW1vdmUgdHlwaW5nCi0JICogb24gdGhlbSBub3cgc28gdGhleSBjYW4gYmUgdXNlIGZvciBhbnkgbWVtb3J5IGFsbG9jYXRpb24KLQkgKi8KLQlibG9ja19zID0gcm91bmR1cCh0aGlzLT5vZmZzZXQsIHJtbS0+YmxvY2tfc2l6ZSk7Ci0JaWYgKGJsb2NrX3MgKyBybW0tPmJsb2NrX3NpemUgPiB0aGlzLT5vZmZzZXQgKyB0aGlzLT5sZW5ndGgpCi0JCXJldHVybjsKLQotCS8qIHNwbGl0IG9mZiBhbnkgc3RpbGwtdHlwZWQgcmVnaW9uIGF0IHRoZSBzdGFydCAqLwotCWlmIChibG9ja19zICE9IHRoaXMtPm9mZnNldCkgewotCQlpZiAoIXJlZ2lvbl9zcGxpdChybW0sIHRoaXMsIGJsb2NrX3MgLSB0aGlzLT5vZmZzZXQpKQotCQkJcmV0dXJuOwotCX0KLQotCS8qIHNwbGl0IG9mZiB0aGUgc29vbi10by1iZS11bnR5cGVkIGJsb2NrKHMpICovCi0JYmxvY2tfbCA9IHJvdW5kZG93bih0aGlzLT5sZW5ndGgsIHJtbS0+YmxvY2tfc2l6ZSk7Ci0JaWYgKGJsb2NrX2wgIT0gdGhpcy0+bGVuZ3RoKSB7Ci0JCXRoaXMgPSByZWdpb25fc3BsaXQocm1tLCB0aGlzLCBibG9ja19sKTsKLQkJaWYgKCF0aGlzKQotCQkJcmV0dXJuOwotCX0KLQotCS8qIG1hcmsgYXMgaGF2aW5nIG5vIHR5cGUsIGFuZCByZXRyeSBtZXJnZSB3aXRoIGFueSBhZGphY2VudAotCSAqIHVudHlwZWQgYmxvY2tzCi0JICovCiAJdGhpcy0+dHlwZSA9IDA7Ci0Jbm91dmVhdV9tbV9tZXJnZShybW0sIHRoaXMpOworCisJaWYgKHByZXYgJiYgcHJldi0+dHlwZSA9PSAwKSB7CisJCXByZXYtPmxlbmd0aCArPSB0aGlzLT5sZW5ndGg7CisJCXJlZ2lvbl9wdXQocm1tLCB0aGlzKTsKKwkJdGhpcyA9IHByZXY7CisJfQorCisJaWYgKG5leHQgJiYgbmV4dC0+dHlwZSA9PSAwKSB7CisJCW5leHQtPm9mZnNldCAgPSB0aGlzLT5vZmZzZXQ7CisJCW5leHQtPmxlbmd0aCArPSB0aGlzLT5sZW5ndGg7CisJCXJlZ2lvbl9wdXQocm1tLCB0aGlzKTsKKwl9CiB9CiAKIGludAogbm91dmVhdV9tbV9nZXQoc3RydWN0IG5vdXZlYXVfbW0gKnJtbSwgaW50IHR5cGUsIHUzMiBzaXplLCB1MzIgc2l6ZV9uYywKIAkgICAgICAgdTMyIGFsaWduLCBzdHJ1Y3Qgbm91dmVhdV9tbV9ub2RlICoqcG5vZGUpCiB7Ci0Jc3RydWN0IG5vdXZlYXVfbW1fbm9kZSAqdGhpcywgKnRtcCwgKm5leHQ7Ci0JdTMyIHNwbGl0b2ZmLCBhdmFpbCwgYWxsb2M7CisJc3RydWN0IG5vdXZlYXVfbW1fbm9kZSAqcHJldiwgKnRoaXMsICpuZXh0OworCXUzMiBtaW4gPSBzaXplX25jID8gc2l6ZV9uYyA6IHNpemU7CisJdTMyIGFsaWduX21hc2sgPSBhbGlnbiAtIDE7CisJdTMyIHNwbGl0b2ZmOworCXUzMiBzLCBlOwogCi0JbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHRoaXMsIHRtcCwgJnJtbS0+ZnJlZSwgZmxfZW50cnkpIHsKLQkJbmV4dCA9IGxpc3RfZW50cnkodGhpcy0+bmxfZW50cnkubmV4dCwgc3RydWN0IG5vdXZlYXVfbW1fbm9kZSwgbmxfZW50cnkpOwotCQlpZiAodGhpcy0+bmxfZW50cnkubmV4dCA9PSAmcm1tLT5ub2RlcykKLQkJCW5leHQgPSBOVUxMOworCWxpc3RfZm9yX2VhY2hfZW50cnkodGhpcywgJnJtbS0+ZnJlZSwgZmxfZW50cnkpIHsKKwkJZSA9IHRoaXMtPm9mZnNldCArIHRoaXMtPmxlbmd0aDsKKwkJcyA9IHRoaXMtPm9mZnNldDsKIAotCQkvKiBza2lwIHdyb25nbHkgdHlwZWQgYmxvY2tzICovCi0JCWlmICh0aGlzLT50eXBlICYmIHRoaXMtPnR5cGUgIT0gdHlwZSkKKwkJcHJldiA9IG5vZGUodGhpcywgcHJldik7CisJCWlmIChwcmV2ICYmIHByZXYtPnR5cGUgIT0gdHlwZSkKKwkJCXMgPSByb3VuZHVwKHMsIHJtbS0+YmxvY2tfc2l6ZSk7CisKKwkJbmV4dCA9IG5vZGUodGhpcywgbmV4dCk7CisJCWlmIChuZXh0ICYmIG5leHQtPnR5cGUgIT0gdHlwZSkKKwkJCWUgPSByb3VuZGRvd24oZSwgcm1tLT5ibG9ja19zaXplKTsKKworCQlzICA9IChzICsgYWxpZ25fbWFzaykgJiB+YWxpZ25fbWFzazsKKwkJZSAmPSB+YWxpZ25fbWFzazsKKwkJaWYgKHMgPiBlIHx8IGUgLSBzIDwgbWluKQogCQkJY29udGludWU7CiAKLQkJLyogYWNjb3VudCBmb3IgYWxpZ25tZW50ICovCi0JCXNwbGl0b2ZmID0gdGhpcy0+b2Zmc2V0ICYgKGFsaWduIC0gMSk7Ci0JCWlmIChzcGxpdG9mZikKLQkJCXNwbGl0b2ZmID0gYWxpZ24gLSBzcGxpdG9mZjsKLQotCQlpZiAodGhpcy0+bGVuZ3RoIDw9IHNwbGl0b2ZmKQotCQkJY29udGludWU7Ci0KLQkJLyogZGV0ZXJtaW5lIHRvdGFsIG1lbW9yeSBhdmFpbGFibGUgZnJvbSB0aGlzLCBhbmQKLQkJICogdGhlIG5leHQgYmxvY2sgKGlmIGFwcHJvcHJpYXRlKQotCQkgKi8KLQkJYXZhaWwgPSB0aGlzLT5sZW5ndGg7Ci0JCWlmIChuZXh0ICYmIG5leHQtPmZyZWUgJiYgKCFuZXh0LT50eXBlIHx8IG5leHQtPnR5cGUgPT0gdHlwZSkpCi0JCQlhdmFpbCArPSBuZXh0LT5sZW5ndGg7Ci0KLQkJYXZhaWwgLT0gc3BsaXRvZmY7Ci0KLQkJLyogZGV0ZXJtaW5lIGFsbG9jYXRpb24gc2l6ZSAqLwotCQlpZiAoc2l6ZV9uYykgewotCQkJYWxsb2MgPSBtaW4oYXZhaWwsIHNpemUpOwotCQkJYWxsb2MgPSByb3VuZGRvd24oYWxsb2MsIHNpemVfbmMpOwotCQkJaWYgKGFsbG9jID09IDApCi0JCQkJY29udGludWU7Ci0JCX0gZWxzZSB7Ci0JCQlhbGxvYyA9IHNpemU7Ci0JCQlpZiAoYXZhaWwgPCBhbGxvYykKLQkJCQljb250aW51ZTsKLQkJfQotCi0JCS8qIHVudHlwZWQgYmxvY2ssIHNwbGl0IG9mZiBhIGNodW5rIHRoYXQncyBhIG11bHRpcGxlCi0JCSAqIG9mIGJsb2NrX3NpemUgYW5kIHR5cGUgaXQKLQkJICovCi0JCWlmICghdGhpcy0+dHlwZSkgewotCQkJdTMyIGJsb2NrID0gcm91bmR1cChhbGxvYyArIHNwbGl0b2ZmLCBybW0tPmJsb2NrX3NpemUpOwotCQkJaWYgKHRoaXMtPmxlbmd0aCA8IGJsb2NrKQotCQkJCWNvbnRpbnVlOwotCi0JCQl0aGlzID0gcmVnaW9uX3NwbGl0KHJtbSwgdGhpcywgYmxvY2spOwotCQkJaWYgKCF0aGlzKQotCQkJCXJldHVybiAtRU5PTUVNOwotCi0JCQl0aGlzLT50eXBlID0gdHlwZTsKLQkJfQotCi0JCS8qIHN0ZWFsaW5nIG1lbW9yeSBmcm9tIGFkamFjZW50IGJsb2NrICovCi0JCWlmIChhbGxvYyA+IHRoaXMtPmxlbmd0aCkgewotCQkJdTMyIGFtb3VudCA9IGFsbG9jIC0gKHRoaXMtPmxlbmd0aCAtIHNwbGl0b2ZmKTsKLQotCQkJaWYgKCFuZXh0LT50eXBlKSB7Ci0JCQkJYW1vdW50ID0gcm91bmR1cChhbW91bnQsIHJtbS0+YmxvY2tfc2l6ZSk7Ci0KLQkJCQluZXh0ID0gcmVnaW9uX3NwbGl0KHJtbSwgbmV4dCwgYW1vdW50KTsKLQkJCQlpZiAoIW5leHQpCi0JCQkJCXJldHVybiAtRU5PTUVNOwotCi0JCQkJbmV4dC0+dHlwZSA9IHR5cGU7Ci0JCQl9Ci0KLQkJCXRoaXMtPmxlbmd0aCArPSBhbW91bnQ7Ci0JCQluZXh0LT5vZmZzZXQgKz0gYW1vdW50OwotCQkJbmV4dC0+bGVuZ3RoIC09IGFtb3VudDsKLQkJCWlmICghbmV4dC0+bGVuZ3RoKSB7Ci0JCQkJbGlzdF9kZWwoJm5leHQtPm5sX2VudHJ5KTsKLQkJCQlsaXN0X2RlbCgmbmV4dC0+ZmxfZW50cnkpOwotCQkJCWtmcmVlKG5leHQpOwotCQkJfQotCQl9Ci0KLQkJaWYgKHNwbGl0b2ZmKSB7Ci0JCQlpZiAoIXJlZ2lvbl9zcGxpdChybW0sIHRoaXMsIHNwbGl0b2ZmKSkKLQkJCQlyZXR1cm4gLUVOT01FTTsKLQkJfQotCi0JCXRoaXMgPSByZWdpb25fc3BsaXQocm1tLCB0aGlzLCBhbGxvYyk7Ci0JCWlmICh0aGlzID09IE5VTEwpCisJCXNwbGl0b2ZmID0gcyAtIHRoaXMtPm9mZnNldDsKKwkJaWYgKHNwbGl0b2ZmICYmICFyZWdpb25fc3BsaXQocm1tLCB0aGlzLCBzcGxpdG9mZikpCiAJCQlyZXR1cm4gLUVOT01FTTsKIAotCQl0aGlzLT5mcmVlID0gZmFsc2U7CisJCXRoaXMgPSByZWdpb25fc3BsaXQocm1tLCB0aGlzLCBtaW4oc2l6ZSwgZSAtIHMpKTsKKwkJaWYgKCF0aGlzKQorCQkJcmV0dXJuIC1FTk9NRU07CisKKwkJdGhpcy0+dHlwZSA9IHR5cGU7CiAJCWxpc3RfZGVsKCZ0aGlzLT5mbF9lbnRyeSk7CiAJCSpwbm9kZSA9IHRoaXM7CiAJCXJldHVybiAwOwpAQCAtMjM0LDcgKzEzNSw2IEBACiAJaGVhcCA9IGt6YWxsb2Moc2l6ZW9mKCpoZWFwKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFoZWFwKQogCQlyZXR1cm4gLUVOT01FTTsKLQloZWFwLT5mcmVlID0gdHJ1ZTsKIAloZWFwLT5vZmZzZXQgPSByb3VuZHVwKG9mZnNldCwgYmxvY2spOwogCWhlYXAtPmxlbmd0aCA9IHJvdW5kZG93bihvZmZzZXQgKyBsZW5ndGgsIGJsb2NrKSAtIGhlYXAtPm9mZnNldDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9tbS5oIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9tbS5oCmluZGV4IGFmMzg0NDkuLjc5OGVhZjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfbW0uaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X21tLmgKQEAgLTMwLDkgKzMwLDcgQEAKIAlzdHJ1Y3QgbGlzdF9oZWFkIGZsX2VudHJ5OwogCXN0cnVjdCBsaXN0X2hlYWQgcmxfZW50cnk7CiAKLQlib29sIGZyZWU7Ci0JaW50ICB0eXBlOwotCisJdTggIHR5cGU7CiAJdTMyIG9mZnNldDsKIAl1MzIgbGVuZ3RoOwogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfcG0uYyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfcG0uYwppbmRleCBmYjg0NmEzLi5mMDVjMGNkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9ub3V2ZWF1X3BtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV9wbS5jCkBAIC00NDMsNyArNDQzLDcgQEAKIAlzdHJ1Y3Qgbm91dmVhdV9wbV9lbmdpbmUgKnBtID0gJmRldl9wcml2LT5lbmdpbmUucG07CiAKIAlpZiAocG0tPmh3bW9uKSB7Ci0JCXN5c2ZzX3JlbW92ZV9ncm91cCgmcG0tPmh3bW9uLT5rb2JqLCAmaHdtb25fYXR0cmdyb3VwKTsKKwkJc3lzZnNfcmVtb3ZlX2dyb3VwKCZkZXYtPnBkZXYtPmRldi5rb2JqLCAmaHdtb25fYXR0cmdyb3VwKTsKIAkJaHdtb25fZGV2aWNlX3VucmVnaXN0ZXIocG0tPmh3bW9uKTsKIAl9CiAjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfdGVtcC5jIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV90ZW1wLmMKaW5kZXggN2VjYzRhZC4uOGQ5OTY4ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV90ZW1wLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV90ZW1wLmMKQEAgLTI2NSw4ICsyNjUsOCBAQAogCXN0cnVjdCBpMmNfYm9hcmRfaW5mbyBpbmZvW10gPSB7CiAJCXsgSTJDX0JPQVJEX0lORk8oInc4M2w3ODV0cyIsIDB4MmQpIH0sCiAJCXsgSTJDX0JPQVJEX0lORk8oInc4Mzc4MWQiLCAweDJkKSB9LAotCQl7IEkyQ19CT0FSRF9JTkZPKCJmNzUzNzUiLCAweDJlKSB9LAogCQl7IEkyQ19CT0FSRF9JTkZPKCJhZHQ3NDczIiwgMHgyZSkgfSwKKwkJeyBJMkNfQk9BUkRfSU5GTygiZjc1Mzc1IiwgMHgyZSkgfSwKIAkJeyBJMkNfQk9BUkRfSU5GTygibG05OSIsIDB4NGMpIH0sCiAJCXsgfQogCX07CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjQwX2dyYXBoLmMgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjQwX2dyYXBoLmMKaW5kZXggMTllZjkyYS4uODg3MGQ3MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnY0MF9ncmFwaC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252NDBfZ3JhcGguYwpAQCAtNDUxLDggKzQ1MSw3IEBACiAJTlZPQkpfQ0xBU1MoZGV2LCAweDMwOWUsIEdSKTsgLyogc3d6c3VyZiAqLwogCiAJLyogY3VyaWUgKi8KLQlpZiAoZGV2X3ByaXYtPmNoaXBzZXQgPj0gMHg2MCB8fAotCSAgICAweDAwMDA1NDUwICYgKDEgPDwgKGRldl9wcml2LT5jaGlwc2V0ICYgMHgwZikpKQorCWlmIChudjQ0X2dyYXBoX2NsYXNzKGRldikpCiAJCU5WT0JKX0NMQVNTKGRldiwgMHg0NDk3LCBHUik7CiAJZWxzZQogCQlOVk9CSl9DTEFTUyhkZXYsIDB4NDA5NywgR1IpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnY0MF9ncmN0eC5jIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnY0MF9ncmN0eC5jCmluZGV4IGNlNTg1MDkuLmY3MDQ0N2QgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252NDBfZ3JjdHguYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjQwX2dyY3R4LmMKQEAgLTExOCwxNyArMTE4LDYgQEAKICAqLwogCiBzdGF0aWMgaW50Ci1udjQwX2dyYXBoXzQwOTcoc3RydWN0IGRybV9kZXZpY2UgKmRldikKLXsKLQlzdHJ1Y3QgZHJtX25vdXZlYXVfcHJpdmF0ZSAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwotCi0JaWYgKChkZXZfcHJpdi0+Y2hpcHNldCAmIDB4ZjApID09IDB4NjApCi0JCXJldHVybiAwOwotCi0JcmV0dXJuICEhKDB4MGJhZiAmICgxIDw8IGRldl9wcml2LT5jaGlwc2V0KSk7Ci19Ci0KLXN0YXRpYyBpbnQKIG52NDBfZ3JhcGhfdnNfY291bnQoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIHsKIAlzdHJ1Y3QgZHJtX25vdXZlYXVfcHJpdmF0ZSAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwpAQCAtMjE5LDcgKzIwOCw3IEBACiAJCWdyX2RlZihjdHgsIDB4NDAwOWRjLCAweDgwMDAwMDAwKTsKIAl9IGVsc2UgewogCQljcF9jdHgoY3R4LCAweDQwMDg0MCwgMjApOwotCQlpZiAoIW52NDBfZ3JhcGhfNDA5NyhjdHgtPmRldikpIHsKKwkJaWYgKG52NDRfZ3JhcGhfY2xhc3MoY3R4LT5kZXYpKSB7CiAJCQlmb3IgKGkgPSAwOyBpIDwgODsgaSsrKQogCQkJCWdyX2RlZihjdHgsIDB4NDAwODYwICsgKGkgKiA0KSwgMHgwMDAwMDAwMSk7CiAJCX0KQEAgLTIyOCw3ICsyMTcsNyBAQAogCQlncl9kZWYoY3R4LCAweDQwMDg4OCwgMHgwMDAwMDA0MCk7CiAJCWNwX2N0eChjdHgsIDB4NDAwODk0LCAxMSk7CiAJCWdyX2RlZihjdHgsIDB4NDAwODk0LCAweDAwMDAwMDQwKTsKLQkJaWYgKG52NDBfZ3JhcGhfNDA5NyhjdHgtPmRldikpIHsKKwkJaWYgKCFudjQ0X2dyYXBoX2NsYXNzKGN0eC0+ZGV2KSkgewogCQkJZm9yIChpID0gMDsgaSA8IDg7IGkrKykKIAkJCQlncl9kZWYoY3R4LCAweDQwMDhhMCArIChpICogNCksIDB4ODAwMDAwMDApOwogCQl9CkBAIC01NDYsNyArNTM1LDcgQEAKIHN0YXRpYyB2b2lkCiBudjQwX2dyYXBoX2NvbnN0cnVjdF9zdGF0ZTNkXzMoc3RydWN0IG5vdXZlYXVfZ3JjdHggKmN0eCkKIHsKLQlpbnQgbGVuID0gbnY0MF9ncmFwaF80MDk3KGN0eC0+ZGV2KSA/IDB4MDY4NCA6IDB4MDA4NDsKKwlpbnQgbGVuID0gbnY0NF9ncmFwaF9jbGFzcyhjdHgtPmRldikgPyAweDAwODQgOiAweDA2ODQ7CiAKIAljcF9vdXQgKGN0eCwgMHgzMDAwMDApOwogCWNwX2xzciAoY3R4LCBsZW4gLSA0KTsKQEAgLTU4MiwxMSArNTcxLDExIEBACiAJfSBlbHNlIHsKIAkJYjBfb2Zmc2V0ID0gMHgxZDQwLzQ7IC8qIDIyMDAgKi8KIAkJYjFfb2Zmc2V0ID0gMHgzZjQwLzQ7IC8qIDBiMDAgOiAwYTQwICovCi0JCXZzX2xlbiA9IG52NDBfZ3JhcGhfNDA5NyhkZXYpID8gMHg0YTQwLzQgOiAweDQ5ODAvNDsKKwkJdnNfbGVuID0gbnY0NF9ncmFwaF9jbGFzcyhkZXYpID8gMHg0OTgwLzQgOiAweDRhNDAvNDsKIAl9CiAKIAljcF9sc3IoY3R4LCB2c19sZW4gKiB2c19uciArIDB4MzAwLzQpOwotCWNwX291dChjdHgsIG52NDBfZ3JhcGhfNDA5NyhkZXYpID8gMHg4MDAwNDEgOiAweDgwMDAyOSk7CisJY3Bfb3V0KGN0eCwgbnY0NF9ncmFwaF9jbGFzcyhkZXYpID8gMHg4MDAwMjkgOiAweDgwMDA0MSk7CiAKIAlvZmZzZXQgPSBjdHgtPmN0eHZhbHNfcG9zOwogCWN0eC0+Y3R4dmFsc19wb3MgKz0gKDB4MDMwMC80ICsgKHZzX25yICogdnNfbGVuKSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjQwX21jLmMgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjQwX21jLmMKaW5kZXggZTRlNzJjMS4uMDNjMGQ0YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnY0MF9tYy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252NDBfbWMuYwpAQCAtNiwyNyArNiwxNyBAQAogaW50CiBudjQwX21jX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIHsKLQlzdHJ1Y3QgZHJtX25vdXZlYXVfcHJpdmF0ZSAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwotCXVpbnQzMl90IHRtcDsKLQogCS8qIFBvd2VyIHVwIGV2ZXJ5dGhpbmcsIHJlc2V0dGluZyBlYWNoIGluZGl2aWR1YWwgdW5pdCB3aWxsCiAJICogYmUgZG9uZSBsYXRlciBpZiBuZWVkZWQuCiAJICovCiAJbnZfd3IzMihkZXYsIE5WMDNfUE1DX0VOQUJMRSwgMHhGRkZGRkZGRik7CiAKLQlzd2l0Y2ggKGRldl9wcml2LT5jaGlwc2V0KSB7Ci0JY2FzZSAweDQ0OgotCWNhc2UgMHg0NjogLyogRzcyICovCi0JY2FzZSAweDRlOgotCWNhc2UgMHg0YzogLyogQzUxX0c3WCAqLwotCQl0bXAgPSBudl9yZDMyKGRldiwgTlYwNF9QRkJfRklGT19EQVRBKTsKKwlpZiAobnY0NF9ncmFwaF9jbGFzcyhkZXYpKSB7CisJCXUzMiB0bXAgPSBudl9yZDMyKGRldiwgTlYwNF9QRkJfRklGT19EQVRBKTsKIAkJbnZfd3IzMihkZXYsIE5WNDBfUE1DXzE3MDAsIHRtcCk7CiAJCW52X3dyMzIoZGV2LCBOVjQwX1BNQ18xNzA0LCAwKTsKIAkJbnZfd3IzMihkZXYsIE5WNDBfUE1DXzE3MDgsIDApOwogCQludl93cjMyKGRldiwgTlY0MF9QTUNfMTcwQywgdG1wKTsKLQkJYnJlYWs7Ci0JZGVmYXVsdDoKLQkJYnJlYWs7CiAJfQogCiAJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjUwX2V2by5jIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnY1MF9ldm8uYwppbmRleCAxNGUyNGU5Li4wZWEwOTBmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjUwX2V2by5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252NTBfZXZvLmMKQEAgLTI4Myw4ICsyODMsNyBAQAogCQkJbnY1MF9ldm9fY2hhbm5lbF9kZWwoJmRldl9wcml2LT5ldm8pOwogCQkJcmV0dXJuIHJldDsKIAkJfQotCX0gZWxzZQotCWlmIChkZXZfcHJpdi0+Y2hpcHNldCAhPSAweDUwKSB7CisJfSBlbHNlIHsKIAkJcmV0ID0gbnY1MF9ldm9fZG1hb2JqX25ldyhldm8sIDB4M2QsIE52RXZvRkIxNiwgMHg3MCwgMHgxOSwKIAkJCQkJICAwLCAweGZmZmZmZmZmLCAweDAwMDEwMDAwKTsKIAkJaWYgKHJldCkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnY1MF9ncmFwaC5jIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnY1MF9ncmFwaC5jCmluZGV4IDJkN2VhNzUuLjM3ZTIxZDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252NTBfZ3JhcGguYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjUwX2dyYXBoLmMKQEAgLTI1Niw2ICsyNTYsNyBAQAogCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBjaGFuLT5kZXY7CiAJc3RydWN0IGRybV9ub3V2ZWF1X3ByaXZhdGUgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKIAlzdHJ1Y3Qgbm91dmVhdV9wZ3JhcGhfZW5naW5lICpwZ3JhcGggPSAmZGV2X3ByaXYtPmVuZ2luZS5ncmFwaDsKKwlzdHJ1Y3Qgbm91dmVhdV9maWZvX2VuZ2luZSAqcGZpZm8gPSAmZGV2X3ByaXYtPmVuZ2luZS5maWZvOwogCWludCBpLCBoZHIgPSAoZGV2X3ByaXYtPmNoaXBzZXQgPT0gMHg1MCkgPyAweDIwMCA6IDB4MjA7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIApAQCAtMjY1LDYgKzI2Niw3IEBACiAJCXJldHVybjsKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZkZXZfcHJpdi0+Y29udGV4dF9zd2l0Y2hfbG9jaywgZmxhZ3MpOworCXBmaWZvLT5yZWFzc2lnbihkZXYsIGZhbHNlKTsKIAlwZ3JhcGgtPmZpZm9fYWNjZXNzKGRldiwgZmFsc2UpOwogCiAJaWYgKHBncmFwaC0+Y2hhbm5lbChkZXYpID09IGNoYW4pCkBAIC0yNzUsNiArMjc3LDcgQEAKIAlkZXZfcHJpdi0+ZW5naW5lLmluc3RtZW0uZmx1c2goZGV2KTsKIAogCXBncmFwaC0+Zmlmb19hY2Nlc3MoZGV2LCB0cnVlKTsKKwlwZmlmby0+cmVhc3NpZ24oZGV2LCB0cnVlKTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXZfcHJpdi0+Y29udGV4dF9zd2l0Y2hfbG9jaywgZmxhZ3MpOwogCiAJbm91dmVhdV9ncHVvYmpfcmVmKE5VTEwsICZjaGFuLT5yYW1pbl9ncmN0eCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjUwX2luc3RtZW0uYyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252NTBfaW5zdG1lbS5jCmluZGV4IDJlMWIxY2QuLmVhMDA0MTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252NTBfaW5zdG1lbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252NTBfaW5zdG1lbS5jCkBAIC0zMzIsOCArMzMyLDExIEBACiAJZ3B1b2JqLT52aW5zdCA9IG5vZGUtPnZyYW0tPm9mZnNldDsKIAogCWlmIChncHVvYmotPmZsYWdzICYgTlZPQkpfRkxBR19WTSkgewotCQlyZXQgPSBub3V2ZWF1X3ZtX2dldChkZXZfcHJpdi0+Y2hhbl92bSwgc2l6ZSwgMTIsCi0JCQkJICAgICBOVl9NRU1fQUNDRVNTX1JXIHwgTlZfTUVNX0FDQ0VTU19TWVMsCisJCXUzMiBmbGFncyA9IE5WX01FTV9BQ0NFU1NfUlc7CisJCWlmICghKGdwdW9iai0+ZmxhZ3MgJiBOVk9CSl9GTEFHX1ZNX1VTRVIpKQorCQkJZmxhZ3MgfD0gTlZfTUVNX0FDQ0VTU19TWVM7CisKKwkJcmV0ID0gbm91dmVhdV92bV9nZXQoZGV2X3ByaXYtPmNoYW5fdm0sIHNpemUsIDEyLCBmbGFncywKIAkJCQkgICAgICZub2RlLT5jaGFuX3ZtYSk7CiAJCWlmIChyZXQpIHsKIAkJCXZyYW0tPnB1dChkZXYsICZub2RlLT52cmFtKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252NTBfdm0uYyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252NTBfdm0uYwppbmRleCAzOGU1MjNlLi40NTlmZjA4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjUwX3ZtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnY1MF92bS5jCkBAIC00NSwxMSArNDUsNiBAQAogCX0KIAogCWlmIChwaHlzICYgMSkgewotCQlpZiAoZGV2X3ByaXYtPnZyYW1fc3lzX2Jhc2UpIHsKLQkJCXBoeXMgKz0gZGV2X3ByaXYtPnZyYW1fc3lzX2Jhc2U7Ci0JCQlwaHlzIHw9IDB4MzA7Ci0JCX0KLQogCQlpZiAoY292ZXJhZ2UgPD0gMzIgKiAxMDI0ICogMTAyNCkKIAkJCXBoeXMgfD0gMHg2MDsKIAkJZWxzZSBpZiAoY292ZXJhZ2UgPD0gNjQgKiAxMDI0ICogMTAyNCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252YzBfZ3JhcGguYyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252YzBfZ3JhcGguYwppbmRleCA1ZmVhY2Q1Li5lYjE4YTdlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmMwX2dyYXBoLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZjMF9ncmFwaC5jCkBAIC0zMSw2ICszMSw3IEBACiAjaW5jbHVkZSAibnZjMF9ncmFwaC5oIgogCiBzdGF0aWMgdm9pZCBudmMwX2dyYXBoX2lzcihzdHJ1Y3QgZHJtX2RldmljZSAqKTsKK3N0YXRpYyB2b2lkIG52YzBfcnVuazE0MF9pc3Ioc3RydWN0IGRybV9kZXZpY2UgKik7CiBzdGF0aWMgaW50ICBudmMwX2dyYXBoX3VubG9hZF9jb250ZXh0X3RvKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHU2NCBjaGFuKTsKIAogdm9pZApAQCAtMTA1LDcgKzEwNiw4IEBACiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKIAotCXJldCA9IG5vdXZlYXVfZ3B1b2JqX25ldyhkZXYsIE5VTEwsIDM4NCAqIDEwMjQsIDQwOTYsIE5WT0JKX0ZMQUdfVk0sCisJcmV0ID0gbm91dmVhdV9ncHVvYmpfbmV3KGRldiwgTlVMTCwgMzg0ICogMTAyNCwgNDA5NiwKKwkJCQkgTlZPQkpfRkxBR19WTSB8IE5WT0JKX0ZMQUdfVk1fVVNFUiwKIAkJCQkgJmdyY2gtPnVuazQxODgxMCk7CiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKQEAgLTI4MCw2ICsyODIsNyBAQAogCQlyZXR1cm47CiAKIAlub3V2ZWF1X2lycV91bnJlZ2lzdGVyKGRldiwgMTIpOworCW5vdXZlYXVfaXJxX3VucmVnaXN0ZXIoZGV2LCAyNSk7CiAKIAlub3V2ZWF1X2dwdW9ial9yZWYoTlVMTCwgJnByaXYtPnVuazQxODhiOCk7CiAJbm91dmVhdV9ncHVvYmpfcmVmKE5VTEwsICZwcml2LT51bms0MTg4YjQpOwpAQCAtMzg5LDYgKzM5Miw3IEBACiAJfQogCiAJbm91dmVhdV9pcnFfcmVnaXN0ZXIoZGV2LCAxMiwgbnZjMF9ncmFwaF9pc3IpOworCW5vdXZlYXVfaXJxX3JlZ2lzdGVyKGRldiwgMjUsIG52YzBfcnVuazE0MF9pc3IpOwogCU5WT0JKX0NMQVNTKGRldiwgMHg5MDJkLCBHUik7IC8qIDJEICovCiAJTlZPQkpfQ0xBU1MoZGV2LCAweDkwMzksIEdSKTsgLyogTTJNRiAqLwogCU5WT0JKX0NMQVNTKGRldiwgMHg5MDk3LCBHUik7IC8qIDNEICovCkBAIC01MTEsOCArNTE1LDggQEAKIAkJCW52X3dyMzIoZGV2LCBUUF9VTklUKGdwYywgdHAsIDB4MjI0KSwgMHhjMDAwMDAwMCk7CiAJCQludl93cjMyKGRldiwgVFBfVU5JVChncGMsIHRwLCAweDQ4YyksIDB4YzAwMDAwMDApOwogCQkJbnZfd3IzMihkZXYsIFRQX1VOSVQoZ3BjLCB0cCwgMHgwODQpLCAweGMwMDAwMDAwKTsKLQkJCW52X3dyMzIoZGV2LCBUUF9VTklUKGdwYywgdHAsIDB4ZTQ0KSwgMHgwMDFmZmZmZSk7Ci0JCQludl93cjMyKGRldiwgVFBfVU5JVChncGMsIHRwLCAweGU0YyksIDB4MDAwMDAwMGYpOworCQkJbnZfd3IzMihkZXYsIFRQX1VOSVQoZ3BjLCB0cCwgMHg2NDQpLCAweDAwMWZmZmZlKTsKKwkJCW52X3dyMzIoZGV2LCBUUF9VTklUKGdwYywgdHAsIDB4NjRjKSwgMHgwMDAwMDAwZik7CiAJCX0KIAkJbnZfd3IzMihkZXYsIEdQQ19VTklUKGdwYywgMHgyYzkwKSwgMHhmZmZmZmZmZik7CiAJCW52X3dyMzIoZGV2LCBHUENfVU5JVChncGMsIDB4MmM5NCksIDB4ZmZmZmZmZmYpOwpAQCAtNzc2LDMgKzc4MCwxOSBAQAogCiAJbnZfd3IzMihkZXYsIDB4NDAwNTAwLCAweDAwMDEwMDAxKTsKIH0KKworc3RhdGljIHZvaWQKK252YzBfcnVuazE0MF9pc3Ioc3RydWN0IGRybV9kZXZpY2UgKmRldikKK3sKKwl1MzIgdW5pdHMgPSBudl9yZDMyKGRldiwgMHgwMDAxN2MpICYgMHgxZjsKKworCXdoaWxlICh1bml0cykgeworCQl1MzIgdW5pdCA9IGZmcyh1bml0cykgLSAxOworCQl1MzIgcmVnID0gMHgxNDAwMDAgKyB1bml0ICogMHgyMDAwOworCQl1MzIgc3QwID0gbnZfbWFzayhkZXYsIHJlZyArIDB4MTAyMCwgMCwgMCk7CisJCXUzMiBzdDEgPSBudl9tYXNrKGRldiwgcmVnICsgMHgxNDIwLCAwLCAwKTsKKworCQlOVl9JTkZPKGRldiwgIlBSVU5LMTQwOiAlZCAweCUwOHggMHglMDh4XG4iLCB1bml0LCBzdDAsIHN0MSk7CisJCXVuaXRzICY9IH4oMSA8PCB1bml0KTsKKwl9Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmMwX2dyY3R4LmMgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmMwX2dyY3R4LmMKaW5kZXggYjllNjhiMi4uZjg4MGZmNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZjMF9ncmN0eC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252YzBfZ3JjdHguYwpAQCAtMTgzMCw3ICsxODMwLDcgQEAKIAogCWZvciAodHAgPSAwLCBpZCA9IDA7IHRwIDwgNDsgdHArKykgewogCQlmb3IgKGdwYyA9IDA7IGdwYyA8IHByaXYtPmdwY19ucjsgZ3BjKyspIHsKLQkJCWlmICh0cCA8PSBwcml2LT50cF9ucltncGNdKSB7CisJCQlpZiAodHAgPCBwcml2LT50cF9ucltncGNdKSB7CiAJCQkJbnZfd3IzMihkZXYsIFRQX1VOSVQoZ3BjLCB0cCwgMHg2OTgpLCBpZCk7CiAJCQkJbnZfd3IzMihkZXYsIFRQX1VOSVQoZ3BjLCB0cCwgMHg0ZTgpLCBpZCk7CiAJCQkJbnZfd3IzMihkZXYsIEdQQ19VTklUKGdwYywgMHgwYzEwICsgdHAgKiA0KSwgaWQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZjMF92bS5jIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZjMF92bS5jCmluZGV4IDRiOTI1MWIuLmU0ZTgzYzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252YzBfdm0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmMwX3ZtLmMKQEAgLTQ4LDggKzQ4LDggQEAKIAlwaHlzID4+PSA4OwogCiAJcGh5cyB8PSAweDAwMDAwMDAxOyAvKiBwcmVzZW50ICovCi0vLwlpZiAodm1hLT5hY2Nlc3MgJiBOVl9NRU1fQUNDRVNTX1NZUykKLS8vCQlwaHlzIHw9IDB4MDAwMDAwMDI7CisJaWYgKHZtYS0+YWNjZXNzICYgTlZfTUVNX0FDQ0VTU19TWVMpCisJCXBoeXMgfD0gMHgwMDAwMDAwMjsKIAogCXBoeXMgfD0gKCh1NjQpdGFyZ2V0ICA8PCAzMik7CiAJcGh5cyB8PSAoKHU2NCltZW10eXBlIDw8IDM2KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vYXRvbWJpb3NfY3J0Yy5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9hdG9tYmlvc19jcnRjLmMKaW5kZXggYjBhYjE4NS4uYjE1MzcwMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9hdG9tYmlvc19jcnRjLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9hdG9tYmlvc19jcnRjLmMKQEAgLTU1NSw2ICs1NTUsNyBAQAogCQkJCQlkcF9jbG9jayA9IGRpZ19jb25uZWN0b3ItPmRwX2Nsb2NrOwogCQkJCX0KIAkJCX0KKy8qIHRoaXMgbWlnaHQgd29yayBwcm9wZXJseSB3aXRoIHRoZSBuZXcgcGxsIGFsZ28gKi8KICNpZiAwIC8qIGRvZXNuJ3Qgd29yayBwcm9wZXJseSBvbiBzb21lIGxhcHRvcHMgKi8KIAkJCS8qIHVzZSByZWNvbW1lbmRlZCByZWZfZGl2IGZvciBzcyAqLwogCQkJaWYgKHJhZGVvbl9lbmNvZGVyLT5kZXZpY2VzICYgKEFUT01fREVWSUNFX0xDRF9TVVBQT1JUKSkgewpAQCAtNTcyLDYgKzU3MywxMSBAQAogCQkJCQlhZGp1c3RlZF9jbG9jayA9IG1vZGUtPmNsb2NrICogMjsKIAkJCQlpZiAocmFkZW9uX2VuY29kZXItPmFjdGl2ZV9kZXZpY2UgJiAoQVRPTV9ERVZJQ0VfVFZfU1VQUE9SVCkpCiAJCQkJCXBsbC0+ZmxhZ3MgfD0gUkFERU9OX1BMTF9QUkVGRVJfQ0xPU0VTVF9MT1dFUjsKKwkJCQkvKiBydjUxNSBuZWVkcyBtb3JlIHRlc3Rpbmcgd2l0aCB0aGlzIG9wdGlvbiAqLworCQkJCWlmIChyZGV2LT5mYW1pbHkgIT0gQ0hJUF9SVjUxNSkgeworCQkJCQlpZiAocmFkZW9uX2VuY29kZXItPmRldmljZXMgJiAoQVRPTV9ERVZJQ0VfTENEX1NVUFBPUlQpKQorCQkJCQkJcGxsLT5mbGFncyB8PSBSQURFT05fUExMX0lTX0xDRDsKKwkJCQl9CiAJCQl9IGVsc2UgewogCQkJCWlmIChlbmNvZGVyLT5lbmNvZGVyX3R5cGUgIT0gRFJNX01PREVfRU5DT0RFUl9EQUMpCiAJCQkJCXBsbC0+ZmxhZ3MgfD0gUkFERU9OX1BMTF9OT19PRERfUE9TVF9ESVY7CkBAIC02MDYsMTQgKzYxMiw5IEBACiAJCQkJYXJncy52MS51c1BpeGVsQ2xvY2sgPSBjcHVfdG9fbGUxNihtb2RlLT5jbG9jayAvIDEwKTsKIAkJCQlhcmdzLnYxLnVjVHJhbnNtaXR0ZXJJRCA9IHJhZGVvbl9lbmNvZGVyLT5lbmNvZGVyX2lkOwogCQkJCWFyZ3MudjEudWNFbmNvZGVNb2RlID0gZW5jb2Rlcl9tb2RlOwotCQkJCWlmIChlbmNvZGVyX21vZGUgPT0gQVRPTV9FTkNPREVSX01PREVfRFApIHsKLQkJCQkJaWYgKHNzX2VuYWJsZWQpCi0JCQkJCQlhcmdzLnYxLnVjQ29uZmlnIHw9Ci0JCQkJCQkJQURKVVNUX0RJU1BMQVlfQ09ORklHX1NTX0VOQUJMRTsKLQkJCQl9IGVsc2UgaWYgKGVuY29kZXJfbW9kZSA9PSBBVE9NX0VOQ09ERVJfTU9ERV9MVkRTKSB7CisJCQkJaWYgKHNzX2VuYWJsZWQpCiAJCQkJCWFyZ3MudjEudWNDb25maWcgfD0KIAkJCQkJCUFESlVTVF9ESVNQTEFZX0NPTkZJR19TU19FTkFCTEU7Ci0JCQkJfQogCiAJCQkJYXRvbV9leGVjdXRlX3RhYmxlKHJkZXYtPm1vZGVfaW5mby5hdG9tX2NvbnRleHQsCiAJCQkJCQkgICBpbmRleCwgKHVpbnQzMl90ICopJmFyZ3MpOwpAQCAtNjI0LDEyICs2MjUsMTIgQEAKIAkJCQlhcmdzLnYzLnNJbnB1dC51Y1RyYW5zbWl0dGVySUQgPSByYWRlb25fZW5jb2Rlci0+ZW5jb2Rlcl9pZDsKIAkJCQlhcmdzLnYzLnNJbnB1dC51Y0VuY29kZU1vZGUgPSBlbmNvZGVyX21vZGU7CiAJCQkJYXJncy52My5zSW5wdXQudWNEaXNwUGxsQ29uZmlnID0gMDsKKwkJCQlpZiAoc3NfZW5hYmxlZCkKKwkJCQkJYXJncy52My5zSW5wdXQudWNEaXNwUGxsQ29uZmlnIHw9CisJCQkJCQlESVNQUExMX0NPTkZJR19TU19FTkFCTEU7CiAJCQkJaWYgKHJhZGVvbl9lbmNvZGVyLT5kZXZpY2VzICYgKEFUT01fREVWSUNFX0RGUF9TVVBQT1JUKSkgewogCQkJCQlzdHJ1Y3QgcmFkZW9uX2VuY29kZXJfYXRvbV9kaWcgKmRpZyA9IHJhZGVvbl9lbmNvZGVyLT5lbmNfcHJpdjsKIAkJCQkJaWYgKGVuY29kZXJfbW9kZSA9PSBBVE9NX0VOQ09ERVJfTU9ERV9EUCkgewotCQkJCQkJaWYgKHNzX2VuYWJsZWQpCi0JCQkJCQkJYXJncy52My5zSW5wdXQudWNEaXNwUGxsQ29uZmlnIHw9Ci0JCQkJCQkJCURJU1BQTExfQ09ORklHX1NTX0VOQUJMRTsKIAkJCQkJCWFyZ3MudjMuc0lucHV0LnVjRGlzcFBsbENvbmZpZyB8PQogCQkJCQkJCURJU1BQTExfQ09ORklHX0NPSEVSRU5UX01PREU7CiAJCQkJCQkvKiAxNjIwMCBvciAyNzAwMCAqLwpAQCAtNjQ5LDE4ICs2NTAsMTEgQEAKIAkJCQkJfQogCQkJCX0gZWxzZSBpZiAocmFkZW9uX2VuY29kZXItPmRldmljZXMgJiAoQVRPTV9ERVZJQ0VfTENEX1NVUFBPUlQpKSB7CiAJCQkJCWlmIChlbmNvZGVyX21vZGUgPT0gQVRPTV9FTkNPREVSX01PREVfRFApIHsKLQkJCQkJCWlmIChzc19lbmFibGVkKQotCQkJCQkJCWFyZ3MudjMuc0lucHV0LnVjRGlzcFBsbENvbmZpZyB8PQotCQkJCQkJCQlESVNQUExMX0NPTkZJR19TU19FTkFCTEU7CiAJCQkJCQlhcmdzLnYzLnNJbnB1dC51Y0Rpc3BQbGxDb25maWcgfD0KIAkJCQkJCQlESVNQUExMX0NPTkZJR19DT0hFUkVOVF9NT0RFOwogCQkJCQkJLyogMTYyMDAgb3IgMjcwMDAgKi8KIAkJCQkJCWFyZ3MudjMuc0lucHV0LnVzUGl4ZWxDbG9jayA9IGNwdV90b19sZTE2KGRwX2Nsb2NrIC8gMTApOwotCQkJCQl9IGVsc2UgaWYgKGVuY29kZXJfbW9kZSA9PSBBVE9NX0VOQ09ERVJfTU9ERV9MVkRTKSB7Ci0JCQkJCQlpZiAoc3NfZW5hYmxlZCkKLQkJCQkJCQlhcmdzLnYzLnNJbnB1dC51Y0Rpc3BQbGxDb25maWcgfD0KLQkJCQkJCQkJRElTUFBMTF9DT05GSUdfU1NfRU5BQkxFOwotCQkJCQl9IGVsc2UgeworCQkJCQl9IGVsc2UgaWYgKGVuY29kZXJfbW9kZSAhPSBBVE9NX0VOQ09ERVJfTU9ERV9MVkRTKSB7CiAJCQkJCQlpZiAobW9kZS0+Y2xvY2sgPiAxNjUwMDApCiAJCQkJCQkJYXJncy52My5zSW5wdXQudWNEaXNwUGxsQ29uZmlnIHw9CiAJCQkJCQkJCURJU1BQTExfQ09ORklHX0RVQUxfTElOSzsKQEAgLTk2Myw4ICs5NTcsMTYgQEAKIAkvKiBhZGp1c3QgcGl4ZWwgY2xvY2sgYXMgbmVlZGVkICovCiAJYWRqdXN0ZWRfY2xvY2sgPSBhdG9tYmlvc19hZGp1c3RfcGxsKGNydGMsIG1vZGUsIHBsbCwgc3NfZW5hYmxlZCwgJnNzKTsKIAotCXJhZGVvbl9jb21wdXRlX3BsbChwbGwsIGFkanVzdGVkX2Nsb2NrLCAmcGxsX2Nsb2NrLCAmZmJfZGl2LCAmZnJhY19mYl9kaXYsCi0JCQkgICAmcmVmX2RpdiwgJnBvc3RfZGl2KTsKKwkvKiBydjUxNSBzZWVtcyBoYXBwaWVyIHdpdGggdGhlIG9sZCBhbGdvICovCisJaWYgKHJkZXYtPmZhbWlseSA9PSBDSElQX1JWNTE1KQorCQlyYWRlb25fY29tcHV0ZV9wbGxfbGVnYWN5KHBsbCwgYWRqdXN0ZWRfY2xvY2ssICZwbGxfY2xvY2ssICZmYl9kaXYsICZmcmFjX2ZiX2RpdiwKKwkJCQkJICAmcmVmX2RpdiwgJnBvc3RfZGl2KTsKKwllbHNlIGlmIChBU0lDX0lTX0FWSVZPKHJkZXYpKQorCQlyYWRlb25fY29tcHV0ZV9wbGxfYXZpdm8ocGxsLCBhZGp1c3RlZF9jbG9jaywgJnBsbF9jbG9jaywgJmZiX2RpdiwgJmZyYWNfZmJfZGl2LAorCQkJCQkgJnJlZl9kaXYsICZwb3N0X2Rpdik7CisJZWxzZQorCQlyYWRlb25fY29tcHV0ZV9wbGxfbGVnYWN5KHBsbCwgYWRqdXN0ZWRfY2xvY2ssICZwbGxfY2xvY2ssICZmYl9kaXYsICZmcmFjX2ZiX2RpdiwKKwkJCQkJICAmcmVmX2RpdiwgJnBvc3RfZGl2KTsKIAogCWF0b21iaW9zX2NydGNfcHJvZ3JhbV9zcyhjcnRjLCBBVE9NX0RJU0FCTEUsIHJhZGVvbl9jcnRjLT5wbGxfaWQsICZzcyk7CiAKQEAgLTEwMDYsNiArMTAwOCw3IEBACiAJc3RydWN0IHJhZGVvbl9ibyAqcmJvOwogCXVpbnQ2NF90IGZiX2xvY2F0aW9uOwogCXVpbnQzMl90IGZiX2Zvcm1hdCwgZmJfcGl0Y2hfcGl4ZWxzLCB0aWxpbmdfZmxhZ3M7CisJdTMyIGZiX3N3YXAgPSBFVkVSR1JFRU5fR1JQSF9FTkRJQU5fU1dBUChFVkVSR1JFRU5fR1JQSF9FTkRJQU5fTk9ORSk7CiAJaW50IHI7CiAKIAkvKiBubyBmYiBib3VuZCAqLwpAQCAtMTA1NywxMSArMTA2MCwxNyBAQAogCWNhc2UgMTY6CiAJCWZiX2Zvcm1hdCA9IChFVkVSR1JFRU5fR1JQSF9ERVBUSChFVkVSR1JFRU5fR1JQSF9ERVBUSF8xNkJQUCkgfAogCQkJICAgICBFVkVSR1JFRU5fR1JQSF9GT1JNQVQoRVZFUkdSRUVOX0dSUEhfRk9STUFUX0FSR0I1NjUpKTsKKyNpZmRlZiBfX0JJR19FTkRJQU4KKwkJZmJfc3dhcCA9IEVWRVJHUkVFTl9HUlBIX0VORElBTl9TV0FQKEVWRVJHUkVFTl9HUlBIX0VORElBTl84SU4xNik7CisjZW5kaWYKIAkJYnJlYWs7CiAJY2FzZSAyNDoKIAljYXNlIDMyOgogCQlmYl9mb3JtYXQgPSAoRVZFUkdSRUVOX0dSUEhfREVQVEgoRVZFUkdSRUVOX0dSUEhfREVQVEhfMzJCUFApIHwKIAkJCSAgICAgRVZFUkdSRUVOX0dSUEhfRk9STUFUKEVWRVJHUkVFTl9HUlBIX0ZPUk1BVF9BUkdCODg4OCkpOworI2lmZGVmIF9fQklHX0VORElBTgorCQlmYl9zd2FwID0gRVZFUkdSRUVOX0dSUEhfRU5ESUFOX1NXQVAoRVZFUkdSRUVOX0dSUEhfRU5ESUFOXzhJTjMyKTsKKyNlbmRpZgogCQlicmVhazsKIAlkZWZhdWx0OgogCQlEUk1fRVJST1IoIlVuc3VwcG9ydGVkIHNjcmVlbiBkZXB0aCAlZFxuIiwKQEAgLTExMDYsNiArMTExNSw3IEBACiAJV1JFRzMyKEVWRVJHUkVFTl9HUlBIX1NFQ09OREFSWV9TVVJGQUNFX0FERFJFU1MgKyByYWRlb25fY3J0Yy0+Y3J0Y19vZmZzZXQsCiAJICAgICAgICh1MzIpIGZiX2xvY2F0aW9uICYgRVZFUkdSRUVOX0dSUEhfU1VSRkFDRV9BRERSRVNTX01BU0spOwogCVdSRUczMihFVkVSR1JFRU5fR1JQSF9DT05UUk9MICsgcmFkZW9uX2NydGMtPmNydGNfb2Zmc2V0LCBmYl9mb3JtYXQpOworCVdSRUczMihFVkVSR1JFRU5fR1JQSF9TV0FQX0NPTlRST0wgKyByYWRlb25fY3J0Yy0+Y3J0Y19vZmZzZXQsIGZiX3N3YXApOwogCiAJV1JFRzMyKEVWRVJHUkVFTl9HUlBIX1NVUkZBQ0VfT0ZGU0VUX1ggKyByYWRlb25fY3J0Yy0+Y3J0Y19vZmZzZXQsIDApOwogCVdSRUczMihFVkVSR1JFRU5fR1JQSF9TVVJGQUNFX09GRlNFVF9ZICsgcmFkZW9uX2NydGMtPmNydGNfb2Zmc2V0LCAwKTsKQEAgLTExNjIsNiArMTE3Miw3IEBACiAJc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqdGFyZ2V0X2ZiOwogCXVpbnQ2NF90IGZiX2xvY2F0aW9uOwogCXVpbnQzMl90IGZiX2Zvcm1hdCwgZmJfcGl0Y2hfcGl4ZWxzLCB0aWxpbmdfZmxhZ3M7CisJdTMyIGZiX3N3YXAgPSBSNjAwX0QxR1JQSF9TV0FQX0VORElBTl9OT05FOwogCWludCByOwogCiAJLyogbm8gZmIgYm91bmQgKi8KQEAgLTEyMTUsMTIgKzEyMjYsMTggQEAKIAkJZmJfZm9ybWF0ID0KIAkJICAgIEFWSVZPX0QxR1JQSF9DT05UUk9MX0RFUFRIXzE2QlBQIHwKIAkJICAgIEFWSVZPX0QxR1JQSF9DT05UUk9MXzE2QlBQX1JHQjU2NTsKKyNpZmRlZiBfX0JJR19FTkRJQU4KKwkJZmJfc3dhcCA9IFI2MDBfRDFHUlBIX1NXQVBfRU5ESUFOXzE2QklUOworI2VuZGlmCiAJCWJyZWFrOwogCWNhc2UgMjQ6CiAJY2FzZSAzMjoKIAkJZmJfZm9ybWF0ID0KIAkJICAgIEFWSVZPX0QxR1JQSF9DT05UUk9MX0RFUFRIXzMyQlBQIHwKIAkJICAgIEFWSVZPX0QxR1JQSF9DT05UUk9MXzMyQlBQX0FSR0I4ODg4OworI2lmZGVmIF9fQklHX0VORElBTgorCQlmYl9zd2FwID0gUjYwMF9EMUdSUEhfU1dBUF9FTkRJQU5fMzJCSVQ7CisjZW5kaWYKIAkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJRFJNX0VSUk9SKCJVbnN1cHBvcnRlZCBzY3JlZW4gZGVwdGggJWRcbiIsCkBAIC0xMjYwLDYgKzEyNzcsOCBAQAogCVdSRUczMihBVklWT19EMUdSUEhfU0VDT05EQVJZX1NVUkZBQ0VfQUREUkVTUyArCiAJICAgICAgIHJhZGVvbl9jcnRjLT5jcnRjX29mZnNldCwgKHUzMikgZmJfbG9jYXRpb24pOwogCVdSRUczMihBVklWT19EMUdSUEhfQ09OVFJPTCArIHJhZGVvbl9jcnRjLT5jcnRjX29mZnNldCwgZmJfZm9ybWF0KTsKKwlpZiAocmRldi0+ZmFtaWx5ID49IENISVBfUjYwMCkKKwkJV1JFRzMyKFI2MDBfRDFHUlBIX1NXQVBfQ09OVFJPTCArIHJhZGVvbl9jcnRjLT5jcnRjX29mZnNldCwgZmJfc3dhcCk7CiAKIAlXUkVHMzIoQVZJVk9fRDFHUlBIX1NVUkZBQ0VfT0ZGU0VUX1ggKyByYWRlb25fY3J0Yy0+Y3J0Y19vZmZzZXQsIDApOwogCVdSRUczMihBVklWT19EMUdSUEhfU1VSRkFDRV9PRkZTRVRfWSArIHJhZGVvbl9jcnRjLT5jcnRjX29mZnNldCwgMCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2F0b21iaW9zX2RwLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2F0b21iaW9zX2RwLmMKaW5kZXggNGU3Nzc4ZC4uNjk1ZGU5YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9hdG9tYmlvc19kcC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vYXRvbWJpb3NfZHAuYwpAQCAtMTg3LDkgKzE4Nyw5IEBACiBpbnQgZHBfbW9kZV92YWxpZCh1OCBkcGNkW0RQX0RQQ0RfU0laRV0sIGludCBtb2RlX2Nsb2NrKQogewogCWludCBsYW5lcyA9IGRwX2xhbmVzX2Zvcl9tb2RlX2Nsb2NrKGRwY2QsIG1vZGVfY2xvY2spOwotCWludCBidyA9IGRwX2xhbmVzX2Zvcl9tb2RlX2Nsb2NrKGRwY2QsIG1vZGVfY2xvY2spOworCWludCBkcF9jbG9jayA9IGRwX2xpbmtfY2xvY2tfZm9yX21vZGVfY2xvY2soZHBjZCwgbW9kZV9jbG9jayk7CiAKLQlpZiAoKGxhbmVzID09IDApIHx8IChidyA9PSAwKSkKKwlpZiAoKGxhbmVzID09IDApIHx8IChkcF9jbG9jayA9PSAwKSkKIAkJcmV0dXJuIE1PREVfQ0xPQ0tfSElHSDsKIAogCXJldHVybiBNT0RFX09LOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9ldmVyZ3JlZW4uYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vZXZlcmdyZWVuLmMKaW5kZXggN2ZlOGViZC4uZmZkYzgzMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9ldmVyZ3JlZW4uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2V2ZXJncmVlbi5jCkBAIC05NywyNiArOTcsMjkgQEAKIH0KIAogLyogZ2V0IHRlbXBlcmF0dXJlIGluIG1pbGxpZGVncmVlcyAqLwotdTMyIGV2ZXJncmVlbl9nZXRfdGVtcChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKK2ludCBldmVyZ3JlZW5fZ2V0X3RlbXAoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiB7CiAJdTMyIHRlbXAgPSAoUlJFRzMyKENHX01VTFRfVEhFUk1BTF9TVEFUVVMpICYgQVNJQ19UX01BU0spID4+CiAJCUFTSUNfVF9TSElGVDsKIAl1MzIgYWN0dWFsX3RlbXAgPSAwOwogCi0JaWYgKCh0ZW1wID4+IDEwKSAmIDEpCi0JCWFjdHVhbF90ZW1wID0gMDsKLQllbHNlIGlmICgodGVtcCA+PiA5KSAmIDEpCisJaWYgKHRlbXAgJiAweDQwMCkKKwkJYWN0dWFsX3RlbXAgPSAtMjU2OworCWVsc2UgaWYgKHRlbXAgJiAweDIwMCkKIAkJYWN0dWFsX3RlbXAgPSAyNTU7Ci0JZWxzZQotCQlhY3R1YWxfdGVtcCA9ICh0ZW1wID4+IDEpICYgMHhmZjsKKwllbHNlIGlmICh0ZW1wICYgMHgxMDApIHsKKwkJYWN0dWFsX3RlbXAgPSB0ZW1wICYgMHgxZmY7CisJCWFjdHVhbF90ZW1wIHw9IH4weDFmZjsKKwl9IGVsc2UKKwkJYWN0dWFsX3RlbXAgPSB0ZW1wICYgMHhmZjsKIAotCXJldHVybiBhY3R1YWxfdGVtcCAqIDEwMDA7CisJcmV0dXJuIChhY3R1YWxfdGVtcCAqIDEwMDApIC8gMjsKIH0KIAotdTMyIHN1bW9fZ2V0X3RlbXAoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCitpbnQgc3Vtb19nZXRfdGVtcChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIHsKIAl1MzIgdGVtcCA9IFJSRUczMihDR19USEVSTUFMX1NUQVRVUykgJiAweGZmOwotCXUzMiBhY3R1YWxfdGVtcCA9ICh0ZW1wID4+IDEpICYgMHhmZjsKKwlpbnQgYWN0dWFsX3RlbXAgPSB0ZW1wIC0gNDk7CiAKIAlyZXR1cm4gYWN0dWFsX3RlbXAgKiAxMDAwOwogfQpAQCAtMTE4Miw2ICsxMTg1LDE4IEBACiAvKgogICogQ1AuCiAgKi8KK3ZvaWQgZXZlcmdyZWVuX3JpbmdfaWJfZXhlY3V0ZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgc3RydWN0IHJhZGVvbl9pYiAqaWIpCit7CisJLyogc2V0IHRvIERYMTAvMTEgbW9kZSAqLworCXJhZGVvbl9yaW5nX3dyaXRlKHJkZXYsIFBBQ0tFVDMoUEFDS0VUM19NT0RFX0NPTlRST0wsIDApKTsKKwlyYWRlb25fcmluZ193cml0ZShyZGV2LCAxKTsKKwkvKiBGSVhNRTogaW1wbGVtZW50ICovCisJcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgUEFDS0VUMyhQQUNLRVQzX0lORElSRUNUX0JVRkZFUiwgMikpOworCXJhZGVvbl9yaW5nX3dyaXRlKHJkZXYsIGliLT5ncHVfYWRkciAmIDB4RkZGRkZGRkMpOworCXJhZGVvbl9yaW5nX3dyaXRlKHJkZXYsIHVwcGVyXzMyX2JpdHMoaWItPmdwdV9hZGRyKSAmIDB4RkYpOworCXJhZGVvbl9yaW5nX3dyaXRlKHJkZXYsIGliLT5sZW5ndGhfZHcpOworfQorCiAKIHN0YXRpYyBpbnQgZXZlcmdyZWVuX2NwX2xvYWRfbWljcm9jb2RlKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogewpAQCAtMTIzMyw3ICsxMjQ4LDcgQEAKIAljcF9tZSA9IDB4ZmY7CiAJV1JFRzMyKENQX01FX0NOVEwsIGNwX21lKTsKIAotCXIgPSByYWRlb25fcmluZ19sb2NrKHJkZXYsIGV2ZXJncmVlbl9kZWZhdWx0X3NpemUgKyAxNSk7CisJciA9IHJhZGVvbl9yaW5nX2xvY2socmRldiwgZXZlcmdyZWVuX2RlZmF1bHRfc2l6ZSArIDE5KTsKIAlpZiAocikgewogCQlEUk1fRVJST1IoInJhZGVvbjogY3AgZmFpbGVkIHRvIGxvY2sgcmluZyAoJWQpLlxuIiwgcik7CiAJCXJldHVybiByOwpAQCAtMTI2Niw2ICsxMjgxLDExIEBACiAJcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgMHhmZmZmZmZmZik7CiAJcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgMHhmZmZmZmZmZik7CiAKKwlyYWRlb25fcmluZ193cml0ZShyZGV2LCAweGMwMDI2OTAwKTsKKwlyYWRlb25fcmluZ193cml0ZShyZGV2LCAweDAwMDAwMzE2KTsKKwlyYWRlb25fcmluZ193cml0ZShyZGV2LCAweDAwMDAwMDBlKTsgLyogVkdUX1ZFUlRFWF9SRVVTRV9CTE9DS19DTlRMICovCisJcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgMHgwMDAwMDAxMCk7IC8qICAqLworCiAJcmFkZW9uX3JpbmdfdW5sb2NrX2NvbW1pdChyZGV2KTsKIAogCXJldHVybiAwOwpAQCAtMjA3Miw2ICsyMDkyLDcgQEAKIAlXUkVHMzIoVkdUX0NBQ0hFX0lOVkFMSURBVElPTiwgdmd0X2NhY2hlX2ludmFsaWRhdGlvbik7CiAKIAlXUkVHMzIoVkdUX0dTX1ZFUlRFWF9SRVVTRSwgMTYpOworCVdSRUczMihQQV9TVV9MSU5FX1NUSVBQTEVfVkFMVUUsIDApOwogCVdSRUczMihQQV9TQ19MSU5FX1NUSVBQTEVfU1RBVEUsIDApOwogCiAJV1JFRzMyKFZHVF9WRVJURVhfUkVVU0VfQkxPQ0tfQ05UTCwgMTQpOwpAQCAtMjIwMSw2ICsyMjIyLDkgQEAKIAlzdHJ1Y3QgZXZlcmdyZWVuX21jX3NhdmUgc2F2ZTsKIAl1MzIgZ3JibV9yZXNldCA9IDA7CiAKKwlpZiAoIShSUkVHMzIoR1JCTV9TVEFUVVMpICYgR1VJX0FDVElWRSkpCisJCXJldHVybiAwOworCiAJZGV2X2luZm8ocmRldi0+ZGV2LCAiR1BVIHNvZnRyZXNldCBcbiIpOwogCWRldl9pbmZvKHJkZXYtPmRldiwgIiAgR1JCTV9TVEFUVVM9MHglMDhYXG4iLAogCQlSUkVHMzIoR1JCTV9TVEFUVVMpKTsKQEAgLTMwMDIsMzEgKzMwMjYsNiBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgYm9vbCBldmVyZ3JlZW5fY2FyZF9wb3N0ZWQoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCi17Ci0JdTMyIHJlZzsKLQotCS8qIGZpcnN0IGNoZWNrIENSVENzICovCi0JaWYgKHJkZXYtPmZsYWdzICYgUkFERU9OX0lTX0lHUCkKLQkJcmVnID0gUlJFRzMyKEVWRVJHUkVFTl9DUlRDX0NPTlRST0wgKyBFVkVSR1JFRU5fQ1JUQzBfUkVHSVNURVJfT0ZGU0VUKSB8Ci0JCQlSUkVHMzIoRVZFUkdSRUVOX0NSVENfQ09OVFJPTCArIEVWRVJHUkVFTl9DUlRDMV9SRUdJU1RFUl9PRkZTRVQpOwotCWVsc2UKLQkJcmVnID0gUlJFRzMyKEVWRVJHUkVFTl9DUlRDX0NPTlRST0wgKyBFVkVSR1JFRU5fQ1JUQzBfUkVHSVNURVJfT0ZGU0VUKSB8Ci0JCQlSUkVHMzIoRVZFUkdSRUVOX0NSVENfQ09OVFJPTCArIEVWRVJHUkVFTl9DUlRDMV9SRUdJU1RFUl9PRkZTRVQpIHwKLQkJCVJSRUczMihFVkVSR1JFRU5fQ1JUQ19DT05UUk9MICsgRVZFUkdSRUVOX0NSVEMyX1JFR0lTVEVSX09GRlNFVCkgfAotCQkJUlJFRzMyKEVWRVJHUkVFTl9DUlRDX0NPTlRST0wgKyBFVkVSR1JFRU5fQ1JUQzNfUkVHSVNURVJfT0ZGU0VUKSB8Ci0JCQlSUkVHMzIoRVZFUkdSRUVOX0NSVENfQ09OVFJPTCArIEVWRVJHUkVFTl9DUlRDNF9SRUdJU1RFUl9PRkZTRVQpIHwKLQkJCVJSRUczMihFVkVSR1JFRU5fQ1JUQ19DT05UUk9MICsgRVZFUkdSRUVOX0NSVEM1X1JFR0lTVEVSX09GRlNFVCk7Ci0JaWYgKHJlZyAmIEVWRVJHUkVFTl9DUlRDX01BU1RFUl9FTikKLQkJcmV0dXJuIHRydWU7Ci0KLQkvKiB0aGVuIGNoZWNrIE1FTV9TSVpFLCBpbiBjYXNlIHRoZSBjcnRjcyBhcmUgb2ZmICovCi0JaWYgKFJSRUczMihDT05GSUdfTUVNU0laRSkpCi0JCXJldHVybiB0cnVlOwotCi0JcmV0dXJuIGZhbHNlOwotfQotCiAvKiBQbGFuIGlzIHRvIG1vdmUgaW5pdGlhbGl6YXRpb24gaW4gdGhhdCBmdW5jdGlvbiBhbmQgdXNlCiAgKiBoZWxwZXIgZnVuY3Rpb24gc28gdGhhdCByYWRlb25fZGV2aWNlX2luaXQgcHJldHR5IG11Y2gKICAqIGRvIG5vdGhpbmcgbW9yZSB0aGFuIGNhbGxpbmcgYXNpYyBzcGVjaWZpYyBmdW5jdGlvbi4gVGhpcwpAQCAtMzA2Myw3ICszMDYyLDcgQEAKIAlpZiAocmFkZW9uX2FzaWNfcmVzZXQocmRldikpCiAJCWRldl93YXJuKHJkZXYtPmRldiwgIkdQVSByZXNldCBmYWlsZWQgIVxuIik7CiAJLyogUG9zdCBjYXJkIGlmIG5lY2Vzc2FyeSAqLwotCWlmICghZXZlcmdyZWVuX2NhcmRfcG9zdGVkKHJkZXYpKSB7CisJaWYgKCFyYWRlb25fY2FyZF9wb3N0ZWQocmRldikpIHsKIAkJaWYgKCFyZGV2LT5iaW9zKSB7CiAJCQlkZXZfZXJyKHJkZXYtPmRldiwgIkNhcmQgbm90IHBvc3RlZCBhbmQgbm8gQklPUyAtIGlnbm9yaW5nXG4iKTsKIAkJCXJldHVybiAtRUlOVkFMOwpAQCAtMzE1OCw2ICszMTU3LDkgQEAKIHsKIAl1MzIgbGlua193aWR0aF9jbnRsLCBzcGVlZF9jbnRsOwogCisJaWYgKHJhZGVvbl9wY2llX2dlbjIgPT0gMCkKKwkJcmV0dXJuOworCiAJaWYgKHJkZXYtPmZsYWdzICYgUkFERU9OX0lTX0lHUCkKIAkJcmV0dXJuOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2V2ZXJncmVlbl9ibGl0X2ttcy5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9ldmVyZ3JlZW5fYmxpdF9rbXMuYwppbmRleCBiNzU4ZGM3Li5hMWJhNGIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2V2ZXJncmVlbl9ibGl0X2ttcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vZXZlcmdyZWVuX2JsaXRfa21zLmMKQEAgLTIzMiw3ICsyMzIsNyBAQAogCiB9CiAKLS8qIGVtaXRzIDMwICovCisvKiBlbWl0cyAzNiAqLwogc3RhdGljIHZvaWQKIHNldF9kZWZhdWx0X3N0YXRlKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogewpAQCAtMjQ1LDYgKzI0NSw4IEBACiAJaW50IG51bV9oc190aHJlYWRzLCBudW1fbHNfdGhyZWFkczsKIAlpbnQgbnVtX3BzX3N0YWNrX2VudHJpZXMsIG51bV92c19zdGFja19lbnRyaWVzLCBudW1fZ3Nfc3RhY2tfZW50cmllcywgbnVtX2VzX3N0YWNrX2VudHJpZXM7CiAJaW50IG51bV9oc19zdGFja19lbnRyaWVzLCBudW1fbHNfc3RhY2tfZW50cmllczsKKwl1NjQgZ3B1X2FkZHI7CisJaW50IGR3b3JkczsKIAogCXN3aXRjaCAocmRldi0+ZmFtaWx5KSB7CiAJY2FzZSBDSElQX0NFREFSOgpAQCAtNDk3LDYgKzQ5OSwxOCBAQAogCXJhZGVvbl9yaW5nX3dyaXRlKHJkZXYsIDB4MDAwMDAwMDApOwogCXJhZGVvbl9yaW5nX3dyaXRlKHJkZXYsIDB4MDAwMDAwMDApOwogCisJLyogc2V0IHRvIERYMTAvMTEgbW9kZSAqLworCXJhZGVvbl9yaW5nX3dyaXRlKHJkZXYsIFBBQ0tFVDMoUEFDS0VUM19NT0RFX0NPTlRST0wsIDApKTsKKwlyYWRlb25fcmluZ193cml0ZShyZGV2LCAxKTsKKworCS8qIGVtaXQgYW4gSUIgcG9pbnRpbmcgYXQgZGVmYXVsdCBzdGF0ZSAqLworCWR3b3JkcyA9IEFMSUdOKHJkZXYtPnI2MDBfYmxpdC5zdGF0ZV9sZW4sIDB4MTApOworCWdwdV9hZGRyID0gcmRldi0+cjYwMF9ibGl0LnNoYWRlcl9ncHVfYWRkciArIHJkZXYtPnI2MDBfYmxpdC5zdGF0ZV9vZmZzZXQ7CisJcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgUEFDS0VUMyhQQUNLRVQzX0lORElSRUNUX0JVRkZFUiwgMikpOworCXJhZGVvbl9yaW5nX3dyaXRlKHJkZXYsIGdwdV9hZGRyICYgMHhGRkZGRkZGQyk7CisJcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgdXBwZXJfMzJfYml0cyhncHVfYWRkcikgJiAweEZGKTsKKwlyYWRlb25fcmluZ193cml0ZShyZGV2LCBkd29yZHMpOworCiB9CiAKIHN0YXRpYyBpbmxpbmUgdWludDMyX3QgaTJmKHVpbnQzMl90IGlucHV0KQpAQCAtNTI3LDggKzU0MSwxMCBAQAogaW50IGV2ZXJncmVlbl9ibGl0X2luaXQoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiB7CiAJdTMyIG9ial9zaXplOwotCWludCByOworCWludCByLCBkd29yZHM7CiAJdm9pZCAqcHRyOworCXUzMiBwYWNrZXQyc1sxNl07CisJaW50IG51bV9wYWNrZXQycyA9IDA7CiAKIAkvKiBwaW4gY29weSBzaGFkZXIgaW50byB2cmFtIGlmIGFscmVhZHkgaW5pdGlhbGl6ZWQgKi8KIAlpZiAocmRldi0+cjYwMF9ibGl0LnNoYWRlcl9vYmopCkBAIC01MzYsOCArNTUyLDE3IEBACiAKIAltdXRleF9pbml0KCZyZGV2LT5yNjAwX2JsaXQubXV0ZXgpOwogCXJkZXYtPnI2MDBfYmxpdC5zdGF0ZV9vZmZzZXQgPSAwOwotCXJkZXYtPnI2MDBfYmxpdC5zdGF0ZV9sZW4gPSAwOwotCW9ial9zaXplID0gMDsKKworCXJkZXYtPnI2MDBfYmxpdC5zdGF0ZV9sZW4gPSBldmVyZ3JlZW5fZGVmYXVsdF9zaXplOworCisJZHdvcmRzID0gcmRldi0+cjYwMF9ibGl0LnN0YXRlX2xlbjsKKwl3aGlsZSAoZHdvcmRzICYgMHhmKSB7CisJCXBhY2tldDJzW251bV9wYWNrZXQycysrXSA9IFBBQ0tFVDIoMCk7CisJCWR3b3JkcysrOworCX0KKworCW9ial9zaXplID0gZHdvcmRzICogNDsKKwlvYmpfc2l6ZSA9IEFMSUdOKG9ial9zaXplLCAyNTYpOwogCiAJcmRldi0+cjYwMF9ibGl0LnZzX29mZnNldCA9IG9ial9zaXplOwogCW9ial9zaXplICs9IGV2ZXJncmVlbl92c19zaXplICogNDsKQEAgLTU2Nyw2ICs1OTIsMTIgQEAKIAkJcmV0dXJuIHI7CiAJfQogCisJbWVtY3B5X3RvaW8ocHRyICsgcmRldi0+cjYwMF9ibGl0LnN0YXRlX29mZnNldCwKKwkJICAgIGV2ZXJncmVlbl9kZWZhdWx0X3N0YXRlLCByZGV2LT5yNjAwX2JsaXQuc3RhdGVfbGVuICogNCk7CisKKwlpZiAobnVtX3BhY2tldDJzKQorCQltZW1jcHlfdG9pbyhwdHIgKyByZGV2LT5yNjAwX2JsaXQuc3RhdGVfb2Zmc2V0ICsgKHJkZXYtPnI2MDBfYmxpdC5zdGF0ZV9sZW4gKiA0KSwKKwkJCSAgICBwYWNrZXQycywgbnVtX3BhY2tldDJzICogNCk7CiAJbWVtY3B5KHB0ciArIHJkZXYtPnI2MDBfYmxpdC52c19vZmZzZXQsIGV2ZXJncmVlbl92cywgZXZlcmdyZWVuX3ZzX3NpemUgKiA0KTsKIAltZW1jcHkocHRyICsgcmRldi0+cjYwMF9ibGl0LnBzX29mZnNldCwgZXZlcmdyZWVuX3BzLCBldmVyZ3JlZW5fcHNfc2l6ZSAqIDQpOwogCXJhZGVvbl9ib19rdW5tYXAocmRldi0+cjYwMF9ibGl0LnNoYWRlcl9vYmopOwpAQCAtNjUyLDcgKzY4Myw3IEBACiAJLyogY2FsY3VsYXRlIG51bWJlciBvZiBsb29wcyBjb3JyZWN0bHkgKi8KIAlyaW5nX3NpemUgPSBudW1fbG9vcHMgKiBkd29yZHNfcGVyX2xvb3A7CiAJLyogc2V0IGRlZmF1bHQgICsgc2hhZGVycyAqLwotCXJpbmdfc2l6ZSArPSA0NjsgLyogc2hhZGVycyArIGRlZiBzdGF0ZSAqLworCXJpbmdfc2l6ZSArPSA1MjsgLyogc2hhZGVycyArIGRlZiBzdGF0ZSAqLwogCXJpbmdfc2l6ZSArPSAxMDsgLyogZmVuY2UgZW1pdCBmb3IgVkIgSUIgKi8KIAlyaW5nX3NpemUgKz0gNTsgLyogZG9uZSBjb3B5ICovCiAJcmluZ19zaXplICs9IDEwOyAvKiBmZW5jZSBlbWl0IGZvciBkb25lIGNvcHkgKi8KQEAgLTY2MCw3ICs2OTEsNyBAQAogCWlmIChyKQogCQlyZXR1cm4gcjsKIAotCXNldF9kZWZhdWx0X3N0YXRlKHJkZXYpOyAvKiAzMCAqLworCXNldF9kZWZhdWx0X3N0YXRlKHJkZXYpOyAvKiAzNiAqLwogCXNldF9zaGFkZXJzKHJkZXYpOyAvKiAxNiAqLwogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9ldmVyZ3JlZW5kLmggYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2V2ZXJncmVlbmQuaAppbmRleCAzNmQzMmQ4Li5hZmVjMWFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2V2ZXJncmVlbmQuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2V2ZXJncmVlbmQuaApAQCAtMjQwLDYgKzI0MCw3IEBACiAjZGVmaW5lCQlGT1JDRV9FT1ZfTUFYX0NMS19DTlQoeCkJCQkoKHgpIDw8IDApCiAjZGVmaW5lCQlGT1JDRV9FT1ZfTUFYX1JFWl9DTlQoeCkJCQkoKHgpIDw8IDE2KQogI2RlZmluZSBQQV9TQ19MSU5FX1NUSVBQTEUJCQkJMHgyOEEwQworI2RlZmluZQlQQV9TVV9MSU5FX1NUSVBQTEVfVkFMVUUJCQkweDhBNjAKICNkZWZpbmUJUEFfU0NfTElORV9TVElQUExFX1NUQVRFCQkJMHg4QjEwCiAKICNkZWZpbmUJU0NSQVRDSF9SRUcwCQkJCQkweDg1MDAKQEAgLTY1Miw2ICs2NTMsNyBAQAogI2RlZmluZQlQQUNLRVQzX0RJU1BBVENIX0RJUkVDVAkJCQkweDE1CiAjZGVmaW5lCVBBQ0tFVDNfRElTUEFUQ0hfSU5ESVJFQ1QJCQkweDE2CiAjZGVmaW5lCVBBQ0tFVDNfSU5ESVJFQ1RfQlVGRkVSX0VORAkJCTB4MTcKKyNkZWZpbmUJUEFDS0VUM19NT0RFX0NPTlRST0wJCQkJMHgxOAogI2RlZmluZQlQQUNLRVQzX1NFVF9QUkVESUNBVElPTgkJCQkweDIwCiAjZGVmaW5lCVBBQ0tFVDNfUkVHX1JNVwkJCQkJMHgyMQogI2RlZmluZQlQQUNLRVQzX0NPTkRfRVhFQwkJCQkweDIyCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3IxMDAuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjEwMC5jCmluZGV4IGY2Mzc1OTUuLjVmMTU4MjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjEwMC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjEwMC5jCkBAIC0xMDMxLDggKzEwMzEsOCBAQAogCVdSRUczMihSQURFT05fQ1BfQ1NRX01PREUsCiAJICAgICAgIFJFR19TRVQoUkFERU9OX0lORElSRUNUMl9TVEFSVCwgaW5kaXJlY3QyX3N0YXJ0KSB8CiAJICAgICAgIFJFR19TRVQoUkFERU9OX0lORElSRUNUMV9TVEFSVCwgaW5kaXJlY3QxX3N0YXJ0KSk7Ci0JV1JFRzMyKDB4NzE4LCAwKTsKLQlXUkVHMzIoMHg3NDQsIDB4MDAwMDRENEQpOworCVdSRUczMihSQURFT05fQ1BfUkJfV1BUUl9ERUxBWSwgMCk7CisJV1JFRzMyKFJBREVPTl9DUF9DU1FfTU9ERSwgMHgwMDAwNEQ0RCk7CiAJV1JFRzMyKFJBREVPTl9DUF9DU1FfQ05UTCwgUkFERU9OX0NTUV9QUklCTV9JTkRCTSk7CiAJcmFkZW9uX3Jpbmdfc3RhcnQocmRldik7CiAJciA9IHJhZGVvbl9yaW5nX3Rlc3QocmRldik7CkBAIC0yMDg2LDEyICsyMDg2LDEzIEBACiB7CiAJc3RydWN0IHIxMDBfbWNfc2F2ZSBzYXZlOwogCXUzMiBzdGF0dXMsIHRtcDsKKwlpbnQgcmV0ID0gMDsKIAotCXIxMDBfbWNfc3RvcChyZGV2LCAmc2F2ZSk7CiAJc3RhdHVzID0gUlJFRzMyKFJfMDAwRTQwX1JCQk1fU1RBVFVTKTsKIAlpZiAoIUdfMDAwRTQwX0dVSV9BQ1RJVkUoc3RhdHVzKSkgewogCQlyZXR1cm4gMDsKIAl9CisJcjEwMF9tY19zdG9wKHJkZXYsICZzYXZlKTsKIAlzdGF0dXMgPSBSUkVHMzIoUl8wMDBFNDBfUkJCTV9TVEFUVVMpOwogCWRldl9pbmZvKHJkZXYtPmRldiwgIiglczolZCkgUkJCTV9TVEFUVVM9MHglMDhYXG4iLCBfX2Z1bmNfXywgX19MSU5FX18sIHN0YXR1cyk7CiAJLyogc3RvcCBDUCAqLwpAQCAtMjEzMSwxMSArMjEzMiwxMSBAQAogCQlHXzAwMEU0MF9UQU1fQlVTWShzdGF0dXMpIHx8IEdfMDAwRTQwX1BCX0JVU1koc3RhdHVzKSkgewogCQlkZXZfZXJyKHJkZXYtPmRldiwgImZhaWxlZCB0byByZXNldCBHUFVcbiIpOwogCQlyZGV2LT5ncHVfbG9ja3VwID0gdHJ1ZTsKLQkJcmV0dXJuIC0xOwotCX0KKwkJcmV0ID0gLTE7CisJfSBlbHNlCisJCWRldl9pbmZvKHJkZXYtPmRldiwgIkdQVSByZXNldCBzdWNjZWVkXG4iKTsKIAlyMTAwX21jX3Jlc3VtZShyZGV2LCAmc2F2ZSk7Ci0JZGV2X2luZm8ocmRldi0+ZGV2LCAiR1BVIHJlc2V0IHN1Y2NlZWRcbiIpOwotCXJldHVybiAwOworCXJldHVybiByZXQ7CiB9CiAKIHZvaWQgcjEwMF9zZXRfY29tbW9uX3JlZ3Moc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCkBAIC0yMzQ2LDEwICsyMzQ3LDEwIEBACiAKIAl0ZW1wID0gUlJFRzMyKFJBREVPTl9DT05GSUdfQ05UTCk7CiAJaWYgKHN0YXRlID09IGZhbHNlKSB7Ci0JCXRlbXAgJj0gfigxPDw4KTsKLQkJdGVtcCB8PSAoMTw8OSk7CisJCXRlbXAgJj0gflJBREVPTl9DRkdfVkdBX1JBTV9FTjsKKwkJdGVtcCB8PSBSQURFT05fQ0ZHX1ZHQV9JT19ESVM7CiAJfSBlbHNlIHsKLQkJdGVtcCAmPSB+KDE8PDkpOworCQl0ZW1wICY9IH5SQURFT05fQ0ZHX1ZHQV9JT19ESVM7CiAJfQogCVdSRUczMihSQURFT05fQ09ORklHX0NOVEwsIHRlbXApOwogfQpAQCAtMzUyMSw3ICszNTIyLDcgQEAKIAlpZiAoaSA8IHJkZXYtPnVzZWNfdGltZW91dCkgewogCQlEUk1fSU5GTygicmluZyB0ZXN0IHN1Y2NlZWRlZCBpbiAlZCB1c2Vjc1xuIiwgaSk7CiAJfSBlbHNlIHsKLQkJRFJNX0VSUk9SKCJyYWRlb246IHJpbmcgdGVzdCBmYWlsZWQgKHNyYWN0aCgweCUwNFgpPTB4JTA4WClcbiIsCisJCURSTV9FUlJPUigicmFkZW9uOiByaW5nIHRlc3QgZmFpbGVkIChzY3JhdGNoKDB4JTA0WCk9MHglMDhYKVxuIiwKIAkJCSAgc2NyYXRjaCwgdG1wKTsKIAkJciA9IC1FSU5WQUw7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yMzAwLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3IzMDAuYwppbmRleCBmYWU1ZTcwLi41NWZlNWJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3IzMDAuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3IzMDAuYwpAQCAtNjksNiArNjksOSBAQAogCW1iKCk7CiB9CiAKKyNkZWZpbmUgUjMwMF9QVEVfV1JJVEVBQkxFICgxIDw8IDIpCisjZGVmaW5lIFIzMDBfUFRFX1JFQURBQkxFICAoMSA8PCAzKQorCiBpbnQgcnYzNzBfcGNpZV9nYXJ0X3NldF9wYWdlKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LCBpbnQgaSwgdWludDY0X3QgYWRkcikKIHsKIAl2b2lkIF9faW9tZW0gKnB0ciA9ICh2b2lkICopcmRldi0+Z2FydC50YWJsZS52cmFtLnB0cjsKQEAgLTc4LDcgKzgxLDcgQEAKIAl9CiAJYWRkciA9IChsb3dlcl8zMl9iaXRzKGFkZHIpID4+IDgpIHwKIAkgICAgICAgKCh1cHBlcl8zMl9iaXRzKGFkZHIpICYgMHhmZikgPDwgMjQpIHwKLQkgICAgICAgMHhjOworCSAgICAgICBSMzAwX1BURV9XUklURUFCTEUgfCBSMzAwX1BURV9SRUFEQUJMRTsKIAkvKiBvbiB4ODYgd2Ugd2FudCB0aGlzIHRvIGJlIENQVSBlbmRpYW4sIG9uIHBvd2VycGMKIAkgKiBvbiBwb3dlcnBjIHdpdGhvdXQgSFcgc3dhcHBlcnMsIGl0J2xsIGdldCBzd2FwcGVkIG9uIHdheQogCSAqIGludG8gVlJBTSAtIHNvIG5vIG5lZWQgZm9yIGNwdV90b19sZTMyIG9uIFZSQU0gdGFibGVzICovCkBAIC0xMzUsNyArMTM4LDcgQEAKIAlXUkVHMzJfUENJRShSQURFT05fUENJRV9UWF9ESVNDQVJEX1JEX0FERFJfTE8sIHJkZXYtPm1jLnZyYW1fc3RhcnQpOwogCVdSRUczMl9QQ0lFKFJBREVPTl9QQ0lFX1RYX0RJU0NBUkRfUkRfQUREUl9ISSwgMCk7CiAJLyogQ2xlYXIgZXJyb3IgKi8KLQlXUkVHMzJfUENJRSgweDE4LCAwKTsKKwlXUkVHMzJfUENJRShSQURFT05fUENJRV9UWF9HQVJUX0VSUk9SLCAwKTsKIAl0bXAgPSBSUkVHMzJfUENJRShSQURFT05fUENJRV9UWF9HQVJUX0NOVEwpOwogCXRtcCB8PSBSQURFT05fUENJRV9UWF9HQVJUX0VOOwogCXRtcCB8PSBSQURFT05fUENJRV9UWF9HQVJUX1VOTUFQUEVEX0FDQ0VTU19ESVNDQVJEOwpAQCAtNDA1LDEyICs0MDgsMTMgQEAKIHsKIAlzdHJ1Y3QgcjEwMF9tY19zYXZlIHNhdmU7CiAJdTMyIHN0YXR1cywgdG1wOworCWludCByZXQgPSAwOwogCi0JcjEwMF9tY19zdG9wKHJkZXYsICZzYXZlKTsKIAlzdGF0dXMgPSBSUkVHMzIoUl8wMDBFNDBfUkJCTV9TVEFUVVMpOwogCWlmICghR18wMDBFNDBfR1VJX0FDVElWRShzdGF0dXMpKSB7CiAJCXJldHVybiAwOwogCX0KKwlyMTAwX21jX3N0b3AocmRldiwgJnNhdmUpOwogCXN0YXR1cyA9IFJSRUczMihSXzAwMEU0MF9SQkJNX1NUQVRVUyk7CiAJZGV2X2luZm8ocmRldi0+ZGV2LCAiKCVzOiVkKSBSQkJNX1NUQVRVUz0weCUwOFhcbiIsIF9fZnVuY19fLCBfX0xJTkVfXywgc3RhdHVzKTsKIAkvKiBzdG9wIENQICovCkBAIC00NTEsMTEgKzQ1NSwxMSBAQAogCWlmIChHXzAwMEU0MF9HQV9CVVNZKHN0YXR1cykgfHwgR18wMDBFNDBfVkFQX0JVU1koc3RhdHVzKSkgewogCQlkZXZfZXJyKHJkZXYtPmRldiwgImZhaWxlZCB0byByZXNldCBHUFVcbiIpOwogCQlyZGV2LT5ncHVfbG9ja3VwID0gdHJ1ZTsKLQkJcmV0dXJuIC0xOwotCX0KKwkJcmV0ID0gLTE7CisJfSBlbHNlCisJCWRldl9pbmZvKHJkZXYtPmRldiwgIkdQVSByZXNldCBzdWNjZWVkXG4iKTsKIAlyMTAwX21jX3Jlc3VtZShyZGV2LCAmc2F2ZSk7Ci0JZGV2X2luZm8ocmRldi0+ZGV2LCAiR1BVIHJlc2V0IHN1Y2NlZWRcbiIpOwotCXJldHVybiAwOworCXJldHVybiByZXQ7CiB9CiAKIC8qCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3I0MjAuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjQyMC5jCmluZGV4IGMzODczNDYuLjBiNTllZDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjQyMC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjQyMC5jCkBAIC05Niw3ICs5Niw3IEBACiAJCSAgICAgICAicHJvZ3JhbW1pbmcgcGlwZXMuIEJhZCB0aGluZ3MgbWlnaHQgaGFwcGVuLlxuIik7CiAJfQogCS8qIGdldCBtYXggbnVtYmVyIG9mIHBpcGVzICovCi0JZ2JfcGlwZV9zZWxlY3QgPSBSUkVHMzIoMHg0MDJDKTsKKwlnYl9waXBlX3NlbGVjdCA9IFJSRUczMihSNDAwX0dCX1BJUEVfU0VMRUNUKTsKIAludW1fcGlwZXMgPSAoKGdiX3BpcGVfc2VsZWN0ID4+IDEyKSAmIDMpICsgMTsKIAogCS8qIFNFIGNoaXBzIGhhdmUgMSBwaXBlICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3I1MjAuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjUyMC5jCmluZGV4IDNjODY3N2YuLjJjZTgwZDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjUyMC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjUyMC5jCkBAIC03OSw4ICs3OSw4IEBACiAJCVdSRUczMigweDQxMjgsIDB4RkYpOwogCX0KIAlyNDIwX3BpcGVzX2luaXQocmRldik7Ci0JZ2JfcGlwZV9zZWxlY3QgPSBSUkVHMzIoMHg0MDJDKTsKLQl0bXAgPSBSUkVHMzIoMHgxNzBDKTsKKwlnYl9waXBlX3NlbGVjdCA9IFJSRUczMihSNDAwX0dCX1BJUEVfU0VMRUNUKTsKKwl0bXAgPSBSUkVHMzIoUjMwMF9EU1RfUElQRV9DT05GSUcpOwogCXBpcGVfc2VsZWN0X2N1cnJlbnQgPSAodG1wID4+IDIpICYgMzsKIAl0bXAgPSAoMSA8PCBwaXBlX3NlbGVjdF9jdXJyZW50KSB8CiAJICAgICAgKCgoZ2JfcGlwZV9zZWxlY3QgPj4gOCkgJiAweEYpIDw8IDQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yNjAwLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3I2MDAuYwppbmRleCA2YjUwNzE2Li42NTA2NzJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3I2MDAuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3I2MDAuYwpAQCAtOTcsMTIgKzk3LDE2IEBACiBzdGF0aWMgdm9pZCByNjAwX3BjaWVfZ2VuMl9lbmFibGUoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpOwogCiAvKiBnZXQgdGVtcGVyYXR1cmUgaW4gbWlsbGlkZWdyZWVzICovCi11MzIgcnY2eHhfZ2V0X3RlbXAoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCitpbnQgcnY2eHhfZ2V0X3RlbXAoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiB7CiAJdTMyIHRlbXAgPSAoUlJFRzMyKENHX1RIRVJNQUxfU1RBVFVTKSAmIEFTSUNfVF9NQVNLKSA+PgogCQlBU0lDX1RfU0hJRlQ7CisJaW50IGFjdHVhbF90ZW1wID0gdGVtcCAmIDB4ZmY7CiAKLQlyZXR1cm4gdGVtcCAqIDEwMDA7CisJaWYgKHRlbXAgJiAweDEwMCkKKwkJYWN0dWFsX3RlbXAgLT0gMjU2OworCisJcmV0dXJuIGFjdHVhbF90ZW1wICogMTAwMDsKIH0KIAogdm9pZCByNjAwX3BtX2dldF9keW5wbV9zdGF0ZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKQEAgLTEyODcsNiArMTI5MSw5IEBACiAJCQlTXzAwODAxNF9DQjJfQlVTWSgxKSB8IFNfMDA4MDE0X0NCM19CVVNZKDEpOwogCXUzMiB0bXA7CiAKKwlpZiAoIShSUkVHMzIoR1JCTV9TVEFUVVMpICYgR1VJX0FDVElWRSkpCisJCXJldHVybiAwOworCiAJZGV2X2luZm8ocmRldi0+ZGV2LCAiR1BVIHNvZnRyZXNldCBcbiIpOwogCWRldl9pbmZvKHJkZXYtPmRldiwgIiAgUl8wMDgwMTBfR1JCTV9TVEFUVVM9MHglMDhYXG4iLAogCQlSUkVHMzIoUl8wMDgwMTBfR1JCTV9TVEFUVVMpKTsKQEAgLTIzNTgsMjQgKzIzNjUsNiBAQAogCS8qIEZJWE1FOiBpbXBsZW1lbnQgKi8KIH0KIAotCi1ib29sIHI2MDBfY2FyZF9wb3N0ZWQoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCi17Ci0JdWludDMyX3QgcmVnOwotCi0JLyogZmlyc3QgY2hlY2sgQ1JUQ3MgKi8KLQlyZWcgPSBSUkVHMzIoRDFDUlRDX0NPTlRST0wpIHwKLQkJUlJFRzMyKEQyQ1JUQ19DT05UUk9MKTsKLQlpZiAocmVnICYgQ1JUQ19FTikKLQkJcmV0dXJuIHRydWU7Ci0KLQkvKiB0aGVuIGNoZWNrIE1FTV9TSVpFLCBpbiBjYXNlIHRoZSBjcnRjcyBhcmUgb2ZmICovCi0JaWYgKFJSRUczMihDT05GSUdfTUVNU0laRSkpCi0JCXJldHVybiB0cnVlOwotCi0JcmV0dXJuIGZhbHNlOwotfQotCiBpbnQgcjYwMF9zdGFydHVwKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogewogCWludCByOwpAQCAtMjUzNiw3ICsyNTI1LDcgQEAKIAlpZiAocikKIAkJcmV0dXJuIHI7CiAJLyogUG9zdCBjYXJkIGlmIG5lY2Vzc2FyeSAqLwotCWlmICghcjYwMF9jYXJkX3Bvc3RlZChyZGV2KSkgeworCWlmICghcmFkZW9uX2NhcmRfcG9zdGVkKHJkZXYpKSB7CiAJCWlmICghcmRldi0+YmlvcykgewogCQkJZGV2X2VycihyZGV2LT5kZXYsICJDYXJkIG5vdCBwb3N0ZWQgYW5kIG5vIEJJT1MgLSBpZ25vcmluZ1xuIik7CiAJCQlyZXR1cm4gLUVJTlZBTDsKQEAgLTM2NTgsNiArMzY0Nyw5IEBACiAJdTMyIGxpbmtfd2lkdGhfY250bCwgbGFuZXMsIHNwZWVkX2NudGwsIHRyYWluaW5nX2NudGwsIHRtcDsKIAl1MTYgbGlua19jbnRsMjsKIAorCWlmIChyYWRlb25fcGNpZV9nZW4yID09IDApCisJCXJldHVybjsKKwogCWlmIChyZGV2LT5mbGFncyAmIFJBREVPTl9JU19JR1ApCiAJCXJldHVybjsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yNjAwX3JlZy5oIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yNjAwX3JlZy5oCmluZGV4IDMzY2RhMDEuLmY4Njk4OTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcjYwMF9yZWcuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3I2MDBfcmVnLmgKQEAgLTgxLDcgKzgxLDExIEBACiAjZGVmaW5lIFI2MDBfTUVESVVNX1ZJRF9MT1dFUl9HUElPX0NOVEwgICAgICAgICAgICAgICAgICAgICAgICAgICAgMHg3MjAKICNkZWZpbmUgUjYwMF9MT1dfVklEX0xPV0VSX0dQSU9fQ05UTCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAweDcyNAogCi0KKyNkZWZpbmUgUjYwMF9EMUdSUEhfU1dBUF9DT05UUk9MICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDB4NjEwQworIyAgICAgICBkZWZpbmUgUjYwMF9EMUdSUEhfU1dBUF9FTkRJQU5fTk9ORSAgICAgICAgICAgICAgICAgICAgKDAgPDwgMCkKKyMgICAgICAgZGVmaW5lIFI2MDBfRDFHUlBIX1NXQVBfRU5ESUFOXzE2QklUICAgICAgICAgICAgICAgICAgICgxIDw8IDApCisjICAgICAgIGRlZmluZSBSNjAwX0QxR1JQSF9TV0FQX0VORElBTl8zMkJJVCAgICAgICAgICAgICAgICAgICAoMiA8PCAwKQorIyAgICAgICBkZWZpbmUgUjYwMF9EMUdSUEhfU1dBUF9FTkRJQU5fNjRCSVQgICAgICAgICAgICAgICAgICAgKDMgPDwgMCkKIAogI2RlZmluZSBSNjAwX0hEUF9OT05TVVJGQUNFX0JBU0UgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDB4MmMwNAogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbi5oIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb24uaAppbmRleCBlOTQ4NjYzLi41NmM0OGI2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uLmgKQEAgLTkyLDYgKzkyLDcgQEAKIGV4dGVybiBpbnQgcmFkZW9uX2F1ZGlvOwogZXh0ZXJuIGludCByYWRlb25fZGlzcF9wcmlvcml0eTsKIGV4dGVybiBpbnQgcmFkZW9uX2h3X2kyYzsKK2V4dGVybiBpbnQgcmFkZW9uX3BjaWVfZ2VuMjsKIAogLyoKICAqIENvcHkgZnJvbSByYWRlb25fZHJ2Lmggc28gd2UgZG9uJ3QgaGF2ZSB0byBpbmNsdWRlIGJvdGggYW5kIGhhdmUgY29uZmxpY3RpbmcKQEAgLTE3OCwxMCArMTc5LDEwIEBACiB2b2lkIHJhZGVvbl9hdG9tYmlvc19nZXRfcG93ZXJfbW9kZXMoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpOwogdm9pZCByYWRlb25fYXRvbV9zZXRfdm9sdGFnZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgdTE2IGxldmVsKTsKIHZvaWQgcnM2OTBfcG1faW5mbyhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7Ci1leHRlcm4gdTMyIHJ2Nnh4X2dldF90ZW1wKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KTsKLWV4dGVybiB1MzIgcnY3NzBfZ2V0X3RlbXAoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpOwotZXh0ZXJuIHUzMiBldmVyZ3JlZW5fZ2V0X3RlbXAoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpOwotZXh0ZXJuIHUzMiBzdW1vX2dldF90ZW1wKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KTsKK2V4dGVybiBpbnQgcnY2eHhfZ2V0X3RlbXAoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpOworZXh0ZXJuIGludCBydjc3MF9nZXRfdGVtcChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CitleHRlcm4gaW50IGV2ZXJncmVlbl9nZXRfdGVtcChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CitleHRlcm4gaW50IHN1bW9fZ2V0X3RlbXAoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpOwogCiAvKgogICogRmVuY2VzLgpAQCAtODExLDggKzgxMiw3IEBACiAJZml4ZWQyMF8xMgkJc2NsazsKIAlmaXhlZDIwXzEyCQltY2xrOwogCWZpeGVkMjBfMTIJCW5lZWRlZF9iYW5kd2lkdGg7Ci0JLyogWFhYOiB1c2UgYSBkZWZpbmUgZm9yIG51bSBwb3dlciBtb2RlcyAqLwotCXN0cnVjdCByYWRlb25fcG93ZXJfc3RhdGUgcG93ZXJfc3RhdGVbOF07CisJc3RydWN0IHJhZGVvbl9wb3dlcl9zdGF0ZSAqcG93ZXJfc3RhdGU7CiAJLyogbnVtYmVyIG9mIHZhbGlkIHBvd2VyIHN0YXRlcyAqLwogCWludCAgICAgICAgICAgICAgICAgICAgIG51bV9wb3dlcl9zdGF0ZXM7CiAJaW50ICAgICAgICAgICAgICAgICAgICAgY3VycmVudF9wb3dlcl9zdGF0ZV9pbmRleDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2FzaWMuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2FzaWMuYwppbmRleCAzYTFiMTYxLi5lNzVkNjNiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9hc2ljLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fYXNpYy5jCkBAIC03NTksNyArNzU5LDcgQEAKIAkuZ2FydF90bGJfZmx1c2ggPSAmZXZlcmdyZWVuX3BjaWVfZ2FydF90bGJfZmx1c2gsCiAJLmdhcnRfc2V0X3BhZ2UgPSAmcnM2MDBfZ2FydF9zZXRfcGFnZSwKIAkucmluZ190ZXN0ID0gJnI2MDBfcmluZ190ZXN0LAotCS5yaW5nX2liX2V4ZWN1dGUgPSAmcjYwMF9yaW5nX2liX2V4ZWN1dGUsCisJLnJpbmdfaWJfZXhlY3V0ZSA9ICZldmVyZ3JlZW5fcmluZ19pYl9leGVjdXRlLAogCS5pcnFfc2V0ID0gJmV2ZXJncmVlbl9pcnFfc2V0LAogCS5pcnFfcHJvY2VzcyA9ICZldmVyZ3JlZW5faXJxX3Byb2Nlc3MsCiAJLmdldF92YmxhbmtfY291bnRlciA9ICZldmVyZ3JlZW5fZ2V0X3ZibGFua19jb3VudGVyLApAQCAtODA1LDcgKzgwNSw3IEBACiAJLmdhcnRfdGxiX2ZsdXNoID0gJmV2ZXJncmVlbl9wY2llX2dhcnRfdGxiX2ZsdXNoLAogCS5nYXJ0X3NldF9wYWdlID0gJnJzNjAwX2dhcnRfc2V0X3BhZ2UsCiAJLnJpbmdfdGVzdCA9ICZyNjAwX3JpbmdfdGVzdCwKLQkucmluZ19pYl9leGVjdXRlID0gJnI2MDBfcmluZ19pYl9leGVjdXRlLAorCS5yaW5nX2liX2V4ZWN1dGUgPSAmZXZlcmdyZWVuX3JpbmdfaWJfZXhlY3V0ZSwKIAkuaXJxX3NldCA9ICZldmVyZ3JlZW5faXJxX3NldCwKIAkuaXJxX3Byb2Nlc3MgPSAmZXZlcmdyZWVuX2lycV9wcm9jZXNzLAogCS5nZXRfdmJsYW5rX2NvdW50ZXIgPSAmZXZlcmdyZWVuX2dldF92YmxhbmtfY291bnRlciwKQEAgLTg0OCw3ICs4NDgsNyBAQAogCS5nYXJ0X3RsYl9mbHVzaCA9ICZldmVyZ3JlZW5fcGNpZV9nYXJ0X3RsYl9mbHVzaCwKIAkuZ2FydF9zZXRfcGFnZSA9ICZyczYwMF9nYXJ0X3NldF9wYWdlLAogCS5yaW5nX3Rlc3QgPSAmcjYwMF9yaW5nX3Rlc3QsCi0JLnJpbmdfaWJfZXhlY3V0ZSA9ICZyNjAwX3JpbmdfaWJfZXhlY3V0ZSwKKwkucmluZ19pYl9leGVjdXRlID0gJmV2ZXJncmVlbl9yaW5nX2liX2V4ZWN1dGUsCiAJLmlycV9zZXQgPSAmZXZlcmdyZWVuX2lycV9zZXQsCiAJLmlycV9wcm9jZXNzID0gJmV2ZXJncmVlbl9pcnFfcHJvY2VzcywKIAkuZ2V0X3ZibGFua19jb3VudGVyID0gJmV2ZXJncmVlbl9nZXRfdmJsYW5rX2NvdW50ZXIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9hc2ljLmggYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9hc2ljLmgKaW5kZXggZTAxZjA3NzEuLmM1OWJkOTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2FzaWMuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9hc2ljLmgKQEAgLTM1NSw2ICszNTUsNyBAQAogYm9vbCBldmVyZ3JlZW5fZ3B1X2lzX2xvY2t1cChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7CiBpbnQgZXZlcmdyZWVuX2FzaWNfcmVzZXQoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpOwogdm9pZCBldmVyZ3JlZW5fYmFuZHdpZHRoX3VwZGF0ZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7Cit2b2lkIGV2ZXJncmVlbl9yaW5nX2liX2V4ZWN1dGUoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsIHN0cnVjdCByYWRlb25faWIgKmliKTsKIGludCBldmVyZ3JlZW5fY29weV9ibGl0KHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LAogCQkJdWludDY0X3Qgc3JjX29mZnNldCwgdWludDY0X3QgZHN0X29mZnNldCwKIAkJCXVuc2lnbmVkIG51bV9wYWdlcywgc3RydWN0IHJhZGVvbl9mZW5jZSAqZmVuY2UpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fYXRvbWJpb3MuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2F0b21iaW9zLmMKaW5kZXggMTU3MzIwMi4uNWMxY2M3YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fYXRvbWJpb3MuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9hdG9tYmlvcy5jCkBAIC0zODcsMTUgKzM4NywxMSBAQAogCQkJKmxpbmVfbXV4ID0gMHg5MDsKIAl9CiAKLQkvKiBtYWMgcnY2MzAgKi8KLQlpZiAoKGRldi0+cGRldi0+ZGV2aWNlID09IDB4OTU4OCkgJiYKLQkgICAgKGRldi0+cGRldi0+c3Vic3lzdGVtX3ZlbmRvciA9PSAweDEwNmIpICYmCi0JICAgIChkZXYtPnBkZXYtPnN1YnN5c3RlbV9kZXZpY2UgPT0gMHgwMGE2KSkgewotCQlpZiAoKHN1cHBvcnRlZF9kZXZpY2UgPT0gQVRPTV9ERVZJQ0VfVFYxX1NVUFBPUlQpICYmCi0JCSAgICAoKmNvbm5lY3Rvcl90eXBlID09IERSTV9NT0RFX0NPTk5FQ1RPUl9EVklJKSkgewotCQkJKmNvbm5lY3Rvcl90eXBlID0gRFJNX01PREVfQ09OTkVDVE9SXzlQaW5ESU47Ci0JCQkqbGluZV9tdXggPSBDT05ORUNUT1JfN1BJTl9ESU5fRU5VTV9JRDE7Ci0JCX0KKwkvKiBtYWMgcnY2MzAsIHJ2NzMwLCBvdGhlcnMgKi8KKwlpZiAoKHN1cHBvcnRlZF9kZXZpY2UgPT0gQVRPTV9ERVZJQ0VfVFYxX1NVUFBPUlQpICYmCisJICAgICgqY29ubmVjdG9yX3R5cGUgPT0gRFJNX01PREVfQ09OTkVDVE9SX0RWSUkpKSB7CisJCSpjb25uZWN0b3JfdHlwZSA9IERSTV9NT0RFX0NPTk5FQ1RPUl85UGluRElOOworCQkqbGluZV9tdXggPSBDT05ORUNUT1JfN1BJTl9ESU5fRU5VTV9JRDE7CiAJfQogCiAJLyogQVNVUyBIRCAzNjAwIFhUIGJvYXJkIGxpc3RzIHRoZSBEVkkgcG9ydCBhcyBIRE1JICovCkBAIC0xMTY3LDE2ICsxMTYzLDYgQEAKIAkJCQlwMXBsbC0+cGxsX291dF9taW4gPSA2NDgwMDsKIAkJCWVsc2UKIAkJCQlwMXBsbC0+cGxsX291dF9taW4gPSAyMDAwMDsKLQkJfSBlbHNlIGlmIChwMXBsbC0+cGxsX291dF9taW4gPiA2NDgwMCkgewotCQkJLyogTGltaXRpbmcgdGhlIHBsbCBvdXRwdXQgcmFuZ2UgaXMgYSBnb29kIHRoaW5nIGdlbmVyYWxseSBhcwotCQkJICogaXQgbGltaXRzIHRoZSBudW1iZXIgb2YgcG9zc2libGUgcGxsIGNvbWJpbmF0aW9ucyBmb3IgYSBnaXZlbgotCQkJICogZnJlcXVlbmN5IHByZXN1bWFibHkgdG8gdGhlIG9uZXMgdGhhdCB3b3JrIGJlc3Qgb24gZWFjaCBjYXJkLgotCQkJICogSG93ZXZlciwgY2VydGFpbiBkdWFsbGluayBEVkkgbW9uaXRvcnMgc2VlbSB0byBsaWtlCi0JCQkgKiBwbGwgY29tYmluYXRpb25zIHRoYXQgd291bGQgYmUgbGltaXRlZCBieSB0aGlzIGF0IGxlYXN0IG9uCi0JCQkgKiBwcmUtRENFIDMuMCByNnh4IGhhcmR3YXJlLiAgVGhpcyBtaWdodCBuZWVkIHRvIGJlIGFkanVzdGVkIHBlcgotCQkJICogZmFtaWx5LgotCQkJICovCi0JCQlwMXBsbC0+cGxsX291dF9taW4gPSA2NDgwMDsKIAkJfQogCiAJCXAxcGxsLT5wbGxfaW5fbWluID0KQEAgLTE5OTEsNiArMTk3Nyw5IEBACiAJbnVtX21vZGVzID0gcG93ZXJfaW5mby0+aW5mby51Y051bU9mUG93ZXJNb2RlRW50cmllczsKIAlpZiAobnVtX21vZGVzID4gQVRPTV9NQVhfTlVNQkVST0ZfUE9XRVJfQkxPQ0spCiAJCW51bV9tb2RlcyA9IEFUT01fTUFYX05VTUJFUk9GX1BPV0VSX0JMT0NLOworCXJkZXYtPnBtLnBvd2VyX3N0YXRlID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHJhZGVvbl9wb3dlcl9zdGF0ZSkgKiBudW1fbW9kZXMsIEdGUF9LRVJORUwpOworCWlmICghcmRldi0+cG0ucG93ZXJfc3RhdGUpCisJCXJldHVybiBzdGF0ZV9pbmRleDsKIAkvKiBsYXN0IG1vZGUgaXMgdXN1YWxseSBkZWZhdWx0LCBhcnJheSBpcyBsb3cgdG8gaGlnaCAqLwogCWZvciAoaSA9IDA7IGkgPCBudW1fbW9kZXM7IGkrKykgewogCQlyZGV2LT5wbS5wb3dlcl9zdGF0ZVtzdGF0ZV9pbmRleF0uY2xvY2tfaW5mb1swXS52b2x0YWdlLnR5cGUgPSBWT0xUQUdFX05PTkU7CkBAIC0yMzQyLDYgKzIzMzEsMTAgQEAKIAlwb3dlcl9pbmZvID0gKHVuaW9uIHBvd2VyX2luZm8gKikobW9kZV9pbmZvLT5hdG9tX2NvbnRleHQtPmJpb3MgKyBkYXRhX29mZnNldCk7CiAKIAlyYWRlb25fYXRvbWJpb3NfYWRkX3BwbGliX3RoZXJtYWxfY29udHJvbGxlcihyZGV2LCAmcG93ZXJfaW5mby0+cHBsaWIuc1RoZXJtYWxDb250cm9sbGVyKTsKKwlyZGV2LT5wbS5wb3dlcl9zdGF0ZSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCByYWRlb25fcG93ZXJfc3RhdGUpICoKKwkJCQkgICAgICAgcG93ZXJfaW5mby0+cHBsaWIudWNOdW1TdGF0ZXMsIEdGUF9LRVJORUwpOworCWlmICghcmRldi0+cG0ucG93ZXJfc3RhdGUpCisJCXJldHVybiBzdGF0ZV9pbmRleDsKIAkvKiBmaXJzdCBtb2RlIGlzIHVzdWFsbHkgZGVmYXVsdCwgZm9sbG93ZWQgYnkgbG93IHRvIGhpZ2ggKi8KIAlmb3IgKGkgPSAwOyBpIDwgcG93ZXJfaW5mby0+cHBsaWIudWNOdW1TdGF0ZXM7IGkrKykgewogCQltb2RlX2luZGV4ID0gMDsKQEAgLTI0MjIsNiArMjQxNSwxMCBAQAogCW5vbl9jbG9ja19pbmZvX2FycmF5ID0gKHN0cnVjdCBOb25DbG9ja0luZm9BcnJheSAqKQogCQkobW9kZV9pbmZvLT5hdG9tX2NvbnRleHQtPmJpb3MgKyBkYXRhX29mZnNldCArCiAJCSBwb3dlcl9pbmZvLT5wcGxpYi51c05vbkNsb2NrSW5mb0FycmF5T2Zmc2V0KTsKKwlyZGV2LT5wbS5wb3dlcl9zdGF0ZSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCByYWRlb25fcG93ZXJfc3RhdGUpICoKKwkJCQkgICAgICAgc3RhdGVfYXJyYXktPnVjTnVtRW50cmllcywgR0ZQX0tFUk5FTCk7CisJaWYgKCFyZGV2LT5wbS5wb3dlcl9zdGF0ZSkKKwkJcmV0dXJuIHN0YXRlX2luZGV4OwogCWZvciAoaSA9IDA7IGkgPCBzdGF0ZV9hcnJheS0+dWNOdW1FbnRyaWVzOyBpKyspIHsKIAkJbW9kZV9pbmRleCA9IDA7CiAJCXBvd2VyX3N0YXRlID0gKHVuaW9uIHBwbGliX3Bvd2VyX3N0YXRlICopJnN0YXRlX2FycmF5LT5zdGF0ZXNbaV07CkBAIC0yNDk1LDE5ICsyNDkyLDIyIEBACiAJCQlicmVhazsKIAkJfQogCX0gZWxzZSB7Ci0JCS8qIGFkZCB0aGUgZGVmYXVsdCBtb2RlICovCi0JCXJkZXYtPnBtLnBvd2VyX3N0YXRlW3N0YXRlX2luZGV4XS50eXBlID0KLQkJCVBPV0VSX1NUQVRFX1RZUEVfREVGQVVMVDsKLQkJcmRldi0+cG0ucG93ZXJfc3RhdGVbc3RhdGVfaW5kZXhdLm51bV9jbG9ja19tb2RlcyA9IDE7Ci0JCXJkZXYtPnBtLnBvd2VyX3N0YXRlW3N0YXRlX2luZGV4XS5jbG9ja19pbmZvWzBdLm1jbGsgPSByZGV2LT5jbG9jay5kZWZhdWx0X21jbGs7Ci0JCXJkZXYtPnBtLnBvd2VyX3N0YXRlW3N0YXRlX2luZGV4XS5jbG9ja19pbmZvWzBdLnNjbGsgPSByZGV2LT5jbG9jay5kZWZhdWx0X3NjbGs7Ci0JCXJkZXYtPnBtLnBvd2VyX3N0YXRlW3N0YXRlX2luZGV4XS5kZWZhdWx0X2Nsb2NrX21vZGUgPQotCQkJJnJkZXYtPnBtLnBvd2VyX3N0YXRlW3N0YXRlX2luZGV4XS5jbG9ja19pbmZvWzBdOwotCQlyZGV2LT5wbS5wb3dlcl9zdGF0ZVtzdGF0ZV9pbmRleF0uY2xvY2tfaW5mb1swXS52b2x0YWdlLnR5cGUgPSBWT0xUQUdFX05PTkU7Ci0JCXJkZXYtPnBtLnBvd2VyX3N0YXRlW3N0YXRlX2luZGV4XS5wY2llX2xhbmVzID0gMTY7Ci0JCXJkZXYtPnBtLmRlZmF1bHRfcG93ZXJfc3RhdGVfaW5kZXggPSBzdGF0ZV9pbmRleDsKLQkJcmRldi0+cG0ucG93ZXJfc3RhdGVbc3RhdGVfaW5kZXhdLmZsYWdzID0gMDsKLQkJc3RhdGVfaW5kZXgrKzsKKwkJcmRldi0+cG0ucG93ZXJfc3RhdGUgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgcmFkZW9uX3Bvd2VyX3N0YXRlKSwgR0ZQX0tFUk5FTCk7CisJCWlmIChyZGV2LT5wbS5wb3dlcl9zdGF0ZSkgeworCQkJLyogYWRkIHRoZSBkZWZhdWx0IG1vZGUgKi8KKwkJCXJkZXYtPnBtLnBvd2VyX3N0YXRlW3N0YXRlX2luZGV4XS50eXBlID0KKwkJCQlQT1dFUl9TVEFURV9UWVBFX0RFRkFVTFQ7CisJCQlyZGV2LT5wbS5wb3dlcl9zdGF0ZVtzdGF0ZV9pbmRleF0ubnVtX2Nsb2NrX21vZGVzID0gMTsKKwkJCXJkZXYtPnBtLnBvd2VyX3N0YXRlW3N0YXRlX2luZGV4XS5jbG9ja19pbmZvWzBdLm1jbGsgPSByZGV2LT5jbG9jay5kZWZhdWx0X21jbGs7CisJCQlyZGV2LT5wbS5wb3dlcl9zdGF0ZVtzdGF0ZV9pbmRleF0uY2xvY2tfaW5mb1swXS5zY2xrID0gcmRldi0+Y2xvY2suZGVmYXVsdF9zY2xrOworCQkJcmRldi0+cG0ucG93ZXJfc3RhdGVbc3RhdGVfaW5kZXhdLmRlZmF1bHRfY2xvY2tfbW9kZSA9CisJCQkJJnJkZXYtPnBtLnBvd2VyX3N0YXRlW3N0YXRlX2luZGV4XS5jbG9ja19pbmZvWzBdOworCQkJcmRldi0+cG0ucG93ZXJfc3RhdGVbc3RhdGVfaW5kZXhdLmNsb2NrX2luZm9bMF0udm9sdGFnZS50eXBlID0gVk9MVEFHRV9OT05FOworCQkJcmRldi0+cG0ucG93ZXJfc3RhdGVbc3RhdGVfaW5kZXhdLnBjaWVfbGFuZXMgPSAxNjsKKwkJCXJkZXYtPnBtLmRlZmF1bHRfcG93ZXJfc3RhdGVfaW5kZXggPSBzdGF0ZV9pbmRleDsKKwkJCXJkZXYtPnBtLnBvd2VyX3N0YXRlW3N0YXRlX2luZGV4XS5mbGFncyA9IDA7CisJCQlzdGF0ZV9pbmRleCsrOworCQl9CiAJfQogCiAJcmRldi0+cG0ubnVtX3Bvd2VyX3N0YXRlcyA9IHN0YXRlX2luZGV4OwpAQCAtMjYyMyw3ICsyNjIzLDcgQEAKIAliaW9zXzJfc2NyYXRjaCAmPSB+QVRPTV9TMl9WUklfQlJJR0hUX0VOQUJMRTsKIAogCS8qIHRlbGwgdGhlIGJpb3Mgbm90IHRvIGhhbmRsZSBtb2RlIHN3aXRjaGluZyAqLwotCWJpb3NfNl9zY3JhdGNoIHw9IChBVE9NX1M2X0FDQ19CTE9DS19ESVNQTEFZX1NXSVRDSCB8IEFUT01fUzZfQUNDX01PREUpOworCWJpb3NfNl9zY3JhdGNoIHw9IEFUT01fUzZfQUNDX0JMT0NLX0RJU1BMQVlfU1dJVENIOwogCiAJaWYgKHJkZXYtPmZhbWlseSA+PSBDSElQX1I2MDApIHsKIAkJV1JFRzMyKFI2MDBfQklPU18yX1NDUkFUQ0gsIGJpb3NfMl9zY3JhdGNoKTsKQEAgLTI2NzQsMTAgKzI2NzQsMTMgQEAKIAllbHNlCiAJCWJpb3NfNl9zY3JhdGNoID0gUlJFRzMyKFJBREVPTl9CSU9TXzZfU0NSQVRDSCk7CiAKLQlpZiAobG9jaykKKwlpZiAobG9jaykgewogCQliaW9zXzZfc2NyYXRjaCB8PSBBVE9NX1M2X0NSSVRJQ0FMX1NUQVRFOwotCWVsc2UKKwkJYmlvc182X3NjcmF0Y2ggJj0gfkFUT01fUzZfQUNDX01PREU7CisJfSBlbHNlIHsKIAkJYmlvc182X3NjcmF0Y2ggJj0gfkFUT01fUzZfQ1JJVElDQUxfU1RBVEU7CisJCWJpb3NfNl9zY3JhdGNoIHw9IEFUT01fUzZfQUNDX01PREU7CisJfQogCiAJaWYgKHJkZXYtPmZhbWlseSA+PSBDSElQX1I2MDApCiAJCVdSRUczMihSNjAwX0JJT1NfNl9TQ1JBVENILCBiaW9zXzZfc2NyYXRjaCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9jb21iaW9zLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9jb21iaW9zLmMKaW5kZXggNTkxZmNhZS4uZDI3ZWY3NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fY29tYmlvcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2NvbWJpb3MuYwpAQCAtMjQ0Miw2ICsyNDQyLDE3IEBACiAKIAlyZGV2LT5wbS5kZWZhdWx0X3Bvd2VyX3N0YXRlX2luZGV4ID0gLTE7CiAKKwkvKiBhbGxvY2F0ZSAyIHBvd2VyIHN0YXRlcyAqLworCXJkZXYtPnBtLnBvd2VyX3N0YXRlID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHJhZGVvbl9wb3dlcl9zdGF0ZSkgKiAyLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXJkZXYtPnBtLnBvd2VyX3N0YXRlKSB7CisJCXJkZXYtPnBtLmRlZmF1bHRfcG93ZXJfc3RhdGVfaW5kZXggPSBzdGF0ZV9pbmRleDsKKwkJcmRldi0+cG0ubnVtX3Bvd2VyX3N0YXRlcyA9IDA7CisKKwkJcmRldi0+cG0uY3VycmVudF9wb3dlcl9zdGF0ZV9pbmRleCA9IHJkZXYtPnBtLmRlZmF1bHRfcG93ZXJfc3RhdGVfaW5kZXg7CisJCXJkZXYtPnBtLmN1cnJlbnRfY2xvY2tfbW9kZV9pbmRleCA9IDA7CisJCXJldHVybjsKKwl9CisKIAlpZiAocmRldi0+ZmxhZ3MgJiBSQURFT05fSVNfTU9CSUxJVFkpIHsKIAkJb2Zmc2V0ID0gY29tYmlvc19nZXRfdGFibGVfb2Zmc2V0KGRldiwgQ09NQklPU19QT1dFUlBMQVlfSU5GT19UQUJMRSk7CiAJCWlmIChvZmZzZXQpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2RldmljZS5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZGV2aWNlLmMKaW5kZXggMjYwOTFkNi4uMGQ0Nzg5MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZGV2aWNlLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZGV2aWNlLmMKQEAgLTg5MSw5ICs4OTEsOSBAQAogCQlwY2lfZGlzYWJsZV9kZXZpY2UoZGV2LT5wZGV2KTsKIAkJcGNpX3NldF9wb3dlcl9zdGF0ZShkZXYtPnBkZXYsIFBDSV9EM2hvdCk7CiAJfQotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlyYWRlb25fZmJkZXZfc2V0X3N1c3BlbmQocmRldiwgMSk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTkwNSwxMSArOTA1LDExIEBACiAJaWYgKGRldi0+c3dpdGNoX3Bvd2VyX3N0YXRlID09IERSTV9TV0lUQ0hfUE9XRVJfT0ZGKQogCQlyZXR1cm4gMDsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlwY2lfc2V0X3Bvd2VyX3N0YXRlKGRldi0+cGRldiwgUENJX0QwKTsKIAlwY2lfcmVzdG9yZV9zdGF0ZShkZXYtPnBkZXYpOwogCWlmIChwY2lfZW5hYmxlX2RldmljZShkZXYtPnBkZXYpKSB7Ci0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAkJcmV0dXJuIC0xOwogCX0KIAlwY2lfc2V0X21hc3RlcihkZXYtPnBkZXYpOwpAQCAtOTIwLDcgKzkyMCw3IEBACiAJcmFkZW9uX3Jlc3RvcmVfYmlvc19zY3JhdGNoX3JlZ3MocmRldik7CiAKIAlyYWRlb25fZmJkZXZfc2V0X3N1c3BlbmQocmRldiwgMCk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAkvKiByZXNldCBocGQgc3RhdGUgKi8KIAlyYWRlb25faHBkX2luaXQocmRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kaXNwbGF5LmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kaXNwbGF5LmMKaW5kZXggZDI2ZGFiZi4uMmVmZjk4YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZGlzcGxheS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2Rpc3BsYXkuYwpAQCAtNzgwLDYgKzc4MCwxMTUgQEAKIAlyZXR1cm4gcmV0OwogfQogCisvKiBhdml2byAqLworc3RhdGljIHZvaWQgYXZpdm9fZ2V0X2ZiX2RpdihzdHJ1Y3QgcmFkZW9uX3BsbCAqcGxsLAorCQkJICAgICB1MzIgdGFyZ2V0X2Nsb2NrLAorCQkJICAgICB1MzIgcG9zdF9kaXYsCisJCQkgICAgIHUzMiByZWZfZGl2LAorCQkJICAgICB1MzIgKmZiX2RpdiwKKwkJCSAgICAgdTMyICpmcmFjX2ZiX2RpdikKK3sKKwl1MzIgdG1wID0gcG9zdF9kaXYgKiByZWZfZGl2OworCisJdG1wICo9IHRhcmdldF9jbG9jazsKKwkqZmJfZGl2ID0gdG1wIC8gcGxsLT5yZWZlcmVuY2VfZnJlcTsKKwkqZnJhY19mYl9kaXYgPSB0bXAgJSBwbGwtPnJlZmVyZW5jZV9mcmVxOworfQorCitzdGF0aWMgdTMyIGF2aXZvX2dldF9wb3N0X2RpdihzdHJ1Y3QgcmFkZW9uX3BsbCAqcGxsLAorCQkJICAgICAgdTMyIHRhcmdldF9jbG9jaykKK3sKKwl1MzIgdmNvLCBwb3N0X2RpdiwgdG1wOworCisJaWYgKHBsbC0+ZmxhZ3MgJiBSQURFT05fUExMX1VTRV9QT1NUX0RJVikKKwkJcmV0dXJuIHBsbC0+cG9zdF9kaXY7CisKKwlpZiAocGxsLT5mbGFncyAmIFJBREVPTl9QTExfUFJFRkVSX01JTk1fT1ZFUl9NQVhQKSB7CisJCWlmIChwbGwtPmZsYWdzICYgUkFERU9OX1BMTF9JU19MQ0QpCisJCQl2Y28gPSBwbGwtPmxjZF9wbGxfb3V0X21pbjsKKwkJZWxzZQorCQkJdmNvID0gcGxsLT5wbGxfb3V0X21pbjsKKwl9IGVsc2UgeworCQlpZiAocGxsLT5mbGFncyAmIFJBREVPTl9QTExfSVNfTENEKQorCQkJdmNvID0gcGxsLT5sY2RfcGxsX291dF9tYXg7CisJCWVsc2UKKwkJCXZjbyA9IHBsbC0+cGxsX291dF9tYXg7CisJfQorCisJcG9zdF9kaXYgPSB2Y28gLyB0YXJnZXRfY2xvY2s7CisJdG1wID0gdmNvICUgdGFyZ2V0X2Nsb2NrOworCisJaWYgKHBsbC0+ZmxhZ3MgJiBSQURFT05fUExMX1BSRUZFUl9NSU5NX09WRVJfTUFYUCkgeworCQlpZiAodG1wKQorCQkJcG9zdF9kaXYrKzsKKwl9IGVsc2UgeworCQlpZiAoIXRtcCkKKwkJCXBvc3RfZGl2LS07CisJfQorCisJcmV0dXJuIHBvc3RfZGl2OworfQorCisjZGVmaW5lIE1BWF9UT0xFUkFOQ0UgMTAKKwordm9pZCByYWRlb25fY29tcHV0ZV9wbGxfYXZpdm8oc3RydWN0IHJhZGVvbl9wbGwgKnBsbCwKKwkJCSAgICAgIHUzMiBmcmVxLAorCQkJICAgICAgdTMyICpkb3RfY2xvY2tfcCwKKwkJCSAgICAgIHUzMiAqZmJfZGl2X3AsCisJCQkgICAgICB1MzIgKmZyYWNfZmJfZGl2X3AsCisJCQkgICAgICB1MzIgKnJlZl9kaXZfcCwKKwkJCSAgICAgIHUzMiAqcG9zdF9kaXZfcCkKK3sKKwl1MzIgdGFyZ2V0X2Nsb2NrID0gZnJlcSAvIDEwOworCXUzMiBwb3N0X2RpdiA9IGF2aXZvX2dldF9wb3N0X2RpdihwbGwsIHRhcmdldF9jbG9jayk7CisJdTMyIHJlZl9kaXYgPSBwbGwtPm1pbl9yZWZfZGl2OworCXUzMiBmYl9kaXYgPSAwLCBmcmFjX2ZiX2RpdiA9IDAsIHRtcDsKKworCWlmIChwbGwtPmZsYWdzICYgUkFERU9OX1BMTF9VU0VfUkVGX0RJVikKKwkJcmVmX2RpdiA9IHBsbC0+cmVmZXJlbmNlX2RpdjsKKworCWlmIChwbGwtPmZsYWdzICYgUkFERU9OX1BMTF9VU0VfRlJBQ19GQl9ESVYpIHsKKwkJYXZpdm9fZ2V0X2ZiX2RpdihwbGwsIHRhcmdldF9jbG9jaywgcG9zdF9kaXYsIHJlZl9kaXYsICZmYl9kaXYsICZmcmFjX2ZiX2Rpdik7CisJCWZyYWNfZmJfZGl2ID0gKDEwMCAqIGZyYWNfZmJfZGl2KSAvIHBsbC0+cmVmZXJlbmNlX2ZyZXE7CisJCWlmIChmcmFjX2ZiX2RpdiA+PSA1KSB7CisJCQlmcmFjX2ZiX2RpdiAtPSA1OworCQkJZnJhY19mYl9kaXYgPSBmcmFjX2ZiX2RpdiAvIDEwOworCQkJZnJhY19mYl9kaXYrKzsKKwkJfQorCQlpZiAoZnJhY19mYl9kaXYgPj0gMTApIHsKKwkJCWZiX2RpdisrOworCQkJZnJhY19mYl9kaXYgPSAwOworCQl9CisJfSBlbHNlIHsKKwkJd2hpbGUgKHJlZl9kaXYgPD0gcGxsLT5tYXhfcmVmX2RpdikgeworCQkJYXZpdm9fZ2V0X2ZiX2RpdihwbGwsIHRhcmdldF9jbG9jaywgcG9zdF9kaXYsIHJlZl9kaXYsCisJCQkJCSAmZmJfZGl2LCAmZnJhY19mYl9kaXYpOworCQkJaWYgKGZyYWNfZmJfZGl2ID49IChwbGwtPnJlZmVyZW5jZV9mcmVxIC8gMikpCisJCQkJZmJfZGl2Kys7CisJCQlmcmFjX2ZiX2RpdiA9IDA7CisJCQl0bXAgPSAocGxsLT5yZWZlcmVuY2VfZnJlcSAqIGZiX2RpdikgLyAocG9zdF9kaXYgKiByZWZfZGl2KTsKKwkJCXRtcCA9ICh0bXAgKiAxMDAwMCkgLyB0YXJnZXRfY2xvY2s7CisKKwkJCWlmICh0bXAgPiAoMTAwMDAgKyBNQVhfVE9MRVJBTkNFKSkKKwkJCQlyZWZfZGl2Kys7CisJCQllbHNlIGlmICh0bXAgPj0gKDEwMDAwIC0gTUFYX1RPTEVSQU5DRSkpCisJCQkJYnJlYWs7CisJCQllbHNlCisJCQkJcmVmX2RpdisrOworCQl9CisJfQorCisJKmRvdF9jbG9ja19wID0gKChwbGwtPnJlZmVyZW5jZV9mcmVxICogZmJfZGl2ICogMTApICsgKHBsbC0+cmVmZXJlbmNlX2ZyZXEgKiBmcmFjX2ZiX2RpdikpIC8KKwkJKHJlZl9kaXYgKiBwb3N0X2RpdiAqIDEwKTsKKwkqZmJfZGl2X3AgPSBmYl9kaXY7CisJKmZyYWNfZmJfZGl2X3AgPSBmcmFjX2ZiX2RpdjsKKwkqcmVmX2Rpdl9wID0gcmVmX2RpdjsKKwkqcG9zdF9kaXZfcCA9IHBvc3RfZGl2OworCURSTV9ERUJVR19LTVMoIiVkLCBwbGwgZGl2aWRlcnMgLSBmYjogJWQuJWQgcmVmOiAlZCwgcG9zdCAlZFxuIiwKKwkJICAgICAgKmRvdF9jbG9ja19wLCBmYl9kaXYsIGZyYWNfZmJfZGl2LCByZWZfZGl2LCBwb3N0X2Rpdik7Cit9CisKKy8qIHByZS1hdml2byAqLwogc3RhdGljIGlubGluZSB1aW50MzJfdCByYWRlb25fZGl2KHVpbnQ2NF90IG4sIHVpbnQzMl90IGQpCiB7CiAJdWludDY0X3QgbW9kOwpAQCAtNzkwLDEzICs4OTksMTMgQEAKIAlyZXR1cm4gbjsKIH0KIAotdm9pZCByYWRlb25fY29tcHV0ZV9wbGwoc3RydWN0IHJhZGVvbl9wbGwgKnBsbCwKLQkJCXVpbnQ2NF90IGZyZXEsCi0JCQl1aW50MzJfdCAqZG90X2Nsb2NrX3AsCi0JCQl1aW50MzJfdCAqZmJfZGl2X3AsCi0JCQl1aW50MzJfdCAqZnJhY19mYl9kaXZfcCwKLQkJCXVpbnQzMl90ICpyZWZfZGl2X3AsCi0JCQl1aW50MzJfdCAqcG9zdF9kaXZfcCkKK3ZvaWQgcmFkZW9uX2NvbXB1dGVfcGxsX2xlZ2FjeShzdHJ1Y3QgcmFkZW9uX3BsbCAqcGxsLAorCQkJICAgICAgIHVpbnQ2NF90IGZyZXEsCisJCQkgICAgICAgdWludDMyX3QgKmRvdF9jbG9ja19wLAorCQkJICAgICAgIHVpbnQzMl90ICpmYl9kaXZfcCwKKwkJCSAgICAgICB1aW50MzJfdCAqZnJhY19mYl9kaXZfcCwKKwkJCSAgICAgICB1aW50MzJfdCAqcmVmX2Rpdl9wLAorCQkJICAgICAgIHVpbnQzMl90ICpwb3N0X2Rpdl9wKQogewogCXVpbnQzMl90IG1pbl9yZWZfZGl2ID0gcGxsLT5taW5fcmVmX2RpdjsKIAl1aW50MzJfdCBtYXhfcmVmX2RpdiA9IHBsbC0+bWF4X3JlZl9kaXY7CkBAIC04MjYsNiArOTM1LDkgQEAKIAkJcGxsX291dF9tYXggPSBwbGwtPnBsbF9vdXRfbWF4OwogCX0KIAorCWlmIChwbGxfb3V0X21pbiA+IDY0ODAwKQorCQlwbGxfb3V0X21pbiA9IDY0ODAwOworCiAJaWYgKHBsbC0+ZmxhZ3MgJiBSQURFT05fUExMX1VTRV9SRUZfRElWKQogCQltaW5fcmVmX2RpdiA9IG1heF9yZWZfZGl2ID0gcGxsLT5yZWZlcmVuY2VfZGl2OwogCWVsc2UgewpAQCAtODQ5LDcgKzk2MSw3IEBACiAJCW1heF9mcmFjdGlvbmFsX2ZlZWRfZGl2ID0gcGxsLT5tYXhfZnJhY19mZWVkYmFja19kaXY7CiAJfQogCi0JZm9yIChwb3N0X2RpdiA9IG1heF9wb3N0X2RpdjsgcG9zdF9kaXYgPj0gbWluX3Bvc3RfZGl2OyAtLXBvc3RfZGl2KSB7CisJZm9yIChwb3N0X2RpdiA9IG1pbl9wb3N0X2RpdjsgcG9zdF9kaXYgPD0gbWF4X3Bvc3RfZGl2OyArK3Bvc3RfZGl2KSB7CiAJCXVpbnQzMl90IHJlZl9kaXY7CiAKIAkJaWYgKChwbGwtPmZsYWdzICYgUkFERU9OX1BMTF9OT19PRERfUE9TVF9ESVYpICYmIChwb3N0X2RpdiAmIDEpKQpAQCAtOTY1LDYgKzEwNzcsMTAgQEAKIAkqZnJhY19mYl9kaXZfcCA9IGJlc3RfZnJhY19mZWVkYmFja19kaXY7CiAJKnJlZl9kaXZfcCA9IGJlc3RfcmVmX2RpdjsKIAkqcG9zdF9kaXZfcCA9IGJlc3RfcG9zdF9kaXY7CisJRFJNX0RFQlVHX0tNUygiJWQgJWQsIHBsbCBkaXZpZGVycyAtIGZiOiAlZC4lZCByZWY6ICVkLCBwb3N0ICVkXG4iLAorCQkgICAgICBmcmVxLCBiZXN0X2ZyZXEgLyAxMDAwLCBiZXN0X2ZlZWRiYWNrX2RpdiwgYmVzdF9mcmFjX2ZlZWRiYWNrX2RpdiwKKwkJICAgICAgYmVzdF9yZWZfZGl2LCBiZXN0X3Bvc3RfZGl2KTsKKwogfQogCiBzdGF0aWMgdm9pZCByYWRlb25fdXNlcl9mcmFtZWJ1ZmZlcl9kZXN0cm95KHN0cnVjdCBkcm1fZnJhbWVidWZmZXIgKmZiKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZHJ2LmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kcnYuYwppbmRleCBiZTVjYjRmLi4yNzViMjZhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kcnYuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9kcnYuYwpAQCAtNDgsNyArNDgsNyBAQAogICogLSAyLjUuMCAtIGFkZCBnZXQgYWNjZWwgMiB0byB3b3JrIGFyb3VuZCBkZHggYnJlYWthZ2UgZm9yIGV2ZXJncmVlbgogICogLSAyLjYuMCAtIGFkZCB0aWxpbmcgY29uZmlnIHF1ZXJ5IChyNnh4KyksIGFkZCBpbml0aWFsIEhpWiBzdXBwb3J0IChyMzAwLT5yNTAwKQogICogICAyLjcuMCAtIGZpeHVwcyBmb3IgcjYwMCAyRCB0aWxpbmcgc3VwcG9ydC4gKG5vIGV4dGVybmFsIEFCSSBjaGFuZ2UpLCBhZGQgZWcgZHluIGdwciByZWdzCi0gKiAgIDIuOC4wIC0gcGFnZWZsaXAgc3VwcG9ydCwgcjUwMCBVU19GT1JNQVQgcmVncy4gcjUwMCBBUkdCMjEwMTAxMCBjb2xvcmJ1ZiwgcjMwMC0+cjUwMCBDTUFTSworICogICAyLjguMCAtIHBhZ2VmbGlwIHN1cHBvcnQsIHI1MDAgVVNfRk9STUFUIHJlZ3MuIHI1MDAgQVJHQjIxMDEwMTAgY29sb3JidWYsIHIzMDAtPnI1MDAgQ01BU0ssIGNsb2NrIGNyeXN0YWwgcXVlcnkKICAqLwogI2RlZmluZSBLTVNfRFJJVkVSX01BSk9SCTIKICNkZWZpbmUgS01TX0RSSVZFUl9NSU5PUgk4CkBAIC0xMDQsNiArMTA0LDcgQEAKIGludCByYWRlb25fYXVkaW8gPSAxOwogaW50IHJhZGVvbl9kaXNwX3ByaW9yaXR5ID0gMDsKIGludCByYWRlb25faHdfaTJjID0gMDsKK2ludCByYWRlb25fcGNpZV9nZW4yID0gMDsKIAogTU9EVUxFX1BBUk1fREVTQyhub193YiwgIkRpc2FibGUgQUdQIHdyaXRlYmFjayBmb3Igc2NyYXRjaCByZWdpc3RlcnMiKTsKIG1vZHVsZV9wYXJhbV9uYW1lZChub193YiwgcmFkZW9uX25vX3diLCBpbnQsIDA0NDQpOwpAQCAtMTQ3LDYgKzE0OCw5IEBACiBNT0RVTEVfUEFSTV9ERVNDKGh3X2kyYywgImh3IGkyYyBlbmdpbmUgZW5hYmxlICgwID0gZGlzYWJsZSkiKTsKIG1vZHVsZV9wYXJhbV9uYW1lZChod19pMmMsIHJhZGVvbl9od19pMmMsIGludCwgMDQ0NCk7CiAKK01PRFVMRV9QQVJNX0RFU0MocGNpZV9nZW4yLCAiUENJRSBHZW4yIG1vZGUgKDEgPSBlbmFibGUpIik7Cittb2R1bGVfcGFyYW1fbmFtZWQocGNpZV9nZW4yLCByYWRlb25fcGNpZV9nZW4yLCBpbnQsIDA0NDQpOworCiBzdGF0aWMgaW50IHJhZGVvbl9zdXNwZW5kKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHBtX21lc3NhZ2VfdCBzdGF0ZSkKIHsKIAlkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZW5jb2RlcnMuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2VuY29kZXJzLmMKaW5kZXggOGZkMTg0Mi4uZDRhNTQyMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZW5jb2RlcnMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9lbmNvZGVycy5jCkBAIC02NDEsNyArNjQxLDcgQEAKIAlzd2l0Y2ggKGNvbm5lY3Rvci0+Y29ubmVjdG9yX3R5cGUpIHsKIAljYXNlIERSTV9NT0RFX0NPTk5FQ1RPUl9EVklJOgogCWNhc2UgRFJNX01PREVfQ09OTkVDVE9SX0hETUlCOiAvKiBIRE1JLUIgaXMgYmFzaWNhbGx5IERMLURWSTsgYW5hbG9nIHdvcmtzIGZpbmUgKi8KLQkJaWYgKGRybV9kZXRlY3RfbW9uaXRvcl9hdWRpbyhyYWRlb25fY29ubmVjdG9yLT5lZGlkKSkgeworCQlpZiAoZHJtX2RldGVjdF9tb25pdG9yX2F1ZGlvKHJhZGVvbl9jb25uZWN0b3ItPmVkaWQpICYmIHJhZGVvbl9hdWRpbykgewogCQkJLyogZml4IG1lICovCiAJCQlpZiAoQVNJQ19JU19EQ0U0KHJkZXYpKQogCQkJCXJldHVybiBBVE9NX0VOQ09ERVJfTU9ERV9EVkk7CkBAIC02NTUsNyArNjU1LDcgQEAKIAljYXNlIERSTV9NT0RFX0NPTk5FQ1RPUl9EVklEOgogCWNhc2UgRFJNX01PREVfQ09OTkVDVE9SX0hETUlBOgogCWRlZmF1bHQ6Ci0JCWlmIChkcm1fZGV0ZWN0X21vbml0b3JfYXVkaW8ocmFkZW9uX2Nvbm5lY3Rvci0+ZWRpZCkpIHsKKwkJaWYgKGRybV9kZXRlY3RfbW9uaXRvcl9hdWRpbyhyYWRlb25fY29ubmVjdG9yLT5lZGlkKSAmJiByYWRlb25fYXVkaW8pIHsKIAkJCS8qIGZpeCBtZSAqLwogCQkJaWYgKEFTSUNfSVNfRENFNChyZGV2KSkKIAkJCQlyZXR1cm4gQVRPTV9FTkNPREVSX01PREVfRFZJOwpAQCAtNjczLDcgKzY3Myw3IEBACiAJCWlmICgoZGlnX2Nvbm5lY3Rvci0+ZHBfc2lua190eXBlID09IENPTk5FQ1RPUl9PQkpFQ1RfSURfRElTUExBWVBPUlQpIHx8CiAJCSAgICAoZGlnX2Nvbm5lY3Rvci0+ZHBfc2lua190eXBlID09IENPTk5FQ1RPUl9PQkpFQ1RfSURfZURQKSkKIAkJCXJldHVybiBBVE9NX0VOQ09ERVJfTU9ERV9EUDsKLQkJZWxzZSBpZiAoZHJtX2RldGVjdF9tb25pdG9yX2F1ZGlvKHJhZGVvbl9jb25uZWN0b3ItPmVkaWQpKSB7CisJCWVsc2UgaWYgKGRybV9kZXRlY3RfbW9uaXRvcl9hdWRpbyhyYWRlb25fY29ubmVjdG9yLT5lZGlkKSAmJiByYWRlb25fYXVkaW8pIHsKIAkJCS8qIGZpeCBtZSAqLwogCQkJaWYgKEFTSUNfSVNfRENFNChyZGV2KSkKIAkJCQlyZXR1cm4gQVRPTV9FTkNPREVSX01PREVfRFZJOwpAQCAtMTA2Myw3ICsxMDYzLDcgQEAKIAlpZiAoIUFTSUNfSVNfRENFNChyZGV2KSkKIAkJcmV0dXJuOwogCi0JaWYgKChhY3Rpb24gIT0gQVRPTV9UUkFOU01JVFRFUl9BQ1RJT05fUE9XRVJfT04pIHx8CisJaWYgKChhY3Rpb24gIT0gQVRPTV9UUkFOU01JVFRFUl9BQ1RJT05fUE9XRVJfT04pICYmCiAJICAgIChhY3Rpb24gIT0gQVRPTV9UUkFOU01JVFRFUl9BQ1RJT05fUE9XRVJfT0ZGKSkKIAkJcmV0dXJuOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9mYi5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZmIuYwppbmRleCBjYTMyZTljLi42NjMyNGI1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9mYi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2ZiLmMKQEAgLTIyNSw2ICsyMjUsOCBAQAogCiAJc3RyY3B5KGluZm8tPmZpeC5pZCwgInJhZGVvbmRybWZiIik7CiAKKwlkcm1fZmJfaGVscGVyX2ZpbGxfZml4KGluZm8sIGZiLT5waXRjaCwgZmItPmRlcHRoKTsKKwogCWluZm8tPmZsYWdzID0gRkJJTkZPX0RFRkFVTFQgfCBGQklORk9fQ0FOX0ZPUkNFX09VVFBVVDsKIAlpbmZvLT5mYm9wcyA9ICZyYWRlb25mYl9vcHM7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2lycV9rbXMuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2lycV9rbXMuYwppbmRleCBhMjg5NjQ2Li45ZWM4MzBjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9pcnFfa21zLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25faXJxX2ttcy5jCkBAIC0xMTAsMTEgKzExMCwxNCBAQAogCiBpbnQgcmFkZW9uX2lycV9rbXNfaW5pdChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIHsKKwlpbnQgaTsKIAlpbnQgciA9IDA7CiAKIAlJTklUX1dPUksoJnJkZXYtPmhvdHBsdWdfd29yaywgcmFkZW9uX2hvdHBsdWdfd29ya19mdW5jKTsKIAogCXNwaW5fbG9ja19pbml0KCZyZGV2LT5pcnEuc3dfbG9jayk7CisJZm9yIChpID0gMDsgaSA8IHJkZXYtPm51bV9jcnRjOyBpKyspCisJCXNwaW5fbG9ja19pbml0KCZyZGV2LT5pcnEucGZsaXBfbG9ja1tpXSk7CiAJciA9IGRybV92YmxhbmtfaW5pdChyZGV2LT5kZGV2LCByZGV2LT5udW1fY3J0Yyk7CiAJaWYgKHIpIHsKIAkJcmV0dXJuIHI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9rbXMuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2ttcy5jCmluZGV4IDI4YTUzZTRhLi44Mzg3ZDMyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9rbXMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9rbXMuYwpAQCAtMjAxLDYgKzIwMSwxMCBAQAogCQl9CiAJCXJhZGVvbl9zZXRfZmlscF9yaWdodHMoZGV2LCAmcmRldi0+Y21hc2tfZmlscCwgZmlscCwgJnZhbHVlKTsKIAkJYnJlYWs7CisJY2FzZSBSQURFT05fSU5GT19DTE9DS19DUllTVEFMX0ZSRVE6CisJCS8qIHJldHVybiBjbG9jayB2YWx1ZSBpbiBLSHogKi8KKwkJdmFsdWUgPSByZGV2LT5jbG9jay5zcGxsLnJlZmVyZW5jZV9mcmVxICogMTA7CisJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCURSTV9ERUJVR19LTVMoIkludmFsaWQgcmVxdWVzdCAlZFxuIiwgaW5mby0+cmVxdWVzdCk7CiAJCXJldHVybiAtRUlOVkFMOwpAQCAtMjQzLDYgKzI0Nyw4IEBACiAJc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYgPSBkZXYtPmRldl9wcml2YXRlOwogCWlmIChyZGV2LT5oeXBlcnpfZmlscCA9PSBmaWxlX3ByaXYpCiAJCXJkZXYtPmh5cGVyel9maWxwID0gTlVMTDsKKwlpZiAocmRldi0+Y21hc2tfZmlscCA9PSBmaWxlX3ByaXYpCisJCXJkZXYtPmNtYXNrX2ZpbHAgPSBOVUxMOwogfQogCiAvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fbGVnYWN5X2NydGMuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2xlZ2FjeV9jcnRjLmMKaW5kZXggYWNlMmU2My4uY2YwNjM4YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fbGVnYWN5X2NydGMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9sZWdhY3lfY3J0Yy5jCkBAIC03NzgsOSArNzc4LDkgQEAKIAlEUk1fREVCVUdfS01TKCJcbiIpOwogCiAJaWYgKCF1c2VfYmlvc19kaXZzKSB7Ci0JCXJhZGVvbl9jb21wdXRlX3BsbChwbGwsIG1vZGUtPmNsb2NrLAotCQkJCSAgICZmcmVxLCAmZmVlZGJhY2tfZGl2LCAmZnJhY19mYl9kaXYsCi0JCQkJICAgJnJlZmVyZW5jZV9kaXYsICZwb3N0X2RpdmlkZXIpOworCQlyYWRlb25fY29tcHV0ZV9wbGxfbGVnYWN5KHBsbCwgbW9kZS0+Y2xvY2ssCisJCQkJCSAgJmZyZXEsICZmZWVkYmFja19kaXYsICZmcmFjX2ZiX2RpdiwKKwkJCQkJICAmcmVmZXJlbmNlX2RpdiwgJnBvc3RfZGl2aWRlcik7CiAKIAkJZm9yIChwb3N0X2RpdiA9ICZwb3N0X2RpdnNbMF07IHBvc3RfZGl2LT5kaXZpZGVyOyArK3Bvc3RfZGl2KSB7CiAJCQlpZiAocG9zdF9kaXYtPmRpdmlkZXIgPT0gcG9zdF9kaXZpZGVyKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fbW9kZS5oIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fbW9kZS5oCmluZGV4IDEyYmRlYWIuLjY3OTRjZGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX21vZGUuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9tb2RlLmgKQEAgLTE0OSw2ICsxNDksNyBAQAogI2RlZmluZSBSQURFT05fUExMX1BSRUZFUl9DTE9TRVNUX0xPV0VSICgxIDw8IDExKQogI2RlZmluZSBSQURFT05fUExMX1VTRV9QT1NUX0RJViAgICAgICAgICgxIDw8IDEyKQogI2RlZmluZSBSQURFT05fUExMX0lTX0xDRCAgICAgICAgICAgICAgICgxIDw8IDEzKQorI2RlZmluZSBSQURFT05fUExMX1BSRUZFUl9NSU5NX09WRVJfTUFYUCAoMSA8PCAxNCkKIAogc3RydWN0IHJhZGVvbl9wbGwgewogCS8qIHJlZmVyZW5jZSBmcmVxdWVuY3kgKi8KQEAgLTUxMCwxMyArNTExLDIxIEBACiAJCQkJCSAgICAgc3RydWN0IHJhZGVvbl9hdG9tX3NzICpzcywKIAkJCQkJICAgICBpbnQgaWQsIHUzMiBjbG9jayk7CiAKLWV4dGVybiB2b2lkIHJhZGVvbl9jb21wdXRlX3BsbChzdHJ1Y3QgcmFkZW9uX3BsbCAqcGxsLAotCQkJICAgICAgIHVpbnQ2NF90IGZyZXEsCi0JCQkgICAgICAgdWludDMyX3QgKmRvdF9jbG9ja19wLAotCQkJICAgICAgIHVpbnQzMl90ICpmYl9kaXZfcCwKLQkJCSAgICAgICB1aW50MzJfdCAqZnJhY19mYl9kaXZfcCwKLQkJCSAgICAgICB1aW50MzJfdCAqcmVmX2Rpdl9wLAotCQkJICAgICAgIHVpbnQzMl90ICpwb3N0X2Rpdl9wKTsKK2V4dGVybiB2b2lkIHJhZGVvbl9jb21wdXRlX3BsbF9sZWdhY3koc3RydWN0IHJhZGVvbl9wbGwgKnBsbCwKKwkJCQkgICAgICB1aW50NjRfdCBmcmVxLAorCQkJCSAgICAgIHVpbnQzMl90ICpkb3RfY2xvY2tfcCwKKwkJCQkgICAgICB1aW50MzJfdCAqZmJfZGl2X3AsCisJCQkJICAgICAgdWludDMyX3QgKmZyYWNfZmJfZGl2X3AsCisJCQkJICAgICAgdWludDMyX3QgKnJlZl9kaXZfcCwKKwkJCQkgICAgICB1aW50MzJfdCAqcG9zdF9kaXZfcCk7CisKK2V4dGVybiB2b2lkIHJhZGVvbl9jb21wdXRlX3BsbF9hdml2byhzdHJ1Y3QgcmFkZW9uX3BsbCAqcGxsLAorCQkJCSAgICAgdTMyIGZyZXEsCisJCQkJICAgICB1MzIgKmRvdF9jbG9ja19wLAorCQkJCSAgICAgdTMyICpmYl9kaXZfcCwKKwkJCQkgICAgIHUzMiAqZnJhY19mYl9kaXZfcCwKKwkJCQkgICAgIHUzMiAqcmVmX2Rpdl9wLAorCQkJCSAgICAgdTMyICpwb3N0X2Rpdl9wKTsKIAogZXh0ZXJuIHZvaWQgcmFkZW9uX3NldHVwX2VuY29kZXJfY2xvbmVzKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9wbS5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fcG0uYwppbmRleCAzYjFiMmJmLi4yYWVkMDNiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9wbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3BtLmMKQEAgLTQzMCw3ICs0MzAsNyBAQAogewogCXN0cnVjdCBkcm1fZGV2aWNlICpkZGV2ID0gcGNpX2dldF9kcnZkYXRhKHRvX3BjaV9kZXYoZGV2KSk7CiAJc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYgPSBkZGV2LT5kZXZfcHJpdmF0ZTsKLQl1MzIgdGVtcDsKKwlpbnQgdGVtcDsKIAogCXN3aXRjaCAocmRldi0+cG0uaW50X3RoZXJtYWxfdHlwZSkgewogCWNhc2UgVEhFUk1BTF9UWVBFX1JWNlhYOgpAQCAtNjQ2LDYgKzY0Niw5IEBACiAjZW5kaWYKIAl9CiAKKwlpZiAocmRldi0+cG0ucG93ZXJfc3RhdGUpCisJCWtmcmVlKHJkZXYtPnBtLnBvd2VyX3N0YXRlKTsKKwogCXJhZGVvbl9od21vbl9maW5pKHJkZXYpOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9yZWcuaCBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3JlZy5oCmluZGV4IDNjZDRkYWMuLmVjOTNhNzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3JlZy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3JlZy5oCkBAIC0zNzUsNiArMzc1LDggQEAKICNkZWZpbmUgUkFERU9OX0NPTkZJR19BUEVSX1NJWkUgICAgICAgICAgICAgMHgwMTA4CiAjZGVmaW5lIFJBREVPTl9DT05GSUdfQk9ORFMgICAgICAgICAgICAgICAgIDB4MDBlOAogI2RlZmluZSBSQURFT05fQ09ORklHX0NOVEwgICAgICAgICAgICAgICAgICAweDAwZTAKKyMgICAgICAgZGVmaW5lIFJBREVPTl9DRkdfVkdBX1JBTV9FTiAgICAgICAgKDEgPDwgOCkKKyMgICAgICAgZGVmaW5lIFJBREVPTl9DRkdfVkdBX0lPX0RJUyAgICAgICAgKDEgPDwgOSkKICMgICAgICAgZGVmaW5lIFJBREVPTl9DRkdfQVRJX1JFVl9BMTEgICAgICAgKDAgICA8PCAxNikKICMgICAgICAgZGVmaW5lIFJBREVPTl9DRkdfQVRJX1JFVl9BMTIgICAgICAgKDEgICA8PCAxNikKICMgICAgICAgZGVmaW5lIFJBREVPTl9DRkdfQVRJX1JFVl9BMTMgICAgICAgKDIgICA8PCAxNikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmVnX3NyY3MvZXZlcmdyZWVuIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yZWdfc3Jjcy9ldmVyZ3JlZW4KaW5kZXggYWM0MGZkMy4uOTE3N2Y5MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yZWdfc3Jjcy9ldmVyZ3JlZW4KKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yZWdfc3Jjcy9ldmVyZ3JlZW4KQEAgLTQzOSw3ICs0MzksNyBAQAogMHgwMDAyODZFQyBTUElfQ09NUFVURV9OVU1fVEhSRUFEX1gKIDB4MDAwMjg2RjAgU1BJX0NPTVBVVEVfTlVNX1RIUkVBRF9ZCiAweDAwMDI4NkY0IFNQSV9DT01QVVRFX05VTV9USFJFQURfWgotMHgwMDAyODZGOCBHRFNfQUREUl9TSVpFCisweDAwMDI4NzI0IEdEU19BRERSX1NJWkUKIDB4MDAwMjg3ODAgQ0JfQkxFTkQwX0NPTlRST0wKIDB4MDAwMjg3ODQgQ0JfQkxFTkQxX0NPTlRST0wKIDB4MDAwMjg3ODggQ0JfQkxFTkQyX0NPTlRST0wKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcnM0MDAuYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcnM0MDAuYwppbmRleCA1NTEyZTRlLi5jNzYyODNkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JzNDAwLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yczQwMC5jCkBAIC0yMDMsNiArMjAzLDkgQEAKIAlyYWRlb25fZ2FydF90YWJsZV9yYW1fZnJlZShyZGV2KTsKIH0KIAorI2RlZmluZSBSUzQwMF9QVEVfV1JJVEVBQkxFICgxIDw8IDIpCisjZGVmaW5lIFJTNDAwX1BURV9SRUFEQUJMRSAgKDEgPDwgMykKKwogaW50IHJzNDAwX2dhcnRfc2V0X3BhZ2Uoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsIGludCBpLCB1aW50NjRfdCBhZGRyKQogewogCXVpbnQzMl90IGVudHJ5OwpAQCAtMjEzLDcgKzIxNiw3IEBACiAKIAllbnRyeSA9IChsb3dlcl8zMl9iaXRzKGFkZHIpICYgUEFHRV9NQVNLKSB8CiAJCSgodXBwZXJfMzJfYml0cyhhZGRyKSAmIDB4ZmYpIDw8IDQpIHwKLQkJMHhjOworCQlSUzQwMF9QVEVfV1JJVEVBQkxFIHwgUlM0MDBfUFRFX1JFQURBQkxFOwogCWVudHJ5ID0gY3B1X3RvX2xlMzIoZW50cnkpOwogCXJkZXYtPmdhcnQudGFibGUucmFtLnB0cltpXSA9IGVudHJ5OwogCXJldHVybiAwOwpAQCAtMjI2LDggKzIyOSw4IEBACiAKIAlmb3IgKGkgPSAwOyBpIDwgcmRldi0+dXNlY190aW1lb3V0OyBpKyspIHsKIAkJLyogcmVhZCBNQ19TVEFUVVMgKi8KLQkJdG1wID0gUlJFRzMyKDB4MDE1MCk7Ci0JCWlmICh0bXAgJiAoMSA8PCAyKSkgeworCQl0bXAgPSBSUkVHMzIoUkFERU9OX01DX1NUQVRVUyk7CisJCWlmICh0bXAgJiBSQURFT05fTUNfSURMRSkgewogCQkJcmV0dXJuIDA7CiAJCX0KIAkJRFJNX1VERUxBWSgxKTsKQEAgLTI0MSw3ICsyNDQsNyBAQAogCXI0MjBfcGlwZXNfaW5pdChyZGV2KTsKIAlpZiAocnM0MDBfbWNfd2FpdF9mb3JfaWRsZShyZGV2KSkgewogCQlwcmludGsoS0VSTl9XQVJOSU5HICJyczQwMDogRmFpbGVkIHRvIHdhaXQgTUMgaWRsZSB3aGlsZSAiCi0JCSAgICAgICAicHJvZ3JhbW1pbmcgcGlwZXMuIEJhZCB0aGluZ3MgbWlnaHQgaGFwcGVuLiAlMDh4XG4iLCBSUkVHMzIoMHgxNTApKTsKKwkJICAgICAgICJwcm9ncmFtbWluZyBwaXBlcy4gQmFkIHRoaW5ncyBtaWdodCBoYXBwZW4uICUwOHhcbiIsIFJSRUczMihSQURFT05fTUNfU1RBVFVTKSk7CiAJfQogfQogCkBAIC0zMDAsOSArMzAzLDkgQEAKIAkJc2VxX3ByaW50ZihtLCAiTUNDRkdfQUdQX0JBU0VfMiAweCUwOHhcbiIsIHRtcCk7CiAJCXRtcCA9IFJSRUczMl9NQyhSUzY5MF9NQ0NGR19BR1BfTE9DQVRJT04pOwogCQlzZXFfcHJpbnRmKG0sICJNQ0NGR19BR1BfTE9DQVRJT04gMHglMDh4XG4iLCB0bXApOwotCQl0bXAgPSBSUkVHMzJfTUMoMHgxMDApOworCQl0bXAgPSBSUkVHMzJfTUMoUlM2OTBfTUNDRkdfRkJfTE9DQVRJT04pOwogCQlzZXFfcHJpbnRmKG0sICJNQ0NGR19GQl9MT0NBVElPTiAweCUwOHhcbiIsIHRtcCk7Ci0JCXRtcCA9IFJSRUczMigweDEzNCk7CisJCXRtcCA9IFJSRUczMihSUzY5MF9IRFBfRkJfTE9DQVRJT04pOwogCQlzZXFfcHJpbnRmKG0sICJIRFBfRkJfTE9DQVRJT04gMHglMDh4XG4iLCB0bXApOwogCX0gZWxzZSB7CiAJCXRtcCA9IFJSRUczMihSQURFT05fQUdQX0JBU0UpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yczYwMC5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yczYwMC5jCmluZGV4IGI0MTkyYWMuLjVhZmUyOTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcnM2MDAuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JzNjAwLmMKQEAgLTMzOSwxNiArMzM5LDE2IEBACiAKIGludCByczYwMF9hc2ljX3Jlc2V0KHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogewotCXUzMiBzdGF0dXMsIHRtcDsKLQogCXN0cnVjdCBydjUxNV9tY19zYXZlIHNhdmU7CisJdTMyIHN0YXR1cywgdG1wOworCWludCByZXQgPSAwOwogCi0JLyogU3RvcHMgYWxsIG1jIGNsaWVudHMgKi8KLQlydjUxNV9tY19zdG9wKHJkZXYsICZzYXZlKTsKIAlzdGF0dXMgPSBSUkVHMzIoUl8wMDBFNDBfUkJCTV9TVEFUVVMpOwogCWlmICghR18wMDBFNDBfR1VJX0FDVElWRShzdGF0dXMpKSB7CiAJCXJldHVybiAwOwogCX0KKwkvKiBTdG9wcyBhbGwgbWMgY2xpZW50cyAqLworCXJ2NTE1X21jX3N0b3AocmRldiwgJnNhdmUpOwogCXN0YXR1cyA9IFJSRUczMihSXzAwMEU0MF9SQkJNX1NUQVRVUyk7CiAJZGV2X2luZm8ocmRldi0+ZGV2LCAiKCVzOiVkKSBSQkJNX1NUQVRVUz0weCUwOFhcbiIsIF9fZnVuY19fLCBfX0xJTkVfXywgc3RhdHVzKTsKIAkvKiBzdG9wIENQICovCkBAIC0zOTIsMTEgKzM5MiwxMSBAQAogCWlmIChHXzAwMEU0MF9HQV9CVVNZKHN0YXR1cykgfHwgR18wMDBFNDBfVkFQX0JVU1koc3RhdHVzKSkgewogCQlkZXZfZXJyKHJkZXYtPmRldiwgImZhaWxlZCB0byByZXNldCBHUFVcbiIpOwogCQlyZGV2LT5ncHVfbG9ja3VwID0gdHJ1ZTsKLQkJcmV0dXJuIC0xOwotCX0KKwkJcmV0ID0gLTE7CisJfSBlbHNlCisJCWRldl9pbmZvKHJkZXYtPmRldiwgIkdQVSByZXNldCBzdWNjZWVkXG4iKTsKIAlydjUxNV9tY19yZXN1bWUocmRldiwgJnNhdmUpOwotCWRldl9pbmZvKHJkZXYtPmRldiwgIkdQVSByZXNldCBzdWNjZWVkXG4iKTsKLQlyZXR1cm4gMDsKKwlyZXR1cm4gcmV0OwogfQogCiAvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9ydjUxNS5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9ydjUxNS5jCmluZGV4IDVkNTY5ZjQuLjY0YjU3YWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcnY1MTUuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3J2NTE1LmMKQEAgLTY5LDEzICs2OSwxMyBAQAogCQkJICBJU1lOQ19DUFNDUkFUQ0hfSURMRUdVSSk7CiAJcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgUEFDS0VUMChXQUlUX1VOVElMLCAwKSk7CiAJcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgV0FJVF8yRF9JRExFQ0xFQU4gfCBXQUlUXzNEX0lETEVDTEVBTik7Ci0JcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgUEFDS0VUMCgweDE3MEMsIDApKTsKLQlyYWRlb25fcmluZ193cml0ZShyZGV2LCAxIDw8IDMxKTsKKwlyYWRlb25fcmluZ193cml0ZShyZGV2LCBQQUNLRVQwKFIzMDBfRFNUX1BJUEVfQ09ORklHLCAwKSk7CisJcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgUjMwMF9QSVBFX0FVVE9fQ09ORklHKTsKIAlyYWRlb25fcmluZ193cml0ZShyZGV2LCBQQUNLRVQwKEdCX1NFTEVDVCwgMCkpOwogCXJhZGVvbl9yaW5nX3dyaXRlKHJkZXYsIDApOwogCXJhZGVvbl9yaW5nX3dyaXRlKHJkZXYsIFBBQ0tFVDAoR0JfRU5BQkxFLCAwKSk7CiAJcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgMCk7Ci0JcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgUEFDS0VUMCgweDQyQzgsIDApKTsKKwlyYWRlb25fcmluZ193cml0ZShyZGV2LCBQQUNLRVQwKFI1MDBfU1VfUkVHX0RFU1QsIDApKTsKIAlyYWRlb25fcmluZ193cml0ZShyZGV2LCAoMSA8PCByZGV2LT5udW1fZ2JfcGlwZXMpIC0gMSk7CiAJcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgUEFDS0VUMChWQVBfSU5ERVhfT0ZGU0VULCAwKSk7CiAJcmFkZW9uX3Jpbmdfd3JpdGUocmRldiwgMCk7CkBAIC0xNTMsOCArMTUzLDggQEAKIAl9CiAJcnY1MTVfdmdhX3JlbmRlcl9kaXNhYmxlKHJkZXYpOwogCXI0MjBfcGlwZXNfaW5pdChyZGV2KTsKLQlnYl9waXBlX3NlbGVjdCA9IFJSRUczMigweDQwMkMpOwotCXRtcCA9IFJSRUczMigweDE3MEMpOworCWdiX3BpcGVfc2VsZWN0ID0gUlJFRzMyKFI0MDBfR0JfUElQRV9TRUxFQ1QpOworCXRtcCA9IFJSRUczMihSMzAwX0RTVF9QSVBFX0NPTkZJRyk7CiAJcGlwZV9zZWxlY3RfY3VycmVudCA9ICh0bXAgPj4gMikgJiAzOwogCXRtcCA9ICgxIDw8IHBpcGVfc2VsZWN0X2N1cnJlbnQpIHwKIAkgICAgICAoKChnYl9waXBlX3NlbGVjdCA+PiA4KSAmIDB4RikgPDwgNCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3J2NzcwLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3J2NzcwLmMKaW5kZXggM2EyNjRhYS4uMjIxMWEzMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9ydjc3MC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcnY3NzAuYwpAQCAtNzgsMTggKzc4LDIzIEBACiB9CiAKIC8qIGdldCB0ZW1wZXJhdHVyZSBpbiBtaWxsaWRlZ3JlZXMgKi8KLXUzMiBydjc3MF9nZXRfdGVtcChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKK2ludCBydjc3MF9nZXRfdGVtcChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIHsKIAl1MzIgdGVtcCA9IChSUkVHMzIoQ0dfTVVMVF9USEVSTUFMX1NUQVRVUykgJiBBU0lDX1RfTUFTSykgPj4KIAkJQVNJQ19UX1NISUZUOwotCXUzMiBhY3R1YWxfdGVtcCA9IDA7CisJaW50IGFjdHVhbF90ZW1wOwogCi0JaWYgKCh0ZW1wID4+IDkpICYgMSkKLQkJYWN0dWFsX3RlbXAgPSAwOwotCWVsc2UKLQkJYWN0dWFsX3RlbXAgPSAodGVtcCA+PiAxKSAmIDB4ZmY7CisJaWYgKHRlbXAgJiAweDQwMCkKKwkJYWN0dWFsX3RlbXAgPSAtMjU2OworCWVsc2UgaWYgKHRlbXAgJiAweDIwMCkKKwkJYWN0dWFsX3RlbXAgPSAyNTU7CisJZWxzZSBpZiAodGVtcCAmIDB4MTAwKSB7CisJCWFjdHVhbF90ZW1wID0gdGVtcCAmIDB4MWZmOworCQlhY3R1YWxfdGVtcCB8PSB+MHgxZmY7CisJfSBlbHNlCisJCWFjdHVhbF90ZW1wID0gdGVtcCAmIDB4ZmY7CiAKLQlyZXR1cm4gYWN0dWFsX3RlbXAgKiAxMDAwOworCXJldHVybiAoYWN0dWFsX3RlbXAgKiAxMDAwKSAvIDI7CiB9CiAKIHZvaWQgcnY3NzBfcG1fbWlzYyhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKQEAgLTEyNjgsNyArMTI3Myw3IEBACiAJaWYgKHIpCiAJCXJldHVybiByOwogCS8qIFBvc3QgY2FyZCBpZiBuZWNlc3NhcnkgKi8KLQlpZiAoIXI2MDBfY2FyZF9wb3N0ZWQocmRldikpIHsKKwlpZiAoIXJhZGVvbl9jYXJkX3Bvc3RlZChyZGV2KSkgewogCQlpZiAoIXJkZXYtPmJpb3MpIHsKIAkJCWRldl9lcnIocmRldi0+ZGV2LCAiQ2FyZCBub3QgcG9zdGVkIGFuZCBubyBCSU9TIC0gaWdub3JpbmdcbiIpOwogCQkJcmV0dXJuIC1FSU5WQUw7CkBAIC0xMzcyLDYgKzEzNzcsOSBAQAogCXUzMiBsaW5rX3dpZHRoX2NudGwsIGxhbmVzLCBzcGVlZF9jbnRsLCB0bXA7CiAJdTE2IGxpbmtfY250bDI7CiAKKwlpZiAocmFkZW9uX3BjaWVfZ2VuMiA9PSAwKQorCQlyZXR1cm47CisKIAlpZiAocmRldi0+ZmxhZ3MgJiBSQURFT05fSVNfSUdQKQogCQlyZXR1cm47CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L3N0dWIvS2NvbmZpZyBiL2RyaXZlcnMvZ3B1L3N0dWIvS2NvbmZpZwppbmRleCAwZTFlZGQ3Li43MGU2MGE0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9zdHViL0tjb25maWcKKysrIGIvZHJpdmVycy9ncHUvc3R1Yi9LY29uZmlnCkBAIC0xLDEyICsxLDEzIEBACiBjb25maWcgU1RVQl9QT1VMU0JPCiAJdHJpc3RhdGUgIkludGVsIEdNQTUwMCBTdHViIERyaXZlciIKIAlkZXBlbmRzIG9uIFBDSQorCWRlcGVuZHMgb24gTkVUICMgZm9yIFRIRVJNQUwKIAkjIFBvdWxzYm8gc3R1YiBkZXBlbmRzIG9uIEFDUElfVklERU8gd2hlbiBBQ1BJIGlzIGVuYWJsZWQKIAkjIGJ1dCBmb3Igc2VsZWN0IHRvIHdvcmssIG5lZWQgdG8gc2VsZWN0IEFDUElfVklERU8ncyBkZXBlbmRlbmNpZXMsIGljawotCXNlbGVjdCBWSURFT19PVVRQVVRfQ09OVFJPTCBpZiBBQ1BJCiAJc2VsZWN0IEJBQ0tMSUdIVF9DTEFTU19ERVZJQ0UgaWYgQUNQSQogCXNlbGVjdCBJTlBVVCBpZiBBQ1BJCiAJc2VsZWN0IEFDUElfVklERU8gaWYgQUNQSQorCXNlbGVjdCBUSEVSTUFMIGlmIEFDUEkKIAloZWxwCiAJICBDaG9vc2UgdGhpcyBvcHRpb24gaWYgeW91IGhhdmUgYSBzeXN0ZW0gdGhhdCBoYXMgSW50ZWwgR01BNTAwCiAJICAoUG91bHNibykgaW50ZWdyYXRlZCBncmFwaGljcy4gSWYgTSBpcyBzZWxlY3RlZCwgdGhlIG1vZHVsZSB3aWxsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS92Z2EvS2NvbmZpZyBiL2RyaXZlcnMvZ3B1L3ZnYS9LY29uZmlnCmluZGV4IDhkMGUzMWEuLjk2YzgzYTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L3ZnYS9LY29uZmlnCisrKyBiL2RyaXZlcnMvZ3B1L3ZnYS9LY29uZmlnCkBAIC0xLDUgKzEsNSBAQAogY29uZmlnIFZHQV9BUkIKLQlib29sICJWR0EgQXJiaXRyYXRpb24iIGlmIEVNQkVEREVECisJYm9vbCAiVkdBIEFyYml0cmF0aW9uIiBpZiBFWFBFUlQKIAlkZWZhdWx0IHkKIAlkZXBlbmRzIG9uIFBDSQogCWhlbHAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L3ZnYS92Z2FhcmIuYyBiL2RyaXZlcnMvZ3B1L3ZnYS92Z2FhcmIuYwppbmRleCBjMzgwYzY1Li5hY2UyYjE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS92Z2EvdmdhYXJiLmMKKysrIGIvZHJpdmVycy9ncHUvdmdhL3ZnYWFyYi5jCkBAIC02MzYsNyArNjM2LDcgQEAKIAkJCXZvaWQgKCppcnFfc2V0X3N0YXRlKSh2b2lkICpjb29raWUsIGJvb2wgc3RhdGUpLAogCQkJdW5zaWduZWQgaW50ICgqc2V0X3ZnYV9kZWNvZGUpKHZvaWQgKmNvb2tpZSwgYm9vbCBkZWNvZGUpKQogewotCWludCByZXQgPSAtMTsKKwlpbnQgcmV0ID0gLUVOT0RFVjsKIAlzdHJ1Y3QgdmdhX2RldmljZSAqdmdhZGV2OwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaGlkL0tjb25maWcgYi9kcml2ZXJzL2hpZC9LY29uZmlnCmluZGV4IDI0Y2NhMmYuLjI1NjBmMDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaGlkL0tjb25maWcKKysrIGIvZHJpdmVycy9oaWQvS2NvbmZpZwpAQCAtNjIsOSArNjIsOSBAQAogCVN1cHBvcnQgZm9yIDNNIFBDVCB0b3VjaCBzY3JlZW5zLgogCiBjb25maWcgSElEX0E0VEVDSAotCXRyaXN0YXRlICJBNCB0ZWNoIG1pY2UiIGlmIEVNQkVEREVECisJdHJpc3RhdGUgIkE0IHRlY2ggbWljZSIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBVU0JfSElECi0JZGVmYXVsdCAhRU1CRURERUQKKwlkZWZhdWx0ICFFWFBFUlQKIAktLS1oZWxwLS0tCiAJU3VwcG9ydCBmb3IgQTQgdGVjaCBYNSBhbmQgV09QLTM1IC8gVHJ1c3QgNDUwTCBtaWNlLgogCkBAIC03Nyw5ICs3Nyw5IEBACiAJZ2FtZSBjb250cm9sbGVycy4KIAogY29uZmlnIEhJRF9BUFBMRQotCXRyaXN0YXRlICJBcHBsZSB7aSxQb3dlcixNYWN9Qm9va3MiIGlmIEVNQkVEREVECisJdHJpc3RhdGUgIkFwcGxlIHtpLFBvd2VyLE1hY31Cb29rcyIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiAoVVNCX0hJRCB8fCBCVF9ISURQKQotCWRlZmF1bHQgIUVNQkVEREVECisJZGVmYXVsdCAhRVhQRVJUCiAJLS0taGVscC0tLQogCVN1cHBvcnQgZm9yIHNvbWUgQXBwbGUgZGV2aWNlcyB3aGljaCBsZXNzIG9yIG1vcmUgYnJlYWsKIAlISUQgc3BlY2lmaWNhdGlvbi4KQEAgLTg4LDkgKzg4LDkgQEAKIAlNYWNCb29rcywgTWFjQm9vayBQcm9zIGFuZCBBcHBsZSBBbHVtaW51bS4KIAogY29uZmlnIEhJRF9CRUxLSU4KLQl0cmlzdGF0ZSAiQmVsa2luIEZsaXAgS1ZNIGFuZCBXaXJlbGVzcyBrZXlib2FyZCIgaWYgRU1CRURERUQKKwl0cmlzdGF0ZSAiQmVsa2luIEZsaXAgS1ZNIGFuZCBXaXJlbGVzcyBrZXlib2FyZCIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBVU0JfSElECi0JZGVmYXVsdCAhRU1CRURERUQKKwlkZWZhdWx0ICFFWFBFUlQKIAktLS1oZWxwLS0tCiAJU3VwcG9ydCBmb3IgQmVsa2luIEZsaXAgS1ZNIGFuZCBXaXJlbGVzcyBrZXlib2FyZC4KIApAQCAtMTAxLDE2ICsxMDEsMTYgQEAKIAlTdXBwb3J0IGZvciBDYW5kbyBkdWFsIHRvdWNoIHBhbmVsLgogCiBjb25maWcgSElEX0NIRVJSWQotCXRyaXN0YXRlICJDaGVycnkgQ3ltb3Rpb24ga2V5Ym9hcmQiIGlmIEVNQkVEREVECisJdHJpc3RhdGUgIkNoZXJyeSBDeW1vdGlvbiBrZXlib2FyZCIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBVU0JfSElECi0JZGVmYXVsdCAhRU1CRURERUQKKwlkZWZhdWx0ICFFWFBFUlQKIAktLS1oZWxwLS0tCiAJU3VwcG9ydCBmb3IgQ2hlcnJ5IEN5bW90aW9uIGtleWJvYXJkLgogCiBjb25maWcgSElEX0NISUNPTlkKLQl0cmlzdGF0ZSAiQ2hpY29ueSBUYWN0aWNhbCBwYWQiIGlmIEVNQkVEREVECisJdHJpc3RhdGUgIkNoaWNvbnkgVGFjdGljYWwgcGFkIiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFVTQl9ISUQKLQlkZWZhdWx0ICFFTUJFRERFRAorCWRlZmF1bHQgIUVYUEVSVAogCS0tLWhlbHAtLS0KIAlTdXBwb3J0IGZvciBDaGljb255IFRhY3RpY2FsIHBhZC4KIApAQCAtMTMwLDkgKzEzMCw5IEBACiAJICBhbmQgc29tZSBhZGRpdGlvbmFsIG11bHRpbWVkaWEga2V5cy4KIAogY29uZmlnIEhJRF9DWVBSRVNTCi0JdHJpc3RhdGUgIkN5cHJlc3MgbW91c2UgYW5kIGJhcmNvZGUgcmVhZGVycyIgaWYgRU1CRURERUQKKwl0cmlzdGF0ZSAiQ3lwcmVzcyBtb3VzZSBhbmQgYmFyY29kZSByZWFkZXJzIiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFVTQl9ISUQKLQlkZWZhdWx0ICFFTUJFRERFRAorCWRlZmF1bHQgIUVYUEVSVAogCS0tLWhlbHAtLS0KIAlTdXBwb3J0IGZvciBjeXByZXNzIG1vdXNlIGFuZCBiYXJjb2RlIHJlYWRlcnMuCiAKQEAgLTE3NCwxNiArMTc0LDE2IEBACiAJU3VwcG9ydCBmb3IgdGhlIEVMRUNPTSBCTTA4NCAoYmx1ZXRvb3RoIG1vdXNlKS4KIAogY29uZmlnIEhJRF9FWktFWQotCXRyaXN0YXRlICJFemtleSBCVEMgODE5MyBrZXlib2FyZCIgaWYgRU1CRURERUQKKwl0cmlzdGF0ZSAiRXprZXkgQlRDIDgxOTMga2V5Ym9hcmQiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gVVNCX0hJRAotCWRlZmF1bHQgIUVNQkVEREVECisJZGVmYXVsdCAhRVhQRVJUCiAJLS0taGVscC0tLQogCVN1cHBvcnQgZm9yIEV6a2V5IEJUQyA4MTkzIGtleWJvYXJkLgogCiBjb25maWcgSElEX0tZRQotCXRyaXN0YXRlICJLeWUvR2VuaXVzIEVyZ28gTW91c2UiIGlmIEVNQkVEREVECisJdHJpc3RhdGUgIkt5ZS9HZW5pdXMgRXJnbyBNb3VzZSIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBVU0JfSElECi0JZGVmYXVsdCAhRU1CRURERUQKKwlkZWZhdWx0ICFFWFBFUlQKIAktLS1oZWxwLS0tCiAJU3VwcG9ydCBmb3IgS3llL0dlbml1cyBFcmdvIE1vdXNlLgogCkBAIC0yMTIsMTYgKzIxMiwxNiBAQAogCVN1cHBvcnQgZm9yIFR3aW5oYW4gSVIgcmVtb3RlIGNvbnRyb2wuCiAKIGNvbmZpZyBISURfS0VOU0lOR1RPTgotCXRyaXN0YXRlICJLZW5zaW5ndG9uIFNsaW1ibGFkZSBUcmFja2JhbGwiIGlmIEVNQkVEREVECisJdHJpc3RhdGUgIktlbnNpbmd0b24gU2xpbWJsYWRlIFRyYWNrYmFsbCIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBVU0JfSElECi0JZGVmYXVsdCAhRU1CRURERUQKKwlkZWZhdWx0ICFFWFBFUlQKIAktLS1oZWxwLS0tCiAJU3VwcG9ydCBmb3IgS2Vuc2luZ3RvbiBTbGltYmxhZGUgVHJhY2tiYWxsLgogCiBjb25maWcgSElEX0xPR0lURUNICi0JdHJpc3RhdGUgIkxvZ2l0ZWNoIGRldmljZXMiIGlmIEVNQkVEREVECisJdHJpc3RhdGUgIkxvZ2l0ZWNoIGRldmljZXMiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gVVNCX0hJRAotCWRlZmF1bHQgIUVNQkVEREVECisJZGVmYXVsdCAhRVhQRVJUCiAJLS0taGVscC0tLQogCVN1cHBvcnQgZm9yIExvZ2l0ZWNoIGRldmljZXMgdGhhdCBhcmUgbm90IGZ1bGx5IGNvbXBsaWFudCB3aXRoIEhJRCBzdGFuZGFyZC4KIApAQCAtMjc2LDkgKzI3Niw5IEBACiAJQXBwbGUgV2lyZWxlc3MgIk1hZ2ljIiBNb3VzZS4KIAogY29uZmlnIEhJRF9NSUNST1NPRlQKLQl0cmlzdGF0ZSAiTWljcm9zb2Z0IG5vbi1mdWxseSBISUQtY29tcGxpYW50IGRldmljZXMiIGlmIEVNQkVEREVECisJdHJpc3RhdGUgIk1pY3Jvc29mdCBub24tZnVsbHkgSElELWNvbXBsaWFudCBkZXZpY2VzIiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFVTQl9ISUQKLQlkZWZhdWx0ICFFTUJFRERFRAorCWRlZmF1bHQgIUVYUEVSVAogCS0tLWhlbHAtLS0KIAlTdXBwb3J0IGZvciBNaWNyb3NvZnQgZGV2aWNlcyB0aGF0IGFyZSBub3QgZnVsbHkgY29tcGxpYW50IHdpdGggSElEIHN0YW5kYXJkLgogCkBAIC0yODksOSArMjg5LDkgQEAKIAlTdXBwb3J0IGZvciBNb3NBcnQgZHVhbC10b3VjaCBwYW5lbHMuCiAKIGNvbmZpZyBISURfTU9OVEVSRVkKLQl0cmlzdGF0ZSAiTW9udGVyZXkgR2VuaXVzIEtCMjlFIGtleWJvYXJkIiBpZiBFTUJFRERFRAorCXRyaXN0YXRlICJNb250ZXJleSBHZW5pdXMgS0IyOUUga2V5Ym9hcmQiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gVVNCX0hJRAotCWRlZmF1bHQgIUVNQkVEREVECisJZGVmYXVsdCAhRVhQRVJUCiAJLS0taGVscC0tLQogCVN1cHBvcnQgZm9yIE1vbnRlcmV5IEdlbml1cyBLQjI5RS4KIApAQCAtMzY1LDggKzM2NSw4IEBACiAJICAtIElSCiAKIGNvbmZpZyBISURfUElDT0xDRF9GQgotCWJvb2wgIkZyYW1lYnVmZmVyIHN1cHBvcnQiIGlmIEVNQkVEREVECi0JZGVmYXVsdCAhRU1CRURERUQKKwlib29sICJGcmFtZWJ1ZmZlciBzdXBwb3J0IiBpZiBFWFBFUlQKKwlkZWZhdWx0ICFFWFBFUlQKIAlkZXBlbmRzIG9uIEhJRF9QSUNPTENECiAJZGVwZW5kcyBvbiBISURfUElDT0xDRD1GQiB8fCBGQj15CiAJc2VsZWN0IEZCX0RFRkVSUkVEX0lPCkBAIC0zNzksOCArMzc5LDggQEAKIAkgIGZyYW1idWZmZXIgZGV2aWNlLgogCiBjb25maWcgSElEX1BJQ09MQ0RfQkFDS0xJR0hUCi0JYm9vbCAiQmFja2xpZ2h0IGNvbnRyb2wiIGlmIEVNQkVEREVECi0JZGVmYXVsdCAhRU1CRURERUQKKwlib29sICJCYWNrbGlnaHQgY29udHJvbCIgaWYgRVhQRVJUCisJZGVmYXVsdCAhRVhQRVJUCiAJZGVwZW5kcyBvbiBISURfUElDT0xDRAogCWRlcGVuZHMgb24gSElEX1BJQ09MQ0Q9QkFDS0xJR0hUX0NMQVNTX0RFVklDRSB8fCBCQUNLTElHSFRfQ0xBU1NfREVWSUNFPXkKIAktLS1oZWxwLS0tCkBAIC0zODgsMTYgKzM4OCwxNiBAQAogCSAgY2xhc3MuCiAKIGNvbmZpZyBISURfUElDT0xDRF9MQ0QKLQlib29sICJDb250cmFzdCBjb250cm9sIiBpZiBFTUJFRERFRAotCWRlZmF1bHQgIUVNQkVEREVECisJYm9vbCAiQ29udHJhc3QgY29udHJvbCIgaWYgRVhQRVJUCisJZGVmYXVsdCAhRVhQRVJUCiAJZGVwZW5kcyBvbiBISURfUElDT0xDRAogCWRlcGVuZHMgb24gSElEX1BJQ09MQ0Q9TENEX0NMQVNTX0RFVklDRSB8fCBMQ0RfQ0xBU1NfREVWSUNFPXkKIAktLS1oZWxwLS0tCiAJICBQcm92aWRlIGFjY2VzcyB0byBQaWNvTENEJ3MgTENEIGNvbnRyYXN0IHZpYSBsY2QgY2xhc3MuCiAKIGNvbmZpZyBISURfUElDT0xDRF9MRURTCi0JYm9vbCAiR1BPIHZpYSBsZWRzIGNsYXNzIiBpZiBFTUJFRERFRAotCWRlZmF1bHQgIUVNQkVEREVECisJYm9vbCAiR1BPIHZpYSBsZWRzIGNsYXNzIiBpZiBFWFBFUlQKKwlkZWZhdWx0ICFFWFBFUlQKIAlkZXBlbmRzIG9uIEhJRF9QSUNPTENECiAJZGVwZW5kcyBvbiBISURfUElDT0xDRD1MRURTX0NMQVNTIHx8IExFRFNfQ0xBU1M9eQogCS0tLWhlbHAtLS0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaGlkL3VzYmhpZC9LY29uZmlnIGIvZHJpdmVycy9oaWQvdXNiaGlkL0tjb25maWcKaW5kZXggNGVkYjNiZS4uMGYyMGZkMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9oaWQvdXNiaGlkL0tjb25maWcKKysrIGIvZHJpdmVycy9oaWQvdXNiaGlkL0tjb25maWcKQEAgLTQ1LDcgKzQ1LDcgQEAKIAkgIElmIHVuc3VyZSwgc2F5IFkuCiAKIG1lbnUgIlVTQiBISUQgQm9vdCBQcm90b2NvbCBkcml2ZXJzIgotCWRlcGVuZHMgb24gVVNCIT1uICYmIFVTQl9ISUQhPXkgJiYgRU1CRURERUQKKwlkZXBlbmRzIG9uIFVTQiE9biAmJiBVU0JfSElEIT15ICYmIEVYUEVSVAogCiBjb25maWcgVVNCX0tCRAogCXRyaXN0YXRlICJVU0IgSElEQlAgS2V5Ym9hcmQgKHNpbXBsZSBCb290KSBzdXBwb3J0IgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9LY29uZmlnIGIvZHJpdmVycy9od21vbi9LY29uZmlnCmluZGV4IDM1ZjAwZGEuLjc3M2U0ODQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vS2NvbmZpZworKysgYi9kcml2ZXJzL2h3bW9uL0tjb25maWcKQEAgLTYxOCw4ICs2MTgsOCBAQAogCWRlcGVuZHMgb24gSTJDCiAJc2VsZWN0IEhXTU9OX1ZJRAogCWhlbHAKLQkgIElmIHlvdSBzYXkgeWVzIGhlcmUgeW91IGdldCBzdXBwb3J0IGZvciBOYXRpb25hbCBTZW1pY29uZHVjdG9yIExNOTMKLQkgIHNlbnNvciBjaGlwcy4KKwkgIElmIHlvdSBzYXkgeWVzIGhlcmUgeW91IGdldCBzdXBwb3J0IGZvciBOYXRpb25hbCBTZW1pY29uZHVjdG9yIExNOTMsCisJICBMTTk0LCBhbmQgY29tcGF0aWJsZSBzZW5zb3IgY2hpcHMuCiAKIAkgIFRoaXMgZHJpdmVyIGNhbiBhbHNvIGJlIGJ1aWx0IGFzIGEgbW9kdWxlLiAgSWYgc28sIHRoZSBtb2R1bGUKIAkgIHdpbGwgYmUgY2FsbGVkIGxtOTMuCmRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL2FwcGxlc21jLmMgYi9kcml2ZXJzL2h3bW9uL2FwcGxlc21jLmMKaW5kZXggY2UwMzcyZjAuLjRjMDc0MzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vYXBwbGVzbWMuYworKysgYi9kcml2ZXJzL2h3bW9uL2FwcGxlc21jLmMKQEAgLTEwNzIsNiArMTA3Miw3IEBACiAJCQlub2RlLT5zZGEuZGV2X2F0dHIuc2hvdyA9IGdycC0+c2hvdzsKIAkJCW5vZGUtPnNkYS5kZXZfYXR0ci5zdG9yZSA9IGdycC0+c3RvcmU7CiAJCQlhdHRyID0gJm5vZGUtPnNkYS5kZXZfYXR0ci5hdHRyOworCQkJc3lzZnNfYXR0cl9pbml0KGF0dHIpOwogCQkJYXR0ci0+bmFtZSA9IG5vZGUtPm5hbWU7CiAJCQlhdHRyLT5tb2RlID0gU19JUlVHTyB8IChncnAtPnN0b3JlID8gU19JV1VTUiA6IDApOwogCQkJcmV0ID0gc3lzZnNfY3JlYXRlX2ZpbGUoJnBkZXYtPmRldi5rb2JqLCBhdHRyKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vYXN1c19hdGswMTEwLmMgYi9kcml2ZXJzL2h3bW9uL2FzdXNfYXRrMDExMC5jCmluZGV4IDJkNjhjZjMuLmI1ZTg5MjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vYXN1c19hdGswMTEwLmMKKysrIGIvZHJpdmVycy9od21vbi9hc3VzX2F0azAxMTAuYwpAQCAtMTMsNiArMTMsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvZG1pLmg+CiAKICNpbmNsdWRlIDxhY3BpL2FjcGkuaD4KICNpbmNsdWRlIDxhY3BpL2FjcGl4Zi5oPgpAQCAtMjIsNiArMjMsMjEgQEAKIAogI2RlZmluZSBBVEtfSElEICJBVEswMTEwIgogCitzdGF0aWMgYm9vbCBuZXdfaWY7Cittb2R1bGVfcGFyYW0obmV3X2lmLCBib29sLCAwKTsKK01PRFVMRV9QQVJNX0RFU0MobmV3X2lmLCAiT3ZlcnJpZGUgZGV0ZWN0aW9uIGhldXJpc3RpYyBhbmQgZm9yY2UgdGhlIHVzZSBvZiB0aGUgbmV3IEFUSzAxMTAgaW50ZXJmYWNlIik7CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZG1pX3N5c3RlbV9pZCBfX2luaXRjb25zdCBhdGtfZm9yY2VfbmV3X2lmW10gPSB7CisJeworCQkvKiBPbGQgaW50ZXJmYWNlIGhhcyBicm9rZW4gTUNIIHRlbXAgbW9uaXRvcmluZyAqLworCQkuaWRlbnQgPSAiQXN1cyBTYWJlcnRvb3RoIFg1OCIsCisJCS5tYXRjaGVzID0geworCQkJRE1JX01BVENIKERNSV9CT0FSRF9OQU1FLCAiU0FCRVJUT09USCBYNTgiKQorCQl9CisJfSwKKwl7IH0KK307CisKIC8qIE1pbmltdW0gdGltZSBiZXR3ZWVuIHJlYWRpbmdzLCBlbmZvcmNlZCBpbiBvcmRlciB0byBhdm9pZAogICogaG9nZ2luZyB0aGUgQ1BVLgogICovCkBAIC0xMzAyLDcgKzEzMTgsOSBAQAogCSAqIGFuYWx5c2lzIG9mIG11bHRpcGxlIERTRFRzIGluZGljYXRlcyB0aGF0IHdoZW4gYm90aCBpbnRlcmZhY2VzCiAJICogYXJlIHByZXNlbnQgdGhlIG5ldyBvbmUgKEdHUlAvR0lUTSkgaXMgbm90IGZ1bmN0aW9uYWwuCiAJICovCi0JaWYgKGRhdGEtPnJ0bXBfaGFuZGxlICYmIGRhdGEtPnJ2bHRfaGFuZGxlICYmIGRhdGEtPnJmYW5faGFuZGxlKQorCWlmIChuZXdfaWYpCisJCWRldl9pbmZvKGRldiwgIk92ZXJyaWRpbmcgaW50ZXJmYWNlIGRldGVjdGlvblxuIik7CisJaWYgKGRhdGEtPnJ0bXBfaGFuZGxlICYmIGRhdGEtPnJ2bHRfaGFuZGxlICYmIGRhdGEtPnJmYW5faGFuZGxlICYmICFuZXdfaWYpCiAJCWRhdGEtPm9sZF9pbnRlcmZhY2UgPSB0cnVlOwogCWVsc2UgaWYgKGRhdGEtPmVudW1lcmF0ZV9oYW5kbGUgJiYgZGF0YS0+cmVhZF9oYW5kbGUgJiYKIAkJCWRhdGEtPndyaXRlX2hhbmRsZSkKQEAgLTE0MjAsNiArMTQzOCw5IEBACiAJCXJldHVybiAtRUJVU1k7CiAJfQogCisJaWYgKGRtaV9jaGVja19zeXN0ZW0oYXRrX2ZvcmNlX25ld19pZikpCisJCW5ld19pZiA9IHRydWU7CisKIAlyZXQgPSBhY3BpX2J1c19yZWdpc3Rlcl9kcml2ZXIoJmF0a19kcml2ZXIpOwogCWlmIChyZXQpCiAJCXByX2luZm8oImFjcGlfYnVzX3JlZ2lzdGVyX2RyaXZlciBmYWlsZWQ6ICVkXG4iLCByZXQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9lbWMxNDAzLmMgYi9kcml2ZXJzL2h3bW9uL2VtYzE0MDMuYwppbmRleCA1ZGVhOWZhLi5jZDJhNmU0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2h3bW9uL2VtYzE0MDMuYworKysgYi9kcml2ZXJzL2h3bW9uL2VtYzE0MDMuYwpAQCAtMzQ0LDcgKzM0NCw3IEBACiB9CiAKIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBzaG9ydCBlbWMxNDAzX2FkZHJlc3NfbGlzdFtdID0gewotCTB4MTgsIDB4MmEsIDB4NGMsIDB4NGQsIEkyQ19DTElFTlRfRU5ECisJMHgxOCwgMHgyOSwgMHg0YywgMHg0ZCwgSTJDX0NMSUVOVF9FTkQKIH07CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCBlbWMxNDAzX2lkdGFibGVbXSA9IHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vbGlzM2x2MDJkLmMgYi9kcml2ZXJzL2h3bW9uL2xpczNsdjAyZC5jCmluZGV4IDFiNjc0YjcuLmQ4MDVlOGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vbGlzM2x2MDJkLmMKKysrIGIvZHJpdmVycy9od21vbi9saXMzbHYwMmQuYwpAQCAtOTU3LDcgKzk1Nyw3IEBACiAKIAkvKiBiYWlsIGlmIHdlIGRpZCBub3QgZ2V0IGFuIElSUSBmcm9tIHRoZSBidXMgbGF5ZXIgKi8KIAlpZiAoIWRldi0+aXJxKSB7Ci0JCXByX2VycigiTm8gSVJRLiBEaXNhYmxpbmcgL2Rldi9mcmVlZmFsbFxuIik7CisJCXByX2RlYnVnKCJObyBJUlEuIERpc2FibGluZyAvZGV2L2ZyZWVmYWxsXG4iKTsKIAkJZ290byBvdXQ7CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL2xtNjMuYyBiL2RyaXZlcnMvaHdtb24vbG02My5jCmluZGV4IDc3NmFlYjMuLjUwOGNiMjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vbG02My5jCisrKyBiL2RyaXZlcnMvaHdtb24vbG02My5jCkBAIC05OCw2ICs5OCw5IEBACiAgKiB2YWx1ZSwgaXQgdXNlcyBzaWduZWQgOC1iaXQgdmFsdWVzIHdpdGggTFNCID0gMSBkZWdyZWUgQ2Vsc2l1cy4KICAqIEZvciByZW1vdGUgdGVtcGVyYXR1cmUsIGxvdyBhbmQgaGlnaCBsaW1pdHMsIGl0IHVzZXMgc2lnbmVkIDExLWJpdCB2YWx1ZXMKICAqIHdpdGggTFNCID0gMC4xMjUgZGVncmVlIENlbHNpdXMsIGxlZnQtanVzdGlmaWVkIGluIDE2LWJpdCByZWdpc3RlcnMuCisgKiBGb3IgTE02NCB0aGUgYWN0dWFsIHJlbW90ZSBkaW9kZSB0ZW1wZXJhdHVyZSBpcyAxNiBkZWdyZWUgQ2Vsc2l1cyBoaWdoZXIKKyAqIHRoYW4gdGhlIHJlZ2lzdGVyIHJlYWRpbmcuIFJlbW90ZSB0ZW1wZXJhdHVyZSBzZXRwb2ludHMgaGF2ZSB0byBiZQorICogYWRhcHRlZCBhY2NvcmRpbmdseS4KICAqLwogCiAjZGVmaW5lIEZBTl9GUk9NX1JFRyhyZWcpCSgocmVnKSA9PSAweEZGRkMgfHwgKHJlZykgPT0gMCA/IDAgOiBcCkBAIC0xNjUsNiArMTY4LDggQEAKIAlzdHJ1Y3QgbXV0ZXggdXBkYXRlX2xvY2s7CiAJY2hhciB2YWxpZDsgLyogemVybyB1bnRpbCBmb2xsb3dpbmcgZmllbGRzIGFyZSB2YWxpZCAqLwogCXVuc2lnbmVkIGxvbmcgbGFzdF91cGRhdGVkOyAvKiBpbiBqaWZmaWVzICovCisJaW50IGtpbmQ7CisJaW50IHRlbXAyX29mZnNldDsKIAogCS8qIHJlZ2lzdGVycyB2YWx1ZXMgKi8KIAl1OCBjb25maWcsIGNvbmZpZ19mYW47CkBAIC0yNDcsMTYgKzI1MiwzNCBAQAogCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBkYXRhLT5jb25maWdfZmFuICYgMHgyMCA/IDEgOiAyKTsKIH0KIAotc3RhdGljIHNzaXplX3Qgc2hvd190ZW1wOChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkZXZhdHRyLAotCQkJICBjaGFyICpidWYpCisvKgorICogVGhlcmUgYXJlIDhiaXQgcmVnaXN0ZXJzIGZvciBib3RoIGxvY2FsKHRlbXAxKSBhbmQgcmVtb3RlKHRlbXAyKSBzZW5zb3IuCisgKiBGb3IgcmVtb3RlIHNlbnNvciByZWdpc3RlcnMgdGVtcDJfb2Zmc2V0IGhhcyB0byBiZSBjb25zaWRlcmVkLAorICogZm9yIGxvY2FsIHNlbnNvciBpdCBtdXN0IG5vdC4KKyAqIFNvIHdlIG5lZWQgc2VwYXJhdGUgOGJpdCBhY2Nlc3NvcnMgZm9yIGxvY2FsIGFuZCByZW1vdGUgc2Vuc29yLgorICovCitzdGF0aWMgc3NpemVfdCBzaG93X2xvY2FsX3RlbXA4KHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQlzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqZGV2YXR0ciwKKwkJCQljaGFyICpidWYpCiB7CiAJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICphdHRyID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpOwogCXN0cnVjdCBsbTYzX2RhdGEgKmRhdGEgPSBsbTYzX3VwZGF0ZV9kZXZpY2UoZGV2KTsKIAlyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgVEVNUDhfRlJPTV9SRUcoZGF0YS0+dGVtcDhbYXR0ci0+aW5kZXhdKSk7CiB9CiAKLXN0YXRpYyBzc2l6ZV90IHNldF90ZW1wOChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpkdW1teSwKLQkJCSBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKK3N0YXRpYyBzc2l6ZV90IHNob3dfcmVtb3RlX3RlbXA4KHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQkgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmRldmF0dHIsCisJCQkJIGNoYXIgKmJ1ZikKK3sKKwlzdHJ1Y3Qgc2Vuc29yX2RldmljZV9hdHRyaWJ1dGUgKmF0dHIgPSB0b19zZW5zb3JfZGV2X2F0dHIoZGV2YXR0cik7CisJc3RydWN0IGxtNjNfZGF0YSAqZGF0YSA9IGxtNjNfdXBkYXRlX2RldmljZShkZXYpOworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBURU1QOF9GUk9NX1JFRyhkYXRhLT50ZW1wOFthdHRyLT5pbmRleF0pCisJCSAgICAgICArIGRhdGEtPnRlbXAyX29mZnNldCk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IHNldF9sb2NhbF90ZW1wOChzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkgICAgICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmR1bW15LAorCQkJICAgICAgIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQogewogCXN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQgPSB0b19pMmNfY2xpZW50KGRldik7CiAJc3RydWN0IGxtNjNfZGF0YSAqZGF0YSA9IGkyY19nZXRfY2xpZW50ZGF0YShjbGllbnQpOwpAQCAtMjc0LDcgKzI5Nyw4IEBACiB7CiAJc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICphdHRyID0gdG9fc2Vuc29yX2Rldl9hdHRyKGRldmF0dHIpOwogCXN0cnVjdCBsbTYzX2RhdGEgKmRhdGEgPSBsbTYzX3VwZGF0ZV9kZXZpY2UoZGV2KTsKLQlyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgVEVNUDExX0ZST01fUkVHKGRhdGEtPnRlbXAxMVthdHRyLT5pbmRleF0pKTsKKwlyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgVEVNUDExX0ZST01fUkVHKGRhdGEtPnRlbXAxMVthdHRyLT5pbmRleF0pCisJCSAgICAgICArIGRhdGEtPnRlbXAyX29mZnNldCk7CiB9CiAKIHN0YXRpYyBzc2l6ZV90IHNldF90ZW1wMTEoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqZGV2YXR0ciwKQEAgLTI5NCw3ICszMTgsNyBAQAogCWludCBuciA9IGF0dHItPmluZGV4OwogCiAJbXV0ZXhfbG9jaygmZGF0YS0+dXBkYXRlX2xvY2spOwotCWRhdGEtPnRlbXAxMVtucl0gPSBURU1QMTFfVE9fUkVHKHZhbCk7CisJZGF0YS0+dGVtcDExW25yXSA9IFRFTVAxMV9UT19SRUcodmFsIC0gZGF0YS0+dGVtcDJfb2Zmc2V0KTsKIAlpMmNfc21idXNfd3JpdGVfYnl0ZV9kYXRhKGNsaWVudCwgcmVnWyhuciAtIDEpICogMl0sCiAJCQkJICBkYXRhLT50ZW1wMTFbbnJdID4+IDgpOwogCWkyY19zbWJ1c193cml0ZV9ieXRlX2RhdGEoY2xpZW50LCByZWdbKG5yIC0gMSkgKiAyICsgMV0sCkBAIC0zMTAsNiArMzM0LDcgQEAKIHsKIAlzdHJ1Y3QgbG02M19kYXRhICpkYXRhID0gbG02M191cGRhdGVfZGV2aWNlKGRldik7CiAJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIFRFTVA4X0ZST01fUkVHKGRhdGEtPnRlbXA4WzJdKQorCQkgICAgICAgKyBkYXRhLT50ZW1wMl9vZmZzZXQKIAkJICAgICAgIC0gVEVNUDhfRlJPTV9SRUcoZGF0YS0+dGVtcDJfY3JpdF9oeXN0KSk7CiB9CiAKQEAgLTMyNCw3ICszNDksNyBAQAogCWxvbmcgaHlzdDsKIAogCW11dGV4X2xvY2soJmRhdGEtPnVwZGF0ZV9sb2NrKTsKLQloeXN0ID0gVEVNUDhfRlJPTV9SRUcoZGF0YS0+dGVtcDhbMl0pIC0gdmFsOworCWh5c3QgPSBURU1QOF9GUk9NX1JFRyhkYXRhLT50ZW1wOFsyXSkgKyBkYXRhLT50ZW1wMl9vZmZzZXQgLSB2YWw7CiAJaTJjX3NtYnVzX3dyaXRlX2J5dGVfZGF0YShjbGllbnQsIExNNjNfUkVHX1JFTU9URV9UQ1JJVF9IWVNULAogCQkJCSAgSFlTVF9UT19SRUcoaHlzdCkpOwogCW11dGV4X3VubG9jaygmZGF0YS0+dXBkYXRlX2xvY2spOwpAQCAtMzU1LDE2ICszODAsMjEgQEAKIHN0YXRpYyBERVZJQ0VfQVRUUihwd20xLCBTX0lXVVNSIHwgU19JUlVHTywgc2hvd19wd20xLCBzZXRfcHdtMSk7CiBzdGF0aWMgREVWSUNFX0FUVFIocHdtMV9lbmFibGUsIFNfSVJVR08sIHNob3dfcHdtMV9lbmFibGUsIE5VTEwpOwogCi1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX2lucHV0LCBTX0lSVUdPLCBzaG93X3RlbXA4LCBOVUxMLCAwKTsKLXN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWF4LCBTX0lXVVNSIHwgU19JUlVHTywgc2hvd190ZW1wOCwKLQlzZXRfdGVtcDgsIDEpOworc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMV9pbnB1dCwgU19JUlVHTywgc2hvd19sb2NhbF90ZW1wOCwgTlVMTCwgMCk7CitzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAxX21heCwgU19JV1VTUiB8IFNfSVJVR08sIHNob3dfbG9jYWxfdGVtcDgsCisJc2V0X2xvY2FsX3RlbXA4LCAxKTsKIAogc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMl9pbnB1dCwgU19JUlVHTywgc2hvd190ZW1wMTEsIE5VTEwsIDApOwogc3RhdGljIFNFTlNPUl9ERVZJQ0VfQVRUUih0ZW1wMl9taW4sIFNfSVdVU1IgfCBTX0lSVUdPLCBzaG93X3RlbXAxMSwKIAlzZXRfdGVtcDExLCAxKTsKIHN0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDJfbWF4LCBTX0lXVVNSIHwgU19JUlVHTywgc2hvd190ZW1wMTEsCiAJc2V0X3RlbXAxMSwgMik7Ci1zdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAyX2NyaXQsIFNfSVJVR08sIHNob3dfdGVtcDgsIE5VTEwsIDIpOworLyoKKyAqIE9uIExNNjMsIHRlbXAyX2NyaXQgY2FuIGJlIHNldCBvbmx5IG9uY2UsIHdoaWNoIHNob3VsZCBiZSBqb2IKKyAqIG9mIHRoZSBib290bG9hZGVyLgorICovCitzdGF0aWMgU0VOU09SX0RFVklDRV9BVFRSKHRlbXAyX2NyaXQsIFNfSVJVR08sIHNob3dfcmVtb3RlX3RlbXA4LAorCU5VTEwsIDIpOwogc3RhdGljIERFVklDRV9BVFRSKHRlbXAyX2NyaXRfaHlzdCwgU19JV1VTUiB8IFNfSVJVR08sIHNob3dfdGVtcDJfY3JpdF9oeXN0LAogCXNldF90ZW1wMl9jcml0X2h5c3QpOwogCkBAIC00NzksNyArNTA5LDEyIEBACiAJZGF0YS0+dmFsaWQgPSAwOwogCW11dGV4X2luaXQoJmRhdGEtPnVwZGF0ZV9sb2NrKTsKIAotCS8qIEluaXRpYWxpemUgdGhlIExNNjMgY2hpcCAqLworCS8qIFNldCB0aGUgZGV2aWNlIHR5cGUgKi8KKwlkYXRhLT5raW5kID0gaWQtPmRyaXZlcl9kYXRhOworCWlmIChkYXRhLT5raW5kID09IGxtNjQpCisJCWRhdGEtPnRlbXAyX29mZnNldCA9IDE2MDAwOworCisJLyogSW5pdGlhbGl6ZSBjaGlwICovCiAJbG02M19pbml0X2NsaWVudChuZXdfY2xpZW50KTsKIAogCS8qIFJlZ2lzdGVyIHN5c2ZzIGhvb2tzICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL2xtOTMuYyBiL2RyaXZlcnMvaHdtb24vbG05My5jCmluZGV4IGM5ZWQxNGUuLjNiNDNkZjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vbG05My5jCisrKyBiL2RyaXZlcnMvaHdtb24vbG05My5jCkBAIC0xMzUsNiArMTM1LDExIEBACiAjZGVmaW5lIExNOTNfTUZSX0lECQkweDczCiAjZGVmaW5lIExNOTNfTUZSX0lEX1BST1RPVFlQRQkweDcyCiAKKy8qIExNOTQgUkVHSVNURVIgVkFMVUVTICovCisjZGVmaW5lIExNOTRfTUZSX0lEXzIJCTB4N2EKKyNkZWZpbmUgTE05NF9NRlJfSUQJCTB4NzkKKyNkZWZpbmUgTE05NF9NRlJfSURfUFJPVE9UWVBFCTB4NzgKKwogLyogU01CdXMgY2FwYWJpbGl0aWVzICovCiAjZGVmaW5lIExNOTNfU01CVVNfRlVOQ19GVUxMIChJMkNfRlVOQ19TTUJVU19CWVRFX0RBVEEgfCBcCiAJCUkyQ19GVU5DX1NNQlVTX1dPUkRfREFUQSB8IEkyQ19GVU5DX1NNQlVTX0JMT0NLX0RBVEEpCkBAIC0yNTA0LDYgKzI1MDksNyBAQAogewogCXN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcHRlciA9IGNsaWVudC0+YWRhcHRlcjsKIAlpbnQgbWZyLCB2ZXI7CisJY29uc3QgY2hhciAqbmFtZTsKIAogCWlmICghaTJjX2NoZWNrX2Z1bmN0aW9uYWxpdHkoYWRhcHRlciwgTE05M19TTUJVU19GVU5DX01JTikpCiAJCXJldHVybiAtRU5PREVWOwpAQCAtMjUxNywxMyArMjUyMywyMyBAQAogCX0KIAogCXZlciA9IGxtOTNfcmVhZF9ieXRlKGNsaWVudCwgTE05M19SRUdfVkVSKTsKLQlpZiAodmVyICE9IExNOTNfTUZSX0lEICYmIHZlciAhPSBMTTkzX01GUl9JRF9QUk9UT1RZUEUpIHsKKwlzd2l0Y2ggKHZlcikgeworCWNhc2UgTE05M19NRlJfSUQ6CisJY2FzZSBMTTkzX01GUl9JRF9QUk9UT1RZUEU6CisJCW5hbWUgPSAibG05MyI7CisJCWJyZWFrOworCWNhc2UgTE05NF9NRlJfSURfMjoKKwljYXNlIExNOTRfTUZSX0lEOgorCWNhc2UgTE05NF9NRlJfSURfUFJPVE9UWVBFOgorCQluYW1lID0gImxtOTQiOworCQlicmVhazsKKwlkZWZhdWx0OgogCQlkZXZfZGJnKCZhZGFwdGVyLT5kZXYsCiAJCQkiZGV0ZWN0IGZhaWxlZCwgYmFkIHZlcnNpb24gaWQgMHglMDJ4IVxuIiwgdmVyKTsKIAkJcmV0dXJuIC1FTk9ERVY7CiAJfQogCi0Jc3RybGNweShpbmZvLT50eXBlLCAibG05MyIsIEkyQ19OQU1FX1NJWkUpOworCXN0cmxjcHkoaW5mby0+dHlwZSwgbmFtZSwgSTJDX05BTUVfU0laRSk7CiAJZGV2X2RiZygmYWRhcHRlci0+ZGV2LCJsb2FkaW5nICVzIGF0ICVkLDB4JTAyeFxuIiwKIAkJY2xpZW50LT5uYW1lLCBpMmNfYWRhcHRlcl9pZChjbGllbnQtPmFkYXB0ZXIpLAogCQljbGllbnQtPmFkZHIpOwpAQCAtMjYwMiw2ICsyNjE4LDcgQEAKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkIGxtOTNfaWRbXSA9IHsKIAl7ICJsbTkzIiwgMCB9LAorCXsgImxtOTQiLCAwIH0sCiAJeyB9CiB9OwogTU9EVUxFX0RFVklDRV9UQUJMRShpMmMsIGxtOTNfaWQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pMmMvYnVzc2VzL3NjeDIwMF9hY2IuYyBiL2RyaXZlcnMvaTJjL2J1c3Nlcy9zY3gyMDBfYWNiLmMKaW5kZXggNTNmYWI1MS4uOTg2ZTVmNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pMmMvYnVzc2VzL3NjeDIwMF9hY2IuYworKysgYi9kcml2ZXJzL2kyYy9idXNzZXMvc2N4MjAwX2FjYi5jCkBAIC0yOSw2ICsyOSw3IEBACiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgogI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiAjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CkBAIC00MCw2ICs0MSw3IEBACiAKIE1PRFVMRV9BVVRIT1IoIkNocmlzdGVyIFdlaW5pZ2VsIDx3aW5nZWxAbmFuby1zeXN0ZW0uY29tPiIpOwogTU9EVUxFX0RFU0NSSVBUSU9OKCJOYXRTZW1pIFNDeDIwMCBBQ0NFU1MuYnVzIERyaXZlciIpOworTU9EVUxFX0FMSUFTKCJwbGF0Zm9ybTpjczU1MzUtc21iIik7CiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CiAKICNkZWZpbmUgTUFYX0RFVklDRVMgNApAQCAtODQsMTAgKzg2LDYgQEAKIAl1OCAqcHRyOwogCWNoYXIgbmVlZHNfcmVzZXQ7CiAJdW5zaWduZWQgbGVuOwotCi0JLyogUENJIGRldmljZSBpbmZvICovCi0Jc3RydWN0IHBjaV9kZXYgKnBkZXY7Ci0JaW50IGJhcjsKIH07CiAKIC8qIFJlZ2lzdGVyIERlZmluaXRpb25zICovCkBAIC0zOTEsNyArMzg5LDcgQEAKIHN0YXRpYyBzdHJ1Y3Qgc2N4MjAwX2FjYl9pZmFjZSAqc2N4MjAwX2FjYl9saXN0Owogc3RhdGljIERFRklORV9NVVRFWChzY3gyMDBfYWNiX2xpc3RfbXV0ZXgpOwogCi1zdGF0aWMgX19pbml0IGludCBzY3gyMDBfYWNiX3Byb2JlKHN0cnVjdCBzY3gyMDBfYWNiX2lmYWNlICppZmFjZSkKK3N0YXRpYyBfX2RldmluaXQgaW50IHNjeDIwMF9hY2JfcHJvYmUoc3RydWN0IHNjeDIwMF9hY2JfaWZhY2UgKmlmYWNlKQogewogCXU4IHZhbDsKIApAQCAtNDI3LDcgKzQyNSw3IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBfX2luaXQgc3RydWN0IHNjeDIwMF9hY2JfaWZhY2UgKnNjeDIwMF9jcmVhdGVfaWZhY2UoY29uc3QgY2hhciAqdGV4dCwKK3N0YXRpYyBfX2RldmluaXQgc3RydWN0IHNjeDIwMF9hY2JfaWZhY2UgKnNjeDIwMF9jcmVhdGVfaWZhY2UoY29uc3QgY2hhciAqdGV4dCwKIAkJc3RydWN0IGRldmljZSAqZGV2LCBpbnQgaW5kZXgpCiB7CiAJc3RydWN0IHNjeDIwMF9hY2JfaWZhY2UgKmlmYWNlOwpAQCAtNDUyLDcgKzQ1MCw3IEBACiAJcmV0dXJuIGlmYWNlOwogfQogCi1zdGF0aWMgaW50IF9faW5pdCBzY3gyMDBfYWNiX2NyZWF0ZShzdHJ1Y3Qgc2N4MjAwX2FjYl9pZmFjZSAqaWZhY2UpCitzdGF0aWMgaW50IF9fZGV2aW5pdCBzY3gyMDBfYWNiX2NyZWF0ZShzdHJ1Y3Qgc2N4MjAwX2FjYl9pZmFjZSAqaWZhY2UpCiB7CiAJc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyOwogCWludCByYzsKQEAgLTQ3Miw2NyArNDcwLDMxIEBACiAJCXJldHVybiAtRU5PREVWOwogCX0KIAotCW11dGV4X2xvY2soJnNjeDIwMF9hY2JfbGlzdF9tdXRleCk7Ci0JaWZhY2UtPm5leHQgPSBzY3gyMDBfYWNiX2xpc3Q7Ci0Jc2N4MjAwX2FjYl9saXN0ID0gaWZhY2U7Ci0JbXV0ZXhfdW5sb2NrKCZzY3gyMDBfYWNiX2xpc3RfbXV0ZXgpOworCWlmICghYWRhcHRlci0+ZGV2LnBhcmVudCkgeworCQkvKiBJZiB0aGVyZSdzIG5vIGRldiwgd2UncmUgdHJhY2tpbmcgKElTQSkgaWZhY2VzIG1hbnVhbGx5ICovCisJCW11dGV4X2xvY2soJnNjeDIwMF9hY2JfbGlzdF9tdXRleCk7CisJCWlmYWNlLT5uZXh0ID0gc2N4MjAwX2FjYl9saXN0OworCQlzY3gyMDBfYWNiX2xpc3QgPSBpZmFjZTsKKwkJbXV0ZXhfdW5sb2NrKCZzY3gyMDBfYWNiX2xpc3RfbXV0ZXgpOworCX0KIAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgX19pbml0IGludCBzY3gyMDBfY3JlYXRlX3BjaShjb25zdCBjaGFyICp0ZXh0LCBzdHJ1Y3QgcGNpX2RldiAqcGRldiwKLQkJaW50IGJhcikKK3N0YXRpYyBzdHJ1Y3Qgc2N4MjAwX2FjYl9pZmFjZSAqIF9fZGV2aW5pdCBzY3gyMDBfY3JlYXRlX2Rldihjb25zdCBjaGFyICp0ZXh0LAorCQl1bnNpZ25lZCBsb25nIGJhc2UsIGludCBpbmRleCwgc3RydWN0IGRldmljZSAqZGV2KQogewogCXN0cnVjdCBzY3gyMDBfYWNiX2lmYWNlICppZmFjZTsKIAlpbnQgcmM7CiAKLQlpZmFjZSA9IHNjeDIwMF9jcmVhdGVfaWZhY2UodGV4dCwgJnBkZXYtPmRldiwgMCk7CisJaWZhY2UgPSBzY3gyMDBfY3JlYXRlX2lmYWNlKHRleHQsIGRldiwgaW5kZXgpOwogCiAJaWYgKGlmYWNlID09IE5VTEwpCi0JCXJldHVybiAtRU5PTUVNOwotCi0JaWZhY2UtPnBkZXYgPSBwZGV2OwotCWlmYWNlLT5iYXIgPSBiYXI7Ci0KLQlyYyA9IHBjaV9lbmFibGVfZGV2aWNlX2lvKGlmYWNlLT5wZGV2KTsKLQlpZiAocmMpCi0JCWdvdG8gZXJyb3V0X2ZyZWU7Ci0KLQlyYyA9IHBjaV9yZXF1ZXN0X3JlZ2lvbihpZmFjZS0+cGRldiwgaWZhY2UtPmJhciwgaWZhY2UtPmFkYXB0ZXIubmFtZSk7Ci0JaWYgKHJjKSB7Ci0JCXByaW50ayhLRVJOX0VSUiBOQU1FICI6IGNhbid0IGFsbG9jYXRlIFBDSSBCQVIgJWRcbiIsCi0JCQkJaWZhY2UtPmJhcik7Ci0JCWdvdG8gZXJyb3V0X2ZyZWU7Ci0JfQotCi0JaWZhY2UtPmJhc2UgPSBwY2lfcmVzb3VyY2Vfc3RhcnQoaWZhY2UtPnBkZXYsIGlmYWNlLT5iYXIpOwotCXJjID0gc2N4MjAwX2FjYl9jcmVhdGUoaWZhY2UpOwotCi0JaWYgKHJjID09IDApCi0JCXJldHVybiAwOwotCi0JcGNpX3JlbGVhc2VfcmVnaW9uKGlmYWNlLT5wZGV2LCBpZmFjZS0+YmFyKTsKLQlwY2lfZGV2X3B1dChpZmFjZS0+cGRldik7Ci0gZXJyb3V0X2ZyZWU6Ci0Ja2ZyZWUoaWZhY2UpOwotCXJldHVybiByYzsKLX0KLQotc3RhdGljIGludCBfX2luaXQgc2N4MjAwX2NyZWF0ZV9pc2EoY29uc3QgY2hhciAqdGV4dCwgdW5zaWduZWQgbG9uZyBiYXNlLAotCQlpbnQgaW5kZXgpCi17Ci0Jc3RydWN0IHNjeDIwMF9hY2JfaWZhY2UgKmlmYWNlOwotCWludCByYzsKLQotCWlmYWNlID0gc2N4MjAwX2NyZWF0ZV9pZmFjZSh0ZXh0LCBOVUxMLCBpbmRleCk7Ci0KLQlpZiAoaWZhY2UgPT0gTlVMTCkKLQkJcmV0dXJuIC1FTk9NRU07CisJCXJldHVybiBOVUxMOwogCiAJaWYgKCFyZXF1ZXN0X3JlZ2lvbihiYXNlLCA4LCBpZmFjZS0+YWRhcHRlci5uYW1lKSkgewogCQlwcmludGsoS0VSTl9FUlIgTkFNRSAiOiBjYW4ndCBhbGxvY2F0ZSBpbyAweCVseC0weCVseFxuIiwKIAkJICAgICAgIGJhc2UsIGJhc2UgKyA4IC0gMSk7Ci0JCXJjID0gLUVCVVNZOwogCQlnb3RvIGVycm91dF9mcmVlOwogCX0KIApAQCAtNTQwLDExNSArNTAyLDExMyBAQAogCXJjID0gc2N4MjAwX2FjYl9jcmVhdGUoaWZhY2UpOwogCiAJaWYgKHJjID09IDApCi0JCXJldHVybiAwOworCQlyZXR1cm4gaWZhY2U7CiAKIAlyZWxlYXNlX3JlZ2lvbihiYXNlLCA4KTsKICBlcnJvdXRfZnJlZToKIAlrZnJlZShpZmFjZSk7Ci0JcmV0dXJuIHJjOworCXJldHVybiBOVUxMOwogfQogCi0vKiBEcml2ZXIgZGF0YSBpcyBhbiBpbmRleCBpbnRvIHRoZSBzY3gyMDBfZGF0YSBhcnJheSB0aGF0IGluZGljYXRlcwotICogdGhlIG5hbWUgYW5kIHRoZSBCQVIgd2hlcmUgdGhlIEkvTyBhZGRyZXNzIHJlc291cmNlIGlzIGxvY2F0ZWQuICBJU0EKLSAqIGRldmljZXMgYXJlIGZsYWdnZWQgd2l0aCBhIGJhciB2YWx1ZSBvZiAtMSAqLworc3RhdGljIGludCBfX2RldmluaXQgc2N4MjAwX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0IHNjeDIwMF9hY2JfaWZhY2UgKmlmYWNlOworCXN0cnVjdCByZXNvdXJjZSAqcmVzOwogCi1zdGF0aWMgY29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgc2N4MjAwX3BjaVtdIF9faW5pdGNvbnN0ID0gewotCXsgUENJX0RFVklDRShQQ0lfVkVORE9SX0lEX05TLCBQQ0lfREVWSUNFX0lEX05TX1NDeDIwMF9CUklER0UpLAotCSAgLmRyaXZlcl9kYXRhID0gMCB9LAotCXsgUENJX0RFVklDRShQQ0lfVkVORE9SX0lEX05TLCBQQ0lfREVWSUNFX0lEX05TX1NDMTEwMF9CUklER0UpLAotCSAgLmRyaXZlcl9kYXRhID0gMCB9LAotCXsgUENJX0RFVklDRShQQ0lfVkVORE9SX0lEX05TLCBQQ0lfREVWSUNFX0lEX05TX0NTNTUzNV9JU0EpLAotCSAgLmRyaXZlcl9kYXRhID0gMSB9LAotCXsgUENJX0RFVklDRShQQ0lfVkVORE9SX0lEX0FNRCwgUENJX0RFVklDRV9JRF9BTURfQ1M1NTM2X0lTQSksCi0JICAuZHJpdmVyX2RhdGEgPSAyIH0sCisJcmVzID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfSU8sIDApOworCWlmICghcmVzKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgImNhbid0IGZldGNoIGRldmljZSByZXNvdXJjZSBpbmZvXG4iKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCisJaWZhY2UgPSBzY3gyMDBfY3JlYXRlX2RldigiQ1M1NTM1IiwgcmVzLT5zdGFydCwgMCwgJnBkZXYtPmRldik7CisJaWYgKCFpZmFjZSkKKwkJcmV0dXJuIC1FSU87CisKKwlkZXZfaW5mbygmcGRldi0+ZGV2LCAiU0N4MjAwIGRldmljZSAnJXMnIHJlZ2lzdGVyZWRcbiIsCisJCQlpZmFjZS0+YWRhcHRlci5uYW1lKTsKKwlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBpZmFjZSk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgX19kZXZleGl0IHNjeDIwMF9jbGVhbnVwX2lmYWNlKHN0cnVjdCBzY3gyMDBfYWNiX2lmYWNlICppZmFjZSkKK3sKKwlpMmNfZGVsX2FkYXB0ZXIoJmlmYWNlLT5hZGFwdGVyKTsKKwlyZWxlYXNlX3JlZ2lvbihpZmFjZS0+YmFzZSwgOCk7CisJa2ZyZWUoaWZhY2UpOworfQorCitzdGF0aWMgaW50IF9fZGV2ZXhpdCBzY3gyMDBfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0IHNjeDIwMF9hY2JfaWZhY2UgKmlmYWNlOworCisJaWZhY2UgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKKwlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBOVUxMKTsKKwlzY3gyMDBfY2xlYW51cF9pZmFjZShpZmFjZSk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgc2N4MjAwX3BjaV9kcnYgPSB7CisJLmRyaXZlciA9IHsKKwkJLm5hbWUgPSAiY3M1NTM1LXNtYiIsCisJCS5vd25lciA9IFRISVNfTU9EVUxFLAorCX0sCisJLnByb2JlID0gc2N4MjAwX3Byb2JlLAorCS5yZW1vdmUgPSBfX2RldmV4aXRfcChzY3gyMDBfcmVtb3ZlKSwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcGNpX2RldmljZV9pZCBzY3gyMDBfaXNhW10gX19pbml0Y29uc3QgPSB7CisJeyBQQ0lfREVWSUNFKFBDSV9WRU5ET1JfSURfTlMsIFBDSV9ERVZJQ0VfSURfTlNfU0N4MjAwX0JSSURHRSkgfSwKKwl7IFBDSV9ERVZJQ0UoUENJX1ZFTkRPUl9JRF9OUywgUENJX0RFVklDRV9JRF9OU19TQzExMDBfQlJJREdFKSB9LAogCXsgMCwgfQogfTsKIAotc3RhdGljIHN0cnVjdCB7Ci0JY29uc3QgY2hhciAqbmFtZTsKLQlpbnQgYmFyOwotfSBzY3gyMDBfZGF0YVtdID0gewotCXsgIlNDeDIwMCIsIC0xIH0sCi0JeyAiQ1M1NTM1IiwgIDAgfSwKLQl7ICJDUzU1MzYiLCAgMCB9Ci19OwotCi1zdGF0aWMgX19pbml0IGludCBzY3gyMDBfc2Nhbl9wY2kodm9pZCkKK3N0YXRpYyBfX2luaXQgdm9pZCBzY3gyMDBfc2Nhbl9pc2Eodm9pZCkKIHsKLQlpbnQgZGF0YSwgZGV2OwotCWludCByYyA9IC1FTk9ERVY7Ci0Jc3RydWN0IHBjaV9kZXYgKnBkZXY7CisJaW50IGk7CiAKLQlmb3IoZGV2ID0gMDsgZGV2IDwgQVJSQVlfU0laRShzY3gyMDBfcGNpKTsgZGV2KyspIHsKLQkJcGRldiA9IHBjaV9nZXRfZGV2aWNlKHNjeDIwMF9wY2lbZGV2XS52ZW5kb3IsCi0JCQkJc2N4MjAwX3BjaVtkZXZdLmRldmljZSwgTlVMTCk7CisJaWYgKCFwY2lfZGV2X3ByZXNlbnQoc2N4MjAwX2lzYSkpCisJCXJldHVybjsKIAotCQlpZiAocGRldiA9PSBOVUxMKQorCWZvciAoaSA9IDA7IGkgPCBNQVhfREVWSUNFUzsgKytpKSB7CisJCWlmIChiYXNlW2ldID09IDApCiAJCQljb250aW51ZTsKIAotCQlkYXRhID0gc2N4MjAwX3BjaVtkZXZdLmRyaXZlcl9kYXRhOwotCi0JCS8qIGlmIC5iYXIgaXMgZ3JlYXRlciBvciBlcXVhbCB0byB6ZXJvLCB0aGlzIGlzIGEKLQkJICogUENJIGRldmljZSAtIG90aGVyd2lzZSwgd2UgYXNzdW1lCi0JCSAgIHRoYXQgdGhlIHBvcnRzIGFyZSBJU0EgYmFzZWQKLQkJKi8KLQotCQlpZiAoc2N4MjAwX2RhdGFbZGF0YV0uYmFyID49IDApCi0JCQlyYyA9IHNjeDIwMF9jcmVhdGVfcGNpKHNjeDIwMF9kYXRhW2RhdGFdLm5hbWUsIHBkZXYsCi0JCQkJCXNjeDIwMF9kYXRhW2RhdGFdLmJhcik7Ci0JCWVsc2UgewotCQkJaW50IGk7Ci0KLQkJCXBjaV9kZXZfcHV0KHBkZXYpOwotCQkJZm9yIChpID0gMDsgaSA8IE1BWF9ERVZJQ0VTOyArK2kpIHsKLQkJCQlpZiAoYmFzZVtpXSA9PSAwKQotCQkJCQljb250aW51ZTsKLQotCQkJCXJjID0gc2N4MjAwX2NyZWF0ZV9pc2Eoc2N4MjAwX2RhdGFbZGF0YV0ubmFtZSwKLQkJCQkJCWJhc2VbaV0sCi0JCQkJCQlpKTsKLQkJCX0KLQkJfQotCi0JCWJyZWFrOworCQkvKiBYWFg6IHNob3VsZCB3ZSBjYXJlIGFib3V0IGZhaWx1cmVzPyAqLworCQlzY3gyMDBfY3JlYXRlX2RldigiU0N4MjAwIiwgYmFzZVtpXSwgaSwgTlVMTCk7CiAJfQotCi0JcmV0dXJuIHJjOwogfQogCiBzdGF0aWMgaW50IF9faW5pdCBzY3gyMDBfYWNiX2luaXQodm9pZCkKIHsKLQlpbnQgcmM7Ci0KIAlwcl9kZWJ1ZyhOQU1FICI6IE5hdFNlbWkgU0N4MjAwIEFDQ0VTUy5idXMgRHJpdmVyXG4iKTsKIAotCXJjID0gc2N4MjAwX3NjYW5fcGNpKCk7CisJLyogRmlyc3Qgc2NhbiBmb3IgSVNBLWJhc2VkIGRldmljZXMgKi8KKwlzY3gyMDBfc2Nhbl9pc2EoKTsJLyogWFhYOiBzaG91bGQgd2UgY2FyZSBhYm91dCBlcnJvcnM/ICovCiAKIAkvKiBJZiBhdCBsZWFzdCBvbmUgYnVzIHdhcyBjcmVhdGVkLCBpbml0IG11c3Qgc3VjY2VlZCAqLwogCWlmIChzY3gyMDBfYWNiX2xpc3QpCiAJCXJldHVybiAwOwotCXJldHVybiByYzsKKworCS8qIE5vIElTQSBkZXZpY2VzOyByZWdpc3RlciB0aGUgcGxhdGZvcm0gZHJpdmVyIGZvciBQQ0ktYmFzZWQgZGV2aWNlcyAqLworCXJldHVybiBwbGF0Zm9ybV9kcml2ZXJfcmVnaXN0ZXIoJnNjeDIwMF9wY2lfZHJ2KTsKIH0KIAogc3RhdGljIHZvaWQgX19leGl0IHNjeDIwMF9hY2JfY2xlYW51cCh2b2lkKQogewogCXN0cnVjdCBzY3gyMDBfYWNiX2lmYWNlICppZmFjZTsKIAorCXBsYXRmb3JtX2RyaXZlcl91bnJlZ2lzdGVyKCZzY3gyMDBfcGNpX2Rydik7CisKIAltdXRleF9sb2NrKCZzY3gyMDBfYWNiX2xpc3RfbXV0ZXgpOwogCXdoaWxlICgoaWZhY2UgPSBzY3gyMDBfYWNiX2xpc3QpICE9IE5VTEwpIHsKIAkJc2N4MjAwX2FjYl9saXN0ID0gaWZhY2UtPm5leHQ7CiAJCW11dGV4X3VubG9jaygmc2N4MjAwX2FjYl9saXN0X211dGV4KTsKIAotCQlpMmNfZGVsX2FkYXB0ZXIoJmlmYWNlLT5hZGFwdGVyKTsKKwkJc2N4MjAwX2NsZWFudXBfaWZhY2UoaWZhY2UpOwogCi0JCWlmIChpZmFjZS0+cGRldikgewotCQkJcGNpX3JlbGVhc2VfcmVnaW9uKGlmYWNlLT5wZGV2LCBpZmFjZS0+YmFyKTsKLQkJCXBjaV9kZXZfcHV0KGlmYWNlLT5wZGV2KTsKLQkJfQotCQllbHNlCi0JCQlyZWxlYXNlX3JlZ2lvbihpZmFjZS0+YmFzZSwgOCk7Ci0KLQkJa2ZyZWUoaWZhY2UpOwogCQltdXRleF9sb2NrKCZzY3gyMDBfYWNiX2xpc3RfbXV0ZXgpOwogCX0KIAltdXRleF91bmxvY2soJnNjeDIwMF9hY2JfbGlzdF9tdXRleCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2kyYy9pMmMtY29yZS5jIGIvZHJpdmVycy9pMmMvaTJjLWNvcmUuYwppbmRleCBjN2RiNjk4Li5mMGJkNWJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2kyYy9pMmMtY29yZS5jCisrKyBiL2RyaXZlcnMvaTJjL2kyYy1jb3JlLmMKQEAgLTE5Niw4OCArMTk2LDYwIEBACiB7CiAJY29uc3Qgc3RydWN0IGRldl9wbV9vcHMgKnBtID0gZGV2LT5kcml2ZXIgPyBkZXYtPmRyaXZlci0+cG0gOiBOVUxMOwogCi0JaWYgKHBtKSB7Ci0JCWlmIChwbV9ydW50aW1lX3N1c3BlbmRlZChkZXYpKQotCQkJcmV0dXJuIDA7Ci0JCWVsc2UKLQkJCXJldHVybiBwbS0+c3VzcGVuZCA/IHBtLT5zdXNwZW5kKGRldikgOiAwOwotCX0KLQotCXJldHVybiBpMmNfbGVnYWN5X3N1c3BlbmQoZGV2LCBQTVNHX1NVU1BFTkQpOworCWlmIChwbSkKKwkJcmV0dXJuIHBtX2dlbmVyaWNfc3VzcGVuZChkZXYpOworCWVsc2UKKwkJcmV0dXJuIGkyY19sZWdhY3lfc3VzcGVuZChkZXYsIFBNU0dfU1VTUEVORCk7CiB9CiAKIHN0YXRpYyBpbnQgaTJjX2RldmljZV9wbV9yZXN1bWUoc3RydWN0IGRldmljZSAqZGV2KQogewogCWNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzICpwbSA9IGRldi0+ZHJpdmVyID8gZGV2LT5kcml2ZXItPnBtIDogTlVMTDsKLQlpbnQgcmV0OwogCiAJaWYgKHBtKQotCQlyZXQgPSBwbS0+cmVzdW1lID8gcG0tPnJlc3VtZShkZXYpIDogMDsKKwkJcmV0dXJuIHBtX2dlbmVyaWNfcmVzdW1lKGRldik7CiAJZWxzZQotCQlyZXQgPSBpMmNfbGVnYWN5X3Jlc3VtZShkZXYpOwotCi0JcmV0dXJuIHJldDsKKwkJcmV0dXJuIGkyY19sZWdhY3lfcmVzdW1lKGRldik7CiB9CiAKIHN0YXRpYyBpbnQgaTJjX2RldmljZV9wbV9mcmVlemUoc3RydWN0IGRldmljZSAqZGV2KQogewogCWNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzICpwbSA9IGRldi0+ZHJpdmVyID8gZGV2LT5kcml2ZXItPnBtIDogTlVMTDsKIAotCWlmIChwbSkgewotCQlpZiAocG1fcnVudGltZV9zdXNwZW5kZWQoZGV2KSkKLQkJCXJldHVybiAwOwotCQllbHNlCi0JCQlyZXR1cm4gcG0tPmZyZWV6ZSA/IHBtLT5mcmVlemUoZGV2KSA6IDA7Ci0JfQotCi0JcmV0dXJuIGkyY19sZWdhY3lfc3VzcGVuZChkZXYsIFBNU0dfRlJFRVpFKTsKKwlpZiAocG0pCisJCXJldHVybiBwbV9nZW5lcmljX2ZyZWV6ZShkZXYpOworCWVsc2UKKwkJcmV0dXJuIGkyY19sZWdhY3lfc3VzcGVuZChkZXYsIFBNU0dfRlJFRVpFKTsKIH0KIAogc3RhdGljIGludCBpMmNfZGV2aWNlX3BtX3RoYXcoc3RydWN0IGRldmljZSAqZGV2KQogewogCWNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzICpwbSA9IGRldi0+ZHJpdmVyID8gZGV2LT5kcml2ZXItPnBtIDogTlVMTDsKIAotCWlmIChwbSkgewotCQlpZiAocG1fcnVudGltZV9zdXNwZW5kZWQoZGV2KSkKLQkJCXJldHVybiAwOwotCQllbHNlCi0JCQlyZXR1cm4gcG0tPnRoYXcgPyBwbS0+dGhhdyhkZXYpIDogMDsKLQl9Ci0KLQlyZXR1cm4gaTJjX2xlZ2FjeV9yZXN1bWUoZGV2KTsKKwlpZiAocG0pCisJCXJldHVybiBwbV9nZW5lcmljX3RoYXcoZGV2KTsKKwllbHNlCisJCXJldHVybiBpMmNfbGVnYWN5X3Jlc3VtZShkZXYpOwogfQogCiBzdGF0aWMgaW50IGkyY19kZXZpY2VfcG1fcG93ZXJvZmYoc3RydWN0IGRldmljZSAqZGV2KQogewogCWNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzICpwbSA9IGRldi0+ZHJpdmVyID8gZGV2LT5kcml2ZXItPnBtIDogTlVMTDsKIAotCWlmIChwbSkgewotCQlpZiAocG1fcnVudGltZV9zdXNwZW5kZWQoZGV2KSkKLQkJCXJldHVybiAwOwotCQllbHNlCi0JCQlyZXR1cm4gcG0tPnBvd2Vyb2ZmID8gcG0tPnBvd2Vyb2ZmKGRldikgOiAwOwotCX0KLQotCXJldHVybiBpMmNfbGVnYWN5X3N1c3BlbmQoZGV2LCBQTVNHX0hJQkVSTkFURSk7CisJaWYgKHBtKQorCQlyZXR1cm4gcG1fZ2VuZXJpY19wb3dlcm9mZihkZXYpOworCWVsc2UKKwkJcmV0dXJuIGkyY19sZWdhY3lfc3VzcGVuZChkZXYsIFBNU0dfSElCRVJOQVRFKTsKIH0KIAogc3RhdGljIGludCBpMmNfZGV2aWNlX3BtX3Jlc3RvcmUoc3RydWN0IGRldmljZSAqZGV2KQogewogCWNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzICpwbSA9IGRldi0+ZHJpdmVyID8gZGV2LT5kcml2ZXItPnBtIDogTlVMTDsKLQlpbnQgcmV0OwogCiAJaWYgKHBtKQotCQlyZXQgPSBwbS0+cmVzdG9yZSA/IHBtLT5yZXN0b3JlKGRldikgOiAwOworCQlyZXR1cm4gcG1fZ2VuZXJpY19yZXN0b3JlKGRldik7CiAJZWxzZQotCQlyZXQgPSBpMmNfbGVnYWN5X3Jlc3VtZShkZXYpOwotCi0JaWYgKCFyZXQpIHsKLQkJcG1fcnVudGltZV9kaXNhYmxlKGRldik7Ci0JCXBtX3J1bnRpbWVfc2V0X2FjdGl2ZShkZXYpOwotCQlwbV9ydW50aW1lX2VuYWJsZShkZXYpOwotCX0KLQotCXJldHVybiByZXQ7CisJCXJldHVybiBpMmNfbGVnYWN5X3Jlc3VtZShkZXYpOwogfQogI2Vsc2UgLyogIUNPTkZJR19QTV9TTEVFUCAqLwogI2RlZmluZSBpMmNfZGV2aWNlX3BtX3N1c3BlbmQJTlVMTApAQCAtMTAyMSw2ICs5OTMsMTQgQEAKIHN0YXRpYyBpbnQgX191bnJlZ2lzdGVyX2NsaWVudChzdHJ1Y3QgZGV2aWNlICpkZXYsIHZvaWQgKmR1bW15KQogewogCXN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQgPSBpMmNfdmVyaWZ5X2NsaWVudChkZXYpOworCWlmIChjbGllbnQgJiYgc3RyY21wKGNsaWVudC0+bmFtZSwgImR1bW15IikpCisJCWkyY191bnJlZ2lzdGVyX2RldmljZShjbGllbnQpOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IF9fdW5yZWdpc3Rlcl9kdW1teShzdHJ1Y3QgZGV2aWNlICpkZXYsIHZvaWQgKmR1bW15KQoreworCXN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQgPSBpMmNfdmVyaWZ5X2NsaWVudChkZXYpOwogCWlmIChjbGllbnQpCiAJCWkyY191bnJlZ2lzdGVyX2RldmljZShjbGllbnQpOwogCXJldHVybiAwOwpAQCAtMTA3NSw4ICsxMDU1LDEyIEBACiAJbXV0ZXhfdW5sb2NrKCZhZGFwLT51c2Vyc3BhY2VfY2xpZW50c19sb2NrKTsKIAogCS8qIERldGFjaCBhbnkgYWN0aXZlIGNsaWVudHMuIFRoaXMgY2FuJ3QgZmFpbCwgdGh1cyB3ZSBkbyBub3QKLQkgICBjaGVja2luZyB0aGUgcmV0dXJuZWQgdmFsdWUuICovCisJICogY2hlY2sgdGhlIHJldHVybmVkIHZhbHVlLiBUaGlzIGlzIGEgdHdvLXBhc3MgcHJvY2VzcywgYmVjYXVzZQorCSAqIHdlIGNhbid0IHJlbW92ZSB0aGUgZHVtbXkgZGV2aWNlcyBkdXJpbmcgdGhlIGZpcnN0IHBhc3M6IHRoZXkKKwkgKiBjb3VsZCBoYXZlIGJlZW4gaW5zdGFudGlhdGVkIGJ5IHJlYWwgZGV2aWNlcyB3aXNoaW5nIHRvIGNsZWFuCisJICogdGhlbSB1cCBwcm9wZXJseSwgc28gd2UgZ2l2ZSB0aGVtIGEgY2hhbmNlIHRvIGRvIHRoYXQgZmlyc3QuICovCiAJcmVzID0gZGV2aWNlX2Zvcl9lYWNoX2NoaWxkKCZhZGFwLT5kZXYsIE5VTEwsIF9fdW5yZWdpc3Rlcl9jbGllbnQpOworCXJlcyA9IGRldmljZV9mb3JfZWFjaF9jaGlsZCgmYWRhcC0+ZGV2LCBOVUxMLCBfX3VucmVnaXN0ZXJfZHVtbXkpOwogCiAjaWZkZWYgQ09ORklHX0kyQ19DT01QQVQKIAljbGFzc19jb21wYXRfcmVtb3ZlX2xpbmsoaTJjX2FkYXB0ZXJfY29tcGF0X2NsYXNzLCAmYWRhcC0+ZGV2LApAQCAtMTE0MCw2ICsxMTI0LDE0IEBACiAJaWYgKHJlcykKIAkJcmV0dXJuIHJlczsKIAorCS8qIERyaXZlcnMgc2hvdWxkIHN3aXRjaCB0byBkZXZfcG1fb3BzIGluc3RlYWQuICovCisJaWYgKGRyaXZlci0+c3VzcGVuZCkKKwkJcHJfd2FybigiaTJjLWNvcmU6IGRyaXZlciBbJXNdIHVzaW5nIGxlZ2FjeSBzdXNwZW5kIG1ldGhvZFxuIiwKKwkJCWRyaXZlci0+ZHJpdmVyLm5hbWUpOworCWlmIChkcml2ZXItPnJlc3VtZSkKKwkJcHJfd2FybigiaTJjLWNvcmU6IGRyaXZlciBbJXNdIHVzaW5nIGxlZ2FjeSByZXN1bWUgbWV0aG9kXG4iLAorCQkJZHJpdmVyLT5kcml2ZXIubmFtZSk7CisKIAlwcl9kZWJ1ZygiaTJjLWNvcmU6IGRyaXZlciBbJXNdIHJlZ2lzdGVyZWRcbiIsIGRyaXZlci0+ZHJpdmVyLm5hbWUpOwogCiAJSU5JVF9MSVNUX0hFQUQoJmRyaXZlci0+Y2xpZW50cyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lkZS9LY29uZmlnIGIvZHJpdmVycy9pZGUvS2NvbmZpZwppbmRleCA5OGNjZmViLi45ODI3YzVlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lkZS9LY29uZmlnCisrKyBiL2RyaXZlcnMvaWRlL0tjb25maWcKQEAgLTEzNCw3ICsxMzQsNyBAQAogCSAgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIGlkZS1jZC4KIAogY29uZmlnIEJMS19ERVZfSURFQ0RfVkVSQk9TRV9FUlJPUlMKLQlib29sICJWZXJib3NlIGVycm9yIGxvZ2dpbmcgZm9yIElERS9BVEFQSSBDRFJPTSBkcml2ZXIiIGlmIEVNQkVEREVECisJYm9vbCAiVmVyYm9zZSBlcnJvciBsb2dnaW5nIGZvciBJREUvQVRBUEkgQ0RST00gZHJpdmVyIiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIEJMS19ERVZfSURFQ0QKIAlkZWZhdWx0IHkKIAloZWxwCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lkbGUvaW50ZWxfaWRsZS5jIGIvZHJpdmVycy9pZGxlL2ludGVsX2lkbGUuYwppbmRleCA1NmFjMDlkLi4xZmEwOTFlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lkbGUvaW50ZWxfaWRsZS5jCisrKyBiL2RyaXZlcnMvaWRsZS9pbnRlbF9pZGxlLmMKQEAgLTU5LDYgKzU5LDggQEAKICNpbmNsdWRlIDxsaW51eC9ocnRpbWVyLmg+CS8qIGt0aW1lX2dldF9yZWFsKCkgKi8KICNpbmNsdWRlIDx0cmFjZS9ldmVudHMvcG93ZXIuaD4KICNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgorI2luY2x1ZGUgPGxpbnV4L25vdGlmaWVyLmg+CisjaW5jbHVkZSA8bGludXgvY3B1Lmg+CiAjaW5jbHVkZSA8YXNtL213YWl0Lmg+CiAKICNkZWZpbmUgSU5URUxfSURMRV9WRVJTSU9OICIwLjQiCkBAIC03Myw2ICs3NSw3IEBACiAKIHN0YXRpYyB1bnNpZ25lZCBpbnQgbXdhaXRfc3Vic3RhdGVzOwogCisjZGVmaW5lIExBUElDX1RJTUVSX0FMV0FZU19SRUxJQUJMRSAweEZGRkZGRkZGCiAvKiBSZWxpYWJsZSBMQVBJQyBUaW1lciBTdGF0ZXMsIGJpdCAxIGZvciBDMSBldGMuICAqLwogc3RhdGljIHVuc2lnbmVkIGludCBsYXBpY190aW1lcl9yZWxpYWJsZV9zdGF0ZXMgPSAoMSA8PCAxKTsJIC8qIERlZmF1bHQgdG8gb25seSBDMSAqLwogCkBAIC04Miw2ICs4NSwxNCBAQAogc3RhdGljIHN0cnVjdCBjcHVpZGxlX3N0YXRlICpjcHVpZGxlX3N0YXRlX3RhYmxlOwogCiAvKgorICogU2V0IHRoaXMgZmxhZyBmb3Igc3RhdGVzIHdoZXJlIHRoZSBIVyBmbHVzaGVzIHRoZSBUTEIgZm9yIHVzCisgKiBhbmQgc28gd2UgZG9uJ3QgbmVlZCBjcm9zcy1jYWxscyB0byBrZWVwIGl0IGNvbnNpc3RlbnQuCisgKiBJZiB0aGlzIGZsYWcgaXMgc2V0LCBTVyBmbHVzaGVzIHRoZSBUTEIsIHNvIGV2ZW4gaWYgdGhlCisgKiBIVyBkb2Vzbid0IGRvIHRoZSBmbHVzaGluZywgdGhpcyBmbGFnIGlzIHNhZmUgdG8gdXNlLgorICovCisjZGVmaW5lIENQVUlETEVfRkxBR19UTEJfRkxVU0hFRAkweDEwMDAwCisKKy8qCiAgKiBTdGF0ZXMgYXJlIGluZGV4ZWQgYnkgdGhlIGNzdGF0ZSBudW1iZXIsCiAgKiB3aGljaCBpcyBhbHNvIHRoZSBpbmRleCBpbnRvIHRoZSBNV0FJVCBoaW50IGFycmF5LgogICogVGh1cyBDMCBpcyBhIGR1bW15LgpAQCAtMTIyLDcgKzEzMyw3IEBACiAJCS5kcml2ZXJfZGF0YSA9ICh2b2lkICopIDB4MDAsCiAJCS5mbGFncyA9IENQVUlETEVfRkxBR19USU1FX1ZBTElELAogCQkuZXhpdF9sYXRlbmN5ID0gMSwKLQkJLnRhcmdldF9yZXNpZGVuY3kgPSA0LAorCQkudGFyZ2V0X3Jlc2lkZW5jeSA9IDEsCiAJCS5lbnRlciA9ICZpbnRlbF9pZGxlIH0sCiAJeyAvKiBNV0FJVCBDMiAqLwogCQkubmFtZSA9ICJTTkItQzMiLApAQCAtMTMwLDcgKzE0MSw3IEBACiAJCS5kcml2ZXJfZGF0YSA9ICh2b2lkICopIDB4MTAsCiAJCS5mbGFncyA9IENQVUlETEVfRkxBR19USU1FX1ZBTElEIHwgQ1BVSURMRV9GTEFHX1RMQl9GTFVTSEVELAogCQkuZXhpdF9sYXRlbmN5ID0gODAsCi0JCS50YXJnZXRfcmVzaWRlbmN5ID0gMTYwLAorCQkudGFyZ2V0X3Jlc2lkZW5jeSA9IDIxMSwKIAkJLmVudGVyID0gJmludGVsX2lkbGUgfSwKIAl7IC8qIE1XQUlUIEMzICovCiAJCS5uYW1lID0gIlNOQi1DNiIsCkBAIC0xMzgsNyArMTQ5LDcgQEAKIAkJLmRyaXZlcl9kYXRhID0gKHZvaWQgKikgMHgyMCwKIAkJLmZsYWdzID0gQ1BVSURMRV9GTEFHX1RJTUVfVkFMSUQgfCBDUFVJRExFX0ZMQUdfVExCX0ZMVVNIRUQsCiAJCS5leGl0X2xhdGVuY3kgPSAxMDQsCi0JCS50YXJnZXRfcmVzaWRlbmN5ID0gMjA4LAorCQkudGFyZ2V0X3Jlc2lkZW5jeSA9IDM0NSwKIAkJLmVudGVyID0gJmludGVsX2lkbGUgfSwKIAl7IC8qIE1XQUlUIEM0ICovCiAJCS5uYW1lID0gIlNOQi1DNyIsCkBAIC0xNDYsNyArMTU3LDcgQEAKIAkJLmRyaXZlcl9kYXRhID0gKHZvaWQgKikgMHgzMCwKIAkJLmZsYWdzID0gQ1BVSURMRV9GTEFHX1RJTUVfVkFMSUQgfCBDUFVJRExFX0ZMQUdfVExCX0ZMVVNIRUQsCiAJCS5leGl0X2xhdGVuY3kgPSAxMDksCi0JCS50YXJnZXRfcmVzaWRlbmN5ID0gMzAwLAorCQkudGFyZ2V0X3Jlc2lkZW5jeSA9IDM0NSwKIAkJLmVudGVyID0gJmludGVsX2lkbGUgfSwKIH07CiAKQEAgLTIyMCw4ICsyMzEsNiBAQAogCWt0X2JlZm9yZSA9IGt0aW1lX2dldF9yZWFsKCk7CiAKIAlzdG9wX2NyaXRpY2FsX3RpbWluZ3MoKTsKLQl0cmFjZV9wb3dlcl9zdGFydChQT1dFUl9DU1RBVEUsIChlYXggPj4gNCkgKyAxLCBjcHUpOwotCXRyYWNlX2NwdV9pZGxlKChlYXggPj4gNCkgKyAxLCBjcHUpOwogCWlmICghbmVlZF9yZXNjaGVkKCkpIHsKIAogCQlfX21vbml0b3IoKHZvaWQgKikmY3VycmVudF90aHJlYWRfaW5mbygpLT5mbGFncywgMCwgMCk7CkBAIC0yNDMsNiArMjUyLDM1IEBACiAJcmV0dXJuIHVzZWNfZGVsdGE7CiB9CiAKK3N0YXRpYyB2b2lkIF9fc2V0dXBfYnJvYWRjYXN0X3RpbWVyKHZvaWQgKmFyZykKK3sKKwl1bnNpZ25lZCBsb25nIHJlYXNvbiA9ICh1bnNpZ25lZCBsb25nKWFyZzsKKwlpbnQgY3B1ID0gc21wX3Byb2Nlc3Nvcl9pZCgpOworCisJcmVhc29uID0gcmVhc29uID8KKwkJQ0xPQ0tfRVZUX05PVElGWV9CUk9BRENBU1RfT04gOiBDTE9DS19FVlRfTk9USUZZX0JST0FEQ0FTVF9PRkY7CisKKwljbG9ja2V2ZW50c19ub3RpZnkocmVhc29uLCAmY3B1KTsKK30KKworc3RhdGljIGludCBzZXR1cF9icm9hZGNhc3RfY3B1aHBfbm90aWZ5KHN0cnVjdCBub3RpZmllcl9ibG9jayAqbiwKKwkJdW5zaWduZWQgbG9uZyBhY3Rpb24sIHZvaWQgKmhjcHUpCit7CisJaW50IGhvdGNwdSA9ICh1bnNpZ25lZCBsb25nKWhjcHU7CisKKwlzd2l0Y2ggKGFjdGlvbiAmIDB4ZikgeworCWNhc2UgQ1BVX09OTElORToKKwkJc21wX2NhbGxfZnVuY3Rpb25fc2luZ2xlKGhvdGNwdSwgX19zZXR1cF9icm9hZGNhc3RfdGltZXIsCisJCQkodm9pZCAqKXRydWUsIDEpOworCQlicmVhazsKKwl9CisJcmV0dXJuIE5PVElGWV9PSzsKK30KKworc3RhdGljIHN0cnVjdCBub3RpZmllcl9ibG9jayBzZXR1cF9icm9hZGNhc3Rfbm90aWZpZXIgPSB7CisJLm5vdGlmaWVyX2NhbGwgPSBzZXR1cF9icm9hZGNhc3RfY3B1aHBfbm90aWZ5LAorfTsKKwogLyoKICAqIGludGVsX2lkbGVfcHJvYmUoKQogICovCkBAIC0zMDUsNyArMzQzLDExIEBACiAJfQogCiAJaWYgKGJvb3RfY3B1X2hhcyhYODZfRkVBVFVSRV9BUkFUKSkJLyogQWx3YXlzIFJlbGlhYmxlIEFQSUMgVGltZXIgKi8KLQkJbGFwaWNfdGltZXJfcmVsaWFibGVfc3RhdGVzID0gMHhGRkZGRkZGRjsKKwkJbGFwaWNfdGltZXJfcmVsaWFibGVfc3RhdGVzID0gTEFQSUNfVElNRVJfQUxXQVlTX1JFTElBQkxFOworCWVsc2UgeworCQlzbXBfY2FsbF9mdW5jdGlvbihfX3NldHVwX2Jyb2FkY2FzdF90aW1lciwgKHZvaWQgKil0cnVlLCAxKTsKKwkJcmVnaXN0ZXJfY3B1X25vdGlmaWVyKCZzZXR1cF9icm9hZGNhc3Rfbm90aWZpZXIpOworCX0KIAogCXByX2RlYnVnKFBSRUZJWCAidiIgSU5URUxfSURMRV9WRVJTSU9OCiAJCSIgbW9kZWwgMHglWFxuIiwgYm9vdF9jcHVfZGF0YS54ODZfbW9kZWwpOwpAQCAtNDAzLDYgKzQ0NSwxMCBAQAogewogCWludCByZXR2YWw7CiAKKwkvKiBEbyBub3QgbG9hZCBpbnRlbF9pZGxlIGF0IGFsbCBmb3Igbm93IGlmIGlkbGU9IGlzIHBhc3NlZCAqLworCWlmIChib290X29wdGlvbl9pZGxlX292ZXJyaWRlICE9IElETEVfTk9fT1ZFUlJJREUpCisJCXJldHVybiAtRU5PREVWOworCiAJcmV0dmFsID0gaW50ZWxfaWRsZV9wcm9iZSgpOwogCWlmIChyZXR2YWwpCiAJCXJldHVybiByZXR2YWw7CkBAIC00MjgsNiArNDc0LDExIEBACiAJaW50ZWxfaWRsZV9jcHVpZGxlX2RldmljZXNfdW5pbml0KCk7CiAJY3B1aWRsZV91bnJlZ2lzdGVyX2RyaXZlcigmaW50ZWxfaWRsZV9kcml2ZXIpOwogCisJaWYgKGxhcGljX3RpbWVyX3JlbGlhYmxlX3N0YXRlcyAhPSBMQVBJQ19USU1FUl9BTFdBWVNfUkVMSUFCTEUpIHsKKwkJc21wX2NhbGxfZnVuY3Rpb24oX19zZXR1cF9icm9hZGNhc3RfdGltZXIsICh2b2lkICopZmFsc2UsIDEpOworCQl1bnJlZ2lzdGVyX2NwdV9ub3RpZmllcigmc2V0dXBfYnJvYWRjYXN0X25vdGlmaWVyKTsKKwl9CisKIAlyZXR1cm47CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9jb3JlL2NhY2hlLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvY29yZS9jYWNoZS5jCmluZGV4IDY4ODgzNTYuLmY5YmE3ZDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9jb3JlL2NhY2hlLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvY2FjaGUuYwpAQCAtMzA4LDcgKzMwOCw3IEBACiAJCQlJTklUX1dPUksoJndvcmstPndvcmssIGliX2NhY2hlX3Rhc2spOwogCQkJd29yay0+ZGV2aWNlICAgPSBldmVudC0+ZGV2aWNlOwogCQkJd29yay0+cG9ydF9udW0gPSBldmVudC0+ZWxlbWVudC5wb3J0X251bTsKLQkJCXNjaGVkdWxlX3dvcmsoJndvcmstPndvcmspOworCQkJcXVldWVfd29yayhpYl93cSwgJndvcmstPndvcmspOwogCQl9CiAJfQogfQpAQCAtMzY4LDcgKzM2OCw3IEBACiAJaW50IHA7CiAKIAlpYl91bnJlZ2lzdGVyX2V2ZW50X2hhbmRsZXIoJmRldmljZS0+Y2FjaGUuZXZlbnRfaGFuZGxlcik7Ci0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKKwlmbHVzaF93b3JrcXVldWUoaWJfd3EpOwogCiAJZm9yIChwID0gMDsgcCA8PSBlbmRfcG9ydChkZXZpY2UpIC0gc3RhcnRfcG9ydChkZXZpY2UpOyArK3ApIHsKIAkJa2ZyZWUoZGV2aWNlLT5jYWNoZS5wa2V5X2NhY2hlW3BdKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9jb3JlL2RldmljZS5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvZGV2aWNlLmMKaW5kZXggYTE5ZWZmYS4uZjc5M2JmMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvZGV2aWNlLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvZGV2aWNlLmMKQEAgLTM4LDcgKzM4LDYgQEAKICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+Ci0jaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+CiAKICNpbmNsdWRlICJjb3JlX3ByaXYuaCIKIApAQCAtNTIsNiArNTEsOSBAQAogCXZvaWQgKiAgICAgICAgICAgIGRhdGE7CiB9OwogCitzdHJ1Y3Qgd29ya3F1ZXVlX3N0cnVjdCAqaWJfd3E7CitFWFBPUlRfU1lNQk9MX0dQTChpYl93cSk7CisKIHN0YXRpYyBMSVNUX0hFQUQoZGV2aWNlX2xpc3QpOwogc3RhdGljIExJU1RfSEVBRChjbGllbnRfbGlzdCk7CiAKQEAgLTcxOCw2ICs3MjAsMTAgQEAKIHsKIAlpbnQgcmV0OwogCisJaWJfd3EgPSBhbGxvY193b3JrcXVldWUoImluZmluaWJhbmQiLCAwLCAwKTsKKwlpZiAoIWliX3dxKQorCQlyZXR1cm4gLUVOT01FTTsKKwogCXJldCA9IGliX3N5c2ZzX3NldHVwKCk7CiAJaWYgKHJldCkKIAkJcHJpbnRrKEtFUk5fV0FSTklORyAiQ291bGRuJ3QgY3JlYXRlIEluZmluaUJhbmQgZGV2aWNlIGNsYXNzXG4iKTsKQEAgLTcyNiw2ICs3MzIsNyBAQAogCWlmIChyZXQpIHsKIAkJcHJpbnRrKEtFUk5fV0FSTklORyAiQ291bGRuJ3Qgc2V0IHVwIEluZmluaUJhbmQgUF9LZXkvR0lEIGNhY2hlXG4iKTsKIAkJaWJfc3lzZnNfY2xlYW51cCgpOworCQlkZXN0cm95X3dvcmtxdWV1ZShpYl93cSk7CiAJfQogCiAJcmV0dXJuIHJldDsKQEAgLTczNiw3ICs3NDMsNyBAQAogCWliX2NhY2hlX2NsZWFudXAoKTsKIAlpYl9zeXNmc19jbGVhbnVwKCk7CiAJLyogTWFrZSBzdXJlIHRoYXQgYW55IHBlbmRpbmcgdW1lbSBhY2NvdW50aW5nIHdvcmsgaXMgZG9uZS4gKi8KLQlmbHVzaF9zY2hlZHVsZWRfd29yaygpOworCWRlc3Ryb3lfd29ya3F1ZXVlKGliX3dxKTsKIH0KIAogbW9kdWxlX2luaXQoaWJfY29yZV9pbml0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9jb3JlL3NhX3F1ZXJ5LmMgYi9kcml2ZXJzL2luZmluaWJhbmQvY29yZS9zYV9xdWVyeS5jCmluZGV4IDkxYTY2MDMuLmZiYmZhMjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9jb3JlL3NhX3F1ZXJ5LmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvc2FfcXVlcnkuYwpAQCAtNDI1LDcgKzQyNSw3IEBACiAJCXBvcnQtPnNtX2FoID0gTlVMTDsKIAkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcG9ydC0+YWhfbG9jaywgZmxhZ3MpOwogCi0JCXNjaGVkdWxlX3dvcmsoJnNhX2Rldi0+cG9ydFtldmVudC0+ZWxlbWVudC5wb3J0X251bSAtCisJCXF1ZXVlX3dvcmsoaWJfd3EsICZzYV9kZXYtPnBvcnRbZXZlbnQtPmVsZW1lbnQucG9ydF9udW0gLQogCQkJCQkgICAgc2FfZGV2LT5zdGFydF9wb3J0XS51cGRhdGVfdGFzayk7CiAJfQogfQpAQCAtMTA3OSw3ICsxMDc5LDcgQEAKIAogCWliX3VucmVnaXN0ZXJfZXZlbnRfaGFuZGxlcigmc2FfZGV2LT5ldmVudF9oYW5kbGVyKTsKIAotCWZsdXNoX3NjaGVkdWxlZF93b3JrKCk7CisJZmx1c2hfd29ya3F1ZXVlKGliX3dxKTsKIAogCWZvciAoaSA9IDA7IGkgPD0gc2FfZGV2LT5lbmRfcG9ydCAtIHNhX2Rldi0+c3RhcnRfcG9ydDsgKytpKSB7CiAJCWlmIChyZG1hX3BvcnRfZ2V0X2xpbmtfbGF5ZXIoZGV2aWNlLCBpICsgMSkgPT0gSUJfTElOS19MQVlFUl9JTkZJTklCQU5EKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvY29yZS91Y21hLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvY29yZS91Y21hLmMKaW5kZXggY2ExMmFjZi4uZWMxZTlkYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdWNtYS5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9jb3JlL3VjbWEuYwpAQCAtNjM2LDYgKzYzNiwxNiBAQAogCX0KIH0KIAorc3RhdGljIHZvaWQgdWNtYV9jb3B5X2l3X3JvdXRlKHN0cnVjdCByZG1hX3VjbV9xdWVyeV9yb3V0ZV9yZXNwICpyZXNwLAorCQkJICAgICAgIHN0cnVjdCByZG1hX3JvdXRlICpyb3V0ZSkKK3sKKwlzdHJ1Y3QgcmRtYV9kZXZfYWRkciAqZGV2X2FkZHI7CisKKwlkZXZfYWRkciA9ICZyb3V0ZS0+YWRkci5kZXZfYWRkcjsKKwlyZG1hX2FkZHJfZ2V0X2RnaWQoZGV2X2FkZHIsICh1bmlvbiBpYl9naWQgKikgJnJlc3AtPmliX3JvdXRlWzBdLmRnaWQpOworCXJkbWFfYWRkcl9nZXRfc2dpZChkZXZfYWRkciwgKHVuaW9uIGliX2dpZCAqKSAmcmVzcC0+aWJfcm91dGVbMF0uc2dpZCk7Cit9CisKIHN0YXRpYyBzc2l6ZV90IHVjbWFfcXVlcnlfcm91dGUoc3RydWN0IHVjbWFfZmlsZSAqZmlsZSwKIAkJCQljb25zdCBjaGFyIF9fdXNlciAqaW5idWYsCiAJCQkJaW50IGluX2xlbiwgaW50IG91dF9sZW4pCkBAIC02NzAsOCArNjgwLDEwIEBACiAKIAlyZXNwLm5vZGVfZ3VpZCA9IChfX2ZvcmNlIF9fdTY0KSBjdHgtPmNtX2lkLT5kZXZpY2UtPm5vZGVfZ3VpZDsKIAlyZXNwLnBvcnRfbnVtID0gY3R4LT5jbV9pZC0+cG9ydF9udW07Ci0JaWYgKHJkbWFfbm9kZV9nZXRfdHJhbnNwb3J0KGN0eC0+Y21faWQtPmRldmljZS0+bm9kZV90eXBlKSA9PSBSRE1BX1RSQU5TUE9SVF9JQikgewotCQlzd2l0Y2ggKHJkbWFfcG9ydF9nZXRfbGlua19sYXllcihjdHgtPmNtX2lkLT5kZXZpY2UsIGN0eC0+Y21faWQtPnBvcnRfbnVtKSkgeworCXN3aXRjaCAocmRtYV9ub2RlX2dldF90cmFuc3BvcnQoY3R4LT5jbV9pZC0+ZGV2aWNlLT5ub2RlX3R5cGUpKSB7CisJY2FzZSBSRE1BX1RSQU5TUE9SVF9JQjoKKwkJc3dpdGNoIChyZG1hX3BvcnRfZ2V0X2xpbmtfbGF5ZXIoY3R4LT5jbV9pZC0+ZGV2aWNlLAorCQkJY3R4LT5jbV9pZC0+cG9ydF9udW0pKSB7CiAJCWNhc2UgSUJfTElOS19MQVlFUl9JTkZJTklCQU5EOgogCQkJdWNtYV9jb3B5X2liX3JvdXRlKCZyZXNwLCAmY3R4LT5jbV9pZC0+cm91dGUpOwogCQkJYnJlYWs7CkBAIC02ODEsNiArNjkzLDEyIEBACiAJCWRlZmF1bHQ6CiAJCQlicmVhazsKIAkJfQorCQlicmVhazsKKwljYXNlIFJETUFfVFJBTlNQT1JUX0lXQVJQOgorCQl1Y21hX2NvcHlfaXdfcm91dGUoJnJlc3AsICZjdHgtPmNtX2lkLT5yb3V0ZSk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWJyZWFrOwogCX0KIAogb3V0OgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdW1lbS5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdW1lbS5jCmluZGV4IDQxNWUxODYuLmI2NDVlNTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9jb3JlL3VtZW0uYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvY29yZS91bWVtLmMKQEAgLTI2Miw3ICsyNjIsNyBAQAogCQkJdW1lbS0+bW0gICA9IG1tOwogCQkJdW1lbS0+ZGlmZiA9IGRpZmY7CiAKLQkJCXNjaGVkdWxlX3dvcmsoJnVtZW0tPndvcmspOworCQkJcXVldWVfd29yayhpYl93cSwgJnVtZW0tPndvcmspOwogCQkJcmV0dXJuOwogCQl9CiAJfSBlbHNlCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvYW1zbzExMDAvYzJfcm5pYy5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2Ftc28xMTAwL2MyX3JuaWMuYwppbmRleCA4NWNmYWU0Li44YzgxOTkyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvYW1zbzExMDAvYzJfcm5pYy5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9hbXNvMTEwMC9jMl9ybmljLmMKQEAgLTQ1OSwxMyArNDU5LDEyIEBACiAJICAgICBJQl9ERVZJQ0VfTUVNX1dJTkRPVyk7CiAKIAkvKiBBbGxvY2F0ZSB0aGUgcXB0cl9hcnJheSAqLwotCWMyZGV2LT5xcHRyX2FycmF5ID0gdm1hbGxvYyhDMl9NQVhfQ1FTICogc2l6ZW9mKHZvaWQgKikpOworCWMyZGV2LT5xcHRyX2FycmF5ID0gdnphbGxvYyhDMl9NQVhfQ1FTICogc2l6ZW9mKHZvaWQgKikpOwogCWlmICghYzJkZXYtPnFwdHJfYXJyYXkpIHsKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQogCi0JLyogSW5pYWxpemUgdGhlIHFwdHJfYXJyYXkgKi8KLQltZW1zZXQoYzJkZXYtPnFwdHJfYXJyYXksIDAsIEMyX01BWF9DUVMgKiBzaXplb2Yodm9pZCAqKSk7CisJLyogSW5pdGlhbGl6ZSB0aGUgcXB0cl9hcnJheSAqLwogCWMyZGV2LT5xcHRyX2FycmF5WzBdID0gKHZvaWQgKikgJmMyZGV2LT5yZXFfdnE7CiAJYzJkZXYtPnFwdHJfYXJyYXlbMV0gPSAodm9pZCAqKSAmYzJkZXYtPnJlcF92cTsKIAljMmRldi0+cXB0cl9hcnJheVsyXSA9ICh2b2lkICopICZjMmRldi0+YWVxOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2Ftc28xMTAwL2MyX3ZxLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvYW1zbzExMDAvYzJfdnEuYwppbmRleCA5Y2U3ODE5Yi4uMmVjNzE2ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2Ftc28xMTAwL2MyX3ZxLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2Ftc28xMTAwL2MyX3ZxLmMKQEAgLTEwNyw3ICsxMDcsNyBAQAogCXIgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3QgYzJfdnFfcmVxKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKHIpIHsKIAkJaW5pdF93YWl0cXVldWVfaGVhZCgmci0+d2FpdF9vYmplY3QpOwotCQlyLT5yZXBseV9tc2cgPSAodTY0KSBOVUxMOworCQlyLT5yZXBseV9tc2cgPSAwOwogCQlyLT5ldmVudCA9IDA7CiAJCXItPmNtX2lkID0gTlVMTDsKIAkJci0+cXAgPSBOVUxMOwpAQCAtMTIzLDcgKzEyMyw3IEBACiAgKi8KIHZvaWQgdnFfcmVxX2ZyZWUoc3RydWN0IGMyX2RldiAqYzJkZXYsIHN0cnVjdCBjMl92cV9yZXEgKnIpCiB7Ci0Jci0+cmVwbHlfbXNnID0gKHU2NCkgTlVMTDsKKwlyLT5yZXBseV9tc2cgPSAwOwogCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZyLT5yZWZjbnQpKSB7CiAJCWtmcmVlKHIpOwogCX0KQEAgLTE1MSw3ICsxNTEsNyBAQAogdm9pZCB2cV9yZXFfcHV0KHN0cnVjdCBjMl9kZXYgKmMyZGV2LCBzdHJ1Y3QgYzJfdnFfcmVxICpyKQogewogCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZyLT5yZWZjbnQpKSB7Ci0JCWlmIChyLT5yZXBseV9tc2cgIT0gKHU2NCkgTlVMTCkKKwkJaWYgKHItPnJlcGx5X21zZyAhPSAwKQogCQkJdnFfcmVwYnVmX2ZyZWUoYzJkZXYsCiAJCQkJICAgICAgICh2b2lkICopICh1bnNpZ25lZCBsb25nKSByLT5yZXBseV9tc2cpOwogCQlrZnJlZShyKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9jeGdiNC9jbS5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2N4Z2I0L2NtLmMKaW5kZXggMGRjNjJiMS4uOGIwMGU2YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2N4Z2I0L2NtLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2N4Z2I0L2NtLmMKQEAgLTM4MCw3ICszODAsNyBAQAogCQkJCQkgIDE2KSkgfCBGV19XUl9GTE9XSUQoZXAtPmh3dGlkKSk7CiAKIAlmbG93Yy0+bW5lbXZhbFswXS5tbmVtb25pYyA9IEZXX0ZMT1dDX01ORU1fUEZOVkZOOwotCWZsb3djLT5tbmVtdmFsWzBdLnZhbCA9IGNwdV90b19iZTMyKDApOworCWZsb3djLT5tbmVtdmFsWzBdLnZhbCA9IGNwdV90b19iZTMyKFBDSV9GVU5DKGVwLT5jb20uZGV2LT5yZGV2LmxsZGkucGRldi0+ZGV2Zm4pIDw8IDgpOwogCWZsb3djLT5tbmVtdmFsWzFdLm1uZW1vbmljID0gRldfRkxPV0NfTU5FTV9DSDsKIAlmbG93Yy0+bW5lbXZhbFsxXS52YWwgPSBjcHVfdG9fYmUzMihlcC0+dHhfY2hhbik7CiAJZmxvd2MtPm1uZW12YWxbMl0ubW5lbW9uaWMgPSBGV19GTE9XQ19NTkVNX1BPUlQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvY3hnYjQvcXAuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9jeGdiNC9xcC5jCmluZGV4IDIwODAwOTAuLjRmMGJlMjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9jeGdiNC9xcC5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9jeGdiNC9xcC5jCkBAIC0yMjAsNyArMjIwLDcgQEAKIAkJVl9GV19SSV9SRVNfV1JfRENBRU4oMCkgfAogCQlWX0ZXX1JJX1JFU19XUl9EQ0FDUFUoMCkgfAogCQlWX0ZXX1JJX1JFU19XUl9GQk1JTigyKSB8Ci0JCVZfRldfUklfUkVTX1dSX0ZCTUFYKDMpIHwKKwkJVl9GV19SSV9SRVNfV1JfRkJNQVgoMikgfAogCQlWX0ZXX1JJX1JFU19XUl9DSURYRlRIUkVTSE8oMCkgfAogCQlWX0ZXX1JJX1JFU19XUl9DSURYRlRIUkVTSCgwKSB8CiAJCVZfRldfUklfUkVTX1dSX0VRU0laRShlcXNpemUpKTsKQEAgLTI0Myw3ICsyNDMsNyBAQAogCQlWX0ZXX1JJX1JFU19XUl9EQ0FFTigwKSB8CiAJCVZfRldfUklfUkVTX1dSX0RDQUNQVSgwKSB8CiAJCVZfRldfUklfUkVTX1dSX0ZCTUlOKDIpIHwKLQkJVl9GV19SSV9SRVNfV1JfRkJNQVgoMykgfAorCQlWX0ZXX1JJX1JFU19XUl9GQk1BWCgyKSB8CiAJCVZfRldfUklfUkVTX1dSX0NJRFhGVEhSRVNITygwKSB8CiAJCVZfRldfUklfUkVTX1dSX0NJRFhGVEhSRVNIKDApIHwKIAkJVl9GV19SSV9SRVNfV1JfRVFTSVpFKGVxc2l6ZSkpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2VoY2EvaXB6X3B0X2ZuLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvZWhjYS9pcHpfcHRfZm4uYwppbmRleCAxNTk2ZTMwLi4xODk4ZDZlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvZWhjYS9pcHpfcHRfZm4uYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvZWhjYS9pcHpfcHRfZm4uYwpAQCAtMjIyLDE1ICsyMjIsMTQgQEAKIAlxdWV1ZS0+c21hbGxfcGFnZSA9IE5VTEw7CiAKIAkvKiBhbGxvY2F0ZSBxdWV1ZSBwYWdlIHBvaW50ZXJzICovCi0JcXVldWUtPnF1ZXVlX3BhZ2VzID0ga21hbGxvYyhucl9vZl9wYWdlcyAqIHNpemVvZih2b2lkICopLCBHRlBfS0VSTkVMKTsKKwlxdWV1ZS0+cXVldWVfcGFnZXMgPSBremFsbG9jKG5yX29mX3BhZ2VzICogc2l6ZW9mKHZvaWQgKiksIEdGUF9LRVJORUwpOwogCWlmICghcXVldWUtPnF1ZXVlX3BhZ2VzKSB7Ci0JCXF1ZXVlLT5xdWV1ZV9wYWdlcyA9IHZtYWxsb2MobnJfb2ZfcGFnZXMgKiBzaXplb2Yodm9pZCAqKSk7CisJCXF1ZXVlLT5xdWV1ZV9wYWdlcyA9IHZ6YWxsb2MobnJfb2ZfcGFnZXMgKiBzaXplb2Yodm9pZCAqKSk7CiAJCWlmICghcXVldWUtPnF1ZXVlX3BhZ2VzKSB7CiAJCQllaGNhX2dlbl9lcnIoIkNvdWxkbid0IGFsbG9jYXRlIHF1ZXVlIHBhZ2UgbGlzdCIpOwogCQkJcmV0dXJuIDA7CiAJCX0KIAl9Ci0JbWVtc2V0KHF1ZXVlLT5xdWV1ZV9wYWdlcywgMCwgbnJfb2ZfcGFnZXMgKiBzaXplb2Yodm9pZCAqKSk7CiAKIAkvKiBhbGxvY2F0ZSBhY3R1YWwgcXVldWUgcGFnZXMgKi8KIAlpZiAoaXNfc21hbGwpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF9kcml2ZXIuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF9kcml2ZXIuYwppbmRleCBiMzNmMDQ1Li40N2RiNGJmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfZHJpdmVyLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX2RyaXZlci5jCkBAIC0xOTksMTIgKzE5OSwxMSBAQAogCQlnb3RvIGJhaWw7CiAJfQogCi0JZGQgPSB2bWFsbG9jKHNpemVvZigqZGQpKTsKKwlkZCA9IHZ6YWxsb2Moc2l6ZW9mKCpkZCkpOwogCWlmICghZGQpIHsKIAkJZGQgPSBFUlJfUFRSKC1FTk9NRU0pOwogCQlnb3RvIGJhaWw7CiAJfQotCW1lbXNldChkZCwgMCwgc2l6ZW9mKCpkZCkpOwogCWRkLT5pcGF0aF91bml0ID0gLTE7CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmaXBhdGhfZGV2c19sb2NrLCBmbGFncyk7CkBAIC03NTYsNyArNzU1LDcgQEAKIAkgKi8KIAlpcGF0aF9zaHV0ZG93bl9kZXZpY2UoZGQpOwogCi0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKKwlmbHVzaF93b3JrcXVldWUoaWJfd3EpOwogCiAJaWYgKGRkLT52ZXJic19kZXYpCiAJCWlwYXRoX3VucmVnaXN0ZXJfaWJfZGV2aWNlKGRkLT52ZXJic19kZXYpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX2ZpbGVfb3BzLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfZmlsZV9vcHMuYwppbmRleCA5MjkyYTE1Li42ZDRiMjljIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfZmlsZV9vcHMuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfZmlsZV9vcHMuYwpAQCAtMTUzMCw3ICsxNTMwLDcgQEAKIAl9CiAKIAludW1fc3VicG9ydHMgPSB1aW5mby0+c3B1X3N1YnBvcnRfY250OwotCXBkLT5zdWJwb3J0X3VyZWdiYXNlID0gdm1hbGxvYyhQQUdFX1NJWkUgKiBudW1fc3VicG9ydHMpOworCXBkLT5zdWJwb3J0X3VyZWdiYXNlID0gdnphbGxvYyhQQUdFX1NJWkUgKiBudW1fc3VicG9ydHMpOwogCWlmICghcGQtPnN1YnBvcnRfdXJlZ2Jhc2UpIHsKIAkJcmV0ID0gLUVOT01FTTsKIAkJZ290byBiYWlsOwpAQCAtMTUzOCwxMyArMTUzOCwxMyBAQAogCS8qIE5vdGU6IHBkLT5wb3J0X3JjdmhkcnFfc2l6ZSBpc24ndCBpbml0aWFsaXplZCB5ZXQuICovCiAJc2l6ZSA9IEFMSUdOKGRkLT5pcGF0aF9yY3ZoZHJjbnQgKiBkZC0+aXBhdGhfcmN2aGRyZW50c2l6ZSAqCiAJCSAgICAgc2l6ZW9mKHUzMiksIFBBR0VfU0laRSkgKiBudW1fc3VicG9ydHM7Ci0JcGQtPnN1YnBvcnRfcmN2aGRyX2Jhc2UgPSB2bWFsbG9jKHNpemUpOworCXBkLT5zdWJwb3J0X3Jjdmhkcl9iYXNlID0gdnphbGxvYyhzaXplKTsKIAlpZiAoIXBkLT5zdWJwb3J0X3Jjdmhkcl9iYXNlKSB7CiAJCXJldCA9IC1FTk9NRU07CiAJCWdvdG8gYmFpbF91cmVnOwogCX0KIAotCXBkLT5zdWJwb3J0X3JjdmVncmJ1ZiA9IHZtYWxsb2MocGQtPnBvcnRfcmN2ZWdyYnVmX2NodW5rcyAqCisJcGQtPnN1YnBvcnRfcmN2ZWdyYnVmID0gdnphbGxvYyhwZC0+cG9ydF9yY3ZlZ3JidWZfY2h1bmtzICoKIAkJCQkJcGQtPnBvcnRfcmN2ZWdyYnVmX3NpemUgKgogCQkJCQludW1fc3VicG9ydHMpOwogCWlmICghcGQtPnN1YnBvcnRfcmN2ZWdyYnVmKSB7CkBAIC0xNTU2LDExICsxNTU2LDYgQEAKIAlwZC0+cG9ydF9zdWJwb3J0X2lkID0gdWluZm8tPnNwdV9zdWJwb3J0X2lkOwogCXBkLT5hY3RpdmVfc2xhdmVzID0gMTsKIAlzZXRfYml0KElQQVRIX1BPUlRfTUFTVEVSX1VOSU5JVCwgJnBkLT5wb3J0X2ZsYWcpOwotCW1lbXNldChwZC0+c3VicG9ydF91cmVnYmFzZSwgMCwgUEFHRV9TSVpFICogbnVtX3N1YnBvcnRzKTsKLQltZW1zZXQocGQtPnN1YnBvcnRfcmN2aGRyX2Jhc2UsIDAsIHNpemUpOwotCW1lbXNldChwZC0+c3VicG9ydF9yY3ZlZ3JidWYsIDAsIHBkLT5wb3J0X3JjdmVncmJ1Zl9jaHVua3MgKgotCQkJCSAgICAgICAgIHBkLT5wb3J0X3JjdmVncmJ1Zl9zaXplICoKLQkJCQkgICAgICAgICBudW1fc3VicG9ydHMpOwogCWdvdG8gYmFpbDsKIAogYmFpbF9yaGRyOgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX2luaXRfY2hpcC5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX2luaXRfY2hpcC5jCmluZGV4IDc3NjkzODIuLmZlZjBmNDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF9pbml0X2NoaXAuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfaW5pdF9jaGlwLmMKQEAgLTQ0Miw3ICs0NDIsNyBAQAogCXN0cnVjdCBwYWdlICoqcGFnZXM7CiAJZG1hX2FkZHJfdCAqYWRkcnM7CiAKLQlwYWdlcyA9IHZtYWxsb2MoZGQtPmlwYXRoX2NmZ3BvcnRzICogZGQtPmlwYXRoX3JjdnRpZGNudCAqCisJcGFnZXMgPSB2emFsbG9jKGRkLT5pcGF0aF9jZmdwb3J0cyAqIGRkLT5pcGF0aF9yY3Z0aWRjbnQgKgogCQkJc2l6ZW9mKHN0cnVjdCBwYWdlICopKTsKIAlpZiAoIXBhZ2VzKSB7CiAJCWlwYXRoX2Rldl9lcnIoZGQsICJmYWlsZWQgdG8gYWxsb2NhdGUgc2hhZG93IHBhZ2UgKiAiCkBAIC00NjEsOSArNDYxLDYgQEAKIAkJcmV0dXJuOwogCX0KIAotCW1lbXNldChwYWdlcywgMCwgZGQtPmlwYXRoX2NmZ3BvcnRzICogZGQtPmlwYXRoX3JjdnRpZGNudCAqCi0JICAgICAgIHNpemVvZihzdHJ1Y3QgcGFnZSAqKSk7Ci0KIAlkZC0+aXBhdGhfcGFnZXNoYWRvdyA9IHBhZ2VzOwogCWRkLT5pcGF0aF9waHlzc2hhZG93ID0gYWRkcnM7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfdXNlcl9wYWdlcy5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX3VzZXJfcGFnZXMuYwppbmRleCA1ZTg2ZDczLi5iYWI5Zjc0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfdXNlcl9wYWdlcy5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF91c2VyX3BhZ2VzLmMKQEAgLTIyMCw3ICsyMjAsNyBAQAogCXdvcmstPm1tID0gbW07CiAJd29yay0+bnVtX3BhZ2VzID0gbnVtX3BhZ2VzOwogCi0Jc2NoZWR1bGVfd29yaygmd29yay0+d29yayk7CisJcXVldWVfd29yayhpYl93cSwgJndvcmstPndvcmspOwogCXJldHVybjsKIAogYmFpbF9tbToKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tbHg0L21haW4uYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tbHg0L21haW4uYwppbmRleCA0Yzg1MjI0Li5jN2E2MjEzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvbWx4NC9tYWluLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L21seDQvbWFpbi5jCkBAIC02MjMsOCArNjIzLDkgQEAKIAlzdHJ1Y3QgbWx4NF9pYl9kZXYgKm1kZXYgPSB0b19tZGV2KGlicXAtPmRldmljZSk7CiAJc3RydWN0IG1seDRfaWJfcXAgKm1xcCA9IHRvX21xcChpYnFwKTsKIAotCWVyciA9IG1seDRfbXVsdGljYXN0X2F0dGFjaChtZGV2LT5kZXYsICZtcXAtPm1xcCwgZ2lkLT5yYXcsICEhKG1xcC0+ZmxhZ3MgJgotCQkJCSAgICBNTFg0X0lCX1FQX0JMT0NLX01VTFRJQ0FTVF9MT09QQkFDSykpOworCWVyciA9IG1seDRfbXVsdGljYXN0X2F0dGFjaChtZGV2LT5kZXYsICZtcXAtPm1xcCwgZ2lkLT5yYXcsCisJCQkJICAgICEhKG1xcC0+ZmxhZ3MgJiBNTFg0X0lCX1FQX0JMT0NLX01VTFRJQ0FTVF9MT09QQkFDSyksCisJCQkJICAgIE1MWDRfUFJPVE9DT0xfSUIpOwogCWlmIChlcnIpCiAJCXJldHVybiBlcnI7CiAKQEAgLTYzNSw3ICs2MzYsNyBAQAogCXJldHVybiAwOwogCiBlcnJfYWRkOgotCW1seDRfbXVsdGljYXN0X2RldGFjaChtZGV2LT5kZXYsICZtcXAtPm1xcCwgZ2lkLT5yYXcpOworCW1seDRfbXVsdGljYXN0X2RldGFjaChtZGV2LT5kZXYsICZtcXAtPm1xcCwgZ2lkLT5yYXcsIE1MWDRfUFJPVE9DT0xfSUIpOwogCXJldHVybiBlcnI7CiB9CiAKQEAgLTY2NSw3ICs2NjYsNyBAQAogCXN0cnVjdCBtbHg0X2liX2dpZF9lbnRyeSAqZ2U7CiAKIAllcnIgPSBtbHg0X211bHRpY2FzdF9kZXRhY2gobWRldi0+ZGV2LAotCQkJCSAgICAmbXFwLT5tcXAsIGdpZC0+cmF3KTsKKwkJCQkgICAgJm1xcC0+bXFwLCBnaWQtPnJhdywgTUxYNF9QUk9UT0NPTF9JQik7CiAJaWYgKGVycikKIAkJcmV0dXJuIGVycjsKIApAQCAtMTAwNSw3ICsxMDA2LDggQEAKIAlpZiAobWx4NF91YXJfYWxsb2MoZGV2LCAmaWJkZXYtPnByaXZfdWFyKSkKIAkJZ290byBlcnJfcGQ7CiAKLQlpYmRldi0+dWFyX21hcCA9IGlvcmVtYXAoaWJkZXYtPnByaXZfdWFyLnBmbiA8PCBQQUdFX1NISUZULCBQQUdFX1NJWkUpOworCWliZGV2LT51YXJfbWFwID0gaW9yZW1hcCgocGh5c19hZGRyX3QpIGliZGV2LT5wcml2X3Vhci5wZm4gPDwgUEFHRV9TSElGVCwKKwkJCQkgUEFHRV9TSVpFKTsKIAlpZiAoIWliZGV2LT51YXJfbWFwKQogCQlnb3RvIGVycl91YXI7CiAJTUxYNF9JTklUX0RPT1JCRUxMX0xPQ0soJmliZGV2LT51YXJfbG9jayk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvbXRoY2EvS2NvbmZpZyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tdGhjYS9LY29uZmlnCmluZGV4IDAzZWZjMDcuLmRhMzE0YzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tdGhjYS9LY29uZmlnCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tdGhjYS9LY29uZmlnCkBAIC03LDcgKzcsNyBAQAogCSAgKCJUYXZvciIpIGFuZCB0aGUgTVQyNTIwOCBQQ0kgRXhwcmVzcyBIQ0EgKCJBcmJlbCIpLgogCiBjb25maWcgSU5GSU5JQkFORF9NVEhDQV9ERUJVRwotCWJvb2wgIlZlcmJvc2UgZGVidWdnaW5nIG91dHB1dCIgaWYgRU1CRURERUQKKwlib29sICJWZXJib3NlIGRlYnVnZ2luZyBvdXRwdXQiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gSU5GSU5JQkFORF9NVEhDQQogCWRlZmF1bHQgeQogCS0tLWhlbHAtLS0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tdGhjYS9tdGhjYV9jYXRhcy5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L210aGNhL210aGNhX2NhdGFzLmMKaW5kZXggMGFhMDExMC4uZTRhMDhjMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L210aGNhL210aGNhX2NhdGFzLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L210aGNhL210aGNhX2NhdGFzLmMKQEAgLTE0Niw3ICsxNDYsNyBAQAogCiB2b2lkIG10aGNhX3N0YXJ0X2NhdGFzX3BvbGwoc3RydWN0IG10aGNhX2RldiAqZGV2KQogewotCXVuc2lnbmVkIGxvbmcgYWRkcjsKKwlwaHlzX2FkZHJfdCBhZGRyOwogCiAJaW5pdF90aW1lcigmZGV2LT5jYXRhc19lcnIudGltZXIpOwogCWRldi0+Y2F0YXNfZXJyLm1hcCAgPSBOVUxMOwpAQCAtMTU4LDcgKzE1OCw4IEBACiAJZGV2LT5jYXRhc19lcnIubWFwID0gaW9yZW1hcChhZGRyLCBkZXYtPmNhdGFzX2Vyci5zaXplICogNCk7CiAJaWYgKCFkZXYtPmNhdGFzX2Vyci5tYXApIHsKIAkJbXRoY2Ffd2FybihkZXYsICJjb3VsZG4ndCBtYXAgY2F0YXN0cm9waGljIGVycm9yIHJlZ2lvbiAiCi0JCQkgICAiYXQgMHglbHgvMHgleFxuIiwgYWRkciwgZGV2LT5jYXRhc19lcnIuc2l6ZSAqIDQpOworCQkJICAgImF0IDB4JWxseC8weCV4XG4iLCAodW5zaWduZWQgbG9uZyBsb25nKSBhZGRyLAorCQkJICAgZGV2LT5jYXRhc19lcnIuc2l6ZSAqIDQpOwogCQlyZXR1cm47CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvbXRoY2EvbXRoY2FfY21kLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvbXRoY2EvbXRoY2FfY21kLmMKaW5kZXggZjRjZWVjZC4uN2JmYTJhMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L210aGNhL210aGNhX2NtZC5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tdGhjYS9tdGhjYV9jbWQuYwpAQCAtNzEzLDcgKzcxMyw3IEBACiAKIHN0YXRpYyB2b2lkIG10aGNhX3NldHVwX2NtZF9kb29yYmVsbHMoc3RydWN0IG10aGNhX2RldiAqZGV2LCB1NjQgYmFzZSkKIHsKLQl1bnNpZ25lZCBsb25nIGFkZHI7CisJcGh5c19hZGRyX3QgYWRkcjsKIAl1MTYgbWF4X29mZiA9IDA7CiAJaW50IGk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tdGhjYS9tdGhjYV9lcS5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L210aGNhL210aGNhX2VxLmMKaW5kZXggOGU4YzcyOC4uNzY3ODVjNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L210aGNhL210aGNhX2VxLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L210aGNhL210aGNhX2VxLmMKQEAgLTY1Myw3ICs2NTMsNyBAQAogCQkJIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCB1bnNpZ25lZCBsb25nIHNpemUsCiAJCQkgdm9pZCBfX2lvbWVtICoqbWFwKQogewotCXVuc2lnbmVkIGxvbmcgYmFzZSA9IHBjaV9yZXNvdXJjZV9zdGFydChkZXYtPnBkZXYsIDApOworCXBoeXNfYWRkcl90IGJhc2UgPSBwY2lfcmVzb3VyY2Vfc3RhcnQoZGV2LT5wZGV2LCAwKTsKIAogCSptYXAgPSBpb3JlbWFwKGJhc2UgKyBvZmZzZXQsIHNpemUpOwogCWlmICghKm1hcCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tdGhjYS9tdGhjYV9tYWluLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvbXRoY2EvbXRoY2FfbWFpbi5jCmluZGV4IDVlZWU2NjYuLjhhNDBjZDUzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvbXRoY2EvbXRoY2FfbWFpbi5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tdGhjYS9tdGhjYV9tYWluLmMKQEAgLTc5MCw3ICs3OTAsNyBAQAogCQlnb3RvIGVycl91YXJfdGFibGVfZnJlZTsKIAl9CiAKLQlkZXYtPmthciA9IGlvcmVtYXAoZGV2LT5kcml2ZXJfdWFyLnBmbiA8PCBQQUdFX1NISUZULCBQQUdFX1NJWkUpOworCWRldi0+a2FyID0gaW9yZW1hcCgocGh5c19hZGRyX3QpIGRldi0+ZHJpdmVyX3Vhci5wZm4gPDwgUEFHRV9TSElGVCwgUEFHRV9TSVpFKTsKIAlpZiAoIWRldi0+a2FyKSB7CiAJCW10aGNhX2VycihkZXYsICJDb3VsZG4ndCBtYXAga2VybmVsIGFjY2VzcyByZWdpb24sICIKIAkJCSAgImFib3J0aW5nLlxuIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvbXRoY2EvbXRoY2FfbXIuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tdGhjYS9tdGhjYV9tci5jCmluZGV4IDA2NWIyMDguLjQ0MDQ1YzggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tdGhjYS9tdGhjYV9tci5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tdGhjYS9tdGhjYV9tci5jCkBAIC04NTMsNyArODUzLDcgQEAKIAogaW50IG10aGNhX2luaXRfbXJfdGFibGUoc3RydWN0IG10aGNhX2RldiAqZGV2KQogewotCXVuc2lnbmVkIGxvbmcgYWRkcjsKKwlwaHlzX2FkZHJfdCBhZGRyOwogCWludCBtcHRzLCBtdHRzLCBlcnIsIGk7CiAKIAllcnIgPSBtdGhjYV9hbGxvY19pbml0KCZkZXYtPm1yX3RhYmxlLm1wdF9hbGxvYywKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9uZXMvbmVzLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lcy5jCmluZGV4IDBjOWYwYWEuLjNiNGVjMzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9uZXMvbmVzLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L25lcy9uZXMuYwpAQCAtMTQ0LDYgKzE0NCw3IEBACiAJc3RydWN0IG5lc19kZXZpY2UgKm5lc2RldjsKIAlzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2OwogCXN0cnVjdCBuZXNfdm5pYyAqbmVzdm5pYzsKKwl1bnNpZ25lZCBpbnQgaXNfYm9uZGVkOwogCiAJbmVzX2RlYnVnKE5FU19EQkdfTkVUREVWLCAibmVzX2luZXRhZGRyX2V2ZW50OiBpcCBhZGRyZXNzICVwSTQsIG5ldG1hc2sgJXBJNC5cbiIsCiAJCSAgJmlmYS0+aWZhX2FkZHJlc3MsICZpZmEtPmlmYV9tYXNrKTsKQEAgLTE1Miw3ICsxNTMsOCBAQAogCQkJCW5lc2RldiwgbmVzZGV2LT5uZXRkZXZbMF0tPm5hbWUpOwogCQluZXRkZXYgPSBuZXNkZXYtPm5ldGRldlswXTsKIAkJbmVzdm5pYyA9IG5ldGRldl9wcml2KG5ldGRldik7Ci0JCWlmIChuZXRkZXYgPT0gZXZlbnRfbmV0ZGV2KSB7CisJCWlzX2JvbmRlZCA9IChuZXRkZXYtPm1hc3RlciA9PSBldmVudF9uZXRkZXYpOworCQlpZiAoKG5ldGRldiA9PSBldmVudF9uZXRkZXYpIHx8IGlzX2JvbmRlZCkgewogCQkJaWYgKG5lc3ZuaWMtPnJkbWFfZW5hYmxlZCA9PSAwKSB7CiAJCQkJbmVzX2RlYnVnKE5FU19EQkdfTkVUREVWLCAiUmV0dXJuaW5nIHdpdGhvdXQgcHJvY2Vzc2luZyBldmVudCBmb3IgJXMgc2luY2UiCiAJCQkJCQkiIFJETUEgaXMgbm90IGVuYWJsZWQuXG4iLApAQCAtMTY5LDcgKzE3MSwxMCBAQAogCQkJCQluZXNfbWFuYWdlX2FycF9jYWNoZShuZXRkZXYsIG5ldGRldi0+ZGV2X2FkZHIsCiAJCQkJCQkJbnRvaGwobmVzdm5pYy0+bG9jYWxfaXBhZGRyKSwgTkVTX0FSUF9ERUxFVEUpOwogCQkJCQluZXN2bmljLT5sb2NhbF9pcGFkZHIgPSAwOwotCQkJCQlyZXR1cm4gTk9USUZZX09LOworCQkJCQlpZiAoaXNfYm9uZGVkKQorCQkJCQkJY29udGludWU7CisJCQkJCWVsc2UKKwkJCQkJCXJldHVybiBOT1RJRllfT0s7CiAJCQkJCWJyZWFrOwogCQkJCWNhc2UgTkVUREVWX1VQOgogCQkJCQluZXNfZGVidWcoTkVTX0RCR19ORVRERVYsICJldmVudDpVUFxuIik7CkBAIC0xNzgsMTUgKzE4MywyNCBAQAogCQkJCQkJbmVzX2RlYnVnKE5FU19EQkdfTkVUREVWLCAiSW50ZXJmYWNlIGFscmVhZHkgaGFzIGxvY2FsX2lwYWRkclxuIik7CiAJCQkJCQlyZXR1cm4gTk9USUZZX09LOwogCQkJCQl9CisJCQkJCS8qIGZhbGwgdGhyb3VnaCAqLworCQkJCWNhc2UgTkVUREVWX0NIQU5HRUFERFI6CiAJCQkJCS8qIEFkZCB0aGUgYWRkcmVzcyB0byB0aGUgSVAgdGFibGUgKi8KLQkJCQkJbmVzdm5pYy0+bG9jYWxfaXBhZGRyID0gaWZhLT5pZmFfYWRkcmVzczsKKwkJCQkJaWYgKG5ldGRldi0+bWFzdGVyKQorCQkJCQkJbmVzdm5pYy0+bG9jYWxfaXBhZGRyID0KKwkJCQkJCQkoKHN0cnVjdCBpbl9kZXZpY2UgKiluZXRkZXYtPm1hc3Rlci0+aXBfcHRyKS0+aWZhX2xpc3QtPmlmYV9hZGRyZXNzOworCQkJCQllbHNlCisJCQkJCQluZXN2bmljLT5sb2NhbF9pcGFkZHIgPSBpZmEtPmlmYV9hZGRyZXNzOwogCiAJCQkJCW5lc193cml0ZV9pbmRleGVkKG5lc2RldiwKIAkJCQkJCQlORVNfSURYX0RTVF9JUF9BRERSKygweDEwKlBDSV9GVU5DKG5lc2Rldi0+cGNpZGV2LT5kZXZmbikpLAotCQkJCQkJCW50b2hsKGlmYS0+aWZhX2FkZHJlc3MpKTsKKwkJCQkJCQludG9obChuZXN2bmljLT5sb2NhbF9pcGFkZHIpKTsKIAkJCQkJbmVzX21hbmFnZV9hcnBfY2FjaGUobmV0ZGV2LCBuZXRkZXYtPmRldl9hZGRyLAogCQkJCQkJCW50b2hsKG5lc3ZuaWMtPmxvY2FsX2lwYWRkciksIE5FU19BUlBfQUREKTsKLQkJCQkJcmV0dXJuIE5PVElGWV9PSzsKKwkJCQkJaWYgKGlzX2JvbmRlZCkKKwkJCQkJCWNvbnRpbnVlOworCQkJCQllbHNlCisJCQkJCQlyZXR1cm4gTk9USUZZX09LOwogCQkJCQlicmVhazsKIAkJCQlkZWZhdWx0OgogCQkJCQlicmVhazsKQEAgLTY2MCw2ICs2NzQsOCBAQAogCX0KIAluZXNfbm90aWZpZXJzX3JlZ2lzdGVyZWQrKzsKIAorCUlOSVRfREVMQVlFRF9XT1JLKCZuZXNkZXYtPndvcmssIG5lc19yZWNoZWNrX2xpbmtfc3RhdHVzKTsKKwogCS8qIEluaXRpYWxpemUgbmV0d29yayBkZXZpY2VzICovCiAJaWYgKChuZXRkZXYgPSBuZXNfbmV0ZGV2X2luaXQobmVzZGV2LCBtbWlvX3JlZ3MpKSA9PSBOVUxMKQogCQlnb3RvIGJhaWw3OwpAQCAtNzQyLDYgKzc1OCw3IEBACiAJc3RydWN0IG5lc19kZXZpY2UgKm5lc2RldiA9IHBjaV9nZXRfZHJ2ZGF0YShwY2lkZXYpOwogCXN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXY7CiAJaW50IG5ldGRldl9pbmRleCA9IDA7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCQlpZiAobmVzZGV2LT5uZXRkZXZfY291bnQpIHsKIAkJCW5ldGRldiA9IG5lc2Rldi0+bmV0ZGV2W25ldGRldl9pbmRleF07CkBAIC03NjgsNiArNzg1LDE0IEBACiAJZnJlZV9pcnEocGNpZGV2LT5pcnEsIG5lc2Rldik7CiAJdGFza2xldF9raWxsKCZuZXNkZXYtPmRwY190YXNrbGV0KTsKIAorCXNwaW5fbG9ja19pcnFzYXZlKCZuZXNkZXYtPm5lc2FkYXB0ZXItPnBoeV9sb2NrLCBmbGFncyk7CisJaWYgKG5lc2Rldi0+bGlua19yZWNoZWNrKSB7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm5lc2Rldi0+bmVzYWRhcHRlci0+cGh5X2xvY2ssIGZsYWdzKTsKKwkJY2FuY2VsX2RlbGF5ZWRfd29ya19zeW5jKCZuZXNkZXYtPndvcmspOworCX0gZWxzZSB7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm5lc2Rldi0+bmVzYWRhcHRlci0+cGh5X2xvY2ssIGZsYWdzKTsKKwl9CisKIAkvKiBEZWFsbG9jYXRlIHRoZSBBZGFwdGVyIFN0cnVjdHVyZSAqLwogCW5lc19kZXN0cm95X2FkYXB0ZXIobmVzZGV2LT5uZXNhZGFwdGVyKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L25lcy9uZXMuaCBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9uZXMvbmVzLmgKaW5kZXggYjNkMTQ1ZS4uNmZlNzk4NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L25lcy9uZXMuaAorKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lcy5oCkBAIC0yNjgsNiArMjY4LDkgQEAKIAl1OCAgICAgICAgICAgICAgICAgICAgIG5hcGlfaXNyX3JhbjsKIAl1OCAgICAgICAgICAgICAgICAgICAgIGRpc2FibGVfcnhfZmxvd19jb250cm9sOwogCXU4ICAgICAgICAgICAgICAgICAgICAgZGlzYWJsZV90eF9mbG93X2NvbnRyb2w7CisKKwlzdHJ1Y3QgZGVsYXllZF93b3JrICAgIHdvcms7CisJdTggICAgICAgICAgICAgICAgICAgICBsaW5rX3JlY2hlY2s7CiB9OwogCiAKQEAgLTUwNyw2ICs1MTAsNyBAQAogdm9pZCBuZXNfaXdhcnBfY2VfaGFuZGxlcihzdHJ1Y3QgbmVzX2RldmljZSAqLCBzdHJ1Y3QgbmVzX2h3X2NxICopOwogaW50IG5lc19kZXN0cm95X2NxcChzdHJ1Y3QgbmVzX2RldmljZSAqKTsKIGludCBuZXNfbmljX2NtX3htaXQoc3RydWN0IHNrX2J1ZmYgKiwgc3RydWN0IG5ldF9kZXZpY2UgKik7Cit2b2lkIG5lc19yZWNoZWNrX2xpbmtfc3RhdHVzKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yayk7CiAKIC8qIG5lc19uaWMuYyAqLwogc3RydWN0IG5ldF9kZXZpY2UgKm5lc19uZXRkZXZfaW5pdChzdHJ1Y3QgbmVzX2RldmljZSAqLCB2b2lkIF9faW9tZW0gKik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc19jbS5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L25lcy9uZXNfY20uYwppbmRleCAyNWFkMGY5Li4wMDllYzgxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc19jbS5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9uZXMvbmVzX2NtLmMKQEAgLTExMDcsNiArMTEwNyw3IEBACiAJc3RydWN0IGZsb3dpIGZsOwogCXN0cnVjdCBuZWlnaGJvdXIgKm5laWdoOwogCWludCByYyA9IGFycGluZGV4OworCXN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXY7CiAJc3RydWN0IG5lc19hZGFwdGVyICpuZXNhZGFwdGVyID0gbmVzdm5pYy0+bmVzZGV2LT5uZXNhZGFwdGVyOwogCiAJbWVtc2V0KCZmbCwgMCwgc2l6ZW9mIGZsKTsKQEAgLTExMTcsNyArMTExOCwxMiBAQAogCQlyZXR1cm4gcmM7CiAJfQogCi0JbmVpZ2ggPSBuZWlnaF9sb29rdXAoJmFycF90YmwsICZydC0+cnRfZ2F0ZXdheSwgbmVzdm5pYy0+bmV0ZGV2KTsKKwlpZiAobmVzdm5pYy0+bmV0ZGV2LT5tYXN0ZXIpCisJCW5ldGRldiA9IG5lc3ZuaWMtPm5ldGRldi0+bWFzdGVyOworCWVsc2UKKwkJbmV0ZGV2ID0gbmVzdm5pYy0+bmV0ZGV2OworCisJbmVpZ2ggPSBuZWlnaF9sb29rdXAoJmFycF90YmwsICZydC0+cnRfZ2F0ZXdheSwgbmV0ZGV2KTsKIAlpZiAobmVpZ2gpIHsKIAkJaWYgKG5laWdoLT5udWRfc3RhdGUgJiBOVURfVkFMSUQpIHsKIAkJCW5lc19kZWJ1ZyhORVNfREJHX0NNLCAiTmVpZ2hib3IgTUFDIGFkZHJlc3MgZm9yIDB4JTA4WCIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9uZXMvbmVzX2h3LmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc19ody5jCmluZGV4IDE5ODBhNDYuLjhiNjA2ZmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9uZXMvbmVzX2h3LmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L25lcy9uZXNfaHcuYwpAQCAtMjYwOCw2ICsyNjA4LDEzIEBACiAJCQkJCQluZXRpZl9zdGFydF9xdWV1ZShuZXN2bmljLT5uZXRkZXYpOwogCQkJCQluZXN2bmljLT5saW5rdXAgPSAxOwogCQkJCQluZXRpZl9jYXJyaWVyX29uKG5lc3ZuaWMtPm5ldGRldik7CisKKwkJCQkJc3Bpbl9sb2NrKCZuZXN2bmljLT5wb3J0X2liZXZlbnRfbG9jayk7CisJCQkJCWlmIChuZXNkZXYtPml3X3N0YXR1cyA9PSAwKSB7CisJCQkJCQluZXNkZXYtPml3X3N0YXR1cyA9IDE7CisJCQkJCQluZXNfcG9ydF9pYmV2ZW50KG5lc3ZuaWMpOworCQkJCQl9CisJCQkJCXNwaW5fdW5sb2NrKCZuZXN2bmljLT5wb3J0X2liZXZlbnRfbG9jayk7CiAJCQkJfQogCQkJfQogCQl9IGVsc2UgewpAQCAtMjYzMyw5ICsyNjQwLDIzIEBACiAJCQkJCQluZXRpZl9zdG9wX3F1ZXVlKG5lc3ZuaWMtPm5ldGRldik7CiAJCQkJCW5lc3ZuaWMtPmxpbmt1cCA9IDA7CiAJCQkJCW5ldGlmX2NhcnJpZXJfb2ZmKG5lc3ZuaWMtPm5ldGRldik7CisKKwkJCQkJc3Bpbl9sb2NrKCZuZXN2bmljLT5wb3J0X2liZXZlbnRfbG9jayk7CisJCQkJCWlmIChuZXNkZXYtPml3X3N0YXR1cyA9PSAxKSB7CisJCQkJCQluZXNkZXYtPml3X3N0YXR1cyA9IDA7CisJCQkJCQluZXNfcG9ydF9pYmV2ZW50KG5lc3ZuaWMpOworCQkJCQl9CisJCQkJCXNwaW5fdW5sb2NrKCZuZXN2bmljLT5wb3J0X2liZXZlbnRfbG9jayk7CiAJCQkJfQogCQkJfQogCQl9CisJCWlmIChuZXNhZGFwdGVyLT5waHlfdHlwZVttYWNfaW5kZXhdID09IE5FU19QSFlfVFlQRV9TRlBfRCkgeworCQkJaWYgKG5lc2Rldi0+bGlua19yZWNoZWNrKQorCQkJCWNhbmNlbF9kZWxheWVkX3dvcmsoJm5lc2Rldi0+d29yayk7CisJCQluZXNkZXYtPmxpbmtfcmVjaGVjayA9IDE7CisJCQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJm5lc2Rldi0+d29yaywKKwkJCQkJICAgICAgTkVTX0xJTktfUkVDSEVDS19ERUxBWSk7CisJCX0KIAl9CiAKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZuZXNhZGFwdGVyLT5waHlfbG9jaywgZmxhZ3MpOwpAQCAtMjY0Myw2ICsyNjY0LDgwIEBACiAJbmVzYWRhcHRlci0+bWFjX3N3X3N0YXRlW21hY19udW1iZXJdID0gTkVTX01BQ19TV19JRExFOwogfQogCit2b2lkIG5lc19yZWNoZWNrX2xpbmtfc3RhdHVzKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXN0cnVjdCBuZXNfZGV2aWNlICpuZXNkZXYgPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0IG5lc19kZXZpY2UsIHdvcmsud29yayk7CisJc3RydWN0IG5lc19hZGFwdGVyICpuZXNhZGFwdGVyID0gbmVzZGV2LT5uZXNhZGFwdGVyOworCXN0cnVjdCBuZXNfdm5pYyAqbmVzdm5pYzsKKwl1MzIgbWFjX2luZGV4ID0gbmVzZGV2LT5tYWNfaW5kZXg7CisJdTE2IHBoeV9kYXRhOworCXUxNiB0ZW1wX3BoeV9kYXRhOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJm5lc2FkYXB0ZXItPnBoeV9sb2NrLCBmbGFncyk7CisKKwkvKiBjaGVjayBsaW5rIHN0YXR1cyAqLworCW5lc19yZWFkXzEwR19waHlfcmVnKG5lc2RldiwgbmVzYWRhcHRlci0+cGh5X2luZGV4W21hY19pbmRleF0sIDEsIDB4OTAwMyk7CisJdGVtcF9waHlfZGF0YSA9ICh1MTYpbmVzX3JlYWRfaW5kZXhlZChuZXNkZXYsIE5FU19JRFhfTUFDX01ESU9fQ09OVFJPTCk7CisKKwluZXNfcmVhZF8xMEdfcGh5X3JlZyhuZXNkZXYsIG5lc2FkYXB0ZXItPnBoeV9pbmRleFttYWNfaW5kZXhdLCAzLCAweDAwMjEpOworCW5lc19yZWFkX2luZGV4ZWQobmVzZGV2LCBORVNfSURYX01BQ19NRElPX0NPTlRST0wpOworCW5lc19yZWFkXzEwR19waHlfcmVnKG5lc2RldiwgbmVzYWRhcHRlci0+cGh5X2luZGV4W21hY19pbmRleF0sIDMsIDB4MDAyMSk7CisJcGh5X2RhdGEgPSAodTE2KW5lc19yZWFkX2luZGV4ZWQobmVzZGV2LCBORVNfSURYX01BQ19NRElPX0NPTlRST0wpOworCisJcGh5X2RhdGEgPSAoIXRlbXBfcGh5X2RhdGEgJiYgKHBoeV9kYXRhID09IDB4ODAwMCkpID8gMHg0IDogMHgwOworCisJbmVzX2RlYnVnKE5FU19EQkdfUEhZLCAiJXM6IFBoeSBkYXRhID0gMHglMDRYLCBsaW5rIHdhcyAlcy5cbiIsCisJCV9fZnVuY19fLCBwaHlfZGF0YSwKKwkJbmVzYWRhcHRlci0+bWFjX2xpbmtfZG93blttYWNfaW5kZXhdID8gIkRPV04iIDogIlVQIik7CisKKwlpZiAocGh5X2RhdGEgJiAweDAwMDQpIHsKKwkJbmVzYWRhcHRlci0+bWFjX2xpbmtfZG93blttYWNfaW5kZXhdID0gMDsKKwkJbGlzdF9mb3JfZWFjaF9lbnRyeShuZXN2bmljLCAmbmVzYWRhcHRlci0+bmVzdm5pY19saXN0W21hY19pbmRleF0sIGxpc3QpIHsKKwkJCWlmIChuZXN2bmljLT5saW5rdXAgPT0gMCkgeworCQkJCXByaW50ayhQRlggIlRoZSBMaW5rIGlzIG5vdyB1cCBmb3IgcG9ydCAlcywgbmV0ZGV2ICVwLlxuIiwKKwkJCQkJCW5lc3ZuaWMtPm5ldGRldi0+bmFtZSwgbmVzdm5pYy0+bmV0ZGV2KTsKKwkJCQlpZiAobmV0aWZfcXVldWVfc3RvcHBlZChuZXN2bmljLT5uZXRkZXYpKQorCQkJCQluZXRpZl9zdGFydF9xdWV1ZShuZXN2bmljLT5uZXRkZXYpOworCQkJCW5lc3ZuaWMtPmxpbmt1cCA9IDE7CisJCQkJbmV0aWZfY2Fycmllcl9vbihuZXN2bmljLT5uZXRkZXYpOworCisJCQkJc3Bpbl9sb2NrKCZuZXN2bmljLT5wb3J0X2liZXZlbnRfbG9jayk7CisJCQkJaWYgKG5lc2Rldi0+aXdfc3RhdHVzID09IDApIHsKKwkJCQkJbmVzZGV2LT5pd19zdGF0dXMgPSAxOworCQkJCQluZXNfcG9ydF9pYmV2ZW50KG5lc3ZuaWMpOworCQkJCX0KKwkJCQlzcGluX3VubG9jaygmbmVzdm5pYy0+cG9ydF9pYmV2ZW50X2xvY2spOworCQkJfQorCQl9CisKKwl9IGVsc2UgeworCQluZXNhZGFwdGVyLT5tYWNfbGlua19kb3duW21hY19pbmRleF0gPSAxOworCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KG5lc3ZuaWMsICZuZXNhZGFwdGVyLT5uZXN2bmljX2xpc3RbbWFjX2luZGV4XSwgbGlzdCkgeworCQkJaWYgKG5lc3ZuaWMtPmxpbmt1cCA9PSAxKSB7CisJCQkJcHJpbnRrKFBGWCAiVGhlIExpbmsgaXMgbm93IGRvd24gZm9yIHBvcnQgJXMsIG5ldGRldiAlcC5cbiIsCisJCQkJCQluZXN2bmljLT5uZXRkZXYtPm5hbWUsIG5lc3ZuaWMtPm5ldGRldik7CisJCQkJaWYgKCEobmV0aWZfcXVldWVfc3RvcHBlZChuZXN2bmljLT5uZXRkZXYpKSkKKwkJCQkJbmV0aWZfc3RvcF9xdWV1ZShuZXN2bmljLT5uZXRkZXYpOworCQkJCW5lc3ZuaWMtPmxpbmt1cCA9IDA7CisJCQkJbmV0aWZfY2Fycmllcl9vZmYobmVzdm5pYy0+bmV0ZGV2KTsKKworCQkJCXNwaW5fbG9jaygmbmVzdm5pYy0+cG9ydF9pYmV2ZW50X2xvY2spOworCQkJCWlmIChuZXNkZXYtPml3X3N0YXR1cyA9PSAxKSB7CisJCQkJCW5lc2Rldi0+aXdfc3RhdHVzID0gMDsKKwkJCQkJbmVzX3BvcnRfaWJldmVudChuZXN2bmljKTsKKwkJCQl9CisJCQkJc3Bpbl91bmxvY2soJm5lc3ZuaWMtPnBvcnRfaWJldmVudF9sb2NrKTsKKwkJCX0KKwkJfQorCX0KKwlpZiAobmVzZGV2LT5saW5rX3JlY2hlY2srKyA8IE5FU19MSU5LX1JFQ0hFQ0tfTUFYKQorCQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJm5lc2Rldi0+d29yaywgTkVTX0xJTktfUkVDSEVDS19ERUxBWSk7CisJZWxzZQorCQluZXNkZXYtPmxpbmtfcmVjaGVjayA9IDA7CisKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZuZXNhZGFwdGVyLT5waHlfbG9jaywgZmxhZ3MpOworfQogCiAKIHN0YXRpYyB2b2lkIG5lc19uaWNfbmFwaV9jZV9oYW5kbGVyKHN0cnVjdCBuZXNfZGV2aWNlICpuZXNkZXYsIHN0cnVjdCBuZXNfaHdfbmljX2NxICpjcSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9uZXMvbmVzX2h3LmggYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc19ody5oCmluZGV4IDEyMDRjMzQuLmQyYWJlMDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9uZXMvbmVzX2h3LmgKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L25lcy9uZXNfaHcuaApAQCAtMTE5Myw2ICsxMTkzLDggQEAKIAogc3RydWN0IG5lc19pYl9kZXZpY2U7CiAKKyNkZWZpbmUgTkVTX0VWRU5UX0RFTEFZIG1zZWNzX3RvX2ppZmZpZXMoMTAwKQorCiBzdHJ1Y3QgbmVzX3ZuaWMgewogCXN0cnVjdCBuZXNfaWJfZGV2aWNlICpuZXNpYmRldjsKIAl1NjQgc3FfZnVsbDsKQEAgLTEyNDcsNiArMTI0OSwxMCBAQAogCXUzMiBscm9fbWF4X2FnZ3I7CiAJc3RydWN0IG5ldF9scm9fbWdyIGxyb19tZ3I7CiAJc3RydWN0IG5ldF9scm9fZGVzYyBscm9fZGVzY1tORVNfTUFYX0xST19ERVNDUklQVE9SU107CisJc3RydWN0IHRpbWVyX2xpc3QgZXZlbnRfdGltZXI7CisJZW51bSBpYl9ldmVudF90eXBlIGRlbGF5ZWRfZXZlbnQ7CisJZW51bSBpYl9ldmVudF90eXBlIGxhc3RfZGlzcGF0Y2hlZF9ldmVudDsKKwlzcGlubG9ja190IHBvcnRfaWJldmVudF9sb2NrOwogfTsKIAogc3RydWN0IG5lc19pYl9kZXZpY2UgewpAQCAtMTM0OCw2ICsxMzU0LDEwIEBACiAjZGVmaW5lIEJBRF9GUkFNRV9PRkZTRVQJNjQKICNkZWZpbmUgQ1FFX01BSk9SX0RSVgkJMHg4MDAwCiAKKy8qIFVzZWQgZm9yIGxpbmsgc3RhdHVzIHJlY2hlY2sgYWZ0ZXIgaW50ZXJydXB0IHByb2Nlc3NpbmcgKi8KKyNkZWZpbmUgTkVTX0xJTktfUkVDSEVDS19ERUxBWQltc2Vjc190b19qaWZmaWVzKDUwKQorI2RlZmluZSBORVNfTElOS19SRUNIRUNLX01BWAk2MAorCiAjZGVmaW5lIG5lc192bGFuX3J4IHZsYW5faHdhY2NlbF9yZWNlaXZlX3NrYgogI2RlZmluZSBuZXNfbmV0aWZfcnggbmV0aWZfcmVjZWl2ZV9za2IKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L25lcy9uZXNfbmljLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc19uaWMuYwppbmRleCA1YTRjMzY0Li4yYzljMTkzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc19uaWMuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc19uaWMuYwpAQCAtMTQ0LDYgKzE0NCw3IEBACiAJdTMyIG5pY19hY3RpdmVfYml0OwogCXUzMiBuaWNfYWN0aXZlOwogCXN0cnVjdCBsaXN0X2hlYWQgKmxpc3RfcG9zLCAqbGlzdF90ZW1wOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKIAlhc3NlcnQobmVzZGV2ICE9IE5VTEwpOwogCkBAIC0yMzMsMTggKzIzNCwzNiBAQAogCQlmaXJzdF9uZXN2bmljID0gbmVzdm5pYzsKIAl9CiAKLQlpZiAobmVzdm5pYy0+b2ZfZGV2aWNlX3JlZ2lzdGVyZWQpIHsKLQkJbmVzZGV2LT5pd19zdGF0dXMgPSAxOwotCQluZXNkZXYtPm5lc2FkYXB0ZXItPnNlbmRfdGVybV9vayA9IDE7Ci0JCW5lc19wb3J0X2liZXZlbnQobmVzdm5pYyk7Ci0JfQotCiAJaWYgKGZpcnN0X25lc3ZuaWMtPmxpbmt1cCkgewogCQkvKiBFbmFibGUgbmV0d29yayBwYWNrZXRzICovCiAJCW5lc3ZuaWMtPmxpbmt1cCA9IDE7CiAJCW5ldGlmX3N0YXJ0X3F1ZXVlKG5ldGRldik7CiAJCW5ldGlmX2NhcnJpZXJfb24obmV0ZGV2KTsKIAl9CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmbmVzZGV2LT5uZXNhZGFwdGVyLT5waHlfbG9jaywgZmxhZ3MpOworCWlmIChuZXNkZXYtPm5lc2FkYXB0ZXItPnBoeV90eXBlW25lc2Rldi0+bWFjX2luZGV4XSA9PSBORVNfUEhZX1RZUEVfU0ZQX0QpIHsKKwkJaWYgKG5lc2Rldi0+bGlua19yZWNoZWNrKQorCQkJY2FuY2VsX2RlbGF5ZWRfd29yaygmbmVzZGV2LT53b3JrKTsKKwkJbmVzZGV2LT5saW5rX3JlY2hlY2sgPSAxOworCQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJm5lc2Rldi0+d29yaywgTkVTX0xJTktfUkVDSEVDS19ERUxBWSk7CisJfQorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm5lc2Rldi0+bmVzYWRhcHRlci0+cGh5X2xvY2ssIGZsYWdzKTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZuZXN2bmljLT5wb3J0X2liZXZlbnRfbG9jaywgZmxhZ3MpOworCWlmIChuZXN2bmljLT5vZl9kZXZpY2VfcmVnaXN0ZXJlZCkgeworCQluZXNkZXYtPm5lc2FkYXB0ZXItPnNlbmRfdGVybV9vayA9IDE7CisJCWlmIChuZXN2bmljLT5saW5rdXAgPT0gMSkgeworCQkJaWYgKG5lc2Rldi0+aXdfc3RhdHVzID09IDApIHsKKwkJCQluZXNkZXYtPml3X3N0YXR1cyA9IDE7CisJCQkJbmVzX3BvcnRfaWJldmVudChuZXN2bmljKTsKKwkJCX0KKwkJfSBlbHNlIHsKKwkJCW5lc2Rldi0+aXdfc3RhdHVzID0gMDsKKwkJfQorCX0KKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZuZXN2bmljLT5wb3J0X2liZXZlbnRfbG9jaywgZmxhZ3MpOworCiAJbmFwaV9lbmFibGUoJm5lc3ZuaWMtPm5hcGkpOwogCW5lc3ZuaWMtPm5ldGRldl9vcGVuID0gMTsKIApAQCAtMjYzLDYgKzI4Miw3IEBACiAJdTMyIG5pY19hY3RpdmU7CiAJc3RydWN0IG5lc192bmljICpmaXJzdF9uZXN2bmljID0gTlVMTDsKIAlzdHJ1Y3QgbGlzdF9oZWFkICpsaXN0X3BvcywgKmxpc3RfdGVtcDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJbmVzX2RlYnVnKE5FU19EQkdfU0hVVERPV04sICJuZXN2bmljPSVwLCBuZXNkZXY9JXAsIG5ldGRldj0lcCAlc1xuIiwKIAkJCW5lc3ZuaWMsIG5lc2RldiwgbmV0ZGV2LCBuZXRkZXYtPm5hbWUpOwpAQCAtMzE1LDEyICszMzUsMTcgQEAKIAluaWNfYWN0aXZlICY9IG5pY19hY3RpdmVfbWFzazsKIAluZXNfd3JpdGVfaW5kZXhlZChuZXNkZXYsIE5FU19JRFhfTklDX0JST0FEQ0FTVF9PTiwgbmljX2FjdGl2ZSk7CiAKLQorCXNwaW5fbG9ja19pcnFzYXZlKCZuZXN2bmljLT5wb3J0X2liZXZlbnRfbG9jaywgZmxhZ3MpOwogCWlmIChuZXN2bmljLT5vZl9kZXZpY2VfcmVnaXN0ZXJlZCkgewogCQluZXNkZXYtPm5lc2FkYXB0ZXItPnNlbmRfdGVybV9vayA9IDA7CiAJCW5lc2Rldi0+aXdfc3RhdHVzID0gMDsKLQkJbmVzX3BvcnRfaWJldmVudChuZXN2bmljKTsKKwkJaWYgKG5lc3ZuaWMtPmxpbmt1cCA9PSAxKQorCQkJbmVzX3BvcnRfaWJldmVudChuZXN2bmljKTsKIAl9CisJZGVsX3RpbWVyX3N5bmMoJm5lc3ZuaWMtPmV2ZW50X3RpbWVyKTsKKwluZXN2bmljLT5ldmVudF90aW1lci5mdW5jdGlvbiA9IE5VTEw7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmbmVzdm5pYy0+cG9ydF9pYmV2ZW50X2xvY2ssIGZsYWdzKTsKKwogCW5lc19kZXN0cm95X25pY19xcChuZXN2bmljKTsKIAogCW5lc3ZuaWMtPm5ldGRldl9vcGVuID0gMDsKQEAgLTE3NTAsNyArMTc3NSwxMCBAQAogCQluZXN2bmljLT5yZG1hX2VuYWJsZWQgPSAwOwogCX0KIAluZXN2bmljLT5uaWNfY3EuY3FfbnVtYmVyID0gbmVzdm5pYy0+bmljLnFwX2lkOworCWluaXRfdGltZXIoJm5lc3ZuaWMtPmV2ZW50X3RpbWVyKTsKKwluZXN2bmljLT5ldmVudF90aW1lci5mdW5jdGlvbiA9IE5VTEw7CiAJc3Bpbl9sb2NrX2luaXQoJm5lc3ZuaWMtPnR4X2xvY2spOworCXNwaW5fbG9ja19pbml0KCZuZXN2bmljLT5wb3J0X2liZXZlbnRfbG9jayk7CiAJbmVzZGV2LT5uZXRkZXZbbmVzZGV2LT5uZXRkZXZfY291bnRdID0gbmV0ZGV2OwogCiAJbmVzX2RlYnVnKE5FU19EQkdfSU5JVCwgIkFkZGluZyBuZXN2bmljICglcCkgdG8gdGhlIGFkYXB0ZXJzIG5lc3ZuaWNfbGlzdCBmb3IgTUFDJWQuXG4iLApAQCAtMTc2Myw4ICsxNzkxLDExIEBACiAJICAgICAgKCgoUENJX0ZVTkMobmVzZGV2LT5wY2lkZXYtPmRldmZuKSA9PSAxKSAmJiAobmVzZGV2LT5tYWNfaW5kZXggPT0gMikpIHx8CiAJICAgICAgICgoUENJX0ZVTkMobmVzZGV2LT5wY2lkZXYtPmRldmZuKSA9PSAyKSAmJiAobmVzZGV2LT5tYWNfaW5kZXggPT0gMSkpKSkpKSB7CiAJCXUzMiB1MzJ0ZW1wOwotCQl1MzIgbGlua19tYXNrOwotCQl1MzIgbGlua192YWw7CisJCXUzMiBsaW5rX21hc2sgPSAwOworCQl1MzIgbGlua192YWwgPSAwOworCQl1MTYgdGVtcF9waHlfZGF0YTsKKwkJdTE2IHBoeV9kYXRhID0gMDsKKwkJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCQl1MzJ0ZW1wID0gbmVzX3JlYWRfaW5kZXhlZChuZXNkZXYsIE5FU19JRFhfUEhZX1BDU19DT05UUk9MX1NUQVRVUzAgKwogCQkJCSgweDIwMCAqIChuZXNkZXYtPm1hY19pbmRleCAmIDEpKSk7CkBAIC0xNzg2LDYgKzE4MTcsMjMgQEAKIAkJCQlsaW5rX3ZhbCA9IDB4MDIwMjAwMDA7CiAJCQl9CiAJCQlicmVhazsKKwkJY2FzZSBORVNfUEhZX1RZUEVfU0ZQX0Q6CisJCQlzcGluX2xvY2tfaXJxc2F2ZSgmbmVzZGV2LT5uZXNhZGFwdGVyLT5waHlfbG9jaywgZmxhZ3MpOworCQkJbmVzX3JlYWRfMTBHX3BoeV9yZWcobmVzZGV2LAorCQkJCQkgICAgIG5lc2Rldi0+bmVzYWRhcHRlci0+cGh5X2luZGV4W25lc2Rldi0+bWFjX2luZGV4XSwKKwkJCQkJICAgICAxLCAweDkwMDMpOworCQkJdGVtcF9waHlfZGF0YSA9ICh1MTYpbmVzX3JlYWRfaW5kZXhlZChuZXNkZXYsIE5FU19JRFhfTUFDX01ESU9fQ09OVFJPTCk7CisJCQluZXNfcmVhZF8xMEdfcGh5X3JlZyhuZXNkZXYsCisJCQkJCSAgICAgbmVzZGV2LT5uZXNhZGFwdGVyLT5waHlfaW5kZXhbbmVzZGV2LT5tYWNfaW5kZXhdLAorCQkJCQkgICAgIDMsIDB4MDAyMSk7CisJCQluZXNfcmVhZF9pbmRleGVkKG5lc2RldiwgTkVTX0lEWF9NQUNfTURJT19DT05UUk9MKTsKKwkJCW5lc19yZWFkXzEwR19waHlfcmVnKG5lc2RldiwKKwkJCQkJICAgICBuZXNkZXYtPm5lc2FkYXB0ZXItPnBoeV9pbmRleFtuZXNkZXYtPm1hY19pbmRleF0sCisJCQkJCSAgICAgMywgMHgwMDIxKTsKKwkJCXBoeV9kYXRhID0gKHUxNiluZXNfcmVhZF9pbmRleGVkKG5lc2RldiwgTkVTX0lEWF9NQUNfTURJT19DT05UUk9MKTsKKwkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm5lc2Rldi0+bmVzYWRhcHRlci0+cGh5X2xvY2ssIGZsYWdzKTsKKwkJCXBoeV9kYXRhID0gKCF0ZW1wX3BoeV9kYXRhICYmIChwaHlfZGF0YSA9PSAweDgwMDApKSA/IDB4NCA6IDB4MDsKKwkJCWJyZWFrOwogCQlkZWZhdWx0OgogCQkJbGlua19tYXNrID0gMHgwZjFmMDAwMDsKIAkJCWxpbmtfdmFsID0gMHgwZjBmMDAwMDsKQEAgLTE3OTUsOCArMTg0MywxNCBAQAogCQl1MzJ0ZW1wID0gbmVzX3JlYWRfaW5kZXhlZChuZXNkZXYsCiAJCQkJCSAgIE5FU19JRFhfUEhZX1BDU19DT05UUk9MX1NUQVRVUzAgKwogCQkJCQkgICAoMHgyMDAgKiAobmVzZGV2LT5tYWNfaW5kZXggJiAxKSkpOwotCQlpZiAoKHUzMnRlbXAgJiBsaW5rX21hc2spID09IGxpbmtfdmFsKQotCQkJbmVzdm5pYy0+bGlua3VwID0gMTsKKworCQlpZiAocGh5X3R5cGUgPT0gTkVTX1BIWV9UWVBFX1NGUF9EKSB7CisJCQlpZiAocGh5X2RhdGEgJiAweDAwMDQpCisJCQkJbmVzdm5pYy0+bGlua3VwID0gMTsKKwkJfSBlbHNlIHsKKwkJCWlmICgodTMydGVtcCAmIGxpbmtfbWFzaykgPT0gbGlua192YWwpCisJCQkJbmVzdm5pYy0+bGlua3VwID0gMTsKKwkJfQogCiAJCS8qIGNsZWFyIHRoZSBNQUMgaW50ZXJydXB0IHN0YXR1cywgYXNzdW1lcyBkaXJlY3QgbG9naWNhbCB0byBwaHlzaWNhbCBtYXBwaW5nICovCiAJCXUzMnRlbXAgPSBuZXNfcmVhZF9pbmRleGVkKG5lc2RldiwgTkVTX0lEWF9NQUNfSU5UX1NUQVRVUyArICgweDIwMCAqIG5lc2Rldi0+bWFjX2luZGV4KSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc192ZXJicy5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L25lcy9uZXNfdmVyYnMuYwppbmRleCA5OTkzM2U0Li4yNmQ4MDE4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvbmVzL25lc192ZXJicy5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9uZXMvbmVzX3ZlcmJzLmMKQEAgLTM5MzYsNiArMzkzNiwzMCBAQAogCXJldHVybiBuZXNpYmRldjsKIH0KIAorCisvKioKKyAqIG5lc19oYW5kbGVfZGVsYXllZF9ldmVudAorICovCitzdGF0aWMgdm9pZCBuZXNfaGFuZGxlX2RlbGF5ZWRfZXZlbnQodW5zaWduZWQgbG9uZyBkYXRhKQoreworCXN0cnVjdCBuZXNfdm5pYyAqbmVzdm5pYyA9ICh2b2lkICopIGRhdGE7CisKKwlpZiAobmVzdm5pYy0+ZGVsYXllZF9ldmVudCAhPSBuZXN2bmljLT5sYXN0X2Rpc3BhdGNoZWRfZXZlbnQpIHsKKwkJc3RydWN0IGliX2V2ZW50IGV2ZW50OworCisJCWV2ZW50LmRldmljZSA9ICZuZXN2bmljLT5uZXNpYmRldi0+aWJkZXY7CisJCWlmICghZXZlbnQuZGV2aWNlKQorCQkJZ290byBzdG9wX3RpbWVyOworCQlldmVudC5ldmVudCA9IG5lc3ZuaWMtPmRlbGF5ZWRfZXZlbnQ7CisJCWV2ZW50LmVsZW1lbnQucG9ydF9udW0gPSBuZXN2bmljLT5sb2dpY2FsX3BvcnQgKyAxOworCQlpYl9kaXNwYXRjaF9ldmVudCgmZXZlbnQpOworCX0KKworc3RvcF90aW1lcjoKKwluZXN2bmljLT5ldmVudF90aW1lci5mdW5jdGlvbiA9IE5VTEw7Cit9CisKKwogdm9pZCAgbmVzX3BvcnRfaWJldmVudChzdHJ1Y3QgbmVzX3ZuaWMgKm5lc3ZuaWMpCiB7CiAJc3RydWN0IG5lc19pYl9kZXZpY2UgKm5lc2liZGV2ID0gbmVzdm5pYy0+bmVzaWJkZXY7CkBAIC0zOTQ0LDcgKzM5NjgsMTggQEAKIAlldmVudC5kZXZpY2UgPSAmbmVzaWJkZXYtPmliZGV2OwogCWV2ZW50LmVsZW1lbnQucG9ydF9udW0gPSBuZXN2bmljLT5sb2dpY2FsX3BvcnQgKyAxOwogCWV2ZW50LmV2ZW50ID0gbmVzZGV2LT5pd19zdGF0dXMgPyBJQl9FVkVOVF9QT1JUX0FDVElWRSA6IElCX0VWRU5UX1BPUlRfRVJSOwotCWliX2Rpc3BhdGNoX2V2ZW50KCZldmVudCk7CisKKwlpZiAoIW5lc3ZuaWMtPmV2ZW50X3RpbWVyLmZ1bmN0aW9uKSB7CisJCWliX2Rpc3BhdGNoX2V2ZW50KCZldmVudCk7CisJCW5lc3ZuaWMtPmxhc3RfZGlzcGF0Y2hlZF9ldmVudCA9IGV2ZW50LmV2ZW50OworCQluZXN2bmljLT5ldmVudF90aW1lci5mdW5jdGlvbiA9IG5lc19oYW5kbGVfZGVsYXllZF9ldmVudDsKKwkJbmVzdm5pYy0+ZXZlbnRfdGltZXIuZGF0YSA9ICh1bnNpZ25lZCBsb25nKSBuZXN2bmljOworCQluZXN2bmljLT5ldmVudF90aW1lci5leHBpcmVzID0gamlmZmllcyArIE5FU19FVkVOVF9ERUxBWTsKKwkJYWRkX3RpbWVyKCZuZXN2bmljLT5ldmVudF90aW1lcik7CisJfSBlbHNlIHsKKwkJbW9kX3RpbWVyKCZuZXN2bmljLT5ldmVudF90aW1lciwgamlmZmllcyArIE5FU19FVkVOVF9ERUxBWSk7CisJfQorCW5lc3ZuaWMtPmRlbGF5ZWRfZXZlbnQgPSBldmVudC5ldmVudDsKIH0KIAogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl9pYmE3MjIwLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl9pYmE3MjIwLmMKaW5kZXggMTI3YTBkNS4uZGU3OTlmMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfaWJhNzIyMC5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX2liYTcyMjAuYwpAQCAtMTY5Miw4ICsxNjkyLDcgQEAKIAlwcGQtPmxmbGFncyAmPSB+UUlCTF9JQl9BVVRPTkVHX0lOUFJPRzsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcGQtPmxmbGFnc19sb2NrLCBmbGFncyk7CiAJd2FrZV91cCgmcHBkLT5jcHNwZWMtPmF1dG9uZWdfd2FpdCk7Ci0JY2FuY2VsX2RlbGF5ZWRfd29yaygmcHBkLT5jcHNwZWMtPmF1dG9uZWdfd29yayk7Ci0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKKwljYW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJnBwZC0+Y3BzcGVjLT5hdXRvbmVnX3dvcmspOwogCiAJc2h1dGRvd25fNzIyMF9yZWxvY2tfcG9sbChwcGQtPmRkKTsKIAl2YWwgPSBxaWJfcmVhZF9rcmVnNjQocHBkLT5kZCwga3JfeGd4c19jZmcpOwpAQCAtMzUxNSw4ICszNTE0LDggQEAKIAogCXRvZ2dsZV83MjIwX3JjbGtybHMocHBkLT5kZCk7CiAJLyogMiBtc2VjIGlzIG1pbmltdW0gbGVuZ3RoIG9mIGEgcG9sbCBjeWNsZSAqLwotCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmcHBkLT5jcHNwZWMtPmF1dG9uZWdfd29yaywKLQkJCSAgICAgIG1zZWNzX3RvX2ppZmZpZXMoMikpOworCXF1ZXVlX2RlbGF5ZWRfd29yayhpYl93cSwgJnBwZC0+Y3BzcGVjLT5hdXRvbmVnX3dvcmssCisJCQkgICBtc2Vjc190b19qaWZmaWVzKDIpKTsKIH0KIAogLyoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX2liYTczMjIuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX2liYTczMjIuYwppbmRleCBhYmQ0MDlkLi5iMDE4MDlhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl9pYmE3MzIyLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfaWJhNzMyMi5jCkBAIC02MjMsNyArNjIzLDYgQEAKIAl1OCBpYm1hbGZ1c2VzbmFwOwogCXN0cnVjdCBxaWJfcXNmcF9kYXRhIHFzZnBfZGF0YTsKIAljaGFyIGVwbXNnYnVmWzE5Ml07IC8qIGZvciBwb3J0IGVycm9yIGludGVycnVwdCBtc2cgYnVmZmVyICovCi0JdTggYm91bmNlZDsKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgewpAQCAtMTg4MSwyMyArMTg4MCw3IEBACiAJCSAgICBJQl9QSFlTUE9SVFNUQVRFX0RJU0FCTEVEKQogCQkJcWliX3NldF9pYl83MzIyX2xzdGF0ZShwcGQsIDAsCiAJCQkgICAgICAgUUxPR0lDX0lCX0lCQ0NfTElOS0lOSVRDTURfRElTQUJMRSk7Ci0JCWVsc2UgewotCQkJdTMyIGxzdGF0ZTsKLQkJCS8qCi0JCQkgKiBXZSBuZWVkIHRoZSBjdXJyZW50IGxvZ2ljYWwgbGluayBzdGF0ZSBiZWZvcmUKLQkJCSAqIGxmbGFncyBhcmUgc2V0IGluIGhhbmRsZV9lX2lic3RhdHVzY2hhbmdlZC4KLQkJCSAqLwotCQkJbHN0YXRlID0gcWliXzczMjJfaWJsaW5rX3N0YXRlKGliY3MpOwotCi0JCQlpZiAoSVNfUU1IKGRkKSAmJiAhcHBkLT5jcHNwZWMtPmJvdW5jZWQgJiYKLQkJCSAgICBsdHN0YXRlID09IElCX1BIWVNQT1JUU1RBVEVfTElOS1VQICYmCi0JCQkgICAgKGxzdGF0ZSA+PSBJQl9QT1JUX0lOSVQgJiYKLQkJCQlsc3RhdGUgPD0gSUJfUE9SVF9BQ1RJVkUpKSB7Ci0JCQkJcHBkLT5jcHNwZWMtPmJvdW5jZWQgPSAxOwotCQkJCXFpYl83MzIyX3NldF9pYl9jZmcocHBkLCBRSUJfSUJfQ0ZHX0xTVEFURSwKLQkJCQkJSUJfTElOS0NNRF9ET1dOIHwgSUJfTElOS0lOSVRDTURfUE9MTCk7Ci0JCQl9Ci0KKwkJZWxzZQogCQkJLyoKIAkJCSAqIFNpbmNlIGdvaW5nIGludG8gYSByZWNvdmVyeSBzdGF0ZSBjYXVzZXMgdGhlIGxpbmsKIAkJCSAqIHN0YXRlIHRvIGdvIGRvd24gYW5kIHNpbmNlIHJlY292ZXJ5IGlzIHRyYW5zaXRvcnksCkBAIC0xOTExLDcgKzE4OTQsNiBAQAogCQkJICAgIGx0c3RhdGUgIT0gSUJfUEhZU1BPUlRTVEFURV9SRUNPVkVSWV9XQUlUUk1UICYmCiAJCQkgICAgbHRzdGF0ZSAhPSBJQl9QSFlTUE9SVFNUQVRFX1JFQ09WRVJZX0lETEUpCiAJCQkJcWliX2hhbmRsZV9lX2lic3RhdHVzY2hhbmdlZChwcGQsIGliY3MpOwotCQl9CiAJfQogCWlmICgqbXNnICYmIGlzZXJyKQogCQlxaWJfZGV2X3BvcnRlcnIoZGQsIHBwZC0+cG9ydCwgIiVzIGVycm9yXG4iLCBtc2cpOwpAQCAtMjM4MSw2ICsyMzYzLDExIEBACiAJcWliX3dyaXRlX2tyZWdfcG9ydChwcGQsIGtycF9yY3ZjdHJsLCBwcGQtPnBfcmN2Y3RybCk7CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGQtPmNzcGVjLT5yY3Ztb2RfbG9jaywgZmxhZ3MpOwogCisJLyogSG9sZCB0aGUgbGluayBzdGF0ZSBtYWNoaW5lIGZvciBtZXp6IGJvYXJkcyAqLworCWlmIChJU19RTUgoZGQpIHx8IElTX1FNRShkZCkpCisJCXFpYl9zZXRfaWJfNzMyMl9sc3RhdGUocHBkLCAwLAorCQkJCSAgICAgICBRTE9HSUNfSUJfSUJDQ19MSU5LSU5JVENNRF9ESVNBQkxFKTsKKwogCS8qIEFsc28gZW5hYmxlIElCU1RBVFVTQ0hHIGludGVycnVwdC4gICovCiAJdmFsID0gcWliX3JlYWRfa3JlZ19wb3J0KHBwZCwga3JwX2Vycm1hc2spOwogCXFpYl93cml0ZV9rcmVnX3BvcnQocHBkLCBrcnBfZXJybWFzaywKQEAgLTI0MDYsMTAgKzIzOTMsOSBAQAogCXBwZC0+bGZsYWdzICY9IH5RSUJMX0lCX0FVVE9ORUdfSU5QUk9HOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBwZC0+bGZsYWdzX2xvY2ssIGZsYWdzKTsKIAl3YWtlX3VwKCZwcGQtPmNwc3BlYy0+YXV0b25lZ193YWl0KTsKLQljYW5jZWxfZGVsYXllZF93b3JrKCZwcGQtPmNwc3BlYy0+YXV0b25lZ193b3JrKTsKKwljYW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJnBwZC0+Y3BzcGVjLT5hdXRvbmVnX3dvcmspOwogCWlmIChwcGQtPmRkLT5jc3BlYy0+cjEpCi0JCWNhbmNlbF9kZWxheWVkX3dvcmsoJnBwZC0+Y3BzcGVjLT5pcGdfd29yayk7Ci0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKKwkJY2FuY2VsX2RlbGF5ZWRfd29ya19zeW5jKCZwcGQtPmNwc3BlYy0+aXBnX3dvcmspOwogCiAJcHBkLT5jcHNwZWMtPmNoYXNlX2VuZCA9IDA7CiAJaWYgKHBwZC0+Y3BzcGVjLT5jaGFzZV90aW1lci5kYXRhKSAvKiBpZiBpbml0dGVkICovCkBAIC0yNzA2LDcgKzI2OTIsNyBAQAogCQkJaWYgKCEocGlucyAmIG1hc2spKSB7CiAJCQkJKytoYW5kbGVkOwogCQkJCXFkLT50X2luc2VydCA9IGdldF9qaWZmaWVzXzY0KCk7Ci0JCQkJc2NoZWR1bGVfd29yaygmcWQtPndvcmspOworCQkJCXF1ZXVlX3dvcmsoaWJfd3EsICZxZC0+d29yayk7CiAJCQl9CiAJCX0KIAl9CkBAIC00OTkwLDggKzQ5NzYsOCBAQAogCXNldF83MzIyX2lic3BlZWRfZmFzdChwcGQsIFFJQl9JQl9ERFIpOwogCXFpYl83MzIyX21pbmlfcGNzX3Jlc2V0KHBwZCk7CiAJLyogMiBtc2VjIGlzIG1pbmltdW0gbGVuZ3RoIG9mIGEgcG9sbCBjeWNsZSAqLwotCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmcHBkLT5jcHNwZWMtPmF1dG9uZWdfd29yaywKLQkJCSAgICAgIG1zZWNzX3RvX2ppZmZpZXMoMikpOworCXF1ZXVlX2RlbGF5ZWRfd29yayhpYl93cSwgJnBwZC0+Y3BzcGVjLT5hdXRvbmVnX3dvcmssCisJCQkgICBtc2Vjc190b19qaWZmaWVzKDIpKTsKIH0KIAogLyoKQEAgLTUxMjEsNyArNTEwNyw4IEBACiAJCWliX2ZyZWVfc2VuZF9tYWQoc2VuZF9idWYpOwogcmV0cnk6CiAJZGVsYXkgPSAyIDw8IHBwZC0+Y3BzcGVjLT5pcGdfdHJpZXM7Ci0Jc2NoZWR1bGVfZGVsYXllZF93b3JrKCZwcGQtPmNwc3BlYy0+aXBnX3dvcmssIG1zZWNzX3RvX2ppZmZpZXMoZGVsYXkpKTsKKwlxdWV1ZV9kZWxheWVkX3dvcmsoaWJfd3EsICZwcGQtPmNwc3BlYy0+aXBnX3dvcmssCisJCQkgICBtc2Vjc190b19qaWZmaWVzKGRlbGF5KSk7CiB9CiAKIC8qCkBAIC01NzAyLDYgKzU2ODksMTEgQEAKIAkJCQlwcGQtPmNwc3BlYy0+aDFfdmFsID0gaDE7CiAJCQkvKiBub3cgY2hhbmdlIHRoZSBJQkMgYW5kIHNlcmRlcywgb3ZlcnJpZGluZyBnZW5lcmljICovCiAJCQlpbml0X3R4ZGRzX3RhYmxlKHBwZCwgMSk7CisJCQkvKiBSZS1lbmFibGUgdGhlIHBoeXNpY2FsIHN0YXRlIG1hY2hpbmUgb24gbWV6eiBib2FyZHMKKwkJCSAqIG5vdyB0aGF0IHRoZSBjb3JyZWN0IHNldHRpbmdzIGhhdmUgYmVlbiBzZXQuICovCisJCQlpZiAoSVNfUU1IKGRkKSB8fCBJU19RTUUoZGQpKQorCQkJCXFpYl9zZXRfaWJfNzMyMl9sc3RhdGUocHBkLCAwLAorCQkJCQkgICAgUUxPR0lDX0lCX0lCQ0NfTElOS0lOSVRDTURfU0xFRVApOwogCQkJYW55Kys7CiAJCX0KIAkJaWYgKCpueHQgPT0gJ1xuJykKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX2luaXQuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX2luaXQuYwppbmRleCA3ODk2YWZiLi5mZmVmYjc4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl9pbml0LmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfaW5pdC5jCkBAIC04MCw3ICs4MCw2IEBACiBtb2R1bGVfcGFyYW1fbmFtZWQod2NfcGF0LCBxaWJfd2NfcGF0LCB1aW50LCBTX0lSVUdPKTsKIE1PRFVMRV9QQVJNX0RFU0Mod2NfcGF0LCAiZW5hYmxlIHdyaXRlLWNvbWJpbmluZyB2aWEgUEFUIG1lY2hhbmlzbSIpOwogCi1zdHJ1Y3Qgd29ya3F1ZXVlX3N0cnVjdCAqcWliX3dxOwogc3RydWN0IHdvcmtxdWV1ZV9zdHJ1Y3QgKnFpYl9jcV93cTsKIAogc3RhdGljIHZvaWQgdmVyaWZ5X2ludGVycnVwdCh1bnNpZ25lZCBsb25nKTsKQEAgLTI3MCwyMyArMjY5LDIwIEBACiAJc3RydWN0IHBhZ2UgKipwYWdlczsKIAlkbWFfYWRkcl90ICphZGRyczsKIAotCXBhZ2VzID0gdm1hbGxvYyhkZC0+Y2ZnY3R4dHMgKiBkZC0+cmN2dGlkY250ICogc2l6ZW9mKHN0cnVjdCBwYWdlICopKTsKKwlwYWdlcyA9IHZ6YWxsb2MoZGQtPmNmZ2N0eHRzICogZGQtPnJjdnRpZGNudCAqIHNpemVvZihzdHJ1Y3QgcGFnZSAqKSk7CiAJaWYgKCFwYWdlcykgewogCQlxaWJfZGV2X2VycihkZCwgImZhaWxlZCB0byBhbGxvY2F0ZSBzaGFkb3cgcGFnZSAqICIKIAkJCSAgICAiYXJyYXksIG5vIGV4cGVjdGVkIHNlbmRzIVxuIik7CiAJCWdvdG8gYmFpbDsKIAl9CiAKLQlhZGRycyA9IHZtYWxsb2MoZGQtPmNmZ2N0eHRzICogZGQtPnJjdnRpZGNudCAqIHNpemVvZihkbWFfYWRkcl90KSk7CisJYWRkcnMgPSB2emFsbG9jKGRkLT5jZmdjdHh0cyAqIGRkLT5yY3Z0aWRjbnQgKiBzaXplb2YoZG1hX2FkZHJfdCkpOwogCWlmICghYWRkcnMpIHsKIAkJcWliX2Rldl9lcnIoZGQsICJmYWlsZWQgdG8gYWxsb2NhdGUgc2hhZG93IGRtYSBoYW5kbGUgIgogCQkJICAgICJhcnJheSwgbm8gZXhwZWN0ZWQgc2VuZHMhXG4iKTsKIAkJZ290byBiYWlsX2ZyZWU7CiAJfQogCi0JbWVtc2V0KHBhZ2VzLCAwLCBkZC0+Y2ZnY3R4dHMgKiBkZC0+cmN2dGlkY250ICogc2l6ZW9mKHN0cnVjdCBwYWdlICopKTsKLQltZW1zZXQoYWRkcnMsIDAsIGRkLT5jZmdjdHh0cyAqIGRkLT5yY3Z0aWRjbnQgKiBzaXplb2YoZG1hX2FkZHJfdCkpOwotCiAJZGQtPnBhZ2VzaGFkb3cgPSBwYWdlczsKIAlkZC0+cGh5c3NoYWRvdyA9IGFkZHJzOwogCXJldHVybjsKQEAgLTEwNDcsMjQgKzEwNDMsMTAgQEAKIAlpZiAocmV0KQogCQlnb3RvIGJhaWw7CiAKLQkvKgotCSAqIFdlIGNyZWF0ZSBvdXIgb3duIHdvcmtxdWV1ZSBtYWlubHkgYmVjYXVzZSB3ZSB3YW50IHRvIGJlCi0JICogYWJsZSB0byBmbHVzaCBpdCB3aGVuIGRldmljZXMgYXJlIGJlaW5nIHJlbW92ZWQuICBXZSBjYW4ndAotCSAqIHVzZSBzY2hlZHVsZV93b3JrKCkvZmx1c2hfc2NoZWR1bGVkX3dvcmsoKSBiZWNhdXNlIGJvdGgKLQkgKiB1bnJlZ2lzdGVyX25ldGRldigpIGFuZCBsaW5rd2F0Y2hfZXZlbnQgdGFrZSB0aGUgcnRubCBsb2NrLAotCSAqIHNvIGZsdXNoX3NjaGVkdWxlZF93b3JrKCkgY2FuIGRlYWRsb2NrIGR1cmluZyBkZXZpY2UKLQkgKiByZW1vdmFsLgotCSAqLwotCXFpYl93cSA9IGNyZWF0ZV93b3JrcXVldWUoInFpYiIpOwotCWlmICghcWliX3dxKSB7Ci0JCXJldCA9IC1FTk9NRU07Ci0JCWdvdG8gYmFpbF9kZXY7Ci0JfQotCiAJcWliX2NxX3dxID0gY3JlYXRlX3NpbmdsZXRocmVhZF93b3JrcXVldWUoInFpYl9jcSIpOwogCWlmICghcWliX2NxX3dxKSB7CiAJCXJldCA9IC1FTk9NRU07Ci0JCWdvdG8gYmFpbF93cTsKKwkJZ290byBiYWlsX2RldjsKIAl9CiAKIAkvKgpAQCAtMTA5NCw4ICsxMDc2LDYgQEAKIAlpZHJfZGVzdHJveSgmcWliX3VuaXRfdGFibGUpOwogYmFpbF9jcV93cToKIAlkZXN0cm95X3dvcmtxdWV1ZShxaWJfY3Ffd3EpOwotYmFpbF93cToKLQlkZXN0cm95X3dvcmtxdWV1ZShxaWJfd3EpOwogYmFpbF9kZXY6CiAJcWliX2Rldl9jbGVhbnVwKCk7CiBiYWlsOgpAQCAtMTExOSw3ICsxMDk5LDYgQEAKIAogCXBjaV91bnJlZ2lzdGVyX2RyaXZlcigmcWliX2RyaXZlcik7CiAKLQlkZXN0cm95X3dvcmtxdWV1ZShxaWJfd3EpOwogCWRlc3Ryb3lfd29ya3F1ZXVlKHFpYl9jcV93cSk7CiAKIAlxaWJfY3B1bGlzdF9jb3VudCA9IDA7CkBAIC0xMjkyLDcgKzEyNzEsNyBAQAogCiAJaWYgKHFpYl9taW5pX2luaXQgfHwgaW5pdGZhaWwgfHwgcmV0KSB7CiAJCXFpYl9zdG9wX3RpbWVycyhkZCk7Ci0JCWZsdXNoX3NjaGVkdWxlZF93b3JrKCk7CisJCWZsdXNoX3dvcmtxdWV1ZShpYl93cSk7CiAJCWZvciAocGlkeCA9IDA7IHBpZHggPCBkZC0+bnVtX3Bwb3J0czsgKytwaWR4KQogCQkJZGQtPmZfcXVpZXRfc2VyZGVzKGRkLT5wcG9ydCArIHBpZHgpOwogCQlpZiAocWliX21pbmlfaW5pdCkKQEAgLTEzNDEsOCArMTMyMCw4IEBACiAKIAlxaWJfc3RvcF90aW1lcnMoZGQpOwogCi0JLyogd2FpdCB1bnRpbCBhbGwgb2Ygb3VyIChxc2ZwKSBzY2hlZHVsZV93b3JrKCkgY2FsbHMgY29tcGxldGUgKi8KLQlmbHVzaF9zY2hlZHVsZWRfd29yaygpOworCS8qIHdhaXQgdW50aWwgYWxsIG9mIG91ciAocXNmcCkgcXVldWVfd29yaygpIGNhbGxzIGNvbXBsZXRlICovCisJZmx1c2hfd29ya3F1ZXVlKGliX3dxKTsKIAogCXJldCA9IHFpYmZzX3JlbW92ZShkZCk7CiAJaWYgKHJldCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX3FzZnAuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX3FzZnAuYwppbmRleCAzNWIzNjA0Li4zMzc0YTUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl9xc2ZwLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfcXNmcC5jCkBAIC00ODUsNyArNDg1LDcgQEAKIAkJZ290byBiYWlsOwogCS8qIFdlIHNlZSBhIG1vZHVsZSwgYnV0IGl0IG1heSBiZSB1bndpc2UgdG8gbG9vayB5ZXQuIEp1c3Qgc2NoZWR1bGUgKi8KIAlxZC0+dF9pbnNlcnQgPSBnZXRfamlmZmllc182NCgpOwotCXNjaGVkdWxlX3dvcmsoJnFkLT53b3JrKTsKKwlxdWV1ZV93b3JrKGliX3dxLCAmcWQtPndvcmspOwogYmFpbDoKIAlyZXR1cm47CiB9CkBAIC00OTMsMTAgKzQ5Myw5IEBACiB2b2lkIHFpYl9xc2ZwX2RlaW5pdChzdHJ1Y3QgcWliX3FzZnBfZGF0YSAqcWQpCiB7CiAJLyoKLQkgKiBUaGVyZSBpcyBub3RoaW5nIHRvIGRvIGhlcmUgZm9yIG5vdy4gIG91cgotCSAqIHdvcmsgaXMgc2NoZWR1bGVkIHdpdGggc2NoZWR1bGVfd29yaygpLCBhbmQKLQkgKiBmbHVzaF9zY2hlZHVsZWRfd29yaygpIGZyb20gcmVtb3ZlX29uZSB3aWxsCi0JICogYmxvY2sgdW50aWwgYWxsIHdvcmsgc3NldHVwIHdpdGggc2NoZWR1bGVfd29yaygpCisJICogVGhlcmUgaXMgbm90aGluZyB0byBkbyBoZXJlIGZvciBub3cuICBvdXIgd29yayBpcyBzY2hlZHVsZWQKKwkgKiB3aXRoIHF1ZXVlX3dvcmsoKSwgYW5kIGZsdXNoX3dvcmtxdWV1ZSgpIGZyb20gcmVtb3ZlX29uZQorCSAqIHdpbGwgYmxvY2sgdW50aWwgYWxsIHdvcmsgc2V0dXAgd2l0aCBxdWV1ZV93b3JrKCkKIAkgKiBjb21wbGV0ZXMuCiAJICovCiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl92ZXJicy5oIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfdmVyYnMuaAppbmRleCA2M2IyMmE5Li45NWU1YjQ3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl92ZXJicy5oCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX3ZlcmJzLmgKQEAgLTgwNSw3ICs4MDUsNiBAQAogCQkgIShxcC0+c19mbGFncyAmIFFJQl9TX0FOWV9XQUlUX1NFTkQpKTsKIH0KIAotZXh0ZXJuIHN0cnVjdCB3b3JrcXVldWVfc3RydWN0ICpxaWJfd3E7CiBleHRlcm4gc3RydWN0IHdvcmtxdWV1ZV9zdHJ1Y3QgKnFpYl9jcV93cTsKIAogLyoKQEAgLTgxNCw3ICs4MTMsNyBAQAogc3RhdGljIGlubGluZSB2b2lkIHFpYl9zY2hlZHVsZV9zZW5kKHN0cnVjdCBxaWJfcXAgKnFwKQogewogCWlmIChxaWJfc2VuZF9vayhxcCkpCi0JCXF1ZXVlX3dvcmsocWliX3dxLCAmcXAtPnNfd29yayk7CisJCXF1ZXVlX3dvcmsoaWJfd3EsICZxcC0+c193b3JrKTsKIH0KIAogc3RhdGljIGlubGluZSBpbnQgcWliX3BrZXlfb2sodTE2IHBrZXkxLCB1MTYgcGtleTIpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL0tjb25maWcgYi9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL0tjb25maWcKaW5kZXggNTU4NTVlZS4uY2RhOGVhYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL3VscC9pcG9pYi9LY29uZmlnCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXBvaWIvS2NvbmZpZwpAQCAtMjQsNyArMjQsNyBAQAogCSAgdW5sZXNzIHlvdSBsaW1pdCBtdHUgZm9yIHRoZXNlIGRlc3RpbmF0aW9ucyB0byAyMDQ0LgogCiBjb25maWcgSU5GSU5JQkFORF9JUE9JQl9ERUJVRwotCWJvb2wgIklQLW92ZXItSW5maW5pQmFuZCBkZWJ1Z2dpbmciIGlmIEVNQkVEREVECisJYm9vbCAiSVAtb3Zlci1JbmZpbmlCYW5kIGRlYnVnZ2luZyIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBJTkZJTklCQU5EX0lQT0lCCiAJZGVmYXVsdCB5CiAJLS0taGVscC0tLQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL3VscC9pcG9pYi9pcG9pYl9jbS5jIGIvZHJpdmVycy9pbmZpbmliYW5kL3VscC9pcG9pYi9pcG9pYl9jbS5jCmluZGV4IGMxYzQ5ZjIuLjkzZDU1ODAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXBvaWIvaXBvaWJfY20uYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL2lwb2liX2NtLmMKQEAgLTM1MiwxNSArMzUyLDEzIEBACiAJaW50IHJldDsKIAlpbnQgaTsKIAotCXJ4LT5yeF9yaW5nID0gdm1hbGxvYyhpcG9pYl9yZWN2cV9zaXplICogc2l6ZW9mICpyeC0+cnhfcmluZyk7CisJcngtPnJ4X3JpbmcgPSB2emFsbG9jKGlwb2liX3JlY3ZxX3NpemUgKiBzaXplb2YgKnJ4LT5yeF9yaW5nKTsKIAlpZiAoIXJ4LT5yeF9yaW5nKSB7CiAJCXByaW50ayhLRVJOX1dBUk5JTkcgIiVzOiBmYWlsZWQgdG8gYWxsb2NhdGUgQ00gbm9uLVNSUSByaW5nICglZCBlbnRyaWVzKVxuIiwKIAkJICAgICAgIHByaXYtPmNhLT5uYW1lLCBpcG9pYl9yZWN2cV9zaXplKTsKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQogCi0JbWVtc2V0KHJ4LT5yeF9yaW5nLCAwLCBpcG9pYl9yZWN2cV9zaXplICogc2l6ZW9mICpyeC0+cnhfcmluZyk7Ci0KIAl0ID0ga21hbGxvYyhzaXplb2YgKnQsIEdGUF9LRVJORUwpOwogCWlmICghdCkgewogCQlyZXQgPSAtRU5PTUVNOwpAQCAtMTA5NywxMyArMTA5NSwxMiBAQAogCXN0cnVjdCBpcG9pYl9kZXZfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KHAtPmRldik7CiAJaW50IHJldDsKIAotCXAtPnR4X3JpbmcgPSB2bWFsbG9jKGlwb2liX3NlbmRxX3NpemUgKiBzaXplb2YgKnAtPnR4X3JpbmcpOworCXAtPnR4X3JpbmcgPSB2emFsbG9jKGlwb2liX3NlbmRxX3NpemUgKiBzaXplb2YgKnAtPnR4X3JpbmcpOwogCWlmICghcC0+dHhfcmluZykgewogCQlpcG9pYl93YXJuKHByaXYsICJmYWlsZWQgdG8gYWxsb2NhdGUgdHggcmluZ1xuIik7CiAJCXJldCA9IC1FTk9NRU07CiAJCWdvdG8gZXJyX3R4OwogCX0KLQltZW1zZXQocC0+dHhfcmluZywgMCwgaXBvaWJfc2VuZHFfc2l6ZSAqIHNpemVvZiAqcC0+dHhfcmluZyk7CiAKIAlwLT5xcCA9IGlwb2liX2NtX2NyZWF0ZV90eF9xcChwLT5kZXYsIHApOwogCWlmIChJU19FUlIocC0+cXApKSB7CkBAIC0xNTIxLDcgKzE1MTgsNyBAQAogCQlyZXR1cm47CiAJfQogCi0JcHJpdi0+Y20uc3JxX3JpbmcgPSB2bWFsbG9jKGlwb2liX3JlY3ZxX3NpemUgKiBzaXplb2YgKnByaXYtPmNtLnNycV9yaW5nKTsKKwlwcml2LT5jbS5zcnFfcmluZyA9IHZ6YWxsb2MoaXBvaWJfcmVjdnFfc2l6ZSAqIHNpemVvZiAqcHJpdi0+Y20uc3JxX3JpbmcpOwogCWlmICghcHJpdi0+Y20uc3JxX3JpbmcpIHsKIAkJcHJpbnRrKEtFUk5fV0FSTklORyAiJXM6IGZhaWxlZCB0byBhbGxvY2F0ZSBDTSBTUlEgcmluZyAoJWQgZW50cmllcylcbiIsCiAJCSAgICAgICBwcml2LT5jYS0+bmFtZSwgaXBvaWJfcmVjdnFfc2l6ZSk7CkBAIC0xNTMwLDcgKzE1MjcsNiBAQAogCQlyZXR1cm47CiAJfQogCi0JbWVtc2V0KHByaXYtPmNtLnNycV9yaW5nLCAwLCBpcG9pYl9yZWN2cV9zaXplICogc2l6ZW9mICpwcml2LT5jbS5zcnFfcmluZyk7CiB9CiAKIGludCBpcG9pYl9jbV9kZXZfaW5pdChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL3VscC9pcG9pYi9pcG9pYl9tYWluLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL2lwb2liX21haW4uYwppbmRleCA3YTA3YTcyLi5hY2EzYjQ0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL2lwb2liX21haW4uYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lwb2liL2lwb2liX21haW4uYwpAQCAtOTE2LDEzICs5MTYsMTIgQEAKIAkJZ290byBvdXQ7CiAJfQogCi0JcHJpdi0+dHhfcmluZyA9IHZtYWxsb2MoaXBvaWJfc2VuZHFfc2l6ZSAqIHNpemVvZiAqcHJpdi0+dHhfcmluZyk7CisJcHJpdi0+dHhfcmluZyA9IHZ6YWxsb2MoaXBvaWJfc2VuZHFfc2l6ZSAqIHNpemVvZiAqcHJpdi0+dHhfcmluZyk7CiAJaWYgKCFwcml2LT50eF9yaW5nKSB7CiAJCXByaW50ayhLRVJOX1dBUk5JTkcgIiVzOiBmYWlsZWQgdG8gYWxsb2NhdGUgVFggcmluZyAoJWQgZW50cmllcylcbiIsCiAJCSAgICAgICBjYS0+bmFtZSwgaXBvaWJfc2VuZHFfc2l6ZSk7CiAJCWdvdG8gb3V0X3J4X3JpbmdfY2xlYW51cDsKIAl9Ci0JbWVtc2V0KHByaXYtPnR4X3JpbmcsIDAsIGlwb2liX3NlbmRxX3NpemUgKiBzaXplb2YgKnByaXYtPnR4X3JpbmcpOwogCiAJLyogcHJpdi0+dHhfaGVhZCwgdHhfdGFpbCAmIHR4X291dHN0YW5kaW5nIGFyZSBhbHJlYWR5IDAgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL3VscC9zcnAvaWJfc3JwLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvdWxwL3NycC9pYl9zcnAuYwppbmRleCA0YjYyMTA1Li44MzY2NGVkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvdWxwL3NycC9pYl9zcnAuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvdWxwL3NycC9pYl9zcnAuYwpAQCAtNjM4LDcgKzYzOCw3IEBACiAJaWYgKHRhcmdldC0+c3RhdGUgPT0gU1JQX1RBUkdFVF9DT05ORUNUSU5HKSB7CiAJCXRhcmdldC0+c3RhdGUgPSBTUlBfVEFSR0VUX0RFQUQ7CiAJCUlOSVRfV09SSygmdGFyZ2V0LT53b3JrLCBzcnBfcmVtb3ZlX3dvcmspOwotCQlzY2hlZHVsZV93b3JrKCZ0YXJnZXQtPndvcmspOworCQlxdWV1ZV93b3JrKGliX3dxLCAmdGFyZ2V0LT53b3JrKTsKIAl9CiAJc3Bpbl91bmxvY2tfaXJxKCZ0YXJnZXQtPmxvY2spOwogCkBAIC0xMTMyLDE1ICsxMTMyLDEyIEBACiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmdGFyZ2V0LT5sb2NrLCBmbGFncyk7CiAJaXUgPSBfX3NycF9nZXRfdHhfaXUodGFyZ2V0LCBTUlBfSVVfQ01EKTsKLQlpZiAoaXUpIHsKLQkJcmVxID0gbGlzdF9maXJzdF9lbnRyeSgmdGFyZ2V0LT5mcmVlX3JlcXMsIHN0cnVjdCBzcnBfcmVxdWVzdCwKLQkJCQkgICAgICBsaXN0KTsKLQkJbGlzdF9kZWwoJnJlcS0+bGlzdCk7Ci0JfQotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnRhcmdldC0+bG9jaywgZmxhZ3MpOwotCiAJaWYgKCFpdSkKLQkJZ290byBlcnI7CisJCWdvdG8gZXJyX3VubG9jazsKKworCXJlcSA9IGxpc3RfZmlyc3RfZW50cnkoJnRhcmdldC0+ZnJlZV9yZXFzLCBzdHJ1Y3Qgc3JwX3JlcXVlc3QsIGxpc3QpOworCWxpc3RfZGVsKCZyZXEtPmxpc3QpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnRhcmdldC0+bG9jaywgZmxhZ3MpOwogCiAJZGV2ID0gdGFyZ2V0LT5zcnBfaG9zdC0+c3JwX2Rldi0+ZGV2OwogCWliX2RtYV9zeW5jX3NpbmdsZV9mb3JfY3B1KGRldiwgaXUtPmRtYSwgc3JwX21heF9pdV9sZW4sCkBAIC0xMTg1LDYgKzExODIsOCBAQAogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJnRhcmdldC0+bG9jaywgZmxhZ3MpOwogCWxpc3RfYWRkKCZyZXEtPmxpc3QsICZ0YXJnZXQtPmZyZWVfcmVxcyk7CisKK2Vycl91bmxvY2s6CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmdGFyZ2V0LT5sb2NrLCBmbGFncyk7CiAKIGVycjoKQEAgLTIxOTksNyArMjE5OCw3IEBACiAJCSAqIHN0YXJ0ZWQgYmVmb3JlIHdlIG1hcmtlZCBvdXIgdGFyZ2V0IHBvcnRzIGFzCiAJCSAqIHJlbW92ZWQsIGFuZCBhbnkgdGFyZ2V0IHBvcnQgcmVtb3ZhbCB0YXNrcy4KIAkJICovCi0JCWZsdXNoX3NjaGVkdWxlZF93b3JrKCk7CisJCWZsdXNoX3dvcmtxdWV1ZShpYl93cSk7CiAKIAkJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHRhcmdldCwgdG1wX3RhcmdldCwKIAkJCQkJICZob3N0LT50YXJnZXRfbGlzdCwgbGlzdCkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9LY29uZmlnIGIvZHJpdmVycy9pbnB1dC9LY29uZmlnCmluZGV4IDA3YzJjZDQuLjE5MDNjMGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvS2NvbmZpZworKysgYi9kcml2ZXJzL2lucHV0L0tjb25maWcKQEAgLTYsNyArNiw3IEBACiAJZGVwZW5kcyBvbiAhUzM5MAogCiBjb25maWcgSU5QVVQKLQl0cmlzdGF0ZSAiR2VuZXJpYyBpbnB1dCBsYXllciAobmVlZGVkIGZvciBrZXlib2FyZCwgbW91c2UsIC4uLikiIGlmIEVNQkVEREVECisJdHJpc3RhdGUgIkdlbmVyaWMgaW5wdXQgbGF5ZXIgKG5lZWRlZCBmb3Iga2V5Ym9hcmQsIG1vdXNlLCAuLi4pIiBpZiBFWFBFUlQKIAlkZWZhdWx0IHkKIAloZWxwCiAJICBTYXkgWSBoZXJlIGlmIHlvdSBoYXZlIGFueSBpbnB1dCBkZXZpY2UgKG1vdXNlLCBrZXlib2FyZCwgdGFibGV0LApAQCAtNjcsNyArNjcsNyBAQAogY29tbWVudCAiVXNlcmxhbmQgaW50ZXJmYWNlcyIKIAogY29uZmlnIElOUFVUX01PVVNFREVWCi0JdHJpc3RhdGUgIk1vdXNlIGludGVyZmFjZSIgaWYgRU1CRURERUQKKwl0cmlzdGF0ZSAiTW91c2UgaW50ZXJmYWNlIiBpZiBFWFBFUlQKIAlkZWZhdWx0IHkKIAloZWxwCiAJICBTYXkgWSBoZXJlIGlmIHlvdSB3YW50IHlvdXIgbW91c2UgdG8gYmUgYWNjZXNzaWJsZSBhcyBjaGFyIGRldmljZXMKQEAgLTE1MCw3ICsxNTAsNyBAQAogCSAgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIGV2YnVnLgogCiBjb25maWcgSU5QVVRfQVBNUE9XRVIKLQl0cmlzdGF0ZSAiSW5wdXQgUG93ZXIgRXZlbnQgLT4gQVBNIEJyaWRnZSIgaWYgRU1CRURERUQKKwl0cmlzdGF0ZSAiSW5wdXQgUG93ZXIgRXZlbnQgLT4gQVBNIEJyaWRnZSIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBJTlBVVCAmJiBBUE1fRU1VTEFUSU9OCiAJaGVscAogCSAgU2F5IFkgaGVyZSBpZiB5b3Ugd2FudCBzdXNwZW5kIGtleSBldmVudHMgdG8gdHJpZ2dlciBhIHVzZXIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvS2NvbmZpZyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvS2NvbmZpZwppbmRleCA3YjNjMGI4Li5jN2E5MjAyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L2tleWJvYXJkL0tjb25maWcKKysrIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9LY29uZmlnCkBAIC0yLDcgKzIsNyBAQAogIyBJbnB1dCBjb3JlIGNvbmZpZ3VyYXRpb24KICMKIG1lbnVjb25maWcgSU5QVVRfS0VZQk9BUkQKLQlib29sICJLZXlib2FyZHMiIGlmIEVNQkVEREVEIHx8ICFYODYKKwlib29sICJLZXlib2FyZHMiIGlmIEVYUEVSVCB8fCAhWDg2CiAJZGVmYXVsdCB5CiAJaGVscAogCSAgU2F5IFkgaGVyZSwgYW5kIGEgbGlzdCBvZiBzdXBwb3J0ZWQga2V5Ym9hcmRzIHdpbGwgYmUgZGlzcGxheWVkLgpAQCAtNTcsNyArNTcsNyBAQAogCSAgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIGF0YWtiZC4KIAogY29uZmlnIEtFWUJPQVJEX0FUS0JECi0JdHJpc3RhdGUgIkFUIGtleWJvYXJkIiBpZiBFTUJFRERFRCB8fCAhWDg2CisJdHJpc3RhdGUgIkFUIGtleWJvYXJkIiBpZiBFWFBFUlQgfHwgIVg4NgogCWRlZmF1bHQgeQogCXNlbGVjdCBTRVJJTwogCXNlbGVjdCBTRVJJT19MSUJQUzIKQEAgLTM0Myw2ICszNDMsMTYgQEAKIAkgIFRvIGNvbXBpbGUgdGhpcyBkcml2ZXIgYXMgYSBtb2R1bGUsIGNob29zZSBNIGhlcmU6IHRoZQogCSAgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIG5tay1za2Uta2V5cGFkLgogCitjb25maWcgS0VZQk9BUkRfVEVHUkEKKwl0cmlzdGF0ZSAiTlZJRElBIFRlZ3JhIGludGVybmFsIG1hdHJpeCBrZXlib2FyZCBjb250cm9sbGVyIHN1cHBvcnQiCisJZGVwZW5kcyBvbiBBUkNIX1RFR1JBCisJaGVscAorCSAgU2F5IFkgaGVyZSBpZiB5b3Ugd2FudCB0byB1c2UgYSBtYXRyaXgga2V5Ym9hcmQgY29ubmVjdGVkIGRpcmVjdGx5CisJICB0byB0aGUgaW50ZXJuYWwga2V5Ym9hcmQgY29udHJvbGxlciBvbiBUZWdyYSBTb0NzLgorCisJICBUbyBjb21waWxlIHRoaXMgZHJpdmVyIGFzIGEgbW9kdWxlLCBjaG9vc2UgTSBoZXJlOiB0aGUKKwkgIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCB0ZWdyYS1rYmMuCisKIGNvbmZpZyBLRVlCT0FSRF9PUEVOQ09SRVMKIAl0cmlzdGF0ZSAiT3BlbkNvcmVzIEtleWJvYXJkIENvbnRyb2xsZXIiCiAJaGVscApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9NYWtlZmlsZSBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvTWFrZWZpbGUKaW5kZXggNGU1NTcxYi4uNDY4YzYyNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2lucHV0L2tleWJvYXJkL01ha2VmaWxlCkBAIC00Miw2ICs0Miw3IEBACiBvYmotJChDT05GSUdfS0VZQk9BUkRfU1RPV0FXQVkpCQkrPSBzdG93YXdheS5vCiBvYmotJChDT05GSUdfS0VZQk9BUkRfU1VOS0JEKQkJKz0gc3Vua2JkLm8KIG9iai0kKENPTkZJR19LRVlCT0FSRF9UQzM1ODlYKQkJKz0gdGMzNTg5eC1rZXlwYWQubworb2JqLSQoQ09ORklHX0tFWUJPQVJEX1RFR1JBKQkJKz0gdGVncmEta2JjLm8KIG9iai0kKENPTkZJR19LRVlCT0FSRF9UTkVUVjEwN1gpCSs9IHRuZXR2MTA3eC1rZXlwYWQubwogb2JqLSQoQ09ORklHX0tFWUJPQVJEX1RXTDQwMzApCQkrPSB0d2w0MDMwX2tleXBhZC5vCiBvYmotJChDT05GSUdfS0VZQk9BUkRfWFRLQkQpCQkrPSB4dGtiZC5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2dwaW9fa2V5cy5jIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9ncGlvX2tleXMuYwppbmRleCA2MDY5YWJlLi5lYjMwMDYzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2dwaW9fa2V5cy5jCisrKyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvZ3Bpb19rZXlzLmMKQEAgLTMyMiw3ICszMjIsNyBAQAogCXN0cnVjdCBncGlvX2tleXNfYnV0dG9uICpidXR0b24gPSBiZGF0YS0+YnV0dG9uOwogCXN0cnVjdCBpbnB1dF9kZXYgKmlucHV0ID0gYmRhdGEtPmlucHV0OwogCXVuc2lnbmVkIGludCB0eXBlID0gYnV0dG9uLT50eXBlID86IEVWX0tFWTsKLQlpbnQgc3RhdGUgPSAoZ3Bpb19nZXRfdmFsdWUoYnV0dG9uLT5ncGlvKSA/IDEgOiAwKSBeIGJ1dHRvbi0+YWN0aXZlX2xvdzsKKwlpbnQgc3RhdGUgPSAoZ3Bpb19nZXRfdmFsdWVfY2Fuc2xlZXAoYnV0dG9uLT5ncGlvKSA/IDEgOiAwKSBeIGJ1dHRvbi0+YWN0aXZlX2xvdzsKIAogCWlucHV0X2V2ZW50KGlucHV0LCB0eXBlLCBidXR0b24tPmNvZGUsICEhc3RhdGUpOwogCWlucHV0X3N5bmMoaW5wdXQpOwpAQCAtNDEwLDggKzQxMCw4IEBACiAJaWYgKCFidXR0b24tPmNhbl9kaXNhYmxlKQogCQlpcnFmbGFncyB8PSBJUlFGX1NIQVJFRDsKIAotCWVycm9yID0gcmVxdWVzdF9pcnEoaXJxLCBncGlvX2tleXNfaXNyLCBpcnFmbGFncywgZGVzYywgYmRhdGEpOwotCWlmIChlcnJvcikgeworCWVycm9yID0gcmVxdWVzdF9hbnlfY29udGV4dF9pcnEoaXJxLCBncGlvX2tleXNfaXNyLCBpcnFmbGFncywgZGVzYywgYmRhdGEpOworCWlmIChlcnJvciA8IDApIHsKIAkJZGV2X2VycihkZXYsICJVbmFibGUgdG8gY2xhaW0gaXJxICVkOyBlcnJvciAlZFxuIiwKIAkJCWlycSwgZXJyb3IpOwogCQlnb3RvIGZhaWwzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9rZXlib2FyZC90ZWdyYS1rYmMuYyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvdGVncmEta2JjLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYWM0NzFiNwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvdGVncmEta2JjLmMKQEAgLTAsMCArMSw3MjcgQEAKKy8qCisgKiBLZXlib2FyZCBjbGFzcyBpbnB1dCBkcml2ZXIgZm9yIHRoZSBOVklESUEgVGVncmEgU29DIGludGVybmFsIG1hdHJpeAorICoga2V5Ym9hcmQgY29udHJvbGxlcgorICoKKyAqIENvcHlyaWdodCAoYykgMjAwOS0yMDExLCBOVklESUEgQ29ycG9yYXRpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKKyAqIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mIE1FUkNIQU5UQUJJTElUWSBvcgorICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvcgorICogbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFsb25nCisgKiB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAorICogNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9jbGsuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bWFjaC9jbGsuaD4KKyNpbmNsdWRlIDxtYWNoL2tiYy5oPgorCisjZGVmaW5lIEtCQ19NQVhfREVCT1VOQ0VfQ05UCTB4M2ZmdQorCisvKiBLQkMgcm93IHNjYW4gdGltZSBhbmQgZGVsYXkgZm9yIGJlZ2lubmluZyB0aGUgcm93IHNjYW4uICovCisjZGVmaW5lIEtCQ19ST1dfU0NBTl9USU1FCTE2CisjZGVmaW5lIEtCQ19ST1dfU0NBTl9ETFkJNQorCisvKiBLQkMgdXNlcyBhIDMyS0h6IGNsb2NrIHNvIGEgY3ljbGUgPSAxLzMyS2h6ICovCisjZGVmaW5lIEtCQ19DWUNMRV9VU0VDCTMyCisKKy8qIEtCQyBSZWdpc3RlcnMgKi8KKworLyogS0JDIENvbnRyb2wgUmVnaXN0ZXIgKi8KKyNkZWZpbmUgS0JDX0NPTlRST0xfMAkweDAKKyNkZWZpbmUgS0JDX0ZJRk9fVEhfQ05UX1NISUZUKGNudCkJKGNudCA8PCAxNCkKKyNkZWZpbmUgS0JDX0RFQk9VTkNFX0NOVF9TSElGVChjbnQpCShjbnQgPDwgNCkKKyNkZWZpbmUgS0JDX0NPTlRST0xfRklGT19DTlRfSU5UX0VOCSgxIDw8IDMpCisjZGVmaW5lIEtCQ19DT05UUk9MX0tCQ19FTgkJKDEgPDwgMCkKKworLyogS0JDIEludGVycnVwdCBSZWdpc3RlciAqLworI2RlZmluZSBLQkNfSU5UXzAJMHg0CisjZGVmaW5lIEtCQ19JTlRfRklGT19DTlRfSU5UX1NUQVRVUwkoMSA8PCAyKQorCisjZGVmaW5lIEtCQ19ST1dfQ0ZHMF8wCTB4OAorI2RlZmluZSBLQkNfQ09MX0NGRzBfMAkweDE4CisjZGVmaW5lIEtCQ19JTklUX0RMWV8wCTB4MjgKKyNkZWZpbmUgS0JDX1JQVF9ETFlfMAkweDJjCisjZGVmaW5lIEtCQ19LUF9FTlQwXzAJMHgzMAorI2RlZmluZSBLQkNfS1BfRU5UMV8wCTB4MzQKKyNkZWZpbmUgS0JDX1JPVzBfTUFTS18wCTB4MzgKKworI2RlZmluZSBLQkNfUk9XX1NISUZUCTMKKworc3RydWN0IHRlZ3JhX2tiYyB7CisJdm9pZCBfX2lvbWVtICptbWlvOworCXN0cnVjdCBpbnB1dF9kZXYgKmlkZXY7CisJdW5zaWduZWQgaW50IGlycTsKKwl1bnNpZ25lZCBpbnQgd2FrZV9lbmFibGVfcm93czsKKwl1bnNpZ25lZCBpbnQgd2FrZV9lbmFibGVfY29sczsKKwlzcGlubG9ja190IGxvY2s7CisJdW5zaWduZWQgaW50IHJlcG9sbF9kbHk7CisJdW5zaWduZWQgbG9uZyBjcF9kbHlfamlmZmllczsKKwljb25zdCBzdHJ1Y3QgdGVncmFfa2JjX3BsYXRmb3JtX2RhdGEgKnBkYXRhOworCXVuc2lnbmVkIHNob3J0IGtleWNvZGVbS0JDX01BWF9LRVldOworCXVuc2lnbmVkIHNob3J0IGN1cnJlbnRfa2V5c1tLQkNfTUFYX0tQRU5UXTsKKwl1bnNpZ25lZCBpbnQgbnVtX3ByZXNzZWRfa2V5czsKKwlzdHJ1Y3QgdGltZXJfbGlzdCB0aW1lcjsKKwlzdHJ1Y3QgY2xrICpjbGs7Cit9OworCitzdGF0aWMgY29uc3QgdTMyIHRlZ3JhX2tiY19kZWZhdWx0X2tleW1hcFtdID0geworCUtFWSgwLCAyLCBLRVlfVyksCisJS0VZKDAsIDMsIEtFWV9TKSwKKwlLRVkoMCwgNCwgS0VZX0EpLAorCUtFWSgwLCA1LCBLRVlfWiksCisJS0VZKDAsIDcsIEtFWV9GTiksCisKKwlLRVkoMSwgNywgS0VZX0xFRlRNRVRBKSwKKworCUtFWSgyLCA2LCBLRVlfUklHSFRBTFQpLAorCUtFWSgyLCA3LCBLRVlfTEVGVEFMVCksCisKKwlLRVkoMywgMCwgS0VZXzUpLAorCUtFWSgzLCAxLCBLRVlfNCksCisJS0VZKDMsIDIsIEtFWV9SKSwKKwlLRVkoMywgMywgS0VZX0UpLAorCUtFWSgzLCA0LCBLRVlfRiksCisJS0VZKDMsIDUsIEtFWV9EKSwKKwlLRVkoMywgNiwgS0VZX1gpLAorCisJS0VZKDQsIDAsIEtFWV83KSwKKwlLRVkoNCwgMSwgS0VZXzYpLAorCUtFWSg0LCAyLCBLRVlfVCksCisJS0VZKDQsIDMsIEtFWV9IKSwKKwlLRVkoNCwgNCwgS0VZX0cpLAorCUtFWSg0LCA1LCBLRVlfViksCisJS0VZKDQsIDYsIEtFWV9DKSwKKwlLRVkoNCwgNywgS0VZX1NQQUNFKSwKKworCUtFWSg1LCAwLCBLRVlfOSksCisJS0VZKDUsIDEsIEtFWV84KSwKKwlLRVkoNSwgMiwgS0VZX1UpLAorCUtFWSg1LCAzLCBLRVlfWSksCisJS0VZKDUsIDQsIEtFWV9KKSwKKwlLRVkoNSwgNSwgS0VZX04pLAorCUtFWSg1LCA2LCBLRVlfQiksCisJS0VZKDUsIDcsIEtFWV9CQUNLU0xBU0gpLAorCisJS0VZKDYsIDAsIEtFWV9NSU5VUyksCisJS0VZKDYsIDEsIEtFWV8wKSwKKwlLRVkoNiwgMiwgS0VZX08pLAorCUtFWSg2LCAzLCBLRVlfSSksCisJS0VZKDYsIDQsIEtFWV9MKSwKKwlLRVkoNiwgNSwgS0VZX0spLAorCUtFWSg2LCA2LCBLRVlfQ09NTUEpLAorCUtFWSg2LCA3LCBLRVlfTSksCisKKwlLRVkoNywgMSwgS0VZX0VRVUFMKSwKKwlLRVkoNywgMiwgS0VZX1JJR0hUQlJBQ0UpLAorCUtFWSg3LCAzLCBLRVlfRU5URVIpLAorCUtFWSg3LCA3LCBLRVlfTUVOVSksCisKKwlLRVkoOCwgNCwgS0VZX1JJR0hUU0hJRlQpLAorCUtFWSg4LCA1LCBLRVlfTEVGVFNISUZUKSwKKworCUtFWSg5LCA1LCBLRVlfUklHSFRDVFJMKSwKKwlLRVkoOSwgNywgS0VZX0xFRlRDVFJMKSwKKworCUtFWSgxMSwgMCwgS0VZX0xFRlRCUkFDRSksCisJS0VZKDExLCAxLCBLRVlfUCksCisJS0VZKDExLCAyLCBLRVlfQVBPU1RST1BIRSksCisJS0VZKDExLCAzLCBLRVlfU0VNSUNPTE9OKSwKKwlLRVkoMTEsIDQsIEtFWV9TTEFTSCksCisJS0VZKDExLCA1LCBLRVlfRE9UKSwKKworCUtFWSgxMiwgMCwgS0VZX0YxMCksCisJS0VZKDEyLCAxLCBLRVlfRjkpLAorCUtFWSgxMiwgMiwgS0VZX0JBQ0tTUEFDRSksCisJS0VZKDEyLCAzLCBLRVlfMyksCisJS0VZKDEyLCA0LCBLRVlfMiksCisJS0VZKDEyLCA1LCBLRVlfVVApLAorCUtFWSgxMiwgNiwgS0VZX1BSSU5UKSwKKwlLRVkoMTIsIDcsIEtFWV9QQVVTRSksCisKKwlLRVkoMTMsIDAsIEtFWV9JTlNFUlQpLAorCUtFWSgxMywgMSwgS0VZX0RFTEVURSksCisJS0VZKDEzLCAzLCBLRVlfUEFHRVVQKSwKKwlLRVkoMTMsIDQsIEtFWV9QQUdFRE9XTiksCisJS0VZKDEzLCA1LCBLRVlfUklHSFQpLAorCUtFWSgxMywgNiwgS0VZX0RPV04pLAorCUtFWSgxMywgNywgS0VZX0xFRlQpLAorCisJS0VZKDE0LCAwLCBLRVlfRjExKSwKKwlLRVkoMTQsIDEsIEtFWV9GMTIpLAorCUtFWSgxNCwgMiwgS0VZX0Y4KSwKKwlLRVkoMTQsIDMsIEtFWV9RKSwKKwlLRVkoMTQsIDQsIEtFWV9GNCksCisJS0VZKDE0LCA1LCBLRVlfRjMpLAorCUtFWSgxNCwgNiwgS0VZXzEpLAorCUtFWSgxNCwgNywgS0VZX0Y3KSwKKworCUtFWSgxNSwgMCwgS0VZX0VTQyksCisJS0VZKDE1LCAxLCBLRVlfR1JBVkUpLAorCUtFWSgxNSwgMiwgS0VZX0Y1KSwKKwlLRVkoMTUsIDMsIEtFWV9UQUIpLAorCUtFWSgxNSwgNCwgS0VZX0YxKSwKKwlLRVkoMTUsIDUsIEtFWV9GMiksCisJS0VZKDE1LCA2LCBLRVlfQ0FQU0xPQ0spLAorCUtFWSgxNSwgNywgS0VZX0Y2KSwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbWF0cml4X2tleW1hcF9kYXRhIHRlZ3JhX2tiY19kZWZhdWx0X2tleW1hcF9kYXRhID0geworCS5rZXltYXAJCT0gdGVncmFfa2JjX2RlZmF1bHRfa2V5bWFwLAorCS5rZXltYXBfc2l6ZQk9IEFSUkFZX1NJWkUodGVncmFfa2JjX2RlZmF1bHRfa2V5bWFwKSwKK307CisKK3N0YXRpYyB2b2lkIHRlZ3JhX2tiY19yZXBvcnRfcmVsZWFzZWRfa2V5cyhzdHJ1Y3QgaW5wdXRfZGV2ICppbnB1dCwKKwkJCQkJICAgdW5zaWduZWQgc2hvcnQgb2xkX2tleWNvZGVzW10sCisJCQkJCSAgIHVuc2lnbmVkIGludCBvbGRfbnVtX2tleXMsCisJCQkJCSAgIHVuc2lnbmVkIHNob3J0IG5ld19rZXljb2Rlc1tdLAorCQkJCQkgICB1bnNpZ25lZCBpbnQgbmV3X251bV9rZXlzKQoreworCXVuc2lnbmVkIGludCBpLCBqOworCisJZm9yIChpID0gMDsgaSA8IG9sZF9udW1fa2V5czsgaSsrKSB7CisJCWZvciAoaiA9IDA7IGogPCBuZXdfbnVtX2tleXM7IGorKykKKwkJCWlmIChvbGRfa2V5Y29kZXNbaV0gPT0gbmV3X2tleWNvZGVzW2pdKQorCQkJCWJyZWFrOworCisJCWlmIChqID09IG5ld19udW1fa2V5cykKKwkJCWlucHV0X3JlcG9ydF9rZXkoaW5wdXQsIG9sZF9rZXljb2Rlc1tpXSwgMCk7CisJfQorfQorCitzdGF0aWMgdm9pZCB0ZWdyYV9rYmNfcmVwb3J0X3ByZXNzZWRfa2V5cyhzdHJ1Y3QgaW5wdXRfZGV2ICppbnB1dCwKKwkJCQkJICB1bnNpZ25lZCBjaGFyIHNjYW5jb2Rlc1tdLAorCQkJCQkgIHVuc2lnbmVkIHNob3J0IGtleWNvZGVzW10sCisJCQkJCSAgdW5zaWduZWQgaW50IG51bV9wcmVzc2VkX2tleXMpCit7CisJdW5zaWduZWQgaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgbnVtX3ByZXNzZWRfa2V5czsgaSsrKSB7CisJCWlucHV0X2V2ZW50KGlucHV0LCBFVl9NU0MsIE1TQ19TQ0FOLCBzY2FuY29kZXNbaV0pOworCQlpbnB1dF9yZXBvcnRfa2V5KGlucHV0LCBrZXljb2Rlc1tpXSwgMSk7CisJfQorfQorCitzdGF0aWMgdm9pZCB0ZWdyYV9rYmNfcmVwb3J0X2tleXMoc3RydWN0IHRlZ3JhX2tiYyAqa2JjKQoreworCXVuc2lnbmVkIGNoYXIgc2NhbmNvZGVzW0tCQ19NQVhfS1BFTlRdOworCXVuc2lnbmVkIHNob3J0IGtleWNvZGVzW0tCQ19NQVhfS1BFTlRdOworCXUzMiB2YWwgPSAwOworCXVuc2lnbmVkIGludCBpOworCXVuc2lnbmVkIGludCBudW1fZG93biA9IDA7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZrYmMtPmxvY2ssIGZsYWdzKTsKKwlmb3IgKGkgPSAwOyBpIDwgS0JDX01BWF9LUEVOVDsgaSsrKSB7CisJCWlmICgoaSAlIDQpID09IDApCisJCQl2YWwgPSByZWFkbChrYmMtPm1taW8gKyBLQkNfS1BfRU5UMF8wICsgaSk7CisKKwkJaWYgKHZhbCAmIDB4ODApIHsKKwkJCXVuc2lnbmVkIGludCBjb2wgPSB2YWwgJiAweDA3OworCQkJdW5zaWduZWQgaW50IHJvdyA9ICh2YWwgPj4gMykgJiAweDBmOworCQkJdW5zaWduZWQgY2hhciBzY2FuY29kZSA9CisJCQkJTUFUUklYX1NDQU5fQ09ERShyb3csIGNvbCwgS0JDX1JPV19TSElGVCk7CisKKwkJCXNjYW5jb2Rlc1tudW1fZG93bl0gPSBzY2FuY29kZTsKKwkJCWtleWNvZGVzW251bV9kb3duKytdID0ga2JjLT5rZXljb2RlW3NjYW5jb2RlXTsKKwkJfQorCisJCXZhbCA+Pj0gODsKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgma2JjLT5sb2NrLCBmbGFncyk7CisKKwl0ZWdyYV9rYmNfcmVwb3J0X3JlbGVhc2VkX2tleXMoa2JjLT5pZGV2LAorCQkJCSAgICAgICBrYmMtPmN1cnJlbnRfa2V5cywga2JjLT5udW1fcHJlc3NlZF9rZXlzLAorCQkJCSAgICAgICBrZXljb2RlcywgbnVtX2Rvd24pOworCXRlZ3JhX2tiY19yZXBvcnRfcHJlc3NlZF9rZXlzKGtiYy0+aWRldiwgc2NhbmNvZGVzLCBrZXljb2RlcywgbnVtX2Rvd24pOworCWlucHV0X3N5bmMoa2JjLT5pZGV2KTsKKworCW1lbWNweShrYmMtPmN1cnJlbnRfa2V5cywga2V5Y29kZXMsIHNpemVvZihrYmMtPmN1cnJlbnRfa2V5cykpOworCWtiYy0+bnVtX3ByZXNzZWRfa2V5cyA9IG51bV9kb3duOworfQorCitzdGF0aWMgdm9pZCB0ZWdyYV9rYmNfa2V5cHJlc3NfdGltZXIodW5zaWduZWQgbG9uZyBkYXRhKQoreworCXN0cnVjdCB0ZWdyYV9rYmMgKmtiYyA9IChzdHJ1Y3QgdGVncmFfa2JjICopZGF0YTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXUzMiB2YWw7CisJdW5zaWduZWQgaW50IGk7CisKKwl2YWwgPSAocmVhZGwoa2JjLT5tbWlvICsgS0JDX0lOVF8wKSA+PiA0KSAmIDB4ZjsKKwlpZiAodmFsKSB7CisJCXVuc2lnbmVkIGxvbmcgZGx5OworCisJCXRlZ3JhX2tiY19yZXBvcnRfa2V5cyhrYmMpOworCisJCS8qCisJCSAqIElmIG1vcmUgdGhhbiBvbmUga2V5cyBhcmUgcHJlc3NlZCB3ZSBuZWVkIG5vdCB3YWl0CisJCSAqIGZvciB0aGUgcmVwb2xsIGRlbGF5LgorCQkgKi8KKwkJZGx5ID0gKHZhbCA9PSAxKSA/IGtiYy0+cmVwb2xsX2RseSA6IDE7CisJCW1vZF90aW1lcigma2JjLT50aW1lciwgamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoZGx5KSk7CisJfSBlbHNlIHsKKwkJLyogUmVsZWFzZSBhbnkgcHJlc3NlZCBrZXlzIGFuZCBleGl0IHRoZSBwb2xsaW5nIGxvb3AgKi8KKwkJZm9yIChpID0gMDsgaSA8IGtiYy0+bnVtX3ByZXNzZWRfa2V5czsgaSsrKQorCQkJaW5wdXRfcmVwb3J0X2tleShrYmMtPmlkZXYsIGtiYy0+Y3VycmVudF9rZXlzW2ldLCAwKTsKKwkJaW5wdXRfc3luYyhrYmMtPmlkZXYpOworCisJCWtiYy0+bnVtX3ByZXNzZWRfa2V5cyA9IDA7CisKKwkJLyogQWxsIGtleXMgYXJlIHJlbGVhc2VkIHNvIGVuYWJsZSB0aGUga2V5cHJlc3MgaW50ZXJydXB0ICovCisJCXNwaW5fbG9ja19pcnFzYXZlKCZrYmMtPmxvY2ssIGZsYWdzKTsKKwkJdmFsID0gcmVhZGwoa2JjLT5tbWlvICsgS0JDX0NPTlRST0xfMCk7CisJCXZhbCB8PSBLQkNfQ09OVFJPTF9GSUZPX0NOVF9JTlRfRU47CisJCXdyaXRlbCh2YWwsIGtiYy0+bW1pbyArIEtCQ19DT05UUk9MXzApOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZrYmMtPmxvY2ssIGZsYWdzKTsKKwl9Cit9CisKK3N0YXRpYyBpcnFyZXR1cm5fdCB0ZWdyYV9rYmNfaXNyKGludCBpcnEsIHZvaWQgKmFyZ3MpCit7CisJc3RydWN0IHRlZ3JhX2tiYyAqa2JjID0gYXJnczsKKwl1MzIgdmFsLCBjdGw7CisKKwkvKgorCSAqIFVudGlsIGFsbCBrZXlzIGFyZSByZWxlYXNlZCwgZGVmZXIgZnVydGhlciBwcm9jZXNzaW5nIHRvCisJICogdGhlIHBvbGxpbmcgbG9vcCBpbiB0ZWdyYV9rYmNfa2V5cHJlc3NfdGltZXIKKwkgKi8KKwljdGwgPSByZWFkbChrYmMtPm1taW8gKyBLQkNfQ09OVFJPTF8wKTsKKwljdGwgJj0gfktCQ19DT05UUk9MX0ZJRk9fQ05UX0lOVF9FTjsKKwl3cml0ZWwoY3RsLCBrYmMtPm1taW8gKyBLQkNfQ09OVFJPTF8wKTsKKworCS8qCisJICogUXVpY2tseSBiYWlsIG91dCAmIHJlZW5hYmxlIGludGVycnVwdHMgaWYgdGhlIGZpZm8gdGhyZXNob2xkCisJICogY291bnQgaW50ZXJydXB0IHdhc24ndCB0aGUgaW50ZXJydXB0IHNvdXJjZQorCSAqLworCXZhbCA9IHJlYWRsKGtiYy0+bW1pbyArIEtCQ19JTlRfMCk7CisJd3JpdGVsKHZhbCwga2JjLT5tbWlvICsgS0JDX0lOVF8wKTsKKworCWlmICh2YWwgJiBLQkNfSU5UX0ZJRk9fQ05UX0lOVF9TVEFUVVMpIHsKKwkJLyoKKwkJICogU2NoZWR1bGUgdGltZXIgdG8gcnVuIHdoZW4gaGFyZHdhcmUgaXMgaW4gY29udGludW91cworCQkgKiBwb2xsaW5nIG1vZGUuCisJCSAqLworCQltb2RfdGltZXIoJmtiYy0+dGltZXIsIGppZmZpZXMgKyBrYmMtPmNwX2RseV9qaWZmaWVzKTsKKwl9IGVsc2UgeworCQljdGwgfD0gS0JDX0NPTlRST0xfRklGT19DTlRfSU5UX0VOOworCQl3cml0ZWwoY3RsLCBrYmMtPm1taW8gKyBLQkNfQ09OVFJPTF8wKTsKKwl9CisKKwlyZXR1cm4gSVJRX0hBTkRMRUQ7Cit9CisKK3N0YXRpYyB2b2lkIHRlZ3JhX2tiY19zZXR1cF93YWtla2V5cyhzdHJ1Y3QgdGVncmFfa2JjICprYmMsIGJvb2wgZmlsdGVyKQoreworCWNvbnN0IHN0cnVjdCB0ZWdyYV9rYmNfcGxhdGZvcm1fZGF0YSAqcGRhdGEgPSBrYmMtPnBkYXRhOworCWludCBpOworCXVuc2lnbmVkIGludCByc3RfdmFsOworCisJQlVHX09OKHBkYXRhLT53YWtlX2NudCA+IEtCQ19NQVhfS0VZKTsKKwlyc3RfdmFsID0gKGZpbHRlciAmJiBwZGF0YS0+d2FrZV9jbnQpID8gfjAgOiAwOworCisJZm9yIChpID0gMDsgaSA8IEtCQ19NQVhfUk9XOyBpKyspCisJCXdyaXRlbChyc3RfdmFsLCBrYmMtPm1taW8gKyBLQkNfUk9XMF9NQVNLXzAgKyBpICogNCk7CisKKwlpZiAoZmlsdGVyKSB7CisJCWZvciAoaSA9IDA7IGkgPCBwZGF0YS0+d2FrZV9jbnQ7IGkrKykgeworCQkJdTMyIHZhbCwgYWRkcjsKKwkJCWFkZHIgPSBwZGF0YS0+d2FrZV9jZmdbaV0ucm93ICogNCArIEtCQ19ST1cwX01BU0tfMDsKKwkJCXZhbCA9IHJlYWRsKGtiYy0+bW1pbyArIGFkZHIpOworCQkJdmFsICY9IH4oMSA8PCBwZGF0YS0+d2FrZV9jZmdbaV0uY29sKTsKKwkJCXdyaXRlbCh2YWwsIGtiYy0+bW1pbyArIGFkZHIpOworCQl9CisJfQorfQorCitzdGF0aWMgdm9pZCB0ZWdyYV9rYmNfY29uZmlnX3BpbnMoc3RydWN0IHRlZ3JhX2tiYyAqa2JjKQoreworCWNvbnN0IHN0cnVjdCB0ZWdyYV9rYmNfcGxhdGZvcm1fZGF0YSAqcGRhdGEgPSBrYmMtPnBkYXRhOworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IEtCQ19NQVhfR1BJTzsgaSsrKSB7CisJCXUzMiByX3NoZnQgPSA1ICogKGkgJSA2KTsKKwkJdTMyIGNfc2hmdCA9IDQgKiAoaSAlIDgpOworCQl1MzIgcl9tYXNrID0gMHgxZiA8PCByX3NoZnQ7CisJCXUzMiBjX21hc2sgPSAweDBmIDw8IGNfc2hmdDsKKwkJdTMyIHJfb2ZmcyA9IChpIC8gNikgKiA0ICsgS0JDX1JPV19DRkcwXzA7CisJCXUzMiBjX29mZnMgPSAoaSAvIDgpICogNCArIEtCQ19DT0xfQ0ZHMF8wOworCQl1MzIgcm93X2NmZyA9IHJlYWRsKGtiYy0+bW1pbyArIHJfb2Zmcyk7CisJCXUzMiBjb2xfY2ZnID0gcmVhZGwoa2JjLT5tbWlvICsgY19vZmZzKTsKKworCQlyb3dfY2ZnICY9IH5yX21hc2s7CisJCWNvbF9jZmcgJj0gfmNfbWFzazsKKworCQlpZiAocGRhdGEtPnBpbl9jZmdbaV0uaXNfcm93KQorCQkJcm93X2NmZyB8PSAoKHBkYXRhLT5waW5fY2ZnW2ldLm51bSA8PCAxKSB8IDEpIDw8IHJfc2hmdDsKKwkJZWxzZQorCQkJY29sX2NmZyB8PSAoKHBkYXRhLT5waW5fY2ZnW2ldLm51bSA8PCAxKSB8IDEpIDw8IGNfc2hmdDsKKworCQl3cml0ZWwocm93X2NmZywga2JjLT5tbWlvICsgcl9vZmZzKTsKKwkJd3JpdGVsKGNvbF9jZmcsIGtiYy0+bW1pbyArIGNfb2Zmcyk7CisJfQorfQorCitzdGF0aWMgaW50IHRlZ3JhX2tiY19zdGFydChzdHJ1Y3QgdGVncmFfa2JjICprYmMpCit7CisJY29uc3Qgc3RydWN0IHRlZ3JhX2tiY19wbGF0Zm9ybV9kYXRhICpwZGF0YSA9IGtiYy0+cGRhdGE7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwl1bnNpZ25lZCBpbnQgZGVib3VuY2VfY250OworCXUzMiB2YWwgPSAwOworCisJY2xrX2VuYWJsZShrYmMtPmNsayk7CisKKwkvKiBSZXNldCB0aGUgS0JDIGNvbnRyb2xsZXIgdG8gY2xlYXIgYWxsIHByZXZpb3VzIHN0YXR1cy4qLworCXRlZ3JhX3BlcmlwaF9yZXNldF9hc3NlcnQoa2JjLT5jbGspOworCXVkZWxheSgxMDApOworCXRlZ3JhX3BlcmlwaF9yZXNldF9kZWFzc2VydChrYmMtPmNsayk7CisJdWRlbGF5KDEwMCk7CisKKwl0ZWdyYV9rYmNfY29uZmlnX3BpbnMoa2JjKTsKKwl0ZWdyYV9rYmNfc2V0dXBfd2FrZWtleXMoa2JjLCBmYWxzZSk7CisKKwl3cml0ZWwocGRhdGEtPnJlcGVhdF9jbnQsIGtiYy0+bW1pbyArIEtCQ19SUFRfRExZXzApOworCisJLyogS2V5Ym9hcmQgZGVib3VuY2UgY291bnQgaXMgbWF4aW11bSBvZiAxMiBiaXRzLiAqLworCWRlYm91bmNlX2NudCA9IG1pbihwZGF0YS0+ZGVib3VuY2VfY250LCBLQkNfTUFYX0RFQk9VTkNFX0NOVCk7CisJdmFsID0gS0JDX0RFQk9VTkNFX0NOVF9TSElGVChkZWJvdW5jZV9jbnQpOworCXZhbCB8PSBLQkNfRklGT19USF9DTlRfU0hJRlQoMSk7IC8qIHNldCBmaWZvIGludGVycnVwdCB0aHJlc2hvbGQgdG8gMSAqLworCXZhbCB8PSBLQkNfQ09OVFJPTF9GSUZPX0NOVF9JTlRfRU47ICAvKiBpbnRlcnJ1cHQgb24gRklGTyB0aHJlc2hvbGQgKi8KKwl2YWwgfD0gS0JDX0NPTlRST0xfS0JDX0VOOyAgICAgLyogZW5hYmxlICovCisJd3JpdGVsKHZhbCwga2JjLT5tbWlvICsgS0JDX0NPTlRST0xfMCk7CisKKwkvKgorCSAqIENvbXB1dGUgdGhlIGRlbGF5KG5zKSBmcm9tIGludGVycnVwdCBtb2RlIHRvIGNvbnRpbnVvdXMgcG9sbGluZworCSAqIG1vZGUgc28gdGhlIHRpbWVyIHJvdXRpbmUgaXMgc2NoZWR1bGVkIGFwcHJvcHJpYXRlbHkuCisJICovCisJdmFsID0gcmVhZGwoa2JjLT5tbWlvICsgS0JDX0lOSVRfRExZXzApOworCWtiYy0+Y3BfZGx5X2ppZmZpZXMgPSB1c2Vjc190b19qaWZmaWVzKCh2YWwgJiAweGZmZmZmKSAqIDMyKTsKKworCWtiYy0+bnVtX3ByZXNzZWRfa2V5cyA9IDA7CisKKwkvKgorCSAqIEF0b21pY2FsbHkgY2xlYXIgb3V0IGFueSByZW1haW5pbmcgZW50cmllcyBpbiB0aGUga2V5IEZJRk8KKwkgKiBhbmQgZW5hYmxlIGtleWJvYXJkIGludGVycnVwdHMuCisJICovCisJc3Bpbl9sb2NrX2lycXNhdmUoJmtiYy0+bG9jaywgZmxhZ3MpOworCXdoaWxlICgxKSB7CisJCXZhbCA9IHJlYWRsKGtiYy0+bW1pbyArIEtCQ19JTlRfMCk7CisJCXZhbCA+Pj0gNDsKKwkJaWYgKCF2YWwpCisJCQlicmVhazsKKworCQl2YWwgPSByZWFkbChrYmMtPm1taW8gKyBLQkNfS1BfRU5UMF8wKTsKKwkJdmFsID0gcmVhZGwoa2JjLT5tbWlvICsgS0JDX0tQX0VOVDFfMCk7CisJfQorCXdyaXRlbCgweDcsIGtiYy0+bW1pbyArIEtCQ19JTlRfMCk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgma2JjLT5sb2NrLCBmbGFncyk7CisKKwllbmFibGVfaXJxKGtiYy0+aXJxKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCB0ZWdyYV9rYmNfc3RvcChzdHJ1Y3QgdGVncmFfa2JjICprYmMpCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwl1MzIgdmFsOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmtiYy0+bG9jaywgZmxhZ3MpOworCXZhbCA9IHJlYWRsKGtiYy0+bW1pbyArIEtCQ19DT05UUk9MXzApOworCXZhbCAmPSB+MTsKKwl3cml0ZWwodmFsLCBrYmMtPm1taW8gKyBLQkNfQ09OVFJPTF8wKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZrYmMtPmxvY2ssIGZsYWdzKTsKKworCWRpc2FibGVfaXJxKGtiYy0+aXJxKTsKKwlkZWxfdGltZXJfc3luYygma2JjLT50aW1lcik7CisKKwljbGtfZGlzYWJsZShrYmMtPmNsayk7Cit9CisKK3N0YXRpYyBpbnQgdGVncmFfa2JjX29wZW4oc3RydWN0IGlucHV0X2RldiAqZGV2KQoreworCXN0cnVjdCB0ZWdyYV9rYmMgKmtiYyA9IGlucHV0X2dldF9kcnZkYXRhKGRldik7CisKKwlyZXR1cm4gdGVncmFfa2JjX3N0YXJ0KGtiYyk7Cit9CisKK3N0YXRpYyB2b2lkIHRlZ3JhX2tiY19jbG9zZShzdHJ1Y3QgaW5wdXRfZGV2ICpkZXYpCit7CisJc3RydWN0IHRlZ3JhX2tiYyAqa2JjID0gaW5wdXRfZ2V0X2RydmRhdGEoZGV2KTsKKworCXJldHVybiB0ZWdyYV9rYmNfc3RvcChrYmMpOworfQorCitzdGF0aWMgYm9vbCBfX2RldmluaXQKK3RlZ3JhX2tiY19jaGVja19waW5fY2ZnKGNvbnN0IHN0cnVjdCB0ZWdyYV9rYmNfcGxhdGZvcm1fZGF0YSAqcGRhdGEsCisJCQlzdHJ1Y3QgZGV2aWNlICpkZXYsIHVuc2lnbmVkIGludCAqbnVtX3Jvd3MpCit7CisJaW50IGk7CisKKwkqbnVtX3Jvd3MgPSAwOworCisJZm9yIChpID0gMDsgaSA8IEtCQ19NQVhfR1BJTzsgaSsrKSB7CisJCWNvbnN0IHN0cnVjdCB0ZWdyYV9rYmNfcGluX2NmZyAqcGluX2NmZyA9ICZwZGF0YS0+cGluX2NmZ1tpXTsKKworCQlpZiAocGluX2NmZy0+aXNfcm93KSB7CisJCQlpZiAocGluX2NmZy0+bnVtID49IEtCQ19NQVhfUk9XKSB7CisJCQkJZGV2X2VycihkZXYsCisJCQkJCSJwaW5fY2ZnWyVkXTogaW52YWxpZCByb3cgbnVtYmVyICVkXG4iLAorCQkJCQlpLCBwaW5fY2ZnLT5udW0pOworCQkJCXJldHVybiBmYWxzZTsKKwkJCX0KKwkJCSgqbnVtX3Jvd3MpKys7CisJCX0gZWxzZSB7CisJCQlpZiAocGluX2NmZy0+bnVtID49IEtCQ19NQVhfQ09MKSB7CisJCQkJZGV2X2VycihkZXYsCisJCQkJCSJwaW5fY2ZnWyVkXTogaW52YWxpZCBjb2x1bW4gbnVtYmVyICVkXG4iLAorCQkJCQlpLCBwaW5fY2ZnLT5udW0pOworCQkJCXJldHVybiBmYWxzZTsKKwkJCX0KKwkJfQorCX0KKworCXJldHVybiB0cnVlOworfQorCitzdGF0aWMgaW50IF9fZGV2aW5pdCB0ZWdyYV9rYmNfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwljb25zdCBzdHJ1Y3QgdGVncmFfa2JjX3BsYXRmb3JtX2RhdGEgKnBkYXRhID0gcGRldi0+ZGV2LnBsYXRmb3JtX2RhdGE7CisJY29uc3Qgc3RydWN0IG1hdHJpeF9rZXltYXBfZGF0YSAqa2V5bWFwX2RhdGE7CisJc3RydWN0IHRlZ3JhX2tiYyAqa2JjOworCXN0cnVjdCBpbnB1dF9kZXYgKmlucHV0X2RldjsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKKwlpbnQgaXJxOworCWludCBlcnI7CisJaW50IGk7CisJaW50IG51bV9yb3dzID0gMDsKKwl1bnNpZ25lZCBpbnQgZGVib3VuY2VfY250OworCXVuc2lnbmVkIGludCBzY2FuX3RpbWVfcm93czsKKworCWlmICghcGRhdGEpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKCF0ZWdyYV9rYmNfY2hlY2tfcGluX2NmZyhwZGF0YSwgJnBkZXYtPmRldiwgJm51bV9yb3dzKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9NRU0sIDApOworCWlmICghcmVzKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgImZhaWxlZCB0byBnZXQgSS9PIG1lbW9yeVxuIik7CisJCXJldHVybiAtRU5YSU87CisJfQorCisJaXJxID0gcGxhdGZvcm1fZ2V0X2lycShwZGV2LCAwKTsKKwlpZiAoaXJxIDwgMCkgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gZ2V0IGtleWJvYXJkIElSUVxuIik7CisJCXJldHVybiAtRU5YSU87CisJfQorCisJa2JjID0ga3phbGxvYyhzaXplb2YoKmtiYyksIEdGUF9LRVJORUwpOworCWlucHV0X2RldiA9IGlucHV0X2FsbG9jYXRlX2RldmljZSgpOworCWlmICgha2JjIHx8ICFpbnB1dF9kZXYpIHsKKwkJZXJyID0gLUVOT01FTTsKKwkJZ290byBlcnJfZnJlZV9tZW07CisJfQorCisJa2JjLT5wZGF0YSA9IHBkYXRhOworCWtiYy0+aWRldiA9IGlucHV0X2RldjsKKwlrYmMtPmlycSA9IGlycTsKKwlzcGluX2xvY2tfaW5pdCgma2JjLT5sb2NrKTsKKwlzZXR1cF90aW1lcigma2JjLT50aW1lciwgdGVncmFfa2JjX2tleXByZXNzX3RpbWVyLCAodW5zaWduZWQgbG9uZylrYmMpOworCisJcmVzID0gcmVxdWVzdF9tZW1fcmVnaW9uKHJlcy0+c3RhcnQsIHJlc291cmNlX3NpemUocmVzKSwgcGRldi0+bmFtZSk7CisJaWYgKCFyZXMpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIHJlcXVlc3QgSS9PIG1lbW9yeVxuIik7CisJCWVyciA9IC1FQlVTWTsKKwkJZ290byBlcnJfZnJlZV9tZW07CisJfQorCisJa2JjLT5tbWlvID0gaW9yZW1hcChyZXMtPnN0YXJ0LCByZXNvdXJjZV9zaXplKHJlcykpOworCWlmICgha2JjLT5tbWlvKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgImZhaWxlZCB0byByZW1hcCBJL08gbWVtb3J5XG4iKTsKKwkJZXJyID0gLUVOWElPOworCQlnb3RvIGVycl9mcmVlX21lbV9yZWdpb247CisJfQorCisJa2JjLT5jbGsgPSBjbGtfZ2V0KCZwZGV2LT5kZXYsIE5VTEwpOworCWlmIChJU19FUlIoa2JjLT5jbGspKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgImZhaWxlZCB0byBnZXQga2V5Ym9hcmQgY2xvY2tcbiIpOworCQllcnIgPSBQVFJfRVJSKGtiYy0+Y2xrKTsKKwkJZ290byBlcnJfaW91bm1hcDsKKwl9CisKKwlrYmMtPndha2VfZW5hYmxlX3Jvd3MgPSAwOworCWtiYy0+d2FrZV9lbmFibGVfY29scyA9IDA7CisJZm9yIChpID0gMDsgaSA8IHBkYXRhLT53YWtlX2NudDsgaSsrKSB7CisJCWtiYy0+d2FrZV9lbmFibGVfcm93cyB8PSAoMSA8PCBwZGF0YS0+d2FrZV9jZmdbaV0ucm93KTsKKwkJa2JjLT53YWtlX2VuYWJsZV9jb2xzIHw9ICgxIDw8IHBkYXRhLT53YWtlX2NmZ1tpXS5jb2wpOworCX0KKworCS8qCisJICogVGhlIHRpbWUgZGVsYXkgYmV0d2VlbiB0d28gY29uc2VjdXRpdmUgcmVhZHMgb2YgdGhlIEZJRk8gaXMKKwkgKiB0aGUgc3VtIG9mIHRoZSByZXBlYXQgdGltZSBhbmQgdGhlIHRpbWUgdGFrZW4gZm9yIHNjYW5uaW5nCisJICogdGhlIHJvd3MuIFRoZXJlIGlzIGFuIGFkZGl0aW9uYWwgZGVsYXkgYmVmb3JlIHRoZSByb3cgc2Nhbm5pbmcKKwkgKiBzdGFydHMuIFRoZSByZXBvbGwgZGVsYXkgaXMgY29tcHV0ZWQgaW4gbWlsbGlzZWNvbmRzLgorCSAqLworCWRlYm91bmNlX2NudCA9IG1pbihwZGF0YS0+ZGVib3VuY2VfY250LCBLQkNfTUFYX0RFQk9VTkNFX0NOVCk7CisJc2Nhbl90aW1lX3Jvd3MgPSAoS0JDX1JPV19TQ0FOX1RJTUUgKyBkZWJvdW5jZV9jbnQpICogbnVtX3Jvd3M7CisJa2JjLT5yZXBvbGxfZGx5ID0gS0JDX1JPV19TQ0FOX0RMWSArIHNjYW5fdGltZV9yb3dzICsgcGRhdGEtPnJlcGVhdF9jbnQ7CisJa2JjLT5yZXBvbGxfZGx5ID0gKChrYmMtPnJlcG9sbF9kbHkgKiBLQkNfQ1lDTEVfVVNFQykgKyA5OTkpIC8gMTAwMDsKKworCWlucHV0X2Rldi0+bmFtZSA9IHBkZXYtPm5hbWU7CisJaW5wdXRfZGV2LT5pZC5idXN0eXBlID0gQlVTX0hPU1Q7CisJaW5wdXRfZGV2LT5kZXYucGFyZW50ID0gJnBkZXYtPmRldjsKKwlpbnB1dF9kZXYtPm9wZW4gPSB0ZWdyYV9rYmNfb3BlbjsKKwlpbnB1dF9kZXYtPmNsb3NlID0gdGVncmFfa2JjX2Nsb3NlOworCisJaW5wdXRfc2V0X2RydmRhdGEoaW5wdXRfZGV2LCBrYmMpOworCisJaW5wdXRfZGV2LT5ldmJpdFswXSA9IEJJVF9NQVNLKEVWX0tFWSk7CisJaW5wdXRfc2V0X2NhcGFiaWxpdHkoaW5wdXRfZGV2LCBFVl9NU0MsIE1TQ19TQ0FOKTsKKworCWlucHV0X2Rldi0+a2V5Y29kZSA9IGtiYy0+a2V5Y29kZTsKKwlpbnB1dF9kZXYtPmtleWNvZGVzaXplID0gc2l6ZW9mKGtiYy0+a2V5Y29kZVswXSk7CisJaW5wdXRfZGV2LT5rZXljb2RlbWF4ID0gQVJSQVlfU0laRShrYmMtPmtleWNvZGUpOworCisJa2V5bWFwX2RhdGEgPSBwZGF0YS0+a2V5bWFwX2RhdGEgPzogJnRlZ3JhX2tiY19kZWZhdWx0X2tleW1hcF9kYXRhOworCW1hdHJpeF9rZXlwYWRfYnVpbGRfa2V5bWFwKGtleW1hcF9kYXRhLCBLQkNfUk9XX1NISUZULAorCQkJCSAgIGlucHV0X2Rldi0+a2V5Y29kZSwgaW5wdXRfZGV2LT5rZXliaXQpOworCisJZXJyID0gcmVxdWVzdF9pcnEoa2JjLT5pcnEsIHRlZ3JhX2tiY19pc3IsIElSUUZfVFJJR0dFUl9ISUdILAorCQkJICBwZGV2LT5uYW1lLCBrYmMpOworCWlmIChlcnIpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIHJlcXVlc3Qga2V5Ym9hcmQgSVJRXG4iKTsKKwkJZ290byBlcnJfcHV0X2NsazsKKwl9CisKKwlkaXNhYmxlX2lycShrYmMtPmlycSk7CisKKwllcnIgPSBpbnB1dF9yZWdpc3Rlcl9kZXZpY2Uoa2JjLT5pZGV2KTsKKwlpZiAoZXJyKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgImZhaWxlZCB0byByZWdpc3RlciBpbnB1dCBkZXZpY2VcbiIpOworCQlnb3RvIGVycl9mcmVlX2lycTsKKwl9CisKKwlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBrYmMpOworCWRldmljZV9pbml0X3dha2V1cCgmcGRldi0+ZGV2LCBwZGF0YS0+d2FrZXVwKTsKKworCXJldHVybiAwOworCitlcnJfZnJlZV9pcnE6CisJZnJlZV9pcnEoa2JjLT5pcnEsIHBkZXYpOworZXJyX3B1dF9jbGs6CisJY2xrX3B1dChrYmMtPmNsayk7CitlcnJfaW91bm1hcDoKKwlpb3VubWFwKGtiYy0+bW1pbyk7CitlcnJfZnJlZV9tZW1fcmVnaW9uOgorCXJlbGVhc2VfbWVtX3JlZ2lvbihyZXMtPnN0YXJ0LCByZXNvdXJjZV9zaXplKHJlcykpOworZXJyX2ZyZWVfbWVtOgorCWlucHV0X2ZyZWVfZGV2aWNlKGtiYy0+aWRldik7CisJa2ZyZWUoa2JjKTsKKworCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyBpbnQgX19kZXZleGl0IHRlZ3JhX2tiY19yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlzdHJ1Y3QgdGVncmFfa2JjICprYmMgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKKworCWZyZWVfaXJxKGtiYy0+aXJxLCBwZGV2KTsKKwljbGtfcHV0KGtiYy0+Y2xrKTsKKworCWlucHV0X3VucmVnaXN0ZXJfZGV2aWNlKGtiYy0+aWRldik7CisJaW91bm1hcChrYmMtPm1taW8pOworCXJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNFX01FTSwgMCk7CisJcmVsZWFzZV9tZW1fcmVnaW9uKHJlcy0+c3RhcnQsIHJlc291cmNlX3NpemUocmVzKSk7CisKKwlrZnJlZShrYmMpOworCisJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgTlVMTCk7CisKKwlyZXR1cm4gMDsKK30KKworI2lmZGVmIENPTkZJR19QTV9TTEVFUAorc3RhdGljIGludCB0ZWdyYV9rYmNfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiA9IHRvX3BsYXRmb3JtX2RldmljZShkZXYpOworCXN0cnVjdCB0ZWdyYV9rYmMgKmtiYyA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOworCisJaWYgKGRldmljZV9tYXlfd2FrZXVwKCZwZGV2LT5kZXYpKSB7CisJCXRlZ3JhX2tiY19zZXR1cF93YWtla2V5cyhrYmMsIHRydWUpOworCQllbmFibGVfaXJxX3dha2Uoa2JjLT5pcnEpOworCQkvKiBGb3JjZWZ1bGx5IGNsZWFyIHRoZSBpbnRlcnJ1cHQgc3RhdHVzICovCisJCXdyaXRlbCgweDcsIGtiYy0+bW1pbyArIEtCQ19JTlRfMCk7CisJCW1zbGVlcCgzMCk7CisJfSBlbHNlIHsKKwkJbXV0ZXhfbG9jaygma2JjLT5pZGV2LT5tdXRleCk7CisJCWlmIChrYmMtPmlkZXYtPnVzZXJzKQorCQkJdGVncmFfa2JjX3N0b3Aoa2JjKTsKKwkJbXV0ZXhfdW5sb2NrKCZrYmMtPmlkZXYtPm11dGV4KTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCB0ZWdyYV9rYmNfcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2ID0gdG9fcGxhdGZvcm1fZGV2aWNlKGRldik7CisJc3RydWN0IHRlZ3JhX2tiYyAqa2JjID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7CisJaW50IGVyciA9IDA7CisKKwlpZiAoZGV2aWNlX21heV93YWtldXAoJnBkZXYtPmRldikpIHsKKwkJZGlzYWJsZV9pcnFfd2FrZShrYmMtPmlycSk7CisJCXRlZ3JhX2tiY19zZXR1cF93YWtla2V5cyhrYmMsIGZhbHNlKTsKKwl9IGVsc2UgeworCQltdXRleF9sb2NrKCZrYmMtPmlkZXYtPm11dGV4KTsKKwkJaWYgKGtiYy0+aWRldi0+dXNlcnMpCisJCQllcnIgPSB0ZWdyYV9rYmNfc3RhcnQoa2JjKTsKKwkJbXV0ZXhfdW5sb2NrKCZrYmMtPmlkZXYtPm11dGV4KTsKKwl9CisKKwlyZXR1cm4gZXJyOworfQorI2VuZGlmCisKK3N0YXRpYyBTSU1QTEVfREVWX1BNX09QUyh0ZWdyYV9rYmNfcG1fb3BzLCB0ZWdyYV9rYmNfc3VzcGVuZCwgdGVncmFfa2JjX3Jlc3VtZSk7CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIHRlZ3JhX2tiY19kcml2ZXIgPSB7CisJLnByb2JlCQk9IHRlZ3JhX2tiY19wcm9iZSwKKwkucmVtb3ZlCQk9IF9fZGV2ZXhpdF9wKHRlZ3JhX2tiY19yZW1vdmUpLAorCS5kcml2ZXIJPSB7CisJCS5uYW1lCT0gInRlZ3JhLWtiYyIsCisJCS5vd25lciAgPSBUSElTX01PRFVMRSwKKwkJLnBtCT0gJnRlZ3JhX2tiY19wbV9vcHMsCisJfSwKK307CisKK3N0YXRpYyB2b2lkIF9fZXhpdCB0ZWdyYV9rYmNfZXhpdCh2b2lkKQoreworCXBsYXRmb3JtX2RyaXZlcl91bnJlZ2lzdGVyKCZ0ZWdyYV9rYmNfZHJpdmVyKTsKK30KK21vZHVsZV9leGl0KHRlZ3JhX2tiY19leGl0KTsKKworc3RhdGljIGludCBfX2luaXQgdGVncmFfa2JjX2luaXQodm9pZCkKK3sKKwlyZXR1cm4gcGxhdGZvcm1fZHJpdmVyX3JlZ2lzdGVyKCZ0ZWdyYV9rYmNfZHJpdmVyKTsKK30KK21vZHVsZV9pbml0KHRlZ3JhX2tiY19pbml0KTsKKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FVVEhPUigiUmFrZXNoIEl5ZXIgPHJpeWVyQG52aWRpYS5jb20+Iik7CitNT0RVTEVfREVTQ1JJUFRJT04oIlRlZ3JhIG1hdHJpeCBrZXlib2FyZCBjb250cm9sbGVyIGRyaXZlciIpOworTU9EVUxFX0FMSUFTKCJwbGF0Zm9ybTp0ZWdyYS1rYmMiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvdG5ldHYxMDd4LWtleXBhZC5jIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC90bmV0djEwN3gta2V5cGFkLmMKaW5kZXggYjRhODFlYi4uYzhmMDk3YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC9rZXlib2FyZC90bmV0djEwN3gta2V5cGFkLmMKKysrIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC90bmV0djEwN3gta2V5cGFkLmMKQEAgLTE0LDYgKzE0LDcgQEAKICAqLwogCiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvZXJyLmg+CiAjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KICNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgogI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgpAQCAtMjE5LDkgKzIyMCw5IEBACiAJfQogCiAJa3AtPmNsayA9IGNsa19nZXQoZGV2LCBOVUxMKTsKLQlpZiAoIWtwLT5jbGspIHsKKwlpZiAoSVNfRVJSKGtwLT5jbGspKSB7CiAJCWRldl9lcnIoZGV2LCAiY2Fubm90IGNsYWltIGRldmljZSBjbG9ja1xuIik7Ci0JCWVycm9yID0gLUVJTlZBTDsKKwkJZXJyb3IgPSBQVFJfRVJSKGtwLT5jbGspOwogCQlnb3RvIGVycm9yX2NsazsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvbWlzYy9peHA0eHgtYmVlcGVyLmMgYi9kcml2ZXJzL2lucHV0L21pc2MvaXhwNHh4LWJlZXBlci5jCmluZGV4IDlkZmQ2ZTUuLjFmMzgzMDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvbWlzYy9peHA0eHgtYmVlcGVyLmMKKysrIGIvZHJpdmVycy9pbnB1dC9taXNjL2l4cDR4eC1iZWVwZXIuYwpAQCAtNjksMTEgKzY5LDcgQEAKIAl9CiAKIAlpZiAodmFsdWUgPiAyMCAmJiB2YWx1ZSA8IDMyNzY3KQotI2lmbmRlZiBGUkVRCi0JCWNvdW50ID0gKGl4cDR4eF9nZXRfYm9hcmRfdGlja19yYXRlKCkgLyAodmFsdWUgKiA0KSkgLSAxOwotI2Vsc2UKLQkJY291bnQgPSAoRlJFUSAvICh2YWx1ZSAqIDQpKSAtIDE7Ci0jZW5kaWYKKwkJY291bnQgPSAoSVhQNFhYX1RJTUVSX0ZSRVEgLyAodmFsdWUgKiA0KSkgLSAxOwogCiAJaXhwNHh4X3Nwa3JfY29udHJvbChwaW4sIGNvdW50KTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9tb3VzZS9LY29uZmlnIGIvZHJpdmVycy9pbnB1dC9tb3VzZS9LY29uZmlnCmluZGV4IGJmNWZkN2YuLjljMWU2ZWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvbW91c2UvS2NvbmZpZworKysgYi9kcml2ZXJzL2lucHV0L21vdXNlL0tjb25maWcKQEAgLTM5LDcgKzM5LDcgQEAKIAkgIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCBwc21vdXNlLgogCiBjb25maWcgTU9VU0VfUFMyX0FMUFMKLQlib29sICJBTFBTIFBTLzIgbW91c2UgcHJvdG9jb2wgZXh0ZW5zaW9uIiBpZiBFTUJFRERFRAorCWJvb2wgIkFMUFMgUFMvMiBtb3VzZSBwcm90b2NvbCBleHRlbnNpb24iIGlmIEVYUEVSVAogCWRlZmF1bHQgeQogCWRlcGVuZHMgb24gTU9VU0VfUFMyCiAJaGVscApAQCAtNDksNyArNDksNyBAQAogCSAgSWYgdW5zdXJlLCBzYXkgWS4KIAogY29uZmlnIE1PVVNFX1BTMl9MT0dJUFMyUFAKLQlib29sICJMb2dpdGVjaCBQUy8yKysgbW91c2UgcHJvdG9jb2wgZXh0ZW5zaW9uIiBpZiBFTUJFRERFRAorCWJvb2wgIkxvZ2l0ZWNoIFBTLzIrKyBtb3VzZSBwcm90b2NvbCBleHRlbnNpb24iIGlmIEVYUEVSVAogCWRlZmF1bHQgeQogCWRlcGVuZHMgb24gTU9VU0VfUFMyCiAJaGVscApAQCAtNTksNyArNTksNyBAQAogCSAgSWYgdW5zdXJlLCBzYXkgWS4KIAogY29uZmlnIE1PVVNFX1BTMl9TWU5BUFRJQ1MKLQlib29sICJTeW5hcHRpY3MgUFMvMiBtb3VzZSBwcm90b2NvbCBleHRlbnNpb24iIGlmIEVNQkVEREVECisJYm9vbCAiU3luYXB0aWNzIFBTLzIgbW91c2UgcHJvdG9jb2wgZXh0ZW5zaW9uIiBpZiBFWFBFUlQKIAlkZWZhdWx0IHkKIAlkZXBlbmRzIG9uIE1PVVNFX1BTMgogCWhlbHAKQEAgLTY5LDcgKzY5LDcgQEAKIAkgIElmIHVuc3VyZSwgc2F5IFkuCiAKIGNvbmZpZyBNT1VTRV9QUzJfTElGRUJPT0sKLQlib29sICJGdWppdHN1IExpZmVib29rIFBTLzIgbW91c2UgcHJvdG9jb2wgZXh0ZW5zaW9uIiBpZiBFTUJFRERFRAorCWJvb2wgIkZ1aml0c3UgTGlmZWJvb2sgUFMvMiBtb3VzZSBwcm90b2NvbCBleHRlbnNpb24iIGlmIEVYUEVSVAogCWRlZmF1bHQgeQogCWRlcGVuZHMgb24gTU9VU0VfUFMyICYmIFg4NiAmJiBETUkKIAloZWxwCkBAIC03OSw3ICs3OSw3IEBACiAJICBJZiB1bnN1cmUsIHNheSBZLgogCiBjb25maWcgTU9VU0VfUFMyX1RSQUNLUE9JTlQKLQlib29sICJJQk0gVHJhY2twb2ludCBQUy8yIG1vdXNlIHByb3RvY29sIGV4dGVuc2lvbiIgaWYgRU1CRURERUQKKwlib29sICJJQk0gVHJhY2twb2ludCBQUy8yIG1vdXNlIHByb3RvY29sIGV4dGVuc2lvbiIgaWYgRVhQRVJUCiAJZGVmYXVsdCB5CiAJZGVwZW5kcyBvbiBNT1VTRV9QUzIKIAloZWxwCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L21vdXNlL3N5bmFwdGljcy5jIGIvZHJpdmVycy9pbnB1dC9tb3VzZS9zeW5hcHRpY3MuYwppbmRleCBkYTM5MmMyLi5hYTE4NmNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L21vdXNlL3N5bmFwdGljcy5jCisrKyBiL2RyaXZlcnMvaW5wdXQvbW91c2Uvc3luYXB0aWNzLmMKQEAgLTc1NSwyMyArNzU1LDI2IEBACiB7CiAJc3RydWN0IHN5bmFwdGljc19kYXRhICpwcml2ID0gcHNtb3VzZS0+cHJpdmF0ZTsKIAlzdHJ1Y3Qgc3luYXB0aWNzX2RhdGEgb2xkX3ByaXYgPSAqcHJpdjsKKwlpbnQgcmV0cnkgPSAwOworCWludCBlcnJvcjsKIAotCXBzbW91c2VfcmVzZXQocHNtb3VzZSk7CisJZG8geworCQlwc21vdXNlX3Jlc2V0KHBzbW91c2UpOworCQllcnJvciA9IHN5bmFwdGljc19kZXRlY3QocHNtb3VzZSwgMCk7CisJfSB3aGlsZSAoZXJyb3IgJiYgKytyZXRyeSA8IDMpOwogCi0JaWYgKHN5bmFwdGljc19kZXRlY3QocHNtb3VzZSwgMCkpCisJaWYgKGVycm9yKQogCQlyZXR1cm4gLTE7CiAKKwlpZiAocmV0cnkgPiAxKQorCQlwcmludGsoS0VSTl9ERUJVRyAiU3luYXB0aWNzIHJlY29ubmVjdGVkIGFmdGVyICVkIHRyaWVzXG4iLAorCQkJcmV0cnkpOworCiAJaWYgKHN5bmFwdGljc19xdWVyeV9oYXJkd2FyZShwc21vdXNlKSkgewogCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBxdWVyeSBTeW5hcHRpY3MgaGFyZHdhcmUuXG4iKTsKIAkJcmV0dXJuIC0xOwogCX0KIAotCWlmIChvbGRfcHJpdi5pZGVudGl0eSAhPSBwcml2LT5pZGVudGl0eSB8fAotCSAgICBvbGRfcHJpdi5tb2RlbF9pZCAhPSBwcml2LT5tb2RlbF9pZCB8fAotCSAgICBvbGRfcHJpdi5jYXBhYmlsaXRpZXMgIT0gcHJpdi0+Y2FwYWJpbGl0aWVzIHx8Ci0JICAgIG9sZF9wcml2LmV4dF9jYXAgIT0gcHJpdi0+ZXh0X2NhcCkKLQkJcmV0dXJuIC0xOwotCiAJaWYgKHN5bmFwdGljc19zZXRfYWJzb2x1dGVfbW9kZShwc21vdXNlKSkgewogCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBpbml0aWFsaXplIFN5bmFwdGljcyBoYXJkd2FyZS5cbiIpOwogCQlyZXR1cm4gLTE7CkBAIC03ODIsNiArNzg1LDE5IEBACiAJCXJldHVybiAtMTsKIAl9CiAKKwlpZiAob2xkX3ByaXYuaWRlbnRpdHkgIT0gcHJpdi0+aWRlbnRpdHkgfHwKKwkgICAgb2xkX3ByaXYubW9kZWxfaWQgIT0gcHJpdi0+bW9kZWxfaWQgfHwKKwkgICAgb2xkX3ByaXYuY2FwYWJpbGl0aWVzICE9IHByaXYtPmNhcGFiaWxpdGllcyB8fAorCSAgICBvbGRfcHJpdi5leHRfY2FwICE9IHByaXYtPmV4dF9jYXApIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJTeW5hcHRpY3MgaGFyZHdhcmUgYXBwZWFycyB0byBiZSBkaWZmZXJlbnQ6ICIKKwkJCSJpZCglbGQtJWxkKSwgbW9kZWwoJWxkLSVsZCksIGNhcHMoJWx4LSVseCksIGV4dCglbHgtJWx4KS5cbiIsCisJCQlvbGRfcHJpdi5pZGVudGl0eSwgcHJpdi0+aWRlbnRpdHksCisJCQlvbGRfcHJpdi5tb2RlbF9pZCwgcHJpdi0+bW9kZWxfaWQsCisJCQlvbGRfcHJpdi5jYXBhYmlsaXRpZXMsIHByaXYtPmNhcGFiaWxpdGllcywKKwkJCW9sZF9wcml2LmV4dF9jYXAsIHByaXYtPmV4dF9jYXApOworCQlyZXR1cm4gLTE7CisJfQorCiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvc2VyaW8vS2NvbmZpZyBiL2RyaXZlcnMvaW5wdXQvc2VyaW8vS2NvbmZpZwppbmRleCAzMDdlZWY3Li41NWYyYzIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L3NlcmlvL0tjb25maWcKKysrIGIvZHJpdmVycy9pbnB1dC9zZXJpby9LY29uZmlnCkBAIC0yLDcgKzIsNyBAQAogIyBJbnB1dCBjb3JlIGNvbmZpZ3VyYXRpb24KICMKIGNvbmZpZyBTRVJJTwotCXRyaXN0YXRlICJTZXJpYWwgSS9PIHN1cHBvcnQiIGlmIEVNQkVEREVEIHx8ICFYODYKKwl0cmlzdGF0ZSAiU2VyaWFsIEkvTyBzdXBwb3J0IiBpZiBFWFBFUlQgfHwgIVg4NgogCWRlZmF1bHQgeQogCWhlbHAKIAkgIFNheSBZZXMgaGVyZSBpZiB5b3UgaGF2ZSBhbnkgaW5wdXQgZGV2aWNlIHRoYXQgdXNlcyBzZXJpYWwgSS9PIHRvCkBAIC0xOSw3ICsxOSw3IEBACiBpZiBTRVJJTwogCiBjb25maWcgU0VSSU9fSTgwNDIKLQl0cmlzdGF0ZSAiaTgwNDIgUEMgS2V5Ym9hcmQgY29udHJvbGxlciIgaWYgRU1CRURERUQgfHwgIVg4NgorCXRyaXN0YXRlICJpODA0MiBQQyBLZXlib2FyZCBjb250cm9sbGVyIiBpZiBFWFBFUlQgfHwgIVg4NgogCWRlZmF1bHQgeQogCWRlcGVuZHMgb24gIVBBUklTQyAmJiAoIUFSTSB8fCBBUkNIX1NIQVJLIHx8IEZPT1RCUklER0VfSE9TVCkgJiYgXAogCQkgICAoIVNVUEVSSCB8fCBTSF9DQVlNQU4pICYmICFNNjhLICYmICFCTEFDS0ZJTgpAQCAtMTY4LDcgKzE2OCw3IEBACiAJICBtb2R1bGUgd2lsbCBiZSBjYWxsZWQgbWFjZXBzMi4KIAogY29uZmlnIFNFUklPX0xJQlBTMgotCXRyaXN0YXRlICJQUy8yIGRyaXZlciBsaWJyYXJ5IiBpZiBFTUJFRERFRAorCXRyaXN0YXRlICJQUy8yIGRyaXZlciBsaWJyYXJ5IiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFNFUklPX0k4MDQyIHx8IFNFUklPX0k4MDQyPW4KIAloZWxwCiAJICBTYXkgWSBoZXJlIGlmIHlvdSBhcmUgdXNpbmcgYSBkcml2ZXIgZm9yIGRldmljZSBjb25uZWN0ZWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvc2VyaW8vY3Q4MmM3MTAuYyBiL2RyaXZlcnMvaW5wdXQvc2VyaW8vY3Q4MmM3MTAuYwppbmRleCA0NDhjNzcyLi44NTI4MTY1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L3NlcmlvL2N0ODJjNzEwLmMKKysrIGIvZHJpdmVycy9pbnB1dC9zZXJpby9jdDgyYzcxMC5jCkBAIC0xMTEsOSArMTExLDExIEBACiBzdGF0aWMgaW50IGN0ODJjNzEwX29wZW4oc3RydWN0IHNlcmlvICpzZXJpbykKIHsKIAl1bnNpZ25lZCBjaGFyIHN0YXR1czsKKwlpbnQgZXJyOwogCi0JaWYgKHJlcXVlc3RfaXJxKENUODJDNzEwX0lSUSwgY3Q4MmM3MTBfaW50ZXJydXB0LCAwLCAiY3Q4MmM3MTAiLCBOVUxMKSkKLQkJcmV0dXJuIC0xOworCWVyciA9IHJlcXVlc3RfaXJxKENUODJDNzEwX0lSUSwgY3Q4MmM3MTBfaW50ZXJydXB0LCAwLCAiY3Q4MmM3MTAiLCBOVUxMKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOwogCiAJc3RhdHVzID0gaW5iX3AoQ1Q4MkM3MTBfU1RBVFVTKTsKIApAQCAtMTMxLDcgKzEzMyw3IEBACiAJCXN0YXR1cyAmPSB+KENUODJDNzEwX0VOQUJMRSB8IENUODJDNzEwX0lOVFNfT04pOwogCQlvdXRiX3Aoc3RhdHVzLCBDVDgyQzcxMF9TVEFUVVMpOwogCQlmcmVlX2lycShDVDgyQzcxMF9JUlEsIE5VTEwpOwotCQlyZXR1cm4gLTE7CisJCXJldHVybiAtRUJVU1k7CiAJfQogCiAJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L3NlcmlvL3NlcnBvcnQuYyBiL2RyaXZlcnMvaW5wdXQvc2VyaW8vc2VycG9ydC5jCmluZGV4IDZlMzYyZGUuLjg3NTVmNWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvc2VyaW8vc2VycG9ydC5jCisrKyBiL2RyaXZlcnMvaW5wdXQvc2VyaW8vc2VycG9ydC5jCkBAIC0xMTYsMTQgKzExNiwxNSBAQAogCiAvKgogICogc2VycG9ydF9sZGlzY19yZWNlaXZlKCkgaXMgY2FsbGVkIGJ5IHRoZSBsb3cgbGV2ZWwgdHR5IGRyaXZlciB3aGVuIGNoYXJhY3RlcnMKLSAqIGFyZSByZWFkeSBmb3IgdXMuIFdlIGZvcndhcmQgdGhlIGNoYXJhY3RlcnMsIG9uZSBieSBvbmUgdG8gdGhlICdpbnRlcnJ1cHQnCi0gKiByb3V0aW5lLgorICogYXJlIHJlYWR5IGZvciB1cy4gV2UgZm9yd2FyZCB0aGUgY2hhcmFjdGVycyBhbmQgZmxhZ3MsIG9uZSBieSBvbmUgdG8gdGhlCisgKiAnaW50ZXJydXB0JyByb3V0aW5lLgogICovCiAKIHN0YXRpYyB2b2lkIHNlcnBvcnRfbGRpc2NfcmVjZWl2ZShzdHJ1Y3QgdHR5X3N0cnVjdCAqdHR5LCBjb25zdCB1bnNpZ25lZCBjaGFyICpjcCwgY2hhciAqZnAsIGludCBjb3VudCkKIHsKIAlzdHJ1Y3Qgc2VycG9ydCAqc2VycG9ydCA9IChzdHJ1Y3Qgc2VycG9ydCopIHR0eS0+ZGlzY19kYXRhOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJdW5zaWduZWQgaW50IGNoX2ZsYWdzOwogCWludCBpOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJnNlcnBvcnQtPmxvY2ssIGZsYWdzKTsKQEAgLTEzMSw4ICsxMzIsMjMgQEAKIAlpZiAoIXRlc3RfYml0KFNFUlBPUlRfQUNUSVZFLCAmc2VycG9ydC0+ZmxhZ3MpKQogCQlnb3RvIG91dDsKIAotCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsrKQotCQlzZXJpb19pbnRlcnJ1cHQoc2VycG9ydC0+c2VyaW8sIGNwW2ldLCAwKTsKKwlmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykgeworCQlzd2l0Y2ggKGZwW2ldKSB7CisJCWNhc2UgVFRZX0ZSQU1FOgorCQkJY2hfZmxhZ3MgPSBTRVJJT19GUkFNRTsKKwkJCWJyZWFrOworCisJCWNhc2UgVFRZX1BBUklUWToKKwkJCWNoX2ZsYWdzID0gU0VSSU9fUEFSSVRZOworCQkJYnJlYWs7CisKKwkJZGVmYXVsdDoKKwkJCWNoX2ZsYWdzID0gMDsKKwkJCWJyZWFrOworCQl9CisKKwkJc2VyaW9faW50ZXJydXB0KHNlcnBvcnQtPnNlcmlvLCBjcFtpXSwgY2hfZmxhZ3MpOworCX0KIAogb3V0OgogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNlcnBvcnQtPmxvY2ssIGZsYWdzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvc3BhcnNlLWtleW1hcC5jIGIvZHJpdmVycy9pbnB1dC9zcGFyc2Uta2V5bWFwLmMKaW5kZXggYTI5YTc4MTIuLjc3MjllNTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvc3BhcnNlLWtleW1hcC5jCisrKyBiL2RyaXZlcnMvaW5wdXQvc3BhcnNlLWtleW1hcC5jCkBAIC0yMDEsNiArMjAxLDcgQEAKIAkJCWJyZWFrOwogCiAJCWNhc2UgS0VfU1c6CisJCWNhc2UgS0VfVlNXOgogCQkJX19zZXRfYml0KEVWX1NXLCBkZXYtPmV2Yml0KTsKIAkJCV9fc2V0X2JpdChlbnRyeS0+c3cuY29kZSwgZGV2LT5zd2JpdCk7CiAJCQlicmVhazsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvdGFibGV0L3dhY29tX3dhYy5jIGIvZHJpdmVycy9pbnB1dC90YWJsZXQvd2Fjb21fd2FjLmMKaW5kZXggNTE4NzgyOS4uMzY3ZmE4MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC90YWJsZXQvd2Fjb21fd2FjLmMKKysrIGIvZHJpdmVycy9pbnB1dC90YWJsZXQvd2Fjb21fd2FjLmMKQEAgLTExMDEsNiArMTEwMSwxMyBAQAogCX0KIH0KIAorc3RhdGljIHVuc2lnbmVkIGludCB3YWNvbV9jYWxjdWxhdGVfdG91Y2hfcmVzKHVuc2lnbmVkIGludCBsb2dpY2FsX21heCwKKwkJCQkJICAgICAgdW5zaWduZWQgaW50IHBoeXNpY2FsX21heCkKK3sKKyAgICAgICAvKiBUb3VjaCBwaHlzaWNhbCBkaW1lbnNpb25zIGFyZSBpbiAxMDB0aCBvZiBtbSAqLworICAgICAgIHJldHVybiAobG9naWNhbF9tYXggKiAxMDApIC8gcGh5c2ljYWxfbWF4OworfQorCiB2b2lkIHdhY29tX3NldHVwX2lucHV0X2NhcGFiaWxpdGllcyhzdHJ1Y3QgaW5wdXRfZGV2ICppbnB1dF9kZXYsCiAJCQkJICAgIHN0cnVjdCB3YWNvbV93YWMgKndhY29tX3dhYykKIHsKQEAgLTEyMjgsOCArMTIzNSwxMiBAQAogCWNhc2UgVEFCTEVUUEM6CiAJCWlmIChmZWF0dXJlcy0+ZGV2aWNlX3R5cGUgPT0gQlROX1RPT0xfRE9VQkxFVEFQIHx8CiAJCSAgICBmZWF0dXJlcy0+ZGV2aWNlX3R5cGUgPT0gQlROX1RPT0xfVFJJUExFVEFQKSB7Ci0JCQlpbnB1dF9zZXRfYWJzX3BhcmFtcyhpbnB1dF9kZXYsIEFCU19SWCwgMCwgZmVhdHVyZXMtPnhfcGh5LCAwLCAwKTsKLQkJCWlucHV0X3NldF9hYnNfcGFyYW1zKGlucHV0X2RldiwgQUJTX1JZLCAwLCBmZWF0dXJlcy0+eV9waHksIDAsIDApOworCQkJaW5wdXRfYWJzX3NldF9yZXMoaW5wdXRfZGV2LCBBQlNfWCwKKwkJCQl3YWNvbV9jYWxjdWxhdGVfdG91Y2hfcmVzKGZlYXR1cmVzLT54X21heCwKKwkJCQkJCQlmZWF0dXJlcy0+eF9waHkpKTsKKwkJCWlucHV0X2Fic19zZXRfcmVzKGlucHV0X2RldiwgQUJTX1ksCisJCQkJd2Fjb21fY2FsY3VsYXRlX3RvdWNoX3JlcyhmZWF0dXJlcy0+eV9tYXgsCisJCQkJCQkJZmVhdHVyZXMtPnlfcGh5KSk7CiAJCQlfX3NldF9iaXQoQlROX1RPT0xfRE9VQkxFVEFQLCBpbnB1dF9kZXYtPmtleWJpdCk7CiAJCX0KIApAQCAtMTI3Miw2ICsxMjgzLDEyIEBACiAJCQlpbnB1dF9zZXRfYWJzX3BhcmFtcyhpbnB1dF9kZXYsIEFCU19NVF9QUkVTU1VSRSwKIAkJCQkJICAgICAwLCBmZWF0dXJlcy0+cHJlc3N1cmVfbWF4LAogCQkJCQkgICAgIGZlYXR1cmVzLT5wcmVzc3VyZV9mdXp6LCAwKTsKKwkJCWlucHV0X2Fic19zZXRfcmVzKGlucHV0X2RldiwgQUJTX1gsCisJCQkJd2Fjb21fY2FsY3VsYXRlX3RvdWNoX3JlcyhmZWF0dXJlcy0+eF9tYXgsCisJCQkJCQkJZmVhdHVyZXMtPnhfcGh5KSk7CisJCQlpbnB1dF9hYnNfc2V0X3JlcyhpbnB1dF9kZXYsIEFCU19ZLAorCQkJCXdhY29tX2NhbGN1bGF0ZV90b3VjaF9yZXMoZmVhdHVyZXMtPnlfbWF4LAorCQkJCQkJCWZlYXR1cmVzLT55X3BoeSkpOwogCQl9IGVsc2UgaWYgKGZlYXR1cmVzLT5kZXZpY2VfdHlwZSA9PSBCVE5fVE9PTF9QRU4pIHsKIAkJCV9fc2V0X2JpdChCVE5fVE9PTF9SVUJCRVIsIGlucHV0X2Rldi0+a2V5Yml0KTsKIAkJCV9fc2V0X2JpdChCVE5fVE9PTF9QRU4sIGlucHV0X2Rldi0+a2V5Yml0KTsKQEAgLTE0MjYsNiArMTQ0MywxMCBAQAogCXsgIldhY29tIEJhbWJvbyAyRkcgNng4IiwgV0FDT01fUEtHTEVOX0JCRlVOLCAgICAgMjE2NDgsIDEzNTMwLCAxMDIzLCA2MywgQkFNQk9PX1BUIH07CiBzdGF0aWMgY29uc3Qgc3RydWN0IHdhY29tX2ZlYXR1cmVzIHdhY29tX2ZlYXR1cmVzXzB4RDQgPQogCXsgIldhY29tIEJhbWJvbyBQZW4iLCAgICAgV0FDT01fUEtHTEVOX0JCRlVOLCAgICAgMTQ3MjAsICA5MjAwLCAgMjU1LCA2MywgQkFNQk9PX1BUIH07CitzdGF0aWMgc3RydWN0IHdhY29tX2ZlYXR1cmVzIHdhY29tX2ZlYXR1cmVzXzB4RDYgPQorCXsgIldhY29tIEJhbWJvb1BUIDJGRyA0eDUiLCBXQUNPTV9QS0dMRU5fQkJGVU4sICAgMTQ3MjAsICA5MjAwLCAxMDIzLCA2MywgQkFNQk9PX1BUIH07CitzdGF0aWMgc3RydWN0IHdhY29tX2ZlYXR1cmVzIHdhY29tX2ZlYXR1cmVzXzB4RDcgPQorCXsgIldhY29tIEJhbWJvb1BUIDJGRyBTbWFsbCIsIFdBQ09NX1BLR0xFTl9CQkZVTiwgMTQ3MjAsICA5MjAwLCAxMDIzLCA2MywgQkFNQk9PX1BUIH07CiBzdGF0aWMgc3RydWN0IHdhY29tX2ZlYXR1cmVzIHdhY29tX2ZlYXR1cmVzXzB4RDggPQogCXsgIldhY29tIEJhbWJvbyBDb21pYyAyRkciLCBXQUNPTV9QS0dMRU5fQkJGVU4sICAgMjE2NDgsIDEzNTMwLCAxMDIzLCA2MywgQkFNQk9PX1BUIH07CiBzdGF0aWMgc3RydWN0IHdhY29tX2ZlYXR1cmVzIHdhY29tX2ZlYXR1cmVzXzB4REEgPQpAQCAtMTUwNyw2ICsxNTI4LDggQEAKIAl7IFVTQl9ERVZJQ0VfV0FDT00oMHhEMikgfSwKIAl7IFVTQl9ERVZJQ0VfV0FDT00oMHhEMykgfSwKIAl7IFVTQl9ERVZJQ0VfV0FDT00oMHhENCkgfSwKKwl7IFVTQl9ERVZJQ0VfV0FDT00oMHhENikgfSwKKwl7IFVTQl9ERVZJQ0VfV0FDT00oMHhENykgfSwKIAl7IFVTQl9ERVZJQ0VfV0FDT00oMHhEOCkgfSwKIAl7IFVTQl9ERVZJQ0VfV0FDT00oMHhEQSkgfSwKIAl7IFVTQl9ERVZJQ0VfV0FDT00oMHhEQikgfSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vS2NvbmZpZyBiL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vS2NvbmZpZwppbmRleCAwYzlmNGIxLi42MTgzNGFlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L3RvdWNoc2NyZWVuL0tjb25maWcKKysrIGIvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi9LY29uZmlnCkBAIC01NDAsNjIgKzU0MCw2MiBAQAogCiBjb25maWcgVE9VQ0hTQ1JFRU5fVVNCX0VHQUxBWAogCWRlZmF1bHQgeQotCWJvb2wgImVHYWxheCwgZVR1cmJvVG91Y2ggQ1QtNDEwLzUxMC83MDAgZGV2aWNlIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiZUdhbGF4LCBlVHVyYm9Ub3VjaCBDVC00MTAvNTEwLzcwMCBkZXZpY2Ugc3VwcG9ydCIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBUT1VDSFNDUkVFTl9VU0JfQ09NUE9TSVRFCiAKIGNvbmZpZyBUT1VDSFNDUkVFTl9VU0JfUEFOSklUCiAJZGVmYXVsdCB5Ci0JYm9vbCAiUGFuSml0IGRldmljZSBzdXBwb3J0IiBpZiBFTUJFRERFRAorCWJvb2wgIlBhbkppdCBkZXZpY2Ugc3VwcG9ydCIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBUT1VDSFNDUkVFTl9VU0JfQ09NUE9TSVRFCiAKIGNvbmZpZyBUT1VDSFNDUkVFTl9VU0JfM00KIAlkZWZhdWx0IHkKLQlib29sICIzTS9NaWNyb3RvdWNoIEVYIElJIHNlcmllcyBkZXZpY2Ugc3VwcG9ydCIgaWYgRU1CRURERUQKKwlib29sICIzTS9NaWNyb3RvdWNoIEVYIElJIHNlcmllcyBkZXZpY2Ugc3VwcG9ydCIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBUT1VDSFNDUkVFTl9VU0JfQ09NUE9TSVRFCiAKIGNvbmZpZyBUT1VDSFNDUkVFTl9VU0JfSVRNCiAJZGVmYXVsdCB5Ci0JYm9vbCAiSVRNIGRldmljZSBzdXBwb3J0IiBpZiBFTUJFRERFRAorCWJvb2wgIklUTSBkZXZpY2Ugc3VwcG9ydCIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBUT1VDSFNDUkVFTl9VU0JfQ09NUE9TSVRFCiAKIGNvbmZpZyBUT1VDSFNDUkVFTl9VU0JfRVRVUkJPCiAJZGVmYXVsdCB5Ci0JYm9vbCAiZVR1cmJvVG91Y2ggKG5vbi1lR2FsYXggY29tcGF0aWJsZSkgZGV2aWNlIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiZVR1cmJvVG91Y2ggKG5vbi1lR2FsYXggY29tcGF0aWJsZSkgZGV2aWNlIHN1cHBvcnQiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gVE9VQ0hTQ1JFRU5fVVNCX0NPTVBPU0lURQogCiBjb25maWcgVE9VQ0hTQ1JFRU5fVVNCX0dVTlpFCiAJZGVmYXVsdCB5Ci0JYm9vbCAiR3VuemUgQUhMNjEgZGV2aWNlIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiR3VuemUgQUhMNjEgZGV2aWNlIHN1cHBvcnQiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gVE9VQ0hTQ1JFRU5fVVNCX0NPTVBPU0lURQogCiBjb25maWcgVE9VQ0hTQ1JFRU5fVVNCX0RNQ19UU0MxMAogCWRlZmF1bHQgeQotCWJvb2wgIkRNQyBUU0MtMTAvMjUgZGV2aWNlIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiRE1DIFRTQy0xMC8yNSBkZXZpY2Ugc3VwcG9ydCIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBUT1VDSFNDUkVFTl9VU0JfQ09NUE9TSVRFCiAKIGNvbmZpZyBUT1VDSFNDUkVFTl9VU0JfSVJUT1VDSAogCWRlZmF1bHQgeQotCWJvb2wgIklSVE9VQ0hTWVNURU1TL1VOSVRPUCBkZXZpY2Ugc3VwcG9ydCIgaWYgRU1CRURERUQKKwlib29sICJJUlRPVUNIU1lTVEVNUy9VTklUT1AgZGV2aWNlIHN1cHBvcnQiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gVE9VQ0hTQ1JFRU5fVVNCX0NPTVBPU0lURQogCiBjb25maWcgVE9VQ0hTQ1JFRU5fVVNCX0lERUFMVEVLCiAJZGVmYXVsdCB5Ci0JYm9vbCAiSWRlYWxURUsgVVJUQzEwMDAgZGV2aWNlIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiSWRlYWxURUsgVVJUQzEwMDAgZGV2aWNlIHN1cHBvcnQiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gVE9VQ0hTQ1JFRU5fVVNCX0NPTVBPU0lURQogCiBjb25maWcgVE9VQ0hTQ1JFRU5fVVNCX0dFTkVSQUxfVE9VQ0gKIAlkZWZhdWx0IHkKLQlib29sICJHZW5lcmFsVG91Y2ggVG91Y2hzY3JlZW4gZGV2aWNlIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiR2VuZXJhbFRvdWNoIFRvdWNoc2NyZWVuIGRldmljZSBzdXBwb3J0IiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFRPVUNIU0NSRUVOX1VTQl9DT01QT1NJVEUKIAogY29uZmlnIFRPVUNIU0NSRUVOX1VTQl9HT1RPUAogCWRlZmF1bHQgeQotCWJvb2wgIkdvVG9wIFN1cGVyX1EyL0dvZ29QZW4vUGVuUG93ZXIgdGFibGV0IGRldmljZSBzdXBwb3J0IiBpZiBFTUJFRERFRAorCWJvb2wgIkdvVG9wIFN1cGVyX1EyL0dvZ29QZW4vUGVuUG93ZXIgdGFibGV0IGRldmljZSBzdXBwb3J0IiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFRPVUNIU0NSRUVOX1VTQl9DT01QT1NJVEUKIAogY29uZmlnIFRPVUNIU0NSRUVOX1VTQl9KQVNURUMKIAlkZWZhdWx0IHkKLQlib29sICJKQVNURUMvRGlnaVRlY2ggRFRSLTAyVSBVU0IgdG91Y2ggY29udHJvbGxlciBkZXZpY2Ugc3VwcG9ydCIgaWYgRU1CRURERUQKKwlib29sICJKQVNURUMvRGlnaVRlY2ggRFRSLTAyVSBVU0IgdG91Y2ggY29udHJvbGxlciBkZXZpY2Ugc3VwcG9ydCIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBUT1VDSFNDUkVFTl9VU0JfQ09NUE9TSVRFCiAKIGNvbmZpZyBUT1VDSFNDUkVFTl9VU0JfRTJJCkBAIC02MDUsMTcgKzYwNSwxNyBAQAogCiBjb25maWcgVE9VQ0hTQ1JFRU5fVVNCX1pZVFJPTklDCiAJZGVmYXVsdCB5Ci0JYm9vbCAiWnl0cm9uaWMgY29udHJvbGxlciIgaWYgRU1CRURERUQKKwlib29sICJaeXRyb25pYyBjb250cm9sbGVyIiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFRPVUNIU0NSRUVOX1VTQl9DT01QT1NJVEUKIAogY29uZmlnIFRPVUNIU0NSRUVOX1VTQl9FVFRfVEM0NVVTQgogCWRlZmF1bHQgeQotCWJvb2wgIkVUJlQgVVNCIHNlcmllcyBUQzRVTS9UQzVVSCB0b3VjaHNjcmVlbiBjb250cm9sbGVyIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiRVQmVCBVU0Igc2VyaWVzIFRDNFVNL1RDNVVIIHRvdWNoc2NyZWVuIGNvbnRyb2xsZXIgc3VwcG9ydCIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBUT1VDSFNDUkVFTl9VU0JfQ09NUE9TSVRFCiAKIGNvbmZpZyBUT1VDSFNDUkVFTl9VU0JfTkVYSU8KIAlkZWZhdWx0IHkKLQlib29sICJORVhJTy9pTmV4aW8gZGV2aWNlIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiTkVYSU8vaU5leGlvIGRldmljZSBzdXBwb3J0IiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFRPVUNIU0NSRUVOX1VTQl9DT01QT1NJVEUKIAogY29uZmlnIFRPVUNIU0NSRUVOX1RPVUNISVQyMTMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vYnUyMTAxM190cy5jIGIvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi9idTIxMDEzX3RzLmMKaW5kZXggZjdmYTllZi4uMTUwN2NlMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi9idTIxMDEzX3RzLmMKKysrIGIvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi9idTIxMDEzX3RzLmMKQEAgLTEyLDYgKzEyLDcgQEAKICNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgogI2luY2x1ZGUgPGxpbnV4L2lucHV0L2J1MjEwMTMuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvcmVndWxhdG9yL2NvbnN1bWVyLmg+CiAKICNkZWZpbmUgUEVOX0RPV05fSU5UUgkwCiAjZGVmaW5lIE1BWF9GSU5HRVJTCTIKQEAgLTEzOSw2ICsxNDAsNyBAQAogICogQGNoaXA6IHBvaW50ZXIgdG8gdGhlIHRvdWNoIHBhbmVsIGNvbnRyb2xsZXIKICAqIEBpbl9kZXY6IHBvaW50ZXIgdG8gdGhlIGlucHV0IGRldmljZSBzdHJ1Y3R1cmUKICAqIEBpbnRyX3BpbjogaW50ZXJydXB0IHBpbiB2YWx1ZQorICogQHJlZ3VsYXRvcjogcG9pbnRlciB0byB0aGUgUmVndWxhdG9yIHVzZWQgZm9yIHRvdWNoIHNjcmVlbgogICoKICAqIFRvdWNoIHBhbmVsIGRldmljZSBkYXRhIHN0cnVjdHVyZQogICovCkBAIC0xNDksNiArMTUxLDcgQEAKIAljb25zdCBzdHJ1Y3QgYnUyMTAxM19wbGF0Zm9ybV9kZXZpY2UgKmNoaXA7CiAJc3RydWN0IGlucHV0X2RldiAqaW5fZGV2OwogCXVuc2lnbmVkIGludCBpbnRyX3BpbjsKKwlzdHJ1Y3QgcmVndWxhdG9yICpyZWd1bGF0b3I7CiB9OwogCiAvKioKQEAgLTQ1Niw2ICs0NTksMjAgQEAKIAlidTIxMDEzX2RhdGEtPmluX2RldiA9IGluX2RldjsKIAlidTIxMDEzX2RhdGEtPmNoaXAgPSBwZGF0YTsKIAlidTIxMDEzX2RhdGEtPmNsaWVudCA9IGNsaWVudDsKKworCWJ1MjEwMTNfZGF0YS0+cmVndWxhdG9yID0gcmVndWxhdG9yX2dldCgmY2xpZW50LT5kZXYsICJWLVRPVUNIIik7CisJaWYgKElTX0VSUihidTIxMDEzX2RhdGEtPnJlZ3VsYXRvcikpIHsKKwkJZGV2X2VycigmY2xpZW50LT5kZXYsICJyZWd1bGF0b3JfZ2V0IGZhaWxlZFxuIik7CisJCWVycm9yID0gUFRSX0VSUihidTIxMDEzX2RhdGEtPnJlZ3VsYXRvcik7CisJCWdvdG8gZXJyX2ZyZWVfbWVtOworCX0KKworCWVycm9yID0gcmVndWxhdG9yX2VuYWJsZShidTIxMDEzX2RhdGEtPnJlZ3VsYXRvcik7CisJaWYgKGVycm9yIDwgMCkgeworCQlkZXZfZXJyKCZjbGllbnQtPmRldiwgInJlZ3VsYXRvciBlbmFibGUgZmFpbGVkXG4iKTsKKwkJZ290byBlcnJfcHV0X3JlZ3VsYXRvcjsKKwl9CisKIAlidTIxMDEzX2RhdGEtPnRvdWNoX3N0b3BwZWQgPSBmYWxzZTsKIAlpbml0X3dhaXRxdWV1ZV9oZWFkKCZidTIxMDEzX2RhdGEtPndhaXQpOwogCkBAIC00NjQsNyArNDgxLDcgQEAKIAkJZXJyb3IgPSBwZGF0YS0+Y3NfZW4ocGRhdGEtPmNzX3Bpbik7CiAJCWlmIChlcnJvciA8IDApIHsKIAkJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiY2hpcCBpbml0IGZhaWxlZFxuIik7Ci0JCQlnb3RvIGVycl9mcmVlX21lbTsKKwkJCWdvdG8gZXJyX2Rpc2FibGVfcmVndWxhdG9yOwogCQl9CiAJfQogCkBAIC00ODUsOSArNTAyLDkgQEAKIAlfX3NldF9iaXQoRVZfQUJTLCBpbl9kZXYtPmV2Yml0KTsKIAogCWlucHV0X3NldF9hYnNfcGFyYW1zKGluX2RldiwgQUJTX01UX1BPU0lUSU9OX1gsIDAsCi0JCQkJCQlwZGF0YS0+eF9tYXhfcmVzLCAwLCAwKTsKKwkJCQkJCXBkYXRhLT50b3VjaF94X21heCwgMCwgMCk7CiAJaW5wdXRfc2V0X2Fic19wYXJhbXMoaW5fZGV2LCBBQlNfTVRfUE9TSVRJT05fWSwgMCwKLQkJCQkJCXBkYXRhLT55X21heF9yZXMsIDAsIDApOworCQkJCQkJcGRhdGEtPnRvdWNoX3lfbWF4LCAwLCAwKTsKIAlpbnB1dF9zZXRfZHJ2ZGF0YShpbl9kZXYsIGJ1MjEwMTNfZGF0YSk7CiAKIAllcnJvciA9IHJlcXVlc3RfdGhyZWFkZWRfaXJxKHBkYXRhLT5pcnEsIE5VTEwsIGJ1MjEwMTNfZ3Bpb19pcnEsCkBAIC01MTMsNiArNTMwLDEwIEBACiAJYnUyMTAxM19mcmVlX2lycShidTIxMDEzX2RhdGEpOwogZXJyX2NzX2Rpc2FibGU6CiAJcGRhdGEtPmNzX2RpcyhwZGF0YS0+Y3NfcGluKTsKK2Vycl9kaXNhYmxlX3JlZ3VsYXRvcjoKKwlyZWd1bGF0b3JfZGlzYWJsZShidTIxMDEzX2RhdGEtPnJlZ3VsYXRvcik7CitlcnJfcHV0X3JlZ3VsYXRvcjoKKwlyZWd1bGF0b3JfcHV0KGJ1MjEwMTNfZGF0YS0+cmVndWxhdG9yKTsKIGVycl9mcmVlX21lbToKIAlpbnB1dF9mcmVlX2RldmljZShpbl9kZXYpOwogCWtmcmVlKGJ1MjEwMTNfZGF0YSk7CkBAIC01MzUsNiArNTU2LDEwIEBACiAJYnUyMTAxM19kYXRhLT5jaGlwLT5jc19kaXMoYnUyMTAxM19kYXRhLT5jaGlwLT5jc19waW4pOwogCiAJaW5wdXRfdW5yZWdpc3Rlcl9kZXZpY2UoYnUyMTAxM19kYXRhLT5pbl9kZXYpOworCisJcmVndWxhdG9yX2Rpc2FibGUoYnUyMTAxM19kYXRhLT5yZWd1bGF0b3IpOworCXJlZ3VsYXRvcl9wdXQoYnUyMTAxM19kYXRhLT5yZWd1bGF0b3IpOworCiAJa2ZyZWUoYnUyMTAxM19kYXRhKTsKIAogCWRldmljZV9pbml0X3dha2V1cCgmY2xpZW50LT5kZXYsIGZhbHNlKTsKQEAgLTU2MSw2ICs1ODYsOCBAQAogCWVsc2UKIAkJZGlzYWJsZV9pcnEoYnUyMTAxM19kYXRhLT5jaGlwLT5pcnEpOwogCisJcmVndWxhdG9yX2Rpc2FibGUoYnUyMTAxM19kYXRhLT5yZWd1bGF0b3IpOworCiAJcmV0dXJuIDA7CiB9CiAKQEAgLTU3Nyw2ICs2MDQsMTIgQEAKIAlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50ID0gYnUyMTAxM19kYXRhLT5jbGllbnQ7CiAJaW50IHJldHZhbDsKIAorCXJldHZhbCA9IHJlZ3VsYXRvcl9lbmFibGUoYnUyMTAxM19kYXRhLT5yZWd1bGF0b3IpOworCWlmIChyZXR2YWwgPCAwKSB7CisJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiYnUyMTAxMyByZWd1bGF0b3IgZW5hYmxlIGZhaWxlZFxuIik7CisJCXJldHVybiByZXR2YWw7CisJfQorCiAJcmV0dmFsID0gYnUyMTAxM19pbml0X2NoaXAoYnUyMTAxM19kYXRhKTsKIAlpZiAocmV0dmFsIDwgMCkgewogCQlkZXZfZXJyKCZjbGllbnQtPmRldiwgImJ1MjEwMTMgY29udHJvbGxlciBjb25maWcgZmFpbGVkXG4iKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vdG5ldHYxMDd4LXRzLmMgYi9kcml2ZXJzL2lucHV0L3RvdWNoc2NyZWVuL3RuZXR2MTA3eC10cy5jCmluZGV4IGNmMWRiYTIuLjIyYTM0MTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vdG5ldHYxMDd4LXRzLmMKKysrIGIvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi90bmV0djEwN3gtdHMuYwpAQCAtMTQsNiArMTQsNyBAQAogICovCiAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KICNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgogI2luY2x1ZGUgPGxpbnV4L2lucHV0Lmg+CiAjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CkBAIC0yODksOSArMjkwLDkgQEAKIAl9CiAKIAl0cy0+Y2xrID0gY2xrX2dldChkZXYsIE5VTEwpOwotCWlmICghdHMtPmNsaykgeworCWlmIChJU19FUlIodHMtPmNsaykpIHsKIAkJZGV2X2VycihkZXYsICJjYW5ub3QgY2xhaW0gZGV2aWNlIGNsb2NrXG4iKTsKLQkJZXJyb3IgPSAtRUlOVkFMOworCQllcnJvciA9IFBUUl9FUlIodHMtPmNsayk7CiAJCWdvdG8gZXJyb3JfY2xrOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pc2RuL2h5c2RuL2h5c2RuX2RlZnMuaCBiL2RyaXZlcnMvaXNkbi9oeXNkbi9oeXNkbl9kZWZzLmgKaW5kZXggNzI5ZGY0MC4uMThiODAxYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL2h5c2RuL2h5c2RuX2RlZnMuaAorKysgYi9kcml2ZXJzL2lzZG4vaHlzZG4vaHlzZG5fZGVmcy5oCkBAIC0yMjcsNyArMjI3LDYgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqLwogLyogaW0vZXhwb3J0ZWQgZnVuY3Rpb25zICovCiAvKioqKioqKioqKioqKioqKioqKioqKioqKi8KLWV4dGVybiBjaGFyICpoeXNkbl9nZXRyZXYoY29uc3QgY2hhciAqKTsKIAogLyogaHlzZG5fcHJvY2NvbmYuYyAqLwogZXh0ZXJuIGludCBoeXNkbl9wcm9jY29uZl9pbml0KHZvaWQpOwkvKiBpbml0IHByb2MgY29uZmlnIGZpbGVzeXMgKi8KQEAgLTI1OSw3ICsyNTgsNiBAQAogCiAvKiBoeXNkbl9uZXQuYyAqLwogZXh0ZXJuIHVuc2lnbmVkIGludCBoeW5ldF9lbmFibGU7IAotZXh0ZXJuIGNoYXIgKmh5c2RuX25ldF9yZXZpc2lvbjsKIGV4dGVybiBpbnQgaHlzZG5fbmV0X2NyZWF0ZShoeXNkbl9jYXJkICopOwkvKiBjcmVhdGUgYSBuZXcgbmV0IGRldmljZSAqLwogZXh0ZXJuIGludCBoeXNkbl9uZXRfcmVsZWFzZShoeXNkbl9jYXJkICopOwkvKiBkZWxldGUgdGhlIGRldmljZSAqLwogZXh0ZXJuIGNoYXIgKmh5c2RuX25ldF9nZXRuYW1lKGh5c2RuX2NhcmQgKik7CS8qIGdldCBuYW1lIG9mIG5ldCBpbnRlcmZhY2UgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9oeXNkbi9oeXNkbl9pbml0LmMgYi9kcml2ZXJzL2lzZG4vaHlzZG4vaHlzZG5faW5pdC5jCmluZGV4IGI3Y2M1YzIuLjBhYjQyYWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXNkbi9oeXNkbi9oeXNkbl9pbml0LmMKKysrIGIvZHJpdmVycy9pc2RuL2h5c2RuL2h5c2RuX2luaXQuYwpAQCAtMzYsNyArMzYsNiBAQAogTU9EVUxFX0FVVEhPUigiV2VybmVyIENvcm5lbGl1cyIpOwogTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwogCi1zdGF0aWMgY2hhciAqaHlzZG5faW5pdF9yZXZpc2lvbiA9ICIkUmV2aXNpb246IDEuNi42LjYgJCI7CiBzdGF0aWMgaW50IGNhcmRtYXg7CQkvKiBudW1iZXIgb2YgZm91bmQgY2FyZHMgKi8KIGh5c2RuX2NhcmQgKmNhcmRfcm9vdCA9IE5VTEw7CS8qIHBvaW50ZXIgdG8gZmlyc3QgY2FyZCAqLwogc3RhdGljIGh5c2RuX2NhcmQgKmNhcmRfbGFzdCA9IE5VTEw7CS8qIHBvaW50ZXIgdG8gZmlyc3QgY2FyZCAqLwpAQCAtNDksMjUgKzQ4LDYgQEAKIC8qIEFkZGl0aW9uYWxseSBuZXdlciB2ZXJzaW9ucyBtYXkgYmUgYWN0aXZhdGVkIHdpdGhvdXQgcmVib290aW5nLiAgICAgICAgICAqLwogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi0vKiBleHRyYWN0IHJldmlzaW9uIG51bWJlciBmcm9tIHN0cmluZyBmb3IgbG9nIG91dHB1dCAqLwotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLWNoYXIgKgotaHlzZG5fZ2V0cmV2KGNvbnN0IGNoYXIgKnJldmlzaW9uKQotewotCWNoYXIgKnJldjsKLQljaGFyICpwOwotCi0JaWYgKChwID0gc3RyY2hyKHJldmlzaW9uLCAnOicpKSkgewotCQlyZXYgPSBwICsgMjsKLQkJcCA9IHN0cmNocihyZXYsICckJyk7Ci0JCSotLXAgPSAwOwotCX0gZWxzZQotCQlyZXYgPSAiPz8/IjsKLQlyZXR1cm4gcmV2OwotfQotCi0KIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyogaW5pdF9tb2R1bGUgaXMgY2FsbGVkIG9uY2Ugd2hlbiB0aGUgbW9kdWxlIGlzIGxvYWRlZCB0byBkbyBhbGwgbmVjZXNzYXJ5ICovCiAvKiB0aGluZ3MgbGlrZSBhdXRvZGV0ZWN0Li4uICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KQEAgLTE3NSwxMyArMTU1LDkgQEAKIHN0YXRpYyBpbnQgX19pbml0CiBoeXNkbl9pbml0KHZvaWQpCiB7Ci0JY2hhciB0bXBbNTBdOwogCWludCByYzsKIAotCXN0cmNweSh0bXAsIGh5c2RuX2luaXRfcmV2aXNpb24pOwotCXByaW50ayhLRVJOX05PVElDRSAiSFlTRE46IG1vZHVsZSBSZXY6ICVzIGxvYWRlZFxuIiwgaHlzZG5fZ2V0cmV2KHRtcCkpOwotCXN0cmNweSh0bXAsIGh5c2RuX25ldF9yZXZpc2lvbik7Ci0JcHJpbnRrKEtFUk5fTk9USUNFICJIWVNETjogbmV0d29yayBpbnRlcmZhY2UgUmV2OiAlcyBcbiIsIGh5c2RuX2dldHJldih0bXApKTsKKwlwcmludGsoS0VSTl9OT1RJQ0UgIkhZU0ROOiBtb2R1bGUgbG9hZGVkXG4iKTsKIAogCXJjID0gcGNpX3JlZ2lzdGVyX2RyaXZlcigmaHlzZG5fcGNpX2RyaXZlcik7CiAJaWYgKHJjKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pc2RuL2h5c2RuL2h5c2RuX25ldC5jIGIvZHJpdmVycy9pc2RuL2h5c2RuL2h5c2RuX25ldC5jCmluZGV4IGZlZWM4ZDguLjExZjJjY2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXNkbi9oeXNkbi9oeXNkbl9uZXQuYworKysgYi9kcml2ZXJzL2lzZG4vaHlzZG4vaHlzZG5fbmV0LmMKQEAgLTI2LDkgKzI2LDYgQEAKIHVuc2lnbmVkIGludCBoeW5ldF9lbmFibGUgPSAweGZmZmZmZmZmOyAKIG1vZHVsZV9wYXJhbShoeW5ldF9lbmFibGUsIHVpbnQsIDApOwogCi0vKiBzdG9yZSB0aGUgYWN0dWFsIHZlcnNpb24gZm9yIGxvZyByZXBvcnRpbmcgKi8KLWNoYXIgKmh5c2RuX25ldF9yZXZpc2lvbiA9ICIkUmV2aXNpb246IDEuOC42LjQgJCI7Ci0KICNkZWZpbmUgTUFYX1NLQl9CVUZGRVJTIDIwCS8qIG51bWJlciBvZiBidWZmZXJzIGZvciBrZWVwaW5nIFRYLWRhdGEgKi8KIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vaHlzZG4vaHlzZG5fcHJvY2NvbmYuYyBiL2RyaXZlcnMvaXNkbi9oeXNkbi9oeXNkbl9wcm9jY29uZi5jCmluZGV4IDk2YjNlMzkuLjVmZTgzYmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXNkbi9oeXNkbi9oeXNkbl9wcm9jY29uZi5jCisrKyBiL2RyaXZlcnMvaXNkbi9oeXNkbi9oeXNkbl9wcm9jY29uZi5jCkBAIC0yMyw3ICsyMyw2IEBACiAjaW5jbHVkZSAiaHlzZG5fZGVmcy5oIgogCiBzdGF0aWMgREVGSU5FX01VVEVYKGh5c2RuX2NvbmZfbXV0ZXgpOwotc3RhdGljIGNoYXIgKmh5c2RuX3Byb2Njb25mX3JldmlzaW9uID0gIiRSZXZpc2lvbjogMS44LjYuNCAkIjsKIAogI2RlZmluZSBJTkZPX09VVF9MRU4gODAJCS8qIGxlbmd0aCBvZiBpbmZvIGxpbmUgaW5jbHVkaW5nIGxmICovCiAKQEAgLTQwNCw3ICs0MDMsNyBAQAogCQljYXJkID0gY2FyZC0+bmV4dDsJLyogbmV4dCBlbnRyeSAqLwogCX0KIAotCXByaW50ayhLRVJOX05PVElDRSAiSFlTRE46IHByb2NmcyBSZXYuICVzIGluaXRpYWxpc2VkXG4iLCBoeXNkbl9nZXRyZXYoaHlzZG5fcHJvY2NvbmZfcmV2aXNpb24pKTsKKwlwcmludGsoS0VSTl9OT1RJQ0UgIkhZU0ROOiBwcm9jZnMgaW5pdGlhbGlzZWRcbiIpOwogCXJldHVybiAoMCk7CiB9CQkJCS8qIGh5c2RuX3Byb2Njb25mX2luaXQgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pc2RuL2ljbi9pY24uYyBiL2RyaXZlcnMvaXNkbi9pY24vaWNuLmMKaW5kZXggZjJiNWJhYi4uMWYzNTViYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL2ljbi9pY24uYworKysgYi9kcml2ZXJzL2lzZG4vaWNuL2ljbi5jCkBAIC0xNjI3LDcgKzE2MjcsNyBAQAogc3RhdGljIGludCBfX2luaXQgaWNuX2luaXQodm9pZCkKIHsKIAljaGFyICpwOwotCWNoYXIgcmV2WzIwXTsKKwljaGFyIHJldlsyMV07CiAKIAltZW1zZXQoJmRldiwgMCwgc2l6ZW9mKGljbl9kZXYpKTsKIAlkZXYubWVtYWRkciA9IChtZW1iYXNlICYgMHgwZmZjMDAwKTsKQEAgLTE2MzgsNiArMTYzOCw3IEBACiAKIAlpZiAoKHAgPSBzdHJjaHIocmV2aXNpb24sICc6JykpKSB7CiAJCXN0cm5jcHkocmV2LCBwICsgMSwgMjApOworCQlyZXZbMjBdID0gJ1wwJzsKIAkJcCA9IHN0cmNocihyZXYsICckJyk7CiAJCWlmIChwKQogCQkJKnAgPSAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9sZWRzL2xlZHMtcHdtLmMgYi9kcml2ZXJzL2xlZHMvbGVkcy1wd20uYwppbmRleCBkYTNmYThkLi42NjZkYWY3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2xlZHMvbGVkcy1wd20uYworKysgYi9kcml2ZXJzL2xlZHMvbGVkcy1wd20uYwpAQCAtNjksNiArNjksNyBAQAogCQlsZWRfZGF0LT5wd20gPSBwd21fcmVxdWVzdChjdXJfbGVkLT5wd21faWQsCiAJCQkJY3VyX2xlZC0+bmFtZSk7CiAJCWlmIChJU19FUlIobGVkX2RhdC0+cHdtKSkgeworCQkJcmV0ID0gUFRSX0VSUihsZWRfZGF0LT5wd20pOwogCQkJZGV2X2VycigmcGRldi0+ZGV2LCAidW5hYmxlIHRvIHJlcXVlc3QgUFdNICVkXG4iLAogCQkJCQljdXJfbGVkLT5wd21faWQpOwogCQkJZ290byBlcnI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2xlZHMvbGVkdHJpZy1ncGlvLmMgYi9kcml2ZXJzL2xlZHMvbGVkdHJpZy1ncGlvLmMKaW5kZXggOTkxZDkzYi4uZWNjNGJmMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9sZWRzL2xlZHRyaWctZ3Bpby5jCisrKyBiL2RyaXZlcnMvbGVkcy9sZWR0cmlnLWdwaW8uYwpAQCAtOTksNyArOTksNyBAQAogCXN0cnVjdCBsZWRfY2xhc3NkZXYgKmxlZCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwogCXN0cnVjdCBncGlvX3RyaWdfZGF0YSAqZ3Bpb19kYXRhID0gbGVkLT50cmlnZ2VyX2RhdGE7CiAKLQlyZXR1cm4gc3ByaW50ZihidWYsICIlc1xuIiwgZ3Bpb19kYXRhLT5pbnZlcnRlZCA/ICJ5ZXMiIDogIm5vIik7CisJcmV0dXJuIHNwcmludGYoYnVmLCAiJXVcbiIsIGdwaW9fZGF0YS0+aW52ZXJ0ZWQpOwogfQogCiBzdGF0aWMgc3NpemVfdCBncGlvX3RyaWdfaW52ZXJ0ZWRfc3RvcmUoc3RydWN0IGRldmljZSAqZGV2LApAQCAtMTA3LDE2ICsxMDcsMTcgQEAKIHsKIAlzdHJ1Y3QgbGVkX2NsYXNzZGV2ICpsZWQgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKIAlzdHJ1Y3QgZ3Bpb190cmlnX2RhdGEgKmdwaW9fZGF0YSA9IGxlZC0+dHJpZ2dlcl9kYXRhOwotCXVuc2lnbmVkIGludmVydGVkOworCXVuc2lnbmVkIGxvbmcgaW52ZXJ0ZWQ7CiAJaW50IHJldDsKIAotCXJldCA9IHNzY2FuZihidWYsICIldSIsICZpbnZlcnRlZCk7Ci0JaWYgKHJldCA8IDEpIHsKLQkJZGV2X2VycihkZXYsICJpbnZhbGlkIHZhbHVlXG4iKTsKLQkJcmV0dXJuIC1FSU5WQUw7Ci0JfQorCXJldCA9IHN0cmljdF9zdHJ0b3VsKGJ1ZiwgMTAsICZpbnZlcnRlZCk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CiAKLQlncGlvX2RhdGEtPmludmVydGVkID0gISFpbnZlcnRlZDsKKwlpZiAoaW52ZXJ0ZWQgPiAxKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWdwaW9fZGF0YS0+aW52ZXJ0ZWQgPSBpbnZlcnRlZDsKIAogCS8qIEFmdGVyIGludmVydGluZywgd2UgbmVlZCB0byB1cGRhdGUgdGhlIExFRC4gKi8KIAlzY2hlZHVsZV93b3JrKCZncGlvX2RhdGEtPndvcmspOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9sZ3Vlc3QvcGFnZV90YWJsZXMuYyBiL2RyaXZlcnMvbGd1ZXN0L3BhZ2VfdGFibGVzLmMKaW5kZXggMDRiMjIxMi4uZDIxNTc4ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9sZ3Vlc3QvcGFnZV90YWJsZXMuYworKysgYi9kcml2ZXJzL2xndWVzdC9wYWdlX3RhYmxlcy5jCkBAIC0xMTM3LDcgKzExMzcsNyBAQAogICovCiB2b2lkIG1hcF9zd2l0Y2hlcl9pbl9ndWVzdChzdHJ1Y3QgbGdfY3B1ICpjcHUsIHN0cnVjdCBsZ3Vlc3RfcGFnZXMgKnBhZ2VzKQogewotCXB0ZV90ICpzd2l0Y2hlcl9wdGVfcGFnZSA9IF9fZ2V0X2NwdV92YXIoc3dpdGNoZXJfcHRlX3BhZ2VzKTsKKwlwdGVfdCAqc3dpdGNoZXJfcHRlX3BhZ2UgPSBfX3RoaXNfY3B1X3JlYWQoc3dpdGNoZXJfcHRlX3BhZ2VzKTsKIAlwdGVfdCByZWdzX3B0ZTsKIAogI2lmZGVmIENPTkZJR19YODZfUEFFCmRpZmYgLS1naXQgYS9kcml2ZXJzL2xndWVzdC94ODYvY29yZS5jIGIvZHJpdmVycy9sZ3Vlc3QveDg2L2NvcmUuYwppbmRleCBiNGViNjc1Li45ZjE2NTljIDEwMDY0NAotLS0gYS9kcml2ZXJzL2xndWVzdC94ODYvY29yZS5jCisrKyBiL2RyaXZlcnMvbGd1ZXN0L3g4Ni9jb3JlLmMKQEAgLTkwLDggKzkwLDggQEAKIAkgKiBtZWFud2hpbGUpLiAgSWYgdGhhdCdzIG5vdCB0aGUgY2FzZSwgd2UgcHJldGVuZCBldmVyeXRoaW5nIGluIHRoZQogCSAqIEd1ZXN0IGhhcyBjaGFuZ2VkLgogCSAqLwotCWlmIChfX2dldF9jcHVfdmFyKGxnX2xhc3RfY3B1KSAhPSBjcHUgfHwgY3B1LT5sYXN0X3BhZ2VzICE9IHBhZ2VzKSB7Ci0JCV9fZ2V0X2NwdV92YXIobGdfbGFzdF9jcHUpID0gY3B1OworCWlmIChfX3RoaXNfY3B1X3JlYWQobGdfbGFzdF9jcHUpICE9IGNwdSB8fCBjcHUtPmxhc3RfcGFnZXMgIT0gcGFnZXMpIHsKKwkJX190aGlzX2NwdV93cml0ZShsZ19sYXN0X2NwdSwgY3B1KTsKIAkJY3B1LT5sYXN0X3BhZ2VzID0gcGFnZXM7CiAJCWNwdS0+Y2hhbmdlZCA9IENIQU5HRURfQUxMOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWFjaW50b3NoL3RoZXJtX3BtNzIuYyBiL2RyaXZlcnMvbWFjaW50b3NoL3RoZXJtX3BtNzIuYwppbmRleCAyZTA0MWZkLi5mM2EyOWYyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21hY2ludG9zaC90aGVybV9wbTcyLmMKKysrIGIvZHJpdmVycy9tYWNpbnRvc2gvdGhlcm1fcG03Mi5jCkBAIC00NDMsNyArNDQzLDcgQEAKIAl0cmllcyA9IDA7CiAJZm9yICg7OykgewogCQluciA9IGkyY19tYXN0ZXJfcmVjdihmY3UsIGJ1ZiwgbmIpOwotCQlpZiAobnIgPiAwIHx8IChuciA8IDAgJiYgbnIgIT0gRU5PREVWKSB8fCB0cmllcyA+PSAxMDApCisJCWlmIChuciA+IDAgfHwgKG5yIDwgMCAmJiBuciAhPSAtRU5PREVWKSB8fCB0cmllcyA+PSAxMDApCiAJCQlicmVhazsKIAkJbXNsZWVwKDEwKTsKIAkJKyt0cmllczsKQEAgLTQ2NCw3ICs0NjQsNyBAQAogCXRyaWVzID0gMDsKIAlmb3IgKDs7KSB7CiAJCW53ID0gaTJjX21hc3Rlcl9zZW5kKGZjdSwgYnVmLCBuYik7Ci0JCWlmIChudyA+IDAgfHwgKG53IDwgMCAmJiBudyAhPSBFSU8pIHx8IHRyaWVzID49IDEwMCkKKwkJaWYgKG53ID4gMCB8fCAobncgPCAwICYmIG53ICE9IC1FSU8pIHx8IHRyaWVzID49IDEwMCkKIAkJCWJyZWFrOwogCQltc2xlZXAoMTApOwogCQkrK3RyaWVzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9LY29uZmlnIGIvZHJpdmVycy9tZC9LY29uZmlnCmluZGV4IGJmMWE5NWUzLi45OGQ5ZWM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL0tjb25maWcKKysrIGIvZHJpdmVycy9tZC9LY29uZmlnCkBAIC0yNDAsNiArMjQwLDMwIEBACiAgICAgICAgICBBbGxvdyB2b2x1bWUgbWFuYWdlcnMgdG8gbWlycm9yIGxvZ2ljYWwgdm9sdW1lcywgYWxzbwogICAgICAgICAgbmVlZGVkIGZvciBsaXZlIGRhdGEgbWlncmF0aW9uIHRvb2xzIHN1Y2ggYXMgJ3B2bW92ZScuCiAKK2NvbmZpZyBETV9SQUlECisgICAgICAgdHJpc3RhdGUgIlJBSUQgNC81LzYgdGFyZ2V0IChFWFBFUklNRU5UQUwpIgorICAgICAgIGRlcGVuZHMgb24gQkxLX0RFVl9ETSAmJiBFWFBFUklNRU5UQUwKKyAgICAgICBzZWxlY3QgTURfUkFJRDQ1NgorICAgICAgIHNlbGVjdCBCTEtfREVWX01ECisgICAgICAgLS0taGVscC0tLQorCSBBIGRtIHRhcmdldCB0aGF0IHN1cHBvcnRzIFJBSUQ0LCBSQUlENSBhbmQgUkFJRDYgbWFwcGluZ3MKKworCSBBIFJBSUQtNSBzZXQgb2YgTiBkcml2ZXMgd2l0aCBhIGNhcGFjaXR5IG9mIEMgTUIgcGVyIGRyaXZlIHByb3ZpZGVzCisJIHRoZSBjYXBhY2l0eSBvZiBDICogKE4gLSAxKSBNQiwgYW5kIHByb3RlY3RzIGFnYWluc3QgYSBmYWlsdXJlCisJIG9mIGEgc2luZ2xlIGRyaXZlLiBGb3IgYSBnaXZlbiBzZWN0b3IgKHJvdykgbnVtYmVyLCAoTiAtIDEpIGRyaXZlcworCSBjb250YWluIGRhdGEgc2VjdG9ycywgYW5kIG9uZSBkcml2ZSBjb250YWlucyB0aGUgcGFyaXR5IHByb3RlY3Rpb24uCisJIEZvciBhIFJBSUQtNCBzZXQsIHRoZSBwYXJpdHkgYmxvY2tzIGFyZSBwcmVzZW50IG9uIGEgc2luZ2xlIGRyaXZlLAorCSB3aGlsZSBhIFJBSUQtNSBzZXQgZGlzdHJpYnV0ZXMgdGhlIHBhcml0eSBhY3Jvc3MgdGhlIGRyaXZlcyBpbiBvbmUKKwkgb2YgdGhlIGF2YWlsYWJsZSBwYXJpdHkgZGlzdHJpYnV0aW9uIG1ldGhvZHMuCisKKwkgQSBSQUlELTYgc2V0IG9mIE4gZHJpdmVzIHdpdGggYSBjYXBhY2l0eSBvZiBDIE1CIHBlciBkcml2ZQorCSBwcm92aWRlcyB0aGUgY2FwYWNpdHkgb2YgQyAqIChOIC0gMikgTUIsIGFuZCBwcm90ZWN0cworCSBhZ2FpbnN0IGEgZmFpbHVyZSBvZiBhbnkgdHdvIGRyaXZlcy4gRm9yIGEgZ2l2ZW4gc2VjdG9yCisJIChyb3cpIG51bWJlciwgKE4gLSAyKSBkcml2ZXMgY29udGFpbiBkYXRhIHNlY3RvcnMsIGFuZCB0d28KKwkgZHJpdmVzIGNvbnRhaW5zIHR3byBpbmRlcGVuZGVudCByZWR1bmRhbmN5IHN5bmRyb21lcy4gIExpa2UKKwkgUkFJRC01LCBSQUlELTYgZGlzdHJpYnV0ZXMgdGhlIHN5bmRyb21lcyBhY3Jvc3MgdGhlIGRyaXZlcworCSBpbiBvbmUgb2YgdGhlIGF2YWlsYWJsZSBwYXJpdHkgZGlzdHJpYnV0aW9uIG1ldGhvZHMuCisKIGNvbmZpZyBETV9MT0dfVVNFUlNQQUNFCiAJdHJpc3RhdGUgIk1pcnJvciB1c2Vyc3BhY2UgbG9nZ2luZyAoRVhQRVJJTUVOVEFMKSIKIAlkZXBlbmRzIG9uIERNX01JUlJPUiAmJiBFWFBFUklNRU5UQUwgJiYgTkVUCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL01ha2VmaWxlIGIvZHJpdmVycy9tZC9NYWtlZmlsZQppbmRleCA1ZTNhYWM0Li5kMDEzODYwIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvbWQvTWFrZWZpbGUKQEAgLTM2LDYgKzM2LDcgQEAKIG9iai0kKENPTkZJR19ETV9NSVJST1IpCQkrPSBkbS1taXJyb3IubyBkbS1sb2cubyBkbS1yZWdpb24taGFzaC5vCiBvYmotJChDT05GSUdfRE1fTE9HX1VTRVJTUEFDRSkJKz0gZG0tbG9nLXVzZXJzcGFjZS5vCiBvYmotJChDT05GSUdfRE1fWkVSTykJCSs9IGRtLXplcm8ubworb2JqLSQoQ09ORklHX0RNX1JBSUQpCSs9IGRtLXJhaWQubwogCiBpZmVxICgkKENPTkZJR19ETV9VRVZFTlQpLHkpCiBkbS1tb2Qtb2JqcwkJCSs9IGRtLXVldmVudC5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2JpdG1hcC5jIGIvZHJpdmVycy9tZC9iaXRtYXAuYwppbmRleCA1YTFmZmUzLi45YTM1MzIwIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2JpdG1hcC5jCisrKyBiL2RyaXZlcnMvbWQvYml0bWFwLmMKQEAgLTIxMCwxMSArMjEwLDExIEBACiAJCSAgICB8fCB0ZXN0X2JpdChGYXVsdHksICZyZGV2LT5mbGFncykpCiAJCQljb250aW51ZTsKIAotCQl0YXJnZXQgPSByZGV2LT5zYl9zdGFydCArIG9mZnNldCArIGluZGV4ICogKFBBR0VfU0laRS81MTIpOworCQl0YXJnZXQgPSBvZmZzZXQgKyBpbmRleCAqIChQQUdFX1NJWkUvNTEyKTsKIAogCQlpZiAoc3luY19wYWdlX2lvKHJkZXYsIHRhcmdldCwKIAkJCQkgcm91bmR1cChzaXplLCBiZGV2X2xvZ2ljYWxfYmxvY2tfc2l6ZShyZGV2LT5iZGV2KSksCi0JCQkJIHBhZ2UsIFJFQUQpKSB7CisJCQkJIHBhZ2UsIFJFQUQsIHRydWUpKSB7CiAJCQlwYWdlLT5pbmRleCA9IGluZGV4OwogCQkJYXR0YWNoX3BhZ2VfYnVmZmVycyhwYWdlLCBOVUxMKTsgLyogc28gdGhhdCBmcmVlX2J1ZmZlciB3aWxsCiAJCQkJCQkJICAqIHF1aWV0bHkgbm8tb3AgKi8KQEAgLTI2NCwxNCArMjY0LDE4IEBACiBzdGF0aWMgaW50IHdyaXRlX3NiX3BhZ2Uoc3RydWN0IGJpdG1hcCAqYml0bWFwLCBzdHJ1Y3QgcGFnZSAqcGFnZSwgaW50IHdhaXQpCiB7CiAJbWRrX3JkZXZfdCAqcmRldiA9IE5VTEw7CisJc3RydWN0IGJsb2NrX2RldmljZSAqYmRldjsKIAltZGRldl90ICptZGRldiA9IGJpdG1hcC0+bWRkZXY7CiAKIAl3aGlsZSAoKHJkZXYgPSBuZXh0X2FjdGl2ZV9yZGV2KHJkZXYsIG1kZGV2KSkgIT0gTlVMTCkgewogCQlpbnQgc2l6ZSA9IFBBR0VfU0laRTsKIAkJbG9mZl90IG9mZnNldCA9IG1kZGV2LT5iaXRtYXBfaW5mby5vZmZzZXQ7CisKKwkJYmRldiA9IChyZGV2LT5tZXRhX2JkZXYpID8gcmRldi0+bWV0YV9iZGV2IDogcmRldi0+YmRldjsKKwogCQlpZiAocGFnZS0+aW5kZXggPT0gYml0bWFwLT5maWxlX3BhZ2VzLTEpCiAJCQlzaXplID0gcm91bmR1cChiaXRtYXAtPmxhc3RfcGFnZV9zaXplLAotCQkJCSAgICAgICBiZGV2X2xvZ2ljYWxfYmxvY2tfc2l6ZShyZGV2LT5iZGV2KSk7CisJCQkJICAgICAgIGJkZXZfbG9naWNhbF9ibG9ja19zaXplKGJkZXYpKTsKIAkJLyogSnVzdCBtYWtlIHN1cmUgd2UgYXJlbid0IGNvcnJ1cHRpbmcgZGF0YSBvcgogCQkgKiBtZXRhZGF0YQogCQkgKi8KQEAgLTE1NDIsNyArMTU0Niw3IEBACiAJd2FpdF9ldmVudChiaXRtYXAtPm1kZGV2LT5yZWNvdmVyeV93YWl0LAogCQkgICBhdG9taWNfcmVhZCgmYml0bWFwLT5tZGRldi0+cmVjb3ZlcnlfYWN0aXZlKSA9PSAwKTsKIAotCWJpdG1hcC0+bWRkZXYtPmN1cnJfcmVzeW5jX2NvbXBsZXRlZCA9IGJpdG1hcC0+bWRkZXYtPmN1cnJfcmVzeW5jOworCWJpdG1hcC0+bWRkZXYtPmN1cnJfcmVzeW5jX2NvbXBsZXRlZCA9IHNlY3RvcjsKIAlzZXRfYml0KE1EX0NIQU5HRV9DTEVBTiwgJmJpdG1hcC0+bWRkZXYtPmZsYWdzKTsKIAlzZWN0b3IgJj0gfigoMVVMTCA8PCBDSFVOS19CTE9DS19TSElGVChiaXRtYXApKSAtIDEpOwogCXMgPSAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1jcnlwdC5jIGIvZHJpdmVycy9tZC9kbS1jcnlwdC5jCmluZGV4IGQ1YjBlNGMuLjRlMDU0YmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tY3J5cHQuYworKysgYi9kcml2ZXJzL21kL2RtLWNyeXB0LmMKQEAgLTE4LDEwICsxOCwxNCBAQAogI2luY2x1ZGUgPGxpbnV4L2NyeXB0by5oPgogI2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgogI2luY2x1ZGUgPGxpbnV4L2JhY2tpbmctZGV2Lmg+CisjaW5jbHVkZSA8bGludXgvcGVyY3B1Lmg+CiAjaW5jbHVkZSA8YXNtL2F0b21pYy5oPgogI2luY2x1ZGUgPGxpbnV4L3NjYXR0ZXJsaXN0Lmg+CiAjaW5jbHVkZSA8YXNtL3BhZ2UuaD4KICNpbmNsdWRlIDxhc20vdW5hbGlnbmVkLmg+CisjaW5jbHVkZSA8Y3J5cHRvL2hhc2guaD4KKyNpbmNsdWRlIDxjcnlwdG8vbWQ1Lmg+CisjaW5jbHVkZSA8Y3J5cHRvL2FsZ2FwaS5oPgogCiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLW1hcHBlci5oPgogCkBAIC02Myw2ICs2Nyw3IEBACiAJc3RydWN0IGNvbnZlcnRfY29udGV4dCAqY3R4OwogCXN0cnVjdCBzY2F0dGVybGlzdCBzZ19pbjsKIAlzdHJ1Y3Qgc2NhdHRlcmxpc3Qgc2dfb3V0OworCXNlY3Rvcl90IGl2X3NlY3RvcjsKIH07CiAKIHN0cnVjdCBjcnlwdF9jb25maWc7CkBAIC03MywxMSArNzgsMTMgQEAKIAl2b2lkICgqZHRyKShzdHJ1Y3QgY3J5cHRfY29uZmlnICpjYyk7CiAJaW50ICgqaW5pdCkoc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MpOwogCWludCAoKndpcGUpKHN0cnVjdCBjcnlwdF9jb25maWcgKmNjKTsKLQlpbnQgKCpnZW5lcmF0b3IpKHN0cnVjdCBjcnlwdF9jb25maWcgKmNjLCB1OCAqaXYsIHNlY3Rvcl90IHNlY3Rvcik7CisJaW50ICgqZ2VuZXJhdG9yKShzdHJ1Y3QgY3J5cHRfY29uZmlnICpjYywgdTggKml2LAorCQkJIHN0cnVjdCBkbV9jcnlwdF9yZXF1ZXN0ICpkbXJlcSk7CisJaW50ICgqcG9zdCkoc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MsIHU4ICppdiwKKwkJICAgIHN0cnVjdCBkbV9jcnlwdF9yZXF1ZXN0ICpkbXJlcSk7CiB9OwogCiBzdHJ1Y3QgaXZfZXNzaXZfcHJpdmF0ZSB7Ci0Jc3RydWN0IGNyeXB0b19jaXBoZXIgKnRmbTsKIAlzdHJ1Y3QgY3J5cHRvX2hhc2ggKmhhc2hfdGZtOwogCXU4ICpzYWx0OwogfTsKQEAgLTg2LDExICs5MywzMiBAQAogCWludCBzaGlmdDsKIH07CiAKKyNkZWZpbmUgTE1LX1NFRURfU0laRSA2NCAvKiBoYXNoICsgMCAqLworc3RydWN0IGl2X2xta19wcml2YXRlIHsKKwlzdHJ1Y3QgY3J5cHRvX3NoYXNoICpoYXNoX3RmbTsKKwl1OCAqc2VlZDsKK307CisKIC8qCiAgKiBDcnlwdDogbWFwcyBhIGxpbmVhciByYW5nZSBvZiBhIGJsb2NrIGRldmljZQogICogYW5kIGVuY3J5cHRzIC8gZGVjcnlwdHMgYXQgdGhlIHNhbWUgdGltZS4KICAqLwogZW51bSBmbGFncyB7IERNX0NSWVBUX1NVU1BFTkRFRCwgRE1fQ1JZUFRfS0VZX1ZBTElEIH07CisKKy8qCisgKiBEdXBsaWNhdGVkIHBlci1DUFUgc3RhdGUgZm9yIGNpcGhlci4KKyAqLworc3RydWN0IGNyeXB0X2NwdSB7CisJc3RydWN0IGFibGtjaXBoZXJfcmVxdWVzdCAqcmVxOworCS8qIEVTU0lWOiBzdHJ1Y3QgY3J5cHRvX2NpcGhlciAqZXNzaXZfdGZtICovCisJdm9pZCAqaXZfcHJpdmF0ZTsKKwlzdHJ1Y3QgY3J5cHRvX2FibGtjaXBoZXIgKnRmbXNbMF07Cit9OworCisvKgorICogVGhlIGZpZWxkcyBpbiBoZXJlIG11c3QgYmUgcmVhZCBvbmx5IGFmdGVyIGluaXRpYWxpemF0aW9uLAorICogY2hhbmdpbmcgc3RhdGUgc2hvdWxkIGJlIGluIGNyeXB0X2NwdS4KKyAqLwogc3RydWN0IGNyeXB0X2NvbmZpZyB7CiAJc3RydWN0IGRtX2RldiAqZGV2OwogCXNlY3Rvcl90IHN0YXJ0OwpAQCAtMTA4LDE3ICsxMzYsMjUgQEAKIAlzdHJ1Y3Qgd29ya3F1ZXVlX3N0cnVjdCAqY3J5cHRfcXVldWU7CiAKIAljaGFyICpjaXBoZXI7Ci0JY2hhciAqY2lwaGVyX21vZGU7CisJY2hhciAqY2lwaGVyX3N0cmluZzsKIAogCXN0cnVjdCBjcnlwdF9pdl9vcGVyYXRpb25zICppdl9nZW5fb3BzOwogCXVuaW9uIHsKIAkJc3RydWN0IGl2X2Vzc2l2X3ByaXZhdGUgZXNzaXY7CiAJCXN0cnVjdCBpdl9iZW5iaV9wcml2YXRlIGJlbmJpOworCQlzdHJ1Y3QgaXZfbG1rX3ByaXZhdGUgbG1rOwogCX0gaXZfZ2VuX3ByaXZhdGU7CiAJc2VjdG9yX3QgaXZfb2Zmc2V0OwogCXVuc2lnbmVkIGludCBpdl9zaXplOwogCiAJLyoKKwkgKiBEdXBsaWNhdGVkIHBlciBjcHUgc3RhdGUuIEFjY2VzcyB0aHJvdWdoCisJICogcGVyX2NwdV9wdHIoKSBvbmx5LgorCSAqLworCXN0cnVjdCBjcnlwdF9jcHUgX19wZXJjcHUgKmNwdTsKKwl1bnNpZ25lZCB0Zm1zX2NvdW50OworCisJLyoKIAkgKiBMYXlvdXQgb2YgZWFjaCBjcnlwdG8gcmVxdWVzdDoKIAkgKgogCSAqICAgc3RydWN0IGFibGtjaXBoZXJfcmVxdWVzdApAQCAtMTMyLDExICsxNjgsMTAgQEAKIAkgKiBjb3JyZWN0bHkgYWxpZ25lZC4KIAkgKi8KIAl1bnNpZ25lZCBpbnQgZG1yZXFfc3RhcnQ7Ci0Jc3RydWN0IGFibGtjaXBoZXJfcmVxdWVzdCAqcmVxOwogCi0Jc3RydWN0IGNyeXB0b19hYmxrY2lwaGVyICp0Zm07CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAl1bnNpZ25lZCBpbnQga2V5X3NpemU7CisJdW5zaWduZWQgaW50IGtleV9wYXJ0czsKIAl1OCBrZXlbMF07CiB9OwogCkBAIC0xNDgsNiArMTgzLDIwIEBACiAKIHN0YXRpYyB2b2lkIGNsb25lX2luaXQoc3RydWN0IGRtX2NyeXB0X2lvICosIHN0cnVjdCBiaW8gKik7CiBzdGF0aWMgdm9pZCBrY3J5cHRkX3F1ZXVlX2NyeXB0KHN0cnVjdCBkbV9jcnlwdF9pbyAqaW8pOworc3RhdGljIHU4ICppdl9vZl9kbXJlcShzdHJ1Y3QgY3J5cHRfY29uZmlnICpjYywgc3RydWN0IGRtX2NyeXB0X3JlcXVlc3QgKmRtcmVxKTsKKworc3RhdGljIHN0cnVjdCBjcnlwdF9jcHUgKnRoaXNfY3J5cHRfY29uZmlnKHN0cnVjdCBjcnlwdF9jb25maWcgKmNjKQoreworCXJldHVybiB0aGlzX2NwdV9wdHIoY2MtPmNwdSk7Cit9CisKKy8qCisgKiBVc2UgdGhpcyB0byBhY2Nlc3MgY2lwaGVyIGF0dHJpYnV0ZXMgdGhhdCBhcmUgdGhlIHNhbWUgZm9yIGVhY2ggQ1BVLgorICovCitzdGF0aWMgc3RydWN0IGNyeXB0b19hYmxrY2lwaGVyICphbnlfdGZtKHN0cnVjdCBjcnlwdF9jb25maWcgKmNjKQoreworCXJldHVybiBfX3RoaXNfY3B1X3B0cihjYy0+Y3B1KS0+dGZtc1swXTsKK30KIAogLyoKICAqIERpZmZlcmVudCBJViBnZW5lcmF0aW9uIGFsZ29yaXRobXM6CkBAIC0xNjgsMjMgKzIxNywzOCBAQAogICogbnVsbDogdGhlIGluaXRpYWwgdmVjdG9yIGlzIGFsd2F5cyB6ZXJvLiAgUHJvdmlkZXMgY29tcGF0aWJpbGl0eSB3aXRoCiAgKiAgICAgICBvYnNvbGV0ZSBsb29wX2Zpc2gyIGRldmljZXMuICBEbyBub3QgdXNlIGZvciBuZXcgZGV2aWNlcy4KICAqCisgKiBsbWs6ICBDb21wYXRpYmxlIGltcGxlbWVudGF0aW9uIG9mIHRoZSBibG9jayBjaGFpbmluZyBtb2RlIHVzZWQKKyAqICAgICAgIGJ5IHRoZSBMb29wLUFFUyBibG9jayBkZXZpY2UgZW5jcnlwdGlvbiBzeXN0ZW0KKyAqICAgICAgIGRlc2lnbmVkIGJ5IEphcmkgUnV1c3UuIFNlZSBodHRwOi8vbG9vcC1hZXMuc291cmNlZm9yZ2UubmV0LworICogICAgICAgSXQgb3BlcmF0ZXMgb24gZnVsbCA1MTIgYnl0ZSBzZWN0b3JzIGFuZCB1c2VzIENCQworICogICAgICAgd2l0aCBhbiBJViBkZXJpdmVkIGZyb20gdGhlIHNlY3RvciBudW1iZXIsIHRoZSBkYXRhIGFuZAorICogICAgICAgb3B0aW9uYWxseSBleHRyYSBJViBzZWVkLgorICogICAgICAgVGhpcyBtZWFucyB0aGF0IGFmdGVyIGRlY3J5cHRpb24gdGhlIGZpcnN0IGJsb2NrCisgKiAgICAgICBvZiBzZWN0b3IgbXVzdCBiZSB0d2Vha2VkIGFjY29yZGluZyB0byBkZWNyeXB0ZWQgZGF0YS4KKyAqICAgICAgIExvb3AtQUVTIGNhbiB1c2UgdGhyZWUgZW5jcnlwdGlvbiBzY2hlbWVzOgorICogICAgICAgICB2ZXJzaW9uIDE6IGlzIHBsYWluIGFlcy1jYmMgbW9kZQorICogICAgICAgICB2ZXJzaW9uIDI6IHVzZXMgNjQgbXVsdGlrZXkgc2NoZW1lIHdpdGggbG1rIElWIGdlbmVyYXRvcgorICogICAgICAgICB2ZXJzaW9uIDM6IHRoZSBzYW1lIGFzIHZlcnNpb24gMiB3aXRoIGFkZGl0aW9uYWwgSVYgc2VlZAorICogICAgICAgICAgICAgICAgICAgKGl0IHVzZXMgNjUga2V5cywgbGFzdCBrZXkgaXMgdXNlZCBhcyBJViBzZWVkKQorICoKICAqIHBsdW1iOiB1bmltcGxlbWVudGVkLCBzZWU6CiAgKiBodHRwOi8vYXJ0aWNsZS5nbWFuZS5vcmcvZ21hbmUubGludXgua2VybmVsLmRldmljZS1tYXBwZXIuZG0tY3J5cHQvNDU0CiAgKi8KIAotc3RhdGljIGludCBjcnlwdF9pdl9wbGFpbl9nZW4oc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MsIHU4ICppdiwgc2VjdG9yX3Qgc2VjdG9yKQorc3RhdGljIGludCBjcnlwdF9pdl9wbGFpbl9nZW4oc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MsIHU4ICppdiwKKwkJCSAgICAgIHN0cnVjdCBkbV9jcnlwdF9yZXF1ZXN0ICpkbXJlcSkKIHsKIAltZW1zZXQoaXYsIDAsIGNjLT5pdl9zaXplKTsKLQkqKHUzMiAqKWl2ID0gY3B1X3RvX2xlMzIoc2VjdG9yICYgMHhmZmZmZmZmZik7CisJKih1MzIgKilpdiA9IGNwdV90b19sZTMyKGRtcmVxLT5pdl9zZWN0b3IgJiAweGZmZmZmZmZmKTsKIAogCXJldHVybiAwOwogfQogCiBzdGF0aWMgaW50IGNyeXB0X2l2X3BsYWluNjRfZ2VuKHN0cnVjdCBjcnlwdF9jb25maWcgKmNjLCB1OCAqaXYsCi0JCQkJc2VjdG9yX3Qgc2VjdG9yKQorCQkJCXN0cnVjdCBkbV9jcnlwdF9yZXF1ZXN0ICpkbXJlcSkKIHsKIAltZW1zZXQoaXYsIDAsIGNjLT5pdl9zaXplKTsKLQkqKHU2NCAqKWl2ID0gY3B1X3RvX2xlNjQoc2VjdG9yKTsKKwkqKHU2NCAqKWl2ID0gY3B1X3RvX2xlNjQoZG1yZXEtPml2X3NlY3Rvcik7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTE5NSw3ICsyNTksOCBAQAogCXN0cnVjdCBpdl9lc3Npdl9wcml2YXRlICplc3NpdiA9ICZjYy0+aXZfZ2VuX3ByaXZhdGUuZXNzaXY7CiAJc3RydWN0IGhhc2hfZGVzYyBkZXNjOwogCXN0cnVjdCBzY2F0dGVybGlzdCBzZzsKLQlpbnQgZXJyOworCXN0cnVjdCBjcnlwdG9fY2lwaGVyICplc3Npdl90Zm07CisJaW50IGVyciwgY3B1OwogCiAJc2dfaW5pdF9vbmUoJnNnLCBjYy0+a2V5LCBjYy0+a2V5X3NpemUpOwogCWRlc2MudGZtID0gZXNzaXYtPmhhc2hfdGZtOwpAQCAtMjA1LDggKzI3MCwxNiBAQAogCWlmIChlcnIpCiAJCXJldHVybiBlcnI7CiAKLQlyZXR1cm4gY3J5cHRvX2NpcGhlcl9zZXRrZXkoZXNzaXYtPnRmbSwgZXNzaXYtPnNhbHQsCisJZm9yX2VhY2hfcG9zc2libGVfY3B1KGNwdSkgeworCQllc3Npdl90Zm0gPSBwZXJfY3B1X3B0cihjYy0+Y3B1LCBjcHUpLT5pdl9wcml2YXRlLAorCisJCWVyciA9IGNyeXB0b19jaXBoZXJfc2V0a2V5KGVzc2l2X3RmbSwgZXNzaXYtPnNhbHQsCiAJCQkJICAgIGNyeXB0b19oYXNoX2RpZ2VzdHNpemUoZXNzaXYtPmhhc2hfdGZtKSk7CisJCWlmIChlcnIpCisJCQlyZXR1cm4gZXJyOworCX0KKworCXJldHVybiAwOwogfQogCiAvKiBXaXBlIHNhbHQgYW5kIHJlc2V0IGtleSBkZXJpdmVkIGZyb20gdm9sdW1lIGtleSAqLwpAQCAtMjE0LDI0ICsyODcsNzYgQEAKIHsKIAlzdHJ1Y3QgaXZfZXNzaXZfcHJpdmF0ZSAqZXNzaXYgPSAmY2MtPml2X2dlbl9wcml2YXRlLmVzc2l2OwogCXVuc2lnbmVkIHNhbHRfc2l6ZSA9IGNyeXB0b19oYXNoX2RpZ2VzdHNpemUoZXNzaXYtPmhhc2hfdGZtKTsKKwlzdHJ1Y3QgY3J5cHRvX2NpcGhlciAqZXNzaXZfdGZtOworCWludCBjcHUsIHIsIGVyciA9IDA7CiAKIAltZW1zZXQoZXNzaXYtPnNhbHQsIDAsIHNhbHRfc2l6ZSk7CiAKLQlyZXR1cm4gY3J5cHRvX2NpcGhlcl9zZXRrZXkoZXNzaXYtPnRmbSwgZXNzaXYtPnNhbHQsIHNhbHRfc2l6ZSk7CisJZm9yX2VhY2hfcG9zc2libGVfY3B1KGNwdSkgeworCQllc3Npdl90Zm0gPSBwZXJfY3B1X3B0cihjYy0+Y3B1LCBjcHUpLT5pdl9wcml2YXRlOworCQlyID0gY3J5cHRvX2NpcGhlcl9zZXRrZXkoZXNzaXZfdGZtLCBlc3Npdi0+c2FsdCwgc2FsdF9zaXplKTsKKwkJaWYgKHIpCisJCQllcnIgPSByOworCX0KKworCXJldHVybiBlcnI7Cit9CisKKy8qIFNldCB1cCBwZXIgY3B1IGNpcGhlciBzdGF0ZSAqLworc3RhdGljIHN0cnVjdCBjcnlwdG9fY2lwaGVyICpzZXR1cF9lc3Npdl9jcHUoc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MsCisJCQkJCSAgICAgc3RydWN0IGRtX3RhcmdldCAqdGksCisJCQkJCSAgICAgdTggKnNhbHQsIHVuc2lnbmVkIHNhbHRzaXplKQoreworCXN0cnVjdCBjcnlwdG9fY2lwaGVyICplc3Npdl90Zm07CisJaW50IGVycjsKKworCS8qIFNldHVwIHRoZSBlc3Npdl90Zm0gd2l0aCB0aGUgZ2l2ZW4gc2FsdCAqLworCWVzc2l2X3RmbSA9IGNyeXB0b19hbGxvY19jaXBoZXIoY2MtPmNpcGhlciwgMCwgQ1JZUFRPX0FMR19BU1lOQyk7CisJaWYgKElTX0VSUihlc3Npdl90Zm0pKSB7CisJCXRpLT5lcnJvciA9ICJFcnJvciBhbGxvY2F0aW5nIGNyeXB0byB0Zm0gZm9yIEVTU0lWIjsKKwkJcmV0dXJuIGVzc2l2X3RmbTsKKwl9CisKKwlpZiAoY3J5cHRvX2NpcGhlcl9ibG9ja3NpemUoZXNzaXZfdGZtKSAhPQorCSAgICBjcnlwdG9fYWJsa2NpcGhlcl9pdnNpemUoYW55X3RmbShjYykpKSB7CisJCXRpLT5lcnJvciA9ICJCbG9jayBzaXplIG9mIEVTU0lWIGNpcGhlciBkb2VzICIKKwkJCSAgICAibm90IG1hdGNoIElWIHNpemUgb2YgYmxvY2sgY2lwaGVyIjsKKwkJY3J5cHRvX2ZyZWVfY2lwaGVyKGVzc2l2X3RmbSk7CisJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCX0KKworCWVyciA9IGNyeXB0b19jaXBoZXJfc2V0a2V5KGVzc2l2X3RmbSwgc2FsdCwgc2FsdHNpemUpOworCWlmIChlcnIpIHsKKwkJdGktPmVycm9yID0gIkZhaWxlZCB0byBzZXQga2V5IGZvciBFU1NJViBjaXBoZXIiOworCQljcnlwdG9fZnJlZV9jaXBoZXIoZXNzaXZfdGZtKTsKKwkJcmV0dXJuIEVSUl9QVFIoZXJyKTsKKwl9CisKKwlyZXR1cm4gZXNzaXZfdGZtOwogfQogCiBzdGF0aWMgdm9pZCBjcnlwdF9pdl9lc3Npdl9kdHIoc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MpCiB7CisJaW50IGNwdTsKKwlzdHJ1Y3QgY3J5cHRfY3B1ICpjcHVfY2M7CisJc3RydWN0IGNyeXB0b19jaXBoZXIgKmVzc2l2X3RmbTsKIAlzdHJ1Y3QgaXZfZXNzaXZfcHJpdmF0ZSAqZXNzaXYgPSAmY2MtPml2X2dlbl9wcml2YXRlLmVzc2l2OwogCi0JY3J5cHRvX2ZyZWVfY2lwaGVyKGVzc2l2LT50Zm0pOwotCWVzc2l2LT50Zm0gPSBOVUxMOwotCiAJY3J5cHRvX2ZyZWVfaGFzaChlc3Npdi0+aGFzaF90Zm0pOwogCWVzc2l2LT5oYXNoX3RmbSA9IE5VTEw7CiAKIAlremZyZWUoZXNzaXYtPnNhbHQpOwogCWVzc2l2LT5zYWx0ID0gTlVMTDsKKworCWZvcl9lYWNoX3Bvc3NpYmxlX2NwdShjcHUpIHsKKwkJY3B1X2NjID0gcGVyX2NwdV9wdHIoY2MtPmNwdSwgY3B1KTsKKwkJZXNzaXZfdGZtID0gY3B1X2NjLT5pdl9wcml2YXRlOworCisJCWlmIChlc3Npdl90Zm0pCisJCQljcnlwdG9fZnJlZV9jaXBoZXIoZXNzaXZfdGZtKTsKKworCQljcHVfY2MtPml2X3ByaXZhdGUgPSBOVUxMOworCX0KIH0KIAogc3RhdGljIGludCBjcnlwdF9pdl9lc3Npdl9jdHIoc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MsIHN0cnVjdCBkbV90YXJnZXQgKnRpLApAQCAtMjQwLDcgKzM2NSw3IEBACiAJc3RydWN0IGNyeXB0b19jaXBoZXIgKmVzc2l2X3RmbSA9IE5VTEw7CiAJc3RydWN0IGNyeXB0b19oYXNoICpoYXNoX3RmbSA9IE5VTEw7CiAJdTggKnNhbHQgPSBOVUxMOwotCWludCBlcnI7CisJaW50IGVyciwgY3B1OwogCiAJaWYgKCFvcHRzKSB7CiAJCXRpLT5lcnJvciA9ICJEaWdlc3QgYWxnb3JpdGhtIG1pc3NpbmcgZm9yIEVTU0lWIG1vZGUiOwpAQCAtMjYyLDQ4ICszODcsNDQgQEAKIAkJZ290byBiYWQ7CiAJfQogCi0JLyogQWxsb2NhdGUgZXNzaXZfdGZtICovCi0JZXNzaXZfdGZtID0gY3J5cHRvX2FsbG9jX2NpcGhlcihjYy0+Y2lwaGVyLCAwLCBDUllQVE9fQUxHX0FTWU5DKTsKLQlpZiAoSVNfRVJSKGVzc2l2X3RmbSkpIHsKLQkJdGktPmVycm9yID0gIkVycm9yIGFsbG9jYXRpbmcgY3J5cHRvIHRmbSBmb3IgRVNTSVYiOwotCQllcnIgPSBQVFJfRVJSKGVzc2l2X3RmbSk7Ci0JCWdvdG8gYmFkOwotCX0KLQlpZiAoY3J5cHRvX2NpcGhlcl9ibG9ja3NpemUoZXNzaXZfdGZtKSAhPQotCSAgICBjcnlwdG9fYWJsa2NpcGhlcl9pdnNpemUoY2MtPnRmbSkpIHsKLQkJdGktPmVycm9yID0gIkJsb2NrIHNpemUgb2YgRVNTSVYgY2lwaGVyIGRvZXMgIgotCQkJICAgICJub3QgbWF0Y2ggSVYgc2l6ZSBvZiBibG9jayBjaXBoZXIiOwotCQllcnIgPSAtRUlOVkFMOwotCQlnb3RvIGJhZDsKLQl9Ci0KIAljYy0+aXZfZ2VuX3ByaXZhdGUuZXNzaXYuc2FsdCA9IHNhbHQ7Ci0JY2MtPml2X2dlbl9wcml2YXRlLmVzc2l2LnRmbSA9IGVzc2l2X3RmbTsKIAljYy0+aXZfZ2VuX3ByaXZhdGUuZXNzaXYuaGFzaF90Zm0gPSBoYXNoX3RmbTsKIAorCWZvcl9lYWNoX3Bvc3NpYmxlX2NwdShjcHUpIHsKKwkJZXNzaXZfdGZtID0gc2V0dXBfZXNzaXZfY3B1KGNjLCB0aSwgc2FsdCwKKwkJCQkJY3J5cHRvX2hhc2hfZGlnZXN0c2l6ZShoYXNoX3RmbSkpOworCQlpZiAoSVNfRVJSKGVzc2l2X3RmbSkpIHsKKwkJCWNyeXB0X2l2X2Vzc2l2X2R0cihjYyk7CisJCQlyZXR1cm4gUFRSX0VSUihlc3Npdl90Zm0pOworCQl9CisJCXBlcl9jcHVfcHRyKGNjLT5jcHUsIGNwdSktPml2X3ByaXZhdGUgPSBlc3Npdl90Zm07CisJfQorCiAJcmV0dXJuIDA7CiAKIGJhZDoKLQlpZiAoZXNzaXZfdGZtICYmICFJU19FUlIoZXNzaXZfdGZtKSkKLQkJY3J5cHRvX2ZyZWVfY2lwaGVyKGVzc2l2X3RmbSk7CiAJaWYgKGhhc2hfdGZtICYmICFJU19FUlIoaGFzaF90Zm0pKQogCQljcnlwdG9fZnJlZV9oYXNoKGhhc2hfdGZtKTsKIAlrZnJlZShzYWx0KTsKIAlyZXR1cm4gZXJyOwogfQogCi1zdGF0aWMgaW50IGNyeXB0X2l2X2Vzc2l2X2dlbihzdHJ1Y3QgY3J5cHRfY29uZmlnICpjYywgdTggKml2LCBzZWN0b3JfdCBzZWN0b3IpCitzdGF0aWMgaW50IGNyeXB0X2l2X2Vzc2l2X2dlbihzdHJ1Y3QgY3J5cHRfY29uZmlnICpjYywgdTggKml2LAorCQkJICAgICAgc3RydWN0IGRtX2NyeXB0X3JlcXVlc3QgKmRtcmVxKQogeworCXN0cnVjdCBjcnlwdG9fY2lwaGVyICplc3Npdl90Zm0gPSB0aGlzX2NyeXB0X2NvbmZpZyhjYyktPml2X3ByaXZhdGU7CisKIAltZW1zZXQoaXYsIDAsIGNjLT5pdl9zaXplKTsKLQkqKHU2NCAqKWl2ID0gY3B1X3RvX2xlNjQoc2VjdG9yKTsKLQljcnlwdG9fY2lwaGVyX2VuY3J5cHRfb25lKGNjLT5pdl9nZW5fcHJpdmF0ZS5lc3Npdi50Zm0sIGl2LCBpdik7CisJKih1NjQgKilpdiA9IGNwdV90b19sZTY0KGRtcmVxLT5pdl9zZWN0b3IpOworCWNyeXB0b19jaXBoZXJfZW5jcnlwdF9vbmUoZXNzaXZfdGZtLCBpdiwgaXYpOworCiAJcmV0dXJuIDA7CiB9CiAKIHN0YXRpYyBpbnQgY3J5cHRfaXZfYmVuYmlfY3RyKHN0cnVjdCBjcnlwdF9jb25maWcgKmNjLCBzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwKIAkJCSAgICAgIGNvbnN0IGNoYXIgKm9wdHMpCiB7Ci0JdW5zaWduZWQgYnMgPSBjcnlwdG9fYWJsa2NpcGhlcl9ibG9ja3NpemUoY2MtPnRmbSk7CisJdW5zaWduZWQgYnMgPSBjcnlwdG9fYWJsa2NpcGhlcl9ibG9ja3NpemUoYW55X3RmbShjYykpOwogCWludCBsb2cgPSBpbG9nMihicyk7CiAKIAkvKiB3ZSBuZWVkIHRvIGNhbGN1bGF0ZSBob3cgZmFyIHdlIG11c3Qgc2hpZnQgdGhlIHNlY3RvciBjb3VudApAQCAtMzI4LDI1ICs0NDksMTc3IEBACiB7CiB9CiAKLXN0YXRpYyBpbnQgY3J5cHRfaXZfYmVuYmlfZ2VuKHN0cnVjdCBjcnlwdF9jb25maWcgKmNjLCB1OCAqaXYsIHNlY3Rvcl90IHNlY3RvcikKK3N0YXRpYyBpbnQgY3J5cHRfaXZfYmVuYmlfZ2VuKHN0cnVjdCBjcnlwdF9jb25maWcgKmNjLCB1OCAqaXYsCisJCQkgICAgICBzdHJ1Y3QgZG1fY3J5cHRfcmVxdWVzdCAqZG1yZXEpCiB7CiAJX19iZTY0IHZhbDsKIAogCW1lbXNldChpdiwgMCwgY2MtPml2X3NpemUgLSBzaXplb2YodTY0KSk7IC8qIHJlc3QgaXMgY2xlYXJlZCBiZWxvdyAqLwogCi0JdmFsID0gY3B1X3RvX2JlNjQoKCh1NjQpc2VjdG9yIDw8IGNjLT5pdl9nZW5fcHJpdmF0ZS5iZW5iaS5zaGlmdCkgKyAxKTsKKwl2YWwgPSBjcHVfdG9fYmU2NCgoKHU2NClkbXJlcS0+aXZfc2VjdG9yIDw8IGNjLT5pdl9nZW5fcHJpdmF0ZS5iZW5iaS5zaGlmdCkgKyAxKTsKIAlwdXRfdW5hbGlnbmVkKHZhbCwgKF9fYmU2NCAqKShpdiArIGNjLT5pdl9zaXplIC0gc2l6ZW9mKHU2NCkpKTsKIAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IGNyeXB0X2l2X251bGxfZ2VuKHN0cnVjdCBjcnlwdF9jb25maWcgKmNjLCB1OCAqaXYsIHNlY3Rvcl90IHNlY3RvcikKK3N0YXRpYyBpbnQgY3J5cHRfaXZfbnVsbF9nZW4oc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MsIHU4ICppdiwKKwkJCSAgICAgc3RydWN0IGRtX2NyeXB0X3JlcXVlc3QgKmRtcmVxKQogewogCW1lbXNldChpdiwgMCwgY2MtPml2X3NpemUpOwogCiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyB2b2lkIGNyeXB0X2l2X2xta19kdHIoc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MpCit7CisJc3RydWN0IGl2X2xta19wcml2YXRlICpsbWsgPSAmY2MtPml2X2dlbl9wcml2YXRlLmxtazsKKworCWlmIChsbWstPmhhc2hfdGZtICYmICFJU19FUlIobG1rLT5oYXNoX3RmbSkpCisJCWNyeXB0b19mcmVlX3NoYXNoKGxtay0+aGFzaF90Zm0pOworCWxtay0+aGFzaF90Zm0gPSBOVUxMOworCisJa3pmcmVlKGxtay0+c2VlZCk7CisJbG1rLT5zZWVkID0gTlVMTDsKK30KKworc3RhdGljIGludCBjcnlwdF9pdl9sbWtfY3RyKHN0cnVjdCBjcnlwdF9jb25maWcgKmNjLCBzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwKKwkJCSAgICBjb25zdCBjaGFyICpvcHRzKQoreworCXN0cnVjdCBpdl9sbWtfcHJpdmF0ZSAqbG1rID0gJmNjLT5pdl9nZW5fcHJpdmF0ZS5sbWs7CisKKwlsbWstPmhhc2hfdGZtID0gY3J5cHRvX2FsbG9jX3NoYXNoKCJtZDUiLCAwLCAwKTsKKwlpZiAoSVNfRVJSKGxtay0+aGFzaF90Zm0pKSB7CisJCXRpLT5lcnJvciA9ICJFcnJvciBpbml0aWFsaXppbmcgTE1LIGhhc2giOworCQlyZXR1cm4gUFRSX0VSUihsbWstPmhhc2hfdGZtKTsKKwl9CisKKwkvKiBObyBzZWVkIGluIExNSyB2ZXJzaW9uIDIgKi8KKwlpZiAoY2MtPmtleV9wYXJ0cyA9PSBjYy0+dGZtc19jb3VudCkgeworCQlsbWstPnNlZWQgPSBOVUxMOworCQlyZXR1cm4gMDsKKwl9CisKKwlsbWstPnNlZWQgPSBremFsbG9jKExNS19TRUVEX1NJWkUsIEdGUF9LRVJORUwpOworCWlmICghbG1rLT5zZWVkKSB7CisJCWNyeXB0X2l2X2xta19kdHIoY2MpOworCQl0aS0+ZXJyb3IgPSAiRXJyb3Iga21hbGxvY2luZyBzZWVkIHN0b3JhZ2UgaW4gTE1LIjsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgY3J5cHRfaXZfbG1rX2luaXQoc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MpCit7CisJc3RydWN0IGl2X2xta19wcml2YXRlICpsbWsgPSAmY2MtPml2X2dlbl9wcml2YXRlLmxtazsKKwlpbnQgc3Via2V5X3NpemUgPSBjYy0+a2V5X3NpemUgLyBjYy0+a2V5X3BhcnRzOworCisJLyogTE1LIHNlZWQgaXMgb24gdGhlIHBvc2l0aW9uIG9mIExNS19LRVlTICsgMSBrZXkgKi8KKwlpZiAobG1rLT5zZWVkKQorCQltZW1jcHkobG1rLT5zZWVkLCBjYy0+a2V5ICsgKGNjLT50Zm1zX2NvdW50ICogc3Via2V5X3NpemUpLAorCQkgICAgICAgY3J5cHRvX3NoYXNoX2RpZ2VzdHNpemUobG1rLT5oYXNoX3RmbSkpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgY3J5cHRfaXZfbG1rX3dpcGUoc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MpCit7CisJc3RydWN0IGl2X2xta19wcml2YXRlICpsbWsgPSAmY2MtPml2X2dlbl9wcml2YXRlLmxtazsKKworCWlmIChsbWstPnNlZWQpCisJCW1lbXNldChsbWstPnNlZWQsIDAsIExNS19TRUVEX1NJWkUpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgY3J5cHRfaXZfbG1rX29uZShzdHJ1Y3QgY3J5cHRfY29uZmlnICpjYywgdTggKml2LAorCQkJICAgIHN0cnVjdCBkbV9jcnlwdF9yZXF1ZXN0ICpkbXJlcSwKKwkJCSAgICB1OCAqZGF0YSkKK3sKKwlzdHJ1Y3QgaXZfbG1rX3ByaXZhdGUgKmxtayA9ICZjYy0+aXZfZ2VuX3ByaXZhdGUubG1rOworCXN0cnVjdCB7CisJCXN0cnVjdCBzaGFzaF9kZXNjIGRlc2M7CisJCWNoYXIgY3R4W2NyeXB0b19zaGFzaF9kZXNjc2l6ZShsbWstPmhhc2hfdGZtKV07CisJfSBzZGVzYzsKKwlzdHJ1Y3QgbWQ1X3N0YXRlIG1kNXN0YXRlOworCXUzMiBidWZbNF07CisJaW50IGksIHI7CisKKwlzZGVzYy5kZXNjLnRmbSA9IGxtay0+aGFzaF90Zm07CisJc2Rlc2MuZGVzYy5mbGFncyA9IENSWVBUT19URk1fUkVRX01BWV9TTEVFUDsKKworCXIgPSBjcnlwdG9fc2hhc2hfaW5pdCgmc2Rlc2MuZGVzYyk7CisJaWYgKHIpCisJCXJldHVybiByOworCisJaWYgKGxtay0+c2VlZCkgeworCQlyID0gY3J5cHRvX3NoYXNoX3VwZGF0ZSgmc2Rlc2MuZGVzYywgbG1rLT5zZWVkLCBMTUtfU0VFRF9TSVpFKTsKKwkJaWYgKHIpCisJCQlyZXR1cm4gcjsKKwl9CisKKwkvKiBTZWN0b3IgaXMgYWx3YXlzIDUxMkIsIGJsb2NrIHNpemUgMTYsIGFkZCBkYXRhIG9mIGJsb2NrcyAxLTMxICovCisJciA9IGNyeXB0b19zaGFzaF91cGRhdGUoJnNkZXNjLmRlc2MsIGRhdGEgKyAxNiwgMTYgKiAzMSk7CisJaWYgKHIpCisJCXJldHVybiByOworCisJLyogU2VjdG9yIGlzIGNyb3BwZWQgdG8gNTYgYml0cyBoZXJlICovCisJYnVmWzBdID0gY3B1X3RvX2xlMzIoZG1yZXEtPml2X3NlY3RvciAmIDB4RkZGRkZGRkYpOworCWJ1ZlsxXSA9IGNwdV90b19sZTMyKCgoKHU2NClkbXJlcS0+aXZfc2VjdG9yID4+IDMyKSAmIDB4MDBGRkZGRkYpIHwgMHg4MDAwMDAwMCk7CisJYnVmWzJdID0gY3B1X3RvX2xlMzIoNDAyNCk7CisJYnVmWzNdID0gMDsKKwlyID0gY3J5cHRvX3NoYXNoX3VwZGF0ZSgmc2Rlc2MuZGVzYywgKHU4ICopYnVmLCBzaXplb2YoYnVmKSk7CisJaWYgKHIpCisJCXJldHVybiByOworCisJLyogTm8gTUQ1IHBhZGRpbmcgaGVyZSAqLworCXIgPSBjcnlwdG9fc2hhc2hfZXhwb3J0KCZzZGVzYy5kZXNjLCAmbWQ1c3RhdGUpOworCWlmIChyKQorCQlyZXR1cm4gcjsKKworCWZvciAoaSA9IDA7IGkgPCBNRDVfSEFTSF9XT1JEUzsgaSsrKQorCQlfX2NwdV90b19sZTMycygmbWQ1c3RhdGUuaGFzaFtpXSk7CisJbWVtY3B5KGl2LCAmbWQ1c3RhdGUuaGFzaCwgY2MtPml2X3NpemUpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgY3J5cHRfaXZfbG1rX2dlbihzdHJ1Y3QgY3J5cHRfY29uZmlnICpjYywgdTggKml2LAorCQkJICAgIHN0cnVjdCBkbV9jcnlwdF9yZXF1ZXN0ICpkbXJlcSkKK3sKKwl1OCAqc3JjOworCWludCByID0gMDsKKworCWlmIChiaW9fZGF0YV9kaXIoZG1yZXEtPmN0eC0+YmlvX2luKSA9PSBXUklURSkgeworCQlzcmMgPSBrbWFwX2F0b21pYyhzZ19wYWdlKCZkbXJlcS0+c2dfaW4pLCBLTV9VU0VSMCk7CisJCXIgPSBjcnlwdF9pdl9sbWtfb25lKGNjLCBpdiwgZG1yZXEsIHNyYyArIGRtcmVxLT5zZ19pbi5vZmZzZXQpOworCQlrdW5tYXBfYXRvbWljKHNyYywgS01fVVNFUjApOworCX0gZWxzZQorCQltZW1zZXQoaXYsIDAsIGNjLT5pdl9zaXplKTsKKworCXJldHVybiByOworfQorCitzdGF0aWMgaW50IGNyeXB0X2l2X2xta19wb3N0KHN0cnVjdCBjcnlwdF9jb25maWcgKmNjLCB1OCAqaXYsCisJCQkgICAgIHN0cnVjdCBkbV9jcnlwdF9yZXF1ZXN0ICpkbXJlcSkKK3sKKwl1OCAqZHN0OworCWludCByOworCisJaWYgKGJpb19kYXRhX2RpcihkbXJlcS0+Y3R4LT5iaW9faW4pID09IFdSSVRFKQorCQlyZXR1cm4gMDsKKworCWRzdCA9IGttYXBfYXRvbWljKHNnX3BhZ2UoJmRtcmVxLT5zZ19vdXQpLCBLTV9VU0VSMCk7CisJciA9IGNyeXB0X2l2X2xta19vbmUoY2MsIGl2LCBkbXJlcSwgZHN0ICsgZG1yZXEtPnNnX291dC5vZmZzZXQpOworCisJLyogVHdlYWsgdGhlIGZpcnN0IGJsb2NrIG9mIHBsYWludGV4dCBzZWN0b3IgKi8KKwlpZiAoIXIpCisJCWNyeXB0b194b3IoZHN0ICsgZG1yZXEtPnNnX291dC5vZmZzZXQsIGl2LCBjYy0+aXZfc2l6ZSk7CisKKwlrdW5tYXBfYXRvbWljKGRzdCwgS01fVVNFUjApOworCXJldHVybiByOworfQorCiBzdGF0aWMgc3RydWN0IGNyeXB0X2l2X29wZXJhdGlvbnMgY3J5cHRfaXZfcGxhaW5fb3BzID0gewogCS5nZW5lcmF0b3IgPSBjcnlwdF9pdl9wbGFpbl9nZW4KIH07CkBAIC0zNzMsNiArNjQ2LDE1IEBACiAJLmdlbmVyYXRvciA9IGNyeXB0X2l2X251bGxfZ2VuCiB9OwogCitzdGF0aWMgc3RydWN0IGNyeXB0X2l2X29wZXJhdGlvbnMgY3J5cHRfaXZfbG1rX29wcyA9IHsKKwkuY3RyCSAgID0gY3J5cHRfaXZfbG1rX2N0ciwKKwkuZHRyCSAgID0gY3J5cHRfaXZfbG1rX2R0ciwKKwkuaW5pdAkgICA9IGNyeXB0X2l2X2xta19pbml0LAorCS53aXBlCSAgID0gY3J5cHRfaXZfbG1rX3dpcGUsCisJLmdlbmVyYXRvciA9IGNyeXB0X2l2X2xta19nZW4sCisJLnBvc3QJICAgPSBjcnlwdF9pdl9sbWtfcG9zdAorfTsKKwogc3RhdGljIHZvaWQgY3J5cHRfY29udmVydF9pbml0KHN0cnVjdCBjcnlwdF9jb25maWcgKmNjLAogCQkJICAgICAgIHN0cnVjdCBjb252ZXJ0X2NvbnRleHQgKmN0eCwKIAkJCSAgICAgICBzdHJ1Y3QgYmlvICpiaW9fb3V0LCBzdHJ1Y3QgYmlvICpiaW9faW4sCkBAIC00MDAsNiArNjgyLDEzIEBACiAJcmV0dXJuIChzdHJ1Y3QgYWJsa2NpcGhlcl9yZXF1ZXN0ICopKChjaGFyICopZG1yZXEgLSBjYy0+ZG1yZXFfc3RhcnQpOwogfQogCitzdGF0aWMgdTggKml2X29mX2RtcmVxKHN0cnVjdCBjcnlwdF9jb25maWcgKmNjLAorCQkgICAgICAgc3RydWN0IGRtX2NyeXB0X3JlcXVlc3QgKmRtcmVxKQoreworCXJldHVybiAodTggKilBTElHTigodW5zaWduZWQgbG9uZykoZG1yZXEgKyAxKSwKKwkJY3J5cHRvX2FibGtjaXBoZXJfYWxpZ25tYXNrKGFueV90Zm0oY2MpKSArIDEpOworfQorCiBzdGF0aWMgaW50IGNyeXB0X2NvbnZlcnRfYmxvY2soc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MsCiAJCQkgICAgICAgc3RydWN0IGNvbnZlcnRfY29udGV4dCAqY3R4LAogCQkJICAgICAgIHN0cnVjdCBhYmxrY2lwaGVyX3JlcXVlc3QgKnJlcSkKQEAgLTQxMSw5ICs3MDAsOSBAQAogCWludCByID0gMDsKIAogCWRtcmVxID0gZG1yZXFfb2ZfcmVxKGNjLCByZXEpOwotCWl2ID0gKHU4ICopQUxJR04oKHVuc2lnbmVkIGxvbmcpKGRtcmVxICsgMSksCi0JCQkgY3J5cHRvX2FibGtjaXBoZXJfYWxpZ25tYXNrKGNjLT50Zm0pICsgMSk7CisJaXYgPSBpdl9vZl9kbXJlcShjYywgZG1yZXEpOwogCisJZG1yZXEtPml2X3NlY3RvciA9IGN0eC0+c2VjdG9yOwogCWRtcmVxLT5jdHggPSBjdHg7CiAJc2dfaW5pdF90YWJsZSgmZG1yZXEtPnNnX2luLCAxKTsKIAlzZ19zZXRfcGFnZSgmZG1yZXEtPnNnX2luLCBidl9pbi0+YnZfcGFnZSwgMSA8PCBTRUNUT1JfU0hJRlQsCkBAIC00MzYsNyArNzI1LDcgQEAKIAl9CiAKIAlpZiAoY2MtPml2X2dlbl9vcHMpIHsKLQkJciA9IGNjLT5pdl9nZW5fb3BzLT5nZW5lcmF0b3IoY2MsIGl2LCBjdHgtPnNlY3Rvcik7CisJCXIgPSBjYy0+aXZfZ2VuX29wcy0+Z2VuZXJhdG9yKGNjLCBpdiwgZG1yZXEpOwogCQlpZiAociA8IDApCiAJCQlyZXR1cm4gcjsKIAl9CkBAIC00NDksMjEgKzczOCwyOCBAQAogCWVsc2UKIAkJciA9IGNyeXB0b19hYmxrY2lwaGVyX2RlY3J5cHQocmVxKTsKIAorCWlmICghciAmJiBjYy0+aXZfZ2VuX29wcyAmJiBjYy0+aXZfZ2VuX29wcy0+cG9zdCkKKwkJciA9IGNjLT5pdl9nZW5fb3BzLT5wb3N0KGNjLCBpdiwgZG1yZXEpOworCiAJcmV0dXJuIHI7CiB9CiAKIHN0YXRpYyB2b2lkIGtjcnlwdGRfYXN5bmNfZG9uZShzdHJ1Y3QgY3J5cHRvX2FzeW5jX3JlcXVlc3QgKmFzeW5jX3JlcSwKIAkJCSAgICAgICBpbnQgZXJyb3IpOworCiBzdGF0aWMgdm9pZCBjcnlwdF9hbGxvY19yZXEoc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MsCiAJCQkgICAgc3RydWN0IGNvbnZlcnRfY29udGV4dCAqY3R4KQogewotCWlmICghY2MtPnJlcSkKLQkJY2MtPnJlcSA9IG1lbXBvb2xfYWxsb2MoY2MtPnJlcV9wb29sLCBHRlBfTk9JTyk7Ci0JYWJsa2NpcGhlcl9yZXF1ZXN0X3NldF90Zm0oY2MtPnJlcSwgY2MtPnRmbSk7Ci0JYWJsa2NpcGhlcl9yZXF1ZXN0X3NldF9jYWxsYmFjayhjYy0+cmVxLCBDUllQVE9fVEZNX1JFUV9NQVlfQkFDS0xPRyB8Ci0JCQkJCUNSWVBUT19URk1fUkVRX01BWV9TTEVFUCwKLQkJCQkJa2NyeXB0ZF9hc3luY19kb25lLAotCQkJCQlkbXJlcV9vZl9yZXEoY2MsIGNjLT5yZXEpKTsKKwlzdHJ1Y3QgY3J5cHRfY3B1ICp0aGlzX2NjID0gdGhpc19jcnlwdF9jb25maWcoY2MpOworCXVuc2lnbmVkIGtleV9pbmRleCA9IGN0eC0+c2VjdG9yICYgKGNjLT50Zm1zX2NvdW50IC0gMSk7CisKKwlpZiAoIXRoaXNfY2MtPnJlcSkKKwkJdGhpc19jYy0+cmVxID0gbWVtcG9vbF9hbGxvYyhjYy0+cmVxX3Bvb2wsIEdGUF9OT0lPKTsKKworCWFibGtjaXBoZXJfcmVxdWVzdF9zZXRfdGZtKHRoaXNfY2MtPnJlcSwgdGhpc19jYy0+dGZtc1trZXlfaW5kZXhdKTsKKwlhYmxrY2lwaGVyX3JlcXVlc3Rfc2V0X2NhbGxiYWNrKHRoaXNfY2MtPnJlcSwKKwkgICAgQ1JZUFRPX1RGTV9SRVFfTUFZX0JBQ0tMT0cgfCBDUllQVE9fVEZNX1JFUV9NQVlfU0xFRVAsCisJICAgIGtjcnlwdGRfYXN5bmNfZG9uZSwgZG1yZXFfb2ZfcmVxKGNjLCB0aGlzX2NjLT5yZXEpKTsKIH0KIAogLyoKQEAgLTQ3Miw2ICs3NjgsNyBAQAogc3RhdGljIGludCBjcnlwdF9jb252ZXJ0KHN0cnVjdCBjcnlwdF9jb25maWcgKmNjLAogCQkJIHN0cnVjdCBjb252ZXJ0X2NvbnRleHQgKmN0eCkKIHsKKwlzdHJ1Y3QgY3J5cHRfY3B1ICp0aGlzX2NjID0gdGhpc19jcnlwdF9jb25maWcoY2MpOwogCWludCByOwogCiAJYXRvbWljX3NldCgmY3R4LT5wZW5kaW5nLCAxKTsKQEAgLTQ4Myw3ICs3ODAsNyBAQAogCiAJCWF0b21pY19pbmMoJmN0eC0+cGVuZGluZyk7CiAKLQkJciA9IGNyeXB0X2NvbnZlcnRfYmxvY2soY2MsIGN0eCwgY2MtPnJlcSk7CisJCXIgPSBjcnlwdF9jb252ZXJ0X2Jsb2NrKGNjLCBjdHgsIHRoaXNfY2MtPnJlcSk7CiAKIAkJc3dpdGNoIChyKSB7CiAJCS8qIGFzeW5jICovCkBAIC00OTIsNyArNzg5LDcgQEAKIAkJCUlOSVRfQ09NUExFVElPTihjdHgtPnJlc3RhcnQpOwogCQkJLyogZmFsbCB0aHJvdWdoKi8KIAkJY2FzZSAtRUlOUFJPR1JFU1M6Ci0JCQljYy0+cmVxID0gTlVMTDsKKwkJCXRoaXNfY2MtPnJlcSA9IE5VTEw7CiAJCQljdHgtPnNlY3RvcisrOwogCQkJY29udGludWU7CiAKQEAgLTY1MSw2ICs5NDgsOSBAQAogICogVGhleSBtdXN0IGJlIHNlcGFyYXRlZCBhcyBvdGhlcndpc2UgdGhlIGZpbmFsIHN0YWdlcyBjb3VsZCBiZQogICogc3RhcnZlZCBieSBuZXcgcmVxdWVzdHMgd2hpY2ggY2FuIGJsb2NrIGluIHRoZSBmaXJzdCBzdGFnZXMgZHVlCiAgKiB0byBtZW1vcnkgYWxsb2NhdGlvbi4KKyAqCisgKiBUaGUgd29yayBpcyBkb25lIHBlciBDUFUgZ2xvYmFsIGZvciBhbGwgZG0tY3J5cHQgaW5zdGFuY2VzLgorICogVGhleSBzaG91bGQgbm90IGRlcGVuZCBvbiBlYWNoIG90aGVyIGFuZCBkbyBub3QgYmxvY2suCiAgKi8KIHN0YXRpYyB2b2lkIGNyeXB0X2VuZGlvKHN0cnVjdCBiaW8gKmNsb25lLCBpbnQgZXJyb3IpCiB7CkBAIC02OTEsMjYgKzk5MSwzMCBAQAogCWNsb25lLT5iaV9kZXN0cnVjdG9yID0gZG1fY3J5cHRfYmlvX2Rlc3RydWN0b3I7CiB9CiAKLXN0YXRpYyB2b2lkIGtjcnlwdGRfaW9fcmVhZChzdHJ1Y3QgZG1fY3J5cHRfaW8gKmlvKQorc3RhdGljIHZvaWQga2NyeXB0ZF91bnBsdWcoc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MpCit7CisJYmxrX3VucGx1ZyhiZGV2X2dldF9xdWV1ZShjYy0+ZGV2LT5iZGV2KSk7Cit9CisKK3N0YXRpYyBpbnQga2NyeXB0ZF9pb19yZWFkKHN0cnVjdCBkbV9jcnlwdF9pbyAqaW8sIGdmcF90IGdmcCkKIHsKIAlzdHJ1Y3QgY3J5cHRfY29uZmlnICpjYyA9IGlvLT50YXJnZXQtPnByaXZhdGU7CiAJc3RydWN0IGJpbyAqYmFzZV9iaW8gPSBpby0+YmFzZV9iaW87CiAJc3RydWN0IGJpbyAqY2xvbmU7CiAKLQljcnlwdF9pbmNfcGVuZGluZyhpbyk7Ci0KIAkvKgogCSAqIFRoZSBibG9jayBsYXllciBtaWdodCBtb2RpZnkgdGhlIGJ2ZWMgYXJyYXksIHNvIGFsd2F5cwogCSAqIGNvcHkgdGhlIHJlcXVpcmVkIGJ2ZWNzIGJlY2F1c2Ugd2UgbmVlZCB0aGUgb3JpZ2luYWwKIAkgKiBvbmUgaW4gb3JkZXIgdG8gZGVjcnlwdCB0aGUgd2hvbGUgYmlvIGRhdGEgKmFmdGVyd2FyZHMqLgogCSAqLwotCWNsb25lID0gYmlvX2FsbG9jX2Jpb3NldChHRlBfTk9JTywgYmlvX3NlZ21lbnRzKGJhc2VfYmlvKSwgY2MtPmJzKTsKLQlpZiAodW5saWtlbHkoIWNsb25lKSkgewotCQlpby0+ZXJyb3IgPSAtRU5PTUVNOwotCQljcnlwdF9kZWNfcGVuZGluZyhpbyk7Ci0JCXJldHVybjsKKwljbG9uZSA9IGJpb19hbGxvY19iaW9zZXQoZ2ZwLCBiaW9fc2VnbWVudHMoYmFzZV9iaW8pLCBjYy0+YnMpOworCWlmICghY2xvbmUpIHsKKwkJa2NyeXB0ZF91bnBsdWcoY2MpOworCQlyZXR1cm4gMTsKIAl9CiAKKwljcnlwdF9pbmNfcGVuZGluZyhpbyk7CisKIAljbG9uZV9pbml0KGlvLCBjbG9uZSk7CiAJY2xvbmUtPmJpX2lkeCA9IDA7CiAJY2xvbmUtPmJpX3ZjbnQgPSBiaW9fc2VnbWVudHMoYmFzZV9iaW8pOwpAQCAtNzIwLDYgKzEwMjQsNyBAQAogCSAgICAgICBzaXplb2Yoc3RydWN0IGJpb192ZWMpICogY2xvbmUtPmJpX3ZjbnQpOwogCiAJZ2VuZXJpY19tYWtlX3JlcXVlc3QoY2xvbmUpOworCXJldHVybiAwOwogfQogCiBzdGF0aWMgdm9pZCBrY3J5cHRkX2lvX3dyaXRlKHN0cnVjdCBkbV9jcnlwdF9pbyAqaW8pCkBAIC03MzIsOSArMTAzNywxMiBAQAogewogCXN0cnVjdCBkbV9jcnlwdF9pbyAqaW8gPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0IGRtX2NyeXB0X2lvLCB3b3JrKTsKIAotCWlmIChiaW9fZGF0YV9kaXIoaW8tPmJhc2VfYmlvKSA9PSBSRUFEKQotCQlrY3J5cHRkX2lvX3JlYWQoaW8pOwotCWVsc2UKKwlpZiAoYmlvX2RhdGFfZGlyKGlvLT5iYXNlX2JpbykgPT0gUkVBRCkgeworCQljcnlwdF9pbmNfcGVuZGluZyhpbyk7CisJCWlmIChrY3J5cHRkX2lvX3JlYWQoaW8sIEdGUF9OT0lPKSkKKwkJCWlvLT5lcnJvciA9IC1FTk9NRU07CisJCWNyeXB0X2RlY19wZW5kaW5nKGlvKTsKKwl9IGVsc2UKIAkJa2NyeXB0ZF9pb193cml0ZShpbyk7CiB9CiAKQEAgLTkwMSw2ICsxMjA5LDkgQEAKIAkJcmV0dXJuOwogCX0KIAorCWlmICghZXJyb3IgJiYgY2MtPml2X2dlbl9vcHMgJiYgY2MtPml2X2dlbl9vcHMtPnBvc3QpCisJCWVycm9yID0gY2MtPml2X2dlbl9vcHMtPnBvc3QoY2MsIGl2X29mX2RtcmVxKGNjLCBkbXJlcSksIGRtcmVxKTsKKwogCW1lbXBvb2xfZnJlZShyZXFfb2ZfZG1yZXEoY2MsIGRtcmVxKSwgY2MtPnJlcV9wb29sKTsKIAogCWlmICghYXRvbWljX2RlY19hbmRfdGVzdCgmY3R4LT5wZW5kaW5nKSkKQEAgLTk3MSwzNCArMTI4Miw4NCBAQAogCX0KIH0KIAorc3RhdGljIHZvaWQgY3J5cHRfZnJlZV90Zm1zKHN0cnVjdCBjcnlwdF9jb25maWcgKmNjLCBpbnQgY3B1KQoreworCXN0cnVjdCBjcnlwdF9jcHUgKmNwdV9jYyA9IHBlcl9jcHVfcHRyKGNjLT5jcHUsIGNwdSk7CisJdW5zaWduZWQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBjYy0+dGZtc19jb3VudDsgaSsrKQorCQlpZiAoY3B1X2NjLT50Zm1zW2ldICYmICFJU19FUlIoY3B1X2NjLT50Zm1zW2ldKSkgeworCQkJY3J5cHRvX2ZyZWVfYWJsa2NpcGhlcihjcHVfY2MtPnRmbXNbaV0pOworCQkJY3B1X2NjLT50Zm1zW2ldID0gTlVMTDsKKwkJfQorfQorCitzdGF0aWMgaW50IGNyeXB0X2FsbG9jX3RmbXMoc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MsIGludCBjcHUsIGNoYXIgKmNpcGhlcm1vZGUpCit7CisJc3RydWN0IGNyeXB0X2NwdSAqY3B1X2NjID0gcGVyX2NwdV9wdHIoY2MtPmNwdSwgY3B1KTsKKwl1bnNpZ25lZCBpOworCWludCBlcnI7CisKKwlmb3IgKGkgPSAwOyBpIDwgY2MtPnRmbXNfY291bnQ7IGkrKykgeworCQljcHVfY2MtPnRmbXNbaV0gPSBjcnlwdG9fYWxsb2NfYWJsa2NpcGhlcihjaXBoZXJtb2RlLCAwLCAwKTsKKwkJaWYgKElTX0VSUihjcHVfY2MtPnRmbXNbaV0pKSB7CisJCQllcnIgPSBQVFJfRVJSKGNwdV9jYy0+dGZtc1tpXSk7CisJCQljcnlwdF9mcmVlX3RmbXMoY2MsIGNwdSk7CisJCQlyZXR1cm4gZXJyOworCQl9CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgY3J5cHRfc2V0a2V5X2FsbGNwdXMoc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MpCit7CisJdW5zaWduZWQgc3Via2V5X3NpemUgPSBjYy0+a2V5X3NpemUgPj4gaWxvZzIoY2MtPnRmbXNfY291bnQpOworCWludCBjcHUsIGVyciA9IDAsIGksIHI7CisKKwlmb3JfZWFjaF9wb3NzaWJsZV9jcHUoY3B1KSB7CisJCWZvciAoaSA9IDA7IGkgPCBjYy0+dGZtc19jb3VudDsgaSsrKSB7CisJCQlyID0gY3J5cHRvX2FibGtjaXBoZXJfc2V0a2V5KHBlcl9jcHVfcHRyKGNjLT5jcHUsIGNwdSktPnRmbXNbaV0sCisJCQkJCQkgICAgIGNjLT5rZXkgKyAoaSAqIHN1YmtleV9zaXplKSwgc3Via2V5X3NpemUpOworCQkJaWYgKHIpCisJCQkJZXJyID0gcjsKKwkJfQorCX0KKworCXJldHVybiBlcnI7Cit9CisKIHN0YXRpYyBpbnQgY3J5cHRfc2V0X2tleShzdHJ1Y3QgY3J5cHRfY29uZmlnICpjYywgY2hhciAqa2V5KQogewotCXVuc2lnbmVkIGtleV9zaXplID0gc3RybGVuKGtleSkgPj4gMTsKLQotCWlmIChjYy0+a2V5X3NpemUgJiYgY2MtPmtleV9zaXplICE9IGtleV9zaXplKQorCS8qIFRoZSBrZXkgc2l6ZSBtYXkgbm90IGJlIGNoYW5nZWQuICovCisJaWYgKGNjLT5rZXlfc2l6ZSAhPSAoc3RybGVuKGtleSkgPj4gMSkpCiAJCXJldHVybiAtRUlOVkFMOwogCi0JY2MtPmtleV9zaXplID0ga2V5X3NpemU7IC8qIGluaXRpYWwgc2V0dGluZ3MgKi8KKwkvKiBIeXBoZW4gKHdoaWNoIGdpdmVzIGEga2V5X3NpemUgb2YgemVybykgbWVhbnMgdGhlcmUgaXMgbm8ga2V5LiAqLworCWlmICghY2MtPmtleV9zaXplICYmIHN0cmNtcChrZXksICItIikpCisJCXJldHVybiAtRUlOVkFMOwogCi0JaWYgKCgha2V5X3NpemUgJiYgc3RyY21wKGtleSwgIi0iKSkgfHwKLQkgICAoa2V5X3NpemUgJiYgY3J5cHRfZGVjb2RlX2tleShjYy0+a2V5LCBrZXksIGtleV9zaXplKSA8IDApKQorCWlmIChjYy0+a2V5X3NpemUgJiYgY3J5cHRfZGVjb2RlX2tleShjYy0+a2V5LCBrZXksIGNjLT5rZXlfc2l6ZSkgPCAwKQogCQlyZXR1cm4gLUVJTlZBTDsKIAogCXNldF9iaXQoRE1fQ1JZUFRfS0VZX1ZBTElELCAmY2MtPmZsYWdzKTsKIAotCXJldHVybiBjcnlwdG9fYWJsa2NpcGhlcl9zZXRrZXkoY2MtPnRmbSwgY2MtPmtleSwgY2MtPmtleV9zaXplKTsKKwlyZXR1cm4gY3J5cHRfc2V0a2V5X2FsbGNwdXMoY2MpOwogfQogCiBzdGF0aWMgaW50IGNyeXB0X3dpcGVfa2V5KHN0cnVjdCBjcnlwdF9jb25maWcgKmNjKQogewogCWNsZWFyX2JpdChETV9DUllQVF9LRVlfVkFMSUQsICZjYy0+ZmxhZ3MpOwogCW1lbXNldCgmY2MtPmtleSwgMCwgY2MtPmtleV9zaXplICogc2l6ZW9mKHU4KSk7Ci0JcmV0dXJuIGNyeXB0b19hYmxrY2lwaGVyX3NldGtleShjYy0+dGZtLCBjYy0+a2V5LCBjYy0+a2V5X3NpemUpOworCisJcmV0dXJuIGNyeXB0X3NldGtleV9hbGxjcHVzKGNjKTsKIH0KIAogc3RhdGljIHZvaWQgY3J5cHRfZHRyKHN0cnVjdCBkbV90YXJnZXQgKnRpKQogewogCXN0cnVjdCBjcnlwdF9jb25maWcgKmNjID0gdGktPnByaXZhdGU7CisJc3RydWN0IGNyeXB0X2NwdSAqY3B1X2NjOworCWludCBjcHU7CiAKIAl0aS0+cHJpdmF0ZSA9IE5VTEw7CiAKQEAgLTEwMTAsNiArMTM3MSwxNCBAQAogCWlmIChjYy0+Y3J5cHRfcXVldWUpCiAJCWRlc3Ryb3lfd29ya3F1ZXVlKGNjLT5jcnlwdF9xdWV1ZSk7CiAKKwlpZiAoY2MtPmNwdSkKKwkJZm9yX2VhY2hfcG9zc2libGVfY3B1KGNwdSkgeworCQkJY3B1X2NjID0gcGVyX2NwdV9wdHIoY2MtPmNwdSwgY3B1KTsKKwkJCWlmIChjcHVfY2MtPnJlcSkKKwkJCQltZW1wb29sX2ZyZWUoY3B1X2NjLT5yZXEsIGNjLT5yZXFfcG9vbCk7CisJCQljcnlwdF9mcmVlX3RmbXMoY2MsIGNwdSk7CisJCX0KKwogCWlmIChjYy0+YnMpCiAJCWJpb3NldF9mcmVlKGNjLT5icyk7CiAKQEAgLTEwMjMsMTQgKzEzOTIsMTQgQEAKIAlpZiAoY2MtPml2X2dlbl9vcHMgJiYgY2MtPml2X2dlbl9vcHMtPmR0cikKIAkJY2MtPml2X2dlbl9vcHMtPmR0cihjYyk7CiAKLQlpZiAoY2MtPnRmbSAmJiAhSVNfRVJSKGNjLT50Zm0pKQotCQljcnlwdG9fZnJlZV9hYmxrY2lwaGVyKGNjLT50Zm0pOwotCiAJaWYgKGNjLT5kZXYpCiAJCWRtX3B1dF9kZXZpY2UodGksIGNjLT5kZXYpOwogCisJaWYgKGNjLT5jcHUpCisJCWZyZWVfcGVyY3B1KGNjLT5jcHUpOworCiAJa3pmcmVlKGNjLT5jaXBoZXIpOwotCWt6ZnJlZShjYy0+Y2lwaGVyX21vZGUpOworCWt6ZnJlZShjYy0+Y2lwaGVyX3N0cmluZyk7CiAKIAkvKiBNdXN0IHplcm8ga2V5IG1hdGVyaWFsIGJlZm9yZSBmcmVlaW5nICovCiAJa3pmcmVlKGNjKTsKQEAgLTEwNDAsOSArMTQwOSw5IEBACiAJCQkgICAgY2hhciAqY2lwaGVyX2luLCBjaGFyICprZXkpCiB7CiAJc3RydWN0IGNyeXB0X2NvbmZpZyAqY2MgPSB0aS0+cHJpdmF0ZTsKLQljaGFyICp0bXAsICpjaXBoZXIsICpjaGFpbm1vZGUsICppdm1vZGUsICppdm9wdHM7CisJY2hhciAqdG1wLCAqY2lwaGVyLCAqY2hhaW5tb2RlLCAqaXZtb2RlLCAqaXZvcHRzLCAqa2V5Y291bnQ7CiAJY2hhciAqY2lwaGVyX2FwaSA9IE5VTEw7Ci0JaW50IHJldCA9IC1FSU5WQUw7CisJaW50IGNwdSwgcmV0ID0gLUVJTlZBTDsKIAogCS8qIENvbnZlcnQgdG8gY3J5cHRvIGFwaSBkZWZpbml0aW9uPyAqLwogCWlmIChzdHJjaHIoY2lwaGVyX2luLCAnKCcpKSB7CkBAIC0xMDUwLDIzICsxNDE5LDMxIEBACiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAorCWNjLT5jaXBoZXJfc3RyaW5nID0ga3N0cmR1cChjaXBoZXJfaW4sIEdGUF9LRVJORUwpOworCWlmICghY2MtPmNpcGhlcl9zdHJpbmcpCisJCWdvdG8gYmFkX21lbTsKKwogCS8qCiAJICogTGVnYWN5IGRtLWNyeXB0IGNpcGhlciBzcGVjaWZpY2F0aW9uCi0JICogY2lwaGVyLW1vZGUtaXY6aXZvcHRzCisJICogY2lwaGVyWzprZXljb3VudF0tbW9kZS1pdjppdm9wdHMKIAkgKi8KIAl0bXAgPSBjaXBoZXJfaW47Ci0JY2lwaGVyID0gc3Ryc2VwKCZ0bXAsICItIik7CisJa2V5Y291bnQgPSBzdHJzZXAoJnRtcCwgIi0iKTsKKwljaXBoZXIgPSBzdHJzZXAoJmtleWNvdW50LCAiOiIpOworCisJaWYgKCFrZXljb3VudCkKKwkJY2MtPnRmbXNfY291bnQgPSAxOworCWVsc2UgaWYgKHNzY2FuZihrZXljb3VudCwgIiV1IiwgJmNjLT50Zm1zX2NvdW50KSAhPSAxIHx8CisJCSAhaXNfcG93ZXJfb2ZfMihjYy0+dGZtc19jb3VudCkpIHsKKwkJdGktPmVycm9yID0gIkJhZCBjaXBoZXIga2V5IGNvdW50IHNwZWNpZmljYXRpb24iOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJY2MtPmtleV9wYXJ0cyA9IGNjLT50Zm1zX2NvdW50OwogCiAJY2MtPmNpcGhlciA9IGtzdHJkdXAoY2lwaGVyLCBHRlBfS0VSTkVMKTsKIAlpZiAoIWNjLT5jaXBoZXIpCiAJCWdvdG8gYmFkX21lbTsKIAotCWlmICh0bXApIHsKLQkJY2MtPmNpcGhlcl9tb2RlID0ga3N0cmR1cCh0bXAsIEdGUF9LRVJORUwpOwotCQlpZiAoIWNjLT5jaXBoZXJfbW9kZSkKLQkJCWdvdG8gYmFkX21lbTsKLQl9Ci0KIAljaGFpbm1vZGUgPSBzdHJzZXAoJnRtcCwgIi0iKTsKIAlpdm9wdHMgPSBzdHJzZXAoJnRtcCwgIi0iKTsKIAlpdm1vZGUgPSBzdHJzZXAoJml2b3B0cywgIjoiKTsKQEAgLTEwNzQsMTAgKzE0NTEsMTkgQEAKIAlpZiAodG1wKQogCQlETVdBUk4oIklnbm9yaW5nIHVuZXhwZWN0ZWQgYWRkaXRpb25hbCBjaXBoZXIgb3B0aW9ucyIpOwogCi0JLyogQ29tcGF0aWJpbGl0eSBtb2RlIGZvciBvbGQgZG0tY3J5cHQgbWFwcGluZ3MgKi8KKwljYy0+Y3B1ID0gX19hbGxvY19wZXJjcHUoc2l6ZW9mKCooY2MtPmNwdSkpICsKKwkJCQkgY2MtPnRmbXNfY291bnQgKiBzaXplb2YoKihjYy0+Y3B1LT50Zm1zKSksCisJCQkJIF9fYWxpZ25vZl9fKHN0cnVjdCBjcnlwdF9jcHUpKTsKKwlpZiAoIWNjLT5jcHUpIHsKKwkJdGktPmVycm9yID0gIkNhbm5vdCBhbGxvY2F0ZSBwZXIgY3B1IHN0YXRlIjsKKwkJZ290byBiYWRfbWVtOworCX0KKworCS8qCisJICogRm9yIGNvbXBhdGliaWxpdHkgd2l0aCB0aGUgb3JpZ2luYWwgZG0tY3J5cHQgbWFwcGluZyBmb3JtYXQsIGlmCisJICogb25seSB0aGUgY2lwaGVyIG5hbWUgaXMgc3VwcGxpZWQsIHVzZSBjYmMtcGxhaW4uCisJICovCiAJaWYgKCFjaGFpbm1vZGUgfHwgKCFzdHJjbXAoY2hhaW5tb2RlLCAicGxhaW4iKSAmJiAhaXZtb2RlKSkgewotCQlrZnJlZShjYy0+Y2lwaGVyX21vZGUpOwotCQljYy0+Y2lwaGVyX21vZGUgPSBrc3RyZHVwKCJjYmMtcGxhaW4iLCBHRlBfS0VSTkVMKTsKIAkJY2hhaW5tb2RlID0gImNiYyI7CiAJCWl2bW9kZSA9ICJwbGFpbiI7CiAJfQpAQCAtMTA5OSwxMSArMTQ4NSwxMiBAQAogCX0KIAogCS8qIEFsbG9jYXRlIGNpcGhlciAqLwotCWNjLT50Zm0gPSBjcnlwdG9fYWxsb2NfYWJsa2NpcGhlcihjaXBoZXJfYXBpLCAwLCAwKTsKLQlpZiAoSVNfRVJSKGNjLT50Zm0pKSB7Ci0JCXJldCA9IFBUUl9FUlIoY2MtPnRmbSk7Ci0JCXRpLT5lcnJvciA9ICJFcnJvciBhbGxvY2F0aW5nIGNyeXB0byB0Zm0iOwotCQlnb3RvIGJhZDsKKwlmb3JfZWFjaF9wb3NzaWJsZV9jcHUoY3B1KSB7CisJCXJldCA9IGNyeXB0X2FsbG9jX3RmbXMoY2MsIGNwdSwgY2lwaGVyX2FwaSk7CisJCWlmIChyZXQgPCAwKSB7CisJCQl0aS0+ZXJyb3IgPSAiRXJyb3IgYWxsb2NhdGluZyBjcnlwdG8gdGZtIjsKKwkJCWdvdG8gYmFkOworCQl9CiAJfQogCiAJLyogSW5pdGlhbGl6ZSBhbmQgc2V0IGtleSAqLwpAQCAtMTExNCw3ICsxNTAxLDcgQEAKIAl9CiAKIAkvKiBJbml0aWFsaXplIElWICovCi0JY2MtPml2X3NpemUgPSBjcnlwdG9fYWJsa2NpcGhlcl9pdnNpemUoY2MtPnRmbSk7CisJY2MtPml2X3NpemUgPSBjcnlwdG9fYWJsa2NpcGhlcl9pdnNpemUoYW55X3RmbShjYykpOwogCWlmIChjYy0+aXZfc2l6ZSkKIAkJLyogYXQgbGVhc3QgYSA2NCBiaXQgc2VjdG9yIG51bWJlciBzaG91bGQgZml0IGluIG91ciBidWZmZXIgKi8KIAkJY2MtPml2X3NpemUgPSBtYXgoY2MtPml2X3NpemUsCkBAIC0xMTM3LDcgKzE1MjQsMTUgQEAKIAkJY2MtPml2X2dlbl9vcHMgPSAmY3J5cHRfaXZfYmVuYmlfb3BzOwogCWVsc2UgaWYgKHN0cmNtcChpdm1vZGUsICJudWxsIikgPT0gMCkKIAkJY2MtPml2X2dlbl9vcHMgPSAmY3J5cHRfaXZfbnVsbF9vcHM7Ci0JZWxzZSB7CisJZWxzZSBpZiAoc3RyY21wKGl2bW9kZSwgImxtayIpID09IDApIHsKKwkJY2MtPml2X2dlbl9vcHMgPSAmY3J5cHRfaXZfbG1rX29wczsKKwkJLyogVmVyc2lvbiAyIGFuZCAzIGlzIHJlY29nbmlzZWQgYWNjb3JkaW5nCisJCSAqIHRvIGxlbmd0aCBvZiBwcm92aWRlZCBtdWx0aS1rZXkgc3RyaW5nLgorCQkgKiBJZiBwcmVzZW50ICh2ZXJzaW9uIDMpLCBsYXN0IGtleSBpcyB1c2VkIGFzIElWIHNlZWQuCisJCSAqLworCQlpZiAoY2MtPmtleV9zaXplICUgY2MtPmtleV9wYXJ0cykKKwkJCWNjLT5rZXlfcGFydHMrKzsKKwl9IGVsc2UgewogCQlyZXQgPSAtRUlOVkFMOwogCQl0aS0+ZXJyb3IgPSAiSW52YWxpZCBJViBtb2RlIjsKIAkJZ290byBiYWQ7CkBAIC0xMTk0LDYgKzE1ODksNyBAQAogCQl0aS0+ZXJyb3IgPSAiQ2Fubm90IGFsbG9jYXRlIGVuY3J5cHRpb24gY29udGV4dCI7CiAJCXJldHVybiAtRU5PTUVNOwogCX0KKwljYy0+a2V5X3NpemUgPSBrZXlfc2l6ZTsKIAogCXRpLT5wcml2YXRlID0gY2M7CiAJcmV0ID0gY3J5cHRfY3RyX2NpcGhlcih0aSwgYXJndlswXSwgYXJndlsxXSk7CkBAIC0xMjA4LDkgKzE2MDQsOSBAQAogCX0KIAogCWNjLT5kbXJlcV9zdGFydCA9IHNpemVvZihzdHJ1Y3QgYWJsa2NpcGhlcl9yZXF1ZXN0KTsKLQljYy0+ZG1yZXFfc3RhcnQgKz0gY3J5cHRvX2FibGtjaXBoZXJfcmVxc2l6ZShjYy0+dGZtKTsKKwljYy0+ZG1yZXFfc3RhcnQgKz0gY3J5cHRvX2FibGtjaXBoZXJfcmVxc2l6ZShhbnlfdGZtKGNjKSk7CiAJY2MtPmRtcmVxX3N0YXJ0ID0gQUxJR04oY2MtPmRtcmVxX3N0YXJ0LCBjcnlwdG9fdGZtX2N0eF9hbGlnbm1lbnQoKSk7Ci0JY2MtPmRtcmVxX3N0YXJ0ICs9IGNyeXB0b19hYmxrY2lwaGVyX2FsaWdubWFzayhjYy0+dGZtKSAmCisJY2MtPmRtcmVxX3N0YXJ0ICs9IGNyeXB0b19hYmxrY2lwaGVyX2FsaWdubWFzayhhbnlfdGZtKGNjKSkgJgogCQkJICAgfihjcnlwdG9fdGZtX2N0eF9hbGlnbm1lbnQoKSAtIDEpOwogCiAJY2MtPnJlcV9wb29sID0gbWVtcG9vbF9jcmVhdGVfa21hbGxvY19wb29sKE1JTl9JT1MsIGNjLT5kbXJlcV9zdGFydCArCkBAIC0xMjE5LDcgKzE2MTUsNiBAQAogCQl0aS0+ZXJyb3IgPSAiQ2Fubm90IGFsbG9jYXRlIGNyeXB0IHJlcXVlc3QgbWVtcG9vbCI7CiAJCWdvdG8gYmFkOwogCX0KLQljYy0+cmVxID0gTlVMTDsKIAogCWNjLT5wYWdlX3Bvb2wgPSBtZW1wb29sX2NyZWF0ZV9wYWdlX3Bvb2woTUlOX1BPT0xfUEFHRVMsIDApOwogCWlmICghY2MtPnBhZ2VfcG9vbCkgewpAQCAtMTI1MiwxMyArMTY0NywyMCBAQAogCWNjLT5zdGFydCA9IHRtcGxsOwogCiAJcmV0ID0gLUVOT01FTTsKLQljYy0+aW9fcXVldWUgPSBjcmVhdGVfc2luZ2xldGhyZWFkX3dvcmtxdWV1ZSgia2NyeXB0ZF9pbyIpOworCWNjLT5pb19xdWV1ZSA9IGFsbG9jX3dvcmtxdWV1ZSgia2NyeXB0ZF9pbyIsCisJCQkJICAgICAgIFdRX05PTl9SRUVOVFJBTlR8CisJCQkJICAgICAgIFdRX01FTV9SRUNMQUlNLAorCQkJCSAgICAgICAxKTsKIAlpZiAoIWNjLT5pb19xdWV1ZSkgewogCQl0aS0+ZXJyb3IgPSAiQ291bGRuJ3QgY3JlYXRlIGtjcnlwdGQgaW8gcXVldWUiOwogCQlnb3RvIGJhZDsKIAl9CiAKLQljYy0+Y3J5cHRfcXVldWUgPSBjcmVhdGVfc2luZ2xldGhyZWFkX3dvcmtxdWV1ZSgia2NyeXB0ZCIpOworCWNjLT5jcnlwdF9xdWV1ZSA9IGFsbG9jX3dvcmtxdWV1ZSgia2NyeXB0ZCIsCisJCQkJCSAgV1FfTk9OX1JFRU5UUkFOVHwKKwkJCQkJICBXUV9DUFVfSU5URU5TSVZFfAorCQkJCQkgIFdRX01FTV9SRUNMQUlNLAorCQkJCQkgIDEpOwogCWlmICghY2MtPmNyeXB0X3F1ZXVlKSB7CiAJCXRpLT5lcnJvciA9ICJDb3VsZG4ndCBjcmVhdGUga2NyeXB0ZCBxdWV1ZSI7CiAJCWdvdG8gYmFkOwpAQCAtMTI4Niw5ICsxNjg4LDEwIEBACiAKIAlpbyA9IGNyeXB0X2lvX2FsbG9jKHRpLCBiaW8sIGRtX3RhcmdldF9vZmZzZXQodGksIGJpby0+Ymlfc2VjdG9yKSk7CiAKLQlpZiAoYmlvX2RhdGFfZGlyKGlvLT5iYXNlX2JpbykgPT0gUkVBRCkKLQkJa2NyeXB0ZF9xdWV1ZV9pbyhpbyk7Ci0JZWxzZQorCWlmIChiaW9fZGF0YV9kaXIoaW8tPmJhc2VfYmlvKSA9PSBSRUFEKSB7CisJCWlmIChrY3J5cHRkX2lvX3JlYWQoaW8sIEdGUF9OT1dBSVQpKQorCQkJa2NyeXB0ZF9xdWV1ZV9pbyhpbyk7CisJfSBlbHNlCiAJCWtjcnlwdGRfcXVldWVfY3J5cHQoaW8pOwogCiAJcmV0dXJuIERNX01BUElPX1NVQk1JVFRFRDsKQEAgLTEzMDYsMTAgKzE3MDksNyBAQAogCQlicmVhazsKIAogCWNhc2UgU1RBVFVTVFlQRV9UQUJMRToKLQkJaWYgKGNjLT5jaXBoZXJfbW9kZSkKLQkJCURNRU1JVCgiJXMtJXMgIiwgY2MtPmNpcGhlciwgY2MtPmNpcGhlcl9tb2RlKTsKLQkJZWxzZQotCQkJRE1FTUlUKCIlcyAiLCBjYy0+Y2lwaGVyKTsKKwkJRE1FTUlUKCIlcyAiLCBjYy0+Y2lwaGVyX3N0cmluZyk7CiAKIAkJaWYgKGNjLT5rZXlfc2l6ZSA+IDApIHsKIAkJCWlmICgobWF4bGVuIC0gc3opIDwgKChjYy0+a2V5X3NpemUgPDwgMSkgKyAxKSkKQEAgLTE0MjEsNyArMTgyMSw3IEBACiAKIHN0YXRpYyBzdHJ1Y3QgdGFyZ2V0X3R5cGUgY3J5cHRfdGFyZ2V0ID0gewogCS5uYW1lICAgPSAiY3J5cHQiLAotCS52ZXJzaW9uID0gezEsIDcsIDB9LAorCS52ZXJzaW9uID0gezEsIDEwLCAwfSwKIAkubW9kdWxlID0gVEhJU19NT0RVTEUsCiAJLmN0ciAgICA9IGNyeXB0X2N0ciwKIAkuZHRyICAgID0gY3J5cHRfZHRyLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1kZWxheS5jIGIvZHJpdmVycy9tZC9kbS1kZWxheS5jCmluZGV4IGJhYTExOTEuLmYxODM3NWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tZGVsYXkuYworKysgYi9kcml2ZXJzL21kL2RtLWRlbGF5LmMKQEAgLTM1Miw3ICszNTIsNyBAQAogewogCWludCByID0gLUVOT01FTTsKIAotCWtkZWxheWRfd3EgPSBjcmVhdGVfd29ya3F1ZXVlKCJrZGVsYXlkIik7CisJa2RlbGF5ZF93cSA9IGFsbG9jX3dvcmtxdWV1ZSgia2RlbGF5ZCIsIFdRX01FTV9SRUNMQUlNLCAwKTsKIAlpZiAoIWtkZWxheWRfd3EpIHsKIAkJRE1FUlIoIkNvdWxkbid0IHN0YXJ0IGtkZWxheWQiKTsKIAkJZ290byBiYWRfcXVldWU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLWlvY3RsLmMgYi9kcml2ZXJzL21kL2RtLWlvY3RsLmMKaW5kZXggNGI1NDYxOC4uNmQxMjc3NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1pb2N0bC5jCisrKyBiL2RyaXZlcnMvbWQvZG0taW9jdGwuYwpAQCAtMjk1LDE5ICsyOTUsNTUgQEAKIAkJRE1XQVJOKCJyZW1vdmVfYWxsIGxlZnQgJWQgb3BlbiBkZXZpY2UocykiLCBkZXZfc2tpcHBlZCk7CiB9CiAKKy8qCisgKiBTZXQgdGhlIHV1aWQgb2YgYSBoYXNoX2NlbGwgdGhhdCBpc24ndCBhbHJlYWR5IHNldC4KKyAqLworc3RhdGljIHZvaWQgX19zZXRfY2VsbF91dWlkKHN0cnVjdCBoYXNoX2NlbGwgKmhjLCBjaGFyICpuZXdfdXVpZCkKK3sKKwltdXRleF9sb2NrKCZkbV9oYXNoX2NlbGxzX211dGV4KTsKKwloYy0+dXVpZCA9IG5ld191dWlkOworCW11dGV4X3VubG9jaygmZG1faGFzaF9jZWxsc19tdXRleCk7CisKKwlsaXN0X2FkZCgmaGMtPnV1aWRfbGlzdCwgX3V1aWRfYnVja2V0cyArIGhhc2hfc3RyKG5ld191dWlkKSk7Cit9CisKKy8qCisgKiBDaGFuZ2VzIHRoZSBuYW1lIG9mIGEgaGFzaF9jZWxsIGFuZCByZXR1cm5zIHRoZSBvbGQgbmFtZSBmb3IKKyAqIHRoZSBjYWxsZXIgdG8gZnJlZS4KKyAqLworc3RhdGljIGNoYXIgKl9fY2hhbmdlX2NlbGxfbmFtZShzdHJ1Y3QgaGFzaF9jZWxsICpoYywgY2hhciAqbmV3X25hbWUpCit7CisJY2hhciAqb2xkX25hbWU7CisKKwkvKgorCSAqIFJlbmFtZSBhbmQgbW92ZSB0aGUgbmFtZSBjZWxsLgorCSAqLworCWxpc3RfZGVsKCZoYy0+bmFtZV9saXN0KTsKKwlvbGRfbmFtZSA9IGhjLT5uYW1lOworCisJbXV0ZXhfbG9jaygmZG1faGFzaF9jZWxsc19tdXRleCk7CisJaGMtPm5hbWUgPSBuZXdfbmFtZTsKKwltdXRleF91bmxvY2soJmRtX2hhc2hfY2VsbHNfbXV0ZXgpOworCisJbGlzdF9hZGQoJmhjLT5uYW1lX2xpc3QsIF9uYW1lX2J1Y2tldHMgKyBoYXNoX3N0cihuZXdfbmFtZSkpOworCisJcmV0dXJuIG9sZF9uYW1lOworfQorCiBzdGF0aWMgc3RydWN0IG1hcHBlZF9kZXZpY2UgKmRtX2hhc2hfcmVuYW1lKHN0cnVjdCBkbV9pb2N0bCAqcGFyYW0sCiAJCQkJCSAgICBjb25zdCBjaGFyICpuZXcpCiB7Ci0JY2hhciAqbmV3X25hbWUsICpvbGRfbmFtZTsKKwljaGFyICpuZXdfZGF0YSwgKm9sZF9uYW1lID0gTlVMTDsKIAlzdHJ1Y3QgaGFzaF9jZWxsICpoYzsKIAlzdHJ1Y3QgZG1fdGFibGUgKnRhYmxlOwogCXN0cnVjdCBtYXBwZWRfZGV2aWNlICptZDsKKwl1bnNpZ25lZCBjaGFuZ2VfdXVpZCA9IChwYXJhbS0+ZmxhZ3MgJiBETV9VVUlEX0ZMQUcpID8gMSA6IDA7CiAKIAkvKgogCSAqIGR1cGxpY2F0ZSBuZXcuCiAJICovCi0JbmV3X25hbWUgPSBrc3RyZHVwKG5ldywgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFuZXdfbmFtZSkKKwluZXdfZGF0YSA9IGtzdHJkdXAobmV3LCBHRlBfS0VSTkVMKTsKKwlpZiAoIW5ld19kYXRhKQogCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKIAogCWRvd25fd3JpdGUoJl9oYXNoX2xvY2spOwpAQCAtMzE1LDEzICszNTEsMTkgQEAKIAkvKgogCSAqIElzIG5ldyBmcmVlID8KIAkgKi8KLQloYyA9IF9fZ2V0X25hbWVfY2VsbChuZXcpOworCWlmIChjaGFuZ2VfdXVpZCkKKwkJaGMgPSBfX2dldF91dWlkX2NlbGwobmV3KTsKKwllbHNlCisJCWhjID0gX19nZXRfbmFtZV9jZWxsKG5ldyk7CisKIAlpZiAoaGMpIHsKLQkJRE1XQVJOKCJhc2tlZCB0byByZW5hbWUgdG8gYW4gYWxyZWFkeS1leGlzdGluZyBuYW1lICVzIC0+ICVzIiwKKwkJRE1XQVJOKCJVbmFibGUgdG8gY2hhbmdlICVzIG9uIG1hcHBlZCBkZXZpY2UgJXMgdG8gb25lIHRoYXQgIgorCQkgICAgICAgImFscmVhZHkgZXhpc3RzOiAlcyIsCisJCSAgICAgICBjaGFuZ2VfdXVpZCA/ICJ1dWlkIiA6ICJuYW1lIiwKIAkJICAgICAgIHBhcmFtLT5uYW1lLCBuZXcpOwogCQlkbV9wdXQoaGMtPm1kKTsKIAkJdXBfd3JpdGUoJl9oYXNoX2xvY2spOwotCQlrZnJlZShuZXdfbmFtZSk7CisJCWtmcmVlKG5ld19kYXRhKTsKIAkJcmV0dXJuIEVSUl9QVFIoLUVCVVNZKTsKIAl9CiAKQEAgLTMzMCwyMiArMzcyLDMwIEBACiAJICovCiAJaGMgPSBfX2dldF9uYW1lX2NlbGwocGFyYW0tPm5hbWUpOwogCWlmICghaGMpIHsKLQkJRE1XQVJOKCJhc2tlZCB0byByZW5hbWUgYSBub24tZXhpc3RlbnQgZGV2aWNlICVzIC0+ICVzIiwKLQkJICAgICAgIHBhcmFtLT5uYW1lLCBuZXcpOworCQlETVdBUk4oIlVuYWJsZSB0byByZW5hbWUgbm9uLWV4aXN0ZW50IGRldmljZSwgJXMgdG8gJXMlcyIsCisJCSAgICAgICBwYXJhbS0+bmFtZSwgY2hhbmdlX3V1aWQgPyAidXVpZCAiIDogIiIsIG5ldyk7CiAJCXVwX3dyaXRlKCZfaGFzaF9sb2NrKTsKLQkJa2ZyZWUobmV3X25hbWUpOworCQlrZnJlZShuZXdfZGF0YSk7CiAJCXJldHVybiBFUlJfUFRSKC1FTlhJTyk7CiAJfQogCiAJLyoKLQkgKiByZW5hbWUgYW5kIG1vdmUgdGhlIG5hbWUgY2VsbC4KKwkgKiBEb2VzIHRoaXMgZGV2aWNlIGFscmVhZHkgaGF2ZSBhIHV1aWQ/CiAJICovCi0JbGlzdF9kZWwoJmhjLT5uYW1lX2xpc3QpOwotCW9sZF9uYW1lID0gaGMtPm5hbWU7Ci0JbXV0ZXhfbG9jaygmZG1faGFzaF9jZWxsc19tdXRleCk7Ci0JaGMtPm5hbWUgPSBuZXdfbmFtZTsKLQltdXRleF91bmxvY2soJmRtX2hhc2hfY2VsbHNfbXV0ZXgpOwotCWxpc3RfYWRkKCZoYy0+bmFtZV9saXN0LCBfbmFtZV9idWNrZXRzICsgaGFzaF9zdHIobmV3X25hbWUpKTsKKwlpZiAoY2hhbmdlX3V1aWQgJiYgaGMtPnV1aWQpIHsKKwkJRE1XQVJOKCJVbmFibGUgdG8gY2hhbmdlIHV1aWQgb2YgbWFwcGVkIGRldmljZSAlcyB0byAlcyAiCisJCSAgICAgICAiYmVjYXVzZSB1dWlkIGlzIGFscmVhZHkgc2V0IHRvICVzIiwKKwkJICAgICAgIHBhcmFtLT5uYW1lLCBuZXcsIGhjLT51dWlkKTsKKwkJZG1fcHV0KGhjLT5tZCk7CisJCXVwX3dyaXRlKCZfaGFzaF9sb2NrKTsKKwkJa2ZyZWUobmV3X2RhdGEpOworCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKKwl9CisKKwlpZiAoY2hhbmdlX3V1aWQpCisJCV9fc2V0X2NlbGxfdXVpZChoYywgbmV3X2RhdGEpOworCWVsc2UKKwkJb2xkX25hbWUgPSBfX2NoYW5nZV9jZWxsX25hbWUoaGMsIG5ld19kYXRhKTsKIAogCS8qCiAJICogV2FrZSB1cCBhbnkgZG0gZXZlbnQgd2FpdGVycy4KQEAgLTcyOSw3ICs3NzksNyBAQAogCWhjID0gX19maW5kX2RldmljZV9oYXNoX2NlbGwocGFyYW0pOwogCiAJaWYgKCFoYykgewotCQlETVdBUk4oImRldmljZSBkb2Vzbid0IGFwcGVhciB0byBiZSBpbiB0aGUgZGV2IGhhc2ggdGFibGUuIik7CisJCURNREVCVUdfTElNSVQoImRldmljZSBkb2Vzbid0IGFwcGVhciB0byBiZSBpbiB0aGUgZGV2IGhhc2ggdGFibGUuIik7CiAJCXVwX3dyaXRlKCZfaGFzaF9sb2NrKTsKIAkJcmV0dXJuIC1FTlhJTzsKIAl9CkBAIC03NDEsNyArNzkxLDcgQEAKIAkgKi8KIAlyID0gZG1fbG9ja19mb3JfZGVsZXRpb24obWQpOwogCWlmIChyKSB7Ci0JCURNV0FSTigidW5hYmxlIHRvIHJlbW92ZSBvcGVuIGRldmljZSAlcyIsIGhjLT5uYW1lKTsKKwkJRE1ERUJVR19MSU1JVCgidW5hYmxlIHRvIHJlbW92ZSBvcGVuIGRldmljZSAlcyIsIGhjLT5uYW1lKTsKIAkJdXBfd3JpdGUoJl9oYXNoX2xvY2spOwogCQlkbV9wdXQobWQpOwogCQlyZXR1cm4gcjsKQEAgLTc3NCwyMSArODI0LDI0IEBACiBzdGF0aWMgaW50IGRldl9yZW5hbWUoc3RydWN0IGRtX2lvY3RsICpwYXJhbSwgc2l6ZV90IHBhcmFtX3NpemUpCiB7CiAJaW50IHI7Ci0JY2hhciAqbmV3X25hbWUgPSAoY2hhciAqKSBwYXJhbSArIHBhcmFtLT5kYXRhX3N0YXJ0OworCWNoYXIgKm5ld19kYXRhID0gKGNoYXIgKikgcGFyYW0gKyBwYXJhbS0+ZGF0YV9zdGFydDsKIAlzdHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQ7CisJdW5zaWduZWQgY2hhbmdlX3V1aWQgPSAocGFyYW0tPmZsYWdzICYgRE1fVVVJRF9GTEFHKSA/IDEgOiAwOwogCi0JaWYgKG5ld19uYW1lIDwgcGFyYW0tPmRhdGEgfHwKLQkgICAgaW52YWxpZF9zdHIobmV3X25hbWUsICh2b2lkICopIHBhcmFtICsgcGFyYW1fc2l6ZSkgfHwKLQkgICAgc3RybGVuKG5ld19uYW1lKSA+IERNX05BTUVfTEVOIC0gMSkgewotCQlETVdBUk4oIkludmFsaWQgbmV3IGxvZ2ljYWwgdm9sdW1lIG5hbWUgc3VwcGxpZWQuIik7CisJaWYgKG5ld19kYXRhIDwgcGFyYW0tPmRhdGEgfHwKKwkgICAgaW52YWxpZF9zdHIobmV3X2RhdGEsICh2b2lkICopIHBhcmFtICsgcGFyYW1fc2l6ZSkgfHwKKwkgICAgc3RybGVuKG5ld19kYXRhKSA+IChjaGFuZ2VfdXVpZCA/IERNX1VVSURfTEVOIC0gMSA6IERNX05BTUVfTEVOIC0gMSkpIHsKKwkJRE1XQVJOKCJJbnZhbGlkIG5ldyBtYXBwZWQgZGV2aWNlIG5hbWUgb3IgdXVpZCBzdHJpbmcgc3VwcGxpZWQuIik7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAotCXIgPSBjaGVja19uYW1lKG5ld19uYW1lKTsKLQlpZiAocikKLQkJcmV0dXJuIHI7CisJaWYgKCFjaGFuZ2VfdXVpZCkgeworCQlyID0gY2hlY2tfbmFtZShuZXdfZGF0YSk7CisJCWlmIChyKQorCQkJcmV0dXJuIHI7CisJfQogCi0JbWQgPSBkbV9oYXNoX3JlbmFtZShwYXJhbSwgbmV3X25hbWUpOworCW1kID0gZG1faGFzaF9yZW5hbWUocGFyYW0sIG5ld19kYXRhKTsKIAlpZiAoSVNfRVJSKG1kKSkKIAkJcmV0dXJuIFBUUl9FUlIobWQpOwogCkBAIC04ODUsNyArOTM4LDcgQEAKIAogCWhjID0gX19maW5kX2RldmljZV9oYXNoX2NlbGwocGFyYW0pOwogCWlmICghaGMpIHsKLQkJRE1XQVJOKCJkZXZpY2UgZG9lc24ndCBhcHBlYXIgdG8gYmUgaW4gdGhlIGRldiBoYXNoIHRhYmxlLiIpOworCQlETURFQlVHX0xJTUlUKCJkZXZpY2UgZG9lc24ndCBhcHBlYXIgdG8gYmUgaW4gdGhlIGRldiBoYXNoIHRhYmxlLiIpOwogCQl1cF93cml0ZSgmX2hhc2hfbG9jayk7CiAJCXJldHVybiAtRU5YSU87CiAJfQpAQCAtMTIxMiw3ICsxMjY1LDcgQEAKIAogCWhjID0gX19maW5kX2RldmljZV9oYXNoX2NlbGwocGFyYW0pOwogCWlmICghaGMpIHsKLQkJRE1XQVJOKCJkZXZpY2UgZG9lc24ndCBhcHBlYXIgdG8gYmUgaW4gdGhlIGRldiBoYXNoIHRhYmxlLiIpOworCQlETURFQlVHX0xJTUlUKCJkZXZpY2UgZG9lc24ndCBhcHBlYXIgdG8gYmUgaW4gdGhlIGRldiBoYXNoIHRhYmxlLiIpOwogCQl1cF93cml0ZSgmX2hhc2hfbG9jayk7CiAJCXJldHVybiAtRU5YSU87CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1rY29weWQuYyBiL2RyaXZlcnMvbWQvZG0ta2NvcHlkLmMKaW5kZXggZDg1ODdiYS4uOTI0ZjVmMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1rY29weWQuYworKysgYi9kcml2ZXJzL21kL2RtLWtjb3B5ZC5jCkBAIC0zNyw2ICszNywxMyBAQAogCXVuc2lnbmVkIGludCBucl9wYWdlczsKIAl1bnNpZ25lZCBpbnQgbnJfZnJlZV9wYWdlczsKIAorCS8qCisJICogQmxvY2sgZGV2aWNlcyB0byB1bnBsdWcuCisJICogTm9uLU5VTEwgcG9pbnRlciBtZWFucyB0aGF0IGEgYmxvY2sgZGV2aWNlIGhhcyBzb21lIHBlbmRpbmcgcmVxdWVzdHMKKwkgKiBhbmQgbmVlZHMgdG8gYmUgdW5wbHVnZ2VkLgorCSAqLworCXN0cnVjdCBibG9ja19kZXZpY2UgKnVucGx1Z1syXTsKKwogCXN0cnVjdCBkbV9pb19jbGllbnQgKmlvX2NsaWVudDsKIAogCXdhaXRfcXVldWVfaGVhZF90IGRlc3Ryb3lxOwpAQCAtMzA4LDYgKzMxNSwzMSBAQAogCXJldHVybiAwOwogfQogCisvKgorICogVW5wbHVnIHRoZSBibG9jayBkZXZpY2UgYXQgdGhlIHNwZWNpZmllZCBpbmRleC4KKyAqLworc3RhdGljIHZvaWQgdW5wbHVnKHN0cnVjdCBkbV9rY29weWRfY2xpZW50ICprYywgaW50IHJ3KQoreworCWlmIChrYy0+dW5wbHVnW3J3XSAhPSBOVUxMKSB7CisJCWJsa191bnBsdWcoYmRldl9nZXRfcXVldWUoa2MtPnVucGx1Z1tyd10pKTsKKwkJa2MtPnVucGx1Z1tyd10gPSBOVUxMOworCX0KK30KKworLyoKKyAqIFByZXBhcmUgYmxvY2sgZGV2aWNlIHVucGx1Zy4gSWYgdGhlcmUncyBhbm90aGVyIGRldmljZQorICogdG8gYmUgdW5wbHVnZ2VkIGF0IHRoZSBzYW1lIGFycmF5IGluZGV4LCB3ZSB1bnBsdWcgdGhhdAorICogZGV2aWNlIGZpcnN0LgorICovCitzdGF0aWMgdm9pZCBwcmVwYXJlX3VucGx1ZyhzdHJ1Y3QgZG1fa2NvcHlkX2NsaWVudCAqa2MsIGludCBydywKKwkJCSAgIHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYpCit7CisJaWYgKGxpa2VseShrYy0+dW5wbHVnW3J3XSA9PSBiZGV2KSkKKwkJcmV0dXJuOworCXVucGx1ZyhrYywgcncpOworCWtjLT51bnBsdWdbcnddID0gYmRldjsKK30KKwogc3RhdGljIHZvaWQgY29tcGxldGVfaW8odW5zaWduZWQgbG9uZyBlcnJvciwgdm9pZCAqY29udGV4dCkKIHsKIAlzdHJ1Y3Qga2NvcHlkX2pvYiAqam9iID0gKHN0cnVjdCBrY29weWRfam9iICopIGNvbnRleHQ7CkBAIC0zNDUsNyArMzc3LDcgQEAKIHsKIAlpbnQgcjsKIAlzdHJ1Y3QgZG1faW9fcmVxdWVzdCBpb19yZXEgPSB7Ci0JCS5iaV9ydyA9IGpvYi0+cncgfCBSRVFfU1lOQyB8IFJFUV9VTlBMVUcsCisJCS5iaV9ydyA9IGpvYi0+cncsCiAJCS5tZW0udHlwZSA9IERNX0lPX1BBR0VfTElTVCwKIAkJLm1lbS5wdHIucGwgPSBqb2ItPnBhZ2VzLAogCQkubWVtLm9mZnNldCA9IGpvYi0+b2Zmc2V0LApAQCAtMzU0LDEwICszODYsMTYgQEAKIAkJLmNsaWVudCA9IGpvYi0+a2MtPmlvX2NsaWVudCwKIAl9OwogCi0JaWYgKGpvYi0+cncgPT0gUkVBRCkKKwlpZiAoam9iLT5ydyA9PSBSRUFEKSB7CiAJCXIgPSBkbV9pbygmaW9fcmVxLCAxLCAmam9iLT5zb3VyY2UsIE5VTEwpOwotCWVsc2UKKwkJcHJlcGFyZV91bnBsdWcoam9iLT5rYywgUkVBRCwgam9iLT5zb3VyY2UuYmRldik7CisJfSBlbHNlIHsKKwkJaWYgKGpvYi0+bnVtX2Rlc3RzID4gMSkKKwkJCWlvX3JlcS5iaV9ydyB8PSBSRVFfVU5QTFVHOwogCQlyID0gZG1faW8oJmlvX3JlcSwgam9iLT5udW1fZGVzdHMsIGpvYi0+ZGVzdHMsIE5VTEwpOworCQlpZiAoIShpb19yZXEuYmlfcncgJiBSRVFfVU5QTFVHKSkKKwkJCXByZXBhcmVfdW5wbHVnKGpvYi0+a2MsIFdSSVRFLCBqb2ItPmRlc3RzWzBdLmJkZXYpOworCX0KIAogCXJldHVybiByOwogfQpAQCAtNDM1LDEwICs0NzMsMTggQEAKIAkgKiBQYWdlcyBqb2JzIHdoZW4gc3VjY2Vzc2Z1bCB3aWxsIGp1bXAgb250byB0aGUgaW8gam9icwogCSAqIGxpc3QuICBpbyBqb2JzIGNhbGwgd2FrZSB3aGVuIHRoZXkgY29tcGxldGUgYW5kIGl0IGFsbAogCSAqIHN0YXJ0cyBhZ2Fpbi4KKwkgKgorCSAqIE5vdGUgdGhhdCBpb19qb2JzIGFkZCBibG9jayBkZXZpY2VzIHRvIHRoZSB1bnBsdWcgYXJyYXksCisJICogdGhpcyBhcnJheSBpcyBjbGVhcmVkIHdpdGggInVucGx1ZyIgY2FsbHMuIEl0IGlzIHRodXMKKwkgKiBmb3JiaWRkZW4gdG8gcnVuIGNvbXBsZXRlX2pvYnMgYWZ0ZXIgaW9fam9icyBhbmQgYmVmb3JlCisJICogdW5wbHVnIGJlY2F1c2UgdGhlIGJsb2NrIGRldmljZSBjb3VsZCBiZSBkZXN0cm95ZWQgaW4KKwkgKiBqb2IgY29tcGxldGlvbiBjYWxsYmFjay4KIAkgKi8KIAlwcm9jZXNzX2pvYnMoJmtjLT5jb21wbGV0ZV9qb2JzLCBrYywgcnVuX2NvbXBsZXRlX2pvYik7CiAJcHJvY2Vzc19qb2JzKCZrYy0+cGFnZXNfam9icywga2MsIHJ1bl9wYWdlc19qb2IpOwogCXByb2Nlc3Nfam9icygma2MtPmlvX2pvYnMsIGtjLCBydW5faW9fam9iKTsKKwl1bnBsdWcoa2MsIFJFQUQpOworCXVucGx1ZyhrYywgV1JJVEUpOwogfQogCiAvKgpAQCAtNjE5LDEyICs2NjUsMTUgQEAKIAlJTklUX0xJU1RfSEVBRCgma2MtPmlvX2pvYnMpOwogCUlOSVRfTElTVF9IRUFEKCZrYy0+cGFnZXNfam9icyk7CiAKKwltZW1zZXQoa2MtPnVucGx1ZywgMCwgc2l6ZW9mKGtjLT51bnBsdWcpKTsKKwogCWtjLT5qb2JfcG9vbCA9IG1lbXBvb2xfY3JlYXRlX3NsYWJfcG9vbChNSU5fSk9CUywgX2pvYl9jYWNoZSk7CiAJaWYgKCFrYy0+am9iX3Bvb2wpCiAJCWdvdG8gYmFkX3NsYWI7CiAKIAlJTklUX1dPUksoJmtjLT5rY29weWRfd29yaywgZG9fd29yayk7Ci0Ja2MtPmtjb3B5ZF93cSA9IGNyZWF0ZV9zaW5nbGV0aHJlYWRfd29ya3F1ZXVlKCJrY29weWQiKTsKKwlrYy0+a2NvcHlkX3dxID0gYWxsb2Nfd29ya3F1ZXVlKCJrY29weWQiLAorCQkJCQlXUV9OT05fUkVFTlRSQU5UIHwgV1FfTUVNX1JFQ0xBSU0sIDApOwogCWlmICgha2MtPmtjb3B5ZF93cSkKIAkJZ290byBiYWRfd29ya3F1ZXVlOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLWxvZy11c2Vyc3BhY2UtYmFzZS5jIGIvZHJpdmVycy9tZC9kbS1sb2ctdXNlcnNwYWNlLWJhc2UuYwppbmRleCAxZWQwMDk0Li5hYTJlMGMzIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLWxvZy11c2Vyc3BhY2UtYmFzZS5jCisrKyBiL2RyaXZlcnMvbWQvZG0tbG9nLXVzZXJzcGFjZS1iYXNlLmMKQEAgLTEyLDEyICsxMiwyMiBAQAogCiAjaW5jbHVkZSAiZG0tbG9nLXVzZXJzcGFjZS10cmFuc2Zlci5oIgogCisjZGVmaW5lIERNX0xPR19VU0VSU1BBQ0VfVlNOICIxLjEuMCIKKwogc3RydWN0IGZsdXNoX2VudHJ5IHsKIAlpbnQgdHlwZTsKIAlyZWdpb25fdCByZWdpb247CiAJc3RydWN0IGxpc3RfaGVhZCBsaXN0OwogfTsKIAorLyoKKyAqIFRoaXMgbGltaXQgb24gdGhlIG51bWJlciBvZiBtYXJrIGFuZCBjbGVhciByZXF1ZXN0IGlzLCB0byBhIGRlZ3JlZSwKKyAqIGFyYml0cmFyeS4gIEhvd2V2ZXIsIHRoZXJlIGlzIHNvbWUgYmFzaXMgZm9yIHRoZSBjaG9pY2UgaW4gdGhlIGxpbWl0cworICogaW1wb3NlZCBvbiB0aGUgc2l6ZSBvZiBkYXRhIHBheWxvYWQgYnkgZG0tbG9nLXVzZXJzcGFjZS10cmFuc2Zlci5jOgorICogZG1fY29uc3VsdF91c2Vyc3BhY2UoKS4KKyAqLworI2RlZmluZSBNQVhfRkxVU0hfR1JPVVBfQ09VTlQgMzIKKwogc3RydWN0IGxvZ19jIHsKIAlzdHJ1Y3QgZG1fdGFyZ2V0ICp0aTsKIAl1aW50MzJfdCByZWdpb25fc2l6ZTsKQEAgLTM3LDggKzQ3LDE1IEBACiAJICovCiAJdWludDY0X3QgaW5fc3luY19oaW50OwogCisJLyoKKwkgKiBNYXJrIGFuZCBjbGVhciByZXF1ZXN0cyBhcmUgaGVsZCB1bnRpbCBhIGZsdXNoIGlzIGlzc3VlZAorCSAqIHNvIHRoYXQgd2UgY2FuIGdyb3VwLCBhbmQgdGhlcmVieSBsaW1pdCwgdGhlIGFtb3VudCBvZgorCSAqIG5ldHdvcmsgdHJhZmZpYyBiZXR3ZWVuIGtlcm5lbCBhbmQgdXNlcnNwYWNlLiAgVGhlICdmbHVzaF9sb2NrJworCSAqIGlzIHVzZWQgdG8gcHJvdGVjdCB0aGVzZSBsaXN0cy4KKwkgKi8KIAlzcGlubG9ja190IGZsdXNoX2xvY2s7Ci0Jc3RydWN0IGxpc3RfaGVhZCBmbHVzaF9saXN0OyAgLyogb25seSBmb3IgY2xlYXIgYW5kIG1hcmsgcmVxdWVzdHMgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIG1hcmtfbGlzdDsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGNsZWFyX2xpc3Q7CiB9OwogCiBzdGF0aWMgbWVtcG9vbF90ICpmbHVzaF9lbnRyeV9wb29sOwpAQCAtMTY5LDcgKzE4Niw4IEBACiAKIAlzdHJuY3B5KGxjLT51dWlkLCBhcmd2WzBdLCBETV9VVUlEX0xFTik7CiAJc3Bpbl9sb2NrX2luaXQoJmxjLT5mbHVzaF9sb2NrKTsKLQlJTklUX0xJU1RfSEVBRCgmbGMtPmZsdXNoX2xpc3QpOworCUlOSVRfTElTVF9IRUFEKCZsYy0+bWFya19saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmbGMtPmNsZWFyX2xpc3QpOwogCiAJc3RyX3NpemUgPSBidWlsZF9jb25zdHJ1Y3Rvcl9zdHJpbmcodGksIGFyZ2MgLSAxLCBhcmd2ICsgMSwgJmN0cl9zdHIpOwogCWlmIChzdHJfc2l6ZSA8IDApIHsKQEAgLTE4MSw4ICsxOTksMTEgQEAKIAlyID0gZG1fY29uc3VsdF91c2Vyc3BhY2UobGMtPnV1aWQsIGxjLT5sdWlkLCBETV9VTE9HX0NUUiwKIAkJCQkgY3RyX3N0ciwgc3RyX3NpemUsIE5VTEwsIE5VTEwpOwogCi0JaWYgKHIgPT0gLUVTUkNIKSB7Ci0JCURNRVJSKCJVc2Vyc3BhY2UgbG9nIHNlcnZlciBub3QgZm91bmQiKTsKKwlpZiAociA8IDApIHsKKwkJaWYgKHIgPT0gLUVTUkNIKQorCQkJRE1FUlIoIlVzZXJzcGFjZSBsb2cgc2VydmVyIG5vdCBmb3VuZCIpOworCQllbHNlCisJCQlETUVSUigiVXNlcnNwYWNlIGxvZyBzZXJ2ZXIgZmFpbGVkIHRvIGNyZWF0ZSBsb2ciKTsKIAkJZ290byBvdXQ7CiAJfQogCkBAIC0yMTQsMTAgKzIzNSw5IEBACiAKIHN0YXRpYyB2b2lkIHVzZXJzcGFjZV9kdHIoc3RydWN0IGRtX2RpcnR5X2xvZyAqbG9nKQogewotCWludCByOwogCXN0cnVjdCBsb2dfYyAqbGMgPSBsb2ctPmNvbnRleHQ7CiAKLQlyID0gZG1fY29uc3VsdF91c2Vyc3BhY2UobGMtPnV1aWQsIGxjLT5sdWlkLCBETV9VTE9HX0RUUiwKKwkodm9pZCkgZG1fY29uc3VsdF91c2Vyc3BhY2UobGMtPnV1aWQsIGxjLT5sdWlkLCBETV9VTE9HX0RUUiwKIAkJCQkgTlVMTCwgMCwKIAkJCQkgTlVMTCwgTlVMTCk7CiAKQEAgLTMzOCw2ICszNTgsNzEgQEAKIAlyZXR1cm4gKHIpID8gMCA6IChpbnQpaW5fc3luYzsKIH0KIAorc3RhdGljIGludCBmbHVzaF9vbmVfYnlfb25lKHN0cnVjdCBsb2dfYyAqbGMsIHN0cnVjdCBsaXN0X2hlYWQgKmZsdXNoX2xpc3QpCit7CisJaW50IHIgPSAwOworCXN0cnVjdCBmbHVzaF9lbnRyeSAqZmU7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGZlLCBmbHVzaF9saXN0LCBsaXN0KSB7CisJCXIgPSB1c2Vyc3BhY2VfZG9fcmVxdWVzdChsYywgbGMtPnV1aWQsIGZlLT50eXBlLAorCQkJCQkgKGNoYXIgKikmZmUtPnJlZ2lvbiwKKwkJCQkJIHNpemVvZihmZS0+cmVnaW9uKSwKKwkJCQkJIE5VTEwsIE5VTEwpOworCQlpZiAocikKKwkJCWJyZWFrOworCX0KKworCXJldHVybiByOworfQorCitzdGF0aWMgaW50IGZsdXNoX2J5X2dyb3VwKHN0cnVjdCBsb2dfYyAqbGMsIHN0cnVjdCBsaXN0X2hlYWQgKmZsdXNoX2xpc3QpCit7CisJaW50IHIgPSAwOworCWludCBjb3VudDsKKwl1aW50MzJfdCB0eXBlID0gMDsKKwlzdHJ1Y3QgZmx1c2hfZW50cnkgKmZlLCAqdG1wX2ZlOworCUxJU1RfSEVBRCh0bXBfbGlzdCk7CisJdWludDY0X3QgZ3JvdXBbTUFYX0ZMVVNIX0dST1VQX0NPVU5UXTsKKworCS8qCisJICogR3JvdXAgcHJvY2VzcyB0aGUgcmVxdWVzdHMKKwkgKi8KKwl3aGlsZSAoIWxpc3RfZW1wdHkoZmx1c2hfbGlzdCkpIHsKKwkJY291bnQgPSAwOworCisJCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShmZSwgdG1wX2ZlLCBmbHVzaF9saXN0LCBsaXN0KSB7CisJCQlncm91cFtjb3VudF0gPSBmZS0+cmVnaW9uOworCQkJY291bnQrKzsKKworCQkJbGlzdF9kZWwoJmZlLT5saXN0KTsKKwkJCWxpc3RfYWRkKCZmZS0+bGlzdCwgJnRtcF9saXN0KTsKKworCQkJdHlwZSA9IGZlLT50eXBlOworCQkJaWYgKGNvdW50ID49IE1BWF9GTFVTSF9HUk9VUF9DT1VOVCkKKwkJCQlicmVhazsKKwkJfQorCisJCXIgPSB1c2Vyc3BhY2VfZG9fcmVxdWVzdChsYywgbGMtPnV1aWQsIHR5cGUsCisJCQkJCSAoY2hhciAqKShncm91cCksCisJCQkJCSBjb3VudCAqIHNpemVvZih1aW50NjRfdCksCisJCQkJCSBOVUxMLCBOVUxMKTsKKwkJaWYgKHIpIHsKKwkJCS8qIEdyb3VwIHNlbmQgZmFpbGVkLiAgQXR0ZW1wdCBvbmUtYnktb25lLiAqLworCQkJbGlzdF9zcGxpY2VfaW5pdCgmdG1wX2xpc3QsIGZsdXNoX2xpc3QpOworCQkJciA9IGZsdXNoX29uZV9ieV9vbmUobGMsIGZsdXNoX2xpc3QpOworCQkJYnJlYWs7CisJCX0KKwl9CisKKwkvKgorCSAqIE11c3QgY29sbGVjdCBmbHVzaF9lbnRyeXMgdGhhdCB3ZXJlIHN1Y2Nlc3NmdWxseSBwcm9jZXNzZWQKKwkgKiBhcyBhIGdyb3VwIHNvIHRoYXQgdGhleSB3aWxsIGJlIGZyZWUnZCBieSB0aGUgY2FsbGVyLgorCSAqLworCWxpc3Rfc3BsaWNlX2luaXQoJnRtcF9saXN0LCBmbHVzaF9saXN0KTsKKworCXJldHVybiByOworfQorCiAvKgogICogdXNlcnNwYWNlX2ZsdXNoCiAgKgpAQCAtMzYwLDMxICs0NDUsMjUgQEAKIAlpbnQgciA9IDA7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAlzdHJ1Y3QgbG9nX2MgKmxjID0gbG9nLT5jb250ZXh0OwotCUxJU1RfSEVBRChmbHVzaF9saXN0KTsKKwlMSVNUX0hFQUQobWFya19saXN0KTsKKwlMSVNUX0hFQUQoY2xlYXJfbGlzdCk7CiAJc3RydWN0IGZsdXNoX2VudHJ5ICpmZSwgKnRtcF9mZTsKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZsYy0+Zmx1c2hfbG9jaywgZmxhZ3MpOwotCWxpc3Rfc3BsaWNlX2luaXQoJmxjLT5mbHVzaF9saXN0LCAmZmx1c2hfbGlzdCk7CisJbGlzdF9zcGxpY2VfaW5pdCgmbGMtPm1hcmtfbGlzdCwgJm1hcmtfbGlzdCk7CisJbGlzdF9zcGxpY2VfaW5pdCgmbGMtPmNsZWFyX2xpc3QsICZjbGVhcl9saXN0KTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZsYy0+Zmx1c2hfbG9jaywgZmxhZ3MpOwogCi0JaWYgKGxpc3RfZW1wdHkoJmZsdXNoX2xpc3QpKQorCWlmIChsaXN0X2VtcHR5KCZtYXJrX2xpc3QpICYmIGxpc3RfZW1wdHkoJmNsZWFyX2xpc3QpKQogCQlyZXR1cm4gMDsKIAotCS8qCi0JICogRklYTUU6IENvdW50IHVwIHJlcXVlc3RzLCBncm91cCByZXF1ZXN0IHR5cGVzLAotCSAqIGFsbG9jYXRlIG1lbW9yeSB0byBzdGljayBhbGwgcmVxdWVzdHMgaW4gYW5kCi0JICogc2VuZCB0byBzZXJ2ZXIgaW4gb25lIGdvLiAgRmFpbGluZyB0aGUgYWxsb2NhdGlvbiwKLQkgKiBkbyBpdCBvbmUgYnkgb25lLgotCSAqLworCXIgPSBmbHVzaF9ieV9ncm91cChsYywgJm1hcmtfbGlzdCk7CisJaWYgKHIpCisJCWdvdG8gZmFpbDsKIAotCWxpc3RfZm9yX2VhY2hfZW50cnkoZmUsICZmbHVzaF9saXN0LCBsaXN0KSB7Ci0JCXIgPSB1c2Vyc3BhY2VfZG9fcmVxdWVzdChsYywgbGMtPnV1aWQsIGZlLT50eXBlLAotCQkJCQkgKGNoYXIgKikmZmUtPnJlZ2lvbiwKLQkJCQkJIHNpemVvZihmZS0+cmVnaW9uKSwKLQkJCQkJIE5VTEwsIE5VTEwpOwotCQlpZiAocikKLQkJCWdvdG8gZmFpbDsKLQl9CisJciA9IGZsdXNoX2J5X2dyb3VwKGxjLCAmY2xlYXJfbGlzdCk7CisJaWYgKHIpCisJCWdvdG8gZmFpbDsKIAogCXIgPSB1c2Vyc3BhY2VfZG9fcmVxdWVzdChsYywgbGMtPnV1aWQsIERNX1VMT0dfRkxVU0gsCiAJCQkJIE5VTEwsIDAsIE5VTEwsIE5VTEwpOwpAQCAtMzk1LDcgKzQ3NCwxMSBAQAogCSAqIENhbGxpbmcgY29kZSB3aWxsIHJlY2VpdmUgYW4gZXJyb3IgYW5kIHdpbGwga25vdyB0aGF0CiAJICogdGhlIGxvZyBmYWNpbGl0eSBoYXMgZmFpbGVkLgogCSAqLwotCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShmZSwgdG1wX2ZlLCAmZmx1c2hfbGlzdCwgbGlzdCkgeworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShmZSwgdG1wX2ZlLCAmbWFya19saXN0LCBsaXN0KSB7CisJCWxpc3RfZGVsKCZmZS0+bGlzdCk7CisJCW1lbXBvb2xfZnJlZShmZSwgZmx1c2hfZW50cnlfcG9vbCk7CisJfQorCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShmZSwgdG1wX2ZlLCAmY2xlYXJfbGlzdCwgbGlzdCkgewogCQlsaXN0X2RlbCgmZmUtPmxpc3QpOwogCQltZW1wb29sX2ZyZWUoZmUsIGZsdXNoX2VudHJ5X3Bvb2wpOwogCX0KQEAgLTQyNSw3ICs1MDgsNyBAQAogCXNwaW5fbG9ja19pcnFzYXZlKCZsYy0+Zmx1c2hfbG9jaywgZmxhZ3MpOwogCWZlLT50eXBlID0gRE1fVUxPR19NQVJLX1JFR0lPTjsKIAlmZS0+cmVnaW9uID0gcmVnaW9uOwotCWxpc3RfYWRkKCZmZS0+bGlzdCwgJmxjLT5mbHVzaF9saXN0KTsKKwlsaXN0X2FkZCgmZmUtPmxpc3QsICZsYy0+bWFya19saXN0KTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZsYy0+Zmx1c2hfbG9jaywgZmxhZ3MpOwogCiAJcmV0dXJuOwpAQCAtNDYyLDcgKzU0NSw3IEBACiAJc3Bpbl9sb2NrX2lycXNhdmUoJmxjLT5mbHVzaF9sb2NrLCBmbGFncyk7CiAJZmUtPnR5cGUgPSBETV9VTE9HX0NMRUFSX1JFR0lPTjsKIAlmZS0+cmVnaW9uID0gcmVnaW9uOwotCWxpc3RfYWRkKCZmZS0+bGlzdCwgJmxjLT5mbHVzaF9saXN0KTsKKwlsaXN0X2FkZCgmZmUtPmxpc3QsICZsYy0+Y2xlYXJfbGlzdCk7CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmbGMtPmZsdXNoX2xvY2ssIGZsYWdzKTsKIAogCXJldHVybjsKQEAgLTY4NCw3ICs3NjcsNyBAQAogCQlyZXR1cm4gcjsKIAl9CiAKLQlETUlORk8oInZlcnNpb24gMS4wLjAgbG9hZGVkIik7CisJRE1JTkZPKCJ2ZXJzaW9uICIgRE1fTE9HX1VTRVJTUEFDRV9WU04gIiBsb2FkZWQiKTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtNjk0LDcgKzc3Nyw3IEBACiAJZG1fdWxvZ190ZnJfZXhpdCgpOwogCW1lbXBvb2xfZGVzdHJveShmbHVzaF9lbnRyeV9wb29sKTsKIAotCURNSU5GTygidmVyc2lvbiAxLjAuMCB1bmxvYWRlZCIpOworCURNSU5GTygidmVyc2lvbiAiIERNX0xPR19VU0VSU1BBQ0VfVlNOICIgdW5sb2FkZWQiKTsKIAlyZXR1cm47CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvZG0tbG9nLXVzZXJzcGFjZS10cmFuc2Zlci5jIGIvZHJpdmVycy9tZC9kbS1sb2ctdXNlcnNwYWNlLXRyYW5zZmVyLmMKaW5kZXggMDc1Y2JjZi4uMDQ5ZWFmMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1sb2ctdXNlcnNwYWNlLXRyYW5zZmVyLmMKKysrIGIvZHJpdmVycy9tZC9kbS1sb2ctdXNlcnNwYWNlLXRyYW5zZmVyLmMKQEAgLTE5OCw2ICsxOTgsNyBAQAogCiAJbWVtc2V0KHRmciwgMCwgRE1fVUxPR19QUkVBTExPQ0VEX1NJWkUgLSBzaXplb2Yoc3RydWN0IGNuX21zZykpOwogCW1lbWNweSh0ZnItPnV1aWQsIHV1aWQsIERNX1VVSURfTEVOKTsKKwl0ZnItPnZlcnNpb24gPSBETV9VTE9HX1JFUVVFU1RfVkVSU0lPTjsKIAl0ZnItPmx1aWQgPSBsdWlkOwogCXRmci0+c2VxID0gZG1fdWxvZ19zZXErKzsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1sb2cuYyBiL2RyaXZlcnMvbWQvZG0tbG9nLmMKaW5kZXggMzM0MjBlNi4uNjk1MTUzNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1sb2cuYworKysgYi9kcml2ZXJzL21kL2RtLWxvZy5jCkBAIC00NTUsNyArNDU1LDcgQEAKIAkJCXIgPSBQVFJfRVJSKGxjLT5pb19yZXEuY2xpZW50KTsKIAkJCURNV0FSTigiY291bGRuJ3QgYWxsb2NhdGUgZGlzayBpbyBjbGllbnQiKTsKIAkJCWtmcmVlKGxjKTsKLQkJCXJldHVybiAtRU5PTUVNOworCQkJcmV0dXJuIHI7CiAJCX0KIAogCQlsYy0+ZGlza19oZWFkZXIgPSB2bWFsbG9jKGJ1Zl9zaXplKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvZG0tbXBhdGguYyBiL2RyaXZlcnMvbWQvZG0tbXBhdGguYwppbmRleCA0ODdlY2RhLi5iODJkMjg4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLW1wYXRoLmMKKysrIGIvZHJpdmVycy9tZC9kbS1tcGF0aC5jCkBAIC0yMyw2ICsyMyw4IEBACiAKICNkZWZpbmUgRE1fTVNHX1BSRUZJWCAibXVsdGlwYXRoIgogI2RlZmluZSBNRVNHX1NUUih4KSB4LCBzaXplb2YoeCkKKyNkZWZpbmUgRE1fUEdfSU5JVF9ERUxBWV9NU0VDUyAyMDAwCisjZGVmaW5lIERNX1BHX0lOSVRfREVMQVlfREVGQVVMVCAoKHVuc2lnbmVkKSAtMSkKIAogLyogUGF0aCBwcm9wZXJ0aWVzICovCiBzdHJ1Y3QgcGdwYXRoIHsKQEAgLTMzLDggKzM1LDcgQEAKIAl1bnNpZ25lZCBmYWlsX2NvdW50OwkJLyogQ3VtdWxhdGl2ZSBmYWlsdXJlIGNvdW50ICovCiAKIAlzdHJ1Y3QgZG1fcGF0aCBwYXRoOwotCXN0cnVjdCB3b3JrX3N0cnVjdCBkZWFjdGl2YXRlX3BhdGg7Ci0Jc3RydWN0IHdvcmtfc3RydWN0IGFjdGl2YXRlX3BhdGg7CisJc3RydWN0IGRlbGF5ZWRfd29yayBhY3RpdmF0ZV9wYXRoOwogfTsKIAogI2RlZmluZSBwYXRoX3RvX3BncGF0aChfX3BncCkgY29udGFpbmVyX29mKChfX3BncCksIHN0cnVjdCBwZ3BhdGgsIHBhdGgpCkBAIC02NSwxMSArNjYsMTUgQEAKIAogCWNvbnN0IGNoYXIgKmh3X2hhbmRsZXJfbmFtZTsKIAljaGFyICpod19oYW5kbGVyX3BhcmFtczsKKwogCXVuc2lnbmVkIG5yX3ByaW9yaXR5X2dyb3VwczsKIAlzdHJ1Y3QgbGlzdF9oZWFkIHByaW9yaXR5X2dyb3VwczsKKworCXdhaXRfcXVldWVfaGVhZF90IHBnX2luaXRfd2FpdDsJLyogV2FpdCBmb3IgcGdfaW5pdCBjb21wbGV0aW9uICovCisKIAl1bnNpZ25lZCBwZ19pbml0X3JlcXVpcmVkOwkvKiBwZ19pbml0IG5lZWRzIGNhbGxpbmc/ICovCiAJdW5zaWduZWQgcGdfaW5pdF9pbl9wcm9ncmVzczsJLyogT25seSBvbmUgcGdfaW5pdCBhbGxvd2VkIGF0IG9uY2UgKi8KLQl3YWl0X3F1ZXVlX2hlYWRfdCBwZ19pbml0X3dhaXQ7CS8qIFdhaXQgZm9yIHBnX2luaXQgY29tcGxldGlvbiAqLworCXVuc2lnbmVkIHBnX2luaXRfZGVsYXlfcmV0cnk7CS8qIERlbGF5IHBnX2luaXQgcmV0cnk/ICovCiAKIAl1bnNpZ25lZCBucl92YWxpZF9wYXRoczsJLyogVG90YWwgbnVtYmVyIG9mIHVzYWJsZSBwYXRocyAqLwogCXN0cnVjdCBwZ3BhdGggKmN1cnJlbnRfcGdwYXRoOwpAQCAtODIsNiArODcsNyBAQAogCXVuc2lnbmVkIHNhdmVkX3F1ZXVlX2lmX25vX3BhdGg7LyogU2F2ZWQgc3RhdGUgZHVyaW5nIHN1c3BlbnNpb24gKi8KIAl1bnNpZ25lZCBwZ19pbml0X3JldHJpZXM7CS8qIE51bWJlciBvZiB0aW1lcyB0byByZXRyeSBwZ19pbml0ICovCiAJdW5zaWduZWQgcGdfaW5pdF9jb3VudDsJCS8qIE51bWJlciBvZiB0aW1lcyBwZ19pbml0IGNhbGxlZCAqLworCXVuc2lnbmVkIHBnX2luaXRfZGVsYXlfbXNlY3M7CS8qIE51bWJlciBvZiBtc2VjcyBiZWZvcmUgcGdfaW5pdCByZXRyeSAqLwogCiAJc3RydWN0IHdvcmtfc3RydWN0IHByb2Nlc3NfcXVldWVkX2lvczsKIAlzdHJ1Y3QgbGlzdF9oZWFkIHF1ZXVlZF9pb3M7CkBAIC0xMTYsNyArMTIyLDYgQEAKIHN0YXRpYyB2b2lkIHByb2Nlc3NfcXVldWVkX2lvcyhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspOwogc3RhdGljIHZvaWQgdHJpZ2dlcl9ldmVudChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspOwogc3RhdGljIHZvaWQgYWN0aXZhdGVfcGF0aChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspOwotc3RhdGljIHZvaWQgZGVhY3RpdmF0ZV9wYXRoKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yayk7CiAKIAogLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpAQCAtMTI5LDggKzEzNCw3IEBACiAKIAlpZiAocGdwYXRoKSB7CiAJCXBncGF0aC0+aXNfYWN0aXZlID0gMTsKLQkJSU5JVF9XT1JLKCZwZ3BhdGgtPmRlYWN0aXZhdGVfcGF0aCwgZGVhY3RpdmF0ZV9wYXRoKTsKLQkJSU5JVF9XT1JLKCZwZ3BhdGgtPmFjdGl2YXRlX3BhdGgsIGFjdGl2YXRlX3BhdGgpOworCQlJTklUX0RFTEFZRURfV09SSygmcGdwYXRoLT5hY3RpdmF0ZV9wYXRoLCBhY3RpdmF0ZV9wYXRoKTsKIAl9CiAKIAlyZXR1cm4gcGdwYXRoOwpAQCAtMTQxLDE0ICsxNDUsNiBAQAogCWtmcmVlKHBncGF0aCk7CiB9CiAKLXN0YXRpYyB2b2lkIGRlYWN0aXZhdGVfcGF0aChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCi17Ci0Jc3RydWN0IHBncGF0aCAqcGdwYXRoID0KLQkJY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBwZ3BhdGgsIGRlYWN0aXZhdGVfcGF0aCk7Ci0KLQlibGtfYWJvcnRfcXVldWUocGdwYXRoLT5wYXRoLmRldi0+YmRldi0+YmRfZGlzay0+cXVldWUpOwotfQotCiBzdGF0aWMgc3RydWN0IHByaW9yaXR5X2dyb3VwICphbGxvY19wcmlvcml0eV9ncm91cCh2b2lkKQogewogCXN0cnVjdCBwcmlvcml0eV9ncm91cCAqcGc7CkBAIC0xOTksNiArMTk1LDcgQEAKIAkJSU5JVF9MSVNUX0hFQUQoJm0tPnF1ZXVlZF9pb3MpOwogCQlzcGluX2xvY2tfaW5pdCgmbS0+bG9jayk7CiAJCW0tPnF1ZXVlX2lvID0gMTsKKwkJbS0+cGdfaW5pdF9kZWxheV9tc2VjcyA9IERNX1BHX0lOSVRfREVMQVlfREVGQVVMVDsKIAkJSU5JVF9XT1JLKCZtLT5wcm9jZXNzX3F1ZXVlZF9pb3MsIHByb2Nlc3NfcXVldWVkX2lvcyk7CiAJCUlOSVRfV09SSygmbS0+dHJpZ2dlcl9ldmVudCwgdHJpZ2dlcl9ldmVudCk7CiAJCWluaXRfd2FpdHF1ZXVlX2hlYWQoJm0tPnBnX2luaXRfd2FpdCk7CkBAIC0yMzgsMTQgKzIzNSwxOSBAQAogc3RhdGljIHZvaWQgX19wZ19pbml0X2FsbF9wYXRocyhzdHJ1Y3QgbXVsdGlwYXRoICptKQogewogCXN0cnVjdCBwZ3BhdGggKnBncGF0aDsKKwl1bnNpZ25lZCBsb25nIHBnX2luaXRfZGVsYXkgPSAwOwogCiAJbS0+cGdfaW5pdF9jb3VudCsrOwogCW0tPnBnX2luaXRfcmVxdWlyZWQgPSAwOworCWlmIChtLT5wZ19pbml0X2RlbGF5X3JldHJ5KQorCQlwZ19pbml0X2RlbGF5ID0gbXNlY3NfdG9famlmZmllcyhtLT5wZ19pbml0X2RlbGF5X21zZWNzICE9IERNX1BHX0lOSVRfREVMQVlfREVGQVVMVCA/CisJCQkJCQkgbS0+cGdfaW5pdF9kZWxheV9tc2VjcyA6IERNX1BHX0lOSVRfREVMQVlfTVNFQ1MpOwogCWxpc3RfZm9yX2VhY2hfZW50cnkocGdwYXRoLCAmbS0+Y3VycmVudF9wZy0+cGdwYXRocywgbGlzdCkgewogCQkvKiBTa2lwIGZhaWxlZCBwYXRocyAqLwogCQlpZiAoIXBncGF0aC0+aXNfYWN0aXZlKQogCQkJY29udGludWU7Ci0JCWlmIChxdWV1ZV93b3JrKGttcGF0aF9oYW5kbGVyZCwgJnBncGF0aC0+YWN0aXZhdGVfcGF0aCkpCisJCWlmIChxdWV1ZV9kZWxheWVkX3dvcmsoa21wYXRoX2hhbmRsZXJkLCAmcGdwYXRoLT5hY3RpdmF0ZV9wYXRoLAorCQkJCSAgICAgICBwZ19pbml0X2RlbGF5KSkKIAkJCW0tPnBnX2luaXRfaW5fcHJvZ3Jlc3MrKzsKIAl9CiB9CkBAIC03OTMsOCArNzk1LDkgQEAKIAljb25zdCBjaGFyICpwYXJhbV9uYW1lOwogCiAJc3RhdGljIHN0cnVjdCBwYXJhbSBfcGFyYW1zW10gPSB7Ci0JCXswLCAzLCAiaW52YWxpZCBudW1iZXIgb2YgZmVhdHVyZSBhcmdzIn0sCisJCXswLCA1LCAiaW52YWxpZCBudW1iZXIgb2YgZmVhdHVyZSBhcmdzIn0sCiAJCXsxLCA1MCwgInBnX2luaXRfcmV0cmllcyBtdXN0IGJlIGJldHdlZW4gMSBhbmQgNTAifSwKKwkJezAsIDYwMDAwLCAicGdfaW5pdF9kZWxheV9tc2VjcyBtdXN0IGJlIGJldHdlZW4gMCBhbmQgNjAwMDAifSwKIAl9OwogCiAJciA9IHJlYWRfcGFyYW0oX3BhcmFtcywgc2hpZnQoYXMpLCAmYXJnYywgJnRpLT5lcnJvcik7CkBAIC04MjEsNiArODI0LDE0IEBACiAJCQljb250aW51ZTsKIAkJfQogCisJCWlmICghc3RybmljbXAocGFyYW1fbmFtZSwgTUVTR19TVFIoInBnX2luaXRfZGVsYXlfbXNlY3MiKSkgJiYKKwkJICAgIChhcmdjID49IDEpKSB7CisJCQlyID0gcmVhZF9wYXJhbShfcGFyYW1zICsgMiwgc2hpZnQoYXMpLAorCQkJCSAgICAgICAmbS0+cGdfaW5pdF9kZWxheV9tc2VjcywgJnRpLT5lcnJvcik7CisJCQlhcmdjLS07CisJCQljb250aW51ZTsKKwkJfQorCiAJCXRpLT5lcnJvciA9ICJVbnJlY29nbmlzZWQgbXVsdGlwYXRoIGZlYXR1cmUgcmVxdWVzdCI7CiAJCXIgPSAtRUlOVkFMOwogCX0gd2hpbGUgKGFyZ2MgJiYgIXIpOwpAQCAtOTMxLDcgKzk0Miw3IEBACiAJZmx1c2hfd29ya3F1ZXVlKGttcGF0aF9oYW5kbGVyZCk7CiAJbXVsdGlwYXRoX3dhaXRfZm9yX3BnX2luaXRfY29tcGxldGlvbihtKTsKIAlmbHVzaF93b3JrcXVldWUoa211bHRpcGF0aGQpOwotCWZsdXNoX3NjaGVkdWxlZF93b3JrKCk7CisJZmx1c2hfd29ya19zeW5jKCZtLT50cmlnZ2VyX2V2ZW50KTsKIH0KIAogc3RhdGljIHZvaWQgbXVsdGlwYXRoX2R0cihzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSkKQEAgLTk5NSw3ICsxMDA2LDYgQEAKIAkJICAgICAgcGdwYXRoLT5wYXRoLmRldi0+bmFtZSwgbS0+bnJfdmFsaWRfcGF0aHMpOwogCiAJc2NoZWR1bGVfd29yaygmbS0+dHJpZ2dlcl9ldmVudCk7Ci0JcXVldWVfd29yayhrbXVsdGlwYXRoZCwgJnBncGF0aC0+ZGVhY3RpdmF0ZV9wYXRoKTsKIAogb3V0OgogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm0tPmxvY2ssIGZsYWdzKTsKQEAgLTEwMzQsNyArMTA0NCw3IEBACiAJCW0tPmN1cnJlbnRfcGdwYXRoID0gTlVMTDsKIAkJcXVldWVfd29yayhrbXVsdGlwYXRoZCwgJm0tPnByb2Nlc3NfcXVldWVkX2lvcyk7CiAJfSBlbHNlIGlmIChtLT5od19oYW5kbGVyX25hbWUgJiYgKG0tPmN1cnJlbnRfcGcgPT0gcGdwYXRoLT5wZykpIHsKLQkJaWYgKHF1ZXVlX3dvcmsoa21wYXRoX2hhbmRsZXJkLCAmcGdwYXRoLT5hY3RpdmF0ZV9wYXRoKSkKKwkJaWYgKHF1ZXVlX3dvcmsoa21wYXRoX2hhbmRsZXJkLCAmcGdwYXRoLT5hY3RpdmF0ZV9wYXRoLndvcmspKQogCQkJbS0+cGdfaW5pdF9pbl9wcm9ncmVzcysrOwogCX0KIApAQCAtMTE2OSw2ICsxMTc5LDcgQEAKIAlzdHJ1Y3QgcHJpb3JpdHlfZ3JvdXAgKnBnID0gcGdwYXRoLT5wZzsKIAlzdHJ1Y3QgbXVsdGlwYXRoICptID0gcGctPm07CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKKwl1bnNpZ25lZCBkZWxheV9yZXRyeSA9IDA7CiAKIAkvKiBkZXZpY2Ugb3IgZHJpdmVyIHByb2JsZW1zICovCiAJc3dpdGNoIChlcnJvcnMpIHsKQEAgLTExOTMsOCArMTIwNCw5IEBACiAJCSAqLwogCQlieXBhc3NfcGcobSwgcGcsIDEpOwogCQlicmVhazsKLQkvKiBUT0RPOiBGb3IgU0NTSV9ESF9SRVRSWSB3ZSBzaG91bGQgd2FpdCBhIGNvdXBsZSBzZWNvbmRzICovCiAJY2FzZSBTQ1NJX0RIX1JFVFJZOgorCQkvKiBXYWl0IGJlZm9yZSByZXRyeWluZy4gKi8KKwkJZGVsYXlfcmV0cnkgPSAxOwogCWNhc2UgU0NTSV9ESF9JTU1fUkVUUlk6CiAJY2FzZSBTQ1NJX0RIX1JFU19URU1QX1VOQVZBSUw6CiAJCWlmIChwZ19pbml0X2xpbWl0X3JlYWNoZWQobSwgcGdwYXRoKSkKQEAgLTEyMjcsNiArMTIzOSw3IEBACiAJaWYgKCFtLT5wZ19pbml0X3JlcXVpcmVkKQogCQltLT5xdWV1ZV9pbyA9IDA7CiAKKwltLT5wZ19pbml0X2RlbGF5X3JldHJ5ID0gZGVsYXlfcmV0cnk7CiAJcXVldWVfd29yayhrbXVsdGlwYXRoZCwgJm0tPnByb2Nlc3NfcXVldWVkX2lvcyk7CiAKIAkvKgpAQCAtMTI0MSw3ICsxMjU0LDcgQEAKIHN0YXRpYyB2b2lkIGFjdGl2YXRlX3BhdGgoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogewogCXN0cnVjdCBwZ3BhdGggKnBncGF0aCA9Ci0JCWNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3QgcGdwYXRoLCBhY3RpdmF0ZV9wYXRoKTsKKwkJY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBwZ3BhdGgsIGFjdGl2YXRlX3BhdGgud29yayk7CiAKIAlzY3NpX2RoX2FjdGl2YXRlKGJkZXZfZ2V0X3F1ZXVlKHBncGF0aC0+cGF0aC5kZXYtPmJkZXYpLAogCQkJCXBnX2luaXRfZG9uZSwgcGdwYXRoKTsKQEAgLTEzODIsMTEgKzEzOTUsMTQgQEAKIAkJRE1FTUlUKCIyICV1ICV1ICIsIG0tPnF1ZXVlX3NpemUsIG0tPnBnX2luaXRfY291bnQpOwogCWVsc2UgewogCQlETUVNSVQoIiV1ICIsIG0tPnF1ZXVlX2lmX25vX3BhdGggKwotCQkJICAgICAgKG0tPnBnX2luaXRfcmV0cmllcyA+IDApICogMik7CisJCQkgICAgICAobS0+cGdfaW5pdF9yZXRyaWVzID4gMCkgKiAyICsKKwkJCSAgICAgIChtLT5wZ19pbml0X2RlbGF5X21zZWNzICE9IERNX1BHX0lOSVRfREVMQVlfREVGQVVMVCkgKiAyKTsKIAkJaWYgKG0tPnF1ZXVlX2lmX25vX3BhdGgpCiAJCQlETUVNSVQoInF1ZXVlX2lmX25vX3BhdGggIik7CiAJCWlmIChtLT5wZ19pbml0X3JldHJpZXMpCiAJCQlETUVNSVQoInBnX2luaXRfcmV0cmllcyAldSAiLCBtLT5wZ19pbml0X3JldHJpZXMpOworCQlpZiAobS0+cGdfaW5pdF9kZWxheV9tc2VjcyAhPSBETV9QR19JTklUX0RFTEFZX0RFRkFVTFQpCisJCQlETUVNSVQoInBnX2luaXRfZGVsYXlfbXNlY3MgJXUgIiwgbS0+cGdfaW5pdF9kZWxheV9tc2Vjcyk7CiAJfQogCiAJaWYgKCFtLT5od19oYW5kbGVyX25hbWUgfHwgdHlwZSA9PSBTVEFUVVNUWVBFX0lORk8pCkBAIC0xNjU1LDcgKzE2NzEsNyBAQAogICotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwogc3RhdGljIHN0cnVjdCB0YXJnZXRfdHlwZSBtdWx0aXBhdGhfdGFyZ2V0ID0gewogCS5uYW1lID0gIm11bHRpcGF0aCIsCi0JLnZlcnNpb24gPSB7MSwgMSwgMX0sCisJLnZlcnNpb24gPSB7MSwgMiwgMH0sCiAJLm1vZHVsZSA9IFRISVNfTU9EVUxFLAogCS5jdHIgPSBtdWx0aXBhdGhfY3RyLAogCS5kdHIgPSBtdWx0aXBhdGhfZHRyLApAQCAtMTY4Nyw3ICsxNzAzLDcgQEAKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCi0Ja211bHRpcGF0aGQgPSBjcmVhdGVfd29ya3F1ZXVlKCJrbXBhdGhkIik7CisJa211bHRpcGF0aGQgPSBhbGxvY193b3JrcXVldWUoImttcGF0aGQiLCBXUV9NRU1fUkVDTEFJTSwgMCk7CiAJaWYgKCFrbXVsdGlwYXRoZCkgewogCQlETUVSUigiZmFpbGVkIHRvIGNyZWF0ZSB3b3JrcXVldWUga21wYXRoZCIpOwogCQlkbV91bnJlZ2lzdGVyX3RhcmdldCgmbXVsdGlwYXRoX3RhcmdldCk7CkBAIC0xNzAxLDcgKzE3MTcsOCBAQAogCSAqIG9sZCB3b3JrcXVldWUgd291bGQgYWxzbyBjcmVhdGUgYSBib3R0bGVuZWNrIGluIHRoZQogCSAqIHBhdGggb2YgdGhlIHN0b3JhZ2UgaGFyZHdhcmUgZGV2aWNlIGFjdGl2YXRpb24uCiAJICovCi0Ja21wYXRoX2hhbmRsZXJkID0gY3JlYXRlX3NpbmdsZXRocmVhZF93b3JrcXVldWUoImttcGF0aF9oYW5kbGVyZCIpOworCWttcGF0aF9oYW5kbGVyZCA9IGFsbG9jX29yZGVyZWRfd29ya3F1ZXVlKCJrbXBhdGhfaGFuZGxlcmQiLAorCQkJCQkJICBXUV9NRU1fUkVDTEFJTSk7CiAJaWYgKCFrbXBhdGhfaGFuZGxlcmQpIHsKIAkJRE1FUlIoImZhaWxlZCB0byBjcmVhdGUgd29ya3F1ZXVlIGttcGF0aF9oYW5kbGVyZCIpOwogCQlkZXN0cm95X3dvcmtxdWV1ZShrbXVsdGlwYXRoZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLXJhaWQuYyBiL2RyaXZlcnMvbWQvZG0tcmFpZC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmI5ZTFlMTUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL21kL2RtLXJhaWQuYwpAQCAtMCwwICsxLDY5NyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMC0yMDExIE5laWwgQnJvd24KKyAqIENvcHlyaWdodCAoQykgMjAxMC0yMDExIFJlZCBIYXQsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBUaGlzIGZpbGUgaXMgcmVsZWFzZWQgdW5kZXIgdGhlIEdQTC4KKyAqLworCisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorCisjaW5jbHVkZSAibWQuaCIKKyNpbmNsdWRlICJyYWlkNS5oIgorI2luY2x1ZGUgImRtLmgiCisjaW5jbHVkZSAiYml0bWFwLmgiCisKKyNkZWZpbmUgRE1fTVNHX1BSRUZJWCAicmFpZCIKKworLyoKKyAqIElmIHRoZSBNRCBkb2Vzbid0IHN1cHBvcnQgTURfU1lOQ19TVEFURV9GT1JDRUQgeWV0LCB0aGVuCisgKiBtYWtlIGl0IHNvIHRoZSBmbGFnIGRvZXNuJ3Qgc2V0IGFueXRoaW5nLgorICovCisjaWZuZGVmIE1EX1NZTkNfU1RBVEVfRk9SQ0VECisjZGVmaW5lIE1EX1NZTkNfU1RBVEVfRk9SQ0VEIDAKKyNlbmRpZgorCitzdHJ1Y3QgcmFpZF9kZXYgeworCS8qCisJICogVHdvIERNIGRldmljZXMsIG9uZSB0byBob2xkIG1ldGFkYXRhIGFuZCBvbmUgdG8gaG9sZCB0aGUKKwkgKiBhY3R1YWwgZGF0YS9wYXJpdHkuICBUaGUgcmVhc29uIGZvciB0aGlzIGlzIHRvIG5vdCBjb25mdXNlCisJICogdGktPmxlbiBhbmQgZ2l2ZSBtb3JlIGZsZXhpYmlsaXR5IGluIGFsdGVyaW5nIHNpemUgYW5kCisJICogY2hhcmFjdGVyaXN0aWNzLgorCSAqCisJICogV2hpbGUgaXQgaXMgcG9zc2libGUgZm9yIHRoaXMgZGV2aWNlIHRvIGJlIGFzc29jaWF0ZWQKKwkgKiB3aXRoIGEgZGlmZmVyZW50IHBoeXNpY2FsIGRldmljZSB0aGFuIHRoZSBkYXRhX2RldiwgaXQKKwkgKiBpcyBpbnRlbmRlZCBmb3IgaXQgdG8gYmUgdGhlIHNhbWUuCisJICogICAgfC0tLS0tLS0tLSBQaHlzaWNhbCBEZXZpY2UgLS0tLS0tLS0tfAorCSAqICAgIHwtIG1ldGFfZGV2IC18LS0tLS0tIGRhdGFfZGV2IC0tLS0tLXwKKwkgKi8KKwlzdHJ1Y3QgZG1fZGV2ICptZXRhX2RldjsKKwlzdHJ1Y3QgZG1fZGV2ICpkYXRhX2RldjsKKwlzdHJ1Y3QgbWRrX3JkZXZfcyByZGV2OworfTsKKworLyoKKyAqIEZsYWdzIGZvciBycy0+cHJpbnRfZmxhZ3MgZmllbGQuCisgKi8KKyNkZWZpbmUgRE1QRl9EQUVNT05fU0xFRVAgICAgICAweDEKKyNkZWZpbmUgRE1QRl9NQVhfV1JJVEVfQkVISU5EICAweDIKKyNkZWZpbmUgRE1QRl9TWU5DICAgICAgICAgICAgICAweDQKKyNkZWZpbmUgRE1QRl9OT1NZTkMgICAgICAgICAgICAweDgKKyNkZWZpbmUgRE1QRl9TVFJJUEVfQ0FDSEUgICAgICAweDEwCisjZGVmaW5lIERNUEZfTUlOX1JFQ09WRVJZX1JBVEUgMHgyMAorI2RlZmluZSBETVBGX01BWF9SRUNPVkVSWV9SQVRFIDB4NDAKKworc3RydWN0IHJhaWRfc2V0IHsKKwlzdHJ1Y3QgZG1fdGFyZ2V0ICp0aTsKKworCXVpbnQ2NF90IHByaW50X2ZsYWdzOworCisJc3RydWN0IG1kZGV2X3MgbWQ7CisJc3RydWN0IHJhaWRfdHlwZSAqcmFpZF90eXBlOworCXN0cnVjdCBkbV90YXJnZXRfY2FsbGJhY2tzIGNhbGxiYWNrczsKKworCXN0cnVjdCByYWlkX2RldiBkZXZbMF07Cit9OworCisvKiBTdXBwb3J0ZWQgcmFpZCB0eXBlcyBhbmQgcHJvcGVydGllcy4gKi8KK3N0YXRpYyBzdHJ1Y3QgcmFpZF90eXBlIHsKKwljb25zdCBjaGFyICpuYW1lOwkJLyogUkFJRCBhbGdvcml0aG0uICovCisJY29uc3QgY2hhciAqZGVzY3I7CQkvKiBEZXNjcmlwdG9yIHRleHQgZm9yIGxvZ2dpbmcuICovCisJY29uc3QgdW5zaWduZWQgcGFyaXR5X2RldnM7CS8qICMgb2YgcGFyaXR5IGRldmljZXMuICovCisJY29uc3QgdW5zaWduZWQgbWluaW1hbF9kZXZzOwkvKiBtaW5pbWFsICMgb2YgZGV2aWNlcyBpbiBzZXQuICovCisJY29uc3QgdW5zaWduZWQgbGV2ZWw7CQkvKiBSQUlEIGxldmVsLiAqLworCWNvbnN0IHVuc2lnbmVkIGFsZ29yaXRobTsJLyogUkFJRCBhbGdvcml0aG0uICovCit9IHJhaWRfdHlwZXNbXSA9IHsKKwl7InJhaWQ0IiwgICAgIlJBSUQ0IChkZWRpY2F0ZWQgcGFyaXR5IGRpc2spIiwJMSwgMiwgNSwgQUxHT1JJVEhNX1BBUklUWV8wfSwKKwl7InJhaWQ1X2xhIiwgIlJBSUQ1IChsZWZ0IGFzeW1tZXRyaWMpIiwJCTEsIDIsIDUsIEFMR09SSVRITV9MRUZUX0FTWU1NRVRSSUN9LAorCXsicmFpZDVfcmEiLCAiUkFJRDUgKHJpZ2h0IGFzeW1tZXRyaWMpIiwJMSwgMiwgNSwgQUxHT1JJVEhNX1JJR0hUX0FTWU1NRVRSSUN9LAorCXsicmFpZDVfbHMiLCAiUkFJRDUgKGxlZnQgc3ltbWV0cmljKSIsCQkxLCAyLCA1LCBBTEdPUklUSE1fTEVGVF9TWU1NRVRSSUN9LAorCXsicmFpZDVfcnMiLCAiUkFJRDUgKHJpZ2h0IHN5bW1ldHJpYykiLAkJMSwgMiwgNSwgQUxHT1JJVEhNX1JJR0hUX1NZTU1FVFJJQ30sCisJeyJyYWlkNl96ciIsICJSQUlENiAoemVybyByZXN0YXJ0KSIsCQkyLCA0LCA2LCBBTEdPUklUSE1fUk9UQVRJTkdfWkVST19SRVNUQVJUfSwKKwl7InJhaWQ2X25yIiwgIlJBSUQ2IChOIHJlc3RhcnQpIiwJCTIsIDQsIDYsIEFMR09SSVRITV9ST1RBVElOR19OX1JFU1RBUlR9LAorCXsicmFpZDZfbmMiLCAiUkFJRDYgKE4gY29udGludWUpIiwJCTIsIDQsIDYsIEFMR09SSVRITV9ST1RBVElOR19OX0NPTlRJTlVFfQorfTsKKworc3RhdGljIHN0cnVjdCByYWlkX3R5cGUgKmdldF9yYWlkX3R5cGUoY2hhciAqbmFtZSkKK3sKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHJhaWRfdHlwZXMpOyBpKyspCisJCWlmICghc3RyY21wKHJhaWRfdHlwZXNbaV0ubmFtZSwgbmFtZSkpCisJCQlyZXR1cm4gJnJhaWRfdHlwZXNbaV07CisKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIHN0cnVjdCByYWlkX3NldCAqY29udGV4dF9hbGxvYyhzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwgc3RydWN0IHJhaWRfdHlwZSAqcmFpZF90eXBlLCB1bnNpZ25lZCByYWlkX2RldnMpCit7CisJdW5zaWduZWQgaTsKKwlzdHJ1Y3QgcmFpZF9zZXQgKnJzOworCXNlY3Rvcl90IHNlY3RvcnNfcGVyX2RldjsKKworCWlmIChyYWlkX2RldnMgPD0gcmFpZF90eXBlLT5wYXJpdHlfZGV2cykgeworCQl0aS0+ZXJyb3IgPSAiSW5zdWZmaWNpZW50IG51bWJlciBvZiBkZXZpY2VzIjsKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisJfQorCisJc2VjdG9yc19wZXJfZGV2ID0gdGktPmxlbjsKKwlpZiAoc2VjdG9yX2RpdihzZWN0b3JzX3Blcl9kZXYsIChyYWlkX2RldnMgLSByYWlkX3R5cGUtPnBhcml0eV9kZXZzKSkpIHsKKwkJdGktPmVycm9yID0gIlRhcmdldCBsZW5ndGggbm90IGRpdmlzaWJsZSBieSBudW1iZXIgb2YgZGF0YSBkZXZpY2VzIjsKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisJfQorCisJcnMgPSBremFsbG9jKHNpemVvZigqcnMpICsgcmFpZF9kZXZzICogc2l6ZW9mKHJzLT5kZXZbMF0pLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXJzKSB7CisJCXRpLT5lcnJvciA9ICJDYW5ub3QgYWxsb2NhdGUgcmFpZCBjb250ZXh0IjsKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisJfQorCisJbWRkZXZfaW5pdCgmcnMtPm1kKTsKKworCXJzLT50aSA9IHRpOworCXJzLT5yYWlkX3R5cGUgPSByYWlkX3R5cGU7CisJcnMtPm1kLnJhaWRfZGlza3MgPSByYWlkX2RldnM7CisJcnMtPm1kLmxldmVsID0gcmFpZF90eXBlLT5sZXZlbDsKKwlycy0+bWQubmV3X2xldmVsID0gcnMtPm1kLmxldmVsOworCXJzLT5tZC5kZXZfc2VjdG9ycyA9IHNlY3RvcnNfcGVyX2RldjsKKwlycy0+bWQubGF5b3V0ID0gcmFpZF90eXBlLT5hbGdvcml0aG07CisJcnMtPm1kLm5ld19sYXlvdXQgPSBycy0+bWQubGF5b3V0OworCXJzLT5tZC5kZWx0YV9kaXNrcyA9IDA7CisJcnMtPm1kLnJlY292ZXJ5X2NwID0gMDsKKworCWZvciAoaSA9IDA7IGkgPCByYWlkX2RldnM7IGkrKykKKwkJbWRfcmRldl9pbml0KCZycy0+ZGV2W2ldLnJkZXYpOworCisJLyoKKwkgKiBSZW1haW5pbmcgaXRlbXMgdG8gYmUgaW5pdGlhbGl6ZWQgYnkgZnVydGhlciBSQUlEIHBhcmFtczoKKwkgKiAgcnMtPm1kLnBlcnNpc3RlbnQKKwkgKiAgcnMtPm1kLmV4dGVybmFsCisJICogIHJzLT5tZC5jaHVua19zZWN0b3JzCisJICogIHJzLT5tZC5uZXdfY2h1bmtfc2VjdG9ycworCSAqLworCisJcmV0dXJuIHJzOworfQorCitzdGF0aWMgdm9pZCBjb250ZXh0X2ZyZWUoc3RydWN0IHJhaWRfc2V0ICpycykKK3sKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBycy0+bWQucmFpZF9kaXNrczsgaSsrKQorCQlpZiAocnMtPmRldltpXS5kYXRhX2RldikKKwkJCWRtX3B1dF9kZXZpY2UocnMtPnRpLCBycy0+ZGV2W2ldLmRhdGFfZGV2KTsKKworCWtmcmVlKHJzKTsKK30KKworLyoKKyAqIEZvciBldmVyeSBkZXZpY2Ugd2UgaGF2ZSB0d28gd29yZHMKKyAqICA8bWV0YV9kZXY+OiBtZXRhIGRldmljZSBuYW1lIG9yICctJyBpZiBtaXNzaW5nCisgKiAgPGRhdGFfZGV2PjogZGF0YSBkZXZpY2UgbmFtZSBvciAnLScgaWYgbWlzc2luZworICoKKyAqIFRoaXMgY29kZSBwYXJzZXMgdGhvc2Ugd29yZHMuCisgKi8KK3N0YXRpYyBpbnQgZGV2X3Bhcm1zKHN0cnVjdCByYWlkX3NldCAqcnMsIGNoYXIgKiphcmd2KQoreworCWludCBpOworCWludCByZWJ1aWxkID0gMDsKKwlpbnQgbWV0YWRhdGFfYXZhaWxhYmxlID0gMDsKKwlpbnQgcmV0ID0gMDsKKworCWZvciAoaSA9IDA7IGkgPCBycy0+bWQucmFpZF9kaXNrczsgaSsrLCBhcmd2ICs9IDIpIHsKKwkJcnMtPmRldltpXS5yZGV2LnJhaWRfZGlzayA9IGk7CisKKwkJcnMtPmRldltpXS5tZXRhX2RldiA9IE5VTEw7CisJCXJzLT5kZXZbaV0uZGF0YV9kZXYgPSBOVUxMOworCisJCS8qCisJCSAqIFRoZXJlIGFyZSBubyBvZmZzZXRzLCBzaW5jZSB0aGVyZSBpcyBhIHNlcGFyYXRlIGRldmljZQorCQkgKiBmb3IgZGF0YSBhbmQgbWV0YWRhdGEuCisJCSAqLworCQlycy0+ZGV2W2ldLnJkZXYuZGF0YV9vZmZzZXQgPSAwOworCQlycy0+ZGV2W2ldLnJkZXYubWRkZXYgPSAmcnMtPm1kOworCisJCWlmIChzdHJjbXAoYXJndlswXSwgIi0iKSkgeworCQkJcnMtPnRpLT5lcnJvciA9ICJNZXRhZGF0YSBkZXZpY2VzIG5vdCBzdXBwb3J0ZWQiOworCQkJcmV0dXJuIC1FSU5WQUw7CisJCX0KKworCQlpZiAoIXN0cmNtcChhcmd2WzFdLCAiLSIpKSB7CisJCQlpZiAoIXRlc3RfYml0KEluX3N5bmMsICZycy0+ZGV2W2ldLnJkZXYuZmxhZ3MpICYmCisJCQkgICAgKCFycy0+ZGV2W2ldLnJkZXYucmVjb3Zlcnlfb2Zmc2V0KSkgeworCQkJCXJzLT50aS0+ZXJyb3IgPSAiRHJpdmUgZGVzaWduYXRlZCBmb3IgcmVidWlsZCBub3Qgc3BlY2lmaWVkIjsKKwkJCQlyZXR1cm4gLUVJTlZBTDsKKwkJCX0KKworCQkJY29udGludWU7CisJCX0KKworCQlyZXQgPSBkbV9nZXRfZGV2aWNlKHJzLT50aSwgYXJndlsxXSwKKwkJCQkgICAgZG1fdGFibGVfZ2V0X21vZGUocnMtPnRpLT50YWJsZSksCisJCQkJICAgICZycy0+ZGV2W2ldLmRhdGFfZGV2KTsKKwkJaWYgKHJldCkgeworCQkJcnMtPnRpLT5lcnJvciA9ICJSQUlEIGRldmljZSBsb29rdXAgZmFpbHVyZSI7CisJCQlyZXR1cm4gcmV0OworCQl9CisKKwkJcnMtPmRldltpXS5yZGV2LmJkZXYgPSBycy0+ZGV2W2ldLmRhdGFfZGV2LT5iZGV2OworCQlsaXN0X2FkZCgmcnMtPmRldltpXS5yZGV2LnNhbWVfc2V0LCAmcnMtPm1kLmRpc2tzKTsKKwkJaWYgKCF0ZXN0X2JpdChJbl9zeW5jLCAmcnMtPmRldltpXS5yZGV2LmZsYWdzKSkKKwkJCXJlYnVpbGQrKzsKKwl9CisKKwlpZiAobWV0YWRhdGFfYXZhaWxhYmxlKSB7CisJCXJzLT5tZC5leHRlcm5hbCA9IDA7CisJCXJzLT5tZC5wZXJzaXN0ZW50ID0gMTsKKwkJcnMtPm1kLm1ham9yX3ZlcnNpb24gPSAyOworCX0gZWxzZSBpZiAocmVidWlsZCAmJiAhcnMtPm1kLnJlY292ZXJ5X2NwKSB7CisJCS8qCisJCSAqIFdpdGhvdXQgbWV0YWRhdGEsIHdlIHdpbGwgbm90IGJlIGFibGUgdG8gdGVsbCBpZiB0aGUgYXJyYXkKKwkJICogaXMgaW4tc3luYyBvciBub3QgLSB3ZSBtdXN0IGFzc3VtZSBpdCBpcyBub3QuICBUaGVyZWZvcmUsCisJCSAqIGl0IGlzIGltcG9zc2libGUgdG8gcmVidWlsZCBhIGRyaXZlLgorCQkgKgorCQkgKiBFdmVuIGlmIHRoZXJlIGlzIG1ldGFkYXRhLCB0aGUgb24tZGlzayBpbmZvcm1hdGlvbiBtYXkKKwkJICogaW5kaWNhdGUgdGhhdCB0aGUgYXJyYXkgaXMgbm90IGluLXN5bmMgYW5kIGl0IHdpbGwgdGhlbgorCQkgKiBmYWlsIGF0IHRoYXQgdGltZS4KKwkJICoKKwkJICogVXNlciBjb3VsZCBzcGVjaWZ5ICdub3N5bmMnIG9wdGlvbiBpZiBkZXNwZXJhdGUuCisJCSAqLworCQlETUVSUigiVW5hYmxlIHRvIHJlYnVpbGQgZHJpdmUgd2hpbGUgYXJyYXkgaXMgbm90IGluLXN5bmMiKTsKKwkJcnMtPnRpLT5lcnJvciA9ICJSQUlEIGRldmljZSBsb29rdXAgZmFpbHVyZSI7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXJldHVybiAwOworfQorCisvKgorICogUG9zc2libGUgYXJndW1lbnRzIGFyZS4uLgorICogUkFJRDQ1NjoKKyAqCTxjaHVua19zaXplPiBbb3B0aW9uYWxfYXJnc10KKyAqCisgKiBPcHRpb25hbCBhcmdzOgorICogICAgW1tub11zeW5jXQkJCUZvcmNlIG9yIHByZXZlbnQgcmVjb3Zlcnkgb2YgdGhlIGVudGlyZSBhcnJheQorICogICAgW3JlYnVpbGQgPGlkeD5dCQkJUmVidWlsZCB0aGUgZHJpdmUgaW5kaWNhdGVkIGJ5IHRoZSBpbmRleAorICogICAgW2RhZW1vbl9zbGVlcCA8bXM+XQkJVGltZSBiZXR3ZWVuIGJpdG1hcCBkYWVtb24gd29yayB0byBjbGVhciBiaXRzCisgKiAgICBbbWluX3JlY292ZXJ5X3JhdGUgPGtCL3NlYy9kaXNrPl0JVGhyb3R0bGUgUkFJRCBpbml0aWFsaXphdGlvbgorICogICAgW21heF9yZWNvdmVyeV9yYXRlIDxrQi9zZWMvZGlzaz5dCVRocm90dGxlIFJBSUQgaW5pdGlhbGl6YXRpb24KKyAqICAgIFttYXhfd3JpdGVfYmVoaW5kIDxzZWN0b3JzPl0JU2VlICctd3JpdGUtYmVoaW5kPScgKG1hbiBtZGFkbSkKKyAqICAgIFtzdHJpcGVfY2FjaGUgPHNlY3RvcnM+XQkJU3RyaXBlIGNhY2hlIHNpemUgZm9yIGhpZ2hlciBSQUlEcworICovCitzdGF0aWMgaW50IHBhcnNlX3JhaWRfcGFyYW1zKHN0cnVjdCByYWlkX3NldCAqcnMsIGNoYXIgKiphcmd2LAorCQkJICAgICB1bnNpZ25lZCBudW1fcmFpZF9wYXJhbXMpCit7CisJdW5zaWduZWQgaSwgcmVidWlsZF9jbnQgPSAwOworCXVuc2lnbmVkIGxvbmcgdmFsdWU7CisJY2hhciAqa2V5OworCisJLyoKKwkgKiBGaXJzdCwgcGFyc2UgdGhlIGluLW9yZGVyIHJlcXVpcmVkIGFyZ3VtZW50cworCSAqLworCWlmICgoc3RyaWN0X3N0cnRvdWwoYXJndlswXSwgMTAsICZ2YWx1ZSkgPCAwKSB8fAorCSAgICAhaXNfcG93ZXJfb2ZfMih2YWx1ZSkgfHwgKHZhbHVlIDwgOCkpIHsKKwkJcnMtPnRpLT5lcnJvciA9ICJCYWQgY2h1bmsgc2l6ZSI7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXJzLT5tZC5uZXdfY2h1bmtfc2VjdG9ycyA9IHJzLT5tZC5jaHVua19zZWN0b3JzID0gdmFsdWU7CisJYXJndisrOworCW51bV9yYWlkX3BhcmFtcy0tOworCisJLyoKKwkgKiBTZWNvbmQsIHBhcnNlIHRoZSB1bm9yZGVyZWQgb3B0aW9uYWwgYXJndW1lbnRzCisJICovCisJZm9yIChpID0gMDsgaSA8IHJzLT5tZC5yYWlkX2Rpc2tzOyBpKyspCisJCXNldF9iaXQoSW5fc3luYywgJnJzLT5kZXZbaV0ucmRldi5mbGFncyk7CisKKwlmb3IgKGkgPSAwOyBpIDwgbnVtX3JhaWRfcGFyYW1zOyBpKyspIHsKKwkJaWYgKCFzdHJjbXAoYXJndltpXSwgIm5vc3luYyIpKSB7CisJCQlycy0+bWQucmVjb3ZlcnlfY3AgPSBNYXhTZWN0b3I7CisJCQlycy0+cHJpbnRfZmxhZ3MgfD0gRE1QRl9OT1NZTkM7CisJCQlycy0+bWQuZmxhZ3MgfD0gTURfU1lOQ19TVEFURV9GT1JDRUQ7CisJCQljb250aW51ZTsKKwkJfQorCQlpZiAoIXN0cmNtcChhcmd2W2ldLCAic3luYyIpKSB7CisJCQlycy0+bWQucmVjb3ZlcnlfY3AgPSAwOworCQkJcnMtPnByaW50X2ZsYWdzIHw9IERNUEZfU1lOQzsKKwkJCXJzLT5tZC5mbGFncyB8PSBNRF9TWU5DX1NUQVRFX0ZPUkNFRDsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJLyogVGhlIHJlc3Qgb2YgdGhlIG9wdGlvbmFsIGFyZ3VtZW50cyBjb21lIGluIGtleS92YWx1ZSBwYWlycyAqLworCQlpZiAoKGkgKyAxKSA+PSBudW1fcmFpZF9wYXJhbXMpIHsKKwkJCXJzLT50aS0+ZXJyb3IgPSAiV3JvbmcgbnVtYmVyIG9mIHJhaWQgcGFyYW1ldGVycyBnaXZlbiI7CisJCQlyZXR1cm4gLUVJTlZBTDsKKwkJfQorCisJCWtleSA9IGFyZ3ZbaSsrXTsKKwkJaWYgKHN0cmljdF9zdHJ0b3VsKGFyZ3ZbaV0sIDEwLCAmdmFsdWUpIDwgMCkgeworCQkJcnMtPnRpLT5lcnJvciA9ICJCYWQgbnVtZXJpY2FsIGFyZ3VtZW50IGdpdmVuIGluIHJhaWQgcGFyYW1zIjsKKwkJCXJldHVybiAtRUlOVkFMOworCQl9CisKKwkJaWYgKCFzdHJjbXAoa2V5LCAicmVidWlsZCIpKSB7CisJCQlpZiAoKytyZWJ1aWxkX2NudCA+IHJzLT5yYWlkX3R5cGUtPnBhcml0eV9kZXZzKSB7CisJCQkJcnMtPnRpLT5lcnJvciA9ICJUb28gbWFueSByZWJ1aWxkIGRyaXZlcyBnaXZlbiI7CisJCQkJcmV0dXJuIC1FSU5WQUw7CisJCQl9CisJCQlpZiAodmFsdWUgPiBycy0+bWQucmFpZF9kaXNrcykgeworCQkJCXJzLT50aS0+ZXJyb3IgPSAiSW52YWxpZCByZWJ1aWxkIGluZGV4IGdpdmVuIjsKKwkJCQlyZXR1cm4gLUVJTlZBTDsKKwkJCX0KKwkJCWNsZWFyX2JpdChJbl9zeW5jLCAmcnMtPmRldlt2YWx1ZV0ucmRldi5mbGFncyk7CisJCQlycy0+ZGV2W3ZhbHVlXS5yZGV2LnJlY292ZXJ5X29mZnNldCA9IDA7CisJCX0gZWxzZSBpZiAoIXN0cmNtcChrZXksICJtYXhfd3JpdGVfYmVoaW5kIikpIHsKKwkJCXJzLT5wcmludF9mbGFncyB8PSBETVBGX01BWF9XUklURV9CRUhJTkQ7CisKKwkJCS8qCisJCQkgKiBJbiBkZXZpY2UtbWFwcGVyLCB3ZSBzcGVjaWZ5IHRoaW5ncyBpbiBzZWN0b3JzLCBidXQKKwkJCSAqIE1EIHJlY29yZHMgdGhpcyB2YWx1ZSBpbiBrQgorCQkJICovCisJCQl2YWx1ZSAvPSAyOworCQkJaWYgKHZhbHVlID4gQ09VTlRFUl9NQVgpIHsKKwkJCQlycy0+dGktPmVycm9yID0gIk1heCB3cml0ZS1iZWhpbmQgbGltaXQgb3V0IG9mIHJhbmdlIjsKKwkJCQlyZXR1cm4gLUVJTlZBTDsKKwkJCX0KKwkJCXJzLT5tZC5iaXRtYXBfaW5mby5tYXhfd3JpdGVfYmVoaW5kID0gdmFsdWU7CisJCX0gZWxzZSBpZiAoIXN0cmNtcChrZXksICJkYWVtb25fc2xlZXAiKSkgeworCQkJcnMtPnByaW50X2ZsYWdzIHw9IERNUEZfREFFTU9OX1NMRUVQOworCQkJaWYgKCF2YWx1ZSB8fCAodmFsdWUgPiBNQVhfU0NIRURVTEVfVElNRU9VVCkpIHsKKwkJCQlycy0+dGktPmVycm9yID0gImRhZW1vbiBzbGVlcCBwZXJpb2Qgb3V0IG9mIHJhbmdlIjsKKwkJCQlyZXR1cm4gLUVJTlZBTDsKKwkJCX0KKwkJCXJzLT5tZC5iaXRtYXBfaW5mby5kYWVtb25fc2xlZXAgPSB2YWx1ZTsKKwkJfSBlbHNlIGlmICghc3RyY21wKGtleSwgInN0cmlwZV9jYWNoZSIpKSB7CisJCQlycy0+cHJpbnRfZmxhZ3MgfD0gRE1QRl9TVFJJUEVfQ0FDSEU7CisKKwkJCS8qCisJCQkgKiBJbiBkZXZpY2UtbWFwcGVyLCB3ZSBzcGVjaWZ5IHRoaW5ncyBpbiBzZWN0b3JzLCBidXQKKwkJCSAqIE1EIHJlY29yZHMgdGhpcyB2YWx1ZSBpbiBrQgorCQkJICovCisJCQl2YWx1ZSAvPSAyOworCisJCQlpZiAocnMtPnJhaWRfdHlwZS0+bGV2ZWwgPCA1KSB7CisJCQkJcnMtPnRpLT5lcnJvciA9ICJJbmFwcHJvcHJpYXRlIGFyZ3VtZW50OiBzdHJpcGVfY2FjaGUiOworCQkJCXJldHVybiAtRUlOVkFMOworCQkJfQorCQkJaWYgKHJhaWQ1X3NldF9jYWNoZV9zaXplKCZycy0+bWQsIChpbnQpdmFsdWUpKSB7CisJCQkJcnMtPnRpLT5lcnJvciA9ICJCYWQgc3RyaXBlX2NhY2hlIHNpemUiOworCQkJCXJldHVybiAtRUlOVkFMOworCQkJfQorCQl9IGVsc2UgaWYgKCFzdHJjbXAoa2V5LCAibWluX3JlY292ZXJ5X3JhdGUiKSkgeworCQkJcnMtPnByaW50X2ZsYWdzIHw9IERNUEZfTUlOX1JFQ09WRVJZX1JBVEU7CisJCQlpZiAodmFsdWUgPiBJTlRfTUFYKSB7CisJCQkJcnMtPnRpLT5lcnJvciA9ICJtaW5fcmVjb3ZlcnlfcmF0ZSBvdXQgb2YgcmFuZ2UiOworCQkJCXJldHVybiAtRUlOVkFMOworCQkJfQorCQkJcnMtPm1kLnN5bmNfc3BlZWRfbWluID0gKGludCl2YWx1ZTsKKwkJfSBlbHNlIGlmICghc3RyY21wKGtleSwgIm1heF9yZWNvdmVyeV9yYXRlIikpIHsKKwkJCXJzLT5wcmludF9mbGFncyB8PSBETVBGX01BWF9SRUNPVkVSWV9SQVRFOworCQkJaWYgKHZhbHVlID4gSU5UX01BWCkgeworCQkJCXJzLT50aS0+ZXJyb3IgPSAibWF4X3JlY292ZXJ5X3JhdGUgb3V0IG9mIHJhbmdlIjsKKwkJCQlyZXR1cm4gLUVJTlZBTDsKKwkJCX0KKwkJCXJzLT5tZC5zeW5jX3NwZWVkX21heCA9IChpbnQpdmFsdWU7CisJCX0gZWxzZSB7CisJCQlETUVSUigiVW5hYmxlIHRvIHBhcnNlIFJBSUQgcGFyYW1ldGVyOiAlcyIsIGtleSk7CisJCQlycy0+dGktPmVycm9yID0gIlVuYWJsZSB0byBwYXJzZSBSQUlEIHBhcmFtZXRlcnMiOworCQkJcmV0dXJuIC1FSU5WQUw7CisJCX0KKwl9CisKKwkvKiBBc3N1bWUgdGhlcmUgYXJlIG5vIG1ldGFkYXRhIGRldmljZXMgdW50aWwgdGhlIGRyaXZlcyBhcmUgcGFyc2VkICovCisJcnMtPm1kLnBlcnNpc3RlbnQgPSAwOworCXJzLT5tZC5leHRlcm5hbCA9IDE7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgZG9fdGFibGVfZXZlbnQoc3RydWN0IHdvcmtfc3RydWN0ICp3cykKK3sKKwlzdHJ1Y3QgcmFpZF9zZXQgKnJzID0gY29udGFpbmVyX29mKHdzLCBzdHJ1Y3QgcmFpZF9zZXQsIG1kLmV2ZW50X3dvcmspOworCisJZG1fdGFibGVfZXZlbnQocnMtPnRpLT50YWJsZSk7Cit9CisKK3N0YXRpYyBpbnQgcmFpZF9pc19jb25nZXN0ZWQoc3RydWN0IGRtX3RhcmdldF9jYWxsYmFja3MgKmNiLCBpbnQgYml0cykKK3sKKwlzdHJ1Y3QgcmFpZF9zZXQgKnJzID0gY29udGFpbmVyX29mKGNiLCBzdHJ1Y3QgcmFpZF9zZXQsIGNhbGxiYWNrcyk7CisKKwlyZXR1cm4gbWRfcmFpZDVfY29uZ2VzdGVkKCZycy0+bWQsIGJpdHMpOworfQorCitzdGF0aWMgdm9pZCByYWlkX3VucGx1ZyhzdHJ1Y3QgZG1fdGFyZ2V0X2NhbGxiYWNrcyAqY2IpCit7CisJc3RydWN0IHJhaWRfc2V0ICpycyA9IGNvbnRhaW5lcl9vZihjYiwgc3RydWN0IHJhaWRfc2V0LCBjYWxsYmFja3MpOworCisJbWRfcmFpZDVfdW5wbHVnX2RldmljZShycy0+bWQucHJpdmF0ZSk7Cit9CisKKy8qCisgKiBDb25zdHJ1Y3QgYSBSQUlENC81LzYgbWFwcGluZzoKKyAqIEFyZ3M6CisgKgk8cmFpZF90eXBlPiA8I3JhaWRfcGFyYW1zPiA8cmFpZF9wYXJhbXM+CQlcCisgKgk8I3JhaWRfZGV2cz4geyA8bWV0YV9kZXYxPiA8ZGV2MT4gLi4gPG1ldGFfZGV2Tj4gPGRldk4+IH0KKyAqCisgKiAqKiBtZXRhZGF0YSBkZXZpY2VzIGFyZSBub3Qgc3VwcG9ydGVkIHlldCwgdXNlICctJyBpbnN0ZWFkICoqCisgKgorICogPHJhaWRfcGFyYW1zPiB2YXJpZXMgYnkgPHJhaWRfdHlwZT4uICBTZWUgJ3BhcnNlX3JhaWRfcGFyYW1zJyBmb3IKKyAqIGRldGFpbHMgb24gcG9zc2libGUgPHJhaWRfcGFyYW1zPi4KKyAqLworc3RhdGljIGludCByYWlkX2N0cihzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwgdW5zaWduZWQgYXJnYywgY2hhciAqKmFyZ3YpCit7CisJaW50IHJldDsKKwlzdHJ1Y3QgcmFpZF90eXBlICpydDsKKwl1bnNpZ25lZCBsb25nIG51bV9yYWlkX3BhcmFtcywgbnVtX3JhaWRfZGV2czsKKwlzdHJ1Y3QgcmFpZF9zZXQgKnJzID0gTlVMTDsKKworCS8qIE11c3QgaGF2ZSBhdCBsZWFzdCA8cmFpZF90eXBlPiA8I3JhaWRfcGFyYW1zPiAqLworCWlmIChhcmdjIDwgMikgeworCQl0aS0+ZXJyb3IgPSAiVG9vIGZldyBhcmd1bWVudHMiOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKiByYWlkIHR5cGUgKi8KKwlydCA9IGdldF9yYWlkX3R5cGUoYXJndlswXSk7CisJaWYgKCFydCkgeworCQl0aS0+ZXJyb3IgPSAiVW5yZWNvZ25pc2VkIHJhaWRfdHlwZSI7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlhcmdjLS07CisJYXJndisrOworCisJLyogbnVtYmVyIG9mIFJBSUQgcGFyYW1ldGVycyAqLworCWlmIChzdHJpY3Rfc3RydG91bChhcmd2WzBdLCAxMCwgJm51bV9yYWlkX3BhcmFtcykgPCAwKSB7CisJCXRpLT5lcnJvciA9ICJDYW5ub3QgdW5kZXJzdGFuZCBudW1iZXIgb2YgUkFJRCBwYXJhbWV0ZXJzIjsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWFyZ2MtLTsKKwlhcmd2Kys7CisKKwkvKiBTa2lwIG92ZXIgUkFJRCBwYXJhbXMgZm9yIG5vdyBhbmQgZmluZCBvdXQgIyBvZiBkZXZpY2VzICovCisJaWYgKG51bV9yYWlkX3BhcmFtcyArIDEgPiBhcmdjKSB7CisJCXRpLT5lcnJvciA9ICJBcmd1bWVudHMgZG8gbm90IGFncmVlIHdpdGggY291bnRzIGdpdmVuIjsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJaWYgKChzdHJpY3Rfc3RydG91bChhcmd2W251bV9yYWlkX3BhcmFtc10sIDEwLCAmbnVtX3JhaWRfZGV2cykgPCAwKSB8fAorCSAgICAobnVtX3JhaWRfZGV2cyA+PSBJTlRfTUFYKSkgeworCQl0aS0+ZXJyb3IgPSAiQ2Fubm90IHVuZGVyc3RhbmQgbnVtYmVyIG9mIHJhaWQgZGV2aWNlcyI7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXJzID0gY29udGV4dF9hbGxvYyh0aSwgcnQsICh1bnNpZ25lZCludW1fcmFpZF9kZXZzKTsKKwlpZiAoSVNfRVJSKHJzKSkKKwkJcmV0dXJuIFBUUl9FUlIocnMpOworCisJcmV0ID0gcGFyc2VfcmFpZF9wYXJhbXMocnMsIGFyZ3YsICh1bnNpZ25lZCludW1fcmFpZF9wYXJhbXMpOworCWlmIChyZXQpCisJCWdvdG8gYmFkOworCisJcmV0ID0gLUVJTlZBTDsKKworCWFyZ2MgLT0gbnVtX3JhaWRfcGFyYW1zICsgMTsgLyogKzE6IHdlIGFscmVhZHkgaGF2ZSBudW1fcmFpZF9kZXZzICovCisJYXJndiArPSBudW1fcmFpZF9wYXJhbXMgKyAxOworCisJaWYgKGFyZ2MgIT0gKG51bV9yYWlkX2RldnMgKiAyKSkgeworCQl0aS0+ZXJyb3IgPSAiU3VwcGxpZWQgUkFJRCBkZXZpY2VzIGRvZXMgbm90IG1hdGNoIHRoZSBjb3VudCBnaXZlbiI7CisJCWdvdG8gYmFkOworCX0KKworCXJldCA9IGRldl9wYXJtcyhycywgYXJndik7CisJaWYgKHJldCkKKwkJZ290byBiYWQ7CisKKwlJTklUX1dPUksoJnJzLT5tZC5ldmVudF93b3JrLCBkb190YWJsZV9ldmVudCk7CisJdGktPnNwbGl0X2lvID0gcnMtPm1kLmNodW5rX3NlY3RvcnM7CisJdGktPnByaXZhdGUgPSByczsKKworCW11dGV4X2xvY2soJnJzLT5tZC5yZWNvbmZpZ19tdXRleCk7CisJcmV0ID0gbWRfcnVuKCZycy0+bWQpOworCXJzLT5tZC5pbl9zeW5jID0gMDsgLyogQXNzdW1lIGFscmVhZHkgbWFya2VkIGRpcnR5ICovCisJbXV0ZXhfdW5sb2NrKCZycy0+bWQucmVjb25maWdfbXV0ZXgpOworCisJaWYgKHJldCkgeworCQl0aS0+ZXJyb3IgPSAiRmFpbCB0byBydW4gcmFpZCBhcnJheSI7CisJCWdvdG8gYmFkOworCX0KKworCXJzLT5jYWxsYmFja3MuY29uZ2VzdGVkX2ZuID0gcmFpZF9pc19jb25nZXN0ZWQ7CisJcnMtPmNhbGxiYWNrcy51bnBsdWdfZm4gPSByYWlkX3VucGx1ZzsKKwlkbV90YWJsZV9hZGRfdGFyZ2V0X2NhbGxiYWNrcyh0aS0+dGFibGUsICZycy0+Y2FsbGJhY2tzKTsKKworCXJldHVybiAwOworCitiYWQ6CisJY29udGV4dF9mcmVlKHJzKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIHJhaWRfZHRyKHN0cnVjdCBkbV90YXJnZXQgKnRpKQoreworCXN0cnVjdCByYWlkX3NldCAqcnMgPSB0aS0+cHJpdmF0ZTsKKworCWxpc3RfZGVsX2luaXQoJnJzLT5jYWxsYmFja3MubGlzdCk7CisJbWRfc3RvcCgmcnMtPm1kKTsKKwljb250ZXh0X2ZyZWUocnMpOworfQorCitzdGF0aWMgaW50IHJhaWRfbWFwKHN0cnVjdCBkbV90YXJnZXQgKnRpLCBzdHJ1Y3QgYmlvICpiaW8sIHVuaW9uIG1hcF9pbmZvICptYXBfY29udGV4dCkKK3sKKwlzdHJ1Y3QgcmFpZF9zZXQgKnJzID0gdGktPnByaXZhdGU7CisJbWRkZXZfdCAqbWRkZXYgPSAmcnMtPm1kOworCisJbWRkZXYtPnBlcnMtPm1ha2VfcmVxdWVzdChtZGRldiwgYmlvKTsKKworCXJldHVybiBETV9NQVBJT19TVUJNSVRURUQ7Cit9CisKK3N0YXRpYyBpbnQgcmFpZF9zdGF0dXMoc3RydWN0IGRtX3RhcmdldCAqdGksIHN0YXR1c190eXBlX3QgdHlwZSwKKwkJICAgICAgIGNoYXIgKnJlc3VsdCwgdW5zaWduZWQgbWF4bGVuKQoreworCXN0cnVjdCByYWlkX3NldCAqcnMgPSB0aS0+cHJpdmF0ZTsKKwl1bnNpZ25lZCByYWlkX3BhcmFtX2NudCA9IDE7IC8qIGF0IGxlYXN0IDEgZm9yIGNodW5rc2l6ZSAqLworCXVuc2lnbmVkIHN6ID0gMDsKKwlpbnQgaTsKKwlzZWN0b3JfdCBzeW5jOworCisJc3dpdGNoICh0eXBlKSB7CisJY2FzZSBTVEFUVVNUWVBFX0lORk86CisJCURNRU1JVCgiJXMgJWQgIiwgcnMtPnJhaWRfdHlwZS0+bmFtZSwgcnMtPm1kLnJhaWRfZGlza3MpOworCisJCWZvciAoaSA9IDA7IGkgPCBycy0+bWQucmFpZF9kaXNrczsgaSsrKSB7CisJCQlpZiAodGVzdF9iaXQoRmF1bHR5LCAmcnMtPmRldltpXS5yZGV2LmZsYWdzKSkKKwkJCQlETUVNSVQoIkQiKTsKKwkJCWVsc2UgaWYgKHRlc3RfYml0KEluX3N5bmMsICZycy0+ZGV2W2ldLnJkZXYuZmxhZ3MpKQorCQkJCURNRU1JVCgiQSIpOworCQkJZWxzZQorCQkJCURNRU1JVCgiYSIpOworCQl9CisKKwkJaWYgKHRlc3RfYml0KE1EX1JFQ09WRVJZX1JVTk5JTkcsICZycy0+bWQucmVjb3ZlcnkpKQorCQkJc3luYyA9IHJzLT5tZC5jdXJyX3Jlc3luY19jb21wbGV0ZWQ7CisJCWVsc2UKKwkJCXN5bmMgPSBycy0+bWQucmVjb3ZlcnlfY3A7CisKKwkJaWYgKHN5bmMgPiBycy0+bWQucmVzeW5jX21heF9zZWN0b3JzKQorCQkJc3luYyA9IHJzLT5tZC5yZXN5bmNfbWF4X3NlY3RvcnM7CisKKwkJRE1FTUlUKCIgJWxsdS8lbGx1IiwKKwkJICAgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpIHN5bmMsCisJCSAgICAgICAodW5zaWduZWQgbG9uZyBsb25nKSBycy0+bWQucmVzeW5jX21heF9zZWN0b3JzKTsKKworCQlicmVhazsKKwljYXNlIFNUQVRVU1RZUEVfVEFCTEU6CisJCS8qIFRoZSBzdHJpbmcgeW91IHdvdWxkIHVzZSB0byBjb25zdHJ1Y3QgdGhpcyBhcnJheSAqLworCQlmb3IgKGkgPSAwOyBpIDwgcnMtPm1kLnJhaWRfZGlza3M7IGkrKykKKwkJCWlmIChycy0+ZGV2W2ldLmRhdGFfZGV2ICYmCisJCQkgICAgIXRlc3RfYml0KEluX3N5bmMsICZycy0+ZGV2W2ldLnJkZXYuZmxhZ3MpKQorCQkJCXJhaWRfcGFyYW1fY250Kys7IC8qIGZvciByZWJ1aWxkcyAqLworCisJCXJhaWRfcGFyYW1fY250ICs9IChod2VpZ2h0NjQocnMtPnByaW50X2ZsYWdzKSAqIDIpOworCQlpZiAocnMtPnByaW50X2ZsYWdzICYgKERNUEZfU1lOQyB8IERNUEZfTk9TWU5DKSkKKwkJCXJhaWRfcGFyYW1fY250LS07CisKKwkJRE1FTUlUKCIlcyAldSAldSIsIHJzLT5yYWlkX3R5cGUtPm5hbWUsCisJCSAgICAgICByYWlkX3BhcmFtX2NudCwgcnMtPm1kLmNodW5rX3NlY3RvcnMpOworCisJCWlmICgocnMtPnByaW50X2ZsYWdzICYgRE1QRl9TWU5DKSAmJgorCQkgICAgKHJzLT5tZC5yZWNvdmVyeV9jcCA9PSBNYXhTZWN0b3IpKQorCQkJRE1FTUlUKCIgc3luYyIpOworCQlpZiAocnMtPnByaW50X2ZsYWdzICYgRE1QRl9OT1NZTkMpCisJCQlETUVNSVQoIiBub3N5bmMiKTsKKworCQlmb3IgKGkgPSAwOyBpIDwgcnMtPm1kLnJhaWRfZGlza3M7IGkrKykKKwkJCWlmIChycy0+ZGV2W2ldLmRhdGFfZGV2ICYmCisJCQkgICAgIXRlc3RfYml0KEluX3N5bmMsICZycy0+ZGV2W2ldLnJkZXYuZmxhZ3MpKQorCQkJCURNRU1JVCgiIHJlYnVpbGQgJXUiLCBpKTsKKworCQlpZiAocnMtPnByaW50X2ZsYWdzICYgRE1QRl9EQUVNT05fU0xFRVApCisJCQlETUVNSVQoIiBkYWVtb25fc2xlZXAgJWx1IiwKKwkJCSAgICAgICBycy0+bWQuYml0bWFwX2luZm8uZGFlbW9uX3NsZWVwKTsKKworCQlpZiAocnMtPnByaW50X2ZsYWdzICYgRE1QRl9NSU5fUkVDT1ZFUllfUkFURSkKKwkJCURNRU1JVCgiIG1pbl9yZWNvdmVyeV9yYXRlICVkIiwgcnMtPm1kLnN5bmNfc3BlZWRfbWluKTsKKworCQlpZiAocnMtPnByaW50X2ZsYWdzICYgRE1QRl9NQVhfUkVDT1ZFUllfUkFURSkKKwkJCURNRU1JVCgiIG1heF9yZWNvdmVyeV9yYXRlICVkIiwgcnMtPm1kLnN5bmNfc3BlZWRfbWF4KTsKKworCQlpZiAocnMtPnByaW50X2ZsYWdzICYgRE1QRl9NQVhfV1JJVEVfQkVISU5EKQorCQkJRE1FTUlUKCIgbWF4X3dyaXRlX2JlaGluZCAlbHUiLAorCQkJICAgICAgIHJzLT5tZC5iaXRtYXBfaW5mby5tYXhfd3JpdGVfYmVoaW5kKTsKKworCQlpZiAocnMtPnByaW50X2ZsYWdzICYgRE1QRl9TVFJJUEVfQ0FDSEUpIHsKKwkJCXJhaWQ1X2NvbmZfdCAqY29uZiA9IHJzLT5tZC5wcml2YXRlOworCisJCQkvKiBjb252ZXJ0IGZyb20ga2lCIHRvIHNlY3RvcnMgKi8KKwkJCURNRU1JVCgiIHN0cmlwZV9jYWNoZSAlZCIsCisJCQkgICAgICAgY29uZiA/IGNvbmYtPm1heF9ucl9zdHJpcGVzICogMiA6IDApOworCQl9CisKKwkJRE1FTUlUKCIgJWQiLCBycy0+bWQucmFpZF9kaXNrcyk7CisJCWZvciAoaSA9IDA7IGkgPCBycy0+bWQucmFpZF9kaXNrczsgaSsrKSB7CisJCQlETUVNSVQoIiAtIik7IC8qIG1ldGFkYXRhIGRldmljZSAqLworCisJCQlpZiAocnMtPmRldltpXS5kYXRhX2RldikKKwkJCQlETUVNSVQoIiAlcyIsIHJzLT5kZXZbaV0uZGF0YV9kZXYtPm5hbWUpOworCQkJZWxzZQorCQkJCURNRU1JVCgiIC0iKTsKKwkJfQorCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHJhaWRfaXRlcmF0ZV9kZXZpY2VzKHN0cnVjdCBkbV90YXJnZXQgKnRpLCBpdGVyYXRlX2RldmljZXNfY2FsbG91dF9mbiBmbiwgdm9pZCAqZGF0YSkKK3sKKwlzdHJ1Y3QgcmFpZF9zZXQgKnJzID0gdGktPnByaXZhdGU7CisJdW5zaWduZWQgaTsKKwlpbnQgcmV0ID0gMDsKKworCWZvciAoaSA9IDA7ICFyZXQgJiYgaSA8IHJzLT5tZC5yYWlkX2Rpc2tzOyBpKyspCisJCWlmIChycy0+ZGV2W2ldLmRhdGFfZGV2KQorCQkJcmV0ID0gZm4odGksCisJCQkJIHJzLT5kZXZbaV0uZGF0YV9kZXYsCisJCQkJIDAsIC8qIE5vIG9mZnNldCBvbiBkYXRhIGRldnMgKi8KKwkJCQkgcnMtPm1kLmRldl9zZWN0b3JzLAorCQkJCSBkYXRhKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIHJhaWRfaW9faGludHMoc3RydWN0IGRtX3RhcmdldCAqdGksIHN0cnVjdCBxdWV1ZV9saW1pdHMgKmxpbWl0cykKK3sKKwlzdHJ1Y3QgcmFpZF9zZXQgKnJzID0gdGktPnByaXZhdGU7CisJdW5zaWduZWQgY2h1bmtfc2l6ZSA9IHJzLT5tZC5jaHVua19zZWN0b3JzIDw8IDk7CisJcmFpZDVfY29uZl90ICpjb25mID0gcnMtPm1kLnByaXZhdGU7CisKKwlibGtfbGltaXRzX2lvX21pbihsaW1pdHMsIGNodW5rX3NpemUpOworCWJsa19saW1pdHNfaW9fb3B0KGxpbWl0cywgY2h1bmtfc2l6ZSAqIChjb25mLT5yYWlkX2Rpc2tzIC0gY29uZi0+bWF4X2RlZ3JhZGVkKSk7Cit9CisKK3N0YXRpYyB2b2lkIHJhaWRfcHJlc3VzcGVuZChzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSkKK3sKKwlzdHJ1Y3QgcmFpZF9zZXQgKnJzID0gdGktPnByaXZhdGU7CisKKwltZF9zdG9wX3dyaXRlcygmcnMtPm1kKTsKK30KKworc3RhdGljIHZvaWQgcmFpZF9wb3N0c3VzcGVuZChzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSkKK3sKKwlzdHJ1Y3QgcmFpZF9zZXQgKnJzID0gdGktPnByaXZhdGU7CisKKwltZGRldl9zdXNwZW5kKCZycy0+bWQpOworfQorCitzdGF0aWMgdm9pZCByYWlkX3Jlc3VtZShzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSkKK3sKKwlzdHJ1Y3QgcmFpZF9zZXQgKnJzID0gdGktPnByaXZhdGU7CisKKwltZGRldl9yZXN1bWUoJnJzLT5tZCk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X3R5cGUgcmFpZF90YXJnZXQgPSB7CisJLm5hbWUgPSAicmFpZCIsCisJLnZlcnNpb24gPSB7MSwgMCwgMH0sCisJLm1vZHVsZSA9IFRISVNfTU9EVUxFLAorCS5jdHIgPSByYWlkX2N0ciwKKwkuZHRyID0gcmFpZF9kdHIsCisJLm1hcCA9IHJhaWRfbWFwLAorCS5zdGF0dXMgPSByYWlkX3N0YXR1cywKKwkuaXRlcmF0ZV9kZXZpY2VzID0gcmFpZF9pdGVyYXRlX2RldmljZXMsCisJLmlvX2hpbnRzID0gcmFpZF9pb19oaW50cywKKwkucHJlc3VzcGVuZCA9IHJhaWRfcHJlc3VzcGVuZCwKKwkucG9zdHN1c3BlbmQgPSByYWlkX3Bvc3RzdXNwZW5kLAorCS5yZXN1bWUgPSByYWlkX3Jlc3VtZSwKK307CisKK3N0YXRpYyBpbnQgX19pbml0IGRtX3JhaWRfaW5pdCh2b2lkKQoreworCXJldHVybiBkbV9yZWdpc3Rlcl90YXJnZXQoJnJhaWRfdGFyZ2V0KTsKK30KKworc3RhdGljIHZvaWQgX19leGl0IGRtX3JhaWRfZXhpdCh2b2lkKQoreworCWRtX3VucmVnaXN0ZXJfdGFyZ2V0KCZyYWlkX3RhcmdldCk7Cit9CisKK21vZHVsZV9pbml0KGRtX3JhaWRfaW5pdCk7Cittb2R1bGVfZXhpdChkbV9yYWlkX2V4aXQpOworCitNT0RVTEVfREVTQ1JJUFRJT04oRE1fTkFNRSAiIHJhaWQ0LzUvNiB0YXJnZXQiKTsKK01PRFVMRV9BTElBUygiZG0tcmFpZDQiKTsKK01PRFVMRV9BTElBUygiZG0tcmFpZDUiKTsKK01PRFVMRV9BTElBUygiZG0tcmFpZDYiKTsKK01PRFVMRV9BVVRIT1IoIk5laWwgQnJvd24gPGRtLWRldmVsQHJlZGhhdC5jb20+Iik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLXJhaWQxLmMgYi9kcml2ZXJzL21kL2RtLXJhaWQxLmMKaW5kZXggMTlhNTliMC4uZGVlMzI2NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1yYWlkMS5jCisrKyBiL2RyaXZlcnMvbWQvZG0tcmFpZDEuYwpAQCAtMjYxLDcgKzI2MSw3IEBACiAJc3RydWN0IGRtX2lvX3JlcXVlc3QgaW9fcmVxID0gewogCQkuYmlfcncgPSBXUklURV9GTFVTSCwKIAkJLm1lbS50eXBlID0gRE1fSU9fS01FTSwKLQkJLm1lbS5wdHIuYnZlYyA9IE5VTEwsCisJCS5tZW0ucHRyLmFkZHIgPSBOVUxMLAogCQkuY2xpZW50ID0gbXMtPmlvX2NsaWVudCwKIAl9OwogCkBAIC02MzcsNiArNjM3LDEyIEBACiAJCS5jbGllbnQgPSBtcy0+aW9fY2xpZW50LAogCX07CiAKKwlpZiAoYmlvLT5iaV9ydyAmIFJFUV9ESVNDQVJEKSB7CisJCWlvX3JlcS5iaV9ydyB8PSBSRVFfRElTQ0FSRDsKKwkJaW9fcmVxLm1lbS50eXBlID0gRE1fSU9fS01FTTsKKwkJaW9fcmVxLm1lbS5wdHIuYWRkciA9IE5VTEw7CisJfQorCiAJZm9yIChpID0gMCwgbSA9IG1zLT5taXJyb3I7IGkgPCBtcy0+bnJfbWlycm9yczsgaSsrLCBtKyspCiAJCW1hcF9yZWdpb24oZGVzdCsrLCBtLCBiaW8pOwogCkBAIC02NzAsNyArNjc2LDggQEAKIAliaW9fbGlzdF9pbml0KCZyZXF1ZXVlKTsKIAogCXdoaWxlICgoYmlvID0gYmlvX2xpc3RfcG9wKHdyaXRlcykpKSB7Ci0JCWlmIChiaW8tPmJpX3J3ICYgUkVRX0ZMVVNIKSB7CisJCWlmICgoYmlvLT5iaV9ydyAmIFJFUV9GTFVTSCkgfHwKKwkJICAgIChiaW8tPmJpX3J3ICYgUkVRX0RJU0NBUkQpKSB7CiAJCQliaW9fbGlzdF9hZGQoJnN5bmMsIGJpbyk7CiAJCQljb250aW51ZTsKIAkJfQpAQCAtMTA3Niw4ICsxMDgzLDEwIEBACiAJdGktPnByaXZhdGUgPSBtczsKIAl0aS0+c3BsaXRfaW8gPSBkbV9yaF9nZXRfcmVnaW9uX3NpemUobXMtPnJoKTsKIAl0aS0+bnVtX2ZsdXNoX3JlcXVlc3RzID0gMTsKKwl0aS0+bnVtX2Rpc2NhcmRfcmVxdWVzdHMgPSAxOwogCi0JbXMtPmttaXJyb3JkX3dxID0gY3JlYXRlX3NpbmdsZXRocmVhZF93b3JrcXVldWUoImttaXJyb3JkIik7CisJbXMtPmttaXJyb3JkX3dxID0gYWxsb2Nfd29ya3F1ZXVlKCJrbWlycm9yZCIsCisJCQkJCSAgV1FfTk9OX1JFRU5UUkFOVCB8IFdRX01FTV9SRUNMQUlNLCAwKTsKIAlpZiAoIW1zLT5rbWlycm9yZF93cSkgewogCQlETUVSUigiY291bGRuJ3Qgc3RhcnQga21pcnJvcmQiKTsKIAkJciA9IC1FTk9NRU07CkBAIC0xMTMwLDcgKzExMzksNyBAQAogCiAJZGVsX3RpbWVyX3N5bmMoJm1zLT50aW1lcik7CiAJZmx1c2hfd29ya3F1ZXVlKG1zLT5rbWlycm9yZF93cSk7Ci0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKKwlmbHVzaF93b3JrX3N5bmMoJm1zLT50cmlnZ2VyX2V2ZW50KTsKIAlkbV9rY29weWRfY2xpZW50X2Rlc3Ryb3kobXMtPmtjb3B5ZF9jbGllbnQpOwogCWRlc3Ryb3lfd29ya3F1ZXVlKG1zLT5rbWlycm9yZF93cSk7CiAJZnJlZV9jb250ZXh0KG1zLCB0aSwgbXMtPm5yX21pcnJvcnMpOwpAQCAtMTQwNiw3ICsxNDE1LDcgQEAKIAogc3RhdGljIHN0cnVjdCB0YXJnZXRfdHlwZSBtaXJyb3JfdGFyZ2V0ID0gewogCS5uYW1lCSA9ICJtaXJyb3IiLAotCS52ZXJzaW9uID0gezEsIDEyLCAwfSwKKwkudmVyc2lvbiA9IHsxLCAxMiwgMX0sCiAJLm1vZHVsZQkgPSBUSElTX01PRFVMRSwKIAkuY3RyCSA9IG1pcnJvcl9jdHIsCiAJLmR0cgkgPSBtaXJyb3JfZHRyLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1zbmFwLXBlcnNpc3RlbnQuYyBiL2RyaXZlcnMvbWQvZG0tc25hcC1wZXJzaXN0ZW50LmMKaW5kZXggMjEyOWNkYi4uOTU4OTFkZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1zbmFwLXBlcnNpc3RlbnQuYworKysgYi9kcml2ZXJzL21kL2RtLXNuYXAtcGVyc2lzdGVudC5jCkBAIC0yNTYsNyArMjU2LDcgQEAKIAkgKi8KIAlJTklUX1dPUktfT05TVEFDSygmcmVxLndvcmssIGRvX21ldGFkYXRhKTsKIAlxdWV1ZV93b3JrKHBzLT5tZXRhZGF0YV93cSwgJnJlcS53b3JrKTsKLQlmbHVzaF93b3JrcXVldWUocHMtPm1ldGFkYXRhX3dxKTsKKwlmbHVzaF93b3JrKCZyZXEud29yayk7CiAKIAlyZXR1cm4gcmVxLnJlc3VsdDsKIH0KQEAgLTgxOCw3ICs4MTgsNyBAQAogCWF0b21pY19zZXQoJnBzLT5wZW5kaW5nX2NvdW50LCAwKTsKIAlwcy0+Y2FsbGJhY2tzID0gTlVMTDsKIAotCXBzLT5tZXRhZGF0YV93cSA9IGNyZWF0ZV9zaW5nbGV0aHJlYWRfd29ya3F1ZXVlKCJrc25hcGhkIik7CisJcHMtPm1ldGFkYXRhX3dxID0gYWxsb2Nfd29ya3F1ZXVlKCJrc25hcGhkIiwgV1FfTUVNX1JFQ0xBSU0sIDApOwogCWlmICghcHMtPm1ldGFkYXRhX3dxKSB7CiAJCWtmcmVlKHBzKTsKIAkJRE1FUlIoImNvdWxkbid0IHN0YXJ0IGhlYWRlciBtZXRhZGF0YSB1cGRhdGUgdGhyZWFkIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLXNuYXAuYyBiL2RyaXZlcnMvbWQvZG0tc25hcC5jCmluZGV4IDUzY2Y3OWQuLmZkZGU1M2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tc25hcC5jCisrKyBiL2RyaXZlcnMvbWQvZG0tc25hcC5jCkBAIC0xOSw3ICsxOSw2IEBACiAjaW5jbHVkZSA8bGludXgvdm1hbGxvYy5oPgogI2luY2x1ZGUgPGxpbnV4L2xvZzIuaD4KICNpbmNsdWRlIDxsaW51eC9kbS1rY29weWQuaD4KLSNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KIAogI2luY2x1ZGUgImRtLWV4Y2VwdGlvbi1zdG9yZS5oIgogCkBAIC04MCw5ICs3OSw2IEBACiAJLyogT3JpZ2luIHdyaXRlcyBkb24ndCB0cmlnZ2VyIGV4Y2VwdGlvbnMgdW50aWwgdGhpcyBpcyBzZXQgKi8KIAlpbnQgYWN0aXZlOwogCi0JLyogV2hldGhlciBvciBub3Qgb3duaW5nIG1hcHBlZF9kZXZpY2UgaXMgc3VzcGVuZGVkICovCi0JaW50IHN1c3BlbmRlZDsKLQogCWF0b21pY190IHBlbmRpbmdfZXhjZXB0aW9uc19jb3VudDsKIAogCW1lbXBvb2xfdCAqcGVuZGluZ19wb29sOwpAQCAtMTA2LDEwICsxMDIsNiBAQAogCiAJc3RydWN0IGRtX2tjb3B5ZF9jbGllbnQgKmtjb3B5ZF9jbGllbnQ7CiAKLQkvKiBRdWV1ZSBvZiBzbmFwc2hvdCB3cml0ZXMgZm9yIGtzbmFwZCB0byBmbHVzaCAqLwotCXN0cnVjdCBiaW9fbGlzdCBxdWV1ZWRfYmlvczsKLQlzdHJ1Y3Qgd29ya19zdHJ1Y3QgcXVldWVkX2Jpb3Nfd29yazsKLQogCS8qIFdhaXQgZm9yIGV2ZW50cyBiYXNlZCBvbiBzdGF0ZV9iaXRzICovCiAJdW5zaWduZWQgbG9uZyBzdGF0ZV9iaXRzOwogCkBAIC0xNjAsOSArMTUyLDYgQEAKIH0KIEVYUE9SVF9TWU1CT0woZG1fc25hcF9jb3cpOwogCi1zdGF0aWMgc3RydWN0IHdvcmtxdWV1ZV9zdHJ1Y3QgKmtzbmFwZDsKLXN0YXRpYyB2b2lkIGZsdXNoX3F1ZXVlZF9iaW9zKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yayk7Ci0KIHN0YXRpYyBzZWN0b3JfdCBjaHVua190b19zZWN0b3Ioc3RydWN0IGRtX2V4Y2VwdGlvbl9zdG9yZSAqc3RvcmUsCiAJCQkJY2h1bmtfdCBjaHVuaykKIHsKQEAgLTExMTAsNyArMTA5OSw2IEBACiAJcy0+dGkgPSB0aTsKIAlzLT52YWxpZCA9IDE7CiAJcy0+YWN0aXZlID0gMDsKLQlzLT5zdXNwZW5kZWQgPSAwOwogCWF0b21pY19zZXQoJnMtPnBlbmRpbmdfZXhjZXB0aW9uc19jb3VudCwgMCk7CiAJaW5pdF9yd3NlbSgmcy0+bG9jayk7CiAJSU5JVF9MSVNUX0hFQUQoJnMtPmxpc3QpOwpAQCAtMTE1Myw5ICsxMTQxLDYgQEAKIAogCXNwaW5fbG9ja19pbml0KCZzLT50cmFja2VkX2NodW5rX2xvY2spOwogCi0JYmlvX2xpc3RfaW5pdCgmcy0+cXVldWVkX2Jpb3MpOwotCUlOSVRfV09SSygmcy0+cXVldWVkX2Jpb3Nfd29yaywgZmx1c2hfcXVldWVkX2Jpb3MpOwotCiAJdGktPnByaXZhdGUgPSBzOwogCXRpLT5udW1fZmx1c2hfcmVxdWVzdHMgPSBudW1fZmx1c2hfcmVxdWVzdHM7CiAKQEAgLTEyNzksOCArMTI2NCw2IEBACiAJc3RydWN0IGRtX3NuYXBzaG90ICpzID0gdGktPnByaXZhdGU7CiAJc3RydWN0IGRtX3NuYXBzaG90ICpzbmFwX3NyYyA9IE5VTEwsICpzbmFwX2Rlc3QgPSBOVUxMOwogCi0JZmx1c2hfd29ya3F1ZXVlKGtzbmFwZCk7Ci0KIAlkb3duX3JlYWQoJl9vcmlnaW5zX2xvY2spOwogCS8qIENoZWNrIHdoZXRoZXIgZXhjZXB0aW9uIGhhbmRvdmVyIG11c3QgYmUgY2FuY2VsbGVkICovCiAJKHZvaWQpIF9fZmluZF9zbmFwc2hvdHNfc2hhcmluZ19jb3cocywgJnNuYXBfc3JjLCAmc25hcF9kZXN0LCBOVUxMKTsKQEAgLTEzNDIsMjAgKzEzMjUsNiBAQAogCX0KIH0KIAotc3RhdGljIHZvaWQgZmx1c2hfcXVldWVkX2Jpb3Moc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQotewotCXN0cnVjdCBkbV9zbmFwc2hvdCAqcyA9Ci0JCWNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3QgZG1fc25hcHNob3QsIHF1ZXVlZF9iaW9zX3dvcmspOwotCXN0cnVjdCBiaW8gKnF1ZXVlZF9iaW9zOwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0KLQlzcGluX2xvY2tfaXJxc2F2ZSgmcy0+cGVfbG9jaywgZmxhZ3MpOwotCXF1ZXVlZF9iaW9zID0gYmlvX2xpc3RfZ2V0KCZzLT5xdWV1ZWRfYmlvcyk7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcy0+cGVfbG9jaywgZmxhZ3MpOwotCi0JZmx1c2hfYmlvcyhxdWV1ZWRfYmlvcyk7Ci19Ci0KIHN0YXRpYyBpbnQgZG9fb3JpZ2luKHN0cnVjdCBkbV9kZXYgKm9yaWdpbiwgc3RydWN0IGJpbyAqYmlvKTsKIAogLyoKQEAgLTE3NjAsMTUgKzE3MjksNiBAQAogCXN0b3BfbWVyZ2Uocyk7CiB9CiAKLXN0YXRpYyB2b2lkIHNuYXBzaG90X3Bvc3RzdXNwZW5kKHN0cnVjdCBkbV90YXJnZXQgKnRpKQotewotCXN0cnVjdCBkbV9zbmFwc2hvdCAqcyA9IHRpLT5wcml2YXRlOwotCi0JZG93bl93cml0ZSgmcy0+bG9jayk7Ci0Jcy0+c3VzcGVuZGVkID0gMTsKLQl1cF93cml0ZSgmcy0+bG9jayk7Ci19Ci0KIHN0YXRpYyBpbnQgc25hcHNob3RfcHJlcmVzdW1lKHN0cnVjdCBkbV90YXJnZXQgKnRpKQogewogCWludCByID0gMDsKQEAgLTE3ODMsNyArMTc0Myw3IEBACiAJCQlETUVSUigiVW5hYmxlIHRvIHJlc3VtZSBzbmFwc2hvdCBzb3VyY2UgdW50aWwgIgogCQkJICAgICAgImhhbmRvdmVyIGNvbXBsZXRlcy4iKTsKIAkJCXIgPSAtRUlOVkFMOwotCQl9IGVsc2UgaWYgKCFzbmFwX3NyYy0+c3VzcGVuZGVkKSB7CisJCX0gZWxzZSBpZiAoIWRtX3N1c3BlbmRlZChzbmFwX3NyYy0+dGkpKSB7CiAJCQlETUVSUigiVW5hYmxlIHRvIHBlcmZvcm0gc25hcHNob3QgaGFuZG92ZXIgdW50aWwgIgogCQkJICAgICAgInNvdXJjZSBpcyBzdXNwZW5kZWQuIik7CiAJCQlyID0gLUVJTlZBTDsKQEAgLTE4MTYsNyArMTc3Niw2IEBACiAKIAlkb3duX3dyaXRlKCZzLT5sb2NrKTsKIAlzLT5hY3RpdmUgPSAxOwotCXMtPnN1c3BlbmRlZCA9IDA7CiAJdXBfd3JpdGUoJnMtPmxvY2spOwogfQogCkBAIC0yMTk0LDcgKzIxNTMsNyBAQAogCiBzdGF0aWMgc3RydWN0IHRhcmdldF90eXBlIG9yaWdpbl90YXJnZXQgPSB7CiAJLm5hbWUgICAgPSAic25hcHNob3Qtb3JpZ2luIiwKLQkudmVyc2lvbiA9IHsxLCA3LCAwfSwKKwkudmVyc2lvbiA9IHsxLCA3LCAxfSwKIAkubW9kdWxlICA9IFRISVNfTU9EVUxFLAogCS5jdHIgICAgID0gb3JpZ2luX2N0ciwKIAkuZHRyICAgICA9IG9yaWdpbl9kdHIsCkBAIC0yMjA3LDEzICsyMTY2LDEyIEBACiAKIHN0YXRpYyBzdHJ1Y3QgdGFyZ2V0X3R5cGUgc25hcHNob3RfdGFyZ2V0ID0gewogCS5uYW1lICAgID0gInNuYXBzaG90IiwKLQkudmVyc2lvbiA9IHsxLCA5LCAwfSwKKwkudmVyc2lvbiA9IHsxLCAxMCwgMH0sCiAJLm1vZHVsZSAgPSBUSElTX01PRFVMRSwKIAkuY3RyICAgICA9IHNuYXBzaG90X2N0ciwKIAkuZHRyICAgICA9IHNuYXBzaG90X2R0ciwKIAkubWFwICAgICA9IHNuYXBzaG90X21hcCwKIAkuZW5kX2lvICA9IHNuYXBzaG90X2VuZF9pbywKLQkucG9zdHN1c3BlbmQgPSBzbmFwc2hvdF9wb3N0c3VzcGVuZCwKIAkucHJlcmVzdW1lICA9IHNuYXBzaG90X3ByZXJlc3VtZSwKIAkucmVzdW1lICA9IHNuYXBzaG90X3Jlc3VtZSwKIAkuc3RhdHVzICA9IHNuYXBzaG90X3N0YXR1cywKQEAgLTIyMjIsMTQgKzIxODAsMTMgQEAKIAogc3RhdGljIHN0cnVjdCB0YXJnZXRfdHlwZSBtZXJnZV90YXJnZXQgPSB7CiAJLm5hbWUgICAgPSBkbV9zbmFwc2hvdF9tZXJnZV90YXJnZXRfbmFtZSwKLQkudmVyc2lvbiA9IHsxLCAwLCAwfSwKKwkudmVyc2lvbiA9IHsxLCAxLCAwfSwKIAkubW9kdWxlICA9IFRISVNfTU9EVUxFLAogCS5jdHIgICAgID0gc25hcHNob3RfY3RyLAogCS5kdHIgICAgID0gc25hcHNob3RfZHRyLAogCS5tYXAgICAgID0gc25hcHNob3RfbWVyZ2VfbWFwLAogCS5lbmRfaW8gID0gc25hcHNob3RfZW5kX2lvLAogCS5wcmVzdXNwZW5kID0gc25hcHNob3RfbWVyZ2VfcHJlc3VzcGVuZCwKLQkucG9zdHN1c3BlbmQgPSBzbmFwc2hvdF9wb3N0c3VzcGVuZCwKIAkucHJlcmVzdW1lICA9IHNuYXBzaG90X3ByZXJlc3VtZSwKIAkucmVzdW1lICA9IHNuYXBzaG90X21lcmdlX3Jlc3VtZSwKIAkuc3RhdHVzICA9IHNuYXBzaG90X3N0YXR1cywKQEAgLTIyOTEsMTcgKzIyNDgsOCBAQAogCQlnb3RvIGJhZF90cmFja2VkX2NodW5rX2NhY2hlOwogCX0KIAotCWtzbmFwZCA9IGNyZWF0ZV9zaW5nbGV0aHJlYWRfd29ya3F1ZXVlKCJrc25hcGQiKTsKLQlpZiAoIWtzbmFwZCkgewotCQlETUVSUigiRmFpbGVkIHRvIGNyZWF0ZSBrc25hcGQgd29ya3F1ZXVlLiIpOwotCQlyID0gLUVOT01FTTsKLQkJZ290byBiYWRfcGVuZGluZ19wb29sOwotCX0KLQogCXJldHVybiAwOwogCi1iYWRfcGVuZGluZ19wb29sOgotCWttZW1fY2FjaGVfZGVzdHJveSh0cmFja2VkX2NodW5rX2NhY2hlKTsKIGJhZF90cmFja2VkX2NodW5rX2NhY2hlOgogCWttZW1fY2FjaGVfZGVzdHJveShwZW5kaW5nX2NhY2hlKTsKIGJhZF9wZW5kaW5nX2NhY2hlOgpAQCAtMjMyMiw4ICsyMjcwLDYgQEAKIAogc3RhdGljIHZvaWQgX19leGl0IGRtX3NuYXBzaG90X2V4aXQodm9pZCkKIHsKLQlkZXN0cm95X3dvcmtxdWV1ZShrc25hcGQpOwotCiAJZG1fdW5yZWdpc3Rlcl90YXJnZXQoJnNuYXBzaG90X3RhcmdldCk7CiAJZG1fdW5yZWdpc3Rlcl90YXJnZXQoJm9yaWdpbl90YXJnZXQpOwogCWRtX3VucmVnaXN0ZXJfdGFyZ2V0KCZtZXJnZV90YXJnZXQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1zdHJpcGUuYyBiL2RyaXZlcnMvbWQvZG0tc3RyaXBlLmMKaW5kZXggZjAzNzFiNC4uZGRkZmExNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1zdHJpcGUuYworKysgYi9kcml2ZXJzL21kL2RtLXN0cmlwZS5jCkBAIC0zOSwyMyArMzksMjAgQEAKIAlzdHJ1Y3QgZG1fdGFyZ2V0ICp0aTsKIAogCS8qIFdvcmsgc3RydWN0IHVzZWQgZm9yIHRyaWdnZXJpbmcgZXZlbnRzKi8KLQlzdHJ1Y3Qgd29ya19zdHJ1Y3Qga3N0cmlwZWRfd3M7CisJc3RydWN0IHdvcmtfc3RydWN0IHRyaWdnZXJfZXZlbnQ7CiAKIAlzdHJ1Y3Qgc3RyaXBlIHN0cmlwZVswXTsKIH07CiAKLXN0YXRpYyBzdHJ1Y3Qgd29ya3F1ZXVlX3N0cnVjdCAqa3N0cmlwZWQ7Ci0KIC8qCiAgKiBBbiBldmVudCBpcyB0cmlnZ2VyZWQgd2hlbmV2ZXIgYSBkcml2ZQogICogZHJvcHMgb3V0IG9mIGEgc3RyaXBlIHZvbHVtZS4KICAqLwogc3RhdGljIHZvaWQgdHJpZ2dlcl9ldmVudChzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiB7Ci0Jc3RydWN0IHN0cmlwZV9jICpzYyA9IGNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3Qgc3RyaXBlX2MsIGtzdHJpcGVkX3dzKTsKLQorCXN0cnVjdCBzdHJpcGVfYyAqc2MgPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0IHN0cmlwZV9jLAorCQkJCQkgICB0cmlnZ2VyX2V2ZW50KTsKIAlkbV90YWJsZV9ldmVudChzYy0+dGktPnRhYmxlKTsKLQogfQogCiBzdGF0aWMgaW5saW5lIHN0cnVjdCBzdHJpcGVfYyAqYWxsb2NfY29udGV4dCh1bnNpZ25lZCBpbnQgc3RyaXBlcykKQEAgLTE2MCw3ICsxNTcsNyBAQAogCQlyZXR1cm4gLUVOT01FTTsKIAl9CiAKLQlJTklUX1dPUksoJnNjLT5rc3RyaXBlZF93cywgdHJpZ2dlcl9ldmVudCk7CisJSU5JVF9XT1JLKCZzYy0+dHJpZ2dlcl9ldmVudCwgdHJpZ2dlcl9ldmVudCk7CiAKIAkvKiBTZXQgcG9pbnRlciB0byBkbSB0YXJnZXQ7IHVzZWQgaW4gdHJpZ2dlcl9ldmVudCAqLwogCXNjLT50aSA9IHRpOwpAQCAtMjExLDcgKzIwOCw3IEBACiAJZm9yIChpID0gMDsgaSA8IHNjLT5zdHJpcGVzOyBpKyspCiAJCWRtX3B1dF9kZXZpY2UodGksIHNjLT5zdHJpcGVbaV0uZGV2KTsKIAotCWZsdXNoX3dvcmtxdWV1ZShrc3RyaXBlZCk7CisJZmx1c2hfd29ya19zeW5jKCZzYy0+dHJpZ2dlcl9ldmVudCk7CiAJa2ZyZWUoc2MpOwogfQogCkBAIC0zNjcsNyArMzY0LDcgQEAKIAkJCWF0b21pY19pbmMoJihzYy0+c3RyaXBlW2ldLmVycm9yX2NvdW50KSk7CiAJCQlpZiAoYXRvbWljX3JlYWQoJihzYy0+c3RyaXBlW2ldLmVycm9yX2NvdW50KSkgPAogCQkJICAgIERNX0lPX0VSUk9SX1RIUkVTSE9MRCkKLQkJCQlxdWV1ZV93b3JrKGtzdHJpcGVkLCAmc2MtPmtzdHJpcGVkX3dzKTsKKwkJCQlzY2hlZHVsZV93b3JrKCZzYy0+dHJpZ2dlcl9ldmVudCk7CiAJCX0KIAogCXJldHVybiBlcnJvcjsKQEAgLTQwMSw3ICszOTgsNyBAQAogCiBzdGF0aWMgc3RydWN0IHRhcmdldF90eXBlIHN0cmlwZV90YXJnZXQgPSB7CiAJLm5hbWUgICA9ICJzdHJpcGVkIiwKLQkudmVyc2lvbiA9IHsxLCAzLCAwfSwKKwkudmVyc2lvbiA9IHsxLCAzLCAxfSwKIAkubW9kdWxlID0gVEhJU19NT0RVTEUsCiAJLmN0ciAgICA9IHN0cmlwZV9jdHIsCiAJLmR0ciAgICA9IHN0cmlwZV9kdHIsCkBAIC00MjIsMjAgKzQxOSwxMCBAQAogCQlyZXR1cm4gcjsKIAl9CiAKLQlrc3RyaXBlZCA9IGNyZWF0ZV9zaW5nbGV0aHJlYWRfd29ya3F1ZXVlKCJrc3RyaXBlZCIpOwotCWlmICgha3N0cmlwZWQpIHsKLQkJRE1FUlIoImZhaWxlZCB0byBjcmVhdGUgd29ya3F1ZXVlIGtzdHJpcGVkIik7Ci0JCWRtX3VucmVnaXN0ZXJfdGFyZ2V0KCZzdHJpcGVfdGFyZ2V0KTsKLQkJcmV0dXJuIC1FTk9NRU07Ci0JfQotCiAJcmV0dXJuIHI7CiB9CiAKIHZvaWQgZG1fc3RyaXBlX2V4aXQodm9pZCkKIHsKIAlkbV91bnJlZ2lzdGVyX3RhcmdldCgmc3RyaXBlX3RhcmdldCk7Ci0JZGVzdHJveV93b3JrcXVldWUoa3N0cmlwZWQpOwotCi0JcmV0dXJuOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS10YWJsZS5jIGIvZHJpdmVycy9tZC9kbS10YWJsZS5jCmluZGV4IDk4NWMyMGEuLjM4ZTRlYjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tdGFibGUuYworKysgYi9kcml2ZXJzL21kL2RtLXRhYmxlLmMKQEAgLTcxLDYgKzcxLDggQEAKIAl2b2lkICpldmVudF9jb250ZXh0OwogCiAJc3RydWN0IGRtX21kX21lbXBvb2xzICptZW1wb29sczsKKworCXN0cnVjdCBsaXN0X2hlYWQgdGFyZ2V0X2NhbGxiYWNrczsKIH07CiAKIC8qCkBAIC0yMDQsNiArMjA2LDcgQEAKIAkJcmV0dXJuIC1FTk9NRU07CiAKIAlJTklUX0xJU1RfSEVBRCgmdC0+ZGV2aWNlcyk7CisJSU5JVF9MSVNUX0hFQUQoJnQtPnRhcmdldF9jYWxsYmFja3MpOwogCWF0b21pY19zZXQoJnQtPmhvbGRlcnMsIDApOwogCXQtPmRpc2NhcmRzX3N1cHBvcnRlZCA9IDE7CiAKQEAgLTM0Nyw2ICszNTAsNyBAQAogCWlmICghZC0+ZG1fZGV2LmJkZXYpCiAJCXJldHVybjsKIAorCWJkX3VubGlua19kaXNrX2hvbGRlcihkLT5kbV9kZXYuYmRldiwgZG1fZGlzayhtZCkpOwogCWJsa2Rldl9wdXQoZC0+ZG1fZGV2LmJkZXYsIGQtPmRtX2Rldi5tb2RlIHwgRk1PREVfRVhDTCk7CiAJZC0+ZG1fZGV2LmJkZXYgPSBOVUxMOwogfQpAQCAtMTIyNSwxMCArMTIyOSwxNyBAQAogCXJldHVybiAwOwogfQogCit2b2lkIGRtX3RhYmxlX2FkZF90YXJnZXRfY2FsbGJhY2tzKHN0cnVjdCBkbV90YWJsZSAqdCwgc3RydWN0IGRtX3RhcmdldF9jYWxsYmFja3MgKmNiKQoreworCWxpc3RfYWRkKCZjYi0+bGlzdCwgJnQtPnRhcmdldF9jYWxsYmFja3MpOworfQorRVhQT1JUX1NZTUJPTF9HUEwoZG1fdGFibGVfYWRkX3RhcmdldF9jYWxsYmFja3MpOworCiBpbnQgZG1fdGFibGVfYW55X2Nvbmdlc3RlZChzdHJ1Y3QgZG1fdGFibGUgKnQsIGludCBiZGlfYml0cykKIHsKIAlzdHJ1Y3QgZG1fZGV2X2ludGVybmFsICpkZDsKIAlzdHJ1Y3QgbGlzdF9oZWFkICpkZXZpY2VzID0gZG1fdGFibGVfZ2V0X2RldmljZXModCk7CisJc3RydWN0IGRtX3RhcmdldF9jYWxsYmFja3MgKmNiOwogCWludCByID0gMDsKIAogCWxpc3RfZm9yX2VhY2hfZW50cnkoZGQsIGRldmljZXMsIGxpc3QpIHsKQEAgLTEyNDMsNiArMTI1NCwxMCBAQAogCQkJCSAgICAgYmRldm5hbWUoZGQtPmRtX2Rldi5iZGV2LCBiKSk7CiAJfQogCisJbGlzdF9mb3JfZWFjaF9lbnRyeShjYiwgJnQtPnRhcmdldF9jYWxsYmFja3MsIGxpc3QpCisJCWlmIChjYi0+Y29uZ2VzdGVkX2ZuKQorCQkJciB8PSBjYi0+Y29uZ2VzdGVkX2ZuKGNiLCBiZGlfYml0cyk7CisKIAlyZXR1cm4gcjsKIH0KIApAQCAtMTI2NCw2ICsxMjc5LDcgQEAKIHsKIAlzdHJ1Y3QgZG1fZGV2X2ludGVybmFsICpkZDsKIAlzdHJ1Y3QgbGlzdF9oZWFkICpkZXZpY2VzID0gZG1fdGFibGVfZ2V0X2RldmljZXModCk7CisJc3RydWN0IGRtX3RhcmdldF9jYWxsYmFja3MgKmNiOwogCiAJbGlzdF9mb3JfZWFjaF9lbnRyeShkZCwgZGV2aWNlcywgbGlzdCkgewogCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKGRkLT5kbV9kZXYuYmRldik7CkBAIC0xMjc2LDYgKzEyOTIsMTAgQEAKIAkJCQkgICAgIGRtX2RldmljZV9uYW1lKHQtPm1kKSwKIAkJCQkgICAgIGJkZXZuYW1lKGRkLT5kbV9kZXYuYmRldiwgYikpOwogCX0KKworCWxpc3RfZm9yX2VhY2hfZW50cnkoY2IsICZ0LT50YXJnZXRfY2FsbGJhY2tzLCBsaXN0KQorCQlpZiAoY2ItPnVucGx1Z19mbikKKwkJCWNiLT51bnBsdWdfZm4oY2IpOwogfQogCiBzdHJ1Y3QgbWFwcGVkX2RldmljZSAqZG1fdGFibGVfZ2V0X21kKHN0cnVjdCBkbV90YWJsZSAqdCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvZG0uYyBiL2RyaXZlcnMvbWQvZG0uYwppbmRleCBmNDhhMmYzLi5lYWEzYWYwIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLmMKKysrIGIvZHJpdmVycy9tZC9kbS5jCkBAIC0zMiw3ICszMiw2IEBACiAjZGVmaW5lIERNX0NPT0tJRV9FTlZfVkFSX05BTUUgIkRNX0NPT0tJRSIKICNkZWZpbmUgRE1fQ09PS0lFX0xFTkdUSCAyNAogCi1zdGF0aWMgREVGSU5FX01VVEVYKGRtX211dGV4KTsKIHN0YXRpYyBjb25zdCBjaGFyICpfbmFtZSA9IERNX05BTUU7CiAKIHN0YXRpYyB1bnNpZ25lZCBpbnQgbWFqb3IgPSAwOwpAQCAtMzI4LDcgKzMyNyw2IEBACiB7CiAJc3RydWN0IG1hcHBlZF9kZXZpY2UgKm1kOwogCi0JbXV0ZXhfbG9jaygmZG1fbXV0ZXgpOwogCXNwaW5fbG9jaygmX21pbm9yX2xvY2spOwogCiAJbWQgPSBiZGV2LT5iZF9kaXNrLT5wcml2YXRlX2RhdGE7CkBAIC0zNDYsNyArMzQ0LDYgQEAKIAogb3V0OgogCXNwaW5fdW5sb2NrKCZfbWlub3JfbG9jayk7Ci0JbXV0ZXhfdW5sb2NrKCZkbV9tdXRleCk7CiAKIAlyZXR1cm4gbWQgPyAwIDogLUVOWElPOwogfQpAQCAtMzU1LDEwICszNTIsMTIgQEAKIHsKIAlzdHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQgPSBkaXNrLT5wcml2YXRlX2RhdGE7CiAKLQltdXRleF9sb2NrKCZkbV9tdXRleCk7CisJc3Bpbl9sb2NrKCZfbWlub3JfbG9jayk7CisKIAlhdG9taWNfZGVjKCZtZC0+b3Blbl9jb3VudCk7CiAJZG1fcHV0KG1kKTsKLQltdXRleF91bmxvY2soJmRtX211dGV4KTsKKworCXNwaW5fdW5sb2NrKCZfbWlub3JfbG9jayk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTE2MzgsMTMgKzE2MzcsMTUgQEAKIAkJaWYgKG1hcF9yZXF1ZXN0KHRpLCBjbG9uZSwgbWQpKQogCQkJZ290byByZXF1ZXVlZDsKIAotCQlzcGluX2xvY2tfaXJxKHEtPnF1ZXVlX2xvY2spOworCQlCVUdfT04oIWlycXNfZGlzYWJsZWQoKSk7CisJCXNwaW5fbG9jayhxLT5xdWV1ZV9sb2NrKTsKIAl9CiAKIAlnb3RvIG91dDsKIAogcmVxdWV1ZWQ6Ci0Jc3Bpbl9sb2NrX2lycShxLT5xdWV1ZV9sb2NrKTsKKwlCVUdfT04oIWlycXNfZGlzYWJsZWQoKSk7CisJc3Bpbl9sb2NrKHEtPnF1ZXVlX2xvY2spOwogCiBwbHVnX2FuZF9vdXQ6CiAJaWYgKCFlbHZfcXVldWVfZW1wdHkocSkpCkBAIC0xODg0LDcgKzE4ODUsOCBAQAogCWFkZF9kaXNrKG1kLT5kaXNrKTsKIAlmb3JtYXRfZGV2X3QobWQtPm5hbWUsIE1LREVWKF9tYWpvciwgbWlub3IpKTsKIAotCW1kLT53cSA9IGNyZWF0ZV9zaW5nbGV0aHJlYWRfd29ya3F1ZXVlKCJrZG1mbHVzaCIpOworCW1kLT53cSA9IGFsbG9jX3dvcmtxdWV1ZSgia2RtZmx1c2giLAorCQkJCSBXUV9OT05fUkVFTlRSQU5UIHwgV1FfTUVNX1JFQ0xBSU0sIDApOwogCWlmICghbWQtPndxKQogCQlnb3RvIGJhZF90aHJlYWQ7CiAKQEAgLTE5OTIsMTMgKzE5OTQsMTQgQEAKIAl3YWtlX3VwKCZtZC0+ZXZlbnRxKTsKIH0KIAorLyoKKyAqIFByb3RlY3RlZCBieSBtZC0+c3VzcGVuZF9sb2NrIG9idGFpbmVkIGJ5IGRtX3N3YXBfdGFibGUoKS4KKyAqLwogc3RhdGljIHZvaWQgX19zZXRfc2l6ZShzdHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQsIHNlY3Rvcl90IHNpemUpCiB7CiAJc2V0X2NhcGFjaXR5KG1kLT5kaXNrLCBzaXplKTsKIAotCW11dGV4X2xvY2soJm1kLT5iZGV2LT5iZF9pbm9kZS0+aV9tdXRleCk7CiAJaV9zaXplX3dyaXRlKG1kLT5iZGV2LT5iZF9pbm9kZSwgKGxvZmZfdClzaXplIDw8IFNFQ1RPUl9TSElGVCk7Ci0JbXV0ZXhfdW5sb2NrKCZtZC0+YmRldi0+YmRfaW5vZGUtPmlfbXV0ZXgpOwogfQogCiAvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9tZC5jIGIvZHJpdmVycy9tZC9tZC5jCmluZGV4IDdmYzA5MGEuLjBjYzMwZWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvbWQuYworKysgYi9kcml2ZXJzL21kL21kLmMKQEAgLTI4NywxMSArMjg3LDE0IEBACiAJbWRkZXZfdCAqbWRkZXYgPSBxLT5xdWV1ZWRhdGE7CiAJaW50IHJ2OwogCWludCBjcHU7CisJdW5zaWduZWQgaW50IHNlY3RvcnM7CiAKLQlpZiAobWRkZXYgPT0gTlVMTCB8fCBtZGRldi0+cGVycyA9PSBOVUxMKSB7CisJaWYgKG1kZGV2ID09IE5VTEwgfHwgbWRkZXYtPnBlcnMgPT0gTlVMTAorCSAgICB8fCAhbWRkZXYtPnJlYWR5KSB7CiAJCWJpb19pb19lcnJvcihiaW8pOwogCQlyZXR1cm4gMDsKIAl9CisJc21wX3JtYigpOyAvKiBFbnN1cmUgaW1wbGljYXRpb25zIG9mICAnYWN0aXZlJyBhcmUgdmlzaWJsZSAqLwogCXJjdV9yZWFkX2xvY2soKTsKIAlpZiAobWRkZXYtPnN1c3BlbmRlZCkgewogCQlERUZJTkVfV0FJVChfX3dhaXQpOwpAQCAtMzA5LDEyICszMTIsMTYgQEAKIAlhdG9taWNfaW5jKCZtZGRldi0+YWN0aXZlX2lvKTsKIAlyY3VfcmVhZF91bmxvY2soKTsKIAorCS8qCisJICogc2F2ZSB0aGUgc2VjdG9ycyBub3cgc2luY2Ugb3VyIGJpbyBjYW4KKwkgKiBnbyBhd2F5IGluc2lkZSBtYWtlX3JlcXVlc3QKKwkgKi8KKwlzZWN0b3JzID0gYmlvX3NlY3RvcnMoYmlvKTsKIAlydiA9IG1kZGV2LT5wZXJzLT5tYWtlX3JlcXVlc3QobWRkZXYsIGJpbyk7CiAKIAljcHUgPSBwYXJ0X3N0YXRfbG9jaygpOwogCXBhcnRfc3RhdF9pbmMoY3B1LCAmbWRkZXYtPmdlbmRpc2stPnBhcnQwLCBpb3NbcnddKTsKLQlwYXJ0X3N0YXRfYWRkKGNwdSwgJm1kZGV2LT5nZW5kaXNrLT5wYXJ0MCwgc2VjdG9yc1tyd10sCi0JCSAgICAgIGJpb19zZWN0b3JzKGJpbykpOworCXBhcnRfc3RhdF9hZGQoY3B1LCAmbWRkZXYtPmdlbmRpc2stPnBhcnQwLCBzZWN0b3JzW3J3XSwgc2VjdG9ycyk7CiAJcGFydF9zdGF0X3VubG9jaygpOwogCiAJaWYgKGF0b21pY19kZWNfYW5kX3Rlc3QoJm1kZGV2LT5hY3RpdmVfaW8pICYmIG1kZGV2LT5zdXNwZW5kZWQpCkBAIC03MDMsOSArNzEwLDkgQEAKIH0KIAogLyogcmV0dXJuIHRoZSBvZmZzZXQgb2YgdGhlIHN1cGVyIGJsb2NrIGluIDUxMmJ5dGUgc2VjdG9ycyAqLwotc3RhdGljIGlubGluZSBzZWN0b3JfdCBjYWxjX2Rldl9zYm9mZnNldChzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2KQorc3RhdGljIGlubGluZSBzZWN0b3JfdCBjYWxjX2Rldl9zYm9mZnNldChtZGtfcmRldl90ICpyZGV2KQogewotCXNlY3Rvcl90IG51bV9zZWN0b3JzID0gaV9zaXplX3JlYWQoYmRldi0+YmRfaW5vZGUpIC8gNTEyOworCXNlY3Rvcl90IG51bV9zZWN0b3JzID0gaV9zaXplX3JlYWQocmRldi0+YmRldi0+YmRfaW5vZGUpIC8gNTEyOwogCXJldHVybiBNRF9ORVdfU0laRV9TRUNUT1JTKG51bV9zZWN0b3JzKTsKIH0KIApAQCAtNzYzLDcgKzc3MCw3IEBACiAJICovCiAJc3RydWN0IGJpbyAqYmlvID0gYmlvX2FsbG9jX21kZGV2KEdGUF9OT0lPLCAxLCBtZGRldik7CiAKLQliaW8tPmJpX2JkZXYgPSByZGV2LT5iZGV2OworCWJpby0+YmlfYmRldiA9IHJkZXYtPm1ldGFfYmRldiA/IHJkZXYtPm1ldGFfYmRldiA6IHJkZXYtPmJkZXY7CiAJYmlvLT5iaV9zZWN0b3IgPSBzZWN0b3I7CiAJYmlvX2FkZF9wYWdlKGJpbywgcGFnZSwgc2l6ZSwgMCk7CiAJYmlvLT5iaV9wcml2YXRlID0gcmRldjsKQEAgLTc5Myw3ICs4MDAsNyBAQAogfQogCiBpbnQgc3luY19wYWdlX2lvKG1ka19yZGV2X3QgKnJkZXYsIHNlY3Rvcl90IHNlY3RvciwgaW50IHNpemUsCi0JCSBzdHJ1Y3QgcGFnZSAqcGFnZSwgaW50IHJ3KQorCQkgc3RydWN0IHBhZ2UgKnBhZ2UsIGludCBydywgYm9vbCBtZXRhZGF0YV9vcCkKIHsKIAlzdHJ1Y3QgYmlvICpiaW8gPSBiaW9fYWxsb2NfbWRkZXYoR0ZQX05PSU8sIDEsIHJkZXYtPm1kZGV2KTsKIAlzdHJ1Y3QgY29tcGxldGlvbiBldmVudDsKQEAgLTgwMSw4ICs4MDgsMTIgQEAKIAogCXJ3IHw9IFJFUV9TWU5DIHwgUkVRX1VOUExVRzsKIAotCWJpby0+YmlfYmRldiA9IHJkZXYtPmJkZXY7Ci0JYmlvLT5iaV9zZWN0b3IgPSBzZWN0b3I7CisJYmlvLT5iaV9iZGV2ID0gKG1ldGFkYXRhX29wICYmIHJkZXYtPm1ldGFfYmRldikgPworCQlyZGV2LT5tZXRhX2JkZXYgOiByZGV2LT5iZGV2OworCWlmIChtZXRhZGF0YV9vcCkKKwkJYmlvLT5iaV9zZWN0b3IgPSBzZWN0b3IgKyByZGV2LT5zYl9zdGFydDsKKwllbHNlCisJCWJpby0+Ymlfc2VjdG9yID0gc2VjdG9yICsgcmRldi0+ZGF0YV9vZmZzZXQ7CiAJYmlvX2FkZF9wYWdlKGJpbywgcGFnZSwgc2l6ZSwgMCk7CiAJaW5pdF9jb21wbGV0aW9uKCZldmVudCk7CiAJYmlvLT5iaV9wcml2YXRlID0gJmV2ZW50OwpAQCAtODI3LDcgKzgzOCw3IEBACiAJCXJldHVybiAwOwogCiAKLQlpZiAoIXN5bmNfcGFnZV9pbyhyZGV2LCByZGV2LT5zYl9zdGFydCwgc2l6ZSwgcmRldi0+c2JfcGFnZSwgUkVBRCkpCisJaWYgKCFzeW5jX3BhZ2VfaW8ocmRldiwgMCwgc2l6ZSwgcmRldi0+c2JfcGFnZSwgUkVBRCwgdHJ1ZSkpCiAJCWdvdG8gZmFpbDsKIAlyZGV2LT5zYl9sb2FkZWQgPSAxOwogCXJldHVybiAwOwpAQCAtOTg5LDcgKzEwMDAsNyBAQAogCSAqCiAJICogSXQgYWxzbyBoYXBwZW5zIHRvIGJlIGEgbXVsdGlwbGUgb2YgNEtiLgogCSAqLwotCXJkZXYtPnNiX3N0YXJ0ID0gY2FsY19kZXZfc2JvZmZzZXQocmRldi0+YmRldik7CisJcmRldi0+c2Jfc3RhcnQgPSBjYWxjX2Rldl9zYm9mZnNldChyZGV2KTsKIAogCXJldCA9IHJlYWRfZGlza19zYihyZGV2LCBNRF9TQl9CWVRFUyk7CiAJaWYgKHJldCkgcmV0dXJuIHJldDsKQEAgLTEzMzAsNyArMTM0MSw3IEBACiAJCXJldHVybiAwOyAvKiBjb21wb25lbnQgbXVzdCBmaXQgZGV2aWNlICovCiAJaWYgKHJkZXYtPm1kZGV2LT5iaXRtYXBfaW5mby5vZmZzZXQpCiAJCXJldHVybiAwOyAvKiBjYW4ndCBtb3ZlIGJpdG1hcCAqLwotCXJkZXYtPnNiX3N0YXJ0ID0gY2FsY19kZXZfc2JvZmZzZXQocmRldi0+YmRldik7CisJcmRldi0+c2Jfc3RhcnQgPSBjYWxjX2Rldl9zYm9mZnNldChyZGV2KTsKIAlpZiAoIW51bV9zZWN0b3JzIHx8IG51bV9zZWN0b3JzID4gcmRldi0+c2Jfc3RhcnQpCiAJCW51bV9zZWN0b3JzID0gcmRldi0+c2Jfc3RhcnQ7CiAJbWRfc3VwZXJfd3JpdGUocmRldi0+bWRkZXYsIHJkZXYsIHJkZXYtPnNiX3N0YXJ0LCByZGV2LT5zYl9zaXplLApAQCAtMTkwNiw2ICsxOTE3LDcgQEAKIAkJTURfQlVHKCk7CiAJCXJldHVybjsKIAl9CisJYmRfdW5saW5rX2Rpc2tfaG9sZGVyKHJkZXYtPmJkZXYsIHJkZXYtPm1kZGV2LT5nZW5kaXNrKTsKIAlsaXN0X2RlbF9yY3UoJnJkZXYtPnNhbWVfc2V0KTsKIAlwcmludGsoS0VSTl9JTkZPICJtZDogdW5iaW5kPCVzPlxuIiwgYmRldm5hbWUocmRldi0+YmRldixiKSk7CiAJcmRldi0+bWRkZXYgPSBOVUxMOwpAQCAtMTk0MCw4ICsxOTUyLDYgQEAKIAkJCV9fYmRldm5hbWUoZGV2LCBiKSk7CiAJCXJldHVybiBQVFJfRVJSKGJkZXYpOwogCX0KLQlpZiAoIXNoYXJlZCkKLQkJc2V0X2JpdChBbGxSZXNlcnZlZCwgJnJkZXYtPmZsYWdzKTsKIAlyZGV2LT5iZGV2ID0gYmRldjsKIAlyZXR1cm4gZXJyOwogfQpAQCAtMjQ1OCw2ICsyNDY4LDkgQEAKIAkJaWYgKHJkZXYtPnJhaWRfZGlzayAhPSAtMSkKIAkJCXJldHVybiAtRUJVU1k7CiAKKwkJaWYgKHRlc3RfYml0KE1EX1JFQ09WRVJZX1JVTk5JTkcsICZyZGV2LT5tZGRldi0+cmVjb3ZlcnkpKQorCQkJcmV0dXJuIC1FQlVTWTsKKwogCQlpZiAocmRldi0+bWRkZXYtPnBlcnMtPmhvdF9hZGRfZGlzayA9PSBOVUxMKQogCQkJcmV0dXJuIC1FSU5WQUw7CiAKQEAgLTI0NjUsNiArMjQ3OCwxMCBAQAogCQkJaWYgKHJkZXYyLT5yYWlkX2Rpc2sgPT0gc2xvdCkKIAkJCQlyZXR1cm4gLUVFWElTVDsKIAorCQlpZiAoc2xvdCA+PSByZGV2LT5tZGRldi0+cmFpZF9kaXNrcyAmJgorCQkgICAgc2xvdCA+PSByZGV2LT5tZGRldi0+cmFpZF9kaXNrcyArIHJkZXYtPm1kZGV2LT5kZWx0YV9kaXNrcykKKwkJCXJldHVybiAtRU5PU1BDOworCiAJCXJkZXYtPnJhaWRfZGlzayA9IHNsb3Q7CiAJCWlmICh0ZXN0X2JpdChJbl9zeW5jLCAmcmRldi0+ZmxhZ3MpKQogCQkJcmRldi0+c2F2ZWRfcmFpZF9kaXNrID0gc2xvdDsKQEAgLTI0ODIsNyArMjQ5OSw4IEBACiAJCQkvKiBmYWlsdXJlIGhlcmUgaXMgT0sgKi87CiAJCS8qIGRvbid0IHdha2V1cCBhbnlvbmUsIGxlYXZlIHRoYXQgdG8gdXNlcnNwYWNlLiAqLwogCX0gZWxzZSB7Ci0JCWlmIChzbG90ID49IHJkZXYtPm1kZGV2LT5yYWlkX2Rpc2tzKQorCQlpZiAoc2xvdCA+PSByZGV2LT5tZGRldi0+cmFpZF9kaXNrcyAmJgorCQkgICAgc2xvdCA+PSByZGV2LT5tZGRldi0+cmFpZF9kaXNrcyArIHJkZXYtPm1kZGV2LT5kZWx0YV9kaXNrcykKIAkJCXJldHVybiAtRU5PU1BDOwogCQlyZGV2LT5yYWlkX2Rpc2sgPSBzbG90OwogCQkvKiBhc3N1bWUgaXQgaXMgd29ya2luZyAqLwpAQCAtMjU5OCwxMiArMjYxNiwxMSBAQAogCiAJCQltZGRldl9sb2NrKG1kZGV2KTsKIAkJCWxpc3RfZm9yX2VhY2hfZW50cnkocmRldjIsICZtZGRldi0+ZGlza3MsIHNhbWVfc2V0KQotCQkJCWlmICh0ZXN0X2JpdChBbGxSZXNlcnZlZCwgJnJkZXYyLT5mbGFncykgfHwKLQkJCQkgICAgKHJkZXYtPmJkZXYgPT0gcmRldjItPmJkZXYgJiYKLQkJCQkgICAgIHJkZXYgIT0gcmRldjIgJiYKLQkJCQkgICAgIG92ZXJsYXBzKHJkZXYtPmRhdGFfb2Zmc2V0LCByZGV2LT5zZWN0b3JzLAotCQkJCQkgICAgICByZGV2Mi0+ZGF0YV9vZmZzZXQsCi0JCQkJCSAgICAgIHJkZXYyLT5zZWN0b3JzKSkpIHsKKwkJCQlpZiAocmRldi0+YmRldiA9PSByZGV2Mi0+YmRldiAmJgorCQkJCSAgICByZGV2ICE9IHJkZXYyICYmCisJCQkJICAgIG92ZXJsYXBzKHJkZXYtPmRhdGFfb2Zmc2V0LCByZGV2LT5zZWN0b3JzLAorCQkJCQkgICAgIHJkZXYyLT5kYXRhX29mZnNldCwKKwkJCQkJICAgICByZGV2Mi0+c2VjdG9ycykpIHsKIAkJCQkJb3ZlcmxhcCA9IDE7CiAJCQkJCWJyZWFrOwogCQkJCX0KQEAgLTMxMDcsNyArMzEyNCw3IEBACiAJCWNoYXIgbm1bMjBdOwogCQlpZiAocmRldi0+cmFpZF9kaXNrIDwgMCkKIAkJCWNvbnRpbnVlOwotCQlpZiAocmRldi0+bmV3X3JhaWRfZGlzayA+IG1kZGV2LT5yYWlkX2Rpc2tzKQorCQlpZiAocmRldi0+bmV3X3JhaWRfZGlzayA+PSBtZGRldi0+cmFpZF9kaXNrcykKIAkJCXJkZXYtPm5ld19yYWlkX2Rpc2sgPSAtMTsKIAkJaWYgKHJkZXYtPm5ld19yYWlkX2Rpc2sgPT0gcmRldi0+cmFpZF9kaXNrKQogCQkJY29udGludWU7CkBAIC0zNzM2LDYgKzM3NTMsOCBAQAogCXJldHVybiBzcHJpbnRmKHBhZ2UsICIlc1xuIiwgdHlwZSk7CiB9CiAKK3N0YXRpYyB2b2lkIHJlYXBfc3luY190aHJlYWQobWRkZXZfdCAqbWRkZXYpOworCiBzdGF0aWMgc3NpemVfdAogYWN0aW9uX3N0b3JlKG1kZGV2X3QgKm1kZGV2LCBjb25zdCBjaGFyICpwYWdlLCBzaXplX3QgbGVuKQogewpAQCAtMzc1MCw5ICszNzY5LDcgQEAKIAlpZiAoY21kX21hdGNoKHBhZ2UsICJpZGxlIikgfHwgY21kX21hdGNoKHBhZ2UsICJmcm96ZW4iKSkgewogCQlpZiAobWRkZXYtPnN5bmNfdGhyZWFkKSB7CiAJCQlzZXRfYml0KE1EX1JFQ09WRVJZX0lOVFIsICZtZGRldi0+cmVjb3ZlcnkpOwotCQkJbWRfdW5yZWdpc3Rlcl90aHJlYWQobWRkZXYtPnN5bmNfdGhyZWFkKTsKLQkJCW1kZGV2LT5zeW5jX3RocmVhZCA9IE5VTEw7Ci0JCQltZGRldi0+cmVjb3ZlcnkgPSAwOworCQkJcmVhcF9zeW5jX3RocmVhZChtZGRldik7CiAJCX0KIAl9IGVsc2UgaWYgKHRlc3RfYml0KE1EX1JFQ09WRVJZX1JVTk5JTkcsICZtZGRldi0+cmVjb3ZlcnkpIHx8CiAJCSAgIHRlc3RfYml0KE1EX1JFQ09WRVJZX05FRURFRCwgJm1kZGV2LT5yZWNvdmVyeSkpCkBAIC0zOTA0LDcgKzM5MjEsNyBAQAogc3RhdGljIHNzaXplX3QKIHN5bmNfY29tcGxldGVkX3Nob3cobWRkZXZfdCAqbWRkZXYsIGNoYXIgKnBhZ2UpCiB7Ci0JdW5zaWduZWQgbG9uZyBtYXhfc2VjdG9ycywgcmVzeW5jOworCXVuc2lnbmVkIGxvbmcgbG9uZyBtYXhfc2VjdG9ycywgcmVzeW5jOwogCiAJaWYgKCF0ZXN0X2JpdChNRF9SRUNPVkVSWV9SVU5OSU5HLCAmbWRkZXYtPnJlY292ZXJ5KSkKIAkJcmV0dXJuIHNwcmludGYocGFnZSwgIm5vbmVcbiIpOwpAQCAtMzkxNSw3ICszOTMyLDcgQEAKIAkJbWF4X3NlY3RvcnMgPSBtZGRldi0+ZGV2X3NlY3RvcnM7CiAKIAlyZXN5bmMgPSBtZGRldi0+Y3Vycl9yZXN5bmNfY29tcGxldGVkOwotCXJldHVybiBzcHJpbnRmKHBhZ2UsICIlbHUgLyAlbHVcbiIsIHJlc3luYywgbWF4X3NlY3RvcnMpOworCXJldHVybiBzcHJpbnRmKHBhZ2UsICIlbGx1IC8gJWxsdVxuIiwgcmVzeW5jLCBtYXhfc2VjdG9ycyk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgbWRfc3lzZnNfZW50cnkgbWRfc3luY19jb21wbGV0ZWQgPSBfX0FUVFJfUk8oc3luY19jb21wbGV0ZWQpOwpAQCAtNDAwMiwxOSArNDAxOSwyNCBAQAogewogCWNoYXIgKmU7CiAJdW5zaWduZWQgbG9uZyBsb25nIG5ldyA9IHNpbXBsZV9zdHJ0b3VsbChidWYsICZlLCAxMCk7CisJdW5zaWduZWQgbG9uZyBsb25nIG9sZCA9IG1kZGV2LT5zdXNwZW5kX2xvOwogCiAJaWYgKG1kZGV2LT5wZXJzID09IE5VTEwgfHwgCiAJICAgIG1kZGV2LT5wZXJzLT5xdWllc2NlID09IE5VTEwpCiAJCXJldHVybiAtRUlOVkFMOwogCWlmIChidWYgPT0gZSB8fCAoKmUgJiYgKmUgIT0gJ1xuJykpCiAJCXJldHVybiAtRUlOVkFMOwotCWlmIChuZXcgPj0gbWRkZXYtPnN1c3BlbmRfaGkgfHwKLQkgICAgKG5ldyA+IG1kZGV2LT5zdXNwZW5kX2xvICYmIG5ldyA8IG1kZGV2LT5zdXNwZW5kX2hpKSkgewotCQltZGRldi0+c3VzcGVuZF9sbyA9IG5ldzsKKworCW1kZGV2LT5zdXNwZW5kX2xvID0gbmV3OworCWlmIChuZXcgPj0gb2xkKQorCQkvKiBTaHJpbmtpbmcgc3VzcGVuZGVkIHJlZ2lvbiAqLwogCQltZGRldi0+cGVycy0+cXVpZXNjZShtZGRldiwgMik7Ci0JCXJldHVybiBsZW47Ci0JfSBlbHNlCi0JCXJldHVybiAtRUlOVkFMOworCWVsc2UgeworCQkvKiBFeHBhbmRpbmcgc3VzcGVuZGVkIHJlZ2lvbiAtIG5lZWQgdG8gd2FpdCAqLworCQltZGRldi0+cGVycy0+cXVpZXNjZShtZGRldiwgMSk7CisJCW1kZGV2LT5wZXJzLT5xdWllc2NlKG1kZGV2LCAwKTsKKwl9CisJcmV0dXJuIGxlbjsKIH0KIHN0YXRpYyBzdHJ1Y3QgbWRfc3lzZnNfZW50cnkgbWRfc3VzcGVuZF9sbyA9CiBfX0FUVFIoc3VzcGVuZF9sbywgU19JUlVHT3xTX0lXVVNSLCBzdXNwZW5kX2xvX3Nob3csIHN1c3BlbmRfbG9fc3RvcmUpOwpAQCAtNDAzMSwyMCArNDA1MywyNCBAQAogewogCWNoYXIgKmU7CiAJdW5zaWduZWQgbG9uZyBsb25nIG5ldyA9IHNpbXBsZV9zdHJ0b3VsbChidWYsICZlLCAxMCk7CisJdW5zaWduZWQgbG9uZyBsb25nIG9sZCA9IG1kZGV2LT5zdXNwZW5kX2hpOwogCiAJaWYgKG1kZGV2LT5wZXJzID09IE5VTEwgfHwKIAkgICAgbWRkZXYtPnBlcnMtPnF1aWVzY2UgPT0gTlVMTCkKIAkJcmV0dXJuIC1FSU5WQUw7CiAJaWYgKGJ1ZiA9PSBlIHx8ICgqZSAmJiAqZSAhPSAnXG4nKSkKIAkJcmV0dXJuIC1FSU5WQUw7Ci0JaWYgKChuZXcgPD0gbWRkZXYtPnN1c3BlbmRfbG8gJiYgbWRkZXYtPnN1c3BlbmRfbG8gPj0gbWRkZXYtPnN1c3BlbmRfaGkpIHx8Ci0JICAgIChuZXcgPiBtZGRldi0+c3VzcGVuZF9sbyAmJiBuZXcgPiBtZGRldi0+c3VzcGVuZF9oaSkpIHsKLQkJbWRkZXYtPnN1c3BlbmRfaGkgPSBuZXc7CisKKwltZGRldi0+c3VzcGVuZF9oaSA9IG5ldzsKKwlpZiAobmV3IDw9IG9sZCkKKwkJLyogU2hyaW5raW5nIHN1c3BlbmRlZCByZWdpb24gKi8KKwkJbWRkZXYtPnBlcnMtPnF1aWVzY2UobWRkZXYsIDIpOworCWVsc2UgeworCQkvKiBFeHBhbmRpbmcgc3VzcGVuZGVkIHJlZ2lvbiAtIG5lZWQgdG8gd2FpdCAqLwogCQltZGRldi0+cGVycy0+cXVpZXNjZShtZGRldiwgMSk7CiAJCW1kZGV2LT5wZXJzLT5xdWllc2NlKG1kZGV2LCAwKTsKLQkJcmV0dXJuIGxlbjsKLQl9IGVsc2UKLQkJcmV0dXJuIC1FSU5WQUw7CisJfQorCXJldHVybiBsZW47CiB9CiBzdGF0aWMgc3RydWN0IG1kX3N5c2ZzX2VudHJ5IG1kX3N1c3BlbmRfaGkgPQogX19BVFRSKHN1c3BlbmRfaGksIFNfSVJVR098U19JV1VTUiwgc3VzcGVuZF9oaV9zaG93LCBzdXNwZW5kX2hpX3N0b3JlKTsKQEAgLTQ0MjIsNyArNDQ0OCw5IEBACiAJCSAqIFdlIGRvbid0IHdhbnQgdGhlIGRhdGEgdG8gb3ZlcmxhcCB0aGUgbWV0YWRhdGEsCiAJCSAqIEludGVybmFsIEJpdG1hcCBpc3N1ZXMgaGF2ZSBiZWVuIGhhbmRsZWQgZWxzZXdoZXJlLgogCQkgKi8KLQkJaWYgKHJkZXYtPmRhdGFfb2Zmc2V0IDwgcmRldi0+c2Jfc3RhcnQpIHsKKwkJaWYgKHJkZXYtPm1ldGFfYmRldikgeworCQkJLyogTm90aGluZyB0byBjaGVjayAqLzsKKwkJfSBlbHNlIGlmIChyZGV2LT5kYXRhX29mZnNldCA8IHJkZXYtPnNiX3N0YXJ0KSB7CiAJCQlpZiAobWRkZXYtPmRldl9zZWN0b3JzICYmCiAJCQkgICAgcmRldi0+ZGF0YV9vZmZzZXQgKyBtZGRldi0+ZGV2X3NlY3RvcnMKIAkJCSAgICA+IHJkZXYtPnNiX3N0YXJ0KSB7CkBAIC00NTU2LDcgKzQ1ODQsOCBAQAogCW1kZGV2LT5zYWZlbW9kZV90aW1lci5kYXRhID0gKHVuc2lnbmVkIGxvbmcpIG1kZGV2OwogCW1kZGV2LT5zYWZlbW9kZV9kZWxheSA9ICgyMDAgKiBIWikvMTAwMCArMTsgLyogMjAwIG1zZWMgZGVsYXkgKi8KIAltZGRldi0+aW5fc3luYyA9IDE7Ci0KKwlzbXBfd21iKCk7CisJbWRkZXYtPnJlYWR5ID0gMTsKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KHJkZXYsICZtZGRldi0+ZGlza3MsIHNhbWVfc2V0KQogCQlpZiAocmRldi0+cmFpZF9kaXNrID49IDApIHsKIAkJCWNoYXIgbm1bMjBdOwpAQCAtNDY5MywxMyArNDcyMiwxMiBAQAogCW1kZGV2LT5wbHVnID0gTlVMTDsKIH0KIAotdm9pZCBtZF9zdG9wX3dyaXRlcyhtZGRldl90ICptZGRldikKK3N0YXRpYyB2b2lkIF9fbWRfc3RvcF93cml0ZXMobWRkZXZfdCAqbWRkZXYpCiB7CiAJaWYgKG1kZGV2LT5zeW5jX3RocmVhZCkgewogCQlzZXRfYml0KE1EX1JFQ09WRVJZX0ZST1pFTiwgJm1kZGV2LT5yZWNvdmVyeSk7CiAJCXNldF9iaXQoTURfUkVDT1ZFUllfSU5UUiwgJm1kZGV2LT5yZWNvdmVyeSk7Ci0JCW1kX3VucmVnaXN0ZXJfdGhyZWFkKG1kZGV2LT5zeW5jX3RocmVhZCk7Ci0JCW1kZGV2LT5zeW5jX3RocmVhZCA9IE5VTEw7CisJCXJlYXBfc3luY190aHJlYWQobWRkZXYpOwogCX0KIAogCWRlbF90aW1lcl9zeW5jKCZtZGRldi0+c2FmZW1vZGVfdGltZXIpOwpAQCAtNDcxMywxMCArNDc0MSwxOCBAQAogCQltZF91cGRhdGVfc2IobWRkZXYsIDEpOwogCX0KIH0KKwordm9pZCBtZF9zdG9wX3dyaXRlcyhtZGRldl90ICptZGRldikKK3sKKwltZGRldl9sb2NrKG1kZGV2KTsKKwlfX21kX3N0b3Bfd3JpdGVzKG1kZGV2KTsKKwltZGRldl91bmxvY2sobWRkZXYpOworfQogRVhQT1JUX1NZTUJPTF9HUEwobWRfc3RvcF93cml0ZXMpOwogCiB2b2lkIG1kX3N0b3AobWRkZXZfdCAqbWRkZXYpCiB7CisJbWRkZXYtPnJlYWR5ID0gMDsKIAltZGRldi0+cGVycy0+c3RvcChtZGRldik7CiAJaWYgKG1kZGV2LT5wZXJzLT5zeW5jX3JlcXVlc3QgJiYgbWRkZXYtPnRvX3JlbW92ZSA9PSBOVUxMKQogCQltZGRldi0+dG9fcmVtb3ZlID0gJm1kX3JlZHVuZGFuY3lfZ3JvdXA7CkBAIC00NzM2LDcgKzQ3NzIsNyBAQAogCQlnb3RvIG91dDsKIAl9CiAJaWYgKG1kZGV2LT5wZXJzKSB7Ci0JCW1kX3N0b3Bfd3JpdGVzKG1kZGV2KTsKKwkJX19tZF9zdG9wX3dyaXRlcyhtZGRldik7CiAKIAkJZXJyICA9IC1FTlhJTzsKIAkJaWYgKG1kZGV2LT5ybz09MSkKQEAgLTQ3NzMsNyArNDgwOSw3IEBACiAJCWlmIChtZGRldi0+cm8pCiAJCQlzZXRfZGlza19ybyhkaXNrLCAwKTsKIAotCQltZF9zdG9wX3dyaXRlcyhtZGRldik7CisJCV9fbWRfc3RvcF93cml0ZXMobWRkZXYpOwogCQltZF9zdG9wKG1kZGV2KTsKIAkJbWRkZXYtPnF1ZXVlLT5tZXJnZV9idmVjX2ZuID0gTlVMTDsKIAkJbWRkZXYtPnF1ZXVlLT51bnBsdWdfZm4gPSBOVUxMOwpAQCAtNTE1MSw5ICs1MTg3LDEwIEBACiAJCS8qIHNldCBzYXZlZF9yYWlkX2Rpc2sgaWYgYXBwcm9wcmlhdGUgKi8KIAkJaWYgKCFtZGRldi0+cGVyc2lzdGVudCkgewogCQkJaWYgKGluZm8tPnN0YXRlICYgKDE8PE1EX0RJU0tfU1lOQykgICYmCi0JCQkgICAgaW5mby0+cmFpZF9kaXNrIDwgbWRkZXYtPnJhaWRfZGlza3MpCisJCQkgICAgaW5mby0+cmFpZF9kaXNrIDwgbWRkZXYtPnJhaWRfZGlza3MpIHsKIAkJCQlyZGV2LT5yYWlkX2Rpc2sgPSBpbmZvLT5yYWlkX2Rpc2s7Ci0JCQllbHNlCisJCQkJc2V0X2JpdChJbl9zeW5jLCAmcmRldi0+ZmxhZ3MpOworCQkJfSBlbHNlCiAJCQkJcmRldi0+cmFpZF9kaXNrID0gLTE7CiAJCX0gZWxzZQogCQkJc3VwZXJfdHlwZXNbbWRkZXYtPm1ham9yX3ZlcnNpb25dLgpAQCAtNTIzMCw3ICs1MjY3LDcgQEAKIAkJCXByaW50ayhLRVJOX0lORk8gIm1kOiBub25wZXJzaXN0ZW50IHN1cGVyYmxvY2sgLi4uXG4iKTsKIAkJCXJkZXYtPnNiX3N0YXJ0ID0gaV9zaXplX3JlYWQocmRldi0+YmRldi0+YmRfaW5vZGUpIC8gNTEyOwogCQl9IGVsc2UKLQkJCXJkZXYtPnNiX3N0YXJ0ID0gY2FsY19kZXZfc2JvZmZzZXQocmRldi0+YmRldik7CisJCQlyZGV2LT5zYl9zdGFydCA9IGNhbGNfZGV2X3Nib2Zmc2V0KHJkZXYpOwogCQlyZGV2LT5zZWN0b3JzID0gcmRldi0+c2Jfc3RhcnQ7CiAKIAkJZXJyID0gYmluZF9yZGV2X3RvX2FycmF5KHJkZXYsIG1kZGV2KTsKQEAgLTUyOTcsNyArNTMzNCw3IEBACiAJfQogCiAJaWYgKG1kZGV2LT5wZXJzaXN0ZW50KQotCQlyZGV2LT5zYl9zdGFydCA9IGNhbGNfZGV2X3Nib2Zmc2V0KHJkZXYtPmJkZXYpOworCQlyZGV2LT5zYl9zdGFydCA9IGNhbGNfZGV2X3Nib2Zmc2V0KHJkZXYpOwogCWVsc2UKIAkJcmRldi0+c2Jfc3RhcnQgPSBpX3NpemVfcmVhZChyZGV2LT5iZGV2LT5iZF9pbm9kZSkgLyA1MTI7CiAKQEAgLTU1MTAsNyArNTU0Nyw2IEBACiAJICogc2Jfc3RhcnQgb3IsIGlmIHRoYXQgaXMgPGRhdGFfb2Zmc2V0LCBpdCBtdXN0IGZpdCBiZWZvcmUgdGhlIHNpemUKIAkgKiBvZiBlYWNoIGRldmljZS4gIElmIG51bV9zZWN0b3JzIGlzIHplcm8sIHdlIGZpbmQgdGhlIGxhcmdlc3Qgc2l6ZQogCSAqIHRoYXQgZml0cy4KLQogCSAqLwogCWlmIChtZGRldi0+c3luY190aHJlYWQpCiAJCXJldHVybiAtRUJVU1k7CkBAIC01NTQ3LDYgKzU1ODMsOCBAQAogCW1kZGV2LT5kZWx0YV9kaXNrcyA9IHJhaWRfZGlza3MgLSBtZGRldi0+cmFpZF9kaXNrczsKIAogCXJ2ID0gbWRkZXYtPnBlcnMtPmNoZWNrX3Jlc2hhcGUobWRkZXYpOworCWlmIChydiA8IDApCisJCW1kZGV2LT5kZWx0YV9kaXNrcyA9IDA7CiAJcmV0dXJuIHJ2OwogfQogCkBAIC02MDMzLDcgKzYwNzEsOCBAQAogCQkJIHx8IGt0aHJlYWRfc2hvdWxkX3N0b3AoKSwKIAkJCSB0aHJlYWQtPnRpbWVvdXQpOwogCi0JCWlmICh0ZXN0X2FuZF9jbGVhcl9iaXQoVEhSRUFEX1dBS0VVUCwgJnRocmVhZC0+ZmxhZ3MpKQorCQljbGVhcl9iaXQoVEhSRUFEX1dBS0VVUCwgJnRocmVhZC0+ZmxhZ3MpOworCQlpZiAoIWt0aHJlYWRfc2hvdWxkX3N0b3AoKSkKIAkJCXRocmVhZC0+cnVuKHRocmVhZC0+bWRkZXYpOwogCX0KIApAQCAtNjc5OSw3ICs2ODM4LDcgQEAKIAkJICAgICAgIGRlc2MsIG1kbmFtZShtZGRldikpOwogCQltZGRldi0+Y3Vycl9yZXN5bmMgPSBqOwogCX0KLQltZGRldi0+Y3Vycl9yZXN5bmNfY29tcGxldGVkID0gbWRkZXYtPmN1cnJfcmVzeW5jOworCW1kZGV2LT5jdXJyX3Jlc3luY19jb21wbGV0ZWQgPSBqOwogCiAJd2hpbGUgKGogPCBtYXhfc2VjdG9ycykgewogCQlzZWN0b3JfdCBzZWN0b3JzOwpAQCAtNjgxNyw4ICs2ODU2LDcgQEAKIAkJCW1kX3VucGx1ZyhtZGRldik7CiAJCQl3YWl0X2V2ZW50KG1kZGV2LT5yZWNvdmVyeV93YWl0LAogCQkJCSAgIGF0b21pY19yZWFkKCZtZGRldi0+cmVjb3ZlcnlfYWN0aXZlKSA9PSAwKTsKLQkJCW1kZGV2LT5jdXJyX3Jlc3luY19jb21wbGV0ZWQgPQotCQkJCW1kZGV2LT5jdXJyX3Jlc3luYzsKKwkJCW1kZGV2LT5jdXJyX3Jlc3luY19jb21wbGV0ZWQgPSBqOwogCQkJc2V0X2JpdChNRF9DSEFOR0VfQ0xFQU4sICZtZGRldi0+ZmxhZ3MpOwogCQkJc3lzZnNfbm90aWZ5KCZtZGRldi0+a29iaiwgTlVMTCwgInN5bmNfY29tcGxldGVkIik7CiAJCX0KQEAgLTY5NTQsOSArNjk5Miw2IEBACiAJfSBlbHNlIGlmICh0ZXN0X2JpdChNRF9SRUNPVkVSWV9SRVFVRVNURUQsICZtZGRldi0+cmVjb3ZlcnkpKQogCQltZGRldi0+cmVzeW5jX21pbiA9IG1kZGV2LT5jdXJyX3Jlc3luY19jb21wbGV0ZWQ7CiAJbWRkZXYtPmN1cnJfcmVzeW5jID0gMDsKLQlpZiAoIXRlc3RfYml0KE1EX1JFQ09WRVJZX0lOVFIsICZtZGRldi0+cmVjb3ZlcnkpKQotCQltZGRldi0+Y3Vycl9yZXN5bmNfY29tcGxldGVkID0gMDsKLQlzeXNmc19ub3RpZnkoJm1kZGV2LT5rb2JqLCBOVUxMLCAic3luY19jb21wbGV0ZWQiKTsKIAl3YWtlX3VwKCZyZXN5bmNfd2FpdCk7CiAJc2V0X2JpdChNRF9SRUNPVkVSWV9ET05FLCAmbWRkZXYtPnJlY292ZXJ5KTsKIAltZF93YWtldXBfdGhyZWFkKG1kZGV2LT50aHJlYWQpOwpAQCAtNjk5Nyw3ICs3MDMyLDcgQEAKIAkJCX0KIAkJfQogCi0JaWYgKG1kZGV2LT5kZWdyYWRlZCAmJiAhIG1kZGV2LT5ybyAmJiAhbWRkZXYtPnJlY292ZXJ5X2Rpc2FibGVkKSB7CisJaWYgKG1kZGV2LT5kZWdyYWRlZCAmJiAhbWRkZXYtPnJlY292ZXJ5X2Rpc2FibGVkKSB7CiAJCWxpc3RfZm9yX2VhY2hfZW50cnkocmRldiwgJm1kZGV2LT5kaXNrcywgc2FtZV9zZXQpIHsKIAkJCWlmIChyZGV2LT5yYWlkX2Rpc2sgPj0gMCAmJgogCQkJICAgICF0ZXN0X2JpdChJbl9zeW5jLCAmcmRldi0+ZmxhZ3MpICYmCkBAIC03MDIzLDYgKzcwNTgsNDUgQEAKIAl9CiAJcmV0dXJuIHNwYXJlczsKIH0KKworc3RhdGljIHZvaWQgcmVhcF9zeW5jX3RocmVhZChtZGRldl90ICptZGRldikKK3sKKwltZGtfcmRldl90ICpyZGV2OworCisJLyogcmVzeW5jIGhhcyBmaW5pc2hlZCwgY29sbGVjdCByZXN1bHQgKi8KKwltZF91bnJlZ2lzdGVyX3RocmVhZChtZGRldi0+c3luY190aHJlYWQpOworCW1kZGV2LT5zeW5jX3RocmVhZCA9IE5VTEw7CisJaWYgKCF0ZXN0X2JpdChNRF9SRUNPVkVSWV9JTlRSLCAmbWRkZXYtPnJlY292ZXJ5KSAmJgorCSAgICAhdGVzdF9iaXQoTURfUkVDT1ZFUllfUkVRVUVTVEVELCAmbWRkZXYtPnJlY292ZXJ5KSkgeworCQkvKiBzdWNjZXNzLi4uKi8KKwkJLyogYWN0aXZhdGUgYW55IHNwYXJlcyAqLworCQlpZiAobWRkZXYtPnBlcnMtPnNwYXJlX2FjdGl2ZShtZGRldikpCisJCQlzeXNmc19ub3RpZnkoJm1kZGV2LT5rb2JqLCBOVUxMLAorCQkJCSAgICAgImRlZ3JhZGVkIik7CisJfQorCWlmICh0ZXN0X2JpdChNRF9SRUNPVkVSWV9SRVNIQVBFLCAmbWRkZXYtPnJlY292ZXJ5KSAmJgorCSAgICBtZGRldi0+cGVycy0+ZmluaXNoX3Jlc2hhcGUpCisJCW1kZGV2LT5wZXJzLT5maW5pc2hfcmVzaGFwZShtZGRldik7CisJbWRfdXBkYXRlX3NiKG1kZGV2LCAxKTsKKworCS8qIGlmIGFycmF5IGlzIG5vLWxvbmdlciBkZWdyYWRlZCwgdGhlbiBhbnkgc2F2ZWRfcmFpZF9kaXNrCisJICogaW5mb3JtYXRpb24gbXVzdCBiZSBzY3JhcHBlZAorCSAqLworCWlmICghbWRkZXYtPmRlZ3JhZGVkKQorCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHJkZXYsICZtZGRldi0+ZGlza3MsIHNhbWVfc2V0KQorCQkJcmRldi0+c2F2ZWRfcmFpZF9kaXNrID0gLTE7CisKKwljbGVhcl9iaXQoTURfUkVDT1ZFUllfUlVOTklORywgJm1kZGV2LT5yZWNvdmVyeSk7CisJY2xlYXJfYml0KE1EX1JFQ09WRVJZX1NZTkMsICZtZGRldi0+cmVjb3ZlcnkpOworCWNsZWFyX2JpdChNRF9SRUNPVkVSWV9SRVNIQVBFLCAmbWRkZXYtPnJlY292ZXJ5KTsKKwljbGVhcl9iaXQoTURfUkVDT1ZFUllfUkVRVUVTVEVELCAmbWRkZXYtPnJlY292ZXJ5KTsKKwljbGVhcl9iaXQoTURfUkVDT1ZFUllfQ0hFQ0ssICZtZGRldi0+cmVjb3ZlcnkpOworCS8qIGZsYWcgcmVjb3ZlcnkgbmVlZGVkIGp1c3QgdG8gZG91YmxlIGNoZWNrICovCisJc2V0X2JpdChNRF9SRUNPVkVSWV9ORUVERUQsICZtZGRldi0+cmVjb3ZlcnkpOworCXN5c2ZzX25vdGlmeV9kaXJlbnRfc2FmZShtZGRldi0+c3lzZnNfYWN0aW9uKTsKKwltZF9uZXdfZXZlbnQobWRkZXYpOworfQorCiAvKgogICogVGhpcyByb3V0aW5lIGlzIHJlZ3VsYXJseSBjYWxsZWQgYnkgYWxsIHBlci1yYWlkLWFycmF5IHRocmVhZHMgdG8KICAqIGRlYWwgd2l0aCBnZW5lcmljIGlzc3VlcyBsaWtlIHJlc3luYyBhbmQgc3VwZXItYmxvY2sgdXBkYXRlLgpAQCAtNzA0Nyw5ICs3MTIxLDYgQEAKICAqLwogdm9pZCBtZF9jaGVja19yZWNvdmVyeShtZGRldl90ICptZGRldikKIHsKLQltZGtfcmRldl90ICpyZGV2OwotCi0KIAlpZiAobWRkZXYtPmJpdG1hcCkKIAkJYml0bWFwX2RhZW1vbl93b3JrKG1kZGV2KTsKIApAQCAtNzA4NCw3ICs3MTU1LDIwIEBACiAJCQkvKiBPbmx5IHRoaW5nIHdlIGRvIG9uIGEgcm8gYXJyYXkgaXMgcmVtb3ZlCiAJCQkgKiBmYWlsZWQgZGV2aWNlcy4KIAkJCSAqLwotCQkJcmVtb3ZlX2FuZF9hZGRfc3BhcmVzKG1kZGV2KTsKKwkJCW1ka19yZGV2X3QgKnJkZXY7CisJCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHJkZXYsICZtZGRldi0+ZGlza3MsIHNhbWVfc2V0KQorCQkJCWlmIChyZGV2LT5yYWlkX2Rpc2sgPj0gMCAmJgorCQkJCSAgICAhdGVzdF9iaXQoQmxvY2tlZCwgJnJkZXYtPmZsYWdzKSAmJgorCQkJCSAgICB0ZXN0X2JpdChGYXVsdHksICZyZGV2LT5mbGFncykgJiYKKwkJCQkgICAgYXRvbWljX3JlYWQoJnJkZXYtPm5yX3BlbmRpbmcpPT0wKSB7CisJCQkJCWlmIChtZGRldi0+cGVycy0+aG90X3JlbW92ZV9kaXNrKAorCQkJCQkJICAgIG1kZGV2LCByZGV2LT5yYWlkX2Rpc2spPT0wKSB7CisJCQkJCQljaGFyIG5tWzIwXTsKKwkJCQkJCXNwcmludGYobm0sInJkJWQiLCByZGV2LT5yYWlkX2Rpc2spOworCQkJCQkJc3lzZnNfcmVtb3ZlX2xpbmsoJm1kZGV2LT5rb2JqLCBubSk7CisJCQkJCQlyZGV2LT5yYWlkX2Rpc2sgPSAtMTsKKwkJCQkJfQorCQkJCX0KIAkJCWNsZWFyX2JpdChNRF9SRUNPVkVSWV9ORUVERUQsICZtZGRldi0+cmVjb3ZlcnkpOwogCQkJZ290byB1bmxvY2s7CiAJCX0KQEAgLTcxMTcsMzQgKzcyMDEsNyBAQAogCQkJZ290byB1bmxvY2s7CiAJCX0KIAkJaWYgKG1kZGV2LT5zeW5jX3RocmVhZCkgewotCQkJLyogcmVzeW5jIGhhcyBmaW5pc2hlZCwgY29sbGVjdCByZXN1bHQgKi8KLQkJCW1kX3VucmVnaXN0ZXJfdGhyZWFkKG1kZGV2LT5zeW5jX3RocmVhZCk7Ci0JCQltZGRldi0+c3luY190aHJlYWQgPSBOVUxMOwotCQkJaWYgKCF0ZXN0X2JpdChNRF9SRUNPVkVSWV9JTlRSLCAmbWRkZXYtPnJlY292ZXJ5KSAmJgotCQkJICAgICF0ZXN0X2JpdChNRF9SRUNPVkVSWV9SRVFVRVNURUQsICZtZGRldi0+cmVjb3ZlcnkpKSB7Ci0JCQkJLyogc3VjY2Vzcy4uLiovCi0JCQkJLyogYWN0aXZhdGUgYW55IHNwYXJlcyAqLwotCQkJCWlmIChtZGRldi0+cGVycy0+c3BhcmVfYWN0aXZlKG1kZGV2KSkKLQkJCQkJc3lzZnNfbm90aWZ5KCZtZGRldi0+a29iaiwgTlVMTCwKLQkJCQkJCSAgICAgImRlZ3JhZGVkIik7Ci0JCQl9Ci0JCQlpZiAodGVzdF9iaXQoTURfUkVDT1ZFUllfUkVTSEFQRSwgJm1kZGV2LT5yZWNvdmVyeSkgJiYKLQkJCSAgICBtZGRldi0+cGVycy0+ZmluaXNoX3Jlc2hhcGUpCi0JCQkJbWRkZXYtPnBlcnMtPmZpbmlzaF9yZXNoYXBlKG1kZGV2KTsKLQkJCW1kX3VwZGF0ZV9zYihtZGRldiwgMSk7Ci0KLQkJCS8qIGlmIGFycmF5IGlzIG5vLWxvbmdlciBkZWdyYWRlZCwgdGhlbiBhbnkgc2F2ZWRfcmFpZF9kaXNrCi0JCQkgKiBpbmZvcm1hdGlvbiBtdXN0IGJlIHNjcmFwcGVkCi0JCQkgKi8KLQkJCWlmICghbWRkZXYtPmRlZ3JhZGVkKQotCQkJCWxpc3RfZm9yX2VhY2hfZW50cnkocmRldiwgJm1kZGV2LT5kaXNrcywgc2FtZV9zZXQpCi0JCQkJCXJkZXYtPnNhdmVkX3JhaWRfZGlzayA9IC0xOwotCi0JCQltZGRldi0+cmVjb3ZlcnkgPSAwOwotCQkJLyogZmxhZyByZWNvdmVyeSBuZWVkZWQganVzdCB0byBkb3VibGUgY2hlY2sgKi8KLQkJCXNldF9iaXQoTURfUkVDT1ZFUllfTkVFREVELCAmbWRkZXYtPnJlY292ZXJ5KTsKLQkJCXN5c2ZzX25vdGlmeV9kaXJlbnRfc2FmZShtZGRldi0+c3lzZnNfYWN0aW9uKTsKLQkJCW1kX25ld19ldmVudChtZGRldik7CisJCQlyZWFwX3N5bmNfdGhyZWFkKG1kZGV2KTsKIAkJCWdvdG8gdW5sb2NrOwogCQl9CiAJCS8qIFNldCBSVU5OSU5HIGJlZm9yZSBjbGVhcmluZyBORUVERUQgdG8gYXZvaWQKQEAgLTcyMDIsNyArNzI1OSwxMSBAQAogCQkJCQkiIHRocmVhZC4uLlxuIiwgCiAJCQkJCW1kbmFtZShtZGRldikpOwogCQkJCS8qIGxlYXZlIHRoZSBzcGFyZXMgd2hlcmUgdGhleSBhcmUsIGl0IHNob3VsZG4ndCBodXJ0ICovCi0JCQkJbWRkZXYtPnJlY292ZXJ5ID0gMDsKKwkJCQljbGVhcl9iaXQoTURfUkVDT1ZFUllfUlVOTklORywgJm1kZGV2LT5yZWNvdmVyeSk7CisJCQkJY2xlYXJfYml0KE1EX1JFQ09WRVJZX1NZTkMsICZtZGRldi0+cmVjb3ZlcnkpOworCQkJCWNsZWFyX2JpdChNRF9SRUNPVkVSWV9SRVNIQVBFLCAmbWRkZXYtPnJlY292ZXJ5KTsKKwkJCQljbGVhcl9iaXQoTURfUkVDT1ZFUllfUkVRVUVTVEVELCAmbWRkZXYtPnJlY292ZXJ5KTsKKwkJCQljbGVhcl9iaXQoTURfUkVDT1ZFUllfQ0hFQ0ssICZtZGRldi0+cmVjb3ZlcnkpOwogCQkJfSBlbHNlCiAJCQkJbWRfd2FrZXVwX3RocmVhZChtZGRldi0+c3luY190aHJlYWQpOwogCQkJc3lzZnNfbm90aWZ5X2RpcmVudF9zYWZlKG1kZGV2LT5zeXNmc19hY3Rpb24pOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9tZC5oIGIvZHJpdmVycy9tZC9tZC5oCmluZGV4IGQwNWJhYjUuLjdlOTBiODUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvbWQuaAorKysgYi9kcml2ZXJzL21kL21kLmgKQEAgLTYwLDYgKzYwLDEyIEBACiAJbWRkZXZfdCAqbWRkZXY7CQkJLyogUkFJRCBhcnJheSBpZiBydW5uaW5nICovCiAJaW50IGxhc3RfZXZlbnRzOwkJLyogSU8gZXZlbnQgdGltZXN0YW1wICovCiAKKwkvKgorCSAqIElmIG1ldGFfYmRldiBpcyBub24tTlVMTCwgaXQgbWVhbnMgdGhhdCBhIHNlcGFyYXRlIGRldmljZSBpcworCSAqIGJlaW5nIHVzZWQgdG8gc3RvcmUgdGhlIG1ldGFkYXRhIChzdXBlcmJsb2NrL2JpdG1hcCkgd2hpY2gKKwkgKiB3b3VsZCBvdGhlcndpc2UgYmUgY29udGFpbmVkIG9uIHRoZSBzYW1lIGRldmljZSBhcyB0aGUgZGF0YSAoYmRldikuCisJICovCisJc3RydWN0IGJsb2NrX2RldmljZSAqbWV0YV9iZGV2OwogCXN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXY7CS8qIGJsb2NrIGRldmljZSBoYW5kbGUgKi8KIAogCXN0cnVjdCBwYWdlCSpzYl9wYWdlOwpAQCAtODcsOCArOTMsNiBAQAogI2RlZmluZQlGYXVsdHkJCTEJCS8qIGRldmljZSBpcyBrbm93biB0byBoYXZlIGEgZmF1bHQgKi8KICNkZWZpbmUJSW5fc3luYwkJMgkJLyogZGV2aWNlIGlzIGluX3N5bmMgd2l0aCByZXN0IG9mIGFycmF5ICovCiAjZGVmaW5lCVdyaXRlTW9zdGx5CTQJCS8qIEF2b2lkIHJlYWRpbmcgaWYgYXQgYWxsIHBvc3NpYmxlICovCi0jZGVmaW5lCUFsbFJlc2VydmVkCTYJCS8qIElmIHdob2xlIGRldmljZSBpcyByZXNlcnZlZCBmb3IKLQkJCQkJICogb25lIGFycmF5ICovCiAjZGVmaW5lCUF1dG9EZXRlY3RlZAk3CQkvKiBhZGRlZCBieSBhdXRvLWRldGVjdCAqLwogI2RlZmluZSBCbG9ja2VkCQk4CQkvKiBBbiBlcnJvciBvY2N1cmVkIG9uIGFuIGV4dGVybmFsbHkKIAkJCQkJICogbWFuYWdlZCBhcnJheSwgZG9uJ3QgYWxsb3cgd3JpdGVzCkBAIC0xNDgsNyArMTUyLDggQEAKIAkJCQkJCSAgICAgICAqIGFyZSBoYXBwZW5pbmcsIHNvIHJ1bi8KIAkJCQkJCSAgICAgICAqIHRha2VvdmVyL3N0b3AgYXJlIG5vdCBzYWZlCiAJCQkJCQkgICAgICAgKi8KLQorCWludAkJCQlyZWFkeTsgLyogU2VlIHdoZW4gc2FmZSB0byBwYXNzIAorCQkJCQkJKiBJTyByZXF1ZXN0cyBkb3duICovCiAJc3RydWN0IGdlbmRpc2sJCQkqZ2VuZGlzazsKIAogCXN0cnVjdCBrb2JqZWN0CQkJa29iajsKQEAgLTQ5Nyw4ICs1MDIsOCBAQAogZXh0ZXJuIHZvaWQgbWRfc3VwZXJfd3JpdGUobWRkZXZfdCAqbWRkZXYsIG1ka19yZGV2X3QgKnJkZXYsCiAJCQkgICBzZWN0b3JfdCBzZWN0b3IsIGludCBzaXplLCBzdHJ1Y3QgcGFnZSAqcGFnZSk7CiBleHRlcm4gdm9pZCBtZF9zdXBlcl93YWl0KG1kZGV2X3QgKm1kZGV2KTsKLWV4dGVybiBpbnQgc3luY19wYWdlX2lvKG1ka19yZGV2X3QgKnJkZXYsIHNlY3Rvcl90IHNlY3RvciwgaW50IHNpemUsCi0JCQlzdHJ1Y3QgcGFnZSAqcGFnZSwgaW50IHJ3KTsKK2V4dGVybiBpbnQgc3luY19wYWdlX2lvKG1ka19yZGV2X3QgKnJkZXYsIHNlY3Rvcl90IHNlY3RvciwgaW50IHNpemUsIAorCQkJc3RydWN0IHBhZ2UgKnBhZ2UsIGludCBydywgYm9vbCBtZXRhZGF0YV9vcCk7CiBleHRlcm4gdm9pZCBtZF9kb19zeW5jKG1kZGV2X3QgKm1kZGV2KTsKIGV4dGVybiB2b2lkIG1kX25ld19ldmVudChtZGRldl90ICptZGRldik7CiBleHRlcm4gaW50IG1kX2FsbG93X3dyaXRlKG1kZGV2X3QgKm1kZGV2KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvcmFpZDAuYyBiL2RyaXZlcnMvbWQvcmFpZDAuYwppbmRleCBhMzlmNGMzLi42MzdhOTY4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL3JhaWQwLmMKKysrIGIvZHJpdmVycy9tZC9yYWlkMC5jCkBAIC0xNzksNiArMTc5LDE0IEBACiAJCQlyZGV2MS0+bmV3X3JhaWRfZGlzayA9IGo7CiAJCX0KIAorCQlpZiAobWRkZXYtPmxldmVsID09IDEpIHsKKwkJCS8qIHRhaWtpbmcgb3ZlciBhIHJhaWQxIGFycmF5LQorCQkJICogd2UgaGF2ZSBvbmx5IG9uZSBhY3RpdmUgZGlzaworCQkJICovCisJCQlqID0gMDsKKwkJCXJkZXYxLT5uZXdfcmFpZF9kaXNrID0gajsKKwkJfQorCiAJCWlmIChqIDwgMCB8fCBqID49IG1kZGV2LT5yYWlkX2Rpc2tzKSB7CiAJCQlwcmludGsoS0VSTl9FUlIgIm1kL3JhaWQwOiVzOiBiYWQgZGlzayBudW1iZXIgJWQgLSAiCiAJCQkgICAgICAgImFib3J0aW5nIVxuIiwgbWRuYW1lKG1kZGV2KSwgaik7CkBAIC02NDQsMTIgKzY1MiwzOCBAQAogCXJldHVybiBwcml2X2NvbmY7CiB9CiAKK3N0YXRpYyB2b2lkICpyYWlkMF90YWtlb3Zlcl9yYWlkMShtZGRldl90ICptZGRldikKK3sKKwlyYWlkMF9jb25mX3QgKnByaXZfY29uZjsKKworCS8qIENoZWNrIGxheW91dDoKKwkgKiAgLSAoTiAtIDEpIG1pcnJvciBkcml2ZXMgbXVzdCBiZSBhbHJlYWR5IGZhdWx0eQorCSAqLworCWlmICgobWRkZXYtPnJhaWRfZGlza3MgLSAxKSAhPSBtZGRldi0+ZGVncmFkZWQpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJtZC9yYWlkMDolczogKE4gLSAxKSBtaXJyb3JzIGRyaXZlcyBtdXN0IGJlIGFscmVhZHkgZmF1bHR5IVxuIiwKKwkJICAgICAgIG1kbmFtZShtZGRldikpOworCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKKwl9CisKKwkvKiBTZXQgbmV3IHBhcmFtZXRlcnMgKi8KKwltZGRldi0+bmV3X2xldmVsID0gMDsKKwltZGRldi0+bmV3X2xheW91dCA9IDA7CisJbWRkZXYtPm5ld19jaHVua19zZWN0b3JzID0gMTI4OyAvKiBieSBkZWZhdWx0IHNldCBjaHVuayBzaXplIHRvIDY0ayAqLworCW1kZGV2LT5kZWx0YV9kaXNrcyA9IDEgLSBtZGRldi0+cmFpZF9kaXNrczsKKwkvKiBtYWtlIHN1cmUgaXQgd2lsbCBiZSBub3QgbWFya2VkIGFzIGRpcnR5ICovCisJbWRkZXYtPnJlY292ZXJ5X2NwID0gTWF4U2VjdG9yOworCisJY3JlYXRlX3N0cmlwX3pvbmVzKG1kZGV2LCAmcHJpdl9jb25mKTsKKwlyZXR1cm4gcHJpdl9jb25mOworfQorCiBzdGF0aWMgdm9pZCAqcmFpZDBfdGFrZW92ZXIobWRkZXZfdCAqbWRkZXYpCiB7CiAJLyogcmFpZDAgY2FuIHRha2Ugb3ZlcjoKIAkgKiAgcmFpZDQgLSBpZiBhbGwgZGF0YSBkaXNrcyBhcmUgYWN0aXZlLgogCSAqICByYWlkNSAtIHByb3ZpZGluZyBpdCBpcyBSYWlkNCBsYXlvdXQgYW5kIG9uZSBkaXNrIGlzIGZhdWx0eQogCSAqICByYWlkMTAgLSBhc3N1bWluZyB3ZSBoYXZlIGFsbCBuZWNlc3NhcnkgYWN0aXZlIGRpc2tzCisJICogIHJhaWQxIC0gd2l0aCAoTiAtMSkgbWlycm9yIGRyaXZlcyBmYXVsdHkKIAkgKi8KIAlpZiAobWRkZXYtPmxldmVsID09IDQpCiAJCXJldHVybiByYWlkMF90YWtlb3Zlcl9yYWlkNDUobWRkZXYpOwpAQCAtNjY1LDYgKzY5OSwxMiBAQAogCWlmIChtZGRldi0+bGV2ZWwgPT0gMTApCiAJCXJldHVybiByYWlkMF90YWtlb3Zlcl9yYWlkMTAobWRkZXYpOwogCisJaWYgKG1kZGV2LT5sZXZlbCA9PSAxKQorCQlyZXR1cm4gcmFpZDBfdGFrZW92ZXJfcmFpZDEobWRkZXYpOworCisJcHJpbnRrKEtFUk5fRVJSICJUYWtlb3ZlciBmcm9tIHJhaWQlaSB0byByYWlkMCBub3Qgc3VwcG9ydGVkXG4iLAorCQltZGRldi0+bGV2ZWwpOworCiAJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvcmFpZDEuYyBiL2RyaXZlcnMvbWQvcmFpZDEuYwppbmRleCA4NDVjZjk1Li5hMjNmZmEzIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL3JhaWQxLmMKKysrIGIvZHJpdmVycy9tZC9yYWlkMS5jCkBAIC0xMDI3LDggKzEwMjcsOSBAQAogCX0gZWxzZQogCQlzZXRfYml0KEZhdWx0eSwgJnJkZXYtPmZsYWdzKTsKIAlzZXRfYml0KE1EX0NIQU5HRV9ERVZTLCAmbWRkZXYtPmZsYWdzKTsKLQlwcmludGsoS0VSTl9BTEVSVCAibWQvcmFpZDE6JXM6IERpc2sgZmFpbHVyZSBvbiAlcywgZGlzYWJsaW5nIGRldmljZS5cbiIKLQkgICAgICAgS0VSTl9BTEVSVCAibWQvcmFpZDE6JXM6IE9wZXJhdGlvbiBjb250aW51aW5nIG9uICVkIGRldmljZXMuXG4iLAorCXByaW50ayhLRVJOX0FMRVJUCisJICAgICAgICJtZC9yYWlkMTolczogRGlzayBmYWlsdXJlIG9uICVzLCBkaXNhYmxpbmcgZGV2aWNlLlxuIgorCSAgICAgICAibWQvcmFpZDE6JXM6IE9wZXJhdGlvbiBjb250aW51aW5nIG9uICVkIGRldmljZXMuXG4iLAogCSAgICAgICBtZG5hbWUobWRkZXYpLCBiZGV2bmFtZShyZGV2LT5iZGV2LCBiKSwKIAkgICAgICAgbWRuYW1lKG1kZGV2KSwgY29uZi0+cmFpZF9kaXNrcyAtIG1kZGV2LT5kZWdyYWRlZCk7CiB9CkBAIC0xMzY0LDEwICsxMzY1LDEwIEBACiAJCQkJCSAqLwogCQkJCQlyZGV2ID0gY29uZi0+bWlycm9yc1tkXS5yZGV2OwogCQkJCQlpZiAoc3luY19wYWdlX2lvKHJkZXYsCi0JCQkJCQkJIHNlY3QgKyByZGV2LT5kYXRhX29mZnNldCwKKwkJCQkJCQkgc2VjdCwKIAkJCQkJCQkgczw8OSwKIAkJCQkJCQkgYmlvLT5iaV9pb192ZWNbaWR4XS5idl9wYWdlLAotCQkJCQkJCSBSRUFEKSkgeworCQkJCQkJCSBSRUFELCBmYWxzZSkpIHsKIAkJCQkJCXN1Y2Nlc3MgPSAxOwogCQkJCQkJYnJlYWs7CiAJCQkJCX0KQEAgLTEzOTAsMTAgKzEzOTEsMTAgQEAKIAkJCQkJcmRldiA9IGNvbmYtPm1pcnJvcnNbZF0ucmRldjsKIAkJCQkJYXRvbWljX2FkZChzLCAmcmRldi0+Y29ycmVjdGVkX2Vycm9ycyk7CiAJCQkJCWlmIChzeW5jX3BhZ2VfaW8ocmRldiwKLQkJCQkJCQkgc2VjdCArIHJkZXYtPmRhdGFfb2Zmc2V0LAorCQkJCQkJCSBzZWN0LAogCQkJCQkJCSBzPDw5LAogCQkJCQkJCSBiaW8tPmJpX2lvX3ZlY1tpZHhdLmJ2X3BhZ2UsCi0JCQkJCQkJIFdSSVRFKSA9PSAwKQorCQkJCQkJCSBXUklURSwgZmFsc2UpID09IDApCiAJCQkJCQltZF9lcnJvcihtZGRldiwgcmRldik7CiAJCQkJfQogCQkJCWQgPSBzdGFydDsKQEAgLTE0MDUsMTAgKzE0MDYsMTAgQEAKIAkJCQkJCWNvbnRpbnVlOwogCQkJCQlyZGV2ID0gY29uZi0+bWlycm9yc1tkXS5yZGV2OwogCQkJCQlpZiAoc3luY19wYWdlX2lvKHJkZXYsCi0JCQkJCQkJIHNlY3QgKyByZGV2LT5kYXRhX29mZnNldCwKKwkJCQkJCQkgc2VjdCwKIAkJCQkJCQkgczw8OSwKIAkJCQkJCQkgYmlvLT5iaV9pb192ZWNbaWR4XS5idl9wYWdlLAotCQkJCQkJCSBSRUFEKSA9PSAwKQorCQkJCQkJCSBSRUFELCBmYWxzZSkgPT0gMCkKIAkJCQkJCW1kX2Vycm9yKG1kZGV2LCByZGV2KTsKIAkJCQl9CiAJCQl9IGVsc2UgewpAQCAtMTQ4OCwxMCArMTQ4OSw4IEBACiAJCQlyZGV2ID0gY29uZi0+bWlycm9yc1tkXS5yZGV2OwogCQkJaWYgKHJkZXYgJiYKIAkJCSAgICB0ZXN0X2JpdChJbl9zeW5jLCAmcmRldi0+ZmxhZ3MpICYmCi0JCQkgICAgc3luY19wYWdlX2lvKHJkZXYsCi0JCQkJCSBzZWN0ICsgcmRldi0+ZGF0YV9vZmZzZXQsCi0JCQkJCSBzPDw5LAotCQkJCQkgY29uZi0+dG1wcGFnZSwgUkVBRCkpCisJCQkgICAgc3luY19wYWdlX2lvKHJkZXYsIHNlY3QsIHM8PDksCisJCQkJCSBjb25mLT50bXBwYWdlLCBSRUFELCBmYWxzZSkpCiAJCQkJc3VjY2VzcyA9IDE7CiAJCQllbHNlIHsKIAkJCQlkKys7CkBAIC0xNTE0LDkgKzE1MTMsOCBAQAogCQkJcmRldiA9IGNvbmYtPm1pcnJvcnNbZF0ucmRldjsKIAkJCWlmIChyZGV2ICYmCiAJCQkgICAgdGVzdF9iaXQoSW5fc3luYywgJnJkZXYtPmZsYWdzKSkgewotCQkJCWlmIChzeW5jX3BhZ2VfaW8ocmRldiwKLQkJCQkJCSBzZWN0ICsgcmRldi0+ZGF0YV9vZmZzZXQsCi0JCQkJCQkgczw8OSwgY29uZi0+dG1wcGFnZSwgV1JJVEUpCisJCQkJaWYgKHN5bmNfcGFnZV9pbyhyZGV2LCBzZWN0LCBzPDw5LAorCQkJCQkJIGNvbmYtPnRtcHBhZ2UsIFdSSVRFLCBmYWxzZSkKIAkJCQkgICAgPT0gMCkKIAkJCQkJLyogV2VsbCwgdGhpcyBkZXZpY2UgaXMgZGVhZCAqLwogCQkJCQltZF9lcnJvcihtZGRldiwgcmRldik7CkBAIC0xNTMxLDkgKzE1MjksOCBAQAogCQkJcmRldiA9IGNvbmYtPm1pcnJvcnNbZF0ucmRldjsKIAkJCWlmIChyZGV2ICYmCiAJCQkgICAgdGVzdF9iaXQoSW5fc3luYywgJnJkZXYtPmZsYWdzKSkgewotCQkJCWlmIChzeW5jX3BhZ2VfaW8ocmRldiwKLQkJCQkJCSBzZWN0ICsgcmRldi0+ZGF0YV9vZmZzZXQsCi0JCQkJCQkgczw8OSwgY29uZi0+dG1wcGFnZSwgUkVBRCkKKwkJCQlpZiAoc3luY19wYWdlX2lvKHJkZXYsIHNlY3QsIHM8PDksCisJCQkJCQkgY29uZi0+dG1wcGFnZSwgUkVBRCwgZmFsc2UpCiAJCQkJICAgID09IDApCiAJCQkJCS8qIFdlbGwsIHRoaXMgZGV2aWNlIGlzIGRlYWQgKi8KIAkJCQkJbWRfZXJyb3IobWRkZXYsIHJkZXYpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9yYWlkMTAuYyBiL2RyaXZlcnMvbWQvcmFpZDEwLmMKaW5kZXggMDY0MTY3NC4uM2I2MDdiMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9yYWlkMTAuYworKysgYi9kcml2ZXJzL21kL3JhaWQxMC5jCkBAIC0xMDUxLDggKzEwNTEsOSBAQAogCX0KIAlzZXRfYml0KEZhdWx0eSwgJnJkZXYtPmZsYWdzKTsKIAlzZXRfYml0KE1EX0NIQU5HRV9ERVZTLCAmbWRkZXYtPmZsYWdzKTsKLQlwcmludGsoS0VSTl9BTEVSVCAibWQvcmFpZDEwOiVzOiBEaXNrIGZhaWx1cmUgb24gJXMsIGRpc2FibGluZyBkZXZpY2UuXG4iCi0JICAgICAgIEtFUk5fQUxFUlQgIm1kL3JhaWQxMDolczogT3BlcmF0aW9uIGNvbnRpbnVpbmcgb24gJWQgZGV2aWNlcy5cbiIsCisJcHJpbnRrKEtFUk5fQUxFUlQKKwkgICAgICAgIm1kL3JhaWQxMDolczogRGlzayBmYWlsdXJlIG9uICVzLCBkaXNhYmxpbmcgZGV2aWNlLlxuIgorCSAgICAgICAibWQvcmFpZDEwOiVzOiBPcGVyYXRpb24gY29udGludWluZyBvbiAlZCBkZXZpY2VzLlxuIiwKIAkgICAgICAgbWRuYW1lKG1kZGV2KSwgYmRldm5hbWUocmRldi0+YmRldiwgYiksCiAJICAgICAgIG1kbmFtZShtZGRldiksIGNvbmYtPnJhaWRfZGlza3MgLSBtZGRldi0+ZGVncmFkZWQpOwogfQpAQCAtMTU1OSw5ICsxNTYwLDkgQEAKIAkJCQlyY3VfcmVhZF91bmxvY2soKTsKIAkJCQlzdWNjZXNzID0gc3luY19wYWdlX2lvKHJkZXYsCiAJCQkJCQkgICAgICAgcjEwX2Jpby0+ZGV2c1tzbF0uYWRkciArCi0JCQkJCQkgICAgICAgc2VjdCArIHJkZXYtPmRhdGFfb2Zmc2V0LAorCQkJCQkJICAgICAgIHNlY3QsCiAJCQkJCQkgICAgICAgczw8OSwKLQkJCQkJCSAgICAgICBjb25mLT50bXBwYWdlLCBSRUFEKTsKKwkJCQkJCSAgICAgICBjb25mLT50bXBwYWdlLCBSRUFELCBmYWxzZSk7CiAJCQkJcmRldl9kZWNfcGVuZGluZyhyZGV2LCBtZGRldik7CiAJCQkJcmN1X3JlYWRfbG9jaygpOwogCQkJCWlmIChzdWNjZXNzKQpAQCAtMTU5OCw4ICsxNTk5LDggQEAKIAkJCQlhdG9taWNfYWRkKHMsICZyZGV2LT5jb3JyZWN0ZWRfZXJyb3JzKTsKIAkJCQlpZiAoc3luY19wYWdlX2lvKHJkZXYsCiAJCQkJCQkgcjEwX2Jpby0+ZGV2c1tzbF0uYWRkciArCi0JCQkJCQkgc2VjdCArIHJkZXYtPmRhdGFfb2Zmc2V0LAotCQkJCQkJIHM8PDksIGNvbmYtPnRtcHBhZ2UsIFdSSVRFKQorCQkJCQkJIHNlY3QsCisJCQkJCQkgczw8OSwgY29uZi0+dG1wcGFnZSwgV1JJVEUsIGZhbHNlKQogCQkJCSAgICA9PSAwKSB7CiAJCQkJCS8qIFdlbGwsIHRoaXMgZGV2aWNlIGlzIGRlYWQgKi8KIAkJCQkJcHJpbnRrKEtFUk5fTk9USUNFCkBAIC0xNjM1LDkgKzE2MzYsOSBAQAogCQkJCXJjdV9yZWFkX3VubG9jaygpOwogCQkJCWlmIChzeW5jX3BhZ2VfaW8ocmRldiwKIAkJCQkJCSByMTBfYmlvLT5kZXZzW3NsXS5hZGRyICsKLQkJCQkJCSBzZWN0ICsgcmRldi0+ZGF0YV9vZmZzZXQsCisJCQkJCQkgc2VjdCwKIAkJCQkJCSBzPDw5LCBjb25mLT50bXBwYWdlLAotCQkJCQkJIFJFQUQpID09IDApIHsKKwkJCQkJCSBSRUFELCBmYWxzZSkgPT0gMCkgewogCQkJCQkvKiBXZWxsLCB0aGlzIGRldmljZSBpcyBkZWFkICovCiAJCQkJCXByaW50ayhLRVJOX05PVElDRQogCQkJCQkgICAgICAgIm1kL3JhaWQxMDolczogdW5hYmxlIHRvIHJlYWQgYmFjayAiCkBAIC0yNDYyLDExICsyNDYzLDEzIEBACiAJbWRkZXYtPnJlY292ZXJ5X2NwID0gTWF4U2VjdG9yOwogCiAJY29uZiA9IHNldHVwX2NvbmYobWRkZXYpOwotCWlmICghSVNfRVJSKGNvbmYpKQorCWlmICghSVNfRVJSKGNvbmYpKSB7CiAJCWxpc3RfZm9yX2VhY2hfZW50cnkocmRldiwgJm1kZGV2LT5kaXNrcywgc2FtZV9zZXQpCiAJCQlpZiAocmRldi0+cmFpZF9kaXNrID49IDApCiAJCQkJcmRldi0+bmV3X3JhaWRfZGlzayA9IHJkZXYtPnJhaWRfZGlzayAqIDI7Ci0JCQorCQljb25mLT5iYXJyaWVyID0gMTsKKwl9CisKIAlyZXR1cm4gY29uZjsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9yYWlkNS5jIGIvZHJpdmVycy9tZC9yYWlkNS5jCmluZGV4IGRjNTc0ZjMuLjcwMjgxMjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvcmFpZDUuYworKysgYi9kcml2ZXJzL21kL3JhaWQ1LmMKQEAgLTE3MjEsNyArMTcyMSw2IEBACiAJCXNldF9iaXQoRmF1bHR5LCAmcmRldi0+ZmxhZ3MpOwogCQlwcmludGsoS0VSTl9BTEVSVAogCQkgICAgICAgIm1kL3JhaWQ6JXM6IERpc2sgZmFpbHVyZSBvbiAlcywgZGlzYWJsaW5nIGRldmljZS5cbiIKLQkJICAgICAgIEtFUk5fQUxFUlQKIAkJICAgICAgICJtZC9yYWlkOiVzOiBPcGVyYXRpb24gY29udGludWluZyBvbiAlZCBkZXZpY2VzLlxuIiwKIAkJICAgICAgIG1kbmFtZShtZGRldiksCiAJCSAgICAgICBiZGV2bmFtZShyZGV2LT5iZGV2LCBiKSwKQEAgLTQyMzcsNyArNDIzNiw3IEBACiAJCXdhaXRfZXZlbnQoY29uZi0+d2FpdF9mb3Jfb3ZlcmxhcCwKIAkJCSAgIGF0b21pY19yZWFkKCZjb25mLT5yZXNoYXBlX3N0cmlwZXMpPT0wKTsKIAkJbWRkZXYtPnJlc2hhcGVfcG9zaXRpb24gPSBjb25mLT5yZXNoYXBlX3Byb2dyZXNzOwotCQltZGRldi0+Y3Vycl9yZXN5bmNfY29tcGxldGVkID0gbWRkZXYtPmN1cnJfcmVzeW5jOworCQltZGRldi0+Y3Vycl9yZXN5bmNfY29tcGxldGVkID0gc2VjdG9yX25yOwogCQljb25mLT5yZXNoYXBlX2NoZWNrcG9pbnQgPSBqaWZmaWVzOwogCQlzZXRfYml0KE1EX0NIQU5HRV9ERVZTLCAmbWRkZXYtPmZsYWdzKTsKIAkJbWRfd2FrZXVwX3RocmVhZChtZGRldi0+dGhyZWFkKTsKQEAgLTQzMzgsNyArNDMzNyw3IEBACiAJCXdhaXRfZXZlbnQoY29uZi0+d2FpdF9mb3Jfb3ZlcmxhcCwKIAkJCSAgIGF0b21pY19yZWFkKCZjb25mLT5yZXNoYXBlX3N0cmlwZXMpID09IDApOwogCQltZGRldi0+cmVzaGFwZV9wb3NpdGlvbiA9IGNvbmYtPnJlc2hhcGVfcHJvZ3Jlc3M7Ci0JCW1kZGV2LT5jdXJyX3Jlc3luY19jb21wbGV0ZWQgPSBtZGRldi0+Y3Vycl9yZXN5bmMgKyByZXNoYXBlX3NlY3RvcnM7CisJCW1kZGV2LT5jdXJyX3Jlc3luY19jb21wbGV0ZWQgPSBzZWN0b3JfbnI7CiAJCWNvbmYtPnJlc2hhcGVfY2hlY2twb2ludCA9IGppZmZpZXM7CiAJCXNldF9iaXQoTURfQ0hBTkdFX0RFVlMsICZtZGRldi0+ZmxhZ3MpOwogCQltZF93YWtldXBfdGhyZWFkKG1kZGV2LT50aHJlYWQpOwpAQCAtNTMzOSw3ICs1MzM4LDcgQEAKIAkJICAgICYmICF0ZXN0X2JpdChGYXVsdHksICZ0bXAtPnJkZXYtPmZsYWdzKQogCQkgICAgJiYgIXRlc3RfYW5kX3NldF9iaXQoSW5fc3luYywgJnRtcC0+cmRldi0+ZmxhZ3MpKSB7CiAJCQljb3VudCsrOwotCQkJc3lzZnNfbm90aWZ5X2RpcmVudCh0bXAtPnJkZXYtPnN5c2ZzX3N0YXRlKTsKKwkJCXN5c2ZzX25vdGlmeV9kaXJlbnRfc2FmZSh0bXAtPnJkZXYtPnN5c2ZzX3N0YXRlKTsKIAkJfQogCX0KIAlzcGluX2xvY2tfaXJxc2F2ZSgmY29uZi0+ZGV2aWNlX2xvY2ssIGZsYWdzKTsKQEAgLTU1MTgsNyArNTUxNyw2IEBACiAJcmFpZDVfY29uZl90ICpjb25mID0gbWRkZXYtPnByaXZhdGU7CiAJbWRrX3JkZXZfdCAqcmRldjsKIAlpbnQgc3BhcmVzID0gMDsKLQlpbnQgYWRkZWRfZGV2aWNlcyA9IDA7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCWlmICh0ZXN0X2JpdChNRF9SRUNPVkVSWV9SVU5OSU5HLCAmbWRkZXYtPnJlY292ZXJ5KSkKQEAgLTU1MjgsOCArNTUyNiw4IEBACiAJCXJldHVybiAtRU5PU1BDOwogCiAJbGlzdF9mb3JfZWFjaF9lbnRyeShyZGV2LCAmbWRkZXYtPmRpc2tzLCBzYW1lX3NldCkKLQkJaWYgKHJkZXYtPnJhaWRfZGlzayA8IDAgJiYKLQkJICAgICF0ZXN0X2JpdChGYXVsdHksICZyZGV2LT5mbGFncykpCisJCWlmICghdGVzdF9iaXQoSW5fc3luYywgJnJkZXYtPmZsYWdzKQorCQkgICAgJiYgIXRlc3RfYml0KEZhdWx0eSwgJnJkZXYtPmZsYWdzKSkKIAkJCXNwYXJlcysrOwogCiAJaWYgKHNwYXJlcyAtIG1kZGV2LT5kZWdyYWRlZCA8IG1kZGV2LT5kZWx0YV9kaXNrcyAtIGNvbmYtPm1heF9kZWdyYWRlZCkKQEAgLTU1NzIsMjkgKzU1NzAsMzUgQEAKIAkgKiB0byBjb3JyZWN0bHkgcmVjb3JkIHRoZSAicGFydGlhbGx5IHJlY29uc3RydWN0ZWQiIHN0YXRlIG9mCiAJICogc3VjaCBkZXZpY2VzIGR1cmluZyB0aGUgcmVzaGFwZSBhbmQgY29uZnVzaW9uIGNvdWxkIHJlc3VsdC4KIAkgKi8KLQlpZiAobWRkZXYtPmRlbHRhX2Rpc2tzID49IDApCi0JICAgIGxpc3RfZm9yX2VhY2hfZW50cnkocmRldiwgJm1kZGV2LT5kaXNrcywgc2FtZV9zZXQpCi0JCWlmIChyZGV2LT5yYWlkX2Rpc2sgPCAwICYmCi0JCSAgICAhdGVzdF9iaXQoRmF1bHR5LCAmcmRldi0+ZmxhZ3MpKSB7Ci0JCQlpZiAocmFpZDVfYWRkX2Rpc2sobWRkZXYsIHJkZXYpID09IDApIHsKLQkJCQljaGFyIG5tWzIwXTsKLQkJCQlpZiAocmRldi0+cmFpZF9kaXNrID49IGNvbmYtPnByZXZpb3VzX3JhaWRfZGlza3MpIHsKLQkJCQkJc2V0X2JpdChJbl9zeW5jLCAmcmRldi0+ZmxhZ3MpOwotCQkJCQlhZGRlZF9kZXZpY2VzKys7Ci0JCQkJfSBlbHNlCi0JCQkJCXJkZXYtPnJlY292ZXJ5X29mZnNldCA9IDA7Ci0JCQkJc3ByaW50ZihubSwgInJkJWQiLCByZGV2LT5yYWlkX2Rpc2spOwotCQkJCWlmIChzeXNmc19jcmVhdGVfbGluaygmbWRkZXYtPmtvYmosCi0JCQkJCQkgICAgICAmcmRldi0+a29iaiwgbm0pKQotCQkJCQkvKiBGYWlsdXJlIGhlcmUgaXMgT0sgKi87Ci0JCQl9IGVsc2UKLQkJCQlicmVhazsKLQkJfQorCWlmIChtZGRldi0+ZGVsdGFfZGlza3MgPj0gMCkgeworCQlpbnQgYWRkZWRfZGV2aWNlcyA9IDA7CisJCWxpc3RfZm9yX2VhY2hfZW50cnkocmRldiwgJm1kZGV2LT5kaXNrcywgc2FtZV9zZXQpCisJCQlpZiAocmRldi0+cmFpZF9kaXNrIDwgMCAmJgorCQkJICAgICF0ZXN0X2JpdChGYXVsdHksICZyZGV2LT5mbGFncykpIHsKKwkJCQlpZiAocmFpZDVfYWRkX2Rpc2sobWRkZXYsIHJkZXYpID09IDApIHsKKwkJCQkJY2hhciBubVsyMF07CisJCQkJCWlmIChyZGV2LT5yYWlkX2Rpc2sKKwkJCQkJICAgID49IGNvbmYtPnByZXZpb3VzX3JhaWRfZGlza3MpIHsKKwkJCQkJCXNldF9iaXQoSW5fc3luYywgJnJkZXYtPmZsYWdzKTsKKwkJCQkJCWFkZGVkX2RldmljZXMrKzsKKwkJCQkJfSBlbHNlCisJCQkJCQlyZGV2LT5yZWNvdmVyeV9vZmZzZXQgPSAwOworCQkJCQlzcHJpbnRmKG5tLCAicmQlZCIsIHJkZXYtPnJhaWRfZGlzayk7CisJCQkJCWlmIChzeXNmc19jcmVhdGVfbGluaygmbWRkZXYtPmtvYmosCisJCQkJCQkJICAgICAgJnJkZXYtPmtvYmosIG5tKSkKKwkJCQkJCS8qIEZhaWx1cmUgaGVyZSBpcyBPSyAqLzsKKwkJCQl9CisJCQl9IGVsc2UgaWYgKHJkZXYtPnJhaWRfZGlzayA+PSBjb25mLT5wcmV2aW91c19yYWlkX2Rpc2tzCisJCQkJICAgJiYgIXRlc3RfYml0KEZhdWx0eSwgJnJkZXYtPmZsYWdzKSkgeworCQkJCS8qIFRoaXMgaXMgYSBzcGFyZSB0aGF0IHdhcyBtYW51YWxseSBhZGRlZCAqLworCQkJCXNldF9iaXQoSW5fc3luYywgJnJkZXYtPmZsYWdzKTsKKwkJCQlhZGRlZF9kZXZpY2VzKys7CisJCQl9CiAKLQkvKiBXaGVuIGEgcmVzaGFwZSBjaGFuZ2VzIHRoZSBudW1iZXIgb2YgZGV2aWNlcywgLT5kZWdyYWRlZAotCSAqIGlzIG1lYXN1cmVkIGFnYWluc3QgdGhlIGxhcmdlciBvZiB0aGUgcHJlIGFuZCBwb3N0IG51bWJlciBvZgotCSAqIGRldmljZXMuKi8KLQlpZiAobWRkZXYtPmRlbHRhX2Rpc2tzID4gMCkgeworCQkvKiBXaGVuIGEgcmVzaGFwZSBjaGFuZ2VzIHRoZSBudW1iZXIgb2YgZGV2aWNlcywKKwkJICogLT5kZWdyYWRlZCBpcyBtZWFzdXJlZCBhZ2FpbnN0IHRoZSBsYXJnZXIgb2YgdGhlCisJCSAqIHByZSBhbmQgcG9zdCBudW1iZXIgb2YgZGV2aWNlcy4KKwkJICovCiAJCXNwaW5fbG9ja19pcnFzYXZlKCZjb25mLT5kZXZpY2VfbG9jaywgZmxhZ3MpOwogCQltZGRldi0+ZGVncmFkZWQgKz0gKGNvbmYtPnJhaWRfZGlza3MgLSBjb25mLT5wcmV2aW91c19yYWlkX2Rpc2tzKQogCQkJLSBhZGRlZF9kZXZpY2VzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9jb21tb24vc2FhNzE0Nl9jb3JlLmMgYi9kcml2ZXJzL21lZGlhL2NvbW1vbi9zYWE3MTQ2X2NvcmUuYwppbmRleCA5ODJmMDAwLi45ZjQ3ZTM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2NvbW1vbi9zYWE3MTQ2X2NvcmUuYworKysgYi9kcml2ZXJzL21lZGlhL2NvbW1vbi9zYWE3MTQ2X2NvcmUuYwpAQCAtNDUyLDcgKzQ1Miw3IEBACiAJSU5GTygoImZvdW5kIHNhYTcxNDYgQCBtZW0gJXAgKHJldmlzaW9uICVkLCBpcnEgJWQpICgweCUwNHgsMHglMDR4KS5cbiIsIGRldi0+bWVtLCBkZXYtPnJldmlzaW9uLCBwY2ktPmlycSwgcGNpLT5zdWJzeXN0ZW1fdmVuZG9yLCBwY2ktPnN1YnN5c3RlbV9kZXZpY2UpKTsKIAlkZXYtPmV4dCA9IGV4dDsKIAotCW11dGV4X2luaXQoJmRldi0+bG9jayk7CisJbXV0ZXhfaW5pdCgmZGV2LT52NGwyX2xvY2spOwogCXNwaW5fbG9ja19pbml0KCZkZXYtPmludF9zbG9jayk7CiAJc3Bpbl9sb2NrX2luaXQoJmRldi0+c2xvY2spOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2NvbW1vbi9zYWE3MTQ2X2ZvcHMuYyBiL2RyaXZlcnMvbWVkaWEvY29tbW9uL3NhYTcxNDZfZm9wcy5jCmluZGV4IGUzZmVkYzYuLjFiZDNkZDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvY29tbW9uL3NhYTcxNDZfZm9wcy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvY29tbW9uL3NhYTcxNDZfZm9wcy5jCkBAIC0xNSwxOCArMTUsMTUgQEAKIAl9CiAKIAkvKiBpcyBpdCBmcmVlPyAqLwotCW11dGV4X2xvY2soJmRldi0+bG9jayk7CiAJaWYgKHZ2LT5yZXNvdXJjZXMgJiBiaXQpIHsKIAkJREVCX0QoKCJsb2NrZWQhIHZ2LT5yZXNvdXJjZXM6MHglMDJ4LCB3ZSB3YW50OjB4JTAyeFxuIix2di0+cmVzb3VyY2VzLGJpdCkpOwogCQkvKiBubywgc29tZW9uZSBlbHNlIHVzZXMgaXQgKi8KLQkJbXV0ZXhfdW5sb2NrKCZkZXYtPmxvY2spOwogCQlyZXR1cm4gMDsKIAl9CiAJLyogaXQncyBmcmVlLCBncmFiIGl0ICovCiAJZmgtPnJlc291cmNlcyAgfD0gYml0OwogCXZ2LT5yZXNvdXJjZXMgfD0gYml0OwogCURFQl9EKCgicmVzOiBnZXQgMHglMDJ4LCBjdXI6MHglMDJ4XG4iLGJpdCx2di0+cmVzb3VyY2VzKSk7Ci0JbXV0ZXhfdW5sb2NrKCZkZXYtPmxvY2spOwogCXJldHVybiAxOwogfQogCkBAIC0zNywxMSArMzQsOSBAQAogCiAJQlVHX09OKChmaC0+cmVzb3VyY2VzICYgYml0cykgIT0gYml0cyk7CiAKLQltdXRleF9sb2NrKCZkZXYtPmxvY2spOwogCWZoLT5yZXNvdXJjZXMgICY9IH5iaXRzOwogCXZ2LT5yZXNvdXJjZXMgJj0gfmJpdHM7CiAJREVCX0QoKCJyZXM6IHB1dCAweCUwMngsIGN1cjoweCUwMnhcbiIsYml0cyx2di0+cmVzb3VyY2VzKSk7Ci0JbXV0ZXhfdW5sb2NrKCZkZXYtPmxvY2spOwogfQogCiAKQEAgLTM5Niw3ICszOTEsNyBAQAogCS53cml0ZQkJPSBmb3BzX3dyaXRlLAogCS5wb2xsCQk9IGZvcHNfcG9sbCwKIAkubW1hcAkJPSBmb3BzX21tYXAsCi0JLmlvY3RsCQk9IHZpZGVvX2lvY3RsMiwKKwkudW5sb2NrZWRfaW9jdGwJPSB2aWRlb19pb2N0bDIsCiB9OwogCiBzdGF0aWMgdm9pZCB2dl9jYWxsYmFjayhzdHJ1Y3Qgc2FhNzE0Nl9kZXYgKmRldiwgdW5zaWduZWQgbG9uZyBzdGF0dXMpCkBAIC01MDUsNiArNTAwLDcgQEAKIAl2ZmQtPmZvcHMgPSAmdmlkZW9fZm9wczsKIAl2ZmQtPmlvY3RsX29wcyA9ICZkZXYtPmV4dF92dl9kYXRhLT5vcHM7CiAJdmZkLT5yZWxlYXNlID0gdmlkZW9fZGV2aWNlX3JlbGVhc2U7CisJdmZkLT5sb2NrID0gJmRldi0+djRsMl9sb2NrOwogCXZmZC0+dHZub3JtcyA9IDA7CiAJZm9yIChpID0gMDsgaSA8IGRldi0+ZXh0X3Z2X2RhdGEtPm51bV9zdGRzOyBpKyspCiAJCXZmZC0+dHZub3JtcyB8PSBkZXYtPmV4dF92dl9kYXRhLT5zdGRzW2ldLmlkOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9jb21tb24vc2FhNzE0Nl92YmkuYyBiL2RyaXZlcnMvbWVkaWEvY29tbW9uL3NhYTcxNDZfdmJpLmMKaW5kZXggMmQ0NTMzYS4uYWZlODU4MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9jb21tb24vc2FhNzE0Nl92YmkuYworKysgYi9kcml2ZXJzL21lZGlhL2NvbW1vbi9zYWE3MTQ2X3ZiaS5jCkBAIC00MTIsNyArNDEyLDcgQEAKIAkJCSAgICBWNEwyX0JVRl9UWVBFX1ZCSV9DQVBUVVJFLAogCQkJICAgIFY0TDJfRklFTERfU0VRX1RCLCAvLyBGSVhNRTogZG9lcyB0aGlzIHJlYWxseSB3b3JrPwogCQkJICAgIHNpemVvZihzdHJ1Y3Qgc2FhNzE0Nl9idWYpLAotCQkJICAgIGZpbGUsIE5VTEwpOworCQkJICAgIGZpbGUsICZkZXYtPnY0bDJfbG9jayk7CiAKIAlpbml0X3RpbWVyKCZmaC0+dmJpX3JlYWRfdGltZW91dCk7CiAJZmgtPnZiaV9yZWFkX3RpbWVvdXQuZnVuY3Rpb24gPSB2YmlfcmVhZF90aW1lb3V0OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9jb21tb24vc2FhNzE0Nl92aWRlby5jIGIvZHJpdmVycy9tZWRpYS9jb21tb24vc2FhNzE0Nl92aWRlby5jCmluZGV4IDBhYzVjNjEuLjlhYWZhNGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvY29tbW9uL3NhYTcxNDZfdmlkZW8uYworKysgYi9kcml2ZXJzL21lZGlhL2NvbW1vbi9zYWE3MTQ2X3ZpZGVvLmMKQEAgLTU1Myw4ICs1NTMsNiBAQAogCQl9CiAJfQogCi0JbXV0ZXhfbG9jaygmZGV2LT5sb2NrKTsKLQogCS8qIG9rLCBhY2NlcHQgaXQgKi8KIAl2di0+b3ZfZmIgPSAqZmI7CiAJdnYtPm92X2ZtdCA9IGZtdDsKQEAgLTU2Myw4ICs1NjEsNiBAQAogCQl2di0+b3ZfZmIuZm10LmJ5dGVzcGVybGluZSA9IHZ2LT5vdl9mYi5mbXQud2lkdGggKiBmbXQtPmRlcHRoIC8gODsKIAkJREVCX0QoKCJzZXR0aW5nIGJ5dGVzcGVybGluZSB0byAlZFxuIiwgdnYtPm92X2ZiLmZtdC5ieXRlc3BlcmxpbmUpKTsKIAl9Ci0KLQltdXRleF91bmxvY2soJmRldi0+bG9jayk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTY0OSw4ICs2NDUsNiBAQAogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKLQltdXRleF9sb2NrKCZkZXYtPmxvY2spOwotCiAJc3dpdGNoIChjdHJsLT50eXBlKSB7CiAJY2FzZSBWNEwyX0NUUkxfVFlQRV9CT09MRUFOOgogCWNhc2UgVjRMMl9DVFJMX1RZUEVfTUVOVToKQEAgLTY5Myw3ICs2ODcsNiBAQAogCQkvKiBmaXhtZTogd2UgY2FuIHN1cHBvcnQgY2hhbmdpbmcgVkZMSVAgYW5kIEhGTElQIGhlcmUuLi4gKi8KIAkJaWYgKElTX0NBUFRVUkVfQUNUSVZFKGZoKSAhPSAwKSB7CiAJCQlERUJfRCgoIlY0TDJfQ0lEX0hGTElQIHdoaWxlIGFjdGl2ZSBjYXB0dXJlLlxuIikpOwotCQkJbXV0ZXhfdW5sb2NrKCZkZXYtPmxvY2spOwogCQkJcmV0dXJuIC1FQlVTWTsKIAkJfQogCQl2di0+aGZsaXAgPSBjLT52YWx1ZTsKQEAgLTcwMSwxNiArNjk0LDEzIEBACiAJY2FzZSBWNEwyX0NJRF9WRkxJUDoKIAkJaWYgKElTX0NBUFRVUkVfQUNUSVZFKGZoKSAhPSAwKSB7CiAJCQlERUJfRCgoIlY0TDJfQ0lEX1ZGTElQIHdoaWxlIGFjdGl2ZSBjYXB0dXJlLlxuIikpOwotCQkJbXV0ZXhfdW5sb2NrKCZkZXYtPmxvY2spOwogCQkJcmV0dXJuIC1FQlVTWTsKIAkJfQogCQl2di0+dmZsaXAgPSBjLT52YWx1ZTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKLQkJbXV0ZXhfdW5sb2NrKCZkZXYtPmxvY2spOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9Ci0JbXV0ZXhfdW5sb2NrKCZkZXYtPmxvY2spOwogCiAJaWYgKElTX09WRVJMQVlfQUNUSVZFKGZoKSAhPSAwKSB7CiAJCXNhYTcxNDZfc3RvcF9wcmV2aWV3KGZoKTsKQEAgLTkwMiwyMiArODkyLDE4IEBACiAJZXJyID0gdmlkaW9jX3RyeV9mbXRfdmlkX292ZXJsYXkoZmlsZSwgZmgsIGYpOwogCWlmICgwICE9IGVycikKIAkJcmV0dXJuIGVycjsKLQltdXRleF9sb2NrKCZkZXYtPmxvY2spOwogCWZoLT5vdi53aW4gICAgPSBmLT5mbXQud2luOwogCWZoLT5vdi5uY2xpcHMgPSBmLT5mbXQud2luLmNsaXBjb3VudDsKIAlpZiAoZmgtPm92Lm5jbGlwcyA+IDE2KQogCQlmaC0+b3YubmNsaXBzID0gMTY7CiAJaWYgKGNvcHlfZnJvbV91c2VyKGZoLT5vdi5jbGlwcywgZi0+Zm10Lndpbi5jbGlwcywKIAkJCQlzaXplb2Yoc3RydWN0IHY0bDJfY2xpcCkgKiBmaC0+b3YubmNsaXBzKSkgewotCQltdXRleF91bmxvY2soJmRldi0+bG9jayk7CiAJCXJldHVybiAtRUZBVUxUOwogCX0KIAogCS8qIGZoLT5vdi5maCBpcyB1c2VkIHRvIGluZGljYXRlIHRoYXQgd2UgaGF2ZSB2YWxpZCBvdmVybGF5IGluZm9ybWF0aW9ucywgdG9vICovCiAJZmgtPm92LmZoID0gZmg7CiAKLQltdXRleF91bmxvY2soJmRldi0+bG9jayk7Ci0KIAkvKiBjaGVjayBpZiBvdXIgY3VycmVudCBvdmVybGF5IGlzIGFjdGl2ZSAqLwogCWlmIChJU19PVkVSTEFZX0FDVElWRShmaCkgIT0gMCkgewogCQlzYWE3MTQ2X3N0b3BfcHJldmlldyhmaCk7CkBAIC05NzYsOCArOTYyLDYgQEAKIAkJfQogCX0KIAotCW11dGV4X2xvY2soJmRldi0+bG9jayk7Ci0KIAlmb3IgKGkgPSAwOyBpIDwgZGV2LT5leHRfdnZfZGF0YS0+bnVtX3N0ZHM7IGkrKykKIAkJaWYgKCppZCAmIGRldi0+ZXh0X3Z2X2RhdGEtPnN0ZHNbaV0uaWQpCiAJCQlicmVhazsKQEAgLTk4OCw4ICs5NzIsNiBAQAogCQlmb3VuZCA9IDE7CiAJfQogCi0JbXV0ZXhfdW5sb2NrKCZkZXYtPmxvY2spOwotCiAJaWYgKHZ2LT5vdl9zdXNwZW5kICE9IE5VTEwpIHsKIAkJc2FhNzE0Nl9zdGFydF9wcmV2aWV3KHZ2LT5vdl9zdXNwZW5kKTsKIAkJdnYtPm92X3N1c3BlbmQgPSBOVUxMOwpAQCAtMTM1NCw3ICsxMzM2LDcgQEAKIAkJCSAgICBWNEwyX0JVRl9UWVBFX1ZJREVPX0NBUFRVUkUsCiAJCQkgICAgVjRMMl9GSUVMRF9JTlRFUkxBQ0VELAogCQkJICAgIHNpemVvZihzdHJ1Y3Qgc2FhNzE0Nl9idWYpLAotCQkJICAgIGZpbGUsIE5VTEwpOworCQkJICAgIGZpbGUsICZkZXYtPnY0bDJfbG9jayk7CiAKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvY29tbW9uL3R1bmVycy9LY29uZmlnIGIvZHJpdmVycy9tZWRpYS9jb21tb24vdHVuZXJzL0tjb25maWcKaW5kZXggNzhiMDg5NS4uNmZjNzlmMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9jb21tb24vdHVuZXJzL0tjb25maWcKKysrIGIvZHJpdmVycy9tZWRpYS9jb21tb24vdHVuZXJzL0tjb25maWcKQEAgLTM0LDcgKzM0LDcgQEAKIGNvbmZpZyBNRURJQV9UVU5FUl9DVVNUT01JU0UKIAlib29sICJDdXN0b21pemUgYW5hbG9nIGFuZCBoeWJyaWQgdHVuZXIgbW9kdWxlcyB0byBidWlsZCIKIAlkZXBlbmRzIG9uIE1FRElBX1RVTkVSCi0JZGVmYXVsdCB5IGlmIEVNQkVEREVECisJZGVmYXVsdCB5IGlmIEVYUEVSVAogCWhlbHAKIAkgIFRoaXMgYWxsb3dzIHRoZSB1c2VyIHRvIGRlc2VsZWN0IHR1bmVyIGRyaXZlcnMgdW5uZWNlc3NhcnkKIAkgIGZvciB0aGVpciBoYXJkd2FyZSBmcm9tIHRoZSBidWlsZC4gVXNlIHRoaXMgb3B0aW9uIHdpdGggY2FyZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9jb21tb24vdHVuZXJzL3RkYTgyOTAuYyBiL2RyaXZlcnMvbWVkaWEvY29tbW9uL3R1bmVycy90ZGE4MjkwLmMKaW5kZXggYzkwNjJjZS4uYmM2YTY3NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9jb21tb24vdHVuZXJzL3RkYTgyOTAuYworKysgYi9kcml2ZXJzL21lZGlhL2NvbW1vbi90dW5lcnMvdGRhODI5MC5jCkBAIC05NSw4ICs5NSw3IEBACiAJCW1zbGVlcCgyMCk7CiAJfSBlbHNlIHsKIAkJbXNnID0gZGlzYWJsZTsKLQkJdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCBtc2csIDEpOwotCQl0dW5lcl9pMmNfeGZlcl9yZWN2KCZwcml2LT5pMmNfcHJvcHMsICZtc2dbMV0sIDEpOworCQl0dW5lcl9pMmNfeGZlcl9zZW5kX3JlY3YoJnByaXYtPmkyY19wcm9wcywgbXNnLCAxLCAmbXNnWzFdLCAxKTsKIAogCQlidWZbMl0gPSBtc2dbMV07CiAJCWJ1ZlsyXSAmPSB+MHgwNDsKQEAgLTIzMywxOSArMjMyLDIyIEBACiAJCXR1bmVyX2kyY194ZmVyX3NlbmQoJnByaXYtPmkyY19wcm9wcywgcGxsX2J3X25vbSwgMik7CiAJfQogCisKIAl0ZGE4MjkwX2kyY19icmlkZ2UoZmUsIDEpOwogCiAJaWYgKGZlLT5vcHMudHVuZXJfb3BzLnNldF9hbmFsb2dfcGFyYW1zKQogCQlmZS0+b3BzLnR1bmVyX29wcy5zZXRfYW5hbG9nX3BhcmFtcyhmZSwgcGFyYW1zKTsKIAogCWZvciAoaSA9IDA7IGkgPCAzOyBpKyspIHsKLQkJdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCAmYWRkcl9wbGxfc3RhdCwgMSk7Ci0JCXR1bmVyX2kyY194ZmVyX3JlY3YoJnByaXYtPmkyY19wcm9wcywgJnBsbF9zdGF0LCAxKTsKKwkJdHVuZXJfaTJjX3hmZXJfc2VuZF9yZWN2KCZwcml2LT5pMmNfcHJvcHMsCisJCQkJCSAmYWRkcl9wbGxfc3RhdCwgMSwgJnBsbF9zdGF0LCAxKTsKIAkJaWYgKHBsbF9zdGF0ICYgMHg4MCkgewotCQkJdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCAmYWRkcl9hZGNfc2F0LCAxKTsKLQkJCXR1bmVyX2kyY194ZmVyX3JlY3YoJnByaXYtPmkyY19wcm9wcywgJmFkY19zYXQsIDEpOwotCQkJdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCAmYWRkcl9hZ2Nfc3RhdCwgMSk7Ci0JCQl0dW5lcl9pMmNfeGZlcl9yZWN2KCZwcml2LT5pMmNfcHJvcHMsICZhZ2Nfc3RhdCwgMSk7CisJCQl0dW5lcl9pMmNfeGZlcl9zZW5kX3JlY3YoJnByaXYtPmkyY19wcm9wcywKKwkJCQkJCSAmYWRkcl9hZGNfc2F0LCAxLAorCQkJCQkJICZhZGNfc2F0LCAxKTsKKwkJCXR1bmVyX2kyY194ZmVyX3NlbmRfcmVjdigmcHJpdi0+aTJjX3Byb3BzLAorCQkJCQkJICZhZGRyX2FnY19zdGF0LCAxLAorCQkJCQkJICZhZ2Nfc3RhdCwgMSk7CiAJCQl0dW5lcl9kYmcoInRkYTgyOTAgaXMgbG9ja2VkLCBBR0M6ICVkXG4iLCBhZ2Nfc3RhdCk7CiAJCQlicmVhazsKIAkJfSBlbHNlIHsKQEAgLTI1OSwyMCArMjYxLDIyIEBACiAJCQkgICBhZ2Nfc3RhdCwgYWRjX3NhdCwgcGxsX3N0YXQgJiAweDgwKTsKIAkJdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCBnYWluc2V0XzIsIDIpOwogCQltc2xlZXAoMTAwKTsKLQkJdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCAmYWRkcl9hZ2Nfc3RhdCwgMSk7Ci0JCXR1bmVyX2kyY194ZmVyX3JlY3YoJnByaXYtPmkyY19wcm9wcywgJmFnY19zdGF0LCAxKTsKLQkJdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCAmYWRkcl9wbGxfc3RhdCwgMSk7Ci0JCXR1bmVyX2kyY194ZmVyX3JlY3YoJnByaXYtPmkyY19wcm9wcywgJnBsbF9zdGF0LCAxKTsKKwkJdHVuZXJfaTJjX3hmZXJfc2VuZF9yZWN2KCZwcml2LT5pMmNfcHJvcHMsCisJCQkJCSAmYWRkcl9hZ2Nfc3RhdCwgMSwgJmFnY19zdGF0LCAxKTsKKwkJdHVuZXJfaTJjX3hmZXJfc2VuZF9yZWN2KCZwcml2LT5pMmNfcHJvcHMsCisJCQkJCSAmYWRkcl9wbGxfc3RhdCwgMSwgJnBsbF9zdGF0LCAxKTsKIAkJaWYgKChhZ2Nfc3RhdCA+IDExNSkgfHwgIShwbGxfc3RhdCAmIDB4ODApKSB7CiAJCQl0dW5lcl9kYmcoImFkanVzdCBnYWluLCBzdGVwIDIuIEFnYzogJWQsIGxvY2s6ICVkXG4iLAogCQkJCSAgIGFnY19zdGF0LCBwbGxfc3RhdCAmIDB4ODApOwogCQkJaWYgKHByaXYtPmNmZy5hZ2NmKQogCQkJCXByaXYtPmNmZy5hZ2NmKGZlKTsKIAkJCW1zbGVlcCgxMDApOwotCQkJdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCAmYWRkcl9hZ2Nfc3RhdCwgMSk7Ci0JCQl0dW5lcl9pMmNfeGZlcl9yZWN2KCZwcml2LT5pMmNfcHJvcHMsICZhZ2Nfc3RhdCwgMSk7Ci0JCQl0dW5lcl9pMmNfeGZlcl9zZW5kKCZwcml2LT5pMmNfcHJvcHMsICZhZGRyX3BsbF9zdGF0LCAxKTsKLQkJCXR1bmVyX2kyY194ZmVyX3JlY3YoJnByaXYtPmkyY19wcm9wcywgJnBsbF9zdGF0LCAxKTsKKwkJCXR1bmVyX2kyY194ZmVyX3NlbmRfcmVjdigmcHJpdi0+aTJjX3Byb3BzLAorCQkJCQkJICZhZGRyX2FnY19zdGF0LCAxLAorCQkJCQkJICZhZ2Nfc3RhdCwgMSk7CisJCQl0dW5lcl9pMmNfeGZlcl9zZW5kX3JlY3YoJnByaXYtPmkyY19wcm9wcywKKwkJCQkJCSAmYWRkcl9wbGxfc3RhdCwgMSwKKwkJCQkJCSAmcGxsX3N0YXQsIDEpOwogCQkJaWYoKGFnY19zdGF0ID4gMTE1KSB8fCAhKHBsbF9zdGF0ICYgMHg4MCkpIHsKIAkJCQl0dW5lcl9kYmcoImFkanVzdCBnYWluLCBzdGVwIDMuIEFnYzogJWRcbiIsIGFnY19zdGF0KTsKIAkJCQl0dW5lcl9pMmNfeGZlcl9zZW5kKCZwcml2LT5pMmNfcHJvcHMsIGFkY19oZWFkXzEyLCAyKTsKQEAgLTI4NCwxMCArMjg4LDEyIEBACiAKIAkvKiBsLyBsJyBkZWFkbG9jaz8gKi8KIAlpZihwcml2LT50ZGE4MjkwX2Vhc3lfbW9kZSAmIDB4NjApIHsKLQkJdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCAmYWRkcl9hZGNfc2F0LCAxKTsKLQkJdHVuZXJfaTJjX3hmZXJfcmVjdigmcHJpdi0+aTJjX3Byb3BzLCAmYWRjX3NhdCwgMSk7Ci0JCXR1bmVyX2kyY194ZmVyX3NlbmQoJnByaXYtPmkyY19wcm9wcywgJmFkZHJfcGxsX3N0YXQsIDEpOwotCQl0dW5lcl9pMmNfeGZlcl9yZWN2KCZwcml2LT5pMmNfcHJvcHMsICZwbGxfc3RhdCwgMSk7CisJCXR1bmVyX2kyY194ZmVyX3NlbmRfcmVjdigmcHJpdi0+aTJjX3Byb3BzLAorCQkJCQkgJmFkZHJfYWRjX3NhdCwgMSwKKwkJCQkJICZhZGNfc2F0LCAxKTsKKwkJdHVuZXJfaTJjX3hmZXJfc2VuZF9yZWN2KCZwcml2LT5pMmNfcHJvcHMsCisJCQkJCSAmYWRkcl9wbGxfc3RhdCwgMSwKKwkJCQkJICZwbGxfc3RhdCwgMSk7CiAJCWlmICgoYWRjX3NhdCA+IDIwKSB8fCAhKHBsbF9zdGF0ICYgMHg4MCkpIHsKIAkJCXR1bmVyX2RiZygidHJ5aW5nIHRvIHJlc29sdmUgU0VDQU0gTCBkZWFkbG9ja1xuIik7CiAJCQl0dW5lcl9pMmNfeGZlcl9zZW5kKCZwcml2LT5pMmNfcHJvcHMsIGFnY19yc3Rfb24sIDIpOwpAQCAtMzA3LDggKzMxMyw3IEBACiAJc3RydWN0IHRkYTgyOTBfcHJpdiAqcHJpdiA9IGZlLT5hbmFsb2dfZGVtb2RfcHJpdjsKIAl1bnNpZ25lZCBjaGFyIGJ1ZltdID0geyAweDMwLCAweDAwIH07IC8qIGNsYl9zdGRidCAqLwogCi0JdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCAmYnVmWzBdLCAxKTsKLQl0dW5lcl9pMmNfeGZlcl9yZWN2KCZwcml2LT5pMmNfcHJvcHMsICZidWZbMV0sIDEpOworCXR1bmVyX2kyY194ZmVyX3NlbmRfcmVjdigmcHJpdi0+aTJjX3Byb3BzLCAmYnVmWzBdLCAxLCAmYnVmWzFdLCAxKTsKIAogCWlmIChlbmFibGUpCiAJCWJ1ZlsxXSA9IDB4MDE7CkBAIC0zMjMsOCArMzI4LDcgQEAKIAlzdHJ1Y3QgdGRhODI5MF9wcml2ICpwcml2ID0gZmUtPmFuYWxvZ19kZW1vZF9wcml2OwogCXVuc2lnbmVkIGNoYXIgYnVmW10gPSB7IDB4MDEsIDB4MDAgfTsKIAotCXR1bmVyX2kyY194ZmVyX3NlbmQoJnByaXYtPmkyY19wcm9wcywgJmJ1ZlswXSwgMSk7Ci0JdHVuZXJfaTJjX3hmZXJfcmVjdigmcHJpdi0+aTJjX3Byb3BzLCAmYnVmWzFdLCAxKTsKKwl0dW5lcl9pMmNfeGZlcl9zZW5kX3JlY3YoJnByaXYtPmkyY19wcm9wcywgJmJ1ZlswXSwgMSwgJmJ1ZlsxXSwgMSk7CiAKIAlpZiAoZW5hYmxlKQogCQlidWZbMV0gPSAweDAxOyAvKiByaXNpbmcgZWRnZSBzZXRzIHJlZ3MgMHgwMiAtIDB4MjMgKi8KQEAgLTM1Myw4ICszNTcsNyBAQAogCXN0cnVjdCB0ZGE4MjkwX3ByaXYgKnByaXYgPSBmZS0+YW5hbG9nX2RlbW9kX3ByaXY7CiAJdW5zaWduZWQgY2hhciBidWZbXSA9IHsgMHgwMiwgMHgwMCB9OyAvKiBESVZfRlVOQyAqLwogCi0JdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCAmYnVmWzBdLCAxKTsKLQl0dW5lcl9pMmNfeGZlcl9yZWN2KCZwcml2LT5pMmNfcHJvcHMsICZidWZbMV0sIDEpOworCXR1bmVyX2kyY194ZmVyX3NlbmRfcmVjdigmcHJpdi0+aTJjX3Byb3BzLCAmYnVmWzBdLCAxLCAmYnVmWzFdLCAxKTsKIAogCWlmIChlbmFibGUpCiAJCWJ1ZlsxXSAmPSB+MHg0MDsKQEAgLTM3MCwxMCArMzczLDEwIEBACiAJdW5zaWduZWQgY2hhciBzZXRfZ3Bpb19jZltdICAgID0geyAweDQ0LCAweDAwIH07CiAJdW5zaWduZWQgY2hhciBzZXRfZ3Bpb192YWxbXSAgID0geyAweDQ2LCAweDAwIH07CiAKLQl0dW5lcl9pMmNfeGZlcl9zZW5kKCZwcml2LT5pMmNfcHJvcHMsICZzZXRfZ3Bpb19jZlswXSwgMSk7Ci0JdHVuZXJfaTJjX3hmZXJfcmVjdigmcHJpdi0+aTJjX3Byb3BzLCAmc2V0X2dwaW9fY2ZbMV0sIDEpOwotCXR1bmVyX2kyY194ZmVyX3NlbmQoJnByaXYtPmkyY19wcm9wcywgJnNldF9ncGlvX3ZhbFswXSwgMSk7Ci0JdHVuZXJfaTJjX3hmZXJfcmVjdigmcHJpdi0+aTJjX3Byb3BzLCAmc2V0X2dwaW9fdmFsWzFdLCAxKTsKKwl0dW5lcl9pMmNfeGZlcl9zZW5kX3JlY3YoJnByaXYtPmkyY19wcm9wcywKKwkJCQkgJnNldF9ncGlvX2NmWzBdLCAxLCAmc2V0X2dwaW9fY2ZbMV0sIDEpOworCXR1bmVyX2kyY194ZmVyX3NlbmRfcmVjdigmcHJpdi0+aTJjX3Byb3BzLAorCQkJCSAmc2V0X2dwaW9fdmFsWzBdLCAxLCAmc2V0X2dwaW9fdmFsWzFdLCAxKTsKIAogCXNldF9ncGlvX2NmWzFdICY9IDB4ZjA7IC8qIGNsZWFyIEdQSU9fMCBiaXRzIDMtMCAqLwogCkBAIC0zOTIsOCArMzk1LDcgQEAKIAl1bnNpZ25lZCBjaGFyIGh2cGxsX3N0YXQgPSAweDI2OwogCXVuc2lnbmVkIGNoYXIgcmV0OwogCi0JdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCAmaHZwbGxfc3RhdCwgMSk7Ci0JdHVuZXJfaTJjX3hmZXJfcmVjdigmcHJpdi0+aTJjX3Byb3BzLCAmcmV0LCAxKTsKKwl0dW5lcl9pMmNfeGZlcl9zZW5kX3JlY3YoJnByaXYtPmkyY19wcm9wcywgJmh2cGxsX3N0YXQsIDEsICZyZXQsIDEpOwogCXJldHVybiAocmV0ICYgMHgwMSkgPyA2NTUzNSA6IDA7CiB9CiAKQEAgLTQxMyw4ICs0MTUsOCBAQAogCXRkYTgyOTVfcG93ZXIoZmUsIDEpOwogCXRkYTgyOTVfYWdjMV9vdXQoZmUsIDEpOwogCi0JdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCAmYmxhbmtpbmdfbW9kZVswXSwgMSk7Ci0JdHVuZXJfaTJjX3hmZXJfcmVjdigmcHJpdi0+aTJjX3Byb3BzLCAmYmxhbmtpbmdfbW9kZVsxXSwgMSk7CisJdHVuZXJfaTJjX3hmZXJfc2VuZF9yZWN2KCZwcml2LT5pMmNfcHJvcHMsCisJCQkJICZibGFua2luZ19tb2RlWzBdLCAxLCAmYmxhbmtpbmdfbW9kZVsxXSwgMSk7CiAKIAl0ZGE4Mjk1X3NldF92aWRlb19zdGQoZmUpOwogCkBAIC00NDcsOCArNDQ5LDggQEAKIAl1bnNpZ25lZCBjaGFyIGkyY19nZXRfYWZjWzFdID0geyAweDFCIH07CiAJdW5zaWduZWQgY2hhciBhZmMgPSAwOwogCi0JdHVuZXJfaTJjX3hmZXJfc2VuZCgmcHJpdi0+aTJjX3Byb3BzLCBpMmNfZ2V0X2FmYywgQVJSQVlfU0laRShpMmNfZ2V0X2FmYykpOwotCXR1bmVyX2kyY194ZmVyX3JlY3YoJnByaXYtPmkyY19wcm9wcywgJmFmYywgMSk7CisJdHVuZXJfaTJjX3hmZXJfc2VuZF9yZWN2KCZwcml2LT5pMmNfcHJvcHMsCisJCQkJIGkyY19nZXRfYWZjLCBBUlJBWV9TSVpFKGkyY19nZXRfYWZjKSwgJmFmYywgMSk7CiAJcmV0dXJuIChhZmMgJiAweDgwKT8gNjU1MzU6MDsKIH0KIApAQCAtNjU0LDIwICs2NTYsMjYgQEAKIHN0YXRpYyBpbnQgdGRhODI5MF9wcm9iZShzdHJ1Y3QgdHVuZXJfaTJjX3Byb3BzICppMmNfcHJvcHMpCiB7CiAjZGVmaW5lIFREQTgyOTBfSUQgMHg4OQotCXVuc2lnbmVkIGNoYXIgdGRhODI5MF9pZFtdID0geyAweDFmLCAweDAwIH07CisJdTggcmVnID0gMHgxZiwgaWQ7CisJc3RydWN0IGkyY19tc2cgbXNnX3JlYWRbXSA9IHsKKwkJeyAuYWRkciA9IDB4NGIsIC5mbGFncyA9IDAsIC5sZW4gPSAxLCAuYnVmID0gJnJlZyB9LAorCQl7IC5hZGRyID0gMHg0YiwgLmZsYWdzID0gSTJDX01fUkQsIC5sZW4gPSAxLCAuYnVmID0gJmlkIH0sCisJfTsKIAogCS8qIGRldGVjdCB0ZGE4MjkwICovCi0JdHVuZXJfaTJjX3hmZXJfc2VuZChpMmNfcHJvcHMsICZ0ZGE4MjkwX2lkWzBdLCAxKTsKLQl0dW5lcl9pMmNfeGZlcl9yZWN2KGkyY19wcm9wcywgJnRkYTgyOTBfaWRbMV0sIDEpOworCWlmIChpMmNfdHJhbnNmZXIoaTJjX3Byb3BzLT5hZGFwLCBtc2dfcmVhZCwgMikgIT0gMikgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICIlczogdGRhODI5MCBjb3VsZG4ndCByZWFkIHJlZ2lzdGVyIDB4JTAyeFxuIiwKKwkJCSAgICAgICBfX2Z1bmNfXywgcmVnKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQogCi0JaWYgKHRkYTgyOTBfaWRbMV0gPT0gVERBODI5MF9JRCkgeworCWlmIChpZCA9PSBUREE4MjkwX0lEKSB7CiAJCWlmIChkZWJ1ZykKIAkJCXByaW50ayhLRVJOX0RFQlVHICIlczogdGRhODI5MCBkZXRlY3RlZCBAICVkLSUwNHhcbiIsCiAJCQkgICAgICAgX19mdW5jX18sIGkyY19hZGFwdGVyX2lkKGkyY19wcm9wcy0+YWRhcCksCiAJCQkgICAgICAgaTJjX3Byb3BzLT5hZGRyKTsKIAkJcmV0dXJuIDA7CiAJfQotCiAJcmV0dXJuIC1FTk9ERVY7CiB9CiAKQEAgLTY3NSwxNiArNjgzLDIzIEBACiB7CiAjZGVmaW5lIFREQTgyOTVfSUQgMHg4YQogI2RlZmluZSBUREE4Mjk1QzJfSUQgMHg4YgotCXVuc2lnbmVkIGNoYXIgdGRhODI5NV9pZFtdID0geyAweDJmLCAweDAwIH07CisJdTggcmVnID0gMHgyZiwgaWQ7CisJc3RydWN0IGkyY19tc2cgbXNnX3JlYWRbXSA9IHsKKwkJeyAuYWRkciA9IDB4NGIsIC5mbGFncyA9IDAsIC5sZW4gPSAxLCAuYnVmID0gJnJlZyB9LAorCQl7IC5hZGRyID0gMHg0YiwgLmZsYWdzID0gSTJDX01fUkQsIC5sZW4gPSAxLCAuYnVmID0gJmlkIH0sCisJfTsKIAotCS8qIGRldGVjdCB0ZGE4Mjk1ICovCi0JdHVuZXJfaTJjX3hmZXJfc2VuZChpMmNfcHJvcHMsICZ0ZGE4Mjk1X2lkWzBdLCAxKTsKLQl0dW5lcl9pMmNfeGZlcl9yZWN2KGkyY19wcm9wcywgJnRkYTgyOTVfaWRbMV0sIDEpOworCS8qIGRldGVjdCB0ZGE4MjkwICovCisJaWYgKGkyY190cmFuc2ZlcihpMmNfcHJvcHMtPmFkYXAsIG1zZ19yZWFkLCAyKSAhPSAyKSB7CisJCXByaW50ayhLRVJOX1dBUk5JTkcgIiVzOiB0ZGE4MjkwIGNvdWxkbid0IHJlYWQgcmVnaXN0ZXIgMHglMDJ4XG4iLAorCQkJICAgICAgIF9fZnVuY19fLCByZWcpOworCQlyZXR1cm4gLUVOT0RFVjsKKwl9CiAKLQlpZiAoKHRkYTgyOTVfaWRbMV0gJiAweGZlKSA9PSBUREE4Mjk1X0lEKSB7CisJaWYgKChpZCAmIDB4ZmUpID09IFREQTgyOTVfSUQpIHsKIAkJaWYgKGRlYnVnKQogCQkJcHJpbnRrKEtFUk5fREVCVUcgIiVzOiAlcyBkZXRlY3RlZCBAICVkLSUwNHhcbiIsCi0JCQkgICAgICAgX19mdW5jX18sICh0ZGE4Mjk1X2lkWzFdID09IFREQTgyOTVfSUQpID8KKwkJCSAgICAgICBfX2Z1bmNfXywgKGlkID09IFREQTgyOTVfSUQpID8KIAkJCSAgICAgICAidGRhODI5NWMxIiA6ICJ0ZGE4Mjk1YzIiLAogCQkJICAgICAgIGkyY19hZGFwdGVyX2lkKGkyY19wcm9wcy0+YWRhcCksCiAJCQkgICAgICAgaTJjX3Byb3BzLT5hZGRyKTsKQEAgLTc0MCw5ICs3NTUsMTEgQEAKIAkJICAgICAgIHNpemVvZihzdHJ1Y3QgYW5hbG9nX2RlbW9kX29wcykpOwogCX0KIAotCWlmICgoIShjZmcpIHx8IChUREE4MjlYX1BST0JFX1RVTkVSID09IGNmZy0+cHJvYmVfdHVuZXIpKSAmJgotCSAgICAodGRhODI5eF9maW5kX3R1bmVyKGZlKSA8IDApKQotCQlnb3RvIGZhaWw7CisJaWYgKCEoY2ZnKSB8fCAoVERBODI5WF9QUk9CRV9UVU5FUiA9PSBjZmctPnByb2JlX3R1bmVyKSkgeworCQl0ZGE4Mjk1X3Bvd2VyKGZlLCAxKTsKKwkJaWYgKHRkYTgyOXhfZmluZF90dW5lcihmZSkgPCAwKQorCQkJZ290byBmYWlsOworCX0KIAogCXN3aXRjaCAocHJpdi0+dmVyKSB7CiAJY2FzZSBUREE4MjkwOgpAQCAtNzg2LDYgKzgwMyw4IEBACiAJcmV0dXJuIGZlOwogCiBmYWlsOgorCW1lbXNldCgmZmUtPm9wcy5hbmFsb2dfb3BzLCAwLCBzaXplb2Yoc3RydWN0IGFuYWxvZ19kZW1vZF9vcHMpKTsKKwogCXRkYTgyOXhfcmVsZWFzZShmZSk7CiAJcmV0dXJuIE5VTEw7CiB9CkBAIC04MDksOCArODI4LDggQEAKIAlpbnQgaTsKIAogCS8qIHJ1bGUgb3V0IHRkYTk4ODcsIHdoaWNoIHdvdWxkIHJldHVybiB0aGUgc2FtZSBieXRlIHJlcGVhdGVkbHkgKi8KLQl0dW5lcl9pMmNfeGZlcl9zZW5kKCZpMmNfcHJvcHMsIHNvZnRfcmVzZXQsIDEpOwotCXR1bmVyX2kyY194ZmVyX3JlY3YoJmkyY19wcm9wcywgYnVmLCBQUk9CRV9CVUZGRVJfU0laRSk7CisJdHVuZXJfaTJjX3hmZXJfc2VuZF9yZWN2KCZpMmNfcHJvcHMsCisJCQkJIHNvZnRfcmVzZXQsIDEsIGJ1ZiwgUFJPQkVfQlVGRkVSX1NJWkUpOwogCWZvciAoaSA9IDE7IGkgPCBQUk9CRV9CVUZGRVJfU0laRTsgaSsrKSB7CiAJCWlmIChidWZbaV0gIT0gYnVmWzBdKQogCQkJYnJlYWs7CkBAIC04MjcsMTMgKzg0NiwxMiBAQAogCS8qIGZhbGwgYmFjayB0byBvbGQgcHJvYmluZyBtZXRob2QgKi8KIAl0dW5lcl9pMmNfeGZlcl9zZW5kKCZpMmNfcHJvcHMsIGVhc3lfbW9kZV9iLCAyKTsKIAl0dW5lcl9pMmNfeGZlcl9zZW5kKCZpMmNfcHJvcHMsIHNvZnRfcmVzZXQsIDIpOwotCXR1bmVyX2kyY194ZmVyX3NlbmQoJmkyY19wcm9wcywgJmFkZHJfZHRvX2xzYiwgMSk7Ci0JdHVuZXJfaTJjX3hmZXJfcmVjdigmaTJjX3Byb3BzLCAmZGF0YSwgMSk7CisJdHVuZXJfaTJjX3hmZXJfc2VuZF9yZWN2KCZpMmNfcHJvcHMsICZhZGRyX2R0b19sc2IsIDEsICZkYXRhLCAxKTsKIAlpZiAoZGF0YSA9PSAwKSB7CiAJCXR1bmVyX2kyY194ZmVyX3NlbmQoJmkyY19wcm9wcywgZWFzeV9tb2RlX2csIDIpOwogCQl0dW5lcl9pMmNfeGZlcl9zZW5kKCZpMmNfcHJvcHMsIHNvZnRfcmVzZXQsIDIpOwotCQl0dW5lcl9pMmNfeGZlcl9zZW5kKCZpMmNfcHJvcHMsICZhZGRyX2R0b19sc2IsIDEpOwotCQl0dW5lcl9pMmNfeGZlcl9yZWN2KCZpMmNfcHJvcHMsICZkYXRhLCAxKTsKKwkJdHVuZXJfaTJjX3hmZXJfc2VuZF9yZWN2KCZpMmNfcHJvcHMsCisJCQkJCSAmYWRkcl9kdG9fbHNiLCAxLCAmZGF0YSwgMSk7CiAJCWlmIChkYXRhID09IDB4N2IpIHsKIAkJCXJldHVybiAwOwogCQl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2R2Yi9kdmItdXNiL2RpYjA3MDBfY29yZS5jIGIvZHJpdmVycy9tZWRpYS9kdmIvZHZiLXVzYi9kaWIwNzAwX2NvcmUuYwppbmRleCA4Y2E0OGY3Li45OGZmYjQwIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9kdmItdXNiL2RpYjA3MDBfY29yZS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL2R2Yi11c2IvZGliMDcwMF9jb3JlLmMKQEAgLTUxNCw4ICs1MTQsOCBAQAogCXVuaW9uIHsKIAkJdTE2IHN5c3RlbTE2OwogCQlzdHJ1Y3QgewotCQkJdTggc3lzdGVtOwogCQkJdTggbm90X3N5c3RlbTsKKwkJCXU4IHN5c3RlbTsKIAkJfTsKIAl9OwogCXU4IGRhdGE7CkBAIC01NzUsNyArNTc1LDcgQEAKIAkJaWYgKChwb2xsX3JlcGx5LT5zeXN0ZW0gXiBwb2xsX3JlcGx5LT5ub3Rfc3lzdGVtKSAhPSAweGZmKSB7CiAJCQlkZWJfZGF0YSgiTkVDIGV4dGVuZGVkIHByb3RvY29sXG4iKTsKIAkJCS8qIE5FQyBleHRlbmRlZCBjb2RlIC0gMjQgYml0cyAqLwotCQkJa2V5Y29kZSA9IHBvbGxfcmVwbHktPnN5c3RlbTE2IDw8IDggfCBwb2xsX3JlcGx5LT5kYXRhOworCQkJa2V5Y29kZSA9IGJlMTZfdG9fY3B1KHBvbGxfcmVwbHktPnN5c3RlbTE2KSA8PCA4IHwgcG9sbF9yZXBseS0+ZGF0YTsKIAkJfSBlbHNlIHsKIAkJCWRlYl9kYXRhKCJORUMgbm9ybWFsIHByb3RvY29sXG4iKTsKIAkJCS8qIG5vcm1hbCBORUMgY29kZSAtIDE2IGJpdHMgKi8KQEAgLTU4Nyw3ICs1ODcsNyBAQAogCQlkZWJfZGF0YSgiUkM1IHByb3RvY29sXG4iKTsKIAkJLyogUkM1IFByb3RvY29sICovCiAJCXRvZ2dsZSA9IHBvbGxfcmVwbHktPnJlcG9ydF9pZDsKLQkJa2V5Y29kZSA9IHBvbGxfcmVwbHktPnN5c3RlbTE2IDw8IDggfCBwb2xsX3JlcGx5LT5kYXRhOworCQlrZXljb2RlID0gcG9sbF9yZXBseS0+c3lzdGVtIDw8IDggfCBwb2xsX3JlcGx5LT5kYXRhOwogCiAJCWJyZWFrOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL2ZpcmV3aXJlL2ZpcmVkdHYtcmMuYyBiL2RyaXZlcnMvbWVkaWEvZHZiL2ZpcmV3aXJlL2ZpcmVkdHYtcmMuYwppbmRleCBmY2YzODI4Li5mODJkNGE5IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9maXJld2lyZS9maXJlZHR2LXJjLmMKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvZmlyZXdpcmUvZmlyZWR0di1yYy5jCkBAIC0xNzIsNyArMTcyLDggQEAKIAogdm9pZCBmZHR2X2hhbmRsZV9yYyhzdHJ1Y3QgZmlyZWR0diAqZmR0diwgdW5zaWduZWQgaW50IGNvZGUpCiB7Ci0JdTE2ICprZXljb2RlID0gZmR0di0+cmVtb3RlX2N0cmxfZGV2LT5rZXljb2RlOworCXN0cnVjdCBpbnB1dF9kZXYgKmlkZXYgPSBmZHR2LT5yZW1vdGVfY3RybF9kZXY7CisJdTE2ICprZXljb2RlID0gaWRldi0+a2V5Y29kZTsKIAogCWlmIChjb2RlID49IDB4MDMwMCAmJiBjb2RlIDw9IDB4MDMxZikKIAkJY29kZSA9IGtleWNvZGVbY29kZSAtIDB4MDMwMF07CkBAIC0xODgsNiArMTg5LDggQEAKIAkJcmV0dXJuOwogCX0KIAotCWlucHV0X3JlcG9ydF9rZXkoZmR0di0+cmVtb3RlX2N0cmxfZGV2LCBjb2RlLCAxKTsKLQlpbnB1dF9yZXBvcnRfa2V5KGZkdHYtPnJlbW90ZV9jdHJsX2RldiwgY29kZSwgMCk7CisJaW5wdXRfcmVwb3J0X2tleShpZGV2LCBjb2RlLCAxKTsKKwlpbnB1dF9zeW5jKGlkZXYpOworCWlucHV0X3JlcG9ydF9rZXkoaWRldiwgY29kZSwgMCk7CisJaW5wdXRfc3luYyhpZGV2KTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9LY29uZmlnIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL0tjb25maWcKaW5kZXggZWYzZTQzYS4uYjg1MTliYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL0tjb25maWcKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL0tjb25maWcKQEAgLTEsNyArMSw3IEBACiBjb25maWcgRFZCX0ZFX0NVU1RPTUlTRQogCWJvb2wgIkN1c3RvbWlzZSB0aGUgZnJvbnRlbmQgbW9kdWxlcyB0byBidWlsZCIKIAlkZXBlbmRzIG9uIERWQl9DT1JFCi0JZGVmYXVsdCB5IGlmIEVNQkVEREVECisJZGVmYXVsdCB5IGlmIEVYUEVSVAogCWhlbHAKIAkgIFRoaXMgYWxsb3dzIHRoZSB1c2VyIHRvIHNlbGVjdC9kZXNlbGVjdCBmcm9udGVuZCBkcml2ZXJzIGZvciB0aGVpcgogCSAgaGFyZHdhcmUgZnJvbSB0aGUgYnVpbGQuCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvYWY5MDEzLmMgYi9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvYWY5MDEzLmMKaW5kZXggY2UyMjIwNS4uYmEyNWZhMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL2FmOTAxMy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9hZjkwMTMuYwpAQCAtMzM0LDExICszMzQsMTEgQEAKIAkJCQlpZl9zYW1wbGVfZnJlcSA9IDMzMDAwMDA7IC8qIDMuMyBNSHogKi8KIAkJCQlicmVhazsKIAkJCWNhc2UgQkFORFdJRFRIXzdfTUhaOgotCQkJCWlmX3NhbXBsZV9mcmVxID0gMzgwMDAwMDsgLyogMy44IE1IeiAqLworCQkJCWlmX3NhbXBsZV9mcmVxID0gMzUwMDAwMDsgLyogMy41IE1IeiAqLwogCQkJCWJyZWFrOwogCQkJY2FzZSBCQU5EV0lEVEhfOF9NSFo6CiAJCQlkZWZhdWx0OgotCQkJCWlmX3NhbXBsZV9mcmVxID0gNDMwMDAwMDsgLyogNC4zIE1IeiAqLworCQkJCWlmX3NhbXBsZV9mcmVxID0gNDAwMDAwMDsgLyogNC4wIE1IeiAqLwogCQkJCWJyZWFrOwogCQkJfQogCQl9IGVsc2UgaWYgKHN0YXRlLT5jb25maWcudHVuZXIgPT0gQUY5MDEzX1RVTkVSX1REQTE4MjE4KSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvaXgyNTA1di5jIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL2l4MjUwNXYuYwppbmRleCA2MzYwYzY4Li42YzJlOTI5IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL2R2Yi9mcm9udGVuZHMvaXgyNTA1di5jCisrKyBiL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9peDI1MDV2LmMKQEAgLTMxMSw3ICszMTEsNyBAQAogCXJldHVybiBmZTsKIAogZXJyb3I6Ci0JaXgyNTA1dl9yZWxlYXNlKGZlKTsKKwlrZnJlZShzdGF0ZSk7CiAJcmV0dXJuIE5VTEw7CiB9CiBFWFBPUlRfU1lNQk9MKGl4MjUwNXZfYXR0YWNoKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL2Zyb250ZW5kcy9tYjg2YTIwcy5jIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL21iODZhMjBzLmMKaW5kZXggZDNhZDNlNy4uY2M0YWNkMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL21iODZhMjBzLmMKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvZnJvbnRlbmRzL21iODZhMjBzLmMKQEAgLTQzLDYgKzQzLDggQEAKIAljb25zdCBzdHJ1Y3QgbWI4NmEyMHNfY29uZmlnICpjb25maWc7CiAKIAlzdHJ1Y3QgZHZiX2Zyb250ZW5kIGZyb250ZW5kOworCisJYm9vbCBuZWVkX2luaXQ7CiB9OwogCiBzdHJ1Y3QgcmVnZGF0YSB7CkBAIC0zMTgsNyArMzIwLDcgQEAKIAogCXJjID0gaTJjX3RyYW5zZmVyKHN0YXRlLT5pMmMsICZtc2csIDEpOwogCWlmIChyYyAhPSAxKSB7Ci0JCXByaW50aygiJXM6IHdyaXRlcmVnIHJjb3IocmMgPT0gJWksIHJlZyA9PSAweCUwMngsIgorCQlwcmludGsoIiVzOiB3cml0ZXJlZyBlcnJvciAocmMgPT0gJWksIHJlZyA9PSAweCUwMngsIgogCQkJICIgZGF0YSA9PSAweCUwMngpXG4iLCBfX2Z1bmNfXywgcmMsIHJlZywgZGF0YSk7CiAJCXJldHVybiByYzsKIAl9CkBAIC0zNTMsNyArMzU1LDcgQEAKIAlyYyA9IGkyY190cmFuc2ZlcihzdGF0ZS0+aTJjLCBtc2csIDIpOwogCiAJaWYgKHJjICE9IDIpIHsKLQkJcmMoIiVzOiByZWc9MHgleCAocmNvcj0lZClcbiIsIF9fZnVuY19fLCByZWcsIHJjKTsKKwkJcmMoIiVzOiByZWc9MHgleCAoZXJyb3I9JWQpXG4iLCBfX2Z1bmNfXywgcmVnLCByYyk7CiAJCXJldHVybiByYzsKIAl9CiAKQEAgLTM4MiwyMyArMzg0LDMxIEBACiAJLyogSW5pdGlhbGl6ZSB0aGUgZnJvbnRlbmQgKi8KIAlyYyA9IG1iODZhMjBzX3dyaXRlcmVnZGF0YShzdGF0ZSwgbWI4NmEyMHNfaW5pdCk7CiAJaWYgKHJjIDwgMCkKLQkJcmV0dXJuIHJjOworCQlnb3RvIGVycjsKIAogCWlmICghc3RhdGUtPmNvbmZpZy0+aXNfc2VyaWFsKSB7CiAJCXJlZ0Q1ICY9IH4xOwogCiAJCXJjID0gbWI4NmEyMHNfd3JpdGVyZWcoc3RhdGUsIDB4NTAsIDB4ZDUpOwogCQlpZiAocmMgPCAwKQotCQkJcmV0dXJuIHJjOworCQkJZ290byBlcnI7CiAJCXJjID0gbWI4NmEyMHNfd3JpdGVyZWcoc3RhdGUsIDB4NTEsIHJlZ0Q1KTsKIAkJaWYgKHJjIDwgMCkKLQkJCXJldHVybiByYzsKKwkJCWdvdG8gZXJyOwogCX0KIAogCWlmIChmZS0+b3BzLmkyY19nYXRlX2N0cmwpCiAJCWZlLT5vcHMuaTJjX2dhdGVfY3RybChmZSwgMSk7CiAKLQlyZXR1cm4gMDsKK2VycjoKKwlpZiAocmMgPCAwKSB7CisJCXN0YXRlLT5uZWVkX2luaXQgPSB0cnVlOworCQlwcmludGsoS0VSTl9JTkZPICJtYjg2YTIwczogSW5pdCBmYWlsZWQuIFdpbGwgdHJ5IGFnYWluIGxhdGVyXG4iKTsKKwl9IGVsc2UgeworCQlzdGF0ZS0+bmVlZF9pbml0ID0gZmFsc2U7CisJCWRwcmludGsoIkluaXRpYWxpemF0aW9uIHN1Y2NlZGVkLlxuIik7CisJfQorCXJldHVybiByYzsKIH0KIAogc3RhdGljIGludCBtYjg2YTIwc19yZWFkX3NpZ25hbF9zdHJlbmd0aChzdHJ1Y3QgZHZiX2Zyb250ZW5kICpmZSwgdTE2ICpzdHJlbmd0aCkKQEAgLTQ4NSw4ICs0OTUsMjIgQEAKIAogCWlmIChmZS0+b3BzLmkyY19nYXRlX2N0cmwpCiAJCWZlLT5vcHMuaTJjX2dhdGVfY3RybChmZSwgMSk7CisJZHByaW50aygiQ2FsbGluZyB0dW5lciBzZXQgcGFyYW1ldGVyc1xuIik7CiAJZmUtPm9wcy50dW5lcl9vcHMuc2V0X3BhcmFtcyhmZSwgcCk7CiAKKwkvKgorCSAqIE1ha2UgaXQgbW9yZSByZWxpYWJsZTogaWYsIGZvciBzb21lIHJlYXNvbiwgdGhlIGluaXRpYWwKKwkgKiBkZXZpY2UgaW5pdGlhbGl6YXRpb24gZG9lc24ndCBoYXBwZW4sIGluaXRpYWxpemUgaXQgd2hlbgorCSAqIGEgU0JUVkQgcGFyYW1ldGVycyBhcmUgYWRqdXN0ZWQuCisJICoKKwkgKiBVbmZvcnR1bmF0ZWx5LCBkdWUgdG8gYSBoYXJkIHRvIHRyYWNrIGJ1ZyBhdCB0ZGE4Mjl4L3RkYTE4MjcxLAorCSAqIHRoZSBhZ2MgY2FsbGJhY2sgbG9naWMgaXMgbm90IGNhbGxlZCBkdXJpbmcgRFZCIGF0dGFjaCB0aW1lLAorCSAqIGNhdXNpbmcgbWI4NmEyMHMgdG8gbm90IGJlIGluaXRpYWxpemVkIHdpdGggS3dvcmxkIFNCVFZELgorCSAqIFNvLCB0aGlzIGhhY2sgaXMgbmVlZGVkLCBpbiBvcmRlciB0byBtYWtlIEt3b3JsZCBTQlRWRCB0byB3b3JrLgorCSAqLworCWlmIChzdGF0ZS0+bmVlZF9pbml0KQorCQltYjg2YTIwc19pbml0ZmUoZmUpOworCiAJaWYgKGZlLT5vcHMuaTJjX2dhdGVfY3RybCkKIAkJZmUtPm9wcy5pMmNfZ2F0ZV9jdHJsKGZlLCAwKTsKIAlyYyA9IG1iODZhMjBzX3dyaXRlcmVnZGF0YShzdGF0ZSwgbWI4NmEyMHNfcmVzZXRfcmVjZXB0aW9uKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvZHZiL3R0cGNpL2F2NzExMF9jYS5jIGIvZHJpdmVycy9tZWRpYS9kdmIvdHRwY2kvYXY3MTEwX2NhLmMKaW5kZXggMTIyYzcyOC4uOWZjMWRkMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9kdmIvdHRwY2kvYXY3MTEwX2NhLmMKKysrIGIvZHJpdmVycy9tZWRpYS9kdmIvdHRwY2kvYXY3MTEwX2NhLmMKQEAgLTI3Nyw3ICsyNzcsNyBAQAogCXsKIAkJY2Ffc2xvdF9pbmZvX3QgKmluZm89KGNhX3Nsb3RfaW5mb190ICopcGFyZzsKIAotCQlpZiAoaW5mby0+bnVtID4gMSkKKwkJaWYgKGluZm8tPm51bSA8IDAgfHwgaW5mby0+bnVtID4gMSkKIAkJCXJldHVybiAtRUlOVkFMOwogCQlhdjcxMTAtPmNpX3Nsb3RbaW5mby0+bnVtXS5udW0gPSBpbmZvLT5udW07CiAJCWF2NzExMC0+Y2lfc2xvdFtpbmZvLT5udW1dLnR5cGUgPSBGV19DSV9MTF9TVVBQT1JUKGF2NzExMC0+YXJtX2FwcCkgPwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9yYWRpby9LY29uZmlnIGIvZHJpdmVycy9tZWRpYS9yYWRpby9LY29uZmlnCmluZGV4IDNjNWE0NzMuLmVjZGZmYTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcmFkaW8vS2NvbmZpZworKysgYi9kcml2ZXJzL21lZGlhL3JhZGlvL0tjb25maWcKQEAgLTE1MSwyMCArMTUxLDYgQEAKIAkgIGZvbGxvd2luZyBwb3J0cyB3aWxsIGJlIHByb2JlZDogMHgyMGMsIDB4MzBjLCAweDI0YywgMHgzNGMsIDB4MjQ4IGFuZAogCSAgMHgyOGMuCiAKLWNvbmZpZyBSQURJT19HRU1URUtfUENJCi0JdHJpc3RhdGUgIkdlbVRlayBQQ0kgUmFkaW8gQ2FyZCBzdXBwb3J0IgotCWRlcGVuZHMgb24gVklERU9fVjRMMiAmJiBQQ0kKLQktLS1oZWxwLS0tCi0JICBDaG9vc2UgWSBoZXJlIGlmIHlvdSBoYXZlIHRoaXMgUENJIEZNIHJhZGlvIGNhcmQuCi0KLQkgIEluIG9yZGVyIHRvIGNvbnRyb2wgeW91ciByYWRpbyBjYXJkLCB5b3Ugd2lsbCBuZWVkIHRvIHVzZSBwcm9ncmFtcwotCSAgdGhhdCBhcmUgY29tcGF0aWJsZSB3aXRoIHRoZSBWaWRlbyBmb3IgTGludXggQVBJLiAgSW5mb3JtYXRpb24gb24KLQkgIHRoaXMgQVBJIGFuZCBwb2ludGVycyB0byAidjRsIiBwcm9ncmFtcyBtYXkgYmUgZm91bmQgYXQKLQkgIDxmaWxlOkRvY3VtZW50YXRpb24vdmlkZW80bGludXgvQVBJLmh0bWw+LgotCi0JICBUbyBjb21waWxlIHRoaXMgZHJpdmVyIGFzIGEgbW9kdWxlLCBjaG9vc2UgTSBoZXJlOiB0aGUKLQkgIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCByYWRpby1nZW10ZWstcGNpLgotCiBjb25maWcgUkFESU9fTUFYSVJBRElPCiAJdHJpc3RhdGUgIkd1aWxsZW1vdCBNQVhJIFJhZGlvIEZNIDIwMDAgcmFkaW8iCiAJZGVwZW5kcyBvbiBWSURFT19WNEwyICYmIFBDSQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9yYWRpby9NYWtlZmlsZSBiL2RyaXZlcnMvbWVkaWEvcmFkaW8vTWFrZWZpbGUKaW5kZXggZDI5NzA3NC4uNzE3NjU2ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9yYWRpby9NYWtlZmlsZQorKysgYi9kcml2ZXJzL21lZGlhL3JhZGlvL01ha2VmaWxlCkBAIC0xMyw3ICsxMyw2IEBACiBvYmotJChDT05GSUdfUkFESU9fUlRSQUNLKSArPSByYWRpby1haW1zbGFiLm8KIG9iai0kKENPTkZJR19SQURJT19aT0xUUklYKSArPSByYWRpby16b2x0cml4Lm8KIG9iai0kKENPTkZJR19SQURJT19HRU1URUspICs9IHJhZGlvLWdlbXRlay5vCi1vYmotJChDT05GSUdfUkFESU9fR0VNVEVLX1BDSSkgKz0gcmFkaW8tZ2VtdGVrLXBjaS5vCiBvYmotJChDT05GSUdfUkFESU9fVFJVU1QpICs9IHJhZGlvLXRydXN0Lm8KIG9iai0kKENPTkZJR19JMkNfU0k0NzEzKSArPSBzaTQ3MTMtaTJjLm8KIG9iai0kKENPTkZJR19SQURJT19TSTQ3MTMpICs9IHJhZGlvLXNpNDcxMy5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3JhZGlvL3JhZGlvLWFpbXNsYWIuYyBiL2RyaXZlcnMvbWVkaWEvcmFkaW8vcmFkaW8tYWltc2xhYi5jCmluZGV4IDZjYzVkMTMuLjRjZTEwZGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcmFkaW8vcmFkaW8tYWltc2xhYi5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcmFkaW8vcmFkaW8tYWltc2xhYi5jCkBAIC0zMSw2ICszMSw3IEBACiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CS8qIE1vZHVsZXMgCQkJKi8KICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CQkvKiBJbml0ZGF0YQkJCSovCiAjaW5jbHVkZSA8bGludXgvaW9wb3J0Lmg+CS8qIHJlcXVlc3RfcmVnaW9uCQkqLworI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CS8qIG1zbGVlcAkJCSovCiAjaW5jbHVkZSA8bGludXgvdmlkZW9kZXYyLmg+CS8qIGtlcm5lbCByYWRpbyBzdHJ1Y3RzCQkqLwogI2luY2x1ZGUgPGxpbnV4L3ZlcnNpb24uaD4JLyogZm9yIEtFUk5FTF9WRVJTSU9OIE1BQ1JPCSovCiAjaW5jbHVkZSA8bGludXgvaW8uaD4JCS8qIG91dGIsIG91dGJfcAkJCSovCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3JhZGlvL3JhZGlvLWdlbXRlay1wY2kuYyBiL2RyaXZlcnMvbWVkaWEvcmFkaW8vcmFkaW8tZ2VtdGVrLXBjaS5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAyOGZhODViLi4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvbWVkaWEvcmFkaW8vcmFkaW8tZ2VtdGVrLXBjaS5jCisrKyAvZGV2L251bGwKQEAgLTEsNDc4ICswLDAgQEAKLS8qCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKgotICogICAgIHJhZGlvLWdlbXRlay1wY2kuYyAtIEdlbXRlayBQQ0kgUmFkaW8gZHJpdmVyCi0gKiAgICAgKEMpIDIwMDEgVmxhZGltaXIgU2hlYm9yZGFldiA8dnNoZWJvcmRhZXZAbWFpbC5ydT4KLSAqCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKgotICogICAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKLSAqICAgICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcwotICogICAgIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mCi0gKiAgICAgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogICAgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogICAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiAgICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogICAgIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogICAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYwotICogICAgIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUKLSAqICAgICBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA2NzUgTWFzcyBBdmUsIENhbWJyaWRnZSwgTUEgMDIxMzksCi0gKiAgICAgVVNBLgotICoKLSAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqCi0gKiAgICAgR2VtdGVrIENvcnAgc3RpbGwgc2lsZW50bHkgcmVmdXNlcyB0byByZWxlYXNlIGFueSBzcGVjaWZpY2F0aW9ucwotICogICAgIG9mIHRoZWlyIG11bHRpbWVkaWEgZGV2aWNlcywgc28gdGhlIHByb3RvY29sIHN0aWxsIGhhcyB0byBiZQotICogICAgIHJldmVyc2UgZW5naW5lZXJlZC4KLSAqCi0gKiAgICAgVGhlIHY0bCBjb2RlIHdhcyBpbnNwaXJlZCBieSBKb25hcyBNdW5zaW4ncyAgR2VtdGVrIHNlcmlhbCBsaW5lCi0gKiAgICAgcmFkaW8gZGV2aWNlIGRyaXZlci4KLSAqCi0gKiAgICAgUGxlYXNlLCBsZXQgbWUga25vdyBpZiB0aGlzIHBpZWNlIG9mIGNvZGUgd2FzIHVzZWZ1bCA6KQotICoKLSAqICAgICBUT0RPOiBtdWx0aXBsZSBkZXZpY2Ugc3VwcG9ydCBhbmQgcG9ydGFiaWxpdHkgd2VyZSBub3QgdGVzdGVkCi0gKgotICogICAgIENvbnZlcnRlZCB0byBWNEwyIEFQSSBieSBNYXVybyBDYXJ2YWxobyBDaGVoYWIgPG1jaGVoYWJAaW5mcmFkZWFkLm9yZz4KLSAqCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKi8KLQotI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+Ci0jaW5jbHVkZSA8bGludXgvbGlzdC5oPgotI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgotI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KLSNpbmNsdWRlIDxsaW51eC9wY2kuaD4KLSNpbmNsdWRlIDxsaW51eC92aWRlb2RldjIuaD4KLSNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgotI2luY2x1ZGUgPGxpbnV4L3ZlcnNpb24uaD4gICAgICAvKiBmb3IgS0VSTkVMX1ZFUlNJT04gTUFDUk8gICAgICovCi0jaW5jbHVkZSA8bGludXgvaW8uaD4KLSNpbmNsdWRlIDxsaW51eC9zbGFiLmg+Ci0jaW5jbHVkZSA8bWVkaWEvdjRsMi1kZXZpY2UuaD4KLSNpbmNsdWRlIDxtZWRpYS92NGwyLWlvY3RsLmg+Ci0KLU1PRFVMRV9BVVRIT1IoIlZsYWRpbWlyIFNoZWJvcmRhZXYgPHZzaGVib3JkYWV2QG1haWwucnU+Iik7Ci1NT0RVTEVfREVTQ1JJUFRJT04oIlRoZSB2aWRlbzRsaW51eCBkcml2ZXIgZm9yIHRoZSBHZW10ZWsgUENJIFJhZGlvIENhcmQiKTsKLU1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKLQotc3RhdGljIGludCBucl9yYWRpbyA9IC0xOwotc3RhdGljIGludCBteCA9IDE7Ci0KLW1vZHVsZV9wYXJhbShteCwgYm9vbCwgMCk7Ci1NT0RVTEVfUEFSTV9ERVNDKG14LCAic2luZ2xlIGRpZ2l0OiAxIC0gdHVybiBvZmYgdGhlIHR1cm5lciB1cG9uIG1vZHVsZSBleGl0IChkZWZhdWx0KSwgMCAtIGRvIG5vdCIpOwotbW9kdWxlX3BhcmFtKG5yX3JhZGlvLCBpbnQsIDApOwotTU9EVUxFX1BBUk1fREVTQyhucl9yYWRpbywgInZpZGVvNGxpbnV4IGRldmljZSBudW1iZXIgdG8gdXNlIik7Ci0KLSNkZWZpbmUgUkFESU9fVkVSU0lPTiBLRVJORUxfVkVSU0lPTigwLCAwLCAyKQotCi0jaWZuZGVmIFBDSV9WRU5ET1JfSURfR0VNVEVLCi0jZGVmaW5lIFBDSV9WRU5ET1JfSURfR0VNVEVLIDB4NTA0NgotI2VuZGlmCi0KLSNpZm5kZWYgUENJX0RFVklDRV9JRF9HRU1URUtfUFIxMDMKLSNkZWZpbmUgUENJX0RFVklDRV9JRF9HRU1URUtfUFIxMDMgMHgxMDAxCi0jZW5kaWYKLQotI2lmbmRlZiBHRU1URUtfUENJX1JBTkdFX0xPVwotI2RlZmluZSBHRU1URUtfUENJX1JBTkdFX0xPVyAoODcqMTYwMDApCi0jZW5kaWYKLQotI2lmbmRlZiBHRU1URUtfUENJX1JBTkdFX0hJR0gKLSNkZWZpbmUgR0VNVEVLX1BDSV9SQU5HRV9ISUdIICgxMDgqMTYwMDApCi0jZW5kaWYKLQotc3RydWN0IGdlbXRla19wY2kgewotCXN0cnVjdCB2NGwyX2RldmljZSB2NGwyX2RldjsKLQlzdHJ1Y3QgdmlkZW9fZGV2aWNlIHZkZXY7Ci0Jc3RydWN0IG11dGV4IGxvY2s7Ci0Jc3RydWN0IHBjaV9kZXYgKnBkZXY7Ci0KLQl1MzIgaW9iYXNlOwotCXUzMiBsZW5ndGg7Ci0KLQl1MzIgY3VycmVudF9mcmVxdWVuY3k7Ci0JdTggIG11dGU7Ci19OwotCi1zdGF0aWMgaW5saW5lIHN0cnVjdCBnZW10ZWtfcGNpICp0b19nZW10ZWtfcGNpKHN0cnVjdCB2NGwyX2RldmljZSAqdjRsMl9kZXYpCi17Ci0JcmV0dXJuIGNvbnRhaW5lcl9vZih2NGwyX2Rldiwgc3RydWN0IGdlbXRla19wY2ksIHY0bDJfZGV2KTsKLX0KLQotc3RhdGljIGlubGluZSB1OCBnZW10ZWtfcGNpX291dCh1MTYgdmFsdWUsIHUzMiBwb3J0KQotewotCW91dHcodmFsdWUsIHBvcnQpOwotCi0JcmV0dXJuICh1OCl2YWx1ZTsKLX0KLQotI2RlZmluZSBfYjAodikgKCooKHU4ICopJnYpKQotCi1zdGF0aWMgdm9pZCBfX2dlbXRla19wY2lfY21kKHUxNiB2YWx1ZSwgdTMyIHBvcnQsIHU4ICpsYXN0X2J5dGUsIGludCBrZWVwKQotewotCXU4IGJ5dGUgPSAqbGFzdF9ieXRlOwotCi0JaWYgKCF2YWx1ZSkgewotCQlpZiAoIWtlZXApCi0JCQl2YWx1ZSA9ICh1MTYpcG9ydDsKLQkJYnl0ZSAmPSAweGZkOwotCX0gZWxzZQotCQlieXRlIHw9IDI7Ci0KLQlfYjAodmFsdWUpID0gYnl0ZTsKLQlvdXR3KHZhbHVlLCBwb3J0KTsKLQlieXRlIHw9IDE7Ci0JX2IwKHZhbHVlKSA9IGJ5dGU7Ci0Jb3V0dyh2YWx1ZSwgcG9ydCk7Ci0JYnl0ZSAmPSAweGZlOwotCV9iMCh2YWx1ZSkgPSBieXRlOwotCW91dHcodmFsdWUsIHBvcnQpOwotCi0JKmxhc3RfYnl0ZSA9IGJ5dGU7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdm9pZCBnZW10ZWtfcGNpX25pbCh1MzIgcG9ydCwgdTggKmxhc3RfYnl0ZSkKLXsKLQlfX2dlbXRla19wY2lfY21kKDB4MDAsIHBvcnQsIGxhc3RfYnl0ZSwgZmFsc2UpOwotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQgZ2VtdGVrX3BjaV9jbWQodTE2IGNtZCwgdTMyIHBvcnQsIHU4ICpsYXN0X2J5dGUpCi17Ci0JX19nZW10ZWtfcGNpX2NtZChjbWQsIHBvcnQsIGxhc3RfYnl0ZSwgdHJ1ZSk7Ci19Ci0KLXN0YXRpYyB2b2lkIGdlbXRla19wY2lfc2V0ZnJlcXVlbmN5KHN0cnVjdCBnZW10ZWtfcGNpICpjYXJkLCB1bnNpZ25lZCBsb25nIGZyZXF1ZW5jeSkKLXsKLQlpbnQgaTsKLQl1MzIgdmFsdWUgPSBmcmVxdWVuY3kgLyAyMDAgKyA4NTY7Ci0JdTE2IG1hc2sgPSAweDgwMDA7Ci0JdTggbGFzdF9ieXRlOwotCXUzMiBwb3J0ID0gY2FyZC0+aW9iYXNlOwotCi0JbXV0ZXhfbG9jaygmY2FyZC0+bG9jayk7Ci0JY2FyZC0+Y3VycmVudF9mcmVxdWVuY3kgPSBmcmVxdWVuY3k7Ci0JbGFzdF9ieXRlID0gZ2VtdGVrX3BjaV9vdXQoMHgwNiwgcG9ydCk7Ci0KLQlpID0gMDsKLQlkbyB7Ci0JCWdlbXRla19wY2lfbmlsKHBvcnQsICZsYXN0X2J5dGUpOwotCQlpKys7Ci0JfSB3aGlsZSAoaSA8IDkpOwotCi0JaSA9IDA7Ci0JZG8gewotCQlnZW10ZWtfcGNpX2NtZCh2YWx1ZSAmIG1hc2ssIHBvcnQsICZsYXN0X2J5dGUpOwotCQltYXNrID4+PSAxOwotCQlpKys7Ci0JfSB3aGlsZSAoaSA8IDE2KTsKLQotCW91dHcoMHgxMCwgcG9ydCk7Ci0JbXV0ZXhfdW5sb2NrKCZjYXJkLT5sb2NrKTsKLX0KLQotCi1zdGF0aWMgdm9pZCBnZW10ZWtfcGNpX211dGUoc3RydWN0IGdlbXRla19wY2kgKmNhcmQpCi17Ci0JbXV0ZXhfbG9jaygmY2FyZC0+bG9jayk7Ci0Jb3V0YigweDFmLCBjYXJkLT5pb2Jhc2UpOwotCWNhcmQtPm11dGUgPSB0cnVlOwotCW11dGV4X3VubG9jaygmY2FyZC0+bG9jayk7Ci19Ci0KLXN0YXRpYyB2b2lkIGdlbXRla19wY2lfdW5tdXRlKHN0cnVjdCBnZW10ZWtfcGNpICpjYXJkKQotewotCWlmIChjYXJkLT5tdXRlKSB7Ci0JCWdlbXRla19wY2lfc2V0ZnJlcXVlbmN5KGNhcmQsIGNhcmQtPmN1cnJlbnRfZnJlcXVlbmN5KTsKLQkJY2FyZC0+bXV0ZSA9IGZhbHNlOwotCX0KLX0KLQotc3RhdGljIGludCBnZW10ZWtfcGNpX2dldHNpZ25hbChzdHJ1Y3QgZ2VtdGVrX3BjaSAqY2FyZCkKLXsKLQlpbnQgc2lnOwotCi0JbXV0ZXhfbG9jaygmY2FyZC0+bG9jayk7Ci0Jc2lnID0gKGluYihjYXJkLT5pb2Jhc2UpICYgMHgwOCkgPyAwIDogMTsKLQltdXRleF91bmxvY2soJmNhcmQtPmxvY2spOwotCXJldHVybiBzaWc7Ci19Ci0KLXN0YXRpYyBpbnQgdmlkaW9jX3F1ZXJ5Y2FwKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LAotCQkJCQlzdHJ1Y3QgdjRsMl9jYXBhYmlsaXR5ICp2KQotewotCXN0cnVjdCBnZW10ZWtfcGNpICpjYXJkID0gdmlkZW9fZHJ2ZGF0YShmaWxlKTsKLQotCXN0cmxjcHkodi0+ZHJpdmVyLCAicmFkaW8tZ2VtdGVrLXBjaSIsIHNpemVvZih2LT5kcml2ZXIpKTsKLQlzdHJsY3B5KHYtPmNhcmQsICJHZW1UZWsgUENJIFJhZGlvIiwgc2l6ZW9mKHYtPmNhcmQpKTsKLQlzbnByaW50Zih2LT5idXNfaW5mbywgc2l6ZW9mKHYtPmJ1c19pbmZvKSwgIlBDSTolcyIsIHBjaV9uYW1lKGNhcmQtPnBkZXYpKTsKLQl2LT52ZXJzaW9uID0gUkFESU9fVkVSU0lPTjsKLQl2LT5jYXBhYmlsaXRpZXMgPSBWNEwyX0NBUF9UVU5FUiB8IFY0TDJfQ0FQX1JBRElPOwotCXJldHVybiAwOwotfQotCi1zdGF0aWMgaW50IHZpZGlvY19nX3R1bmVyKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LAotCQkJCQlzdHJ1Y3QgdjRsMl90dW5lciAqdikKLXsKLQlzdHJ1Y3QgZ2VtdGVrX3BjaSAqY2FyZCA9IHZpZGVvX2RydmRhdGEoZmlsZSk7Ci0KLQlpZiAodi0+aW5kZXggPiAwKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCXN0cmxjcHkodi0+bmFtZSwgIkZNIiwgc2l6ZW9mKHYtPm5hbWUpKTsKLQl2LT50eXBlID0gVjRMMl9UVU5FUl9SQURJTzsKLQl2LT5yYW5nZWxvdyA9IEdFTVRFS19QQ0lfUkFOR0VfTE9XOwotCXYtPnJhbmdlaGlnaCA9IEdFTVRFS19QQ0lfUkFOR0VfSElHSDsKLQl2LT5yeHN1YmNoYW5zID0gVjRMMl9UVU5FUl9TVUJfTU9OTzsKLQl2LT5jYXBhYmlsaXR5ID0gVjRMMl9UVU5FUl9DQVBfTE9XOwotCXYtPmF1ZG1vZGUgPSBWNEwyX1RVTkVSX01PREVfTU9OTzsKLQl2LT5zaWduYWwgPSAweGZmZmYgKiBnZW10ZWtfcGNpX2dldHNpZ25hbChjYXJkKTsKLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIGludCB2aWRpb2Nfc190dW5lcihzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwKLQkJCQkJc3RydWN0IHY0bDJfdHVuZXIgKnYpCi17Ci0JcmV0dXJuIHYtPmluZGV4ID8gLUVJTlZBTCA6IDA7Ci19Ci0KLXN0YXRpYyBpbnQgdmlkaW9jX3NfZnJlcXVlbmN5KHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LAotCQkJCQlzdHJ1Y3QgdjRsMl9mcmVxdWVuY3kgKmYpCi17Ci0Jc3RydWN0IGdlbXRla19wY2kgKmNhcmQgPSB2aWRlb19kcnZkYXRhKGZpbGUpOwotCi0JaWYgKGYtPnR1bmVyICE9IDAgfHwgZi0+dHlwZSAhPSBWNEwyX1RVTkVSX1JBRElPKQotCQlyZXR1cm4gLUVJTlZBTDsKLQlpZiAoZi0+ZnJlcXVlbmN5IDwgR0VNVEVLX1BDSV9SQU5HRV9MT1cgfHwKLQkgICAgZi0+ZnJlcXVlbmN5ID4gR0VNVEVLX1BDSV9SQU5HRV9ISUdIKQotCQlyZXR1cm4gLUVJTlZBTDsKLQlnZW10ZWtfcGNpX3NldGZyZXF1ZW5jeShjYXJkLCBmLT5mcmVxdWVuY3kpOwotCWNhcmQtPm11dGUgPSBmYWxzZTsKLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIGludCB2aWRpb2NfZ19mcmVxdWVuY3koc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsCi0JCQkJCXN0cnVjdCB2NGwyX2ZyZXF1ZW5jeSAqZikKLXsKLQlzdHJ1Y3QgZ2VtdGVrX3BjaSAqY2FyZCA9IHZpZGVvX2RydmRhdGEoZmlsZSk7Ci0KLQlpZiAoZi0+dHVuZXIgIT0gMCkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0JZi0+dHlwZSA9IFY0TDJfVFVORVJfUkFESU87Ci0JZi0+ZnJlcXVlbmN5ID0gY2FyZC0+Y3VycmVudF9mcmVxdWVuY3k7Ci0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBpbnQgdmlkaW9jX3F1ZXJ5Y3RybChzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwKLQkJCQkJc3RydWN0IHY0bDJfcXVlcnljdHJsICpxYykKLXsKLQlzd2l0Y2ggKHFjLT5pZCkgewotCWNhc2UgVjRMMl9DSURfQVVESU9fTVVURToKLQkJcmV0dXJuIHY0bDJfY3RybF9xdWVyeV9maWxsKHFjLCAwLCAxLCAxLCAxKTsKLQljYXNlIFY0TDJfQ0lEX0FVRElPX1ZPTFVNRToKLQkJcmV0dXJuIHY0bDJfY3RybF9xdWVyeV9maWxsKHFjLCAwLCA2NTUzNSwgNjU1MzUsIDY1NTM1KTsKLQl9Ci0JcmV0dXJuIC1FSU5WQUw7Ci19Ci0KLXN0YXRpYyBpbnQgdmlkaW9jX2dfY3RybChzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwKLQkJCQkJc3RydWN0IHY0bDJfY29udHJvbCAqY3RybCkKLXsKLQlzdHJ1Y3QgZ2VtdGVrX3BjaSAqY2FyZCA9IHZpZGVvX2RydmRhdGEoZmlsZSk7Ci0KLQlzd2l0Y2ggKGN0cmwtPmlkKSB7Ci0JY2FzZSBWNEwyX0NJRF9BVURJT19NVVRFOgotCQljdHJsLT52YWx1ZSA9IGNhcmQtPm11dGU7Ci0JCXJldHVybiAwOwotCWNhc2UgVjRMMl9DSURfQVVESU9fVk9MVU1FOgotCQlpZiAoY2FyZC0+bXV0ZSkKLQkJCWN0cmwtPnZhbHVlID0gMDsKLQkJZWxzZQotCQkJY3RybC0+dmFsdWUgPSA2NTUzNTsKLQkJcmV0dXJuIDA7Ci0JfQotCXJldHVybiAtRUlOVkFMOwotfQotCi1zdGF0aWMgaW50IHZpZGlvY19zX2N0cmwoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsCi0JCQkJCXN0cnVjdCB2NGwyX2NvbnRyb2wgKmN0cmwpCi17Ci0Jc3RydWN0IGdlbXRla19wY2kgKmNhcmQgPSB2aWRlb19kcnZkYXRhKGZpbGUpOwotCi0Jc3dpdGNoIChjdHJsLT5pZCkgewotCWNhc2UgVjRMMl9DSURfQVVESU9fTVVURToKLQkJaWYgKGN0cmwtPnZhbHVlKQotCQkJZ2VtdGVrX3BjaV9tdXRlKGNhcmQpOwotCQllbHNlCi0JCQlnZW10ZWtfcGNpX3VubXV0ZShjYXJkKTsKLQkJcmV0dXJuIDA7Ci0JY2FzZSBWNEwyX0NJRF9BVURJT19WT0xVTUU6Ci0JCWlmIChjdHJsLT52YWx1ZSkKLQkJCWdlbXRla19wY2lfdW5tdXRlKGNhcmQpOwotCQllbHNlCi0JCQlnZW10ZWtfcGNpX211dGUoY2FyZCk7Ci0JCXJldHVybiAwOwotCX0KLQlyZXR1cm4gLUVJTlZBTDsKLX0KLQotc3RhdGljIGludCB2aWRpb2NfZ19pbnB1dChzdHJ1Y3QgZmlsZSAqZmlscCwgdm9pZCAqcHJpdiwgdW5zaWduZWQgaW50ICppKQotewotCSppID0gMDsKLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIGludCB2aWRpb2Nfc19pbnB1dChzdHJ1Y3QgZmlsZSAqZmlscCwgdm9pZCAqcHJpdiwgdW5zaWduZWQgaW50IGkpCi17Ci0JcmV0dXJuIGkgPyAtRUlOVkFMIDogMDsKLX0KLQotc3RhdGljIGludCB2aWRpb2NfZ19hdWRpbyhzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwKLQkJCQkJc3RydWN0IHY0bDJfYXVkaW8gKmEpCi17Ci0JYS0+aW5kZXggPSAwOwotCXN0cmxjcHkoYS0+bmFtZSwgIlJhZGlvIiwgc2l6ZW9mKGEtPm5hbWUpKTsKLQlhLT5jYXBhYmlsaXR5ID0gVjRMMl9BVURDQVBfU1RFUkVPOwotCXJldHVybiAwOwotfQotCi1zdGF0aWMgaW50IHZpZGlvY19zX2F1ZGlvKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LAotCQkJCQlzdHJ1Y3QgdjRsMl9hdWRpbyAqYSkKLXsKLQlyZXR1cm4gYS0+aW5kZXggPyAtRUlOVkFMIDogMDsKLX0KLQotZW51bSB7Ci0JR0VNVEVLX1BSMTAzCi19OwotCi1zdGF0aWMgY2hhciAqY2FyZF9uYW1lc1tdIF9fZGV2aW5pdGRhdGEgPSB7Ci0JIkdFTVRFS19QUjEwMyIKLX07Ci0KLXN0YXRpYyBzdHJ1Y3QgcGNpX2RldmljZV9pZCBnZW10ZWtfcGNpX2lkW10gPQotewotCXsgUENJX1ZFTkRPUl9JRF9HRU1URUssIFBDSV9ERVZJQ0VfSURfR0VNVEVLX1BSMTAzLAotCSAgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwgMCwgMCwgR0VNVEVLX1BSMTAzIH0sCi0JeyAwIH0KLX07Ci0KLU1PRFVMRV9ERVZJQ0VfVEFCTEUocGNpLCBnZW10ZWtfcGNpX2lkKTsKLQotc3RhdGljIGNvbnN0IHN0cnVjdCB2NGwyX2ZpbGVfb3BlcmF0aW9ucyBnZW10ZWtfcGNpX2ZvcHMgPSB7Ci0JLm93bmVyCQk9IFRISVNfTU9EVUxFLAotCS51bmxvY2tlZF9pb2N0bAk9IHZpZGVvX2lvY3RsMiwKLX07Ci0KLXN0YXRpYyBjb25zdCBzdHJ1Y3QgdjRsMl9pb2N0bF9vcHMgZ2VtdGVrX3BjaV9pb2N0bF9vcHMgPSB7Ci0JLnZpZGlvY19xdWVyeWNhcCAgICA9IHZpZGlvY19xdWVyeWNhcCwKLQkudmlkaW9jX2dfdHVuZXIgICAgID0gdmlkaW9jX2dfdHVuZXIsCi0JLnZpZGlvY19zX3R1bmVyICAgICA9IHZpZGlvY19zX3R1bmVyLAotCS52aWRpb2NfZ19hdWRpbyAgICAgPSB2aWRpb2NfZ19hdWRpbywKLQkudmlkaW9jX3NfYXVkaW8gICAgID0gdmlkaW9jX3NfYXVkaW8sCi0JLnZpZGlvY19nX2lucHV0ICAgICA9IHZpZGlvY19nX2lucHV0LAotCS52aWRpb2Nfc19pbnB1dCAgICAgPSB2aWRpb2Nfc19pbnB1dCwKLQkudmlkaW9jX2dfZnJlcXVlbmN5ID0gdmlkaW9jX2dfZnJlcXVlbmN5LAotCS52aWRpb2Nfc19mcmVxdWVuY3kgPSB2aWRpb2Nfc19mcmVxdWVuY3ksCi0JLnZpZGlvY19xdWVyeWN0cmwgICA9IHZpZGlvY19xdWVyeWN0cmwsCi0JLnZpZGlvY19nX2N0cmwgICAgICA9IHZpZGlvY19nX2N0cmwsCi0JLnZpZGlvY19zX2N0cmwgICAgICA9IHZpZGlvY19zX2N0cmwsCi19OwotCi1zdGF0aWMgaW50IF9fZGV2aW5pdCBnZW10ZWtfcGNpX3Byb2JlKHN0cnVjdCBwY2lfZGV2ICpwZGV2LCBjb25zdCBzdHJ1Y3QgcGNpX2RldmljZV9pZCAqcGNpX2lkKQotewotCXN0cnVjdCBnZW10ZWtfcGNpICpjYXJkOwotCXN0cnVjdCB2NGwyX2RldmljZSAqdjRsMl9kZXY7Ci0JaW50IHJlczsKLQotCWNhcmQgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgZ2VtdGVrX3BjaSksIEdGUF9LRVJORUwpOwotCWlmIChjYXJkID09IE5VTEwpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAib3V0IG9mIG1lbW9yeVxuIik7Ci0JCXJldHVybiAtRU5PTUVNOwotCX0KLQotCXY0bDJfZGV2ID0gJmNhcmQtPnY0bDJfZGV2OwotCW11dGV4X2luaXQoJmNhcmQtPmxvY2spOwotCWNhcmQtPnBkZXYgPSBwZGV2OwotCi0Jc3RybGNweSh2NGwyX2Rldi0+bmFtZSwgImdlbXRla19wY2kiLCBzaXplb2YodjRsMl9kZXYtPm5hbWUpKTsKLQotCXJlcyA9IHY0bDJfZGV2aWNlX3JlZ2lzdGVyKCZwZGV2LT5kZXYsIHY0bDJfZGV2KTsKLQlpZiAocmVzIDwgMCkgewotCQl2NGwyX2Vycih2NGwyX2RldiwgIkNvdWxkIG5vdCByZWdpc3RlciB2NGwyX2RldmljZVxuIik7Ci0JCWtmcmVlKGNhcmQpOwotCQlyZXR1cm4gcmVzOwotCX0KLQotCWlmIChwY2lfZW5hYmxlX2RldmljZShwZGV2KSkKLQkJZ290byBlcnJfcGNpOwotCi0JY2FyZC0+aW9iYXNlID0gcGNpX3Jlc291cmNlX3N0YXJ0KHBkZXYsIDApOwotCWNhcmQtPmxlbmd0aCA9IHBjaV9yZXNvdXJjZV9sZW4ocGRldiwgMCk7Ci0KLQlpZiAocmVxdWVzdF9yZWdpb24oY2FyZC0+aW9iYXNlLCBjYXJkLT5sZW5ndGgsIGNhcmRfbmFtZXNbcGNpX2lkLT5kcml2ZXJfZGF0YV0pID09IE5VTEwpIHsKLQkJdjRsMl9lcnIodjRsMl9kZXYsICJpL28gcG9ydCBhbHJlYWR5IGluIHVzZVxuIik7Ci0JCWdvdG8gZXJyX3BjaTsKLQl9Ci0KLQlzdHJsY3B5KGNhcmQtPnZkZXYubmFtZSwgdjRsMl9kZXYtPm5hbWUsIHNpemVvZihjYXJkLT52ZGV2Lm5hbWUpKTsKLQljYXJkLT52ZGV2LnY0bDJfZGV2ID0gdjRsMl9kZXY7Ci0JY2FyZC0+dmRldi5mb3BzID0gJmdlbXRla19wY2lfZm9wczsKLQljYXJkLT52ZGV2LmlvY3RsX29wcyA9ICZnZW10ZWtfcGNpX2lvY3RsX29wczsKLQljYXJkLT52ZGV2LnJlbGVhc2UgPSB2aWRlb19kZXZpY2VfcmVsZWFzZV9lbXB0eTsKLQl2aWRlb19zZXRfZHJ2ZGF0YSgmY2FyZC0+dmRldiwgY2FyZCk7Ci0KLQlnZW10ZWtfcGNpX211dGUoY2FyZCk7Ci0KLQlpZiAodmlkZW9fcmVnaXN0ZXJfZGV2aWNlKCZjYXJkLT52ZGV2LCBWRkxfVFlQRV9SQURJTywgbnJfcmFkaW8pIDwgMCkKLQkJZ290byBlcnJfdmlkZW87Ci0KLQl2NGwyX2luZm8odjRsMl9kZXYsICJHZW10ZWsgUENJIFJhZGlvIChyZXYuICVkKSBmb3VuZCBhdCAweCUwNHgtMHglMDR4LlxuIiwKLQkJcGRldi0+cmV2aXNpb24sIGNhcmQtPmlvYmFzZSwgY2FyZC0+aW9iYXNlICsgY2FyZC0+bGVuZ3RoIC0gMSk7Ci0KLQlyZXR1cm4gMDsKLQotZXJyX3ZpZGVvOgotCXJlbGVhc2VfcmVnaW9uKGNhcmQtPmlvYmFzZSwgY2FyZC0+bGVuZ3RoKTsKLQotZXJyX3BjaToKLQl2NGwyX2RldmljZV91bnJlZ2lzdGVyKHY0bDJfZGV2KTsKLQlrZnJlZShjYXJkKTsKLQlyZXR1cm4gLUVOT0RFVjsKLX0KLQotc3RhdGljIHZvaWQgX19kZXZleGl0IGdlbXRla19wY2lfcmVtb3ZlKHN0cnVjdCBwY2lfZGV2ICpwZGV2KQotewotCXN0cnVjdCB2NGwyX2RldmljZSAqdjRsMl9kZXYgPSBkZXZfZ2V0X2RydmRhdGEoJnBkZXYtPmRldik7Ci0Jc3RydWN0IGdlbXRla19wY2kgKmNhcmQgPSB0b19nZW10ZWtfcGNpKHY0bDJfZGV2KTsKLQotCXZpZGVvX3VucmVnaXN0ZXJfZGV2aWNlKCZjYXJkLT52ZGV2KTsKLQl2NGwyX2RldmljZV91bnJlZ2lzdGVyKHY0bDJfZGV2KTsKLQotCXJlbGVhc2VfcmVnaW9uKGNhcmQtPmlvYmFzZSwgY2FyZC0+bGVuZ3RoKTsKLQotCWlmIChteCkKLQkJZ2VtdGVrX3BjaV9tdXRlKGNhcmQpOwotCi0Ja2ZyZWUoY2FyZCk7Ci19Ci0KLXN0YXRpYyBzdHJ1Y3QgcGNpX2RyaXZlciBnZW10ZWtfcGNpX2RyaXZlciA9IHsKLQkubmFtZQkJPSAiZ2VtdGVrX3BjaSIsCi0JLmlkX3RhYmxlCT0gZ2VtdGVrX3BjaV9pZCwKLQkucHJvYmUJCT0gZ2VtdGVrX3BjaV9wcm9iZSwKLQkucmVtb3ZlCQk9IF9fZGV2ZXhpdF9wKGdlbXRla19wY2lfcmVtb3ZlKSwKLX07Ci0KLXN0YXRpYyBpbnQgX19pbml0IGdlbXRla19wY2lfaW5pdCh2b2lkKQotewotCXJldHVybiBwY2lfcmVnaXN0ZXJfZHJpdmVyKCZnZW10ZWtfcGNpX2RyaXZlcik7Ci19Ci0KLXN0YXRpYyB2b2lkIF9fZXhpdCBnZW10ZWtfcGNpX2V4aXQodm9pZCkKLXsKLQlwY2lfdW5yZWdpc3Rlcl9kcml2ZXIoJmdlbXRla19wY2lfZHJpdmVyKTsKLX0KLQotbW9kdWxlX2luaXQoZ2VtdGVrX3BjaV9pbml0KTsKLW1vZHVsZV9leGl0KGdlbXRla19wY2lfZXhpdCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3JhZGlvL3JhZGlvLW1heGlyYWRpby5jIGIvZHJpdmVycy9tZWRpYS9yYWRpby9yYWRpby1tYXhpcmFkaW8uYwppbmRleCA2NDU5YTIyLi41YzJhOTA1IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3JhZGlvL3JhZGlvLW1heGlyYWRpby5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcmFkaW8vcmFkaW8tbWF4aXJhZGlvLmMKQEAgLTc3LDggKzc3LDggQEAKIC8qIFRFQTU3NTcgcGluIG1hcHBpbmdzICovCiBzdGF0aWMgY29uc3QgaW50IGNsayA9IDEsIGRhdGEgPSAyLCB3cmVuID0gNCwgbW9fc3QgPSA4LCBwb3dlciA9IDE2OwogCi0jZGVmaW5lIEZSRVFfTE8JCSg1MCAqIDE2MDAwKQotI2RlZmluZSBGUkVRX0hJCQkoMTUwICogMTYwMDApCisjZGVmaW5lIEZSRVFfTE8JCSg4NyAqIDE2MDAwKQorI2RlZmluZSBGUkVRX0hJCQkoMTA4ICogMTYwMDApCiAKICNkZWZpbmUgRlJFUV9JRiAgICAgICAgIDE3MTIwMCAvKiAxMC43KjE2MDAwICAgKi8KICNkZWZpbmUgRlJFUV9TVEVQICAgICAgIDIwMCAgICAvKiAxMi41KjE2ICAgICAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcmFkaW8vcmFkaW8td2wxMjczLmMgYi9kcml2ZXJzL21lZGlhL3JhZGlvL3JhZGlvLXdsMTI3My5jCmluZGV4IGRkNmJkMzYuLjdlY2M4ZTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcmFkaW8vcmFkaW8td2wxMjczLmMKKysrIGIvZHJpdmVycy9tZWRpYS9yYWRpby9yYWRpby13bDEyNzMuYwpAQCAtMTQwNyw3ICsxNDA3LDcgQEAKIAkucmVhZAkJPSB3bDEyNzNfZm1fZm9wc19yZWFkLAogCS53cml0ZQkJPSB3bDEyNzNfZm1fZm9wc193cml0ZSwKIAkucG9sbAkJPSB3bDEyNzNfZm1fZm9wc19wb2xsLAotCS5pb2N0bAkJPSB2aWRlb19pb2N0bDIsCisJLnVubG9ja2VkX2lvY3RsCT0gdmlkZW9faW9jdGwyLAogCS5vcGVuCQk9IHdsMTI3M19mbV9mb3BzX29wZW4sCiAJLnJlbGVhc2UJPSB3bDEyNzNfZm1fZm9wc19yZWxlYXNlLAogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcmFkaW8vc2k0NzB4L3JhZGlvLXNpNDcweC1jb21tb24uYyBiL2RyaXZlcnMvbWVkaWEvcmFkaW8vc2k0NzB4L3JhZGlvLXNpNDcweC1jb21tb24uYwppbmRleCBhYzc2ZGZlLi42MGMxNzZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3JhZGlvL3NpNDcweC9yYWRpby1zaTQ3MHgtY29tbW9uLmMKKysrIGIvZHJpdmVycy9tZWRpYS9yYWRpby9zaTQ3MHgvcmFkaW8tc2k0NzB4LWNvbW1vbi5jCkBAIC0zNTcsNyArMzU3LDggQEAKIAkJZ290byBkb25lOwogCiAJLyogc3lzY29uZmlnIDEgKi8KLQlyYWRpby0+cmVnaXN0ZXJzW1NZU0NPTkZJRzFdID0gU1lTQ09ORklHMV9ERTsKKwlyYWRpby0+cmVnaXN0ZXJzW1NZU0NPTkZJRzFdID0KKwkJKGRlIDw8IDExKSAmIFNZU0NPTkZJRzFfREU7CQkvKiBERSovCiAJcmV0dmFsID0gc2k0NzB4X3NldF9yZWdpc3RlcihyYWRpbywgU1lTQ09ORklHMSk7CiAJaWYgKHJldHZhbCA8IDApCiAJCWdvdG8gZG9uZTsKQEAgLTY4NywxMiArNjg4LDggQEAKIAkvKiBkcml2ZXIgY29uc3RhbnRzICovCiAJc3RyY3B5KHR1bmVyLT5uYW1lLCAiRk0iKTsKIAl0dW5lci0+dHlwZSA9IFY0TDJfVFVORVJfUkFESU87Ci0jaWYgZGVmaW5lZChDT05GSUdfVVNCX1NJNDcwWCkgfHwgZGVmaW5lZChDT05GSUdfVVNCX1NJNDcwWF9NT0RVTEUpCiAJdHVuZXItPmNhcGFiaWxpdHkgPSBWNEwyX1RVTkVSX0NBUF9MT1cgfCBWNEwyX1RVTkVSX0NBUF9TVEVSRU8gfAogCQkJICAgIFY0TDJfVFVORVJfQ0FQX1JEUyB8IFY0TDJfVFVORVJfQ0FQX1JEU19CTE9DS19JTzsKLSNlbHNlCi0JdHVuZXItPmNhcGFiaWxpdHkgPSBWNEwyX1RVTkVSX0NBUF9MT1cgfCBWNEwyX1RVTkVSX0NBUF9TVEVSRU87Ci0jZW5kaWYKIAogCS8qIHJhbmdlIGxpbWl0cyAqLwogCXN3aXRjaCAoKHJhZGlvLT5yZWdpc3RlcnNbU1lTQ09ORklHMl0gJiBTWVNDT05GSUcyX0JBTkQpID4+IDYpIHsKQEAgLTcxOCwxMiArNzE1LDEwIEBACiAJCXR1bmVyLT5yeHN1YmNoYW5zID0gVjRMMl9UVU5FUl9TVUJfTU9OTzsKIAllbHNlCiAJCXR1bmVyLT5yeHN1YmNoYW5zID0gVjRMMl9UVU5FUl9TVUJfTU9OTyB8IFY0TDJfVFVORVJfU1VCX1NURVJFTzsKLSNpZiBkZWZpbmVkKENPTkZJR19VU0JfU0k0NzBYKSB8fCBkZWZpbmVkKENPTkZJR19VU0JfU0k0NzBYX01PRFVMRSkKIAkvKiBJZiB0aGVyZSBpcyBhIHJlbGlhYmxlIG1ldGhvZCBvZiBkZXRlY3RpbmcgYW4gUkRTIGNoYW5uZWwsCiAJICAgdGhlbiB0aGlzIGNvZGUgc2hvdWxkIGNoZWNrIGZvciB0aGF0IGJlZm9yZSBzZXR0aW5nIHRoaXMKIAkgICBSRFMgc3ViY2hhbm5lbC4gKi8KIAl0dW5lci0+cnhzdWJjaGFucyB8PSBWNEwyX1RVTkVSX1NVQl9SRFM7Ci0jZW5kaWYKIAogCS8qIG1vbm8vc3RlcmVvIHNlbGVjdG9yICovCiAJaWYgKChyYWRpby0+cmVnaXN0ZXJzW1BPV0VSQ0ZHXSAmIFBPV0VSQ0ZHX01PTk8pID09IDApCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3JjL2VuZV9pci5jIGIvZHJpdmVycy9tZWRpYS9yYy9lbmVfaXIuYwppbmRleCA4MGIzYzMxLi4xYWM0OTEzIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3JjL2VuZV9pci5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcmMvZW5lX2lyLmMKQEAgLTQ0NiwyNyArNDQ2LDI3IEBACiAKIHNlbGVjdF90aW1lb3V0OgogCWlmIChkZXYtPnJ4X2Zhbl9pbnB1dF9pbnVzZSkgewotCQlkZXYtPnJkZXYtPnJ4X3Jlc29sdXRpb24gPSBNU19UT19OUyhFTkVfRldfU0FNUExFX1BFUklPRF9GQU4pOworCQlkZXYtPnJkZXYtPnJ4X3Jlc29sdXRpb24gPSBVU19UT19OUyhFTkVfRldfU0FNUExFX1BFUklPRF9GQU4pOwogCiAJCS8qIEZhbiBpbnB1dCBkb2Vzbid0IHN1cHBvcnQgdGltZW91dHMsIGl0IGp1c3QgZW5kcyB0aGUKIAkJCWlucHV0IHdpdGggYSBtYXhpbXVtIHNhbXBsZSAqLwogCQlkZXYtPnJkZXYtPm1pbl90aW1lb3V0ID0gZGV2LT5yZGV2LT5tYXhfdGltZW91dCA9Ci0JCQlNU19UT19OUyhFTkVfRldfU01QTF9CVUZfRkFOX01TSyAqCisJCQlVU19UT19OUyhFTkVfRldfU01QTF9CVUZfRkFOX01TSyAqCiAJCQkJRU5FX0ZXX1NBTVBMRV9QRVJJT0RfRkFOKTsKIAl9IGVsc2UgewotCQlkZXYtPnJkZXYtPnJ4X3Jlc29sdXRpb24gPSBNU19UT19OUyhzYW1wbGVfcGVyaW9kKTsKKwkJZGV2LT5yZGV2LT5yeF9yZXNvbHV0aW9uID0gVVNfVE9fTlMoc2FtcGxlX3BlcmlvZCk7CiAKIAkJLyogVGhlb3JldGljbHkgdGltZW91dCBpcyB1bmxpbWl0ZWQsIGJ1dCB3ZSBjYXAgaXQKIAkJICogYmVjYXVzZSBpdCB3YXMgc2VlbiB0aGF0IG9uIG9uZSBkZXZpY2UsIGl0CiAJCSAqIHdvdWxkIHN0b3Agc2VuZGluZyBzcGFjZXMgYWZ0ZXIgYXJvdW5kIDI1MCBtc2VjLgogCQkgKiBCZXNpZGVzLCB0aGlzIGlzIGNsb3NlIHRvIDJeMzIgYW55d2F5IGFuZCB0aW1lb3V0IGlzIHUzMi4KIAkJICovCi0JCWRldi0+cmRldi0+bWluX3RpbWVvdXQgPSBNU19UT19OUygxMjcgKiBzYW1wbGVfcGVyaW9kKTsKLQkJZGV2LT5yZGV2LT5tYXhfdGltZW91dCA9IE1TX1RPX05TKDIwMDAwMCk7CisJCWRldi0+cmRldi0+bWluX3RpbWVvdXQgPSBVU19UT19OUygxMjcgKiBzYW1wbGVfcGVyaW9kKTsKKwkJZGV2LT5yZGV2LT5tYXhfdGltZW91dCA9IFVTX1RPX05TKDIwMDAwMCk7CiAJfQogCiAJaWYgKGRldi0+aHdfbGVhcm5pbmdfYW5kX3R4X2NhcGFibGUpCi0JCWRldi0+cmRldi0+dHhfcmVzb2x1dGlvbiA9IE1TX1RPX05TKHNhbXBsZV9wZXJpb2QpOworCQlkZXYtPnJkZXYtPnR4X3Jlc29sdXRpb24gPSBVU19UT19OUyhzYW1wbGVfcGVyaW9kKTsKIAogCWlmIChkZXYtPnJkZXYtPnRpbWVvdXQgPiBkZXYtPnJkZXYtPm1heF90aW1lb3V0KQogCQlkZXYtPnJkZXYtPnRpbWVvdXQgPSBkZXYtPnJkZXYtPm1heF90aW1lb3V0OwpAQCAtODAxLDcgKzgwMSw3IEBACiAKIAkJZGJnKCJSWDogJWQgKCVzKSIsIGh3X3NhbXBsZSwgcHVsc2UgPyAicHVsc2UiIDogInNwYWNlIik7CiAKLQkJZXYuZHVyYXRpb24gPSBNU19UT19OUyhod19zYW1wbGUpOworCQlldi5kdXJhdGlvbiA9IFVTX1RPX05TKGh3X3NhbXBsZSk7CiAJCWV2LnB1bHNlID0gcHVsc2U7CiAJCWlyX3Jhd19ldmVudF9zdG9yZV93aXRoX2ZpbHRlcihkZXYtPnJkZXYsICZldik7CiAJfQpAQCAtODIxLDcgKzgyMSw3IEBACiAJZGV2LT5sZWFybmluZ19tb2RlX2VuYWJsZWQgPSBsZWFybmluZ19tb2RlX2ZvcmNlOwogCiAJLyogU2V0IHJlYXNvbmFibGUgZGVmYXVsdCB0aW1lb3V0ICovCi0JZGV2LT5yZGV2LT50aW1lb3V0ID0gTVNfVE9fTlMoMTUwMDAwKTsKKwlkZXYtPnJkZXYtPnRpbWVvdXQgPSBVU19UT19OUygxNTAwMDApOwogfQogCiAvKiBVcGxvYWQgYWxsIGhhcmR3YXJlIHNldHRpbmdzIGF0IG9uY2UuIFVzZWQgYXQgbG9hZCBhbmQgcmVzdW1lIHRpbWUgKi8KQEAgLTEwMDQsNiArMTAwNCwxMCBAQAogCS8qIHZhbGlkYXRlIHJlc291cmNlcyAqLwogCWVycm9yID0gLUVOT0RFVjsKIAorCS8qIGluaXQgdGhlc2UgdG8gLTEsIGFzIDAgaXMgdmFsaWQgZm9yIGJvdGggKi8KKwlkZXYtPmh3X2lvID0gLTE7CisJZGV2LT5pcnEgPSAtMTsKKwogCWlmICghcG5wX3BvcnRfdmFsaWQocG5wX2RldiwgMCkgfHwKIAkgICAgcG5wX3BvcnRfbGVuKHBucF9kZXYsIDApIDwgRU5FX0lPX1NJWkUpCiAJCWdvdG8gZXJyb3I7CkBAIC0xMDcyLDYgKzEwNzYsOCBAQAogCQlyZGV2LT5pbnB1dF9uYW1lID0gIkVORSBlSG9tZSBJbmZyYXJlZCBSZW1vdGUgVHJhbnNjZWl2ZXIiOwogCX0KIAorCWRldi0+cmRldiA9IHJkZXY7CisKIAllbmVfcnhfc2V0dXBfaHdfYnVmZmVyKGRldik7CiAJZW5lX3NldHVwX2RlZmF1bHRfc2V0dGluZ3MoZGV2KTsKIAllbmVfc2V0dXBfaHdfc2V0dGluZ3MoZGV2KTsKQEAgLTEwODMsNyArMTA4OSw2IEBACiAJaWYgKGVycm9yIDwgMCkKIAkJZ290byBlcnJvcjsKIAotCWRldi0+cmRldiA9IHJkZXY7CiAJZW5lX25vdGljZSgiZHJpdmVyIGhhcyBiZWVuIHN1Y2Nlc2Z1bGx5IGxvYWRlZCIpOwogCXJldHVybiAwOwogZXJyb3I6CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3JjL2VuZV9pci5oIGIvZHJpdmVycy9tZWRpYS9yYy9lbmVfaXIuaAppbmRleCBjMTc5YmFmLi4zMzdhNDFkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3JjL2VuZV9pci5oCisrKyBiL2RyaXZlcnMvbWVkaWEvcmMvZW5lX2lyLmgKQEAgLTIwMSw4ICsyMDEsNiBAQAogI2RlZmluZSBkYmdfdmVyYm9zZShmb3JtYXQsIC4uLikJX19kYmcoMiwgZm9ybWF0LCAjIyBfX1ZBX0FSR1NfXykKICNkZWZpbmUgZGJnX3JlZ3MoZm9ybWF0LCAuLi4pCQlfX2RiZygzLCBmb3JtYXQsICMjIF9fVkFfQVJHU19fKQogCi0jZGVmaW5lIE1TX1RPX05TKG1zZWMpICgobXNlYykgKiAxMDAwKQotCiBzdHJ1Y3QgZW5lX2RldmljZSB7CiAJc3RydWN0IHBucF9kZXYgKnBucF9kZXY7CiAJc3RydWN0IHJjX2RldiAqcmRldjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcmMvaW1vbi5jIGIvZHJpdmVycy9tZWRpYS9yYy9pbW9uLmMKaW5kZXggNjgxMTUxMi4uZTdkYzZiNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9yYy9pbW9uLmMKKysrIGIvZHJpdmVycy9tZWRpYS9yYy9pbW9uLmMKQEAgLTk4OCw3ICs5ODgsNiBAQAogCWludCByZXR2YWw7CiAJc3RydWN0IGltb25fY29udGV4dCAqaWN0eCA9IHJjLT5wcml2OwogCXN0cnVjdCBkZXZpY2UgKmRldiA9IGljdHgtPmRldjsKLQlib29sIHBhZF9tb3VzZTsKIAl1bnNpZ25lZCBjaGFyIGlyX3Byb3RvX3BhY2tldFtdID0gewogCQkweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDg2IH07CiAKQEAgLTEwMDAsMjkgKzk5OSwyMCBAQAogCWNhc2UgUkNfVFlQRV9SQzY6CiAJCWRldl9kYmcoZGV2LCAiQ29uZmlndXJpbmcgSVIgcmVjZWl2ZXIgZm9yIE1DRSBwcm90b2NvbFxuIik7CiAJCWlyX3Byb3RvX3BhY2tldFswXSA9IDB4MDE7Ci0JCXBhZF9tb3VzZSA9IGZhbHNlOwogCQlicmVhazsKIAljYXNlIFJDX1RZUEVfVU5LTk9XTjoKIAljYXNlIFJDX1RZUEVfT1RIRVI6CiAJCWRldl9kYmcoZGV2LCAiQ29uZmlndXJpbmcgSVIgcmVjZWl2ZXIgZm9yIGlNT04gcHJvdG9jb2xcbiIpOwotCQlpZiAocGFkX3N0YWJpbGl6ZSAmJiAhbm9tb3VzZSkKLQkJCXBhZF9tb3VzZSA9IHRydWU7Ci0JCWVsc2UgeworCQlpZiAoIXBhZF9zdGFiaWxpemUpCiAJCQlkZXZfZGJnKGRldiwgIlBBRCBzdGFiaWxpemUgZnVuY3Rpb25hbGl0eSBkaXNhYmxlZFxuIik7Ci0JCQlwYWRfbW91c2UgPSBmYWxzZTsKLQkJfQogCQkvKiBpcl9wcm90b19wYWNrZXRbMF0gPSAweDAwOyAvLyBhbHJlYWR5IHRoZSBkZWZhdWx0ICovCiAJCXJjX3R5cGUgPSBSQ19UWVBFX09USEVSOwogCQlicmVhazsKIAlkZWZhdWx0OgogCQlkZXZfd2FybihkZXYsICJVbnN1cHBvcnRlZCBJUiBwcm90b2NvbCBzcGVjaWZpZWQsIG92ZXJyaWRpbmcgIgogCQkJICJ0byBpTU9OIElSIHByb3RvY29sXG4iKTsKLQkJaWYgKHBhZF9zdGFiaWxpemUgJiYgIW5vbW91c2UpCi0JCQlwYWRfbW91c2UgPSB0cnVlOwotCQllbHNlIHsKKwkJaWYgKCFwYWRfc3RhYmlsaXplKQogCQkJZGV2X2RiZyhkZXYsICJQQUQgc3RhYmlsaXplIGZ1bmN0aW9uYWxpdHkgZGlzYWJsZWRcbiIpOwotCQkJcGFkX21vdXNlID0gZmFsc2U7Ci0JCX0KIAkJLyogaXJfcHJvdG9fcGFja2V0WzBdID0gMHgwMDsgLy8gYWxyZWFkeSB0aGUgZGVmYXVsdCAqLwogCQlyY190eXBlID0gUkNfVFlQRV9PVEhFUjsKIAkJYnJlYWs7CkBAIC0xMDM1LDcgKzEwMjUsNyBAQAogCQlnb3RvIG91dDsKIAogCWljdHgtPnJjX3R5cGUgPSByY190eXBlOwotCWljdHgtPnBhZF9tb3VzZSA9IHBhZF9tb3VzZTsKKwlpY3R4LT5wYWRfbW91c2UgPSBmYWxzZTsKIAogb3V0OgogCXJldHVybiByZXR2YWw7CkBAIC0xNTE3LDcgKzE1MDcsNyBAQAogCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaWN0eC0+a2NfbG9jaywgZmxhZ3MpOwogCQkJcmV0dXJuOwogCQl9IGVsc2UgewotCQkJaWN0eC0+cGFkX21vdXNlID0gMDsKKwkJCWljdHgtPnBhZF9tb3VzZSA9IGZhbHNlOwogCQkJZGV2X2RiZyhkZXYsICJtb3VzZSBtb2RlIGRpc2FibGVkLCBwYXNzaW5nIGtleSB2YWx1ZVxuIik7CiAJCX0KIAl9CkBAIC0xNzU2LDcgKzE3NDYsNiBAQAogCXByaW50ayhLRVJOX0NPTlQgIiAoaWQgMHglMDJ4KVxuIiwgZmZkY19jZmdfYnl0ZSk7CiAKIAlpY3R4LT5kaXNwbGF5X3R5cGUgPSBkZXRlY3RlZF9kaXNwbGF5X3R5cGU7Ci0JaWN0eC0+cmRldi0+YWxsb3dlZF9wcm90b3MgPSBhbGxvd2VkX3Byb3RvczsKIAlpY3R4LT5yY190eXBlID0gYWxsb3dlZF9wcm90b3M7CiB9CiAKQEAgLTE4MzksMTAgKzE4MjgsNiBAQAogCXJkZXYtPmFsbG93ZWRfcHJvdG9zID0gUkNfVFlQRV9PVEhFUiB8IFJDX1RZUEVfUkM2OyAvKiBpTU9OIFBBRCBvciBNQ0UgKi8KIAlyZGV2LT5jaGFuZ2VfcHJvdG9jb2wgPSBpbW9uX2lyX2NoYW5nZV9wcm90b2NvbDsKIAlyZGV2LT5kcml2ZXJfbmFtZSA9IE1PRF9OQU1FOwotCWlmIChpY3R4LT5yY190eXBlID09IFJDX1RZUEVfUkM2KQotCQlyZGV2LT5tYXBfbmFtZSA9IFJDX01BUF9JTU9OX01DRTsKLQllbHNlCi0JCXJkZXYtPm1hcF9uYW1lID0gUkNfTUFQX0lNT05fUEFEOwogCiAJLyogRW5hYmxlIGZyb250LXBhbmVsIGJ1dHRvbnMgYW5kL29yIGtub2JzICovCiAJbWVtY3B5KGljdHgtPnVzYl90eF9idWYsICZmcF9wYWNrZXQsIHNpemVvZihmcF9wYWNrZXQpKTsKQEAgLTE4NTEsMTEgKzE4MzYsMTggQEAKIAlpZiAocmV0KQogCQlkZXZfaW5mbyhpY3R4LT5kZXYsICJwYW5lbCBidXR0b25zL2tub2JzIHNldHVwIGZhaWxlZFxuIik7CiAKLQlpZiAoaWN0eC0+cHJvZHVjdCA9PSAweGZmZGMpCisJaWYgKGljdHgtPnByb2R1Y3QgPT0gMHhmZmRjKSB7CiAJCWltb25fZ2V0X2ZmZGNfdHlwZShpY3R4KTsKKwkJcmRldi0+YWxsb3dlZF9wcm90b3MgPSBpY3R4LT5yY190eXBlOworCX0KIAogCWltb25fc2V0X2Rpc3BsYXlfdHlwZShpY3R4KTsKIAorCWlmIChpY3R4LT5yY190eXBlID09IFJDX1RZUEVfUkM2KQorCQlyZGV2LT5tYXBfbmFtZSA9IFJDX01BUF9JTU9OX01DRTsKKwllbHNlCisJCXJkZXYtPm1hcF9uYW1lID0gUkNfTUFQX0lNT05fUEFEOworCiAJcmV0ID0gcmNfcmVnaXN0ZXJfZGV2aWNlKHJkZXYpOwogCWlmIChyZXQgPCAwKSB7CiAJCWRldl9lcnIoaWN0eC0+ZGV2LCAicmVtb3RlIGlucHV0IGRldiByZWdpc3RlciBmYWlsZWRcbiIpOwpAQCAtMjEwOCwxOCArMjEwMCw2IEBACiAJCWdvdG8gZmluZF9lbmRwb2ludF9mYWlsZWQ7CiAJfQogCi0JaWN0eC0+aWRldiA9IGltb25faW5pdF9pZGV2KGljdHgpOwotCWlmICghaWN0eC0+aWRldikgewotCQlkZXZfZXJyKGRldiwgIiVzOiBpbnB1dCBkZXZpY2Ugc2V0dXAgZmFpbGVkXG4iLCBfX2Z1bmNfXyk7Ci0JCWdvdG8gaWRldl9zZXR1cF9mYWlsZWQ7Ci0JfQotCi0JaWN0eC0+cmRldiA9IGltb25faW5pdF9yZGV2KGljdHgpOwotCWlmICghaWN0eC0+cmRldikgewotCQlkZXZfZXJyKGRldiwgIiVzOiByYyBkZXZpY2Ugc2V0dXAgZmFpbGVkXG4iLCBfX2Z1bmNfXyk7Ci0JCWdvdG8gcmRldl9zZXR1cF9mYWlsZWQ7Ci0JfQotCiAJdXNiX2ZpbGxfaW50X3VyYihpY3R4LT5yeF91cmJfaW50ZjAsIGljdHgtPnVzYmRldl9pbnRmMCwKIAkJdXNiX3JjdmludHBpcGUoaWN0eC0+dXNiZGV2X2ludGYwLAogCQkJaWN0eC0+cnhfZW5kcG9pbnRfaW50ZjAtPmJFbmRwb2ludEFkZHJlc3MpLApAQCAtMjEzMywxMyArMjExMywyNSBAQAogCQlnb3RvIHVyYl9zdWJtaXRfZmFpbGVkOwogCX0KIAorCWljdHgtPmlkZXYgPSBpbW9uX2luaXRfaWRldihpY3R4KTsKKwlpZiAoIWljdHgtPmlkZXYpIHsKKwkJZGV2X2VycihkZXYsICIlczogaW5wdXQgZGV2aWNlIHNldHVwIGZhaWxlZFxuIiwgX19mdW5jX18pOworCQlnb3RvIGlkZXZfc2V0dXBfZmFpbGVkOworCX0KKworCWljdHgtPnJkZXYgPSBpbW9uX2luaXRfcmRldihpY3R4KTsKKwlpZiAoIWljdHgtPnJkZXYpIHsKKwkJZGV2X2VycihkZXYsICIlczogcmMgZGV2aWNlIHNldHVwIGZhaWxlZFxuIiwgX19mdW5jX18pOworCQlnb3RvIHJkZXZfc2V0dXBfZmFpbGVkOworCX0KKwogCXJldHVybiBpY3R4OwogCi11cmJfc3VibWl0X2ZhaWxlZDoKLQlyY191bnJlZ2lzdGVyX2RldmljZShpY3R4LT5yZGV2KTsKIHJkZXZfc2V0dXBfZmFpbGVkOgogCWlucHV0X3VucmVnaXN0ZXJfZGV2aWNlKGljdHgtPmlkZXYpOwogaWRldl9zZXR1cF9mYWlsZWQ6CisJdXNiX2tpbGxfdXJiKGljdHgtPnJ4X3VyYl9pbnRmMCk7Cit1cmJfc3VibWl0X2ZhaWxlZDoKIGZpbmRfZW5kcG9pbnRfZmFpbGVkOgogCW11dGV4X3VubG9jaygmaWN0eC0+bG9jayk7CiAJdXNiX2ZyZWVfdXJiKHR4X3VyYik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3JjL2lyLWxpcmMtY29kZWMuYyBiL2RyaXZlcnMvbWVkaWEvcmMvaXItbGlyYy1jb2RlYy5jCmluZGV4IGYwMTFjNWQuLjFjNWNjNjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcmMvaXItbGlyYy1jb2RlYy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcmMvaXItbGlyYy1jb2RlYy5jCkBAIC0xLDQgKzEsNCBAQAotLyogaXItbGlyYy1jb2RlYy5jIC0gaXItY29yZSB0byBjbGFzc2ljIGxpcmMgaW50ZXJmYWNlIGJyaWRnZQorLyogaXItbGlyYy1jb2RlYy5jIC0gcmMtY29yZSB0byBjbGFzc2ljIGxpcmMgaW50ZXJmYWNlIGJyaWRnZQogICoKICAqIENvcHlyaWdodCAoQykgMjAxMCBieSBKYXJvZCBXaWxzb24gPGphcm9kQHJlZGhhdC5jb20+CiAgKgpAQCAtNDcsNiArNDcsNyBAQAogCS8qIENhcnJpZXIgcmVwb3J0cyAqLwogCWlmIChldi5jYXJyaWVyX3JlcG9ydCkgewogCQlzYW1wbGUgPSBMSVJDX0ZSRVFVRU5DWShldi5jYXJyaWVyKTsKKwkJSVJfZHByaW50aygyLCAiY2FycmllciByZXBvcnQgKGZyZXE6ICVkKVxuIiwgc2FtcGxlKTsKIAogCS8qIFBhY2tldCBlbmQgKi8KIAl9IGVsc2UgaWYgKGV2LnRpbWVvdXQpIHsKQEAgLTYyLDYgKzYzLDcgQEAKIAkJCXJldHVybiAwOwogCiAJCXNhbXBsZSA9IExJUkNfVElNRU9VVChldi5kdXJhdGlvbiAvIDEwMDApOworCQlJUl9kcHJpbnRrKDIsICJ0aW1lb3V0IHJlcG9ydCAoZHVyYXRpb246ICVkKVxuIiwgc2FtcGxlKTsKIAogCS8qIE5vcm1hbCBzYW1wbGUgKi8KIAl9IGVsc2UgewpAQCAtODUsNiArODcsOCBAQAogCiAJCXNhbXBsZSA9IGV2LnB1bHNlID8gTElSQ19QVUxTRShldi5kdXJhdGlvbiAvIDEwMDApIDoKIAkJCQkJTElSQ19TUEFDRShldi5kdXJhdGlvbiAvIDEwMDApOworCQlJUl9kcHJpbnRrKDIsICJkZWxpdmVyaW5nICV1dXMgJXMgdG8gbGlyY19kZXZcbiIsCisJCQkgICBUT19VUyhldi5kdXJhdGlvbiksIFRPX1NUUihldi5wdWxzZSkpOwogCX0KIAogCWxpcmNfYnVmZmVyX3dyaXRlKGRldi0+cmF3LT5saXJjLmRydi0+cmJ1ZiwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcmMvaXItcmF3LmMgYi9kcml2ZXJzL21lZGlhL3JjL2lyLXJhdy5jCmluZGV4IDE4NWJhZGQuLjczMjMwZmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcmMvaXItcmF3LmMKKysrIGIvZHJpdmVycy9tZWRpYS9yYy9pci1yYXcuYwpAQCAtMjMzLDcgKzIzMyw3IEBACiAKIC8qIHVzZWQgaW50ZXJuYWxseSBieSB0aGUgc3lzZnMgaW50ZXJmYWNlICovCiB1NjQKLWlyX3Jhd19nZXRfYWxsb3dlZF9wcm90b2NvbHMoKQoraXJfcmF3X2dldF9hbGxvd2VkX3Byb3RvY29scyh2b2lkKQogewogCXU2NCBwcm90b2NvbHM7CiAJbXV0ZXhfbG9jaygmaXJfcmF3X2hhbmRsZXJfbG9jayk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3JjL2tleW1hcHMvcmMtZGliMDcwMC1uZWMuYyBiL2RyaXZlcnMvbWVkaWEvcmMva2V5bWFwcy9yYy1kaWIwNzAwLW5lYy5jCmluZGV4IGM1OTg1MWIuLjdhNWY1MzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcmMva2V5bWFwcy9yYy1kaWIwNzAwLW5lYy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcmMva2V5bWFwcy9yYy1kaWIwNzAwLW5lYy5jCkBAIC0xOSwzNSArMTksMzUgQEAKIAogc3RhdGljIHN0cnVjdCByY19tYXBfdGFibGUgZGliMDcwMF9uZWNfdGFibGVbXSA9IHsKIAkvKiBLZXkgY29kZXMgZm9yIHRoZSBQaXhlbHZpZXcgU0JUVkQgcmVtb3RlICovCi0JeyAweDg2MTMsIEtFWV9NVVRFIH0sCi0JeyAweDg2MTIsIEtFWV9QT1dFUiB9LAotCXsgMHg4NjAxLCBLRVlfMSB9LAotCXsgMHg4NjAyLCBLRVlfMiB9LAotCXsgMHg4NjAzLCBLRVlfMyB9LAotCXsgMHg4NjA0LCBLRVlfNCB9LAotCXsgMHg4NjA1LCBLRVlfNSB9LAotCXsgMHg4NjA2LCBLRVlfNiB9LAotCXsgMHg4NjA3LCBLRVlfNyB9LAotCXsgMHg4NjA4LCBLRVlfOCB9LAotCXsgMHg4NjA5LCBLRVlfOSB9LAotCXsgMHg4NjAwLCBLRVlfMCB9LAotCXsgMHg4NjBkLCBLRVlfQ0hBTk5FTFVQIH0sCi0JeyAweDg2MTksIEtFWV9DSEFOTkVMRE9XTiB9LAotCXsgMHg4NjEwLCBLRVlfVk9MVU1FVVAgfSwKLQl7IDB4ODYwYywgS0VZX1ZPTFVNRURPV04gfSwKKwl7IDB4ODY2YjEzLCBLRVlfTVVURSB9LAorCXsgMHg4NjZiMTIsIEtFWV9QT1dFUiB9LAorCXsgMHg4NjZiMDEsIEtFWV8xIH0sCisJeyAweDg2NmIwMiwgS0VZXzIgfSwKKwl7IDB4ODY2YjAzLCBLRVlfMyB9LAorCXsgMHg4NjZiMDQsIEtFWV80IH0sCisJeyAweDg2NmIwNSwgS0VZXzUgfSwKKwl7IDB4ODY2YjA2LCBLRVlfNiB9LAorCXsgMHg4NjZiMDcsIEtFWV83IH0sCisJeyAweDg2NmIwOCwgS0VZXzggfSwKKwl7IDB4ODY2YjA5LCBLRVlfOSB9LAorCXsgMHg4NjZiMDAsIEtFWV8wIH0sCisJeyAweDg2NmIwZCwgS0VZX0NIQU5ORUxVUCB9LAorCXsgMHg4NjZiMTksIEtFWV9DSEFOTkVMRE9XTiB9LAorCXsgMHg4NjZiMTAsIEtFWV9WT0xVTUVVUCB9LAorCXsgMHg4NjZiMGMsIEtFWV9WT0xVTUVET1dOIH0sCiAKLQl7IDB4ODYwYSwgS0VZX0NBTUVSQSB9LAotCXsgMHg4NjBiLCBLRVlfWk9PTSB9LAotCXsgMHg4NjFiLCBLRVlfQkFDS1NQQUNFIH0sCi0JeyAweDg2MTUsIEtFWV9FTlRFUiB9LAorCXsgMHg4NjZiMGEsIEtFWV9DQU1FUkEgfSwKKwl7IDB4ODY2YjBiLCBLRVlfWk9PTSB9LAorCXsgMHg4NjZiMWIsIEtFWV9CQUNLU1BBQ0UgfSwKKwl7IDB4ODY2YjE1LCBLRVlfRU5URVIgfSwKIAotCXsgMHg4NjFkLCBLRVlfVVAgfSwKLQl7IDB4ODYxZSwgS0VZX0RPV04gfSwKLQl7IDB4ODYwZSwgS0VZX0xFRlQgfSwKLQl7IDB4ODYwZiwgS0VZX1JJR0hUIH0sCisJeyAweDg2NmIxZCwgS0VZX1VQIH0sCisJeyAweDg2NmIxZSwgS0VZX0RPV04gfSwKKwl7IDB4ODY2YjBlLCBLRVlfTEVGVCB9LAorCXsgMHg4NjZiMGYsIEtFWV9SSUdIVCB9LAogCi0JeyAweDg2MTgsIEtFWV9SRUNPUkQgfSwKLQl7IDB4ODYxYSwgS0VZX1NUT1AgfSwKKwl7IDB4ODY2YjE4LCBLRVlfUkVDT1JEIH0sCisJeyAweDg2NmIxYSwgS0VZX1NUT1AgfSwKIAogCS8qIEtleSBjb2RlcyBmb3IgdGhlIEV2b2x1dGVQQyBUVldheSsgcmVtb3RlICovCiAJeyAweDdhMDAsIEtFWV9NRU5VIH0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3JjL2tleW1hcHMvcmMtcmM2LW1jZS5jIGIvZHJpdmVycy9tZWRpYS9yYy9rZXltYXBzL3JjLXJjNi1tY2UuYwppbmRleCAzYmYzMzM3Li4yZjVkYzA2IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3JjL2tleW1hcHMvcmMtcmM2LW1jZS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcmMva2V5bWFwcy9yYy1yYzYtbWNlLmMKQEAgLTMsNiArMyw5IEBACiAgKgogICogQ29weXJpZ2h0IChjKSAyMDEwIGJ5IEphcm9kIFdpbHNvbiA8amFyb2RAcmVkaGF0LmNvbT4KICAqCisgKiBTZWUgaHR0cDovL21lZGlhY2VudGVyZ3VpZGVzLmNvbS9ib29rL2V4cG9ydC9odG1sLzMxIGZvciBkZXRhaWxzIG9uCisgKiBrZXkgbWFwcGluZ3MuCisgKgogICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CiAgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgpAQCAtNjAsNiArNjMsOSBAQAogCXsgMHg4MDBmMDQyNiwgS0VZX0VQRyB9LAkJLyogR3VpZGUgKi8KIAl7IDB4ODAwZjA0MjcsIEtFWV9aT09NIH0sCQkvKiBBc3BlY3QgKi8KIAorCXsgMHg4MDBmMDQzMiwgS0VZX01PREUgfSwJCS8qIFZpc3VhbGl6YXRpb24gKi8KKwl7IDB4ODAwZjA0MzMsIEtFWV9QUkVTRU5UQVRJT04gfSwJLyogU2xpZGUgU2hvdyAqLworCXsgMHg4MDBmMDQzNCwgS0VZX0VKRUNUQ0QgfSwKIAl7IDB4ODAwZjA0M2EsIEtFWV9CUklHSFRORVNTVVAgfSwKIAogCXsgMHg4MDBmMDQ0NiwgS0VZX1RWIH0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3JjL21jZXVzYi5jIGIvZHJpdmVycy9tZWRpYS9yYy9tY2V1c2IuYwppbmRleCAwZmVmNmVmLi42ZGYwYTQ5IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3JjL21jZXVzYi5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcmMvbWNldXNiLmMKQEAgLTQ4LDcgKzQ4LDYgQEAKICNkZWZpbmUgVVNCX0JVRkxFTgkJMzIgLyogVVNCIHJlY2VwdGlvbiBidWZmZXIgbGVuZ3RoICovCiAjZGVmaW5lIFVTQl9DVFJMX01TR19TWgkJMiAgLyogU2l6ZSBvZiB1c2IgY3RybCBtc2cgb24gZ2VuMSBodyAqLwogI2RlZmluZSBNQ0VfRzFfSU5JVF9NU0dTCTQwIC8qIEluaXQgbWVzc2FnZXMgb24gZ2VuMSBodyB0byB0aHJvdyBvdXQgKi8KLSNkZWZpbmUgTVNfVE9fTlMobXNlYykJCSgobXNlYykgKiAxMDAwKQogCiAvKiBNQ0UgY29uc3RhbnRzICovCiAjZGVmaW5lIE1DRV9DTURCVUZfU0laRQkJMzg0ICAvKiBNQ0UgQ29tbWFuZCBidWZmZXIgbGVuZ3RoICovCkBAIC04MTcsNyArODE2LDcgQEAKIAlzd2l0Y2ggKGlyLT5idWZfaW5baW5kZXhdKSB7CiAJLyogMi1ieXRlIHJldHVybiB2YWx1ZSBjb21tYW5kcyAqLwogCWNhc2UgTUNFX0NNRF9TX1RJTUVPVVQ6Ci0JCWlyLT5yYy0+dGltZW91dCA9IE1TX1RPX05TKChoaSA8PCA4IHwgbG8pIC8gMik7CisJCWlyLT5yYy0+dGltZW91dCA9IFVTX1RPX05TKChoaSA8PCA4IHwgbG8pIC8gMik7CiAJCWJyZWFrOwogCiAJLyogMS1ieXRlIHJldHVybiB2YWx1ZSBjb21tYW5kcyAqLwpAQCAtODU2LDkgKzg1NSwxMCBAQAogCQkJYnJlYWs7CiAJCWNhc2UgUEFSU0VfSVJEQVRBOgogCQkJaXItPnJlbS0tOworCQkJaW5pdF9pcl9yYXdfZXZlbnQoJnJhd2lyKTsKIAkJCXJhd2lyLnB1bHNlID0gKChpci0+YnVmX2luW2ldICYgTUNFX1BVTFNFX0JJVCkgIT0gMCk7CiAJCQlyYXdpci5kdXJhdGlvbiA9IChpci0+YnVmX2luW2ldICYgTUNFX1BVTFNFX01BU0spCi0JCQkJCSAqIE1TX1RPX05TKE1DRV9USU1FX1VOSVQpOworCQkJCQkgKiBVU19UT19OUyhNQ0VfVElNRV9VTklUKTsKIAogCQkJZGV2X2RiZyhpci0+ZGV2LCAiU3RvcmluZyAlcyB3aXRoIGR1cmF0aW9uICVkXG4iLAogCQkJCXJhd2lyLnB1bHNlID8gInB1bHNlIiA6ICJzcGFjZSIsCkBAIC04ODQsNiArODg0LDggQEAKIAkJCQkJICAgICBpLCBpci0+cmVtICsgMSwgZmFsc2UpOwogCQkJaWYgKGlyLT5yZW0pCiAJCQkJaXItPnBhcnNlcl9zdGF0ZSA9IFBBUlNFX0lSREFUQTsKKwkJCWVsc2UKKwkJCQlpcl9yYXdfZXZlbnRfcmVzZXQoaXItPnJjKTsKIAkJCWJyZWFrOwogCQl9CiAKQEAgLTEwNjEsNyArMTA2Myw3IEBACiAJcmMtPnByaXYgPSBpcjsKIAlyYy0+ZHJpdmVyX3R5cGUgPSBSQ19EUklWRVJfSVJfUkFXOwogCXJjLT5hbGxvd2VkX3Byb3RvcyA9IFJDX1RZUEVfQUxMOwotCXJjLT50aW1lb3V0ID0gTVNfVE9fTlMoMTAwMCk7CisJcmMtPnRpbWVvdXQgPSBVU19UT19OUygxMDAwKTsKIAlpZiAoIWlyLT5mbGFncy5ub190eCkgewogCQlyYy0+c190eF9tYXNrID0gbWNldXNiX3NldF90eF9tYXNrOwogCQlyYy0+c190eF9jYXJyaWVyID0gbWNldXNiX3NldF90eF9jYXJyaWVyOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9yYy9udXZvdG9uLWNpci5jIGIvZHJpdmVycy9tZWRpYS9yYy9udXZvdG9uLWNpci5jCmluZGV4IGRkNGNhZjguLjI3M2Q5ZDYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcmMvbnV2b3Rvbi1jaXIuYworKysgYi9kcml2ZXJzL21lZGlhL3JjL251dm90b24tY2lyLmMKQEAgLTQ2MCw3ICs0NjAsNyBAQAogCQlyZXR1cm4gMDsKIAl9CiAKLQljYXJyaWVyID0gKGNvdW50ICogMTAwMDAwMCkgLyBkdXJhdGlvbjsKKwljYXJyaWVyID0gTVNfVE9fTlMoY291bnQpIC8gZHVyYXRpb247CiAKIAlpZiAoKGNhcnJpZXIgPiBNQVhfQ0FSUklFUikgfHwgKGNhcnJpZXIgPCBNSU5fQ0FSUklFUikpCiAJCW52dF9kYmcoIldURj8gQ2FycmllciBmcmVxdWVuY3kgb3V0IG9mIHJhbmdlISIpOwpAQCAtNjEyLDggKzYxMiw4IEBACiAJCXNhbXBsZSA9IG52dC0+YnVmW2ldOwogCiAJCXJhd2lyLnB1bHNlID0gKChzYW1wbGUgJiBCVUZfUFVMU0VfQklUKSAhPSAwKTsKLQkJcmF3aXIuZHVyYXRpb24gPSAoc2FtcGxlICYgQlVGX0xFTl9NQVNLKQotCQkJCQkqIFNBTVBMRV9QRVJJT0QgKiAxMDAwOworCQlyYXdpci5kdXJhdGlvbiA9IFVTX1RPX05TKChzYW1wbGUgJiBCVUZfTEVOX01BU0spCisJCQkJCSAgKiBTQU1QTEVfUEVSSU9EKTsKIAogCQlpZiAoKHNhbXBsZSAmIEJVRl9MRU5fTUFTSykgPT0gQlVGX0xFTl9NQVNLKSB7CiAJCQlpZiAobnZ0LT5yYXdpci5wdWxzZSA9PSByYXdpci5wdWxzZSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcmMvcmMtbWFpbi5jIGIvZHJpdmVycy9tZWRpYS9yYy9yYy1tYWluLmMKaW5kZXggNzJiZThhMC4uNTEyYTJmNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9yYy9yYy1tYWluLmMKKysrIGIvZHJpdmVycy9tZWRpYS9yYy9yYy1tYWluLmMKQEAgLTQ1OCwyMSArNDU4LDI3IEBACiAJCWluZGV4ID0gaXJfbG9va3VwX2J5X3NjYW5jb2RlKHJjX21hcCwgc2NhbmNvZGUpOwogCX0KIAotCWlmIChpbmRleCA+PSByY19tYXAtPmxlbikgewotCQlpZiAoIShrZS0+ZmxhZ3MgJiBJTlBVVF9LRVlNQVBfQllfSU5ERVgpKQotCQkJSVJfZHByaW50aygxLCAidW5rbm93biBrZXkgZm9yIHNjYW5jb2RlIDB4JTA0eFxuIiwKLQkJCQkgICBzY2FuY29kZSk7CisJaWYgKGluZGV4IDwgcmNfbWFwLT5sZW4pIHsKKwkJZW50cnkgPSAmcmNfbWFwLT5zY2FuW2luZGV4XTsKKworCQlrZS0+aW5kZXggPSBpbmRleDsKKwkJa2UtPmtleWNvZGUgPSBlbnRyeS0+a2V5Y29kZTsKKwkJa2UtPmxlbiA9IHNpemVvZihlbnRyeS0+c2NhbmNvZGUpOworCQltZW1jcHkoa2UtPnNjYW5jb2RlLCAmZW50cnktPnNjYW5jb2RlLCBzaXplb2YoZW50cnktPnNjYW5jb2RlKSk7CisKKwl9IGVsc2UgaWYgKCEoa2UtPmZsYWdzICYgSU5QVVRfS0VZTUFQX0JZX0lOREVYKSkgeworCQkvKgorCQkgKiBXZSBkbyBub3QgcmVhbGx5IGtub3cgdGhlIHZhbGlkIHJhbmdlIG9mIHNjYW5jb2RlcworCQkgKiBzbyBsZXQncyByZXNwb25kIHdpdGggS0VZX1JFU0VSVkVEIHRvIGFueXRoaW5nIHdlCisJCSAqIGRvIG5vdCBoYXZlIG1hcHBpbmcgZm9yIFt5ZXRdLgorCQkgKi8KKwkJa2UtPmluZGV4ID0gaW5kZXg7CisJCWtlLT5rZXljb2RlID0gS0VZX1JFU0VSVkVEOworCX0gZWxzZSB7CiAJCXJldHZhbCA9IC1FSU5WQUw7CiAJCWdvdG8gb3V0OwogCX0KIAotCWVudHJ5ID0gJnJjX21hcC0+c2NhbltpbmRleF07Ci0KLQlrZS0+aW5kZXggPSBpbmRleDsKLQlrZS0+a2V5Y29kZSA9IGVudHJ5LT5rZXljb2RlOwotCWtlLT5sZW4gPSBzaXplb2YoZW50cnktPnNjYW5jb2RlKTsKLQltZW1jcHkoa2UtPnNjYW5jb2RlLCAmZW50cnktPnNjYW5jb2RlLCBzaXplb2YoZW50cnktPnNjYW5jb2RlKSk7Ci0KIAlyZXR2YWwgPSAwOwogCiBvdXQ6CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3JjL3N0cmVhbXphcC5jIGIvZHJpdmVycy9tZWRpYS9yYy9zdHJlYW16YXAuYwppbmRleCA2ZTI5MTFjLi5lNDM1ZDk0IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3JjL3N0cmVhbXphcC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcmMvc3RyZWFtemFwLmMKQEAgLTE2NCw3ICsxNjQsNyBAQAogCQkJCXN6LT5zaWduYWxfc3RhcnQudHZfdXNlYyAtCiAJCQkJc3otPnNpZ25hbF9sYXN0LnR2X3VzZWMpOwogCQkJcmF3aXIuZHVyYXRpb24gLT0gc3otPnN1bTsKLQkJCXJhd2lyLmR1cmF0aW9uICo9IDEwMDA7CisJCQlyYXdpci5kdXJhdGlvbiA9IFVTX1RPX05TKHJhd2lyLmR1cmF0aW9uKTsKIAkJCXJhd2lyLmR1cmF0aW9uICY9IElSX01BWF9EVVJBVElPTjsKIAkJfQogCQlzel9wdXNoKHN6LCByYXdpcik7CkBAIC0xNzcsNyArMTc3LDcgQEAKIAlyYXdpci5kdXJhdGlvbiA9ICgoaW50KSB2YWx1ZSkgKiBTWl9SRVNPTFVUSU9OOwogCXJhd2lyLmR1cmF0aW9uICs9IFNaX1JFU09MVVRJT04gLyAyOwogCXN6LT5zdW0gKz0gcmF3aXIuZHVyYXRpb247Ci0JcmF3aXIuZHVyYXRpb24gKj0gMTAwMDsKKwlyYXdpci5kdXJhdGlvbiA9IFVTX1RPX05TKHJhd2lyLmR1cmF0aW9uKTsKIAlyYXdpci5kdXJhdGlvbiAmPSBJUl9NQVhfRFVSQVRJT047CiAJc3pfcHVzaChzeiwgcmF3aXIpOwogfQpAQCAtMTk3LDcgKzE5Nyw3IEBACiAJcmF3aXIuZHVyYXRpb24gPSAoKGludCkgdmFsdWUpICogU1pfUkVTT0xVVElPTjsKIAlyYXdpci5kdXJhdGlvbiArPSBTWl9SRVNPTFVUSU9OIC8gMjsKIAlzei0+c3VtICs9IHJhd2lyLmR1cmF0aW9uOwotCXJhd2lyLmR1cmF0aW9uICo9IDEwMDA7CisJcmF3aXIuZHVyYXRpb24gPSBVU19UT19OUyhyYXdpci5kdXJhdGlvbik7CiAJc3pfcHVzaChzeiwgcmF3aXIpOwogfQogCkBAIC0yNzMsNiArMjczLDcgQEAKIAkJCQlpZiAoc3otPnRpbWVvdXRfZW5hYmxlZCkKIAkJCQkJc3pfcHVzaChzeiwgcmF3aXIpOwogCQkJCWlyX3Jhd19ldmVudF9oYW5kbGUoc3otPnJkZXYpOworCQkJCWlyX3Jhd19ldmVudF9yZXNldChzei0+cmRldik7CiAJCQl9IGVsc2UgewogCQkJCXN6X3B1c2hfZnVsbF9zcGFjZShzeiwgc3otPmJ1Zl9pbltpXSk7CiAJCQl9CkBAIC0yOTAsNiArMjkxLDcgQEAKIAkJfQogCX0KIAorCWlyX3Jhd19ldmVudF9oYW5kbGUoc3otPnJkZXYpOwogCXVzYl9zdWJtaXRfdXJiKHVyYiwgR0ZQX0FUT01JQyk7CiAKIAlyZXR1cm47CkBAIC00MzAsMTMgKzQzMiwxMyBAQAogCXN6LT5kZWNvZGVyX3N0YXRlID0gUHVsc2VTcGFjZTsKIAkvKiBGSVhNRTogZG9uJ3QgeWV0IGhhdmUgYSB3YXkgdG8gc2V0IHRoaXMgKi8KIAlzei0+dGltZW91dF9lbmFibGVkID0gdHJ1ZTsKLQlzei0+cmRldi0+dGltZW91dCA9ICgoKFNaX1RJTUVPVVQgKiBTWl9SRVNPTFVUSU9OICogMTAwMCkgJgorCXN6LT5yZGV2LT50aW1lb3V0ID0gKChVU19UT19OUyhTWl9USU1FT1VUICogU1pfUkVTT0xVVElPTikgJgogCQkJCUlSX01BWF9EVVJBVElPTikgfCAweDAzMDAwMDAwKTsKIAkjaWYgMAogCS8qIG5vdCB5ZXQgc3VwcG9ydGVkLCBkZXBlbmRzIG9uIHBhdGNoZXMgZnJvbSBtYXhpbSAqLwogCS8qIHNlZSBhbHNvOiBMSVJDX0dFVF9SRUNfUkVTT0xVVElPTiBhbmQgTElSQ19TRVRfUkVDX1RJTUVPVVQgKi8KLQlzei0+bWluX3RpbWVvdXQgPSBTWl9USU1FT1VUICogU1pfUkVTT0xVVElPTiAqIDEwMDA7Ci0Jc3otPm1heF90aW1lb3V0ID0gU1pfVElNRU9VVCAqIFNaX1JFU09MVVRJT04gKiAxMDAwOworCXN6LT5taW5fdGltZW91dCA9IFVTX1RPX05TKFNaX1RJTUVPVVQgKiBTWl9SRVNPTFVUSU9OKTsKKwlzei0+bWF4X3RpbWVvdXQgPSBVU19UT19OUyhTWl9USU1FT1VUICogU1pfUkVTT0xVVElPTik7CiAJI2VuZGlmCiAKIAlkb19nZXR0aW1lb2ZkYXkoJnN6LT5zaWduYWxfc3RhcnQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9LY29uZmlnIGIvZHJpdmVycy9tZWRpYS92aWRlby9LY29uZmlnCmluZGV4IGViODc1YWYuLmFhMDIxNjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vS2NvbmZpZworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL0tjb25maWcKQEAgLTc4LDcgKzc4LDcgQEAKIAogY29uZmlnIFZJREVPX0hFTFBFUl9DSElQU19BVVRPCiAJYm9vbCAiQXV0b3NlbGVjdCBwZXJ0aW5lbnQgZW5jb2RlcnMvZGVjb2RlcnMgYW5kIG90aGVyIGhlbHBlciBjaGlwcyIKLQlkZWZhdWx0IHkgaWYgIUVNQkVEREVECisJZGVmYXVsdCB5IGlmICFFWFBFUlQKIAktLS1oZWxwLS0tCiAJICBNb3N0IHZpZGVvIGNhcmRzIG1heSByZXF1aXJlIGFkZGl0aW9uYWwgbW9kdWxlcyB0byBlbmNvZGUgb3IKIAkgIGRlY29kZSBhdWRpby92aWRlbyBzdGFuZGFyZHMuIFRoaXMgb3B0aW9uIHdpbGwgYXV0b3NlbGVjdApAQCAtMTQxLDE1ICsxNDEsNiBAQAogCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hvb3NlIE0gaGVyZTogdGhlCiAJICBtb2R1bGUgd2lsbCBiZSBjYWxsZWQgdGRhOTg0MC4KIAotY29uZmlnIFZJREVPX1REQTk4NzUKLQl0cmlzdGF0ZSAiUGhpbGlwcyBUREE5ODc1IGF1ZGlvIHByb2Nlc3NvciIKLQlkZXBlbmRzIG9uIFZJREVPX1Y0TDIgJiYgSTJDCi0JLS0taGVscC0tLQotCSAgU3VwcG9ydCBmb3IgdGRhOTg3NSBhdWRpbyBkZWNvZGVyIGNoaXAgZm91bmQgb24gc29tZSBidDh4eCBib2FyZHMuCi0KLQkgIFRvIGNvbXBpbGUgdGhpcyBkcml2ZXIgYXMgYSBtb2R1bGUsIGNob29zZSBNIGhlcmU6IHRoZQotCSAgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIHRkYTk4NzUuCi0KIGNvbmZpZyBWSURFT19URUE2NDE1QwogCXRyaXN0YXRlICJQaGlsaXBzIFRFQTY0MTVDIGF1ZGlvIHByb2Nlc3NvciIKIAlkZXBlbmRzIG9uIEkyQwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9NYWtlZmlsZSBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vTWFrZWZpbGUKaW5kZXggODFlMzhjYi4uYTUwOWQzMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9NYWtlZmlsZQorKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL01ha2VmaWxlCkBAIC0yNyw3ICsyNyw2IEBACiBvYmotJChDT05GSUdfVklERU9fVFVORVIpICs9IHR1bmVyLm8KIG9iai0kKENPTkZJR19WSURFT19UVkFVRElPKSArPSB0dmF1ZGlvLm8KIG9iai0kKENPTkZJR19WSURFT19UREE3NDMyKSArPSB0ZGE3NDMyLm8KLW9iai0kKENPTkZJR19WSURFT19UREE5ODc1KSArPSB0ZGE5ODc1Lm8KIG9iai0kKENPTkZJR19WSURFT19TQUE2NTg4KSArPSBzYWE2NTg4Lm8KIG9iai0kKENPTkZJR19WSURFT19UREE5ODQwKSArPSB0ZGE5ODQwLm8KIG9iai0kKENPTkZJR19WSURFT19URUE2NDE1QykgKz0gdGVhNjQxNWMubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9hZHY3MTc1LmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2FkdjcxNzUuYwppbmRleCBmMzE4YjUxLi5kMjMyN2RiIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2FkdjcxNzUuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2FkdjcxNzUuYwpAQCAtMzAzLDExICszMDMsMjIgQEAKIAlyZXR1cm4gdjRsMl9jaGlwX2lkZW50X2kyY19jbGllbnQoY2xpZW50LCBjaGlwLCBWNEwyX0lERU5UX0FEVjcxNzUsIDApOwogfQogCitzdGF0aWMgaW50IGFkdjcxNzVfc19wb3dlcihzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkLCBpbnQgb24pCit7CisJaWYgKG9uKQorCQlhZHY3MTc1X3dyaXRlKHNkLCAweDAxLCAweDAwKTsKKwllbHNlCisJCWFkdjcxNzVfd3JpdGUoc2QsIDB4MDEsIDB4NzgpOworCisJcmV0dXJuIDA7Cit9CisKIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdjRsMl9zdWJkZXZfY29yZV9vcHMgYWR2NzE3NV9jb3JlX29wcyA9IHsKIAkuZ19jaGlwX2lkZW50ID0gYWR2NzE3NV9nX2NoaXBfaWRlbnQsCiAJLmluaXQgPSBhZHY3MTc1X2luaXQsCisJLnNfcG93ZXIgPSBhZHY3MTc1X3NfcG93ZXIsCiB9OwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHY0bDJfc3ViZGV2X3ZpZGVvX29wcyBhZHY3MTc1X3ZpZGVvX29wcyA9IHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vYnQ4eHgvYnR0di1jYXJkcy5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9idDh4eC9idHR2LWNhcmRzLmMKaW5kZXggNDllZmNmNi4uN2Y1ODc1NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9idDh4eC9idHR2LWNhcmRzLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9idDh4eC9idHR2LWNhcmRzLmMKQEAgLTEzNzMsNyArMTM3Myw2IEBACiAJCS5ncGlvbXV0ZSAJPSAweDE4MDAsCiAJCS5hdWRpb19tb2RlX2dwaW89IGZ2MjAwMHNfYXVkaW8sCiAJCS5ub19tc3AzNHh4CT0gMSwKLQkJLm5vX3RkYTk4NzUJPSAxLAogCQkubmVlZHNfdHZhdWRpbyAgPSAxLAogCQkucGxsICAgICAgICAgICAgPSBQTExfMjgsCiAJCS50dW5lcl90eXBlICAgICA9IFRVTkVSX1BISUxJUFNfUEFMLApAQCAtMTUxMSw3ICsxNTEwLDYgQEAKIAkJLmdwaW9tdXRlIAk9IDB4MDksCiAJCS5uZWVkc190dmF1ZGlvICA9IDEsCiAJCS5ub19tc3AzNHh4CT0gMSwKLQkJLm5vX3RkYTk4NzUJPSAxLAogCQkucGxsCQk9IFBMTF8yOCwKIAkJLnR1bmVyX3R5cGUJPSBUVU5FUl9QSElMSVBTX1BBTCwKIAkJLnR1bmVyX2FkZHIJPSBBRERSX1VOU0VULApAQCAtMTU1MCw3ICsxNTQ4LDYgQEAKIAkJLmdwaW9tYXNrMiAgICAgID0gMHgwN2ZmLAogCQkubXV4c2VsICAgICAgICAgPSBNVVhTRUwoMywgMywgMywgMywgMywgMywgMywgMywgMywgMywgMywgMywgMywgMywgMywgMyksCiAJCS5ub19tc3AzNHh4ICAgICA9IDEsCi0JCS5ub190ZGE5ODc1ICAgICA9IDEsCiAJCS50dW5lcl90eXBlICAgICA9IFRVTkVSX0FCU0VOVCwKIAkJLnR1bmVyX2FkZHIJPSBBRERSX1VOU0VULAogCQkubXV4c2VsX2hvb2sgICAgPSBydjYwNV9tdXhzZWwsCkBAIC0xNjg2LDcgKzE2ODMsNiBAQAogCQkudHVuZXJfdHlwZSAgICAgPSBUVU5FUl9BQlNFTlQsCiAJCS50dW5lcl9hZGRyCT0gQUREUl9VTlNFVCwKIAkJLm5vX21zcDM0eHggICAgID0gMSwKLQkJLm5vX3RkYTk4NzUgICAgID0gMSwKIAkJLm5vX3RkYTc0MzIgICAgID0gMSwKIAl9LAogCVtCVFRWX0JPQVJEX09TUFJFWTF4MF84NDhdID0gewpAQCAtMTY5OSw3ICsxNjk1LDYgQEAKIAkJLnR1bmVyX3R5cGUgICAgID0gVFVORVJfQUJTRU5ULAogCQkudHVuZXJfYWRkcgk9IEFERFJfVU5TRVQsCiAJCS5ub19tc3AzNHh4ICAgICA9IDEsCi0JCS5ub190ZGE5ODc1ICAgICA9IDEsCiAJCS5ub190ZGE3NDMyICAgICA9IDEsCiAJfSwKIApAQCAtMTcxNCw3ICsxNzA5LDYgQEAKIAkJLnR1bmVyX3R5cGUgICAgID0gVFVORVJfQUJTRU5ULAogCQkudHVuZXJfYWRkcgk9IEFERFJfVU5TRVQsCiAJCS5ub19tc3AzNHh4ICAgICA9IDEsCi0JCS5ub190ZGE5ODc1ICAgICA9IDEsCiAJCS5ub190ZGE3NDMyICAgICA9IDEsCiAJfSwKIAlbQlRUVl9CT0FSRF9PU1BSRVkxeDFdID0gewpAQCAtMTcyNyw3ICsxNzIxLDYgQEAKIAkJLnR1bmVyX3R5cGUgICAgID0gVFVORVJfQUJTRU5ULAogCQkudHVuZXJfYWRkcgk9IEFERFJfVU5TRVQsCiAJCS5ub19tc3AzNHh4ICAgICA9IDEsCi0JCS5ub190ZGE5ODc1ICAgICA9IDEsCiAJCS5ub190ZGE3NDMyICAgICA9IDEsCiAJfSwKIAlbQlRUVl9CT0FSRF9PU1BSRVkxeDFfU1ZJRF0gPSB7CkBAIC0xNzQwLDcgKzE3MzMsNiBAQAogCQkudHVuZXJfdHlwZSAgICAgPSBUVU5FUl9BQlNFTlQsCiAJCS50dW5lcl9hZGRyCT0gQUREUl9VTlNFVCwKIAkJLm5vX21zcDM0eHggICAgID0gMSwKLQkJLm5vX3RkYTk4NzUgICAgID0gMSwKIAkJLm5vX3RkYTc0MzIgICAgID0gMSwKIAl9LAogCVtCVFRWX0JPQVJEX09TUFJFWTJ4eF0gPSB7CkBAIC0xNzUzLDcgKzE3NDUsNiBAQAogCQkudHVuZXJfdHlwZQk9IFRVTkVSX0FCU0VOVCwKIAkJLnR1bmVyX2FkZHIJPSBBRERSX1VOU0VULAogCQkubm9fbXNwMzR4eCAgICAgPSAxLAotCQkubm9fdGRhOTg3NSAgICAgPSAxLAogCQkubm9fdGRhNzQzMiAgICAgPSAxLAogCX0sCiAKQEAgLTE3NjgsNyArMTc1OSw2IEBACiAJCS50dW5lcl90eXBlCT0gVFVORVJfQUJTRU5ULAogCQkudHVuZXJfYWRkcgk9IEFERFJfVU5TRVQsCiAJCS5ub19tc3AzNHh4ICAgICA9IDEsCi0JCS5ub190ZGE5ODc1ICAgICA9IDEsCiAJCS5ub190ZGE3NDMyICAgICA9IDEsCiAJfSwKIAlbQlRUVl9CT0FSRF9PU1BSRVkyeDBdID0gewpAQCAtMTc4MSw3ICsxNzcxLDYgQEAKIAkJLnR1bmVyX3R5cGUJPSBUVU5FUl9BQlNFTlQsCiAJCS50dW5lcl9hZGRyCT0gQUREUl9VTlNFVCwKIAkJLm5vX21zcDM0eHggICAgID0gMSwKLQkJLm5vX3RkYTk4NzUgICAgID0gMSwKIAkJLm5vX3RkYTc0MzIgICAgID0gMSwKIAl9LAogCVtCVFRWX0JPQVJEX09TUFJFWTUwMF0gPSB7CkBAIC0xNzk0LDcgKzE3ODMsNiBAQAogCQkudHVuZXJfdHlwZSAgICAgPSBUVU5FUl9BQlNFTlQsCiAJCS50dW5lcl9hZGRyCT0gQUREUl9VTlNFVCwKIAkJLm5vX21zcDM0eHggICAgID0gMSwKLQkJLm5vX3RkYTk4NzUgICAgID0gMSwKIAkJLm5vX3RkYTc0MzIgICAgID0gMSwKIAl9LAogCVtCVFRWX0JPQVJEX09TUFJFWTU0MF0gPSB7CkBAIC0xODA1LDcgKzE3OTMsNiBAQAogCQkudHVuZXJfdHlwZSAgICAgPSBUVU5FUl9BQlNFTlQsCiAJCS50dW5lcl9hZGRyCT0gQUREUl9VTlNFVCwKIAkJLm5vX21zcDM0eHggICAgID0gMSwKLQkJLm5vX3RkYTk4NzUgICAgID0gMSwKIAkJLm5vX3RkYTc0MzIgICAgID0gMSwKIAl9LAogCkBAIC0xODIwLDcgKzE4MDcsNiBAQAogCQkudHVuZXJfdHlwZQk9IFRVTkVSX0FCU0VOVCwKIAkJLnR1bmVyX2FkZHIJPSBBRERSX1VOU0VULAogCQkubm9fbXNwMzR4eCAgICAgPSAxLAotCQkubm9fdGRhOTg3NSAgICAgPSAxLAogCQkubm9fdGRhNzQzMiAgICAgPSAxLCAgICAgIC8qIG11c3QgYXZvaWQsIGNvbmZsaWN0cyB3aXRoIHRoZSBidDg2MCAqLwogCX0sCiAJW0JUVFZfQk9BUkRfSURTX0VBR0xFXSA9IHsKQEAgLTE4MzUsNyArMTgyMSw2IEBACiAJCS5tdXhzZWwgICAgICAgICA9IE1VWFNFTCgyLCAyLCAyLCAyKSwKIAkJLm11eHNlbF9ob29rICAgID0gZWFnbGVfbXV4c2VsLAogCQkubm9fbXNwMzR4eCAgICAgPSAxLAotCQkubm9fdGRhOTg3NSAgICAgPSAxLAogCQkucGxsICAgICAgICAgICAgPSBQTExfMjgsCiAJfSwKIAlbQlRUVl9CT0FSRF9QSU5OQUNMRVNBVF0gPSB7CkBAIC0xODQ2LDcgKzE4MzEsNiBAQAogCQkudHVuZXJfdHlwZSAgICAgPSBUVU5FUl9BQlNFTlQsCiAJCS50dW5lcl9hZGRyCT0gQUREUl9VTlNFVCwKIAkJLm5vX21zcDM0eHggICAgID0gMSwKLQkJLm5vX3RkYTk4NzUgICAgID0gMSwKIAkJLm5vX3RkYTc0MzIgICAgID0gMSwKIAkJLm11eHNlbCAgICAgICAgID0gTVVYU0VMKDMsIDEpLAogCQkucGxsICAgICAgICAgICAgPSBQTExfMjgsCkBAIC0xODk3LDcgKzE4ODEsNiBAQAogCQkuc3ZocyAgICAgICAgICAgPSAyLAogCQkuZ3Bpb21hc2sgICAgICAgPSAwLAogCQkubm9fbXNwMzR4eCAgICAgPSAxLAotCQkubm9fdGRhOTg3NSAgICAgPSAxLAogCQkubm9fdGRhNzQzMiAgICAgPSAxLAogCQkubXV4c2VsICAgICAgICAgPSBNVVhTRUwoMiwgMCwgMSksCiAJCS5wbGwgICAgICAgICAgICA9IFBMTF8yOCwKQEAgLTE5NzAsNyArMTk1Myw2IEBACiAJCS8qIFR1bmVyLCBDVmlkLCBTVmlkLCBDVmlkIG92ZXIgU1ZpZCBjb25uZWN0b3IgKi8KIAkJLm11eHNlbCAgICAgICAgID0gTVVYU0VMKDIsIDMsIDEsIDEpLAogCQkuZ3Bpb21hc2sgICAgICAgPSAwLAotCQkubm9fdGRhOTg3NSAgICAgPSAxLAogCQkubm9fdGRhNzQzMiAgICAgPSAxLAogCQkudHVuZXJfdHlwZSAgICAgPSBUVU5FUl9QSElMSVBTX1BBTF9JLAogCQkudHVuZXJfYWRkcgk9IEFERFJfVU5TRVQsCkBAIC0yMDE3LDcgKzE5OTksNiBAQAogCQkubXV4c2VsICAgICAgICAgPSBNVVhTRUwoMiwyLDIsMiwgMywzLDMsMywgMSwxLDEsMSwgMCwwLDAsMCksCiAJCS5tdXhzZWxfaG9vayAgICA9IHhndWFyZF9tdXhzZWwsCiAJCS5ub19tc3AzNHh4ICAgICA9IDEsCi0JCS5ub190ZGE5ODc1ICAgICA9IDEsCiAJCS5ub190ZGE3NDMyICAgICA9IDEsCiAJCS5wbGwgICAgICAgICAgICA9IFBMTF8yOCwKIAl9LApAQCAtMjAyOSw3ICsyMDEwLDYgQEAKIAkJLnN2aHMgICAgICAgICAgID0gTk9fU1ZIUywKIAkJLm11eHNlbCAgICAgICAgID0gTVVYU0VMKDIsIDMsIDEsIDApLAogCQkubm9fbXNwMzR4eCAgICAgPSAxLAotCQkubm9fdGRhOTg3NSAgICAgPSAxLAogCQkubm9fdGRhNzQzMiAgICAgPSAxLAogCQkucGxsICAgICAgICAgICAgPSBQTExfMjgsCiAJCS50dW5lcl90eXBlICAgICA9IFRVTkVSX0FCU0VOVCwKQEAgLTIxMzQsNyArMjExNCw2IEBACiAJCS5zdmhzICAgICAgICAgICA9IE5PX1NWSFMsICAgLyogY2FyZCBoYXMgbm8gc3ZocyAqLwogCQkubmVlZHNfdHZhdWRpbyAgPSAwLAogCQkubm9fbXNwMzR4eCAgICAgPSAxLAotCQkubm9fdGRhOTg3NSAgICAgPSAxLAogCQkubm9fdGRhNzQzMiAgICAgPSAxLAogCQkuZ3Bpb21hc2sgICAgICAgPSAweDAwLAogCQkubXV4c2VsICAgICAgICAgPSBNVVhTRUwoMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCwgMCksCkBAIC0yMTU2LDcgKzIxMzUsNiBAQAogCVtCVFRWX0JPQVJEX1RXSU5IQU5fRFNUXSA9IHsKIAkJLm5hbWUgICAgICAgICAgID0gIlR3aW5oYW4gRFNUICsgY2xvbmVzIiwKIAkJLm5vX21zcDM0eHggICAgID0gMSwKLQkJLm5vX3RkYTk4NzUgICAgID0gMSwKIAkJLm5vX3RkYTc0MzIgICAgID0gMSwKIAkJLnR1bmVyX3R5cGUgICAgID0gVFVORVJfQUJTRU5ULAogCQkudHVuZXJfYWRkcgk9IEFERFJfVU5TRVQsCkBAIC0yMTcxLDcgKzIxNDksNiBAQAogCQkvKiBWaWQgSW4sIFNWaWQgSW4sIFZpZCBvdmVyIFNWaWQgaW4gY29ubmVjdG9yICovCiAJCS5tdXhzZWwJCT0gTVVYU0VMKDMsIDEsIDEsIDMpLAogCQkubm9fbXNwMzR4eCAgICAgPSAxLAotCQkubm9fdGRhOTg3NSAgICAgPSAxLAogCQkubm9fdGRhNzQzMiAgICAgPSAxLAogCQkudHVuZXJfdHlwZSAgICAgPSBUVU5FUl9BQlNFTlQsCiAJCS50dW5lcl9hZGRyCT0gQUREUl9VTlNFVCwKQEAgLTIyMjYsNyArMjIwMyw2IEBACiAJCS5zdmhzICAgICAgICAgICA9IE5PX1NWSFMsCiAJCS5tdXhzZWwgICAgICAgICA9IE1VWFNFTCgyLCAzLCAxLCAwKSwKIAkJLm5vX21zcDM0eHggICAgID0gMSwKLQkJLm5vX3RkYTk4NzUgICAgID0gMSwKIAkJLm5vX3RkYTc0MzIgICAgID0gMSwKIAkJLm5lZWRzX3R2YXVkaW8gID0gMCwKIAkJLnR1bmVyX3R5cGUgICAgID0gVFVORVJfQUJTRU5ULApAQCAtMjI3OCw3ICsyMjU0LDYgQEAKIAkJLmdwaW9tYXNrICAgICAgID0gMCwKIAkJLmdwaW9tYXNrMiAgICAgID0gMHgzQzw8MTYsLypTZXQgdGhlIEdQSU9bMThdLT5HUElPWzIxXSBhcyBvdXRwdXQgcGluLj09PiBkcml2ZSB0aGUgdmlkZW8gaW5wdXRzIHRocm91Z2ggYW5hbG9nIG11bHRpcGxleGVycyovCiAJCS5ub19tc3AzNHh4ICAgICA9IDEsCi0JCS5ub190ZGE5ODc1ICAgICA9IDEsCiAJCS5ub190ZGE3NDMyICAgICA9IDEsCiAJCS8qODc4QSBpbnB1dCBpcyBhbHdheXMgTVVYMCwgc2VlIGFib3ZlLiovCiAJCS5tdXhzZWwgICAgICAgICA9IE1VWFNFTCgyLCAyLCAyLCAyKSwKQEAgLTIzMDIsNyArMjI3Nyw2IEBACiAJCS50dW5lcl90eXBlICAgICA9IFRVTkVSX1RFTUlDX1BBTCwKIAkJLnR1bmVyX2FkZHIJPSBBRERSX1VOU0VULAogCQkubm9fbXNwMzR4eCAgICAgPSAxLAotCQkubm9fdGRhOTg3NSAgICAgPSAxLAogCX0sCiAJW0JUVFZfQk9BUkRfQVZEVkJUXzc3MV0gPSB7CiAJCS8qIFdvbGZyYW0gSm9vc3QgPHdvam9AZnJva2FzY2h3ZWkuZGU+ICovCkBAIC0yMzEzLDcgKzIyODcsNiBAQAogCQkudHVuZXJfYWRkcgk9IEFERFJfVU5TRVQsCiAJCS5tdXhzZWwgICAgICAgICA9IE1VWFNFTCgzLCAzKSwKIAkJLm5vX21zcDM0eHggICAgID0gMSwKLQkJLm5vX3RkYTk4NzUgICAgID0gMSwKIAkJLm5vX3RkYTc0MzIgICAgID0gMSwKIAkJLnBsbCAgICAgICAgICAgID0gUExMXzI4LAogCQkuaGFzX2R2YiAgICAgICAgPSAxLApAQCAtMjMyOSw3ICsyMzAyLDYgQEAKIAkJLnN2aHMgICAgICAgICAgID0gMSwKIAkJLm11eHNlbCAgICAgICAgID0gTVVYU0VMKDMsIDEsIDIsIDApLCAvKiBDb21wMCwgUy1WaWRlbywgPywgPyAqLwogCQkubm9fbXNwMzR4eCAgICAgPSAxLAotCQkubm9fdGRhOTg3NSAgICAgPSAxLAogCQkubm9fdGRhNzQzMiAgICAgPSAxLAogCQkucGxsICAgICAgICAgICAgPSBQTExfMjgsCiAJCS50dW5lcl90eXBlICAgICA9IFRVTkVSX0FCU0VOVCwKQEAgLTIzOTMsNyArMjM2NSw2IEBACiAJCS8qIENocmlzIFBhc2NvZSA8Yy5wYXNjb2VAaXRlZS51cS5lZHUuYXU+ICovCiAJCS5uYW1lICAgICAgICAgICA9ICJEVmlDTyBGdXNpb25IRFRWIERWQi1UIExpdGUiLAogCQkubm9fbXNwMzR4eCAgICAgPSAxLAotCQkubm9fdGRhOTg3NSAgICAgPSAxLAogCQkubm9fdGRhNzQzMiAgICAgPSAxLAogCQkucGxsICAgICAgICAgICAgPSBQTExfMjgsCiAJCS5ub192aWRlbyAgICAgICA9IDEsCkBAIC0yNDQwLDcgKzI0MTEsNiBAQAogCQkubXV4c2VsICAgICAgICAgPSBNVVhTRUwoMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiksCiAJCS5wbGwJCT0gUExMXzI4LAogCQkubm9fbXNwMzR4eCAgICAgPSAxLAotCQkubm9fdGRhOTg3NSAgICAgPSAxLAogCQkubm9fdGRhNzQzMgk9IDEsCiAJCS50dW5lcl90eXBlICAgICA9IFRVTkVSX0FCU0VOVCwKIAkJLnR1bmVyX2FkZHIJPSBBRERSX1VOU0VULApAQCAtMjQ3OCw3ICsyNDQ4LDYgQEAKIAkJLnBsbAkJPSBQTExfMjgsCiAJCS5ub19tc3AzNHh4CT0gMSwKIAkJLm5vX3RkYTc0MzIJPSAxLAotCQkubm9fdGRhOTg3NQk9IDEsCiAJCS5tdXhzZWxfaG9vawk9IGtvZGljb200NDAwcl9tdXhzZWwsCiAJfSwKIAlbQlRUVl9CT0FSRF9LT0RJQ09NXzQ0MDBSX1NMXSA9IHsKQEAgLTI1MDAsNyArMjQ2OSw2IEBACiAJCS5wbGwJCT0gUExMXzI4LAogCQkubm9fbXNwMzR4eAk9IDEsCiAJCS5ub190ZGE3NDMyCT0gMSwKLQkJLm5vX3RkYTk4NzUJPSAxLAogCQkubXV4c2VsX2hvb2sJPSBrb2RpY29tNDQwMHJfbXV4c2VsLAogCX0sCiAJCS8qIC0tLS0gY2FyZCAweDg2LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwpAQCAtMjUzMCw3ICsyNDk4LDYgQEAKIAkJLmdwaW9tdXggICAgICAgID0geyAweDAwNDAwMDA1LCAwLCAweDAwMDAwMDAxLCAwIH0sCiAJCS5ncGlvbXV0ZSAJPSAweDAwYzAwMDA3LAogCQkubm9fbXNwMzR4eCAgICAgPSAxLAotCQkubm9fdGRhOTg3NSAgICAgPSAxLAogCQkubm9fdGRhNzQzMiAgICAgPSAxLAogCQkuaGFzX2R2YiAgICAgICAgPSAxLAogCX0sCkBAIC0yNjMwLDcgKzI1OTcsNiBAQAogCQkudHVuZXJfdHlwZSAgICAgPSBUVU5FUl9BQlNFTlQsCiAJCS50dW5lcl9hZGRyICAgICA9IEFERFJfVU5TRVQsCiAJCS5ub19tc3AzNHh4ICAgICA9IDEsCi0JCS5ub190ZGE5ODc1ICAgICA9IDEsCiAJCS5ub190ZGE3NDMyICAgICA9IDEsCiAJfSwKIAkJLyogLS0tLSBjYXJkIDB4OGQgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwpAQCAtMjY1OCw3ICsyNjI0LDYgQEAKIAkJLm11eHNlbAkJPSBNVVhTRUwoMiwgMywgMSwgMSksCiAJCS5ncGlvbXV4IAk9IHsgMTAwMDAwLCAxMDAwMDIsIDEwMDAwMiwgMTAwMDAwIH0sCiAJCS5ub19tc3AzNHh4CT0gMSwKLQkJLm5vX3RkYTk4NzUgICAgID0gMSwKIAkJLm5vX3RkYTc0MzIgICAgID0gMSwKIAkJLnBsbAkJPSBQTExfMjgsCiAJCS50dW5lcl90eXBlCT0gVFVORVJfVE5GXzUzMzVNRiwKQEAgLTI2NzQsNyArMjYzOSw2IEBACiAJCS5ncGlvbWFzawk9IDB4MGYsIC8qIG9sZDogNyAqLwogCQkubXV4c2VsCQk9IE1VWFNFTCgwLCAxLCAzLCAyKSwgLyogQ29tcG9zaXRlIDAtMyAqLwogCQkubm9fbXNwMzR4eAk9IDEsCi0JCS5ub190ZGE5ODc1ICAgICA9IDEsCiAJCS5ub190ZGE3NDMyICAgICA9IDEsCiAJCS50dW5lcl90eXBlCT0gVFVORVJfQUJTRU5ULAogCQkudHVuZXJfYWRkcgk9IEFERFJfVU5TRVQsCkBAIC0yNzMyLDcgKzI2OTYsNiBAQAogCQkuZ3Bpb211eCAgICAgICAgPSB7IDB4MDA0MDAwMDUsIDAsIDB4MDAwMDAwMDEsIDAgfSwKIAkJLmdwaW9tdXRlIAk9IDB4MDBjMDAwMDcsCiAJCS5ub19tc3AzNHh4ICAgICA9IDEsCi0JCS5ub190ZGE5ODc1ICAgICA9IDEsCiAJCS5ub190ZGE3NDMyICAgICA9IDEsCiAJfSwKIAkvKiAtLS0tIGNhcmQgMHg5NS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KQEAgLTI4NzQsNyArMjgzNyw2IEBACiAJCS5wbGwJCT0gUExMXzI4LAogCQkubm9fbXNwMzR4eAk9IDEsCiAJCS5ub190ZGE3NDMyCT0gMSwKLQkJLm5vX3RkYTk4NzUJPSAxLAogCQkubXV4c2VsX2hvb2sgICAgPSBndjgwMHNfbXV4c2VsLAogCX0sCiAJCVtCVFRWX0JPQVJEX0dFT1ZJU0lPTl9HVjgwMFNfU0xdID0gewpAQCAtMjg5OSw3ICsyODYxLDYgQEAKIAkJLnBsbAkJPSBQTExfMjgsCiAJCS5ub19tc3AzNHh4CT0gMSwKIAkJLm5vX3RkYTc0MzIJPSAxLAotCQkubm9fdGRhOTg3NQk9IDEsCiAJCS5tdXhzZWxfaG9vayAgICA9IGd2ODAwc19tdXhzZWwsCiAJfSwKIAlbQlRUVl9CT0FSRF9QVjE4M10gPSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2J0OHh4L2J0dHYuaCBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vYnQ4eHgvYnR0di5oCmluZGV4IGZkNjJiZjEuLmM2MzMzNTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vYnQ4eHgvYnR0di5oCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vYnQ4eHgvYnR0di5oCkBAIC0yMzQsNyArMjM0LDYgQEAKIAogCS8qIGkyYyBhdWRpbyBmbGFncyAqLwogCXVuc2lnbmVkIGludCBub19tc3AzNHh4OjE7Ci0JdW5zaWduZWQgaW50IG5vX3RkYTk4NzU6MTsKIAl1bnNpZ25lZCBpbnQgbm9fdGRhNzQzMjoxOwogCXVuc2lnbmVkIGludCBuZWVkc190dmF1ZGlvOjE7CiAJdW5zaWduZWQgaW50IG1zcDM0eHhfYWx0OjE7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2NhZmVfY2NpYy5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9jYWZlX2NjaWMuYwppbmRleCA3ODkwODdjLi41NWZmZDYwIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2NhZmVfY2NpYy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vY2FmZV9jY2ljLmMKQEAgLTIwMDEsNiArMjAwMSwxMSBAQAogCQkubWluX3dpZHRoID0gMzIwLAogCQkubWluX2hlaWdodCA9IDI0MCwKIAl9OworCXN0cnVjdCBpMmNfYm9hcmRfaW5mbyBvdjc2NzBfaW5mbyA9IHsKKwkJLnR5cGUgPSAib3Y3NjcwIiwKKwkJLmFkZHIgPSAweDQyLAorCQkucGxhdGZvcm1fZGF0YSA9ICZzZW5zb3JfY2ZnLAorCX07CiAKIAkvKgogCSAqIFN0YXJ0IHB1dHRpbmcgdG9nZXRoZXIgb25lIG9mIG91ciBiaWcgY2FtZXJhIHN0cnVjdHVyZXMuCkBAIC0yMDYyLDkgKzIwNjcsOSBAQAogCWlmIChkbWlfY2hlY2tfc3lzdGVtKG9scGNfeG8xX2RtaSkpCiAJCXNlbnNvcl9jZmcuY2xvY2tfc3BlZWQgPSA0NTsKIAotCWNhbS0+c2Vuc29yX2FkZHIgPSAweDQyOwotCWNhbS0+c2Vuc29yID0gdjRsMl9pMmNfbmV3X3N1YmRldl9jZmcoJmNhbS0+djRsMl9kZXYsICZjYW0tPmkyY19hZGFwdGVyLAotCQkJIm92NzY3MCIsIDAsICZzZW5zb3JfY2ZnLCBjYW0tPnNlbnNvcl9hZGRyLCBOVUxMKTsKKwljYW0tPnNlbnNvcl9hZGRyID0gb3Y3NjcwX2luZm8uYWRkcjsKKwljYW0tPnNlbnNvciA9IHY0bDJfaTJjX25ld19zdWJkZXZfYm9hcmQoJmNhbS0+djRsMl9kZXYsICZjYW0tPmkyY19hZGFwdGVyLAorCQkJJm92NzY3MF9pbmZvLCBOVUxMKTsKIAlpZiAoY2FtLT5zZW5zb3IgPT0gTlVMTCkgewogCQlyZXQgPSAtRU5PREVWOwogCQlnb3RvIG91dF9zbWJ1czsKQEAgLTIxODQsOSArMjE4OSw3IEBACiAJc3RydWN0IGNhZmVfY2FtZXJhICpjYW0gPSB0b19jYW0odjRsMl9kZXYpOwogCWludCByZXQgPSAwOwogCi0JcmV0ID0gcGNpX3Jlc3RvcmVfc3RhdGUocGRldik7Ci0JaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKKwlwY2lfcmVzdG9yZV9zdGF0ZShwZGV2KTsKIAlyZXQgPSBwY2lfZW5hYmxlX2RldmljZShwZGV2KTsKIAogCWlmIChyZXQpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3BpYTIvY3BpYTIuaCBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3BpYTIvY3BpYTIuaAppbmRleCA5MTZjMTNkLi42ZDZkMTg0IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2NwaWEyL2NwaWEyLmgKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9jcGlhMi9jcGlhMi5oCkBAIC0zNzgsNyArMzc4LDcgQEAKIAogc3RydWN0IGNhbWVyYV9kYXRhIHsKIAkvKiBsb2NrcyAqLwotCXN0cnVjdCBtdXRleCBidXN5X2xvY2s7CS8qIGd1YXJkIGFnYWluc3QgU01QIG11bHRpdGhyZWFkaW5nICovCisJc3RydWN0IG11dGV4IHY0bDJfbG9jazsJLyogc2VyaWFsaXplIGZpbGUgb3BlcmF0aW9ucyAqLwogCXN0cnVjdCB2NGwyX3ByaW9fc3RhdGUgcHJpbzsKIAogCS8qIGNhbWVyYSBzdGF0dXMgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3BpYTIvY3BpYTJfY29yZS5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9jcGlhMi9jcGlhMl9jb3JlLmMKaW5kZXggOTYwNmJjMC4uYWFmZmNhOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9jcGlhMi9jcGlhMl9jb3JlLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9jcGlhMi9jcGlhMl9jb3JlLmMKQEAgLTIyNDcsNyArMjI0Nyw3IEBACiAKIAogCWNhbS0+cHJlc2VudCA9IDE7Ci0JbXV0ZXhfaW5pdCgmY2FtLT5idXN5X2xvY2spOworCW11dGV4X2luaXQoJmNhbS0+djRsMl9sb2NrKTsKIAlpbml0X3dhaXRxdWV1ZV9oZWFkKCZjYW0tPndxX3N0cmVhbSk7CiAKIAlyZXR1cm4gY2FtOwpAQCAtMjM2NSw5ICsyMzY1LDkgQEAKIAkJY2hhciBfX3VzZXIgKmJ1ZiwgdW5zaWduZWQgbG9uZyBjb3VudCwgaW50IG5vYmxvY2spCiB7CiAJc3RydWN0IGZyYW1lYnVmICpmcmFtZTsKLQlpZiAoIWNvdW50KSB7CisKKwlpZiAoIWNvdW50KQogCQlyZXR1cm4gMDsKLQl9CiAKIAlpZiAoIWJ1ZikgewogCQlFUlIoIiVzOiBidWZmZXIgTlVMTFxuIixfX2Z1bmNfXyk7CkBAIC0yMzc5LDE3ICsyMzc5LDEyIEBACiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAotCS8qIG1ha2UgdGhpcyBfcmVhbGx5XyBzbXAgYW5kIG11bHRpdGhyZWFkLXNhZmUgKi8KLQlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZjYW0tPmJ1c3lfbG9jaykpCi0JCXJldHVybiAtRVJFU1RBUlRTWVM7Ci0KIAlpZiAoIWNhbS0+cHJlc2VudCkgewogCQlMT0coIiVzOiBjYW1lcmEgcmVtb3ZlZFxuIixfX2Z1bmNfXyk7Ci0JCW11dGV4X3VubG9jaygmY2FtLT5idXN5X2xvY2spOwogCQlyZXR1cm4gMDsJLyogRU9GICovCiAJfQogCi0JaWYoIWNhbS0+c3RyZWFtaW5nKSB7CisJaWYgKCFjYW0tPnN0cmVhbWluZykgewogCQkvKiBTdGFydCBzdHJlYW1pbmcgKi8KIAkJY3BpYTJfdXNiX3N0cmVhbV9zdGFydChjYW0sCiAJCQkJICAgICAgIGNhbS0+cGFyYW1zLmNhbWVyYV9zdGF0ZS5zdHJlYW1fbW9kZSk7CkBAIC0yMzk4LDQyICsyMzkzLDMxIEBACiAJLyogQ29weSBjYW0tPmN1cmJ1ZmYgaW4gY2FzZSBpdCBjaGFuZ2VzIHdoaWxlIHdlJ3JlIHByb2Nlc3NpbmcgKi8KIAlmcmFtZSA9IGNhbS0+Y3VyYnVmZjsKIAlpZiAobm9ibG9jayAmJiBmcmFtZS0+c3RhdHVzICE9IEZSQU1FX1JFQURZKSB7Ci0JCW11dGV4X3VubG9jaygmY2FtLT5idXN5X2xvY2spOwogCQlyZXR1cm4gLUVBR0FJTjsKIAl9CiAKLQlpZihmcmFtZS0+c3RhdHVzICE9IEZSQU1FX1JFQURZKSB7Ci0JCW11dGV4X3VubG9jaygmY2FtLT5idXN5X2xvY2spOworCWlmIChmcmFtZS0+c3RhdHVzICE9IEZSQU1FX1JFQURZKSB7CisJCW11dGV4X3VubG9jaygmY2FtLT52NGwyX2xvY2spOwogCQl3YWl0X2V2ZW50X2ludGVycnVwdGlibGUoY2FtLT53cV9zdHJlYW0sCiAJCQkgICAgICAgIWNhbS0+cHJlc2VudCB8fAogCQkJICAgICAgIChmcmFtZSA9IGNhbS0+Y3VyYnVmZiktPnN0YXR1cyA9PSBGUkFNRV9SRUFEWSk7CisJCW11dGV4X2xvY2soJmNhbS0+djRsMl9sb2NrKTsKIAkJaWYgKHNpZ25hbF9wZW5kaW5nKGN1cnJlbnQpKQogCQkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKLQkJLyogbWFrZSB0aGlzIF9yZWFsbHlfIHNtcCBhbmQgbXVsdGl0aHJlYWQtc2FmZSAqLwotCQlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZjYW0tPmJ1c3lfbG9jaykpIHsKLQkJCXJldHVybiAtRVJFU1RBUlRTWVM7Ci0JCX0KLQkJaWYoIWNhbS0+cHJlc2VudCkgewotCQkJbXV0ZXhfdW5sb2NrKCZjYW0tPmJ1c3lfbG9jayk7CisJCWlmICghY2FtLT5wcmVzZW50KQogCQkJcmV0dXJuIDA7Ci0JCX0KIAl9CiAKIAkvKiBjb3B5IGRhdGEgdG8gdXNlciBzcGFjZSAqLwotCWlmIChmcmFtZS0+bGVuZ3RoID4gY291bnQpIHsKLQkJbXV0ZXhfdW5sb2NrKCZjYW0tPmJ1c3lfbG9jayk7CisJaWYgKGZyYW1lLT5sZW5ndGggPiBjb3VudCkKIAkJcmV0dXJuIC1FRkFVTFQ7Ci0JfQotCWlmIChjb3B5X3RvX3VzZXIoYnVmLCBmcmFtZS0+ZGF0YSwgZnJhbWUtPmxlbmd0aCkpIHsKLQkJbXV0ZXhfdW5sb2NrKCZjYW0tPmJ1c3lfbG9jayk7CisJaWYgKGNvcHlfdG9fdXNlcihidWYsIGZyYW1lLT5kYXRhLCBmcmFtZS0+bGVuZ3RoKSkKIAkJcmV0dXJuIC1FRkFVTFQ7Ci0JfQogCiAJY291bnQgPSBmcmFtZS0+bGVuZ3RoOwogCiAJZnJhbWUtPnN0YXR1cyA9IEZSQU1FX0VNUFRZOwogCi0JbXV0ZXhfdW5sb2NrKCZjYW0tPmJ1c3lfbG9jayk7CiAJcmV0dXJuIGNvdW50OwogfQogCkBAIC0yNDQ3LDE3ICsyNDMxLDEzIEBACiB7CiAJdW5zaWduZWQgaW50IHN0YXR1cz0wOwogCi0JaWYoIWNhbSkgeworCWlmICghY2FtKSB7CiAJCUVSUigiJXM6IEludGVybmFsIGVycm9yLCBjYW1lcmFfZGF0YSBub3QgZm91bmQhXG4iLF9fZnVuY19fKTsKIAkJcmV0dXJuIFBPTExFUlI7CiAJfQogCi0JbXV0ZXhfbG9jaygmY2FtLT5idXN5X2xvY2spOwotCi0JaWYoIWNhbS0+cHJlc2VudCkgewotCQltdXRleF91bmxvY2soJmNhbS0+YnVzeV9sb2NrKTsKKwlpZiAoIWNhbS0+cHJlc2VudCkKIAkJcmV0dXJuIFBPTExIVVA7Ci0JfQogCiAJaWYoIWNhbS0+c3RyZWFtaW5nKSB7CiAJCS8qIFN0YXJ0IHN0cmVhbWluZyAqLwpAQCAtMjQ2NSwxNiArMjQ0NSwxMyBAQAogCQkJCSAgICAgICBjYW0tPnBhcmFtcy5jYW1lcmFfc3RhdGUuc3RyZWFtX21vZGUpOwogCX0KIAotCW11dGV4X3VubG9jaygmY2FtLT5idXN5X2xvY2spOwogCXBvbGxfd2FpdChmaWxwLCAmY2FtLT53cV9zdHJlYW0sIHdhaXQpOwotCW11dGV4X2xvY2soJmNhbS0+YnVzeV9sb2NrKTsKIAogCWlmKCFjYW0tPnByZXNlbnQpCiAJCXN0YXR1cyA9IFBPTExIVVA7CiAJZWxzZSBpZihjYW0tPmN1cmJ1ZmYtPnN0YXR1cyA9PSBGUkFNRV9SRUFEWSkKIAkJc3RhdHVzID0gUE9MTElOIHwgUE9MTFJETk9STTsKIAotCW11dGV4X3VubG9jaygmY2FtLT5idXN5X2xvY2spOwogCXJldHVybiBzdGF0dXM7CiB9CiAKQEAgLTI0OTYsMjkgKzI0NzMsMTkgQEAKIAogCURCRygibW1hcCBvZmZzZXQ6JWxkIHNpemU6JWxkXG4iLCBzdGFydF9vZmZzZXQsIHNpemUpOwogCi0JLyogbWFrZSB0aGlzIF9yZWFsbHlfIHNtcC1zYWZlICovCi0JaWYgKG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmY2FtLT5idXN5X2xvY2spKQotCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwotCi0JaWYgKCFjYW0tPnByZXNlbnQpIHsKLQkJbXV0ZXhfdW5sb2NrKCZjYW0tPmJ1c3lfbG9jayk7CisJaWYgKCFjYW0tPnByZXNlbnQpCiAJCXJldHVybiAtRU5PREVWOwotCX0KIAogCWlmIChzaXplID4gY2FtLT5mcmFtZV9zaXplKmNhbS0+bnVtX2ZyYW1lcyAgfHwKIAkgICAgKHN0YXJ0X29mZnNldCAlIGNhbS0+ZnJhbWVfc2l6ZSkgIT0gMCB8fAotCSAgICAoc3RhcnRfb2Zmc2V0K3NpemUgPiBjYW0tPmZyYW1lX3NpemUqY2FtLT5udW1fZnJhbWVzKSkgewotCQltdXRleF91bmxvY2soJmNhbS0+YnVzeV9sb2NrKTsKKwkgICAgKHN0YXJ0X29mZnNldCtzaXplID4gY2FtLT5mcmFtZV9zaXplKmNhbS0+bnVtX2ZyYW1lcykpCiAJCXJldHVybiAtRUlOVkFMOwotCX0KIAogCXBvcyA9ICgodW5zaWduZWQgbG9uZykgKGNhbS0+ZnJhbWVfYnVmZmVyKSkgKyBzdGFydF9vZmZzZXQ7CiAJd2hpbGUgKHNpemUgPiAwKSB7CiAJCXBhZ2UgPSBrdmlydF90b19wYShwb3MpOwotCQlpZiAocmVtYXBfcGZuX3JhbmdlKHZtYSwgc3RhcnQsIHBhZ2UgPj4gUEFHRV9TSElGVCwgUEFHRV9TSVpFLCBQQUdFX1NIQVJFRCkpIHsKLQkJCW11dGV4X3VubG9jaygmY2FtLT5idXN5X2xvY2spOworCQlpZiAocmVtYXBfcGZuX3JhbmdlKHZtYSwgc3RhcnQsIHBhZ2UgPj4gUEFHRV9TSElGVCwgUEFHRV9TSVpFLCBQQUdFX1NIQVJFRCkpCiAJCQlyZXR1cm4gLUVBR0FJTjsKLQkJfQogCQlzdGFydCArPSBQQUdFX1NJWkU7CiAJCXBvcyArPSBQQUdFX1NJWkU7CiAJCWlmIChzaXplID4gUEFHRV9TSVpFKQpAQCAtMjUyOCw3ICsyNDk1LDUgQEAKIAl9CiAKIAljYW0tPm1tYXBwZWQgPSB0cnVlOwotCW11dGV4X3VubG9jaygmY2FtLT5idXN5X2xvY2spOwogCXJldHVybiAwOwogfQotCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2NwaWEyL2NwaWEyX3Y0bC5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9jcGlhMi9jcGlhMl92NGwuYwppbmRleCA3ZWRmODBiLi45YmFkMzk4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2NwaWEyL2NwaWEyX3Y0bC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3BpYTIvY3BpYTJfdjRsLmMKQEAgLTIzOCw1OSArMjM4LDQwIEBACiBzdGF0aWMgaW50IGNwaWEyX29wZW4oc3RydWN0IGZpbGUgKmZpbGUpCiB7CiAJc3RydWN0IGNhbWVyYV9kYXRhICpjYW0gPSB2aWRlb19kcnZkYXRhKGZpbGUpOwotCWludCByZXR2YWwgPSAwOworCXN0cnVjdCBjcGlhMl9maCAqZmg7CiAKIAlpZiAoIWNhbSkgewogCQlFUlIoIkludGVybmFsIGVycm9yLCBjYW1lcmFfZGF0YSBub3QgZm91bmQhXG4iKTsKIAkJcmV0dXJuIC1FTk9ERVY7CiAJfQogCi0JaWYobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZjYW0tPmJ1c3lfbG9jaykpCi0JCXJldHVybiAtRVJFU1RBUlRTWVM7CisJaWYgKCFjYW0tPnByZXNlbnQpCisJCXJldHVybiAtRU5PREVWOwogCi0JaWYoIWNhbS0+cHJlc2VudCkgewotCQlyZXR2YWwgPSAtRU5PREVWOwotCQlnb3RvIGVycl9yZXR1cm47CisJaWYgKGNhbS0+b3Blbl9jb3VudCA9PSAwKSB7CisJCWlmIChjcGlhMl9hbGxvY2F0ZV9idWZmZXJzKGNhbSkpCisJCQlyZXR1cm4gLUVOT01FTTsKKworCQkvKiByZXNldCB0aGUgY2FtZXJhICovCisJCWlmIChjcGlhMl9yZXNldF9jYW1lcmEoY2FtKSA8IDApCisJCQlyZXR1cm4gLUVJTzsKKworCQljYW0tPkFQUF9sZW4gPSAwOworCQljYW0tPkNPTV9sZW4gPSAwOwogCX0KIAotCWlmIChjYW0tPm9wZW5fY291bnQgPiAwKSB7Ci0JCWdvdG8gc2tpcF9pbml0OwotCX0KLQotCWlmIChjcGlhMl9hbGxvY2F0ZV9idWZmZXJzKGNhbSkpIHsKLQkJcmV0dmFsID0gLUVOT01FTTsKLQkJZ290byBlcnJfcmV0dXJuOwotCX0KLQotCS8qIHJlc2V0IHRoZSBjYW1lcmEgKi8KLQlpZiAoY3BpYTJfcmVzZXRfY2FtZXJhKGNhbSkgPCAwKSB7Ci0JCXJldHZhbCA9IC1FSU87Ci0JCWdvdG8gZXJyX3JldHVybjsKLQl9Ci0KLQljYW0tPkFQUF9sZW4gPSAwOwotCWNhbS0+Q09NX2xlbiA9IDA7Ci0KLXNraXBfaW5pdDoKLQl7Ci0JCXN0cnVjdCBjcGlhMl9maCAqZmggPSBrbWFsbG9jKHNpemVvZigqZmgpLEdGUF9LRVJORUwpOwotCQlpZighZmgpIHsKLQkJCXJldHZhbCA9IC1FTk9NRU07Ci0JCQlnb3RvIGVycl9yZXR1cm47Ci0JCX0KLQkJZmlsZS0+cHJpdmF0ZV9kYXRhID0gZmg7Ci0JCWZoLT5wcmlvID0gVjRMMl9QUklPUklUWV9VTlNFVDsKLQkJdjRsMl9wcmlvX29wZW4oJmNhbS0+cHJpbywgJmZoLT5wcmlvKTsKLQkJZmgtPm1tYXBwZWQgPSAwOwotCX0KKwlmaCA9IGttYWxsb2Moc2l6ZW9mKCpmaCksIEdGUF9LRVJORUwpOworCWlmICghZmgpCisJCXJldHVybiAtRU5PTUVNOworCWZpbGUtPnByaXZhdGVfZGF0YSA9IGZoOworCWZoLT5wcmlvID0gVjRMMl9QUklPUklUWV9VTlNFVDsKKwl2NGwyX3ByaW9fb3BlbigmY2FtLT5wcmlvLCAmZmgtPnByaW8pOworCWZoLT5tbWFwcGVkID0gMDsKIAogCSsrY2FtLT5vcGVuX2NvdW50OwogCiAJY3BpYTJfZGJnX2R1bXBfcmVnaXN0ZXJzKGNhbSk7Ci0KLWVycl9yZXR1cm46Ci0JbXV0ZXhfdW5sb2NrKCZjYW0tPmJ1c3lfbG9jayk7Ci0JcmV0dXJuIHJldHZhbDsKKwlyZXR1cm4gMDsKIH0KIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgpAQCAtMzA0LDE1ICsyODUsMTEgQEAKIAlzdHJ1Y3QgY2FtZXJhX2RhdGEgKmNhbSA9IHZpZGVvX2dldF9kcnZkYXRhKGRldik7CiAJc3RydWN0IGNwaWEyX2ZoICpmaCA9IGZpbGUtPnByaXZhdGVfZGF0YTsKIAotCW11dGV4X2xvY2soJmNhbS0+YnVzeV9sb2NrKTsKLQogCWlmIChjYW0tPnByZXNlbnQgJiYKLQkgICAgKGNhbS0+b3Blbl9jb3VudCA9PSAxCi0JICAgICB8fCBmaC0+cHJpbyA9PSBWNEwyX1BSSU9SSVRZX1JFQ09SRAotCSAgICApKSB7CisJICAgIChjYW0tPm9wZW5fY291bnQgPT0gMSB8fCBmaC0+cHJpbyA9PSBWNEwyX1BSSU9SSVRZX1JFQ09SRCkpIHsKIAkJY3BpYTJfdXNiX3N0cmVhbV9zdG9wKGNhbSk7CiAKLQkJaWYoY2FtLT5vcGVuX2NvdW50ID09IDEpIHsKKwkJaWYgKGNhbS0+b3Blbl9jb3VudCA9PSAxKSB7CiAJCQkvKiBzYXZlIGNhbWVyYSBzdGF0ZSBmb3IgbGF0ZXIgb3BlbiAqLwogCQkJY3BpYTJfc2F2ZV9jYW1lcmFfc3RhdGUoY2FtKTsKIApAQCAtMzIxLDI2ICsyOTgsMjEgQEAKIAkJfQogCX0KIAotCXsKLQkJaWYoZmgtPm1tYXBwZWQpCi0JCQljYW0tPm1tYXBwZWQgPSAwOwotCQl2NGwyX3ByaW9fY2xvc2UoJmNhbS0+cHJpbywgZmgtPnByaW8pOwotCQlmaWxlLT5wcml2YXRlX2RhdGEgPSBOVUxMOwotCQlrZnJlZShmaCk7Ci0JfQorCWlmIChmaC0+bW1hcHBlZCkKKwkJY2FtLT5tbWFwcGVkID0gMDsKKwl2NGwyX3ByaW9fY2xvc2UoJmNhbS0+cHJpbywgZmgtPnByaW8pOworCWZpbGUtPnByaXZhdGVfZGF0YSA9IE5VTEw7CisJa2ZyZWUoZmgpOwogCiAJaWYgKC0tY2FtLT5vcGVuX2NvdW50ID09IDApIHsKIAkJY3BpYTJfZnJlZV9idWZmZXJzKGNhbSk7CiAJCWlmICghY2FtLT5wcmVzZW50KSB7CiAJCQl2aWRlb191bnJlZ2lzdGVyX2RldmljZShkZXYpOwotCQkJbXV0ZXhfdW5sb2NrKCZjYW0tPmJ1c3lfbG9jayk7CiAJCQlrZnJlZShjYW0pOwogCQkJcmV0dXJuIDA7CiAJCX0KIAl9CiAKLQltdXRleF91bmxvY2soJmNhbS0+YnVzeV9sb2NrKTsKLQogCXJldHVybiAwOwogfQogCkBAIC00MDUsMTEgKzM3NywxMSBAQAogCQkJcmV0dXJuIDA7CiAJCX0KIAotCQltdXRleF91bmxvY2soJmNhbS0+YnVzeV9sb2NrKTsKKwkJbXV0ZXhfdW5sb2NrKCZjYW0tPnY0bDJfbG9jayk7CiAJCXdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZShjYW0tPndxX3N0cmVhbSwKIAkJCQkJICFjYW0tPnN0cmVhbWluZyB8fAogCQkJCQkgZnJhbWUtPnN0YXR1cyA9PSBGUkFNRV9SRUFEWSk7Ci0JCW11dGV4X2xvY2soJmNhbS0+YnVzeV9sb2NrKTsKKwkJbXV0ZXhfbG9jaygmY2FtLT52NGwyX2xvY2spOwogCQlpZiAoc2lnbmFsX3BlbmRpbmcoY3VycmVudCkpCiAJCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwogCQlpZighY2FtLT5wcmVzZW50KQpAQCAtMTI5MywxMSArMTI2NSwxMSBAQAogCWlmKGZyYW1lIDwgMCkgewogCQkvKiBXYWl0IGZvciBhIGZyYW1lIHRvIGJlY29tZSBhdmFpbGFibGUgKi8KIAkJc3RydWN0IGZyYW1lYnVmICpjYj1jYW0tPmN1cmJ1ZmY7Ci0JCW11dGV4X3VubG9jaygmY2FtLT5idXN5X2xvY2spOworCQltdXRleF91bmxvY2soJmNhbS0+djRsMl9sb2NrKTsKIAkJd2FpdF9ldmVudF9pbnRlcnJ1cHRpYmxlKGNhbS0+d3Ffc3RyZWFtLAogCQkJCQkgIWNhbS0+cHJlc2VudCB8fAogCQkJCQkgKGNiPWNhbS0+Y3VyYnVmZiktPnN0YXR1cyA9PSBGUkFNRV9SRUFEWSk7Ci0JCW11dGV4X2xvY2soJmNhbS0+YnVzeV9sb2NrKTsKKwkJbXV0ZXhfbG9jaygmY2FtLT52NGwyX2xvY2spOwogCQlpZiAoc2lnbmFsX3BlbmRpbmcoY3VycmVudCkpCiAJCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwogCQlpZighY2FtLT5wcmVzZW50KQpAQCAtMTMzNywxNCArMTMwOSw4IEBACiAJaWYgKCFjYW0pCiAJCXJldHVybiAtRU5PVFRZOwogCi0JLyogbWFrZSB0aGlzIF9yZWFsbHlfIHNtcC1zYWZlICovCi0JaWYgKG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmY2FtLT5idXN5X2xvY2spKQotCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwotCi0JaWYgKCFjYW0tPnByZXNlbnQpIHsKLQkJbXV0ZXhfdW5sb2NrKCZjYW0tPmJ1c3lfbG9jayk7CisJaWYgKCFjYW0tPnByZXNlbnQpCiAJCXJldHVybiAtRU5PREVWOwotCX0KIAogCS8qIFByaW9yaXR5IGNoZWNrICovCiAJc3dpdGNoIChjbWQpIHsKQEAgLTEzNTIsMTAgKzEzMTgsOCBAQAogCXsKIAkJc3RydWN0IGNwaWEyX2ZoICpmaCA9IGZpbGUtPnByaXZhdGVfZGF0YTsKIAkJcmV0dmFsID0gdjRsMl9wcmlvX2NoZWNrKCZjYW0tPnByaW8sIGZoLT5wcmlvKTsKLQkJaWYocmV0dmFsKSB7Ci0JCQltdXRleF91bmxvY2soJmNhbS0+YnVzeV9sb2NrKTsKKwkJaWYgKHJldHZhbCkKIAkJCXJldHVybiByZXR2YWw7Ci0JCX0KIAkJYnJlYWs7CiAJfQogCWRlZmF1bHQ6CkBAIC0xNTI5LDcgKzE0OTMsNiBAQAogCQlicmVhazsKIAl9CiAKLQltdXRleF91bmxvY2soJmNhbS0+YnVzeV9sb2NrKTsKIAlyZXR1cm4gcmV0dmFsOwogfQogCkBAIC0xNTk2LDcgKzE1NTksNyBAQAogCS5yZWxlYXNlCT0gY3BpYTJfY2xvc2UsCiAJLnJlYWQJCT0gY3BpYTJfdjRsX3JlYWQsCiAJLnBvbGwJCT0gY3BpYTJfdjRsX3BvbGwsCi0JLmlvY3RsCQk9IGNwaWEyX2lvY3RsLAorCS51bmxvY2tlZF9pb2N0bAk9IGNwaWEyX2lvY3RsLAogCS5tbWFwCQk9IGNwaWEyX21tYXAsCiB9OwogCkBAIC0xNjIwLDYgKzE1ODMsNyBAQAogCiAJbWVtY3B5KGNhbS0+dmRldiwgJmNwaWEyX3RlbXBsYXRlLCBzaXplb2YoY3BpYTJfdGVtcGxhdGUpKTsKIAl2aWRlb19zZXRfZHJ2ZGF0YShjYW0tPnZkZXYsIGNhbSk7CisJY2FtLT52ZGV2LT5sb2NrID0gJmNhbS0+djRsMl9sb2NrOwogCiAJcmVzZXRfY2FtZXJhX3N0cnVjdF92NGwoY2FtKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9jeDE4L2N4MTgtZHJpdmVyLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MTgvY3gxOC1kcml2ZXIuYwppbmRleCAxMzNlYzJiLi45NDRhZjhhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MTgvY3gxOC1kcml2ZXIuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MTgvY3gxOC1kcml2ZXIuYwpAQCAtNjY0LDcgKzY2NCw3IEBACiB7CiAJc25wcmludGYoY3gtPmluX3dvcmtxX25hbWUsIHNpemVvZihjeC0+aW5fd29ya3FfbmFtZSksICIlcy1pbiIsCiAJCSBjeC0+djRsMl9kZXYubmFtZSk7Ci0JY3gtPmluX3dvcmtfcXVldWUgPSBjcmVhdGVfc2luZ2xldGhyZWFkX3dvcmtxdWV1ZShjeC0+aW5fd29ya3FfbmFtZSk7CisJY3gtPmluX3dvcmtfcXVldWUgPSBhbGxvY19vcmRlcmVkX3dvcmtxdWV1ZShjeC0+aW5fd29ya3FfbmFtZSwgMCk7CiAJaWYgKGN4LT5pbl93b3JrX3F1ZXVlID09IE5VTEwpIHsKIAkJQ1gxOF9FUlIoIlVuYWJsZSB0byBjcmVhdGUgaW5jb21pbmcgbWFpbGJveCBoYW5kbGVyIHRocmVhZFxuIik7CiAJCXJldHVybiAtRU5PTUVNOwpAQCAtNjcyLDE4ICs2NzIsNiBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IF9fZGV2aW5pdCBjeDE4X2NyZWF0ZV9vdXRfd29ya3Eoc3RydWN0IGN4MTggKmN4KQotewotCXNucHJpbnRmKGN4LT5vdXRfd29ya3FfbmFtZSwgc2l6ZW9mKGN4LT5vdXRfd29ya3FfbmFtZSksICIlcy1vdXQiLAotCQkgY3gtPnY0bDJfZGV2Lm5hbWUpOwotCWN4LT5vdXRfd29ya19xdWV1ZSA9IGNyZWF0ZV93b3JrcXVldWUoY3gtPm91dF93b3JrcV9uYW1lKTsKLQlpZiAoY3gtPm91dF93b3JrX3F1ZXVlID09IE5VTEwpIHsKLQkJQ1gxOF9FUlIoIlVuYWJsZSB0byBjcmVhdGUgb3V0Z29pbmcgbWFpbGJveCBoYW5kbGVyIHRocmVhZHNcbiIpOwotCQlyZXR1cm4gLUVOT01FTTsKLQl9Ci0JcmV0dXJuIDA7Ci19Ci0KIHN0YXRpYyB2b2lkIF9fZGV2aW5pdCBjeDE4X2luaXRfaW5fd29ya19vcmRlcnMoc3RydWN0IGN4MTggKmN4KQogewogCWludCBpOwpAQCAtNzEwLDE2ICs2OTgsMTAgQEAKIAltdXRleF9pbml0KCZjeC0+ZXB1MmFwdV9tYl9sb2NrKTsKIAltdXRleF9pbml0KCZjeC0+ZXB1MmNwdV9tYl9sb2NrKTsKIAotCXJldCA9IGN4MThfY3JlYXRlX291dF93b3JrcShjeCk7CisJcmV0ID0gY3gxOF9jcmVhdGVfaW5fd29ya3EoY3gpOwogCWlmIChyZXQpCiAJCXJldHVybiByZXQ7CiAKLQlyZXQgPSBjeDE4X2NyZWF0ZV9pbl93b3JrcShjeCk7Ci0JaWYgKHJldCkgewotCQlkZXN0cm95X3dvcmtxdWV1ZShjeC0+b3V0X3dvcmtfcXVldWUpOwotCQlyZXR1cm4gcmV0OwotCX0KLQogCWN4MThfaW5pdF9pbl93b3JrX29yZGVycyhjeCk7CiAKIAkvKiBzdGFydCBjb3VudGluZyBvcGVuX2lkIGF0IDEgKi8KQEAgLTExMDcsNyArMTA4OSw2IEBACiAJcmVsZWFzZV9tZW1fcmVnaW9uKGN4LT5iYXNlX2FkZHIsIENYMThfTUVNX1NJWkUpOwogZnJlZV93b3JrcXVldWVzOgogCWRlc3Ryb3lfd29ya3F1ZXVlKGN4LT5pbl93b3JrX3F1ZXVlKTsKLQlkZXN0cm95X3dvcmtxdWV1ZShjeC0+b3V0X3dvcmtfcXVldWUpOwogZXJyOgogCWlmIChyZXR2YWwgPT0gMCkKIAkJcmV0dmFsID0gLUVOT0RFVjsKQEAgLTEyNTksNyArMTI0MCw2IEBACiAJY3gxOF9oYWx0X2Zpcm13YXJlKGN4KTsKIAogCWRlc3Ryb3lfd29ya3F1ZXVlKGN4LT5pbl93b3JrX3F1ZXVlKTsKLQlkZXN0cm95X3dvcmtxdWV1ZShjeC0+b3V0X3dvcmtfcXVldWUpOwogCiAJY3gxOF9zdHJlYW1zX2NsZWFudXAoY3gsIDEpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MTgvY3gxOC1kcml2ZXIuaCBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gxOC9jeDE4LWRyaXZlci5oCmluZGV4IGY2ZjNlNTAuLjMwNmNhYWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gxOC9jeDE4LWRyaXZlci5oCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gxOC9jeDE4LWRyaXZlci5oCkBAIC02MTcsOSArNjE3LDYgQEAKIAlzdHJ1Y3QgY3gxOF9pbl93b3JrX29yZGVyIGluX3dvcmtfb3JkZXJbQ1gxOF9NQVhfSU5fV09SS19PUkRFUlNdOwogCWNoYXIgZXB1X2RlYnVnX3N0clsyNTZdOyAvKiBDWDE4X0VQVV9ERUJVRyBpcyByYXJlOiB1c2Ugc2hhcmVkIHNwYWNlICovCiAKLQlzdHJ1Y3Qgd29ya3F1ZXVlX3N0cnVjdCAqb3V0X3dvcmtfcXVldWU7Ci0JY2hhciBvdXRfd29ya3FfbmFtZVsxMl07IC8qICJjeDE4LU5OLW91dCIgKi8KLQogCS8qIGkyYyAqLwogCXN0cnVjdCBpMmNfYWRhcHRlciBpMmNfYWRhcFsyXTsKIAlzdHJ1Y3QgaTJjX2FsZ29fYml0X2RhdGEgaTJjX2FsZ29bMl07CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MTgvY3gxOC1zdHJlYW1zLmggYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MTgvY3gxOC1zdHJlYW1zLmgKaW5kZXggNTE3NjVlYi4uNzEzYjBlNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9jeDE4L2N4MTgtc3RyZWFtcy5oCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gxOC9jeDE4LXN0cmVhbXMuaApAQCAtNDIsOCArNDIsNyBAQAogLyogUmVsYXRlZCB0byBzdWJtaXNzaW9uIG9mIG1kbHMgdG8gZmlybXdhcmUgKi8KIHN0YXRpYyBpbmxpbmUgdm9pZCBjeDE4X3N0cmVhbV9sb2FkX2Z3X3F1ZXVlKHN0cnVjdCBjeDE4X3N0cmVhbSAqcykKIHsKLQlzdHJ1Y3QgY3gxOCAqY3ggPSBzLT5jeDsKLQlxdWV1ZV93b3JrKGN4LT5vdXRfd29ya19xdWV1ZSwgJnMtPm91dF93b3JrX29yZGVyKTsKKwlzY2hlZHVsZV93b3JrKCZzLT5vdXRfd29ya19vcmRlcik7CiB9CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBjeDE4X3N0cmVhbV9wdXRfbWRsX2Z3KHN0cnVjdCBjeDE4X3N0cmVhbSAqcywKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gyMzF4eC9jeDIzMXh4LWR2Yi5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9jeDIzMXh4L2N4MjMxeHgtZHZiLmMKaW5kZXggZmU1OWExYy4uMzYzYWE2MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9jeDIzMXh4L2N4MjMxeHgtZHZiLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9jeDIzMXh4L2N4MjMxeHgtZHZiLmMKQEAgLTI4LDcgKzI4LDYgQEAKICNpbmNsdWRlIDxtZWRpYS92aWRlb2J1Zi12bWFsbG9jLmg+CiAKICNpbmNsdWRlICJ4YzUwMDAuaCIKLSNpbmNsdWRlICJkdmJfZHVtbXlfZmUuaCIKICNpbmNsdWRlICJzNWgxNDMyLmgiCiAjaW5jbHVkZSAidGRhMTgyNzEuaCIKICNpbmNsdWRlICJzNWgxNDExLmgiCkBAIC02MTksNyArNjE4LDcgQEAKIAogCQlpZiAoZGV2LT5kdmItPmZyb250ZW5kID09IE5VTEwpIHsKIAkJCXByaW50ayhEUklWRVJfTkFNRQotCQkJICAgICAgICI6IEZhaWxlZCB0byBhdHRhY2ggZHVtbXkgZnJvbnQgZW5kXG4iKTsKKwkJCSAgICAgICAiOiBGYWlsZWQgdG8gYXR0YWNoIHM1aDE0MTEgZnJvbnQgZW5kXG4iKTsKIAkJCXJlc3VsdCA9IC1FSU5WQUw7CiAJCQlnb3RvIG91dF9mcmVlOwogCQl9CkBAIC02NjUsNyArNjY0LDcgQEAKIAogCQlpZiAoZGV2LT5kdmItPmZyb250ZW5kID09IE5VTEwpIHsKIAkJCXByaW50ayhEUklWRVJfTkFNRQotCQkJICAgICAgICI6IEZhaWxlZCB0byBhdHRhY2ggZHVtbXkgZnJvbnQgZW5kXG4iKTsKKwkJCSAgICAgICAiOiBGYWlsZWQgdG8gYXR0YWNoIHM1aDE0MTEgZnJvbnQgZW5kXG4iKTsKIAkJCXJlc3VsdCA9IC1FSU5WQUw7CiAJCQlnb3RvIG91dF9mcmVlOwogCQl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MjU4NDAvY3gyNTg0MC1jb3JlLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2N4MjU4NDAvY3gyNTg0MC1jb3JlLmMKaW5kZXggZjE2NDYxOC4uNmZjMDlkZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9jeDI1ODQwL2N4MjU4NDAtY29yZS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vY3gyNTg0MC9jeDI1ODQwLWNvcmUuYwpAQCAtMTY4MiwyMCArMTY4Miw2IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgY3gyNTg0MF9zX2NvbmZpZyhzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkLCBpbnQgaXJxLCB2b2lkICpwbGF0Zm9ybV9kYXRhKQotewotCXN0cnVjdCBjeDI1ODQwX3N0YXRlICpzdGF0ZSA9IHRvX3N0YXRlKHNkKTsKLQlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50ID0gdjRsMl9nZXRfc3ViZGV2ZGF0YShzZCk7Ci0KLQlpZiAocGxhdGZvcm1fZGF0YSkgewotCQlzdHJ1Y3QgY3gyNTg0MF9wbGF0Zm9ybV9kYXRhICpwZGF0YSA9IHBsYXRmb3JtX2RhdGE7Ci0KLQkJc3RhdGUtPnB2cjE1MF93b3JrYXJvdW5kID0gcGRhdGEtPnB2cjE1MF93b3JrYXJvdW5kOwotCQlzZXRfaW5wdXQoY2xpZW50LCBzdGF0ZS0+dmlkX2lucHV0LCBzdGF0ZS0+YXVkX2lucHV0KTsKLQl9Ci0JcmV0dXJuIDA7Ci19Ci0KIHN0YXRpYyBpbnQgY3gyMzg4NV9pcnFfaGFuZGxlcihzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkLCB1MzIgc3RhdHVzLAogCQkJICAgICAgIGJvb2wgKmhhbmRsZWQpCiB7CkBAIC0xNzg3LDcgKzE3NzMsNiBAQAogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHY0bDJfc3ViZGV2X2NvcmVfb3BzIGN4MjU4NDBfY29yZV9vcHMgPSB7CiAJLmxvZ19zdGF0dXMgPSBjeDI1ODQwX2xvZ19zdGF0dXMsCi0JLnNfY29uZmlnID0gY3gyNTg0MF9zX2NvbmZpZywKIAkuZ19jaGlwX2lkZW50ID0gY3gyNTg0MF9nX2NoaXBfaWRlbnQsCiAJLmdfY3RybCA9IHY0bDJfc3ViZGV2X2dfY3RybCwKIAkuc19jdHJsID0gdjRsMl9zdWJkZXZfc19jdHJsLApAQCAtMTk3NCw3ICsxOTU5LDYgQEAKIAlzdGF0ZS0+dmlkX2lucHV0ID0gQ1gyNTg0MF9DT01QT1NJVEU3OwogCXN0YXRlLT5hdWRfaW5wdXQgPSBDWDI1ODQwX0FVRElPODsKIAlzdGF0ZS0+YXVkY2xrX2ZyZXEgPSA0ODAwMDsKLQlzdGF0ZS0+cHZyMTUwX3dvcmthcm91bmQgPSAwOwogCXN0YXRlLT5hdWRtb2RlID0gVjRMMl9UVU5FUl9NT0RFX0xBTkcxOwogCXN0YXRlLT52YmlfbGluZV9vZmZzZXQgPSA4OwogCXN0YXRlLT5pZCA9IGlkOwpAQCAtMjAzNCw2ICsyMDE4LDEyIEBACiAJdjRsMl9jdHJsX2NsdXN0ZXIoMiwgJnN0YXRlLT52b2x1bWUpOwogCXY0bDJfY3RybF9oYW5kbGVyX3NldHVwKCZzdGF0ZS0+aGRsKTsKIAorCWlmIChjbGllbnQtPmRldi5wbGF0Zm9ybV9kYXRhKSB7CisJCXN0cnVjdCBjeDI1ODQwX3BsYXRmb3JtX2RhdGEgKnBkYXRhID0gY2xpZW50LT5kZXYucGxhdGZvcm1fZGF0YTsKKworCQlzdGF0ZS0+cHZyMTUwX3dvcmthcm91bmQgPSBwZGF0YS0+cHZyMTUwX3dvcmthcm91bmQ7CisJfQorCiAJY3gyNTg0MF9pcl9wcm9iZShzZCk7CiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2RhdmluY2kvdnBpZi5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9kYXZpbmNpL3ZwaWYuYwppbmRleCAxZjUzMmUzLi45ZjNiZmMxIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2RhdmluY2kvdnBpZi5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZGF2aW5jaS92cGlmLmMKQEAgLTQxLDYgKzQxLDE4MyBAQAogCiB2b2lkIF9faW9tZW0gKnZwaWZfYmFzZTsKIAorLyoqCisgKiBjaF9wYXJhbXM6IHZpZGVvIHN0YW5kYXJkIGNvbmZpZ3VyYXRpb24gcGFyYW1ldGVycyBmb3IgdnBpZgorICogVGhlIHRhYmxlIG11c3QgaW5jbHVkZSBhbGwgcHJlc2V0cyBmcm9tIHN1cHBvcnRlZCBzdWJkZXZpY2VzLgorICovCitjb25zdCBzdHJ1Y3QgdnBpZl9jaGFubmVsX2NvbmZpZ19wYXJhbXMgY2hfcGFyYW1zW10gPSB7CisJLyogSERUViBmb3JtYXRzICovCisJeworCQkubmFtZSA9ICI0ODBwNTlfOTQiLAorCQkud2lkdGggPSA3MjAsCisJCS5oZWlnaHQgPSA0ODAsCisJCS5mcm1fZm10ID0gMSwKKwkJLnljbXV4X21vZGUgPSAwLAorCQkuZWF2MnNhdiA9IDEzOC04LAorCQkuc2F2MmVhdiA9IDcyMCwKKwkJLmwxID0gMSwKKwkJLmwzID0gNDMsCisJCS5sNSA9IDUyMywKKwkJLnZzaXplID0gNTI1LAorCQkuY2FwdHVyZV9mb3JtYXQgPSAwLAorCQkudmJpX3N1cHBvcnRlZCA9IDAsCisJCS5oZF9zZCA9IDEsCisJCS5kdl9wcmVzZXQgPSBWNEwyX0RWXzQ4MFA1OV85NCwKKwl9LAorCXsKKwkJLm5hbWUgPSAiNTc2cDUwIiwKKwkJLndpZHRoID0gNzIwLAorCQkuaGVpZ2h0ID0gNTc2LAorCQkuZnJtX2ZtdCA9IDEsCisJCS55Y211eF9tb2RlID0gMCwKKwkJLmVhdjJzYXYgPSAxNDQtOCwKKwkJLnNhdjJlYXYgPSA3MjAsCisJCS5sMSA9IDEsCisJCS5sMyA9IDQ1LAorCQkubDUgPSA2MjEsCisJCS52c2l6ZSA9IDYyNSwKKwkJLmNhcHR1cmVfZm9ybWF0ID0gMCwKKwkJLnZiaV9zdXBwb3J0ZWQgPSAwLAorCQkuaGRfc2QgPSAxLAorCQkuZHZfcHJlc2V0ID0gVjRMMl9EVl81NzZQNTAsCisJfSwKKwl7CisJCS5uYW1lID0gIjcyMHA1MCIsCisJCS53aWR0aCA9IDEyODAsCisJCS5oZWlnaHQgPSA3MjAsCisJCS5mcm1fZm10ID0gMSwKKwkJLnljbXV4X21vZGUgPSAwLAorCQkuZWF2MnNhdiA9IDcwMC04LAorCQkuc2F2MmVhdiA9IDEyODAsCisJCS5sMSA9IDEsCisJCS5sMyA9IDI2LAorCQkubDUgPSA3NDYsCisJCS52c2l6ZSA9IDc1MCwKKwkJLmNhcHR1cmVfZm9ybWF0ID0gMCwKKwkJLnZiaV9zdXBwb3J0ZWQgPSAwLAorCQkuaGRfc2QgPSAxLAorCQkuZHZfcHJlc2V0ID0gVjRMMl9EVl83MjBQNTAsCisJfSwKKwl7CisJCS5uYW1lID0gIjcyMHA2MCIsCisJCS53aWR0aCA9IDEyODAsCisJCS5oZWlnaHQgPSA3MjAsCisJCS5mcm1fZm10ID0gMSwKKwkJLnljbXV4X21vZGUgPSAwLAorCQkuZWF2MnNhdiA9IDM3MCAtIDgsCisJCS5zYXYyZWF2ID0gMTI4MCwKKwkJLmwxID0gMSwKKwkJLmwzID0gMjYsCisJCS5sNSA9IDc0NiwKKwkJLnZzaXplID0gNzUwLAorCQkuY2FwdHVyZV9mb3JtYXQgPSAwLAorCQkudmJpX3N1cHBvcnRlZCA9IDAsCisJCS5oZF9zZCA9IDEsCisJCS5kdl9wcmVzZXQgPSBWNEwyX0RWXzcyMFA2MCwKKwl9LAorCXsKKwkJLm5hbWUgPSAiMTA4MEk1MCIsCisJCS53aWR0aCA9IDE5MjAsCisJCS5oZWlnaHQgPSAxMDgwLAorCQkuZnJtX2ZtdCA9IDAsCisJCS55Y211eF9tb2RlID0gMCwKKwkJLmVhdjJzYXYgPSA3MjAgLSA4LAorCQkuc2F2MmVhdiA9IDE5MjAsCisJCS5sMSA9IDEsCisJCS5sMyA9IDIxLAorCQkubDUgPSA1NjEsCisJCS5sNyA9IDU2MywKKwkJLmw5ID0gNTg0LAorCQkubDExID0gMTEyNCwKKwkJLnZzaXplID0gMTEyNSwKKwkJLmNhcHR1cmVfZm9ybWF0ID0gMCwKKwkJLnZiaV9zdXBwb3J0ZWQgPSAwLAorCQkuaGRfc2QgPSAxLAorCQkuZHZfcHJlc2V0ID0gVjRMMl9EVl8xMDgwSTUwLAorCX0sCisJeworCQkubmFtZSA9ICIxMDgwSTYwIiwKKwkJLndpZHRoID0gMTkyMCwKKwkJLmhlaWdodCA9IDEwODAsCisJCS5mcm1fZm10ID0gMCwKKwkJLnljbXV4X21vZGUgPSAwLAorCQkuZWF2MnNhdiA9IDI4MCAtIDgsCisJCS5zYXYyZWF2ID0gMTkyMCwKKwkJLmwxID0gMSwKKwkJLmwzID0gMjEsCisJCS5sNSA9IDU2MSwKKwkJLmw3ID0gNTYzLAorCQkubDkgPSA1ODQsCisJCS5sMTEgPSAxMTI0LAorCQkudnNpemUgPSAxMTI1LAorCQkuY2FwdHVyZV9mb3JtYXQgPSAwLAorCQkudmJpX3N1cHBvcnRlZCA9IDAsCisJCS5oZF9zZCA9IDEsCisJCS5kdl9wcmVzZXQgPSBWNEwyX0RWXzEwODBJNjAsCisJfSwKKwl7CisJCS5uYW1lID0gIjEwODBwNjAiLAorCQkud2lkdGggPSAxOTIwLAorCQkuaGVpZ2h0ID0gMTA4MCwKKwkJLmZybV9mbXQgPSAxLAorCQkueWNtdXhfbW9kZSA9IDAsCisJCS5lYXYyc2F2ID0gMjgwIC0gOCwKKwkJLnNhdjJlYXYgPSAxOTIwLAorCQkubDEgPSAxLAorCQkubDMgPSA0MiwKKwkJLmw1ID0gMTEyMiwKKwkJLnZzaXplID0gMTEyNSwKKwkJLmNhcHR1cmVfZm9ybWF0ID0gMCwKKwkJLnZiaV9zdXBwb3J0ZWQgPSAwLAorCQkuaGRfc2QgPSAxLAorCQkuZHZfcHJlc2V0ID0gVjRMMl9EVl8xMDgwUDYwLAorCX0sCisKKwkvKiBTRFRWIGZvcm1hdHMgKi8KKwl7CisJCS5uYW1lID0gIk5UU0NfTSIsCisJCS53aWR0aCA9IDcyMCwKKwkJLmhlaWdodCA9IDQ4MCwKKwkJLmZybV9mbXQgPSAwLAorCQkueWNtdXhfbW9kZSA9IDEsCisJCS5lYXYyc2F2ID0gMjY4LAorCQkuc2F2MmVhdiA9IDE0NDAsCisJCS5sMSA9IDEsCisJCS5sMyA9IDIzLAorCQkubDUgPSAyNjMsCisJCS5sNyA9IDI2NiwKKwkJLmw5ID0gMjg2LAorCQkubDExID0gNTI1LAorCQkudnNpemUgPSA1MjUsCisJCS5jYXB0dXJlX2Zvcm1hdCA9IDAsCisJCS52Ymlfc3VwcG9ydGVkID0gMSwKKwkJLmhkX3NkID0gMCwKKwkJLnN0ZGlkID0gVjRMMl9TVERfNTI1XzYwLAorCX0sCisJeworCQkubmFtZSA9ICJQQUxfQkRHSElLIiwKKwkJLndpZHRoID0gNzIwLAorCQkuaGVpZ2h0ID0gNTc2LAorCQkuZnJtX2ZtdCA9IDAsCisJCS55Y211eF9tb2RlID0gMSwKKwkJLmVhdjJzYXYgPSAyODAsCisJCS5zYXYyZWF2ID0gMTQ0MCwKKwkJLmwxID0gMSwKKwkJLmwzID0gMjMsCisJCS5sNSA9IDMxMSwKKwkJLmw3ID0gMzEzLAorCQkubDkgPSAzMzYsCisJCS5sMTEgPSA2MjQsCisJCS52c2l6ZSA9IDYyNSwKKwkJLmNhcHR1cmVfZm9ybWF0ID0gMCwKKwkJLnZiaV9zdXBwb3J0ZWQgPSAxLAorCQkuaGRfc2QgPSAwLAorCQkuc3RkaWQgPSBWNEwyX1NURF82MjVfNTAsCisJfSwKK307CisKK2NvbnN0IHVuc2lnbmVkIGludCB2cGlmX2NoX3BhcmFtc19jb3VudCA9IEFSUkFZX1NJWkUoY2hfcGFyYW1zKTsKKwogc3RhdGljIGlubGluZSB2b2lkIHZwaWZfd3JfYml0KHUzMiByZWcsIHUzMiBiaXQsIHUzMiB2YWwpCiB7CiAJaWYgKHZhbCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZGF2aW5jaS92cGlmLmggYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2RhdmluY2kvdnBpZi5oCmluZGV4IGViZDVjNDMuLjEwNTUwYmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZGF2aW5jaS92cGlmLmgKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9kYXZpbmNpL3ZwaWYuaApAQCAtNTc3LDEyICs1NzcsMTAgQEAKIAljaGFyIG5hbWVbVlBJRl9NQVhfTkFNRV07CS8qIE5hbWUgb2YgdGhlIG1vZGUgKi8KIAl1MTYgd2lkdGg7CQkJLyogSW5kaWNhdGVzIHdpZHRoIG9mIHRoZSBpbWFnZSAqLwogCXUxNiBoZWlnaHQ7CQkJLyogSW5kaWNhdGVzIGhlaWdodCBvZiB0aGUgaW1hZ2UgKi8KLQl1OCBmcHM7Ci0JdTggZnJtX2ZtdDsJCQkvKiBJbmRpY2F0ZXMgd2hldGhlciB0aGlzIGlzIGludGVybGFjZWQKLQkJCQkJICogb3IgcHJvZ3Jlc3NpdmUgZm9ybWF0ICovCi0JdTggeWNtdXhfbW9kZTsJCQkvKiBJbmRpY2F0ZXMgd2hldGhlciB0aGlzIG1vZGUgcmVxdWlyZXMKLQkJCQkJICogc2luZ2xlIG9yIHR3byBjaGFubmVscyAqLwotCXUxNiBlYXYyc2F2OwkJCS8qIGxlbmd0aCBvZiBzYXYgMiBlYXYgKi8KKwl1OCBmcm1fZm10OwkJCS8qIEludGVybGFjZWQgKDApIG9yIHByb2dyZXNzaXZlICgxKSAqLworCXU4IHljbXV4X21vZGU7CQkJLyogVGhpcyBtb2RlIHJlcXVpcmVzIG9uZSAoMCkgb3IgdHdvICgxKQorCQkJCQkgICBjaGFubmVscyAqLworCXUxNiBlYXYyc2F2OwkJCS8qIGxlbmd0aCBvZiBlYXYgMiBzYXYgKi8KIAl1MTYgc2F2MmVhdjsJCQkvKiBsZW5ndGggb2Ygc2F2IDIgZWF2ICovCiAJdTE2IGwxLCBsMywgbDUsIGw3LCBsOSwgbDExOwkvKiBPdGhlciBwYXJhbWV0ZXIgY29uZmlndXJhdGlvbnMgKi8KIAl1MTYgdnNpemU7CQkJLyogVmVydGljYWwgc2l6ZSBvZiB0aGUgaW1hZ2UgKi8KQEAgLTU5MCwxMCArNTg4LDE0IEBACiAJCQkJCSAqIGlzIGluIEJUIG9yIGluIENDRC9DTU9TICovCiAJdTggIHZiaV9zdXBwb3J0ZWQ7CQkvKiBJbmRpY2F0ZXMgd2hldGhlciB0aGlzIG1vZGUKIAkJCQkJICogc3VwcG9ydHMgY2FwdHVyaW5nIHZiaSBvciBub3QgKi8KLQl1OCBoZF9zZDsKLQl2NGwyX3N0ZF9pZCBzdGRpZDsKKwl1OCBoZF9zZDsJCQkvKiBIRFRWICgxKSBvciBTRFRWICgwKSBmb3JtYXQgKi8KKwl2NGwyX3N0ZF9pZCBzdGRpZDsJCS8qIFNEVFYgZm9ybWF0ICovCisJdTMyIGR2X3ByZXNldDsJCQkvKiBIRFRWIGZvcm1hdCAqLwogfTsKIAorZXh0ZXJuIGNvbnN0IHVuc2lnbmVkIGludCB2cGlmX2NoX3BhcmFtc19jb3VudDsKK2V4dGVybiBjb25zdCBzdHJ1Y3QgdnBpZl9jaGFubmVsX2NvbmZpZ19wYXJhbXMgY2hfcGFyYW1zW107CisKIHN0cnVjdCB2cGlmX3ZpZGVvX3BhcmFtczsKIHN0cnVjdCB2cGlmX3BhcmFtczsKIHN0cnVjdCB2cGlmX3ZiaV9wYXJhbXM7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2RhdmluY2kvdnBpZl9jYXB0dXJlLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2RhdmluY2kvdnBpZl9jYXB0dXJlLmMKaW5kZXggMTkzYWJhYi4uZDkzYWQ3NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9kYXZpbmNpL3ZwaWZfY2FwdHVyZS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZGF2aW5jaS92cGlmX2NhcHR1cmUuYwpAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxtZWRpYS92NGwyLWRldmljZS5oPgogI2luY2x1ZGUgPG1lZGlhL3Y0bDItaW9jdGwuaD4KKyNpbmNsdWRlIDxtZWRpYS92NGwyLWNoaXAtaWRlbnQuaD4KIAogI2luY2x1ZGUgInZwaWZfY2FwdHVyZS5oIgogI2luY2x1ZGUgInZwaWYuaCIKQEAgLTgxLDIwICs4Miw2IEBACiBzdGF0aWMgc3RydWN0IGRldmljZSAqdnBpZl9kZXY7CiAKIC8qKgotICogY2hfcGFyYW1zOiB2aWRlbyBzdGFuZGFyZCBjb25maWd1cmF0aW9uIHBhcmFtZXRlcnMgZm9yIHZwaWYKLSAqLwotc3RhdGljIGNvbnN0IHN0cnVjdCB2cGlmX2NoYW5uZWxfY29uZmlnX3BhcmFtcyBjaF9wYXJhbXNbXSA9IHsKLQl7Ci0JCSJOVFNDX00iLCA3MjAsIDQ4MCwgMzAsIDAsIDEsIDI2OCwgMTQ0MCwgMSwgMjMsIDI2MywgMjY2LAotCQkyODYsIDUyNSwgNTI1LCAwLCAxLCAwLCBWNEwyX1NURF81MjVfNjAsCi0JfSwKLQl7Ci0JCSJQQUxfQkRHSElLIiwgNzIwLCA1NzYsIDI1LCAwLCAxLCAyODAsIDE0NDAsIDEsIDIzLCAzMTEsIDMxMywKLQkJMzM2LCA2MjQsIDYyNSwgMCwgMSwgMCwgVjRMMl9TVERfNjI1XzUwLAotCX0sCi19OwotCi0vKioKICAqIHZwaWZfdXNlcnZpcnRfdG9fcGh5cyA6IHRyYW5zbGF0ZSB1c2VyL3ZpcnR1YWwgYWRkcmVzcyB0byBwaHkgYWRkcmVzcwogICogQHZpcnRwOiB1c2VyL3ZpcnR1YWwgYWRkcmVzcwogICoKQEAgLTM0Miw3ICszMjksNyBAQAogICogQGRldl9pZDogZGV2X2lkIHB0cgogICoKICAqIEl0IGNoYW5nZXMgc3RhdHVzIG9mIHRoZSBjYXB0dXJlZCBidWZmZXIsIHRha2VzIG5leHQgYnVmZmVyIGZyb20gdGhlIHF1ZXVlCi0gKiBhbmQgc2V0cyBpdHMgYWRkcmVzcyBpbiBWUElGICByZWdpc3RlcnMKKyAqIGFuZCBzZXRzIGl0cyBhZGRyZXNzIGluIFZQSUYgcmVnaXN0ZXJzCiAgKi8KIHN0YXRpYyBpcnFyZXR1cm5fdCB2cGlmX2NoYW5uZWxfaXNyKGludCBpcnEsIHZvaWQgKmRldl9pZCkKIHsKQEAgLTQzNSwyNCArNDIyLDMxIEBACiAJc3RydWN0IGNvbW1vbl9vYmogKmNvbW1vbiA9ICZjaC0+Y29tbW9uW1ZQSUZfVklERU9fSU5ERVhdOwogCXN0cnVjdCB2cGlmX3BhcmFtcyAqdnBpZnBhcmFtcyA9ICZjaC0+dnBpZnBhcmFtczsKIAljb25zdCBzdHJ1Y3QgdnBpZl9jaGFubmVsX2NvbmZpZ19wYXJhbXMgKmNvbmZpZzsKLQlzdHJ1Y3QgdnBpZl9jaGFubmVsX2NvbmZpZ19wYXJhbXMgKnN0ZF9pbmZvOworCXN0cnVjdCB2cGlmX2NoYW5uZWxfY29uZmlnX3BhcmFtcyAqc3RkX2luZm8gPSAmdnBpZnBhcmFtcy0+c3RkX2luZm87CiAJc3RydWN0IHZpZGVvX29iaiAqdmlkX2NoID0gJmNoLT52aWRlbzsKIAlpbnQgaW5kZXg7CiAKIAl2cGlmX2RiZygyLCBkZWJ1ZywgInZwaWZfdXBkYXRlX3N0ZF9pbmZvXG4iKTsKIAotCXN0ZF9pbmZvID0gJnZwaWZwYXJhbXMtPnN0ZF9pbmZvOwotCi0JZm9yIChpbmRleCA9IDA7IGluZGV4IDwgQVJSQVlfU0laRShjaF9wYXJhbXMpOyBpbmRleCsrKSB7CisJZm9yIChpbmRleCA9IDA7IGluZGV4IDwgdnBpZl9jaF9wYXJhbXNfY291bnQ7IGluZGV4KyspIHsKIAkJY29uZmlnID0gJmNoX3BhcmFtc1tpbmRleF07Ci0JCWlmIChjb25maWctPnN0ZGlkICYgdmlkX2NoLT5zdGRpZCkgewotCQkJbWVtY3B5KHN0ZF9pbmZvLCBjb25maWcsIHNpemVvZigqY29uZmlnKSk7Ci0JCQlicmVhazsKKwkJaWYgKGNvbmZpZy0+aGRfc2QgPT0gMCkgeworCQkJdnBpZl9kYmcoMiwgZGVidWcsICJTRCBmb3JtYXRcbiIpOworCQkJaWYgKGNvbmZpZy0+c3RkaWQgJiB2aWRfY2gtPnN0ZGlkKSB7CisJCQkJbWVtY3B5KHN0ZF9pbmZvLCBjb25maWcsIHNpemVvZigqY29uZmlnKSk7CisJCQkJYnJlYWs7CisJCQl9CisJCX0gZWxzZSB7CisJCQl2cGlmX2RiZygyLCBkZWJ1ZywgIkhEIGZvcm1hdFxuIik7CisJCQlpZiAoY29uZmlnLT5kdl9wcmVzZXQgPT0gdmlkX2NoLT5kdl9wcmVzZXQpIHsKKwkJCQltZW1jcHkoc3RkX2luZm8sIGNvbmZpZywgc2l6ZW9mKCpjb25maWcpKTsKKwkJCQlicmVhazsKKwkJCX0KIAkJfQogCX0KIAogCS8qIHN0YW5kYXJkIG5vdCBmb3VuZCAqLwotCWlmIChpbmRleCA9PSBBUlJBWV9TSVpFKGNoX3BhcmFtcykpCisJaWYgKGluZGV4ID09IHZwaWZfY2hfcGFyYW1zX2NvdW50KQogCQlyZXR1cm4gLUVJTlZBTDsKIAogCWNvbW1vbi0+Zm10LmZtdC5waXgud2lkdGggPSBzdGRfaW5mby0+d2lkdGg7CkBAIC00NjIsNiArNDU2LDcgQEAKIAljb21tb24tPmZtdC5mbXQucGl4LmJ5dGVzcGVybGluZSA9IHN0ZF9pbmZvLT53aWR0aDsKIAl2cGlmcGFyYW1zLT52aWRlb19wYXJhbXMuaHBpdGNoID0gc3RkX2luZm8tPndpZHRoOwogCXZwaWZwYXJhbXMtPnZpZGVvX3BhcmFtcy5zdG9yYWdlX21vZGUgPSBzdGRfaW5mby0+ZnJtX2ZtdDsKKwogCXJldHVybiAwOwogfQogCkBAIC03NTcsNyArNzUyLDcgQEAKIAlzdHJ1Y3QgdmlkZW9fb2JqICp2aWRfY2g7CiAJc3RydWN0IGNoYW5uZWxfb2JqICpjaDsKIAlzdHJ1Y3QgdnBpZl9maCAqZmg7Ci0JaW50IGksIHJldCA9IDA7CisJaW50IGk7CiAKIAl2cGlmX2RiZygyLCBkZWJ1ZywgInZwaWZfb3BlblxuIik7CiAKQEAgLTc2Niw5ICs3NjEsNiBAQAogCXZpZF9jaCA9ICZjaC0+dmlkZW87CiAJY29tbW9uID0gJmNoLT5jb21tb25bVlBJRl9WSURFT19JTkRFWF07CiAKLQlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZjb21tb24tPmxvY2spKQotCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwotCiAJaWYgKE5VTEwgPT0gY2gtPmN1cnJfc3ViZGV2X2luZm8pIHsKIAkJLyoqCiAJCSAqIHNlYXJjaCB0aHJvdWdoIHRoZSBzdWIgZGV2aWNlIHRvIHNlZSBhIHJlZ2lzdGVyZWQKQEAgLTc4NSw4ICs3NzcsNyBAQAogCQl9CiAJCWlmIChpID09IGNvbmZpZy0+c3ViZGV2X2NvdW50KSB7CiAJCQl2cGlmX2VycigiTm8gc3ViIGRldmljZSByZWdpc3RlcmVkXG4iKTsKLQkJCXJldCA9IC1FTk9FTlQ7Ci0JCQlnb3RvIGV4aXQ7CisJCQlyZXR1cm4gLUVOT0VOVDsKIAkJfQogCX0KIApAQCAtNzk0LDggKzc4NSw3IEBACiAJZmggPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgdnBpZl9maCksIEdGUF9LRVJORUwpOwogCWlmIChOVUxMID09IGZoKSB7CiAJCXZwaWZfZXJyKCJ1bmFibGUgdG8gYWxsb2NhdGUgbWVtb3J5IGZvciBmaWxlIGhhbmRsZSBvYmplY3RcbiIpOwotCQlyZXQgPSAtRU5PTUVNOwotCQlnb3RvIGV4aXQ7CisJCXJldHVybiAtRU5PTUVNOwogCX0KIAogCS8qIHN0b3JlIHBvaW50ZXIgdG8gZmggaW4gcHJpdmF0ZV9kYXRhIG1lbWJlciBvZiBmaWxlcCAqLwpAQCAtODE1LDkgKzgwNSw3IEBACiAJLyogSW5pdGlhbGl6ZSBwcmlvcml0eSBvZiB0aGlzIGluc3RhbmNlIHRvIGRlZmF1bHQgcHJpb3JpdHkgKi8KIAlmaC0+cHJpbyA9IFY0TDJfUFJJT1JJVFlfVU5TRVQ7CiAJdjRsMl9wcmlvX29wZW4oJmNoLT5wcmlvLCAmZmgtPnByaW8pOwotZXhpdDoKLQltdXRleF91bmxvY2soJmNvbW1vbi0+bG9jayk7Ci0JcmV0dXJuIHJldDsKKwlyZXR1cm4gMDsKIH0KIAogLyoqCkBAIC04MzcsOSArODI1LDYgQEAKIAogCWNvbW1vbiA9ICZjaC0+Y29tbW9uW1ZQSUZfVklERU9fSU5ERVhdOwogCi0JaWYgKG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmY29tbW9uLT5sb2NrKSkKLQkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKLQogCS8qIGlmIHRoaXMgaW5zdGFuY2UgaXMgZG9pbmcgSU8gKi8KIAlpZiAoZmgtPmlvX2FsbG93ZWRbVlBJRl9WSURFT19JTkRFWF0pIHsKIAkJLyogUmVzZXQgaW9fdXNycyBtZW1iZXIgb2YgY2hhbm5lbCBvYmplY3QgKi8KQEAgLTg2Myw5ICs4NDgsNiBAQAogCS8qIERlY3JlbWVudCBjaGFubmVsIHVzcnMgY291bnRlciAqLwogCWNoLT51c3JzLS07CiAKLQkvKiB1bmxvY2sgbXV0ZXggb24gY2hhbm5lbCBvYmplY3QgKi8KLQltdXRleF91bmxvY2soJmNvbW1vbi0+bG9jayk7Ci0KIAkvKiBDbG9zZSB0aGUgcHJpb3JpdHkgKi8KIAl2NGwyX3ByaW9fY2xvc2UoJmNoLT5wcmlvLCBmaC0+cHJpbyk7CiAKQEAgLTg5MCw3ICs4NzIsNiBAQAogCXN0cnVjdCBjaGFubmVsX29iaiAqY2ggPSBmaC0+Y2hhbm5lbDsKIAlzdHJ1Y3QgY29tbW9uX29iaiAqY29tbW9uOwogCXU4IGluZGV4ID0gMDsKLQlpbnQgcmV0ID0gMDsKIAogCXZwaWZfZGJnKDIsIGRlYnVnLCAidnBpZl9yZXFidWZzXG4iKTsKIApAQCAtOTEzLDEzICs4OTQsOCBAQAogCiAJY29tbW9uID0gJmNoLT5jb21tb25baW5kZXhdOwogCi0JaWYgKG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmY29tbW9uLT5sb2NrKSkKLQkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKLQotCWlmICgwICE9IGNvbW1vbi0+aW9fdXNycykgewotCQlyZXQgPSAtRUJVU1k7Ci0JCWdvdG8gcmVxYnVmX2V4aXQ7Ci0JfQorCWlmICgwICE9IGNvbW1vbi0+aW9fdXNycykKKwkJcmV0dXJuIC1FQlVTWTsKIAogCS8qIEluaXRpYWxpemUgdmlkZW9idWYgcXVldWUgYXMgcGVyIHRoZSBidWZmZXIgdHlwZSAqLwogCXZpZGVvYnVmX3F1ZXVlX2RtYV9jb250aWdfaW5pdCgmY29tbW9uLT5idWZmZXJfcXVldWUsCkBAIC05MjgsNyArOTA0LDcgQEAKIAkJCQkJICAgIHJlcWJ1Zi0+dHlwZSwKIAkJCQkJICAgIGNvbW1vbi0+Zm10LmZtdC5waXguZmllbGQsCiAJCQkJCSAgICBzaXplb2Yoc3RydWN0IHZpZGVvYnVmX2J1ZmZlciksIGZoLAotCQkJCQkgICAgTlVMTCk7CisJCQkJCSAgICAmY29tbW9uLT5sb2NrKTsKIAogCS8qIFNldCBpbyBhbGxvd2VkIG1lbWJlciBvZiBmaWxlIGhhbmRsZSB0byBUUlVFICovCiAJZmgtPmlvX2FsbG93ZWRbaW5kZXhdID0gMTsKQEAgLTkzOSwxMSArOTE1LDcgQEAKIAlJTklUX0xJU1RfSEVBRCgmY29tbW9uLT5kbWFfcXVldWUpOwogCiAJLyogQWxsb2NhdGUgYnVmZmVycyAqLwotCXJldCA9IHZpZGVvYnVmX3JlcWJ1ZnMoJmNvbW1vbi0+YnVmZmVyX3F1ZXVlLCByZXFidWYpOwotCi1yZXFidWZfZXhpdDoKLQltdXRleF91bmxvY2soJmNvbW1vbi0+bG9jayk7Ci0JcmV0dXJuIHJldDsKKwlyZXR1cm4gdmlkZW9idWZfcmVxYnVmcygmY29tbW9uLT5idWZmZXJfcXVldWUsIHJlcWJ1Zik7CiB9CiAKIC8qKgpAQCAtMTE1NywxMSArMTEyOSw2IEBACiAJCXJldHVybiByZXQ7CiAJfQogCi0JaWYgKG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmY29tbW9uLT5sb2NrKSkgewotCQlyZXQgPSAtRVJFU1RBUlRTWVM7Ci0JCWdvdG8gc3RyZWFtb2ZmX2V4aXQ7Ci0JfQotCiAJLyogSWYgYnVmZmVyIHF1ZXVlIGlzIGVtcHR5LCByZXR1cm4gZXJyb3IgKi8KIAlpZiAobGlzdF9lbXB0eSgmY29tbW9uLT5kbWFfcXVldWUpKSB7CiAJCXZwaWZfZGJnKDEsIGRlYnVnLCAiYnVmZmVyIHF1ZXVlIGlzIGVtcHR5XG4iKTsKQEAgLTEyNDAsMTMgKzEyMDcsMTAgQEAKIAkJZW5hYmxlX2NoYW5uZWwxKDEpOwogCX0KIAljaGFubmVsX2ZpcnN0X2ludFtWUElGX1ZJREVPX0lOREVYXVtjaC0+Y2hhbm5lbF9pZF0gPSAxOwotCW11dGV4X3VubG9jaygmY29tbW9uLT5sb2NrKTsKIAlyZXR1cm4gcmV0OwogCiBleGl0OgotCW11dGV4X3VubG9jaygmY29tbW9uLT5sb2NrKTsKLXN0cmVhbW9mZl9leGl0OgotCXJldCA9IHZpZGVvYnVmX3N0cmVhbW9mZigmY29tbW9uLT5idWZmZXJfcXVldWUpOworCXZpZGVvYnVmX3N0cmVhbW9mZigmY29tbW9uLT5idWZmZXJfcXVldWUpOwogCXJldHVybiByZXQ7CiB9CiAKQEAgLTEyODQsOSArMTI0OCw2IEBACiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAotCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmNvbW1vbi0+bG9jaykpCi0JCXJldHVybiAtRVJFU1RBUlRTWVM7Ci0KIAkvKiBkaXNhYmxlIGNoYW5uZWwgKi8KIAlpZiAoVlBJRl9DSEFOTkVMMF9WSURFTyA9PSBjaC0+Y2hhbm5lbF9pZCkgewogCQllbmFibGVfY2hhbm5lbDAoMCk7CkBAIC0xMzA0LDggKzEyNjUsNiBAQAogCWlmIChyZXQgJiYgKHJldCAhPSAtRU5PSU9DVExDTUQpKQogCQl2cGlmX2RiZygxLCBkZWJ1ZywgInN0cmVhbSBvZmYgZmFpbGVkIGluIHN1YmRldlxuIik7CiAKLQltdXRleF91bmxvY2soJmNvbW1vbi0+bG9jayk7Ci0KIAlyZXR1cm4gdmlkZW9idWZfc3RyZWFtb2ZmKCZjb21tb24tPmJ1ZmZlcl9xdWV1ZSk7CiB9CiAKQEAgLTEzODEsMjEgKzEzNDAsMTYgQEAKIHsKIAlzdHJ1Y3QgdnBpZl9maCAqZmggPSBwcml2OwogCXN0cnVjdCBjaGFubmVsX29iaiAqY2ggPSBmaC0+Y2hhbm5lbDsKLQlzdHJ1Y3QgY29tbW9uX29iaiAqY29tbW9uID0gJmNoLT5jb21tb25bVlBJRl9WSURFT19JTkRFWF07CiAJaW50IHJldCA9IDA7CiAKIAl2cGlmX2RiZygyLCBkZWJ1ZywgInZwaWZfcXVlcnlzdGRcbiIpOwogCi0JaWYgKG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmY29tbW9uLT5sb2NrKSkKLQkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKLQogCS8qIENhbGwgcXVlcnlzdGQgZnVuY3Rpb24gb2YgZGVjb2RlciBkZXZpY2UgKi8KIAlyZXQgPSB2NGwyX3N1YmRldl9jYWxsKHZwaWZfb2JqLnNkW2NoLT5jdXJyX3NkX2luZGV4XSwgdmlkZW8sCiAJCQkJcXVlcnlzdGQsIHN0ZF9pZCk7CiAJaWYgKHJldCA8IDApCiAJCXZwaWZfZGJnKDEsIGRlYnVnLCAiRmFpbGVkIHRvIHNldCBzdGFuZGFyZCBmb3Igc3ViIGRldmljZXNcbiIpOwogCi0JbXV0ZXhfdW5sb2NrKCZjb21tb24tPmxvY2spOwogCXJldHVybiByZXQ7CiB9CiAKQEAgLTE0NTEsMTYgKzE0MDUsMTQgQEAKIAlmaC0+aW5pdGlhbGl6ZWQgPSAxOwogCiAJLyogQ2FsbCBlbmNvZGVyIHN1YmRldmljZSBmdW5jdGlvbiB0byBzZXQgdGhlIHN0YW5kYXJkICovCi0JaWYgKG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmY29tbW9uLT5sb2NrKSkKLQkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKLQogCWNoLT52aWRlby5zdGRpZCA9ICpzdGRfaWQ7CisJY2gtPnZpZGVvLmR2X3ByZXNldCA9IFY0TDJfRFZfSU5WQUxJRDsKKwltZW1zZXQoJmNoLT52aWRlby5idF90aW1pbmdzLCAwLCBzaXplb2YoY2gtPnZpZGVvLmJ0X3RpbWluZ3MpKTsKIAogCS8qIEdldCB0aGUgaW5mb3JtYXRpb24gYWJvdXQgdGhlIHN0YW5kYXJkICovCiAJaWYgKHZwaWZfdXBkYXRlX3N0ZF9pbmZvKGNoKSkgewotCQlyZXQgPSAtRUlOVkFMOwogCQl2cGlmX2VycigiRXJyb3IgZ2V0dGluZyB0aGUgc3RhbmRhcmQgaW5mb1xuIik7Ci0JCWdvdG8gc19zdGRfZXhpdDsKKwkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCiAJLyogQ29uZmlndXJlIHRoZSBkZWZhdWx0IGZvcm1hdCBpbmZvcm1hdGlvbiAqLwpAQCAtMTQ3MSw5ICsxNDIzLDYgQEAKIAkJCQlzX3N0ZCwgKnN0ZF9pZCk7CiAJaWYgKHJldCA8IDApCiAJCXZwaWZfZGJnKDEsIGRlYnVnLCAiRmFpbGVkIHRvIHNldCBzdGFuZGFyZCBmb3Igc3ViIGRldmljZXNcbiIpOwotCi1zX3N0ZF9leGl0OgotCW11dGV4X3VubG9jaygmY29tbW9uLT5sb2NrKTsKIAlyZXR1cm4gcmV0OwogfQogCkBAIC0xNTY3LDkgKzE1MTYsNiBAQAogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKLQlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZjb21tb24tPmxvY2spKQotCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwotCiAJLyogZmlyc3Qgc2V0dXAgaW5wdXQgcGF0aCBmcm9tIHN1YiBkZXZpY2UgdG8gdnBpZiAqLwogCWlmIChjb25maWctPnNldHVwX2lucHV0X3BhdGgpIHsKIAkJcmV0ID0gY29uZmlnLT5zZXR1cF9pbnB1dF9wYXRoKGNoLT5jaGFubmVsX2lkLApAQCAtMTU3OCw3ICsxNTI0LDcgQEAKIAkJCXZwaWZfZGJnKDEsIGRlYnVnLCAiY291bGRuJ3Qgc2V0dXAgaW5wdXQgcGF0aCBmb3IgdGhlIgogCQkJCSIgc3ViIGRldmljZSAlcywgZm9yIGlucHV0IGluZGV4ICVkXG4iLAogCQkJCXN1YmRldl9pbmZvLT5uYW1lLCBpbmRleCk7Ci0JCQlnb3RvIGV4aXQ7CisJCQlyZXR1cm4gcmV0OwogCQl9CiAJfQogCkBAIC0xNTg5LDcgKzE1MzUsNyBAQAogCQkJCQlpbnB1dCwgb3V0cHV0LCAwKTsKIAkJaWYgKHJldCA8IDApIHsKIAkJCXZwaWZfZGJnKDEsIGRlYnVnLCAiRmFpbGVkIHRvIHNldCBpbnB1dFxuIik7Ci0JCQlnb3RvIGV4aXQ7CisJCQlyZXR1cm4gcmV0OwogCQl9CiAJfQogCXZpZF9jaC0+aW5wdXRfaWR4ID0gaW5kZXg7CkBAIC0xNjAwLDkgKzE1NDYsNiBAQAogCiAJLyogdXBkYXRlIHR2bm9ybXMgZnJvbSB0aGUgc3ViIGRldmljZSBpbnB1dCBpbmZvICovCiAJY2gtPnZpZGVvX2Rldi0+dHZub3JtcyA9IGNoYW5fY2ZnLT5pbnB1dHNbaW5kZXhdLmlucHV0LnN0ZDsKLQotZXhpdDoKLQltdXRleF91bmxvY2soJmNvbW1vbi0+bG9jayk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtMTY3MSwxMSArMTYxNCw3IEBACiAJCXJldHVybiAtRUlOVkFMOwogCiAJLyogRmlsbCBpbiB0aGUgaW5mb3JtYXRpb24gYWJvdXQgZm9ybWF0ICovCi0JaWYgKG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmY29tbW9uLT5sb2NrKSkKLQkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKLQogCSpmbXQgPSBjb21tb24tPmZtdDsKLQltdXRleF91bmxvY2soJmNvbW1vbi0+bG9jayk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTE2OTQsNyArMTYzMyw3IEBACiAJc3RydWN0IHY0bDJfcGl4X2Zvcm1hdCAqcGl4Zm10OwogCWludCByZXQgPSAwOwogCi0JdnBpZl9kYmcoMiwgZGVidWcsICJWSURJT0NfU19GTVRcbiIpOworCXZwaWZfZGJnKDIsIGRlYnVnLCAiJXNcbiIsIF9fZnVuY19fKTsKIAogCS8qIElmIHN0cmVhbWluZyBpcyBzdGFydGVkLCByZXR1cm4gZXJyb3IgKi8KIAlpZiAoY29tbW9uLT5zdGFydGVkKSB7CkBAIC0xNzIzLDEyICsxNjYyLDcgQEAKIAlpZiAocmV0KQogCQlyZXR1cm4gcmV0OwogCS8qIHN0b3JlIHRoZSBmb3JtYXQgaW4gdGhlIGNoYW5uZWwgb2JqZWN0ICovCi0JaWYgKG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmY29tbW9uLT5sb2NrKSkKLQkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKLQogCWNvbW1vbi0+Zm10ID0gKmZtdDsKLQltdXRleF91bmxvY2soJmNvbW1vbi0+bG9jayk7Ci0KIAlyZXR1cm4gMDsKIH0KIApAQCAtMTgwNyw2ICsxNzQxLDMwNiBAQAogCXJldHVybiAwOwogfQogCisvKioKKyAqIHZwaWZfZW51bV9kdl9wcmVzZXRzKCkgLSBFTlVNX0RWX1BSRVNFVFMgaGFuZGxlcgorICogQGZpbGU6IGZpbGUgcHRyCisgKiBAcHJpdjogZmlsZSBoYW5kbGUKKyAqIEBwcmVzZXQ6IGlucHV0IHByZXNldAorICovCitzdGF0aWMgaW50IHZwaWZfZW51bV9kdl9wcmVzZXRzKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LAorCQlzdHJ1Y3QgdjRsMl9kdl9lbnVtX3ByZXNldCAqcHJlc2V0KQoreworCXN0cnVjdCB2cGlmX2ZoICpmaCA9IHByaXY7CisJc3RydWN0IGNoYW5uZWxfb2JqICpjaCA9IGZoLT5jaGFubmVsOworCisJcmV0dXJuIHY0bDJfc3ViZGV2X2NhbGwodnBpZl9vYmouc2RbY2gtPmN1cnJfc2RfaW5kZXhdLAorCQkJdmlkZW8sIGVudW1fZHZfcHJlc2V0cywgcHJlc2V0KTsKK30KKworLyoqCisgKiB2cGlmX3F1ZXJ5X2R2X3ByZXNldHMoKSAtIFFVRVJZX0RWX1BSRVNFVCBoYW5kbGVyCisgKiBAZmlsZTogZmlsZSBwdHIKKyAqIEBwcml2OiBmaWxlIGhhbmRsZQorICogQHByZXNldDogaW5wdXQgcHJlc2V0CisgKi8KK3N0YXRpYyBpbnQgdnBpZl9xdWVyeV9kdl9wcmVzZXQoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsCisJCXN0cnVjdCB2NGwyX2R2X3ByZXNldCAqcHJlc2V0KQoreworCXN0cnVjdCB2cGlmX2ZoICpmaCA9IHByaXY7CisJc3RydWN0IGNoYW5uZWxfb2JqICpjaCA9IGZoLT5jaGFubmVsOworCisJcmV0dXJuIHY0bDJfc3ViZGV2X2NhbGwodnBpZl9vYmouc2RbY2gtPmN1cnJfc2RfaW5kZXhdLAorCQkgICAgICAgdmlkZW8sIHF1ZXJ5X2R2X3ByZXNldCwgcHJlc2V0KTsKK30KKy8qKgorICogdnBpZl9zX2R2X3ByZXNldHMoKSAtIFNfRFZfUFJFU0VUUyBoYW5kbGVyCisgKiBAZmlsZTogZmlsZSBwdHIKKyAqIEBwcml2OiBmaWxlIGhhbmRsZQorICogQHByZXNldDogaW5wdXQgcHJlc2V0CisgKi8KK3N0YXRpYyBpbnQgdnBpZl9zX2R2X3ByZXNldChzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwKKwkJc3RydWN0IHY0bDJfZHZfcHJlc2V0ICpwcmVzZXQpCit7CisJc3RydWN0IHZwaWZfZmggKmZoID0gcHJpdjsKKwlzdHJ1Y3QgY2hhbm5lbF9vYmogKmNoID0gZmgtPmNoYW5uZWw7CisJc3RydWN0IGNvbW1vbl9vYmogKmNvbW1vbiA9ICZjaC0+Y29tbW9uW1ZQSUZfVklERU9fSU5ERVhdOworCWludCByZXQgPSAwOworCisJaWYgKGNvbW1vbi0+c3RhcnRlZCkgeworCQl2cGlmX2RiZygxLCBkZWJ1ZywgInN0cmVhbWluZyBpbiBwcm9ncmVzc1xuIik7CisJCXJldHVybiAtRUJVU1k7CisJfQorCisJaWYgKChWUElGX0NIQU5ORUwwX1ZJREVPID09IGNoLT5jaGFubmVsX2lkKSB8fAorCSAgICAoVlBJRl9DSEFOTkVMMV9WSURFTyA9PSBjaC0+Y2hhbm5lbF9pZCkpIHsKKwkJaWYgKCFmaC0+aW5pdGlhbGl6ZWQpIHsKKwkJCXZwaWZfZGJnKDEsIGRlYnVnLCAiQ2hhbm5lbCBCdXN5XG4iKTsKKwkJCXJldHVybiAtRUJVU1k7CisJCX0KKwl9CisKKwlyZXQgPSB2NGwyX3ByaW9fY2hlY2soJmNoLT5wcmlvLCBmaC0+cHJpbyk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCWZoLT5pbml0aWFsaXplZCA9IDE7CisKKwkvKiBDYWxsIGVuY29kZXIgc3ViZGV2aWNlIGZ1bmN0aW9uIHRvIHNldCB0aGUgc3RhbmRhcmQgKi8KKwlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZjb21tb24tPmxvY2spKQorCQlyZXR1cm4gLUVSRVNUQVJUU1lTOworCisJY2gtPnZpZGVvLmR2X3ByZXNldCA9IHByZXNldC0+cHJlc2V0OworCWNoLT52aWRlby5zdGRpZCA9IFY0TDJfU1REX1VOS05PV047CisJbWVtc2V0KCZjaC0+dmlkZW8uYnRfdGltaW5ncywgMCwgc2l6ZW9mKGNoLT52aWRlby5idF90aW1pbmdzKSk7CisKKwkvKiBHZXQgdGhlIGluZm9ybWF0aW9uIGFib3V0IHRoZSBzdGFuZGFyZCAqLworCWlmICh2cGlmX3VwZGF0ZV9zdGRfaW5mbyhjaCkpIHsKKwkJdnBpZl9kYmcoMSwgZGVidWcsICJFcnJvciBnZXR0aW5nIHRoZSBzdGFuZGFyZCBpbmZvXG4iKTsKKwkJcmV0ID0gLUVJTlZBTDsKKwl9IGVsc2UgeworCQkvKiBDb25maWd1cmUgdGhlIGRlZmF1bHQgZm9ybWF0IGluZm9ybWF0aW9uICovCisJCXZwaWZfY29uZmlnX2Zvcm1hdChjaCk7CisKKwkJcmV0ID0gdjRsMl9zdWJkZXZfY2FsbCh2cGlmX29iai5zZFtjaC0+Y3Vycl9zZF9pbmRleF0sCisJCQkJdmlkZW8sIHNfZHZfcHJlc2V0LCBwcmVzZXQpOworCX0KKworCW11dGV4X3VubG9jaygmY29tbW9uLT5sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CisvKioKKyAqIHZwaWZfZ19kdl9wcmVzZXRzKCkgLSBHX0RWX1BSRVNFVFMgaGFuZGxlcgorICogQGZpbGU6IGZpbGUgcHRyCisgKiBAcHJpdjogZmlsZSBoYW5kbGUKKyAqIEBwcmVzZXQ6IGlucHV0IHByZXNldAorICovCitzdGF0aWMgaW50IHZwaWZfZ19kdl9wcmVzZXQoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsCisJCXN0cnVjdCB2NGwyX2R2X3ByZXNldCAqcHJlc2V0KQoreworCXN0cnVjdCB2cGlmX2ZoICpmaCA9IHByaXY7CisJc3RydWN0IGNoYW5uZWxfb2JqICpjaCA9IGZoLT5jaGFubmVsOworCisJcHJlc2V0LT5wcmVzZXQgPSBjaC0+dmlkZW8uZHZfcHJlc2V0OworCisJcmV0dXJuIDA7Cit9CisKKy8qKgorICogdnBpZl9zX2R2X3RpbWluZ3MoKSAtIFNfRFZfVElNSU5HUyBoYW5kbGVyCisgKiBAZmlsZTogZmlsZSBwdHIKKyAqIEBwcml2OiBmaWxlIGhhbmRsZQorICogQHRpbWluZ3M6IGRpZ2l0YWwgdmlkZW8gdGltaW5ncworICovCitzdGF0aWMgaW50IHZwaWZfc19kdl90aW1pbmdzKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LAorCQlzdHJ1Y3QgdjRsMl9kdl90aW1pbmdzICp0aW1pbmdzKQoreworCXN0cnVjdCB2cGlmX2ZoICpmaCA9IHByaXY7CisJc3RydWN0IGNoYW5uZWxfb2JqICpjaCA9IGZoLT5jaGFubmVsOworCXN0cnVjdCB2cGlmX3BhcmFtcyAqdnBpZnBhcmFtcyA9ICZjaC0+dnBpZnBhcmFtczsKKwlzdHJ1Y3QgdnBpZl9jaGFubmVsX2NvbmZpZ19wYXJhbXMgKnN0ZF9pbmZvID0gJnZwaWZwYXJhbXMtPnN0ZF9pbmZvOworCXN0cnVjdCB2aWRlb19vYmogKnZpZF9jaCA9ICZjaC0+dmlkZW87CisJc3RydWN0IHY0bDJfYnRfdGltaW5ncyAqYnQgPSAmdmlkX2NoLT5idF90aW1pbmdzOworCWludCByZXQ7CisKKwlpZiAodGltaW5ncy0+dHlwZSAhPSBWNEwyX0RWX0JUXzY1Nl8xMTIwKSB7CisJCXZwaWZfZGJnKDIsIGRlYnVnLCAiVGltaW5nIHR5cGUgbm90IGRlZmluZWRcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKiBDb25maWd1cmUgc3ViZGV2aWNlIHRpbWluZ3MsIGlmIGFueSAqLworCXJldCA9IHY0bDJfc3ViZGV2X2NhbGwodnBpZl9vYmouc2RbY2gtPmN1cnJfc2RfaW5kZXhdLAorCQkJdmlkZW8sIHNfZHZfdGltaW5ncywgdGltaW5ncyk7CisJaWYgKHJldCA9PSAtRU5PSU9DVExDTUQpIHsKKwkJdnBpZl9kYmcoMiwgZGVidWcsICJDdXN0b20gRFYgdGltaW5ncyBub3Qgc3VwcG9ydGVkIGJ5ICIKKwkJCQkic3ViZGV2aWNlXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmIChyZXQgPCAwKSB7CisJCXZwaWZfZGJnKDIsIGRlYnVnLCAiRXJyb3Igc2V0dGluZyBjdXN0b20gRFYgdGltaW5nc1xuIik7CisJCXJldHVybiByZXQ7CisJfQorCisJaWYgKCEodGltaW5ncy0+YnQud2lkdGggJiYgdGltaW5ncy0+YnQuaGVpZ2h0ICYmCisJCQkJKHRpbWluZ3MtPmJ0LmhiYWNrcG9yY2ggfHwKKwkJCQkgdGltaW5ncy0+YnQuaGZyb250cG9yY2ggfHwKKwkJCQkgdGltaW5ncy0+YnQuaHN5bmMpICYmCisJCQkJdGltaW5ncy0+YnQudmZyb250cG9yY2ggJiYKKwkJCQkodGltaW5ncy0+YnQudmJhY2twb3JjaCB8fAorCQkJCSB0aW1pbmdzLT5idC52c3luYykpKSB7CisJCXZwaWZfZGJnKDIsIGRlYnVnLCAiVGltaW5ncyBmb3Igd2lkdGgsIGhlaWdodCwgIgorCQkJCSJob3Jpem9udGFsIGJhY2sgcG9yY2gsIGhvcml6b250YWwgc3luYywgIgorCQkJCSJob3Jpem9udGFsIGZyb250IHBvcmNoLCB2ZXJ0aWNhbCBiYWNrIHBvcmNoLCAiCisJCQkJInZlcnRpY2FsIHN5bmMgYW5kIHZlcnRpY2FsIGJhY2sgcG9yY2ggIgorCQkJCSJtdXN0IGJlIGRlZmluZWRcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkqYnQgPSB0aW1pbmdzLT5idDsKKworCS8qIENvbmZpZ3VyZSB2aWRlbyBwb3J0IHRpbWluZ3MgKi8KKworCXN0ZF9pbmZvLT5lYXYyc2F2ID0gYnQtPmhiYWNrcG9yY2ggKyBidC0+aGZyb250cG9yY2ggKworCQlidC0+aHN5bmMgLSA4OworCXN0ZF9pbmZvLT5zYXYyZWF2ID0gYnQtPndpZHRoOworCisJc3RkX2luZm8tPmwxID0gMTsKKwlzdGRfaW5mby0+bDMgPSBidC0+dnN5bmMgKyBidC0+dmJhY2twb3JjaCArIDE7CisKKwlpZiAoYnQtPmludGVybGFjZWQpIHsKKwkJaWYgKGJ0LT5pbF92YmFja3BvcmNoIHx8IGJ0LT5pbF92ZnJvbnRwb3JjaCB8fCBidC0+aWxfdnN5bmMpIHsKKwkJCXN0ZF9pbmZvLT52c2l6ZSA9IGJ0LT5oZWlnaHQgKiAyICsKKwkJCQlidC0+dmZyb250cG9yY2ggKyBidC0+dnN5bmMgKyBidC0+dmJhY2twb3JjaCArCisJCQkJYnQtPmlsX3Zmcm9udHBvcmNoICsgYnQtPmlsX3ZzeW5jICsKKwkJCQlidC0+aWxfdmJhY2twb3JjaDsKKwkJCXN0ZF9pbmZvLT5sNSA9IHN0ZF9pbmZvLT52c2l6ZS8yIC0KKwkJCQkoYnQtPnZmcm9udHBvcmNoIC0gMSk7CisJCQlzdGRfaW5mby0+bDcgPSBzdGRfaW5mby0+dnNpemUvMiArIDE7CisJCQlzdGRfaW5mby0+bDkgPSBzdGRfaW5mby0+bDcgKyBidC0+aWxfdnN5bmMgKworCQkJCWJ0LT5pbF92YmFja3BvcmNoICsgMTsKKwkJCXN0ZF9pbmZvLT5sMTEgPSBzdGRfaW5mby0+dnNpemUgLQorCQkJCShidC0+aWxfdmZyb250cG9yY2ggLSAxKTsKKwkJfSBlbHNlIHsKKwkJCXZwaWZfZGJnKDIsIGRlYnVnLCAiUmVxdWlyZWQgdGltaW5nIHZhbHVlcyBmb3IgIgorCQkJCQkiaW50ZXJsYWNlZCBCVCBmb3JtYXQgbWlzc2luZ1xuIik7CisJCQlyZXR1cm4gLUVJTlZBTDsKKwkJfQorCX0gZWxzZSB7CisJCXN0ZF9pbmZvLT52c2l6ZSA9IGJ0LT5oZWlnaHQgKyBidC0+dmZyb250cG9yY2ggKworCQkJYnQtPnZzeW5jICsgYnQtPnZiYWNrcG9yY2g7CisJCXN0ZF9pbmZvLT5sNSA9IHN0ZF9pbmZvLT52c2l6ZSAtIChidC0+dmZyb250cG9yY2ggLSAxKTsKKwl9CisJc3RybmNweShzdGRfaW5mby0+bmFtZSwgIkN1c3RvbSB0aW1pbmdzIEJUNjU2LzExMjAiLCBWUElGX01BWF9OQU1FKTsKKwlzdGRfaW5mby0+d2lkdGggPSBidC0+d2lkdGg7CisJc3RkX2luZm8tPmhlaWdodCA9IGJ0LT5oZWlnaHQ7CisJc3RkX2luZm8tPmZybV9mbXQgPSBidC0+aW50ZXJsYWNlZCA/IDAgOiAxOworCXN0ZF9pbmZvLT55Y211eF9tb2RlID0gMDsKKwlzdGRfaW5mby0+Y2FwdHVyZV9mb3JtYXQgPSAwOworCXN0ZF9pbmZvLT52Ymlfc3VwcG9ydGVkID0gMDsKKwlzdGRfaW5mby0+aGRfc2QgPSAxOworCXN0ZF9pbmZvLT5zdGRpZCA9IDA7CisJc3RkX2luZm8tPmR2X3ByZXNldCA9IFY0TDJfRFZfSU5WQUxJRDsKKworCXZpZF9jaC0+c3RkaWQgPSAwOworCXZpZF9jaC0+ZHZfcHJlc2V0ID0gVjRMMl9EVl9JTlZBTElEOworCXJldHVybiAwOworfQorCisvKioKKyAqIHZwaWZfZ19kdl90aW1pbmdzKCkgLSBHX0RWX1RJTUlOR1MgaGFuZGxlcgorICogQGZpbGU6IGZpbGUgcHRyCisgKiBAcHJpdjogZmlsZSBoYW5kbGUKKyAqIEB0aW1pbmdzOiBkaWdpdGFsIHZpZGVvIHRpbWluZ3MKKyAqLworc3RhdGljIGludCB2cGlmX2dfZHZfdGltaW5ncyhzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwKKwkJc3RydWN0IHY0bDJfZHZfdGltaW5ncyAqdGltaW5ncykKK3sKKwlzdHJ1Y3QgdnBpZl9maCAqZmggPSBwcml2OworCXN0cnVjdCBjaGFubmVsX29iaiAqY2ggPSBmaC0+Y2hhbm5lbDsKKwlzdHJ1Y3QgdmlkZW9fb2JqICp2aWRfY2ggPSAmY2gtPnZpZGVvOworCXN0cnVjdCB2NGwyX2J0X3RpbWluZ3MgKmJ0ID0gJnZpZF9jaC0+YnRfdGltaW5nczsKKworCXRpbWluZ3MtPmJ0ID0gKmJ0OworCisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiB2cGlmX2dfY2hpcF9pZGVudCgpIC0gSWRlbnRpZnkgdGhlIGNoaXAKKyAqIEBmaWxlOiBmaWxlIHB0cgorICogQHByaXY6IGZpbGUgaGFuZGxlCisgKiBAY2hpcDogY2hpcCBpZGVudGl0eQorICoKKyAqIFJldHVybnMgemVybyBvciAtRUlOVkFMIGlmIHJlYWQgb3BlcmF0aW9ucyBmYWlscy4KKyAqLworc3RhdGljIGludCB2cGlmX2dfY2hpcF9pZGVudChzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwKKwkJc3RydWN0IHY0bDJfZGJnX2NoaXBfaWRlbnQgKmNoaXApCit7CisJY2hpcC0+aWRlbnQgPSBWNEwyX0lERU5UX05PTkU7CisJY2hpcC0+cmV2aXNpb24gPSAwOworCWlmIChjaGlwLT5tYXRjaC50eXBlICE9IFY0TDJfQ0hJUF9NQVRDSF9JMkNfRFJJVkVSICYmCisJCQljaGlwLT5tYXRjaC50eXBlICE9IFY0TDJfQ0hJUF9NQVRDSF9JMkNfQUREUikgeworCQl2cGlmX2RiZygyLCBkZWJ1ZywgIm1hdGNoX3R5cGUgaXMgaW52YWxpZC5cbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlyZXR1cm4gdjRsMl9kZXZpY2VfY2FsbF91bnRpbF9lcnIoJnZwaWZfb2JqLnY0bDJfZGV2LCAwLCBjb3JlLAorCQkJZ19jaGlwX2lkZW50LCBjaGlwKTsKK30KKworI2lmZGVmIENPTkZJR19WSURFT19BRFZfREVCVUcKKy8qCisgKiB2cGlmX2RiZ19nX3JlZ2lzdGVyKCkgLSBSZWFkIHJlZ2lzdGVyCisgKiBAZmlsZTogZmlsZSBwdHIKKyAqIEBwcml2OiBmaWxlIGhhbmRsZQorICogQHJlZzogcmVnaXN0ZXIgdG8gYmUgcmVhZAorICoKKyAqIERlYnVnZ2luZyBvbmx5CisgKiBSZXR1cm5zIHplcm8gb3IgLUVJTlZBTCBpZiByZWFkIG9wZXJhdGlvbnMgZmFpbHMuCisgKi8KK3N0YXRpYyBpbnQgdnBpZl9kYmdfZ19yZWdpc3RlcihzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwKKwkJc3RydWN0IHY0bDJfZGJnX3JlZ2lzdGVyICpyZWcpeworCXN0cnVjdCB2cGlmX2ZoICpmaCA9IHByaXY7CisJc3RydWN0IGNoYW5uZWxfb2JqICpjaCA9IGZoLT5jaGFubmVsOworCisJcmV0dXJuIHY0bDJfc3ViZGV2X2NhbGwodnBpZl9vYmouc2RbY2gtPmN1cnJfc2RfaW5kZXhdLCBjb3JlLAorCQkJZ19yZWdpc3RlciwgcmVnKTsKK30KKworLyoKKyAqIHZwaWZfZGJnX3NfcmVnaXN0ZXIoKSAtIFdyaXRlIHRvIHJlZ2lzdGVyCisgKiBAZmlsZTogZmlsZSBwdHIKKyAqIEBwcml2OiBmaWxlIGhhbmRsZQorICogQHJlZzogcmVnaXN0ZXIgdG8gYmUgbW9kaWZpZWQKKyAqCisgKiBEZWJ1Z2dpbmcgb25seQorICogUmV0dXJucyB6ZXJvIG9yIC1FSU5WQUwgaWYgd3JpdGUgb3BlcmF0aW9ucyBmYWlscy4KKyAqLworc3RhdGljIGludCB2cGlmX2RiZ19zX3JlZ2lzdGVyKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LAorCQlzdHJ1Y3QgdjRsMl9kYmdfcmVnaXN0ZXIgKnJlZyl7CisJc3RydWN0IHZwaWZfZmggKmZoID0gcHJpdjsKKwlzdHJ1Y3QgY2hhbm5lbF9vYmogKmNoID0gZmgtPmNoYW5uZWw7CisKKwlyZXR1cm4gdjRsMl9zdWJkZXZfY2FsbCh2cGlmX29iai5zZFtjaC0+Y3Vycl9zZF9pbmRleF0sIGNvcmUsCisJCQlzX3JlZ2lzdGVyLCByZWcpOworfQorI2VuZGlmCisKKy8qCisgKiB2cGlmX2xvZ19zdGF0dXMoKSAtIFN0YXR1cyBpbmZvcm1hdGlvbgorICogQGZpbGU6IGZpbGUgcHRyCisgKiBAcHJpdjogZmlsZSBoYW5kbGUKKyAqCisgKiBSZXR1cm5zIHplcm8uCisgKi8KK3N0YXRpYyBpbnQgdnBpZl9sb2dfc3RhdHVzKHN0cnVjdCBmaWxlICpmaWxlcCwgdm9pZCAqcHJpdikKK3sKKwkvKiBzdGF0dXMgZm9yIHN1YiBkZXZpY2VzICovCisJdjRsMl9kZXZpY2VfY2FsbF9hbGwoJnZwaWZfb2JqLnY0bDJfZGV2LCAwLCBjb3JlLCBsb2dfc3RhdHVzKTsKKworCXJldHVybiAwOworfQorCiAvKiB2cGlmIGNhcHR1cmUgaW9jdGwgb3BlcmF0aW9ucyAqLwogc3RhdGljIGNvbnN0IHN0cnVjdCB2NGwyX2lvY3RsX29wcyB2cGlmX2lvY3RsX29wcyA9IHsKIAkudmlkaW9jX3F1ZXJ5Y2FwICAgICAgICAJPSB2cGlmX3F1ZXJ5Y2FwLApAQCAtMTgyOSw2ICsyMDYzLDE4IEBACiAJLnZpZGlvY19zdHJlYW1vbiAgICAgICAgCT0gdnBpZl9zdHJlYW1vbiwKIAkudmlkaW9jX3N0cmVhbW9mZiAgICAgICAJPSB2cGlmX3N0cmVhbW9mZiwKIAkudmlkaW9jX2Nyb3BjYXAgICAgICAgICAJPSB2cGlmX2Nyb3BjYXAsCisJLnZpZGlvY19lbnVtX2R2X3ByZXNldHMgICAgICAgICA9IHZwaWZfZW51bV9kdl9wcmVzZXRzLAorCS52aWRpb2Nfc19kdl9wcmVzZXQgICAgICAgICAgICAgPSB2cGlmX3NfZHZfcHJlc2V0LAorCS52aWRpb2NfZ19kdl9wcmVzZXQgICAgICAgICAgICAgPSB2cGlmX2dfZHZfcHJlc2V0LAorCS52aWRpb2NfcXVlcnlfZHZfcHJlc2V0ICAgICAgICAgPSB2cGlmX3F1ZXJ5X2R2X3ByZXNldCwKKwkudmlkaW9jX3NfZHZfdGltaW5ncyAgICAgICAgICAgID0gdnBpZl9zX2R2X3RpbWluZ3MsCisJLnZpZGlvY19nX2R2X3RpbWluZ3MgICAgICAgICAgICA9IHZwaWZfZ19kdl90aW1pbmdzLAorCS52aWRpb2NfZ19jaGlwX2lkZW50CQk9IHZwaWZfZ19jaGlwX2lkZW50LAorI2lmZGVmIENPTkZJR19WSURFT19BRFZfREVCVUcKKwkudmlkaW9jX2dfcmVnaXN0ZXIJCT0gdnBpZl9kYmdfZ19yZWdpc3RlciwKKwkudmlkaW9jX3NfcmVnaXN0ZXIJCT0gdnBpZl9kYmdfc19yZWdpc3RlciwKKyNlbmRpZgorCS52aWRpb2NfbG9nX3N0YXR1cwkJPSB2cGlmX2xvZ19zdGF0dXMsCiB9OwogCiAvKiB2cGlmIGZpbGUgb3BlcmF0aW9ucyAqLwpAQCAtMTgzNiw3ICsyMDgyLDcgQEAKIAkub3duZXIgPSBUSElTX01PRFVMRSwKIAkub3BlbiA9IHZwaWZfb3BlbiwKIAkucmVsZWFzZSA9IHZwaWZfcmVsZWFzZSwKLQkuaW9jdGwgPSB2aWRlb19pb2N0bDIsCisJLnVubG9ja2VkX2lvY3RsID0gdmlkZW9faW9jdGwyLAogCS5tbWFwID0gdnBpZl9tbWFwLAogCS5wb2xsID0gdnBpZl9wb2xsCiB9OwpAQCAtMTk3OSw2ICsyMjI1LDcgQEAKIAkJY29tbW9uID0gJihjaC0+Y29tbW9uW1ZQSUZfVklERU9fSU5ERVhdKTsKIAkJc3Bpbl9sb2NrX2luaXQoJmNvbW1vbi0+aXJxbG9jayk7CiAJCW11dGV4X2luaXQoJmNvbW1vbi0+bG9jayk7CisJCWNoLT52aWRlb19kZXYtPmxvY2sgPSAmY29tbW9uLT5sb2NrOwogCQkvKiBJbml0aWFsaXplIHByaW8gbWVtYmVyIG9mIGNoYW5uZWwgb2JqZWN0ICovCiAJCXY0bDJfcHJpb19pbml0KCZjaC0+cHJpbyk7CiAJCWVyciA9IHZpZGVvX3JlZ2lzdGVyX2RldmljZShjaC0+dmlkZW9fZGV2LApAQCAtMjAyNiw5ICsyMjczLDkgQEAKIAkJaWYgKHZwaWZfb2JqLnNkW2ldKQogCQkJdnBpZl9vYmouc2RbaV0tPmdycF9pZCA9IDEgPDwgaTsKIAl9Ci0JdjRsMl9pbmZvKCZ2cGlmX29iai52NGwyX2RldiwgIkRNNjQ2eCBWUElGIENhcHR1cmUgZHJpdmVyIgotCQkgICIgaW5pdGlhbGl6ZWRcbiIpOwogCisJdjRsMl9pbmZvKCZ2cGlmX29iai52NGwyX2RldiwKKwkJCSJETTY0NnggVlBJRiBjYXB0dXJlIGRyaXZlciBpbml0aWFsaXplZFxuIik7CiAJcmV0dXJuIDA7CiAKIHByb2JlX3N1YmRldl9vdXQ6CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2RhdmluY2kvdnBpZl9jYXB0dXJlLmggYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2RhdmluY2kvdnBpZl9jYXB0dXJlLmgKaW5kZXggNGUxMmVjOC4uN2E0MTk2ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9kYXZpbmNpL3ZwaWZfY2FwdHVyZS5oCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZGF2aW5jaS92cGlmX2NhcHR1cmUuaApAQCAtNTksNiArNTksOCBAQAogCWVudW0gdjRsMl9maWVsZCBidWZfZmllbGQ7CiAJLyogQ3VycmVudGx5IHNlbGVjdGVkIG9yIGRlZmF1bHQgc3RhbmRhcmQgKi8KIAl2NGwyX3N0ZF9pZCBzdGRpZDsKKwl1MzIgZHZfcHJlc2V0OworCXN0cnVjdCB2NGwyX2J0X3RpbWluZ3MgYnRfdGltaW5nczsKIAkvKiBUaGlzIGlzIHRvIHRyYWNrIHRoZSBsYXN0IGlucHV0IHRoYXQgaXMgcGFzc2VkIHRvIGFwcGxpY2F0aW9uICovCiAJdTMyIGlucHV0X2lkeDsKIH07CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2RhdmluY2kvdnBpZl9kaXNwbGF5LmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2RhdmluY2kvdnBpZl9kaXNwbGF5LmMKaW5kZXggNDEyYzY1ZC4uY2RmNjU5YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9kYXZpbmNpL3ZwaWZfZGlzcGxheS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZGF2aW5jaS92cGlmX2Rpc3BsYXkuYwpAQCAtMzgsNiArMzgsNyBAQAogI2luY2x1ZGUgPG1lZGlhL2FkdjczNDMuaD4KICNpbmNsdWRlIDxtZWRpYS92NGwyLWRldmljZS5oPgogI2luY2x1ZGUgPG1lZGlhL3Y0bDItaW9jdGwuaD4KKyNpbmNsdWRlIDxtZWRpYS92NGwyLWNoaXAtaWRlbnQuaD4KIAogI2luY2x1ZGUgPG1hY2gvZG02NDZ4Lmg+CiAKQEAgLTg0LDE3ICs4NSw2IEBACiBzdGF0aWMgc3RydWN0IHZwaWZfZGV2aWNlIHZwaWZfb2JqID0geyB7TlVMTH0gfTsKIHN0YXRpYyBzdHJ1Y3QgZGV2aWNlICp2cGlmX2RldjsKIAotc3RhdGljIGNvbnN0IHN0cnVjdCB2cGlmX2NoYW5uZWxfY29uZmlnX3BhcmFtcyBjaF9wYXJhbXNbXSA9IHsKLQl7Ci0JCSJOVFNDIiwgNzIwLCA0ODAsIDMwLCAwLCAxLCAyNjgsIDE0NDAsIDEsIDIzLCAyNjMsIDI2NiwKLQkJMjg2LCA1MjUsIDUyNSwgMCwgMSwgMCwgVjRMMl9TVERfNTI1XzYwLAotCX0sCi0JewotCQkiUEFMIiwgNzIwLCA1NzYsIDI1LCAwLCAxLCAyODAsIDE0NDAsIDEsIDIzLCAzMTEsIDMxMywKLQkJMzM2LCA2MjQsIDYyNSwgMCwgMSwgMCwgVjRMMl9TVERfNjI1XzUwLAotCX0sCi19OwotCiAvKgogICogdnBpZl91c2VydmlydF90b19waHlzOiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgdG8gY29udmVydCB1c2VyCiAgKiBzcGFjZSB2aXJ0dWFsIGFkZHJlc3MgdG8gcGh5c2ljYWwgYWRkcmVzcy4KQEAgLTM3MywzMCArMzYzLDU0IEBACiAJcmV0dXJuIElSUV9IQU5ETEVEOwogfQogCi1zdGF0aWMgaW50IHZwaWZfZ2V0X3N0ZF9pbmZvKHN0cnVjdCBjaGFubmVsX29iaiAqY2gpCitzdGF0aWMgaW50IHZwaWZfdXBkYXRlX3N0ZF9pbmZvKHN0cnVjdCBjaGFubmVsX29iaiAqY2gpCiB7Ci0Jc3RydWN0IGNvbW1vbl9vYmogKmNvbW1vbiA9ICZjaC0+Y29tbW9uW1ZQSUZfVklERU9fSU5ERVhdOwogCXN0cnVjdCB2aWRlb19vYmogKnZpZF9jaCA9ICZjaC0+dmlkZW87CiAJc3RydWN0IHZwaWZfcGFyYW1zICp2cGlmcGFyYW1zID0gJmNoLT52cGlmcGFyYW1zOwogCXN0cnVjdCB2cGlmX2NoYW5uZWxfY29uZmlnX3BhcmFtcyAqc3RkX2luZm8gPSAmdnBpZnBhcmFtcy0+c3RkX2luZm87CiAJY29uc3Qgc3RydWN0IHZwaWZfY2hhbm5lbF9jb25maWdfcGFyYW1zICpjb25maWc7CiAKLQlpbnQgaW5kZXg7CisJaW50IGk7CiAKLQlzdGRfaW5mby0+c3RkaWQgPSB2aWRfY2gtPnN0ZGlkOwotCWlmICghc3RkX2luZm8tPnN0ZGlkKQotCQlyZXR1cm4gLTE7Ci0KLQlmb3IgKGluZGV4ID0gMDsgaW5kZXggPCBBUlJBWV9TSVpFKGNoX3BhcmFtcyk7IGluZGV4KyspIHsKLQkJY29uZmlnID0gJmNoX3BhcmFtc1tpbmRleF07Ci0JCWlmIChjb25maWctPnN0ZGlkICYgc3RkX2luZm8tPnN0ZGlkKSB7Ci0JCQltZW1jcHkoc3RkX2luZm8sIGNvbmZpZywgc2l6ZW9mKCpjb25maWcpKTsKLQkJCWJyZWFrOworCWZvciAoaSA9IDA7IGkgPCB2cGlmX2NoX3BhcmFtc19jb3VudDsgaSsrKSB7CisJCWNvbmZpZyA9ICZjaF9wYXJhbXNbaV07CisJCWlmIChjb25maWctPmhkX3NkID09IDApIHsKKwkJCXZwaWZfZGJnKDIsIGRlYnVnLCAiU0QgZm9ybWF0XG4iKTsKKwkJCWlmIChjb25maWctPnN0ZGlkICYgdmlkX2NoLT5zdGRpZCkgeworCQkJCW1lbWNweShzdGRfaW5mbywgY29uZmlnLCBzaXplb2YoKmNvbmZpZykpOworCQkJCWJyZWFrOworCQkJfQorCQl9IGVsc2UgeworCQkJdnBpZl9kYmcoMiwgZGVidWcsICJIRCBmb3JtYXRcbiIpOworCQkJaWYgKGNvbmZpZy0+ZHZfcHJlc2V0ID09IHZpZF9jaC0+ZHZfcHJlc2V0KSB7CisJCQkJbWVtY3B5KHN0ZF9pbmZvLCBjb25maWcsIHNpemVvZigqY29uZmlnKSk7CisJCQkJYnJlYWs7CisJCQl9CiAJCX0KIAl9CiAKLQlpZiAoaW5kZXggPT0gQVJSQVlfU0laRShjaF9wYXJhbXMpKQotCQlyZXR1cm4gLTE7CisJaWYgKGkgPT0gdnBpZl9jaF9wYXJhbXNfY291bnQpIHsKKwkJdnBpZl9kYmcoMSwgZGVidWcsICJGb3JtYXQgbm90IGZvdW5kXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgdnBpZl91cGRhdGVfcmVzb2x1dGlvbihzdHJ1Y3QgY2hhbm5lbF9vYmogKmNoKQoreworCXN0cnVjdCBjb21tb25fb2JqICpjb21tb24gPSAmY2gtPmNvbW1vbltWUElGX1ZJREVPX0lOREVYXTsKKwlzdHJ1Y3QgdmlkZW9fb2JqICp2aWRfY2ggPSAmY2gtPnZpZGVvOworCXN0cnVjdCB2cGlmX3BhcmFtcyAqdnBpZnBhcmFtcyA9ICZjaC0+dnBpZnBhcmFtczsKKwlzdHJ1Y3QgdnBpZl9jaGFubmVsX2NvbmZpZ19wYXJhbXMgKnN0ZF9pbmZvID0gJnZwaWZwYXJhbXMtPnN0ZF9pbmZvOworCisJaWYgKCF2aWRfY2gtPnN0ZGlkICYmICF2aWRfY2gtPmR2X3ByZXNldCAmJiAhdmlkX2NoLT5idF90aW1pbmdzLmhlaWdodCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAodmlkX2NoLT5zdGRpZCB8fCB2aWRfY2gtPmR2X3ByZXNldCkgeworCQlpZiAodnBpZl91cGRhdGVfc3RkX2luZm8oY2gpKQorCQkJcmV0dXJuIC1FSU5WQUw7CisJfQogCiAJY29tbW9uLT5mbXQuZm10LnBpeC53aWR0aCA9IHN0ZF9pbmZvLT53aWR0aDsKIAljb21tb24tPmZtdC5mbXQucGl4LmhlaWdodCA9IHN0ZF9pbmZvLT5oZWlnaHQ7CkBAIC00MDQsOCArNDE4LDggQEAKIAkJCWNvbW1vbi0+Zm10LmZtdC5waXgud2lkdGgsIGNvbW1vbi0+Zm10LmZtdC5waXguaGVpZ2h0KTsKIAogCS8qIFNldCBoZWlnaHQgYW5kIHdpZHRoIHBhcmFtYXRlcmVzICovCi0JY2gtPmNvbW1vbltWUElGX1ZJREVPX0lOREVYXS5oZWlnaHQgPSBzdGRfaW5mby0+aGVpZ2h0OwotCWNoLT5jb21tb25bVlBJRl9WSURFT19JTkRFWF0ud2lkdGggPSBzdGRfaW5mby0+d2lkdGg7CisJY29tbW9uLT5oZWlnaHQgPSBzdGRfaW5mby0+aGVpZ2h0OworCWNvbW1vbi0+d2lkdGggPSBzdGRfaW5mby0+d2lkdGg7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTUxNiwxMCArNTMwLDggQEAKIAllbHNlCiAJCXNpemVpbWFnZSA9IGNvbmZpZ19wYXJhbXMuY2hhbm5lbF9idWZzaXplW2NoLT5jaGFubmVsX2lkXTsKIAotCWlmICh2cGlmX2dldF9zdGRfaW5mbyhjaCkpIHsKLQkJdnBpZl9lcnIoIkVycm9yIGdldHRpbmcgdGhlIHN0YW5kYXJkIGluZm9cbiIpOworCWlmICh2cGlmX3VwZGF0ZV9yZXNvbHV0aW9uKGNoKSkKIAkJcmV0dXJuIC1FSU5WQUw7Ci0JfQogCiAJaHBpdGNoID0gcGl4Zm10LT5ieXRlc3BlcmxpbmU7CiAJdnBpdGNoID0gc2l6ZWltYWdlIC8gKGhwaXRjaCAqIDIpOwpAQCAtNTY4LDcgKzU4MCwxMCBAQAogc3RhdGljIGludCB2cGlmX21tYXAoc3RydWN0IGZpbGUgKmZpbGVwLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKIHsKIAlzdHJ1Y3QgdnBpZl9maCAqZmggPSBmaWxlcC0+cHJpdmF0ZV9kYXRhOwotCXN0cnVjdCBjb21tb25fb2JqICpjb21tb24gPSAmZmgtPmNoYW5uZWwtPmNvbW1vbltWUElGX1ZJREVPX0lOREVYXTsKKwlzdHJ1Y3QgY2hhbm5lbF9vYmogKmNoID0gZmgtPmNoYW5uZWw7CisJc3RydWN0IGNvbW1vbl9vYmogKmNvbW1vbiA9ICYoY2gtPmNvbW1vbltWUElGX1ZJREVPX0lOREVYXSk7CisKKwl2cGlmX2RiZygyLCBkZWJ1ZywgInZwaWZfbW1hcFxuIik7CiAKIAlyZXR1cm4gdmlkZW9idWZfbW1hcF9tYXBwZXIoJmNvbW1vbi0+YnVmZmVyX3F1ZXVlLCB2bWEpOwogfQpAQCAtNjM3LDkgKzY1Miw2IEBACiAJc3RydWN0IGNoYW5uZWxfb2JqICpjaCA9IGZoLT5jaGFubmVsOwogCXN0cnVjdCBjb21tb25fb2JqICpjb21tb24gPSAmY2gtPmNvbW1vbltWUElGX1ZJREVPX0lOREVYXTsKIAotCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmNvbW1vbi0+bG9jaykpCi0JCXJldHVybiAtRVJFU1RBUlRTWVM7Ci0KIAkvKiBpZiB0aGlzIGluc3RhbmNlIGlzIGRvaW5nIElPICovCiAJaWYgKGZoLT5pb19hbGxvd2VkW1ZQSUZfVklERU9fSU5ERVhdKSB7CiAJCS8qIFJlc2V0IGlvX3VzcnMgbWVtYmVyIG9mIGNoYW5uZWwgb2JqZWN0ICovCkBAIC02NjIsOCArNjc0LDYgQEAKIAkJICAgIGNvbmZpZ19wYXJhbXMubnVtYnVmZmVyc1tjaC0+Y2hhbm5lbF9pZF07CiAJfQogCi0JbXV0ZXhfdW5sb2NrKCZjb21tb24tPmxvY2spOwotCiAJLyogRGVjcmVtZW50IGNoYW5uZWwgdXNycyBjb3VudGVyICovCiAJYXRvbWljX2RlYygmY2gtPnVzcnMpOwogCS8qIElmIHRoaXMgZmlsZSBoYW5kbGUgaGFzIGluaXRpYWxpemUgZW5jb2RlciBkZXZpY2UsIHJlc2V0IGl0ICovCkBAIC02ODAsNyArNjkwLDEyIEBACiB9CiAKIC8qIGZ1bmN0aW9ucyBpbXBsZW1lbnRpbmcgaW9jdGxzICovCi0KKy8qKgorICogdnBpZl9xdWVyeWNhcCgpIC0gUVVFUllDQVAgaGFuZGxlcgorICogQGZpbGU6IGZpbGUgcHRyCisgKiBAcHJpdjogZmlsZSBoYW5kbGUKKyAqIEBjYXA6IHB0ciB0byB2NGwyX2NhcGFiaWxpdHkgc3RydWN0dXJlCisgKi8KIHN0YXRpYyBpbnQgdnBpZl9xdWVyeWNhcChzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAgKnByaXYsCiAJCQkJc3RydWN0IHY0bDJfY2FwYWJpbGl0eSAqY2FwKQogewpAQCAtNzIyLDE3ICs3MzcsOSBAQAogCWlmIChjb21tb24tPmZtdC50eXBlICE9IGZtdC0+dHlwZSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKLQkvKiBGaWxsIGluIHRoZSBpbmZvcm1hdGlvbiBhYm91dCBmb3JtYXQgKi8KLQlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZjb21tb24tPmxvY2spKQotCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwotCi0JaWYgKHZwaWZfZ2V0X3N0ZF9pbmZvKGNoKSkgewotCQl2cGlmX2VycigiRXJyb3IgZ2V0dGluZyB0aGUgc3RhbmRhcmQgaW5mb1xuIik7CisJaWYgKHZwaWZfdXBkYXRlX3Jlc29sdXRpb24oY2gpKQogCQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KIAkqZm10ID0gY29tbW9uLT5mbXQ7Ci0JbXV0ZXhfdW5sb2NrKCZjb21tb24tPmxvY2spOwogCXJldHVybiAwOwogfQogCkBAIC03NzMsMTIgKzc4MCw3IEBACiAJLyogc3RvcmUgdGhlIHBpeCBmb3JtYXQgaW4gdGhlIGNoYW5uZWwgb2JqZWN0ICovCiAJY29tbW9uLT5mbXQuZm10LnBpeCA9ICpwaXhmbXQ7CiAJLyogc3RvcmUgdGhlIGZvcm1hdCBpbiB0aGUgY2hhbm5lbCBvYmplY3QgKi8KLQlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZjb21tb24tPmxvY2spKQotCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwotCiAJY29tbW9uLT5mbXQgPSAqZm10OwotCW11dGV4X3VubG9jaygmY29tbW9uLT5sb2NrKTsKLQogCXJldHVybiAwOwogfQogCkBAIC04MDgsNyArODEwLDYgQEAKIAlzdHJ1Y3QgY29tbW9uX29iaiAqY29tbW9uOwogCWVudW0gdjRsMl9maWVsZCBmaWVsZDsKIAl1OCBpbmRleCA9IDA7Ci0JaW50IHJldCA9IDA7CiAKIAkvKiBUaGlzIGZpbGUgaGFuZGxlIGhhcyBub3QgaW5pdGlhbGl6ZWQgdGhlIGNoYW5uZWwsCiAJICAgSXQgaXMgbm90IGFsbG93ZWQgdG8gZG8gc2V0dGluZ3MgKi8KQEAgLTgyNiwxOCArODI3LDEyIEBACiAJaW5kZXggPSBWUElGX1ZJREVPX0lOREVYOwogCiAJY29tbW9uID0gJmNoLT5jb21tb25baW5kZXhdOwotCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmNvbW1vbi0+bG9jaykpCi0JCXJldHVybiAtRVJFU1RBUlRTWVM7CiAKLQlpZiAoY29tbW9uLT5mbXQudHlwZSAhPSByZXFidWYtPnR5cGUpIHsKLQkJcmV0ID0gLUVJTlZBTDsKLQkJZ290byByZXFidWZfZXhpdDsKLQl9CisJaWYgKGNvbW1vbi0+Zm10LnR5cGUgIT0gcmVxYnVmLT50eXBlKQorCQlyZXR1cm4gLUVJTlZBTDsKIAotCWlmICgwICE9IGNvbW1vbi0+aW9fdXNycykgewotCQlyZXQgPSAtRUJVU1k7Ci0JCWdvdG8gcmVxYnVmX2V4aXQ7Ci0JfQorCWlmICgwICE9IGNvbW1vbi0+aW9fdXNycykKKwkJcmV0dXJuIC1FQlVTWTsKIAogCWlmIChyZXFidWYtPnR5cGUgPT0gVjRMMl9CVUZfVFlQRV9WSURFT19PVVRQVVQpIHsKIAkJaWYgKGNvbW1vbi0+Zm10LmZtdC5waXguZmllbGQgPT0gVjRMMl9GSUVMRF9BTlkpCkBAIC04NTQsNyArODQ5LDcgQEAKIAkJCQkJICAgICZjb21tb24tPmlycWxvY2ssCiAJCQkJCSAgICByZXFidWYtPnR5cGUsIGZpZWxkLAogCQkJCQkgICAgc2l6ZW9mKHN0cnVjdCB2aWRlb2J1Zl9idWZmZXIpLCBmaCwKLQkJCQkJICAgIE5VTEwpOworCQkJCQkgICAgJmNvbW1vbi0+bG9jayk7CiAKIAkvKiBTZXQgaW8gYWxsb3dlZCBtZW1iZXIgb2YgZmlsZSBoYW5kbGUgdG8gVFJVRSAqLwogCWZoLT5pb19hbGxvd2VkW2luZGV4XSA9IDE7CkBAIC04NjUsMTEgKzg2MCw3IEBACiAJSU5JVF9MSVNUX0hFQUQoJmNvbW1vbi0+ZG1hX3F1ZXVlKTsKIAogCS8qIEFsbG9jYXRlIGJ1ZmZlcnMgKi8KLQlyZXQgPSB2aWRlb2J1Zl9yZXFidWZzKCZjb21tb24tPmJ1ZmZlcl9xdWV1ZSwgcmVxYnVmKTsKLQotcmVxYnVmX2V4aXQ6Ci0JbXV0ZXhfdW5sb2NrKCZjb21tb24tPmxvY2spOwotCXJldHVybiByZXQ7CisJcmV0dXJuIHZpZGVvYnVmX3JlcWJ1ZnMoJmNvbW1vbi0+YnVmZmVyX3F1ZXVlLCByZXFidWYpOwogfQogCiBzdGF0aWMgaW50IHZwaWZfcXVlcnlidWYoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsCkBAIC05OTAsMjIgKzk4MSwxOSBAQAogCX0KIAogCS8qIENhbGwgZW5jb2RlciBzdWJkZXZpY2UgZnVuY3Rpb24gdG8gc2V0IHRoZSBzdGFuZGFyZCAqLwotCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmNvbW1vbi0+bG9jaykpCi0JCXJldHVybiAtRVJFU1RBUlRTWVM7Ci0KIAljaC0+dmlkZW8uc3RkaWQgPSAqc3RkX2lkOworCWNoLT52aWRlby5kdl9wcmVzZXQgPSBWNEwyX0RWX0lOVkFMSUQ7CisJbWVtc2V0KCZjaC0+dmlkZW8uYnRfdGltaW5ncywgMCwgc2l6ZW9mKGNoLT52aWRlby5idF90aW1pbmdzKSk7CisKIAkvKiBHZXQgdGhlIGluZm9ybWF0aW9uIGFib3V0IHRoZSBzdGFuZGFyZCAqLwotCWlmICh2cGlmX2dldF9zdGRfaW5mbyhjaCkpIHsKLQkJdnBpZl9lcnIoIkVycm9yIGdldHRpbmcgdGhlIHN0YW5kYXJkIGluZm9cbiIpOworCWlmICh2cGlmX3VwZGF0ZV9yZXNvbHV0aW9uKGNoKSkKIAkJcmV0dXJuIC1FSU5WQUw7Ci0JfQogCiAJaWYgKChjaC0+dnBpZnBhcmFtcy5zdGRfaW5mby53aWR0aCAqCiAJCWNoLT52cGlmcGFyYW1zLnN0ZF9pbmZvLmhlaWdodCAqIDIpID4KIAkJY29uZmlnX3BhcmFtcy5jaGFubmVsX2J1ZnNpemVbY2gtPmNoYW5uZWxfaWRdKSB7CiAJCXZwaWZfZXJyKCJpbnZhbGlkIHN0ZCBmb3IgdGhpcyBzaXplXG4iKTsKLQkJcmV0ID0gLUVJTlZBTDsKLQkJZ290byBzX3N0ZF9leGl0OworCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKIAljb21tb24tPmZtdC5mbXQucGl4LmJ5dGVzcGVybGluZSA9IGNvbW1vbi0+Zm10LmZtdC5waXgud2lkdGg7CkBAIC0xMDE2LDE2ICsxMDA0LDEzIEBACiAJCQkJCQlzX3N0ZF9vdXRwdXQsICpzdGRfaWQpOwogCWlmIChyZXQgPCAwKSB7CiAJCXZwaWZfZXJyKCJGYWlsZWQgdG8gc2V0IG91dHB1dCBzdGFuZGFyZFxuIik7Ci0JCWdvdG8gc19zdGRfZXhpdDsKKwkJcmV0dXJuIHJldDsKIAl9CiAKIAlyZXQgPSB2NGwyX2RldmljZV9jYWxsX3VudGlsX2VycigmdnBpZl9vYmoudjRsMl9kZXYsIDEsIGNvcmUsCiAJCQkJCQkJc19zdGQsICpzdGRfaWQpOwogCWlmIChyZXQgPCAwKQogCQl2cGlmX2VycigiRmFpbGVkIHRvIHNldCBzdGFuZGFyZCBmb3Igc3ViIGRldmljZXNcbiIpOwotCi1zX3N0ZF9leGl0OgotCW11dGV4X3VubG9jaygmY29tbW9uLT5sb2NrKTsKIAlyZXR1cm4gcmV0OwogfQogCkBAIC0xMDkwLDIxICsxMDc1LDE3IEBACiAJaWYgKHJldCA8IDApCiAJCXJldHVybiByZXQ7CiAKLQkvKiBDYWxsIHZpZGVvYnVmX3N0cmVhbW9uIHRvIHN0YXJ0IHN0cmVhbWluZyAgaW4gdmlkZW9idWYgKi8KKwkvKiBDYWxsIHZpZGVvYnVmX3N0cmVhbW9uIHRvIHN0YXJ0IHN0cmVhbWluZyBpbiB2aWRlb2J1ZiAqLwogCXJldCA9IHZpZGVvYnVmX3N0cmVhbW9uKCZjb21tb24tPmJ1ZmZlcl9xdWV1ZSk7CiAJaWYgKHJldCA8IDApIHsKIAkJdnBpZl9lcnIoInZpZGVvYnVmX3N0cmVhbW9uXG4iKTsKIAkJcmV0dXJuIHJldDsKIAl9CiAKLQlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZjb21tb24tPmxvY2spKQotCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwotCiAJLyogSWYgYnVmZmVyIHF1ZXVlIGlzIGVtcHR5LCByZXR1cm4gZXJyb3IgKi8KIAlpZiAobGlzdF9lbXB0eSgmY29tbW9uLT5kbWFfcXVldWUpKSB7CiAJCXZwaWZfZXJyKCJidWZmZXIgcXVldWUgaXMgZW1wdHlcbiIpOwotCQlyZXQgPSAtRUlPOwotCQlnb3RvIHN0cmVhbW9uX2V4aXQ7CisJCXJldHVybiAtRUlPOwogCX0KIAogCS8qIEdldCB0aGUgbmV4dCBmcmFtZSBmcm9tIHRoZSBidWZmZXIgcXVldWUgKi8KQEAgLTExMzAsOCArMTExMSw3IEBACiAJCQl8fCAoIWNoLT52cGlmcGFyYW1zLnN0ZF9pbmZvLmZybV9mbXQKIAkJCSYmIChjb21tb24tPmZtdC5mbXQucGl4LmZpZWxkID09IFY0TDJfRklFTERfTk9ORSkpKSB7CiAJCQl2cGlmX2VycigiY29uZmxpY3QgaW4gZmllbGQgZm9ybWF0IGFuZCBzdGQgZm9ybWF0XG4iKTsKLQkJCXJldCA9IC1FSU5WQUw7Ci0JCQlnb3RvIHN0cmVhbW9uX2V4aXQ7CisJCQlyZXR1cm4gLUVJTlZBTDsKIAkJfQogCiAJCS8qIGNsb2NrIHNldHRpbmdzICovCkBAIC0xMTQwLDEzICsxMTIwLDEzIEBACiAJCQkJCQljaC0+dnBpZnBhcmFtcy5zdGRfaW5mby5oZF9zZCk7CiAJCWlmIChyZXQgPCAwKSB7CiAJCQl2cGlmX2VycigiY2FuJ3Qgc2V0IGNsb2NrXG4iKTsKLQkJCWdvdG8gc3RyZWFtb25fZXhpdDsKKwkJCXJldHVybiByZXQ7CiAJCX0KIAogCQkvKiBzZXQgdGhlIHBhcmFtZXRlcnMgYW5kIGFkZHJlc3NlcyAqLwogCQlyZXQgPSB2cGlmX3NldF92aWRlb19wYXJhbXModnBpZiwgY2gtPmNoYW5uZWxfaWQgKyAyKTsKIAkJaWYgKHJldCA8IDApCi0JCQlnb3RvIHN0cmVhbW9uX2V4aXQ7CisJCQlyZXR1cm4gcmV0OwogCiAJCWNvbW1vbi0+c3RhcnRlZCA9IHJldDsKIAkJdnBpZl9jb25maWdfYWRkcihjaCwgcmV0KTsKQEAgLTExNzEsOSArMTE1MSw2IEBACiAJCX0KIAkJY2hhbm5lbF9maXJzdF9pbnRbVlBJRl9WSURFT19JTkRFWF1bY2gtPmNoYW5uZWxfaWRdID0gMTsKIAl9Ci0KLXN0cmVhbW9uX2V4aXQ6Ci0JbXV0ZXhfdW5sb2NrKCZjb21tb24tPmxvY2spOwogCXJldHVybiByZXQ7CiB9CiAKQEAgLTExOTksOSArMTE3Niw2IEBACiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAotCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmNvbW1vbi0+bG9jaykpCi0JCXJldHVybiAtRVJFU1RBUlRTWVM7Ci0KIAlpZiAoYnVmdHlwZSA9PSBWNEwyX0JVRl9UWVBFX1ZJREVPX09VVFBVVCkgewogCQkvKiBkaXNhYmxlIGNoYW5uZWwgKi8KIAkJaWYgKFZQSUZfQ0hBTk5FTDJfVklERU8gPT0gY2gtPmNoYW5uZWxfaWQpIHsKQEAgLTEyMTYsOCArMTE5MCw2IEBACiAJfQogCiAJY29tbW9uLT5zdGFydGVkID0gMDsKLQltdXRleF91bmxvY2soJmNvbW1vbi0+bG9jayk7Ci0KIAlyZXR1cm4gdmlkZW9idWZfc3RyZWFtb2ZmKCZjb21tb24tPmJ1ZmZlcl9xdWV1ZSk7CiB9CiAKQEAgLTEyNjQsMTMgKzEyMzYsOSBAQAogCXN0cnVjdCBjb21tb25fb2JqICpjb21tb24gPSAmY2gtPmNvbW1vbltWUElGX1ZJREVPX0lOREVYXTsKIAlpbnQgcmV0ID0gMDsKIAotCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmNvbW1vbi0+bG9jaykpCi0JCXJldHVybiAtRVJFU1RBUlRTWVM7Ci0KIAlpZiAoY29tbW9uLT5zdGFydGVkKSB7CiAJCXZwaWZfZXJyKCJTdHJlYW1pbmcgaW4gcHJvZ3Jlc3NcbiIpOwotCQlyZXQgPSAtRUJVU1k7Ci0JCWdvdG8gc19vdXRwdXRfZXhpdDsKKwkJcmV0dXJuIC1FQlVTWTsKIAl9CiAKIAlyZXQgPSB2NGwyX2RldmljZV9jYWxsX3VudGlsX2VycigmdnBpZl9vYmoudjRsMl9kZXYsIDEsIHZpZGVvLApAQCAtMTI4MCw5ICsxMjQ4LDYgQEAKIAkJdnBpZl9lcnIoIkZhaWxlZCB0byBzZXQgb3V0cHV0IHN0YW5kYXJkXG4iKTsKIAogCXZpZF9jaC0+b3V0cHV0X2lkID0gaTsKLQotc19vdXRwdXRfZXhpdDoKLQltdXRleF91bmxvY2soJmNvbW1vbi0+bG9jayk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtMTMxNSw2ICsxMjgwLDI4NyBAQAogCXJldHVybiB2NGwyX3ByaW9fY2hhbmdlKCZjaC0+cHJpbywgJmZoLT5wcmlvLCBwKTsKIH0KIAorLyoqCisgKiB2cGlmX2VudW1fZHZfcHJlc2V0cygpIC0gRU5VTV9EVl9QUkVTRVRTIGhhbmRsZXIKKyAqIEBmaWxlOiBmaWxlIHB0cgorICogQHByaXY6IGZpbGUgaGFuZGxlCisgKiBAcHJlc2V0OiBpbnB1dCBwcmVzZXQKKyAqLworc3RhdGljIGludCB2cGlmX2VudW1fZHZfcHJlc2V0cyhzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwKKwkJc3RydWN0IHY0bDJfZHZfZW51bV9wcmVzZXQgKnByZXNldCkKK3sKKwlzdHJ1Y3QgdnBpZl9maCAqZmggPSBwcml2OworCXN0cnVjdCBjaGFubmVsX29iaiAqY2ggPSBmaC0+Y2hhbm5lbDsKKwlzdHJ1Y3QgdmlkZW9fb2JqICp2aWRfY2ggPSAmY2gtPnZpZGVvOworCisJcmV0dXJuIHY0bDJfc3ViZGV2X2NhbGwodnBpZl9vYmouc2RbdmlkX2NoLT5vdXRwdXRfaWRdLAorCQkJdmlkZW8sIGVudW1fZHZfcHJlc2V0cywgcHJlc2V0KTsKK30KKworLyoqCisgKiB2cGlmX3NfZHZfcHJlc2V0cygpIC0gU19EVl9QUkVTRVRTIGhhbmRsZXIKKyAqIEBmaWxlOiBmaWxlIHB0cgorICogQHByaXY6IGZpbGUgaGFuZGxlCisgKiBAcHJlc2V0OiBpbnB1dCBwcmVzZXQKKyAqLworc3RhdGljIGludCB2cGlmX3NfZHZfcHJlc2V0KHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LAorCQlzdHJ1Y3QgdjRsMl9kdl9wcmVzZXQgKnByZXNldCkKK3sKKwlzdHJ1Y3QgdnBpZl9maCAqZmggPSBwcml2OworCXN0cnVjdCBjaGFubmVsX29iaiAqY2ggPSBmaC0+Y2hhbm5lbDsKKwlzdHJ1Y3QgY29tbW9uX29iaiAqY29tbW9uID0gJmNoLT5jb21tb25bVlBJRl9WSURFT19JTkRFWF07CisJc3RydWN0IHZpZGVvX29iaiAqdmlkX2NoID0gJmNoLT52aWRlbzsKKwlpbnQgcmV0ID0gMDsKKworCWlmIChjb21tb24tPnN0YXJ0ZWQpIHsKKwkJdnBpZl9kYmcoMSwgZGVidWcsICJzdHJlYW1pbmcgaW4gcHJvZ3Jlc3NcbiIpOworCQlyZXR1cm4gLUVCVVNZOworCX0KKworCXJldCA9IHY0bDJfcHJpb19jaGVjaygmY2gtPnByaW8sIGZoLT5wcmlvKTsKKwlpZiAocmV0ICE9IDApCisJCXJldHVybiByZXQ7CisKKwlmaC0+aW5pdGlhbGl6ZWQgPSAxOworCisJLyogQ2FsbCBlbmNvZGVyIHN1YmRldmljZSBmdW5jdGlvbiB0byBzZXQgdGhlIHN0YW5kYXJkICovCisJaWYgKG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmY29tbW9uLT5sb2NrKSkKKwkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKKworCWNoLT52aWRlby5kdl9wcmVzZXQgPSBwcmVzZXQtPnByZXNldDsKKwljaC0+dmlkZW8uc3RkaWQgPSBWNEwyX1NURF9VTktOT1dOOworCW1lbXNldCgmY2gtPnZpZGVvLmJ0X3RpbWluZ3MsIDAsIHNpemVvZihjaC0+dmlkZW8uYnRfdGltaW5ncykpOworCisJLyogR2V0IHRoZSBpbmZvcm1hdGlvbiBhYm91dCB0aGUgc3RhbmRhcmQgKi8KKwlpZiAodnBpZl91cGRhdGVfcmVzb2x1dGlvbihjaCkpIHsKKwkJcmV0ID0gLUVJTlZBTDsKKwl9IGVsc2UgeworCQkvKiBDb25maWd1cmUgdGhlIGRlZmF1bHQgZm9ybWF0IGluZm9ybWF0aW9uICovCisJCXZwaWZfY29uZmlnX2Zvcm1hdChjaCk7CisKKwkJcmV0ID0gdjRsMl9zdWJkZXZfY2FsbCh2cGlmX29iai5zZFt2aWRfY2gtPm91dHB1dF9pZF0sCisJCQkJdmlkZW8sIHNfZHZfcHJlc2V0LCBwcmVzZXQpOworCX0KKworCW11dGV4X3VubG9jaygmY29tbW9uLT5sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CisvKioKKyAqIHZwaWZfZ19kdl9wcmVzZXRzKCkgLSBHX0RWX1BSRVNFVFMgaGFuZGxlcgorICogQGZpbGU6IGZpbGUgcHRyCisgKiBAcHJpdjogZmlsZSBoYW5kbGUKKyAqIEBwcmVzZXQ6IGlucHV0IHByZXNldAorICovCitzdGF0aWMgaW50IHZwaWZfZ19kdl9wcmVzZXQoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsCisJCXN0cnVjdCB2NGwyX2R2X3ByZXNldCAqcHJlc2V0KQoreworCXN0cnVjdCB2cGlmX2ZoICpmaCA9IHByaXY7CisJc3RydWN0IGNoYW5uZWxfb2JqICpjaCA9IGZoLT5jaGFubmVsOworCisJcHJlc2V0LT5wcmVzZXQgPSBjaC0+dmlkZW8uZHZfcHJlc2V0OworCisJcmV0dXJuIDA7Cit9CisvKioKKyAqIHZwaWZfc19kdl90aW1pbmdzKCkgLSBTX0RWX1RJTUlOR1MgaGFuZGxlcgorICogQGZpbGU6IGZpbGUgcHRyCisgKiBAcHJpdjogZmlsZSBoYW5kbGUKKyAqIEB0aW1pbmdzOiBkaWdpdGFsIHZpZGVvIHRpbWluZ3MKKyAqLworc3RhdGljIGludCB2cGlmX3NfZHZfdGltaW5ncyhzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwKKwkJc3RydWN0IHY0bDJfZHZfdGltaW5ncyAqdGltaW5ncykKK3sKKwlzdHJ1Y3QgdnBpZl9maCAqZmggPSBwcml2OworCXN0cnVjdCBjaGFubmVsX29iaiAqY2ggPSBmaC0+Y2hhbm5lbDsKKwlzdHJ1Y3QgdnBpZl9wYXJhbXMgKnZwaWZwYXJhbXMgPSAmY2gtPnZwaWZwYXJhbXM7CisJc3RydWN0IHZwaWZfY2hhbm5lbF9jb25maWdfcGFyYW1zICpzdGRfaW5mbyA9ICZ2cGlmcGFyYW1zLT5zdGRfaW5mbzsKKwlzdHJ1Y3QgdmlkZW9fb2JqICp2aWRfY2ggPSAmY2gtPnZpZGVvOworCXN0cnVjdCB2NGwyX2J0X3RpbWluZ3MgKmJ0ID0gJnZpZF9jaC0+YnRfdGltaW5nczsKKwlpbnQgcmV0OworCisJaWYgKHRpbWluZ3MtPnR5cGUgIT0gVjRMMl9EVl9CVF82NTZfMTEyMCkgeworCQl2cGlmX2RiZygyLCBkZWJ1ZywgIlRpbWluZyB0eXBlIG5vdCBkZWZpbmVkXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJLyogQ29uZmlndXJlIHN1YmRldmljZSB0aW1pbmdzLCBpZiBhbnkgKi8KKwlyZXQgPSB2NGwyX3N1YmRldl9jYWxsKHZwaWZfb2JqLnNkW3ZpZF9jaC0+b3V0cHV0X2lkXSwKKwkJCXZpZGVvLCBzX2R2X3RpbWluZ3MsIHRpbWluZ3MpOworCWlmIChyZXQgPT0gLUVOT0lPQ1RMQ01EKSB7CisJCXZwaWZfZGJnKDIsIGRlYnVnLCAiQ3VzdG9tIERWIHRpbWluZ3Mgbm90IHN1cHBvcnRlZCBieSAiCisJCQkJInN1YmRldmljZVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAocmV0IDwgMCkgeworCQl2cGlmX2RiZygyLCBkZWJ1ZywgIkVycm9yIHNldHRpbmcgY3VzdG9tIERWIHRpbWluZ3NcbiIpOworCQlyZXR1cm4gcmV0OworCX0KKworCWlmICghKHRpbWluZ3MtPmJ0LndpZHRoICYmIHRpbWluZ3MtPmJ0LmhlaWdodCAmJgorCQkJCSh0aW1pbmdzLT5idC5oYmFja3BvcmNoIHx8CisJCQkJIHRpbWluZ3MtPmJ0Lmhmcm9udHBvcmNoIHx8CisJCQkJIHRpbWluZ3MtPmJ0LmhzeW5jKSAmJgorCQkJCXRpbWluZ3MtPmJ0LnZmcm9udHBvcmNoICYmCisJCQkJKHRpbWluZ3MtPmJ0LnZiYWNrcG9yY2ggfHwKKwkJCQkgdGltaW5ncy0+YnQudnN5bmMpKSkgeworCQl2cGlmX2RiZygyLCBkZWJ1ZywgIlRpbWluZ3MgZm9yIHdpZHRoLCBoZWlnaHQsICIKKwkJCQkiaG9yaXpvbnRhbCBiYWNrIHBvcmNoLCBob3Jpem9udGFsIHN5bmMsICIKKwkJCQkiaG9yaXpvbnRhbCBmcm9udCBwb3JjaCwgdmVydGljYWwgYmFjayBwb3JjaCwgIgorCQkJCSJ2ZXJ0aWNhbCBzeW5jIGFuZCB2ZXJ0aWNhbCBiYWNrIHBvcmNoICIKKwkJCQkibXVzdCBiZSBkZWZpbmVkXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJKmJ0ID0gdGltaW5ncy0+YnQ7CisKKwkvKiBDb25maWd1cmUgdmlkZW8gcG9ydCB0aW1pbmdzICovCisKKwlzdGRfaW5mby0+ZWF2MnNhdiA9IGJ0LT5oYmFja3BvcmNoICsgYnQtPmhmcm9udHBvcmNoICsKKwkJYnQtPmhzeW5jIC0gODsKKwlzdGRfaW5mby0+c2F2MmVhdiA9IGJ0LT53aWR0aDsKKworCXN0ZF9pbmZvLT5sMSA9IDE7CisJc3RkX2luZm8tPmwzID0gYnQtPnZzeW5jICsgYnQtPnZiYWNrcG9yY2ggKyAxOworCisJaWYgKGJ0LT5pbnRlcmxhY2VkKSB7CisJCWlmIChidC0+aWxfdmJhY2twb3JjaCB8fCBidC0+aWxfdmZyb250cG9yY2ggfHwgYnQtPmlsX3ZzeW5jKSB7CisJCQlzdGRfaW5mby0+dnNpemUgPSBidC0+aGVpZ2h0ICogMiArCisJCQkJYnQtPnZmcm9udHBvcmNoICsgYnQtPnZzeW5jICsgYnQtPnZiYWNrcG9yY2ggKworCQkJCWJ0LT5pbF92ZnJvbnRwb3JjaCArIGJ0LT5pbF92c3luYyArCisJCQkJYnQtPmlsX3ZiYWNrcG9yY2g7CisJCQlzdGRfaW5mby0+bDUgPSBzdGRfaW5mby0+dnNpemUvMiAtCisJCQkJKGJ0LT52ZnJvbnRwb3JjaCAtIDEpOworCQkJc3RkX2luZm8tPmw3ID0gc3RkX2luZm8tPnZzaXplLzIgKyAxOworCQkJc3RkX2luZm8tPmw5ID0gc3RkX2luZm8tPmw3ICsgYnQtPmlsX3ZzeW5jICsKKwkJCQlidC0+aWxfdmJhY2twb3JjaCArIDE7CisJCQlzdGRfaW5mby0+bDExID0gc3RkX2luZm8tPnZzaXplIC0KKwkJCQkoYnQtPmlsX3Zmcm9udHBvcmNoIC0gMSk7CisJCX0gZWxzZSB7CisJCQl2cGlmX2RiZygyLCBkZWJ1ZywgIlJlcXVpcmVkIHRpbWluZyB2YWx1ZXMgZm9yICIKKwkJCQkJImludGVybGFjZWQgQlQgZm9ybWF0IG1pc3NpbmdcbiIpOworCQkJcmV0dXJuIC1FSU5WQUw7CisJCX0KKwl9IGVsc2UgeworCQlzdGRfaW5mby0+dnNpemUgPSBidC0+aGVpZ2h0ICsgYnQtPnZmcm9udHBvcmNoICsKKwkJCWJ0LT52c3luYyArIGJ0LT52YmFja3BvcmNoOworCQlzdGRfaW5mby0+bDUgPSBzdGRfaW5mby0+dnNpemUgLSAoYnQtPnZmcm9udHBvcmNoIC0gMSk7CisJfQorCXN0cm5jcHkoc3RkX2luZm8tPm5hbWUsICJDdXN0b20gdGltaW5ncyBCVDY1Ni8xMTIwIiwKKwkJCVZQSUZfTUFYX05BTUUpOworCXN0ZF9pbmZvLT53aWR0aCA9IGJ0LT53aWR0aDsKKwlzdGRfaW5mby0+aGVpZ2h0ID0gYnQtPmhlaWdodDsKKwlzdGRfaW5mby0+ZnJtX2ZtdCA9IGJ0LT5pbnRlcmxhY2VkID8gMCA6IDE7CisJc3RkX2luZm8tPnljbXV4X21vZGUgPSAwOworCXN0ZF9pbmZvLT5jYXB0dXJlX2Zvcm1hdCA9IDA7CisJc3RkX2luZm8tPnZiaV9zdXBwb3J0ZWQgPSAwOworCXN0ZF9pbmZvLT5oZF9zZCA9IDE7CisJc3RkX2luZm8tPnN0ZGlkID0gMDsKKwlzdGRfaW5mby0+ZHZfcHJlc2V0ID0gVjRMMl9EVl9JTlZBTElEOworCisJdmlkX2NoLT5zdGRpZCA9IDA7CisJdmlkX2NoLT5kdl9wcmVzZXQgPSBWNEwyX0RWX0lOVkFMSUQ7CisKKwlyZXR1cm4gMDsKK30KKworLyoqCisgKiB2cGlmX2dfZHZfdGltaW5ncygpIC0gR19EVl9USU1JTkdTIGhhbmRsZXIKKyAqIEBmaWxlOiBmaWxlIHB0cgorICogQHByaXY6IGZpbGUgaGFuZGxlCisgKiBAdGltaW5nczogZGlnaXRhbCB2aWRlbyB0aW1pbmdzCisgKi8KK3N0YXRpYyBpbnQgdnBpZl9nX2R2X3RpbWluZ3Moc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsCisJCXN0cnVjdCB2NGwyX2R2X3RpbWluZ3MgKnRpbWluZ3MpCit7CisJc3RydWN0IHZwaWZfZmggKmZoID0gcHJpdjsKKwlzdHJ1Y3QgY2hhbm5lbF9vYmogKmNoID0gZmgtPmNoYW5uZWw7CisJc3RydWN0IHZpZGVvX29iaiAqdmlkX2NoID0gJmNoLT52aWRlbzsKKwlzdHJ1Y3QgdjRsMl9idF90aW1pbmdzICpidCA9ICZ2aWRfY2gtPmJ0X3RpbWluZ3M7CisKKwl0aW1pbmdzLT5idCA9ICpidDsKKworCXJldHVybiAwOworfQorCisvKgorICogdnBpZl9nX2NoaXBfaWRlbnQoKSAtIElkZW50aWZ5IHRoZSBjaGlwCisgKiBAZmlsZTogZmlsZSBwdHIKKyAqIEBwcml2OiBmaWxlIGhhbmRsZQorICogQGNoaXA6IGNoaXAgaWRlbnRpdHkKKyAqCisgKiBSZXR1cm5zIHplcm8gb3IgLUVJTlZBTCBpZiByZWFkIG9wZXJhdGlvbnMgZmFpbHMuCisgKi8KK3N0YXRpYyBpbnQgdnBpZl9nX2NoaXBfaWRlbnQoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsCisJCXN0cnVjdCB2NGwyX2RiZ19jaGlwX2lkZW50ICpjaGlwKQoreworCWNoaXAtPmlkZW50ID0gVjRMMl9JREVOVF9OT05FOworCWNoaXAtPnJldmlzaW9uID0gMDsKKwlpZiAoY2hpcC0+bWF0Y2gudHlwZSAhPSBWNEwyX0NISVBfTUFUQ0hfSTJDX0RSSVZFUiAmJgorCQkJY2hpcC0+bWF0Y2gudHlwZSAhPSBWNEwyX0NISVBfTUFUQ0hfSTJDX0FERFIpIHsKKwkJdnBpZl9kYmcoMiwgZGVidWcsICJtYXRjaF90eXBlIGlzIGludmFsaWQuXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJcmV0dXJuIHY0bDJfZGV2aWNlX2NhbGxfdW50aWxfZXJyKCZ2cGlmX29iai52NGwyX2RldiwgMCwgY29yZSwKKwkJCWdfY2hpcF9pZGVudCwgY2hpcCk7Cit9CisKKyNpZmRlZiBDT05GSUdfVklERU9fQURWX0RFQlVHCisvKgorICogdnBpZl9kYmdfZ19yZWdpc3RlcigpIC0gUmVhZCByZWdpc3RlcgorICogQGZpbGU6IGZpbGUgcHRyCisgKiBAcHJpdjogZmlsZSBoYW5kbGUKKyAqIEByZWc6IHJlZ2lzdGVyIHRvIGJlIHJlYWQKKyAqCisgKiBEZWJ1Z2dpbmcgb25seQorICogUmV0dXJucyB6ZXJvIG9yIC1FSU5WQUwgaWYgcmVhZCBvcGVyYXRpb25zIGZhaWxzLgorICovCitzdGF0aWMgaW50IHZwaWZfZGJnX2dfcmVnaXN0ZXIoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsCisJCXN0cnVjdCB2NGwyX2RiZ19yZWdpc3RlciAqcmVnKXsKKwlzdHJ1Y3QgdnBpZl9maCAqZmggPSBwcml2OworCXN0cnVjdCBjaGFubmVsX29iaiAqY2ggPSBmaC0+Y2hhbm5lbDsKKwlzdHJ1Y3QgdmlkZW9fb2JqICp2aWRfY2ggPSAmY2gtPnZpZGVvOworCisJcmV0dXJuIHY0bDJfc3ViZGV2X2NhbGwodnBpZl9vYmouc2RbdmlkX2NoLT5vdXRwdXRfaWRdLCBjb3JlLAorCQkJZ19yZWdpc3RlciwgcmVnKTsKK30KKworLyoKKyAqIHZwaWZfZGJnX3NfcmVnaXN0ZXIoKSAtIFdyaXRlIHRvIHJlZ2lzdGVyCisgKiBAZmlsZTogZmlsZSBwdHIKKyAqIEBwcml2OiBmaWxlIGhhbmRsZQorICogQHJlZzogcmVnaXN0ZXIgdG8gYmUgbW9kaWZpZWQKKyAqCisgKiBEZWJ1Z2dpbmcgb25seQorICogUmV0dXJucyB6ZXJvIG9yIC1FSU5WQUwgaWYgd3JpdGUgb3BlcmF0aW9ucyBmYWlscy4KKyAqLworc3RhdGljIGludCB2cGlmX2RiZ19zX3JlZ2lzdGVyKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LAorCQlzdHJ1Y3QgdjRsMl9kYmdfcmVnaXN0ZXIgKnJlZyl7CisJc3RydWN0IHZwaWZfZmggKmZoID0gcHJpdjsKKwlzdHJ1Y3QgY2hhbm5lbF9vYmogKmNoID0gZmgtPmNoYW5uZWw7CisJc3RydWN0IHZpZGVvX29iaiAqdmlkX2NoID0gJmNoLT52aWRlbzsKKworCXJldHVybiB2NGwyX3N1YmRldl9jYWxsKHZwaWZfb2JqLnNkW3ZpZF9jaC0+b3V0cHV0X2lkXSwgY29yZSwKKwkJCXNfcmVnaXN0ZXIsIHJlZyk7Cit9CisjZW5kaWYKKworLyoKKyAqIHZwaWZfbG9nX3N0YXR1cygpIC0gU3RhdHVzIGluZm9ybWF0aW9uCisgKiBAZmlsZTogZmlsZSBwdHIKKyAqIEBwcml2OiBmaWxlIGhhbmRsZQorICoKKyAqIFJldHVybnMgemVyby4KKyAqLworc3RhdGljIGludCB2cGlmX2xvZ19zdGF0dXMoc3RydWN0IGZpbGUgKmZpbGVwLCB2b2lkICpwcml2KQoreworCS8qIHN0YXR1cyBmb3Igc3ViIGRldmljZXMgKi8KKwl2NGwyX2RldmljZV9jYWxsX2FsbCgmdnBpZl9vYmoudjRsMl9kZXYsIDAsIGNvcmUsIGxvZ19zdGF0dXMpOworCisJcmV0dXJuIDA7Cit9CisKIC8qIHZwaWYgZGlzcGxheSBpb2N0bCBvcGVyYXRpb25zICovCiBzdGF0aWMgY29uc3Qgc3RydWN0IHY0bDJfaW9jdGxfb3BzIHZwaWZfaW9jdGxfb3BzID0gewogCS52aWRpb2NfcXVlcnljYXAgICAgICAgIAk9IHZwaWZfcXVlcnljYXAsCkBAIC0xMzM2LDEzICsxNTgyLDI0IEBACiAJLnZpZGlvY19zX291dHB1dAkJPSB2cGlmX3Nfb3V0cHV0LAogCS52aWRpb2NfZ19vdXRwdXQJCT0gdnBpZl9nX291dHB1dCwKIAkudmlkaW9jX2Nyb3BjYXAgICAgICAgICAJPSB2cGlmX2Nyb3BjYXAsCisJLnZpZGlvY19lbnVtX2R2X3ByZXNldHMgICAgICAgICA9IHZwaWZfZW51bV9kdl9wcmVzZXRzLAorCS52aWRpb2Nfc19kdl9wcmVzZXQgICAgICAgICAgICAgPSB2cGlmX3NfZHZfcHJlc2V0LAorCS52aWRpb2NfZ19kdl9wcmVzZXQgICAgICAgICAgICAgPSB2cGlmX2dfZHZfcHJlc2V0LAorCS52aWRpb2Nfc19kdl90aW1pbmdzICAgICAgICAgICAgPSB2cGlmX3NfZHZfdGltaW5ncywKKwkudmlkaW9jX2dfZHZfdGltaW5ncyAgICAgICAgICAgID0gdnBpZl9nX2R2X3RpbWluZ3MsCisJLnZpZGlvY19nX2NoaXBfaWRlbnQJCT0gdnBpZl9nX2NoaXBfaWRlbnQsCisjaWZkZWYgQ09ORklHX1ZJREVPX0FEVl9ERUJVRworCS52aWRpb2NfZ19yZWdpc3RlcgkJPSB2cGlmX2RiZ19nX3JlZ2lzdGVyLAorCS52aWRpb2Nfc19yZWdpc3RlcgkJPSB2cGlmX2RiZ19zX3JlZ2lzdGVyLAorI2VuZGlmCisJLnZpZGlvY19sb2dfc3RhdHVzCQk9IHZwaWZfbG9nX3N0YXR1cywKIH07CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdjRsMl9maWxlX29wZXJhdGlvbnMgdnBpZl9mb3BzID0gewogCS5vd25lcgkJPSBUSElTX01PRFVMRSwKIAkub3BlbgkJPSB2cGlmX29wZW4sCiAJLnJlbGVhc2UJPSB2cGlmX3JlbGVhc2UsCi0JLmlvY3RsCQk9IHZpZGVvX2lvY3RsMiwKKwkudW5sb2NrZWRfaW9jdGwJPSB2aWRlb19pb2N0bDIsCiAJLm1tYXAJCT0gdnBpZl9tbWFwLAogCS5wb2xsCQk9IHZwaWZfcG9sbAogfTsKQEAgLTE1MjYsNiArMTc4Myw3IEBACiAJCXY0bDJfcHJpb19pbml0KCZjaC0+cHJpbyk7CiAJCWNoLT5jb21tb25bVlBJRl9WSURFT19JTkRFWF0uZm10LnR5cGUgPQogCQkJCQkJVjRMMl9CVUZfVFlQRV9WSURFT19PVVRQVVQ7CisJCWNoLT52aWRlb19kZXYtPmxvY2sgPSAmY29tbW9uLT5sb2NrOwogCiAJCS8qIHJlZ2lzdGVyIHZpZGVvIGRldmljZSAqLwogCQl2cGlmX2RiZygxLCBkZWJ1ZywgImNoYW5uZWw9JXgsY2hhbm5lbC0+dmlkZW9fZGV2PSV4XG4iLApAQCAtMTU2NSw2ICsxODIzLDggQEAKIAkJCXZwaWZfb2JqLnNkW2ldLT5ncnBfaWQgPSAxIDw8IGk7CiAJfQogCisJdjRsMl9pbmZvKCZ2cGlmX29iai52NGwyX2RldiwKKwkJCSJETTY0NnggVlBJRiBkaXNwbGF5IGRyaXZlciBpbml0aWFsaXplZFxuIik7CiAJcmV0dXJuIDA7CiAKIHByb2JlX3N1YmRldl9vdXQ6CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2RhdmluY2kvdnBpZl9kaXNwbGF5LmggYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2RhdmluY2kvdnBpZl9kaXNwbGF5LmgKaW5kZXggYTJhN2NkMS4uYjUzYWFhOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9kYXZpbmNpL3ZwaWZfZGlzcGxheS5oCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZGF2aW5jaS92cGlmX2Rpc3BsYXkuaApAQCAtNjcsNiArNjcsOCBAQAogCQkJCQkgKiBtb3N0IHJlY2VudCBkaXNwbGF5ZWQgZnJhbWUgb25seSAqLwogCXY0bDJfc3RkX2lkIHN0ZGlkOwkJLyogQ3VycmVudGx5IHNlbGVjdGVkIG9yIGRlZmF1bHQKIAkJCQkJICogc3RhbmRhcmQgKi8KKwl1MzIgZHZfcHJlc2V0OworCXN0cnVjdCB2NGwyX2J0X3RpbWluZ3MgYnRfdGltaW5nczsKIAl1MzIgb3V0cHV0X2lkOwkJCS8qIEN1cnJlbnQgb3V0cHV0IGlkICovCiB9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2VtMjh4eC9lbTI4eHgtY2FyZHMuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZW0yOHh4L2VtMjh4eC1jYXJkcy5jCmluZGV4IDA5OWQ1ZGYuLjg3Zjc3YTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZW0yOHh4L2VtMjh4eC1jYXJkcy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZW0yOHh4L2VtMjh4eC1jYXJkcy5jCkBAIC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSA8bWVkaWEvc2FhNzExNS5oPgogI2luY2x1ZGUgPG1lZGlhL3R2cDUxNTAuaD4KICNpbmNsdWRlIDxtZWRpYS90dmF1ZGlvLmg+CisjaW5jbHVkZSA8bWVkaWEvbXQ5djAxMS5oPgogI2luY2x1ZGUgPG1lZGlhL2kyYy1hZGRyLmg+CiAjaW5jbHVkZSA8bWVkaWEvdHZlZXByb20uaD4KICNpbmNsdWRlIDxtZWRpYS92NGwyLWNvbW1vbi5oPgpAQCAtMTkxNywxMSArMTkxOCw2IEBACiAJSTJDX0NMSUVOVF9FTkQKIH07CiAKLXN0YXRpYyB1bnNpZ25lZCBzaG9ydCBtdDl2MDExX2FkZHJzW10gPSB7Ci0JMHhiYSA+PiAxLAotCUkyQ19DTElFTlRfRU5ECi19OwotCiBzdGF0aWMgdW5zaWduZWQgc2hvcnQgbXNwMzQwMF9hZGRyc1tdID0gewogCTB4ODAgPj4gMSwKIAkweDg4ID4+IDEsCkBAIC0yNDM3LDYgKzI0MzMsNyBAQAogCQlkZXYtPmluaXRfZGF0YS5pcl9jb2RlcyA9IFJDX01BUF9SQzVfSEFVUFBBVUdFX05FVzsKIAkJZGV2LT5pbml0X2RhdGEuZ2V0X2tleSA9IGVtMjh4eF9nZXRfa2V5X2VtX2hhdXA7CiAJCWRldi0+aW5pdF9kYXRhLm5hbWUgPSAiaTJjIElSIChFTTI4NDAgSGF1cHBhdWdlKSI7CisJCWJyZWFrOwogCWNhc2UgRU0yODIwX0JPQVJEX0xFQURURUtfV0lORkFTVF9VU0JJSV9ERUxVWEU6CiAJCWRldi0+aW5pdF9kYXRhLmlyX2NvZGVzID0gUkNfTUFQX1dJTkZBU1RfVVNCSUlfREVMVVhFOwogCQlkZXYtPmluaXRfZGF0YS5nZXRfa2V5ID0gZW0yOHh4X2dldF9rZXlfd2luZmFzdF91c2JpaV9kZWx1eGU7CkBAIC0yNjIzLDExICsyNjIwLDE3IEBACiAJCQkidHZwNTE1MCIsIDAsIHR2cDUxNTBfYWRkcnMpOwogCiAJaWYgKGRldi0+ZW0yOHh4X3NlbnNvciA9PSBFTTI4WFhfTVQ5VjAxMSkgeworCQlzdHJ1Y3QgbXQ5djAxMV9wbGF0Zm9ybV9kYXRhIHBkYXRhOworCQlzdHJ1Y3QgaTJjX2JvYXJkX2luZm8gbXQ5djAxMV9pbmZvID0geworCQkJLnR5cGUgPSAibXQ5djAxMSIsCisJCQkuYWRkciA9IDB4YmEgPj4gMSwKKwkJCS5wbGF0Zm9ybV9kYXRhID0gJnBkYXRhLAorCQl9OwogCQlzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkOwogCi0JCXNkID0gdjRsMl9pMmNfbmV3X3N1YmRldigmZGV2LT52NGwyX2RldiwKLQkJCSAmZGV2LT5pMmNfYWRhcCwgIm10OXYwMTEiLCAwLCBtdDl2MDExX2FkZHJzKTsKLQkJdjRsMl9zdWJkZXZfY2FsbChzZCwgY29yZSwgc19jb25maWcsIDAsICZkZXYtPnNlbnNvcl94dGFsKTsKKwkJcGRhdGEueHRhbCA9IGRldi0+c2Vuc29yX3h0YWw7CisJCXNkID0gdjRsMl9pMmNfbmV3X3N1YmRldl9ib2FyZCgmZGV2LT52NGwyX2RldiwgJmRldi0+aTJjX2FkYXAsCisJCQkJJm10OXYwMTFfaW5mbywgTlVMTCk7CiAJfQogCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZXQ2MXgyNTEvZXQ2MXgyNTEuaCBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZXQ2MXgyNTEvZXQ2MXgyNTEuaAppbmRleCBjYzc3ZDE0Li5iZjY2MTg5IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2V0NjF4MjUxL2V0NjF4MjUxLmgKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9ldDYxeDI1MS9ldDYxeDI1MS5oCkBAIC01OSwzMSArNTksNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZXQ2MXgyNTFfaWRfdGFibGVbXSA9IHsKLQl7IFVTQl9ERVZJQ0UoMHgxMDJjLCAweDYxNTEpLCB9LAogCXsgVVNCX0RFVklDRSgweDEwMmMsIDB4NjI1MSksIH0sCi0JeyBVU0JfREVWSUNFKDB4MTAyYywgMHg2MjUzKSwgfSwKLQl7IFVTQl9ERVZJQ0UoMHgxMDJjLCAweDYyNTQpLCB9LAotCXsgVVNCX0RFVklDRSgweDEwMmMsIDB4NjI1NSksIH0sCi0JeyBVU0JfREVWSUNFKDB4MTAyYywgMHg2MjU2KSwgfSwKLQl7IFVTQl9ERVZJQ0UoMHgxMDJjLCAweDYyNTcpLCB9LAotCXsgVVNCX0RFVklDRSgweDEwMmMsIDB4NjI1OCksIH0sCi0JeyBVU0JfREVWSUNFKDB4MTAyYywgMHg2MjU5KSwgfSwKLQl7IFVTQl9ERVZJQ0UoMHgxMDJjLCAweDYyNWEpLCB9LAotCXsgVVNCX0RFVklDRSgweDEwMmMsIDB4NjI1YiksIH0sCi0JeyBVU0JfREVWSUNFKDB4MTAyYywgMHg2MjVjKSwgfSwKLQl7IFVTQl9ERVZJQ0UoMHgxMDJjLCAweDYyNWQpLCB9LAotCXsgVVNCX0RFVklDRSgweDEwMmMsIDB4NjI1ZSksIH0sCi0JeyBVU0JfREVWSUNFKDB4MTAyYywgMHg2MjVmKSwgfSwKLQl7IFVTQl9ERVZJQ0UoMHgxMDJjLCAweDYyNjApLCB9LAotCXsgVVNCX0RFVklDRSgweDEwMmMsIDB4NjI2MSksIH0sCi0JeyBVU0JfREVWSUNFKDB4MTAyYywgMHg2MjYyKSwgfSwKLQl7IFVTQl9ERVZJQ0UoMHgxMDJjLCAweDYyNjMpLCB9LAotCXsgVVNCX0RFVklDRSgweDEwMmMsIDB4NjI2NCksIH0sCi0JeyBVU0JfREVWSUNFKDB4MTAyYywgMHg2MjY1KSwgfSwKLQl7IFVTQl9ERVZJQ0UoMHgxMDJjLCAweDYyNjYpLCB9LAotCXsgVVNCX0RFVklDRSgweDEwMmMsIDB4NjI2NyksIH0sCi0JeyBVU0JfREVWSUNFKDB4MTAyYywgMHg2MjY4KSwgfSwKLQl7IFVTQl9ERVZJQ0UoMHgxMDJjLCAweDYyNjkpLCB9LAogCXsgfQogfTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9iZW5xLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2JlbnEuYwppbmRleCA2MjkwNDM5Li5hMDljNDcwIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2JlbnEuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2JlbnEuYwpAQCAtMjc2LDcgKzI3Niw3IEBACiB9OwogCiAvKiAtLSBtb2R1bGUgaW5pdGlhbGlzYXRpb24gLS0gKi8KLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MDRhNSwgMHgzMDM1KX0sCiAJe30KIH07CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2NvbmV4LmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2NvbmV4LmMKaW5kZXggMWVhY2I2Yy4uOGIzOTg0OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9jb25leC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvY29uZXguYwpAQCAtMTA0MCwxNCArMTA0MCwxNCBAQAogfTsKIAogLyogLS0gbW9kdWxlIGluaXRpYWxpc2F0aW9uIC0tICovCi1zdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gX19kZXZpbml0Y29uc3QgPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CiAJe1VTQl9ERVZJQ0UoMHgwNTcyLCAweDAwNDEpfSwKIAl7fQogfTsKIE1PRFVMRV9ERVZJQ0VfVEFCTEUodXNiLCBkZXZpY2VfdGFibGUpOwogCiAvKiAtLSBkZXZpY2UgY29ubmVjdCAtLSAqLwotc3RhdGljIGludCBfX2RldmluaXQgc2RfcHJvYmUoc3RydWN0IHVzYl9pbnRlcmZhY2UgKmludGYsCitzdGF0aWMgaW50IHNkX3Byb2JlKHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRmLAogCQkJY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgKmlkKQogewogCXJldHVybiBnc3BjYV9kZXZfcHJvYmUoaW50ZiwgaWQsICZzZF9kZXNjLCBzaXplb2Yoc3RydWN0IHNkKSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvY3BpYTEuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvY3BpYTEuYwppbmRleCBjMWFlMDVmLi40YmYyY2FiIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2NwaWExLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9jcGlhMS5jCkBAIC0yMDg4LDcgKzIwODgsNyBAQAogfTsKIAogLyogLS0gbW9kdWxlIGluaXRpYWxpc2F0aW9uIC0tICovCi1zdGF0aWMgY29uc3QgX19kZXZpbml0ZGF0YSBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKIAl7VVNCX0RFVklDRSgweDA1NTMsIDB4MDAwMil9LAogCXtVU0JfREVWSUNFKDB4MDgxMywgMHgwMDAxKX0sCiAJe30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvZXRvbXMuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvZXRvbXMuYwppbmRleCBhNTk0YjM2Li40YjJjNDgzIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2V0b21zLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9ldG9tcy5jCkBAIC04NjQsNyArODY0LDcgQEAKIH07CiAKIC8qIC0tIG1vZHVsZSBpbml0aWFsaXNhdGlvbiAtLSAqLwotc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdIF9fZGV2aW5pdGNvbnN0ID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MTAyYywgMHg2MTUxKSwgLmRyaXZlcl9pbmZvID0gU0VOU09SX1BBUzEwNn0sCiAjaWYgIWRlZmluZWQgQ09ORklHX1VTQl9FVDYxWDI1MSAmJiAhZGVmaW5lZCBDT05GSUdfVVNCX0VUNjFYMjUxX01PRFVMRQogCXtVU0JfREVWSUNFKDB4MTAyYywgMHg2MjUxKSwgLmRyaXZlcl9pbmZvID0gU0VOU09SX1RBUzUxMzBDWFh9LApAQCAtODc1LDcgKzg3NSw3IEBACiBNT0RVTEVfREVWSUNFX1RBQkxFKHVzYiwgZGV2aWNlX3RhYmxlKTsKIAogLyogLS0gZGV2aWNlIGNvbm5lY3QgLS0gKi8KLXN0YXRpYyBpbnQgX19kZXZpbml0IHNkX3Byb2JlKHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRmLAorc3RhdGljIGludCBzZF9wcm9iZShzdHJ1Y3QgdXNiX2ludGVyZmFjZSAqaW50ZiwKIAkJICAgIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkICppZCkKIHsKIAlyZXR1cm4gZ3NwY2FfZGV2X3Byb2JlKGludGYsIGlkLCAmc2RfZGVzYywgc2l6ZW9mKHN0cnVjdCBzZCksCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2ZpbmVwaXguYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvZmluZXBpeC5jCmluZGV4IGQ3ODIyNjQuLjk4N2I0YjY5ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9maW5lcGl4LmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9maW5lcGl4LmMKQEAgLTIyOSw3ICsyMjksNyBAQAogfQogCiAvKiBUYWJsZSBvZiBzdXBwb3J0ZWQgVVNCIGRldmljZXMgKi8KLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MDRjYiwgMHgwMTA0KX0sCiAJe1VTQl9ERVZJQ0UoMHgwNGNiLCAweDAxMDkpfSwKIAl7VVNCX0RFVklDRSgweDA0Y2IsIDB4MDEwYil9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9nbDg2MC9nbDg2MC5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9nbDg2MC9nbDg2MC5jCmluZGV4IGIwNWJlYzcuLjk5MDgzMDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvZ2w4NjAvZ2w4NjAuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2dsODYwL2dsODYwLmMKQEAgLTQ4OCw3ICs0ODgsNyBAQAogCiAvKj09PT09PT09PT09PT09PT09PT0gVVNCIGRyaXZlciBzdHJ1Y3R1cmUgaW5pdGlhbGlzYXRpb24gPT09PT09PT09PT09PT09PT09Ki8KIAotc3RhdGljIGNvbnN0IF9fZGV2aW5pdGRhdGEgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CiAJe1VTQl9ERVZJQ0UoMHgwNWUzLCAweDA1MDMpfSwKIAl7VVNCX0RFVklDRSgweDA1ZTMsIDB4ZjE5MSl9LAogCXt9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2dzcGNhLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2dzcGNhLmMKaW5kZXggNDQyOTcwMC4uZjIxZjJhMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9nc3BjYS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvZ3NwY2EuYwpAQCAtNTUsNyArNTUsNyBAQAogTU9EVUxFX0RFU0NSSVBUSU9OKCJHU1BDQSBVU0IgQ2FtZXJhIERyaXZlciIpOwogTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwogCi0jZGVmaW5lIERSSVZFUl9WRVJTSU9OX05VTUJFUglLRVJORUxfVkVSU0lPTigyLCAxMSwgMCkKKyNkZWZpbmUgRFJJVkVSX1ZFUlNJT05fTlVNQkVSCUtFUk5FTF9WRVJTSU9OKDIsIDEyLCAwKQogCiAjaWZkZWYgR1NQQ0FfREVCVUcKIGludCBnc3BjYV9kZWJ1ZyA9IERfRVJSIHwgRF9QUk9CRTsKQEAgLTUwOCw4ICs1MDgsOCBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IGZyYW1lX2FsbG9jKHN0cnVjdCBnc3BjYV9kZXYgKmdzcGNhX2RldiwKLQkJCXVuc2lnbmVkIGludCBjb3VudCkKK3N0YXRpYyBpbnQgZnJhbWVfYWxsb2Moc3RydWN0IGdzcGNhX2RldiAqZ3NwY2FfZGV2LCBzdHJ1Y3QgZmlsZSAqZmlsZSwKKwkJCWVudW0gdjRsMl9tZW1vcnkgbWVtb3J5LCB1bnNpZ25lZCBpbnQgY291bnQpCiB7CiAJc3RydWN0IGdzcGNhX2ZyYW1lICpmcmFtZTsKIAl1bnNpZ25lZCBpbnQgZnJzejsKQEAgLTUxOSw3ICs1MTksNiBAQAogCWZyc3ogPSBnc3BjYV9kZXYtPmNhbS5jYW1fbW9kZVtpXS5zaXplaW1hZ2U7CiAJUERFQlVHKERfU1RSRUFNLCAiZnJhbWUgYWxsb2MgZnJzejogJWQiLCBmcnN6KTsKIAlmcnN6ID0gUEFHRV9BTElHTihmcnN6KTsKLQlnc3BjYV9kZXYtPmZyc3ogPSBmcnN6OwogCWlmIChjb3VudCA+PSBHU1BDQV9NQVhfRlJBTUVTKQogCQljb3VudCA9IEdTUENBX01BWF9GUkFNRVMgLSAxOwogCWdzcGNhX2Rldi0+ZnJidWYgPSB2bWFsbG9jXzMyKGZyc3ogKiBjb3VudCk7CkBAIC01MjcsNiArNTI2LDkgQEAKIAkJZXJyKCJmcmFtZSBhbGxvYyBmYWlsZWQiKTsKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQorCWdzcGNhX2Rldi0+Y2FwdF9maWxlID0gZmlsZTsKKwlnc3BjYV9kZXYtPm1lbW9yeSA9IG1lbW9yeTsKKwlnc3BjYV9kZXYtPmZyc3ogPSBmcnN6OwogCWdzcGNhX2Rldi0+bmZyYW1lcyA9IGNvdW50OwogCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsrKSB7CiAJCWZyYW1lID0gJmdzcGNhX2Rldi0+ZnJhbWVbaV07CkBAIC01MzUsNyArNTM3LDcgQEAKIAkJZnJhbWUtPnY0bDJfYnVmLmZsYWdzID0gMDsKIAkJZnJhbWUtPnY0bDJfYnVmLmZpZWxkID0gVjRMMl9GSUVMRF9OT05FOwogCQlmcmFtZS0+djRsMl9idWYubGVuZ3RoID0gZnJzejsKLQkJZnJhbWUtPnY0bDJfYnVmLm1lbW9yeSA9IGdzcGNhX2Rldi0+bWVtb3J5OworCQlmcmFtZS0+djRsMl9idWYubWVtb3J5ID0gbWVtb3J5OwogCQlmcmFtZS0+djRsMl9idWYuc2VxdWVuY2UgPSAwOwogCQlmcmFtZS0+ZGF0YSA9IGdzcGNhX2Rldi0+ZnJidWYgKyBpICogZnJzejsKIAkJZnJhbWUtPnY0bDJfYnVmLm0ub2Zmc2V0ID0gaSAqIGZyc3o7CkBAIC01NTgsNiArNTYwLDkgQEAKIAkJCWdzcGNhX2Rldi0+ZnJhbWVbaV0uZGF0YSA9IE5VTEw7CiAJfQogCWdzcGNhX2Rldi0+bmZyYW1lcyA9IDA7CisJZ3NwY2FfZGV2LT5mcnN6ID0gMDsKKwlnc3BjYV9kZXYtPmNhcHRfZmlsZSA9IE5VTEw7CisJZ3NwY2FfZGV2LT5tZW1vcnkgPSBHU1BDQV9NRU1PUllfTk87CiB9CiAKIHN0YXRpYyB2b2lkIGRlc3Ryb3lfdXJicyhzdHJ1Y3QgZ3NwY2FfZGV2ICpnc3BjYV9kZXYpCkBAIC0xMjEwLDI5ICsxMjE1LDE1IEBACiBzdGF0aWMgaW50IGRldl9vcGVuKHN0cnVjdCBmaWxlICpmaWxlKQogewogCXN0cnVjdCBnc3BjYV9kZXYgKmdzcGNhX2RldjsKLQlpbnQgcmV0OwogCiAJUERFQlVHKERfU1RSRUFNLCAiWyVzXSBvcGVuIiwgY3VycmVudC0+Y29tbSk7CiAJZ3NwY2FfZGV2ID0gKHN0cnVjdCBnc3BjYV9kZXYgKikgdmlkZW9fZGV2ZGF0YShmaWxlKTsKLQlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZnc3BjYV9kZXYtPnF1ZXVlX2xvY2spKQotCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwotCWlmICghZ3NwY2FfZGV2LT5wcmVzZW50KSB7Ci0JCXJldCA9IC1FTk9ERVY7Ci0JCWdvdG8gb3V0OwotCX0KLQotCWlmIChnc3BjYV9kZXYtPnVzZXJzID4gNCkgewkvKiAoYXJiaXRyYXJ5IHZhbHVlKSAqLwotCQlyZXQgPSAtRUJVU1k7Ci0JCWdvdG8gb3V0OwotCX0KKwlpZiAoIWdzcGNhX2Rldi0+cHJlc2VudCkKKwkJcmV0dXJuIC1FTk9ERVY7CiAKIAkvKiBwcm90ZWN0IHRoZSBzdWJkcml2ZXIgYWdhaW5zdCBybW1vZCAqLwotCWlmICghdHJ5X21vZHVsZV9nZXQoZ3NwY2FfZGV2LT5tb2R1bGUpKSB7Ci0JCXJldCA9IC1FTk9ERVY7Ci0JCWdvdG8gb3V0OwotCX0KLQotCWdzcGNhX2Rldi0+dXNlcnMrKzsKKwlpZiAoIXRyeV9tb2R1bGVfZ2V0KGdzcGNhX2Rldi0+bW9kdWxlKSkKKwkJcmV0dXJuIC1FTk9ERVY7CiAKIAlmaWxlLT5wcml2YXRlX2RhdGEgPSBnc3BjYV9kZXY7CiAjaWZkZWYgR1NQQ0FfREVCVUcKQEAgLTEyNDQsMTQgKzEyMzUsNyBAQAogCQlnc3BjYV9kZXYtPnZkZXYuZGVidWcgJj0gfihWNEwyX0RFQlVHX0lPQ1RMCiAJCQkJCXwgVjRMMl9ERUJVR19JT0NUTF9BUkcpOwogI2VuZGlmCi0JcmV0ID0gMDsKLW91dDoKLQltdXRleF91bmxvY2soJmdzcGNhX2Rldi0+cXVldWVfbG9jayk7Ci0JaWYgKHJldCAhPSAwKQotCQlQREVCVUcoRF9FUlJ8RF9TVFJFQU0sICJvcGVuIGZhaWxlZCBlcnIgJWQiLCByZXQpOwotCWVsc2UKLQkJUERFQlVHKERfU1RSRUFNLCAib3BlbiBkb25lIik7Ci0JcmV0dXJuIHJldDsKKwlyZXR1cm4gMDsKIH0KIAogc3RhdGljIGludCBkZXZfY2xvc2Uoc3RydWN0IGZpbGUgKmZpbGUpCkBAIC0xMjYxLDcgKzEyNDUsNiBAQAogCVBERUJVRyhEX1NUUkVBTSwgIlslc10gY2xvc2UiLCBjdXJyZW50LT5jb21tKTsKIAlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZnc3BjYV9kZXYtPnF1ZXVlX2xvY2spKQogCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwotCWdzcGNhX2Rldi0+dXNlcnMtLTsKIAogCS8qIGlmIHRoZSBmaWxlIGRpZCB0aGUgY2FwdHVyZSwgZnJlZSB0aGUgc3RyZWFtaW5nIHJlc291cmNlcyAqLwogCWlmIChnc3BjYV9kZXYtPmNhcHRfZmlsZSA9PSBmaWxlKSB7CkBAIC0xMjcyLDggKzEyNTUsNiBAQAogCQkJbXV0ZXhfdW5sb2NrKCZnc3BjYV9kZXYtPnVzYl9sb2NrKTsKIAkJfQogCQlmcmFtZV9mcmVlKGdzcGNhX2Rldik7Ci0JCWdzcGNhX2Rldi0+Y2FwdF9maWxlID0gTlVMTDsKLQkJZ3NwY2FfZGV2LT5tZW1vcnkgPSBHU1BDQV9NRU1PUllfTk87CiAJfQogCWZpbGUtPnByaXZhdGVfZGF0YSA9IE5VTEw7CiAJbW9kdWxlX3B1dChnc3BjYV9kZXYtPm1vZHVsZSk7CkBAIC0xNTE2LDYgKzE0OTcsNyBAQAogCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwogCiAJaWYgKGdzcGNhX2Rldi0+bWVtb3J5ICE9IEdTUENBX01FTU9SWV9OTworCSAgICAmJiBnc3BjYV9kZXYtPm1lbW9yeSAhPSBHU1BDQV9NRU1PUllfUkVBRAogCSAgICAmJiBnc3BjYV9kZXYtPm1lbW9yeSAhPSByYi0+bWVtb3J5KSB7CiAJCXJldCA9IC1FQlVTWTsKIAkJZ290byBvdXQ7CkBAIC0xNTQ0LDE5ICsxNTI2LDE4IEBACiAJCWdzcGNhX3N0cmVhbV9vZmYoZ3NwY2FfZGV2KTsKIAkJbXV0ZXhfdW5sb2NrKCZnc3BjYV9kZXYtPnVzYl9sb2NrKTsKIAl9CisJLyogRG9uJ3QgcmVzdGFydCB0aGUgc3RyZWFtIHdoZW4gc3dpdGNoaW5nIGZyb20gcmVhZCB0byBtbWFwIG1vZGUgKi8KKwlpZiAoZ3NwY2FfZGV2LT5tZW1vcnkgPT0gR1NQQ0FfTUVNT1JZX1JFQUQpCisJCXN0cmVhbWluZyA9IDA7CiAKIAkvKiBmcmVlIHRoZSBwcmV2aW91cyBhbGxvY2F0ZWQgYnVmZmVycywgaWYgYW55ICovCi0JaWYgKGdzcGNhX2Rldi0+bmZyYW1lcyAhPSAwKSB7CisJaWYgKGdzcGNhX2Rldi0+bmZyYW1lcyAhPSAwKQogCQlmcmFtZV9mcmVlKGdzcGNhX2Rldik7Ci0JCWdzcGNhX2Rldi0+Y2FwdF9maWxlID0gTlVMTDsKLQl9CiAJaWYgKHJiLT5jb3VudCA9PSAwKQkJCS8qIHVucmVxdWVzdCAqLwogCQlnb3RvIG91dDsKLQlnc3BjYV9kZXYtPm1lbW9yeSA9IHJiLT5tZW1vcnk7Ci0JcmV0ID0gZnJhbWVfYWxsb2MoZ3NwY2FfZGV2LCByYi0+Y291bnQpOworCXJldCA9IGZyYW1lX2FsbG9jKGdzcGNhX2RldiwgZmlsZSwgcmItPm1lbW9yeSwgcmItPmNvdW50KTsKIAlpZiAocmV0ID09IDApIHsKIAkJcmItPmNvdW50ID0gZ3NwY2FfZGV2LT5uZnJhbWVzOwotCQlnc3BjYV9kZXYtPmNhcHRfZmlsZSA9IGZpbGU7CiAJCWlmIChzdHJlYW1pbmcpCiAJCQlyZXQgPSBnc3BjYV9pbml0X3RyYW5zZmVyKGdzcGNhX2Rldik7CiAJfQpAQCAtMTYzMCwxMSArMTYxMSwxNSBAQAogCiAJaWYgKGJ1Zl90eXBlICE9IFY0TDJfQlVGX1RZUEVfVklERU9fQ0FQVFVSRSkKIAkJcmV0dXJuIC1FSU5WQUw7Ci0JaWYgKCFnc3BjYV9kZXYtPnN0cmVhbWluZykKLQkJcmV0dXJuIDA7CisKIAlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZnc3BjYV9kZXYtPnF1ZXVlX2xvY2spKQogCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwogCisJaWYgKCFnc3BjYV9kZXYtPnN0cmVhbWluZykgeworCQlyZXQgPSAwOworCQlnb3RvIG91dDsKKwl9CisKIAkvKiBjaGVjayB0aGUgY2FwdHVyZSBmaWxlICovCiAJaWYgKGdzcGNhX2Rldi0+Y2FwdF9maWxlICE9IGZpbGUpIHsKIAkJcmV0ID0gLUVCVVNZOwpAQCAtMTY0OSw2ICsxNjM0LDggQEAKIAlnc3BjYV9kZXYtPnVzYl9lcnIgPSAwOwogCWdzcGNhX3N0cmVhbV9vZmYoZ3NwY2FfZGV2KTsKIAltdXRleF91bmxvY2soJmdzcGNhX2Rldi0+dXNiX2xvY2spOworCS8qIEluIGNhc2UgYW5vdGhlciB0aHJlYWQgaXMgd2FpdGluZyBpbiBkcWJ1ZiAqLworCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmZ3NwY2FfZGV2LT53cSk7CiAKIAkvKiBlbXB0eSB0aGUgdHJhbnNmZXIgcXVldWVzICovCiAJYXRvbWljX3NldCgmZ3NwY2FfZGV2LT5mcl9xLCAwKTsKQEAgLTE4MjcsNDMgKzE4MTQsMjkgQEAKIAlyZXR1cm4gcmV0OwogfQogCi0vKgotICogd2FpdCBmb3IgYSB2aWRlbyBmcmFtZQotICoKLSAqIElmIGEgZnJhbWUgaXMgcmVhZHksIGl0cyBpbmRleCBpcyByZXR1cm5lZC4KLSAqLwotc3RhdGljIGludCBmcmFtZV93YWl0KHN0cnVjdCBnc3BjYV9kZXYgKmdzcGNhX2RldiwKLQkJCWludCBub25ibG9ja19pbmcpCitzdGF0aWMgaW50IGZyYW1lX3JlYWR5X25vbG9jayhzdHJ1Y3QgZ3NwY2FfZGV2ICpnc3BjYV9kZXYsIHN0cnVjdCBmaWxlICpmaWxlLAorCQkJCWVudW0gdjRsMl9tZW1vcnkgbWVtb3J5KQogewotCWludCBpLCByZXQ7CisJaWYgKCFnc3BjYV9kZXYtPnByZXNlbnQpCisJCXJldHVybiAtRU5PREVWOworCWlmIChnc3BjYV9kZXYtPmNhcHRfZmlsZSAhPSBmaWxlIHx8IGdzcGNhX2Rldi0+bWVtb3J5ICE9IG1lbW9yeSB8fAorCQkJIWdzcGNhX2Rldi0+c3RyZWFtaW5nKQorCQlyZXR1cm4gLUVJTlZBTDsKIAogCS8qIGNoZWNrIGlmIGEgZnJhbWUgaXMgcmVhZHkgKi8KLQlpID0gZ3NwY2FfZGV2LT5mcl9vOwotCWlmIChpID09IGF0b21pY19yZWFkKCZnc3BjYV9kZXYtPmZyX2kpKSB7Ci0JCWlmIChub25ibG9ja19pbmcpCi0JCQlyZXR1cm4gLUVBR0FJTjsKKwlyZXR1cm4gZ3NwY2FfZGV2LT5mcl9vICE9IGF0b21pY19yZWFkKCZnc3BjYV9kZXYtPmZyX2kpOworfQogCi0JCS8qIHdhaXQgdGlsbCBhIGZyYW1lIGlzIHJlYWR5ICovCi0JCXJldCA9IHdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZV90aW1lb3V0KGdzcGNhX2Rldi0+d3EsCi0JCQlpICE9IGF0b21pY19yZWFkKCZnc3BjYV9kZXYtPmZyX2kpIHx8Ci0JCQkhZ3NwY2FfZGV2LT5zdHJlYW1pbmcgfHwgIWdzcGNhX2Rldi0+cHJlc2VudCwKLQkJCW1zZWNzX3RvX2ppZmZpZXMoMzAwMCkpOwotCQlpZiAocmV0IDwgMCkKLQkJCXJldHVybiByZXQ7Ci0JCWlmIChyZXQgPT0gMCB8fCAhZ3NwY2FfZGV2LT5zdHJlYW1pbmcgfHwgIWdzcGNhX2Rldi0+cHJlc2VudCkKLQkJCXJldHVybiAtRUlPOwotCX0KK3N0YXRpYyBpbnQgZnJhbWVfcmVhZHkoc3RydWN0IGdzcGNhX2RldiAqZ3NwY2FfZGV2LCBzdHJ1Y3QgZmlsZSAqZmlsZSwKKwkJCWVudW0gdjRsMl9tZW1vcnkgbWVtb3J5KQoreworCWludCByZXQ7CiAKLQlnc3BjYV9kZXYtPmZyX28gPSAoaSArIDEpICUgR1NQQ0FfTUFYX0ZSQU1FUzsKLQotCWlmIChnc3BjYV9kZXYtPnNkX2Rlc2MtPmRxX2NhbGxiYWNrKSB7Ci0JCW11dGV4X2xvY2soJmdzcGNhX2Rldi0+dXNiX2xvY2spOwotCQlnc3BjYV9kZXYtPnVzYl9lcnIgPSAwOwotCQlpZiAoZ3NwY2FfZGV2LT5wcmVzZW50KQotCQkJZ3NwY2FfZGV2LT5zZF9kZXNjLT5kcV9jYWxsYmFjayhnc3BjYV9kZXYpOwotCQltdXRleF91bmxvY2soJmdzcGNhX2Rldi0+dXNiX2xvY2spOwotCX0KLQlyZXR1cm4gZ3NwY2FfZGV2LT5mcl9xdWV1ZVtpXTsKKwlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZnc3BjYV9kZXYtPnF1ZXVlX2xvY2spKQorCQlyZXR1cm4gLUVSRVNUQVJUU1lTOworCXJldCA9IGZyYW1lX3JlYWR5X25vbG9jayhnc3BjYV9kZXYsIGZpbGUsIG1lbW9yeSk7CisJbXV0ZXhfdW5sb2NrKCZnc3BjYV9kZXYtPnF1ZXVlX2xvY2spOworCXJldHVybiByZXQ7CiB9CiAKIC8qCkBAIC0xODc2LDMzICsxODQ5LDU3IEBACiB7CiAJc3RydWN0IGdzcGNhX2RldiAqZ3NwY2FfZGV2ID0gcHJpdjsKIAlzdHJ1Y3QgZ3NwY2FfZnJhbWUgKmZyYW1lOwotCWludCBpLCByZXQ7CisJaW50IGksIGosIHJldDsKIAogCVBERUJVRyhEX0ZSQU0sICJkcWJ1ZiIpOwotCWlmICh2NGwyX2J1Zi0+bWVtb3J5ICE9IGdzcGNhX2Rldi0+bWVtb3J5KQotCQlyZXR1cm4gLUVJTlZBTDsKIAotCWlmICghZ3NwY2FfZGV2LT5wcmVzZW50KQotCQlyZXR1cm4gLUVOT0RFVjsKLQotCS8qIGlmIG5vdCBzdHJlYW1pbmcsIGJlIHN1cmUgdGhlIGFwcGxpY2F0aW9uIHdpbGwgbm90IGxvb3AgZm9yZXZlciAqLwotCWlmICghKGZpbGUtPmZfZmxhZ3MgJiBPX05PTkJMT0NLKQotCSAgICAmJiAhZ3NwY2FfZGV2LT5zdHJlYW1pbmcgJiYgZ3NwY2FfZGV2LT51c2VycyA9PSAxKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCS8qIG9ubHkgdGhlIGNhcHR1cmluZyBmaWxlIG1heSBkZXF1ZXVlICovCi0JaWYgKGdzcGNhX2Rldi0+Y2FwdF9maWxlICE9IGZpbGUpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JLyogb25seSBvbmUgZGVxdWV1ZSAvIHJlYWQgYXQgYSB0aW1lICovCi0JaWYgKG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmZ3NwY2FfZGV2LT5yZWFkX2xvY2spKQorCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmdzcGNhX2Rldi0+cXVldWVfbG9jaykpCiAJCXJldHVybiAtRVJFU1RBUlRTWVM7CiAKLQlyZXQgPSBmcmFtZV93YWl0KGdzcGNhX2RldiwgZmlsZS0+Zl9mbGFncyAmIE9fTk9OQkxPQ0spOwotCWlmIChyZXQgPCAwKQotCQlnb3RvIG91dDsKLQlpID0gcmV0OwkJCQkvKiBmcmFtZSBpbmRleCAqLwotCWZyYW1lID0gJmdzcGNhX2Rldi0+ZnJhbWVbaV07CisJZm9yICg7OykgeworCQlyZXQgPSBmcmFtZV9yZWFkeV9ub2xvY2soZ3NwY2FfZGV2LCBmaWxlLCB2NGwyX2J1Zi0+bWVtb3J5KTsKKwkJaWYgKHJldCA8IDApCisJCQlnb3RvIG91dDsKKwkJaWYgKHJldCA+IDApCisJCQlicmVhazsKKworCQltdXRleF91bmxvY2soJmdzcGNhX2Rldi0+cXVldWVfbG9jayk7CisKKwkJaWYgKGZpbGUtPmZfZmxhZ3MgJiBPX05PTkJMT0NLKQorCQkJcmV0dXJuIC1FQUdBSU47CisKKwkJLyogd2FpdCB0aWxsIGEgZnJhbWUgaXMgcmVhZHkgKi8KKwkJcmV0ID0gd2FpdF9ldmVudF9pbnRlcnJ1cHRpYmxlX3RpbWVvdXQoZ3NwY2FfZGV2LT53cSwKKwkJCWZyYW1lX3JlYWR5KGdzcGNhX2RldiwgZmlsZSwgdjRsMl9idWYtPm1lbW9yeSksCisJCQltc2Vjc190b19qaWZmaWVzKDMwMDApKTsKKwkJaWYgKHJldCA8IDApCisJCQlyZXR1cm4gcmV0OworCQlpZiAocmV0ID09IDApCisJCQlyZXR1cm4gLUVJTzsKKworCQlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZnc3BjYV9kZXYtPnF1ZXVlX2xvY2spKQorCQkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKKwl9CisKKwlpID0gZ3NwY2FfZGV2LT5mcl9vOworCWogPSBnc3BjYV9kZXYtPmZyX3F1ZXVlW2ldOworCWZyYW1lID0gJmdzcGNhX2Rldi0+ZnJhbWVbal07CisKKwlnc3BjYV9kZXYtPmZyX28gPSAoaSArIDEpICUgR1NQQ0FfTUFYX0ZSQU1FUzsKKworCWlmIChnc3BjYV9kZXYtPnNkX2Rlc2MtPmRxX2NhbGxiYWNrKSB7CisJCW11dGV4X2xvY2soJmdzcGNhX2Rldi0+dXNiX2xvY2spOworCQlnc3BjYV9kZXYtPnVzYl9lcnIgPSAwOworCQlpZiAoZ3NwY2FfZGV2LT5wcmVzZW50KQorCQkJZ3NwY2FfZGV2LT5zZF9kZXNjLT5kcV9jYWxsYmFjayhnc3BjYV9kZXYpOworCQltdXRleF91bmxvY2soJmdzcGNhX2Rldi0+dXNiX2xvY2spOworCX0KKworCWZyYW1lLT52NGwyX2J1Zi5mbGFncyAmPSB+VjRMMl9CVUZfRkxBR19ET05FOworCW1lbWNweSh2NGwyX2J1ZiwgJmZyYW1lLT52NGwyX2J1Ziwgc2l6ZW9mICp2NGwyX2J1Zik7CisJUERFQlVHKERfRlJBTSwgImRxYnVmICVkIiwgaik7CisJcmV0ID0gMDsKKwogCWlmIChnc3BjYV9kZXYtPm1lbW9yeSA9PSBWNEwyX01FTU9SWV9VU0VSUFRSKSB7CiAJCWlmIChjb3B5X3RvX3VzZXIoKF9fdTggX191c2VyICopIGZyYW1lLT52NGwyX2J1Zi5tLnVzZXJwdHIsCiAJCQkJIGZyYW1lLT5kYXRhLApAQCAtMTkxMCwxNSArMTkwNywxMCBAQAogCQkJUERFQlVHKERfRVJSfERfU1RSRUFNLAogCQkJCSJkcWJ1ZiBjcCB0byB1c2VyIGZhaWxlZCIpOwogCQkJcmV0ID0gLUVGQVVMVDsKLQkJCWdvdG8gb3V0OwogCQl9CiAJfQotCWZyYW1lLT52NGwyX2J1Zi5mbGFncyAmPSB+VjRMMl9CVUZfRkxBR19ET05FOwotCW1lbWNweSh2NGwyX2J1ZiwgJmZyYW1lLT52NGwyX2J1Ziwgc2l6ZW9mICp2NGwyX2J1Zik7Ci0JUERFQlVHKERfRlJBTSwgImRxYnVmICVkIiwgaSk7Ci0JcmV0ID0gMDsKIG91dDoKLQltdXRleF91bmxvY2soJmdzcGNhX2Rldi0+cmVhZF9sb2NrKTsKKwltdXRleF91bmxvY2soJmdzcGNhX2Rldi0+cXVldWVfbG9jayk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtMjAzMyw5ICsyMDI1LDcgQEAKIAlwb2xsX3dhaXQoZmlsZSwgJmdzcGNhX2Rldi0+d3EsIHdhaXQpOwogCiAJLyogaWYgcmVxYnVmcyBpcyBub3QgZG9uZSwgdGhlIHVzZXIgd291bGQgdXNlIHJlYWQoKSAqLwotCWlmIChnc3BjYV9kZXYtPm5mcmFtZXMgPT0gMCkgewotCQlpZiAoZ3NwY2FfZGV2LT5tZW1vcnkgIT0gR1NQQ0FfTUVNT1JZX05PKQotCQkJcmV0dXJuIFBPTExFUlI7CQkvKiBub3QgdGhlIDFzdCB0aW1lICovCisJaWYgKGdzcGNhX2Rldi0+bWVtb3J5ID09IEdTUENBX01FTU9SWV9OTykgewogCQlyZXQgPSByZWFkX2FsbG9jKGdzcGNhX2RldiwgZmlsZSk7CiAJCWlmIChyZXQgIT0gMCkKIAkJCXJldHVybiBQT0xMRVJSOwpAQCAtMjA2NywxOCArMjA1NywxMCBAQAogCVBERUJVRyhEX0ZSQU0sICJyZWFkICglemQpIiwgY291bnQpOwogCWlmICghZ3NwY2FfZGV2LT5wcmVzZW50KQogCQlyZXR1cm4gLUVOT0RFVjsKLQlzd2l0Y2ggKGdzcGNhX2Rldi0+bWVtb3J5KSB7Ci0JY2FzZSBHU1BDQV9NRU1PUllfTk86CQkJLyogZmlyc3QgdGltZSAqLworCWlmIChnc3BjYV9kZXYtPm1lbW9yeSA9PSBHU1BDQV9NRU1PUllfTk8pIHsgLyogZmlyc3QgdGltZSA/ICovCiAJCXJldCA9IHJlYWRfYWxsb2MoZ3NwY2FfZGV2LCBmaWxlKTsKIAkJaWYgKHJldCAhPSAwKQogCQkJcmV0dXJuIHJldDsKLQkJYnJlYWs7Ci0JY2FzZSBHU1BDQV9NRU1PUllfUkVBRDoKLQkJaWYgKGdzcGNhX2Rldi0+Y2FwdF9maWxlID09IGZpbGUpCi0JCQlicmVhazsKLQkJLyogZmFsbCB0aHJ1ICovCi0JZGVmYXVsdDoKLQkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCiAJLyogZ2V0IGEgZnJhbWUgKi8KQEAgLTIyNjYsNyArMjI0OCw2IEBACiAJCWdvdG8gb3V0OwogCiAJbXV0ZXhfaW5pdCgmZ3NwY2FfZGV2LT51c2JfbG9jayk7Ci0JbXV0ZXhfaW5pdCgmZ3NwY2FfZGV2LT5yZWFkX2xvY2spOwogCW11dGV4X2luaXQoJmdzcGNhX2Rldi0+cXVldWVfbG9jayk7CiAJaW5pdF93YWl0cXVldWVfaGVhZCgmZ3NwY2FfZGV2LT53cSk7CiAKQEAgLTIzNDEsMTIgKzIzMjIsMTEgQEAKIAlQREVCVUcoRF9QUk9CRSwgIiVzIGRpc2Nvbm5lY3QiLAogCQl2aWRlb19kZXZpY2Vfbm9kZV9uYW1lKCZnc3BjYV9kZXYtPnZkZXYpKTsKIAltdXRleF9sb2NrKCZnc3BjYV9kZXYtPnVzYl9sb2NrKTsKLQlnc3BjYV9kZXYtPnByZXNlbnQgPSAwOwogCi0JaWYgKGdzcGNhX2Rldi0+c3RyZWFtaW5nKSB7Ci0JCWRlc3Ryb3lfdXJicyhnc3BjYV9kZXYpOwotCQl3YWtlX3VwX2ludGVycnVwdGlibGUoJmdzcGNhX2Rldi0+d3EpOwotCX0KKwlnc3BjYV9kZXYtPnByZXNlbnQgPSAwOworCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmZ3NwY2FfZGV2LT53cSk7CisKKwlkZXN0cm95X3VyYnMoZ3NwY2FfZGV2KTsKIAogI2lmIGRlZmluZWQoQ09ORklHX0lOUFVUKSB8fCBkZWZpbmVkKENPTkZJR19JTlBVVF9NT0RVTEUpCiAJZ3NwY2FfaW5wdXRfZGVzdHJveV91cmIoZ3NwY2FfZGV2KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvZ3NwY2EuaCBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvZ3NwY2EuaAppbmRleCA5N2I3N2EyLi40MTc1NTIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2dzcGNhLmgKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9nc3BjYS5oCkBAIC0yMDUsMTQgKzIwNSwxMiBAQAogCiAJd2FpdF9xdWV1ZV9oZWFkX3Qgd3E7CQkvKiB3YWl0IHF1ZXVlICovCiAJc3RydWN0IG11dGV4IHVzYl9sb2NrOwkJLyogdXNiIGV4Y2hhbmdlIHByb3RlY3Rpb24gKi8KLQlzdHJ1Y3QgbXV0ZXggcmVhZF9sb2NrOwkJLyogcmVhZCBwcm90ZWN0aW9uICovCiAJc3RydWN0IG11dGV4IHF1ZXVlX2xvY2s7CS8qIElTT0MgcXVldWUgcHJvdGVjdGlvbiAqLwogCWludCB1c2JfZXJyOwkJCS8qIFVTQiBlcnJvciAtIHByb3RlY3RlZCBieSB1c2JfbG9jayAqLwogCXUxNiBwa3Rfc2l6ZTsJCQkvKiBJU09DIHBhY2tldCBzaXplICovCiAjaWZkZWYgQ09ORklHX1BNCiAJY2hhciBmcm96ZW47CQkJLyogc3VzcGVuZCAtIHJlc3VtZSAqLwogI2VuZGlmCi0JY2hhciB1c2VyczsJCQkvKiBudW1iZXIgb2Ygb3BlbnMgKi8KIAljaGFyIHByZXNlbnQ7CQkJLyogZGV2aWNlIGNvbm5lY3RlZCAqLwogCWNoYXIgbmJ1ZnJlYWQ7CQkJLyogbnVtYmVyIG9mIGJ1ZmZlcnMgZm9yIHJlYWQoKSAqLwogCWNoYXIgbWVtb3J5OwkJCS8qIG1lbW9yeSB0eXBlIChWNEwyX01FTU9SWV94eHgpICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2plaWxpbmouYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvamVpbGluai5jCmluZGV4IGEzNWU4N2IuLjA2Yjc3N2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvamVpbGluai5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvamVpbGluai5jCkBAIC0zMTQsNyArMzE0LDcgQEAKIH0KIAogLyogVGFibGUgb2Ygc3VwcG9ydGVkIFVTQiBkZXZpY2VzICovCi1zdGF0aWMgY29uc3QgX19kZXZpbml0ZGF0YSBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKIAl7VVNCX0RFVklDRSgweDA5NzksIDB4MDI4MCl9LAogCXt9CiB9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9qcGVnLmggYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2pwZWcuaAppbmRleCBkZTYzYzM2Li5hYjU0OTEwIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2pwZWcuaAorKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2pwZWcuaApAQCAtMTQxLDkgKzE0MSw5IEBACiAJbWVtY3B5KGpwZWdfaGRyLCBqcGVnX2hlYWQsIHNpemVvZiBqcGVnX2hlYWQpOwogI2lmbmRlZiBDT05FWF9DQU0KIAlqcGVnX2hkcltKUEVHX0hFSUdIVF9PRkZTRVQgKyAwXSA9IGhlaWdodCA+PiA4OwotCWpwZWdfaGRyW0pQRUdfSEVJR0hUX09GRlNFVCArIDFdID0gaGVpZ2h0ICYgMHhmZjsKKwlqcGVnX2hkcltKUEVHX0hFSUdIVF9PRkZTRVQgKyAxXSA9IGhlaWdodDsKIAlqcGVnX2hkcltKUEVHX0hFSUdIVF9PRkZTRVQgKyAyXSA9IHdpZHRoID4+IDg7Ci0JanBlZ19oZHJbSlBFR19IRUlHSFRfT0ZGU0VUICsgM10gPSB3aWR0aCAmIDB4ZmY7CisJanBlZ19oZHJbSlBFR19IRUlHSFRfT0ZGU0VUICsgM10gPSB3aWR0aDsKIAlqcGVnX2hkcltKUEVHX0hFSUdIVF9PRkZTRVQgKyA2XSA9IHNhbXBsZXNZOwogI2VuZGlmCiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2tvbmljYS5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9rb25pY2EuYwppbmRleCBkMmNlNjVkLi41OTY0NjkxIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL2tvbmljYS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Eva29uaWNhLmMKQEAgLTYwNyw3ICs2MDcsNyBAQAogfTsKIAogLyogLS0gbW9kdWxlIGluaXRpYWxpc2F0aW9uIC0tICovCi1zdGF0aWMgY29uc3QgX19kZXZpbml0ZGF0YSBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKIAl7VVNCX0RFVklDRSgweDA0YzgsIDB4MDcyMCl9LCAvKiBJbnRlbCBZQyA3NiAqLwogCXt9CiB9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9tNTYwMi9tNTYwMl9jb3JlLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL201NjAyL201NjAyX2NvcmUuYwppbmRleCBjODcyYjkzLi5hNzcyMmIxIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL201NjAyL201NjAyX2NvcmUuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL201NjAyL201NjAyX2NvcmUuYwpAQCAtMjgsNyArMjgsNyBAQAogc3RhdGljIGludCBkdW1wX2JyaWRnZTsKIGludCBkdW1wX3NlbnNvcjsKIAotc3RhdGljIGNvbnN0IF9fZGV2aW5pdGRhdGEgc3RydWN0IHVzYl9kZXZpY2VfaWQgbTU2MDJfdGFibGVbXSA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBtNTYwMl90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MDQwMiwgMHg1NjAyKX0sCiAJe30KIH07CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL21hcnMuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvbWFycy5jCmluZGV4IGE4MTUzNmUuLmNiNGQwYmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvbWFycy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvbWFycy5jCkBAIC00OTAsNyArNDkwLDcgQEAKIH07CiAKIC8qIC0tIG1vZHVsZSBpbml0aWFsaXNhdGlvbiAtLSAqLwotc3RhdGljIGNvbnN0IF9fZGV2aW5pdGRhdGEgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CiAJe1VTQl9ERVZJQ0UoMHgwOTNhLCAweDA1MGYpfSwKIAl7fQogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvbXI5NzMxMGEuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvbXI5NzMxMGEuYwppbmRleCA3NjA3YTI4Li4zODg0YzlkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL21yOTczMTBhLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9tcjk3MzEwYS5jCkBAIC0xMjI5LDcgKzEyMjksNyBAQAogfTsKIAogLyogLS0gbW9kdWxlIGluaXRpYWxpc2F0aW9uIC0tICovCi1zdGF0aWMgY29uc3QgX19kZXZpbml0ZGF0YSBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKIAl7VVNCX0RFVklDRSgweDA4Y2EsIDB4MDExMCl9LAkvKiBUcnVzdCBTcHljQG0gMTAwICovCiAJe1VTQl9ERVZJQ0UoMHgwOGNhLCAweDAxMTEpfSwJLyogQWlwdGVrIFBlbmNhbSBWR0ErICovCiAJe1VTQl9ERVZJQ0UoMHgwOTNhLCAweDAxMGYpfSwJLyogQWxsIG90aGVyIGtub3duIE1SOTczMTBBIFZHQSBjYW1zICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL292NTE5LmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL292NTE5LmMKaW5kZXggZTFjM2I5My4uOGFiMmM0NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9vdjUxOS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evb3Y1MTkuYwpAQCAtNDg4LDcgKzQ4OCw2IEBACiAjZGVmaW5lIFI1MTFfU05BUF9QWERJVgkJCTB4MWMKICNkZWZpbmUgUjUxMV9TTkFQX0xORElWCQkJMHgxZAogI2RlZmluZSBSNTExX1NOQVBfVVZfRU4JCQkweDFlCi0jZGVmaW5lIFI1MTFfU05BUF9VVl9FTgkJCTB4MWUKICNkZWZpbmUgUjUxMV9TTkFQX09QVFMJCQkweDFmCiAKICNkZWZpbmUgUjUxMV9EUkFNX0ZMT1dfQ1RMCQkweDIwCkBAIC0xODQ3LDggKzE4NDYsNyBAQAogCXsgMHg2YywgMHgwYSB9LAogCXsgMHg2ZCwgMHg1NSB9LAogCXsgMHg2ZSwgMHgxMSB9LAotCXsgMHg2ZiwgMHg5ZiB9LAotCQkJCQkvKiAiOWUgZm9yIGFkdmFuY2UgQVdCIiAqLworCXsgMHg2ZiwgMHg5ZiB9LAkJCS8qICI5ZSBmb3IgYWR2YW5jZSBBV0IiICovCiAJeyAweDZhLCAweDQwIH0sCiAJeyBPVjc2NzBfUjAxX0JMVUUsIDB4NDAgfSwKIAl7IE9WNzY3MF9SMDJfUkVELCAweDYwIH0sCkBAIC0zMDU0LDcgKzMwNTIsNyBAQAogewogCXN0YXRpYyBjb25zdCBzdHJ1Y3Qgb3ZfcmVndmFscyBpbml0XzUxOVtdID0gewogCQl7IDB4NWEsIDB4NmQgfSwgLyogRW5hYmxlU3lzdGVtICovCi0JCXsgMHg1MywgMHg5YiB9LAorCQl7IDB4NTMsIDB4OWIgfSwgLyogZG9uJ3QgZW5hYmxlIHRoZSBtaWNyb2NvbnRyb2xsZXIgKi8KIAkJeyBPVjUxOV9SNTRfRU5fQ0xLMSwgMHhmZiB9LCAvKiBzZXQgYml0MiB0byBlbmFibGUganBlZyAqLwogCQl7IDB4NWQsIDB4MDMgfSwKIAkJeyAweDQ5LCAweDAxIH0sCkBAIC00NzQ3LDcgKzQ3NDUsNyBAQAogfTsKIAogLyogLS0gbW9kdWxlIGluaXRpYWxpc2F0aW9uIC0tICovCi1zdGF0aWMgY29uc3QgX19kZXZpbml0ZGF0YSBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKIAl7VVNCX0RFVklDRSgweDA0MWUsIDB4NDAwMyksIC5kcml2ZXJfaW5mbyA9IEJSSURHRV9XOTk2OENGIH0sCiAJe1VTQl9ERVZJQ0UoMHgwNDFlLCAweDQwNTIpLCAuZHJpdmVyX2luZm8gPSBCUklER0VfT1Y1MTkgfSwKIAl7VVNCX0RFVklDRSgweDA0MWUsIDB4NDA1ZiksIC5kcml2ZXJfaW5mbyA9IEJSSURHRV9PVjUxOSB9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9vdjUzNC5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9vdjUzNC5jCmluZGV4IDBlZGY5MzkuLjA0ZGEyMjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evb3Y1MzQuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL292NTM0LmMKQEAgLTQ3OSwxNSArNDc5LDIwIEBACiAJc3RydWN0IHVzYl9kZXZpY2UgKnVkZXYgPSBnc3BjYV9kZXYtPmRldjsKIAlpbnQgcmV0OwogCi0JUERFQlVHKERfVVNCTywgInJlZz0weCUwNHgsIHZhbD0wJTAyeCIsIHJlZywgdmFsKTsKKwlpZiAoZ3NwY2FfZGV2LT51c2JfZXJyIDwgMCkKKwkJcmV0dXJuOworCisJUERFQlVHKERfVVNCTywgIlNFVCAwMSAwMDAwICUwNHggJTAyeCIsIHJlZywgdmFsKTsKIAlnc3BjYV9kZXYtPnVzYl9idWZbMF0gPSB2YWw7CiAJcmV0ID0gdXNiX2NvbnRyb2xfbXNnKHVkZXYsCiAJCQkgICAgICB1c2Jfc25kY3RybHBpcGUodWRldiwgMCksCiAJCQkgICAgICAweDAxLAogCQkJICAgICAgVVNCX0RJUl9PVVQgfCBVU0JfVFlQRV9WRU5ET1IgfCBVU0JfUkVDSVBfREVWSUNFLAogCQkJICAgICAgMHgwMCwgcmVnLCBnc3BjYV9kZXYtPnVzYl9idWYsIDEsIENUUkxfVElNRU9VVCk7Ci0JaWYgKHJldCA8IDApCisJaWYgKHJldCA8IDApIHsKIAkJZXJyKCJ3cml0ZSBmYWlsZWQgJWQiLCByZXQpOworCQlnc3BjYV9kZXYtPnVzYl9lcnIgPSByZXQ7CisJfQogfQogCiBzdGF0aWMgdTggb3Y1MzRfcmVnX3JlYWQoc3RydWN0IGdzcGNhX2RldiAqZ3NwY2FfZGV2LCB1MTYgcmVnKQpAQCAtNDk1LDE0ICs1MDAsMTggQEAKIAlzdHJ1Y3QgdXNiX2RldmljZSAqdWRldiA9IGdzcGNhX2Rldi0+ZGV2OwogCWludCByZXQ7CiAKKwlpZiAoZ3NwY2FfZGV2LT51c2JfZXJyIDwgMCkKKwkJcmV0dXJuIDA7CiAJcmV0ID0gdXNiX2NvbnRyb2xfbXNnKHVkZXYsCiAJCQkgICAgICB1c2JfcmN2Y3RybHBpcGUodWRldiwgMCksCiAJCQkgICAgICAweDAxLAogCQkJICAgICAgVVNCX0RJUl9JTiB8IFVTQl9UWVBFX1ZFTkRPUiB8IFVTQl9SRUNJUF9ERVZJQ0UsCiAJCQkgICAgICAweDAwLCByZWcsIGdzcGNhX2Rldi0+dXNiX2J1ZiwgMSwgQ1RSTF9USU1FT1VUKTsKLQlQREVCVUcoRF9VU0JJLCAicmVnPTB4JTA0eCwgZGF0YT0weCUwMngiLCByZWcsIGdzcGNhX2Rldi0+dXNiX2J1ZlswXSk7Ci0JaWYgKHJldCA8IDApCisJUERFQlVHKERfVVNCSSwgIkdFVCAwMSAwMDAwICUwNHggJTAyeCIsIHJlZywgZ3NwY2FfZGV2LT51c2JfYnVmWzBdKTsKKwlpZiAocmV0IDwgMCkgewogCQllcnIoInJlYWQgZmFpbGVkICVkIiwgcmV0KTsKKwkJZ3NwY2FfZGV2LT51c2JfZXJyID0gcmV0OworCX0KIAlyZXR1cm4gZ3NwY2FfZGV2LT51c2JfYnVmWzBdOwogfQogCkBAIC01NTgsMTMgKzU2NywxNSBAQAogCiBzdGF0aWMgdm9pZCBzY2NiX3JlZ193cml0ZShzdHJ1Y3QgZ3NwY2FfZGV2ICpnc3BjYV9kZXYsIHU4IHJlZywgdTggdmFsKQogewotCVBERUJVRyhEX1VTQk8sICJyZWc6IDB4JTAyeCwgdmFsOiAweCUwMngiLCByZWcsIHZhbCk7CisJUERFQlVHKERfVVNCTywgInNjY2Igd3JpdGU6ICUwMnggJTAyeCIsIHJlZywgdmFsKTsKIAlvdjUzNF9yZWdfd3JpdGUoZ3NwY2FfZGV2LCBPVjUzNF9SRUdfU1VCQUREUiwgcmVnKTsKIAlvdjUzNF9yZWdfd3JpdGUoZ3NwY2FfZGV2LCBPVjUzNF9SRUdfV1JJVEUsIHZhbCk7CiAJb3Y1MzRfcmVnX3dyaXRlKGdzcGNhX2RldiwgT1Y1MzRfUkVHX09QRVJBVElPTiwgT1Y1MzRfT1BfV1JJVEVfMyk7CiAKLQlpZiAoIXNjY2JfY2hlY2tfc3RhdHVzKGdzcGNhX2RldikpCisJaWYgKCFzY2NiX2NoZWNrX3N0YXR1cyhnc3BjYV9kZXYpKSB7CiAJCWVycigic2NjYl9yZWdfd3JpdGUgZmFpbGVkIik7CisJCWdzcGNhX2Rldi0+dXNiX2VyciA9IC1FSU87CisJfQogfQogCiBzdGF0aWMgdTggc2NjYl9yZWdfcmVhZChzdHJ1Y3QgZ3NwY2FfZGV2ICpnc3BjYV9kZXYsIHUxNiByZWcpCkBAIC04ODUsNyArODk2LDcgQEAKIAlvdjUzNF9zZXRfbGVkKGdzcGNhX2RldiwgMCk7CiAJc2V0X2ZyYW1lX3JhdGUoZ3NwY2FfZGV2KTsKIAotCXJldHVybiAwOworCXJldHVybiBnc3BjYV9kZXYtPnVzYl9lcnI7CiB9CiAKIHN0YXRpYyBpbnQgc2Rfc3RhcnQoc3RydWN0IGdzcGNhX2RldiAqZ3NwY2FfZGV2KQpAQCAtOTIwLDcgKzkzMSw3IEBACiAKIAlvdjUzNF9zZXRfbGVkKGdzcGNhX2RldiwgMSk7CiAJb3Y1MzRfcmVnX3dyaXRlKGdzcGNhX2RldiwgMHhlMCwgMHgwMCk7Ci0JcmV0dXJuIDA7CisJcmV0dXJuIGdzcGNhX2Rldi0+dXNiX2VycjsKIH0KIAogc3RhdGljIHZvaWQgc2Rfc3RvcE4oc3RydWN0IGdzcGNhX2RldiAqZ3NwY2FfZGV2KQpAQCAtMTI4OSw3ICsxMzAwLDcgQEAKIH07CiAKIC8qIC0tIG1vZHVsZSBpbml0aWFsaXNhdGlvbiAtLSAqLwotc3RhdGljIGNvbnN0IF9fZGV2aW5pdGRhdGEgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CiAJe1VTQl9ERVZJQ0UoMHgxNDE1LCAweDIwMDApfSwKIAl7fQogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evb3Y1MzRfOS5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9vdjUzNF85LmMKaW5kZXggYzUyNDRiNC4uYWFmNTQyOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9vdjUzNF85LmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9vdjUzNF85LmMKQEAgLTE0MjksNyArMTQyOSw3IEBACiB9OwogCiAvKiAtLSBtb2R1bGUgaW5pdGlhbGlzYXRpb24gLS0gKi8KLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MDZmOCwgMHgzMDAzKX0sCiAJe30KIH07CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3BhYzIwNy5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9wYWMyMDcuYwppbmRleCA5NmY5OTg2Li44MTczOWEyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3BhYzIwNy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvcGFjMjA3LmMKQEAgLTUzMCw3ICs1MzAsNyBAQAogfTsKIAogLyogLS0gbW9kdWxlIGluaXRpYWxpc2F0aW9uIC0tICovCi1zdGF0aWMgY29uc3QgX19kZXZpbml0ZGF0YSBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKIAl7VVNCX0RFVklDRSgweDA0MWUsIDB4NDAyOCl9LAogCXtVU0JfREVWSUNFKDB4MDkzYSwgMHgyNDYwKX0sCiAJe1VTQl9ERVZJQ0UoMHgwOTNhLCAweDI0NjEpfSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvcGFjNzMwMi5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9wYWM3MzAyLmMKaW5kZXggMjcwMDk3NS4uNTYxNWQ3YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9wYWM3MzAyLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9wYWM3MzAyLmMKQEAgLTExODQsNyArMTE4NCw3IEBACiB9OwogCiAvKiAtLSBtb2R1bGUgaW5pdGlhbGlzYXRpb24gLS0gKi8KLXN0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSBfX2RldmluaXRjb25zdCA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKIAl7VVNCX0RFVklDRSgweDA2ZjgsIDB4MzAwOSl9LAogCXtVU0JfREVWSUNFKDB4MDkzYSwgMHgyNjIwKX0sCiAJe1VTQl9ERVZJQ0UoMHgwOTNhLCAweDI2MjEpfSwKQEAgLTEyMDEsNyArMTIwMSw3IEBACiBNT0RVTEVfREVWSUNFX1RBQkxFKHVzYiwgZGV2aWNlX3RhYmxlKTsKIAogLyogLS0gZGV2aWNlIGNvbm5lY3QgLS0gKi8KLXN0YXRpYyBpbnQgX19kZXZpbml0IHNkX3Byb2JlKHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRmLAorc3RhdGljIGludCBzZF9wcm9iZShzdHJ1Y3QgdXNiX2ludGVyZmFjZSAqaW50ZiwKIAkJCWNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkICppZCkKIHsKIAlyZXR1cm4gZ3NwY2FfZGV2X3Byb2JlKGludGYsIGlkLCAmc2RfZGVzYywgc2l6ZW9mKHN0cnVjdCBzZCksCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3BhYzczMTEuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvcGFjNzMxMS5jCmluZGV4IDY4MjBmNWQuLmY4ODAxYjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvcGFjNzMxMS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvcGFjNzMxMS5jCkBAIC04MzcsNyArODM3LDcgQEAKIH07CiAKIC8qIC0tIG1vZHVsZSBpbml0aWFsaXNhdGlvbiAtLSAqLwotc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdIF9fZGV2aW5pdGNvbnN0ID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MDkzYSwgMHgyNjAwKX0sCiAJe1VTQl9ERVZJQ0UoMHgwOTNhLCAweDI2MDEpfSwKIAl7VVNCX0RFVklDRSgweDA5M2EsIDB4MjYwMyl9LApAQCAtODQ5LDcgKzg0OSw3IEBACiBNT0RVTEVfREVWSUNFX1RBQkxFKHVzYiwgZGV2aWNlX3RhYmxlKTsKIAogLyogLS0gZGV2aWNlIGNvbm5lY3QgLS0gKi8KLXN0YXRpYyBpbnQgX19kZXZpbml0IHNkX3Byb2JlKHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRmLAorc3RhdGljIGludCBzZF9wcm9iZShzdHJ1Y3QgdXNiX2ludGVyZmFjZSAqaW50ZiwKIAkJCWNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkICppZCkKIHsKIAlyZXR1cm4gZ3NwY2FfZGV2X3Byb2JlKGludGYsIGlkLCAmc2RfZGVzYywgc2l6ZW9mKHN0cnVjdCBzZCksCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NuOWMyMDI4LmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NuOWMyMDI4LmMKaW5kZXggNDBhMDY2OC4uNDI3MWY4NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zbjljMjAyOC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc245YzIwMjguYwpAQCAtNzAzLDcgKzcwMyw3IEBACiB9OwogCiAvKiAtLSBtb2R1bGUgaW5pdGlhbGlzYXRpb24gLS0gKi8KLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MDQ1OCwgMHg3MDA1KX0sIC8qIEdlbml1cyBTbWFydCAzMDAsIHZlcnNpb24gMiAqLwogCS8qIFRoZSBHZW5pdXMgU21hcnQgaXMgdW50ZXN0ZWQuIEkgY2FuJ3QgZmluZCBhbiBvd25lciAhICovCiAJLyoge1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDgwMDApfSwgREMzMVZDLCBEb24ndCBrbm93IHRoaXMgY2FtZXJhICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NuOWMyMHguYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc245YzIweC5jCmluZGV4IGNiMDhkMDAuLmZjZjI5ODkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc245YzIweC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc245YzIweC5jCkBAIC0yNDcwLDcgKzI0NzAsNyBAQAogCQkJfCAoU0VOU09SXyAjIyBzZW5zb3IgPDwgOCkgXAogCQkJfCAoaTJjX2FkZHIpCiAKLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MjQwKSwgU045QzIwWChNVDlNMDAxLCAweDVkLCAwKX0sCiAJe1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYyNDIpLCBTTjlDMjBYKE1UOU0xMTEsIDB4NWQsIDApfSwKIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjI0OCksIFNOOUMyMFgoT1Y5NjU1LCAweDMwLCAwKX0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3Nvbml4Yi5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zb25peGIuYwppbmRleCA3MzUwNGEzLi5jNmNkNjhkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3Nvbml4Yi5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc29uaXhiLmMKQEAgLTIzLDggKzIzLDE1IEBACiAvKiBTb21lIGRvY3VtZW50YXRpb24gb24ga25vd24gc29uaXhiIHJlZ2lzdGVyczoKIAogUmVnCVVzZQorc245YzEwMSAvIHNuOWMxMDI6CiAweDEwCWhpZ2ggbmliYmxlIHJlZCBnYWluIGxvdyBuaWJibGUgYmx1ZSBnYWluCiAweDExCWxvdyBuaWJibGUgZ3JlZW4gZ2Fpbgorc245YzEwMzoKKzB4MDUJcmVkIGdhaW4gMC0xMjcKKzB4MDYJYmx1ZSBnYWluIDAtMTI3CisweDA3CWdyZWVuIGdhaW4gMC0xMjcKK2FsbDoKKzB4MDgtMHgwZiBpMmMgLyAzd2lyZSByZWdpc3RlcnMKIDB4MTIJaHN0YXJ0CiAweDEzCXZzdGFydAogMHgxNQloc2l6ZSAoaHNpemUgPSByZWdpc3Rlci12YWx1ZSAqIDE2KQpAQCAtODgsMTIgKzk1LDkgQEAKIHR5cGVkZWYgY29uc3QgX191OCBzZW5zb3JfaW5pdF90WzhdOwogCiBzdHJ1Y3Qgc2Vuc29yX2RhdGEgewotCWNvbnN0IF9fdTggKmJyaWRnZV9pbml0WzJdOwotCWludCBicmlkZ2VfaW5pdF9zaXplWzJdOworCWNvbnN0IF9fdTggKmJyaWRnZV9pbml0OwogCXNlbnNvcl9pbml0X3QgKnNlbnNvcl9pbml0OwogCWludCBzZW5zb3JfaW5pdF9zaXplOwotCXNlbnNvcl9pbml0X3QgKnNlbnNvcl9icmlkZ2VfaW5pdFsyXTsKLQlpbnQgc2Vuc29yX2JyaWRnZV9pbml0X3NpemVbMl07CiAJaW50IGZsYWdzOwogCXVuc2lnbmVkIGN0cmxfZGlzOwogCV9fdTggc2Vuc29yX2FkZHI7CkBAIC0xMTQsNyArMTE4LDYgQEAKICNkZWZpbmUgTk9fRlJFUSAoMSA8PCBGUkVRX0lEWCkKICNkZWZpbmUgTk9fQlJJR0hUTkVTUyAoMSA8PCBCUklHSFRORVNTX0lEWCkKIAotI2RlZmluZSBDT01QMiAweDhmCiAjZGVmaW5lIENPTVAgMHhjNwkJLyogMHg4NyAvLzB4MDcgKi8KICNkZWZpbmUgQ09NUDEgMHhjOQkJLyogMHg4OSAvLzB4MDkgKi8KIApAQCAtMTIzLDE1ICsxMjYsMTEgQEAKIAogI2RlZmluZSBTWVNfQ0xLIDB4MDQKIAotI2RlZmluZSBTRU5TKGJyaWRnZV8xLCBicmlkZ2VfMywgc2Vuc29yLCBzZW5zb3JfMSwgXAotCXNlbnNvcl8zLCBfZmxhZ3MsIF9jdHJsX2RpcywgX3NlbnNvcl9hZGRyKSBcCisjZGVmaW5lIFNFTlMoYnJpZGdlLCBzZW5zb3IsIF9mbGFncywgX2N0cmxfZGlzLCBfc2Vuc29yX2FkZHIpIFwKIHsgXAotCS5icmlkZ2VfaW5pdCA9IHsgYnJpZGdlXzEsIGJyaWRnZV8zIH0sIFwKLQkuYnJpZGdlX2luaXRfc2l6ZSA9IHsgc2l6ZW9mKGJyaWRnZV8xKSwgc2l6ZW9mKGJyaWRnZV8zKSB9LCBcCisJLmJyaWRnZV9pbml0ID0gYnJpZGdlLCBcCiAJLnNlbnNvcl9pbml0ID0gc2Vuc29yLCBcCiAJLnNlbnNvcl9pbml0X3NpemUgPSBzaXplb2Yoc2Vuc29yKSwgXAotCS5zZW5zb3JfYnJpZGdlX2luaXQgPSB7IHNlbnNvcl8xLCBzZW5zb3JfMyx9LCBcCi0JLnNlbnNvcl9icmlkZ2VfaW5pdF9zaXplID0geyBzaXplb2Yoc2Vuc29yXzEpLCBzaXplb2Yoc2Vuc29yXzMpfSwgXAogCS5mbGFncyA9IF9mbGFncywgLmN0cmxfZGlzID0gX2N0cmxfZGlzLCAuc2Vuc29yX2FkZHIgPSBfc2Vuc29yX2FkZHIgXAogfQogCkBAIC0zMTEsNyArMzEwLDYgQEAKIAkweDAwLCAweDAwLAogCTB4MDAsIDB4MDAsIDB4MDAsIDB4MDIsIDB4MDIsIDB4MDAsCiAJMHgyOCwgMHgxZSwgMHg2MCwgMHg4ZSwgMHg0MiwKLQkweDFkLCAweDEwLCAweDAyLCAweDAzLCAweDBmLCAweDBjCiB9Owogc3RhdGljIGNvbnN0IF9fdTggaHY3MTMxZF9zZW5zb3JfaW5pdFtdWzhdID0gewogCXsweGEwLCAweDExLCAweDAxLCAweDA0LCAweDAwLCAweDAwLCAweDAwLCAweDE3fSwKQEAgLTMyNiw3ICszMjQsNiBAQAogCTB4MDAsIDB4MDAsCiAJMHgwMCwgMHgwMCwgMHgwMCwgMHgwMiwgMHgwMSwgMHgwMCwKIAkweDI4LCAweDFlLCAweDYwLCAweDhhLCAweDIwLAotCTB4MWQsIDB4MTAsIDB4MDIsIDB4MDMsIDB4MGYsIDB4MGMKIH07CiBzdGF0aWMgY29uc3QgX191OCBodjcxMzFyX3NlbnNvcl9pbml0W11bOF0gPSB7CiAJezB4YzAsIDB4MTEsIDB4MzEsIDB4MzgsIDB4MmEsIDB4MmUsIDB4MDAsIDB4MTB9LApAQCAtMzM5LDcgKzMzNiw3IEBACiAJMHg0NCwgMHg0NCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHg4MCwKIAkweDYwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLAogCTB4MDAsIDB4MDEsIDB4MDEsIDB4MGEsIDB4MTYsIDB4MTIsIDB4NjgsIDB4OGIsCi0JMHgxMCwgMHgxZCwgMHgxMCwgMHgwMiwgMHgwMiwgMHgwOSwgMHgwNworCTB4MTAsCiB9Owogc3RhdGljIGNvbnN0IF9fdTggb3Y2NjUwX3NlbnNvcl9pbml0W11bOF0gPSB7CiAJLyogQnJpZ2h0LCBjb250cmFzdCwgZXRjIGFyZSBzZXQgdGhyb3VnaCBTQ0JCIGludGVyZmFjZS4KQEAgLTM3OCwyNCArMzc1LDEzIEBACiAJMHgyMSwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwJLyogcjA5IC4uIHIxMCAqLwogCTB4MDAsIDB4MDEsIDB4MDEsIDB4MGEsCQkJCS8qIHIxMSAuLiByMTQgKi8KIAkweDI4LCAweDFlLAkJCS8qIEggJiBWIHNpemVzICAgICByMTUgLi4gcjE2ICovCi0JMHg2OCwgQ09NUDIsIE1DS19JTklUMSwJCQkJLyogcjE3IC4uIHIxOSAqLwotCTB4MWQsIDB4MTAsIDB4MDIsIDB4MDMsIDB4MGYsIDB4MGMJCS8qIHIxYSAuLiByMWYgKi8KLX07Ci1zdGF0aWMgY29uc3QgX191OCBpbml0T3Y3NjMwXzNbXSA9IHsKLQkweDQ0LCAweDQ0LCAweDAwLCAweDFhLCAweDIwLCAweDIwLCAweDIwLCAweDgwLAkvKiByMDEgLi4gcjA4ICovCi0JMHgyMSwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwJLyogcjA5IC4uIHIxMCAqLwotCTB4MDAsIDB4MDIsIDB4MDEsIDB4MGEsCQkJCS8qIHIxMSAuLiByMTQgKi8KLQkweDI4LCAweDFlLAkJCS8qIEggJiBWIHNpemVzICAgICByMTUgLi4gcjE2ICovCiAJMHg2OCwgMHg4ZiwgTUNLX0lOSVQxLAkJCQkvKiByMTcgLi4gcjE5ICovCi0JMHgxZCwgMHgxMCwgMHgwMiwgMHgwMywgMHgwZiwgMHgwYywgMHgwMCwJLyogcjFhIC4uIHIyMCAqLwotCTB4MTAsIDB4MjAsIDB4MzAsIDB4NDAsIDB4NTAsIDB4NjAsIDB4NzAsIDB4ODAsIC8qIHIyMSAuLiByMjggKi8KLQkweDkwLCAweGEwLCAweGIwLCAweGMwLCAweGQwLCAweGUwLCAweGYwLCAweGZmICAvKiByMjkgLi4gcjMwICovCiB9Owogc3RhdGljIGNvbnN0IF9fdTggb3Y3NjMwX3NlbnNvcl9pbml0W11bOF0gPSB7CiAJezB4YTAsIDB4MjEsIDB4MTIsIDB4ODAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MTB9LAogCXsweGIwLCAweDIxLCAweDAxLCAweDc3LCAweDNhLCAweDAwLCAweDAwLCAweDEwfSwKIC8qCXsweGQwLCAweDIxLCAweDEyLCAweDdjLCAweDAxLCAweDgwLCAweDM0LCAweDEwfSwJICAgamZtICovCi0JezB4ZDAsIDB4MjEsIDB4MTIsIDB4MWMsIDB4MDAsIDB4ODAsIDB4MzQsIDB4MTB9LAkvKiBqZm0gKi8KKwl7MHhkMCwgMHgyMSwgMHgxMiwgMHg1YywgMHgwMCwgMHg4MCwgMHgzNCwgMHgxMH0sCS8qIGpmbSAqLwogCXsweGEwLCAweDIxLCAweDFiLCAweDA0LCAweDAwLCAweDgwLCAweDM0LCAweDEwfSwKIAl7MHhhMCwgMHgyMSwgMHgyMCwgMHg0NCwgMHgwMCwgMHg4MCwgMHgzNCwgMHgxMH0sCiAJezB4YTAsIDB4MjEsIDB4MjMsIDB4ZWUsIDB4MDAsIDB4ODAsIDB4MzQsIDB4MTB9LApAQCAtNDEzLDE2ICszOTksMTEgQEAKIAl7MHhkMCwgMHgyMSwgMHgxNywgMHgxYywgMHhiZCwgMHgwNiwgMHhmNiwgMHgxMH0sCiB9OwogCi1zdGF0aWMgY29uc3QgX191OCBvdjc2MzBfc2Vuc29yX2luaXRfM1tdWzhdID0gewotCXsweGEwLCAweDIxLCAweDEzLCAweDgwLCAweDAwLAkweDAwLCAweDAwLCAweDEwfSwKLX07Ci0KIHN0YXRpYyBjb25zdCBfX3U4IGluaXRQYXMxMDZbXSA9IHsKIAkweDA0LCAweDAzLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDgxLCAweDQwLCAweDAwLCAweDAwLCAweDAwLAogCTB4MDAsIDB4MDAsCiAJMHgwMCwgMHgwMCwgMHgwMCwgMHgwNCwgMHgwMSwgMHgwMCwKIAkweDE2LCAweDEyLCAweDI0LCBDT01QMSwgTUNLX0lOSVQxLAotCTB4MTgsIDB4MTAsIDB4MDIsIDB4MDIsIDB4MDksIDB4MDcKIH07CiAvKiBjb21wcmVzc2lvbiAweDg2IG1ja2luaXQxIDB4MmIgKi8KIApAQCAtNDk2LDcgKzQ3Nyw2IEBACiAJMHgwMCwgMHgwMCwKIAkweDAwLCAweDAwLCAweDAwLCAweDA2LCAweDAzLCAweDBhLAogCTB4MjgsIDB4MWUsIDB4MjAsIDB4ODksIDB4MjAsCi0JMHgwMCwgMHgwMCwgMHgwMiwgMHgwMywgMHgwZiwgMHgwYwogfTsKIAogLyogIktub3duIiBQQVMyMDJCQ0IgcmVnaXN0ZXJzOgpAQCAtNTM3LDcgKzUxNyw2IEBACiAJMHgwMCwgMHgwMCwKIAkweDAwLCAweDAwLCAweDAwLCAweDQ1LCAweDA5LCAweDBhLAogCTB4MTYsIDB4MTIsIDB4NjAsIDB4ODYsIDB4MmIsCi0JMHgxNCwgMHgwYSwgMHgwMiwgMHgwMiwgMHgwOSwgMHgwNwogfTsKIC8qIFNhbWUgYXMgYWJvdmUsIGV4Y2VwdCBhIGRpZmZlcmVudCBoc3RhcnQgKi8KIHN0YXRpYyBjb25zdCBfX3U4IGluaXRUYXM1MTEwZFtdID0gewpAQCAtNTQ1LDEyICs1MjQsMTkgQEAKIAkweDAwLCAweDAwLAogCTB4MDAsIDB4MDAsIDB4MDAsIDB4NDEsIDB4MDksIDB4MGEsCiAJMHgxNiwgMHgxMiwgMHg2MCwgMHg4NiwgMHgyYiwKLQkweDE0LCAweDBhLCAweDAyLCAweDAyLCAweDA5LCAweDA3CiB9Owotc3RhdGljIGNvbnN0IF9fdTggdGFzNTExMF9zZW5zb3JfaW5pdFtdWzhdID0geworLyogdGFzNTExMGMgaXMgMyB3aXJlLCB0YXM1MTEwZCBpcyAyIHdpcmUgKHJlZ3VsYXIgaTJjKSAqLworc3RhdGljIGNvbnN0IF9fdTggdGFzNTExMGNfc2Vuc29yX2luaXRbXVs4XSA9IHsKIAl7MHgzMCwgMHgxMSwgMHgwMCwgMHgwMCwgMHgwYywgMHgwMCwgMHgwMCwgMHgxMH0sCiAJezB4MzAsIDB4MTEsIDB4MDIsIDB4MjAsIDB4YTksIDB4MDAsIDB4MDAsIDB4MTB9LAotCXsweGEwLCAweDYxLCAweDlhLCAweGNhLCAweDAwLCAweDAwLCAweDAwLCAweDE3fSwKK307CisvKiBLbm93biBUQVM1MTEwRCByZWdpc3RlcnMKKyAqIHJlZzAyOiBnYWluLCBiaXQgb3JkZXIgcmV2ZXJzZWQhISAwID09IG1heCBnYWluLCAyNTUgPT0gbWluIGdhaW4KKyAqIHJlZzAzOiBiaXQzOiB2ZmxpcCwgYml0NDogfmhmbGlwLCBiaXQ3OiB+Z2FpbmJvb3N0ICh+ID09IGludmVydGVkKQorICogICAgICAgIE5vdGU6IHdyaXRpbmcgcmVnMDMgc2VlbXMgdG8gb25seSB3b3JrIHdoZW4gd3JpdHRlbiB0b2dldGhlciB3aXRoIDAyCisgKi8KK3N0YXRpYyBjb25zdCBfX3U4IHRhczUxMTBkX3NlbnNvcl9pbml0W11bOF0gPSB7CisJezB4YTAsIDB4NjEsIDB4OWEsIDB4Y2EsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MTd9LCAvKiByZXNldCAqLwogfTsKIAogc3RhdGljIGNvbnN0IF9fdTggaW5pdFRhczUxMzBbXSA9IHsKQEAgLTU1OCw3ICs1NDQsNiBAQAogCTB4MDAsIDB4MDAsCiAJMHgwMCwgMHgwMCwgMHgwMCwgMHg2OCwgMHgwYywgMHgwYSwKIAkweDI4LCAweDFlLCAweDYwLCBDT01QLCBNQ0tfSU5JVCwKLQkweDE4LCAweDEwLCAweDA0LCAweDAzLCAweDExLCAweDBjCiB9Owogc3RhdGljIGNvbnN0IF9fdTggdGFzNTEzMF9zZW5zb3JfaW5pdFtdWzhdID0gewogLyoJezB4MzAsIDB4MTEsIDB4MDAsIDB4NDAsIDB4NDcsIDB4MDAsIDB4MDAsIDB4MTB9LApAQCAtNTY5LDIxICs1NTQsMTggQEAKIH07CiAKIHN0YXRpYyBzdHJ1Y3Qgc2Vuc29yX2RhdGEgc2Vuc29yX2RhdGFbXSA9IHsKLVNFTlMoaW5pdEh2NzEzMWQsIE5VTEwsIGh2NzEzMWRfc2Vuc29yX2luaXQsIE5VTEwsIE5VTEwsIEZfR0FJTiwgTk9fQlJJR0hUTkVTU3xOT19GUkVRLCAwKSwKLVNFTlMoaW5pdEh2NzEzMXIsIE5VTEwsIGh2NzEzMXJfc2Vuc29yX2luaXQsIE5VTEwsIE5VTEwsIDAsIE5PX0JSSUdIVE5FU1N8Tk9fRVhQT3xOT19GUkVRLCAwKSwKLVNFTlMoaW5pdE92NjY1MCwgTlVMTCwgb3Y2NjUwX3NlbnNvcl9pbml0LCBOVUxMLCBOVUxMLCBGX0dBSU58Rl9TSUYsIDAsIDB4NjApLAotU0VOUyhpbml0T3Y3NjMwLCBpbml0T3Y3NjMwXzMsIG92NzYzMF9zZW5zb3JfaW5pdCwgTlVMTCwgb3Y3NjMwX3NlbnNvcl9pbml0XzMsCi0JRl9HQUlOLCAwLCAweDIxKSwKLVNFTlMoaW5pdFBhczEwNiwgTlVMTCwgcGFzMTA2X3NlbnNvcl9pbml0LCBOVUxMLCBOVUxMLCBGX0dBSU58Rl9TSUYsIE5PX0ZSRVEsCi0JMCksCi1TRU5TKGluaXRQYXMyMDIsIGluaXRQYXMyMDIsIHBhczIwMl9zZW5zb3JfaW5pdCwgTlVMTCwgTlVMTCwgRl9HQUlOLAotCU5PX0ZSRVEsIDApLAotU0VOUyhpbml0VGFzNTExMGMsIE5VTEwsIHRhczUxMTBfc2Vuc29yX2luaXQsIE5VTEwsIE5VTEwsCi0JRl9HQUlOfEZfU0lGfEZfQ09BUlNFX0VYUE8sIE5PX0JSSUdIVE5FU1N8Tk9fRlJFUSwgMCksCi1TRU5TKGluaXRUYXM1MTEwZCwgTlVMTCwgdGFzNTExMF9zZW5zb3JfaW5pdCwgTlVMTCwgTlVMTCwKLQlGX0dBSU58Rl9TSUZ8Rl9DT0FSU0VfRVhQTywgTk9fQlJJR0hUTkVTU3xOT19GUkVRLCAwKSwKLVNFTlMoaW5pdFRhczUxMzAsIE5VTEwsIHRhczUxMzBfc2Vuc29yX2luaXQsIE5VTEwsIE5VTEwsIDAsIE5PX0VYUE98Tk9fRlJFUSwKLQkwKSwKK1NFTlMoaW5pdEh2NzEzMWQsIGh2NzEzMWRfc2Vuc29yX2luaXQsIEZfR0FJTiwgTk9fQlJJR0hUTkVTU3xOT19GUkVRLCAwKSwKK1NFTlMoaW5pdEh2NzEzMXIsIGh2NzEzMXJfc2Vuc29yX2luaXQsIDAsIE5PX0JSSUdIVE5FU1N8Tk9fRVhQT3xOT19GUkVRLCAwKSwKK1NFTlMoaW5pdE92NjY1MCwgb3Y2NjUwX3NlbnNvcl9pbml0LCBGX0dBSU58Rl9TSUYsIDAsIDB4NjApLAorU0VOUyhpbml0T3Y3NjMwLCBvdjc2MzBfc2Vuc29yX2luaXQsIEZfR0FJTiwgMCwgMHgyMSksCitTRU5TKGluaXRQYXMxMDYsIHBhczEwNl9zZW5zb3JfaW5pdCwgRl9HQUlOfEZfU0lGLCBOT19GUkVRLCAwKSwKK1NFTlMoaW5pdFBhczIwMiwgcGFzMjAyX3NlbnNvcl9pbml0LCBGX0dBSU4sIE5PX0ZSRVEsIDApLAorU0VOUyhpbml0VGFzNTExMGMsIHRhczUxMTBjX3NlbnNvcl9pbml0LCBGX0dBSU58Rl9TSUZ8Rl9DT0FSU0VfRVhQTywKKwlOT19CUklHSFRORVNTfE5PX0ZSRVEsIDApLAorU0VOUyhpbml0VGFzNTExMGQsIHRhczUxMTBkX3NlbnNvcl9pbml0LCBGX0dBSU58Rl9TSUZ8Rl9DT0FSU0VfRVhQTywKKwlOT19CUklHSFRORVNTfE5PX0ZSRVEsIDApLAorU0VOUyhpbml0VGFzNTEzMCwgdGFzNTEzMF9zZW5zb3JfaW5pdCwgRl9HQUlOLAorCU5PX0JSSUdIVE5FU1N8Tk9fRVhQT3xOT19GUkVRLCAwKSwKIH07CiAKIC8qIGdldCBvbmUgYnl0ZSBpbiBnc3BjYV9kZXYtPnVzYl9idWYgKi8KQEAgLTY1NSw3ICs2MzcsNiBAQAogc3RhdGljIHZvaWQgc2V0YnJpZ2h0bmVzcyhzdHJ1Y3QgZ3NwY2FfZGV2ICpnc3BjYV9kZXYpCiB7CiAJc3RydWN0IHNkICpzZCA9IChzdHJ1Y3Qgc2QgKikgZ3NwY2FfZGV2OwotCV9fdTggdmFsdWU7CiAKIAlzd2l0Y2ggKHNkLT5zZW5zb3IpIHsKIAljYXNlICBTRU5TT1JfT1Y2NjUwOgpAQCAtNjk3LDE3ICs2NzgsNiBAQAogCQkJZ290byBlcnI7CiAJCWJyZWFrOwogCSAgICB9Ci0JY2FzZSBTRU5TT1JfVEFTNTEzMENYWDogewotCQlfX3U4IGkyY1tdID0KLQkJCXsweDMwLCAweDExLCAweDAyLCAweDIwLCAweDcwLCAweDAwLCAweDAwLCAweDEwfTsKLQotCQl2YWx1ZSA9IDB4ZmYgLSBzZC0+YnJpZ2h0bmVzczsKLQkJaTJjWzRdID0gdmFsdWU7Ci0JCVBERUJVRyhEX0NPTkYsICJicmlnaHRuZXNzICVkIDogJWQiLCB2YWx1ZSwgaTJjWzRdKTsKLQkJaWYgKGkyY193KGdzcGNhX2RldiwgaTJjKSA8IDApCi0JCQlnb3RvIGVycjsKLQkJYnJlYWs7Ci0JICAgIH0KIAl9CiAJcmV0dXJuOwogZXJyOgpAQCAtNzMzLDcgKzcwMyw3IEBACiAJCWJyZWFrOwogCSAgICB9CiAJY2FzZSBTRU5TT1JfVEFTNTExMEM6Ci0JY2FzZSBTRU5TT1JfVEFTNTExMEQ6IHsKKwljYXNlIFNFTlNPUl9UQVM1MTMwQ1hYOiB7CiAJCV9fdTggaTJjW10gPQogCQkJezB4MzAsIDB4MTEsIDB4MDIsIDB4MjAsIDB4NzAsIDB4MDAsIDB4MDAsIDB4MTB9OwogCkBAIC03NDIsNiArNzEyLDIzIEBACiAJCQlnb3RvIGVycjsKIAkJYnJlYWs7CiAJICAgIH0KKwljYXNlIFNFTlNPUl9UQVM1MTEwRDogeworCQlfX3U4IGkyY1tdID0geworCQkJMHhiMCwgMHg2MSwgMHgwMiwgMHgwMCwgMHgxMCwgMHgwMCwgMHgwMCwgMHgxNyB9OworCQlnYWluID0gMjU1IC0gZ2FpbjsKKwkJLyogVGhlIGJpdHMgaW4gdGhlIHJlZ2lzdGVyIGFyZSB0aGUgd3Jvbmcgd2F5IGFyb3VuZCEhICovCisJCWkyY1szXSB8PSAoZ2FpbiAmIDB4ODApID4+IDc7CisJCWkyY1szXSB8PSAoZ2FpbiAmIDB4NDApID4+IDU7CisJCWkyY1szXSB8PSAoZ2FpbiAmIDB4MjApID4+IDM7CisJCWkyY1szXSB8PSAoZ2FpbiAmIDB4MTApID4+IDE7CisJCWkyY1szXSB8PSAoZ2FpbiAmIDB4MDgpIDw8IDE7CisJCWkyY1szXSB8PSAoZ2FpbiAmIDB4MDQpIDw8IDM7CisJCWkyY1szXSB8PSAoZ2FpbiAmIDB4MDIpIDw8IDU7CisJCWkyY1szXSB8PSAoZ2FpbiAmIDB4MDEpIDw8IDc7CisJCWlmIChpMmNfdyhnc3BjYV9kZXYsIGkyYykgPCAwKQorCQkJZ290byBlcnI7CisJCWJyZWFrOworCSAgICB9CiAKIAljYXNlIFNFTlNPUl9PVjY2NTA6CiAJCWdhaW4gPj49IDE7CkBAIC03OTYsNyArNzgzLDcgQEAKIHsKIAlzdHJ1Y3Qgc2QgKnNkID0gKHN0cnVjdCBzZCAqKSBnc3BjYV9kZXY7CiAJX191OCBnYWluOwotCV9fdTggYnVmWzJdID0geyAwLCAwIH07CisJX191OCBidWZbM10gPSB7IDAsIDAsIDAgfTsKIAogCWlmIChzZW5zb3JfZGF0YVtzZC0+c2Vuc29yXS5mbGFncyAmIEZfR0FJTikgewogCQkvKiBVc2UgdGhlIHNlbnNvciBnYWluIHRvIGRvIHRoZSBhY3R1YWwgZ2FpbiAqLwpAQCAtODA0LDEzICs3OTEsMTggQEAKIAkJcmV0dXJuOwogCX0KIAotCWdhaW4gPSBzZC0+Z2FpbiA+PiA0OwotCi0JLyogcmVkIGFuZCBibHVlIGdhaW4gKi8KLQlidWZbMF0gPSBnYWluIDw8IDQgfCBnYWluOwotCS8qIGdyZWVuIGdhaW4gKi8KLQlidWZbMV0gPSBnYWluOwotCXJlZ193KGdzcGNhX2RldiwgMHgxMCwgYnVmLCAyKTsKKwlpZiAoc2QtPmJyaWRnZSA9PSBCUklER0VfMTAzKSB7CisJCWdhaW4gPSBzZC0+Z2FpbiA+PiAxOworCQlidWZbMF0gPSBnYWluOyAvKiBSZWQgKi8KKwkJYnVmWzFdID0gZ2FpbjsgLyogR3JlZW4gKi8KKwkJYnVmWzJdID0gZ2FpbjsgLyogQmx1ZSAqLworCQlyZWdfdyhnc3BjYV9kZXYsIDB4MDUsIGJ1ZiwgMyk7CisJfSBlbHNlIHsKKwkJZ2FpbiA9IHNkLT5nYWluID4+IDQ7CisJCWJ1ZlswXSA9IGdhaW4gPDwgNCB8IGdhaW47IC8qIFJlZCBhbmQgYmx1ZSAqLworCQlidWZbMV0gPSBnYWluOyAvKiBHcmVlbiAqLworCQlyZWdfdyhnc3BjYV9kZXYsIDB4MTAsIGJ1ZiwgMik7CisJfQogfQogCiBzdGF0aWMgdm9pZCBzZXRleHBvc3VyZShzdHJ1Y3QgZ3NwY2FfZGV2ICpnc3BjYV9kZXYpCkBAIC0xMDQ5LDcgKzEwNDEsNyBAQAogCQlkZXNpcmVkX2F2Z19sdW0gPSA1MDAwOwogCX0gZWxzZSB7CiAJCWRlYWR6b25lID0gMTUwMDsKLQkJZGVzaXJlZF9hdmdfbHVtID0gMTgwMDA7CisJCWRlc2lyZWRfYXZnX2x1bSA9IDEzMDAwOwogCX0KIAogCWlmIChzZW5zb3JfZGF0YVtzZC0+c2Vuc29yXS5mbGFncyAmIEZfQ09BUlNFX0VYUE8pCkBAIC0xMTI3LDUzICsxMTE5LDkxIEBACiB7CiAJc3RydWN0IHNkICpzZCA9IChzdHJ1Y3Qgc2QgKikgZ3NwY2FfZGV2OwogCXN0cnVjdCBjYW0gKmNhbSA9ICZnc3BjYV9kZXYtPmNhbTsKLQlpbnQgbW9kZSwgbDsKLQljb25zdCBfX3U4ICpzbjljMTB4OwotCV9fdTggcmVnMTJfMTlbOF07CisJaW50IGksIG1vZGU7CisJX191OCByZWdzWzB4MzFdOwogCiAJbW9kZSA9IGNhbS0+Y2FtX21vZGVbZ3NwY2FfZGV2LT5jdXJyX21vZGVdLnByaXYgJiAweDA3OwotCXNuOWMxMHggPSBzZW5zb3JfZGF0YVtzZC0+c2Vuc29yXS5icmlkZ2VfaW5pdFtzZC0+YnJpZGdlXTsKLQlsID0gc2Vuc29yX2RhdGFbc2QtPnNlbnNvcl0uYnJpZGdlX2luaXRfc2l6ZVtzZC0+YnJpZGdlXTsKLQltZW1jcHkocmVnMTJfMTksICZzbjljMTB4WzB4MTIgLSAxXSwgOCk7Ci0JcmVnMTJfMTlbNl0gPSBzbjljMTB4WzB4MTggLSAxXSB8IChtb2RlIDw8IDQpOwotCS8qIFNwZWNpYWwgY2FzZXMgd2hlcmUgcmVnIDE3IGFuZCBvciAxOSB2YWx1ZSBkZXBlbmRzIG9uIG1vZGUgKi8KKwkvKiBDb3B5IHJlZ2lzdGVycyAweDAxIC0gMHgxOSBmcm9tIHRoZSB0ZW1wbGF0ZSAqLworCW1lbWNweSgmcmVnc1sweDAxXSwgc2Vuc29yX2RhdGFbc2QtPnNlbnNvcl0uYnJpZGdlX2luaXQsIDB4MTkpOworCS8qIFNldCB0aGUgbW9kZSAqLworCXJlZ3NbMHgxOF0gfD0gbW9kZSA8PCA0OworCisJLyogU2V0IGJyaWRnZSBnYWluIHRvIDEuMCAqLworCWlmIChzZC0+YnJpZGdlID09IEJSSURHRV8xMDMpIHsKKwkJcmVnc1sweDA1XSA9IDB4MjA7IC8qIFJlZCAqLworCQlyZWdzWzB4MDZdID0gMHgyMDsgLyogR3JlZW4gKi8KKwkJcmVnc1sweDA3XSA9IDB4MjA7IC8qIEJsdWUgKi8KKwl9IGVsc2UgeworCQlyZWdzWzB4MTBdID0gMHgwMDsgLyogUmVkIGFuZCBibHVlICovCisJCXJlZ3NbMHgxMV0gPSAweDAwOyAvKiBHcmVlbiAqLworCX0KKworCS8qIFNldHVwIHBpeGVsIG51bWJlcnMgYW5kIGF1dG8gZXhwb3N1cmUgd2luZG93ICovCisJaWYgKHNlbnNvcl9kYXRhW3NkLT5zZW5zb3JdLmZsYWdzICYgRl9TSUYpIHsKKwkJcmVnc1sweDFhXSA9IDB4MTQ7IC8qIEhPX1NJWkUgNjQwLCBtYWtlcyBubyBzZW5zZSAqLworCQlyZWdzWzB4MWJdID0gMHgwYTsgLyogVk9fU0laRSAzMjAsIG1ha2VzIG5vIHNlbnNlICovCisJCXJlZ3NbMHgxY10gPSAweDAyOyAvKiBBRSBILXN0YXJ0IDY0ICovCisJCXJlZ3NbMHgxZF0gPSAweDAyOyAvKiBBRSBWLXN0YXJ0IDY0ICovCisJCXJlZ3NbMHgxZV0gPSAweDA5OyAvKiBBRSBILWVuZCAyODggKi8KKwkJcmVnc1sweDFmXSA9IDB4MDc7IC8qIEFFIFYtZW5kIDIyNCAqLworCX0gZWxzZSB7CisJCXJlZ3NbMHgxYV0gPSAweDFkOyAvKiBIT19TSVpFIDk2MCwgbWFrZXMgbm8gc2Vuc2UgKi8KKwkJcmVnc1sweDFiXSA9IDB4MTA7IC8qIFZPX1NJWkUgNTEyLCBtYWtlcyBubyBzZW5zZSAqLworCQlyZWdzWzB4MWNdID0gMHgwNTsgLyogQUUgSC1zdGFydCAxNjAgKi8KKwkJcmVnc1sweDFkXSA9IDB4MDM7IC8qIEFFIFYtc3RhcnQgOTYgKi8KKwkJcmVnc1sweDFlXSA9IDB4MGY7IC8qIEFFIEgtZW5kIDQ4MCAqLworCQlyZWdzWzB4MWZdID0gMHgwYzsgLyogQUUgVi1lbmQgMzg0ICovCisJfQorCisJLyogU2V0dXAgdGhlIGdhbW1hIHRhYmxlIChvbmx5IHVzZWQgd2l0aCB0aGUgc245YzEwMyBicmlkZ2UpICovCisJZm9yIChpID0gMDsgaSA8IDE2OyBpKyspCisJCXJlZ3NbMHgyMCArIGldID0gaSAqIDE2OworCXJlZ3NbMHgyMCArIGldID0gMjU1OworCisJLyogU3BlY2lhbCBjYXNlcyB3aGVyZSBzb21lIHJlZ3MgZGVwZW5kIG9uIG1vZGUgb3IgYnJpZGdlICovCiAJc3dpdGNoIChzZC0+c2Vuc29yKSB7CiAJY2FzZSBTRU5TT1JfVEFTNTEzMENYWDoKLQkJLyogcHJvYmFibHkgbm90IG1vZGUgc3BlY2lmaWMgYXQgYWxsIG1vc3QgbGlrZWx5IHRoZSB1cHBlcgorCQkvKiBGSVhNRSAvIFRFU1RNRQorCQkgICBwcm9iYWJseSBub3QgbW9kZSBzcGVjaWZpYyBhdCBhbGwgbW9zdCBsaWtlbHkgdGhlIHVwcGVyCiAJCSAgIG5pYmJsZSBvZiAweDE5IGlzIGV4cG9zdXJlIChjbG9jayBkaXZpZGVyKSBqdXN0IGFzIHdpdGgKIAkJICAgdGhlIHRhczUxMTAsIHdlIG5lZWQgc29tZW9uZSB0byB0ZXN0IHRoaXMuICovCi0JCXJlZzEyXzE5WzddID0gbW9kZSA/IDB4MjMgOiAweDQzOworCQlyZWdzWzB4MTldID0gbW9kZSA/IDB4MjMgOiAweDQzOwogCQlicmVhazsKKwljYXNlIFNFTlNPUl9PVjc2MzA6CisJCS8qIEZJWE1FIC8gVEVTVE1FIGZvciBzb21lIHJlYXNvbiB3aXRoIHRoZSAxMDEvMTAyIGJyaWRnZSB0aGUKKwkJICAgY2xvY2sgaXMgc2V0IHRvIDEyIE1oeiAocmVnMSA9PSAweDA0KSwgcmF0aGVyIHRoZW4gMjQuCisJCSAgIEFsc28gdGhlIGhzdGFydCBuZWVkcyB0byBnbyBmcm9tIDEgdG8gMiB3aGVuIHVzaW5nIGEgMTAzLAorCQkgICB3aGljaCBpcyBsaWtlbHkgcmVsYXRlZC4gVGhpcyBkb2VzIG5vdCBzZWVtIHJpZ2h0LiAqLworCQlpZiAoc2QtPmJyaWRnZSA9PSBCUklER0VfMTAzKSB7CisJCQlyZWdzWzB4MDFdID0gMHg0NDsgLyogU2VsZWN0IDI0IE1oeiBjbG9jayAqLworCQkJcmVnc1sweDEyXSA9IDB4MDI7IC8qIFNldCBoc3RhcnQgdG8gMiAqLworCQl9CiAJfQogCS8qIERpc2FibGUgY29tcHJlc3Npb24gd2hlbiB0aGUgcmF3IGJheWVyIGZvcm1hdCBoYXMgYmVlbiBzZWxlY3RlZCAqLwogCWlmIChjYW0tPmNhbV9tb2RlW2dzcGNhX2Rldi0+Y3Vycl9tb2RlXS5wcml2ICYgTU9ERV9SQVcpCi0JCXJlZzEyXzE5WzZdICY9IH4weDgwOworCQlyZWdzWzB4MThdICY9IH4weDgwOwogCiAJLyogVmdhIG1vZGUgZW11bGF0aW9uIG9uIFNJRiBzZW5zb3I/ICovCiAJaWYgKGNhbS0+Y2FtX21vZGVbZ3NwY2FfZGV2LT5jdXJyX21vZGVdLnByaXYgJiBNT0RFX1JFRFVDRURfU0lGKSB7Ci0JCXJlZzEyXzE5WzBdICs9IDE2OyAvKiAweDEyOiBoc3RhcnQgYWRqdXN0ICovCi0JCXJlZzEyXzE5WzFdICs9IDI0OyAvKiAweDEzOiB2c3RhcnQgYWRqdXN0ICovCi0JCXJlZzEyXzE5WzNdID0gMzIwIC8gMTY7IC8qIDB4MTU6IGhzaXplICovCi0JCXJlZzEyXzE5WzRdID0gMjQwIC8gMTY7IC8qIDB4MTY6IHZzaXplICovCisJCXJlZ3NbMHgxMl0gKz0gMTY7CS8qIGhzdGFydCBhZGp1c3QgKi8KKwkJcmVnc1sweDEzXSArPSAyNDsJLyogdnN0YXJ0IGFkanVzdCAqLworCQlyZWdzWzB4MTVdICA9IDMyMCAvIDE2OyAvKiBoc2l6ZSAqLworCQlyZWdzWzB4MTZdICA9IDI0MCAvIDE2OyAvKiB2c2l6ZSAqLwogCX0KIAogCS8qIHJlZyAweDAxIGJpdCAyIHZpZGVvIHRyYW5zZmVydCBvbiAqLwotCXJlZ193KGdzcGNhX2RldiwgMHgwMSwgJnNuOWMxMHhbMHgwMSAtIDFdLCAxKTsKKwlyZWdfdyhnc3BjYV9kZXYsIDB4MDEsICZyZWdzWzB4MDFdLCAxKTsKIAkvKiByZWcgMHgxNyBTZW5zb3JDbGsgZW5hYmxlIGludiBDbGsgMHg2MCAqLwotCXJlZ193KGdzcGNhX2RldiwgMHgxNywgJnNuOWMxMHhbMHgxNyAtIDFdLCAxKTsKKwlyZWdfdyhnc3BjYV9kZXYsIDB4MTcsICZyZWdzWzB4MTddLCAxKTsKIAkvKiBTZXQgdGhlIHJlZ2lzdGVycyBmcm9tIHRoZSB0ZW1wbGF0ZSAqLwotCXJlZ193KGdzcGNhX2RldiwgMHgwMSwgc245YzEweCwgbCk7CisJcmVnX3coZ3NwY2FfZGV2LCAweDAxLCAmcmVnc1sweDAxXSwKKwkgICAgICAoc2QtPmJyaWRnZSA9PSBCUklER0VfMTAzKSA/IDB4MzAgOiAweDFmKTsKIAogCS8qIEluaXQgdGhlIHNlbnNvciAqLwogCWkyY193X3ZlY3Rvcihnc3BjYV9kZXYsIHNlbnNvcl9kYXRhW3NkLT5zZW5zb3JdLnNlbnNvcl9pbml0LAogCQkJc2Vuc29yX2RhdGFbc2QtPnNlbnNvcl0uc2Vuc29yX2luaXRfc2l6ZSk7Ci0JaWYgKHNlbnNvcl9kYXRhW3NkLT5zZW5zb3JdLnNlbnNvcl9icmlkZ2VfaW5pdFtzZC0+YnJpZGdlXSkKLQkJaTJjX3dfdmVjdG9yKGdzcGNhX2RldiwKLQkJCXNlbnNvcl9kYXRhW3NkLT5zZW5zb3JdLnNlbnNvcl9icmlkZ2VfaW5pdFtzZC0+YnJpZGdlXSwKLQkJCXNlbnNvcl9kYXRhW3NkLT5zZW5zb3JdLnNlbnNvcl9icmlkZ2VfaW5pdF9zaXplWwotCQkJCXNkLT5icmlkZ2VdKTsKIAotCS8qIE1vZGUgc3BlY2lmaWMgc2Vuc29yIHNldHVwICovCisJLyogTW9kZSAvIGJyaWRnZSBzcGVjaWZpYyBzZW5zb3Igc2V0dXAgKi8KIAlzd2l0Y2ggKHNkLT5zZW5zb3IpIHsKIAljYXNlIFNFTlNPUl9QQVMyMDI6IHsKIAkJY29uc3QgX191OCBpMmNwY2xvY2tkaXZbXSA9CkBAIC0xMTgxLDI3ICsxMjExLDM3IEBACiAJCS8qIGNsb2NrZGl2IGZyb20gNCB0byAzICg3LjUgLT4gMTAgZnBzKSB3aGVuIGluIGxvdyByZXMgbW9kZSAqLwogCQlpZiAobW9kZSkKIAkJCWkyY193KGdzcGNhX2RldiwgaTJjcGNsb2NrZGl2KTsKKwkJYnJlYWs7CiAJICAgIH0KKwljYXNlIFNFTlNPUl9PVjc2MzA6CisJCS8qIEZJWE1FIC8gVEVTVE1FIFdlIHNob3VsZCBiZSBhYmxlIHRvIGhhbmRsZSB0aGlzIGlkZW50aWNhbAorCQkgICBmb3IgdGhlIDEwMS8xMDIgYW5kIHRoZSAxMDMgY2FzZSAqLworCQlpZiAoc2QtPmJyaWRnZSA9PSBCUklER0VfMTAzKSB7CisJCQljb25zdCBfX3U4IGkyY1tdID0geyAweGEwLCAweDIxLCAweDEzLAorCQkJCQkgICAgIDB4ODAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MTAgfTsKKwkJCWkyY193KGdzcGNhX2RldiwgaTJjKTsKKwkJfQorCQlicmVhazsKIAl9CiAJLyogSF9zaXplIFZfc2l6ZSAweDI4LCAweDFlIC0+IDY0MHg0ODAuIDB4MTYsIDB4MTIgLT4gMzUyeDI4OCAqLwotCXJlZ193KGdzcGNhX2RldiwgMHgxNSwgJnJlZzEyXzE5WzNdLCAyKTsKKwlyZWdfdyhnc3BjYV9kZXYsIDB4MTUsICZyZWdzWzB4MTVdLCAyKTsKIAkvKiBjb21wcmVzc2lvbiByZWdpc3RlciAqLwotCXJlZ193KGdzcGNhX2RldiwgMHgxOCwgJnJlZzEyXzE5WzZdLCAxKTsKKwlyZWdfdyhnc3BjYV9kZXYsIDB4MTgsICZyZWdzWzB4MThdLCAxKTsKIAkvKiBIX3N0YXJ0ICovCi0JcmVnX3coZ3NwY2FfZGV2LCAweDEyLCAmcmVnMTJfMTlbMF0sIDEpOworCXJlZ193KGdzcGNhX2RldiwgMHgxMiwgJnJlZ3NbMHgxMl0sIDEpOwogCS8qIFZfU1RBUlQgKi8KLQlyZWdfdyhnc3BjYV9kZXYsIDB4MTMsICZyZWcxMl8xOVsxXSwgMSk7CisJcmVnX3coZ3NwY2FfZGV2LCAweDEzLCAmcmVnc1sweDEzXSwgMSk7CiAJLyogcmVzZXQgMHgxNyBTZW5zb3JDbGsgZW5hYmxlIGludiBDbGsgMHg2MCAqLwogCQkJCS8qZml4bWU6IG92NzYzMCBbMTddPTY4IDhmICgrMjAgaWYgMTAyKSovCi0JcmVnX3coZ3NwY2FfZGV2LCAweDE3LCAmcmVnMTJfMTlbNV0sIDEpOworCXJlZ193KGdzcGNhX2RldiwgMHgxNywgJnJlZ3NbMHgxN10sIDEpOwogCS8qTUNLU0laRSAtPjMgKi8JLypmaXhtZTogbm90IG92NzYzMCovCi0JcmVnX3coZ3NwY2FfZGV2LCAweDE5LCAmcmVnMTJfMTlbN10sIDEpOworCXJlZ193KGdzcGNhX2RldiwgMHgxOSwgJnJlZ3NbMHgxOV0sIDEpOwogCS8qIEFFX1NUUlggQUVfU1RSWSBBRV9FTkRYIEFFX0VORFkgKi8KLQlyZWdfdyhnc3BjYV9kZXYsIDB4MWMsICZzbjljMTB4WzB4MWMgLSAxXSwgNCk7CisJcmVnX3coZ3NwY2FfZGV2LCAweDFjLCAmcmVnc1sweDFjXSwgNCk7CiAJLyogRW5hYmxlIHZpZGVvIHRyYW5zZmVydCAqLwotCXJlZ193KGdzcGNhX2RldiwgMHgwMSwgJnNuOWMxMHhbMF0sIDEpOworCXJlZ193KGdzcGNhX2RldiwgMHgwMSwgJnJlZ3NbMHgwMV0sIDEpOwogCS8qIENvbXByZXNzaW9uICovCi0JcmVnX3coZ3NwY2FfZGV2LCAweDE4LCAmcmVnMTJfMTlbNl0sIDIpOworCXJlZ193KGdzcGNhX2RldiwgMHgxOCwgJnJlZ3NbMHgxOF0sIDIpOwogCW1zbGVlcCgyMCk7CiAKIAlzZC0+cmVnMTEgPSAtMTsKQEAgLTE1MjUsMTUgKzE1NjUsMTUgQEAKIAkuZHJpdmVyX2luZm8gPSAoU0VOU09SXyAjIyBzZW5zb3IgPDwgOCkgfCBCUklER0VfICMjIGJyaWRnZQogCiAKLXN0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSBfX2RldmluaXRjb25zdCA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjAwMSksIFNCKFRBUzUxMTBDLCAxMDIpfSwgLyogVEFTNTExMEMxQiAqLwogCXtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MDA1KSwgU0IoVEFTNTExMEMsIDEwMSl9LCAvKiBUQVM1MTEwQzFCICovCiAJe1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwMDcpLCBTQihUQVM1MTEwRCwgMTAxKX0sIC8qIFRBUzUxMTBEICovCiAJe1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwMDkpLCBTQihQQVMxMDYsIDEwMSl9LAogCXtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MDBkKSwgU0IoUEFTMTA2LCAxMDEpfSwKIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjAxMSksIFNCKE9WNjY1MCwgMTAxKX0sCi0jaWYgIWRlZmluZWQgQ09ORklHX1VTQl9TTjlDMTAyICYmICFkZWZpbmVkIENPTkZJR19VU0JfU045QzEwMl9NT0RVTEUKIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjAxOSksIFNCKE9WNzYzMCwgMTAxKX0sCisjaWYgIWRlZmluZWQgQ09ORklHX1VTQl9TTjlDMTAyICYmICFkZWZpbmVkIENPTkZJR19VU0JfU045QzEwMl9NT0RVTEUKIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjAyNCksIFNCKFRBUzUxMzBDWFgsIDEwMil9LAogCXtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MDI1KSwgU0IoVEFTNTEzMENYWCwgMTAyKX0sCiAjZW5kaWYKQEAgLTE1NDQsMTggKzE1ODQsMjIgQEAKIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjAyYyksIFNCKE9WNzYzMCwgMTAyKX0sCiAJe1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwMmQpLCBTQihIVjcxMzFSLCAxMDIpfSwKIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjAyZSksIFNCKE9WNzYzMCwgMTAyKX0sCi0JLyoge1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwMmIpLCBTQihNSTAzWFgsIDEwMil9LCAqLyAvKiBNSTAzNDMgTUkwMzYwIE1JMDMzMCAqLworCS8qIHtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MDMwKSwgU0IoTUkwM1hYLCAxMDIpfSwgKi8gLyogTUkwMzQzIE1JMDM2MCBNSTAzMzAgKi8KKwkvKiB7VVNCX0RFVklDRSgweDBjNDUsIDB4NjA4MiksIFNCKE1JMDNYWCwgMTAzKX0sICovIC8qIE1JMDM0MyBNSTAzNjAgKi8KKwl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjA4MyksIFNCKEhWNzEzMUQsIDEwMyl9LAorCXtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MDhjKSwgU0IoSFY3MTMxUiwgMTAzKX0sCisJLyoge1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwOGUpLCBTQihDSVNWRjEwLCAxMDMpfSwgKi8KIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjA4ZiksIFNCKE9WNzYzMCwgMTAzKX0sCi0jaWYgIWRlZmluZWQgQ09ORklHX1VTQl9TTjlDMTAyICYmICFkZWZpbmVkIENPTkZJR19VU0JfU045QzEwMl9NT0RVTEUKKwl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjBhOCksIFNCKFBBUzEwNiwgMTAzKX0sCisJe1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYWEpLCBTQihUQVM1MTMwQ1hYLCAxMDMpfSwKIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjBhZiksIFNCKFBBUzIwMiwgMTAzKX0sCi0jZW5kaWYKIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjBiMCksIFNCKE9WNzYzMCwgMTAzKX0sCiAJe30KIH07CiBNT0RVTEVfREVWSUNFX1RBQkxFKHVzYiwgZGV2aWNlX3RhYmxlKTsKIAogLyogLS0gZGV2aWNlIGNvbm5lY3QgLS0gKi8KLXN0YXRpYyBpbnQgX19kZXZpbml0IHNkX3Byb2JlKHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRmLAorc3RhdGljIGludCBzZF9wcm9iZShzdHJ1Y3QgdXNiX2ludGVyZmFjZSAqaW50ZiwKIAkJCWNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkICppZCkKIHsKIAlyZXR1cm4gZ3NwY2FfZGV2X3Byb2JlKGludGYsIGlkLCAmc2RfZGVzYywgc2l6ZW9mKHN0cnVjdCBzZCksCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3Nvbml4ai5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zb25peGouYwppbmRleCAyZDBiYjE3Li5kNmYzOWNlIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3Nvbml4ai5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc29uaXhqLmMKQEAgLTI1LDEyICsyNSwxMiBAQAogI2luY2x1ZGUgImdzcGNhLmgiCiAjaW5jbHVkZSAianBlZy5oIgogCi0jZGVmaW5lIFY0TDJfQ0lEX0lORlJBUkVEIChWNEwyX0NJRF9QUklWQVRFX0JBU0UgKyAwKQotCiBNT0RVTEVfQVVUSE9SKCJKZWFuLUZyYW7Dp29pcyBNb2luZSA8aHR0cDovL21vaW5lamYuZnJlZS5mcj4iKTsKIE1PRFVMRV9ERVNDUklQVElPTigiR1NQQ0EvU09OSVggSlBFRyBVU0IgQ2FtZXJhIERyaXZlciIpOwogTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwogCitzdGF0aWMgaW50IHN0YXJjYW07CisKIC8qIGNvbnRyb2xzICovCiBlbnVtIGVfY3RybCB7CiAJQlJJR0hUTkVTUywKQEAgLTQzLDcgKzQzLDcgQEAKIAlIRkxJUCwKIAlWRkxJUCwKIAlTSEFSUE5FU1MsCi0JSU5GUkFSRUQsCisJSUxMVU0sCiAJRlJFUSwKIAlOQ1RSTFMJCS8qIG51bWJlciBvZiBjb250cm9scyAqLwogfTsKQEAgLTEwMCw3ICsxMDAsOCBAQAogfTsKIAogLyogZGV2aWNlIGZsYWdzICovCi0jZGVmaW5lIFBETl9JTlYJMQkJLyogaW52ZXJzZSBwaW4gU19QV1JfRE4gLyBzbl94eHggdGFibGVzICovCisjZGVmaW5lIEZfUEROX0lOVgkweDAxCS8qIGludmVyc2UgcGluIFNfUFdSX0ROIC8gc25feHh4IHRhYmxlcyAqLworI2RlZmluZSBGX0lMTFVNCQkweDAyCS8qIHByZXNlbmNlIG9mIGlsbHVtaW5hdG9yICovCiAKIC8qIHNuOWMxeHggZGVmaW5pdGlvbnMgKi8KIC8qIHJlZ2lzdGVyIDB4MDEgKi8KQEAgLTEyNCw3ICsxMjUsNyBAQAogc3RhdGljIHZvaWQgc2V0YXV0b2dhaW4oc3RydWN0IGdzcGNhX2RldiAqZ3NwY2FfZGV2KTsKIHN0YXRpYyB2b2lkIHNldGh2ZmxpcChzdHJ1Y3QgZ3NwY2FfZGV2ICpnc3BjYV9kZXYpOwogc3RhdGljIHZvaWQgc2V0c2hhcnBuZXNzKHN0cnVjdCBnc3BjYV9kZXYgKmdzcGNhX2Rldik7Ci1zdGF0aWMgdm9pZCBzZXRpbmZyYXJlZChzdHJ1Y3QgZ3NwY2FfZGV2ICpnc3BjYV9kZXYpOworc3RhdGljIHZvaWQgc2V0aWxsdW0oc3RydWN0IGdzcGNhX2RldiAqZ3NwY2FfZGV2KTsKIHN0YXRpYyB2b2lkIHNldGZyZXEoc3RydWN0IGdzcGNhX2RldiAqZ3NwY2FfZGV2KTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBjdHJsIHNkX2N0cmxzW05DVFJMU10gPSB7CkBAIC0yNTEsMTggKzI1MiwxNyBAQAogCSAgICB9LAogCSAgICAuc2V0X2NvbnRyb2wgPSBzZXRzaGFycG5lc3MKIAl9LAotLyogbXQ5djExMSBvbmx5ICovCi1bSU5GUkFSRURdID0geworW0lMTFVNXSA9IHsKIAkgICAgewotCQkuaWQgICAgICA9IFY0TDJfQ0lEX0lORlJBUkVELAorCQkuaWQgICAgICA9IFY0TDJfQ0lEX0lMTFVNSU5BVE9SU18xLAogCQkudHlwZSAgICA9IFY0TDJfQ1RSTF9UWVBFX0JPT0xFQU4sCi0JCS5uYW1lICAgID0gIkluZnJhcmVkIiwKKwkJLm5hbWUgICAgPSAiSWxsdW1pbmF0b3IgLyBpbmZyYXJlZCIsCiAJCS5taW5pbXVtID0gMCwKIAkJLm1heGltdW0gPSAxLAogCQkuc3RlcCAgICA9IDEsCiAJCS5kZWZhdWx0X3ZhbHVlID0gMCwKIAkgICAgfSwKLQkgICAgLnNldF9jb250cm9sID0gc2V0aW5mcmFyZWQKKwkgICAgLnNldF9jb250cm9sID0gc2V0aWxsdW0KIAl9LAogLyogb3Y3NjMwL292NzY0OC9vdjc2NjAgb25seSAqLwogW0ZSRVFdID0gewpAQCAtMjgyLDMyICsyODIsMjYgQEAKIC8qIHRhYmxlIG9mIHRoZSBkaXNhYmxlZCBjb250cm9scyAqLwogc3RhdGljIGNvbnN0IF9fdTMyIGN0cmxfZGlzW10gPSB7CiBbU0VOU09SX0FEQ00xNzAwXSA9CSgxIDw8IEFVVE9HQUlOKSB8Ci0JCQkoMSA8PCBJTkZSQVJFRCkgfAogCQkJKDEgPDwgSEZMSVApIHwKIAkJCSgxIDw8IFZGTElQKSB8CiAJCQkoMSA8PCBGUkVRKSwKIAotW1NFTlNPUl9HQzAzMDddID0JKDEgPDwgSU5GUkFSRUQpIHwKLQkJCSgxIDw8IEhGTElQKSB8CitbU0VOU09SX0dDMDMwN10gPQkoMSA8PCBIRkxJUCkgfAogCQkJKDEgPDwgVkZMSVApIHwKIAkJCSgxIDw8IEZSRVEpLAogCi1bU0VOU09SX0hWNzEzMVJdID0JKDEgPDwgSU5GUkFSRUQpIHwKLQkJCSgxIDw8IEhGTElQKSB8CitbU0VOU09SX0hWNzEzMVJdID0JKDEgPDwgSEZMSVApIHwKIAkJCSgxIDw8IEZSRVEpLAogCi1bU0VOU09SX01JMDM2MF0gPQkoMSA8PCBJTkZSQVJFRCkgfAotCQkJKDEgPDwgSEZMSVApIHwKK1tTRU5TT1JfTUkwMzYwXSA9CSgxIDw8IEhGTElQKSB8CiAJCQkoMSA8PCBWRkxJUCkgfAogCQkJKDEgPDwgRlJFUSksCiAKLVtTRU5TT1JfTUkwMzYwQl0gPQkoMSA8PCBJTkZSQVJFRCkgfAotCQkJKDEgPDwgSEZMSVApIHwKK1tTRU5TT1JfTUkwMzYwQl0gPQkoMSA8PCBIRkxJUCkgfAogCQkJKDEgPDwgVkZMSVApIHwKIAkJCSgxIDw8IEZSRVEpLAogCi1bU0VOU09SX01PNDAwMF0gPQkoMSA8PCBJTkZSQVJFRCkgfAotCQkJKDEgPDwgSEZMSVApIHwKK1tTRU5TT1JfTU80MDAwXSA9CSgxIDw8IEhGTElQKSB8CiAJCQkoMSA8PCBWRkxJUCkgfAogCQkJKDEgPDwgRlJFUSksCiAKQEAgLTMxNSw0MCArMzA5LDMyIEBACiAJCQkoMSA8PCBWRkxJUCkgfAogCQkJKDEgPDwgRlJFUSksCiAKLVtTRU5TT1JfT002ODAyXSA9CSgxIDw8IElORlJBUkVEKSB8Ci0JCQkoMSA8PCBIRkxJUCkgfAorW1NFTlNPUl9PTTY4MDJdID0JKDEgPDwgSEZMSVApIHwKIAkJCSgxIDw8IFZGTElQKSB8CiAJCQkoMSA8PCBGUkVRKSwKIAotW1NFTlNPUl9PVjc2MzBdID0JKDEgPDwgSU5GUkFSRUQpIHwKLQkJCSgxIDw8IEhGTElQKSwKK1tTRU5TT1JfT1Y3NjMwXSA9CSgxIDw8IEhGTElQKSwKIAotW1NFTlNPUl9PVjc2NDhdID0JKDEgPDwgSU5GUkFSRUQpIHwKLQkJCSgxIDw8IEhGTElQKSwKK1tTRU5TT1JfT1Y3NjQ4XSA9CSgxIDw8IEhGTElQKSwKIAogW1NFTlNPUl9PVjc2NjBdID0JKDEgPDwgQVVUT0dBSU4pIHwKLQkJCSgxIDw8IElORlJBUkVEKSB8CiAJCQkoMSA8PCBIRkxJUCkgfAogCQkJKDEgPDwgVkZMSVApLAogCiBbU0VOU09SX1BPMTAzMF0gPQkoMSA8PCBBVVRPR0FJTikgfAotCQkJKDEgPDwgSU5GUkFSRUQpIHwKIAkJCSgxIDw8IEhGTElQKSB8CiAJCQkoMSA8PCBWRkxJUCkgfAogCQkJKDEgPDwgRlJFUSksCiAKIFtTRU5TT1JfUE8yMDMwTl0gPQkoMSA8PCBBVVRPR0FJTikgfAotCQkJKDEgPDwgSU5GUkFSRUQpIHwKIAkJCSgxIDw8IEZSRVEpLAogCiBbU0VOU09SX1NPSTc2OF0gPQkoMSA8PCBBVVRPR0FJTikgfAotCQkJKDEgPDwgSU5GUkFSRUQpIHwKIAkJCSgxIDw8IEhGTElQKSB8CiAJCQkoMSA8PCBWRkxJUCkgfAogCQkJKDEgPDwgRlJFUSksCiAKIFtTRU5TT1JfU1A4MDcwOF0gPQkoMSA8PCBBVVRPR0FJTikgfAotCQkJKDEgPDwgSU5GUkFSRUQpIHwKIAkJCSgxIDw8IEhGTElQKSB8CiAJCQkoMSA8PCBWRkxJUCkgfAogCQkJKDEgPDwgRlJFUSksCkBAIC0xODIyLDQ0ICsxODA4LDQ2IEBACiAJUERFQlVHKERfUFJPQkUsICJTb25peCBjaGlwIGlkOiAlMDJ4IiwgcmVnRjEpOwogCXN3aXRjaCAoc2QtPmJyaWRnZSkgewogCWNhc2UgQlJJREdFX1NOOUMxMDJQOgotCQlpZiAocmVnRjEgIT0gMHgxMSkKLQkJCXJldHVybiAtRU5PREVWOwotCQlyZWdfdzEoZ3NwY2FfZGV2LCAweDAyLCByZWdHcGlvWzFdKTsKLQkJYnJlYWs7CiAJY2FzZSBCUklER0VfU045QzEwNToKIAkJaWYgKHJlZ0YxICE9IDB4MTEpCiAJCQlyZXR1cm4gLUVOT0RFVjsKLQkJaWYgKHNkLT5zZW5zb3IgPT0gU0VOU09SX01JMDM2MCkKLQkJCW1pMDM2MF9wcm9iZShnc3BjYV9kZXYpOwotCQlyZWdfdyhnc3BjYV9kZXYsIDB4MDEsIHJlZ0dwaW8sIDIpOwotCQlicmVhazsKLQljYXNlIEJSSURHRV9TTjlDMTIwOgotCQlpZiAocmVnRjEgIT0gMHgxMikKLQkJCXJldHVybiAtRU5PREVWOwotCQlzd2l0Y2ggKHNkLT5zZW5zb3IpIHsKLQkJY2FzZSBTRU5TT1JfTUkwMzYwOgotCQkJbWkwMzYwX3Byb2JlKGdzcGNhX2Rldik7Ci0JCQlicmVhazsKLQkJY2FzZSBTRU5TT1JfT1Y3NjMwOgotCQkJb3Y3NjMwX3Byb2JlKGdzcGNhX2Rldik7Ci0JCQlicmVhazsKLQkJY2FzZSBTRU5TT1JfT1Y3NjQ4OgotCQkJb3Y3NjQ4X3Byb2JlKGdzcGNhX2Rldik7Ci0JCQlicmVhazsKLQkJY2FzZSBTRU5TT1JfUE8yMDMwTjoKLQkJCXBvMjAzMG5fcHJvYmUoZ3NwY2FfZGV2KTsKLQkJCWJyZWFrOwotCQl9Ci0JCXJlZ0dwaW9bMV0gPSAweDcwOwkJLyogbm8gYXVkaW8gKi8KLQkJcmVnX3coZ3NwY2FfZGV2LCAweDAxLCByZWdHcGlvLCAyKTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKIC8qCWNhc2UgQlJJREdFX1NOOUMxMTA6ICovCi0vKgljYXNlIEJSSURHRV9TTjlDMzI1OiAqLworLyoJY2FzZSBCUklER0VfU045QzEyMDogKi8KIAkJaWYgKHJlZ0YxICE9IDB4MTIpCiAJCQlyZXR1cm4gLUVOT0RFVjsKKwl9CisKKwlzd2l0Y2ggKHNkLT5zZW5zb3IpIHsKKwljYXNlIFNFTlNPUl9NSTAzNjA6CisJCW1pMDM2MF9wcm9iZShnc3BjYV9kZXYpOworCQlicmVhazsKKwljYXNlIFNFTlNPUl9PVjc2MzA6CisJCW92NzYzMF9wcm9iZShnc3BjYV9kZXYpOworCQlicmVhazsKKwljYXNlIFNFTlNPUl9PVjc2NDg6CisJCW92NzY0OF9wcm9iZShnc3BjYV9kZXYpOworCQlicmVhazsKKwljYXNlIFNFTlNPUl9QTzIwMzBOOgorCQlwbzIwMzBuX3Byb2JlKGdzcGNhX2Rldik7CisJCWJyZWFrOworCX0KKworCXN3aXRjaCAoc2QtPmJyaWRnZSkgeworCWNhc2UgQlJJREdFX1NOOUMxMDJQOgorCQlyZWdfdzEoZ3NwY2FfZGV2LCAweDAyLCByZWdHcGlvWzFdKTsKKwkJYnJlYWs7CisJY2FzZSBCUklER0VfU045QzEwNToKKwkJcmVnX3coZ3NwY2FfZGV2LCAweDAxLCByZWdHcGlvLCAyKTsKKwkJYnJlYWs7CisJY2FzZSBCUklER0VfU045QzExMDoKIAkJcmVnX3cxKGdzcGNhX2RldiwgMHgwMiwgMHg2Mik7CiAJCWJyZWFrOworCWNhc2UgQlJJREdFX1NOOUMxMjA6CisJCXJlZ0dwaW9bMV0gPSAweDcwOwkJLyogbm8gYXVkaW8gKi8KKwkJcmVnX3coZ3NwY2FfZGV2LCAweDAxLCByZWdHcGlvLCAyKTsKKwkJYnJlYWs7CiAJfQogCiAJaWYgKHNkLT5zZW5zb3IgPT0gU0VOU09SX09NNjgwMikKQEAgLTE4NzQsNiArMTg2Miw4IEBACiAJc2QtPmkyY19hZGRyID0gc245YzF4eFs5XTsKIAogCWdzcGNhX2Rldi0+Y3RybF9kaXMgPSBjdHJsX2Rpc1tzZC0+c2Vuc29yXTsKKwlpZiAoIShzZC0+ZmxhZ3MgJiBGX0lMTFVNKSkKKwkJZ3NwY2FfZGV2LT5jdHJsX2RpcyB8PSAoMSA8PCBJTExVTSk7CiAKIAlyZXR1cm4gZ3NwY2FfZGV2LT51c2JfZXJyOwogfQpAQCAtMjE5NywxNiArMjE4NywyOCBAQAogCXJlZ193MShnc3BjYV9kZXYsIDB4OTksIHNkLT5jdHJsc1tTSEFSUE5FU1NdLnZhbCk7CiB9CiAKLXN0YXRpYyB2b2lkIHNldGluZnJhcmVkKHN0cnVjdCBnc3BjYV9kZXYgKmdzcGNhX2RldikKK3N0YXRpYyB2b2lkIHNldGlsbHVtKHN0cnVjdCBnc3BjYV9kZXYgKmdzcGNhX2RldikKIHsKIAlzdHJ1Y3Qgc2QgKnNkID0gKHN0cnVjdCBzZCAqKSBnc3BjYV9kZXY7CiAKLQlpZiAoZ3NwY2FfZGV2LT5jdHJsX2RpcyAmICgxIDw8IElORlJBUkVEKSkKKwlpZiAoZ3NwY2FfZGV2LT5jdHJsX2RpcyAmICgxIDw8IElMTFVNKSkKIAkJcmV0dXJuOwotLypmaXhtZTogZGlmZmVyZW50IHNlcXVlbmNlIGZvciBTdGFyQ2FtIENsaXAgYW5kIFN0YXJDYW0gMzcwaSAqLwotLyogQ2xpcCAqLwotCWkyY193MShnc3BjYV9kZXYsIDB4MDIsCQkJCS8qIGdwaW8gKi8KLQkJc2QtPmN0cmxzW0lORlJBUkVEXS52YWwgPyAweDY2IDogMHg2NCk7CisJc3dpdGNoIChzZC0+c2Vuc29yKSB7CisJY2FzZSBTRU5TT1JfQURDTTE3MDA6CisJCXJlZ193MShnc3BjYV9kZXYsIDB4MDIsCQkJCS8qIGdwaW8gKi8KKwkJCXNkLT5jdHJsc1tJTExVTV0udmFsID8gMHg2NCA6IDB4NjApOworCQlicmVhazsKKwljYXNlIFNFTlNPUl9NVDlWMTExOgorCQlpZiAoc3RhcmNhbSkKKwkJCXJlZ193MShnc3BjYV9kZXYsIDB4MDIsCisJCQkJc2QtPmN0cmxzW0lMTFVNXS52YWwgPworCQkJCQkJMHg1NSA6IDB4NTQpOwkvKiAzNzBpICovCisJCWVsc2UKKwkJCXJlZ193MShnc3BjYV9kZXYsIDB4MDIsCisJCQkJc2QtPmN0cmxzW0lMTFVNXS52YWwgPworCQkJCQkJMHg2NiA6IDB4NjQpOwkvKiBDbGlwICovCisJCWJyZWFrOworCX0KIH0KIAogc3RhdGljIHZvaWQgc2V0ZnJlcShzdHJ1Y3QgZ3NwY2FfZGV2ICpnc3BjYV9kZXYpCkBAIC0yMzQ0LDcgKzIzNDYsNyBAQAogCS8qIHNlbnNvciBjbG9jayBhbHJlYWR5IGVuYWJsZWQgaW4gc2RfaW5pdCAqLwogCS8qIHJlZ193MShnc3BjYV9kZXYsIDB4ZjEsIDB4MDApOyAqLwogCXJlZzAxID0gc245YzF4eFsxXTsKLQlpZiAoc2QtPmZsYWdzICYgUEROX0lOVikKKwlpZiAoc2QtPmZsYWdzICYgRl9QRE5fSU5WKQogCQlyZWcwMSBePSBTX1BETl9JTlY7CQkvKiBwb3dlciBkb3duIGludmVydGVkICovCiAJcmVnX3cxKGdzcGNhX2RldiwgMHgwMSwgcmVnMDEpOwogCkBAIC0yOTA3LDEzICsyOTA5LDExIEBACiAJLmRyaXZlcl9pbmZvID0gKEJSSURHRV8gIyMgYnJpZGdlIDw8IDE2KSBcCiAJCQl8IChTRU5TT1JfICMjIHNlbnNvciA8PCA4KSBcCiAJCQl8IChmbGFncykKLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewotI2lmICFkZWZpbmVkIENPTkZJR19VU0JfU045QzEwMiAmJiAhZGVmaW5lZCBDT05GSUdfVVNCX1NOOUMxMDJfTU9EVUxFCitzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CiAJe1VTQl9ERVZJQ0UoMHgwNDU4LCAweDcwMjUpLCBCUyhTTjlDMTIwLCBNSTAzNjApfSwKIAl7VVNCX0RFVklDRSgweDA0NTgsIDB4NzAyZSksIEJTKFNOOUMxMjAsIE9WNzY2MCl9LAotI2VuZGlmCi0Je1VTQl9ERVZJQ0UoMHgwNDVlLCAweDAwZjUpLCBCU0YoU045QzEwNSwgT1Y3NjYwLCBQRE5fSU5WKX0sCi0Je1VTQl9ERVZJQ0UoMHgwNDVlLCAweDAwZjcpLCBCU0YoU045QzEwNSwgT1Y3NjYwLCBQRE5fSU5WKX0sCisJe1VTQl9ERVZJQ0UoMHgwNDVlLCAweDAwZjUpLCBCU0YoU045QzEwNSwgT1Y3NjYwLCBGX1BETl9JTlYpfSwKKwl7VVNCX0RFVklDRSgweDA0NWUsIDB4MDBmNyksIEJTRihTTjlDMTA1LCBPVjc2NjAsIEZfUEROX0lOVil9LAogCXtVU0JfREVWSUNFKDB4MDQ3MSwgMHgwMzI3KSwgQlMoU045QzEwNSwgTUkwMzYwKX0sCiAJe1VTQl9ERVZJQ0UoMHgwNDcxLCAweDAzMjgpLCBCUyhTTjlDMTA1LCBNSTAzNjApfSwKIAl7VVNCX0RFVklDRSgweDA0NzEsIDB4MDMzMCksIEJTKFNOOUMxMDUsIE1JMDM2MCl9LApAQCAtMjkyNSw3ICsyOTI1LDcgQEAKIC8qCXtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MDdiKSwgQlMoU045QzEwMlAsIE9WNzY2MCl9LCAqLwogCXtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MDdjKSwgQlMoU045QzEwMlAsIEhWNzEzMVIpfSwKIC8qCXtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MDdlKSwgQlMoU045QzEwMlAsIE9WNzYzMCl9LCAqLwotCXtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MGMwKSwgQlMoU045QzEwNSwgTUkwMzYwKX0sCisJe1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYzApLCBCU0YoU045QzEwNSwgTUkwMzYwLCBGX0lMTFVNKX0sCiAJCQkJCQkvKiBvciBNVDlWMTExICovCiAvKgl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjBjMiksIEJTKFNOOUMxMDUsIFAxMDMweEMpfSwgKi8KIC8qCXtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MGM4KSwgQlMoU045QzEwNSwgT002ODAyKX0sICovCkBAIC0yOTM2LDEwICsyOTM2LDggQEAKIC8qCXtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MGZhKSwgQlMoU045QzEwNSwgT1Y3NjQ4KX0sICovCiAvKgl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjBmMiksIEJTKFNOOUMxMDUsIE9WNzY2MCl9LCAqLwogCXtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MGZiKSwgQlMoU045QzEwNSwgT1Y3NjYwKX0sCi0jaWYgIWRlZmluZWQgQ09ORklHX1VTQl9TTjlDMTAyICYmICFkZWZpbmVkIENPTkZJR19VU0JfU045QzEwMl9NT0RVTEUKIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjBmYyksIEJTKFNOOUMxMDUsIEhWNzEzMVIpfSwKIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjBmZSksIEJTKFNOOUMxMDUsIE9WNzYzMCl9LAotI2VuZGlmCiAJe1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYxMDApLCBCUyhTTjlDMTIwLCBNSTAzNjApfSwJLypzbjljMTI4Ki8KIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjEwMiksIEJTKFNOOUMxMjAsIFBPMjAzME4pfSwJLyogL0dDMDMwNSovCiAvKgl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjEwOCksIEJTKFNOOUMxMjAsIE9NNjgwMil9LCAqLwpAQCAtMjk2MiwxNiArMjk2MCwxNSBAQAogLyoJe1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYxMzIpLCBCUyhTTjlDMTIwLCBPVjc2NzApfSwgKi8KIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjEzOCksIEJTKFNOOUMxMjAsIE1PNDAwMCl9LAogCXtVU0JfREVWSUNFKDB4MGM0NSwgMHg2MTNhKSwgQlMoU045QzEyMCwgT1Y3NjQ4KX0sCi0jaWYgIWRlZmluZWQgQ09ORklHX1VTQl9TTjlDMTAyICYmICFkZWZpbmVkIENPTkZJR19VU0JfU045QzEwMl9NT0RVTEUKIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjEzYiksIEJTKFNOOUMxMjAsIE9WNzY2MCl9LAotI2VuZGlmCiAJe1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYxM2MpLCBCUyhTTjlDMTIwLCBIVjcxMzFSKX0sCiAJe1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYxM2UpLCBCUyhTTjlDMTIwLCBPVjc2MzApfSwKIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjE0MiksIEJTKFNOOUMxMjAsIFBPMjAzME4pfSwJLypzbjljMTIwYiovCiAJCQkJCQkvKiBvciBHQzAzMDUgLyBHQzAzMDcgKi8KIAl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjE0MyksIEJTKFNOOUMxMjAsIFNQODA3MDgpfSwJLypzbjljMTIwYiovCiAJe1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYxNDgpLCBCUyhTTjlDMTIwLCBPTTY4MDIpfSwJLypzbjljMTIwYiovCi0Je1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYxNGEpLCBCUyhTTjlDMTIwLCBBRENNMTcwMCl9LAkvKnNuOWMxMjBiKi8KKwl7VVNCX0RFVklDRSgweDBjNDUsIDB4NjE0YSksIEJTRihTTjlDMTIwLCBBRENNMTcwMCwgRl9JTExVTSl9LAorLyoJe1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYxNGMpLCBCUyhTTjlDMTIwLCBHQzAzMDYpfSwgKi8JLypzbjljMTIwYiovCiAJe30KIH07CiBNT0RVTEVfREVWSUNFX1RBQkxFKHVzYiwgZGV2aWNlX3RhYmxlKTsKQEAgLTMwMDcsMyArMzAwNCw3IEBACiAKIG1vZHVsZV9pbml0KHNkX21vZF9pbml0KTsKIG1vZHVsZV9leGl0KHNkX21vZF9leGl0KTsKKworbW9kdWxlX3BhcmFtKHN0YXJjYW0sIGludCwgMDY0NCk7CitNT0RVTEVfUEFSTV9ERVNDKHN0YXJjYW0sCisJIlN0YXJDYW0gbW9kZWwuIDA6IENsaXAsIDE6IDM3MGkiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3BjYTE1MjguYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3BjYTE1MjguYwppbmRleCBlNjQzMzg2Li43NmMwMDZiIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2ExNTI4LmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcGNhMTUyOC5jCkBAIC01NTUsNyArNTU1LDcgQEAKIH07CiAKIC8qIC0tIG1vZHVsZSBpbml0aWFsaXNhdGlvbiAtLSAqLwotc3RhdGljIGNvbnN0IF9fZGV2aW5pdGRhdGEgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CiAJe1VTQl9ERVZJQ0UoMHgwNGZjLCAweDE1MjgpfSwKIAl7fQogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3BjYTUwMC5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcGNhNTAwLmMKaW5kZXggOGUyMDJiOS4uNDU1NTJjMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcGNhNTAwLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcGNhNTAwLmMKQEAgLTEwNTEsNyArMTA1MSw3IEBACiB9OwogCiAvKiAtLSBtb2R1bGUgaW5pdGlhbGlzYXRpb24gLS0gKi8KLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MDQwYSwgMHgwMzAwKSwgLmRyaXZlcl9pbmZvID0gS29kYWtFWjIwMH0sCiAJe1VTQl9ERVZJQ0UoMHgwNDFlLCAweDQwMGEpLCAuZHJpdmVyX2luZm8gPSBDcmVhdGl2ZVBDQ2FtMzAwfSwKIAl7VVNCX0RFVklDRSgweDA0NmQsIDB4MDg5MCksIC5kcml2ZXJfaW5mbyA9IExvZ2l0ZWNoVHJhdmVsZXJ9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcGNhNTAxLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2E1MDEuYwppbmRleCA2NDI4MzlhLi5mN2VmMjgyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2E1MDEuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2E1MDEuYwpAQCAtMjE1NSw3ICsyMTU1LDcgQEAKIH07CiAKIC8qIC0tIG1vZHVsZSBpbml0aWFsaXNhdGlvbiAtLSAqLwotc3RhdGljIGNvbnN0IF9fZGV2aW5pdGRhdGEgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CiAJe1VTQl9ERVZJQ0UoMHgwNDBhLCAweDAwMDIpLCAuZHJpdmVyX2luZm8gPSBLb2Rha0RWQzMyNX0sCiAJe1VTQl9ERVZJQ0UoMHgwNDk3LCAweGMwMDEpLCAuZHJpdmVyX2luZm8gPSBTbWlsZUludGxDYW1lcmF9LAogCXtVU0JfREVWSUNFKDB4MDUwNiwgMHgwMGRmKSwgLmRyaXZlcl9pbmZvID0gVGhyZWVDb21Ib21lQ29ubmVjdExpdGV9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcGNhNTA1LmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2E1MDUuYwppbmRleCBiYzlkZDkwLi5lNWJmODY1IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2E1MDUuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2E1MDUuYwpAQCAtNzg2LDcgKzc4Niw3IEBACiB9OwogCiAvKiAtLSBtb2R1bGUgaW5pdGlhbGlzYXRpb24gLS0gKi8KLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MDQxZSwgMHg0MDFkKSwgLmRyaXZlcl9pbmZvID0gTnh1bHRyYX0sCiAJe1VTQl9ERVZJQ0UoMHgwNzMzLCAweDA0MzApLCAuZHJpdmVyX2luZm8gPSBJbnRlbFBDQ2FtZXJhUHJvfSwKIC8qZml4bWU6IG1heSBiZSBVc2JHcmFiYmVyUFYzMjEgQlJJREdFX1NQQ0E1MDYgU0VOU09SX1NBQTcxMTMgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3BjYTUwOC5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcGNhNTA4LmMKaW5kZXggNzMwNzYzOC4uMzQ4MzE5MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcGNhNTA4LmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcGNhNTA4LmMKQEAgLTE1MDksNyArMTUwOSw3IEBACiB9OwogCiAvKiAtLSBtb2R1bGUgaW5pdGlhbGlzYXRpb24gLS0gKi8KLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MDEzMCwgMHgwMTMwKSwgLmRyaXZlcl9pbmZvID0gSGFtYVVTQlNpZ2h0Y2FtfSwKIAl7VVNCX0RFVklDRSgweDA0MWUsIDB4NDAxOCksIC5kcml2ZXJfaW5mbyA9IENyZWF0aXZlVmlzdGF9LAogCXtVU0JfREVWSUNFKDB4MDczMywgMHgwMTEwKSwgLmRyaXZlcl9pbmZvID0gVmlld1F1ZXN0VlExMTB9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcGNhNTYxLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2E1NjEuYwppbmRleCAzYTE2MmM2Li5lODM2ZTc3IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2E1NjEuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NwY2E1NjEuYwpAQCAtMTA2MSw3ICsxMDYxLDcgQEAKIH07CiAKIC8qIC0tIG1vZHVsZSBpbml0aWFsaXNhdGlvbiAtLSAqLwotc3RhdGljIGNvbnN0IF9fZGV2aW5pdGRhdGEgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CiAJe1VTQl9ERVZJQ0UoMHgwNDFlLCAweDQwMWEpLCAuZHJpdmVyX2luZm8gPSBSZXYwNzJBfSwKIAl7VVNCX0RFVklDRSgweDA0MWUsIDB4NDAzYiksIC5kcml2ZXJfaW5mbyA9IFJldjAxMkF9LAogCXtVU0JfREVWSUNFKDB4MDQ1OCwgMHg3MDA0KSwgLmRyaXZlcl9pbmZvID0gUmV2MDcyQX0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NxOTA1LmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NxOTA1LmMKaW5kZXggNDA0MDY3Ny4uMmU5YzA2MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcTkwNS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3E5MDUuYwpAQCAtMzk2LDcgKzM5Niw3IEBACiB9CiAKIC8qIFRhYmxlIG9mIHN1cHBvcnRlZCBVU0IgZGV2aWNlcyAqLwotc3RhdGljIGNvbnN0IF9fZGV2aW5pdGRhdGEgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CiAJe1VTQl9ERVZJQ0UoMHgyNzcwLCAweDkxMjApfSwKIAl7fQogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3E5MDVjLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NxOTA1Yy5jCmluZGV4IDhiYTE5OTUuLjQ1NzU2M2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3E5MDVjLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcTkwNWMuYwpAQCAtMjk4LDcgKzI5OCw3IEBACiB9CiAKIC8qIFRhYmxlIG9mIHN1cHBvcnRlZCBVU0IgZGV2aWNlcyAqLwotc3RhdGljIGNvbnN0IF9fZGV2aW5pdGRhdGEgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CiAJe1VTQl9ERVZJQ0UoMHgyNzcwLCAweDkwNWMpfSwKIAl7VVNCX0RFVklDRSgweDI3NzAsIDB4OTA1MCl9LAogCXtVU0JfREVWSUNFKDB4Mjc3MCwgMHg5MDUxKX0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NxOTMweC5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zcTkzMHguYwppbmRleCBhNGE5ODgxLi44MjE1ZDVkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3NxOTMweC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3E5MzB4LmMKQEAgLTExNjMsNyArMTE2Myw3IEBACiAjZGVmaW5lIFNUKHNlbnNvciwgdHlwZSkgXAogCS5kcml2ZXJfaW5mbyA9IChTRU5TT1JfICMjIHNlbnNvciA8PCA4KSBcCiAJCQl8ICh0eXBlKQotc3RhdGljIGNvbnN0IF9fZGV2aW5pdGRhdGEgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CiAJe1VTQl9ERVZJQ0UoMHgwNDFlLCAweDQwMzgpLCBTVChNSTAzNjAsIDApfSwKIAl7VVNCX0RFVklDRSgweDA0MWUsIDB4NDAzYyksIFNUKExaMjRCUCwgMCl9LAogCXtVU0JfREVWSUNFKDB4MDQxZSwgMHg0MDNkKSwgU1QoTFoyNEJQLCAwKX0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3N0azAxNC5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zdGswMTQuYwppbmRleCAxMWExOTJiLi44N2JlNTJiIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3N0azAxNC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3RrMDE0LmMKQEAgLTQ5NSw3ICs0OTUsNyBAQAogfTsKIAogLyogLS0gbW9kdWxlIGluaXRpYWxpc2F0aW9uIC0tICovCi1zdGF0aWMgY29uc3QgX19kZXZpbml0ZGF0YSBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKIAl7VVNCX0RFVklDRSgweDA1ZTEsIDB4MDg5Myl9LAogCXt9CiB9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zdHYwNjgwLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3N0djA2ODAuYwppbmRleCBiMTk5YWQ0Li5lMmVmNDFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3N0djA2ODAuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3N0djA2ODAuYwpAQCAtMzI3LDcgKzMyNyw3IEBACiB9OwogCiAvKiAtLSBtb2R1bGUgaW5pdGlhbGlzYXRpb24gLS0gKi8KLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MDU1MywgMHgwMjAyKX0sCiAJe1VTQl9ERVZJQ0UoMHgwNDFlLCAweDQwMDcpfSwKIAl7fQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zdHYwNnh4L3N0djA2eHguYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2Evc3R2MDZ4eC9zdHYwNnh4LmMKaW5kZXggMjhlYTQxNy4uN2UwNjYxNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zdHYwNnh4L3N0djA2eHguYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3N0djA2eHgvc3R2MDZ4eC5jCkBAIC01NjQsNyArNTY0LDcgQEAKIAogCiAvKiAtLSBtb2R1bGUgaW5pdGlhbGlzYXRpb24gLS0gKi8KLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCS8qIFF1aWNrQ2FtIEV4cHJlc3MgKi8KIAl7VVNCX0RFVklDRSgweDA0NmQsIDB4MDg0MCksIC5kcml2ZXJfaW5mbyA9IEJSSURHRV9TVFY2MDAgfSwKIAkvKiBMRUdPIGNhbSAvIFF1aWNrQ2FtIFdlYiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS9zdW5wbHVzLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3N1bnBsdXMuYwppbmRleCBhOWNiY2Q2Li41NDM1NDJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3N1bnBsdXMuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3N1bnBsdXMuYwpAQCAtMTE2Miw3ICsxMTYyLDcgQEAKICNkZWZpbmUgQlMoYnJpZGdlLCBzdWJ0eXBlKSBcCiAJLmRyaXZlcl9pbmZvID0gKEJSSURHRV8gIyMgYnJpZGdlIDw8IDgpIFwKIAkJCXwgKHN1YnR5cGUpCi1zdGF0aWMgY29uc3QgX19kZXZpbml0ZGF0YSBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKIAl7VVNCX0RFVklDRSgweDA0MWUsIDB4NDAwYiksIEJTKFNQQ0E1MDRDLCAwKX0sCiAJe1VTQl9ERVZJQ0UoMHgwNDFlLCAweDQwMTIpLCBCUyhTUENBNTA0QywgMCl9LAogCXtVU0JfREVWSUNFKDB4MDQxZSwgMHg0MDEzKSwgQlMoU1BDQTUwNEMsIDApfSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvdDYxMy5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS90NjEzLmMKaW5kZXggOGYwYzMzMS4uYTNlY2NkOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS90NjEzLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS90NjEzLmMKQEAgLTE0MTYsNyArMTQxNiw3IEBACiB9OwogCiAvKiAtLSBtb2R1bGUgaW5pdGlhbGlzYXRpb24gLS0gKi8KLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MTdhMSwgMHgwMTI4KX0sCiAJe30KIH07CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3R2ODUzMi5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS90djg1MzIuYwppbmRleCAzOGMyMmYwLi45MzNlZjJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3R2ODUzMi5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvdHY4NTMyLmMKQEAgLTM4OCw3ICszODgsNyBAQAogfTsKIAogLyogLS0gbW9kdWxlIGluaXRpYWxpc2F0aW9uIC0tICovCi1zdGF0aWMgY29uc3QgX19kZXZpbml0ZGF0YSBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2RldmljZV9pZCBkZXZpY2VfdGFibGVbXSA9IHsKIAl7VVNCX0RFVklDRSgweDA0NmQsIDB4MDkyMCl9LAogCXtVU0JfREVWSUNFKDB4MDQ2ZCwgMHgwOTIxKX0sCiAJe1VTQl9ERVZJQ0UoMHgwNTQ1LCAweDgwOGIpfSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvdmMwMzJ4LmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3ZjMDMyeC5jCmluZGV4IDliMmFlMWIuLjZjYWVkNzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvdmMwMzJ4LmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS92YzAzMnguYwpAQCAtNDE5Miw3ICs0MTkyLDcgQEAKICNkZWZpbmUgQkYoYnJpZGdlLCBmbGFncykgXAogCS5kcml2ZXJfaW5mbyA9IChCUklER0VfICMjIGJyaWRnZSA8PCA4KSBcCiAJCXwgKGZsYWdzKQotc3RhdGljIGNvbnN0IF9fZGV2aW5pdGRhdGEgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaWQgZGV2aWNlX3RhYmxlW10gPSB7CiAJe1VTQl9ERVZJQ0UoMHgwNDFlLCAweDQwNWIpLCBCRihWQzAzMjMsIEZMX1ZGTElQKX0sCiAJe1VTQl9ERVZJQ0UoMHgwNDZkLCAweDA4OTIpLCBCRihWQzAzMjEsIDApfSwKIAl7VVNCX0RFVklDRSgweDA0NmQsIDB4MDg5NiksIEJGKFZDMDMyMSwgMCl9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS94aXJsaW5rX2NpdC5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS94aXJsaW5rX2NpdC5jCmluZGV4IDViNTAzOWEuLmMwODlhMGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EveGlybGlua19jaXQuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3hpcmxpbmtfY2l0LmMKQEAgLTMyNzAsNyArMzI3MCw3IEBACiB9OwogCiAvKiAtLSBtb2R1bGUgaW5pdGlhbGlzYXRpb24gLS0gKi8KLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXsgVVNCX0RFVklDRV9WRVIoMHgwNTQ1LCAweDgwODAsIDB4MDAwMSwgMHgwMDAxKSwgLmRyaXZlcl9pbmZvID0gQ0lUX01PREVMMCB9LAogCXsgVVNCX0RFVklDRV9WRVIoMHgwNTQ1LCAweDgwODAsIDB4MDAwMiwgMHgwMDAyKSwgLmRyaXZlcl9pbmZvID0gQ0lUX01PREVMMSB9LAogCXsgVVNCX0RFVklDRV9WRVIoMHgwNTQ1LCAweDgwODAsIDB4MDMwYSwgMHgwMzBhKSwgLmRyaXZlcl9pbmZvID0gQ0lUX01PREVMMiB9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS96YzN4eC5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9nc3BjYS96YzN4eC5jCmluZGV4IDE0Yjg1ZDQuLjQ3MjM2YTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vZ3NwY2EvemMzeHguYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2dzcGNhL3pjM3h4LmMKQEAgLTU3OTMsNyArNTc5Myw3IEBACiAJCQlicmVhazsKIAkJZGVmYXVsdDoKIC8qCQljYXNlIDB4ZGQ6CSAqIGRlbGF5ICovCi0JCQltc2xlZXAoYWN0aW9uLT52YWwgLyA2NCArIDEwKTsKKwkJCW1zbGVlcChhY3Rpb24tPmlkeCk7CiAJCQlicmVhazsKIAkJfQogCQlhY3Rpb24rKzsKQEAgLTU4MzAsNyArNTgzMCw3IEBACiAJCVtTRU5TT1JfR0MwMzA1XSA9CWdjMDMwNV9tYXRyaXgsCiAJCVtTRU5TT1JfSERDUzIwMjBiXSA9CU5VTEwsCiAJCVtTRU5TT1JfSFY3MTMxQl0gPQlOVUxMLAotCQlbU0VOU09SX0hWNzEzMVJdID0JTlVMTCwKKwkJW1NFTlNPUl9IVjcxMzFSXSA9CXBvMjAzMF9tYXRyaXgsCiAJCVtTRU5TT1JfSUNNMTA1QV0gPQlwbzIwMzBfbWF0cml4LAogCQlbU0VOU09SX01DNTAxQ0JdID0JTlVMTCwKIAkJW1NFTlNPUl9NVDlWMTExXzFdID0JZ2MwMzA1X21hdHJpeCwKQEAgLTU5MzYsNiArNTkzNiw3IEBACiAJY2FzZSBTRU5TT1JfQURDTTI3MDA6CiAJY2FzZSBTRU5TT1JfR0MwMzA1OgogCWNhc2UgU0VOU09SX0hWNzEzMUI6CisJY2FzZSBTRU5TT1JfSFY3MTMxUjoKIAljYXNlIFNFTlNPUl9PVjc2MjA6CiAJY2FzZSBTRU5TT1JfUEFTMjAyQjoKIAljYXNlIFNFTlNPUl9QTzIwMzA6CkBAIC02MTA4LDExICs2MTA5LDEzIEBACiAJCXJlZ193KGdzcGNhX2RldiwgMHgwMiwgMHgwMDNiKTsKIAkJcmVnX3coZ3NwY2FfZGV2LCAweDAwLCAweDAwMzgpOwogCQlicmVhazsKKwljYXNlIFNFTlNPUl9IVjcxMzFSOgogCWNhc2UgU0VOU09SX1BBUzIwMkI6CiAJCXJlZ193KGdzcGNhX2RldiwgMHgwMywgMHgwMDNiKTsKIAkJcmVnX3coZ3NwY2FfZGV2LCAweDBjLCAweDAwM2EpOwogCQlyZWdfdyhnc3BjYV9kZXYsIDB4MGIsIDB4MDAzOSk7Ci0JCXJlZ193KGdzcGNhX2RldiwgMHgwYiwgMHgwMDM4KTsKKwkJaWYgKHNlbnNvciA9PSBTRU5TT1JfUEFTMjAyQikKKwkJCXJlZ193KGdzcGNhX2RldiwgMHgwYiwgMHgwMDM4KTsKIAkJYnJlYWs7CiAJfQogfQpAQCAtNjcwNCwxMCArNjcwNywxMyBAQAogCQlyZWdfdyhnc3BjYV9kZXYsIDB4MDIsIDB4MDAzYik7CiAJCXJlZ193KGdzcGNhX2RldiwgMHgwMCwgMHgwMDM4KTsKIAkJYnJlYWs7CisJY2FzZSBTRU5TT1JfSFY3MTMxUjoKIAljYXNlIFNFTlNPUl9QQVMyMDJCOgogCQlyZWdfdyhnc3BjYV9kZXYsIDB4MDMsIDB4MDAzYik7CiAJCXJlZ193KGdzcGNhX2RldiwgMHgwYywgMHgwMDNhKTsKIAkJcmVnX3coZ3NwY2FfZGV2LCAweDBiLCAweDAwMzkpOworCQlpZiAoc2QtPnNlbnNvciA9PSBTRU5TT1JfSFY3MTMxUikKKwkJCXJlZ193KGdzcGNhX2RldiwgMHg1MCwgWkMzWFhfUjExRF9HTE9CQUxHQUlOKTsKIAkJYnJlYWs7CiAJfQogCkBAIC02NzIwLDYgKzY3MjYsNyBAQAogCQlicmVhazsKIAljYXNlIFNFTlNPUl9QQVMyMDJCOgogCWNhc2UgU0VOU09SX0dDMDMwNToKKwljYXNlIFNFTlNPUl9IVjcxMzFSOgogCWNhc2UgU0VOU09SX1RBUzUxMzBDOgogCQlyZWdfcihnc3BjYV9kZXYsIDB4MDAwOCk7CiAJCS8qIGZhbGwgdGhydSAqLwpAQCAtNjc2MCw2ICs2NzY3LDEyIEBACiAJCQkJCQkvKiBtcy13aW4gKyAqLwogCQlyZWdfdyhnc3BjYV9kZXYsIDB4NDAsIDB4MDExNyk7CiAJCWJyZWFrOworCWNhc2UgU0VOU09SX0hWNzEzMVI6CisJCWkyY193cml0ZShnc3BjYV9kZXYsIDB4MjUsIDB4MDQsIDB4MDApOwkvKiBleHBvc3VyZSAqLworCQlpMmNfd3JpdGUoZ3NwY2FfZGV2LCAweDI2LCAweDkzLCAweDAwKTsKKwkJaTJjX3dyaXRlKGdzcGNhX2RldiwgMHgyNywgMHhlMCwgMHgwMCk7CisJCXJlZ193KGdzcGNhX2RldiwgMHgwMCwgWkMzWFhfUjFBN19DQUxDR0xPQkFMTUVBTik7CisJCWJyZWFrOwogCWNhc2UgU0VOU09SX0dDMDMwNToKIAljYXNlIFNFTlNPUl9UQVM1MTMwQzoKIAkJcmVnX3coZ3NwY2FfZGV2LCAweDA5LCAweDAxYWQpOwkvKiAoZnJvbSB3aW4gdHJhY2VzKSAqLwpAQCAtNjgwOCw5ICs2ODIxLDE3IEBACiB7CiAJc3RydWN0IHNkICpzZCA9IChzdHJ1Y3Qgc2QgKikgZ3NwY2FfZGV2OwogCi0JaWYgKGRhdGFbMF0gPT0gMHhmZiAmJiBkYXRhWzFdID09IDB4ZDgpIHsJLyogc3RhcnQgb2YgZnJhbWUgKi8KKwkvKiBjaGVjayB0aGUgSlBFRyBlbmQgb2YgZnJhbWUgKi8KKwlpZiAobGVuID49IDMKKwkgJiYgZGF0YVtsZW4gLSAzXSA9PSAweGZmICYmIGRhdGFbbGVuIC0gMl0gPT0gMHhkOSkgeworLypmaXhtZTogd2hhdCBkb2VzIHRoZSBsYXN0IGJ5dGUgbWVhbj8qLwogCQlnc3BjYV9mcmFtZV9hZGQoZ3NwY2FfZGV2LCBMQVNUX1BBQ0tFVCwKLQkJCQkJTlVMTCwgMCk7CisJCQkJCWRhdGEsIGxlbiAtIDEpOworCQlyZXR1cm47CisJfQorCisJLyogY2hlY2sgdGhlIEpQRUcgc3RhcnQgb2YgYSBmcmFtZSAqLworCWlmIChkYXRhWzBdID09IDB4ZmYgJiYgZGF0YVsxXSA9PSAweGQ4KSB7CiAJCS8qIHB1dCB0aGUgSlBFRyBoZWFkZXIgaW4gdGhlIG5ldyBmcmFtZSAqLwogCQlnc3BjYV9mcmFtZV9hZGQoZ3NwY2FfZGV2LCBGSVJTVF9QQUNLRVQsCiAJCQlzZC0+anBlZ19oZHIsIEpQRUdfSERSX1NaKTsKQEAgLTY5MDksNyArNjkzMCw3IEBACiAjZW5kaWYKIH07CiAKLXN0YXRpYyBjb25zdCBfX2RldmluaXRkYXRhIHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0geworc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIGRldmljZV90YWJsZVtdID0gewogCXtVU0JfREVWSUNFKDB4MDQxZSwgMHgwNDFlKX0sCiAJe1VTQl9ERVZJQ0UoMHgwNDFlLCAweDQwMTcpfSwKIAl7VVNCX0RFVklDRSgweDA0MWUsIDB4NDAxYyksIC5kcml2ZXJfaW5mbyA9IFNFTlNPUl9QQVMxMDZ9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9oZHB2ci9NYWtlZmlsZSBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vaGRwdnIvTWFrZWZpbGUKaW5kZXggZTAyMzBmYy4uM2JhYTlmNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9oZHB2ci9NYWtlZmlsZQorKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2hkcHZyL01ha2VmaWxlCkBAIC0xLDYgKzEsNCBAQAotaGRwdnItb2Jqcwk6PSBoZHB2ci1jb250cm9sLm8gaGRwdnItY29yZS5vIGhkcHZyLXZpZGVvLm8KLQotaGRwdnItJChDT05GSUdfSTJDKSArPSBoZHB2ci1pMmMubworaGRwdnItb2Jqcwk6PSBoZHB2ci1jb250cm9sLm8gaGRwdnItY29yZS5vIGhkcHZyLXZpZGVvLm8gaGRwdnItaTJjLm8KIAogb2JqLSQoQ09ORklHX1ZJREVPX0hEUFZSKSArPSBoZHB2ci5vCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vaGRwdnIvaGRwdnItY29yZS5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9oZHB2ci9oZHB2ci1jb3JlLmMKaW5kZXggZjdkMWVlNS4uYTI3ZDkzYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9oZHB2ci9oZHB2ci1jb3JlLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9oZHB2ci9oZHB2ci1jb3JlLmMKQEAgLTI4Myw2ICsyODMsNyBAQAogCXN0cnVjdCBoZHB2cl9kZXZpY2UgKmRldjsKIAlzdHJ1Y3QgdXNiX2hvc3RfaW50ZXJmYWNlICppZmFjZV9kZXNjOwogCXN0cnVjdCB1c2JfZW5kcG9pbnRfZGVzY3JpcHRvciAqZW5kcG9pbnQ7CisJc3RydWN0IGkyY19jbGllbnQgKmNsaWVudDsKIAlzaXplX3QgYnVmZmVyX3NpemU7CiAJaW50IGk7CiAJaW50IHJldHZhbCA9IC1FTk9NRU07CkBAIC0zNzgsMjUgKzM3OSwzNSBAQAogCQlnb3RvIGVycm9yOwogCX0KIAotI2lmZGVmIENPTkZJR19JMkMKLQkvKiB1bnRpbCBpMmMgaXMgd29ya2luZyBwcm9wZXJseSAqLwotCXJldHZhbCA9IDA7IC8qIGhkcHZyX3JlZ2lzdGVyX2kyY19hZGFwdGVyKGRldik7ICovCisjaWYgZGVmaW5lZChDT05GSUdfSTJDKSB8fCBkZWZpbmVkKENPTkZJR19JMkNfTU9EVUxFKQorCXJldHZhbCA9IGhkcHZyX3JlZ2lzdGVyX2kyY19hZGFwdGVyKGRldik7CiAJaWYgKHJldHZhbCA8IDApIHsKLQkJdjRsMl9lcnIoJmRldi0+djRsMl9kZXYsICJyZWdpc3RlcmluZyBpMmMgYWRhcHRlciBmYWlsZWRcbiIpOworCQl2NGwyX2VycigmZGV2LT52NGwyX2RldiwgImkyYyBhZGFwdGVyIHJlZ2lzdGVyIGZhaWxlZFxuIik7CiAJCWdvdG8gZXJyb3I7CiAJfQogCi0JLyogdW50aWwgaTJjIGlzIHdvcmtpbmcgcHJvcGVybHkgKi8KLQlyZXR2YWwgPSAwOyAvKiBoZHB2cl9yZWdpc3Rlcl9pMmNfaXIoZGV2KTsgKi8KLQlpZiAocmV0dmFsIDwgMCkKLQkJdjRsMl9lcnIoJmRldi0+djRsMl9kZXYsICJyZWdpc3RlcmluZyBpMmMgSVIgZGV2aWNlcyBmYWlsZWRcbiIpOwotI2VuZGlmIC8qIENPTkZJR19JMkMgKi8KKwljbGllbnQgPSBoZHB2cl9yZWdpc3Rlcl9pcl9yeF9pMmMoZGV2KTsKKwlpZiAoIWNsaWVudCkgeworCQl2NGwyX2VycigmZGV2LT52NGwyX2RldiwgImkyYyBJUiBSWCBkZXZpY2UgcmVnaXN0ZXIgZmFpbGVkXG4iKTsKKwkJZ290byByZWdfZmFpbDsKKwl9CisKKwljbGllbnQgPSBoZHB2cl9yZWdpc3Rlcl9pcl90eF9pMmMoZGV2KTsKKwlpZiAoIWNsaWVudCkgeworCQl2NGwyX2VycigmZGV2LT52NGwyX2RldiwgImkyYyBJUiBUWCBkZXZpY2UgcmVnaXN0ZXIgZmFpbGVkXG4iKTsKKwkJZ290byByZWdfZmFpbDsKKwl9CisjZW5kaWYKIAogCS8qIGxldCB0aGUgdXNlciBrbm93IHdoYXQgbm9kZSB0aGlzIGRldmljZSBpcyBub3cgYXR0YWNoZWQgdG8gKi8KIAl2NGwyX2luZm8oJmRldi0+djRsMl9kZXYsICJkZXZpY2Ugbm93IGF0dGFjaGVkIHRvICVzXG4iLAogCQkgIHZpZGVvX2RldmljZV9ub2RlX25hbWUoZGV2LT52aWRlb19kZXYpKTsKIAlyZXR1cm4gMDsKIAorcmVnX2ZhaWw6CisjaWYgZGVmaW5lZChDT05GSUdfSTJDKSB8fCBkZWZpbmVkKENPTkZJR19JMkNfTU9EVUxFKQorCWkyY19kZWxfYWRhcHRlcigmZGV2LT5pMmNfYWRhcHRlcik7CisjZW5kaWYKIGVycm9yOgogCWlmIChkZXYpIHsKIAkJLyogRGVzdHJveSBzaW5nbGUgdGhyZWFkICovCkBAIC00MjYsNiArNDM3LDkgQEAKIAltdXRleF9sb2NrKCZkZXYtPmlvX211dGV4KTsKIAloZHB2cl9jYW5jZWxfcXVldWUoZGV2KTsKIAltdXRleF91bmxvY2soJmRldi0+aW9fbXV0ZXgpOworI2lmIGRlZmluZWQoQ09ORklHX0kyQykgfHwgZGVmaW5lZChDT05GSUdfSTJDX01PRFVMRSkKKwlpMmNfZGVsX2FkYXB0ZXIoJmRldi0+aTJjX2FkYXB0ZXIpOworI2VuZGlmCiAJdmlkZW9fdW5yZWdpc3Rlcl9kZXZpY2UoZGV2LT52aWRlb19kZXYpOwogCWF0b21pY19kZWMoJmRldl9ucik7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2hkcHZyL2hkcHZyLWkyYy5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9oZHB2ci9oZHB2ci1pMmMuYwppbmRleCAyNDk2NmFhLi5lNTNmYTU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2hkcHZyL2hkcHZyLWkyYy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vaGRwdnIvaGRwdnItaTJjLmMKQEAgLTEzLDYgKzEzLDggQEAKICAqCiAgKi8KIAorI2lmIGRlZmluZWQoQ09ORklHX0kyQykgfHwgZGVmaW5lZChDT05GSUdfSTJDX01PRFVMRSkKKwogI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KIApAQCAtMjgsMTA2ICszMCw4NiBAQAogI2RlZmluZSBaOEYwODExX0lSX1RYX0kyQ19BRERSCTB4NzAKICNkZWZpbmUgWjhGMDgxMV9JUl9SWF9JMkNfQUREUgkweDcxCiAKLXN0YXRpYyBjb25zdCB1OCBpcl9pMmNfYWRkcnNbXSA9IHsKLQlaOEYwODExX0lSX1RYX0kyQ19BRERSLAotCVo4RjA4MTFfSVJfUlhfSTJDX0FERFIsCi19OwogCi1zdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGlyX2RldmljZW5hbWVzW10gPSB7Ci0JImlyX3R4X3o4ZjA4MTFfaGRwdnIiLAotCSJpcl9yeF96OGYwODExX2hkcHZyIiwKLX07Ci0KLXN0YXRpYyBpbnQgaGRwdnJfbmV3X2kyY19pcihzdHJ1Y3QgaGRwdnJfZGV2aWNlICpkZXYsIHN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcCwKLQkJCSAgICBjb25zdCBjaGFyICp0eXBlLCB1OCBhZGRyKQorc3RydWN0IGkyY19jbGllbnQgKmhkcHZyX3JlZ2lzdGVyX2lyX3R4X2kyYyhzdHJ1Y3QgaGRwdnJfZGV2aWNlICpkZXYpCiB7Ci0Jc3RydWN0IGkyY19ib2FyZF9pbmZvIGluZm87CiAJc3RydWN0IElSX2kyY19pbml0X2RhdGEgKmluaXRfZGF0YSA9ICZkZXYtPmlyX2kyY19pbml0X2RhdGE7Ci0JdW5zaWduZWQgc2hvcnQgYWRkcl9saXN0WzJdID0geyBhZGRyLCBJMkNfQ0xJRU5UX0VORCB9OworCXN0cnVjdCBpMmNfYm9hcmRfaW5mbyBoZHB2cl9pcl90eF9pMmNfYm9hcmRfaW5mbyA9IHsKKwkJSTJDX0JPQVJEX0lORk8oImlyX3R4X3o4ZjA4MTFfaGRwdnIiLCBaOEYwODExX0lSX1RYX0kyQ19BRERSKSwKKwl9OwogCi0JbWVtc2V0KCZpbmZvLCAwLCBzaXplb2Yoc3RydWN0IGkyY19ib2FyZF9pbmZvKSk7Ci0Jc3RybGNweShpbmZvLnR5cGUsIHR5cGUsIEkyQ19OQU1FX1NJWkUpOworCWluaXRfZGF0YS0+bmFtZSA9ICJIRC1QVlIiOworCWhkcHZyX2lyX3R4X2kyY19ib2FyZF9pbmZvLnBsYXRmb3JtX2RhdGEgPSBpbml0X2RhdGE7CisKKwlyZXR1cm4gaTJjX25ld19kZXZpY2UoJmRldi0+aTJjX2FkYXB0ZXIsICZoZHB2cl9pcl90eF9pMmNfYm9hcmRfaW5mbyk7Cit9CisKK3N0cnVjdCBpMmNfY2xpZW50ICpoZHB2cl9yZWdpc3Rlcl9pcl9yeF9pMmMoc3RydWN0IGhkcHZyX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBJUl9pMmNfaW5pdF9kYXRhICppbml0X2RhdGEgPSAmZGV2LT5pcl9pMmNfaW5pdF9kYXRhOworCXN0cnVjdCBpMmNfYm9hcmRfaW5mbyBoZHB2cl9pcl9yeF9pMmNfYm9hcmRfaW5mbyA9IHsKKwkJSTJDX0JPQVJEX0lORk8oImlyX3J4X3o4ZjA4MTFfaGRwdnIiLCBaOEYwODExX0lSX1JYX0kyQ19BRERSKSwKKwl9OwogCiAJLyogT3VyIGRlZmF1bHQgaW5mb3JtYXRpb24gZm9yIGlyLWtiZC1pMmMuYyB0byB1c2UgKi8KLQlzd2l0Y2ggKGFkZHIpIHsKLQljYXNlIFo4RjA4MTFfSVJfUlhfSTJDX0FERFI6Ci0JCWluaXRfZGF0YS0+aXJfY29kZXMgPSBSQ19NQVBfSEFVUFBBVUdFX05FVzsKLQkJaW5pdF9kYXRhLT5pbnRlcm5hbF9nZXRfa2V5X2Z1bmMgPSBJUl9LQkRfR0VUX0tFWV9IQVVQX1hWUjsKLQkJaW5pdF9kYXRhLT50eXBlID0gUkNfVFlQRV9SQzU7Ci0JCWluaXRfZGF0YS0+bmFtZSA9ICJIRCBQVlIiOwotCQlpbmZvLnBsYXRmb3JtX2RhdGEgPSBpbml0X2RhdGE7Ci0JCWJyZWFrOwotCX0KKwlpbml0X2RhdGEtPmlyX2NvZGVzID0gUkNfTUFQX0hBVVBQQVVHRV9ORVc7CisJaW5pdF9kYXRhLT5pbnRlcm5hbF9nZXRfa2V5X2Z1bmMgPSBJUl9LQkRfR0VUX0tFWV9IQVVQX1hWUjsKKwlpbml0X2RhdGEtPnR5cGUgPSBSQ19UWVBFX1JDNTsKKwlpbml0X2RhdGEtPm5hbWUgPSAiSEQtUFZSIjsKKwloZHB2cl9pcl9yeF9pMmNfYm9hcmRfaW5mby5wbGF0Zm9ybV9kYXRhID0gaW5pdF9kYXRhOwogCi0JcmV0dXJuIGkyY19uZXdfcHJvYmVkX2RldmljZShhZGFwLCAmaW5mbywgYWRkcl9saXN0LCBOVUxMKSA9PSBOVUxMID8KLQkgICAgICAgLTEgOiAwOworCXJldHVybiBpMmNfbmV3X2RldmljZSgmZGV2LT5pMmNfYWRhcHRlciwgJmhkcHZyX2lyX3J4X2kyY19ib2FyZF9pbmZvKTsKIH0KIAotaW50IGhkcHZyX3JlZ2lzdGVyX2kyY19pcihzdHJ1Y3QgaGRwdnJfZGV2aWNlICpkZXYpCi17Ci0JaW50IGk7Ci0JaW50IHJldCA9IDA7Ci0KLQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShpcl9pMmNfYWRkcnMpOyBpKyspCi0JCXJldCArPSBoZHB2cl9uZXdfaTJjX2lyKGRldiwgZGV2LT5pMmNfYWRhcHRlciwKLQkJCQkJaXJfZGV2aWNlbmFtZXNbaV0sIGlyX2kyY19hZGRyc1tpXSk7Ci0KLQlyZXR1cm4gcmV0OwotfQotCi1zdGF0aWMgaW50IGhkcHZyX2kyY19yZWFkKHN0cnVjdCBoZHB2cl9kZXZpY2UgKmRldiwgdW5zaWduZWQgY2hhciBhZGRyLAotCQkJICBjaGFyICpkYXRhLCBpbnQgbGVuKQorc3RhdGljIGludCBoZHB2cl9pMmNfcmVhZChzdHJ1Y3QgaGRwdnJfZGV2aWNlICpkZXYsIGludCBidXMsCisJCQkgIHVuc2lnbmVkIGNoYXIgYWRkciwgY2hhciAqZGF0YSwgaW50IGxlbikKIHsKIAlpbnQgcmV0OwotCWNoYXIgKmJ1ZiA9IGttYWxsb2MobGVuLCBHRlBfS0VSTkVMKTsKLQlpZiAoIWJ1ZikKLQkJcmV0dXJuIC1FTk9NRU07CisKKwlpZiAobGVuID4gc2l6ZW9mKGRldi0+aTJjX2J1ZikpCisJCXJldHVybiAtRUlOVkFMOwogCiAJcmV0ID0gdXNiX2NvbnRyb2xfbXNnKGRldi0+dWRldiwKIAkJCSAgICAgIHVzYl9yY3ZjdHJscGlwZShkZXYtPnVkZXYsIDApLAogCQkJICAgICAgUkVRVFlQRV9JMkNfUkVBRCwgQ1RSTF9SRUFEX1JFUVVFU1QsCi0JCQkgICAgICAweDEwMHxhZGRyLCAwLCBidWYsIGxlbiwgMTAwMCk7CisJCQkgICAgICAoYnVzIDw8IDgpIHwgYWRkciwgMCwgJmRldi0+aTJjX2J1ZiwgbGVuLCAxMDAwKTsKIAogCWlmIChyZXQgPT0gbGVuKSB7Ci0JCW1lbWNweShkYXRhLCBidWYsIGxlbik7CisJCW1lbWNweShkYXRhLCAmZGV2LT5pMmNfYnVmLCBsZW4pOwogCQlyZXQgPSAwOwogCX0gZWxzZSBpZiAocmV0ID49IDApCiAJCXJldCA9IC1FSU87CiAKLQlrZnJlZShidWYpOwotCiAJcmV0dXJuIHJldDsKIH0KIAotc3RhdGljIGludCBoZHB2cl9pMmNfd3JpdGUoc3RydWN0IGhkcHZyX2RldmljZSAqZGV2LCB1bnNpZ25lZCBjaGFyIGFkZHIsCi0JCQkgICBjaGFyICpkYXRhLCBpbnQgbGVuKQorc3RhdGljIGludCBoZHB2cl9pMmNfd3JpdGUoc3RydWN0IGhkcHZyX2RldmljZSAqZGV2LCBpbnQgYnVzLAorCQkJICAgdW5zaWduZWQgY2hhciBhZGRyLCBjaGFyICpkYXRhLCBpbnQgbGVuKQogewogCWludCByZXQ7Ci0JY2hhciAqYnVmID0ga21hbGxvYyhsZW4sIEdGUF9LRVJORUwpOwotCWlmICghYnVmKQotCQlyZXR1cm4gLUVOT01FTTsKIAotCW1lbWNweShidWYsIGRhdGEsIGxlbik7CisJaWYgKGxlbiA+IHNpemVvZihkZXYtPmkyY19idWYpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCW1lbWNweSgmZGV2LT5pMmNfYnVmLCBkYXRhLCBsZW4pOwogCXJldCA9IHVzYl9jb250cm9sX21zZyhkZXYtPnVkZXYsCiAJCQkgICAgICB1c2Jfc25kY3RybHBpcGUoZGV2LT51ZGV2LCAwKSwKIAkJCSAgICAgIFJFUVRZUEVfSTJDX1dSSVRFLCBDVFJMX1dSSVRFX1JFUVVFU1QsCi0JCQkgICAgICAweDEwMHxhZGRyLCAwLCBidWYsIGxlbiwgMTAwMCk7CisJCQkgICAgICAoYnVzIDw8IDgpIHwgYWRkciwgMCwgJmRldi0+aTJjX2J1ZiwgbGVuLCAxMDAwKTsKIAogCWlmIChyZXQgPCAwKQotCQlnb3RvIGVycm9yOworCQlyZXR1cm4gcmV0OwogCiAJcmV0ID0gdXNiX2NvbnRyb2xfbXNnKGRldi0+dWRldiwKIAkJCSAgICAgIHVzYl9yY3ZjdHJscGlwZShkZXYtPnVkZXYsIDApLAogCQkJICAgICAgUkVRVFlQRV9JMkNfV1JJVEVfU1RBVFQsIENUUkxfUkVBRF9SRVFVRVNULAotCQkJICAgICAgMCwgMCwgYnVmLCAyLCAxMDAwKTsKKwkJCSAgICAgIDAsIDAsICZkZXYtPmkyY19idWYsIDIsIDEwMDApOwogCi0JaWYgKHJldCA9PSAyKQorCWlmICgocmV0ID09IDIpICYmIChkZXYtPmkyY19idWZbMV0gPT0gKGxlbiAtIDEpKSkKIAkJcmV0ID0gMDsKIAllbHNlIGlmIChyZXQgPj0gMCkKIAkJcmV0ID0gLUVJTzsKIAotZXJyb3I6Ci0Ja2ZyZWUoYnVmKTsKIAlyZXR1cm4gcmV0OwogfQogCkBAIC0xNDYsMTAgKzEyOCwxMCBAQAogCQlhZGRyID0gbXNnc1tpXS5hZGRyIDw8IDE7CiAKIAkJaWYgKG1zZ3NbaV0uZmxhZ3MgJiBJMkNfTV9SRCkKLQkJCXJldHZhbCA9IGhkcHZyX2kyY19yZWFkKGRldiwgYWRkciwgbXNnc1tpXS5idWYsCisJCQlyZXR2YWwgPSBoZHB2cl9pMmNfcmVhZChkZXYsIDEsIGFkZHIsIG1zZ3NbaV0uYnVmLAogCQkJCQkJbXNnc1tpXS5sZW4pOwogCQllbHNlCi0JCQlyZXR2YWwgPSBoZHB2cl9pMmNfd3JpdGUoZGV2LCBhZGRyLCBtc2dzW2ldLmJ1ZiwKKwkJCXJldHZhbCA9IGhkcHZyX2kyY193cml0ZShkZXYsIDEsIGFkZHIsIG1zZ3NbaV0uYnVmLAogCQkJCQkJIG1zZ3NbaV0ubGVuKTsKIAl9CiAKQEAgLTE2OCwzMCArMTUwLDQ3IEBACiAJLmZ1bmN0aW9uYWxpdHkgPSBoZHB2cl9mdW5jdGlvbmFsaXR5LAogfTsKIAorc3RhdGljIHN0cnVjdCBpMmNfYWRhcHRlciBoZHB2cl9pMmNfYWRhcHRlcl90ZW1wbGF0ZSA9IHsKKwkubmFtZSAgID0gIkhhdXBwYWdlIEhEIFBWUiBJMkMiLAorCS5vd25lciAgPSBUSElTX01PRFVMRSwKKwkuYWxnbyAgID0gJmhkcHZyX2FsZ28sCit9OworCitzdGF0aWMgaW50IGhkcHZyX2FjdGl2YXRlX2lyKHN0cnVjdCBoZHB2cl9kZXZpY2UgKmRldikKK3sKKwljaGFyIGJ1ZmZlcls4XTsKKworCW11dGV4X2xvY2soJmRldi0+aTJjX211dGV4KTsKKworCWhkcHZyX2kyY19yZWFkKGRldiwgMCwgMHg1NCwgYnVmZmVyLCAxKTsKKworCWJ1ZmZlclswXSA9IDA7CisJYnVmZmVyWzFdID0gMHg4OworCWhkcHZyX2kyY193cml0ZShkZXYsIDEsIDB4NTQsIGJ1ZmZlciwgMik7CisKKwlidWZmZXJbMV0gPSAweDE4OworCWhkcHZyX2kyY193cml0ZShkZXYsIDEsIDB4NTQsIGJ1ZmZlciwgMik7CisKKwltdXRleF91bmxvY2soJmRldi0+aTJjX211dGV4KTsKKworCXJldHVybiAwOworfQorCiBpbnQgaGRwdnJfcmVnaXN0ZXJfaTJjX2FkYXB0ZXIoc3RydWN0IGhkcHZyX2RldmljZSAqZGV2KQogewotCXN0cnVjdCBpMmNfYWRhcHRlciAqaTJjX2FkYXA7CiAJaW50IHJldHZhbCA9IC1FTk9NRU07CiAKLQlpMmNfYWRhcCA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBpMmNfYWRhcHRlciksIEdGUF9LRVJORUwpOwotCWlmIChpMmNfYWRhcCA9PSBOVUxMKQotCQlnb3RvIGVycm9yOworCWhkcHZyX2FjdGl2YXRlX2lyKGRldik7CiAKLQlzdHJsY3B5KGkyY19hZGFwLT5uYW1lLCAiSGF1cHBhdWdlIEhEIFBWUiBJMkMiLAotCQlzaXplb2YoaTJjX2FkYXAtPm5hbWUpKTsKLQlpMmNfYWRhcC0+YWxnbyAgPSAmaGRwdnJfYWxnbzsKLQlpMmNfYWRhcC0+b3duZXIgPSBUSElTX01PRFVMRTsKLQlpMmNfYWRhcC0+ZGV2LnBhcmVudCA9ICZkZXYtPnVkZXYtPmRldjsKKwltZW1jcHkoJmRldi0+aTJjX2FkYXB0ZXIsICZoZHB2cl9pMmNfYWRhcHRlcl90ZW1wbGF0ZSwKKwkgICAgICAgc2l6ZW9mKHN0cnVjdCBpMmNfYWRhcHRlcikpOworCWRldi0+aTJjX2FkYXB0ZXIuZGV2LnBhcmVudCA9ICZkZXYtPnVkZXYtPmRldjsKIAotCWkyY19zZXRfYWRhcGRhdGEoaTJjX2FkYXAsIGRldik7CisJaTJjX3NldF9hZGFwZGF0YSgmZGV2LT5pMmNfYWRhcHRlciwgZGV2KTsKIAotCXJldHZhbCA9IGkyY19hZGRfYWRhcHRlcihpMmNfYWRhcCk7CisJcmV0dmFsID0gaTJjX2FkZF9hZGFwdGVyKCZkZXYtPmkyY19hZGFwdGVyKTsKIAotCWlmICghcmV0dmFsKQotCQlkZXYtPmkyY19hZGFwdGVyID0gaTJjX2FkYXA7Ci0JZWxzZQotCQlrZnJlZShpMmNfYWRhcCk7Ci0KLWVycm9yOgogCXJldHVybiByZXR2YWw7CiB9CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9oZHB2ci9oZHB2ci12aWRlby5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9oZHB2ci9oZHB2ci12aWRlby5jCmluZGV4IGQzOGZlMTAuLjUxNGFlYTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vaGRwdnIvaGRwdnItdmlkZW8uYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2hkcHZyL2hkcHZyLXZpZGVvLmMKQEAgLTEyMjAsMTIgKzEyMjAsOSBAQAogCXY0bDJfZGV2aWNlX3VucmVnaXN0ZXIoJmRldi0+djRsMl9kZXYpOwogCiAJLyogZGVyZWdpc3RlciBJMkMgYWRhcHRlciAqLwotI2lmZGVmIENPTkZJR19JMkMKKyNpZiBkZWZpbmVkKENPTkZJR19JMkMpIHx8IChDT05GSUdfSTJDX01PRFVMRSkKIAltdXRleF9sb2NrKCZkZXYtPmkyY19tdXRleCk7Ci0JaWYgKGRldi0+aTJjX2FkYXB0ZXIpCi0JCWkyY19kZWxfYWRhcHRlcihkZXYtPmkyY19hZGFwdGVyKTsKLQlrZnJlZShkZXYtPmkyY19hZGFwdGVyKTsKLQlkZXYtPmkyY19hZGFwdGVyID0gTlVMTDsKKwlpMmNfZGVsX2FkYXB0ZXIoJmRldi0+aTJjX2FkYXB0ZXIpOwogCW11dGV4X3VubG9jaygmZGV2LT5pMmNfbXV0ZXgpOwogI2VuZGlmIC8qIENPTkZJR19JMkMgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9oZHB2ci9oZHB2ci5oIGIvZHJpdmVycy9tZWRpYS92aWRlby9oZHB2ci9oZHB2ci5oCmluZGV4IDM3ZjFlNGMuLjA3MmYyM2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vaGRwdnIvaGRwdnIuaAorKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL2hkcHZyL2hkcHZyLmgKQEAgLTI1LDYgKzI1LDcgQEAKIAlLRVJORUxfVkVSU0lPTihIRFBWUl9NQUpPUl9WRVJTSU9OLCBIRFBWUl9NSU5PUl9WRVJTSU9OLCBIRFBWUl9SRUxFQVNFKQogCiAjZGVmaW5lIEhEUFZSX01BWCA4CisjZGVmaW5lIEhEUFZSX0kyQ19NQVhfU0laRSAxMjgKIAogLyogRGVmaW5lIHRoZXNlIHZhbHVlcyB0byBtYXRjaCB5b3VyIGRldmljZXMgKi8KICNkZWZpbmUgSERfUFZSX1ZFTkRPUl9JRAkweDIwNDAKQEAgLTEwNiw5ICsxMDcsMTEgQEAKIAlzdHJ1Y3Qgd29ya19zdHJ1Y3QJd29ya2VyOwogCiAJLyogSTJDIGFkYXB0ZXIgKi8KLQlzdHJ1Y3QgaTJjX2FkYXB0ZXIJKmkyY19hZGFwdGVyOworCXN0cnVjdCBpMmNfYWRhcHRlcglpMmNfYWRhcHRlcjsKIAkvKiBJMkMgbG9jayAqLwogCXN0cnVjdCBtdXRleAkJaTJjX211dGV4OworCS8qIEkyQyBtZXNzYWdlIGJ1ZmZlciBzcGFjZSAqLworCWNoYXIJCQlpMmNfYnVmW0hEUFZSX0kyQ19NQVhfU0laRV07CiAKIAkvKiBGb3IgcGFzc2luZyBkYXRhIHRvIGlyLWtiZC1pMmMgKi8KIAlzdHJ1Y3QgSVJfaTJjX2luaXRfZGF0YQlpcl9pMmNfaW5pdF9kYXRhOwpAQCAtMzEwLDcgKzMxMyw4IEBACiAvKiBpMmMgYWRhcHRlciByZWdpc3RyYXRpb24gKi8KIGludCBoZHB2cl9yZWdpc3Rlcl9pMmNfYWRhcHRlcihzdHJ1Y3QgaGRwdnJfZGV2aWNlICpkZXYpOwogCi1pbnQgaGRwdnJfcmVnaXN0ZXJfaTJjX2lyKHN0cnVjdCBoZHB2cl9kZXZpY2UgKmRldik7CitzdHJ1Y3QgaTJjX2NsaWVudCAqaGRwdnJfcmVnaXN0ZXJfaXJfcnhfaTJjKHN0cnVjdCBoZHB2cl9kZXZpY2UgKmRldik7CitzdHJ1Y3QgaTJjX2NsaWVudCAqaGRwdnJfcmVnaXN0ZXJfaXJfdHhfaTJjKHN0cnVjdCBoZHB2cl9kZXZpY2UgKmRldik7CiAKIC8qPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ki8KIC8qIGJ1ZmZlciBtYW5hZ2VtZW50ICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL2lyLWtiZC1pMmMuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vaXIta2JkLWkyYy5jCmluZGV4IGM4N2I2YmMuLmEyMjFhZDYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vaXIta2JkLWkyYy5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vaXIta2JkLWkyYy5jCkBAIC0xMjgsNiArMTI4LDE5IEBACiAKIHN0YXRpYyBpbnQgZ2V0X2tleV9oYXVwX3h2cihzdHJ1Y3QgSVJfaTJjICppciwgdTMyICppcl9rZXksIHUzMiAqaXJfcmF3KQogeworCWludCByZXQ7CisJdW5zaWduZWQgY2hhciBidWZbMV0gPSB7IDAgfTsKKworCS8qCisJICogVGhpcyBpcyB0aGUgc2FtZSBhcHBhcmVudCAiYXJlIHlvdSByZWFkeT8iIHBvbGwgY29tbWFuZCBvYnNlcnZlZAorCSAqIHdhdGNoaW5nIFdpbmRvd3MgZHJpdmVyIHRyYWZmaWMgYW5kIGltcGxlbWVudGVkIGluIGxpcmNfemlsb2cuIFdpdGgKKwkgKiB0aGlzIGFkZGVkLCB3ZSBnZXQgZmFyIHNhbmVyIHJlbW90ZSBiZWhhdmlvciB3aXRoIHo4IGNoaXBzIG9uIHVzYgorCSAqIGNvbm5lY3RlZCBkZXZpY2VzLCBldmVuIHdpdGggdGhlIGRlZmF1bHQgcG9sbGluZyBpbnRlcnZhbCBvZiAxMDBtcy4KKwkgKi8KKwlyZXQgPSBpMmNfbWFzdGVyX3NlbmQoaXItPmMsIGJ1ZiwgMSk7CisJaWYgKHJldCAhPSAxKQorCQlyZXR1cm4gKHJldCA8IDApID8gcmV0IDogLUVJTlZBTDsKKwogCXJldHVybiBnZXRfa2V5X2hhdXBfY29tbW9uIChpciwgaXJfa2V5LCBpcl9yYXcsIDYsIDMpOwogfQogCkBAIC0yNDQsMTUgKzI1NywxNyBAQAogCXN0YXRpYyB1MzIgaXJfa2V5LCBpcl9yYXc7CiAJaW50IHJjOwogCi0JZHByaW50aygyLCJpcl9wb2xsX2tleVxuIik7CisJZHByaW50aygzLCAiJXNcbiIsIF9fZnVuY19fKTsKIAlyYyA9IGlyLT5nZXRfa2V5KGlyLCAmaXJfa2V5LCAmaXJfcmF3KTsKIAlpZiAocmMgPCAwKSB7CiAJCWRwcmludGsoMiwiZXJyb3JcbiIpOwogCQlyZXR1cm47CiAJfQogCi0JaWYgKHJjKQorCWlmIChyYykgeworCQlkcHJpbnRrKDEsICIlczoga2V5Y29kZSA9IDB4JTA0eFxuIiwgX19mdW5jX18sIGlyX2tleSk7CiAJCXJjX2tleWRvd24oaXItPnJjLCBpcl9rZXksIDApOworCX0KIH0KIAogc3RhdGljIHZvaWQgaXJfd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCkBAIC0zMjEsNiArMzM2LDEyIEBACiAJCXJjX3R5cGUgICAgID0gUkNfVFlQRV9PVEhFUjsKIAkJaXJfY29kZXMgICAgPSBSQ19NQVBfQVZFUk1FRElBX0NBUkRCVVM7CiAJCWJyZWFrOworCWNhc2UgMHg3MToKKwkJbmFtZSAgICAgICAgPSAiSGF1cHBhdWdlL1ppbG9nIFo4IjsKKwkJaXItPmdldF9rZXkgPSBnZXRfa2V5X2hhdXBfeHZyOworCQlyY190eXBlICAgICA9IFJDX1RZUEVfUkM1OworCQlpcl9jb2RlcyAgICA9IGhhdXBwYXVnZSA/IFJDX01BUF9IQVVQUEFVR0VfTkVXIDogUkNfTUFQX1JDNV9UVjsKKwkJYnJlYWs7CiAJfQogCiAJLyogTGV0IHRoZSBjYWxsZXIgb3ZlcnJpZGUgc2V0dGluZ3MgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vaXZ0di9pdnR2LWkyYy5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9pdnR2L2l2dHYtaTJjLmMKaW5kZXggZTEwM2I4Zi4uOWZiODZhMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9pdnR2L2l2dHYtaTJjLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9pdnR2L2l2dHYtaTJjLmMKQEAgLTMwMCwxMCArMzAwLDE1IEBACiAJCQkJYWRhcCwgdHlwZSwgMCwgSTJDX0FERFJTKGh3X2FkZHJzW2lkeF0pKTsKIAl9IGVsc2UgaWYgKGh3ID09IElWVFZfSFdfQ1gyNTg0MCkgewogCQlzdHJ1Y3QgY3gyNTg0MF9wbGF0Zm9ybV9kYXRhIHBkYXRhOworCQlzdHJ1Y3QgaTJjX2JvYXJkX2luZm8gY3gyNTg0MF9pbmZvID0geworCQkJLnR5cGUgPSAiY3gyNTg0MCIsCisJCQkuYWRkciA9IGh3X2FkZHJzW2lkeF0sCisJCQkucGxhdGZvcm1fZGF0YSA9ICZwZGF0YSwKKwkJfTsKIAogCQlwZGF0YS5wdnIxNTBfd29ya2Fyb3VuZCA9IGl0di0+cHZyMTUwX3dvcmthcm91bmQ7Ci0JCXNkID0gdjRsMl9pMmNfbmV3X3N1YmRldl9jZmcoJml0di0+djRsMl9kZXYsCi0JCQkJYWRhcCwgdHlwZSwgMCwgJnBkYXRhLCBod19hZGRyc1tpZHhdLCBOVUxMKTsKKwkJc2QgPSB2NGwyX2kyY19uZXdfc3ViZGV2X2JvYXJkKCZpdHYtPnY0bDJfZGV2LCBhZGFwLAorCQkJCSZjeDI1ODQwX2luZm8sIE5VTEwpOwogCX0gZWxzZSB7CiAJCXNkID0gdjRsMl9pMmNfbmV3X3N1YmRldigmaXR2LT52NGwyX2RldiwKIAkJCQlhZGFwLCB0eXBlLCBod19hZGRyc1tpZHhdLCBOVUxMKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vbXQ5djAxMS5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9tdDl2MDExLmMKaW5kZXggMjA5ZmY5Ny4uNDkwNGQyNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9tdDl2MDExLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9tdDl2MDExLmMKQEAgLTEyLDE3ICsxMiw0MSBAQAogI2luY2x1ZGUgPGFzbS9kaXY2NC5oPgogI2luY2x1ZGUgPG1lZGlhL3Y0bDItZGV2aWNlLmg+CiAjaW5jbHVkZSA8bWVkaWEvdjRsMi1jaGlwLWlkZW50Lmg+Ci0jaW5jbHVkZSAibXQ5djAxMS5oIgorI2luY2x1ZGUgPG1lZGlhL210OXYwMTEuaD4KIAogTU9EVUxFX0RFU0NSSVBUSU9OKCJNaWNyb24gbXQ5djAxMSBzZW5zb3IgZHJpdmVyIik7CiBNT0RVTEVfQVVUSE9SKCJNYXVybyBDYXJ2YWxobyBDaGVoYWIgPG1jaGVoYWJAcmVkaGF0LmNvbT4iKTsKIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKIAotCiBzdGF0aWMgaW50IGRlYnVnOwogbW9kdWxlX3BhcmFtKGRlYnVnLCBpbnQsIDApOwogTU9EVUxFX1BBUk1fREVTQyhkZWJ1ZywgIkRlYnVnIGxldmVsICgwLTIpIik7CiAKKyNkZWZpbmUgUjAwX01UOVYwMTFfQ0hJUF9WRVJTSU9OCTB4MDAKKyNkZWZpbmUgUjAxX01UOVYwMTFfUk9XU1RBUlQJCTB4MDEKKyNkZWZpbmUgUjAyX01UOVYwMTFfQ09MU1RBUlQJCTB4MDIKKyNkZWZpbmUgUjAzX01UOVYwMTFfSEVJR0hUCQkweDAzCisjZGVmaW5lIFIwNF9NVDlWMDExX1dJRFRICQkweDA0CisjZGVmaW5lIFIwNV9NVDlWMDExX0hCTEFOSwkJMHgwNQorI2RlZmluZSBSMDZfTVQ5VjAxMV9WQkxBTksJCTB4MDYKKyNkZWZpbmUgUjA3X01UOVYwMTFfT1VUX0NUUkwJCTB4MDcKKyNkZWZpbmUgUjA5X01UOVYwMTFfU0hVVFRFUl9XSURUSAkweDA5CisjZGVmaW5lIFIwQV9NVDlWMDExX0NMS19TUEVFRAkJMHgwYQorI2RlZmluZSBSMEJfTVQ5VjAxMV9SRVNUQVJUCQkweDBiCisjZGVmaW5lIFIwQ19NVDlWMDExX1NIVVRURVJfREVMQVkJMHgwYworI2RlZmluZSBSMERfTVQ5VjAxMV9SRVNFVAkJMHgwZAorI2RlZmluZSBSMUVfTVQ5VjAxMV9ESUdJVEFMX1pPT00JMHgxZQorI2RlZmluZSBSMjBfTVQ5VjAxMV9SRUFEX01PREUJCTB4MjAKKyNkZWZpbmUgUjJCX01UOVYwMTFfR1JFRU5fMV9HQUlOCTB4MmIKKyNkZWZpbmUgUjJDX01UOVYwMTFfQkxVRV9HQUlOCQkweDJjCisjZGVmaW5lIFIyRF9NVDlWMDExX1JFRF9HQUlOCQkweDJkCisjZGVmaW5lIFIyRV9NVDlWMDExX0dSRUVOXzJfR0FJTgkweDJlCisjZGVmaW5lIFIzNV9NVDlWMDExX0dMT0JBTF9HQUlOCQkweDM1CisjZGVmaW5lIFJGMV9NVDlWMDExX0NISVBfRU5BQkxFCQkweGYxCisKKyNkZWZpbmUgTVQ5VjAxMV9WRVJTSU9OCQkJMHg4MjMyCisjZGVmaW5lIE1UOVYwMTFfUkVWX0JfVkVSU0lPTgkJMHg4MjQzCisKIC8qIHN1cHBvcnRlZCBjb250cm9scyAqLwogc3RhdGljIHN0cnVjdCB2NGwyX3F1ZXJ5Y3RybCBtdDl2MDExX3FjdHJsW10gPSB7CiAJewpAQCAtNDY5LDIzICs0OTMsNiBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IG10OXYwMTFfc19jb25maWcoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCwgaW50IGR1bWIsIHZvaWQgKmRhdGEpCi17Ci0Jc3RydWN0IG10OXYwMTEgKmNvcmUgPSB0b19tdDl2MDExKHNkKTsKLQl1bnNpZ25lZCAqeHRhbCA9IGRhdGE7Ci0KLQl2NGwyX2RiZygxLCBkZWJ1Zywgc2QsICJzX2NvbmZpZyBjYWxsZWRcbiIpOwotCi0JaWYgKHh0YWwpIHsKLQkJY29yZS0+eHRhbCA9ICp4dGFsOwotCQl2NGwyX2RiZygxLCBkZWJ1Zywgc2QsICJ4dGFsIHNldCB0byAlZC4lMDNkIE1IelxuIiwKLQkJCSAqeHRhbCAvIDEwMDAwMDAsICgqeHRhbCAvIDEwMDApICUgMTAwMCk7Ci0JfQotCi0JcmV0dXJuIDA7Ci19Ci0KLQogI2lmZGVmIENPTkZJR19WSURFT19BRFZfREVCVUcKIHN0YXRpYyBpbnQgbXQ5djAxMV9nX3JlZ2lzdGVyKHN0cnVjdCB2NGwyX3N1YmRldiAqc2QsCiAJCQkgICAgICBzdHJ1Y3QgdjRsMl9kYmdfcmVnaXN0ZXIgKnJlZykKQEAgLTUzNiw3ICs1NDMsNiBAQAogCS5nX2N0cmwgPSBtdDl2MDExX2dfY3RybCwKIAkuc19jdHJsID0gbXQ5djAxMV9zX2N0cmwsCiAJLnJlc2V0ID0gbXQ5djAxMV9yZXNldCwKLQkuc19jb25maWcgPSBtdDl2MDExX3NfY29uZmlnLAogCS5nX2NoaXBfaWRlbnQgPSBtdDl2MDExX2dfY2hpcF9pZGVudCwKICNpZmRlZiBDT05GSUdfVklERU9fQURWX0RFQlVHCiAJLmdfcmVnaXN0ZXIgPSBtdDl2MDExX2dfcmVnaXN0ZXIsCkBAIC01OTYsNiArNjAyLDE0IEBACiAJY29yZS0+aGVpZ2h0ID0gNDgwOwogCWNvcmUtPnh0YWwgPSAyNzAwMDAwMDsJLyogSHogKi8KIAorCWlmIChjLT5kZXYucGxhdGZvcm1fZGF0YSkgeworCQlzdHJ1Y3QgbXQ5djAxMV9wbGF0Zm9ybV9kYXRhICpwZGF0YSA9IGMtPmRldi5wbGF0Zm9ybV9kYXRhOworCisJCWNvcmUtPnh0YWwgPSBwZGF0YS0+eHRhbDsKKwkJdjRsMl9kYmcoMSwgZGVidWcsIHNkLCAieHRhbCBzZXQgdG8gJWQuJTAzZCBNSHpcbiIsCisJCQljb3JlLT54dGFsIC8gMTAwMDAwMCwgKGNvcmUtPnh0YWwgLyAxMDAwKSAlIDEwMDApOworCX0KKwogCXY0bF9pbmZvKGMsICJjaGlwIGZvdW5kIEAgMHglMDJ4ICglcyAtIGNoaXAgdmVyc2lvbiAweCUwNHgpXG4iLAogCQkgYy0+YWRkciA8PCAxLCBjLT5hZGFwdGVyLT5uYW1lLCB2ZXJzaW9uKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9tdDl2MDExLmggYi9kcml2ZXJzL21lZGlhL3ZpZGVvL210OXYwMTEuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzM1MGZkNi4uMDAwMDAwMAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL210OXYwMTEuaAorKysgL2Rldi9udWxsCkBAIC0xLDM2ICswLDAgQEAKLS8qCi0gKiBtdDl2MDExIC1NaWNyb24gMS80LUluY2ggVkdBIERpZ2l0YWwgSW1hZ2UgU2Vuc29yCi0gKgotICogQ29weXJpZ2h0IChjKSAyMDA5IE1hdXJvIENhcnZhbGhvIENoZWhhYiAobWNoZWhhYkByZWRoYXQuY29tKQotICogVGhpcyBjb2RlIGlzIHBsYWNlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHYyCi0gKi8KLQotI2lmbmRlZiBNVDlWMDExX0hfCi0jZGVmaW5lIE1UOVYwMTFfSF8KLQotI2RlZmluZSBSMDBfTVQ5VjAxMV9DSElQX1ZFUlNJT04JMHgwMAotI2RlZmluZSBSMDFfTVQ5VjAxMV9ST1dTVEFSVAkJMHgwMQotI2RlZmluZSBSMDJfTVQ5VjAxMV9DT0xTVEFSVAkJMHgwMgotI2RlZmluZSBSMDNfTVQ5VjAxMV9IRUlHSFQJCTB4MDMKLSNkZWZpbmUgUjA0X01UOVYwMTFfV0lEVEgJCTB4MDQKLSNkZWZpbmUgUjA1X01UOVYwMTFfSEJMQU5LCQkweDA1Ci0jZGVmaW5lIFIwNl9NVDlWMDExX1ZCTEFOSwkJMHgwNgotI2RlZmluZSBSMDdfTVQ5VjAxMV9PVVRfQ1RSTAkJMHgwNwotI2RlZmluZSBSMDlfTVQ5VjAxMV9TSFVUVEVSX1dJRFRICTB4MDkKLSNkZWZpbmUgUjBBX01UOVYwMTFfQ0xLX1NQRUVECQkweDBhCi0jZGVmaW5lIFIwQl9NVDlWMDExX1JFU1RBUlQJCTB4MGIKLSNkZWZpbmUgUjBDX01UOVYwMTFfU0hVVFRFUl9ERUxBWQkweDBjCi0jZGVmaW5lIFIwRF9NVDlWMDExX1JFU0VUCQkweDBkCi0jZGVmaW5lIFIxRV9NVDlWMDExX0RJR0lUQUxfWk9PTQkweDFlCi0jZGVmaW5lIFIyMF9NVDlWMDExX1JFQURfTU9ERQkJMHgyMAotI2RlZmluZSBSMkJfTVQ5VjAxMV9HUkVFTl8xX0dBSU4JMHgyYgotI2RlZmluZSBSMkNfTVQ5VjAxMV9CTFVFX0dBSU4JCTB4MmMKLSNkZWZpbmUgUjJEX01UOVYwMTFfUkVEX0dBSU4JCTB4MmQKLSNkZWZpbmUgUjJFX01UOVYwMTFfR1JFRU5fMl9HQUlOCTB4MmUKLSNkZWZpbmUgUjM1X01UOVYwMTFfR0xPQkFMX0dBSU4JCTB4MzUKLSNkZWZpbmUgUkYxX01UOVYwMTFfQ0hJUF9FTkFCTEUJCTB4ZjEKLQotI2RlZmluZSBNVDlWMDExX1ZFUlNJT04JCQkweDgyMzIKLSNkZWZpbmUgTVQ5VjAxMV9SRVZfQl9WRVJTSU9OCQkweDgyNDMKLQotI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL292NzY3MC5jIGIvZHJpdmVycy9tZWRpYS92aWRlby9vdjc2NzAuYwppbmRleCBjODgxYTY0Li5kNGU3YzExIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL292NzY3MC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vb3Y3NjcwLmMKQEAgLTE0NDksNDcgKzE0NDksNiBAQAogCXJldHVybiB2NGwyX2NoaXBfaWRlbnRfaTJjX2NsaWVudChjbGllbnQsIGNoaXAsIFY0TDJfSURFTlRfT1Y3NjcwLCAwKTsKIH0KIAotc3RhdGljIGludCBvdjc2NzBfc19jb25maWcoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCwgaW50IGR1bWIsIHZvaWQgKmRhdGEpCi17Ci0Jc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCA9IHY0bDJfZ2V0X3N1YmRldmRhdGEoc2QpOwotCXN0cnVjdCBvdjc2NzBfY29uZmlnICpjb25maWcgPSBkYXRhOwotCXN0cnVjdCBvdjc2NzBfaW5mbyAqaW5mbyA9IHRvX3N0YXRlKHNkKTsKLQlpbnQgcmV0OwotCi0JaW5mby0+Y2xvY2tfc3BlZWQgPSAzMDsgLyogZGVmYXVsdDogYSBndWVzcyAqLwotCi0JLyoKLQkgKiBNdXN0IGFwcGx5IGNvbmZpZ3VyYXRpb24gYmVmb3JlIGluaXRpYWxpemluZyBkZXZpY2UsIGJlY2F1c2UgaXQKLQkgKiBzZWxlY3RzIEkvTyBtZXRob2QuCi0JICovCi0JaWYgKGNvbmZpZykgewotCQlpbmZvLT5taW5fd2lkdGggPSBjb25maWctPm1pbl93aWR0aDsKLQkJaW5mby0+bWluX2hlaWdodCA9IGNvbmZpZy0+bWluX2hlaWdodDsKLQkJaW5mby0+dXNlX3NtYnVzID0gY29uZmlnLT51c2Vfc21idXM7Ci0KLQkJaWYgKGNvbmZpZy0+Y2xvY2tfc3BlZWQpCi0JCQlpbmZvLT5jbG9ja19zcGVlZCA9IGNvbmZpZy0+Y2xvY2tfc3BlZWQ7Ci0JfQotCi0JLyogTWFrZSBzdXJlIGl0J3MgYW4gb3Y3NjcwICovCi0JcmV0ID0gb3Y3NjcwX2RldGVjdChzZCk7Ci0JaWYgKHJldCkgewotCQl2NGxfZGJnKDEsIGRlYnVnLCBjbGllbnQsCi0JCQkiY2hpcCBmb3VuZCBAIDB4JXggKCVzKSBpcyBub3QgYW4gb3Y3NjcwIGNoaXAuXG4iLAotCQkJY2xpZW50LT5hZGRyIDw8IDEsIGNsaWVudC0+YWRhcHRlci0+bmFtZSk7Ci0JCWtmcmVlKGluZm8pOwotCQlyZXR1cm4gcmV0OwotCX0KLQl2NGxfaW5mbyhjbGllbnQsICJjaGlwIGZvdW5kIEAgMHglMDJ4ICglcylcbiIsCi0JCQljbGllbnQtPmFkZHIgPDwgMSwgY2xpZW50LT5hZGFwdGVyLT5uYW1lKTsKLQotCWluZm8tPmZtdCA9ICZvdjc2NzBfZm9ybWF0c1swXTsKLQlpbmZvLT5zYXQgPSAxMjg7CS8qIFJldmlldyB0aGlzICovCi0JaW5mby0+Y2xrcmMgPSBpbmZvLT5jbG9ja19zcGVlZCAvIDMwOwotCi0JcmV0dXJuIDA7Ci19Ci0KICNpZmRlZiBDT05GSUdfVklERU9fQURWX0RFQlVHCiBzdGF0aWMgaW50IG92NzY3MF9nX3JlZ2lzdGVyKHN0cnVjdCB2NGwyX3N1YmRldiAqc2QsIHN0cnVjdCB2NGwyX2RiZ19yZWdpc3RlciAqcmVnKQogewpAQCAtMTUyOCw3ICsxNDg3LDYgQEAKIAkuc19jdHJsID0gb3Y3NjcwX3NfY3RybCwKIAkucXVlcnljdHJsID0gb3Y3NjcwX3F1ZXJ5Y3RybCwKIAkucmVzZXQgPSBvdjc2NzBfcmVzZXQsCi0JLnNfY29uZmlnID0gb3Y3NjcwX3NfY29uZmlnLAogCS5pbml0ID0gb3Y3NjcwX2luaXQsCiAjaWZkZWYgQ09ORklHX1ZJREVPX0FEVl9ERUJVRwogCS5nX3JlZ2lzdGVyID0gb3Y3NjcwX2dfcmVnaXN0ZXIsCkBAIC0xNTU4LDYgKzE1MTYsNyBAQAogewogCXN0cnVjdCB2NGwyX3N1YmRldiAqc2Q7CiAJc3RydWN0IG92NzY3MF9pbmZvICppbmZvOworCWludCByZXQ7CiAKIAlpbmZvID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IG92NzY3MF9pbmZvKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKGluZm8gPT0gTlVMTCkKQEAgLTE1NjUsNiArMTUyNCwzNyBAQAogCXNkID0gJmluZm8tPnNkOwogCXY0bDJfaTJjX3N1YmRldl9pbml0KHNkLCBjbGllbnQsICZvdjc2NzBfb3BzKTsKIAorCWluZm8tPmNsb2NrX3NwZWVkID0gMzA7IC8qIGRlZmF1bHQ6IGEgZ3Vlc3MgKi8KKwlpZiAoY2xpZW50LT5kZXYucGxhdGZvcm1fZGF0YSkgeworCQlzdHJ1Y3Qgb3Y3NjcwX2NvbmZpZyAqY29uZmlnID0gY2xpZW50LT5kZXYucGxhdGZvcm1fZGF0YTsKKworCQkvKgorCQkgKiBNdXN0IGFwcGx5IGNvbmZpZ3VyYXRpb24gYmVmb3JlIGluaXRpYWxpemluZyBkZXZpY2UsIGJlY2F1c2UgaXQKKwkJICogc2VsZWN0cyBJL08gbWV0aG9kLgorCQkgKi8KKwkJaW5mby0+bWluX3dpZHRoID0gY29uZmlnLT5taW5fd2lkdGg7CisJCWluZm8tPm1pbl9oZWlnaHQgPSBjb25maWctPm1pbl9oZWlnaHQ7CisJCWluZm8tPnVzZV9zbWJ1cyA9IGNvbmZpZy0+dXNlX3NtYnVzOworCisJCWlmIChjb25maWctPmNsb2NrX3NwZWVkKQorCQkJaW5mby0+Y2xvY2tfc3BlZWQgPSBjb25maWctPmNsb2NrX3NwZWVkOworCX0KKworCS8qIE1ha2Ugc3VyZSBpdCdzIGFuIG92NzY3MCAqLworCXJldCA9IG92NzY3MF9kZXRlY3Qoc2QpOworCWlmIChyZXQpIHsKKwkJdjRsX2RiZygxLCBkZWJ1ZywgY2xpZW50LAorCQkJImNoaXAgZm91bmQgQCAweCV4ICglcykgaXMgbm90IGFuIG92NzY3MCBjaGlwLlxuIiwKKwkJCWNsaWVudC0+YWRkciA8PCAxLCBjbGllbnQtPmFkYXB0ZXItPm5hbWUpOworCQlrZnJlZShpbmZvKTsKKwkJcmV0dXJuIHJldDsKKwl9CisJdjRsX2luZm8oY2xpZW50LCAiY2hpcCBmb3VuZCBAIDB4JTAyeCAoJXMpXG4iLAorCQkJY2xpZW50LT5hZGRyIDw8IDEsIGNsaWVudC0+YWRhcHRlci0+bmFtZSk7CisKKwlpbmZvLT5mbXQgPSAmb3Y3NjcwX2Zvcm1hdHNbMF07CisJaW5mby0+c2F0ID0gMTI4OwkvKiBSZXZpZXcgdGhpcyAqLworCWluZm8tPmNsa3JjID0gaW5mby0+Y2xvY2tfc3BlZWQgLyAzMDsKIAlyZXR1cm4gMDsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9wdnJ1c2IyL3B2cnVzYjItaGR3LWludGVybmFsLmggYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3B2cnVzYjIvcHZydXNiMi1oZHctaW50ZXJuYWwuaAppbmRleCBhYzk0YThiLi4zMDVlNmFhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3B2cnVzYjIvcHZydXNiMi1oZHctaW50ZXJuYWwuaAorKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3B2cnVzYjIvcHZydXNiMi1oZHctaW50ZXJuYWwuaApAQCAtNDAsNiArNDAsNyBAQAogI2luY2x1ZGUgInB2cnVzYjItaW8uaCIKICNpbmNsdWRlIDxtZWRpYS92NGwyLWRldmljZS5oPgogI2luY2x1ZGUgPG1lZGlhL2N4MjM0MXguaD4KKyNpbmNsdWRlIDxtZWRpYS9pci1rYmQtaTJjLmg+CiAjaW5jbHVkZSAicHZydXNiMi1kZXZhdHRyLmgiCiAKIC8qIExlZ2FsIHZhbHVlcyBmb3IgUFZSMl9DSURfSFNNICovCkBAIC0yMDIsNiArMjAzLDcgQEAKIAogCS8qIElSIHJlbGF0ZWQgKi8KIAl1bnNpZ25lZCBpbnQgaXJfc2NoZW1lX2FjdGl2ZTsgLyogSVIgc2NoZW1lIGFzIHNlZW4gZnJvbSB0aGUgb3V0c2lkZSAqLworCXN0cnVjdCBJUl9pMmNfaW5pdF9kYXRhIGlyX2luaXRfZGF0YTsgLyogcGFyYW1zIHBhc3NlZCB0byBJUiBtb2R1bGVzICovCiAKIAkvKiBGcmVxdWVuY3kgdGFibGUgKi8KIAl1bnNpZ25lZCBpbnQgZnJlcVRhYmxlW0ZSRVFUQUJMRV9TSVpFXTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vcHZydXNiMi9wdnJ1c2IyLWkyYy1jb3JlLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3B2cnVzYjIvcHZydXNiMi1pMmMtY29yZS5jCmluZGV4IDdjYmUxOGMuLjQ1MWVjZDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vcHZydXNiMi9wdnJ1c2IyLWkyYy1jb3JlLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9wdnJ1c2IyL3B2cnVzYjItaTJjLWNvcmUuYwpAQCAtMTksNiArMTksNyBAQAogICovCiAKICNpbmNsdWRlIDxsaW51eC9pMmMuaD4KKyNpbmNsdWRlIDxtZWRpYS9pci1rYmQtaTJjLmg+CiAjaW5jbHVkZSAicHZydXNiMi1pMmMtY29yZS5oIgogI2luY2x1ZGUgInB2cnVzYjItaGR3LWludGVybmFsLmgiCiAjaW5jbHVkZSAicHZydXNiMi1kZWJ1Zy5oIgpAQCAtNDgsMTMgKzQ5LDYgQEAKIE1PRFVMRV9QQVJNX0RFU0MoZGlzYWJsZV9hdXRvbG9hZF9pcl92aWRlbywKIAkJICIxPWRvIG5vdCB0cnkgdG8gYXV0b2xvYWQgaXJfdmlkZW8gSVIgcmVjZWl2ZXIiKTsKIAotLyogTWFwcGluZyBvZiBJUiBzY2hlbWVzIHRvIGtub3duIEkyQyBhZGRyZXNzZXMgLSBpZiBhbnkgKi8KLXN0YXRpYyBjb25zdCB1bnNpZ25lZCBjaGFyIGlyX3ZpZGVvX2FkZHJlc3Nlc1tdID0gewotCVtQVlIyX0lSX1NDSEVNRV9aSUxPR10gPSAweDcxLAotCVtQVlIyX0lSX1NDSEVNRV8yOVhYWF0gPSAweDE4LAotCVtQVlIyX0lSX1NDSEVNRV8yNFhYWF0gPSAweDE4LAotfTsKLQogc3RhdGljIGludCBwdnIyX2kyY193cml0ZShzdHJ1Y3QgcHZyMl9oZHcgKmhkdywgLyogQ29udGV4dCAqLwogCQkJICB1OCBpMmNfYWRkciwgICAgICAvKiBJMkMgYWRkcmVzcyB3ZSdyZSB0YWxraW5nIHRvICovCiAJCQkgIHU4ICpkYXRhLCAgICAgICAgIC8qIERhdGEgdG8gd3JpdGUgKi8KQEAgLTU3NCwyNiArNTY4LDU1IEBACiBzdGF0aWMgdm9pZCBwdnIyX2kyY19yZWdpc3Rlcl9pcihzdHJ1Y3QgcHZyMl9oZHcgKmhkdykKIHsKIAlzdHJ1Y3QgaTJjX2JvYXJkX2luZm8gaW5mbzsKLQl1bnNpZ25lZCBjaGFyIGFkZHIgPSAwOworCXN0cnVjdCBJUl9pMmNfaW5pdF9kYXRhICppbml0X2RhdGEgPSAmaGR3LT5pcl9pbml0X2RhdGE7CiAJaWYgKHB2cjJfZGlzYWJsZV9pcl92aWRlbykgewogCQlwdnIyX3RyYWNlKFBWUjJfVFJBQ0VfSU5GTywKIAkJCSAgICJBdXRvbWF0aWMgYmluZGluZyBvZiBpcl92aWRlbyBoYXMgYmVlbiBkaXNhYmxlZC4iKTsKIAkJcmV0dXJuOwogCX0KLQlpZiAoaGR3LT5pcl9zY2hlbWVfYWN0aXZlIDwgQVJSQVlfU0laRShpcl92aWRlb19hZGRyZXNzZXMpKSB7Ci0JCWFkZHIgPSBpcl92aWRlb19hZGRyZXNzZXNbaGR3LT5pcl9zY2hlbWVfYWN0aXZlXTsKLQl9Ci0JaWYgKCFhZGRyKSB7CisJbWVtc2V0KCZpbmZvLCAwLCBzaXplb2Yoc3RydWN0IGkyY19ib2FyZF9pbmZvKSk7CisJc3dpdGNoIChoZHctPmlyX3NjaGVtZV9hY3RpdmUpIHsKKwljYXNlIFBWUjJfSVJfU0NIRU1FXzI0WFhYOiAvKiBGWDItY29udHJvbGxlZCBJUiAqLworCWNhc2UgUFZSMl9JUl9TQ0hFTUVfMjlYWFg6IC8qIE9yaWdpbmFsIDI5eHh4IGRldmljZSAqLworCQlpbml0X2RhdGEtPmlyX2NvZGVzICAgICAgICAgICAgICA9IFJDX01BUF9IQVVQUEFVR0VfTkVXOworCQlpbml0X2RhdGEtPmludGVybmFsX2dldF9rZXlfZnVuYyA9IElSX0tCRF9HRVRfS0VZX0hBVVA7CisJCWluaXRfZGF0YS0+dHlwZSAgICAgICAgICAgICAgICAgID0gUkNfVFlQRV9SQzU7CisJCWluaXRfZGF0YS0+bmFtZSAgICAgICAgICAgICAgICAgID0gaGR3LT5oZHdfZGVzYy0+ZGVzY3JpcHRpb247CisJCWluaXRfZGF0YS0+cG9sbGluZ19pbnRlcnZhbCAgICAgID0gMTAwOyAvKiBtcyBGcm9tIGlyLWtiZC1pMmMgKi8KKwkJLyogSVIgUmVjZWl2ZXIgKi8KKwkJaW5mby5hZGRyICAgICAgICAgID0gMHgxODsKKwkJaW5mby5wbGF0Zm9ybV9kYXRhID0gaW5pdF9kYXRhOworCQlzdHJsY3B5KGluZm8udHlwZSwgImlyX3ZpZGVvIiwgSTJDX05BTUVfU0laRSk7CisJCXB2cjJfdHJhY2UoUFZSMl9UUkFDRV9JTkZPLCAiQmluZGluZyAlcyB0byBpMmMgYWRkcmVzcyAweCUwMnguIiwKKwkJCSAgIGluZm8udHlwZSwgaW5mby5hZGRyKTsKKwkJaTJjX25ld19kZXZpY2UoJmhkdy0+aTJjX2FkYXAsICZpbmZvKTsKKwkJYnJlYWs7CisJY2FzZSBQVlIyX0lSX1NDSEVNRV9aSUxPRzogICAgIC8qIEhWUi0xOTUwIHN0eWxlICovCisJY2FzZSBQVlIyX0lSX1NDSEVNRV8yNFhYWF9NQ0U6IC8qIDI0eHh4IE1DRSBkZXZpY2UgKi8KKwkJaW5pdF9kYXRhLT5pcl9jb2RlcyAgICAgICAgICAgICAgPSBSQ19NQVBfSEFVUFBBVUdFX05FVzsKKwkJaW5pdF9kYXRhLT5pbnRlcm5hbF9nZXRfa2V5X2Z1bmMgPSBJUl9LQkRfR0VUX0tFWV9IQVVQX1hWUjsKKwkJaW5pdF9kYXRhLT50eXBlICAgICAgICAgICAgICAgICAgPSBSQ19UWVBFX1JDNTsKKwkJaW5pdF9kYXRhLT5uYW1lICAgICAgICAgICAgICAgICAgPSBoZHctPmhkd19kZXNjLT5kZXNjcmlwdGlvbjsKKwkJLyogSVIgUmVjZWl2ZXIgKi8KKwkJaW5mby5hZGRyICAgICAgICAgID0gMHg3MTsKKwkJaW5mby5wbGF0Zm9ybV9kYXRhID0gaW5pdF9kYXRhOworCQlzdHJsY3B5KGluZm8udHlwZSwgImlyX3J4X3o4ZjA4MTFfaGF1cCIsIEkyQ19OQU1FX1NJWkUpOworCQlwdnIyX3RyYWNlKFBWUjJfVFJBQ0VfSU5GTywgIkJpbmRpbmcgJXMgdG8gaTJjIGFkZHJlc3MgMHglMDJ4LiIsCisJCQkgICBpbmZvLnR5cGUsIGluZm8uYWRkcik7CisJCWkyY19uZXdfZGV2aWNlKCZoZHctPmkyY19hZGFwLCAmaW5mbyk7CisJCS8qIElSIFRyYXNtaXR0ZXIgKi8KKwkJaW5mby5hZGRyICAgICAgICAgID0gMHg3MDsKKwkJaW5mby5wbGF0Zm9ybV9kYXRhID0gaW5pdF9kYXRhOworCQlzdHJsY3B5KGluZm8udHlwZSwgImlyX3R4X3o4ZjA4MTFfaGF1cCIsIEkyQ19OQU1FX1NJWkUpOworCQlwdnIyX3RyYWNlKFBWUjJfVFJBQ0VfSU5GTywgIkJpbmRpbmcgJXMgdG8gaTJjIGFkZHJlc3MgMHglMDJ4LiIsCisJCQkgICBpbmZvLnR5cGUsIGluZm8uYWRkcik7CisJCWkyY19uZXdfZGV2aWNlKCZoZHctPmkyY19hZGFwLCAmaW5mbyk7CisJCWJyZWFrOworCWRlZmF1bHQ6CiAJCS8qIFRoZSBkZXZpY2UgZWl0aGVyIGRvZXNuJ3Qgc3VwcG9ydCBJMkMtYmFzZWQgSVIgb3Igd2UKIAkJICAgZG9uJ3Qga25vdyAoeWV0KSBob3cgdG8gb3BlcmF0ZSBJUiBvbiB0aGUgZGV2aWNlLiAqLwotCQlyZXR1cm47CisJCWJyZWFrOwogCX0KLQlwdnIyX3RyYWNlKFBWUjJfVFJBQ0VfSU5GTywKLQkJICAgIkJpbmRpbmcgaXJfdmlkZW8gdG8gaTJjIGFkZHJlc3MgMHglMDJ4LiIsIGFkZHIpOwotCW1lbXNldCgmaW5mbywgMCwgc2l6ZW9mKHN0cnVjdCBpMmNfYm9hcmRfaW5mbykpOwotCXN0cmxjcHkoaW5mby50eXBlLCAiaXJfdmlkZW8iLCBJMkNfTkFNRV9TSVpFKTsKLQlpbmZvLmFkZHIgPSBhZGRyOwotCWkyY19uZXdfZGV2aWNlKCZoZHctPmkyY19hZGFwLCAmaW5mbyk7CiB9CiAKIHZvaWQgcHZyMl9pMmNfY29yZV9pbml0KHN0cnVjdCBwdnIyX2hkdyAqaGR3KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9zYWE3MTE1LmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3NhYTcxMTUuYwppbmRleCBmMzU0NTlkLi4wZGI5MDkyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3NhYTcxMTUuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3NhYTcxMTUuYwpAQCAtMTU2NSw3ICsxNTY1LDcgQEAKIAljaGlwX2lkID0gbmFtZVs1XTsKIAogCS8qIENoZWNrIHdoZXRoZXIgdGhpcyBjaGlwIGlzIHBhcnQgb2YgdGhlIHNhYTcxMXggc2VyaWVzICovCi0JaWYgKG1lbWNtcChuYW1lLCAiMWY3MTEiLCA1KSkgeworCWlmIChtZW1jbXAobmFtZSArIDEsICJmNzExIiwgNCkpIHsKIAkJdjRsX2RiZygxLCBkZWJ1ZywgY2xpZW50LCAiY2hpcCBmb3VuZCBAIDB4JXggKElEICVzKSBkb2VzIG5vdCBtYXRjaCBhIGtub3duIHNhYTcxMXggY2hpcC5cbiIsCiAJCQljbGllbnQtPmFkZHIgPDwgMSwgbmFtZSk7CiAJCXJldHVybiAtRU5PREVWOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9zYWE3MTM0L3NhYTcxMzQtY2FyZHMuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vc2FhNzEzNC9zYWE3MTM0LWNhcmRzLmMKaW5kZXggZTdhYTU4OC4uZGViOGZjZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9zYWE3MTM0L3NhYTcxMzQtY2FyZHMuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3NhYTcxMzQvc2FhNzEzNC1jYXJkcy5jCkBAIC01MTc5LDE4ICs1MTc5LDggQEAKIAlbU0FBNzEzNF9CT0FSRF9LV09STERfUENJX1NCVFZEX0ZVTExTRUddID0gewogCQkubmFtZSAgICAgICAgICAgPSAiS3dvcmxkIFBDSSBTQlRWRC9JU0RCLVQgRnVsbC1TZWcgSHlicmlkIiwKIAkJLmF1ZGlvX2Nsb2NrICAgID0gMHgwMDE4N2RlNywKLSNpZiAwCi0JLyoKLQkgKiBGSVhNRTogQW5hbG9nIG1vZGUgZG9lc24ndCB3b3JrLCBpZiBkaWdpdGFsIGlzIGVuYWJsZWQuIFRoZSBwcm9wZXIKLQkgKiBmaXggaXMgdG8gdXNlIHRkYTgyOTAgZHJpdmVyLCBidXQgS3dvcmxkIHNlZW1zIHRvIHVzZSBhbgotCSAqIHVuc3VwcG9ydGVkIHZlcnNpb24gb2YgdGRhODI5NS4KLQkgKi8KLQkJLnR1bmVyX3R5cGUgICAgID0gVFVORVJfTlhQX1REQTE4MjcxLAkvKiBUVU5FUl9QSElMSVBTX1REQTgyOTAgKi8KLQkJLnR1bmVyX2FkZHIgICAgID0gMHg2MCwKLSNlbHNlCi0JCS50dW5lcl90eXBlICAgICA9IFVOU0VULAorCQkudHVuZXJfdHlwZSAgICAgPSBUVU5FUl9QSElMSVBTX1REQTgyOTAsCiAJCS50dW5lcl9hZGRyICAgICA9IEFERFJfVU5TRVQsCi0jZW5kaWYKIAkJLnJhZGlvX3R5cGUgICAgID0gVU5TRVQsCiAJCS5yYWRpb19hZGRyCT0gQUREUl9VTlNFVCwKIAkJLmdwaW9tYXNrICAgICAgID0gMHg4ZTA1NDAwMCwKQEAgLTY5MzIsMTAgKzY5MjIsMTcgQEAKIAkvKiB0b2dnbGUgQUdDIHN3aXRjaCB0aHJvdWdoIEdQSU8gMjcgKi8KIAlzd2l0Y2ggKG1vZGUpIHsKIAljYXNlIFREQTE4MjcxX0FOQUxPRzoKLQkJc2FhNzEzNF9zZXRfZ3BpbyhkZXYsIDI3LCAwKTsKKwkJc2FhX3dyaXRlbChTQUE3MTM0X0dQSU9fR1BNT0RFMCA+PiAyLCAweDQwMDApOworCQlzYWFfd3JpdGVsKFNBQTcxMzRfR1BJT19HUFNUQVRVUzAgPj4gMiwgMHg0MDAwKTsKKwkJbXNsZWVwKDIwKTsKIAkJYnJlYWs7CiAJY2FzZSBUREExODI3MV9ESUdJVEFMOgotCQlzYWE3MTM0X3NldF9ncGlvKGRldiwgMjcsIDEpOworCQlzYWFfd3JpdGVsKFNBQTcxMzRfR1BJT19HUE1PREUwID4+IDIsIDB4MTQwMDApOworCQlzYWFfd3JpdGVsKFNBQTcxMzRfR1BJT19HUFNUQVRVUzAgPj4gMiwgMHgxNDAwMCk7CisJCW1zbGVlcCgyMCk7CisJCXNhYV93cml0ZWwoU0FBNzEzNF9HUElPX0dQTU9ERTAgPj4gMiwgMHg1NDAwMCk7CisJCXNhYV93cml0ZWwoU0FBNzEzNF9HUElPX0dQU1RBVFVTMCA+PiAyLCAweDU0MDAwKTsKKwkJbXNsZWVwKDMwKTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJcmV0dXJuIC1FSU5WQUw7CkBAIC02OTkzLDYgKzY5OTAsNyBAQAogaW50IHNhYTcxMzRfdHVuZXJfY2FsbGJhY2sodm9pZCAqcHJpdiwgaW50IGNvbXBvbmVudCwgaW50IGNvbW1hbmQsIGludCBhcmcpCiB7CiAJc3RydWN0IHNhYTcxMzRfZGV2ICpkZXYgPSBwcml2OworCiAJaWYgKGRldiAhPSBOVUxMKSB7CiAJCXN3aXRjaCAoZGV2LT50dW5lcl90eXBlKSB7CiAJCWNhc2UgVFVORVJfUEhJTElQU19UREE4MjkwOgpAQCAtNzY1OSwzNiArNzY1NywxMSBAQAogCQlicmVhazsKIAl9CiAJY2FzZSBTQUE3MTM0X0JPQVJEX0tXT1JMRF9QQ0lfU0JUVkRfRlVMTFNFRzoKLQl7Ci0JCXN0cnVjdCBpMmNfbXNnIG1zZyA9IHsgLmFkZHIgPSAweDRiLCAuZmxhZ3MgPSAwIH07Ci0JCWludCBpOwotCQlzdGF0aWMgdTggYnVmZmVyW11bMl0gPSB7Ci0JCQl7MHgzMCwgMHgzMX0sCi0JCQl7MHhmZiwgMHgwMH0sCi0JCQl7MHg0MSwgMHgwM30sCi0JCQl7MHg0MSwgMHgxYX0sCi0JCQl7MHhmZiwgMHgwMn0sCi0JCQl7MHgzNCwgMHgwMH0sCi0JCQl7MHg0NSwgMHg5N30sCi0JCQl7MHg0NSwgMHhjMX0sCi0JCX07CiAJCXNhYV93cml0ZWwoU0FBNzEzNF9HUElPX0dQTU9ERTAgPj4gMiwgMHg0MDAwKTsKIAkJc2FhX3dyaXRlbChTQUE3MTM0X0dQSU9fR1BTVEFUVVMwID4+IDIsIDB4NDAwMCk7CiAKLQkJLyoKLQkJICogRklYTUU6IGlkZW50aWZ5IHdoYXQgZGV2aWNlIGlzIGF0IGFkZHIgMHg0YiBhbmQgd2hhdCBtZWFucwotCQkgKiB0aGlzIGluaXRpYWxpemF0aW9uCi0JCSAqLwotCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShidWZmZXIpOyBpKyspIHsKLQkJCW1zZy5idWYgPSAmYnVmZmVyW2ldWzBdOwotCQkJbXNnLmxlbiA9IEFSUkFZX1NJWkUoYnVmZmVyWzBdKTsKLQkJCWlmIChpMmNfdHJhbnNmZXIoJmRldi0+aTJjX2FkYXAsICZtc2csIDEpICE9IDEpCi0JCQkJcHJpbnRrKEtFUk5fV0FSTklORwotCQkJCSAgICAgICAiJXM6IFVuYWJsZSB0byBlbmFibGUgdHVuZXIoJWkpLlxuIiwKLQkJCQkgICAgICAgZGV2LT5uYW1lLCBpKTsKLQkJfQorCQlzYWE3MTM0X3NldF9ncGlvKGRldiwgMjcsIDApOwogCQlicmVhazsKLQl9CiAJfSAvKiBzd2l0Y2goKSAqLwogCiAJLyogaW5pdGlhbGl6ZSB0dW5lciAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9zYWE3MTM0L3NhYTcxMzQtZHZiLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3NhYTcxMzQvc2FhNzEzNC1kdmIuYwppbmRleCAzMzE1YTQ4Li5mNjVjYWQyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3NhYTcxMzQvc2FhNzEzNC1kdmIuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3NhYTcxMzQvc2FhNzEzNC1kdmIuYwpAQCAtMjM3LDEyICsyMzcsMzkgQEAKIHN0YXRpYyBzdHJ1Y3QgdGRhMTgyNzFfY29uZmlnIGt3b3JsZF90ZGExODI3MV9jb25maWcgPSB7CiAJLnN0ZF9tYXAgPSAmbWI4NmEyMHNfdGRhMTgyNzFfc3RkX21hcCwKIAkuZ2F0ZSAgICA9IFREQTE4MjcxX0dBVEVfRElHSVRBTCwKKwkuY29uZmlnICA9IDMsCS8qIFVzZSB0dW5lciBjYWxsYmFjayBmb3IgQUdDICovCisKIH07CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgbWI4NmEyMHNfY29uZmlnIGt3b3JsZF9tYjg2YTIwc19jb25maWcgPSB7CiAJLmRlbW9kX2FkZHJlc3MgPSAweDEwLAogfTsKIAorc3RhdGljIGludCBrd29ybGRfc2J0dmRfZ2F0ZV9jdHJsKHN0cnVjdCBkdmJfZnJvbnRlbmQqIGZlLCBpbnQgZW5hYmxlKQoreworCXN0cnVjdCBzYWE3MTM0X2RldiAqZGV2ID0gZmUtPmR2Yi0+cHJpdjsKKworCXVuc2lnbmVkIGNoYXIgaW5pdG1zZ1tdID0gezB4NDUsIDB4OTd9OworCXVuc2lnbmVkIGNoYXIgbXNnX2VuYWJsZVtdID0gezB4NDUsIDB4YzF9OworCXVuc2lnbmVkIGNoYXIgbXNnX2Rpc2FibGVbXSA9IHsweDQ1LCAweDgxfTsKKwlzdHJ1Y3QgaTJjX21zZyBtc2cgPSB7LmFkZHIgPSAweDRiLCAuZmxhZ3MgPSAwLCAuYnVmID0gaW5pdG1zZywgLmxlbiA9IDJ9OworCisJaWYgKGkyY190cmFuc2ZlcigmZGV2LT5pMmNfYWRhcCwgJm1zZywgMSkgIT0gMSkgeworCQl3cHJpbnRrKCJjb3VsZCBub3QgYWNjZXNzIHRoZSBJMkMgZ2F0ZVxuIik7CisJCXJldHVybiAtRUlPOworCX0KKwlpZiAoZW5hYmxlKQorCQltc2cuYnVmID0gbXNnX2VuYWJsZTsKKwllbHNlCisJCW1zZy5idWYgPSBtc2dfZGlzYWJsZTsKKwlpZiAoaTJjX3RyYW5zZmVyKCZkZXYtPmkyY19hZGFwLCAmbXNnLCAxKSAhPSAxKSB7CisJCXdwcmludGsoImNvdWxkIG5vdCBhY2Nlc3MgdGhlIEkyQyBnYXRlXG4iKTsKKwkJcmV0dXJuIC1FSU87CisJfQorCW1zbGVlcCgyMCk7CisJcmV0dXJuIDA7Cit9CisKIC8qID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogICogdGRhMTAwNHggYmFzZWQgRFZCLVQgY2FyZHMsIGhlbHBlciBmdW5jdGlvbnMKICAqLwpAQCAtNjIzLDM3ICs2NTAsNiBAQAogCiAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KIAotc3RhdGljIGludCBfX2t3b3JsZF9zYnR2ZF9pMmNfZ2F0ZV9jdHJsKHN0cnVjdCBzYWE3MTM0X2RldiAqZGV2LCBpbnQgZW5hYmxlKQotewotCXVuc2lnbmVkIGNoYXIgaW5pdG1zZ1tdID0gezB4NDUsIDB4OTd9OwotCXVuc2lnbmVkIGNoYXIgbXNnX2VuYWJsZVtdID0gezB4NDUsIDB4YzF9OwotCXVuc2lnbmVkIGNoYXIgbXNnX2Rpc2FibGVbXSA9IHsweDQ1LCAweDgxfTsKLQlzdHJ1Y3QgaTJjX21zZyBtc2cgPSB7LmFkZHIgPSAweDRiLCAuZmxhZ3MgPSAwLCAuYnVmID0gaW5pdG1zZywgLmxlbiA9IDJ9OwotCi0JaWYgKGkyY190cmFuc2ZlcigmZGV2LT5pMmNfYWRhcCwgJm1zZywgMSkgIT0gMSkgewotCQl3cHJpbnRrKCJjb3VsZCBub3QgYWNjZXNzIHRoZSBJMkMgZ2F0ZVxuIik7Ci0JCXJldHVybiAtRUlPOwotCX0KLQlpZiAoZW5hYmxlKQotCQltc2cuYnVmID0gbXNnX2VuYWJsZTsKLQllbHNlCi0JCW1zZy5idWYgPSBtc2dfZGlzYWJsZTsKLQlpZiAoaTJjX3RyYW5zZmVyKCZkZXYtPmkyY19hZGFwLCAmbXNnLCAxKSAhPSAxKSB7Ci0JCXdwcmludGsoImNvdWxkIG5vdCBhY2Nlc3MgdGhlIEkyQyBnYXRlXG4iKTsKLQkJcmV0dXJuIC1FSU87Ci0JfQotCW1zbGVlcCgyMCk7Ci0JcmV0dXJuIDA7Ci19Ci1zdGF0aWMgaW50IGt3b3JsZF9zYnR2ZF9pMmNfZ2F0ZV9jdHJsKHN0cnVjdCBkdmJfZnJvbnRlbmQgKmZlLCBpbnQgZW5hYmxlKQotewotCXN0cnVjdCBzYWE3MTM0X2RldiAqZGV2ID0gZmUtPmR2Yi0+cHJpdjsKLQotCXJldHVybiBfX2t3b3JsZF9zYnR2ZF9pMmNfZ2F0ZV9jdHJsKGRldiwgZW5hYmxlKTsKLX0KLQotLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCi0KIHN0YXRpYyBzdHJ1Y3QgdGRhMTAwNHhfY29uZmlnIHRkYTgyN3hfbGlmZXZpZXdfY29uZmlnID0gewogCS5kZW1vZF9hZGRyZXNzID0gMHgwOCwKIAkuaW52ZXJ0ICAgICAgICA9IDEsCkBAIC0xNjYwLDI3ICsxNjU2LDIzIEBACiAJCX0KIAkJYnJlYWs7CiAJY2FzZSBTQUE3MTM0X0JPQVJEX0tXT1JMRF9QQ0lfU0JUVkRfRlVMTFNFRzoKLQkJX19rd29ybGRfc2J0dmRfaTJjX2dhdGVfY3RybChkZXYsIDApOwotCQlzYWFfd3JpdGVsKFNBQTcxMzRfR1BJT19HUE1PREUwID4+IDIsIDB4MTQwMDApOwotCQlzYWFfd3JpdGVsKFNBQTcxMzRfR1BJT19HUFNUQVRVUzAgPj4gMiwgMHgxNDAwMCk7Ci0JCW1zbGVlcCgyMCk7Ci0JCXNhYV93cml0ZWwoU0FBNzEzNF9HUElPX0dQTU9ERTAgPj4gMiwgMHg1NDAwMCk7Ci0JCXNhYV93cml0ZWwoU0FBNzEzNF9HUElPX0dQU1RBVFVTMCA+PiAyLCAweDU0MDAwKTsKLQkJbXNsZWVwKDIwKTsKKwkJLyogU3dpdGNoIHRvIGRpZ2l0YWwgbW9kZSAqLworCQlzYWE3MTM0X3R1bmVyX2NhbGxiYWNrKGRldiwgMCwKKwkJCQkgICAgICAgVERBMTgyNzFfQ0FMTEJBQ0tfQ01EX0FHQ19FTkFCTEUsIDEpOwogCQlmZTAtPmR2Yi5mcm9udGVuZCA9IGR2Yl9hdHRhY2gobWI4NmEyMHNfYXR0YWNoLAogCQkJCQkgICAgICAgJmt3b3JsZF9tYjg2YTIwc19jb25maWcsCiAJCQkJCSAgICAgICAmZGV2LT5pMmNfYWRhcCk7Ci0JCV9fa3dvcmxkX3NidHZkX2kyY19nYXRlX2N0cmwoZGV2LCAxKTsKIAkJaWYgKGZlMC0+ZHZiLmZyb250ZW5kICE9IE5VTEwpIHsKKwkJCWR2Yl9hdHRhY2godGRhODI5eF9hdHRhY2gsIGZlMC0+ZHZiLmZyb250ZW5kLAorCQkJCSAgICZkZXYtPmkyY19hZGFwLCAweDRiLAorCQkJCSAgICZ0ZGE4Mjl4X25vX3Byb2JlKTsKIAkJCWR2Yl9hdHRhY2godGRhMTgyNzFfYXR0YWNoLCBmZTAtPmR2Yi5mcm9udGVuZCwKIAkJCQkgICAweDYwLCAmZGV2LT5pMmNfYWRhcCwKIAkJCQkgICAma3dvcmxkX3RkYTE4MjcxX2NvbmZpZyk7Ci0JCQkvKgotCQkJICogT25seSBhZnRlciBzdWNjZXNzLCBpdCBjYW4gaW5pdGlhbGl6ZSB0aGUgZ2F0ZSwgb3RoZXJ3aXNlCi0JCQkgKiBhbiBPT1BTIHdpbGwgaGl0LCBkdWUgdG8ga2ZyZWUoZmUwLT5kdmIuZnJvbnRlbmQpCi0JCQkgKi8KLQkJCWZlMC0+ZHZiLmZyb250ZW5kLT5vcHMuaTJjX2dhdGVfY3RybCA9IGt3b3JsZF9zYnR2ZF9pMmNfZ2F0ZV9jdHJsOworCQkJZmUwLT5kdmIuZnJvbnRlbmQtPm9wcy5pMmNfZ2F0ZV9jdHJsID0ga3dvcmxkX3NidHZkX2dhdGVfY3RybDsKIAkJfQorCisJCS8qIG1iODZhMjBzIG5lZWQgdG8gdXNlIHRoZSBJMkMgZ2F0ZXdheSAqLwogCQlicmVhazsKIAlkZWZhdWx0OgogCQl3cHJpbnRrKCJIdWg/IHVua25vd24gRFZCIGNhcmQ/XG4iKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vc245YzEwMi9zbjljMTAyX2RldnRhYmxlLmggYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3NuOWMxMDIvc245YzEwMl9kZXZ0YWJsZS5oCmluZGV4IDQxMDY0YzcuLmIzZDJjYzcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vc245YzEwMi9zbjljMTAyX2RldnRhYmxlLmgKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby9zbjljMTAyL3NuOWMxMDJfZGV2dGFibGUuaApAQCAtNDcsOCArNDcsOCBAQAogCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MDA5LCBCUklER0VfU045QzEwMiksIH0sCiAJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwMGQsIEJSSURHRV9TTjlDMTAyKSwgfSwKIC8qCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MDExLCBCUklER0VfU045QzEwMiksIH0sIE9WNjY1MCAqLwotI2VuZGlmCiAJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwMTksIEJSSURHRV9TTjlDMTAyKSwgfSwKKyNlbmRpZgogCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MDI0LCBCUklER0VfU045QzEwMiksIH0sCiAJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwMjUsIEJSSURHRV9TTjlDMTAyKSwgfSwKICNpZiAhZGVmaW5lZCBDT05GSUdfVVNCX0dTUENBX1NPTklYQiAmJiAhZGVmaW5lZCBDT05GSUdfVVNCX0dTUENBX1NPTklYQl9NT0RVTEUKQEAgLTU2LDc4ICs1Niw2OCBAQAogCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MDI5LCBCUklER0VfU045QzEwMiksIH0sCiAJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwMmEsIEJSSURHRV9TTjlDMTAyKSwgfSwKICNlbmRpZgotCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MDJiLCBCUklER0VfU045QzEwMiksIH0sCisJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwMmIsIEJSSURHRV9TTjlDMTAyKSwgfSwgLyogbm90IGluIHNvbml4YiAqLwogI2lmICFkZWZpbmVkIENPTkZJR19VU0JfR1NQQ0FfU09OSVhCICYmICFkZWZpbmVkIENPTkZJR19VU0JfR1NQQ0FfU09OSVhCX01PRFVMRQogCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MDJjLCBCUklER0VfU045QzEwMiksIH0sCiAvKgl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjAyZCwgQlJJREdFX1NOOUMxMDIpLCB9LCBIVjcxMzFSICovCiAJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwMmUsIEJSSURHRV9TTjlDMTAyKSwgfSwKICNlbmRpZgotCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MDMwLCBCUklER0VfU045QzEwMiksIH0sCisJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwMzAsIEJSSURHRV9TTjlDMTAyKSwgfSwgLyogbm90IGluIHNvbml4YiAqLwogCS8qIFNOOUMxMDMgKi8KLQl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjA4MCwgQlJJREdFX1NOOUMxMDMpLCB9LAotCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MDgyLCBCUklER0VfU045QzEwMyksIH0sCisvKgl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjA4MCwgQlJJREdFX1NOOUMxMDMpLCB9LCBub24gZXhpc3RlbnQgPyAqLworCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MDgyLCBCUklER0VfU045QzEwMyksIH0sIC8qIG5vdCBpbiBzb25peGIgKi8KKyNpZiAhZGVmaW5lZCBDT05GSUdfVVNCX0dTUENBX1NPTklYQiAmJiAhZGVmaW5lZCBDT05GSUdfVVNCX0dTUENBX1NPTklYQl9NT0RVTEUKIC8qCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MDgzLCBCUklER0VfU045QzEwMyksIH0sIEhZNzEzMUQvRSAqLwotCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MDg4LCBCUklER0VfU045QzEwMyksIH0sCi0JeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwOGEsIEJSSURHRV9TTjlDMTAzKSwgfSwKLQl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjA4YiwgQlJJREdFX1NOOUMxMDMpLCB9LAorLyoJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwODgsIEJSSURHRV9TTjlDMTAzKSwgfSwgbm9uIGV4aXN0ZW50ID8gKi8KKy8qCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MDhhLCBCUklER0VfU045QzEwMyksIH0sIG5vbiBleGlzdGVudCA/ICovCisvKgl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjA4YiwgQlJJREdFX1NOOUMxMDMpLCB9LCBub24gZXhpc3RlbnQgPyAqLwogCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MDhjLCBCUklER0VfU045QzEwMyksIH0sCiAvKgl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjA4ZSwgQlJJREdFX1NOOUMxMDMpLCB9LCBDSVNWRjEwICovCi0jaWYgIWRlZmluZWQgQ09ORklHX1VTQl9HU1BDQV9TT05JWEIgJiYgIWRlZmluZWQgQ09ORklHX1VTQl9HU1BDQV9TT05JWEJfTU9EVUxFCiAJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwOGYsIEJSSURHRV9TTjlDMTAzKSwgfSwKLSNlbmRpZgotCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MGEwLCBCUklER0VfU045QzEwMyksIH0sCi0JeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYTIsIEJSSURHRV9TTjlDMTAzKSwgfSwKLQl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBhMywgQlJJREdFX1NOOUMxMDMpLCB9LAorLyoJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYTAsIEJSSURHRV9TTjlDMTAzKSwgfSwgbm9uIGV4aXN0ZW50ID8gKi8KKy8qCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MGEyLCBCUklER0VfU045QzEwMyksIH0sIG5vbiBleGlzdGVudCA/ICovCisvKgl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBhMywgQlJJREdFX1NOOUMxMDMpLCB9LCBub24gZXhpc3RlbnQgPyAqLwogLyoJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYTgsIEJSSURHRV9TTjlDMTAzKSwgfSwgUEFTMTA2ICovCiAvKgl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBhYSwgQlJJREdFX1NOOUMxMDMpLCB9LCBUQVM1MTMwICovCi0vKgl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBhYiwgQlJJREdFX1NOOUMxMDMpLCB9LCBUQVM1MTMwICovCi0JeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYWMsIEJSSURHRV9TTjlDMTAzKSwgfSwKLQl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBhZSwgQlJJREdFX1NOOUMxMDMpLCB9LAorLyoJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYWIsIEJSSURHRV9TTjlDMTAzKSwgfSwgVEFTNTExMCwgbm9uIGV4aXN0ZW50ICovCisvKgl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBhYywgQlJJREdFX1NOOUMxMDMpLCB9LCBub24gZXhpc3RlbnQgPyAqLworLyoJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYWUsIEJSSURHRV9TTjlDMTAzKSwgfSwgbm9uIGV4aXN0ZW50ID8gKi8KIAl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBhZiwgQlJJREdFX1NOOUMxMDMpLCB9LAotI2lmICFkZWZpbmVkIENPTkZJR19VU0JfR1NQQ0FfU09OSVhCICYmICFkZWZpbmVkIENPTkZJR19VU0JfR1NQQ0FfU09OSVhCX01PRFVMRQogCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MGIwLCBCUklER0VfU045QzEwMyksIH0sCisvKgl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBiMiwgQlJJREdFX1NOOUMxMDMpLCB9LCBub24gZXhpc3RlbnQgPyAqLworLyoJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYjMsIEJSSURHRV9TTjlDMTAzKSwgfSwgbm9uIGV4aXN0ZW50ID8gKi8KKy8qCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MGI4LCBCUklER0VfU045QzEwMyksIH0sIG5vbiBleGlzdGVudCA/ICovCisvKgl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBiYSwgQlJJREdFX1NOOUMxMDMpLCB9LCBub24gZXhpc3RlbnQgPyAqLworLyoJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYmIsIEJSSURHRV9TTjlDMTAzKSwgfSwgbm9uIGV4aXN0ZW50ID8gKi8KKy8qCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MGJjLCBCUklER0VfU045QzEwMyksIH0sIG5vbiBleGlzdGVudCA/ICovCisvKgl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBiZSwgQlJJREdFX1NOOUMxMDMpLCB9LCBub24gZXhpc3RlbnQgPyAqLwogI2VuZGlmCi0JeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYjIsIEJSSURHRV9TTjlDMTAzKSwgfSwKLQl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBiMywgQlJJREdFX1NOOUMxMDMpLCB9LAotCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MGI4LCBCUklER0VfU045QzEwMyksIH0sCi0JeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYmEsIEJSSURHRV9TTjlDMTAzKSwgfSwKLQl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBiYiwgQlJJREdFX1NOOUMxMDMpLCB9LAotCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MGJjLCBCUklER0VfU045QzEwMyksIH0sCi0JeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYmUsIEJSSURHRV9TTjlDMTAzKSwgfSwKIAkvKiBTTjlDMTA1ICovCiAjaWYgIWRlZmluZWQgQ09ORklHX1VTQl9HU1BDQV9TT05JWEogJiYgIWRlZmluZWQgQ09ORklHX1VTQl9HU1BDQV9TT05JWEpfTU9EVUxFCiAJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwNDVlLCAweDAwZjUsIEJSSURHRV9TTjlDMTA1KSwgfSwKIAl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDA0NWUsIDB4MDBmNywgQlJJREdFX1NOOUMxMDUpLCB9LAogCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MDQ3MSwgMHgwMzI3LCBCUklER0VfU045QzEwNSksIH0sCiAJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwNDcxLCAweDAzMjgsIEJSSURHRV9TTjlDMTA1KSwgfSwKLSNlbmRpZgogCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MGMwLCBCUklER0VfU045QzEwNSksIH0sCi0JeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYzIsIEJSSURHRV9TTjlDMTA1KSwgfSwKLQl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBjOCwgQlJJREdFX1NOOUMxMDUpLCB9LAotCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MGNjLCBCUklER0VfU045QzEwNSksIH0sCi0JeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwZWEsIEJSSURHRV9TTjlDMTA1KSwgfSwKLQl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBlYywgQlJJREdFX1NOOUMxMDUpLCB9LAotCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MGVmLCBCUklER0VfU045QzEwNSksIH0sCi0JeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwZmEsIEJSSURHRV9TTjlDMTA1KSwgfSwKKy8qCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MGMyLCBCUklER0VfU045QzEwNSksIH0sIFBPMTAzMCAqLworLyoJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwYzgsIEJSSURHRV9TTjlDMTA1KSwgfSwgT002ODAxICovCisvKgl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBjYywgQlJJREdFX1NOOUMxMDUpLCB9LCBIVjcxMzFHUCAqLworLyoJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwZWEsIEJSSURHRV9TTjlDMTA1KSwgfSwgbm9uIGV4aXN0ZW50ID8gKi8KKy8qCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MGVjLCBCUklER0VfU045QzEwNSksIH0sIE1PNDAwMCAqLworLyoJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwZWYsIEJSSURHRV9TTjlDMTA1KSwgfSwgSUNNMTA1QyAqLworLyoJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwZmEsIEJSSURHRV9TTjlDMTA1KSwgfSwgT1Y3NjQ4ICovCiAJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYwZmIsIEJSSURHRV9TTjlDMTA1KSwgfSwKIAl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjBmYywgQlJJREdFX1NOOUMxMDUpLCB9LAogCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MGZlLCBCUklER0VfU045QzEwNSksIH0sCiAJLyogU045QzEyMCAqLwogCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MDQ1OCwgMHg3MDI1LCBCUklER0VfU045QzEyMCksIH0sCi0jaWYgIWRlZmluZWQgQ09ORklHX1VTQl9HU1BDQV9TT05JWEogJiYgIWRlZmluZWQgQ09ORklHX1VTQl9HU1BDQV9TT05JWEpfTU9EVUxFCi0JeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYxMDIsIEJSSURHRV9TTjlDMTIwKSwgfSwKLSNlbmRpZgotCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MTA4LCBCUklER0VfU045QzEyMCksIH0sCi0JeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYxMGYsIEJSSURHRV9TTjlDMTIwKSwgfSwKLSNpZiAhZGVmaW5lZCBDT05GSUdfVVNCX0dTUENBX1NPTklYSiAmJiAhZGVmaW5lZCBDT05GSUdfVVNCX0dTUENBX1NPTklYSl9NT0RVTEUKKy8qCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MTAyLCBCUklER0VfU045QzEyMCksIH0sIHBvMjAzMCAqLworLyoJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYxMDgsIEJSSURHRV9TTjlDMTIwKSwgfSwgb202ODAxICovCisvKgl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjEwZiwgQlJJREdFX1NOOUMxMjApLCB9LCBTNUs1M0JFQiAqLwogCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MTMwLCBCUklER0VfU045QzEyMCksIH0sCi0jZW5kaWYKIC8qCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MTM4LCBCUklER0VfU045QzEyMCksIH0sIE1PODAwMCAqLwotI2lmICFkZWZpbmVkIENPTkZJR19VU0JfR1NQQ0FfU09OSVhKICYmICFkZWZpbmVkIENPTkZJR19VU0JfR1NQQ0FfU09OSVhKX01PRFVMRQogCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MTNhLCBCUklER0VfU045QzEyMCksIH0sCi0jZW5kaWYKIAl7IFNOOUMxMDJfVVNCX0RFVklDRSgweDBjNDUsIDB4NjEzYiwgQlJJREdFX1NOOUMxMjApLCB9LAotI2lmICFkZWZpbmVkIENPTkZJR19VU0JfR1NQQ0FfU09OSVhKICYmICFkZWZpbmVkIENPTkZJR19VU0JfR1NQQ0FfU09OSVhKX01PRFVMRQogCXsgU045QzEwMl9VU0JfREVWSUNFKDB4MGM0NSwgMHg2MTNjLCBCUklER0VfU045QzEyMCksIH0sCiAJeyBTTjlDMTAyX1VTQl9ERVZJQ0UoMHgwYzQ1LCAweDYxM2UsIEJSSURHRV9TTjlDMTIwKSwgfSwKICNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9zcjAzMHBjMzAuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vc3IwMzBwYzMwLmMKaW5kZXggODY0Njk2Yi4uYzkwMTcyMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby9zcjAzMHBjMzAuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3NyMDMwcGMzMC5jCkBAIC03MTQsMTUgKzcxNCw2IEBACiAJcmV0dXJuIHJldDsKIH0KIAotc3RhdGljIGludCBzcjAzMHBjMzBfc19jb25maWcoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCwKLQkJCSAgICAgIGludCBpcnEsIHZvaWQgKnBsYXRmb3JtX2RhdGEpCi17Ci0Jc3RydWN0IHNyMDMwcGMzMF9pbmZvICppbmZvID0gdG9fc3IwMzBwYzMwKHNkKTsKLQotCWluZm8tPnBkYXRhID0gcGxhdGZvcm1fZGF0YTsKLQlyZXR1cm4gMDsKLX0KLQogc3RhdGljIGludCBzcjAzMHBjMzBfc19zdHJlYW0oc3RydWN0IHY0bDJfc3ViZGV2ICpzZCwgaW50IGVuYWJsZSkKIHsKIAlyZXR1cm4gMDsKQEAgLTc2Myw3ICs3NTQsNiBAQAogfQogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHY0bDJfc3ViZGV2X2NvcmVfb3BzIHNyMDMwcGMzMF9jb3JlX29wcyA9IHsKLQkuc19jb25maWcJPSBzcjAzMHBjMzBfc19jb25maWcsCiAJLnNfcG93ZXIJPSBzcjAzMHBjMzBfc19wb3dlciwKIAkucXVlcnljdHJsCT0gc3IwMzBwYzMwX3F1ZXJ5Y3RybCwKIAkuc19jdHJsCQk9IHNyMDMwcGMzMF9zX2N0cmwsCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3RkYTk4NzUuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vdGRhOTg3NS5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzNWI2ZmY1Li4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vdGRhOTg3NS5jCisrKyAvZGV2L251bGwKQEAgLTEsNDExICswLDAgQEAKLS8qCi0gKiBGb3IgdGhlIFREQTk4NzUgY2hpcAotICogKFRoZSBUREE5ODc1IGlzIHVzZWQgb24gdGhlIERpYW1vbmQgRFRWMjAwMCBmcmVuY2ggdmVyc2lvbgotICogT3RoZXIgY2FyZHMgcHJvYmFibHkgdXNlIHRoZXNlIGNoaXBzIGFzIHdlbGwuKQotICogVGhpcyBkcml2ZXIgd2lsbCBub3QgY29tcGxhaW4gaWYgdXNlZCB3aXRoIGFueQotICogb3RoZXIgaTJjIGRldmljZSB3aXRoIHRoZSBzYW1lIGFkZHJlc3MuCi0gKgotICogQ29weXJpZ2h0IChjKSAyMDAwIEd1aWxsYXVtZSBEZWx2aXQgYmFzZWQgb24gR2VyZCBLbm9yciBzb3VyY2UgYW5kCi0gKiBFcmljIFNhbmRlZW4KLSAqIENvcHlyaWdodCAoYykgMjAwNiBNYXVybyBDYXJ2YWxobyBDaGVoYWIgPG1jaGVoYWJAaW5mcmFkZWFkLm9yZz4KLSAqIFRoaXMgY29kZSBpcyBwbGFjZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogQmFzZWQgb24gdGRhOTg1NS5jIGJ5IFN0ZXZlIFZhbkRlQm9nYXJ0ICh2YW5kZWJvQHVjbGluay5iZXJrZWxleS5lZHUpCi0gKiBXaGljaCB3YXMgYmFzZWQgb24gdGRhODQyNS5jIGJ5IEdyZWcgQWxleGFuZGVyIChjKSAxOTk4Ci0gKgotICogT1BUSU9OUzoKLSAqIGRlYnVnICAgLSBzZXQgdG8gMSBpZiB5b3UnZCBsaWtlIHRvIHNlZSBkZWJ1ZyBtZXNzYWdlcwotICoKLSAqICBSZXZpc2lvbjogMC4xIC0gb3JpZ2luYWwgdmVyc2lvbgotICovCi0KLSNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KLSNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KLSNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KLSNpbmNsdWRlIDxsaW51eC90aW1lci5oPgotI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+Ci0jaW5jbHVkZSA8bGludXgvZXJybm8uaD4KLSNpbmNsdWRlIDxsaW51eC9zbGFiLmg+Ci0jaW5jbHVkZSA8bGludXgvaTJjLmg+Ci0jaW5jbHVkZSA8bGludXgvdmlkZW9kZXYyLmg+Ci0jaW5jbHVkZSA8bWVkaWEvdjRsMi1kZXZpY2UuaD4KLSNpbmNsdWRlIDxtZWRpYS9pMmMtYWRkci5oPgotCi1zdGF0aWMgaW50IGRlYnVnOyAvKiBpbnNtb2QgcGFyYW1ldGVyICovCi1tb2R1bGVfcGFyYW0oZGVidWcsIGludCwgU19JUlVHTyB8IFNfSVdVU1IpOwotTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwotCi0KLS8qIFRoaXMgaXMgYSBzdXBlcnNldCBvZiB0aGUgVERBOTg3NSAqLwotc3RydWN0IHRkYTk4NzUgewotCXN0cnVjdCB2NGwyX3N1YmRldiBzZDsKLQlpbnQgcnZvbCwgbHZvbDsKLQlpbnQgYmFzcywgdHJlYmxlOwotfTsKLQotc3RhdGljIGlubGluZSBzdHJ1Y3QgdGRhOTg3NSAqdG9fc3RhdGUoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCkKLXsKLQlyZXR1cm4gY29udGFpbmVyX29mKHNkLCBzdHJ1Y3QgdGRhOTg3NSwgc2QpOwotfQotCi0jZGVmaW5lIGRwcmludGsgIGlmIChkZWJ1ZykgcHJpbnRrCi0KLS8qIFRoZSBUREE5ODc1IGlzIG1hZGUgYnkgUGhpbGlwcyBTZW1pY29uZHVjdG9yCi0gKiBodHRwOi8vd3d3LnNlbWljb25kdWN0b3JzLnBoaWxpcHMuY29tCi0gKiBUREE5ODc1OiBJMkMtYnVzIGNvbnRyb2xsZWQgRFNQIGF1ZGlvIHByb2Nlc3NvciwgRk0gZGVtb2R1bGF0b3IKLSAqCi0gKi8KLQotCQkvKiBzdWJhZGRyZXNzZXMgZm9yIFREQTk4NzUgKi8KLSNkZWZpbmUgVERBOTg3NV9NVVQgICAgICAgICAweDEyICAvKkdlbmVyYWwgbXV0ZSAgKHZhbHVlIC0tPiAwYjExMDAxMTAwKi8KLSNkZWZpbmUgVERBOTg3NV9DRkcgICAgICAgICAweDAxICAvKiBDb25maWcgcmVnaXN0ZXIgKHZhbHVlIC0tPiAwYjAwMDAwMDAwICovCi0jZGVmaW5lIFREQTk4NzVfREFDT1MgICAgICAgMHgxMyAgLypEQUMgaS9vIHNlbGVjdCAoQURDKSAwYjAwMDAxMDAqLwotI2RlZmluZSBUREE5ODc1X0xPU1IgICAgICAgIDB4MTYgIC8qTGluZSBvdXRwdXQgc2VsZWN0IHJlZ2lydGVyIDBiMDEwMCAwMDAxKi8KLQotI2RlZmluZSBUREE5ODc1X0NIMVYgICAgICAgIDB4MGMgIC8qQ2hhbm5lbCAxIHZvbHVtZSAobXV0ZSkqLwotI2RlZmluZSBUREE5ODc1X0NIMlYgICAgICAgIDB4MGQgIC8qQ2hhbm5lbCAyIHZvbHVtZSAobXV0ZSkqLwotI2RlZmluZSBUREE5ODc1X1NDMSAgICAgICAgIDB4MTQgIC8qU0NBUlQgMSBpbiAobW9ubykqLwotI2RlZmluZSBUREE5ODc1X1NDMiAgICAgICAgIDB4MTUgIC8qU0NBUlQgMiBpbiAobW9ubykqLwotCi0jZGVmaW5lIFREQTk4NzVfQURDSVMgICAgICAgMHgxNyAgLypBREMgaW5wdXQgc2VsZWN0IChtb25vKSAwYjAxMTAgMDAwKi8KLSNkZWZpbmUgVERBOTg3NV9BRVIgICAgICAgICAweDE5ICAvKkF1ZGlvIGVmZmVjdCAoQVZMK1BzZXVkbykgMGIwMDAwIDAxMTAqLwotI2RlZmluZSBUREE5ODc1X01DUyAgICAgICAgIDB4MTggIC8qTWFpbiBjaGFubmVsIHNlbGVjdCAoREFDKSAwYjAwMDAxMDAqLwotI2RlZmluZSBUREE5ODc1X01WTCAgICAgICAgIDB4MWEgIC8qIE1haW4gdm9sdW1lIGdhdWNoZSAqLwotI2RlZmluZSBUREE5ODc1X01WUiAgICAgICAgIDB4MWIgIC8qIE1haW4gdm9sdW1lIGRyb2l0ZSAqLwotI2RlZmluZSBUREE5ODc1X01CQSAgICAgICAgIDB4MWQgIC8qIE1haW4gQmFzc2UgKi8KLSNkZWZpbmUgVERBOTg3NV9NVFIgICAgICAgICAweDFlICAvKiBNYWluIHRyZWJsZSAqLwotI2RlZmluZSBUREE5ODc1X0FDUyAgICAgICAgIDB4MWYgIC8qIEF1eGlsYXJ5IGNoYW5uZWwgc2VsZWN0IChGTSkgMGIwMDAwMDAwKi8KLSNkZWZpbmUgVERBOTg3NV9BVkwgICAgICAgICAweDIwICAvKiBBdXhpbGFyeSB2b2x1bWUgZ2F1Y2hlICovCi0jZGVmaW5lIFREQTk4NzVfQVZSICAgICAgICAgMHgyMSAgLyogQXV4aWxhcnkgdm9sdW1lIGRyb2l0ZSAqLwotI2RlZmluZSBUREE5ODc1X0FCQSAgICAgICAgIDB4MjIgIC8qIEF1eGlsYXJ5IEJhc3NlICovCi0jZGVmaW5lIFREQTk4NzVfQVRSICAgICAgICAgMHgyMyAgLyogQXV4aWxhcnkgdHJlYmxlICovCi0KLSNkZWZpbmUgVERBOTg3NV9NU1IgICAgICAgICAweDAyICAvKiBNb25pdG9yIHNlbGVjdCByZWdpc3RlciAqLwotI2RlZmluZSBUREE5ODc1X0MxTVNCICAgICAgIDB4MDMgIC8qIENhcnJpZXIgMSAoRk0pIGZyZXF1ZW5jeSByZWdpc3RlciBNU0IgKi8KLSNkZWZpbmUgVERBOTg3NV9DMU1JQiAgICAgICAweDA0ICAvKiBDYXJyaWVyIDEgKEZNKSBmcmVxdWVuY3kgcmVnaXN0ZXIgKDE2LThdYiAqLwotI2RlZmluZSBUREE5ODc1X0MxTFNCICAgICAgIDB4MDUgIC8qIENhcnJpZXIgMSAoRk0pIGZyZXF1ZW5jeSByZWdpc3RlciBMU0IgKi8KLSNkZWZpbmUgVERBOTg3NV9DMk1TQiAgICAgICAweDA2ICAvKiBDYXJyaWVyIDIgKG5pY2FtKSBmcmVxdWVuY3kgcmVnaXN0ZXIgTVNCICovCi0jZGVmaW5lIFREQTk4NzVfQzJNSUIgICAgICAgMHgwNyAgLyogQ2FycmllciAyIChuaWNhbSkgZnJlcXVlbmN5IHJlZ2lzdGVyICgxNi04XWIgKi8KLSNkZWZpbmUgVERBOTg3NV9DMkxTQiAgICAgICAweDA4ICAvKiBDYXJyaWVyIDIgKG5pY2FtKSBmcmVxdWVuY3kgcmVnaXN0ZXIgTFNCICovCi0jZGVmaW5lIFREQTk4NzVfRENSICAgICAgICAgMHgwOSAgLyogRGVtb2R1bGF0ZXVyIGNvbmZpZ3VyYXRpb24gcmVnaXJ0ZXIqLwotI2RlZmluZSBUREE5ODc1X0RFRU0gICAgICAgIDB4MGEgIC8qIEZNIGRlLWVtcGhhc2lzIHJlZ2lydGVyKi8KLSNkZWZpbmUgVERBOTg3NV9GTUFUICAgICAgICAweDBiICAvKiBGTSBNYXRyaXggcmVnaXJ0ZXIqLwotCi0vKiB2YWx1ZXMgKi8KLSNkZWZpbmUgVERBOTg3NV9NVVRFX09OCSAgICAweGZmIC8qIGdlbmVyYWwgbXV0ZSAqLwotI2RlZmluZSBUREE5ODc1X01VVEVfT0ZGICAgIDB4Y2MgLyogZ2VuZXJhbCBubyBtdXRlICovCi0KLQotCi0vKiBCZWdpbiBjb2RlICovCi0KLXN0YXRpYyBpbnQgdGRhOTg3NV93cml0ZShzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkLCBpbnQgc3ViYWRkciwgdW5zaWduZWQgY2hhciB2YWwpCi17Ci0Jc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCA9IHY0bDJfZ2V0X3N1YmRldmRhdGEoc2QpOwotCXVuc2lnbmVkIGNoYXIgYnVmZmVyWzJdOwotCi0JdjRsMl9kYmcoMSwgZGVidWcsIHNkLCAiV3JpdGluZyAlZCAweCV4XG4iLCBzdWJhZGRyLCB2YWwpOwotCWJ1ZmZlclswXSA9IHN1YmFkZHI7Ci0JYnVmZmVyWzFdID0gdmFsOwotCWlmICgyICE9IGkyY19tYXN0ZXJfc2VuZChjbGllbnQsIGJ1ZmZlciwgMikpIHsKLQkJdjRsMl93YXJuKHNkLCAiSS9PIGVycm9yLCB0cnlpbmcgKHdyaXRlICVkIDB4JXgpXG4iLAotCQkgICAgICAgc3ViYWRkciwgdmFsKTsKLQkJcmV0dXJuIC0xOwotCX0KLQlyZXR1cm4gMDsKLX0KLQotCi1zdGF0aWMgaW50IGkyY19yZWFkX3JlZ2lzdGVyKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsIGludCBhZGRyLCBpbnQgcmVnKQotewotCXVuc2lnbmVkIGNoYXIgd3JpdGVbMV07Ci0JdW5zaWduZWQgY2hhciByZWFkWzFdOwotCXN0cnVjdCBpMmNfbXNnIG1zZ3NbMl0gPSB7Ci0JCXsgYWRkciwgMCwgICAgICAgIDEsIHdyaXRlIH0sCi0JCXsgYWRkciwgSTJDX01fUkQsIDEsIHJlYWQgIH0KLQl9OwotCi0Jd3JpdGVbMF0gPSByZWc7Ci0KLQlpZiAoMiAhPSBpMmNfdHJhbnNmZXIoY2xpZW50LT5hZGFwdGVyLCBtc2dzLCAyKSkgewotCQl2NGxfd2FybihjbGllbnQsICJJL08gZXJyb3IgKHJlYWQyKVxuIik7Ci0JCXJldHVybiAtMTsKLQl9Ci0JdjRsX2RiZygxLCBkZWJ1ZywgY2xpZW50LCAiY2hpcF9yZWFkMjogcmVnJWQ9MHgleFxuIiwgcmVnLCByZWFkWzBdKTsKLQlyZXR1cm4gcmVhZFswXTsKLX0KLQotc3RhdGljIHZvaWQgdGRhOTg3NV9zZXQoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCkKLXsKLQlzdHJ1Y3QgdGRhOTg3NSAqdGRhID0gdG9fc3RhdGUoc2QpOwotCXVuc2lnbmVkIGNoYXIgYTsKLQotCXY0bDJfZGJnKDEsIGRlYnVnLCBzZCwgInRkYTk4NzVfc2V0KCUwNHgsJTA0eCwlMDR4LCUwNHgpXG4iLAotCQl0ZGEtPmx2b2wsIHRkYS0+cnZvbCwgdGRhLT5iYXNzLCB0ZGEtPnRyZWJsZSk7Ci0KLQlhID0gdGRhLT5sdm9sICYgMHhmZjsKLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X01WTCwgYSk7Ci0JYSA9dGRhLT5ydm9sICYgMHhmZjsKLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X01WUiwgYSk7Ci0JYSA9dGRhLT5iYXNzICYgMHhmZjsKLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X01CQSwgYSk7Ci0JYSA9dGRhLT50cmVibGUgICYgMHhmZjsKLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X01UUiwgYSk7Ci19Ci0KLXN0YXRpYyB2b2lkIGRvX3RkYTk4NzVfaW5pdChzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkKQotewotCXN0cnVjdCB0ZGE5ODc1ICp0ID0gdG9fc3RhdGUoc2QpOwotCi0JdjRsMl9kYmcoMSwgZGVidWcsIHNkLCAiSW4gdGRhOTg3NV9pbml0XG4iKTsKLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X0NGRywgMHhkMCk7IC8qcmVnIGRlIGNvbmZpZyAwIChyZXNldCkqLwotCXRkYTk4NzVfd3JpdGUoc2QsIFREQTk4NzVfTVNSLCAweDAzKTsgICAgLyogTW9uaXRvciAwYjAwMDAwWFhYKi8KLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X0MxTVNCLCAweDAwKTsgIC8qQ2FyMShGTSkgTVNCIFhNSHoqLwotCXRkYTk4NzVfd3JpdGUoc2QsIFREQTk4NzVfQzFNSUIsIDB4MDApOyAgLypDYXIxKEZNKSBNSUIgWE1IeiovCi0JdGRhOTg3NV93cml0ZShzZCwgVERBOTg3NV9DMUxTQiwgMHgwMCk7ICAvKkNhcjEoRk0pIExTQiBYTUh6Ki8KLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X0MyTVNCLCAweDAwKTsgIC8qQ2FyMihOSUNBTSkgTVNCIFhNSHoqLwotCXRkYTk4NzVfd3JpdGUoc2QsIFREQTk4NzVfQzJNSUIsIDB4MDApOyAgLypDYXIyKE5JQ0FNKSBNSUIgWE1IeiovCi0JdGRhOTg3NV93cml0ZShzZCwgVERBOTg3NV9DMkxTQiwgMHgwMCk7ICAvKkNhcjIoTklDQU0pIExTQiBYTUh6Ki8KLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X0RDUiwgMHgwMCk7ICAgIC8qRGVtb2QgY29uZmlnIDB4MDAqLwotCXRkYTk4NzVfd3JpdGUoc2QsIFREQTk4NzVfREVFTSwgMHg0NCk7ICAgLypERS1FbXBoIDBiMDEwMCAwMTAwKi8KLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X0ZNQVQsIDB4MDApOyAgIC8qRk0gTWF0cml4IHJlZyAweDAwKi8KLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X1NDMSwgMHgwMCk7ICAgIC8qIFNDQVJUIDEgKFNDMSkqLwotCXRkYTk4NzVfd3JpdGUoc2QsIFREQTk4NzVfU0MyLCAweDAxKTsgICAgLyogU0NBUlQgMiAoc2MyKSovCi0KLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X0NIMVYsIDB4MTApOyAgLyogQ2hhbm5lbCB2b2x1bWUgMSBtdXRlKi8KLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X0NIMlYsIDB4MTApOyAgLyogQ2hhbm5lbCB2b2x1bWUgMiBtdXRlICovCi0JdGRhOTg3NV93cml0ZShzZCwgVERBOTg3NV9EQUNPUywgMHgwMik7IC8qIHNpZyBEQUMgaS9vKGluOm5pY2FtKSovCi0JdGRhOTg3NV93cml0ZShzZCwgVERBOTg3NV9BRENJUywgMHg2Zik7IC8qIHNpZyBBREMgaW5wdXQoaW46bW9ubykqLwotCXRkYTk4NzVfd3JpdGUoc2QsIFREQTk4NzVfTE9TUiwgMHgwMCk7ICAvKiBsaW5lIG91dCAoaW46bW9ubykqLwotCXRkYTk4NzVfd3JpdGUoc2QsIFREQTk4NzVfQUVSLCAweDAwKTsgICAvKjA2IEVmZmVjdCAoQVZMK1BTRVVETykgKi8KLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X01DUywgMHg0NCk7ICAgLyogTWFpbiBjaCBzZWxlY3QgKERBQykgKi8KLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X01WTCwgMHgwMyk7ICAgLyogVm9sIE1haW4gbGVmdCAxMGRCICovCi0JdGRhOTg3NV93cml0ZShzZCwgVERBOTg3NV9NVlIsIDB4MDMpOyAgIC8qIFZvbCBNYWluIHJpZ2h0IDEwZEIqLwotCXRkYTk4NzVfd3JpdGUoc2QsIFREQTk4NzVfTUJBLCAweDAwKTsgICAvKiBNYWluIEJhc3MgTWFpbiAwZEIqLwotCXRkYTk4NzVfd3JpdGUoc2QsIFREQTk4NzVfTVRSLCAweDAwKTsgICAvKiBNYWluIFRyZWJsZSBNYWluIDBkQiovCi0JdGRhOTg3NV93cml0ZShzZCwgVERBOTg3NV9BQ1MsIDB4NDQpOyAgIC8qIEF1eCBjaGFuIHNlbGVjdCAoZGFjKSovCi0JdGRhOTg3NV93cml0ZShzZCwgVERBOTg3NV9BVkwsIDB4MDApOyAgIC8qIFZvbCBBdXggbGVmdCAwZEIqLwotCXRkYTk4NzVfd3JpdGUoc2QsIFREQTk4NzVfQVZSLCAweDAwKTsgICAvKiBWb2wgQXV4IHJpZ2h0IDBkQiovCi0JdGRhOTg3NV93cml0ZShzZCwgVERBOTg3NV9BQkEsIDB4MDApOyAgIC8qIEF1eCBCYXNzIE1haW4gMGRCKi8KLQl0ZGE5ODc1X3dyaXRlKHNkLCBUREE5ODc1X0FUUiwgMHgwMCk7ICAgLyogQXV4IEFpZ3VzIE1haW4gMGRCKi8KLQotCXRkYTk4NzVfd3JpdGUoc2QsIFREQTk4NzVfTVVULCAweGNjKTsgICAvKiBHZW5lcmFsIG11dGUgICovCi0KLQl0LT5sdm9sID0gdC0+cnZvbCA9IDA7ICAJLyogMGRCICovCi0JdC0+YmFzcyA9IDA7IAkJCS8qIDBkQiAqLwotCXQtPnRyZWJsZSA9IDA7ICAJCS8qIDBkQiAqLwotCXRkYTk4NzVfc2V0KHNkKTsKLX0KLQotCi1zdGF0aWMgaW50IHRkYTk4NzVfZ19jdHJsKHN0cnVjdCB2NGwyX3N1YmRldiAqc2QsIHN0cnVjdCB2NGwyX2NvbnRyb2wgKmN0cmwpCi17Ci0Jc3RydWN0IHRkYTk4NzUgKnQgPSB0b19zdGF0ZShzZCk7Ci0KLQlzd2l0Y2ggKGN0cmwtPmlkKSB7Ci0JY2FzZSBWNEwyX0NJRF9BVURJT19WT0xVTUU6Ci0JewotCQlpbnQgbGVmdCA9ICh0LT5sdm9sKzg0KSo2MDY7Ci0JCWludCByaWdodCA9ICh0LT5ydm9sKzg0KSo2MDY7Ci0KLQkJY3RybC0+dmFsdWU9bWF4KGxlZnQscmlnaHQpOwotCQlyZXR1cm4gMDsKLQl9Ci0JY2FzZSBWNEwyX0NJRF9BVURJT19CQUxBTkNFOgotCXsKLQkJaW50IGxlZnQgPSAodC0+bHZvbCs4NCkqNjA2OwotCQlpbnQgcmlnaHQgPSAodC0+cnZvbCs4NCkqNjA2OwotCQlpbnQgdm9sdW1lID0gbWF4KGxlZnQscmlnaHQpOwotCQlpbnQgYmFsYW5jZSA9ICgzMjc2OCptaW4obGVmdCxyaWdodCkpLwotCQkJICAgICAgKHZvbHVtZSA/IHZvbHVtZSA6IDEpOwotCQljdHJsLT52YWx1ZT0obGVmdDxyaWdodCk/Ci0JCQkoNjU1MzUtYmFsYW5jZSkgOiBiYWxhbmNlOwotCQlyZXR1cm4gMDsKLQl9Ci0JY2FzZSBWNEwyX0NJRF9BVURJT19CQVNTOgotCQljdHJsLT52YWx1ZSA9ICh0LT5iYXNzKzEyKSoyNDI3OyAgICAvKiBtaW4gLTEyIG1heCArMTUgKi8KLQkJcmV0dXJuIDA7Ci0JY2FzZSBWNEwyX0NJRF9BVURJT19UUkVCTEU6Ci0JCWN0cmwtPnZhbHVlID0gKHQtPnRyZWJsZSsxMikqMjczMDsvKiBtaW4gLTEyIG1heCArMTIgKi8KLQkJcmV0dXJuIDA7Ci0JfQotCXJldHVybiAtRUlOVkFMOwotfQotCi1zdGF0aWMgaW50IHRkYTk4NzVfc19jdHJsKHN0cnVjdCB2NGwyX3N1YmRldiAqc2QsIHN0cnVjdCB2NGwyX2NvbnRyb2wgKmN0cmwpCi17Ci0Jc3RydWN0IHRkYTk4NzUgKnQgPSB0b19zdGF0ZShzZCk7Ci0JaW50IGNodm9sID0gMCwgdm9sdW1lID0gMCwgYmFsYW5jZSA9IDAsIGxlZnQsIHJpZ2h0OwotCi0Jc3dpdGNoIChjdHJsLT5pZCkgewotCWNhc2UgVjRMMl9DSURfQVVESU9fVk9MVU1FOgotCQlsZWZ0ID0gKHQtPmx2b2wrODQpKjYwNjsKLQkJcmlnaHQgPSAodC0+cnZvbCs4NCkqNjA2OwotCi0JCXZvbHVtZSA9IG1heChsZWZ0LHJpZ2h0KTsKLQkJYmFsYW5jZSA9ICgzMjc2OCptaW4obGVmdCxyaWdodCkpLwotCQkJICAgICAgKHZvbHVtZSA/IHZvbHVtZSA6IDEpOwotCQliYWxhbmNlID0obGVmdDxyaWdodCk/Ci0JCQkoNjU1MzUtYmFsYW5jZSkgOiBiYWxhbmNlOwotCi0JCXZvbHVtZSA9IGN0cmwtPnZhbHVlOwotCi0JCWNodm9sPTE7Ci0JCWJyZWFrOwotCWNhc2UgVjRMMl9DSURfQVVESU9fQkFMQU5DRToKLQkJbGVmdCA9ICh0LT5sdm9sKzg0KSo2MDY7Ci0JCXJpZ2h0ID0gKHQtPnJ2b2wrODQpKjYwNjsKLQotCQl2b2x1bWU9bWF4KGxlZnQscmlnaHQpOwotCi0JCWJhbGFuY2UgPSBjdHJsLT52YWx1ZTsKLQotCQljaHZvbD0xOwotCQlicmVhazsKLQljYXNlIFY0TDJfQ0lEX0FVRElPX0JBU1M6Ci0JCXQtPmJhc3MgPSAoKGN0cmwtPnZhbHVlLzI0MDApLTEyKSAmIDB4ZmY7Ci0JCWlmICh0LT5iYXNzID4gMTUpCi0JCQl0LT5iYXNzID0gMTU7Ci0JCWlmICh0LT5iYXNzIDwgLTEyKQotCQkJdC0+YmFzcyA9IC0xMiAmIDB4ZmY7Ci0JCWJyZWFrOwotCWNhc2UgVjRMMl9DSURfQVVESU9fVFJFQkxFOgotCQl0LT50cmVibGUgPSAoKGN0cmwtPnZhbHVlLzI3MDApLTEyKSAmIDB4ZmY7Ci0JCWlmICh0LT50cmVibGUgPiAxMikKLQkJCXQtPnRyZWJsZSA9IDEyOwotCQlpZiAodC0+dHJlYmxlIDwgLTEyKQotCQkJdC0+dHJlYmxlID0gLTEyICYgMHhmZjsKLQkJYnJlYWs7Ci0JZGVmYXVsdDoKLQkJcmV0dXJuIC1FSU5WQUw7Ci0JfQotCi0JaWYgKGNodm9sKSB7Ci0JCWxlZnQgPSAobWluKDY1NTM2IC0gYmFsYW5jZSwzMjc2OCkgKgotCQkJdm9sdW1lKSAvIDMyNzY4OwotCQlyaWdodCA9IChtaW4oYmFsYW5jZSwzMjc2OCkgKgotCQkJCXZvbHVtZSkgLyAzMjc2ODsKLQkJdC0+bHZvbCA9ICgobGVmdC82MDYpLTg0KSAmIDB4ZmY7Ci0JCWlmICh0LT5sdm9sID4gMjQpCi0JCQl0LT5sdm9sID0gMjQ7Ci0JCWlmICh0LT5sdm9sIDwgLTg0KQotCQkJdC0+bHZvbCA9IC04NCAmIDB4ZmY7Ci0KLQkJdC0+cnZvbCA9ICgocmlnaHQvNjA2KS04NCkgJiAweGZmOwotCQlpZiAodC0+cnZvbCA+IDI0KQotCQkJdC0+cnZvbCA9IDI0OwotCQlpZiAodC0+cnZvbCA8IC04NCkKLQkJCXQtPnJ2b2wgPSAtODQgJiAweGZmOwotCX0KLQotCXRkYTk4NzVfc2V0KHNkKTsKLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIGludCB0ZGE5ODc1X3F1ZXJ5Y3RybChzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkLCBzdHJ1Y3QgdjRsMl9xdWVyeWN0cmwgKnFjKQotewotCXN3aXRjaCAocWMtPmlkKSB7Ci0JY2FzZSBWNEwyX0NJRF9BVURJT19WT0xVTUU6Ci0JCXJldHVybiB2NGwyX2N0cmxfcXVlcnlfZmlsbChxYywgMCwgNjU1MzUsIDY1NTM1IC8gMTAwLCA1ODg4MCk7Ci0JY2FzZSBWNEwyX0NJRF9BVURJT19CQVNTOgotCWNhc2UgVjRMMl9DSURfQVVESU9fVFJFQkxFOgotCQlyZXR1cm4gdjRsMl9jdHJsX3F1ZXJ5X2ZpbGwocWMsIDAsIDY1NTM1LCA2NTUzNSAvIDEwMCwgMzI3NjgpOwotCX0KLQlyZXR1cm4gLUVJTlZBTDsKLX0KLQotLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KLQotc3RhdGljIGNvbnN0IHN0cnVjdCB2NGwyX3N1YmRldl9jb3JlX29wcyB0ZGE5ODc1X2NvcmVfb3BzID0gewotCS5xdWVyeWN0cmwgPSB0ZGE5ODc1X3F1ZXJ5Y3RybCwKLQkuZ19jdHJsID0gdGRhOTg3NV9nX2N0cmwsCi0JLnNfY3RybCA9IHRkYTk4NzVfc19jdHJsLAotfTsKLQotc3RhdGljIGNvbnN0IHN0cnVjdCB2NGwyX3N1YmRldl9vcHMgdGRhOTg3NV9vcHMgPSB7Ci0JLmNvcmUgPSAmdGRhOTg3NV9jb3JlX29wcywKLX07Ci0KLS8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCi0KLQotLyogKioqKioqKioqKioqKioqKioqKioqKiogKgotICogaTJjIGludGVyZmFjZSBmdW5jdGlvbnMgKgotICogKioqKioqKioqKioqKioqKioqKioqKiogKi8KLQotc3RhdGljIGludCB0ZGE5ODc1X2NoZWNraXQoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgaW50IGFkZHIpCi17Ci0JaW50IGRpYywgcmV2OwotCi0JZGljID0gaTJjX3JlYWRfcmVnaXN0ZXIoY2xpZW50LCBhZGRyLCAyNTQpOwotCXJldiA9IGkyY19yZWFkX3JlZ2lzdGVyKGNsaWVudCwgYWRkciwgMjU1KTsKLQotCWlmIChkaWMgPT0gMCB8fCBkaWMgPT0gMikgeyAvKiB0ZGE5ODc1IGFuZCB0ZGE5ODc1QSAqLwotCQl2NGxfaW5mbyhjbGllbnQsICJ0ZGE5ODc1JXMgcmV2LiAlZCBkZXRlY3RlZCBhdCAweCUwMnhcbiIsCi0JCQlkaWMgPT0gMCA/ICIiIDogIkEiLCByZXYsIGFkZHIgPDwgMSk7Ci0JCXJldHVybiAxOwotCX0KLQl2NGxfaW5mbyhjbGllbnQsICJubyBzdWNoIGNoaXAgYXQgMHglMDJ4IChkaWM9MHgleCByZXY9MHgleClcbiIsCi0JCQlhZGRyIDw8IDEsIGRpYywgcmV2KTsKLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIGludCB0ZGE5ODc1X3Byb2JlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsCi0JCQljb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCAqaWQpCi17Ci0Jc3RydWN0IHRkYTk4NzUgKnQ7Ci0Jc3RydWN0IHY0bDJfc3ViZGV2ICpzZDsKLQotCXY0bF9pbmZvKGNsaWVudCwgImNoaXAgZm91bmQgQCAweCUwMnggKCVzKVxuIiwKLQkJCWNsaWVudC0+YWRkciA8PCAxLCBjbGllbnQtPmFkYXB0ZXItPm5hbWUpOwotCi0JaWYgKCF0ZGE5ODc1X2NoZWNraXQoY2xpZW50LCBjbGllbnQtPmFkZHIpKQotCQlyZXR1cm4gLUVOT0RFVjsKLQotCXQgPSBremFsbG9jKHNpemVvZigqdCksIEdGUF9LRVJORUwpOwotCWlmICghdCkKLQkJcmV0dXJuIC1FTk9NRU07Ci0Jc2QgPSAmdC0+c2Q7Ci0JdjRsMl9pMmNfc3ViZGV2X2luaXQoc2QsIGNsaWVudCwgJnRkYTk4NzVfb3BzKTsKLQotCWRvX3RkYTk4NzVfaW5pdChzZCk7Ci0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBpbnQgdGRhOTg3NV9yZW1vdmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCkKLXsKLQlzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkID0gaTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7Ci0KLQlkb190ZGE5ODc1X2luaXQoc2QpOwotCXY0bDJfZGV2aWNlX3VucmVnaXN0ZXJfc3ViZGV2KHNkKTsKLQlrZnJlZSh0b19zdGF0ZShzZCkpOwotCXJldHVybiAwOwotfQotCi1zdGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgdGRhOTg3NV9pZFtdID0gewotCXsgInRkYTk4NzUiLCAwIH0sCi0JeyB9Ci19OwotTU9EVUxFX0RFVklDRV9UQUJMRShpMmMsIHRkYTk4NzVfaWQpOwotCi1zdGF0aWMgc3RydWN0IGkyY19kcml2ZXIgdGRhOTg3NV9kcml2ZXIgPSB7Ci0JLmRyaXZlciA9IHsKLQkJLm93bmVyCT0gVEhJU19NT0RVTEUsCi0JCS5uYW1lCT0gInRkYTk4NzUiLAotCX0sCi0JLnByb2JlCQk9IHRkYTk4NzVfcHJvYmUsCi0JLnJlbW92ZQkJPSB0ZGE5ODc1X3JlbW92ZSwKLQkuaWRfdGFibGUJPSB0ZGE5ODc1X2lkLAotfTsKLQotc3RhdGljIF9faW5pdCBpbnQgaW5pdF90ZGE5ODc1KHZvaWQpCi17Ci0JcmV0dXJuIGkyY19hZGRfZHJpdmVyKCZ0ZGE5ODc1X2RyaXZlcik7Ci19Ci0KLXN0YXRpYyBfX2V4aXQgdm9pZCBleGl0X3RkYTk4NzUodm9pZCkKLXsKLQlpMmNfZGVsX2RyaXZlcigmdGRhOTg3NV9kcml2ZXIpOwotfQotCi1tb2R1bGVfaW5pdChpbml0X3RkYTk4NzUpOwotbW9kdWxlX2V4aXQoZXhpdF90ZGE5ODc1KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vdGxnMjMwMC9wZC12aWRlby5jIGIvZHJpdmVycy9tZWRpYS92aWRlby90bGcyMzAwL3BkLXZpZGVvLmMKaW5kZXggYTFmZmUxOC4uZGYzM2ExZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby90bGcyMzAwL3BkLXZpZGVvLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby90bGcyMzAwL3BkLXZpZGVvLmMKQEAgLTUxMiwxOSArNTEyLDIwIEBACiAJCQlpbnQgYnVmX3NpemUsIGdmcF90IGdmcF9mbGFncywKIAkJCXVzYl9jb21wbGV0ZV90IGNvbXBsZXRlX2ZuLCB2b2lkICpjb250ZXh0KQogewotCXN0cnVjdCB1cmIgKnVyYjsKLQl2b2lkICptZW07Ci0JaW50IGk7CisJaW50IGkgPSAwOwogCi0JZm9yIChpID0gMDsgaSA8IG51bTsgaSsrKSB7Ci0JCXVyYiA9IHVzYl9hbGxvY191cmIoMCwgZ2ZwX2ZsYWdzKTsKKwlmb3IgKDsgaSA8IG51bTsgaSsrKSB7CisJCXZvaWQgKm1lbTsKKwkJc3RydWN0IHVyYiAqdXJiID0gdXNiX2FsbG9jX3VyYigwLCBnZnBfZmxhZ3MpOwogCQlpZiAodXJiID09IE5VTEwpCiAJCQlyZXR1cm4gaTsKIAogCQltZW0gPSB1c2JfYWxsb2NfY29oZXJlbnQodWRldiwgYnVmX3NpemUsIGdmcF9mbGFncywKIAkJCQkJICZ1cmItPnRyYW5zZmVyX2RtYSk7Ci0JCWlmIChtZW0gPT0gTlVMTCkKKwkJaWYgKG1lbSA9PSBOVUxMKSB7CisJCQl1c2JfZnJlZV91cmIodXJiKTsKIAkJCXJldHVybiBpOworCQl9CiAKIAkJdXNiX2ZpbGxfYnVsa191cmIodXJiLCB1ZGV2LCB1c2JfcmN2YnVsa3BpcGUodWRldiwgZXBfYWRkciksCiAJCQkJbWVtLCBidWZfc2l6ZSwgY29tcGxldGVfZm4sIGNvbnRleHQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby92NGwyLWNvbW1vbi5jIGIvZHJpdmVycy9tZWRpYS92aWRlby92NGwyLWNvbW1vbi5jCmluZGV4IDNmMDg3MWIuLjgxMGVlZjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vdjRsMi1jb21tb24uYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3Y0bDItY29tbW9uLmMKQEAgLTQwNywxOCArNDA3LDYgQEAKIAkvKiBEZWNyZWFzZSB0aGUgbW9kdWxlIHVzZSBjb3VudCB0byBtYXRjaCB0aGUgZmlyc3QgdHJ5X21vZHVsZV9nZXQuICovCiAJbW9kdWxlX3B1dChjbGllbnQtPmRyaXZlci0+ZHJpdmVyLm93bmVyKTsKIAotCWlmIChzZCkgewotCQkvKiBXZSByZXR1cm4gZXJyb3JzIGZyb20gdjRsMl9zdWJkZXZfY2FsbCBvbmx5IGlmIHdlIGhhdmUgdGhlCi0JCSAgIGNhbGxiYWNrIGFzIHRoZSAuc19jb25maWcgaXMgbm90IG1hbmRhdG9yeSAqLwotCQlpbnQgZXJyID0gdjRsMl9zdWJkZXZfY2FsbChzZCwgY29yZSwgc19jb25maWcsCi0JCQkJaW5mby0+aXJxLCBpbmZvLT5wbGF0Zm9ybV9kYXRhKTsKLQotCQlpZiAoZXJyICYmIGVyciAhPSAtRU5PSU9DVExDTUQpIHsKLQkJCXY0bDJfZGV2aWNlX3VucmVnaXN0ZXJfc3ViZGV2KHNkKTsKLQkJCXNkID0gTlVMTDsKLQkJfQotCX0KLQogZXJyb3I6CiAJLyogSWYgd2UgaGF2ZSBhIGNsaWVudCBidXQgbm8gc3ViZGV2LCB0aGVuIHNvbWV0aGluZyB3ZW50IHdyb25nIGFuZAogCSAgIHdlIG11c3QgdW5yZWdpc3RlciB0aGUgY2xpZW50LiAqLwpAQCAtNDI4LDkgKzQxNiw4IEBACiB9CiBFWFBPUlRfU1lNQk9MX0dQTCh2NGwyX2kyY19uZXdfc3ViZGV2X2JvYXJkKTsKIAotc3RydWN0IHY0bDJfc3ViZGV2ICp2NGwyX2kyY19uZXdfc3ViZGV2X2NmZyhzdHJ1Y3QgdjRsMl9kZXZpY2UgKnY0bDJfZGV2LAorc3RydWN0IHY0bDJfc3ViZGV2ICp2NGwyX2kyY19uZXdfc3ViZGV2KHN0cnVjdCB2NGwyX2RldmljZSAqdjRsMl9kZXYsCiAJCXN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcHRlciwgY29uc3QgY2hhciAqY2xpZW50X3R5cGUsCi0JCWludCBpcnEsIHZvaWQgKnBsYXRmb3JtX2RhdGEsCiAJCXU4IGFkZHIsIGNvbnN0IHVuc2lnbmVkIHNob3J0ICpwcm9iZV9hZGRycykKIHsKIAlzdHJ1Y3QgaTJjX2JvYXJkX2luZm8gaW5mbzsKQEAgLTQ0MCwxMiArNDI3LDEwIEBACiAJbWVtc2V0KCZpbmZvLCAwLCBzaXplb2YoaW5mbykpOwogCXN0cmxjcHkoaW5mby50eXBlLCBjbGllbnRfdHlwZSwgc2l6ZW9mKGluZm8udHlwZSkpOwogCWluZm8uYWRkciA9IGFkZHI7Ci0JaW5mby5pcnEgPSBpcnE7Ci0JaW5mby5wbGF0Zm9ybV9kYXRhID0gcGxhdGZvcm1fZGF0YTsKIAogCXJldHVybiB2NGwyX2kyY19uZXdfc3ViZGV2X2JvYXJkKHY0bDJfZGV2LCBhZGFwdGVyLCAmaW5mbywgcHJvYmVfYWRkcnMpOwogfQotRVhQT1JUX1NZTUJPTF9HUEwodjRsMl9pMmNfbmV3X3N1YmRldl9jZmcpOworRVhQT1JUX1NZTUJPTF9HUEwodjRsMl9pMmNfbmV3X3N1YmRldik7CiAKIC8qIFJldHVybiBpMmMgY2xpZW50IGFkZHJlc3Mgb2YgdjRsMl9zdWJkZXYuICovCiB1bnNpZ25lZCBzaG9ydCB2NGwyX2kyY19zdWJkZXZfYWRkcihzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby92NGwyLWN0cmxzLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3Y0bDItY3RybHMuYwppbmRleCA4ZjgxZWZjLi5lZjY2ZDJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3Y0bDItY3RybHMuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3Y0bDItY3RybHMuYwpAQCAtNTY5LDcgKzU2OSw3IEBACiAJaW50IHJldDsKIAl1MzIgc2l6ZTsKIAotCWN0cmwtPmhhc19uZXcgPSAxOworCWN0cmwtPmlzX25ldyA9IDE7CiAJc3dpdGNoIChjdHJsLT50eXBlKSB7CiAJY2FzZSBWNEwyX0NUUkxfVFlQRV9JTlRFR0VSNjQ6CiAJCWN0cmwtPnZhbDY0ID0gYy0+dmFsdWU2NDsKQEAgLTEyODAsOCArMTI4MCwxMiBAQAogCQlpZiAoY3RybC0+ZG9uZSkKIAkJCWNvbnRpbnVlOwogCi0JCWZvciAoaSA9IDA7IGkgPCBtYXN0ZXItPm5jb250cm9sczsgaSsrKQotCQkJY3VyX3RvX25ldyhtYXN0ZXItPmNsdXN0ZXJbaV0pOworCQlmb3IgKGkgPSAwOyBpIDwgbWFzdGVyLT5uY29udHJvbHM7IGkrKykgeworCQkJaWYgKG1hc3Rlci0+Y2x1c3RlcltpXSkgeworCQkJCWN1cl90b19uZXcobWFzdGVyLT5jbHVzdGVyW2ldKTsKKwkJCQltYXN0ZXItPmNsdXN0ZXJbaV0tPmlzX25ldyA9IDE7CisJCQl9CisJCX0KIAogCQkvKiBTa2lwIGJ1dHRvbiBjb250cm9scyBhbmQgcmVhZC1vbmx5IGNvbnRyb2xzLiAqLwogCQlpZiAoY3RybC0+dHlwZSA9PSBWNEwyX0NUUkxfVFlQRV9CVVRUT04gfHwKQEAgLTEzNDAsMTIgKzEzNDQsMTUgQEAKIAogCWN0cmwgPSByZWYtPmN0cmw7CiAJbWVtc2V0KHFjLCAwLCBzaXplb2YoKnFjKSk7Ci0JcWMtPmlkID0gY3RybC0+aWQ7CisJaWYgKGlkID49IFY0TDJfQ0lEX1BSSVZBVEVfQkFTRSkKKwkJcWMtPmlkID0gaWQ7CisJZWxzZQorCQlxYy0+aWQgPSBjdHJsLT5pZDsKIAlzdHJsY3B5KHFjLT5uYW1lLCBjdHJsLT5uYW1lLCBzaXplb2YocWMtPm5hbWUpKTsKIAlxYy0+bWluaW11bSA9IGN0cmwtPm1pbmltdW07CiAJcWMtPm1heGltdW0gPSBjdHJsLT5tYXhpbXVtOwogCXFjLT5kZWZhdWx0X3ZhbHVlID0gY3RybC0+ZGVmYXVsdF92YWx1ZTsKLQlpZiAocWMtPnR5cGUgPT0gVjRMMl9DVFJMX1RZUEVfTUVOVSkKKwlpZiAoY3RybC0+dHlwZSA9PSBWNEwyX0NUUkxfVFlQRV9NRU5VKQogCQlxYy0+c3RlcCA9IDE7CiAJZWxzZQogCQlxYy0+c3RlcCA9IGN0cmwtPnN0ZXA7CkBAIC0xNjQ1LDcgKzE2NTIsNyBAQAogCQlpZiAoY3RybCA9PSBOVUxMKQogCQkJY29udGludWU7CiAKLQkJaWYgKGN0cmwtPmhhc19uZXcpIHsKKwkJaWYgKGN0cmwtPmlzX25ldykgewogCQkJLyogRG91YmxlIGNoZWNrIHRoaXM6IGl0IG1heSBoYXZlIGNoYW5nZWQgc2luY2UgdGhlCiAJCQkgICBsYXN0IGNoZWNrIGluIHRyeV9vcl9zZXRfZXh0X2N0cmxzKCkuICovCiAJCQlpZiAoc2V0ICYmIChjdHJsLT5mbGFncyAmIFY0TDJfQ1RSTF9GTEFHX0dSQUJCRUQpKQpAQCAtMTcxOSwxMyArMTcyNiwxMyBAQAogCiAJCXY0bDJfY3RybF9sb2NrKGN0cmwpOwogCi0JCS8qIFJlc2V0IHRoZSAnaGFzX25ldycgZmxhZ3Mgb2YgdGhlIGNsdXN0ZXIgKi8KKwkJLyogUmVzZXQgdGhlICdpc19uZXcnIGZsYWdzIG9mIHRoZSBjbHVzdGVyICovCiAJCWZvciAoaiA9IDA7IGogPCBtYXN0ZXItPm5jb250cm9sczsgaisrKQogCQkJaWYgKG1hc3Rlci0+Y2x1c3RlcltqXSkKLQkJCQltYXN0ZXItPmNsdXN0ZXJbal0tPmhhc19uZXcgPSAwOworCQkJCW1hc3Rlci0+Y2x1c3RlcltqXS0+aXNfbmV3ID0gMDsKIAogCQkvKiBDb3B5IHRoZSBuZXcgY2FsbGVyLXN1cHBsaWVkIGNvbnRyb2wgdmFsdWVzLgotCQkgICB1c2VyX3RvX25ldygpIHNldHMgJ2hhc19uZXcnIHRvIDEuICovCisJCSAgIHVzZXJfdG9fbmV3KCkgc2V0cyAnaXNfbmV3JyB0byAxLiAqLwogCQlyZXQgPSBjbHVzdGVyX3dhbGsoaSwgY3MsIGhlbHBlcnMsIHVzZXJfdG9fbmV3KTsKIAogCQlpZiAoIXJldCkKQEAgLTE4MjAsMTUgKzE4MjcsMTggQEAKIAlpbnQgcmV0OwogCWludCBpOwogCisJaWYgKGN0cmwtPmZsYWdzICYgVjRMMl9DVFJMX0ZMQUdfUkVBRF9PTkxZKQorCQlyZXR1cm4gLUVBQ0NFUzsKKwogCXY0bDJfY3RybF9sb2NrKGN0cmwpOwogCi0JLyogUmVzZXQgdGhlICdoYXNfbmV3JyBmbGFncyBvZiB0aGUgY2x1c3RlciAqLworCS8qIFJlc2V0IHRoZSAnaXNfbmV3JyBmbGFncyBvZiB0aGUgY2x1c3RlciAqLwogCWZvciAoaSA9IDA7IGkgPCBtYXN0ZXItPm5jb250cm9sczsgaSsrKQogCQlpZiAobWFzdGVyLT5jbHVzdGVyW2ldKQotCQkJbWFzdGVyLT5jbHVzdGVyW2ldLT5oYXNfbmV3ID0gMDsKKwkJCW1hc3Rlci0+Y2x1c3RlcltpXS0+aXNfbmV3ID0gMDsKIAogCWN0cmwtPnZhbCA9ICp2YWw7Ci0JY3RybC0+aGFzX25ldyA9IDE7CisJY3RybC0+aXNfbmV3ID0gMTsKIAlyZXQgPSB0cnlfb3Jfc2V0X2NvbnRyb2xfY2x1c3RlcihtYXN0ZXIsIGZhbHNlKTsKIAlpZiAoIXJldCkKIAkJcmV0ID0gdHJ5X29yX3NldF9jb250cm9sX2NsdXN0ZXIobWFzdGVyLCB0cnVlKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vdjRsMi1kZXYuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vdjRsMi1kZXYuYwppbmRleCAzNTllMjMyLi4zNDE3NjRhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3Y0bDItZGV2LmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby92NGwyLWRldi5jCkBAIC00MTksNiArNDE5LDEwIEBACiAgKglUaGUgcmVnaXN0cmF0aW9uIGNvZGUgYXNzaWducyBtaW5vciBudW1iZXJzIGFuZCBkZXZpY2Ugbm9kZSBudW1iZXJzCiAgKgliYXNlZCBvbiB0aGUgcmVxdWVzdGVkIHR5cGUgYW5kIHJlZ2lzdGVycyB0aGUgbmV3IGRldmljZSBub2RlIHdpdGgKICAqCXRoZSBrZXJuZWwuCisgKgorICoJVGhpcyBmdW5jdGlvbiBhc3N1bWVzIHRoYXQgc3RydWN0IHZpZGVvX2RldmljZSB3YXMgemVyb2VkIHdoZW4gaXQKKyAqCXdhcyBhbGxvY2F0ZWQgYW5kIGRvZXMgbm90IGNvbnRhaW4gYW55IHN0YWxlIGRhdGUuCisgKgogICoJQW4gZXJyb3IgaXMgcmV0dXJuZWQgaWYgbm8gZnJlZSBtaW5vciBvciBkZXZpY2Ugbm9kZSBudW1iZXIgY291bGQgYmUKICAqCWZvdW5kLCBvciBpZiB0aGUgcmVnaXN0cmF0aW9uIG9mIHRoZSBkZXZpY2Ugbm9kZSBmYWlsZWQuCiAgKgpAQCAtNDQwLDcgKzQ0NCw2IEBACiAJaW50IG1pbm9yX29mZnNldCA9IDA7CiAJaW50IG1pbm9yX2NudCA9IFZJREVPX05VTV9ERVZJQ0VTOwogCWNvbnN0IGNoYXIgKm5hbWVfYmFzZTsKLQl2b2lkICpwcml2ID0gdmRldi0+ZGV2LnA7CiAKIAkvKiBBIG1pbm9yIHZhbHVlIG9mIC0xIG1hcmtzIHRoaXMgdmlkZW8gZGV2aWNlIGFzIG5ldmVyCiAJICAgaGF2aW5nIGJlZW4gcmVnaXN0ZXJlZCAqLwpAQCAtNTU5LDEwICs1NjIsNiBAQAogCX0KIAogCS8qIFBhcnQgNDogcmVnaXN0ZXIgdGhlIGRldmljZSB3aXRoIHN5c2ZzICovCi0JbWVtc2V0KCZ2ZGV2LT5kZXYsIDAsIHNpemVvZih2ZGV2LT5kZXYpKTsKLQkvKiBUaGUgbWVtc2V0IGFib3ZlIGNsZWFyZWQgdGhlIGRldmljZSdzIGRldmljZV9wcml2YXRlLCBzbwotCSAgIHB1dCBiYWNrIHRoZSBjb3B5IHdlIG1hZGUgZWFybGllci4gKi8KLQl2ZGV2LT5kZXYucCA9IHByaXY7CiAJdmRldi0+ZGV2LmNsYXNzID0gJnZpZGVvX2NsYXNzOwogCXZkZXYtPmRldi5kZXZ0ID0gTUtERVYoVklERU9fTUFKT1IsIHZkZXYtPm1pbm9yKTsKIAlpZiAodmRldi0+cGFyZW50KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby92NGwyLWRldmljZS5jIGIvZHJpdmVycy9tZWRpYS92aWRlby92NGwyLWRldmljZS5jCmluZGV4IDdmZTZmOTIuLmNlNjRmZTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vdjRsMi1kZXZpY2UuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3Y0bDItZGV2aWNlLmMKQEAgLTEwMCw2ICsxMDAsNyBAQAogCQkJICAgaXMgYSBwbGF0Zm9ybSBidXMsIHRoZW4gaXQgaXMgbmV2ZXIgZGVsZXRlZC4gKi8KIAkJCWlmIChjbGllbnQpCiAJCQkJaTJjX3VucmVnaXN0ZXJfZGV2aWNlKGNsaWVudCk7CisJCQljb250aW51ZTsKIAkJfQogI2VuZGlmCiAjaWYgZGVmaW5lZChDT05GSUdfU1BJKQpAQCAtMTA4LDYgKzEwOSw3IEBACiAKIAkJCWlmIChzcGkpCiAJCQkJc3BpX3VucmVnaXN0ZXJfZGV2aWNlKHNwaSk7CisJCQljb250aW51ZTsKIAkJfQogI2VuZGlmCiAJfQpAQCAtMTI2LDExICsxMjgsMTkgQEAKIAlXQVJOX09OKHNkLT52NGwyX2RldiAhPSBOVUxMKTsKIAlpZiAoIXRyeV9tb2R1bGVfZ2V0KHNkLT5vd25lcikpCiAJCXJldHVybiAtRU5PREVWOworCXNkLT52NGwyX2RldiA9IHY0bDJfZGV2OworCWlmIChzZC0+aW50ZXJuYWxfb3BzICYmIHNkLT5pbnRlcm5hbF9vcHMtPnJlZ2lzdGVyZWQpIHsKKwkJZXJyID0gc2QtPmludGVybmFsX29wcy0+cmVnaXN0ZXJlZChzZCk7CisJCWlmIChlcnIpCisJCQlyZXR1cm4gZXJyOworCX0KIAkvKiBUaGlzIGp1c3QgcmV0dXJucyAwIGlmIGVpdGhlciBvZiB0aGUgdHdvIGFyZ3MgaXMgTlVMTCAqLwogCWVyciA9IHY0bDJfY3RybF9hZGRfaGFuZGxlcih2NGwyX2Rldi0+Y3RybF9oYW5kbGVyLCBzZC0+Y3RybF9oYW5kbGVyKTsKLQlpZiAoZXJyKQorCWlmIChlcnIpIHsKKwkJaWYgKHNkLT5pbnRlcm5hbF9vcHMgJiYgc2QtPmludGVybmFsX29wcy0+dW5yZWdpc3RlcmVkKQorCQkJc2QtPmludGVybmFsX29wcy0+dW5yZWdpc3RlcmVkKHNkKTsKIAkJcmV0dXJuIGVycjsKLQlzZC0+djRsMl9kZXYgPSB2NGwyX2RldjsKKwl9CiAJc3Bpbl9sb2NrKCZ2NGwyX2Rldi0+bG9jayk7CiAJbGlzdF9hZGRfdGFpbCgmc2QtPmxpc3QsICZ2NGwyX2Rldi0+c3ViZGV2cyk7CiAJc3Bpbl91bmxvY2soJnY0bDJfZGV2LT5sb2NrKTsKQEAgLTE0Niw2ICsxNTYsOCBAQAogCXNwaW5fbG9jaygmc2QtPnY0bDJfZGV2LT5sb2NrKTsKIAlsaXN0X2RlbCgmc2QtPmxpc3QpOwogCXNwaW5fdW5sb2NrKCZzZC0+djRsMl9kZXYtPmxvY2spOworCWlmIChzZC0+aW50ZXJuYWxfb3BzICYmIHNkLT5pbnRlcm5hbF9vcHMtPnVucmVnaXN0ZXJlZCkKKwkJc2QtPmludGVybmFsX29wcy0+dW5yZWdpc3RlcmVkKHNkKTsKIAlzZC0+djRsMl9kZXYgPSBOVUxMOwogCW1vZHVsZV9wdXQoc2QtPm93bmVyKTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vdjRsMi1pb2N0bC5jIGIvZHJpdmVycy9tZWRpYS92aWRlby92NGwyLWlvY3RsLmMKaW5kZXggN2U0N2YxNS4uZjUxMzI3ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby92NGwyLWlvY3RsLmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby92NGwyLWlvY3RsLmMKQEAgLTE2NTksMjAgKzE2NTksMjQgQEAKIAl7CiAJCXN0cnVjdCB2NGwyX2RiZ19yZWdpc3RlciAqcCA9IGFyZzsKIAotCQlpZiAoIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCi0JCQlyZXQgPSAtRVBFUk07Ci0JCWVsc2UgaWYgKG9wcy0+dmlkaW9jX2dfcmVnaXN0ZXIpCi0JCQlyZXQgPSBvcHMtPnZpZGlvY19nX3JlZ2lzdGVyKGZpbGUsIGZoLCBwKTsKKwkJaWYgKG9wcy0+dmlkaW9jX2dfcmVnaXN0ZXIpIHsKKwkJCWlmICghY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKKwkJCQlyZXQgPSAtRVBFUk07CisJCQllbHNlCisJCQkJcmV0ID0gb3BzLT52aWRpb2NfZ19yZWdpc3RlcihmaWxlLCBmaCwgcCk7CisJCX0KIAkJYnJlYWs7CiAJfQogCWNhc2UgVklESU9DX0RCR19TX1JFR0lTVEVSOgogCXsKIAkJc3RydWN0IHY0bDJfZGJnX3JlZ2lzdGVyICpwID0gYXJnOwogCi0JCWlmICghY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKLQkJCXJldCA9IC1FUEVSTTsKLQkJZWxzZSBpZiAob3BzLT52aWRpb2Nfc19yZWdpc3RlcikKLQkJCXJldCA9IG9wcy0+dmlkaW9jX3NfcmVnaXN0ZXIoZmlsZSwgZmgsIHApOworCQlpZiAob3BzLT52aWRpb2Nfc19yZWdpc3RlcikgeworCQkJaWYgKCFjYXBhYmxlKENBUF9TWVNfQURNSU4pKQorCQkJCXJldCA9IC1FUEVSTTsKKwkJCWVsc2UKKwkJCQlyZXQgPSBvcHMtPnZpZGlvY19zX3JlZ2lzdGVyKGZpbGUsIGZoLCBwKTsKKwkJfQogCQlicmVhazsKIAl9CiAjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vdzk5NjYuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vdzk5NjYuYwppbmRleCAwMTllZTIwLi5mYTM1NjM5IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3c5OTY2LmMKKysrIGIvZHJpdmVycy9tZWRpYS92aWRlby93OTk2Ni5jCkBAIC05MzcsNiArOTM3LDcgQEAKIAkJcGFycG9ydF91bnJlZ2lzdGVyX2RldmljZShjYW0tPnBkZXYpOwogCQl3OTk2Nl9zZXRfc3RhdGUoY2FtLCBXOTk2Nl9TVEFURV9QREVWLCAwKTsKIAl9CisJbWVtc2V0KGNhbSwgMCwgc2l6ZW9mKCpjYW0pKTsKIH0KIAogCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3pvcmFuL3pvcmFuX2NhcmQuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vem9yYW4vem9yYW5fY2FyZC5jCmluZGV4IDljZGMzYmIuLjlmMmJhYzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvdmlkZW8vem9yYW4vem9yYW5fY2FyZC5jCisrKyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vem9yYW4vem9yYW5fY2FyZC5jCkBAIC0xMDQxLDcgKzEwNDEsNyBAQAogCS8qIGFsbG9jYXRlIG1lbW9yeSAqYmVmb3JlKiBkb2luZyBhbnl0aGluZyB0byB0aGUgaGFyZHdhcmUKIAkgKiBpbiBjYXNlIGFsbG9jYXRpb24gZmFpbHMgKi8KIAl6ci0+c3RhdF9jb20gPSBremFsbG9jKEJVWl9OVU1fU1RBVF9DT00gKiA0LCBHRlBfS0VSTkVMKTsKLQl6ci0+dmlkZW9fZGV2ID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IHZpZGVvX2RldmljZSksIEdGUF9LRVJORUwpOworCXpyLT52aWRlb19kZXYgPSB2aWRlb19kZXZpY2VfYWxsb2MoKTsKIAlpZiAoIXpyLT5zdGF0X2NvbSB8fCAhenItPnZpZGVvX2RldikgewogCQlkcHJpbnRrKDEsCiAJCQlLRVJOX0VSUgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvODhwbTg2MHgtY29yZS5jIGIvZHJpdmVycy9tZmQvODhwbTg2MHgtY29yZS5jCmluZGV4IDIwODk1ZTcuLjc5MzMwMGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkLzg4cG04NjB4LWNvcmUuYworKysgYi9kcml2ZXJzL21mZC84OHBtODYweC1jb3JlLmMKQEAgLTM2MSwxMiArMzYxLDYgQEAKIAl9LAogfTsKIAotc3RhdGljIGlubGluZSBzdHJ1Y3QgcG04NjB4X2lycV9kYXRhICppcnFfdG9fcG04NjB4KHN0cnVjdCBwbTg2MHhfY2hpcCAqY2hpcCwKLQkJCQkJCSAgICBpbnQgaXJxKQotewotCXJldHVybiAmcG04NjB4X2lycXNbaXJxIC0gY2hpcC0+aXJxX2Jhc2VdOwotfQotCiBzdGF0aWMgaXJxcmV0dXJuX3QgcG04NjB4X2lycShpbnQgaXJxLCB2b2lkICpkYXRhKQogewogCXN0cnVjdCBwbTg2MHhfY2hpcCAqY2hpcCA9IGRhdGE7CkBAIC0zODgsMTYgKzM4MiwxNiBAQAogCXJldHVybiBJUlFfSEFORExFRDsKIH0KIAotc3RhdGljIHZvaWQgcG04NjB4X2lycV9sb2NrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBwbTg2MHhfaXJxX2xvY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBwbTg2MHhfY2hpcCAqY2hpcCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IHBtODYweF9jaGlwICpjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CiAKIAltdXRleF9sb2NrKCZjaGlwLT5pcnFfbG9jayk7CiB9CiAKLXN0YXRpYyB2b2lkIHBtODYweF9pcnFfc3luY191bmxvY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHBtODYweF9pcnFfc3luY191bmxvY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBwbTg2MHhfY2hpcCAqY2hpcCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IHBtODYweF9jaGlwICpjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CiAJc3RydWN0IHBtODYweF9pcnFfZGF0YSAqaXJxX2RhdGE7CiAJc3RydWN0IGkyY19jbGllbnQgKmkyYzsKIAlzdGF0aWMgdW5zaWduZWQgY2hhciBjYWNoZWRbM10gPSB7MHgwLCAweDAsIDB4MH07CkBAIC00MzksMjUgKzQzMywyNSBAQAogCW11dGV4X3VubG9jaygmY2hpcC0+aXJxX2xvY2spOwogfQogCi1zdGF0aWMgdm9pZCBwbTg2MHhfaXJxX2VuYWJsZSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgcG04NjB4X2lycV9lbmFibGUoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBwbTg2MHhfY2hpcCAqY2hpcCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7Ci0JcG04NjB4X2lycXNbaXJxIC0gY2hpcC0+aXJxX2Jhc2VdLmVuYWJsZQotCQk9IHBtODYweF9pcnFzW2lycSAtIGNoaXAtPmlycV9iYXNlXS5vZmZzOworCXN0cnVjdCBwbTg2MHhfY2hpcCAqY2hpcCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOworCXBtODYweF9pcnFzW2RhdGEtPmlycSAtIGNoaXAtPmlycV9iYXNlXS5lbmFibGUKKwkJPSBwbTg2MHhfaXJxc1tkYXRhLT5pcnEgLSBjaGlwLT5pcnFfYmFzZV0ub2ZmczsKIH0KIAotc3RhdGljIHZvaWQgcG04NjB4X2lycV9kaXNhYmxlKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBwbTg2MHhfaXJxX2Rpc2FibGUoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBwbTg2MHhfY2hpcCAqY2hpcCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7Ci0JcG04NjB4X2lycXNbaXJxIC0gY2hpcC0+aXJxX2Jhc2VdLmVuYWJsZSA9IDA7CisJc3RydWN0IHBtODYweF9jaGlwICpjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CisJcG04NjB4X2lycXNbZGF0YS0+aXJxIC0gY2hpcC0+aXJxX2Jhc2VdLmVuYWJsZSA9IDA7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgcG04NjB4X2lycV9jaGlwID0gewogCS5uYW1lCQk9ICI4OHBtODYweCIsCi0JLmJ1c19sb2NrCT0gcG04NjB4X2lycV9sb2NrLAotCS5idXNfc3luY191bmxvY2sgPSBwbTg2MHhfaXJxX3N5bmNfdW5sb2NrLAotCS5lbmFibGUJCT0gcG04NjB4X2lycV9lbmFibGUsCi0JLmRpc2FibGUJPSBwbTg2MHhfaXJxX2Rpc2FibGUsCisJLmlycV9idXNfbG9jawk9IHBtODYweF9pcnFfbG9jaywKKwkuaXJxX2J1c19zeW5jX3VubG9jayA9IHBtODYweF9pcnFfc3luY191bmxvY2ssCisJLmlycV9lbmFibGUJPSBwbTg2MHhfaXJxX2VuYWJsZSwKKwkuaXJxX2Rpc2FibGUJPSBwbTg2MHhfaXJxX2Rpc2FibGUsCiB9OwogCiBzdGF0aWMgaW50IF9fZGV2aW5pdCBkZXZpY2VfZ3BhZGNfaW5pdChzdHJ1Y3QgcG04NjB4X2NoaXAgKmNoaXAsCmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC9LY29uZmlnIGIvZHJpdmVycy9tZmQvS2NvbmZpZwppbmRleCBkYTlkMjk3Li5mZDAxODM2IDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC9LY29uZmlnCisrKyBiL2RyaXZlcnMvbWZkL0tjb25maWcKQEAgLTQ5NiwxMyArNDk2LDEzIEBACiAKIGNvbmZpZyBBQjg1MDBfQ09SRQogCWJvb2wgIlNULUVyaWNzc29uIEFCODUwMCBNaXhlZCBTaWduYWwgUG93ZXIgTWFuYWdlbWVudCBjaGlwIgotCWRlcGVuZHMgb24gR0VORVJJQ19IQVJESVJRUyAmJiBBQlg1MDBfQ09SRSAmJiBTUElfTUFTVEVSICYmIEFSQ0hfVTg1MDAKKwlkZXBlbmRzIG9uIEdFTkVSSUNfSEFSRElSUVMgJiYgQUJYNTAwX0NPUkUKIAlzZWxlY3QgTUZEX0NPUkUKIAloZWxwCiAJICBTZWxlY3QgdGhpcyBvcHRpb24gdG8gZW5hYmxlIGFjY2VzcyB0byBBQjg1MDAgcG93ZXIgbWFuYWdlbWVudAotCSAgY2hpcC4gVGhpcyBjb25uZWN0cyB0byBVODUwMCBlaXRoZXIgb24gdGhlIFNTUC9TUEkgYnVzCi0JICBvciB0aGUgSTJDIGJ1cyB2aWEgUFJDTVUuIEl0IGFsc28gYWRkcyB0aGUgaXJxX2NoaXAKLQkgIHBhcnRzIGZvciBoYW5kbGluZyB0aGUgTWl4ZWQgU2lnbmFsIGNoaXAgZXZlbnRzLgorCSAgY2hpcC4gVGhpcyBjb25uZWN0cyB0byBVODUwMCBlaXRoZXIgb24gdGhlIFNTUC9TUEkgYnVzIChkZXByZWNhdGVkCisJICBzaW5jZSBoYXJkd2FyZSB2ZXJzaW9uIHYxLjApIG9yIHRoZSBJMkMgYnVzIHZpYSBQUkNNVS4gSXQgYWxzbyBhZGRzCisJICB0aGUgaXJxX2NoaXAgcGFydHMgZm9yIGhhbmRsaW5nIHRoZSBNaXhlZCBTaWduYWwgY2hpcCBldmVudHMuCiAJICBUaGlzIGNoaXAgZW1iZWRzIHZhcmlvdXMgb3RoZXIgbXVsdGltZWRpYSBmdW50aW9uYWxpdGllcyBhcyB3ZWxsLgogCiBjb25maWcgQUI4NTAwX0kyQ19DT1JFCkBAIC01MzcsNiArNTM3LDE0IEBACiAJICBMRURzLCB2aWJyYXRvciwgc3lzdGVtIHBvd2VyIGFuZCB0ZW1wZXJhdHVyZSwgcG93ZXIgbWFuYWdlbWVudAogCSAgYW5kIEFMU0Egc291bmQuCiAKK2NvbmZpZyBNRkRfQ1M1NTM1CisJdHJpc3RhdGUgIlN1cHBvcnQgZm9yIENTNTUzNSBhbmQgQ1M1NTM2IHNvdXRoYnJpZGdlIGNvcmUgZnVuY3Rpb25zIgorCXNlbGVjdCBNRkRfQ09SRQorCWRlcGVuZHMgb24gUENJCisJLS0taGVscC0tLQorCSAgVGhpcyBpcyB0aGUgY29yZSBkcml2ZXIgZm9yIENTNTUzNS9DUzU1MzYgTUZEIGZ1bmN0aW9ucy4gIFRoaXMgaXMKKyAgICAgICAgICBuZWNlc3NhcnkgZm9yIHVzaW5nIHRoZSBib2FyZCdzIEdQSU8gYW5kIE1GR1BUIGZ1bmN0aW9uYWxpdHkuCisKIGNvbmZpZyBNRkRfVElNQkVSREFMRQogCXRyaXN0YXRlICJTdXBwb3J0IGZvciB0aGUgVGltYmVyZGFsZSBGUEdBIgogCXNlbGVjdCBNRkRfQ09SRQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvTWFrZWZpbGUgYi9kcml2ZXJzL21mZC9NYWtlZmlsZQppbmRleCA4NDhlN2VhLi5hNTRlMmM3IDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC9NYWtlZmlsZQorKysgYi9kcml2ZXJzL21mZC9NYWtlZmlsZQpAQCAtNzAsNyArNzAsNyBAQAogb2JqLSQoQ09ORklHX0FCMzEwMF9DT1JFKQkrPSBhYjMxMDAtY29yZS5vCiBvYmotJChDT05GSUdfQUIzMTAwX09UUCkJKz0gYWIzMTAwLW90cC5vCiBvYmotJChDT05GSUdfQUIzNTUwX0NPUkUpCSs9IGFiMzU1MC1jb3JlLm8KLW9iai0kKENPTkZJR19BQjg1MDBfQ09SRSkJKz0gYWI4NTAwLWNvcmUubyBhYjg1MDAtc3BpLm8KK29iai0kKENPTkZJR19BQjg1MDBfQ09SRSkJKz0gYWI4NTAwLWNvcmUubwogb2JqLSQoQ09ORklHX0FCODUwMF9JMkNfQ09SRSkJKz0gYWI4NTAwLWkyYy5vCiBvYmotJChDT05GSUdfQUI4NTAwX0RFQlVHKQkrPSBhYjg1MDAtZGVidWdmcy5vCiBvYmotJChDT05GSUdfTUZEX1RJTUJFUkRBTEUpICAgICs9IHRpbWJlcmRhbGUubwpAQCAtODIsMyArODIsNCBAQAogb2JqLSQoQ09ORklHX01GRF9UUFM2NTg2WCkJKz0gdHBzNjU4Nngubwogb2JqLSQoQ09ORklHX01GRF9WWDg1NSkJCSs9IHZ4ODU1Lm8KIG9iai0kKENPTkZJR19NRkRfV0wxMjczX0NPUkUpCSs9IHdsMTI3My1jb3JlLm8KK29iai0kKENPTkZJR19NRkRfQ1M1NTM1KQkrPSBjczU1MzUtbWZkLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL2FiMzU1MC1jb3JlLmMgYi9kcml2ZXJzL21mZC9hYjM1NTAtY29yZS5jCmluZGV4IDhhOTg3MzkuLjVmYmNhMzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL2FiMzU1MC1jb3JlLmMKKysrIGIvZHJpdmVycy9tZmQvYWIzNTUwLWNvcmUuYwpAQCAtMTE1OSwxNSArMTE1OSwxNiBAQAogCX0KIH0KIAotc3RhdGljIHZvaWQgYWIzNTUwX21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGFiMzU1MF9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCXN0cnVjdCBhYjM1NTAgKmFiOwogCXN0cnVjdCBhYjM1NTBfcGxhdGZvcm1fZGF0YSAqcGxmX2RhdGE7CisJaW50IGlycTsKIAotCWFiID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlhYiA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCXBsZl9kYXRhID0gYWItPmkyY19jbGllbnRbMF0tPmRldi5wbGF0Zm9ybV9kYXRhOwotCWlycSAtPSBwbGZfZGF0YS0+aXJxLmJhc2U7CisJaXJxID0gZGF0YS0+aXJxIC0gcGxmX2RhdGEtPmlycS5iYXNlOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmFiLT5ldmVudF9sb2NrLCBmbGFncyk7CiAJYWItPmV2ZW50X21hc2tbaXJxIC8gOF0gfD0gQklUKGlycSAlIDgpOwpAQCAtMTE3NiwxNSArMTE3NywxNiBAQAogCXNjaGVkdWxlX3dvcmsoJmFiLT5tYXNrX3dvcmspOwogfQogCi1zdGF0aWMgdm9pZCBhYjM1NTBfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBhYjM1NTBfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCXN0cnVjdCBhYjM1NTAgKmFiOwogCXN0cnVjdCBhYjM1NTBfcGxhdGZvcm1fZGF0YSAqcGxmX2RhdGE7CisJaW50IGlycTsKIAotCWFiID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlhYiA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCXBsZl9kYXRhID0gYWItPmkyY19jbGllbnRbMF0tPmRldi5wbGF0Zm9ybV9kYXRhOwotCWlycSAtPSBwbGZfZGF0YS0+aXJxLmJhc2U7CisJaXJxID0gZGF0YS0+aXJxIC0gcGxmX2RhdGEtPmlycS5iYXNlOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmFiLT5ldmVudF9sb2NrLCBmbGFncyk7CiAJYWItPmV2ZW50X21hc2tbaXJxIC8gOF0gJj0gfkJJVChpcnEgJSA4KTsKQEAgLTExOTMsMjAgKzExOTUsMTYgQEAKIAlzY2hlZHVsZV93b3JrKCZhYi0+bWFza193b3JrKTsKIH0KIAotc3RhdGljIHZvaWQgbm9vcCh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbm9vcChzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgYWIzNTUwX2lycV9jaGlwID0gewogCS5uYW1lCQk9ICJhYjM1NTAtY29yZSIsIC8qIEtlZXAgdGhlIHNhbWUgbmFtZSBhcyB0aGUgcmVxdWVzdCAqLwotCS5zdGFydHVwCT0gTlVMTCwgLyogZGVmYXVsdHMgdG8gZW5hYmxlICovCi0JLnNodXRkb3duCT0gTlVMTCwgLyogZGVmYXVsdHMgdG8gZGlzYWJsZSAqLwotCS5lbmFibGUJCT0gTlVMTCwgLyogZGVmYXVsdHMgdG8gdW5tYXNrICovCi0JLmRpc2FibGUJPSBhYjM1NTBfbWFzaywgLyogTm8gZGVmYXVsdCB0byBtYXNrIGluIGNoaXAuYyAqLwotCS5hY2sJCT0gbm9vcCwKLQkubWFzawkJPSBhYjM1NTBfbWFzaywKLQkudW5tYXNrCQk9IGFiMzU1MF91bm1hc2ssCi0JLmVuZAkJPSBOVUxMLAorCS5pcnFfZGlzYWJsZQk9IGFiMzU1MF9tYXNrLCAvKiBObyBkZWZhdWx0IHRvIG1hc2sgaW4gY2hpcC5jICovCisJLmlycV9hY2sJPSBub29wLAorCS5pcnFfbWFzawk9IGFiMzU1MF9tYXNrLAorCS5pcnFfdW5tYXNrCT0gYWIzNTUwX3VubWFzaywKIH07CiAKIHN0cnVjdCBhYl9mYW1pbHlfaWQgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvYWI4NTAwLWNvcmUuYyBiL2RyaXZlcnMvbWZkL2FiODUwMC1jb3JlLmMKaW5kZXggZDk2NDBhNi4uYjY4ODcwMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZmQvYWI4NTAwLWNvcmUuYworKysgYi9kcml2ZXJzL21mZC9hYjg1MDAtY29yZS5jCkBAIC01Miw2ICs1Miw3IEBACiAjZGVmaW5lIEFCODUwMF9JVF9MQVRDSDhfUkVHCQkweDI3CiAjZGVmaW5lIEFCODUwMF9JVF9MQVRDSDlfUkVHCQkweDI4CiAjZGVmaW5lIEFCODUwMF9JVF9MQVRDSDEwX1JFRwkJMHgyOQorI2RlZmluZSBBQjg1MDBfSVRfTEFUQ0gxMl9SRUcJCTB4MkIKICNkZWZpbmUgQUI4NTAwX0lUX0xBVENIMTlfUkVHCQkweDMyCiAjZGVmaW5lIEFCODUwMF9JVF9MQVRDSDIwX1JFRwkJMHgzMwogI2RlZmluZSBBQjg1MDBfSVRfTEFUQ0gyMV9SRUcJCTB4MzQKQEAgLTk4LDEzICs5OSwxNyBAQAogICogb2Zmc2V0IDAuCiAgKi8KIHN0YXRpYyBjb25zdCBpbnQgYWI4NTAwX2lycV9yZWdvZmZzZXRbQUI4NTAwX05VTV9JUlFfUkVHU10gPSB7Ci0JMCwgMSwgMiwgMywgNCwgNiwgNywgOCwgOSwgMTgsIDE5LCAyMCwgMjEsCisJMCwgMSwgMiwgMywgNCwgNiwgNywgOCwgOSwgMTEsIDE4LCAxOSwgMjAsIDIxLAogfTsKIAogc3RhdGljIGludCBhYjg1MDBfZ2V0X2NoaXBfaWQoc3RydWN0IGRldmljZSAqZGV2KQogewotCXN0cnVjdCBhYjg1MDAgKmFiODUwMCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYtPnBhcmVudCk7Ci0JcmV0dXJuIChpbnQpYWI4NTAwLT5jaGlwX2lkOworCXN0cnVjdCBhYjg1MDAgKmFiODUwMDsKKworCWlmICghZGV2KQorCQlyZXR1cm4gLUVJTlZBTDsKKwlhYjg1MDAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2LT5wYXJlbnQpOworCXJldHVybiBhYjg1MDAgPyAoaW50KWFiODUwMC0+Y2hpcF9pZCA6IC1FSU5WQUw7CiB9CiAKIHN0YXRpYyBpbnQgc2V0X3JlZ2lzdGVyX2ludGVycnVwdGlibGUoc3RydWN0IGFiODUwMCAqYWI4NTAwLCB1OCBiYW5rLApAQCAtMjI4LDE2ICsyMzMsMTYgQEAKIAkuc3RhcnR1cF9pcnFfZW5hYmxlZCA9IE5VTEwsCiB9OwogCi1zdGF0aWMgdm9pZCBhYjg1MDBfaXJxX2xvY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGFiODUwMF9pcnFfbG9jayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IGFiODUwMCAqYWI4NTAwID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgYWI4NTAwICphYjg1MDAgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKIAogCW11dGV4X2xvY2soJmFiODUwMC0+aXJxX2xvY2spOwogfQogCi1zdGF0aWMgdm9pZCBhYjg1MDBfaXJxX3N5bmNfdW5sb2NrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBhYjg1MDBfaXJxX3N5bmNfdW5sb2NrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3QgYWI4NTAwICphYjg1MDAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBhYjg1MDAgKmFiODUwMCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCWludCBpOwogCiAJZm9yIChpID0gMDsgaSA8IEFCODUwMF9OVU1fSVJRX1JFR1M7IGkrKykgewpAQCAtMjQ4LDYgKzI1MywxMCBAQAogCQlpZiAobmV3ID09IG9sZCkKIAkJCWNvbnRpbnVlOwogCisJCS8qIEludGVycnVwdCByZWdpc3RlciAxMiBkb2VzJ250IGV4aXN0IHByaW9yIHRvIHZlcnNpb24gMHgyMCAqLworCQlpZiAoYWI4NTAwX2lycV9yZWdvZmZzZXRbaV0gPT0gMTEgJiYgYWI4NTAwLT5jaGlwX2lkIDwgMHgyMCkKKwkJCWNvbnRpbnVlOworCiAJCWFiODUwMC0+b2xkbWFza1tpXSA9IG5ldzsKIAogCQlyZWcgPSBBQjg1MDBfSVRfTUFTSzFfUkVHICsgYWI4NTAwX2lycV9yZWdvZmZzZXRbaV07CkBAIC0yNTcsMjAgKzI2NiwyMCBAQAogCW11dGV4X3VubG9jaygmYWI4NTAwLT5pcnFfbG9jayk7CiB9CiAKLXN0YXRpYyB2b2lkIGFiODUwMF9pcnFfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgYWI4NTAwX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3QgYWI4NTAwICphYjg1MDAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOwotCWludCBvZmZzZXQgPSBpcnEgLSBhYjg1MDAtPmlycV9iYXNlOworCXN0cnVjdCBhYjg1MDAgKmFiODUwMCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOworCWludCBvZmZzZXQgPSBkYXRhLT5pcnEgLSBhYjg1MDAtPmlycV9iYXNlOwogCWludCBpbmRleCA9IG9mZnNldCAvIDg7CiAJaW50IG1hc2sgPSAxIDw8IChvZmZzZXQgJSA4KTsKIAogCWFiODUwMC0+bWFza1tpbmRleF0gfD0gbWFzazsKIH0KIAotc3RhdGljIHZvaWQgYWI4NTAwX2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGFiODUwMF9pcnFfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3QgYWI4NTAwICphYjg1MDAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOwotCWludCBvZmZzZXQgPSBpcnEgLSBhYjg1MDAtPmlycV9iYXNlOworCXN0cnVjdCBhYjg1MDAgKmFiODUwMCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOworCWludCBvZmZzZXQgPSBkYXRhLT5pcnEgLSBhYjg1MDAtPmlycV9iYXNlOwogCWludCBpbmRleCA9IG9mZnNldCAvIDg7CiAJaW50IG1hc2sgPSAxIDw8IChvZmZzZXQgJSA4KTsKIApAQCAtMjc5LDEwICsyODgsMTAgQEAKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBhYjg1MDBfaXJxX2NoaXAgPSB7CiAJLm5hbWUJCQk9ICJhYjg1MDAiLAotCS5idXNfbG9jawkJPSBhYjg1MDBfaXJxX2xvY2ssCi0JLmJ1c19zeW5jX3VubG9jawk9IGFiODUwMF9pcnFfc3luY191bmxvY2ssCi0JLm1hc2sJCQk9IGFiODUwMF9pcnFfbWFzaywKLQkudW5tYXNrCQkJPSBhYjg1MDBfaXJxX3VubWFzaywKKwkuaXJxX2J1c19sb2NrCQk9IGFiODUwMF9pcnFfbG9jaywKKwkuaXJxX2J1c19zeW5jX3VubG9jawk9IGFiODUwMF9pcnFfc3luY191bmxvY2ssCisJLmlycV9tYXNrCQk9IGFiODUwMF9pcnFfbWFzaywKKwkuaXJxX3VubWFzawkJPSBhYjg1MDBfaXJxX3VubWFzaywKIH07CiAKIHN0YXRpYyBpcnFyZXR1cm5fdCBhYjg1MDBfaXJxKGludCBpcnEsIHZvaWQgKmRldikKQEAgLTI5Nyw2ICszMDYsMTAgQEAKIAkJaW50IHN0YXR1czsKIAkJdTggdmFsdWU7CiAKKwkJLyogSW50ZXJydXB0IHJlZ2lzdGVyIDEyIGRvZXMnbnQgZXhpc3QgcHJpb3IgdG8gdmVyc2lvbiAweDIwICovCisJCWlmIChyZWdvZmZzZXQgPT0gMTEgJiYgYWI4NTAwLT5jaGlwX2lkIDwgMHgyMCkKKwkJCWNvbnRpbnVlOworCiAJCXN0YXR1cyA9IGdldF9yZWdpc3Rlcl9pbnRlcnJ1cHRpYmxlKGFiODUwMCwgQUI4NTAwX0lOVEVSUlVQVCwKIAkJCUFCODUwMF9JVF9MQVRDSDFfUkVHICsgcmVnb2Zmc2V0LCAmdmFsdWUpOwogCQlpZiAoc3RhdHVzIDwgMCB8fCB2YWx1ZSA9PSAwKQpAQCAtMzkzLDEzICs0MDYsMTk1IEBACiAJfSwKIH07CiAKK3N0YXRpYyBzdHJ1Y3QgcmVzb3VyY2UgYWI4NTAwX2JtX3Jlc291cmNlc1tdID0geworCXsKKwkJLm5hbWUgPSAiTUFJTl9FWFRfQ0hfTk9UX09LIiwKKwkJLnN0YXJ0ID0gQUI4NTAwX0lOVF9NQUlOX0VYVF9DSF9OT1RfT0ssCisJCS5lbmQgPSBBQjg1MDBfSU5UX01BSU5fRVhUX0NIX05PVF9PSywKKwkJLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwl7CisJCS5uYW1lID0gIkJBVFRfT1ZWIiwKKwkJLnN0YXJ0ID0gQUI4NTAwX0lOVF9CQVRUX09WViwKKwkJLmVuZCA9IEFCODUwMF9JTlRfQkFUVF9PVlYsCisJCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAorCX0sCisJeworCQkubmFtZSA9ICJNQUlOX0NIX1VOUExVR19ERVQiLAorCQkuc3RhcnQgPSBBQjg1MDBfSU5UX01BSU5fQ0hfVU5QTFVHX0RFVCwKKwkJLmVuZCA9IEFCODUwMF9JTlRfTUFJTl9DSF9VTlBMVUdfREVULAorCQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorCXsKKwkJLm5hbWUgPSAiTUFJTl9DSEFSR0VfUExVR19ERVQiLAorCQkuc3RhcnQgPSBBQjg1MDBfSU5UX01BSU5fQ0hfUExVR19ERVQsCisJCS5lbmQgPSBBQjg1MDBfSU5UX01BSU5fQ0hfUExVR19ERVQsCisJCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAorCX0sCisJeworCQkubmFtZSA9ICJWQlVTX0RFVF9GIiwKKwkJLnN0YXJ0ID0gQUI4NTAwX0lOVF9WQlVTX0RFVF9GLAorCQkuZW5kID0gQUI4NTAwX0lOVF9WQlVTX0RFVF9GLAorCQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorCXsKKwkJLm5hbWUgPSAiVkJVU19ERVRfUiIsCisJCS5zdGFydCA9IEFCODUwMF9JTlRfVkJVU19ERVRfUiwKKwkJLmVuZCA9IEFCODUwMF9JTlRfVkJVU19ERVRfUiwKKwkJLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwl7CisJCS5uYW1lID0gIkJBVF9DVFJMX0lOREIiLAorCQkuc3RhcnQgPSBBQjg1MDBfSU5UX0JBVF9DVFJMX0lOREIsCisJCS5lbmQgPSBBQjg1MDBfSU5UX0JBVF9DVFJMX0lOREIsCisJCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAorCX0sCisJeworCQkubmFtZSA9ICJDSF9XRF9FWFAiLAorCQkuc3RhcnQgPSBBQjg1MDBfSU5UX0NIX1dEX0VYUCwKKwkJLmVuZCA9IEFCODUwMF9JTlRfQ0hfV0RfRVhQLAorCQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorCXsKKwkJLm5hbWUgPSAiVkJVU19PVlYiLAorCQkuc3RhcnQgPSBBQjg1MDBfSU5UX1ZCVVNfT1ZWLAorCQkuZW5kID0gQUI4NTAwX0lOVF9WQlVTX09WViwKKwkJLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwl7CisJCS5uYW1lID0gIk5DT05WX0FDQ1UiLAorCQkuc3RhcnQgPSBBQjg1MDBfSU5UX0NDTl9DT05WX0FDQywKKwkJLmVuZCA9IEFCODUwMF9JTlRfQ0NOX0NPTlZfQUNDLAorCQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorCXsKKwkJLm5hbWUgPSAiTE9XX0JBVF9GIiwKKwkJLnN0YXJ0ID0gQUI4NTAwX0lOVF9MT1dfQkFUX0YsCisJCS5lbmQgPSBBQjg1MDBfSU5UX0xPV19CQVRfRiwKKwkJLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwl7CisJCS5uYW1lID0gIkxPV19CQVRfUiIsCisJCS5zdGFydCA9IEFCODUwMF9JTlRfTE9XX0JBVF9SLAorCQkuZW5kID0gQUI4NTAwX0lOVF9MT1dfQkFUX1IsCisJCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAorCX0sCisJeworCQkubmFtZSA9ICJCVEVNUF9MT1ciLAorCQkuc3RhcnQgPSBBQjg1MDBfSU5UX0JURU1QX0xPVywKKwkJLmVuZCA9IEFCODUwMF9JTlRfQlRFTVBfTE9XLAorCQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorCXsKKwkJLm5hbWUgPSAiQlRFTVBfSElHSCIsCisJCS5zdGFydCA9IEFCODUwMF9JTlRfQlRFTVBfSElHSCwKKwkJLmVuZCA9IEFCODUwMF9JTlRfQlRFTVBfSElHSCwKKwkJLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwl7CisJCS5uYW1lID0gIlVTQl9DSEFSR0VSX05PVF9PS1IiLAorCQkuc3RhcnQgPSBBQjg1MDBfSU5UX1VTQl9DSEFSR0VSX05PVF9PSywKKwkJLmVuZCA9IEFCODUwMF9JTlRfVVNCX0NIQVJHRVJfTk9UX09LLAorCQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorCXsKKwkJLm5hbWUgPSAiVVNCX0NIQVJHRV9ERVRfRE9ORSIsCisJCS5zdGFydCA9IEFCODUwMF9JTlRfVVNCX0NIR19ERVRfRE9ORSwKKwkJLmVuZCA9IEFCODUwMF9JTlRfVVNCX0NIR19ERVRfRE9ORSwKKwkJLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwl7CisJCS5uYW1lID0gIlVTQl9DSF9USF9QUk9UX1IiLAorCQkuc3RhcnQgPSBBQjg1MDBfSU5UX1VTQl9DSF9USF9QUk9UX1IsCisJCS5lbmQgPSBBQjg1MDBfSU5UX1VTQl9DSF9USF9QUk9UX1IsCisJCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAorCX0sCisJeworCQkubmFtZSA9ICJNQUlOX0NIX1RIX1BST1RfUiIsCisJCS5zdGFydCA9IEFCODUwMF9JTlRfTUFJTl9DSF9USF9QUk9UX1IsCisJCS5lbmQgPSBBQjg1MDBfSU5UX01BSU5fQ0hfVEhfUFJPVF9SLAorCQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorCXsKKwkJLm5hbWUgPSAiVVNCX0NIQVJHRVJfTk9UX09LRiIsCisJCS5zdGFydCA9IEFCODUwMF9JTlRfVVNCX0NIQVJHRVJfTk9UX09LRiwKKwkJLmVuZCA9IEFCODUwMF9JTlRfVVNCX0NIQVJHRVJfTk9UX09LRiwKKwkJLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCisJfSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcmVzb3VyY2UgYWI4NTAwX2RlYnVnX3Jlc291cmNlc1tdID0geworCXsKKwkJLm5hbWUJPSAiSVJRX0ZJUlNUIiwKKwkJLnN0YXJ0CT0gQUI4NTAwX0lOVF9NQUlOX0VYVF9DSF9OT1RfT0ssCisJCS5lbmQJPSBBQjg1MDBfSU5UX01BSU5fRVhUX0NIX05PVF9PSywKKwkJLmZsYWdzCT0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwl7CisJCS5uYW1lCT0gIklSUV9MQVNUIiwKKwkJLnN0YXJ0CT0gQUI4NTAwX0lOVF9VU0JfQ0hBUkdFUl9OT1RfT0tGLAorCQkuZW5kCT0gQUI4NTAwX0lOVF9VU0JfQ0hBUkdFUl9OT1RfT0tGLAorCQkuZmxhZ3MJPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorfTsKKworc3RhdGljIHN0cnVjdCByZXNvdXJjZSBhYjg1MDBfdXNiX3Jlc291cmNlc1tdID0geworCXsKKwkJLm5hbWUgPSAiSURfV0FLRVVQX1IiLAorCQkuc3RhcnQgPSBBQjg1MDBfSU5UX0lEX1dBS0VVUF9SLAorCQkuZW5kID0gQUI4NTAwX0lOVF9JRF9XQUtFVVBfUiwKKwkJLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwl7CisJCS5uYW1lID0gIklEX1dBS0VVUF9GIiwKKwkJLnN0YXJ0ID0gQUI4NTAwX0lOVF9JRF9XQUtFVVBfRiwKKwkJLmVuZCA9IEFCODUwMF9JTlRfSURfV0FLRVVQX0YsCisJCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAorCX0sCisJeworCQkubmFtZSA9ICJWQlVTX0RFVF9GIiwKKwkJLnN0YXJ0ID0gQUI4NTAwX0lOVF9WQlVTX0RFVF9GLAorCQkuZW5kID0gQUI4NTAwX0lOVF9WQlVTX0RFVF9GLAorCQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKKwl9LAorCXsKKwkJLm5hbWUgPSAiVkJVU19ERVRfUiIsCisJCS5zdGFydCA9IEFCODUwMF9JTlRfVkJVU19ERVRfUiwKKwkJLmVuZCA9IEFCODUwMF9JTlRfVkJVU19ERVRfUiwKKwkJLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCisJfSwKKwl7CisJCS5uYW1lID0gIlVTQl9MSU5LX1NUQVRVUyIsCisJCS5zdGFydCA9IEFCODUwMF9JTlRfVVNCX0xJTktfU1RBVFVTLAorCQkuZW5kID0gQUI4NTAwX0lOVF9VU0JfTElOS19TVEFUVVMsCisJCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAorCX0sCit9OworCitzdGF0aWMgc3RydWN0IHJlc291cmNlIGFiODUwMF90ZW1wX3Jlc291cmNlc1tdID0geworCXsKKwkJLm5hbWUgID0gIkFCODUwMF9URU1QX1dBUk0iLAorCQkuc3RhcnQgPSBBQjg1MDBfSU5UX1RFTVBfV0FSTSwKKwkJLmVuZCAgID0gQUI4NTAwX0lOVF9URU1QX1dBUk0sCisJCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAorCX0sCit9OworCiBzdGF0aWMgc3RydWN0IG1mZF9jZWxsIGFiODUwMF9kZXZzW10gPSB7CiAjaWZkZWYgQ09ORklHX0RFQlVHX0ZTCiAJewogCQkubmFtZSA9ICJhYjg1MDAtZGVidWciLAorCQkubnVtX3Jlc291cmNlcyA9IEFSUkFZX1NJWkUoYWI4NTAwX2RlYnVnX3Jlc291cmNlcyksCisJCS5yZXNvdXJjZXMgPSBhYjg1MDBfZGVidWdfcmVzb3VyY2VzLAogCX0sCiAjZW5kaWYKIAl7CisJCS5uYW1lID0gImFiODUwMC1zeXNjdHJsIiwKKwl9LAorCXsKKwkJLm5hbWUgPSAiYWI4NTAwLXJlZ3VsYXRvciIsCisJfSwKKwl7CiAJCS5uYW1lID0gImFiODUwMC1ncGFkYyIsCiAJCS5udW1fcmVzb3VyY2VzID0gQVJSQVlfU0laRShhYjg1MDBfZ3BhZGNfcmVzb3VyY2VzKSwKIAkJLnJlc291cmNlcyA9IGFiODUwMF9ncGFkY19yZXNvdXJjZXMsCkBAIC00MTAsNiArNjA1LDIyIEBACiAJCS5yZXNvdXJjZXMgPSBhYjg1MDBfcnRjX3Jlc291cmNlcywKIAl9LAogCXsKKwkJLm5hbWUgPSAiYWI4NTAwLWJtIiwKKwkJLm51bV9yZXNvdXJjZXMgPSBBUlJBWV9TSVpFKGFiODUwMF9ibV9yZXNvdXJjZXMpLAorCQkucmVzb3VyY2VzID0gYWI4NTAwX2JtX3Jlc291cmNlcywKKwl9LAorCXsgLm5hbWUgPSAiYWI4NTAwLWNvZGVjIiwgfSwKKwl7CisJCS5uYW1lID0gImFiODUwMC11c2IiLAorCQkubnVtX3Jlc291cmNlcyA9IEFSUkFZX1NJWkUoYWI4NTAwX3VzYl9yZXNvdXJjZXMpLAorCQkucmVzb3VyY2VzID0gYWI4NTAwX3VzYl9yZXNvdXJjZXMsCisJfSwKKwl7CisJCS5uYW1lID0gImFiODUwMC1wb3dlcm9uLWtleSIsCisJCS5udW1fcmVzb3VyY2VzID0gQVJSQVlfU0laRShhYjg1MDBfcG93ZXJvbmtleV9kYl9yZXNvdXJjZXMpLAorCQkucmVzb3VyY2VzID0gYWI4NTAwX3Bvd2Vyb25rZXlfZGJfcmVzb3VyY2VzLAorCX0sCisJewogCQkubmFtZSA9ICJhYjg1MDAtcHdtIiwKIAkJLmlkID0gMSwKIAl9LApAQCAtNDIxLDE1ICs2MzIsMzUgQEAKIAkJLm5hbWUgPSAiYWI4NTAwLXB3bSIsCiAJCS5pZCA9IDMsCiAJfSwKLQl7IC5uYW1lID0gImFiODUwMC1jaGFyZ2VyIiwgfSwKLQl7IC5uYW1lID0gImFiODUwMC1hdWRpbyIsIH0sCi0JeyAubmFtZSA9ICJhYjg1MDAtdXNiIiwgfSwKLQl7IC5uYW1lID0gImFiODUwMC1yZWd1bGF0b3IiLCB9LAorCXsgLm5hbWUgPSAiYWI4NTAwLWxlZHMiLCB9LAogCXsKLQkJLm5hbWUgPSAiYWI4NTAwLXBvd2Vyb24ta2V5IiwKLQkJLm51bV9yZXNvdXJjZXMgPSBBUlJBWV9TSVpFKGFiODUwMF9wb3dlcm9ua2V5X2RiX3Jlc291cmNlcyksCi0JCS5yZXNvdXJjZXMgPSBhYjg1MDBfcG93ZXJvbmtleV9kYl9yZXNvdXJjZXMsCisJCS5uYW1lID0gImFiODUwMC1kZW5jIiwKIAl9LAorCXsKKwkJLm5hbWUgPSAiYWI4NTAwLXRlbXAiLAorCQkubnVtX3Jlc291cmNlcyA9IEFSUkFZX1NJWkUoYWI4NTAwX3RlbXBfcmVzb3VyY2VzKSwKKwkJLnJlc291cmNlcyA9IGFiODUwMF90ZW1wX3Jlc291cmNlcywKKwl9LAorfTsKKworc3RhdGljIHNzaXplX3Qgc2hvd19jaGlwX2lkKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQlzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQoreworCXN0cnVjdCBhYjg1MDAgKmFiODUwMDsKKworCWFiODUwMCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiUjeFxuIiwgYWI4NTAwID8gYWI4NTAwLT5jaGlwX2lkIDogLUVJTlZBTCk7Cit9CisKK3N0YXRpYyBERVZJQ0VfQVRUUihjaGlwX2lkLCBTX0lSVUdPLCBzaG93X2NoaXBfaWQsIE5VTEwpOworCitzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSAqYWI4NTAwX3N5c2ZzX2VudHJpZXNbXSA9IHsKKwkmZGV2X2F0dHJfY2hpcF9pZC5hdHRyLAorCU5VTEwsCit9OworCitzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBhYjg1MDBfYXR0cl9ncm91cCA9IHsKKwkuYXR0cnMJPSBhYjg1MDBfc3lzZnNfZW50cmllcywKIH07CiAKIGludCBfX2RldmluaXQgYWI4NTAwX2luaXQoc3RydWN0IGFiODUwMCAqYWI4NTAwKQpAQCAtNDU0LDggKzY4NSw5IEBACiAJICogMHgwIC0gRWFybHkgRHJvcAogCSAqIDB4MTAgLSBDdXQgMS4wCiAJICogMHgxMSAtIEN1dCAxLjEKKwkgKiAweDIwIC0gQ3V0IDIuMAogCSAqLwotCWlmICh2YWx1ZSA9PSAweDAgfHwgdmFsdWUgPT0gMHgxMCB8fCB2YWx1ZSA9PSAweDExKSB7CisJaWYgKHZhbHVlID09IDB4MCB8fCB2YWx1ZSA9PSAweDEwIHx8IHZhbHVlID09IDB4MTEgfHwgdmFsdWUgPT0gMHgyMCkgewogCQlhYjg1MDAtPnJldmlzaW9uID0gdmFsdWU7CiAJCWRldl9pbmZvKGFiODUwMC0+ZGV2LCAiZGV0ZWN0ZWQgY2hpcCwgcmV2aXNpb246ICUjeFxuIiwgdmFsdWUpOwogCX0gZWxzZSB7CkBAIC00NjgsMTggKzcwMCwxNiBAQAogCQlwbGF0LT5pbml0KGFiODUwMCk7CiAKIAkvKiBDbGVhciBhbmQgbWFzayBhbGwgaW50ZXJydXB0cyAqLwotCWZvciAoaSA9IDA7IGkgPCAxMDsgaSsrKSB7Ci0JCWdldF9yZWdpc3Rlcl9pbnRlcnJ1cHRpYmxlKGFiODUwMCwgQUI4NTAwX0lOVEVSUlVQVCwKLQkJCUFCODUwMF9JVF9MQVRDSDFfUkVHICsgaSwgJnZhbHVlKTsKLQkJc2V0X3JlZ2lzdGVyX2ludGVycnVwdGlibGUoYWI4NTAwLCBBQjg1MDBfSU5URVJSVVBULAotCQkJQUI4NTAwX0lUX01BU0sxX1JFRyArIGksIDB4ZmYpOwotCX0KKwlmb3IgKGkgPSAwOyBpIDwgQUI4NTAwX05VTV9JUlFfUkVHUzsgaSsrKSB7CisJCS8qIEludGVycnVwdCByZWdpc3RlciAxMiBkb2VzJ250IGV4aXN0IHByaW9yIHRvIHZlcnNpb24gMHgyMCAqLworCQlpZiAoYWI4NTAwX2lycV9yZWdvZmZzZXRbaV0gPT0gMTEgJiYgYWI4NTAwLT5jaGlwX2lkIDwgMHgyMCkKKwkJCWNvbnRpbnVlOwogCi0JZm9yIChpID0gMTg7IGkgPCAyNDsgaSsrKSB7CiAJCWdldF9yZWdpc3Rlcl9pbnRlcnJ1cHRpYmxlKGFiODUwMCwgQUI4NTAwX0lOVEVSUlVQVCwKLQkJCUFCODUwMF9JVF9MQVRDSDFfUkVHICsgaSwgJnZhbHVlKTsKKwkJCUFCODUwMF9JVF9MQVRDSDFfUkVHICsgYWI4NTAwX2lycV9yZWdvZmZzZXRbaV0sCisJCQkmdmFsdWUpOwogCQlzZXRfcmVnaXN0ZXJfaW50ZXJydXB0aWJsZShhYjg1MDAsIEFCODUwMF9JTlRFUlJVUFQsCi0JCQlBQjg1MDBfSVRfTUFTSzFfUkVHICsgaSwgMHhmZik7CisJCQlBQjg1MDBfSVRfTUFTSzFfUkVHICsgYWI4NTAwX2lycV9yZWdvZmZzZXRbaV0sIDB4ZmYpOwogCX0KIAogCXJldCA9IGFieDUwMF9yZWdpc3Rlcl9vcHMoYWI4NTAwLT5kZXYsICZhYjg1MDBfb3BzKTsKQEAgLTQ5NSw3ICs3MjUsOCBAQAogCQkJcmV0dXJuIHJldDsKIAogCQlyZXQgPSByZXF1ZXN0X3RocmVhZGVkX2lycShhYjg1MDAtPmlycSwgTlVMTCwgYWI4NTAwX2lycSwKLQkJCQkJICAgSVJRRl9PTkVTSE9ULCAiYWI4NTAwIiwgYWI4NTAwKTsKKwkJCQkJICAgSVJRRl9PTkVTSE9UIHwgSVJRRl9OT19TVVNQRU5ELAorCQkJCQkgICAiYWI4NTAwIiwgYWI4NTAwKTsKIAkJaWYgKHJldCkKIAkJCWdvdG8gb3V0X3JlbW92ZWlycTsKIAl9CkBAIC01MDYsNiArNzM3LDEwIEBACiAJaWYgKHJldCkKIAkJZ290byBvdXRfZnJlZWlycTsKIAorCXJldCA9IHN5c2ZzX2NyZWF0ZV9ncm91cCgmYWI4NTAwLT5kZXYtPmtvYmosICZhYjg1MDBfYXR0cl9ncm91cCk7CisJaWYgKHJldCkKKwkJZGV2X2VycihhYjg1MDAtPmRldiwgImVycm9yIGNyZWF0aW5nIHN5c2ZzIGVudHJpZXNcbiIpOworCiAJcmV0dXJuIHJldDsKIAogb3V0X2ZyZWVpcnE6CkBAIC01MTksNiArNzU0LDcgQEAKIAogaW50IF9fZGV2ZXhpdCBhYjg1MDBfZXhpdChzdHJ1Y3QgYWI4NTAwICphYjg1MDApCiB7CisJc3lzZnNfcmVtb3ZlX2dyb3VwKCZhYjg1MDAtPmRldi0+a29iaiwgJmFiODUwMF9hdHRyX2dyb3VwKTsKIAltZmRfcmVtb3ZlX2RldmljZXMoYWI4NTAwLT5kZXYpOwogCWlmIChhYjg1MDAtPmlycV9iYXNlKSB7CiAJCWZyZWVfaXJxKGFiODUwMC0+aXJxLCBhYjg1MDApOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvYWI4NTAwLWRlYnVnZnMuYyBiL2RyaXZlcnMvbWZkL2FiODUwMC1kZWJ1Z2ZzLmMKaW5kZXggOGQxZTA1YS4uM2MxNTQxYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZmQvYWI4NTAwLWRlYnVnZnMuYworKysgYi9kcml2ZXJzL21mZC9hYjg1MDAtZGVidWdmcy5jCkBAIC0yNCw5ICsyNCw5IEBACiAgKiBAcGVybTogYWNjZXNzIHBlcm1pc3Npb25zIGZvciB0aGUgcmFuZ2UKICAqLwogc3RydWN0IGFiODUwMF9yZWdfcmFuZ2UgewotICAgICAgIHU4IGZpcnN0OwotICAgICAgIHU4IGxhc3Q7Ci0gICAgICAgdTggcGVybTsKKwl1OCBmaXJzdDsKKwl1OCBsYXN0OworCXU4IHBlcm07CiB9OwogCiAvKioKQEAgLTM2LDkgKzM2LDkgQEAKICAqIEByYW5nZTogdGhlIGxpc3Qgb2YgcmVnaXN0ZXIgcmFuZ2VzCiAgKi8KIHN0cnVjdCBhYjg1MDBfaTJjX3JhbmdlcyB7Ci0gICAgICAgdTggbnVtX3JhbmdlczsKLSAgICAgICB1OCBiYW5raWQ7Ci0gICAgICAgY29uc3Qgc3RydWN0IGFiODUwMF9yZWdfcmFuZ2UgKnJhbmdlOworCXU4IG51bV9yYW5nZXM7CisJdTggYmFua2lkOworCWNvbnN0IHN0cnVjdCBhYjg1MDBfcmVnX3JhbmdlICpyYW5nZTsKIH07CiAKICNkZWZpbmUgQUI4NTAwX05BTUVfU1RSSU5HICJhYjg1MDAiCkBAIC00Nyw1MjEgKzQ3LDUyMSBAQAogI2RlZmluZSBBQjg1MDBfUkVWX1JFRyAweDgwCiAKIHN0YXRpYyBzdHJ1Y3QgYWI4NTAwX2kyY19yYW5nZXMgZGVidWdfcmFuZ2VzW0FCODUwMF9OVU1fQkFOS1NdID0gewotICAgICAgIFsweDBdID0gewotICAgICAgICAgICAgICAgLm51bV9yYW5nZXMgPSAwLAotICAgICAgICAgICAgICAgLnJhbmdlID0gMCwKLSAgICAgICB9LAotICAgICAgIFtBQjg1MDBfU1lTX0NUUkwxX0JMT0NLXSA9IHsKLSAgICAgICAgICAgICAgIC5udW1fcmFuZ2VzID0gMywKLSAgICAgICAgICAgICAgIC5yYW5nZSA9IChzdHJ1Y3QgYWI4NTAwX3JlZ19yYW5nZVtdKSB7Ci0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDAwLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHgwMiwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4NDIsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDQyLAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHg4MCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4ODEsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICB9LAotICAgICAgIH0sCi0gICAgICAgW0FCODUwMF9TWVNfQ1RSTDJfQkxPQ0tdID0gewotICAgICAgICAgICAgICAgLm51bV9yYW5nZXMgPSA0LAotICAgICAgICAgICAgICAgLnJhbmdlID0gKHN0cnVjdCBhYjg1MDBfcmVnX3JhbmdlW10pIHsKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4MDAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDBELAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHgwRiwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4MTcsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDMwLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHgzMCwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4MzIsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDMzLAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgfSwKLSAgICAgICB9LAotICAgICAgIFtBQjg1MDBfUkVHVV9DVFJMMV0gPSB7Ci0gICAgICAgICAgICAgICAubnVtX3JhbmdlcyA9IDMsCi0gICAgICAgICAgICAgICAucmFuZ2UgPSAoc3RydWN0IGFiODUwMF9yZWdfcmFuZ2VbXSkgewotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHgwMCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4MDAsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDAzLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHgxMCwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4ODAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDg0LAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgfSwKLSAgICAgICB9LAotICAgICAgIFtBQjg1MDBfUkVHVV9DVFJMMl0gPSB7Ci0gICAgICAgICAgICAgICAubnVtX3JhbmdlcyA9IDUsCi0gICAgICAgICAgICAgICAucmFuZ2UgPSAoc3RydWN0IGFiODUwMF9yZWdfcmFuZ2VbXSkgewotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHgwMCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4MTUsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDE3LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHgxOSwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4MUIsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDFELAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHgxRiwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4MjIsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDQwLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHg0NCwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgLyogMHg4MC0weDhCIGlzIFNJTSByZWdpc3RlcnMgYW5kIHNob3VsZAotICAgICAgICAgICAgICAgICAgICAgICAgKiBub3QgYmUgYWNjZXNzZWQgZnJvbSBoZXJlICovCi0gICAgICAgICAgICAgICB9LAotICAgICAgIH0sCi0gICAgICAgW0FCODUwMF9VU0JdID0gewotICAgICAgICAgICAgICAgLm51bV9yYW5nZXMgPSAyLAotICAgICAgICAgICAgICAgLnJhbmdlID0gKHN0cnVjdCBhYjg1MDBfcmVnX3JhbmdlW10pIHsKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4ODAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDgzLAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHg4NywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4OEEsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICB9LAotICAgICAgIH0sCi0gICAgICAgW0FCODUwMF9UVk9VVF0gPSB7Ci0gICAgICAgICAgICAgICAubnVtX3JhbmdlcyA9IDksCi0gICAgICAgICAgICAgICAucmFuZ2UgPSAoc3RydWN0IGFiODUwMF9yZWdfcmFuZ2VbXSkgewotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHgwMCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4MTIsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDE1LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHgxNywKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4MTksCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDIxLAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHgyNywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4MkMsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDQxLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHg0MSwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4NDUsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDVCLAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHg1RCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4NUQsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDY5LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHg2OSwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4ODAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDgxLAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgfSwKLSAgICAgICB9LAotICAgICAgIFtBQjg1MDBfREJJXSA9IHsKLSAgICAgICAgICAgICAgIC5udW1fcmFuZ2VzID0gMCwKLSAgICAgICAgICAgICAgIC5yYW5nZSA9IDAsCi0gICAgICAgfSwKLSAgICAgICBbQUI4NTAwX0VDSV9BVl9BQ0NdID0gewotICAgICAgICAgICAgICAgLm51bV9yYW5nZXMgPSAxLAotICAgICAgICAgICAgICAgLnJhbmdlID0gKHN0cnVjdCBhYjg1MDBfcmVnX3JhbmdlW10pIHsKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4ODAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDgyLAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgfSwKLSAgICAgICB9LAotICAgICAgIFsweDldID0gewotICAgICAgICAgICAgICAgLm51bV9yYW5nZXMgPSAwLAotICAgICAgICAgICAgICAgLnJhbmdlID0gMCwKLSAgICAgICB9LAotICAgICAgIFtBQjg1MDBfR1BBRENdID0gewotICAgICAgICAgICAgICAgLm51bV9yYW5nZXMgPSAxLAotICAgICAgICAgICAgICAgLnJhbmdlID0gKHN0cnVjdCBhYjg1MDBfcmVnX3JhbmdlW10pIHsKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4MDAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDA4LAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgfSwKLSAgICAgICB9LAotICAgICAgIFtBQjg1MDBfQ0hBUkdFUl0gPSB7Ci0gICAgICAgICAgICAgICAubnVtX3JhbmdlcyA9IDgsCi0gICAgICAgICAgICAgICAucmFuZ2UgPSAoc3RydWN0IGFiODUwMF9yZWdfcmFuZ2VbXSkgewotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHgwMCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4MDMsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDA1LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHgwNSwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4NDAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDQwLAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHg0MiwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4NDIsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDQ0LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHg0NCwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4NTAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDU1LAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHg4MCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4ODIsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweEMwLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHhDMiwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgIH0sCi0gICAgICAgfSwKLSAgICAgICBbQUI4NTAwX0dBU19HQVVHRV0gPSB7Ci0gICAgICAgICAgICAgICAubnVtX3JhbmdlcyA9IDMsCi0gICAgICAgICAgICAgICAucmFuZ2UgPSAoc3RydWN0IGFiODUwMF9yZWdfcmFuZ2VbXSkgewotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHgwMCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4MDAsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDA3LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHgwQSwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4MTAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDE0LAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgfSwKLSAgICAgICB9LAotICAgICAgIFtBQjg1MDBfQVVESU9dID0gewotICAgICAgICAgICAgICAgLm51bV9yYW5nZXMgPSAxLAotICAgICAgICAgICAgICAgLnJhbmdlID0gKHN0cnVjdCBhYjg1MDBfcmVnX3JhbmdlW10pIHsKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4MDAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDZGLAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgfSwKLSAgICAgICB9LAotICAgICAgIFtBQjg1MDBfSU5URVJSVVBUXSA9IHsKLSAgICAgICAgICAgICAgIC5udW1fcmFuZ2VzID0gMCwKLSAgICAgICAgICAgICAgIC5yYW5nZSA9IDAsCi0gICAgICAgfSwKLSAgICAgICBbQUI4NTAwX1JUQ10gPSB7Ci0gICAgICAgICAgICAgICAubnVtX3JhbmdlcyA9IDEsCi0gICAgICAgICAgICAgICAucmFuZ2UgPSAoc3RydWN0IGFiODUwMF9yZWdfcmFuZ2VbXSkgewotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHgwMCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4MEYsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICB9LAotICAgICAgIH0sCi0gICAgICAgW0FCODUwMF9NSVNDXSA9IHsKLSAgICAgICAgICAgICAgIC5udW1fcmFuZ2VzID0gOCwKLSAgICAgICAgICAgICAgIC5yYW5nZSA9IChzdHJ1Y3QgYWI4NTAwX3JlZ19yYW5nZVtdKSB7Ci0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDAwLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHgwNSwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4MTAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDE1LAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHgyMCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4MjUsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDMwLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHgzNSwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4NDAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDQ1LAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmZpcnN0ID0gMHg1MCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAubGFzdCA9IDB4NTAsCi0gICAgICAgICAgICAgICAgICAgICAgIH0sCi0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDYwLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHg2NywKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5maXJzdCA9IDB4ODAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLmxhc3QgPSAweDgwLAotICAgICAgICAgICAgICAgICAgICAgICB9LAotICAgICAgICAgICAgICAgfSwKLSAgICAgICB9LAotICAgICAgIFsweDExXSA9IHsKLSAgICAgICAgICAgICAgIC5udW1fcmFuZ2VzID0gMCwKLSAgICAgICAgICAgICAgIC5yYW5nZSA9IDAsCi0gICAgICAgfSwKLSAgICAgICBbMHgxMl0gPSB7Ci0gICAgICAgICAgICAgICAubnVtX3JhbmdlcyA9IDAsCi0gICAgICAgICAgICAgICAucmFuZ2UgPSAwLAotICAgICAgIH0sCi0gICAgICAgWzB4MTNdID0gewotICAgICAgICAgICAgICAgLm51bV9yYW5nZXMgPSAwLAotICAgICAgICAgICAgICAgLnJhbmdlID0gMCwKLSAgICAgICB9LAotICAgICAgIFsweDE0XSA9IHsKLSAgICAgICAgICAgICAgIC5udW1fcmFuZ2VzID0gMCwKLSAgICAgICAgICAgICAgIC5yYW5nZSA9IDAsCi0gICAgICAgfSwKLSAgICAgICBbQUI4NTAwX09UUF9FTVVMXSA9IHsKLSAgICAgICAgICAgICAgIC5udW1fcmFuZ2VzID0gMSwKLSAgICAgICAgICAgICAgIC5yYW5nZSA9IChzdHJ1Y3QgYWI4NTAwX3JlZ19yYW5nZVtdKSB7Ci0gICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAuZmlyc3QgPSAweDAxLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC5sYXN0ID0gMHgwRiwKLSAgICAgICAgICAgICAgICAgICAgICAgfSwKLSAgICAgICAgICAgICAgIH0sCi0gICAgICAgfSwKKwlbMHgwXSA9IHsKKwkJLm51bV9yYW5nZXMgPSAwLAorCQkucmFuZ2UgPSAwLAorCX0sCisJW0FCODUwMF9TWVNfQ1RSTDFfQkxPQ0tdID0geworCQkubnVtX3JhbmdlcyA9IDMsCisJCS5yYW5nZSA9IChzdHJ1Y3QgYWI4NTAwX3JlZ19yYW5nZVtdKSB7CisJCQl7CisJCQkJLmZpcnN0ID0gMHgwMCwKKwkJCQkubGFzdCA9IDB4MDIsCisJCQl9LAorCQkJeworCQkJCS5maXJzdCA9IDB4NDIsCisJCQkJLmxhc3QgPSAweDQyLAorCQkJfSwKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDgwLAorCQkJCS5sYXN0ID0gMHg4MSwKKwkJCX0sCisJCX0sCisJfSwKKwlbQUI4NTAwX1NZU19DVFJMMl9CTE9DS10gPSB7CisJCS5udW1fcmFuZ2VzID0gNCwKKwkJLnJhbmdlID0gKHN0cnVjdCBhYjg1MDBfcmVnX3JhbmdlW10pIHsKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDAwLAorCQkJCS5sYXN0ID0gMHgwRCwKKwkJCX0sCisJCQl7CisJCQkJLmZpcnN0ID0gMHgwRiwKKwkJCQkubGFzdCA9IDB4MTcsCisJCQl9LAorCQkJeworCQkJCS5maXJzdCA9IDB4MzAsCisJCQkJLmxhc3QgPSAweDMwLAorCQkJfSwKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDMyLAorCQkJCS5sYXN0ID0gMHgzMywKKwkJCX0sCisJCX0sCisJfSwKKwlbQUI4NTAwX1JFR1VfQ1RSTDFdID0geworCQkubnVtX3JhbmdlcyA9IDMsCisJCS5yYW5nZSA9IChzdHJ1Y3QgYWI4NTAwX3JlZ19yYW5nZVtdKSB7CisJCQl7CisJCQkJLmZpcnN0ID0gMHgwMCwKKwkJCQkubGFzdCA9IDB4MDAsCisJCQl9LAorCQkJeworCQkJCS5maXJzdCA9IDB4MDMsCisJCQkJLmxhc3QgPSAweDEwLAorCQkJfSwKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDgwLAorCQkJCS5sYXN0ID0gMHg4NCwKKwkJCX0sCisJCX0sCisJfSwKKwlbQUI4NTAwX1JFR1VfQ1RSTDJdID0geworCQkubnVtX3JhbmdlcyA9IDUsCisJCS5yYW5nZSA9IChzdHJ1Y3QgYWI4NTAwX3JlZ19yYW5nZVtdKSB7CisJCQl7CisJCQkJLmZpcnN0ID0gMHgwMCwKKwkJCQkubGFzdCA9IDB4MTUsCisJCQl9LAorCQkJeworCQkJCS5maXJzdCA9IDB4MTcsCisJCQkJLmxhc3QgPSAweDE5LAorCQkJfSwKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDFCLAorCQkJCS5sYXN0ID0gMHgxRCwKKwkJCX0sCisJCQl7CisJCQkJLmZpcnN0ID0gMHgxRiwKKwkJCQkubGFzdCA9IDB4MjIsCisJCQl9LAorCQkJeworCQkJCS5maXJzdCA9IDB4NDAsCisJCQkJLmxhc3QgPSAweDQ0LAorCQkJfSwKKwkJCS8qIDB4ODAtMHg4QiBpcyBTSU0gcmVnaXN0ZXJzIGFuZCBzaG91bGQKKwkJCSAqIG5vdCBiZSBhY2Nlc3NlZCBmcm9tIGhlcmUgKi8KKwkJfSwKKwl9LAorCVtBQjg1MDBfVVNCXSA9IHsKKwkJLm51bV9yYW5nZXMgPSAyLAorCQkucmFuZ2UgPSAoc3RydWN0IGFiODUwMF9yZWdfcmFuZ2VbXSkgeworCQkJeworCQkJCS5maXJzdCA9IDB4ODAsCisJCQkJLmxhc3QgPSAweDgzLAorCQkJfSwKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDg3LAorCQkJCS5sYXN0ID0gMHg4QSwKKwkJCX0sCisJCX0sCisJfSwKKwlbQUI4NTAwX1RWT1VUXSA9IHsKKwkJLm51bV9yYW5nZXMgPSA5LAorCQkucmFuZ2UgPSAoc3RydWN0IGFiODUwMF9yZWdfcmFuZ2VbXSkgeworCQkJeworCQkJCS5maXJzdCA9IDB4MDAsCisJCQkJLmxhc3QgPSAweDEyLAorCQkJfSwKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDE1LAorCQkJCS5sYXN0ID0gMHgxNywKKwkJCX0sCisJCQl7CisJCQkJLmZpcnN0ID0gMHgxOSwKKwkJCQkubGFzdCA9IDB4MjEsCisJCQl9LAorCQkJeworCQkJCS5maXJzdCA9IDB4MjcsCisJCQkJLmxhc3QgPSAweDJDLAorCQkJfSwKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDQxLAorCQkJCS5sYXN0ID0gMHg0MSwKKwkJCX0sCisJCQl7CisJCQkJLmZpcnN0ID0gMHg0NSwKKwkJCQkubGFzdCA9IDB4NUIsCisJCQl9LAorCQkJeworCQkJCS5maXJzdCA9IDB4NUQsCisJCQkJLmxhc3QgPSAweDVELAorCQkJfSwKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDY5LAorCQkJCS5sYXN0ID0gMHg2OSwKKwkJCX0sCisJCQl7CisJCQkJLmZpcnN0ID0gMHg4MCwKKwkJCQkubGFzdCA9IDB4ODEsCisJCQl9LAorCQl9LAorCX0sCisJW0FCODUwMF9EQkldID0geworCQkubnVtX3JhbmdlcyA9IDAsCisJCS5yYW5nZSA9IE5VTEwsCisJfSwKKwlbQUI4NTAwX0VDSV9BVl9BQ0NdID0geworCQkubnVtX3JhbmdlcyA9IDEsCisJCS5yYW5nZSA9IChzdHJ1Y3QgYWI4NTAwX3JlZ19yYW5nZVtdKSB7CisJCQl7CisJCQkJLmZpcnN0ID0gMHg4MCwKKwkJCQkubGFzdCA9IDB4ODIsCisJCQl9LAorCQl9LAorCX0sCisJWzB4OV0gPSB7CisJCS5udW1fcmFuZ2VzID0gMCwKKwkJLnJhbmdlID0gTlVMTCwKKwl9LAorCVtBQjg1MDBfR1BBRENdID0geworCQkubnVtX3JhbmdlcyA9IDEsCisJCS5yYW5nZSA9IChzdHJ1Y3QgYWI4NTAwX3JlZ19yYW5nZVtdKSB7CisJCQl7CisJCQkJLmZpcnN0ID0gMHgwMCwKKwkJCQkubGFzdCA9IDB4MDgsCisJCQl9LAorCQl9LAorCX0sCisJW0FCODUwMF9DSEFSR0VSXSA9IHsKKwkJLm51bV9yYW5nZXMgPSA4LAorCQkucmFuZ2UgPSAoc3RydWN0IGFiODUwMF9yZWdfcmFuZ2VbXSkgeworCQkJeworCQkJCS5maXJzdCA9IDB4MDAsCisJCQkJLmxhc3QgPSAweDAzLAorCQkJfSwKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDA1LAorCQkJCS5sYXN0ID0gMHgwNSwKKwkJCX0sCisJCQl7CisJCQkJLmZpcnN0ID0gMHg0MCwKKwkJCQkubGFzdCA9IDB4NDAsCisJCQl9LAorCQkJeworCQkJCS5maXJzdCA9IDB4NDIsCisJCQkJLmxhc3QgPSAweDQyLAorCQkJfSwKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDQ0LAorCQkJCS5sYXN0ID0gMHg0NCwKKwkJCX0sCisJCQl7CisJCQkJLmZpcnN0ID0gMHg1MCwKKwkJCQkubGFzdCA9IDB4NTUsCisJCQl9LAorCQkJeworCQkJCS5maXJzdCA9IDB4ODAsCisJCQkJLmxhc3QgPSAweDgyLAorCQkJfSwKKwkJCXsKKwkJCQkuZmlyc3QgPSAweEMwLAorCQkJCS5sYXN0ID0gMHhDMiwKKwkJCX0sCisJCX0sCisJfSwKKwlbQUI4NTAwX0dBU19HQVVHRV0gPSB7CisJCS5udW1fcmFuZ2VzID0gMywKKwkJLnJhbmdlID0gKHN0cnVjdCBhYjg1MDBfcmVnX3JhbmdlW10pIHsKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDAwLAorCQkJCS5sYXN0ID0gMHgwMCwKKwkJCX0sCisJCQl7CisJCQkJLmZpcnN0ID0gMHgwNywKKwkJCQkubGFzdCA9IDB4MEEsCisJCQl9LAorCQkJeworCQkJCS5maXJzdCA9IDB4MTAsCisJCQkJLmxhc3QgPSAweDE0LAorCQkJfSwKKwkJfSwKKwl9LAorCVtBQjg1MDBfQVVESU9dID0geworCQkubnVtX3JhbmdlcyA9IDEsCisJCS5yYW5nZSA9IChzdHJ1Y3QgYWI4NTAwX3JlZ19yYW5nZVtdKSB7CisJCQl7CisJCQkJLmZpcnN0ID0gMHgwMCwKKwkJCQkubGFzdCA9IDB4NkYsCisJCQl9LAorCQl9LAorCX0sCisJW0FCODUwMF9JTlRFUlJVUFRdID0geworCQkubnVtX3JhbmdlcyA9IDAsCisJCS5yYW5nZSA9IE5VTEwsCisJfSwKKwlbQUI4NTAwX1JUQ10gPSB7CisJCS5udW1fcmFuZ2VzID0gMSwKKwkJLnJhbmdlID0gKHN0cnVjdCBhYjg1MDBfcmVnX3JhbmdlW10pIHsKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDAwLAorCQkJCS5sYXN0ID0gMHgwRiwKKwkJCX0sCisJCX0sCisJfSwKKwlbQUI4NTAwX01JU0NdID0geworCQkubnVtX3JhbmdlcyA9IDgsCisJCS5yYW5nZSA9IChzdHJ1Y3QgYWI4NTAwX3JlZ19yYW5nZVtdKSB7CisJCQl7CisJCQkJLmZpcnN0ID0gMHgwMCwKKwkJCQkubGFzdCA9IDB4MDUsCisJCQl9LAorCQkJeworCQkJCS5maXJzdCA9IDB4MTAsCisJCQkJLmxhc3QgPSAweDE1LAorCQkJfSwKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDIwLAorCQkJCS5sYXN0ID0gMHgyNSwKKwkJCX0sCisJCQl7CisJCQkJLmZpcnN0ID0gMHgzMCwKKwkJCQkubGFzdCA9IDB4MzUsCisJCQl9LAorCQkJeworCQkJCS5maXJzdCA9IDB4NDAsCisJCQkJLmxhc3QgPSAweDQ1LAorCQkJfSwKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDUwLAorCQkJCS5sYXN0ID0gMHg1MCwKKwkJCX0sCisJCQl7CisJCQkJLmZpcnN0ID0gMHg2MCwKKwkJCQkubGFzdCA9IDB4NjcsCisJCQl9LAorCQkJeworCQkJCS5maXJzdCA9IDB4ODAsCisJCQkJLmxhc3QgPSAweDgwLAorCQkJfSwKKwkJfSwKKwl9LAorCVsweDExXSA9IHsKKwkJLm51bV9yYW5nZXMgPSAwLAorCQkucmFuZ2UgPSBOVUxMLAorCX0sCisJWzB4MTJdID0geworCQkubnVtX3JhbmdlcyA9IDAsCisJCS5yYW5nZSA9IE5VTEwsCisJfSwKKwlbMHgxM10gPSB7CisJCS5udW1fcmFuZ2VzID0gMCwKKwkJLnJhbmdlID0gTlVMTCwKKwl9LAorCVsweDE0XSA9IHsKKwkJLm51bV9yYW5nZXMgPSAwLAorCQkucmFuZ2UgPSBOVUxMLAorCX0sCisJW0FCODUwMF9PVFBfRU1VTF0gPSB7CisJCS5udW1fcmFuZ2VzID0gMSwKKwkJLnJhbmdlID0gKHN0cnVjdCBhYjg1MDBfcmVnX3JhbmdlW10pIHsKKwkJCXsKKwkJCQkuZmlyc3QgPSAweDAxLAorCQkJCS5sYXN0ID0gMHgwRiwKKwkJCX0sCisJCX0sCisJfSwKIH07CiAKIHN0YXRpYyBpbnQgYWI4NTAwX3JlZ2lzdGVyc19wcmludChzdHJ1Y3Qgc2VxX2ZpbGUgKnMsIHZvaWQgKnApCiB7Ci0gICAgICAgc3RydWN0IGRldmljZSAqZGV2ID0gcy0+cHJpdmF0ZTsKLSAgICAgICB1bnNpZ25lZCBpbnQgaTsKLSAgICAgICB1MzIgYmFuayA9IGRlYnVnX2Jhbms7CisJc3RydWN0IGRldmljZSAqZGV2ID0gcy0+cHJpdmF0ZTsKKwl1bnNpZ25lZCBpbnQgaTsKKwl1MzIgYmFuayA9IGRlYnVnX2Jhbms7CiAKLSAgICAgICBzZXFfcHJpbnRmKHMsIEFCODUwMF9OQU1FX1NUUklORyAiIHJlZ2lzdGVyIHZhbHVlczpcbiIpOworCXNlcV9wcmludGYocywgQUI4NTAwX05BTUVfU1RSSU5HICIgcmVnaXN0ZXIgdmFsdWVzOlxuIik7CiAKLSAgICAgICBzZXFfcHJpbnRmKHMsICIgYmFuayAldTpcbiIsIGJhbmspOwotICAgICAgIGZvciAoaSA9IDA7IGkgPCBkZWJ1Z19yYW5nZXNbYmFua10ubnVtX3JhbmdlczsgaSsrKSB7Ci0gICAgICAgICAgICAgICB1MzIgcmVnOworCXNlcV9wcmludGYocywgIiBiYW5rICV1OlxuIiwgYmFuayk7CisJZm9yIChpID0gMDsgaSA8IGRlYnVnX3Jhbmdlc1tiYW5rXS5udW1fcmFuZ2VzOyBpKyspIHsKKwkJdTMyIHJlZzsKIAotICAgICAgICAgICAgICAgZm9yIChyZWcgPSBkZWJ1Z19yYW5nZXNbYmFua10ucmFuZ2VbaV0uZmlyc3Q7Ci0gICAgICAgICAgICAgICAgICAgICAgIHJlZyA8PSBkZWJ1Z19yYW5nZXNbYmFua10ucmFuZ2VbaV0ubGFzdDsKLSAgICAgICAgICAgICAgICAgICAgICAgcmVnKyspIHsKLSAgICAgICAgICAgICAgICAgICAgICAgdTggdmFsdWU7Ci0gICAgICAgICAgICAgICAgICAgICAgIGludCBlcnI7CisJCWZvciAocmVnID0gZGVidWdfcmFuZ2VzW2JhbmtdLnJhbmdlW2ldLmZpcnN0OworCQkJcmVnIDw9IGRlYnVnX3Jhbmdlc1tiYW5rXS5yYW5nZVtpXS5sYXN0OworCQkJcmVnKyspIHsKKwkJCXU4IHZhbHVlOworCQkJaW50IGVycjsKIAotICAgICAgICAgICAgICAgICAgICAgICBlcnIgPSBhYng1MDBfZ2V0X3JlZ2lzdGVyX2ludGVycnVwdGlibGUoZGV2LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICh1OCliYW5rLCAodTgpcmVnLCAmdmFsdWUpOwotICAgICAgICAgICAgICAgICAgICAgICBpZiAoZXJyIDwgMCkgewotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRldl9lcnIoZGV2LCAiYWItPnJlYWQgZmFpbCAlZFxuIiwgZXJyKTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gZXJyOwotICAgICAgICAgICAgICAgICAgICAgICB9CisJCQllcnIgPSBhYng1MDBfZ2V0X3JlZ2lzdGVyX2ludGVycnVwdGlibGUoZGV2LAorCQkJCSh1OCliYW5rLCAodTgpcmVnLCAmdmFsdWUpOworCQkJaWYgKGVyciA8IDApIHsKKwkJCQlkZXZfZXJyKGRldiwgImFiLT5yZWFkIGZhaWwgJWRcbiIsIGVycik7CisJCQkJcmV0dXJuIGVycjsKKwkJCX0KIAotICAgICAgICAgICAgICAgICAgICAgICBlcnIgPSBzZXFfcHJpbnRmKHMsICIgIFsldS8weCUwMlhdOiAweCUwMlhcbiIsIGJhbmssCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVnLCB2YWx1ZSk7Ci0gICAgICAgICAgICAgICAgICAgICAgIGlmIChlcnIgPCAwKSB7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGV2X2VycihkZXYsICJzZXFfcHJpbnRmIG92ZXJmbG93XG4iKTsKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiBFcnJvciBpcyBub3QgcmV0dXJuZWQgaGVyZSBzaW5jZQotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqIHRoZSBvdXRwdXQgaXMgd2FudGVkIGluIGFueSBjYXNlICovCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIDA7Ci0gICAgICAgICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAgIH0KLSAgICAgICB9Ci0gICAgICAgcmV0dXJuIDA7CisJCQllcnIgPSBzZXFfcHJpbnRmKHMsICIgIFsldS8weCUwMlhdOiAweCUwMlhcbiIsIGJhbmssCisJCQkJcmVnLCB2YWx1ZSk7CisJCQlpZiAoZXJyIDwgMCkgeworCQkJCWRldl9lcnIoZGV2LCAic2VxX3ByaW50ZiBvdmVyZmxvd1xuIik7CisJCQkJLyogRXJyb3IgaXMgbm90IHJldHVybmVkIGhlcmUgc2luY2UKKwkJCQkgKiB0aGUgb3V0cHV0IGlzIHdhbnRlZCBpbiBhbnkgY2FzZSAqLworCQkJCXJldHVybiAwOworCQkJfQorCQl9CisJfQorCXJldHVybiAwOwogfQogCiBzdGF0aWMgaW50IGFiODUwMF9yZWdpc3RlcnNfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKIHsKLSAgICAgICByZXR1cm4gc2luZ2xlX29wZW4oZmlsZSwgYWI4NTAwX3JlZ2lzdGVyc19wcmludCwgaW5vZGUtPmlfcHJpdmF0ZSk7CisJcmV0dXJuIHNpbmdsZV9vcGVuKGZpbGUsIGFiODUwMF9yZWdpc3RlcnNfcHJpbnQsIGlub2RlLT5pX3ByaXZhdGUpOwogfQogCiBzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBhYjg1MDBfcmVnaXN0ZXJzX2ZvcHMgPSB7Ci0gICAgICAgLm9wZW4gPSBhYjg1MDBfcmVnaXN0ZXJzX29wZW4sCi0gICAgICAgLnJlYWQgPSBzZXFfcmVhZCwKLSAgICAgICAubGxzZWVrID0gc2VxX2xzZWVrLAotICAgICAgIC5yZWxlYXNlID0gc2luZ2xlX3JlbGVhc2UsCi0gICAgICAgLm93bmVyID0gVEhJU19NT0RVTEUsCisJLm9wZW4gPSBhYjg1MDBfcmVnaXN0ZXJzX29wZW4sCisJLnJlYWQgPSBzZXFfcmVhZCwKKwkubGxzZWVrID0gc2VxX2xzZWVrLAorCS5yZWxlYXNlID0gc2luZ2xlX3JlbGVhc2UsCisJLm93bmVyID0gVEhJU19NT0RVTEUsCiB9OwogCiBzdGF0aWMgaW50IGFiODUwMF9iYW5rX3ByaW50KHN0cnVjdCBzZXFfZmlsZSAqcywgdm9pZCAqcCkKIHsKLSAgICAgICByZXR1cm4gc2VxX3ByaW50ZihzLCAiJWRcbiIsIGRlYnVnX2JhbmspOworCXJldHVybiBzZXFfcHJpbnRmKHMsICIlZFxuIiwgZGVidWdfYmFuayk7CiB9CiAKIHN0YXRpYyBpbnQgYWI4NTAwX2Jhbmtfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKIHsKLSAgICAgICByZXR1cm4gc2luZ2xlX29wZW4oZmlsZSwgYWI4NTAwX2JhbmtfcHJpbnQsIGlub2RlLT5pX3ByaXZhdGUpOworCXJldHVybiBzaW5nbGVfb3BlbihmaWxlLCBhYjg1MDBfYmFua19wcmludCwgaW5vZGUtPmlfcHJpdmF0ZSk7CiB9CiAKIHN0YXRpYyBzc2l6ZV90IGFiODUwMF9iYW5rX3dyaXRlKHN0cnVjdCBmaWxlICpmaWxlLAotICAgICAgIGNvbnN0IGNoYXIgX191c2VyICp1c2VyX2J1ZiwKLSAgICAgICBzaXplX3QgY291bnQsIGxvZmZfdCAqcHBvcykKKwljb25zdCBjaGFyIF9fdXNlciAqdXNlcl9idWYsCisJc2l6ZV90IGNvdW50LCBsb2ZmX3QgKnBwb3MpCiB7Ci0gICAgICAgc3RydWN0IGRldmljZSAqZGV2ID0gKChzdHJ1Y3Qgc2VxX2ZpbGUgKikoZmlsZS0+cHJpdmF0ZV9kYXRhKSktPnByaXZhdGU7Ci0gICAgICAgY2hhciBidWZbMzJdOwotICAgICAgIGludCBidWZfc2l6ZTsKLSAgICAgICB1bnNpZ25lZCBsb25nIHVzZXJfYmFuazsKLSAgICAgICBpbnQgZXJyOworCXN0cnVjdCBkZXZpY2UgKmRldiA9ICgoc3RydWN0IHNlcV9maWxlICopKGZpbGUtPnByaXZhdGVfZGF0YSkpLT5wcml2YXRlOworCWNoYXIgYnVmWzMyXTsKKwlpbnQgYnVmX3NpemU7CisJdW5zaWduZWQgbG9uZyB1c2VyX2Jhbms7CisJaW50IGVycjsKIAotICAgICAgIC8qIEdldCB1c2Vyc3BhY2Ugc3RyaW5nIGFuZCBhc3N1cmUgdGVybWluYXRpb24gKi8KLSAgICAgICBidWZfc2l6ZSA9IG1pbihjb3VudCwgKHNpemVvZihidWYpIC0gMSkpOwotICAgICAgIGlmIChjb3B5X2Zyb21fdXNlcihidWYsIHVzZXJfYnVmLCBidWZfc2l6ZSkpCi0gICAgICAgICAgICAgICByZXR1cm4gLUVGQVVMVDsKLSAgICAgICBidWZbYnVmX3NpemVdID0gMDsKKwkvKiBHZXQgdXNlcnNwYWNlIHN0cmluZyBhbmQgYXNzdXJlIHRlcm1pbmF0aW9uICovCisJYnVmX3NpemUgPSBtaW4oY291bnQsIChzaXplb2YoYnVmKSAtIDEpKTsKKwlpZiAoY29weV9mcm9tX3VzZXIoYnVmLCB1c2VyX2J1ZiwgYnVmX3NpemUpKQorCQlyZXR1cm4gLUVGQVVMVDsKKwlidWZbYnVmX3NpemVdID0gMDsKIAotICAgICAgIGVyciA9IHN0cmljdF9zdHJ0b3VsKGJ1ZiwgMCwgJnVzZXJfYmFuayk7Ci0gICAgICAgaWYgKGVycikKLSAgICAgICAgICAgICAgIHJldHVybiAtRUlOVkFMOworCWVyciA9IHN0cmljdF9zdHJ0b3VsKGJ1ZiwgMCwgJnVzZXJfYmFuayk7CisJaWYgKGVycikKKwkJcmV0dXJuIC1FSU5WQUw7CiAKLSAgICAgICBpZiAodXNlcl9iYW5rID49IEFCODUwMF9OVU1fQkFOS1MpIHsKLSAgICAgICAgICAgICAgIGRldl9lcnIoZGV2LCAiZGVidWdmcyBlcnJvciBpbnB1dCA+IG51bWJlciBvZiBiYW5rc1xuIik7Ci0gICAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsKLSAgICAgICB9CisJaWYgKHVzZXJfYmFuayA+PSBBQjg1MDBfTlVNX0JBTktTKSB7CisJCWRldl9lcnIoZGV2LCAiZGVidWdmcyBlcnJvciBpbnB1dCA+IG51bWJlciBvZiBiYW5rc1xuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KIAotICAgICAgIGRlYnVnX2JhbmsgPSB1c2VyX2Jhbms7CisJZGVidWdfYmFuayA9IHVzZXJfYmFuazsKIAotICAgICAgIHJldHVybiBidWZfc2l6ZTsKKwlyZXR1cm4gYnVmX3NpemU7CiB9CiAKIHN0YXRpYyBpbnQgYWI4NTAwX2FkZHJlc3NfcHJpbnQoc3RydWN0IHNlcV9maWxlICpzLCB2b2lkICpwKQogewotICAgICAgIHJldHVybiBzZXFfcHJpbnRmKHMsICIweCUwMlhcbiIsIGRlYnVnX2FkZHJlc3MpOworCXJldHVybiBzZXFfcHJpbnRmKHMsICIweCUwMlhcbiIsIGRlYnVnX2FkZHJlc3MpOwogfQogCiBzdGF0aWMgaW50IGFiODUwMF9hZGRyZXNzX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCiB7Ci0gICAgICAgcmV0dXJuIHNpbmdsZV9vcGVuKGZpbGUsIGFiODUwMF9hZGRyZXNzX3ByaW50LCBpbm9kZS0+aV9wcml2YXRlKTsKKwlyZXR1cm4gc2luZ2xlX29wZW4oZmlsZSwgYWI4NTAwX2FkZHJlc3NfcHJpbnQsIGlub2RlLT5pX3ByaXZhdGUpOwogfQogCiBzdGF0aWMgc3NpemVfdCBhYjg1MDBfYWRkcmVzc193cml0ZShzdHJ1Y3QgZmlsZSAqZmlsZSwKLSAgICAgICBjb25zdCBjaGFyIF9fdXNlciAqdXNlcl9idWYsCi0gICAgICAgc2l6ZV90IGNvdW50LCBsb2ZmX3QgKnBwb3MpCisJY29uc3QgY2hhciBfX3VzZXIgKnVzZXJfYnVmLAorCXNpemVfdCBjb3VudCwgbG9mZl90ICpwcG9zKQogewotICAgICAgIHN0cnVjdCBkZXZpY2UgKmRldiA9ICgoc3RydWN0IHNlcV9maWxlICopKGZpbGUtPnByaXZhdGVfZGF0YSkpLT5wcml2YXRlOwotICAgICAgIGNoYXIgYnVmWzMyXTsKLSAgICAgICBpbnQgYnVmX3NpemU7Ci0gICAgICAgdW5zaWduZWQgbG9uZyB1c2VyX2FkZHJlc3M7Ci0gICAgICAgaW50IGVycjsKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAoKHN0cnVjdCBzZXFfZmlsZSAqKShmaWxlLT5wcml2YXRlX2RhdGEpKS0+cHJpdmF0ZTsKKwljaGFyIGJ1ZlszMl07CisJaW50IGJ1Zl9zaXplOworCXVuc2lnbmVkIGxvbmcgdXNlcl9hZGRyZXNzOworCWludCBlcnI7CiAKLSAgICAgICAvKiBHZXQgdXNlcnNwYWNlIHN0cmluZyBhbmQgYXNzdXJlIHRlcm1pbmF0aW9uICovCi0gICAgICAgYnVmX3NpemUgPSBtaW4oY291bnQsIChzaXplb2YoYnVmKSAtIDEpKTsKLSAgICAgICBpZiAoY29weV9mcm9tX3VzZXIoYnVmLCB1c2VyX2J1ZiwgYnVmX3NpemUpKQotICAgICAgICAgICAgICAgcmV0dXJuIC1FRkFVTFQ7Ci0gICAgICAgYnVmW2J1Zl9zaXplXSA9IDA7CisJLyogR2V0IHVzZXJzcGFjZSBzdHJpbmcgYW5kIGFzc3VyZSB0ZXJtaW5hdGlvbiAqLworCWJ1Zl9zaXplID0gbWluKGNvdW50LCAoc2l6ZW9mKGJ1ZikgLSAxKSk7CisJaWYgKGNvcHlfZnJvbV91c2VyKGJ1ZiwgdXNlcl9idWYsIGJ1Zl9zaXplKSkKKwkJcmV0dXJuIC1FRkFVTFQ7CisJYnVmW2J1Zl9zaXplXSA9IDA7CiAKLSAgICAgICBlcnIgPSBzdHJpY3Rfc3RydG91bChidWYsIDAsICZ1c2VyX2FkZHJlc3MpOwotICAgICAgIGlmIChlcnIpCi0gICAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsKLSAgICAgICBpZiAodXNlcl9hZGRyZXNzID4gMHhmZikgewotICAgICAgICAgICAgICAgZGV2X2VycihkZXYsICJkZWJ1Z2ZzIGVycm9yIGlucHV0ID4gMHhmZlxuIik7Ci0gICAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsKLSAgICAgICB9Ci0gICAgICAgZGVidWdfYWRkcmVzcyA9IHVzZXJfYWRkcmVzczsKLSAgICAgICByZXR1cm4gYnVmX3NpemU7CisJZXJyID0gc3RyaWN0X3N0cnRvdWwoYnVmLCAwLCAmdXNlcl9hZGRyZXNzKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gLUVJTlZBTDsKKwlpZiAodXNlcl9hZGRyZXNzID4gMHhmZikgeworCQlkZXZfZXJyKGRldiwgImRlYnVnZnMgZXJyb3IgaW5wdXQgPiAweGZmXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWRlYnVnX2FkZHJlc3MgPSB1c2VyX2FkZHJlc3M7CisJcmV0dXJuIGJ1Zl9zaXplOwogfQogCiBzdGF0aWMgaW50IGFiODUwMF92YWxfcHJpbnQoc3RydWN0IHNlcV9maWxlICpzLCB2b2lkICpwKQogewotICAgICAgIHN0cnVjdCBkZXZpY2UgKmRldiA9IHMtPnByaXZhdGU7Ci0gICAgICAgaW50IHJldDsKLSAgICAgICB1OCByZWd2YWx1ZTsKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBzLT5wcml2YXRlOworCWludCByZXQ7CisJdTggcmVndmFsdWU7CiAKLSAgICAgICByZXQgPSBhYng1MDBfZ2V0X3JlZ2lzdGVyX2ludGVycnVwdGlibGUoZGV2LAotICAgICAgICAgICAgICAgKHU4KWRlYnVnX2JhbmssICh1OClkZWJ1Z19hZGRyZXNzLCAmcmVndmFsdWUpOwotICAgICAgIGlmIChyZXQgPCAwKSB7Ci0gICAgICAgICAgICAgICBkZXZfZXJyKGRldiwgImFieDUwMF9nZXRfcmVnIGZhaWwgJWQsICVkXG4iLAotICAgICAgICAgICAgICAgICAgICAgICByZXQsIF9fTElORV9fKTsKLSAgICAgICAgICAgICAgIHJldHVybiAtRUlOVkFMOwotICAgICAgIH0KLSAgICAgICBzZXFfcHJpbnRmKHMsICIweCUwMlhcbiIsIHJlZ3ZhbHVlKTsKKwlyZXQgPSBhYng1MDBfZ2V0X3JlZ2lzdGVyX2ludGVycnVwdGlibGUoZGV2LAorCQkodTgpZGVidWdfYmFuaywgKHU4KWRlYnVnX2FkZHJlc3MsICZyZWd2YWx1ZSk7CisJaWYgKHJldCA8IDApIHsKKwkJZGV2X2VycihkZXYsICJhYng1MDBfZ2V0X3JlZyBmYWlsICVkLCAlZFxuIiwKKwkJCXJldCwgX19MSU5FX18pOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJc2VxX3ByaW50ZihzLCAiMHglMDJYXG4iLCByZWd2YWx1ZSk7CiAKLSAgICAgICByZXR1cm4gMDsKKwlyZXR1cm4gMDsKIH0KIAogc3RhdGljIGludCBhYjg1MDBfdmFsX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCiB7Ci0gICAgICAgcmV0dXJuIHNpbmdsZV9vcGVuKGZpbGUsIGFiODUwMF92YWxfcHJpbnQsIGlub2RlLT5pX3ByaXZhdGUpOworCXJldHVybiBzaW5nbGVfb3BlbihmaWxlLCBhYjg1MDBfdmFsX3ByaW50LCBpbm9kZS0+aV9wcml2YXRlKTsKIH0KIAogc3RhdGljIHNzaXplX3QgYWI4NTAwX3ZhbF93cml0ZShzdHJ1Y3QgZmlsZSAqZmlsZSwKLSAgICAgICBjb25zdCBjaGFyIF9fdXNlciAqdXNlcl9idWYsCi0gICAgICAgc2l6ZV90IGNvdW50LCBsb2ZmX3QgKnBwb3MpCisJY29uc3QgY2hhciBfX3VzZXIgKnVzZXJfYnVmLAorCXNpemVfdCBjb3VudCwgbG9mZl90ICpwcG9zKQogewotICAgICAgIHN0cnVjdCBkZXZpY2UgKmRldiA9ICgoc3RydWN0IHNlcV9maWxlICopKGZpbGUtPnByaXZhdGVfZGF0YSkpLT5wcml2YXRlOwotICAgICAgIGNoYXIgYnVmWzMyXTsKLSAgICAgICBpbnQgYnVmX3NpemU7Ci0gICAgICAgdW5zaWduZWQgbG9uZyB1c2VyX3ZhbDsKLSAgICAgICBpbnQgZXJyOworCXN0cnVjdCBkZXZpY2UgKmRldiA9ICgoc3RydWN0IHNlcV9maWxlICopKGZpbGUtPnByaXZhdGVfZGF0YSkpLT5wcml2YXRlOworCWNoYXIgYnVmWzMyXTsKKwlpbnQgYnVmX3NpemU7CisJdW5zaWduZWQgbG9uZyB1c2VyX3ZhbDsKKwlpbnQgZXJyOwogCi0gICAgICAgLyogR2V0IHVzZXJzcGFjZSBzdHJpbmcgYW5kIGFzc3VyZSB0ZXJtaW5hdGlvbiAqLwotICAgICAgIGJ1Zl9zaXplID0gbWluKGNvdW50LCAoc2l6ZW9mKGJ1ZiktMSkpOwotICAgICAgIGlmIChjb3B5X2Zyb21fdXNlcihidWYsIHVzZXJfYnVmLCBidWZfc2l6ZSkpCi0gICAgICAgICAgICAgICByZXR1cm4gLUVGQVVMVDsKLSAgICAgICBidWZbYnVmX3NpemVdID0gMDsKKwkvKiBHZXQgdXNlcnNwYWNlIHN0cmluZyBhbmQgYXNzdXJlIHRlcm1pbmF0aW9uICovCisJYnVmX3NpemUgPSBtaW4oY291bnQsIChzaXplb2YoYnVmKS0xKSk7CisJaWYgKGNvcHlfZnJvbV91c2VyKGJ1ZiwgdXNlcl9idWYsIGJ1Zl9zaXplKSkKKwkJcmV0dXJuIC1FRkFVTFQ7CisJYnVmW2J1Zl9zaXplXSA9IDA7CiAKLSAgICAgICBlcnIgPSBzdHJpY3Rfc3RydG91bChidWYsIDAsICZ1c2VyX3ZhbCk7Ci0gICAgICAgaWYgKGVycikKLSAgICAgICAgICAgICAgIHJldHVybiAtRUlOVkFMOwotICAgICAgIGlmICh1c2VyX3ZhbCA+IDB4ZmYpIHsKLSAgICAgICAgICAgICAgIGRldl9lcnIoZGV2LCAiZGVidWdmcyBlcnJvciBpbnB1dCA+IDB4ZmZcbiIpOwotICAgICAgICAgICAgICAgcmV0dXJuIC1FSU5WQUw7Ci0gICAgICAgfQotICAgICAgIGVyciA9IGFieDUwMF9zZXRfcmVnaXN0ZXJfaW50ZXJydXB0aWJsZShkZXYsCi0gICAgICAgICAgICAgICAodTgpZGVidWdfYmFuaywgZGVidWdfYWRkcmVzcywgKHU4KXVzZXJfdmFsKTsKLSAgICAgICBpZiAoZXJyIDwgMCkgewotICAgICAgICAgICAgICAgcHJpbnRrKEtFUk5fRVJSICJhYng1MDBfc2V0X3JlZyBmYWlsZWQgJWQsICVkIiwgZXJyLCBfX0xJTkVfXyk7Ci0gICAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsKLSAgICAgICB9CisJZXJyID0gc3RyaWN0X3N0cnRvdWwoYnVmLCAwLCAmdXNlcl92YWwpOworCWlmIChlcnIpCisJCXJldHVybiAtRUlOVkFMOworCWlmICh1c2VyX3ZhbCA+IDB4ZmYpIHsKKwkJZGV2X2VycihkZXYsICJkZWJ1Z2ZzIGVycm9yIGlucHV0ID4gMHhmZlxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwllcnIgPSBhYng1MDBfc2V0X3JlZ2lzdGVyX2ludGVycnVwdGlibGUoZGV2LAorCQkodTgpZGVidWdfYmFuaywgZGVidWdfYWRkcmVzcywgKHU4KXVzZXJfdmFsKTsKKwlpZiAoZXJyIDwgMCkgeworCQlwcmludGsoS0VSTl9FUlIgImFieDUwMF9zZXRfcmVnIGZhaWxlZCAlZCwgJWQiLCBlcnIsIF9fTElORV9fKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQogCi0gICAgICAgcmV0dXJuIGJ1Zl9zaXplOworCXJldHVybiBidWZfc2l6ZTsKIH0KIAogc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgYWI4NTAwX2JhbmtfZm9wcyA9IHsKLSAgICAgICAub3BlbiA9IGFiODUwMF9iYW5rX29wZW4sCi0gICAgICAgLndyaXRlID0gYWI4NTAwX2Jhbmtfd3JpdGUsCi0gICAgICAgLnJlYWQgPSBzZXFfcmVhZCwKLSAgICAgICAubGxzZWVrID0gc2VxX2xzZWVrLAotICAgICAgIC5yZWxlYXNlID0gc2luZ2xlX3JlbGVhc2UsCi0gICAgICAgLm93bmVyID0gVEhJU19NT0RVTEUsCisJLm9wZW4gPSBhYjg1MDBfYmFua19vcGVuLAorCS53cml0ZSA9IGFiODUwMF9iYW5rX3dyaXRlLAorCS5yZWFkID0gc2VxX3JlYWQsCisJLmxsc2VlayA9IHNlcV9sc2VlaywKKwkucmVsZWFzZSA9IHNpbmdsZV9yZWxlYXNlLAorCS5vd25lciA9IFRISVNfTU9EVUxFLAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgYWI4NTAwX2FkZHJlc3NfZm9wcyA9IHsKLSAgICAgICAub3BlbiA9IGFiODUwMF9hZGRyZXNzX29wZW4sCi0gICAgICAgLndyaXRlID0gYWI4NTAwX2FkZHJlc3Nfd3JpdGUsCi0gICAgICAgLnJlYWQgPSBzZXFfcmVhZCwKLSAgICAgICAubGxzZWVrID0gc2VxX2xzZWVrLAotICAgICAgIC5yZWxlYXNlID0gc2luZ2xlX3JlbGVhc2UsCi0gICAgICAgLm93bmVyID0gVEhJU19NT0RVTEUsCisJLm9wZW4gPSBhYjg1MDBfYWRkcmVzc19vcGVuLAorCS53cml0ZSA9IGFiODUwMF9hZGRyZXNzX3dyaXRlLAorCS5yZWFkID0gc2VxX3JlYWQsCisJLmxsc2VlayA9IHNlcV9sc2VlaywKKwkucmVsZWFzZSA9IHNpbmdsZV9yZWxlYXNlLAorCS5vd25lciA9IFRISVNfTU9EVUxFLAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgYWI4NTAwX3ZhbF9mb3BzID0gewotICAgICAgIC5vcGVuID0gYWI4NTAwX3ZhbF9vcGVuLAotICAgICAgIC53cml0ZSA9IGFiODUwMF92YWxfd3JpdGUsCi0gICAgICAgLnJlYWQgPSBzZXFfcmVhZCwKLSAgICAgICAubGxzZWVrID0gc2VxX2xzZWVrLAotICAgICAgIC5yZWxlYXNlID0gc2luZ2xlX3JlbGVhc2UsCi0gICAgICAgLm93bmVyID0gVEhJU19NT0RVTEUsCisJLm9wZW4gPSBhYjg1MDBfdmFsX29wZW4sCisJLndyaXRlID0gYWI4NTAwX3ZhbF93cml0ZSwKKwkucmVhZCA9IHNlcV9yZWFkLAorCS5sbHNlZWsgPSBzZXFfbHNlZWssCisJLnJlbGVhc2UgPSBzaW5nbGVfcmVsZWFzZSwKKwkub3duZXIgPSBUSElTX01PRFVMRSwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgZGVudHJ5ICphYjg1MDBfZGlyOwpAQCAtNTcyLDc3ICs1NzIsNzcgQEAKIAogc3RhdGljIGludCBfX2RldmluaXQgYWI4NTAwX2RlYnVnX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBsZikKIHsKLSAgICAgICBkZWJ1Z19iYW5rID0gQUI4NTAwX01JU0M7Ci0gICAgICAgZGVidWdfYWRkcmVzcyA9IEFCODUwMF9SRVZfUkVHICYgMHgwMEZGOworCWRlYnVnX2JhbmsgPSBBQjg1MDBfTUlTQzsKKwlkZWJ1Z19hZGRyZXNzID0gQUI4NTAwX1JFVl9SRUcgJiAweDAwRkY7CiAKLSAgICAgICBhYjg1MDBfZGlyID0gZGVidWdmc19jcmVhdGVfZGlyKEFCODUwMF9OQU1FX1NUUklORywgTlVMTCk7Ci0gICAgICAgaWYgKCFhYjg1MDBfZGlyKQotICAgICAgICAgICAgICAgZ290byBleGl0X25vX2RlYnVnZnM7CisJYWI4NTAwX2RpciA9IGRlYnVnZnNfY3JlYXRlX2RpcihBQjg1MDBfTkFNRV9TVFJJTkcsIE5VTEwpOworCWlmICghYWI4NTAwX2RpcikKKwkJZ290byBleGl0X25vX2RlYnVnZnM7CiAKLSAgICAgICBhYjg1MDBfcmVnX2ZpbGUgPSBkZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJhbGwtYmFuay1yZWdpc3RlcnMiLAotICAgICAgICAgICAgICAgU19JUlVHTywgYWI4NTAwX2RpciwgJnBsZi0+ZGV2LCAmYWI4NTAwX3JlZ2lzdGVyc19mb3BzKTsKLSAgICAgICBpZiAoIWFiODUwMF9yZWdfZmlsZSkKLSAgICAgICAgICAgICAgIGdvdG8gZXhpdF9kZXN0cm95X2RpcjsKKwlhYjg1MDBfcmVnX2ZpbGUgPSBkZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJhbGwtYmFuay1yZWdpc3RlcnMiLAorCQlTX0lSVUdPLCBhYjg1MDBfZGlyLCAmcGxmLT5kZXYsICZhYjg1MDBfcmVnaXN0ZXJzX2ZvcHMpOworCWlmICghYWI4NTAwX3JlZ19maWxlKQorCQlnb3RvIGV4aXRfZGVzdHJveV9kaXI7CiAKLSAgICAgICBhYjg1MDBfYmFua19maWxlID0gZGVidWdmc19jcmVhdGVfZmlsZSgicmVnaXN0ZXItYmFuayIsCi0gICAgICAgICAgICAgICAoU19JUlVHTyB8IFNfSVdVR08pLCBhYjg1MDBfZGlyLCAmcGxmLT5kZXYsICZhYjg1MDBfYmFua19mb3BzKTsKLSAgICAgICBpZiAoIWFiODUwMF9iYW5rX2ZpbGUpCi0gICAgICAgICAgICAgICBnb3RvIGV4aXRfZGVzdHJveV9yZWc7CisJYWI4NTAwX2JhbmtfZmlsZSA9IGRlYnVnZnNfY3JlYXRlX2ZpbGUoInJlZ2lzdGVyLWJhbmsiLAorCQkoU19JUlVHTyB8IFNfSVdVR08pLCBhYjg1MDBfZGlyLCAmcGxmLT5kZXYsICZhYjg1MDBfYmFua19mb3BzKTsKKwlpZiAoIWFiODUwMF9iYW5rX2ZpbGUpCisJCWdvdG8gZXhpdF9kZXN0cm95X3JlZzsKIAotICAgICAgIGFiODUwMF9hZGRyZXNzX2ZpbGUgPSBkZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJyZWdpc3Rlci1hZGRyZXNzIiwKLSAgICAgICAgICAgICAgIChTX0lSVUdPIHwgU19JV1VHTyksIGFiODUwMF9kaXIsICZwbGYtPmRldiwKLSAgICAgICAgICAgICAgICZhYjg1MDBfYWRkcmVzc19mb3BzKTsKLSAgICAgICBpZiAoIWFiODUwMF9hZGRyZXNzX2ZpbGUpCi0gICAgICAgICAgICAgICBnb3RvIGV4aXRfZGVzdHJveV9iYW5rOworCWFiODUwMF9hZGRyZXNzX2ZpbGUgPSBkZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJyZWdpc3Rlci1hZGRyZXNzIiwKKwkJKFNfSVJVR08gfCBTX0lXVUdPKSwgYWI4NTAwX2RpciwgJnBsZi0+ZGV2LAorCQkmYWI4NTAwX2FkZHJlc3NfZm9wcyk7CisJaWYgKCFhYjg1MDBfYWRkcmVzc19maWxlKQorCQlnb3RvIGV4aXRfZGVzdHJveV9iYW5rOwogCi0gICAgICAgYWI4NTAwX3ZhbF9maWxlID0gZGVidWdmc19jcmVhdGVfZmlsZSgicmVnaXN0ZXItdmFsdWUiLAotICAgICAgICAgICAgICAgKFNfSVJVR08gfCBTX0lXVUdPKSwgYWI4NTAwX2RpciwgJnBsZi0+ZGV2LCAmYWI4NTAwX3ZhbF9mb3BzKTsKLSAgICAgICBpZiAoIWFiODUwMF92YWxfZmlsZSkKLSAgICAgICAgICAgICAgIGdvdG8gZXhpdF9kZXN0cm95X2FkZHJlc3M7CisJYWI4NTAwX3ZhbF9maWxlID0gZGVidWdmc19jcmVhdGVfZmlsZSgicmVnaXN0ZXItdmFsdWUiLAorCQkoU19JUlVHTyB8IFNfSVdVR08pLCBhYjg1MDBfZGlyLCAmcGxmLT5kZXYsICZhYjg1MDBfdmFsX2ZvcHMpOworCWlmICghYWI4NTAwX3ZhbF9maWxlKQorCQlnb3RvIGV4aXRfZGVzdHJveV9hZGRyZXNzOwogCi0gICAgICAgcmV0dXJuIDA7CisJcmV0dXJuIDA7CiAKIGV4aXRfZGVzdHJveV9hZGRyZXNzOgotICAgICAgIGRlYnVnZnNfcmVtb3ZlKGFiODUwMF9hZGRyZXNzX2ZpbGUpOworCWRlYnVnZnNfcmVtb3ZlKGFiODUwMF9hZGRyZXNzX2ZpbGUpOwogZXhpdF9kZXN0cm95X2Jhbms6Ci0gICAgICAgZGVidWdmc19yZW1vdmUoYWI4NTAwX2JhbmtfZmlsZSk7CisJZGVidWdmc19yZW1vdmUoYWI4NTAwX2JhbmtfZmlsZSk7CiBleGl0X2Rlc3Ryb3lfcmVnOgotICAgICAgIGRlYnVnZnNfcmVtb3ZlKGFiODUwMF9yZWdfZmlsZSk7CisJZGVidWdmc19yZW1vdmUoYWI4NTAwX3JlZ19maWxlKTsKIGV4aXRfZGVzdHJveV9kaXI6Ci0gICAgICAgZGVidWdmc19yZW1vdmUoYWI4NTAwX2Rpcik7CisJZGVidWdmc19yZW1vdmUoYWI4NTAwX2Rpcik7CiBleGl0X25vX2RlYnVnZnM6Ci0gICAgICAgZGV2X2VycigmcGxmLT5kZXYsICJmYWlsZWQgdG8gY3JlYXRlIGRlYnVnZnMgZW50cmllcy5cbiIpOwotICAgICAgIHJldHVybiAtRU5PTUVNOworCWRldl9lcnIoJnBsZi0+ZGV2LCAiZmFpbGVkIHRvIGNyZWF0ZSBkZWJ1Z2ZzIGVudHJpZXMuXG4iKTsKKwlyZXR1cm4gLUVOT01FTTsKIH0KIAogc3RhdGljIGludCBfX2RldmV4aXQgYWI4NTAwX2RlYnVnX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwbGYpCiB7Ci0gICAgICAgZGVidWdmc19yZW1vdmUoYWI4NTAwX3ZhbF9maWxlKTsKLSAgICAgICBkZWJ1Z2ZzX3JlbW92ZShhYjg1MDBfYWRkcmVzc19maWxlKTsKLSAgICAgICBkZWJ1Z2ZzX3JlbW92ZShhYjg1MDBfYmFua19maWxlKTsKLSAgICAgICBkZWJ1Z2ZzX3JlbW92ZShhYjg1MDBfcmVnX2ZpbGUpOwotICAgICAgIGRlYnVnZnNfcmVtb3ZlKGFiODUwMF9kaXIpOworCWRlYnVnZnNfcmVtb3ZlKGFiODUwMF92YWxfZmlsZSk7CisJZGVidWdmc19yZW1vdmUoYWI4NTAwX2FkZHJlc3NfZmlsZSk7CisJZGVidWdmc19yZW1vdmUoYWI4NTAwX2JhbmtfZmlsZSk7CisJZGVidWdmc19yZW1vdmUoYWI4NTAwX3JlZ19maWxlKTsKKwlkZWJ1Z2ZzX3JlbW92ZShhYjg1MDBfZGlyKTsKIAotICAgICAgIHJldHVybiAwOworCXJldHVybiAwOwogfQogCiBzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBhYjg1MDBfZGVidWdfZHJpdmVyID0gewotICAgICAgIC5kcml2ZXIgPSB7Ci0gICAgICAgICAgICAgICAubmFtZSA9ICJhYjg1MDAtZGVidWciLAotICAgICAgICAgICAgICAgLm93bmVyID0gVEhJU19NT0RVTEUsCi0gICAgICAgfSwKLSAgICAgICAucHJvYmUgID0gYWI4NTAwX2RlYnVnX3Byb2JlLAotICAgICAgIC5yZW1vdmUgPSBfX2RldmV4aXRfcChhYjg1MDBfZGVidWdfcmVtb3ZlKQorCS5kcml2ZXIgPSB7CisJCS5uYW1lID0gImFiODUwMC1kZWJ1ZyIsCisJCS5vd25lciA9IFRISVNfTU9EVUxFLAorCX0sCisJLnByb2JlICA9IGFiODUwMF9kZWJ1Z19wcm9iZSwKKwkucmVtb3ZlID0gX19kZXZleGl0X3AoYWI4NTAwX2RlYnVnX3JlbW92ZSkKIH07CiAKIHN0YXRpYyBpbnQgX19pbml0IGFiODUwMF9kZWJ1Z19pbml0KHZvaWQpCiB7Ci0gICAgICAgcmV0dXJuIHBsYXRmb3JtX2RyaXZlcl9yZWdpc3RlcigmYWI4NTAwX2RlYnVnX2RyaXZlcik7CisJcmV0dXJuIHBsYXRmb3JtX2RyaXZlcl9yZWdpc3RlcigmYWI4NTAwX2RlYnVnX2RyaXZlcik7CiB9CiAKIHN0YXRpYyB2b2lkIF9fZXhpdCBhYjg1MDBfZGVidWdfZXhpdCh2b2lkKQogewotICAgICAgIHBsYXRmb3JtX2RyaXZlcl91bnJlZ2lzdGVyKCZhYjg1MDBfZGVidWdfZHJpdmVyKTsKKwlwbGF0Zm9ybV9kcml2ZXJfdW5yZWdpc3RlcigmYWI4NTAwX2RlYnVnX2RyaXZlcik7CiB9CiBzdWJzeXNfaW5pdGNhbGwoYWI4NTAwX2RlYnVnX2luaXQpOwogbW9kdWxlX2V4aXQoYWI4NTAwX2RlYnVnX2V4aXQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvYWI4NTAwLXNwaS5jIGIvZHJpdmVycy9tZmQvYWI4NTAwLXNwaS5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiMTY1MzQyLi4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvbWZkL2FiODUwMC1zcGkuYworKysgL2Rldi9udWxsCkBAIC0xLDE0MyArMCwwIEBACi0vKgotICogQ29weXJpZ2h0IChDKSBTVC1Fcmljc3NvbiBTQSAyMDEwCi0gKgotICogTGljZW5zZSBUZXJtczogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdjIKLSAqIEF1dGhvcjogU3JpbmlkaGkgS2FzYWdhciA8c3JpbmlkaGkua2FzYWdhckBzdGVyaWNzc29uLmNvbT4KLSAqLwotCi0jaW5jbHVkZSA8bGludXgva2VybmVsLmg+Ci0jaW5jbHVkZSA8bGludXgvc2xhYi5oPgotI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KLSNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KLSNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KLSNpbmNsdWRlIDxsaW51eC9zcGkvc3BpLmg+Ci0jaW5jbHVkZSA8bGludXgvbWZkL2FiODUwMC5oPgotCi0vKgotICogVGhpcyBmdW50aW9uIHdyaXRlcyB0byBhbnkgQUI4NTAwIHJlZ2lzdGVycyB1c2luZwotICogU1BJIHByb3RvY29sICYgIGJlZm9yZSBpdCB3cml0ZXMgaXQgcGFja3MgdGhlIGRhdGEKLSAqIGluIHRoZSBiZWxvdyAyNCBiaXQgZnJhbWUgZm9ybWF0Ci0gKgotICoJICp8LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tfAotICoJICp8IDIzfDIyLi4uMTh8MTcuLi4uLi4uMTB8OXw4fDcuLi4uLi4wfAotICoJICp8IHIvdyAgYmFuayAgICAgICBhZHIgICAgICAgICAgZGF0YSAgfAotICoJICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gKgotICogVGhpcyBmdW5jdGlvbiBzaG91bGRuJ3QgYmUgY2FsbGVkIGZyb20gaW50ZXJydXB0Ci0gKiBjb250ZXh0Ci0gKi8KLXN0YXRpYyBpbnQgYWI4NTAwX3NwaV93cml0ZShzdHJ1Y3QgYWI4NTAwICphYjg1MDAsIHUxNiBhZGRyLCB1OCBkYXRhKQotewotCXN0cnVjdCBzcGlfZGV2aWNlICpzcGkgPSBjb250YWluZXJfb2YoYWI4NTAwLT5kZXYsIHN0cnVjdCBzcGlfZGV2aWNlLAotCQkJCQkgICAgICBkZXYpOwotCXVuc2lnbmVkIGxvbmcgc3BpX2RhdGEgPSBhZGRyIDw8IDEwIHwgZGF0YTsKLQlzdHJ1Y3Qgc3BpX3RyYW5zZmVyIHhmZXI7Ci0Jc3RydWN0IHNwaV9tZXNzYWdlIG1zZzsKLQotCWFiODUwMC0+dHhfYnVmWzBdID0gc3BpX2RhdGE7Ci0JYWI4NTAwLT5yeF9idWZbMF0gPSAwOwotCi0JeGZlci50eF9idWYJPSBhYjg1MDAtPnR4X2J1ZjsKLQl4ZmVyLnJ4X2J1Zgk9IE5VTEw7Ci0JeGZlci5sZW4JPSBzaXplb2YodW5zaWduZWQgbG9uZyk7Ci0KLQlzcGlfbWVzc2FnZV9pbml0KCZtc2cpOwotCXNwaV9tZXNzYWdlX2FkZF90YWlsKCZ4ZmVyLCAmbXNnKTsKLQotCXJldHVybiBzcGlfc3luYyhzcGksICZtc2cpOwotfQotCi1zdGF0aWMgaW50IGFiODUwMF9zcGlfcmVhZChzdHJ1Y3QgYWI4NTAwICphYjg1MDAsIHUxNiBhZGRyKQotewotCXN0cnVjdCBzcGlfZGV2aWNlICpzcGkgPSBjb250YWluZXJfb2YoYWI4NTAwLT5kZXYsIHN0cnVjdCBzcGlfZGV2aWNlLAotCQkJCQkgICAgICBkZXYpOwotCXVuc2lnbmVkIGxvbmcgc3BpX2RhdGEgPSAxIDw8IDIzIHwgYWRkciA8PCAxMDsKLQlzdHJ1Y3Qgc3BpX3RyYW5zZmVyIHhmZXI7Ci0Jc3RydWN0IHNwaV9tZXNzYWdlIG1zZzsKLQlpbnQgcmV0OwotCi0JYWI4NTAwLT50eF9idWZbMF0gPSBzcGlfZGF0YTsKLQlhYjg1MDAtPnJ4X2J1ZlswXSA9IDA7Ci0KLQl4ZmVyLnR4X2J1Zgk9IGFiODUwMC0+dHhfYnVmOwotCXhmZXIucnhfYnVmCT0gYWI4NTAwLT5yeF9idWY7Ci0JeGZlci5sZW4JPSBzaXplb2YodW5zaWduZWQgbG9uZyk7Ci0KLQlzcGlfbWVzc2FnZV9pbml0KCZtc2cpOwotCXNwaV9tZXNzYWdlX2FkZF90YWlsKCZ4ZmVyLCAmbXNnKTsKLQotCXJldCA9IHNwaV9zeW5jKHNwaSwgJm1zZyk7Ci0JaWYgKCFyZXQpCi0JCS8qCi0JCSAqIE9ubHkgdGhlIDggbG93ZXJtb3N0IGJ5dGVzIGFyZQotCQkgKiBkZWZpbmVkIHdpdGggdmFsdWUsIHRoZSByZXN0IG1heQotCQkgKiB2YXJ5IGRlcGVuZGluZyBvbiBjaGlwL2JvYXJkIG5vaXNlLgotCQkgKi8KLQkJcmV0ID0gYWI4NTAwLT5yeF9idWZbMF0gJiAweEZGVTsKLQotCXJldHVybiByZXQ7Ci19Ci0KLXN0YXRpYyBpbnQgX19kZXZpbml0IGFiODUwMF9zcGlfcHJvYmUoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKLXsKLQlzdHJ1Y3QgYWI4NTAwICphYjg1MDA7Ci0JaW50IHJldDsKLQotCXNwaS0+Yml0c19wZXJfd29yZCA9IDI0OwotCXJldCA9IHNwaV9zZXR1cChzcGkpOwotCWlmIChyZXQgPCAwKQotCQlyZXR1cm4gcmV0OwotCi0JYWI4NTAwID0ga3phbGxvYyhzaXplb2YgKmFiODUwMCwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFhYjg1MDApCi0JCXJldHVybiAtRU5PTUVNOwotCi0JYWI4NTAwLT5kZXYgPSAmc3BpLT5kZXY7Ci0JYWI4NTAwLT5pcnEgPSBzcGktPmlycTsKLQotCWFiODUwMC0+cmVhZCA9IGFiODUwMF9zcGlfcmVhZDsKLQlhYjg1MDAtPndyaXRlID0gYWI4NTAwX3NwaV93cml0ZTsKLQotCXNwaV9zZXRfZHJ2ZGF0YShzcGksIGFiODUwMCk7Ci0KLQlyZXQgPSBhYjg1MDBfaW5pdChhYjg1MDApOwotCWlmIChyZXQpCi0JCWtmcmVlKGFiODUwMCk7Ci0KLQlyZXR1cm4gcmV0OwotfQotCi1zdGF0aWMgaW50IF9fZGV2ZXhpdCBhYjg1MDBfc3BpX3JlbW92ZShzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpKQotewotCXN0cnVjdCBhYjg1MDAgKmFiODUwMCA9IHNwaV9nZXRfZHJ2ZGF0YShzcGkpOwotCi0JYWI4NTAwX2V4aXQoYWI4NTAwKTsKLQlrZnJlZShhYjg1MDApOwotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBzdHJ1Y3Qgc3BpX2RyaXZlciBhYjg1MDBfc3BpX2RyaXZlciA9IHsKLQkuZHJpdmVyID0gewotCQkubmFtZSA9ICJhYjg1MDAtc3BpIiwKLQkJLm93bmVyID0gVEhJU19NT0RVTEUsCi0JfSwKLQkucHJvYmUJPSBhYjg1MDBfc3BpX3Byb2JlLAotCS5yZW1vdmUJPSBfX2RldmV4aXRfcChhYjg1MDBfc3BpX3JlbW92ZSkKLX07Ci0KLXN0YXRpYyBpbnQgX19pbml0IGFiODUwMF9zcGlfaW5pdCh2b2lkKQotewotCXJldHVybiBzcGlfcmVnaXN0ZXJfZHJpdmVyKCZhYjg1MDBfc3BpX2RyaXZlcik7Ci19Ci1zdWJzeXNfaW5pdGNhbGwoYWI4NTAwX3NwaV9pbml0KTsKLQotc3RhdGljIHZvaWQgX19leGl0IGFiODUwMF9zcGlfZXhpdCh2b2lkKQotewotCXNwaV91bnJlZ2lzdGVyX2RyaXZlcigmYWI4NTAwX3NwaV9kcml2ZXIpOwotfQotbW9kdWxlX2V4aXQoYWI4NTAwX3NwaV9leGl0KTsKLQotTU9EVUxFX0FVVEhPUigiU3JpbmlkaGkgS0FTQUdBUiA8c3JpbmlkaGkua2FzYWdhckBzdGVyaWNzc29uLmNvbSIpOwotTU9EVUxFX0RFU0NSSVBUSU9OKCJBQjg1MDAgU1BJIik7Ci1NT0RVTEVfTElDRU5TRSgiR1BMIHYyIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC9hc2ljMy5jIGIvZHJpdmVycy9tZmQvYXNpYzMuYwppbmRleCA3ZGU3MDhkLi42YTFmOTQwIDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC9hc2ljMy5jCisrKyBiL2RyaXZlcnMvbWZkL2FzaWMzLmMKQEAgLTU3LDcgKzU3LDcgQEAKIAkJLnJhdGUgPSBfcmF0ZSwJCQlcCiAJfQogCi1zdHJ1Y3QgYXNpYzNfY2xrIGFzaWMzX2Nsa19pbml0W10gX19pbml0ZGF0YSA9IHsKK3N0YXRpYyBzdHJ1Y3QgYXNpYzNfY2xrIGFzaWMzX2Nsa19pbml0W10gX19pbml0ZGF0YSA9IHsKIAlJTklUX0NERVgoU1BJLCAwKSwKIAlJTklUX0NERVgoT1dNLCA1MDAwMDAwKSwKIAlJTklUX0NERVgoUFdNMCwgMCksCkBAIC0xMDIsNyArMTAyLDcgQEAKIAkJCShyZWcgPj4gYXNpYy0+YnVzX3NoaWZ0KSk7CiB9CiAKLXZvaWQgYXNpYzNfc2V0X3JlZ2lzdGVyKHN0cnVjdCBhc2ljMyAqYXNpYywgdTMyIHJlZywgdTMyIGJpdHMsIGJvb2wgc2V0KQorc3RhdGljIHZvaWQgYXNpYzNfc2V0X3JlZ2lzdGVyKHN0cnVjdCBhc2ljMyAqYXNpYywgdTMyIHJlZywgdTMyIGJpdHMsIGJvb2wgc2V0KQogewogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJdTMyIHZhbDsKQEAgLTIyNiwxNCArMjI2LDE0IEBACiAJcmV0dXJuIChpcnEgLSBhc2ljLT5pcnFfYmFzZSkgJiAweGY7CiB9CiAKLXN0YXRpYyB2b2lkIGFzaWMzX21hc2tfZ3Bpb19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGFzaWMzX21hc2tfZ3Bpb19pcnEoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBhc2ljMyAqYXNpYyA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IGFzaWMzICphc2ljID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CiAJdTMyIHZhbCwgYmFuaywgaW5kZXg7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCWJhbmsgPSBhc2ljM19pcnFfdG9fYmFuayhhc2ljLCBpcnEpOwotCWluZGV4ID0gYXNpYzNfaXJxX3RvX2luZGV4KGFzaWMsIGlycSk7CisJYmFuayA9IGFzaWMzX2lycV90b19iYW5rKGFzaWMsIGRhdGEtPmlycSk7CisJaW5kZXggPSBhc2ljM19pcnFfdG9faW5kZXgoYXNpYywgZGF0YS0+aXJxKTsKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZhc2ljLT5sb2NrLCBmbGFncyk7CiAJdmFsID0gYXNpYzNfcmVhZF9yZWdpc3Rlcihhc2ljLCBiYW5rICsgQVNJQzNfR1BJT19NQVNLKTsKQEAgLTI0Miw5ICsyNDIsOSBAQAogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmFzaWMtPmxvY2ssIGZsYWdzKTsKIH0KIAotc3RhdGljIHZvaWQgYXNpYzNfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGFzaWMzX21hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3QgYXNpYzMgKmFzaWMgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBhc2ljMyAqYXNpYyA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCWludCByZWd2YWw7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIApAQCAtMjU0LDcgKzI1NCw3IEBACiAJCQkJICAgICBBU0lDM19JTlRSX0lOVF9NQVNLKTsKIAogCXJlZ3ZhbCAmPSB+KEFTSUMzX0lOVE1BU0tfTUFTSzAgPDwKLQkJICAgIChpcnEgLSAoYXNpYy0+aXJxX2Jhc2UgKyBBU0lDM19OVU1fR1BJT1MpKSk7CisJCSAgICAoZGF0YS0+aXJxIC0gKGFzaWMtPmlycV9iYXNlICsgQVNJQzNfTlVNX0dQSU9TKSkpOwogCiAJYXNpYzNfd3JpdGVfcmVnaXN0ZXIoYXNpYywKIAkJCSAgICAgQVNJQzNfSU5UUl9CQVNFICsKQEAgLTI2MywxNCArMjYzLDE0IEBACiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYXNpYy0+bG9jaywgZmxhZ3MpOwogfQogCi1zdGF0aWMgdm9pZCBhc2ljM191bm1hc2tfZ3Bpb19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIGFzaWMzX3VubWFza19ncGlvX2lycShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IGFzaWMzICphc2ljID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgYXNpYzMgKmFzaWMgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKIAl1MzIgdmFsLCBiYW5rLCBpbmRleDsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCi0JYmFuayA9IGFzaWMzX2lycV90b19iYW5rKGFzaWMsIGlycSk7Ci0JaW5kZXggPSBhc2ljM19pcnFfdG9faW5kZXgoYXNpYywgaXJxKTsKKwliYW5rID0gYXNpYzNfaXJxX3RvX2JhbmsoYXNpYywgZGF0YS0+aXJxKTsKKwlpbmRleCA9IGFzaWMzX2lycV90b19pbmRleChhc2ljLCBkYXRhLT5pcnEpOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmFzaWMtPmxvY2ssIGZsYWdzKTsKIAl2YWwgPSBhc2ljM19yZWFkX3JlZ2lzdGVyKGFzaWMsIGJhbmsgKyBBU0lDM19HUElPX01BU0spOwpAQCAtMjc5LDkgKzI3OSw5IEBACiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYXNpYy0+bG9jaywgZmxhZ3MpOwogfQogCi1zdGF0aWMgdm9pZCBhc2ljM191bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBhc2ljM191bm1hc2tfaXJxKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3QgYXNpYzMgKmFzaWMgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBhc2ljMyAqYXNpYyA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCWludCByZWd2YWw7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIApAQCAtMjkxLDcgKzI5MSw3IEBACiAJCQkJICAgICBBU0lDM19JTlRSX0lOVF9NQVNLKTsKIAogCXJlZ3ZhbCB8PSAoQVNJQzNfSU5UTUFTS19NQVNLMCA8PAotCQkgICAoaXJxIC0gKGFzaWMtPmlycV9iYXNlICsgQVNJQzNfTlVNX0dQSU9TKSkpOworCQkgICAoZGF0YS0+aXJxIC0gKGFzaWMtPmlycV9iYXNlICsgQVNJQzNfTlVNX0dQSU9TKSkpOwogCiAJYXNpYzNfd3JpdGVfcmVnaXN0ZXIoYXNpYywKIAkJCSAgICAgQVNJQzNfSU5UUl9CQVNFICsKQEAgLTMwMCwxNSArMzAwLDE1IEBACiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYXNpYy0+bG9jaywgZmxhZ3MpOwogfQogCi1zdGF0aWMgaW50IGFzaWMzX2dwaW9faXJxX3R5cGUodW5zaWduZWQgaW50IGlycSwgdW5zaWduZWQgaW50IHR5cGUpCitzdGF0aWMgaW50IGFzaWMzX2dwaW9faXJxX3R5cGUoc3RydWN0IGlycV9kYXRhICpkYXRhLCB1bnNpZ25lZCBpbnQgdHlwZSkKIHsKLQlzdHJ1Y3QgYXNpYzMgKmFzaWMgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBhc2ljMyAqYXNpYyA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCXUzMiBiYW5rLCBpbmRleDsKIAl1MTYgdHJpZ2dlciwgbGV2ZWwsIGVkZ2UsIGJpdDsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCi0JYmFuayA9IGFzaWMzX2lycV90b19iYW5rKGFzaWMsIGlycSk7Ci0JaW5kZXggPSBhc2ljM19pcnFfdG9faW5kZXgoYXNpYywgaXJxKTsKKwliYW5rID0gYXNpYzNfaXJxX3RvX2JhbmsoYXNpYywgZGF0YS0+aXJxKTsKKwlpbmRleCA9IGFzaWMzX2lycV90b19pbmRleChhc2ljLCBkYXRhLT5pcnEpOwogCWJpdCA9IDE8PGluZGV4OwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmFzaWMtPmxvY2ssIGZsYWdzKTsKQEAgLTMxOCw3ICszMTgsNyBAQAogCQkJCSAgIGJhbmsgKyBBU0lDM19HUElPX0VER0VfVFJJR0dFUik7CiAJdHJpZ2dlciA9IGFzaWMzX3JlYWRfcmVnaXN0ZXIoYXNpYywKIAkJCQkgICAgICBiYW5rICsgQVNJQzNfR1BJT19UUklHR0VSX1RZUEUpOwotCWFzaWMtPmlycV9ib3RoZWRnZVsoaXJxIC0gYXNpYy0+aXJxX2Jhc2UpID4+IDRdICY9IH5iaXQ7CisJYXNpYy0+aXJxX2JvdGhlZGdlWyhkYXRhLT5pcnEgLSBhc2ljLT5pcnFfYmFzZSkgPj4gNF0gJj0gfmJpdDsKIAogCWlmICh0eXBlID09IElSUV9UWVBFX0VER0VfUklTSU5HKSB7CiAJCXRyaWdnZXIgfD0gYml0OwpAQCAtMzI4LDExICszMjgsMTEgQEAKIAkJZWRnZSAmPSB+Yml0OwogCX0gZWxzZSBpZiAodHlwZSA9PSBJUlFfVFlQRV9FREdFX0JPVEgpIHsKIAkJdHJpZ2dlciB8PSBiaXQ7Ci0JCWlmIChhc2ljM19ncGlvX2dldCgmYXNpYy0+Z3BpbywgaXJxIC0gYXNpYy0+aXJxX2Jhc2UpKQorCQlpZiAoYXNpYzNfZ3Bpb19nZXQoJmFzaWMtPmdwaW8sIGRhdGEtPmlycSAtIGFzaWMtPmlycV9iYXNlKSkKIAkJCWVkZ2UgJj0gfmJpdDsKIAkJZWxzZQogCQkJZWRnZSB8PSBiaXQ7Ci0JCWFzaWMtPmlycV9ib3RoZWRnZVsoaXJxIC0gYXNpYy0+aXJxX2Jhc2UpID4+IDRdIHw9IGJpdDsKKwkJYXNpYy0+aXJxX2JvdGhlZGdlWyhkYXRhLT5pcnEgLSBhc2ljLT5pcnFfYmFzZSkgPj4gNF0gfD0gYml0OwogCX0gZWxzZSBpZiAodHlwZSA9PSBJUlFfVFlQRV9MRVZFTF9MT1cpIHsKIAkJdHJpZ2dlciAmPSB+Yml0OwogCQlsZXZlbCAmPSB+Yml0OwpAQCAtMzU5LDE3ICszNTksMTcgQEAKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBhc2ljM19ncGlvX2lycV9jaGlwID0gewogCS5uYW1lCQk9ICJBU0lDMy1HUElPIiwKLQkuYWNrCQk9IGFzaWMzX21hc2tfZ3Bpb19pcnEsCi0JLm1hc2sJCT0gYXNpYzNfbWFza19ncGlvX2lycSwKLQkudW5tYXNrCQk9IGFzaWMzX3VubWFza19ncGlvX2lycSwKLQkuc2V0X3R5cGUJPSBhc2ljM19ncGlvX2lycV90eXBlLAorCS5pcnFfYWNrCT0gYXNpYzNfbWFza19ncGlvX2lycSwKKwkuaXJxX21hc2sJPSBhc2ljM19tYXNrX2dwaW9faXJxLAorCS5pcnFfdW5tYXNrCT0gYXNpYzNfdW5tYXNrX2dwaW9faXJxLAorCS5pcnFfc2V0X3R5cGUJPSBhc2ljM19ncGlvX2lycV90eXBlLAogfTsKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBhc2ljM19pcnFfY2hpcCA9IHsKIAkubmFtZQkJPSAiQVNJQzMiLAotCS5hY2sJCT0gYXNpYzNfbWFza19pcnEsCi0JLm1hc2sJCT0gYXNpYzNfbWFza19pcnEsCi0JLnVubWFzawkJPSBhc2ljM191bm1hc2tfaXJxLAorCS5pcnFfYWNrCT0gYXNpYzNfbWFza19pcnEsCisJLmlycV9tYXNrCT0gYXNpYzNfbWFza19pcnEsCisJLmlycV91bm1hc2sJPSBhc2ljM191bm1hc2tfaXJxLAogfTsKIAogc3RhdGljIGludCBfX2luaXQgYXNpYzNfaXJxX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCkBAIC02MzUsNyArNjM1LDcgQEAKIAl9LAogCXsKIAkJLnN0YXJ0ID0gQVNJQzNfSVJRX09XTSwKLQkJLnN0YXJ0ID0gQVNJQzNfSVJRX09XTSwKKwkJLmVuZCAgID0gQVNJQzNfSVJRX09XTSwKIAkJLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEgfCBJT1JFU09VUkNFX0lSUV9ISUdIRURHRSwKIAl9LAogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL2NzNTUzNS1tZmQuYyBiL2RyaXZlcnMvbWZkL2NzNTUzNS1tZmQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41OWNhNmYxCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tZmQvY3M1NTM1LW1mZC5jCkBAIC0wLDAgKzEsMTUxIEBACisvKgorICogY3M1NTM1LW1mZC5jIC0gY29yZSBNRkQgZHJpdmVyIGZvciBDUzU1MzUvQ1M1NTM2IHNvdXRoYnJpZGdlcworICoKKyAqIFRoZSBDUzU1MzUgYW5kIENTNTUzNiBoYXMgYW4gSVNBIGJyaWRnZSBvbiB0aGUgUENJIGJ1cyB0aGF0IGlzCisgKiB1c2VkIGZvciBhY2Nlc3NpbmcgR1BJT3MsIE1GR1BUcywgQUNQSSwgZXRjLiAgRWFjaCBzdWJkZXZpY2UgaGFzCisgKiBhbiBJTyByYW5nZSB0aGF0J3Mgc3BlY2lmaWVkIGluIGEgc2luZ2xlIEJBUi4gIFRoZSBCQVIgb3JkZXIgaXMKKyAqIGhhcmRjb2RlZCBpbiB0aGUgQ1M1NTN4IHNwZWNpZmljYXRpb25zLgorICoKKyAqIENvcHlyaWdodCAoYykgMjAxMCAgQW5kcmVzIFNhbG9tb24gPGRpbGluZ2VyQHF1ZXVlZC5uZXQ+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNjc1IE1hc3MgQXZlLCBDYW1icmlkZ2UsIE1BIDAyMTM5LCBVU0EuCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9tZmQvY29yZS5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgorCisjZGVmaW5lIERSVl9OQU1FICJjczU1MzUtbWZkIgorCitlbnVtIGNzNTUzNV9tZmRfYmFycyB7CisJU01CX0JBUiA9IDAsCisJR1BJT19CQVIgPSAxLAorCU1GR1BUX0JBUiA9IDIsCisJUE1TX0JBUiA9IDQsCisJQUNQSV9CQVIgPSA1LAorCU5SX0JBUlMsCit9OworCitzdGF0aWMgX19kZXZpbml0ZGF0YSBzdHJ1Y3QgcmVzb3VyY2UgY3M1NTM1X21mZF9yZXNvdXJjZXNbTlJfQkFSU107CisKK3N0YXRpYyBfX2RldmluaXRkYXRhIHN0cnVjdCBtZmRfY2VsbCBjczU1MzVfbWZkX2NlbGxzW10gPSB7CisJeworCQkuaWQgPSBTTUJfQkFSLAorCQkubmFtZSA9ICJjczU1MzUtc21iIiwKKwkJLm51bV9yZXNvdXJjZXMgPSAxLAorCQkucmVzb3VyY2VzID0gJmNzNTUzNV9tZmRfcmVzb3VyY2VzW1NNQl9CQVJdLAorCX0sCisJeworCQkuaWQgPSBHUElPX0JBUiwKKwkJLm5hbWUgPSAiY3M1NTM1LWdwaW8iLAorCQkubnVtX3Jlc291cmNlcyA9IDEsCisJCS5yZXNvdXJjZXMgPSAmY3M1NTM1X21mZF9yZXNvdXJjZXNbR1BJT19CQVJdLAorCX0sCisJeworCQkuaWQgPSBNRkdQVF9CQVIsCisJCS5uYW1lID0gImNzNTUzNS1tZmdwdCIsCisJCS5udW1fcmVzb3VyY2VzID0gMSwKKwkJLnJlc291cmNlcyA9ICZjczU1MzVfbWZkX3Jlc291cmNlc1tNRkdQVF9CQVJdLAorCX0sCisJeworCQkuaWQgPSBQTVNfQkFSLAorCQkubmFtZSA9ICJjczU1MzUtcG1zIiwKKwkJLm51bV9yZXNvdXJjZXMgPSAxLAorCQkucmVzb3VyY2VzID0gJmNzNTUzNV9tZmRfcmVzb3VyY2VzW1BNU19CQVJdLAorCX0sCisJeworCQkuaWQgPSBBQ1BJX0JBUiwKKwkJLm5hbWUgPSAiY3M1NTM1LWFjcGkiLAorCQkubnVtX3Jlc291cmNlcyA9IDEsCisJCS5yZXNvdXJjZXMgPSAmY3M1NTM1X21mZF9yZXNvdXJjZXNbQUNQSV9CQVJdLAorCX0sCit9OworCitzdGF0aWMgaW50IF9fZGV2aW5pdCBjczU1MzVfbWZkX3Byb2JlKHN0cnVjdCBwY2lfZGV2ICpwZGV2LAorCQljb25zdCBzdHJ1Y3QgcGNpX2RldmljZV9pZCAqaWQpCit7CisJaW50IGVyciwgaTsKKworCWVyciA9IHBjaV9lbmFibGVfZGV2aWNlKHBkZXYpOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CisKKwkvKiBmaWxsIGluIElPIHJhbmdlIGZvciBlYWNoIGNlbGw7IHN1YmRyaXZlcnMgaGFuZGxlIHRoZSByZWdpb24gKi8KKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShjczU1MzVfbWZkX2NlbGxzKTsgaSsrKSB7CisJCWludCBiYXIgPSBjczU1MzVfbWZkX2NlbGxzW2ldLmlkOworCQlzdHJ1Y3QgcmVzb3VyY2UgKnIgPSAmY3M1NTM1X21mZF9yZXNvdXJjZXNbYmFyXTsKKworCQlyLT5mbGFncyA9IElPUkVTT1VSQ0VfSU87CisJCXItPnN0YXJ0ID0gcGNpX3Jlc291cmNlX3N0YXJ0KHBkZXYsIGJhcik7CisJCXItPmVuZCA9IHBjaV9yZXNvdXJjZV9lbmQocGRldiwgYmFyKTsKKworCQkvKiBpZCBpcyB1c2VkIGZvciB0ZW1wb3JhcmlseSBzdG9yaW5nIEJBUjsgdW5zZXQgaXQgbm93ICovCisJCWNzNTUzNV9tZmRfY2VsbHNbaV0uaWQgPSAwOworCX0KKworCWVyciA9IG1mZF9hZGRfZGV2aWNlcygmcGRldi0+ZGV2LCAtMSwgY3M1NTM1X21mZF9jZWxscywKKwkJCUFSUkFZX1NJWkUoY3M1NTM1X21mZF9jZWxscyksIE5VTEwsIDApOworCWlmIChlcnIpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiTUZEIGFkZCBkZXZpY2VzIGZhaWxlZDogJWRcbiIsIGVycik7CisJCWdvdG8gZXJyX2Rpc2FibGU7CisJfQorCisJZGV2X2luZm8oJnBkZXYtPmRldiwgIiV6dSBkZXZpY2VzIHJlZ2lzdGVyZWQuXG4iLAorCQkJQVJSQVlfU0laRShjczU1MzVfbWZkX2NlbGxzKSk7CisKKwlyZXR1cm4gMDsKKworZXJyX2Rpc2FibGU6CisJcGNpX2Rpc2FibGVfZGV2aWNlKHBkZXYpOworCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyB2b2lkIF9fZGV2ZXhpdCBjczU1MzVfbWZkX3JlbW92ZShzdHJ1Y3QgcGNpX2RldiAqcGRldikKK3sKKwltZmRfcmVtb3ZlX2RldmljZXMoJnBkZXYtPmRldik7CisJcGNpX2Rpc2FibGVfZGV2aWNlKHBkZXYpOworfQorCitzdGF0aWMgc3RydWN0IHBjaV9kZXZpY2VfaWQgY3M1NTM1X21mZF9wY2lfdGJsW10gPSB7CisJeyBQQ0lfREVWSUNFKFBDSV9WRU5ET1JfSURfTlMsIFBDSV9ERVZJQ0VfSURfTlNfQ1M1NTM1X0lTQSkgfSwKKwl7IFBDSV9ERVZJQ0UoUENJX1ZFTkRPUl9JRF9BTUQsIFBDSV9ERVZJQ0VfSURfQU1EX0NTNTUzNl9JU0EpIH0sCisJeyAwLCB9Cit9OworTU9EVUxFX0RFVklDRV9UQUJMRShwY2ksIGNzNTUzNV9tZmRfcGNpX3RibCk7CisKK3N0YXRpYyBzdHJ1Y3QgcGNpX2RyaXZlciBjczU1MzVfbWZkX2RydiA9IHsKKwkubmFtZSA9IERSVl9OQU1FLAorCS5pZF90YWJsZSA9IGNzNTUzNV9tZmRfcGNpX3RibCwKKwkucHJvYmUgPSBjczU1MzVfbWZkX3Byb2JlLAorCS5yZW1vdmUgPSBfX2RldmV4aXRfcChjczU1MzVfbWZkX3JlbW92ZSksCit9OworCitzdGF0aWMgaW50IF9faW5pdCBjczU1MzVfbWZkX2luaXQodm9pZCkKK3sKKwlyZXR1cm4gcGNpX3JlZ2lzdGVyX2RyaXZlcigmY3M1NTM1X21mZF9kcnYpOworfQorCitzdGF0aWMgdm9pZCBfX2V4aXQgY3M1NTM1X21mZF9leGl0KHZvaWQpCit7CisJcGNpX3VucmVnaXN0ZXJfZHJpdmVyKCZjczU1MzVfbWZkX2Rydik7Cit9CisKK21vZHVsZV9pbml0KGNzNTUzNV9tZmRfaW5pdCk7Cittb2R1bGVfZXhpdChjczU1MzVfbWZkX2V4aXQpOworCitNT0RVTEVfQVVUSE9SKCJBbmRyZXMgU2Fsb21vbiA8ZGlsaW5nZXJAcXVldWVkLm5ldD4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiTUZEIGRyaXZlciBmb3IgQ1M1NTM1L0NTNTUzNiBzb3V0aGJyaWRnZSdzIElTQSBQQ0kgZGV2aWNlIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC9lengtcGNhcC5jIGIvZHJpdmVycy9tZmQvZXp4LXBjYXAuYwppbmRleCBjMmI2OThkLi45ZTJkOGRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC9lengtcGNhcC5jCisrKyBiL2RyaXZlcnMvbWZkL2V6eC1wY2FwLmMKQEAgLTE0NCwyNiArMTQ0LDI2IEBACiB9CiBFWFBPUlRfU1lNQk9MX0dQTChwY2FwX3RvX2lycSk7CiAKLXN0YXRpYyB2b2lkIHBjYXBfbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHBjYXBfbWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXN0cnVjdCBwY2FwX2NoaXAgKnBjYXAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBwY2FwX2NoaXAgKnBjYXAgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKIAotCXBjYXAtPm1zciB8PSAxIDw8IGlycV90b19wY2FwKHBjYXAsIGlycSk7CisJcGNhcC0+bXNyIHw9IDEgPDwgaXJxX3RvX3BjYXAocGNhcCwgZC0+aXJxKTsKIAlxdWV1ZV93b3JrKHBjYXAtPndvcmtxdWV1ZSwgJnBjYXAtPm1zcl93b3JrKTsKIH0KIAotc3RhdGljIHZvaWQgcGNhcF91bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBwY2FwX3VubWFza19pcnEoc3RydWN0IGlycV9kYXRhICpkKQogewotCXN0cnVjdCBwY2FwX2NoaXAgKnBjYXAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBwY2FwX2NoaXAgKnBjYXAgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKIAotCXBjYXAtPm1zciAmPSB+KDEgPDwgaXJxX3RvX3BjYXAocGNhcCwgaXJxKSk7CisJcGNhcC0+bXNyICY9IH4oMSA8PCBpcnFfdG9fcGNhcChwY2FwLCBkLT5pcnEpKTsKIAlxdWV1ZV93b3JrKHBjYXAtPndvcmtxdWV1ZSwgJnBjYXAtPm1zcl93b3JrKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBwY2FwX2lycV9jaGlwID0gewotCS5uYW1lCT0gInBjYXAiLAotCS5tYXNrCT0gcGNhcF9tYXNrX2lycSwKLQkudW5tYXNrCT0gcGNhcF91bm1hc2tfaXJxLAorCS5uYW1lCQk9ICJwY2FwIiwKKwkuaXJxX21hc2sJPSBwY2FwX21hc2tfaXJxLAorCS5pcnFfdW5tYXNrCT0gcGNhcF91bm1hc2tfaXJxLAogfTsKIAogc3RhdGljIHZvaWQgcGNhcF9tc3Jfd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCkBAIC0xOTksOCArMTk5LDcgQEAKIAkJCWlmIChzZXJ2aWNlICYgMSkgewogCQkJCXN0cnVjdCBpcnFfZGVzYyAqZGVzYyA9IGlycV90b19kZXNjKGlycSk7CiAKLQkJCQlpZiAoV0FSTighZGVzYywgS0VSTl9XQVJOSU5HCi0JCQkJCQkiSW52YWxpZCBQQ0FQIElSUSAlZFxuIiwgaXJxKSkKKwkJCQlpZiAoV0FSTighZGVzYywgIkludmFsaWQgUENBUCBJUlEgJWRcbiIsIGlycSkpCiAJCQkJCWJyZWFrOwogCiAJCQkJaWYgKGRlc2MtPnN0YXR1cyAmIElSUV9ESVNBQkxFRCkKQEAgLTIxOCw3ICsyMTcsNyBAQAogewogCXN0cnVjdCBwY2FwX2NoaXAgKnBjYXAgPSBnZXRfaXJxX2RhdGEoaXJxKTsKIAotCWRlc2MtPmNoaXAtPmFjayhpcnEpOworCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV9hY2soJmRlc2MtPmlycV9kYXRhKTsKIAlxdWV1ZV93b3JrKHBjYXAtPndvcmtxdWV1ZSwgJnBjYXAtPmlzcl93b3JrKTsKIAlyZXR1cm47CiB9CkBAIC0yODIsNyArMjgxLDcgQEAKIAltdXRleF9sb2NrKCZwY2FwLT5hZGNfbXV0ZXgpOwogCXJlcSA9IHBjYXAtPmFkY19xdWV1ZVtwY2FwLT5hZGNfaGVhZF07CiAKLQlpZiAoV0FSTighcmVxLCBLRVJOX1dBUk5JTkcgImFkYyBpcnEgd2l0aG91dCBwZW5kaW5nIHJlcXVlc3RcbiIpKSB7CisJaWYgKFdBUk4oIXJlcSwgImFkYyBpcnEgd2l0aG91dCBwZW5kaW5nIHJlcXVlc3RcbiIpKSB7CiAJCW11dGV4X3VubG9jaygmcGNhcC0+YWRjX211dGV4KTsKIAkJcmV0dXJuIElSUV9IQU5ETEVEOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL2h0Yy1lZ3Bpby5jIGIvZHJpdmVycy9tZmQvaHRjLWVncGlvLmMKaW5kZXggZDNlNzRmOC4uZDAwYjZkMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZmQvaHRjLWVncGlvLmMKKysrIGIvZHJpdmVycy9tZmQvaHRjLWVncGlvLmMKQEAgLTcwLDMxICs3MCwzMiBAQAogCQkJZWktPmFja193cml0ZSwgZWktPmFja19yZWdpc3RlciA8PCBlaS0+YnVzX3NoaWZ0KTsKIH0KIAotc3RhdGljIHZvaWQgZWdwaW9fYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBlZ3Bpb19hY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewogfQogCiAvKiBUaGVyZSBkb2VzIG5vdCBhcHBlYXIgdG8gYmUgYSB3YXkgdG8gcHJvYWN0aXZlbHkgbWFzayBpbnRlcnJ1cHRzCiAgKiBvbiB0aGUgZWdwaW8gY2hpcCBpdHNlbGYuICBTbywgd2Ugc2ltcGx5IGlnbm9yZSBpbnRlcnJ1cHRzIHRoYXQKICAqIGFyZW4ndCBkZXNpcmVkLiAqLwotc3RhdGljIHZvaWQgZWdwaW9fbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgZWdwaW9fbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IGVncGlvX2luZm8gKmVpID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQllaS0+aXJxc19lbmFibGVkICY9IH4oMSA8PCAoaXJxIC0gZWktPmlycV9zdGFydCkpOwotCXByX2RlYnVnKCJFR1BJTyBtYXNrICVkICUwNHhcbiIsIGlycSwgZWktPmlycXNfZW5hYmxlZCk7CisJc3RydWN0IGVncGlvX2luZm8gKmVpID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CisJZWktPmlycXNfZW5hYmxlZCAmPSB+KDEgPDwgKGRhdGEtPmlycSAtIGVpLT5pcnFfc3RhcnQpKTsKKwlwcl9kZWJ1ZygiRUdQSU8gbWFzayAlZCAlMDR4XG4iLCBkYXRhLT5pcnEsIGVpLT5pcnFzX2VuYWJsZWQpOwogfQotc3RhdGljIHZvaWQgZWdwaW9fdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCisKK3N0YXRpYyB2b2lkIGVncGlvX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IGVncGlvX2luZm8gKmVpID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQllaS0+aXJxc19lbmFibGVkIHw9IDEgPDwgKGlycSAtIGVpLT5pcnFfc3RhcnQpOwotCXByX2RlYnVnKCJFR1BJTyB1bm1hc2sgJWQgJTA0eFxuIiwgaXJxLCBlaS0+aXJxc19lbmFibGVkKTsKKwlzdHJ1Y3QgZWdwaW9faW5mbyAqZWkgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKKwllaS0+aXJxc19lbmFibGVkIHw9IDEgPDwgKGRhdGEtPmlycSAtIGVpLT5pcnFfc3RhcnQpOworCXByX2RlYnVnKCJFR1BJTyB1bm1hc2sgJWQgJTA0eFxuIiwgZGF0YS0+aXJxLCBlaS0+aXJxc19lbmFibGVkKTsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBlZ3Bpb19tdXhlZF9jaGlwID0gewotCS5uYW1lICAgPSAiaHRjLWVncGlvIiwKLQkuYWNrCT0gZWdwaW9fYWNrLAotCS5tYXNrICAgPSBlZ3Bpb19tYXNrLAotCS51bm1hc2sgPSBlZ3Bpb191bm1hc2ssCisJLm5hbWUJCT0gImh0Yy1lZ3BpbyIsCisJLmlycV9hY2sJPSBlZ3Bpb19hY2ssCisJLmlycV9tYXNrCT0gZWdwaW9fbWFzaywKKwkuaXJxX3VubWFzawk9IGVncGlvX3VubWFzaywKIH07CiAKIHN0YXRpYyB2b2lkIGVncGlvX2hhbmRsZXIodW5zaWduZWQgaW50IGlycSwgc3RydWN0IGlycV9kZXNjICpkZXNjKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvaHRjLWkyY3BsZC5jIGIvZHJpdmVycy9tZmQvaHRjLWkyY3BsZC5jCmluZGV4IDU5NGM5YTguLjI5NmFkMTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL2h0Yy1pMmNwbGQuYworKysgYi9kcml2ZXJzL21mZC9odGMtaTJjcGxkLmMKQEAgLTgyLDI1ICs4MiwyNSBAQAogLyogVGhlcmUgZG9lcyBub3QgYXBwZWFyIHRvIGJlIGEgd2F5IHRvIHByb2FjdGl2ZWx5IG1hc2sgaW50ZXJydXB0cwogICogb24gdGhlIGh0Y3BsZCBjaGlwIGl0c2VsZi4gIFNvLCB3ZSBzaW1wbHkgaWdub3JlIGludGVycnVwdHMgdGhhdAogICogYXJlbid0IGRlc2lyZWQuICovCi1zdGF0aWMgdm9pZCBodGNwbGRfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaHRjcGxkX21hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBodGNwbGRfY2hpcCAqY2hpcCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7Ci0JY2hpcC0+aXJxc19lbmFibGVkICY9IH4oMSA8PCAoaXJxIC0gY2hpcC0+aXJxX3N0YXJ0KSk7Ci0JcHJfZGVidWcoIkhUQ1BMRCBtYXNrICVkICUwNHhcbiIsIGlycSwgY2hpcC0+aXJxc19lbmFibGVkKTsKKwlzdHJ1Y3QgaHRjcGxkX2NoaXAgKmNoaXAgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKKwljaGlwLT5pcnFzX2VuYWJsZWQgJj0gfigxIDw8IChkYXRhLT5pcnEgLSBjaGlwLT5pcnFfc3RhcnQpKTsKKwlwcl9kZWJ1ZygiSFRDUExEIG1hc2sgJWQgJTA0eFxuIiwgZGF0YS0+aXJxLCBjaGlwLT5pcnFzX2VuYWJsZWQpOwogfQotc3RhdGljIHZvaWQgaHRjcGxkX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgaHRjcGxkX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IGh0Y3BsZF9jaGlwICpjaGlwID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQljaGlwLT5pcnFzX2VuYWJsZWQgfD0gMSA8PCAoaXJxIC0gY2hpcC0+aXJxX3N0YXJ0KTsKLQlwcl9kZWJ1ZygiSFRDUExEIHVubWFzayAlZCAlMDR4XG4iLCBpcnEsIGNoaXAtPmlycXNfZW5hYmxlZCk7CisJc3RydWN0IGh0Y3BsZF9jaGlwICpjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CisJY2hpcC0+aXJxc19lbmFibGVkIHw9IDEgPDwgKGRhdGEtPmlycSAtIGNoaXAtPmlycV9zdGFydCk7CisJcHJfZGVidWcoIkhUQ1BMRCB1bm1hc2sgJWQgJTA0eFxuIiwgZGF0YS0+aXJxLCBjaGlwLT5pcnFzX2VuYWJsZWQpOwogfQogCi1zdGF0aWMgaW50IGh0Y3BsZF9zZXRfdHlwZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgZmxhZ3MpCitzdGF0aWMgaW50IGh0Y3BsZF9zZXRfdHlwZShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEsIHVuc2lnbmVkIGludCBmbGFncykKIHsKLQlzdHJ1Y3QgaXJxX2Rlc2MgKmQgPSBpcnFfdG9fZGVzYyhpcnEpOworCXN0cnVjdCBpcnFfZGVzYyAqZCA9IGlycV90b19kZXNjKGRhdGEtPmlycSk7CiAKIAlpZiAoIWQpIHsKLQkJcHJfZXJyKCJIVENQTEQgaW52YWxpZCBJUlE6ICVkXG4iLCBpcnEpOworCQlwcl9lcnIoIkhUQ1BMRCBpbnZhbGlkIElSUTogJWRcbiIsIGRhdGEtPmlycSk7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIApAQCAtMTE4LDEwICsxMTgsMTAgQEAKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBodGNwbGRfbXV4ZWRfY2hpcCA9IHsKLQkubmFtZSAgICAgPSAiaHRjcGxkIiwKLQkubWFzayAgICAgPSBodGNwbGRfbWFzaywKLQkudW5tYXNrICAgPSBodGNwbGRfdW5tYXNrLAotCS5zZXRfdHlwZSA9IGh0Y3BsZF9zZXRfdHlwZSwKKwkubmFtZSAgICAgICAgID0gImh0Y3BsZCIsCisJLmlycV9tYXNrICAgICA9IGh0Y3BsZF9tYXNrLAorCS5pcnFfdW5tYXNrICAgPSBodGNwbGRfdW5tYXNrLAorCS5pcnFfc2V0X3R5cGUgPSBodGNwbGRfc2V0X3R5cGUsCiB9OwogCiAvKiBUbyBwcm9wZXJseSBkaXNwYXRjaCBJUlEgZXZlbnRzLCB3ZSBuZWVkIHRvIHJlYWQgZnJvbSB0aGUKQEAgLTIzNSw3ICsyMzUsNyBAQAogICogYW5kIHRoYXQgd29yayBpcyBzY2hlZHVsZWQgaW4gdGhlIHNldCByb3V0aW5lLiAgVGhlIGtlcm5lbCBjYW4gdGhlbiBydW4KICAqIHRoZSBJMkMgZnVuY3Rpb25zLCB3aGljaCB3aWxsIHNsZWVwLCBpbiBwcm9jZXNzIGNvbnRleHQuCiAgKi8KLXZvaWQgaHRjcGxkX2NoaXBfc2V0KHN0cnVjdCBncGlvX2NoaXAgKmNoaXAsIHVuc2lnbmVkIG9mZnNldCwgaW50IHZhbCkKK3N0YXRpYyB2b2lkIGh0Y3BsZF9jaGlwX3NldChzdHJ1Y3QgZ3Bpb19jaGlwICpjaGlwLCB1bnNpZ25lZCBvZmZzZXQsIGludCB2YWwpCiB7CiAJc3RydWN0IGkyY19jbGllbnQgKmNsaWVudDsKIAlzdHJ1Y3QgaHRjcGxkX2NoaXAgKmNoaXBfZGF0YTsKQEAgLTI1OSw3ICsyNTksNyBAQAogCXNjaGVkdWxlX3dvcmsoJihjaGlwX2RhdGEtPnNldF92YWxfd29yaykpOwogfQogCi12b2lkIGh0Y3BsZF9jaGlwX3NldF9uaShzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCitzdGF0aWMgdm9pZCBodGNwbGRfY2hpcF9zZXRfbmkoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogewogCXN0cnVjdCBodGNwbGRfY2hpcCAqY2hpcF9kYXRhOwogCXN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQ7CkBAIC0yNjksNyArMjY5LDcgQEAKIAlpMmNfc21idXNfcmVhZF9ieXRlX2RhdGEoY2xpZW50LCBjaGlwX2RhdGEtPmNhY2hlX291dCk7CiB9CiAKLWludCBodGNwbGRfY2hpcF9nZXQoc3RydWN0IGdwaW9fY2hpcCAqY2hpcCwgdW5zaWduZWQgb2Zmc2V0KQorc3RhdGljIGludCBodGNwbGRfY2hpcF9nZXQoc3RydWN0IGdwaW9fY2hpcCAqY2hpcCwgdW5zaWduZWQgb2Zmc2V0KQogewogCXN0cnVjdCBodGNwbGRfY2hpcCAqY2hpcF9kYXRhOwogCWludCB2YWwgPSAwOwpAQCAtMzE2LDcgKzMxNiw3IEBACiAJcmV0dXJuIChvZmZzZXQgPCBjaGlwLT5uZ3BpbykgPyAwIDogLUVJTlZBTDsKIH0KIAotaW50IGh0Y3BsZF9jaGlwX3RvX2lycShzdHJ1Y3QgZ3Bpb19jaGlwICpjaGlwLCB1bnNpZ25lZCBvZmZzZXQpCitzdGF0aWMgaW50IGh0Y3BsZF9jaGlwX3RvX2lycShzdHJ1Y3QgZ3Bpb19jaGlwICpjaGlwLCB1bnNpZ25lZCBvZmZzZXQpCiB7CiAJc3RydWN0IGh0Y3BsZF9jaGlwICpjaGlwX2RhdGE7CiAKQEAgLTMyOCw3ICszMjgsNyBAQAogCQlyZXR1cm4gLUVJTlZBTDsKIH0KIAotdm9pZCBodGNwbGRfY2hpcF9yZXNldChzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50KQorc3RhdGljIHZvaWQgaHRjcGxkX2NoaXBfcmVzZXQoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCkKIHsKIAlzdHJ1Y3QgaHRjcGxkX2NoaXAgKmNoaXBfZGF0YSA9IGkyY19nZXRfY2xpZW50ZGF0YShjbGllbnQpOwogCWlmICghY2hpcF9kYXRhKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvano0NzQwLWFkYy5jIGIvZHJpdmVycy9tZmQvano0NzQwLWFkYy5jCmluZGV4IDlkZDFiMzMuLjBjYzU5NzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL2p6NDc0MC1hZGMuYworKysgYi9kcml2ZXJzL21mZC9qejQ3NDAtYWRjLmMKQEAgLTg0LDMxICs4NCwzMCBAQAogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmFkYy0+bG9jaywgZmxhZ3MpOwogfQogCi1zdGF0aWMgdm9pZCBqejQ3NDBfYWRjX2lycV9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBqejQ3NDBfYWRjX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3Qgano0NzQwX2FkYyAqYWRjID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQlqejQ3NDBfYWRjX2lycV9zZXRfbWFza2VkKGFkYywgaXJxLCB0cnVlKTsKKwlzdHJ1Y3Qgano0NzQwX2FkYyAqYWRjID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CisJano0NzQwX2FkY19pcnFfc2V0X21hc2tlZChhZGMsIGRhdGEtPmlycSwgdHJ1ZSk7CiB9CiAKLXN0YXRpYyB2b2lkIGp6NDc0MF9hZGNfaXJxX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgano0NzQwX2FkY19pcnFfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3Qgano0NzQwX2FkYyAqYWRjID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQlqejQ3NDBfYWRjX2lycV9zZXRfbWFza2VkKGFkYywgaXJxLCBmYWxzZSk7CisJc3RydWN0IGp6NDc0MF9hZGMgKmFkYyA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOworCWp6NDc0MF9hZGNfaXJxX3NldF9tYXNrZWQoYWRjLCBkYXRhLT5pcnEsIGZhbHNlKTsKIH0KIAotc3RhdGljIHZvaWQgano0NzQwX2FkY19pcnFfYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCBqejQ3NDBfYWRjX2lycV9hY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBqejQ3NDBfYWRjICphZGMgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOwotCi0JaXJxIC09IGFkYy0+aXJxX2Jhc2U7CisJc3RydWN0IGp6NDc0MF9hZGMgKmFkYyA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOworCXVuc2lnbmVkIGludCBpcnEgPSBkYXRhLT5pcnEgLSBhZGMtPmlycV9iYXNlOwogCXdyaXRlYihCSVQoaXJxKSwgYWRjLT5iYXNlICsgSlpfUkVHX0FEQ19TVEFUVVMpOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIGp6NDc0MF9hZGNfaXJxX2NoaXAgPSB7CiAJLm5hbWUgPSAiano0NzQwLWFkYyIsCi0JLm1hc2sgPSBqejQ3NDBfYWRjX2lycV9tYXNrLAotCS51bm1hc2sgPSBqejQ3NDBfYWRjX2lycV91bm1hc2ssCi0JLmFjayA9IGp6NDc0MF9hZGNfaXJxX2FjaywKKwkuaXJxX21hc2sgPSBqejQ3NDBfYWRjX2lycV9tYXNrLAorCS5pcnFfdW5tYXNrID0gano0NzQwX2FkY19pcnFfdW5tYXNrLAorCS5pcnFfYWNrID0gano0NzQwX2FkY19pcnFfYWNrLAogfTsKIAogc3RhdGljIHZvaWQgano0NzQwX2FkY19pcnFfZGVtdXgodW5zaWduZWQgaW50IGlycSwgc3RydWN0IGlycV9kZXNjICpkZXNjKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvbWF4ODkyNS1jb3JlLmMgYi9kcml2ZXJzL21mZC9tYXg4OTI1LWNvcmUuYwppbmRleCA0NDY5NWY1Li4wZTk5OGRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC9tYXg4OTI1LWNvcmUuYworKysgYi9kcml2ZXJzL21mZC9tYXg4OTI1LWNvcmUuYwpAQCAtNDA3LDE2ICs0MDcsMTYgQEAKIAlyZXR1cm4gSVJRX0hBTkRMRUQ7CiB9CiAKLXN0YXRpYyB2b2lkIG1heDg5MjVfaXJxX2xvY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1heDg5MjVfaXJxX2xvY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBtYXg4OTI1X2NoaXAgKmNoaXAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBtYXg4OTI1X2NoaXAgKmNoaXAgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKIAogCW11dGV4X2xvY2soJmNoaXAtPmlycV9sb2NrKTsKIH0KIAotc3RhdGljIHZvaWQgbWF4ODkyNV9pcnFfc3luY191bmxvY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1heDg5MjVfaXJxX3N5bmNfdW5sb2NrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3QgbWF4ODkyNV9jaGlwICpjaGlwID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgbWF4ODkyNV9jaGlwICpjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CiAJc3RydWN0IG1heDg5MjVfaXJxX2RhdGEgKmlycV9kYXRhOwogCXN0YXRpYyB1bnNpZ25lZCBjaGFyIGNhY2hlX2NoZ1syXSA9IHsweGZmLCAweGZmfTsKIAlzdGF0aWMgdW5zaWduZWQgY2hhciBjYWNoZV9vblsyXSA9IHsweGZmLCAweGZmfTsKQEAgLTQ5MiwyNSArNDkyLDI1IEBACiAJbXV0ZXhfdW5sb2NrKCZjaGlwLT5pcnFfbG9jayk7CiB9CiAKLXN0YXRpYyB2b2lkIG1heDg5MjVfaXJxX2VuYWJsZSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbWF4ODkyNV9pcnFfZW5hYmxlKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3QgbWF4ODkyNV9jaGlwICpjaGlwID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQltYXg4OTI1X2lycXNbaXJxIC0gY2hpcC0+aXJxX2Jhc2VdLmVuYWJsZQotCQk9IG1heDg5MjVfaXJxc1tpcnEgLSBjaGlwLT5pcnFfYmFzZV0ub2ZmczsKKwlzdHJ1Y3QgbWF4ODkyNV9jaGlwICpjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CisJbWF4ODkyNV9pcnFzW2RhdGEtPmlycSAtIGNoaXAtPmlycV9iYXNlXS5lbmFibGUKKwkJPSBtYXg4OTI1X2lycXNbZGF0YS0+aXJxIC0gY2hpcC0+aXJxX2Jhc2VdLm9mZnM7CiB9CiAKLXN0YXRpYyB2b2lkIG1heDg5MjVfaXJxX2Rpc2FibGUodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1heDg5MjVfaXJxX2Rpc2FibGUoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBtYXg4OTI1X2NoaXAgKmNoaXAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOwotCW1heDg5MjVfaXJxc1tpcnEgLSBjaGlwLT5pcnFfYmFzZV0uZW5hYmxlID0gMDsKKwlzdHJ1Y3QgbWF4ODkyNV9jaGlwICpjaGlwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CisJbWF4ODkyNV9pcnFzW2RhdGEtPmlycSAtIGNoaXAtPmlycV9iYXNlXS5lbmFibGUgPSAwOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG1heDg5MjVfaXJxX2NoaXAgPSB7CiAJLm5hbWUJCT0gIm1heDg5MjUiLAotCS5idXNfbG9jawk9IG1heDg5MjVfaXJxX2xvY2ssCi0JLmJ1c19zeW5jX3VubG9jayA9IG1heDg5MjVfaXJxX3N5bmNfdW5sb2NrLAotCS5lbmFibGUJCT0gbWF4ODkyNV9pcnFfZW5hYmxlLAotCS5kaXNhYmxlCT0gbWF4ODkyNV9pcnFfZGlzYWJsZSwKKwkuaXJxX2J1c19sb2NrCT0gbWF4ODkyNV9pcnFfbG9jaywKKwkuaXJxX2J1c19zeW5jX3VubG9jayA9IG1heDg5MjVfaXJxX3N5bmNfdW5sb2NrLAorCS5pcnFfZW5hYmxlCT0gbWF4ODkyNV9pcnFfZW5hYmxlLAorCS5pcnFfZGlzYWJsZQk9IG1heDg5MjVfaXJxX2Rpc2FibGUsCiB9OwogCiBzdGF0aWMgaW50IG1heDg5MjVfaXJxX2luaXQoc3RydWN0IG1heDg5MjVfY2hpcCAqY2hpcCwgaW50IGlycSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL21heDg5OTgtaXJxLmMgYi9kcml2ZXJzL21mZC9tYXg4OTk4LWlycS5jCmluZGV4IDQ1YmZlNzcuLjM5MDNlMWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL21heDg5OTgtaXJxLmMKKysrIGIvZHJpdmVycy9tZmQvbWF4ODk5OC1pcnEuYwpAQCAtMTAyLDE2ICsxMDIsMTYgQEAKIAlyZXR1cm4gJm1heDg5OThfaXJxc1tpcnEgLSBtYXg4OTk4LT5pcnFfYmFzZV07CiB9CiAKLXN0YXRpYyB2b2lkIG1heDg5OThfaXJxX2xvY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1heDg5OThfaXJxX2xvY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBtYXg4OTk4X2RldiAqbWF4ODk5OCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IG1heDg5OThfZGV2ICptYXg4OTk4ID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CiAKIAltdXRleF9sb2NrKCZtYXg4OTk4LT5pcnFsb2NrKTsKIH0KIAotc3RhdGljIHZvaWQgbWF4ODk5OF9pcnFfc3luY191bmxvY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1heDg5OThfaXJxX3N5bmNfdW5sb2NrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3QgbWF4ODk5OF9kZXYgKm1heDg5OTggPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBtYXg4OTk4X2RldiAqbWF4ODk5OCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCWludCBpOwogCiAJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUobWF4ODk5OC0+aXJxX21hc2tzX2N1cik7IGkrKykgewpAQCAtMTI5LDI4ICsxMjksMzAgQEAKIAltdXRleF91bmxvY2soJm1heDg5OTgtPmlycWxvY2spOwogfQogCi1zdGF0aWMgdm9pZCBtYXg4OTk4X2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIG1heDg5OThfaXJxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IG1heDg5OThfZGV2ICptYXg4OTk4ID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQlzdHJ1Y3QgbWF4ODk5OF9pcnFfZGF0YSAqaXJxX2RhdGEgPSBpcnFfdG9fbWF4ODk5OF9pcnEobWF4ODk5OCwgaXJxKTsKKwlzdHJ1Y3QgbWF4ODk5OF9kZXYgKm1heDg5OTggPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKKwlzdHJ1Y3QgbWF4ODk5OF9pcnFfZGF0YSAqaXJxX2RhdGEgPSBpcnFfdG9fbWF4ODk5OF9pcnEobWF4ODk5OCwKKwkJCQkJCQkgICAgICAgZGF0YS0+aXJxKTsKIAogCW1heDg5OTgtPmlycV9tYXNrc19jdXJbaXJxX2RhdGEtPnJlZyAtIDFdICY9IH5pcnFfZGF0YS0+bWFzazsKIH0KIAotc3RhdGljIHZvaWQgbWF4ODk5OF9pcnFfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgbWF4ODk5OF9pcnFfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IG1heDg5OThfZGV2ICptYXg4OTk4ID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQlzdHJ1Y3QgbWF4ODk5OF9pcnFfZGF0YSAqaXJxX2RhdGEgPSBpcnFfdG9fbWF4ODk5OF9pcnEobWF4ODk5OCwgaXJxKTsKKwlzdHJ1Y3QgbWF4ODk5OF9kZXYgKm1heDg5OTggPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKKwlzdHJ1Y3QgbWF4ODk5OF9pcnFfZGF0YSAqaXJxX2RhdGEgPSBpcnFfdG9fbWF4ODk5OF9pcnEobWF4ODk5OCwKKwkJCQkJCQkgICAgICAgZGF0YS0+aXJxKTsKIAogCW1heDg5OTgtPmlycV9tYXNrc19jdXJbaXJxX2RhdGEtPnJlZyAtIDFdIHw9IGlycV9kYXRhLT5tYXNrOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIG1heDg5OThfaXJxX2NoaXAgPSB7CiAJLm5hbWUgPSAibWF4ODk5OCIsCi0JLmJ1c19sb2NrID0gbWF4ODk5OF9pcnFfbG9jaywKLQkuYnVzX3N5bmNfdW5sb2NrID0gbWF4ODk5OF9pcnFfc3luY191bmxvY2ssCi0JLm1hc2sgPSBtYXg4OTk4X2lycV9tYXNrLAotCS51bm1hc2sgPSBtYXg4OTk4X2lycV91bm1hc2ssCisJLmlycV9idXNfbG9jayA9IG1heDg5OThfaXJxX2xvY2ssCisJLmlycV9idXNfc3luY191bmxvY2sgPSBtYXg4OTk4X2lycV9zeW5jX3VubG9jaywKKwkuaXJxX21hc2sgPSBtYXg4OTk4X2lycV9tYXNrLAorCS5pcnFfdW5tYXNrID0gbWF4ODk5OF9pcnFfdW5tYXNrLAogfTsKIAogc3RhdGljIGlycXJldHVybl90IG1heDg5OThfaXJxX3RocmVhZChpbnQgaXJxLCB2b2lkICpkYXRhKQpAQCAtMTgxLDYgKzE4MywxMyBAQAogCXJldHVybiBJUlFfSEFORExFRDsKIH0KIAoraW50IG1heDg5OThfaXJxX3Jlc3VtZShzdHJ1Y3QgbWF4ODk5OF9kZXYgKm1heDg5OTgpCit7CisJaWYgKG1heDg5OTgtPmlycSAmJiBtYXg4OTk4LT5pcnFfYmFzZSkKKwkJbWF4ODk5OF9pcnFfdGhyZWFkKG1heDg5OTgtPmlycV9iYXNlLCBtYXg4OTk4KTsKKwlyZXR1cm4gMDsKK30KKwogaW50IG1heDg5OThfaXJxX2luaXQoc3RydWN0IG1heDg5OThfZGV2ICptYXg4OTk4KQogewogCWludCBpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvbWF4ODk5OC5jIGIvZHJpdmVycy9tZmQvbWF4ODk5OC5jCmluZGV4IGJiOTk3N2IuLmJiZmU4NjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL21heDg5OTguYworKysgYi9kcml2ZXJzL21mZC9tYXg4OTk4LmMKQEAgLTI1LDYgKzI1LDggQEAKICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L2kyYy5oPgorI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgorI2luY2x1ZGUgPGxpbnV4L3BtX3J1bnRpbWUuaD4KICNpbmNsdWRlIDxsaW51eC9tdXRleC5oPgogI2luY2x1ZGUgPGxpbnV4L21mZC9jb3JlLmg+CiAjaW5jbHVkZSA8bGludXgvbWZkL21heDg5OTguaD4KQEAgLTQwLDYgKzQyLDE0IEBACiAJfSwKIH07CiAKK3N0YXRpYyBzdHJ1Y3QgbWZkX2NlbGwgbHAzOTc0X2RldnNbXSA9IHsKKwl7CisJCS5uYW1lID0gImxwMzk3NC1wbWljIiwKKwl9LCB7CisJCS5uYW1lID0gImxwMzk3NC1ydGMiLAorCX0sCit9OworCiBpbnQgbWF4ODk5OF9yZWFkX3JlZyhzdHJ1Y3QgaTJjX2NsaWVudCAqaTJjLCB1OCByZWcsIHU4ICpkZXN0KQogewogCXN0cnVjdCBtYXg4OTk4X2RldiAqbWF4ODk5OCA9IGkyY19nZXRfY2xpZW50ZGF0YShpMmMpOwpAQCAtMTM1LDYgKzE0NSw3IEBACiAJaWYgKHBkYXRhKSB7CiAJCW1heDg5OTgtPm9ubyA9IHBkYXRhLT5vbm87CiAJCW1heDg5OTgtPmlycV9iYXNlID0gcGRhdGEtPmlycV9iYXNlOworCQltYXg4OTk4LT53YWtldXAgPSBwZGF0YS0+d2FrZXVwOwogCX0KIAltdXRleF9pbml0KCZtYXg4OTk4LT5pb2xvY2spOwogCkBAIC0xNDMsOSArMTU0LDIzIEBACiAKIAltYXg4OTk4X2lycV9pbml0KG1heDg5OTgpOwogCi0JcmV0ID0gbWZkX2FkZF9kZXZpY2VzKG1heDg5OTgtPmRldiwgLTEsCi0JCQkgICAgICBtYXg4OTk4X2RldnMsIEFSUkFZX1NJWkUobWF4ODk5OF9kZXZzKSwKLQkJCSAgICAgIE5VTEwsIDApOworCXBtX3J1bnRpbWVfc2V0X2FjdGl2ZShtYXg4OTk4LT5kZXYpOworCisJc3dpdGNoIChpZC0+ZHJpdmVyX2RhdGEpIHsKKwljYXNlIFRZUEVfTFAzOTc0OgorCQlyZXQgPSBtZmRfYWRkX2RldmljZXMobWF4ODk5OC0+ZGV2LCAtMSwKKwkJCQlscDM5NzRfZGV2cywgQVJSQVlfU0laRShscDM5NzRfZGV2cyksCisJCQkJTlVMTCwgMCk7CisJCWJyZWFrOworCWNhc2UgVFlQRV9NQVg4OTk4OgorCQlyZXQgPSBtZmRfYWRkX2RldmljZXMobWF4ODk5OC0+ZGV2LCAtMSwKKwkJCQltYXg4OTk4X2RldnMsIEFSUkFZX1NJWkUobWF4ODk5OF9kZXZzKSwKKwkJCQlOVUxMLCAwKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcmV0ID0gLUVJTlZBTDsKKwl9CisKIAlpZiAocmV0IDwgMCkKIAkJZ290byBlcnI7CiAKQEAgLTE3OCwxMCArMjAzLDExMyBAQAogfTsKIE1PRFVMRV9ERVZJQ0VfVEFCTEUoaTJjLCBtYXg4OTk4X2kyY19pZCk7CiAKK3N0YXRpYyBpbnQgbWF4ODk5OF9zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgaTJjX2NsaWVudCAqaTJjID0gY29udGFpbmVyX29mKGRldiwgc3RydWN0IGkyY19jbGllbnQsIGRldik7CisJc3RydWN0IG1heDg5OThfZGV2ICptYXg4OTk4ID0gaTJjX2dldF9jbGllbnRkYXRhKGkyYyk7CisKKwlpZiAobWF4ODk5OC0+d2FrZXVwKQorCQlzZXRfaXJxX3dha2UobWF4ODk5OC0+aXJxLCAxKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBtYXg4OTk4X3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IGkyY19jbGllbnQgKmkyYyA9IGNvbnRhaW5lcl9vZihkZXYsIHN0cnVjdCBpMmNfY2xpZW50LCBkZXYpOworCXN0cnVjdCBtYXg4OTk4X2RldiAqbWF4ODk5OCA9IGkyY19nZXRfY2xpZW50ZGF0YShpMmMpOworCisJaWYgKG1heDg5OTgtPndha2V1cCkKKwkJc2V0X2lycV93YWtlKG1heDg5OTgtPmlycSwgMCk7CisJLyoKKwkgKiBJbiBMUDM5NzQsIGlmIElSUSByZWdpc3RlcnMgYXJlIG5vdCAicmVhZCAmIGNsZWFyIgorCSAqIHdoZW4gaXQncyBzZXQgZHVyaW5nIHNsZWVwLCB0aGUgaW50ZXJydXB0IGJlY29tZXMKKwkgKiBkaXNhYmxlZC4KKwkgKi8KKwlyZXR1cm4gbWF4ODk5OF9pcnFfcmVzdW1lKGkyY19nZXRfY2xpZW50ZGF0YShpMmMpKTsKK30KKworc3RydWN0IG1heDg5OThfcmVnX2R1bXAgeworCXU4CWFkZHI7CisJdTgJdmFsOworfTsKKyNkZWZpbmUgU0FWRV9JVEVNKHgpCXsgLmFkZHIgPSAoeCksIC52YWwgPSAweDAsIH0KK3N0cnVjdCBtYXg4OTk4X3JlZ19kdW1wIG1heDg5OThfZHVtcFtdID0geworCVNBVkVfSVRFTShNQVg4OTk4X1JFR19JUlFNMSksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX0lSUU0yKSwKKwlTQVZFX0lURU0oTUFYODk5OF9SRUdfSVJRTTMpLAorCVNBVkVfSVRFTShNQVg4OTk4X1JFR19JUlFNNCksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX1NUQVRVU00xKSwKKwlTQVZFX0lURU0oTUFYODk5OF9SRUdfU1RBVFVTTTIpLAorCVNBVkVfSVRFTShNQVg4OTk4X1JFR19DSEdSMSksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX0NIR1IyKSwKKwlTQVZFX0lURU0oTUFYODk5OF9SRUdfTERPX0FDVElWRV9ESVNDSEFSR0UxKSwKKwlTQVZFX0lURU0oTUFYODk5OF9SRUdfTERPX0FDVElWRV9ESVNDSEFSR0UxKSwKKwlTQVZFX0lURU0oTUFYODk5OF9SRUdfQlVDS19BQ1RJVkVfRElTQ0hBUkdFMyksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX09OT0ZGMSksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX09OT0ZGMiksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX09OT0ZGMyksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX09OT0ZGNCksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX0JVQ0sxX1ZPTFRBR0UxKSwKKwlTQVZFX0lURU0oTUFYODk5OF9SRUdfQlVDSzFfVk9MVEFHRTIpLAorCVNBVkVfSVRFTShNQVg4OTk4X1JFR19CVUNLMV9WT0xUQUdFMyksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX0JVQ0sxX1ZPTFRBR0U0KSwKKwlTQVZFX0lURU0oTUFYODk5OF9SRUdfQlVDSzJfVk9MVEFHRTEpLAorCVNBVkVfSVRFTShNQVg4OTk4X1JFR19CVUNLMl9WT0xUQUdFMiksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX0xETzJfTERPMyksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX0xETzQpLAorCVNBVkVfSVRFTShNQVg4OTk4X1JFR19MRE81KSwKKwlTQVZFX0lURU0oTUFYODk5OF9SRUdfTERPNiksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX0xETzcpLAorCVNBVkVfSVRFTShNQVg4OTk4X1JFR19MRE84X0xETzkpLAorCVNBVkVfSVRFTShNQVg4OTk4X1JFR19MRE8xMF9MRE8xMSksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX0xETzEyKSwKKwlTQVZFX0lURU0oTUFYODk5OF9SRUdfTERPMTMpLAorCVNBVkVfSVRFTShNQVg4OTk4X1JFR19MRE8xNCksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX0xETzE1KSwKKwlTQVZFX0lURU0oTUFYODk5OF9SRUdfTERPMTYpLAorCVNBVkVfSVRFTShNQVg4OTk4X1JFR19MRE8xNyksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX0JLQ0hSKSwKKwlTQVZFX0lURU0oTUFYODk5OF9SRUdfTEJDTkZHMSksCisJU0FWRV9JVEVNKE1BWDg5OThfUkVHX0xCQ05GRzIpLAorfTsKKy8qIFNhdmUgcmVnaXN0ZXJzIGJlZm9yZSBoaWJlcm5hdGlvbiAqLworc3RhdGljIGludCBtYXg4OTk4X2ZyZWV6ZShzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IGkyY19jbGllbnQgKmkyYyA9IGNvbnRhaW5lcl9vZihkZXYsIHN0cnVjdCBpMmNfY2xpZW50LCBkZXYpOworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUobWF4ODk5OF9kdW1wKTsgaSsrKQorCQltYXg4OTk4X3JlYWRfcmVnKGkyYywgbWF4ODk5OF9kdW1wW2ldLmFkZHIsCisJCQkJJm1heDg5OThfZHVtcFtpXS52YWwpOworCisJcmV0dXJuIDA7Cit9CisKKy8qIFJlc3RvcmUgcmVnaXN0ZXJzIGFmdGVyIGhpYmVybmF0aW9uICovCitzdGF0aWMgaW50IG1heDg5OThfcmVzdG9yZShzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IGkyY19jbGllbnQgKmkyYyA9IGNvbnRhaW5lcl9vZihkZXYsIHN0cnVjdCBpMmNfY2xpZW50LCBkZXYpOworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUobWF4ODk5OF9kdW1wKTsgaSsrKQorCQltYXg4OTk4X3dyaXRlX3JlZyhpMmMsIG1heDg5OThfZHVtcFtpXS5hZGRyLAorCQkJCW1heDg5OThfZHVtcFtpXS52YWwpOworCisJcmV0dXJuIDA7Cit9CisKK2NvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIG1heDg5OThfcG0gPSB7CisJLnN1c3BlbmQgPSBtYXg4OTk4X3N1c3BlbmQsCisJLnJlc3VtZSA9IG1heDg5OThfcmVzdW1lLAorCS5mcmVlemUgPSBtYXg4OTk4X2ZyZWV6ZSwKKwkucmVzdG9yZSA9IG1heDg5OThfcmVzdG9yZSwKK307CisKIHN0YXRpYyBzdHJ1Y3QgaTJjX2RyaXZlciBtYXg4OTk4X2kyY19kcml2ZXIgPSB7CiAJLmRyaXZlciA9IHsKIAkJICAgLm5hbWUgPSAibWF4ODk5OCIsCiAJCSAgIC5vd25lciA9IFRISVNfTU9EVUxFLAorCQkgICAucG0gPSAmbWF4ODk5OF9wbSwKIAl9LAogCS5wcm9iZSA9IG1heDg5OThfaTJjX3Byb2JlLAogCS5yZW1vdmUgPSBtYXg4OTk4X2kyY19yZW1vdmUsCmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC9tYzEzeHh4LWNvcmUuYyBiL2RyaXZlcnMvbWZkL21jMTN4eHgtY29yZS5jCmluZGV4IGEyYWMyZWQuLmI5ZmNhZjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL21jMTN4eHgtY29yZS5jCisrKyBiL2RyaXZlcnMvbWZkL21jMTN4eHgtY29yZS5jCkBAIC03NDksNyArNzQ5LDcgQEAKIAlpZiAocmV0KSB7CiBlcnJfbWFzazoKIGVycl9yZXZpc2lvbjoKLQkJbXV0ZXhfdW5sb2NrKCZtYzEzeHh4LT5sb2NrKTsKKwkJbWMxM3h4eF91bmxvY2sobWMxM3h4eCk7CiAJCWRldl9zZXRfZHJ2ZGF0YSgmc3BpLT5kZXYsIE5VTEwpOwogCQlrZnJlZShtYzEzeHh4KTsKIAkJcmV0dXJuIHJldDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL21mZC1jb3JlLmMgYi9kcml2ZXJzL21mZC9tZmQtY29yZS5jCmluZGV4IGVjOTlmNjguLmQ4M2FkMGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL21mZC1jb3JlLmMKKysrIGIvZHJpdmVycy9tZmQvbWZkLWNvcmUuYwpAQCAtMTUsNiArMTUsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgogI2luY2x1ZGUgPGxpbnV4L2FjcGkuaD4KICNpbmNsdWRlIDxsaW51eC9tZmQvY29yZS5oPgorI2luY2x1ZGUgPGxpbnV4L3BtX3J1bnRpbWUuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAKIHN0YXRpYyBpbnQgbWZkX2FkZF9kZXZpY2Uoc3RydWN0IGRldmljZSAqcGFyZW50LCBpbnQgaWQsCkBAIC04Miw2ICs4Myw5IEBACiAJaWYgKHJldCkKIAkJZ290byBmYWlsX3JlczsKIAorCWlmIChjZWxsLT5wbV9ydW50aW1lX25vX2NhbGxiYWNrcykKKwkJcG1fcnVudGltZV9ub19jYWxsYmFja3MoJnBkZXYtPmRldik7CisKIAlrZnJlZShyZXMpOwogCiAJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC9zbTUwMS5jIGIvZHJpdmVycy9tZmQvc201MDEuYwppbmRleCBiYzkyNzVjLi41ZGUzYTc2IDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC9zbTUwMS5jCisrKyBiL2RyaXZlcnMvbWZkL3NtNTAxLmMKQEAgLTI2LDcgKzI2LDcgQEAKICNpbmNsdWRlIDxsaW51eC9zbTUwMS1yZWdzLmg+CiAjaW5jbHVkZSA8bGludXgvc2VyaWFsXzgyNTAuaD4KIAotI2luY2x1ZGUgPGFzbS9pby5oPgorI2luY2x1ZGUgPGxpbnV4L2lvLmg+CiAKIHN0cnVjdCBzbTUwMV9kZXZpY2UgewogCXN0cnVjdCBsaXN0X2hlYWQJCWxpc3Q7CkBAIC03NDUsMTEgKzc0NSw4IEBACiAJaW50IHJldDsKIAogCWZvciAocHRyID0gMDsgcHRyIDwgcGRldi0+bnVtX3Jlc291cmNlczsgcHRyKyspIHsKLQkJcHJpbnRrKEtFUk5fREVCVUcgIiVzWyVkXSBmbGFncyAlMDhseDogJTA4bGx4Li4lMDhsbHhcbiIsCi0JCSAgICAgICBwZGV2LT5uYW1lLCBwdHIsCi0JCSAgICAgICBwZGV2LT5yZXNvdXJjZVtwdHJdLmZsYWdzLAotCQkgICAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylwZGV2LT5yZXNvdXJjZVtwdHJdLnN0YXJ0LAotCQkgICAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylwZGV2LT5yZXNvdXJjZVtwdHJdLmVuZCk7CisJCXByaW50ayhLRVJOX0RFQlVHICIlc1slZF0gJXBSXG4iLAorCQkgICAgICAgcGRldi0+bmFtZSwgcHRyLCAmcGRldi0+cmVzb3VyY2VbcHRyXSk7CiAJfQogCiAJcmV0ID0gcGxhdGZvcm1fZGV2aWNlX3JlZ2lzdGVyKHBkZXYpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvc3RtcGUuYyBiL2RyaXZlcnMvbWZkL3N0bXBlLmMKaW5kZXggYjExNDg3Zi4uM2U1NzMyYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZmQvc3RtcGUuYworKysgYi9kcml2ZXJzL21mZC9zdG1wZS5jCkBAIC02OTksMTYgKzY5OSwxNiBAQAogCXJldHVybiBJUlFfSEFORExFRDsKIH0KIAotc3RhdGljIHZvaWQgc3RtcGVfaXJxX2xvY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHN0bXBlX2lycV9sb2NrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3Qgc3RtcGUgKnN0bXBlID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3Qgc3RtcGUgKnN0bXBlID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CiAKIAltdXRleF9sb2NrKCZzdG1wZS0+aXJxX2xvY2spOwogfQogCi1zdGF0aWMgdm9pZCBzdG1wZV9pcnFfc3luY191bmxvY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHN0bXBlX2lycV9zeW5jX3VubG9jayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IHN0bXBlICpzdG1wZSA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IHN0bXBlICpzdG1wZSA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCXN0cnVjdCBzdG1wZV92YXJpYW50X2luZm8gKnZhcmlhbnQgPSBzdG1wZS0+dmFyaWFudDsKIAlpbnQgbnVtID0gRElWX1JPVU5EX1VQKHZhcmlhbnQtPm51bV9pcnFzLCA4KTsKIAlpbnQgaTsKQEAgLTcyNywyMCArNzI3LDIwIEBACiAJbXV0ZXhfdW5sb2NrKCZzdG1wZS0+aXJxX2xvY2spOwogfQogCi1zdGF0aWMgdm9pZCBzdG1wZV9pcnFfbWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc3RtcGVfaXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBzdG1wZSAqc3RtcGUgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOwotCWludCBvZmZzZXQgPSBpcnEgLSBzdG1wZS0+aXJxX2Jhc2U7CisJc3RydWN0IHN0bXBlICpzdG1wZSA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOworCWludCBvZmZzZXQgPSBkYXRhLT5pcnEgLSBzdG1wZS0+aXJxX2Jhc2U7CiAJaW50IHJlZ29mZnNldCA9IG9mZnNldCAvIDg7CiAJaW50IG1hc2sgPSAxIDw8IChvZmZzZXQgJSA4KTsKIAogCXN0bXBlLT5pZXJbcmVnb2Zmc2V0XSAmPSB+bWFzazsKIH0KIAotc3RhdGljIHZvaWQgc3RtcGVfaXJxX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgc3RtcGVfaXJxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IHN0bXBlICpzdG1wZSA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7Ci0JaW50IG9mZnNldCA9IGlycSAtIHN0bXBlLT5pcnFfYmFzZTsKKwlzdHJ1Y3Qgc3RtcGUgKnN0bXBlID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CisJaW50IG9mZnNldCA9IGRhdGEtPmlycSAtIHN0bXBlLT5pcnFfYmFzZTsKIAlpbnQgcmVnb2Zmc2V0ID0gb2Zmc2V0IC8gODsKIAlpbnQgbWFzayA9IDEgPDwgKG9mZnNldCAlIDgpOwogCkBAIC03NDksMTAgKzc0OSwxMCBAQAogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHN0bXBlX2lycV9jaGlwID0gewogCS5uYW1lCQkJPSAic3RtcGUiLAotCS5idXNfbG9jawkJPSBzdG1wZV9pcnFfbG9jaywKLQkuYnVzX3N5bmNfdW5sb2NrCT0gc3RtcGVfaXJxX3N5bmNfdW5sb2NrLAotCS5tYXNrCQkJPSBzdG1wZV9pcnFfbWFzaywKLQkudW5tYXNrCQkJPSBzdG1wZV9pcnFfdW5tYXNrLAorCS5pcnFfYnVzX2xvY2sJCT0gc3RtcGVfaXJxX2xvY2ssCisJLmlycV9idXNfc3luY191bmxvY2sJPSBzdG1wZV9pcnFfc3luY191bmxvY2ssCisJLmlycV9tYXNrCQk9IHN0bXBlX2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCQk9IHN0bXBlX2lycV91bm1hc2ssCiB9OwogCiBzdGF0aWMgaW50IF9fZGV2aW5pdCBzdG1wZV9pcnFfaW5pdChzdHJ1Y3Qgc3RtcGUgKnN0bXBlKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvdDdsNjZ4Yi5jIGIvZHJpdmVycy9tZmQvdDdsNjZ4Yi5jCmluZGV4IDAwNmMxMjEuLjljYWViNGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL3Q3bDY2eGIuYworKysgYi9kcml2ZXJzL21mZC90N2w2NnhiLmMKQEAgLTE5OSwzNyArMTk5LDM3IEBACiAJCQkJZ2VuZXJpY19oYW5kbGVfaXJxKGlycV9iYXNlICsgaSk7CiB9CiAKLXN0YXRpYyB2b2lkIHQ3bDY2eGJfaXJxX21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHQ3bDY2eGJfaXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCB0N2w2NnhiICp0N2w2NnhiID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgdDdsNjZ4YiAqdDdsNjZ4YiA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCXVuc2lnbmVkIGxvbmcJCQlmbGFnczsKIAl1OCBpbXI7CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmdDdsNjZ4Yi0+bG9jaywgZmxhZ3MpOwogCWltciA9IHRtaW9faW9yZWFkOCh0N2w2NnhiLT5zY3IgKyBTQ1JfSU1SKTsKLQlpbXIgfD0gMSA8PCAoaXJxIC0gdDdsNjZ4Yi0+aXJxX2Jhc2UpOworCWltciB8PSAxIDw8IChkYXRhLT5pcnEgLSB0N2w2NnhiLT5pcnFfYmFzZSk7CiAJdG1pb19pb3dyaXRlOChpbXIsIHQ3bDY2eGItPnNjciArIFNDUl9JTVIpOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnQ3bDY2eGItPmxvY2ssIGZsYWdzKTsKIH0KIAotc3RhdGljIHZvaWQgdDdsNjZ4Yl9pcnFfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB0N2w2NnhiX2lycV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCB0N2w2NnhiICp0N2w2NnhiID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgdDdsNjZ4YiAqdDdsNjZ4YiA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJdTggaW1yOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJnQ3bDY2eGItPmxvY2ssIGZsYWdzKTsKIAlpbXIgPSB0bWlvX2lvcmVhZDgodDdsNjZ4Yi0+c2NyICsgU0NSX0lNUik7Ci0JaW1yICY9IH4oMSA8PCAoaXJxIC0gdDdsNjZ4Yi0+aXJxX2Jhc2UpKTsKKwlpbXIgJj0gfigxIDw8IChkYXRhLT5pcnEgLSB0N2w2NnhiLT5pcnFfYmFzZSkpOwogCXRtaW9faW93cml0ZTgoaW1yLCB0N2w2NnhiLT5zY3IgKyBTQ1JfSU1SKTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ0N2w2NnhiLT5sb2NrLCBmbGFncyk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgdDdsNjZ4Yl9jaGlwID0gewotCS5uYW1lCT0gInQ3bDY2eGIiLAotCS5hY2sJPSB0N2w2NnhiX2lycV9tYXNrLAotCS5tYXNrCT0gdDdsNjZ4Yl9pcnFfbWFzaywKLQkudW5tYXNrCT0gdDdsNjZ4Yl9pcnFfdW5tYXNrLAorCS5uYW1lCQk9ICJ0N2w2NnhiIiwKKwkuaXJxX2Fjawk9IHQ3bDY2eGJfaXJxX21hc2ssCisJLmlycV9tYXNrCT0gdDdsNjZ4Yl9pcnFfbWFzaywKKwkuaXJxX3VubWFzawk9IHQ3bDY2eGJfaXJxX3VubWFzaywKIH07CiAKIC8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvdGM2MzkzeGIuYyBiL2RyaXZlcnMvbWZkL3RjNjM5M3hiLmMKaW5kZXggMWVhODBkOGEuLjlhMjM4NjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL3RjNjM5M3hiLmMKKysrIGIvZHJpdmVycy9tZmQvdGM2MzkzeGIuYwpAQCAtNTI3LDQxICs1MjcsNDEgQEAKIAkJfQogfQogCi1zdGF0aWMgdm9pZCB0YzYzOTN4Yl9pcnFfYWNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB0YzYzOTN4Yl9pcnFfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKIH0KIAotc3RhdGljIHZvaWQgdGM2MzkzeGJfaXJxX21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHRjNjM5M3hiX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3QgdGM2MzkzeGIgKnRjNjM5M3hiID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3QgdGM2MzkzeGIgKnRjNjM5M3hiID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAl1OCBpbXI7CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmdGM2MzkzeGItPmxvY2ssIGZsYWdzKTsKIAlpbXIgPSB0bWlvX2lvcmVhZDgodGM2MzkzeGItPnNjciArIFNDUl9JTVIpOwotCWltciB8PSAxIDw8IChpcnEgLSB0YzYzOTN4Yi0+aXJxX2Jhc2UpOworCWltciB8PSAxIDw8IChkYXRhLT5pcnEgLSB0YzYzOTN4Yi0+aXJxX2Jhc2UpOwogCXRtaW9faW93cml0ZTgoaW1yLCB0YzYzOTN4Yi0+c2NyICsgU0NSX0lNUik7CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmdGM2MzkzeGItPmxvY2ssIGZsYWdzKTsKIH0KIAotc3RhdGljIHZvaWQgdGM2MzkzeGJfaXJxX3VubWFzayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgdGM2MzkzeGJfaXJxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IHRjNjM5M3hiICp0YzYzOTN4YiA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IHRjNjM5M3hiICp0YzYzOTN4YiA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJdTggaW1yOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJnRjNjM5M3hiLT5sb2NrLCBmbGFncyk7CiAJaW1yID0gdG1pb19pb3JlYWQ4KHRjNjM5M3hiLT5zY3IgKyBTQ1JfSU1SKTsKLQlpbXIgJj0gfigxIDw8IChpcnEgLSB0YzYzOTN4Yi0+aXJxX2Jhc2UpKTsKKwlpbXIgJj0gfigxIDw8IChkYXRhLT5pcnEgLSB0YzYzOTN4Yi0+aXJxX2Jhc2UpKTsKIAl0bWlvX2lvd3JpdGU4KGltciwgdGM2MzkzeGItPnNjciArIFNDUl9JTVIpOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnRjNjM5M3hiLT5sb2NrLCBmbGFncyk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgdGM2MzkzeGJfY2hpcCA9IHsKLQkubmFtZQk9ICJ0YzYzOTN4YiIsCi0JLmFjawk9IHRjNjM5M3hiX2lycV9hY2ssCi0JLm1hc2sJPSB0YzYzOTN4Yl9pcnFfbWFzaywKLQkudW5tYXNrCT0gdGM2MzkzeGJfaXJxX3VubWFzaywKKwkubmFtZQkJPSAidGM2MzkzeGIiLAorCS5pcnFfYWNrCT0gdGM2MzkzeGJfaXJxX2FjaywKKwkuaXJxX21hc2sJPSB0YzYzOTN4Yl9pcnFfbWFzaywKKwkuaXJxX3VubWFzawk9IHRjNjM5M3hiX2lycV91bm1hc2ssCiB9OwogCiBzdGF0aWMgdm9pZCB0YzYzOTN4Yl9hdHRhY2hfaXJxKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKmRldikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL3RwczY1MDEwLmMgYi9kcml2ZXJzL21mZC90cHM2NTAxMC5jCmluZGV4IDkwMTg3ZmUuLjkzZDVmZGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL3RwczY1MDEwLmMKKysrIGIvZHJpdmVycy9tZmQvdHBzNjUwMTAuYwpAQCAtMzQsNyArMzQsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvaTJjL3RwczY1MDEwLmg+CiAKLSNpbmNsdWRlIDxhc20vZ3Bpby5oPgorI2luY2x1ZGUgPGxpbnV4L2dwaW8uaD4KIAogCiAvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvdHBzNjU4NnguYyBiL2RyaXZlcnMvbWZkL3RwczY1ODZ4LmMKaW5kZXggYjQ5MzFhYi4uNjI3Y2Y1NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZmQvdHBzNjU4NnguYworKysgYi9kcml2ZXJzL21mZC90cHM2NTg2eC5jCkBAIC00Niw4ICs0Niw2IEBACiAKIC8qIGRldmljZSBpZCAqLwogI2RlZmluZSBUUFM2NTg2WF9WRVJTSU9OQ1JDCTB4Y2QKLSNkZWZpbmUgVFBTNjU4NjIxQV9WRVJTSU9OQ1JDCTB4MTUKLSNkZWZpbmUgVFBTNjU4NjIxQ19WRVJTSU9OQ1JDCTB4MmMKIAogc3RydWN0IHRwczY1ODZ4X2lycV9kYXRhIHsKIAl1OAltYXNrX3JlZzsKQEAgLTMyNSwzNyArMzIzLDM3IEBACiAJcmV0dXJuIGRldmljZV9mb3JfZWFjaF9jaGlsZCh0cHM2NTg2eC0+ZGV2LCBOVUxMLCBfX3JlbW92ZV9zdWJkZXYpOwogfQogCi1zdGF0aWMgdm9pZCB0cHM2NTg2eF9pcnFfbG9jayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgdHBzNjU4NnhfaXJxX2xvY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCB0cHM2NTg2eCAqdHBzNjU4NnggPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCB0cHM2NTg2eCAqdHBzNjU4NnggPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKIAogCW11dGV4X2xvY2soJnRwczY1ODZ4LT5pcnFfbG9jayk7CiB9CiAKLXN0YXRpYyB2b2lkIHRwczY1ODZ4X2lycV9lbmFibGUodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHRwczY1ODZ4X2lycV9lbmFibGUoc3RydWN0IGlycV9kYXRhICppcnFfZGF0YSkKIHsKLQlzdHJ1Y3QgdHBzNjU4NnggKnRwczY1ODZ4ID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQl1bnNpZ25lZCBpbnQgX19pcnEgPSBpcnEgLSB0cHM2NTg2eC0+aXJxX2Jhc2U7CisJc3RydWN0IHRwczY1ODZ4ICp0cHM2NTg2eCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGlycV9kYXRhKTsKKwl1bnNpZ25lZCBpbnQgX19pcnEgPSBpcnFfZGF0YS0+aXJxIC0gdHBzNjU4NngtPmlycV9iYXNlOwogCWNvbnN0IHN0cnVjdCB0cHM2NTg2eF9pcnFfZGF0YSAqZGF0YSA9ICZ0cHM2NTg2eF9pcnFzW19faXJxXTsKIAogCXRwczY1ODZ4LT5tYXNrX3JlZ1tkYXRhLT5tYXNrX3JlZ10gJj0gfmRhdGEtPm1hc2tfbWFzazsKIAl0cHM2NTg2eC0+aXJxX2VuIHw9ICgxIDw8IF9faXJxKTsKIH0KIAotc3RhdGljIHZvaWQgdHBzNjU4NnhfaXJxX2Rpc2FibGUodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHRwczY1ODZ4X2lycV9kaXNhYmxlKHN0cnVjdCBpcnFfZGF0YSAqaXJxX2RhdGEpCiB7Ci0Jc3RydWN0IHRwczY1ODZ4ICp0cHM2NTg2eCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IHRwczY1ODZ4ICp0cHM2NTg2eCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGlycV9kYXRhKTsKIAotCXVuc2lnbmVkIGludCBfX2lycSA9IGlycSAtIHRwczY1ODZ4LT5pcnFfYmFzZTsKKwl1bnNpZ25lZCBpbnQgX19pcnEgPSBpcnFfZGF0YS0+aXJxIC0gdHBzNjU4NngtPmlycV9iYXNlOwogCWNvbnN0IHN0cnVjdCB0cHM2NTg2eF9pcnFfZGF0YSAqZGF0YSA9ICZ0cHM2NTg2eF9pcnFzW19faXJxXTsKIAogCXRwczY1ODZ4LT5tYXNrX3JlZ1tkYXRhLT5tYXNrX3JlZ10gfD0gZGF0YS0+bWFza19tYXNrOwogCXRwczY1ODZ4LT5pcnFfZW4gJj0gfigxIDw8IF9faXJxKTsKIH0KIAotc3RhdGljIHZvaWQgdHBzNjU4NnhfaXJxX3N5bmNfdW5sb2NrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB0cHM2NTg2eF9pcnFfc3luY191bmxvY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCB0cHM2NTg2eCAqdHBzNjU4NnggPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCB0cHM2NTg2eCAqdHBzNjU4NnggPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKIAlpbnQgaTsKIAogCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHRwczY1ODZ4LT5tYXNrX3JlZyk7IGkrKykgewpAQCAtNDIxLDEwICs0MTksMTAgQEAKIAl0cHM2NTg2eC0+aXJxX2Jhc2UgPSBpcnFfYmFzZTsKIAogCXRwczY1ODZ4LT5pcnFfY2hpcC5uYW1lID0gInRwczY1ODZ4IjsKLQl0cHM2NTg2eC0+aXJxX2NoaXAuZW5hYmxlID0gdHBzNjU4NnhfaXJxX2VuYWJsZTsKLQl0cHM2NTg2eC0+aXJxX2NoaXAuZGlzYWJsZSA9IHRwczY1ODZ4X2lycV9kaXNhYmxlOwotCXRwczY1ODZ4LT5pcnFfY2hpcC5idXNfbG9jayA9IHRwczY1ODZ4X2lycV9sb2NrOwotCXRwczY1ODZ4LT5pcnFfY2hpcC5idXNfc3luY191bmxvY2sgPSB0cHM2NTg2eF9pcnFfc3luY191bmxvY2s7CisJdHBzNjU4NngtPmlycV9jaGlwLmlycV9lbmFibGUgPSB0cHM2NTg2eF9pcnFfZW5hYmxlOworCXRwczY1ODZ4LT5pcnFfY2hpcC5pcnFfZGlzYWJsZSA9IHRwczY1ODZ4X2lycV9kaXNhYmxlOworCXRwczY1ODZ4LT5pcnFfY2hpcC5pcnFfYnVzX2xvY2sgPSB0cHM2NTg2eF9pcnFfbG9jazsKKwl0cHM2NTg2eC0+aXJxX2NoaXAuaXJxX2J1c19zeW5jX3VubG9jayA9IHRwczY1ODZ4X2lycV9zeW5jX3VubG9jazsKIAogCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHRwczY1ODZ4X2lycXMpOyBpKyspIHsKIAkJaW50IF9faXJxID0gaSArIHRwczY1ODZ4LT5pcnFfYmFzZTsKQEAgLTQ5OCwxMSArNDk2LDcgQEAKIAkJcmV0dXJuIC1FSU87CiAJfQogCi0JaWYgKChyZXQgIT0gVFBTNjU4NjIxQV9WRVJTSU9OQ1JDKSAmJgotCSAgICAocmV0ICE9IFRQUzY1ODYyMUNfVkVSU0lPTkNSQykpIHsKLQkJZGV2X2VycigmY2xpZW50LT5kZXYsICJVbnN1cHBvcnRlZCBjaGlwIElEOiAleFxuIiwgcmV0KTsKLQkJcmV0dXJuIC1FTk9ERVY7Ci0JfQorCWRldl9pbmZvKCZjbGllbnQtPmRldiwgIlZFUlNJT05DUkMgaXMgJTAyeFxuIiwgcmV0KTsKIAogCXRwczY1ODZ4ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHRwczY1ODZ4KSwgR0ZQX0tFUk5FTCk7CiAJaWYgKHRwczY1ODZ4ID09IE5VTEwpCmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC90d2wtY29yZS5jIGIvZHJpdmVycy9tZmQvdHdsLWNvcmUuYwppbmRleCAxMmFiZDViLi5hMzVmYTdkYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZmQvdHdsLWNvcmUuYworKysgYi9kcml2ZXJzL21mZC90d2wtY29yZS5jCkBAIC0xMDAzLDcgKzEwMDMsNyBAQAogfQogCiAvKiBOT1RFOiAgdGhpcyBkcml2ZXIgb25seSBoYW5kbGVzIGEgc2luZ2xlIHR3bDQwMzAvdHBzNjU5eDAgY2hpcCAqLwotc3RhdGljIGludCBfX2luaXQKK3N0YXRpYyBpbnQgX19kZXZpbml0CiB0d2xfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgKmlkKQogewogCWludAkJCQlzdGF0dXM7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC90d2w0MDMwLWlycS5jIGIvZHJpdmVycy9tZmQvdHdsNDAzMC1pcnEuYwppbmRleCA1ZDNhMTQ3Li42M2EzMGU4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC90d2w0MDMwLWlycS5jCisrKyBiL2RyaXZlcnMvbWZkL3R3bDQwMzAtaXJxLmMKQEAgLTU5OSwzOCArNTk5LDM4IEBACiAgKiBjb21wbGV0aW9uLCBwb3RlbnRpYWxseSBpbmNsdWRpbmcgc29tZSByZS1vcmRlcmluZywgb2YgdGhlc2UgcmVxdWVzdHMuCiAgKi8KIAotc3RhdGljIHZvaWQgdHdsNDAzMF9zaWhfbWFzayh1bnNpZ25lZCBpcnEpCitzdGF0aWMgdm9pZCB0d2w0MDMwX3NpaF9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3Qgc2loX2FnZW50ICpzaWggPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCBzaWhfYWdlbnQgKnNpaCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmc2loX2FnZW50X2xvY2ssIGZsYWdzKTsKLQlzaWgtPmltciB8PSBCSVQoaXJxIC0gc2loLT5pcnFfYmFzZSk7CisJc2loLT5pbXIgfD0gQklUKGRhdGEtPmlycSAtIHNpaC0+aXJxX2Jhc2UpOwogCXNpaC0+aW1yX2NoYW5nZV9wZW5kaW5nID0gdHJ1ZTsKIAlxdWV1ZV93b3JrKHdxLCAmc2loLT5tYXNrX3dvcmspOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNpaF9hZ2VudF9sb2NrLCBmbGFncyk7CiB9CiAKLXN0YXRpYyB2b2lkIHR3bDQwMzBfc2loX3VubWFzayh1bnNpZ25lZCBpcnEpCitzdGF0aWMgdm9pZCB0d2w0MDMwX3NpaF91bm1hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCBzaWhfYWdlbnQgKnNpaCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IHNpaF9hZ2VudCAqc2loID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZzaWhfYWdlbnRfbG9jaywgZmxhZ3MpOwotCXNpaC0+aW1yICY9IH5CSVQoaXJxIC0gc2loLT5pcnFfYmFzZSk7CisJc2loLT5pbXIgJj0gfkJJVChkYXRhLT5pcnEgLSBzaWgtPmlycV9iYXNlKTsKIAlzaWgtPmltcl9jaGFuZ2VfcGVuZGluZyA9IHRydWU7CiAJcXVldWVfd29yayh3cSwgJnNpaC0+bWFza193b3JrKTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzaWhfYWdlbnRfbG9jaywgZmxhZ3MpOwogfQogCi1zdGF0aWMgaW50IHR3bDQwMzBfc2loX3NldF90eXBlKHVuc2lnbmVkIGlycSwgdW5zaWduZWQgdHJpZ2dlcikKK3N0YXRpYyBpbnQgdHdsNDAzMF9zaWhfc2V0X3R5cGUoc3RydWN0IGlycV9kYXRhICpkYXRhLCB1bnNpZ25lZCB0cmlnZ2VyKQogewotCXN0cnVjdCBzaWhfYWdlbnQgKnNpaCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7Ci0Jc3RydWN0IGlycV9kZXNjICpkZXNjID0gaXJxX3RvX2Rlc2MoaXJxKTsKKwlzdHJ1Y3Qgc2loX2FnZW50ICpzaWggPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKKwlzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MgPSBpcnFfdG9fZGVzYyhkYXRhLT5pcnEpOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKIAlpZiAoIWRlc2MpIHsKLQkJcHJfZXJyKCJ0d2w0MDMwOiBJbnZhbGlkIElSUTogJWRcbiIsIGlycSk7CisJCXByX2VycigidHdsNDAzMDogSW52YWxpZCBJUlE6ICVkXG4iLCBkYXRhLT5pcnEpOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKQEAgLTY0MSw3ICs2NDEsNyBAQAogCWlmICgoZGVzYy0+c3RhdHVzICYgSVJRX1RZUEVfU0VOU0VfTUFTSykgIT0gdHJpZ2dlcikgewogCQlkZXNjLT5zdGF0dXMgJj0gfklSUV9UWVBFX1NFTlNFX01BU0s7CiAJCWRlc2MtPnN0YXR1cyB8PSB0cmlnZ2VyOwotCQlzaWgtPmVkZ2VfY2hhbmdlIHw9IEJJVChpcnEgLSBzaWgtPmlycV9iYXNlKTsKKwkJc2loLT5lZGdlX2NoYW5nZSB8PSBCSVQoZGF0YS0+aXJxIC0gc2loLT5pcnFfYmFzZSk7CiAJCXF1ZXVlX3dvcmsod3EsICZzaWgtPmVkZ2Vfd29yayk7CiAJfQogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNpaF9hZ2VudF9sb2NrLCBmbGFncyk7CkBAIC02NTAsOSArNjUwLDkgQEAKIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCB0d2w0MDMwX3NpaF9pcnFfY2hpcCA9IHsKIAkubmFtZQkJPSAidHdsNDAzMCIsCi0JLm1hc2sJCT0gdHdsNDAzMF9zaWhfbWFzaywKLQkudW5tYXNrCQk9IHR3bDQwMzBfc2loX3VubWFzaywKLQkuc2V0X3R5cGUJPSB0d2w0MDMwX3NpaF9zZXRfdHlwZSwKKwkuaXJxX21hc2sgICAgICAJPSB0d2w0MDMwX3NpaF9tYXNrLAorCS5pcnFfdW5tYXNrCT0gdHdsNDAzMF9zaWhfdW5tYXNrLAorCS5pcnFfc2V0X3R5cGUJPSB0d2w0MDMwX3NpaF9zZXRfdHlwZSwKIH07CiAKIC8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC90d2w2MDMwLWlycS5jIGIvZHJpdmVycy9tZmQvdHdsNjAzMC1pcnEuYwppbmRleCAwNmM4OTU1Li40MDgyZWQ3IDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC90d2w2MDMwLWlycS5jCisrKyBiL2RyaXZlcnMvbWZkL3R3bDYwMzAtaXJxLmMKQEAgLTMzMiw3ICszMzIsNyBAQAogCSAqLwogCXR3bDYwMzBfaXJxX2NoaXAgPSBkdW1teV9pcnFfY2hpcDsKIAl0d2w2MDMwX2lycV9jaGlwLm5hbWUgPSAidHdsNjAzMCI7Ci0JdHdsNjAzMF9pcnFfY2hpcC5zZXRfdHlwZSA9IE5VTEw7CisJdHdsNjAzMF9pcnFfY2hpcC5pcnFfc2V0X3R5cGUgPSBOVUxMOwogCiAJZm9yIChpID0gaXJxX2Jhc2U7IGkgPCBpcnFfZW5kOyBpKyspIHsKIAkJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKGksICZ0d2w2MDMwX2lycV9jaGlwLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvdng4NTUuYyBiL2RyaXZlcnMvbWZkL3Z4ODU1LmMKaW5kZXggZWJiMDU5Ny4uMzQ4MDUyYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZmQvdng4NTUuYworKysgYi9kcml2ZXJzL21mZC92eDg1NS5jCkBAIC0xMTIsNyArMTEyLDcgQEAKIAlyZXR1cm4gcmV0OwogfQogCi1zdGF0aWMgdm9pZCB2eDg1NV9yZW1vdmUoc3RydWN0IHBjaV9kZXYgKnBkZXYpCitzdGF0aWMgdm9pZCBfX2RldmV4aXQgdng4NTVfcmVtb3ZlKHN0cnVjdCBwY2lfZGV2ICpwZGV2KQogewogCW1mZF9yZW1vdmVfZGV2aWNlcygmcGRldi0+ZGV2KTsKIAlwY2lfZGlzYWJsZV9kZXZpY2UocGRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC93bTgzMXgtY29yZS5jIGIvZHJpdmVycy9tZmQvd204MzF4LWNvcmUuYwppbmRleCA3NmNhZGNmLi4zZmU5YTU4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC93bTgzMXgtY29yZS5jCisrKyBiL2RyaXZlcnMvbWZkL3dtODMxeC1jb3JlLmMKQEAgLTE1NDEsNiArMTU0MSwxMiBAQAogCQlkZXZfaW5mbyh3bTgzMXgtPmRldiwgIldNODMyNSByZXZpc2lvbiAlY1xuIiwgJ0EnICsgcmV2KTsKIAkJYnJlYWs7CiAKKwljYXNlIFdNODMyNjoKKwkJcGFyZW50ID0gV004MzI2OworCQl3bTgzMXgtPm51bV9ncGlvID0gMTI7CisJCWRldl9pbmZvKHdtODMxeC0+ZGV2LCAiV004MzI2IHJldmlzaW9uICVjXG4iLCAnQScgKyByZXYpOworCQlicmVhazsKKwogCWRlZmF1bHQ6CiAJCWRldl9lcnIod204MzF4LT5kZXYsICJVbmtub3duIFdNODMxeCBkZXZpY2UgJTA0eFxuIiwgcmV0KTsKIAkJcmV0ID0gLUVJTlZBTDsKQEAgLTE2MTAsMTggKzE2MTYsOSBAQAogCQlicmVhazsKIAogCWNhc2UgV004MzIwOgotCQlyZXQgPSBtZmRfYWRkX2RldmljZXMod204MzF4LT5kZXYsIC0xLAotCQkJCSAgICAgIHdtODMyMF9kZXZzLCBBUlJBWV9TSVpFKHdtODMyMF9kZXZzKSwKLQkJCQkgICAgICBOVUxMLCAwKTsKLQkJYnJlYWs7Ci0KIAljYXNlIFdNODMyMToKLQkJcmV0ID0gbWZkX2FkZF9kZXZpY2VzKHdtODMxeC0+ZGV2LCAtMSwKLQkJCQkgICAgICB3bTgzMjBfZGV2cywgQVJSQVlfU0laRSh3bTgzMjBfZGV2cyksCi0JCQkJICAgICAgTlVMTCwgMCk7Ci0JCWJyZWFrOwotCiAJY2FzZSBXTTgzMjU6CisJY2FzZSBXTTgzMjY6CiAJCXJldCA9IG1mZF9hZGRfZGV2aWNlcyh3bTgzMXgtPmRldiwgLTEsCiAJCQkJICAgICAgd204MzIwX2RldnMsIEFSUkFZX1NJWkUod204MzIwX2RldnMpLAogCQkJCSAgICAgIE5VTEwsIHdtODMxeC0+aXJxX2Jhc2UpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvd204MzF4LWkyYy5jIGIvZHJpdmVycy9tZmQvd204MzF4LWkyYy5jCmluZGV4IDE1NmIxOTguLjM4NTNmYTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL3dtODMxeC1pMmMuYworKysgYi9kcml2ZXJzL21mZC93bTgzMXgtaTJjLmMKQEAgLTk0LDkgKzk0LDkgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCB3bTgzMXhfaTJjX3N1c3BlbmQoc3RydWN0IGkyY19jbGllbnQgKmkyYywgcG1fbWVzc2FnZV90IG1lc2cpCitzdGF0aWMgaW50IHdtODMxeF9pMmNfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCiB7Ci0Jc3RydWN0IHdtODMxeCAqd204MzF4ID0gaTJjX2dldF9jbGllbnRkYXRhKGkyYyk7CisJc3RydWN0IHdtODMxeCAqd204MzF4ID0gZGV2X2dldF9kcnZkYXRhKGRldik7CiAKIAlyZXR1cm4gd204MzF4X2RldmljZV9zdXNwZW5kKHdtODMxeCk7CiB9CkBAIC0xMDgsMTkgKzEwOCwyMyBAQAogCXsgIndtODMyMCIsIFdNODMyMCB9LAogCXsgIndtODMyMSIsIFdNODMyMSB9LAogCXsgIndtODMyNSIsIFdNODMyNSB9LAorCXsgIndtODMyNiIsIFdNODMyNiB9LAogCXsgfQogfTsKIE1PRFVMRV9ERVZJQ0VfVEFCTEUoaTJjLCB3bTgzMXhfaTJjX2lkKTsKIAorc3RhdGljIGNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIHdtODMxeF9wbV9vcHMgPSB7CisJLnN1c3BlbmQgPSB3bTgzMXhfaTJjX3N1c3BlbmQsCit9OwogCiBzdGF0aWMgc3RydWN0IGkyY19kcml2ZXIgd204MzF4X2kyY19kcml2ZXIgPSB7CiAJLmRyaXZlciA9IHsKLQkJICAgLm5hbWUgPSAid204MzF4IiwKLQkJICAgLm93bmVyID0gVEhJU19NT0RVTEUsCisJCS5uYW1lID0gIndtODMxeCIsCisJCS5vd25lciA9IFRISVNfTU9EVUxFLAorCQkucG0gPSAmd204MzF4X3BtX29wcywKIAl9LAogCS5wcm9iZSA9IHdtODMxeF9pMmNfcHJvYmUsCiAJLnJlbW92ZSA9IHdtODMxeF9pMmNfcmVtb3ZlLAotCS5zdXNwZW5kID0gd204MzF4X2kyY19zdXNwZW5kLAogCS5pZF90YWJsZSA9IHdtODMxeF9pMmNfaWQsCiB9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC93bTgzMXgtaXJxLmMgYi9kcml2ZXJzL21mZC93bTgzMXgtaXJxLmMKaW5kZXggMjk0MTgzYi4uZjcxOTJkNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZmQvd204MzF4LWlycS5jCisrKyBiL2RyaXZlcnMvbWZkL3dtODMxeC1pcnEuYwpAQCAtMzQ1LDE2ICszNDUsMTYgQEAKIAlyZXR1cm4gJndtODMxeF9pcnFzW2lycSAtIHdtODMxeC0+aXJxX2Jhc2VdOwogfQogCi1zdGF0aWMgdm9pZCB3bTgzMXhfaXJxX2xvY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHdtODMxeF9pcnFfbG9jayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IHdtODMxeCAqd204MzF4ID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKKwlzdHJ1Y3Qgd204MzF4ICp3bTgzMXggPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKIAogCW11dGV4X2xvY2soJndtODMxeC0+aXJxX2xvY2spOwogfQogCi1zdGF0aWMgdm9pZCB3bTgzMXhfaXJxX3N5bmNfdW5sb2NrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB3bTgzMXhfaXJxX3N5bmNfdW5sb2NrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3Qgd204MzF4ICp3bTgzMXggPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCB3bTgzMXggKndtODMxeCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCWludCBpOwogCiAJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUod204MzF4LT5pcnFfbWFza3NfY3VyKTsgaSsrKSB7CkBAIC0zNzEsMjggKzM3MSwzMCBAQAogCW11dGV4X3VubG9jaygmd204MzF4LT5pcnFfbG9jayk7CiB9CiAKLXN0YXRpYyB2b2lkIHdtODMxeF9pcnFfdW5tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB3bTgzMXhfaXJxX3VubWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IHdtODMxeCAqd204MzF4ID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQlzdHJ1Y3Qgd204MzF4X2lycV9kYXRhICppcnFfZGF0YSA9IGlycV90b193bTgzMXhfaXJxKHdtODMxeCwgaXJxKTsKKwlzdHJ1Y3Qgd204MzF4ICp3bTgzMXggPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKKwlzdHJ1Y3Qgd204MzF4X2lycV9kYXRhICppcnFfZGF0YSA9IGlycV90b193bTgzMXhfaXJxKHdtODMxeCwKKwkJCQkJCQkgICAgIGRhdGEtPmlycSk7CiAKIAl3bTgzMXgtPmlycV9tYXNrc19jdXJbaXJxX2RhdGEtPnJlZyAtIDFdICY9IH5pcnFfZGF0YS0+bWFzazsKIH0KIAotc3RhdGljIHZvaWQgd204MzF4X2lycV9tYXNrKHVuc2lnbmVkIGludCBpcnEpCitzdGF0aWMgdm9pZCB3bTgzMXhfaXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCB3bTgzMXggKndtODMxeCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7Ci0Jc3RydWN0IHdtODMxeF9pcnFfZGF0YSAqaXJxX2RhdGEgPSBpcnFfdG9fd204MzF4X2lycSh3bTgzMXgsIGlycSk7CisJc3RydWN0IHdtODMxeCAqd204MzF4ID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CisJc3RydWN0IHdtODMxeF9pcnFfZGF0YSAqaXJxX2RhdGEgPSBpcnFfdG9fd204MzF4X2lycSh3bTgzMXgsCisJCQkJCQkJICAgICBkYXRhLT5pcnEpOwogCiAJd204MzF4LT5pcnFfbWFza3NfY3VyW2lycV9kYXRhLT5yZWcgLSAxXSB8PSBpcnFfZGF0YS0+bWFzazsKIH0KIAotc3RhdGljIGludCB3bTgzMXhfaXJxX3NldF90eXBlKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCB0eXBlKQorc3RhdGljIGludCB3bTgzMXhfaXJxX3NldF90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSwgdW5zaWduZWQgaW50IHR5cGUpCiB7Ci0Jc3RydWN0IHdtODMxeCAqd204MzF4ID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQlpbnQgdmFsOworCXN0cnVjdCB3bTgzMXggKndtODMxeCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOworCWludCB2YWwsIGlycTsKIAotCWlycSA9IGlycSAtIHdtODMxeC0+aXJxX2Jhc2U7CisJaXJxID0gZGF0YS0+aXJxIC0gd204MzF4LT5pcnFfYmFzZTsKIAogCWlmIChpcnEgPCBXTTgzMVhfSVJRX0dQSU9fMSB8fCBpcnEgPiBXTTgzMVhfSVJRX0dQSU9fMTEpIHsKIAkJLyogSWdub3JlIGludGVybmFsLW9ubHkgSVJRcyAqLwpAQCAtNDIxLDEyICs0MjMsMTIgQEAKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCB3bTgzMXhfaXJxX2NoaXAgPSB7Ci0JLm5hbWUgPSAid204MzF4IiwKLQkuYnVzX2xvY2sgPSB3bTgzMXhfaXJxX2xvY2ssCi0JLmJ1c19zeW5jX3VubG9jayA9IHdtODMxeF9pcnFfc3luY191bmxvY2ssCi0JLm1hc2sgPSB3bTgzMXhfaXJxX21hc2ssCi0JLnVubWFzayA9IHdtODMxeF9pcnFfdW5tYXNrLAotCS5zZXRfdHlwZSA9IHdtODMxeF9pcnFfc2V0X3R5cGUsCisJLm5hbWUJCQk9ICJ3bTgzMXgiLAorCS5pcnFfYnVzX2xvY2sJCT0gd204MzF4X2lycV9sb2NrLAorCS5pcnFfYnVzX3N5bmNfdW5sb2NrCT0gd204MzF4X2lycV9zeW5jX3VubG9jaywKKwkuaXJxX21hc2sJCT0gd204MzF4X2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCQk9IHdtODMxeF9pcnFfdW5tYXNrLAorCS5pcnFfc2V0X3R5cGUJCT0gd204MzF4X2lycV9zZXRfdHlwZSwKIH07CiAKIC8qIFRoZSBwcm9jZXNzaW5nIG9mIHRoZSBwcmltYXJ5IGludGVycnVwdCBvY2N1cnMgaW4gYSB0aHJlYWQgc28gdGhhdApAQCAtNTE1LDYgKzUxNywxNyBAQAogCQlyZXR1cm4gMDsKIAl9CiAKKwkvKiBUcnkgdG8gZmxhZyAvSVJRIGFzIGEgd2FrZSBzb3VyY2U7IHRoZXJlIGFyZSBhIG51bWJlciBvZgorCSAqIHVuY29uZGl0aW9uYWwgd2FrZSBzb3VyY2VzIGluIHRoZSBQTUlDIHNvIHRoaXMgaXNuJ3QKKwkgKiBjb25kaXRpb25hbCBidXQgd2UgZG9uJ3QgYWN0dWFsbHkgY2FyZSAqdG9vKiBtdWNoIGlmIGl0CisJICogZmFpbHMuCisJICovCisJcmV0ID0gZW5hYmxlX2lycV93YWtlKGlycSk7CisJaWYgKHJldCAhPSAwKSB7CisJCWRldl93YXJuKHdtODMxeC0+ZGV2LCAiQ2FuJ3QgZW5hYmxlIElSUSBhcyB3YWtlIHNvdXJjZTogJWRcbiIsCisJCQkgcmV0KTsKKwl9CisKIAl3bTgzMXgtPmlycSA9IGlycTsKIAl3bTgzMXgtPmlycV9iYXNlID0gcGRhdGEtPmlycV9iYXNlOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC93bTgzMXgtc3BpLmMgYi9kcml2ZXJzL21mZC93bTgzMXgtc3BpLmMKaW5kZXggMjc4OWIxNS4uMGE4Zjc3MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZmQvd204MzF4LXNwaS5jCisrKyBiL2RyaXZlcnMvbWZkL3dtODMxeC1zcGkuYwpAQCAtODEsNiArODEsOCBAQAogCQl0eXBlID0gV004MzIxOwogCWVsc2UgaWYgKHN0cmNtcChzcGktPm1vZGFsaWFzLCAid204MzI1IikgPT0gMCkKIAkJdHlwZSA9IFdNODMyNTsKKwllbHNlIGlmIChzdHJjbXAoc3BpLT5tb2RhbGlhcywgIndtODMyNiIpID09IDApCisJCXR5cGUgPSBXTTgzMjY7CiAJZWxzZSB7CiAJCWRldl9lcnIoJnNwaS0+ZGV2LCAiVW5rbm93biBkZXZpY2UgdHlwZVxuIik7CiAJCXJldHVybiAtRUlOVkFMOwpAQCAtMTg0LDYgKzE4NiwxNyBAQAogCS5zdXNwZW5kCT0gd204MzF4X3NwaV9zdXNwZW5kLAogfTsKIAorc3RhdGljIHN0cnVjdCBzcGlfZHJpdmVyIHdtODMyNl9zcGlfZHJpdmVyID0geworCS5kcml2ZXIgPSB7CisJCS5uYW1lCT0gIndtODMyNiIsCisJCS5idXMJPSAmc3BpX2J1c190eXBlLAorCQkub3duZXIJPSBUSElTX01PRFVMRSwKKwl9LAorCS5wcm9iZQkJPSB3bTgzMXhfc3BpX3Byb2JlLAorCS5yZW1vdmUJCT0gX19kZXZleGl0X3Aod204MzF4X3NwaV9yZW1vdmUpLAorCS5zdXNwZW5kCT0gd204MzF4X3NwaV9zdXNwZW5kLAorfTsKKwogc3RhdGljIGludCBfX2luaXQgd204MzF4X3NwaV9pbml0KHZvaWQpCiB7CiAJaW50IHJldDsKQEAgLTIxMiwxMiArMjI1LDE3IEBACiAJaWYgKHJldCAhPSAwKQogCQlwcl9lcnIoIkZhaWxlZCB0byByZWdpc3RlciBXTTgzMjUgU1BJIGRyaXZlcjogJWRcbiIsIHJldCk7CiAKKwlyZXQgPSBzcGlfcmVnaXN0ZXJfZHJpdmVyKCZ3bTgzMjZfc3BpX2RyaXZlcik7CisJaWYgKHJldCAhPSAwKQorCQlwcl9lcnIoIkZhaWxlZCB0byByZWdpc3RlciBXTTgzMjYgU1BJIGRyaXZlcjogJWRcbiIsIHJldCk7CisKIAlyZXR1cm4gMDsKIH0KIHN1YnN5c19pbml0Y2FsbCh3bTgzMXhfc3BpX2luaXQpOwogCiBzdGF0aWMgdm9pZCBfX2V4aXQgd204MzF4X3NwaV9leGl0KHZvaWQpCiB7CisJc3BpX3VucmVnaXN0ZXJfZHJpdmVyKCZ3bTgzMjZfc3BpX2RyaXZlcik7CiAJc3BpX3VucmVnaXN0ZXJfZHJpdmVyKCZ3bTgzMjVfc3BpX2RyaXZlcik7CiAJc3BpX3VucmVnaXN0ZXJfZHJpdmVyKCZ3bTgzMjFfc3BpX2RyaXZlcik7CiAJc3BpX3VucmVnaXN0ZXJfZHJpdmVyKCZ3bTgzMjBfc3BpX2RyaXZlcik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC93bTgzNTAtaXJxLmMgYi9kcml2ZXJzL21mZC93bTgzNTAtaXJxLmMKaW5kZXggZjU2YzlhZC4uNTgzOTk2NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZmQvd204MzUwLWlycS5jCisrKyBiL2RyaXZlcnMvbWZkL3dtODM1MC1pcnEuYwpAQCAtNDE3LDE2ICs0MTcsMTYgQEAKIAlyZXR1cm4gSVJRX0hBTkRMRUQ7CiB9CiAKLXN0YXRpYyB2b2lkIHdtODM1MF9pcnFfbG9jayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgd204MzUwX2lycV9sb2NrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3Qgd204MzUwICp3bTgzNTAgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCB3bTgzNTAgKndtODM1MCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCiAJbXV0ZXhfbG9jaygmd204MzUwLT5pcnFfbG9jayk7CiB9CiAKLXN0YXRpYyB2b2lkIHdtODM1MF9pcnFfc3luY191bmxvY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHdtODM1MF9pcnFfc3luY191bmxvY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCB3bTgzNTAgKndtODM1MCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IHdtODM1MCAqd204MzUwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CiAJaW50IGk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh3bTgzNTAtPmlycV9tYXNrcyk7IGkrKykgewpAQCAtNDQyLDI4ICs0NDIsMzAgQEAKIAltdXRleF91bmxvY2soJndtODM1MC0+aXJxX2xvY2spOwogfQogCi1zdGF0aWMgdm9pZCB3bTgzNTBfaXJxX2VuYWJsZSh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgd204MzUwX2lycV9lbmFibGUoc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCB3bTgzNTAgKndtODM1MCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7Ci0Jc3RydWN0IHdtODM1MF9pcnFfZGF0YSAqaXJxX2RhdGEgPSBpcnFfdG9fd204MzUwX2lycSh3bTgzNTAsIGlycSk7CisJc3RydWN0IHdtODM1MCAqd204MzUwID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CisJc3RydWN0IHdtODM1MF9pcnFfZGF0YSAqaXJxX2RhdGEgPSBpcnFfdG9fd204MzUwX2lycSh3bTgzNTAsCisJCQkJCQkJICAgICBkYXRhLT5pcnEpOwogCiAJd204MzUwLT5pcnFfbWFza3NbaXJxX2RhdGEtPnJlZ10gJj0gfmlycV9kYXRhLT5tYXNrOwogfQogCi1zdGF0aWMgdm9pZCB3bTgzNTBfaXJxX2Rpc2FibGUodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHdtODM1MF9pcnFfZGlzYWJsZShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IHdtODM1MCAqd204MzUwID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQlzdHJ1Y3Qgd204MzUwX2lycV9kYXRhICppcnFfZGF0YSA9IGlycV90b193bTgzNTBfaXJxKHdtODM1MCwgaXJxKTsKKwlzdHJ1Y3Qgd204MzUwICp3bTgzNTAgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKKwlzdHJ1Y3Qgd204MzUwX2lycV9kYXRhICppcnFfZGF0YSA9IGlycV90b193bTgzNTBfaXJxKHdtODM1MCwKKwkJCQkJCQkgICAgIGRhdGEtPmlycSk7CiAKIAl3bTgzNTAtPmlycV9tYXNrc1tpcnFfZGF0YS0+cmVnXSB8PSBpcnFfZGF0YS0+bWFzazsKIH0KIAogc3RhdGljIHN0cnVjdCBpcnFfY2hpcCB3bTgzNTBfaXJxX2NoaXAgPSB7Ci0JLm5hbWUgPSAid204MzUwIiwKLQkuYnVzX2xvY2sgPSB3bTgzNTBfaXJxX2xvY2ssCi0JLmJ1c19zeW5jX3VubG9jayA9IHdtODM1MF9pcnFfc3luY191bmxvY2ssCi0JLmRpc2FibGUgPSB3bTgzNTBfaXJxX2Rpc2FibGUsCi0JLmVuYWJsZSA9IHdtODM1MF9pcnFfZW5hYmxlLAorCS5uYW1lCQkJPSAid204MzUwIiwKKwkuaXJxX2J1c19sb2NrCQk9IHdtODM1MF9pcnFfbG9jaywKKwkuaXJxX2J1c19zeW5jX3VubG9jawk9IHdtODM1MF9pcnFfc3luY191bmxvY2ssCisJLmlycV9kaXNhYmxlCQk9IHdtODM1MF9pcnFfZGlzYWJsZSwKKwkuaXJxX2VuYWJsZQkJPSB3bTgzNTBfaXJxX2VuYWJsZSwKIH07CiAKIGludCB3bTgzNTBfaXJxX2luaXQoc3RydWN0IHdtODM1MCAqd204MzUwLCBpbnQgaXJxLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvd204OTk0LWNvcmUuYyBiL2RyaXZlcnMvbWZkL3dtODk5NC1jb3JlLmMKaW5kZXggOGQyMjFiYS4uNDEyMzNjNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZmQvd204OTk0LWNvcmUuYworKysgYi9kcml2ZXJzL21mZC93bTg5OTQtY29yZS5jCkBAIC0xOCw2ICsxOCw3IEBACiAjaW5jbHVkZSA8bGludXgvaTJjLmg+CiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KICNpbmNsdWRlIDxsaW51eC9tZmQvY29yZS5oPgorI2luY2x1ZGUgPGxpbnV4L3BtX3J1bnRpbWUuaD4KICNpbmNsdWRlIDxsaW51eC9yZWd1bGF0b3IvY29uc3VtZXIuaD4KICNpbmNsdWRlIDxsaW51eC9yZWd1bGF0b3IvbWFjaGluZS5oPgogCkBAIC0xNjksOCArMTcwLDE2IEBACiBFWFBPUlRfU1lNQk9MX0dQTCh3bTg5OTRfc2V0X2JpdHMpOwogCiBzdGF0aWMgc3RydWN0IG1mZF9jZWxsIHdtODk5NF9yZWd1bGF0b3JfZGV2c1tdID0gewotCXsgLm5hbWUgPSAid204OTk0LWxkbyIsIC5pZCA9IDEgfSwKLQl7IC5uYW1lID0gIndtODk5NC1sZG8iLCAuaWQgPSAyIH0sCisJeworCQkubmFtZSA9ICJ3bTg5OTQtbGRvIiwKKwkJLmlkID0gMSwKKwkJLnBtX3J1bnRpbWVfbm9fY2FsbGJhY2tzID0gdHJ1ZSwKKwl9LAorCXsKKwkJLm5hbWUgPSAid204OTk0LWxkbyIsCisJCS5pZCA9IDIsCisJCS5wbV9ydW50aW1lX25vX2NhbGxiYWNrcyA9IHRydWUsCisJfSwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgcmVzb3VyY2Ugd204OTk0X2NvZGVjX3Jlc291cmNlc1tdID0gewpAQCAtMjAwLDYgKzIwOSw3IEBACiAJCS5uYW1lID0gIndtODk5NC1ncGlvIiwKIAkJLm51bV9yZXNvdXJjZXMgPSBBUlJBWV9TSVpFKHdtODk5NF9ncGlvX3Jlc291cmNlcyksCiAJCS5yZXNvdXJjZXMgPSB3bTg5OTRfZ3Bpb19yZXNvdXJjZXMsCisJCS5wbV9ydW50aW1lX25vX2NhbGxiYWNrcyA9IHRydWUsCiAJfSwKIH07CiAKQEAgLTIzMSw3ICsyNDEsNyBAQAogfTsKIAogI2lmZGVmIENPTkZJR19QTQotc3RhdGljIGludCB3bTg5OTRfZGV2aWNlX3N1c3BlbmQoc3RydWN0IGRldmljZSAqZGV2KQorc3RhdGljIGludCB3bTg5OTRfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0IHdtODk5NCAqd204OTk0ID0gZGV2X2dldF9kcnZkYXRhKGRldik7CiAJaW50IHJldDsKQEAgLTI2MSw3ICsyNzEsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IHdtODk5NF9kZXZpY2VfcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRldikKK3N0YXRpYyBpbnQgd204OTk0X3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0IHdtODk5NCAqd204OTk0ID0gZGV2X2dldF9kcnZkYXRhKGRldik7CiAJaW50IHJldDsKQEAgLTQ3MSw2ICs0ODEsOSBAQAogCQlnb3RvIGVycl9pcnE7CiAJfQogCisJcG1fcnVudGltZV9lbmFibGUod204OTk0LT5kZXYpOworCXBtX3J1bnRpbWVfcmVzdW1lKHdtODk5NC0+ZGV2KTsKKwogCXJldHVybiAwOwogCiBlcnJfaXJxOgpAQCAtNDkwLDYgKzUwMyw3IEBACiAKIHN0YXRpYyB2b2lkIHdtODk5NF9kZXZpY2VfZXhpdChzdHJ1Y3Qgd204OTk0ICp3bTg5OTQpCiB7CisJcG1fcnVudGltZV9kaXNhYmxlKHdtODk5NC0+ZGV2KTsKIAltZmRfcmVtb3ZlX2RldmljZXMod204OTk0LT5kZXYpOwogCXdtODk5NF9pcnFfZXhpdCh3bTg5OTQpOwogCXJlZ3VsYXRvcl9idWxrX2Rpc2FibGUod204OTk0LT5udW1fc3VwcGxpZXMsCkBAIC01NzMsMjEgKzU4Nyw2IEBACiAJcmV0dXJuIDA7CiB9CiAKLSNpZmRlZiBDT05GSUdfUE0KLXN0YXRpYyBpbnQgd204OTk0X2kyY19zdXNwZW5kKHN0cnVjdCBpMmNfY2xpZW50ICppMmMsIHBtX21lc3NhZ2VfdCBzdGF0ZSkKLXsKLQlyZXR1cm4gd204OTk0X2RldmljZV9zdXNwZW5kKCZpMmMtPmRldik7Ci19Ci0KLXN0YXRpYyBpbnQgd204OTk0X2kyY19yZXN1bWUoc3RydWN0IGkyY19jbGllbnQgKmkyYykKLXsKLQlyZXR1cm4gd204OTk0X2RldmljZV9yZXN1bWUoJmkyYy0+ZGV2KTsKLX0KLSNlbHNlCi0jZGVmaW5lIHdtODk5NF9pMmNfc3VzcGVuZCBOVUxMCi0jZGVmaW5lIHdtODk5NF9pMmNfcmVzdW1lIE5VTEwKLSNlbmRpZgotCiBzdGF0aWMgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgd204OTk0X2kyY19pZFtdID0gewogCXsgIndtODk5NCIsIFdNODk5NCB9LAogCXsgIndtODk1OCIsIFdNODk1OCB9LApAQCAtNTk1LDE1ICs1OTQsMTYgQEAKIH07CiBNT0RVTEVfREVWSUNFX1RBQkxFKGkyYywgd204OTk0X2kyY19pZCk7CiAKK1VOSVZFUlNBTF9ERVZfUE1fT1BTKHdtODk5NF9wbV9vcHMsIHdtODk5NF9zdXNwZW5kLCB3bTg5OTRfcmVzdW1lLCBOVUxMKTsKKwogc3RhdGljIHN0cnVjdCBpMmNfZHJpdmVyIHdtODk5NF9pMmNfZHJpdmVyID0gewogCS5kcml2ZXIgPSB7Ci0JCSAgIC5uYW1lID0gIndtODk5NCIsCi0JCSAgIC5vd25lciA9IFRISVNfTU9EVUxFLAorCQkubmFtZSA9ICJ3bTg5OTQiLAorCQkub3duZXIgPSBUSElTX01PRFVMRSwKKwkJLnBtID0gJndtODk5NF9wbV9vcHMsCiAJfSwKIAkucHJvYmUgPSB3bTg5OTRfaTJjX3Byb2JlLAogCS5yZW1vdmUgPSB3bTg5OTRfaTJjX3JlbW92ZSwKLQkuc3VzcGVuZCA9IHdtODk5NF9pMmNfc3VzcGVuZCwKLQkucmVzdW1lID0gd204OTk0X2kyY19yZXN1bWUsCiAJLmlkX3RhYmxlID0gd204OTk0X2kyY19pZCwKIH07CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL3dtODk5NC1pcnEuYyBiL2RyaXZlcnMvbWZkL3dtODk5NC1pcnEuYwppbmRleCA4NDAwZWIxLi4yOWU4ZmFmIDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC93bTg5OTQtaXJxLmMKKysrIGIvZHJpdmVycy9tZmQvd204OTk0LWlycS5jCkBAIC0xNTYsMTYgKzE1NiwxNiBAQAogCXJldHVybiAmd204OTk0X2lycXNbaXJxIC0gd204OTk0LT5pcnFfYmFzZV07CiB9CiAKLXN0YXRpYyB2b2lkIHdtODk5NF9pcnFfbG9jayh1bnNpZ25lZCBpbnQgaXJxKQorc3RhdGljIHZvaWQgd204OTk0X2lycV9sb2NrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3Qgd204OTk0ICp3bTg5OTQgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOworCXN0cnVjdCB3bTg5OTQgKndtODk5NCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOwogCiAJbXV0ZXhfbG9jaygmd204OTk0LT5pcnFfbG9jayk7CiB9CiAKLXN0YXRpYyB2b2lkIHdtODk5NF9pcnFfc3luY191bmxvY2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHdtODk5NF9pcnFfc3luY191bmxvY2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogewotCXN0cnVjdCB3bTg5OTQgKndtODk5NCA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CisJc3RydWN0IHdtODk5NCAqd204OTk0ID0gaXJxX2RhdGFfZ2V0X2lycV9jaGlwX2RhdGEoZGF0YSk7CiAJaW50IGk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh3bTg5OTQtPmlycV9tYXNrc19jdXIpOyBpKyspIHsKQEAgLTE4MiwyOCArMTgyLDMwIEBACiAJbXV0ZXhfdW5sb2NrKCZ3bTg5OTQtPmlycV9sb2NrKTsKIH0KIAotc3RhdGljIHZvaWQgd204OTk0X2lycV91bm1hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHdtODk5NF9pcnFfdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSkKIHsKLQlzdHJ1Y3Qgd204OTk0ICp3bTg5OTQgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOwotCXN0cnVjdCB3bTg5OTRfaXJxX2RhdGEgKmlycV9kYXRhID0gaXJxX3RvX3dtODk5NF9pcnEod204OTk0LCBpcnEpOworCXN0cnVjdCB3bTg5OTQgKndtODk5NCA9IGlycV9kYXRhX2dldF9pcnFfY2hpcF9kYXRhKGRhdGEpOworCXN0cnVjdCB3bTg5OTRfaXJxX2RhdGEgKmlycV9kYXRhID0gaXJxX3RvX3dtODk5NF9pcnEod204OTk0LAorCQkJCQkJCSAgICAgZGF0YS0+aXJxKTsKIAogCXdtODk5NC0+aXJxX21hc2tzX2N1cltpcnFfZGF0YS0+cmVnIC0gMV0gJj0gfmlycV9kYXRhLT5tYXNrOwogfQogCi1zdGF0aWMgdm9pZCB3bTg5OTRfaXJxX21hc2sodW5zaWduZWQgaW50IGlycSkKK3N0YXRpYyB2b2lkIHdtODk5NF9pcnFfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCiB7Ci0Jc3RydWN0IHdtODk5NCAqd204OTk0ID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKLQlzdHJ1Y3Qgd204OTk0X2lycV9kYXRhICppcnFfZGF0YSA9IGlycV90b193bTg5OTRfaXJxKHdtODk5NCwgaXJxKTsKKwlzdHJ1Y3Qgd204OTk0ICp3bTg5OTQgPSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkYXRhKTsKKwlzdHJ1Y3Qgd204OTk0X2lycV9kYXRhICppcnFfZGF0YSA9IGlycV90b193bTg5OTRfaXJxKHdtODk5NCwKKwkJCQkJCQkgICAgIGRhdGEtPmlycSk7CiAKIAl3bTg5OTQtPmlycV9tYXNrc19jdXJbaXJxX2RhdGEtPnJlZyAtIDFdIHw9IGlycV9kYXRhLT5tYXNrOwogfQogCiBzdGF0aWMgc3RydWN0IGlycV9jaGlwIHdtODk5NF9pcnFfY2hpcCA9IHsKLQkubmFtZSA9ICJ3bTg5OTQiLAotCS5idXNfbG9jayA9IHdtODk5NF9pcnFfbG9jaywKLQkuYnVzX3N5bmNfdW5sb2NrID0gd204OTk0X2lycV9zeW5jX3VubG9jaywKLQkubWFzayA9IHdtODk5NF9pcnFfbWFzaywKLQkudW5tYXNrID0gd204OTk0X2lycV91bm1hc2ssCisJLm5hbWUJCQk9ICJ3bTg5OTQiLAorCS5pcnFfYnVzX2xvY2sJCT0gd204OTk0X2lycV9sb2NrLAorCS5pcnFfYnVzX3N5bmNfdW5sb2NrCT0gd204OTk0X2lycV9zeW5jX3VubG9jaywKKwkuaXJxX21hc2sJCT0gd204OTk0X2lycV9tYXNrLAorCS5pcnFfdW5tYXNrCQk9IHdtODk5NF9pcnFfdW5tYXNrLAogfTsKIAogLyogVGhlIHByb2Nlc3Npbmcgb2YgdGhlIHByaW1hcnkgaW50ZXJydXB0IG9jY3VycyBpbiBhIHRocmVhZCBzbyB0aGF0CmRpZmYgLS1naXQgYS9kcml2ZXJzL21pc2MvS2NvbmZpZyBiL2RyaXZlcnMvbWlzYy9LY29uZmlnCmluZGV4IDFlMWE0YmUuLmNjOGU0OWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWlzYy9LY29uZmlnCisrKyBiL2RyaXZlcnMvbWlzYy9LY29uZmlnCkBAIC02NCw3ICs2NCw3IEBACiAKIGNvbmZpZyBBQjg1MDBfUFdNCiAJYm9vbCAiQUI4NTAwIFBXTSBzdXBwb3J0IgotCWRlcGVuZHMgb24gQUI4NTAwX0NPUkUKKwlkZXBlbmRzIG9uIEFCODUwMF9DT1JFICYmIEFSQ0hfVTg1MDAKIAlzZWxlY3QgSEFWRV9QV00KIAloZWxwCiAJICBUaGlzIGRyaXZlciBleHBvcnRzIGZ1bmN0aW9ucyB0byBlbmFibGUvZGlzYmxlL2NvbmZpZy9mcmVlIFB1bHNlCmRpZmYgLS1naXQgYS9kcml2ZXJzL21pc2MvY3M1NTM1LW1mZ3B0LmMgYi9kcml2ZXJzL21pc2MvY3M1NTM1LW1mZ3B0LmMKaW5kZXggNmY2MjE4MC4uZDAyZDMwMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9taXNjL2NzNTUzNS1tZmdwdC5jCisrKyBiL2RyaXZlcnMvbWlzYy9jczU1MzUtbWZncHQuYwpAQCAtMTYsMTIgKzE2LDExIEBACiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KLSNpbmNsdWRlIDxsaW51eC9wY2kuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9jczU1MzUuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAKICNkZWZpbmUgRFJWX05BTUUgImNzNTUzNS1tZmdwdCIKLSNkZWZpbmUgTUZHUFRfQkFSIDIKIAogc3RhdGljIGludCBtZmdwdF9yZXNldF90aW1lcnM7CiBtb2R1bGVfcGFyYW1fbmFtZWQobWZncHRmaXgsIG1mZ3B0X3Jlc2V0X3RpbWVycywgaW50LCAwNjQ0KTsKQEAgLTM3LDcgKzM2LDcgQEAKIAlERUNMQVJFX0JJVE1BUChhdmFpbCwgTUZHUFRfTUFYX1RJTUVSUyk7CiAJcmVzb3VyY2Vfc2l6ZV90IGJhc2U7CiAKLQlzdHJ1Y3QgcGNpX2RldiAqcGRldjsKKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2OwogCXNwaW5sb2NrX3QgbG9jazsKIAlpbnQgaW5pdGlhbGl6ZWQ7CiB9IGNzNTUzNV9tZmdwdF9jaGlwOwpAQCAtMjkwLDEwICsyODksMTAgQEAKIAlyZXR1cm4gdGltZXJzOwogfQogCi1zdGF0aWMgaW50IF9faW5pdCBjczU1MzVfbWZncHRfcHJvYmUoc3RydWN0IHBjaV9kZXYgKnBkZXYsCi0JCWNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICpwY2lfaWQpCitzdGF0aWMgaW50IF9fZGV2aW5pdCBjczU1MzVfbWZncHRfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIHsKLQlpbnQgZXJyLCB0OworCXN0cnVjdCByZXNvdXJjZSAqcmVzOworCWludCBlcnIgPSAtRUlPLCB0OwogCiAJLyogVGhlcmUgYXJlIHR3byB3YXlzIHRvIGdldCB0aGUgTUZHUFQgYmFzZSBhZGRyZXNzOyBvbmUgaXMgYnkKIAkgKiBmZXRjaGluZyBpdCBmcm9tIE1TUl9MQkFSX01GR1BULCB0aGUgb3RoZXIgaXMgYnkgcmVhZGluZyB0aGUKQEAgLTMwMiwyOSArMzAxLDI3IEBACiAJICogaXQgdHVybnMgb3V0IHRvIGJlIHVucmVsaWFibGUgaW4gdGhlIGZhY2Ugb2YgY3JhcHB5IEJJT1Nlcywgd2UKIAkgKiBjYW4gYWx3YXlzIGdvIGJhY2sgdG8gdXNpbmcgTVNScy4uICovCiAKLQllcnIgPSBwY2lfZW5hYmxlX2RldmljZV9pbyhwZGV2KTsKLQlpZiAoZXJyKSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgImNhbid0IGVuYWJsZSBkZXZpY2UgSU9cbiIpOworCXJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNFX0lPLCAwKTsKKwlpZiAoIXJlcykgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW4ndCBmZXRjaCBkZXZpY2UgcmVzb3VyY2UgaW5mb1xuIik7CiAJCWdvdG8gZG9uZTsKIAl9CiAKLQllcnIgPSBwY2lfcmVxdWVzdF9yZWdpb24ocGRldiwgTUZHUFRfQkFSLCBEUlZfTkFNRSk7Ci0JaWYgKGVycikgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW4ndCBhbGxvYyBQQ0kgQkFSICMlZFxuIiwgTUZHUFRfQkFSKTsKKwlpZiAoIXJlcXVlc3RfcmVnaW9uKHJlcy0+c3RhcnQsIHJlc291cmNlX3NpemUocmVzKSwgcGRldi0+bmFtZSkpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiY2FuJ3QgcmVxdWVzdCByZWdpb25cbiIpOwogCQlnb3RvIGRvbmU7CiAJfQogCiAJLyogc2V0IHVwIHRoZSBkcml2ZXItc3BlY2lmaWMgc3RydWN0ICovCi0JY3M1NTM1X21mZ3B0X2NoaXAuYmFzZSA9IHBjaV9yZXNvdXJjZV9zdGFydChwZGV2LCBNRkdQVF9CQVIpOworCWNzNTUzNV9tZmdwdF9jaGlwLmJhc2UgPSByZXMtPnN0YXJ0OwogCWNzNTUzNV9tZmdwdF9jaGlwLnBkZXYgPSBwZGV2OwogCXNwaW5fbG9ja19pbml0KCZjczU1MzVfbWZncHRfY2hpcC5sb2NrKTsKIAotCWRldl9pbmZvKCZwZGV2LT5kZXYsICJhbGxvY2F0ZWQgUENJIEJBUiAjJWQ6IGJhc2UgMHglbGx4XG4iLCBNRkdQVF9CQVIsCi0JCQkodW5zaWduZWQgbG9uZyBsb25nKSBjczU1MzVfbWZncHRfY2hpcC5iYXNlKTsKKwlkZXZfaW5mbygmcGRldi0+ZGV2LCAicmVzZXJ2ZWQgcmVzb3VyY2UgcmVnaW9uICVwUlxuIiwgcmVzKTsKIAogCS8qIGRldGVjdCB0aGUgYXZhaWxhYmxlIHRpbWVycyAqLwogCXQgPSBzY2FuX3RpbWVycygmY3M1NTM1X21mZ3B0X2NoaXApOwotCWRldl9pbmZvKCZwZGV2LT5kZXYsIERSVl9OQU1FICI6ICVkIE1GR1BUIHRpbWVycyBhdmFpbGFibGVcbiIsIHQpOworCWRldl9pbmZvKCZwZGV2LT5kZXYsICIlZCBNRkdQVCB0aW1lcnMgYXZhaWxhYmxlXG4iLCB0KTsKIAljczU1MzVfbWZncHRfY2hpcC5pbml0aWFsaXplZCA9IDE7CiAJcmV0dXJuIDA7CiAKQEAgLTMzMiw0NyArMzI5LDE4IEBACiAJcmV0dXJuIGVycjsKIH0KIAotc3RhdGljIHN0cnVjdCBwY2lfZGV2aWNlX2lkIGNzNTUzNV9tZmdwdF9wY2lfdGJsW10gPSB7Ci0JeyBQQ0lfREVWSUNFKFBDSV9WRU5ET1JfSURfTlMsIFBDSV9ERVZJQ0VfSURfTlNfQ1M1NTM1X0lTQSkgfSwKLQl7IFBDSV9ERVZJQ0UoUENJX1ZFTkRPUl9JRF9BTUQsIFBDSV9ERVZJQ0VfSURfQU1EX0NTNTUzNl9JU0EpIH0sCi0JeyAwLCB9LAorc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgY3M1NTM1X21mZ3B0X2RydiA9IHsKKwkuZHJpdmVyID0geworCQkubmFtZSA9IERSVl9OQU1FLAorCQkub3duZXIgPSBUSElTX01PRFVMRSwKKwl9LAorCS5wcm9iZSA9IGNzNTUzNV9tZmdwdF9wcm9iZSwKIH07Ci1NT0RVTEVfREVWSUNFX1RBQkxFKHBjaSwgY3M1NTM1X21mZ3B0X3BjaV90YmwpOwogCi0vKgotICogSnVzdCBsaWtlIHdpdGggdGhlIGNzNTUzNS1ncGlvIGRyaXZlciwgd2UgY2FuJ3QgdXNlIHRoZSBzdGFuZGFyZCBQQ0kgZHJpdmVyCi0gKiByZWdpc3RyYXRpb24gc3R1ZmYuICBJdCBvbmx5IGFsbG93cyBvbmx5IG9uZSBkcml2ZXIgdG8gYmluZCB0byBlYWNoIFBDSQotICogZGV2aWNlLCBhbmQgd2Ugd2FudCB0aGUgR1BJTyBhbmQgTUZHUFQgZHJpdmVycyB0byBiZSBhYmxlIHRvIHNoYXJlIGEgUENJCi0gKiBkZXZpY2UuICBJbnN0ZWFkLCB3ZSBtYW51YWxseSBzY2FuIGZvciB0aGUgUENJIGRldmljZSwgcmVxdWVzdCBhIHNpbmdsZQotICogcmVnaW9uLCBhbmQga2VlcCB0cmFjayBvZiB0aGUgZGV2aWNlcyB0aGF0IHdlJ3JlIHVzaW5nLgotICovCi0KLXN0YXRpYyBpbnQgX19pbml0IGNzNTUzNV9tZmdwdF9zY2FuX3BjaSh2b2lkKQotewotCXN0cnVjdCBwY2lfZGV2ICpwZGV2OwotCWludCBlcnIgPSAtRU5PREVWOwotCWludCBpOwotCi0JZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoY3M1NTM1X21mZ3B0X3BjaV90YmwpOyBpKyspIHsKLQkJcGRldiA9IHBjaV9nZXRfZGV2aWNlKGNzNTUzNV9tZmdwdF9wY2lfdGJsW2ldLnZlbmRvciwKLQkJCQljczU1MzVfbWZncHRfcGNpX3RibFtpXS5kZXZpY2UsIE5VTEwpOwotCQlpZiAocGRldikgewotCQkJZXJyID0gY3M1NTM1X21mZ3B0X3Byb2JlKHBkZXYsCi0JCQkJCSZjczU1MzVfbWZncHRfcGNpX3RibFtpXSk7Ci0JCQlpZiAoZXJyKQotCQkJCXBjaV9kZXZfcHV0KHBkZXYpOwotCi0JCQkvKiB3ZSBvbmx5IHN1cHBvcnQgYSBzaW5nbGUgQ1M1NTM1LzYgc291dGhicmlkZ2UgKi8KLQkJCWJyZWFrOwotCQl9Ci0JfQotCi0JcmV0dXJuIGVycjsKLX0KIAogc3RhdGljIGludCBfX2luaXQgY3M1NTM1X21mZ3B0X2luaXQodm9pZCkKIHsKLQlyZXR1cm4gY3M1NTM1X21mZ3B0X3NjYW5fcGNpKCk7CisJcmV0dXJuIHBsYXRmb3JtX2RyaXZlcl9yZWdpc3RlcigmY3M1NTM1X21mZ3B0X2Rydik7CiB9CiAKIG1vZHVsZV9pbml0KGNzNTUzNV9tZmdwdF9pbml0KTsKQEAgLTM4MCwzICszNDgsNCBAQAogTU9EVUxFX0FVVEhPUigiQW5kcmVzIFNhbG9tb24gPGRpbGluZ2VyQHF1ZXVlZC5uZXQ+Iik7CiBNT0RVTEVfREVTQ1JJUFRJT04oIkNTNTUzNS9DUzU1MzYgTUZHUFQgdGltZXIgZHJpdmVyIik7CiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CitNT0RVTEVfQUxJQVMoInBsYXRmb3JtOiIgRFJWX05BTUUpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tbWMvaG9zdC9iZmluX3NkaC5jIGIvZHJpdmVycy9tbWMvaG9zdC9iZmluX3NkaC5jCmluZGV4IGJhYzdkNjIuLjAzNzFiZjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbW1jL2hvc3QvYmZpbl9zZGguYworKysgYi9kcml2ZXJzL21tYy9ob3N0L2JmaW5fc2RoLmMKQEAgLTQ2Miw3ICs0NjIsNyBAQAogCQlnb3RvIG91dDsKIAl9CiAKLQltbWMgPSBtbWNfYWxsb2NfaG9zdChzaXplb2YoKm1tYyksICZwZGV2LT5kZXYpOworCW1tYyA9IG1tY19hbGxvY19ob3N0KHNpemVvZihzdHJ1Y3Qgc2RoX2hvc3QpLCAmcGRldi0+ZGV2KTsKIAlpZiAoIW1tYykgewogCQlyZXQgPSAtRU5PTUVNOwogCQlnb3RvIG91dDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbW1jL2hvc3Qvano0NzQwX21tYy5jIGIvZHJpdmVycy9tbWMvaG9zdC9qejQ3NDBfbW1jLmMKaW5kZXggYjNhMGFiMC4uNzQyMThhZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tbWMvaG9zdC9qejQ3NDBfbW1jLmMKKysrIGIvZHJpdmVycy9tbWMvaG9zdC9qejQ3NDBfbW1jLmMKQEAgLTE0LDYgKzE0LDcgQEAKICAqLwogCiAjaW5jbHVkZSA8bGludXgvbW1jL2hvc3QuaD4KKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KICNpbmNsdWRlIDxsaW51eC9pby5oPgogI2luY2x1ZGUgPGxpbnV4L2lycS5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgpAQCAtODI3LDggKzgyOCw4IEBACiAJfQogCiAJaG9zdC0+Y2xrID0gY2xrX2dldCgmcGRldi0+ZGV2LCAibW1jIik7Ci0JaWYgKCFob3N0LT5jbGspIHsKLQkJcmV0ID0gLUVOT0VOVDsKKwlpZiAoSVNfRVJSKGhvc3QtPmNsaykpIHsKKwkJcmV0ID0gUFRSX0VSUihob3N0LT5jbGspOwogCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJGYWlsZWQgdG8gZ2V0IG1tYyBjbG9ja1xuIik7CiAJCWdvdG8gZXJyX2ZyZWVfaG9zdDsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21tYy9ob3N0L21tY2kuYyBiL2RyaXZlcnMvbW1jL2hvc3QvbW1jaS5jCmluZGV4IDU2MzAyMjguLjJkNmRlM2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbW1jL2hvc3QvbW1jaS5jCisrKyBiL2RyaXZlcnMvbW1jL2hvc3QvbW1jaS5jCkBAIC0xNCw2ICsxNCw3IEBACiAjaW5jbHVkZSA8bGludXgvaW9wb3J0Lmg+CiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KICNpbmNsdWRlIDxsaW51eC9lcnIuaD4KICNpbmNsdWRlIDxsaW51eC9oaWdobWVtLmg+CkBAIC00NiwxMCArNDcsNiBAQAogICoJICAgICAgaXMgYXNzZXJ0ZWQgKGxpa2V3aXNlIGZvciBSWCkKICAqIEBmaWZvaGFsZnNpemU6IG51bWJlciBvZiBieXRlcyB0aGF0IGNhbiBiZSB3cml0dGVuIHdoZW4gTUNJX1RYRklGT0hBTEZFTVBUWQogICoJCSAgaXMgYXNzZXJ0ZWQgKGxpa2V3aXNlIGZvciBSWCkKLSAqIEBicm9rZW5fYmxvY2tlbmQ6IHRoZSBNQ0lfREFUQUJMT0NLRU5EIGlzIGJyb2tlbiBvbiB0aGUgaGFyZHdhcmUKLSAqCQlhbmQgd2lsbCBub3Qgd29yayBhdCBhbGwuCi0gKiBAYnJva2VuX2Jsb2NrZW5kX2RtYTogdGhlIE1DSV9EQVRBQkxPQ0tFTkQgaXMgYnJva2VuIG9uIHRoZSBoYXJkd2FyZSB3aGVuCi0gKgkJdXNpbmcgRE1BLgogICogQHNkaW86IHZhcmlhbnQgc3VwcG9ydHMgU0RJTwogICogQHN0X2Nsa2RpdjogdHJ1ZSBpZiB1c2luZyBhIFNULXNwZWNpZmljIGNsb2NrIGRpdmlkZXIgYWxnb3JpdGhtCiAgKi8KQEAgLTU5LDggKzU2LDYgQEAKIAl1bnNpZ25lZCBpbnQJCWRhdGFsZW5ndGhfYml0czsKIAl1bnNpZ25lZCBpbnQJCWZpZm9zaXplOwogCXVuc2lnbmVkIGludAkJZmlmb2hhbGZzaXplOwotCWJvb2wJCQlicm9rZW5fYmxvY2tlbmQ7Ci0JYm9vbAkJCWJyb2tlbl9ibG9ja2VuZF9kbWE7CiAJYm9vbAkJCXNkaW87CiAJYm9vbAkJCXN0X2Nsa2RpdjsKIH07CkBAIC03Niw3ICs3MSw2IEBACiAJLmZpZm9oYWxmc2l6ZQkJPSA4ICogNCwKIAkuY2xrcmVnX2VuYWJsZQkJPSAxIDw8IDEzLCAvKiBIV0ZDRU4gKi8KIAkuZGF0YWxlbmd0aF9iaXRzCT0gMTYsCi0JLmJyb2tlbl9ibG9ja2VuZF9kbWEJPSB0cnVlLAogCS5zZGlvCQkJPSB0cnVlLAogfTsKIApAQCAtODYsNyArODAsNiBAQAogCS5jbGtyZWcJCQk9IE1DSV9DTEtfRU5BQkxFLAogCS5jbGtyZWdfZW5hYmxlCQk9IDEgPDwgMTQsIC8qIEhXRkNFTiAqLwogCS5kYXRhbGVuZ3RoX2JpdHMJPSAyNCwKLQkuYnJva2VuX2Jsb2NrZW5kCT0gdHJ1ZSwKIAkuc2RpbwkJCT0gdHJ1ZSwKIAkuc3RfY2xrZGl2CQk9IHRydWUsCiB9OwpAQCAtMjEwLDggKzIwMyw2IEBACiAJaG9zdC0+ZGF0YSA9IGRhdGE7CiAJaG9zdC0+c2l6ZSA9IGRhdGEtPmJsa3N6ICogZGF0YS0+YmxvY2tzOwogCWhvc3QtPmRhdGFfeGZlcmVkID0gMDsKLQlob3N0LT5ibG9ja2VuZCA9IGZhbHNlOwotCWhvc3QtPmRhdGFlbmQgPSBmYWxzZTsKIAogCW1tY2lfaW5pdF9zZyhob3N0LCBkYXRhKTsKIApAQCAtMjg4LDIxICsyNzksMjYgQEAKIG1tY2lfZGF0YV9pcnEoc3RydWN0IG1tY2lfaG9zdCAqaG9zdCwgc3RydWN0IG1tY19kYXRhICpkYXRhLAogCSAgICAgIHVuc2lnbmVkIGludCBzdGF0dXMpCiB7Ci0Jc3RydWN0IHZhcmlhbnRfZGF0YSAqdmFyaWFudCA9IGhvc3QtPnZhcmlhbnQ7Ci0KIAkvKiBGaXJzdCBjaGVjayBmb3IgZXJyb3JzICovCiAJaWYgKHN0YXR1cyAmIChNQ0lfREFUQUNSQ0ZBSUx8TUNJX0RBVEFUSU1FT1VUfE1DSV9UWFVOREVSUlVOfE1DSV9SWE9WRVJSVU4pKSB7Ci0JCWRldl9kYmcobW1jX2Rldihob3N0LT5tbWMpLCAiTUNJIEVSUk9SIElSUSAoc3RhdHVzICUwOHgpXG4iLCBzdGF0dXMpOwotCQlpZiAoc3RhdHVzICYgTUNJX0RBVEFDUkNGQUlMKQotCQkJZGF0YS0+ZXJyb3IgPSAtRUlMU0VROwotCQllbHNlIGlmIChzdGF0dXMgJiBNQ0lfREFUQVRJTUVPVVQpCi0JCQlkYXRhLT5lcnJvciA9IC1FVElNRURPVVQ7Ci0JCWVsc2UgaWYgKHN0YXR1cyAmIChNQ0lfVFhVTkRFUlJVTnxNQ0lfUlhPVkVSUlVOKSkKLQkJCWRhdGEtPmVycm9yID0gLUVJTzsKKwkJdTMyIHJlbWFpbiwgc3VjY2VzczsKIAotCQkvKiBGb3JjZS1jb21wbGV0ZSB0aGUgdHJhbnNhY3Rpb24gKi8KLQkJaG9zdC0+YmxvY2tlbmQgPSB0cnVlOwotCQlob3N0LT5kYXRhZW5kID0gdHJ1ZTsKKwkJLyogQ2FsY3VsYXRlIGhvdyBmYXIgd2UgYXJlIGludG8gdGhlIHRyYW5zZmVyICovCisJCXJlbWFpbiA9IHJlYWRsKGhvc3QtPmJhc2UgKyBNTUNJREFUQUNOVCk7CisJCXN1Y2Nlc3MgPSBkYXRhLT5ibGtzeiAqIGRhdGEtPmJsb2NrcyAtIHJlbWFpbjsKKworCQlkZXZfZGJnKG1tY19kZXYoaG9zdC0+bW1jKSwgIk1DSSBFUlJPUiBJUlEgKHN0YXR1cyAlMDh4KVxuIiwgc3RhdHVzKTsKKwkJaWYgKHN0YXR1cyAmIE1DSV9EQVRBQ1JDRkFJTCkgeworCQkJLyogTGFzdCBibG9jayB3YXMgbm90IHN1Y2Nlc3NmdWwgKi8KKwkJCWhvc3QtPmRhdGFfeGZlcmVkID0gcm91bmRfZG93bihzdWNjZXNzIC0gMSwgZGF0YS0+Ymxrc3opOworCQkJZGF0YS0+ZXJyb3IgPSAtRUlMU0VROworCQl9IGVsc2UgaWYgKHN0YXR1cyAmIE1DSV9EQVRBVElNRU9VVCkgeworCQkJaG9zdC0+ZGF0YV94ZmVyZWQgPSByb3VuZF9kb3duKHN1Y2Nlc3MsIGRhdGEtPmJsa3N6KTsKKwkJCWRhdGEtPmVycm9yID0gLUVUSU1FRE9VVDsKKwkJfSBlbHNlIGlmIChzdGF0dXMgJiAoTUNJX1RYVU5ERVJSVU58TUNJX1JYT1ZFUlJVTikpIHsKKwkJCWhvc3QtPmRhdGFfeGZlcmVkID0gcm91bmRfZG93bihzdWNjZXNzLCBkYXRhLT5ibGtzeik7CisJCQlkYXRhLT5lcnJvciA9IC1FSU87CisJCX0KIAogCQkvKgogCQkgKiBXZSBoaXQgYW4gZXJyb3IgY29uZGl0aW9uLiAgRW5zdXJlIHRoYXQgYW55IGRhdGEKQEAgLTMyMSw2MSArMzE3LDE0IEBACiAJCX0KIAl9CiAKLQkvKgotCSAqIE9uIEFSTSB2YXJpYW50cyBpbiBQSU8gbW9kZSwgTUNJX0RBVEFCTE9DS0VORAotCSAqIGlzIGFsd2F5cyBzZW50IGZpcnN0LCBhbmQgd2UgaW5jcmVhc2UgdGhlCi0JICogdHJhbnNmZXJlZCBudW1iZXIgb2YgYnl0ZXMgZm9yIHRoYXQgSVJRLiBUaGVuCi0JICogTUNJX0RBVEFFTkQgZm9sbG93cyBhbmQgd2UgY29uY2x1ZGUgdGhlIHRyYW5zYWN0aW9uLgotCSAqCi0JICogT24gdGhlIFV4NTAwIHNpbmdsZS1JUlEgdmFyaWFudCBNQ0lfREFUQUJMT0NLRU5ECi0JICogZG9lc24ndCBzZWVtIHRvIGltbWVkaWF0ZWx5IGNsZWFyIGZyb20gdGhlIHN0YXR1cywKLQkgKiBzbyB3ZSBjYW4ndCB1c2UgaXQga2VlcCBjb3VudCB3aGVuIG9ubHkgb25lIGlycSBpcwotCSAqIHVzZWQgYmVjYXVzZSB0aGUgaXJxIHdpbGwgaGl0IGZvciBvdGhlciByZWFzb25zLCBhbmQKLQkgKiB0aGVuIHRoZSBmbGFnIGlzIHN0aWxsIHVwLiBTbyB3ZSB1c2UgdGhlIE1DSV9EQVRBRU5ECi0JICogSVJRIGF0IHRoZSBlbmQgb2YgdGhlIGVudGlyZSB0cmFuc2ZlciBiZWNhdXNlCi0JICogTUNJX0RBVEFCTE9DS0VORCBpcyBicm9rZW4uCi0JICoKLQkgKiBJbiB0aGUgVTMwMCwgdGhlIElSUXMgY2FuIGFycml2ZSBvdXQtb2Ytb3JkZXIsCi0JICogZS5nLiBNQ0lfREFUQUJMT0NLRU5EIHNvbWV0aW1lcyBhcnJpdmVzIGFmdGVyIE1DSV9EQVRBRU5ELAotCSAqIHNvIGZvciB0aGlzIGNhc2Ugd2UgdXNlIHRoZSBmbGFncyAiYmxvY2tlbmQiIGFuZAotCSAqICJkYXRhZW5kIiB0byBtYWtlIHN1cmUgYm90aCBJUlFzIGhhdmUgYXJyaXZlZCBiZWZvcmUKLQkgKiBjb25jbHVkaW5nIHRoZSB0cmFuc2FjdGlvbi4gKFRoaXMgZG9lcyBub3QgYXBwbHkKLQkgKiB0byB0aGUgVXg1MDAgd2hpY2ggZG9lc24ndCBmaXJlIE1DSV9EQVRBQkxPQ0tFTkQKLQkgKiBhdCBhbGwuKSBJbiBETUEgbW9kZSBpdCBzdWZmZXJzIGZyb20gdGhlIHNhbWUgcHJvYmxlbQotCSAqIGFzIHRoZSBVeDUwMC4KLQkgKi8KLQlpZiAoc3RhdHVzICYgTUNJX0RBVEFCTE9DS0VORCkgewotCQkvKgotCQkgKiBKdXN0IGJlaW5nIGEgbGl0dGxlIG92ZXItY2F1dGlvdXMsIHdlIGRvIG5vdAotCQkgKiB1c2UgdGhpcyBwcm9ncmVzc2l2ZSB1cGRhdGUgaWYgdGhlIGhhcmR3YXJlIGJsb2NrZW5kCi0JCSAqIGZsYWcgaXMgdW5yZWxpYWJsZTogc2luY2UgaXQgY2FuIHN0YXkgaGlnaCBiZXR3ZWVuCi0JCSAqIElSUXMgaXQgd2lsbCBjb3JydXB0IHRoZSB0cmFuc2ZlciBjb3VudGVyLgotCQkgKi8KLQkJaWYgKCF2YXJpYW50LT5icm9rZW5fYmxvY2tlbmQpCi0JCQlob3N0LT5kYXRhX3hmZXJlZCArPSBkYXRhLT5ibGtzejsKLQkJaG9zdC0+YmxvY2tlbmQgPSB0cnVlOwotCX0KKwlpZiAoc3RhdHVzICYgTUNJX0RBVEFCTE9DS0VORCkKKwkJZGV2X2VycihtbWNfZGV2KGhvc3QtPm1tYyksICJzdHJheSBNQ0lfREFUQUJMT0NLRU5EIGludGVycnVwdFxuIik7CiAKLQlpZiAoc3RhdHVzICYgTUNJX0RBVEFFTkQpCi0JCWhvc3QtPmRhdGFlbmQgPSB0cnVlOwotCi0JLyoKLQkgKiBPbiB2YXJpYW50cyB3aXRoIGJyb2tlbiBibG9ja2VuZCB3ZSBzaGFsbCBvbmx5IHdhaXQgZm9yIGRhdGFlbmQsCi0JICogb24gb3RoZXJzIHdlIG11c3Qgc3luYyB3aXRoIHRoZSBibG9ja2VuZCBzaWduYWwgc2luY2UgdGhleSBjYW4KLQkgKiBhcHBlYXIgb3V0LW9mLW9yZGVyLgotCSAqLwotCWlmIChob3N0LT5kYXRhZW5kICYmIChob3N0LT5ibG9ja2VuZCB8fCB2YXJpYW50LT5icm9rZW5fYmxvY2tlbmQpKSB7CisJaWYgKHN0YXR1cyAmIE1DSV9EQVRBRU5EIHx8IGRhdGEtPmVycm9yKSB7CiAJCW1tY2lfc3RvcF9kYXRhKGhvc3QpOwogCi0JCS8qIFJlc2V0IHRoZXNlIGZsYWdzICovCi0JCWhvc3QtPmJsb2NrZW5kID0gZmFsc2U7Ci0JCWhvc3QtPmRhdGFlbmQgPSBmYWxzZTsKLQotCQkvKgotCQkgKiBWYXJpYW50cyB3aXRoIGJyb2tlbiBibG9ja2VuZCBmbGFncyBuZWVkIHRvIGhhbmRsZSB0aGUKLQkJICogZW5kIG9mIHRoZSBlbnRpcmUgdHJhbnNmZXIgaGVyZS4KLQkJICovCi0JCWlmICh2YXJpYW50LT5icm9rZW5fYmxvY2tlbmQgJiYgIWRhdGEtPmVycm9yKQorCQlpZiAoIWRhdGEtPmVycm9yKQorCQkJLyogVGhlIGVycm9yIGNsYXVzZSBpcyBoYW5kbGVkIGFib3ZlLCBzdWNjZXNzISAqLwogCQkJaG9zdC0+ZGF0YV94ZmVyZWQgKz0gZGF0YS0+Ymxrc3ogKiBkYXRhLT5ibG9ja3M7CiAKIAkJaWYgKCFkYXRhLT5zdG9wKSB7CkBAIC0zOTQsMTUgKzM0MywxNSBAQAogCiAJaG9zdC0+Y21kID0gTlVMTDsKIAotCWNtZC0+cmVzcFswXSA9IHJlYWRsKGJhc2UgKyBNTUNJUkVTUE9OU0UwKTsKLQljbWQtPnJlc3BbMV0gPSByZWFkbChiYXNlICsgTU1DSVJFU1BPTlNFMSk7Ci0JY21kLT5yZXNwWzJdID0gcmVhZGwoYmFzZSArIE1NQ0lSRVNQT05TRTIpOwotCWNtZC0+cmVzcFszXSA9IHJlYWRsKGJhc2UgKyBNTUNJUkVTUE9OU0UzKTsKLQogCWlmIChzdGF0dXMgJiBNQ0lfQ01EVElNRU9VVCkgewogCQljbWQtPmVycm9yID0gLUVUSU1FRE9VVDsKIAl9IGVsc2UgaWYgKHN0YXR1cyAmIE1DSV9DTURDUkNGQUlMICYmIGNtZC0+ZmxhZ3MgJiBNTUNfUlNQX0NSQykgewogCQljbWQtPmVycm9yID0gLUVJTFNFUTsKKwl9IGVsc2UgeworCQljbWQtPnJlc3BbMF0gPSByZWFkbChiYXNlICsgTU1DSVJFU1BPTlNFMCk7CisJCWNtZC0+cmVzcFsxXSA9IHJlYWRsKGJhc2UgKyBNTUNJUkVTUE9OU0UxKTsKKwkJY21kLT5yZXNwWzJdID0gcmVhZGwoYmFzZSArIE1NQ0lSRVNQT05TRTIpOworCQljbWQtPnJlc3BbM10gPSByZWFkbChiYXNlICsgTU1DSVJFU1BPTlNFMyk7CiAJfQogCiAJaWYgKCFjbWQtPmRhdGEgfHwgY21kLT5lcnJvcikgewpAQCAtNzcwLDcgKzcxOSw2IEBACiAJc3RydWN0IHZhcmlhbnRfZGF0YSAqdmFyaWFudCA9IGlkLT5kYXRhOwogCXN0cnVjdCBtbWNpX2hvc3QgKmhvc3Q7CiAJc3RydWN0IG1tY19ob3N0ICptbWM7Ci0JdW5zaWduZWQgaW50IG1hc2s7CiAJaW50IHJldDsKIAogCS8qIG11c3QgaGF2ZSBwbGF0Zm9ybSBkYXRhICovCkBAIC05NTEsMTIgKzg5OSw3IEBACiAJCQlnb3RvIGlycTBfZnJlZTsKIAl9CiAKLQltYXNrID0gTUNJX0lSUUVOQUJMRTsKLQkvKiBEb24ndCB1c2UgdGhlIGRhdGFibG9ja2VuZCBmbGFnIGlmIGl0J3MgYnJva2VuICovCi0JaWYgKHZhcmlhbnQtPmJyb2tlbl9ibG9ja2VuZCkKLQkJbWFzayAmPSB+TUNJX0RBVEFCTE9DS0VORDsKLQotCXdyaXRlbChtYXNrLCBob3N0LT5iYXNlICsgTU1DSU1BU0swKTsKKwl3cml0ZWwoTUNJX0lSUUVOQUJMRSwgaG9zdC0+YmFzZSArIE1NQ0lNQVNLMCk7CiAKIAlhbWJhX3NldF9kcnZkYXRhKGRldiwgbW1jKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tbWMvaG9zdC9tbWNpLmggYi9kcml2ZXJzL21tYy9ob3N0L21tY2kuaAppbmRleCBkZjA2ZjAxLi5jMWRmN2I4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21tYy9ob3N0L21tY2kuaAorKysgYi9kcml2ZXJzL21tYy9ob3N0L21tY2kuaApAQCAtMTM3LDcgKzEzNyw3IEBACiAjZGVmaW5lIE1DSV9JUlFFTkFCTEUJXAogCShNQ0lfQ01EQ1JDRkFJTE1BU0t8TUNJX0RBVEFDUkNGQUlMTUFTS3xNQ0lfQ01EVElNRU9VVE1BU0t8CVwKIAlNQ0lfREFUQVRJTUVPVVRNQVNLfE1DSV9UWFVOREVSUlVOTUFTS3xNQ0lfUlhPVkVSUlVOTUFTS3wJXAotCU1DSV9DTURSRVNQRU5ETUFTS3xNQ0lfQ01EU0VOVE1BU0t8TUNJX0RBVEFCTE9DS0VORE1BU0spCisJTUNJX0NNRFJFU1BFTkRNQVNLfE1DSV9DTURTRU5UTUFTSykKIAogLyogVGhlc2UgaW50ZXJydXB0cyBhcmUgZGlyZWN0ZWQgdG8gSVJRMSB3aGVuIHR3byBJUlEgbGluZXMgYXJlIGF2YWlsYWJsZSAqLwogI2RlZmluZSBNQ0lfSVJRMU1BU0sgXApAQCAtMTc3LDkgKzE3Nyw2IEBACiAJc3RydWN0IHRpbWVyX2xpc3QJdGltZXI7CiAJdW5zaWduZWQgaW50CQlvbGRzdGF0OwogCi0JYm9vbAkJCWJsb2NrZW5kOwotCWJvb2wJCQlkYXRhZW5kOwotCiAJLyogcGlvIHN0dWZmICovCiAJc3RydWN0IHNnX21hcHBpbmdfaXRlcglzZ19taXRlcjsKIAl1bnNpZ25lZCBpbnQJCXNpemU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21tYy9ob3N0L21zbV9zZGNjLmMgYi9kcml2ZXJzL21tYy9ob3N0L21zbV9zZGNjLmMKaW5kZXggNWRlY2ZkMC4uMTUzYWI5NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tbWMvaG9zdC9tc21fc2RjYy5jCisrKyBiL2RyaXZlcnMvbW1jL2hvc3QvbXNtX3NkY2MuYwpAQCAtMzgzLDE0ICszODMsMzAgQEAKIAlob3N0LT5jdXJyLnVzZXJfcGFnZXMgPSAwOwogCiAJYm94ID0gJm5jLT5jbWRbMF07Ci0JZm9yIChpID0gMDsgaSA8IGhvc3QtPmRtYS5udW1fZW50czsgaSsrKSB7CisKKwkvKiBsb2NhdGlvbiBvZiBjb21tYW5kIGJsb2NrIG11c3QgYmUgNjQgYml0IGFsaWduZWQgKi8KKwlCVUdfT04oaG9zdC0+ZG1hLmNtZF9idXNhZGRyICYgMHgwNyk7CisKKwluYy0+Y21kcHRyID0gKGhvc3QtPmRtYS5jbWRfYnVzYWRkciA+PiAzKSB8IENNRF9QVFJfTFA7CisJaG9zdC0+ZG1hLmhkci5jbWRwdHIgPSBETU9WX0NNRF9QVFJfTElTVCB8CisJCQkgICAgICAgRE1PVl9DTURfQUREUihob3N0LT5kbWEuY21kcHRyX2J1c2FkZHIpOworCWhvc3QtPmRtYS5oZHIuY29tcGxldGVfZnVuYyA9IG1zbXNkY2NfZG1hX2NvbXBsZXRlX2Z1bmM7CisKKwluID0gZG1hX21hcF9zZyhtbWNfZGV2KGhvc3QtPm1tYyksIGhvc3QtPmRtYS5zZywKKwkJCWhvc3QtPmRtYS5udW1fZW50cywgaG9zdC0+ZG1hLmRpcik7CisJaWYgKG4gPT0gMCkgeworCQlwcmludGsoS0VSTl9FUlIgIiVzOiBVbmFibGUgdG8gbWFwIGluIGFsbCBzZyBlbGVtZW50c1xuIiwKKwkJCW1tY19ob3N0bmFtZShob3N0LT5tbWMpKTsKKwkJaG9zdC0+ZG1hLnNnID0gTlVMTDsKKwkJaG9zdC0+ZG1hLm51bV9lbnRzID0gMDsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJZm9yX2VhY2hfc2coaG9zdC0+ZG1hLnNnLCBzZywgbiwgaSkgeworCiAJCWJveC0+Y21kID0gQ01EX01PREVfQk9YOwogCi0JLyogSW5pdGlhbGl6ZSBzZyBkbWEgYWRkcmVzcyAqLwotCXNnLT5kbWFfYWRkcmVzcyA9IHBhZ2VfdG9fZG1hKG1tY19kZXYoaG9zdC0+bW1jKSwgc2dfcGFnZShzZykpCi0JCQkJKyBzZy0+b2Zmc2V0OwotCi0JaWYgKGkgPT0gKGhvc3QtPmRtYS5udW1fZW50cyAtIDEpKQorCQlpZiAoaSA9PSBuIC0gMSkKIAkJCWJveC0+Y21kIHw9IENNRF9MQzsKIAkJcm93cyA9IChzZ19kbWFfbGVuKHNnKSAlIE1DSV9GSUZPU0laRSkgPwogCQkJKHNnX2RtYV9sZW4oc2cpIC8gTUNJX0ZJRk9TSVpFKSArIDEgOgpAQCAtNDE4LDI3ICs0MzQsNiBAQAogCQkJYm94LT5jbWQgfD0gQ01EX0RTVF9DUkNJKGNyY2kpOwogCQl9CiAJCWJveCsrOwotCQlzZysrOwotCX0KLQotCS8qIGxvY2F0aW9uIG9mIGNvbW1hbmQgYmxvY2sgbXVzdCBiZSA2NCBiaXQgYWxpZ25lZCAqLwotCUJVR19PTihob3N0LT5kbWEuY21kX2J1c2FkZHIgJiAweDA3KTsKLQotCW5jLT5jbWRwdHIgPSAoaG9zdC0+ZG1hLmNtZF9idXNhZGRyID4+IDMpIHwgQ01EX1BUUl9MUDsKLQlob3N0LT5kbWEuaGRyLmNtZHB0ciA9IERNT1ZfQ01EX1BUUl9MSVNUIHwKLQkJCSAgICAgICBETU9WX0NNRF9BRERSKGhvc3QtPmRtYS5jbWRwdHJfYnVzYWRkcik7Ci0JaG9zdC0+ZG1hLmhkci5jb21wbGV0ZV9mdW5jID0gbXNtc2RjY19kbWFfY29tcGxldGVfZnVuYzsKLQotCW4gPSBkbWFfbWFwX3NnKG1tY19kZXYoaG9zdC0+bW1jKSwgaG9zdC0+ZG1hLnNnLAotCQkJaG9zdC0+ZG1hLm51bV9lbnRzLCBob3N0LT5kbWEuZGlyKTsKLS8qIGRzYiBpbnNpZGUgZG1hX21hcF9zZyB3aWxsIHdyaXRlIG5jIG91dCB0byBtZW0gYXMgd2VsbCAqLwotCi0JaWYgKG4gIT0gaG9zdC0+ZG1hLm51bV9lbnRzKSB7Ci0JCXByaW50ayhLRVJOX0VSUiAiJXM6IFVuYWJsZSB0byBtYXAgaW4gYWxsIHNnIGVsZW1lbnRzXG4iLAotCQkJbW1jX2hvc3RuYW1lKGhvc3QtPm1tYykpOwotCQlob3N0LT5kbWEuc2cgPSBOVUxMOwotCQlob3N0LT5kbWEubnVtX2VudHMgPSAwOwotCQlyZXR1cm4gLUVOT01FTTsKIAl9CiAKIAlyZXR1cm4gMDsKQEAgLTEzMzEsOSArMTMyNiw2IEBACiAJaWYgKGhvc3QtPnRpbWVyLmZ1bmN0aW9uKQogCQlwcl9pbmZvKCIlczogUG9sbGluZyBzdGF0dXMgbW9kZSBlbmFibGVkXG4iLCBtbWNfaG9zdG5hbWUobW1jKSk7CiAKLSNpZiBCVVNDTEtfUFdSU0FWRQotCW1zbXNkY2NfZGlzYWJsZV9jbG9ja3MoaG9zdCwgMSk7Ci0jZW5kaWYKIAlyZXR1cm4gMDsKICBjbWRfaXJxX2ZyZWU6CiAJZnJlZV9pcnEoY21kX2lycXJlcy0+c3RhcnQsIGhvc3QpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tbWMvaG9zdC9zZGhjaS1vZi1jb3JlLmMgYi9kcml2ZXJzL21tYy9ob3N0L3NkaGNpLW9mLWNvcmUuYwppbmRleCBmYTE5ZDg0Li5kZDg0MTI0ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tbWMvaG9zdC9zZGhjaS1vZi1jb3JlLmMKKysrIGIvZHJpdmVycy9tbWMvaG9zdC9zZGhjaS1vZi1jb3JlLmMKQEAgLTEzLDYgKzEzLDcgQEAKICAqIHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KICAqLwogCisjaW5jbHVkZSA8bGludXgvZXJyLmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogI2luY2x1ZGUgPGxpbnV4L2lvLmg+CkBAIC0yMCw4ICsyMSwxMiBAQAogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiAjaW5jbHVkZSA8bGludXgvb2YuaD4KICNpbmNsdWRlIDxsaW51eC9vZl9wbGF0Zm9ybS5oPgorI2luY2x1ZGUgPGxpbnV4L29mX2FkZHJlc3MuaD4KKyNpbmNsdWRlIDxsaW51eC9vZl9pcnEuaD4KICNpbmNsdWRlIDxsaW51eC9tbWMvaG9zdC5oPgorI2lmZGVmIENPTkZJR19QUEMKICNpbmNsdWRlIDxhc20vbWFjaGRlcC5oPgorI2VuZGlmCiAjaW5jbHVkZSAic2RoY2ktb2YuaCIKICNpbmNsdWRlICJzZGhjaS5oIgogCkBAIC0xMTIsNyArMTE3LDExIEBACiAJCXJldHVybiB0cnVlOwogCiAJLyogT2xkIGRldmljZSB0cmVlcyBkb24ndCBoYXZlIHRoZSB3cC1pbnZlcnRlZCBwcm9wZXJ0eS4gKi8KKyNpZmRlZiBDT05GSUdfUFBDCiAJcmV0dXJuIG1hY2hpbmVfaXMobXBjODM3eF9yZGIpIHx8IG1hY2hpbmVfaXMobXBjODM3eF9tZHMpOworI2Vsc2UKKwlyZXR1cm4gZmFsc2U7CisjZW5kaWYKIH0KIAogc3RhdGljIGludCBfX2RldmluaXQgc2RoY2lfb2ZfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqb2ZkZXYsCmRpZmYgLS1naXQgYS9kcml2ZXJzL21tYy9ob3N0L3NkaGNpLXMzYy5jIGIvZHJpdmVycy9tbWMvaG9zdC9zZGhjaS1zM2MuYwppbmRleCAxNzIwMzU4Li41MzA5YWI5IDEwMDY0NAotLS0gYS9kcml2ZXJzL21tYy9ob3N0L3NkaGNpLXMzYy5jCisrKyBiL2RyaXZlcnMvbW1jL2hvc3Qvc2RoY2ktczNjLmMKQEAgLTI3NywxMCArMjc3LDQzIEBACiAJaG9zdC0+Y2xvY2sgPSBjbG9jazsKIH0KIAorLyoqCisgKiBzZGhjaV9zM2NfcGxhdGZvcm1fOGJpdF93aWR0aCAtIHN1cHBvcnQgOGJpdCBidXN3aWR0aAorICogQGhvc3Q6IFRoZSBTREhDSSBob3N0IGJlaW5nIHF1ZXJpZWQKKyAqIEB3aWR0aDogTU1DX0JVU19XSURUSF8gbWFjcm8gZm9yIHRoZSBidXMgd2lkdGggYmVpbmcgcmVxdWVzdGVkCisgKgorICogV2UgaGF2ZSA4LWJpdCB3aWR0aCBzdXBwb3J0IGJ1dCBpcyBub3QgYSB2MyBjb250cm9sbGVyLgorICogU28gd2UgYWRkIHBsYXRmb3JtXzhiaXRfd2lkdGgoKSBhbmQgc3VwcG9ydCA4Yml0IHdpZHRoLgorICovCitzdGF0aWMgaW50IHNkaGNpX3MzY19wbGF0Zm9ybV84Yml0X3dpZHRoKHN0cnVjdCBzZGhjaV9ob3N0ICpob3N0LCBpbnQgd2lkdGgpCit7CisJdTggY3RybDsKKworCWN0cmwgPSBzZGhjaV9yZWFkYihob3N0LCBTREhDSV9IT1NUX0NPTlRST0wpOworCisJc3dpdGNoICh3aWR0aCkgeworCWNhc2UgTU1DX0JVU19XSURUSF84OgorCQljdHJsIHw9IFNESENJX0NUUkxfOEJJVEJVUzsKKwkJY3RybCAmPSB+U0RIQ0lfQ1RSTF80QklUQlVTOworCQlicmVhazsKKwljYXNlIE1NQ19CVVNfV0lEVEhfNDoKKwkJY3RybCB8PSBTREhDSV9DVFJMXzRCSVRCVVM7CisJCWN0cmwgJj0gflNESENJX0NUUkxfOEJJVEJVUzsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYnJlYWs7CisJfQorCisJc2RoY2lfd3JpdGViKGhvc3QsIGN0cmwsIFNESENJX0hPU1RfQ09OVFJPTCk7CisKKwlyZXR1cm4gMDsKK30KKwogc3RhdGljIHN0cnVjdCBzZGhjaV9vcHMgc2RoY2lfczNjX29wcyA9IHsKIAkuZ2V0X21heF9jbG9jawkJPSBzZGhjaV9zM2NfZ2V0X21heF9jbGssCiAJLnNldF9jbG9jawkJPSBzZGhjaV9zM2Nfc2V0X2Nsb2NrLAogCS5nZXRfbWluX2Nsb2NrCQk9IHNkaGNpX3MzY19nZXRfbWluX2Nsb2NrLAorCS5wbGF0Zm9ybV84Yml0X3dpZHRoCT0gc2RoY2lfczNjX3BsYXRmb3JtXzhiaXRfd2lkdGgsCiB9OwogCiBzdGF0aWMgdm9pZCBzZGhjaV9zM2Nfbm90aWZ5X2NoYW5nZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpkZXYsIGludCBzdGF0ZSkKQEAgLTQ3Myw2ICs1MDYsOSBAQAogCWlmIChwZGF0YS0+Y2RfdHlwZSA9PSBTM0NfU0RIQ0lfQ0RfUEVSTUFORU5UKQogCQlob3N0LT5tbWMtPmNhcHMgPSBNTUNfQ0FQX05PTlJFTU9WQUJMRTsKIAorCWlmIChwZGF0YS0+aG9zdF9jYXBzKQorCQlob3N0LT5tbWMtPmNhcHMgfD0gcGRhdGEtPmhvc3RfY2FwczsKKwogCWhvc3QtPnF1aXJrcyB8PSAoU0RIQ0lfUVVJUktfMzJCSVRfRE1BX0FERFIgfAogCQkJIFNESENJX1FVSVJLXzMyQklUX0RNQV9TSVpFKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tbWMvaG9zdC91c2hjLmMgYi9kcml2ZXJzL21tYy9ob3N0L3VzaGMuYwppbmRleCBmOGY2NWRmLi5mMDhmOTQ0IDEwMDY0NAotLS0gYS9kcml2ZXJzL21tYy9ob3N0L3VzaGMuYworKysgYi9kcml2ZXJzL21tYy9ob3N0L3VzaGMuYwpAQCAtMTksNyArMTksNiBAQAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L3VzYi5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgotI2luY2x1ZGUgPGxpbnV4L3VzYi5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgogI2luY2x1ZGUgPGxpbnV4L21tYy9ob3N0Lmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9LY29uZmlnIGIvZHJpdmVycy9tdGQvS2NvbmZpZwppbmRleCBiMWY3Njg5Li43NzQxNDcwIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9LY29uZmlnCisrKyBiL2RyaXZlcnMvbXRkL0tjb25maWcKQEAgLTUzLDkgKzUzLDEwIEBACiAJICBkZXZpY2VzLiBQYXJ0aXRpb25pbmcgb24gTkZUTCAnZGV2aWNlcycgaXMgYSBkaWZmZXJlbnQgLSB0aGF0J3MgdGhlCiAJICAnbm9ybWFsJyBmb3JtIG9mIHBhcnRpdGlvbmluZyB1c2VkIG9uIGEgYmxvY2sgZGV2aWNlLgogCitpZiBNVERfUEFSVElUSU9OUworCiBjb25maWcgTVREX1JFREJPT1RfUEFSVFMKIAl0cmlzdGF0ZSAiUmVkQm9vdCBwYXJ0aXRpb24gdGFibGUgcGFyc2luZyIKLQlkZXBlbmRzIG9uIE1URF9QQVJUSVRJT05TCiAJLS0taGVscC0tLQogCSAgUmVkQm9vdCBpcyBhIFJPTSBtb25pdG9yIGFuZCBib290bG9hZGVyIHdoaWNoIGRlYWxzIHdpdGggbXVsdGlwbGUKIAkgICdpbWFnZXMnIGluIGZsYXNoIGRldmljZXMgYnkgcHV0dGluZyBhIHRhYmxlIG9uZSBvZiB0aGUgZXJhc2UKQEAgLTcyLDkgKzczLDEwIEBACiAJICBTQTExMDAgbWFwIGRyaXZlciAoQ09ORklHX01URF9TQTExMDApIGhhcyBhbiBvcHRpb24gZm9yIHRoaXMsIGZvcgogCSAgZXhhbXBsZS4KIAoraWYgTVREX1JFREJPT1RfUEFSVFMKKwogY29uZmlnIE1URF9SRURCT09UX0RJUkVDVE9SWV9CTE9DSwogCWludCAiTG9jYXRpb24gb2YgUmVkQm9vdCBwYXJ0aXRpb24gdGFibGUiCi0JZGVwZW5kcyBvbiBNVERfUkVEQk9PVF9QQVJUUwogCWRlZmF1bHQgIi0xIgogCS0tLWhlbHAtLS0KIAkgIFRoaXMgb3B0aW9uIGlzIHRoZSBMaW51eCBjb3VudGVycGFydCB0byB0aGUKQEAgLTkxLDE4ICs5MywxOCBAQAogCiBjb25maWcgTVREX1JFREJPT1RfUEFSVFNfVU5BTExPQ0FURUQKIAlib29sICJJbmNsdWRlIHVuYWxsb2NhdGVkIGZsYXNoIHJlZ2lvbnMiCi0JZGVwZW5kcyBvbiBNVERfUkVEQk9PVF9QQVJUUwogCWhlbHAKIAkgIElmIHlvdSBuZWVkIHRvIHJlZ2lzdGVyIGVhY2ggdW5hbGxvY2F0ZWQgZmxhc2ggcmVnaW9uIGFzIGEgTVRECiAJICAncGFydGl0aW9uJywgZW5hYmxlIHRoaXMgb3B0aW9uLgogCiBjb25maWcgTVREX1JFREJPT1RfUEFSVFNfUkVBRE9OTFkKIAlib29sICJGb3JjZSByZWFkLW9ubHkgZm9yIFJlZEJvb3Qgc3lzdGVtIGltYWdlcyIKLQlkZXBlbmRzIG9uIE1URF9SRURCT09UX1BBUlRTCiAJaGVscAogCSAgSWYgeW91IG5lZWQgdG8gZm9yY2UgcmVhZC1vbmx5IGZvciAnUmVkQm9vdCcsICdSZWRCb290IENvbmZpZycgYW5kCiAJICAnRklTIGRpcmVjdG9yeScgaW1hZ2VzLCBlbmFibGUgdGhpcyBvcHRpb24uCiAKK2VuZGlmICMgTVREX1JFREJPT1RfUEFSVFMKKwogY29uZmlnIE1URF9DTURMSU5FX1BBUlRTCiAJYm9vbCAiQ29tbWFuZCBsaW5lIHBhcnRpdGlvbiB0YWJsZSBwYXJzaW5nIgogCWRlcGVuZHMgb24gTVREX1BBUlRJVElPTlMgPSAieSIgJiYgTVREID0gInkiCkBAIC0xNDIsNyArMTQ0LDcgQEAKIAogY29uZmlnIE1URF9BRlNfUEFSVFMKIAl0cmlzdGF0ZSAiQVJNIEZpcm13YXJlIFN1aXRlIHBhcnRpdGlvbiBwYXJzaW5nIgotCWRlcGVuZHMgb24gQVJNICYmIE1URF9QQVJUSVRJT05TCisJZGVwZW5kcyBvbiBBUk0KIAktLS1oZWxwLS0tCiAJICBUaGUgQVJNIEZpcm13YXJlIFN1aXRlIGFsbG93cyB0aGUgdXNlciB0byBkaXZpZGUgZmxhc2ggZGV2aWNlcyBpbnRvCiAJICBtdWx0aXBsZSAnaW1hZ2VzJy4gRWFjaCBzdWNoIGltYWdlIGhhcyBhIGhlYWRlciBjb250YWluaW5nIGl0cyBuYW1lCkBAIC0xNTgsOCArMTYwLDggQEAKIAkgIGV4YW1wbGUuCiAKIGNvbmZpZyBNVERfT0ZfUEFSVFMKLQl0cmlzdGF0ZSAiRmxhc2ggcGFydGl0aW9uIG1hcCBiYXNlZCBvbiBPRiBkZXNjcmlwdGlvbiIKLQlkZXBlbmRzIG9uIE9GICYmIE1URF9QQVJUSVRJT05TCisJZGVmX2Jvb2wgeQorCWRlcGVuZHMgb24gT0YKIAloZWxwCiAJICBUaGlzIHByb3ZpZGVzIGEgcGFydGl0aW9uIHBhcnNpbmcgZnVuY3Rpb24gd2hpY2ggZGVyaXZlcwogCSAgdGhlIHBhcnRpdGlvbiBtYXAgZnJvbSB0aGUgY2hpbGRyZW4gb2YgdGhlIGZsYXNoIG5vZGUsCkBAIC0xNjcsMTAgKzE2OSwxMSBAQAogCiBjb25maWcgTVREX0FSN19QQVJUUwogCXRyaXN0YXRlICJUSSBBUjcgcGFydGl0aW9uaW5nIHN1cHBvcnQiCi0JZGVwZW5kcyBvbiBNVERfUEFSVElUSU9OUwogCS0tLWhlbHAtLS0KIAkgIFRJIEFSNyBwYXJ0aXRpb25pbmcgc3VwcG9ydAogCitlbmRpZiAjIE1URF9QQVJUSVRJT05TCisKIGNvbW1lbnQgIlVzZXIgTW9kdWxlcyBBbmQgVHJhbnNsYXRpb24gTGF5ZXJzIgogCiBjb25maWcgTVREX0NIQVIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL01ha2VmaWxlIGIvZHJpdmVycy9tdGQvTWFrZWZpbGUKaW5kZXggNzYwYWJjNS4uZDRlN2YyNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9tdGQvTWFrZWZpbGUKQEAgLTYsMTMgKzYsMTMgQEAKIG9iai0kKENPTkZJR19NVEQpCQkrPSBtdGQubwogbXRkLXkJCQkJOj0gbXRkY29yZS5vIG10ZHN1cGVyLm8KIG10ZC0kKENPTkZJR19NVERfUEFSVElUSU9OUykJKz0gbXRkcGFydC5vCittdGQtJChDT05GSUdfTVREX09GX1BBUlRTKQkrPSBvZnBhcnQubwogCiBvYmotJChDT05GSUdfTVREX0NPTkNBVCkJKz0gbXRkY29uY2F0Lm8KIG9iai0kKENPTkZJR19NVERfUkVEQk9PVF9QQVJUUykgKz0gcmVkYm9vdC5vCiBvYmotJChDT05GSUdfTVREX0NNRExJTkVfUEFSVFMpICs9IGNtZGxpbmVwYXJ0Lm8KIG9iai0kKENPTkZJR19NVERfQUZTX1BBUlRTKQkrPSBhZnMubwogb2JqLSQoQ09ORklHX01URF9BUjdfUEFSVFMpCSs9IGFyN3BhcnQubwotb2JqLSQoQ09ORklHX01URF9PRl9QQVJUUykgICAgICArPSBvZnBhcnQubwogCiAjICdVc2VycycgLSBjb2RlIHdoaWNoIHByZXNlbnRzIGZ1bmN0aW9uYWxpdHkgdG8gdXNlcnNwYWNlLgogb2JqLSQoQ09ORklHX01URF9DSEFSKQkJKz0gbXRkY2hhci5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9jaGlwcy9jZmlfY21kc2V0XzAwMDEuYyBiL2RyaXZlcnMvbXRkL2NoaXBzL2NmaV9jbWRzZXRfMDAwMS5jCmluZGV4IGFkOTI2OGIuLmE4YzNlMWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL2NoaXBzL2NmaV9jbWRzZXRfMDAwMS5jCisrKyBiL2RyaXZlcnMvbXRkL2NoaXBzL2NmaV9jbWRzZXRfMDAwMS5jCkBAIC0xNjIsNyArMTYyLDcgQEAKICNlbmRpZgogCiAvKiBBdG1lbCBjaGlwcyBkb24ndCB1c2UgdGhlIHNhbWUgUFJJIGZvcm1hdCBhcyBJbnRlbCBjaGlwcyAqLwotc3RhdGljIHZvaWQgZml4dXBfY29udmVydF9hdG1lbF9wcmkoc3RydWN0IG10ZF9pbmZvICptdGQsIHZvaWQgKnBhcmFtKQorc3RhdGljIHZvaWQgZml4dXBfY29udmVydF9hdG1lbF9wcmkoc3RydWN0IG10ZF9pbmZvICptdGQpCiB7CiAJc3RydWN0IG1hcF9pbmZvICptYXAgPSBtdGQtPnByaXY7CiAJc3RydWN0IGNmaV9wcml2YXRlICpjZmkgPSBtYXAtPmZsZHJ2X3ByaXY7CkBAIC0yMDIsNyArMjAyLDcgQEAKIAljZmktPmNmaXEtPkJ1ZldyaXRlVGltZW91dE1heCA9IDA7CiB9CiAKLXN0YXRpYyB2b2lkIGZpeHVwX2F0NDlidjY0MGR4X2xvY2soc3RydWN0IG10ZF9pbmZvICptdGQsIHZvaWQgKnBhcmFtKQorc3RhdGljIHZvaWQgZml4dXBfYXQ0OWJ2NjQwZHhfbG9jayhzdHJ1Y3QgbXRkX2luZm8gKm10ZCkKIHsKIAlzdHJ1Y3QgbWFwX2luZm8gKm1hcCA9IG10ZC0+cHJpdjsKIAlzdHJ1Y3QgY2ZpX3ByaXZhdGUgKmNmaSA9IG1hcC0+ZmxkcnZfcHJpdjsKQEAgLTIxNCw3ICsyMTQsNyBAQAogCiAjaWZkZWYgQ01EU0VUMDAwMV9ESVNBQkxFX0VSQVNFX1NVU1BFTkRfT05fV1JJVEUKIC8qIFNvbWUgSW50ZWwgU3RyYXRhIEZsYXNoIHByaW9yIHRvIEZQTyByZXZpc2lvbiBDIGhhcyBidWdzIGluIHRoaXMgYXJlYSAqLwotc3RhdGljIHZvaWQgZml4dXBfaW50ZWxfc3RyYXRhZmxhc2goc3RydWN0IG10ZF9pbmZvICptdGQsIHZvaWQqIHBhcmFtKQorc3RhdGljIHZvaWQgZml4dXBfaW50ZWxfc3RyYXRhZmxhc2goc3RydWN0IG10ZF9pbmZvICptdGQpCiB7CiAJc3RydWN0IG1hcF9pbmZvICptYXAgPSBtdGQtPnByaXY7CiAJc3RydWN0IGNmaV9wcml2YXRlICpjZmkgPSBtYXAtPmZsZHJ2X3ByaXY7CkBAIC0yMjcsNyArMjI3LDcgQEAKICNlbmRpZgogCiAjaWZkZWYgQ01EU0VUMDAwMV9ESVNBQkxFX1dSSVRFX1NVU1BFTkQKLXN0YXRpYyB2b2lkIGZpeHVwX25vX3dyaXRlX3N1c3BlbmQoc3RydWN0IG10ZF9pbmZvICptdGQsIHZvaWQqIHBhcmFtKQorc3RhdGljIHZvaWQgZml4dXBfbm9fd3JpdGVfc3VzcGVuZChzdHJ1Y3QgbXRkX2luZm8gKm10ZCkKIHsKIAlzdHJ1Y3QgbWFwX2luZm8gKm1hcCA9IG10ZC0+cHJpdjsKIAlzdHJ1Y3QgY2ZpX3ByaXZhdGUgKmNmaSA9IG1hcC0+ZmxkcnZfcHJpdjsKQEAgLTI0MCw3ICsyNDAsNyBAQAogfQogI2VuZGlmCiAKLXN0YXRpYyB2b2lkIGZpeHVwX3N0X20yOHczMjBjdChzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgdm9pZCogcGFyYW0pCitzdGF0aWMgdm9pZCBmaXh1cF9zdF9tMjh3MzIwY3Qoc3RydWN0IG10ZF9pbmZvICptdGQpCiB7CiAJc3RydWN0IG1hcF9pbmZvICptYXAgPSBtdGQtPnByaXY7CiAJc3RydWN0IGNmaV9wcml2YXRlICpjZmkgPSBtYXAtPmZsZHJ2X3ByaXY7CkBAIC0yNDksNyArMjQ5LDcgQEAKIAljZmktPmNmaXEtPkJ1ZldyaXRlVGltZW91dE1heCA9IDA7CS8qIE5vdCBzdXBwb3J0ZWQgKi8KIH0KIAotc3RhdGljIHZvaWQgZml4dXBfc3RfbTI4dzMyMGNiKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCB2b2lkKiBwYXJhbSkKK3N0YXRpYyB2b2lkIGZpeHVwX3N0X20yOHczMjBjYihzdHJ1Y3QgbXRkX2luZm8gKm10ZCkKIHsKIAlzdHJ1Y3QgbWFwX2luZm8gKm1hcCA9IG10ZC0+cHJpdjsKIAlzdHJ1Y3QgY2ZpX3ByaXZhdGUgKmNmaSA9IG1hcC0+ZmxkcnZfcHJpdjsKQEAgLTI1OSw3ICsyNTksNyBAQAogCQkoY2ZpLT5jZmlxLT5FcmFzZVJlZ2lvbkluZm9bMV0gJiAweGZmZmYwMDAwKSB8IDB4M2U7CiB9OwogCi1zdGF0aWMgdm9pZCBmaXh1cF91c2VfcG9pbnQoc3RydWN0IG10ZF9pbmZvICptdGQsIHZvaWQgKnBhcmFtKQorc3RhdGljIHZvaWQgZml4dXBfdXNlX3BvaW50KHN0cnVjdCBtdGRfaW5mbyAqbXRkKQogewogCXN0cnVjdCBtYXBfaW5mbyAqbWFwID0gbXRkLT5wcml2OwogCWlmICghbXRkLT5wb2ludCAmJiBtYXBfaXNfbGluZWFyKG1hcCkpIHsKQEAgLTI2OCw3ICsyNjgsNyBAQAogCX0KIH0KIAotc3RhdGljIHZvaWQgZml4dXBfdXNlX3dyaXRlX2J1ZmZlcnMoc3RydWN0IG10ZF9pbmZvICptdGQsIHZvaWQgKnBhcmFtKQorc3RhdGljIHZvaWQgZml4dXBfdXNlX3dyaXRlX2J1ZmZlcnMoc3RydWN0IG10ZF9pbmZvICptdGQpCiB7CiAJc3RydWN0IG1hcF9pbmZvICptYXAgPSBtdGQtPnByaXY7CiAJc3RydWN0IGNmaV9wcml2YXRlICpjZmkgPSBtYXAtPmZsZHJ2X3ByaXY7CkBAIC0yODIsNyArMjgyLDcgQEAKIC8qCiAgKiBTb21lIGNoaXBzIHBvd2VyLXVwIHdpdGggYWxsIHNlY3RvcnMgbG9ja2VkIGJ5IGRlZmF1bHQuCiAgKi8KLXN0YXRpYyB2b2lkIGZpeHVwX3VubG9ja19wb3dlcnVwX2xvY2soc3RydWN0IG10ZF9pbmZvICptdGQsIHZvaWQgKnBhcmFtKQorc3RhdGljIHZvaWQgZml4dXBfdW5sb2NrX3Bvd2VydXBfbG9jayhzdHJ1Y3QgbXRkX2luZm8gKm10ZCkKIHsKIAlzdHJ1Y3QgbWFwX2luZm8gKm1hcCA9IG10ZC0+cHJpdjsKIAlzdHJ1Y3QgY2ZpX3ByaXZhdGUgKmNmaSA9IG1hcC0+ZmxkcnZfcHJpdjsKQEAgLTI5NSwzMSArMjk1LDMxIEBACiB9CiAKIHN0YXRpYyBzdHJ1Y3QgY2ZpX2ZpeHVwIGNmaV9maXh1cF90YWJsZVtdID0gewotCXsgQ0ZJX01GUl9BVE1FTCwgQ0ZJX0lEX0FOWSwgZml4dXBfY29udmVydF9hdG1lbF9wcmksIE5VTEwgfSwKLQl7IENGSV9NRlJfQVRNRUwsIEFUNDlCVjY0MEQsIGZpeHVwX2F0NDlidjY0MGR4X2xvY2ssIE5VTEwgfSwKLQl7IENGSV9NRlJfQVRNRUwsIEFUNDlCVjY0MERULCBmaXh1cF9hdDQ5YnY2NDBkeF9sb2NrLCBOVUxMIH0sCisJeyBDRklfTUZSX0FUTUVMLCBDRklfSURfQU5ZLCBmaXh1cF9jb252ZXJ0X2F0bWVsX3ByaSB9LAorCXsgQ0ZJX01GUl9BVE1FTCwgQVQ0OUJWNjQwRCwgZml4dXBfYXQ0OWJ2NjQwZHhfbG9jayB9LAorCXsgQ0ZJX01GUl9BVE1FTCwgQVQ0OUJWNjQwRFQsIGZpeHVwX2F0NDlidjY0MGR4X2xvY2sgfSwKICNpZmRlZiBDTURTRVQwMDAxX0RJU0FCTEVfRVJBU0VfU1VTUEVORF9PTl9XUklURQotCXsgQ0ZJX01GUl9BTlksIENGSV9JRF9BTlksIGZpeHVwX2ludGVsX3N0cmF0YWZsYXNoLCBOVUxMIH0sCisJeyBDRklfTUZSX0FOWSwgQ0ZJX0lEX0FOWSwgZml4dXBfaW50ZWxfc3RyYXRhZmxhc2ggfSwKICNlbmRpZgogI2lmZGVmIENNRFNFVDAwMDFfRElTQUJMRV9XUklURV9TVVNQRU5ECi0JeyBDRklfTUZSX0FOWSwgQ0ZJX0lEX0FOWSwgZml4dXBfbm9fd3JpdGVfc3VzcGVuZCwgTlVMTCB9LAorCXsgQ0ZJX01GUl9BTlksIENGSV9JRF9BTlksIGZpeHVwX25vX3dyaXRlX3N1c3BlbmQgfSwKICNlbmRpZgogI2lmICFGT1JDRV9XT1JEX1dSSVRFCi0JeyBDRklfTUZSX0FOWSwgQ0ZJX0lEX0FOWSwgZml4dXBfdXNlX3dyaXRlX2J1ZmZlcnMsIE5VTEwgfSwKKwl7IENGSV9NRlJfQU5ZLCBDRklfSURfQU5ZLCBmaXh1cF91c2Vfd3JpdGVfYnVmZmVycyB9LAogI2VuZGlmCi0JeyBDRklfTUZSX1NULCAweDAwYmEsIC8qIE0yOFczMjBDVCAqLyBmaXh1cF9zdF9tMjh3MzIwY3QsIE5VTEwgfSwKLQl7IENGSV9NRlJfU1QsIDB4MDBiYiwgLyogTTI4VzMyMENCICovIGZpeHVwX3N0X20yOHczMjBjYiwgTlVMTCB9LAotCXsgQ0ZJX01GUl9JTlRFTCwgQ0ZJX0lEX0FOWSwgZml4dXBfdW5sb2NrX3Bvd2VydXBfbG9jaywgTlVMTCwgfSwKLQl7IDAsIDAsIE5VTEwsIE5VTEwgfQorCXsgQ0ZJX01GUl9TVCwgMHgwMGJhLCAvKiBNMjhXMzIwQ1QgKi8gZml4dXBfc3RfbTI4dzMyMGN0IH0sCisJeyBDRklfTUZSX1NULCAweDAwYmIsIC8qIE0yOFczMjBDQiAqLyBmaXh1cF9zdF9tMjh3MzIwY2IgfSwKKwl7IENGSV9NRlJfSU5URUwsIENGSV9JRF9BTlksIGZpeHVwX3VubG9ja19wb3dlcnVwX2xvY2sgfSwKKwl7IDAsIDAsIE5VTEwgfQogfTsKIAogc3RhdGljIHN0cnVjdCBjZmlfZml4dXAgamVkZWNfZml4dXBfdGFibGVbXSA9IHsKLQl7IENGSV9NRlJfSU5URUwsIEk4MjgwMkFCLCAgIGZpeHVwX3VzZV9md2hfbG9jaywgTlVMTCwgfSwKLQl7IENGSV9NRlJfSU5URUwsIEk4MjgwMkFDLCAgIGZpeHVwX3VzZV9md2hfbG9jaywgTlVMTCwgfSwKLQl7IENGSV9NRlJfU1QsICAgIE01MExQVzA4MCwgIGZpeHVwX3VzZV9md2hfbG9jaywgTlVMTCwgfSwKLQl7IENGSV9NRlJfU1QsICAgIE01MEZMVzA4MEEsIGZpeHVwX3VzZV9md2hfbG9jaywgTlVMTCwgfSwKLQl7IENGSV9NRlJfU1QsICAgIE01MEZMVzA4MEIsIGZpeHVwX3VzZV9md2hfbG9jaywgTlVMTCwgfSwKLQl7IDAsIDAsIE5VTEwsIE5VTEwgfQorCXsgQ0ZJX01GUl9JTlRFTCwgSTgyODAyQUIsICAgZml4dXBfdXNlX2Z3aF9sb2NrIH0sCisJeyBDRklfTUZSX0lOVEVMLCBJODI4MDJBQywgICBmaXh1cF91c2VfZndoX2xvY2sgfSwKKwl7IENGSV9NRlJfU1QsICAgIE01MExQVzA4MCwgIGZpeHVwX3VzZV9md2hfbG9jayB9LAorCXsgQ0ZJX01GUl9TVCwgICAgTTUwRkxXMDgwQSwgZml4dXBfdXNlX2Z3aF9sb2NrIH0sCisJeyBDRklfTUZSX1NULCAgICBNNTBGTFcwODBCLCBmaXh1cF91c2VfZndoX2xvY2sgfSwKKwl7IDAsIDAsIE5VTEwgfQogfTsKIHN0YXRpYyBzdHJ1Y3QgY2ZpX2ZpeHVwIGZpeHVwX3RhYmxlW10gPSB7CiAJLyogVGhlIENGSSB2ZW5kb3IgaWRzIGFuZCB0aGUgSkVERUMgdmVuZG9yIElEcyBhcHBlYXIKQEAgLTMyNyw4ICszMjcsOCBAQAogCSAqIHdlbGwuICBUaGlzIHRhYmxlIGlzIHRvIHBpY2sgYWxsIGNhc2VzIHdoZXJlCiAJICogd2Uga25vdyB0aGF0IGlzIHRoZSBjYXNlLgogCSAqLwotCXsgQ0ZJX01GUl9BTlksIENGSV9JRF9BTlksIGZpeHVwX3VzZV9wb2ludCwgTlVMTCB9LAotCXsgMCwgMCwgTlVMTCwgTlVMTCB9CisJeyBDRklfTUZSX0FOWSwgQ0ZJX0lEX0FOWSwgZml4dXBfdXNlX3BvaW50IH0sCisJeyAwLCAwLCBOVUxMIH0KIH07CiAKIHN0YXRpYyB2b2lkIGNmaV9maXh1cF9tYWpvcl9taW5vcihzdHJ1Y3QgY2ZpX3ByaXZhdGUgKmNmaSwKQEAgLTQ1NSw2ICs0NTUsNyBAQAogCW10ZC0+ZmxhZ3MgICA9IE1URF9DQVBfTk9SRkxBU0g7CiAJbXRkLT5uYW1lICAgID0gbWFwLT5uYW1lOwogCW10ZC0+d3JpdGVzaXplID0gMTsKKwltdGQtPndyaXRlYnVmc2l6ZSA9IDEgPDwgY2ZpLT5jZmlxLT5NYXhCdWZXcml0ZVNpemU7CiAKIAltdGQtPnJlYm9vdF9ub3RpZmllci5ub3RpZmllcl9jYWxsID0gY2ZpX2ludGVsZXh0X3JlYm9vdDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvY2hpcHMvY2ZpX2NtZHNldF8wMDAyLmMgYi9kcml2ZXJzL210ZC9jaGlwcy9jZmlfY21kc2V0XzAwMDIuYwppbmRleCAzYjhlMzJkLi5mMDcyZmNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9jaGlwcy9jZmlfY21kc2V0XzAwMDIuYworKysgYi9kcml2ZXJzL210ZC9jaGlwcy9jZmlfY21kc2V0XzAwMDIuYwpAQCAtMTM0LDcgKzEzNCw3IEBACiAKICNpZmRlZiBBTURfQk9PVExPQ19CVUcKIC8qIFdoZWVlLiBCcmluZyBtZSB0aGUgaGVhZCBvZiBzb21lb25lIGF0IEFNRC4gKi8KLXN0YXRpYyB2b2lkIGZpeHVwX2FtZF9ib290YmxvY2soc3RydWN0IG10ZF9pbmZvICptdGQsIHZvaWQqIHBhcmFtKQorc3RhdGljIHZvaWQgZml4dXBfYW1kX2Jvb3RibG9jayhzdHJ1Y3QgbXRkX2luZm8gKm10ZCkKIHsKIAlzdHJ1Y3QgbWFwX2luZm8gKm1hcCA9IG10ZC0+cHJpdjsKIAlzdHJ1Y3QgY2ZpX3ByaXZhdGUgKmNmaSA9IG1hcC0+ZmxkcnZfcHJpdjsKQEAgLTE4Niw3ICsxODYsNyBAQAogfQogI2VuZGlmCiAKLXN0YXRpYyB2b2lkIGZpeHVwX3VzZV93cml0ZV9idWZmZXJzKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCB2b2lkICpwYXJhbSkKK3N0YXRpYyB2b2lkIGZpeHVwX3VzZV93cml0ZV9idWZmZXJzKHN0cnVjdCBtdGRfaW5mbyAqbXRkKQogewogCXN0cnVjdCBtYXBfaW5mbyAqbWFwID0gbXRkLT5wcml2OwogCXN0cnVjdCBjZmlfcHJpdmF0ZSAqY2ZpID0gbWFwLT5mbGRydl9wcml2OwpAQCAtMTk3LDcgKzE5Nyw3IEBACiB9CiAKIC8qIEF0bWVsIGNoaXBzIGRvbid0IHVzZSB0aGUgc2FtZSBQUkkgZm9ybWF0IGFzIEFNRCBjaGlwcyAqLwotc3RhdGljIHZvaWQgZml4dXBfY29udmVydF9hdG1lbF9wcmkoc3RydWN0IG10ZF9pbmZvICptdGQsIHZvaWQgKnBhcmFtKQorc3RhdGljIHZvaWQgZml4dXBfY29udmVydF9hdG1lbF9wcmkoc3RydWN0IG10ZF9pbmZvICptdGQpCiB7CiAJc3RydWN0IG1hcF9pbmZvICptYXAgPSBtdGQtPnByaXY7CiAJc3RydWN0IGNmaV9wcml2YXRlICpjZmkgPSBtYXAtPmZsZHJ2X3ByaXY7CkBAIC0yMjgsMTQgKzIyOCwxNCBAQAogCWNmaS0+Y2ZpcS0+QnVmV3JpdGVUaW1lb3V0TWF4ID0gMDsKIH0KIAotc3RhdGljIHZvaWQgZml4dXBfdXNlX3NlY3NpKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCB2b2lkICpwYXJhbSkKK3N0YXRpYyB2b2lkIGZpeHVwX3VzZV9zZWNzaShzdHJ1Y3QgbXRkX2luZm8gKm10ZCkKIHsKIAkvKiBTZXR1cCBmb3IgY2hpcHMgd2l0aCBhIHNlY3NpIGFyZWEgKi8KIAltdGQtPnJlYWRfdXNlcl9wcm90X3JlZyA9IGNmaV9hbWRzdGRfc2Vjc2lfcmVhZDsKIAltdGQtPnJlYWRfZmFjdF9wcm90X3JlZyA9IGNmaV9hbWRzdGRfc2Vjc2lfcmVhZDsKIH0KIAotc3RhdGljIHZvaWQgZml4dXBfdXNlX2VyYXNlX2NoaXAoc3RydWN0IG10ZF9pbmZvICptdGQsIHZvaWQgKnBhcmFtKQorc3RhdGljIHZvaWQgZml4dXBfdXNlX2VyYXNlX2NoaXAoc3RydWN0IG10ZF9pbmZvICptdGQpCiB7CiAJc3RydWN0IG1hcF9pbmZvICptYXAgPSBtdGQtPnByaXY7CiAJc3RydWN0IGNmaV9wcml2YXRlICpjZmkgPSBtYXAtPmZsZHJ2X3ByaXY7CkBAIC0yNTAsNyArMjUwLDcgQEAKICAqIFNvbWUgQXRtZWwgY2hpcHMgKGUuZy4gdGhlIEFUNDlCVjY0MTYpIHBvd2VyLXVwIHdpdGggYWxsIHNlY3RvcnMKICAqIGxvY2tlZCBieSBkZWZhdWx0LgogICovCi1zdGF0aWMgdm9pZCBmaXh1cF91c2VfYXRtZWxfbG9jayhzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgdm9pZCAqcGFyYW0pCitzdGF0aWMgdm9pZCBmaXh1cF91c2VfYXRtZWxfbG9jayhzdHJ1Y3QgbXRkX2luZm8gKm10ZCkKIHsKIAltdGQtPmxvY2sgPSBjZmlfYXRtZWxfbG9jazsKIAltdGQtPnVubG9jayA9IGNmaV9hdG1lbF91bmxvY2s7CkBAIC0yNzEsNyArMjcxLDcgQEAKIAljZmktPmNmaXEtPk51bUVyYXNlUmVnaW9ucyA9IDE7CiB9CiAKLXN0YXRpYyB2b2lkIGZpeHVwX3NzdDM5dmYoc3RydWN0IG10ZF9pbmZvICptdGQsIHZvaWQgKnBhcmFtKQorc3RhdGljIHZvaWQgZml4dXBfc3N0Mzl2ZihzdHJ1Y3QgbXRkX2luZm8gKm10ZCkKIHsKIAlzdHJ1Y3QgbWFwX2luZm8gKm1hcCA9IG10ZC0+cHJpdjsKIAlzdHJ1Y3QgY2ZpX3ByaXZhdGUgKmNmaSA9IG1hcC0+ZmxkcnZfcHJpdjsKQEAgLTI4Miw3ICsyODIsNyBAQAogCWNmaS0+YWRkcl91bmxvY2syID0gMHgyQUFBOwogfQogCi1zdGF0aWMgdm9pZCBmaXh1cF9zc3QzOXZmX3Jldl9iKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCB2b2lkICpwYXJhbSkKK3N0YXRpYyB2b2lkIGZpeHVwX3NzdDM5dmZfcmV2X2Ioc3RydWN0IG10ZF9pbmZvICptdGQpCiB7CiAJc3RydWN0IG1hcF9pbmZvICptYXAgPSBtdGQtPnByaXY7CiAJc3RydWN0IGNmaV9wcml2YXRlICpjZmkgPSBtYXAtPmZsZHJ2X3ByaXY7CkBAIC0yOTUsMTIgKzI5NSwxMiBAQAogCWNmaS0+c2VjdG9yX2VyYXNlX2NtZCA9IENNRCgweDUwKTsKIH0KIAotc3RhdGljIHZvaWQgZml4dXBfc3N0Mzh2ZjY0MHhfc2VjdG9yc2l6ZShzdHJ1Y3QgbXRkX2luZm8gKm10ZCwgdm9pZCAqcGFyYW0pCitzdGF0aWMgdm9pZCBmaXh1cF9zc3QzOHZmNjQweF9zZWN0b3JzaXplKHN0cnVjdCBtdGRfaW5mbyAqbXRkKQogewogCXN0cnVjdCBtYXBfaW5mbyAqbWFwID0gbXRkLT5wcml2OwogCXN0cnVjdCBjZmlfcHJpdmF0ZSAqY2ZpID0gbWFwLT5mbGRydl9wcml2OwogCi0JZml4dXBfc3N0Mzl2Zl9yZXZfYihtdGQsIHBhcmFtKTsKKwlmaXh1cF9zc3QzOXZmX3Jldl9iKG10ZCk7CiAKIAkvKgogCSAqIENGSSByZXBvcnRzIDEwMjQgc2VjdG9ycyAoMHgwM2ZmKzEpIG9mIDY0S0J5dGVzICgweDAxMDAqMjU2KSB3aGVyZQpAQCAtMzEwLDcgKzMxMCw3IEBACiAJcHJfd2FybmluZygiJXM6IEJhZCAzOFZGNjQweCBDRkkgZGF0YTsgYWRqdXN0aW5nIHNlY3RvciBzaXplIGZyb20gNjQgdG8gOEtpQlxuIiwgbXRkLT5uYW1lKTsKIH0KIAotc3RhdGljIHZvaWQgZml4dXBfczI5Z2wwNjRuX3NlY3RvcnMoc3RydWN0IG10ZF9pbmZvICptdGQsIHZvaWQgKnBhcmFtKQorc3RhdGljIHZvaWQgZml4dXBfczI5Z2wwNjRuX3NlY3RvcnMoc3RydWN0IG10ZF9pbmZvICptdGQpCiB7CiAJc3RydWN0IG1hcF9pbmZvICptYXAgPSBtdGQtPnByaXY7CiAJc3RydWN0IGNmaV9wcml2YXRlICpjZmkgPSBtYXAtPmZsZHJ2X3ByaXY7CkBAIC0zMjEsNyArMzIxLDcgQEAKIAl9CiB9CiAKLXN0YXRpYyB2b2lkIGZpeHVwX3MyOWdsMDMybl9zZWN0b3JzKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCB2b2lkICpwYXJhbSkKK3N0YXRpYyB2b2lkIGZpeHVwX3MyOWdsMDMybl9zZWN0b3JzKHN0cnVjdCBtdGRfaW5mbyAqbXRkKQogewogCXN0cnVjdCBtYXBfaW5mbyAqbWFwID0gbXRkLT5wcml2OwogCXN0cnVjdCBjZmlfcHJpdmF0ZSAqY2ZpID0gbWFwLT5mbGRydl9wcml2OwpAQCAtMzM0LDQ3ICszMzQsNDcgQEAKIAogLyogVXNlZCB0byBmaXggQ0ZJLVRhYmxlcyBvZiBjaGlwcyB3aXRob3V0IEV4dGVuZGVkIFF1ZXJ5IFRhYmxlcyAqLwogc3RhdGljIHN0cnVjdCBjZmlfZml4dXAgY2ZpX25vcHJpX2ZpeHVwX3RhYmxlW10gPSB7Ci0JeyBDRklfTUZSX1NTVCwgMHgyMzRBLCBmaXh1cF9zc3QzOXZmLCBOVUxMLCB9LCAvKiBTU1QzOVZGMTYwMiAqLwotCXsgQ0ZJX01GUl9TU1QsIDB4MjM0QiwgZml4dXBfc3N0Mzl2ZiwgTlVMTCwgfSwgLyogU1NUMzlWRjE2MDEgKi8KLQl7IENGSV9NRlJfU1NULCAweDIzNUEsIGZpeHVwX3NzdDM5dmYsIE5VTEwsIH0sIC8qIFNTVDM5VkYzMjAyICovCi0JeyBDRklfTUZSX1NTVCwgMHgyMzVCLCBmaXh1cF9zc3QzOXZmLCBOVUxMLCB9LCAvKiBTU1QzOVZGMzIwMSAqLwotCXsgQ0ZJX01GUl9TU1QsIDB4MjM1QywgZml4dXBfc3N0Mzl2Zl9yZXZfYiwgTlVMTCwgfSwgLyogU1NUMzlWRjMyMDJCICovCi0JeyBDRklfTUZSX1NTVCwgMHgyMzVELCBmaXh1cF9zc3QzOXZmX3Jldl9iLCBOVUxMLCB9LCAvKiBTU1QzOVZGMzIwMUIgKi8KLQl7IENGSV9NRlJfU1NULCAweDIzNkMsIGZpeHVwX3NzdDM5dmZfcmV2X2IsIE5VTEwsIH0sIC8qIFNTVDM5VkY2NDAyQiAqLwotCXsgQ0ZJX01GUl9TU1QsIDB4MjM2RCwgZml4dXBfc3N0Mzl2Zl9yZXZfYiwgTlVMTCwgfSwgLyogU1NUMzlWRjY0MDFCICovCi0JeyAwLCAwLCBOVUxMLCBOVUxMIH0KKwl7IENGSV9NRlJfU1NULCAweDIzNGEsIGZpeHVwX3NzdDM5dmYgfSwgLyogU1NUMzlWRjE2MDIgKi8KKwl7IENGSV9NRlJfU1NULCAweDIzNGIsIGZpeHVwX3NzdDM5dmYgfSwgLyogU1NUMzlWRjE2MDEgKi8KKwl7IENGSV9NRlJfU1NULCAweDIzNWEsIGZpeHVwX3NzdDM5dmYgfSwgLyogU1NUMzlWRjMyMDIgKi8KKwl7IENGSV9NRlJfU1NULCAweDIzNWIsIGZpeHVwX3NzdDM5dmYgfSwgLyogU1NUMzlWRjMyMDEgKi8KKwl7IENGSV9NRlJfU1NULCAweDIzNWMsIGZpeHVwX3NzdDM5dmZfcmV2X2IgfSwgLyogU1NUMzlWRjMyMDJCICovCisJeyBDRklfTUZSX1NTVCwgMHgyMzVkLCBmaXh1cF9zc3QzOXZmX3Jldl9iIH0sIC8qIFNTVDM5VkYzMjAxQiAqLworCXsgQ0ZJX01GUl9TU1QsIDB4MjM2YywgZml4dXBfc3N0Mzl2Zl9yZXZfYiB9LCAvKiBTU1QzOVZGNjQwMkIgKi8KKwl7IENGSV9NRlJfU1NULCAweDIzNmQsIGZpeHVwX3NzdDM5dmZfcmV2X2IgfSwgLyogU1NUMzlWRjY0MDFCICovCisJeyAwLCAwLCBOVUxMIH0KIH07CiAKIHN0YXRpYyBzdHJ1Y3QgY2ZpX2ZpeHVwIGNmaV9maXh1cF90YWJsZVtdID0gewotCXsgQ0ZJX01GUl9BVE1FTCwgQ0ZJX0lEX0FOWSwgZml4dXBfY29udmVydF9hdG1lbF9wcmksIE5VTEwgfSwKKwl7IENGSV9NRlJfQVRNRUwsIENGSV9JRF9BTlksIGZpeHVwX2NvbnZlcnRfYXRtZWxfcHJpIH0sCiAjaWZkZWYgQU1EX0JPT1RMT0NfQlVHCi0JeyBDRklfTUZSX0FNRCwgQ0ZJX0lEX0FOWSwgZml4dXBfYW1kX2Jvb3RibG9jaywgTlVMTCB9LAotCXsgQ0ZJX01GUl9NQUNST05JWCwgQ0ZJX0lEX0FOWSwgZml4dXBfYW1kX2Jvb3RibG9jaywgTlVMTCB9LAorCXsgQ0ZJX01GUl9BTUQsIENGSV9JRF9BTlksIGZpeHVwX2FtZF9ib290YmxvY2sgfSwKKwl7IENGSV9NRlJfTUFDUk9OSVgsIENGSV9JRF9BTlksIGZpeHVwX2FtZF9ib290YmxvY2sgfSwKICNlbmRpZgotCXsgQ0ZJX01GUl9BTUQsIDB4MDA1MCwgZml4dXBfdXNlX3NlY3NpLCBOVUxMLCB9LAotCXsgQ0ZJX01GUl9BTUQsIDB4MDA1MywgZml4dXBfdXNlX3NlY3NpLCBOVUxMLCB9LAotCXsgQ0ZJX01GUl9BTUQsIDB4MDA1NSwgZml4dXBfdXNlX3NlY3NpLCBOVUxMLCB9LAotCXsgQ0ZJX01GUl9BTUQsIDB4MDA1NiwgZml4dXBfdXNlX3NlY3NpLCBOVUxMLCB9LAotCXsgQ0ZJX01GUl9BTUQsIDB4MDA1QywgZml4dXBfdXNlX3NlY3NpLCBOVUxMLCB9LAotCXsgQ0ZJX01GUl9BTUQsIDB4MDA1RiwgZml4dXBfdXNlX3NlY3NpLCBOVUxMLCB9LAotCXsgQ0ZJX01GUl9BTUQsIDB4MGMwMSwgZml4dXBfczI5Z2wwNjRuX3NlY3RvcnMsIE5VTEwsIH0sCi0JeyBDRklfTUZSX0FNRCwgMHgxMzAxLCBmaXh1cF9zMjlnbDA2NG5fc2VjdG9ycywgTlVMTCwgfSwKLQl7IENGSV9NRlJfQU1ELCAweDFhMDAsIGZpeHVwX3MyOWdsMDMybl9zZWN0b3JzLCBOVUxMLCB9LAotCXsgQ0ZJX01GUl9BTUQsIDB4MWEwMSwgZml4dXBfczI5Z2wwMzJuX3NlY3RvcnMsIE5VTEwsIH0sCi0JeyBDRklfTUZSX1NTVCwgMHg1MzZBLCBmaXh1cF9zc3QzOHZmNjQweF9zZWN0b3JzaXplLCBOVUxMLCB9LCAvKiBTU1QzOFZGNjQwMiAqLwotCXsgQ0ZJX01GUl9TU1QsIDB4NTM2QiwgZml4dXBfc3N0Mzh2ZjY0MHhfc2VjdG9yc2l6ZSwgTlVMTCwgfSwgLyogU1NUMzhWRjY0MDEgKi8KLQl7IENGSV9NRlJfU1NULCAweDUzNkMsIGZpeHVwX3NzdDM4dmY2NDB4X3NlY3RvcnNpemUsIE5VTEwsIH0sIC8qIFNTVDM4VkY2NDA0ICovCi0JeyBDRklfTUZSX1NTVCwgMHg1MzZELCBmaXh1cF9zc3QzOHZmNjQweF9zZWN0b3JzaXplLCBOVUxMLCB9LCAvKiBTU1QzOFZGNjQwMyAqLworCXsgQ0ZJX01GUl9BTUQsIDB4MDA1MCwgZml4dXBfdXNlX3NlY3NpIH0sCisJeyBDRklfTUZSX0FNRCwgMHgwMDUzLCBmaXh1cF91c2Vfc2Vjc2kgfSwKKwl7IENGSV9NRlJfQU1ELCAweDAwNTUsIGZpeHVwX3VzZV9zZWNzaSB9LAorCXsgQ0ZJX01GUl9BTUQsIDB4MDA1NiwgZml4dXBfdXNlX3NlY3NpIH0sCisJeyBDRklfTUZSX0FNRCwgMHgwMDVDLCBmaXh1cF91c2Vfc2Vjc2kgfSwKKwl7IENGSV9NRlJfQU1ELCAweDAwNUYsIGZpeHVwX3VzZV9zZWNzaSB9LAorCXsgQ0ZJX01GUl9BTUQsIDB4MGMwMSwgZml4dXBfczI5Z2wwNjRuX3NlY3RvcnMgfSwKKwl7IENGSV9NRlJfQU1ELCAweDEzMDEsIGZpeHVwX3MyOWdsMDY0bl9zZWN0b3JzIH0sCisJeyBDRklfTUZSX0FNRCwgMHgxYTAwLCBmaXh1cF9zMjlnbDAzMm5fc2VjdG9ycyB9LAorCXsgQ0ZJX01GUl9BTUQsIDB4MWEwMSwgZml4dXBfczI5Z2wwMzJuX3NlY3RvcnMgfSwKKwl7IENGSV9NRlJfU1NULCAweDUzNmEsIGZpeHVwX3NzdDM4dmY2NDB4X3NlY3RvcnNpemUgfSwgLyogU1NUMzhWRjY0MDIgKi8KKwl7IENGSV9NRlJfU1NULCAweDUzNmIsIGZpeHVwX3NzdDM4dmY2NDB4X3NlY3RvcnNpemUgfSwgLyogU1NUMzhWRjY0MDEgKi8KKwl7IENGSV9NRlJfU1NULCAweDUzNmMsIGZpeHVwX3NzdDM4dmY2NDB4X3NlY3RvcnNpemUgfSwgLyogU1NUMzhWRjY0MDQgKi8KKwl7IENGSV9NRlJfU1NULCAweDUzNmQsIGZpeHVwX3NzdDM4dmY2NDB4X3NlY3RvcnNpemUgfSwgLyogU1NUMzhWRjY0MDMgKi8KICNpZiAhRk9SQ0VfV09SRF9XUklURQotCXsgQ0ZJX01GUl9BTlksIENGSV9JRF9BTlksIGZpeHVwX3VzZV93cml0ZV9idWZmZXJzLCBOVUxMLCB9LAorCXsgQ0ZJX01GUl9BTlksIENGSV9JRF9BTlksIGZpeHVwX3VzZV93cml0ZV9idWZmZXJzIH0sCiAjZW5kaWYKLQl7IDAsIDAsIE5VTEwsIE5VTEwgfQorCXsgMCwgMCwgTlVMTCB9CiB9Owogc3RhdGljIHN0cnVjdCBjZmlfZml4dXAgamVkZWNfZml4dXBfdGFibGVbXSA9IHsKLQl7IENGSV9NRlJfU1NULCBTU1Q0OUxGMDA0QiwgZml4dXBfdXNlX2Z3aF9sb2NrLCBOVUxMLCB9LAotCXsgQ0ZJX01GUl9TU1QsIFNTVDQ5TEYwNDBCLCBmaXh1cF91c2VfZndoX2xvY2ssIE5VTEwsIH0sCi0JeyBDRklfTUZSX1NTVCwgU1NUNDlMRjAwOEEsIGZpeHVwX3VzZV9md2hfbG9jaywgTlVMTCwgfSwKLQl7IDAsIDAsIE5VTEwsIE5VTEwgfQorCXsgQ0ZJX01GUl9TU1QsIFNTVDQ5TEYwMDRCLCBmaXh1cF91c2VfZndoX2xvY2sgfSwKKwl7IENGSV9NRlJfU1NULCBTU1Q0OUxGMDQwQiwgZml4dXBfdXNlX2Z3aF9sb2NrIH0sCisJeyBDRklfTUZSX1NTVCwgU1NUNDlMRjAwOEEsIGZpeHVwX3VzZV9md2hfbG9jayB9LAorCXsgMCwgMCwgTlVMTCB9CiB9OwogCiBzdGF0aWMgc3RydWN0IGNmaV9maXh1cCBmaXh1cF90YWJsZVtdID0gewpAQCAtMzgzLDE4ICszODMsMzAgQEAKIAkgKiB3ZWxsLiAgVGhpcyB0YWJsZSBpcyB0byBwaWNrIGFsbCBjYXNlcyB3aGVyZQogCSAqIHdlIGtub3cgdGhhdCBpcyB0aGUgY2FzZS4KIAkgKi8KLQl7IENGSV9NRlJfQU5ZLCBDRklfSURfQU5ZLCBmaXh1cF91c2VfZXJhc2VfY2hpcCwgTlVMTCB9LAotCXsgQ0ZJX01GUl9BVE1FTCwgQVQ0OUJWNjQxNiwgZml4dXBfdXNlX2F0bWVsX2xvY2ssIE5VTEwgfSwKLQl7IDAsIDAsIE5VTEwsIE5VTEwgfQorCXsgQ0ZJX01GUl9BTlksIENGSV9JRF9BTlksIGZpeHVwX3VzZV9lcmFzZV9jaGlwIH0sCisJeyBDRklfTUZSX0FUTUVMLCBBVDQ5QlY2NDE2LCBmaXh1cF91c2VfYXRtZWxfbG9jayB9LAorCXsgMCwgMCwgTlVMTCB9CiB9OwogCiAKIHN0YXRpYyB2b2lkIGNmaV9maXh1cF9tYWpvcl9taW5vcihzdHJ1Y3QgY2ZpX3ByaXZhdGUgKmNmaSwKIAkJCQkgIHN0cnVjdCBjZmlfcHJpX2FtZHN0ZCAqZXh0cCkKIHsKLQlpZiAoY2ZpLT5tZnIgPT0gQ0ZJX01GUl9TQU1TVU5HICYmIGNmaS0+aWQgPT0gMHgyNTdlICYmCi0JICAgIGV4dHAtPk1ham9yVmVyc2lvbiA9PSAnMCcpCi0JCWV4dHAtPk1ham9yVmVyc2lvbiA9ICcxJzsKKwlpZiAoY2ZpLT5tZnIgPT0gQ0ZJX01GUl9TQU1TVU5HKSB7CisJCWlmICgoZXh0cC0+TWFqb3JWZXJzaW9uID09ICcwJyAmJiBleHRwLT5NaW5vclZlcnNpb24gPT0gJzAnKSB8fAorCQkgICAgKGV4dHAtPk1ham9yVmVyc2lvbiA9PSAnMycgJiYgZXh0cC0+TWlub3JWZXJzaW9uID09ICczJykpIHsKKwkJCS8qCisJCQkgKiBTYW1zdW5nIEs4UDI4MTVVUUIgYW5kIEs4RDZ4MTZVeE0gY2hpcHMKKwkJCSAqIHJlcG9ydCBtYWpvcj0wIC8gbWlub3I9MC4KKwkJCSAqIEs4RDN4MTZVeEMgY2hpcHMgcmVwb3J0IG1ham9yPTMgLyBtaW5vcj0zLgorCQkJICovCisJCQlwcmludGsoS0VSTl9OT1RJQ0UgIiAgRml4aW5nIFNhbXN1bmcncyBBbWQvRnVqaXRzdSIKKwkJCSAgICAgICAiIEV4dGVuZGVkIFF1ZXJ5IHZlcnNpb24gdG8gMS4lY1xuIiwKKwkJCSAgICAgICBleHRwLT5NaW5vclZlcnNpb24pOworCQkJZXh0cC0+TWFqb3JWZXJzaW9uID0gJzEnOworCQl9CisJfQorCiAJLyoKIAkgKiBTU1QgMzhWRjY0MHggY2hpcHMgcmVwb3J0IG1ham9yPTB4RkYgLyBtaW5vcj0weEZGLgogCSAqLwpAQCAtNDI4LDYgKzQ0MCwxMCBAQAogCW10ZC0+ZmxhZ3MgICA9IE1URF9DQVBfTk9SRkxBU0g7CiAJbXRkLT5uYW1lICAgID0gbWFwLT5uYW1lOwogCW10ZC0+d3JpdGVzaXplID0gMTsKKwltdGQtPndyaXRlYnVmc2l6ZSA9IDEgPDwgY2ZpLT5jZmlxLT5NYXhCdWZXcml0ZVNpemU7CisKKwlERUJVRyhNVERfREVCVUdfTEVWRUwzLCAiTVREICVzKCk6IHdyaXRlIGJ1ZmZlciBzaXplICVkXG4iLAorCQlfX2Z1bmNfXywgbXRkLT53cml0ZWJ1ZnNpemUpOwogCiAJbXRkLT5yZWJvb3Rfbm90aWZpZXIubm90aWZpZXJfY2FsbCA9IGNmaV9hbWRzdGRfcmVib290OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9jaGlwcy9jZmlfY21kc2V0XzAwMjAuYyBiL2RyaXZlcnMvbXRkL2NoaXBzL2NmaV9jbWRzZXRfMDAyMC5jCmluZGV4IDMxNGFmMWYuLmMwNGI3NjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL2NoaXBzL2NmaV9jbWRzZXRfMDAyMC5jCisrKyBiL2RyaXZlcnMvbXRkL2NoaXBzL2NmaV9jbWRzZXRfMDAyMC5jCkBAIC0yMzgsNiArMjM4LDcgQEAKIAltdGQtPnJlc3VtZSA9IGNmaV9zdGFhX3Jlc3VtZTsKIAltdGQtPmZsYWdzID0gTVREX0NBUF9OT1JGTEFTSCAmIH5NVERfQklUX1dSSVRFQUJMRTsKIAltdGQtPndyaXRlc2l6ZSA9IDg7IC8qIEZJWE1FOiBTaG91bGQgYmUgMCBmb3IgU1RNaWNybyBmbGFzaGVzIHcvb3V0IEVDQyAqLworCW10ZC0+d3JpdGVidWZzaXplID0gMSA8PCBjZmktPmNmaXEtPk1heEJ1ZldyaXRlU2l6ZTsKIAltYXAtPmZsZHJ2ID0gJmNmaV9zdGFhX2NoaXBkcnY7CiAJX19tb2R1bGVfZ2V0KFRISVNfTU9EVUxFKTsKIAltdGQtPm5hbWUgPSBtYXAtPm5hbWU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9jaGlwcy9jZmlfdXRpbC5jIGIvZHJpdmVycy9tdGQvY2hpcHMvY2ZpX3V0aWwuYwppbmRleCAzNjA1MjVjLi42YWUzZDExIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9jaGlwcy9jZmlfdXRpbC5jCisrKyBiL2RyaXZlcnMvbXRkL2NoaXBzL2NmaV91dGlsLmMKQEAgLTE1Niw3ICsxNTYsNyBAQAogCWZvciAoZj1maXh1cHM7IGYtPmZpeHVwOyBmKyspIHsKIAkJaWYgKCgoZi0+bWZyID09IENGSV9NRlJfQU5ZKSB8fCAoZi0+bWZyID09IGNmaS0+bWZyKSkgJiYKIAkJICAgICgoZi0+aWQgID09IENGSV9JRF9BTlkpICB8fCAoZi0+aWQgID09IGNmaS0+aWQpKSkgewotCQkJZi0+Zml4dXAobXRkLCBmLT5wYXJhbSk7CisJCQlmLT5maXh1cChtdGQpOwogCQl9CiAJfQogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvY2hpcHMvZndoX2xvY2suaCBiL2RyaXZlcnMvbXRkL2NoaXBzL2Z3aF9sb2NrLmgKaW5kZXggZDE4MDY0OS4uNWUzY2M4MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvY2hpcHMvZndoX2xvY2suaAorKysgYi9kcml2ZXJzL210ZC9jaGlwcy9md2hfbG9jay5oCkBAIC05OCw3ICs5OCw3IEBACiAJcmV0dXJuIHJldDsKIH0KIAotc3RhdGljIHZvaWQgZml4dXBfdXNlX2Z3aF9sb2NrKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCB2b2lkICpwYXJhbSkKK3N0YXRpYyB2b2lkIGZpeHVwX3VzZV9md2hfbG9jayhzdHJ1Y3QgbXRkX2luZm8gKm10ZCkKIHsKIAlwcmludGsoS0VSTl9OT1RJQ0UgInVzaW5nIGZ3aCBsb2NrL3VubG9jayBtZXRob2RcbiIpOwogCS8qIFNldHVwIGZvciB0aGUgY2hpcHMgd2l0aCB0aGUgZndoIGxvY2sgbWV0aG9kICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9kZXZpY2VzL20yNXA4MC5jIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9tMjVwODAuYwppbmRleCBiZjVhMDAyLi5lNGViYTZjIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9kZXZpY2VzL20yNXA4MC5jCisrKyBiL2RyaXZlcnMvbXRkL2RldmljZXMvbTI1cDgwLmMKQEAgLTUxLDYgKzUxLDEwIEBACiAjZGVmaW5lCU9QQ09ERV9XUkRJCQkweDA0CS8qIFdyaXRlIGRpc2FibGUgKi8KICNkZWZpbmUJT1BDT0RFX0FBSV9XUAkJMHhhZAkvKiBBdXRvIGFkZHJlc3MgaW5jcmVtZW50IHdvcmQgcHJvZ3JhbSAqLwogCisvKiBVc2VkIGZvciBNYWNyb25peCBmbGFzaGVzIG9ubHkuICovCisjZGVmaW5lCU9QQ09ERV9FTjRCCQkweGI3CS8qIEVudGVyIDQtYnl0ZSBtb2RlICovCisjZGVmaW5lCU9QQ09ERV9FWDRCCQkweGU5CS8qIEV4aXQgNC1ieXRlIG1vZGUgKi8KKwogLyogU3RhdHVzIFJlZ2lzdGVyIGJpdHMuICovCiAjZGVmaW5lCVNSX1dJUAkJCTEJLyogV3JpdGUgaW4gcHJvZ3Jlc3MgKi8KICNkZWZpbmUJU1JfV0VMCQkJMgkvKiBXcml0ZSBlbmFibGUgbGF0Y2ggKi8KQEAgLTYyLDcgKzY2LDcgQEAKIAogLyogRGVmaW5lIG1heCB0aW1lcyB0byBjaGVjayBzdGF0dXMgcmVnaXN0ZXIgYmVmb3JlIHdlIGdpdmUgdXAuICovCiAjZGVmaW5lCU1BWF9SRUFEWV9XQUlUX0pJRkZJRVMJKDQwICogSFopCS8qIE0yNVAxNiBzcGVjcyA0MHMgbWF4IGNoaXAgZXJhc2UgKi8KLSNkZWZpbmUJTUFYX0NNRF9TSVpFCQk0CisjZGVmaW5lCU1BWF9DTURfU0laRQkJNQogCiAjaWZkZWYgQ09ORklHX00yNVBYWF9VU0VfRkFTVF9SRUFECiAjZGVmaW5lIE9QQ09ERV9SRUFEIAlPUENPREVfRkFTVF9SRUFECkBAIC0xNTIsNiArMTU2LDE2IEBACiB9CiAKIC8qCisgKiBFbmFibGUvZGlzYWJsZSA0LWJ5dGUgYWRkcmVzc2luZyBtb2RlLgorICovCitzdGF0aWMgaW5saW5lIGludCBzZXRfNGJ5dGUoc3RydWN0IG0yNXAgKmZsYXNoLCBpbnQgZW5hYmxlKQoreworCXU4CWNvZGUgPSBlbmFibGUgPyBPUENPREVfRU40QiA6IE9QQ09ERV9FWDRCOworCisJcmV0dXJuIHNwaV93cml0ZV90aGVuX3JlYWQoZmxhc2gtPnNwaSwgJmNvZGUsIDEsIE5VTEwsIDApOworfQorCisvKgogICogU2VydmljZSByb3V0aW5lIHRvIHJlYWQgc3RhdHVzIHJlZ2lzdGVyIHVudGlsIHJlYWR5LCBvciB0aW1lb3V0IG9jY3Vycy4KICAqIFJldHVybnMgbm9uLXplcm8gaWYgZXJyb3IuCiAgKi8KQEAgLTIwNyw2ICsyMjEsNyBAQAogCWNtZFsxXSA9IGFkZHIgPj4gKGZsYXNoLT5hZGRyX3dpZHRoICogOCAtICA4KTsKIAljbWRbMl0gPSBhZGRyID4+IChmbGFzaC0+YWRkcl93aWR0aCAqIDggLSAxNik7CiAJY21kWzNdID0gYWRkciA+PiAoZmxhc2gtPmFkZHJfd2lkdGggKiA4IC0gMjQpOworCWNtZFs0XSA9IGFkZHIgPj4gKGZsYXNoLT5hZGRyX3dpZHRoICogOCAtIDMyKTsKIH0KIAogc3RhdGljIGludCBtMjVwX2NtZHN6KHN0cnVjdCBtMjVwICpmbGFzaCkKQEAgLTQ4Miw2ICs0OTcsMTAgQEAKIAlzaXplX3QgYWN0dWFsOwogCWludCBjbWRfc3osIHJldDsKIAorCURFQlVHKE1URF9ERUJVR19MRVZFTDIsICIlczogJXMgJXMgMHglMDh4LCBsZW4gJXpkXG4iLAorCQkJZGV2X25hbWUoJmZsYXNoLT5zcGktPmRldiksIF9fZnVuY19fLCAidG8iLAorCQkJKHUzMil0bywgbGVuKTsKKwogCSpyZXRsZW4gPSAwOwogCiAJLyogc2FuaXR5IGNoZWNrcyAqLwpAQCAtNjA3LDcgKzYyNiw2IEBACiAJCS5zZWN0b3Jfc2l6ZSA9IChfc2VjdG9yX3NpemUpLAkJCQlcCiAJCS5uX3NlY3RvcnMgPSAoX25fc2VjdG9ycyksCQkJCVwKIAkJLnBhZ2Vfc2l6ZSA9IDI1NiwJCQkJCVwKLQkJLmFkZHJfd2lkdGggPSAzLAkJCQkJXAogCQkuZmxhZ3MgPSAoX2ZsYWdzKSwJCQkJCVwKIAl9KQogCkBAIC02MzUsNyArNjUzLDcgQEAKIAl7ICJhdDI2ZjAwNCIsICAgSU5GTygweDFmMDQwMCwgMCwgNjQgKiAxMDI0LCAgOCwgU0VDVF80SykgfSwKIAl7ICJhdDI2ZGYwODFhIiwgSU5GTygweDFmNDUwMSwgMCwgNjQgKiAxMDI0LCAxNiwgU0VDVF80SykgfSwKIAl7ICJhdDI2ZGYxNjFhIiwgSU5GTygweDFmNDYwMSwgMCwgNjQgKiAxMDI0LCAzMiwgU0VDVF80SykgfSwKLQl7ICJhdDI2ZGYzMjEiLCAgSU5GTygweDFmNDcwMSwgMCwgNjQgKiAxMDI0LCA2NCwgU0VDVF80SykgfSwKKwl7ICJhdDI2ZGYzMjEiLCAgSU5GTygweDFmNDcwMCwgMCwgNjQgKiAxMDI0LCA2NCwgU0VDVF80SykgfSwKIAogCS8qIEVPTiAtLSBlbjI1cHh4ICovCiAJeyAiZW4yNXAzMiIsIElORk8oMHgxYzIwMTYsIDAsIDY0ICogMTAyNCwgIDY0LCAwKSB9LApAQCAtNjUzLDYgKzY3MSw4IEBACiAJeyAibXgyNWw2NDA1ZCIsICBJTkZPKDB4YzIyMDE3LCAwLCA2NCAqIDEwMjQsIDEyOCwgMCkgfSwKIAl7ICJteDI1bDEyODA1ZCIsIElORk8oMHhjMjIwMTgsIDAsIDY0ICogMTAyNCwgMjU2LCAwKSB9LAogCXsgIm14MjVsMTI4NTVlIiwgSU5GTygweGMyMjYxOCwgMCwgNjQgKiAxMDI0LCAyNTYsIDApIH0sCisJeyAibXgyNWwyNTYzNWUiLCBJTkZPKDB4YzIyMDE5LCAwLCA2NCAqIDEwMjQsIDUxMiwgMCkgfSwKKwl7ICJteDI1bDI1NjU1ZSIsIElORk8oMHhjMjI2MTksIDAsIDY0ICogMTAyNCwgNTEyLCAwKSB9LAogCiAJLyogU3BhbnNpb24gLS0gc2luZ2xlIChsYXJnZSkgc2VjdG9yIHNpemUgb25seSwgYXQgbGVhc3QKIAkgKiBmb3IgdGhlIGNoaXBzIGxpc3RlZCBoZXJlICh3aXRob3V0IGJvb3Qgc2VjdG9ycykuCkBAIC03NjQsNiArNzg0LDcgQEAKIAkJCXJldHVybiAmbTI1cF9pZHNbdG1wXTsKIAkJfQogCX0KKwlkZXZfZXJyKCZzcGktPmRldiwgInVucmVjb2duaXplZCBKRURFQyBpZCAlMDZ4XG4iLCBqZWRlYyk7CiAJcmV0dXJuIEVSUl9QVFIoLUVOT0RFVik7CiB9CiAKQEAgLTg4Myw3ICs5MDQsMTcgQEAKIAogCWZsYXNoLT5tdGQuZGV2LnBhcmVudCA9ICZzcGktPmRldjsKIAlmbGFzaC0+cGFnZV9zaXplID0gaW5mby0+cGFnZV9zaXplOwotCWZsYXNoLT5hZGRyX3dpZHRoID0gaW5mby0+YWRkcl93aWR0aDsKKworCWlmIChpbmZvLT5hZGRyX3dpZHRoKQorCQlmbGFzaC0+YWRkcl93aWR0aCA9IGluZm8tPmFkZHJfd2lkdGg7CisJZWxzZSB7CisJCS8qIGVuYWJsZSA0LWJ5dGUgYWRkcmVzc2luZyBpZiB0aGUgZGV2aWNlIGV4Y2VlZHMgMTZNaUIgKi8KKwkJaWYgKGZsYXNoLT5tdGQuc2l6ZSA+IDB4MTAwMDAwMCkgeworCQkJZmxhc2gtPmFkZHJfd2lkdGggPSA0OworCQkJc2V0XzRieXRlKGZsYXNoLCAxKTsKKwkJfSBlbHNlCisJCQlmbGFzaC0+YWRkcl93aWR0aCA9IDM7CisJfQogCiAJZGV2X2luZm8oJnNwaS0+ZGV2LCAiJXMgKCVsbGQgS2J5dGVzKVxuIiwgaWQtPm5hbWUsCiAJCQkobG9uZyBsb25nKWZsYXNoLT5tdGQuc2l6ZSA+PiAxMCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9kZXZpY2VzL3NzdDI1bC5jIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9zc3QyNWwuYwppbmRleCA2ODQyNDdhLi5jMTYzZTYxIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9kZXZpY2VzL3NzdDI1bC5jCisrKyBiL2RyaXZlcnMvbXRkL2RldmljZXMvc3N0MjVsLmMKQEAgLTMzNSw3ICszMzUsNyBAQAogCXJldHVybiByZXQ7CiB9CiAKLXN0YXRpYyBzdHJ1Y3QgZmxhc2hfaW5mbyAqX19pbml0IHNzdDI1bF9tYXRjaF9kZXZpY2Uoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKK3N0YXRpYyBzdHJ1Y3QgZmxhc2hfaW5mbyAqX19kZXZpbml0IHNzdDI1bF9tYXRjaF9kZXZpY2Uoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKIHsKIAlzdHJ1Y3QgZmxhc2hfaW5mbyAqZmxhc2hfaW5mbyA9IE5VTEw7CiAJc3RydWN0IHNwaV9tZXNzYWdlIG07CkBAIC0zNzUsNyArMzc1LDcgQEAKIAlyZXR1cm4gZmxhc2hfaW5mbzsKIH0KIAotc3RhdGljIGludCBfX2luaXQgc3N0MjVsX3Byb2JlKHN0cnVjdCBzcGlfZGV2aWNlICpzcGkpCitzdGF0aWMgaW50IF9fZGV2aW5pdCBzc3QyNWxfcHJvYmUoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKIHsKIAlzdHJ1Y3QgZmxhc2hfaW5mbyAqZmxhc2hfaW5mbzsKIAlzdHJ1Y3Qgc3N0MjVsX2ZsYXNoICpmbGFzaDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL21hcHMvYW1kNzZ4cm9tLmMgYi9kcml2ZXJzL210ZC9tYXBzL2FtZDc2eHJvbS5jCmluZGV4IDE5ZmU5MmQuLjc3ZDY0Y2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL21hcHMvYW1kNzZ4cm9tLmMKKysrIGIvZHJpdmVycy9tdGQvbWFwcy9hbWQ3Nnhyb20uYwpAQCAtMTQ5LDExICsxNDksOCBAQAogCWlmIChyZXF1ZXN0X3Jlc291cmNlKCZpb21lbV9yZXNvdXJjZSwgJndpbmRvdy0+cnNyYykpIHsKIAkJd2luZG93LT5yc3JjLnBhcmVudCA9IE5VTEw7CiAJCXByaW50ayhLRVJOX0VSUiBNT0RfTkFNRQotCQkJIiAlcygpOiBVbmFibGUgdG8gcmVnaXN0ZXIgcmVzb3VyY2UiCi0JCQkiIDB4JS4xNmxseC0weCUuMTZsbHggLSBrZXJuZWwgYnVnP1xuIiwKLQkJCV9fZnVuY19fLAotCQkJKHVuc2lnbmVkIGxvbmcgbG9uZyl3aW5kb3ctPnJzcmMuc3RhcnQsCi0JCQkodW5zaWduZWQgbG9uZyBsb25nKXdpbmRvdy0+cnNyYy5lbmQpOworCQkgICAgICAgIiAlcygpOiBVbmFibGUgdG8gcmVnaXN0ZXIgcmVzb3VyY2UgJXBSIC0ga2VybmVsIGJ1Zz9cbiIsCisJCSAgICAgICBfX2Z1bmNfXywgJndpbmRvdy0+cnNyYyk7CiAJfQogCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL21hcHMvYmNtOTYzeHgtZmxhc2guYyBiL2RyaXZlcnMvbXRkL21hcHMvYmNtOTYzeHgtZmxhc2guYwppbmRleCBkMTc1YzEyLi4xZjMwNDk1IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9tYXBzL2JjbTk2M3h4LWZsYXNoLmMKKysrIGIvZHJpdmVycy9tdGQvbWFwcy9iY205NjN4eC1mbGFzaC5jCkBAIC0xOTYsMTAgKzE5NiwxNSBAQAogCWJjbTk2M3h4X210ZF9pbmZvID0gZG9fbWFwX3Byb2JlKCJjZmlfcHJvYmUiLCAmYmNtOTYzeHhfbWFwKTsKIAlpZiAoIWJjbTk2M3h4X210ZF9pbmZvKSB7CiAJCWRldl9lcnIoJnBkZXYtPmRldiwgImZhaWxlZCB0byBwcm9iZSB1c2luZyBDRklcbiIpOworCQliY205NjN4eF9tdGRfaW5mbyA9IGRvX21hcF9wcm9iZSgiamVkZWNfcHJvYmUiLCAmYmNtOTYzeHhfbWFwKTsKKwkJaWYgKGJjbTk2M3h4X210ZF9pbmZvKQorCQkJZ290byBwcm9iZV9vazsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIHByb2JlIHVzaW5nIEpFREVDXG4iKTsKIAkJZXJyID0gLUVJTzsKIAkJZ290byBlcnJfcHJvYmU7CiAJfQogCitwcm9iZV9vazoKIAliY205NjN4eF9tdGRfaW5mby0+b3duZXIgPSBUSElTX01PRFVMRTsKIAogCS8qIFRoaXMgaXMgbXV0dWFsbHkgZXhjbHVzaXZlICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9tYXBzL2NrODA0eHJvbS5jIGIvZHJpdmVycy9tdGQvbWFwcy9jazgwNHhyb20uYwppbmRleCBkZGI0NjJiLi41ZmRiN2IyIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9tYXBzL2NrODA0eHJvbS5jCisrKyBiL2RyaXZlcnMvbXRkL21hcHMvY2s4MDR4cm9tLmMKQEAgLTE3OCwxMSArMTc4LDggQEAKIAlpZiAocmVxdWVzdF9yZXNvdXJjZSgmaW9tZW1fcmVzb3VyY2UsICZ3aW5kb3ctPnJzcmMpKSB7CiAJCXdpbmRvdy0+cnNyYy5wYXJlbnQgPSBOVUxMOwogCQlwcmludGsoS0VSTl9FUlIgTU9EX05BTUUKLQkJCSIgJXMoKTogVW5hYmxlIHRvIHJlZ2lzdGVyIHJlc291cmNlIgotCQkJIiAweCUuMDE2bGx4LTB4JS4wMTZsbHggLSBrZXJuZWwgYnVnP1xuIiwKLQkJCV9fZnVuY19fLAotCQkJKHVuc2lnbmVkIGxvbmcgbG9uZyl3aW5kb3ctPnJzcmMuc3RhcnQsCi0JCQkodW5zaWduZWQgbG9uZyBsb25nKXdpbmRvdy0+cnNyYy5lbmQpOworCQkgICAgICAgIiAlcygpOiBVbmFibGUgdG8gcmVnaXN0ZXIgcmVzb3VyY2UgJXBSIC0ga2VybmVsIGJ1Zz9cbiIsCisJCQlfX2Z1bmNfXywgJndpbmRvdy0+cnNyYyk7CiAJfQogCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL21hcHMvZXNiMnJvbS5jIGIvZHJpdmVycy9tdGQvbWFwcy9lc2Iycm9tLmMKaW5kZXggZDEyYzkzZC4uNGZlYjc1MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbWFwcy9lc2Iycm9tLmMKKysrIGIvZHJpdmVycy9tdGQvbWFwcy9lc2Iycm9tLmMKQEAgLTI0MiwxMiArMjQyLDkgQEAKIAl3aW5kb3ctPnJzcmMuZmxhZ3MgPSBJT1JFU09VUkNFX01FTSB8IElPUkVTT1VSQ0VfQlVTWTsKIAlpZiAocmVxdWVzdF9yZXNvdXJjZSgmaW9tZW1fcmVzb3VyY2UsICZ3aW5kb3ctPnJzcmMpKSB7CiAJCXdpbmRvdy0+cnNyYy5wYXJlbnQgPSBOVUxMOwotCQlwcmludGsoS0VSTl9ERUJVRyBNT0RfTkFNRQotCQkJIjogJXMoKTogVW5hYmxlIHRvIHJlZ2lzdGVyIHJlc291cmNlIgotCQkJIiAweCUuMDhsbHgtMHglLjA4bGx4IC0ga2VybmVsIGJ1Zz9cbiIsCi0JCQlfX2Z1bmNfXywKLQkJCSh1bnNpZ25lZCBsb25nIGxvbmcpd2luZG93LT5yc3JjLnN0YXJ0LAotCQkJKHVuc2lnbmVkIGxvbmcgbG9uZyl3aW5kb3ctPnJzcmMuZW5kKTsKKwkJcHJpbnRrKEtFUk5fREVCVUcgTU9EX05BTUUgIjogIgorCQkgICAgICAgIiVzKCk6IFVuYWJsZSB0byByZWdpc3RlciByZXNvdXJjZSAlcFIgLSBrZXJuZWwgYnVnP1xuIiwKKwkJCV9fZnVuY19fLCAmd2luZG93LT5yc3JjKTsKIAl9CiAKIAkvKiBNYXAgdGhlIGZpcm13YXJlIGh1YiBpbnRvIG15IGFkZHJlc3Mgc3BhY2UuICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9tYXBzL2ljaHhyb20uYyBiL2RyaXZlcnMvbXRkL21hcHMvaWNoeHJvbS5jCmluZGV4IGYxMDJiZjIuLjEzMzdhNDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL21hcHMvaWNoeHJvbS5jCisrKyBiL2RyaXZlcnMvbXRkL21hcHMvaWNoeHJvbS5jCkBAIC0xNzUsMTIgKzE3NSw5IEBACiAJd2luZG93LT5yc3JjLmZsYWdzID0gSU9SRVNPVVJDRV9NRU0gfCBJT1JFU09VUkNFX0JVU1k7CiAJaWYgKHJlcXVlc3RfcmVzb3VyY2UoJmlvbWVtX3Jlc291cmNlLCAmd2luZG93LT5yc3JjKSkgewogCQl3aW5kb3ctPnJzcmMucGFyZW50ID0gTlVMTDsKLQkJcHJpbnRrKEtFUk5fREVCVUcgTU9EX05BTUUKLQkJCSI6ICVzKCk6IFVuYWJsZSB0byByZWdpc3RlciByZXNvdXJjZSIKLQkJCSIgMHglLjE2bGx4LTB4JS4xNmxseCAtIGtlcm5lbCBidWc/XG4iLAotCQkJX19mdW5jX18sCi0JCQkodW5zaWduZWQgbG9uZyBsb25nKXdpbmRvdy0+cnNyYy5zdGFydCwKLQkJCSh1bnNpZ25lZCBsb25nIGxvbmcpd2luZG93LT5yc3JjLmVuZCk7CisJCXByaW50ayhLRVJOX0RFQlVHIE1PRF9OQU1FICI6ICIKKwkJICAgICAgICIlcygpOiBVbmFibGUgdG8gcmVnaXN0ZXIgcmVzb3VyY2UgJXBSIC0ga2VybmVsIGJ1Zz9cbiIsCisJCSAgICAgICBfX2Z1bmNfXywgJndpbmRvdy0+cnNyYyk7CiAJfQogCiAJLyogTWFwIHRoZSBmaXJtd2FyZSBodWIgaW50byBteSBhZGRyZXNzIHNwYWNlLiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbWFwcy9waHlzbWFwX29mLmMgYi9kcml2ZXJzL210ZC9tYXBzL3BoeXNtYXBfb2YuYwppbmRleCA5ODYxODE0Li44NTA2NTc4IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9tYXBzL3BoeXNtYXBfb2YuYworKysgYi9kcml2ZXJzL210ZC9tYXBzL3BoeXNtYXBfb2YuYwpAQCAtMjc0LDkgKzI3NCw3IEBACiAJCQljb250aW51ZTsKIAkJfQogCi0JCWRldl9kYmcoJmRldi0+ZGV2LCAib2ZfZmxhc2ggZGV2aWNlOiAlLjhsbHgtJS44bGx4XG4iLAotCQkJKHVuc2lnbmVkIGxvbmcgbG9uZylyZXMuc3RhcnQsCi0JCQkodW5zaWduZWQgbG9uZyBsb25nKXJlcy5lbmQpOworCQlkZXZfZGJnKCZkZXYtPmRldiwgIm9mX2ZsYXNoIGRldmljZTogJXBSXG4iLCAmcmVzKTsKIAogCQllcnIgPSAtRUJVU1k7CiAJCXJlc19zaXplID0gcmVzb3VyY2Vfc2l6ZSgmcmVzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL21hcHMvc2N4MjAwX2RvY2ZsYXNoLmMgYi9kcml2ZXJzL210ZC9tYXBzL3NjeDIwMF9kb2NmbGFzaC5jCmluZGV4IGI1MzkxZWIuLjAyN2U2MjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL21hcHMvc2N4MjAwX2RvY2ZsYXNoLmMKKysrIGIvZHJpdmVycy9tdGQvbWFwcy9zY3gyMDBfZG9jZmxhc2guYwpAQCAtMTY2LDkgKzE2Niw4IEBACiAJCW91dGwocG1yLCBzY3gyMDBfY2JfYmFzZSArIFNDeDIwMF9QTVIpOwogCX0KIAotICAgICAgIAlwcmludGsoS0VSTl9JTkZPIE5BTUUgIjogRE9DQ1MgbWFwcGVkIGF0IDB4JWxseC0weCVsbHgsIHdpZHRoICVkXG4iLAotCQkJKHVuc2lnbmVkIGxvbmcgbG9uZylkb2NtZW0uc3RhcnQsCi0JCQkodW5zaWduZWQgbG9uZyBsb25nKWRvY21lbS5lbmQsIHdpZHRoKTsKKwlwcmludGsoS0VSTl9JTkZPIE5BTUUgIjogRE9DQ1MgbWFwcGVkIGF0ICVwUiwgd2lkdGggJWRcbiIsCisJICAgICAgICZkb2NtZW0sIHdpZHRoKTsKIAogCXNjeDIwMF9kb2NmbGFzaF9tYXAuc2l6ZSA9IHNpemU7CiAJaWYgKHdpZHRoID09IDgpCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9tYXBzL3RxbTh4eGwuYyBiL2RyaXZlcnMvbXRkL21hcHMvdHFtOHh4bC5jCmluZGV4IDYwMTQ2OTguLmMwOGUxNDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL21hcHMvdHFtOHh4bC5jCisrKyBiL2RyaXZlcnMvbXRkL21hcHMvdHFtOHh4bC5jCkBAIC0xMzksNyArMTM5LDcgQEAKIAkJCWdvdG8gZXJyb3JfbWVtOwogCQl9CiAKLQkJbWFwX2JhbmtzW2lkeF0tPm5hbWUgPSAoY2hhciAqKWttYWxsb2MoMTYsIEdGUF9LRVJORUwpOworCQltYXBfYmFua3NbaWR4XS0+bmFtZSA9IGttYWxsb2MoMTYsIEdGUF9LRVJORUwpOwogCiAJCWlmICghbWFwX2JhbmtzW2lkeF0tPm5hbWUpIHsKIAkJCXJldCA9IC1FTk9NRU07CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9tdGRjaGFyLmMgYi9kcml2ZXJzL210ZC9tdGRjaGFyLmMKaW5kZXggZWU0YmIzMy4uMTQ1YjNkMGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL210ZGNoYXIuYworKysgYi9kcml2ZXJzL210ZC9tdGRjaGFyLmMKQEAgLTUyMiwxMCArNTIyLDYgQEAKIAlpZiAoIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCiAJCXJldHVybiAtRVBFUk07CiAKLQkvKiBPbmx5IG1hc3RlciBtdGQgZGV2aWNlIG11c3QgYmUgdXNlZCB0byBjb250cm9sIHBhcnRpdGlvbnMgKi8KLQlpZiAoIW10ZF9pc19tYXN0ZXIobXRkKSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KIAlpZiAoY29weV9mcm9tX3VzZXIoJmEsIGFyZywgc2l6ZW9mKHN0cnVjdCBibGtwZ19pb2N0bF9hcmcpKSkKIAkJcmV0dXJuIC1FRkFVTFQ7CiAKQEAgLTUzNSw2ICs1MzEsMTAgQEAKIAlzd2l0Y2ggKGEub3ApIHsKIAljYXNlIEJMS1BHX0FERF9QQVJUSVRJT046CiAKKwkJLyogT25seSBtYXN0ZXIgbXRkIGRldmljZSBtdXN0IGJlIHVzZWQgdG8gYWRkIHBhcnRpdGlvbnMgKi8KKwkJaWYgKG10ZF9pc19wYXJ0aXRpb24obXRkKSkKKwkJCXJldHVybiAtRUlOVkFMOworCiAJCXJldHVybiBtdGRfYWRkX3BhcnRpdGlvbihtdGQsIHAuZGV2bmFtZSwgcC5zdGFydCwgcC5sZW5ndGgpOwogCiAJY2FzZSBCTEtQR19ERUxfUEFSVElUSU9OOgpAQCAtNjAxLDYgKzYwMSw3IEBACiAJfQogCiAJY2FzZSBNRU1HRVRJTkZPOgorCQltZW1zZXQoJmluZm8sIDAsIHNpemVvZihpbmZvKSk7CiAJCWluZm8udHlwZQk9IG10ZC0+dHlwZTsKIAkJaW5mby5mbGFncwk9IG10ZC0+ZmxhZ3M7CiAJCWluZm8uc2l6ZQk9IG10ZC0+c2l6ZTsKQEAgLTYwOSw3ICs2MTAsNiBAQAogCQlpbmZvLm9vYnNpemUJPSBtdGQtPm9vYnNpemU7CiAJCS8qIFRoZSBiZWxvdyBmaWVsZHMgYXJlIG9ic29sZXRlICovCiAJCWluZm8uZWNjdHlwZQk9IC0xOwotCQlpbmZvLmVjY3NpemUJPSAwOwogCQlpZiAoY29weV90b191c2VyKGFyZ3AsICZpbmZvLCBzaXplb2Yoc3RydWN0IG10ZF9pbmZvX3VzZXIpKSkKIAkJCXJldHVybiAtRUZBVUxUOwogCQlicmVhazsKQEAgLTEyMDEsNyArMTIwMSw3IEBACiBzdGF0aWMgdm9pZCBfX2V4aXQgY2xlYW51cF9tdGRjaGFyKHZvaWQpCiB7CiAJdW5yZWdpc3Rlcl9tdGRfdXNlcigmbXRkY2hhcl9ub3RpZmllcik7Ci0JbW50cHV0X2xvbmcobXRkX2lub2RlX21udCk7CisJbW50cHV0KG10ZF9pbm9kZV9tbnQpOwogCXVucmVnaXN0ZXJfZmlsZXN5c3RlbSgmbXRkX2lub2RlZnNfdHlwZSk7CiAJX191bnJlZ2lzdGVyX2NocmRldihNVERfQ0hBUl9NQUpPUiwgMCwgMSA8PCBNSU5PUkJJVFMsICJtdGQiKTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL210ZGNvbmNhdC5jIGIvZHJpdmVycy9tdGQvbXRkY29uY2F0LmMKaW5kZXggYmY4ZGUwOS4uNWY1Nzc3YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbXRkY29uY2F0LmMKKysrIGIvZHJpdmVycy9tdGQvbXRkY29uY2F0LmMKQEAgLTc3Niw2ICs3NzYsNyBAQAogCWNvbmNhdC0+bXRkLnNpemUgPSBzdWJkZXZbMF0tPnNpemU7CiAJY29uY2F0LT5tdGQuZXJhc2VzaXplID0gc3ViZGV2WzBdLT5lcmFzZXNpemU7CiAJY29uY2F0LT5tdGQud3JpdGVzaXplID0gc3ViZGV2WzBdLT53cml0ZXNpemU7CisJY29uY2F0LT5tdGQud3JpdGVidWZzaXplID0gc3ViZGV2WzBdLT53cml0ZWJ1ZnNpemU7CiAJY29uY2F0LT5tdGQuc3VicGFnZV9zZnQgPSBzdWJkZXZbMF0tPnN1YnBhZ2Vfc2Z0OwogCWNvbmNhdC0+bXRkLm9vYnNpemUgPSBzdWJkZXZbMF0tPm9vYnNpemU7CiAJY29uY2F0LT5tdGQub29iYXZhaWwgPSBzdWJkZXZbMF0tPm9vYmF2YWlsOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbXRkb29wcy5jIGIvZHJpdmVycy9tdGQvbXRkb29wcy5jCmluZGV4IGM5NDgxNTAuLmUzZTQwZjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL210ZG9vcHMuYworKysgYi9kcml2ZXJzL210ZC9tdGRvb3BzLmMKQEAgLTQwMSw3ICs0MDEsOCBAQAogCQlwcmludGsoS0VSTl9XQVJOSU5HICJtdGRvb3BzOiBjb3VsZCBub3QgdW5yZWdpc3RlciBrbXNnX2R1bXBlclxuIik7CiAKIAljeHQtPm10ZCA9IE5VTEw7Ci0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKKwlmbHVzaF93b3JrX3N5bmMoJmN4dC0+d29ya19lcmFzZSk7CisJZmx1c2hfd29ya19zeW5jKCZjeHQtPndvcmtfd3JpdGUpOwogfQogCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL210ZHBhcnQuYyBiL2RyaXZlcnMvbXRkL210ZHBhcnQuYwppbmRleCA3OWUzNjg5Li4wYTQ3NjAxIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9tdGRwYXJ0LmMKKysrIGIvZHJpdmVycy9tdGQvbXRkcGFydC5jCkBAIC0xMjAsOCArMTIwLDI1IEBACiAJCXJldHVybiAtRUlOVkFMOwogCWlmIChvcHMtPmRhdGJ1ZiAmJiBmcm9tICsgb3BzLT5sZW4gPiBtdGQtPnNpemUpCiAJCXJldHVybiAtRUlOVkFMOwotCXJlcyA9IHBhcnQtPm1hc3Rlci0+cmVhZF9vb2IocGFydC0+bWFzdGVyLCBmcm9tICsgcGFydC0+b2Zmc2V0LCBvcHMpOwogCisJLyoKKwkgKiBJZiBPT0IgaXMgYWxzbyByZXF1ZXN0ZWQsIG1ha2Ugc3VyZSB0aGF0IHdlIGRvIG5vdCByZWFkIHBhc3QgdGhlIGVuZAorCSAqIG9mIHRoaXMgcGFydGl0aW9uLgorCSAqLworCWlmIChvcHMtPm9vYmJ1ZikgeworCQlzaXplX3QgbGVuLCBwYWdlczsKKworCQlpZiAob3BzLT5tb2RlID09IE1URF9PT0JfQVVUTykKKwkJCWxlbiA9IG10ZC0+b29iYXZhaWw7CisJCWVsc2UKKwkJCWxlbiA9IG10ZC0+b29ic2l6ZTsKKwkJcGFnZXMgPSBtdGRfZGl2X2J5X3dzKG10ZC0+c2l6ZSwgbXRkKTsKKwkJcGFnZXMgLT0gbXRkX2Rpdl9ieV93cyhmcm9tLCBtdGQpOworCQlpZiAob3BzLT5vb2JvZmZzICsgb3BzLT5vb2JsZW4gPiBwYWdlcyAqIGxlbikKKwkJCXJldHVybiAtRUlOVkFMOworCX0KKworCXJlcyA9IHBhcnQtPm1hc3Rlci0+cmVhZF9vb2IocGFydC0+bWFzdGVyLCBmcm9tICsgcGFydC0+b2Zmc2V0LCBvcHMpOwogCWlmICh1bmxpa2VseShyZXMpKSB7CiAJCWlmIChyZXMgPT0gLUVVQ0xFQU4pCiAJCQltdGQtPmVjY19zdGF0cy5jb3JyZWN0ZWQrKzsKQEAgLTM4NCw2ICs0MDEsNyBAQAogCXNsYXZlLT5tdGQuZmxhZ3MgPSBtYXN0ZXItPmZsYWdzICYgfnBhcnQtPm1hc2tfZmxhZ3M7CiAJc2xhdmUtPm10ZC5zaXplID0gcGFydC0+c2l6ZTsKIAlzbGF2ZS0+bXRkLndyaXRlc2l6ZSA9IG1hc3Rlci0+d3JpdGVzaXplOworCXNsYXZlLT5tdGQud3JpdGVidWZzaXplID0gbWFzdGVyLT53cml0ZWJ1ZnNpemU7CiAJc2xhdmUtPm10ZC5vb2JzaXplID0gbWFzdGVyLT5vb2JzaXplOwogCXNsYXZlLT5tdGQub29iYXZhaWwgPSBtYXN0ZXItPm9vYmF2YWlsOwogCXNsYXZlLT5tdGQuc3VicGFnZV9zZnQgPSBtYXN0ZXItPnN1YnBhZ2Vfc2Z0OwpAQCAtNzIwLDE5ICs3MzgsMTkgQEAKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKHBhcnNlX210ZF9wYXJ0aXRpb25zKTsKIAotaW50IG10ZF9pc19tYXN0ZXIoc3RydWN0IG10ZF9pbmZvICptdGQpCitpbnQgbXRkX2lzX3BhcnRpdGlvbihzdHJ1Y3QgbXRkX2luZm8gKm10ZCkKIHsKIAlzdHJ1Y3QgbXRkX3BhcnQgKnBhcnQ7Ci0JaW50IG5vcGFydCA9IDA7CisJaW50IGlzcGFydCA9IDA7CiAKIAltdXRleF9sb2NrKCZtdGRfcGFydGl0aW9uc19tdXRleCk7CiAJbGlzdF9mb3JfZWFjaF9lbnRyeShwYXJ0LCAmbXRkX3BhcnRpdGlvbnMsIGxpc3QpCiAJCWlmICgmcGFydC0+bXRkID09IG10ZCkgewotCQkJbm9wYXJ0ID0gMTsKKwkJCWlzcGFydCA9IDE7CiAJCQlicmVhazsKIAkJfQogCW11dGV4X3VubG9jaygmbXRkX3BhcnRpdGlvbnNfbXV0ZXgpOwogCi0JcmV0dXJuIG5vcGFydDsKKwlyZXR1cm4gaXNwYXJ0OwogfQotRVhQT1JUX1NZTUJPTF9HUEwobXRkX2lzX21hc3Rlcik7CitFWFBPUlRfU1lNQk9MX0dQTChtdGRfaXNfcGFydGl0aW9uKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvS2NvbmZpZyBiL2RyaXZlcnMvbXRkL25hbmQvS2NvbmZpZwppbmRleCA4MjI5ODAyLi5jODk1OTIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL0tjb25maWcKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9LY29uZmlnCkBAIC05Niw2ICs5Niw3IEBACiBjb25maWcgTVREX05BTkRfQU1TX0RFTFRBCiAJdHJpc3RhdGUgIk5BTkQgRmxhc2ggZGV2aWNlIG9uIEFtc3RyYWQgRTMiCiAJZGVwZW5kcyBvbiBNQUNIX0FNU19ERUxUQQorCWRlZmF1bHQgeQogCWhlbHAKIAkgIFN1cHBvcnQgZm9yIE5BTkQgZmxhc2ggb24gQW1zdHJhZCBFMyAoRGVsdGEpLgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9uYW5kL2Ftcy1kZWx0YS5jIGIvZHJpdmVycy9tdGQvbmFuZC9hbXMtZGVsdGEuYwppbmRleCAyNTQ4ZTEwLi5hMDY3ZDA5IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL2Ftcy1kZWx0YS5jCisrKyBiL2RyaXZlcnMvbXRkL25hbmQvYW1zLWRlbHRhLmMKQEAgLTQsNiArNCw4IEBACiAgKiAgQ29weXJpZ2h0IChDKSAyMDA2IEpvbmF0aGFuIE1jRG93ZWxsIDxub29kbGVzQGVhcnRoLmxpPgogICoKICAqICBEZXJpdmVkIGZyb20gZHJpdmVycy9tdGQvdG90by5jCisgKiAgQ29udmVydGVkIHRvIHBsYXRmb3JtIGRyaXZlciBieSBKYW51c3ogS3J6eXN6dG9maWsgPGprcnp5c3p0QHRpcy5pY25ldC5wbD4KKyAqICBQYXJ0aWFsbHkgc3RvbGVuIGZyb20gZHJpdmVycy9tdGQvbmFuZC9wbGF0X25hbmQuYwogICoKICAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwpAQCAtNjIsOSArNjQsMTAgQEAKIHN0YXRpYyB2b2lkIGFtc19kZWx0YV93cml0ZV9ieXRlKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCB1X2NoYXIgYnl0ZSkKIHsKIAlzdHJ1Y3QgbmFuZF9jaGlwICp0aGlzID0gbXRkLT5wcml2OworCXZvaWQgX19pb21lbSAqaW9fYmFzZSA9IHRoaXMtPnByaXY7CiAKLQlvbWFwX3dyaXRldygwLCAoT01BUDFfTVBVSU9fQkFTRSArIE9NQVBfTVBVSU9fSU9fQ05UTCkpOwotCW9tYXBfd3JpdGV3KGJ5dGUsIHRoaXMtPklPX0FERFJfVyk7CisJd3JpdGV3KDAsIGlvX2Jhc2UgKyBPTUFQX01QVUlPX0lPX0NOVEwpOworCXdyaXRldyhieXRlLCB0aGlzLT5JT19BRERSX1cpOwogCWFtc19kZWx0YV9sYXRjaDJfd3JpdGUoQU1TX0RFTFRBX0xBVENIMl9OQU5EX05XRSwgMCk7CiAJbmRlbGF5KDQwKTsKIAlhbXNfZGVsdGFfbGF0Y2gyX3dyaXRlKEFNU19ERUxUQV9MQVRDSDJfTkFORF9OV0UsCkBAIC03NSwxMSArNzgsMTIgQEAKIHsKIAl1X2NoYXIgcmVzOwogCXN0cnVjdCBuYW5kX2NoaXAgKnRoaXMgPSBtdGQtPnByaXY7CisJdm9pZCBfX2lvbWVtICppb19iYXNlID0gdGhpcy0+cHJpdjsKIAogCWFtc19kZWx0YV9sYXRjaDJfd3JpdGUoQU1TX0RFTFRBX0xBVENIMl9OQU5EX05SRSwgMCk7CiAJbmRlbGF5KDQwKTsKLQlvbWFwX3dyaXRldyh+MCwgKE9NQVAxX01QVUlPX0JBU0UgKyBPTUFQX01QVUlPX0lPX0NOVEwpKTsKLQlyZXMgPSBvbWFwX3JlYWR3KHRoaXMtPklPX0FERFJfUik7CisJd3JpdGV3KH4wLCBpb19iYXNlICsgT01BUF9NUFVJT19JT19DTlRMKTsKKwlyZXMgPSByZWFkdyh0aGlzLT5JT19BRERSX1IpOwogCWFtc19kZWx0YV9sYXRjaDJfd3JpdGUoQU1TX0RFTFRBX0xBVENIMl9OQU5EX05SRSwKIAkJCSAgICAgICBBTVNfREVMVEFfTEFUQ0gyX05BTkRfTlJFKTsKIApAQCAtMTUxLDExICsxNTUsMTYgQEAKIC8qCiAgKiBNYWluIGluaXRpYWxpemF0aW9uIHJvdXRpbmUKICAqLwotc3RhdGljIGludCBfX2luaXQgYW1zX2RlbHRhX2luaXQodm9pZCkKK3N0YXRpYyBpbnQgX19kZXZpbml0IGFtc19kZWx0YV9pbml0KHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiB7CiAJc3RydWN0IG5hbmRfY2hpcCAqdGhpczsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNFX01FTSwgMCk7CisJdm9pZCBfX2lvbWVtICppb19iYXNlOwogCWludCBlcnIgPSAwOwogCisJaWYgKCFyZXMpCisJCXJldHVybiAtRU5YSU87CisKIAkvKiBBbGxvY2F0ZSBtZW1vcnkgZm9yIE1URCBkZXZpY2Ugc3RydWN0dXJlIGFuZCBwcml2YXRlIGRhdGEgKi8KIAlhbXNfZGVsdGFfbXRkID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IG10ZF9pbmZvKSArCiAJCQkJc2l6ZW9mKHN0cnVjdCBuYW5kX2NoaXApLCBHRlBfS0VSTkVMKTsKQEAgLTE3Nyw5ICsxODYsMjUgQEAKIAkvKiBMaW5rIHRoZSBwcml2YXRlIGRhdGEgd2l0aCB0aGUgTVREIHN0cnVjdHVyZSAqLwogCWFtc19kZWx0YV9tdGQtPnByaXYgPSB0aGlzOwogCisJaWYgKCFyZXF1ZXN0X21lbV9yZWdpb24ocmVzLT5zdGFydCwgcmVzb3VyY2Vfc2l6ZShyZXMpLAorCQkJZGV2X25hbWUoJnBkZXYtPmRldikpKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgInJlcXVlc3RfbWVtX3JlZ2lvbiBmYWlsZWRcbiIpOworCQllcnIgPSAtRUJVU1k7CisJCWdvdG8gb3V0X2ZyZWU7CisJfQorCisJaW9fYmFzZSA9IGlvcmVtYXAocmVzLT5zdGFydCwgcmVzb3VyY2Vfc2l6ZShyZXMpKTsKKwlpZiAoaW9fYmFzZSA9PSBOVUxMKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgImlvcmVtYXAgZmFpbGVkXG4iKTsKKwkJZXJyID0gLUVJTzsKKwkJZ290byBvdXRfcmVsZWFzZV9pbzsKKwl9CisKKwl0aGlzLT5wcml2ID0gaW9fYmFzZTsKKwogCS8qIFNldCBhZGRyZXNzIG9mIE5BTkQgSU8gbGluZXMgKi8KLQl0aGlzLT5JT19BRERSX1IgPSAoT01BUDFfTVBVSU9fQkFTRSArIE9NQVBfTVBVSU9fSU5QVVRfTEFUQ0gpOwotCXRoaXMtPklPX0FERFJfVyA9IChPTUFQMV9NUFVJT19CQVNFICsgT01BUF9NUFVJT19PVVRQVVQpOworCXRoaXMtPklPX0FERFJfUiA9IGlvX2Jhc2UgKyBPTUFQX01QVUlPX0lOUFVUX0xBVENIOworCXRoaXMtPklPX0FERFJfVyA9IGlvX2Jhc2UgKyBPTUFQX01QVUlPX09VVFBVVDsKIAl0aGlzLT5yZWFkX2J5dGUgPSBhbXNfZGVsdGFfcmVhZF9ieXRlOwogCXRoaXMtPndyaXRlX2J1ZiA9IGFtc19kZWx0YV93cml0ZV9idWY7CiAJdGhpcy0+cmVhZF9idWYgPSBhbXNfZGVsdGFfcmVhZF9idWY7CkBAIC0xOTUsNiArMjIwLDggQEAKIAl0aGlzLT5jaGlwX2RlbGF5ID0gMzA7CiAJdGhpcy0+ZWNjLm1vZGUgPSBOQU5EX0VDQ19TT0ZUOwogCisJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgaW9fYmFzZSk7CisKIAkvKiBTZXQgY2hpcCBlbmFibGVkLCBidXQgICovCiAJYW1zX2RlbHRhX2xhdGNoMl93cml0ZShOQU5EX01BU0ssIEFNU19ERUxUQV9MQVRDSDJfTkFORF9OUkUgfAogCQkJCQkgIEFNU19ERUxUQV9MQVRDSDJfTkFORF9OV0UgfApAQCAtMjE0LDI1ICsyNDEsNTYgQEAKIAlnb3RvIG91dDsKIAogIG91dF9tdGQ6CisJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgTlVMTCk7CisJaW91bm1hcChpb19iYXNlKTsKK291dF9yZWxlYXNlX2lvOgorCXJlbGVhc2VfbWVtX3JlZ2lvbihyZXMtPnN0YXJ0LCByZXNvdXJjZV9zaXplKHJlcykpOworb3V0X2ZyZWU6CiAJa2ZyZWUoYW1zX2RlbHRhX210ZCk7CiAgb3V0OgogCXJldHVybiBlcnI7CiB9CiAKLW1vZHVsZV9pbml0KGFtc19kZWx0YV9pbml0KTsKLQogLyoKICAqIENsZWFuIHVwIHJvdXRpbmUKICAqLwotc3RhdGljIHZvaWQgX19leGl0IGFtc19kZWx0YV9jbGVhbnVwKHZvaWQpCitzdGF0aWMgaW50IF9fZGV2ZXhpdCBhbXNfZGVsdGFfY2xlYW51cChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogeworCXZvaWQgX19pb21lbSAqaW9fYmFzZSA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOworCXN0cnVjdCByZXNvdXJjZSAqcmVzID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsKKwogCS8qIFJlbGVhc2UgcmVzb3VyY2VzLCB1bnJlZ2lzdGVyIGRldmljZSAqLwogCW5hbmRfcmVsZWFzZShhbXNfZGVsdGFfbXRkKTsKIAorCWlvdW5tYXAoaW9fYmFzZSk7CisJcmVsZWFzZV9tZW1fcmVnaW9uKHJlcy0+c3RhcnQsIHJlc291cmNlX3NpemUocmVzKSk7CisKIAkvKiBGcmVlIHRoZSBNVEQgZGV2aWNlIHN0cnVjdHVyZSAqLwogCWtmcmVlKGFtc19kZWx0YV9tdGQpOworCisJcmV0dXJuIDA7CiB9Ci1tb2R1bGVfZXhpdChhbXNfZGVsdGFfY2xlYW51cCk7CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGFtc19kZWx0YV9uYW5kX2RyaXZlciA9IHsKKwkucHJvYmUJCT0gYW1zX2RlbHRhX2luaXQsCisJLnJlbW92ZQkJPSBfX2RldmV4aXRfcChhbXNfZGVsdGFfY2xlYW51cCksCisJLmRyaXZlcgkJPSB7CisJCS5uYW1lCT0gImFtcy1kZWx0YS1uYW5kIiwKKwkJLm93bmVyCT0gVEhJU19NT0RVTEUsCisJfSwKK307CisKK3N0YXRpYyBpbnQgX19pbml0IGFtc19kZWx0YV9uYW5kX2luaXQodm9pZCkKK3sKKwlyZXR1cm4gcGxhdGZvcm1fZHJpdmVyX3JlZ2lzdGVyKCZhbXNfZGVsdGFfbmFuZF9kcml2ZXIpOworfQorbW9kdWxlX2luaXQoYW1zX2RlbHRhX25hbmRfaW5pdCk7CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBhbXNfZGVsdGFfbmFuZF9leGl0KHZvaWQpCit7CisJcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIoJmFtc19kZWx0YV9uYW5kX2RyaXZlcik7Cit9Cittb2R1bGVfZXhpdChhbXNfZGVsdGFfbmFuZF9leGl0KTsKIAogTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwogTU9EVUxFX0FVVEhPUigiSm9uYXRoYW4gTWNEb3dlbGwgPG5vb2RsZXNAZWFydGgubGk+Iik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9uYW5kL2ZzbF9lbGJjX25hbmQuYyBiL2RyaXZlcnMvbXRkL25hbmQvZnNsX2VsYmNfbmFuZC5jCmluZGV4IGMxNDFiMDcuLjdhMTNkNDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL25hbmQvZnNsX2VsYmNfbmFuZC5jCisrKyBiL2RyaXZlcnMvbXRkL25hbmQvZnNsX2VsYmNfbmFuZC5jCkBAIC0zODgsNiArMzg4LDggQEAKIAkJICAgICAgICAgInBhZ2VfYWRkcjogMHgleCwgY29sdW1uOiAweCV4LlxuIiwKIAkJICAgICAgICAgcGFnZV9hZGRyLCBjb2x1bW4pOwogCisJCWVsYmNfZmNtX2N0cmwtPmNvbHVtbiA9IGNvbHVtbjsKKwkJZWxiY19mY21fY3RybC0+b29iID0gMDsKIAkJZWxiY19mY21fY3RybC0+dXNlX21kciA9IDE7CiAKIAkJZmNyID0gKE5BTkRfQ01EX1NUQVRVUyAgIDw8IEZDUl9DTUQxX1NISUZUKSB8CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9uYW5kL2ZzbWNfbmFuZC5jIGIvZHJpdmVycy9tdGQvbmFuZC9mc21jX25hbmQuYwppbmRleCAwMmVkZmJhLi4yMDViMTBiIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL2ZzbWNfbmFuZC5jCisrKyBiL2RyaXZlcnMvbXRkL25hbmQvZnNtY19uYW5kLmMKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlIDxsaW51eC9pby5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9tdGQvZnNtYy5oPgorI2luY2x1ZGUgPGxpbnV4L2FtYmEvYnVzLmg+CiAjaW5jbHVkZSA8bXRkL210ZC1hYmkuaD4KIAogc3RhdGljIHN0cnVjdCBuYW5kX2VjY2xheW91dCBmc21jX2VjYzFfbGF5b3V0ID0gewpAQCAtMTE5LDIxICsxMjAsMzYgQEAKIAl9CiB9OwogCisKKyNpZmRlZiBDT05GSUdfTVREX1BBUlRJVElPTlMKIC8qCiAgKiBEZWZhdWx0IHBhcnRpdGlvbiB0YWJsZXMgdG8gYmUgdXNlZCBpZiB0aGUgcGFydGl0aW9uIGluZm9ybWF0aW9uIG5vdAotICogcHJvdmlkZWQgdGhyb3VnaCBwbGF0Zm9ybSBkYXRhCi0gKi8KLSNkZWZpbmUgUEFSVElUSU9OKG4sIG9mZiwgc3opCXsubmFtZSA9IG4sIC5vZmZzZXQgPSBvZmYsIC5zaXplID0gc3p9Ci0KLS8qCisgKiBwcm92aWRlZCB0aHJvdWdoIHBsYXRmb3JtIGRhdGEuCisgKgogICogRGVmYXVsdCBwYXJ0aXRpb24gbGF5b3V0IGZvciBzbWFsbCBwYWdlKD0gNTEyIGJ5dGVzKSBkZXZpY2VzCiAgKiBTaXplIGZvciAiUm9vdCBmaWxlIHN5c3RlbSIgaXMgdXBkYXRlZCBpbiBkcml2ZXIgYmFzZWQgb24gYWN0dWFsIGRldmljZSBzaXplCiAgKi8KIHN0YXRpYyBzdHJ1Y3QgbXRkX3BhcnRpdGlvbiBwYXJ0aXRpb25faW5mb18xNktCX2Jsa1tdID0gewotCVBBUlRJVElPTigiWC1sb2FkZXIiLCAwLCA0ICogMHg0MDAwKSwKLQlQQVJUSVRJT04oIlUtQm9vdCIsIDB4MTAwMDAsIDIwICogMHg0MDAwKSwKLQlQQVJUSVRJT04oIktlcm5lbCIsIDB4NjAwMDAsIDI1NiAqIDB4NDAwMCksCi0JUEFSVElUSU9OKCJSb290IEZpbGUgU3lzdGVtIiwgMHg0NjAwMDAsIDApLAorCXsKKwkJLm5hbWUgPSAiWC1sb2FkZXIiLAorCQkub2Zmc2V0ID0gMCwKKwkJLnNpemUgPSA0KjB4NDAwMCwKKwl9LAorCXsKKwkJLm5hbWUgPSAiVS1Cb290IiwKKwkJLm9mZnNldCA9IDB4MTAwMDAsCisJCS5zaXplID0gMjAqMHg0MDAwLAorCX0sCisJeworCQkubmFtZSA9ICJLZXJuZWwiLAorCQkub2Zmc2V0ID0gMHg2MDAwMCwKKwkJLnNpemUgPSAyNTYqMHg0MDAwLAorCX0sCisJeworCQkubmFtZSA9ICJSb290IEZpbGUgU3lzdGVtIiwKKwkJLm9mZnNldCA9IDB4NDYwMDAwLAorCQkuc2l6ZSA9IDAsCisJfSwKIH07CiAKIC8qCkBAIC0xNDEsMTkgKzE1NywzNyBAQAogICogU2l6ZSBmb3IgIlJvb3QgZmlsZSBzeXN0ZW0iIGlzIHVwZGF0ZWQgaW4gZHJpdmVyIGJhc2VkIG9uIGFjdHVhbCBkZXZpY2Ugc2l6ZQogICovCiBzdGF0aWMgc3RydWN0IG10ZF9wYXJ0aXRpb24gcGFydGl0aW9uX2luZm9fMTI4S0JfYmxrW10gPSB7Ci0JUEFSVElUSU9OKCJYLWxvYWRlciIsIDAsIDQgKiAweDIwMDAwKSwKLQlQQVJUSVRJT04oIlUtQm9vdCIsIDB4ODAwMDAsIDEyICogMHgyMDAwMCksCi0JUEFSVElUSU9OKCJLZXJuZWwiLCAweDIwMDAwMCwgNDggKiAweDIwMDAwKSwKLQlQQVJUSVRJT04oIlJvb3QgRmlsZSBTeXN0ZW0iLCAweDgwMDAwMCwgMCksCisJeworCQkubmFtZSA9ICJYLWxvYWRlciIsCisJCS5vZmZzZXQgPSAwLAorCQkuc2l6ZSA9IDQqMHgyMDAwMCwKKwl9LAorCXsKKwkJLm5hbWUgPSAiVS1Cb290IiwKKwkJLm9mZnNldCA9IDB4ODAwMDAsCisJCS5zaXplID0gMTIqMHgyMDAwMCwKKwl9LAorCXsKKwkJLm5hbWUgPSAiS2VybmVsIiwKKwkJLm9mZnNldCA9IDB4MjAwMDAwLAorCQkuc2l6ZSA9IDQ4KjB4MjAwMDAsCisJfSwKKwl7CisJCS5uYW1lID0gIlJvb3QgRmlsZSBTeXN0ZW0iLAorCQkub2Zmc2V0ID0gMHg4MDAwMDAsCisJCS5zaXplID0gMCwKKwl9LAogfTsKIAogI2lmZGVmIENPTkZJR19NVERfQ01ETElORV9QQVJUUwogY29uc3QgY2hhciAqcGFydF9wcm9iZXNbXSA9IHsgImNtZGxpbmVwYXJ0IiwgTlVMTCB9OwogI2VuZGlmCisjZW5kaWYKIAogLyoqCi0gKiBzdHJ1Y3QgZnNtY19uYW5kX2RhdGEgLSBhdHJ1Y3R1cmUgZm9yIEZTTUMgTkFORCBkZXZpY2Ugc3RhdGUKKyAqIHN0cnVjdCBmc21jX25hbmRfZGF0YSAtIHN0cnVjdHVyZSBmb3IgRlNNQyBOQU5EIGRldmljZSBzdGF0ZQogICoKKyAqIEBwaWQ6CQlQYXJ0IElEIG9uIHRoZSBBTUJBIFByaW1lQ2VsbCBmb3JtYXQKICAqIEBtdGQ6CQlNVEQgaW5mbyBmb3IgYSBOQU5EIGZsYXNoLgogICogQG5hbmQ6CQlDaGlwIHJlbGF0ZWQgaW5mbyBmb3IgYSBOQU5EIGZsYXNoLgogICogQHBhcnRpdGlvbnM6CQlQYXJ0aXRpb24gaW5mbyBmb3IgYSBOQU5EIEZsYXNoLgpAQCAtMTY5LDYgKzIwMyw3IEBACiAgKiBAcmVnc192YToJCUZTTUMgcmVncyBiYXNlIGFkZHJlc3MuCiAgKi8KIHN0cnVjdCBmc21jX25hbmRfZGF0YSB7CisJdTMyCQkJcGlkOwogCXN0cnVjdCBtdGRfaW5mbwkJbXRkOwogCXN0cnVjdCBuYW5kX2NoaXAJbmFuZDsKIAlzdHJ1Y3QgbXRkX3BhcnRpdGlvbgkqcGFydGl0aW9uczsKQEAgLTUwOCw3ICs1NDMsOSBAQAogCXN0cnVjdCBuYW5kX2NoaXAgKm5hbmQ7CiAJc3RydWN0IGZzbWNfcmVncyAqcmVnczsKIAlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKLQlpbnQgbnJfcGFydHMsIHJldCA9IDA7CisJaW50IHJldCA9IDA7CisJdTMyIHBpZDsKKwlpbnQgaTsKIAogCWlmICghcGRhdGEpIHsKIAkJZGV2X2VycigmcGRldi0+ZGV2LCAicGxhdGZvcm0gZGF0YSBpcyBOVUxMXG4iKTsKQEAgLTU5OCw2ICs2MzUsMTggQEAKIAlpZiAocmV0KQogCQlnb3RvIGVycl9wcm9iZTE7CiAKKwkvKgorCSAqIFRoaXMgZGV2aWNlIElEIGlzIGFjdHVhbGx5IGEgY29tbW9uIEFNQkEgSUQgYXMgdXNlZCBvbiB0aGUKKwkgKiBBTUJBIFByaW1lQ2VsbCBidXMuIEhvd2V2ZXIgaXQgaXMgbm90IGEgUHJpbWVDZWxsLgorCSAqLworCWZvciAocGlkID0gMCwgaSA9IDA7IGkgPCA0OyBpKyspCisJCXBpZCB8PSAocmVhZGwoaG9zdC0+cmVnc192YSArIHJlc291cmNlX3NpemUocmVzKSAtIDB4MjAgKyA0ICogaSkgJiAyNTUpIDw8IChpICogOCk7CisJaG9zdC0+cGlkID0gcGlkOworCWRldl9pbmZvKCZwZGV2LT5kZXYsICJGU01DIGRldmljZSBwYXJ0bm8gJTAzeCwgbWFudWZhY3R1cmVyICUwMngsICIKKwkJICJyZXZpc2lvbiAlMDJ4LCBjb25maWcgJTAyeFxuIiwKKwkJIEFNQkFfUEFSVF9CSVRTKHBpZCksIEFNQkFfTUFORl9CSVRTKHBpZCksCisJCSBBTUJBX1JFVl9CSVRTKHBpZCksIEFNQkFfQ09ORklHX0JJVFMocGlkKSk7CisKIAlob3N0LT5iYW5rID0gcGRhdGEtPmJhbms7CiAJaG9zdC0+c2VsZWN0X2NoaXAgPSBwZGF0YS0+c2VsZWN0X2Jhbms7CiAJcmVncyA9IGhvc3QtPnJlZ3NfdmE7CkBAIC02MjUsNyArNjc0LDcgQEAKIAogCWZzbWNfbmFuZF9zZXR1cChyZWdzLCBob3N0LT5iYW5rLCBuYW5kLT5vcHRpb25zICYgTkFORF9CVVNXSURUSF8xNik7CiAKLQlpZiAoZ2V0X2ZzbWNfdmVyc2lvbihob3N0LT5yZWdzX3ZhKSA9PSBGU01DX1ZFUjgpIHsKKwlpZiAoQU1CQV9SRVZfQklUUyhob3N0LT5waWQpID49IDgpIHsKIAkJbmFuZC0+ZWNjLnJlYWRfcGFnZSA9IGZzbWNfcmVhZF9wYWdlX2h3ZWNjOwogCQluYW5kLT5lY2MuY2FsY3VsYXRlID0gZnNtY19yZWFkX2h3ZWNjX2VjYzQ7CiAJCW5hbmQtPmVjYy5jb3JyZWN0ID0gZnNtY19jb3JyZWN0X2RhdGE7CkBAIC02NDUsNyArNjk0LDcgQEAKIAkJZ290byBlcnJfcHJvYmU7CiAJfQogCi0JaWYgKGdldF9mc21jX3ZlcnNpb24oaG9zdC0+cmVnc192YSkgPT0gRlNNQ19WRVI4KSB7CisJaWYgKEFNQkFfUkVWX0JJVFMoaG9zdC0+cGlkKSA+PSA4KSB7CiAJCWlmIChob3N0LT5tdGQud3JpdGVzaXplID09IDUxMikgewogCQkJbmFuZC0+ZWNjLmxheW91dCA9ICZmc21jX2VjYzRfc3BfbGF5b3V0OwogCQkJaG9zdC0+ZWNjX3BsYWNlID0gJmZzbWNfZWNjNF9zcF9wbGFjZTsKQEAgLTY3NiwxMSArNzI1LDkgQEAKIAkgKiBDaGVjayBpZiBwYXJ0aXRpb24gaW5mbyBwYXNzZWQgdmlhIGNvbW1hbmQgbGluZQogCSAqLwogCWhvc3QtPm10ZC5uYW1lID0gIm5hbmQiOwotCW5yX3BhcnRzID0gcGFyc2VfbXRkX3BhcnRpdGlvbnMoJmhvc3QtPm10ZCwgcGFydF9wcm9iZXMsCisJaG9zdC0+bnJfcGFydGl0aW9ucyA9IHBhcnNlX210ZF9wYXJ0aXRpb25zKCZob3N0LT5tdGQsIHBhcnRfcHJvYmVzLAogCQkJJmhvc3QtPnBhcnRpdGlvbnMsIDApOwotCWlmIChucl9wYXJ0cyA+IDApIHsKLQkJaG9zdC0+bnJfcGFydGl0aW9ucyA9IG5yX3BhcnRzOwotCX0gZWxzZSB7CisJaWYgKGhvc3QtPm5yX3BhcnRpdGlvbnMgPD0gMCkgewogI2VuZGlmCiAJCS8qCiAJCSAqIENoZWNrIGlmIHBhcnRpdGlvbiBpbmZvIHBhc3NlZCB2aWEgY29tbWFuZCBsaW5lCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9uYW5kL2p6NDc0MF9uYW5kLmMgYi9kcml2ZXJzL210ZC9uYW5kL2p6NDc0MF9uYW5kLmMKaW5kZXggNjczNDNmYy4uY2VhMzhhNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbmFuZC9qejQ3NDBfbmFuZC5jCisrKyBiL2RyaXZlcnMvbXRkL25hbmQvano0NzQwX25hbmQuYwpAQCAtMjUxLDU4ICsyNTEsNiBAQAogCXJldHVybiAwOwogfQogCi0KLS8qIENvcHkgcGFzdGUgb2YgbmFuZF9yZWFkX3BhZ2VfaHdlY2Nfb29iX2ZpcnN0IGV4Y2VwdCBmb3IgZGlmZmVyZW50IGVjY3BvcwotICogaGFuZGxpbmcuIFRoZSBlY2MgYXJlYSBpcyBmb3IgNGsgY2hpcHMgNzIgYnl0ZXMgbG9uZyBhbmQgdGh1cyBkb2VzIG5vdCBmaXQKLSAqIGludG8gdGhlIGVjY3BvcyBhcnJheS4gKi8KLXN0YXRpYyBpbnQganpfbmFuZF9yZWFkX3BhZ2VfaHdlY2Nfb29iX2ZpcnN0KHN0cnVjdCBtdGRfaW5mbyAqbXRkLAotCXN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsIHVpbnQ4X3QgKmJ1ZiwgaW50IHBhZ2UpCi17Ci0JaW50IGksIGVjY3NpemUgPSBjaGlwLT5lY2Muc2l6ZTsKLQlpbnQgZWNjYnl0ZXMgPSBjaGlwLT5lY2MuYnl0ZXM7Ci0JaW50IGVjY3N0ZXBzID0gY2hpcC0+ZWNjLnN0ZXBzOwotCXVpbnQ4X3QgKnAgPSBidWY7Ci0JdW5zaWduZWQgaW50IGVjY19vZmZzZXQgPSBjaGlwLT5wYWdlX3NoaWZ0OwotCi0JLyogUmVhZCB0aGUgT09CIGFyZWEgZmlyc3QgKi8KLQljaGlwLT5jbWRmdW5jKG10ZCwgTkFORF9DTURfUkVBRE9PQiwgMCwgcGFnZSk7Ci0JY2hpcC0+cmVhZF9idWYobXRkLCBjaGlwLT5vb2JfcG9pLCBtdGQtPm9vYnNpemUpOwotCWNoaXAtPmNtZGZ1bmMobXRkLCBOQU5EX0NNRF9SRUFEMCwgMCwgcGFnZSk7Ci0KLQlmb3IgKGkgPSBlY2Nfb2Zmc2V0OyBlY2NzdGVwczsgZWNjc3RlcHMtLSwgaSArPSBlY2NieXRlcywgcCArPSBlY2NzaXplKSB7Ci0JCWludCBzdGF0OwotCi0JCWNoaXAtPmVjYy5od2N0bChtdGQsIE5BTkRfRUNDX1JFQUQpOwotCQljaGlwLT5yZWFkX2J1ZihtdGQsIHAsIGVjY3NpemUpOwotCi0JCXN0YXQgPSBjaGlwLT5lY2MuY29ycmVjdChtdGQsIHAsICZjaGlwLT5vb2JfcG9pW2ldLCBOVUxMKTsKLQkJaWYgKHN0YXQgPCAwKQotCQkJbXRkLT5lY2Nfc3RhdHMuZmFpbGVkKys7Ci0JCWVsc2UKLQkJCW10ZC0+ZWNjX3N0YXRzLmNvcnJlY3RlZCArPSBzdGF0OwotCX0KLQlyZXR1cm4gMDsKLX0KLQotLyogQ29weS1hbmQtcGFzdGUgb2YgbmFuZF93cml0ZV9wYWdlX2h3ZWNjIHdpdGggZGlmZmVyZW50IGVjY3BvcyBoYW5kbGluZy4gKi8KLXN0YXRpYyB2b2lkIGp6X25hbmRfd3JpdGVfcGFnZV9od2VjYyhzdHJ1Y3QgbXRkX2luZm8gKm10ZCwKLQlzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwLCBjb25zdCB1aW50OF90ICpidWYpCi17Ci0JaW50IGksIGVjY3NpemUgPSBjaGlwLT5lY2Muc2l6ZTsKLQlpbnQgZWNjYnl0ZXMgPSBjaGlwLT5lY2MuYnl0ZXM7Ci0JaW50IGVjY3N0ZXBzID0gY2hpcC0+ZWNjLnN0ZXBzOwotCWNvbnN0IHVpbnQ4X3QgKnAgPSBidWY7Ci0JdW5zaWduZWQgaW50IGVjY19vZmZzZXQgPSBjaGlwLT5wYWdlX3NoaWZ0OwotCi0JZm9yIChpID0gZWNjX29mZnNldDsgZWNjc3RlcHM7IGVjY3N0ZXBzLS0sIGkgKz0gZWNjYnl0ZXMsIHAgKz0gZWNjc2l6ZSkgewotCQljaGlwLT5lY2MuaHdjdGwobXRkLCBOQU5EX0VDQ19XUklURSk7Ci0JCWNoaXAtPndyaXRlX2J1ZihtdGQsIHAsIGVjY3NpemUpOwotCQljaGlwLT5lY2MuY2FsY3VsYXRlKG10ZCwgcCwgJmNoaXAtPm9vYl9wb2lbaV0pOwotCX0KLQotCWNoaXAtPndyaXRlX2J1ZihtdGQsIGNoaXAtPm9vYl9wb2ksIG10ZC0+b29ic2l6ZSk7Ci19Ci0KICNpZmRlZiBDT05GSUdfTVREX0NNRExJTkVfUEFSVFMKIHN0YXRpYyBjb25zdCBjaGFyICpwYXJ0X3Byb2Jlc1tdID0geyJjbWRsaW5lIiwgTlVMTH07CiAjZW5kaWYKQEAgLTM5Myw5ICszNDEsNiBAQAogCWNoaXAtPmVjYy5zaXplCQk9IDUxMjsKIAljaGlwLT5lY2MuYnl0ZXMJCT0gOTsKIAotCWNoaXAtPmVjYy5yZWFkX3BhZ2UJPSBqel9uYW5kX3JlYWRfcGFnZV9od2VjY19vb2JfZmlyc3Q7Ci0JY2hpcC0+ZWNjLndyaXRlX3BhZ2UJPSBqel9uYW5kX3dyaXRlX3BhZ2VfaHdlY2M7Ci0KIAlpZiAocGRhdGEpCiAJCWNoaXAtPmVjYy5sYXlvdXQgPSBwZGF0YS0+ZWNjX2xheW91dDsKIApAQCAtNDg5LDcgKzQzNCw3IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIganpfbmFuZF9kcml2ZXIgPSB7CitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBqel9uYW5kX2RyaXZlciA9IHsKIAkucHJvYmUgPSBqel9uYW5kX3Byb2JlLAogCS5yZW1vdmUgPSBfX2RldmV4aXRfcChqel9uYW5kX3JlbW92ZSksCiAJLmRyaXZlciA9IHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvbXhjX25hbmQuYyBiL2RyaXZlcnMvbXRkL25hbmQvbXhjX25hbmQuYwppbmRleCAyMTRiMDNhLi5lZjkzMmJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL214Y19uYW5kLmMKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9teGNfbmFuZC5jCkBAIC0xMDA5LDcgKzEwMDksNyBAQAogCXN0cnVjdCBteGNfbmFuZF9wbGF0Zm9ybV9kYXRhICpwZGF0YSA9IHBkZXYtPmRldi5wbGF0Zm9ybV9kYXRhOwogCXN0cnVjdCBteGNfbmFuZF9ob3N0ICpob3N0OwogCXN0cnVjdCByZXNvdXJjZSAqcmVzOwotCWludCBlcnIgPSAwLCBucl9wYXJ0cyA9IDA7CisJaW50IGVyciA9IDAsIF9fbWF5YmVfdW51c2VkIG5yX3BhcnRzID0gMDsKIAlzdHJ1Y3QgbmFuZF9lY2NsYXlvdXQgKm9vYl9zbWFsbHBhZ2UsICpvb2JfbGFyZ2VwYWdlOwogCiAJLyogQWxsb2NhdGUgbWVtb3J5IGZvciBNVEQgZGV2aWNlIHN0cnVjdHVyZSBhbmQgcHJpdmF0ZSBkYXRhICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9uYW5kL25hbmRfYmFzZS5jIGIvZHJpdmVycy9tdGQvbmFuZC9uYW5kX2Jhc2UuYwppbmRleCAzMWJmMzc2Li5hOWM2Y2U3IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL25hbmRfYmFzZS5jCisrKyBiL2RyaXZlcnMvbXRkL25hbmQvbmFuZF9iYXNlLmMKQEAgLTI4NjUsMjAgKzI4NjUsMjQgQEAKIAogCS8qIGNoZWNrIHZlcnNpb24gKi8KIAl2YWwgPSBsZTE2X3RvX2NwdShwLT5yZXZpc2lvbik7Ci0JaWYgKHZhbCA9PSAxIHx8IHZhbCA+ICgxIDw8IDQpKSB7Ci0JCXByaW50ayhLRVJOX0lORk8gIiVzOiB1bnN1cHBvcnRlZCBPTkZJIHZlcnNpb246ICVkXG4iLAotCQkJCQkJCQlfX2Z1bmNfXywgdmFsKTsKLQkJcmV0dXJuIDA7Ci0JfQotCi0JaWYgKHZhbCAmICgxIDw8IDQpKQorCWlmICh2YWwgJiAoMSA8PCA1KSkKKwkJY2hpcC0+b25maV92ZXJzaW9uID0gMjM7CisJZWxzZSBpZiAodmFsICYgKDEgPDwgNCkpCiAJCWNoaXAtPm9uZmlfdmVyc2lvbiA9IDIyOwogCWVsc2UgaWYgKHZhbCAmICgxIDw8IDMpKQogCQljaGlwLT5vbmZpX3ZlcnNpb24gPSAyMTsKIAllbHNlIGlmICh2YWwgJiAoMSA8PCAyKSkKIAkJY2hpcC0+b25maV92ZXJzaW9uID0gMjA7Ci0JZWxzZQorCWVsc2UgaWYgKHZhbCAmICgxIDw8IDEpKQogCQljaGlwLT5vbmZpX3ZlcnNpb24gPSAxMDsKKwllbHNlCisJCWNoaXAtPm9uZmlfdmVyc2lvbiA9IDA7CisKKwlpZiAoIWNoaXAtPm9uZmlfdmVyc2lvbikgeworCQlwcmludGsoS0VSTl9JTkZPICIlczogdW5zdXBwb3J0ZWQgT05GSSB2ZXJzaW9uOiAlZFxuIiwKKwkJCQkJCQkJX19mdW5jX18sIHZhbCk7CisJCXJldHVybiAwOworCX0KIAogCXNhbml0aXplX3N0cmluZyhwLT5tYW51ZmFjdHVyZXIsIHNpemVvZihwLT5tYW51ZmFjdHVyZXIpKTsKIAlzYW5pdGl6ZV9zdHJpbmcocC0+bW9kZWwsIHNpemVvZihwLT5tb2RlbCkpOwpAQCAtMjg4Nyw3ICsyODkxLDcgQEAKIAltdGQtPndyaXRlc2l6ZSA9IGxlMzJfdG9fY3B1KHAtPmJ5dGVfcGVyX3BhZ2UpOwogCW10ZC0+ZXJhc2VzaXplID0gbGUzMl90b19jcHUocC0+cGFnZXNfcGVyX2Jsb2NrKSAqIG10ZC0+d3JpdGVzaXplOwogCW10ZC0+b29ic2l6ZSA9IGxlMTZfdG9fY3B1KHAtPnNwYXJlX2J5dGVzX3Blcl9wYWdlKTsKLQljaGlwLT5jaGlwc2l6ZSA9IGxlMzJfdG9fY3B1KHAtPmJsb2Nrc19wZXJfbHVuKSAqIG10ZC0+ZXJhc2VzaXplOworCWNoaXAtPmNoaXBzaXplID0gKHVpbnQ2NF90KWxlMzJfdG9fY3B1KHAtPmJsb2Nrc19wZXJfbHVuKSAqIG10ZC0+ZXJhc2VzaXplOwogCWJ1c3cgPSAwOwogCWlmIChsZTE2X3RvX2NwdShwLT5mZWF0dXJlcykgJiAxKQogCQlidXN3ID0gTkFORF9CVVNXSURUSF8xNjsKQEAgLTMxNTcsNyArMzE2MSw3IEBACiAJcHJpbnRrKEtFUk5fSU5GTyAiTkFORCBkZXZpY2U6IE1hbnVmYWN0dXJlciBJRDoiCiAJCSIgMHglMDJ4LCBDaGlwIElEOiAweCUwMnggKCVzICVzKVxuIiwgKm1hZl9pZCwgKmRldl9pZCwKIAkJbmFuZF9tYW51Zl9pZHNbbWFmX2lkeF0ubmFtZSwKLQljaGlwLT5vbmZpX3ZlcnNpb24gPyB0eXBlLT5uYW1lIDogY2hpcC0+b25maV9wYXJhbXMubW9kZWwpOworCQljaGlwLT5vbmZpX3ZlcnNpb24gPyBjaGlwLT5vbmZpX3BhcmFtcy5tb2RlbCA6IHR5cGUtPm5hbWUpOwogCiAJcmV0dXJuIHR5cGU7CiB9CkBAIC0zNDM1LDYgKzM0MzksNyBAQAogCW10ZC0+cmVzdW1lID0gbmFuZF9yZXN1bWU7CiAJbXRkLT5ibG9ja19pc2JhZCA9IG5hbmRfYmxvY2tfaXNiYWQ7CiAJbXRkLT5ibG9ja19tYXJrYmFkID0gbmFuZF9ibG9ja19tYXJrYmFkOworCW10ZC0+d3JpdGVidWZzaXplID0gbXRkLT53cml0ZXNpemU7CiAKIAkvKiBwcm9wYWdhdGUgZWNjLmxheW91dCB0byBtdGRfaW5mbyAqLwogCW10ZC0+ZWNjbGF5b3V0ID0gY2hpcC0+ZWNjLmxheW91dDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvbmFuZF9iYnQuYyBiL2RyaXZlcnMvbXRkL25hbmQvbmFuZF9iYnQuYwppbmRleCA1ODZiOTgxLi42ZWJkODY5IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL25hbmRfYmJ0LmMKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9uYW5kX2JidC5jCkBAIC0xMDkyLDcgKzEwOTIsOCBAQAogCiAvKioKICAqIHZlcmlmeV9iYnRfZGVzY3IgLSB2ZXJpZnkgdGhlIGJhZCBibG9jayBkZXNjcmlwdGlvbgotICogQGJkOgkJCXRoZSB0YWJsZSB0byB2ZXJpZnkKKyAqIEBtdGQ6CU1URCBkZXZpY2Ugc3RydWN0dXJlCisgKiBAYmQ6CQl0aGUgdGFibGUgdG8gdmVyaWZ5CiAgKgogICogVGhpcyBmdW5jdGlvbnMgcGVyZm9ybXMgYSBmZXcgc2FuaXR5IGNoZWNrcyBvbiB0aGUgYmFkIGJsb2NrIGRlc2NyaXB0aW9uCiAgKiB0YWJsZS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvbmFuZHNpbS5jIGIvZHJpdmVycy9tdGQvbmFuZC9uYW5kc2ltLmMKaW5kZXggYTZhNzNhYS4uYTVhYTk5ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbmFuZC9uYW5kc2ltLmMKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9uYW5kc2ltLmMKQEAgLTIxMCwxMiArMjEwLDEyIEBACiAjZGVmaW5lIFNUQVRFX0NNRF9SRUFEMCAgICAgICAgMHgwMDAwMDAwMSAvKiByZWFkIGRhdGEgZnJvbSB0aGUgYmVnaW5uaW5nIG9mIHBhZ2UgKi8KICNkZWZpbmUgU1RBVEVfQ01EX1JFQUQxICAgICAgICAweDAwMDAwMDAyIC8qIHJlYWQgZGF0YSBmcm9tIHRoZSBzZWNvbmQgaGFsZiBvZiBwYWdlICovCiAjZGVmaW5lIFNUQVRFX0NNRF9SRUFEU1RBUlQgICAgMHgwMDAwMDAwMyAvKiByZWFkIGRhdGEgc2Vjb25kIGNvbW1hbmQgKGxhcmdlIHBhZ2UgZGV2aWNlcykgKi8KLSNkZWZpbmUgU1RBVEVfQ01EX1BBR0VQUk9HICAgICAweDAwMDAwMDA0IC8qIHN0YXJ0IHBhZ2UgcHJvZ3JhbW0gKi8KKyNkZWZpbmUgU1RBVEVfQ01EX1BBR0VQUk9HICAgICAweDAwMDAwMDA0IC8qIHN0YXJ0IHBhZ2UgcHJvZ3JhbSAqLwogI2RlZmluZSBTVEFURV9DTURfUkVBRE9PQiAgICAgIDB4MDAwMDAwMDUgLyogcmVhZCBPT0IgYXJlYSAqLwogI2RlZmluZSBTVEFURV9DTURfRVJBU0UxICAgICAgIDB4MDAwMDAwMDYgLyogc2VjdG9yIGVyYXNlIGZpcnN0IGNvbW1hbmQgKi8KICNkZWZpbmUgU1RBVEVfQ01EX1NUQVRVUyAgICAgICAweDAwMDAwMDA3IC8qIHJlYWQgc3RhdHVzICovCiAjZGVmaW5lIFNUQVRFX0NNRF9TVEFUVVNfTSAgICAgMHgwMDAwMDAwOCAvKiByZWFkIG11bHRpLXBsYW5lIHN0YXR1cyAoaXNuJ3QgaW1wbGVtZW50ZWQpICovCi0jZGVmaW5lIFNUQVRFX0NNRF9TRVFJTiAgICAgICAgMHgwMDAwMDAwOSAvKiBzZXF1ZW50aWFsIGRhdGEgaW1wdXQgKi8KKyNkZWZpbmUgU1RBVEVfQ01EX1NFUUlOICAgICAgICAweDAwMDAwMDA5IC8qIHNlcXVlbnRpYWwgZGF0YSBpbnB1dCAqLwogI2RlZmluZSBTVEFURV9DTURfUkVBRElEICAgICAgIDB4MDAwMDAwMEEgLyogcmVhZCBJRCAqLwogI2RlZmluZSBTVEFURV9DTURfRVJBU0UyICAgICAgIDB4MDAwMDAwMEIgLyogc2VjdG9yIGVyYXNlIHNlY29uZCBjb21tYW5kICovCiAjZGVmaW5lIFNUQVRFX0NNRF9SRVNFVCAgICAgICAgMHgwMDAwMDAwQyAvKiByZXNldCAqLwpAQCAtMjMwLDcgKzIzMCw3IEBACiAjZGVmaW5lIFNUQVRFX0FERFJfWkVSTyAgICAgICAgMHgwMDAwMDA0MCAvKiBvbmUgYnl0ZSB6ZXJvIGFkZHJlc3Mgd2FzIGFjY2VwdGVkICovCiAjZGVmaW5lIFNUQVRFX0FERFJfTUFTSyAgICAgICAgMHgwMDAwMDA3MCAvKiBhZGRyZXNzIHN0YXRlcyBtYXNrICovCiAKLS8qIER1cmluZCBkYXRhIGlucHV0L291dHB1dCB0aGUgc2ltdWxhdG9yIGlzIGluIHRoZXNlIHN0YXRlcyAqLworLyogRHVyaW5nIGRhdGEgaW5wdXQvb3V0cHV0IHRoZSBzaW11bGF0b3IgaXMgaW4gdGhlc2Ugc3RhdGVzICovCiAjZGVmaW5lIFNUQVRFX0RBVEFJTiAgICAgICAgICAgMHgwMDAwMDEwMCAvKiB3YWl0aW5nIGZvciBkYXRhIGlucHV0ICovCiAjZGVmaW5lIFNUQVRFX0RBVEFJTl9NQVNLICAgICAgMHgwMDAwMDEwMCAvKiBkYXRhIGlucHV0IHN0YXRlcyBtYXNrICovCiAKQEAgLTI0OCw3ICsyNDgsNyBAQAogCiAvKiBTaW11bGF0b3IncyBhY3Rpb25zIGJpdCBtYXNrcyAqLwogI2RlZmluZSBBQ1RJT05fQ1BZICAgICAgIDB4MDAxMDAwMDAgLyogY29weSBwYWdlL09PQiB0byB0aGUgaW50ZXJuYWwgYnVmZmVyICovCi0jZGVmaW5lIEFDVElPTl9QUkdQQUdFICAgMHgwMDIwMDAwMCAvKiBwcm9ncmFtbSB0aGUgaW50ZXJuYWwgYnVmZmVyIHRvIGZsYXNoICovCisjZGVmaW5lIEFDVElPTl9QUkdQQUdFICAgMHgwMDIwMDAwMCAvKiBwcm9ncmFtIHRoZSBpbnRlcm5hbCBidWZmZXIgdG8gZmxhc2ggKi8KICNkZWZpbmUgQUNUSU9OX1NFQ0VSQVNFICAweDAwMzAwMDAwIC8qIGVyYXNlIHNlY3RvciAqLwogI2RlZmluZSBBQ1RJT05fWkVST09GRiAgIDB4MDA0MDAwMDAgLyogZG9uJ3QgYWRkIGFueSBvZmZzZXQgdG8gYWRkcmVzcyAqLwogI2RlZmluZSBBQ1RJT05fSEFMRk9GRiAgIDB4MDA1MDAwMDAgLyogYWRkIHRvIGFkZHJlc3MgaGFsZiBvZiBwYWdlICovCkBAIC0yNjMsMTggKzI2MywxOCBAQAogI2RlZmluZSBPUFRfUEFHRTUxMiAgICAgIDB4MDAwMDAwMDIgLyogNTEyLWJ5dGUgIHBhZ2UgY2hpcHMgKi8KICNkZWZpbmUgT1BUX1BBR0UyMDQ4ICAgICAweDAwMDAwMDA4IC8qIDIwNDgtYnl0ZSBwYWdlIGNoaXBzICovCiAjZGVmaW5lIE9QVF9TTUFSVE1FRElBICAgMHgwMDAwMDAxMCAvKiBTbWFydE1lZGlhIHRlY2hub2xvZ3kgY2hpcHMgKi8KLSNkZWZpbmUgT1BUX0FVVE9JTkNSICAgICAweDAwMDAwMDIwIC8qIHBhZ2UgbnVtYmVyIGF1dG8gaW5jdGltZW50YXRpb24gaXMgcG9zc2libGUgKi8KKyNkZWZpbmUgT1BUX0FVVE9JTkNSICAgICAweDAwMDAwMDIwIC8qIHBhZ2UgbnVtYmVyIGF1dG8gaW5jcmVtZW50YXRpb24gaXMgcG9zc2libGUgKi8KICNkZWZpbmUgT1BUX1BBR0U1MTJfOEJJVCAweDAwMDAwMDQwIC8qIDUxMi1ieXRlIHBhZ2UgY2hpcHMgd2l0aCA4LWJpdCBidXMgd2lkdGggKi8KICNkZWZpbmUgT1BUX1BBR0U0MDk2ICAgICAweDAwMDAwMDgwIC8qIDQwOTYtYnl0ZSBwYWdlIGNoaXBzICovCiAjZGVmaW5lIE9QVF9MQVJHRVBBR0UgICAgKE9QVF9QQUdFMjA0OCB8IE9QVF9QQUdFNDA5NikgLyogMjA0OCAmIDQwOTYtYnl0ZSBwYWdlIGNoaXBzICovCiAjZGVmaW5lIE9QVF9TTUFMTFBBR0UgICAgKE9QVF9QQUdFMjU2ICB8IE9QVF9QQUdFNTEyKSAgLyogMjU2IGFuZCA1MTItYnl0ZSBwYWdlIGNoaXBzICovCiAKLS8qIFJlbW92ZSBhY3Rpb24gYml0cyBmdG9tIHN0YXRlICovCisvKiBSZW1vdmUgYWN0aW9uIGJpdHMgZnJvbSBzdGF0ZSAqLwogI2RlZmluZSBOU19TVEFURSh4KSAoKHgpICYgfkFDVElPTl9NQVNLKQogCiAvKgogICogTWF4aW11bSBwcmV2aW91cyBzdGF0ZXMgd2hpY2ggbmVlZCB0byBiZSBzYXZlZC4gQ3VycmVudGx5IHNhdmluZyBpcwotICogb25seSBuZWVkZWQgZm9yIHBhZ2UgcHJvZ3JhbW0gb3BlcmF0aW9uIHdpdGggcHJlY2VlZGVkIHJlYWQgY29tbWFuZAorICogb25seSBuZWVkZWQgZm9yIHBhZ2UgcHJvZ3JhbSBvcGVyYXRpb24gd2l0aCBwcmVjZWRlZCByZWFkIGNvbW1hbmQKICAqICh3aGljaCBpcyBvbmx5IHZhbGlkIGZvciA1MTItYnl0ZSBwYWdlcykuCiAgKi8KICNkZWZpbmUgTlNfTUFYX1BSRVZTVEFURVMgMQpAQCAtMzgwLDE2ICszODAsMTYgQEAKIAkvKiBSZWFkIE9PQiAqLwogCXtPUFRfU01BTExQQUdFLCB7U1RBVEVfQ01EX1JFQURPT0IgfCBBQ1RJT05fT09CT0ZGLCBTVEFURV9BRERSX1BBR0UgfCBBQ1RJT05fQ1BZLAogCQkJU1RBVEVfREFUQU9VVCwgU1RBVEVfUkVBRFl9fSwKLQkvKiBQcm9ncmFtbSBwYWdlIHN0YXJ0aW5nIGZyb20gdGhlIGJlZ2lubmluZyAqLworCS8qIFByb2dyYW0gcGFnZSBzdGFydGluZyBmcm9tIHRoZSBiZWdpbm5pbmcgKi8KIAl7T1BUX0FOWSwge1NUQVRFX0NNRF9TRVFJTiwgU1RBVEVfQUREUl9QQUdFLCBTVEFURV9EQVRBSU4sCiAJCQlTVEFURV9DTURfUEFHRVBST0cgfCBBQ1RJT05fUFJHUEFHRSwgU1RBVEVfUkVBRFl9fSwKLQkvKiBQcm9ncmFtbSBwYWdlIHN0YXJ0aW5nIGZyb20gdGhlIGJlZ2lubmluZyAqLworCS8qIFByb2dyYW0gcGFnZSBzdGFydGluZyBmcm9tIHRoZSBiZWdpbm5pbmcgKi8KIAl7T1BUX1NNQUxMUEFHRSwge1NUQVRFX0NNRF9SRUFEMCwgU1RBVEVfQ01EX1NFUUlOIHwgQUNUSU9OX1pFUk9PRkYsIFNUQVRFX0FERFJfUEFHRSwKIAkJCSAgICAgIFNUQVRFX0RBVEFJTiwgU1RBVEVfQ01EX1BBR0VQUk9HIHwgQUNUSU9OX1BSR1BBR0UsIFNUQVRFX1JFQURZfX0sCi0JLyogUHJvZ3JhbW0gcGFnZSBzdGFydGluZyBmcm9tIHRoZSBzZWNvbmQgaGFsZiAqLworCS8qIFByb2dyYW0gcGFnZSBzdGFydGluZyBmcm9tIHRoZSBzZWNvbmQgaGFsZiAqLwogCXtPUFRfUEFHRTUxMiwge1NUQVRFX0NNRF9SRUFEMSwgU1RBVEVfQ01EX1NFUUlOIHwgQUNUSU9OX0hBTEZPRkYsIFNUQVRFX0FERFJfUEFHRSwKIAkJCSAgICAgIFNUQVRFX0RBVEFJTiwgU1RBVEVfQ01EX1BBR0VQUk9HIHwgQUNUSU9OX1BSR1BBR0UsIFNUQVRFX1JFQURZfX0sCi0JLyogUHJvZ3JhbW0gT09CICovCisJLyogUHJvZ3JhbSBPT0IgKi8KIAl7T1BUX1NNQUxMUEFHRSwge1NUQVRFX0NNRF9SRUFET09CLCBTVEFURV9DTURfU0VRSU4gfCBBQ1RJT05fT09CT0ZGLCBTVEFURV9BRERSX1BBR0UsCiAJCQkgICAgICBTVEFURV9EQVRBSU4sIFNUQVRFX0NNRF9QQUdFUFJPRyB8IEFDVElPTl9QUkdQQUdFLCBTVEFURV9SRUFEWX19LAogCS8qIEVyYXNlIHNlY3RvciAqLwpAQCAtNDcwLDcgKzQ3MCw3IEBACiAJCQllcnIgPSAtRUlOVkFMOwogCQkJZ290byBlcnJfY2xvc2U7CiAJCX0KLQkJbnMtPnBhZ2VzX3dyaXR0ZW4gPSB2bWFsbG9jKG5zLT5nZW9tLnBnbnVtKTsKKwkJbnMtPnBhZ2VzX3dyaXR0ZW4gPSB2emFsbG9jKG5zLT5nZW9tLnBnbnVtKTsKIAkJaWYgKCFucy0+cGFnZXNfd3JpdHRlbikgewogCQkJTlNfRVJSKCJhbGxvY19kZXZpY2U6IHVuYWJsZSB0byBhbGxvY2F0ZSBwYWdlcyB3cml0dGVuIGFycmF5XG4iKTsKIAkJCWVyciA9IC1FTk9NRU07CkBAIC00ODMsNyArNDgzLDYgQEAKIAkJCWdvdG8gZXJyX2ZyZWU7CiAJCX0KIAkJbnMtPmNmaWxlID0gY2ZpbGU7Ci0JCW1lbXNldChucy0+cGFnZXNfd3JpdHRlbiwgMCwgbnMtPmdlb20ucGdudW0pOwogCQlyZXR1cm4gMDsKIAl9CiAKQEAgLTExNzEsOSArMTE3MCw5IEBACiAgKiBvZiBzdXBwb3J0ZWQgb3BlcmF0aW9ucy4KICAqCiAgKiBPcGVyYXRpb24gY2FuIGJlIHVua25vd24gYmVjYXVzZSBvZiB0aGUgZm9sbG93aW5nLgotICogICAxLiBOZXcgY29tbWFuZCB3YXMgYWNjZXB0ZWQgYW5kIHRoaXMgaXMgdGhlIGZpcnMgY2FsbCB0byBmaW5kIHRoZQorICogICAxLiBOZXcgY29tbWFuZCB3YXMgYWNjZXB0ZWQgYW5kIHRoaXMgaXMgdGhlIGZpcnN0IGNhbGwgdG8gZmluZCB0aGUKICAqICAgICAgY29ycmVzcG9uZGVudCBzdGF0ZXMgY2hhaW4uIEluIHRoaXMgY2FzZSBucy0+bnBzdGF0ZXMgPSAwOwotICogICAyLiBUaGVyZSBpcyBzZXZlcmFsIG9wZXJhdGlvbnMgd2hpY2ggYmVnaW4gd2l0aCB0aGUgc2FtZSBjb21tYW5kKHMpCisgKiAgIDIuIFRoZXJlIGFyZSBzZXZlcmFsIG9wZXJhdGlvbnMgd2hpY2ggYmVnaW4gd2l0aCB0aGUgc2FtZSBjb21tYW5kKHMpCiAgKiAgICAgIChmb3IgZXhhbXBsZSBwcm9ncmFtIGZyb20gdGhlIHNlY29uZCBoYWxmIGFuZCByZWFkIGZyb20gdGhlCiAgKiAgICAgIHNlY29uZCBoYWxmIG9wZXJhdGlvbnMgYm90aCBiZWdpbiB3aXRoIHRoZSBSRUFEMSBjb21tYW5kKS4gSW4gdGhpcwogICogICAgICBjYXNlIHRoZSBucy0+cHN0YXRlc1tdIGFycmF5IGNvbnRhaW5zIHByZXZpb3VzIHN0YXRlcy4KQEAgLTExODYsNyArMTE4NSw3IEBACiAgKiBucy0+b3BzLCBucy0+c3RhdGUsIG5zLT5ueHN0YXRlIGFyZSBpbml0aWFsaXplZCwgbnMtPm5wc3RhdGUgaXMKICAqIHplcm9lZCkuCiAgKgotICogSWYgdGhlcmUgYXJlIHNldmVyYWwgbWFjaGVzLCB0aGUgY3VycmVudCBzdGF0ZSBpcyBwdXNoZWQgdG8gdGhlCisgKiBJZiB0aGVyZSBhcmUgc2V2ZXJhbCBtYXRjaGVzLCB0aGUgY3VycmVudCBzdGF0ZSBpcyBwdXNoZWQgdG8gdGhlCiAgKiBucy0+cHN0YXRlcy4KICAqCiAgKiBUaGUgb3BlcmF0aW9uIGNhbiBiZSB1bmtub3duIG9ubHkgd2hpbGUgY29tbWFuZHMgYXJlIGlucHV0IHRvIHRoZSBjaGlwLgpAQCAtMTE5NSwxMCArMTE5NCwxMCBAQAogICogb3BlcmF0aW9uIGlzIHNlYXJjaGVkIHVzaW5nIHRoZSBmb2xsb3dpbmcgcGF0dGVybjoKICAqICAgICBucy0+cHN0YXRlc1swXSwgLi4uIG5zLT5wc3RhdGVzW25zLT5ucHN0YXRlc10sIDxhZGRyZXNzIGlucHV0PgogICoKLSAqIEl0IGlzIHN1cHBvc2VkIHRoYXQgdGhpcyBwYXR0ZXJuIG11c3QgZWl0aGVyIG1hdGNoIG9uZSBvcGVyYXRpb24gb24KKyAqIEl0IGlzIHN1cHBvc2VkIHRoYXQgdGhpcyBwYXR0ZXJuIG11c3QgZWl0aGVyIG1hdGNoIG9uZSBvcGVyYXRpb24gb3IKICAqIG5vbmUuIFRoZXJlIGNhbid0IGJlIGFtYmlndWl0eSBpbiB0aGF0IGNhc2UuCiAgKgotICogSWYgbm8gbWF0Y2hlcyBmb3VuZCwgdGhlIGZ1bmN0aW9ucyBkb2VzIHRoZSBmb2xsb3dpbmc6CisgKiBJZiBubyBtYXRjaGVzIGZvdW5kLCB0aGUgZnVuY3Rpb24gZG9lcyB0aGUgZm9sbG93aW5nOgogICogICAxLiBpZiB0aGVyZSBhcmUgc2F2ZWQgc3RhdGVzIHByZXNlbnQsIHRyeSB0byBpZ25vcmUgdGhlbSBhbmQgc2VhcmNoCiAgKiAgICAgIGFnYWluIG9ubHkgdXNpbmcgdGhlIGxhc3QgY29tbWFuZC4gSWYgbm90aGluZyB3YXMgZm91bmQsIHN3aXRjaAogICogICAgICB0byB0aGUgU1RBVEVfUkVBRFkgc3RhdGUuCkBAIC0xNjY4LDcgKzE2NjcsNyBAQAogCiAJY2FzZSBBQ1RJT05fUFJHUEFHRToKIAkJLyoKLQkJICogUHJvZ3JhbW0gcGFnZSAtIG1vdmUgaW50ZXJuYWwgYnVmZmVyIGRhdGEgdG8gdGhlIHBhZ2UuCisJCSAqIFByb2dyYW0gcGFnZSAtIG1vdmUgaW50ZXJuYWwgYnVmZmVyIGRhdGEgdG8gdGhlIHBhZ2UuCiAJCSAqLwogCiAJCWlmIChucy0+bGluZXMud3ApIHsKQEAgLTE5MzMsNyArMTkzMiw3IEBACiAJCU5TX0RCRygicmVhZF9ieXRlOiBhbGwgYnl0ZXMgd2VyZSByZWFkXG4iKTsKIAogCQkvKgotCQkgKiBUaGUgT1BUX0FVVE9JTkNSIGFsbG93cyB0byByZWFkIG5leHQgY29uc2VxaXRpdmUgcGFnZXMgd2l0aG91dAorCQkgKiBUaGUgT1BUX0FVVE9JTkNSIGFsbG93cyB0byByZWFkIG5leHQgY29uc2VjdXRpdmUgcGFnZXMgd2l0aG91dAogCQkgKiBuZXcgcmVhZCBvcGVyYXRpb24gY3ljbGUuCiAJCSAqLwogCQlpZiAoKG5zLT5vcHRpb25zICYgT1BUX0FVVE9JTkNSKSAmJiBOU19TVEFURShucy0+c3RhdGUpID09IFNUQVRFX0RBVEFPVVQpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvcGFzZW1pX25hbmQuYyBiL2RyaXZlcnMvbXRkL25hbmQvcGFzZW1pX25hbmQuYwppbmRleCA2ZGRiMjQ2Li5iYjI3N2E1IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL3Bhc2VtaV9uYW5kLmMKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9wYXNlbWlfbmFuZC5jCkBAIC0xMDcsNyArMTA3LDcgQEAKIAlpZiAocGFzZW1pX25hbmRfbXRkKQogCQlyZXR1cm4gLUVOT0RFVjsKIAotCXByX2RlYnVnKCJwYXNlbWlfbmFuZCBhdCAlbGx4LSVsbHhcbiIsIHJlcy5zdGFydCwgcmVzLmVuZCk7CisJcHJfZGVidWcoInBhc2VtaV9uYW5kIGF0ICVwUlxuIiwgJnJlcyk7CiAKIAkvKiBBbGxvY2F0ZSBtZW1vcnkgZm9yIE1URCBkZXZpY2Ugc3RydWN0dXJlIGFuZCBwcml2YXRlIGRhdGEgKi8KIAlwYXNlbWlfbmFuZF9tdGQgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgbXRkX2luZm8pICsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvcHhhM3h4X25hbmQuYyBiL2RyaXZlcnMvbXRkL25hbmQvcHhhM3h4X25hbmQuYwppbmRleCAxN2Y4NTE4Li5lYTJjMjg4IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL3B4YTN4eF9uYW5kLmMKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9weGEzeHhfbmFuZC5jCkBAIC04ODUsNiArODg1LDcgQEAKIAkvKiBzZXQgaW5mbyBmaWVsZHMgbmVlZGVkIHRvIF9fcmVhZGlkICovCiAJaW5mby0+cmVhZF9pZF9ieXRlcyA9IChpbmZvLT5wYWdlX3NpemUgPT0gMjA0OCkgPyA0IDogMjsKIAlpbmZvLT5yZWdfbmRjciA9IG5kY3I7CisJaW5mby0+Y21kc2V0ID0gJmRlZmF1bHRfY21kc2V0OwogCiAJaWYgKF9fcmVhZGlkKGluZm8sICZpZCkpCiAJCXJldHVybiAtRU5PREVWOwpAQCAtOTE1LDcgKzkxNiw2IEBACiAKIAlpbmZvLT5uZHRyMGNzMCA9IG5hbmRfcmVhZGwoaW5mbywgTkRUUjBDUzApOwogCWluZm8tPm5kdHIxY3MwID0gbmFuZF9yZWFkbChpbmZvLCBORFRSMUNTMCk7Ci0JaW5mby0+Y21kc2V0ID0gJmRlZmF1bHRfY21kc2V0OwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9uYW5kL3R4eDluZGZtYy5jIGIvZHJpdmVycy9tdGQvbmFuZC90eHg5bmRmbWMuYwppbmRleCAwNTRhNDFjLi5jYTI3MGE0IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL3R4eDluZGZtYy5jCisrKyBiL2RyaXZlcnMvbXRkL25hbmQvdHh4OW5kZm1jLmMKQEAgLTI3Nyw4ICsyNzcsOSBAQAogCXJldCA9IG5hbmRfc2Nhbl9pZGVudChtdGQsIDEsIE5VTEwpOwogCWlmICghcmV0KSB7CiAJCWlmIChtdGQtPndyaXRlc2l6ZSA+PSA1MTIpIHsKLQkJCWNoaXAtPmVjYy5zaXplID0gbXRkLT53cml0ZXNpemU7Ci0JCQljaGlwLT5lY2MuYnl0ZXMgPSAzICogKG10ZC0+d3JpdGVzaXplIC8gMjU2KTsKKwkJCS8qIEhhcmR3YXJlIEVDQyA2IGJ5dGUgRUNDIHBlciA1MTIgQnl0ZSBkYXRhICovCisJCQljaGlwLT5lY2Muc2l6ZSA9IDUxMjsKKwkJCWNoaXAtPmVjYy5ieXRlcyA9IDY7CiAJCX0KIAkJcmV0ID0gbmFuZF9zY2FuX3RhaWwobXRkKTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9vbmVuYW5kL29tYXAyLmMgYi9kcml2ZXJzL210ZC9vbmVuYW5kL29tYXAyLmMKaW5kZXggZDA4OTRjYTcuLmFjMzFmNDYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL29uZW5hbmQvb21hcDIuYworKysgYi9kcml2ZXJzL210ZC9vbmVuYW5kL29tYXAyLmMKQEAgLTM1LDYgKzM1LDcgQEAKICNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgogI2luY2x1ZGUgPGxpbnV4L2lvLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L3JlZ3VsYXRvci9jb25zdW1lci5oPgogCiAjaW5jbHVkZSA8YXNtL21hY2gvZmxhc2guaD4KICNpbmNsdWRlIDxwbGF0L2dwbWMuaD4KQEAgLTYzLDggKzY0LDEzIEBACiAJaW50IGRtYV9jaGFubmVsOwogCWludCBmcmVxOwogCWludCAoKnNldHVwKSh2b2lkIF9faW9tZW0gKmJhc2UsIGludCBmcmVxKTsKKwlzdHJ1Y3QgcmVndWxhdG9yICpyZWd1bGF0b3I7CiB9OwogCisjaWZkZWYgQ09ORklHX01URF9QQVJUSVRJT05TCitzdGF0aWMgY29uc3QgY2hhciAqcGFydF9wcm9iZXNbXSA9IHsgImNtZGxpbmVwYXJ0IiwgTlVMTCwgIH07CisjZW5kaWYKKwogc3RhdGljIHZvaWQgb21hcDJfb25lbmFuZF9kbWFfY2IoaW50IGxjaCwgdTE2IGNoX3N0YXR1cywgdm9pZCAqZGF0YSkKIHsKIAlzdHJ1Y3Qgb21hcDJfb25lbmFuZCAqYyA9IGRhdGE7CkBAIC0xMDgsOCArMTE0LDkgQEAKIHN0YXRpYyBpbnQgb21hcDJfb25lbmFuZF93YWl0KHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBpbnQgc3RhdGUpCiB7CiAJc3RydWN0IG9tYXAyX29uZW5hbmQgKmMgPSBjb250YWluZXJfb2YobXRkLCBzdHJ1Y3Qgb21hcDJfb25lbmFuZCwgbXRkKTsKKwlzdHJ1Y3Qgb25lbmFuZF9jaGlwICp0aGlzID0gbXRkLT5wcml2OwogCXVuc2lnbmVkIGludCBpbnRyID0gMDsKLQl1bnNpZ25lZCBpbnQgY3RybDsKKwl1bnNpZ25lZCBpbnQgY3RybCwgY3RybF9tYXNrOwogCXVuc2lnbmVkIGxvbmcgdGltZW91dDsKIAl1MzIgc3lzY2ZnOwogCkBAIC0xODAsNyArMTg3LDggQEAKIAkJCWlmIChyZXN1bHQgPT0gMCkgewogCQkJCS8qIFRpbWVvdXQgYWZ0ZXIgMjBtcyAqLwogCQkJCWN0cmwgPSByZWFkX3JlZyhjLCBPTkVOQU5EX1JFR19DVFJMX1NUQVRVUyk7Ci0JCQkJaWYgKGN0cmwgJiBPTkVOQU5EX0NUUkxfT05HTykgeworCQkJCWlmIChjdHJsICYgT05FTkFORF9DVFJMX09OR08gJiYKKwkJCQkgICAgIXRoaXMtPm9uZ29pbmcpIHsKIAkJCQkJLyoKIAkJCQkJICogVGhlIG9wZXJhdGlvbiBzZWVtcyB0byBiZSBzdGlsbCBnb2luZwogCQkJCQkgKiBzbyBnaXZlIGl0IHNvbWUgbW9yZSB0aW1lLgpAQCAtMjY5LDcgKzI3NywxMSBAQAogCQlyZXR1cm4gLUVJTzsKIAl9CiAKLQlpZiAoY3RybCAmIDB4RkU5RikKKwljdHJsX21hc2sgPSAweEZFOUY7CisJaWYgKHRoaXMtPm9uZ29pbmcpCisJCWN0cmxfbWFzayAmPSB+MHg4MDAwOworCisJaWYgKGN0cmwgJiBjdHJsX21hc2spCiAJCXdhaXRfd2FybigidW5leHBlY3RlZCBjb250cm9sbGVyIHN0YXR1cyIsIHN0YXRlLCBjdHJsLCBpbnRyKTsKIAogCXJldHVybiAwOwpAQCAtNTkxLDYgKzYwMywzMCBAQAogCW1lbXNldCgoX19mb3JjZSB2b2lkICopYy0+b25lbmFuZC5iYXNlLCAwLCBPTkVOQU5EX0JVRlJBTV9TSVpFKTsKIH0KIAorc3RhdGljIGludCBvbWFwMl9vbmVuYW5kX2VuYWJsZShzdHJ1Y3QgbXRkX2luZm8gKm10ZCkKK3sKKwlpbnQgcmV0OworCXN0cnVjdCBvbWFwMl9vbmVuYW5kICpjID0gY29udGFpbmVyX29mKG10ZCwgc3RydWN0IG9tYXAyX29uZW5hbmQsIG10ZCk7CisKKwlyZXQgPSByZWd1bGF0b3JfZW5hYmxlKGMtPnJlZ3VsYXRvcik7CisJaWYgKHJldCAhPSAwKQorCQlkZXZfZXJyKCZjLT5wZGV2LT5kZXYsICJjYW50IGVuYWJsZSByZWd1bGF0b3JcbiIpOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBvbWFwMl9vbmVuYW5kX2Rpc2FibGUoc3RydWN0IG10ZF9pbmZvICptdGQpCit7CisJaW50IHJldDsKKwlzdHJ1Y3Qgb21hcDJfb25lbmFuZCAqYyA9IGNvbnRhaW5lcl9vZihtdGQsIHN0cnVjdCBvbWFwMl9vbmVuYW5kLCBtdGQpOworCisJcmV0ID0gcmVndWxhdG9yX2Rpc2FibGUoYy0+cmVndWxhdG9yKTsKKwlpZiAocmV0ICE9IDApCisJCWRldl9lcnIoJmMtPnBkZXYtPmRldiwgImNhbnQgZGlzYWJsZSByZWd1bGF0b3JcbiIpOworCisJcmV0dXJuIHJldDsKK30KKwogc3RhdGljIGludCBfX2RldmluaXQgb21hcDJfb25lbmFuZF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogewogCXN0cnVjdCBvbWFwX29uZW5hbmRfcGxhdGZvcm1fZGF0YSAqcGRhdGE7CkBAIC03MDUsOCArNzQxLDE4IEBACiAJCX0KIAl9CiAKKwlpZiAocGRhdGEtPnJlZ3VsYXRvcl9jYW5fc2xlZXApIHsKKwkJYy0+cmVndWxhdG9yID0gcmVndWxhdG9yX2dldCgmcGRldi0+ZGV2LCAidm9uZW5hbmQiKTsKKwkJaWYgKElTX0VSUihjLT5yZWd1bGF0b3IpKSB7CisJCQlkZXZfZXJyKCZwZGV2LT5kZXYsICAiRmFpbGVkIHRvIGdldCByZWd1bGF0b3JcbiIpOworCQkJZ290byBlcnJfcmVsZWFzZV9kbWE7CisJCX0KKwkJYy0+b25lbmFuZC5lbmFibGUgPSBvbWFwMl9vbmVuYW5kX2VuYWJsZTsKKwkJYy0+b25lbmFuZC5kaXNhYmxlID0gb21hcDJfb25lbmFuZF9kaXNhYmxlOworCX0KKwogCWlmICgociA9IG9uZW5hbmRfc2NhbigmYy0+bXRkLCAxKSkgPCAwKQotCQlnb3RvIGVycl9yZWxlYXNlX2RtYTsKKwkJZ290byBlcnJfcmVsZWFzZV9yZWd1bGF0b3I7CiAKIAlzd2l0Y2ggKChjLT5vbmVuYW5kLnZlcnNpb25faWQgPj4gNCkgJiAweGYpIHsKIAljYXNlIDA6CkBAIC03MjcsMTMgKzc3MywxNSBAQAogCX0KIAogI2lmZGVmIENPTkZJR19NVERfUEFSVElUSU9OUwotCWlmIChwZGF0YS0+cGFydHMgIT0gTlVMTCkKLQkJciA9IGFkZF9tdGRfcGFydGl0aW9ucygmYy0+bXRkLCBwZGF0YS0+cGFydHMsCi0JCQkJICAgICAgIHBkYXRhLT5ucl9wYXJ0cyk7CisJciA9IHBhcnNlX210ZF9wYXJ0aXRpb25zKCZjLT5tdGQsIHBhcnRfcHJvYmVzLCAmYy0+cGFydHMsIDApOworCWlmIChyID4gMCkKKwkJciA9IGFkZF9tdGRfcGFydGl0aW9ucygmYy0+bXRkLCBjLT5wYXJ0cywgcik7CisJZWxzZSBpZiAocGRhdGEtPnBhcnRzICE9IE5VTEwpCisJCXIgPSBhZGRfbXRkX3BhcnRpdGlvbnMoJmMtPm10ZCwgcGRhdGEtPnBhcnRzLCBwZGF0YS0+bnJfcGFydHMpOwogCWVsc2UKICNlbmRpZgogCQlyID0gYWRkX210ZF9kZXZpY2UoJmMtPm10ZCk7Ci0JaWYgKHIgPCAwKQorCWlmIChyKQogCQlnb3RvIGVycl9yZWxlYXNlX29uZW5hbmQ7CiAKIAlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBjKTsKQEAgLTc0Miw2ICs3OTAsOCBAQAogCiBlcnJfcmVsZWFzZV9vbmVuYW5kOgogCW9uZW5hbmRfcmVsZWFzZSgmYy0+bXRkKTsKK2Vycl9yZWxlYXNlX3JlZ3VsYXRvcjoKKwlyZWd1bGF0b3JfcHV0KGMtPnJlZ3VsYXRvcik7CiBlcnJfcmVsZWFzZV9kbWE6CiAJaWYgKGMtPmRtYV9jaGFubmVsICE9IC0xKQogCQlvbWFwX2ZyZWVfZG1hKGMtPmRtYV9jaGFubmVsKTsKQEAgLTc1Nyw2ICs4MDcsNyBAQAogZXJyX2ZyZWVfY3M6CiAJZ3BtY19jc19mcmVlKGMtPmdwbWNfY3MpOwogZXJyX2tmcmVlOgorCWtmcmVlKGMtPnBhcnRzKTsKIAlrZnJlZShjKTsKIAogCXJldHVybiByOwpAQCAtNzY2LDE4ICs4MTcsOCBAQAogewogCXN0cnVjdCBvbWFwMl9vbmVuYW5kICpjID0gZGV2X2dldF9kcnZkYXRhKCZwZGV2LT5kZXYpOwogCi0JQlVHX09OKGMgPT0gTlVMTCk7Ci0KLSNpZmRlZiBDT05GSUdfTVREX1BBUlRJVElPTlMKLQlpZiAoYy0+cGFydHMpCi0JCWRlbF9tdGRfcGFydGl0aW9ucygmYy0+bXRkKTsKLQllbHNlCi0JCWRlbF9tdGRfZGV2aWNlKCZjLT5tdGQpOwotI2Vsc2UKLQlkZWxfbXRkX2RldmljZSgmYy0+bXRkKTsKLSNlbmRpZgotCiAJb25lbmFuZF9yZWxlYXNlKCZjLT5tdGQpOworCXJlZ3VsYXRvcl9wdXQoYy0+cmVndWxhdG9yKTsKIAlpZiAoYy0+ZG1hX2NoYW5uZWwgIT0gLTEpCiAJCW9tYXBfZnJlZV9kbWEoYy0+ZG1hX2NoYW5uZWwpOwogCW9tYXAyX29uZW5hbmRfc2h1dGRvd24ocGRldik7CkBAIC03ODksNiArODMwLDcgQEAKIAlpb3VubWFwKGMtPm9uZW5hbmQuYmFzZSk7CiAJcmVsZWFzZV9tZW1fcmVnaW9uKGMtPnBoeXNfYmFzZSwgT05FTkFORF9JT19TSVpFKTsKIAlncG1jX2NzX2ZyZWUoYy0+Z3BtY19jcyk7CisJa2ZyZWUoYy0+cGFydHMpOwogCWtmcmVlKGMpOwogCiAJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9vbmVuYW5kL29uZW5hbmRfYmFzZS5jIGIvZHJpdmVycy9tdGQvb25lbmFuZC9vbmVuYW5kX2Jhc2UuYwppbmRleCA2YjNhODc1Li5iYWM0MWNhIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9vbmVuYW5kL29uZW5hbmRfYmFzZS5jCisrKyBiL2RyaXZlcnMvbXRkL29uZW5hbmQvb25lbmFuZF9iYXNlLmMKQEAgLTQwMCw4ICs0MDAsNyBAQAogCQl2YWx1ZSA9IG9uZW5hbmRfYnVmZmVycmFtX2FkZHJlc3ModGhpcywgYmxvY2spOwogCQl0aGlzLT53cml0ZV93b3JkKHZhbHVlLCB0aGlzLT5iYXNlICsgT05FTkFORF9SRUdfU1RBUlRfQUREUkVTUzIpOwogCi0JCWlmIChPTkVOQU5EX0lTX01MQyh0aGlzKSB8fCBPTkVOQU5EX0lTXzJQTEFORSh0aGlzKSB8fAotCQkgICAgT05FTkFORF9JU180S0JfUEFHRSh0aGlzKSkKKwkJaWYgKE9ORU5BTkRfSVNfMlBMQU5FKHRoaXMpIHx8IE9ORU5BTkRfSVNfNEtCX1BBR0UodGhpcykpCiAJCQkvKiBJdCBpcyBhbHdheXMgQnVmZmVyUkFNMCAqLwogCQkJT05FTkFORF9TRVRfQlVGRkVSUkFNMCh0aGlzKTsKIAkJZWxzZQpAQCAtNDMwLDcgKzQyOSw3IEBACiAJCWNhc2UgRkxFWE9ORU5BTkRfQ01EX1JFQ09WRVJfTFNCOgogCQljYXNlIE9ORU5BTkRfQ01EX1JFQUQ6CiAJCWNhc2UgT05FTkFORF9DTURfUkVBRE9PQjoKLQkJCWlmIChPTkVOQU5EX0lTX01MQyh0aGlzKSB8fCBPTkVOQU5EX0lTXzRLQl9QQUdFKHRoaXMpKQorCQkJaWYgKE9ORU5BTkRfSVNfNEtCX1BBR0UodGhpcykpCiAJCQkJLyogSXQgaXMgYWx3YXlzIEJ1ZmZlclJBTTAgKi8KIAkJCQlkYXRhcmFtID0gT05FTkFORF9TRVRfQlVGRkVSUkFNMCh0aGlzKTsKIAkJCWVsc2UKQEAgLTk0OSw2ICs5NDgsOCBAQAogCQlpZiAodGhpcy0+c3RhdGUgPT0gRkxfUkVBRFkpIHsKIAkJCXRoaXMtPnN0YXRlID0gbmV3X3N0YXRlOwogCQkJc3Bpbl91bmxvY2soJnRoaXMtPmNoaXBfbG9jayk7CisJCQlpZiAobmV3X3N0YXRlICE9IEZMX1BNX1NVU1BFTkRFRCAmJiB0aGlzLT5lbmFibGUpCisJCQkJdGhpcy0+ZW5hYmxlKG10ZCk7CiAJCQlicmVhazsKIAkJfQogCQlpZiAobmV3X3N0YXRlID09IEZMX1BNX1NVU1BFTkRFRCkgewpAQCAtOTc1LDYgKzk3Niw4IEBACiB7CiAJc3RydWN0IG9uZW5hbmRfY2hpcCAqdGhpcyA9IG10ZC0+cHJpdjsKIAorCWlmICh0aGlzLT5zdGF0ZSAhPSBGTF9QTV9TVVNQRU5ERUQgJiYgdGhpcy0+ZGlzYWJsZSkKKwkJdGhpcy0+ZGlzYWJsZShtdGQpOwogCS8qIFJlbGVhc2UgdGhlIGNoaXAgKi8KIAlzcGluX2xvY2soJnRoaXMtPmNoaXBfbG9jayk7CiAJdGhpcy0+c3RhdGUgPSBGTF9SRUFEWTsKQEAgLTEzNTMsNyArMTM1Niw3IEBACiAKIAlzdGF0cyA9IG10ZC0+ZWNjX3N0YXRzOwogCi0JcmVhZGNtZCA9IE9ORU5BTkRfSVNfTUxDKHRoaXMpID8gT05FTkFORF9DTURfUkVBRCA6IE9ORU5BTkRfQ01EX1JFQURPT0I7CisJcmVhZGNtZCA9IE9ORU5BTkRfSVNfNEtCX1BBR0UodGhpcykgPyBPTkVOQU5EX0NNRF9SRUFEIDogT05FTkFORF9DTURfUkVBRE9PQjsKIAogCXdoaWxlIChyZWFkIDwgbGVuKSB7CiAJCWNvbmRfcmVzY2hlZCgpOwpAQCAtMTQyOSw3ICsxNDMyLDcgQEAKIAlpbnQgcmV0OwogCiAJb25lbmFuZF9nZXRfZGV2aWNlKG10ZCwgRkxfUkVBRElORyk7Ci0JcmV0ID0gT05FTkFORF9JU19NTEModGhpcykgfHwgT05FTkFORF9JU180S0JfUEFHRSh0aGlzKSA/CisJcmV0ID0gT05FTkFORF9JU180S0JfUEFHRSh0aGlzKSA/CiAJCW9uZW5hbmRfbWxjX3JlYWRfb3BzX25vbG9jayhtdGQsIGZyb20sICZvcHMpIDoKIAkJb25lbmFuZF9yZWFkX29wc19ub2xvY2sobXRkLCBmcm9tLCAmb3BzKTsKIAlvbmVuYW5kX3JlbGVhc2VfZGV2aWNlKG10ZCk7CkBAIC0xNDY0LDcgKzE0NjcsNyBAQAogCiAJb25lbmFuZF9nZXRfZGV2aWNlKG10ZCwgRkxfUkVBRElORyk7CiAJaWYgKG9wcy0+ZGF0YnVmKQotCQlyZXQgPSBPTkVOQU5EX0lTX01MQyh0aGlzKSB8fCBPTkVOQU5EX0lTXzRLQl9QQUdFKHRoaXMpID8KKwkJcmV0ID0gT05FTkFORF9JU180S0JfUEFHRSh0aGlzKSA/CiAJCQlvbmVuYW5kX21sY19yZWFkX29wc19ub2xvY2sobXRkLCBmcm9tLCBvcHMpIDoKIAkJCW9uZW5hbmRfcmVhZF9vcHNfbm9sb2NrKG10ZCwgZnJvbSwgb3BzKTsKIAllbHNlCkBAIC0xNDg1LDggKzE0ODgsNyBAQAogewogCXN0cnVjdCBvbmVuYW5kX2NoaXAgKnRoaXMgPSBtdGQtPnByaXY7CiAJdW5zaWduZWQgbG9uZyB0aW1lb3V0OwotCXVuc2lnbmVkIGludCBpbnRlcnJ1cHQ7Ci0JdW5zaWduZWQgaW50IGN0cmw7CisJdW5zaWduZWQgaW50IGludGVycnVwdCwgY3RybCwgZWNjLCBhZGRyMSwgYWRkcjg7CiAKIAkvKiBUaGUgMjAgbXNlYyBpcyBlbm91Z2ggKi8KIAl0aW1lb3V0ID0gamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoMjApOwpAQCAtMTQ5OCwyNSArMTUwMCwyOCBAQAogCS8qIFRvIGdldCBjb3JyZWN0IGludGVycnVwdCBzdGF0dXMgaW4gdGltZW91dCBjYXNlICovCiAJaW50ZXJydXB0ID0gdGhpcy0+cmVhZF93b3JkKHRoaXMtPmJhc2UgKyBPTkVOQU5EX1JFR19JTlRFUlJVUFQpOwogCWN0cmwgPSB0aGlzLT5yZWFkX3dvcmQodGhpcy0+YmFzZSArIE9ORU5BTkRfUkVHX0NUUkxfU1RBVFVTKTsKKwlhZGRyMSA9IHRoaXMtPnJlYWRfd29yZCh0aGlzLT5iYXNlICsgT05FTkFORF9SRUdfU1RBUlRfQUREUkVTUzEpOworCWFkZHI4ID0gdGhpcy0+cmVhZF93b3JkKHRoaXMtPmJhc2UgKyBPTkVOQU5EX1JFR19TVEFSVF9BRERSRVNTOCk7CiAKIAlpZiAoaW50ZXJydXB0ICYgT05FTkFORF9JTlRfUkVBRCkgewotCQlpbnQgZWNjID0gb25lbmFuZF9yZWFkX2VjYyh0aGlzKTsKKwkJZWNjID0gb25lbmFuZF9yZWFkX2VjYyh0aGlzKTsKIAkJaWYgKGVjYyAmIE9ORU5BTkRfRUNDXzJCSVRfQUxMKSB7Ci0JCQlwcmludGsoS0VSTl9XQVJOSU5HICIlczogZWNjIGVycm9yID0gMHglMDR4LCAiCi0JCQkJImNvbnRyb2xsZXIgZXJyb3IgMHglMDR4XG4iLAotCQkJCV9fZnVuY19fLCBlY2MsIGN0cmwpOworCQkJcHJpbnRrKEtFUk5fREVCVUcgIiVzOiBlY2MgMHglMDR4IGN0cmwgMHglMDR4ICIKKwkJCSAgICAgICAiaW50ciAweCUwNHggYWRkcjEgJSN4IGFkZHI4ICUjeFxuIiwKKwkJCSAgICAgICBfX2Z1bmNfXywgZWNjLCBjdHJsLCBpbnRlcnJ1cHQsIGFkZHIxLCBhZGRyOCk7CiAJCQlyZXR1cm4gT05FTkFORF9CQlRfUkVBRF9FQ0NfRVJST1I7CiAJCX0KIAl9IGVsc2UgewotCQlwcmludGsoS0VSTl9FUlIgIiVzOiByZWFkIHRpbWVvdXQhIGN0cmw9MHglMDR4IGludHI9MHglMDR4XG4iLAotCQkJX19mdW5jX18sIGN0cmwsIGludGVycnVwdCk7CisJCXByaW50ayhLRVJOX0VSUiAiJXM6IHJlYWQgdGltZW91dCEgY3RybCAweCUwNHggIgorCQkgICAgICAgImludHIgMHglMDR4IGFkZHIxICUjeCBhZGRyOCAlI3hcbiIsCisJCSAgICAgICBfX2Z1bmNfXywgY3RybCwgaW50ZXJydXB0LCBhZGRyMSwgYWRkcjgpOwogCQlyZXR1cm4gT05FTkFORF9CQlRfUkVBRF9GQVRBTF9FUlJPUjsKIAl9CiAKIAkvKiBJbml0aWFsIGJhZCBibG9jayBjYXNlOiAweDI0MDAgb3IgMHgwNDAwICovCiAJaWYgKGN0cmwgJiBPTkVOQU5EX0NUUkxfRVJST1IpIHsKLQkJcHJpbnRrKEtFUk5fREVCVUcgIiVzOiBjb250cm9sbGVyIGVycm9yID0gMHglMDR4XG4iLAotCQkJX19mdW5jX18sIGN0cmwpOworCQlwcmludGsoS0VSTl9ERUJVRyAiJXM6IGN0cmwgMHglMDR4IGludHIgMHglMDR4IGFkZHIxICUjeCAiCisJCSAgICAgICAiYWRkcjggJSN4XG4iLCBfX2Z1bmNfXywgY3RybCwgaW50ZXJydXB0LCBhZGRyMSwgYWRkcjgpOwogCQlyZXR1cm4gT05FTkFORF9CQlRfUkVBRF9FUlJPUjsKIAl9CiAKQEAgLTE1NTgsNyArMTU2Myw3IEBACiAKIAljb2x1bW4gPSBmcm9tICYgKG10ZC0+b29ic2l6ZSAtIDEpOwogCi0JcmVhZGNtZCA9IE9ORU5BTkRfSVNfTUxDKHRoaXMpID8gT05FTkFORF9DTURfUkVBRCA6IE9ORU5BTkRfQ01EX1JFQURPT0I7CisJcmVhZGNtZCA9IE9ORU5BTkRfSVNfNEtCX1BBR0UodGhpcykgPyBPTkVOQU5EX0NNRF9SRUFEIDogT05FTkFORF9DTURfUkVBRE9PQjsKIAogCXdoaWxlIChyZWFkIDwgbGVuKSB7CiAJCWNvbmRfcmVzY2hlZCgpOwpAQCAtMTYxMiw3ICsxNjE3LDcgQEAKIAl1X2NoYXIgKm9vYl9idWYgPSB0aGlzLT5vb2JfYnVmOwogCWludCBzdGF0dXMsIGksIHJlYWRjbWQ7CiAKLQlyZWFkY21kID0gT05FTkFORF9JU19NTEModGhpcykgPyBPTkVOQU5EX0NNRF9SRUFEIDogT05FTkFORF9DTURfUkVBRE9PQjsKKwlyZWFkY21kID0gT05FTkFORF9JU180S0JfUEFHRSh0aGlzKSA/IE9ORU5BTkRfQ01EX1JFQUQgOiBPTkVOQU5EX0NNRF9SRUFET09COwogCiAJdGhpcy0+Y29tbWFuZChtdGQsIHJlYWRjbWQsIHRvLCBtdGQtPm9vYnNpemUpOwogCW9uZW5hbmRfdXBkYXRlX2J1ZmZlcnJhbShtdGQsIHRvLCAwKTsKQEAgLTE4NDUsNyArMTg1MCw3IEBACiAJY29uc3QgdV9jaGFyICpidWYgPSBvcHMtPmRhdGJ1ZjsKIAljb25zdCB1X2NoYXIgKm9vYiA9IG9wcy0+b29iYnVmOwogCXVfY2hhciAqb29iYnVmOwotCWludCByZXQgPSAwOworCWludCByZXQgPSAwLCBjbWQ7CiAKIAlERUJVRyhNVERfREVCVUdfTEVWRUwzLCAiJXM6IHRvID0gMHglMDh4LCBsZW4gPSAlaVxuIiwKIAkJX19mdW5jX18sICh1bnNpZ25lZCBpbnQpIHRvLCAoaW50KSBsZW4pOwpAQCAtMTk1NCw3ICsxOTU5LDE5IEBACiAJCQlPTkVOQU5EX1NFVF9ORVhUX0JVRkZFUlJBTSh0aGlzKTsKIAkJfQogCi0JCXRoaXMtPmNvbW1hbmQobXRkLCBPTkVOQU5EX0NNRF9QUk9HLCB0bywgbXRkLT53cml0ZXNpemUpOworCQl0aGlzLT5vbmdvaW5nID0gMDsKKwkJY21kID0gT05FTkFORF9DTURfUFJPRzsKKworCQkvKiBFeGNsdWRlIDFzdCBPVFAgYW5kIE9UUCBibG9ja3MgZm9yIGNhY2hlIHByb2dyYW0gZmVhdHVyZSAqLworCQlpZiAoT05FTkFORF9JU19DQUNIRV9QUk9HUkFNKHRoaXMpICYmCisJCSAgICBsaWtlbHkob25lbmFuZF9ibG9jayh0aGlzLCB0bykgIT0gMCkgJiYKKwkJICAgIE9ORU5BTkRfSVNfNEtCX1BBR0UodGhpcykgJiYKKwkJICAgICgod3JpdHRlbiArIHRoaXNsZW4pIDwgbGVuKSkgeworCQkJY21kID0gT05FTkFORF9DTURfMlhfQ0FDSEVfUFJPRzsKKwkJCXRoaXMtPm9uZ29pbmcgPSAxOworCQl9CisKKwkJdGhpcy0+Y29tbWFuZChtdGQsIGNtZCwgdG8sIG10ZC0+d3JpdGVzaXplKTsKIAogCQkvKgogCQkgKiAyIFBMQU5FLCBNTEMsIGFuZCBGbGV4LU9uZU5BTkQgd2FpdCBoZXJlCkBAIC0yMDY3LDcgKzIwODQsNyBAQAogCiAJb29iYnVmID0gdGhpcy0+b29iX2J1ZjsKIAotCW9vYmNtZCA9IE9ORU5BTkRfSVNfTUxDKHRoaXMpID8gT05FTkFORF9DTURfUFJPRyA6IE9ORU5BTkRfQ01EX1BST0dPT0I7CisJb29iY21kID0gT05FTkFORF9JU180S0JfUEFHRSh0aGlzKSA/IE9ORU5BTkRfQ01EX1BST0cgOiBPTkVOQU5EX0NNRF9QUk9HT09COwogCiAJLyogTG9vcCB1bnRpbCBhbGwgZGF0YSB3cml0ZSAqLwogCXdoaWxlICh3cml0dGVuIDwgbGVuKSB7CkBAIC0yMDg2LDcgKzIxMDMsNyBAQAogCQkJbWVtY3B5KG9vYmJ1ZiArIGNvbHVtbiwgYnVmLCB0aGlzbGVuKTsKIAkJdGhpcy0+d3JpdGVfYnVmZmVycmFtKG10ZCwgT05FTkFORF9TUEFSRVJBTSwgb29iYnVmLCAwLCBtdGQtPm9vYnNpemUpOwogCi0JCWlmIChPTkVOQU5EX0lTX01MQyh0aGlzKSB8fCBPTkVOQU5EX0lTXzRLQl9QQUdFKHRoaXMpKSB7CisJCWlmIChPTkVOQU5EX0lTXzRLQl9QQUdFKHRoaXMpKSB7CiAJCQkvKiBTZXQgbWFpbiBhcmVhIG9mIERhdGFSQU0gdG8gMHhmZiovCiAJCQltZW1zZXQodGhpcy0+cGFnZV9idWYsIDB4ZmYsIG10ZC0+d3JpdGVzaXplKTsKIAkJCXRoaXMtPndyaXRlX2J1ZmZlcnJhbShtdGQsIE9ORU5BTkRfREFUQVJBTSwKQEAgLTI0ODEsNyArMjQ5OCw4IEBACiAJLyogR3JhYiB0aGUgbG9jayBhbmQgc2VlIGlmIHRoZSBkZXZpY2UgaXMgYXZhaWxhYmxlICovCiAJb25lbmFuZF9nZXRfZGV2aWNlKG10ZCwgRkxfRVJBU0lORyk7CiAKLQlpZiAocmVnaW9uIHx8IGluc3RyLT5sZW4gPCBNQl9FUkFTRV9NSU5fQkxLX0NPVU5UICogYmxvY2tfc2l6ZSkgeworCWlmIChPTkVOQU5EX0lTXzRLQl9QQUdFKHRoaXMpIHx8IHJlZ2lvbiB8fAorCSAgICBpbnN0ci0+bGVuIDwgTUJfRVJBU0VfTUlOX0JMS19DT1VOVCAqIGJsb2NrX3NpemUpIHsKIAkJLyogcmVnaW9uIGlzIHNldCBmb3IgRmxleC1PbmVOQU5EIChubyBtYiBlcmFzZSkgKi8KIAkJcmV0ID0gb25lbmFuZF9ibG9ja19ieV9ibG9ja19lcmFzZShtdGQsIGluc3RyLAogCQkJCQkJICAgcmVnaW9uLCBibG9ja19zaXplKTsKQEAgLTMwMjksNyArMzA0Nyw3IEBACiAJdGhpcy0+Y29tbWFuZChtdGQsIE9ORU5BTkRfQ01EX09UUF9BQ0NFU1MsIDAsIDApOwogCXRoaXMtPndhaXQobXRkLCBGTF9PVFBJTkcpOwogCi0JcmV0ID0gT05FTkFORF9JU19NTEModGhpcykgfHwgT05FTkFORF9JU180S0JfUEFHRSh0aGlzKSA/CisJcmV0ID0gT05FTkFORF9JU180S0JfUEFHRSh0aGlzKSA/CiAJCW9uZW5hbmRfbWxjX3JlYWRfb3BzX25vbG9jayhtdGQsIGZyb20sICZvcHMpIDoKIAkJb25lbmFuZF9yZWFkX29wc19ub2xvY2sobXRkLCBmcm9tLCAmb3BzKTsKIApAQCAtMzM3Nyw4ICszMzk1LDEwIEBACiAJY2FzZSBPTkVOQU5EX0RFVklDRV9ERU5TSVRZXzRHYjoKIAkJaWYgKE9ORU5BTkRfSVNfRERQKHRoaXMpKQogCQkJdGhpcy0+b3B0aW9ucyB8PSBPTkVOQU5EX0hBU18yUExBTkU7Ci0JCWVsc2UgaWYgKG51bWJ1ZnMgPT0gMSkKKwkJZWxzZSBpZiAobnVtYnVmcyA9PSAxKSB7CiAJCQl0aGlzLT5vcHRpb25zIHw9IE9ORU5BTkRfSEFTXzRLQl9QQUdFOworCQkJdGhpcy0+b3B0aW9ucyB8PSBPTkVOQU5EX0hBU19DQUNIRV9QUk9HUkFNOworCQl9CiAKIAljYXNlIE9ORU5BTkRfREVWSUNFX0RFTlNJVFlfMkdiOgogCQkvKiAyR2IgRERQIGRvZXMgbm90IGhhdmUgMiBwbGFuZSAqLwpAQCAtMzM5OSw3ICszNDE5LDExIEBACiAJCWJyZWFrOwogCX0KIAotCWlmIChPTkVOQU5EX0lTX01MQyh0aGlzKSB8fCBPTkVOQU5EX0lTXzRLQl9QQUdFKHRoaXMpKQorCS8qIFRoZSBNTEMgaGFzIDRLaUIgcGFnZXNpemUuICovCisJaWYgKE9ORU5BTkRfSVNfTUxDKHRoaXMpKQorCQl0aGlzLT5vcHRpb25zIHw9IE9ORU5BTkRfSEFTXzRLQl9QQUdFOworCisJaWYgKE9ORU5BTkRfSVNfNEtCX1BBR0UodGhpcykpCiAJCXRoaXMtPm9wdGlvbnMgJj0gfk9ORU5BTkRfSEFTXzJQTEFORTsKIAogCWlmIChGTEVYT05FTkFORCh0aGlzKSkgewpAQCAtMzQxNSw2ICszNDM5LDggQEAKIAkJcHJpbnRrKEtFUk5fREVCVUcgIkNoaXAgaGFzIDIgcGxhbmVcbiIpOwogCWlmICh0aGlzLT5vcHRpb25zICYgT05FTkFORF9IQVNfNEtCX1BBR0UpCiAJCXByaW50ayhLRVJOX0RFQlVHICJDaGlwIGhhcyA0S2lCIHBhZ2VzaXplXG4iKTsKKwlpZiAodGhpcy0+b3B0aW9ucyAmIE9ORU5BTkRfSEFTX0NBQ0hFX1BST0dSQU0pCisJCXByaW50ayhLRVJOX0RFQlVHICJDaGlwIGhhcyBjYWNoZSBwcm9ncmFtIGZlYXR1cmVcbiIpOwogfQogCiAvKioKQEAgLTM4MzEsNyArMzg1Nyw3IEBACiAJLyogVGhlIGRhdGEgYnVmZmVyIHNpemUgaXMgZXF1YWwgdG8gcGFnZSBzaXplICovCiAJbXRkLT53cml0ZXNpemUgPSB0aGlzLT5yZWFkX3dvcmQodGhpcy0+YmFzZSArIE9ORU5BTkRfUkVHX0RBVEFfQlVGRkVSX1NJWkUpOwogCS8qIFdlIHVzZSB0aGUgZnVsbCBCdWZmZXJSQU0gKi8KLQlpZiAoT05FTkFORF9JU19NTEModGhpcykgfHwgT05FTkFORF9JU180S0JfUEFHRSh0aGlzKSkKKwlpZiAoT05FTkFORF9JU180S0JfUEFHRSh0aGlzKSkKIAkJbXRkLT53cml0ZXNpemUgPDw9IDE7CiAKIAltdGQtPm9vYnNpemUgPSBtdGQtPndyaXRlc2l6ZSA+PiA1OwpAQCAtNDA1NCw2ICs0MDgwLDcgQEAKIAltdGQtPmJsb2NrX2lzYmFkID0gb25lbmFuZF9ibG9ja19pc2JhZDsKIAltdGQtPmJsb2NrX21hcmtiYWQgPSBvbmVuYW5kX2Jsb2NrX21hcmtiYWQ7CiAJbXRkLT5vd25lciA9IFRISVNfTU9EVUxFOworCW10ZC0+d3JpdGVidWZzaXplID0gbXRkLT53cml0ZXNpemU7CiAKIAkvKiBVbmxvY2sgd2hvbGUgYmxvY2sgKi8KIAl0aGlzLT51bmxvY2tfYWxsKG10ZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9vbmVuYW5kL29uZW5hbmRfYmJ0LmMgYi9kcml2ZXJzL210ZC9vbmVuYW5kL29uZW5hbmRfYmJ0LmMKaW5kZXggMDFhYjViMy4uZmMyYzE2YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvb25lbmFuZC9vbmVuYW5kX2JidC5jCisrKyBiL2RyaXZlcnMvbXRkL29uZW5hbmQvb25lbmFuZF9iYnQuYwpAQCAtOTEsMTYgKzkxLDE4IEBACiAJCWZvciAoaiA9IDA7IGogPCBsZW47IGorKykgewogCQkJLyogTm8gbmVlZCB0byByZWFkIHBhZ2VzIGZ1bGx5LAogCQkJICoganVzdCByZWFkIHJlcXVpcmVkIE9PQiBieXRlcyAqLwotCQkJcmV0ID0gb25lbmFuZF9iYnRfcmVhZF9vb2IobXRkLCBmcm9tICsgaiAqIG10ZC0+d3JpdGVzaXplICsgYmQtPm9mZnMsICZvcHMpOworCQkJcmV0ID0gb25lbmFuZF9iYnRfcmVhZF9vb2IobXRkLAorCQkJCWZyb20gKyBqICogdGhpcy0+d3JpdGVzaXplICsgYmQtPm9mZnMsICZvcHMpOwogCiAJCQkvKiBJZiBpdCBpcyBhIGluaXRpYWwgYmFkIGJsb2NrLCBqdXN0IGlnbm9yZSBpdCAqLwogCQkJaWYgKHJldCA9PSBPTkVOQU5EX0JCVF9SRUFEX0ZBVEFMX0VSUk9SKQogCQkJCXJldHVybiAtRUlPOwogCi0JCQlpZiAocmV0IHx8IGNoZWNrX3Nob3J0X3BhdHRlcm4oJmJ1ZltqICogc2Nhbmxlbl0sIHNjYW5sZW4sIG10ZC0+d3JpdGVzaXplLCBiZCkpIHsKKwkJCWlmIChyZXQgfHwgY2hlY2tfc2hvcnRfcGF0dGVybigmYnVmW2ogKiBzY2FubGVuXSwKKwkJCQkJICAgICAgIHNjYW5sZW4sIHRoaXMtPndyaXRlc2l6ZSwgYmQpKSB7CiAJCQkJYmJtLT5iYnRbaSA+PiAzXSB8PSAweDAzIDw8IChpICYgMHg2KTsKLQkJCQlwcmludGsoS0VSTl9XQVJOSU5HICJCYWQgZXJhc2VibG9jayAlZCBhdCAweCUwOHhcbiIsCi0JCQkJCWkgPj4gMSwgKHVuc2lnbmVkIGludCkgZnJvbSk7CisJCQkJcHJpbnRrKEtFUk5fSU5GTyAiT25lTkFORCBlcmFzZWJsb2NrICVkIGlzIGFuICIKKwkJCQkJImluaXRpYWwgYmFkIGJsb2NrXG4iLCBpID4+IDEpOwogCQkJCW10ZC0+ZWNjX3N0YXRzLmJhZGJsb2NrcysrOwogCQkJCWJyZWFrOwogCQkJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvb25lbmFuZC9zYW1zdW5nLmMgYi9kcml2ZXJzL210ZC9vbmVuYW5kL3NhbXN1bmcuYwppbmRleCAwZGU3YTA1Li5hNGM3NGE5IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9vbmVuYW5kL3NhbXN1bmcuYworKysgYi9kcml2ZXJzL210ZC9vbmVuYW5kL3NhbXN1bmcuYwpAQCAtNjUxLDcgKzY1MSw3IEBACiAJdm9pZCBfX2lvbWVtICpwOwogCXZvaWQgKmJ1ZiA9ICh2b2lkICopIGJ1ZmZlcjsKIAlkbWFfYWRkcl90IGRtYV9zcmMsIGRtYV9kc3Q7Ci0JaW50IGVyciwgcGFnZV9kbWEgPSAwOworCWludCBlcnIsIG9mcywgcGFnZV9kbWEgPSAwOwogCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZvbmVuYW5kLT5wZGV2LT5kZXY7CiAKIAlwID0gdGhpcy0+YmFzZSArIGFyZWE7CkBAIC02NzcsMTAgKzY3NywxMyBAQAogCQlpZiAoIXBhZ2UpCiAJCQlnb3RvIG5vcm1hbDsKIAorCQkvKiBQYWdlIG9mZnNldCAqLworCQlvZnMgPSAoKHNpemVfdCkgYnVmICYgflBBR0VfTUFTSyk7CiAJCXBhZ2VfZG1hID0gMTsKKwogCQkvKiBETUEgcm91dGluZSAqLwogCQlkbWFfc3JjID0gb25lbmFuZC0+cGh5c19iYXNlICsgKHAgLSB0aGlzLT5iYXNlKTsKLQkJZG1hX2RzdCA9IGRtYV9tYXBfcGFnZShkZXYsIHBhZ2UsIDAsIGNvdW50LCBETUFfRlJPTV9ERVZJQ0UpOworCQlkbWFfZHN0ID0gZG1hX21hcF9wYWdlKGRldiwgcGFnZSwgb2ZzLCBjb3VudCwgRE1BX0ZST01fREVWSUNFKTsKIAl9IGVsc2UgewogCQkvKiBETUEgcm91dGluZSAqLwogCQlkbWFfc3JjID0gb25lbmFuZC0+cGh5c19iYXNlICsgKHAgLSB0aGlzLT5iYXNlKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL3ViaS92dGJsLmMgYi9kcml2ZXJzL210ZC91YmkvdnRibC5jCmluZGV4IGZjZGI3ZjYuLjBiODE0MWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL3ViaS92dGJsLmMKKysrIGIvZHJpdmVycy9tdGQvdWJpL3Z0YmwuYwpAQCAtNDI1LDEyICs0MjUsMTEgQEAKIAogCS8qIFJlYWQgYm90aCBMRUIgMCBhbmQgTEVCIDEgaW50byBtZW1vcnkgKi8KIAl1YmlfcmJfZm9yX2VhY2hfZW50cnkocmIsIHNlYiwgJnN2LT5yb290LCB1LnJiKSB7Ci0JCWxlYltzZWItPmxudW1dID0gdm1hbGxvYyh1YmktPnZ0Ymxfc2l6ZSk7CisJCWxlYltzZWItPmxudW1dID0gdnphbGxvYyh1YmktPnZ0Ymxfc2l6ZSk7CiAJCWlmICghbGViW3NlYi0+bG51bV0pIHsKIAkJCWVyciA9IC1FTk9NRU07CiAJCQlnb3RvIG91dF9mcmVlOwogCQl9Ci0JCW1lbXNldChsZWJbc2ViLT5sbnVtXSwgMCwgdWJpLT52dGJsX3NpemUpOwogCiAJCWVyciA9IHViaV9pb19yZWFkX2RhdGEodWJpLCBsZWJbc2ViLT5sbnVtXSwgc2ViLT5wbnVtLCAwLAogCQkJCSAgICAgICB1YmktPnZ0Ymxfc2l6ZSk7CkBAIC01MTYsMTAgKzUxNSw5IEBACiAJaW50IGk7CiAJc3RydWN0IHViaV92dGJsX3JlY29yZCAqdnRibDsKIAotCXZ0YmwgPSB2bWFsbG9jKHViaS0+dnRibF9zaXplKTsKKwl2dGJsID0gdnphbGxvYyh1YmktPnZ0Ymxfc2l6ZSk7CiAJaWYgKCF2dGJsKQogCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKLQltZW1zZXQodnRibCwgMCwgdWJpLT52dGJsX3NpemUpOwogCiAJZm9yIChpID0gMDsgaSA8IHViaS0+dnRibF9zbG90czsgaSsrKQogCQltZW1jcHkoJnZ0YmxbaV0sICZlbXB0eV92dGJsX3JlY29yZCwgVUJJX1ZUQkxfUkVDT1JEX1NJWkUpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvS2NvbmZpZyBiL2RyaXZlcnMvbmV0L0tjb25maWcKaW5kZXggNGM4YmZjOS4uMDM4MjMzMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvS2NvbmZpZworKysgYi9kcml2ZXJzL25ldC9LY29uZmlnCkBAIC0yODY0LDcgKzI4NjQsNyBAQAogCWRlZmF1bHQgbgogCiBjb25maWcgTUxYNF9ERUJVRwotCWJvb2wgIlZlcmJvc2UgZGVidWdnaW5nIG91dHB1dCIgaWYgKE1MWDRfQ09SRSAmJiBFTUJFRERFRCkKKwlib29sICJWZXJib3NlIGRlYnVnZ2luZyBvdXRwdXQiIGlmIChNTFg0X0NPUkUgJiYgRVhQRVJUKQogCWRlcGVuZHMgb24gTUxYNF9DT1JFCiAJZGVmYXVsdCB5CiAJLS0taGVscC0tLQpAQCAtMzM4OSw4ICszMzg5LDcgQEAKIAogY29uZmlnIE5FVENPTlNPTEVfRFlOQU1JQwogCWJvb2wgIkR5bmFtaWMgcmVjb25maWd1cmF0aW9uIG9mIGxvZ2dpbmcgdGFyZ2V0cyIKLQlkZXBlbmRzIG9uIE5FVENPTlNPTEUgJiYgU1lTRlMKLQlzZWxlY3QgQ09ORklHRlNfRlMKKwlkZXBlbmRzIG9uIE5FVENPTlNPTEUgJiYgU1lTRlMgJiYgQ09ORklHRlNfRlMKIAloZWxwCiAJICBUaGlzIG9wdGlvbiBlbmFibGVzIHRoZSBhYmlsaXR5IHRvIGR5bmFtaWNhbGx5IHJlY29uZmlndXJlIHRhcmdldAogCSAgcGFyYW1ldGVycyAoaW50ZXJmYWNlLCBJUCBhZGRyZXNzZXMsIHBvcnQgbnVtYmVycywgTUFDIGFkZHJlc3NlcykKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2FybS9rczg2OTVuZXQuYyBiL2RyaXZlcnMvbmV0L2FybS9rczg2OTVuZXQuYwppbmRleCA1NGM2ZDg0Li5hYTA3NjU3IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9hcm0va3M4Njk1bmV0LmMKKysrIGIvZHJpdmVycy9uZXQvYXJtL2tzODY5NW5ldC5jCkBAIC04NTQsMTIgKzg1NCwxMiBAQAogfQogCiAvKioKLSAqCWtzODY5NV9nZXRfc2V0dGluZ3MgLSBHZXQgZGV2aWNlLXNwZWNpZmljIHNldHRpbmdzLgorICoJa3M4Njk1X3dhbl9nZXRfc2V0dGluZ3MgLSBHZXQgZGV2aWNlLXNwZWNpZmljIHNldHRpbmdzLgogICoJQG5kZXY6IFRoZSBuZXR3b3JrIGRldmljZSB0byByZWFkIHNldHRpbmdzIGZyb20KICAqCUBjbWQ6IFRoZSBldGh0b29sIHN0cnVjdHVyZSB0byByZWFkIGludG8KICAqLwogc3RhdGljIGludAota3M4Njk1X2dldF9zZXR0aW5ncyhzdHJ1Y3QgbmV0X2RldmljZSAqbmRldiwgc3RydWN0IGV0aHRvb2xfY21kICpjbWQpCitrczg2OTVfd2FuX2dldF9zZXR0aW5ncyhzdHJ1Y3QgbmV0X2RldmljZSAqbmRldiwgc3RydWN0IGV0aHRvb2xfY21kICpjbWQpCiB7CiAJc3RydWN0IGtzODY5NV9wcml2ICprc3AgPSBuZXRkZXZfcHJpdihuZGV2KTsKIAl1MzIgY3RybDsKQEAgLTg3MCw2OSArODcwLDUwIEBACiAJCQkgIFNVUFBPUlRFRF9UUCB8IFNVUFBPUlRFRF9NSUkpOwogCWNtZC0+dHJhbnNjZWl2ZXIgPSBYQ1ZSX0lOVEVSTkFMOwogCi0JLyogUG9ydCBzcGVjaWZpYyBleHRyYXMgKi8KLQlzd2l0Y2ggKGtzcC0+ZHR5cGUpIHsKLQljYXNlIEtTODY5NV9EVFlQRV9IUE5BOgotCQljbWQtPnBoeV9hZGRyZXNzID0gMDsKLQkJLyogbm90IHN1cHBvcnRlZCBmb3IgSFBOQSAqLworCWNtZC0+YWR2ZXJ0aXNpbmcgPSBBRFZFUlRJU0VEX1RQIHwgQURWRVJUSVNFRF9NSUk7CisJY21kLT5wb3J0ID0gUE9SVF9NSUk7CisJY21kLT5zdXBwb3J0ZWQgfD0gKFNVUFBPUlRFRF9BdXRvbmVnIHwgU1VQUE9SVEVEX1BhdXNlKTsKKwljbWQtPnBoeV9hZGRyZXNzID0gMDsKKworCWN0cmwgPSByZWFkbChrc3AtPnBoeWlmYWNlX3JlZ3MgKyBLUzg2OTVfV01DKTsKKwlpZiAoKGN0cmwgJiBXTUNfV0FORCkgPT0gMCkgeworCQkvKiBhdXRvLW5lZ290aWF0aW9uIGlzIGVuYWJsZWQgKi8KKwkJY21kLT5hZHZlcnRpc2luZyB8PSBBRFZFUlRJU0VEX0F1dG9uZWc7CisJCWlmIChjdHJsICYgV01DX1dBTkExMDBGKQorCQkJY21kLT5hZHZlcnRpc2luZyB8PSBBRFZFUlRJU0VEXzEwMGJhc2VUX0Z1bGw7CisJCWlmIChjdHJsICYgV01DX1dBTkExMDBIKQorCQkJY21kLT5hZHZlcnRpc2luZyB8PSBBRFZFUlRJU0VEXzEwMGJhc2VUX0hhbGY7CisJCWlmIChjdHJsICYgV01DX1dBTkExMEYpCisJCQljbWQtPmFkdmVydGlzaW5nIHw9IEFEVkVSVElTRURfMTBiYXNlVF9GdWxsOworCQlpZiAoY3RybCAmIFdNQ19XQU5BMTBIKQorCQkJY21kLT5hZHZlcnRpc2luZyB8PSBBRFZFUlRJU0VEXzEwYmFzZVRfSGFsZjsKKwkJaWYgKGN0cmwgJiBXTUNfV0FOQVApCisJCQljbWQtPmFkdmVydGlzaW5nIHw9IEFEVkVSVElTRURfUGF1c2U7CisJCWNtZC0+YXV0b25lZyA9IEFVVE9ORUdfRU5BQkxFOworCisJCWNtZC0+c3BlZWQgPSAoY3RybCAmIFdNQ19XU1MpID8gU1BFRURfMTAwIDogU1BFRURfMTA7CisJCWNtZC0+ZHVwbGV4ID0gKGN0cmwgJiBXTUNfV0RTKSA/CisJCQlEVVBMRVhfRlVMTCA6IERVUExFWF9IQUxGOworCX0gZWxzZSB7CisJCS8qIGF1dG8tbmVnb3RpYXRpb24gaXMgZGlzYWJsZWQgKi8KIAkJY21kLT5hdXRvbmVnID0gQVVUT05FR19ESVNBQkxFOwogCi0JCS8qIEJVRzogRXJtLCBkdHlwZSBocG5hIGltcGxpZXMgbm8gcGh5IHJlZ3MgKi8KLQkJLyoKLQkJY3RybCA9IHJlYWRsKEtTODY5NV9NSVNDX1ZBICsgS1M4Njk1X0hNQyk7Ci0JCWNtZC0+c3BlZWQgPSAoY3RybCAmIEhNQ19IU1MpID8gU1BFRURfMTAwIDogU1BFRURfMTA7Ci0JCWNtZC0+ZHVwbGV4ID0gKGN0cmwgJiBITUNfSERTKSA/IERVUExFWF9GVUxMIDogRFVQTEVYX0hBTEY7Ci0JCSovCi0JCXJldHVybiAtRU9QTk9UU1VQUDsKLQljYXNlIEtTODY5NV9EVFlQRV9XQU46Ci0JCWNtZC0+YWR2ZXJ0aXNpbmcgPSBBRFZFUlRJU0VEX1RQIHwgQURWRVJUSVNFRF9NSUk7Ci0JCWNtZC0+cG9ydCA9IFBPUlRfTUlJOwotCQljbWQtPnN1cHBvcnRlZCB8PSAoU1VQUE9SVEVEX0F1dG9uZWcgfCBTVVBQT1JURURfUGF1c2UpOwotCQljbWQtPnBoeV9hZGRyZXNzID0gMDsKLQotCQljdHJsID0gcmVhZGwoa3NwLT5waHlpZmFjZV9yZWdzICsgS1M4Njk1X1dNQyk7Ci0JCWlmICgoY3RybCAmIFdNQ19XQU5EKSA9PSAwKSB7Ci0JCQkvKiBhdXRvLW5lZ290aWF0aW9uIGlzIGVuYWJsZWQgKi8KLQkJCWNtZC0+YWR2ZXJ0aXNpbmcgfD0gQURWRVJUSVNFRF9BdXRvbmVnOwotCQkJaWYgKGN0cmwgJiBXTUNfV0FOQTEwMEYpCi0JCQkJY21kLT5hZHZlcnRpc2luZyB8PSBBRFZFUlRJU0VEXzEwMGJhc2VUX0Z1bGw7Ci0JCQlpZiAoY3RybCAmIFdNQ19XQU5BMTAwSCkKLQkJCQljbWQtPmFkdmVydGlzaW5nIHw9IEFEVkVSVElTRURfMTAwYmFzZVRfSGFsZjsKLQkJCWlmIChjdHJsICYgV01DX1dBTkExMEYpCi0JCQkJY21kLT5hZHZlcnRpc2luZyB8PSBBRFZFUlRJU0VEXzEwYmFzZVRfRnVsbDsKLQkJCWlmIChjdHJsICYgV01DX1dBTkExMEgpCi0JCQkJY21kLT5hZHZlcnRpc2luZyB8PSBBRFZFUlRJU0VEXzEwYmFzZVRfSGFsZjsKLQkJCWlmIChjdHJsICYgV01DX1dBTkFQKQotCQkJCWNtZC0+YWR2ZXJ0aXNpbmcgfD0gQURWRVJUSVNFRF9QYXVzZTsKLQkJCWNtZC0+YXV0b25lZyA9IEFVVE9ORUdfRU5BQkxFOwotCi0JCQljbWQtPnNwZWVkID0gKGN0cmwgJiBXTUNfV1NTKSA/IFNQRUVEXzEwMCA6IFNQRUVEXzEwOwotCQkJY21kLT5kdXBsZXggPSAoY3RybCAmIFdNQ19XRFMpID8KLQkJCQlEVVBMRVhfRlVMTCA6IERVUExFWF9IQUxGOwotCQl9IGVsc2UgewotCQkJLyogYXV0by1uZWdvdGlhdGlvbiBpcyBkaXNhYmxlZCAqLwotCQkJY21kLT5hdXRvbmVnID0gQVVUT05FR19ESVNBQkxFOwotCi0JCQljbWQtPnNwZWVkID0gKGN0cmwgJiBXTUNfV0FORjEwMCkgPwotCQkJCVNQRUVEXzEwMCA6IFNQRUVEXzEwOwotCQkJY21kLT5kdXBsZXggPSAoY3RybCAmIFdNQ19XQU5GRikgPwotCQkJCURVUExFWF9GVUxMIDogRFVQTEVYX0hBTEY7Ci0JCX0KLQkJYnJlYWs7Ci0JY2FzZSBLUzg2OTVfRFRZUEVfTEFOOgotCQlyZXR1cm4gLUVPUE5PVFNVUFA7CisJCWNtZC0+c3BlZWQgPSAoY3RybCAmIFdNQ19XQU5GMTAwKSA/CisJCQlTUEVFRF8xMDAgOiBTUEVFRF8xMDsKKwkJY21kLT5kdXBsZXggPSAoY3RybCAmIFdNQ19XQU5GRikgPworCQkJRFVQTEVYX0ZVTEwgOiBEVVBMRVhfSEFMRjsKIAl9CiAKIAlyZXR1cm4gMDsKIH0KIAogLyoqCi0gKglrczg2OTVfc2V0X3NldHRpbmdzIC0gU2V0IGRldmljZS1zcGVjaWZpYyBzZXR0aW5ncy4KKyAqCWtzODY5NV93YW5fc2V0X3NldHRpbmdzIC0gU2V0IGRldmljZS1zcGVjaWZpYyBzZXR0aW5ncy4KICAqCUBuZGV2OiBUaGUgbmV0d29yayBkZXZpY2UgdG8gY29uZmlndXJlCiAgKglAY21kOiBUaGUgc2V0dGluZ3MgdG8gY29uZmlndXJlCiAgKi8KIHN0YXRpYyBpbnQKLWtzODY5NV9zZXRfc2V0dGluZ3Moc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIHN0cnVjdCBldGh0b29sX2NtZCAqY21kKQora3M4Njk1X3dhbl9zZXRfc2V0dGluZ3Moc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIHN0cnVjdCBldGh0b29sX2NtZCAqY21kKQogewogCXN0cnVjdCBrczg2OTVfcHJpdiAqa3NwID0gbmV0ZGV2X3ByaXYobmRldik7CiAJdTMyIGN0cmw7CkBAIC05NTYsMTcxICs5MzcsODUgQEAKIAkJCQlBRFZFUlRJU0VEXzEwMGJhc2VUX0Z1bGwpKSA9PSAwKQogCQkJcmV0dXJuIC1FSU5WQUw7CiAKLQkJc3dpdGNoIChrc3AtPmR0eXBlKSB7Ci0JCWNhc2UgS1M4Njk1X0RUWVBFX0hQTkE6Ci0JCQkvKiBIUE5BIGRvZXMgbm90IHN1cHBvcnQgYXV0by1uZWdvdGlhdGlvbi4gKi8KLQkJCXJldHVybiAtRUlOVkFMOwotCQljYXNlIEtTODY5NV9EVFlQRV9XQU46Ci0JCQljdHJsID0gcmVhZGwoa3NwLT5waHlpZmFjZV9yZWdzICsgS1M4Njk1X1dNQyk7CisJCWN0cmwgPSByZWFkbChrc3AtPnBoeWlmYWNlX3JlZ3MgKyBLUzg2OTVfV01DKTsKIAotCQkJY3RybCAmPSB+KFdNQ19XQU5EIHwgV01DX1dBTkExMDBGIHwgV01DX1dBTkExMDBIIHwKLQkJCQkgIFdNQ19XQU5BMTBGIHwgV01DX1dBTkExMEgpOwotCQkJaWYgKGNtZC0+YWR2ZXJ0aXNpbmcgJiBBRFZFUlRJU0VEXzEwMGJhc2VUX0Z1bGwpCi0JCQkJY3RybCB8PSBXTUNfV0FOQTEwMEY7Ci0JCQlpZiAoY21kLT5hZHZlcnRpc2luZyAmIEFEVkVSVElTRURfMTAwYmFzZVRfSGFsZikKLQkJCQljdHJsIHw9IFdNQ19XQU5BMTAwSDsKLQkJCWlmIChjbWQtPmFkdmVydGlzaW5nICYgQURWRVJUSVNFRF8xMGJhc2VUX0Z1bGwpCi0JCQkJY3RybCB8PSBXTUNfV0FOQTEwRjsKLQkJCWlmIChjbWQtPmFkdmVydGlzaW5nICYgQURWRVJUSVNFRF8xMGJhc2VUX0hhbGYpCi0JCQkJY3RybCB8PSBXTUNfV0FOQTEwSDsKKwkJY3RybCAmPSB+KFdNQ19XQU5EIHwgV01DX1dBTkExMDBGIHwgV01DX1dBTkExMDBIIHwKKwkJCSAgV01DX1dBTkExMEYgfCBXTUNfV0FOQTEwSCk7CisJCWlmIChjbWQtPmFkdmVydGlzaW5nICYgQURWRVJUSVNFRF8xMDBiYXNlVF9GdWxsKQorCQkJY3RybCB8PSBXTUNfV0FOQTEwMEY7CisJCWlmIChjbWQtPmFkdmVydGlzaW5nICYgQURWRVJUSVNFRF8xMDBiYXNlVF9IYWxmKQorCQkJY3RybCB8PSBXTUNfV0FOQTEwMEg7CisJCWlmIChjbWQtPmFkdmVydGlzaW5nICYgQURWRVJUSVNFRF8xMGJhc2VUX0Z1bGwpCisJCQljdHJsIHw9IFdNQ19XQU5BMTBGOworCQlpZiAoY21kLT5hZHZlcnRpc2luZyAmIEFEVkVSVElTRURfMTBiYXNlVF9IYWxmKQorCQkJY3RybCB8PSBXTUNfV0FOQTEwSDsKIAotCQkJLyogZm9yY2UgYSByZS1uZWdvdGlhdGlvbiAqLwotCQkJY3RybCB8PSBXTUNfV0FOUjsKLQkJCXdyaXRlbChjdHJsLCBrc3AtPnBoeWlmYWNlX3JlZ3MgKyBLUzg2OTVfV01DKTsKLQkJCWJyZWFrOwotCQljYXNlIEtTODY5NV9EVFlQRV9MQU46Ci0JCQlyZXR1cm4gLUVPUE5PVFNVUFA7Ci0JCX0KLQorCQkvKiBmb3JjZSBhIHJlLW5lZ290aWF0aW9uICovCisJCWN0cmwgfD0gV01DX1dBTlI7CisJCXdyaXRlbChjdHJsLCBrc3AtPnBoeWlmYWNlX3JlZ3MgKyBLUzg2OTVfV01DKTsKIAl9IGVsc2UgewotCQlzd2l0Y2ggKGtzcC0+ZHR5cGUpIHsKLQkJY2FzZSBLUzg2OTVfRFRZUEVfSFBOQToKLQkJCS8qIEJVRzogZHR5cGVfaHBuYSBpbXBsaWVzIG5vIHBoeSByZWdpc3RlcnMgKi8KLQkJCS8qCi0JCQljdHJsID0gX19yYXdfcmVhZGwoS1M4Njk1X01JU0NfVkEgKyBLUzg2OTVfSE1DKTsKKwkJY3RybCA9IHJlYWRsKGtzcC0+cGh5aWZhY2VfcmVncyArIEtTODY5NV9XTUMpOwogCi0JCQljdHJsICY9IH4oSE1DX0hTUyB8IEhNQ19IRFMpOwotCQkJaWYgKGNtZC0+c3BlZWQgPT0gU1BFRURfMTAwKQotCQkJCWN0cmwgfD0gSE1DX0hTUzsKLQkJCWlmIChjbWQtPmR1cGxleCA9PSBEVVBMRVhfRlVMTCkKLQkJCQljdHJsIHw9IEhNQ19IRFM7CisJCS8qIGRpc2FibGUgYXV0by1uZWdvdGlhdGlvbiAqLworCQljdHJsIHw9IFdNQ19XQU5EOworCQljdHJsICY9IH4oV01DX1dBTkYxMDAgfCBXTUNfV0FORkYpOwogCi0JCQlfX3Jhd193cml0ZWwoY3RybCwgS1M4Njk1X01JU0NfVkEgKyBLUzg2OTVfSE1DKTsKLQkJCSovCi0JCQlyZXR1cm4gLUVPUE5PVFNVUFA7Ci0JCWNhc2UgS1M4Njk1X0RUWVBFX1dBTjoKLQkJCWN0cmwgPSByZWFkbChrc3AtPnBoeWlmYWNlX3JlZ3MgKyBLUzg2OTVfV01DKTsKKwkJaWYgKGNtZC0+c3BlZWQgPT0gU1BFRURfMTAwKQorCQkJY3RybCB8PSBXTUNfV0FORjEwMDsKKwkJaWYgKGNtZC0+ZHVwbGV4ID09IERVUExFWF9GVUxMKQorCQkJY3RybCB8PSBXTUNfV0FORkY7CiAKLQkJCS8qIGRpc2FibGUgYXV0by1uZWdvdGlhdGlvbiAqLwotCQkJY3RybCB8PSBXTUNfV0FORDsKLQkJCWN0cmwgJj0gfihXTUNfV0FORjEwMCB8IFdNQ19XQU5GRik7Ci0KLQkJCWlmIChjbWQtPnNwZWVkID09IFNQRUVEXzEwMCkKLQkJCQljdHJsIHw9IFdNQ19XQU5GMTAwOwotCQkJaWYgKGNtZC0+ZHVwbGV4ID09IERVUExFWF9GVUxMKQotCQkJCWN0cmwgfD0gV01DX1dBTkZGOwotCi0JCQl3cml0ZWwoY3RybCwga3NwLT5waHlpZmFjZV9yZWdzICsgS1M4Njk1X1dNQyk7Ci0JCQlicmVhazsKLQkJY2FzZSBLUzg2OTVfRFRZUEVfTEFOOgotCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwotCQl9CisJCXdyaXRlbChjdHJsLCBrc3AtPnBoeWlmYWNlX3JlZ3MgKyBLUzg2OTVfV01DKTsKIAl9CiAKIAlyZXR1cm4gMDsKIH0KIAogLyoqCi0gKglrczg2OTVfbndheXJlc2V0IC0gUmVzdGFydCB0aGUgYXV0b25lZ290aWF0aW9uIG9uIHRoZSBwb3J0LgorICoJa3M4Njk1X3dhbl9ud2F5cmVzZXQgLSBSZXN0YXJ0IHRoZSBhdXRvbmVnb3RpYXRpb24gb24gdGhlIHBvcnQuCiAgKglAbmRldjogVGhlIG5ldHdvcmsgZGV2aWNlIHRvIHJlc3RhcnQgYXV0b25lb3RpYXRpb24gb24KICAqLwogc3RhdGljIGludAota3M4Njk1X253YXlyZXNldChzdHJ1Y3QgbmV0X2RldmljZSAqbmRldikKK2tzODY5NV93YW5fbndheXJlc2V0KHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2KQogewogCXN0cnVjdCBrczg2OTVfcHJpdiAqa3NwID0gbmV0ZGV2X3ByaXYobmRldik7CiAJdTMyIGN0cmw7CiAKLQlzd2l0Y2ggKGtzcC0+ZHR5cGUpIHsKLQljYXNlIEtTODY5NV9EVFlQRV9IUE5BOgotCQkvKiBObyBwaHkgbWVhbnMgbm8gYXV0b25lZ290aWF0aW9uIG9uIGhwbmEgKi8KKwljdHJsID0gcmVhZGwoa3NwLT5waHlpZmFjZV9yZWdzICsgS1M4Njk1X1dNQyk7CisKKwlpZiAoKGN0cmwgJiBXTUNfV0FORCkgPT0gMCkKKwkJd3JpdGVsKGN0cmwgfCBXTUNfV0FOUiwKKwkJICAgICAgIGtzcC0+cGh5aWZhY2VfcmVncyArIEtTODY5NV9XTUMpOworCWVsc2UKKwkJLyogYXV0by1uZWdvdGlhdGlvbiBub3QgZW5hYmxlZCAqLwogCQlyZXR1cm4gLUVJTlZBTDsKLQljYXNlIEtTODY5NV9EVFlQRV9XQU46Ci0JCWN0cmwgPSByZWFkbChrc3AtPnBoeWlmYWNlX3JlZ3MgKyBLUzg2OTVfV01DKTsKLQotCQlpZiAoKGN0cmwgJiBXTUNfV0FORCkgPT0gMCkKLQkJCXdyaXRlbChjdHJsIHwgV01DX1dBTlIsCi0JCQkgICAgICAga3NwLT5waHlpZmFjZV9yZWdzICsgS1M4Njk1X1dNQyk7Ci0JCWVsc2UKLQkJCS8qIGF1dG8tbmVnb3RpYXRpb24gbm90IGVuYWJsZWQgKi8KLQkJCXJldHVybiAtRUlOVkFMOwotCQlicmVhazsKLQljYXNlIEtTODY5NV9EVFlQRV9MQU46Ci0JCXJldHVybiAtRU9QTk9UU1VQUDsKLQl9CiAKIAlyZXR1cm4gMDsKIH0KIAogLyoqCi0gKglrczg2OTVfZ2V0X2xpbmsgLSBSZXRyaWV2ZSBsaW5rIHN0YXR1cyBvZiBuZXR3b3JrIGludGVyZmFjZQotICoJQG5kZXY6IFRoZSBuZXR3b3JrIGludGVyZmFjZSB0byByZXRyaXZlIHRoZSBsaW5rIHN0YXR1cyBvZi4KLSAqLwotc3RhdGljIHUzMgota3M4Njk1X2dldF9saW5rKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2KQotewotCXN0cnVjdCBrczg2OTVfcHJpdiAqa3NwID0gbmV0ZGV2X3ByaXYobmRldik7Ci0JdTMyIGN0cmw7Ci0KLQlzd2l0Y2ggKGtzcC0+ZHR5cGUpIHsKLQljYXNlIEtTODY5NV9EVFlQRV9IUE5BOgotCQkvKiBIUE5BIGFsd2F5cyBoYXMgbGluayAqLwotCQlyZXR1cm4gMTsKLQljYXNlIEtTODY5NV9EVFlQRV9XQU46Ci0JCS8qIFdBTiB3ZSBjYW4gcmVhZCB0aGUgUEhZIGZvciAqLwotCQljdHJsID0gcmVhZGwoa3NwLT5waHlpZmFjZV9yZWdzICsgS1M4Njk1X1dNQyk7Ci0JCXJldHVybiBjdHJsICYgV01DX1dMUzsKLQljYXNlIEtTODY5NV9EVFlQRV9MQU46Ci0JCXJldHVybiAtRU9QTk9UU1VQUDsKLQl9Ci0JcmV0dXJuIDA7Ci19Ci0KLS8qKgotICoJa3M4Njk1X2dldF9wYXVzZSAtIFJldHJpZXZlIG5ldHdvcmsgcGF1c2UvZmxvdy1jb250cm9sIGFkdmVydGlzaW5nCisgKglrczg2OTVfd2FuX2dldF9wYXVzZSAtIFJldHJpZXZlIG5ldHdvcmsgcGF1c2UvZmxvdy1jb250cm9sIGFkdmVydGlzaW5nCiAgKglAbmRldjogVGhlIGRldmljZSB0byByZXRyaWV2ZSBzZXR0aW5ncyBmcm9tCiAgKglAcGFyYW06IFRoZSBzdHJ1Y3R1cmUgdG8gZmlsbCBvdXQgd2l0aCB0aGUgaW5mb3JtYXRpb24KICAqLwogc3RhdGljIHZvaWQKLWtzODY5NV9nZXRfcGF1c2Uoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIHN0cnVjdCBldGh0b29sX3BhdXNlcGFyYW0gKnBhcmFtKQora3M4Njk1X3dhbl9nZXRfcGF1c2Uoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIHN0cnVjdCBldGh0b29sX3BhdXNlcGFyYW0gKnBhcmFtKQogewogCXN0cnVjdCBrczg2OTVfcHJpdiAqa3NwID0gbmV0ZGV2X3ByaXYobmRldik7CiAJdTMyIGN0cmw7CiAKLQlzd2l0Y2ggKGtzcC0+ZHR5cGUpIHsKLQljYXNlIEtTODY5NV9EVFlQRV9IUE5BOgotCQkvKiBObyBwaHkgbGluayBvbiBocG5hIHRvIGNvbmZpZ3VyZSAqLwotCQlyZXR1cm47Ci0JY2FzZSBLUzg2OTVfRFRZUEVfV0FOOgotCQljdHJsID0gcmVhZGwoa3NwLT5waHlpZmFjZV9yZWdzICsgS1M4Njk1X1dNQyk7CisJY3RybCA9IHJlYWRsKGtzcC0+cGh5aWZhY2VfcmVncyArIEtTODY5NV9XTUMpOwogCi0JCS8qIGFkdmVydGlzZSBQYXVzZSAqLwotCQlwYXJhbS0+YXV0b25lZyA9IChjdHJsICYgV01DX1dBTkFQKTsKKwkvKiBhZHZlcnRpc2UgUGF1c2UgKi8KKwlwYXJhbS0+YXV0b25lZyA9IChjdHJsICYgV01DX1dBTkFQKTsKIAotCQkvKiBjdXJyZW50IFJ4IEZsb3ctY29udHJvbCAqLwotCQljdHJsID0ga3M4Njk1X3JlYWRyZWcoa3NwLCBLUzg2OTVfRFJYQyk7Ci0JCXBhcmFtLT5yeF9wYXVzZSA9IChjdHJsICYgRFJYQ19SRkNFKTsKKwkvKiBjdXJyZW50IFJ4IEZsb3ctY29udHJvbCAqLworCWN0cmwgPSBrczg2OTVfcmVhZHJlZyhrc3AsIEtTODY5NV9EUlhDKTsKKwlwYXJhbS0+cnhfcGF1c2UgPSAoY3RybCAmIERSWENfUkZDRSk7CiAKLQkJLyogY3VycmVudCBUeCBGbG93LWNvbnRyb2wgKi8KLQkJY3RybCA9IGtzODY5NV9yZWFkcmVnKGtzcCwgS1M4Njk1X0RUWEMpOwotCQlwYXJhbS0+dHhfcGF1c2UgPSAoY3RybCAmIERUWENfVEZDRSk7Ci0JCWJyZWFrOwotCWNhc2UgS1M4Njk1X0RUWVBFX0xBTjoKLQkJLyogVGhlIExBTidzICJwaHkiIGlzIGEgZGlyZWN0LWF0dGFjaGVkIHN3aXRjaCAqLwotCQlyZXR1cm47Ci0JfQotfQotCi0vKioKLSAqCWtzODY5NV9zZXRfcGF1c2UgLSBDb25maWd1cmUgcGF1c2UvZmxvdy1jb250cm9sCi0gKglAbmRldjogVGhlIGRldmljZSB0byBjb25maWd1cmUKLSAqCUBwYXJhbTogVGhlIHBhdXNlIHBhcmFtZXRlcnMgdG8gc2V0Ci0gKgotICoJVE9ETzogSW1wbGVtZW50IHRoaXMKLSAqLwotc3RhdGljIGludAota3M4Njk1X3NldF9wYXVzZShzdHJ1Y3QgbmV0X2RldmljZSAqbmRldiwgc3RydWN0IGV0aHRvb2xfcGF1c2VwYXJhbSAqcGFyYW0pCi17Ci0JcmV0dXJuIC1FT1BOT1RTVVBQOworCS8qIGN1cnJlbnQgVHggRmxvdy1jb250cm9sICovCisJY3RybCA9IGtzODY5NV9yZWFkcmVnKGtzcCwgS1M4Njk1X0RUWEMpOworCXBhcmFtLT50eF9wYXVzZSA9IChjdHJsICYgRFRYQ19URkNFKTsKIH0KIAogLyoqCkBAIC0xMTQwLDEyICsxMDM1LDE3IEBACiBzdGF0aWMgY29uc3Qgc3RydWN0IGV0aHRvb2xfb3BzIGtzODY5NV9ldGh0b29sX29wcyA9IHsKIAkuZ2V0X21zZ2xldmVsCT0ga3M4Njk1X2dldF9tc2dsZXZlbCwKIAkuc2V0X21zZ2xldmVsCT0ga3M4Njk1X3NldF9tc2dsZXZlbCwKLQkuZ2V0X3NldHRpbmdzCT0ga3M4Njk1X2dldF9zZXR0aW5ncywKLQkuc2V0X3NldHRpbmdzCT0ga3M4Njk1X3NldF9zZXR0aW5ncywKLQkubndheV9yZXNldAk9IGtzODY5NV9ud2F5cmVzZXQsCi0JLmdldF9saW5rCT0ga3M4Njk1X2dldF9saW5rLAotCS5nZXRfcGF1c2VwYXJhbSA9IGtzODY5NV9nZXRfcGF1c2UsCi0JLnNldF9wYXVzZXBhcmFtID0ga3M4Njk1X3NldF9wYXVzZSwKKwkuZ2V0X2RydmluZm8JPSBrczg2OTVfZ2V0X2RydmluZm8sCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGV0aHRvb2xfb3BzIGtzODY5NV93YW5fZXRodG9vbF9vcHMgPSB7CisJLmdldF9tc2dsZXZlbAk9IGtzODY5NV9nZXRfbXNnbGV2ZWwsCisJLnNldF9tc2dsZXZlbAk9IGtzODY5NV9zZXRfbXNnbGV2ZWwsCisJLmdldF9zZXR0aW5ncwk9IGtzODY5NV93YW5fZ2V0X3NldHRpbmdzLAorCS5zZXRfc2V0dGluZ3MJPSBrczg2OTVfd2FuX3NldF9zZXR0aW5ncywKKwkubndheV9yZXNldAk9IGtzODY5NV93YW5fbndheXJlc2V0LAorCS5nZXRfbGluawk9IGV0aHRvb2xfb3BfZ2V0X2xpbmssCisJLmdldF9wYXVzZXBhcmFtID0ga3M4Njk1X3dhbl9nZXRfcGF1c2UsCiAJLmdldF9kcnZpbmZvCT0ga3M4Njk1X2dldF9kcnZpbmZvLAogfTsKIApAQCAtMTU0MSw3ICsxNDQxLDYgQEAKIAogCS8qIGRyaXZlciBzeXN0ZW0gc2V0dXAgKi8KIAluZGV2LT5uZXRkZXZfb3BzID0gJmtzODY5NV9uZXRkZXZfb3BzOwotCVNFVF9FVEhUT09MX09QUyhuZGV2LCAma3M4Njk1X2V0aHRvb2xfb3BzKTsKIAluZGV2LT53YXRjaGRvZ190aW1lbwkgPSBtc2Vjc190b19qaWZmaWVzKHdhdGNoZG9nKTsKIAogCW5ldGlmX25hcGlfYWRkKG5kZXYsICZrc3AtPm5hcGksIGtzODY5NV9wb2xsLCBOQVBJX1dFSUdIVCk7CkBAIC0xNjA4LDEyICsxNTA3LDE1IEBACiAJaWYgKGtzcC0+cGh5aWZhY2VfcmVncyAmJiBrc3AtPmxpbmtfaXJxID09IC0xKSB7CiAJCWtzODY5NV9pbml0X3N3aXRjaChrc3ApOwogCQlrc3AtPmR0eXBlID0gS1M4Njk1X0RUWVBFX0xBTjsKKwkJU0VUX0VUSFRPT0xfT1BTKG5kZXYsICZrczg2OTVfZXRodG9vbF9vcHMpOwogCX0gZWxzZSBpZiAoa3NwLT5waHlpZmFjZV9yZWdzICYmIGtzcC0+bGlua19pcnEgIT0gLTEpIHsKIAkJa3M4Njk1X2luaXRfd2FuX3BoeShrc3ApOwogCQlrc3AtPmR0eXBlID0gS1M4Njk1X0RUWVBFX1dBTjsKKwkJU0VUX0VUSFRPT0xfT1BTKG5kZXYsICZrczg2OTVfd2FuX2V0aHRvb2xfb3BzKTsKIAl9IGVsc2UgewogCQkvKiBObyBpbml0aWFsaXNhdGlvbiBzaW5jZSBIUE5BIGRvZXMgbm90IGhhdmUgYSBQSFkgKi8KIAkJa3NwLT5kdHlwZSA9IEtTODY5NV9EVFlQRV9IUE5BOworCQlTRVRfRVRIVE9PTF9PUFMobmRldiwgJmtzODY5NV9ldGh0b29sX29wcyk7CiAJfQogCiAJLyogQW5kIGJyaW5nIHVwIHRoZSBuZXRfZGV2aWNlIHdpdGggdGhlIG5ldCBjb3JlICovCkBAIC0xNzQyLDcgKzE2NDQsNyBAQAogbW9kdWxlX2luaXQoa3M4Njk1X2luaXQpOwogbW9kdWxlX2V4aXQoa3M4Njk1X2NsZWFudXApOwogCi1NT0RVTEVfQVVUSE9SKCJTaW10ZWMgRWxlY3Ryb25pY3MiKQorTU9EVUxFX0FVVEhPUigiU2ltdGVjIEVsZWN0cm9uaWNzIik7CiBNT0RVTEVfREVTQ1JJUFRJT04oIk1pY3JlbCBLUzg2OTUgKENlbnRhdXIpIEV0aGVybmV0IGRyaXZlciIpOwogTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwogTU9EVUxFX0FMSUFTKCJwbGF0Zm9ybToiIE1PRFVMRU5BTUUpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYXRsMWMvYXRsMWNfbWFpbi5jIGIvZHJpdmVycy9uZXQvYXRsMWMvYXRsMWNfbWFpbi5jCmluZGV4IGE2OTliYmYuLjM4MjQzODIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2F0bDFjL2F0bDFjX21haW4uYworKysgYi9kcml2ZXJzL25ldC9hdGwxYy9hdGwxY19tYWluLmMKQEAgLTQ4LDYgKzQ4LDcgQEAKIAl7UENJX0RFVklDRShQQ0lfVkVORE9SX0lEX0FUVEFOU0lDLCBQQ0lfREVWSUNFX0lEX0FUSEVST1NfTDJDX0IpfSwKIAl7UENJX0RFVklDRShQQ0lfVkVORE9SX0lEX0FUVEFOU0lDLCBQQ0lfREVWSUNFX0lEX0FUSEVST1NfTDJDX0IyKX0sCiAJe1BDSV9ERVZJQ0UoUENJX1ZFTkRPUl9JRF9BVFRBTlNJQywgUENJX0RFVklDRV9JRF9BVEhFUk9TX0wxRCl9LAorCXtQQ0lfREVWSUNFKFBDSV9WRU5ET1JfSURfQVRUQU5TSUMsIFBDSV9ERVZJQ0VfSURfQVRIRVJPU19MMURfMl8wKX0sCiAJLyogcmVxdWlyZWQgbGFzdCBlbnRyeSAqLwogCXsgMCB9CiB9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYmVuZXQvYmVfY21kcy5jIGIvZHJpdmVycy9uZXQvYmVuZXQvYmVfY21kcy5jCmluZGV4IDBjNzgxMWYuLmExNzljYzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JlbmV0L2JlX2NtZHMuYworKysgYi9kcml2ZXJzL25ldC9iZW5ldC9iZV9jbWRzLmMKQEAgLTE3ODYsNiArMTc4NiwxMCBAQAogCXNwaW5fbG9ja19iaCgmYWRhcHRlci0+bWNjX2xvY2spOwogCiAJd3JiID0gd3JiX2Zyb21fbWNjcShhZGFwdGVyKTsKKwlpZiAoIXdyYikgeworCQlzdGF0dXMgPSAtRUJVU1k7CisJCWdvdG8gZXJyOworCX0KIAlyZXEgPSBub25lbWJfY21kLT52YTsKIAlzZ2UgPSBub25lbWJlZGRlZF9zZ2wod3JiKTsKIApAQCAtMTgwMSw2ICsxODA1LDcgQEAKIAogCXN0YXR1cyA9IGJlX21jY19ub3RpZnlfd2FpdChhZGFwdGVyKTsKIAorZXJyOgogCXNwaW5fdW5sb2NrX2JoKCZhZGFwdGVyLT5tY2NfbG9jayk7CiAJcmV0dXJuIHN0YXR1czsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2JlbmV0L2JlX21haW4uYyBiL2RyaXZlcnMvbmV0L2JlbmV0L2JlX21haW4uYwppbmRleCBkZTQwZDNiLi4yOGEzMmE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9iZW5ldC9iZV9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvYmVuZXQvYmVfbWFpbi5jCkBAIC0zMTIsMTEgKzMxMiw5IEBACiAJaWYgKGFkYXB0ZXItPmxpbmtfdXAgIT0gbGlua191cCkgewogCQlhZGFwdGVyLT5saW5rX3NwZWVkID0gLTE7CiAJCWlmIChsaW5rX3VwKSB7Ci0JCQluZXRpZl9zdGFydF9xdWV1ZShuZXRkZXYpOwogCQkJbmV0aWZfY2Fycmllcl9vbihuZXRkZXYpOwogCQkJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IExpbmsgdXBcbiIsIG5ldGRldi0+bmFtZSk7CiAJCX0gZWxzZSB7Ci0JCQluZXRpZl9zdG9wX3F1ZXVlKG5ldGRldik7CiAJCQluZXRpZl9jYXJyaWVyX29mZihuZXRkZXYpOwogCQkJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IExpbmsgZG93blxuIiwgbmV0ZGV2LT5uYW1lKTsKIAkJfQpAQCAtMjYyOCw4ICsyNjI2LDYgQEAKIAogCW5ldGlmX25hcGlfYWRkKG5ldGRldiwgJmFkYXB0ZXItPnR4X2VxLm5hcGksIGJlX3BvbGxfdHhfbWNjLAogCQlCRV9OQVBJX1dFSUdIVCk7Ci0KLQluZXRpZl9zdG9wX3F1ZXVlKG5ldGRldik7CiB9CiAKIHN0YXRpYyB2b2lkIGJlX3VubWFwX3BjaV9iYXJzKHN0cnVjdCBiZV9hZGFwdGVyICphZGFwdGVyKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYmZpbl9tYWMuYyBiL2RyaXZlcnMvbmV0L2JmaW5fbWFjLmMKaW5kZXggMGI5ZmM1MS4uMjJhYmZiMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvYmZpbl9tYWMuYworKysgYi9kcml2ZXJzL25ldC9iZmluX21hYy5jCkBAIC0xMjg0LDE5ICsxMjg0LDEyIEBACiB7CiAJdTMyIGVtYWNfaGFzaGhpLCBlbWFjX2hhc2hsbzsKIAlzdHJ1Y3QgbmV0ZGV2X2h3X2FkZHIgKmhhOwotCWNoYXIgKmFkZHJzOwogCXUzMiBjcmM7CiAKIAllbWFjX2hhc2hoaSA9IGVtYWNfaGFzaGxvID0gMDsKIAogCW5ldGRldl9mb3JfZWFjaF9tY19hZGRyKGhhLCBkZXYpIHsKLQkJYWRkcnMgPSBoYS0+YWRkcjsKLQotCQkvKiBza2lwIG5vbi1tdWx0aWNhc3QgYWRkcmVzc2VzICovCi0JCWlmICghKCphZGRycyAmIDEpKQotCQkJY29udGludWU7Ci0KLQkJY3JjID0gZXRoZXJfY3JjKEVUSF9BTEVOLCBhZGRycyk7CisJCWNyYyA9IGV0aGVyX2NyYyhFVEhfQUxFTiwgaGEtPmFkZHIpOwogCQljcmMgPj49IDI2OwogCiAJCWlmIChjcmMgJiAweDIwKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYm5hL2JuYWRfZXRodG9vbC5jIGIvZHJpdmVycy9uZXQvYm5hL2JuYWRfZXRodG9vbC5jCmluZGV4IDk5YmU1YWUuLjE0MmQ2MDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JuYS9ibmFkX2V0aHRvb2wuYworKysgYi9kcml2ZXJzL25ldC9ibmEvYm5hZF9ldGh0b29sLmMKQEAgLTI3NSw3ICsyNzUsNiBAQAogCiAJaW9jX2F0dHIgPSBremFsbG9jKHNpemVvZigqaW9jX2F0dHIpLCBHRlBfS0VSTkVMKTsKIAlpZiAoaW9jX2F0dHIpIHsKLQkJbWVtc2V0KGlvY19hdHRyLCAwLCBzaXplb2YoKmlvY19hdHRyKSk7CiAJCXNwaW5fbG9ja19pcnFzYXZlKCZibmFkLT5ibmFfbG9jaywgZmxhZ3MpOwogCQliZmFfbndfaW9jX2dldF9hdHRyKCZibmFkLT5ibmEuZGV2aWNlLmlvYywgaW9jX2F0dHIpOwogCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZibmFkLT5ibmFfbG9jaywgZmxhZ3MpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYm54Mi5jIGIvZHJpdmVycy9uZXQvYm54Mi5jCmluZGV4IGRmOTllZGYuLjBiYTU5ZDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JueDIuYworKysgYi9kcml2ZXJzL25ldC9ibngyLmMKQEAgLTc1NTMsNiArNzU1MywxMCBAQAogCSAgICAhKGRhdGEgJiBFVEhfRkxBR19SWFZMQU4pKQogCQlyZXR1cm4gLUVJTlZBTDsKIAorCS8qIFRTTyB3aXRoIFZMQU4gdGFnIHdvbid0IHdvcmsgd2l0aCBjdXJyZW50IGZpcm13YXJlICovCisJaWYgKCEoZGF0YSAmIEVUSF9GTEFHX1RYVkxBTikpCisJCXJldHVybiAtRUlOVkFMOworCiAJcmMgPSBldGh0b29sX29wX3NldF9mbGFncyhkZXYsIGRhdGEsIEVUSF9GTEFHX1JYSEFTSCB8IEVUSF9GTEFHX1JYVkxBTiB8CiAJCQkJICBFVEhfRkxBR19UWFZMQU4pOwogCWlmIChyYykKQEAgLTc5NjIsMTEgKzc5NjYsOCBAQAogCiAJCS8qIEFFUiAoQWR2YW5jZWQgRXJyb3IgUmVwb3J0aW5nKSBob29rcyAqLwogCQllcnIgPSBwY2lfZW5hYmxlX3BjaWVfZXJyb3JfcmVwb3J0aW5nKHBkZXYpOwotCQlpZiAoZXJyKSB7Ci0JCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJwY2lfZW5hYmxlX3BjaWVfZXJyb3JfcmVwb3J0aW5nICIKLQkJCQkJICAgICJmYWlsZWQgMHgleFxuIiwgZXJyKTsKLQkJCS8qIG5vbi1mYXRhbCwgY29udGludWUgKi8KLQkJfQorCQlpZiAoIWVycikKKwkJCWJwLT5mbGFncyB8PSBCTlgyX0ZMQUdfQUVSX0VOQUJMRUQ7CiAKIAl9IGVsc2UgewogCQlicC0+cGNpeF9jYXAgPSBwY2lfZmluZF9jYXBhYmlsaXR5KHBkZXYsIFBDSV9DQVBfSURfUENJWCk7CkBAIC04MjI5LDggKzgyMzAsMTAgQEAKIAlyZXR1cm4gMDsKIAogZXJyX291dF91bm1hcDoKLQlpZiAoYnAtPmZsYWdzICYgQk5YMl9GTEFHX1BDSUUpCisJaWYgKGJwLT5mbGFncyAmIEJOWDJfRkxBR19BRVJfRU5BQkxFRCkgewogCQlwY2lfZGlzYWJsZV9wY2llX2Vycm9yX3JlcG9ydGluZyhwZGV2KTsKKwkJYnAtPmZsYWdzICY9IH5CTlgyX0ZMQUdfQUVSX0VOQUJMRUQ7CisJfQogCiAJaWYgKGJwLT5yZWd2aWV3KSB7CiAJCWlvdW5tYXAoYnAtPnJlZ3ZpZXcpOwpAQCAtODQxOCw4ICs4NDIxLDEwIEBACiAKIAlrZnJlZShicC0+dGVtcF9zdGF0c19ibGspOwogCi0JaWYgKGJwLT5mbGFncyAmIEJOWDJfRkxBR19QQ0lFKQorCWlmIChicC0+ZmxhZ3MgJiBCTlgyX0ZMQUdfQUVSX0VOQUJMRUQpIHsKIAkJcGNpX2Rpc2FibGVfcGNpZV9lcnJvcl9yZXBvcnRpbmcocGRldik7CisJCWJwLT5mbGFncyAmPSB+Qk5YMl9GTEFHX0FFUl9FTkFCTEVEOworCX0KIAogCWZyZWVfbmV0ZGV2KGRldik7CiAKQEAgLTg1MzUsNyArODU0MCw3IEBACiAJfQogCXJ0bmxfdW5sb2NrKCk7CiAKLQlpZiAoIShicC0+ZmxhZ3MgJiBCTlgyX0ZMQUdfUENJRSkpCisJaWYgKCEoYnAtPmZsYWdzICYgQk5YMl9GTEFHX0FFUl9FTkFCTEVEKSkKIAkJcmV0dXJuIHJlc3VsdDsKIAogCWVyciA9IHBjaV9jbGVhbnVwX2Flcl91bmNvcnJlY3RfZXJyb3Jfc3RhdHVzKHBkZXYpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYm54Mi5oIGIvZHJpdmVycy9uZXQvYm54Mi5oCmluZGV4IDU0ODhhMmU4Li5mNDU5ZmIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ibngyLmgKKysrIGIvZHJpdmVycy9uZXQvYm54Mi5oCkBAIC02NzQxLDYgKzY3NDEsNyBAQAogI2RlZmluZSBCTlgyX0ZMQUdfSlVNQk9fQlJPS0VOCQkweDAwMDAwODAwCiAjZGVmaW5lIEJOWDJfRkxBR19DQU5fS0VFUF9WTEFOCQkweDAwMDAxMDAwCiAjZGVmaW5lIEJOWDJfRkxBR19CUk9LRU5fU1RBVFMJCTB4MDAwMDIwMDAKKyNkZWZpbmUgQk5YMl9GTEFHX0FFUl9FTkFCTEVECQkweDAwMDA0MDAwCiAKIAlzdHJ1Y3QgYm54Ml9uYXBpCWJueDJfbmFwaVtCTlgyX01BWF9NU0lYX1ZFQ107CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2JueDJ4L2JueDJ4LmggYi9kcml2ZXJzL25ldC9ibngyeC9ibngyeC5oCmluZGV4IGE2Y2QzMzUuLjY1M2M2MjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JueDJ4L2JueDJ4LmgKKysrIGIvZHJpdmVycy9uZXQvYm54MngvYm54MnguaApAQCAtMjIsOCArMjIsOCBAQAogICogKHlvdSB3aWxsIG5lZWQgdG8gcmVib290IGFmdGVyd2FyZHMpICovCiAvKiAjZGVmaW5lIEJOWDJYX1NUT1BfT05fRVJST1IgKi8KIAotI2RlZmluZSBEUlZfTU9EVUxFX1ZFUlNJT04gICAgICAiMS42Mi4wMC0zIgotI2RlZmluZSBEUlZfTU9EVUxFX1JFTERBVEUgICAgICAiMjAxMC8xMi8yMSIKKyNkZWZpbmUgRFJWX01PRFVMRV9WRVJTSU9OICAgICAgIjEuNjIuMDAtNSIKKyNkZWZpbmUgRFJWX01PRFVMRV9SRUxEQVRFICAgICAgIjIwMTEvMDEvMzAiCiAjZGVmaW5lIEJOWDJYX0JDX1ZFUiAgICAgICAgICAgIDB4MDQwMjAwCiAKICNkZWZpbmUgQk5YMlhfTVVMVElfUVVFVUUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2JueDJ4L2JueDJ4X2hzaS5oIGIvZHJpdmVycy9uZXQvYm54MngvYm54MnhfaHNpLmgKaW5kZXggNjIzOGQ0Zi4uNTQ4ZjU2MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvYm54MngvYm54MnhfaHNpLmgKKysrIGIvZHJpdmVycy9uZXQvYm54MngvYm54MnhfaHNpLmgKQEAgLTM1Miw2ICszNTIsMTAgQEAKICNkZWZpbmUgUE9SVF9IV19DRkdfTEFORV9TV0FQX0NGR18zMTIwMzEyMAkgICAgMHgwMDAwZDhkOAogCS8qIGZvcmNlZCBvbmx5ICovCiAjZGVmaW5lIFBPUlRfSFdfQ0ZHX0xBTkVfU1dBUF9DRkdfMzIxMDMyMTAJICAgIDB4MDAwMGU0ZTQKKyAgICAvKglJbmRpY2F0ZSB3aGV0aGVyIHRvIHN3YXAgdGhlIGV4dGVybmFsIHBoeSBwb2xhcml0eSAqLworI2RlZmluZSBQT1JUX0hXX0NGR19TV0FQX1BIWV9QT0xBUklUWV9NQVNLCSAgICAgICAweDAwMDEwMDAwCisjZGVmaW5lIFBPUlRfSFdfQ0ZHX1NXQVBfUEhZX1BPTEFSSVRZX0RJU0FCTEVECSAgICAweDAwMDAwMDAwCisjZGVmaW5lIFBPUlRfSFdfQ0ZHX1NXQVBfUEhZX1BPTEFSSVRZX0VOQUJMRUQJICAgIDB4MDAwMTAwMDAKIAogCXUzMiBleHRlcm5hbF9waHlfY29uZmlnOwogI2RlZmluZSBQT1JUX0hXX0NGR19TRVJERVNfRVhUX1BIWV9UWVBFX01BU0sJICAgIDB4ZmYwMDAwMDAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2JueDJ4L2JueDJ4X2xpbmsuYyBiL2RyaXZlcnMvbmV0L2JueDJ4L2JueDJ4X2xpbmsuYwppbmRleCA0M2IwZGUyLi5kZDEyMTBmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ibngyeC9ibngyeF9saW5rLmMKKysrIGIvZHJpdmVycy9uZXQvYm54MngvYm54MnhfbGluay5jCkBAIC0xNTczLDcgKzE1NzMsNyBAQAogCiAJb2Zmc2V0ID0gcGh5LT5hZGRyICsgc2VyX2xhbmU7CiAJaWYgKENISVBfSVNfRTIoYnApKQotCQlhZXJfdmFsID0gMHgyODAwICsgb2Zmc2V0IC0gMTsKKwkJYWVyX3ZhbCA9IDB4MzgwMCArIG9mZnNldCAtIDE7CiAJZWxzZQogCQlhZXJfdmFsID0gMHgzODAwICsgb2Zmc2V0OwogCUNMNDVfV1JfT1ZFUl9DTDIyKGJwLCBwaHksCkBAIC0zMTY2LDcgKzMxNjYsMjMgQEAKIAkJaWYgKCF2YXJzLT5saW5rX3VwKQogCQkJYnJlYWs7CiAJY2FzZSBMRURfTU9ERV9PTjoKLQkJaWYgKFNJTkdMRV9NRURJQV9ESVJFQ1QocGFyYW1zKSkgeworCQlpZiAocGFyYW1zLT5waHlbRVhUX1BIWTFdLnR5cGUgPT0KKwkJICAgIFBPUlRfSFdfQ0ZHX1hHWFNfRVhUX1BIWV9UWVBFX0JDTTg3MjcgJiYKKwkJICAgIENISVBfSVNfRTIoYnApICYmIHBhcmFtcy0+bnVtX3BoeXMgPT0gMikgeworCQkJLyoqCisJCQkqIFRoaXMgaXMgYSB3b3JrLWFyb3VuZCBmb3IgRTIrODcyNyBDb25maWd1cmF0aW9ucworCQkJKi8KKwkJCWlmIChtb2RlID09IExFRF9NT0RFX09OIHx8CisJCQkJc3BlZWQgPT0gU1BFRURfMTAwMDApeworCQkJCVJFR19XUihicCwgTklHX1JFR19MRURfTU9ERV9QMCArIHBvcnQqNCwgMCk7CisJCQkJUkVHX1dSKGJwLCBOSUdfUkVHX0xFRF8xMEdfUDAgKyBwb3J0KjQsIDEpOworCisJCQkJdG1wID0gRU1BQ19SRChicCwgRU1BQ19SRUdfRU1BQ19MRUQpOworCQkJCUVNQUNfV1IoYnAsIEVNQUNfUkVHX0VNQUNfTEVELAorCQkJCQkodG1wIHwgRU1BQ19MRURfT1ZFUlJJREUpKTsKKwkJCQlyZXR1cm4gcmM7CisJCQl9CisJCX0gZWxzZSBpZiAoU0lOR0xFX01FRElBX0RJUkVDVChwYXJhbXMpKSB7CiAJCQkvKioKIAkJCSogVGhpcyBpcyBhIHdvcmstYXJvdW5kIGZvciBIVyBpc3N1ZSBmb3VuZCB3aGVuIGxpbmsKIAkJCSogaXMgdXAgaW4gQ0w3MwpAQCAtMzg1NCwxMSArMzg3MCwxNCBAQAogCQkJICAgcGF1c2VfcmVzdWx0KTsKIAl9CiB9Ci0KLXN0YXRpYyB2b2lkIGJueDJ4XzgwNzNfODcyN19leHRlcm5hbF9yb21fYm9vdChzdHJ1Y3QgYm54MnggKmJwLAorc3RhdGljIHU4IGJueDJ4XzgwNzNfODcyN19leHRlcm5hbF9yb21fYm9vdChzdHJ1Y3QgYm54MnggKmJwLAogCQkJCQkgICAgICBzdHJ1Y3QgYm54MnhfcGh5ICpwaHksCiAJCQkJCSAgICAgIHU4IHBvcnQpCiB7CisJdTMyIGNvdW50ID0gMDsKKwl1MTYgZndfdmVyMSwgZndfbXNnb3V0OworCXU4IHJjID0gMDsKKwogCS8qIEJvb3QgcG9ydCBmcm9tIGV4dGVybmFsIFJPTSAgKi8KIAkvKiBFREMgZ3JzdCAqLwogCWJueDJ4X2NsNDVfd3JpdGUoYnAsIHBoeSwKQEAgLTM4ODgsNTYgKzM5MDcsNDUgQEAKIAkJICAgICAgIE1ESU9fUE1BX1JFR19HRU5fQ1RSTCwKIAkJICAgICAgIE1ESU9fUE1BX1JFR19HRU5fQ1RSTF9ST01fUkVTRVRfSU5URVJOQUxfTVApOwogCi0JLyogd2FpdCBmb3IgMTIwbXMgZm9yIGNvZGUgZG93bmxvYWQgdmlhIFNQSSBwb3J0ICovCi0JbXNsZWVwKDEyMCk7CisJLyogRGVsYXkgMTAwbXMgcGVyIHRoZSBQSFkgc3BlY2lmaWNhdGlvbnMgKi8KKwltc2xlZXAoMTAwKTsKKworCS8qIDgwNzMgc29tZXRpbWVzIHRha2luZyBsb25nZXIgdG8gZG93bmxvYWQgKi8KKwlkbyB7CisJCWNvdW50Kys7CisJCWlmIChjb3VudCA+IDMwMCkgeworCQkJRFAoTkVUSUZfTVNHX0xJTkssCisJCQkJICJibngyeF84MDczXzg3MjdfZXh0ZXJuYWxfcm9tX2Jvb3QgcG9ydCAleDoiCisJCQkJICJEb3dubG9hZCBmYWlsZWQuIGZ3IHZlcnNpb24gPSAweCV4XG4iLAorCQkJCSBwb3J0LCBmd192ZXIxKTsKKwkJCXJjID0gLUVJTlZBTDsKKwkJCWJyZWFrOworCQl9CisKKwkJYm54MnhfY2w0NV9yZWFkKGJwLCBwaHksCisJCQkJTURJT19QTUFfREVWQUQsCisJCQkJTURJT19QTUFfUkVHX1JPTV9WRVIxLCAmZndfdmVyMSk7CisJCWJueDJ4X2NsNDVfcmVhZChicCwgcGh5LAorCQkJCU1ESU9fUE1BX0RFVkFELAorCQkJCU1ESU9fUE1BX1JFR19NODA1MV9NU0dPVVRfUkVHLCAmZndfbXNnb3V0KTsKKworCQltc2xlZXAoMSk7CisJfSB3aGlsZSAoZndfdmVyMSA9PSAwIHx8IGZ3X3ZlcjEgPT0gMHg0MzIxIHx8CisJCQkoKGZ3X21zZ291dCAmIDB4ZmYpICE9IDB4MDMgJiYgKHBoeS0+dHlwZSA9PQorCQkJUE9SVF9IV19DRkdfWEdYU19FWFRfUEhZX1RZUEVfQkNNODA3MykpKTsKIAogCS8qIENsZWFyIHNlcl9ib290X2N0bCBiaXQgKi8KIAlibngyeF9jbDQ1X3dyaXRlKGJwLCBwaHksCiAJCSAgICAgICBNRElPX1BNQV9ERVZBRCwKIAkJICAgICAgIE1ESU9fUE1BX1JFR19NSVNDX0NUUkwxLCAweDAwMDApOwogCWJueDJ4X3NhdmVfYmNtX3NwaXJvbV92ZXIoYnAsIHBoeSwgcG9ydCk7Ci19CiAKLXN0YXRpYyB2b2lkIGJueDJ4XzgwNzNfc2V0X3hhdWlfbG93X3Bvd2VyX21vZGUoc3RydWN0IGJueDJ4ICpicCwKLQkJCQkJICAgICAgIHN0cnVjdCBibngyeF9waHkgKnBoeSkKLXsKLQl1MTYgdmFsOwotCWJueDJ4X2NsNDVfcmVhZChicCwgcGh5LAotCQkJTURJT19QTUFfREVWQUQsIE1ESU9fUE1BX1JFR184MDczX0NISVBfUkVWLCAmdmFsKTsKKwlEUChORVRJRl9NU0dfTElOSywKKwkJICJibngyeF84MDczXzg3MjdfZXh0ZXJuYWxfcm9tX2Jvb3QgcG9ydCAleDoiCisJCSAiRG93bmxvYWQgY29tcGxldGUuIGZ3IHZlcnNpb24gPSAweCV4XG4iLAorCQkgcG9ydCwgZndfdmVyMSk7CiAKLQlpZiAodmFsID09IDApIHsKLQkJLyogTXVzdG4ndCBzZXQgbG93IHBvd2VyIG1vZGUgaW4gODA3MyBBMCAqLwotCQlyZXR1cm47Ci0JfQotCi0JLyogRGlzYWJsZSBQTEwgc2VxdWVuY2VyICh1c2UgcmVhZC1tb2RpZnktd3JpdGUgdG8gY2xlYXIgYml0IDEzKSAqLwotCWJueDJ4X2NsNDVfcmVhZChicCwgcGh5LAotCQkJTURJT19YU19ERVZBRCwgTURJT19YU19QTExfU0VRVUVOQ0VSLCAmdmFsKTsKLQl2YWwgJj0gfigxPDwxMyk7Ci0JYm54MnhfY2w0NV93cml0ZShicCwgcGh5LAotCQkgICAgICAgTURJT19YU19ERVZBRCwgTURJT19YU19QTExfU0VRVUVOQ0VSLCB2YWwpOwotCi0JLyogUExMIGNvbnRyb2xzICovCi0JYm54MnhfY2w0NV93cml0ZShicCwgcGh5LCBNRElPX1hTX0RFVkFELCAweDgwNUUsIDB4MTA3Nyk7Ci0JYm54MnhfY2w0NV93cml0ZShicCwgcGh5LCBNRElPX1hTX0RFVkFELCAweDgwNUQsIDB4MDAwMCk7Ci0JYm54MnhfY2w0NV93cml0ZShicCwgcGh5LCBNRElPX1hTX0RFVkFELCAweDgwNUMsIDB4MDMwQik7Ci0JYm54MnhfY2w0NV93cml0ZShicCwgcGh5LCBNRElPX1hTX0RFVkFELCAweDgwNUIsIDB4MTI0MCk7Ci0JYm54MnhfY2w0NV93cml0ZShicCwgcGh5LCBNRElPX1hTX0RFVkFELCAweDgwNUEsIDB4MjQ5MCk7Ci0KLQkvKiBUeCBDb250cm9scyAqLwotCWJueDJ4X2NsNDVfd3JpdGUoYnAsIHBoeSwgTURJT19YU19ERVZBRCwgMHg4MEE3LCAweDBDNzQpOwotCWJueDJ4X2NsNDVfd3JpdGUoYnAsIHBoeSwgTURJT19YU19ERVZBRCwgMHg4MEE2LCAweDkwNDEpOwotCWJueDJ4X2NsNDVfd3JpdGUoYnAsIHBoeSwgTURJT19YU19ERVZBRCwgMHg4MEE1LCAweDQ2NDApOwotCi0JLyogUnggQ29udHJvbHMgKi8KLQlibngyeF9jbDQ1X3dyaXRlKGJwLCBwaHksIE1ESU9fWFNfREVWQUQsIDB4ODBGRSwgMHgwMUM0KTsKLQlibngyeF9jbDQ1X3dyaXRlKGJwLCBwaHksIE1ESU9fWFNfREVWQUQsIDB4ODBGRCwgMHg5MjQ5KTsKLQlibngyeF9jbDQ1X3dyaXRlKGJwLCBwaHksIE1ESU9fWFNfREVWQUQsIDB4ODBGQywgMHgyMDE1KTsKLQotCS8qIEVuYWJsZSBQTEwgc2VxdWVuY2VyICAodXNlIHJlYWQtbW9kaWZ5LXdyaXRlIHRvIHNldCBiaXQgMTMpICovCi0JYm54MnhfY2w0NV9yZWFkKGJwLCBwaHksIE1ESU9fWFNfREVWQUQsIE1ESU9fWFNfUExMX1NFUVVFTkNFUiwgJnZhbCk7Ci0JdmFsIHw9ICgxPDwxMyk7Ci0JYm54MnhfY2w0NV93cml0ZShicCwgcGh5LCBNRElPX1hTX0RFVkFELCBNRElPX1hTX1BMTF9TRVFVRU5DRVIsIHZhbCk7CisJcmV0dXJuIHJjOwogfQogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwpAQCAtNDA5OCw4ICs0MTA2LDYgQEAKIAogCWJueDJ4XzgwNzNfc2V0X3BhdXNlX2NsMzcocGFyYW1zLCBwaHksIHZhcnMpOwogCi0JYm54MnhfODA3M19zZXRfeGF1aV9sb3dfcG93ZXJfbW9kZShicCwgcGh5KTsKLQogCWJueDJ4X2NsNDVfcmVhZChicCwgcGh5LAogCQkJTURJT19QTUFfREVWQUQsIE1ESU9fUE1BX1JFR19NODA1MV9NU0dPVVRfUkVHLCAmdG1wMSk7CiAKQEAgLTQxMDgsNiArNDExNCwyNSBAQAogCiAJRFAoTkVUSUZfTVNHX0xJTkssICJCZWZvcmUgcm9tIFJYX0FMQVJNKHBvcnQxKTogMHgleFxuIiwgdG1wMSk7CiAKKwkvKioKKwkgKiBJZiB0aGlzIGlzIGZvcmNlZCBzcGVlZCwgc2V0IHRvIEtSIG9yIEtYIChhbGwgb3RoZXIgYXJlIG5vdAorCSAqIHN1cHBvcnRlZCkKKwkgKi8KKwkvKiBTd2FwIHBvbGFyaXR5IGlmIHJlcXVpcmVkIC0gTXVzdCBiZSBkb25lIG9ubHkgaW4gbm9uLTFHIG1vZGUgKi8KKwlpZiAocGFyYW1zLT5sYW5lX2NvbmZpZyAmIFBPUlRfSFdfQ0ZHX1NXQVBfUEhZX1BPTEFSSVRZX0VOQUJMRUQpIHsKKwkJLyogQ29uZmlndXJlIHRoZSA4MDczIHRvIHN3YXAgX1AgYW5kIF9OIG9mIHRoZSBLUiBsaW5lcyAqLworCQlEUChORVRJRl9NU0dfTElOSywgIlN3YXBwaW5nIHBvbGFyaXR5IGZvciB0aGUgODA3M1xuIik7CisJCS8qIDEwRyBSeC9UeCBhbmQgMUcgVHggc2lnbmFsIHBvbGFyaXR5IHN3YXAgKi8KKwkJYm54MnhfY2w0NV9yZWFkKGJwLCBwaHksCisJCQkJTURJT19QTUFfREVWQUQsCisJCQkJTURJT19QTUFfUkVHXzgwNzNfT1BUX0RJR0lUQUxfQ1RSTCwgJnZhbCk7CisJCWJueDJ4X2NsNDVfd3JpdGUoYnAsIHBoeSwKKwkJCQkgTURJT19QTUFfREVWQUQsCisJCQkJIE1ESU9fUE1BX1JFR184MDczX09QVF9ESUdJVEFMX0NUUkwsCisJCQkJICh2YWwgfCAoMzw8OSkpKTsKKwl9CisKKwogCS8qIEVuYWJsZSBDTDM3IEJBTSAqLwogCWlmIChSRUdfUkQoYnAsIHBhcmFtcy0+c2htZW1fYmFzZSArCiAJCQkgb2Zmc2V0b2Yoc3RydWN0IHNobWVtX3JlZ2lvbiwgZGV2X2luZm8uCkBAIC00MzE0LDggKzQzMzksMzIgQEAKIAl9CiAKIAlpZiAobGlua191cCkgeworCQkvKiBTd2FwIHBvbGFyaXR5IGlmIHJlcXVpcmVkICovCisJCWlmIChwYXJhbXMtPmxhbmVfY29uZmlnICYKKwkJICAgIFBPUlRfSFdfQ0ZHX1NXQVBfUEhZX1BPTEFSSVRZX0VOQUJMRUQpIHsKKwkJCS8qIENvbmZpZ3VyZSB0aGUgODA3MyB0byBzd2FwIFAgYW5kIE4gb2YgdGhlIEtSIGxpbmVzICovCisJCQlibngyeF9jbDQ1X3JlYWQoYnAsIHBoeSwKKwkJCQkJTURJT19YU19ERVZBRCwKKwkJCQkJTURJT19YU19SRUdfODA3M19SWF9DVFJMX1BDSUUsICZ2YWwxKTsKKwkJCS8qKgorCQkJKiBTZXQgYml0IDMgdG8gaW52ZXJ0IFJ4IGluIDFHIG1vZGUgYW5kIGNsZWFyIHRoaXMgYml0CisJCQkqIHdoZW4gaXRgcyBpbiAxMEcgbW9kZS4KKwkJCSovCisJCQlpZiAodmFycy0+bGluZV9zcGVlZCA9PSBTUEVFRF8xMDAwKSB7CisJCQkJRFAoTkVUSUZfTVNHX0xJTkssICJTd2FwcGluZyAxRyBwb2xhcml0eSBmb3IiCisJCQkJCSAgICAgICJ0aGUgODA3M1xuIik7CisJCQkJdmFsMSB8PSAoMTw8Myk7CisJCQl9IGVsc2UKKwkJCQl2YWwxICY9IH4oMTw8Myk7CisKKwkJCWJueDJ4X2NsNDVfd3JpdGUoYnAsIHBoeSwKKwkJCQkJIE1ESU9fWFNfREVWQUQsCisJCQkJCSBNRElPX1hTX1JFR184MDczX1JYX0NUUkxfUENJRSwKKwkJCQkJIHZhbDEpOworCQl9CiAJCWJueDJ4X2V4dF9waHlfMTBHX2FuX3Jlc29sdmUoYnAsIHBoeSwgdmFycyk7CiAJCWJueDJ4XzgwNzNfcmVzb2x2ZV9mYyhwaHksIHBhcmFtcywgdmFycyk7CisJCXZhcnMtPmR1cGxleCA9IERVUExFWF9GVUxMOwogCX0KIAlyZXR1cm4gbGlua191cDsKIH0KQEAgLTUwNjIsNiArNTExMSw3IEBACiAJCWVsc2UKIAkJCXZhcnMtPmxpbmVfc3BlZWQgPSBTUEVFRF8xMDAwMDsKIAkJYm54MnhfZXh0X3BoeV9yZXNvbHZlX2ZjKHBoeSwgcGFyYW1zLCB2YXJzKTsKKwkJdmFycy0+ZHVwbGV4ID0gRFVQTEVYX0ZVTEw7CiAJfQogCXJldHVybiBsaW5rX3VwOwogfQpAQCAtNTc1OCw4ICs1ODA4LDExIEBACiAJCURQKE5FVElGX01TR19MSU5LLCAicG9ydCAleDogRXh0ZXJuYWwgbGluayBpcyBkb3duXG4iLAogCQkJICAgcGFyYW1zLT5wb3J0KTsKIAl9Ci0JaWYgKGxpbmtfdXApCisJaWYgKGxpbmtfdXApIHsKIAkJYm54MnhfZXh0X3BoeV9yZXNvbHZlX2ZjKHBoeSwgcGFyYW1zLCB2YXJzKTsKKwkJdmFycy0+ZHVwbGV4ID0gRFVQTEVYX0ZVTEw7CisJCURQKE5FVElGX01TR19MSU5LLCAiZHVwbGV4ID0gMHgleFxuIiwgdmFycy0+ZHVwbGV4KTsKKwl9CiAKIAlpZiAoKERVQUxfTUVESUEocGFyYW1zKSkgJiYKIAkgICAgKHBoeS0+cmVxX2xpbmVfc3BlZWQgPT0gU1BFRURfMTAwMCkpIHsKQEAgLTU4NzUsMTAgKzU5MjgsMjYgQEAKIAkJCSBNRElPX1BNQV9SRUdfODQ4MV9MRUQyX01BU0ssCiAJCQkgMHgxOCk7CiAKKwkvKiBTZWxlY3QgYWN0aXZpdHkgc291cmNlIGJ5IFR4IGFuZCBSeCwgYXMgc3VnZ2VzdGVkIGJ5IFBIWSBBRSAqLwogCWJueDJ4X2NsNDVfd3JpdGUoYnAsIHBoeSwKIAkJCSBNRElPX1BNQV9ERVZBRCwKIAkJCSBNRElPX1BNQV9SRUdfODQ4MV9MRUQzX01BU0ssCi0JCQkgMHgwMDQwKTsKKwkJCSAweDAwMDYpOworCisJLyogU2VsZWN0IHRoZSBjbG9zZXN0IGFjdGl2aXR5IGJsaW5rIHJhdGUgdG8gdGhhdCBpbiAxMC8xMDAvMTAwMCAqLworCWJueDJ4X2NsNDVfd3JpdGUoYnAsIHBoeSwKKwkJCU1ESU9fUE1BX0RFVkFELAorCQkJTURJT19QTUFfUkVHXzg0ODFfTEVEM19CTElOSywKKwkJCTApOworCisJYm54MnhfY2w0NV9yZWFkKGJwLCBwaHksCisJCQlNRElPX1BNQV9ERVZBRCwKKwkJCU1ESU9fUE1BX1JFR184NDgyM19DVExfTEVEX0NUTF8xLCAmdmFsKTsKKwl2YWwgfD0gTURJT19QTUFfUkVHXzg0ODIzX0xFRDNfU1RSRVRDSF9FTjsgLyogc3RyZXRjaF9lbiBmb3IgTEVEMyovCisKKwlibngyeF9jbDQ1X3dyaXRlKGJwLCBwaHksCisJCQkgTURJT19QTUFfREVWQUQsCisJCQkgTURJT19QTUFfUkVHXzg0ODIzX0NUTF9MRURfQ1RMXzEsIHZhbCk7CiAKIAkvKiAnSW50ZXJydXB0IE1hc2snICovCiAJYm54MnhfY2w0NV93cml0ZShicCwgcGh5LApAQCAtNjEyNiw2ICs2MTk1LDcgQEAKIAkvKiBDaGVjayBsaW5rIDEwRyAqLwogCWlmICh2YWwyICYgKDE8PDExKSkgewogCQl2YXJzLT5saW5lX3NwZWVkID0gU1BFRURfMTAwMDA7CisJCXZhcnMtPmR1cGxleCA9IERVUExFWF9GVUxMOwogCQlsaW5rX3VwID0gMTsKIAkJYm54MnhfZXh0X3BoeV8xMEdfYW5fcmVzb2x2ZShicCwgcGh5LCB2YXJzKTsKIAl9IGVsc2UgeyAvKiBDaGVjayBMZWdhY3kgc3BlZWQgbGluayAqLwpAQCAtNjQwNSw2ICs2NDc1LDE4IEBACiAJCQkJCSBNRElPX1BNQV9ERVZBRCwKIAkJCQkJIE1ESU9fUE1BX1JFR184NDgxX0xFRDFfTUFTSywKIAkJCQkJIDB4ODApOworCisJCQkvKiBUZWxsIExFRDMgdG8gYmxpbmsgb24gc291cmNlICovCisJCQlibngyeF9jbDQ1X3JlYWQoYnAsIHBoeSwKKwkJCQkJTURJT19QTUFfREVWQUQsCisJCQkJCU1ESU9fUE1BX1JFR184NDgxX0xJTktfU0lHTkFMLAorCQkJCQkmdmFsKTsKKwkJCXZhbCAmPSB+KDc8PDYpOworCQkJdmFsIHw9ICgxPDw2KTsgLyogQTgzQls4OjZdPSAxICovCisJCQlibngyeF9jbDQ1X3dyaXRlKGJwLCBwaHksCisJCQkJCSBNRElPX1BNQV9ERVZBRCwKKwkJCQkJIE1ESU9fUE1BX1JFR184NDgxX0xJTktfU0lHTkFMLAorCQkJCQkgdmFsKTsKIAkJfQogCQlicmVhazsKIAl9CkBAIC02NDg5LDYgKzY1NzEsNyBAQAogCQkJCU1ESU9fQU5fREVWQUQsIE1ESU9fQU5fUkVHX01BU1RFUl9TVEFUVVMsCiAJCQkJJnZhbDIpOwogCQl2YXJzLT5saW5lX3NwZWVkID0gU1BFRURfMTAwMDA7CisJCXZhcnMtPmR1cGxleCA9IERVUExFWF9GVUxMOwogCQlEUChORVRJRl9NU0dfTElOSywgIlNGWDcxMDEgQU4gc3RhdHVzIDB4JXgtPk1hc3Rlcj0leFxuIiwKIAkJCSAgIHZhbDIsICh2YWwyICYgKDE8PDE0KSkpOwogCQlibngyeF9leHRfcGh5XzEwR19hbl9yZXNvbHZlKGJwLCBwaHksIHZhcnMpOwpAQCAtNzYwNSwxMCArNzY4OCwxMyBAQAogCXN0cnVjdCBibngyeF9waHkgcGh5W1BPUlRfTUFYXTsKIAlzdHJ1Y3QgYm54MnhfcGh5ICpwaHlfYmxrW1BPUlRfTUFYXTsKIAl1MTYgdmFsOwotCXM4IHBvcnQ7CisJczggcG9ydCA9IDA7CiAJczggcG9ydF9vZl9wYXRoID0gMDsKLQotCWJueDJ4X2V4dF9waHlfaHdfcmVzZXQoYnAsIDApOworCXUzMiBzd2FwX3ZhbCwgc3dhcF9vdmVycmlkZTsKKwlzd2FwX3ZhbCA9IFJFR19SRChicCwgIE5JR19SRUdfUE9SVF9TV0FQKTsKKwlzd2FwX292ZXJyaWRlID0gUkVHX1JEKGJwLCAgTklHX1JFR19TVFJBUF9PVkVSUklERSk7CisJcG9ydCBePSAoc3dhcF92YWwgJiYgc3dhcF9vdmVycmlkZSk7CisJYm54MnhfZXh0X3BoeV9od19yZXNldChicCwgcG9ydCk7CiAJLyogUEFSVDEgLSBSZXNldCBib3RoIHBoeXMgKi8KIAlmb3IgKHBvcnQgPSBQT1JUX01BWCAtIDE7IHBvcnQgPj0gUE9SVF8wOyBwb3J0LS0pIHsKIAkJdTMyIHNobWVtX2Jhc2UsIHNobWVtMl9iYXNlOwpAQCAtNzY2Myw3ICs3NzQ5LDYgQEAKIAogCS8qIFBBUlQyIC0gRG93bmxvYWQgZmlybXdhcmUgdG8gYm90aCBwaHlzICovCiAJZm9yIChwb3J0ID0gUE9SVF9NQVggLSAxOyBwb3J0ID49IFBPUlRfMDsgcG9ydC0tKSB7Ci0JCXUxNiBmd192ZXIxOwogCQlpZiAoQ0hJUF9JU19FMihicCkpCiAJCQlwb3J0X29mX3BhdGggPSAwOwogCQllbHNlCkBAIC03NjcxLDE5ICs3NzU2LDkgQEAKIAogCQlEUChORVRJRl9NU0dfTElOSywgIkxvYWRpbmcgc3Bpcm9tIGZvciBwaHkgYWRkcmVzcyAweCV4XG4iLAogCQkJICAgcGh5X2Jsa1twb3J0XS0+YWRkcik7Ci0JCWJueDJ4XzgwNzNfODcyN19leHRlcm5hbF9yb21fYm9vdChicCwgcGh5X2Jsa1twb3J0XSwKLQkJCQkJCSAgcG9ydF9vZl9wYXRoKTsKLQotCQlibngyeF9jbDQ1X3JlYWQoYnAsIHBoeV9ibGtbcG9ydF0sCi0JCQkgICAgICBNRElPX1BNQV9ERVZBRCwKLQkJCSAgICAgIE1ESU9fUE1BX1JFR19ST01fVkVSMSwgJmZ3X3ZlcjEpOwotCQlpZiAoZndfdmVyMSA9PSAwIHx8IGZ3X3ZlcjEgPT0gMHg0MzIxKSB7Ci0JCQlEUChORVRJRl9NU0dfTElOSywKLQkJCQkgImJueDJ4XzgwNzNfY29tbW9uX2luaXRfcGh5IHBvcnQgJXg6IgotCQkJCSAiRG93bmxvYWQgZmFpbGVkLiBmdyB2ZXJzaW9uID0gMHgleFxuIiwKLQkJCQkgcG9ydCwgZndfdmVyMSk7CisJCWlmIChibngyeF84MDczXzg3MjdfZXh0ZXJuYWxfcm9tX2Jvb3QoYnAsIHBoeV9ibGtbcG9ydF0sCisJCQkJCQkgICAgICBwb3J0X29mX3BhdGgpKQogCQkJcmV0dXJuIC1FSU5WQUw7Ci0JCX0KIAogCQkvKiBPbmx5IHNldCBiaXQgMTAgPSAxIChUeCBwb3dlciBkb3duKSAqLwogCQlibngyeF9jbDQ1X3JlYWQoYnAsIHBoeV9ibGtbcG9ydF0sCkBAIC03ODQ4LDI3ICs3OTIzLDE3IEBACiAJfQogCS8qIFBBUlQyIC0gRG93bmxvYWQgZmlybXdhcmUgdG8gYm90aCBwaHlzICovCiAJZm9yIChwb3J0ID0gUE9SVF9NQVggLSAxOyBwb3J0ID49IFBPUlRfMDsgcG9ydC0tKSB7Ci0JCXUxNiBmd192ZXIxOwogCQkgaWYgKENISVBfSVNfRTIoYnApKQogCQkJcG9ydF9vZl9wYXRoID0gMDsKIAkJZWxzZQogCQkJcG9ydF9vZl9wYXRoID0gcG9ydDsKIAkJRFAoTkVUSUZfTVNHX0xJTkssICJMb2FkaW5nIHNwaXJvbSBmb3IgcGh5IGFkZHJlc3MgMHgleFxuIiwKIAkJCSAgIHBoeV9ibGtbcG9ydF0tPmFkZHIpOwotCQlibngyeF84MDczXzg3MjdfZXh0ZXJuYWxfcm9tX2Jvb3QoYnAsIHBoeV9ibGtbcG9ydF0sCi0JCQkJCQkgIHBvcnRfb2ZfcGF0aCk7Ci0JCWJueDJ4X2NsNDVfcmVhZChicCwgcGh5X2Jsa1twb3J0XSwKLQkJCSAgICAgIE1ESU9fUE1BX0RFVkFELAotCQkJICAgICAgTURJT19QTUFfUkVHX1JPTV9WRVIxLCAmZndfdmVyMSk7Ci0JCWlmIChmd192ZXIxID09IDAgfHwgZndfdmVyMSA9PSAweDQzMjEpIHsKLQkJCURQKE5FVElGX01TR19MSU5LLAotCQkJCSAiYm54MnhfODcyN19jb21tb25faW5pdF9waHkgcG9ydCAleDoiCi0JCQkJICJEb3dubG9hZCBmYWlsZWQuIGZ3IHZlcnNpb24gPSAweCV4XG4iLAotCQkJCSBwb3J0LCBmd192ZXIxKTsKKwkJaWYgKGJueDJ4XzgwNzNfODcyN19leHRlcm5hbF9yb21fYm9vdChicCwgcGh5X2Jsa1twb3J0XSwKKwkJCQkJCSAgICAgIHBvcnRfb2ZfcGF0aCkpCiAJCQlyZXR1cm4gLUVJTlZBTDsKLQkJfQotCX0KIAorCX0KIAlyZXR1cm4gMDsKIH0KIApAQCAtNzkxNiw2ICs3OTgxLDcgQEAKIAkJCSB1MzIgc2htZW0yX2Jhc2VfcGF0aFtdLCB1MzIgY2hpcF9pZCkKIHsKIAl1OCByYyA9IDA7CisJdTMyIHBoeV92ZXI7CiAJdTggcGh5X2luZGV4OwogCXUzMiBleHRfcGh5X3R5cGUsIGV4dF9waHlfY29uZmlnOwogCURQKE5FVElGX01TR19MSU5LLCAiQmVnaW4gY29tbW9uIHBoeSBpbml0XG4iKTsKQEAgLTc5MjMsNiArNzk4OSwxNiBAQAogCWlmIChDSElQX1JFVl9JU19FTVVMKGJwKSkKIAkJcmV0dXJuIDA7CiAKKwkvKiBDaGVjayBpZiBjb21tb24gaW5pdCB3YXMgYWxyZWFkeSBkb25lICovCisJcGh5X3ZlciA9IFJFR19SRChicCwgc2htZW1fYmFzZV9wYXRoWzBdICsKKwkJCSBvZmZzZXRvZihzdHJ1Y3Qgc2htZW1fcmVnaW9uLAorCQkJCSAgcG9ydF9tYltQT1JUXzBdLmV4dF9waHlfZndfdmVyc2lvbikpOworCWlmIChwaHlfdmVyKSB7CisJCURQKE5FVElGX01TR19MSU5LLCAiTm90IGRvaW5nIGNvbW1vbiBpbml0OyBwaHkgdmVyIGlzIDB4JXhcbiIsCisJCQkgICAgICAgcGh5X3Zlcik7CisJCXJldHVybiAwOworCX0KKwogCS8qIFJlYWQgdGhlIGV4dF9waHlfdHlwZSBmb3IgYXJiaXRyYXJ5IHBvcnQoMCkgKi8KIAlmb3IgKHBoeV9pbmRleCA9IEVYVF9QSFkxOyBwaHlfaW5kZXggPCBNQVhfUEhZUzsKIAkgICAgICBwaHlfaW5kZXgrKykgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYm54MngvYm54MnhfbWFpbi5jIGIvZHJpdmVycy9uZXQvYm54MngvYm54MnhfbWFpbi5jCmluZGV4IDhjZGNmNWIuLmQ1ODRkMzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JueDJ4L2JueDJ4X21haW4uYworKysgYi9kcml2ZXJzL25ldC9ibngyeC9ibngyeF9tYWluLmMKQEAgLTIzMDEsMTUgKzIzMDEsMTAgQEAKIAkJLyogYWNjZXB0IG1hdGNoZWQgdWNhc3QgKi8KIAkJZHJvcF9hbGxfdWNhc3QgPSAwOwogCX0KLQlpZiAoZmlsdGVycyAmIEJOWDJYX0FDQ0VQVF9NVUxUSUNBU1QpIHsKKwlpZiAoZmlsdGVycyAmIEJOWDJYX0FDQ0VQVF9NVUxUSUNBU1QpCiAJCS8qIGFjY2VwdCBtYXRjaGVkIG1jYXN0ICovCiAJCWRyb3BfYWxsX21jYXN0ID0gMDsKLQkJaWYgKElTX01GX1NJKGJwKSkKLQkJCS8qIHNpbmNlIG1jYXN0IGFkZHJlc3NlcyB3b24ndCBhcnJpdmUgd2l0aCBvdmxhbiwKLQkJCSAqIGZ3IG5lZWRzIHRvIGFjY2VwdCBhbGwgb2YgdGhlbSBpbgotCQkJICogc3dpdGNoLWluZGVwZW5kZW50IG1vZGUgKi8KLQkJCWFjY3BfYWxsX21jYXN0ID0gMTsKLQl9CisKIAlpZiAoZmlsdGVycyAmIEJOWDJYX0FDQ0VQVF9BTExfVU5JQ0FTVCkgewogCQkvKiBhY2NlcHQgYWxsIG1jYXN0ICovCiAJCWRyb3BfYWxsX3VjYXN0ID0gMDsKQEAgLTQyODEsOSArNDI3NiwxMiBAQAogCQlkZWZfcV9maWx0ZXJzIHw9IEJOWDJYX0FDQ0VQVF9VTklDQVNUIHwgQk5YMlhfQUNDRVBUX0JST0FEQ0FTVCB8CiAJCQkJQk5YMlhfQUNDRVBUX01VTFRJQ0FTVDsKICNpZmRlZiBCQ01fQ05JQwotCQljbF9pZCA9IGJueDJ4X2Zjb2UoYnAsIGNsX2lkKTsKLQkJYm54MnhfcnhxX3NldF9tYWNfZmlsdGVycyhicCwgY2xfaWQsIEJOWDJYX0FDQ0VQVF9VTklDQVNUIHwKLQkJCQkJICBCTlgyWF9BQ0NFUFRfTVVMVElDQVNUKTsKKwkJaWYgKCFOT19GQ09FKGJwKSkgeworCQkJY2xfaWQgPSBibngyeF9mY29lKGJwLCBjbF9pZCk7CisJCQlibngyeF9yeHFfc2V0X21hY19maWx0ZXJzKGJwLCBjbF9pZCwKKwkJCQkJCSAgQk5YMlhfQUNDRVBUX1VOSUNBU1QgfAorCQkJCQkJICBCTlgyWF9BQ0NFUFRfTVVMVElDQVNUKTsKKwkJfQogI2VuZGlmCiAJCWJyZWFrOwogCkBAIC00MjkxLDE4ICs0Mjg5LDI5IEBACiAJCWRlZl9xX2ZpbHRlcnMgfD0gQk5YMlhfQUNDRVBUX1VOSUNBU1QgfCBCTlgyWF9BQ0NFUFRfQlJPQURDQVNUIHwKIAkJCQlCTlgyWF9BQ0NFUFRfQUxMX01VTFRJQ0FTVDsKICNpZmRlZiBCQ01fQ05JQwotCQljbF9pZCA9IGJueDJ4X2Zjb2UoYnAsIGNsX2lkKTsKLQkJYm54MnhfcnhxX3NldF9tYWNfZmlsdGVycyhicCwgY2xfaWQsIEJOWDJYX0FDQ0VQVF9VTklDQVNUIHwKLQkJCQkJICBCTlgyWF9BQ0NFUFRfTVVMVElDQVNUKTsKKwkJLyoKKwkJICogIFByZXZlbnQgZHVwbGljYXRpb24gb2YgbXVsdGljYXN0IHBhY2tldHMgYnkgY29uZmlndXJpbmcgRkNvRQorCQkgKiAgTDIgQ2xpZW50IHRvIHJlY2VpdmUgb25seSBtYXRjaGVkIHVuaWNhc3QgZnJhbWVzLgorCQkgKi8KKwkJaWYgKCFOT19GQ09FKGJwKSkgeworCQkJY2xfaWQgPSBibngyeF9mY29lKGJwLCBjbF9pZCk7CisJCQlibngyeF9yeHFfc2V0X21hY19maWx0ZXJzKGJwLCBjbF9pZCwKKwkJCQkJCSAgQk5YMlhfQUNDRVBUX1VOSUNBU1QpOworCQl9CiAjZW5kaWYKIAkJYnJlYWs7CiAKIAljYXNlIEJOWDJYX1JYX01PREVfUFJPTUlTQzoKIAkJZGVmX3FfZmlsdGVycyB8PSBCTlgyWF9QUk9NSVNDVU9VU19NT0RFOwogI2lmZGVmIEJDTV9DTklDCi0JCWNsX2lkID0gYm54MnhfZmNvZShicCwgY2xfaWQpOwotCQlibngyeF9yeHFfc2V0X21hY19maWx0ZXJzKGJwLCBjbF9pZCwgQk5YMlhfQUNDRVBUX1VOSUNBU1QgfAotCQkJCQkgIEJOWDJYX0FDQ0VQVF9NVUxUSUNBU1QpOworCQkvKgorCQkgKiAgUHJldmVudCBwYWNrZXRzIGR1cGxpY2F0aW9uIGJ5IGNvbmZpZ3VyaW5nIERST1BfQUxMIGZvciBGQ29FCisJCSAqICBMMiBDbGllbnQuCisJCSAqLworCQlpZiAoIU5PX0ZDT0UoYnApKSB7CisJCQljbF9pZCA9IGJueDJ4X2Zjb2UoYnAsIGNsX2lkKTsKKwkJCWJueDJ4X3J4cV9zZXRfbWFjX2ZpbHRlcnMoYnAsIGNsX2lkLCBCTlgyWF9BQ0NFUFRfTk9ORSk7CisJCX0KICNlbmRpZgogCQkvKiBwYXNzIG1hbmFnZW1lbnQgdW5pY2FzdCBwYWNrZXRzIGFzIHdlbGwgKi8KIAkJbGxoX21hc2sgfD0gTklHX0xMSDBfQlJCMV9EUlZfTUFTS19SRUdfTExIMF9CUkIxX0RSVl9NQVNLX1VOQ1NUOwpAQCAtNTI5NiwxMCArNTMwNSw2IEBACiAJCX0KIAl9CiAKLQlicC0+cG9ydC5uZWVkX2h3X2xvY2sgPSBibngyeF9od19sb2NrX3JlcXVpcmVkKGJwLAotCQkJCQkJICAgICAgIGJwLT5jb21tb24uc2htZW1fYmFzZSwKLQkJCQkJCSAgICAgICBicC0+Y29tbW9uLnNobWVtMl9iYXNlKTsKLQogCWJueDJ4X3NldHVwX2Zhbl9mYWlsdXJlX2RldGVjdGlvbihicCk7CiAKIAkvKiBjbGVhciBQWFAyIGF0dGVudGlvbnMgKi8KQEAgLTU1MDMsOSArNTUwOCw2IEBACiAKIAlibngyeF9pbml0X2Jsb2NrKGJwLCBNQ1BfQkxPQ0ssIGluaXRfc3RhZ2UpOwogCWJueDJ4X2luaXRfYmxvY2soYnAsIERNQUVfQkxPQ0ssIGluaXRfc3RhZ2UpOwotCWJwLT5wb3J0Lm5lZWRfaHdfbG9jayA9IGJueDJ4X2h3X2xvY2tfcmVxdWlyZWQoYnAsCi0JCQkJCQkgICAgICAgYnAtPmNvbW1vbi5zaG1lbV9iYXNlLAotCQkJCQkJICAgICAgIGJwLT5jb21tb24uc2htZW0yX2Jhc2UpOwogCWlmIChibngyeF9mYW5fZmFpbHVyZV9kZXRfcmVxKGJwLCBicC0+Y29tbW9uLnNobWVtX2Jhc2UsCiAJCQkJICAgICAgYnAtPmNvbW1vbi5zaG1lbTJfYmFzZSwgcG9ydCkpIHsKIAkJdTMyIHJlZ19hZGRyID0gKHBvcnQgPyBNSVNDX1JFR19BRVVfRU5BQkxFMV9GVU5DXzFfT1VUXzAgOgpAQCAtODM3OSw2ICs4MzgxLDE3IEBACiAJCSAoZXh0X3BoeV90eXBlICE9IFBPUlRfSFdfQ0ZHX1hHWFNfRVhUX1BIWV9UWVBFX05PVF9DT05OKSkKIAkJYnAtPm1kaW8ucHJ0YWQgPQogCQkJWEdYU19FWFRfUEhZX0FERFIoZXh0X3BoeV9jb25maWcpOworCisJLyoKKwkgKiBDaGVjayBpZiBodyBsb2NrIGlzIHJlcXVpcmVkIHRvIGFjY2VzcyBNREMvTURJTyBidXMgdG8gdGhlIFBIWShzKQorCSAqIEluIE1GIG1vZGUsIGl0IGlzIHNldCB0byBjb3ZlciBzZWxmIHRlc3QgY2FzZXMKKwkgKi8KKwlpZiAoSVNfTUYoYnApKQorCQlicC0+cG9ydC5uZWVkX2h3X2xvY2sgPSAxOworCWVsc2UKKwkJYnAtPnBvcnQubmVlZF9od19sb2NrID0gYm54MnhfaHdfbG9ja19yZXF1aXJlZChicCwKKwkJCQkJCQlicC0+Y29tbW9uLnNobWVtX2Jhc2UsCisJCQkJCQkJYnAtPmNvbW1vbi5zaG1lbTJfYmFzZSk7CiB9CiAKIHN0YXRpYyB2b2lkIF9fZGV2aW5pdCBibngyeF9nZXRfbWFjX2h3aW5mbyhzdHJ1Y3QgYm54MnggKmJwKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYm54MngvYm54MnhfcmVnLmggYi9kcml2ZXJzL25ldC9ibngyeC9ibngyeF9yZWcuaAppbmRleCBjOTM5NjgzLi5lMDEzMzBiIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ibngyeC9ibngyeF9yZWcuaAorKysgYi9kcml2ZXJzL25ldC9ibngyeC9ibngyeF9yZWcuaApAQCAtNjE5NCw3ICs2MTk0LDExIEBACiAjZGVmaW5lIE1ESU9fQ1RMX1JFR184NDgyM19NRURJQV9QUklPUklUWV9DT1BQRVIJMHgwMDAwCiAjZGVmaW5lIE1ESU9fQ1RMX1JFR184NDgyM19NRURJQV9QUklPUklUWV9GSUJFUgkJMHgwMTAwCiAjZGVmaW5lIE1ESU9fQ1RMX1JFR184NDgyM19NRURJQV9GSUJFUl8xRwkJCTB4MTAwMAorI2RlZmluZSBNRElPX0NUTF9SRUdfODQ4MjNfVVNFUl9DVFJMX1JFRwkJMHg0MDA1CisjZGVmaW5lIE1ESU9fQ1RMX1JFR184NDgyM19VU0VSX0NUUkxfQ01TCQkweDAwODAKIAorI2RlZmluZSBNRElPX1BNQV9SRUdfODQ4MjNfQ1RMX0xFRF9DVExfMQkJMHhhOGUzCisjZGVmaW5lIE1ESU9fUE1BX1JFR184NDgyM19MRUQzX1NUUkVUQ0hfRU4JCTB4MDA4MAogCiAjZGVmaW5lIElHVV9GVU5DX0JBU0UJCQkweDA0MDAKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYm9uZGluZy9ib25kXzNhZC5jIGIvZHJpdmVycy9uZXQvYm9uZGluZy9ib25kXzNhZC5jCmluZGV4IDE3MTc4MmUuLjEwMjRhZTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JvbmRpbmcvYm9uZF8zYWQuYworKysgYi9kcml2ZXJzL25ldC9ib25kaW5nL2JvbmRfM2FkLmMKQEAgLTI0NzAsNiArMjQ3MCwxMCBAQAogCWlmICghKGRldi0+ZmxhZ3MgJiBJRkZfTUFTVEVSKSkKIAkJZ290byBvdXQ7CiAKKwlza2IgPSBza2Jfc2hhcmVfY2hlY2soc2tiLCBHRlBfQVRPTUlDKTsKKwlpZiAoIXNrYikKKwkJZ290byBvdXQ7CisKIAlpZiAoIXBza2JfbWF5X3B1bGwoc2tiLCBzaXplb2Yoc3RydWN0IGxhY3BkdSkpKQogCQlnb3RvIG91dDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYm9uZGluZy9ib25kX2FsYi5jIGIvZHJpdmVycy9uZXQvYm9uZGluZy9ib25kX2FsYi5jCmluZGV4IGY0ZTYzOGMuLjVjNmZiYTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JvbmRpbmcvYm9uZF9hbGIuYworKysgYi9kcml2ZXJzL25ldC9ib25kaW5nL2JvbmRfYWxiLmMKQEAgLTMyNiw2ICszMjYsMTAgQEAKIAkJZ290byBvdXQ7CiAJfQogCisJc2tiID0gc2tiX3NoYXJlX2NoZWNrKHNrYiwgR0ZQX0FUT01JQyk7CisJaWYgKCFza2IpCisJCWdvdG8gb3V0OworCiAJaWYgKCFwc2tiX21heV9wdWxsKHNrYiwgYXJwX2hkcl9sZW4oYm9uZF9kZXYpKSkKIAkJZ290byBvdXQ7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2JvbmRpbmcvYm9uZF9tYWluLmMgYi9kcml2ZXJzL25ldC9ib25kaW5nL2JvbmRfbWFpbi5jCmluZGV4IGIxMDI1YjguLjE2M2UwYjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JvbmRpbmcvYm9uZF9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvYm9uZGluZy9ib25kX21haW4uYwpAQCAtMjczMyw2ICsyNzMzLDEwIEBACiAJaWYgKCFzbGF2ZSB8fCAhc2xhdmVfZG9fYXJwX3ZhbGlkYXRlKGJvbmQsIHNsYXZlKSkKIAkJZ290byBvdXRfdW5sb2NrOwogCisJc2tiID0gc2tiX3NoYXJlX2NoZWNrKHNrYiwgR0ZQX0FUT01JQyk7CisJaWYgKCFza2IpCisJCWdvdG8gb3V0X3VubG9jazsKKwogCWlmICghcHNrYl9tYXlfcHVsbChza2IsIGFycF9oZHJfbGVuKGRldikpKQogCQlnb3RvIG91dF91bmxvY2s7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9LY29uZmlnIGIvZHJpdmVycy9uZXQvY2FuL0tjb25maWcKaW5kZXggZDVhOWRiNi4uNWRlYzQ1NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY2FuL0tjb25maWcKKysrIGIvZHJpdmVycy9uZXQvY2FuL0tjb25maWcKQEAgLTIzLDcgKzIzLDcgQEAKIAogCSAgQXMgb25seSB0aGUgc2VuZGluZyBhbmQgcmVjZWl2aW5nIG9mIENBTiBmcmFtZXMgaXMgaW1wbGVtZW50ZWQsIHRoaXMKIAkgIGRyaXZlciBzaG91bGQgd29yayB3aXRoIHRoZSAoc2VyaWFsL1VTQikgQ0FOIGhhcmR3YXJlIGZyb206Ci0JICB3d3cuY2FudXNiLmNvbSAvIHd3dy5jYW4yMzIuY29tIC8gd3d3Lm1pY3Ryb25pYy5jb20gLyB3d3cuY2FuaGFjay5kZQorCSAgd3d3LmNhbnVzYi5jb20gLyB3d3cuY2FuMjMyLmNvbSAvIHd3dy5taWN0cm9uaWNzLmRlIC8gd3d3LmNhbmhhY2suZGUKIAogCSAgVXNlcnNwYWNlIHRvb2xzIHRvIGF0dGFjaCB0aGUgU0xDQU4gbGluZSBkaXNjaXBsaW5lIChzbGNhbl9hdHRhY2gsCiAJICBzbGNhbmQpIGNhbiBiZSBmb3VuZCBpbiB0aGUgY2FuLXV0aWxzIGF0IHRoZSBTb2NrZXRDQU4gU1ZOLCBzZWUKQEAgLTExNyw2ICsxMTcsOCBAQAogCiBzb3VyY2UgImRyaXZlcnMvbmV0L2Nhbi91c2IvS2NvbmZpZyIKIAorc291cmNlICJkcml2ZXJzL25ldC9jYW4vc29mdGluZy9LY29uZmlnIgorCiBjb25maWcgQ0FOX0RFQlVHX0RFVklDRVMKIAlib29sICJDQU4gZGV2aWNlcyBkZWJ1Z2dpbmcgbWVzc2FnZXMiCiAJZGVwZW5kcyBvbiBDQU4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9NYWtlZmlsZSBiL2RyaXZlcnMvbmV0L2Nhbi9NYWtlZmlsZQppbmRleCAwN2NhMTU5Li41M2M4MmE3IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vTWFrZWZpbGUKKysrIGIvZHJpdmVycy9uZXQvY2FuL01ha2VmaWxlCkBAIC05LDYgKzksNyBAQAogY2FuLWRldi15CQkJOj0gZGV2Lm8KIAogb2JqLXkJCQkJKz0gdXNiLworb2JqLXkJCQkJKz0gc29mdGluZy8KIAogb2JqLSQoQ09ORklHX0NBTl9TSkExMDAwKQkrPSBzamExMDAwLwogb2JqLSQoQ09ORklHX0NBTl9NU0NBTikJCSs9IG1zY2FuLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FuL2F0OTFfY2FuLmMgYi9kcml2ZXJzL25ldC9jYW4vYXQ5MV9jYW4uYwppbmRleCA3ZWY4M2QwLi41N2QyZmZiIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vYXQ5MV9jYW4uYworKysgYi9kcml2ZXJzL25ldC9jYW4vYXQ5MV9jYW4uYwpAQCAtMiw3ICsyLDcgQEAKICAqIGF0OTFfY2FuLmMgLSBDQU4gbmV0d29yayBkcml2ZXIgZm9yIEFUOTEgU29DIENBTiBjb250cm9sbGVyCiAgKgogICogKEMpIDIwMDcgYnkgSGFucyBKLiBLb2NoIDxoamtAaGFuc2prb2NoLmRlPgotICogKEMpIDIwMDgsIDIwMDksIDIwMTAgYnkgTWFyYyBLbGVpbmUtQnVkZGUgPGtlcm5lbEBwZW5ndXRyb25peC5kZT4KKyAqIChDKSAyMDA4LCAyMDA5LCAyMDEwLCAyMDExIGJ5IE1hcmMgS2xlaW5lLUJ1ZGRlIDxrZXJuZWxAcGVuZ3V0cm9uaXguZGU+CiAgKgogICogVGhpcyBzb2Z0d2FyZSBtYXkgYmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbAogICogUHVibGljIExpY2Vuc2UgKCJHUEwiKSB2ZXJzaW9uIDIgYXMgZGlzdHJpYnV0ZWQgaW4gdGhlICdDT1BZSU5HJwpAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L25ldGRldmljZS5oPgogI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3J0bmV0bGluay5oPgogI2luY2x1ZGUgPGxpbnV4L3NrYnVmZi5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CkBAIC00MCwyMiArNDEsMjMgQEAKIAogI2luY2x1ZGUgPG1hY2gvYm9hcmQuaD4KIAotI2RlZmluZSBBVDkxX05BUElfV0VJR0hUCTEyCisjZGVmaW5lIEFUOTFfTkFQSV9XRUlHSFQJMTEKIAogLyoKICAqIFJYL1RYIE1haWxib3ggc3BsaXQKICAqIGRvbid0IGRhcmUgdG8gdG91Y2gKICAqLwotI2RlZmluZSBBVDkxX01CX1JYX05VTQkJMTIKKyNkZWZpbmUgQVQ5MV9NQl9SWF9OVU0JCTExCiAjZGVmaW5lIEFUOTFfTUJfVFhfU0hJRlQJMgogCi0jZGVmaW5lIEFUOTFfTUJfUlhfRklSU1QJMAorI2RlZmluZSBBVDkxX01CX1JYX0ZJUlNUCTEKICNkZWZpbmUgQVQ5MV9NQl9SWF9MQVNUCQkoQVQ5MV9NQl9SWF9GSVJTVCArIEFUOTFfTUJfUlhfTlVNIC0gMSkKIAogI2RlZmluZSBBVDkxX01CX1JYX01BU0soaSkJKCgxIDw8IChpKSkgLSAxKQogI2RlZmluZSBBVDkxX01CX1JYX1NQTElUCTgKICNkZWZpbmUgQVQ5MV9NQl9SWF9MT1dfTEFTVAkoQVQ5MV9NQl9SWF9TUExJVCAtIDEpCi0jZGVmaW5lIEFUOTFfTUJfUlhfTE9XX01BU0sJKEFUOTFfTUJfUlhfTUFTSyhBVDkxX01CX1JYX1NQTElUKSkKKyNkZWZpbmUgQVQ5MV9NQl9SWF9MT1dfTUFTSwkoQVQ5MV9NQl9SWF9NQVNLKEFUOTFfTUJfUlhfU1BMSVQpICYgXAorCQkJCSB+QVQ5MV9NQl9SWF9NQVNLKEFUOTFfTUJfUlhfRklSU1QpKQogCiAjZGVmaW5lIEFUOTFfTUJfVFhfTlVNCQkoMSA8PCBBVDkxX01CX1RYX1NISUZUKQogI2RlZmluZSBBVDkxX01CX1RYX0ZJUlNUCShBVDkxX01CX1JYX0xBU1QgKyAxKQpAQCAtMTY4LDYgKzE3MCw4IEBACiAKIAlzdHJ1Y3QgY2xrCQkqY2xrOwogCXN0cnVjdCBhdDkxX2Nhbl9kYXRhCSpwZGF0YTsKKworCWNhbmlkX3QJCQltYjBfaWQ7CiB9OwogCiBzdGF0aWMgc3RydWN0IGNhbl9iaXR0aW1pbmdfY29uc3QgYXQ5MV9iaXR0aW1pbmdfY29uc3QgPSB7CkBAIC0yMjAsNiArMjI0LDE4IEBACiAJc2V0X21iX21vZGVfcHJpbyhwcml2LCBtYiwgbW9kZSwgMCk7CiB9CiAKK3N0YXRpYyBpbmxpbmUgdTMyIGF0OTFfY2FuX2lkX3RvX3JlZ19taWQoY2FuaWRfdCBjYW5faWQpCit7CisJdTMyIHJlZ19taWQ7CisKKwlpZiAoY2FuX2lkICYgQ0FOX0VGRl9GTEFHKQorCQlyZWdfbWlkID0gKGNhbl9pZCAmIENBTl9FRkZfTUFTSykgfCBBVDkxX01JRF9NSURFOworCWVsc2UKKwkJcmVnX21pZCA9IChjYW5faWQgJiBDQU5fU0ZGX01BU0spIDw8IDE4OworCisJcmV0dXJuIHJlZ19taWQ7Cit9CisKIC8qCiAgKiBTd3RpY2ggdHJhbnNjZWl2ZXIgb24gb3Igb2ZmCiAgKi8KQEAgLTIzMywxMiArMjQ5LDIyIEBACiB7CiAJc3RydWN0IGF0OTFfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CiAJdW5zaWduZWQgaW50IGk7CisJdTMyIHJlZ19taWQ7CiAKIAkvKgotCSAqIFRoZSBmaXJzdCAxMiBtYWlsYm94ZXMgYXJlIHVzZWQgYXMgYSByZWNlcHRpb24gRklGTy4gVGhlCi0JICogbGFzdCBtYWlsYm94IGlzIGNvbmZpZ3VyZWQgd2l0aCBvdmVyd3JpdGUgb3B0aW9uLiBUaGUKLQkgKiBvdmVyd3JpdGUgZmxhZyBpbmRpY2F0ZXMgYSBGSUZPIG92ZXJmbG93LgorCSAqIER1ZSB0byBhIGNoaXAgYnVnIChlcnJhdGEgNTAuMi42LjMgJiA1MC4zLjUuMykgdGhlIGZpcnN0CisJICogbWFpbGJveCBpcyBkaXNhYmxlZC4gVGhlIG5leHQgMTEgbWFpbGJveGVzIGFyZSB1c2VkIGFzIGEKKwkgKiByZWNlcHRpb24gRklGTy4gVGhlIGxhc3QgbWFpbGJveCBpcyBjb25maWd1cmVkIHdpdGgKKwkgKiBvdmVyd3JpdGUgb3B0aW9uLiBUaGUgb3ZlcndyaXRlIGZsYWcgaW5kaWNhdGVzIGEgRklGTworCSAqIG92ZXJmbG93LgogCSAqLworCXJlZ19taWQgPSBhdDkxX2Nhbl9pZF90b19yZWdfbWlkKHByaXYtPm1iMF9pZCk7CisJZm9yIChpID0gMDsgaSA8IEFUOTFfTUJfUlhfRklSU1Q7IGkrKykgeworCQlzZXRfbWJfbW9kZShwcml2LCBpLCBBVDkxX01CX01PREVfRElTQUJMRUQpOworCQlhdDkxX3dyaXRlKHByaXYsIEFUOTFfTUlEKGkpLCByZWdfbWlkKTsKKwkJYXQ5MV93cml0ZShwcml2LCBBVDkxX01DUihpKSwgMHgwKTsJLyogY2xlYXIgZGxjICovCisJfQorCiAJZm9yIChpID0gQVQ5MV9NQl9SWF9GSVJTVDsgaSA8IEFUOTFfTUJfUlhfTEFTVDsgaSsrKQogCQlzZXRfbWJfbW9kZShwcml2LCBpLCBBVDkxX01CX01PREVfUlgpOwogCXNldF9tYl9tb2RlKHByaXYsIEFUOTFfTUJfUlhfTEFTVCwgQVQ5MV9NQl9NT0RFX1JYX09WUldSKTsKQEAgLTI1NCw3ICsyODAsOCBAQAogCQlzZXRfbWJfbW9kZV9wcmlvKHByaXYsIGksIEFUOTFfTUJfTU9ERV9UWCwgMCk7CiAKIAkvKiBSZXNldCB0eCBhbmQgcnggaGVscGVyIHBvaW50ZXJzICovCi0JcHJpdi0+dHhfbmV4dCA9IHByaXYtPnR4X2VjaG8gPSBwcml2LT5yeF9uZXh0ID0gMDsKKwlwcml2LT50eF9uZXh0ID0gcHJpdi0+dHhfZWNobyA9IDA7CisJcHJpdi0+cnhfbmV4dCA9IEFUOTFfTUJfUlhfRklSU1Q7CiB9CiAKIHN0YXRpYyBpbnQgYXQ5MV9zZXRfYml0dGltaW5nKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCkBAIC0zNzIsMTIgKzM5OSw3IEBACiAJCW5ldGRldl9lcnIoZGV2LCAiQlVHISBUWCBidWZmZXIgZnVsbCB3aGVuIHF1ZXVlIGF3YWtlIVxuIik7CiAJCXJldHVybiBORVRERVZfVFhfQlVTWTsKIAl9Ci0KLQlpZiAoY2YtPmNhbl9pZCAmIENBTl9FRkZfRkxBRykKLQkJcmVnX21pZCA9IChjZi0+Y2FuX2lkICYgQ0FOX0VGRl9NQVNLKSB8IEFUOTFfTUlEX01JREU7Ci0JZWxzZQotCQlyZWdfbWlkID0gKGNmLT5jYW5faWQgJiBDQU5fU0ZGX01BU0spIDw8IDE4OwotCisJcmVnX21pZCA9IGF0OTFfY2FuX2lkX3RvX3JlZ19taWQoY2YtPmNhbl9pZCk7CiAJcmVnX21jciA9ICgoY2YtPmNhbl9pZCAmIENBTl9SVFJfRkxBRykgPyBBVDkxX01DUl9NUlRSIDogMCkgfAogCQkoY2YtPmNhbl9kbGMgPDwgMTYpIHwgQVQ5MV9NQ1JfTVRDUjsKIApAQCAtNTM5LDI3ICs1NjEsMzEgQEAKICAqCiAgKiBUaGVvcnkgb2YgT3BlcmF0aW9uOgogICoKLSAqIDEyIG9mIHRoZSAxNiBtYWlsYm94ZXMgb24gdGhlIGNoaXAgYXJlIHJlc2VydmVkIGZvciBSWC4gd2Ugc3BsaXQKLSAqIHRoZW0gaW50byAyIGdyb3Vwcy4gVGhlIGxvd2VyIGdyb3VwIGhvbGRzIDggYW5kIHVwcGVyIDQgbWFpbGJveGVzLgorICogMTEgb2YgdGhlIDE2IG1haWxib3hlcyBvbiB0aGUgY2hpcCBhcmUgcmVzZXJ2ZWQgZm9yIFJYLiB3ZSBzcGxpdAorICogdGhlbSBpbnRvIDIgZ3JvdXBzLiBUaGUgbG93ZXIgZ3JvdXAgaG9sZHMgNyBhbmQgdXBwZXIgNCBtYWlsYm94ZXMuCiAgKgogICogTGlrZSBpdCBvciBub3QsIGJ1dCB0aGUgY2hpcCBhbHdheXMgc2F2ZXMgYSByZWNlaXZlZCBDQU4gbWVzc2FnZQogICogaW50byB0aGUgZmlyc3QgZnJlZSBtYWlsYm94IGl0IGZpbmRzIChzdGFydGluZyB3aXRoIHRoZQogICogbG93ZXN0KS4gVGhpcyBtYWtlcyBpdCB2ZXJ5IGRpZmZpY3VsdCB0byByZWFkIHRoZSBtZXNzYWdlcyBpbiB0aGUKICAqIHJpZ2h0IG9yZGVyIGZyb20gdGhlIGNoaXAuIFRoaXMgaXMgaG93IHdlIHdvcmsgYXJvdW5kIHRoYXQgcHJvYmxlbToKICAqCi0gKiBUaGUgZmlyc3QgbWVzc2FnZSBnb2VzIGludG8gbWIgbnIuIDAgYW5kIGlzc3VlcyBhbiBpbnRlcnJ1cHQuIEFsbAorICogVGhlIGZpcnN0IG1lc3NhZ2UgZ29lcyBpbnRvIG1iIG5yLiAxIGFuZCBpc3N1ZXMgYW4gaW50ZXJydXB0LiBBbGwKICAqIHJ4IGludHMgYXJlIGRpc2FibGVkIGluIHRoZSBpbnRlcnJ1cHQgaGFuZGxlciBhbmQgYSBuYXBpIHBvbGwgaXMKICAqIHNjaGVkdWxlZC4gV2UgcmVhZCB0aGUgbWFpbGJveCwgYnV0IGRvIF9ub3RfIHJlZW5hYmxlIHRoZSBtYiAodG8KICAqIHJlY2VpdmUgYW5vdGhlciBtZXNzYWdlKS4KICAqCiAgKiAgICBsb3dlciBtYnhzICAgICAgdXBwZXIKLSAqICAgX19fX19fXl9fX19fXyAgICBfX15fXwotICogIC8gICAgICAgICAgICAgXCAgLyAgICAgXAorICogICAgIF9fX19eX19fX19fICAgIF9fXl9fCisgKiAgICAvICAgICAgICAgICBcICAvICAgICBcCiAgKiArLSstKy0rLSstKy0rLSstKystKy0rLSstKwotICogfHh8eHx4fHh8eHx4fHh8eHx8IHwgfCB8IHwKKyAqIHwgfHh8eHx4fHh8eHx4fHh8fCB8IHwgfCB8CiAgKiArLSstKy0rLSstKy0rLSstKystKy0rLSstKwogICogIDAgMCAwIDAgMCAwICAwIDAgMCAwIDEgMSAgXCBtYWlsCiAgKiAgMCAxIDIgMyA0IDUgIDYgNyA4IDkgMCAxICAvIGJveAorICogIF4KKyAqICB8CisgKiAgIFwKKyAqICAgICB1bnVzZWQsIGR1ZSB0byBjaGlwIGJ1ZwogICoKICAqIFRoZSB2YXJpYWJsZSBwcml2LT5yeF9uZXh0IHBvaW50cyB0byB0aGUgbmV4dCBtYWlsYm94IHRvIHJlYWQgYQogICogbWVzc2FnZSBmcm9tLiBBcyBsb25nIHdlJ3JlIGluIHRoZSBsb3dlciBtYWlsYm94ZXMgd2UganVzdCByZWFkIHRoZQpAQCAtNTkwLDEwICs2MTYsMTAgQEAKIAkJCSJvcmRlciBvZiBpbmNvbWluZyBmcmFtZXMgY2Fubm90IGJlIGd1YXJhbnRlZWRcbiIpOwogCiAgYWdhaW46Ci0JZm9yIChtYiA9IGZpbmRfbmV4dF9iaXQoYWRkciwgQVQ5MV9NQl9SWF9OVU0sIHByaXYtPnJ4X25leHQpOwotCSAgICAgbWIgPCBBVDkxX01CX1JYX05VTSAmJiBxdW90YSA+IDA7CisJZm9yIChtYiA9IGZpbmRfbmV4dF9iaXQoYWRkciwgQVQ5MV9NQl9SWF9MQVNUICsgMSwgcHJpdi0+cnhfbmV4dCk7CisJICAgICBtYiA8IEFUOTFfTUJfUlhfTEFTVCArIDEgJiYgcXVvdGEgPiAwOwogCSAgICAgcmVnX3NyID0gYXQ5MV9yZWFkKHByaXYsIEFUOTFfU1IpLAotCSAgICAgbWIgPSBmaW5kX25leHRfYml0KGFkZHIsIEFUOTFfTUJfUlhfTlVNLCArK3ByaXYtPnJ4X25leHQpKSB7CisJICAgICBtYiA9IGZpbmRfbmV4dF9iaXQoYWRkciwgQVQ5MV9NQl9SWF9MQVNUICsgMSwgKytwcml2LT5yeF9uZXh0KSkgewogCQlhdDkxX3JlYWRfbXNnKGRldiwgbWIpOwogCiAJCS8qIHJlYWN0aXZhdGUgbWFpbGJveGVzICovCkBAIC02MTAsOCArNjM2LDggQEAKIAogCS8qIHVwcGVyIGdyb3VwIGNvbXBsZXRlZCwgbG9vayBhZ2FpbiBpbiBsb3dlciAqLwogCWlmIChwcml2LT5yeF9uZXh0ID4gQVQ5MV9NQl9SWF9MT1dfTEFTVCAmJgotCSAgICBxdW90YSA+IDAgJiYgbWIgPj0gQVQ5MV9NQl9SWF9OVU0pIHsKLQkJcHJpdi0+cnhfbmV4dCA9IDA7CisJICAgIHF1b3RhID4gMCAmJiBtYiA+IEFUOTFfTUJfUlhfTEFTVCkgeworCQlwcml2LT5yeF9uZXh0ID0gQVQ5MV9NQl9SWF9GSVJTVDsKIAkJZ290byBhZ2FpbjsKIAl9CiAKQEAgLTEwMzcsNiArMTA2Myw2NCBAQAogCS5uZG9fc3RhcnRfeG1pdAk9IGF0OTFfc3RhcnRfeG1pdCwKIH07CiAKK3N0YXRpYyBzc2l6ZV90IGF0OTFfc3lzZnNfc2hvd19tYjBfaWQoc3RydWN0IGRldmljZSAqZGV2LAorCQlzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQoreworCXN0cnVjdCBhdDkxX3ByaXYgKnByaXYgPSBuZXRkZXZfcHJpdih0b19uZXRfZGV2KGRldikpOworCisJaWYgKHByaXYtPm1iMF9pZCAmIENBTl9FRkZfRkxBRykKKwkJcmV0dXJuIHNucHJpbnRmKGJ1ZiwgUEFHRV9TSVpFLCAiMHglMDh4XG4iLCBwcml2LT5tYjBfaWQpOworCWVsc2UKKwkJcmV0dXJuIHNucHJpbnRmKGJ1ZiwgUEFHRV9TSVpFLCAiMHglMDN4XG4iLCBwcml2LT5tYjBfaWQpOworfQorCitzdGF0aWMgc3NpemVfdCBhdDkxX3N5c2ZzX3NldF9tYjBfaWQoc3RydWN0IGRldmljZSAqZGV2LAorCQlzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7CisJc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYgPSB0b19uZXRfZGV2KGRldik7CisJc3RydWN0IGF0OTFfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KG5kZXYpOworCXVuc2lnbmVkIGxvbmcgY2FuX2lkOworCXNzaXplX3QgcmV0OworCWludCBlcnI7CisKKwlydG5sX2xvY2soKTsKKworCWlmIChuZGV2LT5mbGFncyAmIElGRl9VUCkgeworCQlyZXQgPSAtRUJVU1k7CisJCWdvdG8gb3V0OworCX0KKworCWVyciA9IHN0cmljdF9zdHJ0b3VsKGJ1ZiwgMCwgJmNhbl9pZCk7CisJaWYgKGVycikgeworCQlyZXQgPSBlcnI7CisJCWdvdG8gb3V0OworCX0KKworCWlmIChjYW5faWQgJiBDQU5fRUZGX0ZMQUcpCisJCWNhbl9pZCAmPSBDQU5fRUZGX01BU0sgfCBDQU5fRUZGX0ZMQUc7CisJZWxzZQorCQljYW5faWQgJj0gQ0FOX1NGRl9NQVNLOworCisJcHJpdi0+bWIwX2lkID0gY2FuX2lkOworCXJldCA9IGNvdW50OworCisgb3V0OgorCXJ0bmxfdW5sb2NrKCk7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIERFVklDRV9BVFRSKG1iMF9pZCwgU19JV1VTUiB8IFNfSVJVR08sCisJYXQ5MV9zeXNmc19zaG93X21iMF9pZCwgYXQ5MV9zeXNmc19zZXRfbWIwX2lkKTsKKworc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKmF0OTFfc3lzZnNfYXR0cnNbXSA9IHsKKwkmZGV2X2F0dHJfbWIwX2lkLmF0dHIsCisJTlVMTCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwIGF0OTFfc3lzZnNfYXR0cl9ncm91cCA9IHsKKwkuYXR0cnMgPSBhdDkxX3N5c2ZzX2F0dHJzLAorfTsKKwogc3RhdGljIGludCBfX2RldmluaXQgYXQ5MV9jYW5fcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIHsKIAlzdHJ1Y3QgbmV0X2RldmljZSAqZGV2OwpAQCAtMTA4Miw2ICsxMTY2LDcgQEAKIAlkZXYtPm5ldGRldl9vcHMJPSAmYXQ5MV9uZXRkZXZfb3BzOwogCWRldi0+aXJxID0gaXJxOwogCWRldi0+ZmxhZ3MgfD0gSUZGX0VDSE87CisJZGV2LT5zeXNmc19ncm91cHNbMF0gPSAmYXQ5MV9zeXNmc19hdHRyX2dyb3VwOwogCiAJcHJpdiA9IG5ldGRldl9wcml2KGRldik7CiAJcHJpdi0+Y2FuLmNsb2NrLmZyZXEgPSBjbGtfZ2V0X3JhdGUoY2xrKTsKQEAgLTEwOTMsNiArMTE3OCw3IEBACiAJcHJpdi0+ZGV2ID0gZGV2OwogCXByaXYtPmNsayA9IGNsazsKIAlwcml2LT5wZGF0YSA9IHBkZXYtPmRldi5wbGF0Zm9ybV9kYXRhOworCXByaXYtPm1iMF9pZCA9IDB4N2ZmOwogCiAJbmV0aWZfbmFwaV9hZGQoZGV2LCAmcHJpdi0+bmFwaSwgYXQ5MV9wb2xsLCBBVDkxX05BUElfV0VJR0hUKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FuL2phbnotaWNhbjMuYyBiL2RyaXZlcnMvbmV0L2Nhbi9qYW56LWljYW4zLmMKaW5kZXggYjlhNmQ3YS4uMzY2ZjVjYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY2FuL2phbnotaWNhbjMuYworKysgYi9kcml2ZXJzL25ldC9jYW4vamFuei1pY2FuMy5jCkBAIC0xNjE4LDcgKzE2MTgsNyBAQAogCXJldHVybiBjb3VudDsKIH0KIAotc3RhdGljIERFVklDRV9BVFRSKHRlcm1pbmF0aW9uLCBTX0lXVUdPIHwgU19JUlVHTywgaWNhbjNfc3lzZnNfc2hvd190ZXJtLAorc3RhdGljIERFVklDRV9BVFRSKHRlcm1pbmF0aW9uLCBTX0lXVVNSIHwgU19JUlVHTywgaWNhbjNfc3lzZnNfc2hvd190ZXJtLAogCQkJCQkJICAgaWNhbjNfc3lzZnNfc2V0X3Rlcm0pOwogCiBzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSAqaWNhbjNfc3lzZnNfYXR0cnNbXSA9IHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9wY2hfY2FuLmMgYi9kcml2ZXJzL25ldC9jYW4vcGNoX2Nhbi5jCmluZGV4IGM0MmU5NzIuLmU1NDcxMmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2Nhbi9wY2hfY2FuLmMKKysrIGIvZHJpdmVycy9uZXQvY2FuL3BjaF9jYW4uYwpAQCAtMTg1LDcgKzE4NSw3IEBACiAKIHN0YXRpYyBzdHJ1Y3QgY2FuX2JpdHRpbWluZ19jb25zdCBwY2hfY2FuX2JpdHRpbWluZ19jb25zdCA9IHsKIAkubmFtZSA9IEtCVUlMRF9NT0ROQU1FLAotCS50c2VnMV9taW4gPSAxLAorCS50c2VnMV9taW4gPSAyLAogCS50c2VnMV9tYXggPSAxNiwKIAkudHNlZzJfbWluID0gMSwKIAkudHNlZzJfbWF4ID0gOCwKQEAgLTk1OSwxMyArOTU5LDEzIEBACiAJc3RydWN0IHBjaF9jYW5fcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KG5kZXYpOwogCiAJdW5yZWdpc3Rlcl9jYW5kZXYocHJpdi0+bmRldik7Ci0JcGNpX2lvdW5tYXAocGRldiwgcHJpdi0+cmVncyk7CiAJaWYgKHByaXYtPnVzZV9tc2kpCiAJCXBjaV9kaXNhYmxlX21zaShwcml2LT5kZXYpOwogCXBjaV9yZWxlYXNlX3JlZ2lvbnMocGRldik7CiAJcGNpX2Rpc2FibGVfZGV2aWNlKHBkZXYpOwogCXBjaV9zZXRfZHJ2ZGF0YShwZGV2LCBOVUxMKTsKIAlwY2hfY2FuX3Jlc2V0KHByaXYpOworCXBjaV9pb3VubWFwKHBkZXYsIHByaXYtPnJlZ3MpOwogCWZyZWVfY2FuZGV2KHByaXYtPm5kZXYpOwogfQogCkBAIC0xMjM4LDYgKzEyMzgsNyBAQAogCQlwcml2LT51c2VfbXNpID0gMDsKIAl9IGVsc2UgewogCQluZXRkZXZfZXJyKG5kZXYsICJQQ0ggQ0FOIG9wZW5lZCB3aXRoIE1TSVxuIik7CisJCXBjaV9zZXRfbWFzdGVyKHBkZXYpOwogCQlwcml2LT51c2VfbXNpID0gMTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9zb2Z0aW5nL0tjb25maWcgYi9kcml2ZXJzL25ldC9jYW4vc29mdGluZy9LY29uZmlnCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjhiYTgxYjMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL25ldC9jYW4vc29mdGluZy9LY29uZmlnCkBAIC0wLDAgKzEsMzAgQEAKK2NvbmZpZyBDQU5fU09GVElORworCXRyaXN0YXRlICJTb2Z0aW5nIEdtYmggQ0FOIGdlbmVyaWMgc3VwcG9ydCIKKwlkZXBlbmRzIG9uIENBTl9ERVYgJiYgSEFTX0lPTUVNCisJLS0taGVscC0tLQorCSAgU3VwcG9ydCBmb3IgQ0FOIGNhcmRzIGZyb20gU29mdGluZyBHbWJoICYgc29tZSBjYXJkcworCSAgZnJvbSBWZWN0b3IgR21iaC4KKwkgIFNvZnRpbmcgR21iaCBDQU4gY2FyZHMgY29tZSB3aXRoIDEgb3IgMiBwaHlzaWNhbCBidXNzZXMuCisJICBUaG9zZSBjYXJkcyB0eXBpY2FsbHkgdXNlIER1YWwgUG9ydCBSQU0gdG8gY29tbXVuaWNhdGUKKwkgIHdpdGggdGhlIGhvc3QgQ1BVLiBUaGUgaW50ZXJmYWNlIGlzIHRoZW4gaWRlbnRpY2FsIGZvciBQQ0kKKwkgIGFuZCBQQ01DSUEgY2FyZHMuIFRoaXMgZHJpdmVyIG9wZXJhdGVzIG9uIGEgcGxhdGZvcm0gZGV2aWNlLAorCSAgd2hpY2ggaGFzIGJlZW4gY3JlYXRlZCBieSBzb2Z0aW5nX2NzIG9yIHNvZnRpbmdfcGNpIGRyaXZlci4KKwkgIFdhcm5pbmc6CisJICBUaGUgQVBJIG9mIHRoZSBjYXJkIGRvZXMgbm90IGFsbG93IGZpbmUgY29udHJvbCBwZXIgYnVzLCBidXQKKwkgIGNvbnRyb2xzIHRoZSAyIGJ1c3NlcyBvbiB0aGUgY2FyZCB0b2dldGhlci4KKwkgIEFzIHN1Y2gsIHNvbWUgYWN0aW9ucyAoc3RhcnQvc3RvcC9idXNvZmYgcmVjb3ZlcnkpIG9uIDEgYnVzCisJICBtdXN0IGJyaW5nIGRvd24gdGhlIG90aGVyIGJ1cyB0b28gdGVtcG9yYXJpbHkuCisKK2NvbmZpZyBDQU5fU09GVElOR19DUworCXRyaXN0YXRlICJTb2Z0aW5nIEdtYmggQ0FOIHBjbWNpYSBjYXJkcyIKKwlkZXBlbmRzIG9uIFBDTUNJQQorCXNlbGVjdCBDQU5fU09GVElORworCS0tLWhlbHAtLS0KKwkgIFN1cHBvcnQgZm9yIFBDTUNJQSBjYXJkcyBmcm9tIFNvZnRpbmcgR21iaCAmIHNvbWUgY2FyZHMKKwkgIGZyb20gVmVjdG9yIEdtYmguCisJICBZb3UgbmVlZCBmaXJtd2FyZSBmb3IgdGhlc2UsIHdoaWNoIHlvdSBjYW4gZ2V0IGF0CisJICBodHRwOi8vZGV2ZWxvcGVyLmJlcmxpb3MuZGUvcHJvamVjdHMvc29ja2V0Y2FuLworCSAgVGhpcyB2ZXJzaW9uIG9mIHRoZSBkcml2ZXIgaXMgd3JpdHRlbiBhZ2FpbnN0CisJICBmaXJtd2FyZSB2ZXJzaW9uIDQuNiAoc29mdGluZy1mdy00LjYtYmluYXJpZXMudGFyLmd6KQorCSAgSW4gb3JkZXIgdG8gdXNlIHRoZSBjYXJkIGFzIENBTiBkZXZpY2UsIHlvdSBuZWVkIHRoZSBTb2Z0aW5nIGdlbmVyaWMKKwkgIHN1cHBvcnQgdG9vLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FuL3NvZnRpbmcvTWFrZWZpbGUgYi9kcml2ZXJzL25ldC9jYW4vc29mdGluZy9NYWtlZmlsZQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jNWU1MDE2Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9uZXQvY2FuL3NvZnRpbmcvTWFrZWZpbGUKQEAgLTAsMCArMSw2IEBACisKK3NvZnRpbmcteSA6PSBzb2Z0aW5nX21haW4ubyBzb2Z0aW5nX2Z3Lm8KK29iai0kKENPTkZJR19DQU5fU09GVElORykgKz0gc29mdGluZy5vCitvYmotJChDT05GSUdfQ0FOX1NPRlRJTkdfQ1MpICs9IHNvZnRpbmdfY3MubworCitjY2ZsYWdzLSQoQ09ORklHX0NBTl9ERUJVR19ERVZJQ0VTKSA6PSAtRERFQlVHCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vc29mdGluZy9zb2Z0aW5nLmggYi9kcml2ZXJzL25ldC9jYW4vc29mdGluZy9zb2Z0aW5nLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uN2VjOWY0ZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi9zb2Z0aW5nL3NvZnRpbmcuaApAQCAtMCwwICsxLDE2NyBAQAorLyoKKyAqIHNvZnRpbmcgY29tbW9uIGludGVyZmFjZXMKKyAqCisgKiBieSBLdXJ0IFZhbiBEaWpjaywgMjAwOC0yMDEwCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2F0b21pYy5oPgorI2luY2x1ZGUgPGxpbnV4L25ldGRldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L2t0aW1lLmg+CisjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KKyNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgorI2luY2x1ZGUgPGxpbnV4L2Nhbi5oPgorI2luY2x1ZGUgPGxpbnV4L2Nhbi9kZXYuaD4KKworI2luY2x1ZGUgInNvZnRpbmdfcGxhdGZvcm0uaCIKKworc3RydWN0IHNvZnRpbmc7CisKK3N0cnVjdCBzb2Z0aW5nX3ByaXYgeworCXN0cnVjdCBjYW5fcHJpdiBjYW47IC8qIG11c3QgYmUgdGhlIGZpcnN0IG1lbWJlciEgKi8KKwlzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2OworCXN0cnVjdCBzb2Z0aW5nICpjYXJkOworCXN0cnVjdCB7CisJCWludCBwZW5kaW5nOworCQkvKiB2YXJpYWJsZXMgd2ljaCBob2xkIHRoZSBjaXJjdWxhciBidWZmZXIgKi8KKwkJaW50IGVjaG9fcHV0OworCQlpbnQgZWNob19nZXQ7CisJfSB0eDsKKwlzdHJ1Y3QgY2FuX2JpdHRpbWluZ19jb25zdCBidHJfY29uc3Q7CisJaW50IGluZGV4OworCXVpbnQ4X3Qgb3V0cHV0OworCXVpbnQxNl90IGNoaXA7Cit9OworI2RlZmluZSBuZXRkZXYyc29mdGluZyhuZXRkZXYpCSgoc3RydWN0IHNvZnRpbmdfcHJpdiAqKW5ldGRldl9wcml2KG5ldGRldikpCisKK3N0cnVjdCBzb2Z0aW5nIHsKKwljb25zdCBzdHJ1Y3Qgc29mdGluZ19wbGF0Zm9ybV9kYXRhICpwZGF0OworCXN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXY7CisJc3RydWN0IG5ldF9kZXZpY2UgKm5ldFsyXTsKKwlzcGlubG9ja190IHNwaW47IC8qIHByb3RlY3QgdGhpcyBzdHJ1Y3R1cmUgJiBEUFJBTSBhY2Nlc3MgKi8KKwlrdGltZV90IHRzX3JlZjsKKwlrdGltZV90IHRzX292ZXJmbG93OyAvKiB0aW1lc3RhbXAgb3ZlcmZsb3cgdmFsdWUsIGluIGt0aW1lICovCisKKwlzdHJ1Y3QgeworCQkvKiBpbmRpY2F0aW9uIG9mIGZpcm13YXJlIHN0YXR1cyAqLworCQlpbnQgdXA7CisJCS8qIHByb3RlY3Rpb24gb2YgdGhlICd1cCcgdmFyaWFibGUgKi8KKwkJc3RydWN0IG11dGV4IGxvY2s7CisJfSBmdzsKKwlzdHJ1Y3QgeworCQlpbnQgbnI7CisJCWludCByZXF1ZXN0ZWQ7CisJCWludCBzdmNfY291bnQ7CisJCXVuc2lnbmVkIGludCBkcHJhbV9wb3NpdGlvbjsKKwl9IGlycTsKKwlzdHJ1Y3QgeworCQlpbnQgcGVuZGluZzsKKwkJaW50IGxhc3RfYnVzOworCQkvKgorCQkgKiBrZWVwIHRoZSBidXMgdGhhdCBsYXN0IHR4J2QgYSBtZXNzYWdlLAorCQkgKiBpbiBvcmRlciB0byBsZXQgZXZlcnkgbmV0ZGV2IHF1ZXVlIHJlc3VtZQorCQkgKi8KKwl9IHR4OworCV9faW9tZW0gdWludDhfdCAqZHByYW07CisJdW5zaWduZWQgbG9uZyBkcHJhbV9waHlzOworCXVuc2lnbmVkIGxvbmcgZHByYW1fc2l6ZTsKKwlzdHJ1Y3QgeworCQl1aW50MTZfdCBmd192ZXJzaW9uLCBod192ZXJzaW9uLCBsaWNlbnNlLCBzZXJpYWw7CisJCXVpbnQxNl90IGNoaXBbMl07CisJCXVuc2lnbmVkIGludCBmcmVxOyAvKiByZW1vdGUgY3B1J3Mgb3BlcmF0aW5nIGZyZXF1ZW5jeSAqLworCX0gaWQ7Cit9OworCitleHRlcm4gaW50IHNvZnRpbmdfZGVmYXVsdF9vdXRwdXQoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldik7CisKK2V4dGVybiBrdGltZV90IHNvZnRpbmdfcmF3Mmt0aW1lKHN0cnVjdCBzb2Z0aW5nICpjYXJkLCB1MzIgcmF3KTsKKworZXh0ZXJuIGludCBzb2Z0aW5nX2NoaXBfcG93ZXJvbihzdHJ1Y3Qgc29mdGluZyAqY2FyZCk7CisKK2V4dGVybiBpbnQgc29mdGluZ19ib290bG9hZGVyX2NvbW1hbmQoc3RydWN0IHNvZnRpbmcgKmNhcmQsIGludDE2X3QgY21kLAorCQljb25zdCBjaGFyICptc2cpOworCisvKiBMb2FkIGZpcm13YXJlIGFmdGVyIHJlc2V0ICovCitleHRlcm4gaW50IHNvZnRpbmdfbG9hZF9mdyhjb25zdCBjaGFyICpmaWxlLCBzdHJ1Y3Qgc29mdGluZyAqY2FyZCwKKwkJCV9faW9tZW0gdWludDhfdCAqdmlydCwgdW5zaWduZWQgaW50IHNpemUsIGludCBvZmZzZXQpOworCisvKiBMb2FkIGZpbmFsIGFwcGxpY2F0aW9uIGZpcm13YXJlIGFmdGVyIGJvb3Rsb2FkZXIgKi8KK2V4dGVybiBpbnQgc29mdGluZ19sb2FkX2FwcF9mdyhjb25zdCBjaGFyICpmaWxlLCBzdHJ1Y3Qgc29mdGluZyAqY2FyZCk7CisKKy8qCisgKiBlbmFibGUgb3IgZGlzYWJsZSBpcnEKKyAqIG9ubHkgY2FsbGVkIHdpdGggZncubG9jayBsb2NrZWQKKyAqLworZXh0ZXJuIGludCBzb2Z0aW5nX2VuYWJsZV9pcnEoc3RydWN0IHNvZnRpbmcgKmNhcmQsIGludCBlbmFibGUpOworCisvKiBzdGFydC9zdG9wIDEgYnVzIG9uIGNhcmQgKi8KK2V4dGVybiBpbnQgc29mdGluZ19zdGFydHN0b3Aoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwgaW50IHVwKTsKKworLyogbmV0aWZfcngoKSAqLworZXh0ZXJuIGludCBzb2Z0aW5nX25ldGRldl9yeChzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2LAorCQljb25zdCBzdHJ1Y3QgY2FuX2ZyYW1lICptc2csIGt0aW1lX3Qga3RpbWUpOworCisvKiBTT0ZUSU5HIERQUkFNIG1hcHBpbmdzICovCisjZGVmaW5lIERQUkFNX1JYCQkweDAwMDAKKwkjZGVmaW5lIERQUkFNX1JYX1NJWkUJMzIKKwkjZGVmaW5lIERQUkFNX1JYX0NOVAkxNgorI2RlZmluZSBEUFJBTV9SWF9SRAkJMHgwMjAxCS8qIHVpbnQ4X3QgKi8KKyNkZWZpbmUgRFBSQU1fUlhfV1IJCTB4MDIwNQkvKiB1aW50OF90ICovCisjZGVmaW5lIERQUkFNX1JYX0xPU1QJCTB4MDIwNwkvKiB1aW50OF90ICovCisKKyNkZWZpbmUgRFBSQU1fRkNUX1BBUkFNCQkweDAzMDAJLyogaW50MTZfdCBbMjBdICovCisjZGVmaW5lIERQUkFNX0ZDVF9SRVNVTFQJMHgwMzI4CS8qIGludDE2X3QgKi8KKyNkZWZpbmUgRFBSQU1fRkNUX0hPU1QJCTB4MDMyYgkvKiB1aW50MTZfdCAqLworCisjZGVmaW5lIERQUkFNX0lORk9fQlVTU1RBVEUJMHgwMzMxCS8qIHVpbnQxNl90ICovCisjZGVmaW5lIERQUkFNX0lORk9fQlVTU1RBVEUyCTB4MDMzNQkvKiB1aW50MTZfdCAqLworI2RlZmluZSBEUFJBTV9JTkZPX0VSUlNUQVRFCTB4MDMzOQkvKiB1aW50MTZfdCAqLworI2RlZmluZSBEUFJBTV9JTkZPX0VSUlNUQVRFMgkweDAzM2QJLyogdWludDE2X3QgKi8KKyNkZWZpbmUgRFBSQU1fUkVTRVQJCTB4MDM0MQkvKiB1aW50MTZfdCAqLworI2RlZmluZSBEUFJBTV9DTFJfUkVDVl9GSUZPCTB4MDM0NQkvKiB1aW50MTZfdCAqLworI2RlZmluZSBEUFJBTV9SRVNFVF9USU1FCTB4MDM0ZAkvKiB1aW50MTZfdCAqLworI2RlZmluZSBEUFJBTV9USU1FCQkweDAzNTAJLyogdWludDY0X3QgKi8KKyNkZWZpbmUgRFBSQU1fV1JfU1RBUlQJCTB4MDM1OAkvKiB1aW50OF90ICovCisjZGVmaW5lIERQUkFNX1dSX0VORAkJMHgwMzU5CS8qIHVpbnQ4X3QgKi8KKyNkZWZpbmUgRFBSQU1fUkVTRVRfUlhfRklGTwkweDAzNjEJLyogdWludDE2X3QgKi8KKyNkZWZpbmUgRFBSQU1fUkVTRVRfVFhfRklGTwkweDAzNjQJLyogdWludDhfdCAqLworI2RlZmluZSBEUFJBTV9SRUFEX0ZJRk9fTEVWRUwJMHgwMzY1CS8qIHVpbnQ4X3QgKi8KKyNkZWZpbmUgRFBSQU1fUlhfRklGT19MRVZFTAkweDAzNjYJLyogdWludDE2X3QgKi8KKyNkZWZpbmUgRFBSQU1fVFhfRklGT19MRVZFTAkweDAzNjYJLyogdWludDE2X3QgKi8KKworI2RlZmluZSBEUFJBTV9UWAkJMHgwNDAwCS8qIHVpbnQxNl90ICovCisJI2RlZmluZSBEUFJBTV9UWF9TSVpFCTE2CisJI2RlZmluZSBEUFJBTV9UWF9DTlQJMzIKKyNkZWZpbmUgRFBSQU1fVFhfUkQJCTB4MDYwMQkvKiB1aW50OF90ICovCisjZGVmaW5lIERQUkFNX1RYX1dSCQkweDA2MDUJLyogdWludDhfdCAqLworCisjZGVmaW5lIERQUkFNX0NPTU1BTkQJCTB4MDdlMAkvKiB1aW50MTZfdCAqLworI2RlZmluZSBEUFJBTV9SRUNFSVBUCQkweDA3ZjAJLyogdWludDE2X3QgKi8KKyNkZWZpbmUgRFBSQU1fSVJRX1RPSE9TVAkweDA3ZmUJLyogdWludDhfdCAqLworI2RlZmluZSBEUFJBTV9JUlFfVE9DQVJECTB4MDdmZgkvKiB1aW50OF90ICovCisKKyNkZWZpbmUgRFBSQU1fVjJfUkVTRVQJCTB4MGUwMAkvKiB1aW50OF90ICovCisjZGVmaW5lIERQUkFNX1YyX0lSUV9UT0hPU1QJMHgwZTAyCS8qIHVpbnQ4X3QgKi8KKworI2RlZmluZSBUWE1BWAkoRFBSQU1fVFhfQ05UIC0gMSkKKworLyogRFBSQU0gcmV0dXJuIGNvZGVzICovCisjZGVmaW5lIFJFU19OT05FCTAKKyNkZWZpbmUgUkVTX09LCQkxCisjZGVmaW5lIFJFU19OT0sJCTIKKyNkZWZpbmUgUkVTX1VOS05PV04JMworLyogRFBSQU0gZmxhZ3MgKi8KKyNkZWZpbmUgQ01EX1RYCQkweDAxCisjZGVmaW5lIENNRF9BQ0sJCTB4MDIKKyNkZWZpbmUgQ01EX1hURAkJMHgwNAorI2RlZmluZSBDTURfUlRSCQkweDA4CisjZGVmaW5lIENNRF9FUlIJCTB4MTAKKyNkZWZpbmUgQ01EX0JVUzIJMHg4MAorCisvKiByZXR1cm5lZCBmaWZvIGVudHJ5IGJ1cyBzdGF0ZSBtYXNrcyAqLworI2RlZmluZSBTRl9NQVNLX0JVU09GRgkJMHg4MAorI2RlZmluZSBTRl9NQVNLX0VQQVNTSVZFCTB4NjAKKworLyogYnVzIHN0YXRlcyAqLworI2RlZmluZSBTVEFURV9CVVNPRkYJMgorI2RlZmluZSBTVEFURV9FUEFTU0lWRQkxCisjZGVmaW5lIFNUQVRFX0VBQ1RJVkUJMApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FuL3NvZnRpbmcvc29mdGluZ19jcy5jIGIvZHJpdmVycy9uZXQvY2FuL3NvZnRpbmcvc29mdGluZ19jcy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmMxMWJiNGQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL25ldC9jYW4vc29mdGluZy9zb2Z0aW5nX2NzLmMKQEAgLTAsMCArMSwzNjAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDgtMjAxMAorICoKKyAqIC0gS3VydCBWYW4gRGlqY2ssIEVJQSBFbGVjdHJvbmljcworICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIHZlcnNpb24gMiBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNyBVU0EKKyAqLworCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorCisjaW5jbHVkZSA8cGNtY2lhL2Npc3RwbC5oPgorI2luY2x1ZGUgPHBjbWNpYS9kcy5oPgorCisjaW5jbHVkZSAic29mdGluZ19wbGF0Zm9ybS5oIgorCitzdGF0aWMgaW50IHNvZnRpbmdjc19pbmRleDsKK3N0YXRpYyBzcGlubG9ja190IHNvZnRpbmdjc19pbmRleF9sb2NrOworCitzdGF0aWMgaW50IHNvZnRpbmdjc19yZXNldChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LCBpbnQgdik7CitzdGF0aWMgaW50IHNvZnRpbmdjc19lbmFibGVfaXJxKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsIGludCB2KTsKKworLyoKKyAqIHBsYXRmb3JtX2RhdGEgZGVzY3JpcHRpb25zCisgKi8KKyNkZWZpbmUgTUhaICgxMDAwKjEwMDApCitzdGF0aWMgY29uc3Qgc3RydWN0IHNvZnRpbmdfcGxhdGZvcm1fZGF0YSBzb2Z0aW5nY3NfcGxhdGZvcm1fZGF0YVtdID0geworeworCS5uYW1lID0gIkNBTmNhcmQiLAorCS5tYW5mID0gMHgwMTY4LCAucHJvZCA9IDB4MDAxLAorCS5nZW5lcmF0aW9uID0gMSwKKwkubmJ1cyA9IDIsCisJLmZyZXEgPSAxNiAqIE1IWiwgLm1heF9icnAgPSAzMiwgLm1heF9zancgPSA0LAorCS5kcHJhbV9zaXplID0gMHgwODAwLAorCS5ib290ID0gezB4MDAwMCwgMHgwMDAwMDAsIGZ3X2RpciAiYmNhcmQuYmluIix9LAorCS5sb2FkID0gezB4MDEyMCwgMHgwMGY2MDAsIGZ3X2RpciAibGRjYXJkLmJpbiIsfSwKKwkuYXBwID0gezB4MDAxMCwgMHgwZDAwMDAsIGZ3X2RpciAiY2FuY2FyZC5iaW4iLH0sCisJLnJlc2V0ID0gc29mdGluZ2NzX3Jlc2V0LAorCS5lbmFibGVfaXJxID0gc29mdGluZ2NzX2VuYWJsZV9pcnEsCit9LCB7CisJLm5hbWUgPSAiQ0FOY2FyZC1ORUMiLAorCS5tYW5mID0gMHgwMTY4LCAucHJvZCA9IDB4MDAyLAorCS5nZW5lcmF0aW9uID0gMSwKKwkubmJ1cyA9IDIsCisJLmZyZXEgPSAxNiAqIE1IWiwgLm1heF9icnAgPSAzMiwgLm1heF9zancgPSA0LAorCS5kcHJhbV9zaXplID0gMHgwODAwLAorCS5ib290ID0gezB4MDAwMCwgMHgwMDAwMDAsIGZ3X2RpciAiYmNhcmQuYmluIix9LAorCS5sb2FkID0gezB4MDEyMCwgMHgwMGY2MDAsIGZ3X2RpciAibGRjYXJkLmJpbiIsfSwKKwkuYXBwID0gezB4MDAxMCwgMHgwZDAwMDAsIGZ3X2RpciAiY2FuY2FyZC5iaW4iLH0sCisJLnJlc2V0ID0gc29mdGluZ2NzX3Jlc2V0LAorCS5lbmFibGVfaXJxID0gc29mdGluZ2NzX2VuYWJsZV9pcnEsCit9LCB7CisJLm5hbWUgPSAiQ0FOY2FyZC1TSkEiLAorCS5tYW5mID0gMHgwMTY4LCAucHJvZCA9IDB4MDA0LAorCS5nZW5lcmF0aW9uID0gMSwKKwkubmJ1cyA9IDIsCisJLmZyZXEgPSAyMCAqIE1IWiwgLm1heF9icnAgPSAzMiwgLm1heF9zancgPSA0LAorCS5kcHJhbV9zaXplID0gMHgwODAwLAorCS5ib290ID0gezB4MDAwMCwgMHgwMDAwMDAsIGZ3X2RpciAiYmNhcmQuYmluIix9LAorCS5sb2FkID0gezB4MDEyMCwgMHgwMGY2MDAsIGZ3X2RpciAibGRjYXJkLmJpbiIsfSwKKwkuYXBwID0gezB4MDAxMCwgMHgwZDAwMDAsIGZ3X2RpciAiY2Fuc2phLmJpbiIsfSwKKwkucmVzZXQgPSBzb2Z0aW5nY3NfcmVzZXQsCisJLmVuYWJsZV9pcnEgPSBzb2Z0aW5nY3NfZW5hYmxlX2lycSwKK30sIHsKKwkubmFtZSA9ICJDQU5jYXJkLTIiLAorCS5tYW5mID0gMHgwMTY4LCAucHJvZCA9IDB4MDA1LAorCS5nZW5lcmF0aW9uID0gMiwKKwkubmJ1cyA9IDIsCisJLmZyZXEgPSAyNCAqIE1IWiwgLm1heF9icnAgPSA2NCwgLm1heF9zancgPSA0LAorCS5kcHJhbV9zaXplID0gMHgxMDAwLAorCS5ib290ID0gezB4MDAwMCwgMHgwMDAwMDAsIGZ3X2RpciAiYmNhcmQyLmJpbiIsfSwKKwkubG9hZCA9IHsweDAxMjAsIDB4MDBmNjAwLCBmd19kaXIgImxkY2FyZDIuYmluIix9LAorCS5hcHAgPSB7MHgwMDEwLCAweDBkMDAwMCwgZndfZGlyICJjYW5jcmQyLmJpbiIsfSwKKwkucmVzZXQgPSBzb2Z0aW5nY3NfcmVzZXQsCisJLmVuYWJsZV9pcnEgPSBOVUxMLAorfSwgeworCS5uYW1lID0gIlZlY3Rvci1DQU5jYXJkIiwKKwkubWFuZiA9IDB4MDE2OCwgLnByb2QgPSAweDA4MSwKKwkuZ2VuZXJhdGlvbiA9IDEsCisJLm5idXMgPSAyLAorCS5mcmVxID0gMTYgKiBNSFosIC5tYXhfYnJwID0gNjQsIC5tYXhfc2p3ID0gNCwKKwkuZHByYW1fc2l6ZSA9IDB4MDgwMCwKKwkuYm9vdCA9IHsweDAwMDAsIDB4MDAwMDAwLCBmd19kaXIgImJjYXJkLmJpbiIsfSwKKwkubG9hZCA9IHsweDAxMjAsIDB4MDBmNjAwLCBmd19kaXIgImxkY2FyZC5iaW4iLH0sCisJLmFwcCA9IHsweDAwMTAsIDB4MGQwMDAwLCBmd19kaXIgImNhbmNhcmQuYmluIix9LAorCS5yZXNldCA9IHNvZnRpbmdjc19yZXNldCwKKwkuZW5hYmxlX2lycSA9IHNvZnRpbmdjc19lbmFibGVfaXJxLAorfSwgeworCS5uYW1lID0gIlZlY3Rvci1DQU5jYXJkLVNKQSIsCisJLm1hbmYgPSAweDAxNjgsIC5wcm9kID0gMHgwODQsCisJLmdlbmVyYXRpb24gPSAxLAorCS5uYnVzID0gMiwKKwkuZnJlcSA9IDIwICogTUhaLCAubWF4X2JycCA9IDMyLCAubWF4X3NqdyA9IDQsCisJLmRwcmFtX3NpemUgPSAweDA4MDAsCisJLmJvb3QgPSB7MHgwMDAwLCAweDAwMDAwMCwgZndfZGlyICJiY2FyZC5iaW4iLH0sCisJLmxvYWQgPSB7MHgwMTIwLCAweDAwZjYwMCwgZndfZGlyICJsZGNhcmQuYmluIix9LAorCS5hcHAgPSB7MHgwMDEwLCAweDBkMDAwMCwgZndfZGlyICJjYW5zamEuYmluIix9LAorCS5yZXNldCA9IHNvZnRpbmdjc19yZXNldCwKKwkuZW5hYmxlX2lycSA9IHNvZnRpbmdjc19lbmFibGVfaXJxLAorfSwgeworCS5uYW1lID0gIlZlY3Rvci1DQU5jYXJkLTIiLAorCS5tYW5mID0gMHgwMTY4LCAucHJvZCA9IDB4MDg1LAorCS5nZW5lcmF0aW9uID0gMiwKKwkubmJ1cyA9IDIsCisJLmZyZXEgPSAyNCAqIE1IWiwgLm1heF9icnAgPSA2NCwgLm1heF9zancgPSA0LAorCS5kcHJhbV9zaXplID0gMHgxMDAwLAorCS5ib290ID0gezB4MDAwMCwgMHgwMDAwMDAsIGZ3X2RpciAiYmNhcmQyLmJpbiIsfSwKKwkubG9hZCA9IHsweDAxMjAsIDB4MDBmNjAwLCBmd19kaXIgImxkY2FyZDIuYmluIix9LAorCS5hcHAgPSB7MHgwMDEwLCAweDBkMDAwMCwgZndfZGlyICJjYW5jcmQyLmJpbiIsfSwKKwkucmVzZXQgPSBzb2Z0aW5nY3NfcmVzZXQsCisJLmVuYWJsZV9pcnEgPSBOVUxMLAorfSwgeworCS5uYW1lID0gIkVESUNjYXJkLU5FQyIsCisJLm1hbmYgPSAweDAxNjgsIC5wcm9kID0gMHgxMDIsCisJLmdlbmVyYXRpb24gPSAxLAorCS5uYnVzID0gMiwKKwkuZnJlcSA9IDE2ICogTUhaLCAubWF4X2JycCA9IDY0LCAubWF4X3NqdyA9IDQsCisJLmRwcmFtX3NpemUgPSAweDA4MDAsCisJLmJvb3QgPSB7MHgwMDAwLCAweDAwMDAwMCwgZndfZGlyICJiY2FyZC5iaW4iLH0sCisJLmxvYWQgPSB7MHgwMTIwLCAweDAwZjYwMCwgZndfZGlyICJsZGNhcmQuYmluIix9LAorCS5hcHAgPSB7MHgwMDEwLCAweDBkMDAwMCwgZndfZGlyICJjYW5jYXJkLmJpbiIsfSwKKwkucmVzZXQgPSBzb2Z0aW5nY3NfcmVzZXQsCisJLmVuYWJsZV9pcnEgPSBzb2Z0aW5nY3NfZW5hYmxlX2lycSwKK30sIHsKKwkubmFtZSA9ICJFRElDY2FyZC0yIiwKKwkubWFuZiA9IDB4MDE2OCwgLnByb2QgPSAweDEwNSwKKwkuZ2VuZXJhdGlvbiA9IDIsCisJLm5idXMgPSAyLAorCS5mcmVxID0gMjQgKiBNSFosIC5tYXhfYnJwID0gNjQsIC5tYXhfc2p3ID0gNCwKKwkuZHByYW1fc2l6ZSA9IDB4MTAwMCwKKwkuYm9vdCA9IHsweDAwMDAsIDB4MDAwMDAwLCBmd19kaXIgImJjYXJkMi5iaW4iLH0sCisJLmxvYWQgPSB7MHgwMTIwLCAweDAwZjYwMCwgZndfZGlyICJsZGNhcmQyLmJpbiIsfSwKKwkuYXBwID0gezB4MDAxMCwgMHgwZDAwMDAsIGZ3X2RpciAiY2FuY3JkMi5iaW4iLH0sCisJLnJlc2V0ID0gc29mdGluZ2NzX3Jlc2V0LAorCS5lbmFibGVfaXJxID0gTlVMTCwKK30sIHsKKwkwLCAwLAorfSwKK307CisKK01PRFVMRV9GSVJNV0FSRShmd19kaXIgImJjYXJkLmJpbiIpOworTU9EVUxFX0ZJUk1XQVJFKGZ3X2RpciAibGRjYXJkLmJpbiIpOworTU9EVUxFX0ZJUk1XQVJFKGZ3X2RpciAiY2FuY2FyZC5iaW4iKTsKK01PRFVMRV9GSVJNV0FSRShmd19kaXIgImNhbnNqYS5iaW4iKTsKKworTU9EVUxFX0ZJUk1XQVJFKGZ3X2RpciAiYmNhcmQyLmJpbiIpOworTU9EVUxFX0ZJUk1XQVJFKGZ3X2RpciAibGRjYXJkMi5iaW4iKTsKK01PRFVMRV9GSVJNV0FSRShmd19kaXIgImNhbmNyZDIuYmluIik7CisKK3N0YXRpYyBfX2RldmluaXQgY29uc3Qgc3RydWN0IHNvZnRpbmdfcGxhdGZvcm1fZGF0YQorKnNvZnRpbmdjc19maW5kX3BsYXRmb3JtX2RhdGEodW5zaWduZWQgaW50IG1hbmYsIHVuc2lnbmVkIGludCBwcm9kKQoreworCWNvbnN0IHN0cnVjdCBzb2Z0aW5nX3BsYXRmb3JtX2RhdGEgKmxwOworCisJZm9yIChscCA9IHNvZnRpbmdjc19wbGF0Zm9ybV9kYXRhOyBscC0+bWFuZjsgKytscCkgeworCQlpZiAoKGxwLT5tYW5mID09IG1hbmYpICYmIChscC0+cHJvZCA9PSBwcm9kKSkKKwkJCXJldHVybiBscDsKKwl9CisJcmV0dXJuIE5VTEw7Cit9CisKKy8qCisgKiBwbGF0Zm9ybWRhdGEgY2FsbGJhY2tzCisgKi8KK3N0YXRpYyBpbnQgc29mdGluZ2NzX3Jlc2V0KHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsIGludCB2KQoreworCXN0cnVjdCBwY21jaWFfZGV2aWNlICpwY21jaWEgPSB0b19wY21jaWFfZGV2KHBkZXYtPmRldi5wYXJlbnQpOworCisJZGV2X2RiZygmcGRldi0+ZGV2LCAicGNtY2lhIGNvbmZpZyBbMl0gJTAyeFxuIiwgdiA/IDAgOiAweDIwKTsKKwlyZXR1cm4gcGNtY2lhX3dyaXRlX2NvbmZpZ19ieXRlKHBjbWNpYSwgMiwgdiA/IDAgOiAweDIwKTsKK30KKworc3RhdGljIGludCBzb2Z0aW5nY3NfZW5hYmxlX2lycShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LCBpbnQgdikKK3sKKwlzdHJ1Y3QgcGNtY2lhX2RldmljZSAqcGNtY2lhID0gdG9fcGNtY2lhX2RldihwZGV2LT5kZXYucGFyZW50KTsKKworCWRldl9kYmcoJnBkZXYtPmRldiwgInBjbWNpYSBjb25maWcgWzBdICUwMnhcbiIsIHYgPyAweDYwIDogMCk7CisJcmV0dXJuIHBjbWNpYV93cml0ZV9jb25maWdfYnl0ZShwY21jaWEsIDAsIHYgPyAweDYwIDogMCk7Cit9CisKKy8qCisgKiBwY21jaWEgY2hlY2sKKyAqLworc3RhdGljIF9fZGV2aW5pdCBpbnQgc29mdGluZ2NzX3Byb2JlX2NvbmZpZyhzdHJ1Y3QgcGNtY2lhX2RldmljZSAqcGNtY2lhLAorCQl2b2lkICpwcml2X2RhdGEpCit7CisJc3RydWN0IHNvZnRpbmdfcGxhdGZvcm1fZGF0YSAqcGRhdCA9IHByaXZfZGF0YTsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnByZXM7CisJaW50IG1lbXNwZWVkID0gMDsKKworCVdBUk5fT04oIXBkYXQpOworCXByZXMgPSBwY21jaWEtPnJlc291cmNlW1BDTUNJQV9JT01FTV8wXTsKKwlpZiAocmVzb3VyY2Vfc2l6ZShwcmVzKSA8IDB4MTAwMCkKKwkJcmV0dXJuIC1FUkFOR0U7CisKKwlwcmVzLT5mbGFncyB8PSBXSU5fTUVNT1JZX1RZUEVfQ00gfCBXSU5fRU5BQkxFOworCWlmIChwZGF0LT5nZW5lcmF0aW9uIDwgMikgeworCQlwcmVzLT5mbGFncyB8PSBXSU5fVVNFX1dBSVQgfCBXSU5fREFUQV9XSURUSF84OworCQltZW1zcGVlZCA9IDM7CisJfSBlbHNlIHsKKwkJcHJlcy0+ZmxhZ3MgfD0gV0lOX0RBVEFfV0lEVEhfMTY7CisJfQorCXJldHVybiBwY21jaWFfcmVxdWVzdF93aW5kb3cocGNtY2lhLCBwcmVzLCBtZW1zcGVlZCk7Cit9CisKK3N0YXRpYyBfX2RldmV4aXQgdm9pZCBzb2Z0aW5nY3NfcmVtb3ZlKHN0cnVjdCBwY21jaWFfZGV2aWNlICpwY21jaWEpCit7CisJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiA9IHBjbWNpYS0+cHJpdjsKKworCS8qIGZyZWUgYml0cyAqLworCXBsYXRmb3JtX2RldmljZV91bnJlZ2lzdGVyKHBkZXYpOworCS8qIHJlbGVhc2UgcGNtY2lhIHN0dWZmICovCisJcGNtY2lhX2Rpc2FibGVfZGV2aWNlKHBjbWNpYSk7Cit9CisKKy8qCisgKiBwbGF0Zm9ybV9kZXZpY2Ugd3JhcHBlcgorICogcGRldi0+cmVzb3VyY2UgaGFzIDIgZW50cmllczogaW8gJiBpcnEKKyAqLworc3RhdGljIHZvaWQgc29mdGluZ2NzX3BkZXZfcmVsZWFzZShzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiA9IHRvX3BsYXRmb3JtX2RldmljZShkZXYpOworCWtmcmVlKHBkZXYpOworfQorCitzdGF0aWMgX19kZXZpbml0IGludCBzb2Z0aW5nY3NfcHJvYmUoc3RydWN0IHBjbWNpYV9kZXZpY2UgKnBjbWNpYSkKK3sKKwlpbnQgcmV0OworCXN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXY7CisJY29uc3Qgc3RydWN0IHNvZnRpbmdfcGxhdGZvcm1fZGF0YSAqcGRhdDsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnByZXM7CisJc3RydWN0IGRldiB7CisJCXN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgcGRldjsKKwkJc3RydWN0IHJlc291cmNlIHJlc1syXTsKKwl9ICpkZXY7CisKKwkvKiBmaW5kIG1hdGNoaW5nIHBsYXRmb3JtX2RhdGEgKi8KKwlwZGF0ID0gc29mdGluZ2NzX2ZpbmRfcGxhdGZvcm1fZGF0YShwY21jaWEtPm1hbmZfaWQsIHBjbWNpYS0+Y2FyZF9pZCk7CisJaWYgKCFwZGF0KQorCQlyZXR1cm4gLUVOT1RUWTsKKworCS8qIHNldHVwIHBjbWNpYSBkZXZpY2UgKi8KKwlwY21jaWEtPmNvbmZpZ19mbGFncyB8PSBDT05GX0VOQUJMRV9JUlEgfCBDT05GX0FVVE9fU0VUX0lPTUVNIHwKKwkJQ09ORl9BVVRPX1NFVF9WUFAgfCBDT05GX0FVVE9fQ0hFQ0tfVkNDOworCXJldCA9IHBjbWNpYV9sb29wX2NvbmZpZyhwY21jaWEsIHNvZnRpbmdjc19wcm9iZV9jb25maWcsICh2b2lkICopcGRhdCk7CisJaWYgKHJldCkKKwkJZ290byBwY21jaWFfZmFpbGVkOworCisJcmV0ID0gcGNtY2lhX2VuYWJsZV9kZXZpY2UocGNtY2lhKTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBwY21jaWFfZmFpbGVkOworCisJcHJlcyA9IHBjbWNpYS0+cmVzb3VyY2VbUENNQ0lBX0lPTUVNXzBdOworCWlmICghcHJlcykgeworCQlyZXQgPSAtRUJBREY7CisJCWdvdG8gcGNtY2lhX2JhZDsKKwl9CisKKwkvKiBjcmVhdGUgc29mdGluZyBwbGF0Zm9ybSBkZXZpY2UgKi8KKwlkZXYgPSBremFsbG9jKHNpemVvZigqZGV2KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFkZXYpIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBtZW1fZmFpbGVkOworCX0KKwlkZXYtPnBkZXYucmVzb3VyY2UgPSBkZXYtPnJlczsKKwlkZXYtPnBkZXYubnVtX3Jlc291cmNlcyA9IEFSUkFZX1NJWkUoZGV2LT5yZXMpOworCWRldi0+cGRldi5kZXYucmVsZWFzZSA9IHNvZnRpbmdjc19wZGV2X3JlbGVhc2U7CisKKwlwZGV2ID0gJmRldi0+cGRldjsKKwlwZGV2LT5kZXYucGxhdGZvcm1fZGF0YSA9ICh2b2lkICopcGRhdDsKKwlwZGV2LT5kZXYucGFyZW50ID0gJnBjbWNpYS0+ZGV2OworCXBjbWNpYS0+cHJpdiA9IHBkZXY7CisKKwkvKiBwbGF0Zm9ybSBkZXZpY2UgcmVzb3VyY2VzICovCisJcGRldi0+cmVzb3VyY2VbMF0uZmxhZ3MgPSBJT1JFU09VUkNFX01FTTsKKwlwZGV2LT5yZXNvdXJjZVswXS5zdGFydCA9IHByZXMtPnN0YXJ0OworCXBkZXYtPnJlc291cmNlWzBdLmVuZCA9IHByZXMtPmVuZDsKKworCXBkZXYtPnJlc291cmNlWzFdLmZsYWdzID0gSU9SRVNPVVJDRV9JUlE7CisJcGRldi0+cmVzb3VyY2VbMV0uc3RhcnQgPSBwY21jaWEtPmlycTsKKwlwZGV2LT5yZXNvdXJjZVsxXS5lbmQgPSBwZGV2LT5yZXNvdXJjZVsxXS5zdGFydDsKKworCS8qIHBsYXRmb3JtIGRldmljZSBzZXR1cCAqLworCXNwaW5fbG9jaygmc29mdGluZ2NzX2luZGV4X2xvY2spOworCXBkZXYtPmlkID0gc29mdGluZ2NzX2luZGV4Kys7CisJc3Bpbl91bmxvY2soJnNvZnRpbmdjc19pbmRleF9sb2NrKTsKKwlwZGV2LT5uYW1lID0gInNvZnRpbmciOworCWRldl9zZXRfbmFtZSgmcGRldi0+ZGV2LCAic29mdGluZ2NzLiVpIiwgcGRldi0+aWQpOworCXJldCA9IHBsYXRmb3JtX2RldmljZV9yZWdpc3RlcihwZGV2KTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBwbGF0Zm9ybV9mYWlsZWQ7CisKKwlkZXZfaW5mbygmcGNtY2lhLT5kZXYsICJjcmVhdGVkICVzXG4iLCBkZXZfbmFtZSgmcGRldi0+ZGV2KSk7CisJcmV0dXJuIDA7CisKK3BsYXRmb3JtX2ZhaWxlZDoKKwlrZnJlZShkZXYpOworbWVtX2ZhaWxlZDoKK3BjbWNpYV9iYWQ6CitwY21jaWFfZmFpbGVkOgorCXBjbWNpYV9kaXNhYmxlX2RldmljZShwY21jaWEpOworCXBjbWNpYS0+cHJpdiA9IE5VTEw7CisJcmV0dXJuIHJldCA/OiAtRU5PREVWOworfQorCitzdGF0aWMgLypjb25zdCovIHN0cnVjdCBwY21jaWFfZGV2aWNlX2lkIHNvZnRpbmdjc19pZHNbXSA9IHsKKwkvKiBzb2Z0aW5nICovCisJUENNQ0lBX0RFVklDRV9NQU5GX0NBUkQoMHgwMTY4LCAweDAwMDEpLAorCVBDTUNJQV9ERVZJQ0VfTUFORl9DQVJEKDB4MDE2OCwgMHgwMDAyKSwKKwlQQ01DSUFfREVWSUNFX01BTkZfQ0FSRCgweDAxNjgsIDB4MDAwNCksCisJUENNQ0lBX0RFVklDRV9NQU5GX0NBUkQoMHgwMTY4LCAweDAwMDUpLAorCS8qIHZlY3RvciwgbWFudWZhY3R1cmVyPyAqLworCVBDTUNJQV9ERVZJQ0VfTUFORl9DQVJEKDB4MDE2OCwgMHgwMDgxKSwKKwlQQ01DSUFfREVWSUNFX01BTkZfQ0FSRCgweDAxNjgsIDB4MDA4NCksCisJUENNQ0lBX0RFVklDRV9NQU5GX0NBUkQoMHgwMTY4LCAweDAwODUpLAorCS8qIEVESUMgKi8KKwlQQ01DSUFfREVWSUNFX01BTkZfQ0FSRCgweDAxNjgsIDB4MDEwMiksCisJUENNQ0lBX0RFVklDRV9NQU5GX0NBUkQoMHgwMTY4LCAweDAxMDUpLAorCVBDTUNJQV9ERVZJQ0VfTlVMTCwKK307CisKK01PRFVMRV9ERVZJQ0VfVEFCTEUocGNtY2lhLCBzb2Z0aW5nY3NfaWRzKTsKKworc3RhdGljIHN0cnVjdCBwY21jaWFfZHJpdmVyIHNvZnRpbmdjc19kcml2ZXIgPSB7CisJLm93bmVyCQk9IFRISVNfTU9EVUxFLAorCS5uYW1lCQk9ICJzb2Z0aW5nY3MiLAorCS5pZF90YWJsZQk9IHNvZnRpbmdjc19pZHMsCisJLnByb2JlCQk9IHNvZnRpbmdjc19wcm9iZSwKKwkucmVtb3ZlCQk9IF9fZGV2ZXhpdF9wKHNvZnRpbmdjc19yZW1vdmUpLAorfTsKKworc3RhdGljIGludCBfX2luaXQgc29mdGluZ2NzX3N0YXJ0KHZvaWQpCit7CisJc3Bpbl9sb2NrX2luaXQoJnNvZnRpbmdjc19pbmRleF9sb2NrKTsKKwlyZXR1cm4gcGNtY2lhX3JlZ2lzdGVyX2RyaXZlcigmc29mdGluZ2NzX2RyaXZlcik7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBzb2Z0aW5nY3Nfc3RvcCh2b2lkKQoreworCXBjbWNpYV91bnJlZ2lzdGVyX2RyaXZlcigmc29mdGluZ2NzX2RyaXZlcik7Cit9CisKK21vZHVsZV9pbml0KHNvZnRpbmdjc19zdGFydCk7Cittb2R1bGVfZXhpdChzb2Z0aW5nY3Nfc3RvcCk7CisKK01PRFVMRV9ERVNDUklQVElPTigic29mdGluZyBDQU5jYXJkIGRyaXZlciIKKwkJIiwgbGlua3MgUENNQ0lBIGNhcmQgdG8gc29mdGluZyBkcml2ZXIiKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9zb2Z0aW5nL3NvZnRpbmdfZncuYyBiL2RyaXZlcnMvbmV0L2Nhbi9zb2Z0aW5nL3NvZnRpbmdfZncuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iNTIwNzg0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9uZXQvY2FuL3NvZnRpbmcvc29mdGluZ19mdy5jCkBAIC0wLDAgKzEsNjkxIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA4LTIwMTAKKyAqCisgKiAtIEt1cnQgVmFuIERpamNrLCBFSUEgRWxlY3Ryb25pY3MKKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSB2ZXJzaW9uIDIgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSwgU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcgVVNBCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2Zpcm13YXJlLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KKyNpbmNsdWRlIDxhc20vZGl2NjQuaD4KKworI2luY2x1ZGUgInNvZnRpbmcuaCIKKworLyoKKyAqIGxvdyBsZXZlbCBEUFJBTSBjb21tYW5kLgorICogTWFrZSBzdXJlIHRoYXQgY2FyZC0+ZHByYW1bRFBSQU1fRkNUX0hPU1RdIGlzIHByZXNldAorICovCitzdGF0aWMgaW50IF9zb2Z0aW5nX2ZjdF9jbWQoc3RydWN0IHNvZnRpbmcgKmNhcmQsIGludDE2X3QgY21kLCB1aW50MTZfdCB2ZWN0b3IsCisJCWNvbnN0IGNoYXIgKm1zZykKK3sKKwlpbnQgcmV0OworCXVuc2lnbmVkIGxvbmcgc3RhbXA7CisKKwlpb3dyaXRlMTYoY21kLCAmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNXSk7CisJaW93cml0ZTgodmVjdG9yID4+IDgsICZjYXJkLT5kcHJhbVtEUFJBTV9GQ1RfSE9TVCArIDFdKTsKKwlpb3dyaXRlOCh2ZWN0b3IsICZjYXJkLT5kcHJhbVtEUFJBTV9GQ1RfSE9TVF0pOworCS8qIGJlIHN1cmUgdG8gZmx1c2ggdGhpcyB0byB0aGUgY2FyZCAqLworCXdtYigpOworCXN0YW1wID0gamlmZmllcyArIDEgKiBIWjsKKwkvKiB3YWl0IGZvciBjYXJkICovCisJZG8geworCQkvKiBEUFJBTV9GQ1RfSE9TVCBpcyBfbm90XyBhbGlnbmVkICovCisJCXJldCA9IGlvcmVhZDgoJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9IT1NUXSkgKworCQkJKGlvcmVhZDgoJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9IT1NUICsgMV0pIDw8IDgpOworCQkvKiBkb24ndCBoYXZlIGFueSBjYWNoZWQgdmFyaWFibGVzICovCisJCXJtYigpOworCQlpZiAocmV0ID09IFJFU19PSykKKwkJCS8qIHJlYWQgcmV0dXJuLXZhbHVlIG5vdyAqLworCQkJcmV0dXJuIGlvcmVhZDE2KCZjYXJkLT5kcHJhbVtEUFJBTV9GQ1RfUkVTVUxUXSk7CisKKwkJaWYgKChyZXQgIT0gdmVjdG9yKSB8fCB0aW1lX2FmdGVyKGppZmZpZXMsIHN0YW1wKSkKKwkJCWJyZWFrOworCQkvKiBwcm9jZXNzIGNvbnRleHQgPT4gcmVsYXggKi8KKwkJdXNsZWVwX3JhbmdlKDUwMCwgMTAwMDApOworCX0gd2hpbGUgKDEpOworCisJcmV0ID0gKHJldCA9PSBSRVNfTk9ORSkgPyAtRVRJTUVET1VUIDogLUVDQU5DRUxFRDsKKwlkZXZfYWxlcnQoJmNhcmQtPnBkZXYtPmRldiwgImZpcm13YXJlICVzIGZhaWxlZCAoJWkpXG4iLCBtc2csIHJldCk7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBzb2Z0aW5nX2ZjdF9jbWQoc3RydWN0IHNvZnRpbmcgKmNhcmQsIGludDE2X3QgY21kLCBjb25zdCBjaGFyICptc2cpCit7CisJaW50IHJldDsKKworCXJldCA9IF9zb2Z0aW5nX2ZjdF9jbWQoY2FyZCwgY21kLCAwLCBtc2cpOworCWlmIChyZXQgPiAwKSB7CisJCWRldl9hbGVydCgmY2FyZC0+cGRldi0+ZGV2LCAiJXMgcmV0dXJuZWQgJXVcbiIsIG1zZywgcmV0KTsKKwkJcmV0ID0gLUVJTzsKKwl9CisJcmV0dXJuIHJldDsKK30KKworaW50IHNvZnRpbmdfYm9vdGxvYWRlcl9jb21tYW5kKHN0cnVjdCBzb2Z0aW5nICpjYXJkLCBpbnQxNl90IGNtZCwKKwkJY29uc3QgY2hhciAqbXNnKQoreworCWludCByZXQ7CisJdW5zaWduZWQgbG9uZyBzdGFtcDsKKworCWlvd3JpdGUxNihSRVNfTk9ORSwgJmNhcmQtPmRwcmFtW0RQUkFNX1JFQ0VJUFRdKTsKKwlpb3dyaXRlMTYoY21kLCAmY2FyZC0+ZHByYW1bRFBSQU1fQ09NTUFORF0pOworCS8qIGJlIHN1cmUgdG8gZmx1c2ggdGhpcyB0byB0aGUgY2FyZCAqLworCXdtYigpOworCXN0YW1wID0gamlmZmllcyArIDMgKiBIWjsKKwkvKiB3YWl0IGZvciBjYXJkICovCisJZG8geworCQlyZXQgPSBpb3JlYWQxNigmY2FyZC0+ZHByYW1bRFBSQU1fUkVDRUlQVF0pOworCQkvKiBkb24ndCBoYXZlIGFueSBjYWNoZWQgdmFyaWFibGVzICovCisJCXJtYigpOworCQlpZiAocmV0ID09IFJFU19PSykKKwkJCXJldHVybiAwOworCQlpZiAodGltZV9hZnRlcihqaWZmaWVzLCBzdGFtcCkpCisJCQlicmVhazsKKwkJLyogcHJvY2VzcyBjb250ZXh0ID0+IHJlbGF4ICovCisJCXVzbGVlcF9yYW5nZSg1MDAsIDEwMDAwKTsKKwl9IHdoaWxlICghc2lnbmFsX3BlbmRpbmcoY3VycmVudCkpOworCisJcmV0ID0gKHJldCA9PSBSRVNfTk9ORSkgPyAtRVRJTUVET1VUIDogLUVDQU5DRUxFRDsKKwlkZXZfYWxlcnQoJmNhcmQtPnBkZXYtPmRldiwgImJvb3Rsb2FkZXIgJXMgZmFpbGVkICglaSlcbiIsIG1zZywgcmV0KTsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGZ3X3BhcnNlKGNvbnN0IHVpbnQ4X3QgKipwbWVtLCB1aW50MTZfdCAqcHR5cGUsIHVpbnQzMl90ICpwYWRkciwKKwkJdWludDE2X3QgKnBsZW4sIGNvbnN0IHVpbnQ4X3QgKipwZGF0KQoreworCXVpbnQxNl90IGNoZWNrc3VtWzJdOworCWNvbnN0IHVpbnQ4X3QgKm1lbTsKKwljb25zdCB1aW50OF90ICplbmQ7CisKKwkvKgorCSAqIGZpcm13YXJlIHJlY29yZHMgYXJlIGEgYmluYXJ5LCB1bmFsaWduZWQgc3RyZWFtIGNvbXBvc2VkIG9mOgorCSAqIHVpbnQxNl90IHR5cGU7CisJICogdWludDMyX3QgYWRkcjsKKwkgKiB1aW50MTZfdCBsZW47CisJICogdWludDhfdCBkYXRbbGVuXTsKKwkgKiB1aW50MTZfdCBjaGVja3N1bTsKKwkgKiBhbGwgdmFsdWVzIGluIGxpdHRsZSBlbmRpYW4uCisJICogV2UgY291bGQgZGVmaW5lIGEgc3RydWN0IGZvciB0aGlzLCB3aXRoIF9fYXR0cmlidXRlX18oKHBhY2tlZCkpLAorCSAqIGJ1dCB3b3VsZCB0aGF0IHNvbHZlIHRoZSBhbGlnbm1lbnQgaW4gX2FsbF8gY2FzZXMgKGNmci4gdGhlCisJICogc3RydWN0IGl0c2VsZiBtYXkgYmUgYW4gb2RkIGFkZHJlc3MpPworCSAqCisJICogSSBjaG9zZSB0byB1c2UgbGVYWF90b19jcHVwKCkgc2luY2UgdGhpcyBzb2x2ZXMgYm90aAorCSAqIGVuZGlhbm5lc3MgJiBhbGlnbm1lbnQuCisJICovCisJbWVtID0gKnBtZW07CisJKnB0eXBlID0gbGUxNl90b19jcHVwKCh2b2lkICopJm1lbVswXSk7CisJKnBhZGRyID0gbGUzMl90b19jcHVwKCh2b2lkICopJm1lbVsyXSk7CisJKnBsZW4gPSBsZTE2X3RvX2NwdXAoKHZvaWQgKikmbWVtWzZdKTsKKwkqcGRhdCA9ICZtZW1bOF07CisJLyogdmVyaWZ5IGNoZWNrc3VtICovCisJZW5kID0gJm1lbVs4ICsgKnBsZW5dOworCWNoZWNrc3VtWzBdID0gbGUxNl90b19jcHVwKCh2b2lkICopZW5kKTsKKwlmb3IgKGNoZWNrc3VtWzFdID0gMDsgbWVtIDwgZW5kOyArK21lbSkKKwkJY2hlY2tzdW1bMV0gKz0gKm1lbTsKKwlpZiAoY2hlY2tzdW1bMF0gIT0gY2hlY2tzdW1bMV0pCisJCXJldHVybiAtRUlOVkFMOworCS8qIGluY3JlbWVudCAqLworCSpwbWVtICs9IDEwICsgKnBsZW47CisJcmV0dXJuIDA7Cit9CisKK2ludCBzb2Z0aW5nX2xvYWRfZncoY29uc3QgY2hhciAqZmlsZSwgc3RydWN0IHNvZnRpbmcgKmNhcmQsCisJCV9faW9tZW0gdWludDhfdCAqZHByYW0sIHVuc2lnbmVkIGludCBzaXplLCBpbnQgb2Zmc2V0KQoreworCWNvbnN0IHN0cnVjdCBmaXJtd2FyZSAqZnc7CisJaW50IHJldDsKKwljb25zdCB1aW50OF90ICptZW0sICplbmQsICpkYXQ7CisJdWludDE2X3QgdHlwZSwgbGVuOworCXVpbnQzMl90IGFkZHI7CisJdWludDhfdCAqYnVmID0gTlVMTDsKKwlpbnQgYnVmbGVuID0gMDsKKwlpbnQ4X3QgdHlwZV9lbmQgPSAwOworCisJcmV0ID0gcmVxdWVzdF9maXJtd2FyZSgmZncsIGZpbGUsICZjYXJkLT5wZGV2LT5kZXYpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCWRldl9kYmcoJmNhcmQtPnBkZXYtPmRldiwgIiVzLCBmaXJtd2FyZSglcykgZ290ICV1IGJ5dGVzIgorCQkiLCBvZmZzZXQgJWMweCUwNHhcbiIsCisJCWNhcmQtPnBkYXQtPm5hbWUsIGZpbGUsICh1bnNpZ25lZCBpbnQpZnctPnNpemUsCisJCShvZmZzZXQgPj0gMCkgPyAnKycgOiAnLScsICh1bnNpZ25lZCBpbnQpYWJzKG9mZnNldCkpOworCS8qIHBhcnNlIHRoZSBmaXJtd2FyZSAqLworCW1lbSA9IGZ3LT5kYXRhOworCWVuZCA9ICZtZW1bZnctPnNpemVdOworCS8qIGxvb2sgZm9yIGhlYWRlciByZWNvcmQgKi8KKwlyZXQgPSBmd19wYXJzZSgmbWVtLCAmdHlwZSwgJmFkZHIsICZsZW4sICZkYXQpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWxlZDsKKwlpZiAodHlwZSAhPSAweGZmZmYpCisJCWdvdG8gZmFpbGVkOworCWlmIChzdHJuY21wKCJTdHJ1Y3R1cmVkIEJpbmFyeSBGb3JtYXQsIFNvZnRpbmcgR21iSCIgLCBkYXQsIGxlbikpIHsKKwkJcmV0ID0gLUVJTlZBTDsKKwkJZ290byBmYWlsZWQ7CisJfQorCS8qIG9rLCB3ZSBoYWQgYSBoZWFkZXIgKi8KKwl3aGlsZSAobWVtIDwgZW5kKSB7CisJCXJldCA9IGZ3X3BhcnNlKCZtZW0sICZ0eXBlLCAmYWRkciwgJmxlbiwgJmRhdCk7CisJCWlmIChyZXQgPCAwKQorCQkJZ290byBmYWlsZWQ7CisJCWlmICh0eXBlID09IDMpIHsKKwkJCS8qIHN0YXJ0IGFkZHJlc3MsIG5vdCB1c2VkIGhlcmUgKi8KKwkJCWNvbnRpbnVlOworCQl9IGVsc2UgaWYgKHR5cGUgPT0gMSkgeworCQkJLyogZW9mICovCisJCQl0eXBlX2VuZCA9IDE7CisJCQlicmVhazsKKwkJfSBlbHNlIGlmICh0eXBlICE9IDApIHsKKwkJCXJldCA9IC1FSU5WQUw7CisJCQlnb3RvIGZhaWxlZDsKKwkJfQorCisJCWlmICgoYWRkciArIGxlbiArIG9mZnNldCkgPiBzaXplKQorCQkJZ290byBmYWlsZWQ7CisJCW1lbWNweV90b2lvKCZkcHJhbVthZGRyICsgb2Zmc2V0XSwgZGF0LCBsZW4pOworCQkvKiBiZSBzdXJlIHRvIGZsdXNoIGNhY2hlcyBmcm9tIElPIHNwYWNlICovCisJCW1iKCk7CisJCWlmIChsZW4gPiBidWZsZW4pIHsKKwkJCS8qIGFsaWduIGJ1ZmxlbiAqLworCQkJYnVmbGVuID0gKGxlbiArICgxMDI0LTEpKSAmIH4oMTAyNC0xKTsKKwkJCWJ1ZiA9IGtyZWFsbG9jKGJ1ZiwgYnVmbGVuLCBHRlBfS0VSTkVMKTsKKwkJCWlmICghYnVmKSB7CisJCQkJcmV0ID0gLUVOT01FTTsKKwkJCQlnb3RvIGZhaWxlZDsKKwkJCX0KKwkJfQorCQkvKiB2ZXJpZnkgcmVjb3JkIGRhdGEgKi8KKwkJbWVtY3B5X2Zyb21pbyhidWYsICZkcHJhbVthZGRyICsgb2Zmc2V0XSwgbGVuKTsKKwkJaWYgKG1lbWNtcChidWYsIGRhdCwgbGVuKSkgeworCQkJLyogaXMgbm90IG9rICovCisJCQlkZXZfYWxlcnQoJmNhcmQtPnBkZXYtPmRldiwgIkRQUkFNIHJlYWRiYWNrIGZhaWxlZFxuIik7CisJCQlyZXQgPSAtRUlPOworCQkJZ290byBmYWlsZWQ7CisJCX0KKwl9CisJaWYgKCF0eXBlX2VuZCkKKwkJLyogbm8gZW5kIHJlY29yZCBzZWVuICovCisJCWdvdG8gZmFpbGVkOworCXJldCA9IDA7CitmYWlsZWQ6CisJa2ZyZWUoYnVmKTsKKwlyZWxlYXNlX2Zpcm13YXJlKGZ3KTsKKwlpZiAocmV0IDwgMCkKKwkJZGV2X2luZm8oJmNhcmQtPnBkZXYtPmRldiwgImZpcm13YXJlICVzIGZhaWxlZFxuIiwgZmlsZSk7CisJcmV0dXJuIHJldDsKK30KKworaW50IHNvZnRpbmdfbG9hZF9hcHBfZncoY29uc3QgY2hhciAqZmlsZSwgc3RydWN0IHNvZnRpbmcgKmNhcmQpCit7CisJY29uc3Qgc3RydWN0IGZpcm13YXJlICpmdzsKKwljb25zdCB1aW50OF90ICptZW0sICplbmQsICpkYXQ7CisJaW50IHJldCwgajsKKwl1aW50MTZfdCB0eXBlLCBsZW47CisJdWludDMyX3QgYWRkciwgc3RhcnRfYWRkciA9IDA7CisJdW5zaWduZWQgaW50IHN1bSwgcnhfc3VtOworCWludDhfdCB0eXBlX2VuZCA9IDAsIHR5cGVfZW50cnlwb2ludCA9IDA7CisKKwlyZXQgPSByZXF1ZXN0X2Zpcm13YXJlKCZmdywgZmlsZSwgJmNhcmQtPnBkZXYtPmRldik7CisJaWYgKHJldCkgeworCQlkZXZfYWxlcnQoJmNhcmQtPnBkZXYtPmRldiwgInJlcXVlc3RfZmlybXdhcmUoJXMpIGdvdCAlaVxuIiwKKwkJCWZpbGUsIHJldCk7CisJCXJldHVybiByZXQ7CisJfQorCWRldl9kYmcoJmNhcmQtPnBkZXYtPmRldiwgImZpcm13YXJlKCVzKSBnb3QgJWx1IGJ5dGVzXG4iLAorCQlmaWxlLCAodW5zaWduZWQgbG9uZylmdy0+c2l6ZSk7CisJLyogcGFyc2UgdGhlIGZpcm13YXJlICovCisJbWVtID0gZnctPmRhdGE7CisJZW5kID0gJm1lbVtmdy0+c2l6ZV07CisJLyogbG9vayBmb3IgaGVhZGVyIHJlY29yZCAqLworCXJldCA9IGZ3X3BhcnNlKCZtZW0sICZ0eXBlLCAmYWRkciwgJmxlbiwgJmRhdCk7CisJaWYgKHJldCkKKwkJZ290byBmYWlsZWQ7CisJcmV0ID0gLUVJTlZBTDsKKwlpZiAodHlwZSAhPSAweGZmZmYpIHsKKwkJZGV2X2FsZXJ0KCZjYXJkLT5wZGV2LT5kZXYsICJmaXJtd2FyZSBzdGFydHMgd2l0aCB0eXBlIDB4JXhcbiIsCisJCQl0eXBlKTsKKwkJZ290byBmYWlsZWQ7CisJfQorCWlmIChzdHJuY21wKCJTdHJ1Y3R1cmVkIEJpbmFyeSBGb3JtYXQsIFNvZnRpbmcgR21iSCIsIGRhdCwgbGVuKSkgeworCQlkZXZfYWxlcnQoJmNhcmQtPnBkZXYtPmRldiwgImZpcm13YXJlIHN0cmluZyAnJS4qcycgZmF1bHRcbiIsCisJCQkJbGVuLCBkYXQpOworCQlnb3RvIGZhaWxlZDsKKwl9CisJLyogb2ssIHdlIGhhZCBhIGhlYWRlciAqLworCXdoaWxlIChtZW0gPCBlbmQpIHsKKwkJcmV0ID0gZndfcGFyc2UoJm1lbSwgJnR5cGUsICZhZGRyLCAmbGVuLCAmZGF0KTsKKwkJaWYgKHJldCkKKwkJCWdvdG8gZmFpbGVkOworCisJCWlmICh0eXBlID09IDMpIHsKKwkJCS8qIHN0YXJ0IGFkZHJlc3MgKi8KKwkJCXN0YXJ0X2FkZHIgPSBhZGRyOworCQkJdHlwZV9lbnRyeXBvaW50ID0gMTsKKwkJCWNvbnRpbnVlOworCQl9IGVsc2UgaWYgKHR5cGUgPT0gMSkgeworCQkJLyogZW9mICovCisJCQl0eXBlX2VuZCA9IDE7CisJCQlicmVhazsKKwkJfSBlbHNlIGlmICh0eXBlICE9IDApIHsKKwkJCWRldl9hbGVydCgmY2FyZC0+cGRldi0+ZGV2LAorCQkJCQkidW5rbm93biByZWNvcmQgdHlwZSAweCUwNHhcbiIsIHR5cGUpOworCQkJcmV0ID0gLUVJTlZBTDsKKwkJCWdvdG8gZmFpbGVkOworCQl9CisKKwkJLyogcmVndWFsYXIgZGF0YSAqLworCQlmb3IgKHN1bSA9IDAsIGogPSAwOyBqIDwgbGVuOyArK2opCisJCQlzdW0gKz0gZGF0W2pdOworCQkvKiB3b3JrIGluIDE2Yml0ICh0YXJnZXQpICovCisJCXN1bSAmPSAweGZmZmY7CisKKwkJbWVtY3B5X3RvaW8oJmNhcmQtPmRwcmFtW2NhcmQtPnBkYXQtPmFwcC5vZmZzXSwgZGF0LCBsZW4pOworCQlpb3dyaXRlMzIoY2FyZC0+cGRhdC0+YXBwLm9mZnMgKyBjYXJkLT5wZGF0LT5hcHAuYWRkciwKKwkJCQkmY2FyZC0+ZHByYW1bRFBSQU1fQ09NTUFORCArIDJdKTsKKwkJaW93cml0ZTMyKGFkZHIsICZjYXJkLT5kcHJhbVtEUFJBTV9DT01NQU5EICsgNl0pOworCQlpb3dyaXRlMTYobGVuLCAmY2FyZC0+ZHByYW1bRFBSQU1fQ09NTUFORCArIDEwXSk7CisJCWlvd3JpdGU4KDEsICZjYXJkLT5kcHJhbVtEUFJBTV9DT01NQU5EICsgMTJdKTsKKwkJcmV0ID0gc29mdGluZ19ib290bG9hZGVyX2NvbW1hbmQoY2FyZCwgMSwgImxvYWRpbmcgYXBwLiIpOworCQlpZiAocmV0IDwgMCkKKwkJCWdvdG8gZmFpbGVkOworCQkvKiB2ZXJpZnkgY2hlY2tzdW0gKi8KKwkJcnhfc3VtID0gaW9yZWFkMTYoJmNhcmQtPmRwcmFtW0RQUkFNX1JFQ0VJUFQgKyAyXSk7CisJCWlmIChyeF9zdW0gIT0gc3VtKSB7CisJCQlkZXZfYWxlcnQoJmNhcmQtPnBkZXYtPmRldiwgIlNSQU0gc2VlbXMgdG8gYmUgZGFtYWdlZCIKKwkJCQkiLCB3YW50ZWQgMHglMDR4LCBnb3QgMHglMDR4XG4iLCBzdW0sIHJ4X3N1bSk7CisJCQlyZXQgPSAtRUlPOworCQkJZ290byBmYWlsZWQ7CisJCX0KKwl9CisJaWYgKCF0eXBlX2VuZCB8fCAhdHlwZV9lbnRyeXBvaW50KQorCQlnb3RvIGZhaWxlZDsKKwkvKiBzdGFydCBhcHBsaWNhdGlvbiBpbiBjYXJkICovCisJaW93cml0ZTMyKHN0YXJ0X2FkZHIsICZjYXJkLT5kcHJhbVtEUFJBTV9DT01NQU5EICsgMl0pOworCWlvd3JpdGU4KDEsICZjYXJkLT5kcHJhbVtEUFJBTV9DT01NQU5EICsgNl0pOworCXJldCA9IHNvZnRpbmdfYm9vdGxvYWRlcl9jb21tYW5kKGNhcmQsIDMsICJzdGFydCBhcHAuIik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFpbGVkOworCXJldCA9IDA7CitmYWlsZWQ6CisJcmVsZWFzZV9maXJtd2FyZShmdyk7CisJaWYgKHJldCA8IDApCisJCWRldl9pbmZvKCZjYXJkLT5wZGV2LT5kZXYsICJmaXJtd2FyZSAlcyBmYWlsZWRcbiIsIGZpbGUpOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgc29mdGluZ19yZXNldF9jaGlwKHN0cnVjdCBzb2Z0aW5nICpjYXJkKQoreworCWludCByZXQ7CisKKwlkbyB7CisJCS8qIHJlc2V0IGNoaXAgKi8KKwkJaW93cml0ZTgoMCwgJmNhcmQtPmRwcmFtW0RQUkFNX1JFU0VUX1JYX0ZJRk9dKTsKKwkJaW93cml0ZTgoMCwgJmNhcmQtPmRwcmFtW0RQUkFNX1JFU0VUX1JYX0ZJRk8rMV0pOworCQlpb3dyaXRlOCgxLCAmY2FyZC0+ZHByYW1bRFBSQU1fUkVTRVRdKTsKKwkJaW93cml0ZTgoMCwgJmNhcmQtPmRwcmFtW0RQUkFNX1JFU0VUKzFdKTsKKworCQlyZXQgPSBzb2Z0aW5nX2ZjdF9jbWQoY2FyZCwgMCwgInJlc2V0X2NhbiIpOworCQlpZiAoIXJldCkKKwkJCWJyZWFrOworCQlpZiAoc2lnbmFsX3BlbmRpbmcoY3VycmVudCkpCisJCQkvKiBkb24ndCB3YWl0IGFueSBsb25nZXIgKi8KKwkJCWJyZWFrOworCX0gd2hpbGUgKDEpOworCWNhcmQtPnR4LnBlbmRpbmcgPSAwOworCXJldHVybiByZXQ7Cit9CisKK2ludCBzb2Z0aW5nX2NoaXBfcG93ZXJvbihzdHJ1Y3Qgc29mdGluZyAqY2FyZCkKK3sKKwlpbnQgcmV0OworCS8qIHN5bmMgKi8KKwlyZXQgPSBfc29mdGluZ19mY3RfY21kKGNhcmQsIDk5LCAweDU1LCAic3luYy1hIik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFpbGVkOworCisJcmV0ID0gX3NvZnRpbmdfZmN0X2NtZChjYXJkLCA5OSwgMHhhYSwgInN5bmMtYiIpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWxlZDsKKworCXJldCA9IHNvZnRpbmdfcmVzZXRfY2hpcChjYXJkKTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBmYWlsZWQ7CisJLyogZ2V0X3NlcmlhbCAqLworCXJldCA9IHNvZnRpbmdfZmN0X2NtZChjYXJkLCA0MywgImdldF9zZXJpYWxfbnVtYmVyIik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFpbGVkOworCWNhcmQtPmlkLnNlcmlhbCA9IGlvcmVhZDMyKCZjYXJkLT5kcHJhbVtEUFJBTV9GQ1RfUEFSQU1dKTsKKwkvKiBnZXRfdmVyc2lvbiAqLworCXJldCA9IHNvZnRpbmdfZmN0X2NtZChjYXJkLCAxMiwgImdldF92ZXJzaW9uIik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFpbGVkOworCWNhcmQtPmlkLmZ3X3ZlcnNpb24gPSBpb3JlYWQxNigmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgMl0pOworCWNhcmQtPmlkLmh3X3ZlcnNpb24gPSBpb3JlYWQxNigmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgNF0pOworCWNhcmQtPmlkLmxpY2Vuc2UgPSBpb3JlYWQxNigmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgNl0pOworCWNhcmQtPmlkLmNoaXBbMF0gPSBpb3JlYWQxNigmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgOF0pOworCWNhcmQtPmlkLmNoaXBbMV0gPSBpb3JlYWQxNigmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgMTBdKTsKKwlyZXR1cm4gMDsKK2ZhaWxlZDoKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCBzb2Z0aW5nX2luaXRpYWxpemVfdGltZXN0YW1wKHN0cnVjdCBzb2Z0aW5nICpjYXJkKQoreworCXVpbnQ2NF90IG92ZjsKKworCWNhcmQtPnRzX3JlZiA9IGt0aW1lX2dldCgpOworCisJLyogMTZNSHogaXMgdGhlIHJlZmVyZW5jZSAqLworCW92ZiA9IDB4MTAwMDAwMDAwVUxMICogMTY7CisJZG9fZGl2KG92ZiwgY2FyZC0+cGRhdC0+ZnJlcSA/OiAxNik7CisKKwljYXJkLT50c19vdmVyZmxvdyA9IGt0aW1lX2FkZF91cyhrdGltZV9zZXQoMCwgMCksIG92Zik7Cit9CisKK2t0aW1lX3Qgc29mdGluZ19yYXcya3RpbWUoc3RydWN0IHNvZnRpbmcgKmNhcmQsIHUzMiByYXcpCit7CisJdWludDY0X3QgcmF3bDsKKwlrdGltZV90IG5vdywgcmVhbF9vZmZzZXQ7CisJa3RpbWVfdCB0YXJnZXQ7CisJa3RpbWVfdCB0bXA7CisKKwlub3cgPSBrdGltZV9nZXQoKTsKKwlyZWFsX29mZnNldCA9IGt0aW1lX3N1YihrdGltZV9nZXRfcmVhbCgpLCBub3cpOworCisJLyogZmluZCBuc2VjIGZyb20gY2FyZCAqLworCXJhd2wgPSByYXcgKiAxNjsKKwlkb19kaXYocmF3bCwgY2FyZC0+cGRhdC0+ZnJlcSA/OiAxNik7CisJdGFyZ2V0ID0ga3RpbWVfYWRkX3VzKGNhcmQtPnRzX3JlZiwgcmF3bCk7CisJLyogdGVzdCBmb3Igb3ZlcmZsb3dzICovCisJdG1wID0ga3RpbWVfYWRkKHRhcmdldCwgY2FyZC0+dHNfb3ZlcmZsb3cpOworCXdoaWxlICh1bmxpa2VseShrdGltZV90b19ucyh0bXApID4ga3RpbWVfdG9fbnMobm93KSkpIHsKKwkJY2FyZC0+dHNfcmVmID0ga3RpbWVfYWRkKGNhcmQtPnRzX3JlZiwgY2FyZC0+dHNfb3ZlcmZsb3cpOworCQl0YXJnZXQgPSB0bXA7CisJCXRtcCA9IGt0aW1lX2FkZCh0YXJnZXQsIGNhcmQtPnRzX292ZXJmbG93KTsKKwl9CisJcmV0dXJuIGt0aW1lX2FkZCh0YXJnZXQsIHJlYWxfb2Zmc2V0KTsKK30KKworc3RhdGljIGlubGluZSBpbnQgc29mdGluZ19lcnJvcl9yZXBvcnRpbmcoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikKK3sKKwlzdHJ1Y3Qgc29mdGluZ19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKworCXJldHVybiAocHJpdi0+Y2FuLmN0cmxtb2RlICYgQ0FOX0NUUkxNT0RFX0JFUlJfUkVQT1JUSU5HKQorCQk/IDEgOiAwOworfQorCitpbnQgc29mdGluZ19zdGFydHN0b3Aoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgaW50IHVwKQoreworCWludCByZXQ7CisJc3RydWN0IHNvZnRpbmcgKmNhcmQ7CisJc3RydWN0IHNvZnRpbmdfcHJpdiAqcHJpdjsKKwlzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2OworCWludCBidXNfYml0bWFza19zdGFydDsKKwlpbnQgaiwgZXJyb3JfcmVwb3J0aW5nOworCXN0cnVjdCBjYW5fZnJhbWUgbXNnOworCWNvbnN0IHN0cnVjdCBjYW5fYml0dGltaW5nICpidDsKKworCXByaXYgPSBuZXRkZXZfcHJpdihkZXYpOworCWNhcmQgPSBwcml2LT5jYXJkOworCisJaWYgKCFjYXJkLT5mdy51cCkKKwkJcmV0dXJuIC1FSU87CisKKwlyZXQgPSBtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmNhcmQtPmZ3LmxvY2spOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlidXNfYml0bWFza19zdGFydCA9IDA7CisJaWYgKGRldiAmJiB1cCkKKwkJLyogcHJlcGFyZSB0byBzdGFydCB0aGlzIGJ1cyBhcyB3ZWxsICovCisJCWJ1c19iaXRtYXNrX3N0YXJ0IHw9ICgxIDw8IHByaXYtPmluZGV4KTsKKwkvKiBicmluZyBuZXRkZXZzIGRvd24gKi8KKwlmb3IgKGogPSAwOyBqIDwgQVJSQVlfU0laRShjYXJkLT5uZXQpOyArK2opIHsKKwkJbmV0ZGV2ID0gY2FyZC0+bmV0W2pdOworCQlpZiAoIW5ldGRldikKKwkJCWNvbnRpbnVlOworCQlwcml2ID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKworCQlpZiAoZGV2ICE9IG5ldGRldikKKwkJCW5ldGlmX3N0b3BfcXVldWUobmV0ZGV2KTsKKworCQlpZiAobmV0aWZfcnVubmluZyhuZXRkZXYpKSB7CisJCQlpZiAoZGV2ICE9IG5ldGRldikKKwkJCQlidXNfYml0bWFza19zdGFydCB8PSAoMSA8PCBqKTsKKwkJCXByaXYtPnR4LnBlbmRpbmcgPSAwOworCQkJcHJpdi0+dHguZWNob19wdXQgPSAwOworCQkJcHJpdi0+dHguZWNob19nZXQgPSAwOworCQkJLyoKKwkJCSAqIHRoaXMgYnVzJyBtYXkganVzdCBoYXZlIGNhbGxlZCBvcGVuX2NhbmRldigpCisJCQkgKiB3aGljaCBpcyByYXRoZXIgc3R1cGlkIHRvIGNhbGwgY2xvc2VfY2FuZGV2KCkKKwkJCSAqIGFscmVhZHkKKwkJCSAqIGJ1dCB3ZSBtYXkgY29tZSBoZXJlIGZyb20gYnVzb2ZmIHJlY292ZXJ5IHRvbworCQkJICogaW4gd2hpY2ggY2FzZSB0aGUgZWNob19za2IgX25lZWRzXyBmbHVzaGluZyB0b28uCisJCQkgKiBqdXN0IGJlIHN1cmUgdG8gY2FsbCBvcGVuX2NhbmRldigpIGFnYWluCisJCQkgKi8KKwkJCWNsb3NlX2NhbmRldihuZXRkZXYpOworCQl9CisJCXByaXYtPmNhbi5zdGF0ZSA9IENBTl9TVEFURV9TVE9QUEVEOworCX0KKwljYXJkLT50eC5wZW5kaW5nID0gMDsKKworCXNvZnRpbmdfZW5hYmxlX2lycShjYXJkLCAwKTsKKwlyZXQgPSBzb2Z0aW5nX3Jlc2V0X2NoaXAoY2FyZCk7CisJaWYgKHJldCkKKwkJZ290byBmYWlsZWQ7CisJaWYgKCFidXNfYml0bWFza19zdGFydCkKKwkJLyogbm8gYnVzc2VzIHRvIGJlIGJyb3VnaHQgdXAgKi8KKwkJZ290byBjYXJkX2RvbmU7CisKKwlpZiAoKGJ1c19iaXRtYXNrX3N0YXJ0ICYgMSkgJiYgKGJ1c19iaXRtYXNrX3N0YXJ0ICYgMikKKwkJCSYmIChzb2Z0aW5nX2Vycm9yX3JlcG9ydGluZyhjYXJkLT5uZXRbMF0pCisJCQkJIT0gc29mdGluZ19lcnJvcl9yZXBvcnRpbmcoY2FyZC0+bmV0WzFdKSkpIHsKKwkJZGV2X2FsZXJ0KCZjYXJkLT5wZGV2LT5kZXYsCisJCQkJImVycl9yZXBvcnRpbmcgZmxhZyBkaWZmZXJzIGZvciBidXNzZXNcbiIpOworCQlnb3RvIGludmFsaWQ7CisJfQorCWVycm9yX3JlcG9ydGluZyA9IDA7CisJaWYgKGJ1c19iaXRtYXNrX3N0YXJ0ICYgMSkgeworCQluZXRkZXYgPSBjYXJkLT5uZXRbMF07CisJCXByaXYgPSBuZXRkZXZfcHJpdihuZXRkZXYpOworCQllcnJvcl9yZXBvcnRpbmcgKz0gc29mdGluZ19lcnJvcl9yZXBvcnRpbmcobmV0ZGV2KTsKKwkJLyogaW5pdCBjaGlwIDEgKi8KKwkJYnQgPSAmcHJpdi0+Y2FuLmJpdHRpbWluZzsKKwkJaW93cml0ZTE2KGJ0LT5icnAsICZjYXJkLT5kcHJhbVtEUFJBTV9GQ1RfUEFSQU0gKyAyXSk7CisJCWlvd3JpdGUxNihidC0+c2p3LCAmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgNF0pOworCQlpb3dyaXRlMTYoYnQtPnBoYXNlX3NlZzEgKyBidC0+cHJvcF9zZWcsCisJCQkJJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDZdKTsKKwkJaW93cml0ZTE2KGJ0LT5waGFzZV9zZWcyLCAmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgOF0pOworCQlpb3dyaXRlMTYoKHByaXYtPmNhbi5jdHJsbW9kZSAmIENBTl9DVFJMTU9ERV8zX1NBTVBMRVMpID8gMSA6IDAsCisJCQkJJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDEwXSk7CisJCXJldCA9IHNvZnRpbmdfZmN0X2NtZChjYXJkLCAxLCAiaW5pdGlhbGl6ZV9jaGlwWzBdIik7CisJCWlmIChyZXQgPCAwKQorCQkJZ290byBmYWlsZWQ7CisJCS8qIHNldCBtb2RlICovCisJCWlvd3JpdGUxNigwLCAmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgMl0pOworCQlpb3dyaXRlMTYoMCwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDRdKTsKKwkJcmV0ID0gc29mdGluZ19mY3RfY21kKGNhcmQsIDMsICJzZXRfbW9kZVswXSIpOworCQlpZiAocmV0IDwgMCkKKwkJCWdvdG8gZmFpbGVkOworCQkvKiBzZXQgZmlsdGVyICovCisJCS8qIDExYml0IGlkICYgbWFzayAqLworCQlpb3dyaXRlMTYoMHgwMDAwLCAmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgMl0pOworCQlpb3dyaXRlMTYoMHgwN2ZmLCAmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgNF0pOworCQkvKiAyOWJpdCBpZC5sbyAmIG1hc2subG8gJiBpZC5oaSAmIG1hc2suaGkgKi8KKwkJaW93cml0ZTE2KDB4MDAwMCwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDZdKTsKKwkJaW93cml0ZTE2KDB4ZmZmZiwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDhdKTsKKwkJaW93cml0ZTE2KDB4MDAwMCwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDEwXSk7CisJCWlvd3JpdGUxNigweDFmZmYsICZjYXJkLT5kcHJhbVtEUFJBTV9GQ1RfUEFSQU0gKyAxMl0pOworCQlyZXQgPSBzb2Z0aW5nX2ZjdF9jbWQoY2FyZCwgNywgInNldF9maWx0ZXJbMF0iKTsKKwkJaWYgKHJldCA8IDApCisJCQlnb3RvIGZhaWxlZDsKKwkJLyogc2V0IG91dHB1dCBjb250cm9sICovCisJCWlvd3JpdGUxNihwcml2LT5vdXRwdXQsICZjYXJkLT5kcHJhbVtEUFJBTV9GQ1RfUEFSQU0gKyAyXSk7CisJCXJldCA9IHNvZnRpbmdfZmN0X2NtZChjYXJkLCA1LCAic2V0X291dHB1dFswXSIpOworCQlpZiAocmV0IDwgMCkKKwkJCWdvdG8gZmFpbGVkOworCX0KKwlpZiAoYnVzX2JpdG1hc2tfc3RhcnQgJiAyKSB7CisJCW5ldGRldiA9IGNhcmQtPm5ldFsxXTsKKwkJcHJpdiA9IG5ldGRldl9wcml2KG5ldGRldik7CisJCWVycm9yX3JlcG9ydGluZyArPSBzb2Z0aW5nX2Vycm9yX3JlcG9ydGluZyhuZXRkZXYpOworCQkvKiBpbml0IGNoaXAyICovCisJCWJ0ID0gJnByaXYtPmNhbi5iaXR0aW1pbmc7CisJCWlvd3JpdGUxNihidC0+YnJwLCAmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgMl0pOworCQlpb3dyaXRlMTYoYnQtPnNqdywgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDRdKTsKKwkJaW93cml0ZTE2KGJ0LT5waGFzZV9zZWcxICsgYnQtPnByb3Bfc2VnLAorCQkJCSZjYXJkLT5kcHJhbVtEUFJBTV9GQ1RfUEFSQU0gKyA2XSk7CisJCWlvd3JpdGUxNihidC0+cGhhc2Vfc2VnMiwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDhdKTsKKwkJaW93cml0ZTE2KChwcml2LT5jYW4uY3RybG1vZGUgJiBDQU5fQ1RSTE1PREVfM19TQU1QTEVTKSA/IDEgOiAwLAorCQkJCSZjYXJkLT5kcHJhbVtEUFJBTV9GQ1RfUEFSQU0gKyAxMF0pOworCQlyZXQgPSBzb2Z0aW5nX2ZjdF9jbWQoY2FyZCwgMiwgImluaXRpYWxpemVfY2hpcFsxXSIpOworCQlpZiAocmV0IDwgMCkKKwkJCWdvdG8gZmFpbGVkOworCQkvKiBzZXQgbW9kZTIgKi8KKwkJaW93cml0ZTE2KDAsICZjYXJkLT5kcHJhbVtEUFJBTV9GQ1RfUEFSQU0gKyAyXSk7CisJCWlvd3JpdGUxNigwLCAmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgNF0pOworCQlyZXQgPSBzb2Z0aW5nX2ZjdF9jbWQoY2FyZCwgNCwgInNldF9tb2RlWzFdIik7CisJCWlmIChyZXQgPCAwKQorCQkJZ290byBmYWlsZWQ7CisJCS8qIHNldCBmaWx0ZXIyICovCisJCS8qIDExYml0IGlkICYgbWFzayAqLworCQlpb3dyaXRlMTYoMHgwMDAwLCAmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgMl0pOworCQlpb3dyaXRlMTYoMHgwN2ZmLCAmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgNF0pOworCQkvKiAyOWJpdCBpZC5sbyAmIG1hc2subG8gJiBpZC5oaSAmIG1hc2suaGkgKi8KKwkJaW93cml0ZTE2KDB4MDAwMCwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDZdKTsKKwkJaW93cml0ZTE2KDB4ZmZmZiwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDhdKTsKKwkJaW93cml0ZTE2KDB4MDAwMCwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDEwXSk7CisJCWlvd3JpdGUxNigweDFmZmYsICZjYXJkLT5kcHJhbVtEUFJBTV9GQ1RfUEFSQU0gKyAxMl0pOworCQlyZXQgPSBzb2Z0aW5nX2ZjdF9jbWQoY2FyZCwgOCwgInNldF9maWx0ZXJbMV0iKTsKKwkJaWYgKHJldCA8IDApCisJCQlnb3RvIGZhaWxlZDsKKwkJLyogc2V0IG91dHB1dCBjb250cm9sMiAqLworCQlpb3dyaXRlMTYocHJpdi0+b3V0cHV0LCAmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgMl0pOworCQlyZXQgPSBzb2Z0aW5nX2ZjdF9jbWQoY2FyZCwgNiwgInNldF9vdXRwdXRbMV0iKTsKKwkJaWYgKHJldCA8IDApCisJCQlnb3RvIGZhaWxlZDsKKwl9CisJLyogZW5hYmxlX2Vycm9yX2ZyYW1lICovCisJLyoKKwkgKiBFcnJvciByZXBvcnRpbmcgaXMgc3dpdGNoZWQgb2ZmIGF0IHRoZSBtb21lbnQgc2luY2UKKwkgKiB0aGUgcmVjZWl2aW5nIG9mIHRoZW0gaXMgbm90IHlldCAxMDAlIHZlcmlmaWVkCisJICogVGhpcyBzaG91bGQgYmUgZW5hYmxlZCBzb29uZXIgb3IgbGF0ZXIKKwkgKgorCWlmIChlcnJvcl9yZXBvcnRpbmcpIHsKKwkJcmV0ID0gc29mdGluZ19mY3RfY21kKGNhcmQsIDUxLCAiZW5hYmxlX2Vycm9yX2ZyYW1lIik7CisJCWlmIChyZXQgPCAwKQorCQkJZ290byBmYWlsZWQ7CisJfQorCSovCisJLyogaW5pdGlhbGl6ZSBpbnRlcmZhY2UgKi8KKwlpb3dyaXRlMTYoMSwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDJdKTsKKwlpb3dyaXRlMTYoMSwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDRdKTsKKwlpb3dyaXRlMTYoMSwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDZdKTsKKwlpb3dyaXRlMTYoMSwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDhdKTsKKwlpb3dyaXRlMTYoMSwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDEwXSk7CisJaW93cml0ZTE2KDEsICZjYXJkLT5kcHJhbVtEUFJBTV9GQ1RfUEFSQU0gKyAxMl0pOworCWlvd3JpdGUxNigxLCAmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgMTRdKTsKKwlpb3dyaXRlMTYoMSwgJmNhcmQtPmRwcmFtW0RQUkFNX0ZDVF9QQVJBTSArIDE2XSk7CisJaW93cml0ZTE2KDEsICZjYXJkLT5kcHJhbVtEUFJBTV9GQ1RfUEFSQU0gKyAxOF0pOworCWlvd3JpdGUxNigxLCAmY2FyZC0+ZHByYW1bRFBSQU1fRkNUX1BBUkFNICsgMjBdKTsKKwlyZXQgPSBzb2Z0aW5nX2ZjdF9jbWQoY2FyZCwgMTcsICJpbml0aWFsaXplX2ludGVyZmFjZSIpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWxlZDsKKwkvKiBlbmFibGVfZmlmbyAqLworCXJldCA9IHNvZnRpbmdfZmN0X2NtZChjYXJkLCAzNiwgImVuYWJsZV9maWZvIik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFpbGVkOworCS8qIGVuYWJsZSBmaWZvIHR4IGFjayAqLworCXJldCA9IHNvZnRpbmdfZmN0X2NtZChjYXJkLCAxMywgImZpZm9fdHhfYWNrWzBdIik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFpbGVkOworCS8qIGVuYWJsZSBmaWZvIHR4IGFjazIgKi8KKwlyZXQgPSBzb2Z0aW5nX2ZjdF9jbWQoY2FyZCwgMTQsICJmaWZvX3R4X2Fja1sxXSIpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWxlZDsKKwkvKiBzdGFydF9jaGlwICovCisJcmV0ID0gc29mdGluZ19mY3RfY21kKGNhcmQsIDExLCAic3RhcnRfY2hpcCIpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWxlZDsKKwlpb3dyaXRlOCgwLCAmY2FyZC0+ZHByYW1bRFBSQU1fSU5GT19CVVNTVEFURV0pOworCWlvd3JpdGU4KDAsICZjYXJkLT5kcHJhbVtEUFJBTV9JTkZPX0JVU1NUQVRFMl0pOworCWlmIChjYXJkLT5wZGF0LT5nZW5lcmF0aW9uIDwgMikgeworCQlpb3dyaXRlOCgwLCAmY2FyZC0+ZHByYW1bRFBSQU1fVjJfSVJRX1RPSE9TVF0pOworCQkvKiBmbHVzaCB0aGUgRFBSQU0gY2FjaGVzICovCisJCXdtYigpOworCX0KKworCXNvZnRpbmdfaW5pdGlhbGl6ZV90aW1lc3RhbXAoY2FyZCk7CisKKwkvKgorCSAqIGRvIHNvY2tldGNhbiBub3RpZmljYXRpb25zL3N0YXR1cyBjaGFuZ2VzCisJICogZnJvbSBoZXJlLCBubyBlcnJvcnMgc2hvdWxkIG9jY3VyLCBvciB0aGUgZmFpbGVkOiBwYXJ0CisJICogbXVzdCBiZSByZXZpZXdlZAorCSAqLworCW1lbXNldCgmbXNnLCAwLCBzaXplb2YobXNnKSk7CisJbXNnLmNhbl9pZCA9IENBTl9FUlJfRkxBRyB8IENBTl9FUlJfUkVTVEFSVEVEOworCW1zZy5jYW5fZGxjID0gQ0FOX0VSUl9ETEM7CisJZm9yIChqID0gMDsgaiA8IEFSUkFZX1NJWkUoY2FyZC0+bmV0KTsgKytqKSB7CisJCWlmICghKGJ1c19iaXRtYXNrX3N0YXJ0ICYgKDEgPDwgaikpKQorCQkJY29udGludWU7CisJCW5ldGRldiA9IGNhcmQtPm5ldFtqXTsKKwkJaWYgKCFuZXRkZXYpCisJCQljb250aW51ZTsKKwkJcHJpdiA9IG5ldGRldl9wcml2KG5ldGRldik7CisJCXByaXYtPmNhbi5zdGF0ZSA9IENBTl9TVEFURV9FUlJPUl9BQ1RJVkU7CisJCW9wZW5fY2FuZGV2KG5ldGRldik7CisJCWlmIChkZXYgIT0gbmV0ZGV2KSB7CisJCQkvKiBub3RpZnkgb3RoZXIgYnVzc2VzIG9uIHRoZSByZXN0YXJ0ICovCisJCQlzb2Z0aW5nX25ldGRldl9yeChuZXRkZXYsICZtc2csIGt0aW1lX3NldCgwLCAwKSk7CisJCQkrK3ByaXYtPmNhbi5jYW5fc3RhdHMucmVzdGFydHM7CisJCX0KKwkJbmV0aWZfd2FrZV9xdWV1ZShuZXRkZXYpOworCX0KKworCS8qIGVuYWJsZSBpbnRlcnJ1cHRzICovCisJcmV0ID0gc29mdGluZ19lbmFibGVfaXJxKGNhcmQsIDEpOworCWlmIChyZXQpCisJCWdvdG8gZmFpbGVkOworY2FyZF9kb25lOgorCW11dGV4X3VubG9jaygmY2FyZC0+ZncubG9jayk7CisJcmV0dXJuIDA7CitpbnZhbGlkOgorCXJldCA9IC1FSU5WQUw7CitmYWlsZWQ6CisJc29mdGluZ19lbmFibGVfaXJxKGNhcmQsIDApOworCXNvZnRpbmdfcmVzZXRfY2hpcChjYXJkKTsKKwltdXRleF91bmxvY2soJmNhcmQtPmZ3LmxvY2spOworCS8qIGJyaW5nIGFsbCBvdGhlciBpbnRlcmZhY2VzIGRvd24gKi8KKwlmb3IgKGogPSAwOyBqIDwgQVJSQVlfU0laRShjYXJkLT5uZXQpOyArK2opIHsKKwkJbmV0ZGV2ID0gY2FyZC0+bmV0W2pdOworCQlpZiAoIW5ldGRldikKKwkJCWNvbnRpbnVlOworCQlkZXZfY2xvc2UobmV0ZGV2KTsKKwl9CisJcmV0dXJuIHJldDsKK30KKworaW50IHNvZnRpbmdfZGVmYXVsdF9vdXRwdXQoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikKK3sKKwlzdHJ1Y3Qgc29mdGluZ19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKwlzdHJ1Y3Qgc29mdGluZyAqY2FyZCA9IHByaXYtPmNhcmQ7CisKKwlzd2l0Y2ggKHByaXYtPmNoaXApIHsKKwljYXNlIDEwMDA6CisJCXJldHVybiAoY2FyZC0+cGRhdC0+Z2VuZXJhdGlvbiA8IDIpID8gMHhmYiA6IDB4ZmE7CisJY2FzZSA1OgorCQlyZXR1cm4gMHg2MDsKKwlkZWZhdWx0OgorCQlyZXR1cm4gMHg0MDsKKwl9Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vc29mdGluZy9zb2Z0aW5nX21haW4uYyBiL2RyaXZlcnMvbmV0L2Nhbi9zb2Z0aW5nL3NvZnRpbmdfbWFpbi5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjUxNTdlMTUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL25ldC9jYW4vc29mdGluZy9zb2Z0aW5nX21haW4uYwpAQCAtMCwwICsxLDg5MyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOC0yMDEwCisgKgorICogLSBLdXJ0IFZhbiBEaWpjaywgRUlBIEVsZWN0cm9uaWNzCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgdmVyc2lvbiAyIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UsIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3IFVTQQorICovCisKKyNpbmNsdWRlIDxsaW51eC92ZXJzaW9uLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgorCisjaW5jbHVkZSAic29mdGluZy5oIgorCisjZGVmaW5lIFRYX0VDSE9fU0tCX01BWCAoKChUWE1BWCsxKS8yKS0xKQorCisvKgorICogdGVzdCBpcyBhIHNwZWNpZmljIENBTiBuZXRkZXYKKyAqIGlzIG9ubGluZSAoaWUuIHVwICduIHJ1bm5pbmcsIG5vdCBzbGVlcGluZywgbm90IGJ1c29mZgorICovCitzdGF0aWMgaW5saW5lIGludCBjYW5pZl9pc19hY3RpdmUoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikKK3sKKwlzdHJ1Y3QgY2FuX3ByaXYgKmNhbiA9IG5ldGRldl9wcml2KG5ldGRldik7CisKKwlpZiAoIW5ldGlmX3J1bm5pbmcobmV0ZGV2KSkKKwkJcmV0dXJuIDA7CisJcmV0dXJuIChjYW4tPnN0YXRlIDw9IENBTl9TVEFURV9FUlJPUl9QQVNTSVZFKTsKK30KKworLyogcmVzZXQgRFBSQU0gKi8KK3N0YXRpYyBpbmxpbmUgdm9pZCBzb2Z0aW5nX3NldF9yZXNldF9kcHJhbShzdHJ1Y3Qgc29mdGluZyAqY2FyZCkKK3sKKwlpZiAoY2FyZC0+cGRhdC0+Z2VuZXJhdGlvbiA+PSAyKSB7CisJCXNwaW5fbG9ja19iaCgmY2FyZC0+c3Bpbik7CisJCWlvd3JpdGU4KGlvcmVhZDgoJmNhcmQtPmRwcmFtW0RQUkFNX1YyX1JFU0VUXSkgJiB+MSwKKwkJCQkmY2FyZC0+ZHByYW1bRFBSQU1fVjJfUkVTRVRdKTsKKwkJc3Bpbl91bmxvY2tfYmgoJmNhcmQtPnNwaW4pOworCX0KK30KKworc3RhdGljIGlubGluZSB2b2lkIHNvZnRpbmdfY2xyX3Jlc2V0X2RwcmFtKHN0cnVjdCBzb2Z0aW5nICpjYXJkKQoreworCWlmIChjYXJkLT5wZGF0LT5nZW5lcmF0aW9uID49IDIpIHsKKwkJc3Bpbl9sb2NrX2JoKCZjYXJkLT5zcGluKTsKKwkJaW93cml0ZTgoaW9yZWFkOCgmY2FyZC0+ZHByYW1bRFBSQU1fVjJfUkVTRVRdKSB8IDEsCisJCQkJJmNhcmQtPmRwcmFtW0RQUkFNX1YyX1JFU0VUXSk7CisJCXNwaW5fdW5sb2NrX2JoKCZjYXJkLT5zcGluKTsKKwl9Cit9CisKKy8qIHRyaWdnZXIgdGhlIHR4IHF1ZXVlLWluZyAqLworc3RhdGljIG5ldGRldl90eF90IHNvZnRpbmdfbmV0ZGV2X3N0YXJ0X3htaXQoc3RydWN0IHNrX2J1ZmYgKnNrYiwKKwkJc3RydWN0IG5ldF9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3Qgc29mdGluZ19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKwlzdHJ1Y3Qgc29mdGluZyAqY2FyZCA9IHByaXYtPmNhcmQ7CisJaW50IHJldDsKKwl1aW50OF90ICpwdHI7CisJdWludDhfdCBmaWZvX3dyLCBmaWZvX3JkOworCXN0cnVjdCBjYW5fZnJhbWUgKmNmID0gKHN0cnVjdCBjYW5fZnJhbWUgKilza2ItPmRhdGE7CisJdWludDhfdCBidWZbRFBSQU1fVFhfU0laRV07CisKKwlpZiAoY2FuX2Ryb3BwZWRfaW52YWxpZF9za2IoZGV2LCBza2IpKQorCQlyZXR1cm4gTkVUREVWX1RYX09LOworCisJc3Bpbl9sb2NrKCZjYXJkLT5zcGluKTsKKworCXJldCA9IE5FVERFVl9UWF9CVVNZOworCWlmICghY2FyZC0+ZncudXAgfHwKKwkJCShjYXJkLT50eC5wZW5kaW5nID49IFRYTUFYKSB8fAorCQkJKHByaXYtPnR4LnBlbmRpbmcgPj0gVFhfRUNIT19TS0JfTUFYKSkKKwkJZ290byB4bWl0X2RvbmU7CisJZmlmb193ciA9IGlvcmVhZDgoJmNhcmQtPmRwcmFtW0RQUkFNX1RYX1dSXSk7CisJZmlmb19yZCA9IGlvcmVhZDgoJmNhcmQtPmRwcmFtW0RQUkFNX1RYX1JEXSk7CisJaWYgKGZpZm9fd3IgPT0gZmlmb19yZCkKKwkJLyogZmlmbyBmdWxsICovCisJCWdvdG8geG1pdF9kb25lOworCW1lbXNldChidWYsIDAsIHNpemVvZihidWYpKTsKKwlwdHIgPSBidWY7CisJKnB0ciA9IENNRF9UWDsKKwlpZiAoY2YtPmNhbl9pZCAmIENBTl9SVFJfRkxBRykKKwkJKnB0ciB8PSBDTURfUlRSOworCWlmIChjZi0+Y2FuX2lkICYgQ0FOX0VGRl9GTEFHKQorCQkqcHRyIHw9IENNRF9YVEQ7CisJaWYgKHByaXYtPmluZGV4KQorCQkqcHRyIHw9IENNRF9CVVMyOworCSsrcHRyOworCSpwdHIrKyA9IGNmLT5jYW5fZGxjOworCSpwdHIrKyA9IChjZi0+Y2FuX2lkID4+IDApOworCSpwdHIrKyA9IChjZi0+Y2FuX2lkID4+IDgpOworCWlmIChjZi0+Y2FuX2lkICYgQ0FOX0VGRl9GTEFHKSB7CisJCSpwdHIrKyA9IChjZi0+Y2FuX2lkID4+IDE2KTsKKwkJKnB0cisrID0gKGNmLT5jYW5faWQgPj4gMjQpOworCX0gZWxzZSB7CisJCS8qIGluY3JlbWVudCAxLCBub3QgMiBhcyB5b3UgbWlnaHQgdGhpbmsgKi8KKwkJcHRyICs9IDE7CisJfQorCWlmICghKGNmLT5jYW5faWQgJiBDQU5fUlRSX0ZMQUcpKQorCQltZW1jcHkocHRyLCAmY2YtPmRhdGFbMF0sIGNmLT5jYW5fZGxjKTsKKwltZW1jcHlfdG9pbygmY2FyZC0+ZHByYW1bRFBSQU1fVFggKyBEUFJBTV9UWF9TSVpFICogZmlmb193cl0sCisJCQlidWYsIERQUkFNX1RYX1NJWkUpOworCWlmICgrK2ZpZm9fd3IgPj0gRFBSQU1fVFhfQ05UKQorCQlmaWZvX3dyID0gMDsKKwlpb3dyaXRlOChmaWZvX3dyLCAmY2FyZC0+ZHByYW1bRFBSQU1fVFhfV1JdKTsKKwljYXJkLT50eC5sYXN0X2J1cyA9IHByaXYtPmluZGV4OworCSsrY2FyZC0+dHgucGVuZGluZzsKKwkrK3ByaXYtPnR4LnBlbmRpbmc7CisJY2FuX3B1dF9lY2hvX3NrYihza2IsIGRldiwgcHJpdi0+dHguZWNob19wdXQpOworCSsrcHJpdi0+dHguZWNob19wdXQ7CisJaWYgKHByaXYtPnR4LmVjaG9fcHV0ID49IFRYX0VDSE9fU0tCX01BWCkKKwkJcHJpdi0+dHguZWNob19wdXQgPSAwOworCS8qIGNhbl9wdXRfZWNob19za2IoKSBzYXZlcyB0aGUgc2tiLCBzYWZlIHRvIHJldHVybiBUWF9PSyAqLworCXJldCA9IE5FVERFVl9UWF9PSzsKK3htaXRfZG9uZToKKwlzcGluX3VubG9jaygmY2FyZC0+c3Bpbik7CisJaWYgKGNhcmQtPnR4LnBlbmRpbmcgPj0gVFhNQVgpIHsKKwkJaW50IGo7CisJCWZvciAoaiA9IDA7IGogPCBBUlJBWV9TSVpFKGNhcmQtPm5ldCk7ICsraikgeworCQkJaWYgKGNhcmQtPm5ldFtqXSkKKwkJCQluZXRpZl9zdG9wX3F1ZXVlKGNhcmQtPm5ldFtqXSk7CisJCX0KKwl9CisJaWYgKHJldCAhPSBORVRERVZfVFhfT0spCisJCW5ldGlmX3N0b3BfcXVldWUoZGV2KTsKKworCXJldHVybiByZXQ7Cit9CisKKy8qCisgKiBzaG9ydGN1dCBmb3Igc2tiIGRlbGl2ZXJ5CisgKi8KK2ludCBzb2Z0aW5nX25ldGRldl9yeChzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2LCBjb25zdCBzdHJ1Y3QgY2FuX2ZyYW1lICptc2csCisJCWt0aW1lX3Qga3RpbWUpCit7CisJc3RydWN0IHNrX2J1ZmYgKnNrYjsKKwlzdHJ1Y3QgY2FuX2ZyYW1lICpjZjsKKworCXNrYiA9IGFsbG9jX2Nhbl9za2IobmV0ZGV2LCAmY2YpOworCWlmICghc2tiKQorCQlyZXR1cm4gLUVOT01FTTsKKwltZW1jcHkoY2YsIG1zZywgc2l6ZW9mKCptc2cpKTsKKwlza2ItPnRzdGFtcCA9IGt0aW1lOworCXJldHVybiBuZXRpZl9yeChza2IpOworfQorCisvKgorICogc29mdGluZ19oYW5kbGVfMQorICogcG9wIDEgZW50cnkgZnJvbSB0aGUgRFBSQU0gcXVldWUsIGFuZCBwcm9jZXNzCisgKi8KK3N0YXRpYyBpbnQgc29mdGluZ19oYW5kbGVfMShzdHJ1Y3Qgc29mdGluZyAqY2FyZCkKK3sKKwlzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2OworCXN0cnVjdCBzb2Z0aW5nX3ByaXYgKnByaXY7CisJa3RpbWVfdCBrdGltZTsKKwlzdHJ1Y3QgY2FuX2ZyYW1lIG1zZzsKKwlpbnQgY250ID0gMCwgbG9zdF9tc2c7CisJdWludDhfdCBmaWZvX3JkLCBmaWZvX3dyLCBjbWQ7CisJdWludDhfdCAqcHRyOworCXVpbnQzMl90IHRtcF91MzI7CisJdWludDhfdCBidWZbRFBSQU1fUlhfU0laRV07CisKKwltZW1zZXQoJm1zZywgMCwgc2l6ZW9mKG1zZykpOworCS8qIHRlc3QgZm9yIGxvc3QgbXNncyAqLworCWxvc3RfbXNnID0gaW9yZWFkOCgmY2FyZC0+ZHByYW1bRFBSQU1fUlhfTE9TVF0pOworCWlmIChsb3N0X21zZykgeworCQlpbnQgajsKKwkJLyogcmVzZXQgY29uZGl0aW9uICovCisJCWlvd3JpdGU4KDAsICZjYXJkLT5kcHJhbVtEUFJBTV9SWF9MT1NUXSk7CisJCS8qIHByZXBhcmUgbXNnICovCisJCW1zZy5jYW5faWQgPSBDQU5fRVJSX0ZMQUcgfCBDQU5fRVJSX0NSVEw7CisJCW1zZy5jYW5fZGxjID0gQ0FOX0VSUl9ETEM7CisJCW1zZy5kYXRhWzFdID0gQ0FOX0VSUl9DUlRMX1JYX09WRVJGTE9XOworCQkvKgorCQkgKiBzZXJ2aWNlIHRvIGFsbCBidXNzZXMsIHdlIGRvbid0IGtub3cgd2hpY2ggaXQgd2FzIGFwcGxpY2FibGUKKwkJICogYnV0IG9ubHkgc2VydmljZSBidXNzZXMgdGhhdCBhcmUgb25saW5lCisJCSAqLworCQlmb3IgKGogPSAwOyBqIDwgQVJSQVlfU0laRShjYXJkLT5uZXQpOyArK2opIHsKKwkJCW5ldGRldiA9IGNhcmQtPm5ldFtqXTsKKwkJCWlmICghbmV0ZGV2KQorCQkJCWNvbnRpbnVlOworCQkJaWYgKCFjYW5pZl9pc19hY3RpdmUobmV0ZGV2KSkKKwkJCQkvKiBhIGRlYWQgYnVzIGhhcyBubyBvdmVyZmxvd3MgKi8KKwkJCQljb250aW51ZTsKKwkJCSsrbmV0ZGV2LT5zdGF0cy5yeF9vdmVyX2Vycm9yczsKKwkJCXNvZnRpbmdfbmV0ZGV2X3J4KG5ldGRldiwgJm1zZywga3RpbWVfc2V0KDAsIDApKTsKKwkJfQorCQkvKiBwcmVwYXJlIGZvciBvdGhlciB1c2UgKi8KKwkJbWVtc2V0KCZtc2csIDAsIHNpemVvZihtc2cpKTsKKwkJKytjbnQ7CisJfQorCisJZmlmb19yZCA9IGlvcmVhZDgoJmNhcmQtPmRwcmFtW0RQUkFNX1JYX1JEXSk7CisJZmlmb193ciA9IGlvcmVhZDgoJmNhcmQtPmRwcmFtW0RQUkFNX1JYX1dSXSk7CisKKwlpZiAoKytmaWZvX3JkID49IERQUkFNX1JYX0NOVCkKKwkJZmlmb19yZCA9IDA7CisJaWYgKGZpZm9fd3IgPT0gZmlmb19yZCkKKwkJcmV0dXJuIGNudDsKKworCW1lbWNweV9mcm9taW8oYnVmLCAmY2FyZC0+ZHByYW1bRFBSQU1fUlggKyBEUFJBTV9SWF9TSVpFKmZpZm9fcmRdLAorCQkJRFBSQU1fUlhfU0laRSk7CisJbWIoKTsKKwkvKiB0cmlnZ2VyIGR1YWwgcG9ydCBSQU0gKi8KKwlpb3dyaXRlOChmaWZvX3JkLCAmY2FyZC0+ZHByYW1bRFBSQU1fUlhfUkRdKTsKKworCXB0ciA9IGJ1ZjsKKwljbWQgPSAqcHRyKys7CisJaWYgKGNtZCA9PSAweGZmKQorCQkvKiBub3QgcXVpdGUgdXNlZnVsbCwgcHJvYmFibHkgdGhlIGNhcmQgaGFzIGdvdCBvdXQgKi8KKwkJcmV0dXJuIDA7CisJbmV0ZGV2ID0gY2FyZC0+bmV0WzBdOworCWlmIChjbWQgJiBDTURfQlVTMikKKwkJbmV0ZGV2ID0gY2FyZC0+bmV0WzFdOworCXByaXYgPSBuZXRkZXZfcHJpdihuZXRkZXYpOworCisJaWYgKGNtZCAmIENNRF9FUlIpIHsKKwkJdWludDhfdCBjYW5fc3RhdGUsIHN0YXRlOworCisJCXN0YXRlID0gKnB0cisrOworCisJCW1zZy5jYW5faWQgPSBDQU5fRVJSX0ZMQUc7CisJCW1zZy5jYW5fZGxjID0gQ0FOX0VSUl9ETEM7CisKKwkJaWYgKHN0YXRlICYgU0ZfTUFTS19CVVNPRkYpIHsKKwkJCWNhbl9zdGF0ZSA9IENBTl9TVEFURV9CVVNfT0ZGOworCQkJbXNnLmNhbl9pZCB8PSBDQU5fRVJSX0JVU09GRjsKKwkJCXN0YXRlID0gU1RBVEVfQlVTT0ZGOworCQl9IGVsc2UgaWYgKHN0YXRlICYgU0ZfTUFTS19FUEFTU0lWRSkgeworCQkJY2FuX3N0YXRlID0gQ0FOX1NUQVRFX0VSUk9SX1BBU1NJVkU7CisJCQltc2cuY2FuX2lkIHw9IENBTl9FUlJfQ1JUTDsKKwkJCW1zZy5kYXRhWzFdID0gQ0FOX0VSUl9DUlRMX1RYX1BBU1NJVkU7CisJCQlzdGF0ZSA9IFNUQVRFX0VQQVNTSVZFOworCQl9IGVsc2UgeworCQkJY2FuX3N0YXRlID0gQ0FOX1NUQVRFX0VSUk9SX0FDVElWRTsKKwkJCW1zZy5jYW5faWQgfD0gQ0FOX0VSUl9DUlRMOworCQkJc3RhdGUgPSBTVEFURV9FQUNUSVZFOworCQl9CisJCS8qIHVwZGF0ZSBEUFJBTSAqLworCQlpb3dyaXRlOChzdGF0ZSwgJmNhcmQtPmRwcmFtW3ByaXYtPmluZGV4ID8KKwkJCQlEUFJBTV9JTkZPX0JVU1NUQVRFMiA6IERQUkFNX0lORk9fQlVTU1RBVEVdKTsKKwkJLyogdGltZXN0YW1wICovCisJCXRtcF91MzIgPSBsZTMyX3RvX2NwdXAoKHZvaWQgKilwdHIpOworCQlwdHIgKz0gNDsKKwkJa3RpbWUgPSBzb2Z0aW5nX3JhdzJrdGltZShjYXJkLCB0bXBfdTMyKTsKKworCQkrK25ldGRldi0+c3RhdHMucnhfZXJyb3JzOworCQkvKiB1cGRhdGUgaW50ZXJuYWwgc3RhdHVzICovCisJCWlmIChjYW5fc3RhdGUgIT0gcHJpdi0+Y2FuLnN0YXRlKSB7CisJCQlwcml2LT5jYW4uc3RhdGUgPSBjYW5fc3RhdGU7CisJCQlpZiAoY2FuX3N0YXRlID09IENBTl9TVEFURV9FUlJPUl9QQVNTSVZFKQorCQkJCSsrcHJpdi0+Y2FuLmNhbl9zdGF0cy5lcnJvcl9wYXNzaXZlOworCQkJZWxzZSBpZiAoY2FuX3N0YXRlID09IENBTl9TVEFURV9CVVNfT0ZGKSB7CisJCQkJLyogdGhpcyBjYWxscyBjYW5fY2xvc2VfY2xlYW51cCgpICovCisJCQkJY2FuX2J1c19vZmYobmV0ZGV2KTsKKwkJCQluZXRpZl9zdG9wX3F1ZXVlKG5ldGRldik7CisJCQl9CisJCQkvKiB0cmlnZ2VyIHNvY2tldGNhbiAqLworCQkJc29mdGluZ19uZXRkZXZfcngobmV0ZGV2LCAmbXNnLCBrdGltZSk7CisJCX0KKworCX0gZWxzZSB7CisJCWlmIChjbWQgJiBDTURfUlRSKQorCQkJbXNnLmNhbl9pZCB8PSBDQU5fUlRSX0ZMQUc7CisJCW1zZy5jYW5fZGxjID0gZ2V0X2Nhbl9kbGMoKnB0cisrKTsKKwkJaWYgKGNtZCAmIENNRF9YVEQpIHsKKwkJCW1zZy5jYW5faWQgfD0gQ0FOX0VGRl9GTEFHOworCQkJbXNnLmNhbl9pZCB8PSBsZTMyX3RvX2NwdXAoKHZvaWQgKilwdHIpOworCQkJcHRyICs9IDQ7CisJCX0gZWxzZSB7CisJCQltc2cuY2FuX2lkIHw9IGxlMTZfdG9fY3B1cCgodm9pZCAqKXB0cik7CisJCQlwdHIgKz0gMjsKKwkJfQorCQkvKiB0aW1lc3RhbXAgKi8KKwkJdG1wX3UzMiA9IGxlMzJfdG9fY3B1cCgodm9pZCAqKXB0cik7CisJCXB0ciArPSA0OworCQlrdGltZSA9IHNvZnRpbmdfcmF3Mmt0aW1lKGNhcmQsIHRtcF91MzIpOworCQlpZiAoIShtc2cuY2FuX2lkICYgQ0FOX1JUUl9GTEFHKSkKKwkJCW1lbWNweSgmbXNnLmRhdGFbMF0sIHB0ciwgOCk7CisJCXB0ciArPSA4OworCQkvKiB1cGRhdGUgc29ja2V0ICovCisJCWlmIChjbWQgJiBDTURfQUNLKSB7CisJCQkvKiBhY2tub3dsZWRnZSwgd2FzIHR4IG1zZyAqLworCQkJc3RydWN0IHNrX2J1ZmYgKnNrYjsKKwkJCXNrYiA9IHByaXYtPmNhbi5lY2hvX3NrYltwcml2LT50eC5lY2hvX2dldF07CisJCQlpZiAoc2tiKQorCQkJCXNrYi0+dHN0YW1wID0ga3RpbWU7CisJCQljYW5fZ2V0X2VjaG9fc2tiKG5ldGRldiwgcHJpdi0+dHguZWNob19nZXQpOworCQkJKytwcml2LT50eC5lY2hvX2dldDsKKwkJCWlmIChwcml2LT50eC5lY2hvX2dldCA+PSBUWF9FQ0hPX1NLQl9NQVgpCisJCQkJcHJpdi0+dHguZWNob19nZXQgPSAwOworCQkJaWYgKHByaXYtPnR4LnBlbmRpbmcpCisJCQkJLS1wcml2LT50eC5wZW5kaW5nOworCQkJaWYgKGNhcmQtPnR4LnBlbmRpbmcpCisJCQkJLS1jYXJkLT50eC5wZW5kaW5nOworCQkJKytuZXRkZXYtPnN0YXRzLnR4X3BhY2tldHM7CisJCQlpZiAoIShtc2cuY2FuX2lkICYgQ0FOX1JUUl9GTEFHKSkKKwkJCQluZXRkZXYtPnN0YXRzLnR4X2J5dGVzICs9IG1zZy5jYW5fZGxjOworCQl9IGVsc2UgeworCQkJaW50IHJldDsKKworCQkJcmV0ID0gc29mdGluZ19uZXRkZXZfcngobmV0ZGV2LCAmbXNnLCBrdGltZSk7CisJCQlpZiAocmV0ID09IE5FVF9SWF9TVUNDRVNTKSB7CisJCQkJKytuZXRkZXYtPnN0YXRzLnJ4X3BhY2tldHM7CisJCQkJaWYgKCEobXNnLmNhbl9pZCAmIENBTl9SVFJfRkxBRykpCisJCQkJCW5ldGRldi0+c3RhdHMucnhfYnl0ZXMgKz0gbXNnLmNhbl9kbGM7CisJCQl9IGVsc2UgeworCQkJCSsrbmV0ZGV2LT5zdGF0cy5yeF9kcm9wcGVkOworCQkJfQorCQl9CisJfQorCSsrY250OworCXJldHVybiBjbnQ7Cit9CisKKy8qCisgKiByZWFsIGludGVycnVwdCBoYW5kbGVyCisgKi8KK3N0YXRpYyBpcnFyZXR1cm5fdCBzb2Z0aW5nX2lycV90aHJlYWQoaW50IGlycSwgdm9pZCAqZGV2X2lkKQoreworCXN0cnVjdCBzb2Z0aW5nICpjYXJkID0gKHN0cnVjdCBzb2Z0aW5nICopZGV2X2lkOworCXN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXY7CisJc3RydWN0IHNvZnRpbmdfcHJpdiAqcHJpdjsKKwlpbnQgaiwgb2Zmc2V0LCB3b3JrX2RvbmU7CisKKwl3b3JrX2RvbmUgPSAwOworCXNwaW5fbG9ja19iaCgmY2FyZC0+c3Bpbik7CisJd2hpbGUgKHNvZnRpbmdfaGFuZGxlXzEoY2FyZCkgPiAwKSB7CisJCSsrY2FyZC0+aXJxLnN2Y19jb3VudDsKKwkJKyt3b3JrX2RvbmU7CisJfQorCXNwaW5fdW5sb2NrX2JoKCZjYXJkLT5zcGluKTsKKwkvKiByZXN1bWUgdHggcXVldWUncyAqLworCW9mZnNldCA9IGNhcmQtPnR4Lmxhc3RfYnVzOworCWZvciAoaiA9IDA7IGogPCBBUlJBWV9TSVpFKGNhcmQtPm5ldCk7ICsraikgeworCQlpZiAoY2FyZC0+dHgucGVuZGluZyA+PSBUWE1BWCkKKwkJCWJyZWFrOworCQluZXRkZXYgPSBjYXJkLT5uZXRbKGogKyBvZmZzZXQgKyAxKSAlIGNhcmQtPnBkYXQtPm5idXNdOworCQlpZiAoIW5ldGRldikKKwkJCWNvbnRpbnVlOworCQlwcml2ID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKwkJaWYgKCFjYW5pZl9pc19hY3RpdmUobmV0ZGV2KSkKKwkJCS8qIGl0IG1ha2VzIG5vIHNlbnNlIHRvIHdha2UgZGVhZCBidXNzZXMgKi8KKwkJCWNvbnRpbnVlOworCQlpZiAocHJpdi0+dHgucGVuZGluZyA+PSBUWF9FQ0hPX1NLQl9NQVgpCisJCQljb250aW51ZTsKKwkJKyt3b3JrX2RvbmU7CisJCW5ldGlmX3dha2VfcXVldWUobmV0ZGV2KTsKKwl9CisJcmV0dXJuIHdvcmtfZG9uZSA/IElSUV9IQU5ETEVEIDogSVJRX05PTkU7Cit9CisKKy8qCisgKiBpbnRlcnJ1cHQgcm91dGluZXM6CisgKiBzY2hlZHVsZSB0aGUgJ3JlYWwgaW50ZXJydXB0IGhhbmRsZXInCisgKi8KK3N0YXRpYyBpcnFyZXR1cm5fdCBzb2Z0aW5nX2lycV92MihpbnQgaXJxLCB2b2lkICpkZXZfaWQpCit7CisJc3RydWN0IHNvZnRpbmcgKmNhcmQgPSAoc3RydWN0IHNvZnRpbmcgKilkZXZfaWQ7CisJdWludDhfdCBpcjsKKworCWlyID0gaW9yZWFkOCgmY2FyZC0+ZHByYW1bRFBSQU1fVjJfSVJRX1RPSE9TVF0pOworCWlvd3JpdGU4KDAsICZjYXJkLT5kcHJhbVtEUFJBTV9WMl9JUlFfVE9IT1NUXSk7CisJcmV0dXJuICgxID09IGlyKSA/IElSUV9XQUtFX1RIUkVBRCA6IElSUV9OT05FOworfQorCitzdGF0aWMgaXJxcmV0dXJuX3Qgc29mdGluZ19pcnFfdjEoaW50IGlycSwgdm9pZCAqZGV2X2lkKQoreworCXN0cnVjdCBzb2Z0aW5nICpjYXJkID0gKHN0cnVjdCBzb2Z0aW5nICopZGV2X2lkOworCXVpbnQ4X3QgaXI7CisKKwlpciA9IGlvcmVhZDgoJmNhcmQtPmRwcmFtW0RQUkFNX0lSUV9UT0hPU1RdKTsKKwlpb3dyaXRlOCgwLCAmY2FyZC0+ZHByYW1bRFBSQU1fSVJRX1RPSE9TVF0pOworCXJldHVybiBpciA/IElSUV9XQUtFX1RIUkVBRCA6IElSUV9OT05FOworfQorCisvKgorICogbmV0ZGV2L2NhbmRldiBpbnRlci1vcGVyYWJpbGl0eQorICovCitzdGF0aWMgaW50IHNvZnRpbmdfbmV0ZGV2X29wZW4oc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYpCit7CisJaW50IHJldDsKKworCS8qIGNoZWNrIG9yIGRldGVybWluZSBhbmQgc2V0IGJpdHRpbWUgKi8KKwlyZXQgPSBvcGVuX2NhbmRldihuZGV2KTsKKwlpZiAoIXJldCkKKwkJcmV0ID0gc29mdGluZ19zdGFydHN0b3AobmRldiwgMSk7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBzb2Z0aW5nX25ldGRldl9zdG9wKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2KQoreworCWludCByZXQ7CisKKwluZXRpZl9zdG9wX3F1ZXVlKG5kZXYpOworCisJLyogc29mdGluZyBjeWNsZSBkb2VzIGNsb3NlX2NhbmRldigpICovCisJcmV0ID0gc29mdGluZ19zdGFydHN0b3AobmRldiwgMCk7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBzb2Z0aW5nX2NhbmRldl9zZXRfbW9kZShzdHJ1Y3QgbmV0X2RldmljZSAqbmRldiwgZW51bSBjYW5fbW9kZSBtb2RlKQoreworCWludCByZXQ7CisKKwlzd2l0Y2ggKG1vZGUpIHsKKwljYXNlIENBTl9NT0RFX1NUQVJUOgorCQkvKiBzb2Z0aW5nX3N0YXJ0c3RvcCBkb2VzIGNsb3NlX2NhbmRldigpICovCisJCXJldCA9IHNvZnRpbmdfc3RhcnRzdG9wKG5kZXYsIDEpOworCQlyZXR1cm4gcmV0OworCWNhc2UgQ0FOX01PREVfU1RPUDoKKwljYXNlIENBTl9NT0RFX1NMRUVQOgorCQlyZXR1cm4gLUVPUE5PVFNVUFA7CisJfQorCXJldHVybiAwOworfQorCisvKgorICogU29mdGluZyBkZXZpY2UgbWFuYWdlbWVudCBoZWxwZXJzCisgKi8KK2ludCBzb2Z0aW5nX2VuYWJsZV9pcnEoc3RydWN0IHNvZnRpbmcgKmNhcmQsIGludCBlbmFibGUpCit7CisJaW50IHJldDsKKworCWlmICghY2FyZC0+aXJxLm5yKSB7CisJCXJldHVybiAwOworCX0gZWxzZSBpZiAoY2FyZC0+aXJxLnJlcXVlc3RlZCAmJiAhZW5hYmxlKSB7CisJCWZyZWVfaXJxKGNhcmQtPmlycS5uciwgY2FyZCk7CisJCWNhcmQtPmlycS5yZXF1ZXN0ZWQgPSAwOworCX0gZWxzZSBpZiAoIWNhcmQtPmlycS5yZXF1ZXN0ZWQgJiYgZW5hYmxlKSB7CisJCXJldCA9IHJlcXVlc3RfdGhyZWFkZWRfaXJxKGNhcmQtPmlycS5uciwKKwkJCQkoY2FyZC0+cGRhdC0+Z2VuZXJhdGlvbiA+PSAyKSA/CisJCQkJCXNvZnRpbmdfaXJxX3YyIDogc29mdGluZ19pcnFfdjEsCisJCQkJc29mdGluZ19pcnFfdGhyZWFkLCBJUlFGX1NIQVJFRCwKKwkJCQlkZXZfbmFtZSgmY2FyZC0+cGRldi0+ZGV2KSwgY2FyZCk7CisJCWlmIChyZXQpIHsKKwkJCWRldl9hbGVydCgmY2FyZC0+cGRldi0+ZGV2LAorCQkJCQkicmVxdWVzdF90aHJlYWRlZF9pcnEoJXUpIGZhaWxlZFxuIiwKKwkJCQkJY2FyZC0+aXJxLm5yKTsKKwkJCXJldHVybiByZXQ7CisJCX0KKwkJY2FyZC0+aXJxLnJlcXVlc3RlZCA9IDE7CisJfQorCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBzb2Z0aW5nX2NhcmRfc2h1dGRvd24oc3RydWN0IHNvZnRpbmcgKmNhcmQpCit7CisJaW50IGZ3X3VwID0gMDsKKworCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmNhcmQtPmZ3LmxvY2spKQorCQkvKiByZXR1cm4gLUVSRVNUQVJUU1lTICovOworCWZ3X3VwID0gY2FyZC0+ZncudXA7CisJY2FyZC0+ZncudXAgPSAwOworCisJaWYgKGNhcmQtPmlycS5yZXF1ZXN0ZWQgJiYgY2FyZC0+aXJxLm5yKSB7CisJCWZyZWVfaXJxKGNhcmQtPmlycS5uciwgY2FyZCk7CisJCWNhcmQtPmlycS5yZXF1ZXN0ZWQgPSAwOworCX0KKwlpZiAoZndfdXApIHsKKwkJaWYgKGNhcmQtPnBkYXQtPmVuYWJsZV9pcnEpCisJCQljYXJkLT5wZGF0LT5lbmFibGVfaXJxKGNhcmQtPnBkZXYsIDApOworCQlzb2Z0aW5nX3NldF9yZXNldF9kcHJhbShjYXJkKTsKKwkJaWYgKGNhcmQtPnBkYXQtPnJlc2V0KQorCQkJY2FyZC0+cGRhdC0+cmVzZXQoY2FyZC0+cGRldiwgMSk7CisJfQorCW11dGV4X3VubG9jaygmY2FyZC0+ZncubG9jayk7Cit9CisKK3N0YXRpYyBfX2RldmluaXQgaW50IHNvZnRpbmdfY2FyZF9ib290KHN0cnVjdCBzb2Z0aW5nICpjYXJkKQoreworCWludCByZXQsIGo7CisJc3RhdGljIGNvbnN0IHVpbnQ4X3Qgc3RyZWFtW10gPSB7CisJCTAsIDEsIDIsIDMsIDQsIDUsIDYsIDcsIDgsIDksIDEwLCAxMSwgMTIsIDEzLCAxNCwgMTUsIH07CisJdW5zaWduZWQgY2hhciBiYWNrW3NpemVvZihzdHJlYW0pXTsKKworCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmNhcmQtPmZ3LmxvY2spKQorCQlyZXR1cm4gLUVSRVNUQVJUU1lTOworCWlmIChjYXJkLT5mdy51cCkgeworCQltdXRleF91bmxvY2soJmNhcmQtPmZ3LmxvY2spOworCQlyZXR1cm4gMDsKKwl9CisJLyogcmVzZXQgYm9hcmQgKi8KKwlpZiAoY2FyZC0+cGRhdC0+ZW5hYmxlX2lycSkKKwkJY2FyZC0+cGRhdC0+ZW5hYmxlX2lycShjYXJkLT5wZGV2LCAxKTsKKwkvKiBib290IGNhcmQgKi8KKwlzb2Z0aW5nX3NldF9yZXNldF9kcHJhbShjYXJkKTsKKwlpZiAoY2FyZC0+cGRhdC0+cmVzZXQpCisJCWNhcmQtPnBkYXQtPnJlc2V0KGNhcmQtPnBkZXYsIDEpOworCWZvciAoaiA9IDA7IChqICsgc2l6ZW9mKHN0cmVhbSkpIDwgY2FyZC0+ZHByYW1fc2l6ZTsKKwkJCWogKz0gc2l6ZW9mKHN0cmVhbSkpIHsKKworCQltZW1jcHlfdG9pbygmY2FyZC0+ZHByYW1bal0sIHN0cmVhbSwgc2l6ZW9mKHN0cmVhbSkpOworCQkvKiBmbHVzaCBJTyBjYWNoZSAqLworCQltYigpOworCQltZW1jcHlfZnJvbWlvKGJhY2ssICZjYXJkLT5kcHJhbVtqXSwgc2l6ZW9mKHN0cmVhbSkpOworCisJCWlmICghbWVtY21wKGJhY2ssIHN0cmVhbSwgc2l6ZW9mKHN0cmVhbSkpKQorCQkJY29udGludWU7CisJCS8qIG1lbW9yeSBpcyBub3QgZXF1YWwgKi8KKwkJZGV2X2FsZXJ0KCZjYXJkLT5wZGV2LT5kZXYsICJkcHJhbSBmYWlsZWQgYXQgMHglMDR4XG4iLCBqKTsKKwkJcmV0ID0gLUVJTzsKKwkJZ290byBmYWlsZWQ7CisJfQorCXdtYigpOworCS8qIGxvYWQgYm9vdCBmaXJtd2FyZSAqLworCXJldCA9IHNvZnRpbmdfbG9hZF9mdyhjYXJkLT5wZGF0LT5ib290LmZ3LCBjYXJkLCBjYXJkLT5kcHJhbSwKKwkJCQljYXJkLT5kcHJhbV9zaXplLAorCQkJCWNhcmQtPnBkYXQtPmJvb3Qub2ZmcyAtIGNhcmQtPnBkYXQtPmJvb3QuYWRkcik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFpbGVkOworCS8qIGxvYWQgbG9hZGVyIGZpcm13YXJlICovCisJcmV0ID0gc29mdGluZ19sb2FkX2Z3KGNhcmQtPnBkYXQtPmxvYWQuZncsIGNhcmQsIGNhcmQtPmRwcmFtLAorCQkJCWNhcmQtPmRwcmFtX3NpemUsCisJCQkJY2FyZC0+cGRhdC0+bG9hZC5vZmZzIC0gY2FyZC0+cGRhdC0+bG9hZC5hZGRyKTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBmYWlsZWQ7CisKKwlpZiAoY2FyZC0+cGRhdC0+cmVzZXQpCisJCWNhcmQtPnBkYXQtPnJlc2V0KGNhcmQtPnBkZXYsIDApOworCXNvZnRpbmdfY2xyX3Jlc2V0X2RwcmFtKGNhcmQpOworCXJldCA9IHNvZnRpbmdfYm9vdGxvYWRlcl9jb21tYW5kKGNhcmQsIDAsICJjYXJkIGJvb3QiKTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBmYWlsZWQ7CisJcmV0ID0gc29mdGluZ19sb2FkX2FwcF9mdyhjYXJkLT5wZGF0LT5hcHAuZncsIGNhcmQpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWxlZDsKKworCXJldCA9IHNvZnRpbmdfY2hpcF9wb3dlcm9uKGNhcmQpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWxlZDsKKworCWNhcmQtPmZ3LnVwID0gMTsKKwltdXRleF91bmxvY2soJmNhcmQtPmZ3LmxvY2spOworCXJldHVybiAwOworZmFpbGVkOgorCWNhcmQtPmZ3LnVwID0gMDsKKwlpZiAoY2FyZC0+cGRhdC0+ZW5hYmxlX2lycSkKKwkJY2FyZC0+cGRhdC0+ZW5hYmxlX2lycShjYXJkLT5wZGV2LCAwKTsKKwlzb2Z0aW5nX3NldF9yZXNldF9kcHJhbShjYXJkKTsKKwlpZiAoY2FyZC0+cGRhdC0+cmVzZXQpCisJCWNhcmQtPnBkYXQtPnJlc2V0KGNhcmQtPnBkZXYsIDEpOworCW11dGV4X3VubG9jaygmY2FyZC0+ZncubG9jayk7CisJcmV0dXJuIHJldDsKK30KKworLyoKKyAqIG5ldGRldiBzeXNmcworICovCitzdGF0aWMgc3NpemVfdCBzaG93X2NoYW5uZWwoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKKwkJY2hhciAqYnVmKQoreworCXN0cnVjdCBuZXRfZGV2aWNlICpuZGV2ID0gdG9fbmV0X2RldihkZXYpOworCXN0cnVjdCBzb2Z0aW5nX3ByaXYgKnByaXYgPSBuZXRkZXYyc29mdGluZyhuZGV2KTsKKworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVpXG4iLCBwcml2LT5pbmRleCk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IHNob3dfY2hpcChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQljaGFyICpidWYpCit7CisJc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYgPSB0b19uZXRfZGV2KGRldik7CisJc3RydWN0IHNvZnRpbmdfcHJpdiAqcHJpdiA9IG5ldGRldjJzb2Z0aW5nKG5kZXYpOworCisJcmV0dXJuIHNwcmludGYoYnVmLCAiJWlcbiIsIHByaXYtPmNoaXApOworfQorCitzdGF0aWMgc3NpemVfdCBzaG93X291dHB1dChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQljaGFyICpidWYpCit7CisJc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYgPSB0b19uZXRfZGV2KGRldik7CisJc3RydWN0IHNvZnRpbmdfcHJpdiAqcHJpdiA9IG5ldGRldjJzb2Z0aW5nKG5kZXYpOworCisJcmV0dXJuIHNwcmludGYoYnVmLCAiMHglMDJ4XG4iLCBwcml2LT5vdXRwdXQpOworfQorCitzdGF0aWMgc3NpemVfdCBzdG9yZV9vdXRwdXQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKKwkJY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7CisJc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYgPSB0b19uZXRfZGV2KGRldik7CisJc3RydWN0IHNvZnRpbmdfcHJpdiAqcHJpdiA9IG5ldGRldjJzb2Z0aW5nKG5kZXYpOworCXN0cnVjdCBzb2Z0aW5nICpjYXJkID0gcHJpdi0+Y2FyZDsKKwl1bnNpZ25lZCBsb25nIHZhbDsKKwlpbnQgcmV0OworCisJcmV0ID0gc3RyaWN0X3N0cnRvdWwoYnVmLCAwLCAmdmFsKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKwl2YWwgJj0gMHhGRjsKKworCXJldCA9IG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmY2FyZC0+ZncubG9jayk7CisJaWYgKHJldCkKKwkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKKwlpZiAobmV0aWZfcnVubmluZyhuZGV2KSkgeworCQltdXRleF91bmxvY2soJmNhcmQtPmZ3LmxvY2spOworCQlyZXR1cm4gLUVCVVNZOworCX0KKwlwcml2LT5vdXRwdXQgPSB2YWw7CisJbXV0ZXhfdW5sb2NrKCZjYXJkLT5mdy5sb2NrKTsKKwlyZXR1cm4gY291bnQ7Cit9CisKK3N0YXRpYyBjb25zdCBERVZJQ0VfQVRUUihjaGFubmVsLCBTX0lSVUdPLCBzaG93X2NoYW5uZWwsIE5VTEwpOworc3RhdGljIGNvbnN0IERFVklDRV9BVFRSKGNoaXAsIFNfSVJVR08sIHNob3dfY2hpcCwgTlVMTCk7CitzdGF0aWMgY29uc3QgREVWSUNFX0FUVFIob3V0cHV0LCBTX0lSVUdPIHwgU19JV1VTUiwgc2hvd19vdXRwdXQsIHN0b3JlX291dHB1dCk7CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYXR0cmlidXRlICpjb25zdCBuZXRkZXZfc3lzZnNfYXR0cnNbXSA9IHsKKwkmZGV2X2F0dHJfY2hhbm5lbC5hdHRyLAorCSZkZXZfYXR0cl9jaGlwLmF0dHIsCisJJmRldl9hdHRyX291dHB1dC5hdHRyLAorCU5VTEwsCit9Oworc3RhdGljIGNvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgbmV0ZGV2X3N5c2ZzX2dyb3VwID0geworCS5uYW1lID0gTlVMTCwKKwkuYXR0cnMgPSAoc3RydWN0IGF0dHJpYnV0ZSAqKiluZXRkZXZfc3lzZnNfYXR0cnMsCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IG5ldF9kZXZpY2Vfb3BzIHNvZnRpbmdfbmV0ZGV2X29wcyA9IHsKKwkubmRvX29wZW4gPSBzb2Z0aW5nX25ldGRldl9vcGVuLAorCS5uZG9fc3RvcCA9IHNvZnRpbmdfbmV0ZGV2X3N0b3AsCisJLm5kb19zdGFydF94bWl0CT0gc29mdGluZ19uZXRkZXZfc3RhcnRfeG1pdCwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgY2FuX2JpdHRpbWluZ19jb25zdCBzb2Z0aW5nX2J0cl9jb25zdCA9IHsKKwkudHNlZzFfbWluID0gMSwKKwkudHNlZzFfbWF4ID0gMTYsCisJLnRzZWcyX21pbiA9IDEsCisJLnRzZWcyX21heCA9IDgsCisJLnNqd19tYXggPSA0LCAvKiBvdmVycnVsZWQgKi8KKwkuYnJwX21pbiA9IDEsCisJLmJycF9tYXggPSAzMiwgLyogb3ZlcnJ1bGVkICovCisJLmJycF9pbmMgPSAxLAorfTsKKworCitzdGF0aWMgX19kZXZpbml0IHN0cnVjdCBuZXRfZGV2aWNlICpzb2Z0aW5nX25ldGRldl9jcmVhdGUoc3RydWN0IHNvZnRpbmcgKmNhcmQsCisJCXVpbnQxNl90IGNoaXBfaWQpCit7CisJc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldjsKKwlzdHJ1Y3Qgc29mdGluZ19wcml2ICpwcml2OworCisJbmV0ZGV2ID0gYWxsb2NfY2FuZGV2KHNpemVvZigqcHJpdiksIFRYX0VDSE9fU0tCX01BWCk7CisJaWYgKCFuZXRkZXYpIHsKKwkJZGV2X2FsZXJ0KCZjYXJkLT5wZGV2LT5kZXYsICJhbGxvY19jYW5kZXYgZmFpbGVkXG4iKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCXByaXYgPSBuZXRkZXZfcHJpdihuZXRkZXYpOworCXByaXYtPm5ldGRldiA9IG5ldGRldjsKKwlwcml2LT5jYXJkID0gY2FyZDsKKwltZW1jcHkoJnByaXYtPmJ0cl9jb25zdCwgJnNvZnRpbmdfYnRyX2NvbnN0LCBzaXplb2YocHJpdi0+YnRyX2NvbnN0KSk7CisJcHJpdi0+YnRyX2NvbnN0LmJycF9tYXggPSBjYXJkLT5wZGF0LT5tYXhfYnJwOworCXByaXYtPmJ0cl9jb25zdC5zandfbWF4ID0gY2FyZC0+cGRhdC0+bWF4X3NqdzsKKwlwcml2LT5jYW4uYml0dGltaW5nX2NvbnN0ID0gJnByaXYtPmJ0cl9jb25zdDsKKwlwcml2LT5jYW4uY2xvY2suZnJlcSA9IDgwMDAwMDA7CisJcHJpdi0+Y2hpcCA9IGNoaXBfaWQ7CisJcHJpdi0+b3V0cHV0ID0gc29mdGluZ19kZWZhdWx0X291dHB1dChuZXRkZXYpOworCVNFVF9ORVRERVZfREVWKG5ldGRldiwgJmNhcmQtPnBkZXYtPmRldik7CisKKwluZXRkZXYtPmZsYWdzIHw9IElGRl9FQ0hPOworCW5ldGRldi0+bmV0ZGV2X29wcyA9ICZzb2Z0aW5nX25ldGRldl9vcHM7CisJcHJpdi0+Y2FuLmRvX3NldF9tb2RlID0gc29mdGluZ19jYW5kZXZfc2V0X21vZGU7CisJcHJpdi0+Y2FuLmN0cmxtb2RlX3N1cHBvcnRlZCA9IENBTl9DVFJMTU9ERV8zX1NBTVBMRVM7CisKKwlyZXR1cm4gbmV0ZGV2OworfQorCitzdGF0aWMgX19kZXZpbml0IGludCBzb2Z0aW5nX25ldGRldl9yZWdpc3RlcihzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2KQoreworCWludCByZXQ7CisKKwluZXRkZXYtPnN5c2ZzX2dyb3Vwc1swXSA9ICZuZXRkZXZfc3lzZnNfZ3JvdXA7CisJcmV0ID0gcmVnaXN0ZXJfY2FuZGV2KG5ldGRldik7CisJaWYgKHJldCkgeworCQlkZXZfYWxlcnQoJm5ldGRldi0+ZGV2LCAicmVnaXN0ZXIgZmFpbGVkXG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIHNvZnRpbmdfbmV0ZGV2X2NsZWFudXAoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikKK3sKKwl1bnJlZ2lzdGVyX2NhbmRldihuZXRkZXYpOworCWZyZWVfY2FuZGV2KG5ldGRldik7Cit9CisKKy8qCisgKiBzeXNmcyBmb3IgUGxhdGZvcm0gZGV2aWNlCisgKi8KKyNkZWZpbmUgREVWX0FUVFJfUk8obmFtZSwgbWVtYmVyKSBcCitzdGF0aWMgc3NpemVfdCBzaG93XyMjbmFtZShzdHJ1Y3QgZGV2aWNlICpkZXYsIFwKKwkJc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNoYXIgKmJ1ZikgXAoreyBcCisJc3RydWN0IHNvZnRpbmcgKmNhcmQgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YSh0b19wbGF0Zm9ybV9kZXZpY2UoZGV2KSk7IFwKKwlyZXR1cm4gc3ByaW50ZihidWYsICIldVxuIiwgY2FyZC0+bWVtYmVyKTsgXAorfSBcCitzdGF0aWMgREVWSUNFX0FUVFIobmFtZSwgMDQ0NCwgc2hvd18jI25hbWUsIE5VTEwpCisKKyNkZWZpbmUgREVWX0FUVFJfUk9fU1RSKG5hbWUsIG1lbWJlcikgXAorc3RhdGljIHNzaXplX3Qgc2hvd18jI25hbWUoc3RydWN0IGRldmljZSAqZGV2LCBcCisJCXN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpIFwKK3sgXAorCXN0cnVjdCBzb2Z0aW5nICpjYXJkID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEodG9fcGxhdGZvcm1fZGV2aWNlKGRldikpOyBcCisJcmV0dXJuIHNwcmludGYoYnVmLCAiJXNcbiIsIGNhcmQtPm1lbWJlcik7IFwKK30gXAorc3RhdGljIERFVklDRV9BVFRSKG5hbWUsIDA0NDQsIHNob3dfIyNuYW1lLCBOVUxMKQorCitERVZfQVRUUl9STyhzZXJpYWwsIGlkLnNlcmlhbCk7CitERVZfQVRUUl9ST19TVFIoZmlybXdhcmUsIHBkYXQtPmFwcC5mdyk7CitERVZfQVRUUl9STyhmaXJtd2FyZV92ZXJzaW9uLCBpZC5md192ZXJzaW9uKTsKK0RFVl9BVFRSX1JPX1NUUihoYXJkd2FyZSwgcGRhdC0+bmFtZSk7CitERVZfQVRUUl9STyhoYXJkd2FyZV92ZXJzaW9uLCBpZC5od192ZXJzaW9uKTsKK0RFVl9BVFRSX1JPKGxpY2Vuc2UsIGlkLmxpY2Vuc2UpOworREVWX0FUVFJfUk8oZnJlcXVlbmN5LCBpZC5mcmVxKTsKK0RFVl9BVFRSX1JPKHR4cGVuZGluZywgdHgucGVuZGluZyk7CisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpzb2Z0aW5nX3BkZXZfYXR0cnNbXSA9IHsKKwkmZGV2X2F0dHJfc2VyaWFsLmF0dHIsCisJJmRldl9hdHRyX2Zpcm13YXJlLmF0dHIsCisJJmRldl9hdHRyX2Zpcm13YXJlX3ZlcnNpb24uYXR0ciwKKwkmZGV2X2F0dHJfaGFyZHdhcmUuYXR0ciwKKwkmZGV2X2F0dHJfaGFyZHdhcmVfdmVyc2lvbi5hdHRyLAorCSZkZXZfYXR0cl9saWNlbnNlLmF0dHIsCisJJmRldl9hdHRyX2ZyZXF1ZW5jeS5hdHRyLAorCSZkZXZfYXR0cl90eHBlbmRpbmcuYXR0ciwKKwlOVUxMLAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgc29mdGluZ19wZGV2X2dyb3VwID0geworCS5uYW1lID0gTlVMTCwKKwkuYXR0cnMgPSBzb2Z0aW5nX3BkZXZfYXR0cnMsCit9OworCisvKgorICogcGxhdGZvcm0gZHJpdmVyCisgKi8KK3N0YXRpYyBfX2RldmV4aXQgaW50IHNvZnRpbmdfcGRldl9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlzdHJ1Y3Qgc29mdGluZyAqY2FyZCA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOworCWludCBqOworCisJLyogZmlyc3QsIGRpc2FibGUgY2FyZCovCisJc29mdGluZ19jYXJkX3NodXRkb3duKGNhcmQpOworCisJZm9yIChqID0gMDsgaiA8IEFSUkFZX1NJWkUoY2FyZC0+bmV0KTsgKytqKSB7CisJCWlmICghY2FyZC0+bmV0W2pdKQorCQkJY29udGludWU7CisJCXNvZnRpbmdfbmV0ZGV2X2NsZWFudXAoY2FyZC0+bmV0W2pdKTsKKwkJY2FyZC0+bmV0W2pdID0gTlVMTDsKKwl9CisJc3lzZnNfcmVtb3ZlX2dyb3VwKCZwZGV2LT5kZXYua29iaiwgJnNvZnRpbmdfcGRldl9ncm91cCk7CisKKwlpb3VubWFwKGNhcmQtPmRwcmFtKTsKKwlrZnJlZShjYXJkKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIF9fZGV2aW5pdCBpbnQgc29mdGluZ19wZGV2X3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJY29uc3Qgc3RydWN0IHNvZnRpbmdfcGxhdGZvcm1fZGF0YSAqcGRhdCA9IHBkZXYtPmRldi5wbGF0Zm9ybV9kYXRhOworCXN0cnVjdCBzb2Z0aW5nICpjYXJkOworCXN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXY7CisJc3RydWN0IHNvZnRpbmdfcHJpdiAqcHJpdjsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnByZXM7CisJaW50IHJldDsKKwlpbnQgajsKKworCWlmICghcGRhdCkgeworCQlkZXZfd2FybigmcGRldi0+ZGV2LCAibm8gcGxhdGZvcm0gZGF0YVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAocGRhdC0+bmJ1cyA+IEFSUkFZX1NJWkUoY2FyZC0+bmV0KSkgeworCQlkZXZfd2FybigmcGRldi0+ZGV2LCAiJXUgbmV0cz8/XG4iLCBwZGF0LT5uYnVzKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJY2FyZCA9IGt6YWxsb2Moc2l6ZW9mKCpjYXJkKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFjYXJkKQorCQlyZXR1cm4gLUVOT01FTTsKKwljYXJkLT5wZGF0ID0gcGRhdDsKKwljYXJkLT5wZGV2ID0gcGRldjsKKwlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBjYXJkKTsKKwltdXRleF9pbml0KCZjYXJkLT5mdy5sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmY2FyZC0+c3Bpbik7CisKKwlyZXQgPSAtRUlOVkFMOworCXByZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9NRU0sIDApOworCWlmICghcHJlcykKKwkJZ290byBwbGF0Zm9ybV9yZXNvdXJjZV9mYWlsZWQ7OworCWNhcmQtPmRwcmFtX3BoeXMgPSBwcmVzLT5zdGFydDsKKwljYXJkLT5kcHJhbV9zaXplID0gcHJlcy0+ZW5kIC0gcHJlcy0+c3RhcnQgKyAxOworCWNhcmQtPmRwcmFtID0gaW9yZW1hcF9ub2NhY2hlKGNhcmQtPmRwcmFtX3BoeXMsIGNhcmQtPmRwcmFtX3NpemUpOworCWlmICghY2FyZC0+ZHByYW0pIHsKKwkJZGV2X2FsZXJ0KCZjYXJkLT5wZGV2LT5kZXYsICJkcHJhbSBpb3JlbWFwIGZhaWxlZFxuIik7CisJCWdvdG8gaW9yZW1hcF9mYWlsZWQ7CisJfQorCisJcHJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNFX0lSUSwgMCk7CisJaWYgKHByZXMpCisJCWNhcmQtPmlycS5uciA9IHByZXMtPnN0YXJ0OworCisJLyogcmVzZXQgY2FyZCAqLworCXJldCA9IHNvZnRpbmdfY2FyZF9ib290KGNhcmQpOworCWlmIChyZXQgPCAwKSB7CisJCWRldl9hbGVydCgmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIGJvb3RcbiIpOworCQlnb3RvIGJvb3RfZmFpbGVkOworCX0KKworCS8qIG9ubHkgbm93LCB0aGUgY2hpcCdzIGFyZSBrbm93biAqLworCWNhcmQtPmlkLmZyZXEgPSBjYXJkLT5wZGF0LT5mcmVxOworCisJcmV0ID0gc3lzZnNfY3JlYXRlX2dyb3VwKCZwZGV2LT5kZXYua29iaiwgJnNvZnRpbmdfcGRldl9ncm91cCk7CisJaWYgKHJldCA8IDApIHsKKwkJZGV2X2FsZXJ0KCZjYXJkLT5wZGV2LT5kZXYsICJzeXNmcyBmYWlsZWRcbiIpOworCQlnb3RvIHN5c2ZzX2ZhaWxlZDsKKwl9CisKKwlyZXQgPSAtRU5PTUVNOworCWZvciAoaiA9IDA7IGogPCBBUlJBWV9TSVpFKGNhcmQtPm5ldCk7ICsraikgeworCQljYXJkLT5uZXRbal0gPSBuZXRkZXYgPQorCQkJc29mdGluZ19uZXRkZXZfY3JlYXRlKGNhcmQsIGNhcmQtPmlkLmNoaXBbal0pOworCQlpZiAoIW5ldGRldikgeworCQkJZGV2X2FsZXJ0KCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gbWFrZSBjYW5bJWldIiwgaik7CisJCQlnb3RvIG5ldGRldl9mYWlsZWQ7CisJCX0KKwkJcHJpdiA9IG5ldGRldl9wcml2KGNhcmQtPm5ldFtqXSk7CisJCXByaXYtPmluZGV4ID0gajsKKwkJcmV0ID0gc29mdGluZ19uZXRkZXZfcmVnaXN0ZXIobmV0ZGV2KTsKKwkJaWYgKHJldCkgeworCQkJZnJlZV9jYW5kZXYobmV0ZGV2KTsKKwkJCWNhcmQtPm5ldFtqXSA9IE5VTEw7CisJCQlkZXZfYWxlcnQoJmNhcmQtPnBkZXYtPmRldiwKKwkJCQkJImZhaWxlZCB0byByZWdpc3RlciBjYW5bJWldXG4iLCBqKTsKKwkJCWdvdG8gbmV0ZGV2X2ZhaWxlZDsKKwkJfQorCX0KKwlkZXZfaW5mbygmY2FyZC0+cGRldi0+ZGV2LCAiJXMgcmVhZHkuXG4iLCBjYXJkLT5wZGF0LT5uYW1lKTsKKwlyZXR1cm4gMDsKKworbmV0ZGV2X2ZhaWxlZDoKKwlmb3IgKGogPSAwOyBqIDwgQVJSQVlfU0laRShjYXJkLT5uZXQpOyArK2opIHsKKwkJaWYgKCFjYXJkLT5uZXRbal0pCisJCQljb250aW51ZTsKKwkJc29mdGluZ19uZXRkZXZfY2xlYW51cChjYXJkLT5uZXRbal0pOworCX0KKwlzeXNmc19yZW1vdmVfZ3JvdXAoJnBkZXYtPmRldi5rb2JqLCAmc29mdGluZ19wZGV2X2dyb3VwKTsKK3N5c2ZzX2ZhaWxlZDoKKwlzb2Z0aW5nX2NhcmRfc2h1dGRvd24oY2FyZCk7Citib290X2ZhaWxlZDoKKwlpb3VubWFwKGNhcmQtPmRwcmFtKTsKK2lvcmVtYXBfZmFpbGVkOgorcGxhdGZvcm1fcmVzb3VyY2VfZmFpbGVkOgorCWtmcmVlKGNhcmQpOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIHNvZnRpbmdfZHJpdmVyID0geworCS5kcml2ZXIgPSB7CisJCS5uYW1lID0gInNvZnRpbmciLAorCQkub3duZXIgPSBUSElTX01PRFVMRSwKKwl9LAorCS5wcm9iZSA9IHNvZnRpbmdfcGRldl9wcm9iZSwKKwkucmVtb3ZlID0gX19kZXZleGl0X3Aoc29mdGluZ19wZGV2X3JlbW92ZSksCit9OworCitNT0RVTEVfQUxJQVMoInBsYXRmb3JtOnNvZnRpbmciKTsKKworc3RhdGljIGludCBfX2luaXQgc29mdGluZ19zdGFydCh2b2lkKQoreworCXJldHVybiBwbGF0Zm9ybV9kcml2ZXJfcmVnaXN0ZXIoJnNvZnRpbmdfZHJpdmVyKTsKK30KKworc3RhdGljIHZvaWQgX19leGl0IHNvZnRpbmdfc3RvcCh2b2lkKQoreworCXBsYXRmb3JtX2RyaXZlcl91bnJlZ2lzdGVyKCZzb2Z0aW5nX2RyaXZlcik7Cit9CisKK21vZHVsZV9pbml0KHNvZnRpbmdfc3RhcnQpOworbW9kdWxlX2V4aXQoc29mdGluZ19zdG9wKTsKKworTU9EVUxFX0RFU0NSSVBUSU9OKCJTb2Z0aW5nIERQUkFNIENBTiBkcml2ZXIiKTsKK01PRFVMRV9BVVRIT1IoIkt1cnQgVmFuIERpamNrIDxrdXJ0LnZhbi5kaWpja0BlaWEuYmU+Iik7CitNT0RVTEVfTElDRU5TRSgiR1BMIHYyIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vc29mdGluZy9zb2Z0aW5nX3BsYXRmb3JtLmggYi9kcml2ZXJzL25ldC9jYW4vc29mdGluZy9zb2Z0aW5nX3BsYXRmb3JtLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZWJiZjY5OAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi9zb2Z0aW5nL3NvZnRpbmdfcGxhdGZvcm0uaApAQCAtMCwwICsxLDQwIEBACisKKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKworI2lmbmRlZiBfU09GVElOR19ERVZJQ0VfSF8KKyNkZWZpbmUgX1NPRlRJTkdfREVWSUNFX0hfCisKKy8qIHNvZnRpbmcgZmlybXdhcmUgZGlyZWN0b3J5IHByZWZpeCAqLworI2RlZmluZSBmd19kaXIgInNvZnRpbmctNC42LyIKKworc3RydWN0IHNvZnRpbmdfcGxhdGZvcm1fZGF0YSB7CisJdW5zaWduZWQgaW50IG1hbmY7CisJdW5zaWduZWQgaW50IHByb2Q7CisJLyoKKwkgKiBnZW5lcmF0aW9uCisJICogMXN0IHdpdGggTkVDIG9yIFNKQTEwMDAKKwkgKiA4Yml0LCBleGNsdXNpdmUgaW50ZXJydXB0LCAuLi4KKwkgKiAybmQgb25seSBTSkExMDAwCisJICogMTZiaXQsIHNoYXJlZCBpbnRlcnJ1cHQKKwkgKi8KKwlpbnQgZ2VuZXJhdGlvbjsKKwlpbnQgbmJ1czsgLyogIyBidXNzZXMgb24gZGV2aWNlICovCisJdW5zaWduZWQgaW50IGZyZXE7IC8qIG9wZXJhdGluZyBmcmVxdWVuY3kgaW4gSHogKi8KKwl1bnNpZ25lZCBpbnQgbWF4X2JycDsKKwl1bnNpZ25lZCBpbnQgbWF4X3NqdzsKKwl1bnNpZ25lZCBsb25nIGRwcmFtX3NpemU7CisJY29uc3QgY2hhciAqbmFtZTsKKwlzdHJ1Y3QgeworCQl1bnNpZ25lZCBsb25nIG9mZnM7CisJCXVuc2lnbmVkIGxvbmcgYWRkcjsKKwkJY29uc3QgY2hhciAqZnc7CisJfSBib290LCBsb2FkLCBhcHA7CisJLyoKKwkgKiByZXNldCgpIGZ1bmN0aW9uCisJICogYnJpbmcgcGRldiBpbiBvciBvdXQgb2YgcmVzZXQsIGRlcGVuZGluZyBvbiB2YWx1ZQorCSAqLworCWludCAoKnJlc2V0KShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LCBpbnQgdmFsdWUpOworCWludCAoKmVuYWJsZV9pcnEpKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsIGludCB2YWx1ZSk7Cit9OworCisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhc3NpbmkuYyBiL2RyaXZlcnMvbmV0L2Nhc3NpbmkuYwppbmRleCA3MjA2YWIyLi4zNDM3NjEzIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYXNzaW5pLmMKKysrIGIvZHJpdmVycy9uZXQvY2Fzc2luaS5jCkBAIC0zMjAzLDcgKzMyMDMsNyBAQAogCWludCBwaHlfdHlwZSA9IENBU19QSFlfTUlJX01ESU8wOyAvKiBkZWZhdWx0IHBoeSB0eXBlICovCiAJaW50IG1hY19vZmYgID0gMDsKIAotI2lmIGRlZmluZWQoQ09ORklHX09GKQorI2lmIGRlZmluZWQoQ09ORklHX1NQQVJDKQogCWNvbnN0IHVuc2lnbmVkIGNoYXIgKmFkZHI7CiAjZW5kaWYKIApAQCAtMzM1NCw3ICszMzU0LDcgQEAKIAlpZiAoZm91bmQgJiBWUERfRk9VTkRfTUFDKQogCQlnb3RvIGRvbmU7CiAKLSNpZiBkZWZpbmVkKENPTkZJR19PRikKKyNpZiBkZWZpbmVkKENPTkZJR19TUEFSQykKIAlhZGRyID0gb2ZfZ2V0X3Byb3BlcnR5KGNwLT5vZl9ub2RlLCAibG9jYWwtbWFjLWFkZHJlc3MiLCBOVUxMKTsKIAlpZiAoYWRkciAhPSBOVUxMKSB7CiAJCW1lbWNweShkZXZfYWRkciwgYWRkciwgNik7CkBAIC01MDMxLDcgKzUwMzEsNyBAQAogCWNwLT5tc2dfZW5hYmxlID0gKGNhc3NpbmlfZGVidWcgPCAwKSA/IENBU19ERUZfTVNHX0VOQUJMRSA6CiAJICBjYXNzaW5pX2RlYnVnOwogCi0jaWYgZGVmaW5lZChDT05GSUdfT0YpCisjaWYgZGVmaW5lZChDT05GSUdfU1BBUkMpCiAJY3AtPm9mX25vZGUgPSBwY2lfZGV2aWNlX3RvX09GX25vZGUocGRldik7CiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY25pYy5jIGIvZHJpdmVycy9uZXQvY25pYy5jCmluZGV4IDI2M2EyOTQuLjdmZjE3MGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2NuaWMuYworKysgYi9kcml2ZXJzL25ldC9jbmljLmMKQEAgLTY5OSwxMyArNjk5LDEzIEBACiBzdGF0aWMgdm9pZCBjbmljX3NldHVwX3BhZ2VfdGJsKHN0cnVjdCBjbmljX2RldiAqZGV2LCBzdHJ1Y3QgY25pY19kbWEgKmRtYSkKIHsKIAlpbnQgaTsKLQl1MzIgKnBhZ2VfdGFibGUgPSBkbWEtPnBndGJsOworCV9fbGUzMiAqcGFnZV90YWJsZSA9IChfX2xlMzIgKikgZG1hLT5wZ3RibDsKIAogCWZvciAoaSA9IDA7IGkgPCBkbWEtPm51bV9wYWdlczsgaSsrKSB7CiAJCS8qIEVhY2ggZW50cnkgbmVlZHMgdG8gYmUgaW4gYmlnIGVuZGlhbiBmb3JtYXQuICovCi0JCSpwYWdlX3RhYmxlID0gKHUzMikgKCh1NjQpIGRtYS0+cGdfbWFwX2FycltpXSA+PiAzMik7CisJCSpwYWdlX3RhYmxlID0gY3B1X3RvX2xlMzIoKHU2NCkgZG1hLT5wZ19tYXBfYXJyW2ldID4+IDMyKTsKIAkJcGFnZV90YWJsZSsrOwotCQkqcGFnZV90YWJsZSA9ICh1MzIpIGRtYS0+cGdfbWFwX2FycltpXTsKKwkJKnBhZ2VfdGFibGUgPSBjcHVfdG9fbGUzMihkbWEtPnBnX21hcF9hcnJbaV0gJiAweGZmZmZmZmZmKTsKIAkJcGFnZV90YWJsZSsrOwogCX0KIH0KQEAgLTcxMywxMyArNzEzLDEzIEBACiBzdGF0aWMgdm9pZCBjbmljX3NldHVwX3BhZ2VfdGJsX2xlKHN0cnVjdCBjbmljX2RldiAqZGV2LCBzdHJ1Y3QgY25pY19kbWEgKmRtYSkKIHsKIAlpbnQgaTsKLQl1MzIgKnBhZ2VfdGFibGUgPSBkbWEtPnBndGJsOworCV9fbGUzMiAqcGFnZV90YWJsZSA9IChfX2xlMzIgKikgZG1hLT5wZ3RibDsKIAogCWZvciAoaSA9IDA7IGkgPCBkbWEtPm51bV9wYWdlczsgaSsrKSB7CiAJCS8qIEVhY2ggZW50cnkgbmVlZHMgdG8gYmUgaW4gbGl0dGxlIGVuZGlhbiBmb3JtYXQuICovCi0JCSpwYWdlX3RhYmxlID0gZG1hLT5wZ19tYXBfYXJyW2ldICYgMHhmZmZmZmZmZjsKKwkJKnBhZ2VfdGFibGUgPSBjcHVfdG9fbGUzMihkbWEtPnBnX21hcF9hcnJbaV0gJiAweGZmZmZmZmZmKTsKIAkJcGFnZV90YWJsZSsrOwotCQkqcGFnZV90YWJsZSA9ICh1MzIpICgodTY0KSBkbWEtPnBnX21hcF9hcnJbaV0gPj4gMzIpOworCQkqcGFnZV90YWJsZSA9IGNwdV90b19sZTMyKCh1NjQpIGRtYS0+cGdfbWFwX2FycltpXSA+PiAzMik7CiAJCXBhZ2VfdGFibGUrKzsKIAl9CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jeGdiNC9jeGdiNF9tYWluLmMgYi9kcml2ZXJzL25ldC9jeGdiNC9jeGdiNF9tYWluLmMKaW5kZXggMDU5YzFlZS4uZWMzNWQ0NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvY3hnYjQvY3hnYjRfbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L2N4Z2I0L2N4Z2I0X21haW4uYwpAQCAtMjcxMCw2ICsyNzEwLDggQEAKIAlzdHJ1Y3QgcG9ydF9pbmZvICpwaSA9IG5ldGRldl9wcml2KGRldik7CiAJc3RydWN0IGFkYXB0ZXIgKmFkYXB0ZXIgPSBwaS0+YWRhcHRlcjsKIAorCW5ldGlmX2NhcnJpZXJfb2ZmKGRldik7CisKIAlpZiAoIShhZGFwdGVyLT5mbGFncyAmIEZVTExfSU5JVF9ET05FKSkgewogCQllcnIgPSBjeGdiX3VwKGFkYXB0ZXIpOwogCQlpZiAoZXJyIDwgMCkKQEAgLTM2NjEsNyArMzY2Myw2IEBACiAJCXBpLT54YWN0X2FkZHJfZmlsdCA9IC0xOwogCQlwaS0+cnhfb2ZmbG9hZCA9IFJYX0NTTzsKIAkJcGktPnBvcnRfaWQgPSBpOwotCQluZXRpZl9jYXJyaWVyX29mZihuZXRkZXYpOwogCQluZXRkZXYtPmlycSA9IHBkZXYtPmlycTsKIAogCQluZXRkZXYtPmZlYXR1cmVzIHw9IE5FVElGX0ZfU0cgfCBUU09fRkxBR1M7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9kZXBjYS5jIGIvZHJpdmVycy9uZXQvZGVwY2EuYwppbmRleCAxYjQ4YjY4Li44YjAwODRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9kZXBjYS5jCisrKyBiL2RyaXZlcnMvbmV0L2RlcGNhLmMKQEAgLTEwOTQsNyArMTA5NCw3IEBACiAJCQkJfQogCQkJfQogCQkJLyogQ2hhbmdlIGJ1ZmZlciBvd25lcnNoaXAgZm9yIHRoaXMgbGFzdCBmcmFtZSwgYmFjayB0byB0aGUgYWRhcHRlciAqLwotCQkJZm9yICg7IGxwLT5yeF9vbGQgIT0gZW50cnk7IGxwLT5yeF9vbGQgPSAoKytscC0+cnhfb2xkKSAmIGxwLT5yeFJpbmdNYXNrKSB7CisJCQlmb3IgKDsgbHAtPnJ4X29sZCAhPSBlbnRyeTsgbHAtPnJ4X29sZCA9IChscC0+cnhfb2xkICsgMSkgJiBscC0+cnhSaW5nTWFzaykgewogCQkJCXdyaXRlbChyZWFkbCgmbHAtPnJ4X3JpbmdbbHAtPnJ4X29sZF0uYmFzZSkgfCBSX09XTiwgJmxwLT5yeF9yaW5nW2xwLT5yeF9vbGRdLmJhc2UpOwogCQkJfQogCQkJd3JpdGVsKHJlYWRsKCZscC0+cnhfcmluZ1tlbnRyeV0uYmFzZSkgfCBSX09XTiwgJmxwLT5yeF9yaW5nW2VudHJ5XS5iYXNlKTsKQEAgLTExMDMsNyArMTEwMyw3IEBACiAJCS8qCiAJCSAgICoqIFVwZGF0ZSBlbnRyeSBpbmZvcm1hdGlvbgogCQkgKi8KLQkJbHAtPnJ4X25ldyA9ICgrK2xwLT5yeF9uZXcpICYgbHAtPnJ4UmluZ01hc2s7CisJCWxwLT5yeF9uZXcgPSAobHAtPnJ4X25ldyArIDEpICYgbHAtPnJ4UmluZ01hc2s7CiAJfQogCiAJcmV0dXJuIDA7CkBAIC0xMTQ4LDcgKzExNDgsNyBAQAogCQl9CiAKIAkJLyogVXBkYXRlIGFsbCB0aGUgcG9pbnRlcnMgKi8KLQkJbHAtPnR4X29sZCA9ICgrK2xwLT50eF9vbGQpICYgbHAtPnR4UmluZ01hc2s7CisJCWxwLT50eF9vbGQgPSAobHAtPnR4X29sZCArIDEpICYgbHAtPnR4UmluZ01hc2s7CiAJfQogCiAJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9kbDJrLmMgYi9kcml2ZXJzL25ldC9kbDJrLmMKaW5kZXggZTFhODIxNi4uYzA1ZGI2MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZGwyay5jCisrKyBiL2RyaXZlcnMvbmV0L2RsMmsuYwpAQCAtMTc1Myw4ICsxNzUzLDYgQEAKIAogCS8qIEZyZWUgYWxsIHRoZSBza2J1ZmZzIGluIHRoZSBxdWV1ZS4gKi8KIAlmb3IgKGkgPSAwOyBpIDwgUlhfUklOR19TSVpFOyBpKyspIHsKLQkJbnAtPnJ4X3JpbmdbaV0uc3RhdHVzID0gMDsKLQkJbnAtPnJ4X3JpbmdbaV0uZnJhZ2luZm8gPSAwOwogCQlza2IgPSBucC0+cnhfc2tidWZmW2ldOwogCQlpZiAoc2tiKSB7CiAJCQlwY2lfdW5tYXBfc2luZ2xlKG5wLT5wZGV2LApAQCAtMTc2Myw2ICsxNzYxLDggQEAKIAkJCWRldl9rZnJlZV9za2IgKHNrYik7CiAJCQlucC0+cnhfc2tidWZmW2ldID0gTlVMTDsKIAkJfQorCQlucC0+cnhfcmluZ1tpXS5zdGF0dXMgPSAwOworCQlucC0+cnhfcmluZ1tpXS5mcmFnaW5mbyA9IDA7CiAJfQogCWZvciAoaSA9IDA7IGkgPCBUWF9SSU5HX1NJWkU7IGkrKykgewogCQlza2IgPSBucC0+dHhfc2tidWZmW2ldOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZTEwMDAvZTEwMDBfaHcuYyBiL2RyaXZlcnMvbmV0L2UxMDAwL2UxMDAwX2h3LmMKaW5kZXggYWVkMjIzYi4uNzUwMWQ5NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZTEwMDAvZTEwMDBfaHcuYworKysgYi9kcml2ZXJzL25ldC9lMTAwMC9lMTAwMF9ody5jCkBAIC0xMjQsNiArMTI0LDcgQEAKIAljYXNlIE04OEUxMDAwX0lfUEhZX0lEOgogCWNhc2UgTTg4RTEwMTFfSV9QSFlfSUQ6CiAJY2FzZSBNODhFMTExMV9JX1BIWV9JRDoKKwljYXNlIE04OEUxMTE4X0VfUEhZX0lEOgogCQlody0+cGh5X3R5cGUgPSBlMTAwMF9waHlfbTg4OwogCQlicmVhazsKIAljYXNlIElHUDAxRTEwMDBfSV9QSFlfSUQ6CkBAIC0zMjIyLDcgKzMyMjMsOCBAQAogCQlicmVhazsKIAljYXNlIGUxMDAwX2NlNDEwMDoKIAkJaWYgKChody0+cGh5X2lkID09IFJUTDgyMTFCX1BIWV9JRCkgfHwKLQkJICAgIChody0+cGh5X2lkID09IFJUTDgyMDFOX1BIWV9JRCkpCisJCSAgICAoaHctPnBoeV9pZCA9PSBSVEw4MjAxTl9QSFlfSUQpIHx8CisJCSAgICAoaHctPnBoeV9pZCA9PSBNODhFMTExOF9FX1BIWV9JRCkpCiAJCQltYXRjaCA9IHRydWU7CiAJCWJyZWFrOwogCWNhc2UgZTEwMDBfODI1NDE6CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9lMTAwMC9lMTAwMF9ody5oIGIvZHJpdmVycy9uZXQvZTEwMDAvZTEwMDBfaHcuaAppbmRleCAxOTZlZWRhLi5jNzBiMjNkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9lMTAwMC9lMTAwMF9ody5oCisrKyBiL2RyaXZlcnMvbmV0L2UxMDAwL2UxMDAwX2h3LmgKQEAgLTI5MTcsNiArMjkxNyw3IEBACiAjZGVmaW5lIE04OEUxMDAwXzE0X1BIWV9JRCBNODhFMTAwMF9FX1BIWV9JRAogI2RlZmluZSBNODhFMTAxMV9JX1JFVl80ICAgMHgwNAogI2RlZmluZSBNODhFMTExMV9JX1BIWV9JRCAgMHgwMTQxMENDMAorI2RlZmluZSBNODhFMTExOF9FX1BIWV9JRCAgMHgwMTQxMEU0MAogI2RlZmluZSBMMUxYVDk3MUFfUEhZX0lEICAgMHgwMDEzNzhFMAogCiAjZGVmaW5lIFJUTDgyMTFCX1BIWV9JRCAgICAweDAwMUNDOTEwCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9lMTAwMC9lMTAwMF9tYWluLmMgYi9kcml2ZXJzL25ldC9lMTAwMC9lMTAwMF9tYWluLmMKaW5kZXggZGU2OWM1NC4uYmZhYjE0MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZTEwMDAvZTEwMDBfbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L2UxMDAwL2UxMDAwX21haW4uYwpAQCAtMzQ3OCw5ICszNDc4LDE3IEBACiAJc3RydWN0IGUxMDAwX2h3ICpodyA9ICZhZGFwdGVyLT5odzsKIAl1MzIgaWNyID0gZXIzMihJQ1IpOwogCi0JaWYgKHVubGlrZWx5KCghaWNyKSB8fCB0ZXN0X2JpdChfX0UxMDAwX0RPV04sICZhZGFwdGVyLT5mbGFncykpKQorCWlmICh1bmxpa2VseSgoIWljcikpKQogCQlyZXR1cm4gSVJRX05PTkU7ICAvKiBOb3Qgb3VyIGludGVycnVwdCAqLwogCisJLyoKKwkgKiB3ZSBtaWdodCBoYXZlIGNhdXNlZCB0aGUgaW50ZXJydXB0LCBidXQgdGhlIGFib3ZlCisJICogcmVhZCBjbGVhcmVkIGl0LCBhbmQganVzdCBpbiBjYXNlIHRoZSBkcml2ZXIgaXMKKwkgKiBkb3duIHRoZXJlIGlzIG5vdGhpbmcgdG8gZG8gc28gcmV0dXJuIGhhbmRsZWQKKwkgKi8KKwlpZiAodW5saWtlbHkodGVzdF9iaXQoX19FMTAwMF9ET1dOLCAmYWRhcHRlci0+ZmxhZ3MpKSkKKwkJcmV0dXJuIElSUV9IQU5ETEVEOworCiAJaWYgKHVubGlrZWx5KGljciAmIChFMTAwMF9JQ1JfUlhTRVEgfCBFMTAwMF9JQ1JfTFNDKSkpIHsKIAkJaHctPmdldF9saW5rX3N0YXR1cyA9IDE7CiAJCS8qIGd1YXJkIGFnYWluc3QgaW50ZXJydXB0IHdoZW4gd2UncmUgZ29pbmcgZG93biAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZTEwMDBlLzgyNTcxLmMgYi9kcml2ZXJzL25ldC9lMTAwMGUvODI1NzEuYwppbmRleCAxMzk3ZGExLi44OWE2OTAzIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9lMTAwMGUvODI1NzEuYworKysgYi9kcml2ZXJzL25ldC9lMTAwMGUvODI1NzEuYwpAQCAtMSw3ICsxLDcgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAKICAgSW50ZWwgUFJPLzEwMDAgTGludXggZHJpdmVyCi0gIENvcHlyaWdodChjKSAxOTk5IC0gMjAxMCBJbnRlbCBDb3Jwb3JhdGlvbi4KKyAgQ29weXJpZ2h0KGMpIDE5OTkgLSAyMDExIEludGVsIENvcnBvcmF0aW9uLgogCiAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CiAgIHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UsCkBAIC0xMzEwLDcgKzEzMTAsNyBAQAogCQkgKiBhcHBseSB3b3JrYXJvdW5kIGZvciBoYXJkd2FyZSBlcnJhdGEgZG9jdW1lbnRlZCBpbiBlcnJhdGEKIAkJICogZG9jcyBGaXhlcyBpc3N1ZSB3aGVyZSBzb21lIGVycm9yIHByb25lIG9yIHVucmVsaWFibGUgUENJZQogCQkgKiBjb21wbGV0aW9ucyBhcmUgb2NjdXJyaW5nLCBwYXJ0aWN1bGFybHkgd2l0aCBBU1BNIGVuYWJsZWQuCi0JCSAqIFdpdGhvdXQgZml4LCBpc3N1ZSBjYW4gY2F1c2UgdHggdGltZW91dHMuCisJCSAqIFdpdGhvdXQgZml4LCBpc3N1ZSBjYW4gY2F1c2UgVHggdGltZW91dHMuCiAJCSAqLwogCQlyZWcgPSBlcjMyKEdDUjIpOwogCQlyZWcgfD0gMTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2UxMDAwZS9NYWtlZmlsZSBiL2RyaXZlcnMvbmV0L2UxMDAwZS9NYWtlZmlsZQppbmRleCAzNjBjOTEzLi4yODUxOWFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9lMTAwMGUvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9uZXQvZTEwMDBlL01ha2VmaWxlCkBAIC0xLDcgKzEsNyBAQAogIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKICMKICMgSW50ZWwgUFJPLzEwMDAgTGludXggZHJpdmVyCi0jIENvcHlyaWdodChjKSAxOTk5IC0gMjAwOCBJbnRlbCBDb3Jwb3JhdGlvbi4KKyMgQ29weXJpZ2h0KGMpIDE5OTkgLSAyMDExIEludGVsIENvcnBvcmF0aW9uLgogIwogIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAogIyB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZTEwMDBlL2RlZmluZXMuaCBiL2RyaXZlcnMvbmV0L2UxMDAwZS9kZWZpbmVzLmgKaW5kZXggNzI0NWRjMi4uMTMxNDk5OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZTEwMDBlL2RlZmluZXMuaAorKysgYi9kcml2ZXJzL25ldC9lMTAwMGUvZGVmaW5lcy5oCkBAIC0xLDcgKzEsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKIAogICBJbnRlbCBQUk8vMTAwMCBMaW51eCBkcml2ZXIKLSAgQ29weXJpZ2h0KGMpIDE5OTkgLSAyMDEwIEludGVsIENvcnBvcmF0aW9uLgorICBDb3B5cmlnaHQoYykgMTk5OSAtIDIwMTEgSW50ZWwgQ29ycG9yYXRpb24uCiAKICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKICAgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2UxMDAwZS9lMTAwMC5oIGIvZHJpdmVycy9uZXQvZTEwMDBlL2UxMDAwLmgKaW5kZXggNTI1NWJlNy4uZTYxMGUxMzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2UxMDAwZS9lMTAwMC5oCisrKyBiL2RyaXZlcnMvbmV0L2UxMDAwZS9lMTAwMC5oCkBAIC0xLDcgKzEsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKIAogICBJbnRlbCBQUk8vMTAwMCBMaW51eCBkcml2ZXIKLSAgQ29weXJpZ2h0KGMpIDE5OTkgLSAyMDEwIEludGVsIENvcnBvcmF0aW9uLgorICBDb3B5cmlnaHQoYykgMTk5OSAtIDIwMTEgSW50ZWwgQ29ycG9yYXRpb24uCiAKICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKICAgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2UxMDAwZS9lczJsYW4uYyBiL2RyaXZlcnMvbmV0L2UxMDAwZS9lczJsYW4uYwppbmRleCBlNDVhNjFjLi4yZmVmYTgyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9lMTAwMGUvZXMybGFuLmMKKysrIGIvZHJpdmVycy9uZXQvZTEwMDBlL2VzMmxhbi5jCkBAIC0xLDcgKzEsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKIAogICBJbnRlbCBQUk8vMTAwMCBMaW51eCBkcml2ZXIKLSAgQ29weXJpZ2h0KGMpIDE5OTkgLSAyMDEwIEludGVsIENvcnBvcmF0aW9uLgorICBDb3B5cmlnaHQoYykgMTk5OSAtIDIwMTEgSW50ZWwgQ29ycG9yYXRpb24uCiAKICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKICAgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2UxMDAwZS9ldGh0b29sLmMgYi9kcml2ZXJzL25ldC9lMTAwMGUvZXRodG9vbC5jCmluZGV4IGY4ZWQwM2QuLmZhMDhiNjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2UxMDAwZS9ldGh0b29sLmMKKysrIGIvZHJpdmVycy9uZXQvZTEwMDBlL2V0aHRvb2wuYwpAQCAtMSw3ICsxLDcgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAKICAgSW50ZWwgUFJPLzEwMDAgTGludXggZHJpdmVyCi0gIENvcHlyaWdodChjKSAxOTk5IC0gMjAxMCBJbnRlbCBDb3Jwb3JhdGlvbi4KKyAgQ29weXJpZ2h0KGMpIDE5OTkgLSAyMDExIEludGVsIENvcnBvcmF0aW9uLgogCiAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CiAgIHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UsCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9lMTAwMGUvaHcuaCBiL2RyaXZlcnMvbmV0L2UxMDAwZS9ody5oCmluZGV4IGU3NzQzODAuLmJjMDg2MGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2UxMDAwZS9ody5oCisrKyBiL2RyaXZlcnMvbmV0L2UxMDAwZS9ody5oCkBAIC0xLDcgKzEsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKIAogICBJbnRlbCBQUk8vMTAwMCBMaW51eCBkcml2ZXIKLSAgQ29weXJpZ2h0KGMpIDE5OTkgLSAyMDEwIEludGVsIENvcnBvcmF0aW9uLgorICBDb3B5cmlnaHQoYykgMTk5OSAtIDIwMTEgSW50ZWwgQ29ycG9yYXRpb24uCiAKICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKICAgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKQEAgLTEwMiw3ICsxMDIsNyBAQAogCUUxMDAwX1JEVFIgICAgID0gMHgwMjgyMCwgLyogUnggRGVsYXkgVGltZXIgLSBSVyAqLwogCUUxMDAwX1JYRENUTF9CQVNFID0gMHgwMjgyOCwgLyogUnggRGVzY3JpcHRvciBDb250cm9sIC0gUlcgKi8KICNkZWZpbmUgRTEwMDBfUlhEQ1RMKF9uKSAgIChFMTAwMF9SWERDVExfQkFTRSArIChfbiA8PCA4KSkKLQlFMTAwMF9SQURWICAgICA9IDB4MDI4MkMsIC8qIFJYIEludGVycnVwdCBBYnNvbHV0ZSBEZWxheSBUaW1lciAtIFJXICovCisJRTEwMDBfUkFEViAgICAgPSAweDAyODJDLCAvKiBSeCBJbnRlcnJ1cHQgQWJzb2x1dGUgRGVsYXkgVGltZXIgLSBSVyAqLwogCiAvKiBDb252ZW5pZW5jZSBtYWNyb3MKICAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9lMTAwMGUvaWNoOGxhbi5jIGIvZHJpdmVycy9uZXQvZTEwMDBlL2ljaDhsYW4uYwppbmRleCA1YmI2NWI3Li5mYjQ2OTc0IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9lMTAwMGUvaWNoOGxhbi5jCisrKyBiL2RyaXZlcnMvbmV0L2UxMDAwZS9pY2g4bGFuLmMKQEAgLTEsNyArMSw3IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogCiAgIEludGVsIFBSTy8xMDAwIExpbnV4IGRyaXZlcgotICBDb3B5cmlnaHQoYykgMTk5OSAtIDIwMTAgSW50ZWwgQ29ycG9yYXRpb24uCisgIENvcHlyaWdodChjKSAxOTk5IC0gMjAxMSBJbnRlbCBDb3Jwb3JhdGlvbi4KIAogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAogICB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZTEwMDBlL2xpYi5jIGIvZHJpdmVycy9uZXQvZTEwMDBlL2xpYi5jCmluZGV4IGZmMjg3MjEuLjY4YWExNzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2UxMDAwZS9saWIuYworKysgYi9kcml2ZXJzL25ldC9lMTAwMGUvbGliLmMKQEAgLTEsNyArMSw3IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogCiAgIEludGVsIFBSTy8xMDAwIExpbnV4IGRyaXZlcgotICBDb3B5cmlnaHQoYykgMTk5OSAtIDIwMTAgSW50ZWwgQ29ycG9yYXRpb24uCisgIENvcHlyaWdodChjKSAxOTk5IC0gMjAxMSBJbnRlbCBDb3Jwb3JhdGlvbi4KIAogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAogICB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlLApAQCAtNTMzLDcgKzUzMyw3IEBACiAJCQltYWMtPmF1dG9uZWdfZmFpbGVkID0gMTsKIAkJCXJldHVybiAwOwogCQl9Ci0JCWVfZGJnKCJOT1QgUlhpbmcgL0MvLCBkaXNhYmxlIEF1dG9OZWcgYW5kIGZvcmNlIGxpbmsuXG4iKTsKKwkJZV9kYmcoIk5PVCBSeCdpbmcgL0MvLCBkaXNhYmxlIEF1dG9OZWcgYW5kIGZvcmNlIGxpbmsuXG4iKTsKIAogCQkvKiBEaXNhYmxlIGF1dG8tbmVnb3RpYXRpb24gaW4gdGhlIFRYQ1cgcmVnaXN0ZXIgKi8KIAkJZXczMihUWENXLCAobWFjLT50eGN3ICYgfkUxMDAwX1RYQ1dfQU5FKSk7CkBAIC01NTYsNyArNTU2LDcgQEAKIAkJICogYW5kIGRpc2FibGUgZm9yY2VkIGxpbmsgaW4gdGhlIERldmljZSBDb250cm9sIHJlZ2lzdGVyCiAJCSAqIGluIGFuIGF0dGVtcHQgdG8gYXV0by1uZWdvdGlhdGUgd2l0aCBvdXIgbGluayBwYXJ0bmVyLgogCQkgKi8KLQkJZV9kYmcoIlJYaW5nIC9DLywgZW5hYmxlIEF1dG9OZWcgYW5kIHN0b3AgZm9yY2luZyBsaW5rLlxuIik7CisJCWVfZGJnKCJSeCdpbmcgL0MvLCBlbmFibGUgQXV0b05lZyBhbmQgc3RvcCBmb3JjaW5nIGxpbmsuXG4iKTsKIAkJZXczMihUWENXLCBtYWMtPnR4Y3cpOwogCQlldzMyKENUUkwsIChjdHJsICYgfkUxMDAwX0NUUkxfU0xVKSk7CiAKQEAgLTU5OCw3ICs1OTgsNyBAQAogCQkJbWFjLT5hdXRvbmVnX2ZhaWxlZCA9IDE7CiAJCQlyZXR1cm4gMDsKIAkJfQotCQllX2RiZygiTk9UIFJYaW5nIC9DLywgZGlzYWJsZSBBdXRvTmVnIGFuZCBmb3JjZSBsaW5rLlxuIik7CisJCWVfZGJnKCJOT1QgUngnaW5nIC9DLywgZGlzYWJsZSBBdXRvTmVnIGFuZCBmb3JjZSBsaW5rLlxuIik7CiAKIAkJLyogRGlzYWJsZSBhdXRvLW5lZ290aWF0aW9uIGluIHRoZSBUWENXIHJlZ2lzdGVyICovCiAJCWV3MzIoVFhDVywgKG1hYy0+dHhjdyAmIH5FMTAwMF9UWENXX0FORSkpOwpAQCAtNjIxLDcgKzYyMSw3IEBACiAJCSAqIGFuZCBkaXNhYmxlIGZvcmNlZCBsaW5rIGluIHRoZSBEZXZpY2UgQ29udHJvbCByZWdpc3RlcgogCQkgKiBpbiBhbiBhdHRlbXB0IHRvIGF1dG8tbmVnb3RpYXRlIHdpdGggb3VyIGxpbmsgcGFydG5lci4KIAkJICovCi0JCWVfZGJnKCJSWGluZyAvQy8sIGVuYWJsZSBBdXRvTmVnIGFuZCBzdG9wIGZvcmNpbmcgbGluay5cbiIpOworCQllX2RiZygiUngnaW5nIC9DLywgZW5hYmxlIEF1dG9OZWcgYW5kIHN0b3AgZm9yY2luZyBsaW5rLlxuIik7CiAJCWV3MzIoVFhDVywgbWFjLT50eGN3KTsKIAkJZXczMihDVFJMLCAoY3RybCAmIH5FMTAwMF9DVFJMX1NMVSkpOwogCkBAIC04MDAsOSArODAwLDkgQEAKIAkgKiBUaGUgcG9zc2libGUgdmFsdWVzIG9mIHRoZSAiZmMiIHBhcmFtZXRlciBhcmU6CiAJICogICAgICAwOiAgRmxvdyBjb250cm9sIGlzIGNvbXBsZXRlbHkgZGlzYWJsZWQKIAkgKiAgICAgIDE6ICBSeCBmbG93IGNvbnRyb2wgaXMgZW5hYmxlZCAod2UgY2FuIHJlY2VpdmUgcGF1c2UgZnJhbWVzLAotCSAqCSAgYnV0IG5vdCBzZW5kIHBhdXNlIGZyYW1lcykuCisJICogICAgICAgICAgYnV0IG5vdCBzZW5kIHBhdXNlIGZyYW1lcykuCiAJICogICAgICAyOiAgVHggZmxvdyBjb250cm9sIGlzIGVuYWJsZWQgKHdlIGNhbiBzZW5kIHBhdXNlIGZyYW1lcyBidXQgd2UKLQkgKgkgIGRvIG5vdCBzdXBwb3J0IHJlY2VpdmluZyBwYXVzZSBmcmFtZXMpLgorCSAqICAgICAgICAgIGRvIG5vdCBzdXBwb3J0IHJlY2VpdmluZyBwYXVzZSBmcmFtZXMpLgogCSAqICAgICAgMzogIEJvdGggUnggYW5kIFR4IGZsb3cgY29udHJvbCAoc3ltbWV0cmljKSBhcmUgZW5hYmxlZC4KIAkgKi8KIAlzd2l0Y2ggKGh3LT5mYy5jdXJyZW50X21vZGUpIHsKQEAgLTEwMzEsOSArMTAzMSw5IEBACiAJICogVGhlIHBvc3NpYmxlIHZhbHVlcyBvZiB0aGUgImZjIiBwYXJhbWV0ZXIgYXJlOgogCSAqICAgICAgMDogIEZsb3cgY29udHJvbCBpcyBjb21wbGV0ZWx5IGRpc2FibGVkCiAJICogICAgICAxOiAgUnggZmxvdyBjb250cm9sIGlzIGVuYWJsZWQgKHdlIGNhbiByZWNlaXZlIHBhdXNlCi0JICoJICBmcmFtZXMgYnV0IG5vdCBzZW5kIHBhdXNlIGZyYW1lcykuCisJICogICAgICAgICAgZnJhbWVzIGJ1dCBub3Qgc2VuZCBwYXVzZSBmcmFtZXMpLgogCSAqICAgICAgMjogIFR4IGZsb3cgY29udHJvbCBpcyBlbmFibGVkICh3ZSBjYW4gc2VuZCBwYXVzZSBmcmFtZXMKLQkgKgkgIGZyYW1lcyBidXQgd2UgZG8gbm90IHJlY2VpdmUgcGF1c2UgZnJhbWVzKS4KKwkgKiAgICAgICAgICBmcmFtZXMgYnV0IHdlIGRvIG5vdCByZWNlaXZlIHBhdXNlIGZyYW1lcykuCiAJICogICAgICAzOiAgQm90aCBSeCBhbmQgVHggZmxvdyBjb250cm9sIChzeW1tZXRyaWMpIGlzIGVuYWJsZWQuCiAJICogIG90aGVyOiAgTm8gb3RoZXIgdmFsdWVzIHNob3VsZCBiZSBwb3NzaWJsZSBhdCB0aGlzIHBvaW50LgogCSAqLwpAQCAtMTE4OSw3ICsxMTg5LDcgQEAKIAkJCX0gZWxzZSB7CiAJCQkJaHctPmZjLmN1cnJlbnRfbW9kZSA9IGUxMDAwX2ZjX3J4X3BhdXNlOwogCQkJCWVfZGJnKCJGbG93IENvbnRyb2wgPSAiCi0JCQkJCSAiUlggUEFVU0UgZnJhbWVzIG9ubHkuXHJcbiIpOworCQkJCSAgICAgICJSeCBQQVVTRSBmcmFtZXMgb25seS5cclxuIik7CiAJCQl9CiAJCX0KIAkJLyoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2UxMDAwZS9uZXRkZXYuYyBiL2RyaXZlcnMvbmV0L2UxMDAwZS9uZXRkZXYuYwppbmRleCBmYTViNjA0Li4zMDY1ODcwIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9lMTAwMGUvbmV0ZGV2LmMKKysrIGIvZHJpdmVycy9uZXQvZTEwMDBlL25ldGRldi5jCkBAIC0xLDcgKzEsNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKIAogICBJbnRlbCBQUk8vMTAwMCBMaW51eCBkcml2ZXIKLSAgQ29weXJpZ2h0KGMpIDE5OTkgLSAyMDEwIEludGVsIENvcnBvcmF0aW9uLgorICBDb3B5cmlnaHQoYykgMTk5OSAtIDIwMTEgSW50ZWwgQ29ycG9yYXRpb24uCiAKICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKICAgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKQEAgLTc3LDE3ICs3NywxNyBAQAogCWNoYXIgKm5hbWU7CiB9OwogCi0jZGVmaW5lIEUxMDAwX1JERkgJMHgwMjQxMCAvKiBSeCBEYXRhIEZJRk8gSGVhZCAtIFJXICovCi0jZGVmaW5lIEUxMDAwX1JERlQJMHgwMjQxOCAvKiBSeCBEYXRhIEZJRk8gVGFpbCAtIFJXICovCi0jZGVmaW5lIEUxMDAwX1JERkhTCTB4MDI0MjAgLyogUnggRGF0YSBGSUZPIEhlYWQgU2F2ZWQgLSBSVyAqLwotI2RlZmluZSBFMTAwMF9SREZUUwkweDAyNDI4IC8qIFJ4IERhdGEgRklGTyBUYWlsIFNhdmVkIC0gUlcgKi8KLSNkZWZpbmUgRTEwMDBfUkRGUEMJMHgwMjQzMCAvKiBSeCBEYXRhIEZJRk8gUGFja2V0IENvdW50IC0gUlcgKi8KKyNkZWZpbmUgRTEwMDBfUkRGSAkweDAyNDEwCS8qIFJ4IERhdGEgRklGTyBIZWFkIC0gUlcgKi8KKyNkZWZpbmUgRTEwMDBfUkRGVAkweDAyNDE4CS8qIFJ4IERhdGEgRklGTyBUYWlsIC0gUlcgKi8KKyNkZWZpbmUgRTEwMDBfUkRGSFMJMHgwMjQyMAkvKiBSeCBEYXRhIEZJRk8gSGVhZCBTYXZlZCAtIFJXICovCisjZGVmaW5lIEUxMDAwX1JERlRTCTB4MDI0MjgJLyogUnggRGF0YSBGSUZPIFRhaWwgU2F2ZWQgLSBSVyAqLworI2RlZmluZSBFMTAwMF9SREZQQwkweDAyNDMwCS8qIFJ4IERhdGEgRklGTyBQYWNrZXQgQ291bnQgLSBSVyAqLwogCi0jZGVmaW5lIEUxMDAwX1RERkgJMHgwMzQxMCAvKiBUeCBEYXRhIEZJRk8gSGVhZCAtIFJXICovCi0jZGVmaW5lIEUxMDAwX1RERlQJMHgwMzQxOCAvKiBUeCBEYXRhIEZJRk8gVGFpbCAtIFJXICovCi0jZGVmaW5lIEUxMDAwX1RERkhTCTB4MDM0MjAgLyogVHggRGF0YSBGSUZPIEhlYWQgU2F2ZWQgLSBSVyAqLwotI2RlZmluZSBFMTAwMF9UREZUUwkweDAzNDI4IC8qIFR4IERhdGEgRklGTyBUYWlsIFNhdmVkIC0gUlcgKi8KLSNkZWZpbmUgRTEwMDBfVERGUEMJMHgwMzQzMCAvKiBUeCBEYXRhIEZJRk8gUGFja2V0IENvdW50IC0gUlcgKi8KKyNkZWZpbmUgRTEwMDBfVERGSAkweDAzNDEwCS8qIFR4IERhdGEgRklGTyBIZWFkIC0gUlcgKi8KKyNkZWZpbmUgRTEwMDBfVERGVAkweDAzNDE4CS8qIFR4IERhdGEgRklGTyBUYWlsIC0gUlcgKi8KKyNkZWZpbmUgRTEwMDBfVERGSFMJMHgwMzQyMAkvKiBUeCBEYXRhIEZJRk8gSGVhZCBTYXZlZCAtIFJXICovCisjZGVmaW5lIEUxMDAwX1RERlRTCTB4MDM0MjgJLyogVHggRGF0YSBGSUZPIFRhaWwgU2F2ZWQgLSBSVyAqLworI2RlZmluZSBFMTAwMF9UREZQQwkweDAzNDMwCS8qIFR4IERhdGEgRklGTyBQYWNrZXQgQ291bnQgLSBSVyAqLwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IGUxMDAwX3JlZ19pbmZvIGUxMDAwX3JlZ19pbmZvX3RibFtdID0gewogCkBAIC05OSw3ICs5OSw3IEBACiAJLyogSW50ZXJydXB0IFJlZ2lzdGVycyAqLwogCXtFMTAwMF9JQ1IsICJJQ1IifSwKIAotCS8qIFJYIFJlZ2lzdGVycyAqLworCS8qIFJ4IFJlZ2lzdGVycyAqLwogCXtFMTAwMF9SQ1RMLCAiUkNUTCJ9LAogCXtFMTAwMF9SRExFTiwgIlJETEVOIn0sCiAJe0UxMDAwX1JESCwgIlJESCJ9LApAQCAtMTE1LDcgKzExNSw3IEBACiAJe0UxMDAwX1JERlRTLCAiUkRGVFMifSwKIAl7RTEwMDBfUkRGUEMsICJSREZQQyJ9LAogCi0JLyogVFggUmVnaXN0ZXJzICovCisJLyogVHggUmVnaXN0ZXJzICovCiAJe0UxMDAwX1RDVEwsICJUQ1RMIn0sCiAJe0UxMDAwX1REQkFMLCAiVERCQUwifSwKIAl7RTEwMDBfVERCQUgsICJUREJBSCJ9LApAQCAtMTYwLDcgKzE2MCw3IEBACiAJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCXByaW50ayhLRVJOX0lORk8gIiUtMTVzICUwOHhcbiIsCi0JCQlyZWdpbmZvLT5uYW1lLCBfX2VyMzIoaHcsIHJlZ2luZm8tPm9mcykpOworCQkgICAgICAgcmVnaW5mby0+bmFtZSwgX19lcjMyKGh3LCByZWdpbmZvLT5vZnMpKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtMTcxLDkgKzE3MSw4IEBACiAJcHJpbnRrKEtFUk5fQ09OVCAiXG4iKTsKIH0KIAotCiAvKgotICogZTEwMDBlX2R1bXAgLSBQcmludCByZWdpc3RlcnMsIHR4LXJpbmcgYW5kIHJ4LXJpbmcKKyAqIGUxMDAwZV9kdW1wIC0gUHJpbnQgcmVnaXN0ZXJzLCBUeC1yaW5nIGFuZCBSeC1yaW5nCiAgKi8KIHN0YXRpYyB2b2lkIGUxMDAwZV9kdW1wKHN0cnVjdCBlMTAwMF9hZGFwdGVyICphZGFwdGVyKQogewpAQCAtMTgyLDEyICsxODEsMjAgQEAKIAlzdHJ1Y3QgZTEwMDBfcmVnX2luZm8gKnJlZ2luZm87CiAJc3RydWN0IGUxMDAwX3JpbmcgKnR4X3JpbmcgPSBhZGFwdGVyLT50eF9yaW5nOwogCXN0cnVjdCBlMTAwMF90eF9kZXNjICp0eF9kZXNjOwotCXN0cnVjdCBteV91MCB7IHU2NCBhOyB1NjQgYjsgfSAqdTA7CisJc3RydWN0IG15X3UwIHsKKwkJdTY0IGE7CisJCXU2NCBiOworCX0gKnUwOwogCXN0cnVjdCBlMTAwMF9idWZmZXIgKmJ1ZmZlcl9pbmZvOwogCXN0cnVjdCBlMTAwMF9yaW5nICpyeF9yaW5nID0gYWRhcHRlci0+cnhfcmluZzsKIAl1bmlvbiBlMTAwMF9yeF9kZXNjX3BhY2tldF9zcGxpdCAqcnhfZGVzY19wczsKIAlzdHJ1Y3QgZTEwMDBfcnhfZGVzYyAqcnhfZGVzYzsKLQlzdHJ1Y3QgbXlfdTEgeyB1NjQgYTsgdTY0IGI7IHU2NCBjOyB1NjQgZDsgfSAqdTE7CisJc3RydWN0IG15X3UxIHsKKwkJdTY0IGE7CisJCXU2NCBiOworCQl1NjQgYzsKKwkJdTY0IGQ7CisJfSAqdTE7CiAJdTMyIHN0YXRlcnI7CiAJaW50IGkgPSAwOwogCkBAIC0xOTgsMTIgKzIwNSwxMCBAQAogCWlmIChuZXRkZXYpIHsKIAkJZGV2X2luZm8oJmFkYXB0ZXItPnBkZXYtPmRldiwgIk5ldCBkZXZpY2UgSW5mb1xuIik7CiAJCXByaW50ayhLRVJOX0lORk8gIkRldmljZSBOYW1lICAgICBzdGF0ZSAgICAgICAgICAgICIKLQkJCSJ0cmFuc19zdGFydCAgICAgIGxhc3RfcnhcbiIpOworCQkgICAgICAgInRyYW5zX3N0YXJ0ICAgICAgbGFzdF9yeFxuIik7CiAJCXByaW50ayhLRVJOX0lORk8gIiUtMTVzICUwMTZsWCAlMDE2bFggJTAxNmxYXG4iLAotCQkJbmV0ZGV2LT5uYW1lLAotCQkJbmV0ZGV2LT5zdGF0ZSwKLQkJCW5ldGRldi0+dHJhbnNfc3RhcnQsCi0JCQluZXRkZXYtPmxhc3RfcngpOworCQkgICAgICAgbmV0ZGV2LT5uYW1lLCBuZXRkZXYtPnN0YXRlLCBuZXRkZXYtPnRyYW5zX3N0YXJ0LAorCQkgICAgICAgbmV0ZGV2LT5sYXN0X3J4KTsKIAl9CiAKIAkvKiBQcmludCBSZWdpc3RlcnMgKi8KQEAgLTIxNCwyNiArMjE5LDI2IEBACiAJCWUxMDAwX3JlZ2R1bXAoaHcsIHJlZ2luZm8pOwogCX0KIAotCS8qIFByaW50IFRYIFJpbmcgU3VtbWFyeSAqLworCS8qIFByaW50IFR4IFJpbmcgU3VtbWFyeSAqLwogCWlmICghbmV0ZGV2IHx8ICFuZXRpZl9ydW5uaW5nKG5ldGRldikpCiAJCWdvdG8gZXhpdDsKIAotCWRldl9pbmZvKCZhZGFwdGVyLT5wZGV2LT5kZXYsICJUWCBSaW5ncyBTdW1tYXJ5XG4iKTsKKwlkZXZfaW5mbygmYWRhcHRlci0+cGRldi0+ZGV2LCAiVHggUmluZyBTdW1tYXJ5XG4iKTsKIAlwcmludGsoS0VSTl9JTkZPICJRdWV1ZSBbTlRVXSBbTlRDXSBbYmkobnRjKS0+ZG1hICBdIgotCQkiIGxlbmcgbnR3IHRpbWVzdGFtcFxuIik7CisJICAgICAgICIgbGVuZyBudHcgdGltZXN0YW1wXG4iKTsKIAlidWZmZXJfaW5mbyA9ICZ0eF9yaW5nLT5idWZmZXJfaW5mb1t0eF9yaW5nLT5uZXh0X3RvX2NsZWFuXTsKIAlwcmludGsoS0VSTl9JTkZPICIgJTVkICU1WCAlNVggJTAxNmxsWCAlMDRYICUzWCAlMDE2bGxYXG4iLAotCQkwLCB0eF9yaW5nLT5uZXh0X3RvX3VzZSwgdHhfcmluZy0+bmV4dF90b19jbGVhbiwKLQkJKHVuc2lnbmVkIGxvbmcgbG9uZylidWZmZXJfaW5mby0+ZG1hLAotCQlidWZmZXJfaW5mby0+bGVuZ3RoLAotCQlidWZmZXJfaW5mby0+bmV4dF90b193YXRjaCwKLQkJKHVuc2lnbmVkIGxvbmcgbG9uZylidWZmZXJfaW5mby0+dGltZV9zdGFtcCk7CisJICAgICAgIDAsIHR4X3JpbmctPm5leHRfdG9fdXNlLCB0eF9yaW5nLT5uZXh0X3RvX2NsZWFuLAorCSAgICAgICAodW5zaWduZWQgbG9uZyBsb25nKWJ1ZmZlcl9pbmZvLT5kbWEsCisJICAgICAgIGJ1ZmZlcl9pbmZvLT5sZW5ndGgsCisJICAgICAgIGJ1ZmZlcl9pbmZvLT5uZXh0X3RvX3dhdGNoLAorCSAgICAgICAodW5zaWduZWQgbG9uZyBsb25nKWJ1ZmZlcl9pbmZvLT50aW1lX3N0YW1wKTsKIAotCS8qIFByaW50IFRYIFJpbmdzICovCisJLyogUHJpbnQgVHggUmluZyAqLwogCWlmICghbmV0aWZfbXNnX3R4X2RvbmUoYWRhcHRlcikpCiAJCWdvdG8gcnhfcmluZ19zdW1tYXJ5OwogCi0JZGV2X2luZm8oJmFkYXB0ZXItPnBkZXYtPmRldiwgIlRYIFJpbmdzIER1bXBcbiIpOworCWRldl9pbmZvKCZhZGFwdGVyLT5wZGV2LT5kZXYsICJUeCBSaW5nIER1bXBcbiIpOwogCiAJLyogVHJhbnNtaXQgRGVzY3JpcHRvciBGb3JtYXRzIC0gREVYVFsyOV0gaXMgMCAoTGVnYWN5KSBvciAxIChFeHRlbmRlZCkKIAkgKgpAQCAtMjYzLDIyICsyNjgsMjIgQEAKIAkgKiAgIDYzICAgICAgIDQ4IDQ3ICAgICA0MCAzOSAgMzYgMzUgICAgMzIgMzEgICAgIDI0IDIzICAyMCAxOSAgICAgICAgMAogCSAqLwogCXByaW50ayhLRVJOX0lORk8gIlRsW2Rlc2NdICAgICBbYWRkcmVzcyA2MzowICBdIFtTcGVDc3NTQ21Dc0xlbl0iCi0JCSIgW2JpLT5kbWEgICAgICAgXSBsZW5nICBudHcgdGltZXN0YW1wICAgICAgICBiaS0+c2tiICIKLQkJIjwtLSBMZWdhY3kgZm9ybWF0XG4iKTsKKwkgICAgICAgIiBbYmktPmRtYSAgICAgICBdIGxlbmcgIG50dyB0aW1lc3RhbXAgICAgICAgIGJpLT5za2IgIgorCSAgICAgICAiPC0tIExlZ2FjeSBmb3JtYXRcbiIpOwogCXByaW50ayhLRVJOX0lORk8gIlRjW2Rlc2NdICAgICBbQ2UgQ29Dc0lwY2VDb1NdIFtNc3NIbFJTQ20wUGxlbl0iCi0JCSIgW2JpLT5kbWEgICAgICAgXSBsZW5nICBudHcgdGltZXN0YW1wICAgICAgICBiaS0+c2tiICIKLQkJIjwtLSBFeHQgQ29udGV4dCBmb3JtYXRcbiIpOworCSAgICAgICAiIFtiaS0+ZG1hICAgICAgIF0gbGVuZyAgbnR3IHRpbWVzdGFtcCAgICAgICAgYmktPnNrYiAiCisJICAgICAgICI8LS0gRXh0IENvbnRleHQgZm9ybWF0XG4iKTsKIAlwcmludGsoS0VSTl9JTkZPICJUZFtkZXNjXSAgICAgW2FkZHJlc3MgNjM6MCAgXSBbVmxhUG9SU0NtMURsZW5dIgotCQkiIFtiaS0+ZG1hICAgICAgIF0gbGVuZyAgbnR3IHRpbWVzdGFtcCAgICAgICAgYmktPnNrYiAiCi0JCSI8LS0gRXh0IERhdGEgZm9ybWF0XG4iKTsKKwkgICAgICAgIiBbYmktPmRtYSAgICAgICBdIGxlbmcgIG50dyB0aW1lc3RhbXAgICAgICAgIGJpLT5za2IgIgorCSAgICAgICAiPC0tIEV4dCBEYXRhIGZvcm1hdFxuIik7CiAJZm9yIChpID0gMDsgdHhfcmluZy0+ZGVzYyAmJiAoaSA8IHR4X3JpbmctPmNvdW50KTsgaSsrKSB7CiAJCXR4X2Rlc2MgPSBFMTAwMF9UWF9ERVNDKCp0eF9yaW5nLCBpKTsKIAkJYnVmZmVyX2luZm8gPSAmdHhfcmluZy0+YnVmZmVyX2luZm9baV07CiAJCXUwID0gKHN0cnVjdCBteV91MCAqKXR4X2Rlc2M7CiAJCXByaW50ayhLRVJOX0lORk8gIlQlY1sweCUwM1hdICAgICUwMTZsbFggJTAxNmxsWCAlMDE2bGxYICIKLQkJCSIlMDRYICAlM1ggJTAxNmxsWCAlcCIsCi0JCSAgICAgICAoIShsZTY0X3RvX2NwdSh1MC0+YikgJiAoMTw8MjkpKSA/ICdsJyA6Ci0JCQkoKGxlNjRfdG9fY3B1KHUwLT5iKSAmICgxPDwyMCkpID8gJ2QnIDogJ2MnKSksIGksCisJCSAgICAgICAiJTA0WCAgJTNYICUwMTZsbFggJXAiLAorCQkgICAgICAgKCEobGU2NF90b19jcHUodTAtPmIpICYgKDEgPDwgMjkpKSA/ICdsJyA6CisJCQkoKGxlNjRfdG9fY3B1KHUwLT5iKSAmICgxIDw8IDIwKSkgPyAnZCcgOiAnYycpKSwgaSwKIAkJICAgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpbGU2NF90b19jcHUodTAtPmEpLAogCQkgICAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylsZTY0X3RvX2NwdSh1MC0+YiksCiAJCSAgICAgICAodW5zaWduZWQgbG9uZyBsb25nKWJ1ZmZlcl9pbmZvLT5kbWEsCkBAIC0yOTYsMjIgKzMwMSwyMiBAQAogCiAJCWlmIChuZXRpZl9tc2dfcGt0ZGF0YShhZGFwdGVyKSAmJiBidWZmZXJfaW5mby0+ZG1hICE9IDApCiAJCQlwcmludF9oZXhfZHVtcChLRVJOX0lORk8sICIiLCBEVU1QX1BSRUZJWF9BRERSRVNTLAotCQkJCQkxNiwgMSwgcGh5c190b192aXJ0KGJ1ZmZlcl9pbmZvLT5kbWEpLAotCQkJCQlidWZmZXJfaW5mby0+bGVuZ3RoLCB0cnVlKTsKKwkJCQkgICAgICAgMTYsIDEsIHBoeXNfdG9fdmlydChidWZmZXJfaW5mby0+ZG1hKSwKKwkJCQkgICAgICAgYnVmZmVyX2luZm8tPmxlbmd0aCwgdHJ1ZSk7CiAJfQogCi0JLyogUHJpbnQgUlggUmluZ3MgU3VtbWFyeSAqLworCS8qIFByaW50IFJ4IFJpbmcgU3VtbWFyeSAqLwogcnhfcmluZ19zdW1tYXJ5OgotCWRldl9pbmZvKCZhZGFwdGVyLT5wZGV2LT5kZXYsICJSWCBSaW5ncyBTdW1tYXJ5XG4iKTsKKwlkZXZfaW5mbygmYWRhcHRlci0+cGRldi0+ZGV2LCAiUnggUmluZyBTdW1tYXJ5XG4iKTsKIAlwcmludGsoS0VSTl9JTkZPICJRdWV1ZSBbTlRVXSBbTlRDXVxuIik7CiAJcHJpbnRrKEtFUk5fSU5GTyAiICU1ZCAlNVggJTVYXG4iLCAwLAotCQlyeF9yaW5nLT5uZXh0X3RvX3VzZSwgcnhfcmluZy0+bmV4dF90b19jbGVhbik7CisJICAgICAgIHJ4X3JpbmctPm5leHRfdG9fdXNlLCByeF9yaW5nLT5uZXh0X3RvX2NsZWFuKTsKIAotCS8qIFByaW50IFJYIFJpbmdzICovCisJLyogUHJpbnQgUnggUmluZyAqLwogCWlmICghbmV0aWZfbXNnX3J4X3N0YXR1cyhhZGFwdGVyKSkKIAkJZ290byBleGl0OwogCi0JZGV2X2luZm8oJmFkYXB0ZXItPnBkZXYtPmRldiwgIlJYIFJpbmdzIER1bXBcbiIpOworCWRldl9pbmZvKCZhZGFwdGVyLT5wZGV2LT5kZXYsICJSeCBSaW5nIER1bXBcbiIpOwogCXN3aXRjaCAoYWRhcHRlci0+cnhfcHNfcGFnZXMpIHsKIAljYXNlIDE6CiAJY2FzZSAyOgpAQCAtMzI5LDcgKzMzNCw3IEBACiAJCSAqICAgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKIAkJICovCiAJCXByaW50ayhLRVJOX0lORk8gIlIgIFtkZXNjXSAgICAgIFtidWZmZXIgMCA2MzowIF0gIgotCQkJIltidWZmZXIgMSA2MzowIF0gIgorCQkgICAgICAgIltidWZmZXIgMSA2MzowIF0gIgogCQkgICAgICAgIltidWZmZXIgMiA2MzowIF0gW2J1ZmZlciAzIDYzOjAgXSBbYmktPmRtYSAgICAgICBdICIKIAkJICAgICAgICJbYmktPnNrYl0gPC0tIEV4dCBQa3QgU3BsaXQgZm9ybWF0XG4iKTsKIAkJLyogW0V4dGVuZGVkXSBSZWNlaXZlIERlc2NyaXB0b3IgKFdyaXRlLUJhY2spIEZvcm1hdApAQCAtMzQ0LDcgKzM0OSw3IEBACiAJCSAqICAgNjMgICAgICAgNDggNDcgICAgMzIgMzEgICAgICAgICAgICAyMCAxOSAgICAgICAgICAgICAgIDAKIAkJICovCiAJCXByaW50ayhLRVJOX0lORk8gIlJXQltkZXNjXSAgICAgIFtjayBpcGlkIG1ycWhzaF0gIgotCQkJIlt2bCAgIGwwIGVlICBlc10gIgorCQkgICAgICAgIlt2bCAgIGwwIGVlICBlc10gIgogCQkgICAgICAgIlsgbDMgIGwyICBsMSBoc10gW3Jlc2VydmVkICAgICAgXSAtLS0tLS0tLS0tLS0tLS0tICIKIAkJICAgICAgICJbYmktPnNrYl0gPC0tIEV4dCBSeCBXcml0ZS1CYWNrIGZvcm1hdFxuIik7CiAJCWZvciAoaSA9IDA7IGkgPCByeF9yaW5nLT5jb3VudDsgaSsrKSB7CkBAIC0zNTIsMjYgKzM1NywyNiBAQAogCQkJcnhfZGVzY19wcyA9IEUxMDAwX1JYX0RFU0NfUFMoKnJ4X3JpbmcsIGkpOwogCQkJdTEgPSAoc3RydWN0IG15X3UxICopcnhfZGVzY19wczsKIAkJCXN0YXRlcnIgPQotCQkJCWxlMzJfdG9fY3B1KHJ4X2Rlc2NfcHMtPndiLm1pZGRsZS5zdGF0dXNfZXJyb3IpOworCQkJICAgIGxlMzJfdG9fY3B1KHJ4X2Rlc2NfcHMtPndiLm1pZGRsZS5zdGF0dXNfZXJyb3IpOwogCQkJaWYgKHN0YXRlcnIgJiBFMTAwMF9SWERfU1RBVF9ERCkgewogCQkJCS8qIERlc2NyaXB0b3IgRG9uZSAqLwogCQkJCXByaW50ayhLRVJOX0lORk8gIlJXQlsweCUwM1hdICAgICAlMDE2bGxYICIKLQkJCQkJIiUwMTZsbFggJTAxNmxsWCAlMDE2bGxYICIKLQkJCQkJIi0tLS0tLS0tLS0tLS0tLS0gJXAiLCBpLAotCQkJCQkodW5zaWduZWQgbG9uZyBsb25nKWxlNjRfdG9fY3B1KHUxLT5hKSwKLQkJCQkJKHVuc2lnbmVkIGxvbmcgbG9uZylsZTY0X3RvX2NwdSh1MS0+YiksCi0JCQkJCSh1bnNpZ25lZCBsb25nIGxvbmcpbGU2NF90b19jcHUodTEtPmMpLAotCQkJCQkodW5zaWduZWQgbG9uZyBsb25nKWxlNjRfdG9fY3B1KHUxLT5kKSwKLQkJCQkJYnVmZmVyX2luZm8tPnNrYik7CisJCQkJICAgICAgICIlMDE2bGxYICUwMTZsbFggJTAxNmxsWCAiCisJCQkJICAgICAgICItLS0tLS0tLS0tLS0tLS0tICVwIiwgaSwKKwkJCQkgICAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylsZTY0X3RvX2NwdSh1MS0+YSksCisJCQkJICAgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpbGU2NF90b19jcHUodTEtPmIpLAorCQkJCSAgICAgICAodW5zaWduZWQgbG9uZyBsb25nKWxlNjRfdG9fY3B1KHUxLT5jKSwKKwkJCQkgICAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylsZTY0X3RvX2NwdSh1MS0+ZCksCisJCQkJICAgICAgIGJ1ZmZlcl9pbmZvLT5za2IpOwogCQkJfSBlbHNlIHsKIAkJCQlwcmludGsoS0VSTl9JTkZPICJSICBbMHglMDNYXSAgICAgJTAxNmxsWCAiCi0JCQkJCSIlMDE2bGxYICUwMTZsbFggJTAxNmxsWCAlMDE2bGxYICVwIiwgaSwKLQkJCQkJKHVuc2lnbmVkIGxvbmcgbG9uZylsZTY0X3RvX2NwdSh1MS0+YSksCi0JCQkJCSh1bnNpZ25lZCBsb25nIGxvbmcpbGU2NF90b19jcHUodTEtPmIpLAotCQkJCQkodW5zaWduZWQgbG9uZyBsb25nKWxlNjRfdG9fY3B1KHUxLT5jKSwKLQkJCQkJKHVuc2lnbmVkIGxvbmcgbG9uZylsZTY0X3RvX2NwdSh1MS0+ZCksCi0JCQkJCSh1bnNpZ25lZCBsb25nIGxvbmcpYnVmZmVyX2luZm8tPmRtYSwKLQkJCQkJYnVmZmVyX2luZm8tPnNrYik7CisJCQkJICAgICAgICIlMDE2bGxYICUwMTZsbFggJTAxNmxsWCAlMDE2bGxYICVwIiwgaSwKKwkJCQkgICAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylsZTY0X3RvX2NwdSh1MS0+YSksCisJCQkJICAgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpbGU2NF90b19jcHUodTEtPmIpLAorCQkJCSAgICAgICAodW5zaWduZWQgbG9uZyBsb25nKWxlNjRfdG9fY3B1KHUxLT5jKSwKKwkJCQkgICAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylsZTY0X3RvX2NwdSh1MS0+ZCksCisJCQkJICAgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpYnVmZmVyX2luZm8tPmRtYSwKKwkJCQkgICAgICAgYnVmZmVyX2luZm8tPnNrYik7CiAKIAkJCQlpZiAobmV0aWZfbXNnX3BrdGRhdGEoYWRhcHRlcikpCiAJCQkJCXByaW50X2hleF9kdW1wKEtFUk5fSU5GTywgIiIsCkBAIC00MDAsMTggKzQwNSwxOCBAQAogCQkgKiA2MyAgICAgICA0OCA0NyAgICA0MCAzOSAgICAgIDMyIDMxICAgICAgICAgMTYgMTUgICAgICAwCiAJCSAqLwogCQlwcmludGsoS0VSTl9JTkZPICJSbFtkZXNjXSAgICAgW2FkZHJlc3MgNjM6MCAgXSAiCi0JCQkiW3ZsIGVyIFMgY2tzIGxuXSBbYmktPmRtYSAgICAgICBdIFtiaS0+c2tiXSAiCi0JCQkiPC0tIExlZ2FjeSBmb3JtYXRcbiIpOworCQkgICAgICAgIlt2bCBlciBTIGNrcyBsbl0gW2JpLT5kbWEgICAgICAgXSBbYmktPnNrYl0gIgorCQkgICAgICAgIjwtLSBMZWdhY3kgZm9ybWF0XG4iKTsKIAkJZm9yIChpID0gMDsgcnhfcmluZy0+ZGVzYyAmJiAoaSA8IHJ4X3JpbmctPmNvdW50KTsgaSsrKSB7CiAJCQlyeF9kZXNjID0gRTEwMDBfUlhfREVTQygqcnhfcmluZywgaSk7CiAJCQlidWZmZXJfaW5mbyA9ICZyeF9yaW5nLT5idWZmZXJfaW5mb1tpXTsKIAkJCXUwID0gKHN0cnVjdCBteV91MCAqKXJ4X2Rlc2M7CiAJCQlwcmludGsoS0VSTl9JTkZPICJSbFsweCUwM1hdICAgICUwMTZsbFggJTAxNmxsWCAiCi0JCQkJIiUwMTZsbFggJXAiLCBpLAotCQkJCSh1bnNpZ25lZCBsb25nIGxvbmcpbGU2NF90b19jcHUodTAtPmEpLAotCQkJCSh1bnNpZ25lZCBsb25nIGxvbmcpbGU2NF90b19jcHUodTAtPmIpLAotCQkJCSh1bnNpZ25lZCBsb25nIGxvbmcpYnVmZmVyX2luZm8tPmRtYSwKLQkJCQlidWZmZXJfaW5mby0+c2tiKTsKKwkJCSAgICAgICAiJTAxNmxsWCAlcCIsIGksCisJCQkgICAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylsZTY0X3RvX2NwdSh1MC0+YSksCisJCQkgICAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylsZTY0X3RvX2NwdSh1MC0+YiksCisJCQkgICAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylidWZmZXJfaW5mby0+ZG1hLAorCQkJICAgICAgIGJ1ZmZlcl9pbmZvLT5za2IpOwogCQkJaWYgKGkgPT0gcnhfcmluZy0+bmV4dF90b191c2UpCiAJCQkJcHJpbnRrKEtFUk5fQ09OVCAiIE5UVVxuIik7CiAJCQllbHNlIGlmIChpID09IHJ4X3JpbmctPm5leHRfdG9fY2xlYW4pCkBAIC00MjEsOSArNDI2LDEwIEBACiAKIAkJCWlmIChuZXRpZl9tc2dfcGt0ZGF0YShhZGFwdGVyKSkKIAkJCQlwcmludF9oZXhfZHVtcChLRVJOX0lORk8sICIiLAotCQkJCQlEVU1QX1BSRUZJWF9BRERSRVNTLAotCQkJCQkxNiwgMSwgcGh5c190b192aXJ0KGJ1ZmZlcl9pbmZvLT5kbWEpLAotCQkJCQlhZGFwdGVyLT5yeF9idWZmZXJfbGVuLCB0cnVlKTsKKwkJCQkJICAgICAgIERVTVBfUFJFRklYX0FERFJFU1MsCisJCQkJCSAgICAgICAxNiwgMSwKKwkJCQkJICAgICAgIHBoeXNfdG9fdmlydChidWZmZXJfaW5mby0+ZG1hKSwKKwkJCQkJICAgICAgIGFkYXB0ZXItPnJ4X2J1ZmZlcl9sZW4sIHRydWUpOwogCQl9CiAJfQogCkBAIC00NTAsOCArNDU2LDcgQEAKICAqIEBza2I6IHBvaW50ZXIgdG8gc2tfYnVmZiB0byBiZSBpbmRpY2F0ZWQgdG8gc3RhY2sKICAqKi8KIHN0YXRpYyB2b2lkIGUxMDAwX3JlY2VpdmVfc2tiKHN0cnVjdCBlMTAwMF9hZGFwdGVyICphZGFwdGVyLAotCQkJICAgICAgc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwKLQkJCSAgICAgIHN0cnVjdCBza19idWZmICpza2IsCisJCQkgICAgICBzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2LCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAogCQkJICAgICAgdTggc3RhdHVzLCBfX2xlMTYgdmxhbikKIHsKIAlza2ItPnByb3RvY29sID0gZXRoX3R5cGVfdHJhbnMoc2tiLCBuZXRkZXYpOwpAQCAtNDY0LDcgKzQ2OSw3IEBACiB9CiAKIC8qKgotICogZTEwMDBfcnhfY2hlY2tzdW0gLSBSZWNlaXZlIENoZWNrc3VtIE9mZmxvYWQgZm9yIDgyNTQzCisgKiBlMTAwMF9yeF9jaGVja3N1bSAtIFJlY2VpdmUgQ2hlY2tzdW0gT2ZmbG9hZAogICogQGFkYXB0ZXI6ICAgICBib2FyZCBwcml2YXRlIHN0cnVjdHVyZQogICogQHN0YXR1c19lcnI6ICByZWNlaXZlIGRlc2NyaXB0b3Igc3RhdHVzIGFuZCBlcnJvciBmaWVsZHMKICAqIEBjc3VtOglyZWNlaXZlIGRlc2NyaXB0b3IgY3N1bSBmaWVsZApAQCAtNTQ4LDcgKzU1Myw3IEBACiAJCQkJCQkgIGFkYXB0ZXItPnJ4X2J1ZmZlcl9sZW4sCiAJCQkJCQkgIERNQV9GUk9NX0RFVklDRSk7CiAJCWlmIChkbWFfbWFwcGluZ19lcnJvcigmcGRldi0+ZGV2LCBidWZmZXJfaW5mby0+ZG1hKSkgewotCQkJZGV2X2VycigmcGRldi0+ZGV2LCAiUlggRE1BIG1hcCBmYWlsZWRcbiIpOworCQkJZGV2X2VycigmcGRldi0+ZGV2LCAiUnggRE1BIG1hcCBmYWlsZWRcbiIpOwogCQkJYWRhcHRlci0+cnhfZG1hX2ZhaWxlZCsrOwogCQkJYnJlYWs7CiAJCX0KQEAgLTYwMSw3ICs2MDYsOCBAQAogCQkJcHNfcGFnZSA9ICZidWZmZXJfaW5mby0+cHNfcGFnZXNbal07CiAJCQlpZiAoaiA+PSBhZGFwdGVyLT5yeF9wc19wYWdlcykgewogCQkJCS8qIGFsbCB1bnVzZWQgZGVzYyBlbnRyaWVzIGdldCBodyBudWxsIHB0ciAqLwotCQkJCXJ4X2Rlc2MtPnJlYWQuYnVmZmVyX2FkZHJbaisxXSA9IH5jcHVfdG9fbGU2NCgwKTsKKwkJCQlyeF9kZXNjLT5yZWFkLmJ1ZmZlcl9hZGRyW2ogKyAxXSA9CisJCQkJICAgIH5jcHVfdG9fbGU2NCgwKTsKIAkJCQljb250aW51ZTsKIAkJCX0KIAkJCWlmICghcHNfcGFnZS0+cGFnZSkgewpAQCAtNjE3LDcgKzYyMyw3IEBACiAJCQkJaWYgKGRtYV9tYXBwaW5nX2Vycm9yKCZwZGV2LT5kZXYsCiAJCQkJCQkgICAgICBwc19wYWdlLT5kbWEpKSB7CiAJCQkJCWRldl9lcnIoJmFkYXB0ZXItPnBkZXYtPmRldiwKLQkJCQkJICAiUlggRE1BIHBhZ2UgbWFwIGZhaWxlZFxuIik7CisJCQkJCQkiUnggRE1BIHBhZ2UgbWFwIGZhaWxlZFxuIik7CiAJCQkJCWFkYXB0ZXItPnJ4X2RtYV9mYWlsZWQrKzsKIAkJCQkJZ290byBub19idWZmZXJzOwogCQkJCX0KQEAgLTYyNyw4ICs2MzMsOCBAQAogCQkJICogZGlkbid0IGNoYW5nZSBiZWNhdXNlIGVhY2ggd3JpdGUtYmFjawogCQkJICogZXJhc2VzIHRoaXMgaW5mby4KIAkJCSAqLwotCQkJcnhfZGVzYy0+cmVhZC5idWZmZXJfYWRkcltqKzFdID0KLQkJCSAgICAgY3B1X3RvX2xlNjQocHNfcGFnZS0+ZG1hKTsKKwkJCXJ4X2Rlc2MtPnJlYWQuYnVmZmVyX2FkZHJbaiArIDFdID0KKwkJCSAgICBjcHVfdG9fbGU2NChwc19wYWdlLT5kbWEpOwogCQl9CiAKIAkJc2tiID0gbmV0ZGV2X2FsbG9jX3NrYl9pcF9hbGlnbihuZXRkZXYsCkBAIC02NDQsNyArNjUwLDcgQEAKIAkJCQkJCSAgYWRhcHRlci0+cnhfcHNfYnNpemUwLAogCQkJCQkJICBETUFfRlJPTV9ERVZJQ0UpOwogCQlpZiAoZG1hX21hcHBpbmdfZXJyb3IoJnBkZXYtPmRldiwgYnVmZmVyX2luZm8tPmRtYSkpIHsKLQkJCWRldl9lcnIoJnBkZXYtPmRldiwgIlJYIERNQSBtYXAgZmFpbGVkXG4iKTsKKwkJCWRldl9lcnIoJnBkZXYtPmRldiwgIlJ4IERNQSBtYXAgZmFpbGVkXG4iKTsKIAkJCWFkYXB0ZXItPnJ4X2RtYV9mYWlsZWQrKzsKIAkJCS8qIGNsZWFudXAgc2tiICovCiAJCQlkZXZfa2ZyZWVfc2tiX2FueShza2IpOwpAQCAtNjYyLDcgKzY2OCw3IEBACiAJCQkgKiBzdWNoIGFzIElBLTY0KS4KIAkJCSAqLwogCQkJd21iKCk7Ci0JCQl3cml0ZWwoaTw8MSwgYWRhcHRlci0+aHcuaHdfYWRkciArIHJ4X3JpbmctPnRhaWwpOworCQkJd3JpdGVsKGkgPDwgMSwgYWRhcHRlci0+aHcuaHdfYWRkciArIHJ4X3JpbmctPnRhaWwpOwogCQl9CiAKIAkJaSsrOwpAQCAtMTEwNiwxMSArMTExMiwxMCBAQAogCQljbGVhbmVkID0gMTsKIAkJY2xlYW5lZF9jb3VudCsrOwogCQlkbWFfdW5tYXBfc2luZ2xlKCZwZGV2LT5kZXYsIGJ1ZmZlcl9pbmZvLT5kbWEsCi0JCQkJIGFkYXB0ZXItPnJ4X3BzX2JzaXplMCwKLQkJCQkgRE1BX0ZST01fREVWSUNFKTsKKwkJCQkgYWRhcHRlci0+cnhfcHNfYnNpemUwLCBETUFfRlJPTV9ERVZJQ0UpOwogCQlidWZmZXJfaW5mby0+ZG1hID0gMDsKIAotCQkvKiBzZWUgIUVPUCBjb21tZW50IGluIG90aGVyIHJ4IHJvdXRpbmUgKi8KKwkJLyogc2VlICFFT1AgY29tbWVudCBpbiBvdGhlciBSeCByb3V0aW5lICovCiAJCWlmICghKHN0YXRlcnIgJiBFMTAwMF9SWERfU1RBVF9FT1ApKQogCQkJYWRhcHRlci0+ZmxhZ3MyIHw9IEZMQUcyX0lTX0RJU0NBUkRJTkc7CiAKQEAgLTI2MTAsNyArMjYxNSw3IEBACiB9CiAKIC8qKgotICogZTEwMDBfY29uZmlndXJlX3R4IC0gQ29uZmlndXJlIDgyNTR4IFRyYW5zbWl0IFVuaXQgYWZ0ZXIgUmVzZXQKKyAqIGUxMDAwX2NvbmZpZ3VyZV90eCAtIENvbmZpZ3VyZSBUcmFuc21pdCBVbml0IGFmdGVyIFJlc2V0CiAgKiBAYWRhcHRlcjogYm9hcmQgcHJpdmF0ZSBzdHJ1Y3R1cmUKICAqCiAgKiBDb25maWd1cmUgdGhlIFR4IHVuaXQgb2YgdGhlIE1BQyBhZnRlciBhIHJlc2V0LgpAQCAtMjY2Myw3ICsyNjY4LDcgQEAKIAkJICogaHRocmVzaCA9IDEgPT0+IHByZWZldGNoIHdoZW4gb25lIG9yIG1vcmUgYXZhaWxhYmxlCiAJCSAqIHB0aHJlc2ggPSAweDFmID09PiBwcmVmZXRjaCBpZiBpbnRlcm5hbCBjYWNoZSAzMSBvciBsZXNzCiAJCSAqIEJFV0FSRTogdGhpcyBzZWVtcyB0byB3b3JrIGJ1dCBzaG91bGQgYmUgY29uc2lkZXJlZCBmaXJzdCBpZgotCQkgKiB0aGVyZSBhcmUgdHggaGFuZ3Mgb3Igb3RoZXIgdHggcmVsYXRlZCBidWdzCisJCSAqIHRoZXJlIGFyZSBUeCBoYW5ncyBvciBvdGhlciBUeCByZWxhdGVkIGJ1Z3MKIAkJICovCiAJCXR4ZGN0bCB8PSBFMTAwMF9UWERDVExfRE1BX0JVUlNUX0VOQUJMRTsKIAkJZXczMihUWERDVEwoMCksIHR4ZGN0bCk7CkBAIC0yODc3LDcgKzI4ODIsNyBAQAogCWlmIChhZGFwdGVyLT5yeF9wc19wYWdlcykgewogCQkvKiB0aGlzIGlzIGEgMzIgYnl0ZSBkZXNjcmlwdG9yICovCiAJCXJkbGVuID0gcnhfcmluZy0+Y291bnQgKgotCQkJc2l6ZW9mKHVuaW9uIGUxMDAwX3J4X2Rlc2NfcGFja2V0X3NwbGl0KTsKKwkJICAgIHNpemVvZih1bmlvbiBlMTAwMF9yeF9kZXNjX3BhY2tldF9zcGxpdCk7CiAJCWFkYXB0ZXItPmNsZWFuX3J4ID0gZTEwMDBfY2xlYW5fcnhfaXJxX3BzOwogCQlhZGFwdGVyLT5hbGxvY19yeF9idWYgPSBlMTAwMF9hbGxvY19yeF9idWZmZXJzX3BzOwogCX0gZWxzZSBpZiAoYWRhcHRlci0+bmV0ZGV2LT5tdHUgPiBFVEhfRlJBTUVfTEVOICsgRVRIX0ZDU19MRU4pIHsKQEAgLTI5MDAsNyArMjkwNSw3IEBACiAJCS8qCiAJCSAqIHNldCB0aGUgd3JpdGViYWNrIHRocmVzaG9sZCAob25seSB0YWtlcyBlZmZlY3QgaWYgdGhlIFJEVFIKIAkJICogaXMgc2V0KS4gc2V0IEdSQU49MSBhbmQgd3JpdGUgYmFjayB1cCB0byAweDQgd29ydGgsIGFuZAotCQkgKiBlbmFibGUgcHJlZmV0Y2hpbmcgb2YgMHgyMCByeCBkZXNjcmlwdG9ycworCQkgKiBlbmFibGUgcHJlZmV0Y2hpbmcgb2YgMHgyMCBSeCBkZXNjcmlwdG9ycwogCQkgKiBncmFudWxhcml0eSA9IDAxCiAJCSAqIHd0aHJlc2ggPSAwNCwKIAkJICogaHRocmVzaCA9IDA0LApAQCAtMjk4MSwxMiArMjk4NiwxMCBAQAogCQkJICogZXhjZXNzaXZlIEMtc3RhdGUgdHJhbnNpdGlvbiBsYXRlbmNpZXMgcmVzdWx0IGluCiAJCQkgKiBkcm9wcGVkIHRyYW5zYWN0aW9ucy4KIAkJCSAqLwotCQkJcG1fcW9zX3VwZGF0ZV9yZXF1ZXN0KAotCQkJCSZhZGFwdGVyLT5uZXRkZXYtPnBtX3Fvc19yZXEsIDU1KTsKKwkJCXBtX3Fvc191cGRhdGVfcmVxdWVzdCgmYWRhcHRlci0+bmV0ZGV2LT5wbV9xb3NfcmVxLCA1NSk7CiAJCX0gZWxzZSB7Ci0JCQlwbV9xb3NfdXBkYXRlX3JlcXVlc3QoCi0JCQkJJmFkYXB0ZXItPm5ldGRldi0+cG1fcW9zX3JlcSwKLQkJCQlQTV9RT1NfREVGQVVMVF9WQUxVRSk7CisJCQlwbV9xb3NfdXBkYXRlX3JlcXVlc3QoJmFkYXB0ZXItPm5ldGRldi0+cG1fcW9zX3JlcSwKKwkJCQkJICAgICAgUE1fUU9TX0RFRkFVTFRfVkFMVUUpOwogCQl9CiAJfQogCkBAIC0zMTUyLDcgKzMxNTUsNyBAQAogCQkvKiBsb3dlciAxNiBiaXRzIGhhcyBSeCBwYWNrZXQgYnVmZmVyIGFsbG9jYXRpb24gc2l6ZSBpbiBLQiAqLwogCQlwYmEgJj0gMHhmZmZmOwogCQkvKgotCQkgKiB0aGUgVHggZmlmbyBhbHNvIHN0b3JlcyAxNiBieXRlcyBvZiBpbmZvcm1hdGlvbiBhYm91dCB0aGUgdHgKKwkJICogdGhlIFR4IGZpZm8gYWxzbyBzdG9yZXMgMTYgYnl0ZXMgb2YgaW5mb3JtYXRpb24gYWJvdXQgdGhlIFR4CiAJCSAqIGJ1dCBkb24ndCBpbmNsdWRlIGV0aGVybmV0IEZDUyBiZWNhdXNlIGhhcmR3YXJlIGFwcGVuZHMgaXQKIAkJICovCiAJCW1pbl90eF9zcGFjZSA9IChhZGFwdGVyLT5tYXhfZnJhbWVfc2l6ZSArCkBAIC0zMTc1LDcgKzMxNzgsNyBAQAogCQkJcGJhIC09IG1pbl90eF9zcGFjZSAtIHR4X3NwYWNlOwogCiAJCQkvKgotCQkJICogaWYgc2hvcnQgb24gUnggc3BhY2UsIFJ4IHdpbnMgYW5kIG11c3QgdHJ1bXAgdHgKKwkJCSAqIGlmIHNob3J0IG9uIFJ4IHNwYWNlLCBSeCB3aW5zIGFuZCBtdXN0IHRydW1wIFR4CiAJCQkgKiBhZGp1c3RtZW50IG9yIHVzZSBFYXJseSBSZWNlaXZlIGlmIGF2YWlsYWJsZQogCQkJICovCiAJCQlpZiAoKHBiYSA8IG1pbl9yeF9zcGFjZSkgJiYKQEAgLTQwMzksMTEgKzQwNDIsMTEgQEAKIAkgICAgICAgYWRhcHRlci0+bmV0ZGV2LT5uYW1lLAogCSAgICAgICBhZGFwdGVyLT5saW5rX3NwZWVkLAogCSAgICAgICAoYWRhcHRlci0+bGlua19kdXBsZXggPT0gRlVMTF9EVVBMRVgpID8KLQkgICAgICAgICAgICAgICAgICAgICAgICAiRnVsbCBEdXBsZXgiIDogIkhhbGYgRHVwbGV4IiwKKwkgICAgICAgIkZ1bGwgRHVwbGV4IiA6ICJIYWxmIER1cGxleCIsCiAJICAgICAgICgoY3RybCAmIEUxMDAwX0NUUkxfVEZDRSkgJiYgKGN0cmwgJiBFMTAwMF9DVFJMX1JGQ0UpKSA/Ci0JICAgICAgICAgICAgICAgICAgICAgICAgIlJYL1RYIiA6Ci0JICAgICAgICgoY3RybCAmIEUxMDAwX0NUUkxfUkZDRSkgPyAiUlgiIDoKLQkgICAgICAgKChjdHJsICYgRTEwMDBfQ1RSTF9URkNFKSA/ICJUWCIgOiAiTm9uZSIgKSkpOworCSAgICAgICAiUngvVHgiIDoKKwkgICAgICAgKChjdHJsICYgRTEwMDBfQ1RSTF9SRkNFKSA/ICJSeCIgOgorCQkoKGN0cmwgJiBFMTAwMF9DVFJMX1RGQ0UpID8gIlR4IiA6ICJOb25lIikpKTsKIH0KIAogc3RhdGljIGJvb2wgZTEwMDBlX2hhc19saW5rKHN0cnVjdCBlMTAwMF9hZGFwdGVyICphZGFwdGVyKQpAQCAtNDMwNiw3ICs0MzA5LDYgQEAKIAkJCSAqIHRvIGdldCBkb25lLCBzbyByZXNldCBjb250cm9sbGVyIHRvIGZsdXNoIFR4LgogCQkJICogKERvIHRoZSByZXNldCBvdXRzaWRlIG9mIGludGVycnVwdCBjb250ZXh0KS4KIAkJCSAqLwotCQkJYWRhcHRlci0+dHhfdGltZW91dF9jb3VudCsrOwogCQkJc2NoZWR1bGVfd29yaygmYWRhcHRlci0+cmVzZXRfdGFzayk7CiAJCQkvKiByZXR1cm4gaW1tZWRpYXRlbHkgc2luY2UgcmVzZXQgaXMgaW1taW5lbnQgKi8KIAkJCXJldHVybjsKQEAgLTQzMzgsNyArNDM0MCw3IEBACiAJLyogRm9yY2UgZGV0ZWN0aW9uIG9mIGh1bmcgY29udHJvbGxlciBldmVyeSB3YXRjaGRvZyBwZXJpb2QgKi8KIAlhZGFwdGVyLT5kZXRlY3RfdHhfaHVuZyA9IDE7CiAKLQkvKiBmbHVzaCBwYXJ0aWFsIGRlc2NyaXB0b3JzIHRvIG1lbW9yeSBiZWZvcmUgZGV0ZWN0aW5nIHR4IGhhbmcgKi8KKwkvKiBmbHVzaCBwYXJ0aWFsIGRlc2NyaXB0b3JzIHRvIG1lbW9yeSBiZWZvcmUgZGV0ZWN0aW5nIFR4IGhhbmcgKi8KIAlpZiAoYWRhcHRlci0+ZmxhZ3MyICYgRkxBRzJfRE1BX0JVUlNUKSB7CiAJCWV3MzIoVElEViwgYWRhcHRlci0+dHhfaW50X2RlbGF5IHwgRTEwMDBfVElEVl9GUEQpOwogCQlldzMyKFJEVFIsIGFkYXB0ZXItPnJ4X2ludF9kZWxheSB8IEUxMDAwX1JEVFJfRlBEKTsKQEAgLTQ1MjksNyArNDUzMSw3IEBACiAJCWJ1ZmZlcl9pbmZvLT5uZXh0X3RvX3dhdGNoID0gaTsKIAkJYnVmZmVyX2luZm8tPmRtYSA9IGRtYV9tYXBfc2luZ2xlKCZwZGV2LT5kZXYsCiAJCQkJCQkgIHNrYi0+ZGF0YSArIG9mZnNldCwKLQkJCQkJCSAgc2l6ZSwJRE1BX1RPX0RFVklDRSk7CisJCQkJCQkgIHNpemUsIERNQV9UT19ERVZJQ0UpOwogCQlidWZmZXJfaW5mby0+bWFwcGVkX2FzX3BhZ2UgPSBmYWxzZTsKIAkJaWYgKGRtYV9tYXBwaW5nX2Vycm9yKCZwZGV2LT5kZXYsIGJ1ZmZlcl9pbmZvLT5kbWEpKQogCQkJZ290byBkbWFfZXJyb3I7CkBAIC00NTc2LDcgKzQ1NzgsNyBAQAogCQl9CiAJfQogCi0Jc2VncyA9IHNrYl9zaGluZm8oc2tiKS0+Z3NvX3NlZ3MgPzogMTsKKwlzZWdzID0gc2tiX3NoaW5mbyhza2IpLT5nc29fc2VncyA/IDogMTsKIAkvKiBtdWx0aXBseSBkYXRhIGNodW5rcyBieSBzaXplIG9mIGhlYWRlcnMgKi8KIAlieXRlY291bnQgPSAoKHNlZ3MgLSAxKSAqIHNrYl9oZWFkbGVuKHNrYikpICsgc2tiLT5sZW47CiAKQEAgLTQ1ODgsMTMgKzQ1OTAsMTMgQEAKIAlyZXR1cm4gY291bnQ7CiAKIGRtYV9lcnJvcjoKLQlkZXZfZXJyKCZwZGV2LT5kZXYsICJUWCBETUEgbWFwIGZhaWxlZFxuIik7CisJZGV2X2VycigmcGRldi0+ZGV2LCAiVHggRE1BIG1hcCBmYWlsZWRcbiIpOwogCWJ1ZmZlcl9pbmZvLT5kbWEgPSAwOwogCWlmIChjb3VudCkKIAkJY291bnQtLTsKIAogCXdoaWxlIChjb3VudC0tKSB7Ci0JCWlmIChpPT0wKQorCQlpZiAoaSA9PSAwKQogCQkJaSArPSB0eF9yaW5nLT5jb3VudDsKIAkJaS0tOwogCQlidWZmZXJfaW5mbyA9ICZ0eF9yaW5nLT5idWZmZXJfaW5mb1tpXTsKQEAgLTYxOTMsNyArNjE5NSw3IEBACiAJaW50IHJldDsKIAlwcl9pbmZvKCJJbnRlbChSKSBQUk8vMTAwMCBOZXR3b3JrIERyaXZlciAtICVzXG4iLAogCQllMTAwMGVfZHJpdmVyX3ZlcnNpb24pOwotCXByX2luZm8oIkNvcHlyaWdodCAoYykgMTk5OSAtIDIwMTAgSW50ZWwgQ29ycG9yYXRpb24uXG4iKTsKKwlwcl9pbmZvKCJDb3B5cmlnaHQoYykgMTk5OSAtIDIwMTEgSW50ZWwgQ29ycG9yYXRpb24uXG4iKTsKIAlyZXQgPSBwY2lfcmVnaXN0ZXJfZHJpdmVyKCZlMTAwMF9kcml2ZXIpOwogCiAJcmV0dXJuIHJldDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2UxMDAwZS9wYXJhbS5jIGIvZHJpdmVycy9uZXQvZTEwMDBlL3BhcmFtLmMKaW5kZXggYTk2MTJiMC4uNGRkOWI2MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZTEwMDBlL3BhcmFtLmMKKysrIGIvZHJpdmVycy9uZXQvZTEwMDBlL3BhcmFtLmMKQEAgLTEsNyArMSw3IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogCiAgIEludGVsIFBSTy8xMDAwIExpbnV4IGRyaXZlcgotICBDb3B5cmlnaHQoYykgMTk5OSAtIDIwMTAgSW50ZWwgQ29ycG9yYXRpb24uCisgIENvcHlyaWdodChjKSAxOTk5IC0gMjAxMSBJbnRlbCBDb3Jwb3JhdGlvbi4KIAogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAogICB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlLApAQCAtNjIsMTAgKzYyLDkgQEAKIAltb2R1bGVfcGFyYW1fYXJyYXlfbmFtZWQoWCwgWCwgaW50LCAmbnVtXyMjWCwgMCk7CVwKIAlNT0RVTEVfUEFSTV9ERVNDKFgsIGRlc2MpOwogCi0KIC8qCiAgKiBUcmFuc21pdCBJbnRlcnJ1cHQgRGVsYXkgaW4gdW5pdHMgb2YgMS4wMjQgbWljcm9zZWNvbmRzCi0gKiBUeCBpbnRlcnJ1cHQgZGVsYXkgbmVlZHMgdG8gdHlwaWNhbGx5IGJlIHNldCB0byBzb21ldGhpbmcgbm9uIHplcm8KKyAqIFR4IGludGVycnVwdCBkZWxheSBuZWVkcyB0byB0eXBpY2FsbHkgYmUgc2V0IHRvIHNvbWV0aGluZyBub24temVybwogICoKICAqIFZhbGlkIFJhbmdlOiAwLTY1NTM1CiAgKi8KQEAgLTExMiw2ICsxMTEsNyBAQAogI2RlZmluZSBERUZBVUxUX0lUUiAzCiAjZGVmaW5lIE1BWF9JVFIgMTAwMDAwCiAjZGVmaW5lIE1JTl9JVFIgMTAwCisKIC8qIEludE1vZGUgKEludGVycnVwdCBNb2RlKQogICoKICAqIFZhbGlkIFJhbmdlOiAwIC0gMgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZTEwMDBlL3BoeS5jIGIvZHJpdmVycy9uZXQvZTEwMDBlL3BoeS5jCmluZGV4IDAwZjg5ZTguLjZiZWEwNTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2UxMDAwZS9waHkuYworKysgYi9kcml2ZXJzL25ldC9lMTAwMGUvcGh5LmMKQEAgLTEsNyArMSw3IEBACiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogCiAgIEludGVsIFBSTy8xMDAwIExpbnV4IGRyaXZlcgotICBDb3B5cmlnaHQoYykgMTk5OSAtIDIwMTAgSW50ZWwgQ29ycG9yYXRpb24uCisgIENvcHlyaWdodChjKSAxOTk5IC0gMjAxMSBJbnRlbCBDb3Jwb3JhdGlvbi4KIAogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAogICB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlLApAQCAtNjQwLDcgKzY0MCw3IEBACiAJczMyIHJldF92YWw7CiAJdTE2IHBoeV9kYXRhOwogCi0JLyogRW5hYmxlIENSUyBvbiBUWC4gVGhpcyBtdXN0IGJlIHNldCBmb3IgaGFsZi1kdXBsZXggb3BlcmF0aW9uLiAqLworCS8qIEVuYWJsZSBDUlMgb24gVHguIFRoaXMgbXVzdCBiZSBzZXQgZm9yIGhhbGYtZHVwbGV4IG9wZXJhdGlvbi4gKi8KIAlyZXRfdmFsID0gZTFlX3JwaHkoaHcsIEk4MjU3N19DRkdfUkVHLCAmcGh5X2RhdGEpOwogCWlmIChyZXRfdmFsKQogCQlnb3RvIG91dDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2VuYzI4ajYwLmMgYi9kcml2ZXJzL25ldC9lbmMyOGo2MC5jCmluZGV4IDExMmM1YWEuLjkwN2IwNWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2VuYzI4ajYwLmMKKysrIGIvZHJpdmVycy9uZXQvZW5jMjhqNjAuYwpAQCAtODEyLDcgKzgxMiw3IEBACiAJaWYgKG5ldGlmX21zZ19odyhwcml2KSkKIAkJcHJpbnRrKEtFUk5fREVCVUcgRFJWX05BTUUgIjogcmVhZGluZyBUU1YgYXQgYWRkcjoweCUwNHhcbiIsCiAJCQkgZW5kcHRyICsgMSk7Ci0JZW5jMjhqNjBfbWVtX3JlYWQocHJpdiwgZW5kcHRyICsgMSwgc2l6ZW9mKHRzdiksIHRzdik7CisJZW5jMjhqNjBfbWVtX3JlYWQocHJpdiwgZW5kcHRyICsgMSwgVFNWX1NJWkUsIHRzdik7CiB9CiAKIHN0YXRpYyB2b2lkIGVuYzI4ajYwX2R1bXBfdHN2KHN0cnVjdCBlbmMyOGo2MF9uZXQgKnByaXYsIGNvbnN0IGNoYXIgKm1zZywKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2dpYW5mYXIuYyBiL2RyaXZlcnMvbmV0L2dpYW5mYXIuYwppbmRleCA2ZGU0Njc1Li41ZWQ4ZjlmOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZ2lhbmZhci5jCisrKyBiL2RyaXZlcnMvbmV0L2dpYW5mYXIuYwpAQCAtNDM0LDcgKzQzNCw2IEBACiBzdGF0aWMgc3RydWN0IG5ldF9kZXZpY2Vfc3RhdHMgKmdmYXJfZ2V0X3N0YXRzKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0IGdmYXJfcHJpdmF0ZSAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7Ci0Jc3RydWN0IG5ldGRldl9xdWV1ZSAqdHhxOwogCXVuc2lnbmVkIGxvbmcgcnhfcGFja2V0cyA9IDAsIHJ4X2J5dGVzID0gMCwgcnhfZHJvcHBlZCA9IDA7CiAJdW5zaWduZWQgbG9uZyB0eF9wYWNrZXRzID0gMCwgdHhfYnl0ZXMgPSAwOwogCWludCBpID0gMDsKQEAgLTQ1MCw5ICs0NDksOCBAQAogCWRldi0+c3RhdHMucnhfZHJvcHBlZCA9IHJ4X2Ryb3BwZWQ7CiAKIAlmb3IgKGkgPSAwOyBpIDwgcHJpdi0+bnVtX3R4X3F1ZXVlczsgaSsrKSB7Ci0JCXR4cSA9IG5ldGRldl9nZXRfdHhfcXVldWUoZGV2LCBpKTsKLQkJdHhfYnl0ZXMgKz0gdHhxLT50eF9ieXRlczsKLQkJdHhfcGFja2V0cyArPSB0eHEtPnR4X3BhY2tldHM7CisJCXR4X2J5dGVzICs9IHByaXYtPnR4X3F1ZXVlW2ldLT5zdGF0cy50eF9ieXRlczsKKwkJdHhfcGFja2V0cyArPSBwcml2LT50eF9xdWV1ZVtpXS0+c3RhdHMudHhfcGFja2V0czsKIAl9CiAKIAlkZXYtPnN0YXRzLnR4X2J5dGVzID0gdHhfYnl0ZXM7CkBAIC0xOTIyLDcgKzE5MjAsNyBAQAogCQlpZiAoZXJyKSB7CiAJCQlmb3IgKGogPSAwOyBqIDwgaTsgaisrKQogCQkJCWZyZWVfZ3JwX2lycXMoJnByaXYtPmdmYXJncnBbal0pOwotCQkJCWdvdG8gaXJxX2ZhaWw7CisJCQlnb3RvIGlycV9mYWlsOwogCQl9CiAJfQogCkBAIC0yMTA5LDggKzIxMDcsOCBAQAogCX0KIAogCS8qIFVwZGF0ZSB0cmFuc21pdCBzdGF0cyAqLwotCXR4cS0+dHhfYnl0ZXMgKz0gc2tiLT5sZW47Ci0JdHhxLT50eF9wYWNrZXRzICsrOworCXR4X3F1ZXVlLT5zdGF0cy50eF9ieXRlcyArPSBza2ItPmxlbjsKKwl0eF9xdWV1ZS0+c3RhdHMudHhfcGFja2V0cysrOwogCiAJdHhiZHAgPSB0eGJkcF9zdGFydCA9IHR4X3F1ZXVlLT5jdXJfdHg7CiAJbHN0YXR1cyA9IHR4YmRwLT5sc3RhdHVzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZ2lhbmZhci5oIGIvZHJpdmVycy9uZXQvZ2lhbmZhci5oCmluZGV4IDY4OTg0ZWIuLjU0ZGU0MTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2dpYW5mYXIuaAorKysgYi9kcml2ZXJzL25ldC9naWFuZmFyLmgKQEAgLTkwNywxMiArOTA3LDIxIEBACiAJTVFfTUdfTU9ERQogfTsKIAorLyoKKyAqIFBlciBUWCBxdWV1ZSBzdGF0cworICovCitzdHJ1Y3QgdHhfcV9zdGF0cyB7CisJdW5zaWduZWQgbG9uZyB0eF9wYWNrZXRzOworCXVuc2lnbmVkIGxvbmcgdHhfYnl0ZXM7Cit9OworCiAvKioKICAqCXN0cnVjdCBnZmFyX3ByaXZfdHhfcSAtIHBlciB0eCBxdWV1ZSBzdHJ1Y3R1cmUKICAqCUB0eGxvY2s6IHBlciBxdWV1ZSB0eCBzcGluIGxvY2sKICAqCUB0eF9za2J1ZmY6c2tiIHBvaW50ZXJzCiAgKglAc2tiX2N1cnR4OiB0byBiZSB1c2VkIHNrYiBwb2ludGVyCiAgKglAc2tiX2RpcnR5dHg6dGhlIGxhc3QgdXNlZCBza2IgcG9pbnRlcgorICoJQHN0YXRzOiBieXRlcy9wYWNrZXRzIHN0YXRzCiAgKglAcWluZGV4OiBpbmRleCBvZiB0aGlzIHF1ZXVlCiAgKglAZGV2OiBiYWNrIHBvaW50ZXIgdG8gdGhlIGRldiBzdHJ1Y3R1cmUKICAqCUBncnA6IGJhY2sgcG9pbnRlciB0byB0aGUgZ3JvdXAgdG8gd2hpY2ggdGhpcyBxdWV1ZSBiZWxvbmdzCkBAIC05MzQsNiArOTQzLDcgQEAKIAlzdHJ1Y3QJdHhiZDggKnR4X2JkX2Jhc2U7CiAJc3RydWN0CXR4YmQ4ICpjdXJfdHg7CiAJc3RydWN0CXR4YmQ4ICpkaXJ0eV90eDsKKwlzdHJ1Y3QgdHhfcV9zdGF0cyBzdGF0czsKIAlzdHJ1Y3QJbmV0X2RldmljZSAqZGV2OwogCXN0cnVjdCBnZmFyX3ByaXZfZ3JwICpncnA7CiAJdTE2CXNrYl9jdXJ0eDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2dyZXRoLmMgYi9kcml2ZXJzL25ldC9ncmV0aC5jCmluZGV4IDI3ZDY5NjAuLmZkYjAzMzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2dyZXRoLmMKKysrIGIvZHJpdmVycy9uZXQvZ3JldGguYwpAQCAtMSw3ICsxLDcgQEAKIC8qCiAgKiBBZXJvZmxleCBHYWlzbGVyIEdSRVRIIDEwLzEwMC8xRyBFdGhlcm5ldCBNQUMuCiAgKgotICogMjAwNS0yMDA5IChjKSBBZXJvZmxleCBHYWlzbGVyIEFCCisgKiAyMDA1LTIwMTAgKGMpIEFlcm9mbGV4IEdhaXNsZXIgQUIKICAqCiAgKiBUaGlzIGRyaXZlciBzdXBwb3J0cyBHUkVUSCAxMC8xMDAgYW5kIEdSRVRIIDEwLzEwMC8xRyBFdGhlcm5ldCBNQUNzCiAgKiBhdmFpbGFibGUgaW4gdGhlIEdSTElCIFZIREwgSVAgY29yZSBsaWJyYXJ5LgpAQCAtMzU2LDYgKzM1Niw4IEBACiAJCWRldl9kYmcoJmRldi0+ZGV2LCAiIHN0YXJ0aW5nIHF1ZXVlXG4iKTsKIAluZXRpZl9zdGFydF9xdWV1ZShkZXYpOwogCisJR1JFVEhfUkVHU0FWRShncmV0aC0+cmVncy0+c3RhdHVzLCAweEZGKTsKKwogCW5hcGlfZW5hYmxlKCZncmV0aC0+bmFwaSk7CiAKIAlncmV0aF9lbmFibGVfaXJxcyhncmV0aCk7CkBAIC0zNzEsNyArMzczLDkgQEAKIAogCW5hcGlfZGlzYWJsZSgmZ3JldGgtPm5hcGkpOwogCisJZ3JldGhfZGlzYWJsZV9pcnFzKGdyZXRoKTsKIAlncmV0aF9kaXNhYmxlX3R4KGdyZXRoKTsKKwlncmV0aF9kaXNhYmxlX3J4KGdyZXRoKTsKIAogCW5ldGlmX3N0b3BfcXVldWUoZGV2KTsKIApAQCAtMzg4LDEyICszOTIsMjAgQEAKIAlzdHJ1Y3QgZ3JldGhfcHJpdmF0ZSAqZ3JldGggPSBuZXRkZXZfcHJpdihkZXYpOwogCXN0cnVjdCBncmV0aF9iZCAqYmRwOwogCWludCBlcnIgPSBORVRERVZfVFhfT0s7Ci0JdTMyIHN0YXR1cywgZG1hX2FkZHI7CisJdTMyIHN0YXR1cywgZG1hX2FkZHIsIGN0cmw7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCWJkcCA9IGdyZXRoLT50eF9iZF9iYXNlICsgZ3JldGgtPnR4X25leHQ7CisJLyogQ2xlYW4gVFggUmluZyAqLworCWdyZXRoX2NsZWFuX3R4KGdyZXRoLT5uZXRkZXYpOwogCiAJaWYgKHVubGlrZWx5KGdyZXRoLT50eF9mcmVlIDw9IDApKSB7CisJCXNwaW5fbG9ja19pcnFzYXZlKCZncmV0aC0+ZGV2bG9jaywgZmxhZ3MpOy8qc2F2ZSBmcm9tIHBvbGwvaXJxKi8KKwkJY3RybCA9IEdSRVRIX1JFR0xPQUQoZ3JldGgtPnJlZ3MtPmNvbnRyb2wpOworCQkvKiBFbmFibGUgVFggSVJRIG9ubHkgaWYgbm90IGFscmVhZHkgaW4gcG9sbCgpIHJvdXRpbmUgKi8KKwkJaWYgKGN0cmwgJiBHUkVUSF9SWEkpCisJCQlHUkVUSF9SRUdTQVZFKGdyZXRoLT5yZWdzLT5jb250cm9sLCBjdHJsIHwgR1JFVEhfVFhJKTsKIAkJbmV0aWZfc3RvcF9xdWV1ZShkZXYpOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZncmV0aC0+ZGV2bG9jaywgZmxhZ3MpOwogCQlyZXR1cm4gTkVUREVWX1RYX0JVU1k7CiAJfQogCkBAIC00MDYsMTMgKzQxOCwxNCBAQAogCQlnb3RvIG91dDsKIAl9CiAKKwliZHAgPSBncmV0aC0+dHhfYmRfYmFzZSArIGdyZXRoLT50eF9uZXh0OwogCWRtYV9hZGRyID0gZ3JldGhfcmVhZF9iZCgmYmRwLT5hZGRyKTsKIAogCW1lbWNweSgodW5zaWduZWQgY2hhciAqKSBwaHlzX3RvX3ZpcnQoZG1hX2FkZHIpLCBza2ItPmRhdGEsIHNrYi0+bGVuKTsKIAogCWRtYV9zeW5jX3NpbmdsZV9mb3JfZGV2aWNlKGdyZXRoLT5kZXYsIGRtYV9hZGRyLCBza2ItPmxlbiwgRE1BX1RPX0RFVklDRSk7CiAKLQlzdGF0dXMgPSBHUkVUSF9CRF9FTiB8IChza2ItPmxlbiAmIEdSRVRIX0JEX0xFTik7CisJc3RhdHVzID0gR1JFVEhfQkRfRU4gfCBHUkVUSF9CRF9JRSB8IChza2ItPmxlbiAmIEdSRVRIX0JEX0xFTik7CiAKIAkvKiBXcmFwIGFyb3VuZCBkZXNjcmlwdG9yIHJpbmcgKi8KIAlpZiAoZ3JldGgtPnR4X25leHQgPT0gR1JFVEhfVFhCRF9OVU1fTUFTSykgewpAQCAtNDIyLDIyICs0MzUsMTEgQEAKIAlncmV0aC0+dHhfbmV4dCA9IE5FWFRfVFgoZ3JldGgtPnR4X25leHQpOwogCWdyZXRoLT50eF9mcmVlLS07CiAKLQkvKiBObyBtb3JlIGRlc2NyaXB0b3JzICovCi0JaWYgKHVubGlrZWx5KGdyZXRoLT50eF9mcmVlID09IDApKSB7Ci0KLQkJLyogRnJlZSB0cmFuc21pdHRlZCBkZXNjcmlwdG9ycyAqLwotCQlncmV0aF9jbGVhbl90eChkZXYpOwotCi0JCS8qIElmIG5vdGhpbmcgd2FzIGNsZWFuZWQsIHN0b3AgcXVldWUgJiB3YWl0IGZvciBpcnEgKi8KLQkJaWYgKHVubGlrZWx5KGdyZXRoLT50eF9mcmVlID09IDApKSB7Ci0JCQlzdGF0dXMgfD0gR1JFVEhfQkRfSUU7Ci0JCQluZXRpZl9zdG9wX3F1ZXVlKGRldik7Ci0JCX0KLQl9Ci0KIAkvKiBXcml0ZSBkZXNjcmlwdG9yIGNvbnRyb2wgd29yZCBhbmQgZW5hYmxlIHRyYW5zbWlzc2lvbiAqLwogCWdyZXRoX3dyaXRlX2JkKCZiZHAtPnN0YXQsIHN0YXR1cyk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJmdyZXRoLT5kZXZsb2NrLCBmbGFncyk7IC8qc2F2ZSBmcm9tIHBvbGwvaXJxKi8KIAlncmV0aF9lbmFibGVfdHgoZ3JldGgpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdyZXRoLT5kZXZsb2NrLCBmbGFncyk7CiAKIG91dDoKIAlkZXZfa2ZyZWVfc2tiKHNrYik7CkBAIC00NTAsMTMgKzQ1MiwyMyBAQAogewogCXN0cnVjdCBncmV0aF9wcml2YXRlICpncmV0aCA9IG5ldGRldl9wcml2KGRldik7CiAJc3RydWN0IGdyZXRoX2JkICpiZHA7Ci0JdTMyIHN0YXR1cyA9IDAsIGRtYV9hZGRyOworCXUzMiBzdGF0dXMgPSAwLCBkbWFfYWRkciwgY3RybDsKIAlpbnQgY3Vycl90eCwgbnJfZnJhZ3MsIGksIGVyciA9IE5FVERFVl9UWF9PSzsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJbnJfZnJhZ3MgPSBza2Jfc2hpbmZvKHNrYiktPm5yX2ZyYWdzOwogCisJLyogQ2xlYW4gVFggUmluZyAqLworCWdyZXRoX2NsZWFuX3R4X2diaXQoZGV2KTsKKwogCWlmIChncmV0aC0+dHhfZnJlZSA8IG5yX2ZyYWdzICsgMSkgeworCQlzcGluX2xvY2tfaXJxc2F2ZSgmZ3JldGgtPmRldmxvY2ssIGZsYWdzKTsvKnNhdmUgZnJvbSBwb2xsL2lycSovCisJCWN0cmwgPSBHUkVUSF9SRUdMT0FEKGdyZXRoLT5yZWdzLT5jb250cm9sKTsKKwkJLyogRW5hYmxlIFRYIElSUSBvbmx5IGlmIG5vdCBhbHJlYWR5IGluIHBvbGwoKSByb3V0aW5lICovCisJCWlmIChjdHJsICYgR1JFVEhfUlhJKQorCQkJR1JFVEhfUkVHU0FWRShncmV0aC0+cmVncy0+Y29udHJvbCwgY3RybCB8IEdSRVRIX1RYSSk7CiAJCW5ldGlmX3N0b3BfcXVldWUoZGV2KTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ3JldGgtPmRldmxvY2ssIGZsYWdzKTsKIAkJZXJyID0gTkVUREVWX1RYX0JVU1k7CiAJCWdvdG8gb3V0OwogCX0KQEAgLTQ5OSw3ICs1MTEsNyBAQAogCQlncmV0aC0+dHhfc2tidWZmW2N1cnJfdHhdID0gTlVMTDsKIAkJYmRwID0gZ3JldGgtPnR4X2JkX2Jhc2UgKyBjdXJyX3R4OwogCi0JCXN0YXR1cyA9IEdSRVRIX1RYQkRfQ1NBTEw7CisJCXN0YXR1cyA9IEdSRVRIX1RYQkRfQ1NBTEwgfCBHUkVUSF9CRF9FTjsKIAkJc3RhdHVzIHw9IGZyYWctPnNpemUgJiBHUkVUSF9CRF9MRU47CiAKIAkJLyogV3JhcCBhcm91bmQgZGVzY3JpcHRvciByaW5nICovCkBAIC01MDksMTQgKzUyMSw4IEBACiAJCS8qIE1vcmUgZnJhZ21lbnRzIGxlZnQgKi8KIAkJaWYgKGkgPCBucl9mcmFncyAtIDEpCiAJCQlzdGF0dXMgfD0gR1JFVEhfVFhCRF9NT1JFOwotCi0JCS8qIC4uLiBsYXN0IGZyYWdtZW50LCBjaGVjayBpZiBvdXQgb2YgZGVzY3JpcHRvcnMgICovCi0JCWVsc2UgaWYgKGdyZXRoLT50eF9mcmVlIC0gbnJfZnJhZ3MgLSAxIDwgKE1BWF9TS0JfRlJBR1MgKyAxKSkgewotCi0JCQkvKiBFbmFibGUgaW50ZXJydXB0cyBhbmQgc3RvcCBxdWV1ZSAqLwotCQkJc3RhdHVzIHw9IEdSRVRIX0JEX0lFOwotCQkJbmV0aWZfc3RvcF9xdWV1ZShkZXYpOwotCQl9CisJCWVsc2UKKwkJCXN0YXR1cyB8PSBHUkVUSF9CRF9JRTsgLyogZW5hYmxlIElSUSBvbiBsYXN0IGZyYWdtZW50ICovCiAKIAkJZ3JldGhfd3JpdGVfYmQoJmJkcC0+c3RhdCwgc3RhdHVzKTsKIApAQCAtNTM2LDI2ICs1NDIsMjkgQEAKIAogCXdtYigpOwogCi0JLyogRW5hYmxlIHRoZSBkZXNjcmlwdG9ycyB0aGF0IHdlIGNvbmZpZ3VyZWQgLi4uICAqLwotCWZvciAoaSA9IDA7IGkgPCBucl9mcmFncyArIDE7IGkrKykgewotCQliZHAgPSBncmV0aC0+dHhfYmRfYmFzZSArIGdyZXRoLT50eF9uZXh0OwotCQlncmV0aF93cml0ZV9iZCgmYmRwLT5zdGF0LCBncmV0aF9yZWFkX2JkKCZiZHAtPnN0YXQpIHwgR1JFVEhfQkRfRU4pOwotCQlncmV0aC0+dHhfbmV4dCA9IE5FWFRfVFgoZ3JldGgtPnR4X25leHQpOwotCQlncmV0aC0+dHhfZnJlZS0tOwotCX0KKwkvKiBFbmFibGUgdGhlIGRlc2NyaXB0b3IgY2hhaW4gYnkgZW5hYmxpbmcgdGhlIGZpcnN0IGRlc2NyaXB0b3IgKi8KKwliZHAgPSBncmV0aC0+dHhfYmRfYmFzZSArIGdyZXRoLT50eF9uZXh0OworCWdyZXRoX3dyaXRlX2JkKCZiZHAtPnN0YXQsIGdyZXRoX3JlYWRfYmQoJmJkcC0+c3RhdCkgfCBHUkVUSF9CRF9FTik7CisJZ3JldGgtPnR4X25leHQgPSBjdXJyX3R4OworCWdyZXRoLT50eF9mcmVlIC09IG5yX2ZyYWdzICsgMTsKIAorCXdtYigpOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmdyZXRoLT5kZXZsb2NrLCBmbGFncyk7IC8qc2F2ZSBmcm9tIHBvbGwvaXJxKi8KIAlncmV0aF9lbmFibGVfdHgoZ3JldGgpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdyZXRoLT5kZXZsb2NrLCBmbGFncyk7CiAKIAlyZXR1cm4gTkVUREVWX1RYX09LOwogCiBmcmFnX21hcF9lcnJvcjoKLQkvKiBVbm1hcCBTS0IgbWFwcGluZ3MgdGhhdCBzdWNjZWVkZWQgKi8KKwkvKiBVbm1hcCBTS0IgbWFwcGluZ3MgdGhhdCBzdWNjZWVkZWQgYW5kIGRpc2FibGUgZGVzY3JpcHRvciAqLwogCWZvciAoaSA9IDA7IGdyZXRoLT50eF9uZXh0ICsgaSAhPSBjdXJyX3R4OyBpKyspIHsKIAkJYmRwID0gZ3JldGgtPnR4X2JkX2Jhc2UgKyBncmV0aC0+dHhfbmV4dCArIGk7CiAJCWRtYV91bm1hcF9zaW5nbGUoZ3JldGgtPmRldiwKIAkJCQkgZ3JldGhfcmVhZF9iZCgmYmRwLT5hZGRyKSwKIAkJCQkgZ3JldGhfcmVhZF9iZCgmYmRwLT5zdGF0KSAmIEdSRVRIX0JEX0xFTiwKIAkJCQkgRE1BX1RPX0RFVklDRSk7CisJCWdyZXRoX3dyaXRlX2JkKCZiZHAtPnN0YXQsIDApOwogCX0KIG1hcF9lcnJvcjoKIAlpZiAobmV0X3JhdGVsaW1pdCgpKQpAQCAtNTY1LDEyICs1NzQsMTEgQEAKIAlyZXR1cm4gZXJyOwogfQogCi0KIHN0YXRpYyBpcnFyZXR1cm5fdCBncmV0aF9pbnRlcnJ1cHQoaW50IGlycSwgdm9pZCAqZGV2X2lkKQogewogCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSBkZXZfaWQ7CiAJc3RydWN0IGdyZXRoX3ByaXZhdGUgKmdyZXRoOwotCXUzMiBzdGF0dXM7CisJdTMyIHN0YXR1cywgY3RybDsKIAlpcnFyZXR1cm5fdCByZXR2YWwgPSBJUlFfTk9ORTsKIAogCWdyZXRoID0gbmV0ZGV2X3ByaXYoZGV2KTsKQEAgLTU4MCwxMyArNTg4LDE1IEBACiAJLyogR2V0IHRoZSBpbnRlcnJ1cHQgZXZlbnRzIHRoYXQgY2F1c2VkIHVzIHRvIGJlIGhlcmUuICovCiAJc3RhdHVzID0gR1JFVEhfUkVHTE9BRChncmV0aC0+cmVncy0+c3RhdHVzKTsKIAorCS8qIE11c3Qgc2VlIGlmIGludGVycnVwdHMgYXJlIGVuYWJsZWQgYWxzbywgSU5UX1RYfElOVF9SWCBmbGFncyBtYXkgYmUKKwkgKiBzZXQgcmVnYXJkbGVzcyBvZiB3aGV0aGVyIElSUSBpcyBlbmFibGVkIG9yIG5vdC4gRXNwZWNpYWxseQorCSAqIGltcG9ydGFudCB3aGVuIHNoYXJlZCBJUlEuCisJICovCisJY3RybCA9IEdSRVRIX1JFR0xPQUQoZ3JldGgtPnJlZ3MtPmNvbnRyb2wpOworCiAJLyogSGFuZGxlIHJ4IGFuZCB0eCBpbnRlcnJ1cHRzIHRocm91Z2ggcG9sbCAqLwotCWlmIChzdGF0dXMgJiAoR1JFVEhfSU5UX1JYIHwgR1JFVEhfSU5UX1RYKSkgewotCi0JCS8qIENsZWFyIGludGVycnVwdCBzdGF0dXMgKi8KLQkJR1JFVEhfUkVHT1JJTihncmV0aC0+cmVncy0+c3RhdHVzLAotCQkJICAgICAgc3RhdHVzICYgKEdSRVRIX0lOVF9SWCB8IEdSRVRIX0lOVF9UWCkpOwotCisJaWYgKCgoc3RhdHVzICYgKEdSRVRIX0lOVF9SRSB8IEdSRVRIX0lOVF9SWCkpICYmIChjdHJsICYgR1JFVEhfUlhJKSkgfHwKKwkgICAgKChzdGF0dXMgJiAoR1JFVEhfSU5UX1RFIHwgR1JFVEhfSU5UX1RYKSkgJiYgKGN0cmwgJiBHUkVUSF9UWEkpKSkgewogCQlyZXR2YWwgPSBJUlFfSEFORExFRDsKIAogCQkvKiBEaXNhYmxlIGludGVycnVwdHMgYW5kIHNjaGVkdWxlIHBvbGwoKSAqLwpAQCAtNjEwLDYgKzYyMCw4IEBACiAKIAl3aGlsZSAoMSkgewogCQliZHAgPSBncmV0aC0+dHhfYmRfYmFzZSArIGdyZXRoLT50eF9sYXN0OworCQlHUkVUSF9SRUdTQVZFKGdyZXRoLT5yZWdzLT5zdGF0dXMsIEdSRVRIX0lOVF9URSB8IEdSRVRIX0lOVF9UWCk7CisJCW1iKCk7CiAJCXN0YXQgPSBncmV0aF9yZWFkX2JkKCZiZHAtPnN0YXQpOwogCiAJCWlmICh1bmxpa2VseShzdGF0ICYgR1JFVEhfQkRfRU4pKQpAQCAtNjcwLDcgKzY4MiwxMCBAQAogCiAJCS8qIFdlIG9ubHkgY2xlYW4gZnVsbHkgY29tcGxldGVkIFNLQnMgKi8KIAkJYmRwX2xhc3RfZnJhZyA9IGdyZXRoLT50eF9iZF9iYXNlICsgU0tJUF9UWChncmV0aC0+dHhfbGFzdCwgbnJfZnJhZ3MpOwotCQlzdGF0ID0gYmRwX2xhc3RfZnJhZy0+c3RhdDsKKworCQlHUkVUSF9SRUdTQVZFKGdyZXRoLT5yZWdzLT5zdGF0dXMsIEdSRVRIX0lOVF9URSB8IEdSRVRIX0lOVF9UWCk7CisJCW1iKCk7CisJCXN0YXQgPSBncmV0aF9yZWFkX2JkKCZiZHBfbGFzdF9mcmFnLT5zdGF0KTsKIAogCQlpZiAoc3RhdCAmIEdSRVRIX0JEX0VOKQogCQkJYnJlYWs7CkBAIC03MDIsMjEgKzcxNyw5IEBACiAJCWdyZXRoLT50eF9mcmVlICs9IG5yX2ZyYWdzKzE7CiAJCWRldl9rZnJlZV9za2Ioc2tiKTsKIAl9Ci0JaWYgKGdyZXRoLT50eF9mcmVlID4gKE1BWF9TS0JfRlJBR1MgKyAxKSkgewotCQluZXRpZl93YWtlX3F1ZXVlKGRldik7Ci0JfQotfQogCi1zdGF0aWMgaW50IGdyZXRoX3BlbmRpbmdfcGFja2V0cyhzdHJ1Y3QgZ3JldGhfcHJpdmF0ZSAqZ3JldGgpCi17Ci0Jc3RydWN0IGdyZXRoX2JkICpiZHA7Ci0JdTMyIHN0YXR1czsKLQliZHAgPSBncmV0aC0+cnhfYmRfYmFzZSArIGdyZXRoLT5yeF9jdXI7Ci0Jc3RhdHVzID0gZ3JldGhfcmVhZF9iZCgmYmRwLT5zdGF0KTsKLQlpZiAoc3RhdHVzICYgR1JFVEhfQkRfRU4pCi0JCXJldHVybiAwOwotCWVsc2UKLQkJcmV0dXJuIDE7CisJaWYgKG5ldGlmX3F1ZXVlX3N0b3BwZWQoZGV2KSAmJiAoZ3JldGgtPnR4X2ZyZWUgPiAoTUFYX1NLQl9GUkFHUysxKSkpCisJCW5ldGlmX3dha2VfcXVldWUoZGV2KTsKIH0KIAogc3RhdGljIGludCBncmV0aF9yeChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBpbnQgbGltaXQpCkBAIC03MjcsMjAgKzczMCwyNCBAQAogCWludCBwa3RfbGVuOwogCWludCBiYWQsIGNvdW50OwogCXUzMiBzdGF0dXMsIGRtYV9hZGRyOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKIAlncmV0aCA9IG5ldGRldl9wcml2KGRldik7CiAKIAlmb3IgKGNvdW50ID0gMDsgY291bnQgPCBsaW1pdDsgKytjb3VudCkgewogCiAJCWJkcCA9IGdyZXRoLT5yeF9iZF9iYXNlICsgZ3JldGgtPnJ4X2N1cjsKKwkJR1JFVEhfUkVHU0FWRShncmV0aC0+cmVncy0+c3RhdHVzLCBHUkVUSF9JTlRfUkUgfCBHUkVUSF9JTlRfUlgpOworCQltYigpOwogCQlzdGF0dXMgPSBncmV0aF9yZWFkX2JkKCZiZHAtPnN0YXQpOwotCQlkbWFfYWRkciA9IGdyZXRoX3JlYWRfYmQoJmJkcC0+YWRkcik7Ci0JCWJhZCA9IDA7CiAKIAkJaWYgKHVubGlrZWx5KHN0YXR1cyAmIEdSRVRIX0JEX0VOKSkgewogCQkJYnJlYWs7CiAJCX0KIAorCQlkbWFfYWRkciA9IGdyZXRoX3JlYWRfYmQoJmJkcC0+YWRkcik7CisJCWJhZCA9IDA7CisKIAkJLyogQ2hlY2sgc3RhdHVzIGZvciBlcnJvcnMuICovCiAJCWlmICh1bmxpa2VseShzdGF0dXMgJiBHUkVUSF9SWEJEX1NUQVRVUykpIHsKIAkJCWlmIChzdGF0dXMgJiBHUkVUSF9SWEJEX0VSUl9GVCkgewpAQCAtODAyLDcgKzgwOSw5IEBACiAKIAkJZG1hX3N5bmNfc2luZ2xlX2Zvcl9kZXZpY2UoZ3JldGgtPmRldiwgZG1hX2FkZHIsIE1BWF9GUkFNRV9TSVpFLCBETUFfRlJPTV9ERVZJQ0UpOwogCisJCXNwaW5fbG9ja19pcnFzYXZlKCZncmV0aC0+ZGV2bG9jaywgZmxhZ3MpOyAvKiBzYXZlIGZyb20gWE1JVCAqLwogCQlncmV0aF9lbmFibGVfcngoZ3JldGgpOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZncmV0aC0+ZGV2bG9jaywgZmxhZ3MpOwogCiAJCWdyZXRoLT5yeF9jdXIgPSBORVhUX1JYKGdyZXRoLT5yeF9jdXIpOwogCX0KQEAgLTgzNiw2ICs4NDUsNyBAQAogCWludCBwa3RfbGVuOwogCWludCBiYWQsIGNvdW50ID0gMDsKIAl1MzIgc3RhdHVzLCBkbWFfYWRkcjsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJZ3JldGggPSBuZXRkZXZfcHJpdihkZXYpOwogCkBAIC04NDMsNiArODUzLDggQEAKIAogCQliZHAgPSBncmV0aC0+cnhfYmRfYmFzZSArIGdyZXRoLT5yeF9jdXI7CiAJCXNrYiA9IGdyZXRoLT5yeF9za2J1ZmZbZ3JldGgtPnJ4X2N1cl07CisJCUdSRVRIX1JFR1NBVkUoZ3JldGgtPnJlZ3MtPnN0YXR1cywgR1JFVEhfSU5UX1JFIHwgR1JFVEhfSU5UX1JYKTsKKwkJbWIoKTsKIAkJc3RhdHVzID0gZ3JldGhfcmVhZF9iZCgmYmRwLT5zdGF0KTsKIAkJYmFkID0gMDsKIApAQCAtODY1LDEwICs4NzcsOSBAQAogCQkJfQogCQl9CiAKLQkJLyogQWxsb2NhdGUgbmV3IHNrYiB0byByZXBsYWNlIGN1cnJlbnQgKi8KLQkJbmV3c2tiID0gbmV0ZGV2X2FsbG9jX3NrYihkZXYsIE1BWF9GUkFNRV9TSVpFICsgTkVUX0lQX0FMSUdOKTsKLQotCQlpZiAoIWJhZCAmJiBuZXdza2IpIHsKKwkJLyogQWxsb2NhdGUgbmV3IHNrYiB0byByZXBsYWNlIGN1cnJlbnQsIG5vdCBuZWVkZWQgaWYgdGhlCisJCSAqIGN1cnJlbnQgc2tiIGNhbiBiZSByZXVzZWQgKi8KKwkJaWYgKCFiYWQgJiYgKG5ld3NrYj1uZXRkZXZfYWxsb2Nfc2tiKGRldiwgTUFYX0ZSQU1FX1NJWkUgKyBORVRfSVBfQUxJR04pKSkgewogCQkJc2tiX3Jlc2VydmUobmV3c2tiLCBORVRfSVBfQUxJR04pOwogCiAJCQlkbWFfYWRkciA9IGRtYV9tYXBfc2luZ2xlKGdyZXRoLT5kZXYsCkBAIC05MDUsMTEgKzkxNiwyMiBAQAogCQkJCWlmIChuZXRfcmF0ZWxpbWl0KCkpCiAJCQkJCWRldl93YXJuKGdyZXRoLT5kZXYsICJDb3VsZCBub3QgY3JlYXRlIERNQSBtYXBwaW5nLCBkcm9wcGluZyBwYWNrZXRcbiIpOwogCQkJCWRldl9rZnJlZV9za2IobmV3c2tiKTsKKwkJCQkvKiByZXVzaW5nIGN1cnJlbnQgc2tiLCBzbyBpdCBpcyBhIGRyb3AgKi8KIAkJCQlkZXYtPnN0YXRzLnJ4X2Ryb3BwZWQrKzsKIAkJCX0KKwkJfSBlbHNlIGlmIChiYWQpIHsKKwkJCS8qIEJhZCBGcmFtZSB0cmFuc2ZlciwgdGhlIHNrYiBpcyByZXVzZWQgKi8KKwkJCWRldi0+c3RhdHMucnhfZHJvcHBlZCsrOwogCQl9IGVsc2UgeworCQkJLyogRmFpbGVkIEFsbG9jYXRpbmcgYSBuZXcgc2tiLiBUaGlzIGlzIHJhdGhlciBzdHVwaWQKKwkJCSAqIGJ1dCB0aGUgY3VycmVudCAiZmlsbGVkIiBza2IgaXMgcmV1c2VkLCBhcyBpZgorCQkJICogdHJhbnNmZXIgZmFpbHVyZS4gT25lIGNvdWxkIGFyZ3VlIHRoYXQgUlggZGVzY3JpcHRvcgorCQkJICogdGFibGUgaGFuZGxpbmcgc2hvdWxkIGJlIGRpdmlkZWQgaW50byBjbGVhbmluZyBhbmQKKwkJCSAqIGZpbGxpbmcgYXMgdGhlIFRYIHBhcnQgb2YgdGhlIGRyaXZlcgorCQkJICovCiAJCQlpZiAobmV0X3JhdGVsaW1pdCgpKQogCQkJCWRldl93YXJuKGdyZXRoLT5kZXYsICJDb3VsZCBub3QgYWxsb2NhdGUgU0tCLCBkcm9wcGluZyBwYWNrZXRcbiIpOworCQkJLyogcmV1c2luZyBjdXJyZW50IHNrYiwgc28gaXQgaXMgYSBkcm9wICovCiAJCQlkZXYtPnN0YXRzLnJ4X2Ryb3BwZWQrKzsKIAkJfQogCkBAIC05MjAsNyArOTQyLDkgQEAKIAogCQl3bWIoKTsKIAkJZ3JldGhfd3JpdGVfYmQoJmJkcC0+c3RhdCwgc3RhdHVzKTsKKwkJc3Bpbl9sb2NrX2lycXNhdmUoJmdyZXRoLT5kZXZsb2NrLCBmbGFncyk7CiAJCWdyZXRoX2VuYWJsZV9yeChncmV0aCk7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdyZXRoLT5kZXZsb2NrLCBmbGFncyk7CiAJCWdyZXRoLT5yeF9jdXIgPSBORVhUX1JYKGdyZXRoLT5yeF9jdXIpOwogCX0KIApAQCAtOTMyLDE1ICs5NTYsMTggQEAKIHsKIAlzdHJ1Y3QgZ3JldGhfcHJpdmF0ZSAqZ3JldGg7CiAJaW50IHdvcmtfZG9uZSA9IDA7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwl1MzIgbWFzaywgY3RybDsKIAlncmV0aCA9IGNvbnRhaW5lcl9vZihuYXBpLCBzdHJ1Y3QgZ3JldGhfcHJpdmF0ZSwgbmFwaSk7CiAKLQlpZiAoZ3JldGgtPmdiaXRfbWFjKSB7Ci0JCWdyZXRoX2NsZWFuX3R4X2diaXQoZ3JldGgtPm5ldGRldik7Ci0JfSBlbHNlIHsKLQkJZ3JldGhfY2xlYW5fdHgoZ3JldGgtPm5ldGRldik7CityZXN0YXJ0X3R4cnhfcG9sbDoKKwlpZiAobmV0aWZfcXVldWVfc3RvcHBlZChncmV0aC0+bmV0ZGV2KSkgeworCQlpZiAoZ3JldGgtPmdiaXRfbWFjKQorCQkJZ3JldGhfY2xlYW5fdHhfZ2JpdChncmV0aC0+bmV0ZGV2KTsKKwkJZWxzZQorCQkJZ3JldGhfY2xlYW5fdHgoZ3JldGgtPm5ldGRldik7CiAJfQogCi1yZXN0YXJ0X3BvbGw6CiAJaWYgKGdyZXRoLT5nYml0X21hYykgewogCQl3b3JrX2RvbmUgKz0gZ3JldGhfcnhfZ2JpdChncmV0aC0+bmV0ZGV2LCBidWRnZXQgLSB3b3JrX2RvbmUpOwogCX0gZWxzZSB7CkBAIC05NDksMTUgKzk3NiwyOSBAQAogCiAJaWYgKHdvcmtfZG9uZSA8IGJ1ZGdldCkgewogCi0JCW5hcGlfY29tcGxldGUobmFwaSk7CisJCXNwaW5fbG9ja19pcnFzYXZlKCZncmV0aC0+ZGV2bG9jaywgZmxhZ3MpOwogCi0JCWlmIChncmV0aF9wZW5kaW5nX3BhY2tldHMoZ3JldGgpKSB7Ci0JCQluYXBpX3Jlc2NoZWR1bGUobmFwaSk7Ci0JCQlnb3RvIHJlc3RhcnRfcG9sbDsKKwkJY3RybCA9IEdSRVRIX1JFR0xPQUQoZ3JldGgtPnJlZ3MtPmNvbnRyb2wpOworCQlpZiAobmV0aWZfcXVldWVfc3RvcHBlZChncmV0aC0+bmV0ZGV2KSkgeworCQkJR1JFVEhfUkVHU0FWRShncmV0aC0+cmVncy0+Y29udHJvbCwKKwkJCQkJY3RybCB8IEdSRVRIX1RYSSB8IEdSRVRIX1JYSSk7CisJCQltYXNrID0gR1JFVEhfSU5UX1JYIHwgR1JFVEhfSU5UX1JFIHwKKwkJCSAgICAgICBHUkVUSF9JTlRfVFggfCBHUkVUSF9JTlRfVEU7CisJCX0gZWxzZSB7CisJCQlHUkVUSF9SRUdTQVZFKGdyZXRoLT5yZWdzLT5jb250cm9sLCBjdHJsIHwgR1JFVEhfUlhJKTsKKwkJCW1hc2sgPSBHUkVUSF9JTlRfUlggfCBHUkVUSF9JTlRfUkU7CisJCX0KKworCQlpZiAoR1JFVEhfUkVHTE9BRChncmV0aC0+cmVncy0+c3RhdHVzKSAmIG1hc2spIHsKKwkJCUdSRVRIX1JFR1NBVkUoZ3JldGgtPnJlZ3MtPmNvbnRyb2wsIGN0cmwpOworCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ3JldGgtPmRldmxvY2ssIGZsYWdzKTsKKwkJCWdvdG8gcmVzdGFydF90eHJ4X3BvbGw7CisJCX0gZWxzZSB7CisJCQlfX25hcGlfY29tcGxldGUobmFwaSk7CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZncmV0aC0+ZGV2bG9jaywgZmxhZ3MpOwogCQl9CiAJfQogCi0JZ3JldGhfZW5hYmxlX2lycXMoZ3JldGgpOwogCXJldHVybiB3b3JrX2RvbmU7CiB9CiAKQEAgLTExNTIsMTEgKzExOTMsMTEgQEAKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgbmV0X2RldmljZV9vcHMgZ3JldGhfbmV0ZGV2X29wcyA9IHsKLQkubmRvX29wZW4gPSBncmV0aF9vcGVuLAotCS5uZG9fc3RvcCA9IGdyZXRoX2Nsb3NlLAotCS5uZG9fc3RhcnRfeG1pdCA9IGdyZXRoX3N0YXJ0X3htaXQsCi0JLm5kb19zZXRfbWFjX2FkZHJlc3MgPSBncmV0aF9zZXRfbWFjX2FkZCwKLQkubmRvX3ZhbGlkYXRlX2FkZHIgCT0gZXRoX3ZhbGlkYXRlX2FkZHIsCisJLm5kb19vcGVuCQk9IGdyZXRoX29wZW4sCisJLm5kb19zdG9wCQk9IGdyZXRoX2Nsb3NlLAorCS5uZG9fc3RhcnRfeG1pdAkJPSBncmV0aF9zdGFydF94bWl0LAorCS5uZG9fc2V0X21hY19hZGRyZXNzCT0gZ3JldGhfc2V0X21hY19hZGQsCisJLm5kb192YWxpZGF0ZV9hZGRyCT0gZXRoX3ZhbGlkYXRlX2FkZHIsCiB9OwogCiBzdGF0aWMgaW5saW5lIGludCB3YWl0X2Zvcl9tZGlvKHN0cnVjdCBncmV0aF9wcml2YXRlICpncmV0aCkKQEAgLTEyMTcsMjkgKzEyNTgsMjYgQEAKIAlzdHJ1Y3QgZ3JldGhfcHJpdmF0ZSAqZ3JldGggPSBuZXRkZXZfcHJpdihkZXYpOwogCXN0cnVjdCBwaHlfZGV2aWNlICpwaHlkZXYgPSBncmV0aC0+cGh5OwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0KIAlpbnQgc3RhdHVzX2NoYW5nZSA9IDA7CisJdTMyIGN0cmw7CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmZ3JldGgtPmRldmxvY2ssIGZsYWdzKTsKIAogCWlmIChwaHlkZXYtPmxpbmspIHsKIAogCQlpZiAoKGdyZXRoLT5zcGVlZCAhPSBwaHlkZXYtPnNwZWVkKSB8fCAoZ3JldGgtPmR1cGxleCAhPSBwaHlkZXYtPmR1cGxleCkpIHsKLQotCQkJR1JFVEhfUkVHQU5ESU4oZ3JldGgtPnJlZ3MtPmNvbnRyb2wsCi0JCQkJICAgICAgIH4oR1JFVEhfQ1RSTF9GRCB8IEdSRVRIX0NUUkxfU1AgfCBHUkVUSF9DVFJMX0dCKSk7CisJCQljdHJsID0gR1JFVEhfUkVHTE9BRChncmV0aC0+cmVncy0+Y29udHJvbCkgJgorCQkJICAgICAgIH4oR1JFVEhfQ1RSTF9GRCB8IEdSRVRIX0NUUkxfU1AgfCBHUkVUSF9DVFJMX0dCKTsKIAogCQkJaWYgKHBoeWRldi0+ZHVwbGV4KQotCQkJCUdSRVRIX1JFR09SSU4oZ3JldGgtPnJlZ3MtPmNvbnRyb2wsIEdSRVRIX0NUUkxfRkQpOworCQkJCWN0cmwgfD0gR1JFVEhfQ1RSTF9GRDsKIAotCQkJaWYgKHBoeWRldi0+c3BlZWQgPT0gU1BFRURfMTAwKSB7Ci0KLQkJCQlHUkVUSF9SRUdPUklOKGdyZXRoLT5yZWdzLT5jb250cm9sLCBHUkVUSF9DVFJMX1NQKTsKLQkJCX0KLQorCQkJaWYgKHBoeWRldi0+c3BlZWQgPT0gU1BFRURfMTAwKQorCQkJCWN0cmwgfD0gR1JFVEhfQ1RSTF9TUDsKIAkJCWVsc2UgaWYgKHBoeWRldi0+c3BlZWQgPT0gU1BFRURfMTAwMCkKLQkJCQlHUkVUSF9SRUdPUklOKGdyZXRoLT5yZWdzLT5jb250cm9sLCBHUkVUSF9DVFJMX0dCKTsKKwkJCQljdHJsIHw9IEdSRVRIX0NUUkxfR0I7CiAKKwkJCUdSRVRIX1JFR1NBVkUoZ3JldGgtPnJlZ3MtPmNvbnRyb2wsIGN0cmwpOwogCQkJZ3JldGgtPnNwZWVkID0gcGh5ZGV2LT5zcGVlZDsKIAkJCWdyZXRoLT5kdXBsZXggPSBwaHlkZXYtPmR1cGxleDsKIAkJCXN0YXR1c19jaGFuZ2UgPSAxOwpAQCAtMTYwMCw2ICsxNjM4LDkgQEAKIAl7CiAJIC5uYW1lID0gIkdBSVNMRVJfRVRITUFDIiwKIAkgfSwKKwl7CisJIC5uYW1lID0gIjAxXzAxZCIsCisJIH0sCiAJe30sCiB9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ncmV0aC5oIGIvZHJpdmVycy9uZXQvZ3JldGguaAppbmRleCAwM2FkOTAzLi5iZTBmMjA2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ncmV0aC5oCisrKyBiL2RyaXZlcnMvbmV0L2dyZXRoLmgKQEAgLTIzLDYgKzIzLDcgQEAKICNkZWZpbmUgR1JFVEhfQkRfTEVOIDB4N0ZGCiAKICNkZWZpbmUgR1JFVEhfVFhFTiAweDEKKyNkZWZpbmUgR1JFVEhfSU5UX1RFIDB4MgogI2RlZmluZSBHUkVUSF9JTlRfVFggMHg4CiAjZGVmaW5lIEdSRVRIX1RYSSAweDQKICNkZWZpbmUgR1JFVEhfVFhCRF9TVEFUVVMgMHgwMDAxQzAwMApAQCAtMzUsNiArMzYsNyBAQAogI2RlZmluZSBHUkVUSF9UWEJEX0VSUl9VRSAweDQwMDAKICNkZWZpbmUgR1JFVEhfVFhCRF9FUlJfQUwgMHg4MDAwCiAKKyNkZWZpbmUgR1JFVEhfSU5UX1JFICAgICAgICAgMHgxCiAjZGVmaW5lIEdSRVRIX0lOVF9SWCAgICAgICAgIDB4NAogI2RlZmluZSBHUkVUSF9SWEVOICAgICAgICAgICAweDIKICNkZWZpbmUgR1JFVEhfUlhJICAgICAgICAgICAgMHg4CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9pcmRhL3NoX2lyZGEuYyBiL2RyaXZlcnMvbmV0L2lyZGEvc2hfaXJkYS5jCmluZGV4IDllM2Y0ZjUuLjQ0ODhiZDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2lyZGEvc2hfaXJkYS5jCisrKyBiL2RyaXZlcnMvbmV0L2lyZGEvc2hfaXJkYS5jCkBAIC02MzUsNyArNjM1LDcgQEAKIAogCXJldCA9IHNoX2lyZGFfc2V0X2JhdWRyYXRlKHNlbGYsIHNwZWVkKTsKIAlpZiAocmV0IDwgMCkKLQkJcmV0dXJuIHJldDsKKwkJZ290byBzaF9pcmRhX2hhcmRfeG1pdF9lbmQ7CiAKIAlzZWxmLT50eF9idWZmLmxlbiA9IDA7CiAJaWYgKHNrYi0+bGVuKSB7CkBAIC02NTIsMTEgKzY1MiwyMSBAQAogCiAJCXNoX2lyZGFfd3JpdGUoc2VsZiwgSVJURkxSLCBzZWxmLT50eF9idWZmLmxlbik7CiAJCXNoX2lyZGFfd3JpdGUoc2VsZiwgSVJUQ1RSLCBBUk1PRCB8IFRFKTsKLQl9CisJfSBlbHNlCisJCWdvdG8gc2hfaXJkYV9oYXJkX3htaXRfZW5kOwogCiAJZGV2X2tmcmVlX3NrYihza2IpOwogCiAJcmV0dXJuIDA7CisKK3NoX2lyZGFfaGFyZF94bWl0X2VuZDoKKwlzaF9pcmRhX3NldF9iYXVkcmF0ZShzZWxmLCA5NjAwKTsKKwluZXRpZl93YWtlX3F1ZXVlKHNlbGYtPm5kZXYpOworCXNoX2lyZGFfcmN2X2N0cmwoc2VsZiwgMSk7CisJZGV2X2tmcmVlX3NrYihza2IpOworCisJcmV0dXJuIHJldDsKKwogfQogCiBzdGF0aWMgaW50IHNoX2lyZGFfaW9jdGwoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIHN0cnVjdCBpZnJlcSAqaWZyZXEsIGludCBjbWQpCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9peGdiZS9peGdiZV9jb21tb24uYyBiL2RyaXZlcnMvbmV0L2l4Z2JlL2l4Z2JlX2NvbW1vbi5jCmluZGV4IGQ1ZWRlMmQuLmViYmRhN2QgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2l4Z2JlL2l4Z2JlX2NvbW1vbi5jCisrKyBiL2RyaXZlcnMvbmV0L2l4Z2JlL2l4Z2JlX2NvbW1vbi5jCkBAIC0xMzcwLDYgKzEzNzAsOSBAQAogCQlod19kYmcoaHcsICIgTmV3IE1BQyBBZGRyID0lcE1cbiIsIGh3LT5tYWMuYWRkcik7CiAKIAkJaHctPm1hYy5vcHMuc2V0X3JhcihodywgMCwgaHctPm1hYy5hZGRyLCAwLCBJWEdCRV9SQUhfQVYpOworCisJCS8qICBjbGVhciBWTURxIHBvb2wvcXVldWUgc2VsZWN0aW9uIGZvciBSQVIgMCAqLworCQlody0+bWFjLm9wcy5jbGVhcl92bWRxKGh3LCAwLCBJWEdCRV9DTEVBUl9WTURRX0FMTCk7CiAJfQogCWh3LT5hZGRyX2N0cmwub3ZlcmZsb3dfcHJvbWlzYyA9IDA7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2l4Z2JlL2l4Z2JlX2Zjb2UuYyBiL2RyaXZlcnMvbmV0L2l4Z2JlL2l4Z2JlX2Zjb2UuYwppbmRleCA2MzQyZDQ4Li44NzUzOTgwIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9peGdiZS9peGdiZV9mY29lLmMKKysrIGIvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfZmNvZS5jCkBAIC0xNjUsNyArMTY1LDcgQEAKIAl1bnNpZ25lZCBpbnQgdGhpc29mZiA9IDA7CiAJdW5zaWduZWQgaW50IHRoaXNsZW4gPSAwOwogCXUzMiBmY2J1ZmYsIGZjZG1hcncsIGZjZmx0cnc7Ci0JZG1hX2FkZHJfdCBhZGRyOworCWRtYV9hZGRyX3QgYWRkciA9IDA7CiAKIAlpZiAoIW5ldGRldiB8fCAhc2dsKQogCQlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2l4Z2JlL2l4Z2JlX21haW4uYyBiL2RyaXZlcnMvbmV0L2l4Z2JlL2l4Z2JlX21haW4uYwppbmRleCBhMDYwNjEwLi5mYmFlNzAzIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9peGdiZS9peGdiZV9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfbWFpbi5jCkBAIC01Miw3ICs1Miw3IEBACiBzdGF0aWMgY29uc3QgY2hhciBpeGdiZV9kcml2ZXJfc3RyaW5nW10gPQogCQkJICAgICAgIkludGVsKFIpIDEwIEdpZ2FiaXQgUENJIEV4cHJlc3MgTmV0d29yayBEcml2ZXIiOwogCi0jZGVmaW5lIERSVl9WRVJTSU9OICIzLjAuMTItazIiCisjZGVmaW5lIERSVl9WRVJTSU9OICIzLjIuOS1rMiIKIGNvbnN0IGNoYXIgaXhnYmVfZHJpdmVyX3ZlcnNpb25bXSA9IERSVl9WRVJTSU9OOwogc3RhdGljIGNoYXIgaXhnYmVfY29weXJpZ2h0W10gPSAiQ29weXJpZ2h0IChjKSAxOTk5LTIwMTAgSW50ZWwgQ29ycG9yYXRpb24uIjsKIApAQCAtMzE3Niw5ICszMTc2LDE2IEBACiAJdTMyIG1oYWRkLCBobHJlZzA7CiAKIAkvKiBEZWNpZGUgd2hldGhlciB0byB1c2UgcGFja2V0IHNwbGl0IG1vZGUgb3Igbm90ICovCisJLyogT24gYnkgZGVmYXVsdCAqLworCWFkYXB0ZXItPmZsYWdzIHw9IElYR0JFX0ZMQUdfUlhfUFNfRU5BQkxFRDsKKwogCS8qIERvIG5vdCB1c2UgcGFja2V0IHNwbGl0IGlmIHdlJ3JlIGluIFNSLUlPViBNb2RlICovCi0JaWYgKCFhZGFwdGVyLT5udW1fdmZzKQotCQlhZGFwdGVyLT5mbGFncyB8PSBJWEdCRV9GTEFHX1JYX1BTX0VOQUJMRUQ7CisJaWYgKGFkYXB0ZXItPm51bV92ZnMpCisJCWFkYXB0ZXItPmZsYWdzICY9IH5JWEdCRV9GTEFHX1JYX1BTX0VOQUJMRUQ7CisKKwkvKiBEaXNhYmxlIHBhY2tldCBzcGxpdCBkdWUgdG8gODI1OTkgZXJyYXR1bSAjNDUgKi8KKwlpZiAoaHctPm1hYy50eXBlID09IGl4Z2JlX21hY184MjU5OUVCKQorCQlhZGFwdGVyLT5mbGFncyAmPSB+SVhHQkVfRkxBR19SWF9QU19FTkFCTEVEOwogCiAJLyogU2V0IHRoZSBSWCBidWZmZXIgbGVuZ3RoIGFjY29yZGluZyB0byB0aGUgbW9kZSAqLwogCWlmIChhZGFwdGVyLT5mbGFncyAmIElYR0JFX0ZMQUdfUlhfUFNfRU5BQkxFRCkgewpAQCAtNDg2MywxNiArNDg3MCwxMyBAQAogewogCWludCBxX2lkeCwgbnVtX3FfdmVjdG9yczsKIAlzdHJ1Y3QgaXhnYmVfcV92ZWN0b3IgKnFfdmVjdG9yOwotCWludCBuYXBpX3ZlY3RvcnM7CiAJaW50ICgqcG9sbCkoc3RydWN0IG5hcGlfc3RydWN0ICosIGludCk7CiAKIAlpZiAoYWRhcHRlci0+ZmxhZ3MgJiBJWEdCRV9GTEFHX01TSVhfRU5BQkxFRCkgewogCQludW1fcV92ZWN0b3JzID0gYWRhcHRlci0+bnVtX21zaXhfdmVjdG9ycyAtIE5PTl9RX1ZFQ1RPUlM7Ci0JCW5hcGlfdmVjdG9ycyA9IGFkYXB0ZXItPm51bV9yeF9xdWV1ZXM7CiAJCXBvbGwgPSAmaXhnYmVfY2xlYW5fcnh0eF9tYW55OwogCX0gZWxzZSB7CiAJCW51bV9xX3ZlY3RvcnMgPSAxOwotCQluYXBpX3ZlY3RvcnMgPSAxOwogCQlwb2xsID0gJml4Z2JlX3BvbGw7CiAJfQogCkBAIC02NjY3LDggKzY2NzEsNiBAQAogCQkJICBzdHJ1Y3QgaXhnYmVfYWRhcHRlciAqYWRhcHRlciwKIAkJCSAgc3RydWN0IGl4Z2JlX3JpbmcgKnR4X3JpbmcpCiB7Ci0Jc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiA9IHR4X3JpbmctPm5ldGRldjsKLQlzdHJ1Y3QgbmV0ZGV2X3F1ZXVlICp0eHE7CiAJdW5zaWduZWQgaW50IGZpcnN0OwogCXVuc2lnbmVkIGludCB0eF9mbGFncyA9IDA7CiAJdTggaGRyX2xlbiA9IDA7CkBAIC02NzY1LDkgKzY3NjcsNiBAQAogCQkvKiBhZGQgdGhlIEFUUiBmaWx0ZXIgaWYgQVRSIGlzIG9uICovCiAJCWlmICh0ZXN0X2JpdChfX0lYR0JFX1RYX0ZESVJfSU5JVF9ET05FLCAmdHhfcmluZy0+c3RhdGUpKQogCQkJaXhnYmVfYXRyKHR4X3JpbmcsIHNrYiwgdHhfZmxhZ3MsIHByb3RvY29sKTsKLQkJdHhxID0gbmV0ZGV2X2dldF90eF9xdWV1ZShuZXRkZXYsIHR4X3JpbmctPnF1ZXVlX2luZGV4KTsKLQkJdHhxLT50eF9ieXRlcyArPSBza2ItPmxlbjsKLQkJdHhxLT50eF9wYWNrZXRzKys7CiAJCWl4Z2JlX3R4X3F1ZXVlKHR4X3JpbmcsIHR4X2ZsYWdzLCBjb3VudCwgc2tiLT5sZW4sIGhkcl9sZW4pOwogCQlpeGdiZV9tYXliZV9zdG9wX3R4KHR4X3JpbmcsIERFU0NfTkVFREVEKTsKIApAQCAtNjkyNSw4ICs2OTI0LDYgQEAKIAlzdHJ1Y3QgaXhnYmVfYWRhcHRlciAqYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CiAJaW50IGk7CiAKLQkvKiBhY2N1cmF0ZSByeC90eCBieXRlcy9wYWNrZXRzIHN0YXRzICovCi0JZGV2X3R4cV9zdGF0c19mb2xkKG5ldGRldiwgc3RhdHMpOwogCXJjdV9yZWFkX2xvY2soKTsKIAlmb3IgKGkgPSAwOyBpIDwgYWRhcHRlci0+bnVtX3J4X3F1ZXVlczsgaSsrKSB7CiAJCXN0cnVjdCBpeGdiZV9yaW5nICpyaW5nID0gQUNDRVNTX09OQ0UoYWRhcHRlci0+cnhfcmluZ1tpXSk7CkBAIC02OTQzLDYgKzY5NDAsMjIgQEAKIAkJCXN0YXRzLT5yeF9ieXRlcyAgICs9IGJ5dGVzOwogCQl9CiAJfQorCisJZm9yIChpID0gMDsgaSA8IGFkYXB0ZXItPm51bV90eF9xdWV1ZXM7IGkrKykgeworCQlzdHJ1Y3QgaXhnYmVfcmluZyAqcmluZyA9IEFDQ0VTU19PTkNFKGFkYXB0ZXItPnR4X3JpbmdbaV0pOworCQl1NjQgYnl0ZXMsIHBhY2tldHM7CisJCXVuc2lnbmVkIGludCBzdGFydDsKKworCQlpZiAocmluZykgeworCQkJZG8geworCQkJCXN0YXJ0ID0gdTY0X3N0YXRzX2ZldGNoX2JlZ2luX2JoKCZyaW5nLT5zeW5jcCk7CisJCQkJcGFja2V0cyA9IHJpbmctPnN0YXRzLnBhY2tldHM7CisJCQkJYnl0ZXMgICA9IHJpbmctPnN0YXRzLmJ5dGVzOworCQkJfSB3aGlsZSAodTY0X3N0YXRzX2ZldGNoX3JldHJ5X2JoKCZyaW5nLT5zeW5jcCwgc3RhcnQpKTsKKwkJCXN0YXRzLT50eF9wYWNrZXRzICs9IHBhY2tldHM7CisJCQlzdGF0cy0+dHhfYnl0ZXMgICArPSBieXRlczsKKwkJfQorCX0KIAlyY3VfcmVhZF91bmxvY2soKTsKIAkvKiBmb2xsb3dpbmcgc3RhdHMgdXBkYXRlZCBieSBpeGdiZV93YXRjaGRvZ190YXNrKCkgKi8KIAlzdGF0cy0+bXVsdGljYXN0CT0gbmV0ZGV2LT5zdGF0cy5tdWx0aWNhc3Q7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9peGdiZS9peGdiZV9zcmlvdi5jIGIvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfc3Jpb3YuYwppbmRleCA0N2IxNTczLi4xODdiM2ExIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9peGdiZS9peGdiZV9zcmlvdi5jCisrKyBiL2RyaXZlcnMvbmV0L2l4Z2JlL2l4Z2JlX3NyaW92LmMKQEAgLTExMCwxMiArMTEwLDEwIEBACiAJcmV0dXJuIGFkYXB0ZXItPmh3Lm1hYy5vcHMuc2V0X3ZmdGEoJmFkYXB0ZXItPmh3LCB2aWQsIHZmLCAoYm9vbClhZGQpOwogfQogCi0KIHN0YXRpYyB2b2lkIGl4Z2JlX3NldF92bW9scihzdHJ1Y3QgaXhnYmVfaHcgKmh3LCB1MzIgdmYsIGJvb2wgYXVwZSkKIHsKIAl1MzIgdm1vbHIgPSBJWEdCRV9SRUFEX1JFRyhodywgSVhHQkVfVk1PTFIodmYpKTsKIAl2bW9sciB8PSAoSVhHQkVfVk1PTFJfUk9NUEUgfAotCQkgIElYR0JFX1ZNT0xSX1JPUEUgfAogCQkgIElYR0JFX1ZNT0xSX0JBTSk7CiAJaWYgKGF1cGUpCiAJCXZtb2xyIHw9IElYR0JFX1ZNT0xSX0FVUEU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9peGdiZS9peGdiZV94NTQwLmMgYi9kcml2ZXJzL25ldC9peGdiZS9peGdiZV94NTQwLmMKaW5kZXggM2E4OTIzOS4uZjI1MThiMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaXhnYmUvaXhnYmVfeDU0MC5jCisrKyBiL2RyaXZlcnMvbmV0L2l4Z2JlL2l4Z2JlX3g1NDAuYwpAQCAtMTMzLDE3ICsxMzMsMTcgQEAKIAl9CiAKIAljdHJsID0gSVhHQkVfUkVBRF9SRUcoaHcsIElYR0JFX0NUUkwpOwotCUlYR0JFX1dSSVRFX1JFRyhodywgSVhHQkVfQ1RSTCwgKGN0cmwgfCBJWEdCRV9DVFJMX1JTVCkpOworCUlYR0JFX1dSSVRFX1JFRyhodywgSVhHQkVfQ1RSTCwgKGN0cmwgfCByZXNldF9iaXQpKTsKIAlJWEdCRV9XUklURV9GTFVTSChodyk7CiAKIAkvKiBQb2xsIGZvciByZXNldCBiaXQgdG8gc2VsZi1jbGVhciBpbmRpY2F0aW5nIHJlc2V0IGlzIGNvbXBsZXRlICovCiAJZm9yIChpID0gMDsgaSA8IDEwOyBpKyspIHsKIAkJdWRlbGF5KDEpOwogCQljdHJsID0gSVhHQkVfUkVBRF9SRUcoaHcsIElYR0JFX0NUUkwpOwotCQlpZiAoIShjdHJsICYgSVhHQkVfQ1RSTF9SU1QpKQorCQlpZiAoIShjdHJsICYgcmVzZXRfYml0KSkKIAkJCWJyZWFrOwogCX0KLQlpZiAoY3RybCAmIElYR0JFX0NUUkxfUlNUKSB7CisJaWYgKGN0cmwgJiByZXNldF9iaXQpIHsKIAkJc3RhdHVzID0gSVhHQkVfRVJSX1JFU0VUX0ZBSUxFRDsKIAkJaHdfZGJnKGh3LCAiUmVzZXQgcG9sbGluZyBmYWlsZWQgdG8gY29tcGxldGUuXG4iKTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9tYWN2dGFwLmMgYi9kcml2ZXJzL25ldC9tYWN2dGFwLmMKaW5kZXggMjE4NDVhZi4uNTkzMzYyMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvbWFjdnRhcC5jCisrKyBiL2RyaXZlcnMvbmV0L21hY3Z0YXAuYwpAQCAtNTg1LDcgKzU4NSw3IEBACiAJcmN1X3JlYWRfbG9ja19iaCgpOwogCXZsYW4gPSByY3VfZGVyZWZlcmVuY2UocS0+dmxhbik7CiAJaWYgKHZsYW4pCi0JCW5ldGRldl9nZXRfdHhfcXVldWUodmxhbi0+ZGV2LCAwKS0+dHhfZHJvcHBlZCsrOworCQl2bGFuLT5kZXYtPnN0YXRzLnR4X2Ryb3BwZWQrKzsKIAlyY3VfcmVhZF91bmxvY2tfYmgoKTsKIAogCXJldHVybiBlcnI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9tbHg0L2NhdGFzLmMgYi9kcml2ZXJzL25ldC9tbHg0L2NhdGFzLmMKaW5kZXggNjhhYWE0Mi4uMzJmOTQ3MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvbWx4NC9jYXRhcy5jCisrKyBiL2RyaXZlcnMvbmV0L21seDQvY2F0YXMuYwpAQCAtMTEzLDcgKzExMyw3IEBACiB2b2lkIG1seDRfc3RhcnRfY2F0YXNfcG9sbChzdHJ1Y3QgbWx4NF9kZXYgKmRldikKIHsKIAlzdHJ1Y3QgbWx4NF9wcml2ICpwcml2ID0gbWx4NF9wcml2KGRldik7Ci0JdW5zaWduZWQgbG9uZyBhZGRyOworCXBoeXNfYWRkcl90IGFkZHI7CiAKIAlJTklUX0xJU1RfSEVBRCgmcHJpdi0+Y2F0YXNfZXJyLmxpc3QpOwogCWluaXRfdGltZXIoJnByaXYtPmNhdGFzX2Vyci50aW1lcik7CkBAIC0xMjQsOCArMTI0LDggQEAKIAogCXByaXYtPmNhdGFzX2Vyci5tYXAgPSBpb3JlbWFwKGFkZHIsIHByaXYtPmZ3LmNhdGFzX3NpemUgKiA0KTsKIAlpZiAoIXByaXYtPmNhdGFzX2Vyci5tYXApIHsKLQkJbWx4NF93YXJuKGRldiwgIkZhaWxlZCB0byBtYXAgaW50ZXJuYWwgZXJyb3IgYnVmZmVyIGF0IDB4JWx4XG4iLAotCQkJICBhZGRyKTsKKwkJbWx4NF93YXJuKGRldiwgIkZhaWxlZCB0byBtYXAgaW50ZXJuYWwgZXJyb3IgYnVmZmVyIGF0IDB4JWxseFxuIiwKKwkJCSAgKHVuc2lnbmVkIGxvbmcgbG9uZykgYWRkcik7CiAJCXJldHVybjsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L21seDQvZW5fbWFpbi5jIGIvZHJpdmVycy9uZXQvbWx4NC9lbl9tYWluLmMKaW5kZXggZjZlMGQ0MC4uMWZmNmNhNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvbWx4NC9lbl9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvbWx4NC9lbl9tYWluLmMKQEAgLTIwMiw3ICsyMDIsOCBAQAogCWlmIChtbHg0X3Vhcl9hbGxvYyhkZXYsICZtZGV2LT5wcml2X3VhcikpCiAJCWdvdG8gZXJyX3BkOwogCi0JbWRldi0+dWFyX21hcCA9IGlvcmVtYXAobWRldi0+cHJpdl91YXIucGZuIDw8IFBBR0VfU0hJRlQsIFBBR0VfU0laRSk7CisJbWRldi0+dWFyX21hcCA9IGlvcmVtYXAoKHBoeXNfYWRkcl90KSBtZGV2LT5wcml2X3Vhci5wZm4gPDwgUEFHRV9TSElGVCwKKwkJCQlQQUdFX1NJWkUpOwogCWlmICghbWRldi0+dWFyX21hcCkKIAkJZ290byBlcnJfdWFyOwogCXNwaW5fbG9ja19pbml0KCZtZGV2LT51YXJfbG9jayk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9tbHg0L21haW4uYyBiL2RyaXZlcnMvbmV0L21seDQvbWFpbi5jCmluZGV4IDc4MmYxMWQuLjI3NjVhM2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L21seDQvbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L21seDQvbWFpbi5jCkBAIC04MjksNyArODI5LDcgQEAKIAkJZ290byBlcnJfdWFyX3RhYmxlX2ZyZWU7CiAJfQogCi0JcHJpdi0+a2FyID0gaW9yZW1hcChwcml2LT5kcml2ZXJfdWFyLnBmbiA8PCBQQUdFX1NISUZULCBQQUdFX1NJWkUpOworCXByaXYtPmthciA9IGlvcmVtYXAoKHBoeXNfYWRkcl90KSBwcml2LT5kcml2ZXJfdWFyLnBmbiA8PCBQQUdFX1NISUZULCBQQUdFX1NJWkUpOwogCWlmICghcHJpdi0+a2FyKSB7CiAJCW1seDRfZXJyKGRldiwgIkNvdWxkbid0IG1hcCBrZXJuZWwgYWNjZXNzIHJlZ2lvbiwgIgogCQkJICJhYm9ydGluZy5cbiIpOwpAQCAtMTI4Niw2ICsxMjg2LDIxIEBACiAJeyBQQ0lfVkRFVklDRShNRUxMQU5PWCwgMHg2NzY0KSB9LCAvKiBNVDI2NDY4IENvbm5lY3RYIEVOIDEwR2lnRSBQQ0llIGdlbjIqLwogCXsgUENJX1ZERVZJQ0UoTUVMTEFOT1gsIDB4Njc0NikgfSwgLyogTVQyNjQzOCBDb25uZWN0WCBFTiA0MEdpZ0UgUENJZSBnZW4yIDVHVC9zICovCiAJeyBQQ0lfVkRFVklDRShNRUxMQU5PWCwgMHg2NzZlKSB9LCAvKiBNVDI2NDc4IENvbm5lY3RYMiA0MEdpZ0UgUENJZSBnZW4yICovCisJeyBQQ0lfVkRFVklDRShNRUxMQU5PWCwgMHgxMDAyKSB9LCAvKiBNVDI1NDAwIEZhbWlseSBbQ29ubmVjdFgtMiBWaXJ0dWFsIEZ1bmN0aW9uXSAqLworCXsgUENJX1ZERVZJQ0UoTUVMTEFOT1gsIDB4MTAwMykgfSwgLyogTVQyNzUwMCBGYW1pbHkgW0Nvbm5lY3RYLTNdICovCisJeyBQQ0lfVkRFVklDRShNRUxMQU5PWCwgMHgxMDA0KSB9LCAvKiBNVDI3NTAwIEZhbWlseSBbQ29ubmVjdFgtMyBWaXJ0dWFsIEZ1bmN0aW9uXSAqLworCXsgUENJX1ZERVZJQ0UoTUVMTEFOT1gsIDB4MTAwNSkgfSwgLyogTVQyNzUxMCBGYW1pbHkgKi8KKwl7IFBDSV9WREVWSUNFKE1FTExBTk9YLCAweDEwMDYpIH0sIC8qIE1UMjc1MTEgRmFtaWx5ICovCisJeyBQQ0lfVkRFVklDRShNRUxMQU5PWCwgMHgxMDA3KSB9LCAvKiBNVDI3NTIwIEZhbWlseSAqLworCXsgUENJX1ZERVZJQ0UoTUVMTEFOT1gsIDB4MTAwOCkgfSwgLyogTVQyNzUyMSBGYW1pbHkgKi8KKwl7IFBDSV9WREVWSUNFKE1FTExBTk9YLCAweDEwMDkpIH0sIC8qIE1UMjc1MzAgRmFtaWx5ICovCisJeyBQQ0lfVkRFVklDRShNRUxMQU5PWCwgMHgxMDBhKSB9LCAvKiBNVDI3NTMxIEZhbWlseSAqLworCXsgUENJX1ZERVZJQ0UoTUVMTEFOT1gsIDB4MTAwYikgfSwgLyogTVQyNzU0MCBGYW1pbHkgKi8KKwl7IFBDSV9WREVWSUNFKE1FTExBTk9YLCAweDEwMGMpIH0sIC8qIE1UMjc1NDEgRmFtaWx5ICovCisJeyBQQ0lfVkRFVklDRShNRUxMQU5PWCwgMHgxMDBkKSB9LCAvKiBNVDI3NTUwIEZhbWlseSAqLworCXsgUENJX1ZERVZJQ0UoTUVMTEFOT1gsIDB4MTAwZSkgfSwgLyogTVQyNzU1MSBGYW1pbHkgKi8KKwl7IFBDSV9WREVWSUNFKE1FTExBTk9YLCAweDEwMGYpIH0sIC8qIE1UMjc1NjAgRmFtaWx5ICovCisJeyBQQ0lfVkRFVklDRShNRUxMQU5PWCwgMHgxMDEwKSB9LCAvKiBNVDI3NTYxIEZhbWlseSAqLwogCXsgMCwgfQogfTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvbWx4NC9tY2cuYyBiL2RyaXZlcnMvbmV0L21seDQvbWNnLmMKaW5kZXggYzRmODhiNy4uNzljZjQyZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvbWx4NC9tY2cuYworKysgYi9kcml2ZXJzL25ldC9tbHg0L21jZy5jCkBAIC05NSw3ICs5NSw4IEBACiAgKiBlbnRyeSBpbiBoYXNoIGNoYWluIGFuZCAqbWdtIGhvbGRzIGVuZCBvZiBoYXNoIGNoYWluLgogICovCiBzdGF0aWMgaW50IGZpbmRfbWdtKHN0cnVjdCBtbHg0X2RldiAqZGV2LAotCQkgICAgdTggKmdpZCwgc3RydWN0IG1seDRfY21kX21haWxib3ggKm1nbV9tYWlsYm94LAorCQkgICAgdTggKmdpZCwgZW51bSBtbHg0X3Byb3RvY29sIHByb3RvY29sLAorCQkgICAgc3RydWN0IG1seDRfY21kX21haWxib3ggKm1nbV9tYWlsYm94LAogCQkgICAgdTE2ICpoYXNoLCBpbnQgKnByZXYsIGludCAqaW5kZXgpCiB7CiAJc3RydWN0IG1seDRfY21kX21haWxib3ggKm1haWxib3g7CkBAIC0xMzQsNyArMTM1LDggQEAKIAkJCXJldHVybiBlcnI7CiAJCX0KIAotCQlpZiAoIW1lbWNtcChtZ20tPmdpZCwgZ2lkLCAxNikpCisJCWlmICghbWVtY21wKG1nbS0+Z2lkLCBnaWQsIDE2KSAmJgorCQkgICAgYmUzMl90b19jcHUobWdtLT5tZW1iZXJzX2NvdW50KSA+PiAzMCA9PSBwcm90b2NvbCkKIAkJCXJldHVybiBlcnI7CiAKIAkJKnByZXYgPSAqaW5kZXg7CkBAIC0xNDYsNyArMTQ4LDcgQEAKIH0KIAogaW50IG1seDRfbXVsdGljYXN0X2F0dGFjaChzdHJ1Y3QgbWx4NF9kZXYgKmRldiwgc3RydWN0IG1seDRfcXAgKnFwLCB1OCBnaWRbMTZdLAotCQkJICBpbnQgYmxvY2tfbWNhc3RfbG9vcGJhY2spCisJCQkgIGludCBibG9ja19tY2FzdF9sb29wYmFjaywgZW51bSBtbHg0X3Byb3RvY29sIHByb3RvY29sKQogewogCXN0cnVjdCBtbHg0X3ByaXYgKnByaXYgPSBtbHg0X3ByaXYoZGV2KTsKIAlzdHJ1Y3QgbWx4NF9jbWRfbWFpbGJveCAqbWFpbGJveDsKQEAgLTE2NSw3ICsxNjcsNyBAQAogCiAJbXV0ZXhfbG9jaygmcHJpdi0+bWNnX3RhYmxlLm11dGV4KTsKIAotCWVyciA9IGZpbmRfbWdtKGRldiwgZ2lkLCBtYWlsYm94LCAmaGFzaCwgJnByZXYsICZpbmRleCk7CisJZXJyID0gZmluZF9tZ20oZGV2LCBnaWQsIHByb3RvY29sLCBtYWlsYm94LCAmaGFzaCwgJnByZXYsICZpbmRleCk7CiAJaWYgKGVycikKIAkJZ290byBvdXQ7CiAKQEAgLTE4Nyw3ICsxODksNyBAQAogCQltZW1jcHkobWdtLT5naWQsIGdpZCwgMTYpOwogCX0KIAotCW1lbWJlcnNfY291bnQgPSBiZTMyX3RvX2NwdShtZ20tPm1lbWJlcnNfY291bnQpOworCW1lbWJlcnNfY291bnQgPSBiZTMyX3RvX2NwdShtZ20tPm1lbWJlcnNfY291bnQpICYgMHhmZmZmZmY7CiAJaWYgKG1lbWJlcnNfY291bnQgPT0gTUxYNF9RUF9QRVJfTUdNKSB7CiAJCW1seDRfZXJyKGRldiwgIk1HTSBhdCBpbmRleCAleCBpcyBmdWxsLlxuIiwgaW5kZXgpOwogCQllcnIgPSAtRU5PTUVNOwpAQCAtMjA3LDcgKzIwOSw3IEBACiAJZWxzZQogCQltZ20tPnFwW21lbWJlcnNfY291bnQrK10gPSBjcHVfdG9fYmUzMihxcC0+cXBuICYgTUdNX1FQTl9NQVNLKTsKIAotCW1nbS0+bWVtYmVyc19jb3VudCAgICAgICA9IGNwdV90b19iZTMyKG1lbWJlcnNfY291bnQpOworCW1nbS0+bWVtYmVyc19jb3VudCA9IGNwdV90b19iZTMyKG1lbWJlcnNfY291bnQgfCAodTMyKSBwcm90b2NvbCA8PCAzMCk7CiAKIAllcnIgPSBtbHg0X1dSSVRFX01DRyhkZXYsIGluZGV4LCBtYWlsYm94KTsKIAlpZiAoZXJyKQpAQCAtMjQyLDcgKzI0NCw4IEBACiB9CiBFWFBPUlRfU1lNQk9MX0dQTChtbHg0X211bHRpY2FzdF9hdHRhY2gpOwogCi1pbnQgbWx4NF9tdWx0aWNhc3RfZGV0YWNoKHN0cnVjdCBtbHg0X2RldiAqZGV2LCBzdHJ1Y3QgbWx4NF9xcCAqcXAsIHU4IGdpZFsxNl0pCitpbnQgbWx4NF9tdWx0aWNhc3RfZGV0YWNoKHN0cnVjdCBtbHg0X2RldiAqZGV2LCBzdHJ1Y3QgbWx4NF9xcCAqcXAsIHU4IGdpZFsxNl0sCisJCQkgIGVudW0gbWx4NF9wcm90b2NvbCBwcm90b2NvbCkKIHsKIAlzdHJ1Y3QgbWx4NF9wcml2ICpwcml2ID0gbWx4NF9wcml2KGRldik7CiAJc3RydWN0IG1seDRfY21kX21haWxib3ggKm1haWxib3g7CkBAIC0yNjAsNyArMjYzLDcgQEAKIAogCW11dGV4X2xvY2soJnByaXYtPm1jZ190YWJsZS5tdXRleCk7CiAKLQllcnIgPSBmaW5kX21nbShkZXYsIGdpZCwgbWFpbGJveCwgJmhhc2gsICZwcmV2LCAmaW5kZXgpOworCWVyciA9IGZpbmRfbWdtKGRldiwgZ2lkLCBwcm90b2NvbCwgbWFpbGJveCwgJmhhc2gsICZwcmV2LCAmaW5kZXgpOwogCWlmIChlcnIpCiAJCWdvdG8gb3V0OwogCkBAIC0yNzAsNyArMjczLDcgQEAKIAkJZ290byBvdXQ7CiAJfQogCi0JbWVtYmVyc19jb3VudCA9IGJlMzJfdG9fY3B1KG1nbS0+bWVtYmVyc19jb3VudCk7CisJbWVtYmVyc19jb3VudCA9IGJlMzJfdG9fY3B1KG1nbS0+bWVtYmVyc19jb3VudCkgJiAweGZmZmZmZjsKIAlmb3IgKGxvYyA9IC0xLCBpID0gMDsgaSA8IG1lbWJlcnNfY291bnQ7ICsraSkKIAkJaWYgKChiZTMyX3RvX2NwdShtZ20tPnFwW2ldKSAmIE1HTV9RUE5fTUFTSykgPT0gcXAtPnFwbikKIAkJCWxvYyA9IGk7CkBAIC0yODIsNyArMjg1LDcgQEAKIAl9CiAKIAotCW1nbS0+bWVtYmVyc19jb3VudCA9IGNwdV90b19iZTMyKC0tbWVtYmVyc19jb3VudCk7CisJbWdtLT5tZW1iZXJzX2NvdW50ID0gY3B1X3RvX2JlMzIoLS1tZW1iZXJzX2NvdW50IHwgKHUzMikgcHJvdG9jb2wgPDwgMzApOwogCW1nbS0+cXBbbG9jXSAgICAgICA9IG1nbS0+cXBbaSAtIDFdOwogCW1nbS0+cXBbaSAtIDFdICAgICA9IDA7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L215cmkxMGdlL215cmkxMGdlLmMgYi9kcml2ZXJzL25ldC9teXJpMTBnZS9teXJpMTBnZS5jCmluZGV4IGEzN2ZjZjEuLmVhNWNmZTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L215cmkxMGdlL215cmkxMGdlLmMKKysrIGIvZHJpdmVycy9uZXQvbXlyaTEwZ2UvbXlyaTEwZ2UuYwpAQCAtMzQwMyw5ICszNDAzLDcgQEAKIAkJcmV0dXJuIC1FSU87CiAJfQogCi0Jc3RhdHVzID0gcGNpX3Jlc3RvcmVfc3RhdGUocGRldik7Ci0JaWYgKHN0YXR1cykKLQkJcmV0dXJuIHN0YXR1czsKKwlwY2lfcmVzdG9yZV9zdGF0ZShwZGV2KTsKIAogCXN0YXR1cyA9IHBjaV9lbmFibGVfZGV2aWNlKHBkZXYpOwogCWlmIChzdGF0dXMpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L25pdS5jIGIvZHJpdmVycy9uZXQvbml1LmMKaW5kZXggMjU0MTMyMS4uOWZiNTlkMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvbml1LmMKKysrIGIvZHJpdmVycy9uZXQvbml1LmMKQEAgLTQ0ODksNiArNDQ4OSw5IEBACiB7CiAJc3RydWN0IG5pdV9wYXJlbnQgKnBhcmVudCA9IG5wLT5wYXJlbnQ7CiAJaW50IGZpcnN0X3J4X2NoYW5uZWwsIGZpcnN0X3R4X2NoYW5uZWw7CisJaW50IG51bV9yeF9yaW5ncywgbnVtX3R4X3JpbmdzOworCXN0cnVjdCByeF9yaW5nX2luZm8gKnJ4X3JpbmdzOworCXN0cnVjdCB0eF9yaW5nX2luZm8gKnR4X3JpbmdzOwogCWludCBpLCBwb3J0LCBlcnI7CiAKIAlwb3J0ID0gbnAtPnBvcnQ7CkBAIC00NDk4LDE4ICs0NTAxLDIxIEBACiAJCWZpcnN0X3R4X2NoYW5uZWwgKz0gcGFyZW50LT50eGNoYW5fcGVyX3BvcnRbaV07CiAJfQogCi0JbnAtPm51bV9yeF9yaW5ncyA9IHBhcmVudC0+cnhjaGFuX3Blcl9wb3J0W3BvcnRdOwotCW5wLT5udW1fdHhfcmluZ3MgPSBwYXJlbnQtPnR4Y2hhbl9wZXJfcG9ydFtwb3J0XTsKKwludW1fcnhfcmluZ3MgPSBwYXJlbnQtPnJ4Y2hhbl9wZXJfcG9ydFtwb3J0XTsKKwludW1fdHhfcmluZ3MgPSBwYXJlbnQtPnR4Y2hhbl9wZXJfcG9ydFtwb3J0XTsKIAotCW5ldGlmX3NldF9yZWFsX251bV9yeF9xdWV1ZXMobnAtPmRldiwgbnAtPm51bV9yeF9yaW5ncyk7Ci0JbmV0aWZfc2V0X3JlYWxfbnVtX3R4X3F1ZXVlcyhucC0+ZGV2LCBucC0+bnVtX3R4X3JpbmdzKTsKLQotCW5wLT5yeF9yaW5ncyA9IGtjYWxsb2MobnAtPm51bV9yeF9yaW5ncywgc2l6ZW9mKHN0cnVjdCByeF9yaW5nX2luZm8pLAotCQkJICAgICAgIEdGUF9LRVJORUwpOworCXJ4X3JpbmdzID0ga2NhbGxvYyhudW1fcnhfcmluZ3MsIHNpemVvZihzdHJ1Y3QgcnhfcmluZ19pbmZvKSwKKwkJCSAgIEdGUF9LRVJORUwpOwogCWVyciA9IC1FTk9NRU07Ci0JaWYgKCFucC0+cnhfcmluZ3MpCisJaWYgKCFyeF9yaW5ncykKIAkJZ290byBvdXRfZXJyOwogCisJbnAtPm51bV9yeF9yaW5ncyA9IG51bV9yeF9yaW5nczsKKwlzbXBfd21iKCk7CisJbnAtPnJ4X3JpbmdzID0gcnhfcmluZ3M7CisKKwluZXRpZl9zZXRfcmVhbF9udW1fcnhfcXVldWVzKG5wLT5kZXYsIG51bV9yeF9yaW5ncyk7CisKIAlmb3IgKGkgPSAwOyBpIDwgbnAtPm51bV9yeF9yaW5nczsgaSsrKSB7CiAJCXN0cnVjdCByeF9yaW5nX2luZm8gKnJwID0gJm5wLT5yeF9yaW5nc1tpXTsKIApAQCAtNDUzOCwxMiArNDU0NCwxOCBAQAogCQkJcmV0dXJuIGVycjsKIAl9CiAKLQlucC0+dHhfcmluZ3MgPSBrY2FsbG9jKG5wLT5udW1fdHhfcmluZ3MsIHNpemVvZihzdHJ1Y3QgdHhfcmluZ19pbmZvKSwKLQkJCSAgICAgICBHRlBfS0VSTkVMKTsKKwl0eF9yaW5ncyA9IGtjYWxsb2MobnVtX3R4X3JpbmdzLCBzaXplb2Yoc3RydWN0IHR4X3JpbmdfaW5mbyksCisJCQkgICBHRlBfS0VSTkVMKTsKIAllcnIgPSAtRU5PTUVNOwotCWlmICghbnAtPnR4X3JpbmdzKQorCWlmICghdHhfcmluZ3MpCiAJCWdvdG8gb3V0X2VycjsKIAorCW5wLT5udW1fdHhfcmluZ3MgPSBudW1fdHhfcmluZ3M7CisJc21wX3dtYigpOworCW5wLT50eF9yaW5ncyA9IHR4X3JpbmdzOworCisJbmV0aWZfc2V0X3JlYWxfbnVtX3R4X3F1ZXVlcyhucC0+ZGV2LCBudW1fdHhfcmluZ3MpOworCiAJZm9yIChpID0gMDsgaSA8IG5wLT5udW1fdHhfcmluZ3M7IGkrKykgewogCQlzdHJ1Y3QgdHhfcmluZ19pbmZvICpycCA9ICZucC0+dHhfcmluZ3NbaV07CiAKQEAgLTYyNDYsMTEgKzYyNTgsMTcgQEAKIHN0YXRpYyB2b2lkIG5pdV9nZXRfcnhfc3RhdHMoc3RydWN0IG5pdSAqbnApCiB7CiAJdW5zaWduZWQgbG9uZyBwa3RzLCBkcm9wcGVkLCBlcnJvcnMsIGJ5dGVzOworCXN0cnVjdCByeF9yaW5nX2luZm8gKnJ4X3JpbmdzOwogCWludCBpOwogCiAJcGt0cyA9IGRyb3BwZWQgPSBlcnJvcnMgPSBieXRlcyA9IDA7CisKKwlyeF9yaW5ncyA9IEFDQ0VTU19PTkNFKG5wLT5yeF9yaW5ncyk7CisJaWYgKCFyeF9yaW5ncykKKwkJZ290byBub19yaW5nczsKKwogCWZvciAoaSA9IDA7IGkgPCBucC0+bnVtX3J4X3JpbmdzOyBpKyspIHsKLQkJc3RydWN0IHJ4X3JpbmdfaW5mbyAqcnAgPSAmbnAtPnJ4X3JpbmdzW2ldOworCQlzdHJ1Y3QgcnhfcmluZ19pbmZvICpycCA9ICZyeF9yaW5nc1tpXTsKIAogCQluaXVfc3luY19yeF9kaXNjYXJkX3N0YXRzKG5wLCBycCwgMCk7CiAKQEAgLTYyNTksNiArNjI3Nyw4IEBACiAJCWRyb3BwZWQgKz0gcnAtPnJ4X2Ryb3BwZWQ7CiAJCWVycm9ycyArPSBycC0+cnhfZXJyb3JzOwogCX0KKworbm9fcmluZ3M6CiAJbnAtPmRldi0+c3RhdHMucnhfcGFja2V0cyA9IHBrdHM7CiAJbnAtPmRldi0+c3RhdHMucnhfYnl0ZXMgPSBieXRlczsKIAlucC0+ZGV2LT5zdGF0cy5yeF9kcm9wcGVkID0gZHJvcHBlZDsKQEAgLTYyNjgsMTYgKzYyODgsMjQgQEAKIHN0YXRpYyB2b2lkIG5pdV9nZXRfdHhfc3RhdHMoc3RydWN0IG5pdSAqbnApCiB7CiAJdW5zaWduZWQgbG9uZyBwa3RzLCBlcnJvcnMsIGJ5dGVzOworCXN0cnVjdCB0eF9yaW5nX2luZm8gKnR4X3JpbmdzOwogCWludCBpOwogCiAJcGt0cyA9IGVycm9ycyA9IGJ5dGVzID0gMDsKKworCXR4X3JpbmdzID0gQUNDRVNTX09OQ0UobnAtPnR4X3JpbmdzKTsKKwlpZiAoIXR4X3JpbmdzKQorCQlnb3RvIG5vX3JpbmdzOworCiAJZm9yIChpID0gMDsgaSA8IG5wLT5udW1fdHhfcmluZ3M7IGkrKykgewotCQlzdHJ1Y3QgdHhfcmluZ19pbmZvICpycCA9ICZucC0+dHhfcmluZ3NbaV07CisJCXN0cnVjdCB0eF9yaW5nX2luZm8gKnJwID0gJnR4X3JpbmdzW2ldOwogCiAJCXBrdHMgKz0gcnAtPnR4X3BhY2tldHM7CiAJCWJ5dGVzICs9IHJwLT50eF9ieXRlczsKIAkJZXJyb3JzICs9IHJwLT50eF9lcnJvcnM7CiAJfQorCitub19yaW5nczoKIAlucC0+ZGV2LT5zdGF0cy50eF9wYWNrZXRzID0gcGt0czsKIAlucC0+ZGV2LT5zdGF0cy50eF9ieXRlcyA9IGJ5dGVzOwogCW5wLT5kZXYtPnN0YXRzLnR4X2Vycm9ycyA9IGVycm9yczsKQEAgLTYyODcsOSArNjMxNSwxMCBAQAogewogCXN0cnVjdCBuaXUgKm5wID0gbmV0ZGV2X3ByaXYoZGV2KTsKIAotCW5pdV9nZXRfcnhfc3RhdHMobnApOwotCW5pdV9nZXRfdHhfc3RhdHMobnApOwotCisJaWYgKG5ldGlmX3J1bm5pbmcoZGV2KSkgeworCQluaXVfZ2V0X3J4X3N0YXRzKG5wKTsKKwkJbml1X2dldF90eF9zdGF0cyhucCk7CisJfQogCXJldHVybiAmZGV2LT5zdGF0czsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvbnM4MzgyMC5jIGIvZHJpdmVycy9uZXQvbnM4MzgyMC5jCmluZGV4IDg0MTM0YzcuLmE0MWIyY2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L25zODM4MjAuYworKysgYi9kcml2ZXJzL25ldC9uczgzODIwLmMKQEAgLTE5ODgsMTIgKzE5ODgsMTEgQEAKIAl9CiAKIAluZGV2ID0gYWxsb2NfZXRoZXJkZXYoc2l6ZW9mKHN0cnVjdCBuczgzODIwKSk7Ci0JZGV2ID0gUFJJVihuZGV2KTsKLQogCWVyciA9IC1FTk9NRU07Ci0JaWYgKCFkZXYpCisJaWYgKCFuZGV2KQogCQlnb3RvIG91dDsKIAorCWRldiA9IFBSSVYobmRldik7CiAJZGV2LT5uZGV2ID0gbmRldjsKIAogCXNwaW5fbG9ja19pbml0KCZkZXYtPnJ4X2luZm8ubG9jayk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9wY2hfZ2JlL3BjaF9nYmVfbWFpbi5jIGIvZHJpdmVycy9uZXQvcGNoX2diZS9wY2hfZ2JlX21haW4uYwppbmRleCBkNzM1NTMwLi40YzlhN2Q0IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9wY2hfZ2JlL3BjaF9nYmVfbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L3BjaF9nYmUvcGNoX2diZV9tYWluLmMKQEAgLTUxOSw3ICs1MTksOSBAQAogCXN0cnVjdCBwY2hfZ2JlX2FkYXB0ZXIgKmFkYXB0ZXI7CiAJYWRhcHRlciA9IGNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3QgcGNoX2diZV9hZGFwdGVyLCByZXNldF90YXNrKTsKIAorCXJ0bmxfbG9jaygpOwogCXBjaF9nYmVfcmVpbml0X2xvY2tlZChhZGFwdGVyKTsKKwlydG5sX3VubG9jaygpOwogfQogCiAvKioKQEAgLTUyOCwxNCArNTMwLDggQEAKICAqLwogdm9pZCBwY2hfZ2JlX3JlaW5pdF9sb2NrZWQoc3RydWN0IHBjaF9nYmVfYWRhcHRlciAqYWRhcHRlcikKIHsKLQlzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2ID0gYWRhcHRlci0+bmV0ZGV2OwotCi0JcnRubF9sb2NrKCk7Ci0JaWYgKG5ldGlmX3J1bm5pbmcobmV0ZGV2KSkgewotCQlwY2hfZ2JlX2Rvd24oYWRhcHRlcik7Ci0JCXBjaF9nYmVfdXAoYWRhcHRlcik7Ci0JfQotCXJ0bmxfdW5sb2NrKCk7CisJcGNoX2diZV9kb3duKGFkYXB0ZXIpOworCXBjaF9nYmVfdXAoYWRhcHRlcik7CiB9CiAKIC8qKgpAQCAtMjI0Nyw3ICsyMjQzLDcgQEAKIAlzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2ID0gcGNpX2dldF9kcnZkYXRhKHBkZXYpOwogCXN0cnVjdCBwY2hfZ2JlX2FkYXB0ZXIgKmFkYXB0ZXIgPSBuZXRkZXZfcHJpdihuZXRkZXYpOwogCi0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKKwljYW5jZWxfd29ya19zeW5jKCZhZGFwdGVyLT5yZXNldF90YXNrKTsKIAl1bnJlZ2lzdGVyX25ldGRldihuZXRkZXYpOwogCiAJcGNoX2diZV9oYWxfcGh5X2h3X3Jlc2V0KCZhZGFwdGVyLT5odyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9wY21jaWEvYXhuZXRfY3MuYyBiL2RyaXZlcnMvbmV0L3BjbWNpYS9heG5ldF9jcy5jCmluZGV4IDFmNDJmNmEuLmQzY2I3NzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3BjbWNpYS9heG5ldF9jcy5jCisrKyBiL2RyaXZlcnMvbmV0L3BjbWNpYS9heG5ldF9jcy5jCkBAIC0xNDg4LDEyICsxNDg4LDEwIEBACiAgICAgCiAJLyogCiAJICogV2FpdCBhIGZ1bGwgVHggdGltZSAoMS4ybXMpICsgc29tZSBndWFyZCB0aW1lLCBOUyBzYXlzIDEuNm1zIHRvdGFsLgotCSAqIEVhcmx5IGRhdGFzaGVldHMgc2FpZCB0byBwb2xsIHRoZSByZXNldCBiaXQsIGJ1dCBub3cgdGhleSBzYXkgdGhhdAotCSAqIGl0ICJpcyBub3QgYSByZWxpYWJsZSBpbmRpY2F0b3IgYW5kIHN1YnNlcXVlbnRseSBzaG91bGQgYmUgaWdub3JlZC4iCi0JICogV2Ugd2FpdCBhdCBsZWFzdCAxMG1zLgorCSAqIFdlIHdhaXQgYXQgbGVhc3QgMm1zLgogCSAqLwogCi0JbWRlbGF5KDEwKTsKKwltZGVsYXkoMik7CiAKIAkvKgogCSAqIFJlc2V0IFJCQ1JbMDFdIGJhY2sgdG8gemVybyBhcyBwZXIgbWFnaWMgaW5jYW50YXRpb24uCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9yODE2OS5jIGIvZHJpdmVycy9uZXQvcjgxNjkuYwppbmRleCBiYjg2NDVhLi41OWNjZjBjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9yODE2OS5jCisrKyBiL2RyaXZlcnMvbmV0L3I4MTY5LmMKQEAgLTU1NCw2ICs1NTQsOCBAQAogCXN0cnVjdCBtaWlfaWZfaW5mbyBtaWk7CiAJc3RydWN0IHJ0bDgxNjlfY291bnRlcnMgY291bnRlcnM7CiAJdTMyIHNhdmVkX3dvbG9wdHM7CisKKwljb25zdCBzdHJ1Y3QgZmlybXdhcmUgKmZ3OwogfTsKIAogTU9EVUxFX0FVVEhPUigiUmVhbHRlayBhbmQgdGhlIExpbnV4IHI4MTY5IGNyZXcgPG5ldGRldkB2Z2VyLmtlcm5lbC5vcmc+Iik7CkBAIC05NzEsNyArOTczLDggQEAKIAkJaWYgKHBtKQogCQkJcG1fcmVxdWVzdF9yZXN1bWUoJnRwLT5wY2lfZGV2LT5kZXYpOwogCQluZXRpZl9jYXJyaWVyX29uKGRldik7Ci0JCW5ldGlmX2luZm8odHAsIGlmdXAsIGRldiwgImxpbmsgdXBcbiIpOworCQlpZiAobmV0X3JhdGVsaW1pdCgpKQorCQkJbmV0aWZfaW5mbyh0cCwgaWZ1cCwgZGV2LCAibGluayB1cFxuIik7CiAJfSBlbHNlIHsKIAkJbmV0aWZfY2Fycmllcl9vZmYoZGV2KTsKIAkJbmV0aWZfaW5mbyh0cCwgaWZkb3duLCBkZXYsICJsaW5rIGRvd25cbiIpOwpAQCAtMTc2Niw2ICsxNzY5LDI5IEBACiAJfQogfQogCitzdGF0aWMgdm9pZCBydGxfcmVsZWFzZV9maXJtd2FyZShzdHJ1Y3QgcnRsODE2OV9wcml2YXRlICp0cCkKK3sKKwlyZWxlYXNlX2Zpcm13YXJlKHRwLT5mdyk7CisJdHAtPmZ3ID0gTlVMTDsKK30KKworc3RhdGljIGludCBydGxfYXBwbHlfZmlybXdhcmUoc3RydWN0IHJ0bDgxNjlfcHJpdmF0ZSAqdHAsIGNvbnN0IGNoYXIgKmZ3X25hbWUpCit7CisJY29uc3Qgc3RydWN0IGZpcm13YXJlICoqZncgPSAmdHAtPmZ3OworCWludCByYyA9ICEqZnc7CisKKwlpZiAocmMpIHsKKwkJcmMgPSByZXF1ZXN0X2Zpcm13YXJlKGZ3LCBmd19uYW1lLCAmdHAtPnBjaV9kZXYtPmRldik7CisJCWlmIChyYyA8IDApCisJCQlnb3RvIG91dDsKKwl9CisKKwkvKiBUT0RPOiByZWxlYXNlIGZpcm13YXJlIG9uY2UgcnRsX3BoeV93cml0ZV9mdyBzaWduYWxzIGZhaWx1cmVzLiAqLworCXJ0bF9waHlfd3JpdGVfZncodHAsICpmdyk7CitvdXQ6CisJcmV0dXJuIHJjOworfQorCiBzdGF0aWMgdm9pZCBydGw4MTY5c19od19waHlfY29uZmlnKHN0cnVjdCBydGw4MTY5X3ByaXZhdGUgKnRwKQogewogCXN0YXRpYyBjb25zdCBzdHJ1Y3QgcGh5X3JlZyBwaHlfcmVnX2luaXRbXSA9IHsKQEAgLTIxMzksNyArMjE2NSw2IEBACiAJCXsgMHgwZCwgMHhmODgwIH0KIAl9OwogCXZvaWQgX19pb21lbSAqaW9hZGRyID0gdHAtPm1taW9fYWRkcjsKLQljb25zdCBzdHJ1Y3QgZmlybXdhcmUgKmZ3OwogCiAJcnRsX3dyaXRlcGh5X2JhdGNoKHRwLCBwaHlfcmVnX2luaXRfMCwgQVJSQVlfU0laRShwaHlfcmVnX2luaXRfMCkpOwogCkBAIC0yMjAzLDExICsyMjI4LDggQEAKIAogCXJ0bF93cml0ZXBoeSh0cCwgMHgxZiwgMHgwMDA1KTsKIAlydGxfd3JpdGVwaHkodHAsIDB4MDUsIDB4MDAxYik7Ci0JaWYgKHJ0bF9yZWFkcGh5KHRwLCAweDA2KSA9PSAweGJmMDAgJiYKLQkgICAgcmVxdWVzdF9maXJtd2FyZSgmZncsIEZJUk1XQVJFXzgxNjhEXzEsICZ0cC0+cGNpX2Rldi0+ZGV2KSA9PSAwKSB7Ci0JCXJ0bF9waHlfd3JpdGVfZncodHAsIGZ3KTsKLQkJcmVsZWFzZV9maXJtd2FyZShmdyk7Ci0JfSBlbHNlIHsKKwlpZiAoKHJ0bF9yZWFkcGh5KHRwLCAweDA2KSAhPSAweGJmMDApIHx8CisJICAgIChydGxfYXBwbHlfZmlybXdhcmUodHAsIEZJUk1XQVJFXzgxNjhEXzEpIDwgMCkpIHsKIAkJbmV0aWZfd2Fybih0cCwgcHJvYmUsIHRwLT5kZXYsICJ1bmFibGUgdG8gYXBwbHkgZmlybXdhcmUgcGF0Y2hcbiIpOwogCX0KIApAQCAtMjI1Nyw3ICsyMjc5LDYgQEAKIAkJeyAweDBkLCAweGY4ODAgfQogCX07CiAJdm9pZCBfX2lvbWVtICppb2FkZHIgPSB0cC0+bW1pb19hZGRyOwotCWNvbnN0IHN0cnVjdCBmaXJtd2FyZSAqZnc7CiAKIAlydGxfd3JpdGVwaHlfYmF0Y2godHAsIHBoeV9yZWdfaW5pdF8wLCBBUlJBWV9TSVpFKHBoeV9yZWdfaW5pdF8wKSk7CiAKQEAgLTIzMTIsMTEgKzIzMzMsOCBAQAogCiAJcnRsX3dyaXRlcGh5KHRwLCAweDFmLCAweDAwMDUpOwogCXJ0bF93cml0ZXBoeSh0cCwgMHgwNSwgMHgwMDFiKTsKLQlpZiAocnRsX3JlYWRwaHkodHAsIDB4MDYpID09IDB4YjMwMCAmJgotCSAgICByZXF1ZXN0X2Zpcm13YXJlKCZmdywgRklSTVdBUkVfODE2OERfMiwgJnRwLT5wY2lfZGV2LT5kZXYpID09IDApIHsKLQkJcnRsX3BoeV93cml0ZV9mdyh0cCwgZncpOwotCQlyZWxlYXNlX2Zpcm13YXJlKGZ3KTsKLQl9IGVsc2UgeworCWlmICgocnRsX3JlYWRwaHkodHAsIDB4MDYpICE9IDB4YjMwMCkgfHwKKwkgICAgKHJ0bF9hcHBseV9maXJtd2FyZSh0cCwgRklSTVdBUkVfODE2OERfMikgPCAwKSkgewogCQluZXRpZl93YXJuKHRwLCBwcm9iZSwgdHAtPmRldiwgInVuYWJsZSB0byBhcHBseSBmaXJtd2FyZSBwYXRjaFxuIik7CiAJfQogCkBAIC0zMjAwLDYgKzMyMTgsOCBAQAogCiAJY2FuY2VsX2RlbGF5ZWRfd29ya19zeW5jKCZ0cC0+dGFzayk7CiAKKwlydGxfcmVsZWFzZV9maXJtd2FyZSh0cCk7CisKIAl1bnJlZ2lzdGVyX25ldGRldihkZXYpOwogCiAJaWYgKHBjaV9kZXZfcnVuX3dha2UocGRldikpCkBAIC0zNzM4LDcgKzM3NTgsOCBAQAogCVJUTF9XMTYoSW50ck1pdGlnYXRlLCAweDUxNTEpOwogCiAJLyogV29yayBhcm91bmQgZm9yIFJ4RklGTyBvdmVyZmxvdy4gKi8KLQlpZiAodHAtPm1hY192ZXJzaW9uID09IFJUTF9HSUdBX01BQ19WRVJfMTEpIHsKKwlpZiAodHAtPm1hY192ZXJzaW9uID09IFJUTF9HSUdBX01BQ19WRVJfMTEgfHwKKwkgICAgdHAtPm1hY192ZXJzaW9uID09IFJUTF9HSUdBX01BQ19WRVJfMjIpIHsKIAkJdHAtPmludHJfZXZlbnQgfD0gUnhGSUZPT3ZlciB8IFBDU1RpbWVvdXQ7CiAJCXRwLT5pbnRyX2V2ZW50ICY9IH5SeE92ZXJmbG93OwogCX0KQEAgLTQ2MjAsMTIgKzQ2NDEsMzMgQEAKIAkJCWJyZWFrOwogCQl9CiAKLQkJLyogV29yayBhcm91bmQgZm9yIHJ4IGZpZm8gb3ZlcmZsb3cgKi8KLQkJaWYgKHVubGlrZWx5KHN0YXR1cyAmIFJ4RklGT092ZXIpICYmCi0JCSh0cC0+bWFjX3ZlcnNpb24gPT0gUlRMX0dJR0FfTUFDX1ZFUl8xMSkpIHsKLQkJCW5ldGlmX3N0b3BfcXVldWUoZGV2KTsKLQkJCXJ0bDgxNjlfdHhfdGltZW91dChkZXYpOwotCQkJYnJlYWs7CisJCWlmICh1bmxpa2VseShzdGF0dXMgJiBSeEZJRk9PdmVyKSkgeworCQkJc3dpdGNoICh0cC0+bWFjX3ZlcnNpb24pIHsKKwkJCS8qIFdvcmsgYXJvdW5kIGZvciByeCBmaWZvIG92ZXJmbG93ICovCisJCQljYXNlIFJUTF9HSUdBX01BQ19WRVJfMTE6CisJCQljYXNlIFJUTF9HSUdBX01BQ19WRVJfMjI6CisJCQljYXNlIFJUTF9HSUdBX01BQ19WRVJfMjY6CisJCQkJbmV0aWZfc3RvcF9xdWV1ZShkZXYpOworCQkJCXJ0bDgxNjlfdHhfdGltZW91dChkZXYpOworCQkJCWdvdG8gZG9uZTsKKwkJCS8qIFRlc3RlcnMgbmVlZGVkLiAqLworCQkJY2FzZSBSVExfR0lHQV9NQUNfVkVSXzE3OgorCQkJY2FzZSBSVExfR0lHQV9NQUNfVkVSXzE5OgorCQkJY2FzZSBSVExfR0lHQV9NQUNfVkVSXzIwOgorCQkJY2FzZSBSVExfR0lHQV9NQUNfVkVSXzIxOgorCQkJY2FzZSBSVExfR0lHQV9NQUNfVkVSXzIzOgorCQkJY2FzZSBSVExfR0lHQV9NQUNfVkVSXzI0OgorCQkJY2FzZSBSVExfR0lHQV9NQUNfVkVSXzI3OgorCQkJY2FzZSBSVExfR0lHQV9NQUNfVkVSXzI4OgorCQkJLyogRXhwZXJpbWVudGFsIHNjaWVuY2UuIFBrdGdlbiBwcm9vZi4gKi8KKwkJCWNhc2UgUlRMX0dJR0FfTUFDX1ZFUl8xMjoKKwkJCWNhc2UgUlRMX0dJR0FfTUFDX1ZFUl8yNToKKwkJCQlpZiAoc3RhdHVzID09IFJ4RklGT092ZXIpCisJCQkJCWdvdG8gZG9uZTsKKwkJCQlicmVhazsKKwkJCWRlZmF1bHQ6CisJCQkJYnJlYWs7CisJCQl9CiAJCX0KIAogCQlpZiAodW5saWtlbHkoc3RhdHVzICYgU1lTRXJyKSkgewpAQCAtNDY2MSw3ICs0NzAzLDcgQEAKIAkJCShzdGF0dXMgJiBSeEZJRk9PdmVyKSA/IChzdGF0dXMgfCBSeE92ZXJmbG93KSA6IHN0YXR1cyk7CiAJCXN0YXR1cyA9IFJUTF9SMTYoSW50clN0YXR1cyk7CiAJfQotCitkb25lOgogCXJldHVybiBJUlFfUkVUVkFMKGhhbmRsZWQpOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9zZmMvZWZ4LmMgYi9kcml2ZXJzL25ldC9zZmMvZWZ4LmMKaW5kZXggNzExNDQ5Yy4uMDAyYmFjNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc2ZjL2VmeC5jCisrKyBiL2RyaXZlcnMvbmV0L3NmYy9lZnguYwpAQCAtMTE1Myw2ICsxMTUzLDkgQEAKIAlpbnQgY291bnQ7CiAJaW50IGNwdTsKIAorCWlmIChyc3NfY3B1cykKKwkJcmV0dXJuIHJzc19jcHVzOworCiAJaWYgKHVubGlrZWx5KCF6YWxsb2NfY3B1bWFza192YXIoJmNvcmVfbWFzaywgR0ZQX0tFUk5FTCkpKSB7CiAJCXByaW50ayhLRVJOX1dBUk5JTkcKIAkJICAgICAgICJzZmM6IFJTUyBkaXNhYmxlZCBkdWUgdG8gYWxsb2NhdGlvbiBmYWlsdXJlXG4iKTsKQEAgLTEyNjYsMjcgKzEyNjksMTggQEAKIAllZngtPmxlZ2FjeV9pcnEgPSAwOwogfQogCi1zdHJ1Y3QgZWZ4X3R4X3F1ZXVlICoKLWVmeF9nZXRfdHhfcXVldWUoc3RydWN0IGVmeF9uaWMgKmVmeCwgdW5zaWduZWQgaW5kZXgsIHVuc2lnbmVkIHR5cGUpCi17Ci0JdW5zaWduZWQgdHhfY2hhbm5lbF9vZmZzZXQgPQotCQlzZXBhcmF0ZV90eF9jaGFubmVscyA/IGVmeC0+bl9jaGFubmVscyAtIGVmeC0+bl90eF9jaGFubmVscyA6IDA7Ci0JRUZYX0JVR19PTl9QQVJBTk9JRChpbmRleCA+PSBlZngtPm5fdHhfY2hhbm5lbHMgfHwKLQkJCSAgICB0eXBlID49IEVGWF9UWFFfVFlQRVMpOwotCXJldHVybiAmZWZ4LT5jaGFubmVsW3R4X2NoYW5uZWxfb2Zmc2V0ICsgaW5kZXhdLT50eF9xdWV1ZVt0eXBlXTsKLX0KLQogc3RhdGljIHZvaWQgZWZ4X3NldF9jaGFubmVscyhzdHJ1Y3QgZWZ4X25pYyAqZWZ4KQogewogCXN0cnVjdCBlZnhfY2hhbm5lbCAqY2hhbm5lbDsKIAlzdHJ1Y3QgZWZ4X3R4X3F1ZXVlICp0eF9xdWV1ZTsKLQl1bnNpZ25lZCB0eF9jaGFubmVsX29mZnNldCA9CisKKwllZngtPnR4X2NoYW5uZWxfb2Zmc2V0ID0KIAkJc2VwYXJhdGVfdHhfY2hhbm5lbHMgPyBlZngtPm5fY2hhbm5lbHMgLSBlZngtPm5fdHhfY2hhbm5lbHMgOiAwOwogCiAJLyogQ2hhbm5lbCBwb2ludGVycyB3ZXJlIHNldCBpbiBlZnhfaW5pdF9zdHJ1Y3QoKSBidXQgd2Ugbm93CiAJICogbmVlZCB0byBjbGVhciB0aGVtIGZvciBUWCBxdWV1ZXMgaW4gYW55IFJYLW9ubHkgY2hhbm5lbHMuICovCiAJZWZ4X2Zvcl9lYWNoX2NoYW5uZWwoY2hhbm5lbCwgZWZ4KSB7Ci0JCWlmIChjaGFubmVsLT5jaGFubmVsIC0gdHhfY2hhbm5lbF9vZmZzZXQgPj0KKwkJaWYgKGNoYW5uZWwtPmNoYW5uZWwgLSBlZngtPnR4X2NoYW5uZWxfb2Zmc2V0ID49CiAJCSAgICBlZngtPm5fdHhfY2hhbm5lbHMpIHsKIAkJCWVmeF9mb3JfZWFjaF9jaGFubmVsX3R4X3F1ZXVlKHR4X3F1ZXVlLCBjaGFubmVsKQogCQkJCXR4X3F1ZXVlLT5jaGFubmVsID0gTlVMTDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3NmYy9mYWxjb24uYyBiL2RyaXZlcnMvbmV0L3NmYy9mYWxjb24uYwppbmRleCA3MGU0ZjdkLi42MWRkZDJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9zZmMvZmFsY29uLmMKKysrIGIvZHJpdmVycy9uZXQvc2ZjL2ZhbGNvbi5jCkBAIC0xMTA3LDIyICsxMTA3LDkgQEAKIAogCS8qIFJlc3RvcmUgUENJIGNvbmZpZ3VyYXRpb24gaWYgbmVlZGVkICovCiAJaWYgKG1ldGhvZCA9PSBSRVNFVF9UWVBFX1dPUkxEKSB7Ci0JCWlmIChlZnhfbmljX2lzX2R1YWxfZnVuYyhlZngpKSB7Ci0JCQlyYyA9IHBjaV9yZXN0b3JlX3N0YXRlKG5pY19kYXRhLT5wY2lfZGV2Mik7Ci0JCQlpZiAocmMpIHsKLQkJCQluZXRpZl9lcnIoZWZ4LCBkcnYsIGVmeC0+bmV0X2RldiwKLQkJCQkJICAiZmFpbGVkIHRvIHJlc3RvcmUgUENJIGNvbmZpZyBmb3IgIgotCQkJCQkgICJ0aGUgc2Vjb25kYXJ5IGZ1bmN0aW9uXG4iKTsKLQkJCQlnb3RvIGZhaWwzOwotCQkJfQotCQl9Ci0JCXJjID0gcGNpX3Jlc3RvcmVfc3RhdGUoZWZ4LT5wY2lfZGV2KTsKLQkJaWYgKHJjKSB7Ci0JCQluZXRpZl9lcnIoZWZ4LCBkcnYsIGVmeC0+bmV0X2RldiwKLQkJCQkgICJmYWlsZWQgdG8gcmVzdG9yZSBQQ0kgY29uZmlnIGZvciB0aGUgIgotCQkJCSAgInByaW1hcnkgZnVuY3Rpb25cbiIpOwotCQkJZ290byBmYWlsNDsKLQkJfQorCQlpZiAoZWZ4X25pY19pc19kdWFsX2Z1bmMoZWZ4KSkKKwkJCXBjaV9yZXN0b3JlX3N0YXRlKG5pY19kYXRhLT5wY2lfZGV2Mik7CisJCXBjaV9yZXN0b3JlX3N0YXRlKGVmeC0+cGNpX2Rldik7CiAJCW5ldGlmX2RiZyhlZngsIGRydiwgZWZ4LT5uZXRfZGV2LAogCQkJICAic3VjY2Vzc2Z1bGx5IHJlc3RvcmVkIFBDSSBjb25maWdcbiIpOwogCX0KQEAgLTExMzMsNyArMTEyMCw3IEBACiAJCXJjID0gLUVUSU1FRE9VVDsKIAkJbmV0aWZfZXJyKGVmeCwgaHcsIGVmeC0+bmV0X2RldiwKIAkJCSAgInRpbWVkIG91dCB3YWl0aW5nIGZvciBoYXJkd2FyZSByZXNldFxuIik7Ci0JCWdvdG8gZmFpbDU7CisJCWdvdG8gZmFpbDM7CiAJfQogCW5ldGlmX2RiZyhlZngsIGh3LCBlZngtPm5ldF9kZXYsICJoYXJkd2FyZSByZXNldCBjb21wbGV0ZVxuIik7CiAKQEAgLTExNDEsMTEgKzExMjgsOSBAQAogCiAJLyogcGNpX3NhdmVfc3RhdGUoKSBhbmQgcGNpX3Jlc3RvcmVfc3RhdGUoKSBNVVNUIGJlIGNhbGxlZCBpbiBwYWlycyAqLwogZmFpbDI6Ci1mYWlsMzoKIAlwY2lfcmVzdG9yZV9zdGF0ZShlZngtPnBjaV9kZXYpOwogZmFpbDE6Ci1mYWlsNDoKLWZhaWw1OgorZmFpbDM6CiAJcmV0dXJuIHJjOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9zZmMvbmV0X2RyaXZlci5oIGIvZHJpdmVycy9uZXQvc2ZjL25ldF9kcml2ZXIuaAppbmRleCBiZGNlNjZkLi4yOGRmODY2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9zZmMvbmV0X2RyaXZlci5oCisrKyBiL2RyaXZlcnMvbmV0L3NmYy9uZXRfZHJpdmVyLmgKQEAgLTczNSw2ICs3MzUsNyBAQAogCXVuc2lnbmVkIG5leHRfYnVmZmVyX3RhYmxlOwogCXVuc2lnbmVkIG5fY2hhbm5lbHM7CiAJdW5zaWduZWQgbl9yeF9jaGFubmVsczsKKwl1bnNpZ25lZCB0eF9jaGFubmVsX29mZnNldDsKIAl1bnNpZ25lZCBuX3R4X2NoYW5uZWxzOwogCXVuc2lnbmVkIGludCByeF9idWZmZXJfbGVuOwogCXVuc2lnbmVkIGludCByeF9idWZmZXJfb3JkZXI7CkBAIC05MjksOCArOTMwLDEzIEBACiAJICAgICBfY2hhbm5lbCA9IChfY2hhbm5lbC0+Y2hhbm5lbCArIDEgPCAoX2VmeCktPm5fY2hhbm5lbHMpID8JXAogCQkgICAgIChfZWZ4KS0+Y2hhbm5lbFtfY2hhbm5lbC0+Y2hhbm5lbCArIDFdIDogTlVMTCkKIAotZXh0ZXJuIHN0cnVjdCBlZnhfdHhfcXVldWUgKgotZWZ4X2dldF90eF9xdWV1ZShzdHJ1Y3QgZWZ4X25pYyAqZWZ4LCB1bnNpZ25lZCBpbmRleCwgdW5zaWduZWQgdHlwZSk7CitzdGF0aWMgaW5saW5lIHN0cnVjdCBlZnhfdHhfcXVldWUgKgorZWZ4X2dldF90eF9xdWV1ZShzdHJ1Y3QgZWZ4X25pYyAqZWZ4LCB1bnNpZ25lZCBpbmRleCwgdW5zaWduZWQgdHlwZSkKK3sKKwlFRlhfQlVHX09OX1BBUkFOT0lEKGluZGV4ID49IGVmeC0+bl90eF9jaGFubmVscyB8fAorCQkJICAgIHR5cGUgPj0gRUZYX1RYUV9UWVBFUyk7CisJcmV0dXJuICZlZngtPmNoYW5uZWxbZWZ4LT50eF9jaGFubmVsX29mZnNldCArIGluZGV4XS0+dHhfcXVldWVbdHlwZV07Cit9CiAKIHN0YXRpYyBpbmxpbmUgc3RydWN0IGVmeF90eF9xdWV1ZSAqCiBlZnhfY2hhbm5lbF9nZXRfdHhfcXVldWUoc3RydWN0IGVmeF9jaGFubmVsICpjaGFubmVsLCB1bnNpZ25lZCB0eXBlKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc2lzOTAwLmMgYi9kcml2ZXJzL25ldC9zaXM5MDAuYwppbmRleCA1OTc2ZDFkLi42NDBlMzY4IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9zaXM5MDAuYworKysgYi9kcml2ZXJzL25ldC9zaXM5MDAuYwpAQCAtMTc3Nyw2ICsxNzc3LDcgQEAKIAkJCQkJICAgICAgImN1cl9yeDolNC40ZCwgZGlydHlfcng6JTQuNGRcbiIsCiAJCQkJCSAgICAgIG5ldF9kZXYtPm5hbWUsIHNpc19wcml2LT5jdXJfcngsCiAJCQkJCSAgICAgIHNpc19wcml2LT5kaXJ0eV9yeCk7CisJCQkJZGV2X2tmcmVlX3NrYihza2IpOwogCQkJCWJyZWFrOwogCQkJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC90ZzMuYyBiL2RyaXZlcnMvbmV0L3RnMy5jCmluZGV4IDc4NDFhOGYuLjkzYjMyZDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3RnMy5jCisrKyBiL2RyaXZlcnMvbmV0L3RnMy5jCkBAIC02MCwxMiArNjAsNiBAQAogI2RlZmluZSBCQVJfMAkwCiAjZGVmaW5lIEJBUl8yCTIKIAotI2lmIGRlZmluZWQoQ09ORklHX1ZMQU5fODAyMVEpIHx8IGRlZmluZWQoQ09ORklHX1ZMQU5fODAyMVFfTU9EVUxFKQotI2RlZmluZSBURzNfVkxBTl9UQUdfVVNFRCAxCi0jZWxzZQotI2RlZmluZSBURzNfVkxBTl9UQUdfVVNFRCAwCi0jZW5kaWYKLQogI2luY2x1ZGUgInRnMy5oIgogCiAjZGVmaW5lIERSVl9NT0RVTEVfTkFNRQkJInRnMyIKQEAgLTEzNCw5ICsxMjgsNiBAQAogCQkJCSBURzNfVFhfUklOR19TSVpFKQogI2RlZmluZSBORVhUX1RYKE4pCQkoKChOKSArIDEpICYgKFRHM19UWF9SSU5HX1NJWkUgLSAxKSkKIAotI2RlZmluZSBURzNfUlhfRE1BX0FMSUdOCQkxNgotI2RlZmluZSBURzNfUlhfSEVBRFJPT00JCQlBTElHTihWTEFOX0hMRU4sIFRHM19SWF9ETUFfQUxJR04pCi0KICNkZWZpbmUgVEczX0RNQV9CWVRFX0VOQUIJCTY0CiAKICNkZWZpbmUgVEczX1JYX1NURF9ETUFfU1oJCTE1MzYKQEAgLTQ3MjIsOCArNDcxMyw2IEBACiAJCXN0cnVjdCBza19idWZmICpza2I7CiAJCWRtYV9hZGRyX3QgZG1hX2FkZHI7CiAJCXUzMiBvcGFxdWVfa2V5LCBkZXNjX2lkeCwgKnBvc3RfcHRyOwotCQlib29sIGh3X3ZsYW4gX19tYXliZV91bnVzZWQgPSBmYWxzZTsKLQkJdTE2IHZ0YWcgX19tYXliZV91bnVzZWQgPSAwOwogCiAJCWRlc2NfaWR4ID0gZGVzYy0+b3BhcXVlICYgUlhEX09QQVFVRV9JTkRFWF9NQVNLOwogCQlvcGFxdWVfa2V5ID0gZGVzYy0+b3BhcXVlICYgUlhEX09QQVFVRV9SSU5HX01BU0s7CkBAIC00NzgyLDEyICs0NzcxLDEyIEBACiAJCQl0ZzNfcmVjeWNsZV9yeCh0bmFwaSwgdHByLCBvcGFxdWVfa2V5LAogCQkJCSAgICAgICBkZXNjX2lkeCwgKnBvc3RfcHRyKTsKIAotCQkJY29weV9za2IgPSBuZXRkZXZfYWxsb2Nfc2tiKHRwLT5kZXYsIGxlbiArIFZMQU5fSExFTiArCisJCQljb3B5X3NrYiA9IG5ldGRldl9hbGxvY19za2IodHAtPmRldiwgbGVuICsKIAkJCQkJCSAgICBURzNfUkFXX0lQX0FMSUdOKTsKIAkJCWlmIChjb3B5X3NrYiA9PSBOVUxMKQogCQkJCWdvdG8gZHJvcF9pdF9ub19yZWN5Y2xlOwogCi0JCQlza2JfcmVzZXJ2ZShjb3B5X3NrYiwgVEczX1JBV19JUF9BTElHTiArIFZMQU5fSExFTik7CisJCQlza2JfcmVzZXJ2ZShjb3B5X3NrYiwgVEczX1JBV19JUF9BTElHTik7CiAJCQlza2JfcHV0KGNvcHlfc2tiLCBsZW4pOwogCQkJcGNpX2RtYV9zeW5jX3NpbmdsZV9mb3JfY3B1KHRwLT5wZGV2LCBkbWFfYWRkciwgbGVuLCBQQ0lfRE1BX0ZST01ERVZJQ0UpOwogCQkJc2tiX2NvcHlfZnJvbV9saW5lYXJfZGF0YShza2IsIGNvcHlfc2tiLT5kYXRhLCBsZW4pOwpAQCAtNDgxNCwzMCArNDgwMywxMSBAQAogCQl9CiAKIAkJaWYgKGRlc2MtPnR5cGVfZmxhZ3MgJiBSWERfRkxBR19WTEFOICYmCi0JCSAgICAhKHRwLT5yeF9tb2RlICYgUlhfTU9ERV9LRUVQX1ZMQU5fVEFHKSkgewotCQkJdnRhZyA9IGRlc2MtPmVycl92bGFuICYgUlhEX1ZMQU5fTUFTSzsKLSNpZiBURzNfVkxBTl9UQUdfVVNFRAotCQkJaWYgKHRwLT52bGdycCkKLQkJCQlod192bGFuID0gdHJ1ZTsKLQkJCWVsc2UKLSNlbmRpZgotCQkJewotCQkJCXN0cnVjdCB2bGFuX2V0aGhkciAqdmUgPSAoc3RydWN0IHZsYW5fZXRoaGRyICopCi0JCQkJCQkgICAgX19za2JfcHVzaChza2IsIFZMQU5fSExFTik7CisJCSAgICAhKHRwLT5yeF9tb2RlICYgUlhfTU9ERV9LRUVQX1ZMQU5fVEFHKSkKKwkJCV9fdmxhbl9od2FjY2VsX3B1dF90YWcoc2tiLAorCQkJCQkgICAgICAgZGVzYy0+ZXJyX3ZsYW4gJiBSWERfVkxBTl9NQVNLKTsKIAotCQkJCW1lbW1vdmUodmUsIHNrYi0+ZGF0YSArIFZMQU5fSExFTiwKLQkJCQkJRVRIX0FMRU4gKiAyKTsKLQkJCQl2ZS0+aF92bGFuX3Byb3RvID0gaHRvbnMoRVRIX1BfODAyMVEpOwotCQkJCXZlLT5oX3ZsYW5fVENJID0gaHRvbnModnRhZyk7Ci0JCQl9Ci0JCX0KLQotI2lmIFRHM19WTEFOX1RBR19VU0VECi0JCWlmIChod192bGFuKQotCQkJdmxhbl9ncm9fcmVjZWl2ZSgmdG5hcGktPm5hcGksIHRwLT52bGdycCwgdnRhZywgc2tiKTsKLQkJZWxzZQotI2VuZGlmCi0JCQluYXBpX2dyb19yZWNlaXZlKCZ0bmFwaS0+bmFwaSwgc2tiKTsKKwkJbmFwaV9ncm9fcmVjZWl2ZSgmdG5hcGktPm5hcGksIHNrYik7CiAKIAkJcmVjZWl2ZWQrKzsKIAkJYnVkZ2V0LS07CkBAIC01NzQwLDExICs1NzEwLDkgQEAKIAkJYmFzZV9mbGFncyB8PSBUWERfRkxBR19UQ1BVRFBfQ1NVTTsKIAl9CiAKLSNpZiBURzNfVkxBTl9UQUdfVVNFRAogCWlmICh2bGFuX3R4X3RhZ19wcmVzZW50KHNrYikpCiAJCWJhc2VfZmxhZ3MgfD0gKFRYRF9GTEFHX1ZMQU4gfAogCQkJICAgICAgICh2bGFuX3R4X3RhZ19nZXQoc2tiKSA8PCAxNikpOwotI2VuZGlmCiAKIAlsZW4gPSBza2JfaGVhZGxlbihza2IpOwogCkBAIC01OTg2LDExICs1OTU0LDEwIEBACiAJCQl9CiAJCX0KIAl9Ci0jaWYgVEczX1ZMQU5fVEFHX1VTRUQKKwogCWlmICh2bGFuX3R4X3RhZ19wcmVzZW50KHNrYikpCiAJCWJhc2VfZmxhZ3MgfD0gKFRYRF9GTEFHX1ZMQU4gfAogCQkJICAgICAgICh2bGFuX3R4X3RhZ19nZXQoc2tiKSA8PCAxNikpOwotI2VuZGlmCiAKIAlpZiAoKHRwLT50ZzNfZmxhZ3MzICYgVEczX0ZMRzNfVVNFX0pVTUJPX0JERkxBRykgJiYKIAkgICAgIW1zcyAmJiBza2ItPmxlbiA+IFZMQU5fRVRIX0ZSQU1FX0xFTikKQEAgLTk1MzIsMTcgKzk0OTksMTAgQEAKIAlyeF9tb2RlID0gdHAtPnJ4X21vZGUgJiB+KFJYX01PREVfUFJPTUlTQyB8CiAJCQkJICBSWF9NT0RFX0tFRVBfVkxBTl9UQUcpOwogCisjaWYgIWRlZmluZWQoQ09ORklHX1ZMQU5fODAyMVEpICYmICFkZWZpbmVkKENPTkZJR19WTEFOXzgwMjFRX01PRFVMRSkKIAkvKiBXaGVuIEFTRiBpcyBpbiB1c2UsIHdlIGFsd2F5cyBrZWVwIHRoZSBSWF9NT0RFX0tFRVBfVkxBTl9UQUcKIAkgKiBmbGFnIGNsZWFyLgogCSAqLwotI2lmIFRHM19WTEFOX1RBR19VU0VECi0JaWYgKCF0cC0+dmxncnAgJiYKLQkgICAgISh0cC0+dGczX2ZsYWdzICYgVEczX0ZMQUdfRU5BQkxFX0FTRikpCi0JCXJ4X21vZGUgfD0gUlhfTU9ERV9LRUVQX1ZMQU5fVEFHOwotI2Vsc2UKLQkvKiBCeSBkZWZpbml0aW9uLCBWTEFOIGlzIGRpc2FibGVkIGFsd2F5cyBpbiB0aGlzCi0JICogY2FzZS4KLQkgKi8KIAlpZiAoISh0cC0+dGczX2ZsYWdzICYgVEczX0ZMQUdfRU5BQkxFX0FTRikpCiAJCXJ4X21vZGUgfD0gUlhfTU9ERV9LRUVQX1ZMQU5fVEFHOwogI2VuZGlmCkBAIC0xMTIzMCwzMSArMTExOTAsNiBAQAogCXJldHVybiAtRU9QTk9UU1VQUDsKIH0KIAotI2lmIFRHM19WTEFOX1RBR19VU0VECi1zdGF0aWMgdm9pZCB0ZzNfdmxhbl9yeF9yZWdpc3RlcihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3Qgdmxhbl9ncm91cCAqZ3JwKQotewotCXN0cnVjdCB0ZzMgKnRwID0gbmV0ZGV2X3ByaXYoZGV2KTsKLQotCWlmICghbmV0aWZfcnVubmluZyhkZXYpKSB7Ci0JCXRwLT52bGdycCA9IGdycDsKLQkJcmV0dXJuOwotCX0KLQotCXRnM19uZXRpZl9zdG9wKHRwKTsKLQotCXRnM19mdWxsX2xvY2sodHAsIDApOwotCi0JdHAtPnZsZ3JwID0gZ3JwOwotCi0JLyogVXBkYXRlIFJYX01PREVfS0VFUF9WTEFOX1RBRyBiaXQgaW4gUlhfTU9ERSByZWdpc3Rlci4gKi8KLQlfX3RnM19zZXRfcnhfbW9kZShkZXYpOwotCi0JdGczX25ldGlmX3N0YXJ0KHRwKTsKLQotCXRnM19mdWxsX3VubG9jayh0cCk7Ci19Ci0jZW5kaWYKLQogc3RhdGljIGludCB0ZzNfZ2V0X2NvYWxlc2NlKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIHN0cnVjdCBldGh0b29sX2NvYWxlc2NlICplYykKIHsKIAlzdHJ1Y3QgdGczICp0cCA9IG5ldGRldl9wcml2KGRldik7CkBAIC0xMzA2Niw5ICsxMzAwMSw3IEBACiAKIHN0YXRpYyB2b2lkIGlubGluZSB2bGFuX2ZlYXR1cmVzX2FkZChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCB1bnNpZ25lZCBsb25nIGZsYWdzKQogewotI2lmIFRHM19WTEFOX1RBR19VU0VECiAJZGV2LT52bGFuX2ZlYXR1cmVzIHw9IGZsYWdzOwotI2VuZGlmCiB9CiAKIHN0YXRpYyBpbmxpbmUgdTMyIHRnM19yeF9yZXRfcmluZ19zaXplKHN0cnVjdCB0ZzMgKnRwKQpAQCAtMTM4NjEsMTEgKzEzNzk0LDExIEBACiAJZWxzZQogCQl0cC0+dGczX2ZsYWdzICY9IH5URzNfRkxBR19QT0xMX1NFUkRFUzsKIAotCXRwLT5yeF9vZmZzZXQgPSBORVRfSVBfQUxJR04gKyBURzNfUlhfSEVBRFJPT007CisJdHAtPnJ4X29mZnNldCA9IE5FVF9JUF9BTElHTjsKIAl0cC0+cnhfY29weV90aHJlc2ggPSBURzNfUlhfQ09QWV9USFJFU0hPTEQ7CiAJaWYgKEdFVF9BU0lDX1JFVih0cC0+cGNpX2NoaXBfcmV2X2lkKSA9PSBBU0lDX1JFVl81NzAxICYmCiAJICAgICh0cC0+dGczX2ZsYWdzICYgVEczX0ZMQUdfUENJWF9NT0RFKSAhPSAwKSB7Ci0JCXRwLT5yeF9vZmZzZXQgLT0gTkVUX0lQX0FMSUdOOworCQl0cC0+cnhfb2Zmc2V0ID0gMDsKICNpZm5kZWYgQ09ORklHX0hBVkVfRUZGSUNJRU5UX1VOQUxJR05FRF9BQ0NFU1MKIAkJdHAtPnJ4X2NvcHlfdGhyZXNoID0gfih1MTYpMDsKICNlbmRpZgpAQCAtMTQ2MjksOSArMTQ1NjIsNiBAQAogCS5uZG9fZG9faW9jdGwJCT0gdGczX2lvY3RsLAogCS5uZG9fdHhfdGltZW91dAkJPSB0ZzNfdHhfdGltZW91dCwKIAkubmRvX2NoYW5nZV9tdHUJCT0gdGczX2NoYW5nZV9tdHUsCi0jaWYgVEczX1ZMQU5fVEFHX1VTRUQKLQkubmRvX3ZsYW5fcnhfcmVnaXN0ZXIJPSB0ZzNfdmxhbl9yeF9yZWdpc3RlciwKLSNlbmRpZgogI2lmZGVmIENPTkZJR19ORVRfUE9MTF9DT05UUk9MTEVSCiAJLm5kb19wb2xsX2NvbnRyb2xsZXIJPSB0ZzNfcG9sbF9jb250cm9sbGVyLAogI2VuZGlmCkBAIC0xNDY0OCw5ICsxNDU3OCw2IEBACiAJLm5kb19kb19pb2N0bAkJPSB0ZzNfaW9jdGwsCiAJLm5kb190eF90aW1lb3V0CQk9IHRnM190eF90aW1lb3V0LAogCS5uZG9fY2hhbmdlX210dQkJPSB0ZzNfY2hhbmdlX210dSwKLSNpZiBURzNfVkxBTl9UQUdfVVNFRAotCS5uZG9fdmxhbl9yeF9yZWdpc3Rlcgk9IHRnM192bGFuX3J4X3JlZ2lzdGVyLAotI2VuZGlmCiAjaWZkZWYgQ09ORklHX05FVF9QT0xMX0NPTlRST0xMRVIKIAkubmRvX3BvbGxfY29udHJvbGxlcgk9IHRnM19wb2xsX2NvbnRyb2xsZXIsCiAjZW5kaWYKQEAgLTE0NzAwLDkgKzE0NjI3LDcgQEAKIAogCVNFVF9ORVRERVZfREVWKGRldiwgJnBkZXYtPmRldik7CiAKLSNpZiBURzNfVkxBTl9UQUdfVVNFRAogCWRldi0+ZmVhdHVyZXMgfD0gTkVUSUZfRl9IV19WTEFOX1RYIHwgTkVUSUZfRl9IV19WTEFOX1JYOwotI2VuZGlmCiAKIAl0cCA9IG5ldGRldl9wcml2KGRldik7CiAJdHAtPnBkZXYgPSBwZGV2OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdGczLmggYi9kcml2ZXJzL25ldC90ZzMuaAppbmRleCBkNjJjOGQ5Li5mNTI4MjQzIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC90ZzMuaAorKysgYi9kcml2ZXJzL25ldC90ZzMuaApAQCAtMjgwOCw5ICsyODA4LDYgQEAKIAl1MzIJCQkJcnhfc3RkX21heF9wb3N0OwogCXUzMgkJCQlyeF9vZmZzZXQ7CiAJdTMyCQkJCXJ4X3BrdF9tYXBfc3o7Ci0jaWYgVEczX1ZMQU5fVEFHX1VTRUQKLQlzdHJ1Y3Qgdmxhbl9ncm91cAkJKnZsZ3JwOwotI2VuZGlmCiAKIAogCS8qIGJlZ2luICJldmVyeXRoaW5nIGVsc2UiIGNhY2hlbGluZShzKSBzZWN0aW9uICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC90aWxlL3RpbGVwcm8uYyBiL2RyaXZlcnMvbmV0L3RpbGUvdGlsZXByby5jCmluZGV4IDBlNmJhYzUuLjdjYjMwMWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3RpbGUvdGlsZXByby5jCisrKyBiL2RyaXZlcnMvbmV0L3RpbGUvdGlsZXByby5jCkBAIC0xNDIsMTQgKzE0Miw2IEBACiBNT0RVTEVfQVVUSE9SKCJUaWxlcmEiKTsKIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKIAotCi0jZGVmaW5lIElTX01VTFRJQ0FTVChtYWNfYWRkcikgXAotCSgoKHU4ICopKG1hY19hZGRyKSlbMF0gJiAweDAxKQotCi0jZGVmaW5lIElTX0JST0FEQ0FTVChtYWNfYWRkcikgXAotCSgoKHUxNiAqKShtYWNfYWRkcikpWzBdID09IDB4ZmZmZikKLQotCiAvKgogICogUXVldWUgb2YgaW5jb21pbmcgcGFja2V0cyBmb3IgYSBzcGVjaWZpYyBjcHUgYW5kIGRldmljZS4KICAqCkBAIC03OTUsNyArNzg3LDcgQEAKIAkJLyoKIAkJICogRklYTUU6IEltcGxlbWVudCBIVyBtdWx0aWNhc3QgZmlsdGVyLgogCQkgKi8KLQkJaWYgKCFJU19NVUxUSUNBU1QoYnVmKSAmJiAhSVNfQlJPQURDQVNUKGJ1ZikpIHsKKwkJaWYgKGlzX3VuaWNhc3RfZXRoZXJfYWRkcihidWYpKSB7CiAJCQkvKiBGaWx0ZXIgcGFja2V0cyBub3QgZm9yIG91ciBhZGRyZXNzLiAqLwogCQkJY29uc3QgdTggKm1pbmUgPSBkZXYtPmRldl9hZGRyOwogCQkJZmlsdGVyID0gY29tcGFyZV9ldGhlcl9hZGRyKG1pbmUsIGJ1Zik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC91Y2NfZ2V0aC5jIGIvZHJpdmVycy9uZXQvdWNjX2dldGguYwppbmRleCA3M2EzZTBkLi43MTVlN2I0IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC91Y2NfZ2V0aC5jCisrKyBiL2RyaXZlcnMvbmV0L3VjY19nZXRoLmMKQEAgLTIwMzIsNyArMjAzMiw3IEBACiAJCQluZXRkZXZfZm9yX2VhY2hfbWNfYWRkcihoYSwgZGV2KSB7CiAJCQkJLyogT25seSBzdXBwb3J0IGdyb3VwIG11bHRpY2FzdCBmb3Igbm93LgogCQkJCSAqLwotCQkJCWlmICghKGhhLT5hZGRyWzBdICYgMSkpCisJCQkJaWYgKCFpc19tdWx0aWNhc3RfZXRoZXJfYWRkcihoYS0+YWRkcikpCiAJCQkJCWNvbnRpbnVlOwogCiAJCQkJLyogQXNrIENQTSB0byBydW4gQ1JDIGFuZCBzZXQgYml0IGluCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC91c2IvY2RjX25jbS5jIGIvZHJpdmVycy9uZXQvdXNiL2NkY19uY20uYwppbmRleCA1OTNjMTA0Li43MTEzMTY4IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC91c2IvY2RjX25jbS5jCisrKyBiL2RyaXZlcnMvbmV0L3VzYi9jZGNfbmNtLmMKQEAgLTEsNyArMSw3IEBACiAvKgogICogY2RjX25jbS5jCiAgKgotICogQ29weXJpZ2h0IChDKSBTVC1Fcmljc3NvbiAyMDEwCisgKiBDb3B5cmlnaHQgKEMpIFNULUVyaWNzc29uIDIwMTAtMjAxMQogICogQ29udGFjdDogQWxleGV5IE9yaXNoa28gPGFsZXhleS5vcmlzaGtvQHN0ZXJpY3Nzb24uY29tPgogICogT3JpZ2luYWwgYXV0aG9yOiBIYW5zIFBldHRlciBTZWxhc2t5IDxoYW5zLnBldHRlci5zZWxhc2t5QHN0ZXJpY3Nzb24uY29tPgogICoKQEAgLTU0LDcgKzU0LDcgQEAKICNpbmNsdWRlIDxsaW51eC91c2IvdXNibmV0Lmg+CiAjaW5jbHVkZSA8bGludXgvdXNiL2NkYy5oPgogCi0jZGVmaW5lCURSSVZFUl9WRVJTSU9OCQkJCSIzMC1Ob3YtMjAxMCIKKyNkZWZpbmUJRFJJVkVSX1ZFUlNJT04JCQkJIjctRmViLTIwMTEiCiAKIC8qIENEQyBOQ00gc3ViY2xhc3MgMy4yLjEgKi8KICNkZWZpbmUgVVNCX0NEQ19OQ01fTkRQMTZfTEVOR1RIX01JTgkJMHgxMApAQCAtNzcsNiArNzcsOSBAQAogICovCiAjZGVmaW5lCUNEQ19OQ01fRFBUX0RBVEFHUkFNU19NQVgJCTMyCiAKKy8qIE1heGltdW0gYW1vdW50IG9mIElOIGRhdGFncmFtcyBpbiBOVEIgKi8KKyNkZWZpbmUJQ0RDX05DTV9EUFRfREFUQUdSQU1TX0lOX01BWAkJMCAvKiB1bmxpbWl0ZWQgKi8KKwogLyogUmVzdGFydCB0aGUgdGltZXIsIGlmIGFtb3VudCBvZiBkYXRhZ3JhbXMgaXMgbGVzcyB0aGFuIGdpdmVuIHZhbHVlICovCiAjZGVmaW5lCUNEQ19OQ01fUkVTVEFSVF9USU1FUl9EQVRBR1JBTV9DTlQJMwogCkBAIC04NSwxMSArODgsNiBAQAogCShzaXplb2Yoc3RydWN0IHVzYl9jZGNfbmNtX250aDE2KSArIHNpemVvZihzdHJ1Y3QgdXNiX2NkY19uY21fbmRwMTYpICsgXAogCShDRENfTkNNX0RQVF9EQVRBR1JBTVNfTUFYICsgMSkgKiBzaXplb2Yoc3RydWN0IHVzYl9jZGNfbmNtX2RwZTE2KSkKIAotc3RydWN0IGNvbm5lY3Rpb25fc3BlZWRfY2hhbmdlIHsKLQlfX2xlMzIJVVNCaXRSYXRlOyAvKiBob2xkcyAzR1BQIGRvd25saW5rIHZhbHVlLCBiaXRzIHBlciBzZWNvbmQgKi8KLQlfX2xlMzIJRFNCaXRSYXRlOyAvKiBob2xkcyAzR1BQIHVwbGluayB2YWx1ZSwgYml0cyBwZXIgc2Vjb25kICovCi19IF9fYXR0cmlidXRlX18gKChwYWNrZWQpKTsKLQogc3RydWN0IGNkY19uY21fZGF0YSB7CiAJc3RydWN0IHVzYl9jZGNfbmNtX250aDE2IG50aDE2OwogCXN0cnVjdCB1c2JfY2RjX25jbV9uZHAxNiBuZHAxNjsKQEAgLTE5OCwxMCArMTk2LDEwIEBACiB7CiAJc3RydWN0IHVzYl9jZGNfbm90aWZpY2F0aW9uIHJlcTsKIAl1MzIgdmFsOwotCV9fbGUxNiBtYXhfZGF0YWdyYW1fc2l6ZTsKIAl1OCBmbGFnczsKIAl1OCBpZmFjZV9ubzsKIAlpbnQgZXJyOworCXUxNiBudGJfZm10X3N1cHBvcnRlZDsKIAogCWlmYWNlX25vID0gY3R4LT5jb250cm9sLT5jdXJfYWx0c2V0dGluZy0+ZGVzYy5iSW50ZXJmYWNlTnVtYmVyOwogCkBAIC0yMjMsNiArMjIxLDkgQEAKIAljdHgtPnR4X3JlbWFpbmRlciA9IGxlMTZfdG9fY3B1KGN0eC0+bmNtX3Bhcm0ud05kcE91dFBheWxvYWRSZW1haW5kZXIpOwogCWN0eC0+dHhfbW9kdWx1cyA9IGxlMTZfdG9fY3B1KGN0eC0+bmNtX3Bhcm0ud05kcE91dERpdmlzb3IpOwogCWN0eC0+dHhfbmRwX21vZHVsdXMgPSBsZTE2X3RvX2NwdShjdHgtPm5jbV9wYXJtLndOZHBPdXRBbGlnbm1lbnQpOworCS8qIGRldmljZXMgcHJpb3IgdG8gTkNNIEVycmF0YSBzaGFsbCBzZXQgdGhpcyBmaWVsZCB0byB6ZXJvICovCisJY3R4LT50eF9tYXhfZGF0YWdyYW1zID0gbGUxNl90b19jcHUoY3R4LT5uY21fcGFybS53TnRiT3V0TWF4RGF0YWdyYW1zKTsKKwludGJfZm10X3N1cHBvcnRlZCA9IGxlMTZfdG9fY3B1KGN0eC0+bmNtX3Bhcm0uYm1OdGJGb3JtYXRzU3VwcG9ydGVkKTsKIAogCWlmIChjdHgtPmZ1bmNfZGVzYyAhPSBOVUxMKQogCQlmbGFncyA9IGN0eC0+ZnVuY19kZXNjLT5ibU5ldHdvcmtDYXBhYmlsaXRpZXM7CkBAIC0yMzEsMjIgKzIzMiw1OCBAQAogCiAJcHJfZGVidWcoImR3TnRiSW5NYXhTaXplPSV1IGR3TnRiT3V0TWF4U2l6ZT0ldSAiCiAJCSAid05kcE91dFBheWxvYWRSZW1haW5kZXI9JXUgd05kcE91dERpdmlzb3I9JXUgIgotCQkgIndOZHBPdXRBbGlnbm1lbnQ9JXUgZmxhZ3M9MHgleFxuIiwKKwkJICJ3TmRwT3V0QWxpZ25tZW50PSV1IHdOdGJPdXRNYXhEYXRhZ3JhbXM9JXUgZmxhZ3M9MHgleFxuIiwKIAkJIGN0eC0+cnhfbWF4LCBjdHgtPnR4X21heCwgY3R4LT50eF9yZW1haW5kZXIsIGN0eC0+dHhfbW9kdWx1cywKLQkJIGN0eC0+dHhfbmRwX21vZHVsdXMsIGZsYWdzKTsKKwkJIGN0eC0+dHhfbmRwX21vZHVsdXMsIGN0eC0+dHhfbWF4X2RhdGFncmFtcywgZmxhZ3MpOwogCi0JLyogbWF4IGNvdW50IG9mIHR4IGRhdGFncmFtcyB3aXRob3V0IHRlcm1pbmF0aW5nIE5VTEwgZW50cnkgKi8KLQljdHgtPnR4X21heF9kYXRhZ3JhbXMgPSBDRENfTkNNX0RQVF9EQVRBR1JBTVNfTUFYOworCS8qIG1heCBjb3VudCBvZiB0eCBkYXRhZ3JhbXMgKi8KKwlpZiAoKGN0eC0+dHhfbWF4X2RhdGFncmFtcyA9PSAwKSB8fAorCQkJKGN0eC0+dHhfbWF4X2RhdGFncmFtcyA+IENEQ19OQ01fRFBUX0RBVEFHUkFNU19NQVgpKQorCQljdHgtPnR4X21heF9kYXRhZ3JhbXMgPSBDRENfTkNNX0RQVF9EQVRBR1JBTVNfTUFYOwogCiAJLyogdmVyaWZ5IG1heGltdW0gc2l6ZSBvZiByZWNlaXZlZCBOVEIgaW4gYnl0ZXMgKi8KLQlpZiAoKGN0eC0+cnhfbWF4IDwKLQkgICAgKENEQ19OQ01fTUlOX0hEUl9TSVpFICsgQ0RDX05DTV9NSU5fREFUQUdSQU1fU0laRSkpIHx8Ci0JICAgIChjdHgtPnJ4X21heCA+IENEQ19OQ01fTlRCX01BWF9TSVpFX1JYKSkgeworCWlmIChjdHgtPnJ4X21heCA8IFVTQl9DRENfTkNNX05UQl9NSU5fSU5fU0laRSkgeworCQlwcl9kZWJ1ZygiVXNpbmcgbWluIHJlY2VpdmUgbGVuZ3RoPSVkXG4iLAorCQkJCQkJVVNCX0NEQ19OQ01fTlRCX01JTl9JTl9TSVpFKTsKKwkJY3R4LT5yeF9tYXggPSBVU0JfQ0RDX05DTV9OVEJfTUlOX0lOX1NJWkU7CisJfQorCisJaWYgKGN0eC0+cnhfbWF4ID4gQ0RDX05DTV9OVEJfTUFYX1NJWkVfUlgpIHsKIAkJcHJfZGVidWcoIlVzaW5nIGRlZmF1bHQgbWF4aW11bSByZWNlaXZlIGxlbmd0aD0lZFxuIiwKIAkJCQkJCUNEQ19OQ01fTlRCX01BWF9TSVpFX1JYKTsKIAkJY3R4LT5yeF9tYXggPSBDRENfTkNNX05UQl9NQVhfU0laRV9SWDsKIAl9CiAKKwkvKiBpbmZvcm0gZGV2aWNlIGFib3V0IE5UQiBpbnB1dCBzaXplIGNoYW5nZXMgKi8KKwlpZiAoY3R4LT5yeF9tYXggIT0gbGUzMl90b19jcHUoY3R4LT5uY21fcGFybS5kd050YkluTWF4U2l6ZSkpIHsKKwkJcmVxLmJtUmVxdWVzdFR5cGUgPSBVU0JfVFlQRV9DTEFTUyB8IFVTQl9ESVJfT1VUIHwKKwkJCQkJCQlVU0JfUkVDSVBfSU5URVJGQUNFOworCQlyZXEuYk5vdGlmaWNhdGlvblR5cGUgPSBVU0JfQ0RDX1NFVF9OVEJfSU5QVVRfU0laRTsKKwkJcmVxLndWYWx1ZSA9IDA7CisJCXJlcS53SW5kZXggPSBjcHVfdG9fbGUxNihpZmFjZV9ubyk7CisKKwkJaWYgKGZsYWdzICYgVVNCX0NEQ19OQ01fTkNBUF9OVEJfSU5QVVRfU0laRSkgeworCQkJc3RydWN0IHVzYl9jZGNfbmNtX25kcF9pbnB1dF9zaXplIG5kcF9pbl9zejsKKworCQkJcmVxLndMZW5ndGggPSA4OworCQkJbmRwX2luX3N6LmR3TnRiSW5NYXhTaXplID0gY3B1X3RvX2xlMzIoY3R4LT5yeF9tYXgpOworCQkJbmRwX2luX3N6LndOdGJJbk1heERhdGFncmFtcyA9CisJCQkJCWNwdV90b19sZTE2KENEQ19OQ01fRFBUX0RBVEFHUkFNU19NQVgpOworCQkJbmRwX2luX3N6LndSZXNlcnZlZCA9IDA7CisJCQllcnIgPSBjZGNfbmNtX2RvX3JlcXVlc3QoY3R4LCAmcmVxLCAmbmRwX2luX3N6LCAwLCBOVUxMLAorCQkJCQkJCQkJMTAwMCk7CisJCX0gZWxzZSB7CisJCQlfX2xlMzIgZHdOdGJJbk1heFNpemUgPSBjcHVfdG9fbGUzMihjdHgtPnJ4X21heCk7CisKKwkJCXJlcS53TGVuZ3RoID0gNDsKKwkJCWVyciA9IGNkY19uY21fZG9fcmVxdWVzdChjdHgsICZyZXEsICZkd050YkluTWF4U2l6ZSwgMCwKKwkJCQkJCQkJTlVMTCwgMTAwMCk7CisJCX0KKworCQlpZiAoZXJyKQorCQkJcHJfZGVidWcoIlNldHRpbmcgTlRCIElucHV0IFNpemUgZmFpbGVkXG4iKTsKKwl9CisKIAkvKiB2ZXJpZnkgbWF4aW11bSBzaXplIG9mIHRyYW5zbWl0dGVkIE5UQiBpbiBieXRlcyAqLwogCWlmICgoY3R4LT50eF9tYXggPAogCSAgICAoQ0RDX05DTV9NSU5fSERSX1NJWkUgKyBDRENfTkNNX01JTl9EQVRBR1JBTV9TSVpFKSkgfHwKQEAgLTI5Nyw0NyArMzM0LDg0IEBACiAJLyogYWRkaXRpb25hbCBjb25maWd1cmF0aW9uICovCiAKIAkvKiBzZXQgQ1JDIE1vZGUgKi8KLQlyZXEuYm1SZXF1ZXN0VHlwZSA9IFVTQl9UWVBFX0NMQVNTIHwgVVNCX0RJUl9PVVQgfCBVU0JfUkVDSVBfSU5URVJGQUNFOwotCXJlcS5iTm90aWZpY2F0aW9uVHlwZSA9IFVTQl9DRENfU0VUX0NSQ19NT0RFOwotCXJlcS53VmFsdWUgPSBjcHVfdG9fbGUxNihVU0JfQ0RDX05DTV9DUkNfTk9UX0FQUEVOREVEKTsKLQlyZXEud0luZGV4ID0gY3B1X3RvX2xlMTYoaWZhY2Vfbm8pOwotCXJlcS53TGVuZ3RoID0gMDsKKwlpZiAoZmxhZ3MgJiBVU0JfQ0RDX05DTV9OQ0FQX0NSQ19NT0RFKSB7CisJCXJlcS5ibVJlcXVlc3RUeXBlID0gVVNCX1RZUEVfQ0xBU1MgfCBVU0JfRElSX09VVCB8CisJCQkJCQkJVVNCX1JFQ0lQX0lOVEVSRkFDRTsKKwkJcmVxLmJOb3RpZmljYXRpb25UeXBlID0gVVNCX0NEQ19TRVRfQ1JDX01PREU7CisJCXJlcS53VmFsdWUgPSBjcHVfdG9fbGUxNihVU0JfQ0RDX05DTV9DUkNfTk9UX0FQUEVOREVEKTsKKwkJcmVxLndJbmRleCA9IGNwdV90b19sZTE2KGlmYWNlX25vKTsKKwkJcmVxLndMZW5ndGggPSAwOwogCi0JZXJyID0gY2RjX25jbV9kb19yZXF1ZXN0KGN0eCwgJnJlcSwgTlVMTCwgMCwgTlVMTCwgMTAwMCk7Ci0JaWYgKGVycikKLQkJcHJfZGVidWcoIlNldHRpbmcgQ1JDIG1vZGUgb2ZmIGZhaWxlZFxuIik7CisJCWVyciA9IGNkY19uY21fZG9fcmVxdWVzdChjdHgsICZyZXEsIE5VTEwsIDAsIE5VTEwsIDEwMDApOworCQlpZiAoZXJyKQorCQkJcHJfZGVidWcoIlNldHRpbmcgQ1JDIG1vZGUgb2ZmIGZhaWxlZFxuIik7CisJfQogCi0JLyogc2V0IE5UQiBmb3JtYXQgKi8KLQlyZXEuYm1SZXF1ZXN0VHlwZSA9IFVTQl9UWVBFX0NMQVNTIHwgVVNCX0RJUl9PVVQgfCBVU0JfUkVDSVBfSU5URVJGQUNFOwotCXJlcS5iTm90aWZpY2F0aW9uVHlwZSA9IFVTQl9DRENfU0VUX05UQl9GT1JNQVQ7Ci0JcmVxLndWYWx1ZSA9IGNwdV90b19sZTE2KFVTQl9DRENfTkNNX05UQjE2X0ZPUk1BVCk7Ci0JcmVxLndJbmRleCA9IGNwdV90b19sZTE2KGlmYWNlX25vKTsKLQlyZXEud0xlbmd0aCA9IDA7CisJLyogc2V0IE5UQiBmb3JtYXQsIGlmIGJvdGggZm9ybWF0cyBhcmUgc3VwcG9ydGVkICovCisJaWYgKG50Yl9mbXRfc3VwcG9ydGVkICYgVVNCX0NEQ19OQ01fTlRIMzJfU0lHTikgeworCQlyZXEuYm1SZXF1ZXN0VHlwZSA9IFVTQl9UWVBFX0NMQVNTIHwgVVNCX0RJUl9PVVQgfAorCQkJCQkJCVVTQl9SRUNJUF9JTlRFUkZBQ0U7CisJCXJlcS5iTm90aWZpY2F0aW9uVHlwZSA9IFVTQl9DRENfU0VUX05UQl9GT1JNQVQ7CisJCXJlcS53VmFsdWUgPSBjcHVfdG9fbGUxNihVU0JfQ0RDX05DTV9OVEIxNl9GT1JNQVQpOworCQlyZXEud0luZGV4ID0gY3B1X3RvX2xlMTYoaWZhY2Vfbm8pOworCQlyZXEud0xlbmd0aCA9IDA7CiAKLQllcnIgPSBjZGNfbmNtX2RvX3JlcXVlc3QoY3R4LCAmcmVxLCBOVUxMLCAwLCBOVUxMLCAxMDAwKTsKLQlpZiAoZXJyKQotCQlwcl9kZWJ1ZygiU2V0dGluZyBOVEIgZm9ybWF0IHRvIDE2LWJpdCBmYWlsZWRcbiIpOworCQllcnIgPSBjZGNfbmNtX2RvX3JlcXVlc3QoY3R4LCAmcmVxLCBOVUxMLCAwLCBOVUxMLCAxMDAwKTsKKwkJaWYgKGVycikKKwkJCXByX2RlYnVnKCJTZXR0aW5nIE5UQiBmb3JtYXQgdG8gMTYtYml0IGZhaWxlZFxuIik7CisJfQorCisJY3R4LT5tYXhfZGF0YWdyYW1fc2l6ZSA9IENEQ19OQ01fTUlOX0RBVEFHUkFNX1NJWkU7CiAKIAkvKiBzZXQgTWF4IERhdGFncmFtIFNpemUgKE1UVSkgKi8KLQlyZXEuYm1SZXF1ZXN0VHlwZSA9IFVTQl9UWVBFX0NMQVNTIHwgVVNCX0RJUl9JTiB8IFVTQl9SRUNJUF9JTlRFUkZBQ0U7Ci0JcmVxLmJOb3RpZmljYXRpb25UeXBlID0gVVNCX0NEQ19HRVRfTUFYX0RBVEFHUkFNX1NJWkU7Ci0JcmVxLndWYWx1ZSA9IDA7Ci0JcmVxLndJbmRleCA9IGNwdV90b19sZTE2KGlmYWNlX25vKTsKLQlyZXEud0xlbmd0aCA9IGNwdV90b19sZTE2KDIpOworCWlmIChmbGFncyAmIFVTQl9DRENfTkNNX05DQVBfTUFYX0RBVEFHUkFNX1NJWkUpIHsKKwkJX19sZTE2IG1heF9kYXRhZ3JhbV9zaXplOworCQl1MTYgZXRoX21heF9zeiA9IGxlMTZfdG9fY3B1KGN0eC0+ZXRoZXJfZGVzYy0+d01heFNlZ21lbnRTaXplKTsKIAotCWVyciA9IGNkY19uY21fZG9fcmVxdWVzdChjdHgsICZyZXEsICZtYXhfZGF0YWdyYW1fc2l6ZSwgMCwgTlVMTCwgMTAwMCk7Ci0JaWYgKGVycikgewotCQlwcl9kZWJ1ZygiIEdFVF9NQVhfREFUQUdSQU1fU0laRSBmYWlsZWQsIHVzaW5nIHNpemU9JXVcbiIsCi0JCQkgQ0RDX05DTV9NSU5fREFUQUdSQU1fU0laRSk7Ci0JCS8qIHVzZSBkZWZhdWx0ICovCi0JCWN0eC0+bWF4X2RhdGFncmFtX3NpemUgPSBDRENfTkNNX01JTl9EQVRBR1JBTV9TSVpFOwotCX0gZWxzZSB7Ci0JCWN0eC0+bWF4X2RhdGFncmFtX3NpemUgPSBsZTE2X3RvX2NwdShtYXhfZGF0YWdyYW1fc2l6ZSk7CisJCXJlcS5ibVJlcXVlc3RUeXBlID0gVVNCX1RZUEVfQ0xBU1MgfCBVU0JfRElSX0lOIHwKKwkJCQkJCQlVU0JfUkVDSVBfSU5URVJGQUNFOworCQlyZXEuYk5vdGlmaWNhdGlvblR5cGUgPSBVU0JfQ0RDX0dFVF9NQVhfREFUQUdSQU1fU0laRTsKKwkJcmVxLndWYWx1ZSA9IDA7CisJCXJlcS53SW5kZXggPSBjcHVfdG9fbGUxNihpZmFjZV9ubyk7CisJCXJlcS53TGVuZ3RoID0gY3B1X3RvX2xlMTYoMik7CiAKLQkJaWYgKGN0eC0+bWF4X2RhdGFncmFtX3NpemUgPCBDRENfTkNNX01JTl9EQVRBR1JBTV9TSVpFKQotCQkJY3R4LT5tYXhfZGF0YWdyYW1fc2l6ZSA9IENEQ19OQ01fTUlOX0RBVEFHUkFNX1NJWkU7Ci0JCWVsc2UgaWYgKGN0eC0+bWF4X2RhdGFncmFtX3NpemUgPiBDRENfTkNNX01BWF9EQVRBR1JBTV9TSVpFKQotCQkJY3R4LT5tYXhfZGF0YWdyYW1fc2l6ZSA9IENEQ19OQ01fTUFYX0RBVEFHUkFNX1NJWkU7CisJCWVyciA9IGNkY19uY21fZG9fcmVxdWVzdChjdHgsICZyZXEsICZtYXhfZGF0YWdyYW1fc2l6ZSwgMCwgTlVMTCwKKwkJCQkJCQkJCTEwMDApOworCQlpZiAoZXJyKSB7CisJCQlwcl9kZWJ1ZygiR0VUX01BWF9EQVRBR1JBTV9TSVpFIGZhaWxlZCwgdXNlIHNpemU9JXVcbiIsCisJCQkJCQlDRENfTkNNX01JTl9EQVRBR1JBTV9TSVpFKTsKKwkJfSBlbHNlIHsKKwkJCWN0eC0+bWF4X2RhdGFncmFtX3NpemUgPSBsZTE2X3RvX2NwdShtYXhfZGF0YWdyYW1fc2l6ZSk7CisJCQkvKiBDaGVjayBFdGggZGVzY3JpcHRvciB2YWx1ZSAqLworCQkJaWYgKGV0aF9tYXhfc3ogPCBDRENfTkNNX01BWF9EQVRBR1JBTV9TSVpFKSB7CisJCQkJaWYgKGN0eC0+bWF4X2RhdGFncmFtX3NpemUgPiBldGhfbWF4X3N6KQorCQkJCQljdHgtPm1heF9kYXRhZ3JhbV9zaXplID0gZXRoX21heF9zejsKKwkJCX0gZWxzZSB7CisJCQkJaWYgKGN0eC0+bWF4X2RhdGFncmFtX3NpemUgPgorCQkJCQkJQ0RDX05DTV9NQVhfREFUQUdSQU1fU0laRSkKKwkJCQkJY3R4LT5tYXhfZGF0YWdyYW1fc2l6ZSA9CisJCQkJCQlDRENfTkNNX01BWF9EQVRBR1JBTV9TSVpFOworCQkJfQorCisJCQlpZiAoY3R4LT5tYXhfZGF0YWdyYW1fc2l6ZSA8IENEQ19OQ01fTUlOX0RBVEFHUkFNX1NJWkUpCisJCQkJY3R4LT5tYXhfZGF0YWdyYW1fc2l6ZSA9CisJCQkJCUNEQ19OQ01fTUlOX0RBVEFHUkFNX1NJWkU7CisKKwkJCS8qIGlmIHZhbHVlIGNoYW5nZWQsIHVwZGF0ZSBkZXZpY2UgKi8KKwkJCXJlcS5ibVJlcXVlc3RUeXBlID0gVVNCX1RZUEVfQ0xBU1MgfCBVU0JfRElSX09VVCB8CisJCQkJCQkJVVNCX1JFQ0lQX0lOVEVSRkFDRTsKKwkJCXJlcS5iTm90aWZpY2F0aW9uVHlwZSA9IFVTQl9DRENfU0VUX01BWF9EQVRBR1JBTV9TSVpFOworCQkJcmVxLndWYWx1ZSA9IDA7CisJCQlyZXEud0luZGV4ID0gY3B1X3RvX2xlMTYoaWZhY2Vfbm8pOworCQkJcmVxLndMZW5ndGggPSAyOworCQkJbWF4X2RhdGFncmFtX3NpemUgPSBjcHVfdG9fbGUxNihjdHgtPm1heF9kYXRhZ3JhbV9zaXplKTsKKworCQkJZXJyID0gY2RjX25jbV9kb19yZXF1ZXN0KGN0eCwgJnJlcSwgJm1heF9kYXRhZ3JhbV9zaXplLAorCQkJCQkJCQkwLCBOVUxMLCAxMDAwKTsKKwkJCWlmIChlcnIpCisJCQkJcHJfZGVidWcoIlNFVF9NQVhfREFUQUdSQU1fU0laRSBmYWlsZWRcbiIpOworCQl9CisKIAl9CiAKIAlpZiAoY3R4LT5uZXRkZXYtPm10dSAhPSAoY3R4LT5tYXhfZGF0YWdyYW1fc2l6ZSAtIEVUSF9ITEVOKSkKQEAgLTQ2NiwxOSArNTQwLDEzIEBACiAKIAkJCWN0eC0+ZXRoZXJfZGVzYyA9CiAJCQkJCShjb25zdCBzdHJ1Y3QgdXNiX2NkY19ldGhlcl9kZXNjICopYnVmOwotCiAJCQlkZXYtPmhhcmRfbXR1ID0KIAkJCQlsZTE2X3RvX2NwdShjdHgtPmV0aGVyX2Rlc2MtPndNYXhTZWdtZW50U2l6ZSk7CiAKLQkJCWlmIChkZXYtPmhhcmRfbXR1IDwKLQkJCSAgICAoQ0RDX05DTV9NSU5fREFUQUdSQU1fU0laRSAtIEVUSF9ITEVOKSkKLQkJCQlkZXYtPmhhcmRfbXR1ID0KLQkJCQkJQ0RDX05DTV9NSU5fREFUQUdSQU1fU0laRSAtIEVUSF9ITEVOOwotCi0JCQllbHNlIGlmIChkZXYtPmhhcmRfbXR1ID4KLQkJCQkgKENEQ19OQ01fTUFYX0RBVEFHUkFNX1NJWkUgLSBFVEhfSExFTikpCi0JCQkJZGV2LT5oYXJkX210dSA9Ci0JCQkJCUNEQ19OQ01fTUFYX0RBVEFHUkFNX1NJWkUgLSBFVEhfSExFTjsKKwkJCWlmIChkZXYtPmhhcmRfbXR1IDwgQ0RDX05DTV9NSU5fREFUQUdSQU1fU0laRSkKKwkJCQlkZXYtPmhhcmRfbXR1ID0JQ0RDX05DTV9NSU5fREFUQUdSQU1fU0laRTsKKwkJCWVsc2UgaWYgKGRldi0+aGFyZF9tdHUgPiBDRENfTkNNX01BWF9EQVRBR1JBTV9TSVpFKQorCQkJCWRldi0+aGFyZF9tdHUgPQlDRENfTkNNX01BWF9EQVRBR1JBTV9TSVpFOwogCQkJYnJlYWs7CiAKIAkJY2FzZSBVU0JfQ0RDX05DTV9UWVBFOgpAQCAtNjI4LDEzICs2OTYsMTMgQEAKIAl1MzIgb2Zmc2V0OwogCXUzMiBsYXN0X29mZnNldDsKIAl1MTYgbiA9IDA7Ci0JdTggdGltZW91dCA9IDA7CisJdTggcmVhZHkyc2VuZCA9IDA7CiAKIAkvKiBpZiB0aGVyZSBpcyBhIHJlbWFpbmluZyBza2IsIGl0IGdldHMgcHJpb3JpdHkgKi8KIAlpZiAoc2tiICE9IE5VTEwpCiAJCXN3YXAoc2tiLCBjdHgtPnR4X3JlbV9za2IpOwogCWVsc2UKLQkJdGltZW91dCA9IDE7CisJCXJlYWR5MnNlbmQgPSAxOwogCiAJLyoKIAkgKiArLS0tLS0tLS0tLS0tLS0tLSsKQEAgLTY4Miw5ICs3NTAsMTAgQEAKIAogCWZvciAoOyBuIDwgY3R4LT50eF9tYXhfZGF0YWdyYW1zOyBuKyspIHsKIAkJLyogY2hlY2sgaWYgZW5kIG9mIHRyYW5zbWl0IGJ1ZmZlciBpcyByZWFjaGVkICovCi0JCWlmIChvZmZzZXQgPj0gY3R4LT50eF9tYXgpCisJCWlmIChvZmZzZXQgPj0gY3R4LT50eF9tYXgpIHsKKwkJCXJlYWR5MnNlbmQgPSAxOwogCQkJYnJlYWs7Ci0KKwkJfQogCQkvKiBjb21wdXRlIG1heGltdW0gYnVmZmVyIHNpemUgKi8KIAkJcmVtID0gY3R4LT50eF9tYXggLSBvZmZzZXQ7CiAKQEAgLTcxMSw5ICs3ODAsNyBAQAogCQkJCX0KIAkJCQljdHgtPnR4X3JlbV9za2IgPSBza2I7CiAJCQkJc2tiID0gTlVMTDsKLQotCQkJCS8qIGxvb3Agb25lIG1vcmUgdGltZSAqLwotCQkJCXRpbWVvdXQgPSAxOworCQkJCXJlYWR5MnNlbmQgPSAxOwogCQkJfQogCQkJYnJlYWs7CiAJCX0KQEAgLTc1Niw3ICs4MjMsNyBAQAogCQljdHgtPnR4X2N1cnJfbGFzdF9vZmZzZXQgPSBsYXN0X29mZnNldDsKIAkJZ290byBleGl0X25vX3NrYjsKIAotCX0gZWxzZSBpZiAoKG4gPCBjdHgtPnR4X21heF9kYXRhZ3JhbXMpICYmICh0aW1lb3V0ID09IDApKSB7CisJfSBlbHNlIGlmICgobiA8IGN0eC0+dHhfbWF4X2RhdGFncmFtcykgJiYgKHJlYWR5MnNlbmQgPT0gMCkpIHsKIAkJLyogd2FpdCBmb3IgbW9yZSBmcmFtZXMgKi8KIAkJLyogcHVzaCB2YXJpYWJsZXMgKi8KIAkJY3R4LT50eF9jdXJyX3NrYiA9IHNrYl9vdXQ7CkBAIC04MTMsNyArODgwLDcgQEAKIAkJCQkJY3B1X3RvX2xlMTYoc2l6ZW9mKGN0eC0+dHhfbmNtLm50aDE2KSk7CiAJY3R4LT50eF9uY20ubnRoMTYud1NlcXVlbmNlID0gY3B1X3RvX2xlMTYoY3R4LT50eF9zZXEpOwogCWN0eC0+dHhfbmNtLm50aDE2LndCbG9ja0xlbmd0aCA9IGNwdV90b19sZTE2KGxhc3Rfb2Zmc2V0KTsKLQljdHgtPnR4X25jbS5udGgxNi53RnBJbmRleCA9IEFMSUdOKHNpemVvZihzdHJ1Y3QgdXNiX2NkY19uY21fbnRoMTYpLAorCWN0eC0+dHhfbmNtLm50aDE2LndOZHBJbmRleCA9IEFMSUdOKHNpemVvZihzdHJ1Y3QgdXNiX2NkY19uY21fbnRoMTYpLAogCQkJCQkJCWN0eC0+dHhfbmRwX21vZHVsdXMpOwogCiAJbWVtY3B5KHNrYl9vdXQtPmRhdGEsICYoY3R4LT50eF9uY20ubnRoMTYpLCBzaXplb2YoY3R4LT50eF9uY20ubnRoMTYpKTsKQEAgLTgyNSwxMyArODkyLDEzIEBACiAJcmVtID0gc2l6ZW9mKGN0eC0+dHhfbmNtLm5kcDE2KSArICgoY3R4LT50eF9jdXJyX2ZyYW1lX251bSArIDEpICoKIAkJCQkJc2l6ZW9mKHN0cnVjdCB1c2JfY2RjX25jbV9kcGUxNikpOwogCWN0eC0+dHhfbmNtLm5kcDE2LndMZW5ndGggPSBjcHVfdG9fbGUxNihyZW0pOwotCWN0eC0+dHhfbmNtLm5kcDE2LndOZXh0RnBJbmRleCA9IDA7IC8qIHJlc2VydmVkICovCisJY3R4LT50eF9uY20ubmRwMTYud05leHROZHBJbmRleCA9IDA7IC8qIHJlc2VydmVkICovCiAKLQltZW1jcHkoKCh1OCAqKXNrYl9vdXQtPmRhdGEpICsgY3R4LT50eF9uY20ubnRoMTYud0ZwSW5kZXgsCisJbWVtY3B5KCgodTggKilza2Jfb3V0LT5kYXRhKSArIGN0eC0+dHhfbmNtLm50aDE2LndOZHBJbmRleCwKIAkJCQkJCSYoY3R4LT50eF9uY20ubmRwMTYpLAogCQkJCQkJc2l6ZW9mKGN0eC0+dHhfbmNtLm5kcDE2KSk7CiAKLQltZW1jcHkoKCh1OCAqKXNrYl9vdXQtPmRhdGEpICsgY3R4LT50eF9uY20ubnRoMTYud0ZwSW5kZXggKworCW1lbWNweSgoKHU4ICopc2tiX291dC0+ZGF0YSkgKyBjdHgtPnR4X25jbS5udGgxNi53TmRwSW5kZXggKwogCQkJCQlzaXplb2YoY3R4LT50eF9uY20ubmRwMTYpLAogCQkJCQkmKGN0eC0+dHhfbmNtLmRwZTE2KSwKIAkJCQkJKGN0eC0+dHhfY3Vycl9mcmFtZV9udW0gKyAxKSAqCkBAIC04NjgsMTUgKzkzNSwxOSBAQAogCWlmIChjdHgtPnR4X3RpbWVyX3BlbmRpbmcgIT0gMCkgewogCQljdHgtPnR4X3RpbWVyX3BlbmRpbmctLTsKIAkJcmVzdGFydCA9IDE7Ci0JfSBlbHNlCisJfSBlbHNlIHsKIAkJcmVzdGFydCA9IDA7CisJfQogCiAJc3Bpbl91bmxvY2soJmN0eC0+bXR4KTsKIAotCWlmIChyZXN0YXJ0KQorCWlmIChyZXN0YXJ0KSB7CisJCXNwaW5fbG9jaygmY3R4LT5tdHgpOwogCQljZGNfbmNtX3R4X3RpbWVvdXRfc3RhcnQoY3R4KTsKLQllbHNlIGlmIChjdHgtPm5ldGRldiAhPSBOVUxMKQorCQlzcGluX3VubG9jaygmY3R4LT5tdHgpOworCX0gZWxzZSBpZiAoY3R4LT5uZXRkZXYgIT0gTlVMTCkgewogCQl1c2JuZXRfc3RhcnRfeG1pdChOVUxMLCBjdHgtPm5ldGRldik7CisJfQogfQogCiBzdGF0aWMgc3RydWN0IHNrX2J1ZmYgKgpAQCAtOTAwLDcgKzk3MSw2IEBACiAJc2tiX291dCA9IGNkY19uY21fZmlsbF90eF9mcmFtZShjdHgsIHNrYik7CiAJaWYgKGN0eC0+dHhfY3Vycl9za2IgIT0gTlVMTCkKIAkJbmVlZF90aW1lciA9IDE7Ci0Jc3Bpbl91bmxvY2soJmN0eC0+bXR4KTsKIAogCS8qIFN0YXJ0IHRpbWVyLCBpZiB0aGVyZSBpcyBhIHJlbWFpbmluZyBza2IgKi8KIAlpZiAobmVlZF90aW1lcikKQEAgLTkwOCw2ICs5NzgsOCBAQAogCiAJaWYgKHNrYl9vdXQpCiAJCWRldi0+bmV0LT5zdGF0cy50eF9wYWNrZXRzICs9IGN0eC0+dHhfY3Vycl9mcmFtZV9udW07CisKKwlzcGluX3VubG9jaygmY3R4LT5tdHgpOwogCXJldHVybiBza2Jfb3V0OwogCiBlcnJvcjoKQEAgLTk1Niw3ICsxMDI4LDcgQEAKIAkJZ290byBlcnJvcjsKIAl9CiAKLQl0ZW1wID0gbGUxNl90b19jcHUoY3R4LT5yeF9uY20ubnRoMTYud0ZwSW5kZXgpOworCXRlbXAgPSBsZTE2X3RvX2NwdShjdHgtPnJ4X25jbS5udGgxNi53TmRwSW5kZXgpOwogCWlmICgodGVtcCArIHNpemVvZihjdHgtPnJ4X25jbS5uZHAxNikpID4gYWN0bGVuKSB7CiAJCXByX2RlYnVnKCJpbnZhbGlkIERQVDE2IGluZGV4XG4iKTsKIAkJZ290byBlcnJvcjsKQEAgLTEwMjAsMTQgKzEwOTIsMTYgQEAKIAkJaWYgKCgob2Zmc2V0ICsgdGVtcCkgPiBhY3RsZW4pIHx8CiAJCSAgICAodGVtcCA+IENEQ19OQ01fTUFYX0RBVEFHUkFNX1NJWkUpIHx8ICh0ZW1wIDwgRVRIX0hMRU4pKSB7CiAJCQlwcl9kZWJ1ZygiaW52YWxpZCBmcmFtZSBkZXRlY3RlZCAoaWdub3JlZCkiCi0JCQkJIm9mZnNldFsldV09JXUsIGxlbmd0aD0ldSwgc2tiPSVwXG4iLAotCQkJCQkJCXgsIG9mZnNldCwgdGVtcCwgc2tiKTsKKwkJCQkJIm9mZnNldFsldV09JXUsIGxlbmd0aD0ldSwgc2tiPSVwXG4iLAorCQkJCQl4LCBvZmZzZXQsIHRlbXAsIHNrYl9pbik7CiAJCQlpZiAoIXgpCiAJCQkJZ290byBlcnJvcjsKIAkJCWJyZWFrOwogCiAJCX0gZWxzZSB7CiAJCQlza2IgPSBza2JfY2xvbmUoc2tiX2luLCBHRlBfQVRPTUlDKTsKKwkJCWlmICghc2tiKQorCQkJCWdvdG8gZXJyb3I7CiAJCQlza2ItPmxlbiA9IHRlbXA7CiAJCQlza2ItPmRhdGEgPSAoKHU4ICopc2tiX2luLT5kYXRhKSArIG9mZnNldDsKIAkJCXNrYl9zZXRfdGFpbF9wb2ludGVyKHNrYiwgdGVtcCk7CkBAIC0xMDQxLDEwICsxMTE1LDEwIEBACiAKIHN0YXRpYyB2b2lkCiBjZGNfbmNtX3NwZWVkX2NoYW5nZShzdHJ1Y3QgY2RjX25jbV9jdHggKmN0eCwKLQkJICAgICBzdHJ1Y3QgY29ubmVjdGlvbl9zcGVlZF9jaGFuZ2UgKmRhdGEpCisJCSAgICAgc3RydWN0IHVzYl9jZGNfc3BlZWRfY2hhbmdlICpkYXRhKQogewotCXVpbnQzMl90IHJ4X3NwZWVkID0gbGUzMl90b19jcHUoZGF0YS0+VVNCaXRSYXRlKTsKLQl1aW50MzJfdCB0eF9zcGVlZCA9IGxlMzJfdG9fY3B1KGRhdGEtPkRTQml0UmF0ZSk7CisJdWludDMyX3Qgcnhfc3BlZWQgPSBsZTMyX3RvX2NwdShkYXRhLT5ETEJpdFJSYXRlKTsKKwl1aW50MzJfdCB0eF9zcGVlZCA9IGxlMzJfdG9fY3B1KGRhdGEtPlVMQml0UmF0ZSk7CiAKIAkvKgogCSAqIEN1cnJlbnRseSB0aGUgVVNCLU5FVCBBUEkgZG9lcyBub3Qgc3VwcG9ydCByZXBvcnRpbmcgdGhlIGFjdHVhbApAQCAtMTA4NSw3ICsxMTU5LDcgQEAKIAkvKiB0ZXN0IGZvciBzcGxpdCBkYXRhIGluIDgtYnl0ZSBjaHVua3MgKi8KIAlpZiAodGVzdF9hbmRfY2xlYXJfYml0KEVWRU5UX1NUU19TUExJVCwgJmRldi0+ZmxhZ3MpKSB7CiAJCWNkY19uY21fc3BlZWRfY2hhbmdlKGN0eCwKLQkJICAgICAgKHN0cnVjdCBjb25uZWN0aW9uX3NwZWVkX2NoYW5nZSAqKXVyYi0+dHJhbnNmZXJfYnVmZmVyKTsKKwkJICAgICAgKHN0cnVjdCB1c2JfY2RjX3NwZWVkX2NoYW5nZSAqKXVyYi0+dHJhbnNmZXJfYnVmZmVyKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtMTExMywxMiArMTE4NywxMiBAQAogCQlicmVhazsKIAogCWNhc2UgVVNCX0NEQ19OT1RJRllfU1BFRURfQ0hBTkdFOgotCQlpZiAodXJiLT5hY3R1YWxfbGVuZ3RoIDwKLQkJICAgIChzaXplb2YoKmV2ZW50KSArIHNpemVvZihzdHJ1Y3QgY29ubmVjdGlvbl9zcGVlZF9jaGFuZ2UpKSkKKwkJaWYgKHVyYi0+YWN0dWFsX2xlbmd0aCA8IChzaXplb2YoKmV2ZW50KSArCisJCQkJCXNpemVvZihzdHJ1Y3QgdXNiX2NkY19zcGVlZF9jaGFuZ2UpKSkKIAkJCXNldF9iaXQoRVZFTlRfU1RTX1NQTElULCAmZGV2LT5mbGFncyk7CiAJCWVsc2UKIAkJCWNkY19uY21fc3BlZWRfY2hhbmdlKGN0eCwKLQkJCQkoc3RydWN0IGNvbm5lY3Rpb25fc3BlZWRfY2hhbmdlICopICZldmVudFsxXSk7CisJCQkJKHN0cnVjdCB1c2JfY2RjX3NwZWVkX2NoYW5nZSAqKSAmZXZlbnRbMV0pOwogCQlicmVhazsKIAogCWRlZmF1bHQ6CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC91c2Iva2F3ZXRoLmMgYi9kcml2ZXJzL25ldC91c2Iva2F3ZXRoLmMKaW5kZXggNWU5ODY0My4uN2RjODQ5NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdXNiL2thd2V0aC5jCisrKyBiL2RyaXZlcnMvbmV0L3VzYi9rYXdldGguYwpAQCAtNDA2LDYgKzQwNiw3IEBACiAKIAlpZiAoZnctPnNpemUgPiBLQVdFVEhfRklSTVdBUkVfQlVGX1NJWkUpIHsKIAkJZXJyKCJGaXJtd2FyZSB0b28gYmlnOiAlenUiLCBmdy0+c2l6ZSk7CisJCXJlbGVhc2VfZmlybXdhcmUoZncpOwogCQlyZXR1cm4gLUVOT1NQQzsKIAl9CiAJZGF0YV9sZW4gPSBmdy0+c2l6ZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3ZpcnRpb19uZXQuYyBiL2RyaXZlcnMvbmV0L3ZpcnRpb19uZXQuYwppbmRleCA5MGEyM2U0Li44MmRiYTVhIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC92aXJ0aW9fbmV0LmMKKysrIGIvZHJpdmVycy9uZXQvdmlydGlvX25ldC5jCkBAIC00NDYsNiArNDQ2LDIwIEBACiAJfQogfQogCitzdGF0aWMgdm9pZCB2aXJ0bmV0X25hcGlfZW5hYmxlKHN0cnVjdCB2aXJ0bmV0X2luZm8gKnZpKQoreworCW5hcGlfZW5hYmxlKCZ2aS0+bmFwaSk7CisKKwkvKiBJZiBhbGwgYnVmZmVycyB3ZXJlIGZpbGxlZCBieSBvdGhlciBzaWRlIGJlZm9yZSB3ZSBuYXBpX2VuYWJsZWQsIHdlCisJICogd29uJ3QgZ2V0IGFub3RoZXIgaW50ZXJydXB0LCBzbyBwcm9jZXNzIGFueSBvdXRzdGFuZGluZyBwYWNrZXRzCisJICogbm93LiAgdmlydG5ldF9wb2xsIHdhbnRzIHJlLWVuYWJsZSB0aGUgcXVldWUsIHNvIHdlIGRpc2FibGUgaGVyZS4KKwkgKiBXZSBzeW5jaHJvbml6ZSBhZ2FpbnN0IGludGVycnVwdHMgdmlhIE5BUElfU1RBVEVfU0NIRUQgKi8KKwlpZiAobmFwaV9zY2hlZHVsZV9wcmVwKCZ2aS0+bmFwaSkpIHsKKwkJdmlydHF1ZXVlX2Rpc2FibGVfY2IodmktPnJ2cSk7CisJCV9fbmFwaV9zY2hlZHVsZSgmdmktPm5hcGkpOworCX0KK30KKwogc3RhdGljIHZvaWQgcmVmaWxsX3dvcmsoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogewogCXN0cnVjdCB2aXJ0bmV0X2luZm8gKnZpOwpAQCAtNDU0LDcgKzQ2OCw3IEBACiAJdmkgPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0IHZpcnRuZXRfaW5mbywgcmVmaWxsLndvcmspOwogCW5hcGlfZGlzYWJsZSgmdmktPm5hcGkpOwogCXN0aWxsX2VtcHR5ID0gIXRyeV9maWxsX3JlY3YodmksIEdGUF9LRVJORUwpOwotCW5hcGlfZW5hYmxlKCZ2aS0+bmFwaSk7CisJdmlydG5ldF9uYXBpX2VuYWJsZSh2aSk7CiAKIAkvKiBJbiB0aGVvcnksIHRoaXMgY2FuIGhhcHBlbjogaWYgd2UgZG9uJ3QgZ2V0IGFueSBidWZmZXJzIGluCiAJICogd2Ugd2lsbCAqbmV2ZXIqIHRyeSB0byBmaWxsIGFnYWluLiAqLwpAQCAtNjM4LDE2ICs2NTIsNyBAQAogewogCXN0cnVjdCB2aXJ0bmV0X2luZm8gKnZpID0gbmV0ZGV2X3ByaXYoZGV2KTsKIAotCW5hcGlfZW5hYmxlKCZ2aS0+bmFwaSk7Ci0KLQkvKiBJZiBhbGwgYnVmZmVycyB3ZXJlIGZpbGxlZCBieSBvdGhlciBzaWRlIGJlZm9yZSB3ZSBuYXBpX2VuYWJsZWQsIHdlCi0JICogd29uJ3QgZ2V0IGFub3RoZXIgaW50ZXJydXB0LCBzbyBwcm9jZXNzIGFueSBvdXRzdGFuZGluZyBwYWNrZXRzCi0JICogbm93LiAgdmlydG5ldF9wb2xsIHdhbnRzIHJlLWVuYWJsZSB0aGUgcXVldWUsIHNvIHdlIGRpc2FibGUgaGVyZS4KLQkgKiBXZSBzeW5jaHJvbml6ZSBhZ2FpbnN0IGludGVycnVwdHMgdmlhIE5BUElfU1RBVEVfU0NIRUQgKi8KLQlpZiAobmFwaV9zY2hlZHVsZV9wcmVwKCZ2aS0+bmFwaSkpIHsKLQkJdmlydHF1ZXVlX2Rpc2FibGVfY2IodmktPnJ2cSk7Ci0JCV9fbmFwaV9zY2hlZHVsZSgmdmktPm5hcGkpOwotCX0KKwl2aXJ0bmV0X25hcGlfZW5hYmxlKHZpKTsKIAlyZXR1cm4gMDsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdm14bmV0My92bXhuZXQzX2Rydi5jIGIvZHJpdmVycy9uZXQvdm14bmV0My92bXhuZXQzX2Rydi5jCmluZGV4IGQxNDNlOGIuLmNjMTRiNGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3ZteG5ldDMvdm14bmV0M19kcnYuYworKysgYi9kcml2ZXJzL25ldC92bXhuZXQzL3ZteG5ldDNfZHJ2LmMKQEAgLTQ4LDYgKzQ4LDkgQEAKIHN0YXRpYyBpbnQgZW5hYmxlX21xID0gMTsKIHN0YXRpYyBpbnQgaXJxX3NoYXJlX21vZGU7CiAKK3N0YXRpYyB2b2lkCit2bXhuZXQzX3dyaXRlX21hY19hZGRyKHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIsIHU4ICptYWMpOworCiAvKgogICogICAgRW5hYmxlL0Rpc2FibGUgdGhlIGdpdmVuIGludHIKICAqLwpAQCAtMTM5LDkgKzE0MiwxMyBAQAogewogCXUzMiByZXQ7CiAJaW50IGk7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKIAorCXNwaW5fbG9ja19pcnFzYXZlKCZhZGFwdGVyLT5jbWRfbG9jaywgZmxhZ3MpOwogCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELCBWTVhORVQzX0NNRF9HRVRfTElOSyk7CiAJcmV0ID0gVk1YTkVUM19SRUFEX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0NNRCk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYWRhcHRlci0+Y21kX2xvY2ssIGZsYWdzKTsKKwogCWFkYXB0ZXItPmxpbmtfc3BlZWQgPSByZXQgPj4gMTY7CiAJaWYgKHJldCAmIDEpIHsgLyogTGluayBpcyB1cC4gKi8KIAkJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IE5JQyBMaW5rIGlzIFVwICVkIE1icHNcbiIsCkBAIC0xODMsOCArMTkwLDEwIEBACiAKIAkvKiBDaGVjayBpZiB0aGVyZSBpcyBhbiBlcnJvciBvbiB4bWl0L3JlY3YgcXVldWVzICovCiAJaWYgKGV2ZW50cyAmIChWTVhORVQzX0VDUl9UUUVSUiB8IFZNWE5FVDNfRUNSX1JRRVJSKSkgeworCQlzcGluX2xvY2soJmFkYXB0ZXItPmNtZF9sb2NrKTsKIAkJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCiAJCQkJICAgICAgIFZNWE5FVDNfQ01EX0dFVF9RVUVVRV9TVEFUVVMpOworCQlzcGluX3VubG9jaygmYWRhcHRlci0+Y21kX2xvY2spOwogCiAJCWZvciAoaSA9IDA7IGkgPCBhZGFwdGVyLT5udW1fdHhfcXVldWVzOyBpKyspCiAJCQlpZiAoYWRhcHRlci0+dHFkX3N0YXJ0W2ldLnN0YXR1cy5zdG9wcGVkKQpAQCAtODA0LDMwICs4MTMsMjUgQEAKIAkJCQkgICBza2JfdHJhbnNwb3J0X2hlYWRlcihza2IpKS0+ZG9mZiAqIDQ7CiAJCWN0eC0+Y29weV9zaXplID0gY3R4LT5ldGhfaXBfaGRyX3NpemUgKyBjdHgtPmw0X2hkcl9zaXplOwogCX0gZWxzZSB7Ci0JCXVuc2lnbmVkIGludCBwdWxsX3NpemU7Ci0KIAkJaWYgKHNrYi0+aXBfc3VtbWVkID09IENIRUNLU1VNX1BBUlRJQUwpIHsKIAkJCWN0eC0+ZXRoX2lwX2hkcl9zaXplID0gc2tiX2NoZWNrc3VtX3N0YXJ0X29mZnNldChza2IpOwogCiAJCQlpZiAoY3R4LT5pcHY0KSB7CiAJCQkJc3RydWN0IGlwaGRyICppcGggPSAoc3RydWN0IGlwaGRyICopCiAJCQkJCQkgICAgc2tiX25ldHdvcmtfaGVhZGVyKHNrYik7Ci0JCQkJaWYgKGlwaC0+cHJvdG9jb2wgPT0gSVBQUk9UT19UQ1ApIHsKLQkJCQkJcHVsbF9zaXplID0gY3R4LT5ldGhfaXBfaGRyX3NpemUgKwotCQkJCQkJICAgIHNpemVvZihzdHJ1Y3QgdGNwaGRyKTsKLQotCQkJCQlpZiAodW5saWtlbHkoIXBza2JfbWF5X3B1bGwoc2tiLAotCQkJCQkJCQlwdWxsX3NpemUpKSkgewotCQkJCQkJZ290byBlcnI7Ci0JCQkJCX0KKwkJCQlpZiAoaXBoLT5wcm90b2NvbCA9PSBJUFBST1RPX1RDUCkKIAkJCQkJY3R4LT5sNF9oZHJfc2l6ZSA9ICgoc3RydWN0IHRjcGhkciAqKQogCQkJCQkgICBza2JfdHJhbnNwb3J0X2hlYWRlcihza2IpKS0+ZG9mZiAqIDQ7Ci0JCQkJfSBlbHNlIGlmIChpcGgtPnByb3RvY29sID09IElQUFJPVE9fVURQKSB7CisJCQkJZWxzZSBpZiAoaXBoLT5wcm90b2NvbCA9PSBJUFBST1RPX1VEUCkKKwkJCQkJLyoKKwkJCQkJICogVXNlIHRjcCBoZWFkZXIgc2l6ZSBzbyB0aGF0IGJ5dGVzIHRvCisJCQkJCSAqIGJlIGNvcGllZCBhcmUgbW9yZSB0aGFuIHJlcXVpcmVkIGJ5CisJCQkJCSAqIHRoZSBkZXZpY2UuCisJCQkJCSAqLwogCQkJCQljdHgtPmw0X2hkcl9zaXplID0KLQkJCQkJCQlzaXplb2Yoc3RydWN0IHVkcGhkcik7Ci0JCQkJfSBlbHNlIHsKKwkJCQkJCQlzaXplb2Yoc3RydWN0IHRjcGhkcik7CisJCQkJZWxzZQogCQkJCQljdHgtPmw0X2hkcl9zaXplID0gMDsKLQkJCQl9CiAJCQl9IGVsc2UgewogCQkJCS8qIGZvciBzaW1wbGljaXR5LCBkb24ndCBjb3B5IEw0IGhlYWRlcnMgKi8KIAkJCQljdHgtPmw0X2hkcl9zaXplID0gMDsKQEAgLTE4NTksMTggKzE4NjMsMTQgQEAKIAlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKIAlzdHJ1Y3QgVm14bmV0M19Ecml2ZXJTaGFyZWQgKnNoYXJlZCA9IGFkYXB0ZXItPnNoYXJlZDsKIAl1MzIgKnZmVGFibGUgPSBhZGFwdGVyLT5zaGFyZWQtPmRldlJlYWQucnhGaWx0ZXJDb25mLnZmVGFibGU7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCWlmIChncnApIHsKIAkJLyogYWRkIHZsYW4gcnggc3RyaXBwaW5nLiAqLwogCQlpZiAoYWRhcHRlci0+bmV0ZGV2LT5mZWF0dXJlcyAmIE5FVElGX0ZfSFdfVkxBTl9SWCkgewogCQkJaW50IGk7Ci0JCQlzdHJ1Y3QgVm14bmV0M19EU0RldlJlYWQgKmRldlJlYWQgPSAmc2hhcmVkLT5kZXZSZWFkOwogCQkJYWRhcHRlci0+dmxhbl9ncnAgPSBncnA7CiAKLQkJCS8qIHVwZGF0ZSBGRUFUVVJFUyB0byBkZXZpY2UgKi8KLQkJCWRldlJlYWQtPm1pc2MudXB0RmVhdHVyZXMgfD0gVVBUMV9GX1JYVkxBTjsKLQkJCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELAotCQkJCQkgICAgICAgVk1YTkVUM19DTURfVVBEQVRFX0ZFQVRVUkUpOwogCQkJLyoKIAkJCSAqICBDbGVhciBlbnRpcmUgdmZUYWJsZTsgdGhlbiBlbmFibGUgdW50YWdnZWQgcGt0cy4KIAkJCSAqICBOb3RlOiBzZXR0aW5nIG9uZSBlbnRyeSBpbiB2ZlRhYmxlIHRvIG5vbi16ZXJvIHR1cm5zCkBAIC0xODgwLDggKzE4ODAsMTAgQEAKIAkJCQl2ZlRhYmxlW2ldID0gMDsKIAogCQkJVk1YTkVUM19TRVRfVkZUQUJMRV9FTlRSWSh2ZlRhYmxlLCAwKTsKKwkJCXNwaW5fbG9ja19pcnFzYXZlKCZhZGFwdGVyLT5jbWRfbG9jaywgZmxhZ3MpOwogCQkJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCiAJCQkJCSAgICAgICBWTVhORVQzX0NNRF9VUERBVEVfVkxBTl9GSUxURVJTKTsKKwkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmFkYXB0ZXItPmNtZF9sb2NrLCBmbGFncyk7CiAJCX0gZWxzZSB7CiAJCQlwcmludGsoS0VSTl9FUlIgIiVzOiB2bGFuX3J4X3JlZ2lzdGVyIHdoZW4gZGV2aWNlIGhhcyAiCiAJCQkgICAgICAgIm5vIE5FVElGX0ZfSFdfVkxBTl9SWFxuIiwgbmV0ZGV2LT5uYW1lKTsKQEAgLTE5MDAsMTMgKzE5MDIsMTAgQEAKIAkJCQkgKi8KIAkJCQl2ZlRhYmxlW2ldID0gMDsKIAkJCX0KKwkJCXNwaW5fbG9ja19pcnFzYXZlKCZhZGFwdGVyLT5jbWRfbG9jaywgZmxhZ3MpOwogCQkJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCiAJCQkJCSAgICAgICBWTVhORVQzX0NNRF9VUERBVEVfVkxBTl9GSUxURVJTKTsKLQotCQkJLyogdXBkYXRlIEZFQVRVUkVTIHRvIGRldmljZSAqLwotCQkJZGV2UmVhZC0+bWlzYy51cHRGZWF0dXJlcyAmPSB+VVBUMV9GX1JYVkxBTjsKLQkJCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELAotCQkJCQkgICAgICAgVk1YTkVUM19DTURfVVBEQVRFX0ZFQVRVUkUpOworCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYWRhcHRlci0+Y21kX2xvY2ssIGZsYWdzKTsKIAkJfQogCX0KIH0KQEAgLTE5MzksMTAgKzE5MzgsMTMgQEAKIHsKIAlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKIAl1MzIgKnZmVGFibGUgPSBhZGFwdGVyLT5zaGFyZWQtPmRldlJlYWQucnhGaWx0ZXJDb25mLnZmVGFibGU7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCVZNWE5FVDNfU0VUX1ZGVEFCTEVfRU5UUlkodmZUYWJsZSwgdmlkKTsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmYWRhcHRlci0+Y21kX2xvY2ssIGZsYWdzKTsKIAlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0NNRCwKIAkJCSAgICAgICBWTVhORVQzX0NNRF9VUERBVEVfVkxBTl9GSUxURVJTKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZhZGFwdGVyLT5jbWRfbG9jaywgZmxhZ3MpOwogfQogCiAKQEAgLTE5NTEsMTAgKzE5NTMsMTMgQEAKIHsKIAlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKIAl1MzIgKnZmVGFibGUgPSBhZGFwdGVyLT5zaGFyZWQtPmRldlJlYWQucnhGaWx0ZXJDb25mLnZmVGFibGU7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCVZNWE5FVDNfQ0xFQVJfVkZUQUJMRV9FTlRSWSh2ZlRhYmxlLCB2aWQpOworCXNwaW5fbG9ja19pcnFzYXZlKCZhZGFwdGVyLT5jbWRfbG9jaywgZmxhZ3MpOwogCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELAogCQkJICAgICAgIFZNWE5FVDNfQ01EX1VQREFURV9WTEFOX0ZJTFRFUlMpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmFkYXB0ZXItPmNtZF9sb2NrLCBmbGFncyk7CiB9CiAKIApAQCAtMTk4NSw2ICsxOTkwLDcgQEAKIHZteG5ldDNfc2V0X21jKHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYpCiB7CiAJc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKIAlzdHJ1Y3QgVm14bmV0M19SeEZpbHRlckNvbmYgKnJ4Q29uZiA9CiAJCQkJCSZhZGFwdGVyLT5zaGFyZWQtPmRldlJlYWQucnhGaWx0ZXJDb25mOwogCXU4ICpuZXdfdGFibGUgPSBOVUxMOwpAQCAtMjAyMCw2ICsyMDI2LDcgQEAKIAkJcnhDb25mLT5tZlRhYmxlUEEgPSAwOwogCX0KIAorCXNwaW5fbG9ja19pcnFzYXZlKCZhZGFwdGVyLT5jbWRfbG9jaywgZmxhZ3MpOwogCWlmIChuZXdfbW9kZSAhPSByeENvbmYtPnJ4TW9kZSkgewogCQlyeENvbmYtPnJ4TW9kZSA9IGNwdV90b19sZTMyKG5ld19tb2RlKTsKIAkJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCkBAIC0yMDI4LDYgKzIwMzUsNyBAQAogCiAJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCiAJCQkgICAgICAgVk1YTkVUM19DTURfVVBEQVRFX01BQ19GSUxURVJTKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZhZGFwdGVyLT5jbWRfbG9jaywgZmxhZ3MpOwogCiAJa2ZyZWUobmV3X3RhYmxlKTsKIH0KQEAgLTIwODAsMTAgKzIwODgsOCBAQAogCQlkZXZSZWFkLT5taXNjLnVwdEZlYXR1cmVzIHw9IFVQVDFfRl9MUk87CiAJCWRldlJlYWQtPm1pc2MubWF4TnVtUnhTRyA9IGNwdV90b19sZTE2KDEgKyBNQVhfU0tCX0ZSQUdTKTsKIAl9Ci0JaWYgKChhZGFwdGVyLT5uZXRkZXYtPmZlYXR1cmVzICYgTkVUSUZfRl9IV19WTEFOX1JYKSAmJgotCSAgICBhZGFwdGVyLT52bGFuX2dycCkgeworCWlmIChhZGFwdGVyLT5uZXRkZXYtPmZlYXR1cmVzICYgTkVUSUZfRl9IV19WTEFOX1JYKQogCQlkZXZSZWFkLT5taXNjLnVwdEZlYXR1cmVzIHw9IFVQVDFfRl9SWFZMQU47Ci0JfQogCiAJZGV2UmVhZC0+bWlzYy5tdHUgPSBjcHVfdG9fbGUzMihhZGFwdGVyLT5uZXRkZXYtPm10dSk7CiAJZGV2UmVhZC0+bWlzYy5xdWV1ZURlc2NQQSA9IGNwdV90b19sZTY0KGFkYXB0ZXItPnF1ZXVlX2Rlc2NfcGEpOwpAQCAtMjE2OCw2ICsyMTc0LDggQEAKIAkvKiByeCBmaWx0ZXIgc2V0dGluZ3MgKi8KIAlkZXZSZWFkLT5yeEZpbHRlckNvbmYucnhNb2RlID0gMDsKIAl2bXhuZXQzX3Jlc3RvcmVfdmxhbihhZGFwdGVyKTsKKwl2bXhuZXQzX3dyaXRlX21hY19hZGRyKGFkYXB0ZXIsIGFkYXB0ZXItPm5ldGRldi0+ZGV2X2FkZHIpOworCiAJLyogdGhlIHJlc3QgYXJlIGFscmVhZHkgemVyb2VkICovCiB9CiAKQEAgLTIxNzcsNiArMjE4NSw3IEBACiB7CiAJaW50IGVyciwgaTsKIAl1MzIgcmV0OworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKIAlkZXZfZGJnKCZhZGFwdGVyLT5uZXRkZXYtPmRldiwgIiVzOiBza2JfYnVmX3NpemUgJWQsIHJ4X2J1Zl9wZXJfcGt0ICVkLCIKIAkJIiByaW5nIHNpemVzICV1ICV1ICV1XG4iLCBhZGFwdGVyLT5uZXRkZXYtPm5hbWUsCkBAIC0yMjA2LDkgKzIyMTUsMTEgQEAKIAkJCSAgICAgICBhZGFwdGVyLT5zaGFyZWRfcGEpKTsKIAlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0RTQUgsIFZNWE5FVDNfR0VUX0FERFJfSEkoCiAJCQkgICAgICAgYWRhcHRlci0+c2hhcmVkX3BhKSk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJmFkYXB0ZXItPmNtZF9sb2NrLCBmbGFncyk7CiAJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCiAJCQkgICAgICAgVk1YTkVUM19DTURfQUNUSVZBVEVfREVWKTsKIAlyZXQgPSBWTVhORVQzX1JFQURfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01EKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZhZGFwdGVyLT5jbWRfbG9jaywgZmxhZ3MpOwogCiAJaWYgKHJldCAhPSAwKSB7CiAJCXByaW50ayhLRVJOX0VSUiAiRmFpbGVkIHRvIGFjdGl2YXRlIGRldiAlczogZXJyb3IgJXVcbiIsCkBAIC0yMjU1LDcgKzIyNjYsMTAgQEAKIHZvaWQKIHZteG5ldDNfcmVzZXRfZGV2KHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIpCiB7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmYWRhcHRlci0+Y21kX2xvY2ssIGZsYWdzKTsKIAlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0NNRCwgVk1YTkVUM19DTURfUkVTRVRfREVWKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZhZGFwdGVyLT5jbWRfbG9jaywgZmxhZ3MpOwogfQogCiAKQEAgLTIyNjMsMTIgKzIyNzcsMTUgQEAKIHZteG5ldDNfcXVpZXNjZV9kZXYoc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlcikKIHsKIAlpbnQgaTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWlmICh0ZXN0X2FuZF9zZXRfYml0KFZNWE5FVDNfU1RBVEVfQklUX1FVSUVTQ0VELCAmYWRhcHRlci0+c3RhdGUpKQogCQlyZXR1cm4gMDsKIAogCisJc3Bpbl9sb2NrX2lycXNhdmUoJmFkYXB0ZXItPmNtZF9sb2NrLCBmbGFncyk7CiAJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCiAJCQkgICAgICAgVk1YTkVUM19DTURfUVVJRVNDRV9ERVYpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmFkYXB0ZXItPmNtZF9sb2NrLCBmbGFncyk7CiAJdm14bmV0M19kaXNhYmxlX2FsbF9pbnRycyhhZGFwdGVyKTsKIAogCWZvciAoaSA9IDA7IGkgPCBhZGFwdGVyLT5udW1fcnhfcXVldWVzOyBpKyspCkBAIC0yNDI2LDcgKzI0NDMsNyBAQAogCXN6ID0gYWRhcHRlci0+cnhfYnVmX3Blcl9wa3QgKiBWTVhORVQzX1JJTkdfU0laRV9BTElHTjsKIAlyaW5nMF9zaXplID0gYWRhcHRlci0+cnhfcXVldWVbMF0ucnhfcmluZ1swXS5zaXplOwogCXJpbmcwX3NpemUgPSAocmluZzBfc2l6ZSArIHN6IC0gMSkgLyBzeiAqIHN6OwotCXJpbmcwX3NpemUgPSBtaW5fdCh1MzIsIHJxLT5yeF9yaW5nWzBdLnNpemUsIFZNWE5FVDNfUlhfUklOR19NQVhfU0laRSAvCisJcmluZzBfc2l6ZSA9IG1pbl90KHUzMiwgcmluZzBfc2l6ZSwgVk1YTkVUM19SWF9SSU5HX01BWF9TSVpFIC8KIAkJCSAgIHN6ICogc3opOwogCXJpbmcxX3NpemUgPSBhZGFwdGVyLT5yeF9xdWV1ZVswXS5yeF9yaW5nWzFdLnNpemU7CiAJY29tcF9zaXplID0gcmluZzBfc2l6ZSArIHJpbmcxX3NpemU7CkBAIC0yNjk1LDcgKzI3MTIsNyBAQAogCQkJYnJlYWs7CiAJCX0gZWxzZSB7CiAJCQkvKiBJZiBmYWlscyB0byBlbmFibGUgcmVxdWlyZWQgbnVtYmVyIG9mIE1TSS14IHZlY3RvcnMKLQkJCSAqIHRyeSBlbmFibGluZyAzIG9mIHRoZW0uIE9uZSBlYWNoIGZvciByeCwgdHggYW5kIGV2ZW50CisJCQkgKiB0cnkgZW5hYmxpbmcgbWluaW11bSBudW1iZXIgb2YgdmVjdG9ycyByZXF1aXJlZC4KIAkJCSAqLwogCQkJdmVjdG9ycyA9IHZlY3Rvcl90aHJlc2hvbGQ7CiAJCQlwcmludGsoS0VSTl9FUlIgIkZhaWxlZCB0byBlbmFibGUgJWQgTVNJLVggZm9yICVzLCB0cnkiCkBAIC0yNzE4LDkgKzI3MzUsMTEgQEAKIAl1MzIgY2ZnOwogCiAJLyogaW50ciBzZXR0aW5ncyAqLworCXNwaW5fbG9jaygmYWRhcHRlci0+Y21kX2xvY2spOwogCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELAogCQkJICAgICAgIFZNWE5FVDNfQ01EX0dFVF9DT05GX0lOVFIpOwogCWNmZyA9IFZNWE5FVDNfUkVBRF9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQpOworCXNwaW5fdW5sb2NrKCZhZGFwdGVyLT5jbWRfbG9jayk7CiAJYWRhcHRlci0+aW50ci50eXBlID0gY2ZnICYgMHgzOwogCWFkYXB0ZXItPmludHIubWFza19tb2RlID0gKGNmZyA+PiAyKSAmIDB4MzsKIApAQCAtMjc1NSw3ICsyNzc0LDcgQEAKIAkJICovCiAJCWlmIChlcnIgPT0gVk1YTkVUM19MSU5VWF9NSU5fTVNJWF9WRUNUKSB7CiAJCQlpZiAoYWRhcHRlci0+c2hhcmVfaW50ciAhPSBWTVhORVQzX0lOVFJfQlVERFlTSEFSRQotCQkJICAgIHx8IGFkYXB0ZXItPm51bV9yeF9xdWV1ZXMgIT0gMikgeworCQkJICAgIHx8IGFkYXB0ZXItPm51bV9yeF9xdWV1ZXMgIT0gMSkgewogCQkJCWFkYXB0ZXItPnNoYXJlX2ludHIgPSBWTVhORVQzX0lOVFJfVFhTSEFSRTsKIAkJCQlwcmludGsoS0VSTl9FUlIgIk51bWJlciBvZiByeCBxdWV1ZXMgOiAxXG4iKTsKIAkJCQlhZGFwdGVyLT5udW1fcnhfcXVldWVzID0gMTsKQEAgLTI5MDUsNiArMjkyNCw3IEBACiAJYWRhcHRlci0+bmV0ZGV2ID0gbmV0ZGV2OwogCWFkYXB0ZXItPnBkZXYgPSBwZGV2OwogCisJc3Bpbl9sb2NrX2luaXQoJmFkYXB0ZXItPmNtZF9sb2NrKTsKIAlhZGFwdGVyLT5zaGFyZWQgPSBwY2lfYWxsb2NfY29uc2lzdGVudChhZGFwdGVyLT5wZGV2LAogCQkJICBzaXplb2Yoc3RydWN0IFZteG5ldDNfRHJpdmVyU2hhcmVkKSwKIAkJCSAgJmFkYXB0ZXItPnNoYXJlZF9wYSk7CkBAIC0zMTA4LDExICszMTI4LDE1IEBACiAJdTggKmFycHJlcTsKIAlzdHJ1Y3QgaW5fZGV2aWNlICppbl9kZXY7CiAJc3RydWN0IGluX2lmYWRkciAqaWZhOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJaW50IGkgPSAwOwogCiAJaWYgKCFuZXRpZl9ydW5uaW5nKG5ldGRldikpCiAJCXJldHVybiAwOwogCisJZm9yIChpID0gMDsgaSA8IGFkYXB0ZXItPm51bV9yeF9xdWV1ZXM7IGkrKykKKwkJbmFwaV9kaXNhYmxlKCZhZGFwdGVyLT5yeF9xdWV1ZVtpXS5uYXBpKTsKKwogCXZteG5ldDNfZGlzYWJsZV9hbGxfaW50cnMoYWRhcHRlcik7CiAJdm14bmV0M19mcmVlX2lycXMoYWRhcHRlcik7CiAJdm14bmV0M19mcmVlX2ludHJfcmVzb3VyY2VzKGFkYXB0ZXIpOwpAQCAtMzE4OCw4ICszMjEyLDEwIEBACiAJYWRhcHRlci0+c2hhcmVkLT5kZXZSZWFkLnBtQ29uZkRlc2MuY29uZlBBID0gY3B1X3RvX2xlNjQodmlydF90b19waHlzKAogCQkJCQkJCQkgcG1Db25mKSk7CiAKKwlzcGluX2xvY2tfaXJxc2F2ZSgmYWRhcHRlci0+Y21kX2xvY2ssIGZsYWdzKTsKIAlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0NNRCwKIAkJCSAgICAgICBWTVhORVQzX0NNRF9VUERBVEVfUE1DRkcpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmFkYXB0ZXItPmNtZF9sb2NrLCBmbGFncyk7CiAKIAlwY2lfc2F2ZV9zdGF0ZShwZGV2KTsKIAlwY2lfZW5hYmxlX3dha2UocGRldiwgcGNpX2Nob29zZV9zdGF0ZShwZGV2LCBQTVNHX1NVU1BFTkQpLApAQCAtMzIwNCw3ICszMjMwLDggQEAKIHN0YXRpYyBpbnQKIHZteG5ldDNfcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRldmljZSkKIHsKLQlpbnQgZXJyOworCWludCBlcnIsIGkgPSAwOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJc3RydWN0IHBjaV9kZXYgKnBkZXYgPSB0b19wY2lfZGV2KGRldmljZSk7CiAJc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiA9IHBjaV9nZXRfZHJ2ZGF0YShwZGV2KTsKIAlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKQEAgLTMyMzIsMTAgKzMyNTksMTQgQEAKIAogCXBjaV9lbmFibGVfd2FrZShwZGV2LCBQQ0lfRDAsIDApOwogCisJc3Bpbl9sb2NrX2lycXNhdmUoJmFkYXB0ZXItPmNtZF9sb2NrLCBmbGFncyk7CiAJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCiAJCQkgICAgICAgVk1YTkVUM19DTURfVVBEQVRFX1BNQ0ZHKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZhZGFwdGVyLT5jbWRfbG9jaywgZmxhZ3MpOwogCXZteG5ldDNfYWxsb2NfaW50cl9yZXNvdXJjZXMoYWRhcHRlcik7CiAJdm14bmV0M19yZXF1ZXN0X2lycXMoYWRhcHRlcik7CisJZm9yIChpID0gMDsgaSA8IGFkYXB0ZXItPm51bV9yeF9xdWV1ZXM7IGkrKykKKwkJbmFwaV9lbmFibGUoJmFkYXB0ZXItPnJ4X3F1ZXVlW2ldLm5hcGkpOwogCXZteG5ldDNfZW5hYmxlX2FsbF9pbnRycyhhZGFwdGVyKTsKIAogCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdm14bmV0My92bXhuZXQzX2V0aHRvb2wuYyBiL2RyaXZlcnMvbmV0L3ZteG5ldDMvdm14bmV0M19ldGh0b29sLmMKaW5kZXggOGUxN2ZjOC4uODEyNTRiZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdm14bmV0My92bXhuZXQzX2V0aHRvb2wuYworKysgYi9kcml2ZXJzL25ldC92bXhuZXQzL3ZteG5ldDNfZXRodG9vbC5jCkBAIC00NSw2ICs0NSw3IEBACiB2bXhuZXQzX3NldF9yeF9jc3VtKHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYsIHUzMiB2YWwpCiB7CiAJc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCWlmIChhZGFwdGVyLT5yeGNzdW0gIT0gdmFsKSB7CiAJCWFkYXB0ZXItPnJ4Y3N1bSA9IHZhbDsKQEAgLTU2LDggKzU3LDEwIEBACiAJCQkJYWRhcHRlci0+c2hhcmVkLT5kZXZSZWFkLm1pc2MudXB0RmVhdHVyZXMgJj0KIAkJCQl+VVBUMV9GX1JYQ1NVTTsKIAorCQkJc3Bpbl9sb2NrX2lycXNhdmUoJmFkYXB0ZXItPmNtZF9sb2NrLCBmbGFncyk7CiAJCQlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0NNRCwKIAkJCQkJICAgICAgIFZNWE5FVDNfQ01EX1VQREFURV9GRUFUVVJFKTsKKwkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmFkYXB0ZXItPmNtZF9sb2NrLCBmbGFncyk7CiAJCX0KIAl9CiAJcmV0dXJuIDA7CkBAIC02OCw3NiArNzEsNzggQEAKIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgdm14bmV0M19zdGF0X2Rlc2MKIHZteG5ldDNfdHFfZGV2X3N0YXRzW10gPSB7CiAJLyogZGVzY3JpcHRpb24sICAgICAgICAgb2Zmc2V0ICovCi0JeyAiVFNPIHBrdHMgdHgiLCAgICAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgVFNPUGt0c1R4T0spIH0sCi0JeyAiVFNPIGJ5dGVzIHR4IiwgICAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgVFNPQnl0ZXNUeE9LKSB9LAotCXsgInVjYXN0IHBrdHMgdHgiLCAgICAgIG9mZnNldG9mKHN0cnVjdCBVUFQxX1R4U3RhdHMsIHVjYXN0UGt0c1R4T0spIH0sCi0JeyAidWNhc3QgYnl0ZXMgdHgiLCAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgdWNhc3RCeXRlc1R4T0spIH0sCi0JeyAibWNhc3QgcGt0cyB0eCIsICAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgbWNhc3RQa3RzVHhPSykgfSwKLQl7ICJtY2FzdCBieXRlcyB0eCIsICAgICBvZmZzZXRvZihzdHJ1Y3QgVVBUMV9UeFN0YXRzLCBtY2FzdEJ5dGVzVHhPSykgfSwKLQl7ICJiY2FzdCBwa3RzIHR4IiwgICAgICBvZmZzZXRvZihzdHJ1Y3QgVVBUMV9UeFN0YXRzLCBiY2FzdFBrdHNUeE9LKSB9LAotCXsgImJjYXN0IGJ5dGVzIHR4IiwgICAgIG9mZnNldG9mKHN0cnVjdCBVUFQxX1R4U3RhdHMsIGJjYXN0Qnl0ZXNUeE9LKSB9LAotCXsgInBrdHMgdHggZXJyIiwgICAgICAgIG9mZnNldG9mKHN0cnVjdCBVUFQxX1R4U3RhdHMsIHBrdHNUeEVycm9yKSB9LAotCXsgInBrdHMgdHggZGlzY2FyZCIsICAgIG9mZnNldG9mKHN0cnVjdCBVUFQxX1R4U3RhdHMsIHBrdHNUeERpc2NhcmQpIH0sCisJeyAiVHggUXVldWUjIiwgICAgICAgIDAgfSwKKwl7ICIgIFRTTyBwa3RzIHR4IiwJb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgVFNPUGt0c1R4T0spIH0sCisJeyAiICBUU08gYnl0ZXMgdHgiLAlvZmZzZXRvZihzdHJ1Y3QgVVBUMV9UeFN0YXRzLCBUU09CeXRlc1R4T0spIH0sCisJeyAiICB1Y2FzdCBwa3RzIHR4IiwJb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgdWNhc3RQa3RzVHhPSykgfSwKKwl7ICIgIHVjYXN0IGJ5dGVzIHR4IiwJb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgdWNhc3RCeXRlc1R4T0spIH0sCisJeyAiICBtY2FzdCBwa3RzIHR4IiwJb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgbWNhc3RQa3RzVHhPSykgfSwKKwl7ICIgIG1jYXN0IGJ5dGVzIHR4IiwJb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgbWNhc3RCeXRlc1R4T0spIH0sCisJeyAiICBiY2FzdCBwa3RzIHR4IiwJb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgYmNhc3RQa3RzVHhPSykgfSwKKwl7ICIgIGJjYXN0IGJ5dGVzIHR4IiwJb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgYmNhc3RCeXRlc1R4T0spIH0sCisJeyAiICBwa3RzIHR4IGVyciIsCW9mZnNldG9mKHN0cnVjdCBVUFQxX1R4U3RhdHMsIHBrdHNUeEVycm9yKSB9LAorCXsgIiAgcGt0cyB0eCBkaXNjYXJkIiwJb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgcGt0c1R4RGlzY2FyZCkgfSwKIH07CiAKIC8qIHBlciB0cSBzdGF0cyBtYWludGFpbmVkIGJ5IHRoZSBkcml2ZXIgKi8KIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgdm14bmV0M19zdGF0X2Rlc2MKIHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzW10gPSB7CiAJLyogZGVzY3JpcHRpb24sICAgICAgICAgb2Zmc2V0ICovCi0JeyJkcnYgZHJvcHBlZCB0eCB0b3RhbCIsIG9mZnNldG9mKHN0cnVjdCB2bXhuZXQzX3RxX2RyaXZlcl9zdGF0cywKLQkJCQkJZHJvcF90b3RhbCkgfSwKLQl7ICIgICB0b28gbWFueSBmcmFncyIsICBvZmZzZXRvZihzdHJ1Y3Qgdm14bmV0M190cV9kcml2ZXJfc3RhdHMsCi0JCQkJCWRyb3BfdG9vX21hbnlfZnJhZ3MpIH0sCi0JeyAiICAgZ2lhbnQgaGRyIiwgICAgICAgb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzLAotCQkJCQlkcm9wX292ZXJzaXplZF9oZHIpIH0sCi0JeyAiICAgaGRyIGVyciIsICAgICAgICAgb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzLAotCQkJCQlkcm9wX2hkcl9pbnNwZWN0X2VycikgfSwKLQl7ICIgICB0c28iLCAgICAgICAgICAgICBvZmZzZXRvZihzdHJ1Y3Qgdm14bmV0M190cV9kcml2ZXJfc3RhdHMsCi0JCQkJCWRyb3BfdHNvKSB9LAotCXsgInJpbmcgZnVsbCIsICAgICAgICAgIG9mZnNldG9mKHN0cnVjdCB2bXhuZXQzX3RxX2RyaXZlcl9zdGF0cywKLQkJCQkJdHhfcmluZ19mdWxsKSB9LAotCXsgInBrdHMgbGluZWFyaXplZCIsICAgIG9mZnNldG9mKHN0cnVjdCB2bXhuZXQzX3RxX2RyaXZlcl9zdGF0cywKLQkJCQkJbGluZWFyaXplZCkgfSwKLQl7ICJoZHIgY2xvbmVkIiwgICAgICAgICBvZmZzZXRvZihzdHJ1Y3Qgdm14bmV0M190cV9kcml2ZXJfc3RhdHMsCi0JCQkJCWNvcHlfc2tiX2hlYWRlcikgfSwKLQl7ICJnaWFudCBoZHIiLCAgICAgICAgICBvZmZzZXRvZihzdHJ1Y3Qgdm14bmV0M190cV9kcml2ZXJfc3RhdHMsCi0JCQkJCW92ZXJzaXplZF9oZHIpIH0sCisJeyIgIGRydiBkcm9wcGVkIHR4IHRvdGFsIiwJb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzLAorCQkJCQkJIGRyb3BfdG90YWwpIH0sCisJeyAiICAgICB0b28gbWFueSBmcmFncyIsIG9mZnNldG9mKHN0cnVjdCB2bXhuZXQzX3RxX2RyaXZlcl9zdGF0cywKKwkJCQkJICBkcm9wX3Rvb19tYW55X2ZyYWdzKSB9LAorCXsgIiAgICAgZ2lhbnQgaGRyIiwJb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzLAorCQkJCQkgZHJvcF9vdmVyc2l6ZWRfaGRyKSB9LAorCXsgIiAgICAgaGRyIGVyciIsCW9mZnNldG9mKHN0cnVjdCB2bXhuZXQzX3RxX2RyaXZlcl9zdGF0cywKKwkJCQkJIGRyb3BfaGRyX2luc3BlY3RfZXJyKSB9LAorCXsgIiAgICAgdHNvIiwJCW9mZnNldG9mKHN0cnVjdCB2bXhuZXQzX3RxX2RyaXZlcl9zdGF0cywKKwkJCQkJIGRyb3BfdHNvKSB9LAorCXsgIiAgcmluZyBmdWxsIiwJb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzLAorCQkJCQkgdHhfcmluZ19mdWxsKSB9LAorCXsgIiAgcGt0cyBsaW5lYXJpemVkIiwJb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzLAorCQkJCQkgbGluZWFyaXplZCkgfSwKKwl7ICIgIGhkciBjbG9uZWQiLAlvZmZzZXRvZihzdHJ1Y3Qgdm14bmV0M190cV9kcml2ZXJfc3RhdHMsCisJCQkJCSBjb3B5X3NrYl9oZWFkZXIpIH0sCisJeyAiICBnaWFudCBoZHIiLAlvZmZzZXRvZihzdHJ1Y3Qgdm14bmV0M190cV9kcml2ZXJfc3RhdHMsCisJCQkJCSBvdmVyc2l6ZWRfaGRyKSB9LAogfTsKIAogLyogcGVyIHJxIHN0YXRzIG1haW50YWluZWQgYnkgdGhlIGRldmljZSAqLwogc3RhdGljIGNvbnN0IHN0cnVjdCB2bXhuZXQzX3N0YXRfZGVzYwogdm14bmV0M19ycV9kZXZfc3RhdHNbXSA9IHsKLQl7ICJMUk8gcGt0cyByeCIsICAgICAgICBvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCBMUk9Qa3RzUnhPSykgfSwKLQl7ICJMUk8gYnl0ZSByeCIsICAgICAgICBvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCBMUk9CeXRlc1J4T0spIH0sCi0JeyAidWNhc3QgcGt0cyByeCIsICAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfUnhTdGF0cywgdWNhc3RQa3RzUnhPSykgfSwKLQl7ICJ1Y2FzdCBieXRlcyByeCIsICAgICBvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCB1Y2FzdEJ5dGVzUnhPSykgfSwKLQl7ICJtY2FzdCBwa3RzIHJ4IiwgICAgICBvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCBtY2FzdFBrdHNSeE9LKSB9LAotCXsgIm1jYXN0IGJ5dGVzIHJ4IiwgICAgIG9mZnNldG9mKHN0cnVjdCBVUFQxX1J4U3RhdHMsIG1jYXN0Qnl0ZXNSeE9LKSB9LAotCXsgImJjYXN0IHBrdHMgcngiLCAgICAgIG9mZnNldG9mKHN0cnVjdCBVUFQxX1J4U3RhdHMsIGJjYXN0UGt0c1J4T0spIH0sCi0JeyAiYmNhc3QgYnl0ZXMgcngiLCAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfUnhTdGF0cywgYmNhc3RCeXRlc1J4T0spIH0sCi0JeyAicGt0cyByeCBvdXQgb2YgYnVmIiwgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfUnhTdGF0cywgcGt0c1J4T3V0T2ZCdWYpIH0sCi0JeyAicGt0cyByeCBlcnIiLCAgICAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfUnhTdGF0cywgcGt0c1J4RXJyb3IpIH0sCisJeyAiUnggUXVldWUjIiwgICAgICAgIDAgfSwKKwl7ICIgIExSTyBwa3RzIHJ4IiwJb2Zmc2V0b2Yoc3RydWN0IFVQVDFfUnhTdGF0cywgTFJPUGt0c1J4T0spIH0sCisJeyAiICBMUk8gYnl0ZSByeCIsCW9mZnNldG9mKHN0cnVjdCBVUFQxX1J4U3RhdHMsIExST0J5dGVzUnhPSykgfSwKKwl7ICIgIHVjYXN0IHBrdHMgcngiLAlvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCB1Y2FzdFBrdHNSeE9LKSB9LAorCXsgIiAgdWNhc3QgYnl0ZXMgcngiLAlvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCB1Y2FzdEJ5dGVzUnhPSykgfSwKKwl7ICIgIG1jYXN0IHBrdHMgcngiLAlvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCBtY2FzdFBrdHNSeE9LKSB9LAorCXsgIiAgbWNhc3QgYnl0ZXMgcngiLAlvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCBtY2FzdEJ5dGVzUnhPSykgfSwKKwl7ICIgIGJjYXN0IHBrdHMgcngiLAlvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCBiY2FzdFBrdHNSeE9LKSB9LAorCXsgIiAgYmNhc3QgYnl0ZXMgcngiLAlvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCBiY2FzdEJ5dGVzUnhPSykgfSwKKwl7ICIgIHBrdHMgcnggT09CIiwJb2Zmc2V0b2Yoc3RydWN0IFVQVDFfUnhTdGF0cywgcGt0c1J4T3V0T2ZCdWYpIH0sCisJeyAiICBwa3RzIHJ4IGVyciIsCW9mZnNldG9mKHN0cnVjdCBVUFQxX1J4U3RhdHMsIHBrdHNSeEVycm9yKSB9LAogfTsKIAogLyogcGVyIHJxIHN0YXRzIG1haW50YWluZWQgYnkgdGhlIGRyaXZlciAqLwogc3RhdGljIGNvbnN0IHN0cnVjdCB2bXhuZXQzX3N0YXRfZGVzYwogdm14bmV0M19ycV9kcml2ZXJfc3RhdHNbXSA9IHsKIAkvKiBkZXNjcmlwdGlvbiwgICAgICAgICBvZmZzZXQgKi8KLQl7ICJkcnYgZHJvcHBlZCByeCB0b3RhbCIsIG9mZnNldG9mKHN0cnVjdCB2bXhuZXQzX3JxX2RyaXZlcl9zdGF0cywKLQkJCQkJICAgZHJvcF90b3RhbCkgfSwKLQl7ICIgICBlcnIiLCAgICAgICAgICAgIG9mZnNldG9mKHN0cnVjdCB2bXhuZXQzX3JxX2RyaXZlcl9zdGF0cywKLQkJCQkJZHJvcF9lcnIpIH0sCi0JeyAiICAgZmNzIiwgICAgICAgICAgICBvZmZzZXRvZihzdHJ1Y3Qgdm14bmV0M19ycV9kcml2ZXJfc3RhdHMsCi0JCQkJCWRyb3BfZmNzKSB9LAotCXsgInJ4IGJ1ZiBhbGxvYyBmYWlsIiwgb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfcnFfZHJpdmVyX3N0YXRzLAotCQkJCQlyeF9idWZfYWxsb2NfZmFpbHVyZSkgfSwKKwl7ICIgIGRydiBkcm9wcGVkIHJ4IHRvdGFsIiwgb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfcnFfZHJpdmVyX3N0YXRzLAorCQkJCQkgICAgIGRyb3BfdG90YWwpIH0sCisJeyAiICAgICBlcnIiLAkJb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfcnFfZHJpdmVyX3N0YXRzLAorCQkJCQkgZHJvcF9lcnIpIH0sCisJeyAiICAgICBmY3MiLAkJb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfcnFfZHJpdmVyX3N0YXRzLAorCQkJCQkgZHJvcF9mY3MpIH0sCisJeyAiICByeCBidWYgYWxsb2MgZmFpbCIsIG9mZnNldG9mKHN0cnVjdCB2bXhuZXQzX3JxX2RyaXZlcl9zdGF0cywKKwkJCQkJICByeF9idWZfYWxsb2NfZmFpbHVyZSkgfSwKIH07CiAKIC8qIGdsb2FibCBzdGF0cyBtYWludGFpbmVkIGJ5IHRoZSBkcml2ZXIgKi8KIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgdm14bmV0M19zdGF0X2Rlc2MKIHZteG5ldDNfZ2xvYmFsX3N0YXRzW10gPSB7CiAJLyogZGVzY3JpcHRpb24sICAgICAgICAgb2Zmc2V0ICovCi0JeyAidHggdGltZW91dCBjb3VudCIsICAgb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfYWRhcHRlciwKKwl7ICJ0eCB0aW1lb3V0IGNvdW50IiwJb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfYWRhcHRlciwKIAkJCQkJIHR4X3RpbWVvdXRfY291bnQpIH0KIH07CiAKQEAgLTE1MSwxMiArMTU2LDE1IEBACiAJc3RydWN0IFVQVDFfVHhTdGF0cyAqZGV2VHhTdGF0czsKIAlzdHJ1Y3QgVVBUMV9SeFN0YXRzICpkZXZSeFN0YXRzOwogCXN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICpuZXRfc3RhdHMgPSAmbmV0ZGV2LT5zdGF0czsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCBpOwogCiAJYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CiAKIAkvKiBDb2xsZWN0IHRoZSBkZXYgc3RhdHMgaW50byB0aGUgc2hhcmVkIGFyZWEgKi8KKwlzcGluX2xvY2tfaXJxc2F2ZSgmYWRhcHRlci0+Y21kX2xvY2ssIGZsYWdzKTsKIAlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0NNRCwgVk1YTkVUM19DTURfR0VUX1NUQVRTKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZhZGFwdGVyLT5jbWRfbG9jaywgZmxhZ3MpOwogCiAJbWVtc2V0KG5ldF9zdGF0cywgMCwgc2l6ZW9mKCpuZXRfc3RhdHMpKTsKIAlmb3IgKGkgPSAwOyBpIDwgYWRhcHRlci0+bnVtX3R4X3F1ZXVlczsgaSsrKSB7CkBAIC0xOTMsMTIgKzIwMSwxNSBAQAogc3RhdGljIGludAogdm14bmV0M19nZXRfc3NldF9jb3VudChzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2LCBpbnQgc3NldCkKIHsKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKIAlzd2l0Y2ggKHNzZXQpIHsKIAljYXNlIEVUSF9TU19TVEFUUzoKLQkJcmV0dXJuIEFSUkFZX1NJWkUodm14bmV0M190cV9kZXZfc3RhdHMpICsKLQkJCUFSUkFZX1NJWkUodm14bmV0M190cV9kcml2ZXJfc3RhdHMpICsKLQkJCUFSUkFZX1NJWkUodm14bmV0M19ycV9kZXZfc3RhdHMpICsKLQkJCUFSUkFZX1NJWkUodm14bmV0M19ycV9kcml2ZXJfc3RhdHMpICsKKwkJcmV0dXJuIChBUlJBWV9TSVpFKHZteG5ldDNfdHFfZGV2X3N0YXRzKSArCisJCQlBUlJBWV9TSVpFKHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzKSkgKgorCQkgICAgICAgYWRhcHRlci0+bnVtX3R4X3F1ZXVlcyArCisJCSAgICAgICAoQVJSQVlfU0laRSh2bXhuZXQzX3JxX2Rldl9zdGF0cykgKworCQkJQVJSQVlfU0laRSh2bXhuZXQzX3JxX2RyaXZlcl9zdGF0cykpICoKKwkJICAgICAgIGFkYXB0ZXItPm51bV9yeF9xdWV1ZXMgKwogCQkJQVJSQVlfU0laRSh2bXhuZXQzX2dsb2JhbF9zdGF0cyk7CiAJZGVmYXVsdDoKIAkJcmV0dXJuIC1FT1BOT1RTVVBQOwpAQCAtMjA2LDEwICsyMTcsMTYgQEAKIH0KIAogCisvKiBTaG91bGQgYmUgbXVsdGlwbGUgb2YgNCAqLworI2RlZmluZSBOVU1fVFhfUkVHUwk4CisjZGVmaW5lIE5VTV9SWF9SRUdTCTEyCisKIHN0YXRpYyBpbnQKIHZteG5ldDNfZ2V0X3JlZ3NfbGVuKHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYpCiB7Ci0JcmV0dXJuIDIwICogc2l6ZW9mKHUzMik7CisJc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CisJcmV0dXJuIChhZGFwdGVyLT5udW1fdHhfcXVldWVzICogTlVNX1RYX1JFR1MgKiBzaXplb2YodTMyKSArCisJCWFkYXB0ZXItPm51bV9yeF9xdWV1ZXMgKiBOVU1fUlhfUkVHUyAqIHNpemVvZih1MzIpKTsKIH0KIAogCkBAIC0yNDAsMjkgKzI1NywzNyBAQAogc3RhdGljIHZvaWQKIHZteG5ldDNfZ2V0X3N0cmluZ3Moc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwgdTMyIHN0cmluZ3NldCwgdTggKmJ1ZikKIHsKKwkgc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CiAJaWYgKHN0cmluZ3NldCA9PSBFVEhfU1NfU1RBVFMpIHsKLQkJaW50IGk7CisJCWludCBpLCBqOworCQlmb3IgKGogPSAwOyBqIDwgYWRhcHRlci0+bnVtX3R4X3F1ZXVlczsgaisrKSB7CisJCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX3RxX2Rldl9zdGF0cyk7IGkrKykgeworCQkJCW1lbWNweShidWYsIHZteG5ldDNfdHFfZGV2X3N0YXRzW2ldLmRlc2MsCisJCQkJICAgICAgIEVUSF9HU1RSSU5HX0xFTik7CisJCQkJYnVmICs9IEVUSF9HU1RSSU5HX0xFTjsKKwkJCX0KKwkJCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzKTsKKwkJCSAgICAgaSsrKSB7CisJCQkJbWVtY3B5KGJ1Ziwgdm14bmV0M190cV9kcml2ZXJfc3RhdHNbaV0uZGVzYywKKwkJCQkgICAgICAgRVRIX0dTVFJJTkdfTEVOKTsKKwkJCQlidWYgKz0gRVRIX0dTVFJJTkdfTEVOOworCQkJfQorCQl9CiAKLQkJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUodm14bmV0M190cV9kZXZfc3RhdHMpOyBpKyspIHsKLQkJCW1lbWNweShidWYsIHZteG5ldDNfdHFfZGV2X3N0YXRzW2ldLmRlc2MsCi0JCQkgICAgICAgRVRIX0dTVFJJTkdfTEVOKTsKLQkJCWJ1ZiArPSBFVEhfR1NUUklOR19MRU47CisJCWZvciAoaiA9IDA7IGogPCBhZGFwdGVyLT5udW1fcnhfcXVldWVzOyBqKyspIHsKKwkJCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHZteG5ldDNfcnFfZGV2X3N0YXRzKTsgaSsrKSB7CisJCQkJbWVtY3B5KGJ1Ziwgdm14bmV0M19ycV9kZXZfc3RhdHNbaV0uZGVzYywKKwkJCQkgICAgICAgRVRIX0dTVFJJTkdfTEVOKTsKKwkJCQlidWYgKz0gRVRIX0dTVFJJTkdfTEVOOworCQkJfQorCQkJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUodm14bmV0M19ycV9kcml2ZXJfc3RhdHMpOworCQkJICAgICBpKyspIHsKKwkJCQltZW1jcHkoYnVmLCB2bXhuZXQzX3JxX2RyaXZlcl9zdGF0c1tpXS5kZXNjLAorCQkJCSAgICAgICBFVEhfR1NUUklOR19MRU4pOworCQkJCWJ1ZiArPSBFVEhfR1NUUklOR19MRU47CisJCQl9CiAJCX0KLQkJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUodm14bmV0M190cV9kcml2ZXJfc3RhdHMpOyBpKyspIHsKLQkJCW1lbWNweShidWYsIHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzW2ldLmRlc2MsCi0JCQkgICAgICAgRVRIX0dTVFJJTkdfTEVOKTsKLQkJCWJ1ZiArPSBFVEhfR1NUUklOR19MRU47Ci0JCX0KLQkJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUodm14bmV0M19ycV9kZXZfc3RhdHMpOyBpKyspIHsKLQkJCW1lbWNweShidWYsIHZteG5ldDNfcnFfZGV2X3N0YXRzW2ldLmRlc2MsCi0JCQkgICAgICAgRVRIX0dTVFJJTkdfTEVOKTsKLQkJCWJ1ZiArPSBFVEhfR1NUUklOR19MRU47Ci0JCX0KLQkJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUodm14bmV0M19ycV9kcml2ZXJfc3RhdHMpOyBpKyspIHsKLQkJCW1lbWNweShidWYsIHZteG5ldDNfcnFfZHJpdmVyX3N0YXRzW2ldLmRlc2MsCi0JCQkgICAgICAgRVRIX0dTVFJJTkdfTEVOKTsKLQkJCWJ1ZiArPSBFVEhfR1NUUklOR19MRU47Ci0JCX0KKwogCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX2dsb2JhbF9zdGF0cyk7IGkrKykgewogCQkJbWVtY3B5KGJ1Ziwgdm14bmV0M19nbG9iYWxfc3RhdHNbaV0uZGVzYywKIAkJCQlFVEhfR1NUUklOR19MRU4pOwpAQCAtMjc3LDYgKzMwMiw3IEBACiAJc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CiAJdTggbHJvX3JlcXVlc3RlZCA9IChkYXRhICYgRVRIX0ZMQUdfTFJPKSA9PSAwID8gMCA6IDE7CiAJdTggbHJvX3ByZXNlbnQgPSAobmV0ZGV2LT5mZWF0dXJlcyAmIE5FVElGX0ZfTFJPKSA9PSAwID8gMCA6IDE7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCWlmIChkYXRhICYgfkVUSF9GTEFHX0xSTykKIAkJcmV0dXJuIC1FT1BOT1RTVVBQOwpAQCAtMjkyLDggKzMxOCwxMCBAQAogCQllbHNlCiAJCQlhZGFwdGVyLT5zaGFyZWQtPmRldlJlYWQubWlzYy51cHRGZWF0dXJlcyAmPQogCQkJCQkJCX5VUFQxX0ZfTFJPOworCQlzcGluX2xvY2tfaXJxc2F2ZSgmYWRhcHRlci0+Y21kX2xvY2ssIGZsYWdzKTsKIAkJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCiAJCQkJICAgICAgIFZNWE5FVDNfQ01EX1VQREFURV9GRUFUVVJFKTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYWRhcHRlci0+Y21kX2xvY2ssIGZsYWdzKTsKIAl9CiAJcmV0dXJuIDA7CiB9CkBAIC0zMDMsMzAgKzMzMSw0MSBAQAogCQkJICBzdHJ1Y3QgZXRodG9vbF9zdGF0cyAqc3RhdHMsIHU2NCAgKmJ1ZikKIHsKIAlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwogCXU4ICpiYXNlOwogCWludCBpOwogCWludCBqID0gMDsKIAorCXNwaW5fbG9ja19pcnFzYXZlKCZhZGFwdGVyLT5jbWRfbG9jaywgZmxhZ3MpOwogCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELCBWTVhORVQzX0NNRF9HRVRfU1RBVFMpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmFkYXB0ZXItPmNtZF9sb2NrLCBmbGFncyk7CiAKIAkvKiB0aGlzIGRvZXMgYXNzdW1lIGVhY2ggY291bnRlciBpcyA2NC1iaXQgd2lkZSAqLwotLyogVE9ETyBjaGFuZ2UgdGhpcyBmb3IgbXVsdGlwbGUgcXVldWVzICovCisJZm9yIChqID0gMDsgaiA8IGFkYXB0ZXItPm51bV90eF9xdWV1ZXM7IGorKykgeworCQliYXNlID0gKHU4ICopJmFkYXB0ZXItPnRxZF9zdGFydFtqXS5zdGF0czsKKwkJKmJ1ZisrID0gKHU2NClqOworCQlmb3IgKGkgPSAxOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX3RxX2Rldl9zdGF0cyk7IGkrKykKKwkJCSpidWYrKyA9ICoodTY0ICopKGJhc2UgKworCQkJCQkgIHZteG5ldDNfdHFfZGV2X3N0YXRzW2ldLm9mZnNldCk7CiAKLQliYXNlID0gKHU4ICopJmFkYXB0ZXItPnRxZF9zdGFydFtqXS5zdGF0czsKLQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX3RxX2Rldl9zdGF0cyk7IGkrKykKLQkJKmJ1ZisrID0gKih1NjQgKikoYmFzZSArIHZteG5ldDNfdHFfZGV2X3N0YXRzW2ldLm9mZnNldCk7CisJCWJhc2UgPSAodTggKikmYWRhcHRlci0+dHhfcXVldWVbal0uc3RhdHM7CisJCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzKTsgaSsrKQorCQkJKmJ1ZisrID0gKih1NjQgKikoYmFzZSArCisJCQkJCSAgdm14bmV0M190cV9kcml2ZXJfc3RhdHNbaV0ub2Zmc2V0KTsKKwl9CiAKLQliYXNlID0gKHU4ICopJmFkYXB0ZXItPnR4X3F1ZXVlW2pdLnN0YXRzOwotCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzKTsgaSsrKQotCQkqYnVmKysgPSAqKHU2NCAqKShiYXNlICsgdm14bmV0M190cV9kcml2ZXJfc3RhdHNbaV0ub2Zmc2V0KTsKKwlmb3IgKGogPSAwOyBqIDwgYWRhcHRlci0+bnVtX3R4X3F1ZXVlczsgaisrKSB7CisJCWJhc2UgPSAodTggKikmYWRhcHRlci0+cnFkX3N0YXJ0W2pdLnN0YXRzOworCQkqYnVmKysgPSAodTY0KSBqOworCQlmb3IgKGkgPSAxOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX3JxX2Rldl9zdGF0cyk7IGkrKykKKwkJCSpidWYrKyA9ICoodTY0ICopKGJhc2UgKworCQkJCQkgIHZteG5ldDNfcnFfZGV2X3N0YXRzW2ldLm9mZnNldCk7CiAKLQliYXNlID0gKHU4ICopJmFkYXB0ZXItPnJxZF9zdGFydFtqXS5zdGF0czsKLQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX3JxX2Rldl9zdGF0cyk7IGkrKykKLQkJKmJ1ZisrID0gKih1NjQgKikoYmFzZSArIHZteG5ldDNfcnFfZGV2X3N0YXRzW2ldLm9mZnNldCk7Ci0KLQliYXNlID0gKHU4ICopJmFkYXB0ZXItPnJ4X3F1ZXVlW2pdLnN0YXRzOwotCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHZteG5ldDNfcnFfZHJpdmVyX3N0YXRzKTsgaSsrKQotCQkqYnVmKysgPSAqKHU2NCAqKShiYXNlICsgdm14bmV0M19ycV9kcml2ZXJfc3RhdHNbaV0ub2Zmc2V0KTsKKwkJYmFzZSA9ICh1OCAqKSZhZGFwdGVyLT5yeF9xdWV1ZVtqXS5zdGF0czsKKwkJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUodm14bmV0M19ycV9kcml2ZXJfc3RhdHMpOyBpKyspCisJCQkqYnVmKysgPSAqKHU2NCAqKShiYXNlICsKKwkJCQkJICB2bXhuZXQzX3JxX2RyaXZlcl9zdGF0c1tpXS5vZmZzZXQpOworCX0KIAogCWJhc2UgPSAodTggKilhZGFwdGVyOwogCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHZteG5ldDNfZ2xvYmFsX3N0YXRzKTsgaSsrKQpAQCAtMzM5LDcgKzM3OCw3IEBACiB7CiAJc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CiAJdTMyICpidWYgPSBwOwotCWludCBpID0gMDsKKwlpbnQgaSA9IDAsIGogPSAwOwogCiAJbWVtc2V0KHAsIDAsIHZteG5ldDNfZ2V0X3JlZ3NfbGVuKG5ldGRldikpOwogCkBAIC0zNDgsMzEgKzM4NywzNSBAQAogCS8qIFVwZGF0ZSB2bXhuZXQzX2dldF9yZWdzX2xlbiBpZiB3ZSB3YW50IHRvIGR1bXAgbW9yZSByZWdpc3RlcnMgKi8KIAogCS8qIG1ha2UgZWFjaCByaW5nIHVzZSBtdWx0aXBsZSBvZiAxNiBieXRlcyAqLwotLyogVE9ETyBjaGFuZ2UgdGhpcyBmb3IgbXVsdGlwbGUgcXVldWVzICovCi0JYnVmWzBdID0gYWRhcHRlci0+dHhfcXVldWVbaV0udHhfcmluZy5uZXh0MmZpbGw7Ci0JYnVmWzFdID0gYWRhcHRlci0+dHhfcXVldWVbaV0udHhfcmluZy5uZXh0MmNvbXA7Ci0JYnVmWzJdID0gYWRhcHRlci0+dHhfcXVldWVbaV0udHhfcmluZy5nZW47Ci0JYnVmWzNdID0gMDsKKwlmb3IgKGkgPSAwOyBpIDwgYWRhcHRlci0+bnVtX3R4X3F1ZXVlczsgaSsrKSB7CisJCWJ1ZltqKytdID0gYWRhcHRlci0+dHhfcXVldWVbaV0udHhfcmluZy5uZXh0MmZpbGw7CisJCWJ1ZltqKytdID0gYWRhcHRlci0+dHhfcXVldWVbaV0udHhfcmluZy5uZXh0MmNvbXA7CisJCWJ1ZltqKytdID0gYWRhcHRlci0+dHhfcXVldWVbaV0udHhfcmluZy5nZW47CisJCWJ1ZltqKytdID0gMDsKIAotCWJ1Zls0XSA9IGFkYXB0ZXItPnR4X3F1ZXVlW2ldLmNvbXBfcmluZy5uZXh0MnByb2M7Ci0JYnVmWzVdID0gYWRhcHRlci0+dHhfcXVldWVbaV0uY29tcF9yaW5nLmdlbjsKLQlidWZbNl0gPSBhZGFwdGVyLT50eF9xdWV1ZVtpXS5zdG9wcGVkOwotCWJ1Zls3XSA9IDA7CisJCWJ1ZltqKytdID0gYWRhcHRlci0+dHhfcXVldWVbaV0uY29tcF9yaW5nLm5leHQycHJvYzsKKwkJYnVmW2orK10gPSBhZGFwdGVyLT50eF9xdWV1ZVtpXS5jb21wX3JpbmcuZ2VuOworCQlidWZbaisrXSA9IGFkYXB0ZXItPnR4X3F1ZXVlW2ldLnN0b3BwZWQ7CisJCWJ1ZltqKytdID0gMDsKKwl9CiAKLQlidWZbOF0gPSBhZGFwdGVyLT5yeF9xdWV1ZVtpXS5yeF9yaW5nWzBdLm5leHQyZmlsbDsKLQlidWZbOV0gPSBhZGFwdGVyLT5yeF9xdWV1ZVtpXS5yeF9yaW5nWzBdLm5leHQyY29tcDsKLQlidWZbMTBdID0gYWRhcHRlci0+cnhfcXVldWVbaV0ucnhfcmluZ1swXS5nZW47Ci0JYnVmWzExXSA9IDA7CisJZm9yIChpID0gMDsgaSA8IGFkYXB0ZXItPm51bV9yeF9xdWV1ZXM7IGkrKykgeworCQlidWZbaisrXSA9IGFkYXB0ZXItPnJ4X3F1ZXVlW2ldLnJ4X3JpbmdbMF0ubmV4dDJmaWxsOworCQlidWZbaisrXSA9IGFkYXB0ZXItPnJ4X3F1ZXVlW2ldLnJ4X3JpbmdbMF0ubmV4dDJjb21wOworCQlidWZbaisrXSA9IGFkYXB0ZXItPnJ4X3F1ZXVlW2ldLnJ4X3JpbmdbMF0uZ2VuOworCQlidWZbaisrXSA9IDA7CiAKLQlidWZbMTJdID0gYWRhcHRlci0+cnhfcXVldWVbaV0ucnhfcmluZ1sxXS5uZXh0MmZpbGw7Ci0JYnVmWzEzXSA9IGFkYXB0ZXItPnJ4X3F1ZXVlW2ldLnJ4X3JpbmdbMV0ubmV4dDJjb21wOwotCWJ1ZlsxNF0gPSBhZGFwdGVyLT5yeF9xdWV1ZVtpXS5yeF9yaW5nWzFdLmdlbjsKLQlidWZbMTVdID0gMDsKKwkJYnVmW2orK10gPSBhZGFwdGVyLT5yeF9xdWV1ZVtpXS5yeF9yaW5nWzFdLm5leHQyZmlsbDsKKwkJYnVmW2orK10gPSBhZGFwdGVyLT5yeF9xdWV1ZVtpXS5yeF9yaW5nWzFdLm5leHQyY29tcDsKKwkJYnVmW2orK10gPSBhZGFwdGVyLT5yeF9xdWV1ZVtpXS5yeF9yaW5nWzFdLmdlbjsKKwkJYnVmW2orK10gPSAwOwogCi0JYnVmWzE2XSA9IGFkYXB0ZXItPnJ4X3F1ZXVlW2ldLmNvbXBfcmluZy5uZXh0MnByb2M7Ci0JYnVmWzE3XSA9IGFkYXB0ZXItPnJ4X3F1ZXVlW2ldLmNvbXBfcmluZy5nZW47Ci0JYnVmWzE4XSA9IDA7Ci0JYnVmWzE5XSA9IDA7CisJCWJ1ZltqKytdID0gYWRhcHRlci0+cnhfcXVldWVbaV0uY29tcF9yaW5nLm5leHQycHJvYzsKKwkJYnVmW2orK10gPSBhZGFwdGVyLT5yeF9xdWV1ZVtpXS5jb21wX3JpbmcuZ2VuOworCQlidWZbaisrXSA9IDA7CisJCWJ1ZltqKytdID0gMDsKKwl9CisKIH0KIAogCkBAIC01NzQsNiArNjE3LDcgQEAKIAkJICAgICAgY29uc3Qgc3RydWN0IGV0aHRvb2xfcnhmaF9pbmRpciAqcCkKIHsKIAl1bnNpZ25lZCBpbnQgaTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwogCXN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIgPSBuZXRkZXZfcHJpdihuZXRkZXYpOwogCXN0cnVjdCBVUFQxX1JTU0NvbmYgKnJzc0NvbmYgPSBhZGFwdGVyLT5yc3NfY29uZjsKIApAQCAtNTkyLDggKzYzNiwxMCBAQAogCWZvciAoaSA9IDA7IGkgPCByc3NDb25mLT5pbmRUYWJsZVNpemU7IGkrKykKIAkJcnNzQ29uZi0+aW5kVGFibGVbaV0gPSBwLT5yaW5nX2luZGV4W2ldOwogCisJc3Bpbl9sb2NrX2lycXNhdmUoJmFkYXB0ZXItPmNtZF9sb2NrLCBmbGFncyk7CiAJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCiAJCQkgICAgICAgVk1YTkVUM19DTURfVVBEQVRFX1JTU0lEVCk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYWRhcHRlci0+Y21kX2xvY2ssIGZsYWdzKTsKIAogCXJldHVybiAwOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC92bXhuZXQzL3ZteG5ldDNfaW50LmggYi9kcml2ZXJzL25ldC92bXhuZXQzL3ZteG5ldDNfaW50LmgKaW5kZXggN2ZhZGVlZC4uZmI1ZDI0NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdm14bmV0My92bXhuZXQzX2ludC5oCisrKyBiL2RyaXZlcnMvbmV0L3ZteG5ldDMvdm14bmV0M19pbnQuaApAQCAtNjgsMTAgKzY4LDEwIEBACiAvKgogICogVmVyc2lvbiBudW1iZXJzCiAgKi8KLSNkZWZpbmUgVk1YTkVUM19EUklWRVJfVkVSU0lPTl9TVFJJTkcgICAiMS4wLjE2LjAtayIKKyNkZWZpbmUgVk1YTkVUM19EUklWRVJfVkVSU0lPTl9TVFJJTkcgICAiMS4wLjI1LjAtayIKIAogLyogYSAzMi1iaXQgaW50LCBlYWNoIGJ5dGUgZW5jb2RlIGEgdmVyaW9uIG51bWJlciBpbiBWTVhORVQzX0RSSVZFUl9WRVJTSU9OICovCi0jZGVmaW5lIFZNWE5FVDNfRFJJVkVSX1ZFUlNJT05fTlVNICAgICAgMHgwMTAwMTAwMAorI2RlZmluZSBWTVhORVQzX0RSSVZFUl9WRVJTSU9OX05VTSAgICAgIDB4MDEwMDE5MDAKIAogI2lmIGRlZmluZWQoQ09ORklHX1BDSV9NU0kpCiAJLyogUlNTIG9ubHkgbWFrZXMgc2Vuc2UgaWYgTVNJLVggaXMgc3VwcG9ydGVkLiAqLwpAQCAtMjg5LDcgKzI4OSw3IEBACiAKICNkZWZpbmUgVk1YTkVUM19MSU5VWF9NQVhfTVNJWF9WRUNUICAgICAoVk1YTkVUM19ERVZJQ0VfTUFYX1RYX1FVRVVFUyArIFwKIAkJCQkJIFZNWE5FVDNfREVWSUNFX01BWF9SWF9RVUVVRVMgKyAxKQotI2RlZmluZSBWTVhORVQzX0xJTlVYX01JTl9NU0lYX1ZFQ1QgICAgIDMgICAgLyogMSBmb3IgZWFjaCA6IHR4LCByeCBhbmQgZXZlbnQgKi8KKyNkZWZpbmUgVk1YTkVUM19MSU5VWF9NSU5fTVNJWF9WRUNUICAgICAyIC8qIDEgZm9yIHR4LXJ4IHBhaXIgYW5kIDEgZm9yIGV2ZW50ICovCiAKIAogc3RydWN0IHZteG5ldDNfaW50ciB7CkBAIC0zMTcsNiArMzE3LDcgQEAKIAlzdHJ1Y3Qgdm14bmV0M19yeF9xdWV1ZQkJcnhfcXVldWVbVk1YTkVUM19ERVZJQ0VfTUFYX1JYX1FVRVVFU107CiAJc3RydWN0IHZsYW5fZ3JvdXAJCSp2bGFuX2dycDsKIAlzdHJ1Y3Qgdm14bmV0M19pbnRyCQlpbnRyOworCXNwaW5sb2NrX3QJCQljbWRfbG9jazsKIAlzdHJ1Y3QgVm14bmV0M19Ecml2ZXJTaGFyZWQJKnNoYXJlZDsKIAlzdHJ1Y3QgVm14bmV0M19QTUNvbmYJCSpwbV9jb25mOwogCXN0cnVjdCBWbXhuZXQzX1R4UXVldWVEZXNjCSp0cWRfc3RhcnQ7ICAgICAvKiBhbGwgdHggcXVldWUgZGVzYyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdnhnZS92eGdlLWNvbmZpZy5jIGIvZHJpdmVycy9uZXQvdnhnZS92eGdlLWNvbmZpZy5jCmluZGV4IDAxYzA1ZjUuLjIyOGQ0ZjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3Z4Z2UvdnhnZS1jb25maWcuYworKysgYi9kcml2ZXJzL25ldC92eGdlL3Z4Z2UtY29uZmlnLmMKQEAgLTM2OTAsNyArMzY5MCw3IEBACiAJaWYgKHN0YXR1cyAhPSBWWEdFX0hXX09LKQogCQlnb3RvIGV4aXQ7CiAKLQlpZiAoKHJ0c190YWJsZSAhPSBWWEdFX0hXX1JUU19BQ0NFU1NfU1RFRVJfQ1RSTF9EQVRBX1NUUlVDVF9TRUxfREEpIHx8CisJaWYgKChydHNfdGFibGUgIT0gVlhHRV9IV19SVFNfQUNDRVNTX1NURUVSX0NUUkxfREFUQV9TVFJVQ1RfU0VMX0RBKSAmJgogCSAgICAocnRzX3RhYmxlICE9CiAJICAgICBWWEdFX0hXX1JUU19BQ1NfU1RFRVJfQ1RSTF9EQVRBX1NUUlVDVF9TRUxfUlRIX01VTFRJX0lUKSkKIAkJKmRhdGExID0gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3Z4Z2UvdnhnZS1tYWluLmMgYi9kcml2ZXJzL25ldC92eGdlL3Z4Z2UtbWFpbi5jCmluZGV4IDFhYzliNTYuLmM4MWE2NTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3Z4Z2UvdnhnZS1tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvdnhnZS92eGdlLW1haW4uYwpAQCAtNDEyMCw2ICs0MTIwLDcgQEAKIAkgICAgICAgImhvdHBsdWcgZXZlbnQuXG4iKTsKIAogb3V0OgorCXJlbGVhc2VfZmlybXdhcmUoZncpOwogCXJldHVybiByZXQ7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9iYXNlLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvYmFzZS5jCmluZGV4IDAxOWE3NGQuLjA5YWU0ZWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9iYXNlLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDVrL2Jhc2UuYwpAQCAtMjI5NCw2ICsyMjk0LDggQEAKIAlpbnQgaTsKIAlib29sIG5lZWRyZXNldCA9IGZhbHNlOwogCisJbXV0ZXhfbG9jaygmc2MtPmxvY2spOworCiAJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoc2MtPnR4cXMpOyBpKyspIHsKIAkJaWYgKHNjLT50eHFzW2ldLnNldHVwKSB7CiAJCQl0eHEgPSAmc2MtPnR4cXNbaV07CkBAIC0yMzIxLDYgKzIzMjMsOCBAQAogCQlhdGg1a19yZXNldChzYywgTlVMTCwgdHJ1ZSk7CiAJfQogCisJbXV0ZXhfdW5sb2NrKCZzYy0+bG9jayk7CisKIAlpZWVlODAyMTFfcXVldWVfZGVsYXllZF93b3JrKHNjLT5odywgJnNjLT50eF9jb21wbGV0ZV93b3JrLAogCQltc2Vjc190b19qaWZmaWVzKEFUSDVLX1RYX0NPTVBMRVRFX1BPTExfSU5UKSk7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvZG1hLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvZG1hLmMKaW5kZXggMDA2NGJlNy4uMjEwOTFjMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDVrL2RtYS5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9kbWEuYwpAQCAtODM4LDkgKzgzOCw5IEBACiAJZm9yIChpID0gMDsgaSA8IHFtYXg7IGkrKykgewogCQllcnIgPSBhdGg1a19od19zdG9wX3R4X2RtYShhaCwgaSk7CiAJCS8qIC1FSU5WQUwgLT4gcXVldWUgaW5hY3RpdmUgKi8KLQkJaWYgKGVyciAhPSAtRUlOVkFMKQorCQlpZiAoZXJyICYmIGVyciAhPSAtRUlOVkFMKQogCQkJcmV0dXJuIGVycjsKIAl9CiAKLQlyZXR1cm4gZXJyOworCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDVrL3BjdS5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDVrL3BjdS5jCmluZGV4IGU1ZjJiOTYuLmE3MDI4MTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg1ay9wY3UuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoNWsvcGN1LmMKQEAgLTg2LDcgKzg2LDcgQEAKIAlpZiAoIWFoLT5haF9id21vZGUpIHsKIAkJZHVyID0gaWVlZTgwMjExX2dlbmVyaWNfZnJhbWVfZHVyYXRpb24oc2MtPmh3LAogCQkJCQkJTlVMTCwgbGVuLCByYXRlKTsKLQkJcmV0dXJuIGR1cjsKKwkJcmV0dXJuIGxlMTZfdG9fY3B1KGR1cik7CiAJfQogCiAJYml0cmF0ZSA9IHJhdGUtPmJpdHJhdGU7CkBAIC0yNjUsOCArMjY1LDYgQEAKIAkJICogd2hhdCByYXRlIHdlIHNob3VsZCBjaG9vc2UgdG8gVFggQUNLcy4gKi8KIAkJdHhfdGltZSA9IGF0aDVrX2h3X2dldF9mcmFtZV9kdXJhdGlvbihhaCwgMTAsIHJhdGUpOwogCi0JCXR4X3RpbWUgPSBsZTE2X3RvX2NwdSh0eF90aW1lKTsKLQogCQlhdGg1a19od19yZWdfd3JpdGUoYWgsIHR4X3RpbWUsIHJlZyk7CiAKIAkJaWYgKCEocmF0ZS0+ZmxhZ3MgJiBJRUVFODAyMTFfUkFURV9TSE9SVF9QUkVBTUJMRSkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvYXI5MDAyX2NhbGliLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvYXI5MDAyX2NhbGliLmMKaW5kZXggMDE4ODBhYS4uNWUzMDBiZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2FyOTAwMl9jYWxpYi5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9hcjkwMDJfY2FsaWIuYwpAQCAtNjc5LDEwICs2NzksNiBAQAogCiAJLyogRG8gTkYgY2FsIG9ubHkgYXQgbG9uZ2VyIGludGVydmFscyAqLwogCWlmIChsb25nY2FsIHx8IG5mY2FsX3BlbmRpbmcpIHsKLQkJLyogRG8gcGVyaW9kaWMgUEFPZmZzZXQgQ2FsICovCi0JCWFyOTAwMl9od19wYV9jYWwoYWgsIGZhbHNlKTsKLQkJYXI5MDAyX2h3X29sY190ZW1wX2NvbXBlbnNhdGlvbihhaCk7Ci0KIAkJLyoKIAkJICogR2V0IHRoZSB2YWx1ZSBmcm9tIHRoZSBwcmV2aW91cyBORiBjYWwgYW5kIHVwZGF0ZQogCQkgKiBoaXN0b3J5IGJ1ZmZlci4KQEAgLTY5Nyw4ICs2OTMsMTIgQEAKIAkJCWF0aDlrX2h3X2xvYWRuZihhaCwgYWgtPmN1cmNoYW4pOwogCQl9CiAKLQkJaWYgKGxvbmdjYWwpCisJCWlmIChsb25nY2FsKSB7CiAJCQlhdGg5a19od19zdGFydF9uZmNhbChhaCwgZmFsc2UpOworCQkJLyogRG8gcGVyaW9kaWMgUEFPZmZzZXQgQ2FsICovCisJCQlhcjkwMDJfaHdfcGFfY2FsKGFoLCBmYWxzZSk7CisJCQlhcjkwMDJfaHdfb2xjX3RlbXBfY29tcGVuc2F0aW9uKGFoKTsKKwkJfQogCX0KIAogCXJldHVybiBpc2NhbGRvbmU7CkBAIC05NTQsNiArOTU0LDkgQEAKIAkJCQkmYWRjX2RjX2NhbF9tdWx0aV9zYW1wbGU7CiAJCX0KIAkJYWgtPnN1cHBfY2FscyA9IEFEQ19HQUlOX0NBTCB8IEFEQ19EQ19DQUwgfCBJUV9NSVNNQVRDSF9DQUw7CisKKwkJaWYgKEFSX1NSRVZfOTI4NyhhaCkpCisJCQlhaC0+c3VwcF9jYWxzICY9IH5BRENfR0FJTl9DQUw7CiAJfQogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvYXI5MDAyX2h3LmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvYXI5MDAyX2h3LmMKaW5kZXggZjhhNzc3MS4uZjQ0Yzg0YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2FyOTAwMl9ody5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9hcjkwMDJfaHcuYwpAQCAtNDI2LDkgKzQyNiw4IEBACiAJCX0KIAogCQkvKiBXQVIgZm9yIEFTUE0gc3lzdGVtIGhhbmcgKi8KLQkJaWYgKEFSX1NSRVZfOTI4MChhaCkgfHwgQVJfU1JFVl85Mjg1KGFoKSB8fCBBUl9TUkVWXzkyODcoYWgpKSB7CisJCWlmIChBUl9TUkVWXzkyODUoYWgpIHx8IEFSX1NSRVZfOTI4NyhhaCkpCiAJCQl2YWwgfD0gKEFSX1dBX0JJVDYgfCBBUl9XQV9CSVQ3KTsKLQkJfQogCiAJCWlmIChBUl9TUkVWXzkyODVFXzIwKGFoKSkKIAkJCXZhbCB8PSBBUl9XQV9CSVQyMzsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9hcjkwMDNfMnAyX2luaXR2YWxzLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvYXI5MDAzXzJwMl9pbml0dmFscy5oCmluZGV4IDgxZjljZjIuLjllY2NhOTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9hcjkwMDNfMnAyX2luaXR2YWxzLmgKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2FyOTAwM18ycDJfaW5pdHZhbHMuaApAQCAtMTg0Miw3ICsxODQyLDcgQEAKIAogc3RhdGljIGNvbnN0IHUzMiBhcjkzMDBQY2llUGh5X3BsbF9vbl9jbGtyZXFfZGlzYWJsZV9MMV8ycDJbXVsyXSA9IHsKIAkvKiBBZGRyICAgICAgYWxsbW9kZXMgICovCi0JezB4MDAwMDQwNDAsIDB4MDgyMTJlNWV9LAorCXsweDAwMDA0MDQwLCAweDA4MjEyNjVlfSwKIAl7MHgwMDAwNDA0MCwgMHgwMDA4MDAzYn0sCiAJezB4MDAwMDQwNDQsIDB4MDAwMDAwMDB9LAogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9hcjkwMDNfaHcuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9hcjkwMDNfaHcuYwppbmRleCA2MTM3NjM0Li4wNmZiMmM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvYXI5MDAzX2h3LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2FyOTAwM19ody5jCkBAIC0xNDYsOCArMTQ2LDggQEAKIAkJLyogU2xlZXAgU2V0dGluZyAqLwogCiAJCUlOSVRfSU5JX0FSUkFZKCZhaC0+aW5pUGNpZVNlcmRlc0xvd1Bvd2VyLAotCQkJCWFyOTMwMFBjaWVQaHlfY2xrcmVxX2VuYWJsZV9MMV8ycDIsCi0JCQkJQVJSQVlfU0laRShhcjkzMDBQY2llUGh5X2Nsa3JlcV9lbmFibGVfTDFfMnAyKSwKKwkJCQlhcjkzMDBQY2llUGh5X3BsbF9vbl9jbGtyZXFfZGlzYWJsZV9MMV8ycDIsCisJCQkJQVJSQVlfU0laRShhcjkzMDBQY2llUGh5X3BsbF9vbl9jbGtyZXFfZGlzYWJsZV9MMV8ycDIpLAogCQkJCTIpOwogCiAJCS8qIEZhc3QgY2xvY2sgbW9kYWwgc2V0dGluZ3MgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9hdGg5ay5oIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2F0aDlrLmgKaW5kZXggMzY4MWNhZjUuLjIzODM4ZTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9hdGg5ay5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9hdGg5ay5oCkBAIC0yMTgsNiArMjE4LDcgQEAKIHN0cnVjdCBhdGhfYnVmX3N0YXRlIHsKIAl1OCBiZl90eXBlOwogCXU4IGJmc19wYXByZDsKKwl1bnNpZ25lZCBsb25nIGJmc19wYXByZF90aW1lc3RhbXA7CiAJZW51bSBhdGg5a19pbnRlcm5hbF9mcmFtZV90eXBlIGJmc19mdHlwZTsKIH07CiAKQEAgLTU5Myw3ICs1OTQsNiBAQAogCXN0cnVjdCB3b3JrX3N0cnVjdCBwYXByZF93b3JrOwogCXN0cnVjdCB3b3JrX3N0cnVjdCBod19jaGVja193b3JrOwogCXN0cnVjdCBjb21wbGV0aW9uIHBhcHJkX2NvbXBsZXRlOwotCWJvb2wgcGFwcmRfcGVuZGluZzsKIAogCXUzMiBpbnRyc3RhdHVzOwogCXUzMiBzY19mbGFnczsgLyogU0NfT1BfKiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2VlcHJvbV9kZWYuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9lZXByb21fZGVmLmMKaW5kZXggMDg4ZjE0MS4uNzQ5YTkzNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2VlcHJvbV9kZWYuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvZWVwcm9tX2RlZi5jCkBAIC0yMjYsNiArMjI2LDEwIEBACiAJICAgIGVlcC0+YmFzZUVlcEhlYWRlci5wd2RjbGtpbmQgPT0gMCkKIAkJYWgtPm5lZWRfYW5fdG9wMl9maXh1cCA9IDE7CiAKKwlpZiAoKGNvbW1vbi0+YnVzX29wcy0+YXRoX2J1c190eXBlID09IEFUSF9VU0IpICYmCisJICAgIChBUl9TUkVWXzkyODAoYWgpKSkKKwkJZWVwLT5tb2RhbEhlYWRlclswXS54cGFCaWFzTHZsID0gMDsKKwogCXJldHVybiAwOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvaHRjLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvaHRjLmgKaW5kZXggYTA5OWIzZS4uNzgwYWM1ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2h0Yy5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9odGMuaApAQCAtNzgsNyArNzgsNyBAQAogCXU4IG5vZGVfaWR4OwogCXU4IHZpZl9pZHg7CiAJdTggdGlkbm87Ci0JdTMyIGZsYWdzOyAvKiBBVEg5S19IVENfVFhfKiAqLworCV9fYmUzMiBmbGFnczsgLyogQVRIOUtfSFRDX1RYXyogKi8KIAl1OCBrZXlfdHlwZTsKIAl1OCBrZXlpeDsKIAl1OCByZXNlcnZlZFsyNl07CkBAIC00MzMsNiArNDMzLDcgQEAKIHZvaWQgYXRoOWtfaHRjX2JlYWNvbmVwKHZvaWQgKmRydl9wcml2LCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAogCQkJZW51bSBodGNfZW5kcG9pbnRfaWQgZXBfaWQsIGJvb2wgdHhvayk7CiAKK2ludCBhdGg5a19odGNfdXBkYXRlX2NhcF90YXJnZXQoc3RydWN0IGF0aDlrX2h0Y19wcml2ICpwcml2KTsKIHZvaWQgYXRoOWtfaHRjX3N0YXRpb25fd29yayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspOwogdm9pZCBhdGg5a19odGNfYWdncl93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yayk7CiB2b2lkIGF0aDlrX2FuaV93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yayk7OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2h0Y19kcnZfaW5pdC5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2h0Y19kcnZfaW5pdC5jCmluZGV4IDM4NDMzZjkuLjAzNTJmMDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9odGNfZHJ2X2luaXQuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvaHRjX2Rydl9pbml0LmMKQEAgLTE0Miw5ICsxNDIsNiBAQAogewogCWF0aDlrX2h0Y19leGl0X2RlYnVnKHByaXYtPmFoKTsKIAlhdGg5a19od19kZWluaXQocHJpdi0+YWgpOwotCXRhc2tsZXRfa2lsbCgmcHJpdi0+c3diYV90YXNrbGV0KTsKLQl0YXNrbGV0X2tpbGwoJnByaXYtPnJ4X3Rhc2tsZXQpOwotCXRhc2tsZXRfa2lsbCgmcHJpdi0+dHhfdGFza2xldCk7CiAJa2ZyZWUocHJpdi0+YWgpOwogCXByaXYtPmFoID0gTlVMTDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9odGNfZHJ2X21haW4uYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9odGNfZHJ2X21haW4uYwppbmRleCA4NDViNGM5Li42YmI1OTk1IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvaHRjX2Rydl9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2h0Y19kcnZfbWFpbi5jCkBAIC0zMDEsNiArMzAxLDE2IEBACiAKIAlwcml2LT5uc3RhdGlvbnMrKzsKIAorCS8qCisJICogU2V0IGNoYWlubWFzayBldGMuIG9uIHRoZSB0YXJnZXQuCisJICovCisJcmV0ID0gYXRoOWtfaHRjX3VwZGF0ZV9jYXBfdGFyZ2V0KHByaXYpOworCWlmIChyZXQpCisJCWF0aF9kYmcoY29tbW9uLCBBVEhfREJHX0NPTkZJRywKKwkJCSJGYWlsZWQgdG8gdXBkYXRlIGNhcGFiaWxpdHkgaW4gdGFyZ2V0XG4iKTsKKworCXByaXYtPmFoLT5pc19tb25pdG9yaW5nID0gdHJ1ZTsKKwogCXJldHVybiAwOwogCiBlcnJfdmlmOgpAQCAtMzI4LDYgKzMzOCw3IEBACiAJfQogCiAJcHJpdi0+bnN0YXRpb25zLS07CisJcHJpdi0+YWgtPmlzX21vbml0b3JpbmcgPSBmYWxzZTsKIAogCXJldHVybiAwOwogfQpAQCAtNDE5LDcgKzQzMCw3IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgYXRoOWtfaHRjX3VwZGF0ZV9jYXBfdGFyZ2V0KHN0cnVjdCBhdGg5a19odGNfcHJpdiAqcHJpdikKK2ludCBhdGg5a19odGNfdXBkYXRlX2NhcF90YXJnZXQoc3RydWN0IGF0aDlrX2h0Y19wcml2ICpwcml2KQogewogCXN0cnVjdCBhdGg5a19odGNfY2FwX3RhcmdldCB0Y2FwOwogCWludCByZXQ7CkBAIC0xMDE0LDEyICsxMDI1LDYgQEAKIAlpbnQgcmV0ID0gMDsKIAl1OCBjbWRfcnNwOwogCi0JLyogQ2FuY2VsIGFsbCB0aGUgcnVubmluZyB0aW1lcnMvd29yayAuLiAqLwotCWNhbmNlbF93b3JrX3N5bmMoJnByaXYtPmZhdGFsX3dvcmspOwotCWNhbmNlbF93b3JrX3N5bmMoJnByaXYtPnBzX3dvcmspOwotCWNhbmNlbF9kZWxheWVkX3dvcmtfc3luYygmcHJpdi0+YXRoOWtfbGVkX2JsaW5rX3dvcmspOwotCWF0aDlrX2xlZF9zdG9wX2JyaWdodG5lc3MocHJpdik7Ci0KIAltdXRleF9sb2NrKCZwcml2LT5tdXRleCk7CiAKIAlpZiAocHJpdi0+b3BfZmxhZ3MgJiBPUF9JTlZBTElEKSB7CkBAIC0xMDMzLDggKzEwMzgsMjMgQEAKIAlXTUlfQ01EKFdNSV9ESVNBQkxFX0lOVFJfQ01ESUQpOwogCVdNSV9DTUQoV01JX0RSQUlOX1RYUV9BTExfQ01ESUQpOwogCVdNSV9DTUQoV01JX1NUT1BfUkVDVl9DTURJRCk7CisKKwl0YXNrbGV0X2tpbGwoJnByaXYtPnN3YmFfdGFza2xldCk7CisJdGFza2xldF9raWxsKCZwcml2LT5yeF90YXNrbGV0KTsKKwl0YXNrbGV0X2tpbGwoJnByaXYtPnR4X3Rhc2tsZXQpOworCiAJc2tiX3F1ZXVlX3B1cmdlKCZwcml2LT50eF9xdWV1ZSk7CiAKKwltdXRleF91bmxvY2soJnByaXYtPm11dGV4KTsKKworCS8qIENhbmNlbCBhbGwgdGhlIHJ1bm5pbmcgdGltZXJzL3dvcmsgLi4gKi8KKwljYW5jZWxfd29ya19zeW5jKCZwcml2LT5mYXRhbF93b3JrKTsKKwljYW5jZWxfd29ya19zeW5jKCZwcml2LT5wc193b3JrKTsKKwljYW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJnByaXYtPmF0aDlrX2xlZF9ibGlua193b3JrKTsKKwlhdGg5a19sZWRfc3RvcF9icmlnaHRuZXNzKHByaXYpOworCisJbXV0ZXhfbG9jaygmcHJpdi0+bXV0ZXgpOworCiAJLyogUmVtb3ZlIG1vbml0b3IgaW50ZXJmYWNlIGhlcmUgKi8KIAlpZiAoYWgtPm9wbW9kZSA9PSBOTDgwMjExX0lGVFlQRV9NT05JVE9SKSB7CiAJCWlmIChhdGg5a19odGNfcmVtb3ZlX21vbml0b3JfaW50ZXJmYWNlKHByaXYpKQpAQCAtMTE4Niw2ICsxMjA2LDIwIEBACiAJCX0KIAl9CiAKKwkvKgorCSAqIE1vbml0b3IgaW50ZXJmYWNlIHNob3VsZCBiZSBhZGRlZCBiZWZvcmUKKwkgKiBJRUVFODAyMTFfQ09ORl9DSEFOR0VfQ0hBTk5FTCBpcyBoYW5kbGVkLgorCSAqLworCWlmIChjaGFuZ2VkICYgSUVFRTgwMjExX0NPTkZfQ0hBTkdFX01PTklUT1IpIHsKKwkJaWYgKGNvbmYtPmZsYWdzICYgSUVFRTgwMjExX0NPTkZfTU9OSVRPUikgeworCQkJaWYgKGF0aDlrX2h0Y19hZGRfbW9uaXRvcl9pbnRlcmZhY2UocHJpdikpCisJCQkJYXRoX2Vycihjb21tb24sICJGYWlsZWQgdG8gc2V0IG1vbml0b3IgbW9kZVxuIik7CisJCQllbHNlCisJCQkJYXRoX2RiZyhjb21tb24sIEFUSF9EQkdfQ09ORklHLAorCQkJCQkiSFcgb3Btb2RlIHNldCB0byBNb25pdG9yIG1vZGVcbiIpOworCQl9CisJfQorCiAJaWYgKGNoYW5nZWQgJiBJRUVFODAyMTFfQ09ORl9DSEFOR0VfQ0hBTk5FTCkgewogCQlzdHJ1Y3QgaWVlZTgwMjExX2NoYW5uZWwgKmN1cmNoYW4gPSBody0+Y29uZi5jaGFubmVsOwogCQlpbnQgcG9zID0gY3VyY2hhbi0+aHdfdmFsdWU7CkBAIC0xMjIxLDE2ICsxMjU1LDYgQEAKIAkJYXRoX3VwZGF0ZV90eHBvdyhwcml2KTsKIAl9CiAKLQlpZiAoY2hhbmdlZCAmIElFRUU4MDIxMV9DT05GX0NIQU5HRV9NT05JVE9SKSB7Ci0JCWlmIChjb25mLT5mbGFncyAmIElFRUU4MDIxMV9DT05GX01PTklUT1IpIHsKLQkJCWlmIChhdGg5a19odGNfYWRkX21vbml0b3JfaW50ZXJmYWNlKHByaXYpKQotCQkJCWF0aF9lcnIoY29tbW9uLCAiRmFpbGVkIHRvIHNldCBtb25pdG9yIG1vZGVcbiIpOwotCQkJZWxzZQotCQkJCWF0aF9kYmcoY29tbW9uLCBBVEhfREJHX0NPTkZJRywKLQkJCQkJIkhXIG9wbW9kZSBzZXQgdG8gTW9uaXRvciBtb2RlXG4iKTsKLQkJfQotCX0KLQogCWlmIChjaGFuZ2VkICYgSUVFRTgwMjExX0NPTkZfQ0hBTkdFX0lETEUpIHsKIAkJbXV0ZXhfbG9jaygmcHJpdi0+aHRjX3BtX2xvY2spOwogCQlpZiAoIXByaXYtPnBzX2lkbGUpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9odGNfZHJ2X3R4cnguYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9odGNfZHJ2X3R4cnguYwppbmRleCAzM2YzNjAyLi43YTVmZmNhIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvaHRjX2Rydl90eHJ4LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2h0Y19kcnZfdHhyeC5jCkBAIC0xMTMsNiArMTEzLDcgQEAKIAogCWlmIChpZWVlODAyMTFfaXNfZGF0YShmYykpIHsKIAkJc3RydWN0IHR4X2ZyYW1lX2hkciB0eF9oZHI7CisJCXUzMiBmbGFncyA9IDA7CiAJCXU4ICpxYzsKIAogCQltZW1zZXQoJnR4X2hkciwgMCwgc2l6ZW9mKHN0cnVjdCB0eF9mcmFtZV9oZHIpKTsKQEAgLTEzNiwxMyArMTM3LDE0IEBACiAJCS8qIENoZWNrIGZvciBSVFMgcHJvdGVjdGlvbiAqLwogCQlpZiAocHJpdi0+aHctPndpcGh5LT5ydHNfdGhyZXNob2xkICE9ICh1MzIpIC0xKQogCQkJaWYgKHNrYi0+bGVuID4gcHJpdi0+aHctPndpcGh5LT5ydHNfdGhyZXNob2xkKQotCQkJCXR4X2hkci5mbGFncyB8PSBBVEg5S19IVENfVFhfUlRTQ1RTOworCQkJCWZsYWdzIHw9IEFUSDlLX0hUQ19UWF9SVFNDVFM7CiAKIAkJLyogQ1RTLXRvLXNlbGYgKi8KLQkJaWYgKCEodHhfaGRyLmZsYWdzICYgQVRIOUtfSFRDX1RYX1JUU0NUUykgJiYKKwkJaWYgKCEoZmxhZ3MgJiBBVEg5S19IVENfVFhfUlRTQ1RTKSAmJgogCQkgICAgKHByaXYtPm9wX2ZsYWdzICYgT1BfUFJPVEVDVF9FTkFCTEUpKQotCQkJdHhfaGRyLmZsYWdzIHw9IEFUSDlLX0hUQ19UWF9DVFNPTkxZOworCQkJZmxhZ3MgfD0gQVRIOUtfSFRDX1RYX0NUU09OTFk7CiAKKwkJdHhfaGRyLmZsYWdzID0gY3B1X3RvX2JlMzIoZmxhZ3MpOwogCQl0eF9oZHIua2V5X3R5cGUgPSBhdGg5a19jbW5fZ2V0X2h3X2NyeXB0b19rZXl0eXBlKHNrYik7CiAJCWlmICh0eF9oZHIua2V5X3R5cGUgPT0gQVRIOUtfS0VZX1RZUEVfQ0xFQVIpCiAJCQl0eF9oZHIua2V5aXggPSAodTgpIEFUSDlLX1RYS0VZSVhfSU5WQUxJRDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9ody5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2h3LmMKaW5kZXggZmRlOTc4Ni4uOWYwMWU1MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2h3LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2h3LmMKQEAgLTM2OSw2ICszNjksOSBAQAogCWVsc2UKIAkJYWgtPmNvbmZpZy5odF9lbmFibGUgPSAwOwogCisJLyogUEFQUkQgbmVlZHMgc29tZSBtb3JlIHdvcmsgdG8gYmUgZW5hYmxlZCAqLworCWFoLT5jb25maWcucGFwcmRfZGlzYWJsZSA9IDE7CisKIAlhaC0+Y29uZmlnLnJ4X2ludHJfbWl0aWdhdGlvbiA9IHRydWU7CiAJYWgtPmNvbmZpZy5wY2llU2VyRGVzV3JpdGUgPSB0cnVlOwogCkBAIC00MzYsOSArNDM5LDEwIEBACiAKIHN0YXRpYyBpbnQgYXRoOWtfaHdfcG9zdF9pbml0KHN0cnVjdCBhdGhfaHcgKmFoKQogeworCXN0cnVjdCBhdGhfY29tbW9uICpjb21tb24gPSBhdGg5a19od19jb21tb24oYWgpOwogCWludCBlY29kZTsKIAotCWlmICghQVJfU1JFVl85MjcxKGFoKSkgeworCWlmIChjb21tb24tPmJ1c19vcHMtPmF0aF9idXNfdHlwZSAhPSBBVEhfVVNCKSB7CiAJCWlmICghYXRoOWtfaHdfY2hpcF90ZXN0KGFoKSkKIAkJCXJldHVybiAtRU5PREVWOwogCX0KQEAgLTEyMTMsNyArMTIxNyw3IEBACiAJYWgtPnR4Y2hhaW5tYXNrID0gY29tbW9uLT50eF9jaGFpbm1hc2s7CiAJYWgtPnJ4Y2hhaW5tYXNrID0gY29tbW9uLT5yeF9jaGFpbm1hc2s7CiAKLQlpZiAoIWFoLT5jaGlwX2Z1bGxzbGVlcCkgeworCWlmICgoY29tbW9uLT5idXNfb3BzLT5hdGhfYnVzX3R5cGUgIT0gQVRIX1VTQikgJiYgIWFoLT5jaGlwX2Z1bGxzbGVlcCkgewogCQlhdGg5a19od19hYm9ydHBjdXJlY3YoYWgpOwogCQlpZiAoIWF0aDlrX2h3X3N0b3BkbWFyZWN2KGFoKSkgewogCQkJYXRoX2RiZyhjb21tb24sIEFUSF9EQkdfWE1JVCwKQEAgLTE5MzIsNyArMTkzNiw4IEBACiAJCXBDYXAtPnJ4X3N0YXR1c19sZW4gPSBzaXplb2Yoc3RydWN0IGFyOTAwM19yeHMpOwogCQlwQ2FwLT50eF9kZXNjX2xlbiA9IHNpemVvZihzdHJ1Y3QgYXI5MDAzX3R4Yyk7CiAJCXBDYXAtPnR4c19sZW4gPSBzaXplb2Yoc3RydWN0IGFyOTAwM190eHMpOwotCQlpZiAoYWgtPmVlcF9vcHMtPmdldF9lZXByb20oYWgsIEVFUF9QQVBSRCkpCisJCWlmICghYWgtPmNvbmZpZy5wYXByZF9kaXNhYmxlICYmCisJCSAgICBhaC0+ZWVwX29wcy0+Z2V0X2VlcHJvbShhaCwgRUVQX1BBUFJEKSkKIAkJCXBDYXAtPmh3X2NhcHMgfD0gQVRIOUtfSFdfQ0FQX1BBUFJEOwogCX0gZWxzZSB7CiAJCXBDYXAtPnR4X2Rlc2NfbGVuID0gc2l6ZW9mKHN0cnVjdCBhdGhfZGVzYyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvaHcuaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9ody5oCmluZGV4IDVhM2RmZWMuLmVhOWZkZTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9ody5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9ody5oCkBAIC0yMjUsNiArMjI1LDcgQEAKIAl1MzIgcGNpZV93YWVuOwogCXU4IGFuYWxvZ19zaGlmdHJlZzsKIAl1OCBodF9lbmFibGU7CisJdTggcGFwcmRfZGlzYWJsZTsKIAl1MzIgb2ZkbV90cmlnX2xvdzsKIAl1MzIgb2ZkbV90cmlnX2hpZ2g7CiAJdTMyIGNja190cmlnX2hpZ2g7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvaW5pdC5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL2luaXQuYwppbmRleCA3NjdkOGI4Li4wODdhNmE5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvaW5pdC5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9pbml0LmMKQEAgLTU5OCw4ICs1OTgsNiBAQAogZXJyX3F1ZXVlczoKIAlhdGg5a19od19kZWluaXQoYWgpOwogZXJyX2h3OgotCXRhc2tsZXRfa2lsbCgmc2MtPmludHJfdHEpOwotCXRhc2tsZXRfa2lsbCgmc2MtPmJjb25fdGFza2xldCk7CiAKIAlrZnJlZShhaCk7CiAJc2MtPnNjX2FoID0gTlVMTDsKQEAgLTgwNyw5ICs4MDUsNiBAQAogCiAJYXRoOWtfaHdfZGVpbml0KHNjLT5zY19haCk7CiAKLQl0YXNrbGV0X2tpbGwoJnNjLT5pbnRyX3RxKTsKLQl0YXNrbGV0X2tpbGwoJnNjLT5iY29uX3Rhc2tsZXQpOwotCiAJa2ZyZWUoc2MtPnNjX2FoKTsKIAlzYy0+c2NfYWggPSBOVUxMOwogfQpAQCAtODI0LDYgKzgxOSw4IEBACiAJd2lwaHlfcmZraWxsX3N0b3BfcG9sbGluZyhzYy0+aHctPndpcGh5KTsKIAlhdGhfZGVpbml0X2xlZHMoc2MpOwogCisJYXRoOWtfcHNfcmVzdG9yZShzYyk7CisKIAlmb3IgKGkgPSAwOyBpIDwgc2MtPm51bV9zZWNfd2lwaHk7IGkrKykgewogCQlzdHJ1Y3QgYXRoX3dpcGh5ICphcGh5ID0gc2MtPnNlY193aXBoeVtpXTsKIAkJaWYgKGFwaHkgPT0gTlVMTCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9tYWluLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsvbWFpbi5jCmluZGV4IGY5MGE2Y2EuLmRhNWM2NDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL21haW4uYwpAQCAtMzI1LDYgKzMyNSw4IEBACiB7CiAJc3RydWN0IGllZWU4MDIxMV9odyAqaHcgPSBzYy0+aHc7CiAJc3RydWN0IGllZWU4MDIxMV90eF9pbmZvICp0eF9pbmZvID0gSUVFRTgwMjExX1NLQl9DQihza2IpOworCXN0cnVjdCBhdGhfaHcgKmFoID0gc2MtPnNjX2FoOworCXN0cnVjdCBhdGhfY29tbW9uICpjb21tb24gPSBhdGg5a19od19jb21tb24oYWgpOwogCXN0cnVjdCBhdGhfdHhfY29udHJvbCB0eGN0bDsKIAlpbnQgdGltZV9sZWZ0OwogCkBAIC0zNDAsMTQgKzM0MiwxNiBAQAogCXR4X2luZm8tPmNvbnRyb2wucmF0ZXNbMV0uaWR4ID0gLTE7CiAKIAlpbml0X2NvbXBsZXRpb24oJnNjLT5wYXByZF9jb21wbGV0ZSk7Ci0Jc2MtPnBhcHJkX3BlbmRpbmcgPSB0cnVlOwogCXR4Y3RsLnBhcHJkID0gQklUKGNoYWluKTsKLQlpZiAoYXRoX3R4X3N0YXJ0KGh3LCBza2IsICZ0eGN0bCkgIT0gMCkKKworCWlmIChhdGhfdHhfc3RhcnQoaHcsIHNrYiwgJnR4Y3RsKSAhPSAwKSB7CisJCWF0aF9kYmcoY29tbW9uLCBBVEhfREJHX1hNSVQsICJQQVBSRCBUWCBmYWlsZWRcbiIpOworCQlkZXZfa2ZyZWVfc2tiX2FueShza2IpOwogCQlyZXR1cm4gZmFsc2U7CisJfQogCiAJdGltZV9sZWZ0ID0gd2FpdF9mb3JfY29tcGxldGlvbl90aW1lb3V0KCZzYy0+cGFwcmRfY29tcGxldGUsCiAJCQltc2Vjc190b19qaWZmaWVzKEFUSF9QQVBSRF9USU1FT1VUKSk7Ci0Jc2MtPnBhcHJkX3BlbmRpbmcgPSBmYWxzZTsKIAogCWlmICghdGltZV9sZWZ0KQogCQlhdGhfZGJnKGF0aDlrX2h3X2NvbW1vbihzYy0+c2NfYWgpLCBBVEhfREJHX0NBTElCUkFURSwKQEAgLTU5MiwxNCArNTk2LDEyIEBACiAJdTMyIHN0YXR1cyA9IHNjLT5pbnRyc3RhdHVzOwogCXUzMiByeG1hc2s7CiAKLQlhdGg5a19wc193YWtldXAoc2MpOwotCiAJaWYgKHN0YXR1cyAmIEFUSDlLX0lOVF9GQVRBTCkgewogCQlhdGhfcmVzZXQoc2MsIHRydWUpOwotCQlhdGg5a19wc19yZXN0b3JlKHNjKTsKIAkJcmV0dXJuOwogCX0KIAorCWF0aDlrX3BzX3dha2V1cChzYyk7CiAJc3Bpbl9sb2NrKCZzYy0+c2NfcGN1X2xvY2spOwogCiAJaWYgKCFhdGg5a19od19jaGVja19hbGl2ZShhaCkpCkBAIC05NTUsOCArOTU3LDYgQEAKIAogCXNwaW5fdW5sb2NrX2JoKCZzYy0+c2NfcGN1X2xvY2spOwogCWF0aDlrX3BzX3Jlc3RvcmUoc2MpOwotCi0JYXRoOWtfc2V0cG93ZXIoc2MsIEFUSDlLX1BNX0ZVTExfU0xFRVApOwogfQogCiBpbnQgYXRoX3Jlc2V0KHN0cnVjdCBhdGhfc29mdGMgKnNjLCBib29sIHJldHJ5X3R4KQpAQCAtOTY5LDYgKzk2OSw3IEBACiAJLyogU3RvcCBBTkkgKi8KIAlkZWxfdGltZXJfc3luYygmY29tbW9uLT5hbmkudGltZXIpOwogCisJYXRoOWtfcHNfd2FrZXVwKHNjKTsKIAlzcGluX2xvY2tfYmgoJnNjLT5zY19wY3VfbG9jayk7CiAKIAlpZWVlODAyMTFfc3RvcF9xdWV1ZXMoaHcpOwpAQCAtMTAxNSw2ICsxMDE2LDcgQEAKIAogCS8qIFN0YXJ0IEFOSSAqLwogCWF0aF9zdGFydF9hbmkoY29tbW9uKTsKKwlhdGg5a19wc19yZXN0b3JlKHNjKTsKIAogCXJldHVybiByOwogfQpAQCAtMTMwOSw2ICsxMzExLDkgQEAKIAogCXNwaW5fbG9ja19iaCgmc2MtPnNjX3BjdV9sb2NrKTsKIAorCS8qIHByZXZlbnQgdGFza2xldHMgdG8gZW5hYmxlIGludGVycnVwdHMgb25jZSB3ZSBkaXNhYmxlIHRoZW0gKi8KKwlhaC0+aW1hc2sgJj0gfkFUSDlLX0lOVF9HTE9CQUw7CisKIAkvKiBtYWtlIHN1cmUgaC93IHdpbGwgbm90IGdlbmVyYXRlIGFueSBpbnRlcnJ1cHQKIAkgKiBiZWZvcmUgc2V0dGluZyB0aGUgaW52YWxpZCBmbGFnLiAqLwogCWF0aDlrX2h3X2Rpc2FibGVfaW50ZXJydXB0cyhhaCk7CkBAIC0xMzI2LDYgKzEzMzEsMTIgQEAKIAogCXNwaW5fdW5sb2NrX2JoKCZzYy0+c2NfcGN1X2xvY2spOwogCisJLyogd2UgY2FuIG5vdyBzeW5jIGlycSBhbmQga2lsbCBhbnkgcnVubmluZyB0YXNrbGV0cywgc2luY2Ugd2UgYWxyZWFkeQorCSAqIGRpc2FibGVkIGludGVycnVwdHMgYW5kIG5vdCBob2xkaW5nIGEgc3BpbiBsb2NrICovCisJc3luY2hyb25pemVfaXJxKHNjLT5pcnEpOworCXRhc2tsZXRfa2lsbCgmc2MtPmludHJfdHEpOworCXRhc2tsZXRfa2lsbCgmc2MtPmJjb25fdGFza2xldCk7CisKIAlhdGg5a19wc19yZXN0b3JlKHNjKTsKIAogCXNjLT5wc19pZGxlID0gdHJ1ZTsKQEAgLTE3MDEsNyArMTcxMiw5IEBACiBza2lwX2NoYW5fY2hhbmdlOgogCWlmIChjaGFuZ2VkICYgSUVFRTgwMjExX0NPTkZfQ0hBTkdFX1BPV0VSKSB7CiAJCXNjLT5jb25maWcudHhwb3dsaW1pdCA9IDIgKiBjb25mLT5wb3dlcl9sZXZlbDsKKwkJYXRoOWtfcHNfd2FrZXVwKHNjKTsKIAkJYXRoX3VwZGF0ZV90eHBvdyhzYyk7CisJCWF0aDlrX3BzX3Jlc3RvcmUoc2MpOwogCX0KIAogCXNwaW5fbG9ja19iaCgmc2MtPndpcGh5X2xvY2spOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL3htaXQuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9hdGg5ay94bWl0LmMKaW5kZXggMzMyZDFmZS4uMDdiNzgwNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2F0aDlrL3htaXQuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hdGgvYXRoOWsveG1pdC5jCkBAIC0xNzI1LDYgKzE3MjUsOSBAQAogCQkJYXI5MDAzX2h3X3NldF9wYXByZF90eGRlc2Moc2MtPnNjX2FoLCBiZi0+YmZfZGVzYywKIAkJCQkJCSAgIGJmLT5iZl9zdGF0ZS5iZnNfcGFwcmQpOwogCisJCWlmICh0eGN0bC0+cGFwcmQpCisJCQliZi0+YmZfc3RhdGUuYmZzX3BhcHJkX3RpbWVzdGFtcCA9IGppZmZpZXM7CisKIAkJYXRoX3R4X3NlbmRfbm9ybWFsKHNjLCB0eGN0bC0+dHhxLCB0aWQsICZiZl9oZWFkKTsKIAl9CiAKQEAgLTE4ODYsNyArMTg4OSw5IEBACiAJYmYtPmJmX2J1Zl9hZGRyID0gMDsKIAogCWlmIChiZi0+YmZfc3RhdGUuYmZzX3BhcHJkKSB7Ci0JCWlmICghc2MtPnBhcHJkX3BlbmRpbmcpCisJCWlmICh0aW1lX2FmdGVyKGppZmZpZXMsCisJCQkJYmYtPmJmX3N0YXRlLmJmc19wYXByZF90aW1lc3RhbXAgKworCQkJCW1zZWNzX3RvX2ppZmZpZXMoQVRIX1BBUFJEX1RJTUVPVVQpKSkKIAkJCWRldl9rZnJlZV9za2JfYW55KHNrYik7CiAJCWVsc2UKIAkJCWNvbXBsZXRlKCZzYy0+cGFwcmRfY29tcGxldGUpOwpAQCAtMjExMyw5ICsyMTE4LDcgQEAKIAlpZiAobmVlZHJlc2V0KSB7CiAJCWF0aF9kYmcoYXRoOWtfaHdfY29tbW9uKHNjLT5zY19haCksIEFUSF9EQkdfUkVTRVQsCiAJCQkidHggaHVuZywgcmVzZXR0aW5nIHRoZSBjaGlwXG4iKTsKLQkJYXRoOWtfcHNfd2FrZXVwKHNjKTsKIAkJYXRoX3Jlc2V0KHNjLCB0cnVlKTsKLQkJYXRoOWtfcHNfcmVzdG9yZShzYyk7CiAJfQogCiAJaWVlZTgwMjExX3F1ZXVlX2RlbGF5ZWRfd29yayhzYy0+aHcsICZzYy0+dHhfY29tcGxldGVfd29yaywKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2F0aC9jYXJsOTE3MC9yeC5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2Nhcmw5MTcwL3J4LmMKaW5kZXggOTM5YTBlOS4uODQ4NjZhNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2Nhcmw5MTcwL3J4LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYXRoL2Nhcmw5MTcwL3J4LmMKQEAgLTU2NCw3ICs1NjQsNyBAQAogCWNhbSA9IGllZWU4MDIxMV9jaGVja190aW0odGltX2llLCB0aW1fbGVuLCBhci0+Y29tbW9uLmN1cmFpZCk7CiAKIAkvKiAyLiBNYXliZSB0aGUgQVAgd2FudHMgdG8gc2VuZCBtdWx0aWNhc3QvYnJvYWRjYXN0IGRhdGE/ICovCi0JY2FtID0gISEodGltX2llLT5iaXRtYXBfY3RybCAmIDB4MDEpOworCWNhbSB8PSAhISh0aW1faWUtPmJpdG1hcF9jdHJsICYgMHgwMSk7CiAKIAlpZiAoIWNhbSkgewogCQkvKiBiYWNrIHRvIGxvdy1wb3dlciBsYW5kLiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaG9zdGFwL2hvc3RhcF9jcy5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaG9zdGFwL2hvc3RhcF9jcy5jCmluZGV4IGJkOGE0MTMuLjIxNzZlZGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2hvc3RhcC9ob3N0YXBfY3MuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ob3N0YXAvaG9zdGFwX2NzLmMKQEAgLTUxOCwyMiArNTE4LDIxIEBACiAJaHdfcHJpdi0+bGluayA9IGxpbms7CiAKIAkvKgotCSAqIE1ha2Ugc3VyZSB0aGUgSVJRIGhhbmRsZXIgY2Fubm90IHByb2NlZWQgdW50aWwgYXQgbGVhc3QKLQkgKiBkZXYtPmJhc2VfYWRkciBpcyBpbml0aWFsaXplZC4KKwkgKiBXZSBlbmFibGUgSVJRIGhlcmUsIGJ1dCBJUlEgaGFuZGxlciB3aWxsIG5vdCBwcm9jZWVkCisJICogdW50aWwgZGV2LT5iYXNlX2FkZHIgaXMgc2V0IGJlbG93LiBUaGlzIHByb3RlY3QgdXMgZnJvbQorCSAqIHJlY2VpdmUgaW50ZXJydXB0cyB3aGVuIGRyaXZlciBpcyBub3QgaW5pdGlhbGl6ZWQuCiAJICovCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmxvY2FsLT5pcnFfaW5pdF9sb2NrLCBmbGFncyk7Ci0KIAlyZXQgPSBwY21jaWFfcmVxdWVzdF9pcnEobGluaywgcHJpc20yX2ludGVycnVwdCk7CiAJaWYgKHJldCkKLQkJZ290byBmYWlsZWRfdW5sb2NrOworCQlnb3RvIGZhaWxlZDsKIAogCXJldCA9IHBjbWNpYV9lbmFibGVfZGV2aWNlKGxpbmspOwogCWlmIChyZXQpCi0JCWdvdG8gZmFpbGVkX3VubG9jazsKKwkJZ290byBmYWlsZWQ7CiAKKwlzcGluX2xvY2tfaXJxc2F2ZSgmbG9jYWwtPmlycV9pbml0X2xvY2ssIGZsYWdzKTsKIAlkZXYtPmlycSA9IGxpbmstPmlycTsKIAlkZXYtPmJhc2VfYWRkciA9IGxpbmstPnJlc291cmNlWzBdLT5zdGFydDsKLQogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmxvY2FsLT5pcnFfaW5pdF9sb2NrLCBmbGFncyk7CiAKIAlsb2NhbC0+c2h1dGRvd24gPSAwOwpAQCAtNTQ2LDggKzU0NSw2IEBACiAKIAlyZXR1cm4gcmV0OwogCi0gZmFpbGVkX3VubG9jazoKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZsb2NhbC0+aXJxX2luaXRfbG9jaywgZmxhZ3MpOwogIGZhaWxlZDoKIAlrZnJlZShod19wcml2KTsKIAlwcmlzbTJfcmVsZWFzZSgodV9sb25nKWxpbmspOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXB3MngwMC9pcHcyMjAwLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pcHcyeDAwL2lwdzIyMDAuYwppbmRleCA4ZDZlZDVmLi5hZTQzOGVkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pcHcyeDAwL2lwdzIyMDAuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pcHcyeDAwL2lwdzIyMDAuYwpAQCAtMTk3Myw2ICsxOTczLDEzIEBACiAKIAlpbnRhID0gaXB3X3JlYWQzMihwcml2LCBJUFdfSU5UQV9SVyk7CiAJaW50YV9tYXNrID0gaXB3X3JlYWQzMihwcml2LCBJUFdfSU5UQV9NQVNLX1IpOworCisJaWYgKGludGEgPT0gMHhGRkZGRkZGRikgeworCQkvKiBIYXJkd2FyZSBkaXNhcHBlYXJlZCAqLworCQlJUFdfV0FSTklORygiVEFTS0xFVCBJTlRBID09IDB4RkZGRkZGRkZcbiIpOworCQkvKiBPbmx5IGhhbmRsZSB0aGUgY2FjaGVkIElOVEEgdmFsdWVzICovCisJCWludGEgPSAwOworCX0KIAlpbnRhICY9IChJUFdfSU5UQV9NQVNLX0FMTCAmIGludGFfbWFzayk7CiAKIAkvKiBBZGQgYW55IGNhY2hlZCBJTlRBIHZhbHVlcyB0aGF0IG5lZWQgdG8gYmUgaGFuZGxlZCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtNDk2NS5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtNDk2NS5jCmluZGV4IDNmMWU1ZjEuLjkxYTlmNTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLTQ5NjUuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC00OTY1LmMKQEAgLTI2MjQsNiArMjYyNCw3IEBACiAJLmZ3X25hbWVfcHJlID0gSVdMNDk2NV9GV19QUkUsCiAJLnVjb2RlX2FwaV9tYXggPSBJV0w0OTY1X1VDT0RFX0FQSV9NQVgsCiAJLnVjb2RlX2FwaV9taW4gPSBJV0w0OTY1X1VDT0RFX0FQSV9NSU4sCisJLnNrdSA9IElXTF9TS1VfQXxJV0xfU0tVX0d8SVdMX1NLVV9OLAogCS52YWxpZF90eF9hbnQgPSBBTlRfQUIsCiAJLnZhbGlkX3J4X2FudCA9IEFOVF9BQkMsCiAJLmVlcHJvbV92ZXIgPSBFRVBST01fNDk2NV9FRVBST01fVkVSU0lPTiwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLTYwMDAuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLTYwMDAuYwppbmRleCBhZjUwNWJjLi5lZjM2YWZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC02MDAwLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtNjAwMC5jCkBAIC02ODEsNiArNjgxLDggQEAKIAkuZndfbmFtZV9wcmUgPSBJV0w2MDUwX0ZXX1BSRSwJCQkJXAogCS51Y29kZV9hcGlfbWF4ID0gSVdMNjA1MF9VQ09ERV9BUElfTUFYLAkJCVwKIAkudWNvZGVfYXBpX21pbiA9IElXTDYwNTBfVUNPREVfQVBJX01JTiwJCQlcCisJLnZhbGlkX3R4X2FudCA9IEFOVF9BQiwJCS8qIC5jZmcgb3ZlcndyaXRlICovCVwKKwkudmFsaWRfcnhfYW50ID0gQU5UX0FCLAkJLyogLmNmZyBvdmVyd3JpdGUgKi8JXAogCS5vcHMgPSAmaXdsNjA1MF9vcHMsCQkJCQlcCiAJLmVlcHJvbV92ZXIgPSBFRVBST01fNjA1MF9FRVBST01fVkVSU0lPTiwJCVwKIAkuZWVwcm9tX2NhbGliX3ZlciA9IEVFUFJPTV82MDUwX1RYX1BPV0VSX1ZFUlNJT04sCVwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWFnbi1lZXByb20uYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWFnbi1lZXByb20uYwppbmRleCA5NzkwNmRkLi4yN2I1YTNlIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1hZ24tZWVwcm9tLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtYWduLWVlcHJvbS5jCkBAIC0xNTIsMTEgKzE1MiwxNCBAQAogCiAJZWVwcm9tX3NrdSA9IGl3bF9lZXByb21fcXVlcnkxNihwcml2LCBFRVBST01fU0tVX0NBUCk7CiAKLQlwcml2LT5jZmctPnNrdSA9ICgoZWVwcm9tX3NrdSAmIEVFUFJPTV9TS1VfQ0FQX0JBTkRfU0VMRUNUSU9OKSA+PgorCWlmICghcHJpdi0+Y2ZnLT5za3UpIHsKKwkJLyogbm90IHVzaW5nIHNrdSBvdmVyd3JpdGUgKi8KKwkJcHJpdi0+Y2ZnLT5za3UgPQorCQkJKChlZXByb21fc2t1ICYgRUVQUk9NX1NLVV9DQVBfQkFORF9TRUxFQ1RJT04pID4+CiAJCQlFRVBST01fU0tVX0NBUF9CQU5EX1BPUyk7Ci0JaWYgKGVlcHJvbV9za3UgJiBFRVBST01fU0tVX0NBUF8xMU5fRU5BQkxFKQotCQlwcml2LT5jZmctPnNrdSB8PSBJV0xfU0tVX047Ci0KKwkJaWYgKGVlcHJvbV9za3UgJiBFRVBST01fU0tVX0NBUF8xMU5fRU5BQkxFKQorCQkJcHJpdi0+Y2ZnLT5za3UgfD0gSVdMX1NLVV9OOworCX0KIAlpZiAoIXByaXYtPmNmZy0+c2t1KSB7CiAJCUlXTF9FUlIocHJpdiwgIkludmFsaWQgZGV2aWNlIHNrdVxuIik7CiAJCXJldHVybiAtRUlOVkFMOwpAQCAtMTY4LDcgKzE3MSw3IEBACiAJCS8qIG5vdCB1c2luZyAuY2ZnIG92ZXJ3cml0ZSAqLwogCQlyYWRpb19jZmcgPSBpd2xfZWVwcm9tX3F1ZXJ5MTYocHJpdiwgRUVQUk9NX1JBRElPX0NPTkZJRyk7CiAJCXByaXYtPmNmZy0+dmFsaWRfdHhfYW50ID0gRUVQUk9NX1JGX0NGR19UWF9BTlRfTVNLKHJhZGlvX2NmZyk7Ci0JCXByaXYtPmNmZy0+dmFsaWRfcnhfYW50ID0gRUVQUk9NX1JGX0NGR19UWF9BTlRfTVNLKHJhZGlvX2NmZyk7CisJCXByaXYtPmNmZy0+dmFsaWRfcnhfYW50ID0gRUVQUk9NX1JGX0NGR19SWF9BTlRfTVNLKHJhZGlvX2NmZyk7CiAJCWlmICghcHJpdi0+Y2ZnLT52YWxpZF90eF9hbnQgfHwgIXByaXYtPmNmZy0+dmFsaWRfcnhfYW50KSB7CiAJCQlJV0xfRVJSKHByaXYsICJJbnZhbGlkIGNoYWluICgwWCV4LCAwWCV4KVxuIiwKIAkJCQlwcml2LT5jZmctPnZhbGlkX3R4X2FudCwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWFnbi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtYWduLmMKaW5kZXggMzYzMzViMS4uYzFjZmQ5OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtYWduLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtYWduLmMKQEAgLTExNTcsNiArMTE1Nyw5IEBACiAJLyogb25seSBSZS1lbmFibGUgaWYgZGlzYWJsZWQgYnkgaXJxICovCiAJaWYgKHRlc3RfYml0KFNUQVRVU19JTlRfRU5BQkxFRCwgJnByaXYtPnN0YXR1cykpCiAJCWl3bF9lbmFibGVfaW50ZXJydXB0cyhwcml2KTsKKwkvKiBSZS1lbmFibGUgUkZfS0lMTCBpZiBpdCBvY2N1cnJlZCAqLworCWVsc2UgaWYgKGhhbmRsZWQgJiBDU1JfSU5UX0JJVF9SRl9LSUxMKQorCQlpd2xfZW5hYmxlX3Jma2lsbF9pbnQocHJpdik7CiAKICNpZmRlZiBDT05GSUdfSVdMV0lGSV9ERUJVRwogCWlmIChpd2xfZ2V0X2RlYnVnX2xldmVsKHByaXYpICYgKElXTF9ETF9JU1IpKSB7CkBAIC0xMzcxLDYgKzEzNzQsOSBAQAogCS8qIG9ubHkgUmUtZW5hYmxlIGlmIGRpc2FibGVkIGJ5IGlycSAqLwogCWlmICh0ZXN0X2JpdChTVEFUVVNfSU5UX0VOQUJMRUQsICZwcml2LT5zdGF0dXMpKQogCQlpd2xfZW5hYmxlX2ludGVycnVwdHMocHJpdik7CisJLyogUmUtZW5hYmxlIFJGX0tJTEwgaWYgaXQgb2NjdXJyZWQgKi8KKwllbHNlIGlmIChoYW5kbGVkICYgQ1NSX0lOVF9CSVRfUkZfS0lMTCkKKwkJaXdsX2VuYWJsZV9yZmtpbGxfaW50KHByaXYpOwogfQogCiAvKiB0aGUgdGhyZXNob2xkIHJhdGlvIG9mIGFjdHVhbF9hY2tfY250IHRvIGV4cGVjdGVkX2Fja19jbnQgaW4gcGVyY2VudCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL25ldGRldi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL25ldGRldi5jCmluZGV4IDEzYTY5ZWIuLjUwOTFkNzcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bWMzMjAwd2lmaS9uZXRkZXYuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd21jMzIwMHdpZmkvbmV0ZGV2LmMKQEAgLTEyNiw2ICsxMjYsNyBAQAogCW5kZXYgPSBhbGxvY19uZXRkZXZfbXEoMCwgIndsYW4lZCIsIGV0aGVyX3NldHVwLCBJV01fVFhfUVVFVUVTKTsKIAlpZiAoIW5kZXYpIHsKIAkJZGV2X2VycihkZXYsICJubyBtZW1vcnkgZm9yIG5ldHdvcmsgZGV2aWNlIGluc3RhbmNlXG4iKTsKKwkJcmV0ID0gLUVOT01FTTsKIAkJZ290byBvdXRfcHJpdjsKIAl9CiAKQEAgLTEzOCw2ICsxMzksNyBAQAogCQkJCSAgICBHRlBfS0VSTkVMKTsKIAlpZiAoIWl3bS0+dW1hY19wcm9maWxlKSB7CiAJCWRldl9lcnIoZGV2LCAiQ291bGRuJ3QgYWxsb2MgbWVtb3J5IGZvciBwcm9maWxlXG4iKTsKKwkJcmV0ID0gLUVOT01FTTsKIAkJZ290byBvdXRfcHJvZmlsZTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3A1NC90eHJ4LmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9wNTQvdHhyeC5jCmluZGV4IDc2YjIzMThhLi5mNjE4Yjk2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9wNTQvdHhyeC5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3A1NC90eHJ4LmMKQEAgLTYxOCw3ICs2MTgsNyBAQAogCWVsc2UKIAkJKmJ1cnN0X3Bvc3NpYmxlID0gZmFsc2U7CiAKLQlpZiAoaW5mby0+ZmxhZ3MgJiBJRUVFODAyMTFfVFhfQ1RMX0FTU0lHTl9TRVEpCisJaWYgKCEoaW5mby0+ZmxhZ3MgJiBJRUVFODAyMTFfVFhfQ1RMX0FTU0lHTl9TRVEpKQogCQkqZmxhZ3MgfD0gUDU0X0hEUl9GTEFHX0RBVEFfT1VUX1NFUU5SOwogCiAJaWYgKGluZm8tPmZsYWdzICYgSUVFRTgwMjExX1RYX0NUTF9QU1BPTExfUkVTUE9OU0UpCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwZmlybXdhcmUuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDBmaXJtd2FyZS5jCmluZGV4IGYwZTFlYjcuLmJlMGZmNzggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDBmaXJtd2FyZS5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDBmaXJtd2FyZS5jCkBAIC01OCw2ICs1OCw3IEBACiAKIAlpZiAoIWZ3IHx8ICFmdy0+c2l6ZSB8fCAhZnctPmRhdGEpIHsKIAkJRVJST1IocnQyeDAwZGV2LCAiRmFpbGVkIHRvIHJlYWQgRmlybXdhcmUuXG4iKTsKKwkJcmVsZWFzZV9maXJtd2FyZShmdyk7CiAJCXJldHVybiAtRU5PRU5UOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMHBjaS5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMHBjaS5jCmluZGV4IDczNjMxYzYuLmFjZTBiNjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDBwY2kuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQyeDAwcGNpLmMKQEAgLTM2MywxMiArMzYzLDEyIEBACiAJc3RydWN0IHJ0MngwMF9kZXYgKnJ0MngwMGRldiA9IGh3LT5wcml2OwogCiAJaWYgKHBjaV9zZXRfcG93ZXJfc3RhdGUocGNpX2RldiwgUENJX0QwKSB8fAotCSAgICBwY2lfZW5hYmxlX2RldmljZShwY2lfZGV2KSB8fAotCSAgICBwY2lfcmVzdG9yZV9zdGF0ZShwY2lfZGV2KSkgeworCSAgICBwY2lfZW5hYmxlX2RldmljZShwY2lfZGV2KSkgewogCQlFUlJPUihydDJ4MDBkZXYsICJGYWlsZWQgdG8gcmVzdW1lIGRldmljZS5cbiIpOwogCQlyZXR1cm4gLUVJTzsKIAl9CiAKKwlwY2lfcmVzdG9yZV9zdGF0ZShwY2lfZGV2KTsKIAlyZXR1cm4gcnQyeDAwbGliX3Jlc3VtZShydDJ4MDBkZXYpOwogfQogRVhQT1JUX1NZTUJPTF9HUEwocnQyeDAwcGNpX3Jlc3VtZSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQ3M3VzYi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0NzN1c2IuYwppbmRleCAwYjRlODU5Li4wMjliZTNjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydDJ4MDAvcnQ3M3VzYi5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDczdXNiLmMKQEAgLTI0NDYsNiArMjQ0Niw3IEBACiAJeyBVU0JfREVWSUNFKDB4MDRiYiwgMHgwOTNkKSwgVVNCX0RFVklDRV9EQVRBKCZydDczdXNiX29wcykgfSwKIAl7IFVTQl9ERVZJQ0UoMHgxNDhmLCAweDI1NzMpLCBVU0JfREVWSUNFX0RBVEEoJnJ0NzN1c2Jfb3BzKSB9LAogCXsgVVNCX0RFVklDRSgweDE0OGYsIDB4MjY3MSksIFVTQl9ERVZJQ0VfREFUQSgmcnQ3M3VzYl9vcHMpIH0sCisJeyBVU0JfREVWSUNFKDB4MDgxMiwgMHgzMTAxKSwgVVNCX0RFVklDRV9EQVRBKCZydDczdXNiX29wcykgfSwKIAkvKiBRY29tICovCiAJeyBVU0JfREVWSUNFKDB4MThlOCwgMHg2MTk2KSwgVVNCX0RFVklDRV9EQVRBKCZydDczdXNiX29wcykgfSwKIAl7IFVTQl9ERVZJQ0UoMHgxOGU4LCAweDYyMjkpLCBVU0JfREVWSUNFX0RBVEEoJnJ0NzN1c2Jfb3BzKSB9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnRsd2lmaS9lZnVzZS5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnRsd2lmaS9lZnVzZS5jCmluZGV4IGI4NDMzZjMuLjYyODc2Y2QgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvZWZ1c2UuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9ydGx3aWZpL2VmdXNlLmMKQEAgLTcyNiw5ICs3MjYsOSBAQAogfQogCiBzdGF0aWMgdm9pZCBlZnVzZV93cml0ZV9kYXRhX2Nhc2UxKHN0cnVjdCBpZWVlODAyMTFfaHcgKmh3LCB1MTYgKmVmdXNlX2FkZHIsCi0JCQkJdTggZWZ1c2VfZGF0YSwgdTggb2Zmc2V0LCBpbnQgKmJjb250aW51YWwsCi0JCQkJdTggKndyaXRlX3N0YXRlLCBzdHJ1Y3QgcGdwa3Rfc3RydWN0IHRhcmdldF9wa3QsCi0JCQkJaW50ICpyZXBlYXRfdGltZXMsIGludCAqYnJlc3VsdCwgdTggd29yZF9lbikKKwkJCXU4IGVmdXNlX2RhdGEsIHU4IG9mZnNldCwgaW50ICpiY29udGludWFsLAorCQkJdTggKndyaXRlX3N0YXRlLCBzdHJ1Y3QgcGdwa3Rfc3RydWN0ICp0YXJnZXRfcGt0LAorCQkJaW50ICpyZXBlYXRfdGltZXMsIGludCAqYnJlc3VsdCwgdTggd29yZF9lbikKIHsKIAlzdHJ1Y3QgcnRsX3ByaXYgKnJ0bHByaXYgPSBydGxfcHJpdihodyk7CiAJc3RydWN0IHBncGt0X3N0cnVjdCB0bXBfcGt0OwpAQCAtNzQ0LDggKzc0NCw4IEBACiAJdG1wX3BrdC53b3JkX2VuID0gdG1wX2hlYWRlciAmIDB4MEY7CiAJdG1wX3dvcmRfY250cyA9IGVmdXNlX2NhbGN1bGF0ZV93b3JkX2NudHModG1wX3BrdC53b3JkX2VuKTsKIAotCWlmICh0bXBfcGt0Lm9mZnNldCAhPSB0YXJnZXRfcGt0Lm9mZnNldCkgewotCQllZnVzZV9hZGRyID0gZWZ1c2VfYWRkciArICh0bXBfd29yZF9jbnRzICogMikgKyAxOworCWlmICh0bXBfcGt0Lm9mZnNldCAhPSB0YXJnZXRfcGt0LT5vZmZzZXQpIHsKKwkJKmVmdXNlX2FkZHIgPSAqZWZ1c2VfYWRkciArICh0bXBfd29yZF9jbnRzICogMikgKyAxOwogCQkqd3JpdGVfc3RhdGUgPSBQR19TVEFURV9IRUFERVI7CiAJfSBlbHNlIHsKIAkJZm9yICh0bXBpbmRleCA9IDA7IHRtcGluZGV4IDwgKHRtcF93b3JkX2NudHMgKiAyKTsgdG1waW5kZXgrKykgewpAQCAtNzU2LDIzICs3NTYsMjMgQEAKIAkJfQogCiAJCWlmIChiZGF0YWVtcHR5ID09IGZhbHNlKSB7Ci0JCQllZnVzZV9hZGRyID0gZWZ1c2VfYWRkciArICh0bXBfd29yZF9jbnRzICogMikgKyAxOworCQkJKmVmdXNlX2FkZHIgPSAqZWZ1c2VfYWRkciArICh0bXBfd29yZF9jbnRzICogMikgKyAxOwogCQkJKndyaXRlX3N0YXRlID0gUEdfU1RBVEVfSEVBREVSOwogCQl9IGVsc2UgewogCQkJbWF0Y2hfd29yZF9lbiA9IDB4MEY7Ci0JCQlpZiAoISgodGFyZ2V0X3BrdC53b3JkX2VuICYgQklUKDApKSB8CisJCQlpZiAoISgodGFyZ2V0X3BrdC0+d29yZF9lbiAmIEJJVCgwKSkgfAogCQkJICAgICAodG1wX3BrdC53b3JkX2VuICYgQklUKDApKSkpCiAJCQkJbWF0Y2hfd29yZF9lbiAmPSAofkJJVCgwKSk7CiAKLQkJCWlmICghKCh0YXJnZXRfcGt0LndvcmRfZW4gJiBCSVQoMSkpIHwKKwkJCWlmICghKCh0YXJnZXRfcGt0LT53b3JkX2VuICYgQklUKDEpKSB8CiAJCQkgICAgICh0bXBfcGt0LndvcmRfZW4gJiBCSVQoMSkpKSkKIAkJCQltYXRjaF93b3JkX2VuICY9ICh+QklUKDEpKTsKIAotCQkJaWYgKCEoKHRhcmdldF9wa3Qud29yZF9lbiAmIEJJVCgyKSkgfAorCQkJaWYgKCEoKHRhcmdldF9wa3QtPndvcmRfZW4gJiBCSVQoMikpIHwKIAkJCSAgICAgKHRtcF9wa3Qud29yZF9lbiAmIEJJVCgyKSkpKQogCQkJCW1hdGNoX3dvcmRfZW4gJj0gKH5CSVQoMikpOwogCi0JCQlpZiAoISgodGFyZ2V0X3BrdC53b3JkX2VuICYgQklUKDMpKSB8CisJCQlpZiAoISgodGFyZ2V0X3BrdC0+d29yZF9lbiAmIEJJVCgzKSkgfAogCQkJICAgICAodG1wX3BrdC53b3JkX2VuICYgQklUKDMpKSkpCiAJCQkJbWF0Y2hfd29yZF9lbiAmPSAofkJJVCgzKSk7CiAKQEAgLTc4MCw3ICs3ODAsNyBAQAogCQkJCWJhZHdvcmRlbiA9IGVmdXNlX3dvcmRfZW5hYmxlX2RhdGFfd3JpdGUoCiAJCQkJCQkJICAgIGh3LCAqZWZ1c2VfYWRkciArIDEsCiAJCQkJCQkJICAgIHRtcF9wa3Qud29yZF9lbiwKLQkJCQkJCQkgICAgdGFyZ2V0X3BrdC5kYXRhKTsKKwkJCQkJCQkgICAgdGFyZ2V0X3BrdC0+ZGF0YSk7CiAKIAkJCQlpZiAoMHgwRiAhPSAoYmFkd29yZGVuICYgMHgwRikpIHsKIAkJCQkJdTggcmVvcmdfb2Zmc2V0ID0gb2Zmc2V0OwpAQCAtNzkxLDI2ICs3OTEsMjYgQEAKIAkJCQl9CiAKIAkJCQl0bXBfd29yZF9lbiA9IDB4MEY7Ci0JCQkJaWYgKCh0YXJnZXRfcGt0LndvcmRfZW4gJiBCSVQoMCkpIF4KKwkJCQlpZiAoKHRhcmdldF9wa3QtPndvcmRfZW4gJiBCSVQoMCkpIF4KIAkJCQkgICAgKG1hdGNoX3dvcmRfZW4gJiBCSVQoMCkpKQogCQkJCQl0bXBfd29yZF9lbiAmPSAofkJJVCgwKSk7CiAKLQkJCQlpZiAoKHRhcmdldF9wa3Qud29yZF9lbiAmIEJJVCgxKSkgXgorCQkJCWlmICgodGFyZ2V0X3BrdC0+d29yZF9lbiAmIEJJVCgxKSkgXgogCQkJCSAgICAobWF0Y2hfd29yZF9lbiAmIEJJVCgxKSkpCiAJCQkJCXRtcF93b3JkX2VuICY9ICh+QklUKDEpKTsKIAotCQkJCWlmICgodGFyZ2V0X3BrdC53b3JkX2VuICYgQklUKDIpKSBeCisJCQkJaWYgKCh0YXJnZXRfcGt0LT53b3JkX2VuICYgQklUKDIpKSBeCiAJCQkJCShtYXRjaF93b3JkX2VuICYgQklUKDIpKSkKIAkJCQkJdG1wX3dvcmRfZW4gJj0gKH5CSVQoMikpOwogCi0JCQkJaWYgKCh0YXJnZXRfcGt0LndvcmRfZW4gJiBCSVQoMykpIF4KKwkJCQlpZiAoKHRhcmdldF9wa3QtPndvcmRfZW4gJiBCSVQoMykpIF4KIAkJCQkgICAgKG1hdGNoX3dvcmRfZW4gJiBCSVQoMykpKQogCQkJCQl0bXBfd29yZF9lbiAmPSAofkJJVCgzKSk7CiAKIAkJCQlpZiAoKHRtcF93b3JkX2VuICYgMHgwRikgIT0gMHgwRikgewogCQkJCQkqZWZ1c2VfYWRkciA9IGVmdXNlX2dldF9jdXJyZW50X3NpemUoaHcpOwotCQkJCQl0YXJnZXRfcGt0Lm9mZnNldCA9IG9mZnNldDsKLQkJCQkJdGFyZ2V0X3BrdC53b3JkX2VuID0gdG1wX3dvcmRfZW47CisJCQkJCXRhcmdldF9wa3QtPm9mZnNldCA9IG9mZnNldDsKKwkJCQkJdGFyZ2V0X3BrdC0+d29yZF9lbiA9IHRtcF93b3JkX2VuOwogCQkJCX0gZWxzZQogCQkJCQkqYmNvbnRpbnVhbCA9IGZhbHNlOwogCQkJCSp3cml0ZV9zdGF0ZSA9IFBHX1NUQVRFX0hFQURFUjsKQEAgLTgyMSw4ICs4MjEsOCBAQAogCQkJCX0KIAkJCX0gZWxzZSB7CiAJCQkJKmVmdXNlX2FkZHIgKz0gKDIgKiB0bXBfd29yZF9jbnRzKSArIDE7Ci0JCQkJdGFyZ2V0X3BrdC5vZmZzZXQgPSBvZmZzZXQ7Ci0JCQkJdGFyZ2V0X3BrdC53b3JkX2VuID0gd29yZF9lbjsKKwkJCQl0YXJnZXRfcGt0LT5vZmZzZXQgPSBvZmZzZXQ7CisJCQkJdGFyZ2V0X3BrdC0+d29yZF9lbiA9IHdvcmRfZW47CiAJCQkJKndyaXRlX3N0YXRlID0gUEdfU1RBVEVfSEVBREVSOwogCQkJfQogCQl9CkBAIC05MzgsNyArOTM4LDcgQEAKIAkJCQllZnVzZV93cml0ZV9kYXRhX2Nhc2UxKGh3LCAmZWZ1c2VfYWRkciwKIAkJCQkJCSAgICAgICBlZnVzZV9kYXRhLCBvZmZzZXQsCiAJCQkJCQkgICAgICAgJmJjb250aW51YWwsCi0JCQkJCQkgICAgICAgJndyaXRlX3N0YXRlLCB0YXJnZXRfcGt0LAorCQkJCQkJICAgICAgICZ3cml0ZV9zdGF0ZSwgJnRhcmdldF9wa3QsCiAJCQkJCQkgICAgICAgJnJlcGVhdF90aW1lcywgJmJyZXN1bHQsCiAJCQkJCQkgICAgICAgd29yZF9lbik7CiAJCQllbHNlCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydGx3aWZpL3BjaS5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnRsd2lmaS9wY2kuYwppbmRleCAwZmEzNmFhLi4xNzU4ZDQ0IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ydGx3aWZpL3BjaS5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0bHdpZmkvcGNpLmMKQEAgLTYxOSw2ICs2MTksMTMgQEAKIAkJCQkJc3RydWN0IHNrX2J1ZmYgKnVza2IgPSBOVUxMOwogCQkJCQl1OCAqcGRhdGE7CiAJCQkJCXVza2IgPSBkZXZfYWxsb2Nfc2tiKHNrYi0+bGVuICsgMTI4KTsKKwkJCQkJaWYgKCF1c2tiKSB7CisJCQkJCQlSVF9UUkFDRShydGxwcml2LAorCQkJCQkJCShDT01QX0lOVFIgfCBDT01QX1JFQ1YpLAorCQkJCQkJCURCR19FTUVSRywKKwkJCQkJCQkoImNhbid0IGFsbG9jIHJ4IHNrYlxuIikpOworCQkJCQkJZ290byBkb25lOworCQkJCQl9CiAJCQkJCW1lbWNweShJRUVFODAyMTFfU0tCX1JYQ0IodXNrYiksCiAJCQkJCQkJJnJ4X3N0YXR1cywKIAkJCQkJCQlzaXplb2Yocnhfc3RhdHVzKSk7CkBAIC02NDEsNyArNjQ4LDcgQEAKIAkJCW5ld19za2IgPSBkZXZfYWxsb2Nfc2tiKHJ0bHBjaS0+cnhidWZmZXJzaXplKTsKIAkJCWlmICh1bmxpa2VseSghbmV3X3NrYikpIHsKIAkJCQlSVF9UUkFDRShydGxwcml2LCAoQ09NUF9JTlRSIHwgQ09NUF9SRUNWKSwKLQkJCQkJIERCR19ETUVTRywKKwkJCQkJIERCR19FTUVSRywKIAkJCQkJICgiY2FuJ3QgYWxsb2Mgc2tiIGZvciByeFxuIikpOwogCQkJCWdvdG8gZG9uZTsKIAkJCX0KQEAgLTEwNjYsOSArMTA3Myw5IEBACiAJCQlzdHJ1Y3Qgc2tfYnVmZiAqc2tiID0KIAkJCSAgICBkZXZfYWxsb2Nfc2tiKHJ0bHBjaS0+cnhidWZmZXJzaXplKTsKIAkJCXUzMiBidWZmZXJhZGRyZXNzOwotCQkJZW50cnkgPSAmcnRscGNpLT5yeF9yaW5nW3J4X3F1ZXVlX2lkeF0uZGVzY1tpXTsKIAkJCWlmICghc2tiKQogCQkJCXJldHVybiAwOworCQkJZW50cnkgPSAmcnRscGNpLT5yeF9yaW5nW3J4X3F1ZXVlX2lkeF0uZGVzY1tpXTsKIAogCQkJLypza2ItPmRldiA9IGRldjsgKi8KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMjUxL21haW4uYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3dsMTI1MS9tYWluLmMKaW5kZXggMDEyZTFhNC4uNDAzNzJiYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMjUxL21haW4uYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyNTEvbWFpbi5jCkBAIC0xMDM5LDYgKzEwMzksOSBAQAogCiAJaWYgKGNoYW5nZWQgJiBCU1NfQ0hBTkdFRF9CRUFDT04pIHsKIAkJYmVhY29uID0gaWVlZTgwMjExX2JlYWNvbl9nZXQoaHcsIHZpZik7CisJCWlmICghYmVhY29uKQorCQkJZ290byBvdXRfc2xlZXA7CisKIAkJcmV0ID0gd2wxMjUxX2NtZF90ZW1wbGF0ZV9zZXQod2wsIENNRF9CRUFDT04sIGJlYWNvbi0+ZGF0YSwKIAkJCQkJICAgICAgYmVhY29uLT5sZW4pOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvc3BpLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy93bDEyeHgvc3BpLmMKaW5kZXggNDY3MTQ5MS4uNzE0NWVhNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3Mvd2wxMnh4L3NwaS5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3dsMTJ4eC9zcGkuYwpAQCAtMTEwLDkgKzExMCw4IEBACiAJc3BpX21lc3NhZ2VfYWRkX3RhaWwoJnQsICZtKTsKIAogCXNwaV9zeW5jKHdsX3RvX3NwaSh3bCksICZtKTsKLQlrZnJlZShjbWQpOwotCiAJd2wxMjcxX2R1bXAoREVCVUdfU1BJLCAic3BpIHJlc2V0IC0+ICIsIGNtZCwgV1NQSV9JTklUX0NNRF9MRU4pOworCWtmcmVlKGNtZCk7CiB9CiAKIHN0YXRpYyB2b2lkIHdsMTI3MV9zcGlfaW5pdChzdHJ1Y3Qgd2wxMjcxICp3bCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3hlbi1uZXRmcm9udC5jIGIvZHJpdmVycy9uZXQveGVuLW5ldGZyb250LmMKaW5kZXggNTQ2ZGU1Ny4uZGExZjEyMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQveGVuLW5ldGZyb250LmMKKysrIGIvZHJpdmVycy9uZXQveGVuLW5ldGZyb250LmMKQEAgLTEyMCw2ICsxMjAsOSBAQAogCXVuc2lnbmVkIGxvbmcgcnhfcGZuX2FycmF5W05FVF9SWF9SSU5HX1NJWkVdOwogCXN0cnVjdCBtdWx0aWNhbGxfZW50cnkgcnhfbWNsW05FVF9SWF9SSU5HX1NJWkUrMV07CiAJc3RydWN0IG1tdV91cGRhdGUgcnhfbW11W05FVF9SWF9SSU5HX1NJWkVdOworCisJLyogU3RhdGlzdGljcyAqLworCWludCByeF9nc29fY2hlY2tzdW1fZml4dXA7CiB9OwogCiBzdHJ1Y3QgbmV0ZnJvbnRfcnhfaW5mbyB7CkBAIC03NzAsMTEgKzc3MywyOSBAQAogCXJldHVybiBjb25zOwogfQogCi1zdGF0aWMgaW50IHNrYl9jaGVja3N1bV9zZXR1cChzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQorc3RhdGljIGludCBjaGVja3N1bV9zZXR1cChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQogewogCXN0cnVjdCBpcGhkciAqaXBoOwogCXVuc2lnbmVkIGNoYXIgKnRoOwogCWludCBlcnIgPSAtRVBST1RPOworCWludCByZWNhbGN1bGF0ZV9wYXJ0aWFsX2NzdW0gPSAwOworCisJLyoKKwkgKiBBIEdTTyBTS0IgbXVzdCBiZSBDSEVDS1NVTV9QQVJUSUFMLiBIb3dldmVyIHNvbWUgYnVnZ3kKKwkgKiBwZWVycyBjYW4gZmFpbCB0byBzZXQgTkVUUlhGX2NzdW1fYmxhbmsgd2hlbiBzZW5kaW5nIGEgR1NPCisJICogZnJhbWUuIEluIHRoaXMgY2FzZSBmb3JjZSB0aGUgU0tCIHRvIENIRUNLU1VNX1BBUlRJQUwgYW5kCisJICogcmVjYWxjdWxhdGUgdGhlIHBhcnRpYWwgY2hlY2tzdW0uCisJICovCisJaWYgKHNrYi0+aXBfc3VtbWVkICE9IENIRUNLU1VNX1BBUlRJQUwgJiYgc2tiX2lzX2dzbyhza2IpKSB7CisJCXN0cnVjdCBuZXRmcm9udF9pbmZvICpucCA9IG5ldGRldl9wcml2KGRldik7CisJCW5wLT5yeF9nc29fY2hlY2tzdW1fZml4dXArKzsKKwkJc2tiLT5pcF9zdW1tZWQgPSBDSEVDS1NVTV9QQVJUSUFMOworCQlyZWNhbGN1bGF0ZV9wYXJ0aWFsX2NzdW0gPSAxOworCX0KKworCS8qIEEgbm9uLUNIRUNLU1VNX1BBUlRJQUwgU0tCIGRvZXMgbm90IHJlcXVpcmUgc2V0dXAuICovCisJaWYgKHNrYi0+aXBfc3VtbWVkICE9IENIRUNLU1VNX1BBUlRJQUwpCisJCXJldHVybiAwOwogCiAJaWYgKHNrYi0+cHJvdG9jb2wgIT0gaHRvbnMoRVRIX1BfSVApKQogCQlnb3RvIG91dDsKQEAgLTc4OCw5ICs4MDksMjMgQEAKIAlzd2l0Y2ggKGlwaC0+cHJvdG9jb2wpIHsKIAljYXNlIElQUFJPVE9fVENQOgogCQlza2ItPmNzdW1fb2Zmc2V0ID0gb2Zmc2V0b2Yoc3RydWN0IHRjcGhkciwgY2hlY2spOworCisJCWlmIChyZWNhbGN1bGF0ZV9wYXJ0aWFsX2NzdW0pIHsKKwkJCXN0cnVjdCB0Y3BoZHIgKnRjcGggPSAoc3RydWN0IHRjcGhkciAqKXRoOworCQkJdGNwaC0+Y2hlY2sgPSB+Y3N1bV90Y3B1ZHBfbWFnaWMoaXBoLT5zYWRkciwgaXBoLT5kYWRkciwKKwkJCQkJCQkgc2tiLT5sZW4gLSBpcGgtPmlobCo0LAorCQkJCQkJCSBJUFBST1RPX1RDUCwgMCk7CisJCX0KIAkJYnJlYWs7CiAJY2FzZSBJUFBST1RPX1VEUDoKIAkJc2tiLT5jc3VtX29mZnNldCA9IG9mZnNldG9mKHN0cnVjdCB1ZHBoZHIsIGNoZWNrKTsKKworCQlpZiAocmVjYWxjdWxhdGVfcGFydGlhbF9jc3VtKSB7CisJCQlzdHJ1Y3QgdWRwaGRyICp1ZHBoID0gKHN0cnVjdCB1ZHBoZHIgKil0aDsKKwkJCXVkcGgtPmNoZWNrID0gfmNzdW1fdGNwdWRwX21hZ2ljKGlwaC0+c2FkZHIsIGlwaC0+ZGFkZHIsCisJCQkJCQkJIHNrYi0+bGVuIC0gaXBoLT5paGwqNCwKKwkJCQkJCQkgSVBQUk9UT19VRFAsIDApOworCQl9CiAJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCWlmIChuZXRfcmF0ZWxpbWl0KCkpCkBAIC04MjksMTMgKzg2NCwxMSBAQAogCQkvKiBFdGhlcm5ldCB3b3JrOiBEZWxheWVkIHRvIGhlcmUgYXMgaXQgcGVla3MgdGhlIGhlYWRlci4gKi8KIAkJc2tiLT5wcm90b2NvbCA9IGV0aF90eXBlX3RyYW5zKHNrYiwgZGV2KTsKIAotCQlpZiAoc2tiLT5pcF9zdW1tZWQgPT0gQ0hFQ0tTVU1fUEFSVElBTCkgewotCQkJaWYgKHNrYl9jaGVja3N1bV9zZXR1cChza2IpKSB7Ci0JCQkJa2ZyZWVfc2tiKHNrYik7Ci0JCQkJcGFja2V0c19kcm9wcGVkKys7Ci0JCQkJZGV2LT5zdGF0cy5yeF9lcnJvcnMrKzsKLQkJCQljb250aW51ZTsKLQkJCX0KKwkJaWYgKGNoZWNrc3VtX3NldHVwKGRldiwgc2tiKSkgeworCQkJa2ZyZWVfc2tiKHNrYik7CisJCQlwYWNrZXRzX2Ryb3BwZWQrKzsKKwkJCWRldi0+c3RhdHMucnhfZXJyb3JzKys7CisJCQljb250aW51ZTsKIAkJfQogCiAJCWRldi0+c3RhdHMucnhfcGFja2V0cysrOwpAQCAtMTYzMiwxMiArMTY2NSw1OSBAQAogCX0KIH0KIAorc3RhdGljIGNvbnN0IHN0cnVjdCB4ZW5uZXRfc3RhdCB7CisJY2hhciBuYW1lW0VUSF9HU1RSSU5HX0xFTl07CisJdTE2IG9mZnNldDsKK30geGVubmV0X3N0YXRzW10gPSB7CisJeworCQkicnhfZ3NvX2NoZWNrc3VtX2ZpeHVwIiwKKwkJb2Zmc2V0b2Yoc3RydWN0IG5ldGZyb250X2luZm8sIHJ4X2dzb19jaGVja3N1bV9maXh1cCkKKwl9LAorfTsKKworc3RhdGljIGludCB4ZW5uZXRfZ2V0X3NzZXRfY291bnQoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgaW50IHN0cmluZ19zZXQpCit7CisJc3dpdGNoIChzdHJpbmdfc2V0KSB7CisJY2FzZSBFVEhfU1NfU1RBVFM6CisJCXJldHVybiBBUlJBWV9TSVpFKHhlbm5ldF9zdGF0cyk7CisJZGVmYXVsdDoKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorfQorCitzdGF0aWMgdm9pZCB4ZW5uZXRfZ2V0X2V0aHRvb2xfc3RhdHMoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKKwkJCQkgICAgIHN0cnVjdCBldGh0b29sX3N0YXRzICpzdGF0cywgdTY0ICogZGF0YSkKK3sKKwl2b2lkICpucCA9IG5ldGRldl9wcml2KGRldik7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh4ZW5uZXRfc3RhdHMpOyBpKyspCisJCWRhdGFbaV0gPSAqKGludCAqKShucCArIHhlbm5ldF9zdGF0c1tpXS5vZmZzZXQpOworfQorCitzdGF0aWMgdm9pZCB4ZW5uZXRfZ2V0X3N0cmluZ3Moc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgdTMyIHN0cmluZ3NldCwgdTggKiBkYXRhKQoreworCWludCBpOworCisJc3dpdGNoIChzdHJpbmdzZXQpIHsKKwljYXNlIEVUSF9TU19TVEFUUzoKKwkJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoeGVubmV0X3N0YXRzKTsgaSsrKQorCQkJbWVtY3B5KGRhdGEgKyBpICogRVRIX0dTVFJJTkdfTEVOLAorCQkJICAgICAgIHhlbm5ldF9zdGF0c1tpXS5uYW1lLCBFVEhfR1NUUklOR19MRU4pOworCQlicmVhazsKKwl9Cit9CisKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZXRodG9vbF9vcHMgeGVubmV0X2V0aHRvb2xfb3BzID0KIHsKIAkuc2V0X3R4X2NzdW0gPSBldGh0b29sX29wX3NldF90eF9jc3VtLAogCS5zZXRfc2cgPSB4ZW5uZXRfc2V0X3NnLAogCS5zZXRfdHNvID0geGVubmV0X3NldF90c28sCiAJLmdldF9saW5rID0gZXRodG9vbF9vcF9nZXRfbGluaywKKworCS5nZXRfc3NldF9jb3VudCA9IHhlbm5ldF9nZXRfc3NldF9jb3VudCwKKwkuZ2V0X2V0aHRvb2xfc3RhdHMgPSB4ZW5uZXRfZ2V0X2V0aHRvb2xfc3RhdHMsCisJLmdldF9zdHJpbmdzID0geGVubmV0X2dldF9zdHJpbmdzLAogfTsKIAogI2lmZGVmIENPTkZJR19TWVNGUwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZmMvcG41NDQuYyBiL2RyaXZlcnMvbmZjL3BuNTQ0LmMKaW5kZXggNDAxYzQ0Yi4uYmFlNjQ3MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZmMvcG41NDQuYworKysgYi9kcml2ZXJzL25mYy9wbjU0NC5jCkBAIC02OSw3ICs2OSw3IEBACiAJc3RydWN0IG11dGV4IHJlYWRfbXV0ZXg7IC8qIFNlcmlhbGl6ZSByZWFkX2lycSBhY2Nlc3MgKi8KIAlzdHJ1Y3QgbXV0ZXggbXV0ZXg7IC8qIFNlcmlhbGl6ZSBpbmZvIHN0cnVjdCBhY2Nlc3MgKi8KIAl1OCAqYnVmOwotCXVuc2lnbmVkIGludCBidWZsZW47CisJc2l6ZV90IGJ1ZmxlbjsKIH07CiAKIHN0YXRpYyBjb25zdCBjaGFyIHJlZ192ZGRfaW9bXQk9ICJWZGRfSU8iOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9vZi9mZHQuYyBiL2RyaXZlcnMvb2YvZmR0LmMKaW5kZXggYzc4N2MzZC4uYWY4MjRlNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9vZi9mZHQuYworKysgYi9kcml2ZXJzL29mL2ZkdC5jCkBAIC02OTIsMTIgKzY5Miw2IEBACiAJcmV0dXJuIDE7CiB9CiAKLXN0YXRpYyB2b2lkICpfX2luaXQgZWFybHlfZGV2aWNlX3RyZWVfYWxsb2ModTY0IHNpemUsIHU2NCBhbGlnbikKLXsKLQl1bnNpZ25lZCBsb25nIG1lbSA9IGVhcmx5X2luaXRfZHRfYWxsb2NfbWVtb3J5X2FyY2goc2l6ZSwgYWxpZ24pOwotCXJldHVybiBfX3ZhKG1lbSk7Ci19Ci0KIC8qKgogICogdW5mbGF0dGVuX2RldmljZV90cmVlIC0gY3JlYXRlIHRyZWUgb2YgZGV2aWNlX25vZGVzIGZyb20gZmxhdCBibG9iCiAgKgpAQCAtNzA5LDcgKzcwMyw3IEBACiB2b2lkIF9faW5pdCB1bmZsYXR0ZW5fZGV2aWNlX3RyZWUodm9pZCkKIHsKIAlfX3VuZmxhdHRlbl9kZXZpY2VfdHJlZShpbml0aWFsX2Jvb3RfcGFyYW1zLCAmYWxsbm9kZXMsCi0JCQkJZWFybHlfZGV2aWNlX3RyZWVfYWxsb2MpOworCQkJCWVhcmx5X2luaXRfZHRfYWxsb2NfbWVtb3J5X2FyY2gpOwogCiAJLyogR2V0IHBvaW50ZXIgdG8gT0YgIi9jaG9zZW4iIG5vZGUgZm9yIHVzZSBldmVyeXdoZXJlICovCiAJb2ZfY2hvc2VuID0gb2ZfZmluZF9ub2RlX2J5X3BhdGgoIi9jaG9zZW4iKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGFycG9ydC9zaGFyZS5jIGIvZHJpdmVycy9wYXJwb3J0L3NoYXJlLmMKaW5kZXggYTJkOWQxZS4uYTg0OGUwMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9wYXJwb3J0L3NoYXJlLmMKKysrIGIvZHJpdmVycy9wYXJwb3J0L3NoYXJlLmMKQEAgLTY3OCw3ICs2NzgsNyBAQAogCiAJLyogTWFrZSBzdXJlIHdlIGhhdmVuJ3QgbGVmdCBhbnkgcG9pbnRlcnMgYXJvdW5kIGluIHRoZSB3YWl0CiAJICogbGlzdC4gKi8KLQlzcGluX2xvY2sgKCZwb3J0LT53YWl0bGlzdF9sb2NrKTsKKwlzcGluX2xvY2tfaXJxKCZwb3J0LT53YWl0bGlzdF9sb2NrKTsKIAlpZiAoZGV2LT53YWl0cHJldiB8fCBkZXYtPndhaXRuZXh0IHx8IHBvcnQtPndhaXRoZWFkID09IGRldikgewogCQlpZiAoZGV2LT53YWl0cHJldikKIAkJCWRldi0+d2FpdHByZXYtPndhaXRuZXh0ID0gZGV2LT53YWl0bmV4dDsKQEAgLTY4OSw3ICs2ODksNyBAQAogCQllbHNlCiAJCQlwb3J0LT53YWl0dGFpbCA9IGRldi0+d2FpdHByZXY7CiAJfQotCXNwaW5fdW5sb2NrICgmcG9ydC0+d2FpdGxpc3RfbG9jayk7CisJc3Bpbl91bmxvY2tfaXJxKCZwb3J0LT53YWl0bGlzdF9sb2NrKTsKIAogCWtmcmVlKGRldi0+c3RhdGUpOwogCWtmcmVlKGRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9tc2kuYyBiL2RyaXZlcnMvcGNpL21zaS5jCmluZGV4IDdjMjRkY2UuLjQ0YjBhZWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL21zaS5jCisrKyBiL2RyaXZlcnMvcGNpL21zaS5jCkBAIC0xNjgsOCArMTY4LDkgQEAKIAl1MzIgbWFza19iaXRzID0gZGVzYy0+bWFza2VkOwogCXVuc2lnbmVkIG9mZnNldCA9IGRlc2MtPm1zaV9hdHRyaWIuZW50cnlfbnIgKiBQQ0lfTVNJWF9FTlRSWV9TSVpFICsKIAkJCQkJCVBDSV9NU0lYX0VOVFJZX1ZFQ1RPUl9DVFJMOwotCW1hc2tfYml0cyAmPSB+MTsKLQltYXNrX2JpdHMgfD0gZmxhZzsKKwltYXNrX2JpdHMgJj0gflBDSV9NU0lYX0VOVFJZX0NUUkxfTUFTS0JJVDsKKwlpZiAoZmxhZykKKwkJbWFza19iaXRzIHw9IFBDSV9NU0lYX0VOVFJZX0NUUkxfTUFTS0JJVDsKIAl3cml0ZWwobWFza19iaXRzLCBkZXNjLT5tYXNrX2Jhc2UgKyBvZmZzZXQpOwogCiAJcmV0dXJuIG1hc2tfYml0czsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL21zaS5oIGIvZHJpdmVycy9wY2kvbXNpLmgKaW5kZXggZmVmZjNiZS4uNjVjNDJmOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY2kvbXNpLmgKKysrIGIvZHJpdmVycy9wY2kvbXNpLmgKQEAgLTYsMTIgKzYsNiBAQAogI2lmbmRlZiBNU0lfSAogI2RlZmluZSBNU0lfSAogCi0jZGVmaW5lIFBDSV9NU0lYX0VOVFJZX1NJWkUJCTE2Ci0jZGVmaW5lICBQQ0lfTVNJWF9FTlRSWV9MT1dFUl9BRERSCTAKLSNkZWZpbmUgIFBDSV9NU0lYX0VOVFJZX1VQUEVSX0FERFIJNAotI2RlZmluZSAgUENJX01TSVhfRU5UUllfREFUQQkJOAotI2RlZmluZSAgUENJX01TSVhfRU5UUllfVkVDVE9SX0NUUkwJMTIKLQogI2RlZmluZSBtc2lfY29udHJvbF9yZWcoYmFzZSkJCShiYXNlICsgUENJX01TSV9GTEFHUykKICNkZWZpbmUgbXNpX2xvd2VyX2FkZHJlc3NfcmVnKGJhc2UpCShiYXNlICsgUENJX01TSV9BRERSRVNTX0xPKQogI2RlZmluZSBtc2lfdXBwZXJfYWRkcmVzc19yZWcoYmFzZSkJKGJhc2UgKyBQQ0lfTVNJX0FERFJFU1NfSEkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9wY2ktYWNwaS5jIGIvZHJpdmVycy9wY2kvcGNpLWFjcGkuYwppbmRleCAyNGUxOWM1Li42ZmUwNzcyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9wY2ktYWNwaS5jCisrKyBiL2RyaXZlcnMvcGNpL3BjaS1hY3BpLmMKQEAgLTQ2LDkgKzQ2LDkgQEAKIAlzdHJ1Y3QgcGNpX2RldiAqcGNpX2RldiA9IGNvbnRleHQ7CiAKIAlpZiAoZXZlbnQgPT0gQUNQSV9OT1RJRllfREVWSUNFX1dBS0UgJiYgcGNpX2RldikgeworCQlwY2lfd2FrZXVwX2V2ZW50KHBjaV9kZXYpOwogCQlwY2lfY2hlY2tfcG1lX3N0YXR1cyhwY2lfZGV2KTsKIAkJcG1fcnVudGltZV9yZXN1bWUoJnBjaV9kZXYtPmRldik7Ci0JCXBjaV93YWtldXBfZXZlbnQocGNpX2Rldik7CiAJCWlmIChwY2lfZGV2LT5zdWJvcmRpbmF0ZSkKIAkJCXBjaV9wbWVfd2FrZXVwX2J1cyhwY2lfZGV2LT5zdWJvcmRpbmF0ZSk7CiAJfQpAQCAtMzk5LDYgKzM5OSw3IEBACiAKIAlpZiAoYWNwaV9nYmxfRkFEVC5ib290X2ZsYWdzICYgQUNQSV9GQURUX05PX0FTUE0pIHsKIAkJcHJpbnRrKEtFUk5fSU5GTyJBQ1BJIEZBRFQgZGVjbGFyZXMgdGhlIHN5c3RlbSBkb2Vzbid0IHN1cHBvcnQgUENJZSBBU1BNLCBzbyBkaXNhYmxlIGl0XG4iKTsKKwkJcGNpZV9jbGVhcl9hc3BtKCk7CiAJCXBjaWVfbm9fYXNwbSgpOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcGNpLWRyaXZlci5jIGIvZHJpdmVycy9wY2kvcGNpLWRyaXZlci5jCmluZGV4IDhhNmY3OTcuLjg4MjQ2ZGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL3BjaS1kcml2ZXIuYworKysgYi9kcml2ZXJzL3BjaS9wY2ktZHJpdmVyLmMKQEAgLTMzOCw3ICszMzgsNyBAQAogfQogCiAvKioKLSAqIF9fcGNpX2RldmljZV9wcm9iZSgpCisgKiBfX3BjaV9kZXZpY2VfcHJvYmUgLSBjaGVjayBpZiBhIGRyaXZlciB3YW50cyB0byBjbGFpbSBhIHNwZWNpZmljIFBDSSBkZXZpY2UKICAqIEBkcnY6IGRyaXZlciB0byBjYWxsIHRvIGNoZWNrIGlmIGl0IHdhbnRzIHRoZSBQQ0kgZGV2aWNlCiAgKiBAcGNpX2RldjogUENJIGRldmljZSBiZWluZyBwcm9iZWQKICAqIApAQCAtNDQ5LDcgKzQ0OSw4IEBACiAJCQlyZXR1cm4gZXJyb3I7CiAJfQogCi0JcmV0dXJuIHBjaV9yZXN0b3JlX3N0YXRlKHBjaV9kZXYpOworCXBjaV9yZXN0b3JlX3N0YXRlKHBjaV9kZXYpOworCXJldHVybiAwOwogfQogCiBzdGF0aWMgdm9pZCBwY2lfcG1fZGVmYXVsdF9yZXN1bWVfZWFybHkoc3RydWN0IHBjaV9kZXYgKnBjaV9kZXYpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9wY2ktc3R1Yi5jIGIvZHJpdmVycy9wY2kvcGNpLXN0dWIuYwppbmRleCBmN2I2OGNhLi43NzVlOTMzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9wY2ktc3R1Yi5jCisrKyBiL2RyaXZlcnMvcGNpL3BjaS1zdHViLmMKQEAgLTQ3LDYgKzQ3LDEwIEBACiAJaWYgKHJjKQogCQlyZXR1cm4gcmM7CiAKKwkvKiBubyBpZHMgcGFzc2VkIGFjdHVhbGx5ICovCisJaWYgKGlkc1swXSA9PSAnXDAnKQorCQlyZXR1cm4gMDsKKwogCS8qIGFkZCBpZHMgc3BlY2lmaWVkIGluIHRoZSBtb2R1bGUgcGFyYW1ldGVyICovCiAJcCA9IGlkczsKIAl3aGlsZSAoKGlkID0gc3Ryc2VwKCZwLCAiLCIpKSkgewpAQCAtNTQsNiArNTgsOSBAQAogCQkJc3ViZGV2aWNlID0gUENJX0FOWV9JRCwgY2xhc3M9MCwgY2xhc3NfbWFzaz0wOwogCQlpbnQgZmllbGRzOwogCisJCWlmICghc3RybGVuKGlkKSkKKwkJCWNvbnRpbnVlOworCiAJCWZpZWxkcyA9IHNzY2FuZihpZCwgIiV4OiV4OiV4OiV4OiV4OiV4IiwKIAkJCQkmdmVuZG9yLCAmZGV2aWNlLCAmc3VidmVuZG9yLCAmc3ViZGV2aWNlLAogCQkJCSZjbGFzcywgJmNsYXNzX21hc2spOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcGNpLXN5c2ZzLmMgYi9kcml2ZXJzL3BjaS9wY2ktc3lzZnMuYwppbmRleCA2M2Q1MDQyLi44ZWNhYWM5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9wY2ktc3lzZnMuYworKysgYi9kcml2ZXJzL3BjaS9wY2ktc3lzZnMuYwpAQCAtMTE0OSw3ICsxMTQ5LDcgQEAKIAkJc3lzZnNfYmluX2F0dHJfaW5pdChhdHRyKTsKIAkJYXR0ci0+c2l6ZSA9IHJvbV9zaXplOwogCQlhdHRyLT5hdHRyLm5hbWUgPSAicm9tIjsKLQkJYXR0ci0+YXR0ci5tb2RlID0gU19JUlVTUjsKKwkJYXR0ci0+YXR0ci5tb2RlID0gU19JUlVTUiB8IFNfSVdVU1I7CiAJCWF0dHItPnJlYWQgPSBwY2lfcmVhZF9yb207CiAJCWF0dHItPndyaXRlID0gcGNpX3dyaXRlX3JvbTsKIAkJcmV0dmFsID0gc3lzZnNfY3JlYXRlX2Jpbl9maWxlKCZwZGV2LT5kZXYua29iaiwgYXR0cik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9wY2kuYyBiL2RyaXZlcnMvcGNpL3BjaS5jCmluZGV4IDcxMGM4YTIuLmI3MTRkNzggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL3BjaS5jCisrKyBiL2RyaXZlcnMvcGNpL3BjaS5jCkBAIC05MzcsMTQgKzkzNywxMyBAQAogICogcGNpX3Jlc3RvcmVfc3RhdGUgLSBSZXN0b3JlIHRoZSBzYXZlZCBzdGF0ZSBvZiBhIFBDSSBkZXZpY2UKICAqIEBkZXY6IC0gUENJIGRldmljZSB0aGF0IHdlJ3JlIGRlYWxpbmcgd2l0aAogICovCi1pbnQgCi1wY2lfcmVzdG9yZV9zdGF0ZShzdHJ1Y3QgcGNpX2RldiAqZGV2KQordm9pZCBwY2lfcmVzdG9yZV9zdGF0ZShzdHJ1Y3QgcGNpX2RldiAqZGV2KQogewogCWludCBpOwogCXUzMiB2YWw7CiAKIAlpZiAoIWRldi0+c3RhdGVfc2F2ZWQpCi0JCXJldHVybiAwOworCQlyZXR1cm47CiAKIAkvKiBQQ0kgRXhwcmVzcyByZWdpc3RlciBtdXN0IGJlIHJlc3RvcmVkIGZpcnN0ICovCiAJcGNpX3Jlc3RvcmVfcGNpZV9zdGF0ZShkZXYpOwpAQCAtOTY4LDggKzk2Nyw2IEBACiAJcGNpX3Jlc3RvcmVfaW92X3N0YXRlKGRldik7CiAKIAlkZXYtPnN0YXRlX3NhdmVkID0gZmFsc2U7Ci0KLQlyZXR1cm4gMDsKIH0KIAogc3RhdGljIGludCBkb19wY2lfZW5hYmxlX2RldmljZShzdHJ1Y3QgcGNpX2RldiAqZGV2LCBpbnQgYmFycykKQEAgLTEzMDAsMjIgKzEyOTcsNiBAQAogCXJldHVybiByZXQ7CiB9CiAKLS8qCi0gKiBUaW1lIHRvIHdhaXQgYmVmb3JlIHRoZSBzeXN0ZW0gY2FuIGJlIHB1dCBpbnRvIGEgc2xlZXAgc3RhdGUgYWZ0ZXIgcmVwb3J0aW5nCi0gKiBhIHdha2V1cCBldmVudCBzaWduYWxlZCBieSBhIFBDSSBkZXZpY2UuCi0gKi8KLSNkZWZpbmUgUENJX1dBS0VVUF9DT09MRE9XTgkxMDAKLQotLyoqCi0gKiBwY2lfd2FrZXVwX2V2ZW50IC0gUmVwb3J0IGEgd2FrZXVwIGV2ZW50IHJlbGF0ZWQgdG8gYSBnaXZlbiBQQ0kgZGV2aWNlLgotICogQGRldjogRGV2aWNlIHRvIHJlcG9ydCB0aGUgd2FrZXVwIGV2ZW50IGZvci4KLSAqLwotdm9pZCBwY2lfd2FrZXVwX2V2ZW50KHN0cnVjdCBwY2lfZGV2ICpkZXYpCi17Ci0JaWYgKGRldmljZV9tYXlfd2FrZXVwKCZkZXYtPmRldikpCi0JCXBtX3dha2V1cF9ldmVudCgmZGV2LT5kZXYsIFBDSV9XQUtFVVBfQ09PTERPV04pOwotfQotCiAvKioKICAqIHBjaV9wbWVfd2FrZXVwIC0gV2FrZSB1cCBhIFBDSSBkZXZpY2UgaWYgaXRzIFBNRSBTdGF0dXMgYml0IGlzIHNldC4KICAqIEBkZXY6IERldmljZSB0byBoYW5kbGUuCkBAIC0xMzI3LDggKzEzMDgsOCBAQAogc3RhdGljIGludCBwY2lfcG1lX3dha2V1cChzdHJ1Y3QgcGNpX2RldiAqZGV2LCB2b2lkICppZ24pCiB7CiAJaWYgKHBjaV9jaGVja19wbWVfc3RhdHVzKGRldikpIHsKLQkJcG1fcmVxdWVzdF9yZXN1bWUoJmRldi0+ZGV2KTsKIAkJcGNpX3dha2V1cF9ldmVudChkZXYpOworCQlwbV9yZXF1ZXN0X3Jlc3VtZSgmZGV2LT5kZXYpOwogCX0KIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL3BjaS5oIGIvZHJpdmVycy9wY2kvcGNpLmgKaW5kZXggN2QzM2Y2Ni4uZjY5ZDZlMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY2kvcGNpLmgKKysrIGIvZHJpdmVycy9wY2kvcGNpLmgKQEAgLTc0LDYgKzc0LDEyIEBACiBleHRlcm4gdm9pZCBwbGF0Zm9ybV9wY2lfd2FrZXVwX2luaXQoc3RydWN0IHBjaV9kZXYgKmRldik7CiBleHRlcm4gdm9pZCBwY2lfYWxsb2NhdGVfY2FwX3NhdmVfYnVmZmVycyhzdHJ1Y3QgcGNpX2RldiAqZGV2KTsKIAorc3RhdGljIGlubGluZSB2b2lkIHBjaV93YWtldXBfZXZlbnQoc3RydWN0IHBjaV9kZXYgKmRldikKK3sKKwkvKiBXYWl0IDEwMCBtcyBiZWZvcmUgdGhlIHN5c3RlbSBjYW4gYmUgcHV0IGludG8gYSBzbGVlcCBzdGF0ZS4gKi8KKwlwbV93YWtldXBfZXZlbnQoJmRldi0+ZGV2LCAxMDApOworfQorCiBzdGF0aWMgaW5saW5lIGJvb2wgcGNpX2lzX2JyaWRnZShzdHJ1Y3QgcGNpX2RldiAqcGNpX2RldikKIHsKIAlyZXR1cm4gISEocGNpX2Rldi0+c3Vib3JkaW5hdGUpOwpAQCAtMTQwLDE0ICsxNDYsNiBAQAogc3RhdGljIGlubGluZSB2b2lkIHBjaV9tc2lfaW5pdF9wY2lfZGV2KHN0cnVjdCBwY2lfZGV2ICpkZXYpIHsgfQogI2VuZGlmCiAKLSNpZmRlZiBDT05GSUdfUENJRUFFUgotdm9pZCBwY2lfbm9fYWVyKHZvaWQpOwotYm9vbCBwY2lfYWVyX2F2YWlsYWJsZSh2b2lkKTsKLSNlbHNlCi1zdGF0aWMgaW5saW5lIHZvaWQgcGNpX25vX2Flcih2b2lkKSB7IH0KLXN0YXRpYyBpbmxpbmUgYm9vbCBwY2lfYWVyX2F2YWlsYWJsZSh2b2lkKSB7IHJldHVybiBmYWxzZTsgfQotI2VuZGlmCi0KIHN0YXRpYyBpbmxpbmUgaW50IHBjaV9ub19kMWQyKHN0cnVjdCBwY2lfZGV2ICpkZXYpCiB7CiAJdW5zaWduZWQgaW50IHBhcmVudF9kc3RhdGVzID0gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL3BjaWUvS2NvbmZpZyBiL2RyaXZlcnMvcGNpL3BjaWUvS2NvbmZpZwppbmRleCBkZGE3MDk4Li5kYzI5MzQ4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9wY2llL0tjb25maWcKKysrIGIvZHJpdmVycy9wY2kvcGNpZS9LY29uZmlnCkBAIC0zMSw3ICszMSw3IEBACiAjIFBDSSBFeHByZXNzIEFTUE0KICMKIGNvbmZpZyBQQ0lFQVNQTQotCWJvb2wgIlBDSSBFeHByZXNzIEFTUE0gY29udHJvbCIgaWYgRU1CRURERUQKKwlib29sICJQQ0kgRXhwcmVzcyBBU1BNIGNvbnRyb2wiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gUENJICYmIFBDSUVQT1JUQlVTCiAJZGVmYXVsdCB5CiAJaGVscApkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcGNpZS9hZXIvYWVyZHJ2LmMgYi9kcml2ZXJzL3BjaS9wY2llL2Flci9hZXJkcnYuYwppbmRleCAyYjJiNjUwLi41OGFkNzkxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9wY2llL2Flci9hZXJkcnYuYworKysgYi9kcml2ZXJzL3BjaS9wY2llL2Flci9hZXJkcnYuYwpAQCAtMTcsNiArMTcsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8bGludXgvcGNpLWFjcGkuaD4KICNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9wY2llL2Flci9hZXJkcnYuaCBiL2RyaXZlcnMvcGNpL3BjaWUvYWVyL2FlcmRydi5oCmluZGV4IDk2NTZlMzAuLjgwYzExZDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL3BjaWUvYWVyL2FlcmRydi5oCisrKyBiL2RyaXZlcnMvcGNpL3BjaWUvYWVyL2FlcmRydi5oCkBAIC0xMzIsNyArMTMyLDYgQEAKIAogI2lmZGVmIENPTkZJR19BQ1BJX0FQRUkKIGV4dGVybiBpbnQgcGNpZV9hZXJfZ2V0X2Zpcm13YXJlX2ZpcnN0KHN0cnVjdCBwY2lfZGV2ICpwY2lfZGV2KTsKLWV4dGVybiBib29sIGFlcl9hY3BpX2Zpcm13YXJlX2ZpcnN0KHZvaWQpOwogI2Vsc2UKIHN0YXRpYyBpbmxpbmUgaW50IHBjaWVfYWVyX2dldF9maXJtd2FyZV9maXJzdChzdHJ1Y3QgcGNpX2RldiAqcGNpX2RldikKIHsKQEAgLTE0MCw4ICsxMzksNiBAQAogCQlyZXR1cm4gcGNpX2Rldi0+X19hZXJfZmlybXdhcmVfZmlyc3Q7CiAJcmV0dXJuIDA7CiB9Ci0KLXN0YXRpYyBpbmxpbmUgYm9vbCBhZXJfYWNwaV9maXJtd2FyZV9maXJzdCh2b2lkKSB7IHJldHVybiBmYWxzZTsgfQogI2VuZGlmCiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBwY2llX2Flcl9mb3JjZV9maXJtd2FyZV9maXJzdChzdHJ1Y3QgcGNpX2RldiAqcGNpX2RldiwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL3BjaWUvYXNwbS5jIGIvZHJpdmVycy9wY2kvcGNpZS9hc3BtLmMKaW5kZXggNzEyMjI4MS4uMzE4OGNkOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY2kvcGNpZS9hc3BtLmMKKysrIGIvZHJpdmVycy9wY2kvcGNpZS9hc3BtLmMKQEAgLTY4LDcgKzY4LDcgQEAKIAlzdHJ1Y3QgYXNwbV9sYXRlbmN5IGFjY2VwdGFibGVbOF07CiB9OwogCi1zdGF0aWMgaW50IGFzcG1fZGlzYWJsZWQsIGFzcG1fZm9yY2U7CitzdGF0aWMgaW50IGFzcG1fZGlzYWJsZWQsIGFzcG1fZm9yY2UsIGFzcG1fY2xlYXJfc3RhdGU7CiBzdGF0aWMgREVGSU5FX01VVEVYKGFzcG1fbG9jayk7CiBzdGF0aWMgTElTVF9IRUFEKGxpbmtfbGlzdCk7CiAKQEAgLTEzOSw3ICsxMzksNyBAQAogewogCS8qIERvbid0IGVuYWJsZSBDbG9jayBQTSBpZiB0aGUgbGluayBpcyBub3QgQ2xvY2sgUE0gY2FwYWJsZSAqLwogCWlmICghbGluay0+Y2xrcG1fY2FwYWJsZSAmJiBlbmFibGUpCi0JCXJldHVybjsKKwkJZW5hYmxlID0gMDsKIAkvKiBOZWVkIG5vdGhpbmcgaWYgdGhlIHNwZWNpZmllZCBlcXVhbHMgdG8gY3VycmVudCBzdGF0ZSAqLwogCWlmIChsaW5rLT5jbGtwbV9lbmFibGVkID09IGVuYWJsZSkKIAkJcmV0dXJuOwpAQCAtNDk4LDYgKzQ5OCwxMCBAQAogCXN0cnVjdCBwY2lfZGV2ICpjaGlsZDsKIAlpbnQgcG9zOwogCXUzMiByZWczMjsKKworCWlmIChhc3BtX2NsZWFyX3N0YXRlKQorCQlyZXR1cm4gLUVJTlZBTDsKKwogCS8qCiAJICogU29tZSBmdW5jdGlvbnMgaW4gYSBzbG90IG1pZ2h0IG5vdCBhbGwgYmUgUENJZSBmdW5jdGlvbnMsCiAJICogdmVyeSBzdHJhbmdlLiBEaXNhYmxlIEFTUE0gZm9yIHRoZSB3aG9sZSBzbG90CkBAIC01NjMsMTIgKzU2NywxNSBAQAogCXN0cnVjdCBwY2llX2xpbmtfc3RhdGUgKmxpbms7CiAJaW50IGJsYWNrbGlzdCA9ICEhcGNpZV9hc3BtX3Nhbml0eV9jaGVjayhwZGV2KTsKIAotCWlmIChhc3BtX2Rpc2FibGVkIHx8ICFwY2lfaXNfcGNpZShwZGV2KSB8fCBwZGV2LT5saW5rX3N0YXRlKQorCWlmICghcGNpX2lzX3BjaWUocGRldikgfHwgcGRldi0+bGlua19zdGF0ZSkKIAkJcmV0dXJuOwogCWlmIChwZGV2LT5wY2llX3R5cGUgIT0gUENJX0VYUF9UWVBFX1JPT1RfUE9SVCAmJgogCSAgICBwZGV2LT5wY2llX3R5cGUgIT0gUENJX0VYUF9UWVBFX0RPV05TVFJFQU0pCiAJCXJldHVybjsKIAorCWlmIChhc3BtX2Rpc2FibGVkICYmICFhc3BtX2NsZWFyX3N0YXRlKQorCQlyZXR1cm47CisKIAkvKiBWSUEgaGFzIGEgc3RyYW5nZSBjaGlwc2V0LCByb290IHBvcnQgaXMgdW5kZXIgYSBicmlkZ2UgKi8KIAlpZiAocGRldi0+cGNpZV90eXBlID09IFBDSV9FWFBfVFlQRV9ST09UX1BPUlQgJiYKIAkgICAgcGRldi0+YnVzLT5zZWxmKQpAQCAtNjQxLDcgKzY0OCw3IEBACiAJc3RydWN0IHBjaV9kZXYgKnBhcmVudCA9IHBkZXYtPmJ1cy0+c2VsZjsKIAlzdHJ1Y3QgcGNpZV9saW5rX3N0YXRlICpsaW5rLCAqcm9vdCwgKnBhcmVudF9saW5rOwogCi0JaWYgKGFzcG1fZGlzYWJsZWQgfHwgIXBjaV9pc19wY2llKHBkZXYpIHx8CisJaWYgKChhc3BtX2Rpc2FibGVkICYmICFhc3BtX2NsZWFyX3N0YXRlKSB8fCAhcGNpX2lzX3BjaWUocGRldikgfHwKIAkgICAgIXBhcmVudCB8fCAhcGFyZW50LT5saW5rX3N0YXRlKQogCQlyZXR1cm47CiAJaWYgKChwYXJlbnQtPnBjaWVfdHlwZSAhPSBQQ0lfRVhQX1RZUEVfUk9PVF9QT1JUKSAmJgpAQCAtODk5LDYgKzkwNiwxMiBAQAogCiBfX3NldHVwKCJwY2llX2FzcG09IiwgcGNpZV9hc3BtX2Rpc2FibGUpOwogCit2b2lkIHBjaWVfY2xlYXJfYXNwbSh2b2lkKQoreworCWlmICghYXNwbV9mb3JjZSkKKwkJYXNwbV9jbGVhcl9zdGF0ZSA9IDE7Cit9CisKIHZvaWQgcGNpZV9ub19hc3BtKHZvaWQpCiB7CiAJaWYgKCFhc3BtX2ZvcmNlKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcGNpZS9wbWUuYyBiL2RyaXZlcnMvcGNpL3BjaWUvcG1lLmMKaW5kZXggMmYzYzkwNC4uMDA1NzM0NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY2kvcGNpZS9wbWUuYworKysgYi9kcml2ZXJzL3BjaS9wY2llL3BtZS5jCkBAIC0yNiw5ICsyNiw2IEBACiAjaW5jbHVkZSAiLi4vcGNpLmgiCiAjaW5jbHVkZSAicG9ydGRydi5oIgogCi0jZGVmaW5lIFBDSV9FWFBfUlRTVEFfUE1FCTB4MTAwMDAgLyogUE1FIHN0YXR1cyAqLwotI2RlZmluZSBQQ0lfRVhQX1JUU1RBX1BFTkRJTkcJMHgyMDAwMCAvKiBQTUUgcGVuZGluZyAqLwotCiAvKgogICogSWYgdGhpcyBzd2l0Y2ggaXMgc2V0LCBNU0kgd2lsbCBub3QgYmUgdXNlZCBmb3IgUENJZSBQTUUgc2lnbmFsaW5nLiAgVGhpcwogICogY2F1c2VzIHRoZSBQQ0llIHBvcnQgZHJpdmVyIHRvIHVzZSBJTlR4IGludGVycnVwdHMgb25seSwgYnV0IGl0IHR1cm5zIG91dApAQCAtNzQsMjIgKzcxLDYgQEAKIH0KIAogLyoqCi0gKiBwY2llX3BtZV9jbGVhcl9zdGF0dXMgLSBDbGVhciByb290IHBvcnQgUE1FIGludGVycnVwdCBzdGF0dXMuCi0gKiBAZGV2OiBQQ0llIHJvb3QgcG9ydCBvciBldmVudCBjb2xsZWN0b3IuCi0gKi8KLXN0YXRpYyB2b2lkIHBjaWVfcG1lX2NsZWFyX3N0YXR1cyhzdHJ1Y3QgcGNpX2RldiAqZGV2KQotewotCWludCBydHN0YV9wb3M7Ci0JdTMyIHJ0c3RhOwotCi0JcnRzdGFfcG9zID0gcGNpX3BjaWVfY2FwKGRldikgKyBQQ0lfRVhQX1JUU1RBOwotCi0JcGNpX3JlYWRfY29uZmlnX2R3b3JkKGRldiwgcnRzdGFfcG9zLCAmcnRzdGEpOwotCXJ0c3RhIHw9IFBDSV9FWFBfUlRTVEFfUE1FOwotCXBjaV93cml0ZV9jb25maWdfZHdvcmQoZGV2LCBydHN0YV9wb3MsIHJ0c3RhKTsKLX0KLQotLyoqCiAgKiBwY2llX3BtZV93YWxrX2J1cyAtIFNjYW4gYSBQQ0kgYnVzIGZvciBkZXZpY2VzIGFzc2VydGluZyBQTUUjLgogICogQGJ1czogUENJIGJ1cyB0byBzY2FuLgogICoKQEAgLTEwMyw4ICs4NCw4IEBACiAJbGlzdF9mb3JfZWFjaF9lbnRyeShkZXYsICZidXMtPmRldmljZXMsIGJ1c19saXN0KSB7CiAJCS8qIFNraXAgUENJZSBkZXZpY2VzIGluIGNhc2Ugd2Ugc3RhcnRlZCBmcm9tIGEgcm9vdCBwb3J0LiAqLwogCQlpZiAoIXBjaV9pc19wY2llKGRldikgJiYgcGNpX2NoZWNrX3BtZV9zdGF0dXMoZGV2KSkgewotCQkJcG1fcmVxdWVzdF9yZXN1bWUoJmRldi0+ZGV2KTsKIAkJCXBjaV93YWtldXBfZXZlbnQoZGV2KTsKKwkJCXBtX3JlcXVlc3RfcmVzdW1lKCZkZXYtPmRldik7CiAJCQlyZXQgPSB0cnVlOwogCQl9CiAKQEAgLTIwNiw4ICsxODcsOCBAQAogCQkvKiBUaGUgZGV2aWNlIGlzIHRoZXJlLCBidXQgd2UgaGF2ZSB0byBjaGVjayBpdHMgUE1FIHN0YXR1cy4gKi8KIAkJZm91bmQgPSBwY2lfY2hlY2tfcG1lX3N0YXR1cyhkZXYpOwogCQlpZiAoZm91bmQpIHsKLQkJCXBtX3JlcXVlc3RfcmVzdW1lKCZkZXYtPmRldik7CiAJCQlwY2lfd2FrZXVwX2V2ZW50KGRldik7CisJCQlwbV9yZXF1ZXN0X3Jlc3VtZSgmZGV2LT5kZXYpOwogCQl9CiAJCXBjaV9kZXZfcHV0KGRldik7CiAJfSBlbHNlIGlmIChkZXZmbikgewpAQCAtMjUzLDcgKzIzNCw3IEBACiAJCQkgKiBDbGVhciBQTUUgc3RhdHVzIG9mIHRoZSBwb3J0LiAgSWYgdGhlcmUgYXJlIG90aGVyCiAJCQkgKiBwZW5kaW5nIFBNRXMsIHRoZSBzdGF0dXMgd2lsbCBiZSBzZXQgYWdhaW4uCiAJCQkgKi8KLQkJCXBjaWVfcG1lX2NsZWFyX3N0YXR1cyhwb3J0KTsKKwkJCXBjaWVfY2xlYXJfcm9vdF9wbWVfc3RhdHVzKHBvcnQpOwogCiAJCQlzcGluX3VubG9ja19pcnEoJmRhdGEtPmxvY2spOwogCQkJcGNpZV9wbWVfaGFuZGxlX3JlcXVlc3QocG9ydCwgcnRzdGEgJiAweGZmZmYpOwpAQCAtMzc4LDcgKzM1OSw3IEBACiAKIAlwb3J0ID0gc3J2LT5wb3J0OwogCXBjaWVfcG1lX2ludGVycnVwdF9lbmFibGUocG9ydCwgZmFsc2UpOwotCXBjaWVfcG1lX2NsZWFyX3N0YXR1cyhwb3J0KTsKKwlwY2llX2NsZWFyX3Jvb3RfcG1lX3N0YXR1cyhwb3J0KTsKIAogCXJldCA9IHJlcXVlc3RfaXJxKHNydi0+aXJxLCBwY2llX3BtZV9pcnEsIElSUUZfU0hBUkVELCAiUENJZSBQTUUiLCBzcnYpOwogCWlmIChyZXQpIHsKQEAgLTQwMiw3ICszODMsNyBAQAogCiAJc3Bpbl9sb2NrX2lycSgmZGF0YS0+bG9jayk7CiAJcGNpZV9wbWVfaW50ZXJydXB0X2VuYWJsZShwb3J0LCBmYWxzZSk7Ci0JcGNpZV9wbWVfY2xlYXJfc3RhdHVzKHBvcnQpOworCXBjaWVfY2xlYXJfcm9vdF9wbWVfc3RhdHVzKHBvcnQpOwogCWRhdGEtPm5vaXJxID0gdHJ1ZTsKIAlzcGluX3VubG9ja19pcnEoJmRhdGEtPmxvY2spOwogCkBAIC00MjIsNyArNDAzLDcgQEAKIAogCXNwaW5fbG9ja19pcnEoJmRhdGEtPmxvY2spOwogCWRhdGEtPm5vaXJxID0gZmFsc2U7Ci0JcGNpZV9wbWVfY2xlYXJfc3RhdHVzKHBvcnQpOworCXBjaWVfY2xlYXJfcm9vdF9wbWVfc3RhdHVzKHBvcnQpOwogCXBjaWVfcG1lX2ludGVycnVwdF9lbmFibGUocG9ydCwgdHJ1ZSk7CiAJc3Bpbl91bmxvY2tfaXJxKCZkYXRhLT5sb2NrKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcGNpZS9wb3J0ZHJ2LmggYi9kcml2ZXJzL3BjaS9wY2llL3BvcnRkcnYuaAppbmRleCA3YjVhYmEwLi5iZDAwYTAxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9wY2llL3BvcnRkcnYuaAorKysgYi9kcml2ZXJzL3BjaS9wY2llL3BvcnRkcnYuaApAQCAtMjAsOSArMjAsNiBAQAogCiAjZGVmaW5lIGdldF9kZXNjcmlwdG9yX2lkKHR5cGUsIHNlcnZpY2UpICgoKHR5cGUgLSA0KSA8PCA0KSB8IHNlcnZpY2UpCiAKLWV4dGVybiBib29sIHBjaWVfcG9ydHNfZGlzYWJsZWQ7Ci1leHRlcm4gYm9vbCBwY2llX3BvcnRzX2F1dG87Ci0KIGV4dGVybiBzdHJ1Y3QgYnVzX3R5cGUgcGNpZV9wb3J0X2J1c190eXBlOwogZXh0ZXJuIGludCBwY2llX3BvcnRfZGV2aWNlX3JlZ2lzdGVyKHN0cnVjdCBwY2lfZGV2ICpkZXYpOwogI2lmZGVmIENPTkZJR19QTQpAQCAtMzUsNiArMzIsOCBAQAogCiBzdHJ1Y3QgcGNpX2RldjsKIAorZXh0ZXJuIHZvaWQgcGNpZV9jbGVhcl9yb290X3BtZV9zdGF0dXMoc3RydWN0IHBjaV9kZXYgKmRldik7CisKICNpZmRlZiBDT05GSUdfUENJRV9QTUUKIGV4dGVybiBib29sIHBjaWVfcG1lX21zaV9kaXNhYmxlZDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcGNpZS9wb3J0ZHJ2X2FjcGkuYyBiL2RyaXZlcnMvcGNpL3BjaWUvcG9ydGRydl9hY3BpLmMKaW5kZXggNTk4MmI2YS4uYTg2YjU2ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY2kvcGNpZS9wb3J0ZHJ2X2FjcGkuYworKysgYi9kcml2ZXJzL3BjaS9wY2llL3BvcnRkcnZfYWNwaS5jCkBAIC0zMyw3ICszMyw3IEBACiAgKi8KIGludCBwY2llX3BvcnRfYWNwaV9zZXR1cChzdHJ1Y3QgcGNpX2RldiAqcG9ydCwgaW50ICpzcnZfbWFzaykKIHsKLQlhY3BpX3N0YXR1cyBzdGF0dXM7CisJc3RydWN0IGFjcGlfcGNpX3Jvb3QgKnJvb3Q7CiAJYWNwaV9oYW5kbGUgaGFuZGxlOwogCXUzMiBmbGFnczsKIApAQCAtNDQsMjYgKzQ0LDExIEBACiAJaWYgKCFoYW5kbGUpCiAJCXJldHVybiAtRUlOVkFMOwogCi0JZmxhZ3MgPSBPU0NfUENJX0VYUFJFU1NfQ0FQX1NUUlVDVFVSRV9DT05UUk9MCi0JCXwgT1NDX1BDSV9FWFBSRVNTX05BVElWRV9IUF9DT05UUk9MCi0JCXwgT1NDX1BDSV9FWFBSRVNTX1BNRV9DT05UUk9MOwotCi0JaWYgKHBjaV9hZXJfYXZhaWxhYmxlKCkpIHsKLQkJaWYgKGFlcl9hY3BpX2Zpcm13YXJlX2ZpcnN0KCkpCi0JCQlkZXZfZGJnKCZwb3J0LT5kZXYsICJQQ0llIGVycm9ycyBoYW5kbGVkIGJ5IEJJT1MuXG4iKTsKLQkJZWxzZQotCQkJZmxhZ3MgfD0gT1NDX1BDSV9FWFBSRVNTX0FFUl9DT05UUk9MOwotCX0KLQotCXN0YXR1cyA9IGFjcGlfcGNpX29zY19jb250cm9sX3NldChoYW5kbGUsICZmbGFncywKLQkJCQkJT1NDX1BDSV9FWFBSRVNTX0NBUF9TVFJVQ1RVUkVfQ09OVFJPTCk7Ci0JaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKSB7Ci0JCWRldl9kYmcoJnBvcnQtPmRldiwgIkFDUEkgX09TQyByZXF1ZXN0IGZhaWxlZCAoY29kZSAlZClcbiIsCi0JCQlzdGF0dXMpOworCXJvb3QgPSBhY3BpX3BjaV9maW5kX3Jvb3QoaGFuZGxlKTsKKwlpZiAoIXJvb3QpCiAJCXJldHVybiAtRU5PREVWOwotCX0KIAotCWRldl9pbmZvKCZwb3J0LT5kZXYsICJBQ1BJIF9PU0MgY29udHJvbCBncmFudGVkIGZvciAweCUwMnhcbiIsIGZsYWdzKTsKKwlmbGFncyA9IHJvb3QtPm9zY19jb250cm9sX3NldDsKIAogCSpzcnZfbWFzayA9IFBDSUVfUE9SVF9TRVJWSUNFX1ZDOwogCWlmIChmbGFncyAmIE9TQ19QQ0lfRVhQUkVTU19OQVRJVkVfSFBfQ09OVFJPTCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL3BjaWUvcG9ydGRydl9jb3JlLmMgYi9kcml2ZXJzL3BjaS9wY2llL3BvcnRkcnZfY29yZS5jCmluZGV4IGE5YzIyMmQuLjUxMzBkMGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL3BjaWUvcG9ydGRydl9jb3JlLmMKKysrIGIvZHJpdmVycy9wY2kvcGNpZS9wb3J0ZHJ2X2NvcmUuYwpAQCAtMjQxLDE3ICsyNDEsMTcgQEAKIAlpbnQgY2FwX21hc2s7CiAJaW50IGVycjsKIAorCWlmIChwY2llX3BvcnRzX2Rpc2FibGVkKQorCQlyZXR1cm4gMDsKKwogCWVyciA9IHBjaWVfcG9ydF9wbGF0Zm9ybV9ub3RpZnkoZGV2LCAmY2FwX21hc2spOwotCWlmIChwY2llX3BvcnRzX2F1dG8pIHsKLQkJaWYgKGVycikgewotCQkJcGNpZV9ub19hc3BtKCk7Ci0JCQlyZXR1cm4gMDsKLQkJfQotCX0gZWxzZSB7CisJaWYgKCFwY2llX3BvcnRzX2F1dG8pIHsKIAkJY2FwX21hc2sgPSBQQ0lFX1BPUlRfU0VSVklDRV9QTUUgfCBQQ0lFX1BPUlRfU0VSVklDRV9IUAogCQkJCXwgUENJRV9QT1JUX1NFUlZJQ0VfVkM7CiAJCWlmIChwY2lfYWVyX2F2YWlsYWJsZSgpKQogCQkJY2FwX21hc2sgfD0gUENJRV9QT1JUX1NFUlZJQ0VfQUVSOworCX0gZWxzZSBpZiAoZXJyKSB7CisJCQlyZXR1cm4gMDsKIAl9CiAKIAlwb3MgPSBwY2lfcGNpZV9jYXAoZGV2KTsKQEAgLTM0OSwxNSArMzQ5LDE4IEBACiAJaW50IHN0YXR1cywgY2FwYWJpbGl0aWVzLCBpLCBucl9zZXJ2aWNlOwogCWludCBpcnFzW1BDSUVfUE9SVF9ERVZJQ0VfTUFYU0VSVklDRVNdOwogCi0JLyogR2V0IGFuZCBjaGVjayBQQ0kgRXhwcmVzcyBwb3J0IHNlcnZpY2VzICovCi0JY2FwYWJpbGl0aWVzID0gZ2V0X3BvcnRfZGV2aWNlX2NhcGFiaWxpdHkoZGV2KTsKLQlpZiAoIWNhcGFiaWxpdGllcykKLQkJcmV0dXJuIC1FTk9ERVY7Ci0KIAkvKiBFbmFibGUgUENJIEV4cHJlc3MgcG9ydCBkZXZpY2UgKi8KIAlzdGF0dXMgPSBwY2lfZW5hYmxlX2RldmljZShkZXYpOwogCWlmIChzdGF0dXMpCiAJCXJldHVybiBzdGF0dXM7CisKKwkvKiBHZXQgYW5kIGNoZWNrIFBDSSBFeHByZXNzIHBvcnQgc2VydmljZXMgKi8KKwljYXBhYmlsaXRpZXMgPSBnZXRfcG9ydF9kZXZpY2VfY2FwYWJpbGl0eShkZXYpOworCWlmICghY2FwYWJpbGl0aWVzKSB7CisJCXBjaWVfbm9fYXNwbSgpOworCQlyZXR1cm4gMDsKKwl9CisKIAlwY2lfc2V0X21hc3RlcihkZXYpOwogCS8qCiAJICogSW5pdGlhbGl6ZSBzZXJ2aWNlIGlycXMuIERvbid0IHVzZSBzZXJ2aWNlIGRldmljZXMgdGhhdApkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcGNpZS9wb3J0ZHJ2X3BjaS5jIGIvZHJpdmVycy9wY2kvcGNpZS9wb3J0ZHJ2X3BjaS5jCmluZGV4IGY5MDMzZTEuLmUwNjEwYmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL3BjaWUvcG9ydGRydl9wY2kuYworKysgYi9kcml2ZXJzL3BjaS9wY2llL3BvcnRkcnZfcGNpLmMKQEAgLTU3LDYgKzU3LDIyIEBACiAKIC8qIGdsb2JhbCBkYXRhICovCiAKKy8qKgorICogcGNpZV9jbGVhcl9yb290X3BtZV9zdGF0dXMgLSBDbGVhciByb290IHBvcnQgUE1FIGludGVycnVwdCBzdGF0dXMuCisgKiBAZGV2OiBQQ0llIHJvb3QgcG9ydCBvciBldmVudCBjb2xsZWN0b3IuCisgKi8KK3ZvaWQgcGNpZV9jbGVhcl9yb290X3BtZV9zdGF0dXMoc3RydWN0IHBjaV9kZXYgKmRldikKK3sKKwlpbnQgcnRzdGFfcG9zOworCXUzMiBydHN0YTsKKworCXJ0c3RhX3BvcyA9IHBjaV9wY2llX2NhcChkZXYpICsgUENJX0VYUF9SVFNUQTsKKworCXBjaV9yZWFkX2NvbmZpZ19kd29yZChkZXYsIHJ0c3RhX3BvcywgJnJ0c3RhKTsKKwlydHN0YSB8PSBQQ0lfRVhQX1JUU1RBX1BNRTsKKwlwY2lfd3JpdGVfY29uZmlnX2R3b3JkKGRldiwgcnRzdGFfcG9zLCBydHN0YSk7Cit9CisKIHN0YXRpYyBpbnQgcGNpZV9wb3J0ZHJ2X3Jlc3RvcmVfY29uZmlnKHN0cnVjdCBwY2lfZGV2ICpkZXYpCiB7CiAJaW50IHJldHZhbDsKQEAgLTY5LDYgKzg1LDIwIEBACiB9CiAKICNpZmRlZiBDT05GSUdfUE0KK3N0YXRpYyBpbnQgcGNpZV9wb3J0X3Jlc3VtZV9ub2lycShzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHBjaV9kZXYgKnBkZXYgPSB0b19wY2lfZGV2KGRldik7CisKKwkvKgorCSAqIFNvbWUgQklPU2VzIGZvcmdldCB0byBjbGVhciBSb290IFBNRSBTdGF0dXMgYml0cyBhZnRlciBzeXN0ZW0gd2FrZXVwCisJICogd2hpY2ggYnJlYWtzIEFDUEktYmFzZWQgcnVudGltZSB3YWtldXAgb24gUENJIEV4cHJlc3MsIHNvIGNsZWFyIHRob3NlCisJICogYml0cyBub3cganVzdCBpbiBjYXNlIChzaG91bGRuJ3QgaHVydCkuCisJICovCisJaWYocGRldi0+cGNpZV90eXBlID09IFBDSV9FWFBfVFlQRV9ST09UX1BPUlQpCisJCXBjaWVfY2xlYXJfcm9vdF9wbWVfc3RhdHVzKHBkZXYpOworCXJldHVybiAwOworfQorCiBzdGF0aWMgY29uc3Qgc3RydWN0IGRldl9wbV9vcHMgcGNpZV9wb3J0ZHJ2X3BtX29wcyA9IHsKIAkuc3VzcGVuZAk9IHBjaWVfcG9ydF9kZXZpY2Vfc3VzcGVuZCwKIAkucmVzdW1lCQk9IHBjaWVfcG9ydF9kZXZpY2VfcmVzdW1lLApAQCAtNzYsNiArMTA2LDcgQEAKIAkudGhhdwkJPSBwY2llX3BvcnRfZGV2aWNlX3Jlc3VtZSwKIAkucG93ZXJvZmYJPSBwY2llX3BvcnRfZGV2aWNlX3N1c3BlbmQsCiAJLnJlc3RvcmUJPSBwY2llX3BvcnRfZGV2aWNlX3Jlc3VtZSwKKwkucmVzdW1lX25vaXJxCT0gcGNpZV9wb3J0X3Jlc3VtZV9ub2lycSwKIH07CiAKICNkZWZpbmUgUENJRV9QT1JURFJWX1BNX09QUwkoJnBjaWVfcG9ydGRydl9wbV9vcHMpCkBAIC0zMjcsMTAgKzM1OCw4IEBACiB7CiAJaW50IHJldHZhbDsKIAotCWlmIChwY2llX3BvcnRzX2Rpc2FibGVkKSB7Ci0JCXBjaWVfbm9fYXNwbSgpOwotCQlyZXR1cm4gLUVBQ0NFUzsKLQl9CisJaWYgKHBjaWVfcG9ydHNfZGlzYWJsZWQpCisJCXJldHVybiBwY2lfcmVnaXN0ZXJfZHJpdmVyKCZwY2llX3BvcnRkcml2ZXIpOwogCiAJZG1pX2NoZWNrX3N5c3RlbShwY2llX3BvcnRkcnZfZG1pX3RhYmxlKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY21jaWEvS2NvbmZpZyBiL2RyaXZlcnMvcGNtY2lhL0tjb25maWcKaW5kZXggZGU4ODZmMy4uNmUzMThjZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY21jaWEvS2NvbmZpZworKysgYi9kcml2ZXJzL3BjbWNpYS9LY29uZmlnCkBAIC02OSw3ICs2OSw3IEBACiBjb25maWcgWUVOVEEKIAl0cmlzdGF0ZSAiQ2FyZEJ1cyB5ZW50YS1jb21wYXRpYmxlIGJyaWRnZSBzdXBwb3J0IgogCWRlcGVuZHMgb24gUENJCi0Jc2VsZWN0IENBUkRCVVMgaWYgIUVNQkVEREVECisJc2VsZWN0IENBUkRCVVMgaWYgIUVYUEVSVAogCXNlbGVjdCBQQ0NBUkRfTk9OU1RBVElDIGlmIFBDTUNJQSAhPSBuCiAJLS0taGVscC0tLQogCSAgVGhpcyBvcHRpb24gZW5hYmxlcyBzdXBwb3J0IGZvciBDYXJkQnVzIGhvc3QgYnJpZGdlcy4gIFZpcnR1YWxseQpAQCAtODQsMjcgKzg0LDI3IEBACiAKIGNvbmZpZyBZRU5UQV9PMgogCWRlZmF1bHQgeQotCWJvb2wgIlNwZWNpYWwgaW5pdGlhbGl6YXRpb24gZm9yIE8yTWljcm8gYnJpZGdlcyIgaWYgRU1CRURERUQKKwlib29sICJTcGVjaWFsIGluaXRpYWxpemF0aW9uIGZvciBPMk1pY3JvIGJyaWRnZXMiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gWUVOVEEKIAogY29uZmlnIFlFTlRBX1JJQ09ICiAJZGVmYXVsdCB5Ci0JYm9vbCAiU3BlY2lhbCBpbml0aWFsaXphdGlvbiBmb3IgUmljb2ggYnJpZGdlcyIgaWYgRU1CRURERUQKKwlib29sICJTcGVjaWFsIGluaXRpYWxpemF0aW9uIGZvciBSaWNvaCBicmlkZ2VzIiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFlFTlRBCiAKIGNvbmZpZyBZRU5UQV9USQogCWRlZmF1bHQgeQotCWJvb2wgIlNwZWNpYWwgaW5pdGlhbGl6YXRpb24gZm9yIFRJIGFuZCBFbkUgYnJpZGdlcyIgaWYgRU1CRURERUQKKwlib29sICJTcGVjaWFsIGluaXRpYWxpemF0aW9uIGZvciBUSSBhbmQgRW5FIGJyaWRnZXMiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gWUVOVEEKIAogY29uZmlnIFlFTlRBX0VORV9UVU5FCiAJZGVmYXVsdCB5Ci0JYm9vbCAiQXV0by10dW5lIEVuRSBicmlkZ2VzIGZvciBDQiBjYXJkcyIgaWYgRU1CRURERUQKKwlib29sICJBdXRvLXR1bmUgRW5FIGJyaWRnZXMgZm9yIENCIGNhcmRzIiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFlFTlRBX1RJICYmIENBUkRCVVMKIAogY29uZmlnIFlFTlRBX1RPU0hJQkEKIAlkZWZhdWx0IHkKLQlib29sICJTcGVjaWFsIGluaXRpYWxpemF0aW9uIGZvciBUb3NoaWJhIFRvUElDIGJyaWRnZXMiIGlmIEVNQkVEREVECisJYm9vbCAiU3BlY2lhbCBpbml0aWFsaXphdGlvbiBmb3IgVG9zaGliYSBUb1BJQyBicmlkZ2VzIiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFlFTlRBCiAKIGNvbmZpZyBQRDY3MjkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGxhdGZvcm0veDg2L2Z1aml0c3UtbGFwdG9wLmMgYi9kcml2ZXJzL3BsYXRmb3JtL3g4Ni9mdWppdHN1LWxhcHRvcC5jCmluZGV4IDE5ZTkyYjIuLjk1ZTNiMDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGxhdGZvcm0veDg2L2Z1aml0c3UtbGFwdG9wLmMKKysrIGIvZHJpdmVycy9wbGF0Zm9ybS94ODYvZnVqaXRzdS1sYXB0b3AuYwpAQCAtNjg5LDcgKzY4OSw3IEBACiAJaWYgKGVycm9yKQogCQlnb3RvIGVycl9mcmVlX2lucHV0X2RldjsKIAotCXJlc3VsdCA9IGFjcGlfYnVzX2dldF9wb3dlcihmdWppdHN1LT5hY3BpX2hhbmRsZSwgJnN0YXRlKTsKKwlyZXN1bHQgPSBhY3BpX2J1c191cGRhdGVfcG93ZXIoZnVqaXRzdS0+YWNwaV9oYW5kbGUsICZzdGF0ZSk7CiAJaWYgKHJlc3VsdCkgewogCQlwcmludGsoS0VSTl9FUlIgIkVycm9yIHJlYWRpbmcgcG93ZXIgc3RhdGVcbiIpOwogCQlnb3RvIGVycl91bnJlZ2lzdGVyX2lucHV0X2RldjsKQEAgLTg1Nyw3ICs4NTcsNyBAQAogCWlmIChlcnJvcikKIAkJZ290byBlcnJfZnJlZV9pbnB1dF9kZXY7CiAKLQlyZXN1bHQgPSBhY3BpX2J1c19nZXRfcG93ZXIoZnVqaXRzdV9ob3RrZXktPmFjcGlfaGFuZGxlLCAmc3RhdGUpOworCXJlc3VsdCA9IGFjcGlfYnVzX3VwZGF0ZV9wb3dlcihmdWppdHN1X2hvdGtleS0+YWNwaV9oYW5kbGUsICZzdGF0ZSk7CiAJaWYgKHJlc3VsdCkgewogCQlwcmludGsoS0VSTl9FUlIgIkVycm9yIHJlYWRpbmcgcG93ZXIgc3RhdGVcbiIpOwogCQlnb3RvIGVycl91bnJlZ2lzdGVyX2lucHV0X2RldjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGxhdGZvcm0veDg2L2ludGVsX3NjdV9pcGMuYyBiL2RyaXZlcnMvcGxhdGZvcm0veDg2L2ludGVsX3NjdV9pcGMuYwppbmRleCAxNzUyZWYwLi5hOTFkNTEwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BsYXRmb3JtL3g4Ni9pbnRlbF9zY3VfaXBjLmMKKysrIGIvZHJpdmVycy9wbGF0Zm9ybS94ODYvaW50ZWxfc2N1X2lwYy5jCkBAIC0yNiw3ICsyNiw2IEBACiAjaW5jbHVkZSA8bGludXgvc2ZpLmg+CiAjaW5jbHVkZSA8YXNtL21yc3QuaD4KICNpbmNsdWRlIDxhc20vaW50ZWxfc2N1X2lwYy5oPgotI2luY2x1ZGUgPGFzbS9tcnN0Lmg+CiAKIC8qIElQQyBkZWZpbmVzIHRoZSBmb2xsb3dpbmcgbWVzc2FnZSB0eXBlcyAqLwogI2RlZmluZSBJUENNU0dfV0FUQ0hET0dfVElNRVIgMHhGOCAvKiBTZXQgS2VybmVsIFdhdGNoZG9nIFRocmVzaG9sZCAqLwpAQCAtMTYxLDcgKzE2MCw3IEBACiB7CiAJaW50IGksIG5jLCBieXRlcywgZDsKIAl1MzIgb2Zmc2V0ID0gMDsKLQl1MzIgZXJyID0gMDsKKwlpbnQgZXJyOwogCXU4IGNidWZbSVBDX1dXQlVGX1NJWkVdID0geyB9OwogCXUzMiAqd2J1ZiA9ICh1MzIgKikmY2J1ZjsKIApAQCAtNDA0LDcgKzQwMyw3IEBACiAgKi8KIGludCBpbnRlbF9zY3VfaXBjX3NpbXBsZV9jb21tYW5kKGludCBjbWQsIGludCBzdWIpCiB7Ci0JdTMyIGVyciA9IDA7CisJaW50IGVycjsKIAogCW11dGV4X2xvY2soJmlwY2xvY2spOwogCWlmIChpcGNkZXYucGRldiA9PSBOVUxMKSB7CkBAIC00MzQsOCArNDMzLDcgQEAKIGludCBpbnRlbF9zY3VfaXBjX2NvbW1hbmQoaW50IGNtZCwgaW50IHN1YiwgdTMyICppbiwgaW50IGlubGVuLAogCQkJCQkJCXUzMiAqb3V0LCBpbnQgb3V0bGVuKQogewotCXUzMiBlcnIgPSAwOwotCWludCBpID0gMDsKKwlpbnQgaSwgZXJyOwogCiAJbXV0ZXhfbG9jaygmaXBjbG9jayk7CiAJaWYgKGlwY2Rldi5wZGV2ID09IE5VTEwpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGxhdGZvcm0veDg2L2ludGVsX3NjdV9pcGN1dGlsLmMgYi9kcml2ZXJzL3BsYXRmb3JtL3g4Ni9pbnRlbF9zY3VfaXBjdXRpbC5jCmluZGV4IGJhMzIzMWQuLmI5M2EwMzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGxhdGZvcm0veDg2L2ludGVsX3NjdV9pcGN1dGlsLmMKKysrIGIvZHJpdmVycy9wbGF0Zm9ybS94ODYvaW50ZWxfc2N1X2lwY3V0aWwuYwpAQCAtMTI4LDYgKzEyOCw2IEBACiBtb2R1bGVfaW5pdChpcGNfbW9kdWxlX2luaXQpOwogbW9kdWxlX2V4aXQoaXBjX21vZHVsZV9leGl0KTsKIAotTU9EVUxFX0xJQ0VOU0UoIkdQTCBWMiIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOwogTU9EVUxFX0RFU0NSSVBUSU9OKCJVdGlsaXR5IGRyaXZlciBmb3IgaW50ZWwgc2N1IGlwYyIpOwogTU9EVUxFX0FVVEhPUigiU3JlZWRoYXJhIDxzcmVlZGhhcmEuZHNAaW50ZWwuY29tPiIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wbnAvTWFrZWZpbGUgYi9kcml2ZXJzL3BucC9NYWtlZmlsZQppbmRleCA4ZGUzNzc1Li5iZmJhODkzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BucC9NYWtlZmlsZQorKysgYi9kcml2ZXJzL3BucC9NYWtlZmlsZQpAQCAtMiwxMSArMiwxMyBAQAogIyBNYWtlZmlsZSBmb3IgdGhlIExpbnV4IFBsdWctYW5kLVBsYXkgU3VwcG9ydC4KICMKIAotb2JqLXkJCTo9IGNvcmUubyBjYXJkLm8gZHJpdmVyLm8gcmVzb3VyY2UubyBtYW5hZ2VyLm8gc3VwcG9ydC5vIGludGVyZmFjZS5vIHF1aXJrcy5vCitvYmoteQkJOj0gcG5wLm8KKworcG5wLXkJCTo9IGNvcmUubyBjYXJkLm8gZHJpdmVyLm8gcmVzb3VyY2UubyBtYW5hZ2VyLm8gc3VwcG9ydC5vIGludGVyZmFjZS5vIHF1aXJrcy5vCiAKIG9iai0kKENPTkZJR19QTlBBQ1BJKQkJKz0gcG5wYWNwaS8KIG9iai0kKENPTkZJR19QTlBCSU9TKQkJKz0gcG5wYmlvcy8KIG9iai0kKENPTkZJR19JU0FQTlApCQkrPSBpc2FwbnAvCiAKICMgcG5wX3N5c3RlbV9pbml0IGdvZXMgYWZ0ZXIgcG5wYWNwaS9wbnBiaW9zIGluaXQKLW9iai15CQkJCSs9IHN5c3RlbS5vCitwbnAteQkJCQkrPSBzeXN0ZW0ubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wbnAvY29yZS5jIGIvZHJpdmVycy9wbnAvY29yZS5jCmluZGV4IDBmMzRkOTYuLmNiNmNlNDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcG5wL2NvcmUuYworKysgYi9kcml2ZXJzL3BucC9jb3JlLmMKQEAgLTIyMCwxMCArMjIwLDUgQEAKIGludCBwbnBfZGVidWc7CiAKICNpZiBkZWZpbmVkKENPTkZJR19QTlBfREVCVUdfTUVTU0FHRVMpCi1zdGF0aWMgaW50IF9faW5pdCBwbnBfZGVidWdfc2V0dXAoY2hhciAqX191bnVzZWQpCi17Ci0JcG5wX2RlYnVnID0gMTsKLQlyZXR1cm4gMTsKLX0KLV9fc2V0dXAoInBucC5kZWJ1ZyIsIHBucF9kZWJ1Z19zZXR1cCk7Cittb2R1bGVfcGFyYW1fbmFtZWQoZGVidWcsIHBucF9kZWJ1ZywgaW50LCAwNjQ0KTsKICNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wbnAvZHJpdmVyLmMgYi9kcml2ZXJzL3BucC9kcml2ZXIuYwppbmRleCBkMWRiYjlkLi4wMGU5NDAzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BucC9kcml2ZXIuYworKysgYi9kcml2ZXJzL3BucC9kcml2ZXIuYwpAQCAtMTg5LDggKzE4OSwxMSBAQAogCWlmICghcG5wX2RydikKIAkJcmV0dXJuIDA7CiAKLQlpZiAocG5wX2Rldi0+cHJvdG9jb2wtPnJlc3VtZSkKLQkJcG5wX2Rldi0+cHJvdG9jb2wtPnJlc3VtZShwbnBfZGV2KTsKKwlpZiAocG5wX2Rldi0+cHJvdG9jb2wtPnJlc3VtZSkgeworCQllcnJvciA9IHBucF9kZXYtPnByb3RvY29sLT5yZXN1bWUocG5wX2Rldik7CisJCWlmIChlcnJvcikKKwkJCXJldHVybiBlcnJvcjsKKwl9CiAKIAlpZiAocG5wX2Nhbl93cml0ZShwbnBfZGV2KSkgewogCQllcnJvciA9IHBucF9zdGFydF9kZXYocG5wX2Rldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BucC9pc2FwbnAvTWFrZWZpbGUgYi9kcml2ZXJzL3BucC9pc2FwbnAvTWFrZWZpbGUKaW5kZXggY2FjMThiYi4uNmU2MDdhYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9wbnAvaXNhcG5wL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvcG5wL2lzYXBucC9NYWtlZmlsZQpAQCAtMSw3ICsxLDcgQEAKICMKICMgTWFrZWZpbGUgZm9yIHRoZSBrZXJuZWwgSVNBUE5QIGRyaXZlci4KICMKK29iai15CQkJKz0gcG5wLm8KK3BucC15CQkJOj0gY29yZS5vIGNvbXBhdC5vCiAKLWlzYXBucC1wcm9jLSQoQ09ORklHX1BST0NfRlMpID0gcHJvYy5vCi0KLW9iai15IDo9IGNvcmUubyBjb21wYXQubyAkKGlzYXBucC1wcm9jLXkpCitwbnAtJChDT05GSUdfUFJPQ19GUykJKz0gcHJvYy5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BucC9wbnBhY3BpL01ha2VmaWxlIGIvZHJpdmVycy9wbnAvcG5wYWNwaS9NYWtlZmlsZQppbmRleCA5MDUzMjZmLi40MGM5M2RhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BucC9wbnBhY3BpL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvcG5wL3BucGFjcGkvTWFrZWZpbGUKQEAgLTEsNSArMSw2IEBACiAjCiAjIE1ha2VmaWxlIGZvciB0aGUga2VybmVsIFBOUEFDUEkgZHJpdmVyLgogIworb2JqLXkgKz0gcG5wLm8KIAotb2JqLXkgOj0gY29yZS5vIHJzcGFyc2VyLm8KK3BucC15IDo9IGNvcmUubyByc3BhcnNlci5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BucC9wbnBhY3BpL2NvcmUuYyBiL2RyaXZlcnMvcG5wL3BucGFjcGkvY29yZS5jCmluZGV4IDU3MzEzZjQuLmNhODRkNTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcG5wL3BucGFjcGkvY29yZS5jCisrKyBiL2RyaXZlcnMvcG5wL3BucGFjcGkvY29yZS5jCkBAIC04MSwxMiArODEsMTkgQEAKIAogc3RhdGljIGludCBwbnBhY3BpX3NldF9yZXNvdXJjZXMoc3RydWN0IHBucF9kZXYgKmRldikKIHsKLQlzdHJ1Y3QgYWNwaV9kZXZpY2UgKmFjcGlfZGV2ID0gZGV2LT5kYXRhOwotCWFjcGlfaGFuZGxlIGhhbmRsZSA9IGFjcGlfZGV2LT5oYW5kbGU7CisJc3RydWN0IGFjcGlfZGV2aWNlICphY3BpX2RldjsKKwlhY3BpX2hhbmRsZSBoYW5kbGU7CiAJc3RydWN0IGFjcGlfYnVmZmVyIGJ1ZmZlcjsKIAlpbnQgcmV0OwogCiAJcG5wX2RiZygmZGV2LT5kZXYsICJzZXQgcmVzb3VyY2VzXG4iKTsKKworCWhhbmRsZSA9IERFVklDRV9BQ1BJX0hBTkRMRSgmZGV2LT5kZXYpOworCWlmICghaGFuZGxlIHx8IEFDUElfRkFJTFVSRShhY3BpX2J1c19nZXRfZGV2aWNlKGhhbmRsZSwgJmFjcGlfZGV2KSkpIHsKKwkJZGV2X2RiZygmZGV2LT5kZXYsICJBQ1BJIGRldmljZSBub3QgZm91bmQgaW4gJXMhXG4iLCBfX2Z1bmNfXyk7CisJCXJldHVybiAtRU5PREVWOworCX0KKwogCXJldCA9IHBucGFjcGlfYnVpbGRfcmVzb3VyY2VfdGVtcGxhdGUoZGV2LCAmYnVmZmVyKTsKIAlpZiAocmV0KQogCQlyZXR1cm4gcmV0OwpAQCAtMTA1LDEyICsxMTIsMTggQEAKIAogc3RhdGljIGludCBwbnBhY3BpX2Rpc2FibGVfcmVzb3VyY2VzKHN0cnVjdCBwbnBfZGV2ICpkZXYpCiB7Ci0Jc3RydWN0IGFjcGlfZGV2aWNlICphY3BpX2RldiA9IGRldi0+ZGF0YTsKLQlhY3BpX2hhbmRsZSBoYW5kbGUgPSBhY3BpX2Rldi0+aGFuZGxlOworCXN0cnVjdCBhY3BpX2RldmljZSAqYWNwaV9kZXY7CisJYWNwaV9oYW5kbGUgaGFuZGxlOwogCWludCByZXQ7CiAKIAlkZXZfZGJnKCZkZXYtPmRldiwgImRpc2FibGUgcmVzb3VyY2VzXG4iKTsKIAorCWhhbmRsZSA9IERFVklDRV9BQ1BJX0hBTkRMRSgmZGV2LT5kZXYpOworCWlmICghaGFuZGxlIHx8IEFDUElfRkFJTFVSRShhY3BpX2J1c19nZXRfZGV2aWNlKGhhbmRsZSwgJmFjcGlfZGV2KSkpIHsKKwkJZGV2X2RiZygmZGV2LT5kZXYsICJBQ1BJIGRldmljZSBub3QgZm91bmQgaW4gJXMhXG4iLCBfX2Z1bmNfXyk7CisJCXJldHVybiAwOworCX0KKwogCS8qIGFjcGlfdW5yZWdpc3Rlcl9nc2kocG5wX2lycShkZXYsIDApKTsgKi8KIAlyZXQgPSAwOwogCWlmIChhY3BpX2J1c19wb3dlcl9tYW5hZ2VhYmxlKGhhbmRsZSkpCkBAIC0xMjQsNDYgKzEzNyw3NCBAQAogI2lmZGVmIENPTkZJR19BQ1BJX1NMRUVQCiBzdGF0aWMgYm9vbCBwbnBhY3BpX2Nhbl93YWtldXAoc3RydWN0IHBucF9kZXYgKmRldikKIHsKLQlzdHJ1Y3QgYWNwaV9kZXZpY2UgKmFjcGlfZGV2ID0gZGV2LT5kYXRhOwotCWFjcGlfaGFuZGxlIGhhbmRsZSA9IGFjcGlfZGV2LT5oYW5kbGU7CisJc3RydWN0IGFjcGlfZGV2aWNlICphY3BpX2RldjsKKwlhY3BpX2hhbmRsZSBoYW5kbGU7CisKKwloYW5kbGUgPSBERVZJQ0VfQUNQSV9IQU5ETEUoJmRldi0+ZGV2KTsKKwlpZiAoIWhhbmRsZSB8fCBBQ1BJX0ZBSUxVUkUoYWNwaV9idXNfZ2V0X2RldmljZShoYW5kbGUsICZhY3BpX2RldikpKSB7CisJCWRldl9kYmcoJmRldi0+ZGV2LCAiQUNQSSBkZXZpY2Ugbm90IGZvdW5kIGluICVzIVxuIiwgX19mdW5jX18pOworCQlyZXR1cm4gZmFsc2U7CisJfQogCiAJcmV0dXJuIGFjcGlfYnVzX2Nhbl93YWtldXAoaGFuZGxlKTsKIH0KIAogc3RhdGljIGludCBwbnBhY3BpX3N1c3BlbmQoc3RydWN0IHBucF9kZXYgKmRldiwgcG1fbWVzc2FnZV90IHN0YXRlKQogewotCXN0cnVjdCBhY3BpX2RldmljZSAqYWNwaV9kZXYgPSBkZXYtPmRhdGE7Ci0JYWNwaV9oYW5kbGUgaGFuZGxlID0gYWNwaV9kZXYtPmhhbmRsZTsKLQlpbnQgcG93ZXJfc3RhdGU7CisJc3RydWN0IGFjcGlfZGV2aWNlICphY3BpX2RldjsKKwlhY3BpX2hhbmRsZSBoYW5kbGU7CisJaW50IGVycm9yID0gMDsKKworCWhhbmRsZSA9IERFVklDRV9BQ1BJX0hBTkRMRSgmZGV2LT5kZXYpOworCWlmICghaGFuZGxlIHx8IEFDUElfRkFJTFVSRShhY3BpX2J1c19nZXRfZGV2aWNlKGhhbmRsZSwgJmFjcGlfZGV2KSkpIHsKKwkJZGV2X2RiZygmZGV2LT5kZXYsICJBQ1BJIGRldmljZSBub3QgZm91bmQgaW4gJXMhXG4iLCBfX2Z1bmNfXyk7CisJCXJldHVybiAwOworCX0KIAogCWlmIChkZXZpY2VfY2FuX3dha2V1cCgmZGV2LT5kZXYpKSB7Ci0JCWludCByYyA9IGFjcGlfcG1fZGV2aWNlX3NsZWVwX3dha2UoJmRldi0+ZGV2LAorCQllcnJvciA9IGFjcGlfcG1fZGV2aWNlX3NsZWVwX3dha2UoJmRldi0+ZGV2LAogCQkJCWRldmljZV9tYXlfd2FrZXVwKCZkZXYtPmRldikpOwotCi0JCWlmIChyYykKLQkJCXJldHVybiByYzsKKwkJaWYgKGVycm9yKQorCQkJcmV0dXJuIGVycm9yOwogCX0KLQlwb3dlcl9zdGF0ZSA9IGFjcGlfcG1fZGV2aWNlX3NsZWVwX3N0YXRlKCZkZXYtPmRldiwgTlVMTCk7Ci0JaWYgKHBvd2VyX3N0YXRlIDwgMCkKLQkJcG93ZXJfc3RhdGUgPSAoc3RhdGUuZXZlbnQgPT0gUE1fRVZFTlRfT04pID8KLQkJCQlBQ1BJX1NUQVRFX0QwIDogQUNQSV9TVEFURV9EMzsKIAotCS8qIGFjcGlfYnVzX3NldF9wb3dlcigpIG9mdGVuIGZhaWxzIChrZXlib2FyZCBwb3J0IGNhbid0IGJlCi0JICogcG93ZXJlZC1kb3duPyksIGFuZCBpbiBhbnkgY2FzZSwgb3VyIHJldHVybiB2YWx1ZSBpcyBpZ25vcmVkCi0JICogYnkgcG5wX2J1c19zdXNwZW5kKCkuICBIZW5jZSB3ZSBkb24ndCByZXZlcnQgdGhlIHdha2V1cAotCSAqIHNldHRpbmcgaWYgdGhlIHNldF9wb3dlciBmYWlscy4KLQkgKi8KLQlyZXR1cm4gYWNwaV9idXNfc2V0X3Bvd2VyKGhhbmRsZSwgcG93ZXJfc3RhdGUpOworCWlmIChhY3BpX2J1c19wb3dlcl9tYW5hZ2VhYmxlKGhhbmRsZSkpIHsKKwkJaW50IHBvd2VyX3N0YXRlID0gYWNwaV9wbV9kZXZpY2Vfc2xlZXBfc3RhdGUoJmRldi0+ZGV2LCBOVUxMKTsKKworCQlpZiAocG93ZXJfc3RhdGUgPCAwKQorCQkJcG93ZXJfc3RhdGUgPSAoc3RhdGUuZXZlbnQgPT0gUE1fRVZFTlRfT04pID8KKwkJCQkJQUNQSV9TVEFURV9EMCA6IEFDUElfU1RBVEVfRDM7CisKKwkJLyoKKwkJICogYWNwaV9idXNfc2V0X3Bvd2VyKCkgb2Z0ZW4gZmFpbHMgKGtleWJvYXJkIHBvcnQgY2FuJ3QgYmUKKwkJICogcG93ZXJlZC1kb3duPyksIGFuZCBpbiBhbnkgY2FzZSwgb3VyIHJldHVybiB2YWx1ZSBpcyBpZ25vcmVkCisJCSAqIGJ5IHBucF9idXNfc3VzcGVuZCgpLiAgSGVuY2Ugd2UgZG9uJ3QgcmV2ZXJ0IHRoZSB3YWtldXAKKwkJICogc2V0dGluZyBpZiB0aGUgc2V0X3Bvd2VyIGZhaWxzLgorCQkgKi8KKwkJZXJyb3IgPSBhY3BpX2J1c19zZXRfcG93ZXIoaGFuZGxlLCBwb3dlcl9zdGF0ZSk7CisJfQorCisJcmV0dXJuIGVycm9yOwogfQogCiBzdGF0aWMgaW50IHBucGFjcGlfcmVzdW1lKHN0cnVjdCBwbnBfZGV2ICpkZXYpCiB7Ci0Jc3RydWN0IGFjcGlfZGV2aWNlICphY3BpX2RldiA9IGRldi0+ZGF0YTsKLQlhY3BpX2hhbmRsZSBoYW5kbGUgPSBhY3BpX2Rldi0+aGFuZGxlOworCXN0cnVjdCBhY3BpX2RldmljZSAqYWNwaV9kZXY7CisJYWNwaV9oYW5kbGUgaGFuZGxlID0gREVWSUNFX0FDUElfSEFORExFKCZkZXYtPmRldik7CisJaW50IGVycm9yID0gMDsKKworCWlmICghaGFuZGxlIHx8IEFDUElfRkFJTFVSRShhY3BpX2J1c19nZXRfZGV2aWNlKGhhbmRsZSwgJmFjcGlfZGV2KSkpIHsKKwkJZGV2X2RiZygmZGV2LT5kZXYsICJBQ1BJIGRldmljZSBub3QgZm91bmQgaW4gJXMhXG4iLCBfX2Z1bmNfXyk7CisJCXJldHVybiAtRU5PREVWOworCX0KIAogCWlmIChkZXZpY2VfbWF5X3dha2V1cCgmZGV2LT5kZXYpKQogCQlhY3BpX3BtX2RldmljZV9zbGVlcF93YWtlKCZkZXYtPmRldiwgZmFsc2UpOwotCXJldHVybiBhY3BpX2J1c19zZXRfcG93ZXIoaGFuZGxlLCBBQ1BJX1NUQVRFX0QwKTsKKworCWlmIChhY3BpX2J1c19wb3dlcl9tYW5hZ2VhYmxlKGhhbmRsZSkpCisJCWVycm9yID0gYWNwaV9idXNfc2V0X3Bvd2VyKGhhbmRsZSwgQUNQSV9TVEFURV9EMCk7CisKKwlyZXR1cm4gZXJyb3I7CiB9CiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9wbnAvcG5wYmlvcy9NYWtlZmlsZSBiL2RyaXZlcnMvcG5wL3BucGJpb3MvTWFrZWZpbGUKaW5kZXggM2NkM2VkNy4uMjQwYjBmZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9wbnAvcG5wYmlvcy9NYWtlZmlsZQorKysgYi9kcml2ZXJzL3BucC9wbnBiaW9zL01ha2VmaWxlCkBAIC0xLDcgKzEsOCBAQAogIwogIyBNYWtlZmlsZSBmb3IgdGhlIGtlcm5lbCBQTlBCSU9TIGRyaXZlci4KICMKK29iai15IDo9IHBucC5vCiAKLXBucGJpb3MtcHJvYy0kKENPTkZJR19QTlBCSU9TX1BST0NfRlMpID0gcHJvYy5vCitwbnAteSA6PSBjb3JlLm8gYmlvc2NhbGxzLm8gcnNwYXJzZXIubwogCi1vYmoteSA6PSBjb3JlLm8gYmlvc2NhbGxzLm8gcnNwYXJzZXIubyAkKHBucGJpb3MtcHJvYy15KQorcG5wLSQoQ09ORklHX1BOUEJJT1NfUFJPQ19GUykgKz0gcHJvYy5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Bvd2VyL0tjb25maWcgYi9kcml2ZXJzL3Bvd2VyL0tjb25maWcKaW5kZXggNjBkODNkOS4uNjFiZjVkNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9wb3dlci9LY29uZmlnCisrKyBiL2RyaXZlcnMvcG93ZXIvS2NvbmZpZwpAQCAtMTM2LDYgKzEzNiwxNiBAQAogCSAgaW4gaGFuZGhlbGQgYW5kIHBvcnRhYmxlIGVxdWlwbWVudC4gVGhlIE1BWDE3MDQwIGlzIGNvbmZpZ3VyZWQKIAkgIHRvIG9wZXJhdGUgd2l0aCBhIHNpbmdsZSBsaXRoaXVtIGNlbGwKIAorY29uZmlnIEJBVFRFUllfTUFYMTcwNDIKKwl0cmlzdGF0ZSAiTWF4aW0gTUFYMTcwNDIvODk5Ny84OTY2IEZ1ZWwgR2F1Z2UiCisJZGVwZW5kcyBvbiBJMkMKKwloZWxwCisJICBNQVgxNzA0MiBpcyBmdWVsLWdhdWdlIHN5c3RlbXMgZm9yIGxpdGhpdW0taW9uIChMaSspIGJhdHRlcmllcworCSAgaW4gaGFuZGhlbGQgYW5kIHBvcnRhYmxlIGVxdWlwbWVudC4gVGhlIE1BWDE3MDQyIGlzIGNvbmZpZ3VyZWQKKwkgIHRvIG9wZXJhdGUgd2l0aCBhIHNpbmdsZSBsaXRoaXVtIGNlbGwuIE1BWDg5OTcgYW5kIE1BWDg5NjYgYXJlCisJICBtdWx0aS1mdW5jdGlvbiBkZXZpY2VzIHRoYXQgaW5jbHVkZSBmdWVsIGdhdWFnZXMgdGhhdCBhcmUgY29tcGF0aWJsZQorCSAgd2l0aCBNQVgxNzA0Mi4KKwogY29uZmlnIEJBVFRFUllfWjIKIAl0cmlzdGF0ZSAiWjIgYmF0dGVyeSBkcml2ZXIiCiAJZGVwZW5kcyBvbiBJMkMgJiYgTUFDSF9aSVBJVDIKQEAgLTE4NSw0ICsxOTUsMTQgQEAKIAloZWxwCiAJICBTYXkgWSBoZXJlIHRvIGVuYWJsZSBzdXBwb3J0IGZvciBUV0w0MDMwIEJhdHRlcnkgQ2hhcmdlIEludGVyZmFjZS4KIAorY29uZmlnIENIQVJHRVJfR1BJTworCXRyaXN0YXRlICJHUElPIGNoYXJnZXIiCisJZGVwZW5kcyBvbiBHUElPTElCCisJaGVscAorCSAgU2F5IFkgdG8gaW5jbHVkZSBzdXBwb3J0IGZvciBjaGFyZ2VycyB3aGljaCByZXBvcnQgdGhlaXIgb25saW5lIHN0YXR1cworCSAgdGhyb3VnaCBhIEdQSU8gcGluLgorCisJICBUaGlzIGRyaXZlciBjYW4gYmUgYnVpbGQgYXMgYSBtb2R1bGUuIElmIHNvLCB0aGUgbW9kdWxlIHdpbGwgYmUKKwkgIGNhbGxlZCBncGlvLWNoYXJnZXIuCisKIGVuZGlmICMgUE9XRVJfU1VQUExZCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Bvd2VyL01ha2VmaWxlIGIvZHJpdmVycy9wb3dlci9NYWtlZmlsZQppbmRleCBjNzU3NzJlLi44Mzg1YmZhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Bvd2VyL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvcG93ZXIvTWFrZWZpbGUKQEAgLTI1LDYgKzI1LDcgQEAKIG9iai0kKENPTkZJR19CQVRURVJZX0JRMjd4MDApCSs9IGJxMjd4MDBfYmF0dGVyeS5vCiBvYmotJChDT05GSUdfQkFUVEVSWV9EQTkwMzApCSs9IGRhOTAzMF9iYXR0ZXJ5Lm8KIG9iai0kKENPTkZJR19CQVRURVJZX01BWDE3MDQwKQkrPSBtYXgxNzA0MF9iYXR0ZXJ5Lm8KK29iai0kKENPTkZJR19CQVRURVJZX01BWDE3MDQyKQkrPSBtYXgxNzA0Ml9iYXR0ZXJ5Lm8KIG9iai0kKENPTkZJR19CQVRURVJZX1oyKQkrPSB6Ml9iYXR0ZXJ5Lm8KIG9iai0kKENPTkZJR19CQVRURVJZX1MzQ19BREMpCSs9IHMzY19hZGNfYmF0dGVyeS5vCiBvYmotJChDT05GSUdfQ0hBUkdFUl9QQ0Y1MDYzMykJKz0gcGNmNTA2MzMtY2hhcmdlci5vCkBAIC0zMiwzICszMyw0IEBACiBvYmotJChDT05GSUdfQkFUVEVSWV9JTlRFTF9NSUQpCSs9IGludGVsX21pZF9iYXR0ZXJ5Lm8KIG9iai0kKENPTkZJR19DSEFSR0VSX0lTUDE3MDQpCSs9IGlzcDE3MDRfY2hhcmdlci5vCiBvYmotJChDT05GSUdfQ0hBUkdFUl9UV0w0MDMwKQkrPSB0d2w0MDMwX2NoYXJnZXIubworb2JqLSQoQ09ORklHX0NIQVJHRVJfR1BJTykJKz0gZ3Bpby1jaGFyZ2VyLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcG93ZXIvY29sbGllX2JhdHRlcnkuYyBiL2RyaXZlcnMvcG93ZXIvY29sbGllX2JhdHRlcnkuYwppbmRleCAwMzlmNDFhLi41NDhkMjYzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Bvd2VyL2NvbGxpZV9iYXR0ZXJ5LmMKKysrIGIvZHJpdmVycy9wb3dlci9jb2xsaWVfYmF0dGVyeS5jCkBAIC0yOTUsNyArMjk1LDcgQEAKIHN0YXRpYyBpbnQgY29sbGllX2JhdF9zdXNwZW5kKHN0cnVjdCB1Y2IxeDAwX2RldiAqZGV2LCBwbV9tZXNzYWdlX3Qgc3RhdGUpCiB7CiAJLyogZmx1c2ggYWxsIHBlbmRpbmcgc3RhdHVzIHVwZGF0ZXMgKi8KLQlmbHVzaF9zY2hlZHVsZWRfd29yaygpOworCWZsdXNoX3dvcmtfc3luYygmYmF0X3dvcmspOwogCXJldHVybiAwOwogfQogCkBAIC0zNjIsNyArMzYyLDcgQEAKIGVycl9wc3lfcmVnX21haW46CiAKIAkvKiBzZWUgY29tbWVudCBpbiBjb2xsaWVfYmF0X3JlbW92ZSAqLwotCWZsdXNoX3NjaGVkdWxlZF93b3JrKCk7CisJY2FuY2VsX3dvcmtfc3luYygmYmF0X3dvcmspOwogCiAJaS0tOwogZXJyX2dwaW86CkBAIC0zODIsMTIgKzM4MiwxMSBAQAogCXBvd2VyX3N1cHBseV91bnJlZ2lzdGVyKCZjb2xsaWVfYmF0X21haW4ucHN5KTsKIAogCS8qCi0JICogbm93IGZsdXNoIGFsbCBwZW5kaW5nIHdvcmsuCi0JICogd2Ugd29uJ3QgZ2V0IGFueSBtb3JlIHNjaGVkdWxlcywgc2luY2UgYWxsCi0JICogc291cmNlcyAoaXNyIGFuZCBleHRlcm5hbF9wb3dlcl9jaGFuZ2VkKQotCSAqIGFyZSB1bnJlZ2lzdGVyZWQgbm93LgorCSAqIE5vdyBjYW5jZWwgdGhlIGJhdF93b3JrLiAgV2Ugd29uJ3QgZ2V0IGFueSBtb3JlIHNjaGVkdWxlcywKKwkgKiBzaW5jZSBhbGwgc291cmNlcyAoaXNyIGFuZCBleHRlcm5hbF9wb3dlcl9jaGFuZ2VkKSBhcmUKKwkgKiB1bnJlZ2lzdGVyZWQgbm93LgogCSAqLwotCWZsdXNoX3NjaGVkdWxlZF93b3JrKCk7CisJY2FuY2VsX3dvcmtfc3luYygmYmF0X3dvcmspOwogCiAJZm9yIChpID0gQVJSQVlfU0laRShncGlvcykgLSAxOyBpID49IDA7IGktLSkKIAkJZ3Bpb19mcmVlKGdwaW9zW2ldLmdwaW8pOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wb3dlci9kczI3NjBfYmF0dGVyeS5jIGIvZHJpdmVycy9wb3dlci9kczI3NjBfYmF0dGVyeS5jCmluZGV4IGU3Zjg5NzguLmU1MzQyOTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcG93ZXIvZHMyNzYwX2JhdHRlcnkuYworKysgYi9kcml2ZXJzL3Bvd2VyL2RzMjc2MF9iYXR0ZXJ5LmMKQEAgLTIxMiw3ICsyMTIsNyBAQAogCWlmIChkaS0+cmVtX2NhcGFjaXR5ID4gMTAwKQogCQlkaS0+cmVtX2NhcGFjaXR5ID0gMTAwOwogCi0JaWYgKGRpLT5jdXJyZW50X3VBID49IDEwMEwpCisJaWYgKGRpLT5jdXJyZW50X3VBIDwgLTEwMEwpCiAJCWRpLT5saWZlX3NlYyA9IC0oKGRpLT5hY2N1bV9jdXJyZW50X3VBaCAtIGRpLT5lbXB0eV91QWgpICogMzZMKQogCQkJCQkvIChkaS0+Y3VycmVudF91QSAvIDEwMEwpOwogCWVsc2UKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcG93ZXIvZ3Bpby1jaGFyZ2VyLmMgYi9kcml2ZXJzL3Bvd2VyL2dwaW8tY2hhcmdlci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjI1Yjg4YWMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Bvd2VyL2dwaW8tY2hhcmdlci5jCkBAIC0wLDAgKzEsMTg4IEBACisvKgorICogIENvcHlyaWdodCAoQykgMjAxMCwgTGFycy1QZXRlciBDbGF1c2VuIDxsYXJzQG1ldGFmb28uZGU+CisgKiAgRHJpdmVyIGZvciBjaGFyZ2VycyB3aGljaCByZXBvcnQgdGhlaXIgb25saW5lIHN0YXR1cyB0aHJvdWdoIGEgR1BJTyBwaW4KKyAqCisgKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqICB1bmRlciAgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCAgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZQorICogIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgIGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyCisgKiAgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYWxvbmcKKyAqICB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAorICogIDY3NSBNYXNzIEF2ZSwgQ2FtYnJpZGdlLCBNQSAwMjEzOSwgVVNBLgorICoKKyAqLworCisjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvZ3Bpby5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9wb3dlcl9zdXBwbHkuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisKKyNpbmNsdWRlIDxsaW51eC9wb3dlci9ncGlvLWNoYXJnZXIuaD4KKworc3RydWN0IGdwaW9fY2hhcmdlciB7CisJY29uc3Qgc3RydWN0IGdwaW9fY2hhcmdlcl9wbGF0Zm9ybV9kYXRhICpwZGF0YTsKKwl1bnNpZ25lZCBpbnQgaXJxOworCisJc3RydWN0IHBvd2VyX3N1cHBseSBjaGFyZ2VyOworfTsKKworc3RhdGljIGlycXJldHVybl90IGdwaW9fY2hhcmdlcl9pcnEoaW50IGlycSwgdm9pZCAqZGV2aWQpCit7CisJc3RydWN0IHBvd2VyX3N1cHBseSAqY2hhcmdlciA9IGRldmlkOworCisJcG93ZXJfc3VwcGx5X2NoYW5nZWQoY2hhcmdlcik7CisKKwlyZXR1cm4gSVJRX0hBTkRMRUQ7Cit9CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IGdwaW9fY2hhcmdlciAqcHN5X3RvX2dwaW9fY2hhcmdlcihzdHJ1Y3QgcG93ZXJfc3VwcGx5ICpwc3kpCit7CisJcmV0dXJuIGNvbnRhaW5lcl9vZihwc3ksIHN0cnVjdCBncGlvX2NoYXJnZXIsIGNoYXJnZXIpOworfQorCitzdGF0aWMgaW50IGdwaW9fY2hhcmdlcl9nZXRfcHJvcGVydHkoc3RydWN0IHBvd2VyX3N1cHBseSAqcHN5LAorCQllbnVtIHBvd2VyX3N1cHBseV9wcm9wZXJ0eSBwc3AsIHVuaW9uIHBvd2VyX3N1cHBseV9wcm9wdmFsICp2YWwpCit7CisJc3RydWN0IGdwaW9fY2hhcmdlciAqZ3Bpb19jaGFyZ2VyID0gcHN5X3RvX2dwaW9fY2hhcmdlcihwc3kpOworCWNvbnN0IHN0cnVjdCBncGlvX2NoYXJnZXJfcGxhdGZvcm1fZGF0YSAqcGRhdGEgPSBncGlvX2NoYXJnZXItPnBkYXRhOworCisJc3dpdGNoIChwc3ApIHsKKwljYXNlIFBPV0VSX1NVUFBMWV9QUk9QX09OTElORToKKwkJdmFsLT5pbnR2YWwgPSBncGlvX2dldF92YWx1ZShwZGF0YS0+Z3Bpbyk7CisJCXZhbC0+aW50dmFsIF49IHBkYXRhLT5ncGlvX2FjdGl2ZV9sb3c7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgZW51bSBwb3dlcl9zdXBwbHlfcHJvcGVydHkgZ3Bpb19jaGFyZ2VyX3Byb3BlcnRpZXNbXSA9IHsKKwlQT1dFUl9TVVBQTFlfUFJPUF9PTkxJTkUsCit9OworCitzdGF0aWMgaW50IF9fZGV2aW5pdCBncGlvX2NoYXJnZXJfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwljb25zdCBzdHJ1Y3QgZ3Bpb19jaGFyZ2VyX3BsYXRmb3JtX2RhdGEgKnBkYXRhID0gcGRldi0+ZGV2LnBsYXRmb3JtX2RhdGE7CisJc3RydWN0IGdwaW9fY2hhcmdlciAqZ3Bpb19jaGFyZ2VyOworCXN0cnVjdCBwb3dlcl9zdXBwbHkgKmNoYXJnZXI7CisJaW50IHJldDsKKwlpbnQgaXJxOworCisJaWYgKCFwZGF0YSkgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJObyBwbGF0Zm9ybSBkYXRhXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJaWYgKCFncGlvX2lzX3ZhbGlkKHBkYXRhLT5ncGlvKSkgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJJbnZhbGlkIGdwaW8gcGluXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJZ3Bpb19jaGFyZ2VyID0ga3phbGxvYyhzaXplb2YoKmdwaW9fY2hhcmdlciksIEdGUF9LRVJORUwpOworCWlmICghZ3Bpb19jaGFyZ2VyKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgIkZhaWxlZCB0byBhbGxvYyBkcml2ZXIgc3RydWN0dXJlXG4iKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJY2hhcmdlciA9ICZncGlvX2NoYXJnZXItPmNoYXJnZXI7CisKKwljaGFyZ2VyLT5uYW1lID0gcGRhdGEtPm5hbWUgPyBwZGF0YS0+bmFtZSA6ICJncGlvLWNoYXJnZXIiOworCWNoYXJnZXItPnR5cGUgPSBwZGF0YS0+dHlwZTsKKwljaGFyZ2VyLT5wcm9wZXJ0aWVzID0gZ3Bpb19jaGFyZ2VyX3Byb3BlcnRpZXM7CisJY2hhcmdlci0+bnVtX3Byb3BlcnRpZXMgPSBBUlJBWV9TSVpFKGdwaW9fY2hhcmdlcl9wcm9wZXJ0aWVzKTsKKwljaGFyZ2VyLT5nZXRfcHJvcGVydHkgPSBncGlvX2NoYXJnZXJfZ2V0X3Byb3BlcnR5OworCWNoYXJnZXItPnN1cHBsaWVkX3RvID0gcGRhdGEtPnN1cHBsaWVkX3RvOworCWNoYXJnZXItPm51bV9zdXBwbGljYW50cyA9IHBkYXRhLT5udW1fc3VwcGxpY2FudHM7CisKKwlyZXQgPSBncGlvX3JlcXVlc3QocGRhdGEtPmdwaW8sIGRldl9uYW1lKCZwZGV2LT5kZXYpKTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgIkZhaWxlZCB0byByZXF1ZXN0IGdwaW8gcGluOiAlZFxuIiwgcmV0KTsKKwkJZ290byBlcnJfZnJlZTsKKwl9CisJcmV0ID0gZ3Bpb19kaXJlY3Rpb25faW5wdXQocGRhdGEtPmdwaW8pOworCWlmIChyZXQpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiRmFpbGVkIHRvIHNldCBncGlvIHRvIGlucHV0OiAlZFxuIiwgcmV0KTsKKwkJZ290byBlcnJfZ3Bpb19mcmVlOworCX0KKworCWdwaW9fY2hhcmdlci0+cGRhdGEgPSBwZGF0YTsKKworCXJldCA9IHBvd2VyX3N1cHBseV9yZWdpc3RlcigmcGRldi0+ZGV2LCBjaGFyZ2VyKTsKKwlpZiAocmV0IDwgMCkgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJGYWlsZWQgdG8gcmVnaXN0ZXIgcG93ZXIgc3VwcGx5OiAlZFxuIiwKKwkJCXJldCk7CisJCWdvdG8gZXJyX2dwaW9fZnJlZTsKKwl9CisKKwlpcnEgPSBncGlvX3RvX2lycShwZGF0YS0+Z3Bpbyk7CisJaWYgKGlycSA+IDApIHsKKwkJcmV0ID0gcmVxdWVzdF9hbnlfY29udGV4dF9pcnEoaXJxLCBncGlvX2NoYXJnZXJfaXJxLAorCQkJCUlSUUZfVFJJR0dFUl9SSVNJTkcgfCBJUlFGX1RSSUdHRVJfRkFMTElORywKKwkJCQlkZXZfbmFtZSgmcGRldi0+ZGV2KSwgY2hhcmdlcik7CisJCWlmIChyZXQpCisJCQlkZXZfd2FybigmcGRldi0+ZGV2LCAiRmFpbGVkIHRvIHJlcXVlc3QgaXJxOiAlZFxuIiwgcmV0KTsKKwkJZWxzZQorCQkJZ3Bpb19jaGFyZ2VyLT5pcnEgPSBpcnE7CisJfQorCisJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgZ3Bpb19jaGFyZ2VyKTsKKworCXJldHVybiAwOworCitlcnJfZ3Bpb19mcmVlOgorCWdwaW9fZnJlZShwZGF0YS0+Z3Bpbyk7CitlcnJfZnJlZToKKwlrZnJlZShncGlvX2NoYXJnZXIpOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgX19kZXZleGl0IGdwaW9fY2hhcmdlcl9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlzdHJ1Y3QgZ3Bpb19jaGFyZ2VyICpncGlvX2NoYXJnZXIgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKKworCWlmIChncGlvX2NoYXJnZXItPmlycSkKKwkJZnJlZV9pcnEoZ3Bpb19jaGFyZ2VyLT5pcnEsICZncGlvX2NoYXJnZXItPmNoYXJnZXIpOworCisJcG93ZXJfc3VwcGx5X3VucmVnaXN0ZXIoJmdwaW9fY2hhcmdlci0+Y2hhcmdlcik7CisKKwlncGlvX2ZyZWUoZ3Bpb19jaGFyZ2VyLT5wZGF0YS0+Z3Bpbyk7CisKKwlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBOVUxMKTsKKwlrZnJlZShncGlvX2NoYXJnZXIpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGdwaW9fY2hhcmdlcl9kcml2ZXIgPSB7CisJLnByb2JlID0gZ3Bpb19jaGFyZ2VyX3Byb2JlLAorCS5yZW1vdmUgPSBfX2RldmV4aXRfcChncGlvX2NoYXJnZXJfcmVtb3ZlKSwKKwkuZHJpdmVyID0geworCQkubmFtZSA9ICJncGlvLWNoYXJnZXIiLAorCQkub3duZXIgPSBUSElTX01PRFVMRSwKKwl9LAorfTsKKworc3RhdGljIGludCBfX2luaXQgZ3Bpb19jaGFyZ2VyX2luaXQodm9pZCkKK3sKKwlyZXR1cm4gcGxhdGZvcm1fZHJpdmVyX3JlZ2lzdGVyKCZncGlvX2NoYXJnZXJfZHJpdmVyKTsKK30KK21vZHVsZV9pbml0KGdwaW9fY2hhcmdlcl9pbml0KTsKKworc3RhdGljIHZvaWQgX19leGl0IGdwaW9fY2hhcmdlcl9leGl0KHZvaWQpCit7CisJcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIoJmdwaW9fY2hhcmdlcl9kcml2ZXIpOworfQorbW9kdWxlX2V4aXQoZ3Bpb19jaGFyZ2VyX2V4aXQpOworCitNT0RVTEVfQVVUSE9SKCJMYXJzLVBldGVyIENsYXVzZW4gPGxhcnNAbWV0YWZvby5kZT4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiRHJpdmVyIGZvciBjaGFyZ2VycyB3aGljaCByZXBvcnQgdGhlaXIgb25saW5lIHN0YXR1cyB0aHJvdWdoIGEgR1BJTyIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FMSUFTKCJwbGF0Zm9ybTpncGlvLWNoYXJnZXIiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcG93ZXIvaW50ZWxfbWlkX2JhdHRlcnkuYyBiL2RyaXZlcnMvcG93ZXIvaW50ZWxfbWlkX2JhdHRlcnkuYwppbmRleCAzNmNmNDAyLi5iY2UzYTAxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Bvd2VyL2ludGVsX21pZF9iYXR0ZXJ5LmMKKysrIGIvZHJpdmVycy9wb3dlci9pbnRlbF9taWRfYmF0dGVyeS5jCkBAIC03NjUsNyArNzY1LDcgQEAKIAlwb3dlcl9zdXBwbHlfdW5yZWdpc3RlcigmcGJpLT51c2IpOwogCXBvd2VyX3N1cHBseV91bnJlZ2lzdGVyKCZwYmktPmJhdHQpOwogCi0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKKwljYW5jZWxfd29ya19zeW5jKCZwYmktPmhhbmRsZXIpOwogCWtmcmVlKHBiaSk7CiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Bvd2VyL2lzcDE3MDRfY2hhcmdlci5jIGIvZHJpdmVycy9wb3dlci9pc3AxNzA0X2NoYXJnZXIuYwppbmRleCA3MjUxMjE4Li4yYWQ5YjE0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Bvd2VyL2lzcDE3MDRfY2hhcmdlci5jCisrKyBiL2RyaXZlcnMvcG93ZXIvaXNwMTcwNF9jaGFyZ2VyLmMKQEAgLTU5LDExICs1OSw2MSBAQAogCXN0cnVjdCBub3RpZmllcl9ibG9jawluYjsKIAlzdHJ1Y3Qgd29ya19zdHJ1Y3QJd29yazsKIAotCWNoYXIJCQltb2RlbFs3XTsKKwkvKiBwcm9wZXJ0aWVzICovCisJY2hhcgkJCW1vZGVsWzhdOwogCXVuc2lnbmVkCQlwcmVzZW50OjE7CisJdW5zaWduZWQJCW9ubGluZToxOworCXVuc2lnbmVkCQljdXJyZW50X21heDsKKworCS8qIHRlbXAgc3RvcmFnZSB2YXJpYWJsZXMgKi8KKwl1bnNpZ25lZCBsb25nCQlldmVudDsKKwl1bnNpZ25lZAkJbWF4X3Bvd2VyOwogfTsKIAogLyoKKyAqIERldGVybWluZSBpcyB0aGUgY2hhcmdpbmcgcG9ydCBEQ1AgKGRlZGljYXRlZCBjaGFyZ2VyKSBvciBDRFAgKEhvc3QvSFVCCisgKiBjaGFyZ2VycykuCisgKgorICogUkVWSVNJVDogVGhlIG1ldGhvZCBpcyBkZWZpbmVkIGluIEJhdHRlcnkgQ2hhcmdpbmcgU3BlY2lmaWNhdGlvbiBhbmQgaXMKKyAqIGFwcGxpY2FibGUgdG8gYW55IFVMUEkgdHJhbnNjZWl2ZXIuIE5vdGhpbmcgaXNwMTcweCBzcGVjaWZpYyBoZXJlLgorICovCitzdGF0aWMgaW5saW5lIGludCBpc3AxNzA0X2NoYXJnZXJfdHlwZShzdHJ1Y3QgaXNwMTcwNF9jaGFyZ2VyICppc3ApCit7CisJdTggcmVnOworCXU4IGZ1bmNfY3RybDsKKwl1OCBvdGdfY3RybDsKKwlpbnQgdHlwZSA9IFBPV0VSX1NVUFBMWV9UWVBFX1VTQl9EQ1A7CisKKwlmdW5jX2N0cmwgPSBvdGdfaW9fcmVhZChpc3AtPm90ZywgVUxQSV9GVU5DX0NUUkwpOworCW90Z19jdHJsID0gb3RnX2lvX3JlYWQoaXNwLT5vdGcsIFVMUElfT1RHX0NUUkwpOworCisJLyogZGlzYWJsZSBwdWxsZG93bnMgKi8KKwlyZWcgPSBVTFBJX09UR19DVFJMX0RNX1BVTExET1dOIHwgVUxQSV9PVEdfQ1RSTF9EUF9QVUxMRE9XTjsKKwlvdGdfaW9fd3JpdGUoaXNwLT5vdGcsIFVMUElfQ0xSKFVMUElfT1RHX0NUUkwpLCByZWcpOworCisJLyogZnVsbCBzcGVlZCAqLworCW90Z19pb193cml0ZShpc3AtPm90ZywgVUxQSV9DTFIoVUxQSV9GVU5DX0NUUkwpLAorCQkJVUxQSV9GVU5DX0NUUkxfWENWUlNFTF9NQVNLKTsKKwlvdGdfaW9fd3JpdGUoaXNwLT5vdGcsIFVMUElfU0VUKFVMUElfRlVOQ19DVFJMKSwKKwkJCVVMUElfRlVOQ19DVFJMX0ZVTExfU1BFRUQpOworCisJLyogRW5hYmxlIHN0cm9uZyBwdWxsLXVwIG9uIERQICgxLjVLKSBhbmQgcmVzZXQgKi8KKwlyZWcgPSBVTFBJX0ZVTkNfQ1RSTF9URVJNU0VMRUNUIHwgVUxQSV9GVU5DX0NUUkxfUkVTRVQ7CisJb3RnX2lvX3dyaXRlKGlzcC0+b3RnLCBVTFBJX1NFVChVTFBJX0ZVTkNfQ1RSTCksIHJlZyk7CisJdXNsZWVwX3JhbmdlKDEwMDAsIDIwMDApOworCisJcmVnID0gb3RnX2lvX3JlYWQoaXNwLT5vdGcsIFVMUElfREVCVUcpOworCWlmICgocmVnICYgMykgIT0gMykKKwkJdHlwZSA9IFBPV0VSX1NVUFBMWV9UWVBFX1VTQl9DRFA7CisKKwkvKiByZWNvdmVyIG9yaWdpbmFsIHN0YXRlICovCisJb3RnX2lvX3dyaXRlKGlzcC0+b3RnLCBVTFBJX0ZVTkNfQ1RSTCwgZnVuY19jdHJsKTsKKwlvdGdfaW9fd3JpdGUoaXNwLT5vdGcsIFVMUElfT1RHX0NUUkwsIG90Z19jdHJsKTsKKworCXJldHVybiB0eXBlOworfQorCisvKgogICogSVNQMTcwNCBkZXRlY3RzIFBTLzIgYWRhcHRlcnMgYXMgY2hhcmdlci4gVG8gbWFrZSBzdXJlIHRoZSBkZXRlY3RlZCBjaGFyZ2VyCiAgKiBpcyBhY3R1YWxseSBhIGRlZGljYXRlZCBjaGFyZ2VyLCB0aGUgZm9sbG93aW5nIHN0ZXBzIG5lZWQgdG8gYmUgdGFrZW4uCiAgKi8KQEAgLTEyNywxNiArMTc3LDE5IEBACiBzdGF0aWMgaW5saW5lIGludCBpc3AxNzA0X2NoYXJnZXJfZGV0ZWN0KHN0cnVjdCBpc3AxNzA0X2NoYXJnZXIgKmlzcCkKIHsKIAl1bnNpZ25lZCBsb25nCXRpbWVvdXQ7Ci0JdTgJCXI7CisJdTgJCXB3cl9jdHJsOwogCWludAkJcmV0ID0gMDsKIAorCXB3cl9jdHJsID0gb3RnX2lvX3JlYWQoaXNwLT5vdGcsIElTUDE3MDRfUFdSX0NUUkwpOworCiAJLyogc2V0IFNXIGNvbnRyb2wgYml0IGluIFBXUl9DVFJMIHJlZ2lzdGVyICovCiAJb3RnX2lvX3dyaXRlKGlzcC0+b3RnLCBJU1AxNzA0X1BXUl9DVFJMLAogCQkJSVNQMTcwNF9QV1JfQ1RSTF9TV0NUUkwpOwogCiAJLyogZW5hYmxlIG1hbnVhbCBjaGFyZ2VyIGRldGVjdGlvbiAqLwotCXIgPSAoSVNQMTcwNF9QV1JfQ1RSTF9TV0NUUkwgfCBJU1AxNzA0X1BXUl9DVFJMX0RQVlNSQ19FTik7Ci0Jb3RnX2lvX3dyaXRlKGlzcC0+b3RnLCBVTFBJX1NFVChJU1AxNzA0X1BXUl9DVFJMKSwgcik7CisJb3RnX2lvX3dyaXRlKGlzcC0+b3RnLCBVTFBJX1NFVChJU1AxNzA0X1BXUl9DVFJMKSwKKwkJCUlTUDE3MDRfUFdSX0NUUkxfU1dDVFJMCisJCQl8IElTUDE3MDRfUFdSX0NUUkxfRFBWU1JDX0VOKTsKIAl1c2xlZXBfcmFuZ2UoMTAwMCwgMjAwMCk7CiAKIAl0aW1lb3V0ID0gamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoMzAwKTsKQEAgLTE0Nyw3ICsyMDAsMTAgQEAKIAkJCXJldCA9IGlzcDE3MDRfY2hhcmdlcl92ZXJpZnkoaXNwKTsKIAkJCWJyZWFrOwogCQl9Ci0JfSB3aGlsZSAoIXRpbWVfYWZ0ZXIoamlmZmllcywgdGltZW91dCkpOworCX0gd2hpbGUgKCF0aW1lX2FmdGVyKGppZmZpZXMsIHRpbWVvdXQpICYmIGlzcC0+b25saW5lKTsKKworCS8qIHJlY292ZXIgb3JpZ2luYWwgc3RhdGUgKi8KKwlvdGdfaW9fd3JpdGUoaXNwLT5vdGcsIElTUDE3MDRfUFdSX0NUUkwsIHB3cl9jdHJsKTsKIAogCXJldHVybiByZXQ7CiB9CkBAIC0xNTUsNTIgKzIxMSw5MiBAQAogc3RhdGljIHZvaWQgaXNwMTcwNF9jaGFyZ2VyX3dvcmsoc3RydWN0IHdvcmtfc3RydWN0ICpkYXRhKQogewogCWludAkJCWRldGVjdDsKKwl1bnNpZ25lZCBsb25nCQlldmVudDsKKwl1bnNpZ25lZAkJcG93ZXI7CiAJc3RydWN0IGlzcDE3MDRfY2hhcmdlcgkqaXNwID0KIAkJY29udGFpbmVyX29mKGRhdGEsIHN0cnVjdCBpc3AxNzA0X2NoYXJnZXIsIHdvcmspOworCXN0YXRpYyBERUZJTkVfTVVURVgobG9jayk7CiAKLQkvKgotCSAqIEZJWE1FIE9ubHkgc3VwcG9ydGluZyBkZWRpY2F0ZWQgY2hhcmdlcnMgZXZlbiB0aG91Z2ggaXNwMTcwNCBjYW4KLQkgKiBkZXRlY3QgSFVCIGFuZCBIT1NUIGNoYXJnZXJzLiBJZiB0aGUgZGV2aWNlIGhhcyBhbHJlYWR5IGJlZW4KLQkgKiBlbnVtZXJhdGVkLCB0aGUgZGV0ZWN0aW9uIHdpbGwgYnJlYWsgdGhlIGNvbm5lY3Rpb24uCi0JICovCi0JaWYgKGlzcC0+b3RnLT5zdGF0ZSAhPSBPVEdfU1RBVEVfQl9JRExFKQotCQlyZXR1cm47CisJZXZlbnQgPSBpc3AtPmV2ZW50OworCXBvd2VyID0gaXNwLT5tYXhfcG93ZXI7CiAKLQkvKiBkaXNhYmxlIGRhdGEgcHVsbHVwcyAqLwotCWlmIChpc3AtPm90Zy0+Z2FkZ2V0KQotCQl1c2JfZ2FkZ2V0X2Rpc2Nvbm5lY3QoaXNwLT5vdGctPmdhZGdldCk7CisJbXV0ZXhfbG9jaygmbG9jayk7CiAKLQkvKiBkZXRlY3QgY2hhcmdlciAqLwotCWRldGVjdCA9IGlzcDE3MDRfY2hhcmdlcl9kZXRlY3QoaXNwKTsKLQlpZiAoZGV0ZWN0KSB7Ci0JCWlzcC0+cHJlc2VudCA9IGRldGVjdDsKLQkJcG93ZXJfc3VwcGx5X2NoYW5nZWQoJmlzcC0+cHN5KTsKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBVU0JfRVZFTlRfVkJVUzoKKwkJaXNwLT5vbmxpbmUgPSB0cnVlOworCisJCS8qIGRldGVjdCBjaGFyZ2VyICovCisJCWRldGVjdCA9IGlzcDE3MDRfY2hhcmdlcl9kZXRlY3QoaXNwKTsKKworCQlpZiAoZGV0ZWN0KSB7CisJCQlpc3AtPnByZXNlbnQgPSBkZXRlY3Q7CisJCQlpc3AtPnBzeS50eXBlID0gaXNwMTcwNF9jaGFyZ2VyX3R5cGUoaXNwKTsKKwkJfQorCisJCXN3aXRjaCAoaXNwLT5wc3kudHlwZSkgeworCQljYXNlIFBPV0VSX1NVUFBMWV9UWVBFX1VTQl9EQ1A6CisJCQlpc3AtPmN1cnJlbnRfbWF4ID0gMTgwMDsKKwkJCWJyZWFrOworCQljYXNlIFBPV0VSX1NVUFBMWV9UWVBFX1VTQl9DRFA6CisJCQkvKgorCQkJICogT25seSA1MDBtQSBoZXJlIG9yIGhpZ2ggc3BlZWQgY2hpcnAKKwkJCSAqIGhhbmRzaGFraW5nIG1heSBicmVhaworCQkJICovCisJCQlpc3AtPmN1cnJlbnRfbWF4ID0gNTAwOworCQkJLyogRkFMTFRIUk9VR0ggKi8KKwkJY2FzZSBQT1dFUl9TVVBQTFlfVFlQRV9VU0I6CisJCWRlZmF1bHQ6CisJCQkvKiBlbmFibGUgZGF0YSBwdWxsdXBzICovCisJCQlpZiAoaXNwLT5vdGctPmdhZGdldCkKKwkJCQl1c2JfZ2FkZ2V0X2Nvbm5lY3QoaXNwLT5vdGctPmdhZGdldCk7CisJCX0KKwkJYnJlYWs7CisJY2FzZSBVU0JfRVZFTlRfTk9ORToKKwkJaXNwLT5vbmxpbmUgPSBmYWxzZTsKKwkJaXNwLT5jdXJyZW50X21heCA9IDA7CisJCWlzcC0+cHJlc2VudCA9IDA7CisJCWlzcC0+Y3VycmVudF9tYXggPSAwOworCQlpc3AtPnBzeS50eXBlID0gUE9XRVJfU1VQUExZX1RZUEVfVVNCOworCisJCS8qCisJCSAqIERpc2FibGUgZGF0YSBwdWxsdXBzLiBXZSBuZWVkIHRvIHByZXZlbnQgdGhlIGNvbnRyb2xsZXIgZnJvbQorCQkgKiBlbnVtZXJhdGluZy4KKwkJICoKKwkJICogRklYTUU6IFRoaXMgaXMgaGVyZSB0byBhbGxvdyBjaGFyZ2VyIGRldGVjdGlvbiB3aXRoIEhvc3QvSFVCCisJCSAqIGNoYXJnZXJzLiBUaGUgcHVsbHVwcyBtYXkgYmUgZW5hYmxlZCBlbHNld2hlcmUsIHNvIHRoaXMgY2FuCisJCSAqIG5vdCBiZSB0aGUgZmluYWwgc29sdXRpb24uCisJCSAqLworCQlpZiAoaXNwLT5vdGctPmdhZGdldCkKKwkJCXVzYl9nYWRnZXRfZGlzY29ubmVjdChpc3AtPm90Zy0+Z2FkZ2V0KTsKKwkJYnJlYWs7CisJY2FzZSBVU0JfRVZFTlRfRU5VTUVSQVRFRDoKKwkJaWYgKGlzcC0+cHJlc2VudCkKKwkJCWlzcC0+Y3VycmVudF9tYXggPSAxODAwOworCQllbHNlCisJCQlpc3AtPmN1cnJlbnRfbWF4ID0gcG93ZXI7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWdvdG8gb3V0OwogCX0KIAotCS8qIGVuYWJsZSBkYXRhIHB1bGx1cHMgKi8KLQlpZiAoaXNwLT5vdGctPmdhZGdldCkKLQkJdXNiX2dhZGdldF9jb25uZWN0KGlzcC0+b3RnLT5nYWRnZXQpOworCXBvd2VyX3N1cHBseV9jaGFuZ2VkKCZpc3AtPnBzeSk7CitvdXQ6CisJbXV0ZXhfdW5sb2NrKCZsb2NrKTsKIH0KIAogc3RhdGljIGludCBpc3AxNzA0X25vdGlmaWVyX2NhbGwoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpuYiwKLQkJdW5zaWduZWQgbG9uZyBldmVudCwgdm9pZCAqdW51c2VkKQorCQl1bnNpZ25lZCBsb25nIGV2ZW50LCB2b2lkICpwb3dlcikKIHsKIAlzdHJ1Y3QgaXNwMTcwNF9jaGFyZ2VyICppc3AgPQogCQljb250YWluZXJfb2YobmIsIHN0cnVjdCBpc3AxNzA0X2NoYXJnZXIsIG5iKTsKIAotCXN3aXRjaCAoZXZlbnQpIHsKLQljYXNlIFVTQl9FVkVOVF9WQlVTOgotCQlzY2hlZHVsZV93b3JrKCZpc3AtPndvcmspOwotCQlicmVhazsKLQljYXNlIFVTQl9FVkVOVF9OT05FOgotCQlpZiAoaXNwLT5wcmVzZW50KSB7Ci0JCQlpc3AtPnByZXNlbnQgPSAwOwotCQkJcG93ZXJfc3VwcGx5X2NoYW5nZWQoJmlzcC0+cHN5KTsKLQkJfQotCQlicmVhazsKLQlkZWZhdWx0OgotCQlyZXR1cm4gTk9USUZZX0RPTkU7Ci0JfQorCWlzcC0+ZXZlbnQgPSBldmVudDsKKworCWlmIChwb3dlcikKKwkJaXNwLT5tYXhfcG93ZXIgPSAqKCh1bnNpZ25lZCAqKXBvd2VyKTsKKworCXNjaGVkdWxlX3dvcmsoJmlzcC0+d29yayk7CiAKIAlyZXR1cm4gTk9USUZZX09LOwogfQpAQCAtMjE2LDYgKzMxMiwxMiBAQAogCWNhc2UgUE9XRVJfU1VQUExZX1BST1BfUFJFU0VOVDoKIAkJdmFsLT5pbnR2YWwgPSBpc3AtPnByZXNlbnQ7CiAJCWJyZWFrOworCWNhc2UgUE9XRVJfU1VQUExZX1BST1BfT05MSU5FOgorCQl2YWwtPmludHZhbCA9IGlzcC0+b25saW5lOworCQlicmVhazsKKwljYXNlIFBPV0VSX1NVUFBMWV9QUk9QX0NVUlJFTlRfTUFYOgorCQl2YWwtPmludHZhbCA9IGlzcC0+Y3VycmVudF9tYXg7CisJCWJyZWFrOwogCWNhc2UgUE9XRVJfU1VQUExZX1BST1BfTU9ERUxfTkFNRToKIAkJdmFsLT5zdHJ2YWwgPSBpc3AtPm1vZGVsOwogCQlicmVhazsKQEAgLTIzMCw2ICszMzIsOCBAQAogCiBzdGF0aWMgZW51bSBwb3dlcl9zdXBwbHlfcHJvcGVydHkgcG93ZXJfcHJvcHNbXSA9IHsKIAlQT1dFUl9TVVBQTFlfUFJPUF9QUkVTRU5ULAorCVBPV0VSX1NVUFBMWV9QUk9QX09OTElORSwKKwlQT1dFUl9TVVBQTFlfUFJPUF9DVVJSRU5UX01BWCwKIAlQT1dFUl9TVVBQTFlfUFJPUF9NT0RFTF9OQU1FLAogCVBPV0VSX1NVUFBMWV9QUk9QX01BTlVGQUNUVVJFUiwKIH07CkBAIC0yODcsMTMgKzM5MSwxMyBAQAogCWlmICghaXNwLT5vdGcpCiAJCWdvdG8gZmFpbDA7CiAKKwlpc3AtPmRldiA9ICZwZGV2LT5kZXY7CisJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgaXNwKTsKKwogCXJldCA9IGlzcDE3MDRfdGVzdF91bHBpKGlzcCk7CiAJaWYgKHJldCA8IDApCiAJCWdvdG8gZmFpbDE7CiAKLQlpc3AtPmRldiA9ICZwZGV2LT5kZXY7Ci0JcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgaXNwKTsKLQogCWlzcC0+cHN5Lm5hbWUJCT0gImlzcDE3MDQiOwogCWlzcC0+cHN5LnR5cGUJCT0gUE9XRVJfU1VQUExZX1RZUEVfVVNCOwogCWlzcC0+cHN5LnByb3BlcnRpZXMJPSBwb3dlcl9wcm9wczsKQEAgLTMxOCw2ICs0MjIsMjMgQEAKIAogCWRldl9pbmZvKGlzcC0+ZGV2LCAicmVnaXN0ZXJlZCB3aXRoIHByb2R1Y3QgaWQgJXNcbiIsIGlzcC0+bW9kZWwpOwogCisJLyoKKwkgKiBUYWtpbmcgb3ZlciB0aGUgRCsgcHVsbHVwLgorCSAqCisJICogRklYTUU6IFRoZSBkZXZpY2Ugd2lsbCBiZSBkaXNjb25uZWN0ZWQgaWYgaXQgd2FzIGFscmVhZHkKKwkgKiBlbnVtZXJhdGVkLiBUaGUgY2hhcmdlciBkcml2ZXIgc2hvdWxkIGJlIGFsd2F5cyBsb2FkZWQgYmVmb3JlIGFueQorCSAqIGdhZGdldCBpcyBsb2FkZWQuCisJICovCisJaWYgKGlzcC0+b3RnLT5nYWRnZXQpCisJCXVzYl9nYWRnZXRfZGlzY29ubmVjdChpc3AtPm90Zy0+Z2FkZ2V0KTsKKworCS8qIERldGVjdCBjaGFyZ2VyIGlmIFZCVVMgaXMgdmFsaWQgKHRoZSBjYWJsZSB3YXMgYWxyZWFkeSBwbHVnZ2VkKS4gKi8KKwlyZXQgPSBvdGdfaW9fcmVhZChpc3AtPm90ZywgVUxQSV9VU0JfSU5UX1NUUyk7CisJaWYgKChyZXQgJiBVTFBJX0lOVF9WQlVTX1ZBTElEKSAmJiAhaXNwLT5vdGctPmRlZmF1bHRfYSkgeworCQlpc3AtPmV2ZW50ID0gVVNCX0VWRU5UX1ZCVVM7CisJCXNjaGVkdWxlX3dvcmsoJmlzcC0+d29yayk7CisJfQorCiAJcmV0dXJuIDA7CiBmYWlsMjoKIAlwb3dlcl9zdXBwbHlfdW5yZWdpc3RlcigmaXNwLT5wc3kpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wb3dlci9qejQ3NDAtYmF0dGVyeS5jIGIvZHJpdmVycy9wb3dlci9qejQ3NDAtYmF0dGVyeS5jCmluZGV4IGE4MTA4YTcuLjAyNDE0ZGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcG93ZXIvano0NzQwLWJhdHRlcnkuYworKysgYi9kcml2ZXJzL3Bvd2VyL2p6NDc0MC1iYXR0ZXJ5LmMKQEAgLTE5LDYgKzE5LDcgQEAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvaW8uaD4KIAogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiAjaW5jbHVkZSA8bGludXgvZ3Bpby5oPgpAQCAtNDcsNiArNDgsOCBAQAogCiAJc3RydWN0IHBvd2VyX3N1cHBseSBiYXR0ZXJ5OwogCXN0cnVjdCBkZWxheWVkX3dvcmsgd29yazsKKworCXN0cnVjdCBtdXRleCBsb2NrOwogfTsKIAogc3RhdGljIGlubGluZSBzdHJ1Y3QganpfYmF0dGVyeSAqcHN5X3RvX2p6X2JhdHRlcnkoc3RydWN0IHBvd2VyX3N1cHBseSAqcHN5KQpAQCAtNjgsNiArNzEsOCBAQAogCXVuc2lnbmVkIGxvbmcgdmFsOwogCWxvbmcgdm9sdGFnZTsKIAorCW11dGV4X2xvY2soJmJhdHRlcnktPmxvY2spOworCiAJSU5JVF9DT01QTEVUSU9OKGJhdHRlcnktPnJlYWRfY29tcGxldGlvbik7CiAKIAllbmFibGVfaXJxKGJhdHRlcnktPmlycSk7CkBAIC05MSw2ICs5Niw4IEBACiAJYmF0dGVyeS0+Y2VsbC0+ZGlzYWJsZShiYXR0ZXJ5LT5wZGV2KTsKIAlkaXNhYmxlX2lycShiYXR0ZXJ5LT5pcnEpOwogCisJbXV0ZXhfdW5sb2NrKCZiYXR0ZXJ5LT5sb2NrKTsKKwogCXJldHVybiB2b2x0YWdlOwogfQogCkBAIC0yNDAsNiArMjQ3LDExIEBACiAJc3RydWN0IGp6X2JhdHRlcnkgKmp6X2JhdHRlcnk7CiAJc3RydWN0IHBvd2VyX3N1cHBseSAqYmF0dGVyeTsKIAorCWlmICghcGRhdGEpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiTm8gcGxhdGZvcm1fZGF0YSBzdXBwbGllZFxuIik7CisJCXJldHVybiAtRU5YSU87CisJfQorCiAJanpfYmF0dGVyeSA9IGt6YWxsb2Moc2l6ZW9mKCpqel9iYXR0ZXJ5KSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFqel9iYXR0ZXJ5KSB7CiAJCWRldl9lcnIoJnBkZXYtPmRldiwgIkZhaWxlZCB0byBhbGxvY2F0ZSBkcml2ZXIgc3RydWN0dXJlXG4iKTsKQEAgLTI5MSw2ICszMDMsNyBAQAogCWp6X2JhdHRlcnktPnBkZXYgPSBwZGV2OwogCiAJaW5pdF9jb21wbGV0aW9uKCZqel9iYXR0ZXJ5LT5yZWFkX2NvbXBsZXRpb24pOworCW11dGV4X2luaXQoJmp6X2JhdHRlcnktPmxvY2spOwogCiAJSU5JVF9ERUxBWUVEX1dPUksoJmp6X2JhdHRlcnktPndvcmssIGp6X2JhdHRlcnlfd29yayk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcG93ZXIvbWF4MTcwNDJfYmF0dGVyeS5jIGIvZHJpdmVycy9wb3dlci9tYXgxNzA0Ml9iYXR0ZXJ5LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzVjODgwNQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvcG93ZXIvbWF4MTcwNDJfYmF0dGVyeS5jCkBAIC0wLDAgKzEsMjM5IEBACisvKgorICogRnVlbCBnYXVnZSBkcml2ZXIgZm9yIE1heGltIDE3MDQyIC8gODk2NiAvIDg5OTcKKyAqICBOb3RlIHRoYXQgTWF4aW0gODk2NiBhbmQgODk5NyBhcmUgbWZkIGFuZCB0aGlzIGlzIGl0cyBzdWJkZXZpY2UuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDExIFNhbXN1bmcgRWxlY3Ryb25pY3MKKyAqIE15dW5nSm9vIEhhbSA8bXl1bmdqb28uaGFtQHNhbXN1bmcuY29tPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSwgU3VpdGUgMzMwLCBCb3N0b24sIE1BICAwMjExMS0xMzA3ICBVU0EKKyAqCisgKiBUaGlzIGRyaXZlciBpcyBiYXNlZCBvbiBtYXgxNzA0MF9iYXR0ZXJ5LmMKKyAqLworCisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9pMmMuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2RfZGV2aWNldGFibGUuaD4KKyNpbmNsdWRlIDxsaW51eC9wb3dlcl9zdXBwbHkuaD4KKyNpbmNsdWRlIDxsaW51eC9wb3dlci9tYXgxNzA0Ml9iYXR0ZXJ5Lmg+CisKK2VudW0gbWF4MTcwNDJfcmVnaXN0ZXIgeworCU1BWDE3MDQyX1NUQVRVUwkJPSAweDAwLAorCU1BWDE3MDQyX1ZBTFJUX1RoCT0gMHgwMSwKKwlNQVgxNzA0Ml9UQUxSVF9UaAk9IDB4MDIsCisJTUFYMTcwNDJfU0FMUlRfVGgJPSAweDAzLAorCU1BWDE3MDQyX0F0UmF0ZQkJPSAweDA0LAorCU1BWDE3MDQyX1JlcENhcAkJPSAweDA1LAorCU1BWDE3MDQyX1JlcFNPQwkJPSAweDA2LAorCU1BWDE3MDQyX0FnZQkJPSAweDA3LAorCU1BWDE3MDQyX1RFTVAJCT0gMHgwOCwKKwlNQVgxNzA0Ml9WQ0VMTAkJPSAweDA5LAorCU1BWDE3MDQyX0N1cnJlbnQJPSAweDBBLAorCU1BWDE3MDQyX0F2Z0N1cnJlbnQJPSAweDBCLAorCU1BWDE3MDQyX1FyZXNpZHVhbAk9IDB4MEMsCisJTUFYMTcwNDJfU09DCQk9IDB4MEQsCisJTUFYMTcwNDJfQXZTT0MJCT0gMHgwRSwKKwlNQVgxNzA0Ml9SZW1DYXAJCT0gMHgwRiwKKwlNQVgxNzQwMl9GdWxsQ0FQCT0gMHgxMCwKKwlNQVgxNzA0Ml9UVEUJCT0gMHgxMSwKKwlNQVgxNzA0Ml9WX2VtcHR5CT0gMHgxMiwKKworCU1BWDE3MDQyX1JTTE9XCQk9IDB4MTQsCisKKwlNQVgxNzA0Ml9BdmdUQQkJPSAweDE2LAorCU1BWDE3MDQyX0N5Y2xlcwkJPSAweDE3LAorCU1BWDE3MDQyX0Rlc2lnbkNhcAk9IDB4MTgsCisJTUFYMTcwNDJfQXZnVkNFTEwJPSAweDE5LAorCU1BWDE3MDQyX01pbk1heFRlbXAJPSAweDFBLAorCU1BWDE3MDQyX01pbk1heFZvbHQJPSAweDFCLAorCU1BWDE3MDQyX01pbk1heEN1cnIJPSAweDFDLAorCU1BWDE3MDQyX0NPTkZJRwkJPSAweDFELAorCU1BWDE3MDQyX0lDSEdUZXJtCT0gMHgxRSwKKwlNQVgxNzA0Ml9BdkNhcAkJPSAweDFGLAorCU1BWDE3MDQyX01hbk5hbWUJPSAweDIwLAorCU1BWDE3MDQyX0Rldk5hbWUJPSAweDIxLAorCU1BWDE3MDQyX0RldkNoZW0JPSAweDIyLAorCisJTUFYMTcwNDJfVGVtcE5vbQk9IDB4MjQsCisJTUFYMTcwNDJfVGVtcENvbGQJPSAweDI1LAorCU1BWDE3MDQyX1RlbXBIb3QJPSAweDI2LAorCU1BWDE3MDQyX0FJTgkJPSAweDI3LAorCU1BWDE3MDQyX0xlYXJuQ0ZHCT0gMHgyOCwKKwlNQVgxNzA0Ml9TSEZUQ0ZHCT0gMHgyOSwKKwlNQVgxNzA0Ml9SZWxheENGRwk9IDB4MkEsCisJTUFYMTcwNDJfTWlzY0NGRwk9IDB4MkIsCisJTUFYMTcwNDJfVEdBSU4JCT0gMHgyQywKKwlNQXgxNzA0Ml9UT0ZGCQk9IDB4MkQsCisJTUFYMTcwNDJfQ0dBSU4JCT0gMHgyRSwKKwlNQVgxNzA0Ml9DT0ZGCQk9IDB4MkYsCisKKwlNQVgxNzA0Ml9RX2VtcHR5CT0gMHgzMywKKwlNQVgxNzA0Ml9UX2VtcHR5CT0gMHgzNCwKKworCU1BWDE3MDQyX1JDT01QMAkJPSAweDM4LAorCU1BWDE3MDQyX1RlbXBDbwkJPSAweDM5LAorCU1BWDE3MDQyX1J4CQk9IDB4M0EsCisJTUFYMTcwNDJfVF9lbXB0eTAJPSAweDNCLAorCU1BWDE3MDQyX1Rhc2tQZXJpb2QJPSAweDNDLAorCU1BWDE3MDQyX0ZTVEFUCQk9IDB4M0QsCisKKwlNQVgxNzA0Ml9TSEROVElNRVIJPSAweDNGLAorCisJTUFYMTcwNDJfVkZSZW1DYXAJPSAweDRBLAorCisJTUFYMTcwNDJfUUgJCT0gMHg0RCwKKwlNQVgxNzA0Ml9RTAkJPSAweDRFLAorfTsKKworc3RydWN0IG1heDE3MDQyX2NoaXAgeworCXN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQ7CisJc3RydWN0IHBvd2VyX3N1cHBseSBiYXR0ZXJ5OworCXN0cnVjdCBtYXgxNzA0Ml9wbGF0Zm9ybV9kYXRhICpwZGF0YTsKK307CisKK3N0YXRpYyBpbnQgbWF4MTcwNDJfd3JpdGVfcmVnKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsIHU4IHJlZywgdTE2IHZhbHVlKQoreworCWludCByZXQgPSBpMmNfc21idXNfd3JpdGVfd29yZF9kYXRhKGNsaWVudCwgcmVnLCB2YWx1ZSk7CisKKwlpZiAocmV0IDwgMCkKKwkJZGV2X2VycigmY2xpZW50LT5kZXYsICIlczogZXJyICVkXG4iLCBfX2Z1bmNfXywgcmV0KTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgbWF4MTcwNDJfcmVhZF9yZWcoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgdTggcmVnKQoreworCWludCByZXQgPSBpMmNfc21idXNfcmVhZF93b3JkX2RhdGEoY2xpZW50LCByZWcpOworCisJaWYgKHJldCA8IDApCisJCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiJXM6IGVyciAlZFxuIiwgX19mdW5jX18sIHJldCk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgZW51bSBwb3dlcl9zdXBwbHlfcHJvcGVydHkgbWF4MTcwNDJfYmF0dGVyeV9wcm9wc1tdID0geworCVBPV0VSX1NVUFBMWV9QUk9QX1ZPTFRBR0VfTk9XLAorCVBPV0VSX1NVUFBMWV9QUk9QX1ZPTFRBR0VfQVZHLAorCVBPV0VSX1NVUFBMWV9QUk9QX0NBUEFDSVRZLAorfTsKKworc3RhdGljIGludCBtYXgxNzA0Ml9nZXRfcHJvcGVydHkoc3RydWN0IHBvd2VyX3N1cHBseSAqcHN5LAorCQkJICAgIGVudW0gcG93ZXJfc3VwcGx5X3Byb3BlcnR5IHBzcCwKKwkJCSAgICB1bmlvbiBwb3dlcl9zdXBwbHlfcHJvcHZhbCAqdmFsKQoreworCXN0cnVjdCBtYXgxNzA0Ml9jaGlwICpjaGlwID0gY29udGFpbmVyX29mKHBzeSwKKwkJCQlzdHJ1Y3QgbWF4MTcwNDJfY2hpcCwgYmF0dGVyeSk7CisKKwlzd2l0Y2ggKHBzcCkgeworCWNhc2UgUE9XRVJfU1VQUExZX1BST1BfVk9MVEFHRV9OT1c6CisJCXZhbC0+aW50dmFsID0gbWF4MTcwNDJfcmVhZF9yZWcoY2hpcC0+Y2xpZW50LAorCQkJCU1BWDE3MDQyX1ZDRUxMKSAqIDgzOyAvKiAxMDAwIC8gMTIgPSA4MyAqLworCQlicmVhazsKKwljYXNlIFBPV0VSX1NVUFBMWV9QUk9QX1ZPTFRBR0VfQVZHOgorCQl2YWwtPmludHZhbCA9IG1heDE3MDQyX3JlYWRfcmVnKGNoaXAtPmNsaWVudCwKKwkJCQlNQVgxNzA0Ml9BdmdWQ0VMTCkgKiA4MzsKKwkJYnJlYWs7CisJY2FzZSBQT1dFUl9TVVBQTFlfUFJPUF9DQVBBQ0lUWToKKwkJdmFsLT5pbnR2YWwgPSBtYXgxNzA0Ml9yZWFkX3JlZyhjaGlwLT5jbGllbnQsCisJCQkJTUFYMTcwNDJfU09DKSAvIDI1NjsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IF9fZGV2aW5pdCBtYXgxNzA0Ml9wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LAorCQkJY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgKmlkKQoreworCXN0cnVjdCBpMmNfYWRhcHRlciAqYWRhcHRlciA9IHRvX2kyY19hZGFwdGVyKGNsaWVudC0+ZGV2LnBhcmVudCk7CisJc3RydWN0IG1heDE3MDQyX2NoaXAgKmNoaXA7CisJaW50IHJldDsKKworCWlmICghaTJjX2NoZWNrX2Z1bmN0aW9uYWxpdHkoYWRhcHRlciwgSTJDX0ZVTkNfU01CVVNfV09SRF9EQVRBKSkKKwkJcmV0dXJuIC1FSU87CisKKwljaGlwID0ga3phbGxvYyhzaXplb2YoKmNoaXApLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWNoaXApCisJCXJldHVybiAtRU5PTUVNOworCisJY2hpcC0+Y2xpZW50ID0gY2xpZW50OworCWNoaXAtPnBkYXRhID0gY2xpZW50LT5kZXYucGxhdGZvcm1fZGF0YTsKKworCWkyY19zZXRfY2xpZW50ZGF0YShjbGllbnQsIGNoaXApOworCisJY2hpcC0+YmF0dGVyeS5uYW1lCQk9ICJtYXgxNzA0Ml9iYXR0ZXJ5IjsKKwljaGlwLT5iYXR0ZXJ5LnR5cGUJCT0gUE9XRVJfU1VQUExZX1RZUEVfQkFUVEVSWTsKKwljaGlwLT5iYXR0ZXJ5LmdldF9wcm9wZXJ0eQk9IG1heDE3MDQyX2dldF9wcm9wZXJ0eTsKKwljaGlwLT5iYXR0ZXJ5LnByb3BlcnRpZXMJPSBtYXgxNzA0Ml9iYXR0ZXJ5X3Byb3BzOworCWNoaXAtPmJhdHRlcnkubnVtX3Byb3BlcnRpZXMJPSBBUlJBWV9TSVpFKG1heDE3MDQyX2JhdHRlcnlfcHJvcHMpOworCisJcmV0ID0gcG93ZXJfc3VwcGx5X3JlZ2lzdGVyKCZjbGllbnQtPmRldiwgJmNoaXAtPmJhdHRlcnkpOworCWlmIChyZXQpIHsKKwkJZGV2X2VycigmY2xpZW50LT5kZXYsICJmYWlsZWQ6IHBvd2VyIHN1cHBseSByZWdpc3RlclxuIik7CisJCWkyY19zZXRfY2xpZW50ZGF0YShjbGllbnQsIE5VTEwpOworCQlrZnJlZShjaGlwKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlpZiAoIWNoaXAtPnBkYXRhLT5lbmFibGVfY3VycmVudF9zZW5zZSkgeworCQltYXgxNzA0Ml93cml0ZV9yZWcoY2xpZW50LCBNQVgxNzA0Ml9DR0FJTiwgMHgwMDAwKTsKKwkJbWF4MTcwNDJfd3JpdGVfcmVnKGNsaWVudCwgTUFYMTcwNDJfTWlzY0NGRywgMHgwMDAzKTsKKwkJbWF4MTcwNDJfd3JpdGVfcmVnKGNsaWVudCwgTUFYMTcwNDJfTGVhcm5DRkcsIDB4MDAwNyk7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgX19kZXZleGl0IG1heDE3MDQyX3JlbW92ZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50KQoreworCXN0cnVjdCBtYXgxNzA0Ml9jaGlwICpjaGlwID0gaTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7CisKKwlwb3dlcl9zdXBwbHlfdW5yZWdpc3RlcigmY2hpcC0+YmF0dGVyeSk7CisJaTJjX3NldF9jbGllbnRkYXRhKGNsaWVudCwgTlVMTCk7CisJa2ZyZWUoY2hpcCk7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCBtYXgxNzA0Ml9pZFtdID0geworCXsgIm1heDE3MDQyIiwgMCB9LAorCXsgfQorfTsKK01PRFVMRV9ERVZJQ0VfVEFCTEUoaTJjLCBtYXgxNzA0Ml9pZCk7CisKK3N0YXRpYyBzdHJ1Y3QgaTJjX2RyaXZlciBtYXgxNzA0Ml9pMmNfZHJpdmVyID0geworCS5kcml2ZXIJPSB7CisJCS5uYW1lCT0gIm1heDE3MDQyIiwKKwl9LAorCS5wcm9iZQkJPSBtYXgxNzA0Ml9wcm9iZSwKKwkucmVtb3ZlCQk9IF9fZGV2ZXhpdF9wKG1heDE3MDQyX3JlbW92ZSksCisJLmlkX3RhYmxlCT0gbWF4MTcwNDJfaWQsCit9OworCitzdGF0aWMgaW50IF9faW5pdCBtYXgxNzA0Ml9pbml0KHZvaWQpCit7CisJcmV0dXJuIGkyY19hZGRfZHJpdmVyKCZtYXgxNzA0Ml9pMmNfZHJpdmVyKTsKK30KK21vZHVsZV9pbml0KG1heDE3MDQyX2luaXQpOworCitzdGF0aWMgdm9pZCBfX2V4aXQgbWF4MTcwNDJfZXhpdCh2b2lkKQoreworCWkyY19kZWxfZHJpdmVyKCZtYXgxNzA0Ml9pMmNfZHJpdmVyKTsKK30KK21vZHVsZV9leGl0KG1heDE3MDQyX2V4aXQpOworCitNT0RVTEVfQVVUSE9SKCJNeXVuZ0pvbyBIYW0gPG15dW5nam9vLmhhbUBzYW1zdW5nLmNvbT4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiTUFYMTcwNDIgRnVlbCBHYXVnZSIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wb3dlci9vbHBjX2JhdHRlcnkuYyBiL2RyaXZlcnMvcG93ZXIvb2xwY19iYXR0ZXJ5LmMKaW5kZXggNWJjMWRjZi4uMGIwZmYzYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9wb3dlci9vbHBjX2JhdHRlcnkuYworKysgYi9kcml2ZXJzL3Bvd2VyL29scGNfYmF0dGVyeS5jCkBAIC0yMDEsNiArMjAxLDcyIEBACiAJcmV0dXJuIHJldDsKIH0KIAorc3RhdGljIGludCBvbHBjX2JhdF9nZXRfY2hhcmdlX2Z1bGxfZGVzaWduKHVuaW9uIHBvd2VyX3N1cHBseV9wcm9wdmFsICp2YWwpCit7CisJdWludDhfdCBlY19ieXRlOworCXVuaW9uIHBvd2VyX3N1cHBseV9wcm9wdmFsIHRlY2g7CisJaW50IHJldCwgbWZyOworCisJcmV0ID0gb2xwY19iYXRfZ2V0X3RlY2goJnRlY2gpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwllY19ieXRlID0gQkFUX0FERFJfTUZSX1RZUEU7CisJcmV0ID0gb2xwY19lY19jbWQoRUNfQkFUX0VFUFJPTSwgJmVjX2J5dGUsIDEsICZlY19ieXRlLCAxKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJbWZyID0gZWNfYnl0ZSA+PiA0OworCisJc3dpdGNoICh0ZWNoLmludHZhbCkgeworCWNhc2UgUE9XRVJfU1VQUExZX1RFQ0hOT0xPR1lfTmlNSDoKKwkJc3dpdGNoIChtZnIpIHsKKwkJY2FzZSAxOiAvKiBHb2xkIFBlYWsgKi8KKwkJCXZhbC0+aW50dmFsID0gMzAwMDAwMCouODsKKwkJCWJyZWFrOworCQlkZWZhdWx0OgorCQkJcmV0dXJuIC1FSU87CisJCX0KKwkJYnJlYWs7CisKKwljYXNlIFBPV0VSX1NVUFBMWV9URUNITk9MT0dZX0xpRmU6CisJCXN3aXRjaCAobWZyKSB7CisJCWNhc2UgMTogLyogR29sZCBQZWFrICovCisJCQl2YWwtPmludHZhbCA9IDI4MDAwMDA7CisJCQlicmVhazsKKwkJY2FzZSAyOiAvKiBCWUQgKi8KKwkJCXZhbC0+aW50dmFsID0gMzEwMDAwMDsKKwkJCWJyZWFrOworCQlkZWZhdWx0OgorCQkJcmV0dXJuIC1FSU87CisJCX0KKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQlyZXR1cm4gLUVJTzsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IG9scGNfYmF0X2dldF9jaGFyZ2Vfbm93KHVuaW9uIHBvd2VyX3N1cHBseV9wcm9wdmFsICp2YWwpCit7CisJdWludDhfdCBzb2M7CisJdW5pb24gcG93ZXJfc3VwcGx5X3Byb3B2YWwgZnVsbDsKKwlpbnQgcmV0OworCisJcmV0ID0gb2xwY19lY19jbWQoRUNfQkFUX1NPQywgTlVMTCwgMCwgJnNvYywgMSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXJldCA9IG9scGNfYmF0X2dldF9jaGFyZ2VfZnVsbF9kZXNpZ24oJmZ1bGwpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwl2YWwtPmludHZhbCA9IHNvYyAqIChmdWxsLmludHZhbCAvIDEwMCk7CisJcmV0dXJuIDA7Cit9CisKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqCQlCYXR0ZXJ5IHByb3BlcnRpZXMKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCkBAIC0yNjcsNiArMzMzLDcgQEAKIAkJCXJldHVybiByZXQ7CiAJCWJyZWFrOwogCWNhc2UgUE9XRVJfU1VQUExZX1BST1BfVk9MVEFHRV9BVkc6CisJY2FzZSBQT1dFUl9TVVBQTFlfUFJPUF9WT0xUQUdFX05PVzoKIAkJcmV0ID0gb2xwY19lY19jbWQoRUNfQkFUX1ZPTFRBR0UsIE5VTEwsIDAsICh2b2lkICopJmVjX3dvcmQsIDIpOwogCQlpZiAocmV0KQogCQkJcmV0dXJuIHJldDsKQEAgLTI3NCw2ICszNDEsNyBAQAogCQl2YWwtPmludHZhbCA9IChzMTYpYmUxNl90b19jcHUoZWNfd29yZCkgKiA5NzYwTCAvIDMyOwogCQlicmVhazsKIAljYXNlIFBPV0VSX1NVUFBMWV9QUk9QX0NVUlJFTlRfQVZHOgorCWNhc2UgUE9XRVJfU1VQUExZX1BST1BfQ1VSUkVOVF9OT1c6CiAJCXJldCA9IG9scGNfZWNfY21kKEVDX0JBVF9DVVJSRU5ULCBOVUxMLCAwLCAodm9pZCAqKSZlY193b3JkLCAyKTsKIAkJaWYgKHJldCkKIAkJCXJldHVybiByZXQ7CkBAIC0yOTQsNiArMzYyLDE2IEBACiAJCWVsc2UKIAkJCXZhbC0+aW50dmFsID0gUE9XRVJfU1VQUExZX0NBUEFDSVRZX0xFVkVMX05PUk1BTDsKIAkJYnJlYWs7CisJY2FzZSBQT1dFUl9TVVBQTFlfUFJPUF9DSEFSR0VfRlVMTF9ERVNJR046CisJCXJldCA9IG9scGNfYmF0X2dldF9jaGFyZ2VfZnVsbF9kZXNpZ24odmFsKTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7CisJCWJyZWFrOworCWNhc2UgUE9XRVJfU1VQUExZX1BST1BfQ0hBUkdFX05PVzoKKwkJcmV0ID0gb2xwY19iYXRfZ2V0X2NoYXJnZV9ub3codmFsKTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7CisJCWJyZWFrOwogCWNhc2UgUE9XRVJfU1VQUExZX1BST1BfVEVNUDoKIAkJcmV0ID0gb2xwY19lY19jbWQoRUNfQkFUX1RFTVAsIE5VTEwsIDAsICh2b2lkICopJmVjX3dvcmQsIDIpOwogCQlpZiAocmV0KQpAQCAtMzMxLDE2ICs0MDksMjAgQEAKIAlyZXR1cm4gcmV0OwogfQogCi1zdGF0aWMgZW51bSBwb3dlcl9zdXBwbHlfcHJvcGVydHkgb2xwY19iYXRfcHJvcHNbXSA9IHsKK3N0YXRpYyBlbnVtIHBvd2VyX3N1cHBseV9wcm9wZXJ0eSBvbHBjX3hvMV9iYXRfcHJvcHNbXSA9IHsKIAlQT1dFUl9TVVBQTFlfUFJPUF9TVEFUVVMsCiAJUE9XRVJfU1VQUExZX1BST1BfQ0hBUkdFX1RZUEUsCiAJUE9XRVJfU1VQUExZX1BST1BfUFJFU0VOVCwKIAlQT1dFUl9TVVBQTFlfUFJPUF9IRUFMVEgsCiAJUE9XRVJfU1VQUExZX1BST1BfVEVDSE5PTE9HWSwKIAlQT1dFUl9TVVBQTFlfUFJPUF9WT0xUQUdFX0FWRywKKwlQT1dFUl9TVVBQTFlfUFJPUF9WT0xUQUdFX05PVywKIAlQT1dFUl9TVVBQTFlfUFJPUF9DVVJSRU5UX0FWRywKKwlQT1dFUl9TVVBQTFlfUFJPUF9DVVJSRU5UX05PVywKIAlQT1dFUl9TVVBQTFlfUFJPUF9DQVBBQ0lUWSwKIAlQT1dFUl9TVVBQTFlfUFJPUF9DQVBBQ0lUWV9MRVZFTCwKKwlQT1dFUl9TVVBQTFlfUFJPUF9DSEFSR0VfRlVMTF9ERVNJR04sCisJUE9XRVJfU1VQUExZX1BST1BfQ0hBUkdFX05PVywKIAlQT1dFUl9TVVBQTFlfUFJPUF9URU1QLAogCVBPV0VSX1NVUFBMWV9QUk9QX1RFTVBfQU1CSUVOVCwKIAlQT1dFUl9TVVBQTFlfUFJPUF9NQU5VRkFDVFVSRVIsCkBAIC0zNDgsNiArNDMwLDI3IEBACiAJUE9XRVJfU1VQUExZX1BST1BfQ0hBUkdFX0NPVU5URVIsCiB9OwogCisvKiBYTy0xLjUgZG9lcyBub3QgaGF2ZSBhbWJpZW50IHRlbXBlcmF0dXJlIHByb3BlcnR5ICovCitzdGF0aWMgZW51bSBwb3dlcl9zdXBwbHlfcHJvcGVydHkgb2xwY194bzE1X2JhdF9wcm9wc1tdID0geworCVBPV0VSX1NVUFBMWV9QUk9QX1NUQVRVUywKKwlQT1dFUl9TVVBQTFlfUFJPUF9DSEFSR0VfVFlQRSwKKwlQT1dFUl9TVVBQTFlfUFJPUF9QUkVTRU5ULAorCVBPV0VSX1NVUFBMWV9QUk9QX0hFQUxUSCwKKwlQT1dFUl9TVVBQTFlfUFJPUF9URUNITk9MT0dZLAorCVBPV0VSX1NVUFBMWV9QUk9QX1ZPTFRBR0VfQVZHLAorCVBPV0VSX1NVUFBMWV9QUk9QX1ZPTFRBR0VfTk9XLAorCVBPV0VSX1NVUFBMWV9QUk9QX0NVUlJFTlRfQVZHLAorCVBPV0VSX1NVUFBMWV9QUk9QX0NVUlJFTlRfTk9XLAorCVBPV0VSX1NVUFBMWV9QUk9QX0NBUEFDSVRZLAorCVBPV0VSX1NVUFBMWV9QUk9QX0NBUEFDSVRZX0xFVkVMLAorCVBPV0VSX1NVUFBMWV9QUk9QX0NIQVJHRV9GVUxMX0RFU0lHTiwKKwlQT1dFUl9TVVBQTFlfUFJPUF9DSEFSR0VfTk9XLAorCVBPV0VSX1NVUFBMWV9QUk9QX1RFTVAsCisJUE9XRVJfU1VQUExZX1BST1BfTUFOVUZBQ1RVUkVSLAorCVBPV0VSX1NVUFBMWV9QUk9QX1NFUklBTF9OVU1CRVIsCisJUE9XRVJfU1VQUExZX1BST1BfQ0hBUkdFX0NPVU5URVIsCit9OworCiAvKiBFRVBST00gcmVhZGluZyBnb2VzIGNvbXBsZXRlbHkgYXJvdW5kIHRoZSBwb3dlcl9zdXBwbHkgQVBJLCBzYWRseSAqLwogCiAjZGVmaW5lIEVFUFJPTV9TVEFSVAkweDIwCkBAIC00MTksOCArNTIyLDYgQEAKIHN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpiYXRfcGRldjsKIAogc3RhdGljIHN0cnVjdCBwb3dlcl9zdXBwbHkgb2xwY19iYXQgPSB7Ci0JLnByb3BlcnRpZXMgPSBvbHBjX2JhdF9wcm9wcywKLQkubnVtX3Byb3BlcnRpZXMgPSBBUlJBWV9TSVpFKG9scGNfYmF0X3Byb3BzKSwKIAkuZ2V0X3Byb3BlcnR5ID0gb2xwY19iYXRfZ2V0X3Byb3BlcnR5LAogCS51c2VfZm9yX2FwbSA9IDEsCiB9OwpAQCAtNDY2LDYgKzU2NywxMyBAQAogCQlnb3RvIGFjX2ZhaWxlZDsKIAogCW9scGNfYmF0Lm5hbWUgPSBiYXRfcGRldi0+bmFtZTsKKwlpZiAob2xwY19ib2FyZF9hdF9sZWFzdChvbHBjX2JvYXJkX3ByZSgweGQwKSkpIHsgLyogWE8tMS41ICovCisJCW9scGNfYmF0LnByb3BlcnRpZXMgPSBvbHBjX3hvMTVfYmF0X3Byb3BzOworCQlvbHBjX2JhdC5udW1fcHJvcGVydGllcyA9IEFSUkFZX1NJWkUob2xwY194bzE1X2JhdF9wcm9wcyk7CisJfSBlbHNlIHsgLyogWE8tMSAqLworCQlvbHBjX2JhdC5wcm9wZXJ0aWVzID0gb2xwY194bzFfYmF0X3Byb3BzOworCQlvbHBjX2JhdC5udW1fcHJvcGVydGllcyA9IEFSUkFZX1NJWkUob2xwY194bzFfYmF0X3Byb3BzKTsKKwl9CiAKIAlyZXQgPSBwb3dlcl9zdXBwbHlfcmVnaXN0ZXIoJmJhdF9wZGV2LT5kZXYsICZvbHBjX2JhdCk7CiAJaWYgKHJldCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcG93ZXIvcG93ZXJfc3VwcGx5X2NvcmUuYyBiL2RyaXZlcnMvcG93ZXIvcG93ZXJfc3VwcGx5X2NvcmUuYwppbmRleCA5MTYwNmJiLi45NzBmNzMzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Bvd2VyL3Bvd2VyX3N1cHBseV9jb3JlLmMKKysrIGIvZHJpdmVycy9wb3dlci9wb3dlcl9zdXBwbHlfY29yZS5jCkBAIC0xOTAsMTAgKzE5MCwxMCBAQAogCWdvdG8gc3VjY2VzczsKIAogY3JlYXRlX3RyaWdnZXJzX2ZhaWxlZDoKLQlkZXZpY2VfdW5yZWdpc3Rlcihwc3ktPmRldik7CisJZGV2aWNlX2RlbChkZXYpOwoga29iamVjdF9zZXRfbmFtZV9mYWlsZWQ6CiBkZXZpY2VfYWRkX2ZhaWxlZDoKLQlrZnJlZShkZXYpOworCXB1dF9kZXZpY2UoZGV2KTsKIHN1Y2Nlc3M6CiAJcmV0dXJuIHJjOwogfQpAQCAtMjAxLDcgKzIwMSw3IEBACiAKIHZvaWQgcG93ZXJfc3VwcGx5X3VucmVnaXN0ZXIoc3RydWN0IHBvd2VyX3N1cHBseSAqcHN5KQogewotCWZsdXNoX3NjaGVkdWxlZF93b3JrKCk7CisJY2FuY2VsX3dvcmtfc3luYygmcHN5LT5jaGFuZ2VkX3dvcmspOwogCXBvd2VyX3N1cHBseV9yZW1vdmVfdHJpZ2dlcnMocHN5KTsKIAlkZXZpY2VfdW5yZWdpc3Rlcihwc3ktPmRldik7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Bvd2VyL3MzY19hZGNfYmF0dGVyeS5jIGIvZHJpdmVycy9wb3dlci9zM2NfYWRjX2JhdHRlcnkuYwppbmRleCA0YThhZTM5Li40MjU1ZjIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Bvd2VyL3MzY19hZGNfYmF0dGVyeS5jCisrKyBiL2RyaXZlcnMvcG93ZXIvczNjX2FkY19iYXR0ZXJ5LmMKQEAgLTExMiw2ICsxMTIsMTMgQEAKIAlyZXR1cm4gdm9sdF92YWwgKyBjdXJfdmFsICogaW1wZWRhbmNlIC8gMTAwMDsKIH0KIAorc3RhdGljIGludCBjaGFyZ2VfZmluaXNoZWQoc3RydWN0IHMzY19hZGNfYmF0ICpiYXQpCit7CisJcmV0dXJuIGJhdC0+cGRhdGEtPmdwaW9faW52ZXJ0ZWQgPworCQkhZ3Bpb19nZXRfdmFsdWUoYmF0LT5wZGF0YS0+Z3Bpb19jaGFyZ2VfZmluaXNoZWQpIDoKKwkJZ3Bpb19nZXRfdmFsdWUoYmF0LT5wZGF0YS0+Z3Bpb19jaGFyZ2VfZmluaXNoZWQpOworfQorCiBzdGF0aWMgaW50IHMzY19hZGNfYmF0X2dldF9wcm9wZXJ0eShzdHJ1Y3QgcG93ZXJfc3VwcGx5ICpwc3ksCiAJCQkJICAgIGVudW0gcG93ZXJfc3VwcGx5X3Byb3BlcnR5IHBzcCwKIAkJCQkgICAgdW5pb24gcG93ZXJfc3VwcGx5X3Byb3B2YWwgKnZhbCkKQEAgLTE0MCw3ICsxNDcsNyBAQAogCiAJaWYgKGJhdC0+Y2FibGVfcGx1Z2dlZCAmJgogCQkoKGJhdC0+cGRhdGEtPmdwaW9fY2hhcmdlX2ZpbmlzaGVkIDwgMCkgfHwKLQkJIWdwaW9fZ2V0X3ZhbHVlKGJhdC0+cGRhdGEtPmdwaW9fY2hhcmdlX2ZpbmlzaGVkKSkpIHsKKwkJIWNoYXJnZV9maW5pc2hlZChiYXQpKSkgewogCQlsdXQgPSBiYXQtPnBkYXRhLT5sdXRfYWNpbjsKIAkJbHV0X3NpemUgPSBiYXQtPnBkYXRhLT5sdXRfYWNpbl9jbnQ7CiAJfQpAQCAtMjM2LDggKzI0Myw3IEBACiAJCX0KIAl9IGVsc2UgewogCQlpZiAoKGJhdC0+cGRhdGEtPmdwaW9fY2hhcmdlX2ZpbmlzaGVkID49IDApICYmIGlzX3BsdWdnZWQpIHsKLQkJCWlzX2NoYXJnZWQgPSBncGlvX2dldF92YWx1ZSgKLQkJCQltYWluX2JhdC5wZGF0YS0+Z3Bpb19jaGFyZ2VfZmluaXNoZWQpOworCQkJaXNfY2hhcmdlZCA9IGNoYXJnZV9maW5pc2hlZCgmbWFpbl9iYXQpOwogCQkJaWYgKGlzX2NoYXJnZWQpIHsKIAkJCQlpZiAoYmF0LT5wZGF0YS0+ZGlzYWJsZV9jaGFyZ2VyKQogCQkJCQliYXQtPnBkYXRhLT5kaXNhYmxlX2NoYXJnZXIoKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcG93ZXIvdG9zYV9iYXR0ZXJ5LmMgYi9kcml2ZXJzL3Bvd2VyL3Rvc2FfYmF0dGVyeS5jCmluZGV4IGVlMDQ5MzYuLjUzZjBkMzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcG93ZXIvdG9zYV9iYXR0ZXJ5LmMKKysrIGIvZHJpdmVycy9wb3dlci90b3NhX2JhdHRlcnkuYwpAQCAtMzMyLDcgKzMzMiw3IEBACiBzdGF0aWMgaW50IHRvc2FfYmF0X3N1c3BlbmQoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqZGV2LCBwbV9tZXNzYWdlX3Qgc3RhdGUpCiB7CiAJLyogZmx1c2ggYWxsIHBlbmRpbmcgc3RhdHVzIHVwZGF0ZXMgKi8KLQlmbHVzaF9zY2hlZHVsZWRfd29yaygpOworCWZsdXNoX3dvcmtfc3luYygmYmF0X3dvcmspOwogCXJldHVybiAwOwogfQogCkBAIC00MjIsNyArNDIyLDcgQEAKIGVycl9wc3lfcmVnX21haW46CiAKIAkvKiBzZWUgY29tbWVudCBpbiB0b3NhX2JhdF9yZW1vdmUgKi8KLQlmbHVzaF9zY2hlZHVsZWRfd29yaygpOworCWNhbmNlbF93b3JrX3N5bmMoJmJhdF93b3JrKTsKIAogCWktLTsKIGVycl9ncGlvOgpAQCAtNDQ1LDEyICs0NDUsMTEgQEAKIAlwb3dlcl9zdXBwbHlfdW5yZWdpc3RlcigmdG9zYV9iYXRfbWFpbi5wc3kpOwogCiAJLyoKLQkgKiBub3cgZmx1c2ggYWxsIHBlbmRpbmcgd29yay4KLQkgKiB3ZSB3b24ndCBnZXQgYW55IG1vcmUgc2NoZWR1bGVzLCBzaW5jZSBhbGwKLQkgKiBzb3VyY2VzIChpc3IgYW5kIGV4dGVybmFsX3Bvd2VyX2NoYW5nZWQpCi0JICogYXJlIHVucmVnaXN0ZXJlZCBub3cuCisJICogTm93IGNhbmNlbCB0aGUgYmF0X3dvcmsuICBXZSB3b24ndCBnZXQgYW55IG1vcmUgc2NoZWR1bGVzLAorCSAqIHNpbmNlIGFsbCBzb3VyY2VzIChpc3IgYW5kIGV4dGVybmFsX3Bvd2VyX2NoYW5nZWQpIGFyZQorCSAqIHVucmVnaXN0ZXJlZCBub3cuCiAJICovCi0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKKwljYW5jZWxfd29ya19zeW5jKCZiYXRfd29yayk7CiAKIAlmb3IgKGkgPSBBUlJBWV9TSVpFKGdwaW9zKSAtIDE7IGkgPj0gMDsgaS0tKQogCQlncGlvX2ZyZWUoZ3Bpb3NbaV0uZ3Bpbyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Bvd2VyL3dtOTd4eF9iYXR0ZXJ5LmMgYi9kcml2ZXJzL3Bvd2VyL3dtOTd4eF9iYXR0ZXJ5LmMKaW5kZXggNTA3MWQ4NS4uMTU2NTU5ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9wb3dlci93bTk3eHhfYmF0dGVyeS5jCisrKyBiL2RyaXZlcnMvcG93ZXIvd205N3h4X2JhdHRlcnkuYwpAQCAtMTQ3LDcgKzE0Nyw3IEBACiAjaWZkZWYgQ09ORklHX1BNCiBzdGF0aWMgaW50IHdtOTd4eF9iYXRfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCiB7Ci0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKKwlmbHVzaF93b3JrX3N5bmMoJmJhdF93b3JrKTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtMjczLDcgKzI3Myw3IEBACiAJCWZyZWVfaXJxKGdwaW9fdG9faXJxKHBkYXRhLT5jaGFyZ2VfZ3BpbyksIGRldik7CiAJCWdwaW9fZnJlZShwZGF0YS0+Y2hhcmdlX2dwaW8pOwogCX0KLQlmbHVzaF9zY2hlZHVsZWRfd29yaygpOworCWNhbmNlbF93b3JrX3N5bmMoJmJhdF93b3JrKTsKIAlwb3dlcl9zdXBwbHlfdW5yZWdpc3RlcigmYmF0X3BzKTsKIAlrZnJlZShwcm9wKTsKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcG93ZXIvejJfYmF0dGVyeS5jIGIvZHJpdmVycy9wb3dlci96Ml9iYXR0ZXJ5LmMKaW5kZXggODUwNjRhOS4uZTVlZDUyZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9wb3dlci96Ml9iYXR0ZXJ5LmMKKysrIGIvZHJpdmVycy9wb3dlci96Ml9iYXR0ZXJ5LmMKQEAgLTI1NCw3ICsyNTQsNyBAQAogCXN0cnVjdCB6Ml9jaGFyZ2VyICpjaGFyZ2VyID0gaTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7CiAJc3RydWN0IHoyX2JhdHRlcnlfaW5mbyAqaW5mbyA9IGNoYXJnZXItPmluZm87CiAKLQlmbHVzaF9zY2hlZHVsZWRfd29yaygpOworCWNhbmNlbF93b3JrX3N5bmMoJmNoYXJnZXItPmJhdF93b3JrKTsKIAlwb3dlcl9zdXBwbHlfdW5yZWdpc3RlcigmY2hhcmdlci0+YmF0dF9wcyk7CiAKIAlrZnJlZShjaGFyZ2VyLT5iYXR0X3BzLnByb3BlcnRpZXMpOwpAQCAtMjcxLDcgKzI3MSw5IEBACiAjaWZkZWYgQ09ORklHX1BNCiBzdGF0aWMgaW50IHoyX2JhdHRfc3VzcGVuZChzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LCBwbV9tZXNzYWdlX3Qgc3RhdGUpCiB7Ci0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKKwlzdHJ1Y3QgejJfY2hhcmdlciAqY2hhcmdlciA9IGkyY19nZXRfY2xpZW50ZGF0YShjbGllbnQpOworCisJZmx1c2hfd29ya19zeW5jKCZjaGFyZ2VyLT5iYXRfd29yayk7CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcHBzL2NsaWVudHMvcHBzLWt0aW1lci5jIGIvZHJpdmVycy9wcHMvY2xpZW50cy9wcHMta3RpbWVyLmMKaW5kZXggMjcyODQ2OS4uODI1ODNiMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9wcHMvY2xpZW50cy9wcHMta3RpbWVyLmMKKysrIGIvZHJpdmVycy9wcHMvY2xpZW50cy9wcHMta3RpbWVyLmMKQEAgLTQ2LDggKzQ2LDYgQEAKIAkvKiBGaXJzdCBvZiBhbGwgd2UgZ2V0IHRoZSB0aW1lIHN0YW1wLi4uICovCiAJcHBzX2dldF90cygmdHMpOwogCi0JZGV2X2luZm8ocHBzLT5kZXYsICJQUFMgZXZlbnQgYXQgJWx1XG4iLCBqaWZmaWVzKTsKLQogCXBwc19ldmVudChwcHMsICZ0cywgUFBTX0NBUFRVUkVBU1NFUlQsIE5VTEwpOwogCiAJbW9kX3RpbWVyKCZrdGltZXIsIGppZmZpZXMgKyBIWik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Bwcy9jbGllbnRzL3Bwc19wYXJwb3J0LmMgYi9kcml2ZXJzL3Bwcy9jbGllbnRzL3Bwc19wYXJwb3J0LmMKaW5kZXggMzIyMjFlZi4uYzU3MWQ2ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9wcHMvY2xpZW50cy9wcHNfcGFycG9ydC5jCisrKyBiL2RyaXZlcnMvcHBzL2NsaWVudHMvcHBzX3BhcnBvcnQuYwpAQCAtMTYzLDcgKzE2Myw3IEBACiAJfQogCiAJZGV2aWNlLT5wYXJkZXYgPSBwYXJwb3J0X3JlZ2lzdGVyX2RldmljZShwb3J0LCBLQlVJTERfTU9ETkFNRSwKLQkJCU5VTEwsIE5VTEwsIHBhcnBvcnRfaXJxLCAwLCBkZXZpY2UpOworCQkJTlVMTCwgTlVMTCwgcGFycG9ydF9pcnEsIFBBUlBPUlRfRkxBR19FWENMLCBkZXZpY2UpOwogCWlmICghZGV2aWNlLT5wYXJkZXYpIHsKIAkJcHJfZXJyKCJjb3VsZG4ndCByZWdpc3RlciB3aXRoICVzXG4iLCBwb3J0LT5uYW1lKTsKIAkJZ290byBlcnJfZnJlZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcHBzL2dlbmVyYXRvcnMvcHBzX2dlbl9wYXJwb3J0LmMgYi9kcml2ZXJzL3Bwcy9nZW5lcmF0b3JzL3Bwc19nZW5fcGFycG9ydC5jCmluZGV4IDVjMzJmOGQuLmI5M2FmM2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcHBzL2dlbmVyYXRvcnMvcHBzX2dlbl9wYXJwb3J0LmMKKysrIGIvZHJpdmVycy9wcHMvZ2VuZXJhdG9ycy9wcHNfZ2VuX3BhcnBvcnQuYwpAQCAtMTk4LDcgKzE5OCw3IEBACiAJfQogCiAJZGV2aWNlLnBhcmRldiA9IHBhcnBvcnRfcmVnaXN0ZXJfZGV2aWNlKHBvcnQsIEtCVUlMRF9NT0ROQU1FLAotCQkJTlVMTCwgTlVMTCwgTlVMTCwgMCwgJmRldmljZSk7CisJCQlOVUxMLCBOVUxMLCBOVUxMLCBQQVJQT1JUX0ZMQUdfRVhDTCwgJmRldmljZSk7CiAJaWYgKCFkZXZpY2UucGFyZGV2KSB7CiAJCXByX2VycigiY291bGRuJ3QgcmVnaXN0ZXIgd2l0aCAlc1xuIiwgcG9ydC0+bmFtZSk7CiAJCXJldHVybjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcmFwaWRpby9yaW8tc2Nhbi5jIGIvZHJpdmVycy9yYXBpZGlvL3Jpby1zY2FuLmMKaW5kZXggNDY3ZTgyYi4uYTUwMzkxYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9yYXBpZGlvL3Jpby1zY2FuLmMKKysrIGIvZHJpdmVycy9yYXBpZGlvL3Jpby1zY2FuLmMKQEAgLTk0Myw2ICs5NDMsOCBAQAogICogQHBvcnQ6IE1hc3RlciBwb3J0IHRvIHNlbmQgdHJhbnNhY3Rpb25zCiAgKiBAZGVzdGlkOiBDdXJyZW50IGRlc3RpbmF0aW9uIElEIGluIG5ldHdvcmsKICAqIEBob3Bjb3VudDogTnVtYmVyIG9mIGhvcHMgaW50byB0aGUgbmV0d29yaworICogQHByZXY6IHByZXZpb3VzIHJpb19kZXYKKyAqIEBwcmV2X3BvcnQ6IHByZXZpb3VzIHBvcnQgbnVtYmVyCiAgKgogICogUmVjdXJzaXZlbHkgZGlzY292ZXJzIGEgUklPIG5ldHdvcmsuICBUcmFuc2FjdGlvbnMgYXJlIHNlbnQgdmlhIHRoZQogICogbWFzdGVyIHBvcnQgcGFzc2VkIGluIEBwb3J0LgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9yZWd1bGF0b3IvbWF4ODk5OC5jIGIvZHJpdmVycy9yZWd1bGF0b3IvbWF4ODk5OC5jCmluZGV4IDc1NjhkZjYuLjBlYzQ5Y2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcmVndWxhdG9yL21heDg5OTguYworKysgYi9kcml2ZXJzL3JlZ3VsYXRvci9tYXg4OTk4LmMKQEAgLTQyNCw2ICs0MjQsOSBAQAogCQkJCX0KIAkJCX0KIAorCQkJaWYgKHBkYXRhLT5idWNrX3ZvbHRhZ2VfbG9jaykKKwkJCQlyZXR1cm4gLUVJTlZBTDsKKwogCQkJLyogbm8gcHJlZGVmaW5lIHJlZ3VsYXRvciBmb3VuZCAqLwogCQkJbWF4ODk5OC0+YnVjazFfaWR4ID0gKGJ1Y2sxX2xhc3RfdmFsICUgMikgKyAyOwogCQkJZGV2X2RiZyhtYXg4OTk4LT5kZXYsICJtYXg4OTk4LT5idWNrMV9pZHg6JWRcbiIsCkBAIC00NTEsMTggKzQ1NCwyNiBAQAogCQkJIkJVQ0syLCBpOiVkIGJ1Y2syX3ZvbDE6JWQsIGJ1Y2syX3ZvbDI6JWRcbiIKIAkJCSwgaSwgbWF4ODk5OC0+YnVjazJfdm9sWzBdLCBtYXg4OTk4LT5idWNrMl92b2xbMV0pOwogCQlpZiAoZ3Bpb19pc192YWxpZChwZGF0YS0+YnVjazJfc2V0MykpIHsKLQkJCWlmIChtYXg4OTk4LT5idWNrMl92b2xbMF0gPT0gaSkgewotCQkJCW1heDg5OTgtPmJ1Y2sxX2lkeCA9IDA7Ci0JCQkJYnVjazJfZ3Bpb19zZXQocGRhdGEtPmJ1Y2syX3NldDMsIDApOwotCQkJfSBlbHNlIHsKLQkJCQltYXg4OTk4LT5idWNrMV9pZHggPSAxOwotCQkJCXJldCA9IG1heDg5OThfZ2V0X3ZvbHRhZ2VfcmVnaXN0ZXIocmRldiwgJnJlZywKLQkJCQkJCQkJICAgJnNoaWZ0LAotCQkJCQkJCQkgICAmbWFzayk7Ci0JCQkJcmV0ID0gbWF4ODk5OF93cml0ZV9yZWcoaTJjLCByZWcsIGkpOwotCQkJCW1heDg5OTgtPmJ1Y2syX3ZvbFsxXSA9IGk7Ci0JCQkJYnVjazJfZ3Bpb19zZXQocGRhdGEtPmJ1Y2syX3NldDMsIDEpOworCisJCQkvKiBjaGVjayBpZiByZXF1ZXN0ZWQgdm9sdGFnZSAqLworCQkJLyogdmFsdWUgaXMgYWxyZWFkeSBkZWZpbmVkICovCisJCQlmb3IgKGogPSAwOyBqIDwgQVJSQVlfU0laRShtYXg4OTk4LT5idWNrMl92b2wpOyBqKyspIHsKKwkJCQlpZiAobWF4ODk5OC0+YnVjazJfdm9sW2pdID09IGkpIHsKKwkJCQkJbWF4ODk5OC0+YnVjazJfaWR4ID0gajsKKwkJCQkJYnVjazJfZ3Bpb19zZXQocGRhdGEtPmJ1Y2syX3NldDMsIGopOworCQkJCQlnb3RvIGJ1Y2syX2V4aXQ7CisJCQkJfQogCQkJfQorCisJCQlpZiAocGRhdGEtPmJ1Y2tfdm9sdGFnZV9sb2NrKQorCQkJCXJldHVybiAtRUlOVkFMOworCisJCQltYXg4OTk4X2dldF92b2x0YWdlX3JlZ2lzdGVyKHJkZXYsCisJCQkJCSZyZWcsICZzaGlmdCwgJm1hc2spOworCQkJcmV0ID0gbWF4ODk5OF93cml0ZV9yZWcoaTJjLCByZWcsIGkpOworCQkJbWF4ODk5OC0+YnVjazJfdm9sW21heDg5OTgtPmJ1Y2syX2lkeF0gPSBpOworCQkJYnVjazJfZ3Bpb19zZXQocGRhdGEtPmJ1Y2syX3NldDMsIG1heDg5OTgtPmJ1Y2syX2lkeCk7CitidWNrMl9leGl0OgogCQkJZGV2X2RiZyhtYXg4OTk4LT5kZXYsICIlczogU0VUMzolZFxuIiwgaTJjLT5uYW1lLAogCQkJCWdwaW9fZ2V0X3ZhbHVlKHBkYXRhLT5idWNrMl9zZXQzKSk7CiAJCX0gZWxzZSB7CkBAIC03MDcsNiArNzE4LDkgQEAKIAlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBtYXg4OTk4KTsKIAlpMmMgPSBtYXg4OTk4LT5pb2Rldi0+aTJjOwogCisJbWF4ODk5OC0+YnVjazFfaWR4ID0gcGRhdGEtPmJ1Y2sxX2RlZmF1bHRfaWR4OworCW1heDg5OTgtPmJ1Y2syX2lkeCA9IHBkYXRhLT5idWNrMl9kZWZhdWx0X2lkeDsKKwogCS8qIE5PVEU6ICovCiAJLyogRm9yIHVudXNlZCBHUElPIE5PVCBtYXJrZWQgYXMgLTEgKHRoZXJlb2YgZXF1YWwgdG8gMCkgIFdBUk5fT04gKi8KIAkvKiB3aWxsIGJlIGRpc3BsYXllZCAqLwpAQCAtNzM5LDIzICs3NTMsNDYgQEAKIAkJaSA9IDA7CiAJCXdoaWxlIChidWNrMTJfdm9sdGFnZV9tYXBfZGVzYy5taW4gKwogCQkgICAgICAgYnVjazEyX3ZvbHRhZ2VfbWFwX2Rlc2Muc3RlcCppCi0JCSAgICAgICAhPSAocGRhdGEtPmJ1Y2sxX21heF92b2x0YWdlMSAvIDEwMDApKQorCQkgICAgICAgPCAocGRhdGEtPmJ1Y2sxX3ZvbHRhZ2UxIC8gMTAwMCkpCiAJCQlpKys7Ci0JCXByaW50ayhLRVJOX0VSUiAiaTolZCwgYnVjazFfaWR4OiVkXG4iLCBpLCBtYXg4OTk4LT5idWNrMV9pZHgpOwogCQltYXg4OTk4LT5idWNrMV92b2xbMF0gPSBpOwogCQlyZXQgPSBtYXg4OTk4X3dyaXRlX3JlZyhpMmMsIE1BWDg5OThfUkVHX0JVQ0sxX1ZPTFRBR0UxLCBpKTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7CiAKIAkJLyogU2V0IHByZWRlZmluZWQgdmFsdWUgZm9yIEJVQ0sxIHJlZ2lzdGVyIDIgKi8KIAkJaSA9IDA7CiAJCXdoaWxlIChidWNrMTJfdm9sdGFnZV9tYXBfZGVzYy5taW4gKwogCQkgICAgICAgYnVjazEyX3ZvbHRhZ2VfbWFwX2Rlc2Muc3RlcCppCi0JCSAgICAgICAhPSAocGRhdGEtPmJ1Y2sxX21heF92b2x0YWdlMiAvIDEwMDApKQorCQkgICAgICAgPCAocGRhdGEtPmJ1Y2sxX3ZvbHRhZ2UyIC8gMTAwMCkpCiAJCQlpKys7CiAKIAkJbWF4ODk5OC0+YnVjazFfdm9sWzFdID0gaTsKLQkJcHJpbnRrKEtFUk5fRVJSICJpOiVkLCBidWNrMV9pZHg6JWRcbiIsIGksIG1heDg5OTgtPmJ1Y2sxX2lkeCk7Ci0JCXJldCA9IG1heDg5OThfd3JpdGVfcmVnKGkyYywgTUFYODk5OF9SRUdfQlVDSzFfVk9MVEFHRTIsIGkpCi0JCQkrIHJldDsKKwkJcmV0ID0gbWF4ODk5OF93cml0ZV9yZWcoaTJjLCBNQVg4OTk4X1JFR19CVUNLMV9WT0xUQUdFMiwgaSk7CisJCWlmIChyZXQpCisJCQlyZXR1cm4gcmV0OworCisJCS8qIFNldCBwcmVkZWZpbmVkIHZhbHVlIGZvciBCVUNLMSByZWdpc3RlciAzICovCisJCWkgPSAwOworCQl3aGlsZSAoYnVjazEyX3ZvbHRhZ2VfbWFwX2Rlc2MubWluICsKKwkJICAgICAgIGJ1Y2sxMl92b2x0YWdlX21hcF9kZXNjLnN0ZXAqaQorCQkgICAgICAgPCAocGRhdGEtPmJ1Y2sxX3ZvbHRhZ2UzIC8gMTAwMCkpCisJCQlpKys7CisKKwkJbWF4ODk5OC0+YnVjazFfdm9sWzJdID0gaTsKKwkJcmV0ID0gbWF4ODk5OF93cml0ZV9yZWcoaTJjLCBNQVg4OTk4X1JFR19CVUNLMV9WT0xUQUdFMywgaSk7CisJCWlmIChyZXQpCisJCQlyZXR1cm4gcmV0OworCisJCS8qIFNldCBwcmVkZWZpbmVkIHZhbHVlIGZvciBCVUNLMSByZWdpc3RlciA0ICovCisJCWkgPSAwOworCQl3aGlsZSAoYnVjazEyX3ZvbHRhZ2VfbWFwX2Rlc2MubWluICsKKwkJICAgICAgIGJ1Y2sxMl92b2x0YWdlX21hcF9kZXNjLnN0ZXAqaQorCQkgICAgICAgPCAocGRhdGEtPmJ1Y2sxX3ZvbHRhZ2U0IC8gMTAwMCkpCisJCQlpKys7CisKKwkJbWF4ODk5OC0+YnVjazFfdm9sWzNdID0gaTsKKwkJcmV0ID0gbWF4ODk5OF93cml0ZV9yZWcoaTJjLCBNQVg4OTk4X1JFR19CVUNLMV9WT0xUQUdFNCwgaSk7CiAJCWlmIChyZXQpCiAJCQlyZXR1cm4gcmV0OwogCkBAIC03NzIsMTggKzgwOSwyOCBAQAogCQlncGlvX2RpcmVjdGlvbl9vdXRwdXQocGRhdGEtPmJ1Y2syX3NldDMsCiAJCQkJICAgICAgbWF4ODk5OC0+YnVjazJfaWR4ICYgMHgxKTsKIAotCQkvKiBCVUNLMiAtIHNldCBwcmVzZXQgZGVmYXVsdCB2b2x0YWdlIHZhbHVlIHRvIGJ1Y2syX3ZvbFswXSAqLworCQkvKiBCVUNLMiByZWdpc3RlciAxICovCiAJCWkgPSAwOwogCQl3aGlsZSAoYnVjazEyX3ZvbHRhZ2VfbWFwX2Rlc2MubWluICsKIAkJICAgICAgIGJ1Y2sxMl92b2x0YWdlX21hcF9kZXNjLnN0ZXAqaQotCQkgICAgICAgIT0gKHBkYXRhLT5idWNrMl9tYXhfdm9sdGFnZSAvIDEwMDApKQorCQkgICAgICAgPCAocGRhdGEtPmJ1Y2syX3ZvbHRhZ2UxIC8gMTAwMCkpCiAJCQlpKys7Ci0JCXByaW50ayhLRVJOX0VSUiAiaTolZCwgYnVjazJfaWR4OiVkXG4iLCBpLCBtYXg4OTk4LT5idWNrMl9pZHgpOwogCQltYXg4OTk4LT5idWNrMl92b2xbMF0gPSBpOwogCQlyZXQgPSBtYXg4OTk4X3dyaXRlX3JlZyhpMmMsIE1BWDg5OThfUkVHX0JVQ0syX1ZPTFRBR0UxLCBpKTsKIAkJaWYgKHJldCkKIAkJCXJldHVybiByZXQ7CiAKKwkJLyogQlVDSzIgcmVnaXN0ZXIgMiAqLworCQlpID0gMDsKKwkJd2hpbGUgKGJ1Y2sxMl92b2x0YWdlX21hcF9kZXNjLm1pbiArCisJCSAgICAgICBidWNrMTJfdm9sdGFnZV9tYXBfZGVzYy5zdGVwKmkKKwkJICAgICAgIDwgKHBkYXRhLT5idWNrMl92b2x0YWdlMiAvIDEwMDApKQorCQkJaSsrOworCQlwcmludGsoS0VSTl9FUlIgImkyOiVkLCBidWNrMl9pZHg6JWRcbiIsIGksIG1heDg5OTgtPmJ1Y2syX2lkeCk7CisJCW1heDg5OTgtPmJ1Y2syX3ZvbFsxXSA9IGk7CisJCXJldCA9IG1heDg5OThfd3JpdGVfcmVnKGkyYywgTUFYODk5OF9SRUdfQlVDSzJfVk9MVEFHRTIsIGkpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKIAl9CiAKIAlmb3IgKGkgPSAwOyBpIDwgcGRhdGEtPm51bV9yZWd1bGF0b3JzOyBpKyspIHsKQEAgLTgzNSw2ICs4ODIsMTIgQEAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIGNvbnN0IHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2VfaWQgbWF4ODk5OF9wbWljX2lkW10gPSB7CisJeyAibWF4ODk5OC1wbWljIiwgVFlQRV9NQVg4OTk4IH0sCisJeyAibHAzOTc0LXBtaWMiLCBUWVBFX0xQMzk3NCB9LAorCXsgfQorfTsKKwogc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgbWF4ODk5OF9wbWljX2RyaXZlciA9IHsKIAkuZHJpdmVyID0gewogCQkubmFtZSA9ICJtYXg4OTk4LXBtaWMiLApAQCAtODQyLDYgKzg5NSw3IEBACiAJfSwKIAkucHJvYmUgPSBtYXg4OTk4X3BtaWNfcHJvYmUsCiAJLnJlbW92ZSA9IF9fZGV2ZXhpdF9wKG1heDg5OThfcG1pY19yZW1vdmUpLAorCS5pZF90YWJsZSA9IG1heDg5OThfcG1pY19pZCwKIH07CiAKIHN0YXRpYyBpbnQgX19pbml0IG1heDg5OThfcG1pY19pbml0KHZvaWQpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3J0Yy9LY29uZmlnIGIvZHJpdmVycy9ydGMvS2NvbmZpZwppbmRleCA0OTQxY2FkLi5jZGQ5NzE5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3J0Yy9LY29uZmlnCisrKyBiL2RyaXZlcnMvcnRjL0tjb25maWcKQEAgLTk3LDE4ICs5Nyw2IEBACiAKIAkgIElmIHVuc3VyZSwgc2F5IFkuCiAKLWNvbmZpZyBSVENfSU5URl9ERVZfVUlFX0VNVUwKLQlib29sICJSVEMgVUlFIGVtdWxhdGlvbiBvbiBkZXYgaW50ZXJmYWNlIgotCWRlcGVuZHMgb24gUlRDX0lOVEZfREVWCi0JaGVscAotCSAgUHJvdmlkZXMgYW4gZW11bGF0aW9uIGZvciBSVENfVUlFIGlmIHRoZSB1bmRlcmx5aW5nIHJ0YyBjaGlwCi0JICBkcml2ZXIgZG9lcyBub3QgZXhwb3NlIFJUQ19VSUUgaW9jdGxzLiBUaG9zZSByZXF1ZXN0cyBnZW5lcmF0ZQotCSAgb25jZS1wZXItc2Vjb25kIHVwZGF0ZSBpbnRlcnJ1cHRzLCB1c2VkIGZvciBzeW5jaHJvbml6YXRpb24uCi0KLQkgIFRoZSBlbXVsYXRpb24gY29kZSB3aWxsIHJlYWQgdGhlIHRpbWUgZnJvbSB0aGUgaGFyZHdhcmUKLQkgIGNsb2NrIHNldmVyYWwgdGltZXMgcGVyIHNlY29uZCwgcGxlYXNlIGVuYWJsZSB0aGlzIG9wdGlvbgotCSAgb25seSBpZiB5b3Uga25vdyB0aGF0IHlvdSByZWFsbHkgbmVlZCBpdC4KLQogY29uZmlnIFJUQ19EUlZfVEVTVAogCXRyaXN0YXRlICJUZXN0IGRyaXZlci9kZXZpY2UiCiAJaGVscApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ydGMvY2xhc3MuYyBiL2RyaXZlcnMvcnRjL2NsYXNzLmMKaW5kZXggOTU4M2NiYy4uYzQwNGI2MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ydGMvY2xhc3MuYworKysgYi9kcml2ZXJzL3J0Yy9jbGFzcy5jCkBAIC0xNDMsNiArMTQzLDcgQEAKIAlydGMtPmlkID0gaWQ7CiAJcnRjLT5vcHMgPSBvcHM7CiAJcnRjLT5vd25lciA9IG93bmVyOworCXJ0Yy0+aXJxX2ZyZXEgPSAxOwogCXJ0Yy0+bWF4X3VzZXJfZnJlcSA9IDY0OwogCXJ0Yy0+ZGV2LnBhcmVudCA9IGRldjsKIAlydGMtPmRldi5jbGFzcyA9IHJ0Y19jbGFzczsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcnRjL2ludGVyZmFjZS5jIGIvZHJpdmVycy9ydGMvaW50ZXJmYWNlLmMKaW5kZXggOTAzODRiOS4uYTBjMDE5NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ydGMvaW50ZXJmYWNlLmMKKysrIGIvZHJpdmVycy9ydGMvaW50ZXJmYWNlLmMKQEAgLTE2LDYgKzE2LDkgQEAKICNpbmNsdWRlIDxsaW51eC9sb2cyLmg+CiAjaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+CiAKK3N0YXRpYyBpbnQgcnRjX3RpbWVyX2VucXVldWUoc3RydWN0IHJ0Y19kZXZpY2UgKnJ0Yywgc3RydWN0IHJ0Y190aW1lciAqdGltZXIpOworc3RhdGljIHZvaWQgcnRjX3RpbWVyX3JlbW92ZShzdHJ1Y3QgcnRjX2RldmljZSAqcnRjLCBzdHJ1Y3QgcnRjX3RpbWVyICp0aW1lcik7CisKIHN0YXRpYyBpbnQgX19ydGNfcmVhZF90aW1lKHN0cnVjdCBydGNfZGV2aWNlICpydGMsIHN0cnVjdCBydGNfdGltZSAqdG0pCiB7CiAJaW50IGVycjsKQEAgLTEyMCwxMiArMTIzLDE4IEBACiAJZXJyID0gbXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZydGMtPm9wc19sb2NrKTsKIAlpZiAoZXJyKQogCQlyZXR1cm4gZXJyOwotCWFsYXJtLT5lbmFibGVkID0gcnRjLT5haWVfdGltZXIuZW5hYmxlZDsKLQlpZiAoYWxhcm0tPmVuYWJsZWQpCisJaWYgKHJ0Yy0+b3BzID09IE5VTEwpCisJCWVyciA9IC1FTk9ERVY7CisJZWxzZSBpZiAoIXJ0Yy0+b3BzLT5yZWFkX2FsYXJtKQorCQllcnIgPSAtRUlOVkFMOworCWVsc2UgeworCQltZW1zZXQoYWxhcm0sIDAsIHNpemVvZihzdHJ1Y3QgcnRjX3drYWxybSkpOworCQlhbGFybS0+ZW5hYmxlZCA9IHJ0Yy0+YWllX3RpbWVyLmVuYWJsZWQ7CiAJCWFsYXJtLT50aW1lID0gcnRjX2t0aW1lX3RvX3RtKHJ0Yy0+YWllX3RpbWVyLm5vZGUuZXhwaXJlcyk7CisJfQogCW11dGV4X3VubG9jaygmcnRjLT5vcHNfbG9jayk7CiAKLQlyZXR1cm4gMDsKKwlyZXR1cm4gZXJyOwogfQogRVhQT1JUX1NZTUJPTF9HUEwocnRjX3JlYWRfYWxhcm0pOwogCkBAIC0xNzUsMTYgKzE4NCwxNCBAQAogCQlyZXR1cm4gZXJyOwogCWlmIChydGMtPmFpZV90aW1lci5lbmFibGVkKSB7CiAJCXJ0Y190aW1lcl9yZW1vdmUocnRjLCAmcnRjLT5haWVfdGltZXIpOwotCQlydGMtPmFpZV90aW1lci5lbmFibGVkID0gMDsKIAl9CiAJcnRjLT5haWVfdGltZXIubm9kZS5leHBpcmVzID0gcnRjX3RtX3RvX2t0aW1lKGFsYXJtLT50aW1lKTsKIAlydGMtPmFpZV90aW1lci5wZXJpb2QgPSBrdGltZV9zZXQoMCwgMCk7CiAJaWYgKGFsYXJtLT5lbmFibGVkKSB7Ci0JCXJ0Yy0+YWllX3RpbWVyLmVuYWJsZWQgPSAxOwotCQlydGNfdGltZXJfZW5xdWV1ZShydGMsICZydGMtPmFpZV90aW1lcik7CisJCWVyciA9IHJ0Y190aW1lcl9lbnF1ZXVlKHJ0YywgJnJ0Yy0+YWllX3RpbWVyKTsKIAl9CiAJbXV0ZXhfdW5sb2NrKCZydGMtPm9wc19sb2NrKTsKLQlyZXR1cm4gMDsKKwlyZXR1cm4gZXJyOwogfQogRVhQT1JUX1NZTUJPTF9HUEwocnRjX3NldF9hbGFybSk7CiAKQEAgLTE5NSwxNSArMjAyLDE1IEBACiAJCXJldHVybiBlcnI7CiAKIAlpZiAocnRjLT5haWVfdGltZXIuZW5hYmxlZCAhPSBlbmFibGVkKSB7Ci0JCWlmIChlbmFibGVkKSB7Ci0JCQlydGMtPmFpZV90aW1lci5lbmFibGVkID0gMTsKLQkJCXJ0Y190aW1lcl9lbnF1ZXVlKHJ0YywgJnJ0Yy0+YWllX3RpbWVyKTsKLQkJfSBlbHNlIHsKKwkJaWYgKGVuYWJsZWQpCisJCQllcnIgPSBydGNfdGltZXJfZW5xdWV1ZShydGMsICZydGMtPmFpZV90aW1lcik7CisJCWVsc2UKIAkJCXJ0Y190aW1lcl9yZW1vdmUocnRjLCAmcnRjLT5haWVfdGltZXIpOwotCQkJcnRjLT5haWVfdGltZXIuZW5hYmxlZCA9IDA7Ci0JCX0KIAl9CiAKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOworCiAJaWYgKCFydGMtPm9wcykKIAkJZXJyID0gLUVOT0RFVjsKIAllbHNlIGlmICghcnRjLT5vcHMtPmFsYXJtX2lycV9lbmFibGUpCkBAIC0yMzUsMTIgKzI0Miw5IEBACiAJCW5vdyA9IHJ0Y190bV90b19rdGltZSh0bSk7CiAJCXJ0Yy0+dWllX3J0Y3RpbWVyLm5vZGUuZXhwaXJlcyA9IGt0aW1lX2FkZChub3csIG9uZXNlYyk7CiAJCXJ0Yy0+dWllX3J0Y3RpbWVyLnBlcmlvZCA9IGt0aW1lX3NldCgxLCAwKTsKLQkJcnRjLT51aWVfcnRjdGltZXIuZW5hYmxlZCA9IDE7Ci0JCXJ0Y190aW1lcl9lbnF1ZXVlKHJ0YywgJnJ0Yy0+dWllX3J0Y3RpbWVyKTsKLQl9IGVsc2UgeworCQllcnIgPSBydGNfdGltZXJfZW5xdWV1ZShydGMsICZydGMtPnVpZV9ydGN0aW1lcik7CisJfSBlbHNlCiAJCXJ0Y190aW1lcl9yZW1vdmUocnRjLCAmcnRjLT51aWVfcnRjdGltZXIpOwotCQlydGMtPnVpZV9ydGN0aW1lci5lbmFibGVkID0gMDsKLQl9CiAKIG91dDoKIAltdXRleF91bmxvY2soJnJ0Yy0+b3BzX2xvY2spOwpAQCAtNDYwLDYgKzQ2NCw5IEBACiAJaW50IGVyciA9IDA7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAorCWlmIChmcmVxIDw9IDApCisJCXJldHVybiAtRUlOVkFMOworCiAJc3Bpbl9sb2NrX2lycXNhdmUoJnJ0Yy0+aXJxX3Rhc2tfbG9jaywgZmxhZ3MpOwogCWlmIChydGMtPmlycV90YXNrICE9IE5VTEwgJiYgdGFzayA9PSBOVUxMKQogCQllcnIgPSAtRUJVU1k7CkBAIC00ODgsMTAgKzQ5NSwxMyBAQAogICogRW5xdWV1ZXMgYSB0aW1lciBvbnRvIHRoZSBydGMgZGV2aWNlcyB0aW1lcnF1ZXVlIGFuZCBzZXRzCiAgKiB0aGUgbmV4dCBhbGFybSBldmVudCBhcHByb3ByaWF0ZWx5LgogICoKKyAqIFNldHMgdGhlIGVuYWJsZWQgYml0IG9uIHRoZSBhZGRlZCB0aW1lci4KKyAqCiAgKiBNdXN0IGhvbGQgb3BzX2xvY2sgZm9yIHByb3BlciBzZXJpYWxpemF0aW9uIG9mIHRpbWVycXVldWUKICAqLwotdm9pZCBydGNfdGltZXJfZW5xdWV1ZShzdHJ1Y3QgcnRjX2RldmljZSAqcnRjLCBzdHJ1Y3QgcnRjX3RpbWVyICp0aW1lcikKK3N0YXRpYyBpbnQgcnRjX3RpbWVyX2VucXVldWUoc3RydWN0IHJ0Y19kZXZpY2UgKnJ0Yywgc3RydWN0IHJ0Y190aW1lciAqdGltZXIpCiB7CisJdGltZXItPmVuYWJsZWQgPSAxOwogCXRpbWVycXVldWVfYWRkKCZydGMtPnRpbWVycXVldWUsICZ0aW1lci0+bm9kZSk7CiAJaWYgKCZ0aW1lci0+bm9kZSA9PSB0aW1lcnF1ZXVlX2dldG5leHQoJnJ0Yy0+dGltZXJxdWV1ZSkpIHsKIAkJc3RydWN0IHJ0Y193a2Fscm0gYWxhcm07CkBAIC01MDEsNyArNTExLDEzIEBACiAJCWVyciA9IF9fcnRjX3NldF9hbGFybShydGMsICZhbGFybSk7CiAJCWlmIChlcnIgPT0gLUVUSU1FKQogCQkJc2NoZWR1bGVfd29yaygmcnRjLT5pcnF3b3JrKTsKKwkJZWxzZSBpZiAoZXJyKSB7CisJCQl0aW1lcnF1ZXVlX2RlbCgmcnRjLT50aW1lcnF1ZXVlLCAmdGltZXItPm5vZGUpOworCQkJdGltZXItPmVuYWJsZWQgPSAwOworCQkJcmV0dXJuIGVycjsKKwkJfQogCX0KKwlyZXR1cm4gMDsKIH0KIAogLyoqCkBAIC01MTIsMTMgKzUyOCwxNSBAQAogICogUmVtb3ZlcyBhIHRpbWVyIG9udG8gdGhlIHJ0YyBkZXZpY2VzIHRpbWVycXVldWUgYW5kIHNldHMKICAqIHRoZSBuZXh0IGFsYXJtIGV2ZW50IGFwcHJvcHJpYXRlbHkuCiAgKgorICogQ2xlYXJzIHRoZSBlbmFibGVkIGJpdCBvbiB0aGUgcmVtb3ZlZCB0aW1lci4KKyAqCiAgKiBNdXN0IGhvbGQgb3BzX2xvY2sgZm9yIHByb3BlciBzZXJpYWxpemF0aW9uIG9mIHRpbWVycXVldWUKICAqLwotdm9pZCBydGNfdGltZXJfcmVtb3ZlKHN0cnVjdCBydGNfZGV2aWNlICpydGMsIHN0cnVjdCBydGNfdGltZXIgKnRpbWVyKQorc3RhdGljIHZvaWQgcnRjX3RpbWVyX3JlbW92ZShzdHJ1Y3QgcnRjX2RldmljZSAqcnRjLCBzdHJ1Y3QgcnRjX3RpbWVyICp0aW1lcikKIHsKIAlzdHJ1Y3QgdGltZXJxdWV1ZV9ub2RlICpuZXh0ID0gdGltZXJxdWV1ZV9nZXRuZXh0KCZydGMtPnRpbWVycXVldWUpOwogCXRpbWVycXVldWVfZGVsKCZydGMtPnRpbWVycXVldWUsICZ0aW1lci0+bm9kZSk7Ci0KKwl0aW1lci0+ZW5hYmxlZCA9IDA7CiAJaWYgKG5leHQgPT0gJnRpbWVyLT5ub2RlKSB7CiAJCXN0cnVjdCBydGNfd2thbHJtIGFsYXJtOwogCQlpbnQgZXJyOwpAQCAtNjI2LDggKzY0NCw3IEBACiAJdGltZXItPm5vZGUuZXhwaXJlcyA9IGV4cGlyZXM7CiAJdGltZXItPnBlcmlvZCA9IHBlcmlvZDsKIAotCXRpbWVyLT5lbmFibGVkID0gMTsKLQlydGNfdGltZXJfZW5xdWV1ZShydGMsIHRpbWVyKTsKKwlyZXQgPSBydGNfdGltZXJfZW5xdWV1ZShydGMsIHRpbWVyKTsKIAogCW11dGV4X3VubG9jaygmcnRjLT5vcHNfbG9jayk7CiAJcmV0dXJuIHJldDsKQEAgLTY0NSw3ICs2NjIsNiBAQAogCW11dGV4X2xvY2soJnJ0Yy0+b3BzX2xvY2spOwogCWlmICh0aW1lci0+ZW5hYmxlZCkKIAkJcnRjX3RpbWVyX3JlbW92ZShydGMsIHRpbWVyKTsKLQl0aW1lci0+ZW5hYmxlZCA9IDA7CiAJbXV0ZXhfdW5sb2NrKCZydGMtPm9wc19sb2NrKTsKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ydGMvcnRjLW1heDg5OTguYyBiL2RyaXZlcnMvcnRjL3J0Yy1tYXg4OTk4LmMKaW5kZXggZjIyZGVlMy4uM2Y3YmM2YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ydGMvcnRjLW1heDg5OTguYworKysgYi9kcml2ZXJzL3J0Yy9ydGMtbWF4ODk5OC5jCkBAIC0yMCw2ICsyMCw3IEBACiAjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvbWZkL21heDg5OTguaD4KICNpbmNsdWRlIDxsaW51eC9tZmQvbWF4ODk5OC1wcml2YXRlLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KIAogI2RlZmluZSBNQVg4OTk4X1JUQ19TRUMJCQkweDAwCiAjZGVmaW5lIE1BWDg5OThfUlRDX01JTgkJCTB4MDEKQEAgLTczLDYgKzc0LDcgQEAKIAlzdHJ1Y3QgaTJjX2NsaWVudAkqcnRjOwogCXN0cnVjdCBydGNfZGV2aWNlCSpydGNfZGV2OwogCWludCBpcnE7CisJYm9vbCBscDM5NzRfYnVnX3dvcmthcm91bmQ7CiB9OwogCiBzdGF0aWMgdm9pZCBtYXg4OTk4X2RhdGFfdG9fdG0odTggKmRhdGEsIHN0cnVjdCBydGNfdGltZSAqdG0pCkBAIC0xMjQsMTAgKzEyNiwxNiBAQAogewogCXN0cnVjdCBtYXg4OTk4X3J0Y19pbmZvICppbmZvID0gZGV2X2dldF9kcnZkYXRhKGRldik7CiAJdTggZGF0YVs4XTsKKwlpbnQgcmV0OwogCiAJbWF4ODk5OF90bV90b19kYXRhKHRtLCBkYXRhKTsKIAotCXJldHVybiBtYXg4OTk4X2J1bGtfd3JpdGUoaW5mby0+cnRjLCBNQVg4OTk4X1JUQ19TRUMsIDgsIGRhdGEpOworCXJldCA9IG1heDg5OThfYnVsa193cml0ZShpbmZvLT5ydGMsIE1BWDg5OThfUlRDX1NFQywgOCwgZGF0YSk7CisKKwlpZiAoaW5mby0+bHAzOTc0X2J1Z193b3JrYXJvdW5kKQorCQltc2xlZXAoMjAwMCk7CisKKwlyZXR1cm4gcmV0OwogfQogCiBzdGF0aWMgaW50IG1heDg5OThfcnRjX3JlYWRfYWxhcm0oc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcnRjX3drYWxybSAqYWxybSkKQEAgLTE2MywxMiArMTcxLDI5IEBACiAKIHN0YXRpYyBpbnQgbWF4ODk5OF9ydGNfc3RvcF9hbGFybShzdHJ1Y3QgbWF4ODk5OF9ydGNfaW5mbyAqaW5mbykKIHsKLQlyZXR1cm4gbWF4ODk5OF93cml0ZV9yZWcoaW5mby0+cnRjLCBNQVg4OTk4X0FMQVJNMF9DT05GLCAwKTsKKwlpbnQgcmV0ID0gbWF4ODk5OF93cml0ZV9yZWcoaW5mby0+cnRjLCBNQVg4OTk4X0FMQVJNMF9DT05GLCAwKTsKKworCWlmIChpbmZvLT5scDM5NzRfYnVnX3dvcmthcm91bmQpCisJCW1zbGVlcCgyMDAwKTsKKworCXJldHVybiByZXQ7CiB9CiAKIHN0YXRpYyBpbnQgbWF4ODk5OF9ydGNfc3RhcnRfYWxhcm0oc3RydWN0IG1heDg5OThfcnRjX2luZm8gKmluZm8pCiB7Ci0JcmV0dXJuIG1heDg5OThfd3JpdGVfcmVnKGluZm8tPnJ0YywgTUFYODk5OF9BTEFSTTBfQ09ORiwgMHg3Nyk7CisJaW50IHJldDsKKwl1OCBhbGFybTBfY29uZiA9IDB4Nzc7CisKKwkvKiBMUDM5NzQgd2l0aCBkZWxheSBidWcgY2hpcHMgaGFzIHJ0YyBhbGFybSBidWdzIHdpdGggIk1PTlRIIiBmaWVsZCAqLworCWlmIChpbmZvLT5scDM5NzRfYnVnX3dvcmthcm91bmQpCisJCWFsYXJtMF9jb25mID0gMHg1NzsKKworCXJldCA9IG1heDg5OThfd3JpdGVfcmVnKGluZm8tPnJ0YywgTUFYODk5OF9BTEFSTTBfQ09ORiwgYWxhcm0wX2NvbmYpOworCisJaWYgKGluZm8tPmxwMzk3NF9idWdfd29ya2Fyb3VuZCkKKwkJbXNsZWVwKDIwMDApOworCisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIGludCBtYXg4OTk4X3J0Y19zZXRfYWxhcm0oc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgcnRjX3drYWxybSAqYWxybSkKQEAgLTE4NywxMCArMjEyLDEzIEBACiAJaWYgKHJldCA8IDApCiAJCXJldHVybiByZXQ7CiAKLQlpZiAoYWxybS0+ZW5hYmxlZCkKLQkJcmV0dXJuIG1heDg5OThfcnRjX3N0YXJ0X2FsYXJtKGluZm8pOworCWlmIChpbmZvLT5scDM5NzRfYnVnX3dvcmthcm91bmQpCisJCW1zbGVlcCgyMDAwKTsKIAotCXJldHVybiAwOworCWlmIChhbHJtLT5lbmFibGVkKQorCQlyZXQgPSBtYXg4OTk4X3J0Y19zdGFydF9hbGFybShpbmZvKTsKKworCXJldHVybiByZXQ7CiB9CiAKIHN0YXRpYyBpbnQgbWF4ODk5OF9ydGNfYWxhcm1faXJxX2VuYWJsZShzdHJ1Y3QgZGV2aWNlICpkZXYsCkBAIC0yMjQsNiArMjUyLDcgQEAKIHN0YXRpYyBpbnQgX19kZXZpbml0IG1heDg5OThfcnRjX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiB7CiAJc3RydWN0IG1heDg5OThfZGV2ICptYXg4OTk4ID0gZGV2X2dldF9kcnZkYXRhKHBkZXYtPmRldi5wYXJlbnQpOworCXN0cnVjdCBtYXg4OTk4X3BsYXRmb3JtX2RhdGEgKnBkYXRhID0gZGV2X2dldF9wbGF0ZGF0YShtYXg4OTk4LT5kZXYpOwogCXN0cnVjdCBtYXg4OTk4X3J0Y19pbmZvICppbmZvOwogCWludCByZXQ7CiAKQEAgLTI0OSwxMCArMjc4LDE4IEBACiAKIAlyZXQgPSByZXF1ZXN0X3RocmVhZGVkX2lycShpbmZvLT5pcnEsIE5VTEwsIG1heDg5OThfcnRjX2FsYXJtX2lycSwgMCwKIAkJCSJydGMtYWxhcm0wIiwgaW5mbyk7CisKIAlpZiAocmV0IDwgMCkKIAkJZGV2X2VycigmcGRldi0+ZGV2LCAiRmFpbGVkIHRvIHJlcXVlc3QgYWxhcm0gSVJROiAlZDogJWRcbiIsCiAJCQlpbmZvLT5pcnEsIHJldCk7CiAKKwlkZXZfaW5mbygmcGRldi0+ZGV2LCAiUlRDIENISVAgTkFNRTogJXNcbiIsIHBkZXYtPmlkX2VudHJ5LT5uYW1lKTsKKwlpZiAocGRhdGEtPnJ0Y19kZWxheSkgeworCQlpbmZvLT5scDM5NzRfYnVnX3dvcmthcm91bmQgPSB0cnVlOworCQlkZXZfd2FybigmcGRldi0+ZGV2LCAiTFAzOTc0IHdpdGggUlRDIFJFR0VSUiBvcHRpb24uIgorCQkJCSIgUlRDIHVwZGF0ZXMgd2lsbCBiZSBleHRyZW1lbHkgc2xvdy5cbiIpOworCX0KKwogCXJldHVybiAwOwogCiBvdXRfcnRjOgpAQCAtMjczLDYgKzMxMCwxMiBAQAogCXJldHVybiAwOwogfQogCitzdGF0aWMgY29uc3Qgc3RydWN0IHBsYXRmb3JtX2RldmljZV9pZCBtYXg4OTk4X3J0Y19pZFtdID0geworCXsgIm1heDg5OTgtcnRjIiwgVFlQRV9NQVg4OTk4IH0sCisJeyAibHAzOTc0LXJ0YyIsIFRZUEVfTFAzOTc0IH0sCisJeyB9Cit9OworCiBzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBtYXg4OTk4X3J0Y19kcml2ZXIgPSB7CiAJLmRyaXZlcgkJPSB7CiAJCS5uYW1lCT0gIm1heDg5OTgtcnRjIiwKQEAgLTI4MCw2ICszMjMsNyBAQAogCX0sCiAJLnByb2JlCQk9IG1heDg5OThfcnRjX3Byb2JlLAogCS5yZW1vdmUJCT0gX19kZXZleGl0X3AobWF4ODk5OF9ydGNfcmVtb3ZlKSwKKwkuaWRfdGFibGUJPSBtYXg4OTk4X3J0Y19pZCwKIH07CiAKIHN0YXRpYyBpbnQgX19pbml0IG1heDg5OThfcnRjX2luaXQodm9pZCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcnRjL3J0Yy1wcm9jLmMgYi9kcml2ZXJzL3J0Yy9ydGMtcHJvYy5jCmluZGV4IGMwODZmYzMuLjI0MmJiZjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcnRjL3J0Yy1wcm9jLmMKKysrIGIvZHJpdmVycy9ydGMvcnRjLXByb2MuYwpAQCAtODEsMTIgKzgxLDE2IEBACiAKIHN0YXRpYyBpbnQgcnRjX3Byb2Nfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKIHsKKwlpbnQgcmV0OwogCXN0cnVjdCBydGNfZGV2aWNlICpydGMgPSBQREUoaW5vZGUpLT5kYXRhOwogCiAJaWYgKCF0cnlfbW9kdWxlX2dldChUSElTX01PRFVMRSkpCiAJCXJldHVybiAtRU5PREVWOwogCi0JcmV0dXJuIHNpbmdsZV9vcGVuKGZpbGUsIHJ0Y19wcm9jX3Nob3csIHJ0Yyk7CisJcmV0ID0gc2luZ2xlX29wZW4oZmlsZSwgcnRjX3Byb2Nfc2hvdywgcnRjKTsKKwlpZiAocmV0KQorCQltb2R1bGVfcHV0KFRISVNfTU9EVUxFKTsKKwlyZXR1cm4gcmV0OwogfQogCiBzdGF0aWMgaW50IHJ0Y19wcm9jX3JlbGVhc2Uoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvYmxvY2svZGFzZF9hbGlhcy5jIGIvZHJpdmVycy9zMzkwL2Jsb2NrL2Rhc2RfYWxpYXMuYwppbmRleCA0MTU1ODA1Li4yYjc3MWYxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvYmxvY2svZGFzZF9hbGlhcy5jCisrKyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2FsaWFzLmMKQEAgLTMxOSw2ICszMTksOSBAQAogCiAJcHJpdmF0ZSA9IChzdHJ1Y3QgZGFzZF9lY2tkX3ByaXZhdGUgKikgZGV2aWNlLT5wcml2YXRlOwogCWxjdSA9IHByaXZhdGUtPmxjdTsKKwkvKiBub3RoaW5nIHRvIGRvIGlmIGFscmVhZHkgZGlzY29ubmVjdGVkICovCisJaWYgKCFsY3UpCisJCXJldHVybjsKIAlkZXZpY2UtPmRpc2NpcGxpbmUtPmdldF91aWQoZGV2aWNlLCAmdWlkKTsKIAlzcGluX2xvY2tfaXJxc2F2ZSgmbGN1LT5sb2NrLCBmbGFncyk7CiAJbGlzdF9kZWxfaW5pdCgmZGV2aWNlLT5hbGlhc19saXN0KTsKQEAgLTY4MCw2ICs2ODMsOSBAQAogCiAJcHJpdmF0ZSA9IChzdHJ1Y3QgZGFzZF9lY2tkX3ByaXZhdGUgKikgZGV2aWNlLT5wcml2YXRlOwogCWxjdSA9IHByaXZhdGUtPmxjdTsKKwkvKiBub3RoaW5nIHRvIGRvIGlmIGFscmVhZHkgcmVtb3ZlZCAqLworCWlmICghbGN1KQorCQlyZXR1cm4gMDsKIAlzcGluX2xvY2tfaXJxc2F2ZSgmbGN1LT5sb2NrLCBmbGFncyk7CiAJX3JlbW92ZV9kZXZpY2VfZnJvbV9sY3UobGN1LCBkZXZpY2UpOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmxjdS0+bG9jaywgZmxhZ3MpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL2Npby9kZXZpY2UuYyBiL2RyaXZlcnMvczM5MC9jaW8vZGV2aWNlLmMKaW5kZXggZTgzOTFiODkuLmI3ZWFmZjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9jaW8vZGV2aWNlLmMKKysrIGIvZHJpdmVycy9zMzkwL2Npby9kZXZpY2UuYwpAQCAtMTgzNSw2ICsxODM1LDcgQEAKIAkgKiBhdmFpbGFibGUgYWdhaW4uIEtpY2sgcmUtZGV0ZWN0aW9uLgogCSAqLwogCWNkZXYtPnByaXZhdGUtPmZsYWdzLnJlc3VtaW5nID0gMTsKKwljZGV2LT5wcml2YXRlLT5wYXRoX25ld19tYXNrID0gTFBNX0FOWVBBVEg7CiAJY3NzX3NjaGVkdWxlX2V2YWwoc2NoLT5zY2hpZCk7CiAJc3Bpbl91bmxvY2tfaXJxKHNjaC0+bG9jayk7CiAJY3NzX2NvbXBsZXRlX3dvcmsoKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvczM5MC9jaW8vcWRpb19tYWluLmMgYi9kcml2ZXJzL3MzOTAvY2lvL3FkaW9fbWFpbi5jCmluZGV4IGU5ZmZmMmIuLjU2NDBjODkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9jaW8vcWRpb19tYWluLmMKKysrIGIvZHJpdmVycy9zMzkwL2Npby9xZGlvX21haW4uYwpAQCAtNDc2LDcgKzQ3Niw3IEBACiBzdGF0aWMgaW50IGdldF9pbmJvdW5kX2J1ZmZlcl9mcm9udGllcihzdHJ1Y3QgcWRpb19xICpxKQogewogCWludCBjb3VudCwgc3RvcDsKLQl1bnNpZ25lZCBjaGFyIHN0YXRlOworCXVuc2lnbmVkIGNoYXIgc3RhdGUgPSAwOwogCiAJLyoKIAkgKiBEb24ndCBjaGVjayAxMjggYnVmZmVycywgYXMgb3RoZXJ3aXNlIHFkaW9faW5ib3VuZF9xX21vdmVkCkBAIC02NDMsNyArNjQzLDcgQEAKIHN0YXRpYyBpbnQgZ2V0X291dGJvdW5kX2J1ZmZlcl9mcm9udGllcihzdHJ1Y3QgcWRpb19xICpxKQogewogCWludCBjb3VudCwgc3RvcDsKLQl1bnNpZ25lZCBjaGFyIHN0YXRlOworCXVuc2lnbmVkIGNoYXIgc3RhdGUgPSAwOwogCiAJaWYgKG5lZWRfc2lnYV9zeW5jKHEpKQogCQlpZiAoKChxdWV1ZV90eXBlKHEpICE9IFFESU9fSVFESU9fUUZNVCkgJiYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvczM5MC9uZXQvbmV0aXVjdi5jIGIvZHJpdmVycy9zMzkwL25ldC9uZXRpdWN2LmMKaW5kZXggNjVlYmVlMC4uYjZhNjM1NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL25ldC9uZXRpdWN2LmMKKysrIGIvZHJpdmVycy9zMzkwL25ldC9uZXRpdWN2LmMKQEAgLTU2NSw3ICs1NjUsNyBAQAogCXN0cnVjdCBpdWN2X2V2ZW50IGV2OwogCWludCByYzsKIAotCWlmIChtZW1jbXAoaXVjdk1hZ2ljLCBpcHVzZXIsIHNpemVvZihpcHVzZXIpKSkKKwlpZiAobWVtY21wKGl1Y3ZNYWdpYywgaXB1c2VyLCAxNikpCiAJCS8qIGlwdXNlciBtdXN0IG1hdGNoIGl1Y3ZNYWdpYy4gKi8KIAkJcmV0dXJuIC1FSU5WQUw7CiAJcmMgPSAtRUlOVkFMOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL25ldC9xZXRoX2NvcmVfbWFpbi5jIGIvZHJpdmVycy9zMzkwL25ldC9xZXRoX2NvcmVfbWFpbi5jCmluZGV4IDI5Zjg0OGIuLjAxOWFlNTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9uZXQvcWV0aF9jb3JlX21haW4uYworKysgYi9kcml2ZXJzL3MzOTAvbmV0L3FldGhfY29yZV9tYWluLmMKQEAgLTk4OCwxNiArOTg4LDMwIEBACiAJY2hwX2RzYyA9IChzdHJ1Y3QgY2hhbm5lbFBhdGhfZHNjICopY2N3X2RldmljZV9nZXRfY2hwX2Rlc2MoY2N3ZGV2LCAwKTsKIAlpZiAoY2hwX2RzYyAhPSBOVUxMKSB7CiAJCS8qIENIUFAgZmllbGQgYml0IDYgPT0gMSAtPiBzaW5nbGUgcXVldWUgKi8KLQkJaWYgKChjaHBfZHNjLT5jaHBwICYgMHgwMikgPT0gMHgwMikKKwkJaWYgKChjaHBfZHNjLT5jaHBwICYgMHgwMikgPT0gMHgwMikgeworCQkJaWYgKChhdG9taWNfcmVhZCgmY2FyZC0+cWRpby5zdGF0ZSkgIT0KKwkJCQlRRVRIX1FESU9fVU5JTklUSUFMSVpFRCkgJiYKKwkJCSAgICAoY2FyZC0+cWRpby5ub19vdXRfcXVldWVzID09IDQpKQorCQkJCS8qIGNoYW5nZSBmcm9tIDQgdG8gMSBvdXRib3VuZCBxdWV1ZXMgKi8KKwkJCQlxZXRoX2ZyZWVfcWRpb19idWZmZXJzKGNhcmQpOwogCQkJY2FyZC0+cWRpby5ub19vdXRfcXVldWVzID0gMTsKKwkJCWlmIChjYXJkLT5xZGlvLmRlZmF1bHRfb3V0X3F1ZXVlICE9IDApCisJCQkJZGV2X2luZm8oJmNhcmQtPmdkZXYtPmRldiwKKwkJCQkJIlByaW9yaXR5IFF1ZXVlaW5nIG5vdCBzdXBwb3J0ZWRcbiIpOworCQkJY2FyZC0+cWRpby5kZWZhdWx0X291dF9xdWV1ZSA9IDA7CisJCX0gZWxzZSB7CisJCQlpZiAoKGF0b21pY19yZWFkKCZjYXJkLT5xZGlvLnN0YXRlKSAhPQorCQkJCVFFVEhfUURJT19VTklOSVRJQUxJWkVEKSAmJgorCQkJICAgIChjYXJkLT5xZGlvLm5vX291dF9xdWV1ZXMgPT0gMSkpIHsKKwkJCQkvKiBjaGFuZ2UgZnJvbSAxIHRvIDQgb3V0Ym91bmQgcXVldWVzICovCisJCQkJcWV0aF9mcmVlX3FkaW9fYnVmZmVycyhjYXJkKTsKKwkJCQljYXJkLT5xZGlvLmRlZmF1bHRfb3V0X3F1ZXVlID0gMjsKKwkJCX0KKwkJCWNhcmQtPnFkaW8ubm9fb3V0X3F1ZXVlcyA9IDQ7CisJCX0KIAkJY2FyZC0+aW5mby5mdW5jX2xldmVsID0gMHg0MTAwICsgY2hwX2RzYy0+ZGVzYzsKIAkJa2ZyZWUoY2hwX2RzYyk7CiAJfQotCWlmIChjYXJkLT5xZGlvLm5vX291dF9xdWV1ZXMgPT0gMSkgewotCQljYXJkLT5xZGlvLmRlZmF1bHRfb3V0X3F1ZXVlID0gMDsKLQkJZGV2X2luZm8oJmNhcmQtPmdkZXYtPmRldiwKLQkJCSJQcmlvcml0eSBRdWV1ZWluZyBub3Qgc3VwcG9ydGVkXG4iKTsKLQl9CiAJUUVUSF9EQkZfVEVYVF8oU0VUVVAsIDIsICJucjoleCIsIGNhcmQtPnFkaW8ubm9fb3V0X3F1ZXVlcyk7CiAJUUVUSF9EQkZfVEVYVF8oU0VUVVAsIDIsICJsdmw6JTAyeCIsIGNhcmQtPmluZm8uZnVuY19sZXZlbCk7CiAJcmV0dXJuOwpAQCAtMTgzMiwzMyArMTg0Niw2IEBACiAJfQogfQogCi1zdGF0aWMgaW5saW5lIGludCBxZXRoX2dldF9tYXhfbXR1X2Zvcl9jYXJkKGludCBjYXJkdHlwZSkKLXsKLQlzd2l0Y2ggKGNhcmR0eXBlKSB7Ci0KLQljYXNlIFFFVEhfQ0FSRF9UWVBFX1VOS05PV046Ci0JY2FzZSBRRVRIX0NBUkRfVFlQRV9PU0Q6Ci0JY2FzZSBRRVRIX0NBUkRfVFlQRV9PU046Ci0JY2FzZSBRRVRIX0NBUkRfVFlQRV9PU006Ci0JY2FzZSBRRVRIX0NBUkRfVFlQRV9PU1g6Ci0JCXJldHVybiA2MTQ0MDsKLQljYXNlIFFFVEhfQ0FSRF9UWVBFX0lRRDoKLQkJcmV0dXJuIDU3MzQ0OwotCWRlZmF1bHQ6Ci0JCXJldHVybiAxNTAwOwotCX0KLX0KLQotc3RhdGljIGlubGluZSBpbnQgcWV0aF9nZXRfbXR1X291dF9vZl9tcGMoaW50IGNhcmR0eXBlKQotewotCXN3aXRjaCAoY2FyZHR5cGUpIHsKLQljYXNlIFFFVEhfQ0FSRF9UWVBFX0lRRDoKLQkJcmV0dXJuIDE7Ci0JZGVmYXVsdDoKLQkJcmV0dXJuIDA7Ci0JfQotfQotCiBzdGF0aWMgaW5saW5lIGludCBxZXRoX2dldF9tdHVfb3V0b2ZfZnJhbWVzaXplKGludCBmcmFtZXNpemUpCiB7CiAJc3dpdGNoIChmcmFtZXNpemUpIHsKQEAgLTE4ODEsMTAgKzE4NjgsOSBAQAogCWNhc2UgUUVUSF9DQVJEX1RZUEVfT1NEOgogCWNhc2UgUUVUSF9DQVJEX1RZUEVfT1NNOgogCWNhc2UgUUVUSF9DQVJEX1RZUEVfT1NYOgotCQlyZXR1cm4gKChtdHUgPj0gNTc2KSAmJiAobXR1IDw9IDYxNDQwKSk7CiAJY2FzZSBRRVRIX0NBUkRfVFlQRV9JUUQ6CiAJCXJldHVybiAoKG10dSA+PSA1NzYpICYmCi0JCQkobXR1IDw9IGNhcmQtPmluZm8ubWF4X210dSArIDQwOTYgLSAzMikpOworCQkJKG10dSA8PSBjYXJkLT5pbmZvLm1heF9tdHUpKTsKIAljYXNlIFFFVEhfQ0FSRF9UWVBFX09TTjoKIAljYXNlIFFFVEhfQ0FSRF9UWVBFX1VOS05PV046CiAJZGVmYXVsdDoKQEAgLTE5MDcsNyArMTg5Myw3IEBACiAJbWVtY3B5KCZjYXJkLT50b2tlbi51bHBfZmlsdGVyX3IsCiAJICAgICAgIFFFVEhfVUxQX0VOQUJMRV9SRVNQX0ZJTFRFUl9UT0tFTihpb2ItPmRhdGEpLAogCSAgICAgICBRRVRIX01QQ19UT0tFTl9MRU5HVEgpOwotCWlmIChxZXRoX2dldF9tdHVfb3V0X29mX21wYyhjYXJkLT5pbmZvLnR5cGUpKSB7CisJaWYgKGNhcmQtPmluZm8udHlwZSA9PSBRRVRIX0NBUkRfVFlQRV9JUUQpIHsKIAkJbWVtY3B5KCZmcmFtZXNpemUsIFFFVEhfVUxQX0VOQUJMRV9SRVNQX01BWF9NVFUoaW9iLT5kYXRhKSwgMik7CiAJCW10dSA9IHFldGhfZ2V0X210dV9vdXRvZl9mcmFtZXNpemUoZnJhbWVzaXplKTsKIAkJaWYgKCFtdHUpIHsKQEAgLTE5MTUsMTIgKzE5MDEsMjEgQEAKIAkJCVFFVEhfREJGX1RFWFRfKFNFVFVQLCAyLCAiICByYyVkIiwgaW9iLT5yYyk7CiAJCQlyZXR1cm4gMDsKIAkJfQotCQljYXJkLT5pbmZvLm1heF9tdHUgPSBtdHU7CisJCWlmIChjYXJkLT5pbmZvLmluaXRpYWxfbXR1ICYmIChjYXJkLT5pbmZvLmluaXRpYWxfbXR1ICE9IG10dSkpIHsKKwkJCS8qIGZyYW1lIHNpemUgaGFzIGNoYW5nZWQgKi8KKwkJCWlmIChjYXJkLT5kZXYgJiYKKwkJCSAgICAoKGNhcmQtPmRldi0+bXR1ID09IGNhcmQtPmluZm8uaW5pdGlhbF9tdHUpIHx8CisJCQkgICAgIChjYXJkLT5kZXYtPm10dSA+IG10dSkpKQorCQkJCWNhcmQtPmRldi0+bXR1ID0gbXR1OworCQkJcWV0aF9mcmVlX3FkaW9fYnVmZmVycyhjYXJkKTsKKwkJfQogCQljYXJkLT5pbmZvLmluaXRpYWxfbXR1ID0gbXR1OworCQljYXJkLT5pbmZvLm1heF9tdHUgPSBtdHU7CiAJCWNhcmQtPnFkaW8uaW5fYnVmX3NpemUgPSBtdHUgKyAyICogUEFHRV9TSVpFOwogCX0gZWxzZSB7CiAJCWNhcmQtPmluZm8uaW5pdGlhbF9tdHUgPSBxZXRoX2dldF9pbml0aWFsX210dV9mb3JfY2FyZChjYXJkKTsKLQkJY2FyZC0+aW5mby5tYXhfbXR1ID0gcWV0aF9nZXRfbWF4X210dV9mb3JfY2FyZChjYXJkLT5pbmZvLnR5cGUpOworCQljYXJkLT5pbmZvLm1heF9tdHUgPSAqKF9fdTE2ICopUUVUSF9VTFBfRU5BQkxFX1JFU1BfTUFYX01UVSgKKwkJCWlvYi0+ZGF0YSk7CiAJCWNhcmQtPnFkaW8uaW5fYnVmX3NpemUgPSBRRVRIX0lOX0JVRl9TSVpFX0RFRkFVTFQ7CiAJfQogCkBAIC0zNzc1LDYgKzM3NzAsNDcgQEAKIAl9CiB9CiAKK3N0YXRpYyB2b2lkIHFldGhfZGV0ZXJtaW5lX2NhcGFiaWxpdGllcyhzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkKQoreworCWludCByYzsKKwlpbnQgbGVuZ3RoOworCWNoYXIgKnByY2Q7CisJc3RydWN0IGNjd19kZXZpY2UgKmRkZXY7CisJaW50IGRkZXZfb2ZmbGluZSA9IDA7CisKKwlRRVRIX0RCRl9URVhUKFNFVFVQLCAyLCAiZGV0Y2FwYWIiKTsKKwlkZGV2ID0gQ0FSRF9EREVWKGNhcmQpOworCWlmICghZGRldi0+b25saW5lKSB7CisJCWRkZXZfb2ZmbGluZSA9IDE7CisJCXJjID0gY2N3X2RldmljZV9zZXRfb25saW5lKGRkZXYpOworCQlpZiAocmMpIHsKKwkJCVFFVEhfREJGX1RFWFRfKFNFVFVQLCAyLCAiM2VyciVkIiwgcmMpOworCQkJZ290byBvdXQ7CisJCX0KKwl9CisKKwlyYyA9IHFldGhfcmVhZF9jb25mX2RhdGEoY2FyZCwgKHZvaWQgKiopICZwcmNkLCAmbGVuZ3RoKTsKKwlpZiAocmMpIHsKKwkJUUVUSF9EQkZfTUVTU0FHRSgyLCAiJXMgcWV0aF9yZWFkX2NvbmZfZGF0YSByZXR1cm5lZCAlaVxuIiwKKwkJCWRldl9uYW1lKCZjYXJkLT5nZGV2LT5kZXYpLCByYyk7CisJCVFFVEhfREJGX1RFWFRfKFNFVFVQLCAyLCAiNWVyciVkIiwgcmMpOworCQlnb3RvIG91dF9vZmZsaW5lOworCX0KKwlxZXRoX2NvbmZpZ3VyZV91bml0YWRkcihjYXJkLCBwcmNkKTsKKwlxZXRoX2NvbmZpZ3VyZV9ibGt0X2RlZmF1bHQoY2FyZCwgcHJjZCk7CisJa2ZyZWUocHJjZCk7CisKKwlyYyA9IHFkaW9fZ2V0X3NzcWRfZGVzYyhkZGV2LCAmY2FyZC0+c3NxZCk7CisJaWYgKHJjKQorCQlRRVRIX0RCRl9URVhUXyhTRVRVUCwgMiwgIjZlcnIlZCIsIHJjKTsKKworb3V0X29mZmxpbmU6CisJaWYgKGRkZXZfb2ZmbGluZSA9PSAxKQorCQljY3dfZGV2aWNlX3NldF9vZmZsaW5lKGRkZXYpOworb3V0OgorCXJldHVybjsKK30KKwogc3RhdGljIGludCBxZXRoX3FkaW9fZXN0YWJsaXNoKHN0cnVjdCBxZXRoX2NhcmQgKmNhcmQpCiB7CiAJc3RydWN0IHFkaW9faW5pdGlhbGl6ZSBpbml0X2RhdGE7CkBAIC0zOTA1LDYgKzM5NDEsNyBAQAogCiAJUUVUSF9EQkZfVEVYVChTRVRVUCwgMiwgImhyZHNldHVwIik7CiAJYXRvbWljX3NldCgmY2FyZC0+Zm9yY2VfYWxsb2Nfc2tiLCAwKTsKKwlxZXRoX2dldF9jaGFubmVsX3BhdGhfZGVzYyhjYXJkKTsKIHJldHJ5OgogCWlmIChyZXRyaWVzKQogCQlRRVRIX0RCRl9NRVNTQUdFKDIsICIlcyBSZXRyeWluZyB0byBkbyBJRFggYWN0aXZhdGVzLlxuIiwKQEAgLTM5MzMsNiArMzk3MCw3IEBACiAJCWVsc2UKIAkJCWdvdG8gcmV0cnk7CiAJfQorCXFldGhfZGV0ZXJtaW5lX2NhcGFiaWxpdGllcyhjYXJkKTsKIAlxZXRoX2luaXRfdG9rZW5zKGNhcmQpOwogCXFldGhfaW5pdF9mdW5jX2xldmVsKGNhcmQpOwogCXJjID0gcWV0aF9pZHhfYWN0aXZhdGVfY2hhbm5lbCgmY2FyZC0+cmVhZCwgcWV0aF9pZHhfcmVhZF9jYik7CkBAIC00MjAyLDQxICs0MjQwLDYgQEAKIAljYXJkLT5kaXNjaXBsaW5lLmNjd2dkcml2ZXIgPSBOVUxMOwogfQogCi1zdGF0aWMgdm9pZCBxZXRoX2RldGVybWluZV9jYXBhYmlsaXRpZXMoc3RydWN0IHFldGhfY2FyZCAqY2FyZCkKLXsKLQlpbnQgcmM7Ci0JaW50IGxlbmd0aDsKLQljaGFyICpwcmNkOwotCi0JUUVUSF9EQkZfVEVYVChTRVRVUCwgMiwgImRldGNhcGFiIik7Ci0JcmMgPSBjY3dfZGV2aWNlX3NldF9vbmxpbmUoQ0FSRF9EREVWKGNhcmQpKTsKLQlpZiAocmMpIHsKLQkJUUVUSF9EQkZfVEVYVF8oU0VUVVAsIDIsICIzZXJyJWQiLCByYyk7Ci0JCWdvdG8gb3V0OwotCX0KLQotCi0JcmMgPSBxZXRoX3JlYWRfY29uZl9kYXRhKGNhcmQsICh2b2lkICoqKSAmcHJjZCwgJmxlbmd0aCk7Ci0JaWYgKHJjKSB7Ci0JCVFFVEhfREJGX01FU1NBR0UoMiwgIiVzIHFldGhfcmVhZF9jb25mX2RhdGEgcmV0dXJuZWQgJWlcbiIsCi0JCQlkZXZfbmFtZSgmY2FyZC0+Z2Rldi0+ZGV2KSwgcmMpOwotCQlRRVRIX0RCRl9URVhUXyhTRVRVUCwgMiwgIjVlcnIlZCIsIHJjKTsKLQkJZ290byBvdXRfb2ZmbGluZTsKLQl9Ci0JcWV0aF9jb25maWd1cmVfdW5pdGFkZHIoY2FyZCwgcHJjZCk7Ci0JcWV0aF9jb25maWd1cmVfYmxrdF9kZWZhdWx0KGNhcmQsIHByY2QpOwotCWtmcmVlKHByY2QpOwotCi0JcmMgPSBxZGlvX2dldF9zc3FkX2Rlc2MoQ0FSRF9EREVWKGNhcmQpLCAmY2FyZC0+c3NxZCk7Ci0JaWYgKHJjKQotCQlRRVRIX0RCRl9URVhUXyhTRVRVUCwgMiwgIjZlcnIlZCIsIHJjKTsKLQotb3V0X29mZmxpbmU6Ci0JY2N3X2RldmljZV9zZXRfb2ZmbGluZShDQVJEX0RERVYoY2FyZCkpOwotb3V0OgotCXJldHVybjsKLX0KLQogc3RhdGljIGludCBxZXRoX2NvcmVfcHJvYmVfZGV2aWNlKHN0cnVjdCBjY3dncm91cF9kZXZpY2UgKmdkZXYpCiB7CiAJc3RydWN0IHFldGhfY2FyZCAqY2FyZDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvczM5MC9uZXQvcWV0aF9sMl9tYWluLmMgYi9kcml2ZXJzL3MzOTAvbmV0L3FldGhfbDJfbWFpbi5jCmluZGV4IDdhN2ExYjYuLmFkYTBmZTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9uZXQvcWV0aF9sMl9tYWluLmMKKysrIGIvZHJpdmVycy9zMzkwL25ldC9xZXRoX2wyX21haW4uYwpAQCAtNTczLDEzICs1NzMsMTMgQEAKIAkJY2FzZSBJUEFfUkNfTDJfRFVQX0xBWUVSM19NQUM6CiAJCQlkZXZfd2FybigmY2FyZC0+Z2Rldi0+ZGV2LAogCQkJCSJNQUMgYWRkcmVzcyAlcE0gYWxyZWFkeSBleGlzdHNcbiIsCi0JCQkJY2FyZC0+ZGV2LT5kZXZfYWRkcik7CisJCQkJY21kLT5kYXRhLnNldGRlbG1hYy5tYWMpOwogCQkJYnJlYWs7CiAJCWNhc2UgSVBBX1JDX0wyX01BQ19OT1RfQVVUSF9CWV9IWVA6CiAJCWNhc2UgSVBBX1JDX0wyX01BQ19OT1RfQVVUSF9CWV9BRFA6CiAJCQlkZXZfd2FybigmY2FyZC0+Z2Rldi0+ZGV2LAogCQkJCSJNQUMgYWRkcmVzcyAlcE0gaXMgbm90IGF1dGhvcml6ZWRcbiIsCi0JCQkJY2FyZC0+ZGV2LT5kZXZfYWRkcik7CisJCQkJY21kLT5kYXRhLnNldGRlbG1hYy5tYWMpOwogCQkJYnJlYWs7CiAJCWRlZmF1bHQ6CiAJCQlicmVhazsKQEAgLTgzMSwxMiArODMxLDE0IEBACiAJcmV0dXJuIE5FVERFVl9UWF9PSzsKIH0KIAotc3RhdGljIGludCBxZXRoX2wyX29wZW4oc3RydWN0IG5ldF9kZXZpY2UgKmRldikKK3N0YXRpYyBpbnQgX19xZXRoX2wyX29wZW4oc3RydWN0IG5ldF9kZXZpY2UgKmRldikKIHsKIAlzdHJ1Y3QgcWV0aF9jYXJkICpjYXJkID0gZGV2LT5tbF9wcml2OwogCWludCByYyA9IDA7CiAKIAlRRVRIX0NBUkRfVEVYVChjYXJkLCA0LCAicWV0aG9wZW4iKTsKKwlpZiAoY2FyZC0+c3RhdGUgPT0gQ0FSRF9TVEFURV9VUCkKKwkJcmV0dXJuIHJjOwogCWlmIChjYXJkLT5zdGF0ZSAhPSBDQVJEX1NUQVRFX1NPRlRTRVRVUCkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKQEAgLTg1Nyw2ICs4NTksMTggQEAKIAlyZXR1cm4gcmM7CiB9CiAKK3N0YXRpYyBpbnQgcWV0aF9sMl9vcGVuKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHFldGhfY2FyZCAqY2FyZCA9IGRldi0+bWxfcHJpdjsKKworCVFFVEhfQ0FSRF9URVhUKGNhcmQsIDUsICJxZXRob3BlXyIpOworCWlmIChxZXRoX3dhaXRfZm9yX3RocmVhZHMoY2FyZCwgUUVUSF9SRUNPVkVSX1RIUkVBRCkpIHsKKwkJUUVUSF9DQVJEX1RFWFQoY2FyZCwgMywgIm9wZW5SRUMiKTsKKwkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKKwl9CisJcmV0dXJuIF9fcWV0aF9sMl9vcGVuKGRldik7Cit9CisKIHN0YXRpYyBpbnQgcWV0aF9sMl9zdG9wKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0IHFldGhfY2FyZCAqY2FyZCA9IGRldi0+bWxfcHJpdjsKQEAgLTEwNDYsNyArMTA2MCw3IEBACiAJaWYgKHJlY292ZXJfZmxhZyA9PSBDQVJEX1NUQVRFX1JFQ09WRVIpIHsKIAkJaWYgKHJlY292ZXJ5X21vZGUgJiYKIAkJICAgIGNhcmQtPmluZm8udHlwZSAhPSBRRVRIX0NBUkRfVFlQRV9PU04pIHsKLQkJCXFldGhfbDJfb3BlbihjYXJkLT5kZXYpOworCQkJX19xZXRoX2wyX29wZW4oY2FyZC0+ZGV2KTsKIAkJfSBlbHNlIHsKIAkJCXJ0bmxfbG9jaygpOwogCQkJZGV2X29wZW4oY2FyZC0+ZGV2KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvczM5MC9uZXQvcWV0aF9sM19tYWluLmMgYi9kcml2ZXJzL3MzOTAvbmV0L3FldGhfbDNfbWFpbi5jCmluZGV4IGUyMjdlNDYuLmQwOWIwYzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9uZXQvcWV0aF9sM19tYWluLmMKKysrIGIvZHJpdmVycy9zMzkwL25ldC9xZXRoX2wzX21haW4uYwpAQCAtMjk5OCw3ICsyOTk4LDkgQEAKIAkgKi8KIAlpZiAoaXBoLT5wcm90b2NvbCA9PSBJUFBST1RPX1VEUCkKIAkJaGRyLT5oZHIubDMuZXh0X2ZsYWdzIHw9IFFFVEhfSERSX0VYVF9VRFA7Ci0JaGRyLT5oZHIubDMuZXh0X2ZsYWdzIHw9IFFFVEhfSERSX0VYVF9DU1VNX1RSQU5TUF9SRVE7CisJaGRyLT5oZHIubDMuZXh0X2ZsYWdzIHw9IFFFVEhfSERSX0VYVF9DU1VNX1RSQU5TUF9SRVEgfAorCQlRRVRIX0hEUl9FWFRfQ1NVTV9IRFJfUkVROworCWlwaC0+Y2hlY2sgPSAwOwogCWlmIChjYXJkLT5vcHRpb25zLnBlcmZvcm1hbmNlX3N0YXRzKQogCQljYXJkLT5wZXJmX3N0YXRzLnR4X2NzdW0rKzsKIH0KQEAgLTMyNDAsMTIgKzMyNDIsMTQgQEAKIAlyZXR1cm4gTkVUREVWX1RYX09LOwogfQogCi1zdGF0aWMgaW50IHFldGhfbDNfb3BlbihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQorc3RhdGljIGludCBfX3FldGhfbDNfb3BlbihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogewogCXN0cnVjdCBxZXRoX2NhcmQgKmNhcmQgPSBkZXYtPm1sX3ByaXY7CiAJaW50IHJjID0gMDsKIAogCVFFVEhfQ0FSRF9URVhUKGNhcmQsIDQsICJxZXRob3BlbiIpOworCWlmIChjYXJkLT5zdGF0ZSA9PSBDQVJEX1NUQVRFX1VQKQorCQlyZXR1cm4gcmM7CiAJaWYgKGNhcmQtPnN0YXRlICE9IENBUkRfU1RBVEVfU09GVFNFVFVQKQogCQlyZXR1cm4gLUVOT0RFVjsKIAljYXJkLT5kYXRhLnN0YXRlID0gQ0hfU1RBVEVfVVA7CkBAIC0zMjYwLDYgKzMyNjQsMTggQEAKIAlyZXR1cm4gcmM7CiB9CiAKK3N0YXRpYyBpbnQgcWV0aF9sM19vcGVuKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHFldGhfY2FyZCAqY2FyZCA9IGRldi0+bWxfcHJpdjsKKworCVFFVEhfQ0FSRF9URVhUKGNhcmQsIDUsICJxZXRob3BlXyIpOworCWlmIChxZXRoX3dhaXRfZm9yX3RocmVhZHMoY2FyZCwgUUVUSF9SRUNPVkVSX1RIUkVBRCkpIHsKKwkJUUVUSF9DQVJEX1RFWFQoY2FyZCwgMywgIm9wZW5SRUMiKTsKKwkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKKwl9CisJcmV0dXJuIF9fcWV0aF9sM19vcGVuKGRldik7Cit9CisKIHN0YXRpYyBpbnQgcWV0aF9sM19zdG9wKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0IHFldGhfY2FyZCAqY2FyZCA9IGRldi0+bWxfcHJpdjsKQEAgLTM1NjQsNyArMzU4MCw3IEBACiAJCW5ldGlmX2NhcnJpZXJfb2ZmKGNhcmQtPmRldik7CiAJaWYgKHJlY292ZXJfZmxhZyA9PSBDQVJEX1NUQVRFX1JFQ09WRVIpIHsKIAkJaWYgKHJlY292ZXJ5X21vZGUpCi0JCQlxZXRoX2wzX29wZW4oY2FyZC0+ZGV2KTsKKwkJCV9fcWV0aF9sM19vcGVuKGNhcmQtPmRldik7CiAJCWVsc2UgewogCQkJcnRubF9sb2NrKCk7CiAJCQlkZXZfb3BlbihjYXJkLT5kZXYpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL25ldC9zbXNnaXVjdi5jIGIvZHJpdmVycy9zMzkwL25ldC9zbXNnaXVjdi5jCmluZGV4IDY1ZTFjZjEuLjIwN2I3ZDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9uZXQvc21zZ2l1Y3YuYworKysgYi9kcml2ZXJzL3MzOTAvbmV0L3Ntc2dpdWN2LmMKQEAgLTYwLDcgKzYwLDcgQEAKIHN0YXRpYyBpbnQgc21zZ19wYXRoX3BlbmRpbmcoc3RydWN0IGl1Y3ZfcGF0aCAqcGF0aCwgdTggaXB2bWlkWzhdLAogCQkJICAgICB1OCBpcHVzZXJbMTZdKQogewotCWlmIChzdHJuY21wKGlwdm1pZCwgIipNU0cgICAgIiwgc2l6ZW9mKGlwdm1pZCkpICE9IDApCisJaWYgKHN0cm5jbXAoaXB2bWlkLCAiKk1TRyAgICAiLCA4KSAhPSAwKQogCQlyZXR1cm4gLUVJTlZBTDsKIAkvKiBQYXRoIHBlbmRpbmcgZnJvbSAqTVNHLiAqLwogCXJldHVybiBpdWN2X3BhdGhfYWNjZXB0KHBhdGgsICZzbXNnX2hhbmRsZXIsICJTTVNHSVVDViAgICAgICAgIiwgTlVMTCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYXJjbXNyL2FyY21zci5oIGIvZHJpdmVycy9zY3NpL2FyY21zci9hcmNtc3IuaAppbmRleCA0NzVjMzFhLi43N2IyNmY1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYXJjbXNyL2FyY21zci5oCisrKyBiL2RyaXZlcnMvc2NzaS9hcmNtc3IvYXJjbXNyLmgKQEAgLTIsNyArMiw3IEBACiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqKiAgICAgICAgTy5TICAgOiBMaW51eAogKiogICBGSUxFIE5BTUUgIDogYXJjbXNyLmgKLSoqICAgICAgICBCWSAgICA6IEVyaWNoIENoZW4KKyoqICAgICAgICBCWSAgICA6IE5pY2sgQ2hlbmcKICoqICAgRGVzY3JpcHRpb246IFNDU0kgUkFJRCBEZXZpY2UgRHJpdmVyIGZvcgogKiogICAgICAgICAgICAgICAgQVJFQ0EgUkFJRCBIb3N0IGFkYXB0ZXIKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKQEAgLTQ2LDggKzQ2LDEyIEBACiBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZTsKIC8qVGhlIGxpbWl0IG9mIG91dHN0YW5kaW5nIHNjc2kgY29tbWFuZCB0aGF0IGZpcm13YXJlIGNhbiBoYW5kbGUqLwogI2RlZmluZSBBUkNNU1JfTUFYX09VVFNUQU5ESU5HX0NNRAkJCQkJCTI1NgotI2RlZmluZSBBUkNNU1JfTUFYX0ZSRUVDQ0JfTlVNCQkJCQkJCTMyMAotI2RlZmluZSBBUkNNU1JfRFJJVkVSX1ZFUlNJT04JCSAgICAgIkRyaXZlciBWZXJzaW9uIDEuMjAuMDAuMTUgMjAxMC8wMi8wMiIKKyNpZmRlZiBDT05GSUdfWEVOCisJI2RlZmluZSBBUkNNU1JfTUFYX0ZSRUVDQ0JfTlVNCTE2MAorI2Vsc2UKKwkjZGVmaW5lIEFSQ01TUl9NQVhfRlJFRUNDQl9OVU0JMzIwCisjZW5kaWYKKyNkZWZpbmUgQVJDTVNSX0RSSVZFUl9WRVJTSU9OCQkgICAgICJEcml2ZXIgVmVyc2lvbiAxLjIwLjAwLjE1IDIwMTAvMDgvMDUiCiAjZGVmaW5lIEFSQ01TUl9TQ1NJX0lOSVRJQVRPUl9JRAkJCQkJCTI1NQogI2RlZmluZSBBUkNNU1JfTUFYX1hGRVJfU0VDVE9SUwkJCQkJCQk1MTIKICNkZWZpbmUgQVJDTVNSX01BWF9YRkVSX1NFQ1RPUlNfQgkJCQkJCTQwOTYKQEAgLTYwLDcgKzY0LDYgQEAKICNkZWZpbmUgQVJDTVNSX01BWF9IQkJfUE9TVFFVRVVFCQkJCQkJMjY0CiAjZGVmaW5lIEFSQ01TUl9NQVhfWEZFUl9MRU4JCQkJCQkJMHgyNjAwMCAvKiAxNTJLICovCiAjZGVmaW5lIEFSQ01TUl9DREJfU0dfUEFHRV9MRU5HVEgJCQkJCQkyNTYgCi0jZGVmaW5lIFNDU0lfQ01EX0FSRUNBX1NQRUNJRklDCQkJCQkJMHhFMQogI2lmbmRlZiBQQ0lfREVWSUNFX0lEX0FSRUNBXzE4ODAKICNkZWZpbmUgUENJX0RFVklDRV9JRF9BUkVDQV8xODgwIDB4MTg4MAogICNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FyY21zci9hcmNtc3JfYXR0ci5jIGIvZHJpdmVycy9zY3NpL2FyY21zci9hcmNtc3JfYXR0ci5jCmluZGV4IGE0ZTA0YzUuLmFjZGFlMzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9hcmNtc3IvYXJjbXNyX2F0dHIuYworKysgYi9kcml2ZXJzL3Njc2kvYXJjbXNyL2FyY21zcl9hdHRyLmMKQEAgLTIsNyArMiw3IEBACiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqKiAgICAgICAgTy5TICAgOiBMaW51eAogKiogICBGSUxFIE5BTUUgIDogYXJjbXNyX2F0dHIuYwotKiogICAgICAgIEJZICAgIDogRXJpY2ggQ2hlbgorKiogICAgICAgIEJZICAgIDogTmljayBDaGVuZwogKiogICBEZXNjcmlwdGlvbjogYXR0cmlidXRlcyBleHBvcnRlZCB0byBzeXNmcyBhbmQgZGV2aWNlIGhvc3QKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoqIENvcHlyaWdodCAoQykgMjAwMiAtIDIwMDUsIEFyZWNhIFRlY2hub2xvZ3kgQ29ycG9yYXRpb24gQWxsIHJpZ2h0cyByZXNlcnZlZApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2FyY21zci9hcmNtc3JfaGJhLmMgYi9kcml2ZXJzL3Njc2kvYXJjbXNyL2FyY21zcl9oYmEuYwppbmRleCAxY2FkY2Q2Li45ODRiZDUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYXJjbXNyL2FyY21zcl9oYmEuYworKysgYi9kcml2ZXJzL3Njc2kvYXJjbXNyL2FyY21zcl9oYmEuYwpAQCAtMiw3ICsyLDcgQEAKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoqICAgICAgICBPLlMgICA6IExpbnV4CiAqKiAgIEZJTEUgTkFNRSAgOiBhcmNtc3JfaGJhLmMKLSoqICAgICAgICBCWSAgICA6IEVyaWNoIENoZW4KKyoqICAgICAgICBCWSAgICA6IE5pY2sgQ2hlbmcKICoqICAgRGVzY3JpcHRpb246IFNDU0kgUkFJRCBEZXZpY2UgRHJpdmVyIGZvcgogKiogICAgICAgICAgICAgICAgQVJFQ0EgUkFJRCBIb3N0IGFkYXB0ZXIKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKQEAgLTc2LDcgKzc2LDcgQEAKIE1PRFVMRV9MSUNFTlNFKCJEdWFsIEJTRC9HUEwiKTsKIE1PRFVMRV9WRVJTSU9OKEFSQ01TUl9EUklWRVJfVkVSU0lPTik7CiBzdGF0aWMgaW50IHNsZWVwdGltZSA9IDEwOwotc3RhdGljIGludCByZXRyeWNvdW50ID0gMzA7CitzdGF0aWMgaW50IHJldHJ5Y291bnQgPSAxMjsKIHdhaXRfcXVldWVfaGVhZF90IHdhaXRfcTsKIHN0YXRpYyBpbnQgYXJjbXNyX2lvcF9tZXNzYWdlX3hmZXIoc3RydWN0IEFkYXB0ZXJDb250cm9sQmxvY2sgKmFjYiwKIAkJCQkJc3RydWN0IHNjc2lfY21uZCAqY21kKTsKQEAgLTE4Nyw3ICsxODcsNiBAQAogCQlpZiAoaXNsZWVwID4gMCkgewogCQkJbXNsZWVwKGlzbGVlcCoxMDAwKTsKIAkJfQotCQlwcmludGsoS0VSTl9OT1RJQ0UgIndha2UtdXBcbiIpOwogCQlyZXR1cm4gMDsKIH0KIApAQCAtOTIxLDcgKzkyMCw2IEBACiB9CiAKIHN0YXRpYyB2b2lkIGFyY21zcl9kcmFpbl9kb25lcXVldWUoc3RydWN0IEFkYXB0ZXJDb250cm9sQmxvY2sgKmFjYiwgc3RydWN0IENvbW1hbmRDb250cm9sQmxvY2sgKnBDQ0IsIGJvb2wgZXJyb3IpCi0KIHsKIAlpbnQgaWQsIGx1bjsKIAlpZiAoKHBDQ0ItPmFjYiAhPSBhY2IpIHx8IChwQ0NCLT5zdGFydGRvbmUgIT0gQVJDTVNSX0NDQl9TVEFSVCkpIHsKQEAgLTk0OCw3ICs5NDYsNyBAQAogCQkJCSwgcENDQi0+c3RhcnRkb25lCiAJCQkJLCBhdG9taWNfcmVhZCgmYWNiLT5jY2JvdXRzdGFuZGluZ2NvdW50KSk7CiAJCSAgcmV0dXJuOwotCQl9CisJfQogCWFyY21zcl9yZXBvcnRfY2NiX3N0YXRlKGFjYiwgcENDQiwgZXJyb3IpOwogfQogCkBAIC05ODEsNyArOTc5LDcgQEAKIAljYXNlIEFDQl9BREFQVEVSX1RZUEVfQjogewogCQlzdHJ1Y3QgTWVzc2FnZVVuaXRfQiAqcmVnID0gYWNiLT5wbXVCOwogCQkvKmNsZWFyIGFsbCBvdXRib3VuZCBwb3N0ZWQgUSovCi0JCXdyaXRlbChBUkNNU1JfRE9PUkJFTExfSU5UX0NMRUFSX1BBVFRFUk4sICZyZWctPmlvcDJkcnZfZG9vcmJlbGwpOyAvKiBjbGVhciBkb29yYmVsbCBpbnRlcnJ1cHQgKi8KKwkJd3JpdGVsKEFSQ01TUl9ET09SQkVMTF9JTlRfQ0xFQVJfUEFUVEVSTiwgcmVnLT5pb3AyZHJ2X2Rvb3JiZWxsKTsgLyogY2xlYXIgZG9vcmJlbGwgaW50ZXJydXB0ICovCiAJCWZvciAoaSA9IDA7IGkgPCBBUkNNU1JfTUFYX0hCQl9QT1NUUVVFVUU7IGkrKykgewogCQkJaWYgKChmbGFnX2NjYiA9IHJlYWRsKCZyZWctPmRvbmVfcWJ1ZmZlcltpXSkpICE9IDApIHsKIAkJCQl3cml0ZWwoMCwgJnJlZy0+ZG9uZV9xYnVmZmVyW2ldKTsKQEAgLTE1MTEsNyArMTUwOSw2IEBACiAJCWFyY21zcl9kcmFpbl9kb25lcXVldWUoYWNiLCBwQ0NCLCBlcnJvcik7CiAJfQogfQotCiBzdGF0aWMgdm9pZCBhcmNtc3JfaGJiX3Bvc3RxdWV1ZV9pc3Ioc3RydWN0IEFkYXB0ZXJDb250cm9sQmxvY2sgKmFjYikKIHsKIAl1aW50MzJfdCBpbmRleDsKQEAgLTIxMDYsMTAgKzIxMDMsNiBAQAogCWlmIChhdG9taWNfcmVhZCgmYWNiLT5jY2JvdXRzdGFuZGluZ2NvdW50KSA+PQogCQkJQVJDTVNSX01BWF9PVVRTVEFORElOR19DTUQpCiAJCXJldHVybiBTQ1NJX01MUVVFVUVfSE9TVF9CVVNZOwotCWlmICgoc2NzaWNtZCA9PSBTQ1NJX0NNRF9BUkVDQV9TUEVDSUZJQykpIHsKLQkJcHJpbnRrKEtFUk5fTk9USUNFICJSZWNlaXZlaW5nIFNDU0lfQ01EX0FSRUNBX1NQRUNJRklDIGNvbW1hbmQuLlxuIik7Ci0JCXJldHVybiAwOwotCX0KIAljY2IgPSBhcmNtc3JfZ2V0X2ZyZWVjY2IoYWNiKTsKIAlpZiAoIWNjYikKIAkJcmV0dXJuIFNDU0lfTUxRVUVVRV9IT1NUX0JVU1k7CkBAIC0yMzkzLDYgKzIzODYsNyBAQAogCWludCBpbmRleCwgcnRuOwogCWJvb2wgZXJyb3I7CiAJcG9sbGluZ19oYmJfY2NiX3JldHJ5OgorCiAJcG9sbF9jb3VudCsrOwogCS8qIGNsZWFyIGRvb3JiZWxsIGludGVycnVwdCAqLwogCXdyaXRlbChBUkNNU1JfRE9PUkJFTExfSU5UX0NMRUFSX1BBVFRFUk4sIHJlZy0+aW9wMmRydl9kb29yYmVsbCk7CkBAIC0yNjYzLDYgKzI2NTcsNyBAQAogewogCXN0cnVjdCBNZXNzYWdlVW5pdF9BIF9faW9tZW0gKnJlZyA9IGFjYi0+cG11QTsKIAlpZiAodW5saWtlbHkoYXRvbWljX3JlYWQoJmFjYi0+cnFfbWFwX3Rva2VuKSA9PSAwKSB8fCAoKGFjYi0+YWNiX2ZsYWdzICYgQUNCX0ZfQlVTX1JFU0VUKSAhPSAwICkgfHwgKChhY2ItPmFjYl9mbGFncyAmIEFDQl9GX0FCT1JUKSAhPSAwICkpeworCQltb2RfdGltZXIoJmFjYi0+ZXRlcm5hbF90aW1lciwgamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoNiAqIEhaKSk7CiAJCXJldHVybjsKIAl9IGVsc2UgewogCQlhY2ItPmZ3X2ZsYWcgPSBGV19OT1JNQUw7CkBAIC0yNjcwLDggKzI2NjUsMTAgQEAKIAkJCWF0b21pY19zZXQoJmFjYi0+cnFfbWFwX3Rva2VuLCAxNik7CiAJCX0KIAkJYXRvbWljX3NldCgmYWNiLT5hbnRlX3Rva2VuX3ZhbHVlLCBhdG9taWNfcmVhZCgmYWNiLT5ycV9tYXBfdG9rZW4pKTsKLQkJaWYgKGF0b21pY19kZWNfYW5kX3Rlc3QoJmFjYi0+cnFfbWFwX3Rva2VuKSkKKwkJaWYgKGF0b21pY19kZWNfYW5kX3Rlc3QoJmFjYi0+cnFfbWFwX3Rva2VuKSkgeworCQkJbW9kX3RpbWVyKCZhY2ItPmV0ZXJuYWxfdGltZXIsIGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKDYgKiBIWikpOwogCQkJcmV0dXJuOworCQl9CiAJCXdyaXRlbChBUkNNU1JfSU5CT1VORF9NRVNHMF9HRVRfQ09ORklHLCAmcmVnLT5pbmJvdW5kX21zZ2FkZHIwKTsKIAkJbW9kX3RpbWVyKCZhY2ItPmV0ZXJuYWxfdGltZXIsIGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKDYgKiBIWikpOwogCX0KQEAgLTI2ODIsMTUgKzI2NzksMTggQEAKIHsKIAlzdHJ1Y3QgTWVzc2FnZVVuaXRfQiBfX2lvbWVtICpyZWcgPSBhY2ItPnBtdUI7CiAJaWYgKHVubGlrZWx5KGF0b21pY19yZWFkKCZhY2ItPnJxX21hcF90b2tlbikgPT0gMCkgfHwgKChhY2ItPmFjYl9mbGFncyAmIEFDQl9GX0JVU19SRVNFVCkgIT0gMCApIHx8ICgoYWNiLT5hY2JfZmxhZ3MgJiBBQ0JfRl9BQk9SVCkgIT0gMCApKXsKKwkJbW9kX3RpbWVyKCZhY2ItPmV0ZXJuYWxfdGltZXIsIGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKDYgKiBIWikpOwogCQlyZXR1cm47CiAJfSBlbHNlIHsKIAkJYWNiLT5md19mbGFnID0gRldfTk9STUFMOwogCQlpZiAoYXRvbWljX3JlYWQoJmFjYi0+YW50ZV90b2tlbl92YWx1ZSkgPT0gYXRvbWljX3JlYWQoJmFjYi0+cnFfbWFwX3Rva2VuKSkgewotCQkJYXRvbWljX3NldCgmYWNiLT5ycV9tYXBfdG9rZW4sMTYpOworCQkJYXRvbWljX3NldCgmYWNiLT5ycV9tYXBfdG9rZW4sIDE2KTsKIAkJfQogCQlhdG9taWNfc2V0KCZhY2ItPmFudGVfdG9rZW5fdmFsdWUsIGF0b21pY19yZWFkKCZhY2ItPnJxX21hcF90b2tlbikpOwotCQlpZihhdG9taWNfZGVjX2FuZF90ZXN0KCZhY2ItPnJxX21hcF90b2tlbikpCisJCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZhY2ItPnJxX21hcF90b2tlbikpIHsKKwkJCW1vZF90aW1lcigmYWNiLT5ldGVybmFsX3RpbWVyLCBqaWZmaWVzICsgbXNlY3NfdG9famlmZmllcyg2ICogSFopKTsKIAkJCXJldHVybjsKKwkJfQogCQl3cml0ZWwoQVJDTVNSX01FU1NBR0VfR0VUX0NPTkZJRywgcmVnLT5kcnYyaW9wX2Rvb3JiZWxsKTsKIAkJbW9kX3RpbWVyKCZhY2ItPmV0ZXJuYWxfdGltZXIsIGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKDYgKiBIWikpOwogCX0KQEAgLTI3MDEsNiArMjcwMSw3IEBACiB7CiAJc3RydWN0IE1lc3NhZ2VVbml0X0MgX19pb21lbSAqcmVnID0gYWNiLT5wbXVDOwogCWlmICh1bmxpa2VseShhdG9taWNfcmVhZCgmYWNiLT5ycV9tYXBfdG9rZW4pID09IDApIHx8ICgoYWNiLT5hY2JfZmxhZ3MgJiBBQ0JfRl9CVVNfUkVTRVQpICE9IDApIHx8ICgoYWNiLT5hY2JfZmxhZ3MgJiBBQ0JfRl9BQk9SVCkgIT0gMCkpIHsKKwkJbW9kX3RpbWVyKCZhY2ItPmV0ZXJuYWxfdGltZXIsIGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKDYgKiBIWikpOwogCQlyZXR1cm47CiAJfSBlbHNlIHsKIAkJYWNiLT5md19mbGFnID0gRldfTk9STUFMOwpAQCAtMjcwOCw4ICsyNzA5LDEwIEBACiAJCQlhdG9taWNfc2V0KCZhY2ItPnJxX21hcF90b2tlbiwgMTYpOwogCQl9CiAJCWF0b21pY19zZXQoJmFjYi0+YW50ZV90b2tlbl92YWx1ZSwgYXRvbWljX3JlYWQoJmFjYi0+cnFfbWFwX3Rva2VuKSk7Ci0JCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZhY2ItPnJxX21hcF90b2tlbikpCisJCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZhY2ItPnJxX21hcF90b2tlbikpIHsKKwkJCW1vZF90aW1lcigmYWNiLT5ldGVybmFsX3RpbWVyLCBqaWZmaWVzICsgbXNlY3NfdG9famlmZmllcyg2ICogSFopKTsKIAkJCXJldHVybjsKKwkJfQogCQl3cml0ZWwoQVJDTVNSX0lOQk9VTkRfTUVTRzBfR0VUX0NPTkZJRywgJnJlZy0+aW5ib3VuZF9tc2dhZGRyMCk7CiAJCXdyaXRlbChBUkNNU1JfSEJDTVVfRFJWMklPUF9NRVNTQUdFX0NNRF9ET05FLCAmcmVnLT5pbmJvdW5kX2Rvb3JiZWxsKTsKIAkJbW9kX3RpbWVyKCZhY2ItPmV0ZXJuYWxfdGltZXIsIGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKDYgKiBIWikpOwpAQCAtMjg5Nyw2ICsyOTAwLDggQEAKIAl1aW50MzJfdCBpbnRtYXNrX29yZzsKIAl1aW50OF90IHJ0bnZhbCA9IDB4MDA7CiAJaW50IGkgPSAwOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKIAlpZiAoYXRvbWljX3JlYWQoJmFjYi0+Y2Nib3V0c3RhbmRpbmdjb3VudCkgIT0gMCkgewogCQkvKiBkaXNhYmxlIGFsbCBvdXRib3VuZCBpbnRlcnJ1cHQgKi8KIAkJaW50bWFza19vcmcgPSBhcmNtc3JfZGlzYWJsZV9vdXRib3VuZF9pbnRzKGFjYik7CkBAIC0yOTA3LDcgKzI5MTIsMTIgQEAKIAkJZm9yIChpID0gMDsgaSA8IEFSQ01TUl9NQVhfRlJFRUNDQl9OVU07IGkrKykgewogCQkJY2NiID0gYWNiLT5wY2NiX3Bvb2xbaV07CiAJCQlpZiAoY2NiLT5zdGFydGRvbmUgPT0gQVJDTVNSX0NDQl9TVEFSVCkgewotCQkJCWFyY21zcl9jY2JfY29tcGxldGUoY2NiKTsKKwkJCQlzY3NpX2RtYV91bm1hcChjY2ItPnBjbWQpOworCQkJCWNjYi0+c3RhcnRkb25lID0gQVJDTVNSX0NDQl9ET05FOworCQkJCWNjYi0+Y2NiX2ZsYWdzID0gMDsKKwkJCQlzcGluX2xvY2tfaXJxc2F2ZSgmYWNiLT5jY2JsaXN0X2xvY2ssIGZsYWdzKTsKKwkJCQlsaXN0X2FkZF90YWlsKCZjY2ItPmxpc3QsICZhY2ItPmNjYl9mcmVlX2xpc3QpOworCQkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmFjYi0+Y2NibGlzdF9sb2NrLCBmbGFncyk7CiAJCQl9CiAJCX0KIAkJYXRvbWljX3NldCgmYWNiLT5jY2JvdXRzdGFuZGluZ2NvdW50LCAwKTsKQEAgLTI5MjAsOCArMjkzMCw3IEBACiAKIHN0YXRpYyBpbnQgYXJjbXNyX2J1c19yZXNldChzdHJ1Y3Qgc2NzaV9jbW5kICpjbWQpCiB7Ci0Jc3RydWN0IEFkYXB0ZXJDb250cm9sQmxvY2sgKmFjYiA9Ci0JCShzdHJ1Y3QgQWRhcHRlckNvbnRyb2xCbG9jayAqKWNtZC0+ZGV2aWNlLT5ob3N0LT5ob3N0ZGF0YTsKKwlzdHJ1Y3QgQWRhcHRlckNvbnRyb2xCbG9jayAqYWNiOwogCXVpbnQzMl90IGludG1hc2tfb3JnLCBvdXRib3VuZF9kb29yYmVsbDsKIAlpbnQgcmV0cnlfY291bnQgPSAwOwogCWludCBydG4gPSBGQUlMRUQ7CkBAIC0yOTcxLDMxICsyOTgwLDE2IEBACiAJCQkJYXRvbWljX3NldCgmYWNiLT5ycV9tYXBfdG9rZW4sIDE2KTsKIAkJCQlhdG9taWNfc2V0KCZhY2ItPmFudGVfdG9rZW5fdmFsdWUsIDE2KTsKIAkJCQlhY2ItPmZ3X2ZsYWcgPSBGV19OT1JNQUw7Ci0JCQkJaW5pdF90aW1lcigmYWNiLT5ldGVybmFsX3RpbWVyKTsKLQkJCQlhY2ItPmV0ZXJuYWxfdGltZXIuZXhwaXJlcyA9IGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKDYqSFopOwotCQkJCWFjYi0+ZXRlcm5hbF90aW1lci5kYXRhID0gKHVuc2lnbmVkIGxvbmcpIGFjYjsKLQkJCQlhY2ItPmV0ZXJuYWxfdGltZXIuZnVuY3Rpb24gPSAmYXJjbXNyX3JlcXVlc3RfZGV2aWNlX21hcDsKLQkJCQlhZGRfdGltZXIoJmFjYi0+ZXRlcm5hbF90aW1lcik7CisJCQkJbW9kX3RpbWVyKCZhY2ItPmV0ZXJuYWxfdGltZXIsIGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKDYgKiBIWikpOwogCQkJCWFjYi0+YWNiX2ZsYWdzICY9IH5BQ0JfRl9CVVNfUkVTRVQ7CiAJCQkJcnRuID0gU1VDQ0VTUzsKIAkJCQlwcmludGsoS0VSTl9FUlIgImFyY21zcjogc2NzaSAgYnVzIHJlc2V0IGVoIHJldHVybnMgd2l0aCBzdWNjZXNzXG4iKTsKIAkJCX0gZWxzZSB7CiAJCQkJYWNiLT5hY2JfZmxhZ3MgJj0gfkFDQl9GX0JVU19SRVNFVDsKLQkJCQlpZiAoYXRvbWljX3JlYWQoJmFjYi0+cnFfbWFwX3Rva2VuKSA9PSAwKSB7Ci0JCQkJCWF0b21pY19zZXQoJmFjYi0+cnFfbWFwX3Rva2VuLCAxNik7Ci0JCQkJCWF0b21pY19zZXQoJmFjYi0+YW50ZV90b2tlbl92YWx1ZSwgMTYpOwotCQkJCQlhY2ItPmZ3X2ZsYWcgPSBGV19OT1JNQUw7Ci0JCQkJCWluaXRfdGltZXIoJmFjYi0+ZXRlcm5hbF90aW1lcik7Ci0JCQkJCQlhY2ItPmV0ZXJuYWxfdGltZXIuZXhwaXJlcyA9IGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKDYqSFopOwotCQkJCQlhY2ItPmV0ZXJuYWxfdGltZXIuZGF0YSA9ICh1bnNpZ25lZCBsb25nKSBhY2I7Ci0JCQkJCWFjYi0+ZXRlcm5hbF90aW1lci5mdW5jdGlvbiA9ICZhcmNtc3JfcmVxdWVzdF9kZXZpY2VfbWFwOwotCQkJCQlhZGRfdGltZXIoJmFjYi0+ZXRlcm5hbF90aW1lcik7Ci0JCQkJfSBlbHNlIHsKLQkJCQkJYXRvbWljX3NldCgmYWNiLT5ycV9tYXBfdG9rZW4sIDE2KTsKLQkJCQkJYXRvbWljX3NldCgmYWNiLT5hbnRlX3Rva2VuX3ZhbHVlLCAxNik7Ci0JCQkJCWFjYi0+ZndfZmxhZyA9IEZXX05PUk1BTDsKLQkJCQkJbW9kX3RpbWVyKCZhY2ItPmV0ZXJuYWxfdGltZXIsIGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKDYqSFopKTsKLQkJCQl9CisJCQkJYXRvbWljX3NldCgmYWNiLT5ycV9tYXBfdG9rZW4sIDE2KTsKKwkJCQlhdG9taWNfc2V0KCZhY2ItPmFudGVfdG9rZW5fdmFsdWUsIDE2KTsKKwkJCQlhY2ItPmZ3X2ZsYWcgPSBGV19OT1JNQUw7CisJCQkJbW9kX3RpbWVyKCZhY2ItPmV0ZXJuYWxfdGltZXIsIGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKDYqSFopKTsKIAkJCQlydG4gPSBTVUNDRVNTOwogCQkJfQogCQkJYnJlYWs7CkBAIC0zMDA3LDIxICszMDAxLDEwIEBACiAJCQkJcnRuID0gRkFJTEVEOwogCQkJfSBlbHNlIHsKIAkJCQlhY2ItPmFjYl9mbGFncyAmPSB+QUNCX0ZfQlVTX1JFU0VUOwotCQkJCWlmIChhdG9taWNfcmVhZCgmYWNiLT5ycV9tYXBfdG9rZW4pID09IDApIHsKLQkJCQkJYXRvbWljX3NldCgmYWNiLT5ycV9tYXBfdG9rZW4sIDE2KTsKLQkJCQkJYXRvbWljX3NldCgmYWNiLT5hbnRlX3Rva2VuX3ZhbHVlLCAxNik7Ci0JCQkJCWFjYi0+ZndfZmxhZyA9IEZXX05PUk1BTDsKLQkJCQkJaW5pdF90aW1lcigmYWNiLT5ldGVybmFsX3RpbWVyKTsKLQkJCQkJCWFjYi0+ZXRlcm5hbF90aW1lci5leHBpcmVzID0gamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoNipIWik7Ci0JCQkJCWFjYi0+ZXRlcm5hbF90aW1lci5kYXRhID0gKHVuc2lnbmVkIGxvbmcpIGFjYjsKLQkJCQkJYWNiLT5ldGVybmFsX3RpbWVyLmZ1bmN0aW9uID0gJmFyY21zcl9yZXF1ZXN0X2RldmljZV9tYXA7Ci0JCQkJCWFkZF90aW1lcigmYWNiLT5ldGVybmFsX3RpbWVyKTsKLQkJCQl9IGVsc2UgewotCQkJCQlhdG9taWNfc2V0KCZhY2ItPnJxX21hcF90b2tlbiwgMTYpOwotCQkJCQlhdG9taWNfc2V0KCZhY2ItPmFudGVfdG9rZW5fdmFsdWUsIDE2KTsKLQkJCQkJYWNiLT5md19mbGFnID0gRldfTk9STUFMOwotCQkJCQltb2RfdGltZXIoJmFjYi0+ZXRlcm5hbF90aW1lciwgamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoNipIWikpOwotCQkJCX0KKwkJCQlhdG9taWNfc2V0KCZhY2ItPnJxX21hcF90b2tlbiwgMTYpOworCQkJCWF0b21pY19zZXQoJmFjYi0+YW50ZV90b2tlbl92YWx1ZSwgMTYpOworCQkJCWFjYi0+ZndfZmxhZyA9IEZXX05PUk1BTDsKKwkJCQltb2RfdGltZXIoJmFjYi0+ZXRlcm5hbF90aW1lciwgamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoNiAqIEhaKSk7CiAJCQkJcnRuID0gU1VDQ0VTUzsKIAkJCX0KIAkJCWJyZWFrOwpAQCAtMzA2NywzMSArMzA1MCwxNiBAQAogCQkJCWF0b21pY19zZXQoJmFjYi0+cnFfbWFwX3Rva2VuLCAxNik7CiAJCQkJYXRvbWljX3NldCgmYWNiLT5hbnRlX3Rva2VuX3ZhbHVlLCAxNik7CiAJCQkJYWNiLT5md19mbGFnID0gRldfTk9STUFMOwotCQkJCWluaXRfdGltZXIoJmFjYi0+ZXRlcm5hbF90aW1lcik7Ci0JCQkJYWNiLT5ldGVybmFsX3RpbWVyLmV4cGlyZXMgPSBqaWZmaWVzICsgbXNlY3NfdG9famlmZmllcyg2ICogSFopOwotCQkJCWFjYi0+ZXRlcm5hbF90aW1lci5kYXRhID0gKHVuc2lnbmVkIGxvbmcpIGFjYjsKLQkJCQlhY2ItPmV0ZXJuYWxfdGltZXIuZnVuY3Rpb24gPSAmYXJjbXNyX3JlcXVlc3RfZGV2aWNlX21hcDsKLQkJCQlhZGRfdGltZXIoJmFjYi0+ZXRlcm5hbF90aW1lcik7CisJCQkJbW9kX3RpbWVyKCZhY2ItPmV0ZXJuYWxfdGltZXIsIGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKDYgKiBIWikpOwogCQkJCWFjYi0+YWNiX2ZsYWdzICY9IH5BQ0JfRl9CVVNfUkVTRVQ7CiAJCQkJcnRuID0gU1VDQ0VTUzsKIAkJCQlwcmludGsoS0VSTl9FUlIgImFyY21zcjogc2NzaSBidXMgcmVzZXQgZWggcmV0dXJucyB3aXRoIHN1Y2Nlc3NcbiIpOwogCQkJfSBlbHNlIHsKIAkJCQlhY2ItPmFjYl9mbGFncyAmPSB+QUNCX0ZfQlVTX1JFU0VUOwotCQkJCWlmIChhdG9taWNfcmVhZCgmYWNiLT5ycV9tYXBfdG9rZW4pID09IDApIHsKLQkJCQkJYXRvbWljX3NldCgmYWNiLT5ycV9tYXBfdG9rZW4sIDE2KTsKLQkJCQkJYXRvbWljX3NldCgmYWNiLT5hbnRlX3Rva2VuX3ZhbHVlLCAxNik7Ci0JCQkJCWFjYi0+ZndfZmxhZyA9IEZXX05PUk1BTDsKLQkJCQkJaW5pdF90aW1lcigmYWNiLT5ldGVybmFsX3RpbWVyKTsKLQkJCQkJCWFjYi0+ZXRlcm5hbF90aW1lci5leHBpcmVzID0gamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoNipIWik7Ci0JCQkJCWFjYi0+ZXRlcm5hbF90aW1lci5kYXRhID0gKHVuc2lnbmVkIGxvbmcpIGFjYjsKLQkJCQkJYWNiLT5ldGVybmFsX3RpbWVyLmZ1bmN0aW9uID0gJmFyY21zcl9yZXF1ZXN0X2RldmljZV9tYXA7Ci0JCQkJCWFkZF90aW1lcigmYWNiLT5ldGVybmFsX3RpbWVyKTsKLQkJCQl9IGVsc2UgewotCQkJCQlhdG9taWNfc2V0KCZhY2ItPnJxX21hcF90b2tlbiwgMTYpOwotCQkJCQlhdG9taWNfc2V0KCZhY2ItPmFudGVfdG9rZW5fdmFsdWUsIDE2KTsKLQkJCQkJYWNiLT5md19mbGFnID0gRldfTk9STUFMOwotCQkJCQltb2RfdGltZXIoJmFjYi0+ZXRlcm5hbF90aW1lciwgamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoNipIWikpOwotCQkJCX0KKwkJCQlhdG9taWNfc2V0KCZhY2ItPnJxX21hcF90b2tlbiwgMTYpOworCQkJCWF0b21pY19zZXQoJmFjYi0+YW50ZV90b2tlbl92YWx1ZSwgMTYpOworCQkJCWFjYi0+ZndfZmxhZyA9IEZXX05PUk1BTDsKKwkJCQltb2RfdGltZXIoJmFjYi0+ZXRlcm5hbF90aW1lciwgamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoNipIWikpOwogCQkJCXJ0biA9IFNVQ0NFU1M7CiAJCQl9CiAJCQlicmVhazsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9pcHIuYyBiL2RyaXZlcnMvc2NzaS9pcHIuYwppbmRleCBkM2M1OTA1Li45YzVjOGJlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvaXByLmMKKysrIGIvZHJpdmVycy9zY3NpL2lwci5jCkBAIC03NTE1LDE2ICs3NTE1LDEwIEBACiB7CiAJc3RydWN0IGlwcl9pb2FfY2ZnICppb2FfY2ZnID0gaXByX2NtZC0+aW9hX2NmZzsKIAl2b2xhdGlsZSB1MzIgaW50X3JlZzsKLQlpbnQgcmM7CiAKIAlFTlRFUjsKIAlpb2FfY2ZnLT5wZGV2LT5zdGF0ZV9zYXZlZCA9IHRydWU7Ci0JcmMgPSBwY2lfcmVzdG9yZV9zdGF0ZShpb2FfY2ZnLT5wZGV2KTsKLQotCWlmIChyYyAhPSBQQ0lCSU9TX1NVQ0NFU1NGVUwpIHsKLQkJaXByX2NtZC0+cy5pb2FzYS5oZHIuaW9hc2MgPSBjcHVfdG9fYmUzMihJUFJfSU9BU0NfUENJX0FDQ0VTU19FUlJPUik7Ci0JCXJldHVybiBJUFJfUkNfSk9CX0NPTlRJTlVFOwotCX0KKwlwY2lfcmVzdG9yZV9zdGF0ZShpb2FfY2ZnLT5wZGV2KTsKIAogCWlmIChpcHJfc2V0X3BjaXhfY21kX3JlZyhpb2FfY2ZnKSkgewogCQlpcHJfY21kLT5zLmlvYXNhLmhkci5pb2FzYyA9IGNwdV90b19iZTMyKElQUl9JT0FTQ19QQ0lfQUNDRVNTX0VSUk9SKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9saWJzYXMvc2FzX3Njc2lfaG9zdC5jIGIvZHJpdmVycy9zY3NpL2xpYnNhcy9zYXNfc2NzaV9ob3N0LmMKaW5kZXggNTgxNWNiZS4uOWE3YWFmNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL2xpYnNhcy9zYXNfc2NzaV9ob3N0LmMKKysrIGIvZHJpdmVycy9zY3NpL2xpYnNhcy9zYXNfc2NzaV9ob3N0LmMKQEAgLTY0Niw2ICs2NDYsNyBAQAogCiAJc3Bpbl9sb2NrX2lycXNhdmUoc2hvc3QtPmhvc3RfbG9jaywgZmxhZ3MpOwogCWxpc3Rfc3BsaWNlX2luaXQoJnNob3N0LT5laF9jbWRfcSwgJmVoX3dvcmtfcSk7CisJc2hvc3QtPmhvc3RfZWhfc2NoZWR1bGVkID0gMDsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKHNob3N0LT5ob3N0X2xvY2ssIGZsYWdzKTsKIAogCVNBU19EUFJJTlRLKCJFbnRlciAlc1xuIiwgX19mdW5jX18pOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19iYXNlLmMgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX2Jhc2UuYwppbmRleCBiMmE4MTcwLi45ZWFkMDM5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX2Jhc2UuYworKysgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX2Jhc2UuYwpAQCAtMjE3Niw5ICsyMTc2LDkgQEAKIAkJLyogYWRqdXN0IGhiYV9xdWV1ZV9kZXB0aCwgcmVwbHlfZnJlZV9xdWV1ZV9kZXB0aCwKIAkJICogYW5kIHF1ZXVlX3NpemUKIAkJICovCi0JCWlvYy0+aGJhX3F1ZXVlX2RlcHRoIC09IHF1ZXVlX2RpZmY7Ci0JCWlvYy0+cmVwbHlfZnJlZV9xdWV1ZV9kZXB0aCAtPSBxdWV1ZV9kaWZmOwotCQlxdWV1ZV9zaXplIC09IHF1ZXVlX2RpZmY7CisJCWlvYy0+aGJhX3F1ZXVlX2RlcHRoIC09IChxdWV1ZV9kaWZmIC8gMik7CisJCWlvYy0+cmVwbHlfZnJlZV9xdWV1ZV9kZXB0aCAtPSAocXVldWVfZGlmZiAvIDIpOworCQlxdWV1ZV9zaXplID0gZmFjdHMtPk1heFJlcGx5RGVzY3JpcHRvclBvc3RRdWV1ZURlcHRoOwogCX0KIAlpb2MtPnJlcGx5X3Bvc3RfcXVldWVfZGVwdGggPSBxdWV1ZV9zaXplOwogCkBAIC0zOTQxLDYgKzM5NDEsOCBAQAogc3RhdGljIHZvaWQKIF9iYXNlX3Jlc2V0X2hhbmRsZXIoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCBpbnQgcmVzZXRfcGhhc2UpCiB7CisJbXB0MnNhc19zY3NpaF9yZXNldF9oYW5kbGVyKGlvYywgcmVzZXRfcGhhc2UpOworCW1wdDJzYXNfY3RsX3Jlc2V0X2hhbmRsZXIoaW9jLCByZXNldF9waGFzZSk7CiAJc3dpdGNoIChyZXNldF9waGFzZSkgewogCWNhc2UgTVBUMl9JT0NfUFJFX1JFU0VUOgogCQlkdG1wcmludGsoaW9jLCBwcmludGsoTVBUMlNBU19JTkZPX0ZNVCAiJXM6ICIKQEAgLTM5NzEsOCArMzk3Myw2IEBACiAJCSAgICAiTVBUMl9JT0NfRE9ORV9SRVNFVFxuIiwgaW9jLT5uYW1lLCBfX2Z1bmNfXykpOwogCQlicmVhazsKIAl9Ci0JbXB0MnNhc19zY3NpaF9yZXNldF9oYW5kbGVyKGlvYywgcmVzZXRfcGhhc2UpOwotCW1wdDJzYXNfY3RsX3Jlc2V0X2hhbmRsZXIoaW9jLCByZXNldF9waGFzZSk7CiB9CiAKIC8qKgpAQCAtNDAyNiw2ICs0MDI2LDcgQEAKIHsKIAlpbnQgcjsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOworCXU4IHBlX2NvbXBsZXRlID0gaW9jLT53YWl0X2Zvcl9wb3J0X2VuYWJsZV90b19jb21wbGV0ZTsKIAogCWR0bXByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0lORk9fRk1UICIlczogZW50ZXJcbiIsIGlvYy0+bmFtZSwKIAkgICAgX19mdW5jX18pKTsKQEAgLTQwNjgsNiArNDA2OSwxNCBAQAogCWlmIChyKQogCQlnb3RvIG91dDsKIAlfYmFzZV9yZXNldF9oYW5kbGVyKGlvYywgTVBUMl9JT0NfQUZURVJfUkVTRVQpOworCisJLyogSWYgdGhpcyBoYXJkIHJlc2V0IGlzIGNhbGxlZCB3aGlsZSBwb3J0IGVuYWJsZSBpcyBhY3RpdmUsIHRoZW4KKwkgKiB0aGVyZSBpcyBubyByZWFzb24gdG8gY2FsbCBtYWtlX2lvY19vcGVyYXRpb25hbAorCSAqLworCWlmIChwZV9jb21wbGV0ZSkgeworCQlyID0gLUVGQVVMVDsKKwkJZ290byBvdXQ7CisJfQogCXIgPSBfYmFzZV9tYWtlX2lvY19vcGVyYXRpb25hbChpb2MsIHNsZWVwX2ZsYWcpOwogCWlmICghcikKIAkJX2Jhc2VfcmVzZXRfaGFuZGxlcihpb2MsIE1QVDJfSU9DX0RPTkVfUkVTRVQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19zY3NpaC5jIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19zY3NpaC5jCmluZGV4IGVkYTM0N2MuLjVkZWQzZGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfc2NzaWguYworKysgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX3Njc2loLmMKQEAgLTgxOSw3ICs4MTksNyBAQAogfQogCiAvKioKLSAqIG1wdHNjc2loX2dldF9zY3NpX2xvb2t1cCAtIHJldHVybnMgc2NtZCBlbnRyeQorICogX3Njc2loX3Njc2lfbG9va3VwX2dldCAtIHJldHVybnMgc2NtZCBlbnRyeQogICogQGlvYzogcGVyIGFkYXB0ZXIgb2JqZWN0CiAgKiBAc21pZDogc3lzdGVtIHJlcXVlc3QgbWVzc2FnZSBpbmRleAogICoKQEAgLTgzMiw2ICs4MzIsMjggQEAKIH0KIAogLyoqCisgKiBfc2NzaWhfc2NzaV9sb29rdXBfZ2V0X2NsZWFyIC0gcmV0dXJucyBzY21kIGVudHJ5CisgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKKyAqIEBzbWlkOiBzeXN0ZW0gcmVxdWVzdCBtZXNzYWdlIGluZGV4CisgKgorICogUmV0dXJucyB0aGUgc21pZCBzdG9yZWQgc2NtZCBwb2ludGVyLgorICogVGhlbiB3aWxsIGRlcmVmcmVuY2UgdGhlIHN0b3JlZCBzY21kIHBvaW50ZXIuCisgKi8KK3N0YXRpYyBpbmxpbmUgc3RydWN0IHNjc2lfY21uZCAqCitfc2NzaWhfc2NzaV9sb29rdXBfZ2V0X2NsZWFyKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQpCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlzdHJ1Y3Qgc2NzaV9jbW5kICpzY21kOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmlvYy0+c2NzaV9sb29rdXBfbG9jaywgZmxhZ3MpOworCXNjbWQgPSBpb2MtPnNjc2lfbG9va3VwW3NtaWQgLSAxXS5zY21kOworCWlvYy0+c2NzaV9sb29rdXBbc21pZCAtIDFdLnNjbWQgPSBOVUxMOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmlvYy0+c2NzaV9sb29rdXBfbG9jaywgZmxhZ3MpOworCisJcmV0dXJuIHNjbWQ7Cit9CisKKy8qKgogICogX3Njc2loX3Njc2lfbG9va3VwX2ZpbmRfYnlfc2NtZCAtIHNjbWQgbG9va3VwCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKICAqIEBzbWlkOiBzeXN0ZW0gcmVxdWVzdCBtZXNzYWdlIGluZGV4CkBAIC0yOTgxLDkgKzMwMDMsNiBAQAogCXUxNiBoYW5kbGU7CiAKIAlmb3IgKGkgPSAwIDsgaSA8IGV2ZW50X2RhdGEtPk51bUVudHJpZXM7IGkrKykgewotCQlpZiAoZXZlbnRfZGF0YS0+UEhZW2ldLlBoeVN0YXR1cyAmCi0JCSAgICBNUEkyX0VWRU5UX1NBU19UT1BPX1BIWVNUQVRVU19WQUNBTlQpCi0JCQljb250aW51ZTsKIAkJaGFuZGxlID0gbGUxNl90b19jcHUoZXZlbnRfZGF0YS0+UEhZW2ldLkF0dGFjaGVkRGV2SGFuZGxlKTsKIAkJaWYgKCFoYW5kbGUpCiAJCQljb250aW51ZTsKQEAgLTMyMTAsNyArMzIyOSw3IEBACiAJdTE2IGNvdW50ID0gMDsKIAogCWZvciAoc21pZCA9IDE7IHNtaWQgPD0gaW9jLT5zY3NpaW9fZGVwdGg7IHNtaWQrKykgewotCQlzY21kID0gX3Njc2loX3Njc2lfbG9va3VwX2dldChpb2MsIHNtaWQpOworCQlzY21kID0gX3Njc2loX3Njc2lfbG9va3VwX2dldF9jbGVhcihpb2MsIHNtaWQpOwogCQlpZiAoIXNjbWQpCiAJCQljb250aW51ZTsKIAkJY291bnQrKzsKQEAgLTM4MDQsNyArMzgyMyw3IEBACiAJdTMyIHJlc3BvbnNlX2NvZGUgPSAwOwogCiAJbXBpX3JlcGx5ID0gbXB0MnNhc19iYXNlX2dldF9yZXBseV92aXJ0X2FkZHIoaW9jLCByZXBseSk7Ci0Jc2NtZCA9IF9zY3NpaF9zY3NpX2xvb2t1cF9nZXQoaW9jLCBzbWlkKTsKKwlzY21kID0gX3Njc2loX3Njc2lfbG9va3VwX2dldF9jbGVhcihpb2MsIHNtaWQpOwogCWlmIChzY21kID09IE5VTEwpCiAJCXJldHVybiAxOwogCkBAIC01MDA1LDYgKzUwMjQsMTIgQEAKIAkJICAgICBldmVudF9kYXRhKTsKICNlbmRpZgogCisJLyogSW4gTVBJIFJldmlzaW9uIEsgKDB4QyksIHRoZSBpbnRlcm5hbCBkZXZpY2UgcmVzZXQgY29tcGxldGUgd2FzCisJICogaW1wbGVtZW50ZWQsIHNvIGF2b2lkIHNldHRpbmcgdG1fYnVzeSBmbGFnIGZvciBvbGRlciBmaXJtd2FyZS4KKwkgKi8KKwlpZiAoKGlvYy0+ZmFjdHMuSGVhZGVyVmVyc2lvbiA+PiA4KSA8IDB4QykKKwkJcmV0dXJuOworCiAJaWYgKGV2ZW50X2RhdGEtPlJlYXNvbkNvZGUgIT0KIAkgICAgTVBJMl9FVkVOVF9TQVNfREVWX1NUQVRfUkNfSU5URVJOQUxfREVWSUNFX1JFU0VUICYmCiAJICAgZXZlbnRfZGF0YS0+UmVhc29uQ29kZSAhPQpAQCAtNTA5OSw2ICs1MTI0LDcgQEAKICAgICBzdHJ1Y3QgZndfZXZlbnRfd29yayAqZndfZXZlbnQpCiB7CiAJc3RydWN0IHNjc2lfY21uZCAqc2NtZDsKKwlzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnNkZXY7CiAJdTE2IHNtaWQsIGhhbmRsZTsKIAl1MzIgbHVuOwogCXN0cnVjdCBNUFQyU0FTX0RFVklDRSAqc2FzX2RldmljZV9wcml2X2RhdGE7CkBAIC01MTA5LDEyICs1MTM1LDE3IEBACiAJTXBpMkV2ZW50RGF0YVNhc0Jyb2FkY2FzdFByaW1pdGl2ZV90ICpldmVudF9kYXRhID0gZndfZXZlbnQtPmV2ZW50X2RhdGE7CiAjZW5kaWYKIAl1MTYgaW9jX3N0YXR1czsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCByOworCiAJZGV3dHByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0lORk9fRk1UICJicm9hZGNhc3QgcHJpbWF0aXZlOiAiCiAJICAgICJwaHkgbnVtYmVyKCVkKSwgd2lkdGgoJWQpXG4iLCBpb2MtPm5hbWUsIGV2ZW50X2RhdGEtPlBoeU51bSwKIAkgICAgZXZlbnRfZGF0YS0+UG9ydFdpZHRoKSk7CiAJZHRtcHJpbnRrKGlvYywgcHJpbnRrKE1QVDJTQVNfSU5GT19GTVQgIiVzOiBlbnRlclxuIiwgaW9jLT5uYW1lLAogCSAgICBfX2Z1bmNfXykpOwogCisJc3Bpbl9sb2NrX2lycXNhdmUoJmlvYy0+c2NzaV9sb29rdXBfbG9jaywgZmxhZ3MpOworCWlvYy0+YnJvYWRjYXN0X2Flbl9idXN5ID0gMDsKIAl0ZXJtaW5hdGlvbl9jb3VudCA9IDA7CiAJcXVlcnlfY291bnQgPSAwOwogCW1waV9yZXBseSA9IGlvYy0+dG1fY21kcy5yZXBseTsKQEAgLTUxMjIsNyArNTE1Myw4IEBACiAJCXNjbWQgPSBfc2NzaWhfc2NzaV9sb29rdXBfZ2V0KGlvYywgc21pZCk7CiAJCWlmICghc2NtZCkKIAkJCWNvbnRpbnVlOwotCQlzYXNfZGV2aWNlX3ByaXZfZGF0YSA9IHNjbWQtPmRldmljZS0+aG9zdGRhdGE7CisJCXNkZXYgPSBzY21kLT5kZXZpY2U7CisJCXNhc19kZXZpY2VfcHJpdl9kYXRhID0gc2Rldi0+aG9zdGRhdGE7CiAJCWlmICghc2FzX2RldmljZV9wcml2X2RhdGEgfHwgIXNhc19kZXZpY2VfcHJpdl9kYXRhLT5zYXNfdGFyZ2V0KQogCQkJY29udGludWU7CiAJCSAvKiBza2lwIGhpZGRlbiByYWlkIGNvbXBvbmVudHMgKi8KQEAgLTUxMzgsNiArNTE3MCw3IEBACiAJCWx1biA9IHNhc19kZXZpY2VfcHJpdl9kYXRhLT5sdW47CiAJCXF1ZXJ5X2NvdW50Kys7CiAKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaW9jLT5zY3NpX2xvb2t1cF9sb2NrLCBmbGFncyk7CiAJCW1wdDJzYXNfc2NzaWhfaXNzdWVfdG0oaW9jLCBoYW5kbGUsIDAsIDAsIGx1biwKIAkJICAgIE1QSTJfU0NTSVRBU0tNR01UX1RBU0tUWVBFX1FVRVJZX1RBU0ssIHNtaWQsIDMwLCBOVUxMKTsKIAkJaW9jLT50bV9jbWRzLnN0YXR1cyA9IE1QVDJfQ01EX05PVF9VU0VEOwpAQCAtNTE0NywxNCArNTE4MCwyMCBAQAogCQkgICAgKG1waV9yZXBseS0+UmVzcG9uc2VDb2RlID09CiAJCSAgICAgTVBJMl9TQ1NJVEFTS01HTVRfUlNQX1RNX1NVQ0NFRURFRCB8fAogCQkgICAgIG1waV9yZXBseS0+UmVzcG9uc2VDb2RlID09Ci0JCSAgICAgTVBJMl9TQ1NJVEFTS01HTVRfUlNQX0lPX1FVRVVFRF9PTl9JT0MpKQorCQkgICAgIE1QSTJfU0NTSVRBU0tNR01UX1JTUF9JT19RVUVVRURfT05fSU9DKSkgeworCQkJc3Bpbl9sb2NrX2lycXNhdmUoJmlvYy0+c2NzaV9sb29rdXBfbG9jaywgZmxhZ3MpOwogCQkJY29udGludWU7Ci0KLQkJbXB0MnNhc19zY3NpaF9pc3N1ZV90bShpb2MsIGhhbmRsZSwgMCwgMCwgbHVuLAotCQkgICAgTVBJMl9TQ1NJVEFTS01HTVRfVEFTS1RZUEVfQUJSVF9UQVNLX1NFVCwgMCwgMzAsIE5VTEwpOworCQl9CisJCXIgPSBtcHQyc2FzX3Njc2loX2lzc3VlX3RtKGlvYywgaGFuZGxlLCBzZGV2LT5jaGFubmVsLCBzZGV2LT5pZCwKKwkJICAgIHNkZXYtPmx1biwgTVBJMl9TQ1NJVEFTS01HTVRfVEFTS1RZUEVfQUJPUlRfVEFTSywgc21pZCwgMzAsCisJCSAgICBzY21kKTsKKwkJaWYgKHIgPT0gRkFJTEVEKQorCQkJc2Rldl9wcmludGsoS0VSTl9XQVJOSU5HLCBzZGV2LCAidGFzayBhYm9ydDogRkFJTEVEICIKKwkJCSAgICAic2NtZCglcClcbiIsIHNjbWQpOwogCQl0ZXJtaW5hdGlvbl9jb3VudCArPSBsZTMyX3RvX2NwdShtcGlfcmVwbHktPlRlcm1pbmF0aW9uQ291bnQpOworCQlzcGluX2xvY2tfaXJxc2F2ZSgmaW9jLT5zY3NpX2xvb2t1cF9sb2NrLCBmbGFncyk7CiAJfQotCWlvYy0+YnJvYWRjYXN0X2Flbl9idXN5ID0gMDsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpb2MtPnNjc2lfbG9va3VwX2xvY2ssIGZsYWdzKTsKIAogCWR0bXByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0lORk9fRk1UCiAJICAgICIlcyAtIGV4aXQsIHF1ZXJ5X2NvdW50ID0gJWQgdGVybWluYXRpb25fY291bnQgPSAlZFxuIiwKQEAgLTY2MjYsNiArNjY2NSw3IEBACiAJCWRlc3Ryb3lfd29ya3F1ZXVlKHdxKTsKIAogCS8qIHJlbGVhc2UgYWxsIHRoZSB2b2x1bWVzICovCisJX3Njc2loX2lyX3NodXRkb3duKGlvYyk7CiAJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHJhaWRfZGV2aWNlLCBuZXh0LCAmaW9jLT5yYWlkX2RldmljZV9saXN0LAogCSAgICBsaXN0KSB7CiAJCWlmIChyYWlkX2RldmljZS0+c3RhcmdldCkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3BtY3JhaWQuYyBiL2RyaXZlcnMvc2NzaS9wbWNyYWlkLmMKaW5kZXggMzAwZDU5Zi4uMzIxY2YzYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3BtY3JhaWQuYworKysgYi9kcml2ZXJzL3Njc2kvcG1jcmFpZC5jCkBAIC0yMjI4LDEyICsyMjI4LDcgQEAKIAkJLyogT25jZSBlaXRoZXIgYmlzdCBvciBwY2kgcmVzZXQgaXMgZG9uZSwgcmVzdG9yZSBQQ0kgY29uZmlnCiAJCSAqIHNwYWNlLiBJZiB0aGlzIGZhaWxzLCBwcm9jZWVkIHdpdGggaGFyZCByZXNldCBhZ2FpbgogCQkgKi8KLQkJaWYgKHBjaV9yZXN0b3JlX3N0YXRlKHBpbnN0YW5jZS0+cGRldikpIHsKLQkJCXBtY3JhaWRfaW5mbygiY29uZmlnLXNwYWNlIGVycm9yIHJlc2V0dGluZyBhZ2FpblxuIik7Ci0JCQlwaW5zdGFuY2UtPmlvYV9zdGF0ZSA9IElPQV9TVEFURV9JTl9SRVNFVF9BTEVSVDsKLQkJCXBtY3JhaWRfcmVzZXRfYWxlcnQoY21kKTsKLQkJCWJyZWFrOwotCQl9CisJCXBjaV9yZXN0b3JlX3N0YXRlKHBpbnN0YW5jZS0+cGRldik7CiAKIAkJLyogZmFpbCBhbGwgcGVuZGluZyBjb21tYW5kcyAqLwogCQlwbWNyYWlkX2ZhaWxfb3V0c3RhbmRpbmdfY21kcyhwaW5zdGFuY2UpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3NkLmMgYi9kcml2ZXJzL3Njc2kvc2QuYwppbmRleCBiNjVlNjVhLi5lNTY3MzAyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvc2QuYworKysgYi9kcml2ZXJzL3Njc2kvc2QuYwpAQCAtOTkwLDMwICs5OTAsNTEgQEAKIAogc3RhdGljIHZvaWQgc2V0X21lZGlhX25vdF9wcmVzZW50KHN0cnVjdCBzY3NpX2Rpc2sgKnNka3ApCiB7Ci0Jc2RrcC0+bWVkaWFfcHJlc2VudCA9IDA7Ci0Jc2RrcC0+Y2FwYWNpdHkgPSAwOwotCXNka3AtPmRldmljZS0+Y2hhbmdlZCA9IDE7CisJaWYgKHNka3AtPm1lZGlhX3ByZXNlbnQpCisJCXNka3AtPmRldmljZS0+Y2hhbmdlZCA9IDE7CisKKwlpZiAoc2RrcC0+ZGV2aWNlLT5yZW1vdmFibGUpIHsKKwkJc2RrcC0+bWVkaWFfcHJlc2VudCA9IDA7CisJCXNka3AtPmNhcGFjaXR5ID0gMDsKKwl9Cit9CisKK3N0YXRpYyBpbnQgbWVkaWFfbm90X3ByZXNlbnQoc3RydWN0IHNjc2lfZGlzayAqc2RrcCwKKwkJCSAgICAgc3RydWN0IHNjc2lfc2Vuc2VfaGRyICpzc2hkcikKK3sKKwlpZiAoIXNjc2lfc2Vuc2VfdmFsaWQoc3NoZHIpKQorCQlyZXR1cm4gMDsKKworCS8qIG5vdCBpbnZva2VkIGZvciBjb21tYW5kcyB0aGF0IGNvdWxkIHJldHVybiBkZWZlcnJlZCBlcnJvcnMgKi8KKwlzd2l0Y2ggKHNzaGRyLT5zZW5zZV9rZXkpIHsKKwljYXNlIFVOSVRfQVRURU5USU9OOgorCWNhc2UgTk9UX1JFQURZOgorCQkvKiBtZWRpdW0gbm90IHByZXNlbnQgKi8KKwkJaWYgKHNzaGRyLT5hc2MgPT0gMHgzQSkgeworCQkJc2V0X21lZGlhX25vdF9wcmVzZW50KHNka3ApOworCQkJcmV0dXJuIDE7CisJCX0KKwl9CisJcmV0dXJuIDA7CiB9CiAKIC8qKgotICoJc2RfbWVkaWFfY2hhbmdlZCAtIGNoZWNrIGlmIG91ciBtZWRpdW0gY2hhbmdlZAotICoJQGRpc2s6IGtlcm5lbCBkZXZpY2UgZGVzY3JpcHRvciAKKyAqCXNkX2NoZWNrX2V2ZW50cyAtIGNoZWNrIG1lZGlhIGV2ZW50cworICoJQGRpc2s6IGtlcm5lbCBkZXZpY2UgZGVzY3JpcHRvcgorICoJQGNsZWFyaW5nOiBkaXNrIGV2ZW50cyBjdXJyZW50bHkgYmVpbmcgY2xlYXJlZAogICoKLSAqCVJldHVybnMgMCBpZiBub3QgYXBwbGljYWJsZSBvciBubyBjaGFuZ2U7IDEgaWYgY2hhbmdlCisgKglSZXR1cm5zIG1hc2sgb2YgRElTS19FVkVOVF8qLgogICoKICAqCU5vdGU6IHRoaXMgZnVuY3Rpb24gaXMgaW52b2tlZCBmcm9tIHRoZSBibG9jayBzdWJzeXN0ZW0uCiAgKiovCi1zdGF0aWMgaW50IHNkX21lZGlhX2NoYW5nZWQoc3RydWN0IGdlbmRpc2sgKmRpc2spCitzdGF0aWMgdW5zaWduZWQgaW50IHNkX2NoZWNrX2V2ZW50cyhzdHJ1Y3QgZ2VuZGlzayAqZGlzaywgdW5zaWduZWQgaW50IGNsZWFyaW5nKQogewogCXN0cnVjdCBzY3NpX2Rpc2sgKnNka3AgPSBzY3NpX2Rpc2soZGlzayk7CiAJc3RydWN0IHNjc2lfZGV2aWNlICpzZHAgPSBzZGtwLT5kZXZpY2U7CiAJc3RydWN0IHNjc2lfc2Vuc2VfaGRyICpzc2hkciA9IE5VTEw7CiAJaW50IHJldHZhbDsKIAotCVNDU0lfTE9HX0hMUVVFVUUoMywgc2RfcHJpbnRrKEtFUk5fSU5GTywgc2RrcCwgInNkX21lZGlhX2NoYW5nZWRcbiIpKTsKLQotCWlmICghc2RwLT5yZW1vdmFibGUpCi0JCXJldHVybiAwOworCVNDU0lfTE9HX0hMUVVFVUUoMywgc2RfcHJpbnRrKEtFUk5fSU5GTywgc2RrcCwgInNkX2NoZWNrX2V2ZW50c1xuIikpOwogCiAJLyoKIAkgKiBJZiB0aGUgZGV2aWNlIGlzIG9mZmxpbmUsIGRvbid0IHNlbmQgYW55IGNvbW1hbmRzIC0ganVzdCBwcmV0ZW5kIGFzCkBAIC0xMDQzLDQwICsxMDY0LDMyIEBACiAJCQkJCSAgICAgIHNzaGRyKTsKIAl9CiAKLQlpZiAocmV0dmFsKSB7CisJLyogZmFpbGVkIHRvIGV4ZWN1dGUgVFVSLCBhc3N1bWUgbWVkaWEgbm90IHByZXNlbnQgKi8KKwlpZiAoaG9zdF9ieXRlKHJldHZhbCkpIHsKIAkJc2V0X21lZGlhX25vdF9wcmVzZW50KHNka3ApOwogCQlnb3RvIG91dDsKIAl9CiAKKwlpZiAobWVkaWFfbm90X3ByZXNlbnQoc2RrcCwgc3NoZHIpKQorCQlnb3RvIG91dDsKKwogCS8qCiAJICogRm9yIHJlbW92YWJsZSBzY3NpIGRpc2sgd2UgaGF2ZSB0byByZWNvZ25pc2UgdGhlIHByZXNlbmNlCi0JICogb2YgYSBkaXNrIGluIHRoZSBkcml2ZS4gVGhpcyBpcyBrZXB0IGluIHRoZSBzdHJ1Y3Qgc2NzaV9kaXNrCi0JICogc3RydWN0IGFuZCB0ZXN0ZWQgYXQgb3BlbiAhICBEYW5pZWwgUm9jaGUgKGRhbkBsZWN0cmEuZnIpCisJICogb2YgYSBkaXNrIGluIHRoZSBkcml2ZS4KIAkgKi8KKwlpZiAoIXNka3AtPm1lZGlhX3ByZXNlbnQpCisJCXNkcC0+Y2hhbmdlZCA9IDE7CiAJc2RrcC0+bWVkaWFfcHJlc2VudCA9IDE7Ci0KIG91dDoKIAkvKgotCSAqIFJlcG9ydCBhIG1lZGlhIGNoYW5nZSB1bmRlciB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CisJICogc2RwLT5jaGFuZ2VkIGlzIHNldCB1bmRlciB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CiAJICoKLQkgKglNZWRpdW0gaXMgcHJlc2VudCBub3cgYW5kIHdhc24ndCBwcmVzZW50IGJlZm9yZS4KLQkgKglNZWRpdW0gd2Fzbid0IHByZXNlbnQgYmVmb3JlIGFuZCBpcyBwcmVzZW50IG5vdy4KLQkgKglNZWRpdW0gd2FzIHByZXNlbnQgYXQgYWxsIHRpbWVzLCBidXQgaXQgY2hhbmdlZCB3aGlsZQotCSAqCQl3ZSB3ZXJlbid0IGxvb2tpbmcgKHNkcC0+Y2hhbmdlZCBpcyBzZXQpLgotCSAqCi0JICogSWYgdGhlcmUgd2FzIG5vIG1lZGl1bSBiZWZvcmUgYW5kIHRoZXJlIGlzIG5vIG1lZGl1bSBub3cgdGhlbgotCSAqIGRvbid0IHJlcG9ydCBhIGNoYW5nZSwgZXZlbiBpZiBhIG1lZGl1bSB3YXMgaW5zZXJ0ZWQgYW5kIHJlbW92ZWQKLQkgKiB3aGlsZSB3ZSB3ZXJlbid0IGxvb2tpbmcuCisJICoJTWVkaXVtIHByZXNlbnQgc3RhdGUgaGFzIGNoYW5nZWQgaW4gZWl0aGVyIGRpcmVjdGlvbi4KKwkgKglEZXZpY2UgaGFzIGluZGljYXRlZCBVTklUX0FUVEVOVElPTi4KIAkgKi8KLQlyZXR2YWwgPSAoc2RrcC0+bWVkaWFfcHJlc2VudCAhPSBzZGtwLT5wcmV2aW91c19zdGF0ZSB8fAotCQkJKHNka3AtPm1lZGlhX3ByZXNlbnQgJiYgc2RwLT5jaGFuZ2VkKSk7Ci0JaWYgKHJldHZhbCkKLQkJc2Rldl9ldnRfc2VuZF9zaW1wbGUoc2RwLCBTREVWX0VWVF9NRURJQV9DSEFOR0UsIEdGUF9LRVJORUwpOwotCXNka3AtPnByZXZpb3VzX3N0YXRlID0gc2RrcC0+bWVkaWFfcHJlc2VudDsKLQotCS8qIHNkcC0+Y2hhbmdlZCBpbmRpY2F0ZXMgbWVkaXVtIHdhcyBjaGFuZ2VkIG9yIGlzIG5vdCBwcmVzZW50ICovCi0Jc2RwLT5jaGFuZ2VkID0gIXNka3AtPm1lZGlhX3ByZXNlbnQ7CiAJa2ZyZWUoc3NoZHIpOworCXJldHZhbCA9IHNkcC0+Y2hhbmdlZCA/IERJU0tfRVZFTlRfTUVESUFfQ0hBTkdFIDogMDsKKwlzZHAtPmNoYW5nZWQgPSAwOwogCXJldHVybiByZXR2YWw7CiB9CiAKQEAgLTExNjksNyArMTE4Miw3IEBACiAjaWZkZWYgQ09ORklHX0NPTVBBVAogCS5jb21wYXRfaW9jdGwJCT0gc2RfY29tcGF0X2lvY3RsLAogI2VuZGlmCi0JLm1lZGlhX2NoYW5nZWQJCT0gc2RfbWVkaWFfY2hhbmdlZCwKKwkuY2hlY2tfZXZlbnRzCQk9IHNkX2NoZWNrX2V2ZW50cywKIAkucmV2YWxpZGF0ZV9kaXNrCT0gc2RfcmV2YWxpZGF0ZV9kaXNrLAogCS51bmxvY2tfbmF0aXZlX2NhcGFjaXR5CT0gc2RfdW5sb2NrX25hdGl2ZV9jYXBhY2l0eSwKIH07CkBAIC0xMzEyLDIzICsxMzI1LDYgQEAKIAlyZXR1cm4gZ29vZF9ieXRlczsKIH0KIAotc3RhdGljIGludCBtZWRpYV9ub3RfcHJlc2VudChzdHJ1Y3Qgc2NzaV9kaXNrICpzZGtwLAotCQkJICAgICBzdHJ1Y3Qgc2NzaV9zZW5zZV9oZHIgKnNzaGRyKQotewotCi0JaWYgKCFzY3NpX3NlbnNlX3ZhbGlkKHNzaGRyKSkKLQkJcmV0dXJuIDA7Ci0JLyogbm90IGludm9rZWQgZm9yIGNvbW1hbmRzIHRoYXQgY291bGQgcmV0dXJuIGRlZmVycmVkIGVycm9ycyAqLwotCWlmIChzc2hkci0+c2Vuc2Vfa2V5ICE9IE5PVF9SRUFEWSAmJgotCSAgICBzc2hkci0+c2Vuc2Vfa2V5ICE9IFVOSVRfQVRURU5USU9OKQotCQlyZXR1cm4gMDsKLQlpZiAoc3NoZHItPmFzYyAhPSAweDNBKSAvKiBtZWRpdW0gbm90IHByZXNlbnQgKi8KLQkJcmV0dXJuIDA7Ci0KLQlzZXRfbWVkaWFfbm90X3ByZXNlbnQoc2RrcCk7Ci0JcmV0dXJuIDE7Ci19Ci0KIC8qCiAgKiBzcGludXAgZGlzayAtIGNhbGxlZCBvbmx5IGluIHNkX3JldmFsaWRhdGVfZGlzaygpCiAgKi8KQEAgLTE1MDMsNyArMTQ5OSw3IEBACiAJICovCiAJaWYgKHNkcC0+cmVtb3ZhYmxlICYmCiAJICAgIHNlbnNlX3ZhbGlkICYmIHNzaGRyLT5zZW5zZV9rZXkgPT0gTk9UX1JFQURZKQotCQlzZHAtPmNoYW5nZWQgPSAxOworCQlzZXRfbWVkaWFfbm90X3ByZXNlbnQoc2RrcCk7CiAKIAkvKgogCSAqIFdlIHVzZWQgdG8gc2V0IG1lZGlhX3ByZXNlbnQgdG8gMCBoZXJlIHRvIGluZGljYXRlIG5vIG1lZGlhCkBAIC0yMzg5LDggKzIzODUsMTAgQEAKIAogCWdkLT5kcml2ZXJmc19kZXYgPSAmc2RwLT5zZGV2X2dlbmRldjsKIAlnZC0+ZmxhZ3MgPSBHRU5IRF9GTF9FWFRfREVWVDsKLQlpZiAoc2RwLT5yZW1vdmFibGUpCisJaWYgKHNkcC0+cmVtb3ZhYmxlKSB7CiAJCWdkLT5mbGFncyB8PSBHRU5IRF9GTF9SRU1PVkFCTEU7CisJCWdkLT5ldmVudHMgfD0gRElTS19FVkVOVF9NRURJQV9DSEFOR0U7CisJfQogCiAJYWRkX2Rpc2soZ2QpOwogCXNkX2RpZl9jb25maWdfaG9zdChzZGtwKTsKQEAgLTI0NzIsNyArMjQ3MCw2IEBACiAJc2RrcC0+ZGlzayA9IGdkOwogCXNka3AtPmluZGV4ID0gaW5kZXg7CiAJYXRvbWljX3NldCgmc2RrcC0+b3BlbmVycywgMCk7Ci0Jc2RrcC0+cHJldmlvdXNfc3RhdGUgPSAxOwogCiAJaWYgKCFzZHAtPnJlcXVlc3RfcXVldWUtPnJxX3RpbWVvdXQpIHsKIAkJaWYgKHNkcC0+dHlwZSAhPSBUWVBFX01PRCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9zZC5oIGIvZHJpdmVycy9zY3NpL3NkLmgKaW5kZXggNTU0ODhmYS4uYzlkOGY2YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3NkLmgKKysrIGIvZHJpdmVycy9zY3NpL3NkLmgKQEAgLTU1LDcgKzU1LDYgQEAKIAl1OAkJbWVkaWFfcHJlc2VudDsKIAl1OAkJd3JpdGVfcHJvdDsKIAl1OAkJcHJvdGVjdGlvbl90eXBlOy8qIERhdGEgSW50ZWdyaXR5IEZpZWxkICovCi0JdW5zaWduZWQJcHJldmlvdXNfc3RhdGUgOiAxOwogCXVuc2lnbmVkCUFUTyA6IDE7CS8qIHN0YXRlIG9mIGRpc2sgQVRPIGJpdCAqLwogCXVuc2lnbmVkCVdDRSA6IDE7CS8qIHN0YXRlIG9mIGRpc2sgV0NFIGJpdCAqLwogCXVuc2lnbmVkCVJDRCA6IDE7CS8qIHN0YXRlIG9mIGRpc2sgUkNEIGJpdCwgdW51c2VkICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvc3IuYyBiL2RyaXZlcnMvc2NzaS9zci5jCmluZGV4IGJlNmJhZjguLmFlZmFkYzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9zci5jCisrKyBiL2RyaXZlcnMvc2NzaS9zci5jCkBAIC0yNDksMTAgKzI0OSw2IEBACiAJCWNkLT5kZXZpY2UtPmNoYW5nZWQgPSAwOwogCX0KIAotCS8qIGZvciBiYWNrd2FyZCBjb21wYXRpYmlsaXR5ICovCi0JaWYgKGV2ZW50cyAmIERJU0tfRVZFTlRfTUVESUFfQ0hBTkdFKQotCQlzZGV2X2V2dF9zZW5kX3NpbXBsZShjZC0+ZGV2aWNlLCBTREVWX0VWVF9NRURJQV9DSEFOR0UsCi0JCQkJICAgICBHRlBfS0VSTkVMKTsKIAlyZXR1cm4gZXZlbnRzOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NmaS9zZmlfY29yZS5jIGIvZHJpdmVycy9zZmkvc2ZpX2NvcmUuYwppbmRleCBjZWJhNTkzLi4wNDExM2U1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3NmaS9zZmlfY29yZS5jCisrKyBiL2RyaXZlcnMvc2ZpL3NmaV9jb3JlLmMKQEAgLTEwMSw3ICsxMDEsNyBAQAogCQlyZXR1cm4gTlVMTDsKIAogCWlmIChzZmlfdXNlX2lvcmVtYXApCi0JCXJldHVybiBpb3JlbWFwKHBoeXMsIHNpemUpOworCQlyZXR1cm4gaW9yZW1hcF9jYWNoZShwaHlzLCBzaXplKTsKIAllbHNlCiAJCXJldHVybiBlYXJseV9pb3JlbWFwKHBoeXMsIHNpemUpOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zaC9pbnRjL2NoaXAuYyBiL2RyaXZlcnMvc2gvaW50Yy9jaGlwLmMKaW5kZXggZGU4ODVhMC4uZjMzZTJkZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zaC9pbnRjL2NoaXAuYworKysgYi9kcml2ZXJzL3NoL2ludGMvY2hpcC5jCkBAIC0xNzMsNyArMTczLDggQEAKIAlyZXR1cm4gMDsKIH0KIAotI2RlZmluZSBWQUxJRCh4KSAoeCB8IDB4ODApCisjZGVmaW5lIFNFTlNFX1ZBTElEX0ZMQUcgMHg4MAorI2RlZmluZSBWQUxJRCh4KSAoeCB8IFNFTlNFX1ZBTElEX0ZMQUcpCiAKIHN0YXRpYyB1bnNpZ25lZCBjaGFyIGludGNfaXJxX3NlbnNlX3RhYmxlW0lSUV9UWVBFX1NFTlNFX01BU0sgKyAxXSA9IHsKIAlbSVJRX1RZUEVfRURHRV9GQUxMSU5HXSA9IFZBTElEKDApLApAQCAtMjAxLDcgKzIwMiw4IEBACiAJaWhwID0gaW50Y19maW5kX2lycShkLT5zZW5zZSwgZC0+bnJfc2Vuc2UsIGlycSk7CiAJaWYgKGlocCkgewogCQlhZGRyID0gSU5UQ19SRUcoZCwgX0lOVENfQUREUl9FKGlocC0+aGFuZGxlKSwgMCk7Ci0JCWludGNfcmVnX2Zuc1tfSU5UQ19GTihpaHAtPmhhbmRsZSldKGFkZHIsIGlocC0+aGFuZGxlLCB2YWx1ZSk7CisJCWludGNfcmVnX2Zuc1tfSU5UQ19GTihpaHAtPmhhbmRsZSldKGFkZHIsIGlocC0+aGFuZGxlLAorCQkJCQkJICAgIHZhbHVlICYgflNFTlNFX1ZBTElEX0ZMQUcpOwogCX0KIAogCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zcGkvS2NvbmZpZyBiL2RyaXZlcnMvc3BpL0tjb25maWcKaW5kZXggMTkwNjg0MC4uYmIyMzNhOWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3BpL0tjb25maWcKKysrIGIvZHJpdmVycy9zcGkvS2NvbmZpZwpAQCAtNTMsNiArNTMsMTQgQEAKIAogY29tbWVudCAiU1BJIE1hc3RlciBDb250cm9sbGVyIERyaXZlcnMiCiAKK2NvbmZpZyBTUElfQVRINzkKKwl0cmlzdGF0ZSAiQXRoZXJvcyBBUjcxWFgvQVI3MjRYL0FSOTEzWCBTUEkgY29udHJvbGxlciBkcml2ZXIiCisJZGVwZW5kcyBvbiBBVEg3OSAmJiBHRU5FUklDX0dQSU8KKwlzZWxlY3QgU1BJX0JJVEJBTkcKKwloZWxwCisJICBUaGlzIGVuYWJsZXMgc3VwcG9ydCBmb3IgdGhlIFNQSSBjb250cm9sbGVyIHByZXNlbnQgb24gdGhlCisJICBBdGhlcm9zIEFSNzFYWC9BUjcyNFgvQVI5MTNYIFNvQ3MuCisKIGNvbmZpZyBTUElfQVRNRUwKIAl0cmlzdGF0ZSAiQXRtZWwgU1BJIENvbnRyb2xsZXIiCiAJZGVwZW5kcyBvbiAoQVJDSF9BVDkxIHx8IEFWUjMyKQpAQCAtMTU2LDEwICsxNjQsMTAgQEAKIAlkZWZfYm9vbCB5IGlmIEFSQ0hfTVgzMQogCiBjb25maWcgU1BJX0lNWF9WRVJfMF83Ci0JZGVmX2Jvb2wgeSBpZiBBUkNIX01YMjUgfHwgQVJDSF9NWDM1IHx8IEFSQ0hfTVg1MQorCWRlZl9ib29sIHkgaWYgQVJDSF9NWDI1IHx8IEFSQ0hfTVgzNSB8fCBBUkNIX01YNTEgfHwgQVJDSF9NWDUzCiAKIGNvbmZpZyBTUElfSU1YX1ZFUl8yXzMKLQlkZWZfYm9vbCB5IGlmIEFSQ0hfTVg1MQorCWRlZl9ib29sIHkgaWYgQVJDSF9NWDUxIHx8IEFSQ0hfTVg1MwogCiBjb25maWcgU1BJX0lNWAogCXRyaXN0YXRlICJGcmVlc2NhbGUgaS5NWCBTUEkgY29udHJvbGxlcnMiCkBAIC0zMTAsOCArMzE4LDggQEAKIAogY29uZmlnIFNQSV9TM0M2NFhYCiAJdHJpc3RhdGUgIlNhbXN1bmcgUzNDNjRYWCBzZXJpZXMgdHlwZSBTUEkiCi0JZGVwZW5kcyBvbiBBUkNIX1MzQzY0WFggJiYgRVhQRVJJTUVOVEFMCi0Jc2VsZWN0IFMzQzY0WFhfRE1BCisJZGVwZW5kcyBvbiAoQVJDSF9TM0M2NFhYIHx8IEFSQ0hfUzVQNjRYMCkKKwlzZWxlY3QgUzNDNjRYWF9ETUEgaWYgQVJDSF9TM0M2NFhYCiAJaGVscAogCSAgU1BJIGRyaXZlciBmb3IgU2Ftc3VuZyBTM0M2NFhYIGFuZCBuZXdlciBTb0NzLgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NwaS9NYWtlZmlsZSBiL2RyaXZlcnMvc3BpL01ha2VmaWxlCmluZGV4IDNhNDI0NjMuLjg2ZDFiNWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3BpL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvc3BpL01ha2VmaWxlCkBAIC0xMCw2ICsxMCw3IEBACiAKICMgU1BJIG1hc3RlciBjb250cm9sbGVyIGRyaXZlcnMgKGJ1cykKIG9iai0kKENPTkZJR19TUElfQVRNRUwpCQkJKz0gYXRtZWxfc3BpLm8KK29iai0kKENPTkZJR19TUElfQVRINzkpCQkJKz0gYXRoNzlfc3BpLm8KIG9iai0kKENPTkZJR19TUElfQkZJTikJCQkrPSBzcGlfYmZpbjV4eC5vCiBvYmotJChDT05GSUdfU1BJX0JJVEJBTkcpCQkrPSBzcGlfYml0YmFuZy5vCiBvYmotJChDT05GSUdfU1BJX0FVMTU1MCkJCSs9IGF1MTU1MF9zcGkubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zcGkvYW1iYS1wbDAyMi5jIGIvZHJpdmVycy9zcGkvYW1iYS1wbDAyMi5jCmluZGV4IGEyYTU5MjEuLjcxYTEyMTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3BpL2FtYmEtcGwwMjIuYworKysgYi9kcml2ZXJzL3NwaS9hbWJhLXBsMDIyLmMKQEAgLTE3OTUsNyArMTc5NSw3IEBACiB7CiAJc3RydWN0IHBsMDIyX2NvbmZpZ19jaGlwIGNvbnN0ICpjaGlwX2luZm87CiAJc3RydWN0IGNoaXBfZGF0YSAqY2hpcDsKLQlzdHJ1Y3Qgc3NwX2Nsb2NrX3BhcmFtcyBjbGtfZnJlcTsKKwlzdHJ1Y3Qgc3NwX2Nsb2NrX3BhcmFtcyBjbGtfZnJlcSA9IHswLCB9OwogCWludCBzdGF0dXMgPSAwOwogCXN0cnVjdCBwbDAyMiAqcGwwMjIgPSBzcGlfbWFzdGVyX2dldF9kZXZkYXRhKHNwaS0+bWFzdGVyKTsKIAl1bnNpZ25lZCBpbnQgYml0cyA9IHNwaS0+Yml0c19wZXJfd29yZDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3BpL2F0aDc5X3NwaS5jIGIvZHJpdmVycy9zcGkvYXRoNzlfc3BpLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmNmZjgxMAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc3BpL2F0aDc5X3NwaS5jCkBAIC0wLDAgKzEsMjkyIEBACisvKgorICogU1BJIGNvbnRyb2xsZXIgZHJpdmVyIGZvciB0aGUgQXRoZXJvcyBBUjcxWFgvQVI3MjRYL0FSOTEzWCBTb0NzCisgKgorICogQ29weXJpZ2h0IChDKSAyMDA5LTIwMTEgR2Fib3IgSnVob3MgPGp1aG9zZ0BvcGVud3J0Lm9yZz4KKyAqCisgKiBUaGlzIGRyaXZlciBoYXMgYmVlbiBiYXNlZCBvbiB0aGUgc3BpLWdwaW8uYzoKKyAqCUNvcHlyaWdodCAoQykgMjAwNiwyMDA4IERhdmlkIEJyb3duZWxsCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CisjaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+CisjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9zcGkvc3BpLmg+CisjaW5jbHVkZSA8bGludXgvc3BpL3NwaV9iaXRiYW5nLmg+CisjaW5jbHVkZSA8bGludXgvYml0b3BzLmg+CisjaW5jbHVkZSA8bGludXgvZ3Bpby5oPgorCisjaW5jbHVkZSA8YXNtL21hY2gtYXRoNzkvYXI3MXh4X3JlZ3MuaD4KKyNpbmNsdWRlIDxhc20vbWFjaC1hdGg3OS9hdGg3OV9zcGlfcGxhdGZvcm0uaD4KKworI2RlZmluZSBEUlZfTkFNRQkiYXRoNzktc3BpIgorCitzdHJ1Y3QgYXRoNzlfc3BpIHsKKwlzdHJ1Y3Qgc3BpX2JpdGJhbmcJYml0YmFuZzsKKwl1MzIJCQlpb2NfYmFzZTsKKwl1MzIJCQlyZWdfY3RybDsKKwl2b2lkIF9faW9tZW0JCSpiYXNlOworfTsKKworc3RhdGljIGlubGluZSB1MzIgYXRoNzlfc3BpX3JyKHN0cnVjdCBhdGg3OV9zcGkgKnNwLCB1bnNpZ25lZCByZWcpCit7CisJcmV0dXJuIGlvcmVhZDMyKHNwLT5iYXNlICsgcmVnKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGF0aDc5X3NwaV93cihzdHJ1Y3QgYXRoNzlfc3BpICpzcCwgdW5zaWduZWQgcmVnLCB1MzIgdmFsKQoreworCWlvd3JpdGUzMih2YWwsIHNwLT5iYXNlICsgcmVnKTsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3QgYXRoNzlfc3BpICphdGg3OV9zcGlkZXZfdG9fc3Aoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKK3sKKwlyZXR1cm4gc3BpX21hc3Rlcl9nZXRfZGV2ZGF0YShzcGktPm1hc3Rlcik7Cit9CisKK3N0YXRpYyB2b2lkIGF0aDc5X3NwaV9jaGlwc2VsZWN0KHN0cnVjdCBzcGlfZGV2aWNlICpzcGksIGludCBpc19hY3RpdmUpCit7CisJc3RydWN0IGF0aDc5X3NwaSAqc3AgPSBhdGg3OV9zcGlkZXZfdG9fc3Aoc3BpKTsKKwlpbnQgY3NfaGlnaCA9IChzcGktPm1vZGUgJiBTUElfQ1NfSElHSCkgPyBpc19hY3RpdmUgOiAhaXNfYWN0aXZlOworCisJaWYgKGlzX2FjdGl2ZSkgeworCQkvKiBzZXQgaW5pdGlhbCBjbG9jayBwb2xhcml0eSAqLworCQlpZiAoc3BpLT5tb2RlICYgU1BJX0NQT0wpCisJCQlzcC0+aW9jX2Jhc2UgfD0gQVI3MVhYX1NQSV9JT0NfQ0xLOworCQllbHNlCisJCQlzcC0+aW9jX2Jhc2UgJj0gfkFSNzFYWF9TUElfSU9DX0NMSzsKKworCQlhdGg3OV9zcGlfd3Ioc3AsIEFSNzFYWF9TUElfUkVHX0lPQywgc3AtPmlvY19iYXNlKTsKKwl9CisKKwlpZiAoc3BpLT5jaGlwX3NlbGVjdCkgeworCQlzdHJ1Y3QgYXRoNzlfc3BpX2NvbnRyb2xsZXJfZGF0YSAqY2RhdGEgPSBzcGktPmNvbnRyb2xsZXJfZGF0YTsKKworCQkvKiBTUEkgaXMgbm9ybWFsbHkgYWN0aXZlLWxvdyAqLworCQlncGlvX3NldF92YWx1ZShjZGF0YS0+Z3BpbywgY3NfaGlnaCk7CisJfSBlbHNlIHsKKwkJaWYgKGNzX2hpZ2gpCisJCQlzcC0+aW9jX2Jhc2UgfD0gQVI3MVhYX1NQSV9JT0NfQ1MwOworCQllbHNlCisJCQlzcC0+aW9jX2Jhc2UgJj0gfkFSNzFYWF9TUElfSU9DX0NTMDsKKworCQlhdGg3OV9zcGlfd3Ioc3AsIEFSNzFYWF9TUElfUkVHX0lPQywgc3AtPmlvY19iYXNlKTsKKwl9CisKK30KKworc3RhdGljIGludCBhdGg3OV9zcGlfc2V0dXBfY3Moc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKK3sKKwlzdHJ1Y3QgYXRoNzlfc3BpICpzcCA9IGF0aDc5X3NwaWRldl90b19zcChzcGkpOworCXN0cnVjdCBhdGg3OV9zcGlfY29udHJvbGxlcl9kYXRhICpjZGF0YTsKKworCWNkYXRhID0gc3BpLT5jb250cm9sbGVyX2RhdGE7CisJaWYgKHNwaS0+Y2hpcF9zZWxlY3QgJiYgIWNkYXRhKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCS8qIGVuYWJsZSBHUElPIG1vZGUgKi8KKwlhdGg3OV9zcGlfd3Ioc3AsIEFSNzFYWF9TUElfUkVHX0ZTLCBBUjcxWFhfU1BJX0ZTX0dQSU8pOworCisJLyogc2F2ZSBDVFJMIHJlZ2lzdGVyICovCisJc3AtPnJlZ19jdHJsID0gYXRoNzlfc3BpX3JyKHNwLCBBUjcxWFhfU1BJX1JFR19DVFJMKTsKKwlzcC0+aW9jX2Jhc2UgPSBhdGg3OV9zcGlfcnIoc3AsIEFSNzFYWF9TUElfUkVHX0lPQyk7CisKKwkvKiBUT0RPOiBzZXR1cCBzcGVlZD8gKi8KKwlhdGg3OV9zcGlfd3Ioc3AsIEFSNzFYWF9TUElfUkVHX0NUUkwsIDB4NDMpOworCisJaWYgKHNwaS0+Y2hpcF9zZWxlY3QpIHsKKwkJaW50IHN0YXR1cyA9IDA7CisKKwkJc3RhdHVzID0gZ3Bpb19yZXF1ZXN0KGNkYXRhLT5ncGlvLCBkZXZfbmFtZSgmc3BpLT5kZXYpKTsKKwkJaWYgKHN0YXR1cykKKwkJCXJldHVybiBzdGF0dXM7CisKKwkJc3RhdHVzID0gZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KGNkYXRhLT5ncGlvLAorCQkJCQkgICAgICAgc3BpLT5tb2RlICYgU1BJX0NTX0hJR0gpOworCQlpZiAoc3RhdHVzKSB7CisJCQlncGlvX2ZyZWUoY2RhdGEtPmdwaW8pOworCQkJcmV0dXJuIHN0YXR1czsKKwkJfQorCX0gZWxzZSB7CisJCWlmIChzcGktPm1vZGUgJiBTUElfQ1NfSElHSCkKKwkJCXNwLT5pb2NfYmFzZSB8PSBBUjcxWFhfU1BJX0lPQ19DUzA7CisJCWVsc2UKKwkJCXNwLT5pb2NfYmFzZSAmPSB+QVI3MVhYX1NQSV9JT0NfQ1MwOworCQlhdGg3OV9zcGlfd3Ioc3AsIEFSNzFYWF9TUElfUkVHX0lPQywgc3AtPmlvY19iYXNlKTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgYXRoNzlfc3BpX2NsZWFudXBfY3Moc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKK3sKKwlzdHJ1Y3QgYXRoNzlfc3BpICpzcCA9IGF0aDc5X3NwaWRldl90b19zcChzcGkpOworCisJaWYgKHNwaS0+Y2hpcF9zZWxlY3QpIHsKKwkJc3RydWN0IGF0aDc5X3NwaV9jb250cm9sbGVyX2RhdGEgKmNkYXRhID0gc3BpLT5jb250cm9sbGVyX2RhdGE7CisJCWdwaW9fZnJlZShjZGF0YS0+Z3Bpbyk7CisJfQorCisJLyogcmVzdG9yZSBDVFJMIHJlZ2lzdGVyICovCisJYXRoNzlfc3BpX3dyKHNwLCBBUjcxWFhfU1BJX1JFR19DVFJMLCBzcC0+cmVnX2N0cmwpOworCS8qIGRpc2FibGUgR1BJTyBtb2RlICovCisJYXRoNzlfc3BpX3dyKHNwLCBBUjcxWFhfU1BJX1JFR19GUywgMCk7Cit9CisKK3N0YXRpYyBpbnQgYXRoNzlfc3BpX3NldHVwKHN0cnVjdCBzcGlfZGV2aWNlICpzcGkpCit7CisJaW50IHN0YXR1cyA9IDA7CisKKwlpZiAoc3BpLT5iaXRzX3Blcl93b3JkID4gMzIpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKCFzcGktPmNvbnRyb2xsZXJfc3RhdGUpIHsKKwkJc3RhdHVzID0gYXRoNzlfc3BpX3NldHVwX2NzKHNwaSk7CisJCWlmIChzdGF0dXMpCisJCQlyZXR1cm4gc3RhdHVzOworCX0KKworCXN0YXR1cyA9IHNwaV9iaXRiYW5nX3NldHVwKHNwaSk7CisJaWYgKHN0YXR1cyAmJiAhc3BpLT5jb250cm9sbGVyX3N0YXRlKQorCQlhdGg3OV9zcGlfY2xlYW51cF9jcyhzcGkpOworCisJcmV0dXJuIHN0YXR1czsKK30KKworc3RhdGljIHZvaWQgYXRoNzlfc3BpX2NsZWFudXAoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKK3sKKwlhdGg3OV9zcGlfY2xlYW51cF9jcyhzcGkpOworCXNwaV9iaXRiYW5nX2NsZWFudXAoc3BpKTsKK30KKworc3RhdGljIHUzMiBhdGg3OV9zcGlfdHhyeF9tb2RlMChzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpLCB1bnNpZ25lZCBuc2VjcywKKwkJCSAgICAgICB1MzIgd29yZCwgdTggYml0cykKK3sKKwlzdHJ1Y3QgYXRoNzlfc3BpICpzcCA9IGF0aDc5X3NwaWRldl90b19zcChzcGkpOworCXUzMiBpb2MgPSBzcC0+aW9jX2Jhc2U7CisKKwkvKiBjbG9jayBzdGFydHMgYXQgaW5hY3RpdmUgcG9sYXJpdHkgKi8KKwlmb3IgKHdvcmQgPDw9ICgzMiAtIGJpdHMpOyBsaWtlbHkoYml0cyk7IGJpdHMtLSkgeworCQl1MzIgb3V0OworCisJCWlmICh3b3JkICYgKDEgPDwgMzEpKQorCQkJb3V0ID0gaW9jIHwgQVI3MVhYX1NQSV9JT0NfRE87CisJCWVsc2UKKwkJCW91dCA9IGlvYyAmIH5BUjcxWFhfU1BJX0lPQ19ETzsKKworCQkvKiBzZXR1cCBNU0IgKHRvIHNsYXZlKSBvbiB0cmFpbGluZyBlZGdlICovCisJCWF0aDc5X3NwaV93cihzcCwgQVI3MVhYX1NQSV9SRUdfSU9DLCBvdXQpOworCQlhdGg3OV9zcGlfd3Ioc3AsIEFSNzFYWF9TUElfUkVHX0lPQywgb3V0IHwgQVI3MVhYX1NQSV9JT0NfQ0xLKTsKKworCQl3b3JkIDw8PSAxOworCX0KKworCXJldHVybiBhdGg3OV9zcGlfcnIoc3AsIEFSNzFYWF9TUElfUkVHX1JEUyk7Cit9CisKK3N0YXRpYyBfX2RldmluaXQgaW50IGF0aDc5X3NwaV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXN0cnVjdCBzcGlfbWFzdGVyICptYXN0ZXI7CisJc3RydWN0IGF0aDc5X3NwaSAqc3A7CisJc3RydWN0IGF0aDc5X3NwaV9wbGF0Zm9ybV9kYXRhICpwZGF0YTsKKwlzdHJ1Y3QgcmVzb3VyY2UJKnI7CisJaW50IHJldDsKKworCW1hc3RlciA9IHNwaV9hbGxvY19tYXN0ZXIoJnBkZXYtPmRldiwgc2l6ZW9mKCpzcCkpOworCWlmIChtYXN0ZXIgPT0gTlVMTCkgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gYWxsb2NhdGUgc3BpIG1hc3RlclxuIik7CisJCXJldHVybiAtRU5PTUVNOworCX0KKworCXNwID0gc3BpX21hc3Rlcl9nZXRfZGV2ZGF0YShtYXN0ZXIpOworCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIHNwKTsKKworCXBkYXRhID0gcGRldi0+ZGV2LnBsYXRmb3JtX2RhdGE7CisKKwltYXN0ZXItPnNldHVwID0gYXRoNzlfc3BpX3NldHVwOworCW1hc3Rlci0+Y2xlYW51cCA9IGF0aDc5X3NwaV9jbGVhbnVwOworCWlmIChwZGF0YSkgeworCQltYXN0ZXItPmJ1c19udW0gPSBwZGF0YS0+YnVzX251bTsKKwkJbWFzdGVyLT5udW1fY2hpcHNlbGVjdCA9IHBkYXRhLT5udW1fY2hpcHNlbGVjdDsKKwl9IGVsc2UgeworCQltYXN0ZXItPmJ1c19udW0gPSAtMTsKKwkJbWFzdGVyLT5udW1fY2hpcHNlbGVjdCA9IDE7CisJfQorCisJc3AtPmJpdGJhbmcubWFzdGVyID0gc3BpX21hc3Rlcl9nZXQobWFzdGVyKTsKKwlzcC0+Yml0YmFuZy5jaGlwc2VsZWN0ID0gYXRoNzlfc3BpX2NoaXBzZWxlY3Q7CisJc3AtPmJpdGJhbmcudHhyeF93b3JkW1NQSV9NT0RFXzBdID0gYXRoNzlfc3BpX3R4cnhfbW9kZTA7CisJc3AtPmJpdGJhbmcuc2V0dXBfdHJhbnNmZXIgPSBzcGlfYml0YmFuZ19zZXR1cF90cmFuc2ZlcjsKKwlzcC0+Yml0YmFuZy5mbGFncyA9IFNQSV9DU19ISUdIOworCisJciA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNFX01FTSwgMCk7CisJaWYgKHIgPT0gTlVMTCkgeworCQlyZXQgPSAtRU5PRU5UOworCQlnb3RvIGVycl9wdXRfbWFzdGVyOworCX0KKworCXNwLT5iYXNlID0gaW9yZW1hcChyLT5zdGFydCwgci0+ZW5kIC0gci0+c3RhcnQgKyAxKTsKKwlpZiAoIXNwLT5iYXNlKSB7CisJCXJldCA9IC1FTlhJTzsKKwkJZ290byBlcnJfcHV0X21hc3RlcjsKKwl9CisKKwlyZXQgPSBzcGlfYml0YmFuZ19zdGFydCgmc3AtPmJpdGJhbmcpOworCWlmIChyZXQpCisJCWdvdG8gZXJyX3VubWFwOworCisJcmV0dXJuIDA7CisKK2Vycl91bm1hcDoKKwlpb3VubWFwKHNwLT5iYXNlKTsKK2Vycl9wdXRfbWFzdGVyOgorCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIE5VTEwpOworCXNwaV9tYXN0ZXJfcHV0KHNwLT5iaXRiYW5nLm1hc3Rlcik7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgX19kZXZleGl0IGludCBhdGg3OV9zcGlfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0IGF0aDc5X3NwaSAqc3AgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKKworCXNwaV9iaXRiYW5nX3N0b3AoJnNwLT5iaXRiYW5nKTsKKwlpb3VubWFwKHNwLT5iYXNlKTsKKwlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBOVUxMKTsKKwlzcGlfbWFzdGVyX3B1dChzcC0+Yml0YmFuZy5tYXN0ZXIpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGF0aDc5X3NwaV9kcml2ZXIgPSB7CisJLnByb2JlCQk9IGF0aDc5X3NwaV9wcm9iZSwKKwkucmVtb3ZlCQk9IF9fZGV2ZXhpdF9wKGF0aDc5X3NwaV9yZW1vdmUpLAorCS5kcml2ZXIJCT0geworCQkubmFtZQk9IERSVl9OQU1FLAorCQkub3duZXIJPSBUSElTX01PRFVMRSwKKwl9LAorfTsKKworc3RhdGljIF9faW5pdCBpbnQgYXRoNzlfc3BpX2luaXQodm9pZCkKK3sKKwlyZXR1cm4gcGxhdGZvcm1fZHJpdmVyX3JlZ2lzdGVyKCZhdGg3OV9zcGlfZHJpdmVyKTsKK30KK21vZHVsZV9pbml0KGF0aDc5X3NwaV9pbml0KTsKKworc3RhdGljIF9fZXhpdCB2b2lkIGF0aDc5X3NwaV9leGl0KHZvaWQpCit7CisJcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIoJmF0aDc5X3NwaV9kcml2ZXIpOworfQorbW9kdWxlX2V4aXQoYXRoNzlfc3BpX2V4aXQpOworCitNT0RVTEVfREVTQ1JJUFRJT04oIlNQSSBjb250cm9sbGVyIGRyaXZlciBmb3IgQXRoZXJvcyBBUjcxWFgvQVI3MjRYL0FSOTEzWCIpOworTU9EVUxFX0FVVEhPUigiR2Fib3IgSnVob3MgPGp1aG9zZ0BvcGVud3J0Lm9yZz4iKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsKK01PRFVMRV9BTElBUygicGxhdGZvcm06IiBEUlZfTkFNRSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3NwaS9kd19zcGlfbW1pby5jIGIvZHJpdmVycy9zcGkvZHdfc3BpX21taW8uYwppbmRleCBkYjM1YmQ5Li4yZmEwMTJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3NwaS9kd19zcGlfbW1pby5jCisrKyBiL2RyaXZlcnMvc3BpL2R3X3NwaV9tbWlvLmMKQEAgLTksNiArOSw3IEBACiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgorI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KQEAgLTY4LDggKzY5LDggQEAKIAl9CiAKIAlkd3NtbWlvLT5jbGsgPSBjbGtfZ2V0KCZwZGV2LT5kZXYsIE5VTEwpOwotCWlmICghZHdzbW1pby0+Y2xrKSB7Ci0JCXJldCA9IC1FTk9ERVY7CisJaWYgKElTX0VSUihkd3NtbWlvLT5jbGspKSB7CisJCXJldCA9IFBUUl9FUlIoZHdzbW1pby0+Y2xrKTsKIAkJZ290byBlcnJfaXJxOwogCX0KIAljbGtfZW5hYmxlKGR3c21taW8tPmNsayk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3NwaS9zcGlfaW14LmMgYi9kcml2ZXJzL3NwaS9zcGlfaW14LmMKaW5kZXggOTQ2OTU2NC4uMWNmOWQ1ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zcGkvc3BpX2lteC5jCisrKyBiL2RyaXZlcnMvc3BpL3NwaV9pbXguYwpAQCAtNzQzLDYgKzc0MywxMiBAQAogCQkubmFtZSA9ICJpbXg1MS1lY3NwaSIsCiAJCS5kcml2ZXJfZGF0YSA9IFNQSV9JTVhfVkVSXzJfMywKIAl9LCB7CisJCS5uYW1lID0gImlteDUzLWNzcGkiLAorCQkuZHJpdmVyX2RhdGEgPSBTUElfSU1YX1ZFUl8wXzcsCisJfSwgeworCQkubmFtZSA9ICJpbXg1My1lY3NwaSIsCisJCS5kcml2ZXJfZGF0YSA9IFNQSV9JTVhfVkVSXzJfMywKKwl9LCB7CiAJCS8qIHNlbnRpbmVsICovCiAJfQogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3BpL3NwaV9zaF9tc2lvZi5jIGIvZHJpdmVycy9zcGkvc3BpX3NoX21zaW9mLmMKaW5kZXggZDkzYjY2Ny4uMmM2NjVmY2VhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3NwaS9zcGlfc2hfbXNpb2YuYworKysgYi9kcml2ZXJzL3NwaS9zcGlfc2hfbXNpb2YuYwpAQCAtNTA5LDkgKzUwOSwxMSBAQAogCWJ5dGVzX2RvbmUgPSAwOwogCiAJd2hpbGUgKGJ5dGVzX2RvbmUgPCB0LT5sZW4pIHsKKwkJdm9pZCAqcnhfYnVmID0gdC0+cnhfYnVmID8gdC0+cnhfYnVmICsgYnl0ZXNfZG9uZSA6IE5VTEw7CisJCWNvbnN0IHZvaWQgKnR4X2J1ZiA9IHQtPnR4X2J1ZiA/IHQtPnR4X2J1ZiArIGJ5dGVzX2RvbmUgOiBOVUxMOwogCQluID0gc2hfbXNpb2Zfc3BpX3R4cnhfb25jZShwLCB0eF9maWZvLCByeF9maWZvLAotCQkJCQkgICB0LT50eF9idWYgKyBieXRlc19kb25lLAotCQkJCQkgICB0LT5yeF9idWYgKyBieXRlc19kb25lLAorCQkJCQkgICB0eF9idWYsCisJCQkJCSAgIHJ4X2J1ZiwKIAkJCQkJICAgd29yZHMsIGJpdHMpOwogCQlpZiAobiA8IDApCiAJCQlicmVhazsKQEAgLTYzNSw3ICs2MzcsNyBAQAogCXJldCA9IHNwaV9iaXRiYW5nX3N0b3AoJnAtPmJpdGJhbmcpOwogCWlmICghcmV0KSB7CiAJCXBtX3J1bnRpbWVfZGlzYWJsZSgmcGRldi0+ZGV2KTsKLQkJZnJlZV9pcnEocGxhdGZvcm1fZ2V0X2lycShwZGV2LCAwKSwgc2hfbXNpb2Zfc3BpX2lycSk7CisJCWZyZWVfaXJxKHBsYXRmb3JtX2dldF9pcnEocGRldiwgMCksIHApOwogCQlpb3VubWFwKHAtPm1hcGJhc2UpOwogCQljbGtfcHV0KHAtPmNsayk7CiAJCXNwaV9tYXN0ZXJfcHV0KHAtPmJpdGJhbmcubWFzdGVyKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3BpL3NwaV90ZWdyYS5jIGIvZHJpdmVycy9zcGkvc3BpX3RlZ3JhLmMKaW5kZXggYmI3ZGYwMi4uODkxZTU5MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zcGkvc3BpX3RlZ3JhLmMKKysrIGIvZHJpdmVycy9zcGkvc3BpX3RlZ3JhLmMKQEAgLTUxMyw3ICs1MTMsNyBAQAogCX0KIAogCXRzcGktPmNsayA9IGNsa19nZXQoJnBkZXYtPmRldiwgTlVMTCk7Ci0JaWYgKElTX0VSUl9PUl9OVUxMKHRzcGktPmNsaykpIHsKKwlpZiAoSVNfRVJSKHRzcGktPmNsaykpIHsKIAkJZGV2X2VycigmcGRldi0+ZGV2LCAiY2FuIG5vdCBnZXQgY2xvY2tcbiIpOwogCQlyZXQgPSBQVFJfRVJSKHRzcGktPmNsayk7CiAJCWdvdG8gZXJyMjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3NiL0tjb25maWcgYi9kcml2ZXJzL3NzYi9LY29uZmlnCmluZGV4IDJkOGNjNDUuLjQyY2RhYTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3NiL0tjb25maWcKKysrIGIvZHJpdmVycy9zc2IvS2NvbmZpZwpAQCAtODIsNyArODIsNyBAQAogCiBjb25maWcgU1NCX1NJTEVOVAogCWJvb2wgIk5vIFNTQiBrZXJuZWwgbWVzc2FnZXMiCi0JZGVwZW5kcyBvbiBTU0IgJiYgRU1CRURERUQKKwlkZXBlbmRzIG9uIFNTQiAmJiBFWFBFUlQKIAloZWxwCiAJICBUaGlzIG9wdGlvbiB0dXJucyBvZmYgYWxsIFNvbmljcyBTaWxpY29uIEJhY2twbGFuZSBwcmludGtzLgogCSAgTm90ZSB0aGF0IHlvdSB3b24ndCBiZSBhYmxlIHRvIGlkZW50aWZ5IHByb2JsZW1zLCBvbmNlCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NzYi9wY21jaWEuYyBiL2RyaXZlcnMvc3NiL3BjbWNpYS5jCmluZGV4IGM3MzQ1ZGIuLmY4NTMzNzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3NiL3BjbWNpYS5jCisrKyBiL2RyaXZlcnMvc3NiL3BjbWNpYS5jCkBAIC03MzMsNyArNzMzLDcgQEAKIAogCS8qIEZldGNoIHRoZSB2ZW5kb3Igc3BlY2lmaWMgdHVwbGVzLiAqLwogCXJlcyA9IHBjbWNpYV9sb29wX3R1cGxlKGJ1cy0+aG9zdF9wY21jaWEsIFNTQl9QQ01DSUFfQ0lTLAotCQkJCXNzYl9wY21jaWFfZG9fZ2V0X2ludmFyaWFudHMsIHNwcm9tKTsKKwkJCQlzc2JfcGNtY2lhX2RvX2dldF9pbnZhcmlhbnRzLCBpdik7CiAJaWYgKChyZXMgPT0gMCkgfHwgKHJlcyA9PSAtRU5PU1BDKSkKIAkJcmV0dXJuIDA7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3NiL3NjYW4uYyBiL2RyaXZlcnMvc3NiL3NjYW4uYwppbmRleCA1YTA5ODVkLi4yOTg4NGMwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3NzYi9zY2FuLmMKKysrIGIvZHJpdmVycy9zc2Ivc2Nhbi5jCkBAIC00MjAsNiArNDIwLDE2IEBACiAJCQlidXMtPnBjaWNvcmUuZGV2ID0gZGV2OwogI2VuZGlmIC8qIENPTkZJR19TU0JfRFJJVkVSX1BDSUNPUkUgKi8KIAkJCWJyZWFrOworCQljYXNlIFNTQl9ERVZfRVRIRVJORVQ6CisJCQlpZiAoYnVzLT5idXN0eXBlID09IFNTQl9CVVNUWVBFX1BDSSkgeworCQkJCWlmIChidXMtPmhvc3RfcGNpLT52ZW5kb3IgPT0gUENJX1ZFTkRPUl9JRF9CUk9BRENPTSAmJgorCQkJCSAgICAoYnVzLT5ob3N0X3BjaS0+ZGV2aWNlICYgMHhGRjAwKSA9PSAweDQzMDApIHsKKwkJCQkJLyogVGhpcyBpcyBhIGRhbmdsaW5nIGV0aGVybmV0IGNvcmUgb24gYQorCQkJCQkgKiB3aXJlbGVzcyBkZXZpY2UuIElnbm9yZSBpdC4gKi8KKwkJCQkJY29udGludWU7CisJCQkJfQorCQkJfQorCQkJYnJlYWs7CiAJCWRlZmF1bHQ6CiAJCQlicmVhazsKIAkJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9taXNjZHJ2L2FyM2twcy9hcjNrcHNjb25maWcuYyBiL2RyaXZlcnMvc3RhZ2luZy9hdGg2a2wvbWlzY2Rydi9hcjNrcHMvYXIza3BzY29uZmlnLmMKaW5kZXggMGUyOThkYi4uMjliOGFiNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2F0aDZrbC9taXNjZHJ2L2FyM2twcy9hcjNrcHNjb25maWcuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvYXRoNmtsL21pc2NkcnYvYXIza3BzL2FyM2twc2NvbmZpZy5jCkBAIC0zNjAsOCArMzYwLDggQEAKICAgICAgICAgCXN0YXR1cyA9IDE7CiAgICAgICAgIAlnb3RvIGNvbXBsZXRlOwogICAgIAl9Ci0gICAgICAgIGxlbiA9IChmaXJtd2FyZS0+c2l6ZSA+IE1BWF9CREFERFJfRk9STUFUX0xFTkdUSCk/IE1BWF9CREFERFJfRk9STUFUX0xFTkdUSDogZmlybXdhcmUtPnNpemU7Ci0JbWVtY3B5KGNvbmZpZ19iZGFkZHIsIGZpcm13YXJlLT5kYXRhLGxlbik7CisJbGVuID0gbWluKGZpcm13YXJlLT5zaXplLCBNQVhfQkRBRERSX0ZPUk1BVF9MRU5HVEggLSAxKTsKKwltZW1jcHkoY29uZmlnX2JkYWRkciwgZmlybXdhcmUtPmRhdGEsIGxlbik7CiAJY29uZmlnX2JkYWRkcltsZW5dID0gJ1wwJzsKIAl3cml0ZV9iZGFkZHIoaGRldixjb25maWdfYmRhZGRyLEJEQUREUl9UWVBFX1NUUklORyk7CiAgICAgICAgCUFfUkVMRUFTRV9GSVJNV0FSRShmaXJtd2FyZSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYXV0b2ZzL2Rpcmhhc2guYyBiL2RyaXZlcnMvc3RhZ2luZy9hdXRvZnMvZGlyaGFzaC5jCmluZGV4IGQzZjQyYzguLmEwOGJkNzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hdXRvZnMvZGlyaGFzaC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9hdXRvZnMvZGlyaGFzaC5jCkBAIC04OCwxNCArODgsMTMgQEAKIAkJfQogCQlwYXRoLm1udCA9IG1udDsKIAkJcGF0aF9nZXQoJnBhdGgpOwotCQlpZiAoIWZvbGxvd19kb3duKCZwYXRoKSkgeworCQlpZiAoIWZvbGxvd19kb3duX29uZSgmcGF0aCkpIHsKIAkJCXBhdGhfcHV0KCZwYXRoKTsKIAkJCURQUklOVEsoKCJhdXRvZnM6IG5vdCBleHBpcmFibGVcCiAJCQkobm90IGEgbW91bnRlZCBkaXJlY3RvcnkpOiAlc1xuIiwgZW50LT5uYW1lKSk7CiAJCQljb250aW51ZTsKIAkJfQotCQl3aGlsZSAoZF9tb3VudHBvaW50KHBhdGguZGVudHJ5KSAmJiBmb2xsb3dfZG93bigmcGF0aCkpCi0JCQk7CisJCWZvbGxvd19kb3duKCZwYXRoLCBmYWxzZSk7ICAvLyBUT0RPOiBuZWVkIHRvIGNoZWNrIGVycm9yCiAJCXVtb3VudF9vayA9IG1heV91bW91bnQocGF0aC5tbnQpOwogCQlwYXRoX3B1dCgmcGF0aCk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9iY20vUW9zLmMgYi9kcml2ZXJzL3N0YWdpbmcvYmNtL1Fvcy5jCmluZGV4IDhjZTQ1MzYuLmZlYWRlOTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9iY20vUW9zLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2JjbS9Rb3MuYwpAQCAtMzU5LDEyICszNTksMTEgQEAKIAogCQlpZihQYWNrZXRUb0Ryb3ApCiAJCXsKLQkJCXN0cnVjdCBuZXRkZXZfcXVldWUgKnR4cSA9IG5ldGRldl9nZXRfdHhfcXVldWUoQWRhcHRlci0+ZGV2LCBpSW5kZXgpOwogCQkJaWYgKG5ldGlmX21zZ190eF9lcnIoQWRhcHRlcikpCiAJCQkJcHJfaW5mbyhQRlggIiVzOiB0eCBxdWV1ZSAlZCBvdmVybGltaXRcbiIsIAogCQkJCQlBZGFwdGVyLT5kZXYtPm5hbWUsIGlJbmRleCk7CiAKLQkJCXR4cS0+dHhfZHJvcHBlZCsrOworCQkJbmV0c3RhdHMtPnR4X2Ryb3BwZWQrKzsKIAogCQkJREVRVUVVRVBBQ0tFVChBZGFwdGVyLT5QYWNrSW5mb1tpSW5kZXhdLkZpcnN0VHhRdWV1ZSwKIAkJCQkJCUFkYXB0ZXItPlBhY2tJbmZvW2lJbmRleF0uTGFzdFR4UXVldWUpOwpAQCAtNDA0LDcgKzQwMyw3IEBACiAvLwlkb3duKCZBZGFwdGVyLT5kYXRhX3BhY2tldF9xdWV1ZV9sb2NrKTsKIAlmb3IoaVFJbmRleD1Mb3dQcmlvcml0eTsgaVFJbmRleDxIaVByaW9yaXR5OyBpUUluZGV4KyspCiAJewotCQlzdHJ1Y3QgbmV0ZGV2X3F1ZXVlICp0eHEgPSBuZXRkZXZfZ2V0X3R4X3F1ZXVlKEFkYXB0ZXItPmRldiwgaVFJbmRleCk7CisJCXN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICpuZXRzdGF0cyA9ICZBZGFwdGVyLT5kZXYtPnN0YXRzOwogCiAJCXNwaW5fbG9ja19iaCgmQWRhcHRlci0+UGFja0luZm9baVFJbmRleF0uU0ZRdWV1ZUxvY2spOwogCQl3aGlsZShBZGFwdGVyLT5QYWNrSW5mb1tpUUluZGV4XS5GaXJzdFR4UXVldWUpCkBAIC00MTMsNyArNDEyLDcgQEAKIAkJCWlmKFBhY2tldFRvRHJvcCkKIAkJCXsKIAkJCQl1aVRvdGFsUGFja2V0TGVuZ3RoID0gUGFja2V0VG9Ecm9wLT5sZW47Ci0JCQkJdHhxLT50eF9kcm9wcGVkKys7CisJCQkJbmV0c3RhdHMtPnR4X2Ryb3BwZWQrKzsKIAkJCX0KIAkJCWVsc2UKIAkJCQl1aVRvdGFsUGFja2V0TGVuZ3RoID0gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9iY20vVHJhbnNtaXQuYyBiL2RyaXZlcnMvc3RhZ2luZy9iY20vVHJhbnNtaXQuYwppbmRleCAwZjcwMDA5Li5kNWU0YTc0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYmNtL1RyYW5zbWl0LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2JjbS9UcmFuc21pdC5jCkBAIC0xNTcsMTEgKzE1NywxMSBAQAogCX0KIAllbHNlCiAJewotCQlzdHJ1Y3QgbmV0ZGV2X3F1ZXVlICp0eHEgPSBuZXRkZXZfZ2V0X3R4X3F1ZXVlKEFkYXB0ZXItPmRldiwgUXVldWVJbmRleCk7CisJCXN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICpuZXRzdGF0cyA9ICZBZGFwdGVyLT5kZXYtPnN0YXRzOwogCQlBZGFwdGVyLT5QYWNrSW5mb1tRdWV1ZUluZGV4XS51aVRvdGFsVHhCeXRlcyArPSBMZWFkZXIuUExlbmd0aDsKIAotCQl0eHEtPnR4X2J5dGVzICs9IExlYWRlci5QTGVuZ3RoOwotCQkrK3R4cS0+dHhfcGFja2V0czsKKwkJbmV0c3RhdHMtPnR4X2J5dGVzICs9IExlYWRlci5QTGVuZ3RoOworCQkrK25ldHN0YXRzLT50eF9wYWNrZXRzOwogCiAJCUFkYXB0ZXItPlBhY2tJbmZvW1F1ZXVlSW5kZXhdLnVpQ3VycmVudFRva2VuQ291bnQgLT0gTGVhZGVyLlBMZW5ndGggPDwgMzsKIAkJQWRhcHRlci0+UGFja0luZm9bUXVldWVJbmRleF0udWlTZW50Qnl0ZXMgKz0gKFBhY2tldC0+bGVuKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvc3lzL3dsX21hYzgwMjExLmMgYi9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL3N5cy93bF9tYWM4MDIxMS5jCmluZGV4IGJkZDYyOWQuLmNkODM5MmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvc3lzL3dsX21hYzgwMjExLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9zeXMvd2xfbWFjODAyMTEuYwpAQCAtMjA5LDExICsyMDksOCBAQAogCXN0cnVjdCB3bF9pbmZvICp3bCA9IGh3LT5wcml2OwogCUFTU0VSVCh3bCk7CiAJV0xfTE9DSyh3bCk7Ci0Jd2xfZG93bih3bCk7CiAJaWVlZTgwMjExX3N0b3BfcXVldWVzKGh3KTsKIAlXTF9VTkxPQ0sod2wpOwotCi0JcmV0dXJuOwogfQogCiBzdGF0aWMgaW50CkBAIC0yNDYsNyArMjQzLDE0IEBACiBzdGF0aWMgdm9pZAogd2xfb3BzX3JlbW92ZV9pbnRlcmZhY2Uoc3RydWN0IGllZWU4MDIxMV9odyAqaHcsIHN0cnVjdCBpZWVlODAyMTFfdmlmICp2aWYpCiB7Ci0JcmV0dXJuOworCXN0cnVjdCB3bF9pbmZvICp3bDsKKworCXdsID0gSFdfVE9fV0woaHcpOworCisJLyogcHV0IGRyaXZlciBpbiBkb3duIHN0YXRlICovCisJV0xfTE9DSyh3bCk7CisJd2xfZG93bih3bCk7CisJV0xfVU5MT0NLKHdsKTsKIH0KIAogc3RhdGljIGludApAQCAtMjU5LDkgKzI2Myw3IEBACiAJc3dpdGNoICh0eXBlKSB7CiAJY2FzZSBOTDgwMjExX0NIQU5fSFQyMDoKIAljYXNlIE5MODAyMTFfQ0hBTl9OT19IVDoKLQkJV0xfTE9DSyh3bCk7CiAJCWVyciA9IHdsY19zZXQod2wtPndsYywgV0xDX1NFVF9DSEFOTkVMLCBjaGFuLT5od192YWx1ZSk7Ci0JCVdMX1VOTE9DSyh3bCk7CiAJCWJyZWFrOwogCWNhc2UgTkw4MDIxMV9DSEFOX0hUNDBNSU5VUzoKIAljYXNlIE5MODAyMTFfQ0hBTl9IVDQwUExVUzoKQEAgLTI4MSw2ICsyODMsNyBAQAogCWludCBlcnIgPSAwOwogCWludCBuZXdfaW50OwogCisJV0xfTE9DSyh3bCk7CiAJaWYgKGNoYW5nZWQgJiBJRUVFODAyMTFfQ09ORl9DSEFOR0VfTElTVEVOX0lOVEVSVkFMKSB7CiAJCVdMX05PTkUoIiVzOiBTZXR0aW5nIGxpc3RlbiBpbnRlcnZhbCB0byAlZFxuIiwKIAkJCV9fZnVuY19fLCBjb25mLT5saXN0ZW5faW50ZXJ2YWwpOwpAQCAtMzM3LDYgKzM0MCw3IEBACiAJfQogCiAgY29uZmlnX291dDoKKwlXTF9VTkxPQ0sod2wpOwogCXJldHVybiBlcnI7CiB9CiAKQEAgLTQ1NSwxMyArNDU5LDIxIEBACiAKIHN0YXRpYyB2b2lkIHdsX29wc19zd19zY2FuX3N0YXJ0KHN0cnVjdCBpZWVlODAyMTFfaHcgKmh3KQogeworCXN0cnVjdCB3bF9pbmZvICp3bCA9IGh3LT5wcml2OwogCVdMX05PTkUoIlNjYW4gU3RhcnRcbiIpOworCVdMX0xPQ0sod2wpOworCXdsY19zY2FuX3N0YXJ0KHdsLT53bGMpOworCVdMX1VOTE9DSyh3bCk7CiAJcmV0dXJuOwogfQogCiBzdGF0aWMgdm9pZCB3bF9vcHNfc3dfc2Nhbl9jb21wbGV0ZShzdHJ1Y3QgaWVlZTgwMjExX2h3ICpodykKIHsKKwlzdHJ1Y3Qgd2xfaW5mbyAqd2wgPSBody0+cHJpdjsKIAlXTF9OT05FKCJTY2FuIENvbXBsZXRlXG4iKTsKKwlXTF9MT0NLKHdsKTsKKwl3bGNfc2Nhbl9zdG9wKHdsLT53bGMpOworCVdMX1VOTE9DSyh3bCk7CiAJcmV0dXJuOwogfQogCkBAIC03NzksNyArNzkxLDcgQEAKIAl3bF9mb3VuZCsrOwogCXJldHVybiB3bDsKIAotIGZhaWw6CitmYWlsOgogCXdsX2ZyZWUod2wpOwogZmFpbDE6CiAJcmV0dXJuIE5VTEw7CkBAIC0xMDkwLDcgKzExMDIsNiBAQAogCXJldHVybiAwOwogfQogCi0jaWZkZWYgTElOVVhTVEFfUFMKIHN0YXRpYyBpbnQgd2xfc3VzcGVuZChzdHJ1Y3QgcGNpX2RldiAqcGRldiwgcG1fbWVzc2FnZV90IHN0YXRlKQogewogCXN0cnVjdCB3bF9pbmZvICp3bDsKQEAgLTExMDUsMTEgKzExMTYsMTIgQEAKIAkJcmV0dXJuIC1FTk9ERVY7CiAJfQogCisJLyogb25seSBuZWVkIHRvIGZsYWcgaHcgaXMgZG93biBmb3IgcHJvcGVyIHJlc3VtZSAqLwogCVdMX0xPQ0sod2wpOwotCXdsX2Rvd24od2wpOwogCXdsLT5wdWItPmh3X3VwID0gZmFsc2U7CiAJV0xfVU5MT0NLKHdsKTsKLQlwY2lfc2F2ZV9zdGF0ZShwZGV2LCB3bC0+cGNpX3Bzc3RhdGUpOworCisJcGNpX3NhdmVfc3RhdGUocGRldik7CiAJcGNpX2Rpc2FibGVfZGV2aWNlKHBkZXYpOwogCXJldHVybiBwY2lfc2V0X3Bvd2VyX3N0YXRlKHBkZXYsIFBDSV9EM2hvdCk7CiB9CkBAIC0xMTMzLDcgKzExNDUsNyBAQAogCWlmIChlcnIpCiAJCXJldHVybiBlcnI7CiAKLQlwY2lfcmVzdG9yZV9zdGF0ZShwZGV2LCB3bC0+cGNpX3Bzc3RhdGUpOworCXBjaV9yZXN0b3JlX3N0YXRlKHBkZXYpOwogCiAJZXJyID0gcGNpX2VuYWJsZV9kZXZpY2UocGRldik7CiAJaWYgKGVycikKQEAgLTExNDUsMTMgKzExNTcsMTIgQEAKIAlpZiAoKHZhbCAmIDB4MDAwMGZmMDApICE9IDApCiAJCXBjaV93cml0ZV9jb25maWdfZHdvcmQocGRldiwgMHg0MCwgdmFsICYgMHhmZmZmMDBmZik7CiAKLQlXTF9MT0NLKHdsKTsKLQllcnIgPSB3bF91cCh3bCk7Ci0JV0xfVU5MT0NLKHdsKTsKLQorCS8qCisJKiAgZG9uZS4gZHJpdmVyIHdpbGwgYmUgcHV0IGluIHVwIHN0YXRlCisJKiAgaW4gd2xfb3BzX2FkZF9pbnRlcmZhY2UoKSBjYWxsLgorCSovCiAJcmV0dXJuIGVycjsKIH0KLSNlbmRpZgkJCQkvKiBMSU5VWFNUQV9QUyAqLwogCiBzdGF0aWMgdm9pZCB3bF9yZW1vdmUoc3RydWN0IHBjaV9kZXYgKnBkZXYpCiB7CkBAIC0xMTg0LDE0ICsxMTk1LDEyIEBACiB9CiAKIHN0YXRpYyBzdHJ1Y3QgcGNpX2RyaXZlciB3bF9wY2lfZHJpdmVyID0gewotIC5uYW1lICA9ICJicmNtODAyMTEiLAotIC5wcm9iZSA9IHdsX3BjaV9wcm9iZSwKLSNpZmRlZiBMSU5VWFNUQV9QUwotIC5zdXNwZW5kID0gd2xfc3VzcGVuZCwKLSAucmVzdW1lICA9IHdsX3Jlc3VtZSwKLSNlbmRpZgkJCQkvKiBMSU5VWFNUQV9QUyAqLwotIC5yZW1vdmUgICA9IF9fZGV2ZXhpdF9wKHdsX3JlbW92ZSksCi0gLmlkX3RhYmxlID0gd2xfaWRfdGFibGUsCisJLm5hbWUgPSAiYnJjbTgwMjExIiwKKwkucHJvYmUgPSB3bF9wY2lfcHJvYmUsCisJLnN1c3BlbmQgPSB3bF9zdXNwZW5kLAorCS5yZXN1bWUgPSB3bF9yZXN1bWUsCisJLnJlbW92ZSA9IF9fZGV2ZXhpdF9wKHdsX3JlbW92ZSksCisJLmlkX3RhYmxlID0gd2xfaWRfdGFibGUsCiB9OwogCiAvKioKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvc3lzL3dsY19tYWM4MDIxMS5jIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9zeXMvd2xjX21hYzgwMjExLmMKaW5kZXggMWQ1ZDAxYS4uZTM3ZTgwNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9zeXMvd2xjX21hYzgwMjExLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9zeXMvd2xjX21hYzgwMjExLmMKQEAgLTUxMjYsNyArNTEyNiw2IEBACiAJZmlmbyA9IHByaW8yZmlmb1twcmlvXTsKIAogCUFTU0VSVCgodWludCkgc2tiX2hlYWRyb29tKHNkdSkgPj0gVFhPRkYpOwotCUFTU0VSVCghKHNkdS0+Y2xvbmVkKSk7CiAJQVNTRVJUKCEoc2R1LT5uZXh0KSk7CiAJQVNTRVJUKCEoc2R1LT5wcmV2KSk7CiAJQVNTRVJUKGZpZm8gPCBORklGTyk7CkBAIC04NDYyLDMgKzg0NjEsMTYgQEAKIAogCWtmcmVlKHFpKTsKIH0KKworLyoKKyAqIEZsYWcgJ3NjYW4gaW4gcHJvZ3Jlc3MnIHRvIHdpdGhvbGQgZHluYW1pYyBwaHkgY2FsaWJyYXRpb24KKyAqLwordm9pZCB3bGNfc2Nhbl9zdGFydChzdHJ1Y3Qgd2xjX2luZm8gKndsYykKK3sKKwl3bGNfcGh5X2hvbGRfdXBkKHdsYy0+YmFuZC0+cGksIFBIWV9IT0xEX0ZPUl9TQ0FOLCB0cnVlKTsKK30KKwordm9pZCB3bGNfc2Nhbl9zdG9wKHN0cnVjdCB3bGNfaW5mbyAqd2xjKQoreworCXdsY19waHlfaG9sZF91cGQod2xjLT5iYW5kLT5waSwgUEhZX0hPTERfRk9SX1NDQU4sIGZhbHNlKTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvc3lzL3dsY19wdWIuaCBiL2RyaXZlcnMvc3RhZ2luZy9icmNtODAyMTEvc3lzL3dsY19wdWIuaAppbmRleCAxNDZhNjkwLi5hZmY0MTMwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYnJjbTgwMjExL3N5cy93bGNfcHViLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2JyY204MDIxMS9zeXMvd2xjX3B1Yi5oCkBAIC01NzAsNiArNTcwLDggQEAKIGV4dGVybiB1MTYgd2xjX3JhdGVfc2htX29mZnNldChzdHJ1Y3Qgd2xjX2luZm8gKndsYywgdTggcmF0ZSk7CiBleHRlcm4gdTMyIHdsY19nZXRfcnNwZWNfaGlzdG9yeShzdHJ1Y3Qgd2xjX2Jzc2NmZyAqY2ZnKTsKIGV4dGVybiB1MzIgd2xjX2dldF9jdXJyZW50X2hpZ2hlc3RfcmF0ZShzdHJ1Y3Qgd2xjX2Jzc2NmZyAqY2ZnKTsKK2V4dGVybiB2b2lkIHdsY19zY2FuX3N0YXJ0KHN0cnVjdCB3bGNfaW5mbyAqd2xjKTsKK2V4dGVybiB2b2lkIHdsY19zY2FuX3N0b3Aoc3RydWN0IHdsY19pbmZvICp3bGMpOwogCiBzdGF0aWMgaW5saW5lIGludCB3bGNfaW92YXJfZ2V0dWludChzdHJ1Y3Qgd2xjX2luZm8gKndsYywgY29uc3QgY2hhciAqbmFtZSwKIAkJCQkgICAgdWludCAqYXJnKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9LY29uZmlnIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9LY29uZmlnCmluZGV4IGFhZDQ3MzIuLjE1MDJkODAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvS2NvbmZpZworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL0tjb25maWcKQEAgLTQzOSw2ICs0MzksNyBAQAogY29uZmlnIENPTUVESV9OSV9BVE1JTwogCXRyaXN0YXRlICJOSSBBVC1NSU8gRSBzZXJpZXMgSVNBLVBOUCBjYXJkIHN1cHBvcnQiCiAJZGVwZW5kcyBvbiBJU0FQTlAgJiYgQ09NRURJX05JX1RJTyAmJiBDT01FRElfTklfQ09NTU9OCisJc2VsZWN0IENPTUVESV84MjU1CiAJZGVmYXVsdCBOCiAJLS0taGVscC0tLQogCSAgRW5hYmxlIHN1cHBvcnQgZm9yIE5hdGlvbmFsIEluc3RydW1lbnRzIEFULU1JTyBFIHNlcmllcyBjYXJkcwpAQCAtMTA0MCw2ICsxMDQxLDggQEAKIGNvbmZpZyBDT01FRElfTklfUENJTUlPCiAJdHJpc3RhdGUgIk5JIFBDSS1NSU8tRSBzZXJpZXMgYW5kIE0gc2VyaWVzIHN1cHBvcnQiCiAJZGVwZW5kcyBvbiBDT01FRElfTklfVElPICYmIENPTUVESV9OSV9DT01NT04KKwlzZWxlY3QgQ09NRURJXzgyNTUKKwlzZWxlY3QgQ09NRURJX0ZDCiAJZGVmYXVsdCBOCiAJLS0taGVscC0tLQogCSAgRW5hYmxlIHN1cHBvcnQgZm9yIE5hdGlvbmFsIEluc3RydW1lbnRzIFBDSS1NSU8tRSBzZXJpZXMgYW5kIE0gc2VyaWVzCkBAIC0xMTY0LDYgKzExNjcsNyBAQAogY29uZmlnIENPTUVESV9OSV9NSU9fQ1MKIAl0cmlzdGF0ZSAiTkkgREFRQ2FyZCBFIHNlcmllcyBQQ01DSUEgc3VwcG9ydCIKIAlkZXBlbmRzIG9uIENPTUVESV9OSV9USU8gJiYgQ09NRURJX05JX0NPTU1PTgorCXNlbGVjdCBDT01FRElfODI1NQogCXNlbGVjdCBDT01FRElfRkMKIAlkZWZhdWx0IE4KIAktLS1oZWxwLS0tCkBAIC0xMjY4LDcgKzEyNzIsNiBAQAogY29uZmlnIENPTUVESV9OSV9USU8KIAl0cmlzdGF0ZSAiTkkgZ2VuZXJhbCBwdXJwb3NlIGNvdW50ZXIgc3VwcG9ydCIKIAlkZXBlbmRzIG9uIENPTUVESV9NSVRFCi0Jc2VsZWN0IENPTUVESV84MjU1CiAJZGVmYXVsdCBOCiAJLS0taGVscC0tLQogCSAgRW5hYmxlIHN1cHBvcnQgZm9yIE5hdGlvbmFsIEluc3RydW1lbnRzIGdlbmVyYWwgcHVycG9zZSBjb3VudGVycy4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9taXRlLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbWl0ZS5jCmluZGV4IGNkMjViMjQuLmZkMjc0ZTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9taXRlLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL21pdGUuYwpAQCAtNjEsOCArNjEsNiBAQAogI2RlZmluZSBQQ0lfREFRX1NJWkUJCTQwOTYKICNkZWZpbmUgUENJX0RBUV9TSVpFXzY2MFggICAgICAgODE5MgogCi1NT0RVTEVfTElDRU5TRSgiR1BMIik7Ci0KIHN0cnVjdCBtaXRlX3N0cnVjdCAqbWl0ZV9kZXZpY2VzOwogRVhQT1JUX1NZTUJPTChtaXRlX2RldmljZXMpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfNjUyNy5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pXzY1MjcuYwppbmRleCAxNGU3MTZlLi41NDc0MWM5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfNjUyNy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV82NTI3LmMKQEAgLTUyNywzICs1MjcsNyBAQAogCiBtb2R1bGVfaW5pdChkcml2ZXJfbmk2NTI3X2luaXRfbW9kdWxlKTsKIG1vZHVsZV9leGl0KGRyaXZlcl9uaTY1MjdfY2xlYW51cF9tb2R1bGUpOworCitNT0RVTEVfQVVUSE9SKCJDb21lZGkgaHR0cDovL3d3dy5jb21lZGkub3JnIik7CitNT0RVTEVfREVTQ1JJUFRJT04oIkNvbWVkaSBsb3ctbGV2ZWwgZHJpdmVyIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfNjV4eC5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pXzY1eHguYwppbmRleCA4YjhlMmFhLi40MDNmYzA5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfNjV4eC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV82NXh4LmMKQEAgLTg3MSwzICs4NzEsNyBAQAogCiBtb2R1bGVfaW5pdChkcml2ZXJfbmlfNjV4eF9pbml0X21vZHVsZSk7CiBtb2R1bGVfZXhpdChkcml2ZXJfbmlfNjV4eF9jbGVhbnVwX21vZHVsZSk7CisKK01PRFVMRV9BVVRIT1IoIkNvbWVkaSBodHRwOi8vd3d3LmNvbWVkaS5vcmciKTsKK01PRFVMRV9ERVNDUklQVElPTigiQ29tZWRpIGxvdy1sZXZlbCBkcml2ZXIiKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV82NjB4LmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfNjYweC5jCmluZGV4IDY2MTJiMDguLmNhMmFlYWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV82NjB4LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pXzY2MHguYwpAQCAtMTQyMSwzICsxNDIxLDcgQEAKIAl9OwogCXJldHVybiAwOwogfQorCitNT0RVTEVfQVVUSE9SKCJDb21lZGkgaHR0cDovL3d3dy5jb21lZGkub3JnIik7CitNT0RVTEVfREVTQ1JJUFRJT04oIkNvbWVkaSBsb3ctbGV2ZWwgZHJpdmVyIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfNjcweC5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pXzY3MHguYwppbmRleCBlOWYwMzRlLi5kOGQ5MWY5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfNjcweC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV82NzB4LmMKQEAgLTM4NCwzICszODQsNyBAQAogCW1pdGVfbGlzdF9kZXZpY2VzKCk7CiAJcmV0dXJuIC1FSU87CiB9CisKK01PRFVMRV9BVVRIT1IoIkNvbWVkaSBodHRwOi8vd3d3LmNvbWVkaS5vcmciKTsKK01PRFVMRV9ERVNDUklQVElPTigiQ29tZWRpIGxvdy1sZXZlbCBkcml2ZXIiKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9sYWJwYy5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX2xhYnBjLmMKaW5kZXggNGQxODY4ZC4uMDcyOGMzYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX2xhYnBjLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX2xhYnBjLmMKQEAgLTU3NSw3ICs1NzUsOCBAQAogCS8qIGdyYWIgb3VyIElSUSAqLwogCWlmIChpcnEpIHsKIAkJaXNyX2ZsYWdzID0gMDsKLQkJaWYgKHRoaXNib2FyZC0+YnVzdHlwZSA9PSBwY2lfYnVzdHlwZSkKKwkJaWYgKHRoaXNib2FyZC0+YnVzdHlwZSA9PSBwY2lfYnVzdHlwZQorCQkgICAgfHwgdGhpc2JvYXJkLT5idXN0eXBlID09IHBjbWNpYV9idXN0eXBlKQogCQkJaXNyX2ZsYWdzIHw9IElSUUZfU0hBUkVEOwogCQlpZiAocmVxdWVzdF9pcnEoaXJxLCBsYWJwY19pbnRlcnJ1cHQsIGlzcl9mbGFncywKIAkJCQlkcml2ZXJfbGFicGMuZHJpdmVyX25hbWUsIGRldikpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9wY2lkaW8uYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9wY2lkaW8uYwppbmRleCA4NGExNWMzLi4wMDVkMmZlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfcGNpZGlvLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX3BjaWRpby5jCkBAIC0xMzU0LDMgKzEzNTQsNyBAQAogCiBtb2R1bGVfaW5pdChkcml2ZXJfcGNpZGlvX2luaXRfbW9kdWxlKTsKIG1vZHVsZV9leGl0KGRyaXZlcl9wY2lkaW9fY2xlYW51cF9tb2R1bGUpOworCitNT0RVTEVfQVVUSE9SKCJDb21lZGkgaHR0cDovL3d3dy5jb21lZGkub3JnIik7CitNT0RVTEVfREVTQ1JJUFRJT04oIkNvbWVkaSBsb3ctbGV2ZWwgZHJpdmVyIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfcGNpbWlvLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfcGNpbWlvLmMKaW5kZXggMjNhMzgxMi4uOTE0OGFiZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX3BjaW1pby5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9wY2ltaW8uYwpAQCAtMTg1MywzICsxODUzLDcgQEAKIAogCXJldHVybiAwOwogfQorCitNT0RVTEVfQVVUSE9SKCJDb21lZGkgaHR0cDovL3d3dy5jb21lZGkub3JnIik7CitNT0RVTEVfREVTQ1JJUFRJT04oIkNvbWVkaSBsb3ctbGV2ZWwgZHJpdmVyIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaHYvYmxrdnNjX2Rydi5jIGIvZHJpdmVycy9zdGFnaW5nL2h2L2Jsa3ZzY19kcnYuYwppbmRleCBiM2QwNWZjLi40ZmI4MDk0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaHYvYmxrdnNjX2Rydi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9odi9ibGt2c2NfZHJ2LmMKQEAgLTM2OCw2ICszNjgsNyBAQAogCQlibGtkZXYtPmdkLT5maXJzdF9taW5vciA9IDA7CiAJYmxrZGV2LT5nZC0+Zm9wcyA9ICZibG9ja19vcHM7CiAJYmxrZGV2LT5nZC0+cHJpdmF0ZV9kYXRhID0gYmxrZGV2OworCWJsa2Rldi0+Z2QtPmRyaXZlcmZzX2RldiA9ICYoYmxrZGV2LT5kZXZpY2VfY3R4LT5kZXZpY2UpOwogCXNwcmludGYoYmxrZGV2LT5nZC0+ZGlza19uYW1lLCAiaGQlYyIsICdhJyArIGRldm51bSk7CiAKIAlibGt2c2NfZG9faW5xdWlyeShibGtkZXYpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2h2L25ldHZzYy5jIGIvZHJpdmVycy9zdGFnaW5nL2h2L25ldHZzYy5jCmluZGV4IGRmOWNkMTMuLjBlZGJlNzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9odi9uZXR2c2MuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaHYvbmV0dnNjLmMKQEAgLTEyNzksNyArMTI3OSw3IEBACiAJLyogQVNTRVJUKGRldmljZSk7ICovCiAKIAlwYWNrZXQgPSBremFsbG9jKE5FVFZTQ19QQUNLRVRfU0laRSAqIHNpemVvZih1bnNpZ25lZCBjaGFyKSwKLQkJCSBHRlBfS0VSTkVMKTsKKwkJCSBHRlBfQVRPTUlDKTsKIAlpZiAoIXBhY2tldCkKIAkJcmV0dXJuOwogCWJ1ZmZlciA9IHBhY2tldDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9odi9uZXR2c2NfZHJ2LmMgYi9kcml2ZXJzL3N0YWdpbmcvaHYvbmV0dnNjX2Rydi5jCmluZGV4IDAxNDdiNDAuLmI0MWM5NjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9odi9uZXR2c2NfZHJ2LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2h2L25ldHZzY19kcnYuYwpAQCAtMjM2LDYgKzIzNiw3IEBACiAJaWYgKHN0YXR1cyA9PSAxKSB7CiAJCW5ldGlmX2NhcnJpZXJfb24obmV0KTsKIAkJbmV0aWZfd2FrZV9xdWV1ZShuZXQpOworCQluZXRpZl9ub3RpZnlfcGVlcnMobmV0KTsKIAl9IGVsc2UgewogCQluZXRpZl9jYXJyaWVyX29mZihuZXQpOwogCQluZXRpZl9zdG9wX3F1ZXVlKG5ldCk7CkBAIC0zNTgsNyArMzU5LDYgQEAKIAogCS8qIFNldCBpbml0aWFsIHN0YXRlICovCiAJbmV0aWZfY2Fycmllcl9vZmYobmV0KTsKLQluZXRpZl9zdG9wX3F1ZXVlKG5ldCk7CiAKIAluZXRfZGV2aWNlX2N0eCA9IG5ldGRldl9wcml2KG5ldCk7CiAJbmV0X2RldmljZV9jdHgtPmRldmljZV9jdHggPSBkZXZpY2VfY3R4OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NDc2X2NvcmUuYyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWRjL2FkNzQ3Nl9jb3JlLmMKaW5kZXggZGViNjhjOC4uYjhiNTRkYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NDc2X2NvcmUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc0NzZfY29yZS5jCkBAIC02OCw3ICs2OCw3IEBACiAJLyogQ29ycmVzcG9uZHMgdG8gVnJlZiAvIDJeKGJpdHMpICovCiAJdW5zaWduZWQgaW50IHNjYWxlX3V2ID0gKHN0LT5pbnRfdnJlZl9tdiAqIDEwMDApID4+IHN0LT5jaGlwX2luZm8tPmJpdHM7CiAKLQlyZXR1cm4gc3ByaW50ZihidWYsICIlZC4lZFxuIiwgc2NhbGVfdXYgLyAxMDAwLCBzY2FsZV91diAlIDEwMDApOworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkLiUwM2RcbiIsIHNjYWxlX3V2IC8gMTAwMCwgc2NhbGVfdXYgJSAxMDAwKTsKIH0KIHN0YXRpYyBJSU9fREVWSUNFX0FUVFIoaW5fc2NhbGUsIFNfSVJVR08sIGFkNzQ3Nl9zaG93X3NjYWxlLCBOVUxMLCAwKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3ODg3X2NvcmUuYyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWRjL2FkNzg4N19jb3JlLmMKaW5kZXggNjg1OTA4OS4uNWQ4NWVmYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3ODg3X2NvcmUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc4ODdfY29yZS5jCkBAIC02OCw3ICs2OCw3IEBACiAJLyogQ29ycmVzcG9uZHMgdG8gVnJlZiAvIDJeKGJpdHMpICovCiAJdW5zaWduZWQgaW50IHNjYWxlX3V2ID0gKHN0LT5pbnRfdnJlZl9tdiAqIDEwMDApID4+IHN0LT5jaGlwX2luZm8tPmJpdHM7CiAKLQlyZXR1cm4gc3ByaW50ZihidWYsICIlZC4lZFxuIiwgc2NhbGVfdXYgLyAxMDAwLCBzY2FsZV91diAlIDEwMDApOworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkLiUwM2RcbiIsIHNjYWxlX3V2IC8gMTAwMCwgc2NhbGVfdXYgJSAxMDAwKTsKIH0KIHN0YXRpYyBJSU9fREVWSUNFX0FUVFIoaW5fc2NhbGUsIFNfSVJVR08sIGFkNzg4N19zaG93X3NjYWxlLCBOVUxMLCAwKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3OTl4X2NvcmUuYyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vYWRjL2FkNzk5eF9jb3JlLmMKaW5kZXggNjMwOWQ1Mi4uODljY2YzNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3OTl4X2NvcmUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc5OXhfY29yZS5jCkBAIC00MzIsNyArNDMyLDcgQEAKIAkvKiBDb3JyZXNwb25kcyB0byBWcmVmIC8gMl4oYml0cykgKi8KIAl1bnNpZ25lZCBpbnQgc2NhbGVfdXYgPSAoc3QtPmludF92cmVmX212ICogMTAwMCkgPj4gc3QtPmNoaXBfaW5mby0+Yml0czsKIAotCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkLiVkXG4iLCBzY2FsZV91diAvIDEwMDAsIHNjYWxlX3V2ICUgMTAwMCk7CisJcmV0dXJuIHNwcmludGYoYnVmLCAiJWQuJTAzZFxuIiwgc2NhbGVfdXYgLyAxMDAwLCBzY2FsZV91diAlIDEwMDApOwogfQogCiBzdGF0aWMgSUlPX0RFVklDRV9BVFRSKGluX3NjYWxlLCBTX0lSVUdPLCBhZDc5OXhfc2hvd19zY2FsZSwgTlVMTCwgMCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2RhYy9hZDU0NDYuYyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vZGFjL2FkNTQ0Ni5jCmluZGV4IGUzMzg3Y2QuLjBmODdlY2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vZGFjL2FkNTQ0Ni5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vZGFjL2FkNTQ0Ni5jCkBAIC04Nyw3ICs4Nyw3IEBACiAJLyogQ29ycmVzcG9uZHMgdG8gVnJlZiAvIDJeKGJpdHMpICovCiAJdW5zaWduZWQgaW50IHNjYWxlX3V2ID0gKHN0LT52cmVmX212ICogMTAwMCkgPj4gc3QtPmNoaXBfaW5mby0+Yml0czsKIAotCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkLiVkXG4iLCBzY2FsZV91diAvIDEwMDAsIHNjYWxlX3V2ICUgMTAwMCk7CisJcmV0dXJuIHNwcmludGYoYnVmLCAiJWQuJTAzZFxuIiwgc2NhbGVfdXYgLyAxMDAwLCBzY2FsZV91diAlIDEwMDApOwogfQogc3RhdGljIElJT19ERVZJQ0VfQVRUUihvdXRfc2NhbGUsIFNfSVJVR08sIGFkNTQ0Nl9zaG93X3NjYWxlLCBOVUxMLCAwKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2ludGVsX3NzdC9pbnRlbG1pZF92Ml9jb250cm9sLmMgYi9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsbWlkX3YyX2NvbnRyb2wuYwppbmRleCBlMzhlODlkLi5lMmY2ZDZhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsbWlkX3YyX2NvbnRyb2wuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvaW50ZWxfc3N0L2ludGVsbWlkX3YyX2NvbnRyb2wuYwpAQCAtODc0LDcgKzg3NCwxMCBAQAogCQlzY19hY2Nlc3NbM10ucmVnX2FkZHIgPSAweDEwOTsKIAkJc2NfYWNjZXNzWzNdLm1hc2sgPSBNQVNLNjsKIAkJc2NfYWNjZXNzWzNdLnZhbHVlID0gMHgwMDsKLQkJbnVtX3ZhbCA9IDQ7CisJCXNjX2FjY2Vzc1s0XS5yZWdfYWRkciA9IDB4MTA0OworCQlzY19hY2Nlc3NbNF0udmFsdWUgPSAweDNDOworCQlzY19hY2Nlc3NbNF0ubWFzayA9IDB4ZmY7CisJCW51bV92YWwgPSA1OwogCQlicmVhazsKIAlkZWZhdWx0OgogCQlyZXR1cm4gLUVJTlZBTDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9saXJjL1RPRE8ubGlyY196aWxvZyBiL2RyaXZlcnMvc3RhZ2luZy9saXJjL1RPRE8ubGlyY196aWxvZwppbmRleCA2YWEzMTJkLi4yZDAyNjNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvbGlyYy9UT0RPLmxpcmNfemlsb2cKKysrIGIvZHJpdmVycy9zdGFnaW5nL2xpcmMvVE9ETy5saXJjX3ppbG9nCkBAIC0xLDEzICsxLDM3IEBACi1UaGUgYmluZGluZyBiZXR3ZWVuIGhkcHZyIGFuZCBsaXJjX3ppbG9nIGlzIGN1cnJlbnRseSBkaXNhYmxlZCwKKzEuIEJvdGggaXIta2JkLWkyYyBhbmQgbGlyY196aWxvZyBwcm92aWRlIHN1cHBvcnQgZm9yIFJYIGV2ZW50cy4KK1RoZSAndHhfb25seScgbGlyY196aWxvZyBtb2R1bGUgcGFyYW1ldGVyIHdpbGwgYWxsb3cgaXIta2JkLWkyYworYW5kIGxpcmNfemlsb2cgdG8gY29leGlzdCBpbiB0aGUga2VybmVsLCBpZiB0aGUgdXNlciByZXF1aXJlcyBzdWNoIGEgc2V0LXVwLgorSG93ZXZlciB0aGUgSVIgdW5pdCB3aWxsIG5vdCB3b3JrIHdlbGwgd2l0aG91dCBjb29yZGluYXRpb24gYmV0d2VlbiB0aGUKK3R3byBtb2R1bGVzLiAgQSBzaGFyZWQgbXV0ZXgsIGZvciB0cmFuc2NlaXZlciBhY2Nlc3MgbG9ja2luZywgbmVlZHMgdG8gYmUKK3N1cHBsaWVkIGJ5IGJyaWRnZSBkcml2ZXJzLCBpbiBzdHJ1Y3QgSVJfaTJfaW5pdF9kYXRhLCB0byBib3RoIGlyLWtiZC1pMmMKK2FuZCBsaXJjX3ppbG9nLCBiZWZvcmUgdGhleSB3aWxsIGNvZXhpc3QgdXNlZnVsbHkuICBUaGlzIHNob3VsZCBiZSBmaXhlZAorYmVmb3JlIG1vdmluZyBvdXQgb2Ygc3RhZ2luZy4KKworMi4gUmVmZXJlbmNlcyBhbmQgbG9ja2luZyBuZWVkIGNhcmVmdWwgZXhhbWluYXRpb24uICBGb3IgY3gxOCBhbmQgaXZ0diBQQ0kKK2NhcmRzLCB3aGljaCBhcmUgbm90IGVhc2lseSAiaG90IHVucGx1Z2dlZCIsIHRoZSBpbXBlcmZlY3Qgc3RhdGUgb2YgcmVmZXJlbmNlCitjb3VudGluZyBhbmQgbG9ja2luZyBpcyBhY2NlcHRhYmxlIGlmIG5vdCBjb3JyZWN0LiAgRm9yIFVTQiBjb25uZWN0ZWQgdW5pdHMKK2xpa2UgSEQgUFZSLCBQVlIgVVNCMiwgSFZSLTE5MDAsIGFuZCBIVlIxOTUwLCB0aGUgbGlrZWx5aG9vZCBvZiBhbiBPb29wcyBvbgordW5wbHVnIGlzIHByb2JhYmx5IGdyZWF0LiAgUHJvcGVyIHJlZmVyZW5jZSBjb3VudGluZyBhbmQgbG9ja2luZyBuZWVkcyB0byBiZQoraW1wbGVtZW50ZWQgYmVmb3JlIHRoaXMgbW9kdWxlIGlzIG1vdmVkIG91dCBvZiBzdGFnaW5nLgorCiszLiBUaGUgYmluZGluZyBiZXR3ZWVuIGhkcHZyIGFuZCBsaXJjX3ppbG9nIGlzIGN1cnJlbnRseSBkaXNhYmxlZCwKIGR1ZSB0byBhbiBPT1BTIHJlcG9ydGVkIGEgZmV3IHllYXJzIGFnbyB3aGVuIGJvdGggdGhlIGhkcHZyIGFuZCBjeDE4CiBkcml2ZXJzIHdlcmUgbG9hZGVkIGluIGhpcyBzeXN0ZW0uIE1vcmUgZGV0YWlscyBjYW4gYmUgc2VlbiBhdDoKIAlodHRwOi8vd3d3Lm1haWwtYXJjaGl2ZS5jb20vbGludXgtbWVkaWFAdmdlci5rZXJuZWwub3JnL21zZzA5MTYzLmh0bWwKIE1vcmUgdGVzdHMgbmVlZCB0byBiZSBkb25lLCBpbiBvcmRlciB0byBmaXggdGhlIHJlcG9ydGVkIGlzc3VlLgogCi1UaGVyZSdzIGEgY29uZmxpY3QgYmV0d2VlbiBpci1rYmQtaTJjOiBCb3RoIHByb3ZpZGUgc3VwcG9ydCBmb3IgUlggZXZlbnRzLgotU3VjaCBjb25mbGljdCBuZWVkcyB0byBiZSBmaXhlZCwgYmVmb3JlIG1vdmluZyBpdCBvdXQgb2Ygc3RhZ2luZy4KKzQuIEluIGFkZGl0aW9uIHRvIHByb3ZpZGluZyBhIHNoYXJlZCBtdXRleCBmb3IgdHJhbnNjZWl2ZXIgYWNjZXNzCitsb2NraW5nLCBicmlkZ2UgZHJpdmVycywgaWYgYWJsZSwgc2hvdWxkIHByb3ZpZGUgYSBjaGlwIHJlc2V0KCkgY2FsbGJhY2sKK3RvIGxpcmNfemlsb2cgdmlhIHN0cnVjdCBJUl9pMmNfaW5pdF9kYXRhLiAgY3gxOCBhbmQgaXZ0diBhbHJlYWR5IGhhdmUgcm91dGluZXMKK3RvIHBlcmZvcm0gWjggY2hpcCByZXNldHMgdmlhIEdQSU8gbWFuaXB1bGF0aW9ucy4gIFRoaXMgd2lsbCBhbGxvdyBsaXJjX3ppbG9nCit0byBicmluZyB0aGUgY2hpcCBiYWNrIHRvIG5vcm1hbCB3aGVuIGl0IGhhbmdzLCBpbiB0aGUgc2FtZSBwbGFjZXMgdGhlCitvcmlnaW5hbCBsaXJjX3B2cjE1MCBkcml2ZXIgY29kZSBkb2VzLiAgVGhpcyBpcyBub3Qgc3RyaWN0bHkgbmVlZGVkLCBzbyBpdAoraXMgbm90IHJlcXVpcmVkIHRvIG1vdmUgbGlyY196aWxvZyBvdXQgb2Ygc3RhZ2luZy4KIAotVGhlIHdheSBJMkMgcHJvYmUgd29ya3MsIGl0IHdpbGwgdHJ5IHRvIHJlZ2lzdGVyIHRoZSBkcml2ZXIgdHdpY2UsIG9uZQotZm9yIFJYIGFuZCBhbm90aGVyIGZvciBUWC4gVGhlIGxvZ2ljIG5lZWRzIHRvIGJlIGZpeGVkIHRvIGF2b2lkIHN1Y2gKLWlzc3VlLgorNS4gQm90aCBsaXJjX3ppbG9nIGFuZCBpci1rYmQtaTJjIHN1cHBvcnQgdGhlIFppbG9nIFo4IGZvciBJUiwgYXMgcHJvZ3JhbW1lZAorYW5kIGluc3RhbGxlZCBvbiBIYXVwcGF1Z2UgcHJvZHVjdHMuICBXaGVuIHdvcmtpbmcgb24gZWl0aGVyIG1vZHVsZSwgZGV2ZWxvcGVycworbXVzdCBjb25zaWRlciBhdCBsZWFzdCB0aGUgZm9sbG93aW5nIGJyaWRnZSBkcml2ZXJzIHdoaWNoIG1lbnRpb24gYW4gSVIgUnggdW5pdAorYXQgYWRkcmVzcyAweDcxIChpbmRpY2F0aXZlIG9mIGEgWjgpOgorCisJaXZ0diBjeDE4IGhkcHZyIHB2cnVzYjIgYnQ4eHggY3g4OCBzYWE3MTM0CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9saXJjL2xpcmNfaW1vbi5jIGIvZHJpdmVycy9zdGFnaW5nL2xpcmMvbGlyY19pbW9uLmMKaW5kZXggMGRhNmI5NS4uMjM1Y2FiMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2xpcmMvbGlyY19pbW9uLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2xpcmMvbGlyY19pbW9uLmMKQEAgLTQ0Nyw2ICs0NDcsNyBAQAogCiBleGl0OgogCW11dGV4X3VubG9jaygmY29udGV4dC0+Y3R4X2xvY2spOworCWtmcmVlKGRhdGFfYnVmKTsKIAogCXJldHVybiAoIXJldHZhbCkgPyBuX2J5dGVzIDogcmV0dmFsOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2xpcmMvbGlyY19pdDg3LmMgYi9kcml2ZXJzL3N0YWdpbmcvbGlyYy9saXJjX2l0ODcuYwppbmRleCA5MjlhZTU3Li41OTM4NjE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvbGlyYy9saXJjX2l0ODcuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvbGlyYy9saXJjX2l0ODcuYwpAQCAtMjMyLDYgKzIzMiw3IEBACiAJCWkrKzsKIAl9CiAJdGVybWluYXRlX3NlbmQodHhfYnVmW2kgLSAxXSk7CisJa2ZyZWUodHhfYnVmKTsKIAlyZXR1cm4gbjsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2xpcmMvbGlyY19wYXJhbGxlbC5jIGIvZHJpdmVycy9zdGFnaW5nL2xpcmMvbGlyY19wYXJhbGxlbC5jCmluZGV4IGRmZDJjNDQuLjNhOWMwOTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9saXJjL2xpcmNfcGFyYWxsZWwuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvbGlyYy9saXJjX3BhcmFsbGVsLmMKQEAgLTM3Niw2ICszNzYsNyBAQAogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJaW50IGNvdW50dGltZXI7CiAJaW50ICp3YnVmOworCXNzaXplX3QgcmV0OwogCiAJaWYgKCFpc19jbGFpbWVkKQogCQlyZXR1cm4gLUVCVVNZOwpAQCAtMzkzLDggKzM5NCwxMCBAQAogCWlmICh0aW1lciA9PSAwKSB7CiAJCS8qIHRyeSBhZ2FpbiBpZiBkZXZpY2UgaXMgcmVhZHkgKi8KIAkJdGltZXIgPSBpbml0X2xpcmNfdGltZXIoKTsKLQkJaWYgKHRpbWVyID09IDApCi0JCQlyZXR1cm4gLUVJTzsKKwkJaWYgKHRpbWVyID09IDApIHsKKwkJCXJldCA9IC1FSU87CisJCQlnb3RvIG91dDsKKwkJfQogCX0KIAogCS8qIGFkanVzdCB2YWx1ZXMgZnJvbSB1c2VjcyAqLwpAQCAtNDIwLDcgKzQyMyw4IEBACiAJCQlpZiAoY2hlY2tfcHNlbGVjZCAmJiAoaW4oMSkgJiBMUF9QU0VMRUNEKSkgewogCQkJCWxpcmNfb2ZmKCk7CiAJCQkJbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwotCQkJCXJldHVybiAtRUlPOworCQkJCXJldCA9IC1FSU87CisJCQkJZ290byBvdXQ7CiAJCQl9CiAJCX0gd2hpbGUgKGNvdW50dGltZXIgPCB3YnVmW2ldKTsKIAkJaSsrOwpAQCAtNDM2LDcgKzQ0MCw4IEBACiAJCQlsZXZlbCA9IG5ld2xldmVsOwogCQkJaWYgKGNoZWNrX3BzZWxlY2QgJiYgKGluKDEpICYgTFBfUFNFTEVDRCkpIHsKIAkJCQlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7Ci0JCQkJcmV0dXJuIC1FSU87CisJCQkJcmV0ID0gLUVJTzsKKwkJCQlnb3RvIG91dDsKIAkJCX0KIAkJfSB3aGlsZSAoY291bnR0aW1lciA8IHdidWZbaV0pOwogCQlpKys7CkBAIC00NDUsNyArNDUwLDExIEBACiAjZWxzZQogCS8qIHBsYWNlIGNvZGUgdGhhdCBoYW5kbGVzIHdyaXRlIHdpdGhvdXQgZXh0ZXJuYWwgdGltZXIgaGVyZSAqLwogI2VuZGlmCi0JcmV0dXJuIG47CisJcmV0ID0gbjsKK291dDoKKwlrZnJlZSh3YnVmKTsKKworCXJldHVybiByZXQ7CiB9CiAKIHN0YXRpYyB1bnNpZ25lZCBpbnQgbGlyY19wb2xsKHN0cnVjdCBmaWxlICpmaWxlLCBwb2xsX3RhYmxlICp3YWl0KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2xpcmMvbGlyY19zYXNlbS5jIGIvZHJpdmVycy9zdGFnaW5nL2xpcmMvbGlyY19zYXNlbS5jCmluZGV4IDk5ODQ4NWUuLjkyNWVhYmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9saXJjL2xpcmNfc2FzZW0uYworKysgYi9kcml2ZXJzL3N0YWdpbmcvbGlyYy9saXJjX3Nhc2VtLmMKQEAgLTQ0OCw2ICs0NDgsNyBAQAogZXhpdDoKIAogCW11dGV4X3VubG9jaygmY29udGV4dC0+Y3R4X2xvY2spOworCWtmcmVlKGRhdGFfYnVmKTsKIAogCXJldHVybiAoIXJldHZhbCkgPyBuX2J5dGVzIDogcmV0dmFsOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2xpcmMvbGlyY19zZXJpYWwuYyBiL2RyaXZlcnMvc3RhZ2luZy9saXJjL2xpcmNfc2VyaWFsLmMKaW5kZXggOWJjZjE0OS4uMWMzMDk5YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2xpcmMvbGlyY19zZXJpYWwuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvbGlyYy9saXJjX3NlcmlhbC5jCkBAIC05NjYsNyArOTY2LDcgQEAKIAlpZiAobiAlIHNpemVvZihpbnQpIHx8IGNvdW50ICUgMiA9PSAwKQogCQlyZXR1cm4gLUVJTlZBTDsKIAl3YnVmID0gbWVtZHVwX3VzZXIoYnVmLCBuKTsKLQlpZiAoUFRSX0VSUih3YnVmKSkKKwlpZiAoSVNfRVJSKHdidWYpKQogCQlyZXR1cm4gUFRSX0VSUih3YnVmKTsKIAlzcGluX2xvY2tfaXJxc2F2ZSgmaGFyZHdhcmVbdHlwZV0ubG9jaywgZmxhZ3MpOwogCWlmICh0eXBlID09IExJUkNfSVJERU8pIHsKQEAgLTk4MSw2ICs5ODEsNyBAQAogCX0KIAlvZmYoKTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZoYXJkd2FyZVt0eXBlXS5sb2NrLCBmbGFncyk7CisJa2ZyZWUod2J1Zik7CiAJcmV0dXJuIG47CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9saXJjL2xpcmNfc2lyLmMgYi9kcml2ZXJzL3N0YWdpbmcvbGlyYy9saXJjX3Npci5jCmluZGV4IGM1NTNhYjYuLjc2YmU3YjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9saXJjL2xpcmNfc2lyLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2xpcmMvbGlyY19zaXIuYwpAQCAtMzMwLDYgKzMzMCw3IEBACiAJLyogZW5hYmxlIHJlY2VpdmVyICovCiAJU2VyMlVUQ1IzID0gVVRDUjNfUlhFfFVUQ1IzX1JJRTsKICNlbmRpZgorCWtmcmVlKHR4X2J1Zik7CiAJcmV0dXJuIGNvdW50OwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvbGlyYy9saXJjX3ppbG9nLmMgYi9kcml2ZXJzL3N0YWdpbmcvbGlyYy9saXJjX3ppbG9nLmMKaW5kZXggYWQyOWJiMS4uMGFhZDBkNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2xpcmMvbGlyY196aWxvZy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9saXJjL2xpcmNfemlsb2cuYwpAQCAtMjAsNiArMjAsOSBAQAogICoKICAqIHBhcnRzIGFyZSBjdXQmcGFzdGVkIGZyb20gdGhlIGxpcmNfaTJjLmMgZHJpdmVyCiAgKgorICogTnVtZXJvdXMgY2hhbmdlcyB1cGRhdGluZyBsaXJjX3ppbG9nLmMgaW4ga2VybmVsIDIuNi4zOCBhbmQgbGF0ZXIgYXJlCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgQW5keSBXYWxscyA8YXdhbGxzQG1kLm1ldHJvY2FzdC5uZXQ+CisgKgogICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAgKiAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKICAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgpAQCAtNjAsMzggKzYzLDQ0IEBACiAjaW5jbHVkZSA8bWVkaWEvbGlyY19kZXYuaD4KICNpbmNsdWRlIDxtZWRpYS9saXJjLmg+CiAKLXN0cnVjdCBJUiB7Ci0Jc3RydWN0IGxpcmNfZHJpdmVyIGw7Ci0KLQkvKiBEZXZpY2UgaW5mbyAqLwotCXN0cnVjdCBtdXRleCBpcl9sb2NrOwotCWludCBvcGVuOwotCWJvb2wgaXNfaGRwdnI7Ci0KK3N0cnVjdCBJUl9yeCB7CiAJLyogUlggZGV2aWNlICovCi0Jc3RydWN0IGkyY19jbGllbnQgY19yeDsKLQlpbnQgaGF2ZV9yeDsKKwlzdHJ1Y3QgaTJjX2NsaWVudCAqYzsKIAogCS8qIFJYIGRldmljZSBidWZmZXIgJiBsb2NrICovCiAJc3RydWN0IGxpcmNfYnVmZmVyIGJ1ZjsKIAlzdHJ1Y3QgbXV0ZXggYnVmX2xvY2s7CiAKIAkvKiBSWCBwb2xsaW5nIHRocmVhZCBkYXRhICovCi0Jc3RydWN0IGNvbXBsZXRpb24gKnRfbm90aWZ5OwotCXN0cnVjdCBjb21wbGV0aW9uICp0X25vdGlmeTI7Ci0JaW50IHNodXRkb3duOwogCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzazsKIAogCS8qIFJYIHJlYWQgZGF0YSAqLwogCXVuc2lnbmVkIGNoYXIgYlszXTsKKwlib29sIGhkcHZyX2RhdGFfZm10OworfTsKIAorc3RydWN0IElSX3R4IHsKIAkvKiBUWCBkZXZpY2UgKi8KLQlzdHJ1Y3QgaTJjX2NsaWVudCBjX3R4OworCXN0cnVjdCBpMmNfY2xpZW50ICpjOworCisJLyogVFggYWRkaXRpb25hbCBhY3Rpb25zIG5lZWRlZCAqLwogCWludCBuZWVkX2Jvb3Q7Ci0JaW50IGhhdmVfdHg7CisJYm9vbCBwb3N0X3R4X3JlYWR5X3BvbGw7Cit9OworCitzdHJ1Y3QgSVIgeworCXN0cnVjdCBsaXJjX2RyaXZlciBsOworCisJc3RydWN0IG11dGV4IGlyX2xvY2s7CisJaW50IG9wZW47CisKKwlzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXB0ZXI7CisJc3RydWN0IElSX3J4ICpyeDsKKwlzdHJ1Y3QgSVJfdHggKnR4OwogfTsKIAogLyogTWlub3IgLT4gZGF0YSBtYXBwaW5nICovCitzdGF0aWMgc3RydWN0IG11dGV4IGlyX2RldmljZXNfbG9jazsKIHN0YXRpYyBzdHJ1Y3QgSVIgKmlyX2RldmljZXNbTUFYX0lSQ1RMX0RFVklDRVNdOwogCiAvKiBCbG9jayBzaXplIGZvciBJUiB0cmFuc21pdHRlciAqLwpAQCAtMTI0LDE0ICsxMzMsMTEgQEAKICNkZWZpbmUgemlsb2dfbm90aWZ5KHMsIGFyZ3MuLi4pIHByaW50ayhLRVJOX05PVElDRSBLQlVJTERfTU9ETkFNRSAiOiAiIHMsIFwKIAkJCQkJIyMgYXJncykKICNkZWZpbmUgemlsb2dfZXJyb3IocywgYXJncy4uLikgcHJpbnRrKEtFUk5fRVJSIEtCVUlMRF9NT0ROQU1FICI6ICIgcywgIyMgYXJncykKLQotI2RlZmluZSBaSUxPR19IQVVQUEFVR0VfSVJfUlhfTkFNRSAiWmlsb2cvSGF1cHBhdWdlIElSIFJYIgotI2RlZmluZSBaSUxPR19IQVVQUEFVR0VfSVJfVFhfTkFNRSAiWmlsb2cvSGF1cHBhdWdlIElSIFRYIgorI2RlZmluZSB6aWxvZ19pbmZvKHMsIGFyZ3MuLi4pIHByaW50ayhLRVJOX0lORk8gS0JVSUxEX01PRE5BTUUgIjogIiBzLCAjIyBhcmdzKQogCiAvKiBtb2R1bGUgcGFyYW1ldGVycyAqLwogc3RhdGljIGludCBkZWJ1ZzsJLyogZGVidWcgb3V0cHV0ICovCi1zdGF0aWMgaW50IGRpc2FibGVfcng7CS8qIGRpc2FibGUgUlggZGV2aWNlICovCi1zdGF0aWMgaW50IGRpc2FibGVfdHg7CS8qIGRpc2FibGUgVFggZGV2aWNlICovCitzdGF0aWMgaW50IHR4X29ubHk7CS8qIG9ubHkgaGFuZGxlIHRoZSBJUiBUeCBmdW5jdGlvbiAqLwogc3RhdGljIGludCBtaW5vciA9IC0xOwkvKiBtaW5vciBudW1iZXIgKi8KIAogI2RlZmluZSBkcHJpbnRrKGZtdCwgYXJncy4uLikJCQkJCQlcCkBAIC0xNTAsOCArMTU2LDEyIEBACiAJaW50IHJldDsKIAlpbnQgZmFpbHVyZXMgPSAwOwogCXVuc2lnbmVkIGNoYXIgc2VuZGJ1ZlsxXSA9IHsgMCB9OworCXN0cnVjdCBJUl9yeCAqcnggPSBpci0+cng7CiAKLQlpZiAobGlyY19idWZmZXJfZnVsbCgmaXItPmJ1ZikpIHsKKwlpZiAocnggPT0gTlVMTCkKKwkJcmV0dXJuIC1FTlhJTzsKKworCWlmIChsaXJjX2J1ZmZlcl9mdWxsKCZyeC0+YnVmKSkgewogCQlkcHJpbnRrKCJidWZmZXIgb3ZlcmZsb3dcbiIpOwogCQlyZXR1cm4gLUVPVkVSRkxPVzsKIAl9CkBAIC0xNjEsMTcgKzE3MSwyNSBAQAogCSAqIGRhdGEgYW5kIHdlIGhhdmUgc3BhY2UKIAkgKi8KIAlkbyB7CisJCWlmIChrdGhyZWFkX3Nob3VsZF9zdG9wKCkpCisJCQlyZXR1cm4gLUVOT0RBVEE7CisKIAkJLyoKIAkJICogTG9jayBpMmMgYnVzIGZvciB0aGUgZHVyYXRpb24uICBSWC9UWCBjaGlwcyBpbnRlcmZlcmUgc28KIAkJICogdGhpcyBpcyB3b3J0aCBpdAogCQkgKi8KIAkJbXV0ZXhfbG9jaygmaXItPmlyX2xvY2spOwogCisJCWlmIChrdGhyZWFkX3Nob3VsZF9zdG9wKCkpIHsKKwkJCW11dGV4X3VubG9jaygmaXItPmlyX2xvY2spOworCQkJcmV0dXJuIC1FTk9EQVRBOworCQl9CisKIAkJLyoKIAkJICogU2VuZCByYW5kb20gInBvbGwgY29tbWFuZCIgKD8pICBXaW5kb3dzIGRyaXZlciBkb2VzIHRoaXMKIAkJICogYW5kIGl0IGlzIGEgZ29vZCBwb2ludCB0byBkZXRlY3QgY2hpcCBmYWlsdXJlLgogCQkgKi8KLQkJcmV0ID0gaTJjX21hc3Rlcl9zZW5kKCZpci0+Y19yeCwgc2VuZGJ1ZiwgMSk7CisJCXJldCA9IGkyY19tYXN0ZXJfc2VuZChyeC0+Yywgc2VuZGJ1ZiwgMSk7CiAJCWlmIChyZXQgIT0gMSkgewogCQkJemlsb2dfZXJyb3IoImkyY19tYXN0ZXJfc2VuZCBmYWlsZWQgd2l0aCAlZFxuIiwJcmV0KTsKIAkJCWlmIChmYWlsdXJlcyA+PSAzKSB7CkBAIC0xODYsNDUgKzIwNCw1MyBAQAogCQkJCSAgICAidHJ5aW5nIHJlc2V0XG4iKTsKIAogCQkJc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19VTklOVEVSUlVQVElCTEUpOworCQkJaWYgKGt0aHJlYWRfc2hvdWxkX3N0b3AoKSkgeworCQkJCW11dGV4X3VubG9jaygmaXItPmlyX2xvY2spOworCQkJCXJldHVybiAtRU5PREFUQTsKKwkJCX0KIAkJCXNjaGVkdWxlX3RpbWVvdXQoKDEwMCAqIEhaICsgOTk5KSAvIDEwMDApOwotCQkJaXItPm5lZWRfYm9vdCA9IDE7CisJCQlpci0+dHgtPm5lZWRfYm9vdCA9IDE7CiAKIAkJCSsrZmFpbHVyZXM7CiAJCQltdXRleF91bmxvY2soJmlyLT5pcl9sb2NrKTsKIAkJCWNvbnRpbnVlOwogCQl9CiAKLQkJcmV0ID0gaTJjX21hc3Rlcl9yZWN2KCZpci0+Y19yeCwga2V5YnVmLCBzaXplb2Yoa2V5YnVmKSk7CisJCWlmIChrdGhyZWFkX3Nob3VsZF9zdG9wKCkpIHsKKwkJCW11dGV4X3VubG9jaygmaXItPmlyX2xvY2spOworCQkJcmV0dXJuIC1FTk9EQVRBOworCQl9CisJCXJldCA9IGkyY19tYXN0ZXJfcmVjdihyeC0+Yywga2V5YnVmLCBzaXplb2Yoa2V5YnVmKSk7CiAJCW11dGV4X3VubG9jaygmaXItPmlyX2xvY2spOwogCQlpZiAocmV0ICE9IHNpemVvZihrZXlidWYpKSB7CiAJCQl6aWxvZ19lcnJvcigiaTJjX21hc3Rlcl9yZWN2IGZhaWxlZCB3aXRoICVkIC0tICIKIAkJCQkgICAgImtlZXBpbmcgbGFzdCByZWFkIGJ1ZmZlclxuIiwgcmV0KTsKIAkJfSBlbHNlIHsKLQkJCWlyLT5iWzBdID0ga2V5YnVmWzNdOwotCQkJaXItPmJbMV0gPSBrZXlidWZbNF07Ci0JCQlpci0+YlsyXSA9IGtleWJ1Zls1XTsKLQkJCWRwcmludGsoImtleSAoMHglMDJ4LzB4JTAyeClcbiIsIGlyLT5iWzBdLCBpci0+YlsxXSk7CisJCQlyeC0+YlswXSA9IGtleWJ1ZlszXTsKKwkJCXJ4LT5iWzFdID0ga2V5YnVmWzRdOworCQkJcngtPmJbMl0gPSBrZXlidWZbNV07CisJCQlkcHJpbnRrKCJrZXkgKDB4JTAyeC8weCUwMngpXG4iLCByeC0+YlswXSwgcngtPmJbMV0pOwogCQl9CiAKIAkJLyoga2V5IHByZXNzZWQgPyAqLwotCQlpZiAoaXItPmlzX2hkcHZyKSB7CisJCWlmIChyeC0+aGRwdnJfZGF0YV9mbXQpIHsKIAkJCWlmIChnb3RfZGF0YSAmJiAoa2V5YnVmWzBdID09IDB4ODApKQogCQkJCXJldHVybiAwOwogCQkJZWxzZSBpZiAoZ290X2RhdGEgJiYgKGtleWJ1ZlswXSA9PSAweDAwKSkKIAkJCQlyZXR1cm4gLUVOT0RBVEE7Ci0JCX0gZWxzZSBpZiAoKGlyLT5iWzBdICYgMHg4MCkgPT0gMCkKKwkJfSBlbHNlIGlmICgocngtPmJbMF0gJiAweDgwKSA9PSAwKQogCQkJcmV0dXJuIGdvdF9kYXRhID8gMCA6IC1FTk9EQVRBOwogCiAJCS8qIGxvb2sgd2hhdCB3ZSBoYXZlICovCi0JCWNvZGUgPSAoKChfX3UxNilpci0+YlswXSAmIDB4N2YpIDw8IDYpIHwgKGlyLT5iWzFdID4+IDIpOworCQljb2RlID0gKCgoX191MTYpcngtPmJbMF0gJiAweDdmKSA8PCA2KSB8IChyeC0+YlsxXSA+PiAyKTsKIAogCQljb2Rlc1swXSA9IChjb2RlID4+IDgpICYgMHhmZjsKIAkJY29kZXNbMV0gPSBjb2RlICYgMHhmZjsKIAogCQkvKiByZXR1cm4gaXQgKi8KLQkJbGlyY19idWZmZXJfd3JpdGUoJmlyLT5idWYsIGNvZGVzKTsKKwkJbGlyY19idWZmZXJfd3JpdGUoJnJ4LT5idWYsIGNvZGVzKTsKIAkJKytnb3RfZGF0YTsKLQl9IHdoaWxlICghbGlyY19idWZmZXJfZnVsbCgmaXItPmJ1ZikpOworCX0gd2hpbGUgKCFsaXJjX2J1ZmZlcl9mdWxsKCZyeC0+YnVmKSk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTI0Miw0NiArMjY4LDM1IEBACiBzdGF0aWMgaW50IGxpcmNfdGhyZWFkKHZvaWQgKmFyZykKIHsKIAlzdHJ1Y3QgSVIgKmlyID0gYXJnOwotCi0JaWYgKGlyLT50X25vdGlmeSAhPSBOVUxMKQotCQljb21wbGV0ZShpci0+dF9ub3RpZnkpOworCXN0cnVjdCBJUl9yeCAqcnggPSBpci0+cng7CiAKIAlkcHJpbnRrKCJwb2xsIHRocmVhZCBzdGFydGVkXG4iKTsKIAotCWRvIHsKLQkJaWYgKGlyLT5vcGVuKSB7Ci0JCQlzZXRfY3VycmVudF9zdGF0ZShUQVNLX0lOVEVSUlVQVElCTEUpOworCXdoaWxlICgha3RocmVhZF9zaG91bGRfc3RvcCgpKSB7CisJCXNldF9jdXJyZW50X3N0YXRlKFRBU0tfSU5URVJSVVBUSUJMRSk7CiAKLQkJCS8qCi0JCQkgKiBUaGlzIGlzIH4xMTMqMiArIDI0ICsgaml0dGVyICgyKnJlcGVhdCBnYXAgKwotCQkJICogY29kZSBsZW5ndGgpLiAgV2UgdXNlIHRoaXMgaW50ZXJ2YWwgYXMgdGhlIGNoaXAKLQkJCSAqIHJlc2V0cyBldmVyeSB0aW1lIHlvdSBwb2xsIGl0IChiYWQhKS4gIFRoaXMgaXMKLQkJCSAqIHRoZXJlZm9yZSBqdXN0IHN1ZmZpY2llbnQgdG8gY2F0Y2ggYWxsIG9mIHRoZQotCQkJICogYnV0dG9uIHByZXNzZXMuICBJdCBtYWtlcyB0aGUgcmVtb3RlIG11Y2ggbW9yZQotCQkJICogcmVzcG9uc2l2ZS4gIFlvdSBjYW4gc2VlIHRoZSBkaWZmZXJlbmNlIGJ5Ci0JCQkgKiBydW5uaW5nIGlydyBhbmQgaG9sZGluZyBkb3duIGEgYnV0dG9uLiAgV2l0aAotCQkJICogMTAwbXMsIHRoZSBvbGQgcG9sbGluZyBpbnRlcnZhbCwgeW91J2xsIG5vdGljZQotCQkJICogYnJlYWtzIGluIHRoZSByZXBlYXQgc2VxdWVuY2UgY29ycmVzcG9uZGluZyB0bwotCQkJICogbG9zdCBrZXlwcmVzc2VzLgotCQkJICovCi0JCQlzY2hlZHVsZV90aW1lb3V0KCgyNjAgKiBIWikgLyAxMDAwKTsKLQkJCWlmIChpci0+c2h1dGRvd24pCi0JCQkJYnJlYWs7Ci0JCQlpZiAoIWFkZF90b19idWYoaXIpKQotCQkJCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmaXItPmJ1Zi53YWl0X3BvbGwpOwotCQl9IGVsc2UgewotCQkJLyogaWYgZGV2aWNlIG5vdCBvcGVuZWQgc28gd2UgY2FuIHNsZWVwIGhhbGYgYSBzZWNvbmQgKi8KLQkJCXNldF9jdXJyZW50X3N0YXRlKFRBU0tfSU5URVJSVVBUSUJMRSk7CisJCS8qIGlmIGRldmljZSBub3Qgb3BlbmVkLCB3ZSBjYW4gc2xlZXAgaGFsZiBhIHNlY29uZCAqLworCQlpZiAoIWlyLT5vcGVuKSB7CiAJCQlzY2hlZHVsZV90aW1lb3V0KEhaLzIpOworCQkJY29udGludWU7CiAJCX0KLQl9IHdoaWxlICghaXItPnNodXRkb3duKTsKIAotCWlmIChpci0+dF9ub3RpZnkyICE9IE5VTEwpCi0JCXdhaXRfZm9yX2NvbXBsZXRpb24oaXItPnRfbm90aWZ5Mik7Ci0KLQlpci0+dGFzayA9IE5VTEw7Ci0JaWYgKGlyLT50X25vdGlmeSAhPSBOVUxMKQotCQljb21wbGV0ZShpci0+dF9ub3RpZnkpOworCQkvKgorCQkgKiBUaGlzIGlzIH4xMTMqMiArIDI0ICsgaml0dGVyICgyKnJlcGVhdCBnYXAgKyBjb2RlIGxlbmd0aCkuCisJCSAqIFdlIHVzZSB0aGlzIGludGVydmFsIGFzIHRoZSBjaGlwIHJlc2V0cyBldmVyeSB0aW1lIHlvdSBwb2xsCisJCSAqIGl0IChiYWQhKS4gIFRoaXMgaXMgdGhlcmVmb3JlIGp1c3Qgc3VmZmljaWVudCB0byBjYXRjaCBhbGwKKwkJICogb2YgdGhlIGJ1dHRvbiBwcmVzc2VzLiAgSXQgbWFrZXMgdGhlIHJlbW90ZSBtdWNoIG1vcmUKKwkJICogcmVzcG9uc2l2ZS4gIFlvdSBjYW4gc2VlIHRoZSBkaWZmZXJlbmNlIGJ5IHJ1bm5pbmcgaXJ3IGFuZAorCQkgKiBob2xkaW5nIGRvd24gYSBidXR0b24uICBXaXRoIDEwMG1zLCB0aGUgb2xkIHBvbGxpbmcKKwkJICogaW50ZXJ2YWwsIHlvdSdsbCBub3RpY2UgYnJlYWtzIGluIHRoZSByZXBlYXQgc2VxdWVuY2UKKwkJICogY29ycmVzcG9uZGluZyB0byBsb3N0IGtleXByZXNzZXMuCisJCSAqLworCQlzY2hlZHVsZV90aW1lb3V0KCgyNjAgKiBIWikgLyAxMDAwKTsKKwkJaWYgKGt0aHJlYWRfc2hvdWxkX3N0b3AoKSkKKwkJCWJyZWFrOworCQlpZiAoIWFkZF90b19idWYoaXIpKQorCQkJd2FrZV91cF9pbnRlcnJ1cHRpYmxlKCZyeC0+YnVmLndhaXRfcG9sbCk7CisJfQogCiAJZHByaW50aygicG9sbCB0aHJlYWQgZW5kZWRcbiIpOwogCXJldHVybiAwOwpAQCAtMjk5LDEwICszMTQsMTAgQEAKIAkgKiB0aGlzIGlzIGNvbXBsZXRlbHkgYnJva2VuIGNvZGUuIGxpcmNfdW5yZWdpc3Rlcl9kcml2ZXIoKQogCSAqIG11c3QgYmUgcG9zc2libGUgZXZlbiB3aGVuIHRoZSBkZXZpY2UgaXMgb3BlbgogCSAqLwotCWlmIChpci0+Y19yeC5hZGRyKQotCQlpMmNfdXNlX2NsaWVudCgmaXItPmNfcngpOwotCWlmIChpci0+Y190eC5hZGRyKQotCQlpMmNfdXNlX2NsaWVudCgmaXItPmNfdHgpOworCWlmIChpci0+cnggIT0gTlVMTCkKKwkJaTJjX3VzZV9jbGllbnQoaXItPnJ4LT5jKTsKKwlpZiAoaXItPnR4ICE9IE5VTEwpCisJCWkyY191c2VfY2xpZW50KGlyLT50eC0+Yyk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTMxMSwxMCArMzI2LDEwIEBACiB7CiAJc3RydWN0IElSICppciA9IGRhdGE7CiAKLQlpZiAoaXItPmNfcnguYWRkcikKLQkJaTJjX3JlbGVhc2VfY2xpZW50KCZpci0+Y19yeCk7Ci0JaWYgKGlyLT5jX3R4LmFkZHIpCi0JCWkyY19yZWxlYXNlX2NsaWVudCgmaXItPmNfdHgpOworCWlmIChpci0+cngpCisJCWkyY19yZWxlYXNlX2NsaWVudChpci0+cngtPmMpOworCWlmIChpci0+dHgpCisJCWkyY19yZWxlYXNlX2NsaWVudChpci0+dHgtPmMpOwogCWlmIChpci0+bC5vd25lciAhPSBOVUxMKQogCQltb2R1bGVfcHV0KGlyLT5sLm93bmVyKTsKIH0KQEAgLTQ1Myw3ICs0NjgsNyBAQAogfQogCiAvKiBzZW5kIGEgYmxvY2sgb2YgZGF0YSB0byB0aGUgSVIgVFggZGV2aWNlICovCi1zdGF0aWMgaW50IHNlbmRfZGF0YV9ibG9jayhzdHJ1Y3QgSVIgKmlyLCB1bnNpZ25lZCBjaGFyICpkYXRhX2Jsb2NrKQorc3RhdGljIGludCBzZW5kX2RhdGFfYmxvY2soc3RydWN0IElSX3R4ICp0eCwgdW5zaWduZWQgY2hhciAqZGF0YV9ibG9jaykKIHsKIAlpbnQgaSwgaiwgcmV0OwogCXVuc2lnbmVkIGNoYXIgYnVmWzVdOwpAQCAtNDY3LDcgKzQ4Miw3IEBACiAJCQlidWZbMSArIGpdID0gZGF0YV9ibG9ja1tpICsgal07CiAJCWRwcmludGsoIiUwMnggJTAyeCAlMDJ4ICUwMnggJTAyeCIsCiAJCQlidWZbMF0sIGJ1ZlsxXSwgYnVmWzJdLCBidWZbM10sIGJ1Zls0XSk7Ci0JCXJldCA9IGkyY19tYXN0ZXJfc2VuZCgmaXItPmNfdHgsIGJ1ZiwgdG9zZW5kICsgMSk7CisJCXJldCA9IGkyY19tYXN0ZXJfc2VuZCh0eC0+YywgYnVmLCB0b3NlbmQgKyAxKTsKIAkJaWYgKHJldCAhPSB0b3NlbmQgKyAxKSB7CiAJCQl6aWxvZ19lcnJvcigiaTJjX21hc3Rlcl9zZW5kIGZhaWxlZCB3aXRoICVkXG4iLCByZXQpOwogCQkJcmV0dXJuIHJldCA8IDAgPyByZXQgOiAtRUZBVUxUOwpAQCAtNDc4LDM4ICs0OTMsNTAgQEAKIH0KIAogLyogc2VuZCBib290IGRhdGEgdG8gdGhlIElSIFRYIGRldmljZSAqLwotc3RhdGljIGludCBzZW5kX2Jvb3RfZGF0YShzdHJ1Y3QgSVIgKmlyKQorc3RhdGljIGludCBzZW5kX2Jvb3RfZGF0YShzdHJ1Y3QgSVJfdHggKnR4KQogewotCWludCByZXQ7CisJaW50IHJldCwgaTsKIAl1bnNpZ25lZCBjaGFyIGJ1Zls0XTsKIAogCS8qIHNlbmQgdGhlIGJvb3QgYmxvY2sgKi8KLQlyZXQgPSBzZW5kX2RhdGFfYmxvY2soaXIsIHR4X2RhdGEtPmJvb3RfZGF0YSk7CisJcmV0ID0gc2VuZF9kYXRhX2Jsb2NrKHR4LCB0eF9kYXRhLT5ib290X2RhdGEpOwogCWlmIChyZXQgIT0gMCkKIAkJcmV0dXJuIHJldDsKIAotCS8qIGtpY2sgaXQgb2ZmPyAqLworCS8qIEhpdCB0aGUgZ28gYnV0dG9uIHRvIGFjdGl2YXRlIHRoZSBuZXcgYm9vdCBkYXRhICovCiAJYnVmWzBdID0gMHgwMDsKIAlidWZbMV0gPSAweDIwOwotCXJldCA9IGkyY19tYXN0ZXJfc2VuZCgmaXItPmNfdHgsIGJ1ZiwgMik7CisJcmV0ID0gaTJjX21hc3Rlcl9zZW5kKHR4LT5jLCBidWYsIDIpOwogCWlmIChyZXQgIT0gMikgewogCQl6aWxvZ19lcnJvcigiaTJjX21hc3Rlcl9zZW5kIGZhaWxlZCB3aXRoICVkXG4iLCByZXQpOwogCQlyZXR1cm4gcmV0IDwgMCA/IHJldCA6IC1FRkFVTFQ7CiAJfQotCXJldCA9IGkyY19tYXN0ZXJfc2VuZCgmaXItPmNfdHgsIGJ1ZiwgMSk7CisKKwkvKgorCSAqIFdhaXQgZm9yIHppbG9nIHRvIHNldHRsZSBhZnRlciBoaXR0aW5nIGdvIHBvc3QgYm9vdCBibG9jayB1cGxvYWQuCisJICogV2l0aG91dCB0aGlzIGRlbGF5LCB0aGUgSEQtUFZSIGFuZCBIVlItMTk1MCBib3RoIHJldHVybiBhbiAtRUlPCisJICogdXBvbiBhdHRlbXB0aW5nIHRvIGdldCBmaXJtd2FyZSByZXZpc2lvbiwgYW5kIHR4IHByb2JlIHRodXMgZmFpbHMuCisJICovCisJZm9yIChpID0gMDsgaSA8IDEwOyBpKyspIHsKKwkJcmV0ID0gaTJjX21hc3Rlcl9zZW5kKHR4LT5jLCBidWYsIDEpOworCQlpZiAocmV0ID09IDEpCisJCQlicmVhazsKKwkJdWRlbGF5KDEwMCk7CisJfQorCiAJaWYgKHJldCAhPSAxKSB7CiAJCXppbG9nX2Vycm9yKCJpMmNfbWFzdGVyX3NlbmQgZmFpbGVkIHdpdGggJWRcbiIsIHJldCk7CiAJCXJldHVybiByZXQgPCAwID8gcmV0IDogLUVGQVVMVDsKIAl9CiAKIAkvKiBIZXJlIGNvbWVzIHRoZSBmaXJtd2FyZSB2ZXJzaW9uLi4uIChob3BlZnVsbHkpICovCi0JcmV0ID0gaTJjX21hc3Rlcl9yZWN2KCZpci0+Y190eCwgYnVmLCA0KTsKKwlyZXQgPSBpMmNfbWFzdGVyX3JlY3YodHgtPmMsIGJ1ZiwgNCk7CiAJaWYgKHJldCAhPSA0KSB7CiAJCXppbG9nX2Vycm9yKCJpMmNfbWFzdGVyX3JlY3YgZmFpbGVkIHdpdGggJWRcbiIsIHJldCk7CiAJCXJldHVybiAwOwogCX0KLQlpZiAoYnVmWzBdICE9IDB4ODApIHsKLQkJemlsb2dfZXJyb3IoInVuZXhwZWN0ZWQgSVIgVFggcmVzcG9uc2U6ICUwMnhcbiIsIGJ1ZlswXSk7CisJaWYgKChidWZbMF0gIT0gMHg4MCkgJiYgKGJ1ZlswXSAhPSAweGEwKSkgeworCQl6aWxvZ19lcnJvcigidW5leHBlY3RlZCBJUiBUWCBpbml0IHJlc3BvbnNlOiAlMDJ4XG4iLCBidWZbMF0pOwogCQlyZXR1cm4gMDsKIAl9CiAJemlsb2dfbm90aWZ5KCJaaWxvZy9IYXVwcGF1Z2UgSVIgYmxhc3RlciBmaXJtd2FyZSB2ZXJzaW9uICIKQEAgLTU0Myw3ICs1NzAsNyBAQAogfQogCiAvKiBsb2FkICJmaXJtd2FyZSIgZm9yIHRoZSBJUiBUWCBkZXZpY2UgKi8KLXN0YXRpYyBpbnQgZndfbG9hZChzdHJ1Y3QgSVIgKmlyKQorc3RhdGljIGludCBmd19sb2FkKHN0cnVjdCBJUl90eCAqdHgpCiB7CiAJaW50IHJldDsKIAl1bnNpZ25lZCBpbnQgaTsKQEAgLTU1OCw3ICs1ODUsNyBAQAogCX0KIAogCS8qIFJlcXVlc3QgY29kZXNldCBkYXRhIGZpbGUgKi8KLQlyZXQgPSByZXF1ZXN0X2Zpcm13YXJlKCZmd19lbnRyeSwgImhhdXAtaXItYmxhc3Rlci5iaW4iLCAmaXItPmNfdHguZGV2KTsKKwlyZXQgPSByZXF1ZXN0X2Zpcm13YXJlKCZmd19lbnRyeSwgImhhdXAtaXItYmxhc3Rlci5iaW4iLCAmdHgtPmMtPmRldik7CiAJaWYgKHJldCAhPSAwKSB7CiAJCXppbG9nX2Vycm9yKCJmaXJtd2FyZSBoYXVwLWlyLWJsYXN0ZXIuYmluIG5vdCBhdmFpbGFibGUgIgogCQkJICAgICIoJWQpXG4iLCByZXQpOwpAQCAtNjg1LDIwICs3MTIsMjAgQEAKIH0KIAogLyogaW5pdGlhbGlzZSB0aGUgSVIgVFggZGV2aWNlICovCi1zdGF0aWMgaW50IHR4X2luaXQoc3RydWN0IElSICppcikKK3N0YXRpYyBpbnQgdHhfaW5pdChzdHJ1Y3QgSVJfdHggKnR4KQogewogCWludCByZXQ7CiAKIAkvKiBMb2FkICdmaXJtd2FyZScgKi8KLQlyZXQgPSBmd19sb2FkKGlyKTsKKwlyZXQgPSBmd19sb2FkKHR4KTsKIAlpZiAocmV0ICE9IDApCiAJCXJldHVybiByZXQ7CiAKIAkvKiBTZW5kIGJvb3QgYmxvY2sgKi8KLQlyZXQgPSBzZW5kX2Jvb3RfZGF0YShpcik7CisJcmV0ID0gc2VuZF9ib290X2RhdGEodHgpOwogCWlmIChyZXQgIT0gMCkKIAkJcmV0dXJuIHJldDsKLQlpci0+bmVlZF9ib290ID0gMDsKKwl0eC0+bmVlZF9ib290ID0gMDsKIAogCS8qIExvb2tzIGdvb2QgKi8KIAlyZXR1cm4gMDsKQEAgLTcxNCwyMCArNzQxLDIwIEBACiBzdGF0aWMgc3NpemVfdCByZWFkKHN0cnVjdCBmaWxlICpmaWxlcCwgY2hhciAqb3V0YnVmLCBzaXplX3QgbiwgbG9mZl90ICpwcG9zKQogewogCXN0cnVjdCBJUiAqaXIgPSBmaWxlcC0+cHJpdmF0ZV9kYXRhOwotCXVuc2lnbmVkIGNoYXIgYnVmW2lyLT5idWYuY2h1bmtfc2l6ZV07CisJc3RydWN0IElSX3J4ICpyeCA9IGlyLT5yeDsKIAlpbnQgcmV0ID0gMCwgd3JpdHRlbiA9IDA7CiAJREVDTEFSRV9XQUlUUVVFVUUod2FpdCwgY3VycmVudCk7CiAKIAlkcHJpbnRrKCJyZWFkIGNhbGxlZFxuIik7Ci0JaWYgKGlyLT5jX3J4LmFkZHIgPT0gMCkKKwlpZiAocnggPT0gTlVMTCkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKLQlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZpci0+YnVmX2xvY2spKQorCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJnJ4LT5idWZfbG9jaykpCiAJCXJldHVybiAtRVJFU1RBUlRTWVM7CiAKLQlpZiAobiAlIGlyLT5idWYuY2h1bmtfc2l6ZSkgeworCWlmIChuICUgcngtPmJ1Zi5jaHVua19zaXplKSB7CiAJCWRwcmludGsoInJlYWQgcmVzdWx0ID0gLUVJTlZBTFxuIik7Ci0JCW11dGV4X3VubG9jaygmaXItPmJ1Zl9sb2NrKTsKKwkJbXV0ZXhfdW5sb2NrKCZyeC0+YnVmX2xvY2spOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKQEAgLTczNiw3ICs3NjMsNyBAQAogCSAqIHRvIGF2b2lkIGxvc2luZyBzY2FuIGNvZGUgKGluIGNhc2Ugd2hlbiBxdWV1ZSBpcyBhd2FrZW4gc29tZXdoZXJlCiAJICogYmV0d2VlbiB3aGlsZSBjb25kaXRpb24gY2hlY2tpbmcgYW5kIHNjaGVkdWxpbmcpCiAJICovCi0JYWRkX3dhaXRfcXVldWUoJmlyLT5idWYud2FpdF9wb2xsLCAmd2FpdCk7CisJYWRkX3dhaXRfcXVldWUoJnJ4LT5idWYud2FpdF9wb2xsLCAmd2FpdCk7CiAJc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19JTlRFUlJVUFRJQkxFKTsKIAogCS8qCkBAIC03NDQsNyArNzcxLDcgQEAKIAkgKiBtb2RlIGFuZCAnY29weV90b191c2VyJyBpcyBoYXBweSwgd2FpdCBmb3IgZGF0YS4KIAkgKi8KIAl3aGlsZSAod3JpdHRlbiA8IG4gJiYgcmV0ID09IDApIHsKLQkJaWYgKGxpcmNfYnVmZmVyX2VtcHR5KCZpci0+YnVmKSkgeworCQlpZiAobGlyY19idWZmZXJfZW1wdHkoJnJ4LT5idWYpKSB7CiAJCQkvKgogCQkJICogQWNjb3JkaW5nIHRvIHRoZSByZWFkKDIpIG1hbiBwYWdlLCAnd3JpdHRlbicgY2FuIGJlCiAJCQkgKiByZXR1cm5lZCBhcyBsZXNzIHRoYW4gJ24nLCBpbnN0ZWFkIG9mIGJsb2NraW5nCkBAIC03NjQsMTYgKzc5MSwxNyBAQAogCQkJc2NoZWR1bGUoKTsKIAkJCXNldF9jdXJyZW50X3N0YXRlKFRBU0tfSU5URVJSVVBUSUJMRSk7CiAJCX0gZWxzZSB7Ci0JCQlsaXJjX2J1ZmZlcl9yZWFkKCZpci0+YnVmLCBidWYpOworCQkJdW5zaWduZWQgY2hhciBidWZbcngtPmJ1Zi5jaHVua19zaXplXTsKKwkJCWxpcmNfYnVmZmVyX3JlYWQoJnJ4LT5idWYsIGJ1Zik7CiAJCQlyZXQgPSBjb3B5X3RvX3VzZXIoKHZvaWQgKilvdXRidWYrd3JpdHRlbiwgYnVmLAotCQkJCQkgICBpci0+YnVmLmNodW5rX3NpemUpOwotCQkJd3JpdHRlbiArPSBpci0+YnVmLmNodW5rX3NpemU7CisJCQkJCSAgIHJ4LT5idWYuY2h1bmtfc2l6ZSk7CisJCQl3cml0dGVuICs9IHJ4LT5idWYuY2h1bmtfc2l6ZTsKIAkJfQogCX0KIAotCXJlbW92ZV93YWl0X3F1ZXVlKCZpci0+YnVmLndhaXRfcG9sbCwgJndhaXQpOworCXJlbW92ZV93YWl0X3F1ZXVlKCZyeC0+YnVmLndhaXRfcG9sbCwgJndhaXQpOwogCXNldF9jdXJyZW50X3N0YXRlKFRBU0tfUlVOTklORyk7Ci0JbXV0ZXhfdW5sb2NrKCZpci0+YnVmX2xvY2spOworCW11dGV4X3VubG9jaygmcngtPmJ1Zl9sb2NrKTsKIAogCWRwcmludGsoInJlYWQgcmVzdWx0ID0gJXMgKCVkKVxuIiwKIAkJcmV0ID8gIi1FRkFVTFQiIDogIk9LIiwgcmV0KTsKQEAgLTc4Miw3ICs4MTAsNyBAQAogfQogCiAvKiBzZW5kIGEga2V5cHJlc3MgdG8gdGhlIElSIFRYIGRldmljZSAqLwotc3RhdGljIGludCBzZW5kX2NvZGUoc3RydWN0IElSICppciwgdW5zaWduZWQgaW50IGNvZGUsIHVuc2lnbmVkIGludCBrZXkpCitzdGF0aWMgaW50IHNlbmRfY29kZShzdHJ1Y3QgSVJfdHggKnR4LCB1bnNpZ25lZCBpbnQgY29kZSwgdW5zaWduZWQgaW50IGtleSkKIHsKIAl1bnNpZ25lZCBjaGFyIGRhdGFfYmxvY2tbVFhfQkxPQ0tfU0laRV07CiAJdW5zaWduZWQgY2hhciBidWZbMl07CkBAIC03OTksMjYgKzgyNywzNCBAQAogCQlyZXR1cm4gcmV0OwogCiAJLyogU2VuZCB0aGUgZGF0YSBibG9jayAqLwotCXJldCA9IHNlbmRfZGF0YV9ibG9jayhpciwgZGF0YV9ibG9jayk7CisJcmV0ID0gc2VuZF9kYXRhX2Jsb2NrKHR4LCBkYXRhX2Jsb2NrKTsKIAlpZiAocmV0ICE9IDApCiAJCXJldHVybiByZXQ7CiAKIAkvKiBTZW5kIGRhdGEgYmxvY2sgbGVuZ3RoPyAqLwogCWJ1ZlswXSA9IDB4MDA7CiAJYnVmWzFdID0gMHg0MDsKLQlyZXQgPSBpMmNfbWFzdGVyX3NlbmQoJmlyLT5jX3R4LCBidWYsIDIpOworCXJldCA9IGkyY19tYXN0ZXJfc2VuZCh0eC0+YywgYnVmLCAyKTsKIAlpZiAocmV0ICE9IDIpIHsKIAkJemlsb2dfZXJyb3IoImkyY19tYXN0ZXJfc2VuZCBmYWlsZWQgd2l0aCAlZFxuIiwgcmV0KTsKIAkJcmV0dXJuIHJldCA8IDAgPyByZXQgOiAtRUZBVUxUOwogCX0KLQlyZXQgPSBpMmNfbWFzdGVyX3NlbmQoJmlyLT5jX3R4LCBidWYsIDEpOworCisJLyogR2l2ZSB0aGUgejggYSBtb21lbnQgdG8gcHJvY2VzcyBkYXRhIGJsb2NrICovCisJZm9yIChpID0gMDsgaSA8IDEwOyBpKyspIHsKKwkJcmV0ID0gaTJjX21hc3Rlcl9zZW5kKHR4LT5jLCBidWYsIDEpOworCQlpZiAocmV0ID09IDEpCisJCQlicmVhazsKKwkJdWRlbGF5KDEwMCk7CisJfQorCiAJaWYgKHJldCAhPSAxKSB7CiAJCXppbG9nX2Vycm9yKCJpMmNfbWFzdGVyX3NlbmQgZmFpbGVkIHdpdGggJWRcbiIsIHJldCk7CiAJCXJldHVybiByZXQgPCAwID8gcmV0IDogLUVGQVVMVDsKIAl9CiAKIAkvKiBTZW5kIGZpbmlzaGVkIGRvd25sb2FkPyAqLwotCXJldCA9IGkyY19tYXN0ZXJfcmVjdigmaXItPmNfdHgsIGJ1ZiwgMSk7CisJcmV0ID0gaTJjX21hc3Rlcl9yZWN2KHR4LT5jLCBidWYsIDEpOwogCWlmIChyZXQgIT0gMSkgewogCQl6aWxvZ19lcnJvcigiaTJjX21hc3Rlcl9yZWN2IGZhaWxlZCB3aXRoICVkXG4iLCByZXQpOwogCQlyZXR1cm4gcmV0IDwgMCA/IHJldCA6IC1FRkFVTFQ7CkBAIC04MzIsNyArODY4LDcgQEAKIAkvKiBTZW5kIHByZXBhcmUgY29tbWFuZD8gKi8KIAlidWZbMF0gPSAweDAwOwogCWJ1ZlsxXSA9IDB4ODA7Ci0JcmV0ID0gaTJjX21hc3Rlcl9zZW5kKCZpci0+Y190eCwgYnVmLCAyKTsKKwlyZXQgPSBpMmNfbWFzdGVyX3NlbmQodHgtPmMsIGJ1ZiwgMik7CiAJaWYgKHJldCAhPSAyKSB7CiAJCXppbG9nX2Vycm9yKCJpMmNfbWFzdGVyX3NlbmQgZmFpbGVkIHdpdGggJWRcbiIsIHJldCk7CiAJCXJldHVybiByZXQgPCAwID8gcmV0IDogLUVGQVVMVDsKQEAgLTg0Myw3ICs4NzksNyBAQAogCSAqIGxhc3QgaTJjX21hc3Rlcl9yZWN2IGFsd2F5cyBmYWlscyB3aXRoIGEgLTUsIHNvIGZvciBub3csIHdlJ3JlCiAJICogZ29pbmcgdG8gc2tpcCB0aGlzIHdob2xlIG1lc3MgYW5kIHNheSB3ZSdyZSBkb25lIG9uIHRoZSBIRCBQVlIKIAkgKi8KLQlpZiAoaXItPmlzX2hkcHZyKSB7CisJaWYgKCF0eC0+cG9zdF90eF9yZWFkeV9wb2xsKSB7CiAJCWRwcmludGsoInNlbnQgY29kZSAldSwga2V5ICV1XG4iLCBjb2RlLCBrZXkpOwogCQlyZXR1cm4gMDsKIAl9CkBAIC04NTcsNyArODkzLDcgQEAKIAlmb3IgKGkgPSAwOyBpIDwgMjA7ICsraSkgewogCQlzZXRfY3VycmVudF9zdGF0ZShUQVNLX1VOSU5URVJSVVBUSUJMRSk7CiAJCXNjaGVkdWxlX3RpbWVvdXQoKDUwICogSFogKyA5OTkpIC8gMTAwMCk7Ci0JCXJldCA9IGkyY19tYXN0ZXJfc2VuZCgmaXItPmNfdHgsIGJ1ZiwgMSk7CisJCXJldCA9IGkyY19tYXN0ZXJfc2VuZCh0eC0+YywgYnVmLCAxKTsKIAkJaWYgKHJldCA9PSAxKQogCQkJYnJlYWs7CiAJCWRwcmludGsoIk5BSyBleHBlY3RlZDogaTJjX21hc3Rlcl9zZW5kICIKQEAgLTg3MCw3ICs5MDYsNyBAQAogCX0KIAogCS8qIFNlZW1zIHRvIGJlIGFuICdvaycgcmVzcG9uc2UgKi8KLQlpID0gaTJjX21hc3Rlcl9yZWN2KCZpci0+Y190eCwgYnVmLCAxKTsKKwlpID0gaTJjX21hc3Rlcl9yZWN2KHR4LT5jLCBidWYsIDEpOwogCWlmIChpICE9IDEpIHsKIAkJemlsb2dfZXJyb3IoImkyY19tYXN0ZXJfcmVjdiBmYWlsZWQgd2l0aCAlZFxuIiwgcmV0KTsKIAkJcmV0dXJuIC1FRkFVTFQ7CkBAIC04OTUsMTAgKzkzMSwxMSBAQAogCQkJICBsb2ZmX3QgKnBwb3MpCiB7CiAJc3RydWN0IElSICppciA9IGZpbGVwLT5wcml2YXRlX2RhdGE7CisJc3RydWN0IElSX3R4ICp0eCA9IGlyLT50eDsKIAlzaXplX3QgaTsKIAlpbnQgZmFpbHVyZXMgPSAwOwogCi0JaWYgKGlyLT5jX3R4LmFkZHIgPT0gMCkKKwlpZiAodHggPT0gTlVMTCkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKIAkvKiBWYWxpZGF0ZSB1c2VyIHBhcmFtZXRlcnMgKi8KQEAgLTkxOSwxNSArOTU2LDE1IEBACiAJCX0KIAogCQkvKiBTZW5kIGJvb3QgZGF0YSBmaXJzdCBpZiByZXF1aXJlZCAqLwotCQlpZiAoaXItPm5lZWRfYm9vdCA9PSAxKSB7Ci0JCQlyZXQgPSBzZW5kX2Jvb3RfZGF0YShpcik7CisJCWlmICh0eC0+bmVlZF9ib290ID09IDEpIHsKKwkJCXJldCA9IHNlbmRfYm9vdF9kYXRhKHR4KTsKIAkJCWlmIChyZXQgPT0gMCkKLQkJCQlpci0+bmVlZF9ib290ID0gMDsKKwkJCQl0eC0+bmVlZF9ib290ID0gMDsKIAkJfQogCiAJCS8qIFNlbmQgdGhlIGNvZGUgKi8KIAkJaWYgKHJldCA9PSAwKSB7Ci0JCQlyZXQgPSBzZW5kX2NvZGUoaXIsICh1bnNpZ25lZCljb21tYW5kID4+IDE2LAorCQkJcmV0ID0gc2VuZF9jb2RlKHR4LCAodW5zaWduZWQpY29tbWFuZCA+PiAxNiwKIAkJCQkJICAgICh1bnNpZ25lZCljb21tYW5kICYgMHhGRkZGKTsKIAkJCWlmIChyZXQgPT0gLUVQUk9UTykgewogCQkJCW11dGV4X3VubG9jaygmaXItPmlyX2xvY2spOwpAQCAtOTUyLDcgKzk4OSw3IEBACiAJCQl9CiAJCQlzZXRfY3VycmVudF9zdGF0ZShUQVNLX1VOSU5URVJSVVBUSUJMRSk7CiAJCQlzY2hlZHVsZV90aW1lb3V0KCgxMDAgKiBIWiArIDk5OSkgLyAxMDAwKTsKLQkJCWlyLT5uZWVkX2Jvb3QgPSAxOworCQkJdHgtPm5lZWRfYm9vdCA9IDE7CiAJCQkrK2ZhaWx1cmVzOwogCQl9IGVsc2UKIAkJCWkgKz0gc2l6ZW9mKGludCk7CkBAIC05NjksMjIgKzEwMDYsMjMgQEAKIHN0YXRpYyB1bnNpZ25lZCBpbnQgcG9sbChzdHJ1Y3QgZmlsZSAqZmlsZXAsIHBvbGxfdGFibGUgKndhaXQpCiB7CiAJc3RydWN0IElSICppciA9IGZpbGVwLT5wcml2YXRlX2RhdGE7CisJc3RydWN0IElSX3J4ICpyeCA9IGlyLT5yeDsKIAl1bnNpZ25lZCBpbnQgcmV0OwogCiAJZHByaW50aygicG9sbCBjYWxsZWRcbiIpOwotCWlmIChpci0+Y19yeC5hZGRyID09IDApCisJaWYgKHJ4ID09IE5VTEwpCiAJCXJldHVybiAtRU5PREVWOwogCi0JbXV0ZXhfbG9jaygmaXItPmJ1Zl9sb2NrKTsKKwltdXRleF9sb2NrKCZyeC0+YnVmX2xvY2spOwogCi0JcG9sbF93YWl0KGZpbGVwLCAmaXItPmJ1Zi53YWl0X3BvbGwsIHdhaXQpOworCXBvbGxfd2FpdChmaWxlcCwgJnJ4LT5idWYud2FpdF9wb2xsLCB3YWl0KTsKIAogCWRwcmludGsoInBvbGwgcmVzdWx0ID0gJXNcbiIsCi0JCWxpcmNfYnVmZmVyX2VtcHR5KCZpci0+YnVmKSA/ICIwIiA6ICJQT0xMSU58UE9MTFJETk9STSIpOworCQlsaXJjX2J1ZmZlcl9lbXB0eSgmcngtPmJ1ZikgPyAiMCIgOiAiUE9MTElOfFBPTExSRE5PUk0iKTsKIAotCXJldCA9IGxpcmNfYnVmZmVyX2VtcHR5KCZpci0+YnVmKSA/IDAgOiAoUE9MTElOfFBPTExSRE5PUk0pOworCXJldCA9IGxpcmNfYnVmZmVyX2VtcHR5KCZyeC0+YnVmKSA/IDAgOiAoUE9MTElOfFBPTExSRE5PUk0pOwogCi0JbXV0ZXhfdW5sb2NrKCZpci0+YnVmX2xvY2spOworCW11dGV4X3VubG9jaygmcngtPmJ1Zl9sb2NrKTsKIAlyZXR1cm4gcmV0OwogfQogCkBAIC05OTQsMTAgKzEwMzIsOSBAQAogCWludCByZXN1bHQ7CiAJdW5zaWduZWQgbG9uZyBtb2RlLCBmZWF0dXJlcyA9IDA7CiAKLQlpZiAoaXItPmNfcnguYWRkciAhPSAwKQorCWZlYXR1cmVzIHw9IExJUkNfQ0FOX1NFTkRfUFVMU0U7CisJaWYgKGlyLT5yeCAhPSBOVUxMKQogCQlmZWF0dXJlcyB8PSBMSVJDX0NBTl9SRUNfTElSQ0NPREU7Ci0JaWYgKGlyLT5jX3R4LmFkZHIgIT0gMCkKLQkJZmVhdHVyZXMgfD0gTElSQ19DQU5fU0VORF9QVUxTRTsKIAogCXN3aXRjaCAoY21kKSB7CiAJY2FzZSBMSVJDX0dFVF9MRU5HVEg6CkBAIC0xMDI0LDE1ICsxMDYxLDkgQEAKIAkJCXJlc3VsdCA9IC1FSU5WQUw7CiAJCWJyZWFrOwogCWNhc2UgTElSQ19HRVRfU0VORF9NT0RFOgotCQlpZiAoIShmZWF0dXJlcyZMSVJDX0NBTl9TRU5EX01BU0spKQotCQkJcmV0dXJuIC1FTk9TWVM7Ci0KIAkJcmVzdWx0ID0gcHV0X3VzZXIoTElSQ19NT0RFX1BVTFNFLCAodW5zaWduZWQgbG9uZyAqKSBhcmcpOwogCQlicmVhazsKIAljYXNlIExJUkNfU0VUX1NFTkRfTU9ERToKLQkJaWYgKCEoZmVhdHVyZXMmTElSQ19DQU5fU0VORF9NQVNLKSkKLQkJCXJldHVybiAtRU5PU1lTOwotCiAJCXJlc3VsdCA9IGdldF91c2VyKG1vZGUsICh1bnNpZ25lZCBsb25nICopIGFyZyk7CiAJCWlmICghcmVzdWx0ICYmIG1vZGUgIT0gTElSQ19NT0RFX1BVTFNFKQogCQkJcmV0dXJuIC1FSU5WQUw7CkBAIC0xMDQzLDYgKzEwNzQsMTUgQEAKIAlyZXR1cm4gcmVzdWx0OwogfQogCisvKiBpcl9kZXZpY2VzX2xvY2sgbXVzdCBiZSBoZWxkICovCitzdGF0aWMgc3RydWN0IElSICpmaW5kX2lyX2RldmljZV9ieV9taW5vcih1bnNpZ25lZCBpbnQgbWlub3IpCit7CisJaWYgKG1pbm9yID49IE1BWF9JUkNUTF9ERVZJQ0VTKQorCQlyZXR1cm4gTlVMTDsKKworCXJldHVybiBpcl9kZXZpY2VzW21pbm9yXTsKK30KKwogLyoKICAqIE9wZW4gdGhlIElSIGRldmljZS4gIEdldCBob2xkIG9mIG91ciBJUiBzdHJ1Y3R1cmUgYW5kCiAgKiBzdGFzaCBpdCBpbiBwcml2YXRlX2RhdGEgZm9yIHRoZSBmaWxlCkBAIC0xMDUxLDE1ICsxMDkxLDE1IEBACiB7CiAJc3RydWN0IElSICppcjsKIAlpbnQgcmV0OworCXVuc2lnbmVkIGludCBtaW5vciA9IE1JTk9SKG5vZGUtPmlfcmRldik7CiAKIAkvKiBmaW5kIG91ciBJUiBzdHJ1Y3QgKi8KLQl1bnNpZ25lZCBtaW5vciA9IE1JTk9SKG5vZGUtPmlfcmRldik7Ci0JaWYgKG1pbm9yID49IE1BWF9JUkNUTF9ERVZJQ0VTKSB7Ci0JCWRwcmludGsoIm1pbm9yICVkOiBvcGVuIHJlc3VsdCA9IC1FTk9ERVZcbiIsCi0JCQltaW5vcik7CisJbXV0ZXhfbG9jaygmaXJfZGV2aWNlc19sb2NrKTsKKwlpciA9IGZpbmRfaXJfZGV2aWNlX2J5X21pbm9yKG1pbm9yKTsKKwltdXRleF91bmxvY2soJmlyX2RldmljZXNfbG9jayk7CisKKwlpZiAoaXIgPT0gTlVMTCkKIAkJcmV0dXJuIC1FTk9ERVY7Ci0JfQotCWlyID0gaXJfZGV2aWNlc1ttaW5vcl07CiAKIAkvKiBpbmNyZW1lbnQgaW4gdXNlIGNvdW50ICovCiAJbXV0ZXhfbG9jaygmaXItPmlyX2xvY2spOwpAQCAtMTEwNiw3ICsxMTQ2LDYgQEAKIAogc3RhdGljIGludCBpcl9yZW1vdmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCk7CiBzdGF0aWMgaW50IGlyX3Byb2JlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkICppZCk7Ci1zdGF0aWMgaW50IGlyX2NvbW1hbmQoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgdW5zaWduZWQgaW50IGNtZCwgdm9pZCAqYXJnKTsKIAogI2RlZmluZSBJRF9GTEFHX1RYCTB4MDEKICNkZWZpbmUgSURfRkxBR19IRFBWUgkweDAyCkBAIC0xMTI2LDcgKzExNjUsNiBAQAogCX0sCiAJLnByb2JlCQk9IGlyX3Byb2JlLAogCS5yZW1vdmUJCT0gaXJfcmVtb3ZlLAotCS5jb21tYW5kCT0gaXJfY29tbWFuZCwKIAkuaWRfdGFibGUJPSBpcl90cmFuc2NlaXZlcl9pZCwKIH07CiAKQEAgLTExNDQsMjE0ICsxMTgyLDI1MyBAQAogCS5yZWxlYXNlCT0gY2xvc2UKIH07CiAKK3N0YXRpYyB2b2lkIGRlc3Ryb3lfcnhfa3RocmVhZChzdHJ1Y3QgSVJfcnggKnJ4KQoreworCS8qIGVuZCB1cCBwb2xsaW5nIHRocmVhZCAqLworCWlmIChyeCAhPSBOVUxMICYmICFJU19FUlJfT1JfTlVMTChyeC0+dGFzaykpIHsKKwkJa3RocmVhZF9zdG9wKHJ4LT50YXNrKTsKKwkJcngtPnRhc2sgPSBOVUxMOworCX0KK30KKworLyogaXJfZGV2aWNlc19sb2NrIG11c3QgYmUgaGVsZCAqLworc3RhdGljIGludCBhZGRfaXJfZGV2aWNlKHN0cnVjdCBJUiAqaXIpCit7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgTUFYX0lSQ1RMX0RFVklDRVM7IGkrKykKKwkJaWYgKGlyX2RldmljZXNbaV0gPT0gTlVMTCkgeworCQkJaXJfZGV2aWNlc1tpXSA9IGlyOworCQkJYnJlYWs7CisJCX0KKworCXJldHVybiBpID09IE1BWF9JUkNUTF9ERVZJQ0VTID8gLUVOT01FTSA6IGk7Cit9CisKKy8qIGlyX2RldmljZXNfbG9jayBtdXN0IGJlIGhlbGQgKi8KK3N0YXRpYyB2b2lkIGRlbF9pcl9kZXZpY2Uoc3RydWN0IElSICppcikKK3sKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBNQVhfSVJDVExfREVWSUNFUzsgaSsrKQorCQlpZiAoaXJfZGV2aWNlc1tpXSA9PSBpcikgeworCQkJaXJfZGV2aWNlc1tpXSA9IE5VTEw7CisJCQlicmVhazsKKwkJfQorfQorCiBzdGF0aWMgaW50IGlyX3JlbW92ZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50KQogewogCXN0cnVjdCBJUiAqaXIgPSBpMmNfZ2V0X2NsaWVudGRhdGEoY2xpZW50KTsKIAotCW11dGV4X2xvY2soJmlyLT5pcl9sb2NrKTsKKwltdXRleF9sb2NrKCZpcl9kZXZpY2VzX2xvY2spOwogCi0JaWYgKGlyLT5oYXZlX3J4IHx8IGlyLT5oYXZlX3R4KSB7Ci0JCURFQ0xBUkVfQ09NUExFVElPTih0bik7Ci0JCURFQ0xBUkVfQ09NUExFVElPTih0bjIpOwotCi0JCS8qIGVuZCB1cCBwb2xsaW5nIHRocmVhZCAqLwotCQlpZiAoaXItPnRhc2sgJiYgIUlTX0VSUihpci0+dGFzaykpIHsKLQkJCWlyLT50X25vdGlmeSA9ICZ0bjsKLQkJCWlyLT50X25vdGlmeTIgPSAmdG4yOwotCQkJaXItPnNodXRkb3duID0gMTsKLQkJCXdha2VfdXBfcHJvY2Vzcyhpci0+dGFzayk7Ci0JCQljb21wbGV0ZSgmdG4yKTsKLQkJCXdhaXRfZm9yX2NvbXBsZXRpb24oJnRuKTsKLQkJCWlyLT50X25vdGlmeSA9IE5VTEw7Ci0JCQlpci0+dF9ub3RpZnkyID0gTlVMTDsKLQkJfQotCi0JfSBlbHNlIHsKLQkJbXV0ZXhfdW5sb2NrKCZpci0+aXJfbG9jayk7Ci0JCXppbG9nX2Vycm9yKCIlczogZGV0YWNoZWQgZnJvbSBzb21ldGhpbmcgd2UgZGlkbid0ICIKLQkJCSAgICAiYXR0YWNoIHRvXG4iLCBfX2Z1bmNfXyk7Ci0JCXJldHVybiAtRU5PREVWOworCWlmIChpciA9PSBOVUxMKSB7CisJCS8qIFdlIGRlc3Ryb3llZCBldmVyeXRoaW5nIHdoZW4gdGhlIGZpcnN0IGNsaWVudCBjYW1lIHRocm91Z2ggKi8KKwkJbXV0ZXhfdW5sb2NrKCZpcl9kZXZpY2VzX2xvY2spOworCQlyZXR1cm4gMDsKIAl9CiAKLQkvKiB1bnJlZ2lzdGVyIGxpcmMgZHJpdmVyICovCi0JaWYgKGlyLT5sLm1pbm9yID49IDAgJiYgaXItPmwubWlub3IgPCBNQVhfSVJDVExfREVWSUNFUykgewotCQlsaXJjX3VucmVnaXN0ZXJfZHJpdmVyKGlyLT5sLm1pbm9yKTsKLQkJaXJfZGV2aWNlc1tpci0+bC5taW5vcl0gPSBOVUxMOworCS8qIEdvb2QtYnllIExJUkMgKi8KKwlsaXJjX3VucmVnaXN0ZXJfZHJpdmVyKGlyLT5sLm1pbm9yKTsKKworCS8qIEdvb2QtYnllIFJ4ICovCisJZGVzdHJveV9yeF9rdGhyZWFkKGlyLT5yeCk7CisJaWYgKGlyLT5yeCAhPSBOVUxMKSB7CisJCWlmIChpci0+cngtPmJ1Zi5maWZvX2luaXRpYWxpemVkKQorCQkJbGlyY19idWZmZXJfZnJlZSgmaXItPnJ4LT5idWYpOworCQlpMmNfc2V0X2NsaWVudGRhdGEoaXItPnJ4LT5jLCBOVUxMKTsKKwkJa2ZyZWUoaXItPnJ4KTsKIAl9CiAKLQkvKiBmcmVlIG1lbW9yeSAqLwotCWxpcmNfYnVmZmVyX2ZyZWUoJmlyLT5idWYpOwotCW11dGV4X3VubG9jaygmaXItPmlyX2xvY2spOworCS8qIEdvb2QtYnllIFR4ICovCisJaTJjX3NldF9jbGllbnRkYXRhKGlyLT50eC0+YywgTlVMTCk7CisJa2ZyZWUoaXItPnR4KTsKKworCS8qIEdvb2QtYnllIElSICovCisJZGVsX2lyX2RldmljZShpcik7CiAJa2ZyZWUoaXIpOwogCisJbXV0ZXhfdW5sb2NrKCZpcl9kZXZpY2VzX2xvY2spOwogCXJldHVybiAwOwogfQogCisKKy8qIGlyX2RldmljZXNfbG9jayBtdXN0IGJlIGhlbGQgKi8KK3N0YXRpYyBzdHJ1Y3QgSVIgKmZpbmRfaXJfZGV2aWNlX2J5X2FkYXB0ZXIoc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyKQoreworCWludCBpOworCXN0cnVjdCBJUiAqaXIgPSBOVUxMOworCisJZm9yIChpID0gMDsgaSA8IE1BWF9JUkNUTF9ERVZJQ0VTOyBpKyspCisJCWlmIChpcl9kZXZpY2VzW2ldICE9IE5VTEwgJiYKKwkJICAgIGlyX2RldmljZXNbaV0tPmFkYXB0ZXIgPT0gYWRhcHRlcikgeworCQkJaXIgPSBpcl9kZXZpY2VzW2ldOworCQkJYnJlYWs7CisJCX0KKworCXJldHVybiBpcjsKK30KKwogc3RhdGljIGludCBpcl9wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LCBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCAqaWQpCiB7Ci0Jc3RydWN0IElSICppciA9IE5VTEw7CisJc3RydWN0IElSICppcjsKIAlzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXAgPSBjbGllbnQtPmFkYXB0ZXI7Ci0JY2hhciBidWY7CiAJaW50IHJldDsKLQlpbnQgaGF2ZV9yeCA9IDAsIGhhdmVfdHggPSAwOworCWJvb2wgdHhfcHJvYmUgPSBmYWxzZTsKIAotCWRwcmludGsoIiVzOiBhZGFwdGVyIG5hbWUgKCVzKSBuciAlZCwgaTJjX2RldmljZV9pZCBuYW1lICglcyksICIKLQkJImNsaWVudCBhZGRyPTB4JTAyeFxuIiwKLQkJX19mdW5jX18sIGFkYXAtPm5hbWUsIGFkYXAtPm5yLCBpZC0+bmFtZSwgY2xpZW50LT5hZGRyKTsKKwlkcHJpbnRrKCIlczogJXMgb24gaTJjLSVkICglcyksIGNsaWVudCBhZGRyPTB4JTAyeFxuIiwKKwkJX19mdW5jX18sIGlkLT5uYW1lLCBhZGFwLT5uciwgYWRhcC0+bmFtZSwgY2xpZW50LT5hZGRyKTsKIAogCS8qCi0JICogRklYTUUgLSBUaGlzIHByb2JlIGZ1bmN0aW9uIHByb2JlcyBib3RoIHRoZSBUeCBhbmQgUngKLQkgKiBhZGRyZXNzZXMgb2YgdGhlIElSIG1pY3JvY29udHJvbGxlci4KLQkgKgotCSAqIEhvd2V2ZXIsIHRoZSBJMkMgc3Vic3lzdGVtIGlzIHBhc3NpbmcgYWxvbmcgb25lIEkyQyBjbGllbnQgYXQgYQotCSAqIHRpbWUsIGJhc2VkIG9uIG1hdGNoZXMgdG8gdGhlIGlyX3RyYW5zY2VpdmVyX2lkW10gdGFibGUgYWJvdmUuCi0JICogVGhlIGV4cGVjdGF0aW9uIGlzIHRoYXQgZWFjaCBpMmNfY2xpZW50IGFkZHJlc3Mgd2lsbCBiZSBwcm9iZWQKLQkgKiBpbmRpdmlkdWFsbHkgYnkgZHJpdmVycyBzbyB0aGUgSTJDIHN1YnN5c3RlbSBjYW4gbWFyayBhbGwgY2xpZW50Ci0JICogYWRkcmVzc2VzIGFzIGNsYWltZWQgb3Igbm90LgotCSAqCi0JICogVGhpcyBwcm9iZSByb3V0aW5lIGNhdXNlcyBvbmx5IG9uZSBvZiB0aGUgY2xpZW50IGFkZHJlc3NlcywgVFggb3IgUlgsCi0JICogdG8gYmUgY2xhaW1lZC4gIFRoaXMgd2lsbCBjYXVzZSBhIHByb2JsZW0gaWYgdGhlIEkyQyBzdWJzeXN0ZW0gaXMKLQkgKiBzdWJzZXF1ZW50bHkgdHJpZ2dlcmVkIHRvIHByb2JlIHVuY2xhaW1lZCBjbGllbnRzIGFnYWluLgorCSAqIFRoZSBJUiByZWNlaXZlciAgICBpcyBhdCBpMmMgYWRkcmVzcyAweDcxLgorCSAqIFRoZSBJUiB0cmFuc21pdHRlciBpcyBhdCBpMmMgYWRkcmVzcyAweDcwLgogCSAqLwotCS8qCi0JICogVGhlIGV4dGVybmFsIElSIHJlY2VpdmVyIGlzIGF0IGkyYyBhZGRyZXNzIDB4NzEuCi0JICogVGhlIElSIHRyYW5zbWl0dGVyIGlzIGF0IDB4NzAuCi0JICovCi0JY2xpZW50LT5hZGRyID0gMHg3MDsKIAotCWlmICghZGlzYWJsZV90eCkgewotCQlpZiAoaTJjX21hc3Rlcl9yZWN2KGNsaWVudCwgJmJ1ZiwgMSkgPT0gMSkKLQkJCWhhdmVfdHggPSAxOwotCQlkcHJpbnRrKCJwcm9iZSAweDcwIEAgJXM6ICVzXG4iLAotCQkJYWRhcC0+bmFtZSwgaGF2ZV90eCA/ICJzdWNjZXNzIiA6ICJmYWlsZWQiKTsKKwlpZiAoaWQtPmRyaXZlcl9kYXRhICYgSURfRkxBR19UWCkKKwkJdHhfcHJvYmUgPSB0cnVlOworCWVsc2UgaWYgKHR4X29ubHkpIC8qIG1vZHVsZSBvcHRpb24gKi8KKwkJcmV0dXJuIC1FTlhJTzsKKworCXppbG9nX2luZm8oInByb2JpbmcgSVIgJXMgb24gJXMgKGkyYy0lZClcbiIsCisJCSAgIHR4X3Byb2JlID8gIlR4IiA6ICJSeCIsIGFkYXAtPm5hbWUsIGFkYXAtPm5yKTsKKworCW11dGV4X2xvY2soJmlyX2RldmljZXNfbG9jayk7CisKKwkvKiBVc2UgYSBzaW5nbGUgc3RydWN0IElSIGluc3RhbmNlIGZvciBib3RoIHRoZSBSeCBhbmQgVHggZnVuY3Rpb25zICovCisJaXIgPSBmaW5kX2lyX2RldmljZV9ieV9hZGFwdGVyKGFkYXApOworCWlmIChpciA9PSBOVUxMKSB7CisJCWlyID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IElSKSwgR0ZQX0tFUk5FTCk7CisJCWlmIChpciA9PSBOVUxMKSB7CisJCQlyZXQgPSAtRU5PTUVNOworCQkJZ290byBvdXRfbm9faXI7CisJCX0KKwkJLyogc3RvcmUgZm9yIHVzZSBpbiBpcl9wcm9iZSgpIGFnYWluLCBhbmQgb3BlbigpIGxhdGVyIG9uICovCisJCXJldCA9IGFkZF9pcl9kZXZpY2UoaXIpOworCQlpZiAocmV0KQorCQkJZ290byBvdXRfZnJlZV9pcjsKKworCQlpci0+YWRhcHRlciA9IGFkYXA7CisJCW11dGV4X2luaXQoJmlyLT5pcl9sb2NrKTsKKworCQkvKiBzZXQgbGlyY19kZXYgc3R1ZmYgKi8KKwkJbWVtY3B5KCZpci0+bCwgJmxpcmNfdGVtcGxhdGUsIHNpemVvZihzdHJ1Y3QgbGlyY19kcml2ZXIpKTsKKwkJaXItPmwubWlub3IgICAgICAgPSBtaW5vcjsgLyogbW9kdWxlIG9wdGlvbiAqLworCQlpci0+bC5jb2RlX2xlbmd0aCA9IDEzOworCQlpci0+bC5yYnVmCSAgPSBOVUxMOworCQlpci0+bC5mb3BzCSAgPSAmbGlyY19mb3BzOworCQlpci0+bC5kYXRhCSAgPSBpcjsKKwkJaXItPmwuZGV2ICAgICAgICAgPSAmYWRhcC0+ZGV2OworCQlpci0+bC5zYW1wbGVfcmF0ZSA9IDA7CiAJfQogCi0JaWYgKCFkaXNhYmxlX3J4KSB7Ci0JCWNsaWVudC0+YWRkciA9IDB4NzE7Ci0JCWlmIChpMmNfbWFzdGVyX3JlY3YoY2xpZW50LCAmYnVmLCAxKSA9PSAxKQotCQkJaGF2ZV9yeCA9IDE7Ci0JCWRwcmludGsoInByb2JlIDB4NzEgQCAlczogJXNcbiIsCi0JCQlhZGFwLT5uYW1lLCBoYXZlX3J4ID8gInN1Y2Nlc3MiIDogImZhaWxlZCIpOworCWlmICh0eF9wcm9iZSkgeworCQkvKiBTZXQgdXAgYSBzdHJ1Y3QgSVJfdHggaW5zdGFuY2UgKi8KKwkJaXItPnR4ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IElSX3R4KSwgR0ZQX0tFUk5FTCk7CisJCWlmIChpci0+dHggPT0gTlVMTCkgeworCQkJcmV0ID0gLUVOT01FTTsKKwkJCWdvdG8gb3V0X2ZyZWVfeHg7CisJCX0KKworCQlpci0+dHgtPmMgPSBjbGllbnQ7CisJCWlyLT50eC0+bmVlZF9ib290ID0gMTsKKwkJaXItPnR4LT5wb3N0X3R4X3JlYWR5X3BvbGwgPQorCQkJICAgICAgIChpZC0+ZHJpdmVyX2RhdGEgJiBJRF9GTEFHX0hEUFZSKSA/IGZhbHNlIDogdHJ1ZTsKKwl9IGVsc2UgeworCQkvKiBTZXQgdXAgYSBzdHJ1Y3QgSVJfcnggaW5zdGFuY2UgKi8KKwkJaXItPnJ4ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IElSX3J4KSwgR0ZQX0tFUk5FTCk7CisJCWlmIChpci0+cnggPT0gTlVMTCkgeworCQkJcmV0ID0gLUVOT01FTTsKKwkJCWdvdG8gb3V0X2ZyZWVfeHg7CisJCX0KKworCQlyZXQgPSBsaXJjX2J1ZmZlcl9pbml0KCZpci0+cngtPmJ1ZiwgMiwgQlVGTEVOIC8gMik7CisJCWlmIChyZXQpCisJCQlnb3RvIG91dF9mcmVlX3h4OworCisJCW11dGV4X2luaXQoJmlyLT5yeC0+YnVmX2xvY2spOworCQlpci0+cngtPmMgPSBjbGllbnQ7CisJCWlyLT5yeC0+aGRwdnJfZGF0YV9mbXQgPQorCQkJICAgICAgIChpZC0+ZHJpdmVyX2RhdGEgJiBJRF9GTEFHX0hEUFZSKSA/IHRydWUgOiBmYWxzZTsKKworCQkvKiBzZXQgbGlyY19kZXYgc3R1ZmYgKi8KKwkJaXItPmwucmJ1ZiA9ICZpci0+cngtPmJ1ZjsKIAl9CiAKLQlpZiAoIShoYXZlX3J4IHx8IGhhdmVfdHgpKSB7Ci0JCXppbG9nX2Vycm9yKCIlczogbm8gZGV2aWNlcyBmb3VuZFxuIiwgYWRhcC0+bmFtZSk7Ci0JCWdvdG8gb3V0X25vZGV2OwotCX0KLQotCXByaW50ayhLRVJOX0lORk8gImxpcmNfemlsb2c6IGNoaXAgZm91bmQgd2l0aCAlc1xuIiwKLQkJaGF2ZV9yeCAmJiBoYXZlX3R4ID8gIlJYIGFuZCBUWCIgOgotCQkJaGF2ZV9yeCA/ICJSWCBvbmx5IiA6ICJUWCBvbmx5Iik7Ci0KLQlpciA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBJUiksIEdGUF9LRVJORUwpOwotCi0JaWYgKCFpcikKLQkJZ290byBvdXRfbm9tZW07Ci0KLQlyZXQgPSBsaXJjX2J1ZmZlcl9pbml0KCZpci0+YnVmLCAyLCBCVUZMRU4gLyAyKTsKLQlpZiAocmV0KQotCQlnb3RvIG91dF9ub21lbTsKLQotCW11dGV4X2luaXQoJmlyLT5pcl9sb2NrKTsKLQltdXRleF9pbml0KCZpci0+YnVmX2xvY2spOwotCWlyLT5uZWVkX2Jvb3QgPSAxOwotCWlyLT5pc19oZHB2ciA9IChpZC0+ZHJpdmVyX2RhdGEgJiBJRF9GTEFHX0hEUFZSKSA/IHRydWUgOiBmYWxzZTsKLQotCW1lbWNweSgmaXItPmwsICZsaXJjX3RlbXBsYXRlLCBzaXplb2Yoc3RydWN0IGxpcmNfZHJpdmVyKSk7Ci0JaXItPmwubWlub3IgPSAtMTsKLQotCS8qIEkyQyBhdHRhY2ggdG8gZGV2aWNlICovCiAJaTJjX3NldF9jbGllbnRkYXRhKGNsaWVudCwgaXIpOwogCisJLyogUHJvY2VlZCBvbmx5IGlmIHdlIGhhdmUgdGhlIHJlcXVpcmVkIFR4IGFuZCBSeCBjbGllbnRzIHJlYWR5IHRvIGdvICovCisJaWYgKGlyLT50eCA9PSBOVUxMIHx8CisJICAgIChpci0+cnggPT0gTlVMTCAmJiAhdHhfb25seSkpIHsKKwkJemlsb2dfaW5mbygicHJvYmUgb2YgSVIgJXMgb24gJXMgKGkyYy0lZCkgZG9uZS4gV2FpdGluZyBvbiAiCisJCQkgICAiSVIgJXMuXG4iLCB0eF9wcm9iZSA/ICJUeCIgOiAiUngiLCBhZGFwLT5uYW1lLAorCQkJICAgYWRhcC0+bnIsIHR4X3Byb2JlID8gIlJ4IiA6ICJUeCIpOworCQlnb3RvIG91dF9vazsKKwl9CisKIAkvKiBpbml0aWFsaXNlIFJYIGRldmljZSAqLwotCWlmIChoYXZlX3J4KSB7Ci0JCURFQ0xBUkVfQ09NUExFVElPTih0bik7Ci0JCW1lbWNweSgmaXItPmNfcngsIGNsaWVudCwgc2l6ZW9mKHN0cnVjdCBpMmNfY2xpZW50KSk7Ci0KLQkJaXItPmNfcnguYWRkciA9IDB4NzE7Ci0JCXN0cmxjcHkoaXItPmNfcngubmFtZSwgWklMT0dfSEFVUFBBVUdFX0lSX1JYX05BTUUsCi0JCQlJMkNfTkFNRV9TSVpFKTsKLQorCWlmIChpci0+cnggIT0gTlVMTCkgewogCQkvKiB0cnkgdG8gZmlyZSB1cCBwb2xsaW5nIHRocmVhZCAqLwotCQlpci0+dF9ub3RpZnkgPSAmdG47Ci0JCWlyLT50YXNrID0ga3RocmVhZF9ydW4obGlyY190aHJlYWQsIGlyLCAibGlyY196aWxvZyIpOwotCQlpZiAoSVNfRVJSKGlyLT50YXNrKSkgewotCQkJcmV0ID0gUFRSX0VSUihpci0+dGFzayk7Ci0JCQl6aWxvZ19lcnJvcigibGlyY19yZWdpc3Rlcl9kcml2ZXI6IGNhbm5vdCBydW4gIgotCQkJCSAgICAicG9sbCB0aHJlYWQgJWRcbiIsIHJldCk7Ci0JCQlnb3RvIGVycjsKKwkJaXItPnJ4LT50YXNrID0ga3RocmVhZF9ydW4obGlyY190aHJlYWQsIGlyLAorCQkJCQkgICAiemlsb2ctcngtaTJjLSVkIiwgYWRhcC0+bnIpOworCQlpZiAoSVNfRVJSKGlyLT5yeC0+dGFzaykpIHsKKwkJCXJldCA9IFBUUl9FUlIoaXItPnJ4LT50YXNrKTsKKwkJCXppbG9nX2Vycm9yKCIlczogY291bGQgbm90IHN0YXJ0IElSIFJ4IHBvbGxpbmcgdGhyZWFkIgorCQkJCSAgICAiXG4iLCBfX2Z1bmNfXyk7CisJCQlnb3RvIG91dF9mcmVlX3h4OwogCQl9Ci0JCXdhaXRfZm9yX2NvbXBsZXRpb24oJnRuKTsKLQkJaXItPnRfbm90aWZ5ID0gTlVMTDsKLQkJaXItPmhhdmVfcnggPSAxOwogCX0KIAotCS8qIGluaXRpYWxpc2UgVFggZGV2aWNlICovCi0JaWYgKGhhdmVfdHgpIHsKLQkJbWVtY3B5KCZpci0+Y190eCwgY2xpZW50LCBzaXplb2Yoc3RydWN0IGkyY19jbGllbnQpKTsKLQkJaXItPmNfdHguYWRkciA9IDB4NzA7Ci0JCXN0cmxjcHkoaXItPmNfdHgubmFtZSwgWklMT0dfSEFVUFBBVUdFX0lSX1RYX05BTUUsCi0JCQlJMkNfTkFNRV9TSVpFKTsKLQkJaXItPmhhdmVfdHggPSAxOwotCX0KLQotCS8qIHNldCBsaXJjX2RldiBzdHVmZiAqLwotCWlyLT5sLmNvZGVfbGVuZ3RoID0gMTM7Ci0JaXItPmwucmJ1ZgkgID0gJmlyLT5idWY7Ci0JaXItPmwuZm9wcwkgID0gJmxpcmNfZm9wczsKLQlpci0+bC5kYXRhCSAgPSBpcjsKLQlpci0+bC5taW5vciAgICAgICA9IG1pbm9yOwotCWlyLT5sLmRldiAgICAgICAgID0gJmFkYXAtPmRldjsKLQlpci0+bC5zYW1wbGVfcmF0ZSA9IDA7Ci0KIAkvKiByZWdpc3RlciB3aXRoIGxpcmMgKi8KIAlpci0+bC5taW5vciA9IGxpcmNfcmVnaXN0ZXJfZHJpdmVyKCZpci0+bCk7CiAJaWYgKGlyLT5sLm1pbm9yIDwgMCB8fCBpci0+bC5taW5vciA+PSBNQVhfSVJDVExfREVWSUNFUykgewotCQl6aWxvZ19lcnJvcigiaXJfYXR0YWNoOiBcIm1pbm9yXCIgbXVzdCBiZSBiZXR3ZWVuIDAgYW5kICVkICIKLQkJCSAgICAiKCVkKSFcbiIsIE1BWF9JUkNUTF9ERVZJQ0VTLTEsIGlyLT5sLm1pbm9yKTsKKwkJemlsb2dfZXJyb3IoIiVzOiBcIm1pbm9yXCIgbXVzdCBiZSBiZXR3ZWVuIDAgYW5kICVkICglZCkhXG4iLAorCQkJICAgIF9fZnVuY19fLCBNQVhfSVJDVExfREVWSUNFUy0xLCBpci0+bC5taW5vcik7CiAJCXJldCA9IC1FQkFEUlFDOwotCQlnb3RvIGVycjsKKwkJZ290byBvdXRfZnJlZV90aHJlYWQ7CiAJfQogCi0JLyogc3RvcmUgdGhpcyBmb3IgZ2V0dGluZyBiYWNrIGluIG9wZW4oKSBsYXRlciBvbiAqLwotCWlyX2RldmljZXNbaXItPmwubWlub3JdID0gaXI7Ci0KIAkvKgogCSAqIGlmIHdlIGhhdmUgdGhlIHR4IGRldmljZSwgbG9hZCB0aGUgJ2Zpcm13YXJlJy4gIFdlIGRvIHRoaXMKIAkgKiBhZnRlciByZWdpc3RlcmluZyB3aXRoIGxpcmMgYXMgb3RoZXJ3aXNlIGhvdHBsdWcgc2VlbXMgdG8gdGFrZQogCSAqIDEwcyB0byBjcmVhdGUgdGhlIGxpcmMgZGV2aWNlLgogCSAqLwotCWlmIChoYXZlX3R4KSB7Ci0JCS8qIFNwZWNpYWwgVFggaW5pdCAqLwotCQlyZXQgPSB0eF9pbml0KGlyKTsKLQkJaWYgKHJldCAhPSAwKQotCQkJZ290byBlcnI7CisJcmV0ID0gdHhfaW5pdChpci0+dHgpOworCWlmIChyZXQgIT0gMCkKKwkJZ290byBvdXRfdW5yZWdpc3RlcjsKKworCXppbG9nX2luZm8oInByb2JlIG9mIElSICVzIG9uICVzIChpMmMtJWQpIGRvbmUuIElSIHVuaXQgcmVhZHkuXG4iLAorCQkgICB0eF9wcm9iZSA/ICJUeCIgOiAiUngiLCBhZGFwLT5uYW1lLCBhZGFwLT5ucik7CitvdXRfb2s6CisJbXV0ZXhfdW5sb2NrKCZpcl9kZXZpY2VzX2xvY2spOworCXJldHVybiAwOworCitvdXRfdW5yZWdpc3RlcjoKKwlsaXJjX3VucmVnaXN0ZXJfZHJpdmVyKGlyLT5sLm1pbm9yKTsKK291dF9mcmVlX3RocmVhZDoKKwlkZXN0cm95X3J4X2t0aHJlYWQoaXItPnJ4KTsKK291dF9mcmVlX3h4OgorCWlmIChpci0+cnggIT0gTlVMTCkgeworCQlpZiAoaXItPnJ4LT5idWYuZmlmb19pbml0aWFsaXplZCkKKwkJCWxpcmNfYnVmZmVyX2ZyZWUoJmlyLT5yeC0+YnVmKTsKKwkJaWYgKGlyLT5yeC0+YyAhPSBOVUxMKQorCQkJaTJjX3NldF9jbGllbnRkYXRhKGlyLT5yeC0+YywgTlVMTCk7CisJCWtmcmVlKGlyLT5yeCk7CiAJfQotCi0JcmV0dXJuIDA7Ci0KLWVycjoKLQkvKiB1bmRvIGV2ZXJ5dGhpbmcsIGhvcGVmdWxseS4uLiAqLwotCWlmIChpci0+Y19yeC5hZGRyKQotCQlpcl9yZW1vdmUoJmlyLT5jX3J4KTsKLQlpZiAoaXItPmNfdHguYWRkcikKLQkJaXJfcmVtb3ZlKCZpci0+Y190eCk7Ci0JcmV0dXJuIHJldDsKLQotb3V0X25vZGV2OgotCXppbG9nX2Vycm9yKCJubyBkZXZpY2UgZm91bmRcbiIpOwotCXJldHVybiAtRU5PREVWOwotCi1vdXRfbm9tZW06Ci0Jemlsb2dfZXJyb3IoIm1lbW9yeSBhbGxvY2F0aW9uIGZhaWx1cmVcbiIpOworCWlmIChpci0+dHggIT0gTlVMTCkgeworCQlpZiAoaXItPnR4LT5jICE9IE5VTEwpCisJCQlpMmNfc2V0X2NsaWVudGRhdGEoaXItPnR4LT5jLCBOVUxMKTsKKwkJa2ZyZWUoaXItPnR4KTsKKwl9CitvdXRfZnJlZV9pcjoKKwlkZWxfaXJfZGV2aWNlKGlyKTsKIAlrZnJlZShpcik7Ci0JcmV0dXJuIC1FTk9NRU07Ci19Ci0KLXN0YXRpYyBpbnQgaXJfY29tbWFuZChzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LCB1bnNpZ25lZCBpbnQgY21kLCB2b2lkICphcmcpCi17Ci0JLyogbm90aGluZyAqLwotCXJldHVybiAwOworb3V0X25vX2lyOgorCXppbG9nX2Vycm9yKCIlczogcHJvYmluZyBJUiAlcyBvbiAlcyAoaTJjLSVkKSBmYWlsZWQgd2l0aCAlZFxuIiwKKwkJICAgIF9fZnVuY19fLCB0eF9wcm9iZSA/ICJUeCIgOiAiUngiLCBhZGFwLT5uYW1lLCBhZGFwLT5uciwKKwkJICAgcmV0KTsKKwltdXRleF91bmxvY2soJmlyX2RldmljZXNfbG9jayk7CisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIGludCBfX2luaXQgemlsb2dfaW5pdCh2b2lkKQpAQCAtMTM2MSw2ICsxNDM4LDcgQEAKIAl6aWxvZ19ub3RpZnkoIlppbG9nL0hhdXBwYXVnZSBJUiBkcml2ZXIgaW5pdGlhbGl6aW5nXG4iKTsKIAogCW11dGV4X2luaXQoJnR4X2RhdGFfbG9jayk7CisJbXV0ZXhfaW5pdCgmaXJfZGV2aWNlc19sb2NrKTsKIAogCXJlcXVlc3RfbW9kdWxlKCJmaXJtd2FyZV9jbGFzcyIpOwogCkBAIC0xMzg2LDcgKzE0NjQsOCBAQAogCiBNT0RVTEVfREVTQ1JJUFRJT04oIlppbG9nL0hhdXBwYXVnZSBpbmZyYXJlZCB0cmFuc21pdHRlciBkcml2ZXIgKGkyYyBzdGFjaykiKTsKIE1PRFVMRV9BVVRIT1IoIkdlcmQgS25vcnIsIE1pY2hhbCBLb2NoYW5vd2ljeiwgQ2hyaXN0b3BoIEJhcnRlbG11cywgIgotCSAgICAgICJVbHJpY2ggTXVlbGxlciwgU3RlZmFuIEphaG4sIEplcm9tZSBCcm9jaywgTWFyayBXZWF2ZXIiKTsKKwkgICAgICAiVWxyaWNoIE11ZWxsZXIsIFN0ZWZhbiBKYWhuLCBKZXJvbWUgQnJvY2ssIE1hcmsgV2VhdmVyLCAiCisJICAgICAgIkFuZHkgV2FsbHMiKTsKIE1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKIC8qIGZvciBjb21wYXQgd2l0aCBvbGQgbmFtZSwgd2hpY2ggaXNuJ3QgYWxsIHRoYXQgYWNjdXJhdGUgYW55bW9yZSAqLwogTU9EVUxFX0FMSUFTKCJsaXJjX3B2cjE1MCIpOwpAQCAtMTM5Nyw4ICsxNDc2LDUgQEAKIG1vZHVsZV9wYXJhbShkZWJ1ZywgYm9vbCwgMDY0NCk7CiBNT0RVTEVfUEFSTV9ERVNDKGRlYnVnLCAiRW5hYmxlIGRlYnVnZ2luZyBtZXNzYWdlcyIpOwogCi1tb2R1bGVfcGFyYW0oZGlzYWJsZV9yeCwgYm9vbCwgMDY0NCk7Ci1NT0RVTEVfUEFSTV9ERVNDKGRpc2FibGVfcngsICJEaXNhYmxlIHRoZSBJUiByZWNlaXZlciBkZXZpY2UiKTsKLQotbW9kdWxlX3BhcmFtKGRpc2FibGVfdHgsIGJvb2wsIDA2NDQpOwotTU9EVUxFX1BBUk1fREVTQyhkaXNhYmxlX3R4LCAiRGlzYWJsZSB0aGUgSVIgdHJhbnNtaXR0ZXIgZGV2aWNlIik7Cittb2R1bGVfcGFyYW0odHhfb25seSwgYm9vbCwgMDY0NCk7CitNT0RVTEVfUEFSTV9ERVNDKHR4X29ubHksICJPbmx5IGhhbmRsZSB0aGUgSVIgdHJhbnNtaXQgZnVuY3Rpb24iKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9tc20vbXNtX2ZiLmMgYi9kcml2ZXJzL3N0YWdpbmcvbXNtL21zbV9mYi5jCmluZGV4IDIzZmEwNDkuLmEyZjI5ZDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9tc20vbXNtX2ZiLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL21zbS9tc21fZmIuYwpAQCAtMzQ3LDcgKzM0Nyw3IEBACiAJaWYgKCghbWZkKSB8fCAobWZkLT5rZXkgIT0gTUZEX0tFWSkpCiAJCXJldHVybiAwOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWZiX3NldF9zdXNwZW5kKG1mZC0+ZmJpLCAxKTsKIAogCXJldCA9IG1zbV9mYl9zdXNwZW5kX3N1YihtZmQpOwpAQCAtMzU4LDcgKzM1OCw3IEBACiAJCXBkZXYtPmRldi5wb3dlci5wb3dlcl9zdGF0ZSA9IHN0YXRlOwogCX0KIAotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCXJldHVybiByZXQ7CiB9CiAjZWxzZQpAQCAtNDMxLDExICs0MzEsMTEgQEAKIAlpZiAoKCFtZmQpIHx8IChtZmQtPmtleSAhPSBNRkRfS0VZKSkKIAkJcmV0dXJuIDA7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJcmV0ID0gbXNtX2ZiX3Jlc3VtZV9zdWIobWZkKTsKIAlwZGV2LT5kZXYucG93ZXIucG93ZXJfc3RhdGUgPSBQTVNHX09OOwogCWZiX3NldF9zdXNwZW5kKG1mZC0+ZmJpLCAxKTsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCXJldHVybiByZXQ7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvb2xwY19kY29uL29scGNfZGNvbi5jIGIvZHJpdmVycy9zdGFnaW5nL29scGNfZGNvbi9vbHBjX2Rjb24uYwppbmRleCA5ZjI2ZGM5Li41NmEyODNkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvb2xwY19kY29uL29scGNfZGNvbi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9vbHBjX2Rjb24vb2xwY19kY29uLmMKQEAgLTM3MywxNyArMzczLDE3IEBACiAJCSAqCiAJCSAqIEZvciBub3csIHdlIGp1c3QgaG9wZS4uCiAJCSAqLwotCQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfbG9jaygpOwogCQlpZ25vcmVfZmJfZXZlbnRzID0gMTsKIAkJaWYgKGZiX2JsYW5rKGZiaW5mbywgRkJfQkxBTktfVU5CTEFOSykpIHsKIAkJCWlnbm9yZV9mYl9ldmVudHMgPSAwOwotCQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQkJY29uc29sZV91bmxvY2soKTsKIAkJCXByaW50ayhLRVJOX0VSUiAib2xwYy1kY29uOiAgRmFpbGVkIHRvIGVudGVyIENQVSBtb2RlXG4iKTsKIAkJCWRjb25fcGVuZGluZyA9IERDT05fU09VUkNFX0RDT047CiAJCQlyZXR1cm47CiAJCX0KIAkJaWdub3JlX2ZiX2V2ZW50cyA9IDA7Ci0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAogCQkvKiBBbmQgdHVybiBvZmYgdGhlIERDT04gKi8KIAkJcGRhdGEtPnNldF9kY29ubG9hZCgxKTsKQEAgLTQzNSwxMiArNDM1LDEyIEBACiAJCQl9CiAJCX0KIAotCQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfbG9jaygpOwogCQlpZ25vcmVfZmJfZXZlbnRzID0gMTsKIAkJaWYgKGZiX2JsYW5rKGZiaW5mbywgRkJfQkxBTktfUE9XRVJET1dOKSkKIAkJCXByaW50ayhLRVJOX0VSUiAib2xwYy1kY29uOiAgY291bGRuJ3QgYmxhbmsgZmIhXG4iKTsKIAkJaWdub3JlX2ZiX2V2ZW50cyA9IDA7Ci0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAogCQlwcmludGsoS0VSTl9JTkZPICJvbHBjLWRjb246IFRoZSBEQ09OIGhhcyBjb250cm9sXG4iKTsKIAkJYnJlYWs7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL3J0X21haW5fZGV2LmMgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL3J0X21haW5fZGV2LmMKaW5kZXggNzAxNTYxZC4uMjM2ZGQzNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9ydF9tYWluX2Rldi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvcnRfbWFpbl9kZXYuYwpAQCAtNDg0LDggKzQ4NCw2IEBACiAJbmV0X2Rldi0+bWxfcHJpdiA9ICh2b2lkICopcEFkOwogCXBBZC0+bmV0X2RldiA9IG5ldF9kZXY7CiAKLQluZXRpZl9zdG9wX3F1ZXVlKG5ldF9kZXYpOwotCiAJcmV0dXJuIG5ldF9kZXY7CiAKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvdXNiX21haW5fZGV2LmMgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL3VzYl9tYWluX2Rldi5jCmluZGV4IGVlNjhkNTEuLjMyMmJmNDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvdXNiX21haW5fZGV2LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC91c2JfbWFpbl9kZXYuYwpAQCAtMTA2LDYgKzEwNiw3IEBACiAJe1VTQl9ERVZJQ0UoMHgwNDExLCAweDAxNmYpfSwJLyogTWVsQ28uLEluYy4gV0xJLVVDLUczMDFOICovCiAJe1VTQl9ERVZJQ0UoMHgxNzM3LCAweDAwNzApfSwJLyogTGlua3N5cyBXVVNCMTAwICovCiAJe1VTQl9ERVZJQ0UoMHgxNzM3LCAweDAwNzEpfSwJLyogTGlua3N5cyBXVVNCNjAwTiAqLworCXtVU0JfREVWSUNFKDB4MTczNywgMHgwMDc4KX0sCS8qIExpbmtzeXMgV1VTQjEwMHYyICovCiAJe1VTQl9ERVZJQ0UoMHgwNDExLCAweDAwZTgpfSwJLyogQnVmZmFsbyBXTEktVUMtRzMwME4gKi8KIAl7VVNCX0RFVklDRSgweDA1MGQsIDB4ODE1Yyl9LAkvKiBCZWxraW4gRjVEODA1MyAqLwogCXtVU0JfREVWSUNFKDB4MTAwRCwgMHg5MDMxKX0sCS8qIE1vdG9yb2xhIDI3NzAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4NzEyL2hhbF9pbml0LmMgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODcxMi9oYWxfaW5pdC5jCmluZGV4IDMyMDg4YTYuLjg0YmUzODMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydGw4NzEyL2hhbF9pbml0LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0bDg3MTIvaGFsX2luaXQuYwpAQCAtMTI4LDEyICsxMjgsMTMgQEAKIAl1OCAqcHRtcGNoYXIgPSBOVUxMLCAqcHBheWxvYWQsICpwdHI7CiAJc3RydWN0IHR4X2Rlc2MgKnB0eF9kZXNjOwogCXUzMiB0eGRzY3Bfc3ogPSBzaXplb2Yoc3RydWN0IHR4X2Rlc2MpOworCXU4IHJldCA9IF9GQUlMOwogCiAJdWxmaWxlbGVuZ3RoID0gcnRsODcxeF9vcGVuX2Z3KHBhZGFwdGVyLCAmcGhmd2ZpbGVfaGRsLCAmcG1hcHBlZGZ3KTsKIAlpZiAocG1hcHBlZGZ3ICYmICh1bGZpbGVsZW5ndGggPiAwKSkgewogCQl1cGRhdGVfZndoZHIoJmZ3aGRyLCBwbWFwcGVkZncpOwogCQlpZiAoY2hrX2Z3aGRyKCZmd2hkciwgdWxmaWxlbGVuZ3RoKSA9PSBfRkFJTCkKLQkJCWdvdG8gZXhpdF9mYWlsOworCQkJZ290byBmaXJtd2FyZV9yZWw7CiAJCWZpbGxfZndwcml2KHBhZGFwdGVyLCAmZndoZHIuZndwcml2KTsKIAkJLyogZmlybXdhcmUgY2hlY2sgb2sgKi8KIAkJbWF4bGVuID0gKGZ3aGRyLmltZ19JTUVNX3NpemUgPiBmd2hkci5pbWdfU1JBTV9zaXplKSA/CkBAIC0xNDEsNyArMTQyLDcgQEAKIAkJbWF4bGVuICs9IHR4ZHNjcF9zejsKIAkJcHRtcGNoYXIgPSBfbWFsbG9jKG1heGxlbiArIEZXQlVGRl9BTElHTl9TWik7CiAJCWlmIChwdG1wY2hhciA9PSBOVUxMKQotCQkJcmV0dXJuIF9GQUlMOworCQkJZ290byBmaXJtd2FyZV9yZWw7CiAKIAkJcHR4X2Rlc2MgPSAoc3RydWN0IHR4X2Rlc2MgKikocHRtcGNoYXIgKyBGV0JVRkZfQUxJR05fU1ogLQogCQkJICAgICgoYWRkcl90KShwdG1wY2hhcikgJiAoRldCVUZGX0FMSUdOX1NaIC0gMSkpKTsKQEAgLTI3MywxMSArMjc0LDEzIEBACiAJCQlnb3RvIGV4aXRfZmFpbDsKIAl9IGVsc2UKIAkJZ290byBleGl0X2ZhaWw7Ci0JcmV0dXJuIF9TVUNDRVNTOworCXJldCA9IF9TVUNDRVNTOwogCiBleGl0X2ZhaWw6CiAJa2ZyZWUocHRtcGNoYXIpOwotCXJldHVybiBfRkFJTDsKK2Zpcm13YXJlX3JlbDoKKwlyZWxlYXNlX2Zpcm13YXJlKChzdHJ1Y3QgZmlybXdhcmUgKilwaGZ3ZmlsZV9oZGwpOworCXJldHVybiByZXQ7CiB9CiAKIHVpbnQgcnRsODcxMl9oYWxfaW5pdChzdHJ1Y3QgX2FkYXB0ZXIgKnBhZGFwdGVyKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0bDg3MTIvdXNiX2ludGYuYyBiL2RyaXZlcnMvc3RhZ2luZy9ydGw4NzEyL3VzYl9pbnRmLmMKaW5kZXggYTY5MmVlOC4uMjFjZTJhZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0bDg3MTIvdXNiX2ludGYuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODcxMi91c2JfaW50Zi5jCkBAIC00Nyw1NCArNDcsMTIzIEBACiBzdGF0aWMgdm9pZCByODcxeHVfZGV2X3JlbW92ZShzdHJ1Y3QgdXNiX2ludGVyZmFjZSAqcHVzYl9pbnRmKTsKIAogc3RhdGljIHN0cnVjdCB1c2JfZGV2aWNlX2lkIHJ0bDg3MXhfdXNiX2lkX3RibFtdID0gewotCS8qOTJTVQotCSAqIFJlYWx0ZWsgKi8KLQl7VVNCX0RFVklDRSgweDBiZGEsIDB4ODE3MSl9LAotCXtVU0JfREVWSUNFKDB4MGJkYSwgMHg4MTcyKX0sCisKKy8qIFJUTDgxODhTVSAqLworCS8qIFJlYWx0ZWsgKi8KKwl7VVNCX0RFVklDRSgweDBCREEsIDB4ODE3MSl9LAogCXtVU0JfREVWSUNFKDB4MGJkYSwgMHg4MTczKX0sCi0Je1VTQl9ERVZJQ0UoMHgwYmRhLCAweDgxNzQpfSwKIAl7VVNCX0RFVklDRSgweDBiZGEsIDB4ODcxMil9LAogCXtVU0JfREVWSUNFKDB4MGJkYSwgMHg4NzEzKX0sCiAJe1VTQl9ERVZJQ0UoMHgwYmRhLCAweEM1MTIpfSwKLQkvKiBBYm9jb20gICovCisJLyogQWJvY29tICovCiAJe1VTQl9ERVZJQ0UoMHgwN0I4LCAweDgxODgpfSwKLQkvKiBDb3JlZ2EgKi8KLQl7VVNCX0RFVklDRSgweDA3YWEsIDB4MDA0Nyl9LAotCS8qIERsaW5rICovCi0Je1VTQl9ERVZJQ0UoMHgwN2QxLCAweDMzMDMpfSwKLQl7VVNCX0RFVklDRSgweDA3ZDEsIDB4MzMwMil9LAotCXtVU0JfREVWSUNFKDB4MDdkMSwgMHgzMzAwKX0sCi0JLyogRGxpbmsgZm9yIFNreXdvcnRoICovCi0Je1VTQl9ERVZJQ0UoMHgxNGIyLCAweDMzMDApfSwKLQl7VVNCX0RFVklDRSgweDE0YjIsIDB4MzMwMSl9LAotCXtVU0JfREVWSUNFKDB4MTRiMiwgMHgzMzAyKX0sCi0JLyogRW5HZW5pdXMgKi8KLQl7VVNCX0RFVklDRSgweDE3NDAsIDB4OTYwMyl9LAotCXtVU0JfREVWSUNFKDB4MTc0MCwgMHg5NjA1KX0sCisJLyogQVNVUyAqLworCXtVU0JfREVWSUNFKDB4MEIwNSwgMHgxNzg2KX0sCisJe1VTQl9ERVZJQ0UoMHgwQjA1LCAweDE3OTEpfSwgLyogMTFuIG1vZGUgZGlzYWJsZSAqLwogCS8qIEJlbGtpbiAqLwotCXtVU0JfREVWSUNFKDB4MDUwZCwgMHg4MTVGKX0sCi0Je1VTQl9ERVZJQ0UoMHgwNTBkLCAweDk0NUEpfSwKLQl7VVNCX0RFVklDRSgweDA1MGQsIDB4ODQ1QSl9LAotCS8qIEd1aWxsZW1vdCAqLwotCXtVU0JfREVWSUNFKDB4MDZmOCwgMHhlMDMxKX0sCisJe1VTQl9ERVZJQ0UoMHgwNTBELCAweDk0NUEpfSwKKwkvKiBDb3JlZ2EgKi8KKwl7VVNCX0RFVklDRSgweDA3QUEsIDB4MDA0Nyl9LAorCS8qIEQtTGluayAqLworCXtVU0JfREVWSUNFKDB4MjAwMSwgMHgzMzA2KX0sCisJe1VTQl9ERVZJQ0UoMHgwN0QxLCAweDMzMDYpfSwgLyogMTFuIG1vZGUgZGlzYWJsZSAqLwogCS8qIEVkaW1heCAqLwogCXtVU0JfREVWSUNFKDB4NzM5MiwgMHg3NjExKX0sCi0Je1VTQl9ERVZJQ0UoMHg3MzkyLCAweDc2MTIpfSwKLQl7VVNCX0RFVklDRSgweDczOTIsIDB4NzYyMil9LAorCS8qIEVuR2VuaXVzICovCisJe1VTQl9ERVZJQ0UoMHgxNzQwLCAweDk2MDMpfSwKKwkvKiBIYXdraW5nICovCisJe1VTQl9ERVZJQ0UoMHgwRTY2LCAweDAwMTYpfSwKKwkvKiBIZXJjdWxlcyAqLworCXtVU0JfREVWSUNFKDB4MDZGOCwgMHhFMDM0KX0sCisJe1VTQl9ERVZJQ0UoMHgwNkY4LCAweEUwMzIpfSwKKwkvKiBMb2dpdGVjICovCisJe1VTQl9ERVZJQ0UoMHgwNzg5LCAweDAxNjcpfSwKKwkvKiBQQ0kgKi8KKwl7VVNCX0RFVklDRSgweDIwMTksIDB4QUIyOCl9LAorCXtVU0JfREVWSUNFKDB4MjAxOSwgMHhFRDE2KX0sCiAJLyogU2l0ZWNvbSAqLworCXtVU0JfREVWSUNFKDB4MERGNiwgMHgwMDU3KX0sCiAJe1VTQl9ERVZJQ0UoMHgwREY2LCAweDAwNDUpfSwKKwl7VVNCX0RFVklDRSgweDBERjYsIDB4MDA1OSl9LCAvKiAxMW4gbW9kZSBkaXNhYmxlICovCisJe1VTQl9ERVZJQ0UoMHgwREY2LCAweDAwNEIpfSwKKwl7VVNCX0RFVklDRSgweDBERjYsIDB4MDA2Myl9LAorCS8qIFN3ZWV4ICovCisJe1VTQl9ERVZJQ0UoMHgxNzdGLCAweDAxNTQpfSwKKwkvKiBUaGlua3dhcmUgKi8KKwl7VVNCX0RFVklDRSgweDBCREEsIDB4NTA3Nyl9LAorCS8qIFRvc2hpYmEgKi8KKwl7VVNCX0RFVklDRSgweDE2OTAsIDB4MDc1Mil9LAorCS8qIC0gKi8KKwl7VVNCX0RFVklDRSgweDIwRjQsIDB4NjQ2Qil9LAorCXtVU0JfREVWSUNFKDB4MDgzQSwgMHhDNTEyKX0sCisKKy8qIFJUTDgxOTFTVSAqLworCS8qIFJlYWx0ZWsgKi8KKwl7VVNCX0RFVklDRSgweDBCREEsIDB4ODE3Mil9LAorCS8qIEFtaWdvICovCisJe1VTQl9ERVZJQ0UoMHgwRUIwLCAweDkwNjEpfSwKKwkvKiBBU1VTL0VLQiAqLworCXtVU0JfREVWSUNFKDB4MEJEQSwgMHg4MTcyKX0sCisJe1VTQl9ERVZJQ0UoMHgxM0QzLCAweDMzMjMpfSwKKwl7VVNCX0RFVklDRSgweDEzRDMsIDB4MzMxMSl9LCAvKiAxMW4gbW9kZSBkaXNhYmxlICovCisJe1VTQl9ERVZJQ0UoMHgxM0QzLCAweDMzNDIpfSwKKwkvKiBBU1VTL0VLQkxlbm92byAqLworCXtVU0JfREVWSUNFKDB4MTNEMywgMHgzMzMzKX0sCisJe1VTQl9ERVZJQ0UoMHgxM0QzLCAweDMzMzQpfSwKKwl7VVNCX0RFVklDRSgweDEzRDMsIDB4MzMzNSl9LCAvKiAxMW4gbW9kZSBkaXNhYmxlICovCisJe1VTQl9ERVZJQ0UoMHgxM0QzLCAweDMzMzYpfSwgLyogMTFuIG1vZGUgZGlzYWJsZSAqLworCS8qIEFTVVMvTWVkaWEgQk9YICovCisJe1VTQl9ERVZJQ0UoMHgxM0QzLCAweDMzMDkpfSwKKwkvKiBCZWxraW4gKi8KKwl7VVNCX0RFVklDRSgweDA1MEQsIDB4ODE1Ril9LAorCS8qIEQtTGluayAqLworCXtVU0JfREVWSUNFKDB4MDdEMSwgMHgzMzAyKX0sCisJe1VTQl9ERVZJQ0UoMHgwN0QxLCAweDMzMDApfSwKKwl7VVNCX0RFVklDRSgweDA3RDEsIDB4MzMwMyl9LAorCS8qIEVkaW1heCAqLworCXtVU0JfREVWSUNFKDB4NzM5MiwgMHg3NjEyKX0sCisJLyogRW5HZW5pdXMgKi8KKwl7VVNCX0RFVklDRSgweDE3NDAsIDB4OTYwNSl9LAorCS8qIEd1aWxsZW1vdCAqLworCXtVU0JfREVWSUNFKDB4MDZGOCwgMHhFMDMxKX0sCiAJLyogSGF3a2luZyAqLwogCXtVU0JfREVWSUNFKDB4MEU2NiwgMHgwMDE1KX0sCi0Je1VTQl9ERVZJQ0UoMHgwRTY2LCAweDAwMTYpfSwKLQl7VVNCX0RFVklDRSgweDBiMDUsIDB4MTc4Nil9LAotCXtVU0JfREVWSUNFKDB4MGIwNSwgMHgxNzkxKX0sICAgIC8qIDExbiBtb2RlIGRpc2FibGUgKi8KLQorCS8qIE1lZGlhbyAqLwogCXtVU0JfREVWSUNFKDB4MTNEMywgMHgzMzA2KX0sCi0Je1VTQl9ERVZJQ0UoMHgxM0QzLCAweDMzMDkpfSwKKwkvKiBQQ0kgKi8KKwl7VVNCX0RFVklDRSgweDIwMTksIDB4RUQxOCl9LAorCXtVU0JfREVWSUNFKDB4MjAxOSwgMHg0OTAxKX0sCisJLyogU2l0ZWNvbSAqLworCXtVU0JfREVWSUNFKDB4MERGNiwgMHgwMDU4KX0sCisJe1VTQl9ERVZJQ0UoMHgwREY2LCAweDAwNDkpfSwKKwl7VVNCX0RFVklDRSgweDBERjYsIDB4MDA0Qyl9LAorCXtVU0JfREVWSUNFKDB4MERGNiwgMHgwMDY0KX0sCisJLyogU2t5d29ydGggKi8KKwl7VVNCX0RFVklDRSgweDE0YjIsIDB4MzMwMCl9LAorCXtVU0JfREVWSUNFKDB4MTRiMiwgMHgzMzAxKX0sCisJe1VTQl9ERVZJQ0UoMHgxNEIyLCAweDMzMDIpfSwKKwkvKiAtICovCisJe1VTQl9ERVZJQ0UoMHgwNEYyLCAweEFGRjIpfSwKKwl7VVNCX0RFVklDRSgweDA0RjIsIDB4QUZGNSl9LAorCXtVU0JfREVWSUNFKDB4MDRGMiwgMHhBRkY2KX0sCisJe1VTQl9ERVZJQ0UoMHgxM0QzLCAweDMzMzkpfSwKKwl7VVNCX0RFVklDRSgweDEzRDMsIDB4MzM0MCl9LCAvKiAxMW4gbW9kZSBkaXNhYmxlICovCisJe1VTQl9ERVZJQ0UoMHgxM0QzLCAweDMzNDEpfSwgLyogMTFuIG1vZGUgZGlzYWJsZSAqLwogCXtVU0JfREVWSUNFKDB4MTNEMywgMHgzMzEwKX0sCi0Je1VTQl9ERVZJQ0UoMHgxM0QzLCAweDMzMTEpfSwgICAgLyogMTFuIG1vZGUgZGlzYWJsZSAqLwogCXtVU0JfREVWSUNFKDB4MTNEMywgMHgzMzI1KX0sCi0Je1VTQl9ERVZJQ0UoMHgwODNBLCAweEM1MTIpfSwKKworLyogUlRMODE5MlNVICovCisJLyogUmVhbHRlayAqLworCXtVU0JfREVWSUNFKDB4MEJEQSwgMHg4MTc0KX0sCisJe1VTQl9ERVZJQ0UoMHgwQkRBLCAweDgxNzQpfSwKKwkvKiBCZWxraW4gKi8KKwl7VVNCX0RFVklDRSgweDA1MEQsIDB4ODQ1QSl9LAorCS8qIENvcmVnYSAqLworCXtVU0JfREVWSUNFKDB4MDdBQSwgMHgwMDUxKX0sCisJLyogRWRpbWF4ICovCisJe1VTQl9ERVZJQ0UoMHg3MzkyLCAweDc2MjIpfSwKKwkvKiBORUMgKi8KKwl7VVNCX0RFVklDRSgweDA0MDksIDB4MDJCNil9LAogCXt9CiB9OwogCkBAIC0xMDMsOCArMTcyLDIwIEBACiBzdGF0aWMgc3RydWN0IHNwZWNpZmljX2RldmljZV9pZCBzcGVjaWZpY19kZXZpY2VfaWRfdGJsW10gPSB7CiAJey5pZFZlbmRvciA9IDB4MGIwNSwgLmlkUHJvZHVjdCA9IDB4MTc5MSwKIAkJIC5mbGFncyA9IFNQRUNfREVWX0lEX0RJU0FCTEVfSFR9LAorCXsuaWRWZW5kb3IgPSAweDBkZjYsIC5pZFByb2R1Y3QgPSAweDAwNTksCisJCSAuZmxhZ3MgPSBTUEVDX0RFVl9JRF9ESVNBQkxFX0hUfSwKKwl7LmlkVmVuZG9yID0gMHgxM2QzLCAuaWRQcm9kdWN0ID0gMHgzMzA2LAorCQkgLmZsYWdzID0gU1BFQ19ERVZfSURfRElTQUJMRV9IVH0sCiAJey5pZFZlbmRvciA9IDB4MTNEMywgLmlkUHJvZHVjdCA9IDB4MzMxMSwKIAkJIC5mbGFncyA9IFNQRUNfREVWX0lEX0RJU0FCTEVfSFR9LAorCXsuaWRWZW5kb3IgPSAweDEzZDMsIC5pZFByb2R1Y3QgPSAweDMzMzUsCisJCSAuZmxhZ3MgPSBTUEVDX0RFVl9JRF9ESVNBQkxFX0hUfSwKKwl7LmlkVmVuZG9yID0gMHgxM2QzLCAuaWRQcm9kdWN0ID0gMHgzMzM2LAorCQkgLmZsYWdzID0gU1BFQ19ERVZfSURfRElTQUJMRV9IVH0sCisJey5pZFZlbmRvciA9IDB4MTNkMywgLmlkUHJvZHVjdCA9IDB4MzM0MCwKKwkJIC5mbGFncyA9IFNQRUNfREVWX0lEX0RJU0FCTEVfSFR9LAorCXsuaWRWZW5kb3IgPSAweDEzZDMsIC5pZFByb2R1Y3QgPSAweDMzNDEsCisJCSAuZmxhZ3MgPSBTUEVDX0RFVl9JRF9ESVNBQkxFX0hUfSwKIAl7fQogfTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3NtN3h4L3NtdGNmYi5jIGIvZHJpdmVycy9zdGFnaW5nL3NtN3h4L3NtdGNmYi5jCmluZGV4IGY0YjE2M2YuLmQwMDdlNGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9zbTd4eC9zbXRjZmIuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvc203eHgvc210Y2ZiLmMKQEAgLTEwNDQsOSArMTA0NCw5IEBACiAKIAkvKiB3aGVuIGRvaW5nIHN1c3BlbmQsIGNhbGwgZmIgYXBpcyBhbmQgcGNpIGFwaXMgKi8KIAlpZiAobXNnLmV2ZW50ID09IFBNX0VWRU5UX1NVU1BFTkQpIHsKLQkJYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX2xvY2soKTsKIAkJZmJfc2V0X3N1c3BlbmQoJnNmYi0+ZmIsIDEpOwotCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfdW5sb2NrKCk7CiAJCXJldHYgPSBwY2lfc2F2ZV9zdGF0ZShwZGV2KTsKIAkJcGNpX2Rpc2FibGVfZGV2aWNlKHBkZXYpOwogCQlyZXR2ID0gcGNpX2Nob29zZV9zdGF0ZShwZGV2LCBtc2cpOwpAQCAtMTA3MSw3ICsxMDcxLDcgQEAKIAkvKiB3aGVuIHJlc3VtaW5nLCByZXN0b3JlIHBjaSBkYXRhIGFuZCBmYiBjdXJzb3IgKi8KIAlpZiAocGRldi0+ZGV2LnBvd2VyLnBvd2VyX3N0YXRlLmV2ZW50ICE9IFBNX0VWRU5UX0ZSRUVaRSkgewogCQlyZXR2ID0gcGNpX3NldF9wb3dlcl9zdGF0ZShwZGV2LCBQQ0lfRDApOwotCQlyZXR2ID0gcGNpX3Jlc3RvcmVfc3RhdGUocGRldik7CisJCXBjaV9yZXN0b3JlX3N0YXRlKHBkZXYpOwogCQlpZiAocGNpX2VuYWJsZV9kZXZpY2UocGRldikpCiAJCQlyZXR1cm4gLTE7CiAJCXBjaV9zZXRfbWFzdGVyKHBkZXYpOwpAQCAtMTEwNSw5ICsxMTA1LDkgQEAKIAogCXNtdGNmYl9zZXRtb2RlKHNmYik7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJZmJfc2V0X3N1c3BlbmQoJnNmYi0+ZmIsIDApOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvc21iZnMvZGlyLmMgYi9kcml2ZXJzL3N0YWdpbmcvc21iZnMvZGlyLmMKaW5kZXggODdhM2E5Yi4uZjIwNGQzMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3NtYmZzL2Rpci5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9zbWJmcy9kaXIuYwpAQCAtMjgzLDcgKzI4Myw3IEBACiAJCXVuc2lnbmVkIGludCwgY29uc3QgY2hhciAqLCBjb25zdCBzdHJ1Y3QgcXN0ciAqKTsKIHN0YXRpYyBpbnQgc21iX2RlbGV0ZV9kZW50cnkoY29uc3Qgc3RydWN0IGRlbnRyeSAqKTsKIAotc3RhdGljIGNvbnN0IHN0cnVjdCBkZW50cnlfb3BlcmF0aW9ucyBzbWJmc19kZW50cnlfb3BlcmF0aW9ucyA9Citjb25zdCBzdHJ1Y3QgZGVudHJ5X29wZXJhdGlvbnMgc21iZnNfZGVudHJ5X29wZXJhdGlvbnMgPQogewogCS5kX3JldmFsaWRhdGUJPSBzbWJfbG9va3VwX3ZhbGlkYXRlLAogCS5kX2hhc2gJCT0gc21iX2hhc2hfZGVudHJ5LApAQCAtMjkxLDcgKzI5MSw3IEBACiAJLmRfZGVsZXRlCT0gc21iX2RlbGV0ZV9kZW50cnksCiB9OwogCi1zdGF0aWMgY29uc3Qgc3RydWN0IGRlbnRyeV9vcGVyYXRpb25zIHNtYmZzX2RlbnRyeV9vcGVyYXRpb25zX2Nhc2UgPQorY29uc3Qgc3RydWN0IGRlbnRyeV9vcGVyYXRpb25zIHNtYmZzX2RlbnRyeV9vcGVyYXRpb25zX2Nhc2UgPQogewogCS5kX3JldmFsaWRhdGUJPSBzbWJfbG9va3VwX3ZhbGlkYXRlLAogCS5kX2RlbGV0ZQk9IHNtYl9kZWxldGVfZGVudHJ5LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3NwZWFrdXAva29iamVjdHMuYyBiL2RyaXZlcnMvc3RhZ2luZy9zcGVha3VwL2tvYmplY3RzLmMKaW5kZXggNDA4YmI5Yi4uMDdhN2Y1NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3NwZWFrdXAva29iamVjdHMuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvc3BlYWt1cC9rb2JqZWN0cy5jCkBAIC0zMzIsNyArMzMyLDcgQEAKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJbGVuID0gc3RybGVuKGJ1Zik7Ci0JaWYgKGxlbiA+IDAgfHwgbGVuIDwgMykgeworCWlmIChsZW4gPiAwICYmIGxlbiA8IDMpIHsKIAkJY2ggPSBidWZbMF07CiAJCWlmIChjaCA9PSAnXG4nKQogCQkJY2ggPSAnMCc7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvc3RlX3JtaTQvc3luYXB0aWNzX2kyY19ybWk0LmMgYi9kcml2ZXJzL3N0YWdpbmcvc3RlX3JtaTQvc3luYXB0aWNzX2kyY19ybWk0LmMKaW5kZXggZThmMDQ3ZS4uODAxODNhNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3N0ZV9ybWk0L3N5bmFwdGljc19pMmNfcm1pNC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9zdGVfcm1pNC9zeW5hcHRpY3NfaTJjX3JtaTQuYwpAQCAtOTg2LDEyICs5ODYsNiBAQAogCWlucHV0X3NldF9hYnNfcGFyYW1zKHJtaTRfZGF0YS0+aW5wdXRfZGV2LCBBQlNfTVRfVE9VQ0hfTUFKT1IsIDAsCiAJCQkJCQlNQVhfVE9VQ0hfTUFKT1IsIDAsIDApOwogCi0JcmV0dmFsID0gaW5wdXRfcmVnaXN0ZXJfZGV2aWNlKHJtaTRfZGF0YS0+aW5wdXRfZGV2KTsKLQlpZiAocmV0dmFsKSB7Ci0JCWRldl9lcnIoJmNsaWVudC0+ZGV2LCAiJXM6aW5wdXQgcmVnaXN0ZXIgZmFpbGVkXG4iLCBfX2Z1bmNfXyk7Ci0JCWdvdG8gZXJyX2lucHV0X3JlZ2lzdGVyOwotCX0KLQogCS8qIENsZWFyIGludGVycnVwdHMgKi8KIAlzeW5hcHRpY3Nfcm1pNF9pMmNfYmxvY2tfcmVhZChybWk0X2RhdGEsCiAJCQlybWk0X2RhdGEtPmZuMDFfZGF0YV9iYXNlX2FkZHIgKyAxLCBpbnRyX3N0YXR1cywKQEAgLTEwMDMsMTUgKzk5NywyMCBAQAogCWlmIChyZXR2YWwpIHsKIAkJZGV2X2VycigmY2xpZW50LT5kZXYsICIlczpVbmFibGUgdG8gZ2V0IGF0dG4gaXJxICVkXG4iLAogCQkJCV9fZnVuY19fLCBwbGF0Zm9ybWRhdGEtPmlycV9udW1iZXIpOwotCQlnb3RvIGVycl9yZXF1ZXN0X2lycTsKKwkJZ290byBlcnJfdW5zZXRfY2xpZW50ZGF0YTsKKwl9CisKKwlyZXR2YWwgPSBpbnB1dF9yZWdpc3Rlcl9kZXZpY2Uocm1pNF9kYXRhLT5pbnB1dF9kZXYpOworCWlmIChyZXR2YWwpIHsKKwkJZGV2X2VycigmY2xpZW50LT5kZXYsICIlczppbnB1dCByZWdpc3RlciBmYWlsZWRcbiIsIF9fZnVuY19fKTsKKwkJZ290byBlcnJfZnJlZV9pcnE7CiAJfQogCiAJcmV0dXJuIHJldHZhbDsKIAotZXJyX3JlcXVlc3RfaXJxOgorZXJyX2ZyZWVfaXJxOgogCWZyZWVfaXJxKHBsYXRmb3JtZGF0YS0+aXJxX251bWJlciwgcm1pNF9kYXRhKTsKLQlpbnB1dF91bnJlZ2lzdGVyX2RldmljZShybWk0X2RhdGEtPmlucHV0X2Rldik7Ci1lcnJfaW5wdXRfcmVnaXN0ZXI6CitlcnJfdW5zZXRfY2xpZW50ZGF0YToKIAlpMmNfc2V0X2NsaWVudGRhdGEoY2xpZW50LCBOVUxMKTsKIGVycl9xdWVyeV9kZXY6CiAJaWYgKHBsYXRmb3JtZGF0YS0+cmVndWxhdG9yX2VuKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvY29yZS9pb19zbS5jIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2NvcmUvaW9fc20uYwppbmRleCA1NzE4NjQ1Li4yN2UwYWE4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvY29yZS9pb19zbS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9jb3JlL2lvX3NtLmMKQEAgLTk0OSw3ICs5NDksNyBAQAogICogICAgICBDYWxscyB0aGUgQnJpZGdlJ3MgQ0hOTF9JU1IgdG8gZGV0ZXJtaW5lIGlmIHRoaXMgaW50ZXJydXB0IGlzIG91cnMsIHRoZW4KICAqICAgICAgc2NoZWR1bGVzIGEgRFBDIHRvIGRpc3BhdGNoIEkvTy4KICAqLwotdm9pZCBpb19tYm94X21zZyh1MzIgbXNnKQoraW50IGlvX21ib3hfbXNnKHN0cnVjdCBub3RpZmllcl9ibG9jayAqc2VsZiwgdW5zaWduZWQgbG9uZyBsZW4sIHZvaWQgKm1zZykKIHsKIAlzdHJ1Y3QgaW9fbWdyICpwaW9fbWdyOwogCXN0cnVjdCBkZXZfb2JqZWN0ICpkZXZfb2JqOwpAQCAtOTU5LDkgKzk1OSw5IEBACiAJZGV2X2dldF9pb19tZ3IoZGV2X29iaiwgJnBpb19tZ3IpOwogCiAJaWYgKCFwaW9fbWdyKQotCQlyZXR1cm47CisJCXJldHVybiBOT1RJRllfQkFEOwogCi0JcGlvX21nci0+aW50cl92YWwgPSAodTE2KW1zZzsKKwlwaW9fbWdyLT5pbnRyX3ZhbCA9ICh1MTYpKCh1MzIpbXNnKTsKIAlpZiAocGlvX21nci0+aW50cl92YWwgJiBNQlhfUE1fQ0xBU1MpCiAJCWlvX2Rpc3BhdGNoX3BtKHBpb19tZ3IpOwogCkBAIC05NzMsNyArOTczLDcgQEAKIAkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcGlvX21nci0+ZHBjX2xvY2ssIGZsYWdzKTsKIAkJdGFza2xldF9zY2hlZHVsZSgmcGlvX21nci0+ZHBjX3Rhc2tsZXQpOwogCX0KLQlyZXR1cm47CisJcmV0dXJuIE5PVElGWV9PSzsKIH0KIAogLyoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9jb3JlL3Rpb21hcDM0MzAuYyBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9jb3JlL3Rpb21hcDM0MzAuYwppbmRleCBhM2IwYTE4Li5hM2Y2OWY2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvY29yZS90aW9tYXAzNDMwLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3RpZHNwYnJpZGdlL2NvcmUvdGlvbWFwMzQzMC5jCkBAIC0yMjMsNiArMjIzLDEwIEBACiAJYnJpZGdlX21zZ19zZXRfcXVldWVfaWQsCiB9OwogCitzdGF0aWMgc3RydWN0IG5vdGlmaWVyX2Jsb2NrIGRzcF9tYm94X25vdGlmaWVyID0geworCS5ub3RpZmllcl9jYWxsID0gaW9fbWJveF9tc2csCit9OworCiBzdGF0aWMgaW5saW5lIHZvaWQgZmx1c2hfYWxsKHN0cnVjdCBicmlkZ2VfZGV2X2NvbnRleHQgKmRldl9jb250ZXh0KQogewogCWlmIChkZXZfY29udGV4dC0+ZHdfYnJkX3N0YXRlID09IEJSRF9EU1BfSElCRVJOQVRJT04gfHwKQEAgLTU1Myw3ICs1NTcsNyBAQAogCQkgKiBFbmFibGUgTWFpbGJveCBldmVudHMgYW5kIGFsc28gZHJhaW4gYW55IHBlbmRpbmcKIAkJICogc3RhbGUgbWVzc2FnZXMuCiAJCSAqLwotCQlkZXZfY29udGV4dC0+bWJveCA9IG9tYXBfbWJveF9nZXQoImRzcCIpOworCQlkZXZfY29udGV4dC0+bWJveCA9IG9tYXBfbWJveF9nZXQoImRzcCIsICZkc3BfbWJveF9ub3RpZmllcik7CiAJCWlmIChJU19FUlIoZGV2X2NvbnRleHQtPm1ib3gpKSB7CiAJCQlkZXZfY29udGV4dC0+bWJveCA9IE5VTEw7CiAJCQlwcl9lcnIoIiVzOiBGYWlsZWQgdG8gZ2V0IGRzcCBtYWlsYm94IGhhbmRsZVxuIiwKQEAgLTU2Myw4ICs1NjcsNiBAQAogCiAJfQogCWlmICghc3RhdHVzKSB7Ci0JCWRldl9jb250ZXh0LT5tYm94LT5yeHEtPmNhbGxiYWNrID0gKGludCAoKikodm9pZCAqKSlpb19tYm94X21zZzsKLQogLypQTV9JVkEyR1JQU0VMX1BFUiA9IDB4QzA7Ki8KIAkJdGVtcCA9IHJlYWRsKHJlc291cmNlcy0+ZHdfcGVyX3BtX2Jhc2UgKyAweEE4KTsKIAkJdGVtcCA9ICh0ZW1wICYgMHhGRkZGRkYzMCkgfCAweEMwOwpAQCAtNjg1LDcgKzY4Nyw3IEBACiAJLyogRGlzYWJsZSB0aGUgbWFpbGJveCBpbnRlcnJ1cHRzICovCiAJaWYgKGRldl9jb250ZXh0LT5tYm94KSB7CiAJCW9tYXBfbWJveF9kaXNhYmxlX2lycShkZXZfY29udGV4dC0+bWJveCwgSVJRX1JYKTsKLQkJb21hcF9tYm94X3B1dChkZXZfY29udGV4dC0+bWJveCk7CisJCW9tYXBfbWJveF9wdXQoZGV2X2NvbnRleHQtPm1ib3gsICZkc3BfbWJveF9ub3RpZmllcik7CiAJCWRldl9jb250ZXh0LT5tYm94ID0gTlVMTDsKIAl9CiAJLyogUmVzZXQgSVZBMiBjbG9ja3MqLwpAQCAtNzg2LDEwICs3ODgsNyBAQAogCiAJcHRfYXR0cnMgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgcGdfdGFibGVfYXR0cnMpLCBHRlBfS0VSTkVMKTsKIAlpZiAocHRfYXR0cnMgIT0gTlVMTCkgewotCQkvKiBBc3N1bWluZyB0aGF0IHdlIHVzZSBvbmx5IERTUCdzIG1lbW9yeSBtYXAKLQkJICogdW50aWwgMHg0MDAwOjAwMDAgLCB3ZSB3b3VsZCBuZWVkIG9ubHkgMTAyNAotCQkgKiBMMSBlbnRpZXMgaS5lIEwxIHNpemUgPSA0SyAqLwotCQlwdF9hdHRycy0+bDFfc2l6ZSA9IDB4MTAwMDsKKwkJcHRfYXR0cnMtPmwxX3NpemUgPSBTWl8xNks7IC8qIDQwOTYgZW50cmllcyBvZiAzMiBiaXRzICovCiAJCWFsaWduX3NpemUgPSBwdF9hdHRycy0+bDFfc2l6ZTsKIAkJLyogQWxpZ24gc2l6ZXMgYXJlIGV4cGVjdGVkIHRvIGJlIHBvd2VyIG9mIDIgKi8KIAkJLyogd2UgbGlrZSB0byBnZXQgYWxpZ25lZCBvbiBMMSB0YWJsZSBzaXplICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdGlkc3BicmlkZ2UvaW5jbHVkZS9kc3BicmlkZ2UvaW9fc20uaCBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9pb19zbS5oCmluZGV4IDE4YWVjNTUuLjgyNDJjNzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9pb19zbS5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy90aWRzcGJyaWRnZS9pbmNsdWRlL2RzcGJyaWRnZS9pb19zbS5oCkBAIC03MiwyMiArNzIsMTcgQEAKIC8qCiAgKiAgPT09PT09PT0gaW9fbWJveF9tc2cgPT09PT09PT0KICAqICBQdXJwb3NlOgotICogICAgICBNYWluIGludGVycnVwdCBoYW5kbGVyIGZvciB0aGUgc2hhcmVkIG1lbW9yeSBCcmlkZ2UgY2hhbm5lbCBtYW5hZ2VyLgotICogICAgICBDYWxscyB0aGUgQnJpZGdlJ3MgY2hubHNtX2lzciB0byBkZXRlcm1pbmUgaWYgdGhpcyBpbnRlcnJ1cHQgaXMgb3VycywKLSAqICAgICAgdGhlbiBzY2hlZHVsZXMgYSBEUEMgdG8gZGlzcGF0Y2ggSS9PLgorICoJTWFpbiBtZXNzYWdlIGhhbmRsZXIgZm9yIHRoZSBzaGFyZWQgbWVtb3J5IEJyaWRnZSBjaGFubmVsIG1hbmFnZXIuCisgKglEZXRlcm1pbmUgaWYgdGhpcyBtZXNzYWdlIGlzIG91cnMsIHRoZW4gc2NoZWR1bGVzIGEgRFBDIHRvCisgKglkaXNwYXRjaCBJL08uCiAgKiAgUGFyYW1ldGVyczoKLSAqICAgICAgcmVmX2RhdGE6ICAgUG9pbnRlciB0byB0aGUgY2hhbm5lbCBtYW5hZ2VyIG9iamVjdCBmb3IgdGhpcyBib2FyZC4KLSAqICAgICAgICAgICAgICAgICAgU2V0IGluIGFuIGluaXRpYWwgY2FsbCB0byBJU1JfSW5zdGFsbCgpLgorICoJc2VsZjoJUG9pbnRlciB0byBpdHMgb3duIG5vdGlmaWVyX2Jsb2NrIHN0cnVjdC4KKyAqCWxlbjoJTGVuZ3RoIG9mIG1lc3NhZ2UuCisgKgltc2c6CU1lc3NhZ2UgY29kZSByZWNlaXZlZC4KICAqICBSZXR1cm5zOgotICogICAgICBUUlVFIGlmIGludGVycnVwdCBoYW5kbGVkOyBGQUxTRSBvdGhlcndpc2UuCi0gKiAgUmVxdWlyZXM6Ci0gKiAgICAgIE11c3QgYmUgaW4gbG9ja2VkIG1lbW9yeSBpZiBleGVjdXRpbmcgaW4ga2VybmVsIG1vZGUuCi0gKiAgICAgIE11c3Qgb25seSBjYWxsIGZ1bmN0aW9ucyB3aGljaCBhcmUgaW4gbG9ja2VkIG1lbW9yeSBpZiBLZXJuZWwgbW9kZS4KLSAqICAgICAgTXVzdCBvbmx5IGNhbGwgYXN5bmNocm9ub3VzIHNlcnZpY2VzLgotICogICAgICBJbnRlcnJ1cHRzIGFyZSBkaXNhYmxlZCBhbmQgRU9JIGZvciB0aGlzIGludGVycnVwdCBoYXMgYmVlbiBzZW50LgotICogIEVuc3VyZXM6CisgKglOT1RJRllfT0sgaWYgaGFuZGxlZDsgTk9USUZZX0JBRCBvdGhlcndpc2UuCiAgKi8KLXZvaWQgaW9fbWJveF9tc2codTMyIG1zZyk7CitpbnQgaW9fbWJveF9tc2coc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpzZWxmLCB1bnNpZ25lZCBsb25nIGxlbiwgdm9pZCAqbXNnKTsKIAogLyoKICAqICA9PT09PT09PSBpb19yZXF1ZXN0X2NobmwgPT09PT09PT0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy90bTYwMDAvdG02MDAwLXZpZGVvLmMgYi9kcml2ZXJzL3N0YWdpbmcvdG02MDAwL3RtNjAwMC12aWRlby5jCmluZGV4IDhmZTAxN2MuLmViOWI5ZjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy90bTYwMDAvdG02MDAwLXZpZGVvLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3RtNjAwMC90bTYwMDAtdmlkZW8uYwpAQCAtMTQ1MCwyOSArMTQ1MCw1NSBAQAogICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKi8KIAotaW50IHRtNjAwMF92NGwyX3JlZ2lzdGVyKHN0cnVjdCB0bTYwMDBfY29yZSAqZGV2KQorc3RhdGljIHN0cnVjdCB2aWRlb19kZXZpY2UgKnZkZXZfaW5pdChzdHJ1Y3QgdG02MDAwX2NvcmUgKmRldiwKKwkJY29uc3Qgc3RydWN0IHZpZGVvX2RldmljZQorCQkqdGVtcGxhdGUsIGNvbnN0IGNoYXIgKnR5cGVfbmFtZSkKIHsKLQlpbnQgcmV0ID0gLTE7CiAJc3RydWN0IHZpZGVvX2RldmljZSAqdmZkOwogCiAJdmZkID0gdmlkZW9fZGV2aWNlX2FsbG9jKCk7Ci0JaWYoIXZmZCkgeworCWlmIChOVUxMID09IHZmZCkKKwkJcmV0dXJuIE5VTEw7CisKKwkqdmZkID0gKnRlbXBsYXRlOworCXZmZC0+djRsMl9kZXYgPSAmZGV2LT52NGwyX2RldjsKKwl2ZmQtPnJlbGVhc2UgPSB2aWRlb19kZXZpY2VfcmVsZWFzZTsKKwl2ZmQtPmRlYnVnID0gdG02MDAwX2RlYnVnOworCXZmZC0+bG9jayA9ICZkZXYtPmxvY2s7CisKKwlzbnByaW50Zih2ZmQtPm5hbWUsIHNpemVvZih2ZmQtPm5hbWUpLCAiJXMgJXMiLCBkZXYtPm5hbWUsIHR5cGVfbmFtZSk7CisKKwl2aWRlb19zZXRfZHJ2ZGF0YSh2ZmQsIGRldik7CisJcmV0dXJuIHZmZDsKK30KKworaW50IHRtNjAwMF92NGwyX3JlZ2lzdGVyKHN0cnVjdCB0bTYwMDBfY29yZSAqZGV2KQoreworCWludCByZXQgPSAtMTsKKworCWRldi0+dmZkID0gdmRldl9pbml0KGRldiwgJnRtNjAwMF90ZW1wbGF0ZSwgInZpZGVvIik7CisKKwlpZiAoIWRldi0+dmZkKSB7CisJCXByaW50ayhLRVJOX0lORk8gIiVzOiBjYW4ndCByZWdpc3RlciB2aWRlbyBkZXZpY2VcbiIsCisJCSAgICAgICBkZXYtPm5hbWUpOwogCQlyZXR1cm4gLUVOT01FTTsKIAl9Ci0JZGV2LT52ZmQgPSB2ZmQ7CiAKIAkvKiBpbml0IHZpZGVvIGRtYSBxdWV1ZXMgKi8KIAlJTklUX0xJU1RfSEVBRCgmZGV2LT52aWRxLmFjdGl2ZSk7CiAJSU5JVF9MSVNUX0hFQUQoJmRldi0+dmlkcS5xdWV1ZWQpOwogCi0JbWVtY3B5KGRldi0+dmZkLCAmdG02MDAwX3RlbXBsYXRlLCBzaXplb2YoKihkZXYtPnZmZCkpKTsKLQlkZXYtPnZmZC0+ZGVidWcgPSB0bTYwMDBfZGVidWc7Ci0JZGV2LT52ZmQtPmxvY2sgPSAmZGV2LT5sb2NrOwotCi0JdmZkLT52NGwyX2RldiA9ICZkZXYtPnY0bDJfZGV2OwotCXZpZGVvX3NldF9kcnZkYXRhKHZmZCwgZGV2KTsKLQogCXJldCA9IHZpZGVvX3JlZ2lzdGVyX2RldmljZShkZXYtPnZmZCwgVkZMX1RZUEVfR1JBQkJFUiwgdmlkZW9fbnIpOworCisJaWYgKHJldCA8IDApIHsKKwkJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IGNhbid0IHJlZ2lzdGVyIHZpZGVvIGRldmljZVxuIiwKKwkJICAgICAgIGRldi0+bmFtZSk7CisJCXJldHVybiByZXQ7CisJfQorCisJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IHJlZ2lzdGVyZWQgZGV2aWNlICVzXG4iLAorCSAgICAgICBkZXYtPm5hbWUsIHZpZGVvX2RldmljZV9ub2RlX25hbWUoZGV2LT52ZmQpKTsKKwogCXByaW50ayhLRVJOX0lORk8gIlRyaWRlbnQgVFZNYXN0ZXIgVE01NjAwL1RNNjAwMC9UTTYwMTAgVVNCMiBib2FyZCAoTG9hZCBzdGF0dXM6ICVkKVxuIiwgcmV0KTsKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3N0dWIuaCBiL2RyaXZlcnMvc3RhZ2luZy91c2JpcC9zdHViLmgKaW5kZXggMzBkYmZiNi4uZDczMjY3OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3N0dWIuaAorKysgYi9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvc3R1Yi5oCkBAIC0zMiw2ICszMiw3IEBACiAKIHN0cnVjdCBzdHViX2RldmljZSB7CiAJc3RydWN0IHVzYl9pbnRlcmZhY2UgKmludGVyZmFjZTsKKwlzdHJ1Y3QgdXNiX2RldmljZSAqdWRldjsKIAlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7CiAKIAlzdHJ1Y3QgdXNiaXBfZGV2aWNlIHVkOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3N0dWJfZGV2LmMgYi9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvc3R1Yl9kZXYuYwppbmRleCBiMTg2YjVmLi5hN2NlNTFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvc3R1Yl9kZXYuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvc3R1Yl9kZXYuYwpAQCAtMjU4LDEwICsyNTgsMTEgQEAKIHN0YXRpYyB2b2lkIHN0dWJfZGV2aWNlX3Jlc2V0KHN0cnVjdCB1c2JpcF9kZXZpY2UgKnVkKQogewogCXN0cnVjdCBzdHViX2RldmljZSAqc2RldiA9IGNvbnRhaW5lcl9vZih1ZCwgc3RydWN0IHN0dWJfZGV2aWNlLCB1ZCk7Ci0Jc3RydWN0IHVzYl9kZXZpY2UgKnVkZXYgPSBpbnRlcmZhY2VfdG9fdXNiZGV2KHNkZXYtPmludGVyZmFjZSk7CisJc3RydWN0IHVzYl9kZXZpY2UgKnVkZXYgPSBzZGV2LT51ZGV2OwogCWludCByZXQ7CiAKIAl1c2JpcF91ZGJnKCJkZXZpY2UgcmVzZXQiKTsKKwogCXJldCA9IHVzYl9sb2NrX2RldmljZV9mb3JfcmVzZXQodWRldiwgc2Rldi0+aW50ZXJmYWNlKTsKIAlpZiAocmV0IDwgMCkgewogCQlkZXZfZXJyKCZ1ZGV2LT5kZXYsICJsb2NrIGZvciByZXNldFxuIik7CkBAIC0zMDksNyArMzEwLDggQEAKICAqCiAgKiBBbGxvY2F0ZXMgYW5kIGluaXRpYWxpemVzIGEgbmV3IHN0dWJfZGV2aWNlIHN0cnVjdC4KICAqLwotc3RhdGljIHN0cnVjdCBzdHViX2RldmljZSAqc3R1Yl9kZXZpY2VfYWxsb2Moc3RydWN0IHVzYl9pbnRlcmZhY2UgKmludGVyZmFjZSkKK3N0YXRpYyBzdHJ1Y3Qgc3R1Yl9kZXZpY2UgKnN0dWJfZGV2aWNlX2FsbG9jKHN0cnVjdCB1c2JfZGV2aWNlICp1ZGV2LAorCQkJCQkgICAgIHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRlcmZhY2UpCiB7CiAJc3RydWN0IHN0dWJfZGV2aWNlICpzZGV2OwogCWludCBidXNudW0gPSBpbnRlcmZhY2VfdG9fYnVzbnVtKGludGVyZmFjZSk7CkBAIC0zMjQsNyArMzI2LDggQEAKIAkJcmV0dXJuIE5VTEw7CiAJfQogCi0Jc2Rldi0+aW50ZXJmYWNlID0gaW50ZXJmYWNlOworCXNkZXYtPmludGVyZmFjZSA9IHVzYl9nZXRfaW50ZihpbnRlcmZhY2UpOworCXNkZXYtPnVkZXYgPSB1c2JfZ2V0X2Rldih1ZGV2KTsKIAogCS8qCiAJICogZGV2aWQgaXMgZGVmaW5lZCB3aXRoIGRldm51bSB3aGVuIHRoaXMgZHJpdmVyIGlzIGZpcnN0IGFsbG9jYXRlZC4KQEAgLTQ1MCwxMSArNDUzLDEyIEBACiAJCQlyZXR1cm4gZXJyOwogCQl9CiAKKwkJdXNiX2dldF9pbnRmKGludGVyZmFjZSk7CiAJCXJldHVybiAwOwogCX0KIAogCS8qIG9rLiB0aGlzIGlzIG15IGRldmljZS4gKi8KLQlzZGV2ID0gc3R1Yl9kZXZpY2VfYWxsb2MoaW50ZXJmYWNlKTsKKwlzZGV2ID0gc3R1Yl9kZXZpY2VfYWxsb2ModWRldiwgaW50ZXJmYWNlKTsKIAlpZiAoIXNkZXYpCiAJCXJldHVybiAtRU5PTUVNOwogCkBAIC00NzYsNiArNDgwLDggQEAKIAkJZGV2X2VycigmaW50ZXJmYWNlLT5kZXYsICJjcmVhdGUgc3lzZnMgZmlsZXMgZm9yICVzXG4iLAogCQkJdWRldl9idXNpZCk7CiAJCXVzYl9zZXRfaW50ZmRhdGEoaW50ZXJmYWNlLCBOVUxMKTsKKwkJdXNiX3B1dF9pbnRmKGludGVyZmFjZSk7CisKIAkJYnVzaWRfcHJpdi0+aW50ZXJmX2NvdW50ID0gMDsKIAogCQlidXNpZF9wcml2LT5zZGV2ID0gTlVMTDsKQEAgLTU0NSw2ICs1NTEsNyBAQAogCWlmIChidXNpZF9wcml2LT5pbnRlcmZfY291bnQgPiAxKSB7CiAJCWJ1c2lkX3ByaXYtPmludGVyZl9jb3VudC0tOwogCQlzaHV0ZG93bl9idXNpZChidXNpZF9wcml2KTsKKwkJdXNiX3B1dF9pbnRmKGludGVyZmFjZSk7CiAJCXJldHVybjsKIAl9CiAKQEAgLTU1NCw2ICs1NjEsOSBAQAogCS8qIDEuIHNodXRkb3duIHRoZSBjdXJyZW50IGNvbm5lY3Rpb24gKi8KIAlzaHV0ZG93bl9idXNpZChidXNpZF9wcml2KTsKIAorCXVzYl9wdXRfZGV2KHNkZXYtPnVkZXYpOworCXVzYl9wdXRfaW50ZihpbnRlcmZhY2UpOworCiAJLyogMy4gZnJlZSBzZGV2ICovCiAJYnVzaWRfcHJpdi0+c2RldiA9IE5VTEw7CiAJc3R1Yl9kZXZpY2VfZnJlZShzZGV2KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy91c2JpcC9zdHViX3J4LmMgYi9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvc3R1Yl9yeC5jCmluZGV4IDNkZTZmZDIuLmFlNmFjODIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy91c2JpcC9zdHViX3J4LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3N0dWJfcnguYwpAQCAtMzY0LDcgKzM2NCw3IEBACiAKIHN0YXRpYyBpbnQgZ2V0X3BpcGUoc3RydWN0IHN0dWJfZGV2aWNlICpzZGV2LCBpbnQgZXBudW0sIGludCBkaXIpCiB7Ci0Jc3RydWN0IHVzYl9kZXZpY2UgKnVkZXYgPSBpbnRlcmZhY2VfdG9fdXNiZGV2KHNkZXYtPmludGVyZmFjZSk7CisJc3RydWN0IHVzYl9kZXZpY2UgKnVkZXYgPSBzZGV2LT51ZGV2OwogCXN0cnVjdCB1c2JfaG9zdF9lbmRwb2ludCAqZXA7CiAJc3RydWN0IHVzYl9lbmRwb2ludF9kZXNjcmlwdG9yICplcGQgPSBOVUxMOwogCkBAIC00ODQsNyArNDg0LDcgQEAKIAlpbnQgcmV0OwogCXN0cnVjdCBzdHViX3ByaXYgKnByaXY7CiAJc3RydWN0IHVzYmlwX2RldmljZSAqdWQgPSAmc2Rldi0+dWQ7Ci0Jc3RydWN0IHVzYl9kZXZpY2UgKnVkZXYgPSBpbnRlcmZhY2VfdG9fdXNiZGV2KHNkZXYtPmludGVyZmFjZSk7CisJc3RydWN0IHVzYl9kZXZpY2UgKnVkZXYgPSBzZGV2LT51ZGV2OwogCWludCBwaXBlID0gZ2V0X3BpcGUoc2RldiwgcGR1LT5iYXNlLmVwLCBwZHUtPmJhc2UuZGlyZWN0aW9uKTsKIAogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvdmhjaS5oIGIvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3ZoY2kuaAppbmRleCA0MWExZmU1Li5hZmMzYjFhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvdmhjaS5oCisrKyBiL2RyaXZlcnMvc3RhZ2luZy91c2JpcC92aGNpLmgKQEAgLTEwMCw5ICsxMDAsNiBAQAogCSAqIEJ1dCwgdGhlIGluZGV4IG9mIHRoaXMgYXJyYXkgYmVnaW5zIGZyb20gMC4KIAkgKi8KIAlzdHJ1Y3QgdmhjaV9kZXZpY2UgdmRldltWSENJX05QT1JUU107Ci0KLQkvKiB2aGNpX2RldmljZSB3aGljaCBoYXMgbm90IGJlZW4gYXNzaWdlZCBpdHMgYWRkcmVzcyB5ZXQgKi8KLQlpbnQgcGVuZGluZ19wb3J0OwogfTsKIAogCkBAIC0xMTksNiArMTE2LDkgQEAKIHZvaWQgdmhjaV9yeF9sb29wKHN0cnVjdCB1c2JpcF90YXNrICp1dCk7CiB2b2lkIHZoY2lfdHhfbG9vcChzdHJ1Y3QgdXNiaXBfdGFzayAqdXQpOwogCitzdHJ1Y3QgdXJiICpwaWNrdXBfdXJiX2FuZF9mcmVlX3ByaXYoc3RydWN0IHZoY2lfZGV2aWNlICp2ZGV2LAorCQkJCQkgICAgX191MzIgc2VxbnVtKTsKKwogI2RlZmluZSBoYXJkd2FyZQkJKCZ0aGVfY29udHJvbGxlci0+cGRldi5kZXYpCiAKIHN0YXRpYyBpbmxpbmUgc3RydWN0IHZoY2lfZGV2aWNlICpwb3J0X3RvX3ZkZXYoX191MzIgcG9ydCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy91c2JpcC92aGNpX2hjZC5jIGIvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3ZoY2lfaGNkLmMKaW5kZXggMDhiZDI2YS4uYTM1ZmU2MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3ZoY2lfaGNkLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3ZoY2lfaGNkLmMKQEAgLTEzOCw4ICsxMzgsNiBAQAogCSAqIHRoZV9jb250cm9sbGVyLT52ZGV2W3JocG9ydF0udWQuc3RhdHVzID0gVkRFVl9DT05ORUNUOwogCSAqIHNwaW5fdW5sb2NrKCZ0aGVfY29udHJvbGxlci0+dmRldltyaHBvcnRdLnVkLmxvY2spOyAqLwogCi0JdGhlX2NvbnRyb2xsZXItPnBlbmRpbmdfcG9ydCA9IHJocG9ydDsKLQogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnRoZV9jb250cm9sbGVyLT5sb2NrLCBmbGFncyk7CiAKIAl1c2JfaGNkX3BvbGxfcmhfc3RhdHVzKHZoY2lfdG9faGNkKHRoZV9jb250cm9sbGVyKSk7CkBAIC01NTksNiArNTU3LDcgQEAKIAlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmdXJiLT5kZXYtPmRldjsKIAlpbnQgcmV0ID0gMDsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOworCXN0cnVjdCB2aGNpX2RldmljZSAqdmRldjsKIAogCXVzYmlwX2RiZ192aGNpX2hjKCJlbnRlciwgdXNiX2hjZCAlcCB1cmIgJXAgbWVtX2ZsYWdzICVkXG4iLAogCQkgICAgaGNkLCB1cmIsIG1lbV9mbGFncyk7CkBAIC01NzQsNiArNTczLDE4IEBACiAJCXJldHVybiB1cmItPnN0YXR1czsKIAl9CiAKKwl2ZGV2ID0gcG9ydF90b192ZGV2KHVyYi0+ZGV2LT5wb3J0bnVtLTEpOworCisJLyogcmVmdXNlIGVucXVldWUgZm9yIGRlYWQgY29ubmVjdGlvbiAqLworCXNwaW5fbG9jaygmdmRldi0+dWQubG9jayk7CisJaWYgKHZkZXYtPnVkLnN0YXR1cyA9PSBWREVWX1NUX05VTEwgfHwgdmRldi0+dWQuc3RhdHVzID09IFZERVZfU1RfRVJST1IpIHsKKwkJdXNiaXBfdWVycigiZW5xdWV1ZSBmb3IgaW5hY3RpdmUgcG9ydCAlZFxuIiwgdmRldi0+cmhwb3J0KTsKKwkJc3Bpbl91bmxvY2soJnZkZXYtPnVkLmxvY2spOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ0aGVfY29udHJvbGxlci0+bG9jaywgZmxhZ3MpOworCQlyZXR1cm4gLUVOT0RFVjsKKwl9CisJc3Bpbl91bmxvY2soJnZkZXYtPnVkLmxvY2spOworCiAJcmV0ID0gdXNiX2hjZF9saW5rX3VyYl90b19lcChoY2QsIHVyYik7CiAJaWYgKHJldCkKIAkJZ290byBub19uZWVkX3VubGluazsKQEAgLTU5Miw4ICs2MDMsNiBAQAogCQlfX3U4IHR5cGUgPSB1c2JfcGlwZXR5cGUodXJiLT5waXBlKTsKIAkJc3RydWN0IHVzYl9jdHJscmVxdWVzdCAqY3RybHJlcSA9CiAJCQkJKHN0cnVjdCB1c2JfY3RybHJlcXVlc3QgKikgdXJiLT5zZXR1cF9wYWNrZXQ7Ci0JCXN0cnVjdCB2aGNpX2RldmljZSAqdmRldiA9Ci0JCQkJcG9ydF90b192ZGV2KHRoZV9jb250cm9sbGVyLT5wZW5kaW5nX3BvcnQpOwogCiAJCWlmICh0eXBlICE9IFBJUEVfQ09OVFJPTCB8fCAhY3RybHJlcSkgewogCQkJZGV2X2VycihkZXYsICJpbnZhbGlkIHJlcXVlc3QgdG8gZGV2bnVtIDBcbiIpOwpAQCAtNjA3LDcgKzYxNiw5IEBACiAJCQlkZXZfaW5mbyhkZXYsICJTZXRBZGRyZXNzIFJlcXVlc3QgKCVkKSB0byBwb3J0ICVkXG4iLAogCQkJCSBjdHJscmVxLT53VmFsdWUsIHZkZXYtPnJocG9ydCk7CiAKLQkJCXZkZXYtPnVkZXYgPSB1cmItPmRldjsKKwkJCWlmICh2ZGV2LT51ZGV2KQorCQkJCXVzYl9wdXRfZGV2KHZkZXYtPnVkZXYpOworCQkJdmRldi0+dWRldiA9IHVzYl9nZXRfZGV2KHVyYi0+ZGV2KTsKIAogCQkJc3Bpbl9sb2NrKCZ2ZGV2LT51ZC5sb2NrKTsKIAkJCXZkZXYtPnVkLnN0YXR1cyA9IFZERVZfU1RfVVNFRDsKQEAgLTYyNyw4ICs2MzgsOSBAQAogCQkJCQkJIkdldF9EZXNjcmlwdG9yIHRvIGRldmljZSAwICIKIAkJCQkJCSIoZ2V0IG1heCBwaXBlIHNpemUpXG4iKTsKIAotCQkJLyogRklYTUU6IHJlZmVyZW5jZSBjb3VudD8gKHVzYl9nZXRfZGV2KCkpICovCi0JCQl2ZGV2LT51ZGV2ID0gdXJiLT5kZXY7CisJCQlpZiAodmRldi0+dWRldikKKwkJCQl1c2JfcHV0X2Rldih2ZGV2LT51ZGV2KTsKKwkJCXZkZXYtPnVkZXYgPSB1c2JfZ2V0X2Rldih1cmItPmRldik7CiAJCQlnb3RvIG91dDsKIAogCQlkZWZhdWx0OgpAQCAtODA1LDcgKzgxNyw2IEBACiAJcmV0dXJuIDA7CiB9CiAKLQogc3RhdGljIHZvaWQgdmhjaV9kZXZpY2VfdW5saW5rX2NsZWFudXAoc3RydWN0IHZoY2lfZGV2aWNlICp2ZGV2KQogewogCXN0cnVjdCB2aGNpX3VubGluayAqdW5saW5rLCAqdG1wOwpAQCAtODEzLDExICs4MjQsMzQgQEAKIAlzcGluX2xvY2soJnZkZXYtPnByaXZfbG9jayk7CiAKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUodW5saW5rLCB0bXAsICZ2ZGV2LT51bmxpbmtfdHgsIGxpc3QpIHsKKwkJdXNiaXBfdWluZm8oInVubGluayBjbGVhbnVwIHR4ICVsdVxuIiwgdW5saW5rLT51bmxpbmtfc2VxbnVtKTsKIAkJbGlzdF9kZWwoJnVubGluay0+bGlzdCk7CiAJCWtmcmVlKHVubGluayk7CiAJfQogCiAJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHVubGluaywgdG1wLCAmdmRldi0+dW5saW5rX3J4LCBsaXN0KSB7CisJCXN0cnVjdCB1cmIgKnVyYjsKKworCQkvKiBnaXZlIGJhY2sgVVJCIG9mIHVuYW5zd2VyZWQgdW5saW5rIHJlcXVlc3QgKi8KKwkJdXNiaXBfdWluZm8oInVubGluayBjbGVhbnVwIHJ4ICVsdVxuIiwgdW5saW5rLT51bmxpbmtfc2VxbnVtKTsKKworCQl1cmIgPSBwaWNrdXBfdXJiX2FuZF9mcmVlX3ByaXYodmRldiwgdW5saW5rLT51bmxpbmtfc2VxbnVtKTsKKwkJaWYgKCF1cmIpIHsKKwkJCXVzYmlwX3VpbmZvKCJ0aGUgdXJiIChzZXFudW0gJWx1KSB3YXMgYWxyZWFkeSBnaXZlbiBiYWNrXG4iLAorCQkJCQkJCXVubGluay0+dW5saW5rX3NlcW51bSk7CisJCQlsaXN0X2RlbCgmdW5saW5rLT5saXN0KTsKKwkJCWtmcmVlKHVubGluayk7CisJCQljb250aW51ZTsKKwkJfQorCisJCXVyYi0+c3RhdHVzID0gLUVOT0RFVjsKKworCQlzcGluX2xvY2soJnRoZV9jb250cm9sbGVyLT5sb2NrKTsKKwkJdXNiX2hjZF91bmxpbmtfdXJiX2Zyb21fZXAodmhjaV90b19oY2QodGhlX2NvbnRyb2xsZXIpLCB1cmIpOworCQlzcGluX3VubG9jaygmdGhlX2NvbnRyb2xsZXItPmxvY2spOworCisJCXVzYl9oY2RfZ2l2ZWJhY2tfdXJiKHZoY2lfdG9faGNkKHRoZV9jb250cm9sbGVyKSwgdXJiLCB1cmItPnN0YXR1cyk7CisKIAkJbGlzdF9kZWwoJnVubGluay0+bGlzdCk7CiAJCWtmcmVlKHVubGluayk7CiAJfQpAQCAtODg3LDYgKzkyMSwxMCBAQAogCXZkZXYtPnNwZWVkICA9IDA7CiAJdmRldi0+ZGV2aWQgID0gMDsKIAorCWlmICh2ZGV2LT51ZGV2KQorCQl1c2JfcHV0X2Rldih2ZGV2LT51ZGV2KTsKKwl2ZGV2LT51ZGV2ID0gTlVMTDsKKwogCXVkLT50Y3Bfc29ja2V0ID0gTlVMTDsKIAogCXVkLT5zdGF0dXMgPSBWREVWX1NUX05VTEw7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvdmhjaV9yeC5jIGIvZHJpdmVycy9zdGFnaW5nL3VzYmlwL3ZoY2lfcnguYwppbmRleCA4MTQ3ZDcyLi5iZjY5OTE0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdXNiaXAvdmhjaV9yeC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy91c2JpcC92aGNpX3J4LmMKQEAgLTIzLDE2ICsyMywxNCBAQAogI2luY2x1ZGUgInZoY2kuaCIKIAogCi0vKiBnZXQgVVJCIGZyb20gdHJhbnNtaXR0ZWQgdXJiIHF1ZXVlICovCi1zdGF0aWMgc3RydWN0IHVyYiAqcGlja3VwX3VyYl9hbmRfZnJlZV9wcml2KHN0cnVjdCB2aGNpX2RldmljZSAqdmRldiwKKy8qIGdldCBVUkIgZnJvbSB0cmFuc21pdHRlZCB1cmIgcXVldWUuIGNhbGxlciBtdXN0IGhvbGQgdmRldi0+cHJpdl9sb2NrICovCitzdHJ1Y3QgdXJiICpwaWNrdXBfdXJiX2FuZF9mcmVlX3ByaXYoc3RydWN0IHZoY2lfZGV2aWNlICp2ZGV2LAogCQkJCQkgICAgX191MzIgc2VxbnVtKQogewogCXN0cnVjdCB2aGNpX3ByaXYgKnByaXYsICp0bXA7CiAJc3RydWN0IHVyYiAqdXJiID0gTlVMTDsKIAlpbnQgc3RhdHVzOwogCi0Jc3Bpbl9sb2NrKCZ2ZGV2LT5wcml2X2xvY2spOwotCiAJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHByaXYsIHRtcCwgJnZkZXYtPnByaXZfcngsIGxpc3QpIHsKIAkJaWYgKHByaXYtPnNlcW51bSA9PSBzZXFudW0pIHsKIAkJCXVyYiA9IHByaXYtPnVyYjsKQEAgLTYzLDggKzYxLDYgQEAKIAkJfQogCX0KIAotCXNwaW5fdW5sb2NrKCZ2ZGV2LT5wcml2X2xvY2spOwotCiAJcmV0dXJuIHVyYjsKIH0KIApAQCAtNzQsOSArNzAsMTEgQEAKIAlzdHJ1Y3QgdXNiaXBfZGV2aWNlICp1ZCA9ICZ2ZGV2LT51ZDsKIAlzdHJ1Y3QgdXJiICp1cmI7CiAKKwlzcGluX2xvY2soJnZkZXYtPnByaXZfbG9jayk7CiAKIAl1cmIgPSBwaWNrdXBfdXJiX2FuZF9mcmVlX3ByaXYodmRldiwgcGR1LT5iYXNlLnNlcW51bSk7CiAKKwlzcGluX3VubG9jaygmdmRldi0+cHJpdl9sb2NrKTsKIAogCWlmICghdXJiKSB7CiAJCXVzYmlwX3VlcnIoImNhbm5vdCBmaW5kIGEgdXJiIG9mIHNlcW51bSAldVxuIiwKQEAgLTE2MSw3ICsxNTksMTIgQEAKIAkJcmV0dXJuOwogCX0KIAorCXNwaW5fbG9jaygmdmRldi0+cHJpdl9sb2NrKTsKKwogCXVyYiA9IHBpY2t1cF91cmJfYW5kX2ZyZWVfcHJpdih2ZGV2LCB1bmxpbmstPnVubGlua19zZXFudW0pOworCisJc3Bpbl91bmxvY2soJnZkZXYtPnByaXZfbG9jayk7CisKIAlpZiAoIXVyYikgewogCQkvKgogCQkgKiBJIGdldCB0aGUgcmVzdWx0IG9mIGEgdW5saW5rIHJlcXVlc3QuIEJ1dCwgaXQgc2VlbXMgdGhhdCBJCkBAIC0xOTAsNiArMTkzLDE5IEBACiAJcmV0dXJuOwogfQogCitzdGF0aWMgaW50IHZoY2lfcHJpdl90eF9lbXB0eShzdHJ1Y3QgdmhjaV9kZXZpY2UgKnZkZXYpCit7CisJaW50IGVtcHR5ID0gMDsKKworCXNwaW5fbG9jaygmdmRldi0+cHJpdl9sb2NrKTsKKworCWVtcHR5ID0gbGlzdF9lbXB0eSgmdmRldi0+cHJpdl9yeCk7CisKKwlzcGluX3VubG9jaygmdmRldi0+cHJpdl9sb2NrKTsKKworCXJldHVybiBlbXB0eTsKK30KKwogLyogcmVjdiBhIHBkdSAqLwogc3RhdGljIHZvaWQgdmhjaV9yeF9wZHUoc3RydWN0IHVzYmlwX2RldmljZSAqdWQpCiB7CkBAIC0yMDIsMTEgKzIxOCwyOSBAQAogCiAJbWVtc2V0KCZwZHUsIDAsIHNpemVvZihwZHUpKTsKIAotCiAJLyogMS4gcmVjZWl2ZSBhIHBkdSBoZWFkZXIgKi8KIAlyZXQgPSB1c2JpcF94bWl0KDAsIHVkLT50Y3Bfc29ja2V0LCAoY2hhciAqKSAmcGR1LCBzaXplb2YocGR1KSwgMCk7CisJaWYgKHJldCA8IDApIHsKKwkJaWYgKHJldCA9PSAtRUNPTk5SRVNFVCkKKwkJCXVzYmlwX3VpbmZvKCJjb25uZWN0aW9uIHJlc2V0IGJ5IHBlZXJcbiIpOworCQllbHNlIGlmIChyZXQgPT0gLUVBR0FJTikgeworCQkJLyogaWdub3JlIGlmIGNvbm5lY3Rpb24gd2FzIGlkbGUgKi8KKwkJCWlmICh2aGNpX3ByaXZfdHhfZW1wdHkodmRldikpCisJCQkJcmV0dXJuOworCQkJdXNiaXBfdWluZm8oImNvbm5lY3Rpb24gdGltZWQgb3V0IHdpdGggcGVuZGluZyB1cmJzXG4iKTsKKwkJfSBlbHNlIGlmIChyZXQgIT0gLUVSRVNUQVJUU1lTKQorCQkJdXNiaXBfdWluZm8oInhtaXQgZmFpbGVkICVkXG4iLCByZXQpOworCisJCXVzYmlwX2V2ZW50X2FkZCh1ZCwgVkRFVl9FVkVOVF9FUlJPUl9UQ1ApOworCQlyZXR1cm47CisJfQorCWlmIChyZXQgPT0gMCkgeworCQl1c2JpcF91aW5mbygiY29ubmVjdGlvbiBjbG9zZWQiKTsKKwkJdXNiaXBfZXZlbnRfYWRkKHVkLCBWREVWX0VWRU5UX0RPV04pOworCQlyZXR1cm47CisJfQogCWlmIChyZXQgIT0gc2l6ZW9mKHBkdSkpIHsKLQkJdXNiaXBfdWVycigicmVjZWl2aW5nIHBkdSBmYWlsZWQhIHNpemUgaXMgJWQsIHNob3VsZCBiZSAlZFxuIiwKKwkJdXNiaXBfdWVycigicmVjZWl2ZWQgcGR1IHNpemUgaXMgJWQsIHNob3VsZCBiZSAlZFxuIiwKIAkJCQkJcmV0LCAodW5zaWduZWQgaW50KXNpemVvZihwZHUpKTsKIAkJdXNiaXBfZXZlbnRfYWRkKHVkLCBWREVWX0VWRU5UX0VSUk9SX1RDUCk7CiAJCXJldHVybjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy92bWUvYnJpZGdlcy9Nb2R1bGUuc3ltdmVycyBiL2RyaXZlcnMvc3RhZ2luZy92bWUvYnJpZGdlcy9Nb2R1bGUuc3ltdmVycwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZTY5ZGUyOS4uMDAwMDAwMAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvdm1lL2JyaWRnZXMvTW9kdWxlLnN5bXZlcnMKKysrIC9kZXYvbnVsbApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3hnaWZiL3ZiX3NldG1vZGUuYyBiL2RyaXZlcnMvc3RhZ2luZy94Z2lmYi92Yl9zZXRtb2RlLmMKaW5kZXggNzAxNmZkZC4uZTE5YjkzMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3hnaWZiL3ZiX3NldG1vZGUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcveGdpZmIvdmJfc2V0bW9kZS5jCkBAIC0zOTU0LDggKzM5NTQsOCBAQAogdW5zaWduZWQgY2hhciBYR0lfSXNMQ0REdWFsTGluayhzdHJ1Y3QgdmJfZGV2aWNlX2luZm8gKnBWQkluZm8pCiB7CiAKLQlpZiAoKCgocFZCSW5mby0+VkJJbmZvICYgU2V0Q1JUMlRvTENEKSB8IFNldENSVDJUb0xDREEpKQotCQkJJiYgKHBWQkluZm8tPkxDREluZm8gJiBTZXRMQ0REdWFsTGluaykpIC8qIHNoYW1wb28wMTI5ICovCisJaWYgKChwVkJJbmZvLT5WQkluZm8gJiAoU2V0Q1JUMlRvTENEIHwgU2V0Q1JUMlRvTENEQSkpICYmCisJCQkocFZCSW5mby0+TENESW5mbyAmIFNldExDRER1YWxMaW5rKSkgLyogc2hhbXBvbzAxMjkgKi8KIAkJcmV0dXJuIDE7CiAKIAlyZXR1cm4gMDsKQEAgLTg3NzMsNyArODc3Myw3IEBACiAKIAlpZiAocFZCSW5mby0+SUZfREVGX0xWRFMgPT0gMCkgewogCQlDUlQySW5kZXggPSBDUlQySW5kZXggPj4gNjsgLyogIGZvciBMQ0QgKi8KLQkJaWYgKCgocFZCSW5mby0+VkJJbmZvICYgU2V0Q1JUMlRvTENEKSB8IFNldENSVDJUb0xDREEpKSB7IC8qMzAxYiovCisJCWlmIChwVkJJbmZvLT5WQkluZm8gJiAoU2V0Q1JUMlRvTENEIHwgU2V0Q1JUMlRvTENEQSkpIHsgLyozMDFiKi8KIAkJCWlmIChwVkJJbmZvLT5MQ0RSZXNJbmZvICE9IFBhbmVsMTAyNHg3NjgpCiAJCQkJVkNMS0luZGV4ID0gTENEWGxhdDJWQ0xLW0NSVDJJbmRleF07CiAJCQllbHNlCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvenJhbS96cmFtX2Rydi5jIGIvZHJpdmVycy9zdGFnaW5nL3pyYW0venJhbV9kcnYuYwppbmRleCA1NDE1NzEyLi40YmQ4Y2JkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvenJhbS96cmFtX2Rydi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy96cmFtL3pyYW1fZHJ2LmMKQEAgLTIyNyw2ICsyMjcsNyBAQAogCiAJCWlmICh6cmFtX3Rlc3RfZmxhZyh6cmFtLCBpbmRleCwgWlJBTV9aRVJPKSkgewogCQkJaGFuZGxlX3plcm9fcGFnZShwYWdlKTsKKwkJCWluZGV4Kys7CiAJCQljb250aW51ZTsKIAkJfQogCkBAIC0yMzUsMTIgKzIzNiwxNCBAQAogCQkJcHJfZGVidWcoIlJlYWQgYmVmb3JlIHdyaXRlOiBzZWN0b3I9JWx1LCBzaXplPSV1IiwKIAkJCQkodWxvbmcpKGJpby0+Ymlfc2VjdG9yKSwgYmlvLT5iaV9zaXplKTsKIAkJCS8qIERvIG5vdGhpbmcgKi8KKwkJCWluZGV4Kys7CiAJCQljb250aW51ZTsKIAkJfQogCiAJCS8qIFBhZ2UgaXMgc3RvcmVkIHVuY29tcHJlc3NlZCBzaW5jZSBpdCdzIGluY29tcHJlc3NpYmxlICovCiAJCWlmICh1bmxpa2VseSh6cmFtX3Rlc3RfZmxhZyh6cmFtLCBpbmRleCwgWlJBTV9VTkNPTVBSRVNTRUQpKSkgewogCQkJaGFuZGxlX3VuY29tcHJlc3NlZF9wYWdlKHpyYW0sIHBhZ2UsIGluZGV4KTsKKwkJCWluZGV4Kys7CiAJCQljb250aW51ZTsKIAkJfQogCkBAIC0zMjAsNiArMzIzLDcgQEAKIAkJCW11dGV4X3VubG9jaygmenJhbS0+bG9jayk7CiAJCQl6cmFtX3N0YXRfaW5jKCZ6cmFtLT5zdGF0cy5wYWdlc196ZXJvKTsKIAkJCXpyYW1fc2V0X2ZsYWcoenJhbSwgaW5kZXgsIFpSQU1fWkVSTyk7CisJCQlpbmRleCsrOwogCQkJY29udGludWU7CiAJCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy90YXJnZXQvS2NvbmZpZyBiL2RyaXZlcnMvdGFyZ2V0L0tjb25maWcKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMmZhYzNiZQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdGFyZ2V0L0tjb25maWcKQEAgLTAsMCArMSwzMiBAQAorCittZW51Y29uZmlnIFRBUkdFVF9DT1JFCisJdHJpc3RhdGUgIkdlbmVyaWMgVGFyZ2V0IENvcmUgTW9kIChUQ00pIGFuZCBDb25maWdGUyBJbmZyYXN0cnVjdHVyZSIKKwlkZXBlbmRzIG9uIFNDU0kgJiYgQkxPQ0sKKwlzZWxlY3QgQ09ORklHRlNfRlMKKwlkZWZhdWx0IG4KKwloZWxwCisJU2F5IFkgb3IgTSBoZXJlIHRvIGVuYWJsZSB0aGUgVENNIFN0b3JhZ2UgRW5naW5lIGFuZCBDb25maWdGUyBlbmFibGVkCisJY29udHJvbCBwYXRoIGZvciB0YXJnZXRfY29yZV9tb2QuICBUaGlzIGluY2x1ZGVzIGJ1aWx0LWluIFRDTSBSQU1ESVNLCisJc3Vic3lzdGVtIGxvZ2ljIGZvciB2aXJ0dWFsIExVTiAwIGFjY2VzcworCitpZiBUQVJHRVRfQ09SRQorCitjb25maWcgVENNX0lCTE9DSworCXRyaXN0YXRlICJUQ00vSUJMT0NLIFN1YnN5c3RlbSBQbHVnaW4gZm9yIExpbnV4L0JMT0NLIgorCWhlbHAKKwlTYXkgWSBoZXJlIHRvIGVuYWJsZSB0aGUgVENNL0lCTE9DSyBzdWJzeXN0ZW0gcGx1Z2luIGZvciBub24tYnVmZmVyZWQKKwlhY2Nlc3MgdG8gTGludXgvQmxvY2sgZGV2aWNlcyB1c2luZyBCSU8KKworY29uZmlnIFRDTV9GSUxFSU8KKwl0cmlzdGF0ZSAiVENNL0ZJTEVJTyBTdWJzeXN0ZW0gUGx1Z2luIGZvciBMaW51eC9WRlMiCisJaGVscAorCVNheSBZIGhlcmUgdG8gZW5hYmxlIHRoZSBUQ00vRklMRUlPIHN1YnN5c3RlbSBwbHVnaW4gZm9yIGJ1ZmZlcmVkCisJYWNjZXNzIHRvIExpbnV4L1ZGUyBzdHJ1Y3QgZmlsZSBvciBzdHJ1Y3QgYmxvY2tfZGV2aWNlCisKK2NvbmZpZyBUQ01fUFNDU0kKKwl0cmlzdGF0ZSAiVENNL3BTQ1NJIFN1YnN5c3RlbSBQbHVnaW4gZm9yIExpbnV4L1NDU0kiCisJaGVscAorCVNheSBZIGhlcmUgdG8gZW5hYmxlIHRoZSBUQ00vcFNDU0kgc3Vic3lzdGVtIHBsdWdpbiBmb3Igbm9uLWJ1ZmZlcmVkCisJcGFzc3Rocm91Z2ggYWNjZXNzIHRvIExpbnV4L1NDU0kgZGV2aWNlCisKK2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC9NYWtlZmlsZSBiL2RyaXZlcnMvdGFyZ2V0L01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjVjZmQ3MDgKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3RhcmdldC9NYWtlZmlsZQpAQCAtMCwwICsxLDI0IEBACitFWFRSQV9DRkxBR1MgKz0gLUkkKHNyY3RyZWUpL2RyaXZlcnMvdGFyZ2V0LyAtSSQoc3JjdHJlZSkvZHJpdmVycy9zY3NpLworCit0YXJnZXRfY29yZV9tb2QteQkJOj0gdGFyZ2V0X2NvcmVfY29uZmlnZnMubyBcCisJCQkJICAgdGFyZ2V0X2NvcmVfZGV2aWNlLm8gXAorCQkJCSAgIHRhcmdldF9jb3JlX2ZhYnJpY19jb25maWdmcy5vIFwKKwkJCQkgICB0YXJnZXRfY29yZV9mYWJyaWNfbGliLm8gXAorCQkJCSAgIHRhcmdldF9jb3JlX2hiYS5vIFwKKwkJCQkgICB0YXJnZXRfY29yZV9wci5vIFwKKwkJCQkgICB0YXJnZXRfY29yZV9hbHVhLm8gXAorCQkJCSAgIHRhcmdldF9jb3JlX3NjZGIubyBcCisJCQkJICAgdGFyZ2V0X2NvcmVfdG1yLm8gXAorCQkJCSAgIHRhcmdldF9jb3JlX3RwZy5vIFwKKwkJCQkgICB0YXJnZXRfY29yZV90cmFuc3BvcnQubyBcCisJCQkJICAgdGFyZ2V0X2NvcmVfY2RiLm8gXAorCQkJCSAgIHRhcmdldF9jb3JlX3VhLm8gXAorCQkJCSAgIHRhcmdldF9jb3JlX3JkLm8gXAorCQkJCSAgIHRhcmdldF9jb3JlX21pYi5vCisKK29iai0kKENPTkZJR19UQVJHRVRfQ09SRSkJKz0gdGFyZ2V0X2NvcmVfbW9kLm8KKworIyBTdWJzeXN0ZW0gbW9kdWxlcworb2JqLSQoQ09ORklHX1RDTV9JQkxPQ0spCSs9IHRhcmdldF9jb3JlX2libG9jay5vCitvYmotJChDT05GSUdfVENNX0ZJTEVJTykJKz0gdGFyZ2V0X2NvcmVfZmlsZS5vCitvYmotJChDT05GSUdfVENNX1BTQ1NJKQkJKz0gdGFyZ2V0X2NvcmVfcHNjc2kubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfYWx1YS5jIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfYWx1YS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjJjNWZjZmUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9hbHVhLmMKQEAgLTAsMCArMSwxOTkxIEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogRmlsZW5hbWU6ICB0YXJnZXRfY29yZV9hbHVhLmMKKyAqCisgKiBUaGlzIGZpbGUgY29udGFpbnMgU1BDLTMgY29tcGxpYW50IGFzeW1tZXRyaWMgbG9naWNhbCB1bml0IGFzc2lnbnRtZW50IChBTFVBKQorICoKKyAqIENvcHlyaWdodCAoYykgMjAwOS0yMDEwIFJpc2luZyBUaWRlIFN5c3RlbXMKKyAqIENvcHlyaWdodCAoYykgMjAwOS0yMDEwIExpbnV4LWlTQ1NJLm9yZworICoKKyAqIE5pY2hvbGFzIEEuIEJlbGxpbmdlciA8bmFiQGtlcm5lbC5vcmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisjaW5jbHVkZSA8bGludXgvdmVyc2lvbi5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgorI2luY2x1ZGUgPGxpbnV4L2NvbmZpZ2ZzLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpX2NtbmQuaD4KKworI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9iYXNlLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV90cmFuc3BvcnQuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX29wcy5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9jb25maWdmcy5oPgorCisjaW5jbHVkZSAidGFyZ2V0X2NvcmVfYWx1YS5oIgorI2luY2x1ZGUgInRhcmdldF9jb3JlX2hiYS5oIgorI2luY2x1ZGUgInRhcmdldF9jb3JlX3VhLmgiCisKK3N0YXRpYyBpbnQgY29yZV9hbHVhX2NoZWNrX3RyYW5zaXRpb24oaW50IHN0YXRlLCBpbnQgKnByaW1hcnkpOworc3RhdGljIGludCBjb3JlX2FsdWFfc2V0X3RnX3B0X3NlY29uZGFyeV9zdGF0ZSgKKwkJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwX21lbWJlciAqdGdfcHRfZ3BfbWVtLAorCQlzdHJ1Y3Qgc2VfcG9ydCAqcG9ydCwgaW50IGV4cGxpY3QsIGludCBvZmZsaW5lKTsKKworLyoKKyAqIFJFUE9SVF9UQVJHRVRfUE9SVF9HUk9VUFMKKyAqCisgKiBTZWUgc3BjNHIxNyBzZWN0aW9uIDYuMjcKKyAqLworaW50IGNvcmVfZW11bGF0ZV9yZXBvcnRfdGFyZ2V0X3BvcnRfZ3JvdXBzKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2ID0gU0VfREVWKGNtZCktPnNlX3N1Yl9kZXY7CisJc3RydWN0IHNlX3BvcnQgKnBvcnQ7CisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncDsKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3BfbWVtYmVyICp0Z19wdF9ncF9tZW07CisJdW5zaWduZWQgY2hhciAqYnVmID0gKHVuc2lnbmVkIGNoYXIgKilUX1RBU0soY21kKS0+dF90YXNrX2J1ZjsKKwl1MzIgcmRfbGVuID0gMCwgb2ZmID0gNDsgLyogU2tpcCBvdmVyIFJFU0VSVkVEIGFyZWEgdG8gZmlyc3QKKwkJCQkgICAgVGFyZ2V0IHBvcnQgZ3JvdXAgZGVzY3JpcHRvciAqLworCisJc3Bpbl9sb2NrKCZUMTBfQUxVQShzdV9kZXYpLT50Z19wdF9ncHNfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeSh0Z19wdF9ncCwgJlQxMF9BTFVBKHN1X2RldiktPnRnX3B0X2dwc19saXN0LAorCQkJdGdfcHRfZ3BfbGlzdCkgeworCQkvKgorCQkgKiBQUkVGOiBQcmVmZXJyZWQgdGFyZ2V0IHBvcnQgYml0LCBkZXRlcm1pbmUgaWYgdGhpcworCQkgKiBiaXQgc2hvdWxkIGJlIHNldCBmb3IgcG9ydCBncm91cC4KKwkJICovCisJCWlmICh0Z19wdF9ncC0+dGdfcHRfZ3BfcHJlZikKKwkJCWJ1ZltvZmZdID0gMHg4MDsKKwkJLyoKKwkJICogU2V0IHRoZSBBU1lNTUVUUklDIEFDQ0VTUyBTdGF0ZQorCQkgKi8KKwkJYnVmW29mZisrXSB8PSAoYXRvbWljX3JlYWQoCisJCQkmdGdfcHRfZ3AtPnRnX3B0X2dwX2FsdWFfYWNjZXNzX3N0YXRlKSAmIDB4ZmYpOworCQkvKgorCQkgKiBTZXQgc3VwcG9ydGVkIEFTWU1NRVRSSUMgQUNDRVNTIFN0YXRlIGJpdHMKKwkJICovCisJCWJ1ZltvZmZdID0gMHg4MDsgLyogVF9TVVAgKi8KKwkJYnVmW29mZl0gfD0gMHg0MDsgLyogT19TVVAgKi8KKwkJYnVmW29mZl0gfD0gMHg4OyAvKiBVX1NVUCAqLworCQlidWZbb2ZmXSB8PSAweDQ7IC8qIFNfU1VQICovCisJCWJ1ZltvZmZdIHw9IDB4MjsgLyogQU5fU1VQICovCisJCWJ1ZltvZmYrK10gfD0gMHgxOyAvKiBBT19TVVAgKi8KKwkJLyoKKwkJICogVEFSR0VUIFBPUlQgR1JPVVAKKwkJICovCisJCWJ1ZltvZmYrK10gPSAoKHRnX3B0X2dwLT50Z19wdF9ncF9pZCA+PiA4KSAmIDB4ZmYpOworCQlidWZbb2ZmKytdID0gKHRnX3B0X2dwLT50Z19wdF9ncF9pZCAmIDB4ZmYpOworCisJCW9mZisrOyAvKiBTa2lwIG92ZXIgUmVzZXJ2ZWQgKi8KKwkJLyoKKwkJICogU1RBVFVTIENPREUKKwkJICovCisJCWJ1ZltvZmYrK10gPSAodGdfcHRfZ3AtPnRnX3B0X2dwX2FsdWFfYWNjZXNzX3N0YXR1cyAmIDB4ZmYpOworCQkvKgorCQkgKiBWZW5kb3IgU3BlY2lmaWMgZmllbGQKKwkJICovCisJCWJ1ZltvZmYrK10gPSAweDAwOworCQkvKgorCQkgKiBUQVJHRVQgUE9SVCBDT1VOVAorCQkgKi8KKwkJYnVmW29mZisrXSA9ICh0Z19wdF9ncC0+dGdfcHRfZ3BfbWVtYmVycyAmIDB4ZmYpOworCQlyZF9sZW4gKz0gODsKKworCQlzcGluX2xvY2soJnRnX3B0X2dwLT50Z19wdF9ncF9sb2NrKTsKKwkJbGlzdF9mb3JfZWFjaF9lbnRyeSh0Z19wdF9ncF9tZW0sICZ0Z19wdF9ncC0+dGdfcHRfZ3BfbWVtX2xpc3QsCisJCQkJdGdfcHRfZ3BfbWVtX2xpc3QpIHsKKwkJCXBvcnQgPSB0Z19wdF9ncF9tZW0tPnRnX3B0OworCQkJLyoKKwkJCSAqIFN0YXJ0IFRhcmdldCBQb3J0IGRlc2NyaXB0b3IgZm9ybWF0CisJCQkgKgorCQkJICogU2VlIHNwYzRyMTcgc2VjdGlvbiA2LjIuNyBUYWJsZSAyNDcKKwkJCSAqLworCQkJb2ZmICs9IDI7IC8qIFNraXAgb3ZlciBPYnNvbGV0ZSAqLworCQkJLyoKKwkJCSAqIFNldCBSRUxBVElWRSBUQVJHRVQgUE9SVCBJREVOVElGSUVSCisJCQkgKi8KKwkJCWJ1ZltvZmYrK10gPSAoKHBvcnQtPnNlcF9ydHBpID4+IDgpICYgMHhmZik7CisJCQlidWZbb2ZmKytdID0gKHBvcnQtPnNlcF9ydHBpICYgMHhmZik7CisJCQlyZF9sZW4gKz0gNDsKKwkJfQorCQlzcGluX3VubG9jaygmdGdfcHRfZ3AtPnRnX3B0X2dwX2xvY2spOworCX0KKwlzcGluX3VubG9jaygmVDEwX0FMVUEoc3VfZGV2KS0+dGdfcHRfZ3BzX2xvY2spOworCS8qCisJICogU2V0IHRoZSBSRVRVUk4gREFUQSBMRU5HVEggc2V0IGluIHRoZSBoZWFkZXIgb2YgdGhlIERhdGFJTiBQYXlsb2FkCisJICovCisJYnVmWzBdID0gKChyZF9sZW4gPj4gMjQpICYgMHhmZik7CisJYnVmWzFdID0gKChyZF9sZW4gPj4gMTYpICYgMHhmZik7CisJYnVmWzJdID0gKChyZF9sZW4gPj4gOCkgJiAweGZmKTsKKwlidWZbM10gPSAocmRfbGVuICYgMHhmZik7CisKKwlyZXR1cm4gMDsKK30KKworLyoKKyAqIFNFVF9UQVJHRVRfUE9SVF9HUk9VUFMgZm9yIGV4cGxpY3QgQUxVQSBvcGVyYXRpb24uCisgKgorICogU2VlIHNwYzRyMTcgc2VjdGlvbiA2LjM1CisgKi8KK2ludCBjb3JlX2VtdWxhdGVfc2V0X3RhcmdldF9wb3J0X2dyb3VwcyhzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gU0VfREVWKGNtZCk7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnN1X2RldiA9IFNFX0RFVihjbWQpLT5zZV9zdWJfZGV2OworCXN0cnVjdCBzZV9wb3J0ICpwb3J0LCAqbF9wb3J0ID0gU0VfTFVOKGNtZCktPmx1bl9zZXA7CisJc3RydWN0IHNlX25vZGVfYWNsICpuYWNsID0gU0VfU0VTUyhjbWQpLT5zZV9ub2RlX2FjbDsKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwID0gTlVMTCwgKmxfdGdfcHRfZ3A7CisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwX21lbWJlciAqdGdfcHRfZ3BfbWVtLCAqbF90Z19wdF9ncF9tZW07CisJdW5zaWduZWQgY2hhciAqYnVmID0gKHVuc2lnbmVkIGNoYXIgKilUX1RBU0soY21kKS0+dF90YXNrX2J1ZjsKKwl1bnNpZ25lZCBjaGFyICpwdHIgPSAmYnVmWzRdOyAvKiBTa2lwIG92ZXIgUkVTRVJWRUQgYXJlYSBpbiBoZWFkZXIgKi8KKwl1MzIgbGVuID0gNDsgLyogU2tpcCBvdmVyIFJFU0VSVkVEIGFyZWEgaW4gaGVhZGVyICovCisJaW50IGFsdWFfYWNjZXNzX3N0YXRlLCBwcmltYXJ5ID0gMCwgcmM7CisJdTE2IHRnX3B0X2lkLCBydHBpOworCisJaWYgKCEobF9wb3J0KSkKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfTFVfQ09NTV9GQUlMVVJFOworCS8qCisJICogRGV0ZXJtaW5lIGlmIGV4cGxpY3QgQUxVQSB2aWEgU0VUX1RBUkdFVF9QT1JUX0dST1VQUyBpcyBhbGxvd2VkCisJICogZm9yIHRoZSBsb2NhbCB0Z19wdF9ncC4KKwkgKi8KKwlsX3RnX3B0X2dwX21lbSA9IGxfcG9ydC0+c2VwX2FsdWFfdGdfcHRfZ3BfbWVtOworCWlmICghKGxfdGdfcHRfZ3BfbWVtKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhY2Nlc3MgbF9wb3J0LT5zZXBfYWx1YV90Z19wdF9ncF9tZW1cbiIpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9VTktOT1dOX1NBTV9PUENPREU7CisJfQorCXNwaW5fbG9jaygmbF90Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9sb2NrKTsKKwlsX3RnX3B0X2dwID0gbF90Z19wdF9ncF9tZW0tPnRnX3B0X2dwOworCWlmICghKGxfdGdfcHRfZ3ApKSB7CisJCXNwaW5fdW5sb2NrKCZsX3RnX3B0X2dwX21lbS0+dGdfcHRfZ3BfbWVtX2xvY2spOworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhY2Nlc3MgKmxfdGdfcHRfZ3BfbWVtLT50Z19wdF9ncFxuIik7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX1VOS05PV05fU0FNX09QQ09ERTsKKwl9CisJcmMgPSAobF90Z19wdF9ncC0+dGdfcHRfZ3BfYWx1YV9hY2Nlc3NfdHlwZSAmIFRQR1NfRVhQTElDVF9BTFVBKTsKKwlzcGluX3VubG9jaygmbF90Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9sb2NrKTsKKworCWlmICghKHJjKSkgeworCQlwcmludGsoS0VSTl9JTkZPICJVbmFibGUgdG8gcHJvY2VzcyBTRVRfVEFSR0VUX1BPUlRfR1JPVVBTIgorCQkJCSIgd2hpbGUgVFBHU19FWFBMSUNUX0FMVUEgaXMgZGlzYWJsZWRcbiIpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9VTktOT1dOX1NBTV9PUENPREU7CisJfQorCisJd2hpbGUgKGxlbiA8IGNtZC0+ZGF0YV9sZW5ndGgpIHsKKwkJYWx1YV9hY2Nlc3Nfc3RhdGUgPSAocHRyWzBdICYgMHgwZik7CisJCS8qCisJCSAqIENoZWNrIHRoZSByZWNlaXZlZCBBTFVBIGFjY2VzcyBzdGF0ZSwgYW5kIGRldGVybWluZSBpZgorCQkgKiB0aGUgc3RhdGUgaXMgYSBwcmltYXJ5IG9yIHNlY29uZGFyeSB0YXJnZXQgcG9ydCBhc3ltbWV0cmljCisJCSAqIGFjY2VzcyBzdGF0ZS4KKwkJICovCisJCXJjID0gY29yZV9hbHVhX2NoZWNrX3RyYW5zaXRpb24oYWx1YV9hY2Nlc3Nfc3RhdGUsICZwcmltYXJ5KTsKKwkJaWYgKHJjICE9IDApIHsKKwkJCS8qCisJCQkgKiBJZiB0aGUgU0VUIFRBUkdFVCBQT1JUIEdST1VQUyBhdHRlbXB0cyB0byBlc3RhYmxpc2gKKwkJCSAqIGFuIGludmFsaWQgY29tYmluYXRpb24gb2YgdGFyZ2V0IHBvcnQgYXN5bW1ldHJpYworCQkJICogYWNjZXNzIHN0YXRlcyBvciBhdHRlbXB0cyB0byBlc3RhYmxpc2ggYW4KKwkJCSAqIHVuc3VwcG9ydGVkIHRhcmdldCBwb3J0IGFzeW1tZXRyaWMgYWNjZXNzIHN0YXRlLAorCQkJICogdGhlbiB0aGUgY29tbWFuZCBzaGFsbCBiZSB0ZXJtaW5hdGVkIHdpdGggQ0hFQ0sKKwkJCSAqIENPTkRJVElPTiBzdGF0dXMsIHdpdGggdGhlIHNlbnNlIGtleSBzZXQgdG8gSUxMRUdBTAorCQkJICogUkVRVUVTVCwgYW5kIHRoZSBhZGRpdGlvbmFsIHNlbnNlIGNvZGUgc2V0IHRvIElOVkFMSUQKKwkJCSAqIEZJRUxEIElOIFBBUkFNRVRFUiBMSVNULgorCQkJICovCisJCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCQl9CisJCXJjID0gLTE7CisJCS8qCisJCSAqIElmIHRoZSBBU1lNTUVUUklDIEFDQ0VTUyBTVEFURSBmaWVsZCAoc2VlIHRhYmxlIDI2NykKKwkJICogc3BlY2lmaWVzIGEgcHJpbWFyeSB0YXJnZXQgcG9ydCBhc3ltbWV0cmljIGFjY2VzcyBzdGF0ZSwKKwkJICogdGhlbiB0aGUgVEFSR0VUIFBPUlQgR1JPVVAgT1IgVEFSR0VUIFBPUlQgZmllbGQgc3BlY2lmaWVzCisJCSAqIGEgcHJpbWFyeSB0YXJnZXQgcG9ydCBncm91cCBmb3Igd2hpY2ggdGhlIHByaW1hcnkgdGFyZ2V0CisJCSAqIHBvcnQgYXN5bW1ldHJpYyBhY2Nlc3Mgc3RhdGUgc2hhbGwgYmUgY2hhbmdlZC4gSWYgdGhlCisJCSAqIEFTWU1NRVRSSUMgQUNDRVNTIFNUQVRFIGZpZWxkIHNwZWNpZmllcyBhIHNlY29uZGFyeSB0YXJnZXQKKwkJICogcG9ydCBhc3ltbWV0cmljIGFjY2VzcyBzdGF0ZSwgdGhlbiB0aGUgVEFSR0VUIFBPUlQgR1JPVVAgT1IKKwkJICogVEFSR0VUIFBPUlQgZmllbGQgc3BlY2lmaWVzIHRoZSByZWxhdGl2ZSB0YXJnZXQgcG9ydAorCQkgKiBpZGVudGlmaWVyIChzZWUgMy4xLjEyMCkgb2YgdGhlIHRhcmdldCBwb3J0IGZvciB3aGljaCB0aGUKKwkJICogc2Vjb25kYXJ5IHRhcmdldCBwb3J0IGFzeW1tZXRyaWMgYWNjZXNzIHN0YXRlIHNoYWxsIGJlCisJCSAqIGNoYW5nZWQuCisJCSAqLworCQlpZiAocHJpbWFyeSkgeworCQkJdGdfcHRfaWQgPSAoKHB0clsyXSA8PCA4KSAmIDB4ZmYpOworCQkJdGdfcHRfaWQgfD0gKHB0clszXSAmIDB4ZmYpOworCQkJLyoKKwkJCSAqIExvY2F0ZSB0aGUgbWF0Y2hpbmcgdGFyZ2V0IHBvcnQgZ3JvdXAgSUQgZnJvbQorCQkJICogdGhlIGdsb2JhbCB0Z19wdF9ncCBsaXN0CisJCQkgKi8KKwkJCXNwaW5fbG9jaygmVDEwX0FMVUEoc3VfZGV2KS0+dGdfcHRfZ3BzX2xvY2spOworCQkJbGlzdF9mb3JfZWFjaF9lbnRyeSh0Z19wdF9ncCwKKwkJCQkJJlQxMF9BTFVBKHN1X2RldiktPnRnX3B0X2dwc19saXN0LAorCQkJCQl0Z19wdF9ncF9saXN0KSB7CisJCQkJaWYgKCEodGdfcHRfZ3AtPnRnX3B0X2dwX3ZhbGlkX2lkKSkKKwkJCQkJY29udGludWU7CisKKwkJCQlpZiAodGdfcHRfaWQgIT0gdGdfcHRfZ3AtPnRnX3B0X2dwX2lkKQorCQkJCQljb250aW51ZTsKKworCQkJCWF0b21pY19pbmMoJnRnX3B0X2dwLT50Z19wdF9ncF9yZWZfY250KTsKKwkJCQlzbXBfbWJfX2FmdGVyX2F0b21pY19pbmMoKTsKKwkJCQlzcGluX3VubG9jaygmVDEwX0FMVUEoc3VfZGV2KS0+dGdfcHRfZ3BzX2xvY2spOworCisJCQkJcmMgPSBjb3JlX2FsdWFfZG9fcG9ydF90cmFuc2l0aW9uKHRnX3B0X2dwLAorCQkJCQkJZGV2LCBsX3BvcnQsIG5hY2wsCisJCQkJCQlhbHVhX2FjY2Vzc19zdGF0ZSwgMSk7CisKKwkJCQlzcGluX2xvY2soJlQxMF9BTFVBKHN1X2RldiktPnRnX3B0X2dwc19sb2NrKTsKKwkJCQlhdG9taWNfZGVjKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfcmVmX2NudCk7CisJCQkJc21wX21iX19hZnRlcl9hdG9taWNfZGVjKCk7CisJCQkJYnJlYWs7CisJCQl9CisJCQlzcGluX3VubG9jaygmVDEwX0FMVUEoc3VfZGV2KS0+dGdfcHRfZ3BzX2xvY2spOworCQkJLyoKKwkJCSAqIElmIG5vdCBtYXRjaGluZyB0YXJnZXQgcG9ydCBncm91cCBJRCBjYW4gYmUgbG9jYXRlZAorCQkJICogdGhyb3cgYW4gZXhjZXB0aW9uIHdpdGggQVNDUTogSU5WQUxJRF9QQVJBTUVURVJfTElTVAorCQkJICovCisJCQlpZiAocmMgIT0gMCkKKwkJCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCQl9IGVsc2UgeworCQkJLyoKKwkJCSAqIEV4dGFjdCB0aGUgUkVMQVRJVkUgVEFSR0VUIFBPUlQgSURFTlRJRklFUiB0byBpZGVudGlmeQorCQkJICogdGhlIFRhcmdldCBQb3J0IGluIHF1ZXN0aW9uIGZvciB0aGUgdGhlIGluY29taW5nCisJCQkgKiBTRVRfVEFSR0VUX1BPUlRfR1JPVVBTIG9wLgorCQkJICovCisJCQlydHBpID0gKChwdHJbMl0gPDwgOCkgJiAweGZmKTsKKwkJCXJ0cGkgfD0gKHB0clszXSAmIDB4ZmYpOworCQkJLyoKKwkJCSAqIExvY2F0ZSB0aGUgbWF0Y2hpbmcgcmVsYXRpdmUgdGFyZ2V0IHBvcnQgaWRlbnRpZmVyCisJCQkgKiBmb3IgdGhlIHN0cnVjdCBzZV9kZXZpY2Ugc3RvcmFnZSBvYmplY3QuCisJCQkgKi8KKwkJCXNwaW5fbG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCQkJbGlzdF9mb3JfZWFjaF9lbnRyeShwb3J0LCAmZGV2LT5kZXZfc2VwX2xpc3QsCisJCQkJCQkJc2VwX2xpc3QpIHsKKwkJCQlpZiAocG9ydC0+c2VwX3J0cGkgIT0gcnRwaSkKKwkJCQkJY29udGludWU7CisKKwkJCQl0Z19wdF9ncF9tZW0gPSBwb3J0LT5zZXBfYWx1YV90Z19wdF9ncF9tZW07CisJCQkJc3Bpbl91bmxvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKworCQkJCXJjID0gY29yZV9hbHVhX3NldF90Z19wdF9zZWNvbmRhcnlfc3RhdGUoCisJCQkJCQl0Z19wdF9ncF9tZW0sIHBvcnQsIDEsIDEpOworCisJCQkJc3Bpbl9sb2NrKCZkZXYtPnNlX3BvcnRfbG9jayk7CisJCQkJYnJlYWs7CisJCQl9CisJCQlzcGluX3VubG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCQkJLyoKKwkJCSAqIElmIG5vdCBtYXRjaGluZyByZWxhdGl2ZSB0YXJnZXQgcG9ydCBpZGVudGlmaWVyIGNhbgorCQkJICogYmUgbG9jYXRlZCwgdGhyb3cgYW4gZXhjZXB0aW9uIHdpdGggQVNDUToKKwkJCSAqIElOVkFMSURfUEFSQU1FVEVSX0xJU1QKKwkJCSAqLworCQkJaWYgKHJjICE9IDApCisJCQkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfSU5WQUxJRF9QQVJBTUVURVJfTElTVDsKKwkJfQorCisJCXB0ciArPSA0OworCQlsZW4gKz0gNDsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSBpbnQgY29yZV9hbHVhX3N0YXRlX25vbm9wdGltaXplZCgKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJdW5zaWduZWQgY2hhciAqY2RiLAorCWludCBub25vcF9kZWxheV9tc2VjcywKKwl1OCAqYWx1YV9hc2NxKQoreworCS8qCisJICogU2V0IFNDRl9BTFVBX05PTl9PUFRJTUlaRUQgaGVyZSwgdGhpcyB2YWx1ZSB3aWxsIGJlIGNoZWNrZWQKKwkgKiBsYXRlciB0byBkZXRlcm1pbmUgaWYgcHJvY2Vzc2luZyBvZiB0aGlzIGNtZCBuZWVkcyB0byBiZQorCSAqIHRlbXBvcmFyaWx5IGRlbGF5ZWQgZm9yIHRoZSBBY3RpdmUvTm9uT3B0aW1pemVkIHByaW1hcnkgYWNjZXNzIHN0YXRlLgorCSAqLworCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9BTFVBX05PTl9PUFRJTUlaRUQ7CisJY21kLT5hbHVhX25vbm9wX2RlbGF5ID0gbm9ub3BfZGVsYXlfbXNlY3M7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IGNvcmVfYWx1YV9zdGF0ZV9zdGFuZGJ5KAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwl1bnNpZ25lZCBjaGFyICpjZGIsCisJdTggKmFsdWFfYXNjcSkKK3sKKwkvKgorCSAqIEFsbG93ZWQgQ0RCcyBmb3IgQUxVQV9BQ0NFU1NfU1RBVEVfU1RBTkRCWSBhcyBkZWZpbmVkIGJ5CisJICogc3BjNHIxNyBzZWN0aW9uIDUuOS4yLjQuNAorCSAqLworCXN3aXRjaCAoY2RiWzBdKSB7CisJY2FzZSBJTlFVSVJZOgorCWNhc2UgTE9HX1NFTEVDVDoKKwljYXNlIExPR19TRU5TRToKKwljYXNlIE1PREVfU0VMRUNUOgorCWNhc2UgTU9ERV9TRU5TRToKKwljYXNlIFJFUE9SVF9MVU5TOgorCWNhc2UgUkVDRUlWRV9ESUFHTk9TVElDOgorCWNhc2UgU0VORF9ESUFHTk9TVElDOgorCWNhc2UgTUFJTlRFTkFOQ0VfSU46CisJCXN3aXRjaCAoY2RiWzFdKSB7CisJCWNhc2UgTUlfUkVQT1JUX1RBUkdFVF9QR1M6CisJCQlyZXR1cm4gMDsKKwkJZGVmYXVsdDoKKwkJCSphbHVhX2FzY3EgPSBBU0NRXzA0SF9BTFVBX1RHX1BUX1NUQU5EQlk7CisJCQlyZXR1cm4gMTsKKwkJfQorCWNhc2UgTUFJTlRFTkFOQ0VfT1VUOgorCQlzd2l0Y2ggKGNkYlsxXSkgeworCQljYXNlIE1PX1NFVF9UQVJHRVRfUEdTOgorCQkJcmV0dXJuIDA7CisJCWRlZmF1bHQ6CisJCQkqYWx1YV9hc2NxID0gQVNDUV8wNEhfQUxVQV9UR19QVF9TVEFOREJZOworCQkJcmV0dXJuIDE7CisJCX0KKwljYXNlIFJFUVVFU1RfU0VOU0U6CisJY2FzZSBQRVJTSVNURU5UX1JFU0VSVkVfSU46CisJY2FzZSBQRVJTSVNURU5UX1JFU0VSVkVfT1VUOgorCWNhc2UgUkVBRF9CVUZGRVI6CisJY2FzZSBXUklURV9CVUZGRVI6CisJCXJldHVybiAwOworCWRlZmF1bHQ6CisJCSphbHVhX2FzY3EgPSBBU0NRXzA0SF9BTFVBX1RHX1BUX1NUQU5EQlk7CisJCXJldHVybiAxOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW5saW5lIGludCBjb3JlX2FsdWFfc3RhdGVfdW5hdmFpbGFibGUoCisJc3RydWN0IHNlX2NtZCAqY21kLAorCXVuc2lnbmVkIGNoYXIgKmNkYiwKKwl1OCAqYWx1YV9hc2NxKQoreworCS8qCisJICogQWxsb3dlZCBDREJzIGZvciBBTFVBX0FDQ0VTU19TVEFURV9VTkFWQUlMQUJMRSBhcyBkZWZpbmVkIGJ5CisJICogc3BjNHIxNyBzZWN0aW9uIDUuOS4yLjQuNQorCSAqLworCXN3aXRjaCAoY2RiWzBdKSB7CisJY2FzZSBJTlFVSVJZOgorCWNhc2UgUkVQT1JUX0xVTlM6CisJY2FzZSBNQUlOVEVOQU5DRV9JTjoKKwkJc3dpdGNoIChjZGJbMV0pIHsKKwkJY2FzZSBNSV9SRVBPUlRfVEFSR0VUX1BHUzoKKwkJCXJldHVybiAwOworCQlkZWZhdWx0OgorCQkJKmFsdWFfYXNjcSA9IEFTQ1FfMDRIX0FMVUFfVEdfUFRfVU5BVkFJTEFCTEU7CisJCQlyZXR1cm4gMTsKKwkJfQorCWNhc2UgTUFJTlRFTkFOQ0VfT1VUOgorCQlzd2l0Y2ggKGNkYlsxXSkgeworCQljYXNlIE1PX1NFVF9UQVJHRVRfUEdTOgorCQkJcmV0dXJuIDA7CisJCWRlZmF1bHQ6CisJCQkqYWx1YV9hc2NxID0gQVNDUV8wNEhfQUxVQV9UR19QVF9VTkFWQUlMQUJMRTsKKwkJCXJldHVybiAxOworCQl9CisJY2FzZSBSRVFVRVNUX1NFTlNFOgorCWNhc2UgUkVBRF9CVUZGRVI6CisJY2FzZSBXUklURV9CVUZGRVI6CisJCXJldHVybiAwOworCWRlZmF1bHQ6CisJCSphbHVhX2FzY3EgPSBBU0NRXzA0SF9BTFVBX1RHX1BUX1VOQVZBSUxBQkxFOworCQlyZXR1cm4gMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSBpbnQgY29yZV9hbHVhX3N0YXRlX3RyYW5zaXRpb24oCisJc3RydWN0IHNlX2NtZCAqY21kLAorCXVuc2lnbmVkIGNoYXIgKmNkYiwKKwl1OCAqYWx1YV9hc2NxKQoreworCS8qCisJICogQWxsb3dlZCBDREJzIGZvciBBTFVBX0FDQ0VTU19TVEFURV9UUkFOU0lUSU8gYXMgZGVmaW5lZCBieQorCSAqIHNwYzRyMTcgc2VjdGlvbiA1LjkuMi41CisJICovCisJc3dpdGNoIChjZGJbMF0pIHsKKwljYXNlIElOUVVJUlk6CisJY2FzZSBSRVBPUlRfTFVOUzoKKwljYXNlIE1BSU5URU5BTkNFX0lOOgorCQlzd2l0Y2ggKGNkYlsxXSkgeworCQljYXNlIE1JX1JFUE9SVF9UQVJHRVRfUEdTOgorCQkJcmV0dXJuIDA7CisJCWRlZmF1bHQ6CisJCQkqYWx1YV9hc2NxID0gQVNDUV8wNEhfQUxVQV9TVEFURV9UUkFOU0lUSU9OOworCQkJcmV0dXJuIDE7CisJCX0KKwljYXNlIFJFUVVFU1RfU0VOU0U6CisJY2FzZSBSRUFEX0JVRkZFUjoKKwljYXNlIFdSSVRFX0JVRkZFUjoKKwkJcmV0dXJuIDA7CisJZGVmYXVsdDoKKwkJKmFsdWFfYXNjcSA9IEFTQ1FfMDRIX0FMVUFfU1RBVEVfVFJBTlNJVElPTjsKKwkJcmV0dXJuIDE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBVc2VkIGZvciBhbHVhX3R5cGUgU1BDX0FMVUFfUEFTU1RIUk9VR0ggYW5kIFNQQzJfQUxVQV9ESVNBQkxFRAorICogaW4gdHJhbnNwb3J0X2NtZF9zZXF1ZW5jZXIoKS4gIFRoaXMgZnVuY3Rpb24gaXMgYXNzaWduZWQgdG8KKyAqIHN0cnVjdCB0MTBfYWx1YSAqLT5zdGF0ZV9jaGVjaygpIGluIGNvcmVfc2V0dXBfYWx1YSgpCisgKi8KK3N0YXRpYyBpbnQgY29yZV9hbHVhX3N0YXRlX2NoZWNrX25vcCgKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJdW5zaWduZWQgY2hhciAqY2RiLAorCXU4ICphbHVhX2FzY3EpCit7CisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBVc2VkIGZvciBhbHVhX3R5cGUgU1BDM19BTFVBX0VNVUxBVEVEIGluIHRyYW5zcG9ydF9jbWRfc2VxdWVuY2VyKCkuCisgKiBUaGlzIGZ1bmN0aW9uIGlzIGFzc2lnbmVkIHRvIHN0cnVjdCB0MTBfYWx1YSAqLT5zdGF0ZV9jaGVjaygpIGluCisgKiBjb3JlX3NldHVwX2FsdWEoKQorICoKKyAqIEFsc28sIHRoaXMgZnVuY3Rpb24gY2FuIHJldHVybiB0aHJlZSBkaWZmZXJlbnQgcmV0dXJuIGNvZGVzIHRvCisgKiBzaWduYWwgdHJhbnNwb3J0X2dlbmVyaWNfY21kX3NlcXVlbmNlcigpCisgKgorICogcmV0dXJuIDE6IElzIHVzZWQgdG8gc2lnbmFsIExVTiBub3QgYWNjZWNzYWJsZSwgYW5kIGNoZWNrIGNvbmRpdGlvbi9ub3QgcmVhZHkKKyAqIHJldHVybiAwOiBVc2VkIHRvIHNpZ25hbCBzdWNjZXNzCisgKiByZXV0cm4gLTE6IFVzZWQgdG8gc2lnbmFsIGZhaWx1cmUsIGFuZCBpbnZhbGlkIGNkYiBmaWVsZAorICovCitzdGF0aWMgaW50IGNvcmVfYWx1YV9zdGF0ZV9jaGVjaygKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJdW5zaWduZWQgY2hhciAqY2RiLAorCXU4ICphbHVhX2FzY3EpCit7CisJc3RydWN0IHNlX2x1biAqbHVuID0gU0VfTFVOKGNtZCk7CisJc3RydWN0IHNlX3BvcnQgKnBvcnQgPSBsdW4tPmx1bl9zZXA7CisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncDsKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3BfbWVtYmVyICp0Z19wdF9ncF9tZW07CisJaW50IG91dF9hbHVhX3N0YXRlLCBub25vcF9kZWxheV9tc2VjczsKKworCWlmICghKHBvcnQpKQorCQlyZXR1cm4gMDsKKwkvKgorCSAqIEZpcnN0LCBjaGVjayBmb3IgYSBzdHJ1Y3Qgc2VfcG9ydCBzcGVjaWZpYyBzZWNvbmRhcnkgQUxVQSB0YXJnZXQgcG9ydAorCSAqIGFjY2VzcyBzdGF0ZTogT0ZGTElORQorCSAqLworCWlmIChhdG9taWNfcmVhZCgmcG9ydC0+c2VwX3RnX3B0X3NlY29uZGFyeV9vZmZsaW5lKSkgeworCQkqYWx1YV9hc2NxID0gQVNDUV8wNEhfQUxVQV9PRkZMSU5FOworCQlwcmludGsoS0VSTl9JTkZPICJBTFVBOiBHb3Qgc2Vjb25kYXJ5IG9mZmxpbmUgc3RhdHVzIGZvciBsb2NhbCIKKwkJCQkiIHRhcmdldCBwb3J0XG4iKTsKKwkJKmFsdWFfYXNjcSA9IEFTQ1FfMDRIX0FMVUFfT0ZGTElORTsKKwkJcmV0dXJuIDE7CisJfQorCSAvKgorCSAqIFNlY29uZCwgb2J0YWluIHRoZSBzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3BfbWVtYmVyIHBvaW50ZXIgdG8gdGhlCisJICogQUxVQSB0YXJnZXQgcG9ydCBncm91cCwgdG8gb2J0YWluIGN1cnJlbnQgQUxVQSBhY2Nlc3Mgc3RhdGUuCisJICogT3RoZXJ3aXNlIGxvb2sgZm9yIHRoZSB1bmRlcmx5aW5nIHN0cnVjdCBzZV9kZXZpY2UgYXNzb2NpYXRpb24gd2l0aAorCSAqIGEgQUxVQSBsb2dpY2FsIHVuaXQgZ3JvdXAuCisJICovCisJdGdfcHRfZ3BfbWVtID0gcG9ydC0+c2VwX2FsdWFfdGdfcHRfZ3BfbWVtOworCXNwaW5fbG9jaygmdGdfcHRfZ3BfbWVtLT50Z19wdF9ncF9tZW1fbG9jayk7CisJdGdfcHRfZ3AgPSB0Z19wdF9ncF9tZW0tPnRnX3B0X2dwOworCW91dF9hbHVhX3N0YXRlID0gYXRvbWljX3JlYWQoJnRnX3B0X2dwLT50Z19wdF9ncF9hbHVhX2FjY2Vzc19zdGF0ZSk7CisJbm9ub3BfZGVsYXlfbXNlY3MgPSB0Z19wdF9ncC0+dGdfcHRfZ3Bfbm9ub3BfZGVsYXlfbXNlY3M7CisJc3Bpbl91bmxvY2soJnRnX3B0X2dwX21lbS0+dGdfcHRfZ3BfbWVtX2xvY2spOworCS8qCisJICogUHJvY2VzcyBBTFVBX0FDQ0VTU19TVEFURV9BQ1RJVkVfT1BUTUlaRUQgaW4gYSBzZXBlcmF0ZSBjb25kaXRpb25hbAorCSAqIHN0YXRlbWVudCBzbyB0aGUgY29tcGxpZXIga25vd3MgZXhwbGljdGx5IHRvIGNoZWNrIHRoaXMgY2FzZSBmaXJzdC4KKwkgKiBGb3IgdGhlIE9wdGltaXplZCBBTFVBIGFjY2VzcyBzdGF0ZSBjYXNlLCB3ZSB3YW50IHRvIHByb2Nlc3MgdGhlCisJICogaW5jb21pbmcgZmFicmljIGNtZCBBU0FQLi4KKwkgKi8KKwlpZiAob3V0X2FsdWFfc3RhdGUgPT0gQUxVQV9BQ0NFU1NfU1RBVEVfQUNUSVZFX09QVE1JWkVEKQorCQlyZXR1cm4gMDsKKworCXN3aXRjaCAob3V0X2FsdWFfc3RhdGUpIHsKKwljYXNlIEFMVUFfQUNDRVNTX1NUQVRFX0FDVElWRV9OT05fT1BUSU1JWkVEOgorCQlyZXR1cm4gY29yZV9hbHVhX3N0YXRlX25vbm9wdGltaXplZChjbWQsIGNkYiwKKwkJCQkJbm9ub3BfZGVsYXlfbXNlY3MsIGFsdWFfYXNjcSk7CisJY2FzZSBBTFVBX0FDQ0VTU19TVEFURV9TVEFOREJZOgorCQlyZXR1cm4gY29yZV9hbHVhX3N0YXRlX3N0YW5kYnkoY21kLCBjZGIsIGFsdWFfYXNjcSk7CisJY2FzZSBBTFVBX0FDQ0VTU19TVEFURV9VTkFWQUlMQUJMRToKKwkJcmV0dXJuIGNvcmVfYWx1YV9zdGF0ZV91bmF2YWlsYWJsZShjbWQsIGNkYiwgYWx1YV9hc2NxKTsKKwljYXNlIEFMVUFfQUNDRVNTX1NUQVRFX1RSQU5TSVRJT046CisJCXJldHVybiBjb3JlX2FsdWFfc3RhdGVfdHJhbnNpdGlvbihjbWQsIGNkYiwgYWx1YV9hc2NxKTsKKwkvKgorCSAqIE9GRkxJTkUgaXMgYSBzZWNvbmRhcnkgQUxVQSB0YXJnZXQgcG9ydCBncm91cCBhY2Nlc3Mgc3RhdGUsIHRoYXQgaXMKKwkgKiBoYW5kbGVkIGFib3ZlIHdpdGggc3RydWN0IHNlX3BvcnQtPnNlcF90Z19wdF9zZWNvbmRhcnlfb2ZmbGluZT0xCisJICovCisJY2FzZSBBTFVBX0FDQ0VTU19TVEFURV9PRkZMSU5FOgorCWRlZmF1bHQ6CisJCXByaW50ayhLRVJOX0VSUiAiVW5rbm93biBBTFVBIGFjY2VzcyBzdGF0ZTogMHglMDJ4XG4iLAorCQkJCW91dF9hbHVhX3N0YXRlKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiAwOworfQorCisvKgorICogQ2hlY2sgaW1wbGljdCBhbmQgZXhwbGljdCBBTFVBIHN0YXRlIGNoYW5nZSByZXF1ZXN0LgorICovCitzdGF0aWMgaW50IGNvcmVfYWx1YV9jaGVja190cmFuc2l0aW9uKGludCBzdGF0ZSwgaW50ICpwcmltYXJ5KQoreworCXN3aXRjaCAoc3RhdGUpIHsKKwljYXNlIEFMVUFfQUNDRVNTX1NUQVRFX0FDVElWRV9PUFRNSVpFRDoKKwljYXNlIEFMVUFfQUNDRVNTX1NUQVRFX0FDVElWRV9OT05fT1BUSU1JWkVEOgorCWNhc2UgQUxVQV9BQ0NFU1NfU1RBVEVfU1RBTkRCWToKKwljYXNlIEFMVUFfQUNDRVNTX1NUQVRFX1VOQVZBSUxBQkxFOgorCQkvKgorCQkgKiBPUFRJTUlaRUQsIE5PTi1PUFRJTUlaRUQsIFNUQU5EQlkgYW5kIFVOQVZBSUxBQkxFIGFyZQorCQkgKiBkZWZpbmVkIGFzIHByaW1hcnkgdGFyZ2V0IHBvcnQgYXN5bW1ldHJpYyBhY2Nlc3Mgc3RhdGVzLgorCQkgKi8KKwkJKnByaW1hcnkgPSAxOworCQlicmVhazsKKwljYXNlIEFMVUFfQUNDRVNTX1NUQVRFX09GRkxJTkU6CisJCS8qCisJCSAqIE9GRkxJTkUgc3RhdGUgaXMgZGVmaW5lZCBhcyBhIHNlY29uZGFyeSB0YXJnZXQgcG9ydAorCQkgKiBhc3ltbWV0cmljIGFjY2VzcyBzdGF0ZS4KKwkJICovCisJCSpwcmltYXJ5ID0gMDsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmtub3duIEFMVUEgYWNjZXNzIHN0YXRlOiAweCUwMnhcbiIsIHN0YXRlKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgY2hhciAqY29yZV9hbHVhX2R1bXBfc3RhdGUoaW50IHN0YXRlKQoreworCXN3aXRjaCAoc3RhdGUpIHsKKwljYXNlIEFMVUFfQUNDRVNTX1NUQVRFX0FDVElWRV9PUFRNSVpFRDoKKwkJcmV0dXJuICJBY3RpdmUvT3B0aW1pemVkIjsKKwljYXNlIEFMVUFfQUNDRVNTX1NUQVRFX0FDVElWRV9OT05fT1BUSU1JWkVEOgorCQlyZXR1cm4gIkFjdGl2ZS9Ob25PcHRpbWl6ZWQiOworCWNhc2UgQUxVQV9BQ0NFU1NfU1RBVEVfU1RBTkRCWToKKwkJcmV0dXJuICJTdGFuZGJ5IjsKKwljYXNlIEFMVUFfQUNDRVNTX1NUQVRFX1VOQVZBSUxBQkxFOgorCQlyZXR1cm4gIlVuYXZhaWxhYmxlIjsKKwljYXNlIEFMVUFfQUNDRVNTX1NUQVRFX09GRkxJTkU6CisJCXJldHVybiAiT2ZmbGluZSI7CisJZGVmYXVsdDoKKwkJcmV0dXJuICJVbmtub3duIjsKKwl9CisKKwlyZXR1cm4gTlVMTDsKK30KKworY2hhciAqY29yZV9hbHVhX2R1bXBfc3RhdHVzKGludCBzdGF0dXMpCit7CisJc3dpdGNoIChzdGF0dXMpIHsKKwljYXNlIEFMVUFfU1RBVFVTX05PTkU6CisJCXJldHVybiAiTm9uZSI7CisJY2FzZSBBTFVBX1NUQVRVU19BTFRFUkVEX0JZX0VYUExJQ1RfU1RQRzoKKwkJcmV0dXJuICJBbHRlcmVkIGJ5IEV4cGxpY3QgU1RQRyI7CisJY2FzZSBBTFVBX1NUQVRVU19BTFRFUkVEX0JZX0lNUExJQ1RfQUxVQToKKwkJcmV0dXJuICJBbHRlcmVkIGJ5IEltcGxpY3QgQUxVQSI7CisJZGVmYXVsdDoKKwkJcmV0dXJuICJVbmtub3duIjsKKwl9CisKKwlyZXR1cm4gTlVMTDsKK30KKworLyoKKyAqIFVzZWQgYnkgZmFicmljIG1vZHVsZXMgdG8gZGV0ZXJtaW5lIHdoZW4gd2UgbmVlZCB0byBkZWxheSBwcm9jZXNzaW5nCisgKiBmb3IgdGhlIEFjdGl2ZS9Ob25PcHRpbWl6ZWQgcGF0aHMuLgorICovCitpbnQgY29yZV9hbHVhX2NoZWNrX25vbm9wX2RlbGF5KAorCXN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlpZiAoIShjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9BTFVBX05PTl9PUFRJTUlaRUQpKQorCQlyZXR1cm4gMDsKKwlpZiAoaW5faW50ZXJydXB0KCkpCisJCXJldHVybiAwOworCS8qCisJICogVGhlIEFMVUEgQWN0aXZlL05vbk9wdGltaXplZCBhY2Nlc3Mgc3RhdGUgZGVsYXkgY2FuIGJlIGRpc2FibGVkCisJICogaW4gdmlhIGNvbmZpZ2ZzIHdpdGggYSB2YWx1ZSBvZiB6ZXJvCisJICovCisJaWYgKCEoY21kLT5hbHVhX25vbm9wX2RlbGF5KSkKKwkJcmV0dXJuIDA7CisJLyoKKwkgKiBzdHJ1Y3Qgc2VfY21kLT5hbHVhX25vbm9wX2RlbGF5IGdldHMgc2V0IGJ5IGEgdGFyZ2V0IHBvcnQgZ3JvdXAKKwkgKiBkZWZpbmVkIGludGVydmFsIGluIGNvcmVfYWx1YV9zdGF0ZV9ub25vcHRpbWl6ZWQoKQorCSAqLworCW1zbGVlcF9pbnRlcnJ1cHRpYmxlKGNtZC0+YWx1YV9ub25vcF9kZWxheSk7CisJcmV0dXJuIDA7Cit9CitFWFBPUlRfU1lNQk9MKGNvcmVfYWx1YV9jaGVja19ub25vcF9kZWxheSk7CisKKy8qCisgKiBDYWxsZWQgd2l0aCB0Z19wdF9ncC0+dGdfcHRfZ3BfbWRfbXV0ZXggb3IgdGdfcHRfZ3BfbWVtLT5zZXBfdGdfcHRfbWRfbXV0ZXgKKyAqCisgKi8KK3N0YXRpYyBpbnQgY29yZV9hbHVhX3dyaXRlX3RwZ19tZXRhZGF0YSgKKwljb25zdCBjaGFyICpwYXRoLAorCXVuc2lnbmVkIGNoYXIgKm1kX2J1ZiwKKwl1MzIgbWRfYnVmX2xlbikKK3sKKwltbV9zZWdtZW50X3Qgb2xkX2ZzOworCXN0cnVjdCBmaWxlICpmaWxlOworCXN0cnVjdCBpb3ZlYyBpb3ZbMV07CisJaW50IGZsYWdzID0gT19SRFdSIHwgT19DUkVBVCB8IE9fVFJVTkMsIHJldDsKKworCW1lbXNldChpb3YsIDAsIHNpemVvZihzdHJ1Y3QgaW92ZWMpKTsKKworCWZpbGUgPSBmaWxwX29wZW4ocGF0aCwgZmxhZ3MsIDA2MDApOworCWlmIChJU19FUlIoZmlsZSkgfHwgIWZpbGUgfHwgIWZpbGUtPmZfZGVudHJ5KSB7CisJCXByaW50ayhLRVJOX0VSUiAiZmlscF9vcGVuKCVzKSBmb3IgQUxVQSBtZXRhZGF0YSBmYWlsZWRcbiIsCisJCQlwYXRoKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCisJaW92WzBdLmlvdl9iYXNlID0gJm1kX2J1ZlswXTsKKwlpb3ZbMF0uaW92X2xlbiA9IG1kX2J1Zl9sZW47CisKKwlvbGRfZnMgPSBnZXRfZnMoKTsKKwlzZXRfZnMoZ2V0X2RzKCkpOworCXJldCA9IHZmc193cml0ZXYoZmlsZSwgJmlvdlswXSwgMSwgJmZpbGUtPmZfcG9zKTsKKwlzZXRfZnMob2xkX2ZzKTsKKworCWlmIChyZXQgPCAwKSB7CisJCXByaW50ayhLRVJOX0VSUiAiRXJyb3Igd3JpdGluZyBBTFVBIG1ldGFkYXRhIGZpbGU6ICVzXG4iLCBwYXRoKTsKKwkJZmlscF9jbG9zZShmaWxlLCBOVUxMKTsKKwkJcmV0dXJuIC1FSU87CisJfQorCWZpbHBfY2xvc2UoZmlsZSwgTlVMTCk7CisKKwlyZXR1cm4gMDsKK30KKworLyoKKyAqIENhbGxlZCB3aXRoIHRnX3B0X2dwLT50Z19wdF9ncF9tZF9tdXRleCBoZWxkCisgKi8KK3N0YXRpYyBpbnQgY29yZV9hbHVhX3VwZGF0ZV90cGdfcHJpbWFyeV9tZXRhZGF0YSgKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwLAorCWludCBwcmltYXJ5X3N0YXRlLAorCXVuc2lnbmVkIGNoYXIgKm1kX2J1ZikKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2ID0gdGdfcHRfZ3AtPnRnX3B0X2dwX3N1X2RldjsKKwlzdHJ1Y3QgdDEwX3d3biAqd3duID0gJnN1X2Rldi0+dDEwX3d3bjsKKwljaGFyIHBhdGhbQUxVQV9NRVRBREFUQV9QQVRIX0xFTl07CisJaW50IGxlbjsKKworCW1lbXNldChwYXRoLCAwLCBBTFVBX01FVEFEQVRBX1BBVEhfTEVOKTsKKworCWxlbiA9IHNucHJpbnRmKG1kX2J1ZiwgdGdfcHRfZ3AtPnRnX3B0X2dwX21kX2J1Zl9sZW4sCisJCQkidGdfcHRfZ3BfaWQ9JWh1XG4iCisJCQkiYWx1YV9hY2Nlc3Nfc3RhdGU9MHglMDJ4XG4iCisJCQkiYWx1YV9hY2Nlc3Nfc3RhdHVzPTB4JTAyeFxuIiwKKwkJCXRnX3B0X2dwLT50Z19wdF9ncF9pZCwgcHJpbWFyeV9zdGF0ZSwKKwkJCXRnX3B0X2dwLT50Z19wdF9ncF9hbHVhX2FjY2Vzc19zdGF0dXMpOworCisJc25wcmludGYocGF0aCwgQUxVQV9NRVRBREFUQV9QQVRIX0xFTiwKKwkJIi92YXIvdGFyZ2V0L2FsdWEvdHBnc18lcy8lcyIsICZ3d24tPnVuaXRfc2VyaWFsWzBdLAorCQljb25maWdfaXRlbV9uYW1lKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfZ3JvdXAuY2dfaXRlbSkpOworCisJcmV0dXJuIGNvcmVfYWx1YV93cml0ZV90cGdfbWV0YWRhdGEocGF0aCwgbWRfYnVmLCBsZW4pOworfQorCitzdGF0aWMgaW50IGNvcmVfYWx1YV9kb190cmFuc2l0aW9uX3RnX3B0KAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3AsCisJc3RydWN0IHNlX3BvcnQgKmxfcG9ydCwKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKm5hY2wsCisJdW5zaWduZWQgY2hhciAqbWRfYnVmLAorCWludCBuZXdfc3RhdGUsCisJaW50IGV4cGxpY3QpCit7CisJc3RydWN0IHNlX2Rldl9lbnRyeSAqc2VfZGV2ZTsKKwlzdHJ1Y3Qgc2VfbHVuX2FjbCAqbGFjbDsKKwlzdHJ1Y3Qgc2VfcG9ydCAqcG9ydDsKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3BfbWVtYmVyICptZW07CisJaW50IG9sZF9zdGF0ZSA9IDA7CisJLyoKKwkgKiBTYXZlIHRoZSBvbGQgcHJpbWFyeSBBTFVBIGFjY2VzcyBzdGF0ZSwgYW5kIHNldCB0aGUgY3VycmVudCBzdGF0ZQorCSAqIHRvIEFMVUFfQUNDRVNTX1NUQVRFX1RSQU5TSVRJT04uCisJICovCisJb2xkX3N0YXRlID0gYXRvbWljX3JlYWQoJnRnX3B0X2dwLT50Z19wdF9ncF9hbHVhX2FjY2Vzc19zdGF0ZSk7CisJYXRvbWljX3NldCgmdGdfcHRfZ3AtPnRnX3B0X2dwX2FsdWFfYWNjZXNzX3N0YXRlLAorCQkJQUxVQV9BQ0NFU1NfU1RBVEVfVFJBTlNJVElPTik7CisJdGdfcHRfZ3AtPnRnX3B0X2dwX2FsdWFfYWNjZXNzX3N0YXR1cyA9IChleHBsaWN0KSA/CisJCQkJQUxVQV9TVEFUVVNfQUxURVJFRF9CWV9FWFBMSUNUX1NUUEcgOgorCQkJCUFMVUFfU1RBVFVTX0FMVEVSRURfQllfSU1QTElDVF9BTFVBOworCS8qCisJICogQ2hlY2sgZm9yIHRoZSBvcHRpb25hbCBBTFVBIHByaW1hcnkgc3RhdGUgdHJhbnNpdGlvbiBkZWxheQorCSAqLworCWlmICh0Z19wdF9ncC0+dGdfcHRfZ3BfdHJhbnNfZGVsYXlfbXNlY3MgIT0gMCkKKwkJbXNsZWVwX2ludGVycnVwdGlibGUodGdfcHRfZ3AtPnRnX3B0X2dwX3RyYW5zX2RlbGF5X21zZWNzKTsKKworCXNwaW5fbG9jaygmdGdfcHRfZ3AtPnRnX3B0X2dwX2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnkobWVtLCAmdGdfcHRfZ3AtPnRnX3B0X2dwX21lbV9saXN0LAorCQkJCXRnX3B0X2dwX21lbV9saXN0KSB7CisJCXBvcnQgPSBtZW0tPnRnX3B0OworCQkvKgorCQkgKiBBZnRlciBhbiBpbXBsaWNpdCB0YXJnZXQgcG9ydCBhc3ltbWV0cmljIGFjY2VzcyBzdGF0ZQorCQkgKiBjaGFuZ2UsIGEgZGV2aWNlIHNlcnZlciBzaGFsbCBlc3RhYmxpc2ggYSB1bml0IGF0dGVudGlvbgorCQkgKiBjb25kaXRpb24gZm9yIHRoZSBpbml0aWF0b3IgcG9ydCBhc3NvY2lhdGVkIHdpdGggZXZlcnkgSV9UCisJCSAqIG5leHVzIHdpdGggdGhlIGFkZGl0aW9uYWwgc2Vuc2UgY29kZSBzZXQgdG8gQVNZTU1FVFJJQworCQkgKiBBQ0NFU1MgU1RBVEUgQ0hBR0VELgorCQkgKgorCQkgKiBBZnRlciBhbiBleHBsaWNpdCB0YXJnZXQgcG9ydCBhc3ltbWV0cmljIGFjY2VzcyBzdGF0ZQorCQkgKiBjaGFuZ2UsIGEgZGV2aWNlIHNlcnZlciBzaGFsbCBlc3RhYmxpc2ggYSB1bml0IGF0dGVudGlvbgorCQkgKiBjb25kaXRpb24gd2l0aCB0aGUgYWRkaXRpb25hbCBzZW5zZSBjb2RlIHNldCB0byBBU1lNTUVUUklDCisJCSAqIEFDQ0VTUyBTVEFURSBDSEFOR0VEIGZvciB0aGUgaW5pdGlhdG9yIHBvcnQgYXNzb2NpYXRlZCB3aXRoCisJCSAqIGV2ZXJ5IElfVCBuZXh1cyBvdGhlciB0aGFuIHRoZSBJX1QgbmV4dXMgb24gd2hpY2ggdGhlIFNFVAorCQkgKiBUQVJHRVQgUE9SVCBHUk9VUFMgY29tbWFuZAorCQkgKi8KKwkJYXRvbWljX2luYygmbWVtLT50Z19wdF9ncF9tZW1fcmVmX2NudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2luYygpOworCQlzcGluX3VubG9jaygmdGdfcHRfZ3AtPnRnX3B0X2dwX2xvY2spOworCisJCXNwaW5fbG9ja19iaCgmcG9ydC0+c2VwX2FsdWFfbG9jayk7CisJCWxpc3RfZm9yX2VhY2hfZW50cnkoc2VfZGV2ZSwgJnBvcnQtPnNlcF9hbHVhX2xpc3QsCisJCQkJCWFsdWFfcG9ydF9saXN0KSB7CisJCQlsYWNsID0gc2VfZGV2ZS0+c2VfbHVuX2FjbDsKKwkJCS8qCisJCQkgKiBzZV9kZXZlLT5zZV9sdW5fYWNsIHBvaW50ZXIgbWF5IGJlIE5VTEwgZm9yIGEKKwkJCSAqIGVudHJ5IGNyZWF0ZWQgd2l0aG91dCBleHBsaWN0IE5vZGUrTWFwcGVkTFVOIEFDTHMKKwkJCSAqLworCQkJaWYgKCEobGFjbCkpCisJCQkJY29udGludWU7CisKKwkJCWlmIChleHBsaWN0ICYmCisJCQkgICAobmFjbCAhPSBOVUxMKSAmJiAobmFjbCA9PSBsYWNsLT5zZV9sdW5fbmFjbCkgJiYKKwkJCSAgIChsX3BvcnQgIT0gTlVMTCkgJiYgKGxfcG9ydCA9PSBwb3J0KSkKKwkJCQljb250aW51ZTsKKworCQkJY29yZV9zY3NpM191YV9hbGxvY2F0ZShsYWNsLT5zZV9sdW5fbmFjbCwKKwkJCQlzZV9kZXZlLT5tYXBwZWRfbHVuLCAweDJBLAorCQkJCUFTQ1FfMkFIX0FTWU1NRVRSSUNfQUNDRVNTX1NUQVRFX0NIQU5HRUQpOworCQl9CisJCXNwaW5fdW5sb2NrX2JoKCZwb3J0LT5zZXBfYWx1YV9sb2NrKTsKKworCQlzcGluX2xvY2soJnRnX3B0X2dwLT50Z19wdF9ncF9sb2NrKTsKKwkJYXRvbWljX2RlYygmbWVtLT50Z19wdF9ncF9tZW1fcmVmX2NudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworCX0KKwlzcGluX3VubG9jaygmdGdfcHRfZ3AtPnRnX3B0X2dwX2xvY2spOworCS8qCisJICogVXBkYXRlIHRoZSBBTFVBIG1ldGFkYXRhIGJ1ZiB0aGF0IGhhcyBiZWVuIGFsbG9jYXRlZCBpbgorCSAqIGNvcmVfYWx1YV9kb19wb3J0X3RyYW5zaXRpb24oKSwgdGhpcyBtZXRhZGF0YSB3aWxsIGJlIHdyaXR0ZW4KKwkgKiB0byBzdHJ1Y3QgZmlsZS4KKwkgKgorCSAqIE5vdGUgdGhhdCB0aGVyZSBpcyB0aGUgY2FzZSB3aGVyZSB3ZSBkbyBub3Qgd2FudCB0byB1cGRhdGUgdGhlCisJICogbWV0YWRhdGEgd2hlbiB0aGUgc2F2ZWQgbWV0YWRhdGEgaXMgYmVpbmcgcGFyc2VkIGluIHVzZXJzcGFjZQorCSAqIHdoZW4gc2V0dGluZyB0aGUgZXhpc3RpbmcgcG9ydCBhY2Nlc3Mgc3RhdGUgYW5kIGFjY2VzcyBzdGF0dXMuCisJICoKKwkgKiBBbHNvIG5vdGUgdGhhdCB0aGUgZmFpbHVyZSB0byB3cml0ZSBvdXQgdGhlIEFMVUEgbWV0YWRhdGEgdG8KKwkgKiBzdHJ1Y3QgZmlsZSBkb2VzIE5PVCBhZmZlY3QgdGhlIGFjdHVhbCBBTFVBIHRyYW5zaXRpb24uCisJICovCisJaWYgKHRnX3B0X2dwLT50Z19wdF9ncF93cml0ZV9tZXRhZGF0YSkgeworCQltdXRleF9sb2NrKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfbWRfbXV0ZXgpOworCQljb3JlX2FsdWFfdXBkYXRlX3RwZ19wcmltYXJ5X21ldGFkYXRhKHRnX3B0X2dwLAorCQkJCQluZXdfc3RhdGUsIG1kX2J1Zik7CisJCW11dGV4X3VubG9jaygmdGdfcHRfZ3AtPnRnX3B0X2dwX21kX211dGV4KTsKKwl9CisJLyoKKwkgKiBTZXQgdGhlIGN1cnJlbnQgcHJpbWFyeSBBTFVBIGFjY2VzcyBzdGF0ZSB0byB0aGUgcmVxdWVzdGVkIG5ldyBzdGF0ZQorCSAqLworCWF0b21pY19zZXQoJnRnX3B0X2dwLT50Z19wdF9ncF9hbHVhX2FjY2Vzc19zdGF0ZSwgbmV3X3N0YXRlKTsKKworCXByaW50ayhLRVJOX0lORk8gIlN1Y2Nlc3NmdWwgJXMgQUxVQSB0cmFuc2l0aW9uIFRHIFBUIEdyb3VwOiAlcyBJRDogJWh1IgorCQkiIGZyb20gcHJpbWFyeSBhY2Nlc3Mgc3RhdGUgJXMgdG8gJXNcbiIsIChleHBsaWN0KSA/ICJleHBsaWN0IiA6CisJCSJpbXBsaWN0IiwgY29uZmlnX2l0ZW1fbmFtZSgmdGdfcHRfZ3AtPnRnX3B0X2dwX2dyb3VwLmNnX2l0ZW0pLAorCQl0Z19wdF9ncC0+dGdfcHRfZ3BfaWQsIGNvcmVfYWx1YV9kdW1wX3N0YXRlKG9sZF9zdGF0ZSksCisJCWNvcmVfYWx1YV9kdW1wX3N0YXRlKG5ld19zdGF0ZSkpOworCisJcmV0dXJuIDA7Cit9CisKK2ludCBjb3JlX2FsdWFfZG9fcG9ydF90cmFuc2l0aW9uKAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqbF90Z19wdF9ncCwKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpsX2RldiwKKwlzdHJ1Y3Qgc2VfcG9ydCAqbF9wb3J0LAorCXN0cnVjdCBzZV9ub2RlX2FjbCAqbF9uYWNsLAorCWludCBuZXdfc3RhdGUsCisJaW50IGV4cGxpY3QpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2OworCXN0cnVjdCBzZV9wb3J0ICpwb3J0OworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXY7CisJc3RydWN0IHNlX25vZGVfYWNsICpuYWNsOworCXN0cnVjdCB0MTBfYWx1YV9sdV9ncCAqbHVfZ3A7CisJc3RydWN0IHQxMF9hbHVhX2x1X2dwX21lbWJlciAqbHVfZ3BfbWVtLCAqbG9jYWxfbHVfZ3BfbWVtOworCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3A7CisJdW5zaWduZWQgY2hhciAqbWRfYnVmOworCWludCBwcmltYXJ5OworCisJaWYgKGNvcmVfYWx1YV9jaGVja190cmFuc2l0aW9uKG5ld19zdGF0ZSwgJnByaW1hcnkpICE9IDApCisJCXJldHVybiAtRUlOVkFMOworCisJbWRfYnVmID0ga3phbGxvYyhsX3RnX3B0X2dwLT50Z19wdF9ncF9tZF9idWZfbGVuLCBHRlBfS0VSTkVMKTsKKwlpZiAoIShtZF9idWYpKSB7CisJCXByaW50aygiVW5hYmxlIHRvIGFsbG9jYXRlIGJ1ZiBmb3IgQUxVQSBtZXRhZGF0YVxuIik7CisJCXJldHVybiAtRU5PTUVNOworCX0KKworCWxvY2FsX2x1X2dwX21lbSA9IGxfZGV2LT5kZXZfYWx1YV9sdV9ncF9tZW07CisJc3Bpbl9sb2NrKCZsb2NhbF9sdV9ncF9tZW0tPmx1X2dwX21lbV9sb2NrKTsKKwlsdV9ncCA9IGxvY2FsX2x1X2dwX21lbS0+bHVfZ3A7CisJYXRvbWljX2luYygmbHVfZ3AtPmx1X2dwX3JlZl9jbnQpOworCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2luYygpOworCXNwaW5fdW5sb2NrKCZsb2NhbF9sdV9ncF9tZW0tPmx1X2dwX21lbV9sb2NrKTsKKwkvKgorCSAqIEZvciBzdG9yYWdlIG9iamVjdHMgdGhhdCBhcmUgbWVtYmVycyBvZiB0aGUgJ2RlZmF1bHRfbHVfZ3AnLAorCSAqIHdlIG9ubHkgZG8gdHJhbnNpdGlvbiBvbiB0aGUgcGFzc2VkICpsX3RwX3B0X2dwLCBhbmQgbm90CisJICogb24gYWxsIG9mIHRoZSBtYXRjaGluZyB0YXJnZXQgcG9ydCBncm91cHMgSURzIGluIGRlZmF1bHRfbHVfZ3AuCisJICovCisJaWYgKCEobHVfZ3AtPmx1X2dwX2lkKSkgeworCQkvKgorCQkgKiBjb3JlX2FsdWFfZG9fdHJhbnNpdGlvbl90Z19wdCgpIHdpbGwgYWx3YXlzIHJldHVybgorCQkgKiBzdWNjZXNzLgorCQkgKi8KKwkJY29yZV9hbHVhX2RvX3RyYW5zaXRpb25fdGdfcHQobF90Z19wdF9ncCwgbF9wb3J0LCBsX25hY2wsCisJCQkJCW1kX2J1ZiwgbmV3X3N0YXRlLCBleHBsaWN0KTsKKwkJYXRvbWljX2RlYygmbHVfZ3AtPmx1X2dwX3JlZl9jbnQpOworCQlzbXBfbWJfX2FmdGVyX2F0b21pY19kZWMoKTsKKwkJa2ZyZWUobWRfYnVmKTsKKwkJcmV0dXJuIDA7CisJfQorCS8qCisJICogRm9yIGFsbCBvdGhlciBMVSBncm91cHMgYXNpZGUgZnJvbSAnZGVmYXVsdF9sdV9ncCcsIHdhbGsgYWxsIG9mCisJICogdGhlIGFzc29jaWF0ZWQgc3RvcmFnZSBvYmplY3RzIGxvb2tpbmcgZm9yIGEgbWF0Y2hpbmcgdGFyZ2V0IHBvcnQKKwkgKiBncm91cCBJRCBmcm9tIHRoZSBsb2NhbCB0YXJnZXQgcG9ydCBncm91cC4KKwkgKi8KKwlzcGluX2xvY2soJmx1X2dwLT5sdV9ncF9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGx1X2dwX21lbSwgJmx1X2dwLT5sdV9ncF9tZW1fbGlzdCwKKwkJCQlsdV9ncF9tZW1fbGlzdCkgeworCisJCWRldiA9IGx1X2dwX21lbS0+bHVfZ3BfbWVtX2RldjsKKwkJc3VfZGV2ID0gZGV2LT5zZV9zdWJfZGV2OworCQlhdG9taWNfaW5jKCZsdV9ncF9tZW0tPmx1X2dwX21lbV9yZWZfY250KTsKKwkJc21wX21iX19hZnRlcl9hdG9taWNfaW5jKCk7CisJCXNwaW5fdW5sb2NrKCZsdV9ncC0+bHVfZ3BfbG9jayk7CisKKwkJc3Bpbl9sb2NrKCZUMTBfQUxVQShzdV9kZXYpLT50Z19wdF9ncHNfbG9jayk7CisJCWxpc3RfZm9yX2VhY2hfZW50cnkodGdfcHRfZ3AsCisJCQkJJlQxMF9BTFVBKHN1X2RldiktPnRnX3B0X2dwc19saXN0LAorCQkJCXRnX3B0X2dwX2xpc3QpIHsKKworCQkJaWYgKCEodGdfcHRfZ3AtPnRnX3B0X2dwX3ZhbGlkX2lkKSkKKwkJCQljb250aW51ZTsKKwkJCS8qCisJCQkgKiBJZiB0aGUgdGFyZ2V0IGJlaGF2aW9yIHBvcnQgYXN5bW1ldHJpYyBhY2Nlc3Mgc3RhdGUKKwkJCSAqIGlzIGNoYW5nZWQgZm9yIGFueSB0YXJnZXQgcG9ydCBncm91cCBhY2Nlc3NpYWJsZSB2aWEKKwkJCSAqIGEgbG9naWNhbCB1bml0IHdpdGhpbiBhIExVIGdyb3VwLCB0aGUgdGFyZ2V0IHBvcnQKKwkJCSAqIGJlaGF2aW9yIGdyb3VwIGFzeW1tZXRyaWMgYWNjZXNzIHN0YXRlcyBmb3IgdGhlIHNhbWUKKwkJCSAqIHRhcmdldCBwb3J0IGdyb3VwIGFjY2Vzc2libGUgdmlhIG90aGVyIGxvZ2ljYWwgdW5pdHMKKwkJCSAqIGluIHRoYXQgTFUgZ3JvdXAgd2lsbCBhbHNvIGNoYW5nZS4KKwkJCSAqLworCQkJaWYgKGxfdGdfcHRfZ3AtPnRnX3B0X2dwX2lkICE9IHRnX3B0X2dwLT50Z19wdF9ncF9pZCkKKwkJCQljb250aW51ZTsKKworCQkJaWYgKGxfdGdfcHRfZ3AgPT0gdGdfcHRfZ3ApIHsKKwkJCQlwb3J0ID0gbF9wb3J0OworCQkJCW5hY2wgPSBsX25hY2w7CisJCQl9IGVsc2UgeworCQkJCXBvcnQgPSBOVUxMOworCQkJCW5hY2wgPSBOVUxMOworCQkJfQorCQkJYXRvbWljX2luYygmdGdfcHRfZ3AtPnRnX3B0X2dwX3JlZl9jbnQpOworCQkJc21wX21iX19hZnRlcl9hdG9taWNfaW5jKCk7CisJCQlzcGluX3VubG9jaygmVDEwX0FMVUEoc3VfZGV2KS0+dGdfcHRfZ3BzX2xvY2spOworCQkJLyoKKwkJCSAqIGNvcmVfYWx1YV9kb190cmFuc2l0aW9uX3RnX3B0KCkgd2lsbCBhbHdheXMgcmV0dXJuCisJCQkgKiBzdWNjZXNzLgorCQkJICovCisJCQljb3JlX2FsdWFfZG9fdHJhbnNpdGlvbl90Z19wdCh0Z19wdF9ncCwgcG9ydCwKKwkJCQkJbmFjbCwgbWRfYnVmLCBuZXdfc3RhdGUsIGV4cGxpY3QpOworCisJCQlzcGluX2xvY2soJlQxMF9BTFVBKHN1X2RldiktPnRnX3B0X2dwc19sb2NrKTsKKwkJCWF0b21pY19kZWMoJnRnX3B0X2dwLT50Z19wdF9ncF9yZWZfY250KTsKKwkJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworCQl9CisJCXNwaW5fdW5sb2NrKCZUMTBfQUxVQShzdV9kZXYpLT50Z19wdF9ncHNfbG9jayk7CisKKwkJc3Bpbl9sb2NrKCZsdV9ncC0+bHVfZ3BfbG9jayk7CisJCWF0b21pY19kZWMoJmx1X2dwX21lbS0+bHVfZ3BfbWVtX3JlZl9jbnQpOworCQlzbXBfbWJfX2FmdGVyX2F0b21pY19kZWMoKTsKKwl9CisJc3Bpbl91bmxvY2soJmx1X2dwLT5sdV9ncF9sb2NrKTsKKworCXByaW50ayhLRVJOX0lORk8gIlN1Y2Nlc3NmdWxseSBwcm9jZXNzZWQgTFUgR3JvdXA6ICVzIGFsbCBBTFVBIFRHIFBUIgorCQkiIEdyb3VwIElEczogJWh1ICVzIHRyYW5zaXRpb24gdG8gcHJpbWFyeSBzdGF0ZTogJXNcbiIsCisJCWNvbmZpZ19pdGVtX25hbWUoJmx1X2dwLT5sdV9ncF9ncm91cC5jZ19pdGVtKSwKKwkJbF90Z19wdF9ncC0+dGdfcHRfZ3BfaWQsIChleHBsaWN0KSA/ICJleHBsaWN0IiA6ICJpbXBsaWN0IiwKKwkJY29yZV9hbHVhX2R1bXBfc3RhdGUobmV3X3N0YXRlKSk7CisKKwlhdG9taWNfZGVjKCZsdV9ncC0+bHVfZ3BfcmVmX2NudCk7CisJc21wX21iX19hZnRlcl9hdG9taWNfZGVjKCk7CisJa2ZyZWUobWRfYnVmKTsKKwlyZXR1cm4gMDsKK30KKworLyoKKyAqIENhbGxlZCB3aXRoIHRnX3B0X2dwX21lbS0+c2VwX3RnX3B0X21kX211dGV4IGhlbGQKKyAqLworc3RhdGljIGludCBjb3JlX2FsdWFfdXBkYXRlX3RwZ19zZWNvbmRhcnlfbWV0YWRhdGEoCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwX21lbWJlciAqdGdfcHRfZ3BfbWVtLAorCXN0cnVjdCBzZV9wb3J0ICpwb3J0LAorCXVuc2lnbmVkIGNoYXIgKm1kX2J1ZiwKKwl1MzIgbWRfYnVmX2xlbikKK3sKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcgPSBwb3J0LT5zZXBfdHBnOworCWNoYXIgcGF0aFtBTFVBX01FVEFEQVRBX1BBVEhfTEVOXSwgd3duW0FMVUFfU0VDT05EQVJZX01FVEFEQVRBX1dXTl9MRU5dOworCWludCBsZW47CisKKwltZW1zZXQocGF0aCwgMCwgQUxVQV9NRVRBREFUQV9QQVRIX0xFTik7CisJbWVtc2V0KHd3biwgMCwgQUxVQV9TRUNPTkRBUllfTUVUQURBVEFfV1dOX0xFTik7CisKKwlsZW4gPSBzbnByaW50Zih3d24sIEFMVUFfU0VDT05EQVJZX01FVEFEQVRBX1dXTl9MRU4sICIlcyIsCisJCQlUUEdfVEZPKHNlX3RwZyktPnRwZ19nZXRfd3duKHNlX3RwZykpOworCisJaWYgKFRQR19URk8oc2VfdHBnKS0+dHBnX2dldF90YWcgIT0gTlVMTCkKKwkJc25wcmludGYod3duK2xlbiwgQUxVQV9TRUNPTkRBUllfTUVUQURBVEFfV1dOX0xFTi1sZW4sICIrJWh1IiwKKwkJCQlUUEdfVEZPKHNlX3RwZyktPnRwZ19nZXRfdGFnKHNlX3RwZykpOworCisJbGVuID0gc25wcmludGYobWRfYnVmLCBtZF9idWZfbGVuLCAiYWx1YV90Z19wdF9vZmZsaW5lPSVkXG4iCisJCQkiYWx1YV90Z19wdF9zdGF0dXM9MHglMDJ4XG4iLAorCQkJYXRvbWljX3JlYWQoJnBvcnQtPnNlcF90Z19wdF9zZWNvbmRhcnlfb2ZmbGluZSksCisJCQlwb3J0LT5zZXBfdGdfcHRfc2Vjb25kYXJ5X3N0YXQpOworCisJc25wcmludGYocGF0aCwgQUxVQV9NRVRBREFUQV9QQVRIX0xFTiwgIi92YXIvdGFyZ2V0L2FsdWEvJXMvJXMvbHVuXyV1IiwKKwkJCVRQR19URk8oc2VfdHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksIHd3biwKKwkJCXBvcnQtPnNlcF9sdW4tPnVucGFja2VkX2x1bik7CisKKwlyZXR1cm4gY29yZV9hbHVhX3dyaXRlX3RwZ19tZXRhZGF0YShwYXRoLCBtZF9idWYsIGxlbik7Cit9CisKK3N0YXRpYyBpbnQgY29yZV9hbHVhX3NldF90Z19wdF9zZWNvbmRhcnlfc3RhdGUoCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwX21lbWJlciAqdGdfcHRfZ3BfbWVtLAorCXN0cnVjdCBzZV9wb3J0ICpwb3J0LAorCWludCBleHBsaWN0LAorCWludCBvZmZsaW5lKQoreworCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3A7CisJdW5zaWduZWQgY2hhciAqbWRfYnVmOworCXUzMiBtZF9idWZfbGVuOworCWludCB0cmFuc19kZWxheV9tc2VjczsKKworCXNwaW5fbG9jaygmdGdfcHRfZ3BfbWVtLT50Z19wdF9ncF9tZW1fbG9jayk7CisJdGdfcHRfZ3AgPSB0Z19wdF9ncF9tZW0tPnRnX3B0X2dwOworCWlmICghKHRnX3B0X2dwKSkgeworCQlzcGluX3VubG9jaygmdGdfcHRfZ3BfbWVtLT50Z19wdF9ncF9tZW1fbG9jayk7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGNvbXBsZXRlIHNlY29uZGFyeSBzdGF0ZSIKKwkJCQkiIHRyYW5zaXRpb25cbiIpOworCQlyZXR1cm4gLTE7CisJfQorCXRyYW5zX2RlbGF5X21zZWNzID0gdGdfcHRfZ3AtPnRnX3B0X2dwX3RyYW5zX2RlbGF5X21zZWNzOworCS8qCisJICogU2V0IHRoZSBzZWNvbmRhcnkgQUxVQSB0YXJnZXQgcG9ydCBhY2Nlc3Mgc3RhdGUgdG8gT0ZGTElORQorCSAqIG9yIHJlbGVhc2UgdGhlIHByZXZpb3VzbHkgc2Vjb25kYXJ5IHN0YXRlIGZvciBzdHJ1Y3Qgc2VfcG9ydAorCSAqLworCWlmIChvZmZsaW5lKQorCQlhdG9taWNfc2V0KCZwb3J0LT5zZXBfdGdfcHRfc2Vjb25kYXJ5X29mZmxpbmUsIDEpOworCWVsc2UKKwkJYXRvbWljX3NldCgmcG9ydC0+c2VwX3RnX3B0X3NlY29uZGFyeV9vZmZsaW5lLCAwKTsKKworCW1kX2J1Zl9sZW4gPSB0Z19wdF9ncC0+dGdfcHRfZ3BfbWRfYnVmX2xlbjsKKwlwb3J0LT5zZXBfdGdfcHRfc2Vjb25kYXJ5X3N0YXQgPSAoZXhwbGljdCkgPworCQkJQUxVQV9TVEFUVVNfQUxURVJFRF9CWV9FWFBMSUNUX1NUUEcgOgorCQkJQUxVQV9TVEFUVVNfQUxURVJFRF9CWV9JTVBMSUNUX0FMVUE7CisKKwlwcmludGsoS0VSTl9JTkZPICJTdWNjZXNzZnVsICVzIEFMVUEgdHJhbnNpdGlvbiBURyBQVCBHcm91cDogJXMgSUQ6ICVodSIKKwkJIiB0byBzZWNvbmRhcnkgYWNjZXNzIHN0YXRlOiAlc1xuIiwgKGV4cGxpY3QpID8gImV4cGxpY3QiIDoKKwkJImltcGxpY3QiLCBjb25maWdfaXRlbV9uYW1lKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfZ3JvdXAuY2dfaXRlbSksCisJCXRnX3B0X2dwLT50Z19wdF9ncF9pZCwgKG9mZmxpbmUpID8gIk9GRkxJTkUiIDogIk9OTElORSIpOworCisJc3Bpbl91bmxvY2soJnRnX3B0X2dwX21lbS0+dGdfcHRfZ3BfbWVtX2xvY2spOworCS8qCisJICogRG8gdGhlIG9wdGlvbmFsIHRyYW5zaXRpb24gZGVsYXkgYWZ0ZXIgd2Ugc2V0IHRoZSBzZWNvbmRhcnkKKwkgKiBBTFVBIGFjY2VzcyBzdGF0ZS4KKwkgKi8KKwlpZiAodHJhbnNfZGVsYXlfbXNlY3MgIT0gMCkKKwkJbXNsZWVwX2ludGVycnVwdGlibGUodHJhbnNfZGVsYXlfbXNlY3MpOworCS8qCisJICogU2VlIGlmIHdlIG5lZWQgdG8gdXBkYXRlIHRoZSBBTFVBIGZhYnJpYyBwb3J0IG1ldGFkYXRhIGZvcgorCSAqIHNlY29uZGFyeSBzdGF0ZSBhbmQgc3RhdHVzCisJICovCisJaWYgKHBvcnQtPnNlcF90Z19wdF9zZWNvbmRhcnlfd3JpdGVfbWQpIHsKKwkJbWRfYnVmID0ga3phbGxvYyhtZF9idWZfbGVuLCBHRlBfS0VSTkVMKTsKKwkJaWYgKCEobWRfYnVmKSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgbWRfYnVmIGZvciIKKwkJCQkiIHNlY29uZGFyeSBBTFVBIGFjY2VzcyBtZXRhZGF0YVxuIik7CisJCQlyZXR1cm4gLTE7CisJCX0KKwkJbXV0ZXhfbG9jaygmcG9ydC0+c2VwX3RnX3B0X21kX211dGV4KTsKKwkJY29yZV9hbHVhX3VwZGF0ZV90cGdfc2Vjb25kYXJ5X21ldGFkYXRhKHRnX3B0X2dwX21lbSwgcG9ydCwKKwkJCQltZF9idWYsIG1kX2J1Zl9sZW4pOworCQltdXRleF91bmxvY2soJnBvcnQtPnNlcF90Z19wdF9tZF9tdXRleCk7CisKKwkJa2ZyZWUobWRfYnVmKTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RydWN0IHQxMF9hbHVhX2x1X2dwICoKK2NvcmVfYWx1YV9hbGxvY2F0ZV9sdV9ncChjb25zdCBjaGFyICpuYW1lLCBpbnQgZGVmX2dyb3VwKQoreworCXN0cnVjdCB0MTBfYWx1YV9sdV9ncCAqbHVfZ3A7CisKKwlsdV9ncCA9IGttZW1fY2FjaGVfemFsbG9jKHQxMF9hbHVhX2x1X2dwX2NhY2hlLCBHRlBfS0VSTkVMKTsKKwlpZiAoIShsdV9ncCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgc3RydWN0IHQxMF9hbHVhX2x1X2dwXG4iKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7OworCX0KKwlJTklUX0xJU1RfSEVBRCgmbHVfZ3AtPmx1X2dwX2xpc3QpOworCUlOSVRfTElTVF9IRUFEKCZsdV9ncC0+bHVfZ3BfbWVtX2xpc3QpOworCXNwaW5fbG9ja19pbml0KCZsdV9ncC0+bHVfZ3BfbG9jayk7CisJYXRvbWljX3NldCgmbHVfZ3AtPmx1X2dwX3JlZl9jbnQsIDApOworCisJaWYgKGRlZl9ncm91cCkgeworCQlsdV9ncC0+bHVfZ3BfaWQgPSBzZV9nbG9iYWwtPmFsdWFfbHVfZ3BzX2NvdW50ZXIrKzs7CisJCWx1X2dwLT5sdV9ncF92YWxpZF9pZCA9IDE7CisJCXNlX2dsb2JhbC0+YWx1YV9sdV9ncHNfY291bnQrKzsKKwl9CisKKwlyZXR1cm4gbHVfZ3A7Cit9CisKK2ludCBjb3JlX2FsdWFfc2V0X2x1X2dwX2lkKHN0cnVjdCB0MTBfYWx1YV9sdV9ncCAqbHVfZ3AsIHUxNiBsdV9ncF9pZCkKK3sKKwlzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKmx1X2dwX3RtcDsKKwl1MTYgbHVfZ3BfaWRfdG1wOworCS8qCisJICogVGhlIGx1X2dwLT5sdV9ncF9pZCBtYXkgb25seSBiZSBzZXQgb25jZS4uCisJICovCisJaWYgKGx1X2dwLT5sdV9ncF92YWxpZF9pZCkgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJBTFVBIExVIEdyb3VwIGFscmVhZHkgaGFzIGEgdmFsaWQgSUQsIgorCQkJIiBpZ25vcmluZyByZXF1ZXN0XG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXNwaW5fbG9jaygmc2VfZ2xvYmFsLT5sdV9ncHNfbG9jayk7CisJaWYgKHNlX2dsb2JhbC0+YWx1YV9sdV9ncHNfY291bnQgPT0gMHgwMDAwZmZmZikgeworCQlwcmludGsoS0VSTl9FUlIgIk1heGltdW0gQUxVQSBzZV9nbG9iYWwtPmFsdWFfbHVfZ3BzX2NvdW50OiIKKwkJCQkiIDB4MDAwMGZmZmYgcmVhY2hlZFxuIik7CisJCXNwaW5fdW5sb2NrKCZzZV9nbG9iYWwtPmx1X2dwc19sb2NrKTsKKwkJa21lbV9jYWNoZV9mcmVlKHQxMF9hbHVhX2x1X2dwX2NhY2hlLCBsdV9ncCk7CisJCXJldHVybiAtMTsKKwl9CithZ2FpbjoKKwlsdV9ncF9pZF90bXAgPSAobHVfZ3BfaWQgIT0gMCkgPyBsdV9ncF9pZCA6CisJCQkJc2VfZ2xvYmFsLT5hbHVhX2x1X2dwc19jb3VudGVyKys7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGx1X2dwX3RtcCwgJnNlX2dsb2JhbC0+Z19sdV9ncHNfbGlzdCwgbHVfZ3BfbGlzdCkgeworCQlpZiAobHVfZ3BfdG1wLT5sdV9ncF9pZCA9PSBsdV9ncF9pZF90bXApIHsKKwkJCWlmICghKGx1X2dwX2lkKSkKKwkJCQlnb3RvIGFnYWluOworCisJCQlwcmludGsoS0VSTl9XQVJOSU5HICJBTFVBIExvZ2ljYWwgVW5pdCBHcm91cCBJRDogJWh1IgorCQkJCSIgYWxyZWFkeSBleGlzdHMsIGlnbm9yaW5nIHJlcXVlc3RcbiIsCisJCQkJbHVfZ3BfaWQpOworCQkJc3Bpbl91bmxvY2soJnNlX2dsb2JhbC0+bHVfZ3BzX2xvY2spOworCQkJcmV0dXJuIC0xOworCQl9CisJfQorCisJbHVfZ3AtPmx1X2dwX2lkID0gbHVfZ3BfaWRfdG1wOworCWx1X2dwLT5sdV9ncF92YWxpZF9pZCA9IDE7CisJbGlzdF9hZGRfdGFpbCgmbHVfZ3AtPmx1X2dwX2xpc3QsICZzZV9nbG9iYWwtPmdfbHVfZ3BzX2xpc3QpOworCXNlX2dsb2JhbC0+YWx1YV9sdV9ncHNfY291bnQrKzsKKwlzcGluX3VubG9jaygmc2VfZ2xvYmFsLT5sdV9ncHNfbG9jayk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCB0MTBfYWx1YV9sdV9ncF9tZW1iZXIgKgorY29yZV9hbHVhX2FsbG9jYXRlX2x1X2dwX21lbShzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHQxMF9hbHVhX2x1X2dwX21lbWJlciAqbHVfZ3BfbWVtOworCisJbHVfZ3BfbWVtID0ga21lbV9jYWNoZV96YWxsb2ModDEwX2FsdWFfbHVfZ3BfbWVtX2NhY2hlLCBHRlBfS0VSTkVMKTsKKwlpZiAoIShsdV9ncF9tZW0pKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIHN0cnVjdCB0MTBfYWx1YV9sdV9ncF9tZW1iZXJcbiIpOworCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKwl9CisJSU5JVF9MSVNUX0hFQUQoJmx1X2dwX21lbS0+bHVfZ3BfbWVtX2xpc3QpOworCXNwaW5fbG9ja19pbml0KCZsdV9ncF9tZW0tPmx1X2dwX21lbV9sb2NrKTsKKwlhdG9taWNfc2V0KCZsdV9ncF9tZW0tPmx1X2dwX21lbV9yZWZfY250LCAwKTsKKworCWx1X2dwX21lbS0+bHVfZ3BfbWVtX2RldiA9IGRldjsKKwlkZXYtPmRldl9hbHVhX2x1X2dwX21lbSA9IGx1X2dwX21lbTsKKworCXJldHVybiBsdV9ncF9tZW07Cit9CisKK3ZvaWQgY29yZV9hbHVhX2ZyZWVfbHVfZ3Aoc3RydWN0IHQxMF9hbHVhX2x1X2dwICpsdV9ncCkKK3sKKwlzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3BfbWVtYmVyICpsdV9ncF9tZW0sICpsdV9ncF9tZW1fdG1wOworCS8qCisJICogT25jZSB3ZSBoYXZlIHJlYWNoZWQgdGhpcyBwb2ludCwgY29uZmlnX2l0ZW1fcHV0KCkgaGFzCisJICogYWxyZWFkeSBiZWVuIGNhbGxlZCBmcm9tIHRhcmdldF9jb3JlX2FsdWFfZHJvcF9sdV9ncCgpLgorCSAqCisJICogSGVyZSwgd2UgcmVtb3ZlIHRoZSAqbHVfZ3AgZnJvbSB0aGUgZ2xvYmFsIGxpc3Qgc28gdGhhdAorCSAqIG5vIGFzc29jaWF0aW9ucyBjYW4gYmUgbWFkZSB3aGlsZSB3ZSBhcmUgcmVsZWFzaW5nCisJICogc3RydWN0IHQxMF9hbHVhX2x1X2dwLgorCSAqLworCXNwaW5fbG9jaygmc2VfZ2xvYmFsLT5sdV9ncHNfbG9jayk7CisJYXRvbWljX3NldCgmbHVfZ3AtPmx1X2dwX3NodXRkb3duLCAxKTsKKwlsaXN0X2RlbCgmbHVfZ3AtPmx1X2dwX2xpc3QpOworCXNlX2dsb2JhbC0+YWx1YV9sdV9ncHNfY291bnQtLTsKKwlzcGluX3VubG9jaygmc2VfZ2xvYmFsLT5sdV9ncHNfbG9jayk7CisJLyoKKwkgKiBBbGxvdyBzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKiByZWZlcmVuY2VkIGJ5IGNvcmVfYWx1YV9nZXRfbHVfZ3BfYnlfbmFtZSgpCisJICogaW4gdGFyZ2V0X2NvcmVfY29uZmlnZnMuYzp0YXJnZXRfY29yZV9zdG9yZV9hbHVhX2x1X2dwKCkgdG8gYmUKKwkgKiByZWxlYXNlZCB3aXRoIGNvcmVfYWx1YV9wdXRfbHVfZ3BfZnJvbV9uYW1lKCkKKwkgKi8KKwl3aGlsZSAoYXRvbWljX3JlYWQoJmx1X2dwLT5sdV9ncF9yZWZfY250KSkKKwkJY3B1X3JlbGF4KCk7CisJLyoKKwkgKiBSZWxlYXNlIHJlZmVyZW5jZSB0byBzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKiBmcm9tIGFsbCBhc3NvY2lhdGVkCisJICogc3RydWN0IHNlX2RldmljZS4KKwkgKi8KKwlzcGluX2xvY2soJmx1X2dwLT5sdV9ncF9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUobHVfZ3BfbWVtLCBsdV9ncF9tZW1fdG1wLAorCQkJCSZsdV9ncC0+bHVfZ3BfbWVtX2xpc3QsIGx1X2dwX21lbV9saXN0KSB7CisJCWlmIChsdV9ncF9tZW0tPmx1X2dwX2Fzc29jKSB7CisJCQlsaXN0X2RlbCgmbHVfZ3BfbWVtLT5sdV9ncF9tZW1fbGlzdCk7CisJCQlsdV9ncC0+bHVfZ3BfbWVtYmVycy0tOworCQkJbHVfZ3BfbWVtLT5sdV9ncF9hc3NvYyA9IDA7CisJCX0KKwkJc3Bpbl91bmxvY2soJmx1X2dwLT5sdV9ncF9sb2NrKTsKKwkJLyoKKwkJICoKKwkJICogbHVfZ3BfbWVtIGlzIGFzc29pY2F0ZWQgd2l0aCBhIHNpbmdsZQorCQkgKiBzdHJ1Y3Qgc2VfZGV2aWNlLT5kZXZfYWx1YV9sdV9ncF9tZW0sIGFuZCBpcyByZWxlYXNlZCB3aGVuCisJCSAqIHN0cnVjdCBzZV9kZXZpY2UgaXMgcmVsZWFzZWQgdmlhIGNvcmVfYWx1YV9mcmVlX2x1X2dwX21lbSgpLgorCQkgKgorCQkgKiBJZiB0aGUgcGFzc2VkIGx1X2dwIGRvZXMgTk9UIG1hdGNoIHRoZSBkZWZhdWx0X2x1X2dwLCBhc3N1bWUKKwkJICogd2Ugd2FudCB0byByZS1hc3NvY2F0ZSBhIGdpdmVuIGx1X2dwX21lbSB3aXRoIGRlZmF1bHRfbHVfZ3AuCisJCSAqLworCQlzcGluX2xvY2soJmx1X2dwX21lbS0+bHVfZ3BfbWVtX2xvY2spOworCQlpZiAobHVfZ3AgIT0gc2VfZ2xvYmFsLT5kZWZhdWx0X2x1X2dwKQorCQkJX19jb3JlX2FsdWFfYXR0YWNoX2x1X2dwX21lbShsdV9ncF9tZW0sCisJCQkJCXNlX2dsb2JhbC0+ZGVmYXVsdF9sdV9ncCk7CisJCWVsc2UKKwkJCWx1X2dwX21lbS0+bHVfZ3AgPSBOVUxMOworCQlzcGluX3VubG9jaygmbHVfZ3BfbWVtLT5sdV9ncF9tZW1fbG9jayk7CisKKwkJc3Bpbl9sb2NrKCZsdV9ncC0+bHVfZ3BfbG9jayk7CisJfQorCXNwaW5fdW5sb2NrKCZsdV9ncC0+bHVfZ3BfbG9jayk7CisKKwlrbWVtX2NhY2hlX2ZyZWUodDEwX2FsdWFfbHVfZ3BfY2FjaGUsIGx1X2dwKTsKK30KKwordm9pZCBjb3JlX2FsdWFfZnJlZV9sdV9ncF9tZW0oc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXYgPSBkZXYtPnNlX3N1Yl9kZXY7CisJc3RydWN0IHQxMF9hbHVhICphbHVhID0gVDEwX0FMVUEoc3VfZGV2KTsKKwlzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKmx1X2dwOworCXN0cnVjdCB0MTBfYWx1YV9sdV9ncF9tZW1iZXIgKmx1X2dwX21lbTsKKworCWlmIChhbHVhLT5hbHVhX3R5cGUgIT0gU1BDM19BTFVBX0VNVUxBVEVEKQorCQlyZXR1cm47CisKKwlsdV9ncF9tZW0gPSBkZXYtPmRldl9hbHVhX2x1X2dwX21lbTsKKwlpZiAoIShsdV9ncF9tZW0pKQorCQlyZXR1cm47CisKKwl3aGlsZSAoYXRvbWljX3JlYWQoJmx1X2dwX21lbS0+bHVfZ3BfbWVtX3JlZl9jbnQpKQorCQljcHVfcmVsYXgoKTsKKworCXNwaW5fbG9jaygmbHVfZ3BfbWVtLT5sdV9ncF9tZW1fbG9jayk7CisJbHVfZ3AgPSBsdV9ncF9tZW0tPmx1X2dwOworCWlmICgobHVfZ3ApKSB7CisJCXNwaW5fbG9jaygmbHVfZ3AtPmx1X2dwX2xvY2spOworCQlpZiAobHVfZ3BfbWVtLT5sdV9ncF9hc3NvYykgeworCQkJbGlzdF9kZWwoJmx1X2dwX21lbS0+bHVfZ3BfbWVtX2xpc3QpOworCQkJbHVfZ3AtPmx1X2dwX21lbWJlcnMtLTsKKwkJCWx1X2dwX21lbS0+bHVfZ3BfYXNzb2MgPSAwOworCQl9CisJCXNwaW5fdW5sb2NrKCZsdV9ncC0+bHVfZ3BfbG9jayk7CisJCWx1X2dwX21lbS0+bHVfZ3AgPSBOVUxMOworCX0KKwlzcGluX3VubG9jaygmbHVfZ3BfbWVtLT5sdV9ncF9tZW1fbG9jayk7CisKKwlrbWVtX2NhY2hlX2ZyZWUodDEwX2FsdWFfbHVfZ3BfbWVtX2NhY2hlLCBsdV9ncF9tZW0pOworfQorCitzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKmNvcmVfYWx1YV9nZXRfbHVfZ3BfYnlfbmFtZShjb25zdCBjaGFyICpuYW1lKQoreworCXN0cnVjdCB0MTBfYWx1YV9sdV9ncCAqbHVfZ3A7CisJc3RydWN0IGNvbmZpZ19pdGVtICpjaTsKKworCXNwaW5fbG9jaygmc2VfZ2xvYmFsLT5sdV9ncHNfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShsdV9ncCwgJnNlX2dsb2JhbC0+Z19sdV9ncHNfbGlzdCwgbHVfZ3BfbGlzdCkgeworCQlpZiAoIShsdV9ncC0+bHVfZ3BfdmFsaWRfaWQpKQorCQkJY29udGludWU7CisJCWNpID0gJmx1X2dwLT5sdV9ncF9ncm91cC5jZ19pdGVtOworCQlpZiAoIShzdHJjbXAoY29uZmlnX2l0ZW1fbmFtZShjaSksIG5hbWUpKSkgeworCQkJYXRvbWljX2luYygmbHVfZ3AtPmx1X2dwX3JlZl9jbnQpOworCQkJc3Bpbl91bmxvY2soJnNlX2dsb2JhbC0+bHVfZ3BzX2xvY2spOworCQkJcmV0dXJuIGx1X2dwOworCQl9CisJfQorCXNwaW5fdW5sb2NrKCZzZV9nbG9iYWwtPmx1X2dwc19sb2NrKTsKKworCXJldHVybiBOVUxMOworfQorCit2b2lkIGNvcmVfYWx1YV9wdXRfbHVfZ3BfZnJvbV9uYW1lKHN0cnVjdCB0MTBfYWx1YV9sdV9ncCAqbHVfZ3ApCit7CisJc3Bpbl9sb2NrKCZzZV9nbG9iYWwtPmx1X2dwc19sb2NrKTsKKwlhdG9taWNfZGVjKCZsdV9ncC0+bHVfZ3BfcmVmX2NudCk7CisJc3Bpbl91bmxvY2soJnNlX2dsb2JhbC0+bHVfZ3BzX2xvY2spOworfQorCisvKgorICogQ2FsbGVkIHdpdGggc3RydWN0IHQxMF9hbHVhX2x1X2dwX21lbWJlci0+bHVfZ3BfbWVtX2xvY2sKKyAqLwordm9pZCBfX2NvcmVfYWx1YV9hdHRhY2hfbHVfZ3BfbWVtKAorCXN0cnVjdCB0MTBfYWx1YV9sdV9ncF9tZW1iZXIgKmx1X2dwX21lbSwKKwlzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKmx1X2dwKQoreworCXNwaW5fbG9jaygmbHVfZ3AtPmx1X2dwX2xvY2spOworCWx1X2dwX21lbS0+bHVfZ3AgPSBsdV9ncDsKKwlsdV9ncF9tZW0tPmx1X2dwX2Fzc29jID0gMTsKKwlsaXN0X2FkZF90YWlsKCZsdV9ncF9tZW0tPmx1X2dwX21lbV9saXN0LCAmbHVfZ3AtPmx1X2dwX21lbV9saXN0KTsKKwlsdV9ncC0+bHVfZ3BfbWVtYmVycysrOworCXNwaW5fdW5sb2NrKCZsdV9ncC0+bHVfZ3BfbG9jayk7Cit9CisKKy8qCisgKiBDYWxsZWQgd2l0aCBzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3BfbWVtYmVyLT5sdV9ncF9tZW1fbG9jaworICovCit2b2lkIF9fY29yZV9hbHVhX2Ryb3BfbHVfZ3BfbWVtKAorCXN0cnVjdCB0MTBfYWx1YV9sdV9ncF9tZW1iZXIgKmx1X2dwX21lbSwKKwlzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKmx1X2dwKQoreworCXNwaW5fbG9jaygmbHVfZ3AtPmx1X2dwX2xvY2spOworCWxpc3RfZGVsKCZsdV9ncF9tZW0tPmx1X2dwX21lbV9saXN0KTsKKwlsdV9ncF9tZW0tPmx1X2dwID0gTlVMTDsKKwlsdV9ncF9tZW0tPmx1X2dwX2Fzc29jID0gMDsKKwlsdV9ncC0+bHVfZ3BfbWVtYmVycy0tOworCXNwaW5fdW5sb2NrKCZsdV9ncC0+bHVfZ3BfbG9jayk7Cit9CisKK3N0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqY29yZV9hbHVhX2FsbG9jYXRlX3RnX3B0X2dwKAorCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXYsCisJY29uc3QgY2hhciAqbmFtZSwKKwlpbnQgZGVmX2dyb3VwKQoreworCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3A7CisKKwl0Z19wdF9ncCA9IGttZW1fY2FjaGVfemFsbG9jKHQxMF9hbHVhX3RnX3B0X2dwX2NhY2hlLCBHRlBfS0VSTkVMKTsKKwlpZiAoISh0Z19wdF9ncCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwXG4iKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCUlOSVRfTElTVF9IRUFEKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJnRnX3B0X2dwLT50Z19wdF9ncF9tZW1fbGlzdCk7CisJbXV0ZXhfaW5pdCgmdGdfcHRfZ3AtPnRnX3B0X2dwX21kX211dGV4KTsKKwlzcGluX2xvY2tfaW5pdCgmdGdfcHRfZ3AtPnRnX3B0X2dwX2xvY2spOworCWF0b21pY19zZXQoJnRnX3B0X2dwLT50Z19wdF9ncF9yZWZfY250LCAwKTsKKwl0Z19wdF9ncC0+dGdfcHRfZ3Bfc3VfZGV2ID0gc3VfZGV2OworCXRnX3B0X2dwLT50Z19wdF9ncF9tZF9idWZfbGVuID0gQUxVQV9NRF9CVUZfTEVOOworCWF0b21pY19zZXQoJnRnX3B0X2dwLT50Z19wdF9ncF9hbHVhX2FjY2Vzc19zdGF0ZSwKKwkJQUxVQV9BQ0NFU1NfU1RBVEVfQUNUSVZFX09QVE1JWkVEKTsKKwkvKgorCSAqIEVuYWJsZSBib3RoIGV4cGxpY3QgYW5kIGltcGxpY3QgQUxVQSBzdXBwb3J0IGJ5IGRlZmF1bHQKKwkgKi8KKwl0Z19wdF9ncC0+dGdfcHRfZ3BfYWx1YV9hY2Nlc3NfdHlwZSA9CisJCQlUUEdTX0VYUExJQ1RfQUxVQSB8IFRQR1NfSU1QTElDVF9BTFVBOworCS8qCisJICogU2V0IHRoZSBkZWZhdWx0IEFjdGl2ZS9Ob25PcHRpbWl6ZWQgRGVsYXkgaW4gbWlsbGlzZWNvbmRzCisJICovCisJdGdfcHRfZ3AtPnRnX3B0X2dwX25vbm9wX2RlbGF5X21zZWNzID0gQUxVQV9ERUZBVUxUX05PTk9QX0RFTEFZX01TRUNTOworCXRnX3B0X2dwLT50Z19wdF9ncF90cmFuc19kZWxheV9tc2VjcyA9IEFMVUFfREVGQVVMVF9UUkFOU19ERUxBWV9NU0VDUzsKKworCWlmIChkZWZfZ3JvdXApIHsKKwkJc3Bpbl9sb2NrKCZUMTBfQUxVQShzdV9kZXYpLT50Z19wdF9ncHNfbG9jayk7CisJCXRnX3B0X2dwLT50Z19wdF9ncF9pZCA9CisJCQkJVDEwX0FMVUEoc3VfZGV2KS0+YWx1YV90Z19wdF9ncHNfY291bnRlcisrOworCQl0Z19wdF9ncC0+dGdfcHRfZ3BfdmFsaWRfaWQgPSAxOworCQlUMTBfQUxVQShzdV9kZXYpLT5hbHVhX3RnX3B0X2dwc19jb3VudCsrOworCQlsaXN0X2FkZF90YWlsKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfbGlzdCwKKwkJCSAgICAgICZUMTBfQUxVQShzdV9kZXYpLT50Z19wdF9ncHNfbGlzdCk7CisJCXNwaW5fdW5sb2NrKCZUMTBfQUxVQShzdV9kZXYpLT50Z19wdF9ncHNfbG9jayk7CisJfQorCisJcmV0dXJuIHRnX3B0X2dwOworfQorCitpbnQgY29yZV9hbHVhX3NldF90Z19wdF9ncF9pZCgKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwLAorCXUxNiB0Z19wdF9ncF9pZCkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2ID0gdGdfcHRfZ3AtPnRnX3B0X2dwX3N1X2RldjsKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwX3RtcDsKKwl1MTYgdGdfcHRfZ3BfaWRfdG1wOworCS8qCisJICogVGhlIHRnX3B0X2dwLT50Z19wdF9ncF9pZCBtYXkgb25seSBiZSBzZXQgb25jZS4uCisJICovCisJaWYgKHRnX3B0X2dwLT50Z19wdF9ncF92YWxpZF9pZCkgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJBTFVBIFRHIFBUIEdyb3VwIGFscmVhZHkgaGFzIGEgdmFsaWQgSUQsIgorCQkJIiBpZ25vcmluZyByZXF1ZXN0XG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXNwaW5fbG9jaygmVDEwX0FMVUEoc3VfZGV2KS0+dGdfcHRfZ3BzX2xvY2spOworCWlmIChUMTBfQUxVQShzdV9kZXYpLT5hbHVhX3RnX3B0X2dwc19jb3VudCA9PSAweDAwMDBmZmZmKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWF4aW11bSBBTFVBIGFsdWFfdGdfcHRfZ3BzX2NvdW50OiIKKwkJCSIgMHgwMDAwZmZmZiByZWFjaGVkXG4iKTsKKwkJc3Bpbl91bmxvY2soJlQxMF9BTFVBKHN1X2RldiktPnRnX3B0X2dwc19sb2NrKTsKKwkJa21lbV9jYWNoZV9mcmVlKHQxMF9hbHVhX3RnX3B0X2dwX2NhY2hlLCB0Z19wdF9ncCk7CisJCXJldHVybiAtMTsKKwl9CithZ2FpbjoKKwl0Z19wdF9ncF9pZF90bXAgPSAodGdfcHRfZ3BfaWQgIT0gMCkgPyB0Z19wdF9ncF9pZCA6CisJCQlUMTBfQUxVQShzdV9kZXYpLT5hbHVhX3RnX3B0X2dwc19jb3VudGVyKys7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHRnX3B0X2dwX3RtcCwgJlQxMF9BTFVBKHN1X2RldiktPnRnX3B0X2dwc19saXN0LAorCQkJdGdfcHRfZ3BfbGlzdCkgeworCQlpZiAodGdfcHRfZ3BfdG1wLT50Z19wdF9ncF9pZCA9PSB0Z19wdF9ncF9pZF90bXApIHsKKwkJCWlmICghKHRnX3B0X2dwX2lkKSkKKwkJCQlnb3RvIGFnYWluOworCisJCQlwcmludGsoS0VSTl9FUlIgIkFMVUEgVGFyZ2V0IFBvcnQgR3JvdXAgSUQ6ICVodSBhbHJlYWR5IgorCQkJCSIgZXhpc3RzLCBpZ25vcmluZyByZXF1ZXN0XG4iLCB0Z19wdF9ncF9pZCk7CisJCQlzcGluX3VubG9jaygmVDEwX0FMVUEoc3VfZGV2KS0+dGdfcHRfZ3BzX2xvY2spOworCQkJcmV0dXJuIC0xOworCQl9CisJfQorCisJdGdfcHRfZ3AtPnRnX3B0X2dwX2lkID0gdGdfcHRfZ3BfaWRfdG1wOworCXRnX3B0X2dwLT50Z19wdF9ncF92YWxpZF9pZCA9IDE7CisJbGlzdF9hZGRfdGFpbCgmdGdfcHRfZ3AtPnRnX3B0X2dwX2xpc3QsCisJCQkmVDEwX0FMVUEoc3VfZGV2KS0+dGdfcHRfZ3BzX2xpc3QpOworCVQxMF9BTFVBKHN1X2RldiktPmFsdWFfdGdfcHRfZ3BzX2NvdW50Kys7CisJc3Bpbl91bmxvY2soJlQxMF9BTFVBKHN1X2RldiktPnRnX3B0X2dwc19sb2NrKTsKKworCXJldHVybiAwOworfQorCitzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3BfbWVtYmVyICpjb3JlX2FsdWFfYWxsb2NhdGVfdGdfcHRfZ3BfbWVtKAorCXN0cnVjdCBzZV9wb3J0ICpwb3J0KQoreworCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncF9tZW1iZXIgKnRnX3B0X2dwX21lbTsKKworCXRnX3B0X2dwX21lbSA9IGttZW1fY2FjaGVfemFsbG9jKHQxMF9hbHVhX3RnX3B0X2dwX21lbV9jYWNoZSwKKwkJCQlHRlBfS0VSTkVMKTsKKwlpZiAoISh0Z19wdF9ncF9tZW0pKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIHN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncF9tZW1iZXJcbiIpOworCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKwl9CisJSU5JVF9MSVNUX0hFQUQoJnRnX3B0X2dwX21lbS0+dGdfcHRfZ3BfbWVtX2xpc3QpOworCXNwaW5fbG9ja19pbml0KCZ0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9sb2NrKTsKKwlhdG9taWNfc2V0KCZ0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9yZWZfY250LCAwKTsKKworCXRnX3B0X2dwX21lbS0+dGdfcHQgPSBwb3J0OworCXBvcnQtPnNlcF9hbHVhX3RnX3B0X2dwX21lbSA9IHRnX3B0X2dwX21lbTsKKwlhdG9taWNfc2V0KCZwb3J0LT5zZXBfdGdfcHRfZ3BfYWN0aXZlLCAxKTsKKworCXJldHVybiB0Z19wdF9ncF9tZW07Cit9CisKK3ZvaWQgY29yZV9hbHVhX2ZyZWVfdGdfcHRfZ3AoCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncCkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2ID0gdGdfcHRfZ3AtPnRnX3B0X2dwX3N1X2RldjsKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3BfbWVtYmVyICp0Z19wdF9ncF9tZW0sICp0Z19wdF9ncF9tZW1fdG1wOworCS8qCisJICogT25jZSB3ZSBoYXZlIHJlYWNoZWQgdGhpcyBwb2ludCwgY29uZmlnX2l0ZW1fcHV0KCkgaGFzIGFscmVhZHkKKwkgKiBiZWVuIGNhbGxlZCBmcm9tIHRhcmdldF9jb3JlX2FsdWFfZHJvcF90Z19wdF9ncCgpLgorCSAqCisJICogSGVyZSB3ZSByZW1vdmUgKnRnX3B0X2dwIGZyb20gdGhlIGdsb2JhbCBsaXN0IHNvIHRoYXQKKwkgKiBubyBhc3NpY2F0aW9ucyAqT1IqIGV4cGxpY3QgQUxVQSB2aWEgU0VUX1RBUkdFVF9QT1JUX0dST1VQUworCSAqIGNhbiBiZSBtYWRlIHdoaWxlIHdlIGFyZSByZWxlYXNpbmcgc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwLgorCSAqLworCXNwaW5fbG9jaygmVDEwX0FMVUEoc3VfZGV2KS0+dGdfcHRfZ3BzX2xvY2spOworCWxpc3RfZGVsKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfbGlzdCk7CisJVDEwX0FMVUEoc3VfZGV2KS0+YWx1YV90Z19wdF9ncHNfY291bnRlci0tOworCXNwaW5fdW5sb2NrKCZUMTBfQUxVQShzdV9kZXYpLT50Z19wdF9ncHNfbG9jayk7CisJLyoKKwkgKiBBbGxvdyBhIHN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncF9tZW1iZXIgKiByZWZlcmVuY2VkIGJ5CisJICogY29yZV9hbHVhX2dldF90Z19wdF9ncF9ieV9uYW1lKCkgaW4KKwkgKiB0YXJnZXRfY29yZV9jb25maWdmcy5jOnRhcmdldF9jb3JlX3N0b3JlX2FsdWFfdGdfcHRfZ3AoKQorCSAqIHRvIGJlIHJlbGVhc2VkIHdpdGggY29yZV9hbHVhX3B1dF90Z19wdF9ncF9mcm9tX25hbWUoKS4KKwkgKi8KKwl3aGlsZSAoYXRvbWljX3JlYWQoJnRnX3B0X2dwLT50Z19wdF9ncF9yZWZfY250KSkKKwkJY3B1X3JlbGF4KCk7CisJLyoKKwkgKiBSZWxlYXNlIHJlZmVyZW5jZSB0byBzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgZnJvbSBhbGwgYXNzb2NpYXRlZAorCSAqIHN0cnVjdCBzZV9wb3J0LgorCSAqLworCXNwaW5fbG9jaygmdGdfcHRfZ3AtPnRnX3B0X2dwX2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSh0Z19wdF9ncF9tZW0sIHRnX3B0X2dwX21lbV90bXAsCisJCQkmdGdfcHRfZ3AtPnRnX3B0X2dwX21lbV9saXN0LCB0Z19wdF9ncF9tZW1fbGlzdCkgeworCQlpZiAodGdfcHRfZ3BfbWVtLT50Z19wdF9ncF9hc3NvYykgeworCQkJbGlzdF9kZWwoJnRnX3B0X2dwX21lbS0+dGdfcHRfZ3BfbWVtX2xpc3QpOworCQkJdGdfcHRfZ3AtPnRnX3B0X2dwX21lbWJlcnMtLTsKKwkJCXRnX3B0X2dwX21lbS0+dGdfcHRfZ3BfYXNzb2MgPSAwOworCQl9CisJCXNwaW5fdW5sb2NrKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfbG9jayk7CisJCS8qCisJCSAqIHRnX3B0X2dwX21lbSBpcyBhc3NvaWNhdGVkIHdpdGggYSBzaW5nbGUKKwkJICogc2VfcG9ydC0+c2VwX2FsdWFfdGdfcHRfZ3BfbWVtLCBhbmQgaXMgcmVsZWFzZWQgdmlhCisJCSAqIGNvcmVfYWx1YV9mcmVlX3RnX3B0X2dwX21lbSgpLgorCQkgKgorCQkgKiBJZiB0aGUgcGFzc2VkIHRnX3B0X2dwIGRvZXMgTk9UIG1hdGNoIHRoZSBkZWZhdWx0X3RnX3B0X2dwLAorCQkgKiBhc3N1bWUgd2Ugd2FudCB0byByZS1hc3NvY2F0ZSBhIGdpdmVuIHRnX3B0X2dwX21lbSB3aXRoCisJCSAqIGRlZmF1bHRfdGdfcHRfZ3AuCisJCSAqLworCQlzcGluX2xvY2soJnRnX3B0X2dwX21lbS0+dGdfcHRfZ3BfbWVtX2xvY2spOworCQlpZiAodGdfcHRfZ3AgIT0gVDEwX0FMVUEoc3VfZGV2KS0+ZGVmYXVsdF90Z19wdF9ncCkgeworCQkJX19jb3JlX2FsdWFfYXR0YWNoX3RnX3B0X2dwX21lbSh0Z19wdF9ncF9tZW0sCisJCQkJCVQxMF9BTFVBKHN1X2RldiktPmRlZmF1bHRfdGdfcHRfZ3ApOworCQl9IGVsc2UKKwkJCXRnX3B0X2dwX21lbS0+dGdfcHRfZ3AgPSBOVUxMOworCQlzcGluX3VubG9jaygmdGdfcHRfZ3BfbWVtLT50Z19wdF9ncF9tZW1fbG9jayk7CisKKwkJc3Bpbl9sb2NrKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfbG9jayk7CisJfQorCXNwaW5fdW5sb2NrKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfbG9jayk7CisKKwlrbWVtX2NhY2hlX2ZyZWUodDEwX2FsdWFfdGdfcHRfZ3BfY2FjaGUsIHRnX3B0X2dwKTsKK30KKwordm9pZCBjb3JlX2FsdWFfZnJlZV90Z19wdF9ncF9tZW0oc3RydWN0IHNlX3BvcnQgKnBvcnQpCit7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnN1X2RldiA9IHBvcnQtPnNlcF9sdW4tPmx1bl9zZV9kZXYtPnNlX3N1Yl9kZXY7CisJc3RydWN0IHQxMF9hbHVhICphbHVhID0gVDEwX0FMVUEoc3VfZGV2KTsKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwOworCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncF9tZW1iZXIgKnRnX3B0X2dwX21lbTsKKworCWlmIChhbHVhLT5hbHVhX3R5cGUgIT0gU1BDM19BTFVBX0VNVUxBVEVEKQorCQlyZXR1cm47CisKKwl0Z19wdF9ncF9tZW0gPSBwb3J0LT5zZXBfYWx1YV90Z19wdF9ncF9tZW07CisJaWYgKCEodGdfcHRfZ3BfbWVtKSkKKwkJcmV0dXJuOworCisJd2hpbGUgKGF0b21pY19yZWFkKCZ0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9yZWZfY250KSkKKwkJY3B1X3JlbGF4KCk7CisKKwlzcGluX2xvY2soJnRnX3B0X2dwX21lbS0+dGdfcHRfZ3BfbWVtX2xvY2spOworCXRnX3B0X2dwID0gdGdfcHRfZ3BfbWVtLT50Z19wdF9ncDsKKwlpZiAoKHRnX3B0X2dwKSkgeworCQlzcGluX2xvY2soJnRnX3B0X2dwLT50Z19wdF9ncF9sb2NrKTsKKwkJaWYgKHRnX3B0X2dwX21lbS0+dGdfcHRfZ3BfYXNzb2MpIHsKKwkJCWxpc3RfZGVsKCZ0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9saXN0KTsKKwkJCXRnX3B0X2dwLT50Z19wdF9ncF9tZW1iZXJzLS07CisJCQl0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX2Fzc29jID0gMDsKKwkJfQorCQlzcGluX3VubG9jaygmdGdfcHRfZ3AtPnRnX3B0X2dwX2xvY2spOworCQl0Z19wdF9ncF9tZW0tPnRnX3B0X2dwID0gTlVMTDsKKwl9CisJc3Bpbl91bmxvY2soJnRnX3B0X2dwX21lbS0+dGdfcHRfZ3BfbWVtX2xvY2spOworCisJa21lbV9jYWNoZV9mcmVlKHQxMF9hbHVhX3RnX3B0X2dwX21lbV9jYWNoZSwgdGdfcHRfZ3BfbWVtKTsKK30KKworc3RhdGljIHN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqY29yZV9hbHVhX2dldF90Z19wdF9ncF9ieV9uYW1lKAorCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXYsCisJY29uc3QgY2hhciAqbmFtZSkKK3sKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwOworCXN0cnVjdCBjb25maWdfaXRlbSAqY2k7CisKKwlzcGluX2xvY2soJlQxMF9BTFVBKHN1X2RldiktPnRnX3B0X2dwc19sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHRnX3B0X2dwLCAmVDEwX0FMVUEoc3VfZGV2KS0+dGdfcHRfZ3BzX2xpc3QsCisJCQl0Z19wdF9ncF9saXN0KSB7CisJCWlmICghKHRnX3B0X2dwLT50Z19wdF9ncF92YWxpZF9pZCkpCisJCQljb250aW51ZTsKKwkJY2kgPSAmdGdfcHRfZ3AtPnRnX3B0X2dwX2dyb3VwLmNnX2l0ZW07CisJCWlmICghKHN0cmNtcChjb25maWdfaXRlbV9uYW1lKGNpKSwgbmFtZSkpKSB7CisJCQlhdG9taWNfaW5jKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfcmVmX2NudCk7CisJCQlzcGluX3VubG9jaygmVDEwX0FMVUEoc3VfZGV2KS0+dGdfcHRfZ3BzX2xvY2spOworCQkJcmV0dXJuIHRnX3B0X2dwOworCQl9CisJfQorCXNwaW5fdW5sb2NrKCZUMTBfQUxVQShzdV9kZXYpLT50Z19wdF9ncHNfbG9jayk7CisKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIHZvaWQgY29yZV9hbHVhX3B1dF90Z19wdF9ncF9mcm9tX25hbWUoCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncCkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2ID0gdGdfcHRfZ3AtPnRnX3B0X2dwX3N1X2RldjsKKworCXNwaW5fbG9jaygmVDEwX0FMVUEoc3VfZGV2KS0+dGdfcHRfZ3BzX2xvY2spOworCWF0b21pY19kZWMoJnRnX3B0X2dwLT50Z19wdF9ncF9yZWZfY250KTsKKwlzcGluX3VubG9jaygmVDEwX0FMVUEoc3VfZGV2KS0+dGdfcHRfZ3BzX2xvY2spOworfQorCisvKgorICogQ2FsbGVkIHdpdGggc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwX21lbWJlci0+dGdfcHRfZ3BfbWVtX2xvY2sgaGVsZAorICovCit2b2lkIF9fY29yZV9hbHVhX2F0dGFjaF90Z19wdF9ncF9tZW0oCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwX21lbWJlciAqdGdfcHRfZ3BfbWVtLAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3ApCit7CisJc3Bpbl9sb2NrKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfbG9jayk7CisJdGdfcHRfZ3BfbWVtLT50Z19wdF9ncCA9IHRnX3B0X2dwOworCXRnX3B0X2dwX21lbS0+dGdfcHRfZ3BfYXNzb2MgPSAxOworCWxpc3RfYWRkX3RhaWwoJnRnX3B0X2dwX21lbS0+dGdfcHRfZ3BfbWVtX2xpc3QsCisJCQkmdGdfcHRfZ3AtPnRnX3B0X2dwX21lbV9saXN0KTsKKwl0Z19wdF9ncC0+dGdfcHRfZ3BfbWVtYmVycysrOworCXNwaW5fdW5sb2NrKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfbG9jayk7Cit9CisKKy8qCisgKiBDYWxsZWQgd2l0aCBzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3BfbWVtYmVyLT50Z19wdF9ncF9tZW1fbG9jayBoZWxkCisgKi8KK3N0YXRpYyB2b2lkIF9fY29yZV9hbHVhX2Ryb3BfdGdfcHRfZ3BfbWVtKAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncF9tZW1iZXIgKnRnX3B0X2dwX21lbSwKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwKQoreworCXNwaW5fbG9jaygmdGdfcHRfZ3AtPnRnX3B0X2dwX2xvY2spOworCWxpc3RfZGVsKCZ0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9saXN0KTsKKwl0Z19wdF9ncF9tZW0tPnRnX3B0X2dwID0gTlVMTDsKKwl0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX2Fzc29jID0gMDsKKwl0Z19wdF9ncC0+dGdfcHRfZ3BfbWVtYmVycy0tOworCXNwaW5fdW5sb2NrKCZ0Z19wdF9ncC0+dGdfcHRfZ3BfbG9jayk7Cit9CisKK3NzaXplX3QgY29yZV9hbHVhX3Nob3dfdGdfcHRfZ3BfaW5mbyhzdHJ1Y3Qgc2VfcG9ydCAqcG9ydCwgY2hhciAqcGFnZSkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2ID0gcG9ydC0+c2VwX2x1bi0+bHVuX3NlX2Rldi0+c2Vfc3ViX2RldjsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW0gKnRnX3B0X2NpOworCXN0cnVjdCB0MTBfYWx1YSAqYWx1YSA9IFQxMF9BTFVBKHN1X2Rldik7CisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncDsKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3BfbWVtYmVyICp0Z19wdF9ncF9tZW07CisJc3NpemVfdCBsZW4gPSAwOworCisJaWYgKGFsdWEtPmFsdWFfdHlwZSAhPSBTUEMzX0FMVUFfRU1VTEFURUQpCisJCXJldHVybiBsZW47CisKKwl0Z19wdF9ncF9tZW0gPSBwb3J0LT5zZXBfYWx1YV90Z19wdF9ncF9tZW07CisJaWYgKCEodGdfcHRfZ3BfbWVtKSkKKwkJcmV0dXJuIGxlbjsKKworCXNwaW5fbG9jaygmdGdfcHRfZ3BfbWVtLT50Z19wdF9ncF9tZW1fbG9jayk7CisJdGdfcHRfZ3AgPSB0Z19wdF9ncF9tZW0tPnRnX3B0X2dwOworCWlmICgodGdfcHRfZ3ApKSB7CisJCXRnX3B0X2NpID0gJnRnX3B0X2dwLT50Z19wdF9ncF9ncm91cC5jZ19pdGVtOworCQlsZW4gKz0gc3ByaW50ZihwYWdlLCAiVEcgUG9ydCBBbGlhczogJXNcblRHIFBvcnQgR3JvdXAgSUQ6IgorCQkJIiAlaHVcblRHIFBvcnQgUHJpbWFyeSBBY2Nlc3MgU3RhdGU6ICVzXG5URyBQb3J0ICIKKwkJCSJQcmltYXJ5IEFjY2VzcyBTdGF0dXM6ICVzXG5URyBQb3J0IFNlY29uZGFyeSBBY2Nlc3MiCisJCQkiIFN0YXRlOiAlc1xuVEcgUG9ydCBTZWNvbmRhcnkgQWNjZXNzIFN0YXR1czogJXNcbiIsCisJCQljb25maWdfaXRlbV9uYW1lKHRnX3B0X2NpKSwgdGdfcHRfZ3AtPnRnX3B0X2dwX2lkLAorCQkJY29yZV9hbHVhX2R1bXBfc3RhdGUoYXRvbWljX3JlYWQoCisJCQkJCSZ0Z19wdF9ncC0+dGdfcHRfZ3BfYWx1YV9hY2Nlc3Nfc3RhdGUpKSwKKwkJCWNvcmVfYWx1YV9kdW1wX3N0YXR1cygKKwkJCQl0Z19wdF9ncC0+dGdfcHRfZ3BfYWx1YV9hY2Nlc3Nfc3RhdHVzKSwKKwkJCShhdG9taWNfcmVhZCgmcG9ydC0+c2VwX3RnX3B0X3NlY29uZGFyeV9vZmZsaW5lKSkgPworCQkJIk9mZmxpbmUiIDogIk5vbmUiLAorCQkJY29yZV9hbHVhX2R1bXBfc3RhdHVzKHBvcnQtPnNlcF90Z19wdF9zZWNvbmRhcnlfc3RhdCkpOworCX0KKwlzcGluX3VubG9jaygmdGdfcHRfZ3BfbWVtLT50Z19wdF9ncF9tZW1fbG9jayk7CisKKwlyZXR1cm4gbGVuOworfQorCitzc2l6ZV90IGNvcmVfYWx1YV9zdG9yZV90Z19wdF9ncF9pbmZvKAorCXN0cnVjdCBzZV9wb3J0ICpwb3J0LAorCWNvbnN0IGNoYXIgKnBhZ2UsCisJc2l6ZV90IGNvdW50KQoreworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZzsKKwlzdHJ1Y3Qgc2VfbHVuICpsdW47CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnN1X2RldiA9IHBvcnQtPnNlcF9sdW4tPmx1bl9zZV9kZXYtPnNlX3N1Yl9kZXY7CisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncCA9IE5VTEwsICp0Z19wdF9ncF9uZXcgPSBOVUxMOworCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncF9tZW1iZXIgKnRnX3B0X2dwX21lbTsKKwl1bnNpZ25lZCBjaGFyIGJ1ZltUR19QVF9HUk9VUF9OQU1FX0JVRl07CisJaW50IG1vdmUgPSAwOworCisJdHBnID0gcG9ydC0+c2VwX3RwZzsKKwlsdW4gPSBwb3J0LT5zZXBfbHVuOworCisJaWYgKFQxMF9BTFVBKHN1X2RldiktPmFsdWFfdHlwZSAhPSBTUEMzX0FMVUFfRU1VTEFURUQpIHsKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAiU1BDM19BTFVBX0VNVUxBVEVEIG5vdCBlbmFibGVkIGZvciIKKwkJCSIgJXMvdHBndF8laHUvJXNcbiIsIFRQR19URk8odHBnKS0+dHBnX2dldF93d24odHBnKSwKKwkJCVRQR19URk8odHBnKS0+dHBnX2dldF90YWcodHBnKSwKKwkJCWNvbmZpZ19pdGVtX25hbWUoJmx1bi0+bHVuX2dyb3VwLmNnX2l0ZW0pKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJaWYgKGNvdW50ID4gVEdfUFRfR1JPVVBfTkFNRV9CVUYpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJBTFVBIFRhcmdldCBQb3J0IEdyb3VwIGFsaWFzIHRvbyBsYXJnZSFcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJbWVtc2V0KGJ1ZiwgMCwgVEdfUFRfR1JPVVBfTkFNRV9CVUYpOworCW1lbWNweShidWYsIHBhZ2UsIGNvdW50KTsKKwkvKgorCSAqIEFueSBBTFVBIHRhcmdldCBwb3J0IGdyb3VwIGFsaWFzIGJlc2lkZXMgIk5VTEwiIG1lYW5zIHdlIHdpbGwgYmUKKwkgKiBtYWtpbmcgYSBuZXcgZ3JvdXAgYXNzb2NpYXRpb24uCisJICovCisJaWYgKHN0cmNtcChzdHJzdHJpcChidWYpLCAiTlVMTCIpKSB7CisJCS8qCisJCSAqIGNvcmVfYWx1YV9nZXRfdGdfcHRfZ3BfYnlfbmFtZSgpIHdpbGwgaW5jcmVtZW50IHJlZmVyZW5jZSB0bworCQkgKiBzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AuICBUaGlzIHJlZmVyZW5jZSBpcyByZWxlYXNlZCB3aXRoCisJCSAqIGNvcmVfYWx1YV9wdXRfdGdfcHRfZ3BfZnJvbV9uYW1lKCkgYmVsb3cuCisJCSAqLworCQl0Z19wdF9ncF9uZXcgPSBjb3JlX2FsdWFfZ2V0X3RnX3B0X2dwX2J5X25hbWUoc3VfZGV2LAorCQkJCQlzdHJzdHJpcChidWYpKTsKKwkJaWYgKCEodGdfcHRfZ3BfbmV3KSkKKwkJCXJldHVybiAtRU5PREVWOworCX0KKwl0Z19wdF9ncF9tZW0gPSBwb3J0LT5zZXBfYWx1YV90Z19wdF9ncF9tZW07CisJaWYgKCEodGdfcHRfZ3BfbWVtKSkgeworCQlpZiAodGdfcHRfZ3BfbmV3KQorCQkJY29yZV9hbHVhX3B1dF90Z19wdF9ncF9mcm9tX25hbWUodGdfcHRfZ3BfbmV3KTsKKwkJcHJpbnRrKEtFUk5fRVJSICJOVUxMIHN0cnVjdCBzZV9wb3J0LT5zZXBfYWx1YV90Z19wdF9ncF9tZW0gcG9pbnRlclxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXNwaW5fbG9jaygmdGdfcHRfZ3BfbWVtLT50Z19wdF9ncF9tZW1fbG9jayk7CisJdGdfcHRfZ3AgPSB0Z19wdF9ncF9tZW0tPnRnX3B0X2dwOworCWlmICgodGdfcHRfZ3ApKSB7CisJCS8qCisJCSAqIENsZWFyaW5nIGFuIGV4aXN0aW5nIHRnX3B0X2dwIGFzc29jaWF0aW9uLCBhbmQgcmVwbGFjaW5nCisJCSAqIHdpdGggdGhlIGRlZmF1bHRfdGdfcHRfZ3AuCisJCSAqLworCQlpZiAoISh0Z19wdF9ncF9uZXcpKSB7CisJCQlwcmludGsoS0VSTl9JTkZPICJUYXJnZXRfQ29yZV9Db25maWdGUzogTW92aW5nIgorCQkJCSIgJXMvdHBndF8laHUvJXMgZnJvbSBBTFVBIFRhcmdldCBQb3J0IEdyb3VwOiIKKwkJCQkiIGFsdWEvJXMsIElEOiAlaHUgYmFjayB0byIKKwkJCQkiIGRlZmF1bHRfdGdfcHRfZ3BcbiIsCisJCQkJVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3d3bih0cGcpLAorCQkJCVRQR19URk8odHBnKS0+dHBnX2dldF90YWcodHBnKSwKKwkJCQljb25maWdfaXRlbV9uYW1lKCZsdW4tPmx1bl9ncm91cC5jZ19pdGVtKSwKKwkJCQljb25maWdfaXRlbV9uYW1lKAorCQkJCQkmdGdfcHRfZ3AtPnRnX3B0X2dwX2dyb3VwLmNnX2l0ZW0pLAorCQkJCXRnX3B0X2dwLT50Z19wdF9ncF9pZCk7CisKKwkJCV9fY29yZV9hbHVhX2Ryb3BfdGdfcHRfZ3BfbWVtKHRnX3B0X2dwX21lbSwgdGdfcHRfZ3ApOworCQkJX19jb3JlX2FsdWFfYXR0YWNoX3RnX3B0X2dwX21lbSh0Z19wdF9ncF9tZW0sCisJCQkJCVQxMF9BTFVBKHN1X2RldiktPmRlZmF1bHRfdGdfcHRfZ3ApOworCQkJc3Bpbl91bmxvY2soJnRnX3B0X2dwX21lbS0+dGdfcHRfZ3BfbWVtX2xvY2spOworCisJCQlyZXR1cm4gY291bnQ7CisJCX0KKwkJLyoKKwkJICogUmVtb3ZpbmcgZXhpc3RpbmcgYXNzb2NpYXRpb24gb2YgdGdfcHRfZ3BfbWVtIHdpdGggdGdfcHRfZ3AKKwkJICovCisJCV9fY29yZV9hbHVhX2Ryb3BfdGdfcHRfZ3BfbWVtKHRnX3B0X2dwX21lbSwgdGdfcHRfZ3ApOworCQltb3ZlID0gMTsKKwl9CisJLyoKKwkgKiBBc3NvY2lhdGUgdGdfcHRfZ3BfbWVtIHdpdGggdGdfcHRfZ3BfbmV3LgorCSAqLworCV9fY29yZV9hbHVhX2F0dGFjaF90Z19wdF9ncF9tZW0odGdfcHRfZ3BfbWVtLCB0Z19wdF9ncF9uZXcpOworCXNwaW5fdW5sb2NrKCZ0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9sb2NrKTsKKwlwcmludGsoS0VSTl9JTkZPICJUYXJnZXRfQ29yZV9Db25maWdGUzogJXMgJXMvdHBndF8laHUvJXMgdG8gQUxVQSIKKwkJIiBUYXJnZXQgUG9ydCBHcm91cDogYWx1YS8lcywgSUQ6ICVodVxuIiwgKG1vdmUpID8KKwkJIk1vdmluZyIgOiAiQWRkaW5nIiwgVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3d3bih0cGcpLAorCQlUUEdfVEZPKHRwZyktPnRwZ19nZXRfdGFnKHRwZyksCisJCWNvbmZpZ19pdGVtX25hbWUoJmx1bi0+bHVuX2dyb3VwLmNnX2l0ZW0pLAorCQljb25maWdfaXRlbV9uYW1lKCZ0Z19wdF9ncF9uZXctPnRnX3B0X2dwX2dyb3VwLmNnX2l0ZW0pLAorCQl0Z19wdF9ncF9uZXctPnRnX3B0X2dwX2lkKTsKKworCWNvcmVfYWx1YV9wdXRfdGdfcHRfZ3BfZnJvbV9uYW1lKHRnX3B0X2dwX25ldyk7CisJcmV0dXJuIGNvdW50OworfQorCitzc2l6ZV90IGNvcmVfYWx1YV9zaG93X2FjY2Vzc190eXBlKAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3AsCisJY2hhciAqcGFnZSkKK3sKKwlpZiAoKHRnX3B0X2dwLT50Z19wdF9ncF9hbHVhX2FjY2Vzc190eXBlICYgVFBHU19FWFBMSUNUX0FMVUEpICYmCisJICAgICh0Z19wdF9ncC0+dGdfcHRfZ3BfYWx1YV9hY2Nlc3NfdHlwZSAmIFRQR1NfSU1QTElDVF9BTFVBKSkKKwkJcmV0dXJuIHNwcmludGYocGFnZSwgIkltcGxpY3QgYW5kIEV4cGxpY3RcbiIpOworCWVsc2UgaWYgKHRnX3B0X2dwLT50Z19wdF9ncF9hbHVhX2FjY2Vzc190eXBlICYgVFBHU19JTVBMSUNUX0FMVUEpCisJCXJldHVybiBzcHJpbnRmKHBhZ2UsICJJbXBsaWN0XG4iKTsKKwllbHNlIGlmICh0Z19wdF9ncC0+dGdfcHRfZ3BfYWx1YV9hY2Nlc3NfdHlwZSAmIFRQR1NfRVhQTElDVF9BTFVBKQorCQlyZXR1cm4gc3ByaW50ZihwYWdlLCAiRXhwbGljdFxuIik7CisJZWxzZQorCQlyZXR1cm4gc3ByaW50ZihwYWdlLCAiTm9uZVxuIik7Cit9CisKK3NzaXplX3QgY29yZV9hbHVhX3N0b3JlX2FjY2Vzc190eXBlKAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3AsCisJY29uc3QgY2hhciAqcGFnZSwKKwlzaXplX3QgY291bnQpCit7CisJdW5zaWduZWQgbG9uZyB0bXA7CisJaW50IHJldDsKKworCXJldCA9IHN0cmljdF9zdHJ0b3VsKHBhZ2UsIDAsICZ0bXApOworCWlmIChyZXQgPCAwKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGV4dHJhY3QgYWx1YV9hY2Nlc3NfdHlwZVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoKHRtcCAhPSAwKSAmJiAodG1wICE9IDEpICYmICh0bXAgIT0gMikgJiYgKHRtcCAhPSAzKSkgeworCQlwcmludGsoS0VSTl9FUlIgIklsbGVnYWwgdmFsdWUgZm9yIGFsdWFfYWNjZXNzX3R5cGU6IgorCQkJCSIgJWx1XG4iLCB0bXApOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKHRtcCA9PSAzKQorCQl0Z19wdF9ncC0+dGdfcHRfZ3BfYWx1YV9hY2Nlc3NfdHlwZSA9CisJCQlUUEdTX0lNUExJQ1RfQUxVQSB8IFRQR1NfRVhQTElDVF9BTFVBOworCWVsc2UgaWYgKHRtcCA9PSAyKQorCQl0Z19wdF9ncC0+dGdfcHRfZ3BfYWx1YV9hY2Nlc3NfdHlwZSA9IFRQR1NfRVhQTElDVF9BTFVBOworCWVsc2UgaWYgKHRtcCA9PSAxKQorCQl0Z19wdF9ncC0+dGdfcHRfZ3BfYWx1YV9hY2Nlc3NfdHlwZSA9IFRQR1NfSU1QTElDVF9BTFVBOworCWVsc2UKKwkJdGdfcHRfZ3AtPnRnX3B0X2dwX2FsdWFfYWNjZXNzX3R5cGUgPSAwOworCisJcmV0dXJuIGNvdW50OworfQorCitzc2l6ZV90IGNvcmVfYWx1YV9zaG93X25vbm9wX2RlbGF5X21zZWNzKAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3AsCisJY2hhciAqcGFnZSkKK3sKKwlyZXR1cm4gc3ByaW50ZihwYWdlLCAiJWRcbiIsIHRnX3B0X2dwLT50Z19wdF9ncF9ub25vcF9kZWxheV9tc2Vjcyk7Cit9CisKK3NzaXplX3QgY29yZV9hbHVhX3N0b3JlX25vbm9wX2RlbGF5X21zZWNzKAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3AsCisJY29uc3QgY2hhciAqcGFnZSwKKwlzaXplX3QgY291bnQpCit7CisJdW5zaWduZWQgbG9uZyB0bXA7CisJaW50IHJldDsKKworCXJldCA9IHN0cmljdF9zdHJ0b3VsKHBhZ2UsIDAsICZ0bXApOworCWlmIChyZXQgPCAwKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGV4dHJhY3Qgbm9ub3BfZGVsYXlfbXNlY3NcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKHRtcCA+IEFMVUFfTUFYX05PTk9QX0RFTEFZX01TRUNTKSB7CisJCXByaW50ayhLRVJOX0VSUiAiUGFzc2VkIG5vbm9wX2RlbGF5X21zZWNzOiAlbHUsIGV4Y2VlZHMiCisJCQkiIEFMVUFfTUFYX05PTk9QX0RFTEFZX01TRUNTOiAlZFxuIiwgdG1wLAorCQkJQUxVQV9NQVhfTk9OT1BfREVMQVlfTVNFQ1MpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJdGdfcHRfZ3AtPnRnX3B0X2dwX25vbm9wX2RlbGF5X21zZWNzID0gKGludCl0bXA7CisKKwlyZXR1cm4gY291bnQ7Cit9CisKK3NzaXplX3QgY29yZV9hbHVhX3Nob3dfdHJhbnNfZGVsYXlfbXNlY3MoCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncCwKKwljaGFyICpwYWdlKQoreworCXJldHVybiBzcHJpbnRmKHBhZ2UsICIlZFxuIiwgdGdfcHRfZ3AtPnRnX3B0X2dwX3RyYW5zX2RlbGF5X21zZWNzKTsKK30KKworc3NpemVfdCBjb3JlX2FsdWFfc3RvcmVfdHJhbnNfZGVsYXlfbXNlY3MoCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncCwKKwljb25zdCBjaGFyICpwYWdlLAorCXNpemVfdCBjb3VudCkKK3sKKwl1bnNpZ25lZCBsb25nIHRtcDsKKwlpbnQgcmV0OworCisJcmV0ID0gc3RyaWN0X3N0cnRvdWwocGFnZSwgMCwgJnRtcCk7CisJaWYgKHJldCA8IDApIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gZXh0cmFjdCB0cmFuc19kZWxheV9tc2Vjc1xuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAodG1wID4gQUxVQV9NQVhfVFJBTlNfREVMQVlfTVNFQ1MpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJQYXNzZWQgdHJhbnNfZGVsYXlfbXNlY3M6ICVsdSwgZXhjZWVkcyIKKwkJCSIgQUxVQV9NQVhfVFJBTlNfREVMQVlfTVNFQ1M6ICVkXG4iLCB0bXAsCisJCQlBTFVBX01BWF9UUkFOU19ERUxBWV9NU0VDUyk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwl0Z19wdF9ncC0+dGdfcHRfZ3BfdHJhbnNfZGVsYXlfbXNlY3MgPSAoaW50KXRtcDsKKworCXJldHVybiBjb3VudDsKK30KKworc3NpemVfdCBjb3JlX2FsdWFfc2hvd19wcmVmZXJyZWRfYml0KAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3AsCisJY2hhciAqcGFnZSkKK3sKKwlyZXR1cm4gc3ByaW50ZihwYWdlLCAiJWRcbiIsIHRnX3B0X2dwLT50Z19wdF9ncF9wcmVmKTsKK30KKworc3NpemVfdCBjb3JlX2FsdWFfc3RvcmVfcHJlZmVycmVkX2JpdCgKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwLAorCWNvbnN0IGNoYXIgKnBhZ2UsCisJc2l6ZV90IGNvdW50KQoreworCXVuc2lnbmVkIGxvbmcgdG1wOworCWludCByZXQ7CisKKwlyZXQgPSBzdHJpY3Rfc3RydG91bChwYWdlLCAwLCAmdG1wKTsKKwlpZiAocmV0IDwgMCkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBleHRyYWN0IHByZWZlcnJlZCBBTFVBIHZhbHVlXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmICgodG1wICE9IDApICYmICh0bXAgIT0gMSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJJbGxlZ2FsIHZhbHVlIGZvciBwcmVmZXJyZWQgQUxVQTogJWx1XG4iLCB0bXApOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJdGdfcHRfZ3AtPnRnX3B0X2dwX3ByZWYgPSAoaW50KXRtcDsKKworCXJldHVybiBjb3VudDsKK30KKworc3NpemVfdCBjb3JlX2FsdWFfc2hvd19vZmZsaW5lX2JpdChzdHJ1Y3Qgc2VfbHVuICpsdW4sIGNoYXIgKnBhZ2UpCit7CisJaWYgKCEobHVuLT5sdW5fc2VwKSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlyZXR1cm4gc3ByaW50ZihwYWdlLCAiJWRcbiIsCisJCWF0b21pY19yZWFkKCZsdW4tPmx1bl9zZXAtPnNlcF90Z19wdF9zZWNvbmRhcnlfb2ZmbGluZSkpOworfQorCitzc2l6ZV90IGNvcmVfYWx1YV9zdG9yZV9vZmZsaW5lX2JpdCgKKwlzdHJ1Y3Qgc2VfbHVuICpsdW4sCisJY29uc3QgY2hhciAqcGFnZSwKKwlzaXplX3QgY291bnQpCit7CisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwX21lbWJlciAqdGdfcHRfZ3BfbWVtOworCXVuc2lnbmVkIGxvbmcgdG1wOworCWludCByZXQ7CisKKwlpZiAoIShsdW4tPmx1bl9zZXApKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCXJldCA9IHN0cmljdF9zdHJ0b3VsKHBhZ2UsIDAsICZ0bXApOworCWlmIChyZXQgPCAwKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGV4dHJhY3QgYWx1YV90Z19wdF9vZmZsaW5lIHZhbHVlXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmICgodG1wICE9IDApICYmICh0bXAgIT0gMSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJJbGxlZ2FsIHZhbHVlIGZvciBhbHVhX3RnX3B0X29mZmxpbmU6ICVsdVxuIiwKKwkJCQl0bXApOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJdGdfcHRfZ3BfbWVtID0gbHVuLT5sdW5fc2VwLT5zZXBfYWx1YV90Z19wdF9ncF9tZW07CisJaWYgKCEodGdfcHRfZ3BfbWVtKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2NhdGUgKnRnX3B0X2dwX21lbVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXJldCA9IGNvcmVfYWx1YV9zZXRfdGdfcHRfc2Vjb25kYXJ5X3N0YXRlKHRnX3B0X2dwX21lbSwKKwkJCWx1bi0+bHVuX3NlcCwgMCwgKGludCl0bXApOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCXJldHVybiBjb3VudDsKK30KKworc3NpemVfdCBjb3JlX2FsdWFfc2hvd19zZWNvbmRhcnlfc3RhdHVzKAorCXN0cnVjdCBzZV9sdW4gKmx1biwKKwljaGFyICpwYWdlKQoreworCXJldHVybiBzcHJpbnRmKHBhZ2UsICIlZFxuIiwgbHVuLT5sdW5fc2VwLT5zZXBfdGdfcHRfc2Vjb25kYXJ5X3N0YXQpOworfQorCitzc2l6ZV90IGNvcmVfYWx1YV9zdG9yZV9zZWNvbmRhcnlfc3RhdHVzKAorCXN0cnVjdCBzZV9sdW4gKmx1biwKKwljb25zdCBjaGFyICpwYWdlLAorCXNpemVfdCBjb3VudCkKK3sKKwl1bnNpZ25lZCBsb25nIHRtcDsKKwlpbnQgcmV0OworCisJcmV0ID0gc3RyaWN0X3N0cnRvdWwocGFnZSwgMCwgJnRtcCk7CisJaWYgKHJldCA8IDApIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gZXh0cmFjdCBhbHVhX3RnX3B0X3N0YXR1c1xuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoKHRtcCAhPSBBTFVBX1NUQVRVU19OT05FKSAmJgorCSAgICAodG1wICE9IEFMVUFfU1RBVFVTX0FMVEVSRURfQllfRVhQTElDVF9TVFBHKSAmJgorCSAgICAodG1wICE9IEFMVUFfU1RBVFVTX0FMVEVSRURfQllfSU1QTElDVF9BTFVBKSkgeworCQlwcmludGsoS0VSTl9FUlIgIklsbGVnYWwgdmFsdWUgZm9yIGFsdWFfdGdfcHRfc3RhdHVzOiAlbHVcbiIsCisJCQkJdG1wKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWx1bi0+bHVuX3NlcC0+c2VwX3RnX3B0X3NlY29uZGFyeV9zdGF0ID0gKGludCl0bXA7CisKKwlyZXR1cm4gY291bnQ7Cit9CisKK3NzaXplX3QgY29yZV9hbHVhX3Nob3dfc2Vjb25kYXJ5X3dyaXRlX21ldGFkYXRhKAorCXN0cnVjdCBzZV9sdW4gKmx1biwKKwljaGFyICpwYWdlKQoreworCXJldHVybiBzcHJpbnRmKHBhZ2UsICIlZFxuIiwKKwkJCWx1bi0+bHVuX3NlcC0+c2VwX3RnX3B0X3NlY29uZGFyeV93cml0ZV9tZCk7Cit9CisKK3NzaXplX3QgY29yZV9hbHVhX3N0b3JlX3NlY29uZGFyeV93cml0ZV9tZXRhZGF0YSgKKwlzdHJ1Y3Qgc2VfbHVuICpsdW4sCisJY29uc3QgY2hhciAqcGFnZSwKKwlzaXplX3QgY291bnQpCit7CisJdW5zaWduZWQgbG9uZyB0bXA7CisJaW50IHJldDsKKworCXJldCA9IHN0cmljdF9zdHJ0b3VsKHBhZ2UsIDAsICZ0bXApOworCWlmIChyZXQgPCAwKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGV4dHJhY3QgYWx1YV90Z19wdF93cml0ZV9tZFxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoKHRtcCAhPSAwKSAmJiAodG1wICE9IDEpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiSWxsZWdhbCB2YWx1ZSBmb3IgYWx1YV90Z19wdF93cml0ZV9tZDoiCisJCQkJIiAlbHVcbiIsIHRtcCk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlsdW4tPmx1bl9zZXAtPnNlcF90Z19wdF9zZWNvbmRhcnlfd3JpdGVfbWQgPSAoaW50KXRtcDsKKworCXJldHVybiBjb3VudDsKK30KKworaW50IGNvcmVfc2V0dXBfYWx1YShzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsIGludCBmb3JjZV9wdCkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2ID0gZGV2LT5zZV9zdWJfZGV2OworCXN0cnVjdCB0MTBfYWx1YSAqYWx1YSA9IFQxMF9BTFVBKHN1X2Rldik7CisJc3RydWN0IHQxMF9hbHVhX2x1X2dwX21lbWJlciAqbHVfZ3BfbWVtOworCS8qCisJICogSWYgdGhpcyBkZXZpY2UgaXMgZnJvbSBUYXJnZXRfQ29yZV9Nb2QvcFNDU0ksIHVzZSB0aGUgQUxVQSBsb2dpYworCSAqIG9mIHRoZSBVbmRlcmx5aW5nIFNDU0kgaGFyZHdhcmUuICBJbiBMaW51eC9TQ1NJIHRlcm1zLCB0aGlzIGNhbgorCSAqIGNhdXNlIGEgcHJvYmxlbSBiZWNhdXNlIGxpYmF0YSBhbmQgc29tZSBTQVRBIFJBSUQgSEJBcyBhcHBlYXIKKwkgKiB1bmRlciBMaW51eC9TQ1NJLCBidXQgZW11bGF0ZSBTQ1NJIGxvZ2ljIHRoZW1zZWx2ZXMuCisJICovCisJaWYgKCgoVFJBTlNQT1JUKGRldiktPnRyYW5zcG9ydF90eXBlID09IFRSQU5TUE9SVF9QTFVHSU5fUEhCQV9QREVWKSAmJgorCSAgICAhKERFVl9BVFRSSUIoZGV2KS0+ZW11bGF0ZV9hbHVhKSkgfHwgZm9yY2VfcHQpIHsKKwkJYWx1YS0+YWx1YV90eXBlID0gU1BDX0FMVUFfUEFTU1RIUk9VR0g7CisJCWFsdWEtPmFsdWFfc3RhdGVfY2hlY2sgPSAmY29yZV9hbHVhX3N0YXRlX2NoZWNrX25vcDsKKwkJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IFVzaW5nIFNQQ19BTFVBX1BBU1NUSFJPVUdILCBubyBBTFVBIgorCQkJIiBlbXVsYXRpb25cbiIsIFRSQU5TUE9SVChkZXYpLT5uYW1lKTsKKwkJcmV0dXJuIDA7CisJfQorCS8qCisJICogSWYgU1BDLTMgb3IgYWJvdmUgaXMgcmVwb3J0ZWQgYnkgcmVhbCBvciBlbXVsYXRlZCBzdHJ1Y3Qgc2VfZGV2aWNlLAorCSAqIHVzZSBlbXVsYXRlZCBBTFVBLgorCSAqLworCWlmIChUUkFOU1BPUlQoZGV2KS0+Z2V0X2RldmljZV9yZXYoZGV2KSA+PSBTQ1NJXzMpIHsKKwkJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IEVuYWJsaW5nIEFMVUEgRW11bGF0aW9uIGZvciBTUEMtMyIKKwkJCSIgZGV2aWNlXG4iLCBUUkFOU1BPUlQoZGV2KS0+bmFtZSk7CisJCS8qCisJCSAqIEFzc29pY2F0ZSB0aGlzIHN0cnVjdCBzZV9kZXZpY2Ugd2l0aCB0aGUgZGVmYXVsdCBBTFVBCisJCSAqIExVTiBHcm91cC4KKwkJICovCisJCWx1X2dwX21lbSA9IGNvcmVfYWx1YV9hbGxvY2F0ZV9sdV9ncF9tZW0oZGV2KTsKKwkJaWYgKElTX0VSUihsdV9ncF9tZW0pIHx8ICFsdV9ncF9tZW0pCisJCQlyZXR1cm4gLTE7CisKKwkJYWx1YS0+YWx1YV90eXBlID0gU1BDM19BTFVBX0VNVUxBVEVEOworCQlhbHVhLT5hbHVhX3N0YXRlX2NoZWNrID0gJmNvcmVfYWx1YV9zdGF0ZV9jaGVjazsKKwkJc3Bpbl9sb2NrKCZsdV9ncF9tZW0tPmx1X2dwX21lbV9sb2NrKTsKKwkJX19jb3JlX2FsdWFfYXR0YWNoX2x1X2dwX21lbShsdV9ncF9tZW0sCisJCQkJc2VfZ2xvYmFsLT5kZWZhdWx0X2x1X2dwKTsKKwkJc3Bpbl91bmxvY2soJmx1X2dwX21lbS0+bHVfZ3BfbWVtX2xvY2spOworCisJCXByaW50ayhLRVJOX0lORk8gIiVzOiBBZGRpbmcgdG8gZGVmYXVsdCBBTFVBIExVIEdyb3VwOiIKKwkJCSIgY29yZS9hbHVhL2x1X2dwcy9kZWZhdWx0X2x1X2dwXG4iLAorCQkJVFJBTlNQT1JUKGRldiktPm5hbWUpOworCX0gZWxzZSB7CisJCWFsdWEtPmFsdWFfdHlwZSA9IFNQQzJfQUxVQV9ESVNBQkxFRDsKKwkJYWx1YS0+YWx1YV9zdGF0ZV9jaGVjayA9ICZjb3JlX2FsdWFfc3RhdGVfY2hlY2tfbm9wOworCQlwcmludGsoS0VSTl9JTkZPICIlczogRGlzYWJsaW5nIEFMVUEgRW11bGF0aW9uIGZvciBTUEMtMiIKKwkJCSIgZGV2aWNlXG4iLCBUUkFOU1BPUlQoZGV2KS0+bmFtZSk7CisJfQorCisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9hbHVhLmggYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9hbHVhLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzg2Zjk3YQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2FsdWEuaApAQCAtMCwwICsxLDEyNiBAQAorI2lmbmRlZiBUQVJHRVRfQ09SRV9BTFVBX0gKKyNkZWZpbmUgVEFSR0VUX0NPUkVfQUxVQV9ICisKKy8qCisgKiBJTlFVSVJZIHJlc3BvbnNlIGRhdGEsIFRQR1MgRmllbGQKKyAqCisgKiBmcm9tIHNwYzRyMTcgc2VjdGlvbiA2LjQuMiBUYWJsZSAxMzUKKyAqLworI2RlZmluZSBUUEdTX05PX0FMVUEJCQkJMHgwMAorI2RlZmluZSBUUEdTX0lNUExJQ1RfQUxVQQkJCTB4MTAKKyNkZWZpbmUgVFBHU19FWFBMSUNUX0FMVUEJCQkweDIwCisKKy8qCisgKiBBU1lNTUVUUklDIEFDQ0VTUyBTVEFURSBmaWVsZAorICoKKyAqIGZyb20gc3BjNHIxNyBzZWN0aW9uIDYuMjcgVGFibGUgMjQ1CisgKi8KKyNkZWZpbmUgQUxVQV9BQ0NFU1NfU1RBVEVfQUNUSVZFX09QVE1JWkVECTB4MAorI2RlZmluZSBBTFVBX0FDQ0VTU19TVEFURV9BQ1RJVkVfTk9OX09QVElNSVpFRAkweDEKKyNkZWZpbmUgQUxVQV9BQ0NFU1NfU1RBVEVfU1RBTkRCWQkJMHgyCisjZGVmaW5lIEFMVUFfQUNDRVNTX1NUQVRFX1VOQVZBSUxBQkxFCQkweDMKKyNkZWZpbmUgQUxVQV9BQ0NFU1NfU1RBVEVfT0ZGTElORQkJMHhlCisjZGVmaW5lIEFMVUFfQUNDRVNTX1NUQVRFX1RSQU5TSVRJT04JCTB4ZgorCisvKgorICogUkVQT1JUX1RBUkdFVF9QT1JUX0dST1VQIFNUQVRVUyBDT0RFCisgKgorICogZnJvbSBzcGM0cjE3IHNlY3Rpb24gNi4yNyBUYWJsZSAyNDYKKyAqLworI2RlZmluZSBBTFVBX1NUQVRVU19OT05FCQkJCTB4MDAKKyNkZWZpbmUgQUxVQV9TVEFUVVNfQUxURVJFRF9CWV9FWFBMSUNUX1NUUEcJCTB4MDEKKyNkZWZpbmUgQUxVQV9TVEFUVVNfQUxURVJFRF9CWV9JTVBMSUNUX0FMVUEJCTB4MDIKKworLyoKKyAqIEZyb20gc3BjNHIxNywgVGFibGUgRC4xOiBBU0MgYW5kIEFTQ1EgQXNzaWduZW1lbnQKKyAqLworI2RlZmluZSBBU0NRXzA0SF9BTFVBX1NUQVRFX1RSQU5TSVRJT04JCQkweDBhCisjZGVmaW5lIEFTQ1FfMDRIX0FMVUFfVEdfUFRfU1RBTkRCWQkJCTB4MGIKKyNkZWZpbmUgQVNDUV8wNEhfQUxVQV9UR19QVF9VTkFWQUlMQUJMRQkJCTB4MGMKKyNkZWZpbmUgQVNDUV8wNEhfQUxVQV9PRkZMSU5FCQkJCTB4MTIKKworLyoKKyAqIFVzZWQgYXMgdGhlIGRlZmF1bHQgZm9yIEFjdGl2ZS9Ob25PcHRpbWl6ZWQgZGVsYXkgKGluIG1pbGxpc2Vjb25kcykKKyAqIFRoaXMgY2FuIGFsc28gYmUgY2hhbmdlZCB2aWEgY29uZmlnZnMgb24gYSBwZXIgdGFyZ2V0IHBvcnQgZ3JvdXAgYmFzaXMuLgorICovCisjZGVmaW5lIEFMVUFfREVGQVVMVF9OT05PUF9ERUxBWV9NU0VDUwkJCTEwMAorI2RlZmluZSBBTFVBX01BWF9OT05PUF9ERUxBWV9NU0VDUwkJCTEwMDAwIC8qIDEwIHNlY29uZHMgKi8KKy8qCisgKiBVc2VkIGZvciBpbXBsaWN0IGFuZCBleHBsaWN0IEFMVUEgdHJhbnNpdGlvbmFsIGRlbGF5LCB0aGF0IGlzIGRpc2FibGVkCisgKiBieSBkZWZhdWx0LCBhbmQgaXMgaW50ZW5kZWQgdG8gYmUgdXNlZCBmb3IgZGVidWdnaW5nIGNsaWVudCBzaWRlIEFMVUEgY29kZS4KKyAqLworI2RlZmluZSBBTFVBX0RFRkFVTFRfVFJBTlNfREVMQVlfTVNFQ1MJCQkwCisjZGVmaW5lIEFMVUFfTUFYX1RSQU5TX0RFTEFZX01TRUNTCQkJMzAwMDAgLyogMzAgc2Vjb25kcyAqLworLyoKKyAqIFVzZWQgYnkgY29yZV9hbHVhX3VwZGF0ZV90cGdfcHJpbWFyeV9tZXRhZGF0YSgpIGFuZAorICogY29yZV9hbHVhX3VwZGF0ZV90cGdfc2Vjb25kYXJ5X21ldGFkYXRhKCkKKyAqLworI2RlZmluZSBBTFVBX01FVEFEQVRBX1BBVEhfTEVOCQkJCTUxMgorLyoKKyAqIFVzZWQgYnkgY29yZV9hbHVhX3VwZGF0ZV90cGdfc2Vjb25kYXJ5X21ldGFkYXRhKCkKKyAqLworI2RlZmluZSBBTFVBX1NFQ09OREFSWV9NRVRBREFUQV9XV05fTEVOCQkJMjU2CisKK2V4dGVybiBzdHJ1Y3Qga21lbV9jYWNoZSAqdDEwX2FsdWFfbHVfZ3BfY2FjaGU7CitleHRlcm4gc3RydWN0IGttZW1fY2FjaGUgKnQxMF9hbHVhX2x1X2dwX21lbV9jYWNoZTsKK2V4dGVybiBzdHJ1Y3Qga21lbV9jYWNoZSAqdDEwX2FsdWFfdGdfcHRfZ3BfY2FjaGU7CitleHRlcm4gc3RydWN0IGttZW1fY2FjaGUgKnQxMF9hbHVhX3RnX3B0X2dwX21lbV9jYWNoZTsKKworZXh0ZXJuIGludCBjb3JlX2VtdWxhdGVfcmVwb3J0X3RhcmdldF9wb3J0X2dyb3VwcyhzdHJ1Y3Qgc2VfY21kICopOworZXh0ZXJuIGludCBjb3JlX2VtdWxhdGVfc2V0X3RhcmdldF9wb3J0X2dyb3VwcyhzdHJ1Y3Qgc2VfY21kICopOworZXh0ZXJuIGludCBjb3JlX2FsdWFfY2hlY2tfbm9ub3BfZGVsYXkoc3RydWN0IHNlX2NtZCAqKTsKK2V4dGVybiBpbnQgY29yZV9hbHVhX2RvX3BvcnRfdHJhbnNpdGlvbihzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKiwKKwkJCQlzdHJ1Y3Qgc2VfZGV2aWNlICosIHN0cnVjdCBzZV9wb3J0ICosCisJCQkJc3RydWN0IHNlX25vZGVfYWNsICosIGludCwgaW50KTsKK2V4dGVybiBjaGFyICpjb3JlX2FsdWFfZHVtcF9zdGF0dXMoaW50KTsKK2V4dGVybiBzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKmNvcmVfYWx1YV9hbGxvY2F0ZV9sdV9ncChjb25zdCBjaGFyICosIGludCk7CitleHRlcm4gaW50IGNvcmVfYWx1YV9zZXRfbHVfZ3BfaWQoc3RydWN0IHQxMF9hbHVhX2x1X2dwICosIHUxNik7CitleHRlcm4gdm9pZCBjb3JlX2FsdWFfZnJlZV9sdV9ncChzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKik7CitleHRlcm4gdm9pZCBjb3JlX2FsdWFfZnJlZV9sdV9ncF9tZW0oc3RydWN0IHNlX2RldmljZSAqKTsKK2V4dGVybiBzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKmNvcmVfYWx1YV9nZXRfbHVfZ3BfYnlfbmFtZShjb25zdCBjaGFyICopOworZXh0ZXJuIHZvaWQgY29yZV9hbHVhX3B1dF9sdV9ncF9mcm9tX25hbWUoc3RydWN0IHQxMF9hbHVhX2x1X2dwICopOworZXh0ZXJuIHZvaWQgX19jb3JlX2FsdWFfYXR0YWNoX2x1X2dwX21lbShzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3BfbWVtYmVyICosCisJCQkJCXN0cnVjdCB0MTBfYWx1YV9sdV9ncCAqKTsKK2V4dGVybiB2b2lkIF9fY29yZV9hbHVhX2Ryb3BfbHVfZ3BfbWVtKHN0cnVjdCB0MTBfYWx1YV9sdV9ncF9tZW1iZXIgKiwKKwkJCQkJc3RydWN0IHQxMF9hbHVhX2x1X2dwICopOworZXh0ZXJuIHZvaWQgY29yZV9hbHVhX2Ryb3BfbHVfZ3BfZGV2KHN0cnVjdCBzZV9kZXZpY2UgKik7CitleHRlcm4gc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICpjb3JlX2FsdWFfYWxsb2NhdGVfdGdfcHRfZ3AoCisJCQlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqLCBjb25zdCBjaGFyICosIGludCk7CitleHRlcm4gaW50IGNvcmVfYWx1YV9zZXRfdGdfcHRfZ3BfaWQoc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICosIHUxNik7CitleHRlcm4gc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwX21lbWJlciAqY29yZV9hbHVhX2FsbG9jYXRlX3RnX3B0X2dwX21lbSgKKwkJCQkJc3RydWN0IHNlX3BvcnQgKik7CitleHRlcm4gdm9pZCBjb3JlX2FsdWFfZnJlZV90Z19wdF9ncChzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKik7CitleHRlcm4gdm9pZCBjb3JlX2FsdWFfZnJlZV90Z19wdF9ncF9tZW0oc3RydWN0IHNlX3BvcnQgKik7CitleHRlcm4gdm9pZCBfX2NvcmVfYWx1YV9hdHRhY2hfdGdfcHRfZ3BfbWVtKHN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncF9tZW1iZXIgKiwKKwkJCQkJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICopOworZXh0ZXJuIHNzaXplX3QgY29yZV9hbHVhX3Nob3dfdGdfcHRfZ3BfaW5mbyhzdHJ1Y3Qgc2VfcG9ydCAqLCBjaGFyICopOworZXh0ZXJuIHNzaXplX3QgY29yZV9hbHVhX3N0b3JlX3RnX3B0X2dwX2luZm8oc3RydWN0IHNlX3BvcnQgKiwgY29uc3QgY2hhciAqLAorCQkJCQkJc2l6ZV90KTsKK2V4dGVybiBzc2l6ZV90IGNvcmVfYWx1YV9zaG93X2FjY2Vzc190eXBlKHN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqLCBjaGFyICopOworZXh0ZXJuIHNzaXplX3QgY29yZV9hbHVhX3N0b3JlX2FjY2Vzc190eXBlKHN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqLAorCQkJCQljb25zdCBjaGFyICosIHNpemVfdCk7CitleHRlcm4gc3NpemVfdCBjb3JlX2FsdWFfc2hvd19ub25vcF9kZWxheV9tc2VjcyhzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKiwKKwkJCQkJCWNoYXIgKik7CitleHRlcm4gc3NpemVfdCBjb3JlX2FsdWFfc3RvcmVfbm9ub3BfZGVsYXlfbXNlY3Moc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICosCisJCQkJCWNvbnN0IGNoYXIgKiwgc2l6ZV90KTsKK2V4dGVybiBzc2l6ZV90IGNvcmVfYWx1YV9zaG93X3RyYW5zX2RlbGF5X21zZWNzKHN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqLAorCQkJCQljaGFyICopOworZXh0ZXJuIHNzaXplX3QgY29yZV9hbHVhX3N0b3JlX3RyYW5zX2RlbGF5X21zZWNzKHN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqLAorCQkJCQljb25zdCBjaGFyICosIHNpemVfdCk7CitleHRlcm4gc3NpemVfdCBjb3JlX2FsdWFfc2hvd19wcmVmZXJyZWRfYml0KHN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqLAorCQkJCQljaGFyICopOworZXh0ZXJuIHNzaXplX3QgY29yZV9hbHVhX3N0b3JlX3ByZWZlcnJlZF9iaXQoc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICosCisJCQkJCWNvbnN0IGNoYXIgKiwgc2l6ZV90KTsKK2V4dGVybiBzc2l6ZV90IGNvcmVfYWx1YV9zaG93X29mZmxpbmVfYml0KHN0cnVjdCBzZV9sdW4gKiwgY2hhciAqKTsKK2V4dGVybiBzc2l6ZV90IGNvcmVfYWx1YV9zdG9yZV9vZmZsaW5lX2JpdChzdHJ1Y3Qgc2VfbHVuICosIGNvbnN0IGNoYXIgKiwKKwkJCQkJc2l6ZV90KTsKK2V4dGVybiBzc2l6ZV90IGNvcmVfYWx1YV9zaG93X3NlY29uZGFyeV9zdGF0dXMoc3RydWN0IHNlX2x1biAqLCBjaGFyICopOworZXh0ZXJuIHNzaXplX3QgY29yZV9hbHVhX3N0b3JlX3NlY29uZGFyeV9zdGF0dXMoc3RydWN0IHNlX2x1biAqLAorCQkJCQljb25zdCBjaGFyICosIHNpemVfdCk7CitleHRlcm4gc3NpemVfdCBjb3JlX2FsdWFfc2hvd19zZWNvbmRhcnlfd3JpdGVfbWV0YWRhdGEoc3RydWN0IHNlX2x1biAqLAorCQkJCQljaGFyICopOworZXh0ZXJuIHNzaXplX3QgY29yZV9hbHVhX3N0b3JlX3NlY29uZGFyeV93cml0ZV9tZXRhZGF0YShzdHJ1Y3Qgc2VfbHVuICosCisJCQkJCWNvbnN0IGNoYXIgKiwgc2l6ZV90KTsKK2V4dGVybiBpbnQgY29yZV9zZXR1cF9hbHVhKHN0cnVjdCBzZV9kZXZpY2UgKiwgaW50KTsKKworI2VuZGlmIC8qIFRBUkdFVF9DT1JFX0FMVUFfSCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfY2RiLmMgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9jZGIuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zNjYwODBiCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfY2RiLmMKQEAgLTAsMCArMSwxMTMxIEBACisvKgorICogQ0RCIGVtdWxhdGlvbiBmb3Igbm9uLVJFQUQvV1JJVEUgY29tbWFuZHMuCisgKgorICogQ29weXJpZ2h0IChjKSAyMDAyLCAyMDAzLCAyMDA0LCAyMDA1IFB5WCBUZWNobm9sb2dpZXMsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNiwgMjAwNyBTQkUsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAwNy0yMDEwIFJpc2luZyBUaWRlIFN5c3RlbXMKKyAqIENvcHlyaWdodCAoYykgMjAwOC0yMDEwIExpbnV4LWlTQ1NJLm9yZworICoKKyAqIE5pY2hvbGFzIEEuIEJlbGxpbmdlciA8bmFiQGtlcm5lbC5vcmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqLworCisjaW5jbHVkZSA8YXNtL3VuYWxpZ25lZC5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaS5oPgorCisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2Jhc2UuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdHJhbnNwb3J0Lmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19vcHMuaD4KKyNpbmNsdWRlICJ0YXJnZXRfY29yZV91YS5oIgorCitzdGF0aWMgdm9pZAordGFyZ2V0X2ZpbGxfYWx1YV9kYXRhKHN0cnVjdCBzZV9wb3J0ICpwb3J0LCB1bnNpZ25lZCBjaGFyICpidWYpCit7CisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncDsKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3BfbWVtYmVyICp0Z19wdF9ncF9tZW07CisKKwkvKgorCSAqIFNldCBTQ0NTIGZvciBNQUlOVEVOQU5DRV9JTiArIFJFUE9SVF9UQVJHRVRfUE9SVF9HUk9VUFMuCisJICovCisJYnVmWzVdCT0gMHg4MDsKKworCS8qCisJICogU2V0IFRQR1MgZmllbGQgZm9yIGV4cGxpY3QgYW5kL29yIGltcGxpY3QgQUxVQSBhY2Nlc3MgdHlwZQorCSAqIGFuZCBvcHRlcmF0aW9uLgorCSAqCisJICogU2VlIHNwYzRyMTcgc2VjdGlvbiA2LjQuMiBUYWJsZSAxMzUKKwkgKi8KKwlpZiAoIXBvcnQpCisJCXJldHVybjsKKwl0Z19wdF9ncF9tZW0gPSBwb3J0LT5zZXBfYWx1YV90Z19wdF9ncF9tZW07CisJaWYgKCF0Z19wdF9ncF9tZW0pCisJCXJldHVybjsKKworCXNwaW5fbG9jaygmdGdfcHRfZ3BfbWVtLT50Z19wdF9ncF9tZW1fbG9jayk7CisJdGdfcHRfZ3AgPSB0Z19wdF9ncF9tZW0tPnRnX3B0X2dwOworCWlmICh0Z19wdF9ncCkKKwkJYnVmWzVdIHw9IHRnX3B0X2dwLT50Z19wdF9ncF9hbHVhX2FjY2Vzc190eXBlOworCXNwaW5fdW5sb2NrKCZ0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9sb2NrKTsKK30KKworc3RhdGljIGludAordGFyZ2V0X2VtdWxhdGVfaW5xdWlyeV9zdGQoc3RydWN0IHNlX2NtZCAqY21kKQoreworCXN0cnVjdCBzZV9sdW4gKmx1biA9IFNFX0xVTihjbWQpOworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IFNFX0RFVihjbWQpOworCXVuc2lnbmVkIGNoYXIgKmJ1ZiA9IGNtZC0+dF90YXNrLT50X3Rhc2tfYnVmOworCisJLyoKKwkgKiBNYWtlIHN1cmUgd2UgYXQgbGVhc3QgaGF2ZSA2IGJ5dGVzIG9mIElOUVVJUlkgcmVzcG9uc2UKKwkgKiBwYXlsb2FkIGdvaW5nIGJhY2sgZm9yIEVWUEQ9MAorCSAqLworCWlmIChjbWQtPmRhdGFfbGVuZ3RoIDwgNikgeworCQlwcmludGsoS0VSTl9FUlIgIlNDU0kgSW5xdWlyeSBwYXlsb2FkIGxlbmd0aDogJXUiCisJCQkiIHRvbyBzbWFsbCBmb3IgRVZQRD0wXG4iLCBjbWQtPmRhdGFfbGVuZ3RoKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWJ1ZlswXSA9IGRldi0+dHJhbnNwb3J0LT5nZXRfZGV2aWNlX3R5cGUoZGV2KTsKKwlpZiAoYnVmWzBdID09IFRZUEVfVEFQRSkKKwkJYnVmWzFdID0gMHg4MDsKKwlidWZbMl0gPSBkZXYtPnRyYW5zcG9ydC0+Z2V0X2RldmljZV9yZXYoZGV2KTsKKworCS8qCisJICogRW5hYmxlIFNDQ1MgYW5kIFRQR1MgZmllbGRzIGZvciBFbXVsYXRlZCBBTFVBCisJICovCisJaWYgKFQxMF9BTFVBKGRldi0+c2Vfc3ViX2RldiktPmFsdWFfdHlwZSA9PSBTUEMzX0FMVUFfRU1VTEFURUQpCisJCXRhcmdldF9maWxsX2FsdWFfZGF0YShsdW4tPmx1bl9zZXAsIGJ1Zik7CisKKwlpZiAoY21kLT5kYXRhX2xlbmd0aCA8IDgpIHsKKwkJYnVmWzRdID0gMTsgLyogU2V0IGFkZGl0aW9uYWwgbGVuZ3RoIHRvIDEgKi8KKwkJcmV0dXJuIDA7CisJfQorCisJYnVmWzddID0gMHgzMjsgLyogU3luYz0xIGFuZCBDbWRRdWU9MSAqLworCisJLyoKKwkgKiBEbyBub3QgaW5jbHVkZSB2ZW5kb3IsIHByb2R1Y3QsIHJldmVyc2lvbiBpbmZvIGluIElOUVVJUlkKKwkgKiByZXNwb25zZSBwYXlsb2FkIGZvciBjZGJzIHdpdGggYSBzbWFsbCBhbGxvY2F0aW9uIGxlbmd0aC4KKwkgKi8KKwlpZiAoY21kLT5kYXRhX2xlbmd0aCA8IDM2KSB7CisJCWJ1Zls0XSA9IDM7IC8qIFNldCBhZGRpdGlvbmFsIGxlbmd0aCB0byAzICovCisJCXJldHVybiAwOworCX0KKworCXNucHJpbnRmKCh1bnNpZ25lZCBjaGFyICopJmJ1Zls4XSwgOCwgIkxJTy1PUkciKTsKKwlzbnByaW50ZigodW5zaWduZWQgY2hhciAqKSZidWZbMTZdLCAxNiwgIiVzIiwKKwkJICZERVZfVDEwX1dXTihkZXYpLT5tb2RlbFswXSk7CisJc25wcmludGYoKHVuc2lnbmVkIGNoYXIgKikmYnVmWzMyXSwgNCwgIiVzIiwKKwkJICZERVZfVDEwX1dXTihkZXYpLT5yZXZpc2lvblswXSk7CisJYnVmWzRdID0gMzE7IC8qIFNldCBhZGRpdGlvbmFsIGxlbmd0aCB0byAzMSAqLworCXJldHVybiAwOworfQorCisvKiBzdXBwb3J0ZWQgdml0YWwgcHJvZHVjdCBkYXRhIHBhZ2VzICovCitzdGF0aWMgaW50Cit0YXJnZXRfZW11bGF0ZV9ldnBkXzAwKHN0cnVjdCBzZV9jbWQgKmNtZCwgdW5zaWduZWQgY2hhciAqYnVmKQoreworCWJ1ZlsxXSA9IDB4MDA7CisJaWYgKGNtZC0+ZGF0YV9sZW5ndGggPCA4KQorCQlyZXR1cm4gMDsKKworCWJ1Zls0XSA9IDB4MDsKKwkvKgorCSAqIE9ubHkgcmVwb3J0IHRoZSBJTlFVSVJZIEVWUEQ9MSBwYWdlcyBhZnRlciBhIHZhbGlkIE5BQQorCSAqIFJlZ2lzdGVyZWQgRXh0ZW5kZWQgTFVOIFdXTiBoYXMgYmVlbiBzZXQgdmlhIENvbmZpZ0ZTCisJICogZHVyaW5nIGRldmljZSBjcmVhdGlvbi9yZXN0YXJ0LgorCSAqLworCWlmIChTRV9ERVYoY21kKS0+c2Vfc3ViX2Rldi0+c3VfZGV2X2ZsYWdzICYKKwkJCVNERl9FTVVMQVRFRF9WUERfVU5JVF9TRVJJQUwpIHsKKwkJYnVmWzNdID0gMzsKKwkJYnVmWzVdID0gMHg4MDsKKwkJYnVmWzZdID0gMHg4MzsKKwkJYnVmWzddID0gMHg4NjsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworLyogdW5pdCBzZXJpYWwgbnVtYmVyICovCitzdGF0aWMgaW50Cit0YXJnZXRfZW11bGF0ZV9ldnBkXzgwKHN0cnVjdCBzZV9jbWQgKmNtZCwgdW5zaWduZWQgY2hhciAqYnVmKQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IFNFX0RFVihjbWQpOworCXUxNiBsZW4gPSAwOworCisJYnVmWzFdID0gMHg4MDsKKwlpZiAoZGV2LT5zZV9zdWJfZGV2LT5zdV9kZXZfZmxhZ3MgJgorCQkJU0RGX0VNVUxBVEVEX1ZQRF9VTklUX1NFUklBTCkgeworCQl1MzIgdW5pdF9zZXJpYWxfbGVuOworCisJCXVuaXRfc2VyaWFsX2xlbiA9CisJCQlzdHJsZW4oJkRFVl9UMTBfV1dOKGRldiktPnVuaXRfc2VyaWFsWzBdKTsKKwkJdW5pdF9zZXJpYWxfbGVuKys7IC8qIEZvciBOVUxMIFRlcm1pbmF0b3IgKi8KKworCQlpZiAoKChsZW4gKyA0KSArIHVuaXRfc2VyaWFsX2xlbikgPiBjbWQtPmRhdGFfbGVuZ3RoKSB7CisJCQlsZW4gKz0gdW5pdF9zZXJpYWxfbGVuOworCQkJYnVmWzJdID0gKChsZW4gPj4gOCkgJiAweGZmKTsKKwkJCWJ1ZlszXSA9IChsZW4gJiAweGZmKTsKKwkJCXJldHVybiAwOworCQl9CisJCWxlbiArPSBzcHJpbnRmKCh1bnNpZ25lZCBjaGFyICopJmJ1Zls0XSwgIiVzIiwKKwkJCSZERVZfVDEwX1dXTihkZXYpLT51bml0X3NlcmlhbFswXSk7CisJCWxlbisrOyAvKiBFeHRyYSBCeXRlIGZvciBOVUxMIFRlcm1pbmF0b3IgKi8KKwkJYnVmWzNdID0gbGVuOworCX0KKwlyZXR1cm4gMDsKK30KKworLyoKKyAqIERldmljZSBpZGVudGlmaWNhdGlvbiBWUEQsIGZvciBhIGNvbXBsZXRlIGxpc3Qgb2YKKyAqIERFU0lHTkFUT1IgVFlQRXMgc2VlIHNwYzRyMTcgVGFibGUgNDU5LgorICovCitzdGF0aWMgaW50Cit0YXJnZXRfZW11bGF0ZV9ldnBkXzgzKHN0cnVjdCBzZV9jbWQgKmNtZCwgdW5zaWduZWQgY2hhciAqYnVmKQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IFNFX0RFVihjbWQpOworCXN0cnVjdCBzZV9sdW4gKmx1biA9IFNFX0xVTihjbWQpOworCXN0cnVjdCBzZV9wb3J0ICpwb3J0ID0gTlVMTDsKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcgPSBOVUxMOworCXN0cnVjdCB0MTBfYWx1YV9sdV9ncF9tZW1iZXIgKmx1X2dwX21lbTsKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwOworCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncF9tZW1iZXIgKnRnX3B0X2dwX21lbTsKKwl1bnNpZ25lZCBjaGFyIGJpbmFyeSwgYmluYXJ5X25ldzsKKwl1bnNpZ25lZCBjaGFyICpwcm9kID0gJkRFVl9UMTBfV1dOKGRldiktPm1vZGVsWzBdOworCXUzMiBwcm9kX2xlbjsKKwl1MzIgdW5pdF9zZXJpYWxfbGVuLCBvZmYgPSAwOworCWludCBpOworCXUxNiBsZW4gPSAwLCBpZF9sZW47CisKKwlidWZbMV0gPSAweDgzOworCW9mZiA9IDQ7CisKKwkvKgorCSAqIE5BQSBJRUVFIFJlZ2lzdGVyZWQgRXh0ZW5kZWQgQXNzaWduZWQgZGVzaWduYXRvciBmb3JtYXQsIHNlZQorCSAqIHNwYzRyMTcgc2VjdGlvbiA3LjcuMy42LjUKKwkgKgorCSAqIFdlIGRlcGVuZCB1cG9uIGEgdGFyZ2V0X2NvcmVfbW9kL0NvbmZpZ0ZTIHByb3ZpZGVkCisJICogL3N5cy9rZXJuZWwvY29uZmlnL3RhcmdldC9jb3JlLyRIQkEvJERFVi93d24vdnBkX3VuaXRfc2VyaWFsCisJICogdmFsdWUgaW4gb3JkZXIgdG8gcmV0dXJuIHRoZSBOQUEgaWQuCisJICovCisJaWYgKCEoZGV2LT5zZV9zdWJfZGV2LT5zdV9kZXZfZmxhZ3MgJiBTREZfRU1VTEFURURfVlBEX1VOSVRfU0VSSUFMKSkKKwkJZ290byBjaGVja190MTBfdmVuZF9kZXNjOworCisJaWYgKG9mZiArIDIwID4gY21kLT5kYXRhX2xlbmd0aCkKKwkJZ290byBjaGVja190MTBfdmVuZF9kZXNjOworCisJLyogQ09ERSBTRVQgPT0gQmluYXJ5ICovCisJYnVmW29mZisrXSA9IDB4MTsKKworCS8qIFNldCBBU1NPSUNBVElPTiA9PSBhZGRyZXNzZWQgbG9naWNhbCB1bml0OiAwKWIgKi8KKwlidWZbb2ZmXSA9IDB4MDA7CisKKwkvKiBJZGVudGlmaWVyL0Rlc2lnbmF0b3IgdHlwZSA9PSBOQUEgaWRlbnRpZmllciAqLworCWJ1ZltvZmYrK10gPSAweDM7CisJb2ZmKys7CisKKwkvKiBJZGVudGlmaWVyL0Rlc2lnbmF0b3IgbGVuZ3RoICovCisJYnVmW29mZisrXSA9IDB4MTA7CisKKwkvKgorCSAqIFN0YXJ0IE5BQSBJRUVFIFJlZ2lzdGVyZWQgRXh0ZW5kZWQgSWRlbnRpZmllci9EZXNpZ25hdG9yCisJICovCisJYnVmW29mZisrXSA9ICgweDYgPDwgNCk7CisKKwkvKgorCSAqIFVzZSBPcGVuRmFicmljcyBJRUVFIENvbXBhbnkgSUQ6IDAwIDE0IDA1CisJICovCisJYnVmW29mZisrXSA9IDB4MDE7CisJYnVmW29mZisrXSA9IDB4NDA7CisJYnVmW29mZl0gPSAoMHg1IDw8IDQpOworCisJLyoKKwkgKiBSZXR1cm4gQ29uZmlnRlMgVW5pdCBTZXJpYWwgTnVtYmVyIGluZm9ybWF0aW9uIGZvcgorCSAqIFZFTkRPUl9TUEVDSUZJQ19JREVOVElGSUVSIGFuZAorCSAqIFZFTkRPUl9TUEVDSUZJQ19JREVOVElGSUVSX0VYVEVOVElPTgorCSAqLworCWJpbmFyeSA9IHRyYW5zcG9ydF9hc2NpaWhleF90b19iaW5hcnloZXgoCisJCQkJJkRFVl9UMTBfV1dOKGRldiktPnVuaXRfc2VyaWFsWzBdKTsKKwlidWZbb2ZmKytdIHw9IChiaW5hcnkgJiAweGYwKSA+PiA0OworCWZvciAoaSA9IDA7IGkgPCAyNDsgaSArPSAyKSB7CisJCWJpbmFyeV9uZXcgPSB0cmFuc3BvcnRfYXNjaWloZXhfdG9fYmluYXJ5aGV4KAorCQkJJkRFVl9UMTBfV1dOKGRldiktPnVuaXRfc2VyaWFsW2krMl0pOworCQlidWZbb2ZmXSA9IChiaW5hcnkgJiAweDBmKSA8PCA0OworCQlidWZbb2ZmKytdIHw9IChiaW5hcnlfbmV3ICYgMHhmMCkgPj4gNDsKKwkJYmluYXJ5ID0gYmluYXJ5X25ldzsKKwl9CisJbGVuID0gMjA7CisJb2ZmID0gKGxlbiArIDQpOworCitjaGVja190MTBfdmVuZF9kZXNjOgorCS8qCisJICogVDEwIFZlbmRvciBJZGVudGlmaWVyIFBhZ2UsIHNlZSBzcGM0cjE3IHNlY3Rpb24gNy43LjMuNAorCSAqLworCWlkX2xlbiA9IDg7IC8qIEZvciBWZW5kb3IgZmllbGQgKi8KKwlwcm9kX2xlbiA9IDQ7IC8qIEZvciBWUEQgSGVhZGVyICovCisJcHJvZF9sZW4gKz0gODsgLyogRm9yIFZlbmRvciBmaWVsZCAqLworCXByb2RfbGVuICs9IHN0cmxlbihwcm9kKTsKKwlwcm9kX2xlbisrOyAvKiBGb3IgOiAqLworCisJaWYgKGRldi0+c2Vfc3ViX2Rldi0+c3VfZGV2X2ZsYWdzICYKKwkJCVNERl9FTVVMQVRFRF9WUERfVU5JVF9TRVJJQUwpIHsKKwkJdW5pdF9zZXJpYWxfbGVuID0KKwkJCXN0cmxlbigmREVWX1QxMF9XV04oZGV2KS0+dW5pdF9zZXJpYWxbMF0pOworCQl1bml0X3NlcmlhbF9sZW4rKzsgLyogRm9yIE5VTEwgVGVybWluYXRvciAqLworCisJCWlmICgobGVuICsgKGlkX2xlbiArIDQpICsKKwkJICAgIChwcm9kX2xlbiArIHVuaXRfc2VyaWFsX2xlbikpID4KKwkJCQljbWQtPmRhdGFfbGVuZ3RoKSB7CisJCQlsZW4gKz0gKHByb2RfbGVuICsgdW5pdF9zZXJpYWxfbGVuKTsKKwkJCWdvdG8gY2hlY2tfcG9ydDsKKwkJfQorCQlpZF9sZW4gKz0gc3ByaW50ZigodW5zaWduZWQgY2hhciAqKSZidWZbb2ZmKzEyXSwKKwkJCQkiJXM6JXMiLCBwcm9kLAorCQkJCSZERVZfVDEwX1dXTihkZXYpLT51bml0X3NlcmlhbFswXSk7CisJfQorCWJ1ZltvZmZdID0gMHgyOyAvKiBBU0NJSSAqLworCWJ1ZltvZmYrMV0gPSAweDE7IC8qIFQxMCBWZW5kb3IgSUQgKi8KKwlidWZbb2ZmKzJdID0gMHgwOworCW1lbWNweSgodW5zaWduZWQgY2hhciAqKSZidWZbb2ZmKzRdLCAiTElPLU9SRyIsIDgpOworCS8qIEV4dHJhIEJ5dGUgZm9yIE5VTEwgVGVybWluYXRvciAqLworCWlkX2xlbisrOworCS8qIElkZW50aWZpZXIgTGVuZ3RoICovCisJYnVmW29mZiszXSA9IGlkX2xlbjsKKwkvKiBIZWFkZXIgc2l6ZSBmb3IgRGVzaWduYXRpb24gZGVzY3JpcHRvciAqLworCWxlbiArPSAoaWRfbGVuICsgNCk7CisJb2ZmICs9IChpZF9sZW4gKyA0KTsKKwkvKgorCSAqIHN0cnVjdCBzZV9wb3J0IGlzIG9ubHkgc2V0IGZvciBJTlFVSVJZIFZQRD0xIHRocm91Z2ggJEZBQlJJQ19NT0QKKwkgKi8KK2NoZWNrX3BvcnQ6CisJcG9ydCA9IGx1bi0+bHVuX3NlcDsKKwlpZiAocG9ydCkgeworCQlzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKmx1X2dwOworCQl1MzIgcGFkZGluZywgc2NzaV9uYW1lX2xlbjsKKwkJdTE2IGx1X2dwX2lkID0gMDsKKwkJdTE2IHRnX3B0X2dwX2lkID0gMDsKKwkJdTE2IHRwZ3Q7CisKKwkJdHBnID0gcG9ydC0+c2VwX3RwZzsKKwkJLyoKKwkJICogUmVsYXRpdmUgdGFyZ2V0IHBvcnQgaWRlbnRpZmVyLCBzZWUgc3BjNHIxNworCQkgKiBzZWN0aW9uIDcuNy4zLjcKKwkJICoKKwkJICogR2V0IHRoZSBQUk9UT0NPTCBJREVOVElGSUVSIGFzIGRlZmluZWQgYnkgc3BjNHIxNworCQkgKiBzZWN0aW9uIDcuNS4xIFRhYmxlIDM2MgorCQkgKi8KKwkJaWYgKCgobGVuICsgNCkgKyA4KSA+IGNtZC0+ZGF0YV9sZW5ndGgpIHsKKwkJCWxlbiArPSA4OworCQkJZ290byBjaGVja190cGdpOworCQl9CisJCWJ1ZltvZmZdID0KKwkJCShUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfcHJvdG9faWRlbnQodHBnKSA8PCA0KTsKKwkJYnVmW29mZisrXSB8PSAweDE7IC8qIENPREUgU0VUID09IEJpbmFyeSAqLworCQlidWZbb2ZmXSA9IDB4ODA7IC8qIFNldCBQSVY9MSAqLworCQkvKiBTZXQgQVNTT0lDQVRJT04gPT0gdGFyZ2V0IHBvcnQ6IDAxYiAqLworCQlidWZbb2ZmXSB8PSAweDEwOworCQkvKiBERVNJR05BVE9SIFRZUEUgPT0gUmVsYXRpdmUgdGFyZ2V0IHBvcnQgaWRlbnRpZmVyICovCisJCWJ1ZltvZmYrK10gfD0gMHg0OworCQlvZmYrKzsgLyogU2tpcCBvdmVyIFJlc2VydmVkICovCisJCWJ1ZltvZmYrK10gPSA0OyAvKiBERVNJR05BVE9SIExFTkdUSCAqLworCQkvKiBTa2lwIG92ZXIgT2Jzb2xldGUgZmllbGQgaW4gUlRQSSBwYXlsb2FkCisJCSAqIGluIFRhYmxlIDQ3MiAqLworCQlvZmYgKz0gMjsKKwkJYnVmW29mZisrXSA9ICgocG9ydC0+c2VwX3J0cGkgPj4gOCkgJiAweGZmKTsKKwkJYnVmW29mZisrXSA9IChwb3J0LT5zZXBfcnRwaSAmIDB4ZmYpOworCQlsZW4gKz0gODsgLyogSGVhZGVyIHNpemUgKyBEZXNpZ25hdGlvbiBkZXNjcmlwdG9yICovCisJCS8qCisJCSAqIFRhcmdldCBwb3J0IGdyb3VwIGlkZW50aWZpZXIsIHNlZSBzcGM0cjE3CisJCSAqIHNlY3Rpb24gNy43LjMuOAorCQkgKgorCQkgKiBHZXQgdGhlIFBST1RPQ09MIElERU5USUZJRVIgYXMgZGVmaW5lZCBieSBzcGM0cjE3CisJCSAqIHNlY3Rpb24gNy41LjEgVGFibGUgMzYyCisJCSAqLworY2hlY2tfdHBnaToKKwkJaWYgKFQxMF9BTFVBKGRldi0+c2Vfc3ViX2RldiktPmFsdWFfdHlwZSAhPQorCQkJCVNQQzNfQUxVQV9FTVVMQVRFRCkKKwkJCWdvdG8gY2hlY2tfc2NzaV9uYW1lOworCisJCWlmICgoKGxlbiArIDQpICsgOCkgPiBjbWQtPmRhdGFfbGVuZ3RoKSB7CisJCQlsZW4gKz0gODsKKwkJCWdvdG8gY2hlY2tfbHVfZ3A7CisJCX0KKwkJdGdfcHRfZ3BfbWVtID0gcG9ydC0+c2VwX2FsdWFfdGdfcHRfZ3BfbWVtOworCQlpZiAoIXRnX3B0X2dwX21lbSkKKwkJCWdvdG8gY2hlY2tfbHVfZ3A7CisKKwkJc3Bpbl9sb2NrKCZ0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9sb2NrKTsKKwkJdGdfcHRfZ3AgPSB0Z19wdF9ncF9tZW0tPnRnX3B0X2dwOworCQlpZiAoISh0Z19wdF9ncCkpIHsKKwkJCXNwaW5fdW5sb2NrKCZ0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9sb2NrKTsKKwkJCWdvdG8gY2hlY2tfbHVfZ3A7CisJCX0KKwkJdGdfcHRfZ3BfaWQgPSB0Z19wdF9ncC0+dGdfcHRfZ3BfaWQ7CisJCXNwaW5fdW5sb2NrKCZ0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9sb2NrKTsKKworCQlidWZbb2ZmXSA9CisJCQkoVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX3Byb3RvX2lkZW50KHRwZykgPDwgNCk7CisJCWJ1ZltvZmYrK10gfD0gMHgxOyAvKiBDT0RFIFNFVCA9PSBCaW5hcnkgKi8KKwkJYnVmW29mZl0gPSAweDgwOyAvKiBTZXQgUElWPTEgKi8KKwkJLyogU2V0IEFTU09JQ0FUSU9OID09IHRhcmdldCBwb3J0OiAwMWIgKi8KKwkJYnVmW29mZl0gfD0gMHgxMDsKKwkJLyogREVTSUdOQVRPUiBUWVBFID09IFRhcmdldCBwb3J0IGdyb3VwIGlkZW50aWZpZXIgKi8KKwkJYnVmW29mZisrXSB8PSAweDU7CisJCW9mZisrOyAvKiBTa2lwIG92ZXIgUmVzZXJ2ZWQgKi8KKwkJYnVmW29mZisrXSA9IDQ7IC8qIERFU0lHTkFUT1IgTEVOR1RIICovCisJCW9mZiArPSAyOyAvKiBTa2lwIG92ZXIgUmVzZXJ2ZWQgRmllbGQgKi8KKwkJYnVmW29mZisrXSA9ICgodGdfcHRfZ3BfaWQgPj4gOCkgJiAweGZmKTsKKwkJYnVmW29mZisrXSA9ICh0Z19wdF9ncF9pZCAmIDB4ZmYpOworCQlsZW4gKz0gODsgLyogSGVhZGVyIHNpemUgKyBEZXNpZ25hdGlvbiBkZXNjcmlwdG9yICovCisJCS8qCisJCSAqIExvZ2ljYWwgVW5pdCBHcm91cCBpZGVudGlmaWVyLCBzZWUgc3BjNHIxNworCQkgKiBzZWN0aW9uIDcuNy4zLjgKKwkJICovCitjaGVja19sdV9ncDoKKwkJaWYgKCgobGVuICsgNCkgKyA4KSA+IGNtZC0+ZGF0YV9sZW5ndGgpIHsKKwkJCWxlbiArPSA4OworCQkJZ290byBjaGVja19zY3NpX25hbWU7CisJCX0KKwkJbHVfZ3BfbWVtID0gZGV2LT5kZXZfYWx1YV9sdV9ncF9tZW07CisJCWlmICghKGx1X2dwX21lbSkpCisJCQlnb3RvIGNoZWNrX3Njc2lfbmFtZTsKKworCQlzcGluX2xvY2soJmx1X2dwX21lbS0+bHVfZ3BfbWVtX2xvY2spOworCQlsdV9ncCA9IGx1X2dwX21lbS0+bHVfZ3A7CisJCWlmICghKGx1X2dwKSkgeworCQkJc3Bpbl91bmxvY2soJmx1X2dwX21lbS0+bHVfZ3BfbWVtX2xvY2spOworCQkJZ290byBjaGVja19zY3NpX25hbWU7CisJCX0KKwkJbHVfZ3BfaWQgPSBsdV9ncC0+bHVfZ3BfaWQ7CisJCXNwaW5fdW5sb2NrKCZsdV9ncF9tZW0tPmx1X2dwX21lbV9sb2NrKTsKKworCQlidWZbb2ZmKytdIHw9IDB4MTsgLyogQ09ERSBTRVQgPT0gQmluYXJ5ICovCisJCS8qIERFU0lHTkFUT1IgVFlQRSA9PSBMb2dpY2FsIFVuaXQgR3JvdXAgaWRlbnRpZmllciAqLworCQlidWZbb2ZmKytdIHw9IDB4NjsKKwkJb2ZmKys7IC8qIFNraXAgb3ZlciBSZXNlcnZlZCAqLworCQlidWZbb2ZmKytdID0gNDsgLyogREVTSUdOQVRPUiBMRU5HVEggKi8KKwkJb2ZmICs9IDI7IC8qIFNraXAgb3ZlciBSZXNlcnZlZCBGaWVsZCAqLworCQlidWZbb2ZmKytdID0gKChsdV9ncF9pZCA+PiA4KSAmIDB4ZmYpOworCQlidWZbb2ZmKytdID0gKGx1X2dwX2lkICYgMHhmZik7CisJCWxlbiArPSA4OyAvKiBIZWFkZXIgc2l6ZSArIERlc2lnbmF0aW9uIGRlc2NyaXB0b3IgKi8KKwkJLyoKKwkJICogU0NTSSBuYW1lIHN0cmluZyBkZXNpZ25hdG9yLCBzZWUgc3BjNHIxNworCQkgKiBzZWN0aW9uIDcuNy4zLjExCisJCSAqCisJCSAqIEdldCB0aGUgUFJPVE9DT0wgSURFTlRJRklFUiBhcyBkZWZpbmVkIGJ5IHNwYzRyMTcKKwkJICogc2VjdGlvbiA3LjUuMSBUYWJsZSAzNjIKKwkJICovCitjaGVja19zY3NpX25hbWU6CisJCXNjc2lfbmFtZV9sZW4gPSBzdHJsZW4oVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3d3bih0cGcpKTsKKwkJLyogVVRGLTggIix0LDB4PDE2LWJpdCBUUEdUPiIgKyBOVUxMIFRlcm1pbmF0b3IgKi8KKwkJc2NzaV9uYW1lX2xlbiArPSAxMDsKKwkJLyogQ2hlY2sgZm9yIDQtYnl0ZSBwYWRkaW5nICovCisJCXBhZGRpbmcgPSAoKC1zY3NpX25hbWVfbGVuKSAmIDMpOworCQlpZiAocGFkZGluZyAhPSAwKQorCQkJc2NzaV9uYW1lX2xlbiArPSBwYWRkaW5nOworCQkvKiBIZWFkZXIgc2l6ZSArIERlc2lnbmF0aW9uIGRlc2NyaXB0b3IgKi8KKwkJc2NzaV9uYW1lX2xlbiArPSA0OworCisJCWlmICgoKGxlbiArIDQpICsgc2NzaV9uYW1lX2xlbikgPiBjbWQtPmRhdGFfbGVuZ3RoKSB7CisJCQlsZW4gKz0gc2NzaV9uYW1lX2xlbjsKKwkJCWdvdG8gc2V0X2xlbjsKKwkJfQorCQlidWZbb2ZmXSA9CisJCQkoVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX3Byb3RvX2lkZW50KHRwZykgPDwgNCk7CisJCWJ1ZltvZmYrK10gfD0gMHgzOyAvKiBDT0RFIFNFVCA9PSBVVEYtOCAqLworCQlidWZbb2ZmXSA9IDB4ODA7IC8qIFNldCBQSVY9MSAqLworCQkvKiBTZXQgQVNTT0lDQVRJT04gPT0gdGFyZ2V0IHBvcnQ6IDAxYiAqLworCQlidWZbb2ZmXSB8PSAweDEwOworCQkvKiBERVNJR05BVE9SIFRZUEUgPT0gU0NTSSBuYW1lIHN0cmluZyAqLworCQlidWZbb2ZmKytdIHw9IDB4ODsKKwkJb2ZmICs9IDI7IC8qIFNraXAgb3ZlciBSZXNlcnZlZCBhbmQgbGVuZ3RoICovCisJCS8qCisJCSAqIFNDU0kgbmFtZSBzdHJpbmcgaWRlbnRpZmVyIGNvbnRhaW5pbmcsICRGQUJSSUNfTU9ECisJCSAqIGRlcGVuZGVudCBpbmZvcm1hdGlvbi4gIEZvciBMSU8tVGFyZ2V0IGFuZCBpU0NTSQorCQkgKiBUYXJnZXQgUG9ydCwgdGhpcyBtZWFucyAiPGlTQ1NJIG5hbWU+LHQsMHg8VFBHVD4gaW4KKwkJICogVVRGLTggZW5jb2RpbmcuCisJCSAqLworCQl0cGd0ID0gVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3RhZyh0cGcpOworCQlzY3NpX25hbWVfbGVuID0gc3ByaW50ZigmYnVmW29mZl0sICIlcyx0LDB4JTA0eCIsCisJCQkJCVRQR19URk8odHBnKS0+dHBnX2dldF93d24odHBnKSwgdHBndCk7CisJCXNjc2lfbmFtZV9sZW4gKz0gMSAvKiBJbmNsdWRlICBOVUxMIHRlcm1pbmF0b3IgKi87CisJCS8qCisJCSAqIFRoZSBudWxsLXRlcm1pbmF0ZWQsIG51bGwtcGFkZGVkIChzZWUgNC40LjIpIFNDU0kKKwkJICogTkFNRSBTVFJJTkcgZmllbGQgY29udGFpbnMgYSBVVEYtOCBmb3JtYXQgc3RyaW5nLgorCQkgKiBUaGUgbnVtYmVyIG9mIGJ5dGVzIGluIHRoZSBTQ1NJIE5BTUUgU1RSSU5HIGZpZWxkCisJCSAqIChpLmUuLCB0aGUgdmFsdWUgaW4gdGhlIERFU0lHTkFUT1IgTEVOR1RIIGZpZWxkKQorCQkgKiBzaGFsbCBiZSBubyBsYXJnZXIgdGhhbiAyNTYgYW5kIHNoYWxsIGJlIGEgbXVsdGlwbGUKKwkJICogb2YgZm91ci4KKwkJICovCisJCWlmIChwYWRkaW5nKQorCQkJc2NzaV9uYW1lX2xlbiArPSBwYWRkaW5nOworCisJCWJ1ZltvZmYtMV0gPSBzY3NpX25hbWVfbGVuOworCQlvZmYgKz0gc2NzaV9uYW1lX2xlbjsKKwkJLyogSGVhZGVyIHNpemUgKyBEZXNpZ25hdGlvbiBkZXNjcmlwdG9yICovCisJCWxlbiArPSAoc2NzaV9uYW1lX2xlbiArIDQpOworCX0KK3NldF9sZW46CisJYnVmWzJdID0gKChsZW4gPj4gOCkgJiAweGZmKTsKKwlidWZbM10gPSAobGVuICYgMHhmZik7IC8qIFBhZ2UgTGVuZ3RoIGZvciBWUEQgMHg4MyAqLworCXJldHVybiAwOworfQorCisvKiBFeHRlbmRlZCBJTlFVSVJZIERhdGEgVlBEIFBhZ2UgKi8KK3N0YXRpYyBpbnQKK3RhcmdldF9lbXVsYXRlX2V2cGRfODYoc3RydWN0IHNlX2NtZCAqY21kLCB1bnNpZ25lZCBjaGFyICpidWYpCit7CisJaWYgKGNtZC0+ZGF0YV9sZW5ndGggPCA2MCkKKwkJcmV0dXJuIDA7CisKKwlidWZbMV0gPSAweDg2OworCWJ1ZlsyXSA9IDB4M2M7CisJLyogU2V0IEhFQURTVVAsIE9SRFNVUCwgU0lNUFNVUCAqLworCWJ1Zls1XSA9IDB4MDc7CisKKwkvKiBJZiBXcml0ZUNhY2hlIGVtdWxhdGlvbiBpcyBlbmFibGVkLCBzZXQgVl9TVVAgKi8KKwlpZiAoREVWX0FUVFJJQihTRV9ERVYoY21kKSktPmVtdWxhdGVfd3JpdGVfY2FjaGUgPiAwKQorCQlidWZbNl0gPSAweDAxOworCXJldHVybiAwOworfQorCisvKiBCbG9jayBMaW1pdHMgVlBEIHBhZ2UgKi8KK3N0YXRpYyBpbnQKK3RhcmdldF9lbXVsYXRlX2V2cGRfYjAoc3RydWN0IHNlX2NtZCAqY21kLCB1bnNpZ25lZCBjaGFyICpidWYpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gU0VfREVWKGNtZCk7CisJaW50IGhhdmVfdHAgPSAwOworCisJLyoKKwkgKiBGb2xsb3dpbmcgc2JjM3IyMiBzZWN0aW9uIDYuNS4zIEJsb2NrIExpbWl0cyBWUEQgcGFnZSwgd2hlbgorCSAqIGVtdWxhdGVfdHB1PTEgb3IgZW11bGF0ZV90cHdzPTEgd2Ugd2lsbCBiZSBleHBlY3QgYQorCSAqIGRpZmZlcmVudCBwYWdlIGxlbmd0aCBmb3IgVGhpbiBQcm92aXNpb25pbmcuCisJICovCisJaWYgKERFVl9BVFRSSUIoZGV2KS0+ZW11bGF0ZV90cHUgfHwgREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3Rwd3MpCisJCWhhdmVfdHAgPSAxOworCisJaWYgKGNtZC0+ZGF0YV9sZW5ndGggPCAoMHgxMCArIDQpKSB7CisJCXByaW50ayhLRVJOX0lORk8gIlJlY2VpdmVkIGRhdGFfbGVuZ3RoOiAldSIKKwkJCSIgdG9vIHNtYWxsIGZvciBFVlBEIDB4YjBcbiIsCisJCQljbWQtPmRhdGFfbGVuZ3RoKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmIChoYXZlX3RwICYmIGNtZC0+ZGF0YV9sZW5ndGggPCAoMHgzYyArIDQpKSB7CisJCXByaW50ayhLRVJOX0lORk8gIlJlY2VpdmVkIGRhdGFfbGVuZ3RoOiAldSIKKwkJCSIgdG9vIHNtYWxsIGZvciBUUEU9MSBFVlBEIDB4YjBcbiIsCisJCQljbWQtPmRhdGFfbGVuZ3RoKTsKKwkJaGF2ZV90cCA9IDA7CisJfQorCisJYnVmWzBdID0gZGV2LT50cmFuc3BvcnQtPmdldF9kZXZpY2VfdHlwZShkZXYpOworCWJ1ZlsxXSA9IDB4YjA7CisJYnVmWzNdID0gaGF2ZV90cCA/IDB4M2MgOiAweDEwOworCisJLyoKKwkgKiBTZXQgT1BUSU1BTCBUUkFOU0ZFUiBMRU5HVEggR1JBTlVMQVJJVFkKKwkgKi8KKwlwdXRfdW5hbGlnbmVkX2JlMTYoMSwgJmJ1Zls2XSk7CisKKwkvKgorCSAqIFNldCBNQVhJTVVNIFRSQU5TRkVSIExFTkdUSAorCSAqLworCXB1dF91bmFsaWduZWRfYmUzMihERVZfQVRUUklCKGRldiktPm1heF9zZWN0b3JzLCAmYnVmWzhdKTsKKworCS8qCisJICogU2V0IE9QVElNQUwgVFJBTlNGRVIgTEVOR1RICisJICovCisJcHV0X3VuYWxpZ25lZF9iZTMyKERFVl9BVFRSSUIoZGV2KS0+b3B0aW1hbF9zZWN0b3JzLCAmYnVmWzEyXSk7CisKKwkvKgorCSAqIEV4aXQgbm93IGlmIHdlIGRvbid0IHN1cHBvcnQgVFAgb3IgdGhlIGluaXRpYXRvciBzZW50IGEgdG9vCisJICogc2hvcnQgYnVmZmVyLgorCSAqLworCWlmICghaGF2ZV90cCB8fCBjbWQtPmRhdGFfbGVuZ3RoIDwgKDB4M2MgKyA0KSkKKwkJcmV0dXJuIDA7CisKKwkvKgorCSAqIFNldCBNQVhJTVVNIFVOTUFQIExCQSBDT1VOVAorCSAqLworCXB1dF91bmFsaWduZWRfYmUzMihERVZfQVRUUklCKGRldiktPm1heF91bm1hcF9sYmFfY291bnQsICZidWZbMjBdKTsKKworCS8qCisJICogU2V0IE1BWElNVU0gVU5NQVAgQkxPQ0sgREVTQ1JJUFRPUiBDT1VOVAorCSAqLworCXB1dF91bmFsaWduZWRfYmUzMihERVZfQVRUUklCKGRldiktPm1heF91bm1hcF9ibG9ja19kZXNjX2NvdW50LAorCQkJICAgJmJ1ZlsyNF0pOworCisJLyoKKwkgKiBTZXQgT1BUSU1BTCBVTk1BUCBHUkFOVUxBUklUWQorCSAqLworCXB1dF91bmFsaWduZWRfYmUzMihERVZfQVRUUklCKGRldiktPnVubWFwX2dyYW51bGFyaXR5LCAmYnVmWzI4XSk7CisKKwkvKgorCSAqIFVOTUFQIEdSQU5VTEFSSVRZIEFMSUdOTUVOVAorCSAqLworCXB1dF91bmFsaWduZWRfYmUzMihERVZfQVRUUklCKGRldiktPnVubWFwX2dyYW51bGFyaXR5X2FsaWdubWVudCwKKwkJCSAgICZidWZbMzJdKTsKKwlpZiAoREVWX0FUVFJJQihkZXYpLT51bm1hcF9ncmFudWxhcml0eV9hbGlnbm1lbnQgIT0gMCkKKwkJYnVmWzMyXSB8PSAweDgwOyAvKiBTZXQgdGhlIFVHQVZBTElEIGJpdCAqLworCisJcmV0dXJuIDA7Cit9CisKKy8qIFRoaW4gUHJvdmlzaW9uaW5nIFZQRCAqLworc3RhdGljIGludAordGFyZ2V0X2VtdWxhdGVfZXZwZF9iMihzdHJ1Y3Qgc2VfY21kICpjbWQsIHVuc2lnbmVkIGNoYXIgKmJ1ZikKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKworCS8qCisJICogRnJvbSBzYmMzcjIyIHNlY3Rpb24gNi41LjQgVGhpbiBQcm92aXNpb25pbmcgVlBEIHBhZ2U6CisJICoKKwkgKiBUaGUgUEFHRSBMRU5HVEggZmllbGQgaXMgZGVmaW5lZCBpbiBTUEMtNC4gSWYgdGhlIERQIGJpdCBpcyBzZXQgdG8KKwkgKiB6ZXJvLCB0aGVuIHRoZSBwYWdlIGxlbmd0aCBzaGFsbCBiZSBzZXQgdG8gMDAwNGguICBJZiB0aGUgRFAgYml0CisJICogaXMgc2V0IHRvIG9uZSwgdGhlbiB0aGUgcGFnZSBsZW5ndGggc2hhbGwgYmUgc2V0IHRvIHRoZSB2YWx1ZQorCSAqIGRlZmluZWQgaW4gdGFibGUgMTYyLgorCSAqLworCWJ1ZlswXSA9IGRldi0+dHJhbnNwb3J0LT5nZXRfZGV2aWNlX3R5cGUoZGV2KTsKKwlidWZbMV0gPSAweGIyOworCisJLyoKKwkgKiBTZXQgSGFyZGNvZGVkIGxlbmd0aCBtZW50aW9uZWQgYWJvdmUgZm9yIERQPTAKKwkgKi8KKwlwdXRfdW5hbGlnbmVkX2JlMTYoMHgwMDA0LCAmYnVmWzJdKTsKKworCS8qCisJICogVGhlIFRIUkVTSE9MRCBFWFBPTkVOVCBmaWVsZCBpbmRpY2F0ZXMgdGhlIHRocmVzaG9sZCBzZXQgc2l6ZSBpbgorCSAqIExCQXMgYXMgYSBwb3dlciBvZiAyIChpLmUuLCB0aGUgdGhyZXNob2xkIHNldCBzaXplIGlzIGVxdWFsIHRvCisJICogMih0aHJlc2hvbGQgZXhwb25lbnQpKS4KKwkgKgorCSAqIE5vdGUgdGhhdCB0aGlzIGlzIGN1cnJlbnRseSBzZXQgdG8gMHgwMCBhcyBta3Agc2F5cyBpdCB3aWxsIGJlCisJICogY2hhbmdpbmcgYWdhaW4uICBXZSBjYW4gZW5hYmxlIHRoaXMgb25jZSBpdCBoYXMgc2V0dGxlZCBpbiBUMTAKKwkgKiBhbmQgaXMgYWN0dWFsbHkgdXNlZCBieSBMaW51eC9TQ1NJIE1MIGNvZGUuCisJICovCisJYnVmWzRdID0gMHgwMDsKKworCS8qCisJICogQSBUUFUgYml0IHNldCB0byBvbmUgaW5kaWNhdGVzIHRoYXQgdGhlIGRldmljZSBzZXJ2ZXIgc3VwcG9ydHMKKwkgKiB0aGUgVU5NQVAgY29tbWFuZCAoc2VlIDUuMjUpLiBBIFRQVSBiaXQgc2V0IHRvIHplcm8gaW5kaWNhdGVzCisJICogdGhhdCB0aGUgZGV2aWNlIHNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IHRoZSBVTk1BUCBjb21tYW5kLgorCSAqLworCWlmIChERVZfQVRUUklCKGRldiktPmVtdWxhdGVfdHB1ICE9IDApCisJCWJ1Zls1XSA9IDB4ODA7CisKKwkvKgorCSAqIEEgVFBXUyBiaXQgc2V0IHRvIG9uZSBpbmRpY2F0ZXMgdGhhdCB0aGUgZGV2aWNlIHNlcnZlciBzdXBwb3J0cworCSAqIHRoZSB1c2Ugb2YgdGhlIFdSSVRFIFNBTUUgKDE2KSBjb21tYW5kIChzZWUgNS40MikgdG8gdW5tYXAgTEJBcy4KKwkgKiBBIFRQV1MgYml0IHNldCB0byB6ZXJvIGluZGljYXRlcyB0aGF0IHRoZSBkZXZpY2Ugc2VydmVyIGRvZXMgbm90CisJICogc3VwcG9ydCB0aGUgdXNlIG9mIHRoZSBXUklURSBTQU1FICgxNikgY29tbWFuZCB0byB1bm1hcCBMQkFzLgorCSAqLworCWlmIChERVZfQVRUUklCKGRldiktPmVtdWxhdGVfdHB3cyAhPSAwKQorCQlidWZbNV0gfD0gMHg0MDsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50Cit0YXJnZXRfZW11bGF0ZV9pbnF1aXJ5KHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKwl1bnNpZ25lZCBjaGFyICpidWYgPSBjbWQtPnRfdGFzay0+dF90YXNrX2J1ZjsKKwl1bnNpZ25lZCBjaGFyICpjZGIgPSBjbWQtPnRfdGFzay0+dF90YXNrX2NkYjsKKworCWlmICghKGNkYlsxXSAmIDB4MSkpCisJCXJldHVybiB0YXJnZXRfZW11bGF0ZV9pbnF1aXJ5X3N0ZChjbWQpOworCisJLyoKKwkgKiBNYWtlIHN1cmUgd2UgYXQgbGVhc3QgaGF2ZSA0IGJ5dGVzIG9mIElOUVVJUlkgcmVzcG9uc2UKKwkgKiBwYXlsb2FkIGZvciAweDAwIGdvaW5nIGJhY2sgZm9yIEVWUEQ9MS4gIE5vdGUgdGhhdCAweDgwCisJICogYW5kIDB4ODMgd2lsbCBjaGVjayBmb3IgZW5vdWdoIHBheWxvYWQgZGF0YSBsZW5ndGggYW5kCisJICoganVtcCB0byBzZXRfbGVuOiBsYWJlbCB3aGVuIHRoZXJlIGlzIG5vdCBlbm91Z2ggaW5xdWlyeSBFVlBECisJICogcGF5bG9hZCBsZW5ndGggbGVmdCBmb3IgdGhlIG5leHQgb3V0Z29pbmcgRVZQRCBtZXRhZGF0YQorCSAqLworCWlmIChjbWQtPmRhdGFfbGVuZ3RoIDwgNCkgeworCQlwcmludGsoS0VSTl9FUlIgIlNDU0kgSW5xdWlyeSBwYXlsb2FkIGxlbmd0aDogJXUiCisJCQkiIHRvbyBzbWFsbCBmb3IgRVZQRD0xXG4iLCBjbWQtPmRhdGFfbGVuZ3RoKTsKKwkJcmV0dXJuIC0xOworCX0KKwlidWZbMF0gPSBkZXYtPnRyYW5zcG9ydC0+Z2V0X2RldmljZV90eXBlKGRldik7CisKKwlzd2l0Y2ggKGNkYlsyXSkgeworCWNhc2UgMHgwMDoKKwkJcmV0dXJuIHRhcmdldF9lbXVsYXRlX2V2cGRfMDAoY21kLCBidWYpOworCWNhc2UgMHg4MDoKKwkJcmV0dXJuIHRhcmdldF9lbXVsYXRlX2V2cGRfODAoY21kLCBidWYpOworCWNhc2UgMHg4MzoKKwkJcmV0dXJuIHRhcmdldF9lbXVsYXRlX2V2cGRfODMoY21kLCBidWYpOworCWNhc2UgMHg4NjoKKwkJcmV0dXJuIHRhcmdldF9lbXVsYXRlX2V2cGRfODYoY21kLCBidWYpOworCWNhc2UgMHhiMDoKKwkJcmV0dXJuIHRhcmdldF9lbXVsYXRlX2V2cGRfYjAoY21kLCBidWYpOworCWNhc2UgMHhiMjoKKwkJcmV0dXJuIHRhcmdldF9lbXVsYXRlX2V2cGRfYjIoY21kLCBidWYpOworCWRlZmF1bHQ6CisJCXByaW50ayhLRVJOX0VSUiAiVW5rbm93biBWUEQgQ29kZTogMHglMDJ4XG4iLCBjZGJbMl0pOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQKK3RhcmdldF9lbXVsYXRlX3JlYWRjYXBhY2l0eShzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gU0VfREVWKGNtZCk7CisJdW5zaWduZWQgY2hhciAqYnVmID0gY21kLT50X3Rhc2stPnRfdGFza19idWY7CisJdTMyIGJsb2NrcyA9IGRldi0+dHJhbnNwb3J0LT5nZXRfYmxvY2tzKGRldik7CisKKwlidWZbMF0gPSAoYmxvY2tzID4+IDI0KSAmIDB4ZmY7CisJYnVmWzFdID0gKGJsb2NrcyA+PiAxNikgJiAweGZmOworCWJ1ZlsyXSA9IChibG9ja3MgPj4gOCkgJiAweGZmOworCWJ1ZlszXSA9IGJsb2NrcyAmIDB4ZmY7CisJYnVmWzRdID0gKERFVl9BVFRSSUIoZGV2KS0+YmxvY2tfc2l6ZSA+PiAyNCkgJiAweGZmOworCWJ1Zls1XSA9IChERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUgPj4gMTYpICYgMHhmZjsKKwlidWZbNl0gPSAoREVWX0FUVFJJQihkZXYpLT5ibG9ja19zaXplID4+IDgpICYgMHhmZjsKKwlidWZbN10gPSBERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUgJiAweGZmOworCS8qCisJICogU2V0IG1heCAzMi1iaXQgYmxvY2tzIHRvIHNpZ25hbCBTRVJWSUNFIEFDVElPTiBSRUFEX0NBUEFDSVRZXzE2CisJKi8KKwlpZiAoREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3RwdSB8fCBERVZfQVRUUklCKGRldiktPmVtdWxhdGVfdHB3cykKKwkJcHV0X3VuYWxpZ25lZF9iZTMyKDB4RkZGRkZGRkYsICZidWZbMF0pOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQKK3RhcmdldF9lbXVsYXRlX3JlYWRjYXBhY2l0eV8xNihzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gU0VfREVWKGNtZCk7CisJdW5zaWduZWQgY2hhciAqYnVmID0gY21kLT50X3Rhc2stPnRfdGFza19idWY7CisJdW5zaWduZWQgbG9uZyBsb25nIGJsb2NrcyA9IGRldi0+dHJhbnNwb3J0LT5nZXRfYmxvY2tzKGRldik7CisKKwlidWZbMF0gPSAoYmxvY2tzID4+IDU2KSAmIDB4ZmY7CisJYnVmWzFdID0gKGJsb2NrcyA+PiA0OCkgJiAweGZmOworCWJ1ZlsyXSA9IChibG9ja3MgPj4gNDApICYgMHhmZjsKKwlidWZbM10gPSAoYmxvY2tzID4+IDMyKSAmIDB4ZmY7CisJYnVmWzRdID0gKGJsb2NrcyA+PiAyNCkgJiAweGZmOworCWJ1Zls1XSA9IChibG9ja3MgPj4gMTYpICYgMHhmZjsKKwlidWZbNl0gPSAoYmxvY2tzID4+IDgpICYgMHhmZjsKKwlidWZbN10gPSBibG9ja3MgJiAweGZmOworCWJ1Zls4XSA9IChERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUgPj4gMjQpICYgMHhmZjsKKwlidWZbOV0gPSAoREVWX0FUVFJJQihkZXYpLT5ibG9ja19zaXplID4+IDE2KSAmIDB4ZmY7CisJYnVmWzEwXSA9IChERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUgPj4gOCkgJiAweGZmOworCWJ1ZlsxMV0gPSBERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUgJiAweGZmOworCS8qCisJICogU2V0IFRoaW4gUHJvdmlzaW9uaW5nIEVuYWJsZSBiaXQgZm9sbG93aW5nIHNiYzNyMjIgaW4gc2VjdGlvbgorCSAqIFJFQUQgQ0FQQUNJVFkgKDE2KSBieXRlIDE0IGlmIGVtdWxhdGVfdHB1IG9yIGVtdWxhdGVfdHB3cyBpcyBlbmFibGVkLgorCSAqLworCWlmIChERVZfQVRUUklCKGRldiktPmVtdWxhdGVfdHB1IHx8IERFVl9BVFRSSUIoZGV2KS0+ZW11bGF0ZV90cHdzKQorCQlidWZbMTRdID0gMHg4MDsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50Cit0YXJnZXRfbW9kZXNlbnNlX3J3cmVjb3ZlcnkodW5zaWduZWQgY2hhciAqcCkKK3sKKwlwWzBdID0gMHgwMTsKKwlwWzFdID0gMHgwYTsKKworCXJldHVybiAxMjsKK30KKworc3RhdGljIGludAordGFyZ2V0X21vZGVzZW5zZV9jb250cm9sKHN0cnVjdCBzZV9kZXZpY2UgKmRldiwgdW5zaWduZWQgY2hhciAqcCkKK3sKKwlwWzBdID0gMHgwYTsKKwlwWzFdID0gMHgwYTsKKwlwWzJdID0gMjsKKwkvKgorCSAqIEZyb20gc3BjNHIxNywgc2VjdGlvbiA3LjQuNiBDb250cm9sIG1vZGUgUGFnZQorCSAqCisJICogVW5pdCBBdHRlbnRpb24gaW50ZXJsb2NrcyBjb250cm9sIChVTl9JTlRMQ0tfQ1RSTCkgdG8gY29kZSAwMGIKKwkgKgorCSAqIDAwYjogVGhlIGxvZ2ljYWwgdW5pdCBzaGFsbCBjbGVhciBhbnkgdW5pdCBhdHRlbnRpb24gY29uZGl0aW9uCisJICogcmVwb3J0ZWQgaW4gdGhlIHNhbWUgSV9UX0xfUSBuZXh1cyB0cmFuc2FjdGlvbiBhcyBhIENIRUNLIENPTkRJVElPTgorCSAqIHN0YXR1cyBhbmQgc2hhbGwgbm90IGVzdGFibGlzaCBhIHVuaXQgYXR0ZW50aW9uIGNvbmRpdGlvbiB3aGVuIGEgY29tLQorCSAqIG1hbmQgaXMgY29tcGxldGVkIHdpdGggQlVTWSwgVEFTSyBTRVQgRlVMTCwgb3IgUkVTRVJWQVRJT04gQ09ORkxJQ1QKKwkgKiBzdGF0dXMuCisJICoKKwkgKiAxMGI6IFRoZSBsb2dpY2FsIHVuaXQgc2hhbGwgbm90IGNsZWFyIGFueSB1bml0IGF0dGVudGlvbiBjb25kaXRpb24KKwkgKiByZXBvcnRlZCBpbiB0aGUgc2FtZSBJX1RfTF9RIG5leHVzIHRyYW5zYWN0aW9uIGFzIGEgQ0hFQ0sgQ09ORElUSU9OCisJICogc3RhdHVzIGFuZCBzaGFsbCBub3QgZXN0YWJsaXNoIGEgdW5pdCBhdHRlbnRpb24gY29uZGl0aW9uIHdoZW4KKwkgKiBhIGNvbW1hbmQgaXMgY29tcGxldGVkIHdpdGggQlVTWSwgVEFTSyBTRVQgRlVMTCwgb3IgUkVTRVJWQVRJT04KKwkgKiBDT05GTElDVCBzdGF0dXMuCisJICoKKwkgKiAxMWIgYSBUaGUgbG9naWNhbCB1bml0IHNoYWxsIG5vdCBjbGVhciBhbnkgdW5pdCBhdHRlbnRpb24gY29uZGl0aW9uCisJICogcmVwb3J0ZWQgaW4gdGhlIHNhbWUgSV9UX0xfUSBuZXh1cyB0cmFuc2FjdGlvbiBhcyBhIENIRUNLIENPTkRJVElPTgorCSAqIHN0YXR1cyBhbmQgc2hhbGwgZXN0YWJsaXNoIGEgdW5pdCBhdHRlbnRpb24gY29uZGl0aW9uIGZvciB0aGUKKwkgKiBpbml0aWF0b3IgcG9ydCBhc3NvY2lhdGVkIHdpdGggdGhlIElfVCBuZXh1cyBvbiB3aGljaCB0aGUgQlVTWSwKKwkgKiBUQVNLIFNFVCBGVUxMLCBvciBSRVNFUlZBVElPTiBDT05GTElDVCBzdGF0dXMgaXMgYmVpbmcgcmV0dXJuZWQuCisJICogRGVwZW5kaW5nIG9uIHRoZSBzdGF0dXMsIHRoZSBhZGRpdGlvbmFsIHNlbnNlIGNvZGUgc2hhbGwgYmUgc2V0IHRvCisJICogUFJFVklPVVMgQlVTWSBTVEFUVVMsIFBSRVZJT1VTIFRBU0sgU0VUIEZVTEwgU1RBVFVTLCBvciBQUkVWSU9VUworCSAqIFJFU0VSVkFUSU9OIENPTkZMSUNUIFNUQVRVUy4gVW50aWwgaXQgaXMgY2xlYXJlZCBieSBhIFJFUVVFU1QgU0VOU0UKKwkgKiBjb21tYW5kLCBhIHVuaXQgYXR0ZW50aW9uIGNvbmRpdGlvbiBzaGFsbCBiZSBlc3RhYmxpc2hlZCBvbmx5IG9uY2UKKwkgKiBmb3IgYSBCVVNZLCBUQVNLIFNFVCBGVUxMLCBvciBSRVNFUlZBVElPTiBDT05GTElDVCBzdGF0dXMgcmVnYXJkbGVzcworCSAqIHRvIHRoZSBudW1iZXIgb2YgY29tbWFuZHMgY29tcGxldGVkIHdpdGggb25lIG9mIHRob3NlIHN0YXR1cyBjb2Rlcy4KKwkgKi8KKwlwWzRdID0gKERFVl9BVFRSSUIoZGV2KS0+ZW11bGF0ZV91YV9pbnRsY2tfY3RybCA9PSAyKSA/IDB4MzAgOgorCSAgICAgICAoREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3VhX2ludGxja19jdHJsID09IDEpID8gMHgyMCA6IDB4MDA7CisJLyoKKwkgKiBGcm9tIHNwYzRyMTcsIHNlY3Rpb24gNy40LjYgQ29udHJvbCBtb2RlIFBhZ2UKKwkgKgorCSAqIFRhc2sgQWJvcnRlZCBTdGF0dXMgKFRBUykgYml0IHNldCB0byB6ZXJvLgorCSAqCisJICogQSB0YXNrIGFib3J0ZWQgc3RhdHVzIChUQVMpIGJpdCBzZXQgdG8gemVybyBzcGVjaWZpZXMgdGhhdCBhYm9ydGVkCisJICogdGFza3Mgc2hhbGwgYmUgdGVybWluYXRlZCBieSB0aGUgZGV2aWNlIHNlcnZlciB3aXRob3V0IGFueSByZXNwb25zZQorCSAqIHRvIHRoZSBhcHBsaWNhdGlvbiBjbGllbnQuIEEgVEFTIGJpdCBzZXQgdG8gb25lIHNwZWNpZmllcyB0aGF0IHRhc2tzCisJICogYWJvcnRlZCBieSB0aGUgYWN0aW9ucyBvZiBhbiBJX1QgbmV4dXMgb3RoZXIgdGhhbiB0aGUgSV9UIG5leHVzIG9uCisJICogd2hpY2ggdGhlIGNvbW1hbmQgd2FzIHJlY2VpdmVkIHNoYWxsIGJlIGNvbXBsZXRlZCB3aXRoIFRBU0sgQUJPUlRFRAorCSAqIHN0YXR1cyAoc2VlIFNBTS00KS4KKwkgKi8KKwlwWzVdID0gKERFVl9BVFRSSUIoZGV2KS0+ZW11bGF0ZV90YXMpID8gMHg0MCA6IDB4MDA7CisJcFs4XSA9IDB4ZmY7CisJcFs5XSA9IDB4ZmY7CisJcFsxMV0gPSAzMDsKKworCXJldHVybiAxMjsKK30KKworc3RhdGljIGludAordGFyZ2V0X21vZGVzZW5zZV9jYWNoaW5nKHN0cnVjdCBzZV9kZXZpY2UgKmRldiwgdW5zaWduZWQgY2hhciAqcCkKK3sKKwlwWzBdID0gMHgwODsKKwlwWzFdID0gMHgxMjsKKwlpZiAoREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3dyaXRlX2NhY2hlID4gMCkKKwkJcFsyXSA9IDB4MDQ7IC8qIFdyaXRlIENhY2hlIEVuYWJsZSAqLworCXBbMTJdID0gMHgyMDsgLyogRGlzYWJsZWQgUmVhZCBBaGVhZCAqLworCisJcmV0dXJuIDIwOworfQorCitzdGF0aWMgdm9pZAordGFyZ2V0X21vZGVzZW5zZV93cml0ZV9wcm90ZWN0KHVuc2lnbmVkIGNoYXIgKmJ1ZiwgaW50IHR5cGUpCit7CisJLyoKKwkgKiBJIGJlbGlldmUgdGhhdCB0aGUgV1AgYml0IChiaXQgNykgaW4gdGhlIG1vZGUgaGVhZGVyIGlzIHRoZSBzYW1lIGZvcgorCSAqIGFsbCBkZXZpY2UgdHlwZXMuLgorCSAqLworCXN3aXRjaCAodHlwZSkgeworCWNhc2UgVFlQRV9ESVNLOgorCWNhc2UgVFlQRV9UQVBFOgorCWRlZmF1bHQ6CisJCWJ1ZlswXSB8PSAweDgwOyAvKiBXUCBiaXQgKi8KKwkJYnJlYWs7CisJfQorfQorCitzdGF0aWMgdm9pZAordGFyZ2V0X21vZGVzZW5zZV9kcG9mdWEodW5zaWduZWQgY2hhciAqYnVmLCBpbnQgdHlwZSkKK3sKKwlzd2l0Y2ggKHR5cGUpIHsKKwljYXNlIFRZUEVfRElTSzoKKwkJYnVmWzBdIHw9IDB4MTA7IC8qIERQT0ZVQSBiaXQgKi8KKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYnJlYWs7CisJfQorfQorCitzdGF0aWMgaW50Cit0YXJnZXRfZW11bGF0ZV9tb2Rlc2Vuc2Uoc3RydWN0IHNlX2NtZCAqY21kLCBpbnQgdGVuKQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IFNFX0RFVihjbWQpOworCWNoYXIgKmNkYiA9IGNtZC0+dF90YXNrLT50X3Rhc2tfY2RiOworCXVuc2lnbmVkIGNoYXIgKnJidWYgPSBjbWQtPnRfdGFzay0+dF90YXNrX2J1ZjsKKwlpbnQgdHlwZSA9IGRldi0+dHJhbnNwb3J0LT5nZXRfZGV2aWNlX3R5cGUoZGV2KTsKKwlpbnQgb2Zmc2V0ID0gKHRlbikgPyA4IDogNDsKKwlpbnQgbGVuZ3RoID0gMDsKKwl1bnNpZ25lZCBjaGFyIGJ1ZltTRV9NT0RFX1BBR0VfQlVGXTsKKworCW1lbXNldChidWYsIDAsIFNFX01PREVfUEFHRV9CVUYpOworCisJc3dpdGNoIChjZGJbMl0gJiAweDNmKSB7CisJY2FzZSAweDAxOgorCQlsZW5ndGggPSB0YXJnZXRfbW9kZXNlbnNlX3J3cmVjb3ZlcnkoJmJ1ZltvZmZzZXRdKTsKKwkJYnJlYWs7CisJY2FzZSAweDA4OgorCQlsZW5ndGggPSB0YXJnZXRfbW9kZXNlbnNlX2NhY2hpbmcoZGV2LCAmYnVmW29mZnNldF0pOworCQlicmVhazsKKwljYXNlIDB4MGE6CisJCWxlbmd0aCA9IHRhcmdldF9tb2Rlc2Vuc2VfY29udHJvbChkZXYsICZidWZbb2Zmc2V0XSk7CisJCWJyZWFrOworCWNhc2UgMHgzZjoKKwkJbGVuZ3RoID0gdGFyZ2V0X21vZGVzZW5zZV9yd3JlY292ZXJ5KCZidWZbb2Zmc2V0XSk7CisJCWxlbmd0aCArPSB0YXJnZXRfbW9kZXNlbnNlX2NhY2hpbmcoZGV2LCAmYnVmW29mZnNldCtsZW5ndGhdKTsKKwkJbGVuZ3RoICs9IHRhcmdldF9tb2Rlc2Vuc2VfY29udHJvbChkZXYsICZidWZbb2Zmc2V0K2xlbmd0aF0pOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlwcmludGsoS0VSTl9FUlIgIkdvdCBVbmtub3duIE1vZGUgUGFnZTogMHglMDJ4XG4iLAorCQkJCWNkYlsyXSAmIDB4M2YpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9VTktOT1dOX01PREVfUEFHRTsKKwl9CisJb2Zmc2V0ICs9IGxlbmd0aDsKKworCWlmICh0ZW4pIHsKKwkJb2Zmc2V0IC09IDI7CisJCWJ1ZlswXSA9IChvZmZzZXQgPj4gOCkgJiAweGZmOworCQlidWZbMV0gPSBvZmZzZXQgJiAweGZmOworCisJCWlmICgoU0VfTFVOKGNtZCktPmx1bl9hY2Nlc3MgJiBUUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9PTkxZKSB8fAorCQkgICAgKGNtZC0+c2VfZGV2ZSAmJgorCQkgICAgKGNtZC0+c2VfZGV2ZS0+bHVuX2ZsYWdzICYgVFJBTlNQT1JUX0xVTkZMQUdTX1JFQURfT05MWSkpKQorCQkJdGFyZ2V0X21vZGVzZW5zZV93cml0ZV9wcm90ZWN0KCZidWZbM10sIHR5cGUpOworCisJCWlmICgoREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3dyaXRlX2NhY2hlID4gMCkgJiYKKwkJICAgIChERVZfQVRUUklCKGRldiktPmVtdWxhdGVfZnVhX3dyaXRlID4gMCkpCisJCQl0YXJnZXRfbW9kZXNlbnNlX2Rwb2Z1YSgmYnVmWzNdLCB0eXBlKTsKKworCQlpZiAoKG9mZnNldCArIDIpID4gY21kLT5kYXRhX2xlbmd0aCkKKwkJCW9mZnNldCA9IGNtZC0+ZGF0YV9sZW5ndGg7CisKKwl9IGVsc2UgeworCQlvZmZzZXQgLT0gMTsKKwkJYnVmWzBdID0gb2Zmc2V0ICYgMHhmZjsKKworCQlpZiAoKFNFX0xVTihjbWQpLT5sdW5fYWNjZXNzICYgVFJBTlNQT1JUX0xVTkZMQUdTX1JFQURfT05MWSkgfHwKKwkJICAgIChjbWQtPnNlX2RldmUgJiYKKwkJICAgIChjbWQtPnNlX2RldmUtPmx1bl9mbGFncyAmIFRSQU5TUE9SVF9MVU5GTEFHU19SRUFEX09OTFkpKSkKKwkJCXRhcmdldF9tb2Rlc2Vuc2Vfd3JpdGVfcHJvdGVjdCgmYnVmWzJdLCB0eXBlKTsKKworCQlpZiAoKERFVl9BVFRSSUIoZGV2KS0+ZW11bGF0ZV93cml0ZV9jYWNoZSA+IDApICYmCisJCSAgICAoREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX2Z1YV93cml0ZSA+IDApKQorCQkJdGFyZ2V0X21vZGVzZW5zZV9kcG9mdWEoJmJ1ZlsyXSwgdHlwZSk7CisKKwkJaWYgKChvZmZzZXQgKyAxKSA+IGNtZC0+ZGF0YV9sZW5ndGgpCisJCQlvZmZzZXQgPSBjbWQtPmRhdGFfbGVuZ3RoOworCX0KKwltZW1jcHkocmJ1ZiwgYnVmLCBvZmZzZXQpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQKK3RhcmdldF9lbXVsYXRlX3JlcXVlc3Rfc2Vuc2Uoc3RydWN0IHNlX2NtZCAqY21kKQoreworCXVuc2lnbmVkIGNoYXIgKmNkYiA9IGNtZC0+dF90YXNrLT50X3Rhc2tfY2RiOworCXVuc2lnbmVkIGNoYXIgKmJ1ZiA9IGNtZC0+dF90YXNrLT50X3Rhc2tfYnVmOworCXU4IHVhX2FzYyA9IDAsIHVhX2FzY3EgPSAwOworCisJaWYgKGNkYlsxXSAmIDB4MDEpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJSRVFVRVNUX1NFTlNFIGRlc2NyaXB0aW9uIGVtdWxhdGlvbiBub3QiCisJCQkiIHN1cHBvcnRlZFxuIik7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0lOVkFMSURfQ0RCX0ZJRUxEOworCX0KKwlpZiAoIShjb3JlX3Njc2kzX3VhX2NsZWFyX2Zvcl9yZXF1ZXN0X3NlbnNlKGNtZCwgJnVhX2FzYywgJnVhX2FzY3EpKSkgeworCQkvKgorCQkgKiBDVVJSRU5UIEVSUk9SLCBVTklUIEFUVEVOVElPTgorCQkgKi8KKwkJYnVmWzBdID0gMHg3MDsKKwkJYnVmW1NQQ19TRU5TRV9LRVlfT0ZGU0VUXSA9IFVOSVRfQVRURU5USU9OOworCQkvKgorCQkgKiBNYWtlIHN1cmUgcmVxdWVzdCBkYXRhIGxlbmd0aCBpcyBlbm91Z2ggZm9yIGFkZGl0aW9uYWwKKwkJICogc2Vuc2UgZGF0YS4KKwkJICovCisJCWlmIChjbWQtPmRhdGFfbGVuZ3RoIDw9IDE4KSB7CisJCQlidWZbN10gPSAweDAwOworCQkJcmV0dXJuIDA7CisJCX0KKwkJLyoKKwkJICogVGhlIEFkZGl0aW9uYWwgU2Vuc2UgQ29kZSAoQVNDKSBmcm9tIHRoZSBVTklUIEFUVEVOVElPTgorCQkgKi8KKwkJYnVmW1NQQ19BU0NfS0VZX09GRlNFVF0gPSB1YV9hc2M7CisJCWJ1ZltTUENfQVNDUV9LRVlfT0ZGU0VUXSA9IHVhX2FzY3E7CisJCWJ1Zls3XSA9IDB4MEE7CisJfSBlbHNlIHsKKwkJLyoKKwkJICogQ1VSUkVOVCBFUlJPUiwgTk8gU0VOU0UKKwkJICovCisJCWJ1ZlswXSA9IDB4NzA7CisJCWJ1ZltTUENfU0VOU0VfS0VZX09GRlNFVF0gPSBOT19TRU5TRTsKKwkJLyoKKwkJICogTWFrZSBzdXJlIHJlcXVlc3QgZGF0YSBsZW5ndGggaXMgZW5vdWdoIGZvciBhZGRpdGlvbmFsCisJCSAqIHNlbnNlIGRhdGEuCisJCSAqLworCQlpZiAoY21kLT5kYXRhX2xlbmd0aCA8PSAxOCkgeworCQkJYnVmWzddID0gMHgwMDsKKwkJCXJldHVybiAwOworCQl9CisJCS8qCisJCSAqIE5PIEFERElUSU9OQUwgU0VOU0UgSU5GT1JNQVRJT04KKwkJICovCisJCWJ1ZltTUENfQVNDX0tFWV9PRkZTRVRdID0gMHgwMDsKKwkJYnVmWzddID0gMHgwQTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworLyoKKyAqIFVzZWQgZm9yIFRDTS9JQkxPQ0sgYW5kIFRDTS9GSUxFSU8gZm9yIGJsb2NrL2Jsay1saWIuYyBsZXZlbCBkaXNjYXJkIHN1cHBvcnQuCisgKiBOb3RlIHRoaXMgaXMgbm90IHVzZWQgZm9yIFRDTS9wU0NTSSBwYXNzdGhyb3VnaAorICovCitzdGF0aWMgaW50Cit0YXJnZXRfZW11bGF0ZV91bm1hcChzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlzdHJ1Y3Qgc2VfY21kICpjbWQgPSBUQVNLX0NNRCh0YXNrKTsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKwl1bnNpZ25lZCBjaGFyICpidWYgPSBjbWQtPnRfdGFzay0+dF90YXNrX2J1ZiwgKnB0ciA9IE5VTEw7CisJdW5zaWduZWQgY2hhciAqY2RiID0gJmNtZC0+dF90YXNrLT50X3Rhc2tfY2RiWzBdOworCXNlY3Rvcl90IGxiYTsKKwl1bnNpZ25lZCBpbnQgc2l6ZSA9IGNtZC0+ZGF0YV9sZW5ndGgsIHJhbmdlOworCWludCByZXQsIG9mZnNldDsKKwl1bnNpZ25lZCBzaG9ydCBkbCwgYmRfZGw7CisKKwkvKiBGaXJzdCBVTk1BUCBibG9jayBkZXNjcmlwdG9yIHN0YXJ0cyBhdCA4IGJ5dGUgb2Zmc2V0ICovCisJb2Zmc2V0ID0gODsKKwlzaXplIC09IDg7CisJZGwgPSBnZXRfdW5hbGlnbmVkX2JlMTYoJmNkYlswXSk7CisJYmRfZGwgPSBnZXRfdW5hbGlnbmVkX2JlMTYoJmNkYlsyXSk7CisJcHRyID0gJmJ1ZltvZmZzZXRdOworCXByaW50ayhLRVJOX0lORk8gIlVOTUFQOiBTdWI6ICVzIFVzaW5nIGRsOiAlaHUgYmRfZGw6ICVodSBzaXplOiAlaHUiCisJCSIgcHRyOiAlcFxuIiwgZGV2LT50cmFuc3BvcnQtPm5hbWUsIGRsLCBiZF9kbCwgc2l6ZSwgcHRyKTsKKworCXdoaWxlIChzaXplKSB7CisJCWxiYSA9IGdldF91bmFsaWduZWRfYmU2NCgmcHRyWzBdKTsKKwkJcmFuZ2UgPSBnZXRfdW5hbGlnbmVkX2JlMzIoJnB0cls4XSk7CisJCXByaW50ayhLRVJOX0lORk8gIlVOTUFQOiBVc2luZyBsYmE6ICVsbHUgYW5kIHJhbmdlOiAldVxuIiwKKwkJCQkgKHVuc2lnbmVkIGxvbmcgbG9uZylsYmEsIHJhbmdlKTsKKworCQlyZXQgPSBkZXYtPnRyYW5zcG9ydC0+ZG9fZGlzY2FyZChkZXYsIGxiYSwgcmFuZ2UpOworCQlpZiAocmV0IDwgMCkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJibGtkZXZfaXNzdWVfZGlzY2FyZCgpIGZhaWxlZDogJWRcbiIsCisJCQkJCXJldCk7CisJCQlyZXR1cm4gLTE7CisJCX0KKworCQlwdHIgKz0gMTY7CisJCXNpemUgLT0gMTY7CisJfQorCisJdGFzay0+dGFza19zY3NpX3N0YXR1cyA9IEdPT0Q7CisJdHJhbnNwb3J0X2NvbXBsZXRlX3Rhc2sodGFzaywgMSk7CisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBVc2VkIGZvciBUQ00vSUJMT0NLIGFuZCBUQ00vRklMRUlPIGZvciBibG9jay9ibGstbGliLmMgbGV2ZWwgZGlzY2FyZCBzdXBwb3J0LgorICogTm90ZSB0aGlzIGlzIG5vdCB1c2VkIGZvciBUQ00vcFNDU0kgcGFzc3Rocm91Z2gKKyAqLworc3RhdGljIGludAordGFyZ2V0X2VtdWxhdGVfd3JpdGVfc2FtZShzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlzdHJ1Y3Qgc2VfY21kICpjbWQgPSBUQVNLX0NNRCh0YXNrKTsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKwlzZWN0b3JfdCBsYmEgPSBjbWQtPnRfdGFzay0+dF90YXNrX2xiYTsKKwl1bnNpZ25lZCBpbnQgcmFuZ2U7CisJaW50IHJldDsKKworCXJhbmdlID0gKGNtZC0+ZGF0YV9sZW5ndGggLyBERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiV1JJVEVfU0FNRSBVTk1BUDogTEJBOiAlbGx1IFJhbmdlOiAldVxuIiwKKwkJCSAodW5zaWduZWQgbG9uZyBsb25nKWxiYSwgcmFuZ2UpOworCisJcmV0ID0gZGV2LT50cmFuc3BvcnQtPmRvX2Rpc2NhcmQoZGV2LCBsYmEsIHJhbmdlKTsKKwlpZiAocmV0IDwgMCkgeworCQlwcmludGsoS0VSTl9JTkZPICJibGtkZXZfaXNzdWVfZGlzY2FyZCgpIGZhaWxlZCBmb3IgV1JJVEVfU0FNRVxuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwl0YXNrLT50YXNrX3Njc2lfc3RhdHVzID0gR09PRDsKKwl0cmFuc3BvcnRfY29tcGxldGVfdGFzayh0YXNrLCAxKTsKKwlyZXR1cm4gMDsKK30KKworaW50Cit0cmFuc3BvcnRfZW11bGF0ZV9jb250cm9sX2NkYihzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlzdHJ1Y3Qgc2VfY21kICpjbWQgPSBUQVNLX0NNRCh0YXNrKTsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKwl1bnNpZ25lZCBzaG9ydCBzZXJ2aWNlX2FjdGlvbjsKKwlpbnQgcmV0ID0gMDsKKworCXN3aXRjaCAoY21kLT50X3Rhc2stPnRfdGFza19jZGJbMF0pIHsKKwljYXNlIElOUVVJUlk6CisJCXJldCA9IHRhcmdldF9lbXVsYXRlX2lucXVpcnkoY21kKTsKKwkJYnJlYWs7CisJY2FzZSBSRUFEX0NBUEFDSVRZOgorCQlyZXQgPSB0YXJnZXRfZW11bGF0ZV9yZWFkY2FwYWNpdHkoY21kKTsKKwkJYnJlYWs7CisJY2FzZSBNT0RFX1NFTlNFOgorCQlyZXQgPSB0YXJnZXRfZW11bGF0ZV9tb2Rlc2Vuc2UoY21kLCAwKTsKKwkJYnJlYWs7CisJY2FzZSBNT0RFX1NFTlNFXzEwOgorCQlyZXQgPSB0YXJnZXRfZW11bGF0ZV9tb2Rlc2Vuc2UoY21kLCAxKTsKKwkJYnJlYWs7CisJY2FzZSBTRVJWSUNFX0FDVElPTl9JTjoKKwkJc3dpdGNoIChjbWQtPnRfdGFzay0+dF90YXNrX2NkYlsxXSAmIDB4MWYpIHsKKwkJY2FzZSBTQUlfUkVBRF9DQVBBQ0lUWV8xNjoKKwkJCXJldCA9IHRhcmdldF9lbXVsYXRlX3JlYWRjYXBhY2l0eV8xNihjbWQpOworCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisJCQlwcmludGsoS0VSTl9FUlIgIlVuc3VwcG9ydGVkIFNBOiAweCUwMnhcbiIsCisJCQkJY21kLT50X3Rhc2stPnRfdGFza19jZGJbMV0gJiAweDFmKTsKKwkJCXJldHVybiBQWVhfVFJBTlNQT1JUX1VOS05PV05fU0FNX09QQ09ERTsKKwkJfQorCQlicmVhazsKKwljYXNlIFJFUVVFU1RfU0VOU0U6CisJCXJldCA9IHRhcmdldF9lbXVsYXRlX3JlcXVlc3Rfc2Vuc2UoY21kKTsKKwkJYnJlYWs7CisJY2FzZSBVTk1BUDoKKwkJaWYgKCFkZXYtPnRyYW5zcG9ydC0+ZG9fZGlzY2FyZCkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJVTk1BUCBlbXVsYXRpb24gbm90IHN1cHBvcnRlZCBmb3I6ICVzXG4iLAorCQkJCQlkZXYtPnRyYW5zcG9ydC0+bmFtZSk7CisJCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9VTktOT1dOX1NBTV9PUENPREU7CisJCX0KKwkJcmV0ID0gdGFyZ2V0X2VtdWxhdGVfdW5tYXAodGFzayk7CisJCWJyZWFrOworCWNhc2UgV1JJVEVfU0FNRV8xNjoKKwkJaWYgKCFkZXYtPnRyYW5zcG9ydC0+ZG9fZGlzY2FyZCkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJXUklURV9TQU1FXzE2IGVtdWxhdGlvbiBub3Qgc3VwcG9ydGVkIgorCQkJCQkiIGZvcjogJXNcbiIsIGRldi0+dHJhbnNwb3J0LT5uYW1lKTsKKwkJCXJldHVybiBQWVhfVFJBTlNQT1JUX1VOS05PV05fU0FNX09QQ09ERTsKKwkJfQorCQlyZXQgPSB0YXJnZXRfZW11bGF0ZV93cml0ZV9zYW1lKHRhc2spOworCQlicmVhazsKKwljYXNlIFZBUklBQkxFX0xFTkdUSF9DTUQ6CisJCXNlcnZpY2VfYWN0aW9uID0KKwkJCWdldF91bmFsaWduZWRfYmUxNigmY21kLT50X3Rhc2stPnRfdGFza19jZGJbOF0pOworCQlzd2l0Y2ggKHNlcnZpY2VfYWN0aW9uKSB7CisJCWNhc2UgV1JJVEVfU0FNRV8zMjoKKwkJCWlmICghZGV2LT50cmFuc3BvcnQtPmRvX2Rpc2NhcmQpIHsKKwkJCQlwcmludGsoS0VSTl9FUlIgIldSSVRFX1NBTUVfMzIgU0EgZW11bGF0aW9uIG5vdCIKKwkJCQkJIiBzdXBwb3J0ZWQgZm9yOiAlc1xuIiwKKwkJCQkJZGV2LT50cmFuc3BvcnQtPm5hbWUpOworCQkJCXJldHVybiBQWVhfVFJBTlNQT1JUX1VOS05PV05fU0FNX09QQ09ERTsKKwkJCX0KKwkJCXJldCA9IHRhcmdldF9lbXVsYXRlX3dyaXRlX3NhbWUodGFzayk7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5zdXBwb3J0ZWQgVkFSSUFCTEVfTEVOR1RIX0NNRCBTQToiCisJCQkJCSIgMHglMDJ4XG4iLCBzZXJ2aWNlX2FjdGlvbik7CisJCQlicmVhazsKKwkJfQorCQlicmVhazsKKwljYXNlIFNZTkNIUk9OSVpFX0NBQ0hFOgorCWNhc2UgMHg5MTogLyogU1lOQ0hST05JWkVfQ0FDSEVfMTY6ICovCisJCWlmICghZGV2LT50cmFuc3BvcnQtPmRvX3N5bmNfY2FjaGUpIHsKKwkJCXByaW50ayhLRVJOX0VSUgorCQkJCSJTWU5DSFJPTklaRV9DQUNIRSBlbXVsYXRpb24gbm90IHN1cHBvcnRlZCIKKwkJCQkiIGZvcjogJXNcbiIsIGRldi0+dHJhbnNwb3J0LT5uYW1lKTsKKwkJCXJldHVybiBQWVhfVFJBTlNQT1JUX1VOS05PV05fU0FNX09QQ09ERTsKKwkJfQorCQlkZXYtPnRyYW5zcG9ydC0+ZG9fc3luY19jYWNoZSh0YXNrKTsKKwkJYnJlYWs7CisJY2FzZSBBTExPV19NRURJVU1fUkVNT1ZBTDoKKwljYXNlIEVSQVNFOgorCWNhc2UgUkVaRVJPX1VOSVQ6CisJY2FzZSBTRUVLXzEwOgorCWNhc2UgU1BBQ0U6CisJY2FzZSBTVEFSVF9TVE9QOgorCWNhc2UgVEVTVF9VTklUX1JFQURZOgorCWNhc2UgVkVSSUZZOgorCWNhc2UgV1JJVEVfRklMRU1BUktTOgorCQlicmVhazsKKwlkZWZhdWx0OgorCQlwcmludGsoS0VSTl9FUlIgIlVuc3VwcG9ydGVkIFNDU0kgT3Bjb2RlOiAweCUwMnggZm9yICVzXG4iLAorCQkJY21kLT50X3Rhc2stPnRfdGFza19jZGJbMF0sIGRldi0+dHJhbnNwb3J0LT5uYW1lKTsKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfVU5LTk9XTl9TQU1fT1BDT0RFOworCX0KKworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCXRhc2stPnRhc2tfc2NzaV9zdGF0dXMgPSBHT09EOworCXRyYW5zcG9ydF9jb21wbGV0ZV90YXNrKHRhc2ssIDEpOworCisJcmV0dXJuIFBZWF9UUkFOU1BPUlRfU0VOVF9UT19UUkFOU1BPUlQ7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9jb25maWdmcy5jIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfY29uZmlnZnMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yNzY0NTEwCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfY29uZmlnZnMuYwpAQCAtMCwwICsxLDMyMjUgQEAKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBGaWxlbmFtZTogIHRhcmdldF9jb3JlX2NvbmZpZ2ZzLmMKKyAqCisgKiBUaGlzIGZpbGUgY29udGFpbnMgQ29uZmlnRlMgbG9naWMgZm9yIHRoZSBHZW5lcmljIFRhcmdldCBFbmdpbmUgcHJvamVjdC4KKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxMCBSaXNpbmcgVGlkZSBTeXN0ZW1zCisgKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxMCBMaW51eC1pU0NTSS5vcmcKKyAqCisgKiBOaWNob2xhcyBBLiBCZWxsaW5nZXIgPG5hYkBrZXJuZWwub3JnPgorICoKKyAqIGJhc2VkIG9uIGNvbmZpZ2ZzIENvcHlyaWdodCAoQykgMjAwNSBPcmFjbGUuICBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlcGFyYW0uaD4KKyNpbmNsdWRlIDxsaW51eC92ZXJzaW9uLmg+CisjaW5jbHVkZSA8Z2VuZXJhdGVkL3V0c3JlbGVhc2UuaD4KKyNpbmNsdWRlIDxsaW51eC91dHNuYW1lLmg+CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5jbHVkZSA8bGludXgvbmFtZWkuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L3VuaXN0ZC5oPgorI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgorI2luY2x1ZGUgPGxpbnV4L3BhcnNlci5oPgorI2luY2x1ZGUgPGxpbnV4L3N5c2NhbGxzLmg+CisjaW5jbHVkZSA8bGludXgvY29uZmlnZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9wcm9jX2ZzLmg+CisKKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfYmFzZS5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdHJhbnNwb3J0Lmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19vcHMuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX2NvbmZpZ2ZzLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2NvbmZpZ2ZzLmg+CisjaW5jbHVkZSA8dGFyZ2V0L2NvbmZpZ2ZzX21hY3Jvcy5oPgorCisjaW5jbHVkZSAidGFyZ2V0X2NvcmVfYWx1YS5oIgorI2luY2x1ZGUgInRhcmdldF9jb3JlX2hiYS5oIgorI2luY2x1ZGUgInRhcmdldF9jb3JlX3ByLmgiCisjaW5jbHVkZSAidGFyZ2V0X2NvcmVfcmQuaCIKKworc3RhdGljIHN0cnVjdCBsaXN0X2hlYWQgZ190Zl9saXN0Oworc3RhdGljIHN0cnVjdCBtdXRleCBnX3RmX2xvY2s7CisKK3N0cnVjdCB0YXJnZXRfY29yZV9jb25maWdmc19hdHRyaWJ1dGUgeworCXN0cnVjdCBjb25maWdmc19hdHRyaWJ1dGUgYXR0cjsKKwlzc2l6ZV90ICgqc2hvdykodm9pZCAqLCBjaGFyICopOworCXNzaXplX3QgKCpzdG9yZSkodm9pZCAqLCBjb25zdCBjaGFyICosIHNpemVfdCk7Cit9OworCitzdGF0aWMgaW5saW5lIHN0cnVjdCBzZV9oYmEgKgoraXRlbV90b19oYmEoc3RydWN0IGNvbmZpZ19pdGVtICppdGVtKQoreworCXJldHVybiBjb250YWluZXJfb2YodG9fY29uZmlnX2dyb3VwKGl0ZW0pLCBzdHJ1Y3Qgc2VfaGJhLCBoYmFfZ3JvdXApOworfQorCisvKgorICogQXR0cmlidXRlcyBmb3IgL3N5cy9rZXJuZWwvY29uZmlnL3RhcmdldC8KKyAqLworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfYXR0cl9zaG93KHN0cnVjdCBjb25maWdfaXRlbSAqaXRlbSwKKwkJCQkgICAgICBzdHJ1Y3QgY29uZmlnZnNfYXR0cmlidXRlICphdHRyLAorCQkJCSAgICAgIGNoYXIgKnBhZ2UpCit7CisJcmV0dXJuIHNwcmludGYocGFnZSwgIlRhcmdldCBFbmdpbmUgQ29yZSBDb25maWdGUyBJbmZyYXN0cnVjdHVyZSAlcyIKKwkJIiBvbiAlcy8lcyBvbiAiVVRTX1JFTEVBU0UiXG4iLCBUQVJHRVRfQ09SRV9DT05GSUdGU19WRVJTSU9OLAorCQl1dHNuYW1lKCktPnN5c25hbWUsIHV0c25hbWUoKS0+bWFjaGluZSk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfaXRlbV9vcGVyYXRpb25zIHRhcmdldF9jb3JlX2ZhYnJpY19pdGVtX29wcyA9IHsKKwkuc2hvd19hdHRyaWJ1dGUgPSB0YXJnZXRfY29yZV9hdHRyX3Nob3csCit9OworCitzdGF0aWMgc3RydWN0IGNvbmZpZ2ZzX2F0dHJpYnV0ZSB0YXJnZXRfY29yZV9pdGVtX2F0dHJfdmVyc2lvbiA9IHsKKwkuY2Ffb3duZXIJPSBUSElTX01PRFVMRSwKKwkuY2FfbmFtZQk9ICJ2ZXJzaW9uIiwKKwkuY2FfbW9kZQk9IFNfSVJVR08sCit9OworCitzdGF0aWMgc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKnRhcmdldF9jb3JlX2dldF9mYWJyaWMoCisJY29uc3QgY2hhciAqbmFtZSkKK3sKKwlzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19jb25maWdmcyAqdGY7CisKKwlpZiAoIShuYW1lKSkKKwkJcmV0dXJuIE5VTEw7CisKKwltdXRleF9sb2NrKCZnX3RmX2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnkodGYsICZnX3RmX2xpc3QsIHRmX2xpc3QpIHsKKwkJaWYgKCEoc3RyY21wKHRmLT50Zl9uYW1lLCBuYW1lKSkpIHsKKwkJCWF0b21pY19pbmMoJnRmLT50Zl9hY2Nlc3NfY250KTsKKwkJCW11dGV4X3VubG9jaygmZ190Zl9sb2NrKTsKKwkJCXJldHVybiB0ZjsKKwkJfQorCX0KKwltdXRleF91bmxvY2soJmdfdGZfbG9jayk7CisKKwlyZXR1cm4gTlVMTDsKK30KKworLyoKKyAqIENhbGxlZCBmcm9tIHN0cnVjdCB0YXJnZXRfY29yZV9ncm91cF9vcHMtPm1ha2VfZ3JvdXAoKQorICovCitzdGF0aWMgc3RydWN0IGNvbmZpZ19ncm91cCAqdGFyZ2V0X2NvcmVfcmVnaXN0ZXJfZmFicmljKAorCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLAorCWNvbnN0IGNoYXIgKm5hbWUpCit7CisJc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKnRmOworCWludCByZXQ7CisKKwlwcmludGsoS0VSTl9JTkZPICJUYXJnZXRfQ29yZV9Db25maWdGUzogUkVHSVNURVIgLT4gZ3JvdXA6ICVwIG5hbWU6IgorCQkJIiAlc1xuIiwgZ3JvdXAsIG5hbWUpOworCS8qCisJICogRW5zdXJlIHRoYXQgVENNIHN1YnN5c3RlbSBwbHVnaW5zIGFyZSBsb2FkZWQgYXQgdGhpcyBwb2ludCBmb3IKKwkgKiB1c2luZyB0aGUgUkFNRElTS19EUiB2aXJ0dWFsIExVTiAwIGFuZCBhbGwgb3RoZXIgc3RydWN0IHNlX3BvcnQKKwkgKiBMVU4gc3ltbGlua3MuCisJICovCisJaWYgKHRyYW5zcG9ydF9zdWJzeXN0ZW1fY2hlY2tfaW5pdCgpIDwgMCkKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisKKwkvKgorCSAqIEJlbG93IGFyZSBzb21lIGhhcmRjb2RlZCByZXF1ZXN0X21vZHVsZSgpIGNhbGxzIHRvIGF1dG9tYXRpY2FsbHkKKwkgKiBsb2NhbCBmYWJyaWMgbW9kdWxlcyB3aGVuIHRoZSBmb2xsb3dpbmcgaXMgY2FsbGVkOgorCSAqCisJICogbWtkaXIgLXAgL3N5cy9rZXJuZWwvY29uZmlnL3RhcmdldC8kTU9EVUxFX05BTUUKKwkgKgorCSAqIE5vdGUgdGhhdCB0aGlzIGRvZXMgbm90IGxpbWl0IHdoaWNoIFRDTSBmYWJyaWMgbW9kdWxlIGNhbiBiZQorCSAqIHJlZ2lzdGVyZWQsIGJ1dCBzaW1wbHkgcHJvdmlkcyBhdXRvIGxvYWRpbmcgbG9naWMgZm9yIG1vZHVsZXMgd2l0aAorCSAqIG1rZGlyKDIpIHN5c3RlbSBjYWxscyB3aXRoIGtub3duIFRDTSBmYWJyaWMgbW9kdWxlcy4KKwkgKi8KKwlpZiAoIShzdHJuY21wKG5hbWUsICJpc2NzaSIsIDUpKSkgeworCQkvKgorCQkgKiBBdXRvbWF0aWNhbGx5IGxvYWQgdGhlIExJTyBUYXJnZXQgZmFicmljIG1vZHVsZSB3aGVuIHRoZQorCQkgKiBmb2xsb3dpbmcgaXMgY2FsbGVkOgorCQkgKgorCQkgKiBta2RpciAtcCAkQ09ORklHRlMvdGFyZ2V0L2lzY3NpCisJCSAqLworCQlyZXQgPSByZXF1ZXN0X21vZHVsZSgiaXNjc2lfdGFyZ2V0X21vZCIpOworCQlpZiAocmV0IDwgMCkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJyZXF1ZXN0X21vZHVsZSgpIGZhaWxlZCBmb3IiCisJCQkJIiBpc2NzaV90YXJnZXRfbW9kLmtvOiAlZFxuIiwgcmV0KTsKKwkJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCQl9CisJfSBlbHNlIGlmICghKHN0cm5jbXAobmFtZSwgImxvb3BiYWNrIiwgOCkpKSB7CisJCS8qCisJCSAqIEF1dG9tYXRpY2FsbHkgbG9hZCB0aGUgdGNtX2xvb3AgZmFicmljIG1vZHVsZSB3aGVuIHRoZQorCQkgKiBmb2xsb3dpbmcgaXMgY2FsbGVkOgorCQkgKgorCQkgKiBta2RpciAtcCAkQ09ORklHRlMvdGFyZ2V0L2xvb3BiYWNrCisJCSAqLworCQlyZXQgPSByZXF1ZXN0X21vZHVsZSgidGNtX2xvb3AiKTsKKwkJaWYgKHJldCA8IDApIHsKKwkJCXByaW50ayhLRVJOX0VSUiAicmVxdWVzdF9tb2R1bGUoKSBmYWlsZWQgZm9yIgorCQkJCSIgdGNtX2xvb3Aua286ICVkXG4iLCByZXQpOworCQkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisJCX0KKwl9CisKKwl0ZiA9IHRhcmdldF9jb3JlX2dldF9mYWJyaWMobmFtZSk7CisJaWYgKCEodGYpKSB7CisJCXByaW50ayhLRVJOX0VSUiAidGFyZ2V0X2NvcmVfZ2V0X2ZhYnJpYygpIGZhaWxlZCBmb3IgJXNcbiIsCisJCQluYW1lKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisJfQorCXByaW50ayhLRVJOX0lORk8gIlRhcmdldF9Db3JlX0NvbmZpZ0ZTOiBSRUdJU1RFUiAtPiBMb2NhdGVkIGZhYnJpYzoiCisJCQkiICVzXG4iLCB0Zi0+dGZfbmFtZSk7CisJLyoKKwkgKiBPbiBhIHN1Y2Nlc3NmdWwgdGFyZ2V0X2NvcmVfZ2V0X2ZhYnJpYygpIGxvb2ssIHRoZSByZXR1cm5lZAorCSAqIHN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzICp0ZiB3aWxsIGNvbnRhaW4gYSB1c2FnZSByZWZlcmVuY2UuCisJICovCisJcHJpbnRrKEtFUk5fSU5GTyAiVGFyZ2V0X0NvcmVfQ29uZmlnRlM6IFJFR0lTVEVSIHRmY193d25fY2l0IC0+ICVwXG4iLAorCQkJJlRGX0NJVF9UTVBMKHRmKS0+dGZjX3d3bl9jaXQpOworCisJdGYtPnRmX2dyb3VwLmRlZmF1bHRfZ3JvdXBzID0gdGYtPnRmX2RlZmF1bHRfZ3JvdXBzOworCXRmLT50Zl9ncm91cC5kZWZhdWx0X2dyb3Vwc1swXSA9ICZ0Zi0+dGZfZGlzY19ncm91cDsKKwl0Zi0+dGZfZ3JvdXAuZGVmYXVsdF9ncm91cHNbMV0gPSBOVUxMOworCisJY29uZmlnX2dyb3VwX2luaXRfdHlwZV9uYW1lKCZ0Zi0+dGZfZ3JvdXAsIG5hbWUsCisJCQkmVEZfQ0lUX1RNUEwodGYpLT50ZmNfd3duX2NpdCk7CisJY29uZmlnX2dyb3VwX2luaXRfdHlwZV9uYW1lKCZ0Zi0+dGZfZGlzY19ncm91cCwgImRpc2NvdmVyeV9hdXRoIiwKKwkJCSZURl9DSVRfVE1QTCh0ZiktPnRmY19kaXNjb3ZlcnlfY2l0KTsKKworCXByaW50ayhLRVJOX0lORk8gIlRhcmdldF9Db3JlX0NvbmZpZ0ZTOiBSRUdJU1RFUiAtPiBBbGxvY2F0ZWQgRmFicmljOiIKKwkJCSIgJXNcbiIsIHRmLT50Zl9ncm91cC5jZ19pdGVtLmNpX25hbWUpOworCS8qCisJICogU2V0dXAgdGZfb3BzLnRmX3N1YnN5cyBwb2ludGVyIGZvciB1c2FnZSB3aXRoIGNvbmZpZ2ZzX2RlcGVuZF9pdGVtKCkKKwkgKi8KKwl0Zi0+dGZfb3BzLnRmX3N1YnN5cyA9IHRmLT50Zl9zdWJzeXM7CisJdGYtPnRmX2ZhYnJpYyA9ICZ0Zi0+dGZfZ3JvdXAuY2dfaXRlbTsKKwlwcmludGsoS0VSTl9JTkZPICJUYXJnZXRfQ29yZV9Db25maWdGUzogUkVHSVNURVIgLT4gU2V0IHRmLT50Zl9mYWJyaWMiCisJCQkiIGZvciAlc1xuIiwgbmFtZSk7CisKKwlyZXR1cm4gJnRmLT50Zl9ncm91cDsKK30KKworLyoKKyAqIENhbGxlZCBmcm9tIHN0cnVjdCB0YXJnZXRfY29yZV9ncm91cF9vcHMtPmRyb3BfaXRlbSgpCisgKi8KK3N0YXRpYyB2b2lkIHRhcmdldF9jb3JlX2RlcmVnaXN0ZXJfZmFicmljKAorCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLAorCXN0cnVjdCBjb25maWdfaXRlbSAqaXRlbSkKK3sKKwlzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19jb25maWdmcyAqdGYgPSBjb250YWluZXJfb2YoCisJCXRvX2NvbmZpZ19ncm91cChpdGVtKSwgc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMsIHRmX2dyb3VwKTsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwICp0Zl9ncm91cDsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW0gKmRmX2l0ZW07CisJaW50IGk7CisKKwlwcmludGsoS0VSTl9JTkZPICJUYXJnZXRfQ29yZV9Db25maWdGUzogREVSRUdJU1RFUiAtPiBMb29raW5nIHVwICVzIGluIgorCQkiIHRmIGxpc3RcbiIsIGNvbmZpZ19pdGVtX25hbWUoaXRlbSkpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiVGFyZ2V0X0NvcmVfQ29uZmlnRlM6IERFUkVHSVNURVIgLT4gbG9jYXRlZCBmYWJyaWM6IgorCQkJIiAlc1xuIiwgdGYtPnRmX25hbWUpOworCWF0b21pY19kZWMoJnRmLT50Zl9hY2Nlc3NfY250KTsKKworCXByaW50ayhLRVJOX0lORk8gIlRhcmdldF9Db3JlX0NvbmZpZ0ZTOiBERVJFR0lTVEVSIC0+IFJlbGVhc2luZyIKKwkJCSIgdGYtPnRmX2ZhYnJpYyBmb3IgJXNcbiIsIHRmLT50Zl9uYW1lKTsKKwl0Zi0+dGZfZmFicmljID0gTlVMTDsKKworCXByaW50ayhLRVJOX0lORk8gIlRhcmdldF9Db3JlX0NvbmZpZ0ZTOiBERVJFR0lTVEVSIC0+IFJlbGVhc2luZyBjaSIKKwkJCSIgJXNcbiIsIGNvbmZpZ19pdGVtX25hbWUoaXRlbSkpOworCisJdGZfZ3JvdXAgPSAmdGYtPnRmX2dyb3VwOworCWZvciAoaSA9IDA7IHRmX2dyb3VwLT5kZWZhdWx0X2dyb3Vwc1tpXTsgaSsrKSB7CisJCWRmX2l0ZW0gPSAmdGZfZ3JvdXAtPmRlZmF1bHRfZ3JvdXBzW2ldLT5jZ19pdGVtOworCQl0Zl9ncm91cC0+ZGVmYXVsdF9ncm91cHNbaV0gPSBOVUxMOworCQljb25maWdfaXRlbV9wdXQoZGZfaXRlbSk7CisJfQorCWNvbmZpZ19pdGVtX3B1dChpdGVtKTsKK30KKworc3RhdGljIHN0cnVjdCBjb25maWdmc19ncm91cF9vcGVyYXRpb25zIHRhcmdldF9jb3JlX2ZhYnJpY19ncm91cF9vcHMgPSB7CisJLm1ha2VfZ3JvdXAJPSAmdGFyZ2V0X2NvcmVfcmVnaXN0ZXJfZmFicmljLAorCS5kcm9wX2l0ZW0JPSAmdGFyZ2V0X2NvcmVfZGVyZWdpc3Rlcl9mYWJyaWMsCit9OworCisvKgorICogQWxsIGl0ZW0gYXR0cmlidXRlcyBhcHBlYXJpbmcgaW4gL3N5cy9rZXJuZWwvdGFyZ2V0LyBhcHBlYXIgaGVyZS4KKyAqLworc3RhdGljIHN0cnVjdCBjb25maWdmc19hdHRyaWJ1dGUgKnRhcmdldF9jb3JlX2ZhYnJpY19pdGVtX2F0dHJzW10gPSB7CisJJnRhcmdldF9jb3JlX2l0ZW1fYXR0cl92ZXJzaW9uLAorCU5VTEwsCit9OworCisvKgorICogUHJvdmlkZXMgRmFicmljcyBHcm91cHMgYW5kIEl0ZW0gQXR0cmlidXRlcyBmb3IgL3N5cy9rZXJuZWwvY29uZmlnL3RhcmdldC8KKyAqLworc3RhdGljIHN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRhcmdldF9jb3JlX2ZhYnJpY3NfaXRlbSA9IHsKKwkuY3RfaXRlbV9vcHMJPSAmdGFyZ2V0X2NvcmVfZmFicmljX2l0ZW1fb3BzLAorCS5jdF9ncm91cF9vcHMJPSAmdGFyZ2V0X2NvcmVfZmFicmljX2dyb3VwX29wcywKKwkuY3RfYXR0cnMJPSB0YXJnZXRfY29yZV9mYWJyaWNfaXRlbV9hdHRycywKKwkuY3Rfb3duZXIJPSBUSElTX01PRFVMRSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfc3Vic3lzdGVtIHRhcmdldF9jb3JlX2ZhYnJpY3MgPSB7CisJLnN1X2dyb3VwID0geworCQkuY2dfaXRlbSA9IHsKKwkJCS5jaV9uYW1lYnVmID0gInRhcmdldCIsCisJCQkuY2lfdHlwZSA9ICZ0YXJnZXRfY29yZV9mYWJyaWNzX2l0ZW0sCisJCX0sCisJfSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfc3Vic3lzdGVtICp0YXJnZXRfY29yZV9zdWJzeXN0ZW1bXSA9IHsKKwkmdGFyZ2V0X2NvcmVfZmFicmljcywKKwlOVUxMLAorfTsKKworLyojIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKKy8vIFN0YXJ0IGZ1bmN0aW9ucyBjYWxsZWQgYnkgZXh0ZXJuYWwgVGFyZ2V0IEZhYnJpY3MgTW9kdWxlcworLy8jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjKi8KKworLyoKKyAqIEZpcnN0IGZ1bmN0aW9uIGNhbGxlZCBieSBmYWJyaWMgbW9kdWxlcyB0bzoKKyAqCisgKiAxKSBBbGxvY2F0ZSBhIHN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzIGFuZCBzYXZlIHRoZSAqZmFicmljX2NpdCBwb2ludGVyLgorICogMikgQWRkIHN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzIHRvIGdfdGZfbGlzdAorICogMykgUmV0dXJuIHN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzIHRvIGZhYnJpYyBtb2R1bGUgdG8gYmUgcGFzc2VkCisgKiAgICBpbnRvIHRhcmdldF9mYWJyaWNfY29uZmlnZnNfcmVnaXN0ZXIoKS4KKyAqLworc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKnRhcmdldF9mYWJyaWNfY29uZmlnZnNfaW5pdCgKKwlzdHJ1Y3QgbW9kdWxlICpmYWJyaWNfbW9kLAorCWNvbnN0IGNoYXIgKm5hbWUpCit7CisJc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKnRmOworCisJaWYgKCEoZmFicmljX21vZCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHN0cnVjdCBtb2R1bGUgKmZhYnJpY19tb2QgcG9pbnRlclxuIik7CisJCXJldHVybiBOVUxMOworCX0KKwlpZiAoIShuYW1lKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2NhdGUgcGFzc2VkIGZhYnJpYyBuYW1lXG4iKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCWlmIChzdHJsZW4obmFtZSkgPiBUQVJHRVRfRkFCUklDX05BTUVfU0laRSkgeworCQlwcmludGsoS0VSTl9FUlIgIlBhc3NlZCBuYW1lOiAlcyBleGNlZWRzIFRBUkdFVF9GQUJSSUMiCisJCQkiX05BTUVfU0laRVxuIiwgbmFtZSk7CisJCXJldHVybiBOVUxMOworCX0KKworCXRmID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMpLCBHRlBfS0VSTkVMKTsKKwlpZiAoISh0ZikpCisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCisJSU5JVF9MSVNUX0hFQUQoJnRmLT50Zl9saXN0KTsKKwlhdG9taWNfc2V0KCZ0Zi0+dGZfYWNjZXNzX2NudCwgMCk7CisJLyoKKwkgKiBTZXR1cCB0aGUgZGVmYXVsdCBnZW5lcmljIHN0cnVjdCBjb25maWdfaXRlbV90eXBlJ3MgKGNpdHMpIGluCisJICogc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMtPnRmX2NpdF90bXBsCisJICovCisJdGYtPnRmX21vZHVsZSA9IGZhYnJpY19tb2Q7CisJdGFyZ2V0X2ZhYnJpY19zZXR1cF9jaXRzKHRmKTsKKworCXRmLT50Zl9zdWJzeXMgPSB0YXJnZXRfY29yZV9zdWJzeXN0ZW1bMF07CisJc25wcmludGYodGYtPnRmX25hbWUsIFRBUkdFVF9GQUJSSUNfTkFNRV9TSVpFLCAiJXMiLCBuYW1lKTsKKworCW11dGV4X2xvY2soJmdfdGZfbG9jayk7CisJbGlzdF9hZGRfdGFpbCgmdGYtPnRmX2xpc3QsICZnX3RmX2xpc3QpOworCW11dGV4X3VubG9jaygmZ190Zl9sb2NrKTsKKworCXByaW50ayhLRVJOX0lORk8gIjw8PDw8PDw8PDw8PDw8PDw8PDw8PDwgQkVHSU4gRkFCUklDIEFQSSA+Pj4+Pj4+PiIKKwkJCSI+Pj4+Pj4+Pj4+Pj4+PlxuIik7CisJcHJpbnRrKEtFUk5fSU5GTyAiSW5pdGlhbGl6ZWQgc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnM6ICVwIGZvciIKKwkJCSIgJXNcbiIsIHRmLCB0Zi0+dGZfbmFtZSk7CisJcmV0dXJuIHRmOworfQorRVhQT1JUX1NZTUJPTCh0YXJnZXRfZmFicmljX2NvbmZpZ2ZzX2luaXQpOworCisvKgorICogQ2FsbGVkIGJ5IGZhYnJpYyBwbHVnaW5zIGFmdGVyIEZBSUxFRCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzX3JlZ2lzdGVyKCkgY2FsbC4KKyAqLwordm9pZCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzX2ZyZWUoCisJc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKnRmKQoreworCW11dGV4X2xvY2soJmdfdGZfbG9jayk7CisJbGlzdF9kZWwoJnRmLT50Zl9saXN0KTsKKwltdXRleF91bmxvY2soJmdfdGZfbG9jayk7CisKKwlrZnJlZSh0Zik7Cit9CitFWFBPUlRfU1lNQk9MKHRhcmdldF9mYWJyaWNfY29uZmlnZnNfZnJlZSk7CisKKy8qCisgKiBQZXJmb3JtIGEgc2FuaXR5IGNoZWNrIG9mIHRoZSBwYXNzZWQgdGYtPnRmX29wcyBiZWZvcmUgY29tcGxldGluZworICogVENNIGZhYnJpYyBtb2R1bGUgcmVnaXN0cmF0aW9uLgorICovCitzdGF0aWMgaW50IHRhcmdldF9mYWJyaWNfdGZfb3BzX2NoZWNrKAorCXN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzICp0ZikKK3sKKwlzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcyAqdGZvID0gJnRmLT50Zl9vcHM7CisKKwlpZiAoISh0Zm8tPmdldF9mYWJyaWNfbmFtZSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+Z2V0X2ZhYnJpY19uYW1lKClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGZvLT5nZXRfZmFicmljX3Byb3RvX2lkZW50KSkgeworCQlwcmludGsoS0VSTl9FUlIgIk1pc3NpbmcgdGZvLT5nZXRfZmFicmljX3Byb3RvX2lkZW50KClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGZvLT50cGdfZ2V0X3d3bikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+dHBnX2dldF93d24oKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPnRwZ19nZXRfdGFnKSkgeworCQlwcmludGsoS0VSTl9FUlIgIk1pc3NpbmcgdGZvLT50cGdfZ2V0X3RhZygpXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmICghKHRmby0+dHBnX2dldF9kZWZhdWx0X2RlcHRoKSkgeworCQlwcmludGsoS0VSTl9FUlIgIk1pc3NpbmcgdGZvLT50cGdfZ2V0X2RlZmF1bHRfZGVwdGgoKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPnRwZ19nZXRfcHJfdHJhbnNwb3J0X2lkKSkgeworCQlwcmludGsoS0VSTl9FUlIgIk1pc3NpbmcgdGZvLT50cGdfZ2V0X3ByX3RyYW5zcG9ydF9pZCgpXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmICghKHRmby0+dHBnX2dldF9wcl90cmFuc3BvcnRfaWRfbGVuKSkgeworCQlwcmludGsoS0VSTl9FUlIgIk1pc3NpbmcgdGZvLT50cGdfZ2V0X3ByX3RyYW5zcG9ydF9pZF9sZW4oKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPnRwZ19jaGVja19kZW1vX21vZGUpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB0Zm8tPnRwZ19jaGVja19kZW1vX21vZGUoKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPnRwZ19jaGVja19kZW1vX21vZGVfY2FjaGUpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB0Zm8tPnRwZ19jaGVja19kZW1vX21vZGVfY2FjaGUoKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPnRwZ19jaGVja19kZW1vX21vZGVfd3JpdGVfcHJvdGVjdCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+dHBnX2NoZWNrX2RlbW9fbW9kZV93cml0ZV9wcm90ZWN0KClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGZvLT50cGdfY2hlY2tfcHJvZF9tb2RlX3dyaXRlX3Byb3RlY3QpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB0Zm8tPnRwZ19jaGVja19wcm9kX21vZGVfd3JpdGVfcHJvdGVjdCgpXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmICghKHRmby0+dHBnX2FsbG9jX2ZhYnJpY19hY2wpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB0Zm8tPnRwZ19hbGxvY19mYWJyaWNfYWNsKClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGZvLT50cGdfcmVsZWFzZV9mYWJyaWNfYWNsKSkgeworCQlwcmludGsoS0VSTl9FUlIgIk1pc3NpbmcgdGZvLT50cGdfcmVsZWFzZV9mYWJyaWNfYWNsKClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGZvLT50cGdfZ2V0X2luc3RfaW5kZXgpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB0Zm8tPnRwZ19nZXRfaW5zdF9pbmRleCgpXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmICghKHRmby0+cmVsZWFzZV9jbWRfdG9fcG9vbCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+cmVsZWFzZV9jbWRfdG9fcG9vbCgpXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmICghKHRmby0+cmVsZWFzZV9jbWRfZGlyZWN0KSkgeworCQlwcmludGsoS0VSTl9FUlIgIk1pc3NpbmcgdGZvLT5yZWxlYXNlX2NtZF9kaXJlY3QoKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPnNodXRkb3duX3Nlc3Npb24pKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB0Zm8tPnNodXRkb3duX3Nlc3Npb24oKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPmNsb3NlX3Nlc3Npb24pKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB0Zm8tPmNsb3NlX3Nlc3Npb24oKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPnN0b3Bfc2Vzc2lvbikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+c3RvcF9zZXNzaW9uKClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGZvLT5mYWxsX2JhY2tfdG9fZXJsMCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+ZmFsbF9iYWNrX3RvX2VybDAoKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPnNlc3NfbG9nZ2VkX2luKSkgeworCQlwcmludGsoS0VSTl9FUlIgIk1pc3NpbmcgdGZvLT5zZXNzX2xvZ2dlZF9pbigpXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmICghKHRmby0+c2Vzc19nZXRfaW5kZXgpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB0Zm8tPnNlc3NfZ2V0X2luZGV4KClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGZvLT53cml0ZV9wZW5kaW5nKSkgeworCQlwcmludGsoS0VSTl9FUlIgIk1pc3NpbmcgdGZvLT53cml0ZV9wZW5kaW5nKClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGZvLT53cml0ZV9wZW5kaW5nX3N0YXR1cykpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+d3JpdGVfcGVuZGluZ19zdGF0dXMoKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPnNldF9kZWZhdWx0X25vZGVfYXR0cmlidXRlcykpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+c2V0X2RlZmF1bHRfbm9kZV9hdHRyaWJ1dGVzKClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGZvLT5nZXRfdGFza190YWcpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB0Zm8tPmdldF90YXNrX3RhZygpXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmICghKHRmby0+Z2V0X2NtZF9zdGF0ZSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+Z2V0X2NtZF9zdGF0ZSgpXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmICghKHRmby0+bmV3X2NtZF9mYWlsdXJlKSkgeworCQlwcmludGsoS0VSTl9FUlIgIk1pc3NpbmcgdGZvLT5uZXdfY21kX2ZhaWx1cmUoKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPnF1ZXVlX2RhdGFfaW4pKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB0Zm8tPnF1ZXVlX2RhdGFfaW4oKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPnF1ZXVlX3N0YXR1cykpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+cXVldWVfc3RhdHVzKClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGZvLT5xdWV1ZV90bV9yc3ApKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB0Zm8tPnF1ZXVlX3RtX3JzcCgpXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmICghKHRmby0+c2V0X2ZhYnJpY19zZW5zZV9sZW4pKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB0Zm8tPnNldF9mYWJyaWNfc2Vuc2VfbGVuKClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGZvLT5nZXRfZmFicmljX3NlbnNlX2xlbikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+Z2V0X2ZhYnJpY19zZW5zZV9sZW4oKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPmlzX3N0YXRlX3JlbW92ZSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+aXNfc3RhdGVfcmVtb3ZlKClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGZvLT5wYWNrX2x1bikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+cGFja19sdW4oKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwkvKgorCSAqIFdlIGF0IGxlYXN0IHJlcXVpcmUgdGZvLT5mYWJyaWNfbWFrZV93d24oKSwgdGZvLT5mYWJyaWNfZHJvcF93d24oKQorCSAqIHRmby0+ZmFicmljX21ha2VfdHBnKCkgYW5kIHRmby0+ZmFicmljX2Ryb3BfdHBnKCkgaW4KKwkgKiB0YXJnZXRfY29yZV9mYWJyaWNfY29uZmlnZnMuYyBXV04rVFBHIGdyb3VwIGNvbnRleHQgY29kZS4KKwkgKi8KKwlpZiAoISh0Zm8tPmZhYnJpY19tYWtlX3d3bikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+ZmFicmljX21ha2Vfd3duKClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGZvLT5mYWJyaWNfZHJvcF93d24pKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB0Zm8tPmZhYnJpY19kcm9wX3d3bigpXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmICghKHRmby0+ZmFicmljX21ha2VfdHBnKSkgeworCQlwcmludGsoS0VSTl9FUlIgIk1pc3NpbmcgdGZvLT5mYWJyaWNfbWFrZV90cGcoKVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoISh0Zm8tPmZhYnJpY19kcm9wX3RwZykpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHRmby0+ZmFicmljX2Ryb3BfdHBnKClcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworLyoKKyAqIENhbGxlZCAybmQgZnJvbSBmYWJyaWMgbW9kdWxlIHdpdGggcmV0dXJuZWQgcGFyYW1ldGVyIG9mCisgKiBzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19jb25maWdmcyAqIGZyb20gdGFyZ2V0X2ZhYnJpY19jb25maWdmc19pbml0KCkuCisgKgorICogVXBvbiBhIHN1Y2Nlc3NmdWwgcmVnaXN0cmF0aW9uLCB0aGUgbmV3IGZhYnJpYydzIHN0cnVjdCBjb25maWdfaXRlbSBpcworICogcmV0dXJuLiAgQWxzbywgYSBwb2ludGVyIHRvIHRoaXMgc3RydWN0IGlzIHNldCBpbiB0aGUgcGFzc2VkCisgKiBzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19jb25maWdmcy4KKyAqLworaW50IHRhcmdldF9mYWJyaWNfY29uZmlnZnNfcmVnaXN0ZXIoCisJc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKnRmKQoreworCXN0cnVjdCBjb25maWdfZ3JvdXAgKnN1X2dyb3VwOworCWludCByZXQ7CisKKwlpZiAoISh0ZikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gbG9jYXRlIHRhcmdldF9mYWJyaWNfY29uZmlnZnMiCisJCQkiIHBvaW50ZXJcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKCEodGYtPnRmX3N1YnN5cykpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gdGFyZ2V0IHN0cnVjdCBjb25maWdfc3Vic3lzdGVtIgorCQkJIiBwb2ludGVyXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCXN1X2dyb3VwID0gJnRmLT50Zl9zdWJzeXMtPnN1X2dyb3VwOworCWlmICghKHN1X2dyb3VwKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2NhdGUgdGFyZ2V0IHN0cnVjdCBjb25maWdfZ3JvdXAiCisJCQkiIHBvaW50ZXJcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJcmV0ID0gdGFyZ2V0X2ZhYnJpY190Zl9vcHNfY2hlY2sodGYpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJcHJpbnRrKEtFUk5fSU5GTyAiPDw8PDw8PDw8PDw8PDw8PDw8PDw8PCBFTkQgRkFCUklDIEFQSSA+Pj4+Pj4+Pj4+Pj4iCisJCSI+Pj4+Pj4+Pj4+XG4iKTsKKwlyZXR1cm4gMDsKK30KK0VYUE9SVF9TWU1CT0wodGFyZ2V0X2ZhYnJpY19jb25maWdmc19yZWdpc3Rlcik7CisKK3ZvaWQgdGFyZ2V0X2ZhYnJpY19jb25maWdmc19kZXJlZ2lzdGVyKAorCXN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzICp0ZikKK3sKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwICpzdV9ncm91cDsKKwlzdHJ1Y3QgY29uZmlnZnNfc3Vic3lzdGVtICpzdTsKKworCWlmICghKHRmKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2NhdGUgcGFzc2VkIHRhcmdldF9mYWJyaWNfIgorCQkJImNvbmZpZ2ZzXG4iKTsKKwkJcmV0dXJuOworCX0KKwlzdSA9IHRmLT50Zl9zdWJzeXM7CisJaWYgKCEoc3UpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGxvY2F0ZSBwYXNzZWQgdGYtPnRmX3N1YnN5cyIKKwkJCSIgcG9pbnRlclxuIik7CisJCXJldHVybjsKKwl9CisJc3VfZ3JvdXAgPSAmdGYtPnRmX3N1YnN5cy0+c3VfZ3JvdXA7CisJaWYgKCEoc3VfZ3JvdXApKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGxvY2F0ZSB0YXJnZXQgc3RydWN0IGNvbmZpZ19ncm91cCIKKwkJCSIgcG9pbnRlclxuIik7CisJCXJldHVybjsKKwl9CisKKwlwcmludGsoS0VSTl9JTkZPICI8PDw8PDw8PDw8PDw8PDw8PDw8PDw8IEJFR0lOIEZBQlJJQyBBUEkgPj4+Pj4+Pj4+PiIKKwkJCSI+Pj4+Pj4+Pj4+Pj5cbiIpOworCW11dGV4X2xvY2soJmdfdGZfbG9jayk7CisJaWYgKGF0b21pY19yZWFkKCZ0Zi0+dGZfYWNjZXNzX2NudCkpIHsKKwkJbXV0ZXhfdW5sb2NrKCZnX3RmX2xvY2spOworCQlwcmludGsoS0VSTl9FUlIgIk5vbiB6ZXJvIHRmLT50Zl9hY2Nlc3NfY250IGZvciBmYWJyaWMgJXNcbiIsCisJCQl0Zi0+dGZfbmFtZSk7CisJCUJVRygpOworCX0KKwlsaXN0X2RlbCgmdGYtPnRmX2xpc3QpOworCW11dGV4X3VubG9jaygmZ190Zl9sb2NrKTsKKworCXByaW50ayhLRVJOX0lORk8gIlRhcmdldF9Db3JlX0NvbmZpZ0ZTOiBERVJFR0lTVEVSIC0+IFJlbGVhc2luZyB0ZjoiCisJCQkiICVzXG4iLCB0Zi0+dGZfbmFtZSk7CisJdGYtPnRmX21vZHVsZSA9IE5VTEw7CisJdGYtPnRmX3N1YnN5cyA9IE5VTEw7CisJa2ZyZWUodGYpOworCisJcHJpbnRrKCI8PDw8PDw8PDw8PDw8PDw8PDw8PDw8IEVORCBGQUJSSUMgQVBJID4+Pj4+Pj4+Pj4+Pj4+Pj4+IgorCQkJIj4+Pj4+XG4iKTsKKwlyZXR1cm47Cit9CitFWFBPUlRfU1lNQk9MKHRhcmdldF9mYWJyaWNfY29uZmlnZnNfZGVyZWdpc3Rlcik7CisKKy8qIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCisvLyBTdG9wIGZ1bmN0aW9ucyBjYWxsZWQgYnkgZXh0ZXJuYWwgVGFyZ2V0IEZhYnJpY3MgTW9kdWxlcworLy8jIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjKi8KKworLyogU3RhcnQgZnVuY3Rpb25zIGZvciBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9kZXZfYXR0cmliX2NpdCAqLworCisjZGVmaW5lIERFRl9ERVZfQVRUUklCX1NIT1coX25hbWUpCQkJCQlcCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9kZXZfc2hvd19hdHRyXyMjX25hbWUoCQkJXAorCXN0cnVjdCBzZV9kZXZfYXR0cmliICpkYSwJCQkJCVwKKwljaGFyICpwYWdlKQkJCQkJCQlcCit7CQkJCQkJCQkJXAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldjsJCQkJCQlcCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiA9IGRhLT5kYV9zdWJfZGV2OwkJCVwKKwlzc2l6ZV90IHJiOwkJCQkJCQlcCisJCQkJCQkJCQlcCisJc3Bpbl9sb2NrKCZzZV9kZXYtPnNlX2Rldl9sb2NrKTsJCQkJXAorCWRldiA9IHNlX2Rldi0+c2VfZGV2X3B0cjsJCQkJCVwKKwlpZiAoIShkZXYpKSB7CQkJCQkJCVwKKwkJc3Bpbl91bmxvY2soJnNlX2Rldi0+c2VfZGV2X2xvY2spOyAJCQlcCisJCXJldHVybiAtRU5PREVWOwkJCQkJCVwKKwl9CQkJCQkJCQlcCisJcmIgPSBzbnByaW50ZihwYWdlLCBQQUdFX1NJWkUsICIldVxuIiwgKHUzMilERVZfQVRUUklCKGRldiktPl9uYW1lKTsgXAorCXNwaW5fdW5sb2NrKCZzZV9kZXYtPnNlX2Rldl9sb2NrKTsJCQkJXAorCQkJCQkJCQkJXAorCXJldHVybiByYjsJCQkJCQkJXAorfQorCisjZGVmaW5lIERFRl9ERVZfQVRUUklCX1NUT1JFKF9uYW1lKQkJCQkJXAorc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfZGV2X3N0b3JlX2F0dHJfIyNfbmFtZSgJCQlcCisJc3RydWN0IHNlX2Rldl9hdHRyaWIgKmRhLAkJCQkJXAorCWNvbnN0IGNoYXIgKnBhZ2UsCQkJCQkJXAorCXNpemVfdCBjb3VudCkJCQkJCQkJXAorewkJCQkJCQkJCVwKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXY7CQkJCQkJXAorCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzZV9kZXYgPSBkYS0+ZGFfc3ViX2RldjsJCQlcCisJdW5zaWduZWQgbG9uZyB2YWw7CQkJCQkJXAorCWludCByZXQ7CQkJCQkJCVwKKwkJCQkJCQkJCVwKKwlzcGluX2xvY2soJnNlX2Rldi0+c2VfZGV2X2xvY2spOwkJCQlcCisJZGV2ID0gc2VfZGV2LT5zZV9kZXZfcHRyOwkJCQkJXAorCWlmICghKGRldikpIHsJCQkJCQkJXAorCQlzcGluX3VubG9jaygmc2VfZGV2LT5zZV9kZXZfbG9jayk7CQkJXAorCQlyZXR1cm4gLUVOT0RFVjsJCQkJCQlcCisJfQkJCQkJCQkJXAorCXJldCA9IHN0cmljdF9zdHJ0b3VsKHBhZ2UsIDAsICZ2YWwpOwkJCQlcCisJaWYgKHJldCA8IDApIHsJCQkJCQkJXAorCQlzcGluX3VubG9jaygmc2VfZGV2LT5zZV9kZXZfbG9jayk7ICAgICAgICAgICAgICAgICAgICAgIFwKKwkJcHJpbnRrKEtFUk5fRVJSICJzdHJpY3Rfc3RydG91bCgpIGZhaWxlZCB3aXRoIgkJXAorCQkJIiByZXQ6ICVkXG4iLCByZXQpOwkJCQlcCisJCXJldHVybiAtRUlOVkFMOwkJCQkJCVwKKwl9CQkJCQkJCQlcCisJcmV0ID0gc2VfZGV2X3NldF8jI19uYW1lKGRldiwgKHUzMil2YWwpOwkJCVwKKwlzcGluX3VubG9jaygmc2VfZGV2LT5zZV9kZXZfbG9jayk7CQkJCVwKKwkJCQkJCQkJCVwKKwlyZXR1cm4gKCFyZXQpID8gY291bnQgOiAtRUlOVkFMOwkJCQlcCit9CisKKyNkZWZpbmUgREVGX0RFVl9BVFRSSUIoX25hbWUpCQkJCQkJXAorREVGX0RFVl9BVFRSSUJfU0hPVyhfbmFtZSk7CQkJCQkJXAorREVGX0RFVl9BVFRSSUJfU1RPUkUoX25hbWUpOworCisjZGVmaW5lIERFRl9ERVZfQVRUUklCX1JPKF9uYW1lKQkJCQkJXAorREVGX0RFVl9BVFRSSUJfU0hPVyhfbmFtZSk7CisKK0NPTkZJR0ZTX0VBVFRSX1NUUlVDVCh0YXJnZXRfY29yZV9kZXZfYXR0cmliLCBzZV9kZXZfYXR0cmliKTsKKyNkZWZpbmUgU0VfREVWX0FUVFIoX25hbWUsIF9tb2RlKQkJCQkJXAorc3RhdGljIHN0cnVjdCB0YXJnZXRfY29yZV9kZXZfYXR0cmliX2F0dHJpYnV0ZQkJCQlcCisJCQl0YXJnZXRfY29yZV9kZXZfYXR0cmliXyMjX25hbWUgPQkJXAorCQlfX0NPTkZJR0ZTX0VBVFRSKF9uYW1lLCBfbW9kZSwJCQkJXAorCQl0YXJnZXRfY29yZV9kZXZfc2hvd19hdHRyXyMjX25hbWUsCQkJXAorCQl0YXJnZXRfY29yZV9kZXZfc3RvcmVfYXR0cl8jI19uYW1lKTsKKworI2RlZmluZSBTRV9ERVZfQVRUUl9STyhfbmFtZSk7CQkJCQkJXAorc3RhdGljIHN0cnVjdCB0YXJnZXRfY29yZV9kZXZfYXR0cmliX2F0dHJpYnV0ZQkJCQlcCisJCQl0YXJnZXRfY29yZV9kZXZfYXR0cmliXyMjX25hbWUgPQkJXAorCV9fQ09ORklHRlNfRUFUVFJfUk8oX25hbWUsCQkJCQlcCisJdGFyZ2V0X2NvcmVfZGV2X3Nob3dfYXR0cl8jI19uYW1lKTsKKworREVGX0RFVl9BVFRSSUIoZW11bGF0ZV9kcG8pOworU0VfREVWX0FUVFIoZW11bGF0ZV9kcG8sIFNfSVJVR08gfCBTX0lXVVNSKTsKKworREVGX0RFVl9BVFRSSUIoZW11bGF0ZV9mdWFfd3JpdGUpOworU0VfREVWX0FUVFIoZW11bGF0ZV9mdWFfd3JpdGUsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworREVGX0RFVl9BVFRSSUIoZW11bGF0ZV9mdWFfcmVhZCk7CitTRV9ERVZfQVRUUihlbXVsYXRlX2Z1YV9yZWFkLCBTX0lSVUdPIHwgU19JV1VTUik7CisKK0RFRl9ERVZfQVRUUklCKGVtdWxhdGVfd3JpdGVfY2FjaGUpOworU0VfREVWX0FUVFIoZW11bGF0ZV93cml0ZV9jYWNoZSwgU19JUlVHTyB8IFNfSVdVU1IpOworCitERUZfREVWX0FUVFJJQihlbXVsYXRlX3VhX2ludGxja19jdHJsKTsKK1NFX0RFVl9BVFRSKGVtdWxhdGVfdWFfaW50bGNrX2N0cmwsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworREVGX0RFVl9BVFRSSUIoZW11bGF0ZV90YXMpOworU0VfREVWX0FUVFIoZW11bGF0ZV90YXMsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworREVGX0RFVl9BVFRSSUIoZW11bGF0ZV90cHUpOworU0VfREVWX0FUVFIoZW11bGF0ZV90cHUsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworREVGX0RFVl9BVFRSSUIoZW11bGF0ZV90cHdzKTsKK1NFX0RFVl9BVFRSKGVtdWxhdGVfdHB3cywgU19JUlVHTyB8IFNfSVdVU1IpOworCitERUZfREVWX0FUVFJJQihlbmZvcmNlX3ByX2lzaWRzKTsKK1NFX0RFVl9BVFRSKGVuZm9yY2VfcHJfaXNpZHMsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworREVGX0RFVl9BVFRSSUJfUk8oaHdfYmxvY2tfc2l6ZSk7CitTRV9ERVZfQVRUUl9STyhod19ibG9ja19zaXplKTsKKworREVGX0RFVl9BVFRSSUIoYmxvY2tfc2l6ZSk7CitTRV9ERVZfQVRUUihibG9ja19zaXplLCBTX0lSVUdPIHwgU19JV1VTUik7CisKK0RFRl9ERVZfQVRUUklCX1JPKGh3X21heF9zZWN0b3JzKTsKK1NFX0RFVl9BVFRSX1JPKGh3X21heF9zZWN0b3JzKTsKKworREVGX0RFVl9BVFRSSUIobWF4X3NlY3RvcnMpOworU0VfREVWX0FUVFIobWF4X3NlY3RvcnMsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworREVGX0RFVl9BVFRSSUIob3B0aW1hbF9zZWN0b3JzKTsKK1NFX0RFVl9BVFRSKG9wdGltYWxfc2VjdG9ycywgU19JUlVHTyB8IFNfSVdVU1IpOworCitERUZfREVWX0FUVFJJQl9STyhod19xdWV1ZV9kZXB0aCk7CitTRV9ERVZfQVRUUl9STyhod19xdWV1ZV9kZXB0aCk7CisKK0RFRl9ERVZfQVRUUklCKHF1ZXVlX2RlcHRoKTsKK1NFX0RFVl9BVFRSKHF1ZXVlX2RlcHRoLCBTX0lSVUdPIHwgU19JV1VTUik7CisKK0RFRl9ERVZfQVRUUklCKHRhc2tfdGltZW91dCk7CitTRV9ERVZfQVRUUih0YXNrX3RpbWVvdXQsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworREVGX0RFVl9BVFRSSUIobWF4X3VubWFwX2xiYV9jb3VudCk7CitTRV9ERVZfQVRUUihtYXhfdW5tYXBfbGJhX2NvdW50LCBTX0lSVUdPIHwgU19JV1VTUik7CisKK0RFRl9ERVZfQVRUUklCKG1heF91bm1hcF9ibG9ja19kZXNjX2NvdW50KTsKK1NFX0RFVl9BVFRSKG1heF91bm1hcF9ibG9ja19kZXNjX2NvdW50LCBTX0lSVUdPIHwgU19JV1VTUik7CisKK0RFRl9ERVZfQVRUUklCKHVubWFwX2dyYW51bGFyaXR5KTsKK1NFX0RFVl9BVFRSKHVubWFwX2dyYW51bGFyaXR5LCBTX0lSVUdPIHwgU19JV1VTUik7CisKK0RFRl9ERVZfQVRUUklCKHVubWFwX2dyYW51bGFyaXR5X2FsaWdubWVudCk7CitTRV9ERVZfQVRUUih1bm1hcF9ncmFudWxhcml0eV9hbGlnbm1lbnQsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworQ09ORklHRlNfRUFUVFJfT1BTKHRhcmdldF9jb3JlX2Rldl9hdHRyaWIsIHNlX2Rldl9hdHRyaWIsIGRhX2dyb3VwKTsKKworc3RhdGljIHN0cnVjdCBjb25maWdmc19hdHRyaWJ1dGUgKnRhcmdldF9jb3JlX2Rldl9hdHRyaWJfYXR0cnNbXSA9IHsKKwkmdGFyZ2V0X2NvcmVfZGV2X2F0dHJpYl9lbXVsYXRlX2Rwby5hdHRyLAorCSZ0YXJnZXRfY29yZV9kZXZfYXR0cmliX2VtdWxhdGVfZnVhX3dyaXRlLmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl9hdHRyaWJfZW11bGF0ZV9mdWFfcmVhZC5hdHRyLAorCSZ0YXJnZXRfY29yZV9kZXZfYXR0cmliX2VtdWxhdGVfd3JpdGVfY2FjaGUuYXR0ciwKKwkmdGFyZ2V0X2NvcmVfZGV2X2F0dHJpYl9lbXVsYXRlX3VhX2ludGxja19jdHJsLmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl9hdHRyaWJfZW11bGF0ZV90YXMuYXR0ciwKKwkmdGFyZ2V0X2NvcmVfZGV2X2F0dHJpYl9lbXVsYXRlX3RwdS5hdHRyLAorCSZ0YXJnZXRfY29yZV9kZXZfYXR0cmliX2VtdWxhdGVfdHB3cy5hdHRyLAorCSZ0YXJnZXRfY29yZV9kZXZfYXR0cmliX2VuZm9yY2VfcHJfaXNpZHMuYXR0ciwKKwkmdGFyZ2V0X2NvcmVfZGV2X2F0dHJpYl9od19ibG9ja19zaXplLmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl9hdHRyaWJfYmxvY2tfc2l6ZS5hdHRyLAorCSZ0YXJnZXRfY29yZV9kZXZfYXR0cmliX2h3X21heF9zZWN0b3JzLmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl9hdHRyaWJfbWF4X3NlY3RvcnMuYXR0ciwKKwkmdGFyZ2V0X2NvcmVfZGV2X2F0dHJpYl9vcHRpbWFsX3NlY3RvcnMuYXR0ciwKKwkmdGFyZ2V0X2NvcmVfZGV2X2F0dHJpYl9od19xdWV1ZV9kZXB0aC5hdHRyLAorCSZ0YXJnZXRfY29yZV9kZXZfYXR0cmliX3F1ZXVlX2RlcHRoLmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl9hdHRyaWJfdGFza190aW1lb3V0LmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl9hdHRyaWJfbWF4X3VubWFwX2xiYV9jb3VudC5hdHRyLAorCSZ0YXJnZXRfY29yZV9kZXZfYXR0cmliX21heF91bm1hcF9ibG9ja19kZXNjX2NvdW50LmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl9hdHRyaWJfdW5tYXBfZ3JhbnVsYXJpdHkuYXR0ciwKKwkmdGFyZ2V0X2NvcmVfZGV2X2F0dHJpYl91bm1hcF9ncmFudWxhcml0eV9hbGlnbm1lbnQuYXR0ciwKKwlOVUxMLAorfTsKKworc3RhdGljIHN0cnVjdCBjb25maWdmc19pdGVtX29wZXJhdGlvbnMgdGFyZ2V0X2NvcmVfZGV2X2F0dHJpYl9vcHMgPSB7CisJLnNob3dfYXR0cmlidXRlCQk9IHRhcmdldF9jb3JlX2Rldl9hdHRyaWJfYXR0cl9zaG93LAorCS5zdG9yZV9hdHRyaWJ1dGUJPSB0YXJnZXRfY29yZV9kZXZfYXR0cmliX2F0dHJfc3RvcmUsCit9OworCitzdGF0aWMgc3RydWN0IGNvbmZpZ19pdGVtX3R5cGUgdGFyZ2V0X2NvcmVfZGV2X2F0dHJpYl9jaXQgPSB7CisJLmN0X2l0ZW1fb3BzCQk9ICZ0YXJnZXRfY29yZV9kZXZfYXR0cmliX29wcywKKwkuY3RfYXR0cnMJCT0gdGFyZ2V0X2NvcmVfZGV2X2F0dHJpYl9hdHRycywKKwkuY3Rfb3duZXIJCT0gVEhJU19NT0RVTEUsCit9OworCisvKiBFbmQgZnVuY3Rpb25zIGZvciBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9kZXZfYXR0cmliX2NpdCAqLworCisvKiAgU3RhcnQgZnVuY3Rpb25zIGZvciBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9kZXZfd3duX2NpdCAqLworCitDT05GSUdGU19FQVRUUl9TVFJVQ1QodGFyZ2V0X2NvcmVfZGV2X3d3biwgdDEwX3d3bik7CisjZGVmaW5lIFNFX0RFVl9XV05fQVRUUihfbmFtZSwgX21vZGUpCQkJCQlcCitzdGF0aWMgc3RydWN0IHRhcmdldF9jb3JlX2Rldl93d25fYXR0cmlidXRlIHRhcmdldF9jb3JlX2Rldl93d25fIyNfbmFtZSA9IFwKKwkJX19DT05GSUdGU19FQVRUUihfbmFtZSwgX21vZGUsCQkJCVwKKwkJdGFyZ2V0X2NvcmVfZGV2X3d3bl9zaG93X2F0dHJfIyNfbmFtZSwJCQlcCisJCXRhcmdldF9jb3JlX2Rldl93d25fc3RvcmVfYXR0cl8jI19uYW1lKTsKKworI2RlZmluZSBTRV9ERVZfV1dOX0FUVFJfUk8oX25hbWUpOwkJCQkJXAorZG8gewkJCQkJCQkJCVwKKwlzdGF0aWMgc3RydWN0IHRhcmdldF9jb3JlX2Rldl93d25fYXR0cmlidXRlCQkJXAorCQkJdGFyZ2V0X2NvcmVfZGV2X3d3bl8jI19uYW1lID0JCQlcCisJCV9fQ09ORklHRlNfRUFUVFJfUk8oX25hbWUsCQkJCVwKKwkJdGFyZ2V0X2NvcmVfZGV2X3d3bl9zaG93X2F0dHJfIyNfbmFtZSk7CQkJXAorfSB3aGlsZSAoMCk7CisKKy8qCisgKiBWUEQgcGFnZSAweDgwIFVuaXQgc2VyaWFsCisgKi8KK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX2Rldl93d25fc2hvd19hdHRyX3ZwZF91bml0X3NlcmlhbCgKKwlzdHJ1Y3QgdDEwX3d3biAqdDEwX3d3biwKKwljaGFyICpwYWdlKQoreworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzZV9kZXYgPSB0MTBfd3duLT50MTBfc3ViX2RldjsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXY7CisKKwlkZXYgPSBzZV9kZXYtPnNlX2Rldl9wdHI7CisJaWYgKCEoZGV2KSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlyZXR1cm4gc3ByaW50ZihwYWdlLCAiVDEwIFZQRCBVbml0IFNlcmlhbCBOdW1iZXI6ICVzXG4iLAorCQkmdDEwX3d3bi0+dW5pdF9zZXJpYWxbMF0pOworfQorCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9kZXZfd3duX3N0b3JlX2F0dHJfdnBkX3VuaXRfc2VyaWFsKAorCXN0cnVjdCB0MTBfd3duICp0MTBfd3duLAorCWNvbnN0IGNoYXIgKnBhZ2UsCisJc2l6ZV90IGNvdW50KQoreworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXYgPSB0MTBfd3duLT50MTBfc3ViX2RldjsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXY7CisJdW5zaWduZWQgY2hhciBidWZbSU5RVUlSWV9WUERfU0VSSUFMX0xFTl07CisKKwkvKgorCSAqIElmIExpbnV4L1NDU0kgc3Vic3lzdGVtX2FwaV90IHBsdWdpbiBnb3QgYSBWUEQgVW5pdCBTZXJpYWwKKwkgKiBmcm9tIHRoZSBzdHJ1Y3Qgc2NzaV9kZXZpY2UgbGV2ZWwgZmlybXdhcmUsIGRvIG5vdCBhbGxvdworCSAqIFZQRCBVbml0IFNlcmlhbCB0byBiZSBlbXVsYXRlZC4KKwkgKgorCSAqIE5vdGUgdGhpcyBzdHJ1Y3Qgc2NzaV9kZXZpY2UgY291bGQgYWxzbyBiZSBlbXVsYXRpbmcgVlBECisJICogaW5mb3JtYXRpb24gZnJvbSBpdHMgZHJpdmVycy9zY3NpIExMRC4gIEJ1dCBmb3Igbm93IHdlIGFzc3VtZQorCSAqIGl0IGlzIGRvaW5nICd0aGUgcmlnaHQgdGhpbmcnIHdydCBhIHdvcmxkIHdpZGUgdW5pcXVlCisJICogVlBEIFVuaXQgU2VyaWFsIE51bWJlciB0aGF0IE9TIGRlcGVuZGVudCBtdWx0aXBhdGggY2FuIGRlcGVuZCBvbi4KKwkgKi8KKwlpZiAoc3VfZGV2LT5zdV9kZXZfZmxhZ3MgJiBTREZfRklSTVdBUkVfVlBEX1VOSVRfU0VSSUFMKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5kZXJseWluZyBTQ1NJIGRldmljZSBmaXJtd2FyZSBwcm92aWRlZCBWUEQiCisJCQkiIFVuaXQgU2VyaWFsLCBpZ25vcmluZyByZXF1ZXN0XG4iKTsKKwkJcmV0dXJuIC1FT1BOT1RTVVBQOworCX0KKworCWlmICgoc3RybGVuKHBhZ2UpICsgMSkgPiBJTlFVSVJZX1ZQRF9TRVJJQUxfTEVOKSB7CisJCXByaW50ayhLRVJOX0VSUiAiRW11bGF0ZWQgVlBEIFVuaXQgU2VyaWFsIGV4Y2VlZHMiCisJCSIgSU5RVUlSWV9WUERfU0VSSUFMX0xFTjogJWRcbiIsIElOUVVJUllfVlBEX1NFUklBTF9MRU4pOworCQlyZXR1cm4gLUVPVkVSRkxPVzsKKwl9CisJLyoKKwkgKiBDaGVjayB0byBzZWUgaWYgYW55IGFjdGl2ZSAkRkFCUklDX01PRCBleHBvcnRzIGV4aXN0LiAgSWYgdGhleQorCSAqIGRvIGV4aXN0LCBmYWlsIGhlcmUgYXMgY2hhbmdpbmcgdGhpcyBpbmZvcm1hdGlvbiBvbiB0aGUgZmx5CisJICogKHVuZGVybmVhdGggdGhlIGluaXRpYXRvciBzaWRlIE9TIGRlcGVuZGVudCBtdWx0aXBhdGggY29kZSkKKwkgKiBjb3VsZCBjYXVzZSBuZWdhdGl2ZSBlZmZlY3RzLgorCSAqLworCWRldiA9IHN1X2Rldi0+c2VfZGV2X3B0cjsKKwlpZiAoKGRldikpIHsKKwkJaWYgKGF0b21pY19yZWFkKCZkZXYtPmRldl9leHBvcnRfb2JqLm9ial9hY2Nlc3NfY291bnQpKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBzZXQgVlBEIFVuaXQgU2VyaWFsIHdoaWxlIgorCQkJCSIgYWN0aXZlICVkICRGQUJSSUNfTU9EIGV4cG9ydHMgZXhpc3RcbiIsCisJCQkJYXRvbWljX3JlYWQoJmRldi0+ZGV2X2V4cG9ydF9vYmoub2JqX2FjY2Vzc19jb3VudCkpOworCQkJcmV0dXJuIC1FSU5WQUw7CisJCX0KKwl9CisJLyoKKwkgKiBUaGlzIGN1cnJlbnRseSBhc3N1bWVzIEFTQ0lJIGVuY29kaW5nIGZvciBlbXVsYXRlZCBWUEQgVW5pdCBTZXJpYWwuCisJICoKKwkgKiBBbHNvLCBzdHJpcCBhbnkgbmV3bGluZSBhZGRlZCBmcm9tIHRoZSB1c2Vyc3BhY2UKKwkgKiBlY2hvICRVVUlEID4gJFRBUkdFVC8kSEJBLyRTVE9SQUdFX09CSkVDVC93d24vdnBkX3VuaXRfc2VyaWFsCisJICovCisJbWVtc2V0KGJ1ZiwgMCwgSU5RVUlSWV9WUERfU0VSSUFMX0xFTik7CisJc25wcmludGYoYnVmLCBJTlFVSVJZX1ZQRF9TRVJJQUxfTEVOLCAiJXMiLCBwYWdlKTsKKwlzbnByaW50ZihzdV9kZXYtPnQxMF93d24udW5pdF9zZXJpYWwsIElOUVVJUllfVlBEX1NFUklBTF9MRU4sCisJCQkiJXMiLCBzdHJzdHJpcChidWYpKTsKKwlzdV9kZXYtPnN1X2Rldl9mbGFncyB8PSBTREZfRU1VTEFURURfVlBEX1VOSVRfU0VSSUFMOworCisJcHJpbnRrKEtFUk5fSU5GTyAiVGFyZ2V0X0NvcmVfQ29uZmlnRlM6IFNldCBlbXVsYXRlZCBWUEQgVW5pdCBTZXJpYWw6IgorCQkJIiAlc1xuIiwgc3VfZGV2LT50MTBfd3duLnVuaXRfc2VyaWFsKTsKKworCXJldHVybiBjb3VudDsKK30KKworU0VfREVWX1dXTl9BVFRSKHZwZF91bml0X3NlcmlhbCwgU19JUlVHTyB8IFNfSVdVU1IpOworCisvKgorICogVlBEIHBhZ2UgMHg4MyBQcm90b2NvbCBJZGVudGlmaWVyCisgKi8KK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX2Rldl93d25fc2hvd19hdHRyX3ZwZF9wcm90b2NvbF9pZGVudGlmaWVyKAorCXN0cnVjdCB0MTBfd3duICp0MTBfd3duLAorCWNoYXIgKnBhZ2UpCit7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiA9IHQxMF93d24tPnQxMF9zdWJfZGV2OworCXN0cnVjdCBzZV9kZXZpY2UgKmRldjsKKwlzdHJ1Y3QgdDEwX3ZwZCAqdnBkOworCXVuc2lnbmVkIGNoYXIgYnVmW1ZQRF9UTVBfQlVGX1NJWkVdOworCXNzaXplX3QgbGVuID0gMDsKKworCWRldiA9IHNlX2Rldi0+c2VfZGV2X3B0cjsKKwlpZiAoIShkZXYpKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCW1lbXNldChidWYsIDAsIFZQRF9UTVBfQlVGX1NJWkUpOworCisJc3Bpbl9sb2NrKCZ0MTBfd3duLT50MTBfdnBkX2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnkodnBkLCAmdDEwX3d3bi0+dDEwX3ZwZF9saXN0LCB2cGRfbGlzdCkgeworCQlpZiAoISh2cGQtPnByb3RvY29sX2lkZW50aWZpZXJfc2V0KSkKKwkJCWNvbnRpbnVlOworCisJCXRyYW5zcG9ydF9kdW1wX3ZwZF9wcm90b19pZCh2cGQsIGJ1ZiwgVlBEX1RNUF9CVUZfU0laRSk7CisKKwkJaWYgKChsZW4gKyBzdHJsZW4oYnVmKSA+IFBBR0VfU0laRSkpCisJCQlicmVhazsKKworCQlsZW4gKz0gc3ByaW50ZihwYWdlK2xlbiwgIiVzIiwgYnVmKTsKKwl9CisJc3Bpbl91bmxvY2soJnQxMF93d24tPnQxMF92cGRfbG9jayk7CisKKwlyZXR1cm4gbGVuOworfQorCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9kZXZfd3duX3N0b3JlX2F0dHJfdnBkX3Byb3RvY29sX2lkZW50aWZpZXIoCisJc3RydWN0IHQxMF93d24gKnQxMF93d24sCisJY29uc3QgY2hhciAqcGFnZSwKKwlzaXplX3QgY291bnQpCit7CisJcmV0dXJuIC1FTk9TWVM7Cit9CisKK1NFX0RFVl9XV05fQVRUUih2cGRfcHJvdG9jb2xfaWRlbnRpZmllciwgU19JUlVHTyB8IFNfSVdVU1IpOworCisvKgorICogR2VuZXJpYyB3cmFwcGVyIGZvciBkdW1waW5nIFZQRCBpZGVudGlmaWVycyBieSBhc3NvY2lhdGlvbi4KKyAqLworI2RlZmluZSBERUZfREVWX1dXTl9BU1NPQ19TSE9XKF9uYW1lLCBfYXNzb2MpCQkJCVwKK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX2Rldl93d25fc2hvd19hdHRyXyMjX25hbWUoCQkJXAorCXN0cnVjdCB0MTBfd3duICp0MTBfd3duLAkJCQkJXAorCWNoYXIgKnBhZ2UpCQkJCQkJCVwKK3sJCQkJCQkJCQlcCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiA9IHQxMF93d24tPnQxMF9zdWJfZGV2OwkJXAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldjsJCQkJCQlcCisJc3RydWN0IHQxMF92cGQgKnZwZDsJCQkJCQkJXAorCXVuc2lnbmVkIGNoYXIgYnVmW1ZQRF9UTVBfQlVGX1NJWkVdOwkJCQlcCisJc3NpemVfdCBsZW4gPSAwOwkJCQkJCVwKKwkJCQkJCQkJCVwKKwlkZXYgPSBzZV9kZXYtPnNlX2Rldl9wdHI7CQkJCQlcCisJaWYgKCEoZGV2KSkJCQkJCQkJXAorCQlyZXR1cm4gLUVOT0RFVjsJCQkJCQlcCisJCQkJCQkJCQlcCisJc3Bpbl9sb2NrKCZ0MTBfd3duLT50MTBfdnBkX2xvY2spOwkJCQlcCisJbGlzdF9mb3JfZWFjaF9lbnRyeSh2cGQsICZ0MTBfd3duLT50MTBfdnBkX2xpc3QsIHZwZF9saXN0KSB7CVwKKwkJaWYgKHZwZC0+YXNzb2NpYXRpb24gIT0gX2Fzc29jKQkJCQlcCisJCQljb250aW51ZTsJCQkJCVwKKwkJCQkJCQkJCVwKKwkJbWVtc2V0KGJ1ZiwgMCwgVlBEX1RNUF9CVUZfU0laRSk7CQkJXAorCQl0cmFuc3BvcnRfZHVtcF92cGRfYXNzb2ModnBkLCBidWYsIFZQRF9UTVBfQlVGX1NJWkUpOwlcCisJCWlmICgobGVuICsgc3RybGVuKGJ1ZikgPiBQQUdFX1NJWkUpKQkJCVwKKwkJCWJyZWFrOwkJCQkJCVwKKwkJbGVuICs9IHNwcmludGYocGFnZStsZW4sICIlcyIsIGJ1Zik7CQkJXAorCQkJCQkJCQkJXAorCQltZW1zZXQoYnVmLCAwLCBWUERfVE1QX0JVRl9TSVpFKTsJCQlcCisJCXRyYW5zcG9ydF9kdW1wX3ZwZF9pZGVudF90eXBlKHZwZCwgYnVmLCBWUERfVE1QX0JVRl9TSVpFKTsgXAorCQlpZiAoKGxlbiArIHN0cmxlbihidWYpID4gUEFHRV9TSVpFKSkJCQlcCisJCQlicmVhazsJCQkJCQlcCisJCWxlbiArPSBzcHJpbnRmKHBhZ2UrbGVuLCAiJXMiLCBidWYpOwkJCVwKKwkJCQkJCQkJCVwKKwkJbWVtc2V0KGJ1ZiwgMCwgVlBEX1RNUF9CVUZfU0laRSk7CQkJXAorCQl0cmFuc3BvcnRfZHVtcF92cGRfaWRlbnQodnBkLCBidWYsIFZQRF9UTVBfQlVGX1NJWkUpOyBcCisJCWlmICgobGVuICsgc3RybGVuKGJ1ZikgPiBQQUdFX1NJWkUpKQkJCVwKKwkJCWJyZWFrOwkJCQkJCVwKKwkJbGVuICs9IHNwcmludGYocGFnZStsZW4sICIlcyIsIGJ1Zik7CQkJXAorCX0JCQkJCQkJCVwKKwlzcGluX3VubG9jaygmdDEwX3d3bi0+dDEwX3ZwZF9sb2NrKTsJCQkJXAorCQkJCQkJCQkJXAorCXJldHVybiBsZW47CQkJCQkJCVwKK30KKworLyoKKyAqIFZQRCBwYWdlIDB4ODMgQXNzb2ljYXRpb246IExvZ2ljYWwgVW5pdAorICovCitERUZfREVWX1dXTl9BU1NPQ19TSE9XKHZwZF9hc3NvY19sb2dpY2FsX3VuaXQsIDB4MDApOworCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9kZXZfd3duX3N0b3JlX2F0dHJfdnBkX2Fzc29jX2xvZ2ljYWxfdW5pdCgKKwlzdHJ1Y3QgdDEwX3d3biAqdDEwX3d3biwKKwljb25zdCBjaGFyICpwYWdlLAorCXNpemVfdCBjb3VudCkKK3sKKwlyZXR1cm4gLUVOT1NZUzsKK30KKworU0VfREVWX1dXTl9BVFRSKHZwZF9hc3NvY19sb2dpY2FsX3VuaXQsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworLyoKKyAqIFZQRCBwYWdlIDB4ODMgQXNzb2NpYXRpb246IFRhcmdldCBQb3J0CisgKi8KK0RFRl9ERVZfV1dOX0FTU09DX1NIT1codnBkX2Fzc29jX3RhcmdldF9wb3J0LCAweDEwKTsKKworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfZGV2X3d3bl9zdG9yZV9hdHRyX3ZwZF9hc3NvY190YXJnZXRfcG9ydCgKKwlzdHJ1Y3QgdDEwX3d3biAqdDEwX3d3biwKKwljb25zdCBjaGFyICpwYWdlLAorCXNpemVfdCBjb3VudCkKK3sKKwlyZXR1cm4gLUVOT1NZUzsKK30KKworU0VfREVWX1dXTl9BVFRSKHZwZF9hc3NvY190YXJnZXRfcG9ydCwgU19JUlVHTyB8IFNfSVdVU1IpOworCisvKgorICogVlBEIHBhZ2UgMHg4MyBBc3NvY2lhdGlvbjogU0NTSSBUYXJnZXQgRGV2aWNlCisgKi8KK0RFRl9ERVZfV1dOX0FTU09DX1NIT1codnBkX2Fzc29jX3Njc2lfdGFyZ2V0X2RldmljZSwgMHgyMCk7CisKK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX2Rldl93d25fc3RvcmVfYXR0cl92cGRfYXNzb2Nfc2NzaV90YXJnZXRfZGV2aWNlKAorCXN0cnVjdCB0MTBfd3duICp0MTBfd3duLAorCWNvbnN0IGNoYXIgKnBhZ2UsCisJc2l6ZV90IGNvdW50KQoreworCXJldHVybiAtRU5PU1lTOworfQorCitTRV9ERVZfV1dOX0FUVFIodnBkX2Fzc29jX3Njc2lfdGFyZ2V0X2RldmljZSwgU19JUlVHTyB8IFNfSVdVU1IpOworCitDT05GSUdGU19FQVRUUl9PUFModGFyZ2V0X2NvcmVfZGV2X3d3biwgdDEwX3d3biwgdDEwX3d3bl9ncm91cCk7CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfYXR0cmlidXRlICp0YXJnZXRfY29yZV9kZXZfd3duX2F0dHJzW10gPSB7CisJJnRhcmdldF9jb3JlX2Rldl93d25fdnBkX3VuaXRfc2VyaWFsLmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl93d25fdnBkX3Byb3RvY29sX2lkZW50aWZpZXIuYXR0ciwKKwkmdGFyZ2V0X2NvcmVfZGV2X3d3bl92cGRfYXNzb2NfbG9naWNhbF91bml0LmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl93d25fdnBkX2Fzc29jX3RhcmdldF9wb3J0LmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl93d25fdnBkX2Fzc29jX3Njc2lfdGFyZ2V0X2RldmljZS5hdHRyLAorCU5VTEwsCit9OworCitzdGF0aWMgc3RydWN0IGNvbmZpZ2ZzX2l0ZW1fb3BlcmF0aW9ucyB0YXJnZXRfY29yZV9kZXZfd3duX29wcyA9IHsKKwkuc2hvd19hdHRyaWJ1dGUJCT0gdGFyZ2V0X2NvcmVfZGV2X3d3bl9hdHRyX3Nob3csCisJLnN0b3JlX2F0dHJpYnV0ZQk9IHRhcmdldF9jb3JlX2Rldl93d25fYXR0cl9zdG9yZSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9kZXZfd3duX2NpdCA9IHsKKwkuY3RfaXRlbV9vcHMJCT0gJnRhcmdldF9jb3JlX2Rldl93d25fb3BzLAorCS5jdF9hdHRycwkJPSB0YXJnZXRfY29yZV9kZXZfd3duX2F0dHJzLAorCS5jdF9vd25lcgkJPSBUSElTX01PRFVMRSwKK307CisKKy8qICBFbmQgZnVuY3Rpb25zIGZvciBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9kZXZfd3duX2NpdCAqLworCisvKiAgU3RhcnQgZnVuY3Rpb25zIGZvciBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9kZXZfcHJfY2l0ICovCisKK0NPTkZJR0ZTX0VBVFRSX1NUUlVDVCh0YXJnZXRfY29yZV9kZXZfcHIsIHNlX3N1YnN5c3RlbV9kZXYpOworI2RlZmluZSBTRV9ERVZfUFJfQVRUUihfbmFtZSwgX21vZGUpCQkJCQlcCitzdGF0aWMgc3RydWN0IHRhcmdldF9jb3JlX2Rldl9wcl9hdHRyaWJ1dGUgdGFyZ2V0X2NvcmVfZGV2X3ByXyMjX25hbWUgPSBcCisJX19DT05GSUdGU19FQVRUUihfbmFtZSwgX21vZGUsCQkJCQlcCisJdGFyZ2V0X2NvcmVfZGV2X3ByX3Nob3dfYXR0cl8jI19uYW1lLAkJCQlcCisJdGFyZ2V0X2NvcmVfZGV2X3ByX3N0b3JlX2F0dHJfIyNfbmFtZSk7CisKKyNkZWZpbmUgU0VfREVWX1BSX0FUVFJfUk8oX25hbWUpOwkJCQkJXAorc3RhdGljIHN0cnVjdCB0YXJnZXRfY29yZV9kZXZfcHJfYXR0cmlidXRlIHRhcmdldF9jb3JlX2Rldl9wcl8jI19uYW1lID0JXAorCV9fQ09ORklHRlNfRUFUVFJfUk8oX25hbWUsCQkJCQlcCisJdGFyZ2V0X2NvcmVfZGV2X3ByX3Nob3dfYXR0cl8jI19uYW1lKTsKKworLyoKKyAqIHJlc19ob2xkZXIKKyAqLworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfZGV2X3ByX3Nob3dfc3BjM19yZXMoCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCWNoYXIgKnBhZ2UsCisJc3NpemVfdCAqbGVuKQoreworCXN0cnVjdCBzZV9ub2RlX2FjbCAqc2VfbmFjbDsKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnOworCWNoYXIgaV9idWZbUFJfUkVHX0lTSURfSURfTEVOXTsKKwlpbnQgcHJmX2lzaWQ7CisKKwltZW1zZXQoaV9idWYsIDAsIFBSX1JFR19JU0lEX0lEX0xFTik7CisKKwlzcGluX2xvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCXByX3JlZyA9IGRldi0+ZGV2X3ByX3Jlc19ob2xkZXI7CisJaWYgKCEocHJfcmVnKSkgeworCQkqbGVuICs9IHNwcmludGYocGFnZSArICpsZW4sICJObyBTUEMtMyBSZXNlcnZhdGlvbiBob2xkZXJcbiIpOworCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCXJldHVybiAqbGVuOworCX0KKwlzZV9uYWNsID0gcHJfcmVnLT5wcl9yZWdfbmFjbDsKKwlwcmZfaXNpZCA9IGNvcmVfcHJfZHVtcF9pbml0aWF0b3JfcG9ydChwcl9yZWcsICZpX2J1ZlswXSwKKwkJCQlQUl9SRUdfSVNJRF9JRF9MRU4pOworCisJKmxlbiArPSBzcHJpbnRmKHBhZ2UgKyAqbGVuLCAiU1BDLTMgUmVzZXJ2YXRpb246ICVzIEluaXRpYXRvcjogJXMlc1xuIiwKKwkJVFBHX1RGTyhzZV9uYWNsLT5zZV90cGcpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJc2VfbmFjbC0+aW5pdGlhdG9ybmFtZSwgKHByZl9pc2lkKSA/ICZpX2J1ZlswXSA6ICIiKTsKKwlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisKKwlyZXR1cm4gKmxlbjsKK30KKworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfZGV2X3ByX3Nob3dfc3BjMl9yZXMoCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCWNoYXIgKnBhZ2UsCisJc3NpemVfdCAqbGVuKQoreworCXN0cnVjdCBzZV9ub2RlX2FjbCAqc2VfbmFjbDsKKworCXNwaW5fbG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJc2VfbmFjbCA9IGRldi0+ZGV2X3Jlc2VydmVkX25vZGVfYWNsOworCWlmICghKHNlX25hY2wpKSB7CisJCSpsZW4gKz0gc3ByaW50ZihwYWdlICsgKmxlbiwgIk5vIFNQQy0yIFJlc2VydmF0aW9uIGhvbGRlclxuIik7CisJCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwkJcmV0dXJuICpsZW47CisJfQorCSpsZW4gKz0gc3ByaW50ZihwYWdlICsgKmxlbiwgIlNQQy0yIFJlc2VydmF0aW9uOiAlcyBJbml0aWF0b3I6ICVzXG4iLAorCQlUUEdfVEZPKHNlX25hY2wtPnNlX3RwZyktPmdldF9mYWJyaWNfbmFtZSgpLAorCQlzZV9uYWNsLT5pbml0aWF0b3JuYW1lKTsKKwlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisKKwlyZXR1cm4gKmxlbjsKK30KKworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfZGV2X3ByX3Nob3dfYXR0cl9yZXNfaG9sZGVyKAorCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXYsCisJY2hhciAqcGFnZSkKK3sKKwlzc2l6ZV90IGxlbiA9IDA7CisKKwlpZiAoIShzdV9kZXYtPnNlX2Rldl9wdHIpKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCXN3aXRjaCAoVDEwX1JFUyhzdV9kZXYpLT5yZXNfdHlwZSkgeworCWNhc2UgU1BDM19QRVJTSVNURU5UX1JFU0VSVkFUSU9OUzoKKwkJdGFyZ2V0X2NvcmVfZGV2X3ByX3Nob3dfc3BjM19yZXMoc3VfZGV2LT5zZV9kZXZfcHRyLAorCQkJCXBhZ2UsICZsZW4pOworCQlicmVhazsKKwljYXNlIFNQQzJfUkVTRVJWQVRJT05TOgorCQl0YXJnZXRfY29yZV9kZXZfcHJfc2hvd19zcGMyX3JlcyhzdV9kZXYtPnNlX2Rldl9wdHIsCisJCQkJcGFnZSwgJmxlbik7CisJCWJyZWFrOworCWNhc2UgU1BDX1BBU1NUSFJPVUdIOgorCQlsZW4gKz0gc3ByaW50ZihwYWdlK2xlbiwgIlBhc3N0aHJvdWdoXG4iKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJbGVuICs9IHNwcmludGYocGFnZStsZW4sICJVbmtub3duXG4iKTsKKwkJYnJlYWs7CisJfQorCisJcmV0dXJuIGxlbjsKK30KKworU0VfREVWX1BSX0FUVFJfUk8ocmVzX2hvbGRlcik7CisKKy8qCisgKiByZXNfcHJfYWxsX3RndF9wdHMKKyAqLworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfZGV2X3ByX3Nob3dfYXR0cl9yZXNfcHJfYWxsX3RndF9wdHMoCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnN1X2RldiwKKwljaGFyICpwYWdlKQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldjsKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnOworCXNzaXplX3QgbGVuID0gMDsKKworCWRldiA9IHN1X2Rldi0+c2VfZGV2X3B0cjsKKwlpZiAoIShkZXYpKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCWlmIChUMTBfUkVTKHN1X2RldiktPnJlc190eXBlICE9IFNQQzNfUEVSU0lTVEVOVF9SRVNFUlZBVElPTlMpCisJCXJldHVybiBsZW47CisKKwlzcGluX2xvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCXByX3JlZyA9IGRldi0+ZGV2X3ByX3Jlc19ob2xkZXI7CisJaWYgKCEocHJfcmVnKSkgeworCQlsZW4gPSBzcHJpbnRmKHBhZ2UsICJObyBTUEMtMyBSZXNlcnZhdGlvbiBob2xkZXJcbiIpOworCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCXJldHVybiBsZW47CisJfQorCS8qCisJICogU2VlIEFsbCBUYXJnZXQgUG9ydHMgKEFMTF9UR19QVCkgYml0IGluIHNwY3IxNywgc2VjdGlvbiA2LjE0LjMKKwkgKiBCYXNpYyBQRVJTSVNURU5UIFJFU0VSVkVSIE9VVCBwYXJhbWV0ZXIgbGlzdCwgcGFnZSAyOTAKKwkgKi8KKwlpZiAocHJfcmVnLT5wcl9yZWdfYWxsX3RnX3B0KQorCQlsZW4gPSBzcHJpbnRmKHBhZ2UsICJTUEMtMyBSZXNlcnZhdGlvbjogQWxsIFRhcmdldCIKKwkJCSIgUG9ydHMgcmVnaXN0cmF0aW9uXG4iKTsKKwllbHNlCisJCWxlbiA9IHNwcmludGYocGFnZSwgIlNQQy0zIFJlc2VydmF0aW9uOiBTaW5nbGUiCisJCQkiIFRhcmdldCBQb3J0IHJlZ2lzdHJhdGlvblxuIik7CisJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCisJcmV0dXJuIGxlbjsKK30KKworU0VfREVWX1BSX0FUVFJfUk8ocmVzX3ByX2FsbF90Z3RfcHRzKTsKKworLyoKKyAqIHJlc19wcl9nZW5lcmF0aW9uCisgKi8KK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX2Rldl9wcl9zaG93X2F0dHJfcmVzX3ByX2dlbmVyYXRpb24oCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnN1X2RldiwKKwljaGFyICpwYWdlKQoreworCWlmICghKHN1X2Rldi0+c2VfZGV2X3B0cikpCisJCXJldHVybiAtRU5PREVWOworCisJaWYgKFQxMF9SRVMoc3VfZGV2KS0+cmVzX3R5cGUgIT0gU1BDM19QRVJTSVNURU5UX1JFU0VSVkFUSU9OUykKKwkJcmV0dXJuIDA7CisKKwlyZXR1cm4gc3ByaW50ZihwYWdlLCAiMHglMDh4XG4iLCBUMTBfUkVTKHN1X2RldiktPnByX2dlbmVyYXRpb24pOworfQorCitTRV9ERVZfUFJfQVRUUl9STyhyZXNfcHJfZ2VuZXJhdGlvbik7CisKKy8qCisgKiByZXNfcHJfaG9sZGVyX3RnX3BvcnQKKyAqLworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfZGV2X3ByX3Nob3dfYXR0cl9yZXNfcHJfaG9sZGVyX3RnX3BvcnQoCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnN1X2RldiwKKwljaGFyICpwYWdlKQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldjsKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKnNlX25hY2w7CisJc3RydWN0IHNlX2x1biAqbHVuOworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZzsKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnOworCXN0cnVjdCB0YXJnZXRfY29yZV9mYWJyaWNfb3BzICp0Zm87CisJc3NpemVfdCBsZW4gPSAwOworCisJZGV2ID0gc3VfZGV2LT5zZV9kZXZfcHRyOworCWlmICghKGRldikpCisJCXJldHVybiAtRU5PREVWOworCisJaWYgKFQxMF9SRVMoc3VfZGV2KS0+cmVzX3R5cGUgIT0gU1BDM19QRVJTSVNURU5UX1JFU0VSVkFUSU9OUykKKwkJcmV0dXJuIGxlbjsKKworCXNwaW5fbG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJcHJfcmVnID0gZGV2LT5kZXZfcHJfcmVzX2hvbGRlcjsKKwlpZiAoIShwcl9yZWcpKSB7CisJCWxlbiA9IHNwcmludGYocGFnZSwgIk5vIFNQQy0zIFJlc2VydmF0aW9uIGhvbGRlclxuIik7CisJCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwkJcmV0dXJuIGxlbjsKKwl9CisJc2VfbmFjbCA9IHByX3JlZy0+cHJfcmVnX25hY2w7CisJc2VfdHBnID0gc2VfbmFjbC0+c2VfdHBnOworCWx1biA9IHByX3JlZy0+cHJfcmVnX3RnX3B0X2x1bjsKKwl0Zm8gPSBUUEdfVEZPKHNlX3RwZyk7CisKKwlsZW4gKz0gc3ByaW50ZihwYWdlK2xlbiwgIlNQQy0zIFJlc2VydmF0aW9uOiAlcyIKKwkJIiBUYXJnZXQgTm9kZSBFbmRwb2ludDogJXNcbiIsIHRmby0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCXRmby0+dHBnX2dldF93d24oc2VfdHBnKSk7CisJbGVuICs9IHNwcmludGYocGFnZStsZW4sICJTUEMtMyBSZXNlcnZhdGlvbjogUmVsYXRpdmUgUG9ydCIKKwkJIiBJZGVudGlmZXIgVGFnOiAlaHUgJXMgUG9ydGFsIEdyb3VwIFRhZzogJWh1IgorCQkiICVzIExvZ2ljYWwgVW5pdDogJXVcbiIsIGx1bi0+bHVuX3NlcC0+c2VwX3J0cGksCisJCXRmby0+Z2V0X2ZhYnJpY19uYW1lKCksIHRmby0+dHBnX2dldF90YWcoc2VfdHBnKSwKKwkJdGZvLT5nZXRfZmFicmljX25hbWUoKSwgbHVuLT51bnBhY2tlZF9sdW4pOworCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKworCXJldHVybiBsZW47Cit9CisKK1NFX0RFVl9QUl9BVFRSX1JPKHJlc19wcl9ob2xkZXJfdGdfcG9ydCk7CisKKy8qCisgKiByZXNfcHJfcmVnaXN0ZXJlZF9pX3B0cworICovCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9kZXZfcHJfc2hvd19hdHRyX3Jlc19wcl9yZWdpc3RlcmVkX2lfcHRzKAorCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXYsCisJY2hhciAqcGFnZSkKK3sKKwlzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcyAqdGZvOworCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWc7CisJdW5zaWduZWQgY2hhciBidWZbMzg0XTsKKwljaGFyIGlfYnVmW1BSX1JFR19JU0lEX0lEX0xFTl07CisJc3NpemVfdCBsZW4gPSAwOworCWludCByZWdfY291bnQgPSAwLCBwcmZfaXNpZDsKKworCWlmICghKHN1X2Rldi0+c2VfZGV2X3B0cikpCisJCXJldHVybiAtRU5PREVWOworCisJaWYgKFQxMF9SRVMoc3VfZGV2KS0+cmVzX3R5cGUgIT0gU1BDM19QRVJTSVNURU5UX1JFU0VSVkFUSU9OUykKKwkJcmV0dXJuIGxlbjsKKworCWxlbiArPSBzcHJpbnRmKHBhZ2UrbGVuLCAiU1BDLTMgUFIgUmVnaXN0cmF0aW9uczpcbiIpOworCisJc3Bpbl9sb2NrKCZUMTBfUkVTKHN1X2RldiktPnJlZ2lzdHJhdGlvbl9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHByX3JlZywgJlQxMF9SRVMoc3VfZGV2KS0+cmVnaXN0cmF0aW9uX2xpc3QsCisJCQlwcl9yZWdfbGlzdCkgeworCisJCW1lbXNldChidWYsIDAsIDM4NCk7CisJCW1lbXNldChpX2J1ZiwgMCwgUFJfUkVHX0lTSURfSURfTEVOKTsKKwkJdGZvID0gcHJfcmVnLT5wcl9yZWdfbmFjbC0+c2VfdHBnLT5zZV90cGdfdGZvOworCQlwcmZfaXNpZCA9IGNvcmVfcHJfZHVtcF9pbml0aWF0b3JfcG9ydChwcl9yZWcsICZpX2J1ZlswXSwKKwkJCQkJUFJfUkVHX0lTSURfSURfTEVOKTsKKwkJc3ByaW50ZihidWYsICIlcyBOb2RlOiAlcyVzIEtleTogMHglMDE2THggUFJnZW46IDB4JTA4eFxuIiwKKwkJCXRmby0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCQlwcl9yZWctPnByX3JlZ19uYWNsLT5pbml0aWF0b3JuYW1lLCAocHJmX2lzaWQpID8KKwkJCSZpX2J1ZlswXSA6ICIiLCBwcl9yZWctPnByX3Jlc19rZXksCisJCQlwcl9yZWctPnByX3Jlc19nZW5lcmF0aW9uKTsKKworCQlpZiAoKGxlbiArIHN0cmxlbihidWYpID4gUEFHRV9TSVpFKSkKKwkJCWJyZWFrOworCisJCWxlbiArPSBzcHJpbnRmKHBhZ2UrbGVuLCAiJXMiLCBidWYpOworCQlyZWdfY291bnQrKzsKKwl9CisJc3Bpbl91bmxvY2soJlQxMF9SRVMoc3VfZGV2KS0+cmVnaXN0cmF0aW9uX2xvY2spOworCisJaWYgKCEocmVnX2NvdW50KSkKKwkJbGVuICs9IHNwcmludGYocGFnZStsZW4sICJOb25lXG4iKTsKKworCXJldHVybiBsZW47Cit9CisKK1NFX0RFVl9QUl9BVFRSX1JPKHJlc19wcl9yZWdpc3RlcmVkX2lfcHRzKTsKKworLyoKKyAqIHJlc19wcl90eXBlCisgKi8KK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX2Rldl9wcl9zaG93X2F0dHJfcmVzX3ByX3R5cGUoCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnN1X2RldiwKKwljaGFyICpwYWdlKQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldjsKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnOworCXNzaXplX3QgbGVuID0gMDsKKworCWRldiA9IHN1X2Rldi0+c2VfZGV2X3B0cjsKKwlpZiAoIShkZXYpKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCWlmIChUMTBfUkVTKHN1X2RldiktPnJlc190eXBlICE9IFNQQzNfUEVSU0lTVEVOVF9SRVNFUlZBVElPTlMpCisJCXJldHVybiBsZW47CisKKwlzcGluX2xvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCXByX3JlZyA9IGRldi0+ZGV2X3ByX3Jlc19ob2xkZXI7CisJaWYgKCEocHJfcmVnKSkgeworCQlsZW4gPSBzcHJpbnRmKHBhZ2UsICJObyBTUEMtMyBSZXNlcnZhdGlvbiBob2xkZXJcbiIpOworCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCXJldHVybiBsZW47CisJfQorCWxlbiA9IHNwcmludGYocGFnZSwgIlNQQy0zIFJlc2VydmF0aW9uIFR5cGU6ICVzXG4iLAorCQljb3JlX3Njc2kzX3ByX2R1bXBfdHlwZShwcl9yZWctPnByX3Jlc190eXBlKSk7CisJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCisJcmV0dXJuIGxlbjsKK30KKworU0VfREVWX1BSX0FUVFJfUk8ocmVzX3ByX3R5cGUpOworCisvKgorICogcmVzX3R5cGUKKyAqLworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfZGV2X3ByX3Nob3dfYXR0cl9yZXNfdHlwZSgKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2LAorCWNoYXIgKnBhZ2UpCit7CisJc3NpemVfdCBsZW4gPSAwOworCisJaWYgKCEoc3VfZGV2LT5zZV9kZXZfcHRyKSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlzd2l0Y2ggKFQxMF9SRVMoc3VfZGV2KS0+cmVzX3R5cGUpIHsKKwljYXNlIFNQQzNfUEVSU0lTVEVOVF9SRVNFUlZBVElPTlM6CisJCWxlbiA9IHNwcmludGYocGFnZSwgIlNQQzNfUEVSU0lTVEVOVF9SRVNFUlZBVElPTlNcbiIpOworCQlicmVhazsKKwljYXNlIFNQQzJfUkVTRVJWQVRJT05TOgorCQlsZW4gPSBzcHJpbnRmKHBhZ2UsICJTUEMyX1JFU0VSVkFUSU9OU1xuIik7CisJCWJyZWFrOworCWNhc2UgU1BDX1BBU1NUSFJPVUdIOgorCQlsZW4gPSBzcHJpbnRmKHBhZ2UsICJTUENfUEFTU1RIUk9VR0hcbiIpOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlsZW4gPSBzcHJpbnRmKHBhZ2UsICJVTktOT1dOXG4iKTsKKwkJYnJlYWs7CisJfQorCisJcmV0dXJuIGxlbjsKK30KKworU0VfREVWX1BSX0FUVFJfUk8ocmVzX3R5cGUpOworCisvKgorICogcmVzX2FwdHBsX2FjdGl2ZQorICovCisKK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX2Rldl9wcl9zaG93X2F0dHJfcmVzX2FwdHBsX2FjdGl2ZSgKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2LAorCWNoYXIgKnBhZ2UpCit7CisJaWYgKCEoc3VfZGV2LT5zZV9kZXZfcHRyKSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlpZiAoVDEwX1JFUyhzdV9kZXYpLT5yZXNfdHlwZSAhPSBTUEMzX1BFUlNJU1RFTlRfUkVTRVJWQVRJT05TKQorCQlyZXR1cm4gMDsKKworCXJldHVybiBzcHJpbnRmKHBhZ2UsICJBUFRQTCBCaXQgU3RhdHVzOiAlc1xuIiwKKwkJKFQxMF9SRVMoc3VfZGV2KS0+cHJfYXB0cGxfYWN0aXZlKSA/ICJBY3RpdmF0ZWQiIDogIkRpc2FibGVkIik7Cit9CisKK1NFX0RFVl9QUl9BVFRSX1JPKHJlc19hcHRwbF9hY3RpdmUpOworCisvKgorICogcmVzX2FwdHBsX21ldGFkYXRhCisgKi8KK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX2Rldl9wcl9zaG93X2F0dHJfcmVzX2FwdHBsX21ldGFkYXRhKAorCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXYsCisJY2hhciAqcGFnZSkKK3sKKwlpZiAoIShzdV9kZXYtPnNlX2Rldl9wdHIpKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCWlmIChUMTBfUkVTKHN1X2RldiktPnJlc190eXBlICE9IFNQQzNfUEVSU0lTVEVOVF9SRVNFUlZBVElPTlMpCisJCXJldHVybiAwOworCisJcmV0dXJuIHNwcmludGYocGFnZSwgIlJlYWR5IHRvIHByb2Nlc3MgUFIgQVBUUEwgbWV0YWRhdGEuLlxuIik7Cit9CisKK2VudW0geworCU9wdF9pbml0aWF0b3JfZmFicmljLCBPcHRfaW5pdGlhdG9yX25vZGUsIE9wdF9pbml0aWF0b3Jfc2lkLAorCU9wdF9zYV9yZXNfa2V5LCBPcHRfcmVzX2hvbGRlciwgT3B0X3Jlc190eXBlLCBPcHRfcmVzX3Njb3BlLAorCU9wdF9yZXNfYWxsX3RnX3B0LCBPcHRfbWFwcGVkX2x1biwgT3B0X3RhcmdldF9mYWJyaWMsCisJT3B0X3RhcmdldF9ub2RlLCBPcHRfdHBndCwgT3B0X3BvcnRfcnRwaSwgT3B0X3RhcmdldF9sdW4sIE9wdF9lcnIKK307CisKK3N0YXRpYyBtYXRjaF90YWJsZV90IHRva2VucyA9IHsKKwl7T3B0X2luaXRpYXRvcl9mYWJyaWMsICJpbml0aWF0b3JfZmFicmljPSVzIn0sCisJe09wdF9pbml0aWF0b3Jfbm9kZSwgImluaXRpYXRvcl9ub2RlPSVzIn0sCisJe09wdF9pbml0aWF0b3Jfc2lkLCAiaW5pdGlhdG9yX3NpZD0lcyJ9LAorCXtPcHRfc2FfcmVzX2tleSwgInNhX3Jlc19rZXk9JXMifSwKKwl7T3B0X3Jlc19ob2xkZXIsICJyZXNfaG9sZGVyPSVkIn0sCisJe09wdF9yZXNfdHlwZSwgInJlc190eXBlPSVkIn0sCisJe09wdF9yZXNfc2NvcGUsICJyZXNfc2NvcGU9JWQifSwKKwl7T3B0X3Jlc19hbGxfdGdfcHQsICJyZXNfYWxsX3RnX3B0PSVkIn0sCisJe09wdF9tYXBwZWRfbHVuLCAibWFwcGVkX2x1bj0lZCJ9LAorCXtPcHRfdGFyZ2V0X2ZhYnJpYywgInRhcmdldF9mYWJyaWM9JXMifSwKKwl7T3B0X3RhcmdldF9ub2RlLCAidGFyZ2V0X25vZGU9JXMifSwKKwl7T3B0X3RwZ3QsICJ0cGd0PSVkIn0sCisJe09wdF9wb3J0X3J0cGksICJwb3J0X3J0cGk9JWQifSwKKwl7T3B0X3RhcmdldF9sdW4sICJ0YXJnZXRfbHVuPSVkIn0sCisJe09wdF9lcnIsIE5VTEx9Cit9OworCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9kZXZfcHJfc3RvcmVfYXR0cl9yZXNfYXB0cGxfbWV0YWRhdGEoCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnN1X2RldiwKKwljb25zdCBjaGFyICpwYWdlLAorCXNpemVfdCBjb3VudCkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXY7CisJdW5zaWduZWQgY2hhciAqaV9mYWJyaWMsICp0X2ZhYnJpYywgKmlfcG9ydCA9IE5VTEwsICp0X3BvcnQgPSBOVUxMOworCXVuc2lnbmVkIGNoYXIgKmlzaWQgPSBOVUxMOworCWNoYXIgKm9yaWcsICpwdHIsICphcmdfcCwgKm9wdHM7CisJc3Vic3RyaW5nX3QgYXJnc1tNQVhfT1BUX0FSR1NdOworCXVuc2lnbmVkIGxvbmcgbG9uZyB0bXBfbGw7CisJdTY0IHNhX3Jlc19rZXkgPSAwOworCXUzMiBtYXBwZWRfbHVuID0gMCwgdGFyZ2V0X2x1biA9IDA7CisJaW50IHJldCA9IC0xLCByZXNfaG9sZGVyID0gMCwgYWxsX3RnX3B0ID0gMCwgYXJnLCB0b2tlbjsKKwl1MTYgcG9ydF9ycHRpID0gMCwgdHBndCA9IDA7CisJdTggdHlwZSA9IDAsIHNjb3BlOworCisJZGV2ID0gc3VfZGV2LT5zZV9kZXZfcHRyOworCWlmICghKGRldikpCisJCXJldHVybiAtRU5PREVWOworCisJaWYgKFQxMF9SRVMoc3VfZGV2KS0+cmVzX3R5cGUgIT0gU1BDM19QRVJTSVNURU5UX1JFU0VSVkFUSU9OUykKKwkJcmV0dXJuIDA7CisKKwlpZiAoYXRvbWljX3JlYWQoJmRldi0+ZGV2X2V4cG9ydF9vYmoub2JqX2FjY2Vzc19jb3VudCkpIHsKKwkJcHJpbnRrKEtFUk5fSU5GTyAiVW5hYmxlIHRvIHByb2Nlc3MgQVBUUEwgbWV0YWRhdGEgd2hpbGUiCisJCQkiIGFjdGl2ZSBmYWJyaWMgZXhwb3J0cyBleGlzdFxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCW9wdHMgPSBrc3RyZHVwKHBhZ2UsIEdGUF9LRVJORUwpOworCWlmICghb3B0cykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlvcmlnID0gb3B0czsKKwl3aGlsZSAoKHB0ciA9IHN0cnNlcCgmb3B0cywgIiwiKSkgIT0gTlVMTCkgeworCQlpZiAoISpwdHIpCisJCQljb250aW51ZTsKKworCQl0b2tlbiA9IG1hdGNoX3Rva2VuKHB0ciwgdG9rZW5zLCBhcmdzKTsKKwkJc3dpdGNoICh0b2tlbikgeworCQljYXNlIE9wdF9pbml0aWF0b3JfZmFicmljOgorCQkJaV9mYWJyaWMgPSBtYXRjaF9zdHJkdXAoJmFyZ3NbMF0pOworCQkJYnJlYWs7CisJCWNhc2UgT3B0X2luaXRpYXRvcl9ub2RlOgorCQkJaV9wb3J0ID0gbWF0Y2hfc3RyZHVwKCZhcmdzWzBdKTsKKwkJCWlmIChzdHJsZW4oaV9wb3J0KSA+IFBSX0FQVFBMX01BWF9JUE9SVF9MRU4pIHsKKwkJCQlwcmludGsoS0VSTl9FUlIgIkFQVFBMIG1ldGFkYXRhIGluaXRpYXRvcl9ub2RlPSIKKwkJCQkJIiBleGNlZWRzIFBSX0FQVFBMX01BWF9JUE9SVF9MRU46ICVkXG4iLAorCQkJCQlQUl9BUFRQTF9NQVhfSVBPUlRfTEVOKTsKKwkJCQlyZXQgPSAtRUlOVkFMOworCQkJCWJyZWFrOworCQkJfQorCQkJYnJlYWs7CisJCWNhc2UgT3B0X2luaXRpYXRvcl9zaWQ6CisJCQlpc2lkID0gbWF0Y2hfc3RyZHVwKCZhcmdzWzBdKTsKKwkJCWlmIChzdHJsZW4oaXNpZCkgPiBQUl9SRUdfSVNJRF9MRU4pIHsKKwkJCQlwcmludGsoS0VSTl9FUlIgIkFQVFBMIG1ldGFkYXRhIGluaXRpYXRvcl9pc2lkIgorCQkJCQkiPSBleGNlZWRzIFBSX1JFR19JU0lEX0xFTjogJWRcbiIsCisJCQkJCVBSX1JFR19JU0lEX0xFTik7CisJCQkJcmV0ID0gLUVJTlZBTDsKKwkJCQlicmVhazsKKwkJCX0KKwkJCWJyZWFrOworCQljYXNlIE9wdF9zYV9yZXNfa2V5OgorCQkJYXJnX3AgPSBtYXRjaF9zdHJkdXAoJmFyZ3NbMF0pOworCQkJcmV0ID0gc3RyaWN0X3N0cnRvdWxsKGFyZ19wLCAwLCAmdG1wX2xsKTsKKwkJCWlmIChyZXQgPCAwKSB7CisJCQkJcHJpbnRrKEtFUk5fRVJSICJzdHJpY3Rfc3RydG91bGwoKSBmYWlsZWQgZm9yIgorCQkJCQkiIHNhX3Jlc19rZXk9XG4iKTsKKwkJCQlnb3RvIG91dDsKKwkJCX0KKwkJCXNhX3Jlc19rZXkgPSAodTY0KXRtcF9sbDsKKwkJCWJyZWFrOworCQkvKgorCQkgKiBQUiBBUFRQTCBNZXRhZGF0YSBmb3IgUmVzZXJ2YXRpb24KKwkJICovCisJCWNhc2UgT3B0X3Jlc19ob2xkZXI6CisJCQltYXRjaF9pbnQoYXJncywgJmFyZyk7CisJCQlyZXNfaG9sZGVyID0gYXJnOworCQkJYnJlYWs7CisJCWNhc2UgT3B0X3Jlc190eXBlOgorCQkJbWF0Y2hfaW50KGFyZ3MsICZhcmcpOworCQkJdHlwZSA9ICh1OClhcmc7CisJCQlicmVhazsKKwkJY2FzZSBPcHRfcmVzX3Njb3BlOgorCQkJbWF0Y2hfaW50KGFyZ3MsICZhcmcpOworCQkJc2NvcGUgPSAodTgpYXJnOworCQkJYnJlYWs7CisJCWNhc2UgT3B0X3Jlc19hbGxfdGdfcHQ6CisJCQltYXRjaF9pbnQoYXJncywgJmFyZyk7CisJCQlhbGxfdGdfcHQgPSAoaW50KWFyZzsKKwkJCWJyZWFrOworCQljYXNlIE9wdF9tYXBwZWRfbHVuOgorCQkJbWF0Y2hfaW50KGFyZ3MsICZhcmcpOworCQkJbWFwcGVkX2x1biA9ICh1MzIpYXJnOworCQkJYnJlYWs7CisJCS8qCisJCSAqIFBSIEFQVFBMIE1ldGFkYXRhIGZvciBUYXJnZXQgUG9ydAorCQkgKi8KKwkJY2FzZSBPcHRfdGFyZ2V0X2ZhYnJpYzoKKwkJCXRfZmFicmljID0gbWF0Y2hfc3RyZHVwKCZhcmdzWzBdKTsKKwkJCWJyZWFrOworCQljYXNlIE9wdF90YXJnZXRfbm9kZToKKwkJCXRfcG9ydCA9IG1hdGNoX3N0cmR1cCgmYXJnc1swXSk7CisJCQlpZiAoc3RybGVuKHRfcG9ydCkgPiBQUl9BUFRQTF9NQVhfVFBPUlRfTEVOKSB7CisJCQkJcHJpbnRrKEtFUk5fRVJSICJBUFRQTCBtZXRhZGF0YSB0YXJnZXRfbm9kZT0iCisJCQkJCSIgZXhjZWVkcyBQUl9BUFRQTF9NQVhfVFBPUlRfTEVOOiAlZFxuIiwKKwkJCQkJUFJfQVBUUExfTUFYX1RQT1JUX0xFTik7CisJCQkJcmV0ID0gLUVJTlZBTDsKKwkJCQlicmVhazsKKwkJCX0KKwkJCWJyZWFrOworCQljYXNlIE9wdF90cGd0OgorCQkJbWF0Y2hfaW50KGFyZ3MsICZhcmcpOworCQkJdHBndCA9ICh1MTYpYXJnOworCQkJYnJlYWs7CisJCWNhc2UgT3B0X3BvcnRfcnRwaToKKwkJCW1hdGNoX2ludChhcmdzLCAmYXJnKTsKKwkJCXBvcnRfcnB0aSA9ICh1MTYpYXJnOworCQkJYnJlYWs7CisJCWNhc2UgT3B0X3RhcmdldF9sdW46CisJCQltYXRjaF9pbnQoYXJncywgJmFyZyk7CisJCQl0YXJnZXRfbHVuID0gKHUzMilhcmc7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCWJyZWFrOworCQl9CisJfQorCisJaWYgKCEoaV9wb3J0KSB8fCAhKHRfcG9ydCkgfHwgIShzYV9yZXNfa2V5KSkgeworCQlwcmludGsoS0VSTl9FUlIgIklsbGVnYWwgcGFyYW1ldGVycyBmb3IgQVBUUEwgcmVnaXN0cmF0aW9uXG4iKTsKKwkJcmV0ID0gLUVJTlZBTDsKKwkJZ290byBvdXQ7CisJfQorCisJaWYgKHJlc19ob2xkZXIgJiYgISh0eXBlKSkgeworCQlwcmludGsoS0VSTl9FUlIgIklsbGVnYWwgUFIgdHlwZTogMHglMDJ4IGZvciByZXNlcnZhdGlvbiIKKwkJCQkiIGhvbGRlclxuIiwgdHlwZSk7CisJCXJldCA9IC1FSU5WQUw7CisJCWdvdG8gb3V0OworCX0KKworCXJldCA9IGNvcmVfc2NzaTNfYWxsb2NfYXB0cGxfcmVnaXN0cmF0aW9uKFQxMF9SRVMoc3VfZGV2KSwgc2FfcmVzX2tleSwKKwkJCWlfcG9ydCwgaXNpZCwgbWFwcGVkX2x1biwgdF9wb3J0LCB0cGd0LCB0YXJnZXRfbHVuLAorCQkJcmVzX2hvbGRlciwgYWxsX3RnX3B0LCB0eXBlKTsKK291dDoKKwlrZnJlZShvcmlnKTsKKwlyZXR1cm4gKHJldCA9PSAwKSA/IGNvdW50IDogcmV0OworfQorCitTRV9ERVZfUFJfQVRUUihyZXNfYXB0cGxfbWV0YWRhdGEsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworQ09ORklHRlNfRUFUVFJfT1BTKHRhcmdldF9jb3JlX2Rldl9wciwgc2Vfc3Vic3lzdGVtX2Rldiwgc2VfZGV2X3ByX2dyb3VwKTsKKworc3RhdGljIHN0cnVjdCBjb25maWdmc19hdHRyaWJ1dGUgKnRhcmdldF9jb3JlX2Rldl9wcl9hdHRyc1tdID0geworCSZ0YXJnZXRfY29yZV9kZXZfcHJfcmVzX2hvbGRlci5hdHRyLAorCSZ0YXJnZXRfY29yZV9kZXZfcHJfcmVzX3ByX2FsbF90Z3RfcHRzLmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl9wcl9yZXNfcHJfZ2VuZXJhdGlvbi5hdHRyLAorCSZ0YXJnZXRfY29yZV9kZXZfcHJfcmVzX3ByX2hvbGRlcl90Z19wb3J0LmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl9wcl9yZXNfcHJfcmVnaXN0ZXJlZF9pX3B0cy5hdHRyLAorCSZ0YXJnZXRfY29yZV9kZXZfcHJfcmVzX3ByX3R5cGUuYXR0ciwKKwkmdGFyZ2V0X2NvcmVfZGV2X3ByX3Jlc190eXBlLmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl9wcl9yZXNfYXB0cGxfYWN0aXZlLmF0dHIsCisJJnRhcmdldF9jb3JlX2Rldl9wcl9yZXNfYXB0cGxfbWV0YWRhdGEuYXR0ciwKKwlOVUxMLAorfTsKKworc3RhdGljIHN0cnVjdCBjb25maWdmc19pdGVtX29wZXJhdGlvbnMgdGFyZ2V0X2NvcmVfZGV2X3ByX29wcyA9IHsKKwkuc2hvd19hdHRyaWJ1dGUJCT0gdGFyZ2V0X2NvcmVfZGV2X3ByX2F0dHJfc2hvdywKKwkuc3RvcmVfYXR0cmlidXRlCT0gdGFyZ2V0X2NvcmVfZGV2X3ByX2F0dHJfc3RvcmUsCit9OworCitzdGF0aWMgc3RydWN0IGNvbmZpZ19pdGVtX3R5cGUgdGFyZ2V0X2NvcmVfZGV2X3ByX2NpdCA9IHsKKwkuY3RfaXRlbV9vcHMJCT0gJnRhcmdldF9jb3JlX2Rldl9wcl9vcHMsCisJLmN0X2F0dHJzCQk9IHRhcmdldF9jb3JlX2Rldl9wcl9hdHRycywKKwkuY3Rfb3duZXIJCT0gVEhJU19NT0RVTEUsCit9OworCisvKiAgRW5kIGZ1bmN0aW9ucyBmb3Igc3RydWN0IGNvbmZpZ19pdGVtX3R5cGUgdGFyZ2V0X2NvcmVfZGV2X3ByX2NpdCAqLworCisvKiAgU3RhcnQgZnVuY3Rpb25zIGZvciBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9kZXZfY2l0ICovCisKK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX3Nob3dfZGV2X2luZm8odm9pZCAqcCwgY2hhciAqcGFnZSkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc2VfZGV2ID0gKHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICopcDsKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEgPSBzZV9kZXYtPnNlX2Rldl9oYmE7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9hcGkgKnQgPSBoYmEtPnRyYW5zcG9ydDsKKwlpbnQgYmwgPSAwOworCXNzaXplX3QgcmVhZF9ieXRlcyA9IDA7CisKKwlpZiAoIShzZV9kZXYtPnNlX2Rldl9wdHIpKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCXRyYW5zcG9ydF9kdW1wX2Rldl9zdGF0ZShzZV9kZXYtPnNlX2Rldl9wdHIsIHBhZ2UsICZibCk7CisJcmVhZF9ieXRlcyArPSBibDsKKwlyZWFkX2J5dGVzICs9IHQtPnNob3dfY29uZmlnZnNfZGV2X3BhcmFtcyhoYmEsIHNlX2RldiwgcGFnZStyZWFkX2J5dGVzKTsKKwlyZXR1cm4gcmVhZF9ieXRlczsKK30KKworc3RhdGljIHN0cnVjdCB0YXJnZXRfY29yZV9jb25maWdmc19hdHRyaWJ1dGUgdGFyZ2V0X2NvcmVfYXR0cl9kZXZfaW5mbyA9IHsKKwkuYXR0cgk9IHsgLmNhX293bmVyID0gVEhJU19NT0RVTEUsCisJCSAgICAuY2FfbmFtZSA9ICJpbmZvIiwKKwkJICAgIC5jYV9tb2RlID0gU19JUlVHTyB9LAorCS5zaG93CT0gdGFyZ2V0X2NvcmVfc2hvd19kZXZfaW5mbywKKwkuc3RvcmUJPSBOVUxMLAorfTsKKworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfc3RvcmVfZGV2X2NvbnRyb2woCisJdm9pZCAqcCwKKwljb25zdCBjaGFyICpwYWdlLAorCXNpemVfdCBjb3VudCkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc2VfZGV2ID0gKHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICopcDsKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEgPSBzZV9kZXYtPnNlX2Rldl9oYmE7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9hcGkgKnQgPSBoYmEtPnRyYW5zcG9ydDsKKworCWlmICghKHNlX2Rldi0+c2VfZGV2X3N1X3B0cikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gbG9jYXRlIHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2PnNlIgorCQkJCSJfZGV2X3N1X3B0clxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXJldHVybiB0LT5zZXRfY29uZmlnZnNfZGV2X3BhcmFtcyhoYmEsIHNlX2RldiwgcGFnZSwgY291bnQpOworfQorCitzdGF0aWMgc3RydWN0IHRhcmdldF9jb3JlX2NvbmZpZ2ZzX2F0dHJpYnV0ZSB0YXJnZXRfY29yZV9hdHRyX2Rldl9jb250cm9sID0geworCS5hdHRyCT0geyAuY2Ffb3duZXIgPSBUSElTX01PRFVMRSwKKwkJICAgIC5jYV9uYW1lID0gImNvbnRyb2wiLAorCQkgICAgLmNhX21vZGUgPSBTX0lXVVNSIH0sCisJLnNob3cJPSBOVUxMLAorCS5zdG9yZQk9IHRhcmdldF9jb3JlX3N0b3JlX2Rldl9jb250cm9sLAorfTsKKworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfc2hvd19kZXZfYWxpYXModm9pZCAqcCwgY2hhciAqcGFnZSkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc2VfZGV2ID0gKHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICopcDsKKworCWlmICghKHNlX2Rldi0+c3VfZGV2X2ZsYWdzICYgU0RGX1VTSU5HX0FMSUFTKSkKKwkJcmV0dXJuIDA7CisKKwlyZXR1cm4gc25wcmludGYocGFnZSwgUEFHRV9TSVpFLCAiJXNcbiIsIHNlX2Rldi0+c2VfZGV2X2FsaWFzKTsKK30KKworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfc3RvcmVfZGV2X2FsaWFzKAorCXZvaWQgKnAsCisJY29uc3QgY2hhciAqcGFnZSwKKwlzaXplX3QgY291bnQpCit7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiA9IChzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqKXA7CisJc3RydWN0IHNlX2hiYSAqaGJhID0gc2VfZGV2LT5zZV9kZXZfaGJhOworCXNzaXplX3QgcmVhZF9ieXRlczsKKworCWlmIChjb3VudCA+IChTRV9ERVZfQUxJQVNfTEVOLTEpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiYWxpYXMgY291bnQ6ICVkIGV4Y2VlZHMiCisJCQkiIFNFX0RFVl9BTElBU19MRU4tMTogJXVcbiIsIChpbnQpY291bnQsCisJCQlTRV9ERVZfQUxJQVNfTEVOLTEpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlzZV9kZXYtPnN1X2Rldl9mbGFncyB8PSBTREZfVVNJTkdfQUxJQVM7CisJcmVhZF9ieXRlcyA9IHNucHJpbnRmKCZzZV9kZXYtPnNlX2Rldl9hbGlhc1swXSwgU0VfREVWX0FMSUFTX0xFTiwKKwkJCSIlcyIsIHBhZ2UpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiVGFyZ2V0X0NvcmVfQ29uZmlnRlM6ICVzLyVzIHNldCBhbGlhczogJXNcbiIsCisJCWNvbmZpZ19pdGVtX25hbWUoJmhiYS0+aGJhX2dyb3VwLmNnX2l0ZW0pLAorCQljb25maWdfaXRlbV9uYW1lKCZzZV9kZXYtPnNlX2Rldl9ncm91cC5jZ19pdGVtKSwKKwkJc2VfZGV2LT5zZV9kZXZfYWxpYXMpOworCisJcmV0dXJuIHJlYWRfYnl0ZXM7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2NvcmVfY29uZmlnZnNfYXR0cmlidXRlIHRhcmdldF9jb3JlX2F0dHJfZGV2X2FsaWFzID0geworCS5hdHRyCT0geyAuY2Ffb3duZXIgPSBUSElTX01PRFVMRSwKKwkJICAgIC5jYV9uYW1lID0gImFsaWFzIiwKKwkJICAgIC5jYV9tb2RlID0gIFNfSVJVR08gfCBTX0lXVVNSIH0sCisJLnNob3cJPSB0YXJnZXRfY29yZV9zaG93X2Rldl9hbGlhcywKKwkuc3RvcmUJPSB0YXJnZXRfY29yZV9zdG9yZV9kZXZfYWxpYXMsCit9OworCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9zaG93X2Rldl91ZGV2X3BhdGgodm9pZCAqcCwgY2hhciAqcGFnZSkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc2VfZGV2ID0gKHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICopcDsKKworCWlmICghKHNlX2Rldi0+c3VfZGV2X2ZsYWdzICYgU0RGX1VTSU5HX1VERVZfUEFUSCkpCisJCXJldHVybiAwOworCisJcmV0dXJuIHNucHJpbnRmKHBhZ2UsIFBBR0VfU0laRSwgIiVzXG4iLCBzZV9kZXYtPnNlX2Rldl91ZGV2X3BhdGgpOworfQorCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9zdG9yZV9kZXZfdWRldl9wYXRoKAorCXZvaWQgKnAsCisJY29uc3QgY2hhciAqcGFnZSwKKwlzaXplX3QgY291bnQpCit7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiA9IChzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqKXA7CisJc3RydWN0IHNlX2hiYSAqaGJhID0gc2VfZGV2LT5zZV9kZXZfaGJhOworCXNzaXplX3QgcmVhZF9ieXRlczsKKworCWlmIChjb3VudCA+IChTRV9VREVWX1BBVEhfTEVOLTEpKSB7CisJCXByaW50ayhLRVJOX0VSUiAidWRldl9wYXRoIGNvdW50OiAlZCBleGNlZWRzIgorCQkJIiBTRV9VREVWX1BBVEhfTEVOLTE6ICV1XG4iLCAoaW50KWNvdW50LAorCQkJU0VfVURFVl9QQVRIX0xFTi0xKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJc2VfZGV2LT5zdV9kZXZfZmxhZ3MgfD0gU0RGX1VTSU5HX1VERVZfUEFUSDsKKwlyZWFkX2J5dGVzID0gc25wcmludGYoJnNlX2Rldi0+c2VfZGV2X3VkZXZfcGF0aFswXSwgU0VfVURFVl9QQVRIX0xFTiwKKwkJCSIlcyIsIHBhZ2UpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiVGFyZ2V0X0NvcmVfQ29uZmlnRlM6ICVzLyVzIHNldCB1ZGV2X3BhdGg6ICVzXG4iLAorCQljb25maWdfaXRlbV9uYW1lKCZoYmEtPmhiYV9ncm91cC5jZ19pdGVtKSwKKwkJY29uZmlnX2l0ZW1fbmFtZSgmc2VfZGV2LT5zZV9kZXZfZ3JvdXAuY2dfaXRlbSksCisJCXNlX2Rldi0+c2VfZGV2X3VkZXZfcGF0aCk7CisKKwlyZXR1cm4gcmVhZF9ieXRlczsKK30KKworc3RhdGljIHN0cnVjdCB0YXJnZXRfY29yZV9jb25maWdmc19hdHRyaWJ1dGUgdGFyZ2V0X2NvcmVfYXR0cl9kZXZfdWRldl9wYXRoID0geworCS5hdHRyCT0geyAuY2Ffb3duZXIgPSBUSElTX01PRFVMRSwKKwkJICAgIC5jYV9uYW1lID0gInVkZXZfcGF0aCIsCisJCSAgICAuY2FfbW9kZSA9ICBTX0lSVUdPIHwgU19JV1VTUiB9LAorCS5zaG93CT0gdGFyZ2V0X2NvcmVfc2hvd19kZXZfdWRldl9wYXRoLAorCS5zdG9yZQk9IHRhcmdldF9jb3JlX3N0b3JlX2Rldl91ZGV2X3BhdGgsCit9OworCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9zdG9yZV9kZXZfZW5hYmxlKAorCXZvaWQgKnAsCisJY29uc3QgY2hhciAqcGFnZSwKKwlzaXplX3QgY291bnQpCit7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiA9IChzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqKXA7CisJc3RydWN0IHNlX2RldmljZSAqZGV2OworCXN0cnVjdCBzZV9oYmEgKmhiYSA9IHNlX2Rldi0+c2VfZGV2X2hiYTsKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2FwaSAqdCA9IGhiYS0+dHJhbnNwb3J0OworCWNoYXIgKnB0cjsKKworCXB0ciA9IHN0cnN0cihwYWdlLCAiMSIpOworCWlmICghKHB0cikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJGb3IgZGV2X2VuYWJsZSBvcHMsIG9ubHkgdmFsaWQgdmFsdWUiCisJCQkJIiBpcyBcIjFcIlxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoKHNlX2Rldi0+c2VfZGV2X3B0cikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJzZV9kZXYtPnNlX2Rldl9wdHIgYWxyZWFkeSBzZXQgZm9yIHN0b3JhZ2UiCisJCQkJIiBvYmplY3RcbiIpOworCQlyZXR1cm4gLUVFWElTVDsKKwl9CisKKwlpZiAodC0+Y2hlY2tfY29uZmlnZnNfZGV2X3BhcmFtcyhoYmEsIHNlX2RldikgPCAwKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWRldiA9IHQtPmNyZWF0ZV92aXJ0ZGV2aWNlKGhiYSwgc2VfZGV2LCBzZV9kZXYtPnNlX2Rldl9zdV9wdHIpOworCWlmICghKGRldikgfHwgSVNfRVJSKGRldikpCisJCXJldHVybiAtRUlOVkFMOworCisJc2VfZGV2LT5zZV9kZXZfcHRyID0gZGV2OworCXByaW50ayhLRVJOX0lORk8gIlRhcmdldF9Db3JlX0NvbmZpZ0ZTOiBSZWdpc3RlcmVkIHNlX2Rldi0+c2VfZGV2X3B0cjoiCisJCSIgJXBcbiIsIHNlX2Rldi0+c2VfZGV2X3B0cik7CisKKwlyZXR1cm4gY291bnQ7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2NvcmVfY29uZmlnZnNfYXR0cmlidXRlIHRhcmdldF9jb3JlX2F0dHJfZGV2X2VuYWJsZSA9IHsKKwkuYXR0cgk9IHsgLmNhX293bmVyID0gVEhJU19NT0RVTEUsCisJCSAgICAuY2FfbmFtZSA9ICJlbmFibGUiLAorCQkgICAgLmNhX21vZGUgPSBTX0lXVVNSIH0sCisJLnNob3cJPSBOVUxMLAorCS5zdG9yZQk9IHRhcmdldF9jb3JlX3N0b3JlX2Rldl9lbmFibGUsCit9OworCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9zaG93X2FsdWFfbHVfZ3Aodm9pZCAqcCwgY2hhciAqcGFnZSkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXY7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnN1X2RldiA9IChzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqKXA7CisJc3RydWN0IGNvbmZpZ19pdGVtICpsdV9jaTsKKwlzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKmx1X2dwOworCXN0cnVjdCB0MTBfYWx1YV9sdV9ncF9tZW1iZXIgKmx1X2dwX21lbTsKKwlzc2l6ZV90IGxlbiA9IDA7CisKKwlkZXYgPSBzdV9kZXYtPnNlX2Rldl9wdHI7CisJaWYgKCEoZGV2KSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlpZiAoVDEwX0FMVUEoc3VfZGV2KS0+YWx1YV90eXBlICE9IFNQQzNfQUxVQV9FTVVMQVRFRCkKKwkJcmV0dXJuIGxlbjsKKworCWx1X2dwX21lbSA9IGRldi0+ZGV2X2FsdWFfbHVfZ3BfbWVtOworCWlmICghKGx1X2dwX21lbSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJOVUxMIHN0cnVjdCBzZV9kZXZpY2UtPmRldl9hbHVhX2x1X2dwX21lbSIKKwkJCQkiIHBvaW50ZXJcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlzcGluX2xvY2soJmx1X2dwX21lbS0+bHVfZ3BfbWVtX2xvY2spOworCWx1X2dwID0gbHVfZ3BfbWVtLT5sdV9ncDsKKwlpZiAoKGx1X2dwKSkgeworCQlsdV9jaSA9ICZsdV9ncC0+bHVfZ3BfZ3JvdXAuY2dfaXRlbTsKKwkJbGVuICs9IHNwcmludGYocGFnZSwgIkxVIEdyb3VwIEFsaWFzOiAlc1xuTFUgR3JvdXAgSUQ6ICVodVxuIiwKKwkJCWNvbmZpZ19pdGVtX25hbWUobHVfY2kpLCBsdV9ncC0+bHVfZ3BfaWQpOworCX0KKwlzcGluX3VubG9jaygmbHVfZ3BfbWVtLT5sdV9ncF9tZW1fbG9jayk7CisKKwlyZXR1cm4gbGVuOworfQorCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9zdG9yZV9hbHVhX2x1X2dwKAorCXZvaWQgKnAsCisJY29uc3QgY2hhciAqcGFnZSwKKwlzaXplX3QgY291bnQpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2OworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXYgPSAoc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKilwOworCXN0cnVjdCBzZV9oYmEgKmhiYSA9IHN1X2Rldi0+c2VfZGV2X2hiYTsKKwlzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKmx1X2dwID0gTlVMTCwgKmx1X2dwX25ldyA9IE5VTEw7CisJc3RydWN0IHQxMF9hbHVhX2x1X2dwX21lbWJlciAqbHVfZ3BfbWVtOworCXVuc2lnbmVkIGNoYXIgYnVmW0xVX0dST1VQX05BTUVfQlVGXTsKKwlpbnQgbW92ZSA9IDA7CisKKwlkZXYgPSBzdV9kZXYtPnNlX2Rldl9wdHI7CisJaWYgKCEoZGV2KSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlpZiAoVDEwX0FMVUEoc3VfZGV2KS0+YWx1YV90eXBlICE9IFNQQzNfQUxVQV9FTVVMQVRFRCkgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJTUEMzX0FMVUFfRU1VTEFURUQgbm90IGVuYWJsZWQgZm9yICVzLyVzXG4iLAorCQkJY29uZmlnX2l0ZW1fbmFtZSgmaGJhLT5oYmFfZ3JvdXAuY2dfaXRlbSksCisJCQljb25maWdfaXRlbV9uYW1lKCZzdV9kZXYtPnNlX2Rldl9ncm91cC5jZ19pdGVtKSk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAoY291bnQgPiBMVV9HUk9VUF9OQU1FX0JVRikgeworCQlwcmludGsoS0VSTl9FUlIgIkFMVUEgTFUgR3JvdXAgQWxpYXMgdG9vIGxhcmdlIVxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwltZW1zZXQoYnVmLCAwLCBMVV9HUk9VUF9OQU1FX0JVRik7CisJbWVtY3B5KGJ1ZiwgcGFnZSwgY291bnQpOworCS8qCisJICogQW55IEFMVUEgbG9naWNhbCB1bml0IGFsaWFzIGJlc2lkZXMgIk5VTEwiIG1lYW5zIHdlIHdpbGwgYmUKKwkgKiBtYWtpbmcgYSBuZXcgZ3JvdXAgYXNzb2NpYXRpb24uCisJICovCisJaWYgKHN0cmNtcChzdHJzdHJpcChidWYpLCAiTlVMTCIpKSB7CisJCS8qCisJCSAqIGNvcmVfYWx1YV9nZXRfbHVfZ3BfYnlfbmFtZSgpIHdpbGwgaW5jcmVtZW50IHJlZmVyZW5jZSB0bworCQkgKiBzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AuICBUaGlzIHJlZmVyZW5jZSBpcyByZWxlYXNlZCB3aXRoCisJCSAqIGNvcmVfYWx1YV9nZXRfbHVfZ3BfYnlfbmFtZSBiZWxvdygpLgorCQkgKi8KKwkJbHVfZ3BfbmV3ID0gY29yZV9hbHVhX2dldF9sdV9ncF9ieV9uYW1lKHN0cnN0cmlwKGJ1ZikpOworCQlpZiAoIShsdV9ncF9uZXcpKQorCQkJcmV0dXJuIC1FTk9ERVY7CisJfQorCWx1X2dwX21lbSA9IGRldi0+ZGV2X2FsdWFfbHVfZ3BfbWVtOworCWlmICghKGx1X2dwX21lbSkpIHsKKwkJaWYgKGx1X2dwX25ldykKKwkJCWNvcmVfYWx1YV9wdXRfbHVfZ3BfZnJvbV9uYW1lKGx1X2dwX25ldyk7CisJCXByaW50ayhLRVJOX0VSUiAiTlVMTCBzdHJ1Y3Qgc2VfZGV2aWNlLT5kZXZfYWx1YV9sdV9ncF9tZW0iCisJCQkJIiBwb2ludGVyXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJc3Bpbl9sb2NrKCZsdV9ncF9tZW0tPmx1X2dwX21lbV9sb2NrKTsKKwlsdV9ncCA9IGx1X2dwX21lbS0+bHVfZ3A7CisJaWYgKChsdV9ncCkpIHsKKwkJLyoKKwkJICogQ2xlYXJpbmcgYW4gZXhpc3RpbmcgbHVfZ3AgYXNzb2NpYXRpb24sIGFuZCByZXBsYWNpbmcKKwkJICogd2l0aCBOVUxMCisJCSAqLworCQlpZiAoIShsdV9ncF9uZXcpKSB7CisJCQlwcmludGsoS0VSTl9JTkZPICJUYXJnZXRfQ29yZV9Db25maWdGUzogUmVsZWFzaW5nICVzLyVzIgorCQkJCSIgZnJvbSBBTFVBIExVIEdyb3VwOiBjb3JlL2FsdWEvbHVfZ3BzLyVzLCBJRDoiCisJCQkJIiAlaHVcbiIsCisJCQkJY29uZmlnX2l0ZW1fbmFtZSgmaGJhLT5oYmFfZ3JvdXAuY2dfaXRlbSksCisJCQkJY29uZmlnX2l0ZW1fbmFtZSgmc3VfZGV2LT5zZV9kZXZfZ3JvdXAuY2dfaXRlbSksCisJCQkJY29uZmlnX2l0ZW1fbmFtZSgmbHVfZ3AtPmx1X2dwX2dyb3VwLmNnX2l0ZW0pLAorCQkJCWx1X2dwLT5sdV9ncF9pZCk7CisKKwkJCV9fY29yZV9hbHVhX2Ryb3BfbHVfZ3BfbWVtKGx1X2dwX21lbSwgbHVfZ3ApOworCQkJc3Bpbl91bmxvY2soJmx1X2dwX21lbS0+bHVfZ3BfbWVtX2xvY2spOworCisJCQlyZXR1cm4gY291bnQ7CisJCX0KKwkJLyoKKwkJICogUmVtb3ZpbmcgZXhpc3RpbmcgYXNzb2NpYXRpb24gb2YgbHVfZ3BfbWVtIHdpdGggbHVfZ3AKKwkJICovCisJCV9fY29yZV9hbHVhX2Ryb3BfbHVfZ3BfbWVtKGx1X2dwX21lbSwgbHVfZ3ApOworCQltb3ZlID0gMTsKKwl9CisJLyoKKwkgKiBBc3NvY2lhdGUgbHVfZ3BfbWVtIHdpdGggbHVfZ3BfbmV3LgorCSAqLworCV9fY29yZV9hbHVhX2F0dGFjaF9sdV9ncF9tZW0obHVfZ3BfbWVtLCBsdV9ncF9uZXcpOworCXNwaW5fdW5sb2NrKCZsdV9ncF9tZW0tPmx1X2dwX21lbV9sb2NrKTsKKworCXByaW50ayhLRVJOX0lORk8gIlRhcmdldF9Db3JlX0NvbmZpZ0ZTOiAlcyAlcy8lcyB0byBBTFVBIExVIEdyb3VwOiIKKwkJIiBjb3JlL2FsdWEvbHVfZ3BzLyVzLCBJRDogJWh1XG4iLAorCQkobW92ZSkgPyAiTW92aW5nIiA6ICJBZGRpbmciLAorCQljb25maWdfaXRlbV9uYW1lKCZoYmEtPmhiYV9ncm91cC5jZ19pdGVtKSwKKwkJY29uZmlnX2l0ZW1fbmFtZSgmc3VfZGV2LT5zZV9kZXZfZ3JvdXAuY2dfaXRlbSksCisJCWNvbmZpZ19pdGVtX25hbWUoJmx1X2dwX25ldy0+bHVfZ3BfZ3JvdXAuY2dfaXRlbSksCisJCWx1X2dwX25ldy0+bHVfZ3BfaWQpOworCisJY29yZV9hbHVhX3B1dF9sdV9ncF9mcm9tX25hbWUobHVfZ3BfbmV3KTsKKwlyZXR1cm4gY291bnQ7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2NvcmVfY29uZmlnZnNfYXR0cmlidXRlIHRhcmdldF9jb3JlX2F0dHJfZGV2X2FsdWFfbHVfZ3AgPSB7CisJLmF0dHIJPSB7IC5jYV9vd25lciA9IFRISVNfTU9EVUxFLAorCQkgICAgLmNhX25hbWUgPSAiYWx1YV9sdV9ncCIsCisJCSAgICAuY2FfbW9kZSA9IFNfSVJVR08gfCBTX0lXVVNSIH0sCisJLnNob3cJPSB0YXJnZXRfY29yZV9zaG93X2FsdWFfbHVfZ3AsCisJLnN0b3JlCT0gdGFyZ2V0X2NvcmVfc3RvcmVfYWx1YV9sdV9ncCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfYXR0cmlidXRlICpsaW9fY29yZV9kZXZfYXR0cnNbXSA9IHsKKwkmdGFyZ2V0X2NvcmVfYXR0cl9kZXZfaW5mby5hdHRyLAorCSZ0YXJnZXRfY29yZV9hdHRyX2Rldl9jb250cm9sLmF0dHIsCisJJnRhcmdldF9jb3JlX2F0dHJfZGV2X2FsaWFzLmF0dHIsCisJJnRhcmdldF9jb3JlX2F0dHJfZGV2X3VkZXZfcGF0aC5hdHRyLAorCSZ0YXJnZXRfY29yZV9hdHRyX2Rldl9lbmFibGUuYXR0ciwKKwkmdGFyZ2V0X2NvcmVfYXR0cl9kZXZfYWx1YV9sdV9ncC5hdHRyLAorCU5VTEwsCit9OworCitzdGF0aWMgdm9pZCB0YXJnZXRfY29yZV9kZXZfcmVsZWFzZShzdHJ1Y3QgY29uZmlnX2l0ZW0gKml0ZW0pCit7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiA9IGNvbnRhaW5lcl9vZih0b19jb25maWdfZ3JvdXAoaXRlbSksCisJCQkJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYsIHNlX2Rldl9ncm91cCk7CisJc3RydWN0IGNvbmZpZ19ncm91cCAqZGV2X2NnOworCisJaWYgKCEoc2VfZGV2KSkKKwkJcmV0dXJuOworCisJZGV2X2NnID0gJnNlX2Rldi0+c2VfZGV2X2dyb3VwOworCWtmcmVlKGRldl9jZy0+ZGVmYXVsdF9ncm91cHMpOworfQorCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9kZXZfc2hvdyhzdHJ1Y3QgY29uZmlnX2l0ZW0gKml0ZW0sCisJCQkJICAgICBzdHJ1Y3QgY29uZmlnZnNfYXR0cmlidXRlICphdHRyLAorCQkJCSAgICAgY2hhciAqcGFnZSkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc2VfZGV2ID0gY29udGFpbmVyX29mKAorCQkJdG9fY29uZmlnX2dyb3VwKGl0ZW0pLCBzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiwKKwkJCXNlX2Rldl9ncm91cCk7CisJc3RydWN0IHRhcmdldF9jb3JlX2NvbmZpZ2ZzX2F0dHJpYnV0ZSAqdGNfYXR0ciA9IGNvbnRhaW5lcl9vZigKKwkJCWF0dHIsIHN0cnVjdCB0YXJnZXRfY29yZV9jb25maWdmc19hdHRyaWJ1dGUsIGF0dHIpOworCisJaWYgKCEodGNfYXR0ci0+c2hvdykpCisJCXJldHVybiAtRUlOVkFMOworCisJcmV0dXJuIHRjX2F0dHItPnNob3coKHZvaWQgKilzZV9kZXYsIHBhZ2UpOworfQorCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9kZXZfc3RvcmUoc3RydWN0IGNvbmZpZ19pdGVtICppdGVtLAorCQkJCSAgICAgIHN0cnVjdCBjb25maWdmc19hdHRyaWJ1dGUgKmF0dHIsCisJCQkJICAgICAgY29uc3QgY2hhciAqcGFnZSwgc2l6ZV90IGNvdW50KQoreworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzZV9kZXYgPSBjb250YWluZXJfb2YoCisJCQl0b19jb25maWdfZ3JvdXAoaXRlbSksIHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2LAorCQkJc2VfZGV2X2dyb3VwKTsKKwlzdHJ1Y3QgdGFyZ2V0X2NvcmVfY29uZmlnZnNfYXR0cmlidXRlICp0Y19hdHRyID0gY29udGFpbmVyX29mKAorCQkJYXR0ciwgc3RydWN0IHRhcmdldF9jb3JlX2NvbmZpZ2ZzX2F0dHJpYnV0ZSwgYXR0cik7CisKKwlpZiAoISh0Y19hdHRyLT5zdG9yZSkpCisJCXJldHVybiAtRUlOVkFMOworCisJcmV0dXJuIHRjX2F0dHItPnN0b3JlKCh2b2lkICopc2VfZGV2LCBwYWdlLCBjb3VudCk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfaXRlbV9vcGVyYXRpb25zIHRhcmdldF9jb3JlX2Rldl9pdGVtX29wcyA9IHsKKwkucmVsZWFzZQkJPSB0YXJnZXRfY29yZV9kZXZfcmVsZWFzZSwKKwkuc2hvd19hdHRyaWJ1dGUJCT0gdGFyZ2V0X2NvcmVfZGV2X3Nob3csCisJLnN0b3JlX2F0dHJpYnV0ZQk9IHRhcmdldF9jb3JlX2Rldl9zdG9yZSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9kZXZfY2l0ID0geworCS5jdF9pdGVtX29wcwkJPSAmdGFyZ2V0X2NvcmVfZGV2X2l0ZW1fb3BzLAorCS5jdF9hdHRycwkJPSBsaW9fY29yZV9kZXZfYXR0cnMsCisJLmN0X293bmVyCQk9IFRISVNfTU9EVUxFLAorfTsKKworLyogRW5kIGZ1bmN0aW9ucyBmb3Igc3RydWN0IGNvbmZpZ19pdGVtX3R5cGUgdGFyZ2V0X2NvcmVfZGV2X2NpdCAqLworCisvKiBTdGFydCBmdW5jdGlvbnMgZm9yIHN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRhcmdldF9jb3JlX2FsdWFfbHVfZ3BfY2l0ICovCisKK0NPTkZJR0ZTX0VBVFRSX1NUUlVDVCh0YXJnZXRfY29yZV9hbHVhX2x1X2dwLCB0MTBfYWx1YV9sdV9ncCk7CisjZGVmaW5lIFNFX0RFVl9BTFVBX0xVX0FUVFIoX25hbWUsIF9tb2RlKQkJCQlcCitzdGF0aWMgc3RydWN0IHRhcmdldF9jb3JlX2FsdWFfbHVfZ3BfYXR0cmlidXRlCQkJCVwKKwkJCXRhcmdldF9jb3JlX2FsdWFfbHVfZ3BfIyNfbmFtZSA9CQlcCisJX19DT05GSUdGU19FQVRUUihfbmFtZSwgX21vZGUsCQkJCQlcCisJdGFyZ2V0X2NvcmVfYWx1YV9sdV9ncF9zaG93X2F0dHJfIyNfbmFtZSwJCQlcCisJdGFyZ2V0X2NvcmVfYWx1YV9sdV9ncF9zdG9yZV9hdHRyXyMjX25hbWUpOworCisjZGVmaW5lIFNFX0RFVl9BTFVBX0xVX0FUVFJfUk8oX25hbWUpCQkJCQlcCitzdGF0aWMgc3RydWN0IHRhcmdldF9jb3JlX2FsdWFfbHVfZ3BfYXR0cmlidXRlCQkJCVwKKwkJCXRhcmdldF9jb3JlX2FsdWFfbHVfZ3BfIyNfbmFtZSA9CQlcCisJX19DT05GSUdGU19FQVRUUl9STyhfbmFtZSwJCQkJCVwKKwl0YXJnZXRfY29yZV9hbHVhX2x1X2dwX3Nob3dfYXR0cl8jI19uYW1lKTsKKworLyoKKyAqIGx1X2dwX2lkCisgKi8KK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX2FsdWFfbHVfZ3Bfc2hvd19hdHRyX2x1X2dwX2lkKAorCXN0cnVjdCB0MTBfYWx1YV9sdV9ncCAqbHVfZ3AsCisJY2hhciAqcGFnZSkKK3sKKwlpZiAoIShsdV9ncC0+bHVfZ3BfdmFsaWRfaWQpKQorCQlyZXR1cm4gMDsKKworCXJldHVybiBzcHJpbnRmKHBhZ2UsICIlaHVcbiIsIGx1X2dwLT5sdV9ncF9pZCk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX2FsdWFfbHVfZ3Bfc3RvcmVfYXR0cl9sdV9ncF9pZCgKKwlzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3AgKmx1X2dwLAorCWNvbnN0IGNoYXIgKnBhZ2UsCisJc2l6ZV90IGNvdW50KQoreworCXN0cnVjdCBjb25maWdfZ3JvdXAgKmFsdWFfbHVfZ3BfY2cgPSAmbHVfZ3AtPmx1X2dwX2dyb3VwOworCXVuc2lnbmVkIGxvbmcgbHVfZ3BfaWQ7CisJaW50IHJldDsKKworCXJldCA9IHN0cmljdF9zdHJ0b3VsKHBhZ2UsIDAsICZsdV9ncF9pZCk7CisJaWYgKHJldCA8IDApIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJzdHJpY3Rfc3RydG91bCgpIHJldHVybmVkICVkIGZvciIKKwkJCSIgbHVfZ3BfaWRcbiIsIHJldCk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlpZiAobHVfZ3BfaWQgPiAweDAwMDBmZmZmKSB7CisJCXByaW50ayhLRVJOX0VSUiAiQUxVQSBsdV9ncF9pZDogJWx1IGV4Y2VlZHMgbWF4aW11bToiCisJCQkiIDB4MDAwMGZmZmZcbiIsIGx1X2dwX2lkKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJcmV0ID0gY29yZV9hbHVhX3NldF9sdV9ncF9pZChsdV9ncCwgKHUxNilsdV9ncF9pZCk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiAtRUlOVkFMOworCisJcHJpbnRrKEtFUk5fSU5GTyAiVGFyZ2V0X0NvcmVfQ29uZmlnRlM6IFNldCBBTFVBIExvZ2ljYWwgVW5pdCIKKwkJIiBHcm91cDogY29yZS9hbHVhL2x1X2dwcy8lcyB0byBJRDogJWh1XG4iLAorCQljb25maWdfaXRlbV9uYW1lKCZhbHVhX2x1X2dwX2NnLT5jZ19pdGVtKSwKKwkJbHVfZ3AtPmx1X2dwX2lkKTsKKworCXJldHVybiBjb3VudDsKK30KKworU0VfREVWX0FMVUFfTFVfQVRUUihsdV9ncF9pZCwgU19JUlVHTyB8IFNfSVdVU1IpOworCisvKgorICogbWVtYmVycworICovCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9hbHVhX2x1X2dwX3Nob3dfYXR0cl9tZW1iZXJzKAorCXN0cnVjdCB0MTBfYWx1YV9sdV9ncCAqbHVfZ3AsCisJY2hhciAqcGFnZSkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXY7CisJc3RydWN0IHNlX2hiYSAqaGJhOworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXY7CisJc3RydWN0IHQxMF9hbHVhX2x1X2dwX21lbWJlciAqbHVfZ3BfbWVtOworCXNzaXplX3QgbGVuID0gMCwgY3VyX2xlbjsKKwl1bnNpZ25lZCBjaGFyIGJ1ZltMVV9HUk9VUF9OQU1FX0JVRl07CisKKwltZW1zZXQoYnVmLCAwLCBMVV9HUk9VUF9OQU1FX0JVRik7CisKKwlzcGluX2xvY2soJmx1X2dwLT5sdV9ncF9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGx1X2dwX21lbSwgJmx1X2dwLT5sdV9ncF9tZW1fbGlzdCwgbHVfZ3BfbWVtX2xpc3QpIHsKKwkJZGV2ID0gbHVfZ3BfbWVtLT5sdV9ncF9tZW1fZGV2OworCQlzdV9kZXYgPSBkZXYtPnNlX3N1Yl9kZXY7CisJCWhiYSA9IHN1X2Rldi0+c2VfZGV2X2hiYTsKKworCQljdXJfbGVuID0gc25wcmludGYoYnVmLCBMVV9HUk9VUF9OQU1FX0JVRiwgIiVzLyVzXG4iLAorCQkJY29uZmlnX2l0ZW1fbmFtZSgmaGJhLT5oYmFfZ3JvdXAuY2dfaXRlbSksCisJCQljb25maWdfaXRlbV9uYW1lKCZzdV9kZXYtPnNlX2Rldl9ncm91cC5jZ19pdGVtKSk7CisJCWN1cl9sZW4rKzsgLyogRXh0cmEgYnl0ZSBmb3IgTlVMTCB0ZXJtaW5hdG9yICovCisKKwkJaWYgKChjdXJfbGVuICsgbGVuKSA+IFBBR0VfU0laRSkgeworCQkJcHJpbnRrKEtFUk5fV0FSTklORyAiUmFuIG91dCBvZiBsdV9ncF9zaG93X2F0dHIiCisJCQkJIl9tZW1iZXJzIGJ1ZmZlclxuIik7CisJCQlicmVhazsKKwkJfQorCQltZW1jcHkocGFnZStsZW4sIGJ1ZiwgY3VyX2xlbik7CisJCWxlbiArPSBjdXJfbGVuOworCX0KKwlzcGluX3VubG9jaygmbHVfZ3AtPmx1X2dwX2xvY2spOworCisJcmV0dXJuIGxlbjsKK30KKworU0VfREVWX0FMVUFfTFVfQVRUUl9STyhtZW1iZXJzKTsKKworQ09ORklHRlNfRUFUVFJfT1BTKHRhcmdldF9jb3JlX2FsdWFfbHVfZ3AsIHQxMF9hbHVhX2x1X2dwLCBsdV9ncF9ncm91cCk7CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfYXR0cmlidXRlICp0YXJnZXRfY29yZV9hbHVhX2x1X2dwX2F0dHJzW10gPSB7CisJJnRhcmdldF9jb3JlX2FsdWFfbHVfZ3BfbHVfZ3BfaWQuYXR0ciwKKwkmdGFyZ2V0X2NvcmVfYWx1YV9sdV9ncF9tZW1iZXJzLmF0dHIsCisJTlVMTCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfaXRlbV9vcGVyYXRpb25zIHRhcmdldF9jb3JlX2FsdWFfbHVfZ3Bfb3BzID0geworCS5zaG93X2F0dHJpYnV0ZQkJPSB0YXJnZXRfY29yZV9hbHVhX2x1X2dwX2F0dHJfc2hvdywKKwkuc3RvcmVfYXR0cmlidXRlCT0gdGFyZ2V0X2NvcmVfYWx1YV9sdV9ncF9hdHRyX3N0b3JlLAorfTsKKworc3RhdGljIHN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRhcmdldF9jb3JlX2FsdWFfbHVfZ3BfY2l0ID0geworCS5jdF9pdGVtX29wcwkJPSAmdGFyZ2V0X2NvcmVfYWx1YV9sdV9ncF9vcHMsCisJLmN0X2F0dHJzCQk9IHRhcmdldF9jb3JlX2FsdWFfbHVfZ3BfYXR0cnMsCisJLmN0X293bmVyCQk9IFRISVNfTU9EVUxFLAorfTsKKworLyogRW5kIGZ1bmN0aW9ucyBmb3Igc3RydWN0IGNvbmZpZ19pdGVtX3R5cGUgdGFyZ2V0X2NvcmVfYWx1YV9sdV9ncF9jaXQgKi8KKworLyogU3RhcnQgZnVuY3Rpb25zIGZvciBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9hbHVhX2x1X2dwc19jaXQgKi8KKworc3RhdGljIHN0cnVjdCBjb25maWdfZ3JvdXAgKnRhcmdldF9jb3JlX2FsdWFfY3JlYXRlX2x1X2dwKAorCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLAorCWNvbnN0IGNoYXIgKm5hbWUpCit7CisJc3RydWN0IHQxMF9hbHVhX2x1X2dwICpsdV9ncDsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwICphbHVhX2x1X2dwX2NnID0gTlVMTDsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW0gKmFsdWFfbHVfZ3BfY2kgPSBOVUxMOworCisJbHVfZ3AgPSBjb3JlX2FsdWFfYWxsb2NhdGVfbHVfZ3AobmFtZSwgMCk7CisJaWYgKElTX0VSUihsdV9ncCkpCisJCXJldHVybiBOVUxMOworCisJYWx1YV9sdV9ncF9jZyA9ICZsdV9ncC0+bHVfZ3BfZ3JvdXA7CisJYWx1YV9sdV9ncF9jaSA9ICZhbHVhX2x1X2dwX2NnLT5jZ19pdGVtOworCisJY29uZmlnX2dyb3VwX2luaXRfdHlwZV9uYW1lKGFsdWFfbHVfZ3BfY2csIG5hbWUsCisJCQkmdGFyZ2V0X2NvcmVfYWx1YV9sdV9ncF9jaXQpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiVGFyZ2V0X0NvcmVfQ29uZmlnRlM6IEFsbG9jYXRlZCBBTFVBIExvZ2ljYWwgVW5pdCIKKwkJIiBHcm91cDogY29yZS9hbHVhL2x1X2dwcy8lc1xuIiwKKwkJY29uZmlnX2l0ZW1fbmFtZShhbHVhX2x1X2dwX2NpKSk7CisKKwlyZXR1cm4gYWx1YV9sdV9ncF9jZzsKKworfQorCitzdGF0aWMgdm9pZCB0YXJnZXRfY29yZV9hbHVhX2Ryb3BfbHVfZ3AoCisJc3RydWN0IGNvbmZpZ19ncm91cCAqZ3JvdXAsCisJc3RydWN0IGNvbmZpZ19pdGVtICppdGVtKQoreworCXN0cnVjdCB0MTBfYWx1YV9sdV9ncCAqbHVfZ3AgPSBjb250YWluZXJfb2YodG9fY29uZmlnX2dyb3VwKGl0ZW0pLAorCQkJc3RydWN0IHQxMF9hbHVhX2x1X2dwLCBsdV9ncF9ncm91cCk7CisKKwlwcmludGsoS0VSTl9JTkZPICJUYXJnZXRfQ29yZV9Db25maWdGUzogUmVsZWFzaW5nIEFMVUEgTG9naWNhbCBVbml0IgorCQkiIEdyb3VwOiBjb3JlL2FsdWEvbHVfZ3BzLyVzLCBJRDogJWh1XG4iLAorCQljb25maWdfaXRlbV9uYW1lKGl0ZW0pLCBsdV9ncC0+bHVfZ3BfaWQpOworCisJY29uZmlnX2l0ZW1fcHV0KGl0ZW0pOworCWNvcmVfYWx1YV9mcmVlX2x1X2dwKGx1X2dwKTsKK30KKworc3RhdGljIHN0cnVjdCBjb25maWdmc19ncm91cF9vcGVyYXRpb25zIHRhcmdldF9jb3JlX2FsdWFfbHVfZ3BzX2dyb3VwX29wcyA9IHsKKwkubWFrZV9ncm91cAkJPSAmdGFyZ2V0X2NvcmVfYWx1YV9jcmVhdGVfbHVfZ3AsCisJLmRyb3BfaXRlbQkJPSAmdGFyZ2V0X2NvcmVfYWx1YV9kcm9wX2x1X2dwLAorfTsKKworc3RhdGljIHN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRhcmdldF9jb3JlX2FsdWFfbHVfZ3BzX2NpdCA9IHsKKwkuY3RfaXRlbV9vcHMJCT0gTlVMTCwKKwkuY3RfZ3JvdXBfb3BzCQk9ICZ0YXJnZXRfY29yZV9hbHVhX2x1X2dwc19ncm91cF9vcHMsCisJLmN0X293bmVyCQk9IFRISVNfTU9EVUxFLAorfTsKKworLyogRW5kIGZ1bmN0aW9ucyBmb3Igc3RydWN0IGNvbmZpZ19pdGVtX3R5cGUgdGFyZ2V0X2NvcmVfYWx1YV9sdV9ncHNfY2l0ICovCisKKy8qIFN0YXJ0IGZ1bmN0aW9ucyBmb3Igc3RydWN0IGNvbmZpZ19pdGVtX3R5cGUgdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9jaXQgKi8KKworQ09ORklHRlNfRUFUVFJfU1RSVUNUKHRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3AsIHQxMF9hbHVhX3RnX3B0X2dwKTsKKyNkZWZpbmUgU0VfREVWX0FMVUFfVEdfUFRfQVRUUihfbmFtZSwgX21vZGUpCQkJCVwKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9hdHRyaWJ1dGUJCQlcCisJCQl0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwXyMjX25hbWUgPQkJXAorCV9fQ09ORklHRlNfRUFUVFIoX25hbWUsIF9tb2RlLAkJCQkJXAorCXRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3Bfc2hvd19hdHRyXyMjX25hbWUsCQkJXAorCXRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3Bfc3RvcmVfYXR0cl8jI19uYW1lKTsKKworI2RlZmluZSBTRV9ERVZfQUxVQV9UR19QVF9BVFRSX1JPKF9uYW1lKQkJCQlcCitzdGF0aWMgc3RydWN0IHRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3BfYXR0cmlidXRlCQkJXAorCQkJdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF8jI19uYW1lID0JCVwKKwlfX0NPTkZJR0ZTX0VBVFRSX1JPKF9uYW1lLAkJCQkJXAorCXRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3Bfc2hvd19hdHRyXyMjX25hbWUpOworCisvKgorICogYWx1YV9hY2Nlc3Nfc3RhdGUKKyAqLworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9zaG93X2F0dHJfYWx1YV9hY2Nlc3Nfc3RhdGUoCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncCwKKwljaGFyICpwYWdlKQoreworCXJldHVybiBzcHJpbnRmKHBhZ2UsICIlZFxuIiwKKwkJYXRvbWljX3JlYWQoJnRnX3B0X2dwLT50Z19wdF9ncF9hbHVhX2FjY2Vzc19zdGF0ZSkpOworfQorCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwX3N0b3JlX2F0dHJfYWx1YV9hY2Nlc3Nfc3RhdGUoCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncCwKKwljb25zdCBjaGFyICpwYWdlLAorCXNpemVfdCBjb3VudCkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2ID0gdGdfcHRfZ3AtPnRnX3B0X2dwX3N1X2RldjsKKwl1bnNpZ25lZCBsb25nIHRtcDsKKwlpbnQgbmV3X3N0YXRlLCByZXQ7CisKKwlpZiAoISh0Z19wdF9ncC0+dGdfcHRfZ3BfdmFsaWRfaWQpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGRvIGltcGxpY3QgQUxVQSBvbiBub24gdmFsaWQiCisJCQkiIHRnX3B0X2dwIElEOiAlaHVcbiIsIHRnX3B0X2dwLT50Z19wdF9ncF92YWxpZF9pZCk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXJldCA9IHN0cmljdF9zdHJ0b3VsKHBhZ2UsIDAsICZ0bXApOworCWlmIChyZXQgPCAwKSB7CisJCXByaW50aygiVW5hYmxlIHRvIGV4dHJhY3QgbmV3IEFMVUEgYWNjZXNzIHN0YXRlIGZyb20iCisJCQkJIiAlc1xuIiwgcGFnZSk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwluZXdfc3RhdGUgPSAoaW50KXRtcDsKKworCWlmICghKHRnX3B0X2dwLT50Z19wdF9ncF9hbHVhX2FjY2Vzc190eXBlICYgVFBHU19JTVBMSUNUX0FMVUEpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIHByb2Nlc3MgaW1wbGljdCBjb25maWdmcyBBTFVBIgorCQkJIiB0cmFuc2l0aW9uIHdoaWxlIFRQR1NfSU1QTElDVF9BTFVBIGlzIGRpYWJsZWRcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlyZXQgPSBjb3JlX2FsdWFfZG9fcG9ydF90cmFuc2l0aW9uKHRnX3B0X2dwLCBzdV9kZXYtPnNlX2Rldl9wdHIsCisJCQkJCU5VTEwsIE5VTEwsIG5ld19zdGF0ZSwgMCk7CisJcmV0dXJuICghcmV0KSA/IGNvdW50IDogLUVJTlZBTDsKK30KKworU0VfREVWX0FMVUFfVEdfUFRfQVRUUihhbHVhX2FjY2Vzc19zdGF0ZSwgU19JUlVHTyB8IFNfSVdVU1IpOworCisvKgorICogYWx1YV9hY2Nlc3Nfc3RhdHVzCisgKi8KK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3Bfc2hvd19hdHRyX2FsdWFfYWNjZXNzX3N0YXR1cygKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwLAorCWNoYXIgKnBhZ2UpCit7CisJcmV0dXJuIHNwcmludGYocGFnZSwgIiVzXG4iLAorCQljb3JlX2FsdWFfZHVtcF9zdGF0dXModGdfcHRfZ3AtPnRnX3B0X2dwX2FsdWFfYWNjZXNzX3N0YXR1cykpOworfQorCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwX3N0b3JlX2F0dHJfYWx1YV9hY2Nlc3Nfc3RhdHVzKAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3AsCisJY29uc3QgY2hhciAqcGFnZSwKKwlzaXplX3QgY291bnQpCit7CisJdW5zaWduZWQgbG9uZyB0bXA7CisJaW50IG5ld19zdGF0dXMsIHJldDsKKworCWlmICghKHRnX3B0X2dwLT50Z19wdF9ncF92YWxpZF9pZCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gZG8gc2V0IEFMVUEgYWNjZXNzIHN0YXR1cyBvbiBub24iCisJCQkiIHZhbGlkIHRnX3B0X2dwIElEOiAlaHVcbiIsCisJCQl0Z19wdF9ncC0+dGdfcHRfZ3BfdmFsaWRfaWQpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlyZXQgPSBzdHJpY3Rfc3RydG91bChwYWdlLCAwLCAmdG1wKTsKKwlpZiAocmV0IDwgMCkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBleHRyYWN0IG5ldyBBTFVBIGFjY2VzcyBzdGF0dXMiCisJCQkJIiBmcm9tICVzXG4iLCBwYWdlKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCW5ld19zdGF0dXMgPSAoaW50KXRtcDsKKworCWlmICgobmV3X3N0YXR1cyAhPSBBTFVBX1NUQVRVU19OT05FKSAmJgorCSAgICAobmV3X3N0YXR1cyAhPSBBTFVBX1NUQVRVU19BTFRFUkVEX0JZX0VYUExJQ1RfU1RQRykgJiYKKwkgICAgKG5ld19zdGF0dXMgIT0gQUxVQV9TVEFUVVNfQUxURVJFRF9CWV9JTVBMSUNUX0FMVUEpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiSWxsZWdhbCBBTFVBIGFjY2VzcyBzdGF0dXM6IDB4JTAyeFxuIiwKKwkJCQluZXdfc3RhdHVzKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJdGdfcHRfZ3AtPnRnX3B0X2dwX2FsdWFfYWNjZXNzX3N0YXR1cyA9IG5ld19zdGF0dXM7CisJcmV0dXJuIGNvdW50OworfQorCitTRV9ERVZfQUxVQV9UR19QVF9BVFRSKGFsdWFfYWNjZXNzX3N0YXR1cywgU19JUlVHTyB8IFNfSVdVU1IpOworCisvKgorICogYWx1YV9hY2Nlc3NfdHlwZQorICovCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwX3Nob3dfYXR0cl9hbHVhX2FjY2Vzc190eXBlKAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3AsCisJY2hhciAqcGFnZSkKK3sKKwlyZXR1cm4gY29yZV9hbHVhX3Nob3dfYWNjZXNzX3R5cGUodGdfcHRfZ3AsIHBhZ2UpOworfQorCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwX3N0b3JlX2F0dHJfYWx1YV9hY2Nlc3NfdHlwZSgKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwLAorCWNvbnN0IGNoYXIgKnBhZ2UsCisJc2l6ZV90IGNvdW50KQoreworCXJldHVybiBjb3JlX2FsdWFfc3RvcmVfYWNjZXNzX3R5cGUodGdfcHRfZ3AsIHBhZ2UsIGNvdW50KTsKK30KKworU0VfREVWX0FMVUFfVEdfUFRfQVRUUihhbHVhX2FjY2Vzc190eXBlLCBTX0lSVUdPIHwgU19JV1VTUik7CisKKy8qCisgKiBhbHVhX3dyaXRlX21ldGFkYXRhCisgKi8KK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3Bfc2hvd19hdHRyX2FsdWFfd3JpdGVfbWV0YWRhdGEoCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncCwKKwljaGFyICpwYWdlKQoreworCXJldHVybiBzcHJpbnRmKHBhZ2UsICIlZFxuIiwgdGdfcHRfZ3AtPnRnX3B0X2dwX3dyaXRlX21ldGFkYXRhKTsKK30KKworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9zdG9yZV9hdHRyX2FsdWFfd3JpdGVfbWV0YWRhdGEoCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncCwKKwljb25zdCBjaGFyICpwYWdlLAorCXNpemVfdCBjb3VudCkKK3sKKwl1bnNpZ25lZCBsb25nIHRtcDsKKwlpbnQgcmV0OworCisJcmV0ID0gc3RyaWN0X3N0cnRvdWwocGFnZSwgMCwgJnRtcCk7CisJaWYgKHJldCA8IDApIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gZXh0cmFjdCBhbHVhX3dyaXRlX21ldGFkYXRhXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJaWYgKCh0bXAgIT0gMCkgJiYgKHRtcCAhPSAxKSkgeworCQlwcmludGsoS0VSTl9FUlIgIklsbGVnYWwgdmFsdWUgZm9yIGFsdWFfd3JpdGVfbWV0YWRhdGE6IgorCQkJIiAlbHVcbiIsIHRtcCk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwl0Z19wdF9ncC0+dGdfcHRfZ3Bfd3JpdGVfbWV0YWRhdGEgPSAoaW50KXRtcDsKKworCXJldHVybiBjb3VudDsKK30KKworU0VfREVWX0FMVUFfVEdfUFRfQVRUUihhbHVhX3dyaXRlX21ldGFkYXRhLCBTX0lSVUdPIHwgU19JV1VTUik7CisKKworCisvKgorICogbm9ub3BfZGVsYXlfbXNlY3MKKyAqLworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9zaG93X2F0dHJfbm9ub3BfZGVsYXlfbXNlY3MoCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncCwKKwljaGFyICpwYWdlKQoreworCXJldHVybiBjb3JlX2FsdWFfc2hvd19ub25vcF9kZWxheV9tc2Vjcyh0Z19wdF9ncCwgcGFnZSk7CisKK30KKworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9zdG9yZV9hdHRyX25vbm9wX2RlbGF5X21zZWNzKAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3AsCisJY29uc3QgY2hhciAqcGFnZSwKKwlzaXplX3QgY291bnQpCit7CisJcmV0dXJuIGNvcmVfYWx1YV9zdG9yZV9ub25vcF9kZWxheV9tc2Vjcyh0Z19wdF9ncCwgcGFnZSwgY291bnQpOworfQorCitTRV9ERVZfQUxVQV9UR19QVF9BVFRSKG5vbm9wX2RlbGF5X21zZWNzLCBTX0lSVUdPIHwgU19JV1VTUik7CisKKy8qCisgKiB0cmFuc19kZWxheV9tc2VjcworICovCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwX3Nob3dfYXR0cl90cmFuc19kZWxheV9tc2VjcygKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwLAorCWNoYXIgKnBhZ2UpCit7CisJcmV0dXJuIGNvcmVfYWx1YV9zaG93X3RyYW5zX2RlbGF5X21zZWNzKHRnX3B0X2dwLCBwYWdlKTsKK30KKworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9zdG9yZV9hdHRyX3RyYW5zX2RlbGF5X21zZWNzKAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3AsCisJY29uc3QgY2hhciAqcGFnZSwKKwlzaXplX3QgY291bnQpCit7CisJcmV0dXJuIGNvcmVfYWx1YV9zdG9yZV90cmFuc19kZWxheV9tc2Vjcyh0Z19wdF9ncCwgcGFnZSwgY291bnQpOworfQorCitTRV9ERVZfQUxVQV9UR19QVF9BVFRSKHRyYW5zX2RlbGF5X21zZWNzLCBTX0lSVUdPIHwgU19JV1VTUik7CisKKy8qCisgKiBwcmVmZXJyZWQKKyAqLworCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwX3Nob3dfYXR0cl9wcmVmZXJyZWQoCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncCwKKwljaGFyICpwYWdlKQoreworCXJldHVybiBjb3JlX2FsdWFfc2hvd19wcmVmZXJyZWRfYml0KHRnX3B0X2dwLCBwYWdlKTsKK30KKworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9zdG9yZV9hdHRyX3ByZWZlcnJlZCgKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwLAorCWNvbnN0IGNoYXIgKnBhZ2UsCisJc2l6ZV90IGNvdW50KQoreworCXJldHVybiBjb3JlX2FsdWFfc3RvcmVfcHJlZmVycmVkX2JpdCh0Z19wdF9ncCwgcGFnZSwgY291bnQpOworfQorCitTRV9ERVZfQUxVQV9UR19QVF9BVFRSKHByZWZlcnJlZCwgU19JUlVHTyB8IFNfSVdVU1IpOworCisvKgorICogdGdfcHRfZ3BfaWQKKyAqLworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9zaG93X2F0dHJfdGdfcHRfZ3BfaWQoCisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncCwKKwljaGFyICpwYWdlKQoreworCWlmICghKHRnX3B0X2dwLT50Z19wdF9ncF92YWxpZF9pZCkpCisJCXJldHVybiAwOworCisJcmV0dXJuIHNwcmludGYocGFnZSwgIiVodVxuIiwgdGdfcHRfZ3AtPnRnX3B0X2dwX2lkKTsKK30KKworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9zdG9yZV9hdHRyX3RnX3B0X2dwX2lkKAorCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqdGdfcHRfZ3AsCisJY29uc3QgY2hhciAqcGFnZSwKKwlzaXplX3QgY291bnQpCit7CisJc3RydWN0IGNvbmZpZ19ncm91cCAqYWx1YV90Z19wdF9ncF9jZyA9ICZ0Z19wdF9ncC0+dGdfcHRfZ3BfZ3JvdXA7CisJdW5zaWduZWQgbG9uZyB0Z19wdF9ncF9pZDsKKwlpbnQgcmV0OworCisJcmV0ID0gc3RyaWN0X3N0cnRvdWwocGFnZSwgMCwgJnRnX3B0X2dwX2lkKTsKKwlpZiAocmV0IDwgMCkgeworCQlwcmludGsoS0VSTl9FUlIgInN0cmljdF9zdHJ0b3VsKCkgcmV0dXJuZWQgJWQgZm9yIgorCQkJIiB0Z19wdF9ncF9pZFxuIiwgcmV0KTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmICh0Z19wdF9ncF9pZCA+IDB4MDAwMGZmZmYpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJBTFVBIHRnX3B0X2dwX2lkOiAlbHUgZXhjZWVkcyBtYXhpbXVtOiIKKwkJCSIgMHgwMDAwZmZmZlxuIiwgdGdfcHRfZ3BfaWQpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlyZXQgPSBjb3JlX2FsdWFfc2V0X3RnX3B0X2dwX2lkKHRnX3B0X2dwLCAodTE2KXRnX3B0X2dwX2lkKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlwcmludGsoS0VSTl9JTkZPICJUYXJnZXRfQ29yZV9Db25maWdGUzogU2V0IEFMVUEgVGFyZ2V0IFBvcnQgR3JvdXA6ICIKKwkJImNvcmUvYWx1YS90Z19wdF9ncHMvJXMgdG8gSUQ6ICVodVxuIiwKKwkJY29uZmlnX2l0ZW1fbmFtZSgmYWx1YV90Z19wdF9ncF9jZy0+Y2dfaXRlbSksCisJCXRnX3B0X2dwLT50Z19wdF9ncF9pZCk7CisKKwlyZXR1cm4gY291bnQ7Cit9CisKK1NFX0RFVl9BTFVBX1RHX1BUX0FUVFIodGdfcHRfZ3BfaWQsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworLyoKKyAqIG1lbWJlcnMKKyAqLworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9zaG93X2F0dHJfbWVtYmVycygKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwLAorCWNoYXIgKnBhZ2UpCit7CisJc3RydWN0IHNlX3BvcnQgKnBvcnQ7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnOworCXN0cnVjdCBzZV9sdW4gKmx1bjsKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3BfbWVtYmVyICp0Z19wdF9ncF9tZW07CisJc3NpemVfdCBsZW4gPSAwLCBjdXJfbGVuOworCXVuc2lnbmVkIGNoYXIgYnVmW1RHX1BUX0dST1VQX05BTUVfQlVGXTsKKworCW1lbXNldChidWYsIDAsIFRHX1BUX0dST1VQX05BTUVfQlVGKTsKKworCXNwaW5fbG9jaygmdGdfcHRfZ3AtPnRnX3B0X2dwX2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnkodGdfcHRfZ3BfbWVtLCAmdGdfcHRfZ3AtPnRnX3B0X2dwX21lbV9saXN0LAorCQkJdGdfcHRfZ3BfbWVtX2xpc3QpIHsKKwkJcG9ydCA9IHRnX3B0X2dwX21lbS0+dGdfcHQ7CisJCXRwZyA9IHBvcnQtPnNlcF90cGc7CisJCWx1biA9IHBvcnQtPnNlcF9sdW47CisKKwkJY3VyX2xlbiA9IHNucHJpbnRmKGJ1ZiwgVEdfUFRfR1JPVVBfTkFNRV9CVUYsICIlcy8lcy90cGd0XyVodSIKKwkJCSIvJXNcbiIsIFRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCQlUUEdfVEZPKHRwZyktPnRwZ19nZXRfd3duKHRwZyksCisJCQlUUEdfVEZPKHRwZyktPnRwZ19nZXRfdGFnKHRwZyksCisJCQljb25maWdfaXRlbV9uYW1lKCZsdW4tPmx1bl9ncm91cC5jZ19pdGVtKSk7CisJCWN1cl9sZW4rKzsgLyogRXh0cmEgYnl0ZSBmb3IgTlVMTCB0ZXJtaW5hdG9yICovCisKKwkJaWYgKChjdXJfbGVuICsgbGVuKSA+IFBBR0VfU0laRSkgeworCQkJcHJpbnRrKEtFUk5fV0FSTklORyAiUmFuIG91dCBvZiBsdV9ncF9zaG93X2F0dHIiCisJCQkJIl9tZW1iZXJzIGJ1ZmZlclxuIik7CisJCQlicmVhazsKKwkJfQorCQltZW1jcHkocGFnZStsZW4sIGJ1ZiwgY3VyX2xlbik7CisJCWxlbiArPSBjdXJfbGVuOworCX0KKwlzcGluX3VubG9jaygmdGdfcHRfZ3AtPnRnX3B0X2dwX2xvY2spOworCisJcmV0dXJuIGxlbjsKK30KKworU0VfREVWX0FMVUFfVEdfUFRfQVRUUl9STyhtZW1iZXJzKTsKKworQ09ORklHRlNfRUFUVFJfT1BTKHRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3AsIHQxMF9hbHVhX3RnX3B0X2dwLAorCQkJdGdfcHRfZ3BfZ3JvdXApOworCitzdGF0aWMgc3RydWN0IGNvbmZpZ2ZzX2F0dHJpYnV0ZSAqdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9hdHRyc1tdID0geworCSZ0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwX2FsdWFfYWNjZXNzX3N0YXRlLmF0dHIsCisJJnRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3BfYWx1YV9hY2Nlc3Nfc3RhdHVzLmF0dHIsCisJJnRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3BfYWx1YV9hY2Nlc3NfdHlwZS5hdHRyLAorCSZ0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwX2FsdWFfd3JpdGVfbWV0YWRhdGEuYXR0ciwKKwkmdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9ub25vcF9kZWxheV9tc2Vjcy5hdHRyLAorCSZ0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwX3RyYW5zX2RlbGF5X21zZWNzLmF0dHIsCisJJnRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3BfcHJlZmVycmVkLmF0dHIsCisJJnRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3BfdGdfcHRfZ3BfaWQuYXR0ciwKKwkmdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9tZW1iZXJzLmF0dHIsCisJTlVMTCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfaXRlbV9vcGVyYXRpb25zIHRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3Bfb3BzID0geworCS5zaG93X2F0dHJpYnV0ZQkJPSB0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwX2F0dHJfc2hvdywKKwkuc3RvcmVfYXR0cmlidXRlCT0gdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9hdHRyX3N0b3JlLAorfTsKKworc3RhdGljIHN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3BfY2l0ID0geworCS5jdF9pdGVtX29wcwkJPSAmdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9vcHMsCisJLmN0X2F0dHJzCQk9IHRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3BfYXR0cnMsCisJLmN0X293bmVyCQk9IFRISVNfTU9EVUxFLAorfTsKKworLyogRW5kIGZ1bmN0aW9ucyBmb3Igc3RydWN0IGNvbmZpZ19pdGVtX3R5cGUgdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9jaXQgKi8KKworLyogU3RhcnQgZnVuY3Rpb25zIGZvciBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwc19jaXQgKi8KKworc3RhdGljIHN0cnVjdCBjb25maWdfZ3JvdXAgKnRhcmdldF9jb3JlX2FsdWFfY3JlYXRlX3RnX3B0X2dwKAorCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLAorCWNvbnN0IGNoYXIgKm5hbWUpCit7CisJc3RydWN0IHQxMF9hbHVhICphbHVhID0gY29udGFpbmVyX29mKGdyb3VwLCBzdHJ1Y3QgdDEwX2FsdWEsCisJCQkJCWFsdWFfdGdfcHRfZ3BzX2dyb3VwKTsKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwOworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXYgPSBhbHVhLT50MTBfc3ViX2RldjsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwICphbHVhX3RnX3B0X2dwX2NnID0gTlVMTDsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW0gKmFsdWFfdGdfcHRfZ3BfY2kgPSBOVUxMOworCisJdGdfcHRfZ3AgPSBjb3JlX2FsdWFfYWxsb2NhdGVfdGdfcHRfZ3Aoc3VfZGV2LCBuYW1lLCAwKTsKKwlpZiAoISh0Z19wdF9ncCkpCisJCXJldHVybiBOVUxMOworCisJYWx1YV90Z19wdF9ncF9jZyA9ICZ0Z19wdF9ncC0+dGdfcHRfZ3BfZ3JvdXA7CisJYWx1YV90Z19wdF9ncF9jaSA9ICZhbHVhX3RnX3B0X2dwX2NnLT5jZ19pdGVtOworCisJY29uZmlnX2dyb3VwX2luaXRfdHlwZV9uYW1lKGFsdWFfdGdfcHRfZ3BfY2csIG5hbWUsCisJCQkmdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9jaXQpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiVGFyZ2V0X0NvcmVfQ29uZmlnRlM6IEFsbG9jYXRlZCBBTFVBIFRhcmdldCBQb3J0IgorCQkiIEdyb3VwOiBhbHVhL3RnX3B0X2dwcy8lc1xuIiwKKwkJY29uZmlnX2l0ZW1fbmFtZShhbHVhX3RnX3B0X2dwX2NpKSk7CisKKwlyZXR1cm4gYWx1YV90Z19wdF9ncF9jZzsKK30KKworc3RhdGljIHZvaWQgdGFyZ2V0X2NvcmVfYWx1YV9kcm9wX3RnX3B0X2dwKAorCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLAorCXN0cnVjdCBjb25maWdfaXRlbSAqaXRlbSkKK3sKKwlzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AgKnRnX3B0X2dwID0gY29udGFpbmVyX29mKHRvX2NvbmZpZ19ncm91cChpdGVtKSwKKwkJCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCwgdGdfcHRfZ3BfZ3JvdXApOworCisJcHJpbnRrKEtFUk5fSU5GTyAiVGFyZ2V0X0NvcmVfQ29uZmlnRlM6IFJlbGVhc2luZyBBTFVBIFRhcmdldCBQb3J0IgorCQkiIEdyb3VwOiBhbHVhL3RnX3B0X2dwcy8lcywgSUQ6ICVodVxuIiwKKwkJY29uZmlnX2l0ZW1fbmFtZShpdGVtKSwgdGdfcHRfZ3AtPnRnX3B0X2dwX2lkKTsKKworCWNvbmZpZ19pdGVtX3B1dChpdGVtKTsKKwljb3JlX2FsdWFfZnJlZV90Z19wdF9ncCh0Z19wdF9ncCk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfZ3JvdXBfb3BlcmF0aW9ucyB0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwc19ncm91cF9vcHMgPSB7CisJLm1ha2VfZ3JvdXAJCT0gJnRhcmdldF9jb3JlX2FsdWFfY3JlYXRlX3RnX3B0X2dwLAorCS5kcm9wX2l0ZW0JCT0gJnRhcmdldF9jb3JlX2FsdWFfZHJvcF90Z19wdF9ncCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwc19jaXQgPSB7CisJLmN0X2dyb3VwX29wcwkJPSAmdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncHNfZ3JvdXBfb3BzLAorCS5jdF9vd25lcgkJPSBUSElTX01PRFVMRSwKK307CisKKy8qIEVuZCBmdW5jdGlvbnMgZm9yIHN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3BzX2NpdCAqLworCisvKiBTdGFydCBmdW5jdGlvbnMgZm9yIHN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRhcmdldF9jb3JlX2FsdWFfY2l0ICovCisKKy8qCisgKiB0YXJnZXRfY29yZV9hbHVhX2NpdCBpcyBhIENvbmZpZ0ZTIGdyb3VwIHRoYXQgbGl2ZXMgdW5kZXIKKyAqIC9zeXMva2VybmVsL2NvbmZpZy90YXJnZXQvY29yZS9hbHVhLiAgVGhlcmUgYXJlIGRlZmF1bHQgZ3JvdXBzCisgKiBjb3JlL2FsdWEvbHVfZ3BzIGFuZCBjb3JlL2FsdWEvdGdfcHRfZ3BzIHRoYXQgYXJlIGF0dGFjaGVkIHRvCisgKiB0YXJnZXRfY29yZV9hbHVhX2NpdCBpbiB0YXJnZXRfY29yZV9pbml0X2NvbmZpZ2ZzKCkgYmVsb3cuCisgKi8KK3N0YXRpYyBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9hbHVhX2NpdCA9IHsKKwkuY3RfaXRlbV9vcHMJCT0gTlVMTCwKKwkuY3RfYXR0cnMJCT0gTlVMTCwKKwkuY3Rfb3duZXIJCT0gVEhJU19NT0RVTEUsCit9OworCisvKiBFbmQgZnVuY3Rpb25zIGZvciBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9hbHVhX2NpdCAqLworCisvKiBTdGFydCBmdW5jdGlvbnMgZm9yIHN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRhcmdldF9jb3JlX2hiYV9jaXQgKi8KKworc3RhdGljIHN0cnVjdCBjb25maWdfZ3JvdXAgKnRhcmdldF9jb3JlX21ha2Vfc3ViZGV2KAorCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLAorCWNvbnN0IGNoYXIgKm5hbWUpCit7CisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncDsKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc2VfZGV2OworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpICp0OworCXN0cnVjdCBjb25maWdfaXRlbSAqaGJhX2NpID0gJmdyb3VwLT5jZ19pdGVtOworCXN0cnVjdCBzZV9oYmEgKmhiYSA9IGl0ZW1fdG9faGJhKGhiYV9jaSk7CisJc3RydWN0IGNvbmZpZ19ncm91cCAqZGV2X2NnID0gTlVMTCwgKnRnX3B0X2dwX2NnID0gTlVMTDsKKworCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmhiYS0+aGJhX2FjY2Vzc19tdXRleCkpCisJCXJldHVybiBOVUxMOworCisJLyoKKwkgKiBMb2NhdGUgdGhlIHN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpIGZyb20gcGFyZW50J3Mgc3RydWN0IHNlX2hiYS4KKwkgKi8KKwl0ID0gaGJhLT50cmFuc3BvcnQ7CisKKwlzZV9kZXYgPSBremFsbG9jKHNpemVvZihzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiksIEdGUF9LRVJORUwpOworCWlmICghc2VfZGV2KSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIG1lbW9yeSBmb3IiCisJCQkJIiBzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldlxuIik7CisJCWdvdG8gdW5sb2NrOworCX0KKwlJTklUX0xJU1RfSEVBRCgmc2VfZGV2LT5nX3NlX2Rldl9saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmc2VfZGV2LT50MTBfd3duLnQxMF92cGRfbGlzdCk7CisJc3Bpbl9sb2NrX2luaXQoJnNlX2Rldi0+dDEwX3d3bi50MTBfdnBkX2xvY2spOworCUlOSVRfTElTVF9IRUFEKCZzZV9kZXYtPnQxMF9yZXNlcnZhdGlvbi5yZWdpc3RyYXRpb25fbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJnNlX2Rldi0+dDEwX3Jlc2VydmF0aW9uLmFwdHBsX3JlZ19saXN0KTsKKwlzcGluX2xvY2tfaW5pdCgmc2VfZGV2LT50MTBfcmVzZXJ2YXRpb24ucmVnaXN0cmF0aW9uX2xvY2spOworCXNwaW5fbG9ja19pbml0KCZzZV9kZXYtPnQxMF9yZXNlcnZhdGlvbi5hcHRwbF9yZWdfbG9jayk7CisJSU5JVF9MSVNUX0hFQUQoJnNlX2Rldi0+dDEwX2FsdWEudGdfcHRfZ3BzX2xpc3QpOworCXNwaW5fbG9ja19pbml0KCZzZV9kZXYtPnQxMF9hbHVhLnRnX3B0X2dwc19sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmc2VfZGV2LT5zZV9kZXZfbG9jayk7CisJc2VfZGV2LT50MTBfcmVzZXJ2YXRpb24ucHJfYXB0cGxfYnVmX2xlbiA9IFBSX0FQVFBMX0JVRl9MRU47CisJc2VfZGV2LT50MTBfd3duLnQxMF9zdWJfZGV2ID0gc2VfZGV2OworCXNlX2Rldi0+dDEwX2FsdWEudDEwX3N1Yl9kZXYgPSBzZV9kZXY7CisJc2VfZGV2LT5zZV9kZXZfYXR0cmliLmRhX3N1Yl9kZXYgPSBzZV9kZXY7CisKKwlzZV9kZXYtPnNlX2Rldl9oYmEgPSBoYmE7CisJZGV2X2NnID0gJnNlX2Rldi0+c2VfZGV2X2dyb3VwOworCisJZGV2X2NnLT5kZWZhdWx0X2dyb3VwcyA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBjb25maWdfZ3JvdXApICogNiwKKwkJCUdGUF9LRVJORUwpOworCWlmICghKGRldl9jZy0+ZGVmYXVsdF9ncm91cHMpKQorCQlnb3RvIG91dDsKKwkvKgorCSAqIFNldCBzZV9kZXZfc3VfcHRyIGZyb20gc3RydWN0IHNlX3N1YnN5c3RlbV9hcGkgcmV0dXJuZWQgdm9pZCBwdHIKKwkgKiBmb3IgLT5hbGxvY2F0ZV92aXJ0ZGV2aWNlKCkKKwkgKgorCSAqIHNlX2Rldi0+c2VfZGV2X3B0ciB3aWxsIGJlIHNldCBhZnRlciAtPmNyZWF0ZV92aXJ0ZGV2KCkKKwkgKiBoYXMgYmVlbiBjYWxsZWQgc3VjY2Vzc2Z1bGx5IGluIHRoZSBuZXh0IGxldmVsIHVwIGluIHRoZQorCSAqIGNvbmZpZ2ZzIHRyZWUgZm9yIGRldmljZSBvYmplY3QncyBzdHJ1Y3QgY29uZmlnX2dyb3VwLgorCSAqLworCXNlX2Rldi0+c2VfZGV2X3N1X3B0ciA9IHQtPmFsbG9jYXRlX3ZpcnRkZXZpY2UoaGJhLCBuYW1lKTsKKwlpZiAoIShzZV9kZXYtPnNlX2Rldl9zdV9wdHIpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGxvY2F0ZSBzdWJzeXN0ZW0gZGVwZW5kZW50IHBvaW50ZXIiCisJCQkiIGZyb20gYWxsb2NhdGVfdmlydGRldmljZSgpXG4iKTsKKwkJZ290byBvdXQ7CisJfQorCXNwaW5fbG9jaygmc2VfZ2xvYmFsLT5nX2RldmljZV9sb2NrKTsKKwlsaXN0X2FkZF90YWlsKCZzZV9kZXYtPmdfc2VfZGV2X2xpc3QsICZzZV9nbG9iYWwtPmdfc2VfZGV2X2xpc3QpOworCXNwaW5fdW5sb2NrKCZzZV9nbG9iYWwtPmdfZGV2aWNlX2xvY2spOworCisJY29uZmlnX2dyb3VwX2luaXRfdHlwZV9uYW1lKCZzZV9kZXYtPnNlX2Rldl9ncm91cCwgbmFtZSwKKwkJCSZ0YXJnZXRfY29yZV9kZXZfY2l0KTsKKwljb25maWdfZ3JvdXBfaW5pdF90eXBlX25hbWUoJnNlX2Rldi0+c2VfZGV2X2F0dHJpYi5kYV9ncm91cCwgImF0dHJpYiIsCisJCQkmdGFyZ2V0X2NvcmVfZGV2X2F0dHJpYl9jaXQpOworCWNvbmZpZ19ncm91cF9pbml0X3R5cGVfbmFtZSgmc2VfZGV2LT5zZV9kZXZfcHJfZ3JvdXAsICJwciIsCisJCQkmdGFyZ2V0X2NvcmVfZGV2X3ByX2NpdCk7CisJY29uZmlnX2dyb3VwX2luaXRfdHlwZV9uYW1lKCZzZV9kZXYtPnQxMF93d24udDEwX3d3bl9ncm91cCwgInd3biIsCisJCQkmdGFyZ2V0X2NvcmVfZGV2X3d3bl9jaXQpOworCWNvbmZpZ19ncm91cF9pbml0X3R5cGVfbmFtZSgmc2VfZGV2LT50MTBfYWx1YS5hbHVhX3RnX3B0X2dwc19ncm91cCwKKwkJCSJhbHVhIiwgJnRhcmdldF9jb3JlX2FsdWFfdGdfcHRfZ3BzX2NpdCk7CisJZGV2X2NnLT5kZWZhdWx0X2dyb3Vwc1swXSA9ICZzZV9kZXYtPnNlX2Rldl9hdHRyaWIuZGFfZ3JvdXA7CisJZGV2X2NnLT5kZWZhdWx0X2dyb3Vwc1sxXSA9ICZzZV9kZXYtPnNlX2Rldl9wcl9ncm91cDsKKwlkZXZfY2ctPmRlZmF1bHRfZ3JvdXBzWzJdID0gJnNlX2Rldi0+dDEwX3d3bi50MTBfd3duX2dyb3VwOworCWRldl9jZy0+ZGVmYXVsdF9ncm91cHNbM10gPSAmc2VfZGV2LT50MTBfYWx1YS5hbHVhX3RnX3B0X2dwc19ncm91cDsKKwlkZXZfY2ctPmRlZmF1bHRfZ3JvdXBzWzRdID0gTlVMTDsKKwkvKgorCSAqIEFkZCBjb3JlLyRIQkEvJERFVi9hbHVhL3RnX3B0X2dwcy9kZWZhdWx0X3RnX3B0X2dwCisJICovCisJdGdfcHRfZ3AgPSBjb3JlX2FsdWFfYWxsb2NhdGVfdGdfcHRfZ3Aoc2VfZGV2LCAiZGVmYXVsdF90Z19wdF9ncCIsIDEpOworCWlmICghKHRnX3B0X2dwKSkKKwkJZ290byBvdXQ7CisKKwl0Z19wdF9ncF9jZyA9ICZUMTBfQUxVQShzZV9kZXYpLT5hbHVhX3RnX3B0X2dwc19ncm91cDsKKwl0Z19wdF9ncF9jZy0+ZGVmYXVsdF9ncm91cHMgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgY29uZmlnX2dyb3VwKSAqIDIsCisJCQkJR0ZQX0tFUk5FTCk7CisJaWYgKCEodGdfcHRfZ3BfY2ctPmRlZmF1bHRfZ3JvdXBzKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSB0Z19wdF9ncF9jZy0+IgorCQkJCSJkZWZhdWx0X2dyb3Vwc1xuIik7CisJCWdvdG8gb3V0OworCX0KKworCWNvbmZpZ19ncm91cF9pbml0X3R5cGVfbmFtZSgmdGdfcHRfZ3AtPnRnX3B0X2dwX2dyb3VwLAorCQkJImRlZmF1bHRfdGdfcHRfZ3AiLCAmdGFyZ2V0X2NvcmVfYWx1YV90Z19wdF9ncF9jaXQpOworCXRnX3B0X2dwX2NnLT5kZWZhdWx0X2dyb3Vwc1swXSA9ICZ0Z19wdF9ncC0+dGdfcHRfZ3BfZ3JvdXA7CisJdGdfcHRfZ3BfY2ctPmRlZmF1bHRfZ3JvdXBzWzFdID0gTlVMTDsKKwlUMTBfQUxVQShzZV9kZXYpLT5kZWZhdWx0X3RnX3B0X2dwID0gdGdfcHRfZ3A7CisKKwlwcmludGsoS0VSTl9JTkZPICJUYXJnZXRfQ29yZV9Db25maWdGUzogQWxsb2NhdGVkIHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2OiIKKwkJIiAlcCBzZV9kZXZfc3VfcHRyOiAlcFxuIiwgc2VfZGV2LCBzZV9kZXYtPnNlX2Rldl9zdV9wdHIpOworCisJbXV0ZXhfdW5sb2NrKCZoYmEtPmhiYV9hY2Nlc3NfbXV0ZXgpOworCXJldHVybiAmc2VfZGV2LT5zZV9kZXZfZ3JvdXA7CitvdXQ6CisJaWYgKFQxMF9BTFVBKHNlX2RldiktPmRlZmF1bHRfdGdfcHRfZ3ApIHsKKwkJY29yZV9hbHVhX2ZyZWVfdGdfcHRfZ3AoVDEwX0FMVUEoc2VfZGV2KS0+ZGVmYXVsdF90Z19wdF9ncCk7CisJCVQxMF9BTFVBKHNlX2RldiktPmRlZmF1bHRfdGdfcHRfZ3AgPSBOVUxMOworCX0KKwlpZiAodGdfcHRfZ3BfY2cpCisJCWtmcmVlKHRnX3B0X2dwX2NnLT5kZWZhdWx0X2dyb3Vwcyk7CisJaWYgKGRldl9jZykKKwkJa2ZyZWUoZGV2X2NnLT5kZWZhdWx0X2dyb3Vwcyk7CisJaWYgKHNlX2Rldi0+c2VfZGV2X3N1X3B0cikKKwkJdC0+ZnJlZV9kZXZpY2Uoc2VfZGV2LT5zZV9kZXZfc3VfcHRyKTsKKwlrZnJlZShzZV9kZXYpOwordW5sb2NrOgorCW11dGV4X3VubG9jaygmaGJhLT5oYmFfYWNjZXNzX211dGV4KTsKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIHZvaWQgdGFyZ2V0X2NvcmVfZHJvcF9zdWJkZXYoCisJc3RydWN0IGNvbmZpZ19ncm91cCAqZ3JvdXAsCisJc3RydWN0IGNvbmZpZ19pdGVtICppdGVtKQoreworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzZV9kZXYgPSBjb250YWluZXJfb2YodG9fY29uZmlnX2dyb3VwKGl0ZW0pLAorCQkJCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2LCBzZV9kZXZfZ3JvdXApOworCXN0cnVjdCBzZV9oYmEgKmhiYTsKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2FwaSAqdDsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW0gKmRmX2l0ZW07CisJc3RydWN0IGNvbmZpZ19ncm91cCAqZGV2X2NnLCAqdGdfcHRfZ3BfY2c7CisJaW50IGksIHJldDsKKworCWhiYSA9IGl0ZW1fdG9faGJhKCZzZV9kZXYtPnNlX2Rldl9oYmEtPmhiYV9ncm91cC5jZ19pdGVtKTsKKworCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmhiYS0+aGJhX2FjY2Vzc19tdXRleCkpCisJCWdvdG8gb3V0OworCisJdCA9IGhiYS0+dHJhbnNwb3J0OworCisJc3Bpbl9sb2NrKCZzZV9nbG9iYWwtPmdfZGV2aWNlX2xvY2spOworCWxpc3RfZGVsKCZzZV9kZXYtPmdfc2VfZGV2X2xpc3QpOworCXNwaW5fdW5sb2NrKCZzZV9nbG9iYWwtPmdfZGV2aWNlX2xvY2spOworCisJdGdfcHRfZ3BfY2cgPSAmVDEwX0FMVUEoc2VfZGV2KS0+YWx1YV90Z19wdF9ncHNfZ3JvdXA7CisJZm9yIChpID0gMDsgdGdfcHRfZ3BfY2ctPmRlZmF1bHRfZ3JvdXBzW2ldOyBpKyspIHsKKwkJZGZfaXRlbSA9ICZ0Z19wdF9ncF9jZy0+ZGVmYXVsdF9ncm91cHNbaV0tPmNnX2l0ZW07CisJCXRnX3B0X2dwX2NnLT5kZWZhdWx0X2dyb3Vwc1tpXSA9IE5VTEw7CisJCWNvbmZpZ19pdGVtX3B1dChkZl9pdGVtKTsKKwl9CisJa2ZyZWUodGdfcHRfZ3BfY2ctPmRlZmF1bHRfZ3JvdXBzKTsKKwljb3JlX2FsdWFfZnJlZV90Z19wdF9ncChUMTBfQUxVQShzZV9kZXYpLT5kZWZhdWx0X3RnX3B0X2dwKTsKKwlUMTBfQUxVQShzZV9kZXYpLT5kZWZhdWx0X3RnX3B0X2dwID0gTlVMTDsKKworCWRldl9jZyA9ICZzZV9kZXYtPnNlX2Rldl9ncm91cDsKKwlmb3IgKGkgPSAwOyBkZXZfY2ctPmRlZmF1bHRfZ3JvdXBzW2ldOyBpKyspIHsKKwkJZGZfaXRlbSA9ICZkZXZfY2ctPmRlZmF1bHRfZ3JvdXBzW2ldLT5jZ19pdGVtOworCQlkZXZfY2ctPmRlZmF1bHRfZ3JvdXBzW2ldID0gTlVMTDsKKwkJY29uZmlnX2l0ZW1fcHV0KGRmX2l0ZW0pOworCX0KKworCWNvbmZpZ19pdGVtX3B1dChpdGVtKTsKKwkvKgorCSAqIFRoaXMgcG9pbnRlciB3aWxsIHNldCB3aGVuIHRoZSBzdG9yYWdlIGlzIGVuYWJsZWQgd2l0aDoKKwkgKiBgZWNobyAxID4gJENPTkZJR0ZTL2NvcmUvJEhCQS8kREVWL2Rldl9lbmFibGVgCisJICovCisJaWYgKHNlX2Rldi0+c2VfZGV2X3B0cikgeworCQlwcmludGsoS0VSTl9JTkZPICJUYXJnZXRfQ29yZV9Db25maWdGUzogQ2FsbGluZyBzZV9mcmVlXyIKKwkJCSJ2aXJ0dWFsX2RldmljZSgpIGZvciBzZV9kZXZfcHRyOiAlcFxuIiwKKwkJCQlzZV9kZXYtPnNlX2Rldl9wdHIpOworCisJCXJldCA9IHNlX2ZyZWVfdmlydHVhbF9kZXZpY2Uoc2VfZGV2LT5zZV9kZXZfcHRyLCBoYmEpOworCQlpZiAocmV0IDwgMCkKKwkJCWdvdG8gaGJhX291dDsKKwl9IGVsc2UgeworCQkvKgorCQkgKiBSZWxlYXNlIHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2LT5zZV9kZXZfc3VfcHRyLi4KKwkJICovCisJCXByaW50ayhLRVJOX0lORk8gIlRhcmdldF9Db3JlX0NvbmZpZ0ZTOiBDYWxsaW5nIHQtPmZyZWVfIgorCQkJImRldmljZSgpIGZvciBzZV9kZXZfc3VfcHRyOiAlcFxuIiwKKwkJCXNlX2Rldi0+c2VfZGV2X3N1X3B0cik7CisKKwkJdC0+ZnJlZV9kZXZpY2Uoc2VfZGV2LT5zZV9kZXZfc3VfcHRyKTsKKwl9CisKKwlwcmludGsoS0VSTl9JTkZPICJUYXJnZXRfQ29yZV9Db25maWdGUzogRGVhbGxvY2F0aW5nIHNlX3N1YnN5c3RlbSIKKwkJIl9kZXZfdDogJXBcbiIsIHNlX2Rldik7CisKK2hiYV9vdXQ6CisJbXV0ZXhfdW5sb2NrKCZoYmEtPmhiYV9hY2Nlc3NfbXV0ZXgpOworb3V0OgorCWtmcmVlKHNlX2Rldik7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfZ3JvdXBfb3BlcmF0aW9ucyB0YXJnZXRfY29yZV9oYmFfZ3JvdXBfb3BzID0geworCS5tYWtlX2dyb3VwCQk9IHRhcmdldF9jb3JlX21ha2Vfc3ViZGV2LAorCS5kcm9wX2l0ZW0JCT0gdGFyZ2V0X2NvcmVfZHJvcF9zdWJkZXYsCit9OworCitDT05GSUdGU19FQVRUUl9TVFJVQ1QodGFyZ2V0X2NvcmVfaGJhLCBzZV9oYmEpOworI2RlZmluZSBTRV9IQkFfQVRUUihfbmFtZSwgX21vZGUpCQkJCVwKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2NvcmVfaGJhX2F0dHJpYnV0ZQkJCQlcCisJCXRhcmdldF9jb3JlX2hiYV8jI19uYW1lID0JCQlcCisJCV9fQ09ORklHRlNfRUFUVFIoX25hbWUsIF9tb2RlLAkJCVwKKwkJdGFyZ2V0X2NvcmVfaGJhX3Nob3dfYXR0cl8jI19uYW1lLAkJXAorCQl0YXJnZXRfY29yZV9oYmFfc3RvcmVfYXR0cl8jI19uYW1lKTsKKworI2RlZmluZSBTRV9IQkFfQVRUUl9STyhfbmFtZSkJCQkJCVwKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2NvcmVfaGJhX2F0dHJpYnV0ZQkJCQlcCisJCXRhcmdldF9jb3JlX2hiYV8jI19uYW1lID0JCQlcCisJCV9fQ09ORklHRlNfRUFUVFJfUk8oX25hbWUsCQkJXAorCQl0YXJnZXRfY29yZV9oYmFfc2hvd19hdHRyXyMjX25hbWUpOworCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9oYmFfc2hvd19hdHRyX2hiYV9pbmZvKAorCXN0cnVjdCBzZV9oYmEgKmhiYSwKKwljaGFyICpwYWdlKQoreworCXJldHVybiBzcHJpbnRmKHBhZ2UsICJIQkEgSW5kZXg6ICVkIHBsdWdpbjogJXMgdmVyc2lvbjogJXNcbiIsCisJCQloYmEtPmhiYV9pZCwgaGJhLT50cmFuc3BvcnQtPm5hbWUsCisJCQlUQVJHRVRfQ09SRV9DT05GSUdGU19WRVJTSU9OKTsKK30KKworU0VfSEJBX0FUVFJfUk8oaGJhX2luZm8pOworCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfY29yZV9oYmFfc2hvd19hdHRyX2hiYV9tb2RlKHN0cnVjdCBzZV9oYmEgKmhiYSwKKwkJCQljaGFyICpwYWdlKQoreworCWludCBoYmFfbW9kZSA9IDA7CisKKwlpZiAoaGJhLT5oYmFfZmxhZ3MgJiBIQkFfRkxBR1NfUFNDU0lfTU9ERSkKKwkJaGJhX21vZGUgPSAxOworCisJcmV0dXJuIHNwcmludGYocGFnZSwgIiVkXG4iLCBoYmFfbW9kZSk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9jb3JlX2hiYV9zdG9yZV9hdHRyX2hiYV9tb2RlKHN0cnVjdCBzZV9oYmEgKmhiYSwKKwkJCQljb25zdCBjaGFyICpwYWdlLCBzaXplX3QgY291bnQpCit7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9hcGkgKnRyYW5zcG9ydCA9IGhiYS0+dHJhbnNwb3J0OworCXVuc2lnbmVkIGxvbmcgbW9kZV9mbGFnOworCWludCByZXQ7CisKKwlpZiAodHJhbnNwb3J0LT5wbW9kZV9lbmFibGVfaGJhID09IE5VTEwpCisJCXJldHVybiAtRUlOVkFMOworCisJcmV0ID0gc3RyaWN0X3N0cnRvdWwocGFnZSwgMCwgJm1vZGVfZmxhZyk7CisJaWYgKHJldCA8IDApIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gZXh0cmFjdCBoYmEgbW9kZSBmbGFnOiAlZFxuIiwgcmV0KTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJc3Bpbl9sb2NrKCZoYmEtPmRldmljZV9sb2NrKTsKKwlpZiAoIShsaXN0X2VtcHR5KCZoYmEtPmhiYV9kZXZfbGlzdCkpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIHNldCBoYmFfbW9kZSB3aXRoIGFjdGl2ZSBkZXZpY2VzXG4iKTsKKwkJc3Bpbl91bmxvY2soJmhiYS0+ZGV2aWNlX2xvY2spOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJc3Bpbl91bmxvY2soJmhiYS0+ZGV2aWNlX2xvY2spOworCisJcmV0ID0gdHJhbnNwb3J0LT5wbW9kZV9lbmFibGVfaGJhKGhiYSwgbW9kZV9mbGFnKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIC1FSU5WQUw7CisJaWYgKHJldCA+IDApCisJCWhiYS0+aGJhX2ZsYWdzIHw9IEhCQV9GTEFHU19QU0NTSV9NT0RFOworCWVsc2UgaWYgKHJldCA9PSAwKQorCQloYmEtPmhiYV9mbGFncyAmPSB+SEJBX0ZMQUdTX1BTQ1NJX01PREU7CisKKwlyZXR1cm4gY291bnQ7Cit9CisKK1NFX0hCQV9BVFRSKGhiYV9tb2RlLCBTX0lSVUdPIHwgU19JV1VTUik7CisKK0NPTkZJR0ZTX0VBVFRSX09QUyh0YXJnZXRfY29yZV9oYmEsIHNlX2hiYSwgaGJhX2dyb3VwKTsKKworc3RhdGljIHN0cnVjdCBjb25maWdmc19hdHRyaWJ1dGUgKnRhcmdldF9jb3JlX2hiYV9hdHRyc1tdID0geworCSZ0YXJnZXRfY29yZV9oYmFfaGJhX2luZm8uYXR0ciwKKwkmdGFyZ2V0X2NvcmVfaGJhX2hiYV9tb2RlLmF0dHIsCisJTlVMTCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfaXRlbV9vcGVyYXRpb25zIHRhcmdldF9jb3JlX2hiYV9pdGVtX29wcyA9IHsKKwkuc2hvd19hdHRyaWJ1dGUJCT0gdGFyZ2V0X2NvcmVfaGJhX2F0dHJfc2hvdywKKwkuc3RvcmVfYXR0cmlidXRlCT0gdGFyZ2V0X2NvcmVfaGJhX2F0dHJfc3RvcmUsCit9OworCitzdGF0aWMgc3RydWN0IGNvbmZpZ19pdGVtX3R5cGUgdGFyZ2V0X2NvcmVfaGJhX2NpdCA9IHsKKwkuY3RfaXRlbV9vcHMJCT0gJnRhcmdldF9jb3JlX2hiYV9pdGVtX29wcywKKwkuY3RfZ3JvdXBfb3BzCQk9ICZ0YXJnZXRfY29yZV9oYmFfZ3JvdXBfb3BzLAorCS5jdF9hdHRycwkJPSB0YXJnZXRfY29yZV9oYmFfYXR0cnMsCisJLmN0X293bmVyCQk9IFRISVNfTU9EVUxFLAorfTsKKworc3RhdGljIHN0cnVjdCBjb25maWdfZ3JvdXAgKnRhcmdldF9jb3JlX2NhbGxfYWRkaGJhdG90YXJnZXQoCisJc3RydWN0IGNvbmZpZ19ncm91cCAqZ3JvdXAsCisJY29uc3QgY2hhciAqbmFtZSkKK3sKKwljaGFyICpzZV9wbHVnaW5fc3RyLCAqc3RyLCAqc3RyMjsKKwlzdHJ1Y3Qgc2VfaGJhICpoYmE7CisJY2hhciBidWZbVEFSR0VUX0NPUkVfTkFNRV9NQVhfTEVOXTsKKwl1bnNpZ25lZCBsb25nIHBsdWdpbl9kZXBfaWQgPSAwOworCWludCByZXQ7CisKKwltZW1zZXQoYnVmLCAwLCBUQVJHRVRfQ09SRV9OQU1FX01BWF9MRU4pOworCWlmIChzdHJsZW4obmFtZSkgPiBUQVJHRVRfQ09SRV9OQU1FX01BWF9MRU4pIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJQYXNzZWQgKm5hbWUgc3RybGVuKCk6ICVkIGV4Y2VlZHMiCisJCQkiIFRBUkdFVF9DT1JFX05BTUVfTUFYX0xFTjogJWRcbiIsIChpbnQpc3RybGVuKG5hbWUpLAorCQkJVEFSR0VUX0NPUkVfTkFNRV9NQVhfTEVOKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVOQU1FVE9PTE9ORyk7CisJfQorCXNucHJpbnRmKGJ1ZiwgVEFSR0VUX0NPUkVfTkFNRV9NQVhfTEVOLCAiJXMiLCBuYW1lKTsKKworCXN0ciA9IHN0cnN0cihidWYsICJfIik7CisJaWYgKCEoc3RyKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2NhdGUgXCJfXCIgZm9yICRTVUJTWVNURU1fUExVR0lOXyRIT1NUX0lEXG4iKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisJfQorCXNlX3BsdWdpbl9zdHIgPSBidWY7CisJLyoKKwkgKiBTcGVjaWFsIGNhc2UgZm9yIHN1YnN5c3RlbSBwbHVnaW5zIHRoYXQgaGF2ZSAiXyIgaW4gdGhlaXIgbmFtZXMuCisJICogTmFtZWx5IHJkX2RpcmVjdCBhbmQgcmRfbWNwLi4KKwkgKi8KKwlzdHIyID0gc3Ryc3RyKHN0cisxLCAiXyIpOworCWlmICgoc3RyMikpIHsKKwkJKnN0cjIgPSAnXDAnOyAvKiBUZXJtaW5hdGUgZm9yICpzZV9wbHVnaW5fc3RyICovCisJCXN0cjIrKzsgLyogU2tpcCB0byBzdGFydCBvZiBwbHVnaW4gZGVwZW5kZW50IElEICovCisJCXN0ciA9IHN0cjI7CisJfSBlbHNlIHsKKwkJKnN0ciA9ICdcMCc7IC8qIFRlcm1pbmF0ZSBmb3IgKnNlX3BsdWdpbl9zdHIgKi8KKwkJc3RyKys7IC8qIFNraXAgdG8gc3RhcnQgb2YgcGx1Z2luIGRlcGVuZGVudCBJRCAqLworCX0KKworCXJldCA9IHN0cmljdF9zdHJ0b3VsKHN0ciwgMCwgJnBsdWdpbl9kZXBfaWQpOworCWlmIChyZXQgPCAwKSB7CisJCXByaW50ayhLRVJOX0VSUiAic3RyaWN0X3N0cnRvdWwoKSByZXR1cm5lZCAlZCBmb3IiCisJCQkJIiBwbHVnaW5fZGVwX2lkXG4iLCByZXQpOworCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKKwl9CisJLyoKKwkgKiBMb2FkIHVwIFRDTSBzdWJzeXN0ZW0gcGx1Z2lucyBpZiB0aGV5IGhhdmUgbm90IGFscmVhZHkgYmVlbiBsb2FkZWQuCisJICovCisJaWYgKHRyYW5zcG9ydF9zdWJzeXN0ZW1fY2hlY2tfaW5pdCgpIDwgMCkKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisKKwloYmEgPSBjb3JlX2FsbG9jX2hiYShzZV9wbHVnaW5fc3RyLCBwbHVnaW5fZGVwX2lkLCAwKTsKKwlpZiAoSVNfRVJSKGhiYSkpCisJCXJldHVybiBFUlJfQ0FTVChoYmEpOworCisJY29uZmlnX2dyb3VwX2luaXRfdHlwZV9uYW1lKCZoYmEtPmhiYV9ncm91cCwgbmFtZSwKKwkJCSZ0YXJnZXRfY29yZV9oYmFfY2l0KTsKKworCXJldHVybiAmaGJhLT5oYmFfZ3JvdXA7Cit9CisKK3N0YXRpYyB2b2lkIHRhcmdldF9jb3JlX2NhbGxfZGVsaGJhZnJvbXRhcmdldCgKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwICpncm91cCwKKwlzdHJ1Y3QgY29uZmlnX2l0ZW0gKml0ZW0pCit7CisJc3RydWN0IHNlX2hiYSAqaGJhID0gaXRlbV90b19oYmEoaXRlbSk7CisKKwljb25maWdfaXRlbV9wdXQoaXRlbSk7CisJY29yZV9kZWxldGVfaGJhKGhiYSk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfZ3JvdXBfb3BlcmF0aW9ucyB0YXJnZXRfY29yZV9ncm91cF9vcHMgPSB7CisJLm1ha2VfZ3JvdXAJPSB0YXJnZXRfY29yZV9jYWxsX2FkZGhiYXRvdGFyZ2V0LAorCS5kcm9wX2l0ZW0JPSB0YXJnZXRfY29yZV9jYWxsX2RlbGhiYWZyb210YXJnZXQsCit9OworCitzdGF0aWMgc3RydWN0IGNvbmZpZ19pdGVtX3R5cGUgdGFyZ2V0X2NvcmVfY2l0ID0geworCS5jdF9pdGVtX29wcwk9IE5VTEwsCisJLmN0X2dyb3VwX29wcwk9ICZ0YXJnZXRfY29yZV9ncm91cF9vcHMsCisJLmN0X2F0dHJzCT0gTlVMTCwKKwkuY3Rfb3duZXIJPSBUSElTX01PRFVMRSwKK307CisKKy8qIFN0b3AgZnVuY3Rpb25zIGZvciBzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0YXJnZXRfY29yZV9oYmFfY2l0ICovCisKK3N0YXRpYyBpbnQgdGFyZ2V0X2NvcmVfaW5pdF9jb25maWdmcyh2b2lkKQoreworCXN0cnVjdCBjb25maWdfZ3JvdXAgKnRhcmdldF9jZywgKmhiYV9jZyA9IE5VTEwsICphbHVhX2NnID0gTlVMTDsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwICpsdV9ncF9jZyA9IE5VTEw7CisJc3RydWN0IGNvbmZpZ2ZzX3N1YnN5c3RlbSAqc3Vic3lzOworCXN0cnVjdCBwcm9jX2Rpcl9lbnRyeSAqc2NzaV90YXJnZXRfcHJvYyA9IE5VTEw7CisJc3RydWN0IHQxMF9hbHVhX2x1X2dwICpsdV9ncDsKKwlpbnQgcmV0OworCisJcHJpbnRrKEtFUk5fSU5GTyAiVEFSR0VUX0NPUkVbMF06IExvYWRpbmcgR2VuZXJpYyBLZXJuZWwgU3RvcmFnZSIKKwkJIiBFbmdpbmU6ICVzIG9uICVzLyVzIG9uICJVVFNfUkVMRUFTRSJcbiIsCisJCVRBUkdFVF9DT1JFX1ZFUlNJT04sIHV0c25hbWUoKS0+c3lzbmFtZSwgdXRzbmFtZSgpLT5tYWNoaW5lKTsKKworCXN1YnN5cyA9IHRhcmdldF9jb3JlX3N1YnN5c3RlbVswXTsKKwljb25maWdfZ3JvdXBfaW5pdCgmc3Vic3lzLT5zdV9ncm91cCk7CisJbXV0ZXhfaW5pdCgmc3Vic3lzLT5zdV9tdXRleCk7CisKKwlJTklUX0xJU1RfSEVBRCgmZ190Zl9saXN0KTsKKwltdXRleF9pbml0KCZnX3RmX2xvY2spOworCWluaXRfc2NzaV9pbmRleF90YWJsZSgpOworCXJldCA9IGluaXRfc2VfZ2xvYmFsKCk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiAtMTsKKwkvKgorCSAqIENyZWF0ZSAkQ09ORklHRlMvdGFyZ2V0L2NvcmUgZGVmYXVsdCBncm91cCBmb3IgSEJBIDwtPiBTdG9yYWdlIE9iamVjdAorCSAqIGFuZCBBTFVBIExvZ2ljYWwgVW5pdCBHcm91cCBhbmQgVGFyZ2V0IFBvcnQgR3JvdXAgaW5mcmFzdHJ1Y3R1cmUuCisJICovCisJdGFyZ2V0X2NnID0gJnN1YnN5cy0+c3VfZ3JvdXA7CisJdGFyZ2V0X2NnLT5kZWZhdWx0X2dyb3VwcyA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBjb25maWdfZ3JvdXApICogMiwKKwkJCQlHRlBfS0VSTkVMKTsKKwlpZiAoISh0YXJnZXRfY2ctPmRlZmF1bHRfZ3JvdXBzKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSB0YXJnZXRfY2ctPmRlZmF1bHRfZ3JvdXBzXG4iKTsKKwkJZ290byBvdXRfZ2xvYmFsOworCX0KKworCWNvbmZpZ19ncm91cF9pbml0X3R5cGVfbmFtZSgmc2VfZ2xvYmFsLT50YXJnZXRfY29yZV9oYmFncm91cCwKKwkJCSJjb3JlIiwgJnRhcmdldF9jb3JlX2NpdCk7CisJdGFyZ2V0X2NnLT5kZWZhdWx0X2dyb3Vwc1swXSA9ICZzZV9nbG9iYWwtPnRhcmdldF9jb3JlX2hiYWdyb3VwOworCXRhcmdldF9jZy0+ZGVmYXVsdF9ncm91cHNbMV0gPSBOVUxMOworCS8qCisJICogQ3JlYXRlIEFMVUEgaW5mcmFzdHJ1Y3R1cmUgdW5kZXIgL3N5cy9rZXJuZWwvY29uZmlnL3RhcmdldC9jb3JlL2FsdWEvCisJICovCisJaGJhX2NnID0gJnNlX2dsb2JhbC0+dGFyZ2V0X2NvcmVfaGJhZ3JvdXA7CisJaGJhX2NnLT5kZWZhdWx0X2dyb3VwcyA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBjb25maWdfZ3JvdXApICogMiwKKwkJCQlHRlBfS0VSTkVMKTsKKwlpZiAoIShoYmFfY2ctPmRlZmF1bHRfZ3JvdXBzKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBoYmFfY2ctPmRlZmF1bHRfZ3JvdXBzXG4iKTsKKwkJZ290byBvdXRfZ2xvYmFsOworCX0KKwljb25maWdfZ3JvdXBfaW5pdF90eXBlX25hbWUoJnNlX2dsb2JhbC0+YWx1YV9ncm91cCwKKwkJCSJhbHVhIiwgJnRhcmdldF9jb3JlX2FsdWFfY2l0KTsKKwloYmFfY2ctPmRlZmF1bHRfZ3JvdXBzWzBdID0gJnNlX2dsb2JhbC0+YWx1YV9ncm91cDsKKwloYmFfY2ctPmRlZmF1bHRfZ3JvdXBzWzFdID0gTlVMTDsKKwkvKgorCSAqIEFkZCBBTFVBIExvZ2ljYWwgVW5pdCBHcm91cCBhbmQgVGFyZ2V0IFBvcnQgR3JvdXAgQ29uZmlnRlMKKwkgKiBncm91cHMgdW5kZXIgL3N5cy9rZXJuZWwvY29uZmlnL3RhcmdldC9jb3JlL2FsdWEvCisJICovCisJYWx1YV9jZyA9ICZzZV9nbG9iYWwtPmFsdWFfZ3JvdXA7CisJYWx1YV9jZy0+ZGVmYXVsdF9ncm91cHMgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgY29uZmlnX2dyb3VwKSAqIDIsCisJCQlHRlBfS0VSTkVMKTsKKwlpZiAoIShhbHVhX2NnLT5kZWZhdWx0X2dyb3VwcykpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgYWx1YV9jZy0+ZGVmYXVsdF9ncm91cHNcbiIpOworCQlnb3RvIG91dF9nbG9iYWw7CisJfQorCisJY29uZmlnX2dyb3VwX2luaXRfdHlwZV9uYW1lKCZzZV9nbG9iYWwtPmFsdWFfbHVfZ3BzX2dyb3VwLAorCQkJImx1X2dwcyIsICZ0YXJnZXRfY29yZV9hbHVhX2x1X2dwc19jaXQpOworCWFsdWFfY2ctPmRlZmF1bHRfZ3JvdXBzWzBdID0gJnNlX2dsb2JhbC0+YWx1YV9sdV9ncHNfZ3JvdXA7CisJYWx1YV9jZy0+ZGVmYXVsdF9ncm91cHNbMV0gPSBOVUxMOworCS8qCisJICogQWRkIGNvcmUvYWx1YS9sdV9ncHMvZGVmYXVsdF9sdV9ncAorCSAqLworCWx1X2dwID0gY29yZV9hbHVhX2FsbG9jYXRlX2x1X2dwKCJkZWZhdWx0X2x1X2dwIiwgMSk7CisJaWYgKElTX0VSUihsdV9ncCkpCisJCWdvdG8gb3V0X2dsb2JhbDsKKworCWx1X2dwX2NnID0gJnNlX2dsb2JhbC0+YWx1YV9sdV9ncHNfZ3JvdXA7CisJbHVfZ3BfY2ctPmRlZmF1bHRfZ3JvdXBzID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGNvbmZpZ19ncm91cCkgKiAyLAorCQkJR0ZQX0tFUk5FTCk7CisJaWYgKCEobHVfZ3BfY2ctPmRlZmF1bHRfZ3JvdXBzKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBsdV9ncF9jZy0+ZGVmYXVsdF9ncm91cHNcbiIpOworCQlnb3RvIG91dF9nbG9iYWw7CisJfQorCisJY29uZmlnX2dyb3VwX2luaXRfdHlwZV9uYW1lKCZsdV9ncC0+bHVfZ3BfZ3JvdXAsICJkZWZhdWx0X2x1X2dwIiwKKwkJCQkmdGFyZ2V0X2NvcmVfYWx1YV9sdV9ncF9jaXQpOworCWx1X2dwX2NnLT5kZWZhdWx0X2dyb3Vwc1swXSA9ICZsdV9ncC0+bHVfZ3BfZ3JvdXA7CisJbHVfZ3BfY2ctPmRlZmF1bHRfZ3JvdXBzWzFdID0gTlVMTDsKKwlzZV9nbG9iYWwtPmRlZmF1bHRfbHVfZ3AgPSBsdV9ncDsKKwkvKgorCSAqIFJlZ2lzdGVyIHRoZSB0YXJnZXRfY29yZV9tb2Qgc3Vic3lzdGVtIHdpdGggY29uZmlnZnMuCisJICovCisJcmV0ID0gY29uZmlnZnNfcmVnaXN0ZXJfc3Vic3lzdGVtKHN1YnN5cyk7CisJaWYgKHJldCA8IDApIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJFcnJvciAlZCB3aGlsZSByZWdpc3RlcmluZyBzdWJzeXN0ZW0gJXNcbiIsCisJCQlyZXQsIHN1YnN5cy0+c3VfZ3JvdXAuY2dfaXRlbS5jaV9uYW1lYnVmKTsKKwkJZ290byBvdXRfZ2xvYmFsOworCX0KKwlwcmludGsoS0VSTl9JTkZPICJUQVJHRVRfQ09SRVswXTogSW5pdGlhbGl6ZWQgQ29uZmlnRlMgRmFicmljIgorCQkiIEluZnJhc3RydWN0dXJlOiAiVEFSR0VUX0NPUkVfQ09ORklHRlNfVkVSU0lPTiIgb24gJXMvJXMiCisJCSIgb24gIlVUU19SRUxFQVNFIlxuIiwgdXRzbmFtZSgpLT5zeXNuYW1lLCB1dHNuYW1lKCktPm1hY2hpbmUpOworCS8qCisJICogUmVnaXN0ZXIgYnVpbHQtaW4gUkFNRElTSyBzdWJzeXN0ZW0gbG9naWMgZm9yIHZpcnR1YWwgTFVOIDAKKwkgKi8KKwlyZXQgPSByZF9tb2R1bGVfaW5pdCgpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIG91dDsKKworCWlmIChjb3JlX2Rldl9zZXR1cF92aXJ0dWFsX2x1bjAoKSA8IDApCisJCWdvdG8gb3V0OworCisJc2NzaV90YXJnZXRfcHJvYyA9IHByb2NfbWtkaXIoInNjc2lfdGFyZ2V0IiwgMCk7CisJaWYgKCEoc2NzaV90YXJnZXRfcHJvYykpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJwcm9jX21rZGlyKHNjc2lfdGFyZ2V0LCAwKSBmYWlsZWRcbiIpOworCQlnb3RvIG91dDsKKwl9CisJcmV0ID0gaW5pdF9zY3NpX3RhcmdldF9taWIoKTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBvdXQ7CisKKwlyZXR1cm4gMDsKKworb3V0OgorCWNvbmZpZ2ZzX3VucmVnaXN0ZXJfc3Vic3lzdGVtKHN1YnN5cyk7CisJaWYgKHNjc2lfdGFyZ2V0X3Byb2MpCisJCXJlbW92ZV9wcm9jX2VudHJ5KCJzY3NpX3RhcmdldCIsIDApOworCWNvcmVfZGV2X3JlbGVhc2VfdmlydHVhbF9sdW4wKCk7CisJcmRfbW9kdWxlX2V4aXQoKTsKK291dF9nbG9iYWw6CisJaWYgKHNlX2dsb2JhbC0+ZGVmYXVsdF9sdV9ncCkgeworCQljb3JlX2FsdWFfZnJlZV9sdV9ncChzZV9nbG9iYWwtPmRlZmF1bHRfbHVfZ3ApOworCQlzZV9nbG9iYWwtPmRlZmF1bHRfbHVfZ3AgPSBOVUxMOworCX0KKwlpZiAobHVfZ3BfY2cpCisJCWtmcmVlKGx1X2dwX2NnLT5kZWZhdWx0X2dyb3Vwcyk7CisJaWYgKGFsdWFfY2cpCisJCWtmcmVlKGFsdWFfY2ctPmRlZmF1bHRfZ3JvdXBzKTsKKwlpZiAoaGJhX2NnKQorCQlrZnJlZShoYmFfY2ctPmRlZmF1bHRfZ3JvdXBzKTsKKwlrZnJlZSh0YXJnZXRfY2ctPmRlZmF1bHRfZ3JvdXBzKTsKKwlyZWxlYXNlX3NlX2dsb2JhbCgpOworCXJldHVybiAtMTsKK30KKworc3RhdGljIHZvaWQgdGFyZ2V0X2NvcmVfZXhpdF9jb25maWdmcyh2b2lkKQoreworCXN0cnVjdCBjb25maWdmc19zdWJzeXN0ZW0gKnN1YnN5czsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwICpoYmFfY2csICphbHVhX2NnLCAqbHVfZ3BfY2c7CisJc3RydWN0IGNvbmZpZ19pdGVtICppdGVtOworCWludCBpOworCisJc2VfZ2xvYmFsLT5pbl9zaHV0ZG93biA9IDE7CisJc3Vic3lzID0gdGFyZ2V0X2NvcmVfc3Vic3lzdGVtWzBdOworCisJbHVfZ3BfY2cgPSAmc2VfZ2xvYmFsLT5hbHVhX2x1X2dwc19ncm91cDsKKwlmb3IgKGkgPSAwOyBsdV9ncF9jZy0+ZGVmYXVsdF9ncm91cHNbaV07IGkrKykgeworCQlpdGVtID0gJmx1X2dwX2NnLT5kZWZhdWx0X2dyb3Vwc1tpXS0+Y2dfaXRlbTsKKwkJbHVfZ3BfY2ctPmRlZmF1bHRfZ3JvdXBzW2ldID0gTlVMTDsKKwkJY29uZmlnX2l0ZW1fcHV0KGl0ZW0pOworCX0KKwlrZnJlZShsdV9ncF9jZy0+ZGVmYXVsdF9ncm91cHMpOworCWNvcmVfYWx1YV9mcmVlX2x1X2dwKHNlX2dsb2JhbC0+ZGVmYXVsdF9sdV9ncCk7CisJc2VfZ2xvYmFsLT5kZWZhdWx0X2x1X2dwID0gTlVMTDsKKworCWFsdWFfY2cgPSAmc2VfZ2xvYmFsLT5hbHVhX2dyb3VwOworCWZvciAoaSA9IDA7IGFsdWFfY2ctPmRlZmF1bHRfZ3JvdXBzW2ldOyBpKyspIHsKKwkJaXRlbSA9ICZhbHVhX2NnLT5kZWZhdWx0X2dyb3Vwc1tpXS0+Y2dfaXRlbTsKKwkJYWx1YV9jZy0+ZGVmYXVsdF9ncm91cHNbaV0gPSBOVUxMOworCQljb25maWdfaXRlbV9wdXQoaXRlbSk7CisJfQorCWtmcmVlKGFsdWFfY2ctPmRlZmF1bHRfZ3JvdXBzKTsKKworCWhiYV9jZyA9ICZzZV9nbG9iYWwtPnRhcmdldF9jb3JlX2hiYWdyb3VwOworCWZvciAoaSA9IDA7IGhiYV9jZy0+ZGVmYXVsdF9ncm91cHNbaV07IGkrKykgeworCQlpdGVtID0gJmhiYV9jZy0+ZGVmYXVsdF9ncm91cHNbaV0tPmNnX2l0ZW07CisJCWhiYV9jZy0+ZGVmYXVsdF9ncm91cHNbaV0gPSBOVUxMOworCQljb25maWdfaXRlbV9wdXQoaXRlbSk7CisJfQorCWtmcmVlKGhiYV9jZy0+ZGVmYXVsdF9ncm91cHMpOworCisJZm9yIChpID0gMDsgc3Vic3lzLT5zdV9ncm91cC5kZWZhdWx0X2dyb3Vwc1tpXTsgaSsrKSB7CisJCWl0ZW0gPSAmc3Vic3lzLT5zdV9ncm91cC5kZWZhdWx0X2dyb3Vwc1tpXS0+Y2dfaXRlbTsKKwkJc3Vic3lzLT5zdV9ncm91cC5kZWZhdWx0X2dyb3Vwc1tpXSA9IE5VTEw7CisJCWNvbmZpZ19pdGVtX3B1dChpdGVtKTsKKwl9CisJa2ZyZWUoc3Vic3lzLT5zdV9ncm91cC5kZWZhdWx0X2dyb3Vwcyk7CisKKwljb25maWdmc191bnJlZ2lzdGVyX3N1YnN5c3RlbShzdWJzeXMpOworCXByaW50ayhLRVJOX0lORk8gIlRBUkdFVF9DT1JFWzBdOiBSZWxlYXNlZCBDb25maWdGUyBGYWJyaWMiCisJCQkiIEluZnJhc3RydWN0dXJlXG4iKTsKKworCXJlbW92ZV9zY3NpX3RhcmdldF9taWIoKTsKKwlyZW1vdmVfcHJvY19lbnRyeSgic2NzaV90YXJnZXQiLCAwKTsKKwljb3JlX2Rldl9yZWxlYXNlX3ZpcnR1YWxfbHVuMCgpOworCXJkX21vZHVsZV9leGl0KCk7CisJcmVsZWFzZV9zZV9nbG9iYWwoKTsKKworCXJldHVybjsKK30KKworTU9EVUxFX0RFU0NSSVBUSU9OKCJUYXJnZXRfQ29yZV9Nb2QvQ29uZmlnRlMiKTsKK01PRFVMRV9BVVRIT1IoIm5hYkBMaW51eC1pU0NTSS5vcmciKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKKworbW9kdWxlX2luaXQodGFyZ2V0X2NvcmVfaW5pdF9jb25maWdmcyk7Cittb2R1bGVfZXhpdCh0YXJnZXRfY29yZV9leGl0X2NvbmZpZ2ZzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5jIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfZGV2aWNlLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzE3Y2U1OAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5jCkBAIC0wLDAgKzEsMTY5NCBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIEZpbGVuYW1lOiAgdGFyZ2V0X2NvcmVfZGV2aWNlLmMgKGJhc2VkIG9uIGlzY3NpX3RhcmdldF9kZXZpY2UuYykKKyAqCisgKiBUaGlzIGZpbGUgY29udGFpbnMgdGhlIGlTQ1NJIFZpcnR1YWwgRGV2aWNlIGFuZCBEaXNrIFRyYW5zcG9ydAorICogYWdub3N0aWMgcmVsYXRlZCBmdW5jdGlvbnMuCisgKgorICogQ29weXJpZ2h0IChjKSAyMDAzLCAyMDA0LCAyMDA1IFB5WCBUZWNobm9sb2dpZXMsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA2IFNCRSwgSW5jLiAgQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoYykgMjAwNy0yMDEwIFJpc2luZyBUaWRlIFN5c3RlbXMKKyAqIENvcHlyaWdodCAoYykgMjAwOC0yMDEwIExpbnV4LWlTQ1NJLm9yZworICoKKyAqIE5pY2hvbGFzIEEuIEJlbGxpbmdlciA8bmFiQGtlcm5lbC5vcmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisjaW5jbHVkZSA8bGludXgvbmV0Lmg+CisjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC90aW1lci5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgorI2luY2x1ZGUgPGxpbnV4L3NtcF9sb2NrLmg+CisjaW5jbHVkZSA8bGludXgva3RocmVhZC5oPgorI2luY2x1ZGUgPGxpbnV4L2luLmg+CisjaW5jbHVkZSA8bmV0L3NvY2suaD4KKyNpbmNsdWRlIDxuZXQvdGNwLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpLmg+CisKKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfYmFzZS5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdHBnLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX3RyYW5zcG9ydC5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfb3BzLmg+CisKKyNpbmNsdWRlICJ0YXJnZXRfY29yZV9hbHVhLmgiCisjaW5jbHVkZSAidGFyZ2V0X2NvcmVfaGJhLmgiCisjaW5jbHVkZSAidGFyZ2V0X2NvcmVfcHIuaCIKKyNpbmNsdWRlICJ0YXJnZXRfY29yZV91YS5oIgorCitzdGF0aWMgdm9pZCBzZV9kZXZfc3RhcnQoc3RydWN0IHNlX2RldmljZSAqZGV2KTsKK3N0YXRpYyB2b2lkIHNlX2Rldl9zdG9wKHN0cnVjdCBzZV9kZXZpY2UgKmRldik7CisKK2ludCB0cmFuc3BvcnRfZ2V0X2x1bl9mb3JfY21kKAorCXN0cnVjdCBzZV9jbWQgKnNlX2NtZCwKKwl1bnNpZ25lZCBjaGFyICpjZGIsCisJdTMyIHVucGFja2VkX2x1bikKK3sKKwlzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICpkZXZlOworCXN0cnVjdCBzZV9sdW4gKnNlX2x1biA9IE5VTEw7CisJc3RydWN0IHNlX3Nlc3Npb24gKnNlX3Nlc3MgPSBTRV9TRVNTKHNlX2NtZCk7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgcmVhZF9vbmx5ID0gMDsKKworCXNwaW5fbG9ja19pcnEoJlNFX05PREVfQUNMKHNlX3Nlc3MpLT5kZXZpY2VfbGlzdF9sb2NrKTsKKwlkZXZlID0gc2VfY21kLT5zZV9kZXZlID0KKwkJCSZTRV9OT0RFX0FDTChzZV9zZXNzKS0+ZGV2aWNlX2xpc3RbdW5wYWNrZWRfbHVuXTsKKwlpZiAoZGV2ZS0+bHVuX2ZsYWdzICYgVFJBTlNQT1JUX0xVTkZMQUdTX0lOSVRJQVRPUl9BQ0NFU1MpIHsKKwkJaWYgKHNlX2NtZCkgeworCQkJZGV2ZS0+dG90YWxfY21kcysrOworCQkJZGV2ZS0+dG90YWxfYnl0ZXMgKz0gc2VfY21kLT5kYXRhX2xlbmd0aDsKKworCQkJaWYgKHNlX2NtZC0+ZGF0YV9kaXJlY3Rpb24gPT0gRE1BX1RPX0RFVklDRSkgeworCQkJCWlmIChkZXZlLT5sdW5fZmxhZ3MgJgorCQkJCQkJVFJBTlNQT1JUX0xVTkZMQUdTX1JFQURfT05MWSkgeworCQkJCQlyZWFkX29ubHkgPSAxOworCQkJCQlnb3RvIG91dDsKKwkJCQl9CisJCQkJZGV2ZS0+d3JpdGVfYnl0ZXMgKz0gc2VfY21kLT5kYXRhX2xlbmd0aDsKKwkJCX0gZWxzZSBpZiAoc2VfY21kLT5kYXRhX2RpcmVjdGlvbiA9PQorCQkJCSAgIERNQV9GUk9NX0RFVklDRSkgeworCQkJCWRldmUtPnJlYWRfYnl0ZXMgKz0gc2VfY21kLT5kYXRhX2xlbmd0aDsKKwkJCX0KKwkJfQorCQlkZXZlLT5kZXZlX2NtZHMrKzsKKworCQlzZV9sdW4gPSBzZV9jbWQtPnNlX2x1biA9IGRldmUtPnNlX2x1bjsKKwkJc2VfY21kLT5wcl9yZXNfa2V5ID0gZGV2ZS0+cHJfcmVzX2tleTsKKwkJc2VfY21kLT5vcmlnX2ZlX2x1biA9IHVucGFja2VkX2x1bjsKKwkJc2VfY21kLT5zZV9vcmlnX29ial9wdHIgPSBTRV9MVU4oc2VfY21kKS0+bHVuX3NlX2RldjsKKwkJc2VfY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NFX0xVTl9DTUQ7CisJfQorb3V0OgorCXNwaW5fdW5sb2NrX2lycSgmU0VfTk9ERV9BQ0woc2Vfc2VzcyktPmRldmljZV9saXN0X2xvY2spOworCisJaWYgKCFzZV9sdW4pIHsKKwkJaWYgKHJlYWRfb25seSkgeworCQkJc2VfY21kLT5zY3NpX3NlbnNlX3JlYXNvbiA9IFRDTV9XUklURV9QUk9URUNURUQ7CisJCQlzZV9jbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DREJfRVhDRVBUSU9OOworCQkJcHJpbnRrKCJUQVJHRVRfQ09SRVslc106IERldGVjdGVkIFdSSVRFX1BST1RFQ1RFRCBMVU4iCisJCQkJIiBBY2Nlc3MgZm9yIDB4JTA4eFxuIiwKKwkJCQlDTURfVEZPKHNlX2NtZCktPmdldF9mYWJyaWNfbmFtZSgpLAorCQkJCXVucGFja2VkX2x1bik7CisJCQlyZXR1cm4gLTE7CisJCX0gZWxzZSB7CisJCQkvKgorCQkJICogVXNlIHRoZSBzZV9wb3J0YWxfZ3JvdXAtPnRwZ192aXJ0X2x1bjAgdG8gYWxsb3cgZm9yCisJCQkgKiBSRVBPUlRfTFVOUywgZXQgYWwgdG8gYmUgcmV0dXJuZWQgd2hlbiBubyBhY3RpdmUKKwkJCSAqIE1hcHBlZExVTj0wIGV4aXN0cyBmb3IgdGhpcyBJbml0aWF0b3IgUG9ydC4KKwkJCSAqLworCQkJaWYgKHVucGFja2VkX2x1biAhPSAwKSB7CisJCQkJc2VfY21kLT5zY3NpX3NlbnNlX3JlYXNvbiA9IFRDTV9OT05fRVhJU1RFTlRfTFVOOworCQkJCXNlX2NtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0NEQl9FWENFUFRJT047CisJCQkJcHJpbnRrKCJUQVJHRVRfQ09SRVslc106IERldGVjdGVkIE5PTl9FWElTVEVOVF9MVU4iCisJCQkJCSIgQWNjZXNzIGZvciAweCUwOHhcbiIsCisJCQkJCUNNRF9URk8oc2VfY21kKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCQkJCXVucGFja2VkX2x1bik7CisJCQkJcmV0dXJuIC0xOworCQkJfQorCQkJLyoKKwkJCSAqIEZvcmNlIFdSSVRFIFBST1RFQ1QgZm9yIHZpcnR1YWwgTFVOIDAKKwkJCSAqLworCQkJaWYgKChzZV9jbWQtPmRhdGFfZGlyZWN0aW9uICE9IERNQV9GUk9NX0RFVklDRSkgJiYKKwkJCSAgICAoc2VfY21kLT5kYXRhX2RpcmVjdGlvbiAhPSBETUFfTk9ORSkpIHsKKwkJCQlzZV9jbWQtPnNjc2lfc2Vuc2VfcmVhc29uID0gVENNX1dSSVRFX1BST1RFQ1RFRDsKKwkJCQlzZV9jbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DREJfRVhDRVBUSU9OOworCQkJCXJldHVybiAtMTsKKwkJCX0KKyNpZiAwCisJCQlwcmludGsoIlRBUkdFVF9DT1JFWyVzXTogVXNpbmcgdmlydHVhbCBMVU4wISA6LSlcbiIsCisJCQkJQ01EX1RGTyhzZV9jbWQpLT5nZXRfZmFicmljX25hbWUoKSk7CisjZW5kaWYKKwkJCXNlX2x1biA9IHNlX2NtZC0+c2VfbHVuID0gJnNlX3Nlc3MtPnNlX3RwZy0+dHBnX3ZpcnRfbHVuMDsKKwkJCXNlX2NtZC0+b3JpZ19mZV9sdW4gPSAwOworCQkJc2VfY21kLT5zZV9vcmlnX29ial9wdHIgPSBTRV9MVU4oc2VfY21kKS0+bHVuX3NlX2RldjsKKwkJCXNlX2NtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TRV9MVU5fQ01EOworCQl9CisJfQorCS8qCisJICogRGV0ZXJtaW5lIGlmIHRoZSBzdHJ1Y3Qgc2VfbHVuIGlzIG9ubGluZS4KKwkgKi8KKy8qICN3YXJuaW5nIEZJWE1FOiBDaGVjayBmb3IgTFVOX1JFU0VUICsgVU5JVCBBdHRlbnRpb24gKi8KKwlpZiAoc2VfZGV2X2NoZWNrX29ubGluZShzZV9sdW4tPmx1bl9zZV9kZXYpICE9IDApIHsKKwkJc2VfY21kLT5zY3NpX3NlbnNlX3JlYXNvbiA9IFRDTV9OT05fRVhJU1RFTlRfTFVOOworCQlzZV9jbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DREJfRVhDRVBUSU9OOworCQlyZXR1cm4gLTE7CisJfQorCisJeworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IHNlX2x1bi0+bHVuX3NlX2RldjsKKwlzcGluX2xvY2soJmRldi0+c3RhdHNfbG9jayk7CisJZGV2LT5udW1fY21kcysrOworCWlmIChzZV9jbWQtPmRhdGFfZGlyZWN0aW9uID09IERNQV9UT19ERVZJQ0UpCisJCWRldi0+d3JpdGVfYnl0ZXMgKz0gc2VfY21kLT5kYXRhX2xlbmd0aDsKKwllbHNlIGlmIChzZV9jbWQtPmRhdGFfZGlyZWN0aW9uID09IERNQV9GUk9NX0RFVklDRSkKKwkJZGV2LT5yZWFkX2J5dGVzICs9IHNlX2NtZC0+ZGF0YV9sZW5ndGg7CisJc3Bpbl91bmxvY2soJmRldi0+c3RhdHNfbG9jayk7CisJfQorCisJLyoKKwkgKiBBZGQgdGhlIGlzY3NpX2NtZF90IHRvIHRoZSBzdHJ1Y3Qgc2VfbHVuJ3MgY21kIGxpc3QuICBUaGlzIGxpc3QgaXMgdXNlZAorCSAqIGZvciB0cmFja2luZyBzdGF0ZSBvZiBzdHJ1Y3Qgc2VfY21kcyBkdXJpbmcgTFVOIHNodXRkb3duIGV2ZW50cy4KKwkgKi8KKwlzcGluX2xvY2tfaXJxc2F2ZSgmc2VfbHVuLT5sdW5fY21kX2xvY2ssIGZsYWdzKTsKKwlsaXN0X2FkZF90YWlsKCZzZV9jbWQtPnNlX2x1bl9saXN0LCAmc2VfbHVuLT5sdW5fY21kX2xpc3QpOworCWF0b21pY19zZXQoJlRfVEFTSyhzZV9jbWQpLT50cmFuc3BvcnRfbHVuX2FjdGl2ZSwgMSk7CisjaWYgMAorCXByaW50ayhLRVJOX0lORk8gIkFkZGluZyBJVFQ6IDB4JTA4eCB0byBMVU4gTElTVFslZF1cbiIsCisJCUNNRF9URk8oc2VfY21kKS0+Z2V0X3Rhc2tfdGFnKHNlX2NtZCksIHNlX2x1bi0+dW5wYWNrZWRfbHVuKTsKKyNlbmRpZgorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNlX2x1bi0+bHVuX2NtZF9sb2NrLCBmbGFncyk7CisKKwlyZXR1cm4gMDsKK30KK0VYUE9SVF9TWU1CT0wodHJhbnNwb3J0X2dldF9sdW5fZm9yX2NtZCk7CisKK2ludCB0cmFuc3BvcnRfZ2V0X2x1bl9mb3JfdG1yKAorCXN0cnVjdCBzZV9jbWQgKnNlX2NtZCwKKwl1MzIgdW5wYWNrZWRfbHVuKQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IE5VTEw7CisJc3RydWN0IHNlX2Rldl9lbnRyeSAqZGV2ZTsKKwlzdHJ1Y3Qgc2VfbHVuICpzZV9sdW4gPSBOVUxMOworCXN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzID0gU0VfU0VTUyhzZV9jbWQpOworCXN0cnVjdCBzZV90bXJfcmVxICpzZV90bXIgPSBzZV9jbWQtPnNlX3Rtcl9yZXE7CisKKwlzcGluX2xvY2tfaXJxKCZTRV9OT0RFX0FDTChzZV9zZXNzKS0+ZGV2aWNlX2xpc3RfbG9jayk7CisJZGV2ZSA9IHNlX2NtZC0+c2VfZGV2ZSA9CisJCQkmU0VfTk9ERV9BQ0woc2Vfc2VzcyktPmRldmljZV9saXN0W3VucGFja2VkX2x1bl07CisJaWYgKGRldmUtPmx1bl9mbGFncyAmIFRSQU5TUE9SVF9MVU5GTEFHU19JTklUSUFUT1JfQUNDRVNTKSB7CisJCXNlX2x1biA9IHNlX2NtZC0+c2VfbHVuID0gc2VfdG1yLT50bXJfbHVuID0gZGV2ZS0+c2VfbHVuOworCQlkZXYgPSBzZV90bXItPnRtcl9kZXYgPSBzZV9sdW4tPmx1bl9zZV9kZXY7CisJCXNlX2NtZC0+cHJfcmVzX2tleSA9IGRldmUtPnByX3Jlc19rZXk7CisJCXNlX2NtZC0+b3JpZ19mZV9sdW4gPSB1bnBhY2tlZF9sdW47CisJCXNlX2NtZC0+c2Vfb3JpZ19vYmpfcHRyID0gU0VfTFVOKHNlX2NtZCktPmx1bl9zZV9kZXY7CisvKgkJc2VfY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NFX0xVTl9DTUQ7ICovCisJfQorCXNwaW5fdW5sb2NrX2lycSgmU0VfTk9ERV9BQ0woc2Vfc2VzcyktPmRldmljZV9saXN0X2xvY2spOworCisJaWYgKCFzZV9sdW4pIHsKKwkJcHJpbnRrKEtFUk5fSU5GTyAiVEFSR0VUX0NPUkVbJXNdOiBEZXRlY3RlZCBOT05fRVhJU1RFTlRfTFVOIgorCQkJIiBBY2Nlc3MgZm9yIDB4JTA4eFxuIiwKKwkJCUNNRF9URk8oc2VfY21kKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCQl1bnBhY2tlZF9sdW4pOworCQlzZV9jbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DREJfRVhDRVBUSU9OOworCQlyZXR1cm4gLTE7CisJfQorCS8qCisJICogRGV0ZXJtaW5lIGlmIHRoZSBzdHJ1Y3Qgc2VfbHVuIGlzIG9ubGluZS4KKwkgKi8KKy8qICN3YXJuaW5nIEZJWE1FOiBDaGVjayBmb3IgTFVOX1JFU0VUICsgVU5JVCBBdHRlbnRpb24gKi8KKwlpZiAoc2VfZGV2X2NoZWNrX29ubGluZShzZV9sdW4tPmx1bl9zZV9kZXYpICE9IDApIHsKKwkJc2VfY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ0RCX0VYQ0VQVElPTjsKKwkJcmV0dXJuIC0xOworCX0KKworCXNwaW5fbG9jaygmZGV2LT5zZV90bXJfbG9jayk7CisJbGlzdF9hZGRfdGFpbCgmc2VfdG1yLT50bXJfbGlzdCwgJmRldi0+ZGV2X3Rtcl9saXN0KTsKKwlzcGluX3VubG9jaygmZGV2LT5zZV90bXJfbG9jayk7CisKKwlyZXR1cm4gMDsKK30KK0VYUE9SVF9TWU1CT0wodHJhbnNwb3J0X2dldF9sdW5fZm9yX3Rtcik7CisKKy8qCisgKiBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBmcm9tIGNvcmVfc2NzaTNfZW11bGF0ZV9wcm9fcmVnaXN0ZXJfYW5kX21vdmUoKQorICogYW5kIGNvcmVfc2NzaTNfZGVjb2RlX3NwZWNfaV9wb3J0KCksIGFuZCB3aWxsIGluY3JlbWVudCAmZGV2ZS0+cHJfcmVmX2NvdW50CisgKiB3aGVuIGEgbWF0Y2hpbmcgcnRwaSBpcyBmb3VuZC4KKyAqLworc3RydWN0IHNlX2Rldl9lbnRyeSAqY29yZV9nZXRfc2VfZGV2ZV9mcm9tX3J0cGkoCisJc3RydWN0IHNlX25vZGVfYWNsICpuYWNsLAorCXUxNiBydHBpKQoreworCXN0cnVjdCBzZV9kZXZfZW50cnkgKmRldmU7CisJc3RydWN0IHNlX2x1biAqbHVuOworCXN0cnVjdCBzZV9wb3J0ICpwb3J0OworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZyA9IG5hY2wtPnNlX3RwZzsKKwl1MzIgaTsKKworCXNwaW5fbG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCWZvciAoaSA9IDA7IGkgPCBUUkFOU1BPUlRfTUFYX0xVTlNfUEVSX1RQRzsgaSsrKSB7CisJCWRldmUgPSAmbmFjbC0+ZGV2aWNlX2xpc3RbaV07CisKKwkJaWYgKCEoZGV2ZS0+bHVuX2ZsYWdzICYgVFJBTlNQT1JUX0xVTkZMQUdTX0lOSVRJQVRPUl9BQ0NFU1MpKQorCQkJY29udGludWU7CisKKwkJbHVuID0gZGV2ZS0+c2VfbHVuOworCQlpZiAoIShsdW4pKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIiVzIGRldmljZSBlbnRyaWVzIGRldmljZSBwb2ludGVyIGlzIgorCQkJCSIgTlVMTCwgYnV0IEluaXRpYXRvciBoYXMgYWNjZXNzLlxuIiwKKwkJCQlUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpKTsKKwkJCWNvbnRpbnVlOworCQl9CisJCXBvcnQgPSBsdW4tPmx1bl9zZXA7CisJCWlmICghKHBvcnQpKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIiVzIGRldmljZSBlbnRyaWVzIGRldmljZSBwb2ludGVyIGlzIgorCQkJCSIgTlVMTCwgYnV0IEluaXRpYXRvciBoYXMgYWNjZXNzLlxuIiwKKwkJCQlUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpKTsKKwkJCWNvbnRpbnVlOworCQl9CisJCWlmIChwb3J0LT5zZXBfcnRwaSAhPSBydHBpKQorCQkJY29udGludWU7CisKKwkJYXRvbWljX2luYygmZGV2ZS0+cHJfcmVmX2NvdW50KTsKKwkJc21wX21iX19hZnRlcl9hdG9taWNfaW5jKCk7CisJCXNwaW5fdW5sb2NrX2lycSgmbmFjbC0+ZGV2aWNlX2xpc3RfbG9jayk7CisKKwkJcmV0dXJuIGRldmU7CisJfQorCXNwaW5fdW5sb2NrX2lycSgmbmFjbC0+ZGV2aWNlX2xpc3RfbG9jayk7CisKKwlyZXR1cm4gTlVMTDsKK30KKworaW50IGNvcmVfZnJlZV9kZXZpY2VfbGlzdF9mb3Jfbm9kZSgKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKm5hY2wsCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnKQoreworCXN0cnVjdCBzZV9kZXZfZW50cnkgKmRldmU7CisJc3RydWN0IHNlX2x1biAqbHVuOworCXUzMiBpOworCisJaWYgKCFuYWNsLT5kZXZpY2VfbGlzdCkKKwkJcmV0dXJuIDA7CisKKwlzcGluX2xvY2tfaXJxKCZuYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKwlmb3IgKGkgPSAwOyBpIDwgVFJBTlNQT1JUX01BWF9MVU5TX1BFUl9UUEc7IGkrKykgeworCQlkZXZlID0gJm5hY2wtPmRldmljZV9saXN0W2ldOworCisJCWlmICghKGRldmUtPmx1bl9mbGFncyAmIFRSQU5TUE9SVF9MVU5GTEFHU19JTklUSUFUT1JfQUNDRVNTKSkKKwkJCWNvbnRpbnVlOworCisJCWlmICghZGV2ZS0+c2VfbHVuKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIiVzIGRldmljZSBlbnRyaWVzIGRldmljZSBwb2ludGVyIGlzIgorCQkJCSIgTlVMTCwgYnV0IEluaXRpYXRvciBoYXMgYWNjZXNzLlxuIiwKKwkJCQlUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpKTsKKwkJCWNvbnRpbnVlOworCQl9CisJCWx1biA9IGRldmUtPnNlX2x1bjsKKworCQlzcGluX3VubG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCQljb3JlX3VwZGF0ZV9kZXZpY2VfbGlzdF9mb3Jfbm9kZShsdW4sIE5VTEwsIGRldmUtPm1hcHBlZF9sdW4sCisJCQlUUkFOU1BPUlRfTFVORkxBR1NfTk9fQUNDRVNTLCBuYWNsLCB0cGcsIDApOworCQlzcGluX2xvY2tfaXJxKCZuYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKwl9CisJc3Bpbl91bmxvY2tfaXJxKCZuYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKworCWtmcmVlKG5hY2wtPmRldmljZV9saXN0KTsKKwluYWNsLT5kZXZpY2VfbGlzdCA9IE5VTEw7CisKKwlyZXR1cm4gMDsKK30KKwordm9pZCBjb3JlX2RlY19sYWNsX2NvdW50KHN0cnVjdCBzZV9ub2RlX2FjbCAqc2VfbmFjbCwgc3RydWN0IHNlX2NtZCAqc2VfY21kKQoreworCXN0cnVjdCBzZV9kZXZfZW50cnkgKmRldmU7CisKKwlzcGluX2xvY2tfaXJxKCZzZV9uYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKwlkZXZlID0gJnNlX25hY2wtPmRldmljZV9saXN0W3NlX2NtZC0+b3JpZ19mZV9sdW5dOworCWRldmUtPmRldmVfY21kcy0tOworCXNwaW5fdW5sb2NrX2lycSgmc2VfbmFjbC0+ZGV2aWNlX2xpc3RfbG9jayk7CisKKwlyZXR1cm47Cit9CisKK3ZvaWQgY29yZV91cGRhdGVfZGV2aWNlX2xpc3RfYWNjZXNzKAorCXUzMiBtYXBwZWRfbHVuLAorCXUzMiBsdW5fYWNjZXNzLAorCXN0cnVjdCBzZV9ub2RlX2FjbCAqbmFjbCkKK3sKKwlzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICpkZXZlOworCisJc3Bpbl9sb2NrX2lycSgmbmFjbC0+ZGV2aWNlX2xpc3RfbG9jayk7CisJZGV2ZSA9ICZuYWNsLT5kZXZpY2VfbGlzdFttYXBwZWRfbHVuXTsKKwlpZiAobHVuX2FjY2VzcyAmIFRSQU5TUE9SVF9MVU5GTEFHU19SRUFEX1dSSVRFKSB7CisJCWRldmUtPmx1bl9mbGFncyAmPSB+VFJBTlNQT1JUX0xVTkZMQUdTX1JFQURfT05MWTsKKwkJZGV2ZS0+bHVuX2ZsYWdzIHw9IFRSQU5TUE9SVF9MVU5GTEFHU19SRUFEX1dSSVRFOworCX0gZWxzZSB7CisJCWRldmUtPmx1bl9mbGFncyAmPSB+VFJBTlNQT1JUX0xVTkZMQUdTX1JFQURfV1JJVEU7CisJCWRldmUtPmx1bl9mbGFncyB8PSBUUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9PTkxZOworCX0KKwlzcGluX3VubG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCisJcmV0dXJuOworfQorCisvKiAgICAgIGNvcmVfdXBkYXRlX2RldmljZV9saXN0X2Zvcl9ub2RlKCk6CisgKgorICoKKyAqLworaW50IGNvcmVfdXBkYXRlX2RldmljZV9saXN0X2Zvcl9ub2RlKAorCXN0cnVjdCBzZV9sdW4gKmx1biwKKwlzdHJ1Y3Qgc2VfbHVuX2FjbCAqbHVuX2FjbCwKKwl1MzIgbWFwcGVkX2x1biwKKwl1MzIgbHVuX2FjY2VzcywKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKm5hY2wsCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnLAorCWludCBlbmFibGUpCit7CisJc3RydWN0IHNlX3BvcnQgKnBvcnQgPSBsdW4tPmx1bl9zZXA7CisJc3RydWN0IHNlX2Rldl9lbnRyeSAqZGV2ZSA9ICZuYWNsLT5kZXZpY2VfbGlzdFttYXBwZWRfbHVuXTsKKwlpbnQgdHJhbnMgPSAwOworCS8qCisJICogSWYgdGhlIE1hcHBlZExVTiBlbnRyeSBpcyBiZWluZyBkaXNhYmxlZCwgdGhlIGVudHJ5IGluCisJICogcG9ydC0+c2VwX2FsdWFfbGlzdCBtdXN0IGJlIHJlbW92ZWQgbm93IGJlZm9yZSBjbGVhcmluZyB0aGUKKwkgKiBzdHJ1Y3Qgc2VfZGV2X2VudHJ5IHBvaW50ZXJzIGJlbG93IGFzIGxvZ2ljIGluCisJICogY29yZV9hbHVhX2RvX3RyYW5zaXRpb25fdGdfcHQoKSBkZXBlbmRzIG9uIHRoZXNlIGJlaW5nIHByZXNlbnQuCisJICovCisJaWYgKCEoZW5hYmxlKSkgeworCQkvKgorCQkgKiBkZXZlLT5zZV9sdW5fYWNsIHdpbGwgYmUgTlVMTCBmb3IgZGVtby1tb2RlIGNyZWF0ZWQgTFVOcworCQkgKiB0aGF0IGhhdmUgbm90IGJlZW4gZXhwbGljdGx5IGNvbmNlcnRlZCB0byBNYXBwZWRMVU5zIC0+CisJCSAqIHN0cnVjdCBzZV9sdW5fYWNsLgorCQkgKi8KKwkJaWYgKCEoZGV2ZS0+c2VfbHVuX2FjbCkpCisJCQlyZXR1cm4gMDsKKworCQlzcGluX2xvY2tfYmgoJnBvcnQtPnNlcF9hbHVhX2xvY2spOworCQlsaXN0X2RlbCgmZGV2ZS0+YWx1YV9wb3J0X2xpc3QpOworCQlzcGluX3VubG9ja19iaCgmcG9ydC0+c2VwX2FsdWFfbG9jayk7CisJfQorCisJc3Bpbl9sb2NrX2lycSgmbmFjbC0+ZGV2aWNlX2xpc3RfbG9jayk7CisJaWYgKGVuYWJsZSkgeworCQkvKgorCQkgKiBDaGVjayBpZiB0aGUgY2FsbCBpcyBoYW5kbGluZyBkZW1vIG1vZGUgLT4gZXhwbGljdCBMVU4gQUNMCisJCSAqIHRyYW5zaXRpb24uICBUaGlzIHRyYW5zaXRpb24gbXVzdCBiZSBmb3IgdGhlIHNhbWUgc3RydWN0IHNlX2x1bgorCQkgKiArIG1hcHBlZF9sdW4gdGhhdCB3YXMgc2V0dXAgaW4gZGVtbyBtb2RlLi4KKwkJICovCisJCWlmIChkZXZlLT5sdW5fZmxhZ3MgJiBUUkFOU1BPUlRfTFVORkxBR1NfSU5JVElBVE9SX0FDQ0VTUykgeworCQkJaWYgKGRldmUtPnNlX2x1bl9hY2wgIT0gTlVMTCkgeworCQkJCXByaW50ayhLRVJOX0VSUiAic3RydWN0IHNlX2Rldl9lbnRyeS0+c2VfbHVuX2FjbCIKKwkJCQkJIiBhbHJlYWR5IHNldCBmb3IgZGVtbyBtb2RlIC0+IGV4cGxpY3QiCisJCQkJCSIgTFVOIEFDTCB0cmFuc2l0aW9uXG4iKTsKKwkJCQlyZXR1cm4gLTE7CisJCQl9CisJCQlpZiAoZGV2ZS0+c2VfbHVuICE9IGx1bikgeworCQkJCXByaW50ayhLRVJOX0VSUiAic3RydWN0IHNlX2Rldl9lbnRyeS0+c2VfbHVuIGRvZXMiCisJCQkJCSIgbWF0Y2ggcGFzc2VkIHN0cnVjdCBzZV9sdW4gZm9yIGRlbW8gbW9kZSIKKwkJCQkJIiAtPiBleHBsaWN0IExVTiBBQ0wgdHJhbnNpdGlvblxuIik7CisJCQkJcmV0dXJuIC0xOworCQkJfQorCQkJZGV2ZS0+c2VfbHVuX2FjbCA9IGx1bl9hY2w7CisJCQl0cmFucyA9IDE7CisJCX0gZWxzZSB7CisJCQlkZXZlLT5zZV9sdW4gPSBsdW47CisJCQlkZXZlLT5zZV9sdW5fYWNsID0gbHVuX2FjbDsKKwkJCWRldmUtPm1hcHBlZF9sdW4gPSBtYXBwZWRfbHVuOworCQkJZGV2ZS0+bHVuX2ZsYWdzIHw9IFRSQU5TUE9SVF9MVU5GTEFHU19JTklUSUFUT1JfQUNDRVNTOworCQl9CisKKwkJaWYgKGx1bl9hY2Nlc3MgJiBUUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9XUklURSkgeworCQkJZGV2ZS0+bHVuX2ZsYWdzICY9IH5UUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9PTkxZOworCQkJZGV2ZS0+bHVuX2ZsYWdzIHw9IFRSQU5TUE9SVF9MVU5GTEFHU19SRUFEX1dSSVRFOworCQl9IGVsc2UgeworCQkJZGV2ZS0+bHVuX2ZsYWdzICY9IH5UUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9XUklURTsKKwkJCWRldmUtPmx1bl9mbGFncyB8PSBUUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9PTkxZOworCQl9CisKKwkJaWYgKHRyYW5zKSB7CisJCQlzcGluX3VubG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCQkJcmV0dXJuIDA7CisJCX0KKwkJZGV2ZS0+Y3JlYXRpb25fdGltZSA9IGdldF9qaWZmaWVzXzY0KCk7CisJCWRldmUtPmF0dGFjaF9jb3VudCsrOworCQlzcGluX3VubG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCisJCXNwaW5fbG9ja19iaCgmcG9ydC0+c2VwX2FsdWFfbG9jayk7CisJCWxpc3RfYWRkX3RhaWwoJmRldmUtPmFsdWFfcG9ydF9saXN0LCAmcG9ydC0+c2VwX2FsdWFfbGlzdCk7CisJCXNwaW5fdW5sb2NrX2JoKCZwb3J0LT5zZXBfYWx1YV9sb2NrKTsKKworCQlyZXR1cm4gMDsKKwl9CisJLyoKKwkgKiBXYWl0IGZvciBhbnkgaW4gcHJvY2VzcyBTUEVDX0lfUFQ9MSBvciBSRUdJU1RFUl9BTkRfTU9WRQorCSAqIFBSIG9wZXJhdGlvbiB0byBjb21wbGV0ZS4KKwkgKi8KKwlzcGluX3VubG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCXdoaWxlIChhdG9taWNfcmVhZCgmZGV2ZS0+cHJfcmVmX2NvdW50KSAhPSAwKQorCQljcHVfcmVsYXgoKTsKKwlzcGluX2xvY2tfaXJxKCZuYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKwkvKgorCSAqIERpc2FibGUgc3RydWN0IHNlX2Rldl9lbnRyeSBMVU4gQUNMIG1hcHBpbmcKKwkgKi8KKwljb3JlX3Njc2kzX3VhX3JlbGVhc2VfYWxsKGRldmUpOworCWRldmUtPnNlX2x1biA9IE5VTEw7CisJZGV2ZS0+c2VfbHVuX2FjbCA9IE5VTEw7CisJZGV2ZS0+bHVuX2ZsYWdzID0gMDsKKwlkZXZlLT5jcmVhdGlvbl90aW1lID0gMDsKKwlkZXZlLT5hdHRhY2hfY291bnQtLTsKKwlzcGluX3VubG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCisJY29yZV9zY3NpM19mcmVlX3ByX3JlZ19mcm9tX25hY2wobHVuLT5sdW5fc2VfZGV2LCBuYWNsKTsKKwlyZXR1cm4gMDsKK30KKworLyogICAgICBjb3JlX2NsZWFyX2x1bl9mcm9tX3RwZygpOgorICoKKyAqCisgKi8KK3ZvaWQgY29yZV9jbGVhcl9sdW5fZnJvbV90cGcoc3RydWN0IHNlX2x1biAqbHVuLCBzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcpCit7CisJc3RydWN0IHNlX25vZGVfYWNsICpuYWNsOworCXN0cnVjdCBzZV9kZXZfZW50cnkgKmRldmU7CisJdTMyIGk7CisKKwlzcGluX2xvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShuYWNsLCAmdHBnLT5hY2xfbm9kZV9saXN0LCBhY2xfbGlzdCkgeworCQlzcGluX3VubG9ja19iaCgmdHBnLT5hY2xfbm9kZV9sb2NrKTsKKworCQlzcGluX2xvY2tfaXJxKCZuYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKwkJZm9yIChpID0gMDsgaSA8IFRSQU5TUE9SVF9NQVhfTFVOU19QRVJfVFBHOyBpKyspIHsKKwkJCWRldmUgPSAmbmFjbC0+ZGV2aWNlX2xpc3RbaV07CisJCQlpZiAobHVuICE9IGRldmUtPnNlX2x1bikKKwkJCQljb250aW51ZTsKKwkJCXNwaW5fdW5sb2NrX2lycSgmbmFjbC0+ZGV2aWNlX2xpc3RfbG9jayk7CisKKwkJCWNvcmVfdXBkYXRlX2RldmljZV9saXN0X2Zvcl9ub2RlKGx1biwgTlVMTCwKKwkJCQlkZXZlLT5tYXBwZWRfbHVuLCBUUkFOU1BPUlRfTFVORkxBR1NfTk9fQUNDRVNTLAorCQkJCW5hY2wsIHRwZywgMCk7CisKKwkJCXNwaW5fbG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCQl9CisJCXNwaW5fdW5sb2NrX2lycSgmbmFjbC0+ZGV2aWNlX2xpc3RfbG9jayk7CisKKwkJc3Bpbl9sb2NrX2JoKCZ0cGctPmFjbF9ub2RlX2xvY2spOworCX0KKwlzcGluX3VubG9ja19iaCgmdHBnLT5hY2xfbm9kZV9sb2NrKTsKKworCXJldHVybjsKK30KKworc3RhdGljIHN0cnVjdCBzZV9wb3J0ICpjb3JlX2FsbG9jX3BvcnQoc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBzZV9wb3J0ICpwb3J0LCAqcG9ydF90bXA7CisKKwlwb3J0ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHNlX3BvcnQpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIShwb3J0KSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBzdHJ1Y3Qgc2VfcG9ydFxuIik7CisJCXJldHVybiBOVUxMOworCX0KKwlJTklUX0xJU1RfSEVBRCgmcG9ydC0+c2VwX2FsdWFfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJnBvcnQtPnNlcF9saXN0KTsKKwlhdG9taWNfc2V0KCZwb3J0LT5zZXBfdGdfcHRfc2Vjb25kYXJ5X29mZmxpbmUsIDApOworCXNwaW5fbG9ja19pbml0KCZwb3J0LT5zZXBfYWx1YV9sb2NrKTsKKwltdXRleF9pbml0KCZwb3J0LT5zZXBfdGdfcHRfbWRfbXV0ZXgpOworCisJc3Bpbl9sb2NrKCZkZXYtPnNlX3BvcnRfbG9jayk7CisJaWYgKGRldi0+ZGV2X3BvcnRfY291bnQgPT0gMHgwMDAwZmZmZikgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJSZWFjaGVkIGRldi0+ZGV2X3BvcnRfY291bnQgPT0iCisJCQkJIiAweDAwMDBmZmZmXG4iKTsKKwkJc3Bpbl91bmxvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorYWdhaW46CisJLyoKKwkgKiBBbGxvY2F0ZSB0aGUgbmV4dCBSRUxBVElWRSBUQVJHRVQgUE9SVCBJREVOVElGRVIgZm9yIHRoaXMgc3RydWN0IHNlX2RldmljZQorCSAqIEhlcmUgaXMgdGhlIHRhYmxlIGZyb20gc3BjNHIxNyBzZWN0aW9uIDcuNy4zLjguCisJICoKKwkgKiAgICBUYWJsZSA0NzMgLS0gUkVMQVRJVkUgVEFSR0VUIFBPUlQgSURFTlRJRklFUiBmaWVsZAorCSAqCisJICogQ29kZSAgICAgIERlc2NyaXB0aW9uCisJICogMGggICAgICAgIFJlc2VydmVkCisJICogMWggICAgICAgIFJlbGF0aXZlIHBvcnQgMSwgaGlzdG9yaWNhbGx5IGtub3duIGFzIHBvcnQgQQorCSAqIDJoICAgICAgICBSZWxhdGl2ZSBwb3J0IDIsIGhpc3RvcmljYWxseSBrbm93biBhcyBwb3J0IEIKKwkgKiAzaCB0byBGRkZGaCAgICBSZWxhdGl2ZSBwb3J0IDMgdGhyb3VnaCA2NSA1MzUKKwkgKi8KKwlwb3J0LT5zZXBfcnRwaSA9IGRldi0+ZGV2X3JwdGlfY291bnRlcisrOworCWlmICghKHBvcnQtPnNlcF9ydHBpKSkKKwkJZ290byBhZ2FpbjsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkocG9ydF90bXAsICZkZXYtPmRldl9zZXBfbGlzdCwgc2VwX2xpc3QpIHsKKwkJLyoKKwkJICogTWFrZSBzdXJlIFJFTEFUSVZFIFRBUkdFVCBQT1JUIElERU5USUZFUiBpcyB1bmlxdWUKKwkJICogZm9yIDE2LWJpdCB3cmFwLi4KKwkJICovCisJCWlmIChwb3J0LT5zZXBfcnRwaSA9PSBwb3J0X3RtcC0+c2VwX3J0cGkpCisJCQlnb3RvIGFnYWluOworCX0KKwlzcGluX3VubG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCisJcmV0dXJuIHBvcnQ7Cit9CisKK3N0YXRpYyB2b2lkIGNvcmVfZXhwb3J0X3BvcnQoCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZywKKwlzdHJ1Y3Qgc2VfcG9ydCAqcG9ydCwKKwlzdHJ1Y3Qgc2VfbHVuICpsdW4pCit7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnN1X2RldiA9IFNVX0RFVihkZXYpOworCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncF9tZW1iZXIgKnRnX3B0X2dwX21lbSA9IE5VTEw7CisKKwlzcGluX2xvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKwlzcGluX2xvY2soJmx1bi0+bHVuX3NlcF9sb2NrKTsKKwlwb3J0LT5zZXBfdHBnID0gdHBnOworCXBvcnQtPnNlcF9sdW4gPSBsdW47CisJbHVuLT5sdW5fc2VwID0gcG9ydDsKKwlzcGluX3VubG9jaygmbHVuLT5sdW5fc2VwX2xvY2spOworCisJbGlzdF9hZGRfdGFpbCgmcG9ydC0+c2VwX2xpc3QsICZkZXYtPmRldl9zZXBfbGlzdCk7CisJc3Bpbl91bmxvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKworCWlmIChUMTBfQUxVQShzdV9kZXYpLT5hbHVhX3R5cGUgPT0gU1BDM19BTFVBX0VNVUxBVEVEKSB7CisJCXRnX3B0X2dwX21lbSA9IGNvcmVfYWx1YV9hbGxvY2F0ZV90Z19wdF9ncF9tZW0ocG9ydCk7CisJCWlmIChJU19FUlIodGdfcHRfZ3BfbWVtKSB8fCAhdGdfcHRfZ3BfbWVtKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSB0MTBfYWx1YV90Z19wdCIKKwkJCQkJIl9ncF9tZW1iZXJfdFxuIik7CisJCQlyZXR1cm47CisJCX0KKwkJc3Bpbl9sb2NrKCZ0Z19wdF9ncF9tZW0tPnRnX3B0X2dwX21lbV9sb2NrKTsKKwkJX19jb3JlX2FsdWFfYXR0YWNoX3RnX3B0X2dwX21lbSh0Z19wdF9ncF9tZW0sCisJCQlUMTBfQUxVQShzdV9kZXYpLT5kZWZhdWx0X3RnX3B0X2dwKTsKKwkJc3Bpbl91bmxvY2soJnRnX3B0X2dwX21lbS0+dGdfcHRfZ3BfbWVtX2xvY2spOworCQlwcmludGsoS0VSTl9JTkZPICIlcy8lczogQWRkaW5nIHRvIGRlZmF1bHQgQUxVQSBUYXJnZXQgUG9ydCIKKwkJCSIgR3JvdXA6IGFsdWEvZGVmYXVsdF90Z19wdF9ncFxuIiwKKwkJCVRSQU5TUE9SVChkZXYpLT5uYW1lLCBUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpKTsKKwl9CisKKwlkZXYtPmRldl9wb3J0X2NvdW50Kys7CisJcG9ydC0+c2VwX2luZGV4ID0gcG9ydC0+c2VwX3J0cGk7IC8qIFJFTEFUSVZFIFRBUkdFVCBQT1JUIElERU5USUZFUiAqLworfQorCisvKgorICoJQ2FsbGVkIHdpdGggc3RydWN0IHNlX2RldmljZS0+c2VfcG9ydF9sb2NrIHNwaW5sb2NrIGhlbGQuCisgKi8KK3N0YXRpYyB2b2lkIGNvcmVfcmVsZWFzZV9wb3J0KHN0cnVjdCBzZV9kZXZpY2UgKmRldiwgc3RydWN0IHNlX3BvcnQgKnBvcnQpCit7CisJLyoKKwkgKiBXYWl0IGZvciBhbnkgcG9ydCByZWZlcmVuY2UgZm9yIFBSIEFMTF9UR19QVD0xIG9wZXJhdGlvbgorCSAqIHRvIGNvbXBsZXRlIGluIF9fY29yZV9zY3NpM19hbGxvY19yZWdpc3RyYXRpb24oKQorCSAqLworCXNwaW5fdW5sb2NrKCZkZXYtPnNlX3BvcnRfbG9jayk7CisJaWYgKGF0b21pY19yZWFkKCZwb3J0LT5zZXBfdGdfcHRfcmVmX2NudCkpCisJCWNwdV9yZWxheCgpOworCXNwaW5fbG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCisJY29yZV9hbHVhX2ZyZWVfdGdfcHRfZ3BfbWVtKHBvcnQpOworCisJbGlzdF9kZWwoJnBvcnQtPnNlcF9saXN0KTsKKwlkZXYtPmRldl9wb3J0X2NvdW50LS07CisJa2ZyZWUocG9ydCk7CisKKwlyZXR1cm47Cit9CisKK2ludCBjb3JlX2Rldl9leHBvcnQoCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZywKKwlzdHJ1Y3Qgc2VfbHVuICpsdW4pCit7CisJc3RydWN0IHNlX3BvcnQgKnBvcnQ7CisKKwlwb3J0ID0gY29yZV9hbGxvY19wb3J0KGRldik7CisJaWYgKCEocG9ydCkpCisJCXJldHVybiAtMTsKKworCWx1bi0+bHVuX3NlX2RldiA9IGRldjsKKwlzZV9kZXZfc3RhcnQoZGV2KTsKKworCWF0b21pY19pbmMoJmRldi0+ZGV2X2V4cG9ydF9vYmoub2JqX2FjY2Vzc19jb3VudCk7CisJY29yZV9leHBvcnRfcG9ydChkZXYsIHRwZywgcG9ydCwgbHVuKTsKKwlyZXR1cm4gMDsKK30KKwordm9pZCBjb3JlX2Rldl91bmV4cG9ydCgKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnLAorCXN0cnVjdCBzZV9sdW4gKmx1bikKK3sKKwlzdHJ1Y3Qgc2VfcG9ydCAqcG9ydCA9IGx1bi0+bHVuX3NlcDsKKworCXNwaW5fbG9jaygmbHVuLT5sdW5fc2VwX2xvY2spOworCWlmIChsdW4tPmx1bl9zZV9kZXYgPT0gTlVMTCkgeworCQlzcGluX3VubG9jaygmbHVuLT5sdW5fc2VwX2xvY2spOworCQlyZXR1cm47CisJfQorCXNwaW5fdW5sb2NrKCZsdW4tPmx1bl9zZXBfbG9jayk7CisKKwlzcGluX2xvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKwlhdG9taWNfZGVjKCZkZXYtPmRldl9leHBvcnRfb2JqLm9ial9hY2Nlc3NfY291bnQpOworCWNvcmVfcmVsZWFzZV9wb3J0KGRldiwgcG9ydCk7CisJc3Bpbl91bmxvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKworCXNlX2Rldl9zdG9wKGRldik7CisJbHVuLT5sdW5fc2VfZGV2ID0gTlVMTDsKK30KKworaW50IHRyYW5zcG9ydF9jb3JlX3JlcG9ydF9sdW5fcmVzcG9uc2Uoc3RydWN0IHNlX2NtZCAqc2VfY21kKQoreworCXN0cnVjdCBzZV9kZXZfZW50cnkgKmRldmU7CisJc3RydWN0IHNlX2x1biAqc2VfbHVuOworCXN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzID0gU0VfU0VTUyhzZV9jbWQpOworCXN0cnVjdCBzZV90YXNrICpzZV90YXNrOworCXVuc2lnbmVkIGNoYXIgKmJ1ZiA9ICh1bnNpZ25lZCBjaGFyICopVF9UQVNLKHNlX2NtZCktPnRfdGFza19idWY7CisJdTMyIGNkYl9vZmZzZXQgPSAwLCBsdW5fY291bnQgPSAwLCBvZmZzZXQgPSA4OworCXU2NCBpLCBsdW47CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHNlX3Rhc2ssICZUX1RBU0soc2VfY21kKS0+dF90YXNrX2xpc3QsIHRfbGlzdCkKKwkJYnJlYWs7CisKKwlpZiAoIShzZV90YXNrKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2NhdGUgc3RydWN0IHNlX3Rhc2sgZm9yIHN0cnVjdCBzZV9jbWRcbiIpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9MVV9DT01NX0ZBSUxVUkU7CisJfQorCisJLyoKKwkgKiBJZiBubyBzdHJ1Y3Qgc2Vfc2Vzc2lvbiBwb2ludGVyIGlzIHByZXNlbnQsIHRoaXMgc3RydWN0IHNlX2NtZCBpcworCSAqIGNvbWluZyB2aWEgYSB0YXJnZXRfY29yZV9tb2QgUEFTU1RIUk9VR0ggb3AsIGFuZCBub3QgdGhyb3VnaAorCSAqIGEgJEZBQlJJQ19NT0QuICBJbiB0aGF0IGNhc2UsIHJlcG9ydCBMVU49MCBvbmx5LgorCSAqLworCWlmICghKHNlX3Nlc3MpKSB7CisJCWx1biA9IDA7CisJCWJ1ZltvZmZzZXQrK10gPSAoKGx1biA+PiA1NikgJiAweGZmKTsKKwkJYnVmW29mZnNldCsrXSA9ICgobHVuID4+IDQ4KSAmIDB4ZmYpOworCQlidWZbb2Zmc2V0KytdID0gKChsdW4gPj4gNDApICYgMHhmZik7CisJCWJ1ZltvZmZzZXQrK10gPSAoKGx1biA+PiAzMikgJiAweGZmKTsKKwkJYnVmW29mZnNldCsrXSA9ICgobHVuID4+IDI0KSAmIDB4ZmYpOworCQlidWZbb2Zmc2V0KytdID0gKChsdW4gPj4gMTYpICYgMHhmZik7CisJCWJ1ZltvZmZzZXQrK10gPSAoKGx1biA+PiA4KSAmIDB4ZmYpOworCQlidWZbb2Zmc2V0KytdID0gKGx1biAmIDB4ZmYpOworCQlsdW5fY291bnQgPSAxOworCQlnb3RvIGRvbmU7CisJfQorCisJc3Bpbl9sb2NrX2lycSgmU0VfTk9ERV9BQ0woc2Vfc2VzcyktPmRldmljZV9saXN0X2xvY2spOworCWZvciAoaSA9IDA7IGkgPCBUUkFOU1BPUlRfTUFYX0xVTlNfUEVSX1RQRzsgaSsrKSB7CisJCWRldmUgPSAmU0VfTk9ERV9BQ0woc2Vfc2VzcyktPmRldmljZV9saXN0W2ldOworCQlpZiAoIShkZXZlLT5sdW5fZmxhZ3MgJiBUUkFOU1BPUlRfTFVORkxBR1NfSU5JVElBVE9SX0FDQ0VTUykpCisJCQljb250aW51ZTsKKwkJc2VfbHVuID0gZGV2ZS0+c2VfbHVuOworCQkvKgorCQkgKiBXZSBkZXRlcm1pbmUgdGhlIGNvcnJlY3QgTFVOIExJU1QgTEVOR1RIIGV2ZW4gb25jZSB3ZQorCQkgKiBoYXZlIHJlYWNoZWQgdGhlIGluaXRpYWwgYWxsb2NhdGlvbiBsZW5ndGguCisJCSAqIFNlZSBTUEMyLVIyMCA3LjE5LgorCQkgKi8KKwkJbHVuX2NvdW50Kys7CisJCWlmICgoY2RiX29mZnNldCArIDgpID49IHNlX2NtZC0+ZGF0YV9sZW5ndGgpCisJCQljb250aW51ZTsKKworCQlsdW4gPSBjcHVfdG9fYmU2NChDTURfVEZPKHNlX2NtZCktPnBhY2tfbHVuKGRldmUtPm1hcHBlZF9sdW4pKTsKKwkJYnVmW29mZnNldCsrXSA9ICgobHVuID4+IDU2KSAmIDB4ZmYpOworCQlidWZbb2Zmc2V0KytdID0gKChsdW4gPj4gNDgpICYgMHhmZik7CisJCWJ1ZltvZmZzZXQrK10gPSAoKGx1biA+PiA0MCkgJiAweGZmKTsKKwkJYnVmW29mZnNldCsrXSA9ICgobHVuID4+IDMyKSAmIDB4ZmYpOworCQlidWZbb2Zmc2V0KytdID0gKChsdW4gPj4gMjQpICYgMHhmZik7CisJCWJ1ZltvZmZzZXQrK10gPSAoKGx1biA+PiAxNikgJiAweGZmKTsKKwkJYnVmW29mZnNldCsrXSA9ICgobHVuID4+IDgpICYgMHhmZik7CisJCWJ1ZltvZmZzZXQrK10gPSAobHVuICYgMHhmZik7CisJCWNkYl9vZmZzZXQgKz0gODsKKwl9CisJc3Bpbl91bmxvY2tfaXJxKCZTRV9OT0RFX0FDTChzZV9zZXNzKS0+ZGV2aWNlX2xpc3RfbG9jayk7CisKKwkvKgorCSAqIFNlZSBTUEMzIHIwNywgcGFnZSAxNTkuCisJICovCitkb25lOgorCWx1bl9jb3VudCAqPSA4OworCWJ1ZlswXSA9ICgobHVuX2NvdW50ID4+IDI0KSAmIDB4ZmYpOworCWJ1ZlsxXSA9ICgobHVuX2NvdW50ID4+IDE2KSAmIDB4ZmYpOworCWJ1ZlsyXSA9ICgobHVuX2NvdW50ID4+IDgpICYgMHhmZik7CisJYnVmWzNdID0gKGx1bl9jb3VudCAmIDB4ZmYpOworCisJcmV0dXJuIFBZWF9UUkFOU1BPUlRfU0VOVF9UT19UUkFOU1BPUlQ7Cit9CisKKy8qCXNlX3JlbGVhc2VfZGV2aWNlX2Zvcl9oYmEoKToKKyAqCisgKgorICovCit2b2lkIHNlX3JlbGVhc2VfZGV2aWNlX2Zvcl9oYmEoc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBzZV9oYmEgKmhiYSA9IGRldi0+c2VfaGJhOworCisJaWYgKChkZXYtPmRldl9zdGF0dXMgJiBUUkFOU1BPUlRfREVWSUNFX0FDVElWQVRFRCkgfHwKKwkgICAgKGRldi0+ZGV2X3N0YXR1cyAmIFRSQU5TUE9SVF9ERVZJQ0VfREVBQ1RJVkFURUQpIHx8CisJICAgIChkZXYtPmRldl9zdGF0dXMgJiBUUkFOU1BPUlRfREVWSUNFX1NIVVRET1dOKSB8fAorCSAgICAoZGV2LT5kZXZfc3RhdHVzICYgVFJBTlNQT1JUX0RFVklDRV9PRkZMSU5FX0FDVElWQVRFRCkgfHwKKwkgICAgKGRldi0+ZGV2X3N0YXR1cyAmIFRSQU5TUE9SVF9ERVZJQ0VfT0ZGTElORV9ERUFDVElWQVRFRCkpCisJCXNlX2Rldl9zdG9wKGRldik7CisKKwlpZiAoZGV2LT5kZXZfcHRyKSB7CisJCWt0aHJlYWRfc3RvcChkZXYtPnByb2Nlc3NfdGhyZWFkKTsKKwkJaWYgKGRldi0+dHJhbnNwb3J0LT5mcmVlX2RldmljZSkKKwkJCWRldi0+dHJhbnNwb3J0LT5mcmVlX2RldmljZShkZXYtPmRldl9wdHIpOworCX0KKworCXNwaW5fbG9jaygmaGJhLT5kZXZpY2VfbG9jayk7CisJbGlzdF9kZWwoJmRldi0+ZGV2X2xpc3QpOworCWhiYS0+ZGV2X2NvdW50LS07CisJc3Bpbl91bmxvY2soJmhiYS0+ZGV2aWNlX2xvY2spOworCisJY29yZV9zY3NpM19mcmVlX2FsbF9yZWdpc3RyYXRpb25zKGRldik7CisJc2VfcmVsZWFzZV92cGRfZm9yX2RldihkZXYpOworCisJa2ZyZWUoZGV2LT5kZXZfc3RhdHVzX3F1ZXVlX29iaik7CisJa2ZyZWUoZGV2LT5kZXZfcXVldWVfb2JqKTsKKwlrZnJlZShkZXYpOworCisJcmV0dXJuOworfQorCit2b2lkIHNlX3JlbGVhc2VfdnBkX2Zvcl9kZXYoc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXN0cnVjdCB0MTBfdnBkICp2cGQsICp2cGRfdG1wOworCisJc3Bpbl9sb2NrKCZERVZfVDEwX1dXTihkZXYpLT50MTBfdnBkX2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSh2cGQsIHZwZF90bXAsCisJCQkmREVWX1QxMF9XV04oZGV2KS0+dDEwX3ZwZF9saXN0LCB2cGRfbGlzdCkgeworCQlsaXN0X2RlbCgmdnBkLT52cGRfbGlzdCk7CisJCWtmcmVlKHZwZCk7CisJfQorCXNwaW5fdW5sb2NrKCZERVZfVDEwX1dXTihkZXYpLT50MTBfdnBkX2xvY2spOworCisJcmV0dXJuOworfQorCisvKgorICogQ2FsbGVkIHdpdGggc3RydWN0IHNlX2hiYS0+ZGV2aWNlX2xvY2sgaGVsZC4KKyAqLwordm9pZCBzZV9jbGVhcl9kZXZfcG9ydHMoc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBzZV9oYmEgKmhiYSA9IGRldi0+c2VfaGJhOworCXN0cnVjdCBzZV9sdW4gKmx1bjsKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGc7CisJc3RydWN0IHNlX3BvcnQgKnNlcCwgKnNlcF90bXA7CisKKwlzcGluX2xvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoc2VwLCBzZXBfdG1wLCAmZGV2LT5kZXZfc2VwX2xpc3QsIHNlcF9saXN0KSB7CisJCXNwaW5fdW5sb2NrKCZkZXYtPnNlX3BvcnRfbG9jayk7CisJCXNwaW5fdW5sb2NrKCZoYmEtPmRldmljZV9sb2NrKTsKKworCQlsdW4gPSBzZXAtPnNlcF9sdW47CisJCXRwZyA9IHNlcC0+c2VwX3RwZzsKKwkJc3Bpbl9sb2NrKCZsdW4tPmx1bl9zZXBfbG9jayk7CisJCWlmIChsdW4tPmx1bl9zZV9kZXYgPT0gTlVMTCkgeworCQkJc3Bpbl91bmxvY2soJmx1bi0+bHVuX3NlcF9sb2NrKTsKKwkJCWNvbnRpbnVlOworCQl9CisJCXNwaW5fdW5sb2NrKCZsdW4tPmx1bl9zZXBfbG9jayk7CisKKwkJY29yZV9kZXZfZGVsX2x1bih0cGcsIGx1bi0+dW5wYWNrZWRfbHVuKTsKKworCQlzcGluX2xvY2soJmhiYS0+ZGV2aWNlX2xvY2spOworCQlzcGluX2xvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKwl9CisJc3Bpbl91bmxvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKworCXJldHVybjsKK30KKworLyoJc2VfZnJlZV92aXJ0dWFsX2RldmljZSgpOgorICoKKyAqCVVzZWQgZm9yIElCTE9DSywgUkFNRElTSywgYW5kIEZJTEVJTyBUcmFuc3BvcnQgRHJpdmVycy4KKyAqLworaW50IHNlX2ZyZWVfdmlydHVhbF9kZXZpY2Uoc3RydWN0IHNlX2RldmljZSAqZGV2LCBzdHJ1Y3Qgc2VfaGJhICpoYmEpCit7CisJc3Bpbl9sb2NrKCZoYmEtPmRldmljZV9sb2NrKTsKKwlzZV9jbGVhcl9kZXZfcG9ydHMoZGV2KTsKKwlzcGluX3VubG9jaygmaGJhLT5kZXZpY2VfbG9jayk7CisKKwljb3JlX2FsdWFfZnJlZV9sdV9ncF9tZW0oZGV2KTsKKwlzZV9yZWxlYXNlX2RldmljZV9mb3JfaGJhKGRldik7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgc2VfZGV2X3N0YXJ0KHN0cnVjdCBzZV9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEgPSBkZXYtPnNlX2hiYTsKKworCXNwaW5fbG9jaygmaGJhLT5kZXZpY2VfbG9jayk7CisJYXRvbWljX2luYygmZGV2LT5kZXZfb2JqLm9ial9hY2Nlc3NfY291bnQpOworCWlmIChhdG9taWNfcmVhZCgmZGV2LT5kZXZfb2JqLm9ial9hY2Nlc3NfY291bnQpID09IDEpIHsKKwkJaWYgKGRldi0+ZGV2X3N0YXR1cyAmIFRSQU5TUE9SVF9ERVZJQ0VfREVBQ1RJVkFURUQpIHsKKwkJCWRldi0+ZGV2X3N0YXR1cyAmPSB+VFJBTlNQT1JUX0RFVklDRV9ERUFDVElWQVRFRDsKKwkJCWRldi0+ZGV2X3N0YXR1cyB8PSBUUkFOU1BPUlRfREVWSUNFX0FDVElWQVRFRDsKKwkJfSBlbHNlIGlmIChkZXYtPmRldl9zdGF0dXMgJgorCQkJICAgVFJBTlNQT1JUX0RFVklDRV9PRkZMSU5FX0RFQUNUSVZBVEVEKSB7CisJCQlkZXYtPmRldl9zdGF0dXMgJj0KKwkJCQl+VFJBTlNQT1JUX0RFVklDRV9PRkZMSU5FX0RFQUNUSVZBVEVEOworCQkJZGV2LT5kZXZfc3RhdHVzIHw9IFRSQU5TUE9SVF9ERVZJQ0VfT0ZGTElORV9BQ1RJVkFURUQ7CisJCX0KKwl9CisJc3Bpbl91bmxvY2soJmhiYS0+ZGV2aWNlX2xvY2spOworfQorCitzdGF0aWMgdm9pZCBzZV9kZXZfc3RvcChzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHNlX2hiYSAqaGJhID0gZGV2LT5zZV9oYmE7CisKKwlzcGluX2xvY2soJmhiYS0+ZGV2aWNlX2xvY2spOworCWF0b21pY19kZWMoJmRldi0+ZGV2X29iai5vYmpfYWNjZXNzX2NvdW50KTsKKwlpZiAoYXRvbWljX3JlYWQoJmRldi0+ZGV2X29iai5vYmpfYWNjZXNzX2NvdW50KSA9PSAwKSB7CisJCWlmIChkZXYtPmRldl9zdGF0dXMgJiBUUkFOU1BPUlRfREVWSUNFX0FDVElWQVRFRCkgeworCQkJZGV2LT5kZXZfc3RhdHVzICY9IH5UUkFOU1BPUlRfREVWSUNFX0FDVElWQVRFRDsKKwkJCWRldi0+ZGV2X3N0YXR1cyB8PSBUUkFOU1BPUlRfREVWSUNFX0RFQUNUSVZBVEVEOworCQl9IGVsc2UgaWYgKGRldi0+ZGV2X3N0YXR1cyAmCisJCQkgICBUUkFOU1BPUlRfREVWSUNFX09GRkxJTkVfQUNUSVZBVEVEKSB7CisJCQlkZXYtPmRldl9zdGF0dXMgJj0gflRSQU5TUE9SVF9ERVZJQ0VfT0ZGTElORV9BQ1RJVkFURUQ7CisJCQlkZXYtPmRldl9zdGF0dXMgfD0gVFJBTlNQT1JUX0RFVklDRV9PRkZMSU5FX0RFQUNUSVZBVEVEOworCQl9CisJfQorCXNwaW5fdW5sb2NrKCZoYmEtPmRldmljZV9sb2NrKTsKKworCXdoaWxlIChhdG9taWNfcmVhZCgmaGJhLT5kZXZfbWliX2FjY2Vzc19jb3VudCkpCisJCWNwdV9yZWxheCgpOworfQorCitpbnQgc2VfZGV2X2NoZWNrX29ubGluZShzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpCit7CisJaW50IHJldDsKKworCXNwaW5fbG9ja19pcnEoJmRldi0+ZGV2X3N0YXR1c19sb2NrKTsKKwlyZXQgPSAoKGRldi0+ZGV2X3N0YXR1cyAmIFRSQU5TUE9SVF9ERVZJQ0VfQUNUSVZBVEVEKSB8fAorCSAgICAgICAoZGV2LT5kZXZfc3RhdHVzICYgVFJBTlNQT1JUX0RFVklDRV9ERUFDVElWQVRFRCkpID8gMCA6IDE7CisJc3Bpbl91bmxvY2tfaXJxKCZkZXYtPmRldl9zdGF0dXNfbG9jayk7CisKKwlyZXR1cm4gcmV0OworfQorCitpbnQgc2VfZGV2X2NoZWNrX3NodXRkb3duKHN0cnVjdCBzZV9kZXZpY2UgKmRldikKK3sKKwlpbnQgcmV0OworCisJc3Bpbl9sb2NrX2lycSgmZGV2LT5kZXZfc3RhdHVzX2xvY2spOworCXJldCA9IChkZXYtPmRldl9zdGF0dXMgJiBUUkFOU1BPUlRfREVWSUNFX1NIVVRET1dOKTsKKwlzcGluX3VubG9ja19pcnEoJmRldi0+ZGV2X3N0YXR1c19sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CisKK3ZvaWQgc2VfZGV2X3NldF9kZWZhdWx0X2F0dHJpYnMoCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCXN0cnVjdCBzZV9kZXZfbGltaXRzICpkZXZfbGltaXRzKQoreworCXN0cnVjdCBxdWV1ZV9saW1pdHMgKmxpbWl0cyA9ICZkZXZfbGltaXRzLT5saW1pdHM7CisKKwlERVZfQVRUUklCKGRldiktPmVtdWxhdGVfZHBvID0gREFfRU1VTEFURV9EUE87CisJREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX2Z1YV93cml0ZSA9IERBX0VNVUxBVEVfRlVBX1dSSVRFOworCURFVl9BVFRSSUIoZGV2KS0+ZW11bGF0ZV9mdWFfcmVhZCA9IERBX0VNVUxBVEVfRlVBX1JFQUQ7CisJREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3dyaXRlX2NhY2hlID0gREFfRU1VTEFURV9XUklURV9DQUNIRTsKKwlERVZfQVRUUklCKGRldiktPmVtdWxhdGVfdWFfaW50bGNrX2N0cmwgPSBEQV9FTVVMQVRFX1VBX0lOVExMQ0tfQ1RSTDsKKwlERVZfQVRUUklCKGRldiktPmVtdWxhdGVfdGFzID0gREFfRU1VTEFURV9UQVM7CisJREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3RwdSA9IERBX0VNVUxBVEVfVFBVOworCURFVl9BVFRSSUIoZGV2KS0+ZW11bGF0ZV90cHdzID0gREFfRU1VTEFURV9UUFdTOworCURFVl9BVFRSSUIoZGV2KS0+ZW11bGF0ZV9yZXNlcnZhdGlvbnMgPSBEQV9FTVVMQVRFX1JFU0VSVkFUSU9OUzsKKwlERVZfQVRUUklCKGRldiktPmVtdWxhdGVfYWx1YSA9IERBX0VNVUxBVEVfQUxVQTsKKwlERVZfQVRUUklCKGRldiktPmVuZm9yY2VfcHJfaXNpZHMgPSBEQV9FTkZPUkNFX1BSX0lTSURTOworCS8qCisJICogVGhlIFRQVT0xIGFuZCBUUFdTPTEgc2V0dGluZ3Mgd2lsbCBiZSBzZXQgaW4gVENNL0lCTE9DSworCSAqIGlibG9ja19jcmVhdGVfdmlydGRldmljZSgpIGZyb20gc3RydWN0IHF1ZXVlX2xpbWl0cyB2YWx1ZXMKKwkgKiBpZiBibGtfcXVldWVfZGlzY2FyZCgpPT0xCisJICovCisJREVWX0FUVFJJQihkZXYpLT5tYXhfdW5tYXBfbGJhX2NvdW50ID0gREFfTUFYX1VOTUFQX0xCQV9DT1VOVDsKKwlERVZfQVRUUklCKGRldiktPm1heF91bm1hcF9ibG9ja19kZXNjX2NvdW50ID0KKwkJCQlEQV9NQVhfVU5NQVBfQkxPQ0tfREVTQ19DT1VOVDsKKwlERVZfQVRUUklCKGRldiktPnVubWFwX2dyYW51bGFyaXR5ID0gREFfVU5NQVBfR1JBTlVMQVJJVFlfREVGQVVMVDsKKwlERVZfQVRUUklCKGRldiktPnVubWFwX2dyYW51bGFyaXR5X2FsaWdubWVudCA9CisJCQkJREFfVU5NQVBfR1JBTlVMQVJJVFlfQUxJR05NRU5UX0RFRkFVTFQ7CisJLyoKKwkgKiBibG9ja19zaXplIGlzIGJhc2VkIG9uIHN1YnN5c3RlbSBwbHVnaW4gZGVwZW5kZW50IHJlcXVpcmVtZW50cy4KKwkgKi8KKwlERVZfQVRUUklCKGRldiktPmh3X2Jsb2NrX3NpemUgPSBsaW1pdHMtPmxvZ2ljYWxfYmxvY2tfc2l6ZTsKKwlERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUgPSBsaW1pdHMtPmxvZ2ljYWxfYmxvY2tfc2l6ZTsKKwkvKgorCSAqIG1heF9zZWN0b3JzIGlzIGJhc2VkIG9uIHN1YnN5c3RlbSBwbHVnaW4gZGVwZW5kZW50IHJlcXVpcmVtZW50cy4KKwkgKi8KKwlERVZfQVRUUklCKGRldiktPmh3X21heF9zZWN0b3JzID0gbGltaXRzLT5tYXhfaHdfc2VjdG9yczsKKwlERVZfQVRUUklCKGRldiktPm1heF9zZWN0b3JzID0gbGltaXRzLT5tYXhfc2VjdG9yczsKKwkvKgorCSAqIFNldCBvcHRpbWFsX3NlY3RvcnMgZnJvbSBtYXhfc2VjdG9ycywgd2hpY2ggY2FuIGJlIGxvd2VyZWQgdmlhCisJICogY29uZmlnZnMuCisJICovCisJREVWX0FUVFJJQihkZXYpLT5vcHRpbWFsX3NlY3RvcnMgPSBsaW1pdHMtPm1heF9zZWN0b3JzOworCS8qCisJICogcXVldWVfZGVwdGggaXMgYmFzZWQgb24gc3Vic3lzdGVtIHBsdWdpbiBkZXBlbmRlbnQgcmVxdWlyZW1lbnRzLgorCSAqLworCURFVl9BVFRSSUIoZGV2KS0+aHdfcXVldWVfZGVwdGggPSBkZXZfbGltaXRzLT5od19xdWV1ZV9kZXB0aDsKKwlERVZfQVRUUklCKGRldiktPnF1ZXVlX2RlcHRoID0gZGV2X2xpbWl0cy0+cXVldWVfZGVwdGg7Cit9CisKK2ludCBzZV9kZXZfc2V0X3Rhc2tfdGltZW91dChzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsIHUzMiB0YXNrX3RpbWVvdXQpCit7CisJaWYgKHRhc2tfdGltZW91dCA+IERBX1RBU0tfVElNRU9VVF9NQVgpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJkZXZbJXBdOiBQYXNzZWQgdGFza190aW1lb3V0OiAldSBsYXJnZXIgdGhlbiIKKwkJCSIgREFfVEFTS19USU1FT1VUX01BWFxuIiwgZGV2LCB0YXNrX3RpbWVvdXQpOworCQlyZXR1cm4gLTE7CisJfSBlbHNlIHsKKwkJREVWX0FUVFJJQihkZXYpLT50YXNrX3RpbWVvdXQgPSB0YXNrX3RpbWVvdXQ7CisJCXByaW50ayhLRVJOX0lORk8gImRldlslcF06IFNldCBTRSBEZXZpY2UgdGFza190aW1lb3V0OiAldVxuIiwKKwkJCWRldiwgdGFza190aW1lb3V0KTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworaW50IHNlX2Rldl9zZXRfbWF4X3VubWFwX2xiYV9jb3VudCgKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsCisJdTMyIG1heF91bm1hcF9sYmFfY291bnQpCit7CisJREVWX0FUVFJJQihkZXYpLT5tYXhfdW5tYXBfbGJhX2NvdW50ID0gbWF4X3VubWFwX2xiYV9jb3VudDsKKwlwcmludGsoS0VSTl9JTkZPICJkZXZbJXBdOiBTZXQgbWF4X3VubWFwX2xiYV9jb3VudDogJXVcbiIsCisJCQlkZXYsIERFVl9BVFRSSUIoZGV2KS0+bWF4X3VubWFwX2xiYV9jb3VudCk7CisJcmV0dXJuIDA7Cit9CisKK2ludCBzZV9kZXZfc2V0X21heF91bm1hcF9ibG9ja19kZXNjX2NvdW50KAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwl1MzIgbWF4X3VubWFwX2Jsb2NrX2Rlc2NfY291bnQpCit7CisJREVWX0FUVFJJQihkZXYpLT5tYXhfdW5tYXBfYmxvY2tfZGVzY19jb3VudCA9IG1heF91bm1hcF9ibG9ja19kZXNjX2NvdW50OworCXByaW50ayhLRVJOX0lORk8gImRldlslcF06IFNldCBtYXhfdW5tYXBfYmxvY2tfZGVzY19jb3VudDogJXVcbiIsCisJCQlkZXYsIERFVl9BVFRSSUIoZGV2KS0+bWF4X3VubWFwX2Jsb2NrX2Rlc2NfY291bnQpOworCXJldHVybiAwOworfQorCitpbnQgc2VfZGV2X3NldF91bm1hcF9ncmFudWxhcml0eSgKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsCisJdTMyIHVubWFwX2dyYW51bGFyaXR5KQoreworCURFVl9BVFRSSUIoZGV2KS0+dW5tYXBfZ3JhbnVsYXJpdHkgPSB1bm1hcF9ncmFudWxhcml0eTsKKwlwcmludGsoS0VSTl9JTkZPICJkZXZbJXBdOiBTZXQgdW5tYXBfZ3JhbnVsYXJpdHk6ICV1XG4iLAorCQkJZGV2LCBERVZfQVRUUklCKGRldiktPnVubWFwX2dyYW51bGFyaXR5KTsKKwlyZXR1cm4gMDsKK30KKworaW50IHNlX2Rldl9zZXRfdW5tYXBfZ3JhbnVsYXJpdHlfYWxpZ25tZW50KAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwl1MzIgdW5tYXBfZ3JhbnVsYXJpdHlfYWxpZ25tZW50KQoreworCURFVl9BVFRSSUIoZGV2KS0+dW5tYXBfZ3JhbnVsYXJpdHlfYWxpZ25tZW50ID0gdW5tYXBfZ3JhbnVsYXJpdHlfYWxpZ25tZW50OworCXByaW50ayhLRVJOX0lORk8gImRldlslcF06IFNldCB1bm1hcF9ncmFudWxhcml0eV9hbGlnbm1lbnQ6ICV1XG4iLAorCQkJZGV2LCBERVZfQVRUUklCKGRldiktPnVubWFwX2dyYW51bGFyaXR5X2FsaWdubWVudCk7CisJcmV0dXJuIDA7Cit9CisKK2ludCBzZV9kZXZfc2V0X2VtdWxhdGVfZHBvKHN0cnVjdCBzZV9kZXZpY2UgKmRldiwgaW50IGZsYWcpCit7CisJaWYgKChmbGFnICE9IDApICYmIChmbGFnICE9IDEpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiSWxsZWdhbCB2YWx1ZSAlZFxuIiwgZmxhZyk7CisJCXJldHVybiAtMTsKKwl9CisJaWYgKFRSQU5TUE9SVChkZXYpLT5kcG9fZW11bGF0ZWQgPT0gTlVMTCkgeworCQlwcmludGsoS0VSTl9FUlIgIlRSQU5TUE9SVChkZXYpLT5kcG9fZW11bGF0ZWQgaXMgTlVMTFxuIik7CisJCXJldHVybiAtMTsKKwl9CisJaWYgKFRSQU5TUE9SVChkZXYpLT5kcG9fZW11bGF0ZWQoZGV2KSA9PSAwKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVFJBTlNQT1JUKGRldiktPmRwb19lbXVsYXRlZCBub3Qgc3VwcG9ydGVkXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwlERVZfQVRUUklCKGRldiktPmVtdWxhdGVfZHBvID0gZmxhZzsKKwlwcmludGsoS0VSTl9JTkZPICJkZXZbJXBdOiBTRSBEZXZpY2UgUGFnZSBPdXQgKERQTykgRW11bGF0aW9uIgorCQkJIiBiaXQ6ICVkXG4iLCBkZXYsIERFVl9BVFRSSUIoZGV2KS0+ZW11bGF0ZV9kcG8pOworCXJldHVybiAwOworfQorCitpbnQgc2VfZGV2X3NldF9lbXVsYXRlX2Z1YV93cml0ZShzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsIGludCBmbGFnKQoreworCWlmICgoZmxhZyAhPSAwKSAmJiAoZmxhZyAhPSAxKSkgeworCQlwcmludGsoS0VSTl9FUlIgIklsbGVnYWwgdmFsdWUgJWRcbiIsIGZsYWcpOworCQlyZXR1cm4gLTE7CisJfQorCWlmIChUUkFOU1BPUlQoZGV2KS0+ZnVhX3dyaXRlX2VtdWxhdGVkID09IE5VTEwpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJUUkFOU1BPUlQoZGV2KS0+ZnVhX3dyaXRlX2VtdWxhdGVkIGlzIE5VTExcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCWlmIChUUkFOU1BPUlQoZGV2KS0+ZnVhX3dyaXRlX2VtdWxhdGVkKGRldikgPT0gMCkgeworCQlwcmludGsoS0VSTl9FUlIgIlRSQU5TUE9SVChkZXYpLT5mdWFfd3JpdGVfZW11bGF0ZWQgbm90IHN1cHBvcnRlZFxuIik7CisJCXJldHVybiAtMTsKKwl9CisJREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX2Z1YV93cml0ZSA9IGZsYWc7CisJcHJpbnRrKEtFUk5fSU5GTyAiZGV2WyVwXTogU0UgRGV2aWNlIEZvcmNlZCBVbml0IEFjY2VzcyBXUklURXM6ICVkXG4iLAorCQkJZGV2LCBERVZfQVRUUklCKGRldiktPmVtdWxhdGVfZnVhX3dyaXRlKTsKKwlyZXR1cm4gMDsKK30KKworaW50IHNlX2Rldl9zZXRfZW11bGF0ZV9mdWFfcmVhZChzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsIGludCBmbGFnKQoreworCWlmICgoZmxhZyAhPSAwKSAmJiAoZmxhZyAhPSAxKSkgeworCQlwcmludGsoS0VSTl9FUlIgIklsbGVnYWwgdmFsdWUgJWRcbiIsIGZsYWcpOworCQlyZXR1cm4gLTE7CisJfQorCWlmIChUUkFOU1BPUlQoZGV2KS0+ZnVhX3JlYWRfZW11bGF0ZWQgPT0gTlVMTCkgeworCQlwcmludGsoS0VSTl9FUlIgIlRSQU5TUE9SVChkZXYpLT5mdWFfcmVhZF9lbXVsYXRlZCBpcyBOVUxMXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwlpZiAoVFJBTlNQT1JUKGRldiktPmZ1YV9yZWFkX2VtdWxhdGVkKGRldikgPT0gMCkgeworCQlwcmludGsoS0VSTl9FUlIgIlRSQU5TUE9SVChkZXYpLT5mdWFfcmVhZF9lbXVsYXRlZCBub3Qgc3VwcG9ydGVkXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwlERVZfQVRUUklCKGRldiktPmVtdWxhdGVfZnVhX3JlYWQgPSBmbGFnOworCXByaW50ayhLRVJOX0lORk8gImRldlslcF06IFNFIERldmljZSBGb3JjZWQgVW5pdCBBY2Nlc3MgUkVBRHM6ICVkXG4iLAorCQkJZGV2LCBERVZfQVRUUklCKGRldiktPmVtdWxhdGVfZnVhX3JlYWQpOworCXJldHVybiAwOworfQorCitpbnQgc2VfZGV2X3NldF9lbXVsYXRlX3dyaXRlX2NhY2hlKHN0cnVjdCBzZV9kZXZpY2UgKmRldiwgaW50IGZsYWcpCit7CisJaWYgKChmbGFnICE9IDApICYmIChmbGFnICE9IDEpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiSWxsZWdhbCB2YWx1ZSAlZFxuIiwgZmxhZyk7CisJCXJldHVybiAtMTsKKwl9CisJaWYgKFRSQU5TUE9SVChkZXYpLT53cml0ZV9jYWNoZV9lbXVsYXRlZCA9PSBOVUxMKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVFJBTlNQT1JUKGRldiktPndyaXRlX2NhY2hlX2VtdWxhdGVkIGlzIE5VTExcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCWlmIChUUkFOU1BPUlQoZGV2KS0+d3JpdGVfY2FjaGVfZW11bGF0ZWQoZGV2KSA9PSAwKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVFJBTlNQT1JUKGRldiktPndyaXRlX2NhY2hlX2VtdWxhdGVkIG5vdCBzdXBwb3J0ZWRcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCURFVl9BVFRSSUIoZGV2KS0+ZW11bGF0ZV93cml0ZV9jYWNoZSA9IGZsYWc7CisJcHJpbnRrKEtFUk5fSU5GTyAiZGV2WyVwXTogU0UgRGV2aWNlIFdSSVRFX0NBQ0hFX0VNVUxBVElPTiBmbGFnOiAlZFxuIiwKKwkJCWRldiwgREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3dyaXRlX2NhY2hlKTsKKwlyZXR1cm4gMDsKK30KKworaW50IHNlX2Rldl9zZXRfZW11bGF0ZV91YV9pbnRsY2tfY3RybChzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsIGludCBmbGFnKQoreworCWlmICgoZmxhZyAhPSAwKSAmJiAoZmxhZyAhPSAxKSAmJiAoZmxhZyAhPSAyKSkgeworCQlwcmludGsoS0VSTl9FUlIgIklsbGVnYWwgdmFsdWUgJWRcbiIsIGZsYWcpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKGF0b21pY19yZWFkKCZkZXYtPmRldl9leHBvcnRfb2JqLm9ial9hY2Nlc3NfY291bnQpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiZGV2WyVwXTogVW5hYmxlIHRvIGNoYW5nZSBTRSBEZXZpY2UiCisJCQkiIFVBX0lOVFJMQ0tfQ1RSTCB3aGlsZSBkZXZfZXhwb3J0X29iajogJWQgY291bnQiCisJCQkiIGV4aXN0c1xuIiwgZGV2LAorCQkJYXRvbWljX3JlYWQoJmRldi0+ZGV2X2V4cG9ydF9vYmoub2JqX2FjY2Vzc19jb3VudCkpOworCQlyZXR1cm4gLTE7CisJfQorCURFVl9BVFRSSUIoZGV2KS0+ZW11bGF0ZV91YV9pbnRsY2tfY3RybCA9IGZsYWc7CisJcHJpbnRrKEtFUk5fSU5GTyAiZGV2WyVwXTogU0UgRGV2aWNlIFVBX0lOVFJMQ0tfQ1RSTCBmbGFnOiAlZFxuIiwKKwkJZGV2LCBERVZfQVRUUklCKGRldiktPmVtdWxhdGVfdWFfaW50bGNrX2N0cmwpOworCisJcmV0dXJuIDA7Cit9CisKK2ludCBzZV9kZXZfc2V0X2VtdWxhdGVfdGFzKHN0cnVjdCBzZV9kZXZpY2UgKmRldiwgaW50IGZsYWcpCit7CisJaWYgKChmbGFnICE9IDApICYmIChmbGFnICE9IDEpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiSWxsZWdhbCB2YWx1ZSAlZFxuIiwgZmxhZyk7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoYXRvbWljX3JlYWQoJmRldi0+ZGV2X2V4cG9ydF9vYmoub2JqX2FjY2Vzc19jb3VudCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJkZXZbJXBdOiBVbmFibGUgdG8gY2hhbmdlIFNFIERldmljZSBUQVMgd2hpbGUiCisJCQkiIGRldl9leHBvcnRfb2JqOiAlZCBjb3VudCBleGlzdHNcbiIsIGRldiwKKwkJCWF0b21pY19yZWFkKCZkZXYtPmRldl9leHBvcnRfb2JqLm9ial9hY2Nlc3NfY291bnQpKTsKKwkJcmV0dXJuIC0xOworCX0KKwlERVZfQVRUUklCKGRldiktPmVtdWxhdGVfdGFzID0gZmxhZzsKKwlwcmludGsoS0VSTl9JTkZPICJkZXZbJXBdOiBTRSBEZXZpY2UgVEFTS19BQk9SVEVEIHN0YXR1cyBiaXQ6ICVzXG4iLAorCQlkZXYsIChERVZfQVRUUklCKGRldiktPmVtdWxhdGVfdGFzKSA/ICJFbmFibGVkIiA6ICJEaXNhYmxlZCIpOworCisJcmV0dXJuIDA7Cit9CisKK2ludCBzZV9kZXZfc2V0X2VtdWxhdGVfdHB1KHN0cnVjdCBzZV9kZXZpY2UgKmRldiwgaW50IGZsYWcpCit7CisJaWYgKChmbGFnICE9IDApICYmIChmbGFnICE9IDEpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiSWxsZWdhbCB2YWx1ZSAlZFxuIiwgZmxhZyk7CisJCXJldHVybiAtMTsKKwl9CisJLyoKKwkgKiBXZSBleHBlY3QgdGhpcyB2YWx1ZSB0byBiZSBub24temVybyB3aGVuIGdlbmVyaWMgQmxvY2sgTGF5ZXIKKwkgKiBEaXNjYXJkIHN1cHBvcnRlZCBpcyBkZXRlY3RlZCBpYmxvY2tfY3JlYXRlX3ZpcnRkZXZpY2UoKS4KKwkgKi8KKwlpZiAoIShERVZfQVRUUklCKGRldiktPm1heF91bm1hcF9ibG9ja19kZXNjX2NvdW50KSkgeworCQlwcmludGsoS0VSTl9FUlIgIkdlbmVyaWMgQmxvY2sgRGlzY2FyZCBub3Qgc3VwcG9ydGVkXG4iKTsKKwkJcmV0dXJuIC1FTk9TWVM7CisJfQorCisJREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3RwdSA9IGZsYWc7CisJcHJpbnRrKEtFUk5fSU5GTyAiZGV2WyVwXTogU0UgRGV2aWNlIFRoaW4gUHJvdmlzaW9uaW5nIFVOTUFQIGJpdDogJWRcbiIsCisJCQkJZGV2LCBmbGFnKTsKKwlyZXR1cm4gMDsKK30KKworaW50IHNlX2Rldl9zZXRfZW11bGF0ZV90cHdzKHN0cnVjdCBzZV9kZXZpY2UgKmRldiwgaW50IGZsYWcpCit7CisJaWYgKChmbGFnICE9IDApICYmIChmbGFnICE9IDEpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiSWxsZWdhbCB2YWx1ZSAlZFxuIiwgZmxhZyk7CisJCXJldHVybiAtMTsKKwl9CisJLyoKKwkgKiBXZSBleHBlY3QgdGhpcyB2YWx1ZSB0byBiZSBub24temVybyB3aGVuIGdlbmVyaWMgQmxvY2sgTGF5ZXIKKwkgKiBEaXNjYXJkIHN1cHBvcnRlZCBpcyBkZXRlY3RlZCBpYmxvY2tfY3JlYXRlX3ZpcnRkZXZpY2UoKS4KKwkgKi8KKwlpZiAoIShERVZfQVRUUklCKGRldiktPm1heF91bm1hcF9ibG9ja19kZXNjX2NvdW50KSkgeworCQlwcmludGsoS0VSTl9FUlIgIkdlbmVyaWMgQmxvY2sgRGlzY2FyZCBub3Qgc3VwcG9ydGVkXG4iKTsKKwkJcmV0dXJuIC1FTk9TWVM7CisJfQorCisJREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3Rwd3MgPSBmbGFnOworCXByaW50ayhLRVJOX0lORk8gImRldlslcF06IFNFIERldmljZSBUaGluIFByb3Zpc2lvbmluZyBXUklURV9TQU1FOiAlZFxuIiwKKwkJCQlkZXYsIGZsYWcpOworCXJldHVybiAwOworfQorCitpbnQgc2VfZGV2X3NldF9lbmZvcmNlX3ByX2lzaWRzKHN0cnVjdCBzZV9kZXZpY2UgKmRldiwgaW50IGZsYWcpCit7CisJaWYgKChmbGFnICE9IDApICYmIChmbGFnICE9IDEpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiSWxsZWdhbCB2YWx1ZSAlZFxuIiwgZmxhZyk7CisJCXJldHVybiAtMTsKKwl9CisJREVWX0FUVFJJQihkZXYpLT5lbmZvcmNlX3ByX2lzaWRzID0gZmxhZzsKKwlwcmludGsoS0VSTl9JTkZPICJkZXZbJXBdOiBTRSBEZXZpY2UgZW5mb3JjZV9wcl9pc2lkcyBiaXQ6ICVzXG4iLCBkZXYsCisJCShERVZfQVRUUklCKGRldiktPmVuZm9yY2VfcHJfaXNpZHMpID8gIkVuYWJsZWQiIDogIkRpc2FibGVkIik7CisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBOb3RlLCB0aGlzIGNhbiBvbmx5IGJlIGNhbGxlZCBvbiB1bmV4cG9ydGVkIFNFIERldmljZSBPYmplY3QuCisgKi8KK2ludCBzZV9kZXZfc2V0X3F1ZXVlX2RlcHRoKHN0cnVjdCBzZV9kZXZpY2UgKmRldiwgdTMyIHF1ZXVlX2RlcHRoKQoreworCXUzMiBvcmlnX3F1ZXVlX2RlcHRoID0gZGV2LT5xdWV1ZV9kZXB0aDsKKworCWlmIChhdG9taWNfcmVhZCgmZGV2LT5kZXZfZXhwb3J0X29iai5vYmpfYWNjZXNzX2NvdW50KSkgeworCQlwcmludGsoS0VSTl9FUlIgImRldlslcF06IFVuYWJsZSB0byBjaGFuZ2UgU0UgRGV2aWNlIFRDUSB3aGlsZSIKKwkJCSIgZGV2X2V4cG9ydF9vYmo6ICVkIGNvdW50IGV4aXN0c1xuIiwgZGV2LAorCQkJYXRvbWljX3JlYWQoJmRldi0+ZGV2X2V4cG9ydF9vYmoub2JqX2FjY2Vzc19jb3VudCkpOworCQlyZXR1cm4gLTE7CisJfQorCWlmICghKHF1ZXVlX2RlcHRoKSkgeworCQlwcmludGsoS0VSTl9FUlIgImRldlslcF06IElsbGVnYWwgWkVSTyB2YWx1ZSBmb3IgcXVldWUiCisJCQkiX2RlcHRoXG4iLCBkZXYpOworCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKFRSQU5TUE9SVChkZXYpLT50cmFuc3BvcnRfdHlwZSA9PSBUUkFOU1BPUlRfUExVR0lOX1BIQkFfUERFVikgeworCQlpZiAocXVldWVfZGVwdGggPiBERVZfQVRUUklCKGRldiktPmh3X3F1ZXVlX2RlcHRoKSB7CisJCQlwcmludGsoS0VSTl9FUlIgImRldlslcF06IFBhc3NlZCBxdWV1ZV9kZXB0aDogJXUiCisJCQkJIiBleGNlZWRzIFRDTS9TRV9EZXZpY2UgVENROiAldVxuIiwKKwkJCQlkZXYsIHF1ZXVlX2RlcHRoLAorCQkJCURFVl9BVFRSSUIoZGV2KS0+aHdfcXVldWVfZGVwdGgpOworCQkJcmV0dXJuIC0xOworCQl9CisJfSBlbHNlIHsKKwkJaWYgKHF1ZXVlX2RlcHRoID4gREVWX0FUVFJJQihkZXYpLT5xdWV1ZV9kZXB0aCkgeworCQkJaWYgKHF1ZXVlX2RlcHRoID4gREVWX0FUVFJJQihkZXYpLT5od19xdWV1ZV9kZXB0aCkgeworCQkJCXByaW50ayhLRVJOX0VSUiAiZGV2WyVwXTogUGFzc2VkIHF1ZXVlX2RlcHRoOiIKKwkJCQkJIiAldSBleGNlZWRzIFRDTS9TRV9EZXZpY2UgTUFYIgorCQkJCQkiIFRDUTogJXVcbiIsIGRldiwgcXVldWVfZGVwdGgsCisJCQkJCURFVl9BVFRSSUIoZGV2KS0+aHdfcXVldWVfZGVwdGgpOworCQkJCXJldHVybiAtMTsKKwkJCX0KKwkJfQorCX0KKworCURFVl9BVFRSSUIoZGV2KS0+cXVldWVfZGVwdGggPSBkZXYtPnF1ZXVlX2RlcHRoID0gcXVldWVfZGVwdGg7CisJaWYgKHF1ZXVlX2RlcHRoID4gb3JpZ19xdWV1ZV9kZXB0aCkKKwkJYXRvbWljX2FkZChxdWV1ZV9kZXB0aCAtIG9yaWdfcXVldWVfZGVwdGgsICZkZXYtPmRlcHRoX2xlZnQpOworCWVsc2UgaWYgKHF1ZXVlX2RlcHRoIDwgb3JpZ19xdWV1ZV9kZXB0aCkKKwkJYXRvbWljX3N1YihvcmlnX3F1ZXVlX2RlcHRoIC0gcXVldWVfZGVwdGgsICZkZXYtPmRlcHRoX2xlZnQpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiZGV2WyVwXTogU0UgRGV2aWNlIFRDUSBEZXB0aCBjaGFuZ2VkIHRvOiAldVxuIiwKKwkJCWRldiwgcXVldWVfZGVwdGgpOworCXJldHVybiAwOworfQorCitpbnQgc2VfZGV2X3NldF9tYXhfc2VjdG9ycyhzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsIHUzMiBtYXhfc2VjdG9ycykKK3sKKwlpbnQgZm9yY2UgPSAwOyAvKiBGb3JjZSBzZXR0aW5nIGZvciBWREVWUyAqLworCisJaWYgKGF0b21pY19yZWFkKCZkZXYtPmRldl9leHBvcnRfb2JqLm9ial9hY2Nlc3NfY291bnQpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiZGV2WyVwXTogVW5hYmxlIHRvIGNoYW5nZSBTRSBEZXZpY2UiCisJCQkiIG1heF9zZWN0b3JzIHdoaWxlIGRldl9leHBvcnRfb2JqOiAlZCBjb3VudCBleGlzdHNcbiIsCisJCQlkZXYsIGF0b21pY19yZWFkKCZkZXYtPmRldl9leHBvcnRfb2JqLm9ial9hY2Nlc3NfY291bnQpKTsKKwkJcmV0dXJuIC0xOworCX0KKwlpZiAoIShtYXhfc2VjdG9ycykpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJkZXZbJXBdOiBJbGxlZ2FsIFpFUk8gdmFsdWUgZm9yIgorCQkJIiBtYXhfc2VjdG9yc1xuIiwgZGV2KTsKKwkJcmV0dXJuIC0xOworCX0KKwlpZiAobWF4X3NlY3RvcnMgPCBEQV9TVEFUVVNfTUFYX1NFQ1RPUlNfTUlOKSB7CisJCXByaW50ayhLRVJOX0VSUiAiZGV2WyVwXTogUGFzc2VkIG1heF9zZWN0b3JzOiAldSBsZXNzIHRoYW4iCisJCQkiIERBX1NUQVRVU19NQVhfU0VDVE9SU19NSU46ICV1XG4iLCBkZXYsIG1heF9zZWN0b3JzLAorCQkJCURBX1NUQVRVU19NQVhfU0VDVE9SU19NSU4pOworCQlyZXR1cm4gLTE7CisJfQorCWlmIChUUkFOU1BPUlQoZGV2KS0+dHJhbnNwb3J0X3R5cGUgPT0gVFJBTlNQT1JUX1BMVUdJTl9QSEJBX1BERVYpIHsKKwkJaWYgKG1heF9zZWN0b3JzID4gREVWX0FUVFJJQihkZXYpLT5od19tYXhfc2VjdG9ycykgeworCQkJcHJpbnRrKEtFUk5fRVJSICJkZXZbJXBdOiBQYXNzZWQgbWF4X3NlY3RvcnM6ICV1IgorCQkJCSIgZ3JlYXRlciB0aGFuIFRDTS9TRV9EZXZpY2UgbWF4X3NlY3RvcnM6IgorCQkJCSIgJXVcbiIsIGRldiwgbWF4X3NlY3RvcnMsCisJCQkJREVWX0FUVFJJQihkZXYpLT5od19tYXhfc2VjdG9ycyk7CisJCQkgcmV0dXJuIC0xOworCQl9CisJfSBlbHNlIHsKKwkJaWYgKCEoZm9yY2UpICYmIChtYXhfc2VjdG9ycyA+CisJCQkJIERFVl9BVFRSSUIoZGV2KS0+aHdfbWF4X3NlY3RvcnMpKSB7CisJCQlwcmludGsoS0VSTl9FUlIgImRldlslcF06IFBhc3NlZCBtYXhfc2VjdG9yczogJXUiCisJCQkJIiBncmVhdGVyIHRoYW4gVENNL1NFX0RldmljZSBtYXhfc2VjdG9ycyIKKwkJCQkiOiAldSwgdXNlIGZvcmNlPTEgdG8gb3ZlcnJpZGUuXG4iLCBkZXYsCisJCQkJbWF4X3NlY3RvcnMsIERFVl9BVFRSSUIoZGV2KS0+aHdfbWF4X3NlY3RvcnMpOworCQkJcmV0dXJuIC0xOworCQl9CisJCWlmIChtYXhfc2VjdG9ycyA+IERBX1NUQVRVU19NQVhfU0VDVE9SU19NQVgpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiZGV2WyVwXTogUGFzc2VkIG1heF9zZWN0b3JzOiAldSIKKwkJCQkiIGdyZWF0ZXIgdGhhbiBEQV9TVEFUVVNfTUFYX1NFQ1RPUlNfTUFYOiIKKwkJCQkiICV1XG4iLCBkZXYsIG1heF9zZWN0b3JzLAorCQkJCURBX1NUQVRVU19NQVhfU0VDVE9SU19NQVgpOworCQkJcmV0dXJuIC0xOworCQl9CisJfQorCisJREVWX0FUVFJJQihkZXYpLT5tYXhfc2VjdG9ycyA9IG1heF9zZWN0b3JzOworCXByaW50aygiZGV2WyVwXTogU0UgRGV2aWNlIG1heF9zZWN0b3JzIGNoYW5nZWQgdG8gJXVcbiIsCisJCQlkZXYsIG1heF9zZWN0b3JzKTsKKwlyZXR1cm4gMDsKK30KKworaW50IHNlX2Rldl9zZXRfb3B0aW1hbF9zZWN0b3JzKHN0cnVjdCBzZV9kZXZpY2UgKmRldiwgdTMyIG9wdGltYWxfc2VjdG9ycykKK3sKKwlpZiAoYXRvbWljX3JlYWQoJmRldi0+ZGV2X2V4cG9ydF9vYmoub2JqX2FjY2Vzc19jb3VudCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJkZXZbJXBdOiBVbmFibGUgdG8gY2hhbmdlIFNFIERldmljZSIKKwkJCSIgb3B0aW1hbF9zZWN0b3JzIHdoaWxlIGRldl9leHBvcnRfb2JqOiAlZCBjb3VudCBleGlzdHNcbiIsCisJCQlkZXYsIGF0b21pY19yZWFkKCZkZXYtPmRldl9leHBvcnRfb2JqLm9ial9hY2Nlc3NfY291bnQpKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmIChUUkFOU1BPUlQoZGV2KS0+dHJhbnNwb3J0X3R5cGUgPT0gVFJBTlNQT1JUX1BMVUdJTl9QSEJBX1BERVYpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJkZXZbJXBdOiBQYXNzZWQgb3B0aW1hbF9zZWN0b3JzIGNhbm5vdCBiZSIKKwkJCQkiIGNoYW5nZWQgZm9yIFRDTS9wU0NTSVxuIiwgZGV2KTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCWlmIChvcHRpbWFsX3NlY3RvcnMgPiBERVZfQVRUUklCKGRldiktPm1heF9zZWN0b3JzKSB7CisJCXByaW50ayhLRVJOX0VSUiAiZGV2WyVwXTogUGFzc2VkIG9wdGltYWxfc2VjdG9ycyAldSBjYW5ub3QgYmUiCisJCQkiIGdyZWF0ZXIgdGhhbiBtYXhfc2VjdG9yczogJXVcbiIsIGRldiwKKwkJCW9wdGltYWxfc2VjdG9ycywgREVWX0FUVFJJQihkZXYpLT5tYXhfc2VjdG9ycyk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCURFVl9BVFRSSUIoZGV2KS0+b3B0aW1hbF9zZWN0b3JzID0gb3B0aW1hbF9zZWN0b3JzOworCXByaW50ayhLRVJOX0lORk8gImRldlslcF06IFNFIERldmljZSBvcHRpbWFsX3NlY3RvcnMgY2hhbmdlZCB0byAldVxuIiwKKwkJCWRldiwgb3B0aW1hbF9zZWN0b3JzKTsKKwlyZXR1cm4gMDsKK30KKworaW50IHNlX2Rldl9zZXRfYmxvY2tfc2l6ZShzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsIHUzMiBibG9ja19zaXplKQoreworCWlmIChhdG9taWNfcmVhZCgmZGV2LT5kZXZfZXhwb3J0X29iai5vYmpfYWNjZXNzX2NvdW50KSkgeworCQlwcmludGsoS0VSTl9FUlIgImRldlslcF06IFVuYWJsZSB0byBjaGFuZ2UgU0UgRGV2aWNlIGJsb2NrX3NpemUiCisJCQkiIHdoaWxlIGRldl9leHBvcnRfb2JqOiAlZCBjb3VudCBleGlzdHNcbiIsIGRldiwKKwkJCWF0b21pY19yZWFkKCZkZXYtPmRldl9leHBvcnRfb2JqLm9ial9hY2Nlc3NfY291bnQpKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlmICgoYmxvY2tfc2l6ZSAhPSA1MTIpICYmCisJICAgIChibG9ja19zaXplICE9IDEwMjQpICYmCisJICAgIChibG9ja19zaXplICE9IDIwNDgpICYmCisJICAgIChibG9ja19zaXplICE9IDQwOTYpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiZGV2WyVwXTogSWxsZWdhbCB2YWx1ZSBmb3IgYmxvY2tfZGV2aWNlOiAldSIKKwkJCSIgZm9yIFNFIGRldmljZSwgbXVzdCBiZSA1MTIsIDEwMjQsIDIwNDggb3IgNDA5NlxuIiwKKwkJCWRldiwgYmxvY2tfc2l6ZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlpZiAoVFJBTlNQT1JUKGRldiktPnRyYW5zcG9ydF90eXBlID09IFRSQU5TUE9SVF9QTFVHSU5fUEhCQV9QREVWKSB7CisJCXByaW50ayhLRVJOX0VSUiAiZGV2WyVwXTogTm90IGFsbG93ZWQgdG8gY2hhbmdlIGJsb2NrX3NpemUgZm9yIgorCQkJIiBQaHlzaWNhbCBEZXZpY2UsIHVzZSBmb3IgTGludXgvU0NTSSB0byBjaGFuZ2UiCisJCQkiIGJsb2NrX3NpemUgZm9yIHVuZGVybHlpbmcgaGFyZHdhcmVcbiIsIGRldik7CisJCXJldHVybiAtMTsKKwl9CisKKwlERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUgPSBibG9ja19zaXplOworCXByaW50ayhLRVJOX0lORk8gImRldlslcF06IFNFIERldmljZSBibG9ja19zaXplIGNoYW5nZWQgdG8gJXVcbiIsCisJCQlkZXYsIGJsb2NrX3NpemUpOworCXJldHVybiAwOworfQorCitzdHJ1Y3Qgc2VfbHVuICpjb3JlX2Rldl9hZGRfbHVuKAorCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZywKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEsCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCXUzMiBsdW4pCit7CisJc3RydWN0IHNlX2x1biAqbHVuX3A7CisJdTMyIGx1bl9hY2Nlc3MgPSAwOworCisJaWYgKGF0b21pY19yZWFkKCZkZXYtPmRldl9hY2Nlc3Nfb2JqLm9ial9hY2Nlc3NfY291bnQpICE9IDApIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gZXhwb3J0IHN0cnVjdCBzZV9kZXZpY2Ugd2hpbGUgZGV2X2FjY2Vzc19vYmo6ICVkXG4iLAorCQkJYXRvbWljX3JlYWQoJmRldi0+ZGV2X2FjY2Vzc19vYmoub2JqX2FjY2Vzc19jb3VudCkpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlsdW5fcCA9IGNvcmVfdHBnX3ByZV9hZGRsdW4odHBnLCBsdW4pOworCWlmICgoSVNfRVJSKGx1bl9wKSkgfHwgIShsdW5fcCkpCisJCXJldHVybiBOVUxMOworCisJaWYgKGRldi0+ZGV2X2ZsYWdzICYgREZfUkVBRF9PTkxZKQorCQlsdW5fYWNjZXNzID0gVFJBTlNQT1JUX0xVTkZMQUdTX1JFQURfT05MWTsKKwllbHNlCisJCWx1bl9hY2Nlc3MgPSBUUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9XUklURTsKKworCWlmIChjb3JlX3RwZ19wb3N0X2FkZGx1bih0cGcsIGx1bl9wLCBsdW5fYWNjZXNzLCBkZXYpIDwgMCkKKwkJcmV0dXJuIE5VTEw7CisKKwlwcmludGsoS0VSTl9JTkZPICIlc19UUEdbJXVdX0xVTlsldV0gLSBBY3RpdmF0ZWQgJXMgTG9naWNhbCBVbml0IGZyb20iCisJCSIgQ09SRSBIQkE6ICV1XG4iLCBUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpLAorCQlUUEdfVEZPKHRwZyktPnRwZ19nZXRfdGFnKHRwZyksIGx1bl9wLT51bnBhY2tlZF9sdW4sCisJCVRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksIGhiYS0+aGJhX2lkKTsKKwkvKgorCSAqIFVwZGF0ZSBMVU4gbWFwcyBmb3IgZHluYW1pY2FsbHkgYWRkZWQgaW5pdGlhdG9ycyB3aGVuCisJICogZ2VuZXJhdGVfbm9kZV9hY2wgaXMgZW5hYmxlZC4KKwkgKi8KKwlpZiAoVFBHX1RGTyh0cGcpLT50cGdfY2hlY2tfZGVtb19tb2RlKHRwZykpIHsKKwkJc3RydWN0IHNlX25vZGVfYWNsICphY2w7CisJCXNwaW5fbG9ja19iaCgmdHBnLT5hY2xfbm9kZV9sb2NrKTsKKwkJbGlzdF9mb3JfZWFjaF9lbnRyeShhY2wsICZ0cGctPmFjbF9ub2RlX2xpc3QsIGFjbF9saXN0KSB7CisJCQlpZiAoYWNsLT5keW5hbWljX25vZGVfYWNsKSB7CisJCQkJc3Bpbl91bmxvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7CisJCQkJY29yZV90cGdfYWRkX25vZGVfdG9fZGV2cyhhY2wsIHRwZyk7CisJCQkJc3Bpbl9sb2NrX2JoKCZ0cGctPmFjbF9ub2RlX2xvY2spOworCQkJfQorCQl9CisJCXNwaW5fdW5sb2NrX2JoKCZ0cGctPmFjbF9ub2RlX2xvY2spOworCX0KKworCXJldHVybiBsdW5fcDsKK30KKworLyogICAgICBjb3JlX2Rldl9kZWxfbHVuKCk6CisgKgorICoKKyAqLworaW50IGNvcmVfZGV2X2RlbF9sdW4oCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnLAorCXUzMiB1bnBhY2tlZF9sdW4pCit7CisJc3RydWN0IHNlX2x1biAqbHVuOworCWludCByZXQgPSAwOworCisJbHVuID0gY29yZV90cGdfcHJlX2RlbGx1bih0cGcsIHVucGFja2VkX2x1biwgJnJldCk7CisJaWYgKCEobHVuKSkKKwkJcmV0dXJuIHJldDsKKworCWNvcmVfdHBnX3Bvc3RfZGVsbHVuKHRwZywgbHVuKTsKKworCXByaW50ayhLRVJOX0lORk8gIiVzX1RQR1sldV1fTFVOWyV1XSAtIERlYWN0aXZhdGVkICVzIExvZ2ljYWwgVW5pdCBmcm9tIgorCQkiIGRldmljZSBvYmplY3RcbiIsIFRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCVRQR19URk8odHBnKS0+dHBnX2dldF90YWcodHBnKSwgdW5wYWNrZWRfbHVuLAorCQlUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpKTsKKworCXJldHVybiAwOworfQorCitzdHJ1Y3Qgc2VfbHVuICpjb3JlX2dldF9sdW5fZnJvbV90cGcoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnLCB1MzIgdW5wYWNrZWRfbHVuKQoreworCXN0cnVjdCBzZV9sdW4gKmx1bjsKKworCXNwaW5fbG9jaygmdHBnLT50cGdfbHVuX2xvY2spOworCWlmICh1bnBhY2tlZF9sdW4gPiAoVFJBTlNQT1JUX01BWF9MVU5TX1BFUl9UUEctMSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICIlcyBMVU46ICV1IGV4Y2VlZHMgVFJBTlNQT1JUX01BWF9MVU5TIgorCQkJIl9QRVJfVFBHLTE6ICV1IGZvciBUYXJnZXQgUG9ydGFsIEdyb3VwOiAlaHVcbiIsCisJCQlUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpLCB1bnBhY2tlZF9sdW4sCisJCQlUUkFOU1BPUlRfTUFYX0xVTlNfUEVSX1RQRy0xLAorCQkJVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3RhZyh0cGcpKTsKKwkJc3Bpbl91bmxvY2soJnRwZy0+dHBnX2x1bl9sb2NrKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCWx1biA9ICZ0cGctPnRwZ19sdW5fbGlzdFt1bnBhY2tlZF9sdW5dOworCisJaWYgKGx1bi0+bHVuX3N0YXR1cyAhPSBUUkFOU1BPUlRfTFVOX1NUQVRVU19GUkVFKSB7CisJCXByaW50ayhLRVJOX0VSUiAiJXMgTG9naWNhbCBVbml0IE51bWJlcjogJXUgaXMgbm90IGZyZWUgb24iCisJCQkiIFRhcmdldCBQb3J0YWwgR3JvdXA6ICVodSwgaWdub3JpbmcgcmVxdWVzdC5cbiIsCisJCQlUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpLCB1bnBhY2tlZF9sdW4sCisJCQlUUEdfVEZPKHRwZyktPnRwZ19nZXRfdGFnKHRwZykpOworCQlzcGluX3VubG9jaygmdHBnLT50cGdfbHVuX2xvY2spOworCQlyZXR1cm4gTlVMTDsKKwl9CisJc3Bpbl91bmxvY2soJnRwZy0+dHBnX2x1bl9sb2NrKTsKKworCXJldHVybiBsdW47Cit9CisKKy8qICAgICAgY29yZV9kZXZfZ2V0X2x1bigpOgorICoKKyAqCisgKi8KK3N0YXRpYyBzdHJ1Y3Qgc2VfbHVuICpjb3JlX2Rldl9nZXRfbHVuKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZywgdTMyIHVucGFja2VkX2x1bikKK3sKKwlzdHJ1Y3Qgc2VfbHVuICpsdW47CisKKwlzcGluX2xvY2soJnRwZy0+dHBnX2x1bl9sb2NrKTsKKwlpZiAodW5wYWNrZWRfbHVuID4gKFRSQU5TUE9SVF9NQVhfTFVOU19QRVJfVFBHLTEpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiJXMgTFVOOiAldSBleGNlZWRzIFRSQU5TUE9SVF9NQVhfTFVOU19QRVIiCisJCQkiX1RQRy0xOiAldSBmb3IgVGFyZ2V0IFBvcnRhbCBHcm91cDogJWh1XG4iLAorCQkJVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSwgdW5wYWNrZWRfbHVuLAorCQkJVFJBTlNQT1JUX01BWF9MVU5TX1BFUl9UUEctMSwKKwkJCVRQR19URk8odHBnKS0+dHBnX2dldF90YWcodHBnKSk7CisJCXNwaW5fdW5sb2NrKCZ0cGctPnRwZ19sdW5fbG9jayk7CisJCXJldHVybiBOVUxMOworCX0KKwlsdW4gPSAmdHBnLT50cGdfbHVuX2xpc3RbdW5wYWNrZWRfbHVuXTsKKworCWlmIChsdW4tPmx1bl9zdGF0dXMgIT0gVFJBTlNQT1JUX0xVTl9TVEFUVVNfQUNUSVZFKSB7CisJCXByaW50ayhLRVJOX0VSUiAiJXMgTG9naWNhbCBVbml0IE51bWJlcjogJXUgaXMgbm90IGFjdGl2ZSBvbiIKKwkJCSIgVGFyZ2V0IFBvcnRhbCBHcm91cDogJWh1LCBpZ25vcmluZyByZXF1ZXN0LlxuIiwKKwkJCVRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksIHVucGFja2VkX2x1biwKKwkJCVRQR19URk8odHBnKS0+dHBnX2dldF90YWcodHBnKSk7CisJCXNwaW5fdW5sb2NrKCZ0cGctPnRwZ19sdW5fbG9jayk7CisJCXJldHVybiBOVUxMOworCX0KKwlzcGluX3VubG9jaygmdHBnLT50cGdfbHVuX2xvY2spOworCisJcmV0dXJuIGx1bjsKK30KKworc3RydWN0IHNlX2x1bl9hY2wgKmNvcmVfZGV2X2luaXRfaW5pdGlhdG9yX25vZGVfbHVuX2FjbCgKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcsCisJdTMyIG1hcHBlZF9sdW4sCisJY2hhciAqaW5pdGlhdG9ybmFtZSwKKwlpbnQgKnJldCkKK3sKKwlzdHJ1Y3Qgc2VfbHVuX2FjbCAqbGFjbDsKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKm5hY2w7CisKKwlpZiAoc3RybGVuKGluaXRpYXRvcm5hbWUpID4gVFJBTlNQT1JUX0lRTl9MRU4pIHsKKwkJcHJpbnRrKEtFUk5fRVJSICIlcyBJbml0aWF0b3JOYW1lIGV4Y2VlZHMgbWF4aW11bSBzaXplLlxuIiwKKwkJCVRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCkpOworCQkqcmV0ID0gLUVPVkVSRkxPVzsKKwkJcmV0dXJuIE5VTEw7CisJfQorCW5hY2wgPSBjb3JlX3RwZ19nZXRfaW5pdGlhdG9yX25vZGVfYWNsKHRwZywgaW5pdGlhdG9ybmFtZSk7CisJaWYgKCEobmFjbCkpIHsKKwkJKnJldCA9IC1FSU5WQUw7CisJCXJldHVybiBOVUxMOworCX0KKwlsYWNsID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHNlX2x1bl9hY2wpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIShsYWNsKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIHN0cnVjdCBzZV9sdW5fYWNsLlxuIik7CisJCSpyZXQgPSAtRU5PTUVNOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlJTklUX0xJU1RfSEVBRCgmbGFjbC0+bGFjbF9saXN0KTsKKwlsYWNsLT5tYXBwZWRfbHVuID0gbWFwcGVkX2x1bjsKKwlsYWNsLT5zZV9sdW5fbmFjbCA9IG5hY2w7CisJc25wcmludGYobGFjbC0+aW5pdGlhdG9ybmFtZSwgVFJBTlNQT1JUX0lRTl9MRU4sICIlcyIsIGluaXRpYXRvcm5hbWUpOworCisJcmV0dXJuIGxhY2w7Cit9CisKK2ludCBjb3JlX2Rldl9hZGRfaW5pdGlhdG9yX25vZGVfbHVuX2FjbCgKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcsCisJc3RydWN0IHNlX2x1bl9hY2wgKmxhY2wsCisJdTMyIHVucGFja2VkX2x1biwKKwl1MzIgbHVuX2FjY2VzcykKK3sKKwlzdHJ1Y3Qgc2VfbHVuICpsdW47CisJc3RydWN0IHNlX25vZGVfYWNsICpuYWNsOworCisJbHVuID0gY29yZV9kZXZfZ2V0X2x1bih0cGcsIHVucGFja2VkX2x1bik7CisJaWYgKCEobHVuKSkgeworCQlwcmludGsoS0VSTl9FUlIgIiVzIExvZ2ljYWwgVW5pdCBOdW1iZXI6ICV1IGlzIG5vdCBhY3RpdmUgb24iCisJCQkiIFRhcmdldCBQb3J0YWwgR3JvdXA6ICVodSwgaWdub3JpbmcgcmVxdWVzdC5cbiIsCisJCQlUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpLCB1bnBhY2tlZF9sdW4sCisJCQlUUEdfVEZPKHRwZyktPnRwZ19nZXRfdGFnKHRwZykpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwluYWNsID0gbGFjbC0+c2VfbHVuX25hY2w7CisJaWYgKCEobmFjbCkpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKChsdW4tPmx1bl9hY2Nlc3MgJiBUUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9PTkxZKSAmJgorCSAgICAobHVuX2FjY2VzcyAmIFRSQU5TUE9SVF9MVU5GTEFHU19SRUFEX1dSSVRFKSkKKwkJbHVuX2FjY2VzcyA9IFRSQU5TUE9SVF9MVU5GTEFHU19SRUFEX09OTFk7CisKKwlsYWNsLT5zZV9sdW4gPSBsdW47CisKKwlpZiAoY29yZV91cGRhdGVfZGV2aWNlX2xpc3RfZm9yX25vZGUobHVuLCBsYWNsLCBsYWNsLT5tYXBwZWRfbHVuLAorCQkJbHVuX2FjY2VzcywgbmFjbCwgdHBnLCAxKSA8IDApCisJCXJldHVybiAtRUlOVkFMOworCisJc3Bpbl9sb2NrKCZsdW4tPmx1bl9hY2xfbG9jayk7CisJbGlzdF9hZGRfdGFpbCgmbGFjbC0+bGFjbF9saXN0LCAmbHVuLT5sdW5fYWNsX2xpc3QpOworCWF0b21pY19pbmMoJmx1bi0+bHVuX2FjbF9jb3VudCk7CisJc21wX21iX19hZnRlcl9hdG9taWNfaW5jKCk7CisJc3Bpbl91bmxvY2soJmx1bi0+bHVuX2FjbF9sb2NrKTsKKworCXByaW50ayhLRVJOX0lORk8gIiVzX1RQR1slaHVdX0xVTlsldS0+JXVdIC0gQWRkZWQgJXMgQUNMIGZvciAiCisJCSIgSW5pdGlhdG9yTm9kZTogJXNcbiIsIFRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCVRQR19URk8odHBnKS0+dHBnX2dldF90YWcodHBnKSwgdW5wYWNrZWRfbHVuLCBsYWNsLT5tYXBwZWRfbHVuLAorCQkobHVuX2FjY2VzcyAmIFRSQU5TUE9SVF9MVU5GTEFHU19SRUFEX1dSSVRFKSA/ICJSVyIgOiAiUk8iLAorCQlsYWNsLT5pbml0aWF0b3JuYW1lKTsKKwkvKgorCSAqIENoZWNrIHRvIHNlZSBpZiB0aGVyZSBhcmUgYW55IGV4aXN0aW5nIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gQVBUUEwKKwkgKiBwcmUtcmVnaXN0cmF0aW9ucyB0aGF0IG5lZWQgdG8gYmUgZW5hYmxlZCBmb3IgdGhpcyBMVU4gQUNMLi4KKwkgKi8KKwljb3JlX3Njc2kzX2NoZWNrX2FwdHBsX3JlZ2lzdHJhdGlvbihsdW4tPmx1bl9zZV9kZXYsIHRwZywgbHVuLCBsYWNsKTsKKwlyZXR1cm4gMDsKK30KKworLyogICAgICBjb3JlX2Rldl9kZWxfaW5pdGlhdG9yX25vZGVfbHVuX2FjbCgpOgorICoKKyAqCisgKi8KK2ludCBjb3JlX2Rldl9kZWxfaW5pdGlhdG9yX25vZGVfbHVuX2FjbCgKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcsCisJc3RydWN0IHNlX2x1biAqbHVuLAorCXN0cnVjdCBzZV9sdW5fYWNsICpsYWNsKQoreworCXN0cnVjdCBzZV9ub2RlX2FjbCAqbmFjbDsKKworCW5hY2wgPSBsYWNsLT5zZV9sdW5fbmFjbDsKKwlpZiAoIShuYWNsKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlzcGluX2xvY2soJmx1bi0+bHVuX2FjbF9sb2NrKTsKKwlsaXN0X2RlbCgmbGFjbC0+bGFjbF9saXN0KTsKKwlhdG9taWNfZGVjKCZsdW4tPmx1bl9hY2xfY291bnQpOworCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworCXNwaW5fdW5sb2NrKCZsdW4tPmx1bl9hY2xfbG9jayk7CisKKwljb3JlX3VwZGF0ZV9kZXZpY2VfbGlzdF9mb3Jfbm9kZShsdW4sIE5VTEwsIGxhY2wtPm1hcHBlZF9sdW4sCisJCVRSQU5TUE9SVF9MVU5GTEFHU19OT19BQ0NFU1MsIG5hY2wsIHRwZywgMCk7CisKKwlsYWNsLT5zZV9sdW4gPSBOVUxMOworCisJcHJpbnRrKEtFUk5fSU5GTyAiJXNfVFBHWyVodV1fTFVOWyV1XSAtIFJlbW92ZWQgQUNMIGZvciIKKwkJIiBJbml0aWF0b3JOb2RlOiAlcyBNYXBwZWQgTFVOOiAldVxuIiwKKwkJVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3RhZyh0cGcpLCBsdW4tPnVucGFja2VkX2x1biwKKwkJbGFjbC0+aW5pdGlhdG9ybmFtZSwgbGFjbC0+bWFwcGVkX2x1bik7CisKKwlyZXR1cm4gMDsKK30KKwordm9pZCBjb3JlX2Rldl9mcmVlX2luaXRpYXRvcl9ub2RlX2x1bl9hY2woCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnLAorCXN0cnVjdCBzZV9sdW5fYWNsICpsYWNsKQoreworCXByaW50aygiJXNfVFBHWyVodV0gLSBGcmVlaW5nIEFDTCBmb3IgJXMgSW5pdGlhdG9yTm9kZTogJXMiCisJCSIgTWFwcGVkIExVTjogJXVcbiIsIFRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCVRQR19URk8odHBnKS0+dHBnX2dldF90YWcodHBnKSwKKwkJVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJbGFjbC0+aW5pdGlhdG9ybmFtZSwgbGFjbC0+bWFwcGVkX2x1bik7CisKKwlrZnJlZShsYWNsKTsKK30KKworaW50IGNvcmVfZGV2X3NldHVwX3ZpcnR1YWxfbHVuMCh2b2lkKQoreworCXN0cnVjdCBzZV9oYmEgKmhiYTsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXY7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiA9IE5VTEw7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9hcGkgKnQ7CisJY2hhciBidWZbMTZdOworCWludCByZXQ7CisKKwloYmEgPSBjb3JlX2FsbG9jX2hiYSgicmRfZHIiLCAwLCBIQkFfRkxBR1NfSU5URVJOQUxfVVNFKTsKKwlpZiAoSVNfRVJSKGhiYSkpCisJCXJldHVybiBQVFJfRVJSKGhiYSk7CisKKwlzZV9nbG9iYWwtPmdfbHVuMF9oYmEgPSBoYmE7CisJdCA9IGhiYS0+dHJhbnNwb3J0OworCisJc2VfZGV2ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIShzZV9kZXYpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIG1lbW9yeSBmb3IiCisJCQkJIiBzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldlxuIik7CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gb3V0OworCX0KKwlJTklUX0xJU1RfSEVBRCgmc2VfZGV2LT5nX3NlX2Rldl9saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmc2VfZGV2LT50MTBfd3duLnQxMF92cGRfbGlzdCk7CisJc3Bpbl9sb2NrX2luaXQoJnNlX2Rldi0+dDEwX3d3bi50MTBfdnBkX2xvY2spOworCUlOSVRfTElTVF9IRUFEKCZzZV9kZXYtPnQxMF9yZXNlcnZhdGlvbi5yZWdpc3RyYXRpb25fbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJnNlX2Rldi0+dDEwX3Jlc2VydmF0aW9uLmFwdHBsX3JlZ19saXN0KTsKKwlzcGluX2xvY2tfaW5pdCgmc2VfZGV2LT50MTBfcmVzZXJ2YXRpb24ucmVnaXN0cmF0aW9uX2xvY2spOworCXNwaW5fbG9ja19pbml0KCZzZV9kZXYtPnQxMF9yZXNlcnZhdGlvbi5hcHRwbF9yZWdfbG9jayk7CisJSU5JVF9MSVNUX0hFQUQoJnNlX2Rldi0+dDEwX2FsdWEudGdfcHRfZ3BzX2xpc3QpOworCXNwaW5fbG9ja19pbml0KCZzZV9kZXYtPnQxMF9hbHVhLnRnX3B0X2dwc19sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmc2VfZGV2LT5zZV9kZXZfbG9jayk7CisJc2VfZGV2LT50MTBfcmVzZXJ2YXRpb24ucHJfYXB0cGxfYnVmX2xlbiA9IFBSX0FQVFBMX0JVRl9MRU47CisJc2VfZGV2LT50MTBfd3duLnQxMF9zdWJfZGV2ID0gc2VfZGV2OworCXNlX2Rldi0+dDEwX2FsdWEudDEwX3N1Yl9kZXYgPSBzZV9kZXY7CisJc2VfZGV2LT5zZV9kZXZfYXR0cmliLmRhX3N1Yl9kZXYgPSBzZV9kZXY7CisJc2VfZGV2LT5zZV9kZXZfaGJhID0gaGJhOworCisJc2VfZGV2LT5zZV9kZXZfc3VfcHRyID0gdC0+YWxsb2NhdGVfdmlydGRldmljZShoYmEsICJ2aXJ0X2x1bjAiKTsKKwlpZiAoIShzZV9kZXYtPnNlX2Rldl9zdV9wdHIpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGxvY2F0ZSBzdWJzeXN0ZW0gZGVwZW5kZW50IHBvaW50ZXIiCisJCQkiIGZyb20gYWxsb2NhdGVfdmlydGRldmljZSgpXG4iKTsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBvdXQ7CisJfQorCXNlX2dsb2JhbC0+Z19sdW4wX3N1X2RldiA9IHNlX2RldjsKKworCW1lbXNldChidWYsIDAsIDE2KTsKKwlzcHJpbnRmKGJ1ZiwgInJkX3BhZ2VzPTgiKTsKKwl0LT5zZXRfY29uZmlnZnNfZGV2X3BhcmFtcyhoYmEsIHNlX2RldiwgYnVmLCBzaXplb2YoYnVmKSk7CisKKwlkZXYgPSB0LT5jcmVhdGVfdmlydGRldmljZShoYmEsIHNlX2Rldiwgc2VfZGV2LT5zZV9kZXZfc3VfcHRyKTsKKwlpZiAoIShkZXYpIHx8IElTX0VSUihkZXYpKSB7CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gb3V0OworCX0KKwlzZV9kZXYtPnNlX2Rldl9wdHIgPSBkZXY7CisJc2VfZ2xvYmFsLT5nX2x1bjBfZGV2ID0gZGV2OworCisJcmV0dXJuIDA7CitvdXQ6CisJc2VfZ2xvYmFsLT5nX2x1bjBfc3VfZGV2ID0gTlVMTDsKKwlrZnJlZShzZV9kZXYpOworCWlmIChzZV9nbG9iYWwtPmdfbHVuMF9oYmEpIHsKKwkJY29yZV9kZWxldGVfaGJhKHNlX2dsb2JhbC0+Z19sdW4wX2hiYSk7CisJCXNlX2dsb2JhbC0+Z19sdW4wX2hiYSA9IE5VTEw7CisJfQorCXJldHVybiByZXQ7Cit9CisKKwordm9pZCBjb3JlX2Rldl9yZWxlYXNlX3ZpcnR1YWxfbHVuMCh2b2lkKQoreworCXN0cnVjdCBzZV9oYmEgKmhiYSA9IHNlX2dsb2JhbC0+Z19sdW4wX2hiYTsKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2ID0gc2VfZ2xvYmFsLT5nX2x1bjBfc3VfZGV2OworCisJaWYgKCEoaGJhKSkKKwkJcmV0dXJuOworCisJaWYgKHNlX2dsb2JhbC0+Z19sdW4wX2RldikKKwkJc2VfZnJlZV92aXJ0dWFsX2RldmljZShzZV9nbG9iYWwtPmdfbHVuMF9kZXYsIGhiYSk7CisKKwlrZnJlZShzdV9kZXYpOworCWNvcmVfZGVsZXRlX2hiYShoYmEpOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX2NvbmZpZ2ZzLmMgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfY29uZmlnZnMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zMmIxNDhkCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX2NvbmZpZ2ZzLmMKQEAgLTAsMCArMSw5OTYgQEAKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisqIEZpbGVuYW1lOiB0YXJnZXRfY29yZV9mYWJyaWNfY29uZmlnZnMuYworICoKKyAqIFRoaXMgZmlsZSBjb250YWlucyBnZW5lcmljIGZhYnJpYyBtb2R1bGUgY29uZmlnZnMgaW5mcmFzdHJ1Y3R1cmUgZm9yCisgKiBUQ00gdjQueCBjb2RlCisgKgorICogQ29weXJpZ2h0IChjKSAyMDEwIFJpc2luZyBUaWRlIFN5c3RlbXMKKyAqIENvcHlyaWdodCAoYykgMjAxMCBMaW51eC1pU0NTSS5vcmcKKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMTAgTmljaG9sYXMgQS4gQmVsbGluZ2VyIDxuYWJAbGludXgtaXNjc2kub3JnPgorKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGVwYXJhbS5oPgorI2luY2x1ZGUgPGxpbnV4L3ZlcnNpb24uaD4KKyNpbmNsdWRlIDxnZW5lcmF0ZWQvdXRzcmVsZWFzZS5oPgorI2luY2x1ZGUgPGxpbnV4L3V0c25hbWUuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9uYW1laS5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGludXgvdW5pc3RkLmg+CisjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CisjaW5jbHVkZSA8bGludXgvc3lzY2FsbHMuaD4KKyNpbmNsdWRlIDxsaW51eC9jb25maWdmcy5oPgorCisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2Jhc2UuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfZGV2aWNlLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX3RwZy5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV90cmFuc3BvcnQuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX29wcy5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfY29uZmlnZnMuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfY29uZmlnZnMuaD4KKyNpbmNsdWRlIDx0YXJnZXQvY29uZmlnZnNfbWFjcm9zLmg+CisKKyNpbmNsdWRlICJ0YXJnZXRfY29yZV9hbHVhLmgiCisjaW5jbHVkZSAidGFyZ2V0X2NvcmVfaGJhLmgiCisjaW5jbHVkZSAidGFyZ2V0X2NvcmVfcHIuaCIKKworI2RlZmluZSBURl9DSVRfU0VUVVAoX25hbWUsIF9pdGVtX29wcywgX2dyb3VwX29wcywgX2F0dHJzKQkJXAorc3RhdGljIHZvaWQgdGFyZ2V0X2ZhYnJpY19zZXR1cF8jI19uYW1lIyNfY2l0KHN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzICp0ZikgXAorewkJCQkJCQkJCVwKKwlzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19jb25maWdmc190ZW1wbGF0ZSAqdGZjID0gJnRmLT50Zl9jaXRfdG1wbDsJXAorCXN0cnVjdCBjb25maWdfaXRlbV90eXBlICpjaXQgPSAmdGZjLT50ZmNfIyNfbmFtZSMjX2NpdDsJCVwKKwkJCQkJCQkJCVwKKwljaXQtPmN0X2l0ZW1fb3BzID0gX2l0ZW1fb3BzOwkJCQkJXAorCWNpdC0+Y3RfZ3JvdXBfb3BzID0gX2dyb3VwX29wczsJCQkJCVwKKwljaXQtPmN0X2F0dHJzID0gX2F0dHJzOwkJCQkJCVwKKwljaXQtPmN0X293bmVyID0gdGYtPnRmX21vZHVsZTsJCQkJCVwKKwlwcmludGsoIlNldHVwIGdlbmVyaWMgJXNcbiIsIF9fc3RyaW5naWZ5KF9uYW1lKSk7CQlcCit9CisKKy8qIFN0YXJ0IG9mIHRmY190cGdfbWFwcGVkbHVuX2NpdCAqLworCitzdGF0aWMgaW50IHRhcmdldF9mYWJyaWNfbWFwcGVkbHVuX2xpbmsoCisJc3RydWN0IGNvbmZpZ19pdGVtICpsdW5fYWNsX2NpLAorCXN0cnVjdCBjb25maWdfaXRlbSAqbHVuX2NpKQoreworCXN0cnVjdCBzZV9kZXZfZW50cnkgKmRldmU7CisJc3RydWN0IHNlX2x1biAqbHVuID0gY29udGFpbmVyX29mKHRvX2NvbmZpZ19ncm91cChsdW5fY2kpLAorCQkJc3RydWN0IHNlX2x1biwgbHVuX2dyb3VwKTsKKwlzdHJ1Y3Qgc2VfbHVuX2FjbCAqbGFjbCA9IGNvbnRhaW5lcl9vZih0b19jb25maWdfZ3JvdXAobHVuX2FjbF9jaSksCisJCQlzdHJ1Y3Qgc2VfbHVuX2FjbCwgc2VfbHVuX2dyb3VwKTsKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGc7CisJc3RydWN0IGNvbmZpZ19pdGVtICpuYWNsX2NpLCAqdHBnX2NpLCAqdHBnX2NpX3MsICp3d25fY2ksICp3d25fY2lfczsKKwlpbnQgcmV0ID0gMCwgbHVuX2FjY2VzczsKKwkvKgorCSAqIEVuc3VyZSB0aGF0IHRoZSBzb3VyY2UgcG9ydCBleGlzdHMKKwkgKi8KKwlpZiAoIShsdW4tPmx1bl9zZXApIHx8ICEobHVuLT5sdW5fc2VwLT5zZXBfdHBnKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlNvdXJjZSBzZV9sdW4tPmx1bl9zZXAgb3IgbHVuLT5sdW5fc2VwLT5zZXAiCisJCQkJIl90cGcgZG9lcyBub3QgZXhpc3RcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJc2VfdHBnID0gbHVuLT5sdW5fc2VwLT5zZXBfdHBnOworCisJbmFjbF9jaSA9ICZsdW5fYWNsX2NpLT5jaV9wYXJlbnQtPmNpX2dyb3VwLT5jZ19pdGVtOworCXRwZ19jaSA9ICZuYWNsX2NpLT5jaV9ncm91cC0+Y2dfaXRlbTsKKwl3d25fY2kgPSAmdHBnX2NpLT5jaV9ncm91cC0+Y2dfaXRlbTsKKwl0cGdfY2lfcyA9ICZsdW5fY2ktPmNpX3BhcmVudC0+Y2lfZ3JvdXAtPmNnX2l0ZW07CisJd3duX2NpX3MgPSAmdHBnX2NpX3MtPmNpX2dyb3VwLT5jZ19pdGVtOworCS8qCisJICogTWFrZSBzdXJlIHRoZSBTeW1MaW5rIGlzIGdvaW5nIHRvIHRoZSBzYW1lICRGQUJSSUMvJFdXTi90cGd0XyRUUEdUCisJICovCisJaWYgKHN0cmNtcChjb25maWdfaXRlbV9uYW1lKHd3bl9jaSksIGNvbmZpZ19pdGVtX25hbWUod3duX2NpX3MpKSkgeworCQlwcmludGsoS0VSTl9FUlIgIklsbGVnYWwgSW5pdGlhdG9yIEFDTCBTeW1MaW5rIG91dHNpZGUgb2YgJXNcbiIsCisJCQljb25maWdfaXRlbV9uYW1lKHd3bl9jaSkpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYgKHN0cmNtcChjb25maWdfaXRlbV9uYW1lKHRwZ19jaSksIGNvbmZpZ19pdGVtX25hbWUodHBnX2NpX3MpKSkgeworCQlwcmludGsoS0VSTl9FUlIgIklsbGVnYWwgSW5pdGlhdG9yIEFDTCBTeW1saW5rIG91dHNpZGUgb2YgJXMiCisJCQkiIFRQR1Q6ICVzXG4iLCBjb25maWdfaXRlbV9uYW1lKHd3bl9jaSksCisJCQljb25maWdfaXRlbV9uYW1lKHRwZ19jaSkpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJLyoKKwkgKiBJZiB0aGlzIHN0cnVjdCBzZV9ub2RlX2FjbCB3YXMgZHluYW1pY2FsbHkgZ2VuZXJhdGVkIHdpdGgKKwkgKiB0cGdfMS9hdHRyaWIvZ2VuZXJhdGVfbm9kZV9hY2xzPTEsIHVzZSB0aGUgZXhpc3RpbmcgZGV2ZS0+bHVuX2ZsYWdzLAorCSAqIHdoaWNoIGJlIHdpbGwgd3JpdGUgcHJvdGVjdGVkIChSRUFELU9OTFkpIHdoZW4KKwkgKiB0cGdfMS9hdHRyaWIvZGVtb19tb2RlX3dyaXRlX3Byb3RlY3Q9MQorCSAqLworCXNwaW5fbG9ja19pcnEoJmxhY2wtPnNlX2x1bl9uYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKwlkZXZlID0gJmxhY2wtPnNlX2x1bl9uYWNsLT5kZXZpY2VfbGlzdFtsYWNsLT5tYXBwZWRfbHVuXTsKKwlpZiAoZGV2ZS0+bHVuX2ZsYWdzICYgVFJBTlNQT1JUX0xVTkZMQUdTX0lOSVRJQVRPUl9BQ0NFU1MpCisJCWx1bl9hY2Nlc3MgPSBkZXZlLT5sdW5fZmxhZ3M7CisJZWxzZQorCQlsdW5fYWNjZXNzID0KKwkJCShUUEdfVEZPKHNlX3RwZyktPnRwZ19jaGVja19wcm9kX21vZGVfd3JpdGVfcHJvdGVjdCgKKwkJCQlzZV90cGcpKSA/IFRSQU5TUE9SVF9MVU5GTEFHU19SRUFEX09OTFkgOgorCQkJCQkgICBUUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9XUklURTsKKwlzcGluX3VubG9ja19pcnEoJmxhY2wtPnNlX2x1bl9uYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKwkvKgorCSAqIERldGVybWluZSB0aGUgYWN0dWFsIG1hcHBlZCBMVU4gdmFsdWUgdXNlciB3YW50cy4uCisJICoKKwkgKiBUaGlzIHZhbHVlIGlzIHdoYXQgdGhlIFNDU0kgSW5pdGlhdG9yIGFjdHVhbGx5IHNlZXMgdGhlCisJICogaXNjc2kvJElRTi8kVFBHVC9sdW4vbHVuXyogYXMgb24gdGhlaXIgU0NTSSBJbml0aWF0b3IgUG9ydHMuCisJICovCisJcmV0ID0gY29yZV9kZXZfYWRkX2luaXRpYXRvcl9ub2RlX2x1bl9hY2woc2VfdHBnLCBsYWNsLAorCQkJbHVuLT51bnBhY2tlZF9sdW4sIGx1bl9hY2Nlc3MpOworCisJcmV0dXJuIChyZXQgPCAwKSA/IC1FSU5WQUwgOiAwOworfQorCitzdGF0aWMgaW50IHRhcmdldF9mYWJyaWNfbWFwcGVkbHVuX3VubGluaygKKwlzdHJ1Y3QgY29uZmlnX2l0ZW0gKmx1bl9hY2xfY2ksCisJc3RydWN0IGNvbmZpZ19pdGVtICpsdW5fY2kpCit7CisJc3RydWN0IHNlX2x1biAqbHVuOworCXN0cnVjdCBzZV9sdW5fYWNsICpsYWNsID0gY29udGFpbmVyX29mKHRvX2NvbmZpZ19ncm91cChsdW5fYWNsX2NpKSwKKwkJCXN0cnVjdCBzZV9sdW5fYWNsLCBzZV9sdW5fZ3JvdXApOworCXN0cnVjdCBzZV9ub2RlX2FjbCAqbmFjbCA9IGxhY2wtPnNlX2x1bl9uYWNsOworCXN0cnVjdCBzZV9kZXZfZW50cnkgKmRldmUgPSAmbmFjbC0+ZGV2aWNlX2xpc3RbbGFjbC0+bWFwcGVkX2x1bl07CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnOworCS8qCisJICogRGV0ZXJtaW5lIGlmIHRoZSB1bmRlcmx5aW5nIE1hcHBlZExVTiBoYXMgYWxyZWFkeSBiZWVuIHJlbGVhc2VkLi4KKwkgKi8KKwlpZiAoIShkZXZlLT5zZV9sdW4pKQorCQlyZXR1cm4gMDsKKworCWx1biA9IGNvbnRhaW5lcl9vZih0b19jb25maWdfZ3JvdXAobHVuX2NpKSwgc3RydWN0IHNlX2x1biwgbHVuX2dyb3VwKTsKKwlzZV90cGcgPSBsdW4tPmx1bl9zZXAtPnNlcF90cGc7CisKKwljb3JlX2Rldl9kZWxfaW5pdGlhdG9yX25vZGVfbHVuX2FjbChzZV90cGcsIGx1biwgbGFjbCk7CisJcmV0dXJuIDA7Cit9CisKK0NPTkZJR0ZTX0VBVFRSX1NUUlVDVCh0YXJnZXRfZmFicmljX21hcHBlZGx1biwgc2VfbHVuX2FjbCk7CisjZGVmaW5lIFRDTV9NQVBQRURMVU5fQVRUUihfbmFtZSwgX21vZGUpCQkJCVwKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19tYXBwZWRsdW5fYXR0cmlidXRlIHRhcmdldF9mYWJyaWNfbWFwcGVkbHVuXyMjX25hbWUgPSBcCisJX19DT05GSUdGU19FQVRUUihfbmFtZSwgX21vZGUsCQkJCQlcCisJdGFyZ2V0X2ZhYnJpY19tYXBwZWRsdW5fc2hvd18jI19uYW1lLAkJCQlcCisJdGFyZ2V0X2ZhYnJpY19tYXBwZWRsdW5fc3RvcmVfIyNfbmFtZSk7CisKK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9mYWJyaWNfbWFwcGVkbHVuX3Nob3dfd3JpdGVfcHJvdGVjdCgKKwlzdHJ1Y3Qgc2VfbHVuX2FjbCAqbGFjbCwKKwljaGFyICpwYWdlKQoreworCXN0cnVjdCBzZV9ub2RlX2FjbCAqc2VfbmFjbCA9IGxhY2wtPnNlX2x1bl9uYWNsOworCXN0cnVjdCBzZV9kZXZfZW50cnkgKmRldmU7CisJc3NpemVfdCBsZW47CisKKwlzcGluX2xvY2tfaXJxKCZzZV9uYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKwlkZXZlID0gJnNlX25hY2wtPmRldmljZV9saXN0W2xhY2wtPm1hcHBlZF9sdW5dOworCWxlbiA9IHNwcmludGYocGFnZSwgIiVkXG4iLAorCQkJKGRldmUtPmx1bl9mbGFncyAmIFRSQU5TUE9SVF9MVU5GTEFHU19SRUFEX09OTFkpID8KKwkJCTEgOiAwKTsKKwlzcGluX3VubG9ja19pcnEoJnNlX25hY2wtPmRldmljZV9saXN0X2xvY2spOworCisJcmV0dXJuIGxlbjsKK30KKworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2ZhYnJpY19tYXBwZWRsdW5fc3RvcmVfd3JpdGVfcHJvdGVjdCgKKwlzdHJ1Y3Qgc2VfbHVuX2FjbCAqbGFjbCwKKwljb25zdCBjaGFyICpwYWdlLAorCXNpemVfdCBjb3VudCkKK3sKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKnNlX25hY2wgPSBsYWNsLT5zZV9sdW5fbmFjbDsKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcgPSBzZV9uYWNsLT5zZV90cGc7CisJdW5zaWduZWQgbG9uZyBvcDsKKworCWlmIChzdHJpY3Rfc3RydG91bChwYWdlLCAwLCAmb3ApKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlmICgob3AgIT0gMSkgJiYgKG9wICE9IDApKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWNvcmVfdXBkYXRlX2RldmljZV9saXN0X2FjY2VzcyhsYWNsLT5tYXBwZWRfbHVuLCAob3ApID8KKwkJCVRSQU5TUE9SVF9MVU5GTEFHU19SRUFEX09OTFkgOgorCQkJVFJBTlNQT1JUX0xVTkZMQUdTX1JFQURfV1JJVEUsCisJCQlsYWNsLT5zZV9sdW5fbmFjbCk7CisKKwlwcmludGsoS0VSTl9JTkZPICIlc19Db25maWdGUzogQ2hhbmdlZCBJbml0aWF0b3IgQUNMOiAlcyIKKwkJIiBNYXBwZWQgTFVOOiAldSBXcml0ZSBQcm90ZWN0IGJpdCB0byAlc1xuIiwKKwkJVFBHX1RGTyhzZV90cGcpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJbGFjbC0+aW5pdGlhdG9ybmFtZSwgbGFjbC0+bWFwcGVkX2x1biwgKG9wKSA/ICJPTiIgOiAiT0ZGIik7CisKKwlyZXR1cm4gY291bnQ7CisKK30KKworVENNX01BUFBFRExVTl9BVFRSKHdyaXRlX3Byb3RlY3QsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworQ09ORklHRlNfRUFUVFJfT1BTKHRhcmdldF9mYWJyaWNfbWFwcGVkbHVuLCBzZV9sdW5fYWNsLCBzZV9sdW5fZ3JvdXApOworCitzdGF0aWMgc3RydWN0IGNvbmZpZ2ZzX2F0dHJpYnV0ZSAqdGFyZ2V0X2ZhYnJpY19tYXBwZWRsdW5fYXR0cnNbXSA9IHsKKwkmdGFyZ2V0X2ZhYnJpY19tYXBwZWRsdW5fd3JpdGVfcHJvdGVjdC5hdHRyLAorCU5VTEwsCit9OworCitzdGF0aWMgc3RydWN0IGNvbmZpZ2ZzX2l0ZW1fb3BlcmF0aW9ucyB0YXJnZXRfZmFicmljX21hcHBlZGx1bl9pdGVtX29wcyA9IHsKKwkuc2hvd19hdHRyaWJ1dGUJCT0gdGFyZ2V0X2ZhYnJpY19tYXBwZWRsdW5fYXR0cl9zaG93LAorCS5zdG9yZV9hdHRyaWJ1dGUJPSB0YXJnZXRfZmFicmljX21hcHBlZGx1bl9hdHRyX3N0b3JlLAorCS5hbGxvd19saW5rCQk9IHRhcmdldF9mYWJyaWNfbWFwcGVkbHVuX2xpbmssCisJLmRyb3BfbGluawkJPSB0YXJnZXRfZmFicmljX21hcHBlZGx1bl91bmxpbmssCit9OworCitURl9DSVRfU0VUVVAodHBnX21hcHBlZGx1biwgJnRhcmdldF9mYWJyaWNfbWFwcGVkbHVuX2l0ZW1fb3BzLCBOVUxMLAorCQl0YXJnZXRfZmFicmljX21hcHBlZGx1bl9hdHRycyk7CisKKy8qIEVuZCBvZiB0ZmNfdHBnX21hcHBlZGx1bl9jaXQgKi8KKworLyogU3RhcnQgb2YgdGZjX3RwZ19uYWNsX2F0dHJpYl9jaXQgKi8KKworQ09ORklHRlNfRUFUVFJfT1BTKHRhcmdldF9mYWJyaWNfbmFjbF9hdHRyaWIsIHNlX25vZGVfYWNsLCBhY2xfYXR0cmliX2dyb3VwKTsKKworc3RhdGljIHN0cnVjdCBjb25maWdmc19pdGVtX29wZXJhdGlvbnMgdGFyZ2V0X2ZhYnJpY19uYWNsX2F0dHJpYl9pdGVtX29wcyA9IHsKKwkuc2hvd19hdHRyaWJ1dGUJCT0gdGFyZ2V0X2ZhYnJpY19uYWNsX2F0dHJpYl9hdHRyX3Nob3csCisJLnN0b3JlX2F0dHJpYnV0ZQk9IHRhcmdldF9mYWJyaWNfbmFjbF9hdHRyaWJfYXR0cl9zdG9yZSwKK307CisKK1RGX0NJVF9TRVRVUCh0cGdfbmFjbF9hdHRyaWIsICZ0YXJnZXRfZmFicmljX25hY2xfYXR0cmliX2l0ZW1fb3BzLCBOVUxMLCBOVUxMKTsKKworLyogRW5kIG9mIHRmY190cGdfbmFjbF9hdHRyaWJfY2l0ICovCisKKy8qIFN0YXJ0IG9mIHRmY190cGdfbmFjbF9hdXRoX2NpdCAqLworCitDT05GSUdGU19FQVRUUl9PUFModGFyZ2V0X2ZhYnJpY19uYWNsX2F1dGgsIHNlX25vZGVfYWNsLCBhY2xfYXV0aF9ncm91cCk7CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfaXRlbV9vcGVyYXRpb25zIHRhcmdldF9mYWJyaWNfbmFjbF9hdXRoX2l0ZW1fb3BzID0geworCS5zaG93X2F0dHJpYnV0ZQkJPSB0YXJnZXRfZmFicmljX25hY2xfYXV0aF9hdHRyX3Nob3csCisJLnN0b3JlX2F0dHJpYnV0ZQk9IHRhcmdldF9mYWJyaWNfbmFjbF9hdXRoX2F0dHJfc3RvcmUsCit9OworCitURl9DSVRfU0VUVVAodHBnX25hY2xfYXV0aCwgJnRhcmdldF9mYWJyaWNfbmFjbF9hdXRoX2l0ZW1fb3BzLCBOVUxMLCBOVUxMKTsKKworLyogRW5kIG9mIHRmY190cGdfbmFjbF9hdXRoX2NpdCAqLworCisvKiBTdGFydCBvZiB0ZmNfdHBnX25hY2xfcGFyYW1fY2l0ICovCisKK0NPTkZJR0ZTX0VBVFRSX09QUyh0YXJnZXRfZmFicmljX25hY2xfcGFyYW0sIHNlX25vZGVfYWNsLCBhY2xfcGFyYW1fZ3JvdXApOworCitzdGF0aWMgc3RydWN0IGNvbmZpZ2ZzX2l0ZW1fb3BlcmF0aW9ucyB0YXJnZXRfZmFicmljX25hY2xfcGFyYW1faXRlbV9vcHMgPSB7CisJLnNob3dfYXR0cmlidXRlCQk9IHRhcmdldF9mYWJyaWNfbmFjbF9wYXJhbV9hdHRyX3Nob3csCisJLnN0b3JlX2F0dHJpYnV0ZQk9IHRhcmdldF9mYWJyaWNfbmFjbF9wYXJhbV9hdHRyX3N0b3JlLAorfTsKKworVEZfQ0lUX1NFVFVQKHRwZ19uYWNsX3BhcmFtLCAmdGFyZ2V0X2ZhYnJpY19uYWNsX3BhcmFtX2l0ZW1fb3BzLCBOVUxMLCBOVUxMKTsKKworLyogRW5kIG9mIHRmY190cGdfbmFjbF9wYXJhbV9jaXQgKi8KKworLyogU3RhcnQgb2YgdGZjX3RwZ19uYWNsX2Jhc2VfY2l0ICovCisKK0NPTkZJR0ZTX0VBVFRSX09QUyh0YXJnZXRfZmFicmljX25hY2xfYmFzZSwgc2Vfbm9kZV9hY2wsIGFjbF9ncm91cCk7CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnX2dyb3VwICp0YXJnZXRfZmFicmljX21ha2VfbWFwcGVkbHVuKAorCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLAorCWNvbnN0IGNoYXIgKm5hbWUpCit7CisJc3RydWN0IHNlX25vZGVfYWNsICpzZV9uYWNsID0gY29udGFpbmVyX29mKGdyb3VwLAorCQkJc3RydWN0IHNlX25vZGVfYWNsLCBhY2xfZ3JvdXApOworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZyA9IHNlX25hY2wtPnNlX3RwZzsKKwlzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19jb25maWdmcyAqdGYgPSBzZV90cGctPnNlX3RwZ193d24tPnd3bl90ZjsKKwlzdHJ1Y3Qgc2VfbHVuX2FjbCAqbGFjbDsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW0gKmFjbF9jaTsKKwljaGFyICpidWY7CisJdW5zaWduZWQgbG9uZyBtYXBwZWRfbHVuOworCWludCByZXQgPSAwOworCisJYWNsX2NpID0gJmdyb3VwLT5jZ19pdGVtOworCWlmICghKGFjbF9jaSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gbG9jYXRlbCBhY2xfY2lcbiIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlidWYgPSBremFsbG9jKHN0cmxlbihuYW1lKSArIDEsIEdGUF9LRVJORUwpOworCWlmICghKGJ1ZikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgbWVtb3J5IGZvciBuYW1lIGJ1ZlxuIik7CisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCX0KKwlzbnByaW50ZihidWYsIHN0cmxlbihuYW1lKSArIDEsICIlcyIsIG5hbWUpOworCS8qCisJICogTWFrZSBzdXJlIHVzZXIgaXMgY3JlYXRpbmcgaXNjc2kvJElRTi8kVFBHVC9hY2xzLyRJTklUSUFUT1IvbHVuXyRJRC4KKwkgKi8KKwlpZiAoc3Ryc3RyKGJ1ZiwgImx1bl8iKSAhPSBidWYpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gbG9jYXRlIFwibHVuX1wiIGZyb20gYnVmOiAlcyIKKwkJCSIgbmFtZTogJXNcbiIsIGJ1ZiwgbmFtZSk7CisJCXJldCA9IC1FSU5WQUw7CisJCWdvdG8gb3V0OworCX0KKwkvKgorCSAqIERldGVybWluZSB0aGUgTWFwcGVkIExVTiB2YWx1ZS4gIFRoaXMgaXMgd2hhdCB0aGUgU0NTSSBJbml0aWF0b3IKKwkgKiBQb3J0IHdpbGwgYWN0dWFsbHkgc2VlLgorCSAqLworCWlmIChzdHJpY3Rfc3RydG91bChidWYgKyA0LCAwLCAmbWFwcGVkX2x1bikgfHwgbWFwcGVkX2x1biA+IFVJTlRfTUFYKSB7CisJCXJldCA9IC1FSU5WQUw7CisJCWdvdG8gb3V0OworCX0KKworCWxhY2wgPSBjb3JlX2Rldl9pbml0X2luaXRpYXRvcl9ub2RlX2x1bl9hY2woc2VfdHBnLCBtYXBwZWRfbHVuLAorCQkJY29uZmlnX2l0ZW1fbmFtZShhY2xfY2kpLCAmcmV0KTsKKwlpZiAoIShsYWNsKSkKKwkJZ290byBvdXQ7CisKKwljb25maWdfZ3JvdXBfaW5pdF90eXBlX25hbWUoJmxhY2wtPnNlX2x1bl9ncm91cCwgbmFtZSwKKwkJCSZURl9DSVRfVE1QTCh0ZiktPnRmY190cGdfbWFwcGVkbHVuX2NpdCk7CisKKwlrZnJlZShidWYpOworCXJldHVybiAmbGFjbC0+c2VfbHVuX2dyb3VwOworb3V0OgorCWtmcmVlKGJ1Zik7CisJcmV0dXJuIEVSUl9QVFIocmV0KTsKK30KKworc3RhdGljIHZvaWQgdGFyZ2V0X2ZhYnJpY19kcm9wX21hcHBlZGx1bigKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwICpncm91cCwKKwlzdHJ1Y3QgY29uZmlnX2l0ZW0gKml0ZW0pCit7CisJc3RydWN0IHNlX2x1bl9hY2wgKmxhY2wgPSBjb250YWluZXJfb2YodG9fY29uZmlnX2dyb3VwKGl0ZW0pLAorCQkJc3RydWN0IHNlX2x1bl9hY2wsIHNlX2x1bl9ncm91cCk7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnID0gbGFjbC0+c2VfbHVuX25hY2wtPnNlX3RwZzsKKworCWNvbmZpZ19pdGVtX3B1dChpdGVtKTsKKwljb3JlX2Rldl9mcmVlX2luaXRpYXRvcl9ub2RlX2x1bl9hY2woc2VfdHBnLCBsYWNsKTsKK30KKworc3RhdGljIHN0cnVjdCBjb25maWdmc19pdGVtX29wZXJhdGlvbnMgdGFyZ2V0X2ZhYnJpY19uYWNsX2Jhc2VfaXRlbV9vcHMgPSB7CisJLnNob3dfYXR0cmlidXRlCQk9IHRhcmdldF9mYWJyaWNfbmFjbF9iYXNlX2F0dHJfc2hvdywKKwkuc3RvcmVfYXR0cmlidXRlCT0gdGFyZ2V0X2ZhYnJpY19uYWNsX2Jhc2VfYXR0cl9zdG9yZSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfZ3JvdXBfb3BlcmF0aW9ucyB0YXJnZXRfZmFicmljX25hY2xfYmFzZV9ncm91cF9vcHMgPSB7CisJLm1ha2VfZ3JvdXAJCT0gdGFyZ2V0X2ZhYnJpY19tYWtlX21hcHBlZGx1biwKKwkuZHJvcF9pdGVtCQk9IHRhcmdldF9mYWJyaWNfZHJvcF9tYXBwZWRsdW4sCit9OworCitURl9DSVRfU0VUVVAodHBnX25hY2xfYmFzZSwgJnRhcmdldF9mYWJyaWNfbmFjbF9iYXNlX2l0ZW1fb3BzLAorCQkmdGFyZ2V0X2ZhYnJpY19uYWNsX2Jhc2VfZ3JvdXBfb3BzLCBOVUxMKTsKKworLyogRW5kIG9mIHRmY190cGdfbmFjbF9iYXNlX2NpdCAqLworCisvKiBTdGFydCBvZiB0ZmNfdHBnX25hY2xfY2l0ICovCisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnX2dyb3VwICp0YXJnZXRfZmFicmljX21ha2Vfbm9kZWFjbCgKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwICpncm91cCwKKwljb25zdCBjaGFyICpuYW1lKQoreworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZyA9IGNvbnRhaW5lcl9vZihncm91cCwKKwkJCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAsIHRwZ19hY2xfZ3JvdXApOworCXN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzICp0ZiA9IHNlX3RwZy0+c2VfdHBnX3d3bi0+d3duX3RmOworCXN0cnVjdCBzZV9ub2RlX2FjbCAqc2VfbmFjbDsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwICpuYWNsX2NnOworCisJaWYgKCEodGYtPnRmX29wcy5mYWJyaWNfbWFrZV9ub2RlYWNsKSkgeworCQlwcmludGsoS0VSTl9FUlIgInRmLT50Zl9vcHMuZmFicmljX21ha2Vfbm9kZWFjbCBpcyBOVUxMXG4iKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT1NZUyk7CisJfQorCisJc2VfbmFjbCA9IHRmLT50Zl9vcHMuZmFicmljX21ha2Vfbm9kZWFjbChzZV90cGcsIGdyb3VwLCBuYW1lKTsKKwlpZiAoSVNfRVJSKHNlX25hY2wpKQorCQlyZXR1cm4gRVJSX1BUUihQVFJfRVJSKHNlX25hY2wpKTsKKworCW5hY2xfY2cgPSAmc2VfbmFjbC0+YWNsX2dyb3VwOworCW5hY2xfY2ctPmRlZmF1bHRfZ3JvdXBzID0gc2VfbmFjbC0+YWNsX2RlZmF1bHRfZ3JvdXBzOworCW5hY2xfY2ctPmRlZmF1bHRfZ3JvdXBzWzBdID0gJnNlX25hY2wtPmFjbF9hdHRyaWJfZ3JvdXA7CisJbmFjbF9jZy0+ZGVmYXVsdF9ncm91cHNbMV0gPSAmc2VfbmFjbC0+YWNsX2F1dGhfZ3JvdXA7CisJbmFjbF9jZy0+ZGVmYXVsdF9ncm91cHNbMl0gPSAmc2VfbmFjbC0+YWNsX3BhcmFtX2dyb3VwOworCW5hY2xfY2ctPmRlZmF1bHRfZ3JvdXBzWzNdID0gTlVMTDsKKworCWNvbmZpZ19ncm91cF9pbml0X3R5cGVfbmFtZSgmc2VfbmFjbC0+YWNsX2dyb3VwLCBuYW1lLAorCQkJJlRGX0NJVF9UTVBMKHRmKS0+dGZjX3RwZ19uYWNsX2Jhc2VfY2l0KTsKKwljb25maWdfZ3JvdXBfaW5pdF90eXBlX25hbWUoJnNlX25hY2wtPmFjbF9hdHRyaWJfZ3JvdXAsICJhdHRyaWIiLAorCQkJJlRGX0NJVF9UTVBMKHRmKS0+dGZjX3RwZ19uYWNsX2F0dHJpYl9jaXQpOworCWNvbmZpZ19ncm91cF9pbml0X3R5cGVfbmFtZSgmc2VfbmFjbC0+YWNsX2F1dGhfZ3JvdXAsICJhdXRoIiwKKwkJCSZURl9DSVRfVE1QTCh0ZiktPnRmY190cGdfbmFjbF9hdXRoX2NpdCk7CisJY29uZmlnX2dyb3VwX2luaXRfdHlwZV9uYW1lKCZzZV9uYWNsLT5hY2xfcGFyYW1fZ3JvdXAsICJwYXJhbSIsCisJCQkmVEZfQ0lUX1RNUEwodGYpLT50ZmNfdHBnX25hY2xfcGFyYW1fY2l0KTsKKworCXJldHVybiAmc2VfbmFjbC0+YWNsX2dyb3VwOworfQorCitzdGF0aWMgdm9pZCB0YXJnZXRfZmFicmljX2Ryb3Bfbm9kZWFjbCgKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwICpncm91cCwKKwlzdHJ1Y3QgY29uZmlnX2l0ZW0gKml0ZW0pCit7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnID0gY29udGFpbmVyX29mKGdyb3VwLAorCQkJc3RydWN0IHNlX3BvcnRhbF9ncm91cCwgdHBnX2FjbF9ncm91cCk7CisJc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKnRmID0gc2VfdHBnLT5zZV90cGdfd3duLT53d25fdGY7CisJc3RydWN0IHNlX25vZGVfYWNsICpzZV9uYWNsID0gY29udGFpbmVyX29mKHRvX2NvbmZpZ19ncm91cChpdGVtKSwKKwkJCXN0cnVjdCBzZV9ub2RlX2FjbCwgYWNsX2dyb3VwKTsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW0gKmRmX2l0ZW07CisJc3RydWN0IGNvbmZpZ19ncm91cCAqbmFjbF9jZzsKKwlpbnQgaTsKKworCW5hY2xfY2cgPSAmc2VfbmFjbC0+YWNsX2dyb3VwOworCWZvciAoaSA9IDA7IG5hY2xfY2ctPmRlZmF1bHRfZ3JvdXBzW2ldOyBpKyspIHsKKwkJZGZfaXRlbSA9ICZuYWNsX2NnLT5kZWZhdWx0X2dyb3Vwc1tpXS0+Y2dfaXRlbTsKKwkJbmFjbF9jZy0+ZGVmYXVsdF9ncm91cHNbaV0gPSBOVUxMOworCQljb25maWdfaXRlbV9wdXQoZGZfaXRlbSk7CisJfQorCisJY29uZmlnX2l0ZW1fcHV0KGl0ZW0pOworCXRmLT50Zl9vcHMuZmFicmljX2Ryb3Bfbm9kZWFjbChzZV9uYWNsKTsKK30KKworc3RhdGljIHN0cnVjdCBjb25maWdmc19ncm91cF9vcGVyYXRpb25zIHRhcmdldF9mYWJyaWNfbmFjbF9ncm91cF9vcHMgPSB7CisJLm1ha2VfZ3JvdXAJPSB0YXJnZXRfZmFicmljX21ha2Vfbm9kZWFjbCwKKwkuZHJvcF9pdGVtCT0gdGFyZ2V0X2ZhYnJpY19kcm9wX25vZGVhY2wsCit9OworCitURl9DSVRfU0VUVVAodHBnX25hY2wsIE5VTEwsICZ0YXJnZXRfZmFicmljX25hY2xfZ3JvdXBfb3BzLCBOVUxMKTsKKworLyogRW5kIG9mIHRmY190cGdfbmFjbF9jaXQgKi8KKworLyogU3RhcnQgb2YgdGZjX3RwZ19ucF9iYXNlX2NpdCAqLworCitDT05GSUdGU19FQVRUUl9PUFModGFyZ2V0X2ZhYnJpY19ucF9iYXNlLCBzZV90cGdfbnAsIHRwZ19ucF9ncm91cCk7CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfaXRlbV9vcGVyYXRpb25zIHRhcmdldF9mYWJyaWNfbnBfYmFzZV9pdGVtX29wcyA9IHsKKwkuc2hvd19hdHRyaWJ1dGUJCT0gdGFyZ2V0X2ZhYnJpY19ucF9iYXNlX2F0dHJfc2hvdywKKwkuc3RvcmVfYXR0cmlidXRlCT0gdGFyZ2V0X2ZhYnJpY19ucF9iYXNlX2F0dHJfc3RvcmUsCit9OworCitURl9DSVRfU0VUVVAodHBnX25wX2Jhc2UsICZ0YXJnZXRfZmFicmljX25wX2Jhc2VfaXRlbV9vcHMsIE5VTEwsIE5VTEwpOworCisvKiBFbmQgb2YgdGZjX3RwZ19ucF9iYXNlX2NpdCAqLworCisvKiBTdGFydCBvZiB0ZmNfdHBnX25wX2NpdCAqLworCitzdGF0aWMgc3RydWN0IGNvbmZpZ19ncm91cCAqdGFyZ2V0X2ZhYnJpY19tYWtlX25wKAorCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLAorCWNvbnN0IGNoYXIgKm5hbWUpCit7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnID0gY29udGFpbmVyX29mKGdyb3VwLAorCQkJCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAsIHRwZ19ucF9ncm91cCk7CisJc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKnRmID0gc2VfdHBnLT5zZV90cGdfd3duLT53d25fdGY7CisJc3RydWN0IHNlX3RwZ19ucCAqc2VfdHBnX25wOworCisJaWYgKCEodGYtPnRmX29wcy5mYWJyaWNfbWFrZV9ucCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJ0Zi0+dGZfb3BzLmZhYnJpY19tYWtlX25wIGlzIE5VTExcbiIpOworCQlyZXR1cm4gRVJSX1BUUigtRU5PU1lTKTsKKwl9CisKKwlzZV90cGdfbnAgPSB0Zi0+dGZfb3BzLmZhYnJpY19tYWtlX25wKHNlX3RwZywgZ3JvdXAsIG5hbWUpOworCWlmICghKHNlX3RwZ19ucCkgfHwgSVNfRVJSKHNlX3RwZ19ucCkpCisJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCisJY29uZmlnX2dyb3VwX2luaXRfdHlwZV9uYW1lKCZzZV90cGdfbnAtPnRwZ19ucF9ncm91cCwgbmFtZSwKKwkJCSZURl9DSVRfVE1QTCh0ZiktPnRmY190cGdfbnBfYmFzZV9jaXQpOworCisJcmV0dXJuICZzZV90cGdfbnAtPnRwZ19ucF9ncm91cDsKK30KKworc3RhdGljIHZvaWQgdGFyZ2V0X2ZhYnJpY19kcm9wX25wKAorCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLAorCXN0cnVjdCBjb25maWdfaXRlbSAqaXRlbSkKK3sKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcgPSBjb250YWluZXJfb2YoZ3JvdXAsCisJCQkJc3RydWN0IHNlX3BvcnRhbF9ncm91cCwgdHBnX25wX2dyb3VwKTsKKwlzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19jb25maWdmcyAqdGYgPSBzZV90cGctPnNlX3RwZ193d24tPnd3bl90ZjsKKwlzdHJ1Y3Qgc2VfdHBnX25wICpzZV90cGdfbnAgPSBjb250YWluZXJfb2YodG9fY29uZmlnX2dyb3VwKGl0ZW0pLAorCQkJCXN0cnVjdCBzZV90cGdfbnAsIHRwZ19ucF9ncm91cCk7CisKKwljb25maWdfaXRlbV9wdXQoaXRlbSk7CisJdGYtPnRmX29wcy5mYWJyaWNfZHJvcF9ucChzZV90cGdfbnApOworfQorCitzdGF0aWMgc3RydWN0IGNvbmZpZ2ZzX2dyb3VwX29wZXJhdGlvbnMgdGFyZ2V0X2ZhYnJpY19ucF9ncm91cF9vcHMgPSB7CisJLm1ha2VfZ3JvdXAJPSAmdGFyZ2V0X2ZhYnJpY19tYWtlX25wLAorCS5kcm9wX2l0ZW0JPSAmdGFyZ2V0X2ZhYnJpY19kcm9wX25wLAorfTsKKworVEZfQ0lUX1NFVFVQKHRwZ19ucCwgTlVMTCwgJnRhcmdldF9mYWJyaWNfbnBfZ3JvdXBfb3BzLCBOVUxMKTsKKworLyogRW5kIG9mIHRmY190cGdfbnBfY2l0ICovCisKKy8qIFN0YXJ0IG9mIHRmY190cGdfcG9ydF9jaXQgKi8KKworQ09ORklHRlNfRUFUVFJfU1RSVUNUKHRhcmdldF9mYWJyaWNfcG9ydCwgc2VfbHVuKTsKKyNkZWZpbmUgVENNX1BPUlRfQVRUUihfbmFtZSwgX21vZGUpCQkJCQlcCitzdGF0aWMgc3RydWN0IHRhcmdldF9mYWJyaWNfcG9ydF9hdHRyaWJ1dGUgdGFyZ2V0X2ZhYnJpY19wb3J0XyMjX25hbWUgPQlcCisJX19DT05GSUdGU19FQVRUUihfbmFtZSwgX21vZGUsCQkJCQlcCisJdGFyZ2V0X2ZhYnJpY19wb3J0X3Nob3dfYXR0cl8jI19uYW1lLAkJCQlcCisJdGFyZ2V0X2ZhYnJpY19wb3J0X3N0b3JlX2F0dHJfIyNfbmFtZSk7CisKKyNkZWZpbmUgVENNX1BPUlRfQVRUT1JfUk8oX25hbWUpCQkJCQlcCisJX19DT05GSUdGU19FQVRUUl9STyhfbmFtZSwJCQkJCVwKKwl0YXJnZXRfZmFicmljX3BvcnRfc2hvd19hdHRyXyMjX25hbWUpOworCisvKgorICogYWx1YV90Z19wdF9ncAorICovCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfZmFicmljX3BvcnRfc2hvd19hdHRyX2FsdWFfdGdfcHRfZ3AoCisJc3RydWN0IHNlX2x1biAqbHVuLAorCWNoYXIgKnBhZ2UpCit7CisJaWYgKCEobHVuKSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlpZiAoIShsdW4tPmx1bl9zZXApKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCXJldHVybiBjb3JlX2FsdWFfc2hvd190Z19wdF9ncF9pbmZvKGx1bi0+bHVuX3NlcCwgcGFnZSk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9mYWJyaWNfcG9ydF9zdG9yZV9hdHRyX2FsdWFfdGdfcHRfZ3AoCisJc3RydWN0IHNlX2x1biAqbHVuLAorCWNvbnN0IGNoYXIgKnBhZ2UsCisJc2l6ZV90IGNvdW50KQoreworCWlmICghKGx1bikpCisJCXJldHVybiAtRU5PREVWOworCisJaWYgKCEobHVuLT5sdW5fc2VwKSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlyZXR1cm4gY29yZV9hbHVhX3N0b3JlX3RnX3B0X2dwX2luZm8obHVuLT5sdW5fc2VwLCBwYWdlLCBjb3VudCk7Cit9CisKK1RDTV9QT1JUX0FUVFIoYWx1YV90Z19wdF9ncCwgU19JUlVHTyB8IFNfSVdVU1IpOworCisvKgorICogYWx1YV90Z19wdF9vZmZsaW5lCisgKi8KK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9mYWJyaWNfcG9ydF9zaG93X2F0dHJfYWx1YV90Z19wdF9vZmZsaW5lKAorCXN0cnVjdCBzZV9sdW4gKmx1biwKKwljaGFyICpwYWdlKQoreworCWlmICghKGx1bikpCisJCXJldHVybiAtRU5PREVWOworCisJaWYgKCEobHVuLT5sdW5fc2VwKSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlyZXR1cm4gY29yZV9hbHVhX3Nob3dfb2ZmbGluZV9iaXQobHVuLCBwYWdlKTsKK30KKworc3RhdGljIHNzaXplX3QgdGFyZ2V0X2ZhYnJpY19wb3J0X3N0b3JlX2F0dHJfYWx1YV90Z19wdF9vZmZsaW5lKAorCXN0cnVjdCBzZV9sdW4gKmx1biwKKwljb25zdCBjaGFyICpwYWdlLAorCXNpemVfdCBjb3VudCkKK3sKKwlpZiAoIShsdW4pKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCWlmICghKGx1bi0+bHVuX3NlcCkpCisJCXJldHVybiAtRU5PREVWOworCisJcmV0dXJuIGNvcmVfYWx1YV9zdG9yZV9vZmZsaW5lX2JpdChsdW4sIHBhZ2UsIGNvdW50KTsKK30KKworVENNX1BPUlRfQVRUUihhbHVhX3RnX3B0X29mZmxpbmUsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworLyoKKyAqIGFsdWFfdGdfcHRfc3RhdHVzCisgKi8KK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9mYWJyaWNfcG9ydF9zaG93X2F0dHJfYWx1YV90Z19wdF9zdGF0dXMoCisJc3RydWN0IHNlX2x1biAqbHVuLAorCWNoYXIgKnBhZ2UpCit7CisJaWYgKCEobHVuKSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlpZiAoIShsdW4tPmx1bl9zZXApKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCXJldHVybiBjb3JlX2FsdWFfc2hvd19zZWNvbmRhcnlfc3RhdHVzKGx1biwgcGFnZSk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9mYWJyaWNfcG9ydF9zdG9yZV9hdHRyX2FsdWFfdGdfcHRfc3RhdHVzKAorCXN0cnVjdCBzZV9sdW4gKmx1biwKKwljb25zdCBjaGFyICpwYWdlLAorCXNpemVfdCBjb3VudCkKK3sKKwlpZiAoIShsdW4pKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCWlmICghKGx1bi0+bHVuX3NlcCkpCisJCXJldHVybiAtRU5PREVWOworCisJcmV0dXJuIGNvcmVfYWx1YV9zdG9yZV9zZWNvbmRhcnlfc3RhdHVzKGx1biwgcGFnZSwgY291bnQpOworfQorCitUQ01fUE9SVF9BVFRSKGFsdWFfdGdfcHRfc3RhdHVzLCBTX0lSVUdPIHwgU19JV1VTUik7CisKKy8qCisgKiBhbHVhX3RnX3B0X3dyaXRlX21kCisgKi8KK3N0YXRpYyBzc2l6ZV90IHRhcmdldF9mYWJyaWNfcG9ydF9zaG93X2F0dHJfYWx1YV90Z19wdF93cml0ZV9tZCgKKwlzdHJ1Y3Qgc2VfbHVuICpsdW4sCisJY2hhciAqcGFnZSkKK3sKKwlpZiAoIShsdW4pKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCWlmICghKGx1bi0+bHVuX3NlcCkpCisJCXJldHVybiAtRU5PREVWOworCisJcmV0dXJuIGNvcmVfYWx1YV9zaG93X3NlY29uZGFyeV93cml0ZV9tZXRhZGF0YShsdW4sIHBhZ2UpOworfQorCitzdGF0aWMgc3NpemVfdCB0YXJnZXRfZmFicmljX3BvcnRfc3RvcmVfYXR0cl9hbHVhX3RnX3B0X3dyaXRlX21kKAorCXN0cnVjdCBzZV9sdW4gKmx1biwKKwljb25zdCBjaGFyICpwYWdlLAorCXNpemVfdCBjb3VudCkKK3sKKwlpZiAoIShsdW4pKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCWlmICghKGx1bi0+bHVuX3NlcCkpCisJCXJldHVybiAtRU5PREVWOworCisJcmV0dXJuIGNvcmVfYWx1YV9zdG9yZV9zZWNvbmRhcnlfd3JpdGVfbWV0YWRhdGEobHVuLCBwYWdlLCBjb3VudCk7Cit9CisKK1RDTV9QT1JUX0FUVFIoYWx1YV90Z19wdF93cml0ZV9tZCwgU19JUlVHTyB8IFNfSVdVU1IpOworCisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfYXR0cmlidXRlICp0YXJnZXRfZmFicmljX3BvcnRfYXR0cnNbXSA9IHsKKwkmdGFyZ2V0X2ZhYnJpY19wb3J0X2FsdWFfdGdfcHRfZ3AuYXR0ciwKKwkmdGFyZ2V0X2ZhYnJpY19wb3J0X2FsdWFfdGdfcHRfb2ZmbGluZS5hdHRyLAorCSZ0YXJnZXRfZmFicmljX3BvcnRfYWx1YV90Z19wdF9zdGF0dXMuYXR0ciwKKwkmdGFyZ2V0X2ZhYnJpY19wb3J0X2FsdWFfdGdfcHRfd3JpdGVfbWQuYXR0ciwKKwlOVUxMLAorfTsKKworQ09ORklHRlNfRUFUVFJfT1BTKHRhcmdldF9mYWJyaWNfcG9ydCwgc2VfbHVuLCBsdW5fZ3JvdXApOworCitzdGF0aWMgaW50IHRhcmdldF9mYWJyaWNfcG9ydF9saW5rKAorCXN0cnVjdCBjb25maWdfaXRlbSAqbHVuX2NpLAorCXN0cnVjdCBjb25maWdfaXRlbSAqc2VfZGV2X2NpKQoreworCXN0cnVjdCBjb25maWdfaXRlbSAqdHBnX2NpOworCXN0cnVjdCBzZV9kZXZpY2UgKmRldjsKKwlzdHJ1Y3Qgc2VfbHVuICpsdW4gPSBjb250YWluZXJfb2YodG9fY29uZmlnX2dyb3VwKGx1bl9jaSksCisJCQkJc3RydWN0IHNlX2x1biwgbHVuX2dyb3VwKTsKKwlzdHJ1Y3Qgc2VfbHVuICpsdW5fcDsKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGc7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiA9IGNvbnRhaW5lcl9vZigKKwkJCQl0b19jb25maWdfZ3JvdXAoc2VfZGV2X2NpKSwgc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYsCisJCQkJc2VfZGV2X2dyb3VwKTsKKwlzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19jb25maWdmcyAqdGY7CisJaW50IHJldDsKKworCXRwZ19jaSA9ICZsdW5fY2ktPmNpX3BhcmVudC0+Y2lfZ3JvdXAtPmNnX2l0ZW07CisJc2VfdHBnID0gY29udGFpbmVyX29mKHRvX2NvbmZpZ19ncm91cCh0cGdfY2kpLAorCQkJCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAsIHRwZ19ncm91cCk7CisJdGYgPSBzZV90cGctPnNlX3RwZ193d24tPnd3bl90ZjsKKworCWlmIChsdW4tPmx1bl9zZV9kZXYgIT0gIE5VTEwpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJQb3J0IFN5bWxpbmsgYWxyZWFkeSBleGlzdHNcbiIpOworCQlyZXR1cm4gLUVFWElTVDsKKwl9CisKKwlkZXYgPSBzZV9kZXYtPnNlX2Rldl9wdHI7CisJaWYgKCEoZGV2KSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2NhdGUgc3RydWN0IHNlX2RldmljZSBwb2ludGVyIGZyb20iCisJCQkiICVzXG4iLCBjb25maWdfaXRlbV9uYW1lKHNlX2Rldl9jaSkpOworCQlyZXQgPSAtRU5PREVWOworCQlnb3RvIG91dDsKKwl9CisKKwlsdW5fcCA9IGNvcmVfZGV2X2FkZF9sdW4oc2VfdHBnLCBkZXYtPnNlX2hiYSwgZGV2LAorCQkJCWx1bi0+dW5wYWNrZWRfbHVuKTsKKwlpZiAoKElTX0VSUihsdW5fcCkpIHx8ICEobHVuX3ApKSB7CisJCXByaW50ayhLRVJOX0VSUiAiY29yZV9kZXZfYWRkX2x1bigpIGZhaWxlZFxuIik7CisJCXJldCA9IC1FSU5WQUw7CisJCWdvdG8gb3V0OworCX0KKworCWlmICh0Zi0+dGZfb3BzLmZhYnJpY19wb3N0X2xpbmspIHsKKwkJLyoKKwkJICogQ2FsbCB0aGUgb3B0aW9uYWwgZmFicmljX3Bvc3RfbGluaygpIHRvIGFsbG93IGEKKwkJICogZmFicmljIG1vZHVsZSB0byBzZXR1cCBhbnkgYWRkaXRpb25hbCBzdGF0ZSBvbmNlCisJCSAqIGNvcmVfZGV2X2FkZF9sdW4oKSBoYXMgYmVlbiBjYWxsZWQuLgorCQkgKi8KKwkJdGYtPnRmX29wcy5mYWJyaWNfcG9zdF9saW5rKHNlX3RwZywgbHVuKTsKKwl9CisKKwlyZXR1cm4gMDsKK291dDoKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IHRhcmdldF9mYWJyaWNfcG9ydF91bmxpbmsoCisJc3RydWN0IGNvbmZpZ19pdGVtICpsdW5fY2ksCisJc3RydWN0IGNvbmZpZ19pdGVtICpzZV9kZXZfY2kpCit7CisJc3RydWN0IHNlX2x1biAqbHVuID0gY29udGFpbmVyX29mKHRvX2NvbmZpZ19ncm91cChsdW5fY2kpLAorCQkJCXN0cnVjdCBzZV9sdW4sIGx1bl9ncm91cCk7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnID0gbHVuLT5sdW5fc2VwLT5zZXBfdHBnOworCXN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzICp0ZiA9IHNlX3RwZy0+c2VfdHBnX3d3bi0+d3duX3RmOworCisJaWYgKHRmLT50Zl9vcHMuZmFicmljX3ByZV91bmxpbmspIHsKKwkJLyoKKwkJICogQ2FsbCB0aGUgb3B0aW9uYWwgZmFicmljX3ByZV91bmxpbmsoKSB0byBhbGxvdyBhCisJCSAqIGZhYnJpYyBtb2R1bGUgdG8gcmVsZWFzZSBhbnkgYWRkaXRpb25hbCBzdGF0IGJlZm9yZQorCQkgKiBjb3JlX2Rldl9kZWxfbHVuKCkgaXMgY2FsbGVkLgorCQkqLworCQl0Zi0+dGZfb3BzLmZhYnJpY19wcmVfdW5saW5rKHNlX3RwZywgbHVuKTsKKwl9CisKKwljb3JlX2Rldl9kZWxfbHVuKHNlX3RwZywgbHVuLT51bnBhY2tlZF9sdW4pOworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IGNvbmZpZ2ZzX2l0ZW1fb3BlcmF0aW9ucyB0YXJnZXRfZmFicmljX3BvcnRfaXRlbV9vcHMgPSB7CisJLnNob3dfYXR0cmlidXRlCQk9IHRhcmdldF9mYWJyaWNfcG9ydF9hdHRyX3Nob3csCisJLnN0b3JlX2F0dHJpYnV0ZQk9IHRhcmdldF9mYWJyaWNfcG9ydF9hdHRyX3N0b3JlLAorCS5hbGxvd19saW5rCQk9IHRhcmdldF9mYWJyaWNfcG9ydF9saW5rLAorCS5kcm9wX2xpbmsJCT0gdGFyZ2V0X2ZhYnJpY19wb3J0X3VubGluaywKK307CisKK1RGX0NJVF9TRVRVUCh0cGdfcG9ydCwgJnRhcmdldF9mYWJyaWNfcG9ydF9pdGVtX29wcywgTlVMTCwgdGFyZ2V0X2ZhYnJpY19wb3J0X2F0dHJzKTsKKworLyogRW5kIG9mIHRmY190cGdfcG9ydF9jaXQgKi8KKworLyogU3RhcnQgb2YgdGZjX3RwZ19sdW5fY2l0ICovCisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnX2dyb3VwICp0YXJnZXRfZmFicmljX21ha2VfbHVuKAorCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLAorCWNvbnN0IGNoYXIgKm5hbWUpCit7CisJc3RydWN0IHNlX2x1biAqbHVuOworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZyA9IGNvbnRhaW5lcl9vZihncm91cCwKKwkJCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAsIHRwZ19sdW5fZ3JvdXApOworCXN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzICp0ZiA9IHNlX3RwZy0+c2VfdHBnX3d3bi0+d3duX3RmOworCXVuc2lnbmVkIGxvbmcgdW5wYWNrZWRfbHVuOworCisJaWYgKHN0cnN0cihuYW1lLCAibHVuXyIpICE9IG5hbWUpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gbG9jYXRlIFwnX1wiIGluIgorCQkJCSIgXCJsdW5fJExVTl9OVU1CRVJcIlxuIik7CisJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCX0KKwlpZiAoc3RyaWN0X3N0cnRvdWwobmFtZSArIDQsIDAsICZ1bnBhY2tlZF9sdW4pIHx8IHVucGFja2VkX2x1biA+IFVJTlRfTUFYKQorCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKKworCWx1biA9IGNvcmVfZ2V0X2x1bl9mcm9tX3RwZyhzZV90cGcsIHVucGFja2VkX2x1bik7CisJaWYgKCEobHVuKSkKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisKKwljb25maWdfZ3JvdXBfaW5pdF90eXBlX25hbWUoJmx1bi0+bHVuX2dyb3VwLCBuYW1lLAorCQkJJlRGX0NJVF9UTVBMKHRmKS0+dGZjX3RwZ19wb3J0X2NpdCk7CisKKwlyZXR1cm4gJmx1bi0+bHVuX2dyb3VwOworfQorCitzdGF0aWMgdm9pZCB0YXJnZXRfZmFicmljX2Ryb3BfbHVuKAorCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLAorCXN0cnVjdCBjb25maWdfaXRlbSAqaXRlbSkKK3sKKwljb25maWdfaXRlbV9wdXQoaXRlbSk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfZ3JvdXBfb3BlcmF0aW9ucyB0YXJnZXRfZmFicmljX2x1bl9ncm91cF9vcHMgPSB7CisJLm1ha2VfZ3JvdXAJPSAmdGFyZ2V0X2ZhYnJpY19tYWtlX2x1biwKKwkuZHJvcF9pdGVtCT0gJnRhcmdldF9mYWJyaWNfZHJvcF9sdW4sCit9OworCitURl9DSVRfU0VUVVAodHBnX2x1biwgTlVMTCwgJnRhcmdldF9mYWJyaWNfbHVuX2dyb3VwX29wcywgTlVMTCk7CisKKy8qIEVuZCBvZiB0ZmNfdHBnX2x1bl9jaXQgKi8KKworLyogU3RhcnQgb2YgdGZjX3RwZ19hdHRyaWJfY2l0ICovCisKK0NPTkZJR0ZTX0VBVFRSX09QUyh0YXJnZXRfZmFicmljX3RwZ19hdHRyaWIsIHNlX3BvcnRhbF9ncm91cCwgdHBnX2F0dHJpYl9ncm91cCk7CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfaXRlbV9vcGVyYXRpb25zIHRhcmdldF9mYWJyaWNfdHBnX2F0dHJpYl9pdGVtX29wcyA9IHsKKwkuc2hvd19hdHRyaWJ1dGUJCT0gdGFyZ2V0X2ZhYnJpY190cGdfYXR0cmliX2F0dHJfc2hvdywKKwkuc3RvcmVfYXR0cmlidXRlCT0gdGFyZ2V0X2ZhYnJpY190cGdfYXR0cmliX2F0dHJfc3RvcmUsCit9OworCitURl9DSVRfU0VUVVAodHBnX2F0dHJpYiwgJnRhcmdldF9mYWJyaWNfdHBnX2F0dHJpYl9pdGVtX29wcywgTlVMTCwgTlVMTCk7CisKKy8qIEVuZCBvZiB0ZmNfdHBnX2F0dHJpYl9jaXQgKi8KKworLyogU3RhcnQgb2YgdGZjX3RwZ19wYXJhbV9jaXQgKi8KKworQ09ORklHRlNfRUFUVFJfT1BTKHRhcmdldF9mYWJyaWNfdHBnX3BhcmFtLCBzZV9wb3J0YWxfZ3JvdXAsIHRwZ19wYXJhbV9ncm91cCk7CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfaXRlbV9vcGVyYXRpb25zIHRhcmdldF9mYWJyaWNfdHBnX3BhcmFtX2l0ZW1fb3BzID0geworCS5zaG93X2F0dHJpYnV0ZQkJPSB0YXJnZXRfZmFicmljX3RwZ19wYXJhbV9hdHRyX3Nob3csCisJLnN0b3JlX2F0dHJpYnV0ZQk9IHRhcmdldF9mYWJyaWNfdHBnX3BhcmFtX2F0dHJfc3RvcmUsCit9OworCitURl9DSVRfU0VUVVAodHBnX3BhcmFtLCAmdGFyZ2V0X2ZhYnJpY190cGdfcGFyYW1faXRlbV9vcHMsIE5VTEwsIE5VTEwpOworCisvKiBFbmQgb2YgdGZjX3RwZ19wYXJhbV9jaXQgKi8KKworLyogU3RhcnQgb2YgdGZjX3RwZ19iYXNlX2NpdCAqLworLyoKKyAqIEZvciB1c2Ugd2l0aCBURl9UUEdfQVRUUigpIGFuZCBURl9UUEdfQVRUUl9STygpCisgKi8KK0NPTkZJR0ZTX0VBVFRSX09QUyh0YXJnZXRfZmFicmljX3RwZywgc2VfcG9ydGFsX2dyb3VwLCB0cGdfZ3JvdXApOworCitzdGF0aWMgc3RydWN0IGNvbmZpZ2ZzX2l0ZW1fb3BlcmF0aW9ucyB0YXJnZXRfZmFicmljX3RwZ19iYXNlX2l0ZW1fb3BzID0geworCS5zaG93X2F0dHJpYnV0ZQkJPSB0YXJnZXRfZmFicmljX3RwZ19hdHRyX3Nob3csCisJLnN0b3JlX2F0dHJpYnV0ZQk9IHRhcmdldF9mYWJyaWNfdHBnX2F0dHJfc3RvcmUsCit9OworCitURl9DSVRfU0VUVVAodHBnX2Jhc2UsICZ0YXJnZXRfZmFicmljX3RwZ19iYXNlX2l0ZW1fb3BzLCBOVUxMLCBOVUxMKTsKKworLyogRW5kIG9mIHRmY190cGdfYmFzZV9jaXQgKi8KKworLyogU3RhcnQgb2YgdGZjX3RwZ19jaXQgKi8KKworc3RhdGljIHN0cnVjdCBjb25maWdfZ3JvdXAgKnRhcmdldF9mYWJyaWNfbWFrZV90cGcoCisJc3RydWN0IGNvbmZpZ19ncm91cCAqZ3JvdXAsCisJY29uc3QgY2hhciAqbmFtZSkKK3sKKwlzdHJ1Y3Qgc2Vfd3duICp3d24gPSBjb250YWluZXJfb2YoZ3JvdXAsIHN0cnVjdCBzZV93d24sIHd3bl9ncm91cCk7CisJc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKnRmID0gd3duLT53d25fdGY7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnOworCisJaWYgKCEodGYtPnRmX29wcy5mYWJyaWNfbWFrZV90cGcpKSB7CisJCXByaW50ayhLRVJOX0VSUiAidGYtPnRmX29wcy5mYWJyaWNfbWFrZV90cGcgaXMgTlVMTFxuIik7CisJCXJldHVybiBFUlJfUFRSKC1FTk9TWVMpOworCX0KKworCXNlX3RwZyA9IHRmLT50Zl9vcHMuZmFicmljX21ha2VfdHBnKHd3biwgZ3JvdXAsIG5hbWUpOworCWlmICghKHNlX3RwZykgfHwgSVNfRVJSKHNlX3RwZykpCisJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCS8qCisJICogU2V0dXAgZGVmYXVsdCBncm91cHMgZnJvbSBwcmUtYWxsb2NhdGVkIHNlX3RwZy0+dHBnX2RlZmF1bHRfZ3JvdXBzCisJICovCisJc2VfdHBnLT50cGdfZ3JvdXAuZGVmYXVsdF9ncm91cHMgPSBzZV90cGctPnRwZ19kZWZhdWx0X2dyb3VwczsKKwlzZV90cGctPnRwZ19ncm91cC5kZWZhdWx0X2dyb3Vwc1swXSA9ICZzZV90cGctPnRwZ19sdW5fZ3JvdXA7CisJc2VfdHBnLT50cGdfZ3JvdXAuZGVmYXVsdF9ncm91cHNbMV0gPSAmc2VfdHBnLT50cGdfbnBfZ3JvdXA7CisJc2VfdHBnLT50cGdfZ3JvdXAuZGVmYXVsdF9ncm91cHNbMl0gPSAmc2VfdHBnLT50cGdfYWNsX2dyb3VwOworCXNlX3RwZy0+dHBnX2dyb3VwLmRlZmF1bHRfZ3JvdXBzWzNdID0gJnNlX3RwZy0+dHBnX2F0dHJpYl9ncm91cDsKKwlzZV90cGctPnRwZ19ncm91cC5kZWZhdWx0X2dyb3Vwc1s0XSA9ICZzZV90cGctPnRwZ19wYXJhbV9ncm91cDsKKwlzZV90cGctPnRwZ19ncm91cC5kZWZhdWx0X2dyb3Vwc1s1XSA9IE5VTEw7CisKKwljb25maWdfZ3JvdXBfaW5pdF90eXBlX25hbWUoJnNlX3RwZy0+dHBnX2dyb3VwLCBuYW1lLAorCQkJJlRGX0NJVF9UTVBMKHRmKS0+dGZjX3RwZ19iYXNlX2NpdCk7CisJY29uZmlnX2dyb3VwX2luaXRfdHlwZV9uYW1lKCZzZV90cGctPnRwZ19sdW5fZ3JvdXAsICJsdW4iLAorCQkJJlRGX0NJVF9UTVBMKHRmKS0+dGZjX3RwZ19sdW5fY2l0KTsKKwljb25maWdfZ3JvdXBfaW5pdF90eXBlX25hbWUoJnNlX3RwZy0+dHBnX25wX2dyb3VwLCAibnAiLAorCQkJJlRGX0NJVF9UTVBMKHRmKS0+dGZjX3RwZ19ucF9jaXQpOworCWNvbmZpZ19ncm91cF9pbml0X3R5cGVfbmFtZSgmc2VfdHBnLT50cGdfYWNsX2dyb3VwLCAiYWNscyIsCisJCQkmVEZfQ0lUX1RNUEwodGYpLT50ZmNfdHBnX25hY2xfY2l0KTsKKwljb25maWdfZ3JvdXBfaW5pdF90eXBlX25hbWUoJnNlX3RwZy0+dHBnX2F0dHJpYl9ncm91cCwgImF0dHJpYiIsCisJCQkmVEZfQ0lUX1RNUEwodGYpLT50ZmNfdHBnX2F0dHJpYl9jaXQpOworCWNvbmZpZ19ncm91cF9pbml0X3R5cGVfbmFtZSgmc2VfdHBnLT50cGdfcGFyYW1fZ3JvdXAsICJwYXJhbSIsCisJCQkmVEZfQ0lUX1RNUEwodGYpLT50ZmNfdHBnX3BhcmFtX2NpdCk7CisKKwlyZXR1cm4gJnNlX3RwZy0+dHBnX2dyb3VwOworfQorCitzdGF0aWMgdm9pZCB0YXJnZXRfZmFicmljX2Ryb3BfdHBnKAorCXN0cnVjdCBjb25maWdfZ3JvdXAgKmdyb3VwLAorCXN0cnVjdCBjb25maWdfaXRlbSAqaXRlbSkKK3sKKwlzdHJ1Y3Qgc2Vfd3duICp3d24gPSBjb250YWluZXJfb2YoZ3JvdXAsIHN0cnVjdCBzZV93d24sIHd3bl9ncm91cCk7CisJc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKnRmID0gd3duLT53d25fdGY7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnID0gY29udGFpbmVyX29mKHRvX2NvbmZpZ19ncm91cChpdGVtKSwKKwkJCQlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwLCB0cGdfZ3JvdXApOworCXN0cnVjdCBjb25maWdfZ3JvdXAgKnRwZ19jZyA9ICZzZV90cGctPnRwZ19ncm91cDsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW0gKmRmX2l0ZW07CisJaW50IGk7CisJLyoKKwkgKiBSZWxlYXNlIGRlZmF1bHQgZ3JvdXBzLCBidXQgZG8gbm90IHJlbGVhc2UgdHBnX2NnLT5kZWZhdWx0X2dyb3VwcworCSAqIG1lbW9yeSBhcyBpdCBpcyBzdGF0aWNhbGx5IGFsbG9jYXRlZCBhdCBzZV90cGctPnRwZ19kZWZhdWx0X2dyb3Vwcy4KKwkgKi8KKwlmb3IgKGkgPSAwOyB0cGdfY2ctPmRlZmF1bHRfZ3JvdXBzW2ldOyBpKyspIHsKKwkJZGZfaXRlbSA9ICZ0cGdfY2ctPmRlZmF1bHRfZ3JvdXBzW2ldLT5jZ19pdGVtOworCQl0cGdfY2ctPmRlZmF1bHRfZ3JvdXBzW2ldID0gTlVMTDsKKwkJY29uZmlnX2l0ZW1fcHV0KGRmX2l0ZW0pOworCX0KKworCWNvbmZpZ19pdGVtX3B1dChpdGVtKTsKKwl0Zi0+dGZfb3BzLmZhYnJpY19kcm9wX3RwZyhzZV90cGcpOworfQorCitzdGF0aWMgc3RydWN0IGNvbmZpZ2ZzX2dyb3VwX29wZXJhdGlvbnMgdGFyZ2V0X2ZhYnJpY190cGdfZ3JvdXBfb3BzID0geworCS5tYWtlX2dyb3VwCT0gdGFyZ2V0X2ZhYnJpY19tYWtlX3RwZywKKwkuZHJvcF9pdGVtCT0gdGFyZ2V0X2ZhYnJpY19kcm9wX3RwZywKK307CisKK1RGX0NJVF9TRVRVUCh0cGcsIE5VTEwsICZ0YXJnZXRfZmFicmljX3RwZ19ncm91cF9vcHMsIE5VTEwpOworCisvKiBFbmQgb2YgdGZjX3RwZ19jaXQgKi8KKworLyogU3RhcnQgb2YgdGZjX3d3bl9jaXQgKi8KKworc3RhdGljIHN0cnVjdCBjb25maWdfZ3JvdXAgKnRhcmdldF9mYWJyaWNfbWFrZV93d24oCisJc3RydWN0IGNvbmZpZ19ncm91cCAqZ3JvdXAsCisJY29uc3QgY2hhciAqbmFtZSkKK3sKKwlzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19jb25maWdmcyAqdGYgPSBjb250YWluZXJfb2YoZ3JvdXAsCisJCQkJc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMsIHRmX2dyb3VwKTsKKwlzdHJ1Y3Qgc2Vfd3duICp3d247CisKKwlpZiAoISh0Zi0+dGZfb3BzLmZhYnJpY19tYWtlX3d3bikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJ0Zi0+dGZfb3BzLmZhYnJpY19tYWtlX3d3biBpcyBOVUxMXG4iKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT1NZUyk7CisJfQorCisJd3duID0gdGYtPnRmX29wcy5mYWJyaWNfbWFrZV93d24odGYsIGdyb3VwLCBuYW1lKTsKKwlpZiAoISh3d24pIHx8IElTX0VSUih3d24pKQorCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKKworCXd3bi0+d3duX3RmID0gdGY7CisJY29uZmlnX2dyb3VwX2luaXRfdHlwZV9uYW1lKCZ3d24tPnd3bl9ncm91cCwgbmFtZSwKKwkJCSZURl9DSVRfVE1QTCh0ZiktPnRmY190cGdfY2l0KTsKKworCXJldHVybiAmd3duLT53d25fZ3JvdXA7Cit9CisKK3N0YXRpYyB2b2lkIHRhcmdldF9mYWJyaWNfZHJvcF93d24oCisJc3RydWN0IGNvbmZpZ19ncm91cCAqZ3JvdXAsCisJc3RydWN0IGNvbmZpZ19pdGVtICppdGVtKQoreworCXN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzICp0ZiA9IGNvbnRhaW5lcl9vZihncm91cCwKKwkJCQlzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19jb25maWdmcywgdGZfZ3JvdXApOworCXN0cnVjdCBzZV93d24gKnd3biA9IGNvbnRhaW5lcl9vZih0b19jb25maWdfZ3JvdXAoaXRlbSksCisJCQkJc3RydWN0IHNlX3d3biwgd3duX2dyb3VwKTsKKworCWNvbmZpZ19pdGVtX3B1dChpdGVtKTsKKwl0Zi0+dGZfb3BzLmZhYnJpY19kcm9wX3d3bih3d24pOworfQorCitzdGF0aWMgc3RydWN0IGNvbmZpZ2ZzX2dyb3VwX29wZXJhdGlvbnMgdGFyZ2V0X2ZhYnJpY193d25fZ3JvdXBfb3BzID0geworCS5tYWtlX2dyb3VwCT0gdGFyZ2V0X2ZhYnJpY19tYWtlX3d3biwKKwkuZHJvcF9pdGVtCT0gdGFyZ2V0X2ZhYnJpY19kcm9wX3d3biwKK307CisvKgorICogRm9yIHVzZSB3aXRoIFRGX1dXTl9BVFRSKCkgYW5kIFRGX1dXTl9BVFRSX1JPKCkKKyAqLworQ09ORklHRlNfRUFUVFJfT1BTKHRhcmdldF9mYWJyaWNfd3duLCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzLCB0Zl9ncm91cCk7CisKK3N0YXRpYyBzdHJ1Y3QgY29uZmlnZnNfaXRlbV9vcGVyYXRpb25zIHRhcmdldF9mYWJyaWNfd3duX2l0ZW1fb3BzID0geworCS5zaG93X2F0dHJpYnV0ZQkJPSB0YXJnZXRfZmFicmljX3d3bl9hdHRyX3Nob3csCisJLnN0b3JlX2F0dHJpYnV0ZQk9IHRhcmdldF9mYWJyaWNfd3duX2F0dHJfc3RvcmUsCit9OworCitURl9DSVRfU0VUVVAod3duLCAmdGFyZ2V0X2ZhYnJpY193d25faXRlbV9vcHMsICZ0YXJnZXRfZmFicmljX3d3bl9ncm91cF9vcHMsIE5VTEwpOworCisvKiBFbmQgb2YgdGZjX3d3bl9jaXQgKi8KKworLyogU3RhcnQgb2YgdGZjX2Rpc2NvdmVyeV9jaXQgKi8KKworQ09ORklHRlNfRUFUVFJfT1BTKHRhcmdldF9mYWJyaWNfZGlzY292ZXJ5LCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzLAorCQl0Zl9kaXNjX2dyb3VwKTsKKworc3RhdGljIHN0cnVjdCBjb25maWdmc19pdGVtX29wZXJhdGlvbnMgdGFyZ2V0X2ZhYnJpY19kaXNjb3ZlcnlfaXRlbV9vcHMgPSB7CisJLnNob3dfYXR0cmlidXRlCQk9IHRhcmdldF9mYWJyaWNfZGlzY292ZXJ5X2F0dHJfc2hvdywKKwkuc3RvcmVfYXR0cmlidXRlCT0gdGFyZ2V0X2ZhYnJpY19kaXNjb3ZlcnlfYXR0cl9zdG9yZSwKK307CisKK1RGX0NJVF9TRVRVUChkaXNjb3ZlcnksICZ0YXJnZXRfZmFicmljX2Rpc2NvdmVyeV9pdGVtX29wcywgTlVMTCwgTlVMTCk7CisKKy8qIEVuZCBvZiB0ZmNfZGlzY292ZXJ5X2NpdCAqLworCitpbnQgdGFyZ2V0X2ZhYnJpY19zZXR1cF9jaXRzKHN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzICp0ZikKK3sKKwl0YXJnZXRfZmFicmljX3NldHVwX2Rpc2NvdmVyeV9jaXQodGYpOworCXRhcmdldF9mYWJyaWNfc2V0dXBfd3duX2NpdCh0Zik7CisJdGFyZ2V0X2ZhYnJpY19zZXR1cF90cGdfY2l0KHRmKTsKKwl0YXJnZXRfZmFicmljX3NldHVwX3RwZ19iYXNlX2NpdCh0Zik7CisJdGFyZ2V0X2ZhYnJpY19zZXR1cF90cGdfcG9ydF9jaXQodGYpOworCXRhcmdldF9mYWJyaWNfc2V0dXBfdHBnX2x1bl9jaXQodGYpOworCXRhcmdldF9mYWJyaWNfc2V0dXBfdHBnX25wX2NpdCh0Zik7CisJdGFyZ2V0X2ZhYnJpY19zZXR1cF90cGdfbnBfYmFzZV9jaXQodGYpOworCXRhcmdldF9mYWJyaWNfc2V0dXBfdHBnX2F0dHJpYl9jaXQodGYpOworCXRhcmdldF9mYWJyaWNfc2V0dXBfdHBnX3BhcmFtX2NpdCh0Zik7CisJdGFyZ2V0X2ZhYnJpY19zZXR1cF90cGdfbmFjbF9jaXQodGYpOworCXRhcmdldF9mYWJyaWNfc2V0dXBfdHBnX25hY2xfYmFzZV9jaXQodGYpOworCXRhcmdldF9mYWJyaWNfc2V0dXBfdHBnX25hY2xfYXR0cmliX2NpdCh0Zik7CisJdGFyZ2V0X2ZhYnJpY19zZXR1cF90cGdfbmFjbF9hdXRoX2NpdCh0Zik7CisJdGFyZ2V0X2ZhYnJpY19zZXR1cF90cGdfbmFjbF9wYXJhbV9jaXQodGYpOworCXRhcmdldF9mYWJyaWNfc2V0dXBfdHBnX21hcHBlZGx1bl9jaXQodGYpOworCisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfbGliLmMgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfbGliLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjYyODU2NAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19saWIuYwpAQCAtMCwwICsxLDQ1MSBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIEZpbGVuYW1lOiAgdGFyZ2V0X2NvcmVfZmFicmljX2xpYi5jCisgKgorICogVGhpcyBmaWxlIGNvbnRhaW5zIGdlbmVyaWMgaGlnaCBsZXZlbCBwcm90b2NvbCBpZGVudGlmaWVyIGFuZCBQUgorICogaGFuZGxlcnMgZm9yIFRDTSBmYWJyaWMgbW9kdWxlcworICoKKyAqIENvcHlyaWdodCAoYykgMjAxMCBSaXNpbmcgVGlkZSBTeXN0ZW1zLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMTAgTGludXgtaVNDU0kub3JnCisgKgorICogTmljaG9sYXMgQS4gQmVsbGluZ2VyIDxuYWJAbGludXgtaXNjc2kub3JnPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgorI2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+CisjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KKyNpbmNsdWRlIDxsaW51eC9zbXBfbG9jay5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaS5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV9jbW5kLmg+CisKKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfYmFzZS5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdHJhbnNwb3J0Lmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19vcHMuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfY29uZmlnZnMuaD4KKworI2luY2x1ZGUgInRhcmdldF9jb3JlX2hiYS5oIgorI2luY2x1ZGUgInRhcmdldF9jb3JlX3ByLmgiCisKKy8qCisgKiBIYW5kbGVycyBmb3IgU2VyaWFsIEF0dGFjaGVkIFNDU0kgKFNBUykKKyAqLwordTggc2FzX2dldF9mYWJyaWNfcHJvdG9faWRlbnQoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnKQoreworCS8qCisJICogUmV0dXJuIGEgU0FTIFNlcmlhbCBTQ1NJIFByb3RvY29sIGlkZW50aWZpZXIgZm9yIGxvb3BiYWNrIG9wZXJhdGlvbnMKKwkgKiBUaGlzIGlzIGRlZmluZWQgaW4gIHNlY3Rpb24gNy41LjEgVGFibGUgMzYyIGluIHNwYzRyMTcKKwkgKi8KKwlyZXR1cm4gMHg2OworfQorRVhQT1JUX1NZTUJPTChzYXNfZ2V0X2ZhYnJpY19wcm90b19pZGVudCk7CisKK3UzMiBzYXNfZ2V0X3ByX3RyYW5zcG9ydF9pZCgKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcsCisJc3RydWN0IHNlX25vZGVfYWNsICpzZV9uYWNsLAorCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsCisJaW50ICpmb3JtYXRfY29kZSwKKwl1bnNpZ25lZCBjaGFyICpidWYpCit7CisJdW5zaWduZWQgY2hhciBiaW5hcnksICpwdHI7CisJaW50IGk7CisJdTMyIG9mZiA9IDQ7CisJLyoKKwkgKiBTZXQgUFJPVE9DT0wgSURFTlRJRklFUiB0byA2aCBmb3IgU0FTCisJICovCisJYnVmWzBdID0gMHgwNjsKKwkvKgorCSAqIEZyb20gc3BjNHIxNywgNy41LjQuNyBUcmFuc3BvcnRJRCBmb3IgaW5pdGlhdG9yIHBvcnRzIHVzaW5nIFNDU0kKKwkgKiBvdmVyIFNBUyBTZXJpYWwgU0NTSSBQcm90b2NvbAorCSAqLworCXB0ciA9ICZzZV9uYWNsLT5pbml0aWF0b3JuYW1lWzRdOyAvKiBTa2lwIG92ZXIgJ25hYS4gcHJlZml4ICovCisKKwlmb3IgKGkgPSAwOyBpIDwgMTY7IGkgKz0gMikgeworCQliaW5hcnkgPSB0cmFuc3BvcnRfYXNjaWloZXhfdG9fYmluYXJ5aGV4KCZwdHJbaV0pOworCQlidWZbb2ZmKytdID0gYmluYXJ5OworCX0KKwkvKgorCSAqIFRoZSBTQVMgVHJhbnNwb3J0IElEIGlzIGEgaGFyZGNvZGVkIDI0LWJ5dGUgbGVuZ3RoCisJICovCisJcmV0dXJuIDI0OworfQorRVhQT1JUX1NZTUJPTChzYXNfZ2V0X3ByX3RyYW5zcG9ydF9pZCk7CisKK3UzMiBzYXNfZ2V0X3ByX3RyYW5zcG9ydF9pZF9sZW4oCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnLAorCXN0cnVjdCBzZV9ub2RlX2FjbCAqc2VfbmFjbCwKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnLAorCWludCAqZm9ybWF0X2NvZGUpCit7CisJKmZvcm1hdF9jb2RlID0gMDsKKwkvKgorCSAqIEZyb20gc3BjNHIxNywgNy41LjQuNyBUcmFuc3BvcnRJRCBmb3IgaW5pdGlhdG9yIHBvcnRzIHVzaW5nIFNDU0kKKwkgKiBvdmVyIFNBUyBTZXJpYWwgU0NTSSBQcm90b2NvbAorCSAqCisJICogVGhlIFNBUyBUcmFuc3BvcnQgSUQgaXMgYSBoYXJkY29kZWQgMjQtYnl0ZSBsZW5ndGgKKwkgKi8KKwlyZXR1cm4gMjQ7Cit9CitFWFBPUlRfU1lNQk9MKHNhc19nZXRfcHJfdHJhbnNwb3J0X2lkX2xlbik7CisKKy8qCisgKiBVc2VkIGZvciBoYW5kbGluZyBTQ1NJIGZhYnJpYyBkZXBlbmRlbnQgVHJhbnNwb3J0SURzIGluIFNQQy0zIGFuZCBhYm92ZQorICogUGVyc2lzdGVudCBSZXNlcnZhdGlvbiBTUEVDX0lfUFQ9MSBhbmQgUFJPVVQgUkVHSVNURVJfQU5EX01PVkUgb3BlcmF0aW9ucy4KKyAqLworY2hhciAqc2FzX3BhcnNlX3ByX291dF90cmFuc3BvcnRfaWQoCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnLAorCWNvbnN0IGNoYXIgKmJ1ZiwKKwl1MzIgKm91dF90aWRfbGVuLAorCWNoYXIgKipwb3J0X25leHVzX3B0cikKK3sKKwkvKgorCSAqIEFzc3VtZSB0aGUgRk9STUFUIENPREUgMDBiIGZyb20gc3BjNHIxNywgNy41LjQuNyBUcmFuc3BvcnRJRAorCSAqIGZvciBpbml0aWF0b3IgcG9ydHMgdXNpbmcgU0NTSSBvdmVyIFNBUyBTZXJpYWwgU0NTSSBQcm90b2NvbAorCSAqCisJICogVGhlIFRyYW5zcG9ydElEIGZvciBhIFNBUyBJbml0aWF0b3IgUG9ydCBpcyBvZiBmaXhlZCBzaXplIG9mCisJICogMjQgYnl0ZXMsIGFuZCBTQVMgZG9lcyBub3QgY29udGFpbiBhIElfVCBuZXh1cyBpZGVudGlmaWVyLAorCSAqIHNvIHdlIHJldHVybiB0aGUgKipwb3J0X25leHVzX3B0ciBzZXQgdG8gTlVMTC4KKwkgKi8KKwkqcG9ydF9uZXh1c19wdHIgPSBOVUxMOworCSpvdXRfdGlkX2xlbiA9IDI0OworCisJcmV0dXJuIChjaGFyICopJmJ1Zls0XTsKK30KK0VYUE9SVF9TWU1CT0woc2FzX3BhcnNlX3ByX291dF90cmFuc3BvcnRfaWQpOworCisvKgorICogSGFuZGxlcnMgZm9yIEZpYnJlIENoYW5uZWwgUHJvdG9jb2wgKEZDUCkKKyAqLwordTggZmNfZ2V0X2ZhYnJpY19wcm90b19pZGVudChzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcpCit7CisJcmV0dXJuIDB4MDsJLyogMCA9IGZjcC0yIHBlciBTUEM0IHNlY3Rpb24gNy41LjEgKi8KK30KK0VYUE9SVF9TWU1CT0woZmNfZ2V0X2ZhYnJpY19wcm90b19pZGVudCk7CisKK3UzMiBmY19nZXRfcHJfdHJhbnNwb3J0X2lkX2xlbigKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcsCisJc3RydWN0IHNlX25vZGVfYWNsICpzZV9uYWNsLAorCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsCisJaW50ICpmb3JtYXRfY29kZSkKK3sKKwkqZm9ybWF0X2NvZGUgPSAwOworCS8qCisJICogVGhlIEZDIFRyYW5zcG9ydCBJRCBpcyBhIGhhcmRjb2RlZCAyNC1ieXRlIGxlbmd0aAorCSAqLworCXJldHVybiAyNDsKK30KK0VYUE9SVF9TWU1CT0woZmNfZ2V0X3ByX3RyYW5zcG9ydF9pZF9sZW4pOworCit1MzIgZmNfZ2V0X3ByX3RyYW5zcG9ydF9pZCgKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcsCisJc3RydWN0IHNlX25vZGVfYWNsICpzZV9uYWNsLAorCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsCisJaW50ICpmb3JtYXRfY29kZSwKKwl1bnNpZ25lZCBjaGFyICpidWYpCit7CisJdW5zaWduZWQgY2hhciBiaW5hcnksICpwdHI7CisJaW50IGk7CisJdTMyIG9mZiA9IDg7CisJLyoKKwkgKiBQUk9UT0NPTCBJREVOVElGSUVSIGlzIDBoIGZvciBGQ1AtMgorCSAqCisJICogRnJvbSBzcGM0cjE3LCA3LjUuNC4yIFRyYW5zcG9ydElEIGZvciBpbml0aWF0b3IgcG9ydHMgdXNpbmcKKwkgKiBTQ1NJIG92ZXIgRmlicmUgQ2hhbm5lbAorCSAqCisJICogV2UgY29udmVydCB0aGUgQVNDSUkgZm9ybWF0dGVkIE4gUG9ydCBuYW1lIGludG8gYSBiaW5hcnkKKwkgKiBlbmNvZGVkIFRyYW5zcG9ydElELgorCSAqLworCXB0ciA9ICZzZV9uYWNsLT5pbml0aWF0b3JuYW1lWzBdOworCisJZm9yIChpID0gMDsgaSA8IDI0OyApIHsKKwkJaWYgKCEoc3RybmNtcCgmcHRyW2ldLCAiOiIsIDEpKSkgeworCQkJaSsrOworCQkJY29udGludWU7CisJCX0KKwkJYmluYXJ5ID0gdHJhbnNwb3J0X2FzY2lpaGV4X3RvX2JpbmFyeWhleCgmcHRyW2ldKTsKKwkJYnVmW29mZisrXSA9IGJpbmFyeTsKKwkJaSArPSAyOworCX0KKwkvKgorCSAqIFRoZSBGQyBUcmFuc3BvcnQgSUQgaXMgYSBoYXJkY29kZWQgMjQtYnl0ZSBsZW5ndGgKKwkgKi8KKwlyZXR1cm4gMjQ7Cit9CitFWFBPUlRfU1lNQk9MKGZjX2dldF9wcl90cmFuc3BvcnRfaWQpOworCitjaGFyICpmY19wYXJzZV9wcl9vdXRfdHJhbnNwb3J0X2lkKAorCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZywKKwljb25zdCBjaGFyICpidWYsCisJdTMyICpvdXRfdGlkX2xlbiwKKwljaGFyICoqcG9ydF9uZXh1c19wdHIpCit7CisJLyoKKwkgKiBUaGUgVHJhbnNwb3J0SUQgZm9yIGEgRkMgTiBQb3J0IGlzIG9mIGZpeGVkIHNpemUgb2YKKwkgKiAyNCBieXRlcywgYW5kIEZDIGRvZXMgbm90IGNvbnRhaW4gYSBJX1QgbmV4dXMgaWRlbnRpZmllciwKKwkgKiBzbyB3ZSByZXR1cm4gdGhlICoqcG9ydF9uZXh1c19wdHIgc2V0IHRvIE5VTEwuCisJICovCisJKnBvcnRfbmV4dXNfcHRyID0gTlVMTDsKKwkqb3V0X3RpZF9sZW4gPSAyNDsKKworCSByZXR1cm4gKGNoYXIgKikmYnVmWzhdOworfQorRVhQT1JUX1NZTUJPTChmY19wYXJzZV9wcl9vdXRfdHJhbnNwb3J0X2lkKTsKKworLyoKKyAqIEhhbmRsZXJzIGZvciBJbnRlcm5ldCBTbWFsbCBDb21wdXRlciBTeXN0ZW1zIEludGVyZmFjZSAoaVNDU0kpCisgKi8KKwordTggaXNjc2lfZ2V0X2ZhYnJpY19wcm90b19pZGVudChzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcpCit7CisJLyoKKwkgKiBUaGlzIHZhbHVlIGlzIGRlZmluZWQgZm9yICJJbnRlcm5ldCBTQ1NJIChpU0NTSSkiCisJICogaW4gc3BjNHIxNyBzZWN0aW9uIDcuNS4xIFRhYmxlIDM2MgorCSAqLworCXJldHVybiAweDU7Cit9CitFWFBPUlRfU1lNQk9MKGlzY3NpX2dldF9mYWJyaWNfcHJvdG9faWRlbnQpOworCit1MzIgaXNjc2lfZ2V0X3ByX3RyYW5zcG9ydF9pZCgKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcsCisJc3RydWN0IHNlX25vZGVfYWNsICpzZV9uYWNsLAorCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsCisJaW50ICpmb3JtYXRfY29kZSwKKwl1bnNpZ25lZCBjaGFyICpidWYpCit7CisJdTMyIG9mZiA9IDQsIHBhZGRpbmcgPSAwOworCXUxNiBsZW4gPSAwOworCisJc3Bpbl9sb2NrX2lycSgmc2VfbmFjbC0+bmFjbF9zZXNzX2xvY2spOworCS8qCisJICogU2V0IFBST1RPQ09MIElERU5USUZJRVIgdG8gNWggZm9yIGlTQ1NJCisJKi8KKwlidWZbMF0gPSAweDA1OworCS8qCisJICogRnJvbSBzcGM0cjE3IFNlY3Rpb24gNy41LjQuNjogVHJhbnNwb3J0SUQgZm9yIGluaXRpYXRvcgorCSAqIHBvcnRzIHVzaW5nIFNDU0kgb3ZlciBpU0NTSS4KKwkgKgorCSAqIFRoZSBudWxsLXRlcm1pbmF0ZWQsIG51bGwtcGFkZGVkIChzZWUgNC40LjIpIElTQ1NJIE5BTUUgZmllbGQKKwkgKiBzaGFsbCBjb250YWluIHRoZSBpU0NTSSBuYW1lIG9mIGFuIGlTQ1NJIGluaXRpYXRvciBub2RlIChzZWUKKwkgKiBSRkMgMzcyMCkuIFRoZSBmaXJzdCBJU0NTSSBOQU1FIGZpZWxkIGJ5dGUgY29udGFpbmluZyBhbiBBU0NJSQorCSAqIG51bGwgY2hhcmFjdGVyIHRlcm1pbmF0ZXMgdGhlIElTQ1NJIE5BTUUgZmllbGQgd2l0aG91dCByZWdhcmQgZm9yCisJICogdGhlIHNwZWNpZmllZCBsZW5ndGggb2YgdGhlIGlTQ1NJIFRyYW5zcG9ydElEIG9yIHRoZSBjb250ZW50cyBvZgorCSAqIHRoZSBBRERJVElPTkFMIExFTkdUSCBmaWVsZC4KKwkgKi8KKwlsZW4gPSBzcHJpbnRmKCZidWZbb2ZmXSwgIiVzIiwgc2VfbmFjbC0+aW5pdGlhdG9ybmFtZSk7CisJLyoKKwkgKiBBZGQgRXh0cmEgYnl0ZSBmb3IgTlVMTCB0ZXJtaW5hdG9yCisJICovCisJbGVuKys7CisJLyoKKwkgKiBJZiB0aGVyZSBpcyBJU0lEIHByZXNlbnQgd2l0aCB0aGUgcmVnaXN0cmF0aW9uIGFuZCAqZm9ybWF0IGNvZGUgPT0gMQorCSAqIDEsIHVzZSBpU0NTSSBJbml0aWF0b3IgcG9ydCBUcmFuc3BvcnRJRCBmb3JtYXQuCisJICoKKwkgKiBPdGhlcndpc2UgdXNlIGlTQ1NJIEluaXRpYXRvciBkZXZpY2UgVHJhbnNwb3J0SUQgZm9ybWF0IHRoYXQKKwkgKiBkb2VzIG5vdCBjb250YWluIHRoZSBBU0NJSSBlbmNvZGVkIGlTQ1NJIEluaXRpYXRvciBpU0lEIHZhbHVlCisJICogcHJvdmllZCBieSB0aGUgaVNDU2kgSW5pdGlhdG9yIGR1cmluZyB0aGUgaVNDU0kgbG9naW4gcHJvY2Vzcy4KKwkgKi8KKwlpZiAoKCpmb3JtYXRfY29kZSA9PSAxKSAmJiAocHJfcmVnLT5pc2lkX3ByZXNlbnRfYXRfcmVnKSkgeworCQkvKgorCQkgKiBTZXQgRk9STUFUIENPREUgMDFiIGZvciBpU0NTSSBJbml0aWF0b3IgcG9ydCBUcmFuc3BvcnRJRAorCQkgKiBmb3JtYXQuCisJCSAqLworCQlidWZbMF0gfD0gMHg0MDsKKwkJLyoKKwkJICogRnJvbSBzcGM0cjE3IFNlY3Rpb24gNy41LjQuNjogVHJhbnNwb3J0SUQgZm9yIGluaXRpYXRvcgorCQkgKiBwb3J0cyB1c2luZyBTQ1NJIG92ZXIgaVNDU0kuICBUYWJsZSAzOTAKKwkJICoKKwkJICogVGhlIFNFUEFSQVRPUiBmaWVsZCBzaGFsbCBjb250YWluIHRoZSBmaXZlIEFTQ0lJCisJCSAqIGNoYXJhY3RlcnMgIixpLDB4Ii4KKwkJICoKKwkJICogVGhlIG51bGwtdGVybWluYXRlZCwgbnVsbC1wYWRkZWQgSVNDU0kgSU5JVElBVE9SIFNFU1NJT04gSUQKKwkJICogZmllbGQgc2hhbGwgY29udGFpbiB0aGUgaVNDU0kgaW5pdGlhdG9yIHNlc3Npb24gaWRlbnRpZmllcgorCQkgKiAoc2VlIFJGQyAzNzIwKSBpbiB0aGUgZm9ybSBvZiBBU0NJSSBjaGFyYWN0ZXJzIHRoYXQgYXJlIHRoZQorCQkgKiBoZXhhZGVjaW1hbCBkaWdpdHMgY29udmVydGVkIGZyb20gdGhlIGJpbmFyeSBpU0NTSSBpbml0aWF0b3IKKwkJICogc2Vzc2lvbiBpZGVudGlmaWVyIHZhbHVlLiBUaGUgZmlyc3QgSVNDU0kgSU5JVElBVE9SIFNFU1NJT04KKwkJICogSUQgZmllbGQgYnl0ZSBjb250YWluaW5nIGFuIEFTQ0lJIG51bGwgY2hhcmFjdGVyCisJCSAqLworCQlidWZbb2ZmK2xlbl0gPSAweDJjOyBvZmYrKzsgLyogQVNDSUkgQ2hhcmFjdGVyOiAiLCIgKi8KKwkJYnVmW29mZitsZW5dID0gMHg2OTsgb2ZmKys7IC8qIEFTQ0lJIENoYXJhY3RlcjogImkiICovCisJCWJ1ZltvZmYrbGVuXSA9IDB4MmM7IG9mZisrOyAvKiBBU0NJSSBDaGFyYWN0ZXI6ICIsIiAqLworCQlidWZbb2ZmK2xlbl0gPSAweDMwOyBvZmYrKzsgLyogQVNDSUkgQ2hhcmFjdGVyOiAiMCIgKi8KKwkJYnVmW29mZitsZW5dID0gMHg3ODsgb2ZmKys7IC8qIEFTQ0lJIENoYXJhY3RlcjogIngiICovCisJCWxlbiArPSA1OworCQlidWZbb2ZmK2xlbl0gPSBwcl9yZWctPnByX3JlZ19pc2lkWzBdOyBvZmYrKzsKKwkJYnVmW29mZitsZW5dID0gcHJfcmVnLT5wcl9yZWdfaXNpZFsxXTsgb2ZmKys7CisJCWJ1ZltvZmYrbGVuXSA9IHByX3JlZy0+cHJfcmVnX2lzaWRbMl07IG9mZisrOworCQlidWZbb2ZmK2xlbl0gPSBwcl9yZWctPnByX3JlZ19pc2lkWzNdOyBvZmYrKzsKKwkJYnVmW29mZitsZW5dID0gcHJfcmVnLT5wcl9yZWdfaXNpZFs0XTsgb2ZmKys7CisJCWJ1ZltvZmYrbGVuXSA9IHByX3JlZy0+cHJfcmVnX2lzaWRbNV07IG9mZisrOworCQlidWZbb2ZmK2xlbl0gPSAnXDAnOyBvZmYrKzsKKwkJbGVuICs9IDc7CisJfQorCXNwaW5fdW5sb2NrX2lycSgmc2VfbmFjbC0+bmFjbF9zZXNzX2xvY2spOworCS8qCisJICogVGhlIEFERElUSU9OQUwgTEVOR1RIIGZpZWxkIHNwZWNpZmllcyB0aGUgbnVtYmVyIG9mIGJ5dGVzIHRoYXQgZm9sbG93CisJICogaW4gdGhlIFRyYW5zcG9ydElELiBUaGUgYWRkaXRpb25hbCBsZW5ndGggc2hhbGwgYmUgYXQgbGVhc3QgMjAgYW5kCisJICogc2hhbGwgYmUgYSBtdWx0aXBsZSBvZiBmb3VyLgorCSovCisJcGFkZGluZyA9ICgoLWxlbikgJiAzKTsKKwlpZiAocGFkZGluZyAhPSAwKQorCQlsZW4gKz0gcGFkZGluZzsKKworCWJ1ZlsyXSA9ICgobGVuID4+IDgpICYgMHhmZik7CisJYnVmWzNdID0gKGxlbiAmIDB4ZmYpOworCS8qCisJICogSW5jcmVtZW50IHZhbHVlIGZvciB0b3RhbCBwYXlsb2FkICsgaGVhZGVyIGxlbmd0aCBmb3IKKwkgKiBmdWxsIHN0YXR1cyBkZXNjcmlwdG9yCisJICovCisJbGVuICs9IDQ7CisKKwlyZXR1cm4gbGVuOworfQorRVhQT1JUX1NZTUJPTChpc2NzaV9nZXRfcHJfdHJhbnNwb3J0X2lkKTsKKwordTMyIGlzY3NpX2dldF9wcl90cmFuc3BvcnRfaWRfbGVuKAorCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZywKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKnNlX25hY2wsCisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKnByX3JlZywKKwlpbnQgKmZvcm1hdF9jb2RlKQoreworCXUzMiBsZW4gPSAwLCBwYWRkaW5nID0gMDsKKworCXNwaW5fbG9ja19pcnEoJnNlX25hY2wtPm5hY2xfc2Vzc19sb2NrKTsKKwlsZW4gPSBzdHJsZW4oc2VfbmFjbC0+aW5pdGlhdG9ybmFtZSk7CisJLyoKKwkgKiBBZGQgZXh0cmEgYnl0ZSBmb3IgTlVMTCB0ZXJtaW5hdG9yCisJICovCisJbGVuKys7CisJLyoKKwkgKiBJZiB0aGVyZSBpcyBJU0lEIHByZXNlbnQgd2l0aCB0aGUgcmVnaXN0cmF0aW9uLCB1c2UgZm9ybWF0IGNvZGU6CisJICogMDFiOiBpU0NTSSBJbml0aWF0b3IgcG9ydCBUcmFuc3BvcnRJRCBmb3JtYXQKKwkgKgorCSAqIElmIHRoZXJlIGlzIG5vdCBhbiBhY3RpdmUgaVNDU0kgc2Vzc2lvbiwgdXNlIGZvcm1hdCBjb2RlOgorCSAqIDAwYjogaVNDU0kgSW5pdGlhdG9yIGRldmljZSBUcmFuc3BvcnRJRCBmb3JtYXQKKwkgKi8KKwlpZiAocHJfcmVnLT5pc2lkX3ByZXNlbnRfYXRfcmVnKSB7CisJCWxlbiArPSA1OyAvKiBGb3IgIixpLDB4IiBBU0NJSSBzZXBlcmF0b3IgKi8KKwkJbGVuICs9IDc7IC8qIEZvciBpU0NTSSBJbml0aWF0b3IgU2Vzc2lvbiBJRCArIE51bGwgdGVybWluYXRvciAqLworCQkqZm9ybWF0X2NvZGUgPSAxOworCX0gZWxzZQorCQkqZm9ybWF0X2NvZGUgPSAwOworCXNwaW5fdW5sb2NrX2lycSgmc2VfbmFjbC0+bmFjbF9zZXNzX2xvY2spOworCS8qCisJICogVGhlIEFERElUSU9OQUwgTEVOR1RIIGZpZWxkIHNwZWNpZmllcyB0aGUgbnVtYmVyIG9mIGJ5dGVzIHRoYXQgZm9sbG93CisJICogaW4gdGhlIFRyYW5zcG9ydElELiBUaGUgYWRkaXRpb25hbCBsZW5ndGggc2hhbGwgYmUgYXQgbGVhc3QgMjAgYW5kCisJICogc2hhbGwgYmUgYSBtdWx0aXBsZSBvZiBmb3VyLgorCSAqLworCXBhZGRpbmcgPSAoKC1sZW4pICYgMyk7CisJaWYgKHBhZGRpbmcgIT0gMCkKKwkJbGVuICs9IHBhZGRpbmc7CisJLyoKKwkgKiBJbmNyZW1lbnQgdmFsdWUgZm9yIHRvdGFsIHBheWxvYWQgKyBoZWFkZXIgbGVuZ3RoIGZvcgorCSAqIGZ1bGwgc3RhdHVzIGRlc2NyaXB0b3IKKwkgKi8KKwlsZW4gKz0gNDsKKworCXJldHVybiBsZW47Cit9CitFWFBPUlRfU1lNQk9MKGlzY3NpX2dldF9wcl90cmFuc3BvcnRfaWRfbGVuKTsKKworY2hhciAqaXNjc2lfcGFyc2VfcHJfb3V0X3RyYW5zcG9ydF9pZCgKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcsCisJY29uc3QgY2hhciAqYnVmLAorCXUzMiAqb3V0X3RpZF9sZW4sCisJY2hhciAqKnBvcnRfbmV4dXNfcHRyKQoreworCWNoYXIgKnA7CisJdTMyIHRpZF9sZW4sIHBhZGRpbmc7CisJaW50IGk7CisJdTE2IGFkZF9sZW47CisJdTggZm9ybWF0X2NvZGUgPSAoYnVmWzBdICYgMHhjMCk7CisJLyoKKwkgKiBDaGVjayBmb3IgRk9STUFUIENPREUgMDBiIG9yIDAxYiBmcm9tIHNwYzRyMTcsIHNlY3Rpb24gNy41LjQuNjoKKwkgKgorCSAqICAgICAgIFRyYW5zcG9ydElEIGZvciBpbml0aWF0b3IgcG9ydHMgdXNpbmcgU0NTSSBvdmVyIGlTQ1NJLAorCSAqICAgICAgIGZyb20gVGFibGUgMzg4IC0tIGlTQ1NJIFRyYW5zcG9ydElEIGZvcm1hdHMuCisJICoKKwkgKiAgICAwMGIgICAgIEluaXRpYXRvciBwb3J0IGlzIGlkZW50aWZpZWQgdXNpbmcgdGhlIHdvcmxkIHdpZGUgdW5pcXVlCisJICogICAgICAgICAgICBTQ1NJIGRldmljZSBuYW1lIG9mIHRoZSBpU0NTSSBpbml0aWF0b3IKKwkgKiAgICAgICAgICAgIGRldmljZSBjb250YWluaW5nIHRoZSBpbml0aWF0b3IgcG9ydCAoc2VlIHRhYmxlIDM4OSkuCisJICogICAgMDFiICAgICBJbml0aWF0b3IgcG9ydCBpcyBpZGVudGlmaWVkIHVzaW5nIHRoZSB3b3JsZCB3aWRlIHVuaXF1ZQorCSAqICAgICAgICAgICAgaW5pdGlhdG9yIHBvcnQgaWRlbnRpZmllciAoc2VlIHRhYmxlIDM5MCkuMTBiIHRvIDExYgorCSAqICAgICAgICAgICAgUmVzZXJ2ZWQKKwkgKi8KKwlpZiAoKGZvcm1hdF9jb2RlICE9IDB4MDApICYmIChmb3JtYXRfY29kZSAhPSAweDQwKSkgeworCQlwcmludGsoS0VSTl9FUlIgIklsbGVnYWwgZm9ybWF0IGNvZGU6IDB4JTAyeCBmb3IgaVNDU0kiCisJCQkiIEluaXRpYXRvciBUcmFuc3BvcnQgSURcbiIsIGZvcm1hdF9jb2RlKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCS8qCisJICogSWYgdGhlIGNhbGxlciB3YW50cyB0aGUgVHJhbnNwb3J0SUQgTGVuZ3RoLCB3ZSBzZXQgdGhhdCB2YWx1ZSBmb3IgdGhlCisJICogZW50aXJlIGlTQ1NJIFRhcm5zcG9ydCBJRCBub3cuCisJICovCisJIGlmIChvdXRfdGlkX2xlbiAhPSBOVUxMKSB7CisJCWFkZF9sZW4gPSAoKGJ1ZlsyXSA+PiA4KSAmIDB4ZmYpOworCQlhZGRfbGVuIHw9IChidWZbM10gJiAweGZmKTsKKworCQl0aWRfbGVuID0gc3RybGVuKChjaGFyICopJmJ1Zls0XSk7CisJCXRpZF9sZW4gKz0gNDsgLyogQWRkIGZvdXIgYnl0ZXMgZm9yIGlTQ1NJIFRyYW5zcG9ydCBJRCBoZWFkZXIgKi8KKwkJdGlkX2xlbiArPSAxOyAvKiBBZGQgb25lIGJ5dGUgZm9yIE5VTEwgdGVybWluYXRvciAqLworCQlwYWRkaW5nID0gKCgtdGlkX2xlbikgJiAzKTsKKwkJaWYgKHBhZGRpbmcgIT0gMCkKKwkJCXRpZF9sZW4gKz0gcGFkZGluZzsKKworCQlpZiAoKGFkZF9sZW4gKyA0KSAhPSB0aWRfbGVuKSB7CisJCQlwcmludGsoS0VSTl9JTkZPICJMSU8tVGFyZ2V0IEV4dHJhY3RlZCBhZGRfbGVuOiAlaHUgIgorCQkJCSJkb2VzIG5vdCBtYXRjaCBjYWxjdWxhdGVkIHRpZF9sZW46ICV1LCIKKwkJCQkiIHVzaW5nIHRpZF9sZW4gaW5zdGVhZFxuIiwgYWRkX2xlbis0LCB0aWRfbGVuKTsKKwkJCSpvdXRfdGlkX2xlbiA9IHRpZF9sZW47CisJCX0gZWxzZQorCQkJKm91dF90aWRfbGVuID0gKGFkZF9sZW4gKyA0KTsKKwl9CisJLyoKKwkgKiBDaGVjayBmb3IgJyxpLDB4JyBzZXBlcmF0b3IgYmV0d2VlbiBpU0NTSSBOYW1lIGFuZCBpU0NTSSBJbml0aWF0b3IKKwkgKiBTZXNzaW9uIElEIGFzIGRlZmluZWQgaW4gVGFibGUgMzkwIC0gaVNDU0kgaW5pdGlhdG9yIHBvcnQgVHJhbnNwb3J0SUQKKwkgKiBmb3JtYXQuCisJICovCisJaWYgKGZvcm1hdF9jb2RlID09IDB4NDApIHsKKwkJcCA9IHN0cnN0cigoY2hhciAqKSZidWZbNF0sICIsaSwweCIpOworCQlpZiAoIShwKSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gbG9jYXRlIFwiLGksMHhcIiBzZXBlcmF0b3IiCisJCQkJIiBmb3IgSW5pdGlhdG9yIHBvcnQgaWRlbnRpZmllcjogJXNcbiIsCisJCQkJKGNoYXIgKikmYnVmWzRdKTsKKwkJCXJldHVybiBOVUxMOworCQl9CisJCSpwID0gJ1wwJzsgLyogVGVybWluYXRlIGlTQ1NJIE5hbWUgKi8KKwkJcCArPSA1OyAvKiBTa2lwIG92ZXIgIixpLDB4IiBzZXBlcmF0b3IgKi8KKworCQkqcG9ydF9uZXh1c19wdHIgPSBwOworCQkvKgorCQkgKiBHbyBhaGVhZCBhbmQgZG8gdGhlIGxvd2VyIGNhc2UgY29udmVyc2lvbiBvZiB0aGUgcmVjZWl2ZWQKKwkJICogMTIgQVNDSUkgY2hhcmFjdGVycyByZXByZXNlbnRpbmcgdGhlIElTSUQgaW4gdGhlIFRyYW5zcG9ydElECisJCSAqIGZvciBjb21wYXJpc2lvbiBhZ2FpbnN0IHRoZSBydW5uaW5nIGlTQ1NJIHNlc3Npb24ncyBJU0lEIGZyb20KKwkJICogaXNjc2lfdGFyZ2V0LmM6bGlvX3Nlc3NfZ2V0X2luaXRpYXRvcl9zaWQoKQorCQkgKi8KKwkJZm9yIChpID0gMDsgaSA8IDEyOyBpKyspIHsKKwkJCWlmIChpc2RpZ2l0KCpwKSkgeworCQkJCXArKzsKKwkJCQljb250aW51ZTsKKwkJCX0KKwkJCSpwID0gdG9sb3dlcigqcCk7CisJCQlwKys7CisJCX0KKwl9CisKKwlyZXR1cm4gKGNoYXIgKikmYnVmWzRdOworfQorRVhQT1JUX1NZTUJPTChpc2NzaV9wYXJzZV9wcl9vdXRfdHJhbnNwb3J0X2lkKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2ZpbGUuYyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2ZpbGUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wYWFjYTg4Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfZmlsZS5jCkBAIC0wLDAgKzEsNjg4IEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogRmlsZW5hbWU6ICB0YXJnZXRfY29yZV9maWxlLmMKKyAqCisgKiBUaGlzIGZpbGUgY29udGFpbnMgdGhlIFN0b3JhZ2UgRW5naW5lIDwtPiBGSUxFSU8gdHJhbnNwb3J0IHNwZWNpZmljIGZ1bmN0aW9ucworICoKKyAqIENvcHlyaWdodCAoYykgMjAwNSBQeVggVGVjaG5vbG9naWVzLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTQkUsIEluYy4gIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKGMpIDIwMDctMjAxMCBSaXNpbmcgVGlkZSBTeXN0ZW1zCisgKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxMCBMaW51eC1pU0NTSS5vcmcKKyAqCisgKiBOaWNob2xhcyBBLiBCZWxsaW5nZXIgPG5hYkBrZXJuZWwub3JnPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworI2luY2x1ZGUgPGxpbnV4L3ZlcnNpb24uaD4KKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KKyNpbmNsdWRlIDxsaW51eC9wYXJzZXIuaD4KKyNpbmNsdWRlIDxsaW51eC90aW1lci5oPgorI2luY2x1ZGUgPGxpbnV4L2Jsa2Rldi5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgorI2luY2x1ZGUgPGxpbnV4L3NtcF9sb2NrLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpX2hvc3QuaD4KKworI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9iYXNlLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV90cmFuc3BvcnQuaD4KKworI2luY2x1ZGUgInRhcmdldF9jb3JlX2ZpbGUuaCIKKworI2lmIDEKKyNkZWZpbmUgREVCVUdfRkRfQ0FDSEUoeC4uLikgcHJpbnRrKHgpCisjZWxzZQorI2RlZmluZSBERUJVR19GRF9DQUNIRSh4Li4uKQorI2VuZGlmCisKKyNpZiAxCisjZGVmaW5lIERFQlVHX0ZEX0ZVQSh4Li4uKSBwcmludGsoeCkKKyNlbHNlCisjZGVmaW5lIERFQlVHX0ZEX0ZVQSh4Li4uKQorI2VuZGlmCisKK3N0YXRpYyBzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2FwaSBmaWxlaW9fdGVtcGxhdGU7CisKKy8qCWZkX2F0dGFjaF9oYmEoKTogKFBhcnQgb2Ygc2Vfc3Vic3lzdGVtX2FwaV90IHRlbXBsYXRlKQorICoKKyAqCisgKi8KK3N0YXRpYyBpbnQgZmRfYXR0YWNoX2hiYShzdHJ1Y3Qgc2VfaGJhICpoYmEsIHUzMiBob3N0X2lkKQoreworCXN0cnVjdCBmZF9ob3N0ICpmZF9ob3N0OworCisJZmRfaG9zdCA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBmZF9ob3N0KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCEoZmRfaG9zdCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgbWVtb3J5IGZvciBzdHJ1Y3QgZmRfaG9zdFxuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlmZF9ob3N0LT5mZF9ob3N0X2lkID0gaG9zdF9pZDsKKworCWF0b21pY19zZXQoJmhiYS0+bGVmdF9xdWV1ZV9kZXB0aCwgRkRfSEJBX1FVRVVFX0RFUFRIKTsKKwlhdG9taWNfc2V0KCZoYmEtPm1heF9xdWV1ZV9kZXB0aCwgRkRfSEJBX1FVRVVFX0RFUFRIKTsKKwloYmEtPmhiYV9wdHIgPSAodm9pZCAqKSBmZF9ob3N0OworCisJcHJpbnRrKEtFUk5fSU5GTyAiQ09SRV9IQkFbJWRdIC0gVENNIEZJTEVJTyBIQkEgRHJpdmVyICVzIG9uIEdlbmVyaWMiCisJCSIgVGFyZ2V0IENvcmUgU3RhY2sgJXNcbiIsIGhiYS0+aGJhX2lkLCBGRF9WRVJTSU9OLAorCQlUQVJHRVRfQ09SRV9NT0RfVkVSU0lPTik7CisJcHJpbnRrKEtFUk5fSU5GTyAiQ09SRV9IQkFbJWRdIC0gQXR0YWNoZWQgRklMRUlPIEhCQTogJXUgdG8gR2VuZXJpYyIKKwkJIiBUYXJnZXQgQ29yZSB3aXRoIFRDUSBEZXB0aDogJWQgTWF4U2VjdG9yczogJXVcbiIsCisJCWhiYS0+aGJhX2lkLCBmZF9ob3N0LT5mZF9ob3N0X2lkLAorCQlhdG9taWNfcmVhZCgmaGJhLT5tYXhfcXVldWVfZGVwdGgpLCBGRF9NQVhfU0VDVE9SUyk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgZmRfZGV0YWNoX2hiYShzdHJ1Y3Qgc2VfaGJhICpoYmEpCit7CisJc3RydWN0IGZkX2hvc3QgKmZkX2hvc3QgPSBoYmEtPmhiYV9wdHI7CisKKwlwcmludGsoS0VSTl9JTkZPICJDT1JFX0hCQVslZF0gLSBEZXRhY2hlZCBGSUxFSU8gSEJBOiAldSBmcm9tIEdlbmVyaWMiCisJCSIgVGFyZ2V0IENvcmVcbiIsIGhiYS0+aGJhX2lkLCBmZF9ob3N0LT5mZF9ob3N0X2lkKTsKKworCWtmcmVlKGZkX2hvc3QpOworCWhiYS0+aGJhX3B0ciA9IE5VTEw7Cit9CisKK3N0YXRpYyB2b2lkICpmZF9hbGxvY2F0ZV92aXJ0ZGV2aWNlKHN0cnVjdCBzZV9oYmEgKmhiYSwgY29uc3QgY2hhciAqbmFtZSkKK3sKKwlzdHJ1Y3QgZmRfZGV2ICpmZF9kZXY7CisJc3RydWN0IGZkX2hvc3QgKmZkX2hvc3QgPSAoc3RydWN0IGZkX2hvc3QgKikgaGJhLT5oYmFfcHRyOworCisJZmRfZGV2ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGZkX2RldiksIEdGUF9LRVJORUwpOworCWlmICghKGZkX2RldikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgbWVtb3J5IGZvciBzdHJ1Y3QgZmRfZGV2XG4iKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJZmRfZGV2LT5mZF9ob3N0ID0gZmRfaG9zdDsKKworCXByaW50ayhLRVJOX0lORk8gIkZJTEVJTzogQWxsb2NhdGVkIGZkX2RldiBmb3IgJXBcbiIsIG5hbWUpOworCisJcmV0dXJuIGZkX2RldjsKK30KKworLyoJZmRfY3JlYXRlX3ZpcnRkZXZpY2UoKTogKFBhcnQgb2Ygc2Vfc3Vic3lzdGVtX2FwaV90IHRlbXBsYXRlKQorICoKKyAqCisgKi8KK3N0YXRpYyBzdHJ1Y3Qgc2VfZGV2aWNlICpmZF9jcmVhdGVfdmlydGRldmljZSgKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEsCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiwKKwl2b2lkICpwKQoreworCWNoYXIgKmRldl9wID0gTlVMTDsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXY7CisJc3RydWN0IHNlX2Rldl9saW1pdHMgZGV2X2xpbWl0czsKKwlzdHJ1Y3QgcXVldWVfbGltaXRzICpsaW1pdHM7CisJc3RydWN0IGZkX2RldiAqZmRfZGV2ID0gKHN0cnVjdCBmZF9kZXYgKikgcDsKKwlzdHJ1Y3QgZmRfaG9zdCAqZmRfaG9zdCA9IChzdHJ1Y3QgZmRfaG9zdCAqKSBoYmEtPmhiYV9wdHI7CisJbW1fc2VnbWVudF90IG9sZF9mczsKKwlzdHJ1Y3QgZmlsZSAqZmlsZTsKKwlzdHJ1Y3QgaW5vZGUgKmlub2RlID0gTlVMTDsKKwlpbnQgZGV2X2ZsYWdzID0gMCwgZmxhZ3M7CisKKwltZW1zZXQoJmRldl9saW1pdHMsIDAsIHNpemVvZihzdHJ1Y3Qgc2VfZGV2X2xpbWl0cykpOworCisJb2xkX2ZzID0gZ2V0X2ZzKCk7CisJc2V0X2ZzKGdldF9kcygpKTsKKwlkZXZfcCA9IGdldG5hbWUoZmRfZGV2LT5mZF9kZXZfbmFtZSk7CisJc2V0X2ZzKG9sZF9mcyk7CisKKwlpZiAoSVNfRVJSKGRldl9wKSkgeworCQlwcmludGsoS0VSTl9FUlIgImdldG5hbWUoJXMpIGZhaWxlZDogJWx1XG4iLAorCQkJZmRfZGV2LT5mZF9kZXZfbmFtZSwgSVNfRVJSKGRldl9wKSk7CisJCWdvdG8gZmFpbDsKKwl9CisjaWYgMAorCWlmIChkaS0+bm9fY3JlYXRlX2ZpbGUpCisJCWZsYWdzID0gT19SRFdSIHwgT19MQVJHRUZJTEU7CisJZWxzZQorCQlmbGFncyA9IE9fUkRXUiB8IE9fQ1JFQVQgfCBPX0xBUkdFRklMRTsKKyNlbHNlCisJZmxhZ3MgPSBPX1JEV1IgfCBPX0NSRUFUIHwgT19MQVJHRUZJTEU7CisjZW5kaWYKKy8qCWZsYWdzIHw9IE9fRElSRUNUOyAqLworCS8qCisJICogSWYgZmRfYnVmZmVyZWRfaW89MSBoYXMgbm90IGJlZW4gc2V0IGV4cGxpY3RseSAodGhlIGRlZmF1bHQpLAorCSAqIHVzZSBPX1NZTkMgdG8gZm9yY2UgRklMRUlPIHdyaXRlcyB0byBkaXNrLgorCSAqLworCWlmICghKGZkX2Rldi0+ZmJkX2ZsYWdzICYgRkRCRF9VU0VfQlVGRkVSRURfSU8pKQorCQlmbGFncyB8PSBPX1NZTkM7CisKKwlmaWxlID0gZmlscF9vcGVuKGRldl9wLCBmbGFncywgMDYwMCk7CisKKwlpZiAoSVNfRVJSKGZpbGUpIHx8ICFmaWxlIHx8ICFmaWxlLT5mX2RlbnRyeSkgeworCQlwcmludGsoS0VSTl9FUlIgImZpbHBfb3BlbiglcykgZmFpbGVkXG4iLCBkZXZfcCk7CisJCWdvdG8gZmFpbDsKKwl9CisJZmRfZGV2LT5mZF9maWxlID0gZmlsZTsKKwkvKgorCSAqIElmIHVzaW5nIGEgYmxvY2sgYmFja2VuZCB3aXRoIHRoaXMgc3RydWN0IGZpbGUsIHdlIGV4dHJhY3QKKwkgKiBmZF9kZXYtPmZkX1tibG9jayxkZXZdX3NpemUgZnJvbSBzdHJ1Y3QgYmxvY2tfZGV2aWNlLgorCSAqCisJICogT3RoZXJ3aXNlLCB3ZSB1c2UgdGhlIHBhc3NlZCBmZF9zaXplPSBmcm9tIGNvbmZpZ2ZzCisJICovCisJaW5vZGUgPSBmaWxlLT5mX21hcHBpbmctPmhvc3Q7CisJaWYgKFNfSVNCTEsoaW5vZGUtPmlfbW9kZSkpIHsKKwkJc3RydWN0IHJlcXVlc3RfcXVldWUgKnE7CisJCS8qCisJCSAqIFNldHVwIHRoZSBsb2NhbCBzY29wZSBxdWV1ZV9saW1pdHMgZnJvbSBzdHJ1Y3QgcmVxdWVzdF9xdWV1ZS0+bGltaXRzCisJCSAqIHRvIHBhc3MgaW50byB0cmFuc3BvcnRfYWRkX2RldmljZV90b19jb3JlX2hiYSgpIGFzIHN0cnVjdCBzZV9kZXZfbGltaXRzLgorCQkgKi8KKwkJcSA9IGJkZXZfZ2V0X3F1ZXVlKGlub2RlLT5pX2JkZXYpOworCQlsaW1pdHMgPSAmZGV2X2xpbWl0cy5saW1pdHM7CisJCWxpbWl0cy0+bG9naWNhbF9ibG9ja19zaXplID0gYmRldl9sb2dpY2FsX2Jsb2NrX3NpemUoaW5vZGUtPmlfYmRldik7CisJCWxpbWl0cy0+bWF4X2h3X3NlY3RvcnMgPSBxdWV1ZV9tYXhfaHdfc2VjdG9ycyhxKTsKKwkJbGltaXRzLT5tYXhfc2VjdG9ycyA9IHF1ZXVlX21heF9zZWN0b3JzKHEpOworCQkvKgorCQkgKiBEZXRlcm1pbmUgdGhlIG51bWJlciBvZiBieXRlcyBmcm9tIGlfc2l6ZV9yZWFkKCkgbWludXMKKwkJICogb25lICgxKSBsb2dpY2FsIHNlY3RvciBmcm9tIHVuZGVybHlpbmcgc3RydWN0IGJsb2NrX2RldmljZQorCQkgKi8KKwkJZmRfZGV2LT5mZF9ibG9ja19zaXplID0gYmRldl9sb2dpY2FsX2Jsb2NrX3NpemUoaW5vZGUtPmlfYmRldik7CisJCWZkX2Rldi0+ZmRfZGV2X3NpemUgPSAoaV9zaXplX3JlYWQoZmlsZS0+Zl9tYXBwaW5nLT5ob3N0KSAtCisJCQkJICAgICAgIGZkX2Rldi0+ZmRfYmxvY2tfc2l6ZSk7CisKKwkJcHJpbnRrKEtFUk5fSU5GTyAiRklMRUlPOiBVc2luZyBzaXplOiAlbGx1IGJ5dGVzIGZyb20gc3RydWN0IgorCQkJIiBibG9ja19kZXZpY2UgYmxvY2tzOiAlbGx1IGxvZ2ljYWxfYmxvY2tfc2l6ZTogJWRcbiIsCisJCQlmZF9kZXYtPmZkX2Rldl9zaXplLAorCQkJZGl2X3U2NChmZF9kZXYtPmZkX2Rldl9zaXplLCBmZF9kZXYtPmZkX2Jsb2NrX3NpemUpLAorCQkJZmRfZGV2LT5mZF9ibG9ja19zaXplKTsKKwl9IGVsc2UgeworCQlpZiAoIShmZF9kZXYtPmZiZF9mbGFncyAmIEZCREZfSEFTX1NJWkUpKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIkZJTEVJTzogTWlzc2luZyBmZF9kZXZfc2l6ZT0iCisJCQkJIiBwYXJhbWV0ZXIsIGFuZCBubyBiYWNraW5nIHN0cnVjdCIKKwkJCQkiIGJsb2NrX2RldmljZVxuIik7CisJCQlnb3RvIGZhaWw7CisJCX0KKworCQlsaW1pdHMgPSAmZGV2X2xpbWl0cy5saW1pdHM7CisJCWxpbWl0cy0+bG9naWNhbF9ibG9ja19zaXplID0gRkRfQkxPQ0tTSVpFOworCQlsaW1pdHMtPm1heF9od19zZWN0b3JzID0gRkRfTUFYX1NFQ1RPUlM7CisJCWxpbWl0cy0+bWF4X3NlY3RvcnMgPSBGRF9NQVhfU0VDVE9SUzsKKwkJZmRfZGV2LT5mZF9ibG9ja19zaXplID0gRkRfQkxPQ0tTSVpFOworCX0KKworCWRldl9saW1pdHMuaHdfcXVldWVfZGVwdGggPSBGRF9NQVhfREVWSUNFX1FVRVVFX0RFUFRIOworCWRldl9saW1pdHMucXVldWVfZGVwdGggPSBGRF9ERVZJQ0VfUVVFVUVfREVQVEg7CisKKwlkZXYgPSB0cmFuc3BvcnRfYWRkX2RldmljZV90b19jb3JlX2hiYShoYmEsICZmaWxlaW9fdGVtcGxhdGUsCisJCQkJc2VfZGV2LCBkZXZfZmxhZ3MsICh2b2lkICopZmRfZGV2LAorCQkJCSZkZXZfbGltaXRzLCAiRklMRUlPIiwgRkRfVkVSU0lPTik7CisJaWYgKCEoZGV2KSkKKwkJZ290byBmYWlsOworCisJZmRfZGV2LT5mZF9kZXZfaWQgPSBmZF9ob3N0LT5mZF9ob3N0X2Rldl9pZF9jb3VudCsrOworCWZkX2Rldi0+ZmRfcXVldWVfZGVwdGggPSBkZXYtPnF1ZXVlX2RlcHRoOworCisJcHJpbnRrKEtFUk5fSU5GTyAiQ09SRV9GSUxFWyV1XSAtIEFkZGVkIFRDTSBGSUxFSU8gRGV2aWNlIElEOiAldSBhdCAlcywiCisJCSIgJWxsdSB0b3RhbCBieXRlc1xuIiwgZmRfaG9zdC0+ZmRfaG9zdF9pZCwgZmRfZGV2LT5mZF9kZXZfaWQsCisJCQlmZF9kZXYtPmZkX2Rldl9uYW1lLCBmZF9kZXYtPmZkX2Rldl9zaXplKTsKKworCXB1dG5hbWUoZGV2X3ApOworCXJldHVybiBkZXY7CitmYWlsOgorCWlmIChmZF9kZXYtPmZkX2ZpbGUpIHsKKwkJZmlscF9jbG9zZShmZF9kZXYtPmZkX2ZpbGUsIE5VTEwpOworCQlmZF9kZXYtPmZkX2ZpbGUgPSBOVUxMOworCX0KKwlwdXRuYW1lKGRldl9wKTsKKwlyZXR1cm4gTlVMTDsKK30KKworLyoJZmRfZnJlZV9kZXZpY2UoKTogKFBhcnQgb2Ygc2Vfc3Vic3lzdGVtX2FwaV90IHRlbXBsYXRlKQorICoKKyAqCisgKi8KK3N0YXRpYyB2b2lkIGZkX2ZyZWVfZGV2aWNlKHZvaWQgKnApCit7CisJc3RydWN0IGZkX2RldiAqZmRfZGV2ID0gKHN0cnVjdCBmZF9kZXYgKikgcDsKKworCWlmIChmZF9kZXYtPmZkX2ZpbGUpIHsKKwkJZmlscF9jbG9zZShmZF9kZXYtPmZkX2ZpbGUsIE5VTEwpOworCQlmZF9kZXYtPmZkX2ZpbGUgPSBOVUxMOworCX0KKworCWtmcmVlKGZkX2Rldik7Cit9CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IGZkX3JlcXVlc3QgKkZJTEVfUkVRKHN0cnVjdCBzZV90YXNrICp0YXNrKQoreworCXJldHVybiBjb250YWluZXJfb2YodGFzaywgc3RydWN0IGZkX3JlcXVlc3QsIGZkX3Rhc2spOworfQorCisKK3N0YXRpYyBzdHJ1Y3Qgc2VfdGFzayAqCitmZF9hbGxvY190YXNrKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlzdHJ1Y3QgZmRfcmVxdWVzdCAqZmRfcmVxOworCisJZmRfcmVxID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGZkX3JlcXVlc3QpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIShmZF9yZXEpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIHN0cnVjdCBmZF9yZXF1ZXN0XG4iKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJZmRfcmVxLT5mZF9kZXYgPSBTRV9ERVYoY21kKS0+ZGV2X3B0cjsKKworCXJldHVybiAmZmRfcmVxLT5mZF90YXNrOworfQorCitzdGF0aWMgaW50IGZkX2RvX3JlYWR2KHN0cnVjdCBzZV90YXNrICp0YXNrKQoreworCXN0cnVjdCBmZF9yZXF1ZXN0ICpyZXEgPSBGSUxFX1JFUSh0YXNrKTsKKwlzdHJ1Y3QgZmlsZSAqZmQgPSByZXEtPmZkX2Rldi0+ZmRfZmlsZTsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnID0gdGFzay0+dGFza19zZzsKKwlzdHJ1Y3QgaW92ZWMgKmlvdjsKKwltbV9zZWdtZW50X3Qgb2xkX2ZzOworCWxvZmZfdCBwb3MgPSAodGFzay0+dGFza19sYmEgKiBERVZfQVRUUklCKHRhc2stPnNlX2RldiktPmJsb2NrX3NpemUpOworCWludCByZXQgPSAwLCBpOworCisJaW92ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGlvdmVjKSAqIHRhc2stPnRhc2tfc2dfbnVtLCBHRlBfS0VSTkVMKTsKKwlpZiAoIShpb3YpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIGZkX2RvX3JlYWR2IGlvdltdXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWZvciAoaSA9IDA7IGkgPCB0YXNrLT50YXNrX3NnX251bTsgaSsrKSB7CisJCWlvdltpXS5pb3ZfbGVuID0gc2dbaV0ubGVuZ3RoOworCQlpb3ZbaV0uaW92X2Jhc2UgPSBzZ192aXJ0KCZzZ1tpXSk7CisJfQorCisJb2xkX2ZzID0gZ2V0X2ZzKCk7CisJc2V0X2ZzKGdldF9kcygpKTsKKwlyZXQgPSB2ZnNfcmVhZHYoZmQsICZpb3ZbMF0sIHRhc2stPnRhc2tfc2dfbnVtLCAmcG9zKTsKKwlzZXRfZnMob2xkX2ZzKTsKKworCWtmcmVlKGlvdik7CisJLyoKKwkgKiBSZXR1cm4gemVyb3MgYW5kIEdPT0Qgc3RhdHVzIGV2ZW4gaWYgdGhlIFJFQUQgZGlkIG5vdCByZXR1cm4KKwkgKiB0aGUgZXhwZWN0ZWQgdmlydF9zaXplIGZvciBzdHJ1Y3QgZmlsZSB3L28gYSBiYWNraW5nIHN0cnVjdAorCSAqIGJsb2NrX2RldmljZS4KKwkgKi8KKwlpZiAoU19JU0JMSyhmZC0+Zl9kZW50cnktPmRfaW5vZGUtPmlfbW9kZSkpIHsKKwkJaWYgKHJldCA8IDAgfHwgcmV0ICE9IHRhc2stPnRhc2tfc2l6ZSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJ2ZnNfcmVhZHYoKSByZXR1cm5lZCAlZCwiCisJCQkJIiBleHBlY3RpbmcgJWQgZm9yIFNfSVNCTEtcbiIsIHJldCwKKwkJCQkoaW50KXRhc2stPnRhc2tfc2l6ZSk7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9IGVsc2UgeworCQlpZiAocmV0IDwgMCkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJ2ZnNfcmVhZHYoKSByZXR1cm5lZCAlZCBmb3Igbm9uIgorCQkJCSIgU19JU0JMS1xuIiwgcmV0KTsKKwkJCXJldHVybiAtMTsKKwkJfQorCX0KKworCXJldHVybiAxOworfQorCitzdGF0aWMgaW50IGZkX2RvX3dyaXRldihzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlzdHJ1Y3QgZmRfcmVxdWVzdCAqcmVxID0gRklMRV9SRVEodGFzayk7CisJc3RydWN0IGZpbGUgKmZkID0gcmVxLT5mZF9kZXYtPmZkX2ZpbGU7CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZyA9IHRhc2stPnRhc2tfc2c7CisJc3RydWN0IGlvdmVjICppb3Y7CisJbW1fc2VnbWVudF90IG9sZF9mczsKKwlsb2ZmX3QgcG9zID0gKHRhc2stPnRhc2tfbGJhICogREVWX0FUVFJJQih0YXNrLT5zZV9kZXYpLT5ibG9ja19zaXplKTsKKwlpbnQgcmV0LCBpID0gMDsKKworCWlvdiA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBpb3ZlYykgKiB0YXNrLT50YXNrX3NnX251bSwgR0ZQX0tFUk5FTCk7CisJaWYgKCEoaW92KSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBmZF9kb193cml0ZXYgaW92W11cbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJZm9yIChpID0gMDsgaSA8IHRhc2stPnRhc2tfc2dfbnVtOyBpKyspIHsKKwkJaW92W2ldLmlvdl9sZW4gPSBzZ1tpXS5sZW5ndGg7CisJCWlvdltpXS5pb3ZfYmFzZSA9IHNnX3ZpcnQoJnNnW2ldKTsKKwl9CisKKwlvbGRfZnMgPSBnZXRfZnMoKTsKKwlzZXRfZnMoZ2V0X2RzKCkpOworCXJldCA9IHZmc193cml0ZXYoZmQsICZpb3ZbMF0sIHRhc2stPnRhc2tfc2dfbnVtLCAmcG9zKTsKKwlzZXRfZnMob2xkX2ZzKTsKKworCWtmcmVlKGlvdik7CisKKwlpZiAocmV0IDwgMCB8fCByZXQgIT0gdGFzay0+dGFza19zaXplKSB7CisJCXByaW50ayhLRVJOX0VSUiAidmZzX3dyaXRldigpIHJldHVybmVkICVkXG4iLCByZXQpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDE7Cit9CisKK3N0YXRpYyB2b2lkIGZkX2VtdWxhdGVfc3luY19jYWNoZShzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlzdHJ1Y3Qgc2VfY21kICpjbWQgPSBUQVNLX0NNRCh0YXNrKTsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBjbWQtPnNlX2RldjsKKwlzdHJ1Y3QgZmRfZGV2ICpmZF9kZXYgPSBkZXYtPmRldl9wdHI7CisJaW50IGltbWVkID0gKGNtZC0+dF90YXNrLT50X3Rhc2tfY2RiWzFdICYgMHgyKTsKKwlsb2ZmX3Qgc3RhcnQsIGVuZDsKKwlpbnQgcmV0OworCisJLyoKKwkgKiBJZiB0aGUgSW1tZWRpYXRlIGJpdCBpcyBzZXQsIHF1ZXVlIHVwIHRoZSBHT09EIHJlc3BvbnNlCisJICogZm9yIHRoaXMgU1lOQ0hST05JWkVfQ0FDSEUgb3AKKwkgKi8KKwlpZiAoaW1tZWQpCisJCXRyYW5zcG9ydF9jb21wbGV0ZV9zeW5jX2NhY2hlKGNtZCwgMSk7CisKKwkvKgorCSAqIERldGVybWluZSBpZiB3ZSB3aWxsIGJlIGZsdXNoaW5nIHRoZSBlbnRpcmUgZGV2aWNlLgorCSAqLworCWlmIChjbWQtPnRfdGFzay0+dF90YXNrX2xiYSA9PSAwICYmIGNtZC0+ZGF0YV9sZW5ndGggPT0gMCkgeworCQlzdGFydCA9IDA7CisJCWVuZCA9IExMT05HX01BWDsKKwl9IGVsc2UgeworCQlzdGFydCA9IGNtZC0+dF90YXNrLT50X3Rhc2tfbGJhICogREVWX0FUVFJJQihkZXYpLT5ibG9ja19zaXplOworCQlpZiAoY21kLT5kYXRhX2xlbmd0aCkKKwkJCWVuZCA9IHN0YXJ0ICsgY21kLT5kYXRhX2xlbmd0aDsKKwkJZWxzZQorCQkJZW5kID0gTExPTkdfTUFYOworCX0KKworCXJldCA9IHZmc19mc3luY19yYW5nZShmZF9kZXYtPmZkX2ZpbGUsIHN0YXJ0LCBlbmQsIDEpOworCWlmIChyZXQgIT0gMCkKKwkJcHJpbnRrKEtFUk5fRVJSICJGSUxFSU86IHZmc19mc3luY19yYW5nZSgpIGZhaWxlZDogJWRcbiIsIHJldCk7CisKKwlpZiAoIWltbWVkKQorCQl0cmFuc3BvcnRfY29tcGxldGVfc3luY19jYWNoZShjbWQsIHJldCA9PSAwKTsKK30KKworLyoKKyAqIFRlbGwgVENNIENvcmUgdGhhdCB3ZSBhcmUgY2FwYWJsZSBvZiBXcml0ZUNhY2hlIGVtdWxhdGlvbiBmb3IKKyAqIGFuIHVuZGVybHlpbmcgc3RydWN0IHNlX2RldmljZS4KKyAqLworc3RhdGljIGludCBmZF9lbXVsYXRlZF93cml0ZV9jYWNoZShzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpCit7CisJcmV0dXJuIDE7Cit9CisKK3N0YXRpYyBpbnQgZmRfZW11bGF0ZWRfZHBvKHN0cnVjdCBzZV9kZXZpY2UgKmRldikKK3sKKwlyZXR1cm4gMDsKK30KKy8qCisgKiBUZWxsIFRDTSBDb3JlIHRoYXQgd2Ugd2lsbCBiZSBlbXVsYXRpbmcgRm9yY2VkIFVuaXQgQWNjZXNzIChGVUEpIGZvciBXUklURXMKKyAqIGZvciBUWVBFX0RJU0suCisgKi8KK3N0YXRpYyBpbnQgZmRfZW11bGF0ZWRfZnVhX3dyaXRlKHN0cnVjdCBzZV9kZXZpY2UgKmRldikKK3sKKwlyZXR1cm4gMTsKK30KKworc3RhdGljIGludCBmZF9lbXVsYXRlZF9mdWFfcmVhZChzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpCit7CisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBXUklURSBGb3JjZSBVbml0IEFjY2VzcyAoRlVBKSBlbXVsYXRpb24gb24gYSBwZXIgc3RydWN0IHNlX3Rhc2sKKyAqIExCQSByYW5nZSBiYXNpcy4uCisgKi8KK3N0YXRpYyB2b2lkIGZkX2VtdWxhdGVfd3JpdGVfZnVhKHN0cnVjdCBzZV9jbWQgKmNtZCwgc3RydWN0IHNlX3Rhc2sgKnRhc2spCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gY21kLT5zZV9kZXY7CisJc3RydWN0IGZkX2RldiAqZmRfZGV2ID0gZGV2LT5kZXZfcHRyOworCWxvZmZfdCBzdGFydCA9IHRhc2stPnRhc2tfbGJhICogREVWX0FUVFJJQihkZXYpLT5ibG9ja19zaXplOworCWxvZmZfdCBlbmQgPSBzdGFydCArIHRhc2stPnRhc2tfc2l6ZTsKKwlpbnQgcmV0OworCisJREVCVUdfRkRfQ0FDSEUoIkZJTEVJTzogRlVBIFdSSVRFIExCQTogJWxsdSwgYnl0ZXM6ICV1XG4iLAorCQkJdGFzay0+dGFza19sYmEsIHRhc2stPnRhc2tfc2l6ZSk7CisKKwlyZXQgPSB2ZnNfZnN5bmNfcmFuZ2UoZmRfZGV2LT5mZF9maWxlLCBzdGFydCwgZW5kLCAxKTsKKwlpZiAocmV0ICE9IDApCisJCXByaW50ayhLRVJOX0VSUiAiRklMRUlPOiB2ZnNfZnN5bmNfcmFuZ2UoKSBmYWlsZWQ6ICVkXG4iLCByZXQpOworfQorCitzdGF0aWMgaW50IGZkX2RvX3Rhc2soc3RydWN0IHNlX3Rhc2sgKnRhc2spCit7CisJc3RydWN0IHNlX2NtZCAqY21kID0gdGFzay0+dGFza19zZV9jbWQ7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gY21kLT5zZV9kZXY7CisJaW50IHJldCA9IDA7CisKKwkvKgorCSAqIENhbGwgdmVjdG9yaXplZCBmaWxlaW8gZnVuY3Rpb25zIHRvIG1hcCBzdHJ1Y3Qgc2NhdHRlcmxpc3QKKwkgKiBwaHlzaWNhbCBtZW1vcnkgYWRkcmVzc2VzIHRvIHN0cnVjdCBpb3ZlYyB2aXJ0dWFsIG1lbW9yeS4KKwkgKi8KKwlpZiAodGFzay0+dGFza19kYXRhX2RpcmVjdGlvbiA9PSBETUFfRlJPTV9ERVZJQ0UpIHsKKwkJcmV0ID0gZmRfZG9fcmVhZHYodGFzayk7CisJfSBlbHNlIHsKKwkJcmV0ID0gZmRfZG9fd3JpdGV2KHRhc2spOworCisJCWlmIChyZXQgPiAwICYmCisJCSAgICBERVZfQVRUUklCKGRldiktPmVtdWxhdGVfd3JpdGVfY2FjaGUgPiAwICYmCisJCSAgICBERVZfQVRUUklCKGRldiktPmVtdWxhdGVfZnVhX3dyaXRlID4gMCAmJgorCQkgICAgVF9UQVNLKGNtZCktPnRfdGFza3NfZnVhKSB7CisJCQkvKgorCQkJICogV2UgbWlnaHQgbmVlZCB0byBiZSBhIGJpdCBzbWFydGVyIGhlcmUKKwkJCSAqIGFuZCByZXR1cm4gc29tZSBzZW5zZSBkYXRhIHRvIGxldCB0aGUgaW5pdGlhdG9yCisJCQkgKiBrbm93IHRoZSBGVUEgV1JJVEUgY2FjaGUgc3luYyBmYWlsZWQuLj8KKwkJCSAqLworCQkJZmRfZW11bGF0ZV93cml0ZV9mdWEoY21kLCB0YXNrKTsKKwkJfQorCisJfQorCisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisJaWYgKHJldCkgeworCQl0YXNrLT50YXNrX3Njc2lfc3RhdHVzID0gR09PRDsKKwkJdHJhbnNwb3J0X2NvbXBsZXRlX3Rhc2sodGFzaywgMSk7CisJfQorCXJldHVybiBQWVhfVFJBTlNQT1JUX1NFTlRfVE9fVFJBTlNQT1JUOworfQorCisvKglmZF9mcmVlX3Rhc2soKTogKFBhcnQgb2Ygc2Vfc3Vic3lzdGVtX2FwaV90IHRlbXBsYXRlKQorICoKKyAqCisgKi8KK3N0YXRpYyB2b2lkIGZkX2ZyZWVfdGFzayhzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlzdHJ1Y3QgZmRfcmVxdWVzdCAqcmVxID0gRklMRV9SRVEodGFzayk7CisKKwlrZnJlZShyZXEpOworfQorCitlbnVtIHsKKwlPcHRfZmRfZGV2X25hbWUsIE9wdF9mZF9kZXZfc2l6ZSwgT3B0X2ZkX2J1ZmZlcmVkX2lvLCBPcHRfZXJyCit9OworCitzdGF0aWMgbWF0Y2hfdGFibGVfdCB0b2tlbnMgPSB7CisJe09wdF9mZF9kZXZfbmFtZSwgImZkX2Rldl9uYW1lPSVzIn0sCisJe09wdF9mZF9kZXZfc2l6ZSwgImZkX2Rldl9zaXplPSVzIn0sCisJe09wdF9mZF9idWZmZXJlZF9pbywgImZkX2J1ZmZlcmVkX2lkPSVkIn0sCisJe09wdF9lcnIsIE5VTEx9Cit9OworCitzdGF0aWMgc3NpemVfdCBmZF9zZXRfY29uZmlnZnNfZGV2X3BhcmFtcygKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEsCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiwKKwljb25zdCBjaGFyICpwYWdlLCBzc2l6ZV90IGNvdW50KQoreworCXN0cnVjdCBmZF9kZXYgKmZkX2RldiA9IHNlX2Rldi0+c2VfZGV2X3N1X3B0cjsKKwljaGFyICpvcmlnLCAqcHRyLCAqYXJnX3AsICpvcHRzOworCXN1YnN0cmluZ190IGFyZ3NbTUFYX09QVF9BUkdTXTsKKwlpbnQgcmV0ID0gMCwgYXJnLCB0b2tlbjsKKworCW9wdHMgPSBrc3RyZHVwKHBhZ2UsIEdGUF9LRVJORUwpOworCWlmICghb3B0cykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlvcmlnID0gb3B0czsKKworCXdoaWxlICgocHRyID0gc3Ryc2VwKCZvcHRzLCAiLCIpKSAhPSBOVUxMKSB7CisJCWlmICghKnB0cikKKwkJCWNvbnRpbnVlOworCisJCXRva2VuID0gbWF0Y2hfdG9rZW4ocHRyLCB0b2tlbnMsIGFyZ3MpOworCQlzd2l0Y2ggKHRva2VuKSB7CisJCWNhc2UgT3B0X2ZkX2Rldl9uYW1lOgorCQkJc25wcmludGYoZmRfZGV2LT5mZF9kZXZfbmFtZSwgRkRfTUFYX0RFVl9OQU1FLAorCQkJCQkiJXMiLCBtYXRjaF9zdHJkdXAoJmFyZ3NbMF0pKTsKKwkJCXByaW50ayhLRVJOX0lORk8gIkZJTEVJTzogUmVmZXJlbmNpbmcgUGF0aDogJXNcbiIsCisJCQkJCWZkX2Rldi0+ZmRfZGV2X25hbWUpOworCQkJZmRfZGV2LT5mYmRfZmxhZ3MgfD0gRkJERl9IQVNfUEFUSDsKKwkJCWJyZWFrOworCQljYXNlIE9wdF9mZF9kZXZfc2l6ZToKKwkJCWFyZ19wID0gbWF0Y2hfc3RyZHVwKCZhcmdzWzBdKTsKKwkJCXJldCA9IHN0cmljdF9zdHJ0b3VsbChhcmdfcCwgMCwgJmZkX2Rldi0+ZmRfZGV2X3NpemUpOworCQkJaWYgKHJldCA8IDApIHsKKwkJCQlwcmludGsoS0VSTl9FUlIgInN0cmljdF9zdHJ0b3VsbCgpIGZhaWxlZCBmb3IiCisJCQkJCQkiIGZkX2Rldl9zaXplPVxuIik7CisJCQkJZ290byBvdXQ7CisJCQl9CisJCQlwcmludGsoS0VSTl9JTkZPICJGSUxFSU86IFJlZmVyZW5jaW5nIFNpemU6ICVsbHUiCisJCQkJCSIgYnl0ZXNcbiIsIGZkX2Rldi0+ZmRfZGV2X3NpemUpOworCQkJZmRfZGV2LT5mYmRfZmxhZ3MgfD0gRkJERl9IQVNfU0laRTsKKwkJCWJyZWFrOworCQljYXNlIE9wdF9mZF9idWZmZXJlZF9pbzoKKwkJCW1hdGNoX2ludChhcmdzLCAmYXJnKTsKKwkJCWlmIChhcmcgIT0gMSkgeworCQkJCXByaW50ayhLRVJOX0VSUiAiYm9ndXMgZmRfYnVmZmVyZWRfaW89JWQgdmFsdWVcbiIsIGFyZyk7CisJCQkJcmV0ID0gLUVJTlZBTDsKKwkJCQlnb3RvIG91dDsKKwkJCX0KKworCQkJcHJpbnRrKEtFUk5fSU5GTyAiRklMRUlPOiBVc2luZyBidWZmZXJlZCBJL08iCisJCQkJIiBvcGVyYXRpb25zIGZvciBzdHJ1Y3QgZmRfZGV2XG4iKTsKKworCQkJZmRfZGV2LT5mYmRfZmxhZ3MgfD0gRkRCRF9VU0VfQlVGRkVSRURfSU87CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCWJyZWFrOworCQl9CisJfQorCitvdXQ6CisJa2ZyZWUob3JpZyk7CisJcmV0dXJuICghcmV0KSA/IGNvdW50IDogcmV0OworfQorCitzdGF0aWMgc3NpemVfdCBmZF9jaGVja19jb25maWdmc19kZXZfcGFyYW1zKHN0cnVjdCBzZV9oYmEgKmhiYSwgc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldikKK3sKKwlzdHJ1Y3QgZmRfZGV2ICpmZF9kZXYgPSAoc3RydWN0IGZkX2RldiAqKSBzZV9kZXYtPnNlX2Rldl9zdV9wdHI7CisKKwlpZiAoIShmZF9kZXYtPmZiZF9mbGFncyAmIEZCREZfSEFTX1BBVEgpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyBmZF9kZXZfbmFtZT1cbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzc2l6ZV90IGZkX3Nob3dfY29uZmlnZnNfZGV2X3BhcmFtcygKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEsCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiwKKwljaGFyICpiKQoreworCXN0cnVjdCBmZF9kZXYgKmZkX2RldiA9IHNlX2Rldi0+c2VfZGV2X3N1X3B0cjsKKwlzc2l6ZV90IGJsID0gMDsKKworCWJsID0gc3ByaW50ZihiICsgYmwsICJUQ00gRklMRUlPIElEOiAldSIsIGZkX2Rldi0+ZmRfZGV2X2lkKTsKKwlibCArPSBzcHJpbnRmKGIgKyBibCwgIiAgICAgICAgRmlsZTogJXMgIFNpemU6ICVsbHUgIE1vZGU6ICVzXG4iLAorCQlmZF9kZXYtPmZkX2Rldl9uYW1lLCBmZF9kZXYtPmZkX2Rldl9zaXplLAorCQkoZmRfZGV2LT5mYmRfZmxhZ3MgJiBGREJEX1VTRV9CVUZGRVJFRF9JTykgPworCQkiQnVmZmVyZWQiIDogIlN5bmNocm9ub3VzIik7CisJcmV0dXJuIGJsOworfQorCisvKglmZF9nZXRfY2RiKCk6IChQYXJ0IG9mIHNlX3N1YnN5c3RlbV9hcGlfdCB0ZW1wbGF0ZSkKKyAqCisgKgorICovCitzdGF0aWMgdW5zaWduZWQgY2hhciAqZmRfZ2V0X2NkYihzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlzdHJ1Y3QgZmRfcmVxdWVzdCAqcmVxID0gRklMRV9SRVEodGFzayk7CisKKwlyZXR1cm4gcmVxLT5mZF9zY3NpX2NkYjsKK30KKworLyoJZmRfZ2V0X2RldmljZV9yZXYoKTogKFBhcnQgb2Ygc2Vfc3Vic3lzdGVtX2FwaV90IHRlbXBsYXRlKQorICoKKyAqCisgKi8KK3N0YXRpYyB1MzIgZmRfZ2V0X2RldmljZV9yZXYoc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXJldHVybiBTQ1NJX1NQQ18yOyAvKiBSZXR1cm5zIFNQQy0zIGluIEluaXRpYXRvciBEYXRhICovCit9CisKKy8qCWZkX2dldF9kZXZpY2VfdHlwZSgpOiAoUGFydCBvZiBzZV9zdWJzeXN0ZW1fYXBpX3QgdGVtcGxhdGUpCisgKgorICoKKyAqLworc3RhdGljIHUzMiBmZF9nZXRfZGV2aWNlX3R5cGUoc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXJldHVybiBUWVBFX0RJU0s7Cit9CisKK3N0YXRpYyBzZWN0b3JfdCBmZF9nZXRfYmxvY2tzKHN0cnVjdCBzZV9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgZmRfZGV2ICpmZF9kZXYgPSBkZXYtPmRldl9wdHI7CisJdW5zaWduZWQgbG9uZyBsb25nIGJsb2Nrc19sb25nID0gZGl2X3U2NChmZF9kZXYtPmZkX2Rldl9zaXplLAorCQkJREVWX0FUVFJJQihkZXYpLT5ibG9ja19zaXplKTsKKworCXJldHVybiBibG9ja3NfbG9uZzsKK30KKworc3RhdGljIHN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpIGZpbGVpb190ZW1wbGF0ZSA9IHsKKwkubmFtZQkJCT0gImZpbGVpbyIsCisJLm93bmVyCQkJPSBUSElTX01PRFVMRSwKKwkudHJhbnNwb3J0X3R5cGUJCT0gVFJBTlNQT1JUX1BMVUdJTl9WSEJBX1BERVYsCisJLmF0dGFjaF9oYmEJCT0gZmRfYXR0YWNoX2hiYSwKKwkuZGV0YWNoX2hiYQkJPSBmZF9kZXRhY2hfaGJhLAorCS5hbGxvY2F0ZV92aXJ0ZGV2aWNlCT0gZmRfYWxsb2NhdGVfdmlydGRldmljZSwKKwkuY3JlYXRlX3ZpcnRkZXZpY2UJPSBmZF9jcmVhdGVfdmlydGRldmljZSwKKwkuZnJlZV9kZXZpY2UJCT0gZmRfZnJlZV9kZXZpY2UsCisJLmRwb19lbXVsYXRlZAkJPSBmZF9lbXVsYXRlZF9kcG8sCisJLmZ1YV93cml0ZV9lbXVsYXRlZAk9IGZkX2VtdWxhdGVkX2Z1YV93cml0ZSwKKwkuZnVhX3JlYWRfZW11bGF0ZWQJPSBmZF9lbXVsYXRlZF9mdWFfcmVhZCwKKwkud3JpdGVfY2FjaGVfZW11bGF0ZWQJPSBmZF9lbXVsYXRlZF93cml0ZV9jYWNoZSwKKwkuYWxsb2NfdGFzawkJPSBmZF9hbGxvY190YXNrLAorCS5kb190YXNrCQk9IGZkX2RvX3Rhc2ssCisJLmRvX3N5bmNfY2FjaGUJCT0gZmRfZW11bGF0ZV9zeW5jX2NhY2hlLAorCS5mcmVlX3Rhc2sJCT0gZmRfZnJlZV90YXNrLAorCS5jaGVja19jb25maWdmc19kZXZfcGFyYW1zID0gZmRfY2hlY2tfY29uZmlnZnNfZGV2X3BhcmFtcywKKwkuc2V0X2NvbmZpZ2ZzX2Rldl9wYXJhbXMgPSBmZF9zZXRfY29uZmlnZnNfZGV2X3BhcmFtcywKKwkuc2hvd19jb25maWdmc19kZXZfcGFyYW1zID0gZmRfc2hvd19jb25maWdmc19kZXZfcGFyYW1zLAorCS5nZXRfY2RiCQk9IGZkX2dldF9jZGIsCisJLmdldF9kZXZpY2VfcmV2CQk9IGZkX2dldF9kZXZpY2VfcmV2LAorCS5nZXRfZGV2aWNlX3R5cGUJPSBmZF9nZXRfZGV2aWNlX3R5cGUsCisJLmdldF9ibG9ja3MJCT0gZmRfZ2V0X2Jsb2NrcywKK307CisKK3N0YXRpYyBpbnQgX19pbml0IGZpbGVpb19tb2R1bGVfaW5pdCh2b2lkKQoreworCXJldHVybiB0cmFuc3BvcnRfc3Vic3lzdGVtX3JlZ2lzdGVyKCZmaWxlaW9fdGVtcGxhdGUpOworfQorCitzdGF0aWMgdm9pZCBmaWxlaW9fbW9kdWxlX2V4aXQodm9pZCkKK3sKKwl0cmFuc3BvcnRfc3Vic3lzdGVtX3JlbGVhc2UoJmZpbGVpb190ZW1wbGF0ZSk7Cit9CisKK01PRFVMRV9ERVNDUklQVElPTigiVENNIEZJTEVJTyBzdWJzeXN0ZW0gcGx1Z2luIik7CitNT0RVTEVfQVVUSE9SKCJuYWJATGludXgtaVNDU0kub3JnIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CisKK21vZHVsZV9pbml0KGZpbGVpb19tb2R1bGVfaW5pdCk7Cittb2R1bGVfZXhpdChmaWxlaW9fbW9kdWxlX2V4aXQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfZmlsZS5oIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfZmlsZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmVmNGRlMmIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9maWxlLmgKQEAgLTAsMCArMSw1MCBAQAorI2lmbmRlZiBUQVJHRVRfQ09SRV9GSUxFX0gKKyNkZWZpbmUgVEFSR0VUX0NPUkVfRklMRV9ICisKKyNkZWZpbmUgRkRfVkVSU0lPTgkJIjQuMCIKKworI2RlZmluZSBGRF9NQVhfREVWX05BTUUJCTI1NgorLyogTWF4aW11bSBxdWV1ZWRlcHRoIGZvciB0aGUgRklMRUlPIEhCQSAqLworI2RlZmluZSBGRF9IQkFfUVVFVUVfREVQVEgJMjU2CisjZGVmaW5lIEZEX0RFVklDRV9RVUVVRV9ERVBUSAkzMgorI2RlZmluZSBGRF9NQVhfREVWSUNFX1FVRVVFX0RFUFRIIDEyOAorI2RlZmluZSBGRF9CTE9DS1NJWkUJCTUxMgorI2RlZmluZSBGRF9NQVhfU0VDVE9SUwkJMTAyNAorCisjZGVmaW5lIFJSRl9FTVVMQVRFX0NEQgkJMHgwMQorI2RlZmluZSBSUkZfR09UX0xCQQkJMHgwMgorCitzdHJ1Y3QgZmRfcmVxdWVzdCB7CisJc3RydWN0IHNlX3Rhc2sJZmRfdGFzazsKKwkvKiBTQ1NJIENEQiBmcm9tIGlTQ1NJIENvbW1hbmQgUERVICovCisJdW5zaWduZWQgY2hhcglmZF9zY3NpX2NkYltUQ01fTUFYX0NPTU1BTkRfU0laRV07CisJLyogRklMRUlPIGRldmljZSAqLworCXN0cnVjdCBmZF9kZXYJKmZkX2RldjsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCisjZGVmaW5lIEZCREZfSEFTX1BBVEgJCTB4MDEKKyNkZWZpbmUgRkJERl9IQVNfU0laRQkJMHgwMgorI2RlZmluZSBGREJEX1VTRV9CVUZGRVJFRF9JTwkweDA0CisKK3N0cnVjdCBmZF9kZXYgeworCXUzMgkJZmJkX2ZsYWdzOworCXVuc2lnbmVkIGNoYXIJZmRfZGV2X25hbWVbRkRfTUFYX0RFVl9OQU1FXTsKKwkvKiBVbmlxdWUgUmFtZGlzayBEZXZpY2UgSUQgaW4gUmFtZGlzayBIQkEgKi8KKwl1MzIJCWZkX2Rldl9pZDsKKwkvKiBOdW1iZXIgb2YgU0cgdGFibGVzIGluIHNnX3RhYmxlX2FycmF5ICovCisJdTMyCQlmZF90YWJsZV9jb3VudDsKKwl1MzIJCWZkX3F1ZXVlX2RlcHRoOworCXUzMgkJZmRfYmxvY2tfc2l6ZTsKKwl1bnNpZ25lZCBsb25nIGxvbmcgZmRfZGV2X3NpemU7CisJc3RydWN0IGZpbGUJKmZkX2ZpbGU7CisJLyogRklMRUlPIEhCQSBkZXZpY2UgaXMgY29ubmVjdGVkIHRvICovCisJc3RydWN0IGZkX2hvc3QgKmZkX2hvc3Q7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworc3RydWN0IGZkX2hvc3QgeworCXUzMgkJZmRfaG9zdF9kZXZfaWRfY291bnQ7CisJLyogVW5pcXVlIEZJTEVJTyBIb3N0IElEICovCisJdTMyCQlmZF9ob3N0X2lkOworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKKyNlbmRpZiAvKiBUQVJHRVRfQ09SRV9GSUxFX0ggKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2hiYS5jIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfaGJhLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNGJiZTgyMAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2hiYS5jCkBAIC0wLDAgKzEsMTg1IEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogRmlsZW5hbWU6ICB0YXJnZXRfY29yZV9oYmEuYworICoKKyAqIFRoaXMgZmlsZSBjb3BudGFpbnMgdGhlIGlTQ1NJIEhCQSBUcmFuc3BvcnQgcmVsYXRlZCBmdW5jdGlvbnMuCisgKgorICogQ29weXJpZ2h0IChjKSAyMDAzLCAyMDA0LCAyMDA1IFB5WCBUZWNobm9sb2dpZXMsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNiwgMjAwNyBTQkUsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAwNy0yMDEwIFJpc2luZyBUaWRlIFN5c3RlbXMKKyAqIENvcHlyaWdodCAoYykgMjAwOC0yMDEwIExpbnV4LWlTQ1NJLm9yZworICoKKyAqIE5pY2hvbGFzIEEuIEJlbGxpbmdlciA8bmFiQGtlcm5lbC5vcmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisjaW5jbHVkZSA8bGludXgvbmV0Lmg+CisjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CisjaW5jbHVkZSA8bGludXgvdGltZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KKyNpbmNsdWRlIDxsaW51eC9zbXBfbG9jay5oPgorI2luY2x1ZGUgPGxpbnV4L2luLmg+CisjaW5jbHVkZSA8bmV0L3NvY2suaD4KKyNpbmNsdWRlIDxuZXQvdGNwLmg+CisKKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfYmFzZS5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfZGV2aWNlLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX3RwZy5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV90cmFuc3BvcnQuaD4KKworI2luY2x1ZGUgInRhcmdldF9jb3JlX2hiYS5oIgorCitzdGF0aWMgTElTVF9IRUFEKHN1YnN5c3RlbV9saXN0KTsKK3N0YXRpYyBERUZJTkVfTVVURVgoc3Vic3lzdGVtX211dGV4KTsKKworaW50IHRyYW5zcG9ydF9zdWJzeXN0ZW1fcmVnaXN0ZXIoc3RydWN0IHNlX3N1YnN5c3RlbV9hcGkgKnN1Yl9hcGkpCit7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9hcGkgKnM7CisKKwlJTklUX0xJU1RfSEVBRCgmc3ViX2FwaS0+c3ViX2FwaV9saXN0KTsKKworCW11dGV4X2xvY2soJnN1YnN5c3RlbV9tdXRleCk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShzLCAmc3Vic3lzdGVtX2xpc3QsIHN1Yl9hcGlfbGlzdCkgeworCQlpZiAoIShzdHJjbXAocy0+bmFtZSwgc3ViX2FwaS0+bmFtZSkpKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIiVwIGlzIGFscmVhZHkgcmVnaXN0ZXJlZCB3aXRoIgorCQkJCSIgZHVwbGljYXRlIG5hbWUgJXMsIHVuYWJsZSB0byBwcm9jZXNzIgorCQkJCSIgcmVxdWVzdFxuIiwgcywgcy0+bmFtZSk7CisJCQltdXRleF91bmxvY2soJnN1YnN5c3RlbV9tdXRleCk7CisJCQlyZXR1cm4gLUVFWElTVDsKKwkJfQorCX0KKwlsaXN0X2FkZF90YWlsKCZzdWJfYXBpLT5zdWJfYXBpX2xpc3QsICZzdWJzeXN0ZW1fbGlzdCk7CisJbXV0ZXhfdW5sb2NrKCZzdWJzeXN0ZW1fbXV0ZXgpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiVENNOiBSZWdpc3RlcmVkIHN1YnN5c3RlbSBwbHVnaW46ICVzIHN0cnVjdCBtb2R1bGU6IgorCQkJIiAlcFxuIiwgc3ViX2FwaS0+bmFtZSwgc3ViX2FwaS0+b3duZXIpOworCXJldHVybiAwOworfQorRVhQT1JUX1NZTUJPTCh0cmFuc3BvcnRfc3Vic3lzdGVtX3JlZ2lzdGVyKTsKKwordm9pZCB0cmFuc3BvcnRfc3Vic3lzdGVtX3JlbGVhc2Uoc3RydWN0IHNlX3N1YnN5c3RlbV9hcGkgKnN1Yl9hcGkpCit7CisJbXV0ZXhfbG9jaygmc3Vic3lzdGVtX211dGV4KTsKKwlsaXN0X2RlbCgmc3ViX2FwaS0+c3ViX2FwaV9saXN0KTsKKwltdXRleF91bmxvY2soJnN1YnN5c3RlbV9tdXRleCk7Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9zdWJzeXN0ZW1fcmVsZWFzZSk7CisKK3N0YXRpYyBzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2FwaSAqY29yZV9nZXRfYmFja2VuZChjb25zdCBjaGFyICpzdWJfbmFtZSkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2FwaSAqczsKKworCW11dGV4X2xvY2soJnN1YnN5c3RlbV9tdXRleCk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShzLCAmc3Vic3lzdGVtX2xpc3QsIHN1Yl9hcGlfbGlzdCkgeworCQlpZiAoIXN0cmNtcChzLT5uYW1lLCBzdWJfbmFtZSkpCisJCQlnb3RvIGZvdW5kOworCX0KKwltdXRleF91bmxvY2soJnN1YnN5c3RlbV9tdXRleCk7CisJcmV0dXJuIE5VTEw7Citmb3VuZDoKKwlpZiAocy0+b3duZXIgJiYgIXRyeV9tb2R1bGVfZ2V0KHMtPm93bmVyKSkKKwkJcyA9IE5VTEw7CisJbXV0ZXhfdW5sb2NrKCZzdWJzeXN0ZW1fbXV0ZXgpOworCXJldHVybiBzOworfQorCitzdHJ1Y3Qgc2VfaGJhICoKK2NvcmVfYWxsb2NfaGJhKGNvbnN0IGNoYXIgKnBsdWdpbl9uYW1lLCB1MzIgcGx1Z2luX2RlcF9pZCwgdTMyIGhiYV9mbGFncykKK3sKKwlzdHJ1Y3Qgc2VfaGJhICpoYmE7CisJaW50IHJldCA9IDA7CisKKwloYmEgPSBremFsbG9jKHNpemVvZigqaGJhKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFoYmEpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgc3RydWN0IHNlX2hiYVxuIik7CisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCX0KKworCUlOSVRfTElTVF9IRUFEKCZoYmEtPmhiYV9kZXZfbGlzdCk7CisJc3Bpbl9sb2NrX2luaXQoJmhiYS0+ZGV2aWNlX2xvY2spOworCXNwaW5fbG9ja19pbml0KCZoYmEtPmhiYV9xdWV1ZV9sb2NrKTsKKwltdXRleF9pbml0KCZoYmEtPmhiYV9hY2Nlc3NfbXV0ZXgpOworCisJaGJhLT5oYmFfaW5kZXggPSBzY3NpX2dldF9uZXdfaW5kZXgoU0NTSV9JTlNUX0lOREVYKTsKKwloYmEtPmhiYV9mbGFncyB8PSBoYmFfZmxhZ3M7CisKKwlhdG9taWNfc2V0KCZoYmEtPm1heF9xdWV1ZV9kZXB0aCwgMCk7CisJYXRvbWljX3NldCgmaGJhLT5sZWZ0X3F1ZXVlX2RlcHRoLCAwKTsKKworCWhiYS0+dHJhbnNwb3J0ID0gY29yZV9nZXRfYmFja2VuZChwbHVnaW5fbmFtZSk7CisJaWYgKCFoYmEtPnRyYW5zcG9ydCkgeworCQlyZXQgPSAtRUlOVkFMOworCQlnb3RvIG91dF9mcmVlX2hiYTsKKwl9CisKKwlyZXQgPSBoYmEtPnRyYW5zcG9ydC0+YXR0YWNoX2hiYShoYmEsIHBsdWdpbl9kZXBfaWQpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIG91dF9tb2R1bGVfcHV0OworCisJc3Bpbl9sb2NrKCZzZV9nbG9iYWwtPmhiYV9sb2NrKTsKKwloYmEtPmhiYV9pZCA9IHNlX2dsb2JhbC0+Z19oYmFfaWRfY291bnRlcisrOworCWxpc3RfYWRkX3RhaWwoJmhiYS0+aGJhX2xpc3QsICZzZV9nbG9iYWwtPmdfaGJhX2xpc3QpOworCXNwaW5fdW5sb2NrKCZzZV9nbG9iYWwtPmhiYV9sb2NrKTsKKworCXByaW50ayhLRVJOX0lORk8gIkNPUkVfSEJBWyVkXSAtIEF0dGFjaGVkIEhCQSB0byBHZW5lcmljIFRhcmdldCIKKwkJCSIgQ29yZVxuIiwgaGJhLT5oYmFfaWQpOworCisJcmV0dXJuIGhiYTsKKworb3V0X21vZHVsZV9wdXQ6CisJaWYgKGhiYS0+dHJhbnNwb3J0LT5vd25lcikKKwkJbW9kdWxlX3B1dChoYmEtPnRyYW5zcG9ydC0+b3duZXIpOworCWhiYS0+dHJhbnNwb3J0ID0gTlVMTDsKK291dF9mcmVlX2hiYToKKwlrZnJlZShoYmEpOworCXJldHVybiBFUlJfUFRSKHJldCk7Cit9CisKK2ludAorY29yZV9kZWxldGVfaGJhKHN0cnVjdCBzZV9oYmEgKmhiYSkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsICpkZXZfdG1wOworCisJc3Bpbl9sb2NrKCZoYmEtPmRldmljZV9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoZGV2LCBkZXZfdG1wLCAmaGJhLT5oYmFfZGV2X2xpc3QsIGRldl9saXN0KSB7CisKKwkJc2VfY2xlYXJfZGV2X3BvcnRzKGRldik7CisJCXNwaW5fdW5sb2NrKCZoYmEtPmRldmljZV9sb2NrKTsKKworCQlzZV9yZWxlYXNlX2RldmljZV9mb3JfaGJhKGRldik7CisKKwkJc3Bpbl9sb2NrKCZoYmEtPmRldmljZV9sb2NrKTsKKwl9CisJc3Bpbl91bmxvY2soJmhiYS0+ZGV2aWNlX2xvY2spOworCisJaGJhLT50cmFuc3BvcnQtPmRldGFjaF9oYmEoaGJhKTsKKworCXNwaW5fbG9jaygmc2VfZ2xvYmFsLT5oYmFfbG9jayk7CisJbGlzdF9kZWwoJmhiYS0+aGJhX2xpc3QpOworCXNwaW5fdW5sb2NrKCZzZV9nbG9iYWwtPmhiYV9sb2NrKTsKKworCXByaW50ayhLRVJOX0lORk8gIkNPUkVfSEJBWyVkXSAtIERldGFjaGVkIEhCQSBmcm9tIEdlbmVyaWMgVGFyZ2V0IgorCQkJIiBDb3JlXG4iLCBoYmEtPmhiYV9pZCk7CisKKwlpZiAoaGJhLT50cmFuc3BvcnQtPm93bmVyKQorCQltb2R1bGVfcHV0KGhiYS0+dHJhbnNwb3J0LT5vd25lcik7CisKKwloYmEtPnRyYW5zcG9ydCA9IE5VTEw7CisJa2ZyZWUoaGJhKTsKKwlyZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2hiYS5oIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfaGJhLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYmIwZmVhNQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2hiYS5oCkBAIC0wLDAgKzEsNyBAQAorI2lmbmRlZiBUQVJHRVRfQ09SRV9IQkFfSAorI2RlZmluZSBUQVJHRVRfQ09SRV9IQkFfSAorCitleHRlcm4gc3RydWN0IHNlX2hiYSAqY29yZV9hbGxvY19oYmEoY29uc3QgY2hhciAqLCB1MzIsIHUzMik7CitleHRlcm4gaW50IGNvcmVfZGVsZXRlX2hiYShzdHJ1Y3Qgc2VfaGJhICopOworCisjZW5kaWYgLyogVEFSR0VUX0NPUkVfSEJBX0ggKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2libG9jay5jIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfaWJsb2NrLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzZlMGQ3NQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2libG9jay5jCkBAIC0wLDAgKzEsODA4IEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogRmlsZW5hbWU6ICB0YXJnZXRfY29yZV9pYmxvY2suYworICoKKyAqIFRoaXMgZmlsZSBjb250YWlucyB0aGUgU3RvcmFnZSBFbmdpbmUgIDwtPiBMaW51eCBCbG9ja0lPIHRyYW5zcG9ydAorICogc3BlY2lmaWMgZnVuY3Rpb25zLgorICoKKyAqIENvcHlyaWdodCAoYykgMjAwMywgMjAwNCwgMjAwNSBQeVggVGVjaG5vbG9naWVzLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDYsIDIwMDcgU0JFLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMDctMjAxMCBSaXNpbmcgVGlkZSBTeXN0ZW1zCisgKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxMCBMaW51eC1pU0NTSS5vcmcKKyAqCisgKiBOaWNob2xhcyBBLiBCZWxsaW5nZXIgPG5hYkBrZXJuZWwub3JnPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworI2luY2x1ZGUgPGxpbnV4L3ZlcnNpb24uaD4KKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KKyNpbmNsdWRlIDxsaW51eC9wYXJzZXIuaD4KKyNpbmNsdWRlIDxsaW51eC90aW1lci5oPgorI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5jbHVkZSA8bGludXgvYmxrZGV2Lmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CisjaW5jbHVkZSA8bGludXgvc21wX2xvY2suaD4KKyNpbmNsdWRlIDxsaW51eC9iaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9nZW5oZC5oPgorI2luY2x1ZGUgPGxpbnV4L2ZpbGUuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2kuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2lfaG9zdC5oPgorCisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2Jhc2UuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfZGV2aWNlLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX3RyYW5zcG9ydC5oPgorCisjaW5jbHVkZSAidGFyZ2V0X2NvcmVfaWJsb2NrLmgiCisKKyNpZiAwCisjZGVmaW5lIERFQlVHX0lCTE9DSyh4Li4uKSBwcmludGsoeCkKKyNlbHNlCisjZGVmaW5lIERFQlVHX0lCTE9DSyh4Li4uKQorI2VuZGlmCisKK3N0YXRpYyBzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2FwaSBpYmxvY2tfdGVtcGxhdGU7CisKK3N0YXRpYyB2b2lkIGlibG9ja19iaW9fZG9uZShzdHJ1Y3QgYmlvICosIGludCk7CisKKy8qCWlibG9ja19hdHRhY2hfaGJhKCk6IChQYXJ0IG9mIHNlX3N1YnN5c3RlbV9hcGlfdCB0ZW1wbGF0ZSkKKyAqCisgKgorICovCitzdGF0aWMgaW50IGlibG9ja19hdHRhY2hfaGJhKHN0cnVjdCBzZV9oYmEgKmhiYSwgdTMyIGhvc3RfaWQpCit7CisJc3RydWN0IGlibG9ja19oYmEgKmliX2hvc3Q7CisKKwlpYl9ob3N0ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGlibG9ja19oYmEpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIShpYl9ob3N0KSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIgorCQkJCSIgc3RydWN0IGlibG9ja19oYmFcbiIpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwlpYl9ob3N0LT5pYmxvY2tfaG9zdF9pZCA9IGhvc3RfaWQ7CisKKwlhdG9taWNfc2V0KCZoYmEtPmxlZnRfcXVldWVfZGVwdGgsIElCTE9DS19IQkFfUVVFVUVfREVQVEgpOworCWF0b21pY19zZXQoJmhiYS0+bWF4X3F1ZXVlX2RlcHRoLCBJQkxPQ0tfSEJBX1FVRVVFX0RFUFRIKTsKKwloYmEtPmhiYV9wdHIgPSAodm9pZCAqKSBpYl9ob3N0OworCisJcHJpbnRrKEtFUk5fSU5GTyAiQ09SRV9IQkFbJWRdIC0gVENNIGlCbG9jayBIQkEgRHJpdmVyICVzIG9uIgorCQkiIEdlbmVyaWMgVGFyZ2V0IENvcmUgU3RhY2sgJXNcbiIsIGhiYS0+aGJhX2lkLAorCQlJQkxPQ0tfVkVSU0lPTiwgVEFSR0VUX0NPUkVfTU9EX1ZFUlNJT04pOworCisJcHJpbnRrKEtFUk5fSU5GTyAiQ09SRV9IQkFbJWRdIC0gQXR0YWNoZWQgaUJsb2NrIEhCQTogJXUgdG8gR2VuZXJpYyIKKwkJIiBUYXJnZXQgQ29yZSBUQ1EgRGVwdGg6ICVkXG4iLCBoYmEtPmhiYV9pZCwKKwkJaWJfaG9zdC0+aWJsb2NrX2hvc3RfaWQsIGF0b21pY19yZWFkKCZoYmEtPm1heF9xdWV1ZV9kZXB0aCkpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIGlibG9ja19kZXRhY2hfaGJhKHN0cnVjdCBzZV9oYmEgKmhiYSkKK3sKKwlzdHJ1Y3QgaWJsb2NrX2hiYSAqaWJfaG9zdCA9IGhiYS0+aGJhX3B0cjsKKworCXByaW50ayhLRVJOX0lORk8gIkNPUkVfSEJBWyVkXSAtIERldGFjaGVkIGlCbG9jayBIQkE6ICV1IGZyb20gR2VuZXJpYyIKKwkJIiBUYXJnZXQgQ29yZVxuIiwgaGJhLT5oYmFfaWQsIGliX2hvc3QtPmlibG9ja19ob3N0X2lkKTsKKworCWtmcmVlKGliX2hvc3QpOworCWhiYS0+aGJhX3B0ciA9IE5VTEw7Cit9CisKK3N0YXRpYyB2b2lkICppYmxvY2tfYWxsb2NhdGVfdmlydGRldmljZShzdHJ1Y3Qgc2VfaGJhICpoYmEsIGNvbnN0IGNoYXIgKm5hbWUpCit7CisJc3RydWN0IGlibG9ja19kZXYgKmliX2RldiA9IE5VTEw7CisJc3RydWN0IGlibG9ja19oYmEgKmliX2hvc3QgPSBoYmEtPmhiYV9wdHI7CisKKwlpYl9kZXYgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgaWJsb2NrX2RldiksIEdGUF9LRVJORUwpOworCWlmICghKGliX2RldikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgc3RydWN0IGlibG9ja19kZXZcbiIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJaWJfZGV2LT5pYmRfaG9zdCA9IGliX2hvc3Q7CisKKwlwcmludGsoS0VSTl9JTkZPICAiSUJMT0NLOiBBbGxvY2F0ZWQgaWJfZGV2IGZvciAlc1xuIiwgbmFtZSk7CisKKwlyZXR1cm4gaWJfZGV2OworfQorCitzdGF0aWMgc3RydWN0IHNlX2RldmljZSAqaWJsb2NrX2NyZWF0ZV92aXJ0ZGV2aWNlKAorCXN0cnVjdCBzZV9oYmEgKmhiYSwKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc2VfZGV2LAorCXZvaWQgKnApCit7CisJc3RydWN0IGlibG9ja19kZXYgKmliX2RldiA9IHA7CisJc3RydWN0IHNlX2RldmljZSAqZGV2OworCXN0cnVjdCBzZV9kZXZfbGltaXRzIGRldl9saW1pdHM7CisJc3RydWN0IGJsb2NrX2RldmljZSAqYmQgPSBOVUxMOworCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxOworCXN0cnVjdCBxdWV1ZV9saW1pdHMgKmxpbWl0czsKKwl1MzIgZGV2X2ZsYWdzID0gMDsKKworCWlmICghKGliX2RldikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gbG9jYXRlIHN0cnVjdCBpYmxvY2tfZGV2IHBhcmFtZXRlclxuIik7CisJCXJldHVybiAwOworCX0KKwltZW1zZXQoJmRldl9saW1pdHMsIDAsIHNpemVvZihzdHJ1Y3Qgc2VfZGV2X2xpbWl0cykpOworCS8qCisJICogVGhlc2Ugc2V0dGluZ3MgbmVlZCB0byBiZSBtYWRlIHR1bmFibGUuLgorCSAqLworCWliX2Rldi0+aWJkX2Jpb19zZXQgPSBiaW9zZXRfY3JlYXRlKDMyLCA2NCk7CisJaWYgKCEoaWJfZGV2LT5pYmRfYmlvX3NldCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJJQkxPQ0s6IFVuYWJsZSB0byBjcmVhdGUgYmlvc2V0KClcbiIpOworCQlyZXR1cm4gMDsKKwl9CisJcHJpbnRrKEtFUk5fSU5GTyAiSUJMT0NLOiBDcmVhdGVkIGJpb19zZXQoKVxuIik7CisJLyoKKwkgKiBpYmxvY2tfY2hlY2tfY29uZmlnZnNfZGV2X3BhcmFtcygpIGVuc3VyZXMgdGhhdCBpYl9kZXYtPmliZF91ZGV2X3BhdGgKKwkgKiBtdXN0IGFscmVhZHkgaGF2ZSBiZWVuIHNldCBpbiBvcmRlciBmb3IgZWNobyAxID4gJEhCQS8kREVWL2VuYWJsZSB0byBydW4uCisJICovCisJcHJpbnRrKEtFUk5fSU5GTyAgIklCTE9DSzogQ2xhaW1pbmcgc3RydWN0IGJsb2NrX2RldmljZTogJXNcbiIsCisJCQlpYl9kZXYtPmliZF91ZGV2X3BhdGgpOworCisJYmQgPSBibGtkZXZfZ2V0X2J5X3BhdGgoaWJfZGV2LT5pYmRfdWRldl9wYXRoLAorCQkJCUZNT0RFX1dSSVRFfEZNT0RFX1JFQUR8Rk1PREVfRVhDTCwgaWJfZGV2KTsKKwlpZiAoIShiZCkpCisJCWdvdG8gZmFpbGVkOworCS8qCisJICogU2V0dXAgdGhlIGxvY2FsIHNjb3BlIHF1ZXVlX2xpbWl0cyBmcm9tIHN0cnVjdCByZXF1ZXN0X3F1ZXVlLT5saW1pdHMKKwkgKiB0byBwYXNzIGludG8gdHJhbnNwb3J0X2FkZF9kZXZpY2VfdG9fY29yZV9oYmEoKSBhcyBzdHJ1Y3Qgc2VfZGV2X2xpbWl0cy4KKwkgKi8KKwlxID0gYmRldl9nZXRfcXVldWUoYmQpOworCWxpbWl0cyA9ICZkZXZfbGltaXRzLmxpbWl0czsKKwlsaW1pdHMtPmxvZ2ljYWxfYmxvY2tfc2l6ZSA9IGJkZXZfbG9naWNhbF9ibG9ja19zaXplKGJkKTsKKwlsaW1pdHMtPm1heF9od19zZWN0b3JzID0gcXVldWVfbWF4X2h3X3NlY3RvcnMocSk7CisJbGltaXRzLT5tYXhfc2VjdG9ycyA9IHF1ZXVlX21heF9zZWN0b3JzKHEpOworCWRldl9saW1pdHMuaHdfcXVldWVfZGVwdGggPSBJQkxPQ0tfTUFYX0RFVklDRV9RVUVVRV9ERVBUSDsKKwlkZXZfbGltaXRzLnF1ZXVlX2RlcHRoID0gSUJMT0NLX0RFVklDRV9RVUVVRV9ERVBUSDsKKworCWliX2Rldi0+aWJkX21ham9yID0gTUFKT1IoYmQtPmJkX2Rldik7CisJaWJfZGV2LT5pYmRfbWlub3IgPSBNSU5PUihiZC0+YmRfZGV2KTsKKwlpYl9kZXYtPmliZF9iZCA9IGJkOworCisJZGV2ID0gdHJhbnNwb3J0X2FkZF9kZXZpY2VfdG9fY29yZV9oYmEoaGJhLAorCQkJJmlibG9ja190ZW1wbGF0ZSwgc2VfZGV2LCBkZXZfZmxhZ3MsICh2b2lkICopaWJfZGV2LAorCQkJJmRldl9saW1pdHMsICJJQkxPQ0siLCBJQkxPQ0tfVkVSU0lPTik7CisJaWYgKCEoZGV2KSkKKwkJZ290byBmYWlsZWQ7CisKKwlpYl9kZXYtPmliZF9kZXB0aCA9IGRldi0+cXVldWVfZGVwdGg7CisKKwkvKgorCSAqIENoZWNrIGlmIHRoZSB1bmRlcmx5aW5nIHN0cnVjdCBibG9ja19kZXZpY2UgcmVxdWVzdF9xdWV1ZSBzdXBwb3J0cworCSAqIHRoZSBRVUVVRV9GTEFHX0RJU0NBUkQgYml0IGZvciBVTk1BUC9XUklURV9TQU1FIGluIFNDU0kgKyBUUklNCisJICogaW4gQVRBIGFuZCB3ZSBuZWVkIHRvIHNldCBUUEU9MQorCSAqLworCWlmIChibGtfcXVldWVfZGlzY2FyZChiZGV2X2dldF9xdWV1ZShiZCkpKSB7CisJCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVldWUoYmQpOworCisJCURFVl9BVFRSSUIoZGV2KS0+bWF4X3VubWFwX2xiYV9jb3VudCA9CisJCQkJcS0+bGltaXRzLm1heF9kaXNjYXJkX3NlY3RvcnM7CisJCS8qCisJCSAqIEN1cnJlbnRseSBoYXJkY29kZWQgdG8gMSBpbiBMaW51eC9TQ1NJIGNvZGUuLgorCQkgKi8KKwkJREVWX0FUVFJJQihkZXYpLT5tYXhfdW5tYXBfYmxvY2tfZGVzY19jb3VudCA9IDE7CisJCURFVl9BVFRSSUIoZGV2KS0+dW5tYXBfZ3JhbnVsYXJpdHkgPQorCQkJCXEtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5OworCQlERVZfQVRUUklCKGRldiktPnVubWFwX2dyYW51bGFyaXR5X2FsaWdubWVudCA9CisJCQkJcS0+bGltaXRzLmRpc2NhcmRfYWxpZ25tZW50OworCisJCXByaW50ayhLRVJOX0lORk8gIklCTE9DSzogQkxPQ0sgRGlzY2FyZCBzdXBwb3J0IGF2YWlsYWJsZSwiCisJCQkJIiBkaXNhYmxlZCBieSBkZWZhdWx0XG4iKTsKKwl9CisKKwlyZXR1cm4gZGV2OworCitmYWlsZWQ6CisJaWYgKGliX2Rldi0+aWJkX2Jpb19zZXQpIHsKKwkJYmlvc2V0X2ZyZWUoaWJfZGV2LT5pYmRfYmlvX3NldCk7CisJCWliX2Rldi0+aWJkX2Jpb19zZXQgPSBOVUxMOworCX0KKwlpYl9kZXYtPmliZF9iZCA9IE5VTEw7CisJaWJfZGV2LT5pYmRfbWFqb3IgPSAwOworCWliX2Rldi0+aWJkX21pbm9yID0gMDsKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIHZvaWQgaWJsb2NrX2ZyZWVfZGV2aWNlKHZvaWQgKnApCit7CisJc3RydWN0IGlibG9ja19kZXYgKmliX2RldiA9IHA7CisKKwlibGtkZXZfcHV0KGliX2Rldi0+aWJkX2JkLCBGTU9ERV9XUklURXxGTU9ERV9SRUFEfEZNT0RFX0VYQ0wpOworCWJpb3NldF9mcmVlKGliX2Rldi0+aWJkX2Jpb19zZXQpOworCWtmcmVlKGliX2Rldik7Cit9CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IGlibG9ja19yZXEgKklCTE9DS19SRVEoc3RydWN0IHNlX3Rhc2sgKnRhc2spCit7CisJcmV0dXJuIGNvbnRhaW5lcl9vZih0YXNrLCBzdHJ1Y3QgaWJsb2NrX3JlcSwgaWJfdGFzayk7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc2VfdGFzayAqCitpYmxvY2tfYWxsb2NfdGFzayhzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IGlibG9ja19yZXEgKmliX3JlcTsKKworCWliX3JlcSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBpYmxvY2tfcmVxKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCEoaWJfcmVxKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIHN0cnVjdCBpYmxvY2tfcmVxXG4iKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJaWJfcmVxLT5pYl9kZXYgPSBTRV9ERVYoY21kKS0+ZGV2X3B0cjsKKwlhdG9taWNfc2V0KCZpYl9yZXEtPmliX2Jpb19jbnQsIDApOworCXJldHVybiAmaWJfcmVxLT5pYl90YXNrOworfQorCitzdGF0aWMgdW5zaWduZWQgbG9uZyBsb25nIGlibG9ja19lbXVsYXRlX3JlYWRfY2FwX3dpdGhfYmxvY2tfc2l6ZSgKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsCisJc3RydWN0IGJsb2NrX2RldmljZSAqYmQsCisJc3RydWN0IHJlcXVlc3RfcXVldWUgKnEpCit7CisJdW5zaWduZWQgbG9uZyBsb25nIGJsb2Nrc19sb25nID0gKGRpdl91NjQoaV9zaXplX3JlYWQoYmQtPmJkX2lub2RlKSwKKwkJCQkJYmRldl9sb2dpY2FsX2Jsb2NrX3NpemUoYmQpKSAtIDEpOworCXUzMiBibG9ja19zaXplID0gYmRldl9sb2dpY2FsX2Jsb2NrX3NpemUoYmQpOworCisJaWYgKGJsb2NrX3NpemUgPT0gREVWX0FUVFJJQihkZXYpLT5ibG9ja19zaXplKQorCQlyZXR1cm4gYmxvY2tzX2xvbmc7CisKKwlzd2l0Y2ggKGJsb2NrX3NpemUpIHsKKwljYXNlIDQwOTY6CisJCXN3aXRjaCAoREVWX0FUVFJJQihkZXYpLT5ibG9ja19zaXplKSB7CisJCWNhc2UgMjA0ODoKKwkJCWJsb2Nrc19sb25nIDw8PSAxOworCQkJYnJlYWs7CisJCWNhc2UgMTAyNDoKKwkJCWJsb2Nrc19sb25nIDw8PSAyOworCQkJYnJlYWs7CisJCWNhc2UgNTEyOgorCQkJYmxvY2tzX2xvbmcgPDw9IDM7CisJCWRlZmF1bHQ6CisJCQlicmVhazsKKwkJfQorCQlicmVhazsKKwljYXNlIDIwNDg6CisJCXN3aXRjaCAoREVWX0FUVFJJQihkZXYpLT5ibG9ja19zaXplKSB7CisJCWNhc2UgNDA5NjoKKwkJCWJsb2Nrc19sb25nID4+PSAxOworCQkJYnJlYWs7CisJCWNhc2UgMTAyNDoKKwkJCWJsb2Nrc19sb25nIDw8PSAxOworCQkJYnJlYWs7CisJCWNhc2UgNTEyOgorCQkJYmxvY2tzX2xvbmcgPDw9IDI7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCWJyZWFrOworCQl9CisJCWJyZWFrOworCWNhc2UgMTAyNDoKKwkJc3dpdGNoIChERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUpIHsKKwkJY2FzZSA0MDk2OgorCQkJYmxvY2tzX2xvbmcgPj49IDI7CisJCQlicmVhazsKKwkJY2FzZSAyMDQ4OgorCQkJYmxvY2tzX2xvbmcgPj49IDE7CisJCQlicmVhazsKKwkJY2FzZSA1MTI6CisJCQlibG9ja3NfbG9uZyA8PD0gMTsKKwkJCWJyZWFrOworCQlkZWZhdWx0OgorCQkJYnJlYWs7CisJCX0KKwkJYnJlYWs7CisJY2FzZSA1MTI6CisJCXN3aXRjaCAoREVWX0FUVFJJQihkZXYpLT5ibG9ja19zaXplKSB7CisJCWNhc2UgNDA5NjoKKwkJCWJsb2Nrc19sb25nID4+PSAzOworCQkJYnJlYWs7CisJCWNhc2UgMjA0ODoKKwkJCWJsb2Nrc19sb25nID4+PSAyOworCQkJYnJlYWs7CisJCWNhc2UgMTAyNDoKKwkJCWJsb2Nrc19sb25nID4+PSAxOworCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisJCQlicmVhazsKKwkJfQorCQlicmVhazsKKwlkZWZhdWx0OgorCQlicmVhazsKKwl9CisKKwlyZXR1cm4gYmxvY2tzX2xvbmc7Cit9CisKKy8qCisgKiBFbXVsYXRlIFNZQ0hST05JWkVfQ0FDSEVfKgorICovCitzdGF0aWMgdm9pZCBpYmxvY2tfZW11bGF0ZV9zeW5jX2NhY2hlKHN0cnVjdCBzZV90YXNrICp0YXNrKQoreworCXN0cnVjdCBzZV9jbWQgKmNtZCA9IFRBU0tfQ01EKHRhc2spOworCXN0cnVjdCBpYmxvY2tfZGV2ICppYl9kZXYgPSBjbWQtPnNlX2Rldi0+ZGV2X3B0cjsKKwlpbnQgaW1tZWQgPSAoVF9UQVNLKGNtZCktPnRfdGFza19jZGJbMV0gJiAweDIpOworCXNlY3Rvcl90IGVycm9yX3NlY3RvcjsKKwlpbnQgcmV0OworCisJLyoKKwkgKiBJZiB0aGUgSW1tZWRpYXRlIGJpdCBpcyBzZXQsIHF1ZXVlIHVwIHRoZSBHT09EIHJlc3BvbnNlCisJICogZm9yIHRoaXMgU1lOQ0hST05JWkVfQ0FDSEUgb3AKKwkgKi8KKwlpZiAoaW1tZWQpCisJCXRyYW5zcG9ydF9jb21wbGV0ZV9zeW5jX2NhY2hlKGNtZCwgMSk7CisKKwkvKgorCSAqIGJsa2Rldl9pc3N1ZV9mbHVzaCgpIGRvZXMgbm90IHN1cHBvcnQgYSBzcGVjaWZ5aW5nIGEgcmFuZ2UsIHNvCisJICogd2UgaGF2ZSB0byBmbHVzaCB0aGUgZW50aXJlIGNhY2hlLgorCSAqLworCXJldCA9IGJsa2Rldl9pc3N1ZV9mbHVzaChpYl9kZXYtPmliZF9iZCwgR0ZQX0tFUk5FTCwgJmVycm9yX3NlY3Rvcik7CisJaWYgKHJldCAhPSAwKSB7CisJCXByaW50ayhLRVJOX0VSUiAiSUJMT0NLOiBibG9ja19pc3N1ZV9mbHVzaCgpIGZhaWxlZDogJWQgIgorCQkJIiBlcnJvcl9zZWN0b3I6ICVsbHVcbiIsIHJldCwKKwkJCSh1bnNpZ25lZCBsb25nIGxvbmcpZXJyb3Jfc2VjdG9yKTsKKwl9CisKKwlpZiAoIWltbWVkKQorCQl0cmFuc3BvcnRfY29tcGxldGVfc3luY19jYWNoZShjbWQsIHJldCA9PSAwKTsKK30KKworLyoKKyAqIFRlbGwgVENNIENvcmUgdGhhdCB3ZSBhcmUgY2FwYWJsZSBvZiBXcml0ZUNhY2hlIGVtdWxhdGlvbiBmb3IKKyAqIGFuIHVuZGVybHlpbmcgc3RydWN0IHNlX2RldmljZS4KKyAqLworc3RhdGljIGludCBpYmxvY2tfZW11bGF0ZWRfd3JpdGVfY2FjaGUoc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXJldHVybiAxOworfQorCitzdGF0aWMgaW50IGlibG9ja19lbXVsYXRlZF9kcG8oc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXJldHVybiAwOworfQorCisvKgorICogVGVsbCBUQ00gQ29yZSB0aGF0IHdlIHdpbGwgYmUgZW11bGF0aW5nIEZvcmNlZCBVbml0IEFjY2VzcyAoRlVBKSBmb3IgV1JJVEVzCisgKiBmb3IgVFlQRV9ESVNLLgorICovCitzdGF0aWMgaW50IGlibG9ja19lbXVsYXRlZF9mdWFfd3JpdGUoc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXJldHVybiAxOworfQorCitzdGF0aWMgaW50IGlibG9ja19lbXVsYXRlZF9mdWFfcmVhZChzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpCit7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgaWJsb2NrX2RvX3Rhc2soc3RydWN0IHNlX3Rhc2sgKnRhc2spCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gdGFzay0+dGFza19zZV9jbWQtPnNlX2RldjsKKwlzdHJ1Y3QgaWJsb2NrX3JlcSAqcmVxID0gSUJMT0NLX1JFUSh0YXNrKTsKKwlzdHJ1Y3QgaWJsb2NrX2RldiAqaWJkID0gKHN0cnVjdCBpYmxvY2tfZGV2ICopcmVxLT5pYl9kZXY7CisJc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShpYmQtPmliZF9iZCk7CisJc3RydWN0IGJpbyAqYmlvID0gcmVxLT5pYl9iaW8sICpuYmlvID0gTlVMTDsKKwlpbnQgcnc7CisKKwlpZiAodGFzay0+dGFza19kYXRhX2RpcmVjdGlvbiA9PSBETUFfVE9fREVWSUNFKSB7CisJCS8qCisJCSAqIEZvcmNlIGRhdGEgdG8gZGlzayBpZiB3ZSBwcmV0ZW5kIHRvIG5vdCBoYXZlIGEgdm9sYXRpbGUKKwkJICogd3JpdGUgY2FjaGUsIG9yIHRoZSBpbml0aWF0b3Igc2V0IHRoZSBGb3JjZSBVbml0IEFjY2VzcyBiaXQuCisJCSAqLworCQlpZiAoREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3dyaXRlX2NhY2hlID09IDAgfHwKKwkJICAgIChERVZfQVRUUklCKGRldiktPmVtdWxhdGVfZnVhX3dyaXRlID4gMCAmJgorCQkgICAgIFRfVEFTSyh0YXNrLT50YXNrX3NlX2NtZCktPnRfdGFza3NfZnVhKSkKKwkJCXJ3ID0gV1JJVEVfRlVBOworCQllbHNlCisJCQlydyA9IFdSSVRFOworCX0gZWxzZSB7CisJCXJ3ID0gUkVBRDsKKwl9CisKKwl3aGlsZSAoYmlvKSB7CisJCW5iaW8gPSBiaW8tPmJpX25leHQ7CisJCWJpby0+YmlfbmV4dCA9IE5VTEw7CisJCURFQlVHX0lCTE9DSygiQ2FsbGluZyBzdWJtaXRfYmlvKCkgdGFzazogJXAgYmlvOiAlcCIKKwkJCSIgYmlvLT5iaV9zZWN0b3I6ICVsbHVcbiIsIHRhc2ssIGJpbywgYmlvLT5iaV9zZWN0b3IpOworCisJCXN1Ym1pdF9iaW8ocncsIGJpbyk7CisJCWJpbyA9IG5iaW87CisJfQorCisJaWYgKHEtPnVucGx1Z19mbikKKwkJcS0+dW5wbHVnX2ZuKHEpOworCXJldHVybiBQWVhfVFJBTlNQT1JUX1NFTlRfVE9fVFJBTlNQT1JUOworfQorCitzdGF0aWMgaW50IGlibG9ja19kb19kaXNjYXJkKHN0cnVjdCBzZV9kZXZpY2UgKmRldiwgc2VjdG9yX3QgbGJhLCB1MzIgcmFuZ2UpCit7CisJc3RydWN0IGlibG9ja19kZXYgKmliZCA9IGRldi0+ZGV2X3B0cjsKKwlzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZCA9IGliZC0+aWJkX2JkOworCWludCBiYXJyaWVyID0gMDsKKworCXJldHVybiBibGtkZXZfaXNzdWVfZGlzY2FyZChiZCwgbGJhLCByYW5nZSwgR0ZQX0tFUk5FTCwgYmFycmllcik7Cit9CisKK3N0YXRpYyB2b2lkIGlibG9ja19mcmVlX3Rhc2soc3RydWN0IHNlX3Rhc2sgKnRhc2spCit7CisJc3RydWN0IGlibG9ja19yZXEgKnJlcSA9IElCTE9DS19SRVEodGFzayk7CisJc3RydWN0IGJpbyAqYmlvLCAqaGJpbyA9IHJlcS0+aWJfYmlvOworCS8qCisJICogV2Ugb25seSByZWxlYXNlIHRoZSBiaW8ocykgaGVyZSBpZiBpYmxvY2tfYmlvX2RvbmUoKSBoYXMgbm90IGNhbGxlZAorCSAqIGJpb19wdXQoKSAtPiBpYmxvY2tfYmlvX2Rlc3RydWN0b3IoKS4KKwkgKi8KKwl3aGlsZSAoaGJpbyAhPSBOVUxMKSB7CisJCWJpbyA9IGhiaW87CisJCWhiaW8gPSBoYmlvLT5iaV9uZXh0OworCQliaW8tPmJpX25leHQgPSBOVUxMOworCQliaW9fcHV0KGJpbyk7CisJfQorCisJa2ZyZWUocmVxKTsKK30KKworZW51bSB7CisJT3B0X3VkZXZfcGF0aCwgT3B0X2ZvcmNlLCBPcHRfZXJyCit9OworCitzdGF0aWMgbWF0Y2hfdGFibGVfdCB0b2tlbnMgPSB7CisJe09wdF91ZGV2X3BhdGgsICJ1ZGV2X3BhdGg9JXMifSwKKwl7T3B0X2ZvcmNlLCAiZm9yY2U9JWQifSwKKwl7T3B0X2VyciwgTlVMTH0KK307CisKK3N0YXRpYyBzc2l6ZV90IGlibG9ja19zZXRfY29uZmlnZnNfZGV2X3BhcmFtcyhzdHJ1Y3Qgc2VfaGJhICpoYmEsCisJCQkJCSAgICAgICBzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc2VfZGV2LAorCQkJCQkgICAgICAgY29uc3QgY2hhciAqcGFnZSwgc3NpemVfdCBjb3VudCkKK3sKKwlzdHJ1Y3QgaWJsb2NrX2RldiAqaWJfZGV2ID0gc2VfZGV2LT5zZV9kZXZfc3VfcHRyOworCWNoYXIgKm9yaWcsICpwdHIsICpvcHRzOworCXN1YnN0cmluZ190IGFyZ3NbTUFYX09QVF9BUkdTXTsKKwlpbnQgcmV0ID0gMCwgYXJnLCB0b2tlbjsKKworCW9wdHMgPSBrc3RyZHVwKHBhZ2UsIEdGUF9LRVJORUwpOworCWlmICghb3B0cykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlvcmlnID0gb3B0czsKKworCXdoaWxlICgocHRyID0gc3Ryc2VwKCZvcHRzLCAiLCIpKSAhPSBOVUxMKSB7CisJCWlmICghKnB0cikKKwkJCWNvbnRpbnVlOworCisJCXRva2VuID0gbWF0Y2hfdG9rZW4ocHRyLCB0b2tlbnMsIGFyZ3MpOworCQlzd2l0Y2ggKHRva2VuKSB7CisJCWNhc2UgT3B0X3VkZXZfcGF0aDoKKwkJCWlmIChpYl9kZXYtPmliZF9iZCkgeworCQkJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIHNldCB1ZGV2X3BhdGg9IHdoaWxlIgorCQkJCQkiIGliX2Rldi0+aWJkX2JkIGV4aXN0c1xuIik7CisJCQkJcmV0ID0gLUVFWElTVDsKKwkJCQlnb3RvIG91dDsKKwkJCX0KKworCQkJcmV0ID0gc25wcmludGYoaWJfZGV2LT5pYmRfdWRldl9wYXRoLCBTRV9VREVWX1BBVEhfTEVOLAorCQkJCSIlcyIsIG1hdGNoX3N0cmR1cCgmYXJnc1swXSkpOworCQkJcHJpbnRrKEtFUk5fSU5GTyAiSUJMT0NLOiBSZWZlcmVuY2luZyBVREVWIHBhdGg6ICVzXG4iLAorCQkJCQlpYl9kZXYtPmliZF91ZGV2X3BhdGgpOworCQkJaWJfZGV2LT5pYmRfZmxhZ3MgfD0gSUJERl9IQVNfVURFVl9QQVRIOworCQkJYnJlYWs7CisJCWNhc2UgT3B0X2ZvcmNlOgorCQkJbWF0Y2hfaW50KGFyZ3MsICZhcmcpOworCQkJaWJfZGV2LT5pYmRfZm9yY2UgPSBhcmc7CisJCQlwcmludGsoS0VSTl9JTkZPICJJQkxPQ0s6IFNldCBmb3JjZT0lZFxuIiwKKwkJCQlpYl9kZXYtPmliZF9mb3JjZSk7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCWJyZWFrOworCQl9CisJfQorCitvdXQ6CisJa2ZyZWUob3JpZyk7CisJcmV0dXJuICghcmV0KSA/IGNvdW50IDogcmV0OworfQorCitzdGF0aWMgc3NpemVfdCBpYmxvY2tfY2hlY2tfY29uZmlnZnNfZGV2X3BhcmFtcygKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEsCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldikKK3sKKwlzdHJ1Y3QgaWJsb2NrX2RldiAqaWJkID0gc2VfZGV2LT5zZV9kZXZfc3VfcHRyOworCisJaWYgKCEoaWJkLT5pYmRfZmxhZ3MgJiBJQkRGX0hBU19VREVWX1BBVEgpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTWlzc2luZyB1ZGV2X3BhdGg9IHBhcmFtZXRlcnMgZm9yIElCTE9DS1xuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHNzaXplX3QgaWJsb2NrX3Nob3dfY29uZmlnZnNfZGV2X3BhcmFtcygKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEsCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiwKKwljaGFyICpiKQoreworCXN0cnVjdCBpYmxvY2tfZGV2ICppYmQgPSBzZV9kZXYtPnNlX2Rldl9zdV9wdHI7CisJc3RydWN0IGJsb2NrX2RldmljZSAqYmQgPSBpYmQtPmliZF9iZDsKKwljaGFyIGJ1ZltCREVWTkFNRV9TSVpFXTsKKwlzc2l6ZV90IGJsID0gMDsKKworCWlmIChiZCkKKwkJYmwgKz0gc3ByaW50ZihiICsgYmwsICJpQmxvY2sgZGV2aWNlOiAlcyIsCisJCQkJYmRldm5hbWUoYmQsIGJ1ZikpOworCWlmIChpYmQtPmliZF9mbGFncyAmIElCREZfSEFTX1VERVZfUEFUSCkgeworCQlibCArPSBzcHJpbnRmKGIgKyBibCwgIiAgVURFViBQQVRIOiAlc1xuIiwKKwkJCQlpYmQtPmliZF91ZGV2X3BhdGgpOworCX0gZWxzZQorCQlibCArPSBzcHJpbnRmKGIgKyBibCwgIlxuIik7CisKKwlibCArPSBzcHJpbnRmKGIgKyBibCwgIiAgICAgICAgIik7CisJaWYgKGJkKSB7CisJCWJsICs9IHNwcmludGYoYiArIGJsLCAiTWFqb3I6ICVkIE1pbm9yOiAlZCAgJXNcbiIsCisJCQlpYmQtPmliZF9tYWpvciwgaWJkLT5pYmRfbWlub3IsICghYmQtPmJkX2NvbnRhaW5zKSA/CisJCQkiIiA6IChiZC0+YmRfaG9sZGVyID09IChzdHJ1Y3QgaWJsb2NrX2RldiAqKWliZCkgPworCQkJIkNMQUlNRUQ6IElCTE9DSyIgOiAiQ0xBSU1FRDogT1MiKTsKKwl9IGVsc2UgeworCQlibCArPSBzcHJpbnRmKGIgKyBibCwgIk1ham9yOiAlZCBNaW5vcjogJWRcbiIsCisJCQlpYmQtPmliZF9tYWpvciwgaWJkLT5pYmRfbWlub3IpOworCX0KKworCXJldHVybiBibDsKK30KKworc3RhdGljIHZvaWQgaWJsb2NrX2Jpb19kZXN0cnVjdG9yKHN0cnVjdCBiaW8gKmJpbykKK3sKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzayA9IGJpby0+YmlfcHJpdmF0ZTsKKwlzdHJ1Y3QgaWJsb2NrX2RldiAqaWJfZGV2ID0gdGFzay0+c2VfZGV2LT5kZXZfcHRyOworCisJYmlvX2ZyZWUoYmlvLCBpYl9kZXYtPmliZF9iaW9fc2V0KTsKK30KKworc3RhdGljIHN0cnVjdCBiaW8gKmlibG9ja19nZXRfYmlvKAorCXN0cnVjdCBzZV90YXNrICp0YXNrLAorCXN0cnVjdCBpYmxvY2tfcmVxICppYl9yZXEsCisJc3RydWN0IGlibG9ja19kZXYgKmliX2RldiwKKwlpbnQgKnJldCwKKwlzZWN0b3JfdCBsYmEsCisJdTMyIHNnX251bSkKK3sKKwlzdHJ1Y3QgYmlvICpiaW87CisKKwliaW8gPSBiaW9fYWxsb2NfYmlvc2V0KEdGUF9OT0lPLCBzZ19udW0sIGliX2Rldi0+aWJkX2Jpb19zZXQpOworCWlmICghKGJpbykpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgbWVtb3J5IGZvciBiaW9cbiIpOworCQkqcmV0ID0gUFlYX1RSQU5TUE9SVF9PVVRfT0ZfTUVNT1JZX1JFU09VUkNFUzsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJREVCVUdfSUJMT0NLKCJBbGxvY2F0ZWQgYmlvOiAlcCB0YXNrX3NnX251bTogJXUgdXNpbmcgaWJkX2Jpb19zZXQ6IgorCQkiICVwXG4iLCBiaW8sIHRhc2stPnRhc2tfc2dfbnVtLCBpYl9kZXYtPmliZF9iaW9fc2V0KTsKKwlERUJVR19JQkxPQ0soIkFsbG9jYXRlZCBiaW86ICVwIHRhc2tfc2l6ZTogJXVcbiIsIGJpbywgdGFzay0+dGFza19zaXplKTsKKworCWJpby0+YmlfYmRldiA9IGliX2Rldi0+aWJkX2JkOworCWJpby0+YmlfcHJpdmF0ZSA9ICh2b2lkICopIHRhc2s7CisJYmlvLT5iaV9kZXN0cnVjdG9yID0gaWJsb2NrX2Jpb19kZXN0cnVjdG9yOworCWJpby0+YmlfZW5kX2lvID0gJmlibG9ja19iaW9fZG9uZTsKKwliaW8tPmJpX3NlY3RvciA9IGxiYTsKKwlhdG9taWNfaW5jKCZpYl9yZXEtPmliX2Jpb19jbnQpOworCisJREVCVUdfSUJMT0NLKCJTZXQgYmlvLT5iaV9zZWN0b3I6ICVsbHVcbiIsIGJpby0+Ymlfc2VjdG9yKTsKKwlERUJVR19JQkxPQ0soIlNldCBpYl9yZXEtPmliX2Jpb19jbnQ6ICVkXG4iLAorCQkJYXRvbWljX3JlYWQoJmliX3JlcS0+aWJfYmlvX2NudCkpOworCXJldHVybiBiaW87Cit9CisKK3N0YXRpYyBpbnQgaWJsb2NrX21hcF90YXNrX1NHKHN0cnVjdCBzZV90YXNrICp0YXNrKQoreworCXN0cnVjdCBzZV9jbWQgKmNtZCA9IHRhc2stPnRhc2tfc2VfY21kOworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IFNFX0RFVihjbWQpOworCXN0cnVjdCBpYmxvY2tfZGV2ICppYl9kZXYgPSB0YXNrLT5zZV9kZXYtPmRldl9wdHI7CisJc3RydWN0IGlibG9ja19yZXEgKmliX3JlcSA9IElCTE9DS19SRVEodGFzayk7CisJc3RydWN0IGJpbyAqYmlvID0gTlVMTCwgKmhiaW8gPSBOVUxMLCAqdGJpbyA9IE5VTEw7CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZzsKKwlpbnQgcmV0ID0gMDsKKwl1MzIgaSwgc2dfbnVtID0gdGFzay0+dGFza19zZ19udW07CisJc2VjdG9yX3QgYmxvY2tfbGJhOworCS8qCisJICogRG8gc3RhcnRpbmcgY29udmVyc2lvbiB1cCBmcm9tIG5vbiA1MTItYnl0ZSBibG9ja3NpemUgd2l0aAorCSAqIHN0cnVjdCBzZV90YXNrIFNDU0kgYmxvY2tzaXplIGludG8gTGludXgvQmxvY2sgNTEyIHVuaXRzIGZvciBCSU8uCisJICovCisJaWYgKERFVl9BVFRSSUIoZGV2KS0+YmxvY2tfc2l6ZSA9PSA0MDk2KQorCQlibG9ja19sYmEgPSAodGFzay0+dGFza19sYmEgPDwgMyk7CisJZWxzZSBpZiAoREVWX0FUVFJJQihkZXYpLT5ibG9ja19zaXplID09IDIwNDgpCisJCWJsb2NrX2xiYSA9ICh0YXNrLT50YXNrX2xiYSA8PCAyKTsKKwllbHNlIGlmIChERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUgPT0gMTAyNCkKKwkJYmxvY2tfbGJhID0gKHRhc2stPnRhc2tfbGJhIDw8IDEpOworCWVsc2UgaWYgKERFVl9BVFRSSUIoZGV2KS0+YmxvY2tfc2l6ZSA9PSA1MTIpCisJCWJsb2NrX2xiYSA9IHRhc2stPnRhc2tfbGJhOworCWVsc2UgeworCQlwcmludGsoS0VSTl9FUlIgIlVuc3VwcG9ydGVkIFNDU0kgLT4gQkxPQ0sgTEJBIGNvbnZlcnNpb246IgorCQkJCSIgJXVcbiIsIERFVl9BVFRSSUIoZGV2KS0+YmxvY2tfc2l6ZSk7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwl9CisKKwliaW8gPSBpYmxvY2tfZ2V0X2Jpbyh0YXNrLCBpYl9yZXEsIGliX2RldiwgJnJldCwgYmxvY2tfbGJhLCBzZ19udW0pOworCWlmICghKGJpbykpCisJCXJldHVybiByZXQ7CisKKwlpYl9yZXEtPmliX2JpbyA9IGJpbzsKKwloYmlvID0gdGJpbyA9IGJpbzsKKwkvKgorCSAqIFVzZSBmcy9iaW8uYzpiaW9fYWRkX3BhZ2VzKCkgdG8gc2V0dXAgdGhlIGJpb192ZWMgbWFwbGlzdAorCSAqIGZyb20gVENNIHN0cnVjdCBzZV9tZW0gLT4gdGFzay0+dGFza19zZyAtPiBzdHJ1Y3Qgc2NhdHRlcmxpc3QgbWVtb3J5LgorCSAqLworCWZvcl9lYWNoX3NnKHRhc2stPnRhc2tfc2csIHNnLCB0YXNrLT50YXNrX3NnX251bSwgaSkgeworCQlERUJVR19JQkxPQ0soInRhc2s6ICVwIGJpbzogJXAgQ2FsbGluZyBiaW9fYWRkX3BhZ2UoKTogcGFnZToiCisJCQkiICVwIGxlbjogJXUgb2Zmc2V0OiAldVxuIiwgdGFzaywgYmlvLCBzZ19wYWdlKHNnKSwKKwkJCQlzZy0+bGVuZ3RoLCBzZy0+b2Zmc2V0KTsKK2FnYWluOgorCQlyZXQgPSBiaW9fYWRkX3BhZ2UoYmlvLCBzZ19wYWdlKHNnKSwgc2ctPmxlbmd0aCwgc2ctPm9mZnNldCk7CisJCWlmIChyZXQgIT0gc2ctPmxlbmd0aCkgeworCisJCQlERUJVR19JQkxPQ0soIioqKiBTZXQgYmlvLT5iaV9zZWN0b3I6ICVsbHVcbiIsCisJCQkJCWJpby0+Ymlfc2VjdG9yKTsKKwkJCURFQlVHX0lCTE9DSygiKiogdGFzay0+dGFza19zaXplOiAldVxuIiwKKwkJCQkJdGFzay0+dGFza19zaXplKTsKKwkJCURFQlVHX0lCTE9DSygiKioqIGJpby0+YmlfbWF4X3ZlY3M6ICV1XG4iLAorCQkJCQliaW8tPmJpX21heF92ZWNzKTsKKwkJCURFQlVHX0lCTE9DSygiKioqIGJpby0+YmlfdmNudDogJXVcbiIsCisJCQkJCWJpby0+YmlfdmNudCk7CisKKwkJCWJpbyA9IGlibG9ja19nZXRfYmlvKHRhc2ssIGliX3JlcSwgaWJfZGV2LCAmcmV0LAorCQkJCQkJYmxvY2tfbGJhLCBzZ19udW0pOworCQkJaWYgKCEoYmlvKSkKKwkJCQlnb3RvIGZhaWw7CisKKwkJCXRiaW8gPSB0YmlvLT5iaV9uZXh0ID0gYmlvOworCQkJREVCVUdfSUJMT0NLKCItLS0tLS0tLS0tLS0tLS0tLT4gQWRkZWQgKzEgYmlvOiAlcCB0byIKKwkJCQkiIGxpc3QsIEdvaW5nIHRvIGFnYWluXG4iLCBiaW8pOworCQkJZ290byBhZ2FpbjsKKwkJfQorCQkvKiBBbHdheXMgaW4gNTEyIGJ5dGUgdW5pdHMgZm9yIExpbnV4L0Jsb2NrICovCisJCWJsb2NrX2xiYSArPSBzZy0+bGVuZ3RoID4+IElCTE9DS19MQkFfU0hJRlQ7CisJCXNnX251bS0tOworCQlERUJVR19JQkxPQ0soInRhc2s6ICVwIGJpby1hZGRfcGFnZSgpIHBhc3NlZCEsIGRlY3JlbWVudGVkIgorCQkJIiBzZ19udW0gdG8gJXVcbiIsIHRhc2ssIHNnX251bSk7CisJCURFQlVHX0lCTE9DSygidGFzazogJXAgYmlvX2FkZF9wYWdlKCkgcGFzc2VkISwgaW5jcmVhc2VkIGxiYSIKKwkJCQkiIHRvICVsbHVcbiIsIHRhc2ssIGJsb2NrX2xiYSk7CisJCURFQlVHX0lCTE9DSygidGFzazogJXAgYmlvX2FkZF9wYWdlKCkgcGFzc2VkISwgYmlvLT5iaV92Y250OiIKKwkJCQkiICV1XG4iLCB0YXNrLCBiaW8tPmJpX3ZjbnQpOworCX0KKworCXJldHVybiAwOworZmFpbDoKKwl3aGlsZSAoaGJpbykgeworCQliaW8gPSBoYmlvOworCQloYmlvID0gaGJpby0+YmlfbmV4dDsKKwkJYmlvLT5iaV9uZXh0ID0gTlVMTDsKKwkJYmlvX3B1dChiaW8pOworCX0KKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdW5zaWduZWQgY2hhciAqaWJsb2NrX2dldF9jZGIoc3RydWN0IHNlX3Rhc2sgKnRhc2spCit7CisJcmV0dXJuIElCTE9DS19SRVEodGFzayktPmliX3Njc2lfY2RiOworfQorCitzdGF0aWMgdTMyIGlibG9ja19nZXRfZGV2aWNlX3JldihzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpCit7CisJcmV0dXJuIFNDU0lfU1BDXzI7IC8qIFJldHVybnMgU1BDLTMgaW4gSW5pdGlhdG9yIERhdGEgKi8KK30KKworc3RhdGljIHUzMiBpYmxvY2tfZ2V0X2RldmljZV90eXBlKHN0cnVjdCBzZV9kZXZpY2UgKmRldikKK3sKKwlyZXR1cm4gVFlQRV9ESVNLOworfQorCitzdGF0aWMgc2VjdG9yX3QgaWJsb2NrX2dldF9ibG9ja3Moc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBpYmxvY2tfZGV2ICppYmQgPSBkZXYtPmRldl9wdHI7CisJc3RydWN0IGJsb2NrX2RldmljZSAqYmQgPSBpYmQtPmliZF9iZDsKKwlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKGJkKTsKKworCXJldHVybiBpYmxvY2tfZW11bGF0ZV9yZWFkX2NhcF93aXRoX2Jsb2NrX3NpemUoZGV2LCBiZCwgcSk7Cit9CisKK3N0YXRpYyB2b2lkIGlibG9ja19iaW9fZG9uZShzdHJ1Y3QgYmlvICpiaW8sIGludCBlcnIpCit7CisJc3RydWN0IHNlX3Rhc2sgKnRhc2sgPSBiaW8tPmJpX3ByaXZhdGU7CisJc3RydWN0IGlibG9ja19yZXEgKmliciA9IElCTE9DS19SRVEodGFzayk7CisJLyoKKwkgKiBTZXQgLUVJTyBpZiAhQklPX1VQVE9EQVRFIGFuZCB0aGUgcGFzc2VkIGlzIHN0aWxsIGVycj0wCisJICovCisJaWYgKCEodGVzdF9iaXQoQklPX1VQVE9EQVRFLCAmYmlvLT5iaV9mbGFncykpICYmICEoZXJyKSkKKwkJZXJyID0gLUVJTzsKKworCWlmIChlcnIgIT0gMCkgeworCQlwcmludGsoS0VSTl9FUlIgInRlc3RfYml0KEJJT19VUFRPREFURSkgZmFpbGVkIGZvciBiaW86ICVwLCIKKwkJCSIgZXJyOiAlZFxuIiwgYmlvLCBlcnIpOworCQkvKgorCQkgKiBCdW1wIHRoZSBpYl9iaW9fZXJyX2NudCBhbmQgcmVsZWFzZSBiaW8uCisJCSAqLworCQlhdG9taWNfaW5jKCZpYnItPmliX2Jpb19lcnJfY250KTsKKwkJc21wX21iX19hZnRlcl9hdG9taWNfaW5jKCk7CisJCWJpb19wdXQoYmlvKTsKKwkJLyoKKwkJICogV2FpdCB0byBjb21wbGV0ZSB0aGUgdGFzayB1bnRpbCB0aGUgbGFzdCBiaW8gYXMgY29tcGxldGVkLgorCQkgKi8KKwkJaWYgKCEoYXRvbWljX2RlY19hbmRfdGVzdCgmaWJyLT5pYl9iaW9fY250KSkpCisJCQlyZXR1cm47CisKKwkJaWJyLT5pYl9iaW8gPSBOVUxMOworCQl0cmFuc3BvcnRfY29tcGxldGVfdGFzayh0YXNrLCAwKTsKKwkJcmV0dXJuOworCX0KKwlERUJVR19JQkxPQ0soImRvbmVbJXBdIGJpbzogJXAgdGFza19sYmE6ICVsbHUgYmlvX2xiYTogJWxsdSBlcnI9JWRcbiIsCisJCXRhc2ssIGJpbywgdGFzay0+dGFza19sYmEsIGJpby0+Ymlfc2VjdG9yLCBlcnIpOworCS8qCisJICogYmlvX3B1dCgpIHdpbGwgY2FsbCBpYmxvY2tfYmlvX2Rlc3RydWN0b3IoKSB0byByZWxlYXNlIHRoZSBiaW8gYmFjaworCSAqIHRvIGlici0+aWJfYmlvX3NldC4KKwkgKi8KKwliaW9fcHV0KGJpbyk7CisJLyoKKwkgKiBXYWl0IHRvIGNvbXBsZXRlIHRoZSB0YXNrIHVudGlsIHRoZSBsYXN0IGJpbyBhcyBjb21wbGV0ZWQuCisJICovCisJaWYgKCEoYXRvbWljX2RlY19hbmRfdGVzdCgmaWJyLT5pYl9iaW9fY250KSkpCisJCXJldHVybjsKKwkvKgorCSAqIFJldHVybiBHT09EIHN0YXR1cyBmb3IgdGFzayBpZiB6ZXJvIGliX2Jpb19lcnJfY250IGV4aXN0cy4KKwkgKi8KKwlpYnItPmliX2JpbyA9IE5VTEw7CisJdHJhbnNwb3J0X2NvbXBsZXRlX3Rhc2sodGFzaywgKCFhdG9taWNfcmVhZCgmaWJyLT5pYl9iaW9fZXJyX2NudCkpKTsKK30KKworc3RhdGljIHN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpIGlibG9ja190ZW1wbGF0ZSA9IHsKKwkubmFtZQkJCT0gImlibG9jayIsCisJLm93bmVyCQkJPSBUSElTX01PRFVMRSwKKwkudHJhbnNwb3J0X3R5cGUJCT0gVFJBTlNQT1JUX1BMVUdJTl9WSEJBX1BERVYsCisJLm1hcF90YXNrX1NHCQk9IGlibG9ja19tYXBfdGFza19TRywKKwkuYXR0YWNoX2hiYQkJPSBpYmxvY2tfYXR0YWNoX2hiYSwKKwkuZGV0YWNoX2hiYQkJPSBpYmxvY2tfZGV0YWNoX2hiYSwKKwkuYWxsb2NhdGVfdmlydGRldmljZQk9IGlibG9ja19hbGxvY2F0ZV92aXJ0ZGV2aWNlLAorCS5jcmVhdGVfdmlydGRldmljZQk9IGlibG9ja19jcmVhdGVfdmlydGRldmljZSwKKwkuZnJlZV9kZXZpY2UJCT0gaWJsb2NrX2ZyZWVfZGV2aWNlLAorCS5kcG9fZW11bGF0ZWQJCT0gaWJsb2NrX2VtdWxhdGVkX2RwbywKKwkuZnVhX3dyaXRlX2VtdWxhdGVkCT0gaWJsb2NrX2VtdWxhdGVkX2Z1YV93cml0ZSwKKwkuZnVhX3JlYWRfZW11bGF0ZWQJPSBpYmxvY2tfZW11bGF0ZWRfZnVhX3JlYWQsCisJLndyaXRlX2NhY2hlX2VtdWxhdGVkCT0gaWJsb2NrX2VtdWxhdGVkX3dyaXRlX2NhY2hlLAorCS5hbGxvY190YXNrCQk9IGlibG9ja19hbGxvY190YXNrLAorCS5kb190YXNrCQk9IGlibG9ja19kb190YXNrLAorCS5kb19kaXNjYXJkCQk9IGlibG9ja19kb19kaXNjYXJkLAorCS5kb19zeW5jX2NhY2hlCQk9IGlibG9ja19lbXVsYXRlX3N5bmNfY2FjaGUsCisJLmZyZWVfdGFzawkJPSBpYmxvY2tfZnJlZV90YXNrLAorCS5jaGVja19jb25maWdmc19kZXZfcGFyYW1zID0gaWJsb2NrX2NoZWNrX2NvbmZpZ2ZzX2Rldl9wYXJhbXMsCisJLnNldF9jb25maWdmc19kZXZfcGFyYW1zID0gaWJsb2NrX3NldF9jb25maWdmc19kZXZfcGFyYW1zLAorCS5zaG93X2NvbmZpZ2ZzX2Rldl9wYXJhbXMgPSBpYmxvY2tfc2hvd19jb25maWdmc19kZXZfcGFyYW1zLAorCS5nZXRfY2RiCQk9IGlibG9ja19nZXRfY2RiLAorCS5nZXRfZGV2aWNlX3JldgkJPSBpYmxvY2tfZ2V0X2RldmljZV9yZXYsCisJLmdldF9kZXZpY2VfdHlwZQk9IGlibG9ja19nZXRfZGV2aWNlX3R5cGUsCisJLmdldF9ibG9ja3MJCT0gaWJsb2NrX2dldF9ibG9ja3MsCit9OworCitzdGF0aWMgaW50IF9faW5pdCBpYmxvY2tfbW9kdWxlX2luaXQodm9pZCkKK3sKKwlyZXR1cm4gdHJhbnNwb3J0X3N1YnN5c3RlbV9yZWdpc3RlcigmaWJsb2NrX3RlbXBsYXRlKTsKK30KKworc3RhdGljIHZvaWQgaWJsb2NrX21vZHVsZV9leGl0KHZvaWQpCit7CisJdHJhbnNwb3J0X3N1YnN5c3RlbV9yZWxlYXNlKCZpYmxvY2tfdGVtcGxhdGUpOworfQorCitNT0RVTEVfREVTQ1JJUFRJT04oIlRDTSBJQkxPQ0sgc3Vic3lzdGVtIHBsdWdpbiIpOworTU9EVUxFX0FVVEhPUigibmFiQExpbnV4LWlTQ1NJLm9yZyIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworCittb2R1bGVfaW5pdChpYmxvY2tfbW9kdWxlX2luaXQpOworbW9kdWxlX2V4aXQoaWJsb2NrX21vZHVsZV9leGl0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2libG9jay5oIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfaWJsb2NrLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjRjMWY0ZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2libG9jay5oCkBAIC0wLDAgKzEsNDAgQEAKKyNpZm5kZWYgVEFSR0VUX0NPUkVfSUJMT0NLX0gKKyNkZWZpbmUgVEFSR0VUX0NPUkVfSUJMT0NLX0gKKworI2RlZmluZSBJQkxPQ0tfVkVSU0lPTgkJIjQuMCIKKworI2RlZmluZSBJQkxPQ0tfSEJBX1FVRVVFX0RFUFRICTUxMgorI2RlZmluZSBJQkxPQ0tfREVWSUNFX1FVRVVFX0RFUFRICTMyCisjZGVmaW5lIElCTE9DS19NQVhfREVWSUNFX1FVRVVFX0RFUFRICTEyOAorI2RlZmluZSBJQkxPQ0tfTUFYX0NEQlMJCTE2CisjZGVmaW5lIElCTE9DS19MQkFfU0hJRlQJOQorCitzdHJ1Y3QgaWJsb2NrX3JlcSB7CisJc3RydWN0IHNlX3Rhc2sgaWJfdGFzazsKKwl1bnNpZ25lZCBjaGFyIGliX3Njc2lfY2RiW1RDTV9NQVhfQ09NTUFORF9TSVpFXTsKKwlhdG9taWNfdCBpYl9iaW9fY250OworCWF0b21pY190IGliX2Jpb19lcnJfY250OworCXN0cnVjdCBiaW8gKmliX2JpbzsKKwlzdHJ1Y3QgaWJsb2NrX2RldiAqaWJfZGV2OworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKKyNkZWZpbmUgSUJERl9IQVNfVURFVl9QQVRICQkweDAxCisjZGVmaW5lIElCREZfSEFTX0ZPUkNFCQkJMHgwMgorCitzdHJ1Y3QgaWJsb2NrX2RldiB7CisJdW5zaWduZWQgY2hhciBpYmRfdWRldl9wYXRoW1NFX1VERVZfUEFUSF9MRU5dOworCWludAlpYmRfZm9yY2U7CisJaW50CWliZF9tYWpvcjsKKwlpbnQJaWJkX21pbm9yOworCXUzMglpYmRfZGVwdGg7CisJdTMyCWliZF9mbGFnczsKKwlzdHJ1Y3QgYmlvX3NldAkqaWJkX2Jpb19zZXQ7CisJc3RydWN0IGJsb2NrX2RldmljZSAqaWJkX2JkOworCXN0cnVjdCBpYmxvY2tfaGJhICppYmRfaG9zdDsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCitzdHJ1Y3QgaWJsb2NrX2hiYSB7CisJaW50CQlpYmxvY2tfaG9zdF9pZDsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCisjZW5kaWYgLyogVEFSR0VUX0NPUkVfSUJMT0NLX0ggKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX21pYi5jIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfbWliLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDVhNDhhYQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX21pYi5jCkBAIC0wLDAgKzEsMTA3OCBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIEZpbGVuYW1lOiAgdGFyZ2V0X2NvcmVfbWliLmMKKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMDYtMjAwNyBTQkUsIEluYy4gIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKGMpIDIwMDctMjAxMCBSaXNpbmcgVGlkZSBTeXN0ZW1zCisgKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxMCBMaW51eC1pU0NTSS5vcmcKKyAqCisgKiBOaWNob2xhcyBBLiBCZWxsaW5nZXIgPG5hYkBsaW51eC1pc2NzaS5vcmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisKKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L3RpbWVyLmg+CisjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CisjaW5jbHVkZSA8bGludXgvdmVyc2lvbi5oPgorI2luY2x1ZGUgPGdlbmVyYXRlZC91dHNyZWxlYXNlLmg+CisjaW5jbHVkZSA8bGludXgvdXRzbmFtZS5oPgorI2luY2x1ZGUgPGxpbnV4L3Byb2NfZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgorI2luY2x1ZGUgPGxpbnV4L2Jsa2Rldi5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaS5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2lfaG9zdC5oPgorCisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2Jhc2UuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdHJhbnNwb3J0Lmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19vcHMuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfY29uZmlnZnMuaD4KKworI2luY2x1ZGUgInRhcmdldF9jb3JlX2hiYS5oIgorI2luY2x1ZGUgInRhcmdldF9jb3JlX21pYi5oIgorCisvKiBTQ1NJIG1pYiB0YWJsZSBpbmRleCAqLworc3RhdGljIHN0cnVjdCBzY3NpX2luZGV4X3RhYmxlIHNjc2lfaW5kZXhfdGFibGU7CisKKyNpZm5kZWYgSU5JVElBTF9KSUZGSUVTCisjZGVmaW5lIElOSVRJQUxfSklGRklFUyAoKHVuc2lnbmVkIGxvbmcpKHVuc2lnbmVkIGludCkgKC0zMDAqSFopKQorI2VuZGlmCisKKy8qIFNDU0kgSW5zdGFuY2UgVGFibGUgKi8KKyNkZWZpbmUgU0NTSV9JTlNUX1NXX0lOREVYCQkxCisjZGVmaW5lIFNDU0lfVFJBTlNQT1JUX0lOREVYCQkxCisKKyNkZWZpbmUgTk9ORQkJIk5vbmUiCisjZGVmaW5lIElTUFJJTlQoYSkgICAoKGEgPj0gJyAnKSAmJiAoYSA8PSAnficpKQorCitzdGF0aWMgaW5saW5lIGludCBsaXN0X2lzX2ZpcnN0KGNvbnN0IHN0cnVjdCBsaXN0X2hlYWQgKmxpc3QsCisJCQkJY29uc3Qgc3RydWN0IGxpc3RfaGVhZCAqaGVhZCkKK3sKKwlyZXR1cm4gbGlzdC0+cHJldiA9PSBoZWFkOworfQorCitzdGF0aWMgdm9pZCAqbG9jYXRlX2hiYV9zdGFydCgKKwlzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwKKwlsb2ZmX3QgKnBvcykKK3sKKwlzcGluX2xvY2soJnNlX2dsb2JhbC0+Z19kZXZpY2VfbG9jayk7CisJcmV0dXJuIHNlcV9saXN0X3N0YXJ0KCZzZV9nbG9iYWwtPmdfc2VfZGV2X2xpc3QsICpwb3MpOworfQorCitzdGF0aWMgdm9pZCAqbG9jYXRlX2hiYV9uZXh0KAorCXN0cnVjdCBzZXFfZmlsZSAqc2VxLAorCXZvaWQgKnYsCisJbG9mZl90ICpwb3MpCit7CisJcmV0dXJuIHNlcV9saXN0X25leHQodiwgJnNlX2dsb2JhbC0+Z19zZV9kZXZfbGlzdCwgcG9zKTsKK30KKworc3RhdGljIHZvaWQgbG9jYXRlX2hiYV9zdG9wKHN0cnVjdCBzZXFfZmlsZSAqc2VxLCB2b2lkICp2KQoreworCXNwaW5fdW5sb2NrKCZzZV9nbG9iYWwtPmdfZGV2aWNlX2xvY2spOworfQorCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogU0NTSSBNSUIgVGFibGVzCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworLyoKKyAqIFNDU0kgSW5zdGFuY2UgVGFibGUKKyAqLworc3RhdGljIHZvaWQgKnNjc2lfaW5zdF9zZXFfc3RhcnQoCisJc3RydWN0IHNlcV9maWxlICpzZXEsCisJbG9mZl90ICpwb3MpCit7CisJc3Bpbl9sb2NrKCZzZV9nbG9iYWwtPmhiYV9sb2NrKTsKKwlyZXR1cm4gc2VxX2xpc3Rfc3RhcnQoJnNlX2dsb2JhbC0+Z19oYmFfbGlzdCwgKnBvcyk7Cit9CisKK3N0YXRpYyB2b2lkICpzY3NpX2luc3Rfc2VxX25leHQoCisJc3RydWN0IHNlcV9maWxlICpzZXEsCisJdm9pZCAqdiwKKwlsb2ZmX3QgKnBvcykKK3sKKwlyZXR1cm4gc2VxX2xpc3RfbmV4dCh2LCAmc2VfZ2xvYmFsLT5nX2hiYV9saXN0LCBwb3MpOworfQorCitzdGF0aWMgdm9pZCBzY3NpX2luc3Rfc2VxX3N0b3Aoc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYpCit7CisJc3Bpbl91bmxvY2soJnNlX2dsb2JhbC0+aGJhX2xvY2spOworfQorCitzdGF0aWMgaW50IHNjc2lfaW5zdF9zZXFfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdikKK3sKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEgPSBsaXN0X2VudHJ5KHYsIHN0cnVjdCBzZV9oYmEsIGhiYV9saXN0KTsKKworCWlmIChsaXN0X2lzX2ZpcnN0KCZoYmEtPmhiYV9saXN0LCAmc2VfZ2xvYmFsLT5nX2hiYV9saXN0KSkKKwkJc2VxX3B1dHMoc2VxLCAiaW5zdCBzd19pbmR4XG4iKTsKKworCXNlcV9wcmludGYoc2VxLCAiJXUgJXVcbiIsIGhiYS0+aGJhX2luZGV4LCBTQ1NJX0lOU1RfU1dfSU5ERVgpOworCXNlcV9wcmludGYoc2VxLCAicGx1Z2luOiAlcyB2ZXJzaW9uOiAlc1xuIiwKKwkJCWhiYS0+dHJhbnNwb3J0LT5uYW1lLCBUQVJHRVRfQ09SRV9WRVJTSU9OKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IHNlcV9vcGVyYXRpb25zIHNjc2lfaW5zdF9zZXFfb3BzID0geworCS5zdGFydAk9IHNjc2lfaW5zdF9zZXFfc3RhcnQsCisJLm5leHQJPSBzY3NpX2luc3Rfc2VxX25leHQsCisJLnN0b3AJPSBzY3NpX2luc3Rfc2VxX3N0b3AsCisJLnNob3cJPSBzY3NpX2luc3Rfc2VxX3Nob3cKK307CisKK3N0YXRpYyBpbnQgc2NzaV9pbnN0X3NlcV9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQoreworCXJldHVybiBzZXFfb3BlbihmaWxlLCAmc2NzaV9pbnN0X3NlcV9vcHMpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBzY3NpX2luc3Rfc2VxX2ZvcHMgPSB7CisJLm93bmVyCSA9IFRISVNfTU9EVUxFLAorCS5vcGVuCSA9IHNjc2lfaW5zdF9zZXFfb3BlbiwKKwkucmVhZAkgPSBzZXFfcmVhZCwKKwkubGxzZWVrCSA9IHNlcV9sc2VlaywKKwkucmVsZWFzZSA9IHNlcV9yZWxlYXNlLAorfTsKKworLyoKKyAqIFNDU0kgRGV2aWNlIFRhYmxlCisgKi8KK3N0YXRpYyB2b2lkICpzY3NpX2Rldl9zZXFfc3RhcnQoc3RydWN0IHNlcV9maWxlICpzZXEsIGxvZmZfdCAqcG9zKQoreworCXJldHVybiBsb2NhdGVfaGJhX3N0YXJ0KHNlcSwgcG9zKTsKK30KKworc3RhdGljIHZvaWQgKnNjc2lfZGV2X3NlcV9uZXh0KHN0cnVjdCBzZXFfZmlsZSAqc2VxLCB2b2lkICp2LCBsb2ZmX3QgKnBvcykKK3sKKwlyZXR1cm4gbG9jYXRlX2hiYV9uZXh0KHNlcSwgdiwgcG9zKTsKK30KKworc3RhdGljIHZvaWQgc2NzaV9kZXZfc2VxX3N0b3Aoc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYpCit7CisJbG9jYXRlX2hiYV9zdG9wKHNlcSwgdik7Cit9CisKK3N0YXRpYyBpbnQgc2NzaV9kZXZfc2VxX3Nob3coc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYpCit7CisJc3RydWN0IHNlX2hiYSAqaGJhOworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzZV9kZXYgPSBsaXN0X2VudHJ5KHYsIHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2LAorCQkJCQkJZ19zZV9kZXZfbGlzdCk7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gc2VfZGV2LT5zZV9kZXZfcHRyOworCWNoYXIgc3RyWzI4XTsKKwlpbnQgazsKKworCWlmIChsaXN0X2lzX2ZpcnN0KCZzZV9kZXYtPmdfc2VfZGV2X2xpc3QsICZzZV9nbG9iYWwtPmdfc2VfZGV2X2xpc3QpKQorCQlzZXFfcHV0cyhzZXEsICJpbnN0IGluZHggcm9sZSBwb3J0c1xuIik7CisKKwlpZiAoIShkZXYpKQorCQlyZXR1cm4gMDsKKworCWhiYSA9IGRldi0+c2VfaGJhOworCWlmICghKGhiYSkpIHsKKwkJLyogTG9nIGVycm9yID8gKi8KKwkJcmV0dXJuIDA7CisJfQorCisJc2VxX3ByaW50ZihzZXEsICIldSAldSAlcyAldVxuIiwgaGJhLT5oYmFfaW5kZXgsCisJCSAgIGRldi0+ZGV2X2luZGV4LCAiVGFyZ2V0IiwgZGV2LT5kZXZfcG9ydF9jb3VudCk7CisKKwltZW1jcHkoJnN0clswXSwgKHZvaWQgKilERVZfVDEwX1dXTihkZXYpLCAyOCk7CisKKwkvKiB2ZW5kb3IgKi8KKwlmb3IgKGsgPSAwOyBrIDwgODsgaysrKQorCQlzdHJba10gPSBJU1BSSU5UKERFVl9UMTBfV1dOKGRldiktPnZlbmRvcltrXSkgPworCQkJCURFVl9UMTBfV1dOKGRldiktPnZlbmRvcltrXSA6IDB4MjA7CisJc3RyW2tdID0gMHgyMDsKKworCS8qIG1vZGVsICovCisJZm9yIChrID0gMDsgayA8IDE2OyBrKyspCisJCXN0cltrKzldID0gSVNQUklOVChERVZfVDEwX1dXTihkZXYpLT5tb2RlbFtrXSkgPworCQkJCURFVl9UMTBfV1dOKGRldiktPm1vZGVsW2tdIDogMHgyMDsKKwlzdHJbayArIDldID0gMDsKKworCXNlcV9wcmludGYoc2VxLCAiZGV2X2FsaWFzOiAlc1xuIiwgc3RyKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IHNlcV9vcGVyYXRpb25zIHNjc2lfZGV2X3NlcV9vcHMgPSB7CisJLnN0YXJ0ICA9IHNjc2lfZGV2X3NlcV9zdGFydCwKKwkubmV4dCAgID0gc2NzaV9kZXZfc2VxX25leHQsCisJLnN0b3AgICA9IHNjc2lfZGV2X3NlcV9zdG9wLAorCS5zaG93ICAgPSBzY3NpX2Rldl9zZXFfc2hvdworfTsKKworc3RhdGljIGludCBzY3NpX2Rldl9zZXFfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKK3sKKwlyZXR1cm4gc2VxX29wZW4oZmlsZSwgJnNjc2lfZGV2X3NlcV9vcHMpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBzY3NpX2Rldl9zZXFfZm9wcyA9IHsKKwkub3duZXIJID0gVEhJU19NT0RVTEUsCisJLm9wZW4JID0gc2NzaV9kZXZfc2VxX29wZW4sCisJLnJlYWQJID0gc2VxX3JlYWQsCisJLmxsc2VlawkgPSBzZXFfbHNlZWssCisJLnJlbGVhc2UgPSBzZXFfcmVsZWFzZSwKK307CisKKy8qCisgKiBTQ1NJIFBvcnQgVGFibGUKKyAqLworc3RhdGljIHZvaWQgKnNjc2lfcG9ydF9zZXFfc3RhcnQoc3RydWN0IHNlcV9maWxlICpzZXEsIGxvZmZfdCAqcG9zKQoreworCXJldHVybiBsb2NhdGVfaGJhX3N0YXJ0KHNlcSwgcG9zKTsKK30KKworc3RhdGljIHZvaWQgKnNjc2lfcG9ydF9zZXFfbmV4dChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdiwgbG9mZl90ICpwb3MpCit7CisJcmV0dXJuIGxvY2F0ZV9oYmFfbmV4dChzZXEsIHYsIHBvcyk7Cit9CisKK3N0YXRpYyB2b2lkIHNjc2lfcG9ydF9zZXFfc3RvcChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdikKK3sKKwlsb2NhdGVfaGJhX3N0b3Aoc2VxLCB2KTsKK30KKworc3RhdGljIGludCBzY3NpX3BvcnRfc2VxX3Nob3coc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYpCit7CisJc3RydWN0IHNlX2hiYSAqaGJhOworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzZV9kZXYgPSBsaXN0X2VudHJ5KHYsIHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2LAorCQkJCQkJZ19zZV9kZXZfbGlzdCk7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gc2VfZGV2LT5zZV9kZXZfcHRyOworCXN0cnVjdCBzZV9wb3J0ICpzZXAsICpzZXBfdG1wOworCisJaWYgKGxpc3RfaXNfZmlyc3QoJnNlX2Rldi0+Z19zZV9kZXZfbGlzdCwgJnNlX2dsb2JhbC0+Z19zZV9kZXZfbGlzdCkpCisJCXNlcV9wdXRzKHNlcSwgImluc3QgZGV2aWNlIGluZHggcm9sZSBidXN5X2NvdW50XG4iKTsKKworCWlmICghKGRldikpCisJCXJldHVybiAwOworCisJaGJhID0gZGV2LT5zZV9oYmE7CisJaWYgKCEoaGJhKSkgeworCQkvKiBMb2cgZXJyb3IgPyAqLworCQlyZXR1cm4gMDsKKwl9CisKKwkvKiBGSVhNRTogc2NzaVBvcnRCdXN5U3RhdHVzZXMgY291bnQgKi8KKwlzcGluX2xvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoc2VwLCBzZXBfdG1wLCAmZGV2LT5kZXZfc2VwX2xpc3QsIHNlcF9saXN0KSB7CisJCXNlcV9wcmludGYoc2VxLCAiJXUgJXUgJXUgJXMldSAldVxuIiwgaGJhLT5oYmFfaW5kZXgsCisJCQlkZXYtPmRldl9pbmRleCwgc2VwLT5zZXBfaW5kZXgsICJEZXZpY2UiLAorCQkJZGV2LT5kZXZfaW5kZXgsIDApOworCX0KKwlzcGluX3VubG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc2VxX29wZXJhdGlvbnMgc2NzaV9wb3J0X3NlcV9vcHMgPSB7CisJLnN0YXJ0ICA9IHNjc2lfcG9ydF9zZXFfc3RhcnQsCisJLm5leHQgICA9IHNjc2lfcG9ydF9zZXFfbmV4dCwKKwkuc3RvcCAgID0gc2NzaV9wb3J0X3NlcV9zdG9wLAorCS5zaG93ICAgPSBzY3NpX3BvcnRfc2VxX3Nob3cKK307CisKK3N0YXRpYyBpbnQgc2NzaV9wb3J0X3NlcV9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQoreworCXJldHVybiBzZXFfb3BlbihmaWxlLCAmc2NzaV9wb3J0X3NlcV9vcHMpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBzY3NpX3BvcnRfc2VxX2ZvcHMgPSB7CisJLm93bmVyCSA9IFRISVNfTU9EVUxFLAorCS5vcGVuCSA9IHNjc2lfcG9ydF9zZXFfb3BlbiwKKwkucmVhZAkgPSBzZXFfcmVhZCwKKwkubGxzZWVrCSA9IHNlcV9sc2VlaywKKwkucmVsZWFzZSA9IHNlcV9yZWxlYXNlLAorfTsKKworLyoKKyAqIFNDU0kgVHJhbnNwb3J0IFRhYmxlCisgKi8KK3N0YXRpYyB2b2lkICpzY3NpX3RyYW5zcG9ydF9zZXFfc3RhcnQoc3RydWN0IHNlcV9maWxlICpzZXEsIGxvZmZfdCAqcG9zKQoreworCXJldHVybiBsb2NhdGVfaGJhX3N0YXJ0KHNlcSwgcG9zKTsKK30KKworc3RhdGljIHZvaWQgKnNjc2lfdHJhbnNwb3J0X3NlcV9uZXh0KHN0cnVjdCBzZXFfZmlsZSAqc2VxLCB2b2lkICp2LCBsb2ZmX3QgKnBvcykKK3sKKwlyZXR1cm4gbG9jYXRlX2hiYV9uZXh0KHNlcSwgdiwgcG9zKTsKK30KKworc3RhdGljIHZvaWQgc2NzaV90cmFuc3BvcnRfc2VxX3N0b3Aoc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYpCit7CisJbG9jYXRlX2hiYV9zdG9wKHNlcSwgdik7Cit9CisKK3N0YXRpYyBpbnQgc2NzaV90cmFuc3BvcnRfc2VxX3Nob3coc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYpCit7CisJc3RydWN0IHNlX2hiYSAqaGJhOworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzZV9kZXYgPSBsaXN0X2VudHJ5KHYsIHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2LAorCQkJCQkJZ19zZV9kZXZfbGlzdCk7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gc2VfZGV2LT5zZV9kZXZfcHRyOworCXN0cnVjdCBzZV9wb3J0ICpzZSwgKnNlX3RtcDsKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGc7CisJc3RydWN0IHQxMF93d24gKnd3bjsKKwljaGFyIGJ1Zls2NF07CisKKwlpZiAobGlzdF9pc19maXJzdCgmc2VfZGV2LT5nX3NlX2Rldl9saXN0LCAmc2VfZ2xvYmFsLT5nX3NlX2Rldl9saXN0KSkKKwkJc2VxX3B1dHMoc2VxLCAiaW5zdCBkZXZpY2UgaW5keCBkZXZfbmFtZVxuIik7CisKKwlpZiAoIShkZXYpKQorCQlyZXR1cm4gMDsKKworCWhiYSA9IGRldi0+c2VfaGJhOworCWlmICghKGhiYSkpIHsKKwkJLyogTG9nIGVycm9yID8gKi8KKwkJcmV0dXJuIDA7CisJfQorCisJd3duID0gREVWX1QxMF9XV04oZGV2KTsKKworCXNwaW5fbG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShzZSwgc2VfdG1wLCAmZGV2LT5kZXZfc2VwX2xpc3QsIHNlcF9saXN0KSB7CisJCXRwZyA9IHNlLT5zZXBfdHBnOworCQlzcHJpbnRmKGJ1ZiwgInNjc2lUcmFuc3BvcnQlcyIsCisJCQkJVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSk7CisKKwkJc2VxX3ByaW50ZihzZXEsICIldSAlcyAldSAlcyslc1xuIiwKKwkJCWhiYS0+aGJhX2luZGV4LCAvKiBzY3NpVHJhbnNwb3J0SW5kZXggKi8KKwkJCWJ1ZiwgIC8qIHNjc2lUcmFuc3BvcnRUeXBlICovCisJCQkoVFBHX1RGTyh0cGcpLT50cGdfZ2V0X2luc3RfaW5kZXggIT0gTlVMTCkgPworCQkJVFBHX1RGTyh0cGcpLT50cGdfZ2V0X2luc3RfaW5kZXgodHBnKSA6CisJCQkwLAorCQkJVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3d3bih0cGcpLAorCQkJKHN0cmxlbih3d24tPnVuaXRfc2VyaWFsKSkgPworCQkJLyogc2NzaVRyYW5zcG9ydERldk5hbWUgKi8KKwkJCXd3bi0+dW5pdF9zZXJpYWwgOiB3d24tPnZlbmRvcik7CisJfQorCXNwaW5fdW5sb2NrKCZkZXYtPnNlX3BvcnRfbG9jayk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBzZXFfb3BlcmF0aW9ucyBzY3NpX3RyYW5zcG9ydF9zZXFfb3BzID0geworCS5zdGFydCAgPSBzY3NpX3RyYW5zcG9ydF9zZXFfc3RhcnQsCisJLm5leHQgICA9IHNjc2lfdHJhbnNwb3J0X3NlcV9uZXh0LAorCS5zdG9wICAgPSBzY3NpX3RyYW5zcG9ydF9zZXFfc3RvcCwKKwkuc2hvdyAgID0gc2NzaV90cmFuc3BvcnRfc2VxX3Nob3cKK307CisKK3N0YXRpYyBpbnQgc2NzaV90cmFuc3BvcnRfc2VxX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCit7CisJcmV0dXJuIHNlcV9vcGVuKGZpbGUsICZzY3NpX3RyYW5zcG9ydF9zZXFfb3BzKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgc2NzaV90cmFuc3BvcnRfc2VxX2ZvcHMgPSB7CisJLm93bmVyCSA9IFRISVNfTU9EVUxFLAorCS5vcGVuCSA9IHNjc2lfdHJhbnNwb3J0X3NlcV9vcGVuLAorCS5yZWFkCSA9IHNlcV9yZWFkLAorCS5sbHNlZWsJID0gc2VxX2xzZWVrLAorCS5yZWxlYXNlID0gc2VxX3JlbGVhc2UsCit9OworCisvKgorICogU0NTSSBUYXJnZXQgRGV2aWNlIFRhYmxlCisgKi8KK3N0YXRpYyB2b2lkICpzY3NpX3RndF9kZXZfc2VxX3N0YXJ0KHN0cnVjdCBzZXFfZmlsZSAqc2VxLCBsb2ZmX3QgKnBvcykKK3sKKwlyZXR1cm4gbG9jYXRlX2hiYV9zdGFydChzZXEsIHBvcyk7Cit9CisKK3N0YXRpYyB2b2lkICpzY3NpX3RndF9kZXZfc2VxX25leHQoc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYsIGxvZmZfdCAqcG9zKQoreworCXJldHVybiBsb2NhdGVfaGJhX25leHQoc2VxLCB2LCBwb3MpOworfQorCitzdGF0aWMgdm9pZCBzY3NpX3RndF9kZXZfc2VxX3N0b3Aoc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYpCit7CisJbG9jYXRlX2hiYV9zdG9wKHNlcSwgdik7Cit9CisKKworI2RlZmluZSBMVV9DT1VOVAkxICAvKiBmb3Igbm93ICovCitzdGF0aWMgaW50IHNjc2lfdGd0X2Rldl9zZXFfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdikKK3sKKwlzdHJ1Y3Qgc2VfaGJhICpoYmE7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiA9IGxpc3RfZW50cnkodiwgc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYsCisJCQkJCQlnX3NlX2Rldl9saXN0KTsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBzZV9kZXYtPnNlX2Rldl9wdHI7CisJaW50IG5vbl9hY2Nlc3NpYmxlX2x1cyA9IDA7CisJY2hhciBzdGF0dXNbMTZdOworCisJaWYgKGxpc3RfaXNfZmlyc3QoJnNlX2Rldi0+Z19zZV9kZXZfbGlzdCwgJnNlX2dsb2JhbC0+Z19zZV9kZXZfbGlzdCkpCisJCXNlcV9wdXRzKHNlcSwgImluc3QgaW5keCBudW1fTFVzIHN0YXR1cyBub25fYWNjZXNzX0xVcyIKKwkJCSIgcmVzZXRzXG4iKTsKKworCWlmICghKGRldikpCisJCXJldHVybiAwOworCisJaGJhID0gZGV2LT5zZV9oYmE7CisJaWYgKCEoaGJhKSkgeworCQkvKiBMb2cgZXJyb3IgPyAqLworCQlyZXR1cm4gMDsKKwl9CisKKwlzd2l0Y2ggKGRldi0+ZGV2X3N0YXR1cykgeworCWNhc2UgVFJBTlNQT1JUX0RFVklDRV9BQ1RJVkFURUQ6CisJCXN0cmNweShzdGF0dXMsICJhY3RpdmF0ZWQiKTsKKwkJYnJlYWs7CisJY2FzZSBUUkFOU1BPUlRfREVWSUNFX0RFQUNUSVZBVEVEOgorCQlzdHJjcHkoc3RhdHVzLCAiZGVhY3RpdmF0ZWQiKTsKKwkJbm9uX2FjY2Vzc2libGVfbHVzID0gMTsKKwkJYnJlYWs7CisJY2FzZSBUUkFOU1BPUlRfREVWSUNFX1NIVVRET1dOOgorCQlzdHJjcHkoc3RhdHVzLCAic2h1dGRvd24iKTsKKwkJbm9uX2FjY2Vzc2libGVfbHVzID0gMTsKKwkJYnJlYWs7CisJY2FzZSBUUkFOU1BPUlRfREVWSUNFX09GRkxJTkVfQUNUSVZBVEVEOgorCWNhc2UgVFJBTlNQT1JUX0RFVklDRV9PRkZMSU5FX0RFQUNUSVZBVEVEOgorCQlzdHJjcHkoc3RhdHVzLCAib2ZmbGluZSIpOworCQlub25fYWNjZXNzaWJsZV9sdXMgPSAxOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlzcHJpbnRmKHN0YXR1cywgInVua25vd24oJWQpIiwgZGV2LT5kZXZfc3RhdHVzKTsKKwkJbm9uX2FjY2Vzc2libGVfbHVzID0gMTsKKwl9CisKKwlzZXFfcHJpbnRmKHNlcSwgIiV1ICV1ICV1ICVzICV1ICV1XG4iLAorCQkgICBoYmEtPmhiYV9pbmRleCwgZGV2LT5kZXZfaW5kZXgsIExVX0NPVU5ULAorCQkgICBzdGF0dXMsIG5vbl9hY2Nlc3NpYmxlX2x1cywgZGV2LT5udW1fcmVzZXRzKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IHNlcV9vcGVyYXRpb25zIHNjc2lfdGd0X2Rldl9zZXFfb3BzID0geworCS5zdGFydCAgPSBzY3NpX3RndF9kZXZfc2VxX3N0YXJ0LAorCS5uZXh0ICAgPSBzY3NpX3RndF9kZXZfc2VxX25leHQsCisJLnN0b3AgICA9IHNjc2lfdGd0X2Rldl9zZXFfc3RvcCwKKwkuc2hvdyAgID0gc2NzaV90Z3RfZGV2X3NlcV9zaG93Cit9OworCitzdGF0aWMgaW50IHNjc2lfdGd0X2Rldl9zZXFfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKK3sKKwlyZXR1cm4gc2VxX29wZW4oZmlsZSwgJnNjc2lfdGd0X2Rldl9zZXFfb3BzKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgc2NzaV90Z3RfZGV2X3NlcV9mb3BzID0geworCS5vd25lcgkgPSBUSElTX01PRFVMRSwKKwkub3BlbgkgPSBzY3NpX3RndF9kZXZfc2VxX29wZW4sCisJLnJlYWQJID0gc2VxX3JlYWQsCisJLmxsc2VlawkgPSBzZXFfbHNlZWssCisJLnJlbGVhc2UgPSBzZXFfcmVsZWFzZSwKK307CisKKy8qCisgKiBTQ1NJIFRhcmdldCBQb3J0IFRhYmxlCisgKi8KK3N0YXRpYyB2b2lkICpzY3NpX3RndF9wb3J0X3NlcV9zdGFydChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgbG9mZl90ICpwb3MpCit7CisJcmV0dXJuIGxvY2F0ZV9oYmFfc3RhcnQoc2VxLCBwb3MpOworfQorCitzdGF0aWMgdm9pZCAqc2NzaV90Z3RfcG9ydF9zZXFfbmV4dChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdiwgbG9mZl90ICpwb3MpCit7CisJcmV0dXJuIGxvY2F0ZV9oYmFfbmV4dChzZXEsIHYsIHBvcyk7Cit9CisKK3N0YXRpYyB2b2lkIHNjc2lfdGd0X3BvcnRfc2VxX3N0b3Aoc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYpCit7CisJbG9jYXRlX2hiYV9zdG9wKHNlcSwgdik7Cit9CisKK3N0YXRpYyBpbnQgc2NzaV90Z3RfcG9ydF9zZXFfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdikKK3sKKwlzdHJ1Y3Qgc2VfaGJhICpoYmE7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiA9IGxpc3RfZW50cnkodiwgc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYsCisJCQkJCQlnX3NlX2Rldl9saXN0KTsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBzZV9kZXYtPnNlX2Rldl9wdHI7CisJc3RydWN0IHNlX3BvcnQgKnNlcCwgKnNlcF90bXA7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnOworCXUzMiByeF9tYnl0ZXMsIHR4X21ieXRlczsKKwl1bnNpZ25lZCBsb25nIGxvbmcgbnVtX2NtZHM7CisJY2hhciBidWZbNjRdOworCisJaWYgKGxpc3RfaXNfZmlyc3QoJnNlX2Rldi0+Z19zZV9kZXZfbGlzdCwgJnNlX2dsb2JhbC0+Z19zZV9kZXZfbGlzdCkpCisJCXNlcV9wdXRzKHNlcSwgImluc3QgZGV2aWNlIGluZHggbmFtZSBwb3J0X2luZGV4IGluX2NtZHMiCisJCQkiIHdyaXRlX21ieXRlcyByZWFkX21ieXRlcyBoc19pbl9jbWRzXG4iKTsKKworCWlmICghKGRldikpCisJCXJldHVybiAwOworCisJaGJhID0gZGV2LT5zZV9oYmE7CisJaWYgKCEoaGJhKSkgeworCQkvKiBMb2cgZXJyb3IgPyAqLworCQlyZXR1cm4gMDsKKwl9CisKKwlzcGluX2xvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoc2VwLCBzZXBfdG1wLCAmZGV2LT5kZXZfc2VwX2xpc3QsIHNlcF9saXN0KSB7CisJCXRwZyA9IHNlcC0+c2VwX3RwZzsKKwkJc3ByaW50ZihidWYsICIlc1BvcnQjIiwKKwkJCVRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCkpOworCisJCXNlcV9wcmludGYoc2VxLCAiJXUgJXUgJXUgJXMlZCAlcyVzJWQgIiwKKwkJICAgICBoYmEtPmhiYV9pbmRleCwKKwkJICAgICBkZXYtPmRldl9pbmRleCwKKwkJICAgICBzZXAtPnNlcF9pbmRleCwKKwkJICAgICBidWYsIHNlcC0+c2VwX2luZGV4LAorCQkgICAgIFRQR19URk8odHBnKS0+dHBnX2dldF93d24odHBnKSwgIit0KyIsCisJCSAgICAgVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3RhZyh0cGcpKTsKKworCQlzcGluX2xvY2soJnNlcC0+c2VwX2x1bi0+bHVuX3NlcF9sb2NrKTsKKwkJbnVtX2NtZHMgPSBzZXAtPnNlcF9zdGF0cy5jbWRfcGR1czsKKwkJcnhfbWJ5dGVzID0gKHNlcC0+c2VwX3N0YXRzLnJ4X2RhdGFfb2N0ZXRzID4+IDIwKTsKKwkJdHhfbWJ5dGVzID0gKHNlcC0+c2VwX3N0YXRzLnR4X2RhdGFfb2N0ZXRzID4+IDIwKTsKKwkJc3Bpbl91bmxvY2soJnNlcC0+c2VwX2x1bi0+bHVuX3NlcF9sb2NrKTsKKworCQlzZXFfcHJpbnRmKHNlcSwgIiVsbHUgJXUgJXUgJXVcbiIsIG51bV9jbWRzLAorCQkJcnhfbWJ5dGVzLCB0eF9tYnl0ZXMsIDApOworCX0KKwlzcGluX3VubG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc2VxX29wZXJhdGlvbnMgc2NzaV90Z3RfcG9ydF9zZXFfb3BzID0geworCS5zdGFydCAgPSBzY3NpX3RndF9wb3J0X3NlcV9zdGFydCwKKwkubmV4dCAgID0gc2NzaV90Z3RfcG9ydF9zZXFfbmV4dCwKKwkuc3RvcCAgID0gc2NzaV90Z3RfcG9ydF9zZXFfc3RvcCwKKwkuc2hvdyAgID0gc2NzaV90Z3RfcG9ydF9zZXFfc2hvdworfTsKKworc3RhdGljIGludCBzY3NpX3RndF9wb3J0X3NlcV9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQoreworCXJldHVybiBzZXFfb3BlbihmaWxlLCAmc2NzaV90Z3RfcG9ydF9zZXFfb3BzKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgc2NzaV90Z3RfcG9ydF9zZXFfZm9wcyA9IHsKKwkub3duZXIJID0gVEhJU19NT0RVTEUsCisJLm9wZW4JID0gc2NzaV90Z3RfcG9ydF9zZXFfb3BlbiwKKwkucmVhZAkgPSBzZXFfcmVhZCwKKwkubGxzZWVrCSA9IHNlcV9sc2VlaywKKwkucmVsZWFzZSA9IHNlcV9yZWxlYXNlLAorfTsKKworLyoKKyAqIFNDU0kgQXV0aG9yaXplZCBJbml0aWF0b3IgVGFibGU6CisgKiBJdCBjb250YWlucyB0aGUgU0NTSSBJbml0aWF0b3JzIGF1dGhvcml6ZWQgdG8gYmUgYXR0YWNoZWQgdG8gb25lIG9mIHRoZQorICogbG9jYWwgVGFyZ2V0IHBvcnRzLgorICogSXRlcmF0ZXMgdGhyb3VnaCBhbGwgYWN0aXZlIFRQR3MgYW5kIGV4dHJhY3RzIHRoZSBpbmZvIGZyb20gdGhlIEFDTHMKKyAqLworc3RhdGljIHZvaWQgKnNjc2lfYXV0aF9pbnRyX3NlcV9zdGFydChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgbG9mZl90ICpwb3MpCit7CisJc3Bpbl9sb2NrX2JoKCZzZV9nbG9iYWwtPnNlX3RwZ19sb2NrKTsKKwlyZXR1cm4gc2VxX2xpc3Rfc3RhcnQoJnNlX2dsb2JhbC0+Z19zZV90cGdfbGlzdCwgKnBvcyk7Cit9CisKK3N0YXRpYyB2b2lkICpzY3NpX2F1dGhfaW50cl9zZXFfbmV4dChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdiwKKwkJCQkJIGxvZmZfdCAqcG9zKQoreworCXJldHVybiBzZXFfbGlzdF9uZXh0KHYsICZzZV9nbG9iYWwtPmdfc2VfdHBnX2xpc3QsIHBvcyk7Cit9CisKK3N0YXRpYyB2b2lkIHNjc2lfYXV0aF9pbnRyX3NlcV9zdG9wKHN0cnVjdCBzZXFfZmlsZSAqc2VxLCB2b2lkICp2KQoreworCXNwaW5fdW5sb2NrX2JoKCZzZV9nbG9iYWwtPnNlX3RwZ19sb2NrKTsKK30KKworc3RhdGljIGludCBzY3NpX2F1dGhfaW50cl9zZXFfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdikKK3sKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcgPSBsaXN0X2VudHJ5KHYsIHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAsCisJCQkJCQlzZV90cGdfbGlzdCk7CisJc3RydWN0IHNlX2Rldl9lbnRyeSAqZGV2ZTsKKwlzdHJ1Y3Qgc2VfbHVuICpsdW47CisJc3RydWN0IHNlX25vZGVfYWNsICpzZV9uYWNsOworCWludCBqOworCisJaWYgKGxpc3RfaXNfZmlyc3QoJnNlX3RwZy0+c2VfdHBnX2xpc3QsCisJCQkgICZzZV9nbG9iYWwtPmdfc2VfdHBnX2xpc3QpKQorCQlzZXFfcHV0cyhzZXEsICJpbnN0IGRldiBwb3J0IGluZHggZGV2X29yX3BvcnQgaW50cl9uYW1lICIKKwkJCSAibWFwX2luZHggYXR0X2NvdW50IG51bV9jbWRzIHJlYWRfbWJ5dGVzICIKKwkJCSAid3JpdGVfbWJ5dGVzIGhzX251bV9jbWRzIGNyZWF0aW9uX3RpbWUgcm93X3N0YXR1c1xuIik7CisKKwlpZiAoIShzZV90cGcpKQorCQlyZXR1cm4gMDsKKworCXNwaW5fbG9jaygmc2VfdHBnLT5hY2xfbm9kZV9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHNlX25hY2wsICZzZV90cGctPmFjbF9ub2RlX2xpc3QsIGFjbF9saXN0KSB7CisKKwkJYXRvbWljX2luYygmc2VfbmFjbC0+bWliX3JlZl9jb3VudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2luYygpOworCQlzcGluX3VubG9jaygmc2VfdHBnLT5hY2xfbm9kZV9sb2NrKTsKKworCQlzcGluX2xvY2tfaXJxKCZzZV9uYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKwkJZm9yIChqID0gMDsgaiA8IFRSQU5TUE9SVF9NQVhfTFVOU19QRVJfVFBHOyBqKyspIHsKKwkJCWRldmUgPSAmc2VfbmFjbC0+ZGV2aWNlX2xpc3Rbal07CisJCQlpZiAoIShkZXZlLT5sdW5fZmxhZ3MgJgorCQkJCQlUUkFOU1BPUlRfTFVORkxBR1NfSU5JVElBVE9SX0FDQ0VTUykgfHwKKwkJCSAgICAoIWRldmUtPnNlX2x1bikpCisJCQkJY29udGludWU7CisJCQlsdW4gPSBkZXZlLT5zZV9sdW47CisJCQlpZiAoIWx1bi0+bHVuX3NlX2RldikKKwkJCQljb250aW51ZTsKKworCQkJc2VxX3ByaW50ZihzZXEsICIldSAldSAldSAldSAldSAlcyAldSAldSAldSAldSAldSAldSIKKwkJCQkJIiAldSAlc1xuIiwKKwkJCQkvKiBzY3NpSW5zdEluZGV4ICovCisJCQkJKFRQR19URk8oc2VfdHBnKS0+dHBnX2dldF9pbnN0X2luZGV4ICE9IE5VTEwpID8KKwkJCQlUUEdfVEZPKHNlX3RwZyktPnRwZ19nZXRfaW5zdF9pbmRleChzZV90cGcpIDoKKwkJCQkwLAorCQkJCS8qIHNjc2lEZXZpY2VJbmRleCAqLworCQkJCWx1bi0+bHVuX3NlX2Rldi0+ZGV2X2luZGV4LAorCQkJCS8qIHNjc2lBdXRoSW50clRndFBvcnRJbmRleCAqLworCQkJCVRQR19URk8oc2VfdHBnKS0+dHBnX2dldF90YWcoc2VfdHBnKSwKKwkJCQkvKiBzY3NpQXV0aEludHJJbmRleCAqLworCQkJCXNlX25hY2wtPmFjbF9pbmRleCwKKwkJCQkvKiBzY3NpQXV0aEludHJEZXZPclBvcnQgKi8KKwkJCQkxLAorCQkJCS8qIHNjc2lBdXRoSW50ck5hbWUgKi8KKwkJCQlzZV9uYWNsLT5pbml0aWF0b3JuYW1lWzBdID8KKwkJCQkJc2VfbmFjbC0+aW5pdGlhdG9ybmFtZSA6IE5PTkUsCisJCQkJLyogRklYTUU6IHNjc2lBdXRoSW50ckx1bk1hcEluZGV4ICovCisJCQkJMCwKKwkJCQkvKiBzY3NpQXV0aEludHJBdHRhY2hlZFRpbWVzICovCisJCQkJZGV2ZS0+YXR0YWNoX2NvdW50LAorCQkJCS8qIHNjc2lBdXRoSW50ck91dENvbW1hbmRzICovCisJCQkJZGV2ZS0+dG90YWxfY21kcywKKwkJCQkvKiBzY3NpQXV0aEludHJSZWFkTWVnYUJ5dGVzICovCisJCQkJKHUzMikoZGV2ZS0+cmVhZF9ieXRlcyA+PiAyMCksCisJCQkJLyogc2NzaUF1dGhJbnRyV3JpdHRlbk1lZ2FCeXRlcyAqLworCQkJCSh1MzIpKGRldmUtPndyaXRlX2J5dGVzID4+IDIwKSwKKwkJCQkvKiBGSVhNRTogc2NzaUF1dGhJbnRySFNPdXRDb21tYW5kcyAqLworCQkJCTAsCisJCQkJLyogc2NzaUF1dGhJbnRyTGFzdENyZWF0aW9uICovCisJCQkJKHUzMikoKCh1MzIpZGV2ZS0+Y3JlYXRpb25fdGltZSAtCisJCQkJCSAgICBJTklUSUFMX0pJRkZJRVMpICogMTAwIC8gSFopLAorCQkJCS8qIEZJWE1FOiBzY3NpQXV0aEludHJSb3dTdGF0dXMgKi8KKwkJCQkiUmVhZHkiKTsKKwkJfQorCQlzcGluX3VubG9ja19pcnEoJnNlX25hY2wtPmRldmljZV9saXN0X2xvY2spOworCisJCXNwaW5fbG9jaygmc2VfdHBnLT5hY2xfbm9kZV9sb2NrKTsKKwkJYXRvbWljX2RlYygmc2VfbmFjbC0+bWliX3JlZl9jb3VudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworCX0KKwlzcGluX3VubG9jaygmc2VfdHBnLT5hY2xfbm9kZV9sb2NrKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IHNlcV9vcGVyYXRpb25zIHNjc2lfYXV0aF9pbnRyX3NlcV9vcHMgPSB7CisJLnN0YXJ0CT0gc2NzaV9hdXRoX2ludHJfc2VxX3N0YXJ0LAorCS5uZXh0CT0gc2NzaV9hdXRoX2ludHJfc2VxX25leHQsCisJLnN0b3AJPSBzY3NpX2F1dGhfaW50cl9zZXFfc3RvcCwKKwkuc2hvdwk9IHNjc2lfYXV0aF9pbnRyX3NlcV9zaG93Cit9OworCitzdGF0aWMgaW50IHNjc2lfYXV0aF9pbnRyX3NlcV9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQoreworCXJldHVybiBzZXFfb3BlbihmaWxlLCAmc2NzaV9hdXRoX2ludHJfc2VxX29wcyk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHNjc2lfYXV0aF9pbnRyX3NlcV9mb3BzID0geworCS5vd25lcgkgPSBUSElTX01PRFVMRSwKKwkub3BlbgkgPSBzY3NpX2F1dGhfaW50cl9zZXFfb3BlbiwKKwkucmVhZAkgPSBzZXFfcmVhZCwKKwkubGxzZWVrCSA9IHNlcV9sc2VlaywKKwkucmVsZWFzZSA9IHNlcV9yZWxlYXNlLAorfTsKKworLyoKKyAqIFNDU0kgQXR0YWNoZWQgSW5pdGlhdG9yIFBvcnQgVGFibGU6CisgKiBJdCBsaXN0cyB0aGUgU0NTSSBJbml0aWF0b3JzIGF0dGFjaGVkIHRvIG9uZSBvZiB0aGUgbG9jYWwgVGFyZ2V0IHBvcnRzLgorICogSXRlcmF0ZXMgdGhyb3VnaCBhbGwgYWN0aXZlIFRQR3MgYW5kIHVzZSBhY3RpdmUgc2Vzc2lvbnMgZnJvbSBlYWNoIFRQRworICogdG8gbGlzdCB0aGUgaW5mbyBmbyB0aGlzIHRhYmxlLgorICovCitzdGF0aWMgdm9pZCAqc2NzaV9hdHRfaW50cl9wb3J0X3NlcV9zdGFydChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgbG9mZl90ICpwb3MpCit7CisJc3Bpbl9sb2NrX2JoKCZzZV9nbG9iYWwtPnNlX3RwZ19sb2NrKTsKKwlyZXR1cm4gc2VxX2xpc3Rfc3RhcnQoJnNlX2dsb2JhbC0+Z19zZV90cGdfbGlzdCwgKnBvcyk7Cit9CisKK3N0YXRpYyB2b2lkICpzY3NpX2F0dF9pbnRyX3BvcnRfc2VxX25leHQoc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYsCisJCQkJCSBsb2ZmX3QgKnBvcykKK3sKKwlyZXR1cm4gc2VxX2xpc3RfbmV4dCh2LCAmc2VfZ2xvYmFsLT5nX3NlX3RwZ19saXN0LCBwb3MpOworfQorCitzdGF0aWMgdm9pZCBzY3NpX2F0dF9pbnRyX3BvcnRfc2VxX3N0b3Aoc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYpCit7CisJc3Bpbl91bmxvY2tfYmgoJnNlX2dsb2JhbC0+c2VfdHBnX2xvY2spOworfQorCitzdGF0aWMgaW50IHNjc2lfYXR0X2ludHJfcG9ydF9zZXFfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdikKK3sKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcgPSBsaXN0X2VudHJ5KHYsIHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAsCisJCQkJCQlzZV90cGdfbGlzdCk7CisJc3RydWN0IHNlX2Rldl9lbnRyeSAqZGV2ZTsKKwlzdHJ1Y3Qgc2VfbHVuICpsdW47CisJc3RydWN0IHNlX25vZGVfYWNsICpzZV9uYWNsOworCXN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzOworCXVuc2lnbmVkIGNoYXIgYnVmWzY0XTsKKwlpbnQgajsKKworCWlmIChsaXN0X2lzX2ZpcnN0KCZzZV90cGctPnNlX3RwZ19saXN0LAorCQkJICAmc2VfZ2xvYmFsLT5nX3NlX3RwZ19saXN0KSkKKwkJc2VxX3B1dHMoc2VxLCAiaW5zdCBkZXYgcG9ydCBpbmR4IHBvcnRfYXV0aF9pbmR4IHBvcnRfbmFtZSIKKwkJCSIgcG9ydF9pZGVudFxuIik7CisKKwlpZiAoIShzZV90cGcpKQorCQlyZXR1cm4gMDsKKworCXNwaW5fbG9jaygmc2VfdHBnLT5zZXNzaW9uX2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnkoc2Vfc2VzcywgJnNlX3RwZy0+dHBnX3Nlc3NfbGlzdCwgc2Vzc19saXN0KSB7CisJCWlmICgoVFBHX1RGTyhzZV90cGcpLT5zZXNzX2xvZ2dlZF9pbihzZV9zZXNzKSkgfHwKKwkJICAgICghc2Vfc2Vzcy0+c2Vfbm9kZV9hY2wpIHx8CisJCSAgICAoIXNlX3Nlc3MtPnNlX25vZGVfYWNsLT5kZXZpY2VfbGlzdCkpCisJCQljb250aW51ZTsKKworCQlhdG9taWNfaW5jKCZzZV9zZXNzLT5taWJfcmVmX2NvdW50KTsKKwkJc21wX21iX19hZnRlcl9hdG9taWNfaW5jKCk7CisJCXNlX25hY2wgPSBzZV9zZXNzLT5zZV9ub2RlX2FjbDsKKwkJYXRvbWljX2luYygmc2VfbmFjbC0+bWliX3JlZl9jb3VudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2luYygpOworCQlzcGluX3VubG9jaygmc2VfdHBnLT5zZXNzaW9uX2xvY2spOworCisJCXNwaW5fbG9ja19pcnEoJnNlX25hY2wtPmRldmljZV9saXN0X2xvY2spOworCQlmb3IgKGogPSAwOyBqIDwgVFJBTlNQT1JUX01BWF9MVU5TX1BFUl9UUEc7IGorKykgeworCQkJZGV2ZSA9ICZzZV9uYWNsLT5kZXZpY2VfbGlzdFtqXTsKKwkJCWlmICghKGRldmUtPmx1bl9mbGFncyAmCisJCQkJCVRSQU5TUE9SVF9MVU5GTEFHU19JTklUSUFUT1JfQUNDRVNTKSB8fAorCQkJICAgKCFkZXZlLT5zZV9sdW4pKQorCQkJCWNvbnRpbnVlOworCisJCQlsdW4gPSBkZXZlLT5zZV9sdW47CisJCQlpZiAoIWx1bi0+bHVuX3NlX2RldikKKwkJCQljb250aW51ZTsKKworCQkJbWVtc2V0KGJ1ZiwgMCwgNjQpOworCQkJaWYgKFRQR19URk8oc2VfdHBnKS0+c2Vzc19nZXRfaW5pdGlhdG9yX3NpZCAhPSBOVUxMKQorCQkJCVRQR19URk8oc2VfdHBnKS0+c2Vzc19nZXRfaW5pdGlhdG9yX3NpZCgKKwkJCQkJc2Vfc2VzcywgKHVuc2lnbmVkIGNoYXIgKikmYnVmWzBdLCA2NCk7CisKKwkJCXNlcV9wcmludGYoc2VxLCAiJXUgJXUgJXUgJXUgJXUgJXMraSslc1xuIiwKKwkJCQkvKiBzY3NpSW5zdEluZGV4ICovCisJCQkJKFRQR19URk8oc2VfdHBnKS0+dHBnX2dldF9pbnN0X2luZGV4ICE9IE5VTEwpID8KKwkJCQlUUEdfVEZPKHNlX3RwZyktPnRwZ19nZXRfaW5zdF9pbmRleChzZV90cGcpIDoKKwkJCQkwLAorCQkJCS8qIHNjc2lEZXZpY2VJbmRleCAqLworCQkJCWx1bi0+bHVuX3NlX2Rldi0+ZGV2X2luZGV4LAorCQkJCS8qIHNjc2lQb3J0SW5kZXggKi8KKwkJCQlUUEdfVEZPKHNlX3RwZyktPnRwZ19nZXRfdGFnKHNlX3RwZyksCisJCQkJLyogc2NzaUF0dEludHJQb3J0SW5kZXggKi8KKwkJCQkoVFBHX1RGTyhzZV90cGcpLT5zZXNzX2dldF9pbmRleCAhPSBOVUxMKSA/CisJCQkJVFBHX1RGTyhzZV90cGcpLT5zZXNzX2dldF9pbmRleChzZV9zZXNzKSA6CisJCQkJMCwKKwkJCQkvKiBzY3NpQXR0SW50clBvcnRBdXRoSW50cklkeCAqLworCQkJCXNlX25hY2wtPmFjbF9pbmRleCwKKwkJCQkvKiBzY3NpQXR0SW50clBvcnROYW1lICovCisJCQkJc2VfbmFjbC0+aW5pdGlhdG9ybmFtZVswXSA/CisJCQkJCXNlX25hY2wtPmluaXRpYXRvcm5hbWUgOiBOT05FLAorCQkJCS8qIHNjc2lBdHRJbnRyUG9ydElkZW50aWZpZXIgKi8KKwkJCQlidWYpOworCQl9CisJCXNwaW5fdW5sb2NrX2lycSgmc2VfbmFjbC0+ZGV2aWNlX2xpc3RfbG9jayk7CisKKwkJc3Bpbl9sb2NrKCZzZV90cGctPnNlc3Npb25fbG9jayk7CisJCWF0b21pY19kZWMoJnNlX25hY2wtPm1pYl9yZWZfY291bnQpOworCQlzbXBfbWJfX2FmdGVyX2F0b21pY19kZWMoKTsKKwkJYXRvbWljX2RlYygmc2Vfc2Vzcy0+bWliX3JlZl9jb3VudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworCX0KKwlzcGluX3VubG9jaygmc2VfdHBnLT5zZXNzaW9uX2xvY2spOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc2VxX29wZXJhdGlvbnMgc2NzaV9hdHRfaW50cl9wb3J0X3NlcV9vcHMgPSB7CisJLnN0YXJ0CT0gc2NzaV9hdHRfaW50cl9wb3J0X3NlcV9zdGFydCwKKwkubmV4dAk9IHNjc2lfYXR0X2ludHJfcG9ydF9zZXFfbmV4dCwKKwkuc3RvcAk9IHNjc2lfYXR0X2ludHJfcG9ydF9zZXFfc3RvcCwKKwkuc2hvdwk9IHNjc2lfYXR0X2ludHJfcG9ydF9zZXFfc2hvdworfTsKKworc3RhdGljIGludCBzY3NpX2F0dF9pbnRyX3BvcnRfc2VxX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCit7CisJcmV0dXJuIHNlcV9vcGVuKGZpbGUsICZzY3NpX2F0dF9pbnRyX3BvcnRfc2VxX29wcyk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHNjc2lfYXR0X2ludHJfcG9ydF9zZXFfZm9wcyA9IHsKKwkub3duZXIJID0gVEhJU19NT0RVTEUsCisJLm9wZW4JID0gc2NzaV9hdHRfaW50cl9wb3J0X3NlcV9vcGVuLAorCS5yZWFkCSA9IHNlcV9yZWFkLAorCS5sbHNlZWsJID0gc2VxX2xzZWVrLAorCS5yZWxlYXNlID0gc2VxX3JlbGVhc2UsCit9OworCisvKgorICogU0NTSSBMb2dpY2FsIFVuaXQgVGFibGUKKyAqLworc3RhdGljIHZvaWQgKnNjc2lfbHVfc2VxX3N0YXJ0KHN0cnVjdCBzZXFfZmlsZSAqc2VxLCBsb2ZmX3QgKnBvcykKK3sKKwlyZXR1cm4gbG9jYXRlX2hiYV9zdGFydChzZXEsIHBvcyk7Cit9CisKK3N0YXRpYyB2b2lkICpzY3NpX2x1X3NlcV9uZXh0KHN0cnVjdCBzZXFfZmlsZSAqc2VxLCB2b2lkICp2LCBsb2ZmX3QgKnBvcykKK3sKKwlyZXR1cm4gbG9jYXRlX2hiYV9uZXh0KHNlcSwgdiwgcG9zKTsKK30KKworc3RhdGljIHZvaWQgc2NzaV9sdV9zZXFfc3RvcChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdikKK3sKKwlsb2NhdGVfaGJhX3N0b3Aoc2VxLCB2KTsKK30KKworI2RlZmluZSBTQ1NJX0xVX0lOREVYCQkxCitzdGF0aWMgaW50IHNjc2lfbHVfc2VxX3Nob3coc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYpCit7CisJc3RydWN0IHNlX2hiYSAqaGJhOworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzZV9kZXYgPSBsaXN0X2VudHJ5KHYsIHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2LAorCQkJCQkJZ19zZV9kZXZfbGlzdCk7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gc2VfZGV2LT5zZV9kZXZfcHRyOworCWludCBqOworCWNoYXIgc3RyWzI4XTsKKworCWlmIChsaXN0X2lzX2ZpcnN0KCZzZV9kZXYtPmdfc2VfZGV2X2xpc3QsICZzZV9nbG9iYWwtPmdfc2VfZGV2X2xpc3QpKQorCQlzZXFfcHV0cyhzZXEsICJpbnN0IGRldiBpbmR4IExVTiBsdV9uYW1lIHZlbmQgcHJvZCByZXYiCisJCSIgZGV2X3R5cGUgc3RhdHVzIHN0YXRlLWJpdCBudW1fY21kcyByZWFkX21ieXRlcyIKKwkJIiB3cml0ZV9tYnl0ZXMgcmVzZXRzIGZ1bGxfc3RhdCBoc19udW1fY21kcyBjcmVhdGlvbl90aW1lXG4iKTsKKworCWlmICghKGRldikpCisJCXJldHVybiAwOworCisJaGJhID0gZGV2LT5zZV9oYmE7CisJaWYgKCEoaGJhKSkgeworCQkvKiBMb2cgZXJyb3IgPyAqLworCQlyZXR1cm4gMDsKKwl9CisKKwkvKiBGaXggTFUgc3RhdGUsIGlmIHdlIGNhbiByZWFkIGl0IGZyb20gdGhlIGRldmljZSAqLworCXNlcV9wcmludGYoc2VxLCAiJXUgJXUgJXUgJWxsdSAlcyIsIGhiYS0+aGJhX2luZGV4LAorCQkJZGV2LT5kZXZfaW5kZXgsIFNDU0lfTFVfSU5ERVgsCisJCQkodW5zaWduZWQgbG9uZyBsb25nKTAsIC8qIEZJWE1FOiBzY3NpTHVEZWZhdWx0THVuICovCisJCQkoc3RybGVuKERFVl9UMTBfV1dOKGRldiktPnVuaXRfc2VyaWFsKSkgPworCQkJLyogc2NzaUx1V3duTmFtZSAqLworCQkJKGNoYXIgKikmREVWX1QxMF9XV04oZGV2KS0+dW5pdF9zZXJpYWxbMF0gOgorCQkJIk5vbmUiKTsKKworCW1lbWNweSgmc3RyWzBdLCAodm9pZCAqKURFVl9UMTBfV1dOKGRldiksIDI4KTsKKwkvKiBzY3NpTHVWZW5kb3JJZCAqLworCWZvciAoaiA9IDA7IGogPCA4OyBqKyspCisJCXN0cltqXSA9IElTUFJJTlQoREVWX1QxMF9XV04oZGV2KS0+dmVuZG9yW2pdKSA/CisJCQlERVZfVDEwX1dXTihkZXYpLT52ZW5kb3Jbal0gOiAweDIwOworCXN0cls4XSA9IDA7CisJc2VxX3ByaW50ZihzZXEsICIgJXMiLCBzdHIpOworCisJLyogc2NzaUx1UHJvZHVjdElkICovCisJZm9yIChqID0gMDsgaiA8IDE2OyBqKyspCisJCXN0cltqXSA9IElTUFJJTlQoREVWX1QxMF9XV04oZGV2KS0+bW9kZWxbal0pID8KKwkJCURFVl9UMTBfV1dOKGRldiktPm1vZGVsW2pdIDogMHgyMDsKKwlzdHJbMTZdID0gMDsKKwlzZXFfcHJpbnRmKHNlcSwgIiAlcyIsIHN0cik7CisKKwkvKiBzY3NpTHVSZXZpc2lvbklkICovCisJZm9yIChqID0gMDsgaiA8IDQ7IGorKykKKwkJc3RyW2pdID0gSVNQUklOVChERVZfVDEwX1dXTihkZXYpLT5yZXZpc2lvbltqXSkgPworCQkJREVWX1QxMF9XV04oZGV2KS0+cmV2aXNpb25bal0gOiAweDIwOworCXN0cls0XSA9IDA7CisJc2VxX3ByaW50ZihzZXEsICIgJXMiLCBzdHIpOworCisJc2VxX3ByaW50ZihzZXEsICIgJXUgJXMgJXMgJWxsdSAldSAldSAldSAldSAldSAldVxuIiwKKwkJLyogc2NzaUx1UGVyaXBoZXJhbFR5cGUgKi8KKwkJICAgVFJBTlNQT1JUKGRldiktPmdldF9kZXZpY2VfdHlwZShkZXYpLAorCQkgICAoZGV2LT5kZXZfc3RhdHVzID09IFRSQU5TUE9SVF9ERVZJQ0VfQUNUSVZBVEVEKSA/CisJCSJhdmFpbGFibGUiIDogIm5vdGF2YWlsYWJsZSIsIC8qIHNjc2lMdVN0YXR1cyAqLworCQkiZXhwb3NlZCIsIAkvKiBzY3NpTHVTdGF0ZSAqLworCQkodW5zaWduZWQgbG9uZyBsb25nKWRldi0+bnVtX2NtZHMsCisJCS8qIHNjc2lMdVJlYWRNZWdhQnl0ZXMgKi8KKwkJKHUzMikoZGV2LT5yZWFkX2J5dGVzID4+IDIwKSwKKwkJLyogc2NzaUx1V3JpdHRlbk1lZ2FCeXRlcyAqLworCQkodTMyKShkZXYtPndyaXRlX2J5dGVzID4+IDIwKSwKKwkJZGV2LT5udW1fcmVzZXRzLCAvKiBzY3NpTHVJblJlc2V0cyAqLworCQkwLCAvKiBzY3NpTHVPdXRUYXNrU2V0RnVsbFN0YXR1cyAqLworCQkwLCAvKiBzY3NpTHVIU0luQ29tbWFuZHMgKi8KKwkJKHUzMikoKCh1MzIpZGV2LT5jcmVhdGlvbl90aW1lIC0gSU5JVElBTF9KSUZGSUVTKSAqCisJCQkJCQkJMTAwIC8gSFopKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IHNlcV9vcGVyYXRpb25zIHNjc2lfbHVfc2VxX29wcyA9IHsKKwkuc3RhcnQgID0gc2NzaV9sdV9zZXFfc3RhcnQsCisJLm5leHQgICA9IHNjc2lfbHVfc2VxX25leHQsCisJLnN0b3AgICA9IHNjc2lfbHVfc2VxX3N0b3AsCisJLnNob3cgICA9IHNjc2lfbHVfc2VxX3Nob3cKK307CisKK3N0YXRpYyBpbnQgc2NzaV9sdV9zZXFfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKK3sKKwlyZXR1cm4gc2VxX29wZW4oZmlsZSwgJnNjc2lfbHVfc2VxX29wcyk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHNjc2lfbHVfc2VxX2ZvcHMgPSB7CisJLm93bmVyCSA9IFRISVNfTU9EVUxFLAorCS5vcGVuCSA9IHNjc2lfbHVfc2VxX29wZW4sCisJLnJlYWQJID0gc2VxX3JlYWQsCisJLmxsc2VlawkgPSBzZXFfbHNlZWssCisJLnJlbGVhc2UgPSBzZXFfcmVsZWFzZSwKK307CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisvKgorICogUmVtb3ZlIHByb2MgZnMgZW50cmllcworICovCit2b2lkIHJlbW92ZV9zY3NpX3RhcmdldF9taWIodm9pZCkKK3sKKwlyZW1vdmVfcHJvY19lbnRyeSgic2NzaV90YXJnZXQvbWliL3Njc2lfaW5zdCIsIE5VTEwpOworCXJlbW92ZV9wcm9jX2VudHJ5KCJzY3NpX3RhcmdldC9taWIvc2NzaV9kZXYiLCBOVUxMKTsKKwlyZW1vdmVfcHJvY19lbnRyeSgic2NzaV90YXJnZXQvbWliL3Njc2lfcG9ydCIsIE5VTEwpOworCXJlbW92ZV9wcm9jX2VudHJ5KCJzY3NpX3RhcmdldC9taWIvc2NzaV90cmFuc3BvcnQiLCBOVUxMKTsKKwlyZW1vdmVfcHJvY19lbnRyeSgic2NzaV90YXJnZXQvbWliL3Njc2lfdGd0X2RldiIsIE5VTEwpOworCXJlbW92ZV9wcm9jX2VudHJ5KCJzY3NpX3RhcmdldC9taWIvc2NzaV90Z3RfcG9ydCIsIE5VTEwpOworCXJlbW92ZV9wcm9jX2VudHJ5KCJzY3NpX3RhcmdldC9taWIvc2NzaV9hdXRoX2ludHIiLCBOVUxMKTsKKwlyZW1vdmVfcHJvY19lbnRyeSgic2NzaV90YXJnZXQvbWliL3Njc2lfYXR0X2ludHJfcG9ydCIsIE5VTEwpOworCXJlbW92ZV9wcm9jX2VudHJ5KCJzY3NpX3RhcmdldC9taWIvc2NzaV9sdSIsIE5VTEwpOworCXJlbW92ZV9wcm9jX2VudHJ5KCJzY3NpX3RhcmdldC9taWIiLCBOVUxMKTsKK30KKworLyoKKyAqIENyZWF0ZSBwcm9jIGZzIGVudHJpZXMgZm9yIHRoZSBtaWIgdGFibGVzCisgKi8KK2ludCBpbml0X3Njc2lfdGFyZ2V0X21pYih2b2lkKQoreworCXN0cnVjdCBwcm9jX2Rpcl9lbnRyeSAqZGlyX2VudHJ5OworCXN0cnVjdCBwcm9jX2Rpcl9lbnRyeSAqc2NzaV9pbnN0X2VudHJ5OworCXN0cnVjdCBwcm9jX2Rpcl9lbnRyeSAqc2NzaV9kZXZfZW50cnk7CisJc3RydWN0IHByb2NfZGlyX2VudHJ5ICpzY3NpX3BvcnRfZW50cnk7CisJc3RydWN0IHByb2NfZGlyX2VudHJ5ICpzY3NpX3RyYW5zcG9ydF9lbnRyeTsKKwlzdHJ1Y3QgcHJvY19kaXJfZW50cnkgKnNjc2lfdGd0X2Rldl9lbnRyeTsKKwlzdHJ1Y3QgcHJvY19kaXJfZW50cnkgKnNjc2lfdGd0X3BvcnRfZW50cnk7CisJc3RydWN0IHByb2NfZGlyX2VudHJ5ICpzY3NpX2F1dGhfaW50cl9lbnRyeTsKKwlzdHJ1Y3QgcHJvY19kaXJfZW50cnkgKnNjc2lfYXR0X2ludHJfcG9ydF9lbnRyeTsKKwlzdHJ1Y3QgcHJvY19kaXJfZW50cnkgKnNjc2lfbHVfZW50cnk7CisKKwlkaXJfZW50cnkgPSBwcm9jX21rZGlyKCJzY3NpX3RhcmdldC9taWIiLCBOVUxMKTsKKwlpZiAoIShkaXJfZW50cnkpKSB7CisJCXByaW50ayhLRVJOX0VSUiAicHJvY19ta2RpcigpIGZhaWxlZC5cbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJc2NzaV9pbnN0X2VudHJ5ID0KKwkJY3JlYXRlX3Byb2NfZW50cnkoInNjc2lfdGFyZ2V0L21pYi9zY3NpX2luc3QiLCAwLCBOVUxMKTsKKwlpZiAoc2NzaV9pbnN0X2VudHJ5KQorCQlzY3NpX2luc3RfZW50cnktPnByb2NfZm9wcyA9ICZzY3NpX2luc3Rfc2VxX2ZvcHM7CisJZWxzZQorCQlnb3RvIGVycm9yOworCisJc2NzaV9kZXZfZW50cnkgPQorCQljcmVhdGVfcHJvY19lbnRyeSgic2NzaV90YXJnZXQvbWliL3Njc2lfZGV2IiwgMCwgTlVMTCk7CisJaWYgKHNjc2lfZGV2X2VudHJ5KQorCQlzY3NpX2Rldl9lbnRyeS0+cHJvY19mb3BzID0gJnNjc2lfZGV2X3NlcV9mb3BzOworCWVsc2UKKwkJZ290byBlcnJvcjsKKworCXNjc2lfcG9ydF9lbnRyeSA9CisJCWNyZWF0ZV9wcm9jX2VudHJ5KCJzY3NpX3RhcmdldC9taWIvc2NzaV9wb3J0IiwgMCwgTlVMTCk7CisJaWYgKHNjc2lfcG9ydF9lbnRyeSkKKwkJc2NzaV9wb3J0X2VudHJ5LT5wcm9jX2ZvcHMgPSAmc2NzaV9wb3J0X3NlcV9mb3BzOworCWVsc2UKKwkJZ290byBlcnJvcjsKKworCXNjc2lfdHJhbnNwb3J0X2VudHJ5ID0KKwkJY3JlYXRlX3Byb2NfZW50cnkoInNjc2lfdGFyZ2V0L21pYi9zY3NpX3RyYW5zcG9ydCIsIDAsIE5VTEwpOworCWlmIChzY3NpX3RyYW5zcG9ydF9lbnRyeSkKKwkJc2NzaV90cmFuc3BvcnRfZW50cnktPnByb2NfZm9wcyA9ICZzY3NpX3RyYW5zcG9ydF9zZXFfZm9wczsKKwllbHNlCisJCWdvdG8gZXJyb3I7CisKKwlzY3NpX3RndF9kZXZfZW50cnkgPQorCQljcmVhdGVfcHJvY19lbnRyeSgic2NzaV90YXJnZXQvbWliL3Njc2lfdGd0X2RldiIsIDAsIE5VTEwpOworCWlmIChzY3NpX3RndF9kZXZfZW50cnkpCisJCXNjc2lfdGd0X2Rldl9lbnRyeS0+cHJvY19mb3BzID0gJnNjc2lfdGd0X2Rldl9zZXFfZm9wczsKKwllbHNlCisJCWdvdG8gZXJyb3I7CisKKwlzY3NpX3RndF9wb3J0X2VudHJ5ID0KKwkJY3JlYXRlX3Byb2NfZW50cnkoInNjc2lfdGFyZ2V0L21pYi9zY3NpX3RndF9wb3J0IiwgMCwgTlVMTCk7CisJaWYgKHNjc2lfdGd0X3BvcnRfZW50cnkpCisJCXNjc2lfdGd0X3BvcnRfZW50cnktPnByb2NfZm9wcyA9ICZzY3NpX3RndF9wb3J0X3NlcV9mb3BzOworCWVsc2UKKwkJZ290byBlcnJvcjsKKworCXNjc2lfYXV0aF9pbnRyX2VudHJ5ID0KKwkJY3JlYXRlX3Byb2NfZW50cnkoInNjc2lfdGFyZ2V0L21pYi9zY3NpX2F1dGhfaW50ciIsIDAsIE5VTEwpOworCWlmIChzY3NpX2F1dGhfaW50cl9lbnRyeSkKKwkJc2NzaV9hdXRoX2ludHJfZW50cnktPnByb2NfZm9wcyA9ICZzY3NpX2F1dGhfaW50cl9zZXFfZm9wczsKKwllbHNlCisJCWdvdG8gZXJyb3I7CisKKwlzY3NpX2F0dF9pbnRyX3BvcnRfZW50cnkgPQorCSAgICAgIGNyZWF0ZV9wcm9jX2VudHJ5KCJzY3NpX3RhcmdldC9taWIvc2NzaV9hdHRfaW50cl9wb3J0IiwgMCwgTlVMTCk7CisJaWYgKHNjc2lfYXR0X2ludHJfcG9ydF9lbnRyeSkKKwkJc2NzaV9hdHRfaW50cl9wb3J0X2VudHJ5LT5wcm9jX2ZvcHMgPQorCQkJCSZzY3NpX2F0dF9pbnRyX3BvcnRfc2VxX2ZvcHM7CisJZWxzZQorCQlnb3RvIGVycm9yOworCisJc2NzaV9sdV9lbnRyeSA9IGNyZWF0ZV9wcm9jX2VudHJ5KCJzY3NpX3RhcmdldC9taWIvc2NzaV9sdSIsIDAsIE5VTEwpOworCWlmIChzY3NpX2x1X2VudHJ5KQorCQlzY3NpX2x1X2VudHJ5LT5wcm9jX2ZvcHMgPSAmc2NzaV9sdV9zZXFfZm9wczsKKwllbHNlCisJCWdvdG8gZXJyb3I7CisKKwlyZXR1cm4gMDsKKworZXJyb3I6CisJcHJpbnRrKEtFUk5fRVJSICJjcmVhdGVfcHJvY19lbnRyeSgpIGZhaWxlZC5cbiIpOworCXJlbW92ZV9zY3NpX3RhcmdldF9taWIoKTsKKwlyZXR1cm4gLTE7Cit9CisKKy8qCisgKiBJbml0aWFsaXplIHRoZSBpbmRleCB0YWJsZSBmb3IgYWxsb2NhdGluZyB1bmlxdWUgcm93IGluZGV4ZXMgdG8gdmFyaW91cyBtaWIKKyAqIHRhYmxlcworICovCit2b2lkIGluaXRfc2NzaV9pbmRleF90YWJsZSh2b2lkKQoreworCW1lbXNldCgmc2NzaV9pbmRleF90YWJsZSwgMCwgc2l6ZW9mKHN0cnVjdCBzY3NpX2luZGV4X3RhYmxlKSk7CisJc3Bpbl9sb2NrX2luaXQoJnNjc2lfaW5kZXhfdGFibGUubG9jayk7Cit9CisKKy8qCisgKiBBbGxvY2F0ZSBhIG5ldyByb3cgaW5kZXggZm9yIHRoZSBlbnRyeSB0eXBlIHNwZWNpZmllZAorICovCit1MzIgc2NzaV9nZXRfbmV3X2luZGV4KHNjc2lfaW5kZXhfdCB0eXBlKQoreworCXUzMiBuZXdfaW5kZXg7CisKKwlpZiAoKHR5cGUgPCAwKSB8fCAodHlwZSA+PSBTQ1NJX0lOREVYX1RZUEVfTUFYKSkgeworCQlwcmludGsoS0VSTl9FUlIgIkludmFsaWQgaW5kZXggdHlwZSAlZFxuIiwgdHlwZSk7CisJCXJldHVybiAtMTsKKwl9CisKKwlzcGluX2xvY2soJnNjc2lfaW5kZXhfdGFibGUubG9jayk7CisJbmV3X2luZGV4ID0gKytzY3NpX2luZGV4X3RhYmxlLnNjc2lfbWliX2luZGV4W3R5cGVdOworCWlmIChuZXdfaW5kZXggPT0gMCkKKwkJbmV3X2luZGV4ID0gKytzY3NpX2luZGV4X3RhYmxlLnNjc2lfbWliX2luZGV4W3R5cGVdOworCXNwaW5fdW5sb2NrKCZzY3NpX2luZGV4X3RhYmxlLmxvY2spOworCisJcmV0dXJuIG5ld19pbmRleDsKK30KK0VYUE9SVF9TWU1CT0woc2NzaV9nZXRfbmV3X2luZGV4KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX21pYi5oIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfbWliLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjc3MjA0NgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX21pYi5oCkBAIC0wLDAgKzEsMjggQEAKKyNpZm5kZWYgVEFSR0VUX0NPUkVfTUlCX0gKKyNkZWZpbmUgVEFSR0VUX0NPUkVfTUlCX0gKKwordHlwZWRlZiBlbnVtIHsKKwlTQ1NJX0lOU1RfSU5ERVgsCisJU0NTSV9ERVZJQ0VfSU5ERVgsCisJU0NTSV9BVVRIX0lOVFJfSU5ERVgsCisJU0NTSV9JTkRFWF9UWVBFX01BWAorfSBzY3NpX2luZGV4X3Q7CisKK3N0cnVjdCBzY3NpX2luZGV4X3RhYmxlIHsKKwlzcGlubG9ja190CWxvY2s7CisJdTMyIAkJc2NzaV9taWJfaW5kZXhbU0NTSV9JTkRFWF9UWVBFX01BWF07Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworLyogU0NTSSBQb3J0IHN0YXRzICovCitzdHJ1Y3Qgc2NzaV9wb3J0X3N0YXRzIHsKKwl1NjQJY21kX3BkdXM7CisJdTY0CXR4X2RhdGFfb2N0ZXRzOworCXU2NAlyeF9kYXRhX29jdGV0czsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCitleHRlcm4gaW50IGluaXRfc2NzaV90YXJnZXRfbWliKHZvaWQpOworZXh0ZXJuIHZvaWQgcmVtb3ZlX3Njc2lfdGFyZ2V0X21pYih2b2lkKTsKK2V4dGVybiB2b2lkIGluaXRfc2NzaV9pbmRleF90YWJsZSh2b2lkKTsKK2V4dGVybiB1MzIgc2NzaV9nZXRfbmV3X2luZGV4KHNjc2lfaW5kZXhfdCk7CisKKyNlbmRpZiAgIC8qKiogVEFSR0VUX0NPUkVfTUlCX0ggKioqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfcHIuYyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX3ByLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjUyMWY3NQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX3ByLmMKQEAgLTAsMCArMSw0MjUyIEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogRmlsZW5hbWU6ICB0YXJnZXRfY29yZV9wci5jCisgKgorICogVGhpcyBmaWxlIGNvbnRhaW5zIFNQQy0zIGNvbXBsaWFudCBwZXJzaXN0ZW50IHJlc2VydmF0aW9ucyBhbmQKKyAqIGxlZ2FjeSBTUEMtMiByZXNlcnZhdGlvbnMgd2l0aCBjb21wYXRpYmxlIHJlc2VydmF0aW9uIGhhbmRsaW5nIChDUkg9MSkKKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMDksIDIwMTAgUmlzaW5nIFRpZGUgU3lzdGVtcworICogQ29weXJpZ2h0IChjKSAyMDA5LCAyMDEwIExpbnV4LWlTQ1NJLm9yZworICoKKyAqIE5pY2hvbGFzIEEuIEJlbGxpbmdlciA8bmFiQGtlcm5lbC5vcmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisjaW5jbHVkZSA8bGludXgvdmVyc2lvbi5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgorI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2kuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2lfY21uZC5oPgorI2luY2x1ZGUgPGFzbS91bmFsaWduZWQuaD4KKworI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9iYXNlLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV90bXIuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdHBnLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX3RyYW5zcG9ydC5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfb3BzLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2NvbmZpZ2ZzLmg+CisKKyNpbmNsdWRlICJ0YXJnZXRfY29yZV9oYmEuaCIKKyNpbmNsdWRlICJ0YXJnZXRfY29yZV9wci5oIgorI2luY2x1ZGUgInRhcmdldF9jb3JlX3VhLmgiCisKKy8qCisgKiBVc2VkIGZvciBTcGVjaWZ5IEluaXRpYXRvciBQb3J0cyBDYXBhYmxlIEJpdCAoU1BFQ19JX1BUKQorICovCitzdHJ1Y3QgcHJfdHJhbnNwb3J0X2lkX2hvbGRlciB7CisJaW50IGRlc3RfbG9jYWxfbmV4dXM7CisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKmRlc3RfcHJfcmVnOworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKmRlc3RfdHBnOworCXN0cnVjdCBzZV9ub2RlX2FjbCAqZGVzdF9ub2RlX2FjbDsKKwlzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICpkZXN0X3NlX2RldmU7CisJc3RydWN0IGxpc3RfaGVhZCBkZXN0X2xpc3Q7Cit9OworCitpbnQgY29yZV9wcl9kdW1wX2luaXRpYXRvcl9wb3J0KAorCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsCisJY2hhciAqYnVmLAorCXUzMiBzaXplKQoreworCWlmICghKHByX3JlZy0+aXNpZF9wcmVzZW50X2F0X3JlZykpCisJCXJldHVybiAwOworCisJc25wcmludGYoYnVmLCBzaXplLCAiLGksMHglcyIsICZwcl9yZWctPnByX3JlZ19pc2lkWzBdKTsKKwlyZXR1cm4gMTsKK30KKworc3RhdGljIHZvaWQgX19jb3JlX3Njc2kzX2NvbXBsZXRlX3Byb19yZWxlYXNlKHN0cnVjdCBzZV9kZXZpY2UgKiwgc3RydWN0IHNlX25vZGVfYWNsICosCisJCQlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqLCBpbnQpOworCitzdGF0aWMgaW50IGNvcmVfc2NzaTJfcmVzZXJ2YXRpb25fc2VxX25vbl9ob2xkZXIoCisJc3RydWN0IHNlX2NtZCAqY21kLAorCXVuc2lnbmVkIGNoYXIgKmNkYiwKKwl1MzIgcHJfcmVnX3R5cGUpCit7CisJc3dpdGNoIChjZGJbMF0pIHsKKwljYXNlIElOUVVJUlk6CisJY2FzZSBSRUxFQVNFOgorCWNhc2UgUkVMRUFTRV8xMDoKKwkJcmV0dXJuIDA7CisJZGVmYXVsdDoKKwkJcmV0dXJuIDE7CisJfQorCisJcmV0dXJuIDE7Cit9CisKK3N0YXRpYyBpbnQgY29yZV9zY3NpMl9yZXNlcnZhdGlvbl9jaGVjayhzdHJ1Y3Qgc2VfY21kICpjbWQsIHUzMiAqcHJfcmVnX3R5cGUpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gY21kLT5zZV9kZXY7CisJc3RydWN0IHNlX3Nlc3Npb24gKnNlc3MgPSBjbWQtPnNlX3Nlc3M7CisJaW50IHJldDsKKworCWlmICghKHNlc3MpKQorCQlyZXR1cm4gMDsKKworCXNwaW5fbG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJaWYgKCFkZXYtPmRldl9yZXNlcnZlZF9ub2RlX2FjbCB8fCAhc2VzcykgeworCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCXJldHVybiAwOworCX0KKwlpZiAoZGV2LT5kZXZfcmVzZXJ2ZWRfbm9kZV9hY2wgIT0gc2Vzcy0+c2Vfbm9kZV9hY2wpIHsKKwkJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCQlyZXR1cm4gLTE7CisJfQorCWlmICghKGRldi0+ZGV2X2ZsYWdzICYgREZfU1BDMl9SRVNFUlZBVElPTlNfV0lUSF9JU0lEKSkgeworCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCXJldHVybiAwOworCX0KKwlyZXQgPSAoZGV2LT5kZXZfcmVzX2Jpbl9pc2lkID09IHNlc3MtPnNlc3NfYmluX2lzaWQpID8gMCA6IC0xOworCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgY29yZV9zY3NpMl9yZXNlcnZhdGlvbl9yZWxlYXNlKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBjbWQtPnNlX2RldjsKKwlzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqc2VzcyA9IGNtZC0+c2Vfc2VzczsKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcgPSBzZXNzLT5zZV90cGc7CisKKwlpZiAoIShzZXNzKSB8fCAhKHRwZykpCisJCXJldHVybiAwOworCisJc3Bpbl9sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwlpZiAoIWRldi0+ZGV2X3Jlc2VydmVkX25vZGVfYWNsIHx8ICFzZXNzKSB7CisJCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwkJcmV0dXJuIDA7CisJfQorCisJaWYgKGRldi0+ZGV2X3Jlc2VydmVkX25vZGVfYWNsICE9IHNlc3MtPnNlX25vZGVfYWNsKSB7CisJCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwkJcmV0dXJuIDA7CisJfQorCWRldi0+ZGV2X3Jlc2VydmVkX25vZGVfYWNsID0gTlVMTDsKKwlkZXYtPmRldl9mbGFncyAmPSB+REZfU1BDMl9SRVNFUlZBVElPTlM7CisJaWYgKGRldi0+ZGV2X2ZsYWdzICYgREZfU1BDMl9SRVNFUlZBVElPTlNfV0lUSF9JU0lEKSB7CisJCWRldi0+ZGV2X3Jlc19iaW5faXNpZCA9IDA7CisJCWRldi0+ZGV2X2ZsYWdzICY9IH5ERl9TUEMyX1JFU0VSVkFUSU9OU19XSVRIX0lTSUQ7CisJfQorCXByaW50ayhLRVJOX0lORk8gIlNDU0ktMiBSZWxlYXNlZCByZXNlcnZhdGlvbiBmb3IgJXMgTFVOOiAldSAtPiIKKwkJIiBNQVBQRUQgTFVOOiAldSBmb3IgJXNcbiIsIFRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCVNFX0xVTihjbWQpLT51bnBhY2tlZF9sdW4sIGNtZC0+c2VfZGV2ZS0+bWFwcGVkX2x1biwKKwkJc2Vzcy0+c2Vfbm9kZV9hY2wtPmluaXRpYXRvcm5hbWUpOworCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGNvcmVfc2NzaTJfcmVzZXJ2YXRpb25fcmVzZXJ2ZShzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gY21kLT5zZV9kZXY7CisJc3RydWN0IHNlX3Nlc3Npb24gKnNlc3MgPSBjbWQtPnNlX3Nlc3M7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnID0gc2Vzcy0+c2VfdHBnOworCisJaWYgKChUX1RBU0soY21kKS0+dF90YXNrX2NkYlsxXSAmIDB4MDEpICYmCisJICAgIChUX1RBU0soY21kKS0+dF90YXNrX2NkYlsxXSAmIDB4MDIpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiTG9uZ0lPIGFuZCBPYnNlbGV0ZSBCaXRzIHNldCwgcmV0dXJuaW5nIgorCQkJCSIgSUxMRUdBTF9SRVFVRVNUXG4iKTsKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfSUxMRUdBTF9SRVFVRVNUOworCX0KKwkvKgorCSAqIFRoaXMgaXMgY3VycmVudGx5IHRoZSBjYXNlIGZvciB0YXJnZXRfY29yZV9tb2QgcGFzc3Rocm91Z2ggc3RydWN0IHNlX2NtZAorCSAqIG9wcworCSAqLworCWlmICghKHNlc3MpIHx8ICEodHBnKSkKKwkJcmV0dXJuIDA7CisKKwlzcGluX2xvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCWlmIChkZXYtPmRldl9yZXNlcnZlZF9ub2RlX2FjbCAmJgorCSAgIChkZXYtPmRldl9yZXNlcnZlZF9ub2RlX2FjbCAhPSBzZXNzLT5zZV9ub2RlX2FjbCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJTQ1NJLTIgUkVTRVJWQVRJT04gQ09ORkxJRlQgZm9yICVzIGZhYnJpY1xuIiwKKwkJCVRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCkpOworCQlwcmludGsoS0VSTl9FUlIgIk9yaWdpbmFsIHJlc2VydmVyIExVTjogJXUgJXNcbiIsCisJCQlTRV9MVU4oY21kKS0+dW5wYWNrZWRfbHVuLAorCQkJZGV2LT5kZXZfcmVzZXJ2ZWRfbm9kZV9hY2wtPmluaXRpYXRvcm5hbWUpOworCQlwcmludGsoS0VSTl9FUlIgIkN1cnJlbnQgYXR0ZW1wdCAtIExVTjogJXUgLT4gTUFQUEVEIExVTjogJXUiCisJCQkiIGZyb20gJXMgXG4iLCBTRV9MVU4oY21kKS0+dW5wYWNrZWRfbHVuLAorCQkJY21kLT5zZV9kZXZlLT5tYXBwZWRfbHVuLAorCQkJc2Vzcy0+c2Vfbm9kZV9hY2wtPmluaXRpYXRvcm5hbWUpOworCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX1JFU0VSVkFUSU9OX0NPTkZMSUNUOworCX0KKworCWRldi0+ZGV2X3Jlc2VydmVkX25vZGVfYWNsID0gc2Vzcy0+c2Vfbm9kZV9hY2w7CisJZGV2LT5kZXZfZmxhZ3MgfD0gREZfU1BDMl9SRVNFUlZBVElPTlM7CisJaWYgKHNlc3MtPnNlc3NfYmluX2lzaWQgIT0gMCkgeworCQlkZXYtPmRldl9yZXNfYmluX2lzaWQgPSBzZXNzLT5zZXNzX2Jpbl9pc2lkOworCQlkZXYtPmRldl9mbGFncyB8PSBERl9TUEMyX1JFU0VSVkFUSU9OU19XSVRIX0lTSUQ7CisJfQorCXByaW50ayhLRVJOX0lORk8gIlNDU0ktMiBSZXNlcnZlZCAlcyBMVU46ICV1IC0+IE1BUFBFRCBMVU46ICV1IgorCQkiIGZvciAlc1xuIiwgVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJU0VfTFVOKGNtZCktPnVucGFja2VkX2x1biwgY21kLT5zZV9kZXZlLT5tYXBwZWRfbHVuLAorCQlzZXNzLT5zZV9ub2RlX2FjbC0+aW5pdGlhdG9ybmFtZSk7CisJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqY29yZV9zY3NpM19sb2NhdGVfcHJfcmVnKHN0cnVjdCBzZV9kZXZpY2UgKiwKKwkJCQkJc3RydWN0IHNlX25vZGVfYWNsICosIHN0cnVjdCBzZV9zZXNzaW9uICopOworc3RhdGljIHZvaWQgY29yZV9zY3NpM19wdXRfcHJfcmVnKHN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICopOworCisvKgorICogU2V0dXAgaW4gdGFyZ2V0X2NvcmVfdHJhbnNwb3J0LmM6dHJhbnNwb3J0X2dlbmVyaWNfY21kX3NlcXVlbmNlcigpCisgKiBhbmQgY2FsbGVkIHZpYSBzdHJ1Y3Qgc2VfY21kLT50cmFuc3BvcnRfZW11bGF0ZV9jZGIoKSBpbiBUQ00gcHJvY2Vzc2luZworICogdGhyZWFkIGNvbnRleHQuCisgKi8KK2ludCBjb3JlX3Njc2kyX2VtdWxhdGVfY3JoKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqc2Vfc2VzcyA9IGNtZC0+c2Vfc2VzczsKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2ID0gY21kLT5zZV9kZXYtPnNlX3N1Yl9kZXY7CisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKnByX3JlZzsKKwlzdHJ1Y3QgdDEwX3Jlc2VydmF0aW9uX3RlbXBsYXRlICpwcl90bXBsID0gJnN1X2Rldi0+dDEwX3Jlc2VydmF0aW9uOworCXVuc2lnbmVkIGNoYXIgKmNkYiA9ICZUX1RBU0soY21kKS0+dF90YXNrX2NkYlswXTsKKwlpbnQgY3JoID0gKFQxMF9SRVMoc3VfZGV2KS0+cmVzX3R5cGUgPT0gU1BDM19QRVJTSVNURU5UX1JFU0VSVkFUSU9OUyk7CisJaW50IGNvbmZsaWN0ID0gMDsKKworCWlmICghKHNlX3Nlc3MpKQorCQlyZXR1cm4gMDsKKworCWlmICghKGNyaCkpCisJCWdvdG8gYWZ0ZXJfY3JoOworCisJcHJfcmVnID0gY29yZV9zY3NpM19sb2NhdGVfcHJfcmVnKGNtZC0+c2VfZGV2LCBzZV9zZXNzLT5zZV9ub2RlX2FjbCwKKwkJCXNlX3Nlc3MpOworCWlmIChwcl9yZWcpIHsKKwkJLyoKKwkJICogRnJvbSBzcGM0cjE3IDUuNy4zIEV4Y2VwdGlvbnMgdG8gU1BDLTIgUkVTRVJWRSBhbmQgUkVMRUFTRQorCQkgKiBiZWhhdmlvcgorCQkgKgorCQkgKiBBIFJFU0VSVkUoNikgb3IgUkVTRVJWRSgxMCkgY29tbWFuZCBzaGFsbCBjb21wbGV0ZSB3aXRoIEdPT0QKKwkJICogc3RhdHVzLCBidXQgbm8gcmVzZXJ2YXRpb24gc2hhbGwgYmUgZXN0YWJsaXNoZWQgYW5kIHRoZQorCQkgKiBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIHNoYWxsIG5vdCBiZSBjaGFuZ2VkLCBpZiB0aGUgY29tbWFuZAorCQkgKiBpcyByZWNlaXZlZCBmcm9tIGEpIGFuZCBiKSBiZWxvdy4KKwkJICoKKwkJICogQSBSRUxFQVNFKDYpIG9yIFJFTEVBU0UoMTApIGNvbW1hbmQgc2hhbGwgY29tcGxldGUgd2l0aCBHT09ECisJCSAqIHN0YXR1cywgYnV0IHRoZSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIHNoYWxsIG5vdCBiZSByZWxlYXNlZCwKKwkJICogaWYgdGhlIGNvbW1hbmQgaXMgcmVjZWl2ZWQgZnJvbSBhKSBhbmQgYikKKwkJICoKKwkJICogYSkgQW4gSV9UIG5leHVzIHRoYXQgaXMgYSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIGhvbGRlcjsgb3IKKwkJICogYikgQW4gSV9UIG5leHVzIHRoYXQgaXMgcmVnaXN0ZXJlZCBpZiBhIHJlZ2lzdHJhbnRzIG9ubHkgb3IKKwkJICogICAgYWxsIHJlZ2lzdHJhbnRzIHR5cGUgcGVyc2lzdGVudCByZXNlcnZhdGlvbiBpcyBwcmVzZW50LgorCQkgKgorCQkgKiBJbiBhbGwgb3RoZXIgY2FzZXMsIGEgUkVTRVJWRSg2KSBjb21tYW5kLCBSRVNFUlZFKDEwKSBjb21tYW5kLAorCQkgKiBSRUxFQVNFKDYpIGNvbW1hbmQsIG9yIFJFTEVBU0UoMTApIGNvbW1hbmQgc2hhbGwgYmUgcHJvY2Vzc2VkCisJCSAqIGFzIGRlZmluZWQgaW4gU1BDLTIuCisJCSAqLworCQlpZiAocHJfcmVnLT5wcl9yZXNfaG9sZGVyKSB7CisJCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnKTsKKwkJCXJldHVybiAwOworCQl9CisJCWlmICgocHJfcmVnLT5wcl9yZXNfdHlwZSA9PSBQUl9UWVBFX1dSSVRFX0VYQ0xVU0lWRV9SRUdPTkxZKSB8fAorCQkgICAgKHByX3JlZy0+cHJfcmVzX3R5cGUgPT0gUFJfVFlQRV9FWENMVVNJVkVfQUNDRVNTX1JFR09OTFkpIHx8CisJCSAgICAocHJfcmVnLT5wcl9yZXNfdHlwZSA9PSBQUl9UWVBFX1dSSVRFX0VYQ0xVU0lWRV9BTExSRUcpIHx8CisJCSAgICAocHJfcmVnLT5wcl9yZXNfdHlwZSA9PSBQUl9UWVBFX0VYQ0xVU0lWRV9BQ0NFU1NfQUxMUkVHKSkgeworCQkJY29yZV9zY3NpM19wdXRfcHJfcmVnKHByX3JlZyk7CisJCQlyZXR1cm4gMDsKKwkJfQorCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnKTsKKwkJY29uZmxpY3QgPSAxOworCX0gZWxzZSB7CisJCS8qCisJCSAqIEZvbGxvd2luZyBzcGMycjIwIDUuNS4xIFJlc2VydmF0aW9ucyBvdmVydmlldzoKKwkJICoKKwkJICogSWYgYSBsb2dpY2FsIHVuaXQgaGFzIGV4ZWN1dGVkIGEgUEVSU0lTVEVOVCBSRVNFUlZFIE9VVAorCQkgKiBjb21tYW5kIHdpdGggdGhlIFJFR0lTVEVSIG9yIHRoZSBSRUdJU1RFUiBBTkQgSUdOT1JFCisJCSAqIEVYSVNUSU5HIEtFWSBzZXJ2aWNlIGFjdGlvbiBhbmQgaXMgc3RpbGwgcmVnaXN0ZXJlZCBieSBhbnkKKwkJICogaW5pdGlhdG9yLCBhbGwgUkVTRVJWRSBjb21tYW5kcyBhbmQgYWxsIFJFTEVBU0UgY29tbWFuZHMKKwkJICogcmVnYXJkbGVzcyBvZiBpbml0aWF0b3Igc2hhbGwgY29uZmxpY3QgYW5kIHNoYWxsIHRlcm1pbmF0ZQorCQkgKiB3aXRoIGEgUkVTRVJWQVRJT04gQ09ORkxJQ1Qgc3RhdHVzLgorCQkgKi8KKwkJc3Bpbl9sb2NrKCZwcl90bXBsLT5yZWdpc3RyYXRpb25fbG9jayk7CisJCWNvbmZsaWN0ID0gKGxpc3RfZW1wdHkoJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9saXN0KSkgPyAwIDogMTsKKwkJc3Bpbl91bmxvY2soJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9sb2NrKTsKKwl9CisKKwlpZiAoY29uZmxpY3QpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJSZWNlaXZlZCBsZWdhY3kgU1BDLTIgUkVTRVJWRS9SRUxFQVNFIgorCQkJIiB3aGlsZSBhY3RpdmUgU1BDLTMgcmVnaXN0cmF0aW9ucyBleGlzdCwiCisJCQkiIHJldHVybmluZyBSRVNFUlZBVElPTl9DT05GTElDVFxuIik7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX1JFU0VSVkFUSU9OX0NPTkZMSUNUOworCX0KKworYWZ0ZXJfY3JoOgorCWlmICgoY2RiWzBdID09IFJFU0VSVkUpIHx8IChjZGJbMF0gPT0gUkVTRVJWRV8xMCkpCisJCXJldHVybiBjb3JlX3Njc2kyX3Jlc2VydmF0aW9uX3Jlc2VydmUoY21kKTsKKwllbHNlIGlmICgoY2RiWzBdID09IFJFTEVBU0UpIHx8IChjZGJbMF0gPT0gUkVMRUFTRV8xMCkpCisJCXJldHVybiBjb3JlX3Njc2kyX3Jlc2VydmF0aW9uX3JlbGVhc2UoY21kKTsKKwllbHNlCisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0lOVkFMSURfQ0RCX0ZJRUxEOworfQorCisvKgorICogQmVnaW4gU1BDLTMvU1BDLTQgUGVyc2lzdGVudCBSZXNlcnZhdGlvbnMgZW11bGF0aW9uIHN1cHBvcnQKKyAqCisgKiBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBieSB0aG9zZSBpbml0aWF0b3IgcG9ydHMgd2hvIGFyZSAqTk9UKgorICogdGhlIGFjdGl2ZSBQUiByZXNlcnZhdGlvbiBob2xkZXIgd2hlbiBhIHJlc2VydmF0aW9uIGlzIHByZXNlbnQuCisgKi8KK3N0YXRpYyBpbnQgY29yZV9zY3NpM19wcl9zZXFfbm9uX2hvbGRlcigKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJdW5zaWduZWQgY2hhciAqY2RiLAorCXUzMiBwcl9yZWdfdHlwZSkKK3sKKwlzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICpzZV9kZXZlOworCXN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzID0gU0VfU0VTUyhjbWQpOworCWludCBvdGhlcl9jZGIgPSAwLCBpZ25vcmVfcmVnOworCWludCByZWdpc3RlcmVkX25leHVzID0gMCwgcmV0ID0gMTsgLyogQ29uZmxpY3QgYnkgZGVmYXVsdCAqLworCWludCBhbGxfcmVnID0gMCwgcmVnX29ubHkgPSAwOyAvKiBBTExfUkVHLCBSRUdfT05MWSAqLworCWludCB3ZSA9IDA7IC8qIFdyaXRlIEV4Y2x1c2l2ZSAqLworCWludCBsZWdhY3kgPSAwOyAvKiBBY3QgbGlrZSBhIGxlZ2FjeSBkZXZpY2UgYW5kIHJldHVybgorCQkJICogUkVTRVJWQVRJT04gQ09ORkxJQ1Qgb24gc29tZSBDREJzICovCisJLyoKKwkgKiBBIGxlZ2FjeSBTUEMtMiByZXNlcnZhdGlvbiBpcyBiZWluZyBoZWxkLgorCSAqLworCWlmIChjbWQtPnNlX2Rldi0+ZGV2X2ZsYWdzICYgREZfU1BDMl9SRVNFUlZBVElPTlMpCisJCXJldHVybiBjb3JlX3Njc2kyX3Jlc2VydmF0aW9uX3NlcV9ub25faG9sZGVyKGNtZCwKKwkJCQkJY2RiLCBwcl9yZWdfdHlwZSk7CisKKwlzZV9kZXZlID0gJnNlX3Nlc3MtPnNlX25vZGVfYWNsLT5kZXZpY2VfbGlzdFtjbWQtPm9yaWdfZmVfbHVuXTsKKwkvKgorCSAqIERldGVybWluZSBpZiB0aGUgcmVnaXN0cmF0aW9uIHNob3VsZCBiZSBpZ25vcmVkIGR1ZSB0bworCSAqIG5vbi1tYXRjaGluZyBJU0lEcyBpbiBjb3JlX3Njc2kzX3ByX3Jlc2VydmF0aW9uX2NoZWNrKCkuCisJICovCisJaWdub3JlX3JlZyA9IChwcl9yZWdfdHlwZSAmIDB4ODAwMDAwMDApOworCWlmIChpZ25vcmVfcmVnKQorCQlwcl9yZWdfdHlwZSAmPSB+MHg4MDAwMDAwMDsKKworCXN3aXRjaCAocHJfcmVnX3R5cGUpIHsKKwljYXNlIFBSX1RZUEVfV1JJVEVfRVhDTFVTSVZFOgorCQl3ZSA9IDE7CisJY2FzZSBQUl9UWVBFX0VYQ0xVU0lWRV9BQ0NFU1M6CisJCS8qCisJCSAqIFNvbWUgY29tbWFuZHMgYXJlIG9ubHkgYWxsb3dlZCBmb3IgdGhlIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24KKwkJICogaG9sZGVyLgorCQkgKi8KKwkJaWYgKChzZV9kZXZlLT5kZWZfcHJfcmVnaXN0ZXJlZCkgJiYgIShpZ25vcmVfcmVnKSkKKwkJCXJlZ2lzdGVyZWRfbmV4dXMgPSAxOworCQlicmVhazsKKwljYXNlIFBSX1RZUEVfV1JJVEVfRVhDTFVTSVZFX1JFR09OTFk6CisJCXdlID0gMTsKKwljYXNlIFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTU19SRUdPTkxZOgorCQkvKgorCQkgKiBTb21lIGNvbW1hbmRzIGFyZSBvbmx5IGFsbG93ZWQgZm9yIHJlZ2lzdGVyZWQgSV9UIE5leHVzZXMuCisJCSAqLworCQlyZWdfb25seSA9IDE7CisJCWlmICgoc2VfZGV2ZS0+ZGVmX3ByX3JlZ2lzdGVyZWQpICYmICEoaWdub3JlX3JlZykpCisJCQlyZWdpc3RlcmVkX25leHVzID0gMTsKKwkJYnJlYWs7CisJY2FzZSBQUl9UWVBFX1dSSVRFX0VYQ0xVU0lWRV9BTExSRUc6CisJCXdlID0gMTsKKwljYXNlIFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTU19BTExSRUc6CisJCS8qCisJCSAqIEVhY2ggcmVnaXN0ZXJlZCBJX1QgTmV4dXMgaXMgYSByZXNlcnZhdGlvbiBob2xkZXIuCisJCSAqLworCQlhbGxfcmVnID0gMTsKKwkJaWYgKChzZV9kZXZlLT5kZWZfcHJfcmVnaXN0ZXJlZCkgJiYgIShpZ25vcmVfcmVnKSkKKwkJCXJlZ2lzdGVyZWRfbmV4dXMgPSAxOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlyZXR1cm4gLTE7CisJfQorCS8qCisJICogUmVmZXJlbmNlZCBmcm9tIHNwYzRyMTcgdGFibGUgNDUgZm9yICpOT04qIFBSIGhvbGRlciBhY2Nlc3MKKwkgKi8KKwlzd2l0Y2ggKGNkYlswXSkgeworCWNhc2UgU0VDVVJJVFlfUFJPVE9DT0xfSU46CisJCWlmIChyZWdpc3RlcmVkX25leHVzKQorCQkJcmV0dXJuIDA7CisJCXJldCA9ICh3ZSkgPyAwIDogMTsKKwkJYnJlYWs7CisJY2FzZSBNT0RFX1NFTlNFOgorCWNhc2UgTU9ERV9TRU5TRV8xMDoKKwljYXNlIFJFQURfQVRUUklCVVRFOgorCWNhc2UgUkVBRF9CVUZGRVI6CisJY2FzZSBSRUNFSVZFX0RJQUdOT1NUSUM6CisJCWlmIChsZWdhY3kpIHsKKwkJCXJldCA9IDE7CisJCQlicmVhazsKKwkJfQorCQlpZiAocmVnaXN0ZXJlZF9uZXh1cykgeworCQkJcmV0ID0gMDsKKwkJCWJyZWFrOworCQl9CisJCXJldCA9ICh3ZSkgPyAwIDogMTsgLyogQWxsb3dlZCBXcml0ZSBFeGNsdXNpdmUgKi8KKwkJYnJlYWs7CisJY2FzZSBQRVJTSVNURU5UX1JFU0VSVkVfT1VUOgorCQkvKgorCQkgKiBUaGlzIGZvbGxvd3MgUEVSU0lTVEVOVF9SRVNFUlZFX09VVCBzZXJ2aWNlIGFjdGlvbnMgdGhhdAorCQkgKiBhcmUgYWxsb3dlZCBpbiB0aGUgcHJlc2VuY2Ugb2YgdmFyaW91cyByZXNlcnZhdGlvbnMuCisJCSAqIFNlZSBzcGM0cjE3LCB0YWJsZSA0NgorCQkgKi8KKwkJc3dpdGNoIChjZGJbMV0gJiAweDFmKSB7CisJCWNhc2UgUFJPX0NMRUFSOgorCQljYXNlIFBST19QUkVFTVBUOgorCQljYXNlIFBST19QUkVFTVBUX0FORF9BQk9SVDoKKwkJCXJldCA9IChyZWdpc3RlcmVkX25leHVzKSA/IDAgOiAxOworCQkJYnJlYWs7CisJCWNhc2UgUFJPX1JFR0lTVEVSOgorCQljYXNlIFBST19SRUdJU1RFUl9BTkRfSUdOT1JFX0VYSVNUSU5HX0tFWToKKwkJCXJldCA9IDA7CisJCQlicmVhazsKKwkJY2FzZSBQUk9fUkVHSVNURVJfQU5EX01PVkU6CisJCWNhc2UgUFJPX1JFU0VSVkU6CisJCQlyZXQgPSAxOworCQkJYnJlYWs7CisJCWNhc2UgUFJPX1JFTEVBU0U6CisJCQlyZXQgPSAocmVnaXN0ZXJlZF9uZXh1cykgPyAwIDogMTsKKwkJCWJyZWFrOworCQlkZWZhdWx0OgorCQkJcHJpbnRrKEtFUk5fRVJSICJVbmtub3duIFBFUlNJU1RFTlRfUkVTRVJWRV9PVVQgc2VydmljZSIKKwkJCQkiIGFjdGlvbjogMHglMDJ4XG4iLCBjZGJbMV0gJiAweDFmKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQlicmVhazsKKwljYXNlIFJFTEVBU0U6CisJY2FzZSBSRUxFQVNFXzEwOgorCQkvKiBIYW5kbGVkIGJ5IENSSD0xIGluIGNvcmVfc2NzaTJfZW11bGF0ZV9jcmgoKSAqLworCQlyZXQgPSAwOworCQlicmVhazsKKwljYXNlIFJFU0VSVkU6CisJY2FzZSBSRVNFUlZFXzEwOgorCQkvKiBIYW5kbGVkIGJ5IENSSD0xIGluIGNvcmVfc2NzaTJfZW11bGF0ZV9jcmgoKSAqLworCQlyZXQgPSAwOworCQlicmVhazsKKwljYXNlIFRFU1RfVU5JVF9SRUFEWToKKwkJcmV0ID0gKGxlZ2FjeSkgPyAxIDogMDsgLyogQ29uZmxpY3QgZm9yIGxlZ2FjeSAqLworCQlicmVhazsKKwljYXNlIE1BSU5URU5BTkNFX0lOOgorCQlzd2l0Y2ggKGNkYlsxXSAmIDB4MWYpIHsKKwkJY2FzZSBNSV9NQU5BR0VNRU5UX1BST1RPQ09MX0lOOgorCQkJaWYgKHJlZ2lzdGVyZWRfbmV4dXMpIHsKKwkJCQlyZXQgPSAwOworCQkJCWJyZWFrOworCQkJfQorCQkJcmV0ID0gKHdlKSA/IDAgOiAxOyAvKiBBbGxvd2VkIFdyaXRlIEV4Y2x1c2l2ZSAqLworCQkJYnJlYWs7CisJCWNhc2UgTUlfUkVQT1JUX1NVUFBPUlRFRF9PUEVSQVRJT05fQ09ERVM6CisJCWNhc2UgTUlfUkVQT1JUX1NVUFBPUlRFRF9UQVNLX01BTkFHRU1FTlRfRlVOQ1RJT05TOgorCQkJaWYgKGxlZ2FjeSkgeworCQkJCXJldCA9IDE7CisJCQkJYnJlYWs7CisJCQl9CisJCQlpZiAocmVnaXN0ZXJlZF9uZXh1cykgeworCQkJCXJldCA9IDA7CisJCQkJYnJlYWs7CisJCQl9CisJCQlyZXQgPSAod2UpID8gMCA6IDE7IC8qIEFsbG93ZWQgV3JpdGUgRXhjbHVzaXZlICovCisJCQlicmVhazsKKwkJY2FzZSBNSV9SRVBPUlRfQUxJQVNFUzoKKwkJY2FzZSBNSV9SRVBPUlRfSURFTlRJRllJTkdfSU5GT1JNQVRJT046CisJCWNhc2UgTUlfUkVQT1JUX1BSSU9SSVRZOgorCQljYXNlIE1JX1JFUE9SVF9UQVJHRVRfUEdTOgorCQljYXNlIE1JX1JFUE9SVF9USU1FU1RBTVA6CisJCQlyZXQgPSAwOyAvKiBBbGxvd2VkICovCisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5rbm93biBNSSBTZXJ2aWNlIEFjdGlvbjogMHglMDJ4XG4iLAorCQkJCShjZGJbMV0gJiAweDFmKSk7CisJCQlyZXR1cm4gLTE7CisJCX0KKwkJYnJlYWs7CisJY2FzZSBBQ0NFU1NfQ09OVFJPTF9JTjoKKwljYXNlIEFDQ0VTU19DT05UUk9MX09VVDoKKwljYXNlIElOUVVJUlk6CisJY2FzZSBMT0dfU0VOU0U6CisJY2FzZSBSRUFEX01FRElBX1NFUklBTF9OVU1CRVI6CisJY2FzZSBSRVBPUlRfTFVOUzoKKwljYXNlIFJFUVVFU1RfU0VOU0U6CisJCXJldCA9IDA7IC8qLyBBbGxvd2VkIENEQnMgKi8KKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJb3RoZXJfY2RiID0gMTsKKwkJYnJlYWs7CisJfQorCS8qCisJICogQ2FzZSB3aGVyZSB0aGUgQ0RCIGlzIGV4cGxpY3RseSBhbGxvd2VkIGluIHRoZSBhYm92ZSBzd2l0Y2gKKwkgKiBzdGF0ZW1lbnQuCisJICovCisJaWYgKCEocmV0KSAmJiAhKG90aGVyX2NkYikpIHsKKyNpZiAwCisJCXByaW50ayhLRVJOX0lORk8gIkFsbG93aW5nIGV4cGxpY3QgQ0RCOiAweCUwMnggZm9yICVzIgorCQkJIiByZXNlcnZhdGlvbiBob2xkZXJcbiIsIGNkYlswXSwKKwkJCWNvcmVfc2NzaTNfcHJfZHVtcF90eXBlKHByX3JlZ190eXBlKSk7CisjZW5kaWYKKwkJcmV0dXJuIHJldDsKKwl9CisJLyoKKwkgKiBDaGVjayBpZiB3cml0ZSBleGNsdXNpdmUgaW5pdGlhdG9yIHBvcnRzICpOT1QqIGhvbGRpbmcgdGhlCisJICogV1JJVEVfRVhDTFVTSVZFXyogcmVzZXJ2YXRpb24uCisJICovCisJaWYgKCh3ZSkgJiYgIShyZWdpc3RlcmVkX25leHVzKSkgeworCQlpZiAoY21kLT5kYXRhX2RpcmVjdGlvbiA9PSBETUFfVE9fREVWSUNFKSB7CisJCQkvKgorCQkJICogQ29uZmxpY3QgZm9yIHdyaXRlIGV4Y2x1c2l2ZQorCQkJICovCisJCQlwcmludGsoS0VSTl9JTkZPICIlcyBDb25mbGljdCBmb3IgdW5yZWdpc3RlcmVkIG5leHVzIgorCQkJCSIgJXMgQ0RCOiAweCUwMnggdG8gJXMgcmVzZXJ2YXRpb25cbiIsCisJCQkJdHJhbnNwb3J0X2R1bXBfY21kX2RpcmVjdGlvbihjbWQpLAorCQkJCXNlX3Nlc3MtPnNlX25vZGVfYWNsLT5pbml0aWF0b3JuYW1lLCBjZGJbMF0sCisJCQkJY29yZV9zY3NpM19wcl9kdW1wX3R5cGUocHJfcmVnX3R5cGUpKTsKKwkJCXJldHVybiAxOworCQl9IGVsc2UgeworCQkJLyoKKwkJCSAqIEFsbG93IG5vbiBXUklURSBDREJzIGZvciBhbGwgV3JpdGUgRXhjbHVzaXZlCisJCQkgKiBQUiBUWVBFcyB0byBwYXNzIGZvciByZWdpc3RlcmVkIGFuZAorCQkJICogbm9uLXJlZ2lzdGVyZWRfbmV4dXhlcyBOT1QgaG9sZGluZyB0aGUgcmVzZXJ2YXRpb24uCisJCQkgKgorCQkJICogV2Ugb25seSBtYWtlIG5vaXNlIGZvciB0aGUgdW5yZWdpc3RlcmQgbmV4dXNlcywKKwkJCSAqIGFzIHdlIGV4cGVjdCByZWdpc3RlcmVkIG5vbi1yZXNlcnZhdGlvbiBob2xkaW5nCisJCQkgKiBuZXh1c2VzIHRvIGlzc3VlIENEQnMuCisJCQkgKi8KKyNpZiAwCisJCQlpZiAoIShyZWdpc3RlcmVkX25leHVzKSkgeworCQkJCXByaW50ayhLRVJOX0lORk8gIkFsbG93aW5nIGltcGxpY3QgQ0RCOiAweCUwMngiCisJCQkJCSIgZm9yICVzIHJlc2VydmF0aW9uIG9uIHVucmVnaXN0ZXJlZCIKKwkJCQkJIiBuZXh1c1xuIiwgY2RiWzBdLAorCQkJCQljb3JlX3Njc2kzX3ByX2R1bXBfdHlwZShwcl9yZWdfdHlwZSkpOworCQkJfQorI2VuZGlmCisJCQlyZXR1cm4gMDsKKwkJfQorCX0gZWxzZSBpZiAoKHJlZ19vbmx5KSB8fCAoYWxsX3JlZykpIHsKKwkJaWYgKHJlZ2lzdGVyZWRfbmV4dXMpIHsKKwkJCS8qCisJCQkgKiBGb3IgUFJfKl9SRUdfT05MWSBhbmQgUFJfKl9BTExfUkVHIHJlc2VydmF0aW9ucywKKwkJCSAqIGFsbG93IGNvbW1hbmRzIGZyb20gcmVnaXN0ZXJlZCBuZXh1c2VzLgorCQkJICovCisjaWYgMAorCQkJcHJpbnRrKEtFUk5fSU5GTyAiQWxsb3dpbmcgaW1wbGljdCBDREI6IDB4JTAyeCBmb3IgJXMiCisJCQkJIiByZXNlcnZhdGlvblxuIiwgY2RiWzBdLAorCQkJCWNvcmVfc2NzaTNfcHJfZHVtcF90eXBlKHByX3JlZ190eXBlKSk7CisjZW5kaWYKKwkJCXJldHVybiAwOworCQl9CisJfQorCXByaW50ayhLRVJOX0lORk8gIiVzIENvbmZsaWN0IGZvciAlc3JlZ2lzdGVyZWQgbmV4dXMgJXMgQ0RCOiAweCUyeCIKKwkJIiBmb3IgJXMgcmVzZXJ2YXRpb25cbiIsIHRyYW5zcG9ydF9kdW1wX2NtZF9kaXJlY3Rpb24oY21kKSwKKwkJKHJlZ2lzdGVyZWRfbmV4dXMpID8gIiIgOiAidW4iLAorCQlzZV9zZXNzLT5zZV9ub2RlX2FjbC0+aW5pdGlhdG9ybmFtZSwgY2RiWzBdLAorCQljb3JlX3Njc2kzX3ByX2R1bXBfdHlwZShwcl9yZWdfdHlwZSkpOworCisJcmV0dXJuIDE7IC8qIENvbmZsaWN0IGJ5IGRlZmF1bHQgKi8KK30KKworc3RhdGljIHUzMiBjb3JlX3Njc2kzX3ByX2dlbmVyYXRpb24oc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXYgPSBTVV9ERVYoZGV2KTsKKwl1MzIgcHJnOworCS8qCisJICogUFJHZW5lcmF0aW9uIGZpZWxkIHNoYWxsIGNvbnRhaW4gdGhlIHZhbHVlIG9mIGEgMzItYml0IHdyYXBwaW5nCisJICogY291bnRlciBtYWludGVkIGJ5IHRoZSBkZXZpY2Ugc2VydmVyLgorCSAqCisJICogTm90ZSB0aGF0IHRoaXMgaXMgZG9uZSByZWdhcmRsZXNzIG9mIEFjdGl2ZSBQZXJzaXN0IGFjcm9zcworCSAqIFRhcmdldCBQb3dlckxvc3MgKEFQVFBMKQorCSAqCisJICogU2VlIHNwYzRyMTcgc2VjdGlvbiA2LjMuMTIgUkVBRF9LRVlTIHNlcnZpY2UgYWN0aW9uCisJICovCisJc3Bpbl9sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwlwcmcgPSBUMTBfUkVTKHN1X2RldiktPnByX2dlbmVyYXRpb24rKzsKKwlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisKKwlyZXR1cm4gcHJnOworfQorCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfcHJfcmVzZXJ2YXRpb25fY2hlY2soCisJc3RydWN0IHNlX2NtZCAqY21kLAorCXUzMiAqcHJfcmVnX3R5cGUpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gY21kLT5zZV9kZXY7CisJc3RydWN0IHNlX3Nlc3Npb24gKnNlc3MgPSBjbWQtPnNlX3Nlc3M7CisJaW50IHJldDsKKworCWlmICghKHNlc3MpKQorCQlyZXR1cm4gMDsKKwkvKgorCSAqIEEgbGVnYWN5IFNQQy0yIHJlc2VydmF0aW9uIGlzIGJlaW5nIGhlbGQuCisJICovCisJaWYgKGRldi0+ZGV2X2ZsYWdzICYgREZfU1BDMl9SRVNFUlZBVElPTlMpCisJCXJldHVybiBjb3JlX3Njc2kyX3Jlc2VydmF0aW9uX2NoZWNrKGNtZCwgcHJfcmVnX3R5cGUpOworCisJc3Bpbl9sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwlpZiAoIShkZXYtPmRldl9wcl9yZXNfaG9sZGVyKSkgeworCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCXJldHVybiAwOworCX0KKwkqcHJfcmVnX3R5cGUgPSBkZXYtPmRldl9wcl9yZXNfaG9sZGVyLT5wcl9yZXNfdHlwZTsKKwljbWQtPnByX3Jlc19rZXkgPSBkZXYtPmRldl9wcl9yZXNfaG9sZGVyLT5wcl9yZXNfa2V5OworCWlmIChkZXYtPmRldl9wcl9yZXNfaG9sZGVyLT5wcl9yZWdfbmFjbCAhPSBzZXNzLT5zZV9ub2RlX2FjbCkgeworCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCXJldHVybiAtMTsKKwl9CisJaWYgKCEoZGV2LT5kZXZfcHJfcmVzX2hvbGRlci0+aXNpZF9wcmVzZW50X2F0X3JlZykpIHsKKwkJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCQlyZXR1cm4gMDsKKwl9CisJcmV0ID0gKGRldi0+ZGV2X3ByX3Jlc19ob2xkZXItPnByX3JlZ19iaW5faXNpZCA9PQorCSAgICAgICBzZXNzLT5zZXNzX2Jpbl9pc2lkKSA/IDAgOiAtMTsKKwkvKgorCSAqIFVzZSBiaXQgaW4gKnByX3JlZ190eXBlIHRvIG5vdGlmeSBJU0lEIG1pc21hdGNoIGluCisJICogY29yZV9zY3NpM19wcl9zZXFfbm9uX2hvbGRlcigpLgorCSAqLworCWlmIChyZXQgIT0gMCkKKwkJKnByX3JlZ190eXBlIHw9IDB4ODAwMDAwMDA7CisJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpfX2NvcmVfc2NzaTNfZG9fYWxsb2NfcmVnaXN0cmF0aW9uKAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKm5hY2wsCisJc3RydWN0IHNlX2Rldl9lbnRyeSAqZGV2ZSwKKwl1bnNpZ25lZCBjaGFyICppc2lkLAorCXU2NCBzYV9yZXNfa2V5LAorCWludCBhbGxfdGdfcHQsCisJaW50IGFwdHBsKQoreworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXYgPSBTVV9ERVYoZGV2KTsKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnOworCisJcHJfcmVnID0ga21lbV9jYWNoZV96YWxsb2ModDEwX3ByX3JlZ19jYWNoZSwgR0ZQX0FUT01JQyk7CisJaWYgKCEocHJfcmVnKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvblxuIik7CisJCXJldHVybiBOVUxMOworCX0KKworCXByX3JlZy0+cHJfYXB0cGxfYnVmID0ga3phbGxvYyhUMTBfUkVTKHN1X2RldiktPnByX2FwdHBsX2J1Zl9sZW4sCisJCQkJCUdGUF9BVE9NSUMpOworCWlmICghKHByX3JlZy0+cHJfYXB0cGxfYnVmKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBwcl9yZWctPnByX2FwdHBsX2J1ZlxuIik7CisJCWttZW1fY2FjaGVfZnJlZSh0MTBfcHJfcmVnX2NhY2hlLCBwcl9yZWcpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlJTklUX0xJU1RfSEVBRCgmcHJfcmVnLT5wcl9yZWdfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJnByX3JlZy0+cHJfcmVnX2Fib3J0X2xpc3QpOworCUlOSVRfTElTVF9IRUFEKCZwcl9yZWctPnByX3JlZ19hcHRwbF9saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmcHJfcmVnLT5wcl9yZWdfYXRwX2xpc3QpOworCUlOSVRfTElTVF9IRUFEKCZwcl9yZWctPnByX3JlZ19hdHBfbWVtX2xpc3QpOworCWF0b21pY19zZXQoJnByX3JlZy0+cHJfcmVzX2hvbGRlcnMsIDApOworCXByX3JlZy0+cHJfcmVnX25hY2wgPSBuYWNsOworCXByX3JlZy0+cHJfcmVnX2RldmUgPSBkZXZlOworCXByX3JlZy0+cHJfcmVzX21hcHBlZF9sdW4gPSBkZXZlLT5tYXBwZWRfbHVuOworCXByX3JlZy0+cHJfYXB0cGxfdGFyZ2V0X2x1biA9IGRldmUtPnNlX2x1bi0+dW5wYWNrZWRfbHVuOworCXByX3JlZy0+cHJfcmVzX2tleSA9IHNhX3Jlc19rZXk7CisJcHJfcmVnLT5wcl9yZWdfYWxsX3RnX3B0ID0gYWxsX3RnX3B0OworCXByX3JlZy0+cHJfcmVnX2FwdHBsID0gYXB0cGw7CisJcHJfcmVnLT5wcl9yZWdfdGdfcHRfbHVuID0gZGV2ZS0+c2VfbHVuOworCS8qCisJICogSWYgYW4gSVNJRCB2YWx1ZSBmb3IgdGhpcyBTQ1NJIEluaXRpYXRvciBQb3J0IGV4aXN0cywKKwkgKiBzYXZlIGl0IHRvIHRoZSByZWdpc3RyYXRpb24gbm93LgorCSAqLworCWlmIChpc2lkICE9IE5VTEwpIHsKKwkJcHJfcmVnLT5wcl9yZWdfYmluX2lzaWQgPSBnZXRfdW5hbGlnbmVkX2JlNjQoaXNpZCk7CisJCXNucHJpbnRmKHByX3JlZy0+cHJfcmVnX2lzaWQsIFBSX1JFR19JU0lEX0xFTiwgIiVzIiwgaXNpZCk7CisJCXByX3JlZy0+aXNpZF9wcmVzZW50X2F0X3JlZyA9IDE7CisJfQorCisJcmV0dXJuIHByX3JlZzsKK30KKworc3RhdGljIGludCBjb3JlX3Njc2kzX2x1bmFjbF9kZXBlbmRfaXRlbShzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICopOworc3RhdGljIHZvaWQgY29yZV9zY3NpM19sdW5hY2xfdW5kZXBlbmRfaXRlbShzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICopOworCisvKgorICogRnVuY3Rpb24gdXNlZCBmb3IgaGFuZGxpbmcgUFIgcmVnaXN0cmF0aW9ucyBmb3IgQUxMX1RHX1BUPTEgYW5kIEFMTF9UR19QVD0wCisgKiBtb2Rlcy4KKyAqLworc3RhdGljIHN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpfX2NvcmVfc2NzaTNfYWxsb2NfcmVnaXN0cmF0aW9uKAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKm5hY2wsCisJc3RydWN0IHNlX2Rldl9lbnRyeSAqZGV2ZSwKKwl1bnNpZ25lZCBjaGFyICppc2lkLAorCXU2NCBzYV9yZXNfa2V5LAorCWludCBhbGxfdGdfcHQsCisJaW50IGFwdHBsKQoreworCXN0cnVjdCBzZV9kZXZfZW50cnkgKmRldmVfdG1wOworCXN0cnVjdCBzZV9ub2RlX2FjbCAqbmFjbF90bXA7CisJc3RydWN0IHNlX3BvcnQgKnBvcnQsICpwb3J0X3RtcDsKKwlzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcyAqdGZvID0gbmFjbC0+c2VfdHBnLT5zZV90cGdfdGZvOworCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsICpwcl9yZWdfYXRwLCAqcHJfcmVnX3RtcCwgKnByX3JlZ190bXBfc2FmZTsKKwlpbnQgcmV0OworCS8qCisJICogQ3JlYXRlIGEgcmVnaXN0cmF0aW9uIGZvciB0aGUgSV9UIE5leHVzIHVwb24gd2hpY2ggdGhlCisJICogUFJPVVQgUkVHSVNURVIgd2FzIHJlY2VpdmVkLgorCSAqLworCXByX3JlZyA9IF9fY29yZV9zY3NpM19kb19hbGxvY19yZWdpc3RyYXRpb24oZGV2LCBuYWNsLCBkZXZlLCBpc2lkLAorCQkJc2FfcmVzX2tleSwgYWxsX3RnX3B0LCBhcHRwbCk7CisJaWYgKCEocHJfcmVnKSkKKwkJcmV0dXJuIE5VTEw7CisJLyoKKwkgKiBSZXR1cm4gcG9pbnRlciB0byBwcl9yZWcgZm9yIEFMTF9UR19QVD0wCisJICovCisJaWYgKCEoYWxsX3RnX3B0KSkKKwkJcmV0dXJuIHByX3JlZzsKKwkvKgorCSAqIENyZWF0ZSBsaXN0IG9mIG1hdGNoaW5nIFNDU0kgSW5pdGlhdG9yIFBvcnQgcmVnaXN0cmF0aW9ucworCSAqIGZvciBBTExfVEdfUFQ9MQorCSAqLworCXNwaW5fbG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShwb3J0LCBwb3J0X3RtcCwgJmRldi0+ZGV2X3NlcF9saXN0LCBzZXBfbGlzdCkgeworCQlhdG9taWNfaW5jKCZwb3J0LT5zZXBfdGdfcHRfcmVmX2NudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2luYygpOworCQlzcGluX3VubG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCisJCXNwaW5fbG9ja19iaCgmcG9ydC0+c2VwX2FsdWFfbG9jayk7CisJCWxpc3RfZm9yX2VhY2hfZW50cnkoZGV2ZV90bXAsICZwb3J0LT5zZXBfYWx1YV9saXN0LAorCQkJCQlhbHVhX3BvcnRfbGlzdCkgeworCQkJLyoKKwkJCSAqIFRoaXMgcG9pbnRlciB3aWxsIGJlIE5VTEwgZm9yIGRlbW8gbW9kZSBNYXBwZWRMVU5zCisJCQkgKiB0aGF0IGhhdmUgbm90IGJlZW4gbWFrZSBleHBsaWN0IHZpYSBhIENvbmZpZ0ZTCisJCQkgKiBNYXBwZWRMVU4gZ3JvdXAgZm9yIHRoZSBTQ1NJIEluaXRpYXRvciBOb2RlIEFDTC4KKwkJCSAqLworCQkJaWYgKCEoZGV2ZV90bXAtPnNlX2x1bl9hY2wpKQorCQkJCWNvbnRpbnVlOworCisJCQluYWNsX3RtcCA9IGRldmVfdG1wLT5zZV9sdW5fYWNsLT5zZV9sdW5fbmFjbDsKKwkJCS8qCisJCQkgKiBTa2lwIHRoZSBtYXRjaGluZyBzdHJ1Y3Qgc2Vfbm9kZV9hY2wgdGhhdCBpcyBhbGxvY2F0ZWQKKwkJCSAqIGFib3ZlLi4KKwkJCSAqLworCQkJaWYgKG5hY2wgPT0gbmFjbF90bXApCisJCQkJY29udGludWU7CisJCQkvKgorCQkJICogT25seSBwZXJmb3JtIFBSIHJlZ2lzdHJhdGlvbnMgZm9yIHRhcmdldCBwb3J0cyBvbgorCQkJICogdGhlIHNhbWUgZmFicmljIG1vZHVsZSBhcyB0aGUgUkVHSVNURVIgdy8gQUxMX1RHX1BUPTEKKwkJCSAqIGFycml2ZWQuCisJCQkgKi8KKwkJCWlmICh0Zm8gIT0gbmFjbF90bXAtPnNlX3RwZy0+c2VfdHBnX3RmbykKKwkJCQljb250aW51ZTsKKwkJCS8qCisJCQkgKiBMb29rIGZvciBhIG1hdGNoaW5nIEluaXRpYXRvciBOb2RlIEFDTCBpbiBBU0NJSSBmb3JtYXQKKwkJCSAqLworCQkJaWYgKHN0cmNtcChuYWNsLT5pbml0aWF0b3JuYW1lLCBuYWNsX3RtcC0+aW5pdGlhdG9ybmFtZSkpCisJCQkJY29udGludWU7CisKKwkJCWF0b21pY19pbmMoJmRldmVfdG1wLT5wcl9yZWZfY291bnQpOworCQkJc21wX21iX19hZnRlcl9hdG9taWNfaW5jKCk7CisJCQlzcGluX3VubG9ja19iaCgmcG9ydC0+c2VwX2FsdWFfbG9jayk7CisJCQkvKgorCQkJICogR3JhYiBhIGNvbmZpZ2ZzIGdyb3VwIGRlcGVuZGVuY3kgdGhhdCBpcyByZWxlYXNlZAorCQkJICogZm9yIHRoZSBleGNlcHRpb24gcGF0aCBhdCBsYWJlbCBvdXQ6IGJlbG93LCBvciB1cG9uCisJCQkgKiBjb21wbGV0aW9uIG9mIGFkZGluZyBBTExfVEdfUFQ9MSByZWdpc3RyYXRpb25zIGluCisJCQkgKiBfX2NvcmVfc2NzaTNfYWRkX3JlZ2lzdHJhdGlvbigpCisJCQkgKi8KKwkJCXJldCA9IGNvcmVfc2NzaTNfbHVuYWNsX2RlcGVuZF9pdGVtKGRldmVfdG1wKTsKKwkJCWlmIChyZXQgPCAwKSB7CisJCQkJcHJpbnRrKEtFUk5fRVJSICJjb3JlX3Njc2kzX2x1bmFjbF9kZXBlbmQiCisJCQkJCQkiX2l0ZW0oKSBmYWlsZWRcbiIpOworCQkJCWF0b21pY19kZWMoJnBvcnQtPnNlcF90Z19wdF9yZWZfY250KTsKKwkJCQlzbXBfbWJfX2FmdGVyX2F0b21pY19kZWMoKTsKKwkJCQlhdG9taWNfZGVjKCZkZXZlX3RtcC0+cHJfcmVmX2NvdW50KTsKKwkJCQlzbXBfbWJfX2FmdGVyX2F0b21pY19kZWMoKTsKKwkJCQlnb3RvIG91dDsKKwkJCX0KKwkJCS8qCisJCQkgKiBMb2NhdGVkIGEgbWF0Y2hpbmcgU0NTSSBJbml0aWF0b3IgUG9ydCBvbiBhIGRpZmZlcmVudAorCQkJICogcG9ydCwgYWxsb2NhdGUgdGhlIHByX3JlZ19hdHAgYW5kIGF0dGFjaCBpdCB0byB0aGUKKwkJCSAqIHByX3JlZy0+cHJfcmVnX2F0cF9saXN0IHRoYXQgd2lsbCBiZSBwcm9jZXNzZWQgb25jZQorCQkJICogdGhlIG9yaWdpbmFsICpwcl9yZWcgaXMgcHJvY2Vzc2VkIGluCisJCQkgKiBfX2NvcmVfc2NzaTNfYWRkX3JlZ2lzdHJhdGlvbigpCisJCQkgKi8KKwkJCXByX3JlZ19hdHAgPSBfX2NvcmVfc2NzaTNfZG9fYWxsb2NfcmVnaXN0cmF0aW9uKGRldiwKKwkJCQkJCW5hY2xfdG1wLCBkZXZlX3RtcCwgTlVMTCwKKwkJCQkJCXNhX3Jlc19rZXksIGFsbF90Z19wdCwgYXB0cGwpOworCQkJaWYgKCEocHJfcmVnX2F0cCkpIHsKKwkJCQlhdG9taWNfZGVjKCZwb3J0LT5zZXBfdGdfcHRfcmVmX2NudCk7CisJCQkJc21wX21iX19hZnRlcl9hdG9taWNfZGVjKCk7CisJCQkJYXRvbWljX2RlYygmZGV2ZV90bXAtPnByX3JlZl9jb3VudCk7CisJCQkJc21wX21iX19hZnRlcl9hdG9taWNfZGVjKCk7CisJCQkJY29yZV9zY3NpM19sdW5hY2xfdW5kZXBlbmRfaXRlbShkZXZlX3RtcCk7CisJCQkJZ290byBvdXQ7CisJCQl9CisKKwkJCWxpc3RfYWRkX3RhaWwoJnByX3JlZ19hdHAtPnByX3JlZ19hdHBfbWVtX2xpc3QsCisJCQkJICAgICAgJnByX3JlZy0+cHJfcmVnX2F0cF9saXN0KTsKKwkJCXNwaW5fbG9ja19iaCgmcG9ydC0+c2VwX2FsdWFfbG9jayk7CisJCX0KKwkJc3Bpbl91bmxvY2tfYmgoJnBvcnQtPnNlcF9hbHVhX2xvY2spOworCisJCXNwaW5fbG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCQlhdG9taWNfZGVjKCZwb3J0LT5zZXBfdGdfcHRfcmVmX2NudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworCX0KKwlzcGluX3VubG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCisJcmV0dXJuIHByX3JlZzsKK291dDoKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocHJfcmVnX3RtcCwgcHJfcmVnX3RtcF9zYWZlLAorCQkJJnByX3JlZy0+cHJfcmVnX2F0cF9saXN0LCBwcl9yZWdfYXRwX21lbV9saXN0KSB7CisJCWxpc3RfZGVsKCZwcl9yZWdfdG1wLT5wcl9yZWdfYXRwX21lbV9saXN0KTsKKwkJY29yZV9zY3NpM19sdW5hY2xfdW5kZXBlbmRfaXRlbShwcl9yZWdfdG1wLT5wcl9yZWdfZGV2ZSk7CisJCWttZW1fY2FjaGVfZnJlZSh0MTBfcHJfcmVnX2NhY2hlLCBwcl9yZWdfdG1wKTsKKwl9CisJa21lbV9jYWNoZV9mcmVlKHQxMF9wcl9yZWdfY2FjaGUsIHByX3JlZyk7CisJcmV0dXJuIE5VTEw7Cit9CisKK2ludCBjb3JlX3Njc2kzX2FsbG9jX2FwdHBsX3JlZ2lzdHJhdGlvbigKKwlzdHJ1Y3QgdDEwX3Jlc2VydmF0aW9uX3RlbXBsYXRlICpwcl90bXBsLAorCXU2NCBzYV9yZXNfa2V5LAorCXVuc2lnbmVkIGNoYXIgKmlfcG9ydCwKKwl1bnNpZ25lZCBjaGFyICppc2lkLAorCXUzMiBtYXBwZWRfbHVuLAorCXVuc2lnbmVkIGNoYXIgKnRfcG9ydCwKKwl1MTYgdHBndCwKKwl1MzIgdGFyZ2V0X2x1biwKKwlpbnQgcmVzX2hvbGRlciwKKwlpbnQgYWxsX3RnX3B0LAorCXU4IHR5cGUpCit7CisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKnByX3JlZzsKKworCWlmICghKGlfcG9ydCkgfHwgISh0X3BvcnQpIHx8ICEoc2FfcmVzX2tleSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJJbGxlZ2FsIHBhcmFtZXRlcnMgZm9yIEFQVFBMIHJlZ2lzdHJhdGlvblxuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlwcl9yZWcgPSBrbWVtX2NhY2hlX3phbGxvYyh0MTBfcHJfcmVnX2NhY2hlLCBHRlBfS0VSTkVMKTsKKwlpZiAoIShwcl9yZWcpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIHN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwlwcl9yZWctPnByX2FwdHBsX2J1ZiA9IGt6YWxsb2MocHJfdG1wbC0+cHJfYXB0cGxfYnVmX2xlbiwgR0ZQX0tFUk5FTCk7CisKKwlJTklUX0xJU1RfSEVBRCgmcHJfcmVnLT5wcl9yZWdfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJnByX3JlZy0+cHJfcmVnX2Fib3J0X2xpc3QpOworCUlOSVRfTElTVF9IRUFEKCZwcl9yZWctPnByX3JlZ19hcHRwbF9saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmcHJfcmVnLT5wcl9yZWdfYXRwX2xpc3QpOworCUlOSVRfTElTVF9IRUFEKCZwcl9yZWctPnByX3JlZ19hdHBfbWVtX2xpc3QpOworCWF0b21pY19zZXQoJnByX3JlZy0+cHJfcmVzX2hvbGRlcnMsIDApOworCXByX3JlZy0+cHJfcmVnX25hY2wgPSBOVUxMOworCXByX3JlZy0+cHJfcmVnX2RldmUgPSBOVUxMOworCXByX3JlZy0+cHJfcmVzX21hcHBlZF9sdW4gPSBtYXBwZWRfbHVuOworCXByX3JlZy0+cHJfYXB0cGxfdGFyZ2V0X2x1biA9IHRhcmdldF9sdW47CisJcHJfcmVnLT5wcl9yZXNfa2V5ID0gc2FfcmVzX2tleTsKKwlwcl9yZWctPnByX3JlZ19hbGxfdGdfcHQgPSBhbGxfdGdfcHQ7CisJcHJfcmVnLT5wcl9yZWdfYXB0cGwgPSAxOworCXByX3JlZy0+cHJfcmVnX3RnX3B0X2x1biA9IE5VTEw7CisJcHJfcmVnLT5wcl9yZXNfc2NvcGUgPSAwOyAvKiBBbHdheXMgTFVOX1NDT1BFICovCisJcHJfcmVnLT5wcl9yZXNfdHlwZSA9IHR5cGU7CisJLyoKKwkgKiBJZiBhbiBJU0lEIHZhbHVlIGhhZCBiZWVuIHNhdmVkIGluIEFQVFBMIG1ldGFkYXRhIGZvciB0aGlzCisJICogU0NTSSBJbml0aWF0b3IgUG9ydCwgcmVzdG9yZSBpdCBub3cuCisJICovCisJaWYgKGlzaWQgIT0gTlVMTCkgeworCQlwcl9yZWctPnByX3JlZ19iaW5faXNpZCA9IGdldF91bmFsaWduZWRfYmU2NChpc2lkKTsKKwkJc25wcmludGYocHJfcmVnLT5wcl9yZWdfaXNpZCwgUFJfUkVHX0lTSURfTEVOLCAiJXMiLCBpc2lkKTsKKwkJcHJfcmVnLT5pc2lkX3ByZXNlbnRfYXRfcmVnID0gMTsKKwl9CisJLyoKKwkgKiBDb3B5IHRoZSBpX3BvcnQgYW5kIHRfcG9ydCBpbmZvcm1hdGlvbiBmcm9tIGNhbGxlci4KKwkgKi8KKwlzbnByaW50Zihwcl9yZWctPnByX2lwb3J0LCBQUl9BUFRQTF9NQVhfSVBPUlRfTEVOLCAiJXMiLCBpX3BvcnQpOworCXNucHJpbnRmKHByX3JlZy0+cHJfdHBvcnQsIFBSX0FQVFBMX01BWF9UUE9SVF9MRU4sICIlcyIsIHRfcG9ydCk7CisJcHJfcmVnLT5wcl9yZWdfdHBndCA9IHRwZ3Q7CisJLyoKKwkgKiBTZXQgcHJfcmVzX2hvbGRlciBmcm9tIGNhbGxlciwgdGhlIHByX3JlZyB3aG8gaXMgdGhlIHJlc2VydmF0aW9uCisJICogaG9sZGVyIHdpbGwgZ2V0IGl0J3MgcG9pbnRlciBzZXQgaW4gY29yZV9zY3NpM19hcHRwbF9yZXNlcnZlKCkgb25jZQorCSAqIHRoZSBJbml0aWF0b3IgTm9kZSBMVU4gQUNMIGZyb20gdGhlIGZhYnJpYyBtb2R1bGUgaXMgY3JlYXRlZCBmb3IKKwkgKiB0aGlzIHJlZ2lzdHJhdGlvbi4KKwkgKi8KKwlwcl9yZWctPnByX3Jlc19ob2xkZXIgPSByZXNfaG9sZGVyOworCisJbGlzdF9hZGRfdGFpbCgmcHJfcmVnLT5wcl9yZWdfYXB0cGxfbGlzdCwgJnByX3RtcGwtPmFwdHBsX3JlZ19saXN0KTsKKwlwcmludGsoS0VSTl9JTkZPICJTUEMtMyBQUiBBUFRQTCBTdWNjZXNzZnVsbHkgYWRkZWQgcmVnaXN0cmF0aW9uJXMgZnJvbSIKKwkJCSIgbWV0YWRhdGFcbiIsIChyZXNfaG9sZGVyKSA/ICIrcmVzZXJ2YXRpb24iIDogIiIpOworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBjb3JlX3Njc2kzX2FwdHBsX3Jlc2VydmUoCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZywKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKm5vZGVfYWNsLAorCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcpCit7CisJY2hhciBpX2J1ZltQUl9SRUdfSVNJRF9JRF9MRU5dOworCWludCBwcmZfaXNpZDsKKworCW1lbXNldChpX2J1ZiwgMCwgUFJfUkVHX0lTSURfSURfTEVOKTsKKwlwcmZfaXNpZCA9IGNvcmVfcHJfZHVtcF9pbml0aWF0b3JfcG9ydChwcl9yZWcsICZpX2J1ZlswXSwKKwkJCQlQUl9SRUdfSVNJRF9JRF9MRU4pOworCisJc3Bpbl9sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwlkZXYtPmRldl9wcl9yZXNfaG9sZGVyID0gcHJfcmVnOworCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKworCXByaW50ayhLRVJOX0lORk8gIlNQQy0zIFBSIFslc10gU2VydmljZSBBY3Rpb246IEFQVFBMIFJFU0VSVkUgY3JlYXRlZCIKKwkJIiBuZXcgcmVzZXJ2YXRpb24gaG9sZGVyIFRZUEU6ICVzIEFMTF9UR19QVDogJWRcbiIsCisJCVRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCWNvcmVfc2NzaTNfcHJfZHVtcF90eXBlKHByX3JlZy0+cHJfcmVzX3R5cGUpLAorCQkocHJfcmVnLT5wcl9yZWdfYWxsX3RnX3B0KSA/IDEgOiAwKTsKKwlwcmludGsoS0VSTl9JTkZPICJTUEMtMyBQUiBbJXNdIFJFU0VSVkUgTm9kZTogJXMlc1xuIiwKKwkJVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSwgbm9kZV9hY2wtPmluaXRpYXRvcm5hbWUsCisJCShwcmZfaXNpZCkgPyAmaV9idWZbMF0gOiAiIik7Cit9CisKK3N0YXRpYyB2b2lkIF9fY29yZV9zY3NpM19hZGRfcmVnaXN0cmF0aW9uKHN0cnVjdCBzZV9kZXZpY2UgKiwgc3RydWN0IHNlX25vZGVfYWNsICosCisJCQkJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKiwgaW50LCBpbnQpOworCitzdGF0aWMgaW50IF9fY29yZV9zY3NpM19jaGVja19hcHRwbF9yZWdpc3RyYXRpb24oCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZywKKwlzdHJ1Y3Qgc2VfbHVuICpsdW4sCisJdTMyIHRhcmdldF9sdW4sCisJc3RydWN0IHNlX25vZGVfYWNsICpuYWNsLAorCXN0cnVjdCBzZV9kZXZfZW50cnkgKmRldmUpCit7CisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKnByX3JlZywgKnByX3JlZ190bXA7CisJc3RydWN0IHQxMF9yZXNlcnZhdGlvbl90ZW1wbGF0ZSAqcHJfdG1wbCA9ICZTVV9ERVYoZGV2KS0+dDEwX3Jlc2VydmF0aW9uOworCXVuc2lnbmVkIGNoYXIgaV9wb3J0W1BSX0FQVFBMX01BWF9JUE9SVF9MRU5dOworCXVuc2lnbmVkIGNoYXIgdF9wb3J0W1BSX0FQVFBMX01BWF9UUE9SVF9MRU5dOworCXUxNiB0cGd0OworCisJbWVtc2V0KGlfcG9ydCwgMCwgUFJfQVBUUExfTUFYX0lQT1JUX0xFTik7CisJbWVtc2V0KHRfcG9ydCwgMCwgUFJfQVBUUExfTUFYX1RQT1JUX0xFTik7CisJLyoKKwkgKiBDb3B5IEluaXRpYXRvciBQb3J0IGluZm9ybWF0aW9uIGZyb20gc3RydWN0IHNlX25vZGVfYWNsCisJICovCisJc25wcmludGYoaV9wb3J0LCBQUl9BUFRQTF9NQVhfSVBPUlRfTEVOLCAiJXMiLCBuYWNsLT5pbml0aWF0b3JuYW1lKTsKKwlzbnByaW50Zih0X3BvcnQsIFBSX0FQVFBMX01BWF9UUE9SVF9MRU4sICIlcyIsCisJCQlUUEdfVEZPKHRwZyktPnRwZ19nZXRfd3duKHRwZykpOworCXRwZ3QgPSBUUEdfVEZPKHRwZyktPnRwZ19nZXRfdGFnKHRwZyk7CisJLyoKKwkgKiBMb29rIGZvciB0aGUgbWF0Y2hpbmcgcmVnaXN0cmF0aW9ucytyZXNlcnZhdGlvbiBmcm9tIHRob3NlCisJICogY3JlYXRlZCBmcm9tIEFQVFBMIG1ldGFkYXRhLiAgTm90ZSB0aGF0IG11bHRpcGxlIHJlZ2lzdHJhdGlvbnMKKwkgKiBtYXkgZXhpc3QgZm9yIGZhYnJpY3MgdGhhdCB1c2UgSVNJRHMgaW4gdGhlaXIgU0NTSSBJbml0aWF0b3IgUG9ydAorCSAqIFRyYW5zcG9ydElEcy4KKwkgKi8KKwlzcGluX2xvY2soJnByX3RtcGwtPmFwdHBsX3JlZ19sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocHJfcmVnLCBwcl9yZWdfdG1wLCAmcHJfdG1wbC0+YXB0cGxfcmVnX2xpc3QsCisJCQkJcHJfcmVnX2FwdHBsX2xpc3QpIHsKKwkJaWYgKCEoc3RyY21wKHByX3JlZy0+cHJfaXBvcnQsIGlfcG9ydCkpICYmCisJCSAgICAgKHByX3JlZy0+cHJfcmVzX21hcHBlZF9sdW4gPT0gZGV2ZS0+bWFwcGVkX2x1bikgJiYKKwkJICAgICEoc3RyY21wKHByX3JlZy0+cHJfdHBvcnQsIHRfcG9ydCkpICYmCisJCSAgICAgKHByX3JlZy0+cHJfcmVnX3RwZ3QgPT0gdHBndCkgJiYKKwkJICAgICAocHJfcmVnLT5wcl9hcHRwbF90YXJnZXRfbHVuID09IHRhcmdldF9sdW4pKSB7CisKKwkJCXByX3JlZy0+cHJfcmVnX25hY2wgPSBuYWNsOworCQkJcHJfcmVnLT5wcl9yZWdfZGV2ZSA9IGRldmU7CisJCQlwcl9yZWctPnByX3JlZ190Z19wdF9sdW4gPSBsdW47CisKKwkJCWxpc3RfZGVsKCZwcl9yZWctPnByX3JlZ19hcHRwbF9saXN0KTsKKwkJCXNwaW5fdW5sb2NrKCZwcl90bXBsLT5hcHRwbF9yZWdfbG9jayk7CisJCQkvKgorCQkJICogQXQgdGhpcyBwb2ludCBhbGwgb2YgdGhlIHBvaW50ZXJzIGluICpwcl9yZWcgd2lsbAorCQkJICogYmUgc2V0dXAsIHNvIGdvIGFoZWFkIGFuZCBhZGQgdGhlIHJlZ2lzdHJhdGlvbi4KKwkJCSAqLworCisJCQlfX2NvcmVfc2NzaTNfYWRkX3JlZ2lzdHJhdGlvbihkZXYsIG5hY2wsIHByX3JlZywgMCwgMCk7CisJCQkvKgorCQkJICogSWYgdGhpcyByZWdpc3RyYXRpb24gaXMgdGhlIHJlc2VydmF0aW9uIGhvbGRlciwKKwkJCSAqIG1ha2UgdGhhdCBoYXBwZW4gbm93Li4KKwkJCSAqLworCQkJaWYgKHByX3JlZy0+cHJfcmVzX2hvbGRlcikKKwkJCQljb3JlX3Njc2kzX2FwdHBsX3Jlc2VydmUoZGV2LCB0cGcsCisJCQkJCQluYWNsLCBwcl9yZWcpOworCQkJLyoKKwkJCSAqIFJlZW5hYmxlIHByX2FwdHBsX2FjdGl2ZSB0byBhY2NlcHQgbmV3IG1ldGFkYXRhCisJCQkgKiB1cGRhdGVzIG9uY2UgdGhlIFNDU0kgZGV2aWNlIGlzIGFjdGl2ZSBhZ2Fpbi4uCisJCQkgKi8KKwkJCXNwaW5fbG9jaygmcHJfdG1wbC0+YXB0cGxfcmVnX2xvY2spOworCQkJcHJfdG1wbC0+cHJfYXB0cGxfYWN0aXZlID0gMTsKKwkJfQorCX0KKwlzcGluX3VubG9jaygmcHJfdG1wbC0+YXB0cGxfcmVnX2xvY2spOworCisJcmV0dXJuIDA7Cit9CisKK2ludCBjb3JlX3Njc2kzX2NoZWNrX2FwdHBsX3JlZ2lzdHJhdGlvbigKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnLAorCXN0cnVjdCBzZV9sdW4gKmx1biwKKwlzdHJ1Y3Qgc2VfbHVuX2FjbCAqbHVuX2FjbCkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2ID0gU1VfREVWKGRldik7CisJc3RydWN0IHNlX25vZGVfYWNsICpuYWNsID0gbHVuX2FjbC0+c2VfbHVuX25hY2w7CisJc3RydWN0IHNlX2Rldl9lbnRyeSAqZGV2ZSA9ICZuYWNsLT5kZXZpY2VfbGlzdFtsdW5fYWNsLT5tYXBwZWRfbHVuXTsKKworCWlmIChUMTBfUkVTKHN1X2RldiktPnJlc190eXBlICE9IFNQQzNfUEVSU0lTVEVOVF9SRVNFUlZBVElPTlMpCisJCXJldHVybiAwOworCisJcmV0dXJuIF9fY29yZV9zY3NpM19jaGVja19hcHRwbF9yZWdpc3RyYXRpb24oZGV2LCB0cGcsIGx1biwKKwkJCQlsdW4tPnVucGFja2VkX2x1biwgbmFjbCwgZGV2ZSk7Cit9CisKK3N0YXRpYyB2b2lkIF9fY29yZV9zY3NpM19kdW1wX3JlZ2lzdHJhdGlvbigKKwlzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcyAqdGZvLAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKm5hY2wsCisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKnByX3JlZywKKwlpbnQgcmVnaXN0ZXJfdHlwZSkKK3sKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcgPSBuYWNsLT5zZV90cGc7CisJY2hhciBpX2J1ZltQUl9SRUdfSVNJRF9JRF9MRU5dOworCWludCBwcmZfaXNpZDsKKworCW1lbXNldCgmaV9idWZbMF0sIDAsIFBSX1JFR19JU0lEX0lEX0xFTik7CisJcHJmX2lzaWQgPSBjb3JlX3ByX2R1bXBfaW5pdGlhdG9yX3BvcnQocHJfcmVnLCAmaV9idWZbMF0sCisJCQkJUFJfUkVHX0lTSURfSURfTEVOKTsKKworCXByaW50ayhLRVJOX0lORk8gIlNQQy0zIFBSIFslc10gU2VydmljZSBBY3Rpb246IFJFR0lTVEVSJXMgSW5pdGlhdG9yIgorCQkiIE5vZGU6ICVzJXNcbiIsIHRmby0+Z2V0X2ZhYnJpY19uYW1lKCksIChyZWdpc3Rlcl90eXBlID09IDIpID8KKwkJIl9BTkRfTU9WRSIgOiAocmVnaXN0ZXJfdHlwZSA9PSAxKSA/CisJCSJfQU5EX0lHTk9SRV9FWElTVElOR19LRVkiIDogIiIsIG5hY2wtPmluaXRpYXRvcm5hbWUsCisJCShwcmZfaXNpZCkgPyBpX2J1ZiA6ICIiKTsKKwlwcmludGsoS0VSTl9JTkZPICJTUEMtMyBQUiBbJXNdIHJlZ2lzdHJhdGlvbiBvbiBUYXJnZXQgUG9ydDogJXMsMHglMDR4XG4iLAorCQkgdGZvLT5nZXRfZmFicmljX25hbWUoKSwgdGZvLT50cGdfZ2V0X3d3bihzZV90cGcpLAorCQl0Zm8tPnRwZ19nZXRfdGFnKHNlX3RwZykpOworCXByaW50ayhLRVJOX0lORk8gIlNQQy0zIFBSIFslc10gZm9yICVzIFRDTSBTdWJzeXN0ZW0gJXMgT2JqZWN0IFRhcmdldCIKKwkJIiBQb3J0KHMpXG4iLCAgdGZvLT5nZXRfZmFicmljX25hbWUoKSwKKwkJKHByX3JlZy0+cHJfcmVnX2FsbF90Z19wdCkgPyAiQUxMIiA6ICJTSU5HTEUiLAorCQlUUkFOU1BPUlQoZGV2KS0+bmFtZSk7CisJcHJpbnRrKEtFUk5fSU5GTyAiU1BDLTMgUFIgWyVzXSBTQSBSZXMgS2V5OiAweCUwMTZMeCBQUmdlbmVyYXRpb246IgorCQkiIDB4JTA4eCAgQVBUUEw6ICVkXG4iLCB0Zm8tPmdldF9mYWJyaWNfbmFtZSgpLAorCQlwcl9yZWctPnByX3Jlc19rZXksIHByX3JlZy0+cHJfcmVzX2dlbmVyYXRpb24sCisJCXByX3JlZy0+cHJfcmVnX2FwdHBsKTsKK30KKworLyoKKyAqIHRoaXMgZnVuY3Rpb24gY2FuIGJlIGNhbGxlZCB3aXRoIHN0cnVjdCBzZV9kZXZpY2UtPmRldl9yZXNlcnZhdGlvbl9sb2NrCisgKiB3aGVuIHJlZ2lzdGVyX21vdmUgPSAxCisgKi8KK3N0YXRpYyB2b2lkIF9fY29yZV9zY3NpM19hZGRfcmVnaXN0cmF0aW9uKAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKm5hY2wsCisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKnByX3JlZywKKwlpbnQgcmVnaXN0ZXJfdHlwZSwKKwlpbnQgcmVnaXN0ZXJfbW92ZSkKK3sKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2ID0gU1VfREVWKGRldik7CisJc3RydWN0IHRhcmdldF9jb3JlX2ZhYnJpY19vcHMgKnRmbyA9IG5hY2wtPnNlX3RwZy0+c2VfdHBnX3RmbzsKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnX3RtcCwgKnByX3JlZ190bXBfc2FmZTsKKwlzdHJ1Y3QgdDEwX3Jlc2VydmF0aW9uX3RlbXBsYXRlICpwcl90bXBsID0gJlNVX0RFVihkZXYpLT50MTBfcmVzZXJ2YXRpb247CisKKwkvKgorCSAqIEluY3JlbWVudCBQUmdlbmVyYXRpb24gY291bnRlciBmb3Igc3RydWN0IHNlX2RldmljZSB1cG9uIGEgc3VjY2Vzc2Z1bAorCSAqIFJFR0lTVEVSLCBzZWUgc3BjNHIxNyBzZWN0aW9uIDYuMy4yIFJFQURfS0VZUyBzZXJ2aWNlIGFjdGlvbgorCSAqCisJICogQWxzbywgd2hlbiByZWdpc3Rlcl9tb3ZlID0gMSBmb3IgUFJPVVQgUkVHSVNURVJfQU5EX01PVkUgc2VydmljZQorCSAqIGFjdGlvbiwgdGhlIHN0cnVjdCBzZV9kZXZpY2UtPmRldl9yZXNlcnZhdGlvbl9sb2NrIHdpbGwgYWxyZWFkeSBiZSBoZWxkLAorCSAqIHNvIHdlIGRvIG5vdCBjYWxsIGNvcmVfc2NzaTNfcHJfZ2VuZXJhdGlvbigpIHdoaWNoIGdyYWJzIHRoZSBsb2NrCisJICogZm9yIHRoZSBSRUdJU1RFUi4KKwkgKi8KKwlwcl9yZWctPnByX3Jlc19nZW5lcmF0aW9uID0gKHJlZ2lzdGVyX21vdmUpID8KKwkJCVQxMF9SRVMoc3VfZGV2KS0+cHJfZ2VuZXJhdGlvbisrIDoKKwkJCWNvcmVfc2NzaTNfcHJfZ2VuZXJhdGlvbihkZXYpOworCisJc3Bpbl9sb2NrKCZwcl90bXBsLT5yZWdpc3RyYXRpb25fbG9jayk7CisJbGlzdF9hZGRfdGFpbCgmcHJfcmVnLT5wcl9yZWdfbGlzdCwgJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9saXN0KTsKKwlwcl9yZWctPnByX3JlZ19kZXZlLT5kZWZfcHJfcmVnaXN0ZXJlZCA9IDE7CisKKwlfX2NvcmVfc2NzaTNfZHVtcF9yZWdpc3RyYXRpb24odGZvLCBkZXYsIG5hY2wsIHByX3JlZywgcmVnaXN0ZXJfdHlwZSk7CisJc3Bpbl91bmxvY2soJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9sb2NrKTsKKwkvKgorCSAqIFNraXAgZXh0cmEgcHJvY2Vzc2luZyBmb3IgQUxMX1RHX1BUPTAgb3IgUkVHSVNURVJfQU5EX01PVkUuCisJICovCisJaWYgKCEocHJfcmVnLT5wcl9yZWdfYWxsX3RnX3B0KSB8fCAocmVnaXN0ZXJfbW92ZSkpCisJCXJldHVybjsKKwkvKgorCSAqIFdhbGsgcHJfcmVnLT5wcl9yZWdfYXRwX2xpc3QgYW5kIGFkZCByZWdpc3RyYXRpb25zIGZvciBBTExfVEdfUFQ9MQorCSAqIGFsbG9jYXRlZCBpbiBfX2NvcmVfc2NzaTNfYWxsb2NfcmVnaXN0cmF0aW9uKCkKKwkgKi8KKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocHJfcmVnX3RtcCwgcHJfcmVnX3RtcF9zYWZlLAorCQkJJnByX3JlZy0+cHJfcmVnX2F0cF9saXN0LCBwcl9yZWdfYXRwX21lbV9saXN0KSB7CisJCWxpc3RfZGVsKCZwcl9yZWdfdG1wLT5wcl9yZWdfYXRwX21lbV9saXN0KTsKKworCQlwcl9yZWdfdG1wLT5wcl9yZXNfZ2VuZXJhdGlvbiA9IGNvcmVfc2NzaTNfcHJfZ2VuZXJhdGlvbihkZXYpOworCisJCXNwaW5fbG9jaygmcHJfdG1wbC0+cmVnaXN0cmF0aW9uX2xvY2spOworCQlsaXN0X2FkZF90YWlsKCZwcl9yZWdfdG1wLT5wcl9yZWdfbGlzdCwKKwkJCSAgICAgICZwcl90bXBsLT5yZWdpc3RyYXRpb25fbGlzdCk7CisJCXByX3JlZ190bXAtPnByX3JlZ19kZXZlLT5kZWZfcHJfcmVnaXN0ZXJlZCA9IDE7CisKKwkJX19jb3JlX3Njc2kzX2R1bXBfcmVnaXN0cmF0aW9uKHRmbywgZGV2LAorCQkJCXByX3JlZ190bXAtPnByX3JlZ19uYWNsLCBwcl9yZWdfdG1wLAorCQkJCXJlZ2lzdGVyX3R5cGUpOworCQlzcGluX3VubG9jaygmcHJfdG1wbC0+cmVnaXN0cmF0aW9uX2xvY2spOworCQkvKgorCQkgKiBEcm9wIGNvbmZpZ2ZzIGdyb3VwIGRlcGVuZGVuY3kgcmVmZXJlbmNlIGZyb20KKwkJICogX19jb3JlX3Njc2kzX2FsbG9jX3JlZ2lzdHJhdGlvbigpCisJCSAqLworCQljb3JlX3Njc2kzX2x1bmFjbF91bmRlcGVuZF9pdGVtKHByX3JlZ190bXAtPnByX3JlZ19kZXZlKTsKKwl9Cit9CisKK3N0YXRpYyBpbnQgY29yZV9zY3NpM19hbGxvY19yZWdpc3RyYXRpb24oCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCXN0cnVjdCBzZV9ub2RlX2FjbCAqbmFjbCwKKwlzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICpkZXZlLAorCXVuc2lnbmVkIGNoYXIgKmlzaWQsCisJdTY0IHNhX3Jlc19rZXksCisJaW50IGFsbF90Z19wdCwKKwlpbnQgYXB0cGwsCisJaW50IHJlZ2lzdGVyX3R5cGUsCisJaW50IHJlZ2lzdGVyX21vdmUpCit7CisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKnByX3JlZzsKKworCXByX3JlZyA9IF9fY29yZV9zY3NpM19hbGxvY19yZWdpc3RyYXRpb24oZGV2LCBuYWNsLCBkZXZlLCBpc2lkLAorCQkJc2FfcmVzX2tleSwgYWxsX3RnX3B0LCBhcHRwbCk7CisJaWYgKCEocHJfcmVnKSkKKwkJcmV0dXJuIC0xOworCisJX19jb3JlX3Njc2kzX2FkZF9yZWdpc3RyYXRpb24oZGV2LCBuYWNsLCBwcl9yZWcsCisJCQlyZWdpc3Rlcl90eXBlLCByZWdpc3Rlcl9tb3ZlKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpfX2NvcmVfc2NzaTNfbG9jYXRlX3ByX3JlZygKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsCisJc3RydWN0IHNlX25vZGVfYWNsICpuYWNsLAorCXVuc2lnbmVkIGNoYXIgKmlzaWQpCit7CisJc3RydWN0IHQxMF9yZXNlcnZhdGlvbl90ZW1wbGF0ZSAqcHJfdG1wbCA9ICZTVV9ERVYoZGV2KS0+dDEwX3Jlc2VydmF0aW9uOworCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsICpwcl9yZWdfdG1wOworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZzsKKworCXNwaW5fbG9jaygmcHJfdG1wbC0+cmVnaXN0cmF0aW9uX2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShwcl9yZWcsIHByX3JlZ190bXAsCisJCQkmcHJfdG1wbC0+cmVnaXN0cmF0aW9uX2xpc3QsIHByX3JlZ19saXN0KSB7CisJCS8qCisJCSAqIEZpcnN0IGxvb2sgZm9yIGEgbWF0Y2hpbmcgc3RydWN0IHNlX25vZGVfYWNsCisJCSAqLworCQlpZiAocHJfcmVnLT5wcl9yZWdfbmFjbCAhPSBuYWNsKQorCQkJY29udGludWU7CisKKwkJdHBnID0gcHJfcmVnLT5wcl9yZWdfbmFjbC0+c2VfdHBnOworCQkvKgorCQkgKiBJZiB0aGlzIHJlZ2lzdHJhdGlvbiBkb2VzIE5PVCBjb250YWluIGEgZmFicmljIHByb3ZpZGVkCisJCSAqIElTSUQsIHRoZW4gd2UgaGF2ZSBmb3VuZCBhIG1hdGNoLgorCQkgKi8KKwkJaWYgKCEocHJfcmVnLT5pc2lkX3ByZXNlbnRfYXRfcmVnKSkgeworCQkJLyoKKwkJCSAqIERldGVybWluZSBpZiB0aGlzIFNDU0kgZGV2aWNlIHNlcnZlciByZXF1aXJlcyB0aGF0CisJCQkgKiBTQ1NJIEludGlhdGlvciBUcmFuc3BvcnRJRCB3LyBJU0lEcyBpcyBlbmZvcmNlZAorCQkJICogZm9yIGZhYnJpYyBtb2R1bGVzIChpU0NTSSkgcmVxdWlyaW5nIHRoZW0uCisJCQkgKi8KKwkJCWlmIChUUEdfVEZPKHRwZyktPnNlc3NfZ2V0X2luaXRpYXRvcl9zaWQgIT0gTlVMTCkgeworCQkJCWlmIChERVZfQVRUUklCKGRldiktPmVuZm9yY2VfcHJfaXNpZHMpCisJCQkJCWNvbnRpbnVlOworCQkJfQorCQkJYXRvbWljX2luYygmcHJfcmVnLT5wcl9yZXNfaG9sZGVycyk7CisJCQlzbXBfbWJfX2FmdGVyX2F0b21pY19pbmMoKTsKKwkJCXNwaW5fdW5sb2NrKCZwcl90bXBsLT5yZWdpc3RyYXRpb25fbG9jayk7CisJCQlyZXR1cm4gcHJfcmVnOworCQl9CisJCS8qCisJCSAqIElmIHRoZSAqcHJfcmVnIGNvbnRhaW5zIGEgZmFicmljIGRlZmluZWQgSVNJRCBmb3IgbXVsdGktdmFsdWUKKwkJICogU0NTSSBJbml0aWF0b3IgUG9ydCBUcmFuc3BvcnRJRHMsIHRoZW4gd2UgZXhwZWN0IGEgdmFsaWQKKwkJICogbWF0Y2hpbmcgSVNJRCB0byBiZSBwcm92aWRlZCBieSB0aGUgbG9jYWwgU0NTSSBJbml0aWF0b3IgUG9ydC4KKwkJICovCisJCWlmICghKGlzaWQpKQorCQkJY29udGludWU7CisJCWlmIChzdHJjbXAoaXNpZCwgcHJfcmVnLT5wcl9yZWdfaXNpZCkpCisJCQljb250aW51ZTsKKworCQlhdG9taWNfaW5jKCZwcl9yZWctPnByX3Jlc19ob2xkZXJzKTsKKwkJc21wX21iX19hZnRlcl9hdG9taWNfaW5jKCk7CisJCXNwaW5fdW5sb2NrKCZwcl90bXBsLT5yZWdpc3RyYXRpb25fbG9jayk7CisJCXJldHVybiBwcl9yZWc7CisJfQorCXNwaW5fdW5sb2NrKCZwcl90bXBsLT5yZWdpc3RyYXRpb25fbG9jayk7CisKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIHN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpjb3JlX3Njc2kzX2xvY2F0ZV9wcl9yZWcoCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCXN0cnVjdCBzZV9ub2RlX2FjbCAqbmFjbCwKKwlzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqc2VzcykKK3sKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcgPSBuYWNsLT5zZV90cGc7CisJdW5zaWduZWQgY2hhciBidWZbUFJfUkVHX0lTSURfTEVOXSwgKmlzaWRfcHRyID0gTlVMTDsKKworCWlmIChUUEdfVEZPKHRwZyktPnNlc3NfZ2V0X2luaXRpYXRvcl9zaWQgIT0gTlVMTCkgeworCQltZW1zZXQoJmJ1ZlswXSwgMCwgUFJfUkVHX0lTSURfTEVOKTsKKwkJVFBHX1RGTyh0cGcpLT5zZXNzX2dldF9pbml0aWF0b3Jfc2lkKHNlc3MsICZidWZbMF0sCisJCQkJCVBSX1JFR19JU0lEX0xFTik7CisJCWlzaWRfcHRyID0gJmJ1ZlswXTsKKwl9CisKKwlyZXR1cm4gX19jb3JlX3Njc2kzX2xvY2F0ZV9wcl9yZWcoZGV2LCBuYWNsLCBpc2lkX3B0cik7Cit9CisKK3N0YXRpYyB2b2lkIGNvcmVfc2NzaTNfcHV0X3ByX3JlZyhzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnKQoreworCWF0b21pY19kZWMoJnByX3JlZy0+cHJfcmVzX2hvbGRlcnMpOworCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworfQorCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfY2hlY2tfaW1wbGljdF9yZWxlYXNlKAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnKQoreworCXN0cnVjdCBzZV9ub2RlX2FjbCAqbmFjbCA9IHByX3JlZy0+cHJfcmVnX25hY2w7CisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKnByX3Jlc19ob2xkZXI7CisJaW50IHJldCA9IDA7CisKKwlzcGluX2xvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCXByX3Jlc19ob2xkZXIgPSBkZXYtPmRldl9wcl9yZXNfaG9sZGVyOworCWlmICghKHByX3Jlc19ob2xkZXIpKSB7CisJCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwkJcmV0dXJuIHJldDsKKwl9CisJaWYgKHByX3Jlc19ob2xkZXIgPT0gcHJfcmVnKSB7CisJCS8qCisJCSAqIFBlcmZvcm0gYW4gaW1wbGljdCBSRUxFQVNFIGlmIHRoZSByZWdpc3RyYXRpb24gdGhhdAorCQkgKiBpcyBiZWluZyByZWxlYXNlZCBpcyBob2xkaW5nIHRoZSByZXNlcnZhdGlvbi4KKwkJICoKKwkJICogRnJvbSBzcGM0cjE3LCBzZWN0aW9uIDUuNy4xMS4xOgorCQkgKgorCQkgKiBlKSBJZiB0aGUgSV9UIG5leHVzIGlzIHRoZSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIGhvbGRlcgorCQkgKiAgICBhbmQgdGhlIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gaXMgbm90IGFuIGFsbCByZWdpc3RyYW50cworCQkgKiAgICB0eXBlLCB0aGVuIGEgUEVSU0lTVEVOVCBSRVNFUlZFIE9VVCBjb21tYW5kIHdpdGggUkVHSVNURVIKKwkJICogICAgc2VydmljZSBhY3Rpb24gb3IgUkVHSVNURVIgQU5EICBJR05PUkUgRVhJU1RJTkcgS0VZCisJCSAqICAgIHNlcnZpY2UgYWN0aW9uIHdpdGggdGhlIFNFUlZJQ0UgQUNUSU9OIFJFU0VSVkFUSU9OIEtFWQorCQkgKiAgICBmaWVsZCBzZXQgdG8gemVybyAoc2VlIDUuNy4xMS4zKS4KKwkJICovCisJCV9fY29yZV9zY3NpM19jb21wbGV0ZV9wcm9fcmVsZWFzZShkZXYsIG5hY2wsIHByX3JlZywgMCk7CisJCXJldCA9IDE7CisJCS8qCisJCSAqIEZvciAnQWxsIFJlZ2lzdHJhbnRzJyByZXNlcnZhdGlvbiB0eXBlcywgYWxsIGV4aXN0aW5nCisJCSAqIHJlZ2lzdHJhdGlvbnMgYXJlIHN0aWxsIHByb2Nlc3NlZCBhcyByZXNlcnZhdGlvbiBob2xkZXJzCisJCSAqIGluIGNvcmVfc2NzaTNfcHJfc2VxX25vbl9ob2xkZXIoKSBhZnRlciB0aGUgaW5pdGlhbAorCQkgKiByZXNlcnZhdGlvbiBob2xkZXIgaXMgaW1wbGljdGx5IHJlbGVhc2VkIGhlcmUuCisJCSAqLworCX0gZWxzZSBpZiAocHJfcmVnLT5wcl9yZWdfYWxsX3RnX3B0ICYmCisJCSAgKCFzdHJjbXAocHJfcmVzX2hvbGRlci0+cHJfcmVnX25hY2wtPmluaXRpYXRvcm5hbWUsCisJCQkgIHByX3JlZy0+cHJfcmVnX25hY2wtPmluaXRpYXRvcm5hbWUpKSAmJgorCQkgIChwcl9yZXNfaG9sZGVyLT5wcl9yZXNfa2V5ID09IHByX3JlZy0+cHJfcmVzX2tleSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJTUEMtMyBQUjogVW5hYmxlIHRvIHBlcmZvcm0gQUxMX1RHX1BUPTEiCisJCQkiIFVOUkVHSVNURVIgd2hpbGUgZXhpc3RpbmcgcmVzZXJ2YXRpb24gd2l0aCBtYXRjaGluZyIKKwkJCSIga2V5IDB4JTAxNkx4IGlzIHByZXNlbnQgZnJvbSBhbm90aGVyIFNDU0kgSW5pdGlhdG9yIgorCQkJIiBQb3J0XG4iLCBwcl9yZWctPnByX3Jlc19rZXkpOworCQlyZXQgPSAtMTsKKwl9CisJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCisJcmV0dXJuIHJldDsKK30KKworLyoKKyAqIENhbGxlZCB3aXRoIHN0cnVjdCB0MTBfcmVzZXJ2YXRpb25fdGVtcGxhdGUtPnJlZ2lzdHJhdGlvbl9sb2NrIGhlbGQuCisgKi8KK3N0YXRpYyB2b2lkIF9fY29yZV9zY3NpM19mcmVlX3JlZ2lzdHJhdGlvbigKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsCisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKnByX3JlZywKKwlzdHJ1Y3QgbGlzdF9oZWFkICpwcmVlbXB0X2FuZF9hYm9ydF9saXN0LAorCWludCBkZWNfaG9sZGVycykKK3sKKwlzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcyAqdGZvID0KKwkJCXByX3JlZy0+cHJfcmVnX25hY2wtPnNlX3RwZy0+c2VfdHBnX3RmbzsKKwlzdHJ1Y3QgdDEwX3Jlc2VydmF0aW9uX3RlbXBsYXRlICpwcl90bXBsID0gJlNVX0RFVihkZXYpLT50MTBfcmVzZXJ2YXRpb247CisJY2hhciBpX2J1ZltQUl9SRUdfSVNJRF9JRF9MRU5dOworCWludCBwcmZfaXNpZDsKKworCW1lbXNldChpX2J1ZiwgMCwgUFJfUkVHX0lTSURfSURfTEVOKTsKKwlwcmZfaXNpZCA9IGNvcmVfcHJfZHVtcF9pbml0aWF0b3JfcG9ydChwcl9yZWcsICZpX2J1ZlswXSwKKwkJCQlQUl9SRUdfSVNJRF9JRF9MRU4pOworCisJcHJfcmVnLT5wcl9yZWdfZGV2ZS0+ZGVmX3ByX3JlZ2lzdGVyZWQgPSAwOworCXByX3JlZy0+cHJfcmVnX2RldmUtPnByX3Jlc19rZXkgPSAwOworCWxpc3RfZGVsKCZwcl9yZWctPnByX3JlZ19saXN0KTsKKwkvKgorCSAqIENhbGxlciBhY2Nlc3NpbmcgKnByX3JlZyB1c2luZyBjb3JlX3Njc2kzX2xvY2F0ZV9wcl9yZWcoKSwKKwkgKiBzbyBjYWxsIGNvcmVfc2NzaTNfcHV0X3ByX3JlZygpIHRvIGRlY3JlbWVudCBvdXIgcmVmZXJlbmNlLgorCSAqLworCWlmIChkZWNfaG9sZGVycykKKwkJY29yZV9zY3NpM19wdXRfcHJfcmVnKHByX3JlZyk7CisJLyoKKwkgKiBXYWl0IHVudGlsIGFsbCByZWZlcmVuY2UgZnJvbSBhbnkgb3RoZXIgSV9UIG5leHVzZXMgZm9yIHRoaXMKKwkgKiAqcHJfcmVnIGhhdmUgYmVlbiByZWxlYXNlZC4gIEJlY2F1c2UgbGlzdF9kZWwoKSBpcyBjYWxsZWQgYWJvdmUsCisJICogdGhlIGxhc3QgY29yZV9zY3NpM19wdXRfcHJfcmVnKHByX3JlZykgd2lsbCByZWxlYXNlIHRoaXMgcmVmZXJlbmNlCisJICogY291bnQgYmFjayB0byB6ZXJvLCBhbmQgd2UgcmVsZWFzZSAqcHJfcmVnLgorCSAqLworCXdoaWxlIChhdG9taWNfcmVhZCgmcHJfcmVnLT5wcl9yZXNfaG9sZGVycykgIT0gMCkgeworCQlzcGluX3VubG9jaygmcHJfdG1wbC0+cmVnaXN0cmF0aW9uX2xvY2spOworCQlwcmludGsoIlNQQy0zIFBSIFslc10gd2FpdGluZyBmb3IgcHJfcmVzX2hvbGRlcnNcbiIsCisJCQkJdGZvLT5nZXRfZmFicmljX25hbWUoKSk7CisJCWNwdV9yZWxheCgpOworCQlzcGluX2xvY2soJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9sb2NrKTsKKwl9CisKKwlwcmludGsoS0VSTl9JTkZPICJTUEMtMyBQUiBbJXNdIFNlcnZpY2UgQWN0aW9uOiBVTlJFR0lTVEVSIEluaXRpYXRvciIKKwkJIiBOb2RlOiAlcyVzXG4iLCB0Zm8tPmdldF9mYWJyaWNfbmFtZSgpLAorCQlwcl9yZWctPnByX3JlZ19uYWNsLT5pbml0aWF0b3JuYW1lLAorCQkocHJmX2lzaWQpID8gJmlfYnVmWzBdIDogIiIpOworCXByaW50ayhLRVJOX0lORk8gIlNQQy0zIFBSIFslc10gZm9yICVzIFRDTSBTdWJzeXN0ZW0gJXMgT2JqZWN0IFRhcmdldCIKKwkJIiBQb3J0KHMpXG4iLCB0Zm8tPmdldF9mYWJyaWNfbmFtZSgpLAorCQkocHJfcmVnLT5wcl9yZWdfYWxsX3RnX3B0KSA/ICJBTEwiIDogIlNJTkdMRSIsCisJCVRSQU5TUE9SVChkZXYpLT5uYW1lKTsKKwlwcmludGsoS0VSTl9JTkZPICJTUEMtMyBQUiBbJXNdIFNBIFJlcyBLZXk6IDB4JTAxNkx4IFBSZ2VuZXJhdGlvbjoiCisJCSIgMHglMDh4XG4iLCB0Zm8tPmdldF9mYWJyaWNfbmFtZSgpLCBwcl9yZWctPnByX3Jlc19rZXksCisJCXByX3JlZy0+cHJfcmVzX2dlbmVyYXRpb24pOworCisJaWYgKCEocHJlZW1wdF9hbmRfYWJvcnRfbGlzdCkpIHsKKwkJcHJfcmVnLT5wcl9yZWdfZGV2ZSA9IE5VTEw7CisJCXByX3JlZy0+cHJfcmVnX25hY2wgPSBOVUxMOworCQlrZnJlZShwcl9yZWctPnByX2FwdHBsX2J1Zik7CisJCWttZW1fY2FjaGVfZnJlZSh0MTBfcHJfcmVnX2NhY2hlLCBwcl9yZWcpOworCQlyZXR1cm47CisJfQorCS8qCisJICogRm9yIFBSRUVNUFRfQU5EX0FCT1JULCB0aGUgbGlzdCBvZiAqcHJfcmVnIGluIHByZWVtcHRfYW5kX2Fib3J0X2xpc3QKKwkgKiBhcmUgcmVsZWFzZWQgb25jZSB0aGUgQUJPUlRfVEFTS19TRVQgaGFzIGNvbXBsZXRlZC4uCisJICovCisJbGlzdF9hZGRfdGFpbCgmcHJfcmVnLT5wcl9yZWdfYWJvcnRfbGlzdCwgcHJlZW1wdF9hbmRfYWJvcnRfbGlzdCk7Cit9CisKK3ZvaWQgY29yZV9zY3NpM19mcmVlX3ByX3JlZ19mcm9tX25hY2woCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCXN0cnVjdCBzZV9ub2RlX2FjbCAqbmFjbCkKK3sKKwlzdHJ1Y3QgdDEwX3Jlc2VydmF0aW9uX3RlbXBsYXRlICpwcl90bXBsID0gJlNVX0RFVihkZXYpLT50MTBfcmVzZXJ2YXRpb247CisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKnByX3JlZywgKnByX3JlZ190bXAsICpwcl9yZXNfaG9sZGVyOworCS8qCisJICogSWYgdGhlIHBhc3NlZCBzZV9ub2RlX2FjbCBtYXRjaGVzIHRoZSByZXNlcnZhdGlvbiBob2xkZXIsCisJICogcmVsZWFzZSB0aGUgcmVzZXJ2YXRpb24uCisJICovCisJc3Bpbl9sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwlwcl9yZXNfaG9sZGVyID0gZGV2LT5kZXZfcHJfcmVzX2hvbGRlcjsKKwlpZiAoKHByX3Jlc19ob2xkZXIgIT0gTlVMTCkgJiYKKwkgICAgKHByX3Jlc19ob2xkZXItPnByX3JlZ19uYWNsID09IG5hY2wpKQorCQlfX2NvcmVfc2NzaTNfY29tcGxldGVfcHJvX3JlbGVhc2UoZGV2LCBuYWNsLCBwcl9yZXNfaG9sZGVyLCAwKTsKKwlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJLyoKKwkgKiBSZWxlYXNlIGFueSByZWdpc3RyYXRpb24gYXNzb2NpYXRlZCB3aXRoIHRoZSBzdHJ1Y3Qgc2Vfbm9kZV9hY2wuCisJICovCisJc3Bpbl9sb2NrKCZwcl90bXBsLT5yZWdpc3RyYXRpb25fbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHByX3JlZywgcHJfcmVnX3RtcCwKKwkJCSZwcl90bXBsLT5yZWdpc3RyYXRpb25fbGlzdCwgcHJfcmVnX2xpc3QpIHsKKworCQlpZiAocHJfcmVnLT5wcl9yZWdfbmFjbCAhPSBuYWNsKQorCQkJY29udGludWU7CisKKwkJX19jb3JlX3Njc2kzX2ZyZWVfcmVnaXN0cmF0aW9uKGRldiwgcHJfcmVnLCBOVUxMLCAwKTsKKwl9CisJc3Bpbl91bmxvY2soJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9sb2NrKTsKK30KKwordm9pZCBjb3JlX3Njc2kzX2ZyZWVfYWxsX3JlZ2lzdHJhdGlvbnMoCisJc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXN0cnVjdCB0MTBfcmVzZXJ2YXRpb25fdGVtcGxhdGUgKnByX3RtcGwgPSAmU1VfREVWKGRldiktPnQxMF9yZXNlcnZhdGlvbjsKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnLCAqcHJfcmVnX3RtcCwgKnByX3Jlc19ob2xkZXI7CisKKwlzcGluX2xvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCXByX3Jlc19ob2xkZXIgPSBkZXYtPmRldl9wcl9yZXNfaG9sZGVyOworCWlmIChwcl9yZXNfaG9sZGVyICE9IE5VTEwpIHsKKwkJc3RydWN0IHNlX25vZGVfYWNsICpwcl9yZXNfbmFjbCA9IHByX3Jlc19ob2xkZXItPnByX3JlZ19uYWNsOworCQlfX2NvcmVfc2NzaTNfY29tcGxldGVfcHJvX3JlbGVhc2UoZGV2LCBwcl9yZXNfbmFjbCwKKwkJCQlwcl9yZXNfaG9sZGVyLCAwKTsKKwl9CisJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCisJc3Bpbl9sb2NrKCZwcl90bXBsLT5yZWdpc3RyYXRpb25fbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHByX3JlZywgcHJfcmVnX3RtcCwKKwkJCSZwcl90bXBsLT5yZWdpc3RyYXRpb25fbGlzdCwgcHJfcmVnX2xpc3QpIHsKKworCQlfX2NvcmVfc2NzaTNfZnJlZV9yZWdpc3RyYXRpb24oZGV2LCBwcl9yZWcsIE5VTEwsIDApOworCX0KKwlzcGluX3VubG9jaygmcHJfdG1wbC0+cmVnaXN0cmF0aW9uX2xvY2spOworCisJc3Bpbl9sb2NrKCZwcl90bXBsLT5hcHRwbF9yZWdfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHByX3JlZywgcHJfcmVnX3RtcCwgJnByX3RtcGwtPmFwdHBsX3JlZ19saXN0LAorCQkJCXByX3JlZ19hcHRwbF9saXN0KSB7CisJCWxpc3RfZGVsKCZwcl9yZWctPnByX3JlZ19hcHRwbF9saXN0KTsKKwkJa2ZyZWUocHJfcmVnLT5wcl9hcHRwbF9idWYpOworCQlrbWVtX2NhY2hlX2ZyZWUodDEwX3ByX3JlZ19jYWNoZSwgcHJfcmVnKTsKKwl9CisJc3Bpbl91bmxvY2soJnByX3RtcGwtPmFwdHBsX3JlZ19sb2NrKTsKK30KKworc3RhdGljIGludCBjb3JlX3Njc2kzX3RwZ19kZXBlbmRfaXRlbShzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcpCit7CisJcmV0dXJuIGNvbmZpZ2ZzX2RlcGVuZF9pdGVtKFRQR19URk8odHBnKS0+dGZfc3Vic3lzLAorCQkJJnRwZy0+dHBnX2dyb3VwLmNnX2l0ZW0pOworfQorCitzdGF0aWMgdm9pZCBjb3JlX3Njc2kzX3RwZ191bmRlcGVuZF9pdGVtKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZykKK3sKKwljb25maWdmc191bmRlcGVuZF9pdGVtKFRQR19URk8odHBnKS0+dGZfc3Vic3lzLAorCQkJJnRwZy0+dHBnX2dyb3VwLmNnX2l0ZW0pOworCisJYXRvbWljX2RlYygmdHBnLT50cGdfcHJfcmVmX2NvdW50KTsKKwlzbXBfbWJfX2FmdGVyX2F0b21pY19kZWMoKTsKK30KKworc3RhdGljIGludCBjb3JlX3Njc2kzX25vZGVhY2xfZGVwZW5kX2l0ZW0oc3RydWN0IHNlX25vZGVfYWNsICpuYWNsKQoreworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZyA9IG5hY2wtPnNlX3RwZzsKKworCWlmIChuYWNsLT5keW5hbWljX25vZGVfYWNsKQorCQlyZXR1cm4gMDsKKworCXJldHVybiBjb25maWdmc19kZXBlbmRfaXRlbShUUEdfVEZPKHRwZyktPnRmX3N1YnN5cywKKwkJCSZuYWNsLT5hY2xfZ3JvdXAuY2dfaXRlbSk7Cit9CisKK3N0YXRpYyB2b2lkIGNvcmVfc2NzaTNfbm9kZWFjbF91bmRlcGVuZF9pdGVtKHN0cnVjdCBzZV9ub2RlX2FjbCAqbmFjbCkKK3sKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcgPSBuYWNsLT5zZV90cGc7CisKKwlpZiAobmFjbC0+ZHluYW1pY19ub2RlX2FjbCkgeworCQlhdG9taWNfZGVjKCZuYWNsLT5hY2xfcHJfcmVmX2NvdW50KTsKKwkJc21wX21iX19hZnRlcl9hdG9taWNfZGVjKCk7CisJCXJldHVybjsKKwl9CisKKwljb25maWdmc191bmRlcGVuZF9pdGVtKFRQR19URk8odHBnKS0+dGZfc3Vic3lzLAorCQkJJm5hY2wtPmFjbF9ncm91cC5jZ19pdGVtKTsKKworCWF0b21pY19kZWMoJm5hY2wtPmFjbF9wcl9yZWZfY291bnQpOworCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworfQorCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfbHVuYWNsX2RlcGVuZF9pdGVtKHN0cnVjdCBzZV9kZXZfZW50cnkgKnNlX2RldmUpCit7CisJc3RydWN0IHNlX2x1bl9hY2wgKmx1bl9hY2wgPSBzZV9kZXZlLT5zZV9sdW5fYWNsOworCXN0cnVjdCBzZV9ub2RlX2FjbCAqbmFjbDsKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGc7CisJLyoKKwkgKiBGb3IgbmFjbC0+ZHluYW1pY19ub2RlX2FjbD0xCisJICovCisJaWYgKCEobHVuX2FjbCkpCisJCXJldHVybiAwOworCisJbmFjbCA9IGx1bl9hY2wtPnNlX2x1bl9uYWNsOworCXRwZyA9IG5hY2wtPnNlX3RwZzsKKworCXJldHVybiBjb25maWdmc19kZXBlbmRfaXRlbShUUEdfVEZPKHRwZyktPnRmX3N1YnN5cywKKwkJCSZsdW5fYWNsLT5zZV9sdW5fZ3JvdXAuY2dfaXRlbSk7Cit9CisKK3N0YXRpYyB2b2lkIGNvcmVfc2NzaTNfbHVuYWNsX3VuZGVwZW5kX2l0ZW0oc3RydWN0IHNlX2Rldl9lbnRyeSAqc2VfZGV2ZSkKK3sKKwlzdHJ1Y3Qgc2VfbHVuX2FjbCAqbHVuX2FjbCA9IHNlX2RldmUtPnNlX2x1bl9hY2w7CisJc3RydWN0IHNlX25vZGVfYWNsICpuYWNsOworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZzsKKwkvKgorCSAqIEZvciBuYWNsLT5keW5hbWljX25vZGVfYWNsPTEKKwkgKi8KKwlpZiAoIShsdW5fYWNsKSkgeworCQlhdG9taWNfZGVjKCZzZV9kZXZlLT5wcl9yZWZfY291bnQpOworCQlzbXBfbWJfX2FmdGVyX2F0b21pY19kZWMoKTsKKwkJcmV0dXJuOworCX0KKwluYWNsID0gbHVuX2FjbC0+c2VfbHVuX25hY2w7CisJdHBnID0gbmFjbC0+c2VfdHBnOworCisJY29uZmlnZnNfdW5kZXBlbmRfaXRlbShUUEdfVEZPKHRwZyktPnRmX3N1YnN5cywKKwkJCSZsdW5fYWNsLT5zZV9sdW5fZ3JvdXAuY2dfaXRlbSk7CisKKwlhdG9taWNfZGVjKCZzZV9kZXZlLT5wcl9yZWZfY291bnQpOworCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworfQorCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfZGVjb2RlX3NwZWNfaV9wb3J0KAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcsCisJdW5zaWduZWQgY2hhciAqbF9pc2lkLAorCXU2NCBzYV9yZXNfa2V5LAorCWludCBhbGxfdGdfcHQsCisJaW50IGFwdHBsKQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IFNFX0RFVihjbWQpOworCXN0cnVjdCBzZV9wb3J0ICp0bXBfcG9ydDsKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpkZXN0X3RwZyA9IE5VTEwsICp0bXBfdHBnOworCXN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzID0gU0VfU0VTUyhjbWQpOworCXN0cnVjdCBzZV9ub2RlX2FjbCAqZGVzdF9ub2RlX2FjbCA9IE5VTEw7CisJc3RydWN0IHNlX2Rldl9lbnRyeSAqZGVzdF9zZV9kZXZlID0gTlVMTCwgKmxvY2FsX3NlX2RldmU7CisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKmRlc3RfcHJfcmVnLCAqbG9jYWxfcHJfcmVnLCAqcHJfcmVnX2U7CisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKnByX3JlZ190bXAsICpwcl9yZWdfdG1wX3NhZmU7CisJc3RydWN0IGxpc3RfaGVhZCB0aWRfZGVzdF9saXN0OworCXN0cnVjdCBwcl90cmFuc3BvcnRfaWRfaG9sZGVyICp0aWRoX25ldywgKnRpZGgsICp0aWRoX3RtcDsKKwlzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcyAqdG1wX3RmX29wczsKKwl1bnNpZ25lZCBjaGFyICpidWYgPSAodW5zaWduZWQgY2hhciAqKVRfVEFTSyhjbWQpLT50X3Rhc2tfYnVmOworCXVuc2lnbmVkIGNoYXIgKnB0ciwgKmlfc3RyID0gTlVMTCwgcHJvdG9faWRlbnQsIHRtcF9wcm90b19pZGVudDsKKwljaGFyICppcG9ydF9wdHIgPSBOVUxMLCBkZXN0X2lwb3J0WzY0XSwgaV9idWZbUFJfUkVHX0lTSURfSURfTEVOXTsKKwl1MzIgdHBkbCwgdGlkX2xlbiA9IDA7CisJaW50IHJldCwgZGVzdF9sb2NhbF9uZXh1cywgcHJmX2lzaWQ7CisJdTMyIGRlc3RfcnRwaSA9IDA7CisKKwltZW1zZXQoZGVzdF9pcG9ydCwgMCwgNjQpOworCUlOSVRfTElTVF9IRUFEKCZ0aWRfZGVzdF9saXN0KTsKKworCWxvY2FsX3NlX2RldmUgPSAmc2Vfc2Vzcy0+c2Vfbm9kZV9hY2wtPmRldmljZV9saXN0W2NtZC0+b3JpZ19mZV9sdW5dOworCS8qCisJICogQWxsb2NhdGUgYSBzdHJ1Y3QgcHJfdHJhbnNwb3J0X2lkX2hvbGRlciBhbmQgc2V0dXAgdGhlCisJICogbG9jYWxfbm9kZV9hY2wgYW5kIGxvY2FsX3NlX2RldmUgcG9pbnRlcnMgYW5kIGFkZCB0bworCSAqIHN0cnVjdCBsaXN0X2hlYWQgdGlkX2Rlc3RfbGlzdCBmb3IgYWRkIHJlZ2lzdHJhdGlvbgorCSAqIHByb2Nlc3NpbmcgaW4gdGhlIGxvb3Agb2YgdGlkX2Rlc3RfbGlzdCBiZWxvdy4KKwkgKi8KKwl0aWRoX25ldyA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBwcl90cmFuc3BvcnRfaWRfaG9sZGVyKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCEodGlkaF9uZXcpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIHRpZGhfbmV3XG4iKTsKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfTFVfQ09NTV9GQUlMVVJFOworCX0KKwlJTklUX0xJU1RfSEVBRCgmdGlkaF9uZXctPmRlc3RfbGlzdCk7CisJdGlkaF9uZXctPmRlc3RfdHBnID0gdHBnOworCXRpZGhfbmV3LT5kZXN0X25vZGVfYWNsID0gc2Vfc2Vzcy0+c2Vfbm9kZV9hY2w7CisJdGlkaF9uZXctPmRlc3Rfc2VfZGV2ZSA9IGxvY2FsX3NlX2RldmU7CisKKwlsb2NhbF9wcl9yZWcgPSBfX2NvcmVfc2NzaTNfYWxsb2NfcmVnaXN0cmF0aW9uKFNFX0RFVihjbWQpLAorCQkJCXNlX3Nlc3MtPnNlX25vZGVfYWNsLCBsb2NhbF9zZV9kZXZlLCBsX2lzaWQsCisJCQkJc2FfcmVzX2tleSwgYWxsX3RnX3B0LCBhcHRwbCk7CisJaWYgKCEobG9jYWxfcHJfcmVnKSkgeworCQlrZnJlZSh0aWRoX25ldyk7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwl9CisJdGlkaF9uZXctPmRlc3RfcHJfcmVnID0gbG9jYWxfcHJfcmVnOworCS8qCisJICogVGhlIGxvY2FsIElfVCBuZXh1cyBkb2VzIG5vdCBob2xkIGFueSBjb25maWdmcyBkZXBlbmRhbmNlcywKKwkgKiBzbyB3ZSBzZXQgdGlkX2gtPmRlc3RfbG9jYWxfbmV4dXM9MSB0byBwcmV2ZW50IHRoZQorCSAqIGNvbmZpZ2ZzX3VuZGVwZW5kX2l0ZW0oKSBjYWxscyBpbiB0aGUgdGlkX2Rlc3RfbGlzdCBsb29wcyBiZWxvdy4KKwkgKi8KKwl0aWRoX25ldy0+ZGVzdF9sb2NhbF9uZXh1cyA9IDE7CisJbGlzdF9hZGRfdGFpbCgmdGlkaF9uZXctPmRlc3RfbGlzdCwgJnRpZF9kZXN0X2xpc3QpOworCS8qCisJICogRm9yIGEgUEVSU0lTVEVOVCBSRVNFUlZFIE9VVCBzcGVjaWZ5IGluaXRpYXRvciBwb3J0cyBwYXlsb2FkLAorCSAqIGZpcnN0IGV4dHJhY3QgVHJhbnNwb3J0SUQgUGFyYW1ldGVyIERhdGEgTGVuZ3RoLCBhbmQgbWFrZSBzdXJlCisJICogdGhlIHZhbHVlIG1hdGNoZXMgdXAgdG8gdGhlIFNDU0kgZXhwZWN0ZWQgZGF0YSB0cmFuc2ZlciBsZW5ndGguCisJICovCisJdHBkbCA9IChidWZbMjRdICYgMHhmZikgPDwgMjQ7CisJdHBkbCB8PSAoYnVmWzI1XSAmIDB4ZmYpIDw8IDE2OworCXRwZGwgfD0gKGJ1ZlsyNl0gJiAweGZmKSA8PCA4OworCXRwZGwgfD0gYnVmWzI3XSAmIDB4ZmY7CisKKwlpZiAoKHRwZGwgKyAyOCkgIT0gY21kLT5kYXRhX2xlbmd0aCkgeworCQlwcmludGsoS0VSTl9FUlIgIlNQQy0zIFBSOiBJbGxlZ2FsIHRwZGw6ICV1ICsgMjggYnl0ZSBoZWFkZXIiCisJCQkiIGRvZXMgbm90IGVxdWFsIENEQiBkYXRhX2xlbmd0aDogJXVcbiIsIHRwZGwsCisJCQljbWQtPmRhdGFfbGVuZ3RoKTsKKwkJcmV0ID0gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCQlnb3RvIG91dDsKKwl9CisJLyoKKwkgKiBTdGFydCBwcm9jZXNzaW5nIHRoZSByZWNlaXZlZCB0cmFuc3BvcnQgSURzIHVzaW5nIHRoZQorCSAqIHJlY2VpdmluZyBJX1QgTmV4dXMgcG9ydGFsJ3MgZmFicmljIGRlcGVuZGVudCBtZXRob2RzIHRvCisJICogb2J0YWluIHRoZSBTQ1NJIEluaXRpYXRvciBQb3J0L0RldmljZSBJZGVudGlmaWVycy4KKwkgKi8KKwlwdHIgPSAmYnVmWzI4XTsKKworCXdoaWxlICh0cGRsID4gMCkgeworCQlwcm90b19pZGVudCA9IChwdHJbMF0gJiAweDBmKTsKKwkJZGVzdF90cGcgPSBOVUxMOworCisJCXNwaW5fbG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHRtcF9wb3J0LCAmZGV2LT5kZXZfc2VwX2xpc3QsIHNlcF9saXN0KSB7CisJCQl0bXBfdHBnID0gdG1wX3BvcnQtPnNlcF90cGc7CisJCQlpZiAoISh0bXBfdHBnKSkKKwkJCQljb250aW51ZTsKKwkJCXRtcF90Zl9vcHMgPSBUUEdfVEZPKHRtcF90cGcpOworCQkJaWYgKCEodG1wX3RmX29wcykpCisJCQkJY29udGludWU7CisJCQlpZiAoISh0bXBfdGZfb3BzLT5nZXRfZmFicmljX3Byb3RvX2lkZW50KSB8fAorCQkJICAgICEodG1wX3RmX29wcy0+dHBnX3BhcnNlX3ByX291dF90cmFuc3BvcnRfaWQpKQorCQkJCWNvbnRpbnVlOworCQkJLyoKKwkJCSAqIExvb2sgZm9yIHRoZSBtYXRjaGluZyBwcm90b19pZGVudCBwcm92aWRlZCBieQorCQkJICogdGhlIHJlY2VpdmVkIFRyYW5zcG9ydElECisJCQkgKi8KKwkJCXRtcF9wcm90b19pZGVudCA9IHRtcF90Zl9vcHMtPmdldF9mYWJyaWNfcHJvdG9faWRlbnQodG1wX3RwZyk7CisJCQlpZiAodG1wX3Byb3RvX2lkZW50ICE9IHByb3RvX2lkZW50KQorCQkJCWNvbnRpbnVlOworCQkJZGVzdF9ydHBpID0gdG1wX3BvcnQtPnNlcF9ydHBpOworCisJCQlpX3N0ciA9IHRtcF90Zl9vcHMtPnRwZ19wYXJzZV9wcl9vdXRfdHJhbnNwb3J0X2lkKAorCQkJCQl0bXBfdHBnLCAoY29uc3QgY2hhciAqKXB0ciwgJnRpZF9sZW4sCisJCQkJCSZpcG9ydF9wdHIpOworCQkJaWYgKCEoaV9zdHIpKQorCQkJCWNvbnRpbnVlOworCisJCQlhdG9taWNfaW5jKCZ0bXBfdHBnLT50cGdfcHJfcmVmX2NvdW50KTsKKwkJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2luYygpOworCQkJc3Bpbl91bmxvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKworCQkJcmV0ID0gY29yZV9zY3NpM190cGdfZGVwZW5kX2l0ZW0odG1wX3RwZyk7CisJCQlpZiAocmV0ICE9IDApIHsKKwkJCQlwcmludGsoS0VSTl9FUlIgIiBjb3JlX3Njc2kzX3RwZ19kZXBlbmRfaXRlbSgpIgorCQkJCQkiIGZvciB0bXBfdHBnXG4iKTsKKwkJCQlhdG9taWNfZGVjKCZ0bXBfdHBnLT50cGdfcHJfcmVmX2NvdW50KTsKKwkJCQlzbXBfbWJfX2FmdGVyX2F0b21pY19kZWMoKTsKKwkJCQlyZXQgPSBQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwkJCQlnb3RvIG91dDsKKwkJCX0KKwkJCS8qCisJCQkgKiBMb2NhdGUgdGhlIGRlc2luYXRpb24gaW5pdGlhdG9yIEFDTCB0byBiZSByZWdpc3RlcmVkCisJCQkgKiBmcm9tIHRoZSBkZWNvZGVkIGZhYnJpYyBtb2R1bGUgc3BlY2lmaWMgVHJhbnNwb3J0SUQKKwkJCSAqIGF0ICppX3N0ci4KKwkJCSAqLworCQkJc3Bpbl9sb2NrX2JoKCZ0bXBfdHBnLT5hY2xfbm9kZV9sb2NrKTsKKwkJCWRlc3Rfbm9kZV9hY2wgPSBfX2NvcmVfdHBnX2dldF9pbml0aWF0b3Jfbm9kZV9hY2woCisJCQkJCQl0bXBfdHBnLCBpX3N0cik7CisJCQlpZiAoZGVzdF9ub2RlX2FjbCkgeworCQkJCWF0b21pY19pbmMoJmRlc3Rfbm9kZV9hY2wtPmFjbF9wcl9yZWZfY291bnQpOworCQkJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2luYygpOworCQkJfQorCQkJc3Bpbl91bmxvY2tfYmgoJnRtcF90cGctPmFjbF9ub2RlX2xvY2spOworCisJCQlpZiAoIShkZXN0X25vZGVfYWNsKSkgeworCQkJCWNvcmVfc2NzaTNfdHBnX3VuZGVwZW5kX2l0ZW0odG1wX3RwZyk7CisJCQkJc3Bpbl9sb2NrKCZkZXYtPnNlX3BvcnRfbG9jayk7CisJCQkJY29udGludWU7CisJCQl9CisKKwkJCXJldCA9IGNvcmVfc2NzaTNfbm9kZWFjbF9kZXBlbmRfaXRlbShkZXN0X25vZGVfYWNsKTsKKwkJCWlmIChyZXQgIT0gMCkgeworCQkJCXByaW50ayhLRVJOX0VSUiAiY29uZmlnZnNfZGVwZW5kX2l0ZW0oKSBmYWlsZWQiCisJCQkJCSIgZm9yIGRlc3Rfbm9kZV9hY2wtPmFjbF9ncm91cFxuIik7CisJCQkJYXRvbWljX2RlYygmZGVzdF9ub2RlX2FjbC0+YWNsX3ByX3JlZl9jb3VudCk7CisJCQkJc21wX21iX19hZnRlcl9hdG9taWNfZGVjKCk7CisJCQkJY29yZV9zY3NpM190cGdfdW5kZXBlbmRfaXRlbSh0bXBfdHBnKTsKKwkJCQlyZXQgPSBQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwkJCQlnb3RvIG91dDsKKwkJCX0KKworCQkJZGVzdF90cGcgPSB0bXBfdHBnOworCQkJcHJpbnRrKEtFUk5fSU5GTyAiU1BDLTMgUFIgU1BFQ19JX1BUOiBMb2NhdGVkICVzIE5vZGU6IgorCQkJCSIgJXMgUG9ydCBSVFBJOiAlaHVcbiIsCisJCQkJVFBHX1RGTyhkZXN0X3RwZyktPmdldF9mYWJyaWNfbmFtZSgpLAorCQkJCWRlc3Rfbm9kZV9hY2wtPmluaXRpYXRvcm5hbWUsIGRlc3RfcnRwaSk7CisKKwkJCXNwaW5fbG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCQkJYnJlYWs7CisJCX0KKwkJc3Bpbl91bmxvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKworCQlpZiAoIShkZXN0X3RwZykpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFIgU1BFQ19JX1BUOiBVbmFibGUgdG8gbG9jYXRlIgorCQkJCQkiIGRlc3RfdHBnXG4iKTsKKwkJCXJldCA9IFBZWF9UUkFOU1BPUlRfSU5WQUxJRF9QQVJBTUVURVJfTElTVDsKKwkJCWdvdG8gb3V0OworCQl9CisjaWYgMAorCQlwcmludGsoIlNQQy0zIFBSIFNQRUNfSV9QVDogR290ICVzIGRhdGFfbGVuZ3RoOiAldSB0cGRsOiAldSIKKwkJCSIgdGlkX2xlbjogJWQgZm9yICVzICsgJXNcbiIsCisJCQlUUEdfVEZPKGRlc3RfdHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksIGNtZC0+ZGF0YV9sZW5ndGgsCisJCQl0cGRsLCB0aWRfbGVuLCBpX3N0ciwgaXBvcnRfcHRyKTsKKyNlbmRpZgorCQlpZiAodGlkX2xlbiA+IHRwZGwpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFIgU1BFQ19JX1BUOiBJbGxlZ2FsIHRpZF9sZW46IgorCQkJCSIgJXUgZm9yIFRyYW5zcG9ydCBJRDogJXNcbiIsIHRpZF9sZW4sIHB0cik7CisJCQljb3JlX3Njc2kzX25vZGVhY2xfdW5kZXBlbmRfaXRlbShkZXN0X25vZGVfYWNsKTsKKwkJCWNvcmVfc2NzaTNfdHBnX3VuZGVwZW5kX2l0ZW0oZGVzdF90cGcpOworCQkJcmV0ID0gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCQkJZ290byBvdXQ7CisJCX0KKwkJLyoKKwkJICogTG9jYXRlIHRoZSBkZXNpbnRhdGlvbiBzdHJ1Y3Qgc2VfZGV2X2VudHJ5IHBvaW50ZXIgZm9yIG1hdGNoaW5nCisJCSAqIFJFTEFUSVZFIFRBUkdFVCBQT1JUIElERU5USUZJRVIgb24gdGhlIHJlY2VpdmluZyBJX1QgTmV4dXMKKwkJICogVGFyZ2V0IFBvcnQuCisJCSAqLworCQlkZXN0X3NlX2RldmUgPSBjb3JlX2dldF9zZV9kZXZlX2Zyb21fcnRwaShkZXN0X25vZGVfYWNsLAorCQkJCQlkZXN0X3J0cGkpOworCQlpZiAoIShkZXN0X3NlX2RldmUpKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2NhdGUgJXMgZGVzdF9zZV9kZXZlIgorCQkJCSIgZnJvbSBkZXN0aW5hdGlvbiBSVFBJOiAlaHVcbiIsCisJCQkJVFBHX1RGTyhkZXN0X3RwZyktPmdldF9mYWJyaWNfbmFtZSgpLAorCQkJCWRlc3RfcnRwaSk7CisKKwkJCWNvcmVfc2NzaTNfbm9kZWFjbF91bmRlcGVuZF9pdGVtKGRlc3Rfbm9kZV9hY2wpOworCQkJY29yZV9zY3NpM190cGdfdW5kZXBlbmRfaXRlbShkZXN0X3RwZyk7CisJCQlyZXQgPSBQWVhfVFJBTlNQT1JUX0lOVkFMSURfUEFSQU1FVEVSX0xJU1Q7CisJCQlnb3RvIG91dDsKKwkJfQorCisJCXJldCA9IGNvcmVfc2NzaTNfbHVuYWNsX2RlcGVuZF9pdGVtKGRlc3Rfc2VfZGV2ZSk7CisJCWlmIChyZXQgPCAwKSB7CisJCQlwcmludGsoS0VSTl9FUlIgImNvcmVfc2NzaTNfbHVuYWNsX2RlcGVuZF9pdGVtKCkiCisJCQkJCSIgZmFpbGVkXG4iKTsKKwkJCWF0b21pY19kZWMoJmRlc3Rfc2VfZGV2ZS0+cHJfcmVmX2NvdW50KTsKKwkJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworCQkJY29yZV9zY3NpM19ub2RlYWNsX3VuZGVwZW5kX2l0ZW0oZGVzdF9ub2RlX2FjbCk7CisJCQljb3JlX3Njc2kzX3RwZ191bmRlcGVuZF9pdGVtKGRlc3RfdHBnKTsKKwkJCXJldCA9IFBZWF9UUkFOU1BPUlRfTFVfQ09NTV9GQUlMVVJFOworCQkJZ290byBvdXQ7CisJCX0KKyNpZiAwCisJCXByaW50ayhLRVJOX0lORk8gIlNQQy0zIFBSIFNQRUNfSV9QVDogTG9jYXRlZCAlcyBOb2RlOiAlcyIKKwkJCSIgZGVzdF9zZV9kZXZlIG1hcHBlZF9sdW46ICV1XG4iLAorCQkJVFBHX1RGTyhkZXN0X3RwZyktPmdldF9mYWJyaWNfbmFtZSgpLAorCQkJZGVzdF9ub2RlX2FjbC0+aW5pdGlhdG9ybmFtZSwgZGVzdF9zZV9kZXZlLT5tYXBwZWRfbHVuKTsKKyNlbmRpZgorCQkvKgorCQkgKiBTa2lwIGFueSBUcmFuc3BvcnRJRHMgdGhhdCBhbHJlYWR5IGhhdmUgYSByZWdpc3RyYXRpb24gZm9yCisJCSAqIHRoaXMgdGFyZ2V0IHBvcnQuCisJCSAqLworCQlwcl9yZWdfZSA9IF9fY29yZV9zY3NpM19sb2NhdGVfcHJfcmVnKGRldiwgZGVzdF9ub2RlX2FjbCwKKwkJCQkJaXBvcnRfcHRyKTsKKwkJaWYgKHByX3JlZ19lKSB7CisJCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnX2UpOworCQkJY29yZV9zY3NpM19sdW5hY2xfdW5kZXBlbmRfaXRlbShkZXN0X3NlX2RldmUpOworCQkJY29yZV9zY3NpM19ub2RlYWNsX3VuZGVwZW5kX2l0ZW0oZGVzdF9ub2RlX2FjbCk7CisJCQljb3JlX3Njc2kzX3RwZ191bmRlcGVuZF9pdGVtKGRlc3RfdHBnKTsKKwkJCXB0ciArPSB0aWRfbGVuOworCQkJdHBkbCAtPSB0aWRfbGVuOworCQkJdGlkX2xlbiA9IDA7CisJCQljb250aW51ZTsKKwkJfQorCQkvKgorCQkgKiBBbGxvY2F0ZSBhIHN0cnVjdCBwcl90cmFuc3BvcnRfaWRfaG9sZGVyIGFuZCBzZXR1cAorCQkgKiB0aGUgZGVzdF9ub2RlX2FjbCBhbmQgZGVzdF9zZV9kZXZlIHBvaW50ZXJzIGZvciB0aGUKKwkJICogbG9vcCBiZWxvdy4KKwkJICovCisJCXRpZGhfbmV3ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHByX3RyYW5zcG9ydF9pZF9ob2xkZXIpLAorCQkJCUdGUF9LRVJORUwpOworCQlpZiAoISh0aWRoX25ldykpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIHRpZGhfbmV3XG4iKTsKKwkJCWNvcmVfc2NzaTNfbHVuYWNsX3VuZGVwZW5kX2l0ZW0oZGVzdF9zZV9kZXZlKTsKKwkJCWNvcmVfc2NzaTNfbm9kZWFjbF91bmRlcGVuZF9pdGVtKGRlc3Rfbm9kZV9hY2wpOworCQkJY29yZV9zY3NpM190cGdfdW5kZXBlbmRfaXRlbShkZXN0X3RwZyk7CisJCQlyZXQgPSBQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwkJCWdvdG8gb3V0OworCQl9CisJCUlOSVRfTElTVF9IRUFEKCZ0aWRoX25ldy0+ZGVzdF9saXN0KTsKKwkJdGlkaF9uZXctPmRlc3RfdHBnID0gZGVzdF90cGc7CisJCXRpZGhfbmV3LT5kZXN0X25vZGVfYWNsID0gZGVzdF9ub2RlX2FjbDsKKwkJdGlkaF9uZXctPmRlc3Rfc2VfZGV2ZSA9IGRlc3Rfc2VfZGV2ZTsKKworCQkvKgorCQkgKiBBbGxvY2F0ZSwgYnV0IGRvIE5PVCBhZGQgdGhlIHJlZ2lzdHJhdGlvbiBmb3IgdGhlCisJCSAqIFRyYW5zcG9ydElEIHJlZmVyZW5jZWQgU0NTSSBJbml0aWF0b3IgcG9ydC4gIFRoaXMKKwkJICogZG9uZSBiZWNhdXNlIG9mIHRoZSBmb2xsb3dpbmcgZnJvbSBzcGM0cjE3IGluIHNlY3Rpb24KKwkJICogNi4xNC4zIHdydCBTUEVDX0lfUFQ6CisJCSAqCisJCSAqICJJZiBhIHJlZ2lzdHJhdGlvbiBmYWlscyBmb3IgYW55IGluaXRpYXRvciBwb3J0IChlLmcuLCBpZiB0aAorCQkgKiBsb2dpY2FsIHVuaXQgZG9lcyBub3QgaGF2ZSBlbm91Z2ggcmVzb3VyY2VzIGF2YWlsYWJsZSB0bworCQkgKiBob2xkIHRoZSByZWdpc3RyYXRpb24gaW5mb3JtYXRpb24pLCBubyByZWdpc3RyYXRpb25zIHNoYWxsIGJlCisJCSAqIG1hZGUsIGFuZCB0aGUgY29tbWFuZCBzaGFsbCBiZSB0ZXJtaW5hdGVkIHdpdGgKKwkJICogQ0hFQ0sgQ09ORElUSU9OIHN0YXR1cy4iCisJCSAqCisJCSAqIFRoYXQgbWVhbnMgd2UgY2FsbCBfX2NvcmVfc2NzaTNfYWxsb2NfcmVnaXN0cmF0aW9uKCkgaGVyZSwKKwkJICogYW5kIHRoZW4gY2FsbCBfX2NvcmVfc2NzaTNfYWRkX3JlZ2lzdHJhdGlvbigpIGluIHRoZQorCQkgKiAybmQgbG9vcCB3aGljaCB3aWxsIG5ldmVyIGZhaWwuCisJCSAqLworCQlkZXN0X3ByX3JlZyA9IF9fY29yZV9zY3NpM19hbGxvY19yZWdpc3RyYXRpb24oU0VfREVWKGNtZCksCisJCQkJZGVzdF9ub2RlX2FjbCwgZGVzdF9zZV9kZXZlLCBpcG9ydF9wdHIsCisJCQkJc2FfcmVzX2tleSwgYWxsX3RnX3B0LCBhcHRwbCk7CisJCWlmICghKGRlc3RfcHJfcmVnKSkgeworCQkJY29yZV9zY3NpM19sdW5hY2xfdW5kZXBlbmRfaXRlbShkZXN0X3NlX2RldmUpOworCQkJY29yZV9zY3NpM19ub2RlYWNsX3VuZGVwZW5kX2l0ZW0oZGVzdF9ub2RlX2FjbCk7CisJCQljb3JlX3Njc2kzX3RwZ191bmRlcGVuZF9pdGVtKGRlc3RfdHBnKTsKKwkJCWtmcmVlKHRpZGhfbmV3KTsKKwkJCXJldCA9IFBZWF9UUkFOU1BPUlRfSU5WQUxJRF9QQVJBTUVURVJfTElTVDsKKwkJCWdvdG8gb3V0OworCQl9CisJCXRpZGhfbmV3LT5kZXN0X3ByX3JlZyA9IGRlc3RfcHJfcmVnOworCQlsaXN0X2FkZF90YWlsKCZ0aWRoX25ldy0+ZGVzdF9saXN0LCAmdGlkX2Rlc3RfbGlzdCk7CisKKwkJcHRyICs9IHRpZF9sZW47CisJCXRwZGwgLT0gdGlkX2xlbjsKKwkJdGlkX2xlbiA9IDA7CisKKwl9CisJLyoKKwkgKiBHbyBhaGVhZCBhbmQgY3JlYXRlIGEgcmVnaXN0cmF0aW9ucyBmcm9tIHRpZF9kZXN0X2xpc3QgZm9yIHRoZQorCSAqIFNQRUNfSV9QVCBwcm92aWRlZCBUcmFuc3BvcnRJRCBmb3IgdGhlICp0aWRoIHJlZmVyZW5jZWQgZGVzdF9ub2RlX2FjbAorCSAqIGFuZCBkZXN0X3NlX2RldmUuCisJICoKKwkgKiBUaGUgU0EgUmVzZXJ2YXRpb24gS2V5IGZyb20gdGhlIFBST1VUIGlzIHNldCBmb3IgdGhlCisJICogcmVnaXN0cmF0aW9uLCBhbmQgQUxMX1RHX1BUIGlzIGFsc28gcGFzc2VkLiAgQUxMX1RHX1BUPTEKKwkgKiBtZWFucyB0aGF0IHRoZSBUcmFuc3BvcnRJRCBJbml0aWF0b3IgcG9ydCB3aWxsIGJlCisJICogcmVnaXN0ZXJlZCBvbiBhbGwgb2YgdGhlIHRhcmdldCBwb3J0cyBpbiB0aGUgU0NTSSB0YXJnZXQgZGV2aWNlCisJICogQUxMX1RHX1BUPTAgbWVhbnMgdGhlIHJlZ2lzdHJhdGlvbiB3aWxsIG9ubHkgYmUgZm9yIHRoZQorCSAqIFNDU0kgdGFyZ2V0IHBvcnQgdGhlIFBST1VUIFJFR0lTVEVSIHdpdGggU1BFQ19JX1BUPTEKKwkgKiB3YXMgcmVjZWl2ZWQuCisJICovCisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHRpZGgsIHRpZGhfdG1wLCAmdGlkX2Rlc3RfbGlzdCwgZGVzdF9saXN0KSB7CisJCWRlc3RfdHBnID0gdGlkaC0+ZGVzdF90cGc7CisJCWRlc3Rfbm9kZV9hY2wgPSB0aWRoLT5kZXN0X25vZGVfYWNsOworCQlkZXN0X3NlX2RldmUgPSB0aWRoLT5kZXN0X3NlX2RldmU7CisJCWRlc3RfcHJfcmVnID0gdGlkaC0+ZGVzdF9wcl9yZWc7CisJCWRlc3RfbG9jYWxfbmV4dXMgPSB0aWRoLT5kZXN0X2xvY2FsX25leHVzOworCisJCWxpc3RfZGVsKCZ0aWRoLT5kZXN0X2xpc3QpOworCQlrZnJlZSh0aWRoKTsKKworCQltZW1zZXQoaV9idWYsIDAsIFBSX1JFR19JU0lEX0lEX0xFTik7CisJCXByZl9pc2lkID0gY29yZV9wcl9kdW1wX2luaXRpYXRvcl9wb3J0KGRlc3RfcHJfcmVnLCAmaV9idWZbMF0sCisJCQkJCQlQUl9SRUdfSVNJRF9JRF9MRU4pOworCisJCV9fY29yZV9zY3NpM19hZGRfcmVnaXN0cmF0aW9uKFNFX0RFVihjbWQpLCBkZXN0X25vZGVfYWNsLAorCQkJCQlkZXN0X3ByX3JlZywgMCwgMCk7CisKKwkJcHJpbnRrKEtFUk5fSU5GTyAiU1BDLTMgUFIgWyVzXSBTUEVDX0lfUFQ6IFN1Y2Nlc3NmdWxseSIKKwkJCSIgcmVnaXN0ZXJlZCBUcmFuc3BvcnQgSUQgZm9yIE5vZGU6ICVzJXMgTWFwcGVkIExVTjoiCisJCQkiICV1XG4iLCBUUEdfVEZPKGRlc3RfdHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCQlkZXN0X25vZGVfYWNsLT5pbml0aWF0b3JuYW1lLCAocHJmX2lzaWQpID8KKwkJCSZpX2J1ZlswXSA6ICIiLCBkZXN0X3NlX2RldmUtPm1hcHBlZF9sdW4pOworCisJCWlmIChkZXN0X2xvY2FsX25leHVzKQorCQkJY29udGludWU7CisKKwkJY29yZV9zY3NpM19sdW5hY2xfdW5kZXBlbmRfaXRlbShkZXN0X3NlX2RldmUpOworCQljb3JlX3Njc2kzX25vZGVhY2xfdW5kZXBlbmRfaXRlbShkZXN0X25vZGVfYWNsKTsKKwkJY29yZV9zY3NpM190cGdfdW5kZXBlbmRfaXRlbShkZXN0X3RwZyk7CisJfQorCisJcmV0dXJuIDA7CitvdXQ6CisJLyoKKwkgKiBGb3IgdGhlIGZhaWx1cmUgY2FzZSwgcmVsZWFzZSBldmVyeXRoaW5nIGZyb20gdGlkX2Rlc3RfbGlzdAorCSAqIGluY2x1ZGluZyAqZGVzdF9wcl9yZWcgYW5kIHRoZSBjb25maWdmcyBkZXBlbmRhbmNlcy4uCisJICovCisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHRpZGgsIHRpZGhfdG1wLCAmdGlkX2Rlc3RfbGlzdCwgZGVzdF9saXN0KSB7CisJCWRlc3RfdHBnID0gdGlkaC0+ZGVzdF90cGc7CisJCWRlc3Rfbm9kZV9hY2wgPSB0aWRoLT5kZXN0X25vZGVfYWNsOworCQlkZXN0X3NlX2RldmUgPSB0aWRoLT5kZXN0X3NlX2RldmU7CisJCWRlc3RfcHJfcmVnID0gdGlkaC0+ZGVzdF9wcl9yZWc7CisJCWRlc3RfbG9jYWxfbmV4dXMgPSB0aWRoLT5kZXN0X2xvY2FsX25leHVzOworCisJCWxpc3RfZGVsKCZ0aWRoLT5kZXN0X2xpc3QpOworCQlrZnJlZSh0aWRoKTsKKwkJLyoKKwkJICogUmVsZWFzZSBhbnkgZXh0cmEgQUxMX1RHX1BUPTEgcmVnaXN0cmF0aW9ucyBmb3IKKwkJICogdGhlIFNQRUNfSV9QVD0xIGNhc2UuCisJCSAqLworCQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocHJfcmVnX3RtcCwgcHJfcmVnX3RtcF9zYWZlLAorCQkJCSZkZXN0X3ByX3JlZy0+cHJfcmVnX2F0cF9saXN0LAorCQkJCXByX3JlZ19hdHBfbWVtX2xpc3QpIHsKKwkJCWxpc3RfZGVsKCZwcl9yZWdfdG1wLT5wcl9yZWdfYXRwX21lbV9saXN0KTsKKwkJCWNvcmVfc2NzaTNfbHVuYWNsX3VuZGVwZW5kX2l0ZW0ocHJfcmVnX3RtcC0+cHJfcmVnX2RldmUpOworCQkJa21lbV9jYWNoZV9mcmVlKHQxMF9wcl9yZWdfY2FjaGUsIHByX3JlZ190bXApOworCQl9CisKKwkJa2ZyZWUoZGVzdF9wcl9yZWctPnByX2FwdHBsX2J1Zik7CisJCWttZW1fY2FjaGVfZnJlZSh0MTBfcHJfcmVnX2NhY2hlLCBkZXN0X3ByX3JlZyk7CisKKwkJaWYgKGRlc3RfbG9jYWxfbmV4dXMpCisJCQljb250aW51ZTsKKworCQljb3JlX3Njc2kzX2x1bmFjbF91bmRlcGVuZF9pdGVtKGRlc3Rfc2VfZGV2ZSk7CisJCWNvcmVfc2NzaTNfbm9kZWFjbF91bmRlcGVuZF9pdGVtKGRlc3Rfbm9kZV9hY2wpOworCQljb3JlX3Njc2kzX3RwZ191bmRlcGVuZF9pdGVtKGRlc3RfdHBnKTsKKwl9CisJcmV0dXJuIHJldDsKK30KKworLyoKKyAqIENhbGxlZCB3aXRoIHN0cnVjdCBzZV9kZXZpY2UtPmRldl9yZXNlcnZhdGlvbl9sb2NrIGhlbGQKKyAqLworc3RhdGljIGludCBfX2NvcmVfc2NzaTNfdXBkYXRlX2FwdHBsX2J1ZigKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsCisJdW5zaWduZWQgY2hhciAqYnVmLAorCXUzMiBwcl9hcHRwbF9idWZfbGVuLAorCWludCBjbGVhcl9hcHRwbF9tZXRhZGF0YSkKK3sKKwlzdHJ1Y3Qgc2VfbHVuICpsdW47CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnOworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXYgPSBTVV9ERVYoZGV2KTsKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnOworCXVuc2lnbmVkIGNoYXIgdG1wWzUxMl0sIGlzaWRfYnVmWzMyXTsKKwlzc2l6ZV90IGxlbiA9IDA7CisJaW50IHJlZ19jb3VudCA9IDA7CisKKwltZW1zZXQoYnVmLCAwLCBwcl9hcHRwbF9idWZfbGVuKTsKKwkvKgorCSAqIENhbGxlZCB0byBjbGVhciBtZXRhZGF0YSBvbmNlIEFQVFBMIGhhcyBiZWVuIGRlYWN0aXZhdGVkLgorCSAqLworCWlmIChjbGVhcl9hcHRwbF9tZXRhZGF0YSkgeworCQlzbnByaW50ZihidWYsIHByX2FwdHBsX2J1Zl9sZW4sCisJCQkJIk5vIFJlZ2lzdHJhdGlvbnMgb3IgUmVzZXJ2YXRpb25zXG4iKTsKKwkJcmV0dXJuIDA7CisJfQorCS8qCisJICogV2FsayB0aGUgcmVnaXN0cmF0aW9uIGxpc3QuLgorCSAqLworCXNwaW5fbG9jaygmVDEwX1JFUyhzdV9kZXYpLT5yZWdpc3RyYXRpb25fbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShwcl9yZWcsICZUMTBfUkVTKHN1X2RldiktPnJlZ2lzdHJhdGlvbl9saXN0LAorCQkJcHJfcmVnX2xpc3QpIHsKKworCQl0bXBbMF0gPSAnXDAnOworCQlpc2lkX2J1ZlswXSA9ICdcMCc7CisJCXRwZyA9IHByX3JlZy0+cHJfcmVnX25hY2wtPnNlX3RwZzsKKwkJbHVuID0gcHJfcmVnLT5wcl9yZWdfdGdfcHRfbHVuOworCQkvKgorCQkgKiBXcml0ZSBvdXQgYW55IElTSUQgdmFsdWUgdG8gQVBUUEwgbWV0YWRhdGEgdGhhdCB3YXMgaW5jbHVkZWQKKwkJICogaW4gdGhlIG9yaWdpbmFsIHJlZ2lzdHJhdGlvbi4KKwkJICovCisJCWlmIChwcl9yZWctPmlzaWRfcHJlc2VudF9hdF9yZWcpCisJCQlzbnByaW50Zihpc2lkX2J1ZiwgMzIsICJpbml0aWF0b3Jfc2lkPSVzXG4iLAorCQkJCQlwcl9yZWctPnByX3JlZ19pc2lkKTsKKwkJLyoKKwkJICogSW5jbHVkZSBzcGVjaWFsIG1ldGFkYXRhIGlmIHRoZSBwcl9yZWcgbWF0Y2hlcyB0aGUKKwkJICogcmVzZXJ2YXRpb24gaG9sZGVyLgorCQkgKi8KKwkJaWYgKGRldi0+ZGV2X3ByX3Jlc19ob2xkZXIgPT0gcHJfcmVnKSB7CisJCQlzbnByaW50Zih0bXAsIDUxMiwgIlBSX1JFR19TVEFSVDogJWQiCisJCQkJIlxuaW5pdGlhdG9yX2ZhYnJpYz0lc1xuIgorCQkJCSJpbml0aWF0b3Jfbm9kZT0lc1xuJXMiCisJCQkJInNhX3Jlc19rZXk9JWxsdVxuIgorCQkJCSJyZXNfaG9sZGVyPTFcbnJlc190eXBlPSUwMnhcbiIKKwkJCQkicmVzX3Njb3BlPSUwMnhcbnJlc19hbGxfdGdfcHQ9JWRcbiIKKwkJCQkibWFwcGVkX2x1bj0ldVxuIiwgcmVnX2NvdW50LAorCQkJCVRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCQkJcHJfcmVnLT5wcl9yZWdfbmFjbC0+aW5pdGlhdG9ybmFtZSwgaXNpZF9idWYsCisJCQkJcHJfcmVnLT5wcl9yZXNfa2V5LCBwcl9yZWctPnByX3Jlc190eXBlLAorCQkJCXByX3JlZy0+cHJfcmVzX3Njb3BlLCBwcl9yZWctPnByX3JlZ19hbGxfdGdfcHQsCisJCQkJcHJfcmVnLT5wcl9yZXNfbWFwcGVkX2x1bik7CisJCX0gZWxzZSB7CisJCQlzbnByaW50Zih0bXAsIDUxMiwgIlBSX1JFR19TVEFSVDogJWRcbiIKKwkJCQkiaW5pdGlhdG9yX2ZhYnJpYz0lc1xuaW5pdGlhdG9yX25vZGU9JXNcbiVzIgorCQkJCSJzYV9yZXNfa2V5PSVsbHVcbnJlc19ob2xkZXI9MFxuIgorCQkJCSJyZXNfYWxsX3RnX3B0PSVkXG5tYXBwZWRfbHVuPSV1XG4iLAorCQkJCXJlZ19jb3VudCwgVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJCQlwcl9yZWctPnByX3JlZ19uYWNsLT5pbml0aWF0b3JuYW1lLCBpc2lkX2J1ZiwKKwkJCQlwcl9yZWctPnByX3Jlc19rZXksIHByX3JlZy0+cHJfcmVnX2FsbF90Z19wdCwKKwkJCQlwcl9yZWctPnByX3Jlc19tYXBwZWRfbHVuKTsKKwkJfQorCisJCWlmICgobGVuICsgc3RybGVuKHRtcCkgPiBwcl9hcHRwbF9idWZfbGVuKSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gdXBkYXRlIHJlbmFtaW5nIgorCQkJCSIgQVBUUEwgbWV0YWRhdGFcbiIpOworCQkJc3Bpbl91bmxvY2soJlQxMF9SRVMoc3VfZGV2KS0+cmVnaXN0cmF0aW9uX2xvY2spOworCQkJcmV0dXJuIC0xOworCQl9CisJCWxlbiArPSBzcHJpbnRmKGJ1ZitsZW4sICIlcyIsIHRtcCk7CisKKwkJLyoKKwkJICogSW5jbHVkZSBpbmZvcm1hdGlvbiBhYm91dCB0aGUgYXNzb2NpYXRlZCBTQ1NJIHRhcmdldCBwb3J0LgorCQkgKi8KKwkJc25wcmludGYodG1wLCA1MTIsICJ0YXJnZXRfZmFicmljPSVzXG50YXJnZXRfbm9kZT0lc1xuIgorCQkJInRwZ3Q9JWh1XG5wb3J0X3J0cGk9JWh1XG50YXJnZXRfbHVuPSV1XG5QUl9SRUdfRU5EOiIKKwkJCSIgJWRcbiIsIFRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCQlUUEdfVEZPKHRwZyktPnRwZ19nZXRfd3duKHRwZyksCisJCQlUUEdfVEZPKHRwZyktPnRwZ19nZXRfdGFnKHRwZyksCisJCQlsdW4tPmx1bl9zZXAtPnNlcF9ydHBpLCBsdW4tPnVucGFja2VkX2x1biwgcmVnX2NvdW50KTsKKworCQlpZiAoKGxlbiArIHN0cmxlbih0bXApID4gcHJfYXB0cGxfYnVmX2xlbikpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIHVwZGF0ZSByZW5hbWluZyIKKwkJCQkiIEFQVFBMIG1ldGFkYXRhXG4iKTsKKwkJCXNwaW5fdW5sb2NrKCZUMTBfUkVTKHN1X2RldiktPnJlZ2lzdHJhdGlvbl9sb2NrKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQlsZW4gKz0gc3ByaW50ZihidWYrbGVuLCAiJXMiLCB0bXApOworCQlyZWdfY291bnQrKzsKKwl9CisJc3Bpbl91bmxvY2soJlQxMF9SRVMoc3VfZGV2KS0+cmVnaXN0cmF0aW9uX2xvY2spOworCisJaWYgKCEocmVnX2NvdW50KSkKKwkJbGVuICs9IHNwcmludGYoYnVmK2xlbiwgIk5vIFJlZ2lzdHJhdGlvbnMgb3IgUmVzZXJ2YXRpb25zIik7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBjb3JlX3Njc2kzX3VwZGF0ZV9hcHRwbF9idWYoCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCXVuc2lnbmVkIGNoYXIgKmJ1ZiwKKwl1MzIgcHJfYXB0cGxfYnVmX2xlbiwKKwlpbnQgY2xlYXJfYXB0cGxfbWV0YWRhdGEpCit7CisJaW50IHJldDsKKworCXNwaW5fbG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJcmV0ID0gX19jb3JlX3Njc2kzX3VwZGF0ZV9hcHRwbF9idWYoZGV2LCBidWYsIHByX2FwdHBsX2J1Zl9sZW4sCisJCQkJY2xlYXJfYXB0cGxfbWV0YWRhdGEpOworCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CisKKy8qCisgKiBDYWxsZWQgd2l0aCBzdHJ1Y3Qgc2VfZGV2aWNlLT5hcHRwbF9maWxlX211dGV4IGhlbGQKKyAqLworc3RhdGljIGludCBfX2NvcmVfc2NzaTNfd3JpdGVfYXB0cGxfdG9fZmlsZSgKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsCisJdW5zaWduZWQgY2hhciAqYnVmLAorCXUzMiBwcl9hcHRwbF9idWZfbGVuKQoreworCXN0cnVjdCB0MTBfd3duICp3d24gPSAmU1VfREVWKGRldiktPnQxMF93d247CisJc3RydWN0IGZpbGUgKmZpbGU7CisJc3RydWN0IGlvdmVjIGlvdlsxXTsKKwltbV9zZWdtZW50X3Qgb2xkX2ZzOworCWludCBmbGFncyA9IE9fUkRXUiB8IE9fQ1JFQVQgfCBPX1RSVU5DOworCWNoYXIgcGF0aFs1MTJdOworCWludCByZXQ7CisKKwltZW1zZXQoaW92LCAwLCBzaXplb2Yoc3RydWN0IGlvdmVjKSk7CisJbWVtc2V0KHBhdGgsIDAsIDUxMik7CisKKwlpZiAoc3RybGVuKCZ3d24tPnVuaXRfc2VyaWFsWzBdKSA+IDUxMikgeworCQlwcmludGsoS0VSTl9FUlIgIldXTiB2YWx1ZSBmb3Igc3RydWN0IHNlX2RldmljZSBkb2VzIG5vdCBmaXQiCisJCQkiIGludG8gcGF0aCBidWZmZXJcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJc25wcmludGYocGF0aCwgNTEyLCAiL3Zhci90YXJnZXQvcHIvYXB0cGxfJXMiLCAmd3duLT51bml0X3NlcmlhbFswXSk7CisJZmlsZSA9IGZpbHBfb3BlbihwYXRoLCBmbGFncywgMDYwMCk7CisJaWYgKElTX0VSUihmaWxlKSB8fCAhZmlsZSB8fCAhZmlsZS0+Zl9kZW50cnkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJmaWxwX29wZW4oJXMpIGZvciBBUFRQTCBtZXRhZGF0YSIKKwkJCSIgZmFpbGVkXG4iLCBwYXRoKTsKKwkJcmV0dXJuIC0xOworCX0KKworCWlvdlswXS5pb3ZfYmFzZSA9ICZidWZbMF07CisJaWYgKCEocHJfYXB0cGxfYnVmX2xlbikpCisJCWlvdlswXS5pb3ZfbGVuID0gKHN0cmxlbigmYnVmWzBdKSArIDEpOyAvKiBBZGQgZXh0cmEgZm9yIE5VTEwgKi8KKwllbHNlCisJCWlvdlswXS5pb3ZfbGVuID0gcHJfYXB0cGxfYnVmX2xlbjsKKworCW9sZF9mcyA9IGdldF9mcygpOworCXNldF9mcyhnZXRfZHMoKSk7CisJcmV0ID0gdmZzX3dyaXRldihmaWxlLCAmaW92WzBdLCAxLCAmZmlsZS0+Zl9wb3MpOworCXNldF9mcyhvbGRfZnMpOworCisJaWYgKHJldCA8IDApIHsKKwkJcHJpbnRrKCJFcnJvciB3cml0aW5nIEFQVFBMIG1ldGFkYXRhIGZpbGU6ICVzXG4iLCBwYXRoKTsKKwkJZmlscF9jbG9zZShmaWxlLCBOVUxMKTsKKwkJcmV0dXJuIC0xOworCX0KKwlmaWxwX2Nsb3NlKGZpbGUsIE5VTEwpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgY29yZV9zY3NpM191cGRhdGVfYW5kX3dyaXRlX2FwdHBsKAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwl1bnNpZ25lZCBjaGFyICppbl9idWYsCisJdTMyIGluX3ByX2FwdHBsX2J1Zl9sZW4pCit7CisJdW5zaWduZWQgY2hhciBudWxsX2J1Zls2NF0sICpidWY7CisJdTMyIHByX2FwdHBsX2J1Zl9sZW47CisJaW50IHJldCwgY2xlYXJfYXB0cGxfbWV0YWRhdGEgPSAwOworCS8qCisJICogQ2FuIGJlIGNhbGxlZCB3aXRoIGEgTlVMTCBwb2ludGVyIGZyb20gUFJPVVQgc2VydmljZSBhY3Rpb24gQ0xFQVIKKwkgKi8KKwlpZiAoIShpbl9idWYpKSB7CisJCW1lbXNldChudWxsX2J1ZiwgMCwgNjQpOworCQlidWYgPSAmbnVsbF9idWZbMF07CisJCS8qCisJCSAqIFRoaXMgd2lsbCBjbGVhciB0aGUgQVBUUEwgbWV0YWRhdGEgdG86CisJCSAqICJObyBSZWdpc3RyYXRpb25zIG9yIFJlc2VydmF0aW9ucyIgc3RhdHVzCisJCSAqLworCQlwcl9hcHRwbF9idWZfbGVuID0gNjQ7CisJCWNsZWFyX2FwdHBsX21ldGFkYXRhID0gMTsKKwl9IGVsc2UgeworCQlidWYgPSBpbl9idWY7CisJCXByX2FwdHBsX2J1Zl9sZW4gPSBpbl9wcl9hcHRwbF9idWZfbGVuOworCX0KKworCXJldCA9IGNvcmVfc2NzaTNfdXBkYXRlX2FwdHBsX2J1ZihkZXYsIGJ1ZiwgcHJfYXB0cGxfYnVmX2xlbiwKKwkJCQljbGVhcl9hcHRwbF9tZXRhZGF0YSk7CisJaWYgKHJldCAhPSAwKQorCQlyZXR1cm4gLTE7CisJLyoKKwkgKiBfX2NvcmVfc2NzaTNfd3JpdGVfYXB0cGxfdG9fZmlsZSgpIHdpbGwgY2FsbCBzdHJsZW4oKQorCSAqIG9uIHRoZSBwYXNzZWQgYnVmIHRvIGRldGVybWluZSBwcl9hcHRwbF9idWZfbGVuLgorCSAqLworCXJldCA9IF9fY29yZV9zY3NpM193cml0ZV9hcHRwbF90b19maWxlKGRldiwgYnVmLCAwKTsKKwlpZiAocmV0ICE9IDApCisJCXJldHVybiAtMTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgY29yZV9zY3NpM19lbXVsYXRlX3Byb19yZWdpc3RlcigKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJdTY0IHJlc19rZXksCisJdTY0IHNhX3Jlc19rZXksCisJaW50IGFwdHBsLAorCWludCBhbGxfdGdfcHQsCisJaW50IHNwZWNfaV9wdCwKKwlpbnQgaWdub3JlX2tleSkKK3sKKwlzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqc2Vfc2VzcyA9IFNFX1NFU1MoY21kKTsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKwlzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICpzZV9kZXZlOworCXN0cnVjdCBzZV9sdW4gKnNlX2x1biA9IFNFX0xVTihjbWQpOworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZzsKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnLCAqcHJfcmVnX3AsICpwcl9yZWdfdG1wLCAqcHJfcmVnX2U7CisJc3RydWN0IHQxMF9yZXNlcnZhdGlvbl90ZW1wbGF0ZSAqcHJfdG1wbCA9ICZTVV9ERVYoZGV2KS0+dDEwX3Jlc2VydmF0aW9uOworCS8qIFVzZWQgZm9yIEFQVFBMIG1ldGFkYXRhIHcvIFVOUkVHSVNURVIgKi8KKwl1bnNpZ25lZCBjaGFyICpwcl9hcHRwbF9idWYgPSBOVUxMOworCXVuc2lnbmVkIGNoYXIgaXNpZF9idWZbUFJfUkVHX0lTSURfTEVOXSwgKmlzaWRfcHRyID0gTlVMTDsKKwlpbnQgcHJfaG9sZGVyID0gMCwgcmV0ID0gMCwgdHlwZTsKKworCWlmICghKHNlX3Nlc3MpIHx8ICEoc2VfbHVuKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlNQQy0zIFBSOiBzZV9zZXNzIHx8IHN0cnVjdCBzZV9sdW4gaXMgTlVMTCFcbiIpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9MVV9DT01NX0ZBSUxVUkU7CisJfQorCXNlX3RwZyA9IHNlX3Nlc3MtPnNlX3RwZzsKKwlzZV9kZXZlID0gJnNlX3Nlc3MtPnNlX25vZGVfYWNsLT5kZXZpY2VfbGlzdFtjbWQtPm9yaWdfZmVfbHVuXTsKKworCWlmIChUUEdfVEZPKHNlX3RwZyktPnNlc3NfZ2V0X2luaXRpYXRvcl9zaWQgIT0gTlVMTCkgeworCQltZW1zZXQoJmlzaWRfYnVmWzBdLCAwLCBQUl9SRUdfSVNJRF9MRU4pOworCQlUUEdfVEZPKHNlX3RwZyktPnNlc3NfZ2V0X2luaXRpYXRvcl9zaWQoc2Vfc2VzcywgJmlzaWRfYnVmWzBdLAorCQkJCVBSX1JFR19JU0lEX0xFTik7CisJCWlzaWRfcHRyID0gJmlzaWRfYnVmWzBdOworCX0KKwkvKgorCSAqIEZvbGxvdyBsb2dpYyBmcm9tIHNwYzRyMTcgU2VjdGlvbiA1LjcuNywgUmVnaXN0ZXIgQmVoYXZpb3JzIFRhYmxlIDQ3CisJICovCisJcHJfcmVnX2UgPSBjb3JlX3Njc2kzX2xvY2F0ZV9wcl9yZWcoZGV2LCBzZV9zZXNzLT5zZV9ub2RlX2FjbCwgc2Vfc2Vzcyk7CisJaWYgKCEocHJfcmVnX2UpKSB7CisJCWlmIChyZXNfa2V5KSB7CisJCQlwcmludGsoS0VSTl9XQVJOSU5HICJTUEMtMyBQUjogUmVzZXJ2YXRpb24gS2V5IG5vbi16ZXJvIgorCQkJCSIgZm9yIFNBIFJFR0lTVEVSLCByZXR1cm5pbmcgQ09ORkxJQ1RcbiIpOworCQkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfUkVTRVJWQVRJT05fQ09ORkxJQ1Q7CisJCX0KKwkJLyoKKwkJICogRG8gbm90aGluZyBidXQgcmV0dXJuIEdPT0Qgc3RhdHVzLgorCQkgKi8KKwkJaWYgKCEoc2FfcmVzX2tleSkpCisJCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9TRU5UX1RPX1RSQU5TUE9SVDsKKworCQlpZiAoIShzcGVjX2lfcHQpKSB7CisJCQkvKgorCQkJICogUGVyZm9ybSB0aGUgU2VydmljZSBBY3Rpb24gUkVHSVNURVIgb24gdGhlIEluaXRpYXRvcgorCQkJICogUG9ydCBFbmRwb2ludCB0aGF0IHRoZSBQUk8gd2FzIHJlY2VpdmVkIGZyb20gb24gdGhlCisJCQkgKiBMb2dpY2FsIFVuaXQgb2YgdGhlIFNDU0kgZGV2aWNlIHNlcnZlci4KKwkJCSAqLworCQkJcmV0ID0gY29yZV9zY3NpM19hbGxvY19yZWdpc3RyYXRpb24oU0VfREVWKGNtZCksCisJCQkJCXNlX3Nlc3MtPnNlX25vZGVfYWNsLCBzZV9kZXZlLCBpc2lkX3B0ciwKKwkJCQkJc2FfcmVzX2tleSwgYWxsX3RnX3B0LCBhcHRwbCwKKwkJCQkJaWdub3JlX2tleSwgMCk7CisJCQlpZiAocmV0ICE9IDApIHsKKwkJCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSIKKwkJCQkJIiBzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvblxuIik7CisJCQkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfSU5WQUxJRF9QQVJBTUVURVJfTElTVDsKKwkJCX0KKwkJfSBlbHNlIHsKKwkJCS8qCisJCQkgKiBSZWdpc3RlciBib3RoIHRoZSBJbml0aWF0b3IgcG9ydCB0aGF0IHJlY2VpdmVkCisJCQkgKiBQUk9VVCBTQSBSRUdJU1RFUiArIFNQRUNfSV9QVD0xIGFuZCBleHRyYWN0IFNDU0kKKwkJCSAqIFRyYW5zcG9ydElEIGZyb20gUGFyYW1ldGVyIGxpc3QgYW5kIGxvb3AgdGhyb3VnaAorCQkJICogZmFicmljIGRlcGVuZGVudCBwYXJhbWV0ZXIgbGlzdCB3aGlsZSBjYWxsaW5nCisJCQkgKiBsb2dpYyBmcm9tIG9mIGNvcmVfc2NzaTNfYWxsb2NfcmVnaXN0cmF0aW9uKCkgZm9yCisJCQkgKiBlYWNoIFRyYW5zcG9ydElEIHByb3ZpZGVkIFNDU0kgSW5pdGlhdG9yIFBvcnQvRGV2aWNlCisJCQkgKi8KKwkJCXJldCA9IGNvcmVfc2NzaTNfZGVjb2RlX3NwZWNfaV9wb3J0KGNtZCwgc2VfdHBnLAorCQkJCQlpc2lkX3B0ciwgc2FfcmVzX2tleSwgYWxsX3RnX3B0LCBhcHRwbCk7CisJCQlpZiAocmV0ICE9IDApCisJCQkJcmV0dXJuIHJldDsKKwkJfQorCQkvKgorCQkgKiBOb3RoaW5nIGxlZnQgdG8gZG8gZm9yIHRoZSBBUFRQTD0wIGNhc2UuCisJCSAqLworCQlpZiAoIShhcHRwbCkpIHsKKwkJCXByX3RtcGwtPnByX2FwdHBsX2FjdGl2ZSA9IDA7CisJCQljb3JlX3Njc2kzX3VwZGF0ZV9hbmRfd3JpdGVfYXB0cGwoU0VfREVWKGNtZCksIE5VTEwsIDApOworCQkJcHJpbnRrKCJTUEMtMyBQUjogU2V0IEFQVFBMIEJpdCBEZWFjdGl2YXRlZCBmb3IiCisJCQkJCSIgUkVHSVNURVJcbiIpOworCQkJcmV0dXJuIDA7CisJCX0KKwkJLyoKKwkJICogTG9jYXRlIHRoZSBuZXdseSBhbGxvY2F0ZWQgbG9jYWwgSV9UIE5leHVzICpwcl9yZWcsIGFuZAorCQkgKiB1cGRhdGUgdGhlIEFQVFBMIG1ldGFkYXRhIGluZm9ybWF0aW9uIHVzaW5nIGl0cworCQkgKiBwcmVhbGxvY2F0ZWQgKnByX3JlZy0+cHJfYXB0cGxfYnVmLgorCQkgKi8KKwkJcHJfcmVnID0gY29yZV9zY3NpM19sb2NhdGVfcHJfcmVnKFNFX0RFVihjbWQpLAorCQkJCXNlX3Nlc3MtPnNlX25vZGVfYWNsLCBzZV9zZXNzKTsKKworCQlyZXQgPSBjb3JlX3Njc2kzX3VwZGF0ZV9hbmRfd3JpdGVfYXB0cGwoU0VfREVWKGNtZCksCisJCQkJJnByX3JlZy0+cHJfYXB0cGxfYnVmWzBdLAorCQkJCXByX3RtcGwtPnByX2FwdHBsX2J1Zl9sZW4pOworCQlpZiAoIShyZXQpKSB7CisJCQlwcl90bXBsLT5wcl9hcHRwbF9hY3RpdmUgPSAxOworCQkJcHJpbnRrKCJTUEMtMyBQUjogU2V0IEFQVFBMIEJpdCBBY3RpdmF0ZWQgZm9yIFJFR0lTVEVSXG4iKTsKKwkJfQorCisJCWNvcmVfc2NzaTNfcHV0X3ByX3JlZyhwcl9yZWcpOworCQlyZXR1cm4gcmV0OworCX0gZWxzZSB7CisJCS8qCisJCSAqIExvY2F0ZSB0aGUgZXhpc3RpbmcgKnByX3JlZyB2aWEgc3RydWN0IHNlX25vZGVfYWNsIHBvaW50ZXJzCisJCSAqLworCQlwcl9yZWcgPSBwcl9yZWdfZTsKKwkJdHlwZSA9IHByX3JlZy0+cHJfcmVzX3R5cGU7CisKKwkJaWYgKCEoaWdub3JlX2tleSkpIHsKKwkJCWlmIChyZXNfa2V5ICE9IHByX3JlZy0+cHJfcmVzX2tleSkgeworCQkJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFIgUkVHSVNURVI6IFJlY2VpdmVkIgorCQkJCQkiIHJlc19rZXk6IDB4JTAxNkx4IGRvZXMgbm90IG1hdGNoIgorCQkJCQkiIGV4aXN0aW5nIFNBIFJFR0lTVEVSIHJlc19rZXk6IgorCQkJCQkiIDB4JTAxNkx4XG4iLCByZXNfa2V5LAorCQkJCQlwcl9yZWctPnByX3Jlc19rZXkpOworCQkJCWNvcmVfc2NzaTNfcHV0X3ByX3JlZyhwcl9yZWcpOworCQkJCXJldHVybiBQWVhfVFJBTlNQT1JUX1JFU0VSVkFUSU9OX0NPTkZMSUNUOworCQkJfQorCQl9CisJCWlmIChzcGVjX2lfcHQpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFIgVU5SRUdJU1RFUjogU1BFQ19JX1BUIgorCQkJCSIgc2V0IHdoaWxlIHNhX3Jlc19rZXk9MFxuIik7CisJCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnKTsKKwkJCXJldHVybiBQWVhfVFJBTlNQT1JUX0lOVkFMSURfUEFSQU1FVEVSX0xJU1Q7CisJCX0KKwkJLyoKKwkJICogQW4gZXhpc3RpbmcgQUxMX1RHX1BUPTEgcmVnaXN0cmF0aW9uIGJlaW5nIHJlbGVhc2VkCisJCSAqIG11c3QgYWxzbyBzZXQgQUxMX1RHX1BUPTEgaW4gdGhlIGluY29taW5nIFBST1VULgorCQkgKi8KKwkJaWYgKHByX3JlZy0+cHJfcmVnX2FsbF90Z19wdCAmJiAhKGFsbF90Z19wdCkpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFIgVU5SRUdJU1RFUjogQUxMX1RHX1BUPTEiCisJCQkJIiByZWdpc3RyYXRpb24gZXhpc3RzLCBidXQgQUxMX1RHX1BUPTEgYml0IG5vdCIKKwkJCQkiIHByZXNlbnQgaW4gcmVjZWl2ZWQgUFJPVVRcbiIpOworCQkJY29yZV9zY3NpM19wdXRfcHJfcmVnKHByX3JlZyk7CisJCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9JTlZBTElEX0NEQl9GSUVMRDsKKwkJfQorCQkvKgorCQkgKiBBbGxvY2F0ZSBBUFRQTCBtZXRhZGF0YSBidWZmZXIgdXNlZCBmb3IgVU5SRUdJU1RFUiBvcHMKKwkJICovCisJCWlmIChhcHRwbCkgeworCQkJcHJfYXB0cGxfYnVmID0ga3phbGxvYyhwcl90bXBsLT5wcl9hcHRwbF9idWZfbGVuLAorCQkJCQkJR0ZQX0tFUk5FTCk7CisJCQlpZiAoIShwcl9hcHRwbF9idWYpKSB7CisJCQkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUiCisJCQkJCSIgcHJfYXB0cGxfYnVmXG4iKTsKKwkJCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnKTsKKwkJCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9MVV9DT01NX0ZBSUxVUkU7CisJCQl9CisJCX0KKwkJLyoKKwkJICogc2FfcmVzX2tleT0wIFVucmVnaXN0ZXIgUmVzZXJ2YXRpb24gS2V5IGZvciByZWdpc3RlcmVkIElfVAorCQkgKiBOZXh1cyBzYV9yZXNfa2V5PTEgQ2hhbmdlIFJlc2VydmF0aW9uIEtleSBmb3IgcmVnaXN0ZXJlZCBJX1QKKwkJICogTmV4dXMuCisJCSAqLworCQlpZiAoIShzYV9yZXNfa2V5KSkgeworCQkJcHJfaG9sZGVyID0gY29yZV9zY3NpM19jaGVja19pbXBsaWN0X3JlbGVhc2UoCisJCQkJCVNFX0RFVihjbWQpLCBwcl9yZWcpOworCQkJaWYgKHByX2hvbGRlciA8IDApIHsKKwkJCQlrZnJlZShwcl9hcHRwbF9idWYpOworCQkJCWNvcmVfc2NzaTNfcHV0X3ByX3JlZyhwcl9yZWcpOworCQkJCXJldHVybiBQWVhfVFJBTlNQT1JUX1JFU0VSVkFUSU9OX0NPTkZMSUNUOworCQkJfQorCisJCQlzcGluX2xvY2soJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9sb2NrKTsKKwkJCS8qCisJCQkgKiBSZWxlYXNlIGFsbCBBTExfVEdfUFQ9MSBmb3IgdGhlIG1hdGNoaW5nIFNDU0kgSW5pdGlhdG9yIFBvcnQKKwkJCSAqIGFuZCBtYXRjaGluZyBwcl9yZXNfa2V5LgorCQkJICovCisJCQlpZiAocHJfcmVnLT5wcl9yZWdfYWxsX3RnX3B0KSB7CisJCQkJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHByX3JlZ19wLCBwcl9yZWdfdG1wLAorCQkJCQkJJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9saXN0LAorCQkJCQkJcHJfcmVnX2xpc3QpIHsKKworCQkJCQlpZiAoIShwcl9yZWdfcC0+cHJfcmVnX2FsbF90Z19wdCkpCisJCQkJCQljb250aW51ZTsKKworCQkJCQlpZiAocHJfcmVnX3AtPnByX3Jlc19rZXkgIT0gcmVzX2tleSkKKwkJCQkJCWNvbnRpbnVlOworCisJCQkJCWlmIChwcl9yZWcgPT0gcHJfcmVnX3ApCisJCQkJCQljb250aW51ZTsKKworCQkJCQlpZiAoc3RyY21wKHByX3JlZy0+cHJfcmVnX25hY2wtPmluaXRpYXRvcm5hbWUsCisJCQkJCQkgICBwcl9yZWdfcC0+cHJfcmVnX25hY2wtPmluaXRpYXRvcm5hbWUpKQorCQkJCQkJY29udGludWU7CisKKwkJCQkJX19jb3JlX3Njc2kzX2ZyZWVfcmVnaXN0cmF0aW9uKGRldiwKKwkJCQkJCQlwcl9yZWdfcCwgTlVMTCwgMCk7CisJCQkJfQorCQkJfQorCQkJLyoKKwkJCSAqIFJlbGVhc2UgdGhlIGNhbGxpbmcgSV9UIE5leHVzIHJlZ2lzdHJhdGlvbiBub3cuLgorCQkJICovCisJCQlfX2NvcmVfc2NzaTNfZnJlZV9yZWdpc3RyYXRpb24oU0VfREVWKGNtZCksIHByX3JlZywKKwkJCQkJCQlOVUxMLCAxKTsKKwkJCS8qCisJCQkgKiBGcm9tIHNwYzRyMTcsIHNlY3Rpb24gNS43LjExLjMgVW5yZWdpc3RlcmluZworCQkJICoKKwkJCSAqIElmIHRoZSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIGlzIGEgcmVnaXN0cmFudHMgb25seQorCQkJICogdHlwZSwgdGhlIGRldmljZSBzZXJ2ZXIgc2hhbGwgZXN0YWJsaXNoIGEgdW5pdAorCQkJICogYXR0ZW50aW9uIGNvbmRpdGlvbiBmb3IgdGhlIGluaXRpYXRvciBwb3J0IGFzc29jaWF0ZWQKKwkJCSAqIHdpdGggZXZlcnkgcmVnaXN0ZXJlZCBJX1QgbmV4dXMgZXhjZXB0IGZvciB0aGUgSV9UCisJCQkgKiBuZXh1cyBvbiB3aGljaCB0aGUgUEVSU0lTVEVOVCBSRVNFUlZFIE9VVCBjb21tYW5kIHdhcworCQkJICogcmVjZWl2ZWQsIHdpdGggdGhlIGFkZGl0aW9uYWwgc2Vuc2UgY29kZSBzZXQgdG8KKwkJCSAqIFJFU0VSVkFUSU9OUyBSRUxFQVNFRC4KKwkJCSAqLworCQkJaWYgKHByX2hvbGRlciAmJgorCQkJICAgKCh0eXBlID09IFBSX1RZUEVfV1JJVEVfRVhDTFVTSVZFX1JFR09OTFkpIHx8CisJCQkgICAgKHR5cGUgPT0gUFJfVFlQRV9FWENMVVNJVkVfQUNDRVNTX1JFR09OTFkpKSkgeworCQkJCWxpc3RfZm9yX2VhY2hfZW50cnkocHJfcmVnX3AsCisJCQkJCQkmcHJfdG1wbC0+cmVnaXN0cmF0aW9uX2xpc3QsCisJCQkJCQlwcl9yZWdfbGlzdCkgeworCisJCQkJCWNvcmVfc2NzaTNfdWFfYWxsb2NhdGUoCisJCQkJCQlwcl9yZWdfcC0+cHJfcmVnX25hY2wsCisJCQkJCQlwcl9yZWdfcC0+cHJfcmVzX21hcHBlZF9sdW4sCisJCQkJCQkweDJBLAorCQkJCQkJQVNDUV8yQUhfUkVTRVJWQVRJT05TX1JFTEVBU0VEKTsKKwkJCQl9CisJCQl9CisJCQlzcGluX3VubG9jaygmcHJfdG1wbC0+cmVnaXN0cmF0aW9uX2xvY2spOworCisJCQlpZiAoIShhcHRwbCkpIHsKKwkJCQlwcl90bXBsLT5wcl9hcHRwbF9hY3RpdmUgPSAwOworCQkJCWNvcmVfc2NzaTNfdXBkYXRlX2FuZF93cml0ZV9hcHRwbChkZXYsIE5VTEwsIDApOworCQkJCXByaW50aygiU1BDLTMgUFI6IFNldCBBUFRQTCBCaXQgRGVhY3RpdmF0ZWQiCisJCQkJCQkiIGZvciBVTlJFR0lTVEVSXG4iKTsKKwkJCQlyZXR1cm4gMDsKKwkJCX0KKworCQkJcmV0ID0gY29yZV9zY3NpM191cGRhdGVfYW5kX3dyaXRlX2FwdHBsKGRldiwKKwkJCQkJJnByX2FwdHBsX2J1ZlswXSwKKwkJCQkJcHJfdG1wbC0+cHJfYXB0cGxfYnVmX2xlbik7CisJCQlpZiAoIShyZXQpKSB7CisJCQkJcHJfdG1wbC0+cHJfYXB0cGxfYWN0aXZlID0gMTsKKwkJCQlwcmludGsoIlNQQy0zIFBSOiBTZXQgQVBUUEwgQml0IEFjdGl2YXRlZCIKKwkJCQkJCSIgZm9yIFVOUkVHSVNURVJcbiIpOworCQkJfQorCisJCQlrZnJlZShwcl9hcHRwbF9idWYpOworCQkJcmV0dXJuIHJldDsKKwkJfSBlbHNlIHsKKwkJCS8qCisJCQkgKiBJbmNyZW1lbnQgUFJnZW5lcmF0aW9uIGNvdW50ZXIgZm9yIHN0cnVjdCBzZV9kZXZpY2UiCisJCQkgKiB1cG9uIGEgc3VjY2Vzc2Z1bCBSRUdJU1RFUiwgc2VlIHNwYzRyMTcgc2VjdGlvbiA2LjMuMgorCQkJICogUkVBRF9LRVlTIHNlcnZpY2UgYWN0aW9uLgorCQkJICovCisJCQlwcl9yZWctPnByX3Jlc19nZW5lcmF0aW9uID0gY29yZV9zY3NpM19wcl9nZW5lcmF0aW9uKAorCQkJCQkJCVNFX0RFVihjbWQpKTsKKwkJCXByX3JlZy0+cHJfcmVzX2tleSA9IHNhX3Jlc19rZXk7CisJCQlwcmludGsoIlNQQy0zIFBSIFslc10gUkVHSVNURVIlczogQ2hhbmdlZCBSZXNlcnZhdGlvbiIKKwkJCQkiIEtleSBmb3IgJXMgdG86IDB4JTAxNkx4IFBSZ2VuZXJhdGlvbjoiCisJCQkJIiAweCUwOHhcbiIsIENNRF9URk8oY21kKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCQkJKGlnbm9yZV9rZXkpID8gIl9BTkRfSUdOT1JFX0VYSVNUSU5HX0tFWSIgOiAiIiwKKwkJCQlwcl9yZWctPnByX3JlZ19uYWNsLT5pbml0aWF0b3JuYW1lLAorCQkJCXByX3JlZy0+cHJfcmVzX2tleSwgcHJfcmVnLT5wcl9yZXNfZ2VuZXJhdGlvbik7CisKKwkJCWlmICghKGFwdHBsKSkgeworCQkJCXByX3RtcGwtPnByX2FwdHBsX2FjdGl2ZSA9IDA7CisJCQkJY29yZV9zY3NpM191cGRhdGVfYW5kX3dyaXRlX2FwdHBsKGRldiwgTlVMTCwgMCk7CisJCQkJY29yZV9zY3NpM19wdXRfcHJfcmVnKHByX3JlZyk7CisJCQkJcHJpbnRrKCJTUEMtMyBQUjogU2V0IEFQVFBMIEJpdCBEZWFjdGl2YXRlZCIKKwkJCQkJCSIgZm9yIFJFR0lTVEVSXG4iKTsKKwkJCQlyZXR1cm4gMDsKKwkJCX0KKworCQkJcmV0ID0gY29yZV9zY3NpM191cGRhdGVfYW5kX3dyaXRlX2FwdHBsKGRldiwKKwkJCQkJJnByX2FwdHBsX2J1ZlswXSwKKwkJCQkJcHJfdG1wbC0+cHJfYXB0cGxfYnVmX2xlbik7CisJCQlpZiAoIShyZXQpKSB7CisJCQkJcHJfdG1wbC0+cHJfYXB0cGxfYWN0aXZlID0gMTsKKwkJCQlwcmludGsoIlNQQy0zIFBSOiBTZXQgQVBUUEwgQml0IEFjdGl2YXRlZCIKKwkJCQkJCSIgZm9yIFJFR0lTVEVSXG4iKTsKKwkJCX0KKworCQkJa2ZyZWUocHJfYXB0cGxfYnVmKTsKKwkJCWNvcmVfc2NzaTNfcHV0X3ByX3JlZyhwcl9yZWcpOworCQl9CisJfQorCXJldHVybiAwOworfQorCit1bnNpZ25lZCBjaGFyICpjb3JlX3Njc2kzX3ByX2R1bXBfdHlwZShpbnQgdHlwZSkKK3sKKwlzd2l0Y2ggKHR5cGUpIHsKKwljYXNlIFBSX1RZUEVfV1JJVEVfRVhDTFVTSVZFOgorCQlyZXR1cm4gIldyaXRlIEV4Y2x1c2l2ZSBBY2Nlc3MiOworCWNhc2UgUFJfVFlQRV9FWENMVVNJVkVfQUNDRVNTOgorCQlyZXR1cm4gIkV4Y2x1c2l2ZSBBY2Nlc3MiOworCWNhc2UgUFJfVFlQRV9XUklURV9FWENMVVNJVkVfUkVHT05MWToKKwkJcmV0dXJuICJXcml0ZSBFeGNsdXNpdmUgQWNjZXNzLCBSZWdpc3RyYW50cyBPbmx5IjsKKwljYXNlIFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTU19SRUdPTkxZOgorCQlyZXR1cm4gIkV4Y2x1c2l2ZSBBY2Nlc3MsIFJlZ2lzdHJhbnRzIE9ubHkiOworCWNhc2UgUFJfVFlQRV9XUklURV9FWENMVVNJVkVfQUxMUkVHOgorCQlyZXR1cm4gIldyaXRlIEV4Y2x1c2l2ZSBBY2Nlc3MsIEFsbCBSZWdpc3RyYW50cyI7CisJY2FzZSBQUl9UWVBFX0VYQ0xVU0lWRV9BQ0NFU1NfQUxMUkVHOgorCQlyZXR1cm4gIkV4Y2x1c2l2ZSBBY2Nlc3MsIEFsbCBSZWdpc3RyYW50cyI7CisJZGVmYXVsdDoKKwkJYnJlYWs7CisJfQorCisJcmV0dXJuICJVbmtub3duIFNQQy0zIFBSIFR5cGUiOworfQorCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfcHJvX3Jlc2VydmUoCisJc3RydWN0IHNlX2NtZCAqY21kLAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwlpbnQgdHlwZSwKKwlpbnQgc2NvcGUsCisJdTY0IHJlc19rZXkpCit7CisJc3RydWN0IHNlX3Nlc3Npb24gKnNlX3Nlc3MgPSBTRV9TRVNTKGNtZCk7CisJc3RydWN0IHNlX2Rldl9lbnRyeSAqc2VfZGV2ZTsKKwlzdHJ1Y3Qgc2VfbHVuICpzZV9sdW4gPSBTRV9MVU4oY21kKTsKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGc7CisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKnByX3JlZywgKnByX3Jlc19ob2xkZXI7CisJc3RydWN0IHQxMF9yZXNlcnZhdGlvbl90ZW1wbGF0ZSAqcHJfdG1wbCA9ICZTVV9ERVYoZGV2KS0+dDEwX3Jlc2VydmF0aW9uOworCWNoYXIgaV9idWZbUFJfUkVHX0lTSURfSURfTEVOXTsKKwlpbnQgcmV0LCBwcmZfaXNpZDsKKworCW1lbXNldChpX2J1ZiwgMCwgUFJfUkVHX0lTSURfSURfTEVOKTsKKworCWlmICghKHNlX3Nlc3MpIHx8ICEoc2VfbHVuKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlNQQy0zIFBSOiBzZV9zZXNzIHx8IHN0cnVjdCBzZV9sdW4gaXMgTlVMTCFcbiIpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9MVV9DT01NX0ZBSUxVUkU7CisJfQorCXNlX3RwZyA9IHNlX3Nlc3MtPnNlX3RwZzsKKwlzZV9kZXZlID0gJnNlX3Nlc3MtPnNlX25vZGVfYWNsLT5kZXZpY2VfbGlzdFtjbWQtPm9yaWdfZmVfbHVuXTsKKwkvKgorCSAqIExvY2F0ZSB0aGUgZXhpc3RpbmcgKnByX3JlZyB2aWEgc3RydWN0IHNlX25vZGVfYWNsIHBvaW50ZXJzCisJICovCisJcHJfcmVnID0gY29yZV9zY3NpM19sb2NhdGVfcHJfcmVnKFNFX0RFVihjbWQpLCBzZV9zZXNzLT5zZV9ub2RlX2FjbCwKKwkJCQlzZV9zZXNzKTsKKwlpZiAoIShwcl9yZWcpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFI6IFVuYWJsZSB0byBsb2NhdGUiCisJCQkiIFBSX1JFR0lTVEVSRUQgKnByX3JlZyBmb3IgUkVTRVJWRVxuIik7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwl9CisJLyoKKwkgKiBGcm9tIHNwYzRyMTcgU2VjdGlvbiA1LjcuOTogUmVzZXJ2aW5nOgorCSAqCisJICogQW4gYXBwbGljYXRpb24gY2xpZW50IGNyZWF0ZXMgYSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIGJ5IGlzc3VpbmcKKwkgKiBhIFBFUlNJU1RFTlQgUkVTRVJWRSBPVVQgY29tbWFuZCB3aXRoIFJFU0VSVkUgc2VydmljZSBhY3Rpb24gdGhyb3VnaAorCSAqIGEgcmVnaXN0ZXJlZCBJX1QgbmV4dXMgd2l0aCB0aGUgZm9sbG93aW5nIHBhcmFtZXRlcnM6CisJICogICAgYSkgUkVTRVJWQVRJT04gS0VZIHNldCB0byB0aGUgdmFsdWUgb2YgdGhlIHJlc2VydmF0aW9uIGtleSB0aGF0IGlzCisJICogCSByZWdpc3RlcmVkIHdpdGggdGhlIGxvZ2ljYWwgdW5pdCBmb3IgdGhlIElfVCBuZXh1czsgYW5kCisJICovCisJaWYgKHJlc19rZXkgIT0gcHJfcmVnLT5wcl9yZXNfa2V5KSB7CisJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFIgUkVTRVJWRTogUmVjZWl2ZWQgcmVzX2tleTogMHglMDE2THgiCisJCQkiIGRvZXMgbm90IG1hdGNoIGV4aXN0aW5nIFNBIFJFR0lTVEVSIHJlc19rZXk6IgorCQkJIiAweCUwMTZMeFxuIiwgcmVzX2tleSwgcHJfcmVnLT5wcl9yZXNfa2V5KTsKKwkJY29yZV9zY3NpM19wdXRfcHJfcmVnKHByX3JlZyk7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX1JFU0VSVkFUSU9OX0NPTkZMSUNUOworCX0KKwkvKgorCSAqIEZyb20gc3BjNHIxNyBTZWN0aW9uIDUuNy45OiBSZXNlcnZpbmc6CisJICoKKwkgKiBGcm9tIGFib3ZlOgorCSAqICBiKSBUWVBFIGZpZWxkIGFuZCBTQ09QRSBmaWVsZCBzZXQgdG8gdGhlIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24KKwkgKiAgICAgYmVpbmcgY3JlYXRlZC4KKwkgKgorCSAqIE9ubHkgb25lIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gaXMgYWxsb3dlZCBhdCBhIHRpbWUgcGVyIGxvZ2ljYWwgdW5pdAorCSAqIGFuZCB0aGF0IHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gaGFzIGEgc2NvcGUgb2YgTFVfU0NPUEUuCisJICovCisJaWYgKHNjb3BlICE9IFBSX1NDT1BFX0xVX1NDT1BFKSB7CisJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFI6IElsbGVnYWwgU0NPUEU6IDB4JTAyeFxuIiwgc2NvcGUpOworCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnKTsKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfSU5WQUxJRF9QQVJBTUVURVJfTElTVDsKKwl9CisJLyoKKwkgKiBTZWUgaWYgd2UgaGF2ZSBhbiBleGlzdGluZyBQUiByZXNlcnZhdGlvbiBob2xkZXIgcG9pbnRlciBhdAorCSAqIHN0cnVjdCBzZV9kZXZpY2UtPmRldl9wcl9yZXNfaG9sZGVyIGluIHRoZSBmb3JtIHN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uCisJICogKnByX3Jlc19ob2xkZXIuCisJICovCisJc3Bpbl9sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwlwcl9yZXNfaG9sZGVyID0gZGV2LT5kZXZfcHJfcmVzX2hvbGRlcjsKKwlpZiAoKHByX3Jlc19ob2xkZXIpKSB7CisJCS8qCisJCSAqIEZyb20gc3BjNHIxNyBTZWN0aW9uIDUuNy45OiBSZXNlcnZpbmc6CisJCSAqCisJCSAqIElmIHRoZSBkZXZpY2Ugc2VydmVyIHJlY2VpdmVzIGEgUEVSU0lTVEVOVCBSRVNFUlZFIE9VVAorCQkgKiBjb21tYW5kIGZyb20gYW4gSV9UIG5leHVzIG90aGVyIHRoYW4gYSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uCisJCSAqIGhvbGRlciAoc2VlIDUuNy4xMCkgdGhhdCBhdHRlbXB0cyB0byBjcmVhdGUgYSBwZXJzaXN0ZW50CisJCSAqIHJlc2VydmF0aW9uIHdoZW4gYSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIGFscmVhZHkgZXhpc3RzIGZvcgorCQkgKiB0aGUgbG9naWNhbCB1bml0LCB0aGVuIHRoZSBjb21tYW5kIHNoYWxsIGJlIGNvbXBsZXRlZCB3aXRoCisJCSAqIFJFU0VSVkFUSU9OIENPTkZMSUNUIHN0YXR1cy4KKwkJICovCisJCWlmIChwcl9yZXNfaG9sZGVyICE9IHByX3JlZykgeworCQkJc3RydWN0IHNlX25vZGVfYWNsICpwcl9yZXNfbmFjbCA9IHByX3Jlc19ob2xkZXItPnByX3JlZ19uYWNsOworCQkJcHJpbnRrKEtFUk5fRVJSICJTUEMtMyBQUjogQXR0ZW1wdGVkIFJFU0VSVkUgZnJvbSIKKwkJCQkiIFslc106ICVzIHdoaWxlIHJlc2VydmF0aW9uIGFscmVhZHkgaGVsZCBieSIKKwkJCQkiIFslc106ICVzLCByZXR1cm5pbmcgUkVTRVJWQVRJT05fQ09ORkxJQ1RcbiIsCisJCQkJQ01EX1RGTyhjbWQpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJCQlzZV9zZXNzLT5zZV9ub2RlX2FjbC0+aW5pdGlhdG9ybmFtZSwKKwkJCQlUUEdfVEZPKHByX3Jlc19uYWNsLT5zZV90cGcpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJCQlwcl9yZXNfaG9sZGVyLT5wcl9yZWdfbmFjbC0+aW5pdGlhdG9ybmFtZSk7CisKKwkJCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwkJCWNvcmVfc2NzaTNfcHV0X3ByX3JlZyhwcl9yZWcpOworCQkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfUkVTRVJWQVRJT05fQ09ORkxJQ1Q7CisJCX0KKwkJLyoKKwkJICogRnJvbSBzcGM0cjE3IFNlY3Rpb24gNS43Ljk6IFJlc2VydmluZzoKKwkJICoKKwkJICogSWYgYSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIGhvbGRlciBhdHRlbXB0cyB0byBtb2RpZnkgdGhlCisJCSAqIHR5cGUgb3Igc2NvcGUgb2YgYW4gZXhpc3RpbmcgcGVyc2lzdGVudCByZXNlcnZhdGlvbiwgdGhlCisJCSAqIGNvbW1hbmQgc2hhbGwgYmUgY29tcGxldGVkIHdpdGggUkVTRVJWQVRJT04gQ09ORkxJQ1Qgc3RhdHVzLgorCQkgKi8KKwkJaWYgKChwcl9yZXNfaG9sZGVyLT5wcl9yZXNfdHlwZSAhPSB0eXBlKSB8fAorCQkgICAgKHByX3Jlc19ob2xkZXItPnByX3Jlc19zY29wZSAhPSBzY29wZSkpIHsKKwkJCXN0cnVjdCBzZV9ub2RlX2FjbCAqcHJfcmVzX25hY2wgPSBwcl9yZXNfaG9sZGVyLT5wcl9yZWdfbmFjbDsKKwkJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFI6IEF0dGVtcHRlZCBSRVNFUlZFIGZyb20iCisJCQkJIiBbJXNdOiAlcyB0cnlpbmcgdG8gY2hhbmdlIFRZUEUgYW5kL29yIFNDT1BFLCIKKwkJCQkiIHdoaWxlIHJlc2VydmF0aW9uIGFscmVhZHkgaGVsZCBieSBbJXNdOiAlcywiCisJCQkJIiByZXR1cm5pbmcgUkVTRVJWQVRJT05fQ09ORkxJQ1RcbiIsCisJCQkJQ01EX1RGTyhjbWQpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJCQlzZV9zZXNzLT5zZV9ub2RlX2FjbC0+aW5pdGlhdG9ybmFtZSwKKwkJCQlUUEdfVEZPKHByX3Jlc19uYWNsLT5zZV90cGcpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJCQlwcl9yZXNfaG9sZGVyLT5wcl9yZWdfbmFjbC0+aW5pdGlhdG9ybmFtZSk7CisKKwkJCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwkJCWNvcmVfc2NzaTNfcHV0X3ByX3JlZyhwcl9yZWcpOworCQkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfUkVTRVJWQVRJT05fQ09ORkxJQ1Q7CisJCX0KKwkJLyoKKwkJICogRnJvbSBzcGM0cjE3IFNlY3Rpb24gNS43Ljk6IFJlc2VydmluZzoKKwkJICoKKwkJICogSWYgdGhlIGRldmljZSBzZXJ2ZXIgcmVjZWl2ZXMgYSBQRVJTSVNURU5UIFJFU0VSVkUgT1VUCisJCSAqIGNvbW1hbmQgd2l0aCBSRVNFUlZFIHNlcnZpY2UgYWN0aW9uIHdoZXJlIHRoZSBUWVBFIGZpZWxkIGFuZAorCQkgKiB0aGUgU0NPUEUgZmllbGQgY29udGFpbiB0aGUgc2FtZSB2YWx1ZXMgYXMgdGhlIGV4aXN0aW5nIHR5cGUKKwkJICogYW5kIHNjb3BlIGZyb20gYSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIGhvbGRlciwgaXQgc2hhbGwgbm90CisJCSAqIG1ha2UgYW55IGNoYW5nZSB0byB0aGUgZXhpc3RpbmcgcGVyc2lzdGVudCByZXNlcnZhdGlvbiBhbmQKKwkJICogc2hhbGwgY29tcGxldGV0aGUgY29tbWFuZCB3aXRoIEdPT0Qgc3RhdHVzLgorCQkgKi8KKwkJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnKTsKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfU0VOVF9UT19UUkFOU1BPUlQ7CisJfQorCS8qCisJICogT3RoZXJ3aXNlLCBvdXIgKnByX3JlZyBiZWNvbWVzIHRoZSBQUiByZXNlcnZhdGlvbiBob2xkZXIgZm9yIHNhaWQKKwkgKiBUWVBFL1NDT1BFLiAgQWxzbyBzZXQgdGhlIHJlY2VpdmVkIHNjb3BlIGFuZCB0eXBlIGluICpwcl9yZWcuCisJICovCisJcHJfcmVnLT5wcl9yZXNfc2NvcGUgPSBzY29wZTsKKwlwcl9yZWctPnByX3Jlc190eXBlID0gdHlwZTsKKwlwcl9yZWctPnByX3Jlc19ob2xkZXIgPSAxOworCWRldi0+ZGV2X3ByX3Jlc19ob2xkZXIgPSBwcl9yZWc7CisJcHJmX2lzaWQgPSBjb3JlX3ByX2R1bXBfaW5pdGlhdG9yX3BvcnQocHJfcmVnLCAmaV9idWZbMF0sCisJCQkJUFJfUkVHX0lTSURfSURfTEVOKTsKKworCXByaW50ayhLRVJOX0lORk8gIlNQQy0zIFBSIFslc10gU2VydmljZSBBY3Rpb246IFJFU0VSVkUgY3JlYXRlZCBuZXciCisJCSIgcmVzZXJ2YXRpb24gaG9sZGVyIFRZUEU6ICVzIEFMTF9UR19QVDogJWRcbiIsCisJCUNNRF9URk8oY21kKS0+Z2V0X2ZhYnJpY19uYW1lKCksIGNvcmVfc2NzaTNfcHJfZHVtcF90eXBlKHR5cGUpLAorCQkocHJfcmVnLT5wcl9yZWdfYWxsX3RnX3B0KSA/IDEgOiAwKTsKKwlwcmludGsoS0VSTl9JTkZPICJTUEMtMyBQUiBbJXNdIFJFU0VSVkUgTm9kZTogJXMlc1xuIiwKKwkJCUNNRF9URk8oY21kKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCQlzZV9zZXNzLT5zZV9ub2RlX2FjbC0+aW5pdGlhdG9ybmFtZSwKKwkJCShwcmZfaXNpZCkgPyAmaV9idWZbMF0gOiAiIik7CisJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCisJaWYgKHByX3RtcGwtPnByX2FwdHBsX2FjdGl2ZSkgeworCQlyZXQgPSBjb3JlX3Njc2kzX3VwZGF0ZV9hbmRfd3JpdGVfYXB0cGwoU0VfREVWKGNtZCksCisJCQkJJnByX3JlZy0+cHJfYXB0cGxfYnVmWzBdLAorCQkJCXByX3RtcGwtPnByX2FwdHBsX2J1Zl9sZW4pOworCQlpZiAoIShyZXQpKQorCQkJcHJpbnRrKEtFUk5fSU5GTyAiU1BDLTMgUFI6IFVwZGF0ZWQgQVBUUEwgbWV0YWRhdGEiCisJCQkJCSIgZm9yIFJFU0VSVkVcbiIpOworCX0KKworCWNvcmVfc2NzaTNfcHV0X3ByX3JlZyhwcl9yZWcpOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfZW11bGF0ZV9wcm9fcmVzZXJ2ZSgKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJaW50IHR5cGUsCisJaW50IHNjb3BlLAorCXU2NCByZXNfa2V5KQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IGNtZC0+c2VfZGV2OworCWludCByZXQgPSAwOworCisJc3dpdGNoICh0eXBlKSB7CisJY2FzZSBQUl9UWVBFX1dSSVRFX0VYQ0xVU0lWRToKKwljYXNlIFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTUzoKKwljYXNlIFBSX1RZUEVfV1JJVEVfRVhDTFVTSVZFX1JFR09OTFk6CisJY2FzZSBQUl9UWVBFX0VYQ0xVU0lWRV9BQ0NFU1NfUkVHT05MWToKKwljYXNlIFBSX1RZUEVfV1JJVEVfRVhDTFVTSVZFX0FMTFJFRzoKKwljYXNlIFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTU19BTExSRUc6CisJCXJldCA9IGNvcmVfc2NzaTNfcHJvX3Jlc2VydmUoY21kLCBkZXYsIHR5cGUsIHNjb3BlLCByZXNfa2V5KTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcHJpbnRrKEtFUk5fRVJSICJTUEMtMyBQUjogVW5rbm93biBTZXJ2aWNlIEFjdGlvbiBSRVNFUlZFIFR5cGU6IgorCQkJIiAweCUwMnhcbiIsIHR5cGUpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9JTlZBTElEX0NEQl9GSUVMRDsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorCisvKgorICogQ2FsbGVkIHdpdGggc3RydWN0IHNlX2RldmljZS0+ZGV2X3Jlc2VydmF0aW9uX2xvY2sgaGVsZC4KKyAqLworc3RhdGljIHZvaWQgX19jb3JlX3Njc2kzX2NvbXBsZXRlX3Byb19yZWxlYXNlKAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKnNlX25hY2wsCisJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKnByX3JlZywKKwlpbnQgZXhwbGljdCkKK3sKKwlzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcyAqdGZvID0gc2VfbmFjbC0+c2VfdHBnLT5zZV90cGdfdGZvOworCWNoYXIgaV9idWZbUFJfUkVHX0lTSURfSURfTEVOXTsKKwlpbnQgcHJmX2lzaWQ7CisKKwltZW1zZXQoaV9idWYsIDAsIFBSX1JFR19JU0lEX0lEX0xFTik7CisJcHJmX2lzaWQgPSBjb3JlX3ByX2R1bXBfaW5pdGlhdG9yX3BvcnQocHJfcmVnLCAmaV9idWZbMF0sCisJCQkJUFJfUkVHX0lTSURfSURfTEVOKTsKKwkvKgorCSAqIEdvIGFoZWFkIGFuZCByZWxlYXNlIHRoZSBjdXJyZW50IFBSIHJlc2VydmF0aW9uIGhvbGRlci4KKwkgKi8KKwlkZXYtPmRldl9wcl9yZXNfaG9sZGVyID0gTlVMTDsKKworCXByaW50ayhLRVJOX0lORk8gIlNQQy0zIFBSIFslc10gU2VydmljZSBBY3Rpb246ICVzIFJFTEVBU0UgY2xlYXJlZCIKKwkJIiByZXNlcnZhdGlvbiBob2xkZXIgVFlQRTogJXMgQUxMX1RHX1BUOiAlZFxuIiwKKwkJdGZvLT5nZXRfZmFicmljX25hbWUoKSwgKGV4cGxpY3QpID8gImV4cGxpY3QiIDogImltcGxpY3QiLAorCQljb3JlX3Njc2kzX3ByX2R1bXBfdHlwZShwcl9yZWctPnByX3Jlc190eXBlKSwKKwkJKHByX3JlZy0+cHJfcmVnX2FsbF90Z19wdCkgPyAxIDogMCk7CisJcHJpbnRrKEtFUk5fSU5GTyAiU1BDLTMgUFIgWyVzXSBSRUxFQVNFIE5vZGU6ICVzJXNcbiIsCisJCXRmby0+Z2V0X2ZhYnJpY19uYW1lKCksIHNlX25hY2wtPmluaXRpYXRvcm5hbWUsCisJCShwcmZfaXNpZCkgPyAmaV9idWZbMF0gOiAiIik7CisJLyoKKwkgKiBDbGVhciBUWVBFIGFuZCBTQ09QRSBmb3IgdGhlIG5leHQgUFJPVVQgU2VydmljZSBBY3Rpb246IFJFU0VSVkUKKwkgKi8KKwlwcl9yZWctPnByX3Jlc19ob2xkZXIgPSBwcl9yZWctPnByX3Jlc190eXBlID0gcHJfcmVnLT5wcl9yZXNfc2NvcGUgPSAwOworfQorCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfZW11bGF0ZV9wcm9fcmVsZWFzZSgKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJaW50IHR5cGUsCisJaW50IHNjb3BlLAorCXU2NCByZXNfa2V5KQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IGNtZC0+c2VfZGV2OworCXN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzID0gU0VfU0VTUyhjbWQpOworCXN0cnVjdCBzZV9sdW4gKnNlX2x1biA9IFNFX0xVTihjbWQpOworCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsICpwcl9yZWdfcCwgKnByX3Jlc19ob2xkZXI7CisJc3RydWN0IHQxMF9yZXNlcnZhdGlvbl90ZW1wbGF0ZSAqcHJfdG1wbCA9ICZTVV9ERVYoZGV2KS0+dDEwX3Jlc2VydmF0aW9uOworCWludCByZXQsIGFsbF9yZWcgPSAwOworCisJaWYgKCEoc2Vfc2VzcykgfHwgIShzZV9sdW4pKSB7CisJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFI6IHNlX3Nlc3MgfHwgc3RydWN0IHNlX2x1biBpcyBOVUxMIVxuIik7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwl9CisJLyoKKwkgKiBMb2NhdGUgdGhlIGV4aXN0aW5nICpwcl9yZWcgdmlhIHN0cnVjdCBzZV9ub2RlX2FjbCBwb2ludGVycworCSAqLworCXByX3JlZyA9IGNvcmVfc2NzaTNfbG9jYXRlX3ByX3JlZyhkZXYsIHNlX3Nlc3MtPnNlX25vZGVfYWNsLCBzZV9zZXNzKTsKKwlpZiAoIShwcl9yZWcpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFI6IFVuYWJsZSB0byBsb2NhdGUiCisJCQkiIFBSX1JFR0lTVEVSRUQgKnByX3JlZyBmb3IgUkVMRUFTRVxuIik7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwl9CisJLyoKKwkgKiBGcm9tIHNwYzRyMTcgU2VjdGlvbiA1LjcuMTEuMiBSZWxlYXNpbmc6CisJICoKKwkgKiBJZiB0aGVyZSBpcyBubyBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIG9yIGluIHJlc3BvbnNlIHRvIGEgcGVyc2lzdGVudAorCSAqIHJlc2VydmF0aW9uIHJlbGVhc2UgcmVxdWVzdCBmcm9tIGEgcmVnaXN0ZXJlZCBJX1QgbmV4dXMgdGhhdCBpcyBub3QgYQorCSAqIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gaG9sZGVyIChzZWUgNS43LjEwKSwgdGhlIGRldmljZSBzZXJ2ZXIgc2hhbGwKKwkgKiBkbyB0aGUgZm9sbG93aW5nOgorCSAqCisJICogICAgIGEpIE5vdCByZWxlYXNlIHRoZSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uLCBpZiBhbnk7CisJICogICAgIGIpIE5vdCByZW1vdmUgYW55IHJlZ2lzdHJhdGlvbnM7IGFuZAorCSAqICAgICBjKSBDb21wbGV0ZSB0aGUgY29tbWFuZCB3aXRoIEdPT0Qgc3RhdHVzLgorCSAqLworCXNwaW5fbG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJcHJfcmVzX2hvbGRlciA9IGRldi0+ZGV2X3ByX3Jlc19ob2xkZXI7CisJaWYgKCEocHJfcmVzX2hvbGRlcikpIHsKKwkJLyoKKwkJICogTm8gcGVyc2lzdGVudCByZXNlcnZhdGlvbiwgcmV0dXJuIEdPT0Qgc3RhdHVzLgorCQkgKi8KKwkJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnKTsKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfU0VOVF9UT19UUkFOU1BPUlQ7CisJfQorCWlmICgocHJfcmVzX2hvbGRlci0+cHJfcmVzX3R5cGUgPT0gUFJfVFlQRV9XUklURV9FWENMVVNJVkVfQUxMUkVHKSB8fAorCSAgICAocHJfcmVzX2hvbGRlci0+cHJfcmVzX3R5cGUgPT0gUFJfVFlQRV9FWENMVVNJVkVfQUNDRVNTX0FMTFJFRykpCisJCWFsbF9yZWcgPSAxOworCisJaWYgKChhbGxfcmVnID09IDApICYmIChwcl9yZXNfaG9sZGVyICE9IHByX3JlZykpIHsKKwkJLyoKKwkJICogTm9uICdBbGwgUmVnaXN0cmFudHMnIFBSIFR5cGUgY2FzZXMuLgorCQkgKiBSZWxlYXNlIHJlcXVlc3QgZnJvbSBhIHJlZ2lzdGVyZWQgSV9UIG5leHVzIHRoYXQgaXMgbm90IGEKKwkJICogcGVyc2lzdGVudCByZXNlcnZhdGlvbiBob2xkZXIuIHJldHVybiBHT09EIHN0YXR1cy4KKwkJICovCisJCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwkJY29yZV9zY3NpM19wdXRfcHJfcmVnKHByX3JlZyk7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX1NFTlRfVE9fVFJBTlNQT1JUOworCX0KKwkvKgorCSAqIEZyb20gc3BjNHIxNyBTZWN0aW9uIDUuNy4xMS4yIFJlbGVhc2luZzoKKwkgKgorCSAqIE9ubHkgdGhlIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gaG9sZGVyIChzZWUgNS43LjEwKSBpcyBhbGxvd2VkIHRvCisJICogcmVsZWFzZSBhIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24uCisJICoKKwkgKiBBbiBhcHBsaWNhdGlvbiBjbGllbnQgcmVsZWFzZXMgdGhlIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gYnkgaXNzdWluZworCSAqIGEgUEVSU0lTVEVOVCBSRVNFUlZFIE9VVCBjb21tYW5kIHdpdGggUkVMRUFTRSBzZXJ2aWNlIGFjdGlvbiB0aHJvdWdoCisJICogYW4gSV9UIG5leHVzIHRoYXQgaXMgYSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIGhvbGRlciB3aXRoIHRoZQorCSAqIGZvbGxvd2luZyBwYXJhbWV0ZXJzOgorCSAqCisJICogICAgIGEpIFJFU0VSVkFUSU9OIEtFWSBmaWVsZCBzZXQgdG8gdGhlIHZhbHVlIG9mIHRoZSByZXNlcnZhdGlvbiBrZXkKKwkgKgkgIHRoYXQgaXMgcmVnaXN0ZXJlZCB3aXRoIHRoZSBsb2dpY2FsIHVuaXQgZm9yIHRoZSBJX1QgbmV4dXM7CisJICovCisJaWYgKHJlc19rZXkgIT0gcHJfcmVnLT5wcl9yZXNfa2V5KSB7CisJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFIgUkVMRUFTRTogUmVjZWl2ZWQgcmVzX2tleTogMHglMDE2THgiCisJCQkiIGRvZXMgbm90IG1hdGNoIGV4aXN0aW5nIFNBIFJFR0lTVEVSIHJlc19rZXk6IgorCQkJIiAweCUwMTZMeFxuIiwgcmVzX2tleSwgcHJfcmVnLT5wcl9yZXNfa2V5KTsKKwkJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnKTsKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfUkVTRVJWQVRJT05fQ09ORkxJQ1Q7CisJfQorCS8qCisJICogRnJvbSBzcGM0cjE3IFNlY3Rpb24gNS43LjExLjIgUmVsZWFzaW5nIGFuZCBhYm92ZToKKwkgKgorCSAqIGIpIFRZUEUgZmllbGQgYW5kIFNDT1BFIGZpZWxkIHNldCB0byBtYXRjaCB0aGUgcGVyc2lzdGVudAorCSAqICAgIHJlc2VydmF0aW9uIGJlaW5nIHJlbGVhc2VkLgorCSAqLworCWlmICgocHJfcmVzX2hvbGRlci0+cHJfcmVzX3R5cGUgIT0gdHlwZSkgfHwKKwkgICAgKHByX3Jlc19ob2xkZXItPnByX3Jlc19zY29wZSAhPSBzY29wZSkpIHsKKwkJc3RydWN0IHNlX25vZGVfYWNsICpwcl9yZXNfbmFjbCA9IHByX3Jlc19ob2xkZXItPnByX3JlZ19uYWNsOworCQlwcmludGsoS0VSTl9FUlIgIlNQQy0zIFBSIFJFTEVBU0U6IEF0dGVtcHRlZCB0byByZWxlYXNlIgorCQkJIiByZXNlcnZhdGlvbiBmcm9tIFslc106ICVzIHdpdGggZGlmZmVyZW50IFRZUEUgIgorCQkJImFuZC9vciBTQ09QRSAgd2hpbGUgcmVzZXJ2YXRpb24gYWxyZWFkeSBoZWxkIGJ5IgorCQkJIiBbJXNdOiAlcywgcmV0dXJuaW5nIFJFU0VSVkFUSU9OX0NPTkZMSUNUXG4iLAorCQkJQ01EX1RGTyhjbWQpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJCXNlX3Nlc3MtPnNlX25vZGVfYWNsLT5pbml0aWF0b3JuYW1lLAorCQkJVFBHX1RGTyhwcl9yZXNfbmFjbC0+c2VfdHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCQlwcl9yZXNfaG9sZGVyLT5wcl9yZWdfbmFjbC0+aW5pdGlhdG9ybmFtZSk7CisKKwkJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnKTsKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfUkVTRVJWQVRJT05fQ09ORkxJQ1Q7CisJfQorCS8qCisJICogSW4gcmVzcG9uc2UgdG8gYSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIHJlbGVhc2UgcmVxdWVzdCBmcm9tIHRoZQorCSAqIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gaG9sZGVyIHRoZSBkZXZpY2Ugc2VydmVyIHNoYWxsIHBlcmZvcm0gYQorCSAqIHJlbGVhc2UgYnkgZG9pbmcgdGhlIGZvbGxvd2luZyBhcyBhbiB1bmludGVycnVwdGVkIHNlcmllcyBvZiBhY3Rpb25zOgorCSAqIGEpIFJlbGVhc2UgdGhlIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb247CisJICogYikgTm90IHJlbW92ZSBhbnkgcmVnaXN0cmF0aW9uKHMpOworCSAqIGMpIElmIHRoZSByZWxlYXNlZCBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIGlzIGEgcmVnaXN0cmFudHMgb25seSB0eXBlCisJICogb3IgYWxsIHJlZ2lzdHJhbnRzIHR5cGUgcGVyc2lzdGVudCByZXNlcnZhdGlvbiwKKwkgKiAgICB0aGUgZGV2aWNlIHNlcnZlciBzaGFsbCBlc3RhYmxpc2ggYSB1bml0IGF0dGVudGlvbiBjb25kaXRpb24gZm9yCisJICogICAgdGhlIGluaXRpYXRvciBwb3J0IGFzc29jaWF0ZWQgd2l0aCBldmVyeSByZWdpcy0KKwkgKiAgICB0ZXJlZCBJX1QgbmV4dXMgb3RoZXIgdGhhbiBJX1QgbmV4dXMgb24gd2hpY2ggdGhlIFBFUlNJU1RFTlQKKwkgKiAgICBSRVNFUlZFIE9VVCBjb21tYW5kIHdpdGggUkVMRUFTRSBzZXJ2aWNlIGFjdGlvbiB3YXMgcmVjZWl2ZWQsCisJICogICAgd2l0aCB0aGUgYWRkaXRpb25hbCBzZW5zZSBjb2RlIHNldCB0byBSRVNFUlZBVElPTlMgUkVMRUFTRUQ7IGFuZAorCSAqIGQpIElmIHRoZSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIGlzIG9mIGFueSBvdGhlciB0eXBlLCB0aGUgZGV2aWNlCisJICogICAgc2VydmVyIHNoYWxsIG5vdCBlc3RhYmxpc2ggYSB1bml0IGF0dGVudGlvbiBjb25kaXRpb24uCisJICovCisJX19jb3JlX3Njc2kzX2NvbXBsZXRlX3Byb19yZWxlYXNlKGRldiwgc2Vfc2Vzcy0+c2Vfbm9kZV9hY2wsCisJCQlwcl9yZWcsIDEpOworCisJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCisJaWYgKCh0eXBlICE9IFBSX1RZUEVfV1JJVEVfRVhDTFVTSVZFX1JFR09OTFkpICYmCisJICAgICh0eXBlICE9IFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTU19SRUdPTkxZKSAmJgorCSAgICAodHlwZSAhPSBQUl9UWVBFX1dSSVRFX0VYQ0xVU0lWRV9BTExSRUcpICYmCisJICAgICh0eXBlICE9IFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTU19BTExSRUcpKSB7CisJCS8qCisJCSAqIElmIG5vIFVOSVQgQVRURU5USU9OIGNvbmRpdGlvbnMgd2lsbCBiZSBlc3RhYmxpc2hlZCBmb3IKKwkJICogUFJfVFlQRV9XUklURV9FWENMVVNJVkUgb3IgUFJfVFlQRV9FWENMVVNJVkVfQUNDRVNTCisJCSAqIGdvIGFoZWFkIGFuZCBjaGVjayBmb3IgQVBUUEw9MSB1cGRhdGUrd3JpdGUgYmVsb3cKKwkJICovCisJCWdvdG8gd3JpdGVfYXB0cGw7CisJfQorCisJc3Bpbl9sb2NrKCZwcl90bXBsLT5yZWdpc3RyYXRpb25fbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShwcl9yZWdfcCwgJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9saXN0LAorCQkJcHJfcmVnX2xpc3QpIHsKKwkJLyoKKwkJICogRG8gbm90IGVzdGFibGlzaCBhIFVOSVQgQVRURU5USU9OIGNvbmRpdGlvbgorCQkgKiBmb3IgdGhlIGNhbGxpbmcgSV9UIE5leHVzCisJCSAqLworCQlpZiAocHJfcmVnX3AgPT0gcHJfcmVnKQorCQkJY29udGludWU7CisKKwkJY29yZV9zY3NpM191YV9hbGxvY2F0ZShwcl9yZWdfcC0+cHJfcmVnX25hY2wsCisJCQkJcHJfcmVnX3AtPnByX3Jlc19tYXBwZWRfbHVuLAorCQkJCTB4MkEsIEFTQ1FfMkFIX1JFU0VSVkFUSU9OU19SRUxFQVNFRCk7CisJfQorCXNwaW5fdW5sb2NrKCZwcl90bXBsLT5yZWdpc3RyYXRpb25fbG9jayk7CisKK3dyaXRlX2FwdHBsOgorCWlmIChwcl90bXBsLT5wcl9hcHRwbF9hY3RpdmUpIHsKKwkJcmV0ID0gY29yZV9zY3NpM191cGRhdGVfYW5kX3dyaXRlX2FwdHBsKFNFX0RFVihjbWQpLAorCQkJCSZwcl9yZWctPnByX2FwdHBsX2J1ZlswXSwKKwkJCQlwcl90bXBsLT5wcl9hcHRwbF9idWZfbGVuKTsKKwkJaWYgKCEocmV0KSkKKwkJCXByaW50aygiU1BDLTMgUFI6IFVwZGF0ZWQgQVBUUEwgbWV0YWRhdGEgZm9yIFJFTEVBU0VcbiIpOworCX0KKworCWNvcmVfc2NzaTNfcHV0X3ByX3JlZyhwcl9yZWcpOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfZW11bGF0ZV9wcm9fY2xlYXIoCisJc3RydWN0IHNlX2NtZCAqY21kLAorCXU2NCByZXNfa2V5KQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IGNtZC0+c2VfZGV2OworCXN0cnVjdCBzZV9ub2RlX2FjbCAqcHJfcmVnX25hY2w7CisJc3RydWN0IHNlX3Nlc3Npb24gKnNlX3Nlc3MgPSBTRV9TRVNTKGNtZCk7CisJc3RydWN0IHQxMF9yZXNlcnZhdGlvbl90ZW1wbGF0ZSAqcHJfdG1wbCA9ICZTVV9ERVYoZGV2KS0+dDEwX3Jlc2VydmF0aW9uOworCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsICpwcl9yZWdfdG1wLCAqcHJfcmVnX24sICpwcl9yZXNfaG9sZGVyOworCXUzMiBwcl9yZXNfbWFwcGVkX2x1biA9IDA7CisJaW50IGNhbGxpbmdfaXRfbmV4dXMgPSAwOworCS8qCisJICogTG9jYXRlIHRoZSBleGlzdGluZyAqcHJfcmVnIHZpYSBzdHJ1Y3Qgc2Vfbm9kZV9hY2wgcG9pbnRlcnMKKwkgKi8KKwlwcl9yZWdfbiA9IGNvcmVfc2NzaTNfbG9jYXRlX3ByX3JlZyhTRV9ERVYoY21kKSwKKwkJCXNlX3Nlc3MtPnNlX25vZGVfYWNsLCBzZV9zZXNzKTsKKwlpZiAoIShwcl9yZWdfbikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJTUEMtMyBQUjogVW5hYmxlIHRvIGxvY2F0ZSIKKwkJCSIgUFJfUkVHSVNURVJFRCAqcHJfcmVnIGZvciBDTEVBUlxuIik7CisJCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9MVV9DT01NX0ZBSUxVUkU7CisJfQorCS8qCisJICogRnJvbSBzcGM0cjE3IHNlY3Rpb24gNS43LjExLjYsIENsZWFyaW5nOgorCSAqCisJICogQW55IGFwcGxpY2F0aW9uIGNsaWVudCBtYXkgcmVsZWFzZSB0aGUgcGVyc2lzdGVudCByZXNlcnZhdGlvbiBhbmQKKwkgKiByZW1vdmUgYWxsIHJlZ2lzdHJhdGlvbnMgZnJvbSBhIGRldmljZSBzZXJ2ZXIgYnkgaXNzdWluZyBhCisJICogUEVSU0lTVEVOVCBSRVNFUlZFIE9VVCBjb21tYW5kIHdpdGggQ0xFQVIgc2VydmljZSBhY3Rpb24gdGhyb3VnaCBhCisJICogcmVnaXN0ZXJlZCBJX1QgbmV4dXMgd2l0aCB0aGUgZm9sbG93aW5nIHBhcmFtZXRlcjoKKwkgKgorCSAqCWEpIFJFU0VSVkFUSU9OIEtFWSBmaWVsZCBzZXQgdG8gdGhlIHZhbHVlIG9mIHRoZSByZXNlcnZhdGlvbiBrZXkKKwkgKiAJICAgdGhhdCBpcyByZWdpc3RlcmVkIHdpdGggdGhlIGxvZ2ljYWwgdW5pdCBmb3IgdGhlIElfVCBuZXh1cy4KKwkgKi8KKwlpZiAocmVzX2tleSAhPSBwcl9yZWdfbi0+cHJfcmVzX2tleSkgeworCQlwcmludGsoS0VSTl9FUlIgIlNQQy0zIFBSIFJFR0lTVEVSOiBSZWNlaXZlZCIKKwkJCSIgcmVzX2tleTogMHglMDE2THggZG9lcyBub3QgbWF0Y2giCisJCQkiIGV4aXN0aW5nIFNBIFJFR0lTVEVSIHJlc19rZXk6IgorCQkJIiAweCUwMTZMeFxuIiwgcmVzX2tleSwgcHJfcmVnX24tPnByX3Jlc19rZXkpOworCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnX24pOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9SRVNFUlZBVElPTl9DT05GTElDVDsKKwl9CisJLyoKKwkgKiBhKSBSZWxlYXNlIHRoZSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uLCBpZiBhbnk7CisJICovCisJc3Bpbl9sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwlwcl9yZXNfaG9sZGVyID0gZGV2LT5kZXZfcHJfcmVzX2hvbGRlcjsKKwlpZiAocHJfcmVzX2hvbGRlcikgeworCQlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKnByX3Jlc19uYWNsID0gcHJfcmVzX2hvbGRlci0+cHJfcmVnX25hY2w7CisJCV9fY29yZV9zY3NpM19jb21wbGV0ZV9wcm9fcmVsZWFzZShkZXYsIHByX3Jlc19uYWNsLAorCQkJcHJfcmVzX2hvbGRlciwgMCk7CisJfQorCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwkvKgorCSAqIGIpIFJlbW92ZSBhbGwgcmVnaXN0cmF0aW9uKHMpIChzZWUgc3BjNHIxNyA1LjcuNyk7CisJICovCisJc3Bpbl9sb2NrKCZwcl90bXBsLT5yZWdpc3RyYXRpb25fbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHByX3JlZywgcHJfcmVnX3RtcCwKKwkJCSZwcl90bXBsLT5yZWdpc3RyYXRpb25fbGlzdCwgcHJfcmVnX2xpc3QpIHsKKworCQljYWxsaW5nX2l0X25leHVzID0gKHByX3JlZ19uID09IHByX3JlZykgPyAxIDogMDsKKwkJcHJfcmVnX25hY2wgPSBwcl9yZWctPnByX3JlZ19uYWNsOworCQlwcl9yZXNfbWFwcGVkX2x1biA9IHByX3JlZy0+cHJfcmVzX21hcHBlZF9sdW47CisJCV9fY29yZV9zY3NpM19mcmVlX3JlZ2lzdHJhdGlvbihkZXYsIHByX3JlZywgTlVMTCwKKwkJCQkJY2FsbGluZ19pdF9uZXh1cyk7CisJCS8qCisJCSAqIGUpIEVzdGFibGlzaCBhIHVuaXQgYXR0ZW50aW9uIGNvbmRpdGlvbiBmb3IgdGhlIGluaXRpYXRvcgorCQkgKiAgICBwb3J0IGFzc29jaWF0ZWQgd2l0aCBldmVyeSByZWdpc3RlcmVkIElfVCBuZXh1cyBvdGhlcgorCQkgKiAgICB0aGFuIHRoZSBJX1QgbmV4dXMgb24gd2hpY2ggdGhlIFBFUlNJU1RFTlQgUkVTRVJWRSBPVVQKKwkJICogICAgY29tbWFuZCB3aXRoIENMRUFSIHNlcnZpY2UgYWN0aW9uIHdhcyByZWNlaXZlZCwgd2l0aCB0aGUKKwkJICogICAgYWRkaXRpb25hbCBzZW5zZSBjb2RlIHNldCB0byBSRVNFUlZBVElPTlMgUFJFRU1QVEVELgorCQkgKi8KKwkJaWYgKCEoY2FsbGluZ19pdF9uZXh1cykpCisJCQljb3JlX3Njc2kzX3VhX2FsbG9jYXRlKHByX3JlZ19uYWNsLCBwcl9yZXNfbWFwcGVkX2x1biwKKwkJCQkweDJBLCBBU0NRXzJBSF9SRVNFUlZBVElPTlNfUFJFRU1QVEVEKTsKKwl9CisJc3Bpbl91bmxvY2soJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9sb2NrKTsKKworCXByaW50ayhLRVJOX0lORk8gIlNQQy0zIFBSIFslc10gU2VydmljZSBBY3Rpb246IENMRUFSIGNvbXBsZXRlXG4iLAorCQlDTURfVEZPKGNtZCktPmdldF9mYWJyaWNfbmFtZSgpKTsKKworCWlmIChwcl90bXBsLT5wcl9hcHRwbF9hY3RpdmUpIHsKKwkJY29yZV9zY3NpM191cGRhdGVfYW5kX3dyaXRlX2FwdHBsKFNFX0RFVihjbWQpLCBOVUxMLCAwKTsKKwkJcHJpbnRrKEtFUk5fSU5GTyAiU1BDLTMgUFI6IFVwZGF0ZWQgQVBUUEwgbWV0YWRhdGEiCisJCQkJIiBmb3IgQ0xFQVJcbiIpOworCX0KKworCWNvcmVfc2NzaTNfcHJfZ2VuZXJhdGlvbihkZXYpOworCXJldHVybiAwOworfQorCisvKgorICogQ2FsbGVkIHdpdGggc3RydWN0IHNlX2RldmljZS0+ZGV2X3Jlc2VydmF0aW9uX2xvY2sgaGVsZC4KKyAqLworc3RhdGljIHZvaWQgX19jb3JlX3Njc2kzX2NvbXBsZXRlX3Byb19wcmVlbXB0KAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnLAorCXN0cnVjdCBsaXN0X2hlYWQgKnByZWVtcHRfYW5kX2Fib3J0X2xpc3QsCisJaW50IHR5cGUsCisJaW50IHNjb3BlLAorCWludCBhYm9ydCkKK3sKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKm5hY2wgPSBwcl9yZWctPnByX3JlZ19uYWNsOworCXN0cnVjdCB0YXJnZXRfY29yZV9mYWJyaWNfb3BzICp0Zm8gPSBuYWNsLT5zZV90cGctPnNlX3RwZ190Zm87CisJY2hhciBpX2J1ZltQUl9SRUdfSVNJRF9JRF9MRU5dOworCWludCBwcmZfaXNpZDsKKworCW1lbXNldChpX2J1ZiwgMCwgUFJfUkVHX0lTSURfSURfTEVOKTsKKwlwcmZfaXNpZCA9IGNvcmVfcHJfZHVtcF9pbml0aWF0b3JfcG9ydChwcl9yZWcsICZpX2J1ZlswXSwKKwkJCQlQUl9SRUdfSVNJRF9JRF9MRU4pOworCS8qCisJICogRG8gYW4gaW1wbGljdCBSRUxFQVNFIG9mIHRoZSBleGlzdGluZyByZXNlcnZhdGlvbi4KKwkgKi8KKwlpZiAoZGV2LT5kZXZfcHJfcmVzX2hvbGRlcikKKwkJX19jb3JlX3Njc2kzX2NvbXBsZXRlX3Byb19yZWxlYXNlKGRldiwgbmFjbCwKKwkJCQlkZXYtPmRldl9wcl9yZXNfaG9sZGVyLCAwKTsKKworCWRldi0+ZGV2X3ByX3Jlc19ob2xkZXIgPSBwcl9yZWc7CisJcHJfcmVnLT5wcl9yZXNfaG9sZGVyID0gMTsKKwlwcl9yZWctPnByX3Jlc190eXBlID0gdHlwZTsKKwlwcl9yZWctPnByX3Jlc19zY29wZSA9IHNjb3BlOworCisJcHJpbnRrKEtFUk5fSU5GTyAiU1BDLTMgUFIgWyVzXSBTZXJ2aWNlIEFjdGlvbjogUFJFRU1QVCVzIGNyZWF0ZWQgbmV3IgorCQkiIHJlc2VydmF0aW9uIGhvbGRlciBUWVBFOiAlcyBBTExfVEdfUFQ6ICVkXG4iLAorCQl0Zm8tPmdldF9mYWJyaWNfbmFtZSgpLCAoYWJvcnQpID8gIl9BTkRfQUJPUlQiIDogIiIsCisJCWNvcmVfc2NzaTNfcHJfZHVtcF90eXBlKHR5cGUpLAorCQkocHJfcmVnLT5wcl9yZWdfYWxsX3RnX3B0KSA/IDEgOiAwKTsKKwlwcmludGsoS0VSTl9JTkZPICJTUEMtMyBQUiBbJXNdIFBSRUVNUFQlcyBmcm9tIE5vZGU6ICVzJXNcbiIsCisJCXRmby0+Z2V0X2ZhYnJpY19uYW1lKCksIChhYm9ydCkgPyAiX0FORF9BQk9SVCIgOiAiIiwKKwkJbmFjbC0+aW5pdGlhdG9ybmFtZSwgKHByZl9pc2lkKSA/ICZpX2J1ZlswXSA6ICIiKTsKKwkvKgorCSAqIEZvciBQUkVFTVBUX0FORF9BQk9SVCwgYWRkIHRoZSBwcmVlbXB0aW5nIHJlc2VydmF0aW9uJ3MKKwkgKiBzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiB0byB0aGUgbGlzdCB0aGF0IHdpbGwgYmUgY29tcGFyZWQKKwkgKiBhZ2FpbnN0IHJlY2VpdmVkIENEQnMuLgorCSAqLworCWlmIChwcmVlbXB0X2FuZF9hYm9ydF9saXN0KQorCQlsaXN0X2FkZF90YWlsKCZwcl9yZWctPnByX3JlZ19hYm9ydF9saXN0LAorCQkJCXByZWVtcHRfYW5kX2Fib3J0X2xpc3QpOworfQorCitzdGF0aWMgdm9pZCBjb3JlX3Njc2kzX3JlbGVhc2VfcHJlZW1wdF9hbmRfYWJvcnQoCisJc3RydWN0IGxpc3RfaGVhZCAqcHJlZW1wdF9hbmRfYWJvcnRfbGlzdCwKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnX2hvbGRlcikKK3sKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnLCAqcHJfcmVnX3RtcDsKKworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShwcl9yZWcsIHByX3JlZ190bXAsIHByZWVtcHRfYW5kX2Fib3J0X2xpc3QsCisJCQkJcHJfcmVnX2Fib3J0X2xpc3QpIHsKKworCQlsaXN0X2RlbCgmcHJfcmVnLT5wcl9yZWdfYWJvcnRfbGlzdCk7CisJCWlmIChwcl9yZWdfaG9sZGVyID09IHByX3JlZykKKwkJCWNvbnRpbnVlOworCQlpZiAocHJfcmVnLT5wcl9yZXNfaG9sZGVyKSB7CisJCQlwcmludGsoS0VSTl9XQVJOSU5HICJwcl9yZWctPnByX3Jlc19ob2xkZXIgc3RpbGwgc2V0XG4iKTsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJcHJfcmVnLT5wcl9yZWdfZGV2ZSA9IE5VTEw7CisJCXByX3JlZy0+cHJfcmVnX25hY2wgPSBOVUxMOworCQlrZnJlZShwcl9yZWctPnByX2FwdHBsX2J1Zik7CisJCWttZW1fY2FjaGVfZnJlZSh0MTBfcHJfcmVnX2NhY2hlLCBwcl9yZWcpOworCX0KK30KKworaW50IGNvcmVfc2NzaTNfY2hlY2tfY2RiX2Fib3J0X2FuZF9wcmVlbXB0KAorCXN0cnVjdCBsaXN0X2hlYWQgKnByZWVtcHRfYW5kX2Fib3J0X2xpc3QsCisJc3RydWN0IHNlX2NtZCAqY21kKQoreworCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsICpwcl9yZWdfdG1wOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHByX3JlZywgcHJfcmVnX3RtcCwgcHJlZW1wdF9hbmRfYWJvcnRfbGlzdCwKKwkJCQlwcl9yZWdfYWJvcnRfbGlzdCkgeworCQlpZiAocHJfcmVnLT5wcl9yZXNfa2V5ID09IGNtZC0+cHJfcmVzX2tleSkKKwkJCXJldHVybiAwOworCX0KKworCXJldHVybiAxOworfQorCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfcHJvX3ByZWVtcHQoCisJc3RydWN0IHNlX2NtZCAqY21kLAorCWludCB0eXBlLAorCWludCBzY29wZSwKKwl1NjQgcmVzX2tleSwKKwl1NjQgc2FfcmVzX2tleSwKKwlpbnQgYWJvcnQpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gU0VfREVWKGNtZCk7CisJc3RydWN0IHNlX2Rldl9lbnRyeSAqc2VfZGV2ZTsKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKnByX3JlZ19uYWNsOworCXN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzID0gU0VfU0VTUyhjbWQpOworCXN0cnVjdCBsaXN0X2hlYWQgcHJlZW1wdF9hbmRfYWJvcnRfbGlzdDsKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnLCAqcHJfcmVnX3RtcCwgKnByX3JlZ19uLCAqcHJfcmVzX2hvbGRlcjsKKwlzdHJ1Y3QgdDEwX3Jlc2VydmF0aW9uX3RlbXBsYXRlICpwcl90bXBsID0gJlNVX0RFVihkZXYpLT50MTBfcmVzZXJ2YXRpb247CisJdTMyIHByX3Jlc19tYXBwZWRfbHVuID0gMDsKKwlpbnQgYWxsX3JlZyA9IDAsIGNhbGxpbmdfaXRfbmV4dXMgPSAwLCByZWxlYXNlZF9yZWdzID0gMDsKKwlpbnQgcHJoX3R5cGUgPSAwLCBwcmhfc2NvcGUgPSAwLCByZXQ7CisKKwlpZiAoIShzZV9zZXNzKSkKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfTFVfQ09NTV9GQUlMVVJFOworCisJc2VfZGV2ZSA9ICZzZV9zZXNzLT5zZV9ub2RlX2FjbC0+ZGV2aWNlX2xpc3RbY21kLT5vcmlnX2ZlX2x1bl07CisJcHJfcmVnX24gPSBjb3JlX3Njc2kzX2xvY2F0ZV9wcl9yZWcoU0VfREVWKGNtZCksIHNlX3Nlc3MtPnNlX25vZGVfYWNsLAorCQkJCXNlX3Nlc3MpOworCWlmICghKHByX3JlZ19uKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlNQQy0zIFBSOiBVbmFibGUgdG8gbG9jYXRlIgorCQkJIiBQUl9SRUdJU1RFUkVEICpwcl9yZWcgZm9yIFBSRUVNUFQlc1xuIiwKKwkJCShhYm9ydCkgPyAiX0FORF9BQk9SVCIgOiAiIik7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX1JFU0VSVkFUSU9OX0NPTkZMSUNUOworCX0KKwlpZiAocHJfcmVnX24tPnByX3Jlc19rZXkgIT0gcmVzX2tleSkgeworCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnX24pOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9SRVNFUlZBVElPTl9DT05GTElDVDsKKwl9CisJaWYgKHNjb3BlICE9IFBSX1NDT1BFX0xVX1NDT1BFKSB7CisJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFI6IElsbGVnYWwgU0NPUEU6IDB4JTAyeFxuIiwgc2NvcGUpOworCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnX24pOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCX0KKwlJTklUX0xJU1RfSEVBRCgmcHJlZW1wdF9hbmRfYWJvcnRfbGlzdCk7CisKKwlzcGluX2xvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCXByX3Jlc19ob2xkZXIgPSBkZXYtPmRldl9wcl9yZXNfaG9sZGVyOworCWlmIChwcl9yZXNfaG9sZGVyICYmCisJICAgKChwcl9yZXNfaG9sZGVyLT5wcl9yZXNfdHlwZSA9PSBQUl9UWVBFX1dSSVRFX0VYQ0xVU0lWRV9BTExSRUcpIHx8CisJICAgIChwcl9yZXNfaG9sZGVyLT5wcl9yZXNfdHlwZSA9PSBQUl9UWVBFX0VYQ0xVU0lWRV9BQ0NFU1NfQUxMUkVHKSkpCisJCWFsbF9yZWcgPSAxOworCisJaWYgKCEoYWxsX3JlZykgJiYgIShzYV9yZXNfa2V5KSkgeworCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCWNvcmVfc2NzaTNfcHV0X3ByX3JlZyhwcl9yZWdfbik7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0lOVkFMSURfUEFSQU1FVEVSX0xJU1Q7CisJfQorCS8qCisJICogRnJvbSBzcGM0cjE3LCBzZWN0aW9uIDUuNy4xMS40LjQgUmVtb3ZpbmcgUmVnaXN0cmF0aW9uczoKKwkgKgorCSAqIElmIHRoZSBTRVJWSUNFIEFDVElPTiBSRVNFUlZBVElPTiBLRVkgZmllbGQgZG9lcyBub3QgaWRlbnRpZnkgYQorCSAqIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gaG9sZGVyIG9yIHRoZXJlIGlzIG5vIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24KKwkgKiBob2xkZXIgKGkuZS4sIHRoZXJlIGlzIG5vIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24pLCB0aGVuIHRoZSBkZXZpY2UKKwkgKiBzZXJ2ZXIgc2hhbGwgcGVyZm9ybSBhIHByZWVtcHQgYnkgZG9pbmcgdGhlIGZvbGxvd2luZyBpbiBhbgorCSAqIHVuaW50ZXJydXB0ZWQgc2VyaWVzIG9mIGFjdGlvbnMuIChTZWUgYmVsb3cuLikKKwkgKi8KKwlpZiAoIShwcl9yZXNfaG9sZGVyKSB8fCAocHJfcmVzX2hvbGRlci0+cHJfcmVzX2tleSAhPSBzYV9yZXNfa2V5KSkgeworCQkvKgorCQkgKiBObyBleGlzdGluZyBvciBTQSBSZXNlcnZhdGlvbiBLZXkgbWF0Y2hpbmcgcmVzZXJ2YXRpb25zLi4KKwkJICoKKwkJICogUFJPVVQgU0EgUFJFRU1QVCB3aXRoIEFsbCBSZWdpc3RyYW50IHR5cGUgcmVzZXJ2YXRpb25zIGFyZQorCQkgKiBhbGxvd2VkIHRvIGJlIHByb2Nlc3NlZCB3aXRob3V0IGEgbWF0Y2hpbmcgU0EgUmVzZXJ2YXRpb24gS2V5CisJCSAqLworCQlzcGluX2xvY2soJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9sb2NrKTsKKwkJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHByX3JlZywgcHJfcmVnX3RtcCwKKwkJCQkmcHJfdG1wbC0+cmVnaXN0cmF0aW9uX2xpc3QsIHByX3JlZ19saXN0KSB7CisJCQkvKgorCQkJICogUmVtb3Zpbmcgb2YgcmVnaXN0cmF0aW9ucyBpbiBub24gYWxsIHJlZ2lzdHJhbnRzCisJCQkgKiB0eXBlIHJlc2VydmF0aW9ucyB3aXRob3V0IGEgbWF0Y2hpbmcgU0EgcmVzZXJ2YXRpb24KKwkJCSAqIGtleS4KKwkJCSAqCisJCQkgKiBhKSBSZW1vdmUgdGhlIHJlZ2lzdHJhdGlvbnMgZm9yIGFsbCBJX1QgbmV4dXNlcworCQkJICogICAgc3BlY2lmaWVkIGJ5IHRoZSBTRVJWSUNFIEFDVElPTiBSRVNFUlZBVElPTiBLRVkKKwkJCSAqICAgIGZpZWxkOworCQkJICogYikgSWdub3JlIHRoZSBjb250ZW50cyBvZiB0aGUgU0NPUEUgYW5kIFRZUEUgZmllbGRzOworCQkJICogYykgUHJvY2VzcyB0YXNrcyBhcyBkZWZpbmVkIGluIDUuNy4xOyBhbmQKKwkJCSAqIGQpIEVzdGFibGlzaCBhIHVuaXQgYXR0ZW50aW9uIGNvbmRpdGlvbiBmb3IgdGhlCisJCQkgKiAgICBpbml0aWF0b3IgcG9ydCBhc3NvY2lhdGVkIHdpdGggZXZlcnkgSV9UIG5leHVzCisJCQkgKiAgICB0aGF0IGxvc3QgaXRzIHJlZ2lzdHJhdGlvbiBvdGhlciB0aGFuIHRoZSBJX1QKKwkJCSAqICAgIG5leHVzIG9uIHdoaWNoIHRoZSBQRVJTSVNURU5UIFJFU0VSVkUgT1VUIGNvbW1hbmQKKwkJCSAqICAgIHdhcyByZWNlaXZlZCwgd2l0aCB0aGUgYWRkaXRpb25hbCBzZW5zZSBjb2RlIHNldAorCQkJICogICAgdG8gUkVHSVNUUkFUSU9OUyBQUkVFTVBURUQuCisJCQkgKi8KKwkJCWlmICghKGFsbF9yZWcpKSB7CisJCQkJaWYgKHByX3JlZy0+cHJfcmVzX2tleSAhPSBzYV9yZXNfa2V5KQorCQkJCQljb250aW51ZTsKKworCQkJCWNhbGxpbmdfaXRfbmV4dXMgPSAocHJfcmVnX24gPT0gcHJfcmVnKSA/IDEgOiAwOworCQkJCXByX3JlZ19uYWNsID0gcHJfcmVnLT5wcl9yZWdfbmFjbDsKKwkJCQlwcl9yZXNfbWFwcGVkX2x1biA9IHByX3JlZy0+cHJfcmVzX21hcHBlZF9sdW47CisJCQkJX19jb3JlX3Njc2kzX2ZyZWVfcmVnaXN0cmF0aW9uKGRldiwgcHJfcmVnLAorCQkJCQkoYWJvcnQpID8gJnByZWVtcHRfYW5kX2Fib3J0X2xpc3QgOgorCQkJCQkJTlVMTCwgY2FsbGluZ19pdF9uZXh1cyk7CisJCQkJcmVsZWFzZWRfcmVncysrOworCQkJfSBlbHNlIHsKKwkJCQkvKgorCQkJCSAqIENhc2UgZm9yIGFueSBleGlzdGluZyBhbGwgcmVnaXN0cmFudHMgdHlwZQorCQkJCSAqIHJlc2VydmF0aW9uLCBmb2xsb3cgbG9naWMgaW4gc3BjNHIxNyBzZWN0aW9uCisJCQkJICogNS43LjExLjQgUHJlZW1wdGluZywgVGFibGUgNTIgYW5kIEZpZ3VyZSA3LgorCQkJCSAqCisJCQkJICogRm9yIGEgWkVSTyBTQSBSZXNlcnZhdGlvbiBrZXksIHJlbGVhc2UKKwkJCQkgKiBhbGwgb3RoZXIgcmVnaXN0cmF0aW9ucyBhbmQgZG8gYW4gaW1wbGljdAorCQkJCSAqIHJlbGVhc2Ugb2YgYWN0aXZlIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24uCisJCQkJICoKKwkJCQkgKiBGb3IgYSBub24tWkVSTyBTQSBSZXNlcnZhdGlvbiBrZXksIG9ubHkKKwkJCQkgKiByZWxlYXNlIHRoZSBtYXRjaGluZyByZXNlcnZhdGlvbiBrZXkgZnJvbQorCQkJCSAqIHJlZ2lzdHJhdGlvbnMuCisJCQkJICovCisJCQkJaWYgKChzYV9yZXNfa2V5KSAmJgorCQkJCSAgICAgKHByX3JlZy0+cHJfcmVzX2tleSAhPSBzYV9yZXNfa2V5KSkKKwkJCQkJY29udGludWU7CisKKwkJCQljYWxsaW5nX2l0X25leHVzID0gKHByX3JlZ19uID09IHByX3JlZykgPyAxIDogMDsKKwkJCQlpZiAoY2FsbGluZ19pdF9uZXh1cykKKwkJCQkJY29udGludWU7CisKKwkJCQlwcl9yZWdfbmFjbCA9IHByX3JlZy0+cHJfcmVnX25hY2w7CisJCQkJcHJfcmVzX21hcHBlZF9sdW4gPSBwcl9yZWctPnByX3Jlc19tYXBwZWRfbHVuOworCQkJCV9fY29yZV9zY3NpM19mcmVlX3JlZ2lzdHJhdGlvbihkZXYsIHByX3JlZywKKwkJCQkJKGFib3J0KSA/ICZwcmVlbXB0X2FuZF9hYm9ydF9saXN0IDoKKwkJCQkJCU5VTEwsIDApOworCQkJCXJlbGVhc2VkX3JlZ3MrKzsKKwkJCX0KKwkJCWlmICghKGNhbGxpbmdfaXRfbmV4dXMpKQorCQkJCWNvcmVfc2NzaTNfdWFfYWxsb2NhdGUocHJfcmVnX25hY2wsCisJCQkJCXByX3Jlc19tYXBwZWRfbHVuLCAweDJBLAorCQkJCQlBU0NRXzJBSF9SRVNFUlZBVElPTlNfUFJFRU1QVEVEKTsKKwkJfQorCQlzcGluX3VubG9jaygmcHJfdG1wbC0+cmVnaXN0cmF0aW9uX2xvY2spOworCQkvKgorCQkgKiBJZiBhIFBFUlNJU1RFTlQgUkVTRVJWRSBPVVQgd2l0aCBhIFBSRUVNUFQgc2VydmljZSBhY3Rpb24gb3IKKwkJICogYSBQUkVFTVBUIEFORCBBQk9SVCBzZXJ2aWNlIGFjdGlvbiBzZXRzIHRoZSBTRVJWSUNFIEFDVElPTgorCQkgKiBSRVNFUlZBVElPTiBLRVkgZmllbGQgdG8gYSB2YWx1ZSB0aGF0IGRvZXMgbm90IG1hdGNoIGFueQorCQkgKiByZWdpc3RlcmVkIHJlc2VydmF0aW9uIGtleSwgdGhlbiB0aGUgZGV2aWNlIHNlcnZlciBzaGFsbAorCQkgKiBjb21wbGV0ZSB0aGUgY29tbWFuZCB3aXRoIFJFU0VSVkFUSU9OIENPTkZMSUNUIHN0YXR1cy4KKwkJICovCisJCWlmICghKHJlbGVhc2VkX3JlZ3MpKSB7CisJCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnX24pOworCQkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfUkVTRVJWQVRJT05fQ09ORkxJQ1Q7CisJCX0KKwkJLyoKKwkJICogRm9yIGFuIGV4aXN0aW5nIGFsbCByZWdpc3RyYW50cyB0eXBlIHJlc2VydmF0aW9uCisJCSAqIHdpdGggYSB6ZXJvIFNBIHJzZXJ2YXRpb24ga2V5LCBwcmVlbXB0IHRoZSBleGlzdGluZworCQkgKiByZXNlcnZhdGlvbiB3aXRoIHRoZSBuZXcgUFIgdHlwZSBhbmQgc2NvcGUuCisJCSAqLworCQlpZiAocHJfcmVzX2hvbGRlciAmJiBhbGxfcmVnICYmICEoc2FfcmVzX2tleSkpIHsKKwkJCV9fY29yZV9zY3NpM19jb21wbGV0ZV9wcm9fcHJlZW1wdChkZXYsIHByX3JlZ19uLAorCQkJCShhYm9ydCkgPyAmcHJlZW1wdF9hbmRfYWJvcnRfbGlzdCA6IE5VTEwsCisJCQkJdHlwZSwgc2NvcGUsIGFib3J0KTsKKworCQkJaWYgKGFib3J0KQorCQkJCWNvcmVfc2NzaTNfcmVsZWFzZV9wcmVlbXB0X2FuZF9hYm9ydCgKKwkJCQkJJnByZWVtcHRfYW5kX2Fib3J0X2xpc3QsIHByX3JlZ19uKTsKKwkJfQorCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisKKwkJaWYgKHByX3RtcGwtPnByX2FwdHBsX2FjdGl2ZSkgeworCQkJcmV0ID0gY29yZV9zY3NpM191cGRhdGVfYW5kX3dyaXRlX2FwdHBsKFNFX0RFVihjbWQpLAorCQkJCQkmcHJfcmVnX24tPnByX2FwdHBsX2J1ZlswXSwKKwkJCQkJcHJfdG1wbC0+cHJfYXB0cGxfYnVmX2xlbik7CisJCQlpZiAoIShyZXQpKQorCQkJCXByaW50ayhLRVJOX0lORk8gIlNQQy0zIFBSOiBVcGRhdGVkIEFQVFBMIgorCQkJCQkiIG1ldGFkYXRhIGZvciAgUFJFRU1QVCVzXG4iLCAoYWJvcnQpID8KKwkJCQkJIl9BTkRfQUJPUlQiIDogIiIpOworCQl9CisKKwkJY29yZV9zY3NpM19wdXRfcHJfcmVnKHByX3JlZ19uKTsKKwkJY29yZV9zY3NpM19wcl9nZW5lcmF0aW9uKFNFX0RFVihjbWQpKTsKKwkJcmV0dXJuIDA7CisJfQorCS8qCisJICogVGhlIFBSRUVNUFRpbmcgU0EgcmVzZXJ2YXRpb24ga2V5IG1hdGNoZXMgdGhhdCBvZiB0aGUKKwkgKiBleGlzdGluZyBwZXJzaXN0ZW50IHJlc2VydmF0aW9uLCBmaXJzdCwgd2UgY2hlY2sgaWYKKwkgKiB3ZSBhcmUgcHJlZW1wdGluZyBvdXIgb3duIHJlc2VydmF0aW9uLgorCSAqIEZyb20gc3BjNHIxNywgc2VjdGlvbiA1LjcuMTEuNC4zIFByZWVtcHRpbmcKKwkgKiBwZXJzaXN0ZW50IHJlc2VydmF0aW9ucyBhbmQgcmVnaXN0cmF0aW9uIGhhbmRsaW5nCisJICoKKwkgKiBJZiBhbiBhbGwgcmVnaXN0cmFudHMgcGVyc2lzdGVudCByZXNlcnZhdGlvbiBpcyBub3QKKwkgKiBwcmVzZW50LCBpdCBpcyBub3QgYW4gZXJyb3IgZm9yIHRoZSBwZXJzaXN0ZW50CisJICogcmVzZXJ2YXRpb24gaG9sZGVyIHRvIHByZWVtcHQgaXRzZWxmIChpLmUuLCBhCisJICogUEVSU0lTVEVOVCBSRVNFUlZFIE9VVCB3aXRoIGEgUFJFRU1QVCBzZXJ2aWNlIGFjdGlvbgorCSAqIG9yIGEgUFJFRU1QVCBBTkQgQUJPUlQgc2VydmljZSBhY3Rpb24gd2l0aCB0aGUKKwkgKiBTRVJWSUNFIEFDVElPTiBSRVNFUlZBVElPTiBLRVkgdmFsdWUgZXF1YWwgdG8gdGhlCisJICogcGVyc2lzdGVudCByZXNlcnZhdGlvbiBob2xkZXIncyByZXNlcnZhdGlvbiBrZXkgdGhhdAorCSAqIGlzIHJlY2VpdmVkIGZyb20gdGhlIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gaG9sZGVyKS4KKwkgKiBJbiB0aGF0IGNhc2UsIHRoZSBkZXZpY2Ugc2VydmVyIHNoYWxsIGVzdGFibGlzaCB0aGUKKwkgKiBuZXcgcGVyc2lzdGVudCByZXNlcnZhdGlvbiBhbmQgbWFpbnRhaW4gdGhlCisJICogcmVnaXN0cmF0aW9uLgorCSAqLworCXByaF90eXBlID0gcHJfcmVzX2hvbGRlci0+cHJfcmVzX3R5cGU7CisJcHJoX3Njb3BlID0gcHJfcmVzX2hvbGRlci0+cHJfcmVzX3Njb3BlOworCS8qCisJICogSWYgdGhlIFNFUlZJQ0UgQUNUSU9OIFJFU0VSVkFUSU9OIEtFWSBmaWVsZCBpZGVudGlmaWVzIGEKKwkgKiBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIGhvbGRlciAoc2VlIDUuNy4xMCksIHRoZSBkZXZpY2UKKwkgKiBzZXJ2ZXIgc2hhbGwgcGVyZm9ybSBhIHByZWVtcHQgYnkgZG9pbmcgdGhlIGZvbGxvd2luZyBhcworCSAqIGFuIHVuaW50ZXJydXB0ZWQgc2VyaWVzIG9mIGFjdGlvbnM6CisJICoKKwkgKiBhKSBSZWxlYXNlIHRoZSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIGZvciB0aGUgaG9sZGVyCisJICogICAgaWRlbnRpZmllZCBieSB0aGUgU0VSVklDRSBBQ1RJT04gUkVTRVJWQVRJT04gS0VZIGZpZWxkOworCSAqLworCWlmIChwcl9yZWdfbiAhPSBwcl9yZXNfaG9sZGVyKQorCQlfX2NvcmVfc2NzaTNfY29tcGxldGVfcHJvX3JlbGVhc2UoZGV2LAorCQkJCXByX3Jlc19ob2xkZXItPnByX3JlZ19uYWNsLAorCQkJCWRldi0+ZGV2X3ByX3Jlc19ob2xkZXIsIDApOworCS8qCisJICogYikgUmVtb3ZlIHRoZSByZWdpc3RyYXRpb25zIGZvciBhbGwgSV9UIG5leHVzZXMgaWRlbnRpZmllZAorCSAqICAgIGJ5IHRoZSBTRVJWSUNFIEFDVElPTiBSRVNFUlZBVElPTiBLRVkgZmllbGQsIGV4Y2VwdCB0aGUKKwkgKiAgICBJX1QgbmV4dXMgdGhhdCBpcyBiZWluZyB1c2VkIGZvciB0aGUgUEVSU0lTVEVOVCBSRVNFUlZFCisJICogICAgT1VUIGNvbW1hbmQuIElmIGFuIGFsbCByZWdpc3RyYW50cyBwZXJzaXN0ZW50IHJlc2VydmF0aW9uCisJICogICAgaXMgcHJlc2VudCBhbmQgdGhlIFNFUlZJQ0UgQUNUSU9OIFJFU0VSVkFUSU9OIEtFWSBmaWVsZAorCSAqICAgIGlzIHNldCB0byB6ZXJvLCB0aGVuIGFsbCByZWdpc3RyYXRpb25zIHNoYWxsIGJlIHJlbW92ZWQKKwkgKiAgICBleGNlcHQgZm9yIHRoYXQgb2YgdGhlIElfVCBuZXh1cyB0aGF0IGlzIGJlaW5nIHVzZWQgZm9yCisJICogICAgdGhlIFBFUlNJU1RFTlQgUkVTRVJWRSBPVVQgY29tbWFuZDsKKwkgKi8KKwlzcGluX2xvY2soJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocHJfcmVnLCBwcl9yZWdfdG1wLAorCQkJJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9saXN0LCBwcl9yZWdfbGlzdCkgeworCisJCWNhbGxpbmdfaXRfbmV4dXMgPSAocHJfcmVnX24gPT0gcHJfcmVnKSA/IDEgOiAwOworCQlpZiAoY2FsbGluZ19pdF9uZXh1cykKKwkJCWNvbnRpbnVlOworCisJCWlmIChwcl9yZWctPnByX3Jlc19rZXkgIT0gc2FfcmVzX2tleSkKKwkJCWNvbnRpbnVlOworCisJCXByX3JlZ19uYWNsID0gcHJfcmVnLT5wcl9yZWdfbmFjbDsKKwkJcHJfcmVzX21hcHBlZF9sdW4gPSBwcl9yZWctPnByX3Jlc19tYXBwZWRfbHVuOworCQlfX2NvcmVfc2NzaTNfZnJlZV9yZWdpc3RyYXRpb24oZGV2LCBwcl9yZWcsCisJCQkJKGFib3J0KSA/ICZwcmVlbXB0X2FuZF9hYm9ydF9saXN0IDogTlVMTCwKKwkJCQljYWxsaW5nX2l0X25leHVzKTsKKwkJLyoKKwkJICogZSkgRXN0YWJsaXNoIGEgdW5pdCBhdHRlbnRpb24gY29uZGl0aW9uIGZvciB0aGUgaW5pdGlhdG9yCisJCSAqICAgIHBvcnQgYXNzb2NpYXRlZCB3aXRoIGV2ZXJ5IElfVCBuZXh1cyB0aGF0IGxvc3QgaXRzCisJCSAqICAgIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gYW5kL29yIHJlZ2lzdHJhdGlvbiwgd2l0aCB0aGUKKwkJICogICAgYWRkaXRpb25hbCBzZW5zZSBjb2RlIHNldCB0byBSRUdJU1RSQVRJT05TIFBSRUVNUFRFRDsKKwkJICovCisJCWNvcmVfc2NzaTNfdWFfYWxsb2NhdGUocHJfcmVnX25hY2wsIHByX3Jlc19tYXBwZWRfbHVuLCAweDJBLAorCQkJCUFTQ1FfMkFIX1JFU0VSVkFUSU9OU19QUkVFTVBURUQpOworCX0KKwlzcGluX3VubG9jaygmcHJfdG1wbC0+cmVnaXN0cmF0aW9uX2xvY2spOworCS8qCisJICogYykgRXN0YWJsaXNoIGEgcGVyc2lzdGVudCByZXNlcnZhdGlvbiBmb3IgdGhlIHByZWVtcHRpbmcKKwkgKiAgICBJX1QgbmV4dXMgdXNpbmcgdGhlIGNvbnRlbnRzIG9mIHRoZSBTQ09QRSBhbmQgVFlQRSBmaWVsZHM7CisJICovCisJX19jb3JlX3Njc2kzX2NvbXBsZXRlX3Byb19wcmVlbXB0KGRldiwgcHJfcmVnX24sCisJCQkoYWJvcnQpID8gJnByZWVtcHRfYW5kX2Fib3J0X2xpc3QgOiBOVUxMLAorCQkJdHlwZSwgc2NvcGUsIGFib3J0KTsKKwkvKgorCSAqIGQpIFByb2Nlc3MgdGFza3MgYXMgZGVmaW5lZCBpbiA1LjcuMTsKKwkgKiBlKSBTZWUgYWJvdmUuLgorCSAqIGYpIElmIHRoZSB0eXBlIG9yIHNjb3BlIGhhcyBjaGFuZ2VkLCB0aGVuIGZvciBldmVyeSBJX1QgbmV4dXMKKwkgKiAgICB3aG9zZSByZXNlcnZhdGlvbiBrZXkgd2FzIG5vdCByZW1vdmVkLCBleGNlcHQgZm9yIHRoZSBJX1QKKwkgKiAgICBuZXh1cyBvbiB3aGljaCB0aGUgUEVSU0lTVEVOVCBSRVNFUlZFIE9VVCBjb21tYW5kIHdhcworCSAqICAgIHJlY2VpdmVkLCB0aGUgZGV2aWNlIHNlcnZlciBzaGFsbCBlc3RhYmxpc2ggYSB1bml0CisJICogICAgYXR0ZW50aW9uIGNvbmRpdGlvbiBmb3IgdGhlIGluaXRpYXRvciBwb3J0IGFzc29jaWF0ZWQgd2l0aAorCSAqICAgIHRoYXQgSV9UIG5leHVzLCB3aXRoIHRoZSBhZGRpdGlvbmFsIHNlbnNlIGNvZGUgc2V0IHRvCisJICogICAgUkVTRVJWQVRJT05TIFJFTEVBU0VELiBJZiB0aGUgdHlwZSBvciBzY29wZSBoYXZlIG5vdAorCSAqICAgIGNoYW5nZWQsIHRoZW4gbm8gdW5pdCBhdHRlbnRpb24gY29uZGl0aW9uKHMpIHNoYWxsIGJlCisJICogICAgZXN0YWJsaXNoZWQgZm9yIHRoaXMgcmVhc29uLgorCSAqLworCWlmICgocHJoX3R5cGUgIT0gdHlwZSkgfHwgKHByaF9zY29wZSAhPSBzY29wZSkpIHsKKwkJc3Bpbl9sb2NrKCZwcl90bXBsLT5yZWdpc3RyYXRpb25fbG9jayk7CisJCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShwcl9yZWcsIHByX3JlZ190bXAsCisJCQkJJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9saXN0LCBwcl9yZWdfbGlzdCkgeworCisJCQljYWxsaW5nX2l0X25leHVzID0gKHByX3JlZ19uID09IHByX3JlZykgPyAxIDogMDsKKwkJCWlmIChjYWxsaW5nX2l0X25leHVzKQorCQkJCWNvbnRpbnVlOworCisJCQljb3JlX3Njc2kzX3VhX2FsbG9jYXRlKHByX3JlZy0+cHJfcmVnX25hY2wsCisJCQkJCXByX3JlZy0+cHJfcmVzX21hcHBlZF9sdW4sIDB4MkEsCisJCQkJCUFTQ1FfMkFIX1JFU0VSVkFUSU9OU19SRUxFQVNFRCk7CisJCX0KKwkJc3Bpbl91bmxvY2soJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9sb2NrKTsKKwl9CisJc3Bpbl91bmxvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCS8qCisJICogQ2FsbCBMVU5fUkVTRVQgbG9naWMgdXBvbiBsaXN0IG9mIHN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uLAorCSAqIEFsbCByZWNlaXZlZCBDREJzIGZvciB0aGUgbWF0Y2hpbmcgZXhpc3RpbmcgcmVzZXJ2YXRpb24gYW5kCisJICogcmVnaXN0cmF0aW9ucyB1bmRlcmdvIEFCT1JUX1RBU0sgbG9naWMuCisJICoKKwkgKiBGcm9tIHRoZXJlLCBjb3JlX3Njc2kzX3JlbGVhc2VfcHJlZW1wdF9hbmRfYWJvcnQoKSB3aWxsCisJICogcmVsZWFzZSBldmVyeSByZWdpc3RyYXRpb24gaW4gdGhlIGxpc3QgKHdoaWNoIGhhdmUgYWxyZWFkeQorCSAqIGJlZW4gcmVtb3ZlZCBmcm9tIHRoZSBwcmltYXJ5IHByX3JlZyBsaXN0KSwgZXhjZXB0IHRoZQorCSAqIG5ldyBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIGhvbGRlciwgdGhlIGNhbGxpbmcgSW5pdGlhdG9yIFBvcnQuCisJICovCisJaWYgKGFib3J0KSB7CisJCWNvcmVfdG1yX2x1bl9yZXNldChkZXYsIE5VTEwsICZwcmVlbXB0X2FuZF9hYm9ydF9saXN0LCBjbWQpOworCQljb3JlX3Njc2kzX3JlbGVhc2VfcHJlZW1wdF9hbmRfYWJvcnQoJnByZWVtcHRfYW5kX2Fib3J0X2xpc3QsCisJCQkJCQlwcl9yZWdfbik7CisJfQorCisJaWYgKHByX3RtcGwtPnByX2FwdHBsX2FjdGl2ZSkgeworCQlyZXQgPSBjb3JlX3Njc2kzX3VwZGF0ZV9hbmRfd3JpdGVfYXB0cGwoU0VfREVWKGNtZCksCisJCQkJJnByX3JlZ19uLT5wcl9hcHRwbF9idWZbMF0sCisJCQkJcHJfdG1wbC0+cHJfYXB0cGxfYnVmX2xlbik7CisJCWlmICghKHJldCkpCisJCQlwcmludGsoIlNQQy0zIFBSOiBVcGRhdGVkIEFQVFBMIG1ldGFkYXRhIGZvciBQUkVFTVBUIgorCQkJCSIlc1xuIiwgKGFib3J0KSA/ICJfQU5EX0FCT1JUIiA6ICIiKTsKKwl9CisKKwljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnX24pOworCWNvcmVfc2NzaTNfcHJfZ2VuZXJhdGlvbihTRV9ERVYoY21kKSk7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgY29yZV9zY3NpM19lbXVsYXRlX3Byb19wcmVlbXB0KAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwlpbnQgdHlwZSwKKwlpbnQgc2NvcGUsCisJdTY0IHJlc19rZXksCisJdTY0IHNhX3Jlc19rZXksCisJaW50IGFib3J0KQoreworCWludCByZXQgPSAwOworCisJc3dpdGNoICh0eXBlKSB7CisJY2FzZSBQUl9UWVBFX1dSSVRFX0VYQ0xVU0lWRToKKwljYXNlIFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTUzoKKwljYXNlIFBSX1RZUEVfV1JJVEVfRVhDTFVTSVZFX1JFR09OTFk6CisJY2FzZSBQUl9UWVBFX0VYQ0xVU0lWRV9BQ0NFU1NfUkVHT05MWToKKwljYXNlIFBSX1RZUEVfV1JJVEVfRVhDTFVTSVZFX0FMTFJFRzoKKwljYXNlIFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTU19BTExSRUc6CisJCXJldCA9IGNvcmVfc2NzaTNfcHJvX3ByZWVtcHQoY21kLCB0eXBlLCBzY29wZSwKKwkJCQlyZXNfa2V5LCBzYV9yZXNfa2V5LCBhYm9ydCk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFI6IFVua25vd24gU2VydmljZSBBY3Rpb24gUFJFRU1QVCVzIgorCQkJIiBUeXBlOiAweCUwMnhcbiIsIChhYm9ydCkgPyAiX0FORF9BQk9SVCIgOiAiIiwgdHlwZSk7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0lOVkFMSURfQ0RCX0ZJRUxEOworCX0KKworCXJldHVybiByZXQ7Cit9CisKKworc3RhdGljIGludCBjb3JlX3Njc2kzX2VtdWxhdGVfcHJvX3JlZ2lzdGVyX2FuZF9tb3ZlKAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwl1NjQgcmVzX2tleSwKKwl1NjQgc2FfcmVzX2tleSwKKwlpbnQgYXB0cGwsCisJaW50IHVucmVnKQoreworCXN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzID0gU0VfU0VTUyhjbWQpOworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IFNFX0RFVihjbWQpOworCXN0cnVjdCBzZV9kZXZfZW50cnkgKnNlX2RldmUsICpkZXN0X3NlX2RldmUgPSBOVUxMOworCXN0cnVjdCBzZV9sdW4gKnNlX2x1biA9IFNFX0xVTihjbWQpOworCXN0cnVjdCBzZV9ub2RlX2FjbCAqcHJfcmVzX25hY2wsICpwcl9yZWdfbmFjbCwgKmRlc3Rfbm9kZV9hY2wgPSBOVUxMOworCXN0cnVjdCBzZV9wb3J0ICpzZV9wb3J0OworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZywgKmRlc3Rfc2VfdHBnID0gTlVMTDsKKwlzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcyAqZGVzdF90Zl9vcHMgPSBOVUxMLCAqdGZfb3BzOworCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsICpwcl9yZXNfaG9sZGVyLCAqZGVzdF9wcl9yZWc7CisJc3RydWN0IHQxMF9yZXNlcnZhdGlvbl90ZW1wbGF0ZSAqcHJfdG1wbCA9ICZTVV9ERVYoZGV2KS0+dDEwX3Jlc2VydmF0aW9uOworCXVuc2lnbmVkIGNoYXIgKmJ1ZiA9ICh1bnNpZ25lZCBjaGFyICopVF9UQVNLKGNtZCktPnRfdGFza19idWY7CisJdW5zaWduZWQgY2hhciAqaW5pdGlhdG9yX3N0cjsKKwljaGFyICppcG9ydF9wdHIgPSBOVUxMLCBkZXN0X2lwb3J0WzY0XSwgaV9idWZbUFJfUkVHX0lTSURfSURfTEVOXTsKKwl1MzIgdGlkX2xlbiwgdG1wX3RpZF9sZW47CisJaW50IG5ld19yZWcgPSAwLCB0eXBlLCBzY29wZSwgcmV0LCBtYXRjaGluZ19pbmFtZSwgcHJmX2lzaWQ7CisJdW5zaWduZWQgc2hvcnQgcnRwaTsKKwl1bnNpZ25lZCBjaGFyIHByb3RvX2lkZW50OworCisJaWYgKCEoc2Vfc2VzcykgfHwgIShzZV9sdW4pKSB7CisJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFI6IHNlX3Nlc3MgfHwgc3RydWN0IHNlX2x1biBpcyBOVUxMIVxuIik7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwl9CisJbWVtc2V0KGRlc3RfaXBvcnQsIDAsIDY0KTsKKwltZW1zZXQoaV9idWYsIDAsIFBSX1JFR19JU0lEX0lEX0xFTik7CisJc2VfdHBnID0gc2Vfc2Vzcy0+c2VfdHBnOworCXRmX29wcyA9IFRQR19URk8oc2VfdHBnKTsKKwlzZV9kZXZlID0gJnNlX3Nlc3MtPnNlX25vZGVfYWNsLT5kZXZpY2VfbGlzdFtjbWQtPm9yaWdfZmVfbHVuXTsKKwkvKgorCSAqIEZvbGxvdyBsb2dpYyBmcm9tIHNwYzRyMTcgU2VjdGlvbiA1LjcuOCwgVGFibGUgNTAgLS0KKwkgKglSZWdpc3RlciBiZWhhdmlvcnMgZm9yIGEgUkVHSVNURVIgQU5EIE1PVkUgc2VydmljZSBhY3Rpb24KKwkgKgorCSAqIExvY2F0ZSB0aGUgZXhpc3RpbmcgKnByX3JlZyB2aWEgc3RydWN0IHNlX25vZGVfYWNsIHBvaW50ZXJzCisJICovCisJcHJfcmVnID0gY29yZV9zY3NpM19sb2NhdGVfcHJfcmVnKFNFX0RFVihjbWQpLCBzZV9zZXNzLT5zZV9ub2RlX2FjbCwKKwkJCQlzZV9zZXNzKTsKKwlpZiAoIShwcl9yZWcpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFI6IFVuYWJsZSB0byBsb2NhdGUgUFJfUkVHSVNURVJFRCIKKwkJCSIgKnByX3JlZyBmb3IgUkVHSVNURVJfQU5EX01PVkVcbiIpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9MVV9DT01NX0ZBSUxVUkU7CisJfQorCS8qCisJICogVGhlIHByb3ZpZGVkIHJlc2VydmF0aW9uIGtleSBtdWNoIG1hdGNoIHRoZSBleGlzdGluZyByZXNlcnZhdGlvbiBrZXkKKwkgKiBwcm92aWRlZCBkdXJpbmcgdGhpcyBpbml0aWF0b3IncyBJX1QgbmV4dXMgcmVnaXN0cmF0aW9uLgorCSAqLworCWlmIChyZXNfa2V5ICE9IHByX3JlZy0+cHJfcmVzX2tleSkgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJTUEMtMyBQUiBSRUdJU1RFUl9BTkRfTU9WRTogUmVjZWl2ZWQiCisJCQkiIHJlc19rZXk6IDB4JTAxNkx4IGRvZXMgbm90IG1hdGNoIGV4aXN0aW5nIFNBIFJFR0lTVEVSIgorCQkJIiByZXNfa2V5OiAweCUwMTZMeFxuIiwgcmVzX2tleSwgcHJfcmVnLT5wcl9yZXNfa2V5KTsKKwkJY29yZV9zY3NpM19wdXRfcHJfcmVnKHByX3JlZyk7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX1JFU0VSVkFUSU9OX0NPTkZMSUNUOworCX0KKwkvKgorCSAqIFRoZSBzZXJ2aWNlIGFjdGl2ZSByZXNlcnZhdGlvbiBrZXkgbmVlZHMgdG8gYmUgbm9uIHplcm8KKwkgKi8KKwlpZiAoIShzYV9yZXNfa2V5KSkgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJTUEMtMyBQUiBSRUdJU1RFUl9BTkRfTU9WRTogUmVjZWl2ZWQgemVybyIKKwkJCSIgc2FfcmVzX2tleVxuIik7CisJCWNvcmVfc2NzaTNfcHV0X3ByX3JlZyhwcl9yZWcpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCX0KKwkvKgorCSAqIERldGVybWluZSB0aGUgUmVsYXRpdmUgVGFyZ2V0IFBvcnQgSWRlbnRpZmllciB3aGVyZSB0aGUgcmVzZXJ2YXRpb24KKwkgKiB3aWxsIGJlIG1vdmVkIHRvIGZvciB0aGUgVHJhbnNwb3J0SUQgY29udGFpbmluZyBTQ1NJIGluaXRpYXRvciBXV04KKwkgKiBpbmZvcm1hdGlvbi4KKwkgKi8KKwlydHBpID0gKGJ1ZlsxOF0gJiAweGZmKSA8PCA4OworCXJ0cGkgfD0gYnVmWzE5XSAmIDB4ZmY7CisJdGlkX2xlbiA9IChidWZbMjBdICYgMHhmZikgPDwgMjQ7CisJdGlkX2xlbiB8PSAoYnVmWzIxXSAmIDB4ZmYpIDw8IDE2OworCXRpZF9sZW4gfD0gKGJ1ZlsyMl0gJiAweGZmKSA8PCA4OworCXRpZF9sZW4gfD0gYnVmWzIzXSAmIDB4ZmY7CisKKwlpZiAoKHRpZF9sZW4gKyAyNCkgIT0gY21kLT5kYXRhX2xlbmd0aCkgeworCQlwcmludGsoS0VSTl9FUlIgIlNQQy0zIFBSOiBJbGxlZ2FsIHRpZF9sZW46ICV1ICsgMjQgYnl0ZSBoZWFkZXIiCisJCQkiIGRvZXMgbm90IGVxdWFsIENEQiBkYXRhX2xlbmd0aDogJXVcbiIsIHRpZF9sZW4sCisJCQljbWQtPmRhdGFfbGVuZ3RoKTsKKwkJY29yZV9zY3NpM19wdXRfcHJfcmVnKHByX3JlZyk7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0lOVkFMSURfUEFSQU1FVEVSX0xJU1Q7CisJfQorCisJc3Bpbl9sb2NrKCZkZXYtPnNlX3BvcnRfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShzZV9wb3J0LCAmZGV2LT5kZXZfc2VwX2xpc3QsIHNlcF9saXN0KSB7CisJCWlmIChzZV9wb3J0LT5zZXBfcnRwaSAhPSBydHBpKQorCQkJY29udGludWU7CisJCWRlc3Rfc2VfdHBnID0gc2VfcG9ydC0+c2VwX3RwZzsKKwkJaWYgKCEoZGVzdF9zZV90cGcpKQorCQkJY29udGludWU7CisJCWRlc3RfdGZfb3BzID0gVFBHX1RGTyhkZXN0X3NlX3RwZyk7CisJCWlmICghKGRlc3RfdGZfb3BzKSkKKwkJCWNvbnRpbnVlOworCisJCWF0b21pY19pbmMoJmRlc3Rfc2VfdHBnLT50cGdfcHJfcmVmX2NvdW50KTsKKwkJc21wX21iX19hZnRlcl9hdG9taWNfaW5jKCk7CisJCXNwaW5fdW5sb2NrKCZkZXYtPnNlX3BvcnRfbG9jayk7CisKKwkJcmV0ID0gY29yZV9zY3NpM190cGdfZGVwZW5kX2l0ZW0oZGVzdF9zZV90cGcpOworCQlpZiAocmV0ICE9IDApIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiY29yZV9zY3NpM190cGdfZGVwZW5kX2l0ZW0oKSBmYWlsZWQiCisJCQkJIiBmb3IgZGVzdF9zZV90cGdcbiIpOworCQkJYXRvbWljX2RlYygmZGVzdF9zZV90cGctPnRwZ19wcl9yZWZfY291bnQpOworCQkJc21wX21iX19hZnRlcl9hdG9taWNfZGVjKCk7CisJCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnKTsKKwkJCXJldHVybiBQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwkJfQorCisJCXNwaW5fbG9jaygmZGV2LT5zZV9wb3J0X2xvY2spOworCQlicmVhazsKKwl9CisJc3Bpbl91bmxvY2soJmRldi0+c2VfcG9ydF9sb2NrKTsKKworCWlmICghKGRlc3Rfc2VfdHBnKSB8fCAoIWRlc3RfdGZfb3BzKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlNQQy0zIFBSIFJFR0lTVEVSX0FORF9NT1ZFOiBVbmFibGUgdG8gbG9jYXRlIgorCQkJIiBmYWJyaWMgb3BzIGZyb20gUmVsYXRpdmUgVGFyZ2V0IFBvcnQgSWRlbnRpZmllcjoiCisJCQkiICVodVxuIiwgcnRwaSk7CisJCWNvcmVfc2NzaTNfcHV0X3ByX3JlZyhwcl9yZWcpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCX0KKwlwcm90b19pZGVudCA9IChidWZbMjRdICYgMHgwZik7CisjaWYgMAorCXByaW50aygiU1BDLTMgUFIgUkVHSVNURVJfQU5EX01PVkU6IEV4dHJhY3RlZCBQcm90b2NvbCBJZGVudGlmaWVyOiIKKwkJCSIgMHglMDJ4XG4iLCBwcm90b19pZGVudCk7CisjZW5kaWYKKwlpZiAocHJvdG9faWRlbnQgIT0gZGVzdF90Zl9vcHMtPmdldF9mYWJyaWNfcHJvdG9faWRlbnQoZGVzdF9zZV90cGcpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiU1BDLTMgUFIgUkVHSVNURVJfQU5EX01PVkU6IFJlY2VpdmVkIgorCQkJIiBwcm90b19pZGVudDogMHglMDJ4IGRvZXMgbm90IG1hdGNoIGlkZW50OiAweCUwMngiCisJCQkiIGZyb20gZmFicmljOiAlc1xuIiwgcHJvdG9faWRlbnQsCisJCQlkZXN0X3RmX29wcy0+Z2V0X2ZhYnJpY19wcm90b19pZGVudChkZXN0X3NlX3RwZyksCisJCQlkZXN0X3RmX29wcy0+Z2V0X2ZhYnJpY19uYW1lKCkpOworCQlyZXQgPSBQWVhfVFJBTlNQT1JUX0lOVkFMSURfUEFSQU1FVEVSX0xJU1Q7CisJCWdvdG8gb3V0OworCX0KKwlpZiAoZGVzdF90Zl9vcHMtPnRwZ19wYXJzZV9wcl9vdXRfdHJhbnNwb3J0X2lkID09IE5VTEwpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJTUEMtMyBQUiBSRUdJU1RFUl9BTkRfTU9WRTogRmFicmljIGRvZXMgbm90IgorCQkJIiBjb250YWluZyBhIHZhbGlkIHRwZ19wYXJzZV9wcl9vdXRfdHJhbnNwb3J0X2lkIgorCQkJIiBmdW5jdGlvbiBwb2ludGVyXG4iKTsKKwkJcmV0ID0gUFlYX1RSQU5TUE9SVF9MVV9DT01NX0ZBSUxVUkU7CisJCWdvdG8gb3V0OworCX0KKwlpbml0aWF0b3Jfc3RyID0gZGVzdF90Zl9vcHMtPnRwZ19wYXJzZV9wcl9vdXRfdHJhbnNwb3J0X2lkKGRlc3Rfc2VfdHBnLAorCQkJKGNvbnN0IGNoYXIgKikmYnVmWzI0XSwgJnRtcF90aWRfbGVuLCAmaXBvcnRfcHRyKTsKKwlpZiAoIShpbml0aWF0b3Jfc3RyKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlNQQy0zIFBSIFJFR0lTVEVSX0FORF9NT1ZFOiBVbmFibGUgdG8gbG9jYXRlIgorCQkJIiBpbml0aWF0b3Jfc3RyIGZyb20gVHJhbnNwb3J0IElEXG4iKTsKKwkJcmV0ID0gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCQlnb3RvIG91dDsKKwl9CisKKwlwcmludGsoS0VSTl9JTkZPICJTUEMtMyBQUiBbJXNdIEV4dHJhY3RlZCBpbml0aWF0b3IgJXMgaWRlbnRpZmllcjogJXMiCisJCSIgJXNcbiIsIGRlc3RfdGZfb3BzLT5nZXRfZmFicmljX25hbWUoKSwgKGlwb3J0X3B0ciAhPSBOVUxMKSA/CisJCSJwb3J0IiA6ICJkZXZpY2UiLCBpbml0aWF0b3Jfc3RyLCAoaXBvcnRfcHRyICE9IE5VTEwpID8KKwkJaXBvcnRfcHRyIDogIiIpOworCS8qCisJICogSWYgYSBQRVJTSVNURU5UIFJFU0VSVkUgT1VUIGNvbW1hbmQgd2l0aCBhIFJFR0lTVEVSIEFORCBNT1ZFIHNlcnZpY2UKKwkgKiBhY3Rpb24gc3BlY2lmaWVzIGEgVHJhbnNwb3J0SUQgdGhhdCBpcyB0aGUgc2FtZSBhcyB0aGUgaW5pdGlhdG9yIHBvcnQKKwkgKiBvZiB0aGUgSV9UIG5leHVzIGZvciB0aGUgY29tbWFuZCByZWNlaXZlZCwgdGhlbiB0aGUgY29tbWFuZCBzaGFsbAorCSAqIGJlIHRlcm1pbmF0ZWQgd2l0aCBDSEVDSyBDT05ESVRJT04gc3RhdHVzLCB3aXRoIHRoZSBzZW5zZSBrZXkgc2V0IHRvCisJICogSUxMRUdBTCBSRVFVRVNULCBhbmQgdGhlIGFkZGl0aW9uYWwgc2Vuc2UgY29kZSBzZXQgdG8gSU5WQUxJRCBGSUVMRAorCSAqIElOIFBBUkFNRVRFUiBMSVNULgorCSAqLworCXByX3JlZ19uYWNsID0gcHJfcmVnLT5wcl9yZWdfbmFjbDsKKwltYXRjaGluZ19pbmFtZSA9ICghc3RyY21wKGluaXRpYXRvcl9zdHIsCisJCQkJICBwcl9yZWdfbmFjbC0+aW5pdGlhdG9ybmFtZSkpID8gMSA6IDA7CisJaWYgKCEobWF0Y2hpbmdfaW5hbWUpKQorCQlnb3RvIGFmdGVyX2lwb3J0X2NoZWNrOworCisJaWYgKCEoaXBvcnRfcHRyKSB8fCAhKHByX3JlZy0+aXNpZF9wcmVzZW50X2F0X3JlZykpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJTUEMtMyBQUiBSRUdJU1RFUl9BTkRfTU9WRTogVHJhbnNwb3J0SUQ6ICVzIgorCQkJIiBtYXRjaGVzOiAlcyBvbiByZWNlaXZlZCBJX1QgTmV4dXNcbiIsIGluaXRpYXRvcl9zdHIsCisJCQlwcl9yZWdfbmFjbC0+aW5pdGlhdG9ybmFtZSk7CisJCXJldCA9IFBZWF9UUkFOU1BPUlRfSU5WQUxJRF9QQVJBTUVURVJfTElTVDsKKwkJZ290byBvdXQ7CisJfQorCWlmICghKHN0cmNtcChpcG9ydF9wdHIsIHByX3JlZy0+cHJfcmVnX2lzaWQpKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlNQQy0zIFBSIFJFR0lTVEVSX0FORF9NT1ZFOiBUcmFuc3BvcnRJRDogJXMgJXMiCisJCQkiIG1hdGNoZXM6ICVzICVzIG9uIHJlY2VpdmVkIElfVCBOZXh1c1xuIiwKKwkJCWluaXRpYXRvcl9zdHIsIGlwb3J0X3B0ciwgcHJfcmVnX25hY2wtPmluaXRpYXRvcm5hbWUsCisJCQlwcl9yZWctPnByX3JlZ19pc2lkKTsKKwkJcmV0ID0gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCQlnb3RvIG91dDsKKwl9CithZnRlcl9pcG9ydF9jaGVjazoKKwkvKgorCSAqIExvY2F0ZSB0aGUgZGVzdGluYXRpb24gc3RydWN0IHNlX25vZGVfYWNsIGZyb20gdGhlIHJlY2VpdmVkIFRyYW5zcG9ydCBJRAorCSAqLworCXNwaW5fbG9ja19iaCgmZGVzdF9zZV90cGctPmFjbF9ub2RlX2xvY2spOworCWRlc3Rfbm9kZV9hY2wgPSBfX2NvcmVfdHBnX2dldF9pbml0aWF0b3Jfbm9kZV9hY2woZGVzdF9zZV90cGcsCisJCQkJaW5pdGlhdG9yX3N0cik7CisJaWYgKGRlc3Rfbm9kZV9hY2wpIHsKKwkJYXRvbWljX2luYygmZGVzdF9ub2RlX2FjbC0+YWNsX3ByX3JlZl9jb3VudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2luYygpOworCX0KKwlzcGluX3VubG9ja19iaCgmZGVzdF9zZV90cGctPmFjbF9ub2RlX2xvY2spOworCisJaWYgKCEoZGVzdF9ub2RlX2FjbCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gbG9jYXRlICVzIGRlc3Rfbm9kZV9hY2wgZm9yIgorCQkJIiBUcmFuc3BvcnRJRCVzXG4iLCBkZXN0X3RmX29wcy0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCQlpbml0aWF0b3Jfc3RyKTsKKwkJcmV0ID0gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCQlnb3RvIG91dDsKKwl9CisJcmV0ID0gY29yZV9zY3NpM19ub2RlYWNsX2RlcGVuZF9pdGVtKGRlc3Rfbm9kZV9hY2wpOworCWlmIChyZXQgIT0gMCkgeworCQlwcmludGsoS0VSTl9FUlIgImNvcmVfc2NzaTNfbm9kZWFjbF9kZXBlbmRfaXRlbSgpIGZvciIKKwkJCSIgZGVzdF9ub2RlX2FjbFxuIik7CisJCWF0b21pY19kZWMoJmRlc3Rfbm9kZV9hY2wtPmFjbF9wcl9yZWZfY291bnQpOworCQlzbXBfbWJfX2FmdGVyX2F0b21pY19kZWMoKTsKKwkJZGVzdF9ub2RlX2FjbCA9IE5VTEw7CisJCXJldCA9IFBZWF9UUkFOU1BPUlRfTFVfQ09NTV9GQUlMVVJFOworCQlnb3RvIG91dDsKKwl9CisjaWYgMAorCXByaW50ayhLRVJOX0lORk8gIlNQQy0zIFBSIFJFR0lTVEVSX0FORF9NT1ZFOiBGb3VuZCAlcyBkZXN0X25vZGVfYWNsOiIKKwkJIiAlcyBmcm9tIFRyYW5zcG9ydElEXG4iLCBkZXN0X3RmX29wcy0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCWRlc3Rfbm9kZV9hY2wtPmluaXRpYXRvcm5hbWUpOworI2VuZGlmCisJLyoKKwkgKiBMb2NhdGUgdGhlIHN0cnVjdCBzZV9kZXZfZW50cnkgcG9pbnRlciBmb3IgdGhlIG1hdGNoaW5nIFJFTEFUSVZFIFRBUkdFVAorCSAqIFBPUlQgSURFTlRJRklFUi4KKwkgKi8KKwlkZXN0X3NlX2RldmUgPSBjb3JlX2dldF9zZV9kZXZlX2Zyb21fcnRwaShkZXN0X25vZGVfYWNsLCBydHBpKTsKKwlpZiAoIShkZXN0X3NlX2RldmUpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGxvY2F0ZSAlcyBkZXN0X3NlX2RldmUgZnJvbSBSVFBJOiIKKwkJCSIgJWh1XG4iLCAgZGVzdF90Zl9vcHMtPmdldF9mYWJyaWNfbmFtZSgpLCBydHBpKTsKKwkJcmV0ID0gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCQlnb3RvIG91dDsKKwl9CisKKwlyZXQgPSBjb3JlX3Njc2kzX2x1bmFjbF9kZXBlbmRfaXRlbShkZXN0X3NlX2RldmUpOworCWlmIChyZXQgPCAwKSB7CisJCXByaW50ayhLRVJOX0VSUiAiY29yZV9zY3NpM19sdW5hY2xfZGVwZW5kX2l0ZW0oKSBmYWlsZWRcbiIpOworCQlhdG9taWNfZGVjKCZkZXN0X3NlX2RldmUtPnByX3JlZl9jb3VudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworCQlkZXN0X3NlX2RldmUgPSBOVUxMOworCQlyZXQgPSBQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwkJZ290byBvdXQ7CisJfQorI2lmIDAKKwlwcmludGsoS0VSTl9JTkZPICJTUEMtMyBQUiBSRUdJU1RFUl9BTkRfTU9WRTogTG9jYXRlZCAlcyBub2RlICVzIExVTiIKKwkJIiBBQ0wgZm9yIGRlc3Rfc2VfZGV2ZS0+bWFwcGVkX2x1bjogJXVcbiIsCisJCWRlc3RfdGZfb3BzLT5nZXRfZmFicmljX25hbWUoKSwgZGVzdF9ub2RlX2FjbC0+aW5pdGlhdG9ybmFtZSwKKwkJZGVzdF9zZV9kZXZlLT5tYXBwZWRfbHVuKTsKKyNlbmRpZgorCS8qCisJICogQSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIG5lZWRzIHRvIGFscmVhZHkgZXhpc3RpbmcgaW4gb3JkZXIgdG8KKwkgKiBzdWNjZXNzZnVsbHkgY29tcGxldGUgdGhlIFJFR0lTVEVSX0FORF9NT1ZFIHNlcnZpY2UgYWN0aW9uLi4KKwkgKi8KKwlzcGluX2xvY2soJmRldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCXByX3Jlc19ob2xkZXIgPSBkZXYtPmRldl9wcl9yZXNfaG9sZGVyOworCWlmICghKHByX3Jlc19ob2xkZXIpKSB7CisJCXByaW50ayhLRVJOX1dBUk5JTkcgIlNQQy0zIFBSIFJFR0lTVEVSX0FORF9NT1ZFOiBObyByZXNlcnZhdGlvbiIKKwkJCSIgY3VycmVudGx5IGhlbGRcbiIpOworCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCXJldCA9IFBZWF9UUkFOU1BPUlRfSU5WQUxJRF9DREJfRklFTEQ7CisJCWdvdG8gb3V0OworCX0KKwkvKgorCSAqIFRoZSByZWNlaXZlZCBvbiBJX1QgTmV4dXMgbXVzdCBiZSB0aGUgcmVzZXJ2YXRpb24gaG9sZGVyLgorCSAqCisJICogRnJvbSBzcGM0cjE3IHNlY3Rpb24gNS43LjggIFRhYmxlIDUwIC0tCisJICogCVJlZ2lzdGVyIGJlaGF2aW9ycyBmb3IgYSBSRUdJU1RFUiBBTkQgTU9WRSBzZXJ2aWNlIGFjdGlvbgorCSAqLworCWlmIChwcl9yZXNfaG9sZGVyICE9IHByX3JlZykgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJTUEMtMyBQUiBSRUdJU1RFUl9BTkRfTU9WRTogQ2FsbGluZyBJX1QiCisJCQkiIE5leHVzIGlzIG5vdCByZXNlcnZhdGlvbiBob2xkZXJcbiIpOworCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCXJldCA9IFBZWF9UUkFOU1BPUlRfUkVTRVJWQVRJT05fQ09ORkxJQ1Q7CisJCWdvdG8gb3V0OworCX0KKwkvKgorCSAqIEZyb20gc3BjNHIxNyBzZWN0aW9uIDUuNy44OiByZWdpc3RlcmluZyBhbmQgbW92aW5nIHJlc2VydmF0aW9uCisJICoKKwkgKiBJZiBhIFBFUlNJU1RFTlQgUkVTRVJWRSBPVVQgY29tbWFuZCB3aXRoIGEgUkVHSVNURVIgQU5EIE1PVkUgc2VydmljZQorCSAqIGFjdGlvbiBpcyByZWNlaXZlZCBhbmQgdGhlIGVzdGFibGlzaGVkIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gaXMgYQorCSAqIFdyaXRlIEV4Y2x1c2l2ZSAtIEFsbCBSZWdpc3RyYW50cyB0eXBlIG9yIEV4Y2x1c2l2ZSBBY2Nlc3MgLQorCSAqIEFsbCBSZWdpc3RyYW50cyB0eXBlIHJlc2VydmF0aW9uLCB0aGVuIHRoZSBjb21tYW5kIHNoYWxsIGJlIGNvbXBsZXRlZAorCSAqIHdpdGggUkVTRVJWQVRJT04gQ09ORkxJQ1Qgc3RhdHVzLgorCSAqLworCWlmICgocHJfcmVzX2hvbGRlci0+cHJfcmVzX3R5cGUgPT0gUFJfVFlQRV9XUklURV9FWENMVVNJVkVfQUxMUkVHKSB8fAorCSAgICAocHJfcmVzX2hvbGRlci0+cHJfcmVzX3R5cGUgPT0gUFJfVFlQRV9FWENMVVNJVkVfQUNDRVNTX0FMTFJFRykpIHsKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAiU1BDLTMgUFIgUkVHSVNURVJfQU5EX01PVkU6IFVuYWJsZSB0byBtb3ZlIgorCQkJIiByZXNlcnZhdGlvbiBmb3IgdHlwZTogJXNcbiIsCisJCQljb3JlX3Njc2kzX3ByX2R1bXBfdHlwZShwcl9yZXNfaG9sZGVyLT5wcl9yZXNfdHlwZSkpOworCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCXJldCA9IFBZWF9UUkFOU1BPUlRfUkVTRVJWQVRJT05fQ09ORkxJQ1Q7CisJCWdvdG8gb3V0OworCX0KKwlwcl9yZXNfbmFjbCA9IHByX3Jlc19ob2xkZXItPnByX3JlZ19uYWNsOworCS8qCisJICogYikgSWdub3JlIHRoZSBjb250ZW50cyBvZiB0aGUgKHJlY2VpdmVkKSBTQ09QRSBhbmQgVFlQRSBmaWVsZHM7CisJICovCisJdHlwZSA9IHByX3Jlc19ob2xkZXItPnByX3Jlc190eXBlOworCXNjb3BlID0gcHJfcmVzX2hvbGRlci0+cHJfcmVzX3R5cGU7CisJLyoKKwkgKiBjKSBBc3NvY2lhdGUgdGhlIHJlc2VydmF0aW9uIGtleSBzcGVjaWZpZWQgaW4gdGhlIFNFUlZJQ0UgQUNUSU9OCisJICogICAgUkVTRVJWQVRJT04gS0VZIGZpZWxkIHdpdGggdGhlIElfVCBuZXh1cyBzcGVjaWZpZWQgYXMgdGhlCisJICogICAgZGVzdGluYXRpb24gb2YgdGhlIHJlZ2lzdGVyIGFuZCBtb3ZlLCB3aGVyZToKKwkgKiAgICBBKSBUaGUgSV9UIG5leHVzIGlzIHNwZWNpZmllZCBieSB0aGUgVHJhbnNwb3J0SUQgYW5kIHRoZQorCSAqCSBSRUxBVElWRSBUQVJHRVQgUE9SVCBJREVOVElGSUVSIGZpZWxkIChzZWUgNi4xNC40KTsgYW5kCisJICogICAgQikgUmVnYXJkbGVzcyBvZiB0aGUgVHJhbnNwb3J0SUQgZm9ybWF0IHVzZWQsIHRoZSBhc3NvY2lhdGlvbiBmb3IKKwkgKiAgICAgICB0aGUgaW5pdGlhdG9yIHBvcnQgaXMgYmFzZWQgb24gZWl0aGVyIHRoZSBpbml0aWF0b3IgcG9ydCBuYW1lCisJICogICAgICAgKHNlZSAzLjEuNzEpIG9uIFNDU0kgdHJhbnNwb3J0IHByb3RvY29scyB3aGVyZSBwb3J0IG5hbWVzIGFyZQorCSAqICAgICAgIHJlcXVpcmVkIG9yIHRoZSBpbml0aWF0b3IgcG9ydCBpZGVudGlmaWVyIChzZWUgMy4xLjcwKSBvbiBTQ1NJCisJICogICAgICAgdHJhbnNwb3J0IHByb3RvY29scyB3aGVyZSBwb3J0IG5hbWVzIGFyZSBub3QgcmVxdWlyZWQ7CisJICogZCkgUmVnaXN0ZXIgdGhlIHJlc2VydmF0aW9uIGtleSBzcGVjaWZpZWQgaW4gdGhlIFNFUlZJQ0UgQUNUSU9OCisJICogICAgUkVTRVJWQVRJT04gS0VZIGZpZWxkOworCSAqIGUpIFJldGFpbiB0aGUgcmVzZXJ2YXRpb24ga2V5IHNwZWNpZmllZCBpbiB0aGUgU0VSVklDRSBBQ1RJT04KKwkgKiAgICBSRVNFUlZBVElPTiBLRVkgZmllbGQgYW5kIGFzc29jaWF0ZWQgaW5mb3JtYXRpb247CisJICoKKwkgKiBBbHNvLCBJdCBpcyBub3QgYW4gZXJyb3IgZm9yIGEgUkVHSVNURVIgQU5EIE1PVkUgc2VydmljZSBhY3Rpb24gdG8KKwkgKiByZWdpc3RlciBhbiBJX1QgbmV4dXMgdGhhdCBpcyBhbHJlYWR5IHJlZ2lzdGVyZWQgd2l0aCB0aGUgc2FtZQorCSAqIHJlc2VydmF0aW9uIGtleSBvciBhIGRpZmZlcmVudCByZXNlcnZhdGlvbiBrZXkuCisJICovCisJZGVzdF9wcl9yZWcgPSBfX2NvcmVfc2NzaTNfbG9jYXRlX3ByX3JlZyhkZXYsIGRlc3Rfbm9kZV9hY2wsCisJCQkJCWlwb3J0X3B0cik7CisJaWYgKCEoZGVzdF9wcl9yZWcpKSB7CisJCXJldCA9IGNvcmVfc2NzaTNfYWxsb2NfcmVnaXN0cmF0aW9uKFNFX0RFVihjbWQpLAorCQkJCWRlc3Rfbm9kZV9hY2wsIGRlc3Rfc2VfZGV2ZSwgaXBvcnRfcHRyLAorCQkJCXNhX3Jlc19rZXksIDAsIGFwdHBsLCAyLCAxKTsKKwkJaWYgKHJldCAhPSAwKSB7CisJCQlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisJCQlyZXQgPSBQWVhfVFJBTlNQT1JUX0lOVkFMSURfUEFSQU1FVEVSX0xJU1Q7CisJCQlnb3RvIG91dDsKKwkJfQorCQlkZXN0X3ByX3JlZyA9IF9fY29yZV9zY3NpM19sb2NhdGVfcHJfcmVnKGRldiwgZGVzdF9ub2RlX2FjbCwKKwkJCQkJCWlwb3J0X3B0cik7CisJCW5ld19yZWcgPSAxOworCX0KKwkvKgorCSAqIGYpIFJlbGVhc2UgdGhlIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gZm9yIHRoZSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uCisJICogICAgaG9sZGVyIChpLmUuLCB0aGUgSV9UIG5leHVzIG9uIHdoaWNoIHRoZQorCSAqLworCV9fY29yZV9zY3NpM19jb21wbGV0ZV9wcm9fcmVsZWFzZShkZXYsIHByX3Jlc19uYWNsLAorCQkJZGV2LT5kZXZfcHJfcmVzX2hvbGRlciwgMCk7CisJLyoKKwkgKiBnKSBNb3ZlIHRoZSBwZXJzaXN0ZW50IHJlc2VydmF0aW9uIHRvIHRoZSBzcGVjaWZpZWQgSV9UIG5leHVzIHVzaW5nCisJICogICAgdGhlIHNhbWUgc2NvcGUgYW5kIHR5cGUgYXMgdGhlIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gcmVsZWFzZWQgaW4KKwkgKiAgICBpdGVtIGYpOyBhbmQKKwkgKi8KKwlkZXYtPmRldl9wcl9yZXNfaG9sZGVyID0gZGVzdF9wcl9yZWc7CisJZGVzdF9wcl9yZWctPnByX3Jlc19ob2xkZXIgPSAxOworCWRlc3RfcHJfcmVnLT5wcl9yZXNfdHlwZSA9IHR5cGU7CisJcHJfcmVnLT5wcl9yZXNfc2NvcGUgPSBzY29wZTsKKwlwcmZfaXNpZCA9IGNvcmVfcHJfZHVtcF9pbml0aWF0b3JfcG9ydChwcl9yZWcsICZpX2J1ZlswXSwKKwkJCQlQUl9SRUdfSVNJRF9JRF9MRU4pOworCS8qCisJICogSW5jcmVtZW50IFBSR2VuZXJhdGlvbiBmb3IgZXhpc3RpbmcgcmVnaXN0cmF0aW9ucy4uCisJICovCisJaWYgKCEobmV3X3JlZykpCisJCWRlc3RfcHJfcmVnLT5wcl9yZXNfZ2VuZXJhdGlvbiA9IHByX3RtcGwtPnByX2dlbmVyYXRpb24rKzsKKwlzcGluX3VubG9jaygmZGV2LT5kZXZfcmVzZXJ2YXRpb25fbG9jayk7CisKKwlwcmludGsoS0VSTl9JTkZPICJTUEMtMyBQUiBbJXNdIFNlcnZpY2UgQWN0aW9uOiBSRUdJU1RFUl9BTkRfTU9WRSIKKwkJIiBjcmVhdGVkIG5ldyByZXNlcnZhdGlvbiBob2xkZXIgVFlQRTogJXMgb24gb2JqZWN0IFJUUEk6IgorCQkiICVodSAgUFJHZW5lcmF0aW9uOiAweCUwOHhcbiIsIGRlc3RfdGZfb3BzLT5nZXRfZmFicmljX25hbWUoKSwKKwkJY29yZV9zY3NpM19wcl9kdW1wX3R5cGUodHlwZSksIHJ0cGksCisJCWRlc3RfcHJfcmVnLT5wcl9yZXNfZ2VuZXJhdGlvbik7CisJcHJpbnRrKEtFUk5fSU5GTyAiU1BDLTMgUFIgU3VjY2Vzc2Z1bGx5IG1vdmVkIHJlc2VydmF0aW9uIGZyb20iCisJCSIgJXMgRmFicmljIE5vZGU6ICVzJXMgLT4gJXMgRmFicmljIE5vZGU6ICVzICVzXG4iLAorCQl0Zl9vcHMtPmdldF9mYWJyaWNfbmFtZSgpLCBwcl9yZWdfbmFjbC0+aW5pdGlhdG9ybmFtZSwKKwkJKHByZl9pc2lkKSA/ICZpX2J1ZlswXSA6ICIiLCBkZXN0X3RmX29wcy0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCWRlc3Rfbm9kZV9hY2wtPmluaXRpYXRvcm5hbWUsIChpcG9ydF9wdHIgIT0gTlVMTCkgPworCQlpcG9ydF9wdHIgOiAiIik7CisJLyoKKwkgKiBJdCBpcyBub3cgc2FmZSB0byByZWxlYXNlIGNvbmZpZ2ZzIGdyb3VwIGRlcGVuZGVuY2llcyBmb3IgZGVzdGluYXRpb24KKwkgKiBvZiBUcmFuc3BvcnQgSUQgSW5pdGlhdG9yIERldmljZS9Qb3J0IElkZW50aWZpZXIKKwkgKi8KKwljb3JlX3Njc2kzX2x1bmFjbF91bmRlcGVuZF9pdGVtKGRlc3Rfc2VfZGV2ZSk7CisJY29yZV9zY3NpM19ub2RlYWNsX3VuZGVwZW5kX2l0ZW0oZGVzdF9ub2RlX2FjbCk7CisJY29yZV9zY3NpM190cGdfdW5kZXBlbmRfaXRlbShkZXN0X3NlX3RwZyk7CisJLyoKKwkgKiBoKSBJZiB0aGUgVU5SRUcgYml0IGlzIHNldCB0byBvbmUsIHVucmVnaXN0ZXIgKHNlZSA1LjcuMTEuMykgdGhlIElfVAorCSAqIG5leHVzIG9uIHdoaWNoIFBFUlNJU1RFTlQgUkVTRVJWRSBPVVQgY29tbWFuZCB3YXMgcmVjZWl2ZWQuCisJICovCisJaWYgKHVucmVnKSB7CisJCXNwaW5fbG9jaygmcHJfdG1wbC0+cmVnaXN0cmF0aW9uX2xvY2spOworCQlfX2NvcmVfc2NzaTNfZnJlZV9yZWdpc3RyYXRpb24oZGV2LCBwcl9yZWcsIE5VTEwsIDEpOworCQlzcGluX3VubG9jaygmcHJfdG1wbC0+cmVnaXN0cmF0aW9uX2xvY2spOworCX0gZWxzZQorCQljb3JlX3Njc2kzX3B1dF9wcl9yZWcocHJfcmVnKTsKKworCS8qCisJICogQ2xlYXIgdGhlIEFQVFBMIG1ldGFkYXRhIGlmIEFQVFBMIGhhcyBiZWVuIGRpc2FibGVkLCBvdGhlcndpc2UKKwkgKiB3cml0ZSBvdXQgdGhlIHVwZGF0ZWQgbWV0YWRhdGEgdG8gc3RydWN0IGZpbGUgZm9yIHRoaXMgU0NTSSBkZXZpY2UuCisJICovCisJaWYgKCEoYXB0cGwpKSB7CisJCXByX3RtcGwtPnByX2FwdHBsX2FjdGl2ZSA9IDA7CisJCWNvcmVfc2NzaTNfdXBkYXRlX2FuZF93cml0ZV9hcHRwbChTRV9ERVYoY21kKSwgTlVMTCwgMCk7CisJCXByaW50aygiU1BDLTMgUFI6IFNldCBBUFRQTCBCaXQgRGVhY3RpdmF0ZWQgZm9yIgorCQkJCSIgUkVHSVNURVJfQU5EX01PVkVcbiIpOworCX0gZWxzZSB7CisJCXByX3RtcGwtPnByX2FwdHBsX2FjdGl2ZSA9IDE7CisJCXJldCA9IGNvcmVfc2NzaTNfdXBkYXRlX2FuZF93cml0ZV9hcHRwbChTRV9ERVYoY21kKSwKKwkJCQkmZGVzdF9wcl9yZWctPnByX2FwdHBsX2J1ZlswXSwKKwkJCQlwcl90bXBsLT5wcl9hcHRwbF9idWZfbGVuKTsKKwkJaWYgKCEocmV0KSkKKwkJCXByaW50aygiU1BDLTMgUFI6IFNldCBBUFRQTCBCaXQgQWN0aXZhdGVkIGZvciIKKwkJCQkJIiBSRUdJU1RFUl9BTkRfTU9WRVxuIik7CisJfQorCisJY29yZV9zY3NpM19wdXRfcHJfcmVnKGRlc3RfcHJfcmVnKTsKKwlyZXR1cm4gMDsKK291dDoKKwlpZiAoZGVzdF9zZV9kZXZlKQorCQljb3JlX3Njc2kzX2x1bmFjbF91bmRlcGVuZF9pdGVtKGRlc3Rfc2VfZGV2ZSk7CisJaWYgKGRlc3Rfbm9kZV9hY2wpCisJCWNvcmVfc2NzaTNfbm9kZWFjbF91bmRlcGVuZF9pdGVtKGRlc3Rfbm9kZV9hY2wpOworCWNvcmVfc2NzaTNfdHBnX3VuZGVwZW5kX2l0ZW0oZGVzdF9zZV90cGcpOworCWNvcmVfc2NzaTNfcHV0X3ByX3JlZyhwcl9yZWcpOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBsb25nIGxvbmcgY29yZV9zY3NpM19leHRyYWN0X3Jlc2VydmF0aW9uX2tleSh1bnNpZ25lZCBjaGFyICpjZGIpCit7CisJdW5zaWduZWQgaW50IF9fdjEsIF9fdjI7CisKKwlfX3YxID0gKGNkYlswXSA8PCAyNCkgfCAoY2RiWzFdIDw8IDE2KSB8IChjZGJbMl0gPDwgOCkgfCBjZGJbM107CisJX192MiA9IChjZGJbNF0gPDwgMjQpIHwgKGNkYls1XSA8PCAxNikgfCAoY2RiWzZdIDw8IDgpIHwgY2RiWzddOworCisJcmV0dXJuICgodW5zaWduZWQgbG9uZyBsb25nKV9fdjIpIHwgKHVuc2lnbmVkIGxvbmcgbG9uZylfX3YxIDw8IDMyOworfQorCisvKgorICogU2VlIHNwYzRyMTcgc2VjdGlvbiA2LjE0IFRhYmxlIDE3MAorICovCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfZW11bGF0ZV9wcl9vdXQoc3RydWN0IHNlX2NtZCAqY21kLCB1bnNpZ25lZCBjaGFyICpjZGIpCit7CisJdW5zaWduZWQgY2hhciAqYnVmID0gKHVuc2lnbmVkIGNoYXIgKilUX1RBU0soY21kKS0+dF90YXNrX2J1ZjsKKwl1NjQgcmVzX2tleSwgc2FfcmVzX2tleTsKKwlpbnQgc2EsIHNjb3BlLCB0eXBlLCBhcHRwbDsKKwlpbnQgc3BlY19pX3B0ID0gMCwgYWxsX3RnX3B0ID0gMCwgdW5yZWcgPSAwOworCS8qCisJICogRklYTUU6IEEgTlVMTCBzdHJ1Y3Qgc2Vfc2Vzc2lvbiBwb2ludGVyIG1lYW5zIGFuIHRoaXMgaXMgbm90IGNvbWluZyBmcm9tCisJICogYSAkRkFCUklDX01PRCdzIG5leHVzLCBidXQgZnJvbSBpbnRlcm5hbCBwYXNzdGhyb3VnaCBvcHMuCisJICovCisJaWYgKCEoU0VfU0VTUyhjbWQpKSkKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfTFVfQ09NTV9GQUlMVVJFOworCisJaWYgKGNtZC0+ZGF0YV9sZW5ndGggPCAyNCkgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJTUEMtUFI6IFJlY2lldmVkIFBSIE9VVCBwYXJhbWV0ZXIgbGlzdCIKKwkJCSIgbGVuZ3RoIHRvbyBzbWFsbDogJXVcbiIsIGNtZC0+ZGF0YV9sZW5ndGgpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCX0KKwkvKgorCSAqIEZyb20gdGhlIFBFUlNJU1RFTlRfUkVTRVJWRV9PVVQgY29tbWFuZCBkZXNjcmlwdG9yIGJsb2NrIChDREIpCisJICovCisJc2EgPSAoY2RiWzFdICYgMHgxZik7CisJc2NvcGUgPSAoY2RiWzJdICYgMHhmMCk7CisJdHlwZSA9IChjZGJbMl0gJiAweDBmKTsKKwkvKgorCSAqIEZyb20gUEVSU0lTVEVOVF9SRVNFUlZFX09VVCBwYXJhbWV0ZXIgbGlzdCAocGF5bG9hZCkKKwkgKi8KKwlyZXNfa2V5ID0gY29yZV9zY3NpM19leHRyYWN0X3Jlc2VydmF0aW9uX2tleSgmYnVmWzBdKTsKKwlzYV9yZXNfa2V5ID0gY29yZV9zY3NpM19leHRyYWN0X3Jlc2VydmF0aW9uX2tleSgmYnVmWzhdKTsKKwkvKgorCSAqIFJFR0lTVEVSX0FORF9NT1ZFIHVzZXMgYSBkaWZmZXJlbnQgU0EgcGFyYW1ldGVyIGxpc3QgY29udGFpbmluZworCSAqIFNDU0kgVHJhbnNwb3J0SURzLgorCSAqLworCWlmIChzYSAhPSBQUk9fUkVHSVNURVJfQU5EX01PVkUpIHsKKwkJc3BlY19pX3B0ID0gKGJ1ZlsyMF0gJiAweDA4KTsKKwkJYWxsX3RnX3B0ID0gKGJ1ZlsyMF0gJiAweDA0KTsKKwkJYXB0cGwgPSAoYnVmWzIwXSAmIDB4MDEpOworCX0gZWxzZSB7CisJCWFwdHBsID0gKGJ1ZlsxN10gJiAweDAxKTsKKwkJdW5yZWcgPSAoYnVmWzE3XSAmIDB4MDIpOworCX0KKwkvKgorCSAqIFNQRUNfSV9QVD0xIGlzIG9ubHkgdmFsaWQgZm9yIFNlcnZpY2UgYWN0aW9uOiBSRUdJU1RFUgorCSAqLworCWlmIChzcGVjX2lfcHQgJiYgKChjZGJbMV0gJiAweDFmKSAhPSBQUk9fUkVHSVNURVIpKQorCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCS8qCisJICogRnJvbSBzcGM0cjE3IHNlY3Rpb24gNi4xNDoKKwkgKgorCSAqIElmIHRoZSBTUEVDX0lfUFQgYml0IGlzIHNldCB0byB6ZXJvLCB0aGUgc2VydmljZSBhY3Rpb24gaXMgbm90CisJICogUkVHSVNURVIgQU5EIE1PVkUsIGFuZCB0aGUgcGFyYW1ldGVyIGxpc3QgbGVuZ3RoIGlzIG5vdCAyNCwgdGhlbgorCSAqIHRoZSBjb21tYW5kIHNoYWxsIGJlIHRlcm1pbmF0ZWQgd2l0aCBDSEVDSyBDT05ESVRJT04gc3RhdHVzLCB3aXRoCisJICogdGhlIHNlbnNlIGtleSBzZXQgdG8gSUxMRUdBTCBSRVFVRVNULCBhbmQgdGhlIGFkZGl0aW9uYWwgc2Vuc2UKKwkgKiBjb2RlIHNldCB0byBQQVJBTUVURVIgTElTVCBMRU5HVEggRVJST1IuCisJICovCisJaWYgKCEoc3BlY19pX3B0KSAmJiAoKGNkYlsxXSAmIDB4MWYpICE9IFBST19SRUdJU1RFUl9BTkRfTU9WRSkgJiYKKwkgICAgKGNtZC0+ZGF0YV9sZW5ndGggIT0gMjQpKSB7CisJCXByaW50ayhLRVJOX1dBUk5JTkcgIlNQQy1QUjogUmVjaWV2ZWQgUFIgT1VUIGlsbGVnYWwgcGFyYW1ldGVyIgorCQkJIiBsaXN0IGxlbmd0aDogJXVcbiIsIGNtZC0+ZGF0YV9sZW5ndGgpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOworCX0KKwkvKgorCSAqIChjb3JlX3Njc2kzX2VtdWxhdGVfcHJvXyogZnVuY3Rpb24gcGFyYW1ldGVycworCSAqIGFyZSBkZWZpbmVkIGJ5IHNwYzRyMTcgVGFibGUgMTc0OgorCSAqIFBFUlNJU1RFTlRfUkVTRVJWRV9PVVQgc2VydmljZSBhY3Rpb25zIGFuZCB2YWxpZCBwYXJhbWV0ZXJzLgorCSAqLworCXN3aXRjaCAoc2EpIHsKKwljYXNlIFBST19SRUdJU1RFUjoKKwkJcmV0dXJuIGNvcmVfc2NzaTNfZW11bGF0ZV9wcm9fcmVnaXN0ZXIoY21kLAorCQkJcmVzX2tleSwgc2FfcmVzX2tleSwgYXB0cGwsIGFsbF90Z19wdCwgc3BlY19pX3B0LCAwKTsKKwljYXNlIFBST19SRVNFUlZFOgorCQlyZXR1cm4gY29yZV9zY3NpM19lbXVsYXRlX3Byb19yZXNlcnZlKGNtZCwKKwkJCXR5cGUsIHNjb3BlLCByZXNfa2V5KTsKKwljYXNlIFBST19SRUxFQVNFOgorCQlyZXR1cm4gY29yZV9zY3NpM19lbXVsYXRlX3Byb19yZWxlYXNlKGNtZCwKKwkJCXR5cGUsIHNjb3BlLCByZXNfa2V5KTsKKwljYXNlIFBST19DTEVBUjoKKwkJcmV0dXJuIGNvcmVfc2NzaTNfZW11bGF0ZV9wcm9fY2xlYXIoY21kLCByZXNfa2V5KTsKKwljYXNlIFBST19QUkVFTVBUOgorCQlyZXR1cm4gY29yZV9zY3NpM19lbXVsYXRlX3Byb19wcmVlbXB0KGNtZCwgdHlwZSwgc2NvcGUsCisJCQkJCXJlc19rZXksIHNhX3Jlc19rZXksIDApOworCWNhc2UgUFJPX1BSRUVNUFRfQU5EX0FCT1JUOgorCQlyZXR1cm4gY29yZV9zY3NpM19lbXVsYXRlX3Byb19wcmVlbXB0KGNtZCwgdHlwZSwgc2NvcGUsCisJCQkJCXJlc19rZXksIHNhX3Jlc19rZXksIDEpOworCWNhc2UgUFJPX1JFR0lTVEVSX0FORF9JR05PUkVfRVhJU1RJTkdfS0VZOgorCQlyZXR1cm4gY29yZV9zY3NpM19lbXVsYXRlX3Byb19yZWdpc3RlcihjbWQsCisJCQkwLCBzYV9yZXNfa2V5LCBhcHRwbCwgYWxsX3RnX3B0LCBzcGVjX2lfcHQsIDEpOworCWNhc2UgUFJPX1JFR0lTVEVSX0FORF9NT1ZFOgorCQlyZXR1cm4gY29yZV9zY3NpM19lbXVsYXRlX3Byb19yZWdpc3Rlcl9hbmRfbW92ZShjbWQsIHJlc19rZXksCisJCQkJc2FfcmVzX2tleSwgYXB0cGwsIHVucmVnKTsKKwlkZWZhdWx0OgorCQlwcmludGsoS0VSTl9FUlIgIlVua25vd24gUEVSU0lTVEVOVF9SRVNFUlZFX09VVCBzZXJ2aWNlIgorCQkJIiBhY3Rpb246IDB4JTAyeFxuIiwgY2RiWzFdICYgMHgxZik7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0lOVkFMSURfQ0RCX0ZJRUxEOworCX0KKworCXJldHVybiBQWVhfVFJBTlNQT1JUX0lOVkFMSURfQ0RCX0ZJRUxEOworfQorCisvKgorICogUEVSU0lTVEVOVF9SRVNFUlZFX0lOIFNlcnZpY2UgQWN0aW9uIFJFQURfS0VZUworICoKKyAqIFNlZSBzcGM0cjE3IHNlY3Rpb24gNS43LjYuMiBhbmQgc2VjdGlvbiA2LjEzLjIsIFRhYmxlIDE2MAorICovCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfcHJpX3JlYWRfa2V5cyhzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHNlX2RldmljZSAqc2VfZGV2ID0gU0VfREVWKGNtZCk7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnN1X2RldiA9IFNVX0RFVihzZV9kZXYpOworCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWc7CisJdW5zaWduZWQgY2hhciAqYnVmID0gKHVuc2lnbmVkIGNoYXIgKilUX1RBU0soY21kKS0+dF90YXNrX2J1ZjsKKwl1MzIgYWRkX2xlbiA9IDAsIG9mZiA9IDg7CisKKwlpZiAoY21kLT5kYXRhX2xlbmd0aCA8IDgpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJQUklOIFNBIFJFQURfS0VZUyBTQ1NJIERhdGEgTGVuZ3RoOiAldSIKKwkJCSIgdG9vIHNtYWxsXG4iLCBjbWQtPmRhdGFfbGVuZ3RoKTsKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfSU5WQUxJRF9DREJfRklFTEQ7CisJfQorCisJYnVmWzBdID0gKChUMTBfUkVTKHN1X2RldiktPnByX2dlbmVyYXRpb24gPj4gMjQpICYgMHhmZik7CisJYnVmWzFdID0gKChUMTBfUkVTKHN1X2RldiktPnByX2dlbmVyYXRpb24gPj4gMTYpICYgMHhmZik7CisJYnVmWzJdID0gKChUMTBfUkVTKHN1X2RldiktPnByX2dlbmVyYXRpb24gPj4gOCkgJiAweGZmKTsKKwlidWZbM10gPSAoVDEwX1JFUyhzdV9kZXYpLT5wcl9nZW5lcmF0aW9uICYgMHhmZik7CisKKwlzcGluX2xvY2soJlQxMF9SRVMoc3VfZGV2KS0+cmVnaXN0cmF0aW9uX2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnkocHJfcmVnLCAmVDEwX1JFUyhzdV9kZXYpLT5yZWdpc3RyYXRpb25fbGlzdCwKKwkJCXByX3JlZ19saXN0KSB7CisJCS8qCisJCSAqIENoZWNrIGZvciBvdmVyZmxvdyBvZiA4Ynl0ZSBQUkkgUkVBRF9LRVlTIHBheWxvYWQgYW5kCisJCSAqIG5leHQgcmVzZXJ2YXRpb24ga2V5IGxpc3QgZGVzY3JpcHRvci4KKwkJICovCisJCWlmICgoYWRkX2xlbiArIDgpID4gKGNtZC0+ZGF0YV9sZW5ndGggLSA4KSkKKwkJCWJyZWFrOworCisJCWJ1ZltvZmYrK10gPSAoKHByX3JlZy0+cHJfcmVzX2tleSA+PiA1NikgJiAweGZmKTsKKwkJYnVmW29mZisrXSA9ICgocHJfcmVnLT5wcl9yZXNfa2V5ID4+IDQ4KSAmIDB4ZmYpOworCQlidWZbb2ZmKytdID0gKChwcl9yZWctPnByX3Jlc19rZXkgPj4gNDApICYgMHhmZik7CisJCWJ1ZltvZmYrK10gPSAoKHByX3JlZy0+cHJfcmVzX2tleSA+PiAzMikgJiAweGZmKTsKKwkJYnVmW29mZisrXSA9ICgocHJfcmVnLT5wcl9yZXNfa2V5ID4+IDI0KSAmIDB4ZmYpOworCQlidWZbb2ZmKytdID0gKChwcl9yZWctPnByX3Jlc19rZXkgPj4gMTYpICYgMHhmZik7CisJCWJ1ZltvZmYrK10gPSAoKHByX3JlZy0+cHJfcmVzX2tleSA+PiA4KSAmIDB4ZmYpOworCQlidWZbb2ZmKytdID0gKHByX3JlZy0+cHJfcmVzX2tleSAmIDB4ZmYpOworCisJCWFkZF9sZW4gKz0gODsKKwl9CisJc3Bpbl91bmxvY2soJlQxMF9SRVMoc3VfZGV2KS0+cmVnaXN0cmF0aW9uX2xvY2spOworCisJYnVmWzRdID0gKChhZGRfbGVuID4+IDI0KSAmIDB4ZmYpOworCWJ1Zls1XSA9ICgoYWRkX2xlbiA+PiAxNikgJiAweGZmKTsKKwlidWZbNl0gPSAoKGFkZF9sZW4gPj4gOCkgJiAweGZmKTsKKwlidWZbN10gPSAoYWRkX2xlbiAmIDB4ZmYpOworCisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBQRVJTSVNURU5UX1JFU0VSVkVfSU4gU2VydmljZSBBY3Rpb24gUkVBRF9SRVNFUlZBVElPTgorICoKKyAqIFNlZSBzcGM0cjE3IHNlY3Rpb24gNS43LjYuMyBhbmQgc2VjdGlvbiA2LjEzLjMuMiBUYWJsZSAxNjEgYW5kIDE2MgorICovCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfcHJpX3JlYWRfcmVzZXJ2YXRpb24oc3RydWN0IHNlX2NtZCAqY21kKQoreworCXN0cnVjdCBzZV9kZXZpY2UgKnNlX2RldiA9IFNFX0RFVihjbWQpOworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzdV9kZXYgPSBTVV9ERVYoc2VfZGV2KTsKKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqcHJfcmVnOworCXVuc2lnbmVkIGNoYXIgKmJ1ZiA9ICh1bnNpZ25lZCBjaGFyICopVF9UQVNLKGNtZCktPnRfdGFza19idWY7CisJdTY0IHByX3Jlc19rZXk7CisJdTMyIGFkZF9sZW4gPSAxNjsgLyogSGFyZGNvZGVkIHRvIDE2IHdoZW4gYSByZXNlcnZhdGlvbiBpcyBoZWxkLiAqLworCisJaWYgKGNtZC0+ZGF0YV9sZW5ndGggPCA4KSB7CisJCXByaW50ayhLRVJOX0VSUiAiUFJJTiBTQSBSRUFEX1JFU0VSVkFUSU9OUyBTQ1NJIERhdGEgTGVuZ3RoOiAldSIKKwkJCSIgdG9vIHNtYWxsXG4iLCBjbWQtPmRhdGFfbGVuZ3RoKTsKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfSU5WQUxJRF9DREJfRklFTEQ7CisJfQorCisJYnVmWzBdID0gKChUMTBfUkVTKHN1X2RldiktPnByX2dlbmVyYXRpb24gPj4gMjQpICYgMHhmZik7CisJYnVmWzFdID0gKChUMTBfUkVTKHN1X2RldiktPnByX2dlbmVyYXRpb24gPj4gMTYpICYgMHhmZik7CisJYnVmWzJdID0gKChUMTBfUkVTKHN1X2RldiktPnByX2dlbmVyYXRpb24gPj4gOCkgJiAweGZmKTsKKwlidWZbM10gPSAoVDEwX1JFUyhzdV9kZXYpLT5wcl9nZW5lcmF0aW9uICYgMHhmZik7CisKKwlzcGluX2xvY2soJnNlX2Rldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCXByX3JlZyA9IHNlX2Rldi0+ZGV2X3ByX3Jlc19ob2xkZXI7CisJaWYgKChwcl9yZWcpKSB7CisJCS8qCisJCSAqIFNldCB0aGUgaGFyZGNvZGVkIEFkZGl0aW9uYWwgTGVuZ3RoCisJCSAqLworCQlidWZbNF0gPSAoKGFkZF9sZW4gPj4gMjQpICYgMHhmZik7CisJCWJ1Zls1XSA9ICgoYWRkX2xlbiA+PiAxNikgJiAweGZmKTsKKwkJYnVmWzZdID0gKChhZGRfbGVuID4+IDgpICYgMHhmZik7CisJCWJ1Zls3XSA9IChhZGRfbGVuICYgMHhmZik7CisKKwkJaWYgKGNtZC0+ZGF0YV9sZW5ndGggPCAyMikgeworCQkJc3Bpbl91bmxvY2soJnNlX2Rldi0+ZGV2X3Jlc2VydmF0aW9uX2xvY2spOworCQkJcmV0dXJuIDA7CisJCX0KKwkJLyoKKwkJICogU2V0IHRoZSBSZXNlcnZhdGlvbiBrZXkuCisJCSAqCisJCSAqIEZyb20gc3BjNHIxNywgc2VjdGlvbiA1LjcuMTA6CisJCSAqIEEgcGVyc2lzdGVudCByZXNlcnZhdGlvbiBob2xkZXIgaGFzIGl0cyByZXNlcnZhdGlvbiBrZXkKKwkJICogcmV0dXJuZWQgaW4gdGhlIHBhcmFtZXRlciBkYXRhIGZyb20gYSBQRVJTSVNURU5UCisJCSAqIFJFU0VSVkUgSU4gY29tbWFuZCB3aXRoIFJFQUQgUkVTRVJWQVRJT04gc2VydmljZSBhY3Rpb24gYXMKKwkJICogZm9sbG93czoKKwkJICogYSkgRm9yIGEgcGVyc2lzdGVudCByZXNlcnZhdGlvbiBvZiB0aGUgdHlwZSBXcml0ZSBFeGNsdXNpdmUKKwkJICogICAgLSBBbGwgUmVnaXN0cmFudHMgb3IgRXhjbHVzaXZlIEFjY2VzcyDCrSBBbGwgUmVnaXRyYW50cywKKwkJICogICAgICB0aGUgcmVzZXJ2YXRpb24ga2V5IHNoYWxsIGJlIHNldCB0byB6ZXJvOyBvcgorCQkgKiBiKSBGb3IgYWxsIG90aGVyIHBlcnNpc3RlbnQgcmVzZXJ2YXRpb24gdHlwZXMsIHRoZQorCQkgKiAgICByZXNlcnZhdGlvbiBrZXkgc2hhbGwgYmUgc2V0IHRvIHRoZSByZWdpc3RlcmVkCisJCSAqICAgIHJlc2VydmF0aW9uIGtleSBmb3IgdGhlIElfVCBuZXh1cyB0aGF0IGhvbGRzIHRoZQorCQkgKiAgICBwZXJzaXN0ZW50IHJlc2VydmF0aW9uLgorCQkgKi8KKwkJaWYgKChwcl9yZWctPnByX3Jlc190eXBlID09IFBSX1RZUEVfV1JJVEVfRVhDTFVTSVZFX0FMTFJFRykgfHwKKwkJICAgIChwcl9yZWctPnByX3Jlc190eXBlID09IFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTU19BTExSRUcpKQorCQkJcHJfcmVzX2tleSA9IDA7CisJCWVsc2UKKwkJCXByX3Jlc19rZXkgPSBwcl9yZWctPnByX3Jlc19rZXk7CisKKwkJYnVmWzhdID0gKChwcl9yZXNfa2V5ID4+IDU2KSAmIDB4ZmYpOworCQlidWZbOV0gPSAoKHByX3Jlc19rZXkgPj4gNDgpICYgMHhmZik7CisJCWJ1ZlsxMF0gPSAoKHByX3Jlc19rZXkgPj4gNDApICYgMHhmZik7CisJCWJ1ZlsxMV0gPSAoKHByX3Jlc19rZXkgPj4gMzIpICYgMHhmZik7CisJCWJ1ZlsxMl0gPSAoKHByX3Jlc19rZXkgPj4gMjQpICYgMHhmZik7CisJCWJ1ZlsxM10gPSAoKHByX3Jlc19rZXkgPj4gMTYpICYgMHhmZik7CisJCWJ1ZlsxNF0gPSAoKHByX3Jlc19rZXkgPj4gOCkgJiAweGZmKTsKKwkJYnVmWzE1XSA9IChwcl9yZXNfa2V5ICYgMHhmZik7CisJCS8qCisJCSAqIFNldCB0aGUgU0NPUEUgYW5kIFRZUEUKKwkJICovCisJCWJ1ZlsyMV0gPSAocHJfcmVnLT5wcl9yZXNfc2NvcGUgJiAweGYwKSB8CisJCQkgIChwcl9yZWctPnByX3Jlc190eXBlICYgMHgwZik7CisJfQorCXNwaW5fdW5sb2NrKCZzZV9kZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKworCXJldHVybiAwOworfQorCisvKgorICogUEVSU0lTVEVOVF9SRVNFUlZFX0lOIFNlcnZpY2UgQWN0aW9uIFJFUE9SVF9DQVBBQklMSVRJRVMKKyAqCisgKiBTZWUgc3BjNHIxNyBzZWN0aW9uIDYuMTMuNCBUYWJsZSAxNjUKKyAqLworc3RhdGljIGludCBjb3JlX3Njc2kzX3ByaV9yZXBvcnRfY2FwYWJpbGl0aWVzKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKwlzdHJ1Y3QgdDEwX3Jlc2VydmF0aW9uX3RlbXBsYXRlICpwcl90bXBsID0gJlNVX0RFVihkZXYpLT50MTBfcmVzZXJ2YXRpb247CisJdW5zaWduZWQgY2hhciAqYnVmID0gKHVuc2lnbmVkIGNoYXIgKilUX1RBU0soY21kKS0+dF90YXNrX2J1ZjsKKwl1MTYgYWRkX2xlbiA9IDg7IC8qIEhhcmRjb2RlZCB0byA4LiAqLworCisJaWYgKGNtZC0+ZGF0YV9sZW5ndGggPCA2KSB7CisJCXByaW50ayhLRVJOX0VSUiAiUFJJTiBTQSBSRVBPUlRfQ0FQQUJJTElUSUVTIFNDU0kgRGF0YSBMZW5ndGg6IgorCQkJIiAldSB0b28gc21hbGxcbiIsIGNtZC0+ZGF0YV9sZW5ndGgpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9JTlZBTElEX0NEQl9GSUVMRDsKKwl9CisKKwlidWZbMF0gPSAoKGFkZF9sZW4gPDwgOCkgJiAweGZmKTsKKwlidWZbMV0gPSAoYWRkX2xlbiAmIDB4ZmYpOworCWJ1ZlsyXSB8PSAweDEwOyAvKiBDUkg6IENvbXBhdGlibGUgUmVzZXJ2YXRpb24gSGFubGRpbmcgYml0LiAqLworCWJ1ZlsyXSB8PSAweDA4OyAvKiBTSVBfQzogU3BlY2lmeSBJbml0aWF0b3IgUG9ydHMgQ2FwYWJsZSBiaXQgKi8KKwlidWZbMl0gfD0gMHgwNDsgLyogQVRQX0M6IEFsbCBUYXJnZXQgUG9ydHMgQ2FwYWJsZSBiaXQgKi8KKwlidWZbMl0gfD0gMHgwMTsgLyogUFRQTF9DOiBQZXJzaXN0ZW5jZSBhY3Jvc3MgVGFyZ2V0IFBvd2VyIExvc3MgYml0ICovCisJLyoKKwkgKiBXZSBhcmUgZmlsbGluZyBpbiB0aGUgUEVSU0lTVEVOVCBSRVNFUlZBVElPTiBUWVBFIE1BU0sgYmVsb3csIHNvCisJICogc2V0IHRoZSBUTVY6IFRhc2sgTWFzayBWYWxpZCBiaXQuCisJICovCisJYnVmWzNdIHw9IDB4ODA7CisJLyoKKwkgKiBDaGFuZ2UgQUxMT1cgQ09NTUFORHMgdG8gMHgyMCBvciAweDQwIGxhdGVyIGZyb20gVGFibGUgMTY2CisJICovCisJYnVmWzNdIHw9IDB4MTA7IC8qIEFMTE9XIENPTU1BTkRzIGZpZWxkIDAwMWIgKi8KKwkvKgorCSAqIFBUUExfQTogUGVyc2lzdGVuY2UgYWNyb3NzIFRhcmdldCBQb3dlciBMb3NzIEFjdGl2ZSBiaXQKKwkgKi8KKwlpZiAocHJfdG1wbC0+cHJfYXB0cGxfYWN0aXZlKQorCQlidWZbM10gfD0gMHgwMTsKKwkvKgorCSAqIFNldHVwIHRoZSBQRVJTSVNURU5UIFJFU0VSVkFUSU9OIFRZUEUgTUFTSyBmcm9tIFRhYmxlIDE2NworCSAqLworCWJ1Zls0XSB8PSAweDgwOyAvKiBQUl9UWVBFX0VYQ0xVU0lWRV9BQ0NFU1NfQUxMUkVHICovCisJYnVmWzRdIHw9IDB4NDA7IC8qIFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTU19SRUdPTkxZICovCisJYnVmWzRdIHw9IDB4MjA7IC8qIFBSX1RZUEVfV1JJVEVfRVhDTFVTSVZFX1JFR09OTFkgKi8KKwlidWZbNF0gfD0gMHgwODsgLyogUFJfVFlQRV9FWENMVVNJVkVfQUNDRVNTICovCisJYnVmWzRdIHw9IDB4MDI7IC8qIFBSX1RZUEVfV1JJVEVfRVhDTFVTSVZFICovCisJYnVmWzVdIHw9IDB4MDE7IC8qIFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTU19BTExSRUcgKi8KKworCXJldHVybiAwOworfQorCisvKgorICogUEVSU0lTVEVOVF9SRVNFUlZFX0lOIFNlcnZpY2UgQWN0aW9uIFJFQURfRlVMTF9TVEFUVVMKKyAqCisgKiBTZWUgc3BjNHIxNyBzZWN0aW9uIDYuMTMuNSBUYWJsZSAxNjggYW5kIDE2OQorICovCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfcHJpX3JlYWRfZnVsbF9zdGF0dXMoc3RydWN0IHNlX2NtZCAqY21kKQoreworCXN0cnVjdCBzZV9kZXZpY2UgKnNlX2RldiA9IFNFX0RFVihjbWQpOworCXN0cnVjdCBzZV9ub2RlX2FjbCAqc2VfbmFjbDsKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc3VfZGV2ID0gU1VfREVWKHNlX2Rldik7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnOworCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICpwcl9yZWcsICpwcl9yZWdfdG1wOworCXN0cnVjdCB0MTBfcmVzZXJ2YXRpb25fdGVtcGxhdGUgKnByX3RtcGwgPSAmU1VfREVWKHNlX2RldiktPnQxMF9yZXNlcnZhdGlvbjsKKwl1bnNpZ25lZCBjaGFyICpidWYgPSAodW5zaWduZWQgY2hhciAqKVRfVEFTSyhjbWQpLT50X3Rhc2tfYnVmOworCXUzMiBhZGRfZGVzY19sZW4gPSAwLCBhZGRfbGVuID0gMCwgZGVzY19sZW4sIGV4cF9kZXNjX2xlbjsKKwl1MzIgb2ZmID0gODsgLyogb2ZmIGludG8gZmlyc3QgRnVsbCBTdGF0dXMgZGVzY3JpcHRvciAqLworCWludCBmb3JtYXRfY29kZSA9IDA7CisKKwlpZiAoY21kLT5kYXRhX2xlbmd0aCA8IDgpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJQUklOIFNBIFJFQURfRlVMTF9TVEFUVVMgU0NTSSBEYXRhIExlbmd0aDogJXUiCisJCQkiIHRvbyBzbWFsbFxuIiwgY21kLT5kYXRhX2xlbmd0aCk7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0lOVkFMSURfQ0RCX0ZJRUxEOworCX0KKworCWJ1ZlswXSA9ICgoVDEwX1JFUyhzdV9kZXYpLT5wcl9nZW5lcmF0aW9uID4+IDI0KSAmIDB4ZmYpOworCWJ1ZlsxXSA9ICgoVDEwX1JFUyhzdV9kZXYpLT5wcl9nZW5lcmF0aW9uID4+IDE2KSAmIDB4ZmYpOworCWJ1ZlsyXSA9ICgoVDEwX1JFUyhzdV9kZXYpLT5wcl9nZW5lcmF0aW9uID4+IDgpICYgMHhmZik7CisJYnVmWzNdID0gKFQxMF9SRVMoc3VfZGV2KS0+cHJfZ2VuZXJhdGlvbiAmIDB4ZmYpOworCisJc3Bpbl9sb2NrKCZwcl90bXBsLT5yZWdpc3RyYXRpb25fbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHByX3JlZywgcHJfcmVnX3RtcCwKKwkJCSZwcl90bXBsLT5yZWdpc3RyYXRpb25fbGlzdCwgcHJfcmVnX2xpc3QpIHsKKworCQlzZV9uYWNsID0gcHJfcmVnLT5wcl9yZWdfbmFjbDsKKwkJc2VfdHBnID0gcHJfcmVnLT5wcl9yZWdfbmFjbC0+c2VfdHBnOworCQlhZGRfZGVzY19sZW4gPSAwOworCisJCWF0b21pY19pbmMoJnByX3JlZy0+cHJfcmVzX2hvbGRlcnMpOworCQlzbXBfbWJfX2FmdGVyX2F0b21pY19pbmMoKTsKKwkJc3Bpbl91bmxvY2soJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9sb2NrKTsKKwkJLyoKKwkJICogRGV0ZXJtaW5lIGV4cGVjdGVkIGxlbmd0aCBvZiAkRkFCUklDX01PRCBzcGVjaWZpYworCQkgKiBUcmFuc3BvcnRJRCBmdWxsIHN0YXR1cyBkZXNjcmlwdG9yLi4KKwkJICovCisJCWV4cF9kZXNjX2xlbiA9IFRQR19URk8oc2VfdHBnKS0+dHBnX2dldF9wcl90cmFuc3BvcnRfaWRfbGVuKAorCQkJCXNlX3RwZywgc2VfbmFjbCwgcHJfcmVnLCAmZm9ybWF0X2NvZGUpOworCisJCWlmICgoZXhwX2Rlc2NfbGVuICsgYWRkX2xlbikgPiBjbWQtPmRhdGFfbGVuZ3RoKSB7CisJCQlwcmludGsoS0VSTl9XQVJOSU5HICJTUEMtMyBQUklOIFJFQURfRlVMTF9TVEFUVVMgcmFuIgorCQkJCSIgb3V0IG9mIGJ1ZmZlcjogJWRcbiIsIGNtZC0+ZGF0YV9sZW5ndGgpOworCQkJc3Bpbl9sb2NrKCZwcl90bXBsLT5yZWdpc3RyYXRpb25fbG9jayk7CisJCQlhdG9taWNfZGVjKCZwcl9yZWctPnByX3Jlc19ob2xkZXJzKTsKKwkJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworCQkJYnJlYWs7CisJCX0KKwkJLyoKKwkJICogU2V0IFJFU0VSVkFUSU9OIEtFWQorCQkgKi8KKwkJYnVmW29mZisrXSA9ICgocHJfcmVnLT5wcl9yZXNfa2V5ID4+IDU2KSAmIDB4ZmYpOworCQlidWZbb2ZmKytdID0gKChwcl9yZWctPnByX3Jlc19rZXkgPj4gNDgpICYgMHhmZik7CisJCWJ1ZltvZmYrK10gPSAoKHByX3JlZy0+cHJfcmVzX2tleSA+PiA0MCkgJiAweGZmKTsKKwkJYnVmW29mZisrXSA9ICgocHJfcmVnLT5wcl9yZXNfa2V5ID4+IDMyKSAmIDB4ZmYpOworCQlidWZbb2ZmKytdID0gKChwcl9yZWctPnByX3Jlc19rZXkgPj4gMjQpICYgMHhmZik7CisJCWJ1ZltvZmYrK10gPSAoKHByX3JlZy0+cHJfcmVzX2tleSA+PiAxNikgJiAweGZmKTsKKwkJYnVmW29mZisrXSA9ICgocHJfcmVnLT5wcl9yZXNfa2V5ID4+IDgpICYgMHhmZik7CisJCWJ1ZltvZmYrK10gPSAocHJfcmVnLT5wcl9yZXNfa2V5ICYgMHhmZik7CisJCW9mZiArPSA0OyAvKiBTa2lwIE92ZXIgUmVzZXJ2ZWQgYXJlYSAqLworCisJCS8qCisJCSAqIFNldCBBTExfVEdfUFQgYml0IGlmIFBST1VUIFNBIFJFR0lTVEVSIGhhZCB0aGlzIHNldC4KKwkJICovCisJCWlmIChwcl9yZWctPnByX3JlZ19hbGxfdGdfcHQpCisJCQlidWZbb2ZmXSA9IDB4MDI7CisJCS8qCisJCSAqIFRoZSBzdHJ1Y3Qgc2VfbHVuIHBvaW50ZXIgd2lsbCBiZSBwcmVzZW50IGZvciB0aGUKKwkJICogcmVzZXJ2YXRpb24gaG9sZGVyIGZvciBQUl9IT0xERVIgYml0LgorCQkgKgorCQkgKiBBbHNvLCBpZiB0aGlzIHJlZ2lzdHJhdGlvbiBpcyB0aGUgcmVzZXJ2YXRpb24KKwkJICogaG9sZGVyLCBmaWxsIGluIFNDT1BFIGFuZCBUWVBFIGluIHRoZSBuZXh0IGJ5dGUuCisJCSAqLworCQlpZiAocHJfcmVnLT5wcl9yZXNfaG9sZGVyKSB7CisJCQlidWZbb2ZmKytdIHw9IDB4MDE7CisJCQlidWZbb2ZmKytdID0gKHByX3JlZy0+cHJfcmVzX3Njb3BlICYgMHhmMCkgfAorCQkJCSAgICAgKHByX3JlZy0+cHJfcmVzX3R5cGUgJiAweDBmKTsKKwkJfSBlbHNlCisJCQlvZmYgKz0gMjsKKworCQlvZmYgKz0gNDsgLyogU2tpcCBvdmVyIHJlc2VydmVkIGFyZWEgKi8KKwkJLyoKKwkJICogRnJvbSBzcGM0cjE3IDYuMy4xNToKKwkJICoKKwkJICogSWYgdGhlIEFMTF9UR19QVCBiaXQgc2V0IHRvIHplcm8sIHRoZSBSRUxBVElWRSBUQVJHRVQgUE9SVAorCQkgKiBJREVOVElGSUVSIGZpZWxkIGNvbnRhaW5zIHRoZSByZWxhdGl2ZSBwb3J0IGlkZW50aWZpZXIgKHNlZQorCQkgKiAzLjEuMTIwKSBvZiB0aGUgdGFyZ2V0IHBvcnQgdGhhdCBpcyBwYXJ0IG9mIHRoZSBJX1QgbmV4dXMKKwkJICogZGVzY3JpYmVkIGJ5IHRoaXMgZnVsbCBzdGF0dXMgZGVzY3JpcHRvci4gSWYgdGhlIEFMTF9UR19QVAorCQkgKiBiaXQgaXMgc2V0IHRvIG9uZSwgdGhlIGNvbnRlbnRzIG9mIHRoZSBSRUxBVElWRSBUQVJHRVQgUE9SVAorCQkgKiBJREVOVElGSUVSIGZpZWxkIGFyZSBub3QgZGVmaW5lZCBieSB0aGlzIHN0YW5kYXJkLgorCQkgKi8KKwkJaWYgKCEocHJfcmVnLT5wcl9yZWdfYWxsX3RnX3B0KSkgeworCQkJc3RydWN0IHNlX3BvcnQgKnBvcnQgPSBwcl9yZWctPnByX3JlZ190Z19wdF9sdW4tPmx1bl9zZXA7CisKKwkJCWJ1ZltvZmYrK10gPSAoKHBvcnQtPnNlcF9ydHBpID4+IDgpICYgMHhmZik7CisJCQlidWZbb2ZmKytdID0gKHBvcnQtPnNlcF9ydHBpICYgMHhmZik7CisJCX0gZWxzZQorCQkJb2ZmICs9IDI7IC8qIFNraXAgb3ZlciBSRUxBVElWRSBUQVJHRVQgUE9SVCBJREVOVElGRVIgKi8KKworCQkvKgorCQkgKiBOb3csIGhhdmUgdGhlICRGQUJSSUNfTU9EIGZpbGwgaW4gdGhlIHByb3RvY29sIGlkZW50aWZpZXIKKwkJICovCisJCWRlc2NfbGVuID0gVFBHX1RGTyhzZV90cGcpLT50cGdfZ2V0X3ByX3RyYW5zcG9ydF9pZChzZV90cGcsCisJCQkJc2VfbmFjbCwgcHJfcmVnLCAmZm9ybWF0X2NvZGUsICZidWZbb2ZmKzRdKTsKKworCQlzcGluX2xvY2soJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9sb2NrKTsKKwkJYXRvbWljX2RlYygmcHJfcmVnLT5wcl9yZXNfaG9sZGVycyk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworCQkvKgorCQkgKiBTZXQgdGhlIEFERElUSU9OQUwgREVTQ1JJUFRPUiBMRU5HVEgKKwkJICovCisJCWJ1ZltvZmYrK10gPSAoKGRlc2NfbGVuID4+IDI0KSAmIDB4ZmYpOworCQlidWZbb2ZmKytdID0gKChkZXNjX2xlbiA+PiAxNikgJiAweGZmKTsKKwkJYnVmW29mZisrXSA9ICgoZGVzY19sZW4gPj4gOCkgJiAweGZmKTsKKwkJYnVmW29mZisrXSA9IChkZXNjX2xlbiAmIDB4ZmYpOworCQkvKgorCQkgKiBTaXplIG9mIGZ1bGwgZGVzY3RpcG9yIGhlYWRlciBtaW51cyBUcmFuc3BvcnRJRAorCQkgKiBjb250YWluaW5nICRGQUJSSUNfTU9EIHNwZWNpZmljKSBpbml0aWF0b3IgZGV2aWNlL3BvcnQKKwkJICogV1dOIGluZm9ybWF0aW9uLgorCQkgKgorCQkgKiAgU2VlIHNwYzRyMTcgU2VjdGlvbiA2LjEzLjUgVGFibGUgMTY5CisJCSAqLworCQlhZGRfZGVzY19sZW4gPSAoMjQgKyBkZXNjX2xlbik7CisKKwkJb2ZmICs9IGRlc2NfbGVuOworCQlhZGRfbGVuICs9IGFkZF9kZXNjX2xlbjsKKwl9CisJc3Bpbl91bmxvY2soJnByX3RtcGwtPnJlZ2lzdHJhdGlvbl9sb2NrKTsKKwkvKgorCSAqIFNldCBBRERJVElPTkFMX0xFTkdUSAorCSAqLworCWJ1Zls0XSA9ICgoYWRkX2xlbiA+PiAyNCkgJiAweGZmKTsKKwlidWZbNV0gPSAoKGFkZF9sZW4gPj4gMTYpICYgMHhmZik7CisJYnVmWzZdID0gKChhZGRfbGVuID4+IDgpICYgMHhmZik7CisJYnVmWzddID0gKGFkZF9sZW4gJiAweGZmKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGNvcmVfc2NzaTNfZW11bGF0ZV9wcl9pbihzdHJ1Y3Qgc2VfY21kICpjbWQsIHVuc2lnbmVkIGNoYXIgKmNkYikKK3sKKwlzd2l0Y2ggKGNkYlsxXSAmIDB4MWYpIHsKKwljYXNlIFBSSV9SRUFEX0tFWVM6CisJCXJldHVybiBjb3JlX3Njc2kzX3ByaV9yZWFkX2tleXMoY21kKTsKKwljYXNlIFBSSV9SRUFEX1JFU0VSVkFUSU9OOgorCQlyZXR1cm4gY29yZV9zY3NpM19wcmlfcmVhZF9yZXNlcnZhdGlvbihjbWQpOworCWNhc2UgUFJJX1JFUE9SVF9DQVBBQklMSVRJRVM6CisJCXJldHVybiBjb3JlX3Njc2kzX3ByaV9yZXBvcnRfY2FwYWJpbGl0aWVzKGNtZCk7CisJY2FzZSBQUklfUkVBRF9GVUxMX1NUQVRVUzoKKwkJcmV0dXJuIGNvcmVfc2NzaTNfcHJpX3JlYWRfZnVsbF9zdGF0dXMoY21kKTsKKwlkZWZhdWx0OgorCQlwcmludGsoS0VSTl9FUlIgIlVua25vd24gUEVSU0lTVEVOVF9SRVNFUlZFX0lOIHNlcnZpY2UiCisJCQkiIGFjdGlvbjogMHglMDJ4XG4iLCBjZGJbMV0gJiAweDFmKTsKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfSU5WQUxJRF9DREJfRklFTEQ7CisJfQorCit9CisKK2ludCBjb3JlX3Njc2kzX2VtdWxhdGVfcHIoc3RydWN0IHNlX2NtZCAqY21kKQoreworCXVuc2lnbmVkIGNoYXIgKmNkYiA9ICZUX1RBU0soY21kKS0+dF90YXNrX2NkYlswXTsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBjbWQtPnNlX2RldjsKKwkvKgorCSAqIEZvbGxvd2luZyBzcGMycjIwIDUuNS4xIFJlc2VydmF0aW9ucyBvdmVydmlldzoKKwkgKgorCSAqIElmIGEgbG9naWNhbCB1bml0IGhhcyBiZWVuIHJlc2VydmVkIGJ5IGFueSBSRVNFUlZFIGNvbW1hbmQgYW5kIGlzCisJICogc3RpbGwgcmVzZXJ2ZWQgYnkgYW55IGluaXRpYXRvciwgYWxsIFBFUlNJU1RFTlQgUkVTRVJWRSBJTiBhbmQgYWxsCisJICogUEVSU0lTVEVOVCBSRVNFUlZFIE9VVCBjb21tYW5kcyBzaGFsbCBjb25mbGljdCByZWdhcmRsZXNzIG9mCisJICogaW5pdGlhdG9yIG9yIHNlcnZpY2UgYWN0aW9uIGFuZCBzaGFsbCB0ZXJtaW5hdGUgd2l0aCBhIFJFU0VSVkFUSU9OCisJICogQ09ORkxJQ1Qgc3RhdHVzLgorCSAqLworCWlmIChkZXYtPmRldl9mbGFncyAmIERGX1NQQzJfUkVTRVJWQVRJT05TKSB7CisJCXByaW50ayhLRVJOX0VSUiAiUmVjZWl2ZWQgUEVSU0lTVEVOVF9SRVNFUlZFIENEQiB3aGlsZSBsZWdhY3kiCisJCQkiIFNQQy0yIHJlc2VydmF0aW9uIGlzIGhlbGQsIHJldHVybmluZyIKKwkJCSIgUkVTRVJWQVRJT05fQ09ORkxJQ1RcbiIpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9SRVNFUlZBVElPTl9DT05GTElDVDsKKwl9CisKKwlyZXR1cm4gKGNkYlswXSA9PSBQRVJTSVNURU5UX1JFU0VSVkVfT1VUKSA/CisJICAgICAgIGNvcmVfc2NzaTNfZW11bGF0ZV9wcl9vdXQoY21kLCBjZGIpIDoKKwkgICAgICAgY29yZV9zY3NpM19lbXVsYXRlX3ByX2luKGNtZCwgY2RiKTsKK30KKworc3RhdGljIGludCBjb3JlX3B0X3Jlc2VydmF0aW9uX2NoZWNrKHN0cnVjdCBzZV9jbWQgKmNtZCwgdTMyICpwcl9yZXNfdHlwZSkKK3sKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBjb3JlX3B0X3NlcV9ub25faG9sZGVyKAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwl1bnNpZ25lZCBjaGFyICpjZGIsCisJdTMyIHByX3JlZ190eXBlKQoreworCXJldHVybiAwOworfQorCitpbnQgY29yZV9zZXR1cF9yZXNlcnZhdGlvbnMoc3RydWN0IHNlX2RldmljZSAqZGV2LCBpbnQgZm9yY2VfcHQpCit7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnN1X2RldiA9IGRldi0+c2Vfc3ViX2RldjsKKwlzdHJ1Y3QgdDEwX3Jlc2VydmF0aW9uX3RlbXBsYXRlICpyZXN0ID0gJnN1X2Rldi0+dDEwX3Jlc2VydmF0aW9uOworCS8qCisJICogSWYgdGhpcyBkZXZpY2UgaXMgZnJvbSBUYXJnZXRfQ29yZV9Nb2QvcFNDU0ksIHVzZSB0aGUgcmVzZXJ2YXRpb25zCisJICogb2YgdGhlIFVuZGVybHlpbmcgU0NTSSBoYXJkd2FyZS4gIEluIExpbnV4L1NDU0kgdGVybXMsIHRoaXMgY2FuCisJICogY2F1c2UgYSBwcm9ibGVtIGJlY2F1c2UgbGliYXRhIGFuZCBzb21lIFNBVEEgUkFJRCBIQkFzIGFwcGVhcgorCSAqIHVuZGVyIExpbnV4L1NDU0ksIGJ1dCB0byBlbXVsYXRlIHJlc2VydmF0aW9ucyB0aGVtc2VsdmVzLgorCSAqLworCWlmICgoKFRSQU5TUE9SVChkZXYpLT50cmFuc3BvcnRfdHlwZSA9PSBUUkFOU1BPUlRfUExVR0lOX1BIQkFfUERFVikgJiYKKwkgICAgIShERVZfQVRUUklCKGRldiktPmVtdWxhdGVfcmVzZXJ2YXRpb25zKSkgfHwgZm9yY2VfcHQpIHsKKwkJcmVzdC0+cmVzX3R5cGUgPSBTUENfUEFTU1RIUk9VR0g7CisJCXJlc3QtPnByX29wcy50MTBfcmVzZXJ2YXRpb25fY2hlY2sgPSAmY29yZV9wdF9yZXNlcnZhdGlvbl9jaGVjazsKKwkJcmVzdC0+cHJfb3BzLnQxMF9zZXFfbm9uX2hvbGRlciA9ICZjb3JlX3B0X3NlcV9ub25faG9sZGVyOworCQlwcmludGsoS0VSTl9JTkZPICIlczogVXNpbmcgU1BDX1BBU1NUSFJPVUdILCBubyByZXNlcnZhdGlvbiIKKwkJCSIgZW11bGF0aW9uXG4iLCBUUkFOU1BPUlQoZGV2KS0+bmFtZSk7CisJCXJldHVybiAwOworCX0KKwkvKgorCSAqIElmIFNQQy0zIG9yIGFib3ZlIGlzIHJlcG9ydGVkIGJ5IHJlYWwgb3IgZW11bGF0ZWQgc3RydWN0IHNlX2RldmljZSwKKwkgKiB1c2UgZW11bGF0ZWQgUGVyc2lzdGVudCBSZXNlcnZhdGlvbnMuCisJICovCisJaWYgKFRSQU5TUE9SVChkZXYpLT5nZXRfZGV2aWNlX3JldihkZXYpID49IFNDU0lfMykgeworCQlyZXN0LT5yZXNfdHlwZSA9IFNQQzNfUEVSU0lTVEVOVF9SRVNFUlZBVElPTlM7CisJCXJlc3QtPnByX29wcy50MTBfcmVzZXJ2YXRpb25fY2hlY2sgPSAmY29yZV9zY3NpM19wcl9yZXNlcnZhdGlvbl9jaGVjazsKKwkJcmVzdC0+cHJfb3BzLnQxMF9zZXFfbm9uX2hvbGRlciA9ICZjb3JlX3Njc2kzX3ByX3NlcV9ub25faG9sZGVyOworCQlwcmludGsoS0VSTl9JTkZPICIlczogVXNpbmcgU1BDM19QRVJTSVNURU5UX1JFU0VSVkFUSU9OUyIKKwkJCSIgZW11bGF0aW9uXG4iLCBUUkFOU1BPUlQoZGV2KS0+bmFtZSk7CisJfSBlbHNlIHsKKwkJcmVzdC0+cmVzX3R5cGUgPSBTUEMyX1JFU0VSVkFUSU9OUzsKKwkJcmVzdC0+cHJfb3BzLnQxMF9yZXNlcnZhdGlvbl9jaGVjayA9ICZjb3JlX3Njc2kyX3Jlc2VydmF0aW9uX2NoZWNrOworCQlyZXN0LT5wcl9vcHMudDEwX3NlcV9ub25faG9sZGVyID0KKwkJCQkmY29yZV9zY3NpMl9yZXNlcnZhdGlvbl9zZXFfbm9uX2hvbGRlcjsKKwkJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IFVzaW5nIFNQQzJfUkVTRVJWQVRJT05TIGVtdWxhdGlvblxuIiwKKwkJCVRSQU5TUE9SVChkZXYpLT5uYW1lKTsKKwl9CisKKwlyZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX3ByLmggYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9wci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU2MDNiY2YKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9wci5oCkBAIC0wLDAgKzEsNjcgQEAKKyNpZm5kZWYgVEFSR0VUX0NPUkVfUFJfSAorI2RlZmluZSBUQVJHRVRfQ09SRV9QUl9ICisvKgorICogUEVSU0lTVEVOVF9SRVNFUlZFX09VVCBzZXJ2aWNlIGFjdGlvbiBjb2RlcworICoKKyAqIHNwYzRyMTcgc2VjdGlvbiA2LjE0LjIgVGFibGUgMTcxCisgKi8KKyNkZWZpbmUgUFJPX1JFR0lTVEVSCQkJCTB4MDAKKyNkZWZpbmUgUFJPX1JFU0VSVkUJCQkJMHgwMQorI2RlZmluZSBQUk9fUkVMRUFTRQkJCQkweDAyCisjZGVmaW5lIFBST19DTEVBUgkJCQkweDAzCisjZGVmaW5lIFBST19QUkVFTVBUCQkJCTB4MDQKKyNkZWZpbmUgUFJPX1BSRUVNUFRfQU5EX0FCT1JUCQkJMHgwNQorI2RlZmluZSBQUk9fUkVHSVNURVJfQU5EX0lHTk9SRV9FWElTVElOR19LRVkJMHgwNgorI2RlZmluZSBQUk9fUkVHSVNURVJfQU5EX01PVkUJCQkweDA3CisvKgorICogUEVSU0lTVEVOVF9SRVNFUlZFX0lOIHNlcnZpY2UgYWN0aW9uIGNvZGVzCisgKgorICogc3BjNHIxNyBzZWN0aW9uIDYuMTMuMSBUYWJsZSAxNTkKKyAqLworI2RlZmluZSBQUklfUkVBRF9LRVlTCQkJCTB4MDAKKyNkZWZpbmUgUFJJX1JFQURfUkVTRVJWQVRJT04JCQkweDAxCisjZGVmaW5lIFBSSV9SRVBPUlRfQ0FQQUJJTElUSUVTCQkJMHgwMgorI2RlZmluZSBQUklfUkVBRF9GVUxMX1NUQVRVUwkJCTB4MDMKKy8qCisgKiBQRVJTSVNURU5UX1JFU0VSVkVfIFNDT1BFIGZpZWxkCisgKgorICogc3BjNHIxNyBzZWN0aW9uIDYuMTMuMy4zIFRhYmxlIDE2MworICovCisjZGVmaW5lIFBSX1NDT1BFX0xVX1NDT1BFCQkJMHgwMAorLyoKKyAqIFBFUlNJU1RFTlRfUkVTRVJWRV8qIFRZUEUgZmllbGQKKyAqCisgKiBzcGM0cjE3IHNlY3Rpb24gNi4xMy4zLjQgVGFibGUgMTY0CisgKi8KKyNkZWZpbmUgUFJfVFlQRV9XUklURV9FWENMVVNJVkUJCQkweDAxCisjZGVmaW5lIFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTUwkJMHgwMworI2RlZmluZSBQUl9UWVBFX1dSSVRFX0VYQ0xVU0lWRV9SRUdPTkxZCQkweDA1CisjZGVmaW5lIFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTU19SRUdPTkxZCTB4MDYKKyNkZWZpbmUgUFJfVFlQRV9XUklURV9FWENMVVNJVkVfQUxMUkVHCQkweDA3CisjZGVmaW5lIFBSX1RZUEVfRVhDTFVTSVZFX0FDQ0VTU19BTExSRUcJCTB4MDgKKworI2RlZmluZSBQUl9BUFRQTF9NQVhfSVBPUlRfTEVOCQkJMjU2CisjZGVmaW5lIFBSX0FQVFBMX01BWF9UUE9SVF9MRU4JCQkyNTYKKworZXh0ZXJuIHN0cnVjdCBrbWVtX2NhY2hlICp0MTBfcHJfcmVnX2NhY2hlOworCitleHRlcm4gaW50IGNvcmVfcHJfZHVtcF9pbml0aWF0b3JfcG9ydChzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqLAorCQkJY2hhciAqLCB1MzIpOworZXh0ZXJuIGludCBjb3JlX3Njc2kyX2VtdWxhdGVfY3JoKHN0cnVjdCBzZV9jbWQgKik7CitleHRlcm4gaW50IGNvcmVfc2NzaTNfYWxsb2NfYXB0cGxfcmVnaXN0cmF0aW9uKAorCQkJc3RydWN0IHQxMF9yZXNlcnZhdGlvbl90ZW1wbGF0ZSAqLCB1NjQsCisJCQl1bnNpZ25lZCBjaGFyICosIHVuc2lnbmVkIGNoYXIgKiwgdTMyLAorCQkJdW5zaWduZWQgY2hhciAqLCB1MTYsIHUzMiwgaW50LCBpbnQsIHU4KTsKK2V4dGVybiBpbnQgY29yZV9zY3NpM19jaGVja19hcHRwbF9yZWdpc3RyYXRpb24oc3RydWN0IHNlX2RldmljZSAqLAorCQkJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLCBzdHJ1Y3Qgc2VfbHVuICosCisJCQlzdHJ1Y3Qgc2VfbHVuX2FjbCAqKTsKK2V4dGVybiB2b2lkIGNvcmVfc2NzaTNfZnJlZV9wcl9yZWdfZnJvbV9uYWNsKHN0cnVjdCBzZV9kZXZpY2UgKiwKKwkJCQkJICAgICBzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKik7CitleHRlcm4gdm9pZCBjb3JlX3Njc2kzX2ZyZWVfYWxsX3JlZ2lzdHJhdGlvbnMoc3RydWN0IHNlX2RldmljZSAqKTsKK2V4dGVybiB1bnNpZ25lZCBjaGFyICpjb3JlX3Njc2kzX3ByX2R1bXBfdHlwZShpbnQpOworZXh0ZXJuIGludCBjb3JlX3Njc2kzX2NoZWNrX2NkYl9hYm9ydF9hbmRfcHJlZW1wdChzdHJ1Y3QgbGlzdF9oZWFkICosCisJCQkJCQkgIHN0cnVjdCBzZV9jbWQgKik7CitleHRlcm4gaW50IGNvcmVfc2NzaTNfZW11bGF0ZV9wcihzdHJ1Y3Qgc2VfY21kICopOworZXh0ZXJuIGludCBjb3JlX3NldHVwX3Jlc2VydmF0aW9ucyhzdHJ1Y3Qgc2VfZGV2aWNlICosIGludCk7CisKKyNlbmRpZiAvKiBUQVJHRVRfQ09SRV9QUl9IICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9wc2NzaS5jIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfcHNjc2kuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43NDJkMjQ2Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfcHNjc2kuYwpAQCAtMCwwICsxLDE0NzAgQEAKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBGaWxlbmFtZTogIHRhcmdldF9jb3JlX3BzY3NpLmMKKyAqCisgKiBUaGlzIGZpbGUgY29udGFpbnMgdGhlIGdlbmVyaWMgdGFyZ2V0IG1vZGUgPC0+IExpbnV4IFNDU0kgc3Vic3lzdGVtIHBsdWdpbi4KKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMDMsIDIwMDQsIDIwMDUgUHlYIFRlY2hub2xvZ2llcywgSW5jLgorICogQ29weXJpZ2h0IChjKSAyMDA1LCAyMDA2LCAyMDA3IFNCRSwgSW5jLgorICogQ29weXJpZ2h0IChjKSAyMDA3LTIwMTAgUmlzaW5nIFRpZGUgU3lzdGVtcworICogQ29weXJpZ2h0IChjKSAyMDA4LTIwMTAgTGludXgtaVNDU0kub3JnCisgKgorICogTmljaG9sYXMgQS4gQmVsbGluZ2VyIDxuYWJAa2VybmVsLm9yZz4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCisgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICoKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKyNpbmNsdWRlIDxsaW51eC92ZXJzaW9uLmg+CisjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CisjaW5jbHVkZSA8bGludXgvcGFyc2VyLmg+CisjaW5jbHVkZSA8bGludXgvdGltZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9ibGtkZXYuaD4KKyNpbmNsdWRlIDxsaW51eC9ibGtfdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KKyNpbmNsdWRlIDxsaW51eC9zbXBfbG9jay5oPgorI2luY2x1ZGUgPGxpbnV4L2dlbmhkLmg+CisjaW5jbHVkZSA8bGludXgvY2Ryb20uaD4KKyNpbmNsdWRlIDxsaW51eC9maWxlLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpX2RldmljZS5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV9jbW5kLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpX2hvc3QuaD4KKyNpbmNsdWRlIDxzY3NpL2xpYnNhcy5oPiAvKiBGb3IgVEFTS19BVFRSXyogKi8KKworI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9iYXNlLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV90cmFuc3BvcnQuaD4KKworI2luY2x1ZGUgInRhcmdldF9jb3JlX3BzY3NpLmgiCisKKyNkZWZpbmUgSVNQUklOVChhKSAgKChhID49ICcgJykgJiYgKGEgPD0gJ34nKSkKKworc3RhdGljIHN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpIHBzY3NpX3RlbXBsYXRlOworCitzdGF0aWMgdm9pZCBwc2NzaV9yZXFfZG9uZShzdHJ1Y3QgcmVxdWVzdCAqLCBpbnQpOworCisvKglwc2NzaV9nZXRfc2goKToKKyAqCisgKgorICovCitzdGF0aWMgc3RydWN0IFNjc2lfSG9zdCAqcHNjc2lfZ2V0X3NoKHUzMiBob3N0X25vKQoreworCXN0cnVjdCBTY3NpX0hvc3QgKnNoID0gTlVMTDsKKworCXNoID0gc2NzaV9ob3N0X2xvb2t1cChob3N0X25vKTsKKwlpZiAoSVNfRVJSKHNoKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2NhdGUgU0NTSSBIQkEgd2l0aCBIb3N0IElEOiIKKwkJCQkiICV1XG4iLCBob3N0X25vKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJcmV0dXJuIHNoOworfQorCisvKglwc2NzaV9hdHRhY2hfaGJhKCk6CisgKgorICogCXBzY3NpX2dldF9zaCgpIHVzZWQgc2NzaV9ob3N0X2xvb2t1cCgpIHRvIGxvY2F0ZSBzdHJ1Y3QgU2NzaV9Ib3N0LgorICoJZnJvbSB0aGUgcGFzc2VkIFNDU0kgSG9zdCBJRC4KKyAqLworc3RhdGljIGludCBwc2NzaV9hdHRhY2hfaGJhKHN0cnVjdCBzZV9oYmEgKmhiYSwgdTMyIGhvc3RfaWQpCit7CisJaW50IGhiYV9kZXB0aDsKKwlzdHJ1Y3QgcHNjc2lfaGJhX3ZpcnQgKnBodjsKKworCXBodiA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBwc2NzaV9oYmFfdmlydCksIEdGUF9LRVJORUwpOworCWlmICghKHBodikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgc3RydWN0IHBzY3NpX2hiYV92aXJ0XG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwlwaHYtPnBodl9ob3N0X2lkID0gaG9zdF9pZDsKKwlwaHYtPnBodl9tb2RlID0gUEhWX1ZJUlVUQUxfSE9TVF9JRDsKKwloYmFfZGVwdGggPSBQU0NTSV9WSVJUVUFMX0hCQV9ERVBUSDsKKwlhdG9taWNfc2V0KCZoYmEtPmxlZnRfcXVldWVfZGVwdGgsIGhiYV9kZXB0aCk7CisJYXRvbWljX3NldCgmaGJhLT5tYXhfcXVldWVfZGVwdGgsIGhiYV9kZXB0aCk7CisKKwloYmEtPmhiYV9wdHIgPSAodm9pZCAqKXBodjsKKworCXByaW50ayhLRVJOX0lORk8gIkNPUkVfSEJBWyVkXSAtIFRDTSBTQ1NJIEhCQSBEcml2ZXIgJXMgb24iCisJCSIgR2VuZXJpYyBUYXJnZXQgQ29yZSBTdGFjayAlc1xuIiwgaGJhLT5oYmFfaWQsCisJCVBTQ1NJX1ZFUlNJT04sIFRBUkdFVF9DT1JFX01PRF9WRVJTSU9OKTsKKwlwcmludGsoS0VSTl9JTkZPICJDT1JFX0hCQVslZF0gLSBBdHRhY2hlZCBTQ1NJIEhCQSB0byBHZW5lcmljIgorCQkiIFRhcmdldCBDb3JlIHdpdGggVENRIERlcHRoOiAlZFxuIiwgaGJhLT5oYmFfaWQsCisJCWF0b21pY19yZWFkKCZoYmEtPm1heF9xdWV1ZV9kZXB0aCkpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIHBzY3NpX2RldGFjaF9oYmEoc3RydWN0IHNlX2hiYSAqaGJhKQoreworCXN0cnVjdCBwc2NzaV9oYmFfdmlydCAqcGh2ID0gaGJhLT5oYmFfcHRyOworCXN0cnVjdCBTY3NpX0hvc3QgKnNjc2lfaG9zdCA9IHBodi0+cGh2X2xsZF9ob3N0OworCisJaWYgKHNjc2lfaG9zdCkgeworCQlzY3NpX2hvc3RfcHV0KHNjc2lfaG9zdCk7CisKKwkJcHJpbnRrKEtFUk5fSU5GTyAiQ09SRV9IQkFbJWRdIC0gRGV0YWNoZWQgU0NTSSBIQkE6ICVzIGZyb20iCisJCQkiIEdlbmVyaWMgVGFyZ2V0IENvcmVcbiIsIGhiYS0+aGJhX2lkLAorCQkJKHNjc2lfaG9zdC0+aG9zdHQtPm5hbWUpID8gKHNjc2lfaG9zdC0+aG9zdHQtPm5hbWUpIDoKKwkJCSJVbmtub3duIik7CisJfSBlbHNlCisJCXByaW50ayhLRVJOX0lORk8gIkNPUkVfSEJBWyVkXSAtIERldGFjaGVkIFZpcnR1YWwgU0NTSSBIQkEiCisJCQkiIGZyb20gR2VuZXJpYyBUYXJnZXQgQ29yZVxuIiwgaGJhLT5oYmFfaWQpOworCisJa2ZyZWUocGh2KTsKKwloYmEtPmhiYV9wdHIgPSBOVUxMOworfQorCitzdGF0aWMgaW50IHBzY3NpX3Btb2RlX2VuYWJsZV9oYmEoc3RydWN0IHNlX2hiYSAqaGJhLCB1bnNpZ25lZCBsb25nIG1vZGVfZmxhZykKK3sKKwlzdHJ1Y3QgcHNjc2lfaGJhX3ZpcnQgKnBodiA9IChzdHJ1Y3QgcHNjc2lfaGJhX3ZpcnQgKiloYmEtPmhiYV9wdHI7CisJc3RydWN0IFNjc2lfSG9zdCAqc2ggPSBwaHYtPnBodl9sbGRfaG9zdDsKKwlpbnQgaGJhX2RlcHRoID0gUFNDU0lfVklSVFVBTF9IQkFfREVQVEg7CisJLyoKKwkgKiBSZWxlYXNlIHRoZSBzdHJ1Y3QgU2NzaV9Ib3N0CisJICovCisJaWYgKCEobW9kZV9mbGFnKSkgeworCQlpZiAoIShzaCkpCisJCQlyZXR1cm4gMDsKKworCQlwaHYtPnBodl9sbGRfaG9zdCA9IE5VTEw7CisJCXBodi0+cGh2X21vZGUgPSBQSFZfVklSVVRBTF9IT1NUX0lEOworCQlhdG9taWNfc2V0KCZoYmEtPmxlZnRfcXVldWVfZGVwdGgsIGhiYV9kZXB0aCk7CisJCWF0b21pY19zZXQoJmhiYS0+bWF4X3F1ZXVlX2RlcHRoLCBoYmFfZGVwdGgpOworCisJCXByaW50ayhLRVJOX0lORk8gIkNPUkVfSEJBWyVkXSAtIERpc2FibGVkIHBTQ1NJIEhCQSBQYXNzdGhyb3VnaCIKKwkJCSIgJXNcbiIsIGhiYS0+aGJhX2lkLCAoc2gtPmhvc3R0LT5uYW1lKSA/CisJCQkoc2gtPmhvc3R0LT5uYW1lKSA6ICJVbmtub3duIik7CisKKwkJc2NzaV9ob3N0X3B1dChzaCk7CisJCXJldHVybiAwOworCX0KKwkvKgorCSAqIE90aGVyd2lzZSwgbG9jYXRlIHN0cnVjdCBTY3NpX0hvc3QgZnJvbSB0aGUgb3JpZ2luYWwgcGFzc2VkCisJICogcFNDU0kgSG9zdCBJRCBhbmQgZW5hYmxlIGZvciBwaGJhIG1vZGUKKwkgKi8KKwlzaCA9IHBzY3NpX2dldF9zaChwaHYtPnBodl9ob3N0X2lkKTsKKwlpZiAoIShzaCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJwU0NTSTogVW5hYmxlIHRvIGxvY2F0ZSBTQ1NJIEhvc3QgZm9yIgorCQkJIiBwaHZfaG9zdF9pZDogJWRcbiIsIHBodi0+cGh2X2hvc3RfaWQpOworCQlyZXR1cm4gLTE7CisJfQorCS8qCisJICogVXN1YWxseSB0aGUgU0NTSSBMTEQgd2lsbCB1c2UgdGhlIGhvc3R0LT5jYW5fcXVldWUgdmFsdWUgdG8gZGVmaW5lCisJICogaXRzIEhCQSBUQ1EgZGVwdGguICBTb21lIG90aGVyIGRyaXZlcnMgKGxpa2UgMi42IG1lZ2FyYWlkKSBkb24ndCBzZXQKKwkgKiB0aGlzIGF0IGFsbCBhbmQgc2V0IHNoLT5jYW5fcXVldWUgYXQgcnVudGltZS4KKwkgKi8KKwloYmFfZGVwdGggPSAoc2gtPmhvc3R0LT5jYW5fcXVldWUgPiBzaC0+Y2FuX3F1ZXVlKSA/CisJCXNoLT5ob3N0dC0+Y2FuX3F1ZXVlIDogc2gtPmNhbl9xdWV1ZTsKKworCWF0b21pY19zZXQoJmhiYS0+bGVmdF9xdWV1ZV9kZXB0aCwgaGJhX2RlcHRoKTsKKwlhdG9taWNfc2V0KCZoYmEtPm1heF9xdWV1ZV9kZXB0aCwgaGJhX2RlcHRoKTsKKworCXBodi0+cGh2X2xsZF9ob3N0ID0gc2g7CisJcGh2LT5waHZfbW9kZSA9IFBIVl9MTERfU0NTSV9IT1NUX05POworCisJcHJpbnRrKEtFUk5fSU5GTyAiQ09SRV9IQkFbJWRdIC0gRW5hYmxlZCBwU0NTSSBIQkEgUGFzc3Rocm91Z2ggJXNcbiIsCisJCWhiYS0+aGJhX2lkLCAoc2gtPmhvc3R0LT5uYW1lKSA/IChzaC0+aG9zdHQtPm5hbWUpIDogIlVua25vd24iKTsKKworCXJldHVybiAxOworfQorCitzdGF0aWMgdm9pZCBwc2NzaV90YXBlX3JlYWRfYmxvY2tzaXplKHN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwkJc3RydWN0IHNjc2lfZGV2aWNlICpzZGV2KQoreworCXVuc2lnbmVkIGNoYXIgY2RiW01BWF9DT01NQU5EX1NJWkVdLCAqYnVmOworCWludCByZXQ7CisKKwlidWYgPSBremFsbG9jKDEyLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWJ1ZikKKwkJcmV0dXJuOworCisJbWVtc2V0KGNkYiwgMCwgTUFYX0NPTU1BTkRfU0laRSk7CisJY2RiWzBdID0gTU9ERV9TRU5TRTsKKwljZGJbNF0gPSAweDBjOyAvKiAxMiBieXRlcyAqLworCisJcmV0ID0gc2NzaV9leGVjdXRlX3JlcShzZGV2LCBjZGIsIERNQV9GUk9NX0RFVklDRSwgYnVmLCAxMiwgTlVMTCwKKwkJCUhaLCAxLCBOVUxMKTsKKwlpZiAocmV0KQorCQlnb3RvIG91dF9mcmVlOworCisJLyoKKwkgKiBJZiBNT0RFX1NFTlNFIHN0aWxsIHJldHVybnMgemVybywgc2V0IHRoZSBkZWZhdWx0IHZhbHVlIHRvIDEwMjQuCisJICovCisJc2Rldi0+c2VjdG9yX3NpemUgPSAoYnVmWzldIDw8IDE2KSB8IChidWZbMTBdIDw8IDgpIHwgKGJ1ZlsxMV0pOworCWlmICghc2Rldi0+c2VjdG9yX3NpemUpCisJCXNkZXYtPnNlY3Rvcl9zaXplID0gMTAyNDsKK291dF9mcmVlOgorCWtmcmVlKGJ1Zik7Cit9CisKK3N0YXRpYyB2b2lkCitwc2NzaV9zZXRfaW5xdWlyeV9pbmZvKHN0cnVjdCBzY3NpX2RldmljZSAqc2Rldiwgc3RydWN0IHQxMF93d24gKnd3bikKK3sKKwl1bnNpZ25lZCBjaGFyICpidWY7CisKKwlpZiAoc2Rldi0+aW5xdWlyeV9sZW4gPCBJTlFVSVJZX0xFTikKKwkJcmV0dXJuOworCisJYnVmID0gc2Rldi0+aW5xdWlyeTsKKwlpZiAoIWJ1ZikKKwkJcmV0dXJuOworCS8qCisJICogVXNlIHNkZXYtPmlucXVpcnkgZnJvbSBkcml2ZXJzL3Njc2kvc2NzaV9zY2FuLmM6c2NzaV9hbGxvY19zZGV2KCkKKwkgKi8KKwltZW1jcHkoJnd3bi0+dmVuZG9yWzBdLCAmYnVmWzhdLCBzaXplb2Yod3duLT52ZW5kb3IpKTsKKwltZW1jcHkoJnd3bi0+bW9kZWxbMF0sICZidWZbMTZdLCBzaXplb2Yod3duLT5tb2RlbCkpOworCW1lbWNweSgmd3duLT5yZXZpc2lvblswXSwgJmJ1ZlszMl0sIHNpemVvZih3d24tPnJldmlzaW9uKSk7Cit9CisKK3N0YXRpYyBpbnQKK3BzY3NpX2dldF9pbnF1aXJ5X3ZwZF9zZXJpYWwoc3RydWN0IHNjc2lfZGV2aWNlICpzZGV2LCBzdHJ1Y3QgdDEwX3d3biAqd3duKQoreworCXVuc2lnbmVkIGNoYXIgY2RiW01BWF9DT01NQU5EX1NJWkVdLCAqYnVmOworCWludCByZXQ7CisKKwlidWYgPSBremFsbG9jKElOUVVJUllfVlBEX1NFUklBTF9MRU4sIEdGUF9LRVJORUwpOworCWlmICghYnVmKQorCQlyZXR1cm4gLTE7CisKKwltZW1zZXQoY2RiLCAwLCBNQVhfQ09NTUFORF9TSVpFKTsKKwljZGJbMF0gPSBJTlFVSVJZOworCWNkYlsxXSA9IDB4MDE7IC8qIFF1ZXJ5IFZQRCAqLworCWNkYlsyXSA9IDB4ODA7IC8qIFVuaXQgU2VyaWFsIE51bWJlciAqLworCWNkYlszXSA9IChJTlFVSVJZX1ZQRF9TRVJJQUxfTEVOID4+IDgpICYgMHhmZjsKKwljZGJbNF0gPSAoSU5RVUlSWV9WUERfU0VSSUFMX0xFTiAmIDB4ZmYpOworCisJcmV0ID0gc2NzaV9leGVjdXRlX3JlcShzZGV2LCBjZGIsIERNQV9GUk9NX0RFVklDRSwgYnVmLAorCQkJICAgICAgSU5RVUlSWV9WUERfU0VSSUFMX0xFTiwgTlVMTCwgSFosIDEsIE5VTEwpOworCWlmIChyZXQpCisJCWdvdG8gb3V0X2ZyZWU7CisKKwlzbnByaW50Zigmd3duLT51bml0X3NlcmlhbFswXSwgSU5RVUlSWV9WUERfU0VSSUFMX0xFTiwgIiVzIiwgJmJ1Zls0XSk7CisKKwl3d24tPnQxMF9zdWJfZGV2LT5zdV9kZXZfZmxhZ3MgfD0gU0RGX0ZJUk1XQVJFX1ZQRF9VTklUX1NFUklBTDsKKworCWtmcmVlKGJ1Zik7CisJcmV0dXJuIDA7CisKK291dF9mcmVlOgorCWtmcmVlKGJ1Zik7CisJcmV0dXJuIC0xOworfQorCitzdGF0aWMgdm9pZAorcHNjc2lfZ2V0X2lucXVpcnlfdnBkX2RldmljZV9pZGVudChzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnNkZXYsCisJCXN0cnVjdCB0MTBfd3duICp3d24pCit7CisJdW5zaWduZWQgY2hhciBjZGJbTUFYX0NPTU1BTkRfU0laRV0sICpidWYsICpwYWdlXzgzOworCWludCBpZGVudF9sZW4sIHBhZ2VfbGVuLCBvZmYgPSA0LCByZXQ7CisJc3RydWN0IHQxMF92cGQgKnZwZDsKKworCWJ1ZiA9IGt6YWxsb2MoSU5RVUlSWV9WUERfU0VSSUFMX0xFTiwgR0ZQX0tFUk5FTCk7CisJaWYgKCFidWYpCisJCXJldHVybjsKKworCW1lbXNldChjZGIsIDAsIE1BWF9DT01NQU5EX1NJWkUpOworCWNkYlswXSA9IElOUVVJUlk7CisJY2RiWzFdID0gMHgwMTsgLyogUXVlcnkgVlBEICovCisJY2RiWzJdID0gMHg4MzsgLyogRGV2aWNlIElkZW50aWZpZXIgKi8KKwljZGJbM10gPSAoSU5RVUlSWV9WUERfREVWSUNFX0lERU5USUZJRVJfTEVOID4+IDgpICYgMHhmZjsKKwljZGJbNF0gPSAoSU5RVUlSWV9WUERfREVWSUNFX0lERU5USUZJRVJfTEVOICYgMHhmZik7CisKKwlyZXQgPSBzY3NpX2V4ZWN1dGVfcmVxKHNkZXYsIGNkYiwgRE1BX0ZST01fREVWSUNFLCBidWYsCisJCQkgICAgICBJTlFVSVJZX1ZQRF9ERVZJQ0VfSURFTlRJRklFUl9MRU4sCisJCQkgICAgICBOVUxMLCBIWiwgMSwgTlVMTCk7CisJaWYgKHJldCkKKwkJZ290byBvdXQ7CisKKwlwYWdlX2xlbiA9IChidWZbMl0gPDwgOCkgfCBidWZbM107CisJd2hpbGUgKHBhZ2VfbGVuID4gMCkgeworCQkvKiBHcmFiIGEgcG9pbnRlciB0byB0aGUgSWRlbnRpZmljYXRpb24gZGVzY3JpcHRvciAqLworCQlwYWdlXzgzID0gJmJ1ZltvZmZdOworCQlpZGVudF9sZW4gPSBwYWdlXzgzWzNdOworCQlpZiAoIWlkZW50X2xlbikgeworCQkJcHJpbnRrKEtFUk5fRVJSICJwYWdlXzgzWzNdOiBpZGVudGlmaWVyIgorCQkJCQkiIGxlbmd0aCB6ZXJvIVxuIik7CisJCQlicmVhazsKKwkJfQorCQlwcmludGsoS0VSTl9JTkZPICJUMTAgVlBEIElkZW50aWZlciBMZW5ndGg6ICVkXG4iLCBpZGVudF9sZW4pOworCisJCXZwZCA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCB0MTBfdnBkKSwgR0ZQX0tFUk5FTCk7CisJCWlmICghdnBkKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIgorCQkJCQkiIHN0cnVjdCB0MTBfdnBkXG4iKTsKKwkJCWdvdG8gb3V0OworCQl9CisJCUlOSVRfTElTVF9IRUFEKCZ2cGQtPnZwZF9saXN0KTsKKworCQl0cmFuc3BvcnRfc2V0X3ZwZF9wcm90b19pZCh2cGQsIHBhZ2VfODMpOworCQl0cmFuc3BvcnRfc2V0X3ZwZF9hc3NvYyh2cGQsIHBhZ2VfODMpOworCisJCWlmICh0cmFuc3BvcnRfc2V0X3ZwZF9pZGVudF90eXBlKHZwZCwgcGFnZV84MykgPCAwKSB7CisJCQlvZmYgKz0gKGlkZW50X2xlbiArIDQpOworCQkJcGFnZV9sZW4gLT0gKGlkZW50X2xlbiArIDQpOworCQkJa2ZyZWUodnBkKTsKKwkJCWNvbnRpbnVlOworCQl9CisJCWlmICh0cmFuc3BvcnRfc2V0X3ZwZF9pZGVudCh2cGQsIHBhZ2VfODMpIDwgMCkgeworCQkJb2ZmICs9IChpZGVudF9sZW4gKyA0KTsKKwkJCXBhZ2VfbGVuIC09IChpZGVudF9sZW4gKyA0KTsKKwkJCWtmcmVlKHZwZCk7CisJCQljb250aW51ZTsKKwkJfQorCisJCWxpc3RfYWRkX3RhaWwoJnZwZC0+dnBkX2xpc3QsICZ3d24tPnQxMF92cGRfbGlzdCk7CisJCW9mZiArPSAoaWRlbnRfbGVuICsgNCk7CisJCXBhZ2VfbGVuIC09IChpZGVudF9sZW4gKyA0KTsKKwl9CisKK291dDoKKwlrZnJlZShidWYpOworfQorCisvKglwc2NzaV9hZGRfZGV2aWNlX3RvX2xpc3QoKToKKyAqCisgKgorICovCitzdGF0aWMgc3RydWN0IHNlX2RldmljZSAqcHNjc2lfYWRkX2RldmljZV90b19saXN0KAorCXN0cnVjdCBzZV9oYmEgKmhiYSwKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc2VfZGV2LAorCXN0cnVjdCBwc2NzaV9kZXZfdmlydCAqcGR2LAorCXN0cnVjdCBzY3NpX2RldmljZSAqc2QsCisJaW50IGRldl9mbGFncykKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXY7CisJc3RydWN0IHNlX2Rldl9saW1pdHMgZGV2X2xpbWl0czsKKwlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcTsKKwlzdHJ1Y3QgcXVldWVfbGltaXRzICpsaW1pdHM7CisKKwltZW1zZXQoJmRldl9saW1pdHMsIDAsIHNpemVvZihzdHJ1Y3Qgc2VfZGV2X2xpbWl0cykpOworCisJaWYgKCFzZC0+cXVldWVfZGVwdGgpIHsKKwkJc2QtPnF1ZXVlX2RlcHRoID0gUFNDU0lfREVGQVVMVF9RVUVVRURFUFRIOworCisJCXByaW50ayhLRVJOX0VSUiAiU2V0IGJyb2tlbiBTQ1NJIERldmljZSAlZDolZDolZCIKKwkJCSIgcXVldWVfZGVwdGggdG8gJWRcbiIsIHNkLT5jaGFubmVsLCBzZC0+aWQsCisJCQkJc2QtPmx1biwgc2QtPnF1ZXVlX2RlcHRoKTsKKwl9CisJLyoKKwkgKiBTZXR1cCB0aGUgbG9jYWwgc2NvcGUgcXVldWVfbGltaXRzIGZyb20gc3RydWN0IHJlcXVlc3RfcXVldWUtPmxpbWl0cworCSAqIHRvIHBhc3MgaW50byB0cmFuc3BvcnRfYWRkX2RldmljZV90b19jb3JlX2hiYSgpIGFzIHN0cnVjdCBzZV9kZXZfbGltaXRzLgorCSAqLworCXEgPSBzZC0+cmVxdWVzdF9xdWV1ZTsKKwlsaW1pdHMgPSAmZGV2X2xpbWl0cy5saW1pdHM7CisJbGltaXRzLT5sb2dpY2FsX2Jsb2NrX3NpemUgPSBzZC0+c2VjdG9yX3NpemU7CisJbGltaXRzLT5tYXhfaHdfc2VjdG9ycyA9IChzZC0+aG9zdC0+bWF4X3NlY3RvcnMgPiBxdWV1ZV9tYXhfaHdfc2VjdG9ycyhxKSkgPworCQkJCSAgcXVldWVfbWF4X2h3X3NlY3RvcnMocSkgOiBzZC0+aG9zdC0+bWF4X3NlY3RvcnM7CisJbGltaXRzLT5tYXhfc2VjdG9ycyA9IChzZC0+aG9zdC0+bWF4X3NlY3RvcnMgPiBxdWV1ZV9tYXhfc2VjdG9ycyhxKSkgPworCQkJCSAgcXVldWVfbWF4X3NlY3RvcnMocSkgOiBzZC0+aG9zdC0+bWF4X3NlY3RvcnM7CisJZGV2X2xpbWl0cy5od19xdWV1ZV9kZXB0aCA9IHNkLT5xdWV1ZV9kZXB0aDsKKwlkZXZfbGltaXRzLnF1ZXVlX2RlcHRoID0gc2QtPnF1ZXVlX2RlcHRoOworCS8qCisJICogU2V0dXAgb3VyIHN0YW5kYXJkIElOUVVJUlkgaW5mbyBpbnRvIHNlX2Rldi0+dDEwX3d3bgorCSAqLworCXBzY3NpX3NldF9pbnF1aXJ5X2luZm8oc2QsICZzZV9kZXYtPnQxMF93d24pOworCisJLyoKKwkgKiBTZXQgdGhlIHBvaW50ZXIgcGR2LT5wZHZfc2QgdG8gZnJvbSBwYXNzZWQgc3RydWN0IHNjc2lfZGV2aWNlLAorCSAqIHdoaWNoIGhhcyBhbHJlYWR5IGJlZW4gcmVmZXJlbmNlZCB3aXRoIExpbnV4IFNDU0kgY29kZSB3aXRoCisJICogc2NzaV9kZXZpY2VfZ2V0KCkgaW4gdGhpcyBmaWxlJ3MgcHNjc2lfY3JlYXRlX3ZpcnRkZXZpY2UoKS4KKwkgKgorCSAqIFRoZSBwYXNzdGhyb3VnaCBvcGVyYXRpb25zIGNhbGxlZCBieSB0aGUgdHJhbnNwb3J0X2FkZF9kZXZpY2VfKgorCSAqIGZ1bmN0aW9uIGJlbG93IHdpbGwgcmVxdWlyZSB0aGlzIHBvaW50ZXIgdG8gYmUgc2V0IGZvciBwYXNzdGhyb3VnCisJICogIG9wcy4KKwkgKgorCSAqIEZvciB0aGUgc2h1dGRvd24gY2FzZSBpbiBwc2NzaV9mcmVlX2RldmljZSgpLCB0aGlzIHN0cnVjdAorCSAqIHNjc2lfZGV2aWNlICByZWZlcmVuY2UgaXMgcmVsZWFzZWQgd2l0aCBMaW51eCBTQ1NJIGNvZGUKKwkgKiBzY3NpX2RldmljZV9wdXQoKSBhbmQgdGhlIHBkdi0+cGR2X3NkIGNsZWFyZWQuCisJICovCisJcGR2LT5wZHZfc2QgPSBzZDsKKworCWRldiA9IHRyYW5zcG9ydF9hZGRfZGV2aWNlX3RvX2NvcmVfaGJhKGhiYSwgJnBzY3NpX3RlbXBsYXRlLAorCQkJCXNlX2RldiwgZGV2X2ZsYWdzLCAodm9pZCAqKXBkdiwKKwkJCQkmZGV2X2xpbWl0cywgTlVMTCwgTlVMTCk7CisJaWYgKCEoZGV2KSkgeworCQlwZHYtPnBkdl9zZCA9IE5VTEw7CisJCXJldHVybiBOVUxMOworCX0KKworCS8qCisJICogTG9jYXRlIFZQRCBXV04gSW5mb3JtYXRpb24gdXNlZCBmb3IgdmFyaW91cyBwdXJwb3NlcyB3aXRoaW4KKwkgKiB0aGUgU3RvcmFnZSBFbmdpbmUuCisJICovCisJaWYgKCFwc2NzaV9nZXRfaW5xdWlyeV92cGRfc2VyaWFsKHNkLCAmc2VfZGV2LT50MTBfd3duKSkgeworCQkvKgorCQkgKiBJZiBWUEQgVW5pdCBTZXJpYWwgcmV0dXJuZWQgR09PRCBzdGF0dXMsIHRyeQorCQkgKiBWUEQgRGV2aWNlIElkZW50aWZpY2F0aW9uIHBhZ2UgKDB4ODMpLgorCQkgKi8KKwkJcHNjc2lfZ2V0X2lucXVpcnlfdnBkX2RldmljZV9pZGVudChzZCwgJnNlX2Rldi0+dDEwX3d3bik7CisJfQorCisJLyoKKwkgKiBGb3IgVFlQRV9UQVBFLCBhdHRlbXB0IHRvIGRldGVybWluZSBibG9ja3NpemUgd2l0aCBNT0RFX1NFTlNFLgorCSAqLworCWlmIChzZC0+dHlwZSA9PSBUWVBFX1RBUEUpCisJCXBzY3NpX3RhcGVfcmVhZF9ibG9ja3NpemUoZGV2LCBzZCk7CisJcmV0dXJuIGRldjsKK30KKworc3RhdGljIHZvaWQgKnBzY3NpX2FsbG9jYXRlX3ZpcnRkZXZpY2Uoc3RydWN0IHNlX2hiYSAqaGJhLCBjb25zdCBjaGFyICpuYW1lKQoreworCXN0cnVjdCBwc2NzaV9kZXZfdmlydCAqcGR2OworCisJcGR2ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHBzY3NpX2Rldl92aXJ0KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCEocGR2KSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIHN0cnVjdCBwc2NzaV9kZXZfdmlydFxuIik7CisJCXJldHVybiBOVUxMOworCX0KKwlwZHYtPnBkdl9zZV9oYmEgPSBoYmE7CisKKwlwcmludGsoS0VSTl9JTkZPICJQU0NTSTogQWxsb2NhdGVkIHBkdjogJXAgZm9yICVzXG4iLCBwZHYsIG5hbWUpOworCXJldHVybiAodm9pZCAqKXBkdjsKK30KKworLyoKKyAqIENhbGxlZCB3aXRoIHN0cnVjdCBTY3NpX0hvc3QtPmhvc3RfbG9jayBjYWxsZWQuCisgKi8KK3N0YXRpYyBzdHJ1Y3Qgc2VfZGV2aWNlICpwc2NzaV9jcmVhdGVfdHlwZV9kaXNrKAorCXN0cnVjdCBzY3NpX2RldmljZSAqc2QsCisJc3RydWN0IHBzY3NpX2Rldl92aXJ0ICpwZHYsCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiwKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2OworCXN0cnVjdCBwc2NzaV9oYmFfdmlydCAqcGh2ID0gKHN0cnVjdCBwc2NzaV9oYmFfdmlydCAqKXBkdi0+cGR2X3NlX2hiYS0+aGJhX3B0cjsKKwlzdHJ1Y3QgU2NzaV9Ib3N0ICpzaCA9IHNkLT5ob3N0OworCXN0cnVjdCBibG9ja19kZXZpY2UgKmJkOworCXUzMiBkZXZfZmxhZ3MgPSAwOworCisJaWYgKHNjc2lfZGV2aWNlX2dldChzZCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJzY3NpX2RldmljZV9nZXQoKSBmYWlsZWQgZm9yICVkOiVkOiVkOiVkXG4iLAorCQkJc2gtPmhvc3Rfbm8sIHNkLT5jaGFubmVsLCBzZC0+aWQsIHNkLT5sdW4pOworCQlzcGluX3VubG9ja19pcnEoc2gtPmhvc3RfbG9jayk7CisJCXJldHVybiBOVUxMOworCX0KKwlzcGluX3VubG9ja19pcnEoc2gtPmhvc3RfbG9jayk7CisJLyoKKwkgKiBDbGFpbSBleGNsdXNpdmUgc3RydWN0IGJsb2NrX2RldmljZSBhY2Nlc3MgdG8gc3RydWN0IHNjc2lfZGV2aWNlCisJICogZm9yIFRZUEVfRElTSyB1c2luZyBzdXBwbGllZCB1ZGV2X3BhdGgKKwkgKi8KKwliZCA9IGJsa2Rldl9nZXRfYnlfcGF0aChzZV9kZXYtPnNlX2Rldl91ZGV2X3BhdGgsCisJCQkJRk1PREVfV1JJVEV8Rk1PREVfUkVBRHxGTU9ERV9FWENMLCBwZHYpOworCWlmICghKGJkKSkgeworCQlwcmludGsoInBTQ1NJOiBibGtkZXZfZ2V0X2J5X3BhdGgoKSBmYWlsZWRcbiIpOworCQlzY3NpX2RldmljZV9wdXQoc2QpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJcGR2LT5wZHZfYmQgPSBiZDsKKworCWRldiA9IHBzY3NpX2FkZF9kZXZpY2VfdG9fbGlzdChoYmEsIHNlX2RldiwgcGR2LCBzZCwgZGV2X2ZsYWdzKTsKKwlpZiAoIShkZXYpKSB7CisJCWJsa2Rldl9wdXQocGR2LT5wZHZfYmQsIEZNT0RFX1dSSVRFfEZNT0RFX1JFQUR8Rk1PREVfRVhDTCk7CisJCXNjc2lfZGV2aWNlX3B1dChzZCk7CisJCXJldHVybiBOVUxMOworCX0KKwlwcmludGsoS0VSTl9JTkZPICJDT1JFX1BTQ1NJWyVkXSAtIEFkZGVkIFRZUEVfRElTSyBmb3IgJWQ6JWQ6JWQ6JWRcbiIsCisJCXBodi0+cGh2X2hvc3RfaWQsIHNoLT5ob3N0X25vLCBzZC0+Y2hhbm5lbCwgc2QtPmlkLCBzZC0+bHVuKTsKKworCXJldHVybiBkZXY7Cit9CisKKy8qCisgKiBDYWxsZWQgd2l0aCBzdHJ1Y3QgU2NzaV9Ib3N0LT5ob3N0X2xvY2sgY2FsbGVkLgorICovCitzdGF0aWMgc3RydWN0IHNlX2RldmljZSAqcHNjc2lfY3JlYXRlX3R5cGVfcm9tKAorCXN0cnVjdCBzY3NpX2RldmljZSAqc2QsCisJc3RydWN0IHBzY3NpX2Rldl92aXJ0ICpwZHYsCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiwKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2OworCXN0cnVjdCBwc2NzaV9oYmFfdmlydCAqcGh2ID0gKHN0cnVjdCBwc2NzaV9oYmFfdmlydCAqKXBkdi0+cGR2X3NlX2hiYS0+aGJhX3B0cjsKKwlzdHJ1Y3QgU2NzaV9Ib3N0ICpzaCA9IHNkLT5ob3N0OworCXUzMiBkZXZfZmxhZ3MgPSAwOworCisJaWYgKHNjc2lfZGV2aWNlX2dldChzZCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJzY3NpX2RldmljZV9nZXQoKSBmYWlsZWQgZm9yICVkOiVkOiVkOiVkXG4iLAorCQkJc2gtPmhvc3Rfbm8sIHNkLT5jaGFubmVsLCBzZC0+aWQsIHNkLT5sdW4pOworCQlzcGluX3VubG9ja19pcnEoc2gtPmhvc3RfbG9jayk7CisJCXJldHVybiBOVUxMOworCX0KKwlzcGluX3VubG9ja19pcnEoc2gtPmhvc3RfbG9jayk7CisKKwlkZXYgPSBwc2NzaV9hZGRfZGV2aWNlX3RvX2xpc3QoaGJhLCBzZV9kZXYsIHBkdiwgc2QsIGRldl9mbGFncyk7CisJaWYgKCEoZGV2KSkgeworCQlzY3NpX2RldmljZV9wdXQoc2QpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJcHJpbnRrKEtFUk5fSU5GTyAiQ09SRV9QU0NTSVslZF0gLSBBZGRlZCBUeXBlOiAlcyBmb3IgJWQ6JWQ6JWQ6JWRcbiIsCisJCXBodi0+cGh2X2hvc3RfaWQsIHNjc2lfZGV2aWNlX3R5cGUoc2QtPnR5cGUpLCBzaC0+aG9zdF9ubywKKwkJc2QtPmNoYW5uZWwsIHNkLT5pZCwgc2QtPmx1bik7CisKKwlyZXR1cm4gZGV2OworfQorCisvKgorICpDYWxsZWQgd2l0aCBzdHJ1Y3QgU2NzaV9Ib3N0LT5ob3N0X2xvY2sgY2FsbGVkLgorICovCitzdGF0aWMgc3RydWN0IHNlX2RldmljZSAqcHNjc2lfY3JlYXRlX3R5cGVfb3RoZXIoCisJc3RydWN0IHNjc2lfZGV2aWNlICpzZCwKKwlzdHJ1Y3QgcHNjc2lfZGV2X3ZpcnQgKnBkdiwKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc2VfZGV2LAorCXN0cnVjdCBzZV9oYmEgKmhiYSkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXY7CisJc3RydWN0IHBzY3NpX2hiYV92aXJ0ICpwaHYgPSAoc3RydWN0IHBzY3NpX2hiYV92aXJ0ICopcGR2LT5wZHZfc2VfaGJhLT5oYmFfcHRyOworCXN0cnVjdCBTY3NpX0hvc3QgKnNoID0gc2QtPmhvc3Q7CisJdTMyIGRldl9mbGFncyA9IDA7CisKKwlzcGluX3VubG9ja19pcnEoc2gtPmhvc3RfbG9jayk7CisJZGV2ID0gcHNjc2lfYWRkX2RldmljZV90b19saXN0KGhiYSwgc2VfZGV2LCBwZHYsIHNkLCBkZXZfZmxhZ3MpOworCWlmICghKGRldikpCisJCXJldHVybiBOVUxMOworCisJcHJpbnRrKEtFUk5fSU5GTyAiQ09SRV9QU0NTSVslZF0gLSBBZGRlZCBUeXBlOiAlcyBmb3IgJWQ6JWQ6JWQ6JWRcbiIsCisJCXBodi0+cGh2X2hvc3RfaWQsIHNjc2lfZGV2aWNlX3R5cGUoc2QtPnR5cGUpLCBzaC0+aG9zdF9ubywKKwkJc2QtPmNoYW5uZWwsIHNkLT5pZCwgc2QtPmx1bik7CisKKwlyZXR1cm4gZGV2OworfQorCitzdGF0aWMgc3RydWN0IHNlX2RldmljZSAqcHNjc2lfY3JlYXRlX3ZpcnRkZXZpY2UoCisJc3RydWN0IHNlX2hiYSAqaGJhLAorCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzZV9kZXYsCisJdm9pZCAqcCkKK3sKKwlzdHJ1Y3QgcHNjc2lfZGV2X3ZpcnQgKnBkdiA9IChzdHJ1Y3QgcHNjc2lfZGV2X3ZpcnQgKilwOworCXN0cnVjdCBzZV9kZXZpY2UgKmRldjsKKwlzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnNkOworCXN0cnVjdCBwc2NzaV9oYmFfdmlydCAqcGh2ID0gKHN0cnVjdCBwc2NzaV9oYmFfdmlydCAqKWhiYS0+aGJhX3B0cjsKKwlzdHJ1Y3QgU2NzaV9Ib3N0ICpzaCA9IHBodi0+cGh2X2xsZF9ob3N0OworCWludCBsZWdhY3lfbW9kZV9lbmFibGUgPSAwOworCisJaWYgKCEocGR2KSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2NhdGUgc3RydWN0IHBzY3NpX2Rldl92aXJ0IgorCQkJCSIgcGFyYW1ldGVyXG4iKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCS8qCisJICogSWYgbm90IHJ1bm5pbmcgaW4gUEhWX0xMRF9TQ1NJX0hPU1RfTk8gbW9kZSwgbG9jYXRlIHRoZQorCSAqIHN0cnVjdCBTY3NpX0hvc3Qgd2Ugd2lsbCBuZWVkIHRvIGJyaW5nIHRoZSBUQ00vcFNDU0kgb2JqZWN0IG9ubGluZQorCSAqLworCWlmICghKHNoKSkgeworCQlpZiAocGh2LT5waHZfbW9kZSA9PSBQSFZfTExEX1NDU0lfSE9TVF9OTykgeworCQkJcHJpbnRrKEtFUk5fRVJSICJwU0NTSTogVW5hYmxlIHRvIGxvY2F0ZSBzdHJ1Y3QiCisJCQkJIiBTY3NpX0hvc3QgZm9yIFBIVl9MTERfU0NTSV9IT1NUX05PXG4iKTsKKwkJCXJldHVybiBOVUxMOworCQl9CisJCS8qCisJCSAqIEZvciB0aGUgbmV3ZXIgUEhWX1ZJUlVUQUxfSE9TVF9JRCBzdHJ1Y3Qgc2NzaV9kZXZpY2UKKwkJICogcmVmZXJlbmNlLCB3ZSBlbmZvcmNlIHRoYXQgdWRldl9wYXRoIGhhcyBiZWVuIHNldAorCQkgKi8KKwkJaWYgKCEoc2VfZGV2LT5zdV9kZXZfZmxhZ3MgJiBTREZfVVNJTkdfVURFVl9QQVRIKSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJwU0NTSTogdWRldl9wYXRoIGF0dHJpYnV0ZSBoYXMgbm90IgorCQkJCSIgYmVlbiBzZXQgYmVmb3JlIEVOQUJMRT0xXG4iKTsKKwkJCXJldHVybiBOVUxMOworCQl9CisJCS8qCisJCSAqIElmIG5vIHNjc2lfaG9zdF9pZD0gd2FzIHBhc3NlZCBmb3IgUEhWX1ZJUlVUQUxfSE9TVF9JRCwKKwkJICogdXNlIHRoZSBvcmlnaW5hbCBUQ00gaGJhIElEIHRvIHJlZmVyZW5jZSBMaW51eC9TQ1NJIEhvc3QgTm8KKwkJICogYW5kIGVuYWJsZSBmb3IgUEhWX0xMRF9TQ1NJX0hPU1RfTk8gbW9kZS4KKwkJICovCisJCWlmICghKHBkdi0+cGR2X2ZsYWdzICYgUERGX0hBU19WSVJUX0hPU1RfSUQpKSB7CisJCQlzcGluX2xvY2soJmhiYS0+ZGV2aWNlX2xvY2spOworCQkJaWYgKCEobGlzdF9lbXB0eSgmaGJhLT5oYmFfZGV2X2xpc3QpKSkgeworCQkJCXByaW50ayhLRVJOX0VSUiAicFNDU0k6IFVuYWJsZSB0byBzZXQgaGJhX21vZGUiCisJCQkJCSIgd2l0aCBhY3RpdmUgZGV2aWNlc1xuIik7CisJCQkJc3Bpbl91bmxvY2soJmhiYS0+ZGV2aWNlX2xvY2spOworCQkJCXJldHVybiBOVUxMOworCQkJfQorCQkJc3Bpbl91bmxvY2soJmhiYS0+ZGV2aWNlX2xvY2spOworCisJCQlpZiAocHNjc2lfcG1vZGVfZW5hYmxlX2hiYShoYmEsIDEpICE9IDEpCisJCQkJcmV0dXJuIE5VTEw7CisKKwkJCWxlZ2FjeV9tb2RlX2VuYWJsZSA9IDE7CisJCQloYmEtPmhiYV9mbGFncyB8PSBIQkFfRkxBR1NfUFNDU0lfTU9ERTsKKwkJCXNoID0gcGh2LT5waHZfbGxkX2hvc3Q7CisJCX0gZWxzZSB7CisJCQlzaCA9IHBzY3NpX2dldF9zaChwZHYtPnBkdl9ob3N0X2lkKTsKKwkJCWlmICghKHNoKSkgeworCQkJCXByaW50ayhLRVJOX0VSUiAicFNDU0k6IFVuYWJsZSB0byBsb2NhdGUiCisJCQkJCSIgcGR2X2hvc3RfaWQ6ICVkXG4iLCBwZHYtPnBkdl9ob3N0X2lkKTsKKwkJCQlyZXR1cm4gTlVMTDsKKwkJCX0KKwkJfQorCX0gZWxzZSB7CisJCWlmIChwaHYtPnBodl9tb2RlID09IFBIVl9WSVJVVEFMX0hPU1RfSUQpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAicFNDU0k6IFBIVl9WSVJVVEFMX0hPU1RfSUQgc2V0IHdoaWxlIgorCQkJCSIgc3RydWN0IFNjc2lfSG9zdCBleGlzdHNcbiIpOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKwl9CisKKwlzcGluX2xvY2tfaXJxKHNoLT5ob3N0X2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnkoc2QsICZzaC0+X19kZXZpY2VzLCBzaWJsaW5ncykgeworCQlpZiAoKHBkdi0+cGR2X2NoYW5uZWxfaWQgIT0gc2QtPmNoYW5uZWwpIHx8CisJCSAgICAocGR2LT5wZHZfdGFyZ2V0X2lkICE9IHNkLT5pZCkgfHwKKwkJICAgIChwZHYtPnBkdl9sdW5faWQgIT0gc2QtPmx1bikpCisJCQljb250aW51ZTsKKwkJLyoKKwkJICogRnVuY3Rpb25zIHdpbGwgcmVsZWFzZSB0aGUgaGVsZCBzdHJ1Y3Qgc2NzaV9ob3N0LT5ob3N0X2xvY2sKKwkJICogYmVmb3JlIGNhbGxpbmcgY2FsbGluZyBwc2NzaV9hZGRfZGV2aWNlX3RvX2xpc3QoKSB0byByZWdpc3RlcgorCQkgKiBzdHJ1Y3Qgc2NzaV9kZXZpY2Ugd2l0aCB0YXJnZXRfY29yZV9tb2QuCisJCSAqLworCQlzd2l0Y2ggKHNkLT50eXBlKSB7CisJCWNhc2UgVFlQRV9ESVNLOgorCQkJZGV2ID0gcHNjc2lfY3JlYXRlX3R5cGVfZGlzayhzZCwgcGR2LCBzZV9kZXYsIGhiYSk7CisJCQlicmVhazsKKwkJY2FzZSBUWVBFX1JPTToKKwkJCWRldiA9IHBzY3NpX2NyZWF0ZV90eXBlX3JvbShzZCwgcGR2LCBzZV9kZXYsIGhiYSk7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCWRldiA9IHBzY3NpX2NyZWF0ZV90eXBlX290aGVyKHNkLCBwZHYsIHNlX2RldiwgaGJhKTsKKwkJCWJyZWFrOworCQl9CisKKwkJaWYgKCEoZGV2KSkgeworCQkJaWYgKHBodi0+cGh2X21vZGUgPT0gUEhWX1ZJUlVUQUxfSE9TVF9JRCkKKwkJCQlzY3NpX2hvc3RfcHV0KHNoKTsKKwkJCWVsc2UgaWYgKGxlZ2FjeV9tb2RlX2VuYWJsZSkgeworCQkJCXBzY3NpX3Btb2RlX2VuYWJsZV9oYmEoaGJhLCAwKTsKKwkJCQloYmEtPmhiYV9mbGFncyAmPSB+SEJBX0ZMQUdTX1BTQ1NJX01PREU7CisJCQl9CisJCQlwZHYtPnBkdl9zZCA9IE5VTEw7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCQlyZXR1cm4gZGV2OworCX0KKwlzcGluX3VubG9ja19pcnEoc2gtPmhvc3RfbG9jayk7CisKKwlwcmludGsoS0VSTl9FUlIgInBTQ1NJOiBVbmFibGUgdG8gbG9jYXRlICVkOiVkOiVkOiVkXG4iLCBzaC0+aG9zdF9ubywKKwkJcGR2LT5wZHZfY2hhbm5lbF9pZCwgIHBkdi0+cGR2X3RhcmdldF9pZCwgcGR2LT5wZHZfbHVuX2lkKTsKKworCWlmIChwaHYtPnBodl9tb2RlID09IFBIVl9WSVJVVEFMX0hPU1RfSUQpCisJCXNjc2lfaG9zdF9wdXQoc2gpOworCWVsc2UgaWYgKGxlZ2FjeV9tb2RlX2VuYWJsZSkgeworCQlwc2NzaV9wbW9kZV9lbmFibGVfaGJhKGhiYSwgMCk7CisJCWhiYS0+aGJhX2ZsYWdzICY9IH5IQkFfRkxBR1NfUFNDU0lfTU9ERTsKKwl9CisKKwlyZXR1cm4gTlVMTDsKK30KKworLyoJcHNjc2lfZnJlZV9kZXZpY2UoKTogKFBhcnQgb2Ygc2Vfc3Vic3lzdGVtX2FwaV90IHRlbXBsYXRlKQorICoKKyAqCisgKi8KK3N0YXRpYyB2b2lkIHBzY3NpX2ZyZWVfZGV2aWNlKHZvaWQgKnApCit7CisJc3RydWN0IHBzY3NpX2Rldl92aXJ0ICpwZHYgPSBwOworCXN0cnVjdCBwc2NzaV9oYmFfdmlydCAqcGh2ID0gcGR2LT5wZHZfc2VfaGJhLT5oYmFfcHRyOworCXN0cnVjdCBzY3NpX2RldmljZSAqc2QgPSBwZHYtPnBkdl9zZDsKKworCWlmIChzZCkgeworCQkvKgorCQkgKiBSZWxlYXNlIGV4Y2x1c2l2ZSBwU0NTSSBpbnRlcm5hbCBzdHJ1Y3QgYmxvY2tfZGV2aWNlIGNsYWltIGZvcgorCQkgKiBzdHJ1Y3Qgc2NzaV9kZXZpY2Ugd2l0aCBUWVBFX0RJU0sgZnJvbSBwc2NzaV9jcmVhdGVfdHlwZV9kaXNrKCkKKwkJICovCisJCWlmICgoc2QtPnR5cGUgPT0gVFlQRV9ESVNLKSAmJiBwZHYtPnBkdl9iZCkgeworCQkJYmxrZGV2X3B1dChwZHYtPnBkdl9iZCwKKwkJCQkgICBGTU9ERV9XUklURXxGTU9ERV9SRUFEfEZNT0RFX0VYQ0wpOworCQkJcGR2LT5wZHZfYmQgPSBOVUxMOworCQl9CisJCS8qCisJCSAqIEZvciBIQkEgbW9kZSBQSFZfTExEX1NDU0lfSE9TVF9OTywgcmVsZWFzZSB0aGUgcmVmZXJlbmNlCisJCSAqIHRvIHN0cnVjdCBTY3NpX0hvc3Qgbm93LgorCQkgKi8KKwkJaWYgKChwaHYtPnBodl9tb2RlID09IFBIVl9MTERfU0NTSV9IT1NUX05PKSAmJgorCQkgICAgKHBodi0+cGh2X2xsZF9ob3N0ICE9IE5VTEwpKQorCQkJc2NzaV9ob3N0X3B1dChwaHYtPnBodl9sbGRfaG9zdCk7CisKKwkJaWYgKChzZC0+dHlwZSA9PSBUWVBFX0RJU0spIHx8IChzZC0+dHlwZSA9PSBUWVBFX1JPTSkpCisJCQlzY3NpX2RldmljZV9wdXQoc2QpOworCisJCXBkdi0+cGR2X3NkID0gTlVMTDsKKwl9CisKKwlrZnJlZShwZHYpOworfQorCitzdGF0aWMgaW5saW5lIHN0cnVjdCBwc2NzaV9wbHVnaW5fdGFzayAqUFNDU0lfVEFTSyhzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlyZXR1cm4gY29udGFpbmVyX29mKHRhc2ssIHN0cnVjdCBwc2NzaV9wbHVnaW5fdGFzaywgcHNjc2lfdGFzayk7Cit9CisKKworLyoJcHNjc2lfdHJhbnNwb3J0X2NvbXBsZXRlKCk6CisgKgorICoKKyAqLworc3RhdGljIGludCBwc2NzaV90cmFuc3BvcnRfY29tcGxldGUoc3RydWN0IHNlX3Rhc2sgKnRhc2spCit7CisJc3RydWN0IHBzY3NpX2Rldl92aXJ0ICpwZHYgPSB0YXNrLT5zZV9kZXYtPmRldl9wdHI7CisJc3RydWN0IHNjc2lfZGV2aWNlICpzZCA9IHBkdi0+cGR2X3NkOworCWludCByZXN1bHQ7CisJc3RydWN0IHBzY3NpX3BsdWdpbl90YXNrICpwdCA9IFBTQ1NJX1RBU0sodGFzayk7CisJdW5zaWduZWQgY2hhciAqY2RiID0gJnB0LT5wc2NzaV9jZGJbMF07CisKKwlyZXN1bHQgPSBwdC0+cHNjc2lfcmVzdWx0OworCS8qCisJICogSGFjayB0byBtYWtlIHN1cmUgdGhhdCBXcml0ZS1Qcm90ZWN0IG1vZGVwYWdlIGlzIHNldCBpZiBSL08gbW9kZSBpcworCSAqIGZvcmNlZC4KKwkgKi8KKwlpZiAoKChjZGJbMF0gPT0gTU9ERV9TRU5TRSkgfHwgKGNkYlswXSA9PSBNT0RFX1NFTlNFXzEwKSkgJiYKKwkgICAgIChzdGF0dXNfYnl0ZShyZXN1bHQpIDw8IDEpID09IFNBTV9TVEFUX0dPT0QpIHsKKwkJaWYgKCFUQVNLX0NNRCh0YXNrKS0+c2VfZGV2ZSkKKwkJCWdvdG8gYWZ0ZXJfbW9kZV9zZW5zZTsKKworCQlpZiAoVEFTS19DTUQodGFzayktPnNlX2RldmUtPmx1bl9mbGFncyAmCisJCQkJVFJBTlNQT1JUX0xVTkZMQUdTX1JFQURfT05MWSkgeworCQkJdW5zaWduZWQgY2hhciAqYnVmID0gKHVuc2lnbmVkIGNoYXIgKikKKwkJCQlUX1RBU0sodGFzay0+dGFza19zZV9jbWQpLT50X3Rhc2tfYnVmOworCisJCQlpZiAoY2RiWzBdID09IE1PREVfU0VOU0VfMTApIHsKKwkJCQlpZiAoIShidWZbM10gJiAweDgwKSkKKwkJCQkJYnVmWzNdIHw9IDB4ODA7CisJCQl9IGVsc2UgeworCQkJCWlmICghKGJ1ZlsyXSAmIDB4ODApKQorCQkJCQlidWZbMl0gfD0gMHg4MDsKKwkJCX0KKwkJfQorCX0KK2FmdGVyX21vZGVfc2Vuc2U6CisKKwlpZiAoc2QtPnR5cGUgIT0gVFlQRV9UQVBFKQorCQlnb3RvIGFmdGVyX21vZGVfc2VsZWN0OworCisJLyoKKwkgKiBIYWNrIHRvIGNvcnJlY3RseSBvYnRhaW4gdGhlIGluaXRpYXRvciByZXF1ZXN0ZWQgYmxvY2tzaXplIGZvcgorCSAqIFRZUEVfVEFQRS4gIFNpbmNlIHRoaXMgdmFsdWUgaXMgZGVwZW5kZW50IHVwb24gZWFjaCB0YXBlIG1lZGlhLAorCSAqIHN0cnVjdCBzY3NpX2RldmljZS0+c2VjdG9yX3NpemUgd2lsbCBub3QgY29udGFpbiB0aGUgY29ycmVjdCB2YWx1ZQorCSAqIGJ5IGRlZmF1bHQsIHNvIHdlIGdvIGFoZWFkIGFuZCBzZXQgaXQgc28KKwkgKiBUUkFOU1BPUlQoZGV2KS0+Z2V0X2Jsb2NrZGV2KCkgcmV0dXJucyB0aGUgY29ycmVjdCB2YWx1ZSB0byB0aGUKKwkgKiBzdG9yYWdlIGVuZ2luZS4KKwkgKi8KKwlpZiAoKChjZGJbMF0gPT0gTU9ERV9TRUxFQ1QpIHx8IChjZGJbMF0gPT0gTU9ERV9TRUxFQ1RfMTApKSAmJgorCSAgICAgIChzdGF0dXNfYnl0ZShyZXN1bHQpIDw8IDEpID09IFNBTV9TVEFUX0dPT0QpIHsKKwkJdW5zaWduZWQgY2hhciAqYnVmOworCQlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnID0gdGFzay0+dGFza19zZzsKKwkJdTE2IGJkbDsKKwkJdTMyIGJsb2Nrc2l6ZTsKKworCQlidWYgPSBzZ192aXJ0KCZzZ1swXSk7CisJCWlmICghKGJ1ZikpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGdldCBidWYgZm9yIHNjYXR0ZXJsaXN0XG4iKTsKKwkJCWdvdG8gYWZ0ZXJfbW9kZV9zZWxlY3Q7CisJCX0KKworCQlpZiAoY2RiWzBdID09IE1PREVfU0VMRUNUKQorCQkJYmRsID0gKGJ1ZlszXSk7CisJCWVsc2UKKwkJCWJkbCA9IChidWZbNl0gPDwgOCkgfCAoYnVmWzddKTsKKworCQlpZiAoIWJkbCkKKwkJCWdvdG8gYWZ0ZXJfbW9kZV9zZWxlY3Q7CisKKwkJaWYgKGNkYlswXSA9PSBNT0RFX1NFTEVDVCkKKwkJCWJsb2Nrc2l6ZSA9IChidWZbOV0gPDwgMTYpIHwgKGJ1ZlsxMF0gPDwgOCkgfAorCQkJCQkoYnVmWzExXSk7CisJCWVsc2UKKwkJCWJsb2Nrc2l6ZSA9IChidWZbMTNdIDw8IDE2KSB8IChidWZbMTRdIDw8IDgpIHwKKwkJCQkJKGJ1ZlsxNV0pOworCisJCXNkLT5zZWN0b3Jfc2l6ZSA9IGJsb2Nrc2l6ZTsKKwl9CithZnRlcl9tb2RlX3NlbGVjdDoKKworCWlmIChzdGF0dXNfYnl0ZShyZXN1bHQpICYgQ0hFQ0tfQ09ORElUSU9OKQorCQlyZXR1cm4gMTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IHNlX3Rhc2sgKgorcHNjc2lfYWxsb2NfdGFzayhzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHBzY3NpX3BsdWdpbl90YXNrICpwdDsKKwl1bnNpZ25lZCBjaGFyICpjZGIgPSBUX1RBU0soY21kKS0+dF90YXNrX2NkYjsKKworCXB0ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHBzY3NpX3BsdWdpbl90YXNrKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFwdCkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBzdHJ1Y3QgcHNjc2lfcGx1Z2luX3Rhc2tcbiIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwkvKgorCSAqIElmIFRDTSBDb3JlIGlzIHNpZ25hbGluZyBhID4gVENNX01BWF9DT01NQU5EX1NJWkUgYWxsb2NhdGlvbiwKKwkgKiBhbGxvY2F0ZSB0aGUgZXh0ZW5kZWQgQ0RCIGJ1ZmZlciBmb3IgcGVyIHN0cnVjdCBzZV90YXNrIGNvbnRleHQKKwkgKiBwdC0+cHNjc2lfY2RiIG5vdy4KKwkgKi8KKwlpZiAoVF9UQVNLKGNtZCktPnRfdGFza19jZGIgIT0gVF9UQVNLKGNtZCktPl9fdF90YXNrX2NkYikgeworCisJCXB0LT5wc2NzaV9jZGIgPSBremFsbG9jKHNjc2lfY29tbWFuZF9zaXplKGNkYiksIEdGUF9LRVJORUwpOworCQlpZiAoIShwdC0+cHNjc2lfY2RiKSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJwU0NTSTogVW5hYmxlIHRvIGFsbG9jYXRlIGV4dGVuZGVkIgorCQkJCQkiIHB0LT5wc2NzaV9jZGJcbiIpOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKwl9IGVsc2UKKwkJcHQtPnBzY3NpX2NkYiA9ICZwdC0+X19wc2NzaV9jZGJbMF07CisKKwlyZXR1cm4gJnB0LT5wc2NzaV90YXNrOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgcHNjc2lfYmxrX2luaXRfcmVxdWVzdCgKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzaywKKwlzdHJ1Y3QgcHNjc2lfcGx1Z2luX3Rhc2sgKnB0LAorCXN0cnVjdCByZXF1ZXN0ICpyZXEsCisJaW50IGJpZGlfcmVhZCkKK3sKKwkvKgorCSAqIERlZmluZWQgYXMgInNjc2kgY29tbWFuZCIgaW4gaW5jbHVkZS9saW51eC9ibGtkZXYuaC4KKwkgKi8KKwlyZXEtPmNtZF90eXBlID0gUkVRX1RZUEVfQkxPQ0tfUEM7CisJLyoKKwkgKiBGb3IgdGhlIGV4dHJhIEJJREktQ09NTUFORCBSRUFEIHN0cnVjdCByZXF1ZXN0IHdlIGRvIG5vdAorCSAqIG5lZWQgdG8gc2V0dXAgdGhlIHJlbWFpbmluZyBzdHJ1Y3R1cmUgbWVtYmVycworCSAqLworCWlmIChiaWRpX3JlYWQpCisJCXJldHVybjsKKwkvKgorCSAqIFNldHVwIHRoZSBkb25lIGZ1bmN0aW9uIHBvaW50ZXIgZm9yIHN0cnVjdCByZXF1ZXN0LAorCSAqIGFsc28gc2V0IHRoZSBlbmRfaW9fZGF0YSBwb2ludGVyLnRvIHN0cnVjdCBzZV90YXNrLgorCSAqLworCXJlcS0+ZW5kX2lvID0gcHNjc2lfcmVxX2RvbmU7CisJcmVxLT5lbmRfaW9fZGF0YSA9ICh2b2lkICopdGFzazsKKwkvKgorCSAqIExvYWQgdGhlIHJlZmVyZW5jZWQgc3RydWN0IHNlX3Rhc2sncyBTQ1NJIENEQiBpbnRvCisJICogaW5jbHVkZS9saW51eC9ibGtkZXYuaDpzdHJ1Y3QgcmVxdWVzdC0+Y21kCisJICovCisJcmVxLT5jbWRfbGVuID0gc2NzaV9jb21tYW5kX3NpemUocHQtPnBzY3NpX2NkYik7CisJcmVxLT5jbWQgPSAmcHQtPnBzY3NpX2NkYlswXTsKKwkvKgorCSAqIFNldHVwIHBvaW50ZXIgZm9yIG91dGdvaW5nIHNlbnNlIGRhdGEuCisJICovCisJcmVxLT5zZW5zZSA9ICh2b2lkICopJnB0LT5wc2NzaV9zZW5zZVswXTsKKwlyZXEtPnNlbnNlX2xlbiA9IDA7Cit9CisKKy8qCisgKiBVc2VkIGZvciBwU0NTSSBkYXRhIHBheWxvYWRzIGZvciBhbGwgKk5PTiogU0NGX1NDU0lfREFUQV9TR19JT19DREIKKyovCitzdGF0aWMgaW50IHBzY3NpX2Jsa19nZXRfcmVxdWVzdChzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlzdHJ1Y3QgcHNjc2lfcGx1Z2luX3Rhc2sgKnB0ID0gUFNDU0lfVEFTSyh0YXNrKTsKKwlzdHJ1Y3QgcHNjc2lfZGV2X3ZpcnQgKnBkdiA9IHRhc2stPnNlX2Rldi0+ZGV2X3B0cjsKKworCXB0LT5wc2NzaV9yZXEgPSBibGtfZ2V0X3JlcXVlc3QocGR2LT5wZHZfc2QtPnJlcXVlc3RfcXVldWUsCisJCQkodGFzay0+dGFza19kYXRhX2RpcmVjdGlvbiA9PSBETUFfVE9fREVWSUNFKSwKKwkJCUdGUF9LRVJORUwpOworCWlmICghKHB0LT5wc2NzaV9yZXEpIHx8IElTX0VSUihwdC0+cHNjc2lfcmVxKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlBTQ1NJOiBibGtfZ2V0X3JlcXVlc3QoKSBmYWlsZWQ6ICVsZFxuIiwKKwkJCQlJU19FUlIocHQtPnBzY3NpX3JlcSkpOworCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9MVV9DT01NX0ZBSUxVUkU7CisJfQorCS8qCisJICogU2V0dXAgdGhlIG5ld2x5IGFsbG9jYXRlZCBzdHJ1Y3QgcmVxdWVzdCBmb3IgUkVRX1RZUEVfQkxPQ0tfUEMsCisJICogYW5kIHNldHVwIHJxIGNhbGxiYWNrLCBDREIgYW5kIHNlbnNlLgorCSAqLworCXBzY3NpX2Jsa19pbml0X3JlcXVlc3QodGFzaywgcHQsIHB0LT5wc2NzaV9yZXEsIDApOworCXJldHVybiAwOworfQorCisvKiAgICAgIHBzY3NpX2RvX3Rhc2soKTogKFBhcnQgb2Ygc2Vfc3Vic3lzdGVtX2FwaV90IHRlbXBsYXRlKQorICoKKyAqCisgKi8KK3N0YXRpYyBpbnQgcHNjc2lfZG9fdGFzayhzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlzdHJ1Y3QgcHNjc2lfcGx1Z2luX3Rhc2sgKnB0ID0gUFNDU0lfVEFTSyh0YXNrKTsKKwlzdHJ1Y3QgcHNjc2lfZGV2X3ZpcnQgKnBkdiA9IHRhc2stPnNlX2Rldi0+ZGV2X3B0cjsKKwkvKgorCSAqIFNldCB0aGUgc3RydWN0IHJlcXVlc3QtPnRpbWVvdXQgdmFsdWUgYmFzZWQgb24gcGVyaXBoZXJhbAorCSAqIGRldmljZSB0eXBlIGZyb20gU0NTSS4KKwkgKi8KKwlpZiAocGR2LT5wZHZfc2QtPnR5cGUgPT0gVFlQRV9ESVNLKQorCQlwdC0+cHNjc2lfcmVxLT50aW1lb3V0ID0gUFNfVElNRU9VVF9ESVNLOworCWVsc2UKKwkJcHQtPnBzY3NpX3JlcS0+dGltZW91dCA9IFBTX1RJTUVPVVRfT1RIRVI7CisKKwlwdC0+cHNjc2lfcmVxLT5yZXRyaWVzID0gUFNfUkVUUlk7CisJLyoKKwkgKiBRdWV1ZSB0aGUgc3RydWN0IHJlcXVlc3QgaW50byB0aGUgc3RydWN0IHNjc2lfZGV2aWNlLT5yZXF1ZXN0X3F1ZXVlLgorCSAqIEFsc28gY2hlY2sgZm9yIEhFQURfT0ZfUVVFVUUgU0FNIFRBU0sgYXR0ciBmcm9tIHJlY2VpdmVkIHNlX2NtZAorCSAqIGRlc2NyaXB0b3IKKwkgKi8KKwlibGtfZXhlY3V0ZV9ycV9ub3dhaXQocGR2LT5wZHZfc2QtPnJlcXVlc3RfcXVldWUsIE5VTEwsIHB0LT5wc2NzaV9yZXEsCisJCQkodGFzay0+dGFza19zZV9jbWQtPnNhbV90YXNrX2F0dHIgPT0gVEFTS19BVFRSX0hPUSksCisJCQlwc2NzaV9yZXFfZG9uZSk7CisKKwlyZXR1cm4gUFlYX1RSQU5TUE9SVF9TRU5UX1RPX1RSQU5TUE9SVDsKK30KKworc3RhdGljIHZvaWQgcHNjc2lfZnJlZV90YXNrKHN0cnVjdCBzZV90YXNrICp0YXNrKQoreworCXN0cnVjdCBwc2NzaV9wbHVnaW5fdGFzayAqcHQgPSBQU0NTSV9UQVNLKHRhc2spOworCXN0cnVjdCBzZV9jbWQgKmNtZCA9IHRhc2stPnRhc2tfc2VfY21kOworCisJLyoKKwkgKiBSZWxlYXNlIHRoZSBleHRlbmRlZCBDREIgYWxsb2NhdGlvbiBmcm9tIHBzY3NpX2FsbG9jX3Rhc2soKQorCSAqIGlmIG9uZSBleGlzdHMuCisJICovCisJaWYgKFRfVEFTSyhjbWQpLT50X3Rhc2tfY2RiICE9IFRfVEFTSyhjbWQpLT5fX3RfdGFza19jZGIpCisJCWtmcmVlKHB0LT5wc2NzaV9jZGIpOworCS8qCisJICogV2UgZG8gbm90IHJlbGVhc2UgdGhlIGJpbyhzKSBoZXJlIGFzc29jaWF0ZWQgd2l0aCB0aGlzIHRhc2ssIGFzCisJICogdGhpcyBpcyBoYW5kbGVkIGJ5IGJpb19wdXQoKSBhbmQgcHNjc2lfYmlfZW5kaW8oKS4KKwkgKi8KKwlrZnJlZShwdCk7Cit9CisKK2VudW0geworCU9wdF9zY3NpX2hvc3RfaWQsIE9wdF9zY3NpX2NoYW5uZWxfaWQsIE9wdF9zY3NpX3RhcmdldF9pZCwKKwlPcHRfc2NzaV9sdW5faWQsIE9wdF9lcnIKK307CisKK3N0YXRpYyBtYXRjaF90YWJsZV90IHRva2VucyA9IHsKKwl7T3B0X3Njc2lfaG9zdF9pZCwgInNjc2lfaG9zdF9pZD0lZCJ9LAorCXtPcHRfc2NzaV9jaGFubmVsX2lkLCAic2NzaV9jaGFubmVsX2lkPSVkIn0sCisJe09wdF9zY3NpX3RhcmdldF9pZCwgInNjc2lfdGFyZ2V0X2lkPSVkIn0sCisJe09wdF9zY3NpX2x1bl9pZCwgInNjc2lfbHVuX2lkPSVkIn0sCisJe09wdF9lcnIsIE5VTEx9Cit9OworCitzdGF0aWMgc3NpemVfdCBwc2NzaV9zZXRfY29uZmlnZnNfZGV2X3BhcmFtcyhzdHJ1Y3Qgc2VfaGJhICpoYmEsCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiwKKwljb25zdCBjaGFyICpwYWdlLAorCXNzaXplX3QgY291bnQpCit7CisJc3RydWN0IHBzY3NpX2Rldl92aXJ0ICpwZHYgPSBzZV9kZXYtPnNlX2Rldl9zdV9wdHI7CisJc3RydWN0IHBzY3NpX2hiYV92aXJ0ICpwaHYgPSBoYmEtPmhiYV9wdHI7CisJY2hhciAqb3JpZywgKnB0ciwgKm9wdHM7CisJc3Vic3RyaW5nX3QgYXJnc1tNQVhfT1BUX0FSR1NdOworCWludCByZXQgPSAwLCBhcmcsIHRva2VuOworCisJb3B0cyA9IGtzdHJkdXAocGFnZSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFvcHRzKQorCQlyZXR1cm4gLUVOT01FTTsKKworCW9yaWcgPSBvcHRzOworCisJd2hpbGUgKChwdHIgPSBzdHJzZXAoJm9wdHMsICIsIikpICE9IE5VTEwpIHsKKwkJaWYgKCEqcHRyKQorCQkJY29udGludWU7CisKKwkJdG9rZW4gPSBtYXRjaF90b2tlbihwdHIsIHRva2VucywgYXJncyk7CisJCXN3aXRjaCAodG9rZW4pIHsKKwkJY2FzZSBPcHRfc2NzaV9ob3N0X2lkOgorCQkJaWYgKHBodi0+cGh2X21vZGUgPT0gUEhWX0xMRF9TQ1NJX0hPU1RfTk8pIHsKKwkJCQlwcmludGsoS0VSTl9FUlIgIlBTQ1NJWyVkXTogVW5hYmxlIHRvIGFjY2VwdCIKKwkJCQkJIiBzY3NpX2hvc3RfaWQgd2hpbGUgcGh2X21vZGUgPT0iCisJCQkJCSIgUEhWX0xMRF9TQ1NJX0hPU1RfTk9cbiIsCisJCQkJCXBodi0+cGh2X2hvc3RfaWQpOworCQkJCXJldCA9IC1FSU5WQUw7CisJCQkJZ290byBvdXQ7CisJCQl9CisJCQltYXRjaF9pbnQoYXJncywgJmFyZyk7CisJCQlwZHYtPnBkdl9ob3N0X2lkID0gYXJnOworCQkJcHJpbnRrKEtFUk5fSU5GTyAiUFNDU0lbJWRdOiBSZWZlcmVuY2luZyBTQ1NJIEhvc3QgSUQ6IgorCQkJCSIgJWRcbiIsIHBodi0+cGh2X2hvc3RfaWQsIHBkdi0+cGR2X2hvc3RfaWQpOworCQkJcGR2LT5wZHZfZmxhZ3MgfD0gUERGX0hBU19WSVJUX0hPU1RfSUQ7CisJCQlicmVhazsKKwkJY2FzZSBPcHRfc2NzaV9jaGFubmVsX2lkOgorCQkJbWF0Y2hfaW50KGFyZ3MsICZhcmcpOworCQkJcGR2LT5wZHZfY2hhbm5lbF9pZCA9IGFyZzsKKwkJCXByaW50ayhLRVJOX0lORk8gIlBTQ1NJWyVkXTogUmVmZXJlbmNpbmcgU0NTSSBDaGFubmVsIgorCQkJCSIgSUQ6ICVkXG4iLCAgcGh2LT5waHZfaG9zdF9pZCwKKwkJCQlwZHYtPnBkdl9jaGFubmVsX2lkKTsKKwkJCXBkdi0+cGR2X2ZsYWdzIHw9IFBERl9IQVNfQ0hBTk5FTF9JRDsKKwkJCWJyZWFrOworCQljYXNlIE9wdF9zY3NpX3RhcmdldF9pZDoKKwkJCW1hdGNoX2ludChhcmdzLCAmYXJnKTsKKwkJCXBkdi0+cGR2X3RhcmdldF9pZCA9IGFyZzsKKwkJCXByaW50ayhLRVJOX0lORk8gIlBTQ1NJWyVkXTogUmVmZXJlbmNpbmcgU0NTSSBUYXJnZXQiCisJCQkJIiBJRDogJWRcbiIsIHBodi0+cGh2X2hvc3RfaWQsCisJCQkJcGR2LT5wZHZfdGFyZ2V0X2lkKTsKKwkJCXBkdi0+cGR2X2ZsYWdzIHw9IFBERl9IQVNfVEFSR0VUX0lEOworCQkJYnJlYWs7CisJCWNhc2UgT3B0X3Njc2lfbHVuX2lkOgorCQkJbWF0Y2hfaW50KGFyZ3MsICZhcmcpOworCQkJcGR2LT5wZHZfbHVuX2lkID0gYXJnOworCQkJcHJpbnRrKEtFUk5fSU5GTyAiUFNDU0lbJWRdOiBSZWZlcmVuY2luZyBTQ1NJIExVTiBJRDoiCisJCQkJIiAlZFxuIiwgcGh2LT5waHZfaG9zdF9pZCwgcGR2LT5wZHZfbHVuX2lkKTsKKwkJCXBkdi0+cGR2X2ZsYWdzIHw9IFBERl9IQVNfTFVOX0lEOworCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisJCQlicmVhazsKKwkJfQorCX0KKworb3V0OgorCWtmcmVlKG9yaWcpOworCXJldHVybiAoIXJldCkgPyBjb3VudCA6IHJldDsKK30KKworc3RhdGljIHNzaXplX3QgcHNjc2lfY2hlY2tfY29uZmlnZnNfZGV2X3BhcmFtcygKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEsCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldikKK3sKKwlzdHJ1Y3QgcHNjc2lfZGV2X3ZpcnQgKnBkdiA9IHNlX2Rldi0+c2VfZGV2X3N1X3B0cjsKKworCWlmICghKHBkdi0+cGR2X2ZsYWdzICYgUERGX0hBU19DSEFOTkVMX0lEKSB8fAorCSAgICAhKHBkdi0+cGR2X2ZsYWdzICYgUERGX0hBU19UQVJHRVRfSUQpIHx8CisJICAgICEocGR2LT5wZHZfZmxhZ3MgJiBQREZfSEFTX0xVTl9JRCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJNaXNzaW5nIHNjc2lfY2hhbm5lbF9pZD0sIHNjc2lfdGFyZ2V0X2lkPSBhbmQiCisJCQkiIHNjc2lfbHVuX2lkPSBwYXJhbWV0ZXJzXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgc3NpemVfdCBwc2NzaV9zaG93X2NvbmZpZ2ZzX2Rldl9wYXJhbXMoc3RydWN0IHNlX2hiYSAqaGJhLAorCQkJCQkgICAgICBzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc2VfZGV2LAorCQkJCQkgICAgICBjaGFyICpiKQoreworCXN0cnVjdCBwc2NzaV9oYmFfdmlydCAqcGh2ID0gaGJhLT5oYmFfcHRyOworICAgICAgICBzdHJ1Y3QgcHNjc2lfZGV2X3ZpcnQgKnBkdiA9IHNlX2Rldi0+c2VfZGV2X3N1X3B0cjsKKwlzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnNkID0gcGR2LT5wZHZfc2Q7CisJdW5zaWduZWQgY2hhciBob3N0X2lkWzE2XTsKKwlzc2l6ZV90IGJsOworCWludCBpOworCisJaWYgKHBodi0+cGh2X21vZGUgPT0gUEhWX1ZJUlVUQUxfSE9TVF9JRCkKKwkJc25wcmludGYoaG9zdF9pZCwgMTYsICIlZCIsIHBkdi0+cGR2X2hvc3RfaWQpOworCWVsc2UKKwkJc25wcmludGYoaG9zdF9pZCwgMTYsICJQSEJBIE1vZGUiKTsKKworCWJsID0gc3ByaW50ZihiLCAiU0NTSSBEZXZpY2UgQnVzIExvY2F0aW9uOiIKKwkJIiBDaGFubmVsIElEOiAlZCBUYXJnZXQgSUQ6ICVkIExVTjogJWQgSG9zdCBJRDogJXNcbiIsCisJCXBkdi0+cGR2X2NoYW5uZWxfaWQsIHBkdi0+cGR2X3RhcmdldF9pZCwgcGR2LT5wZHZfbHVuX2lkLAorCQlob3N0X2lkKTsKKworCWlmIChzZCkgeworCQlibCArPSBzcHJpbnRmKGIgKyBibCwgIiAgICAgICAgIik7CisJCWJsICs9IHNwcmludGYoYiArIGJsLCAiVmVuZG9yOiAiKTsKKwkJZm9yIChpID0gMDsgaSA8IDg7IGkrKykgeworCQkJaWYgKElTUFJJTlQoc2QtPnZlbmRvcltpXSkpICAgLyogcHJpbnRhYmxlIGNoYXJhY3Rlcj8gKi8KKwkJCQlibCArPSBzcHJpbnRmKGIgKyBibCwgIiVjIiwgc2QtPnZlbmRvcltpXSk7CisJCQllbHNlCisJCQkJYmwgKz0gc3ByaW50ZihiICsgYmwsICIgIik7CisJCX0KKwkJYmwgKz0gc3ByaW50ZihiICsgYmwsICIgTW9kZWw6ICIpOworCQlmb3IgKGkgPSAwOyBpIDwgMTY7IGkrKykgeworCQkJaWYgKElTUFJJTlQoc2QtPm1vZGVsW2ldKSkgICAvKiBwcmludGFibGUgY2hhcmFjdGVyID8gKi8KKwkJCQlibCArPSBzcHJpbnRmKGIgKyBibCwgIiVjIiwgc2QtPm1vZGVsW2ldKTsKKwkJCWVsc2UKKwkJCQlibCArPSBzcHJpbnRmKGIgKyBibCwgIiAiKTsKKwkJfQorCQlibCArPSBzcHJpbnRmKGIgKyBibCwgIiBSZXY6ICIpOworCQlmb3IgKGkgPSAwOyBpIDwgNDsgaSsrKSB7CisJCQlpZiAoSVNQUklOVChzZC0+cmV2W2ldKSkgICAvKiBwcmludGFibGUgY2hhcmFjdGVyID8gKi8KKwkJCQlibCArPSBzcHJpbnRmKGIgKyBibCwgIiVjIiwgc2QtPnJldltpXSk7CisJCQllbHNlCisJCQkJYmwgKz0gc3ByaW50ZihiICsgYmwsICIgIik7CisJCX0KKwkJYmwgKz0gc3ByaW50ZihiICsgYmwsICJcbiIpOworCX0KKwlyZXR1cm4gYmw7Cit9CisKK3N0YXRpYyB2b2lkIHBzY3NpX2JpX2VuZGlvKHN0cnVjdCBiaW8gKmJpbywgaW50IGVycm9yKQoreworCWJpb19wdXQoYmlvKTsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3QgYmlvICpwc2NzaV9nZXRfYmlvKHN0cnVjdCBwc2NzaV9kZXZfdmlydCAqcGR2LCBpbnQgc2dfbnVtKQoreworCXN0cnVjdCBiaW8gKmJpbzsKKwkvKgorCSAqIFVzZSBiaW9fbWFsbG9jKCkgZm9sbG93aW5nIHRoZSBjb21tZW50IGluIGZvciBiaW8gLT4gc3RydWN0IHJlcXVlc3QKKwkgKiBpbiBibG9jay9ibGstY29yZS5jOmJsa19tYWtlX3JlcXVlc3QoKQorCSAqLworCWJpbyA9IGJpb19rbWFsbG9jKEdGUF9LRVJORUwsIHNnX251bSk7CisJaWYgKCEoYmlvKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlBTQ1NJOiBiaW9fa21hbGxvYygpIGZhaWxlZFxuIik7CisJCXJldHVybiBOVUxMOworCX0KKwliaW8tPmJpX2VuZF9pbyA9IHBzY3NpX2JpX2VuZGlvOworCisJcmV0dXJuIGJpbzsKK30KKworI2lmIDAKKyNkZWZpbmUgREVCVUdfUFNDU0koeC4uLikgcHJpbnRrKHgpCisjZWxzZQorI2RlZmluZSBERUJVR19QU0NTSSh4Li4uKQorI2VuZGlmCisKK3N0YXRpYyBpbnQgX19wc2NzaV9tYXBfdGFza19TRygKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzaywKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnRhc2tfc2csCisJdTMyIHRhc2tfc2dfbnVtLAorCWludCBiaWRpX3JlYWQpCit7CisJc3RydWN0IHBzY3NpX3BsdWdpbl90YXNrICpwdCA9IFBTQ1NJX1RBU0sodGFzayk7CisJc3RydWN0IHBzY3NpX2Rldl92aXJ0ICpwZHYgPSB0YXNrLT5zZV9kZXYtPmRldl9wdHI7CisJc3RydWN0IGJpbyAqYmlvID0gTlVMTCwgKmhiaW8gPSBOVUxMLCAqdGJpbyA9IE5VTEw7CisJc3RydWN0IHBhZ2UgKnBhZ2U7CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZzsKKwl1MzIgZGF0YV9sZW4gPSB0YXNrLT50YXNrX3NpemUsIGksIGxlbiwgYnl0ZXMsIG9mZjsKKwlpbnQgbnJfcGFnZXMgPSAodGFzay0+dGFza19zaXplICsgdGFza19zZ1swXS5vZmZzZXQgKworCQkJUEFHRV9TSVpFIC0gMSkgPj4gUEFHRV9TSElGVDsKKwlpbnQgbnJfdmVjcyA9IDAsIHJjLCByZXQgPSBQWVhfVFJBTlNQT1JUX09VVF9PRl9NRU1PUllfUkVTT1VSQ0VTOworCWludCBydyA9ICh0YXNrLT50YXNrX2RhdGFfZGlyZWN0aW9uID09IERNQV9UT19ERVZJQ0UpOworCisJaWYgKCF0YXNrLT50YXNrX3NpemUpCisJCXJldHVybiAwOworCS8qCisJICogRm9yIFNDRl9TQ1NJX0RBVEFfU0dfSU9fQ0RCLCBVc2UgZnMvYmlvLmM6YmlvX2FkZF9wYWdlKCkgdG8gc2V0dXAKKwkgKiB0aGUgYmlvX3ZlYyBtYXBsaXN0IGZyb20gVEM8IHN0cnVjdCBzZV9tZW0gLT4gdGFzay0+dGFza19zZyAtPgorCSAqIHN0cnVjdCBzY2F0dGVybGlzdCBtZW1vcnkuICBUaGUgc3RydWN0IHNlX3Rhc2stPnRhc2tfc2dbXSBjdXJyZW50bHkgbmVlZHMKKwkgKiB0byBiZSBhdHRhY2hlZCB0byBzdHJ1Y3QgYmlvcyBmb3Igc3VibWlzc2lvbiB0byBMaW51eC9TQ1NJIHVzaW5nCisJICogc3RydWN0IHJlcXVlc3QgdG8gc3RydWN0IHNjc2lfZGV2aWNlLT5yZXF1ZXN0X3F1ZXVlLgorCSAqCisJICogTm90ZSB0aGF0IHRoaXMgd2lsbCBiZSBjaGFuZ2luZyBwb3N0IHYyLjYuMjggYXMgVGFyZ2V0X0NvcmVfTW9kL3BTQ1NJCisJICogaXMgcG9ydGVkIHRvIHVwc3RyZWFtIFNDU0kgcGFzc3Rocm91Z2ggZnVuY3Rpb25hbGl0eSB0aGF0IGFjY2VwdHMKKwkgKiBzdHJ1Y3Qgc2NhdHRlcmxpc3QtPnBhZ2VfbGluayBvciBzdHJ1Y3QgcGFnZSBhcyBhIHBhcmFlbWV0ZXIuCisJICovCisJREVCVUdfUFNDU0koIlBTQ1NJOiBucl9wYWdlczogJWRcbiIsIG5yX3BhZ2VzKTsKKworCWZvcl9lYWNoX3NnKHRhc2tfc2csIHNnLCB0YXNrX3NnX251bSwgaSkgeworCQlwYWdlID0gc2dfcGFnZShzZyk7CisJCW9mZiA9IHNnLT5vZmZzZXQ7CisJCWxlbiA9IHNnLT5sZW5ndGg7CisKKwkJREVCVUdfUFNDU0koIlBTQ1NJOiBpOiAlZCBwYWdlOiAlcCBsZW46ICVkIG9mZjogJWRcbiIsIGksCisJCQlwYWdlLCBsZW4sIG9mZik7CisKKwkJd2hpbGUgKGxlbiA+IDAgJiYgZGF0YV9sZW4gPiAwKSB7CisJCQlieXRlcyA9IG1pbl90KHVuc2lnbmVkIGludCwgbGVuLCBQQUdFX1NJWkUgLSBvZmYpOworCQkJYnl0ZXMgPSBtaW4oYnl0ZXMsIGRhdGFfbGVuKTsKKworCQkJaWYgKCEoYmlvKSkgeworCQkJCW5yX3ZlY3MgPSBtaW5fdChpbnQsIEJJT19NQVhfUEFHRVMsIG5yX3BhZ2VzKTsKKwkJCQlucl9wYWdlcyAtPSBucl92ZWNzOworCQkJCS8qCisJCQkJICogQ2FsbHMgYmlvX2ttYWxsb2MoKSBhbmQgc2V0cyBiaW8tPmJpX2VuZF9pbygpCisJCQkJICovCisJCQkJYmlvID0gcHNjc2lfZ2V0X2JpbyhwZHYsIG5yX3ZlY3MpOworCQkJCWlmICghKGJpbykpCisJCQkJCWdvdG8gZmFpbDsKKworCQkJCWlmIChydykKKwkJCQkJYmlvLT5iaV9ydyB8PSBSRVFfV1JJVEU7CisKKwkJCQlERUJVR19QU0NTSSgiUFNDU0k6IEFsbG9jYXRlZCBiaW86ICVwLCIKKwkJCQkJIiBkaXI6ICVzIG5yX3ZlY3M6ICVkXG4iLCBiaW8sCisJCQkJCShydykgPyAicnciIDogInIiLCBucl92ZWNzKTsKKwkJCQkvKgorCQkJCSAqIFNldCAqaGJpbyBwb2ludGVyIHRvIGhhbmRsZSB0aGUgY2FzZToKKwkJCQkgKiBucl9wYWdlcyA+IEJJT19NQVhfUEFHRVMsIHdoZXJlIGFkZGl0aW9uYWwKKwkJCQkgKiBiaW9zIG5lZWQgdG8gYmUgYWRkZWQgdG8gY29tcGxldGUgYSBnaXZlbgorCQkJCSAqIHN0cnVjdCBzZV90YXNrCisJCQkJICovCisJCQkJaWYgKCFoYmlvKQorCQkJCQloYmlvID0gdGJpbyA9IGJpbzsKKwkJCQllbHNlCisJCQkJCXRiaW8gPSB0YmlvLT5iaV9uZXh0ID0gYmlvOworCQkJfQorCisJCQlERUJVR19QU0NTSSgiUFNDU0k6IENhbGxpbmcgYmlvX2FkZF9wY19wYWdlKCkgaTogJWQiCisJCQkJIiBiaW86ICVwIHBhZ2U6ICVwIGxlbjogJWQgb2ZmOiAlZFxuIiwgaSwgYmlvLAorCQkJCXBhZ2UsIGxlbiwgb2ZmKTsKKworCQkJcmMgPSBiaW9fYWRkX3BjX3BhZ2UocGR2LT5wZHZfc2QtPnJlcXVlc3RfcXVldWUsCisJCQkJCWJpbywgcGFnZSwgYnl0ZXMsIG9mZik7CisJCQlpZiAocmMgIT0gYnl0ZXMpCisJCQkJZ290byBmYWlsOworCisJCQlERUJVR19QU0NTSSgiUFNDU0k6IGJpby0+YmlfdmNudDogJWQgbnJfdmVjczogJWRcbiIsCisJCQkJYmlvLT5iaV92Y250LCBucl92ZWNzKTsKKworCQkJaWYgKGJpby0+YmlfdmNudCA+IG5yX3ZlY3MpIHsKKwkJCQlERUJVR19QU0NTSSgiUFNDU0k6IFJlYWNoZWQgYmlvLT5iaV92Y250IG1heDoiCisJCQkJCSIgJWQgaTogJWQgYmlvOiAlcCwgYWxsb2NhdGluZyBhbm90aGVyIgorCQkJCQkiIGJpb1xuIiwgYmlvLT5iaV92Y250LCBpLCBiaW8pOworCQkJCS8qCisJCQkJICogQ2xlYXIgdGhlIHBvaW50ZXIgc28gdGhhdCBhbm90aGVyIGJpbyB3aWxsCisJCQkJICogYmUgYWxsb2NhdGVkIHdpdGggcHNjc2lfZ2V0X2JpbygpIGFib3ZlLCB0aGUKKwkJCQkgKiBjdXJyZW50IGJpbyBoYXMgYWxyZWFkeSBiZWVuIHNldCAqdGJpbyBhbmQKKwkJCQkgKiBiaW8tPmJpX25leHQuCisJCQkJICovCisJCQkJYmlvID0gTlVMTDsKKwkJCX0KKworCQkJcGFnZSsrOworCQkJbGVuIC09IGJ5dGVzOworCQkJZGF0YV9sZW4gLT0gYnl0ZXM7CisJCQlvZmYgPSAwOworCQl9CisJfQorCS8qCisJICogU2V0dXAgdGhlIHByaW1hcnkgcHQtPnBzY3NpX3JlcSB1c2VkIGZvciBub24gQklESSBhbmQgQklESS1DT01NQU5ECisJICogcHJpbWFyeSBTQ1NJIFdSSVRFIHBvYXlsb2FkIG1hcHBlZCBmb3Igc3RydWN0IHNlX3Rhc2stPnRhc2tfc2dbXQorCSAqLworCWlmICghKGJpZGlfcmVhZCkpIHsKKwkJLyoKKwkJICogU3RhcnRpbmcgd2l0aCB2Mi42LjMxLCBjYWxsIGJsa19tYWtlX3JlcXVlc3QoKSBwYXNzaW5nIGluICpoYmlvIHRvCisJCSAqIGFsbG9jYXRlIHRoZSBwU0NTSSB0YXNrIGEgc3RydWN0IHJlcXVlc3QuCisJCSAqLworCQlwdC0+cHNjc2lfcmVxID0gYmxrX21ha2VfcmVxdWVzdChwZHYtPnBkdl9zZC0+cmVxdWVzdF9xdWV1ZSwKKwkJCQkJaGJpbywgR0ZQX0tFUk5FTCk7CisJCWlmICghKHB0LT5wc2NzaV9yZXEpKSB7CisJCQlwcmludGsoS0VSTl9FUlIgInBTQ1NJOiBibGtfbWFrZV9yZXF1ZXN0KCkgZmFpbGVkXG4iKTsKKwkJCWdvdG8gZmFpbDsKKwkJfQorCQkvKgorCQkgKiBTZXR1cCB0aGUgbmV3bHkgYWxsb2NhdGVkIHN0cnVjdCByZXF1ZXN0IGZvciBSRVFfVFlQRV9CTE9DS19QQywKKwkJICogYW5kIHNldHVwIHJxIGNhbGxiYWNrLCBDREIgYW5kIHNlbnNlLgorCQkgKi8KKwkJcHNjc2lfYmxrX2luaXRfcmVxdWVzdCh0YXNrLCBwdCwgcHQtPnBzY3NpX3JlcSwgMCk7CisKKwkJcmV0dXJuIHRhc2stPnRhc2tfc2dfbnVtOworCX0KKwkvKgorCSAqIFNldHVwIHRoZSBzZWNvbmRhcnkgcHQtPnBzY3NpX3JlcS0+bmV4dF9ycSB1c2VkIGZvciB0aGUgZXh0cmEgQklESS1DT01NQU5ECisJICogU0NTSSBSRUFEIHBheWxhb2QgbWFwcGVkIGZvciBzdHJ1Y3Qgc2VfdGFzay0+dGFza19zZ19iaWRpW10KKwkgKi8KKwlwdC0+cHNjc2lfcmVxLT5uZXh0X3JxID0gYmxrX21ha2VfcmVxdWVzdChwZHYtPnBkdl9zZC0+cmVxdWVzdF9xdWV1ZSwKKwkJCQkJaGJpbywgR0ZQX0tFUk5FTCk7CisJaWYgKCEocHQtPnBzY3NpX3JlcS0+bmV4dF9ycSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJwU0NTSTogYmxrX21ha2VfcmVxdWVzdCgpIGZhaWxlZCBmb3IgQklESVxuIik7CisJCWdvdG8gZmFpbDsKKwl9CisJcHNjc2lfYmxrX2luaXRfcmVxdWVzdCh0YXNrLCBwdCwgcHQtPnBzY3NpX3JlcS0+bmV4dF9ycSwgMSk7CisKKwlyZXR1cm4gdGFzay0+dGFza19zZ19udW07CitmYWlsOgorCXdoaWxlIChoYmlvKSB7CisJCWJpbyA9IGhiaW87CisJCWhiaW8gPSBoYmlvLT5iaV9uZXh0OworCQliaW8tPmJpX25leHQgPSBOVUxMOworCQliaW9fZW5kaW8oYmlvLCAwKTsKKwl9CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBwc2NzaV9tYXBfdGFza19TRyhzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlpbnQgcmV0OworCisJLyoKKwkgKiBTZXR1cCB0aGUgbWFpbiBzdHJ1Y3QgcmVxdWVzdCBmb3IgdGhlIHRhc2stPnRhc2tfc2dbXSBwYXlsb2FkCisJICovCisKKwlyZXQgPSBfX3BzY3NpX21hcF90YXNrX1NHKHRhc2ssIHRhc2stPnRhc2tfc2csIHRhc2stPnRhc2tfc2dfbnVtLCAwKTsKKwlpZiAocmV0ID49IDAgJiYgdGFzay0+dGFza19zZ19iaWRpKSB7CisJCS8qCisJCSAqIElmIHByZXNlbnQsIHNldCB1cCB0aGUgZXh0cmEgQklESS1DT01NQU5EIFNDU0kgUkVBRAorCQkgKiBzdHJ1Y3QgcmVxdWVzdCBhbmQgcGF5bG9hZC4KKwkJICovCisJCXJldCA9IF9fcHNjc2lfbWFwX3Rhc2tfU0codGFzaywgdGFzay0+dGFza19zZ19iaWRpLAorCQkJCQl0YXNrLT50YXNrX3NnX251bSwgMSk7CisJfQorCisJaWYgKHJldCA8IDApCisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwlyZXR1cm4gMDsKK30KKworLyoJcHNjc2lfbWFwX3Rhc2tfbm9uX1NHKCk6CisgKgorICoKKyAqLworc3RhdGljIGludCBwc2NzaV9tYXBfdGFza19ub25fU0coc3RydWN0IHNlX3Rhc2sgKnRhc2spCit7CisJc3RydWN0IHNlX2NtZCAqY21kID0gVEFTS19DTUQodGFzayk7CisJc3RydWN0IHBzY3NpX3BsdWdpbl90YXNrICpwdCA9IFBTQ1NJX1RBU0sodGFzayk7CisJc3RydWN0IHBzY3NpX2Rldl92aXJ0ICpwZHYgPSB0YXNrLT5zZV9kZXYtPmRldl9wdHI7CisJaW50IHJldCA9IDA7CisKKwlpZiAocHNjc2lfYmxrX2dldF9yZXF1ZXN0KHRhc2spIDwgMCkKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfTFVfQ09NTV9GQUlMVVJFOworCisJaWYgKCF0YXNrLT50YXNrX3NpemUpCisJCXJldHVybiAwOworCisJcmV0ID0gYmxrX3JxX21hcF9rZXJuKHBkdi0+cGR2X3NkLT5yZXF1ZXN0X3F1ZXVlLAorCQkJcHQtPnBzY3NpX3JlcSwgVF9UQVNLKGNtZCktPnRfdGFza19idWYsCisJCQl0YXNrLT50YXNrX3NpemUsIEdGUF9LRVJORUwpOworCWlmIChyZXQgPCAwKSB7CisJCXByaW50ayhLRVJOX0VSUiAiUFNDU0k6IGJsa19ycV9tYXBfa2VybigpIGZhaWxlZDogJWRcbiIsIHJldCk7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgcHNjc2lfQ0RCX25vbmUoc3RydWN0IHNlX3Rhc2sgKnRhc2spCit7CisJcmV0dXJuIHBzY3NpX2Jsa19nZXRfcmVxdWVzdCh0YXNrKTsKK30KKworLyoJcHNjc2lfZ2V0X2NkYigpOgorICoKKyAqCisgKi8KK3N0YXRpYyB1bnNpZ25lZCBjaGFyICpwc2NzaV9nZXRfY2RiKHN0cnVjdCBzZV90YXNrICp0YXNrKQoreworCXN0cnVjdCBwc2NzaV9wbHVnaW5fdGFzayAqcHQgPSBQU0NTSV9UQVNLKHRhc2spOworCisJcmV0dXJuIHB0LT5wc2NzaV9jZGI7Cit9CisKKy8qCXBzY3NpX2dldF9zZW5zZV9idWZmZXIoKToKKyAqCisgKgorICovCitzdGF0aWMgdW5zaWduZWQgY2hhciAqcHNjc2lfZ2V0X3NlbnNlX2J1ZmZlcihzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlzdHJ1Y3QgcHNjc2lfcGx1Z2luX3Rhc2sgKnB0ID0gUFNDU0lfVEFTSyh0YXNrKTsKKworCXJldHVybiAodW5zaWduZWQgY2hhciAqKSZwdC0+cHNjc2lfc2Vuc2VbMF07Cit9CisKKy8qCXBzY3NpX2dldF9kZXZpY2VfcmV2KCk6CisgKgorICoKKyAqLworc3RhdGljIHUzMiBwc2NzaV9nZXRfZGV2aWNlX3JldihzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHBzY3NpX2Rldl92aXJ0ICpwZHYgPSBkZXYtPmRldl9wdHI7CisJc3RydWN0IHNjc2lfZGV2aWNlICpzZCA9IHBkdi0+cGR2X3NkOworCisJcmV0dXJuIChzZC0+c2NzaV9sZXZlbCAtIDEpID8gc2QtPnNjc2lfbGV2ZWwgLSAxIDogMTsKK30KKworLyoJcHNjc2lfZ2V0X2RldmljZV90eXBlKCk6CisgKgorICoKKyAqLworc3RhdGljIHUzMiBwc2NzaV9nZXRfZGV2aWNlX3R5cGUoc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBwc2NzaV9kZXZfdmlydCAqcGR2ID0gZGV2LT5kZXZfcHRyOworCXN0cnVjdCBzY3NpX2RldmljZSAqc2QgPSBwZHYtPnBkdl9zZDsKKworCXJldHVybiBzZC0+dHlwZTsKK30KKworc3RhdGljIHNlY3Rvcl90IHBzY3NpX2dldF9ibG9ja3Moc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBwc2NzaV9kZXZfdmlydCAqcGR2ID0gZGV2LT5kZXZfcHRyOworCisJaWYgKHBkdi0+cGR2X2JkICYmIHBkdi0+cGR2X2JkLT5iZF9wYXJ0KQorCQlyZXR1cm4gcGR2LT5wZHZfYmQtPmJkX3BhcnQtPm5yX3NlY3RzOworCisJZHVtcF9zdGFjaygpOworCXJldHVybiAwOworfQorCisvKglwc2NzaV9oYW5kbGVfU0FNX1NUQVRVU19mYWlsdXJlcygpOgorICoKKyAqCisgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZCBwc2NzaV9wcm9jZXNzX1NBTV9zdGF0dXMoCisJc3RydWN0IHNlX3Rhc2sgKnRhc2ssCisJc3RydWN0IHBzY3NpX3BsdWdpbl90YXNrICpwdCkKK3sKKwl0YXNrLT50YXNrX3Njc2lfc3RhdHVzID0gc3RhdHVzX2J5dGUocHQtPnBzY3NpX3Jlc3VsdCk7CisJaWYgKCh0YXNrLT50YXNrX3Njc2lfc3RhdHVzKSkgeworCQl0YXNrLT50YXNrX3Njc2lfc3RhdHVzIDw8PSAxOworCQlwcmludGsoS0VSTl9JTkZPICJQU0NTSSBTdGF0dXMgQnl0ZSBleGNlcHRpb24gYXQgdGFzazogJXAgQ0RCOiIKKwkJCSIgMHglMDJ4IFJlc3VsdDogMHglMDh4XG4iLCB0YXNrLCBwdC0+cHNjc2lfY2RiWzBdLAorCQkJcHQtPnBzY3NpX3Jlc3VsdCk7CisJfQorCisJc3dpdGNoIChob3N0X2J5dGUocHQtPnBzY3NpX3Jlc3VsdCkpIHsKKwljYXNlIERJRF9PSzoKKwkJdHJhbnNwb3J0X2NvbXBsZXRlX3Rhc2sodGFzaywgKCF0YXNrLT50YXNrX3Njc2lfc3RhdHVzKSk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXByaW50ayhLRVJOX0lORk8gIlBTQ1NJIEhvc3QgQnl0ZSBleGNlcHRpb24gYXQgdGFzazogJXAgQ0RCOiIKKwkJCSIgMHglMDJ4IFJlc3VsdDogMHglMDh4XG4iLCB0YXNrLCBwdC0+cHNjc2lfY2RiWzBdLAorCQkJcHQtPnBzY3NpX3Jlc3VsdCk7CisJCXRhc2stPnRhc2tfc2NzaV9zdGF0dXMgPSBTQU1fU1RBVF9DSEVDS19DT05ESVRJT047CisJCXRhc2stPnRhc2tfZXJyb3Jfc3RhdHVzID0gUFlYX1RSQU5TUE9SVF9VTktOT1dOX1NBTV9PUENPREU7CisJCVRBU0tfQ01EKHRhc2spLT50cmFuc3BvcnRfZXJyb3Jfc3RhdHVzID0KKwkJCQkJUFlYX1RSQU5TUE9SVF9VTktOT1dOX1NBTV9PUENPREU7CisJCXRyYW5zcG9ydF9jb21wbGV0ZV90YXNrKHRhc2ssIDApOworCQlicmVhazsKKwl9CisKKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkIHBzY3NpX3JlcV9kb25lKHN0cnVjdCByZXF1ZXN0ICpyZXEsIGludCB1cHRvZGF0ZSkKK3sKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzayA9IHJlcS0+ZW5kX2lvX2RhdGE7CisJc3RydWN0IHBzY3NpX3BsdWdpbl90YXNrICpwdCA9IFBTQ1NJX1RBU0sodGFzayk7CisKKwlwdC0+cHNjc2lfcmVzdWx0ID0gcmVxLT5lcnJvcnM7CisJcHQtPnBzY3NpX3Jlc2lkID0gcmVxLT5yZXNpZF9sZW47CisKKwlwc2NzaV9wcm9jZXNzX1NBTV9zdGF0dXModGFzaywgcHQpOworCS8qCisJICogUmVsZWFzZSBCSURJLVJFQUQgaWYgcHJlc2VudAorCSAqLworCWlmIChyZXEtPm5leHRfcnEgIT0gTlVMTCkKKwkJX19ibGtfcHV0X3JlcXVlc3QocmVxLT5xLCByZXEtPm5leHRfcnEpOworCisJX19ibGtfcHV0X3JlcXVlc3QocmVxLT5xLCByZXEpOworCXB0LT5wc2NzaV9yZXEgPSBOVUxMOworfQorCitzdGF0aWMgc3RydWN0IHNlX3N1YnN5c3RlbV9hcGkgcHNjc2lfdGVtcGxhdGUgPSB7CisJLm5hbWUJCQk9ICJwc2NzaSIsCisJLm93bmVyCQkJPSBUSElTX01PRFVMRSwKKwkudHJhbnNwb3J0X3R5cGUJCT0gVFJBTlNQT1JUX1BMVUdJTl9QSEJBX1BERVYsCisJLmNkYl9ub25lCQk9IHBzY3NpX0NEQl9ub25lLAorCS5tYXBfdGFza19ub25fU0cJPSBwc2NzaV9tYXBfdGFza19ub25fU0csCisJLm1hcF90YXNrX1NHCQk9IHBzY3NpX21hcF90YXNrX1NHLAorCS5hdHRhY2hfaGJhCQk9IHBzY3NpX2F0dGFjaF9oYmEsCisJLmRldGFjaF9oYmEJCT0gcHNjc2lfZGV0YWNoX2hiYSwKKwkucG1vZGVfZW5hYmxlX2hiYQk9IHBzY3NpX3Btb2RlX2VuYWJsZV9oYmEsCisJLmFsbG9jYXRlX3ZpcnRkZXZpY2UJPSBwc2NzaV9hbGxvY2F0ZV92aXJ0ZGV2aWNlLAorCS5jcmVhdGVfdmlydGRldmljZQk9IHBzY3NpX2NyZWF0ZV92aXJ0ZGV2aWNlLAorCS5mcmVlX2RldmljZQkJPSBwc2NzaV9mcmVlX2RldmljZSwKKwkudHJhbnNwb3J0X2NvbXBsZXRlCT0gcHNjc2lfdHJhbnNwb3J0X2NvbXBsZXRlLAorCS5hbGxvY190YXNrCQk9IHBzY3NpX2FsbG9jX3Rhc2ssCisJLmRvX3Rhc2sJCT0gcHNjc2lfZG9fdGFzaywKKwkuZnJlZV90YXNrCQk9IHBzY3NpX2ZyZWVfdGFzaywKKwkuY2hlY2tfY29uZmlnZnNfZGV2X3BhcmFtcyA9IHBzY3NpX2NoZWNrX2NvbmZpZ2ZzX2Rldl9wYXJhbXMsCisJLnNldF9jb25maWdmc19kZXZfcGFyYW1zID0gcHNjc2lfc2V0X2NvbmZpZ2ZzX2Rldl9wYXJhbXMsCisJLnNob3dfY29uZmlnZnNfZGV2X3BhcmFtcyA9IHBzY3NpX3Nob3dfY29uZmlnZnNfZGV2X3BhcmFtcywKKwkuZ2V0X2NkYgkJPSBwc2NzaV9nZXRfY2RiLAorCS5nZXRfc2Vuc2VfYnVmZmVyCT0gcHNjc2lfZ2V0X3NlbnNlX2J1ZmZlciwKKwkuZ2V0X2RldmljZV9yZXYJCT0gcHNjc2lfZ2V0X2RldmljZV9yZXYsCisJLmdldF9kZXZpY2VfdHlwZQk9IHBzY3NpX2dldF9kZXZpY2VfdHlwZSwKKwkuZ2V0X2Jsb2NrcwkJPSBwc2NzaV9nZXRfYmxvY2tzLAorfTsKKworc3RhdGljIGludCBfX2luaXQgcHNjc2lfbW9kdWxlX2luaXQodm9pZCkKK3sKKwlyZXR1cm4gdHJhbnNwb3J0X3N1YnN5c3RlbV9yZWdpc3RlcigmcHNjc2lfdGVtcGxhdGUpOworfQorCitzdGF0aWMgdm9pZCBwc2NzaV9tb2R1bGVfZXhpdCh2b2lkKQoreworCXRyYW5zcG9ydF9zdWJzeXN0ZW1fcmVsZWFzZSgmcHNjc2lfdGVtcGxhdGUpOworfQorCitNT0RVTEVfREVTQ1JJUFRJT04oIlRDTSBQU0NTSSBzdWJzeXN0ZW0gcGx1Z2luIik7CitNT0RVTEVfQVVUSE9SKCJuYWJATGludXgtaVNDU0kub3JnIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CisKK21vZHVsZV9pbml0KHBzY3NpX21vZHVsZV9pbml0KTsKK21vZHVsZV9leGl0KHBzY3NpX21vZHVsZV9leGl0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX3BzY3NpLmggYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9wc2NzaS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmE0Y2Q1ZDMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9wc2NzaS5oCkBAIC0wLDAgKzEsNjUgQEAKKyNpZm5kZWYgVEFSR0VUX0NPUkVfUFNDU0lfSAorI2RlZmluZSBUQVJHRVRfQ09SRV9QU0NTSV9ICisKKyNkZWZpbmUgUFNDU0lfVkVSU0lPTgkJInY0LjAiCisjZGVmaW5lIFBTQ1NJX1ZJUlRVQUxfSEJBX0RFUFRICTIwNDgKKworLyogdXNlZCBpbiBwc2NzaV9maW5kX2FsbG9jX2xlbigpICovCisjaWZuZGVmIElOUVVJUllfREFUQV9TSVpFCisjZGVmaW5lIElOUVVJUllfREFUQV9TSVpFCTB4MjQKKyNlbmRpZgorCisvKiB1c2VkIGluIHBzY3NpX2FkZF9kZXZpY2VfdG9fbGlzdCgpICovCisjZGVmaW5lIFBTQ1NJX0RFRkFVTFRfUVVFVUVERVBUSAkxCisKKyNkZWZpbmUgUFNfUkVUUlkJCTUKKyNkZWZpbmUgUFNfVElNRU9VVF9ESVNLCQkoMTUqSFopCisjZGVmaW5lIFBTX1RJTUVPVVRfT1RIRVIJKDUwMCpIWikKKworI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV9kcml2ZXIuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2lfZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgva3JlZi5oPgorI2luY2x1ZGUgPGxpbnV4L2tvYmplY3QuaD4KKworc3RydWN0IHBzY3NpX3BsdWdpbl90YXNrIHsKKwlzdHJ1Y3Qgc2VfdGFzayBwc2NzaV90YXNrOworCXVuc2lnbmVkIGNoYXIgKnBzY3NpX2NkYjsKKwl1bnNpZ25lZCBjaGFyIF9fcHNjc2lfY2RiW1RDTV9NQVhfQ09NTUFORF9TSVpFXTsKKwl1bnNpZ25lZCBjaGFyIHBzY3NpX3NlbnNlW1NDU0lfU0VOU0VfQlVGRkVSU0laRV07CisJaW50CXBzY3NpX2RpcmVjdGlvbjsKKwlpbnQJcHNjc2lfcmVzdWx0OworCXUzMglwc2NzaV9yZXNpZDsKKwlzdHJ1Y3QgcmVxdWVzdCAqcHNjc2lfcmVxOworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKKyNkZWZpbmUgUERGX0hBU19DSEFOTkVMX0lECTB4MDEKKyNkZWZpbmUgUERGX0hBU19UQVJHRVRfSUQJMHgwMgorI2RlZmluZSBQREZfSEFTX0xVTl9JRAkJMHgwNAorI2RlZmluZSBQREZfSEFTX1ZQRF9VTklUX1NFUklBTCAweDA4CisjZGVmaW5lIFBERl9IQVNfVlBEX0RFVl9JREVOVAkweDEwCisjZGVmaW5lIFBERl9IQVNfVklSVF9IT1NUX0lECTB4MjAKKworc3RydWN0IHBzY3NpX2Rldl92aXJ0IHsKKwlpbnQJcGR2X2ZsYWdzOworCWludAlwZHZfaG9zdF9pZDsKKwlpbnQJcGR2X2NoYW5uZWxfaWQ7CisJaW50CXBkdl90YXJnZXRfaWQ7CisJaW50CXBkdl9sdW5faWQ7CisJc3RydWN0IGJsb2NrX2RldmljZSAqcGR2X2JkOworCXN0cnVjdCBzY3NpX2RldmljZSAqcGR2X3NkOworCXN0cnVjdCBzZV9oYmEgKnBkdl9zZV9oYmE7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKwordHlwZWRlZiBlbnVtIHBodl9tb2RlcyB7CisJUEhWX1ZJUlVUQUxfSE9TVF9JRCwKKwlQSFZfTExEX1NDU0lfSE9TVF9OTworfSBwaHZfbW9kZXNfdDsKKworc3RydWN0IHBzY3NpX2hiYV92aXJ0IHsKKwlpbnQJCQlwaHZfaG9zdF9pZDsKKwlwaHZfbW9kZXNfdAkJcGh2X21vZGU7CisJc3RydWN0IFNjc2lfSG9zdAkqcGh2X2xsZF9ob3N0OworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKKyNlbmRpZiAgIC8qKiogVEFSR0VUX0NPUkVfUFNDU0lfSCAqKiovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9yZC5jIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfcmQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45NzlhZWJmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfcmQuYwpAQCAtMCwwICsxLDEwOTEgQEAKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBGaWxlbmFtZTogIHRhcmdldF9jb3JlX3JkLmMKKyAqCisgKiBUaGlzIGZpbGUgY29udGFpbnMgdGhlIFN0b3JhZ2UgRW5naW5lIDwtPiBSYW1kaXNrIHRyYW5zcG9ydAorICogc3BlY2lmaWMgZnVuY3Rpb25zLgorICoKKyAqIENvcHlyaWdodCAoYykgMjAwMywgMjAwNCwgMjAwNSBQeVggVGVjaG5vbG9naWVzLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDYsIDIwMDcgU0JFLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMDctMjAxMCBSaXNpbmcgVGlkZSBTeXN0ZW1zCisgKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxMCBMaW51eC1pU0NTSS5vcmcKKyAqCisgKiBOaWNob2xhcyBBLiBCZWxsaW5nZXIgPG5hYkBrZXJuZWwub3JnPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworI2luY2x1ZGUgPGxpbnV4L3ZlcnNpb24uaD4KKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KKyNpbmNsdWRlIDxsaW51eC9wYXJzZXIuaD4KKyNpbmNsdWRlIDxsaW51eC90aW1lci5oPgorI2luY2x1ZGUgPGxpbnV4L2Jsa2Rldi5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgorI2luY2x1ZGUgPGxpbnV4L3NtcF9sb2NrLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpX2hvc3QuaD4KKworI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9iYXNlLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV90cmFuc3BvcnQuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX29wcy5oPgorCisjaW5jbHVkZSAidGFyZ2V0X2NvcmVfcmQuaCIKKworc3RhdGljIHN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpIHJkX2RyX3RlbXBsYXRlOworc3RhdGljIHN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpIHJkX21jcF90ZW1wbGF0ZTsKKworLyogI2RlZmluZSBERUJVR19SQU1ESVNLX01DUCAqLworLyogI2RlZmluZSBERUJVR19SQU1ESVNLX0RSICovCisKKy8qCXJkX2F0dGFjaF9oYmEoKTogKFBhcnQgb2Ygc2Vfc3Vic3lzdGVtX2FwaV90IHRlbXBsYXRlKQorICoKKyAqCisgKi8KK3N0YXRpYyBpbnQgcmRfYXR0YWNoX2hiYShzdHJ1Y3Qgc2VfaGJhICpoYmEsIHUzMiBob3N0X2lkKQoreworCXN0cnVjdCByZF9ob3N0ICpyZF9ob3N0OworCisJcmRfaG9zdCA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCByZF9ob3N0KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCEocmRfaG9zdCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgbWVtb3J5IGZvciBzdHJ1Y3QgcmRfaG9zdFxuIik7CisJCXJldHVybiAtRU5PTUVNOworCX0KKworCXJkX2hvc3QtPnJkX2hvc3RfaWQgPSBob3N0X2lkOworCisJYXRvbWljX3NldCgmaGJhLT5sZWZ0X3F1ZXVlX2RlcHRoLCBSRF9IQkFfUVVFVUVfREVQVEgpOworCWF0b21pY19zZXQoJmhiYS0+bWF4X3F1ZXVlX2RlcHRoLCBSRF9IQkFfUVVFVUVfREVQVEgpOworCWhiYS0+aGJhX3B0ciA9ICh2b2lkICopIHJkX2hvc3Q7CisKKwlwcmludGsoS0VSTl9JTkZPICJDT1JFX0hCQVslZF0gLSBUQ00gUmFtZGlzayBIQkEgRHJpdmVyICVzIG9uIgorCQkiIEdlbmVyaWMgVGFyZ2V0IENvcmUgU3RhY2sgJXNcbiIsIGhiYS0+aGJhX2lkLAorCQlSRF9IQkFfVkVSU0lPTiwgVEFSR0VUX0NPUkVfTU9EX1ZFUlNJT04pOworCXByaW50ayhLRVJOX0lORk8gIkNPUkVfSEJBWyVkXSAtIEF0dGFjaGVkIFJhbWRpc2sgSEJBOiAldSB0byBHZW5lcmljIgorCQkiIFRhcmdldCBDb3JlIFRDUSBEZXB0aDogJWQgTWF4U2VjdG9yczogJXVcbiIsIGhiYS0+aGJhX2lkLAorCQlyZF9ob3N0LT5yZF9ob3N0X2lkLCBhdG9taWNfcmVhZCgmaGJhLT5tYXhfcXVldWVfZGVwdGgpLAorCQlSRF9NQVhfU0VDVE9SUyk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgcmRfZGV0YWNoX2hiYShzdHJ1Y3Qgc2VfaGJhICpoYmEpCit7CisJc3RydWN0IHJkX2hvc3QgKnJkX2hvc3QgPSBoYmEtPmhiYV9wdHI7CisKKwlwcmludGsoS0VSTl9JTkZPICJDT1JFX0hCQVslZF0gLSBEZXRhY2hlZCBSYW1kaXNrIEhCQTogJXUgZnJvbSIKKwkJIiBHZW5lcmljIFRhcmdldCBDb3JlXG4iLCBoYmEtPmhiYV9pZCwgcmRfaG9zdC0+cmRfaG9zdF9pZCk7CisKKwlrZnJlZShyZF9ob3N0KTsKKwloYmEtPmhiYV9wdHIgPSBOVUxMOworfQorCisvKglyZF9yZWxlYXNlX2RldmljZV9zcGFjZSgpOgorICoKKyAqCisgKi8KK3N0YXRpYyB2b2lkIHJkX3JlbGVhc2VfZGV2aWNlX3NwYWNlKHN0cnVjdCByZF9kZXYgKnJkX2RldikKK3sKKwl1MzIgaSwgaiwgcGFnZV9jb3VudCA9IDAsIHNnX3Blcl90YWJsZTsKKwlzdHJ1Y3QgcmRfZGV2X3NnX3RhYmxlICpzZ190YWJsZTsKKwlzdHJ1Y3QgcGFnZSAqcGc7CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZzsKKworCWlmICghcmRfZGV2LT5zZ190YWJsZV9hcnJheSB8fCAhcmRfZGV2LT5zZ190YWJsZV9jb3VudCkKKwkJcmV0dXJuOworCisJc2dfdGFibGUgPSByZF9kZXYtPnNnX3RhYmxlX2FycmF5OworCisJZm9yIChpID0gMDsgaSA8IHJkX2Rldi0+c2dfdGFibGVfY291bnQ7IGkrKykgeworCQlzZyA9IHNnX3RhYmxlW2ldLnNnX3RhYmxlOworCQlzZ19wZXJfdGFibGUgPSBzZ190YWJsZVtpXS5yZF9zZ19jb3VudDsKKworCQlmb3IgKGogPSAwOyBqIDwgc2dfcGVyX3RhYmxlOyBqKyspIHsKKwkJCXBnID0gc2dfcGFnZSgmc2dbal0pOworCQkJaWYgKChwZykpIHsKKwkJCQlfX2ZyZWVfcGFnZShwZyk7CisJCQkJcGFnZV9jb3VudCsrOworCQkJfQorCQl9CisKKwkJa2ZyZWUoc2cpOworCX0KKworCXByaW50ayhLRVJOX0lORk8gIkNPUkVfUkRbJXVdIC0gUmVsZWFzZWQgZGV2aWNlIHNwYWNlIGZvciBSYW1kaXNrIgorCQkiIERldmljZSBJRDogJXUsIHBhZ2VzICV1IGluICV1IHRhYmxlcyB0b3RhbCBieXRlcyAlbHVcbiIsCisJCXJkX2Rldi0+cmRfaG9zdC0+cmRfaG9zdF9pZCwgcmRfZGV2LT5yZF9kZXZfaWQsIHBhZ2VfY291bnQsCisJCXJkX2Rldi0+c2dfdGFibGVfY291bnQsICh1bnNpZ25lZCBsb25nKXBhZ2VfY291bnQgKiBQQUdFX1NJWkUpOworCisJa2ZyZWUoc2dfdGFibGUpOworCXJkX2Rldi0+c2dfdGFibGVfYXJyYXkgPSBOVUxMOworCXJkX2Rldi0+c2dfdGFibGVfY291bnQgPSAwOworfQorCisKKy8qCXJkX2J1aWxkX2RldmljZV9zcGFjZSgpOgorICoKKyAqCisgKi8KK3N0YXRpYyBpbnQgcmRfYnVpbGRfZGV2aWNlX3NwYWNlKHN0cnVjdCByZF9kZXYgKnJkX2RldikKK3sKKwl1MzIgaSA9IDAsIGosIHBhZ2Vfb2Zmc2V0ID0gMCwgc2dfcGVyX3RhYmxlLCBzZ190YWJsZXMsIHRvdGFsX3NnX25lZWRlZDsKKwl1MzIgbWF4X3NnX3Blcl90YWJsZSA9IChSRF9NQVhfQUxMT0NBVElPTl9TSVpFIC8KKwkJCQlzaXplb2Yoc3RydWN0IHNjYXR0ZXJsaXN0KSk7CisJc3RydWN0IHJkX2Rldl9zZ190YWJsZSAqc2dfdGFibGU7CisJc3RydWN0IHBhZ2UgKnBnOworCXN0cnVjdCBzY2F0dGVybGlzdCAqc2c7CisKKwlpZiAocmRfZGV2LT5yZF9wYWdlX2NvdW50IDw9IDApIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJJbGxlZ2FsIHBhZ2UgY291bnQ6ICV1IGZvciBSYW1kaXNrIGRldmljZVxuIiwKKwkJCXJkX2Rldi0+cmRfcGFnZV9jb3VudCk7CisJCXJldHVybiAtMTsKKwl9CisJdG90YWxfc2dfbmVlZGVkID0gcmRfZGV2LT5yZF9wYWdlX2NvdW50OworCisJc2dfdGFibGVzID0gKHRvdGFsX3NnX25lZWRlZCAvIG1heF9zZ19wZXJfdGFibGUpICsgMTsKKworCXNnX3RhYmxlID0ga3phbGxvYyhzZ190YWJsZXMgKiBzaXplb2Yoc3RydWN0IHJkX2Rldl9zZ190YWJsZSksIEdGUF9LRVJORUwpOworCWlmICghKHNnX3RhYmxlKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIFJhbWRpc2siCisJCQkiIHNjYXR0ZXJsaXN0IHRhYmxlc1xuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlyZF9kZXYtPnNnX3RhYmxlX2FycmF5ID0gc2dfdGFibGU7CisJcmRfZGV2LT5zZ190YWJsZV9jb3VudCA9IHNnX3RhYmxlczsKKworCXdoaWxlICh0b3RhbF9zZ19uZWVkZWQpIHsKKwkJc2dfcGVyX3RhYmxlID0gKHRvdGFsX3NnX25lZWRlZCA+IG1heF9zZ19wZXJfdGFibGUpID8KKwkJCW1heF9zZ19wZXJfdGFibGUgOiB0b3RhbF9zZ19uZWVkZWQ7CisKKwkJc2cgPSBremFsbG9jKHNnX3Blcl90YWJsZSAqIHNpemVvZihzdHJ1Y3Qgc2NhdHRlcmxpc3QpLAorCQkJCUdGUF9LRVJORUwpOworCQlpZiAoIShzZykpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIHNjYXR0ZXJsaXN0IGFycmF5IgorCQkJCSIgZm9yIHN0cnVjdCByZF9kZXZcbiIpOworCQkJcmV0dXJuIC0xOworCQl9CisKKwkJc2dfaW5pdF90YWJsZSgoc3RydWN0IHNjYXR0ZXJsaXN0ICopJnNnWzBdLCBzZ19wZXJfdGFibGUpOworCisJCXNnX3RhYmxlW2ldLnNnX3RhYmxlID0gc2c7CisJCXNnX3RhYmxlW2ldLnJkX3NnX2NvdW50ID0gc2dfcGVyX3RhYmxlOworCQlzZ190YWJsZVtpXS5wYWdlX3N0YXJ0X29mZnNldCA9IHBhZ2Vfb2Zmc2V0OworCQlzZ190YWJsZVtpKytdLnBhZ2VfZW5kX29mZnNldCA9IChwYWdlX29mZnNldCArIHNnX3Blcl90YWJsZSkKKwkJCQkJCS0gMTsKKworCQlmb3IgKGogPSAwOyBqIDwgc2dfcGVyX3RhYmxlOyBqKyspIHsKKwkJCXBnID0gYWxsb2NfcGFnZXMoR0ZQX0tFUk5FTCwgMCk7CisJCQlpZiAoIShwZykpIHsKKwkJCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBzY2F0dGVybGlzdCIKKwkJCQkJIiBwYWdlcyBmb3Igc3RydWN0IHJkX2Rldl9zZ190YWJsZVxuIik7CisJCQkJcmV0dXJuIC0xOworCQkJfQorCQkJc2dfYXNzaWduX3BhZ2UoJnNnW2pdLCBwZyk7CisJCQlzZ1tqXS5sZW5ndGggPSBQQUdFX1NJWkU7CisJCX0KKworCQlwYWdlX29mZnNldCArPSBzZ19wZXJfdGFibGU7CisJCXRvdGFsX3NnX25lZWRlZCAtPSBzZ19wZXJfdGFibGU7CisJfQorCisJcHJpbnRrKEtFUk5fSU5GTyAiQ09SRV9SRFsldV0gLSBCdWlsdCBSYW1kaXNrIERldmljZSBJRDogJXUgc3BhY2Ugb2YiCisJCSIgJXUgcGFnZXMgaW4gJXUgdGFibGVzXG4iLCByZF9kZXYtPnJkX2hvc3QtPnJkX2hvc3RfaWQsCisJCXJkX2Rldi0+cmRfZGV2X2lkLCByZF9kZXYtPnJkX3BhZ2VfY291bnQsCisJCXJkX2Rldi0+c2dfdGFibGVfY291bnQpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkICpyZF9hbGxvY2F0ZV92aXJ0ZGV2aWNlKAorCXN0cnVjdCBzZV9oYmEgKmhiYSwKKwljb25zdCBjaGFyICpuYW1lLAorCWludCByZF9kaXJlY3QpCit7CisJc3RydWN0IHJkX2RldiAqcmRfZGV2OworCXN0cnVjdCByZF9ob3N0ICpyZF9ob3N0ID0gaGJhLT5oYmFfcHRyOworCisJcmRfZGV2ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHJkX2RldiksIEdGUF9LRVJORUwpOworCWlmICghKHJkX2RldikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgbWVtb3J5IGZvciBzdHJ1Y3QgcmRfZGV2XG4iKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJcmRfZGV2LT5yZF9ob3N0ID0gcmRfaG9zdDsKKwlyZF9kZXYtPnJkX2RpcmVjdCA9IHJkX2RpcmVjdDsKKworCXJldHVybiByZF9kZXY7Cit9CisKK3N0YXRpYyB2b2lkICpyZF9ESVJFQ1RfYWxsb2NhdGVfdmlydGRldmljZShzdHJ1Y3Qgc2VfaGJhICpoYmEsIGNvbnN0IGNoYXIgKm5hbWUpCit7CisJcmV0dXJuIHJkX2FsbG9jYXRlX3ZpcnRkZXZpY2UoaGJhLCBuYW1lLCAxKTsKK30KKworc3RhdGljIHZvaWQgKnJkX01FTUNQWV9hbGxvY2F0ZV92aXJ0ZGV2aWNlKHN0cnVjdCBzZV9oYmEgKmhiYSwgY29uc3QgY2hhciAqbmFtZSkKK3sKKwlyZXR1cm4gcmRfYWxsb2NhdGVfdmlydGRldmljZShoYmEsIG5hbWUsIDApOworfQorCisvKglyZF9jcmVhdGVfdmlydGRldmljZSgpOgorICoKKyAqCisgKi8KK3N0YXRpYyBzdHJ1Y3Qgc2VfZGV2aWNlICpyZF9jcmVhdGVfdmlydGRldmljZSgKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEsCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiwKKwl2b2lkICpwLAorCWludCByZF9kaXJlY3QpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2OworCXN0cnVjdCBzZV9kZXZfbGltaXRzIGRldl9saW1pdHM7CisJc3RydWN0IHJkX2RldiAqcmRfZGV2ID0gcDsKKwlzdHJ1Y3QgcmRfaG9zdCAqcmRfaG9zdCA9IGhiYS0+aGJhX3B0cjsKKwlpbnQgZGV2X2ZsYWdzID0gMDsKKwljaGFyIHByb2RbMTZdLCByZXZbNF07CisKKwltZW1zZXQoJmRldl9saW1pdHMsIDAsIHNpemVvZihzdHJ1Y3Qgc2VfZGV2X2xpbWl0cykpOworCisJaWYgKHJkX2J1aWxkX2RldmljZV9zcGFjZShyZF9kZXYpIDwgMCkKKwkJZ290byBmYWlsOworCisJc25wcmludGYocHJvZCwgMTYsICJSQU1ESVNLLSVzIiwgKHJkX2Rldi0+cmRfZGlyZWN0KSA/ICJEUiIgOiAiTUNQIik7CisJc25wcmludGYocmV2LCA0LCAiJXMiLCAocmRfZGV2LT5yZF9kaXJlY3QpID8gUkRfRFJfVkVSU0lPTiA6CisJCQkJCQlSRF9NQ1BfVkVSU0lPTik7CisKKwlkZXZfbGltaXRzLmxpbWl0cy5sb2dpY2FsX2Jsb2NrX3NpemUgPSBSRF9CTE9DS1NJWkU7CisJZGV2X2xpbWl0cy5saW1pdHMubWF4X2h3X3NlY3RvcnMgPSBSRF9NQVhfU0VDVE9SUzsKKwlkZXZfbGltaXRzLmxpbWl0cy5tYXhfc2VjdG9ycyA9IFJEX01BWF9TRUNUT1JTOworCWRldl9saW1pdHMuaHdfcXVldWVfZGVwdGggPSBSRF9NQVhfREVWSUNFX1FVRVVFX0RFUFRIOworCWRldl9saW1pdHMucXVldWVfZGVwdGggPSBSRF9ERVZJQ0VfUVVFVUVfREVQVEg7CisKKwlkZXYgPSB0cmFuc3BvcnRfYWRkX2RldmljZV90b19jb3JlX2hiYShoYmEsCisJCQkocmRfZGV2LT5yZF9kaXJlY3QpID8gJnJkX2RyX3RlbXBsYXRlIDoKKwkJCSZyZF9tY3BfdGVtcGxhdGUsIHNlX2RldiwgZGV2X2ZsYWdzLCAodm9pZCAqKXJkX2RldiwKKwkJCSZkZXZfbGltaXRzLCBwcm9kLCByZXYpOworCWlmICghKGRldikpCisJCWdvdG8gZmFpbDsKKworCXJkX2Rldi0+cmRfZGV2X2lkID0gcmRfaG9zdC0+cmRfaG9zdF9kZXZfaWRfY291bnQrKzsKKwlyZF9kZXYtPnJkX3F1ZXVlX2RlcHRoID0gZGV2LT5xdWV1ZV9kZXB0aDsKKworCXByaW50ayhLRVJOX0lORk8gIkNPUkVfUkRbJXVdIC0gQWRkZWQgVENNICVzIFJhbWRpc2sgRGV2aWNlIElEOiAldSBvZiIKKwkJIiAldSBwYWdlcyBpbiAldSB0YWJsZXMsICVsdSB0b3RhbCBieXRlc1xuIiwKKwkJcmRfaG9zdC0+cmRfaG9zdF9pZCwgKCFyZF9kZXYtPnJkX2RpcmVjdCkgPyAiTUVNQ1BZIiA6CisJCSJESVJFQ1QiLCByZF9kZXYtPnJkX2Rldl9pZCwgcmRfZGV2LT5yZF9wYWdlX2NvdW50LAorCQlyZF9kZXYtPnNnX3RhYmxlX2NvdW50LAorCQkodW5zaWduZWQgbG9uZykocmRfZGV2LT5yZF9wYWdlX2NvdW50ICogUEFHRV9TSVpFKSk7CisKKwlyZXR1cm4gZGV2OworCitmYWlsOgorCXJkX3JlbGVhc2VfZGV2aWNlX3NwYWNlKHJkX2Rldik7CisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc2VfZGV2aWNlICpyZF9ESVJFQ1RfY3JlYXRlX3ZpcnRkZXZpY2UoCisJc3RydWN0IHNlX2hiYSAqaGJhLAorCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzZV9kZXYsCisJdm9pZCAqcCkKK3sKKwlyZXR1cm4gcmRfY3JlYXRlX3ZpcnRkZXZpY2UoaGJhLCBzZV9kZXYsIHAsIDEpOworfQorCitzdGF0aWMgc3RydWN0IHNlX2RldmljZSAqcmRfTUVNQ1BZX2NyZWF0ZV92aXJ0ZGV2aWNlKAorCXN0cnVjdCBzZV9oYmEgKmhiYSwKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc2VfZGV2LAorCXZvaWQgKnApCit7CisJcmV0dXJuIHJkX2NyZWF0ZV92aXJ0ZGV2aWNlKGhiYSwgc2VfZGV2LCBwLCAwKTsKK30KKworLyoJcmRfZnJlZV9kZXZpY2UoKTogKFBhcnQgb2Ygc2Vfc3Vic3lzdGVtX2FwaV90IHRlbXBsYXRlKQorICoKKyAqCisgKi8KK3N0YXRpYyB2b2lkIHJkX2ZyZWVfZGV2aWNlKHZvaWQgKnApCit7CisJc3RydWN0IHJkX2RldiAqcmRfZGV2ID0gcDsKKworCXJkX3JlbGVhc2VfZGV2aWNlX3NwYWNlKHJkX2Rldik7CisJa2ZyZWUocmRfZGV2KTsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3QgcmRfcmVxdWVzdCAqUkRfUkVRKHN0cnVjdCBzZV90YXNrICp0YXNrKQoreworCXJldHVybiBjb250YWluZXJfb2YodGFzaywgc3RydWN0IHJkX3JlcXVlc3QsIHJkX3Rhc2spOworfQorCitzdGF0aWMgc3RydWN0IHNlX3Rhc2sgKgorcmRfYWxsb2NfdGFzayhzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHJkX3JlcXVlc3QgKnJkX3JlcTsKKworCXJkX3JlcSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCByZF9yZXF1ZXN0KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFyZF9yZXEpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgc3RydWN0IHJkX3JlcXVlc3RcbiIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisJcmRfcmVxLT5yZF9kZXYgPSBTRV9ERVYoY21kKS0+ZGV2X3B0cjsKKworCXJldHVybiAmcmRfcmVxLT5yZF90YXNrOworfQorCisvKglyZF9nZXRfc2dfdGFibGUoKToKKyAqCisgKgorICovCitzdGF0aWMgc3RydWN0IHJkX2Rldl9zZ190YWJsZSAqcmRfZ2V0X3NnX3RhYmxlKHN0cnVjdCByZF9kZXYgKnJkX2RldiwgdTMyIHBhZ2UpCit7CisJdTMyIGk7CisJc3RydWN0IHJkX2Rldl9zZ190YWJsZSAqc2dfdGFibGU7CisKKwlmb3IgKGkgPSAwOyBpIDwgcmRfZGV2LT5zZ190YWJsZV9jb3VudDsgaSsrKSB7CisJCXNnX3RhYmxlID0gJnJkX2Rldi0+c2dfdGFibGVfYXJyYXlbaV07CisJCWlmICgoc2dfdGFibGUtPnBhZ2Vfc3RhcnRfb2Zmc2V0IDw9IHBhZ2UpICYmCisJCSAgICAoc2dfdGFibGUtPnBhZ2VfZW5kX29mZnNldCA+PSBwYWdlKSkKKwkJCXJldHVybiBzZ190YWJsZTsKKwl9CisKKwlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2NhdGUgc3RydWN0IHJkX2Rldl9zZ190YWJsZSBmb3IgcGFnZTogJXVcbiIsCisJCQlwYWdlKTsKKworCXJldHVybiBOVUxMOworfQorCisvKglyZF9NRU1DUFlfcmVhZCgpOgorICoKKyAqCisgKi8KK3N0YXRpYyBpbnQgcmRfTUVNQ1BZX3JlYWQoc3RydWN0IHJkX3JlcXVlc3QgKnJlcSkKK3sKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzayA9ICZyZXEtPnJkX3Rhc2s7CisJc3RydWN0IHJkX2RldiAqZGV2ID0gcmVxLT5yZF9kZXY7CisJc3RydWN0IHJkX2Rldl9zZ190YWJsZSAqdGFibGU7CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZ19kLCAqc2dfczsKKwl2b2lkICpkc3QsICpzcmM7CisJdTMyIGkgPSAwLCBqID0gMCwgZHN0X29mZnNldCA9IDAsIHNyY19vZmZzZXQgPSAwOworCXUzMiBsZW5ndGgsIHBhZ2VfZW5kID0gMCwgdGFibGVfc2dfZW5kOworCXUzMiByZF9vZmZzZXQgPSByZXEtPnJkX29mZnNldDsKKworCXRhYmxlID0gcmRfZ2V0X3NnX3RhYmxlKGRldiwgcmVxLT5yZF9wYWdlKTsKKwlpZiAoISh0YWJsZSkpCisJCXJldHVybiAtMTsKKworCXRhYmxlX3NnX2VuZCA9ICh0YWJsZS0+cGFnZV9lbmRfb2Zmc2V0IC0gcmVxLT5yZF9wYWdlKTsKKwlzZ19kID0gdGFzay0+dGFza19zZzsKKwlzZ19zID0gJnRhYmxlLT5zZ190YWJsZVtyZXEtPnJkX3BhZ2UgLSB0YWJsZS0+cGFnZV9zdGFydF9vZmZzZXRdOworI2lmZGVmIERFQlVHX1JBTURJU0tfTUNQCisJcHJpbnRrKEtFUk5fSU5GTyAiUkRbJXVdOiBSZWFkIExCQTogJWxsdSwgU2l6ZTogJXUgUGFnZTogJXUsIE9mZnNldDoiCisJCSIgJXVcbiIsIGRldi0+cmRfZGV2X2lkLCB0YXNrLT50YXNrX2xiYSwgcmVxLT5yZF9zaXplLAorCQlyZXEtPnJkX3BhZ2UsIHJlcS0+cmRfb2Zmc2V0KTsKKyNlbmRpZgorCXNyY19vZmZzZXQgPSByZF9vZmZzZXQ7CisKKwl3aGlsZSAocmVxLT5yZF9zaXplKSB7CisJCWlmICgoc2dfZFtpXS5sZW5ndGggLSBkc3Rfb2Zmc2V0KSA8CisJCSAgICAoc2dfc1tqXS5sZW5ndGggLSBzcmNfb2Zmc2V0KSkgeworCQkJbGVuZ3RoID0gKHNnX2RbaV0ubGVuZ3RoIC0gZHN0X29mZnNldCk7CisjaWZkZWYgREVCVUdfUkFNRElTS19NQ1AKKwkJCXByaW50ayhLRVJOX0lORk8gIlN0ZXAgMSAtIHNnX2RbJWRdOiAlcCBsZW5ndGg6ICVkIgorCQkJCSIgb2Zmc2V0OiAldSBzZ19zWyVkXS5sZW5ndGg6ICV1XG4iLCBpLAorCQkJCSZzZ19kW2ldLCBzZ19kW2ldLmxlbmd0aCwgc2dfZFtpXS5vZmZzZXQsIGosCisJCQkJc2dfc1tqXS5sZW5ndGgpOworCQkJcHJpbnRrKEtFUk5fSU5GTyAiU3RlcCAxIC0gbGVuZ3RoOiAldSBkc3Rfb2Zmc2V0OiAldSIKKwkJCQkiIHNyY19vZmZzZXQ6ICV1XG4iLCBsZW5ndGgsIGRzdF9vZmZzZXQsCisJCQkJc3JjX29mZnNldCk7CisjZW5kaWYKKwkJCWlmIChsZW5ndGggPiByZXEtPnJkX3NpemUpCisJCQkJbGVuZ3RoID0gcmVxLT5yZF9zaXplOworCisJCQlkc3QgPSBzZ192aXJ0KCZzZ19kW2krK10pICsgZHN0X29mZnNldDsKKwkJCWlmICghZHN0KQorCQkJCUJVRygpOworCisJCQlzcmMgPSBzZ192aXJ0KCZzZ19zW2pdKSArIHNyY19vZmZzZXQ7CisJCQlpZiAoIXNyYykKKwkJCQlCVUcoKTsKKworCQkJZHN0X29mZnNldCA9IDA7CisJCQlzcmNfb2Zmc2V0ID0gbGVuZ3RoOworCQkJcGFnZV9lbmQgPSAwOworCQl9IGVsc2UgeworCQkJbGVuZ3RoID0gKHNnX3Nbal0ubGVuZ3RoIC0gc3JjX29mZnNldCk7CisjaWZkZWYgREVCVUdfUkFNRElTS19NQ1AKKwkJCXByaW50ayhLRVJOX0lORk8gIlN0ZXAgMiAtIHNnX2RbJWRdOiAlcCBsZW5ndGg6ICVkIgorCQkJCSIgb2Zmc2V0OiAldSBzZ19zWyVkXS5sZW5ndGg6ICV1XG4iLCBpLAorCQkJCSZzZ19kW2ldLCBzZ19kW2ldLmxlbmd0aCwgc2dfZFtpXS5vZmZzZXQsCisJCQkJaiwgc2dfc1tqXS5sZW5ndGgpOworCQkJcHJpbnRrKEtFUk5fSU5GTyAiU3RlcCAyIC0gbGVuZ3RoOiAldSBkc3Rfb2Zmc2V0OiAldSIKKwkJCQkiIHNyY19vZmZzZXQ6ICV1XG4iLCBsZW5ndGgsIGRzdF9vZmZzZXQsCisJCQkJc3JjX29mZnNldCk7CisjZW5kaWYKKwkJCWlmIChsZW5ndGggPiByZXEtPnJkX3NpemUpCisJCQkJbGVuZ3RoID0gcmVxLT5yZF9zaXplOworCisJCQlkc3QgPSBzZ192aXJ0KCZzZ19kW2ldKSArIGRzdF9vZmZzZXQ7CisJCQlpZiAoIWRzdCkKKwkJCQlCVUcoKTsKKworCQkJaWYgKHNnX2RbaV0ubGVuZ3RoID09IGxlbmd0aCkgeworCQkJCWkrKzsKKwkJCQlkc3Rfb2Zmc2V0ID0gMDsKKwkJCX0gZWxzZQorCQkJCWRzdF9vZmZzZXQgPSBsZW5ndGg7CisKKwkJCXNyYyA9IHNnX3ZpcnQoJnNnX3NbaisrXSkgKyBzcmNfb2Zmc2V0OworCQkJaWYgKCFzcmMpCisJCQkJQlVHKCk7CisKKwkJCXNyY19vZmZzZXQgPSAwOworCQkJcGFnZV9lbmQgPSAxOworCQl9CisKKwkJbWVtY3B5KGRzdCwgc3JjLCBsZW5ndGgpOworCisjaWZkZWYgREVCVUdfUkFNRElTS19NQ1AKKwkJcHJpbnRrKEtFUk5fSU5GTyAicGFnZTogJXUsIHJlbWFpbmluZyBzaXplOiAldSwgbGVuZ3RoOiAldSwiCisJCQkiIGk6ICV1LCBqOiAldVxuIiwgcmVxLT5yZF9wYWdlLAorCQkJKHJlcS0+cmRfc2l6ZSAtIGxlbmd0aCksIGxlbmd0aCwgaSwgaik7CisjZW5kaWYKKwkJcmVxLT5yZF9zaXplIC09IGxlbmd0aDsKKwkJaWYgKCEocmVxLT5yZF9zaXplKSkKKwkJCXJldHVybiAwOworCisJCWlmICghcGFnZV9lbmQpCisJCQljb250aW51ZTsKKworCQlpZiAoKytyZXEtPnJkX3BhZ2UgPD0gdGFibGUtPnBhZ2VfZW5kX29mZnNldCkgeworI2lmZGVmIERFQlVHX1JBTURJU0tfTUNQCisJCQlwcmludGsoS0VSTl9JTkZPICJwYWdlOiAldSBpbiBzYW1lIHBhZ2UgdGFibGVcbiIsCisJCQkJcmVxLT5yZF9wYWdlKTsKKyNlbmRpZgorCQkJY29udGludWU7CisJCX0KKyNpZmRlZiBERUJVR19SQU1ESVNLX01DUAorCQlwcmludGsoS0VSTl9JTkZPICJnZXR0aW5nIG5ldyBwYWdlIHRhYmxlIGZvciBwYWdlOiAldVxuIiwKKwkJCQlyZXEtPnJkX3BhZ2UpOworI2VuZGlmCisJCXRhYmxlID0gcmRfZ2V0X3NnX3RhYmxlKGRldiwgcmVxLT5yZF9wYWdlKTsKKwkJaWYgKCEodGFibGUpKQorCQkJcmV0dXJuIC0xOworCisJCXNnX3MgPSAmdGFibGUtPnNnX3RhYmxlW2ogPSAwXTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworLyoJcmRfTUVNQ1BZX3dyaXRlKCk6CisgKgorICoKKyAqLworc3RhdGljIGludCByZF9NRU1DUFlfd3JpdGUoc3RydWN0IHJkX3JlcXVlc3QgKnJlcSkKK3sKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzayA9ICZyZXEtPnJkX3Rhc2s7CisJc3RydWN0IHJkX2RldiAqZGV2ID0gcmVxLT5yZF9kZXY7CisJc3RydWN0IHJkX2Rldl9zZ190YWJsZSAqdGFibGU7CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZ19kLCAqc2dfczsKKwl2b2lkICpkc3QsICpzcmM7CisJdTMyIGkgPSAwLCBqID0gMCwgZHN0X29mZnNldCA9IDAsIHNyY19vZmZzZXQgPSAwOworCXUzMiBsZW5ndGgsIHBhZ2VfZW5kID0gMCwgdGFibGVfc2dfZW5kOworCXUzMiByZF9vZmZzZXQgPSByZXEtPnJkX29mZnNldDsKKworCXRhYmxlID0gcmRfZ2V0X3NnX3RhYmxlKGRldiwgcmVxLT5yZF9wYWdlKTsKKwlpZiAoISh0YWJsZSkpCisJCXJldHVybiAtMTsKKworCXRhYmxlX3NnX2VuZCA9ICh0YWJsZS0+cGFnZV9lbmRfb2Zmc2V0IC0gcmVxLT5yZF9wYWdlKTsKKwlzZ19kID0gJnRhYmxlLT5zZ190YWJsZVtyZXEtPnJkX3BhZ2UgLSB0YWJsZS0+cGFnZV9zdGFydF9vZmZzZXRdOworCXNnX3MgPSB0YXNrLT50YXNrX3NnOworI2lmZGVmIERFQlVHX1JBTURJU0tfTUNQCisJcHJpbnRrKEtFUk5fSU5GTyAiUkRbJWRdIFdyaXRlIExCQTogJWxsdSwgU2l6ZTogJXUsIFBhZ2U6ICV1LCIKKwkJIiBPZmZzZXQ6ICV1XG4iLCBkZXYtPnJkX2Rldl9pZCwgdGFzay0+dGFza19sYmEsIHJlcS0+cmRfc2l6ZSwKKwkJcmVxLT5yZF9wYWdlLCByZXEtPnJkX29mZnNldCk7CisjZW5kaWYKKwlkc3Rfb2Zmc2V0ID0gcmRfb2Zmc2V0OworCisJd2hpbGUgKHJlcS0+cmRfc2l6ZSkgeworCQlpZiAoKHNnX3NbaV0ubGVuZ3RoIC0gc3JjX29mZnNldCkgPAorCQkgICAgKHNnX2Rbal0ubGVuZ3RoIC0gZHN0X29mZnNldCkpIHsKKwkJCWxlbmd0aCA9IChzZ19zW2ldLmxlbmd0aCAtIHNyY19vZmZzZXQpOworI2lmZGVmIERFQlVHX1JBTURJU0tfTUNQCisJCQlwcmludGsoS0VSTl9JTkZPICJTdGVwIDEgLSBzZ19zWyVkXTogJXAgbGVuZ3RoOiAlZCIKKwkJCQkiIG9mZnNldDogJWQgc2dfZFslZF0ubGVuZ3RoOiAldVxuIiwgaSwKKwkJCQkmc2dfc1tpXSwgc2dfc1tpXS5sZW5ndGgsIHNnX3NbaV0ub2Zmc2V0LAorCQkJCWosIHNnX2Rbal0ubGVuZ3RoKTsKKwkJCXByaW50ayhLRVJOX0lORk8gIlN0ZXAgMSAtIGxlbmd0aDogJXUgc3JjX29mZnNldDogJXUiCisJCQkJIiBkc3Rfb2Zmc2V0OiAldVxuIiwgbGVuZ3RoLCBzcmNfb2Zmc2V0LAorCQkJCWRzdF9vZmZzZXQpOworI2VuZGlmCisJCQlpZiAobGVuZ3RoID4gcmVxLT5yZF9zaXplKQorCQkJCWxlbmd0aCA9IHJlcS0+cmRfc2l6ZTsKKworCQkJc3JjID0gc2dfdmlydCgmc2dfc1tpKytdKSArIHNyY19vZmZzZXQ7CisJCQlpZiAoIXNyYykKKwkJCQlCVUcoKTsKKworCQkJZHN0ID0gc2dfdmlydCgmc2dfZFtqXSkgKyBkc3Rfb2Zmc2V0OworCQkJaWYgKCFkc3QpCisJCQkJQlVHKCk7CisKKwkJCXNyY19vZmZzZXQgPSAwOworCQkJZHN0X29mZnNldCA9IGxlbmd0aDsKKwkJCXBhZ2VfZW5kID0gMDsKKwkJfSBlbHNlIHsKKwkJCWxlbmd0aCA9IChzZ19kW2pdLmxlbmd0aCAtIGRzdF9vZmZzZXQpOworI2lmZGVmIERFQlVHX1JBTURJU0tfTUNQCisJCQlwcmludGsoS0VSTl9JTkZPICJTdGVwIDIgLSBzZ19zWyVkXTogJXAgbGVuZ3RoOiAlZCIKKwkJCQkiIG9mZnNldDogJWQgc2dfZFslZF0ubGVuZ3RoOiAldVxuIiwgaSwKKwkJCQkmc2dfc1tpXSwgc2dfc1tpXS5sZW5ndGgsIHNnX3NbaV0ub2Zmc2V0LAorCQkJCWosIHNnX2Rbal0ubGVuZ3RoKTsKKwkJCXByaW50ayhLRVJOX0lORk8gIlN0ZXAgMiAtIGxlbmd0aDogJXUgc3JjX29mZnNldDogJXUiCisJCQkJIiBkc3Rfb2Zmc2V0OiAldVxuIiwgbGVuZ3RoLCBzcmNfb2Zmc2V0LAorCQkJCWRzdF9vZmZzZXQpOworI2VuZGlmCisJCQlpZiAobGVuZ3RoID4gcmVxLT5yZF9zaXplKQorCQkJCWxlbmd0aCA9IHJlcS0+cmRfc2l6ZTsKKworCQkJc3JjID0gc2dfdmlydCgmc2dfc1tpXSkgKyBzcmNfb2Zmc2V0OworCQkJaWYgKCFzcmMpCisJCQkJQlVHKCk7CisKKwkJCWlmIChzZ19zW2ldLmxlbmd0aCA9PSBsZW5ndGgpIHsKKwkJCQlpKys7CisJCQkJc3JjX29mZnNldCA9IDA7CisJCQl9IGVsc2UKKwkJCQlzcmNfb2Zmc2V0ID0gbGVuZ3RoOworCisJCQlkc3QgPSBzZ192aXJ0KCZzZ19kW2orK10pICsgZHN0X29mZnNldDsKKwkJCWlmICghZHN0KQorCQkJCUJVRygpOworCisJCQlkc3Rfb2Zmc2V0ID0gMDsKKwkJCXBhZ2VfZW5kID0gMTsKKwkJfQorCisJCW1lbWNweShkc3QsIHNyYywgbGVuZ3RoKTsKKworI2lmZGVmIERFQlVHX1JBTURJU0tfTUNQCisJCXByaW50ayhLRVJOX0lORk8gInBhZ2U6ICV1LCByZW1haW5pbmcgc2l6ZTogJXUsIGxlbmd0aDogJXUsIgorCQkJIiBpOiAldSwgajogJXVcbiIsIHJlcS0+cmRfcGFnZSwKKwkJCShyZXEtPnJkX3NpemUgLSBsZW5ndGgpLCBsZW5ndGgsIGksIGopOworI2VuZGlmCisJCXJlcS0+cmRfc2l6ZSAtPSBsZW5ndGg7CisJCWlmICghKHJlcS0+cmRfc2l6ZSkpCisJCQlyZXR1cm4gMDsKKworCQlpZiAoIXBhZ2VfZW5kKQorCQkJY29udGludWU7CisKKwkJaWYgKCsrcmVxLT5yZF9wYWdlIDw9IHRhYmxlLT5wYWdlX2VuZF9vZmZzZXQpIHsKKyNpZmRlZiBERUJVR19SQU1ESVNLX01DUAorCQkJcHJpbnRrKEtFUk5fSU5GTyAicGFnZTogJXUgaW4gc2FtZSBwYWdlIHRhYmxlXG4iLAorCQkJCXJlcS0+cmRfcGFnZSk7CisjZW5kaWYKKwkJCWNvbnRpbnVlOworCQl9CisjaWZkZWYgREVCVUdfUkFNRElTS19NQ1AKKwkJcHJpbnRrKEtFUk5fSU5GTyAiZ2V0dGluZyBuZXcgcGFnZSB0YWJsZSBmb3IgcGFnZTogJXVcbiIsCisJCQkJcmVxLT5yZF9wYWdlKTsKKyNlbmRpZgorCQl0YWJsZSA9IHJkX2dldF9zZ190YWJsZShkZXYsIHJlcS0+cmRfcGFnZSk7CisJCWlmICghKHRhYmxlKSkKKwkJCXJldHVybiAtMTsKKworCQlzZ19kID0gJnRhYmxlLT5zZ190YWJsZVtqID0gMF07CisJfQorCisJcmV0dXJuIDA7Cit9CisKKy8qCXJkX01FTUNQWV9kb190YXNrKCk6IChQYXJ0IG9mIHNlX3N1YnN5c3RlbV9hcGlfdCB0ZW1wbGF0ZSkKKyAqCisgKgorICovCitzdGF0aWMgaW50IHJkX01FTUNQWV9kb190YXNrKHN0cnVjdCBzZV90YXNrICp0YXNrKQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IHRhc2stPnNlX2RldjsKKwlzdHJ1Y3QgcmRfcmVxdWVzdCAqcmVxID0gUkRfUkVRKHRhc2spOworCXVuc2lnbmVkIGxvbmcgbG9uZyBsYmE7CisJaW50IHJldDsKKworCXJlcS0+cmRfcGFnZSA9ICh0YXNrLT50YXNrX2xiYSAqIERFVl9BVFRSSUIoZGV2KS0+YmxvY2tfc2l6ZSkgLyBQQUdFX1NJWkU7CisJbGJhID0gdGFzay0+dGFza19sYmE7CisJcmVxLT5yZF9vZmZzZXQgPSAoZG9fZGl2KGxiYSwKKwkJCSAgKFBBR0VfU0laRSAvIERFVl9BVFRSSUIoZGV2KS0+YmxvY2tfc2l6ZSkpKSAqCisJCQkgICBERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemU7CisJcmVxLT5yZF9zaXplID0gdGFzay0+dGFza19zaXplOworCisJaWYgKHRhc2stPnRhc2tfZGF0YV9kaXJlY3Rpb24gPT0gRE1BX0ZST01fREVWSUNFKQorCQlyZXQgPSByZF9NRU1DUFlfcmVhZChyZXEpOworCWVsc2UKKwkJcmV0ID0gcmRfTUVNQ1BZX3dyaXRlKHJlcSk7CisKKwlpZiAocmV0ICE9IDApCisJCXJldHVybiByZXQ7CisKKwl0YXNrLT50YXNrX3Njc2lfc3RhdHVzID0gR09PRDsKKwl0cmFuc3BvcnRfY29tcGxldGVfdGFzayh0YXNrLCAxKTsKKworCXJldHVybiBQWVhfVFJBTlNQT1JUX1NFTlRfVE9fVFJBTlNQT1JUOworfQorCisvKglyZF9ESVJFQ1Rfd2l0aF9vZmZzZXQoKToKKyAqCisgKgorICovCitzdGF0aWMgaW50IHJkX0RJUkVDVF93aXRoX29mZnNldCgKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzaywKKwlzdHJ1Y3QgbGlzdF9oZWFkICpzZV9tZW1fbGlzdCwKKwl1MzIgKnNlX21lbV9jbnQsCisJdTMyICp0YXNrX29mZnNldCkKK3sKKwlzdHJ1Y3QgcmRfcmVxdWVzdCAqcmVxID0gUkRfUkVRKHRhc2spOworCXN0cnVjdCByZF9kZXYgKmRldiA9IHJlcS0+cmRfZGV2OworCXN0cnVjdCByZF9kZXZfc2dfdGFibGUgKnRhYmxlOworCXN0cnVjdCBzZV9tZW0gKnNlX21lbTsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnX3M7CisJdTMyIGogPSAwLCBzZXRfb2Zmc2V0ID0gMTsKKwl1MzIgZ2V0X25leHRfdGFibGUgPSAwLCBvZmZzZXRfbGVuZ3RoLCB0YWJsZV9zZ19lbmQ7CisKKwl0YWJsZSA9IHJkX2dldF9zZ190YWJsZShkZXYsIHJlcS0+cmRfcGFnZSk7CisJaWYgKCEodGFibGUpKQorCQlyZXR1cm4gLTE7CisKKwl0YWJsZV9zZ19lbmQgPSAodGFibGUtPnBhZ2VfZW5kX29mZnNldCAtIHJlcS0+cmRfcGFnZSk7CisJc2dfcyA9ICZ0YWJsZS0+c2dfdGFibGVbcmVxLT5yZF9wYWdlIC0gdGFibGUtPnBhZ2Vfc3RhcnRfb2Zmc2V0XTsKKyNpZmRlZiBERUJVR19SQU1ESVNLX0RSCisJcHJpbnRrKEtFUk5fSU5GTyAiJXMgRElSRUNUIExCQTogJWxsdSwgU2l6ZTogJXUgUGFnZTogJXUsIE9mZnNldDogJXVcbiIsCisJCSh0YXNrLT50YXNrX2RhdGFfZGlyZWN0aW9uID09IERNQV9UT19ERVZJQ0UpID8KKwkJCSJXcml0ZSIgOiAiUmVhZCIsCisJCXRhc2stPnRhc2tfbGJhLCByZXEtPnJkX3NpemUsIHJlcS0+cmRfcGFnZSwgcmVxLT5yZF9vZmZzZXQpOworI2VuZGlmCisJd2hpbGUgKHJlcS0+cmRfc2l6ZSkgeworCQlzZV9tZW0gPSBrbWVtX2NhY2hlX3phbGxvYyhzZV9tZW1fY2FjaGUsIEdGUF9LRVJORUwpOworCQlpZiAoIShzZV9tZW0pKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBzdHJ1Y3Qgc2VfbWVtXG4iKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCQlJTklUX0xJU1RfSEVBRCgmc2VfbWVtLT5zZV9saXN0KTsKKworCQlpZiAoc2V0X29mZnNldCkgeworCQkJb2Zmc2V0X2xlbmd0aCA9IHNnX3Nbal0ubGVuZ3RoIC0gcmVxLT5yZF9vZmZzZXQ7CisJCQlpZiAob2Zmc2V0X2xlbmd0aCA+IHJlcS0+cmRfc2l6ZSkKKwkJCQlvZmZzZXRfbGVuZ3RoID0gcmVxLT5yZF9zaXplOworCisJCQlzZV9tZW0tPnNlX3BhZ2UgPSBzZ19wYWdlKCZzZ19zW2orK10pOworCQkJc2VfbWVtLT5zZV9vZmYgPSByZXEtPnJkX29mZnNldDsKKwkJCXNlX21lbS0+c2VfbGVuID0gb2Zmc2V0X2xlbmd0aDsKKworCQkJc2V0X29mZnNldCA9IDA7CisJCQlnZXRfbmV4dF90YWJsZSA9IChqID4gdGFibGVfc2dfZW5kKTsKKwkJCWdvdG8gY2hlY2tfZW90OworCQl9CisKKwkJb2Zmc2V0X2xlbmd0aCA9IChyZXEtPnJkX3NpemUgPCByZXEtPnJkX29mZnNldCkgPworCQkJcmVxLT5yZF9zaXplIDogcmVxLT5yZF9vZmZzZXQ7CisKKwkJc2VfbWVtLT5zZV9wYWdlID0gc2dfcGFnZSgmc2dfc1tqXSk7CisJCXNlX21lbS0+c2VfbGVuID0gb2Zmc2V0X2xlbmd0aDsKKworCQlzZXRfb2Zmc2V0ID0gMTsKKworY2hlY2tfZW90OgorI2lmZGVmIERFQlVHX1JBTURJU0tfRFIKKwkJcHJpbnRrKEtFUk5fSU5GTyAicGFnZTogJXUsIHNpemU6ICV1LCBvZmZzZXRfbGVuZ3RoOiAldSwgajogJXUiCisJCQkiIHNlX21lbTogJXAsIHNlX3BhZ2U6ICVwIHNlX29mZjogJXUgc2VfbGVuOiAldVxuIiwKKwkJCXJlcS0+cmRfcGFnZSwgcmVxLT5yZF9zaXplLCBvZmZzZXRfbGVuZ3RoLCBqLCBzZV9tZW0sCisJCQlzZV9tZW0tPnNlX3BhZ2UsIHNlX21lbS0+c2Vfb2ZmLCBzZV9tZW0tPnNlX2xlbik7CisjZW5kaWYKKwkJbGlzdF9hZGRfdGFpbCgmc2VfbWVtLT5zZV9saXN0LCBzZV9tZW1fbGlzdCk7CisJCSgqc2VfbWVtX2NudCkrKzsKKworCQlyZXEtPnJkX3NpemUgLT0gb2Zmc2V0X2xlbmd0aDsKKwkJaWYgKCEocmVxLT5yZF9zaXplKSkKKwkJCWdvdG8gb3V0OworCisJCWlmICghc2V0X29mZnNldCAmJiAhZ2V0X25leHRfdGFibGUpCisJCQljb250aW51ZTsKKworCQlpZiAoKytyZXEtPnJkX3BhZ2UgPD0gdGFibGUtPnBhZ2VfZW5kX29mZnNldCkgeworI2lmZGVmIERFQlVHX1JBTURJU0tfRFIKKwkJCXByaW50ayhLRVJOX0lORk8gInBhZ2U6ICV1IGluIHNhbWUgcGFnZSB0YWJsZVxuIiwKKwkJCQkJcmVxLT5yZF9wYWdlKTsKKyNlbmRpZgorCQkJY29udGludWU7CisJCX0KKyNpZmRlZiBERUJVR19SQU1ESVNLX0RSCisJCXByaW50ayhLRVJOX0lORk8gImdldHRpbmcgbmV3IHBhZ2UgdGFibGUgZm9yIHBhZ2U6ICV1XG4iLAorCQkJCXJlcS0+cmRfcGFnZSk7CisjZW5kaWYKKwkJdGFibGUgPSByZF9nZXRfc2dfdGFibGUoZGV2LCByZXEtPnJkX3BhZ2UpOworCQlpZiAoISh0YWJsZSkpCisJCQlyZXR1cm4gLTE7CisKKwkJc2dfcyA9ICZ0YWJsZS0+c2dfdGFibGVbaiA9IDBdOworCX0KKworb3V0OgorCVRfVEFTSyh0YXNrLT50YXNrX3NlX2NtZCktPnRfdGFza3Nfc2VfbnVtICs9ICpzZV9tZW1fY250OworI2lmZGVmIERFQlVHX1JBTURJU0tfRFIKKwlwcmludGsoS0VSTl9JTkZPICJSRF9EUiAtIEFsbG9jYXRlZCAldSBzdHJ1Y3Qgc2VfbWVtIHNlZ21lbnRzIGZvciB0YXNrXG4iLAorCQkJKnNlX21lbV9jbnQpOworI2VuZGlmCisJcmV0dXJuIDA7Cit9CisKKy8qCXJkX0RJUkVDVF93aXRob3V0X29mZnNldCgpOgorICoKKyAqCisgKi8KK3N0YXRpYyBpbnQgcmRfRElSRUNUX3dpdGhvdXRfb2Zmc2V0KAorCXN0cnVjdCBzZV90YXNrICp0YXNrLAorCXN0cnVjdCBsaXN0X2hlYWQgKnNlX21lbV9saXN0LAorCXUzMiAqc2VfbWVtX2NudCwKKwl1MzIgKnRhc2tfb2Zmc2V0KQoreworCXN0cnVjdCByZF9yZXF1ZXN0ICpyZXEgPSBSRF9SRVEodGFzayk7CisJc3RydWN0IHJkX2RldiAqZGV2ID0gcmVxLT5yZF9kZXY7CisJc3RydWN0IHJkX2Rldl9zZ190YWJsZSAqdGFibGU7CisJc3RydWN0IHNlX21lbSAqc2VfbWVtOworCXN0cnVjdCBzY2F0dGVybGlzdCAqc2dfczsKKwl1MzIgbGVuZ3RoLCBqID0gMDsKKworCXRhYmxlID0gcmRfZ2V0X3NnX3RhYmxlKGRldiwgcmVxLT5yZF9wYWdlKTsKKwlpZiAoISh0YWJsZSkpCisJCXJldHVybiAtMTsKKworCXNnX3MgPSAmdGFibGUtPnNnX3RhYmxlW3JlcS0+cmRfcGFnZSAtIHRhYmxlLT5wYWdlX3N0YXJ0X29mZnNldF07CisjaWZkZWYgREVCVUdfUkFNRElTS19EUgorCXByaW50ayhLRVJOX0lORk8gIiVzIERJUkVDVCBMQkE6ICVsbHUsIFNpemU6ICV1LCBQYWdlOiAldVxuIiwKKwkJKHRhc2stPnRhc2tfZGF0YV9kaXJlY3Rpb24gPT0gRE1BX1RPX0RFVklDRSkgPworCQkJIldyaXRlIiA6ICJSZWFkIiwKKwkJdGFzay0+dGFza19sYmEsIHJlcS0+cmRfc2l6ZSwgcmVxLT5yZF9wYWdlKTsKKyNlbmRpZgorCXdoaWxlIChyZXEtPnJkX3NpemUpIHsKKwkJc2VfbWVtID0ga21lbV9jYWNoZV96YWxsb2Moc2VfbWVtX2NhY2hlLCBHRlBfS0VSTkVMKTsKKwkJaWYgKCEoc2VfbWVtKSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgc3RydWN0IHNlX21lbVxuIik7CisJCQlyZXR1cm4gLTE7CisJCX0KKwkJSU5JVF9MSVNUX0hFQUQoJnNlX21lbS0+c2VfbGlzdCk7CisKKwkJbGVuZ3RoID0gKHJlcS0+cmRfc2l6ZSA8IHNnX3Nbal0ubGVuZ3RoKSA/CisJCQlyZXEtPnJkX3NpemUgOiBzZ19zW2pdLmxlbmd0aDsKKworCQlzZV9tZW0tPnNlX3BhZ2UgPSBzZ19wYWdlKCZzZ19zW2orK10pOworCQlzZV9tZW0tPnNlX2xlbiA9IGxlbmd0aDsKKworI2lmZGVmIERFQlVHX1JBTURJU0tfRFIKKwkJcHJpbnRrKEtFUk5fSU5GTyAicGFnZTogJXUsIHNpemU6ICV1LCBqOiAldSBzZV9tZW06ICVwLCIKKwkJCSIgc2VfcGFnZTogJXAgc2Vfb2ZmOiAldSBzZV9sZW46ICV1XG4iLCByZXEtPnJkX3BhZ2UsCisJCQlyZXEtPnJkX3NpemUsIGosIHNlX21lbSwgc2VfbWVtLT5zZV9wYWdlLAorCQkJc2VfbWVtLT5zZV9vZmYsIHNlX21lbS0+c2VfbGVuKTsKKyNlbmRpZgorCQlsaXN0X2FkZF90YWlsKCZzZV9tZW0tPnNlX2xpc3QsIHNlX21lbV9saXN0KTsKKwkJKCpzZV9tZW1fY250KSsrOworCisJCXJlcS0+cmRfc2l6ZSAtPSBsZW5ndGg7CisJCWlmICghKHJlcS0+cmRfc2l6ZSkpCisJCQlnb3RvIG91dDsKKworCQlpZiAoKytyZXEtPnJkX3BhZ2UgPD0gdGFibGUtPnBhZ2VfZW5kX29mZnNldCkgeworI2lmZGVmIERFQlVHX1JBTURJU0tfRFIKKwkJCXByaW50aygicGFnZTogJXUgaW4gc2FtZSBwYWdlIHRhYmxlXG4iLAorCQkJCXJlcS0+cmRfcGFnZSk7CisjZW5kaWYKKwkJCWNvbnRpbnVlOworCQl9CisjaWZkZWYgREVCVUdfUkFNRElTS19EUgorCQlwcmludGsoS0VSTl9JTkZPICJnZXR0aW5nIG5ldyBwYWdlIHRhYmxlIGZvciBwYWdlOiAldVxuIiwKKwkJCQlyZXEtPnJkX3BhZ2UpOworI2VuZGlmCisJCXRhYmxlID0gcmRfZ2V0X3NnX3RhYmxlKGRldiwgcmVxLT5yZF9wYWdlKTsKKwkJaWYgKCEodGFibGUpKQorCQkJcmV0dXJuIC0xOworCisJCXNnX3MgPSAmdGFibGUtPnNnX3RhYmxlW2ogPSAwXTsKKwl9CisKK291dDoKKwlUX1RBU0sodGFzay0+dGFza19zZV9jbWQpLT50X3Rhc2tzX3NlX251bSArPSAqc2VfbWVtX2NudDsKKyNpZmRlZiBERUJVR19SQU1ESVNLX0RSCisJcHJpbnRrKEtFUk5fSU5GTyAiUkRfRFIgLSBBbGxvY2F0ZWQgJXUgc3RydWN0IHNlX21lbSBzZWdtZW50cyBmb3IgdGFza1xuIiwKKwkJCSpzZV9tZW1fY250KTsKKyNlbmRpZgorCXJldHVybiAwOworfQorCisvKglyZF9ESVJFQ1RfZG9fc2VfbWVtX21hcCgpOgorICoKKyAqCisgKi8KK3N0YXRpYyBpbnQgcmRfRElSRUNUX2RvX3NlX21lbV9tYXAoCisJc3RydWN0IHNlX3Rhc2sgKnRhc2ssCisJc3RydWN0IGxpc3RfaGVhZCAqc2VfbWVtX2xpc3QsCisJdm9pZCAqaW5fbWVtLAorCXN0cnVjdCBzZV9tZW0gKmluX3NlX21lbSwKKwlzdHJ1Y3Qgc2VfbWVtICoqb3V0X3NlX21lbSwKKwl1MzIgKnNlX21lbV9jbnQsCisJdTMyICp0YXNrX29mZnNldF9pbikKK3sKKwlzdHJ1Y3Qgc2VfY21kICpjbWQgPSB0YXNrLT50YXNrX3NlX2NtZDsKKwlzdHJ1Y3QgcmRfcmVxdWVzdCAqcmVxID0gUkRfUkVRKHRhc2spOworCXUzMiB0YXNrX29mZnNldCA9ICp0YXNrX29mZnNldF9pbjsKKwl1bnNpZ25lZCBsb25nIGxvbmcgbGJhOworCWludCByZXQ7CisKKwlyZXEtPnJkX3BhZ2UgPSAoKHRhc2stPnRhc2tfbGJhICogREVWX0FUVFJJQih0YXNrLT5zZV9kZXYpLT5ibG9ja19zaXplKSAvCisJCQlQQUdFX1NJWkUpOworCWxiYSA9IHRhc2stPnRhc2tfbGJhOworCXJlcS0+cmRfb2Zmc2V0ID0gKGRvX2RpdihsYmEsCisJCQkgIChQQUdFX1NJWkUgLyBERVZfQVRUUklCKHRhc2stPnNlX2RldiktPmJsb2NrX3NpemUpKSkgKgorCQkJICAgREVWX0FUVFJJQih0YXNrLT5zZV9kZXYpLT5ibG9ja19zaXplOworCXJlcS0+cmRfc2l6ZSA9IHRhc2stPnRhc2tfc2l6ZTsKKworCWlmIChyZXEtPnJkX29mZnNldCkKKwkJcmV0ID0gcmRfRElSRUNUX3dpdGhfb2Zmc2V0KHRhc2ssIHNlX21lbV9saXN0LCBzZV9tZW1fY250LAorCQkJCXRhc2tfb2Zmc2V0X2luKTsKKwllbHNlCisJCXJldCA9IHJkX0RJUkVDVF93aXRob3V0X29mZnNldCh0YXNrLCBzZV9tZW1fbGlzdCwgc2VfbWVtX2NudCwKKwkJCQl0YXNrX29mZnNldF9pbik7CisKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCWlmIChDTURfVEZPKGNtZCktPnRhc2tfc2dfY2hhaW5pbmcgPT0gMCkKKwkJcmV0dXJuIDA7CisJLyoKKwkgKiBDdXJyZW50bHkgcHJldmVudCB3cml0ZXJzIGZyb20gbXVsdGlwbGUgSFcgZmFicmljcyBkb2luZworCSAqIHBjaV9tYXBfc2coKSB0byBSRF9EUidzIGludGVybmFsIHNjYXR0ZXJsaXN0IG1lbW9yeS4KKwkgKi8KKwlpZiAoY21kLT5kYXRhX2RpcmVjdGlvbiA9PSBETUFfVE9fREVWSUNFKSB7CisJCXByaW50ayhLRVJOX0VSUiAiRE1BX1RPX0RFVklDRSBub3Qgc3VwcG9ydGVkIGZvciIKKwkJCQkiIFJBTURJU0tfRFIgd2l0aCB0YXNrX3NnX2NoYWluaW5nPTFcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCS8qCisJICogU3BlY2lhbCBjYXNlIGZvciBpZiB0YXNrX3NnX2NoYWluaW5nIGlzIGVuYWJsZWQsIHRoZW4KKwkgKiB3ZSBzZXR1cCBzdHJ1Y3Qgc2VfdGFzay0+dGFza19zZ1tdLCBhcyBpdCB3aWxsIGJlIHVzZWQgYnkKKwkgKiB0cmFuc3BvcnRfZG9fdGFza19zZ19jaGFpbigpIGZvciBjcmVhdGluZyBjaGFpbmdlZCBTR0xzCisJICogYWNyb3NzIG11bHRpcGxlIHN0cnVjdCBzZV90YXNrLT50YXNrX3NnW10uCisJICovCisJaWYgKCEodHJhbnNwb3J0X2NhbGNfc2dfbnVtKHRhc2ssCisJCQlsaXN0X2VudHJ5KFRfVEFTSyhjbWQpLT50X21lbV9saXN0LT5uZXh0LAorCQkJCSAgIHN0cnVjdCBzZV9tZW0sIHNlX2xpc3QpLAorCQkJdGFza19vZmZzZXQpKSkKKwkJcmV0dXJuIC0xOworCisJcmV0dXJuIHRyYW5zcG9ydF9tYXBfbWVtX3RvX3NnKHRhc2ssIHNlX21lbV9saXN0LCB0YXNrLT50YXNrX3NnLAorCQkJbGlzdF9lbnRyeShUX1RBU0soY21kKS0+dF9tZW1fbGlzdC0+bmV4dCwKKwkJCQkgICBzdHJ1Y3Qgc2VfbWVtLCBzZV9saXN0KSwKKwkJCW91dF9zZV9tZW0sIHNlX21lbV9jbnQsIHRhc2tfb2Zmc2V0X2luKTsKK30KKworLyoJcmRfRElSRUNUX2RvX3Rhc2soKTogKFBhcnQgb2Ygc2Vfc3Vic3lzdGVtX2FwaV90IHRlbXBsYXRlKQorICoKKyAqCisgKi8KK3N0YXRpYyBpbnQgcmRfRElSRUNUX2RvX3Rhc2soc3RydWN0IHNlX3Rhc2sgKnRhc2spCit7CisJLyoKKwkgKiBBdCB0aGlzIHBvaW50IHRoZSBsb2NhbGx5IGFsbG9jYXRlZCBSRCB0YWJsZXMgaGF2ZSBiZWVuIG1hcHBlZAorCSAqIHRvIHN0cnVjdCBzZV9tZW0gZWxlbWVudHMgaW4gcmRfRElSRUNUX2RvX3NlX21lbV9tYXAoKS4KKwkgKi8KKwl0YXNrLT50YXNrX3Njc2lfc3RhdHVzID0gR09PRDsKKwl0cmFuc3BvcnRfY29tcGxldGVfdGFzayh0YXNrLCAxKTsKKworCXJldHVybiBQWVhfVFJBTlNQT1JUX1NFTlRfVE9fVFJBTlNQT1JUOworfQorCisvKglyZF9mcmVlX3Rhc2soKTogKFBhcnQgb2Ygc2Vfc3Vic3lzdGVtX2FwaV90IHRlbXBsYXRlKQorICoKKyAqCisgKi8KK3N0YXRpYyB2b2lkIHJkX2ZyZWVfdGFzayhzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlrZnJlZShSRF9SRVEodGFzaykpOworfQorCitlbnVtIHsKKwlPcHRfcmRfcGFnZXMsIE9wdF9lcnIKK307CisKK3N0YXRpYyBtYXRjaF90YWJsZV90IHRva2VucyA9IHsKKwl7T3B0X3JkX3BhZ2VzLCAicmRfcGFnZXM9JWQifSwKKwl7T3B0X2VyciwgTlVMTH0KK307CisKK3N0YXRpYyBzc2l6ZV90IHJkX3NldF9jb25maWdmc19kZXZfcGFyYW1zKAorCXN0cnVjdCBzZV9oYmEgKmhiYSwKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqc2VfZGV2LAorCWNvbnN0IGNoYXIgKnBhZ2UsCisJc3NpemVfdCBjb3VudCkKK3sKKwlzdHJ1Y3QgcmRfZGV2ICpyZF9kZXYgPSBzZV9kZXYtPnNlX2Rldl9zdV9wdHI7CisJY2hhciAqb3JpZywgKnB0ciwgKm9wdHM7CisJc3Vic3RyaW5nX3QgYXJnc1tNQVhfT1BUX0FSR1NdOworCWludCByZXQgPSAwLCBhcmcsIHRva2VuOworCisJb3B0cyA9IGtzdHJkdXAocGFnZSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFvcHRzKQorCQlyZXR1cm4gLUVOT01FTTsKKworCW9yaWcgPSBvcHRzOworCisJd2hpbGUgKChwdHIgPSBzdHJzZXAoJm9wdHMsICIsIikpICE9IE5VTEwpIHsKKwkJaWYgKCEqcHRyKQorCQkJY29udGludWU7CisKKwkJdG9rZW4gPSBtYXRjaF90b2tlbihwdHIsIHRva2VucywgYXJncyk7CisJCXN3aXRjaCAodG9rZW4pIHsKKwkJY2FzZSBPcHRfcmRfcGFnZXM6CisJCQltYXRjaF9pbnQoYXJncywgJmFyZyk7CisJCQlyZF9kZXYtPnJkX3BhZ2VfY291bnQgPSBhcmc7CisJCQlwcmludGsoS0VSTl9JTkZPICJSQU1ESVNLOiBSZWZlcmVuY2luZyBQYWdlIgorCQkJCSIgQ291bnQ6ICV1XG4iLCByZF9kZXYtPnJkX3BhZ2VfY291bnQpOworCQkJcmRfZGV2LT5yZF9mbGFncyB8PSBSREZfSEFTX1BBR0VfQ09VTlQ7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCWJyZWFrOworCQl9CisJfQorCisJa2ZyZWUob3JpZyk7CisJcmV0dXJuICghcmV0KSA/IGNvdW50IDogcmV0OworfQorCitzdGF0aWMgc3NpemVfdCByZF9jaGVja19jb25maWdmc19kZXZfcGFyYW1zKHN0cnVjdCBzZV9oYmEgKmhiYSwgc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldikKK3sKKwlzdHJ1Y3QgcmRfZGV2ICpyZF9kZXYgPSBzZV9kZXYtPnNlX2Rldl9zdV9wdHI7CisKKwlpZiAoIShyZF9kZXYtPnJkX2ZsYWdzICYgUkRGX0hBU19QQUdFX0NPVU5UKSkgeworCQlwcmludGsoS0VSTl9JTkZPICJNaXNzaW5nIHJkX3BhZ2VzPSBwYXJhbWV0ZXJcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzc2l6ZV90IHJkX3Nob3dfY29uZmlnZnNfZGV2X3BhcmFtcygKKwlzdHJ1Y3Qgc2VfaGJhICpoYmEsCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiwKKwljaGFyICpiKQoreworCXN0cnVjdCByZF9kZXYgKnJkX2RldiA9IHNlX2Rldi0+c2VfZGV2X3N1X3B0cjsKKwlzc2l6ZV90IGJsID0gc3ByaW50ZihiLCAiVENNIFJhbURpc2sgSUQ6ICV1ICBSYW1EaXNrIE1ha2V1cDogJXNcbiIsCisJCQlyZF9kZXYtPnJkX2Rldl9pZCwgKHJkX2Rldi0+cmRfZGlyZWN0KSA/CisJCQkicmRfZGlyZWN0IiA6ICJyZF9tY3AiKTsKKwlibCArPSBzcHJpbnRmKGIgKyBibCwgIiAgICAgICAgUEFHRVMvUEFHRV9TSVpFOiAldSolbHUiCisJCQkiICBTR190YWJsZV9jb3VudDogJXVcbiIsIHJkX2Rldi0+cmRfcGFnZV9jb3VudCwKKwkJCVBBR0VfU0laRSwgcmRfZGV2LT5zZ190YWJsZV9jb3VudCk7CisJcmV0dXJuIGJsOworfQorCisvKglyZF9nZXRfY2RiKCk6IChQYXJ0IG9mIHNlX3N1YnN5c3RlbV9hcGlfdCB0ZW1wbGF0ZSkKKyAqCisgKgorICovCitzdGF0aWMgdW5zaWduZWQgY2hhciAqcmRfZ2V0X2NkYihzdHJ1Y3Qgc2VfdGFzayAqdGFzaykKK3sKKwlzdHJ1Y3QgcmRfcmVxdWVzdCAqcmVxID0gUkRfUkVRKHRhc2spOworCisJcmV0dXJuIHJlcS0+cmRfc2NzaV9jZGI7Cit9CisKK3N0YXRpYyB1MzIgcmRfZ2V0X2RldmljZV9yZXYoc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXJldHVybiBTQ1NJX1NQQ18yOyAvKiBSZXR1cm5zIFNQQy0zIGluIEluaXRpYXRvciBEYXRhICovCit9CisKK3N0YXRpYyB1MzIgcmRfZ2V0X2RldmljZV90eXBlKHN0cnVjdCBzZV9kZXZpY2UgKmRldikKK3sKKwlyZXR1cm4gVFlQRV9ESVNLOworfQorCitzdGF0aWMgc2VjdG9yX3QgcmRfZ2V0X2Jsb2NrcyhzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHJkX2RldiAqcmRfZGV2ID0gZGV2LT5kZXZfcHRyOworCXVuc2lnbmVkIGxvbmcgbG9uZyBibG9ja3NfbG9uZyA9ICgocmRfZGV2LT5yZF9wYWdlX2NvdW50ICogUEFHRV9TSVpFKSAvCisJCQlERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUpIC0gMTsKKworCXJldHVybiBibG9ja3NfbG9uZzsKK30KKworc3RhdGljIHN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpIHJkX2RyX3RlbXBsYXRlID0geworCS5uYW1lCQkJPSAicmRfZHIiLAorCS50cmFuc3BvcnRfdHlwZQkJPSBUUkFOU1BPUlRfUExVR0lOX1ZIQkFfVkRFViwKKwkuYXR0YWNoX2hiYQkJPSByZF9hdHRhY2hfaGJhLAorCS5kZXRhY2hfaGJhCQk9IHJkX2RldGFjaF9oYmEsCisJLmFsbG9jYXRlX3ZpcnRkZXZpY2UJPSByZF9ESVJFQ1RfYWxsb2NhdGVfdmlydGRldmljZSwKKwkuY3JlYXRlX3ZpcnRkZXZpY2UJPSByZF9ESVJFQ1RfY3JlYXRlX3ZpcnRkZXZpY2UsCisJLmZyZWVfZGV2aWNlCQk9IHJkX2ZyZWVfZGV2aWNlLAorCS5hbGxvY190YXNrCQk9IHJkX2FsbG9jX3Rhc2ssCisJLmRvX3Rhc2sJCT0gcmRfRElSRUNUX2RvX3Rhc2ssCisJLmZyZWVfdGFzawkJPSByZF9mcmVlX3Rhc2ssCisJLmNoZWNrX2NvbmZpZ2ZzX2Rldl9wYXJhbXMgPSByZF9jaGVja19jb25maWdmc19kZXZfcGFyYW1zLAorCS5zZXRfY29uZmlnZnNfZGV2X3BhcmFtcyA9IHJkX3NldF9jb25maWdmc19kZXZfcGFyYW1zLAorCS5zaG93X2NvbmZpZ2ZzX2Rldl9wYXJhbXMgPSByZF9zaG93X2NvbmZpZ2ZzX2Rldl9wYXJhbXMsCisJLmdldF9jZGIJCT0gcmRfZ2V0X2NkYiwKKwkuZ2V0X2RldmljZV9yZXYJCT0gcmRfZ2V0X2RldmljZV9yZXYsCisJLmdldF9kZXZpY2VfdHlwZQk9IHJkX2dldF9kZXZpY2VfdHlwZSwKKwkuZ2V0X2Jsb2NrcwkJPSByZF9nZXRfYmxvY2tzLAorCS5kb19zZV9tZW1fbWFwCQk9IHJkX0RJUkVDVF9kb19zZV9tZW1fbWFwLAorfTsKKworc3RhdGljIHN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpIHJkX21jcF90ZW1wbGF0ZSA9IHsKKwkubmFtZQkJCT0gInJkX21jcCIsCisJLnRyYW5zcG9ydF90eXBlCQk9IFRSQU5TUE9SVF9QTFVHSU5fVkhCQV9WREVWLAorCS5hdHRhY2hfaGJhCQk9IHJkX2F0dGFjaF9oYmEsCisJLmRldGFjaF9oYmEJCT0gcmRfZGV0YWNoX2hiYSwKKwkuYWxsb2NhdGVfdmlydGRldmljZQk9IHJkX01FTUNQWV9hbGxvY2F0ZV92aXJ0ZGV2aWNlLAorCS5jcmVhdGVfdmlydGRldmljZQk9IHJkX01FTUNQWV9jcmVhdGVfdmlydGRldmljZSwKKwkuZnJlZV9kZXZpY2UJCT0gcmRfZnJlZV9kZXZpY2UsCisJLmFsbG9jX3Rhc2sJCT0gcmRfYWxsb2NfdGFzaywKKwkuZG9fdGFzawkJPSByZF9NRU1DUFlfZG9fdGFzaywKKwkuZnJlZV90YXNrCQk9IHJkX2ZyZWVfdGFzaywKKwkuY2hlY2tfY29uZmlnZnNfZGV2X3BhcmFtcyA9IHJkX2NoZWNrX2NvbmZpZ2ZzX2Rldl9wYXJhbXMsCisJLnNldF9jb25maWdmc19kZXZfcGFyYW1zID0gcmRfc2V0X2NvbmZpZ2ZzX2Rldl9wYXJhbXMsCisJLnNob3dfY29uZmlnZnNfZGV2X3BhcmFtcyA9IHJkX3Nob3dfY29uZmlnZnNfZGV2X3BhcmFtcywKKwkuZ2V0X2NkYgkJPSByZF9nZXRfY2RiLAorCS5nZXRfZGV2aWNlX3JldgkJPSByZF9nZXRfZGV2aWNlX3JldiwKKwkuZ2V0X2RldmljZV90eXBlCT0gcmRfZ2V0X2RldmljZV90eXBlLAorCS5nZXRfYmxvY2tzCQk9IHJkX2dldF9ibG9ja3MsCit9OworCitpbnQgX19pbml0IHJkX21vZHVsZV9pbml0KHZvaWQpCit7CisJaW50IHJldDsKKworCXJldCA9IHRyYW5zcG9ydF9zdWJzeXN0ZW1fcmVnaXN0ZXIoJnJkX2RyX3RlbXBsYXRlKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCXJldCA9IHRyYW5zcG9ydF9zdWJzeXN0ZW1fcmVnaXN0ZXIoJnJkX21jcF90ZW1wbGF0ZSk7CisJaWYgKHJldCA8IDApIHsKKwkJdHJhbnNwb3J0X3N1YnN5c3RlbV9yZWxlYXNlKCZyZF9kcl90ZW1wbGF0ZSk7CisJCXJldHVybiByZXQ7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3ZvaWQgcmRfbW9kdWxlX2V4aXQodm9pZCkKK3sKKwl0cmFuc3BvcnRfc3Vic3lzdGVtX3JlbGVhc2UoJnJkX2RyX3RlbXBsYXRlKTsKKwl0cmFuc3BvcnRfc3Vic3lzdGVtX3JlbGVhc2UoJnJkX21jcF90ZW1wbGF0ZSk7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9yZC5oIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfcmQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xM2JhZGZiCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfcmQuaApAQCAtMCwwICsxLDczIEBACisjaWZuZGVmIFRBUkdFVF9DT1JFX1JEX0gKKyNkZWZpbmUgVEFSR0VUX0NPUkVfUkRfSAorCisjZGVmaW5lIFJEX0hCQV9WRVJTSU9OCQkidjQuMCIKKyNkZWZpbmUgUkRfRFJfVkVSU0lPTgkJIjQuMCIKKyNkZWZpbmUgUkRfTUNQX1ZFUlNJT04JCSI0LjAiCisKKy8qIExhcmdlc3QgcGllY2Ugb2YgbWVtb3J5IGttYWxsb2MgY2FuIGFsbG9jYXRlICovCisjZGVmaW5lIFJEX01BWF9BTExPQ0FUSU9OX1NJWkUJNjU1MzYKKy8qIE1heGltdW0gcXVldWVkZXB0aCBmb3IgdGhlIFJhbWRpc2sgSEJBICovCisjZGVmaW5lIFJEX0hCQV9RVUVVRV9ERVBUSAkyNTYKKyNkZWZpbmUgUkRfREVWSUNFX1FVRVVFX0RFUFRICTMyCisjZGVmaW5lIFJEX01BWF9ERVZJQ0VfUVVFVUVfREVQVEggMTI4CisjZGVmaW5lIFJEX0JMT0NLU0laRQkJNTEyCisjZGVmaW5lIFJEX01BWF9TRUNUT1JTCQkxMDI0CisKK2V4dGVybiBzdHJ1Y3Qga21lbV9jYWNoZSAqc2VfbWVtX2NhY2hlOworCisvKiBVc2VkIGluIHRhcmdldF9jb3JlX2luaXRfY29uZmlnZnMoKSBmb3IgdmlydHVhbCBMVU4gMCBhY2Nlc3MgKi8KK2ludCBfX2luaXQgcmRfbW9kdWxlX2luaXQodm9pZCk7Cit2b2lkIHJkX21vZHVsZV9leGl0KHZvaWQpOworCisjZGVmaW5lIFJSRl9FTVVMQVRFX0NEQgkJMHgwMQorI2RlZmluZSBSUkZfR09UX0xCQQkJMHgwMgorCitzdHJ1Y3QgcmRfcmVxdWVzdCB7CisJc3RydWN0IHNlX3Rhc2sJcmRfdGFzazsKKworCS8qIFNDU0kgQ0RCIGZyb20gaVNDU0kgQ29tbWFuZCBQRFUgKi8KKwl1bnNpZ25lZCBjaGFyCXJkX3Njc2lfY2RiW1RDTV9NQVhfQ09NTUFORF9TSVpFXTsKKwkvKiBPZmZzZXQgZnJvbSBzdGFydCBvZiBwYWdlICovCisJdTMyCQlyZF9vZmZzZXQ7CisJLyogU3RhcnRpbmcgcGFnZSBpbiBSYW1kaXNrIGZvciByZXF1ZXN0ICovCisJdTMyCQlyZF9wYWdlOworCS8qIFRvdGFsIG51bWJlciBvZiBwYWdlcyBuZWVkZWQgZm9yIHJlcXVlc3QgKi8KKwl1MzIJCXJkX3BhZ2VfY291bnQ7CisJLyogU2NhdHRlcmxpc3QgY291bnQgKi8KKwl1MzIJCXJkX3NpemU7CisJLyogUmFtZGlzayBkZXZpY2UgKi8KKwlzdHJ1Y3QgcmRfZGV2CSpyZF9kZXY7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworc3RydWN0IHJkX2Rldl9zZ190YWJsZSB7CisJdTMyCQlwYWdlX3N0YXJ0X29mZnNldDsKKwl1MzIJCXBhZ2VfZW5kX29mZnNldDsKKwl1MzIJCXJkX3NnX2NvdW50OworCXN0cnVjdCBzY2F0dGVybGlzdCAqc2dfdGFibGU7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworI2RlZmluZSBSREZfSEFTX1BBR0VfQ09VTlQJMHgwMQorCitzdHJ1Y3QgcmRfZGV2IHsKKwlpbnQJCXJkX2RpcmVjdDsKKwl1MzIJCXJkX2ZsYWdzOworCS8qIFVuaXF1ZSBSYW1kaXNrIERldmljZSBJRCBpbiBSYW1kaXNrIEhCQSAqLworCXUzMgkJcmRfZGV2X2lkOworCS8qIFRvdGFsIHBhZ2UgY291bnQgZm9yIHJhbWRpc2sgZGV2aWNlICovCisJdTMyCQlyZF9wYWdlX2NvdW50OworCS8qIE51bWJlciBvZiBTRyB0YWJsZXMgaW4gc2dfdGFibGVfYXJyYXkgKi8KKwl1MzIJCXNnX3RhYmxlX2NvdW50OworCXUzMgkJcmRfcXVldWVfZGVwdGg7CisJLyogQXJyYXkgb2YgcmRfZGV2X3NnX3RhYmxlX3QgY29udGFpbmluZyBzY2F0dGVybGlzdHMgKi8KKwlzdHJ1Y3QgcmRfZGV2X3NnX3RhYmxlICpzZ190YWJsZV9hcnJheTsKKwkvKiBSYW1kaXNrIEhCQSBkZXZpY2UgaXMgY29ubmVjdGVkIHRvICovCisJc3RydWN0IHJkX2hvc3QgKnJkX2hvc3Q7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworc3RydWN0IHJkX2hvc3QgeworCXUzMgkJcmRfaG9zdF9kZXZfaWRfY291bnQ7CisJdTMyCQlyZF9ob3N0X2lkOwkJLyogVW5pcXVlIFJhbWRpc2sgSG9zdCBJRCAqLworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKKyNlbmRpZiAvKiBUQVJHRVRfQ09SRV9SRF9IICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9zY2RiLmMgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9zY2RiLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGM2ZmVkMAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX3NjZGIuYwpAQCAtMCwwICsxLDEwNSBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIEZpbGVuYW1lOiAgdGFyZ2V0X2NvcmVfc2NkYi5jCisgKgorICogVGhpcyBmaWxlIGNvbnRhaW5zIHRoZSBnZW5lcmljIHRhcmdldCBlbmdpbmUgU3BsaXQgQ0RCIHJlbGF0ZWQgZnVuY3Rpb25zLgorICoKKyAqIENvcHlyaWdodCAoYykgMjAwNC0yMDA1IFB5WCBUZWNobm9sb2dpZXMsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNiwgMjAwNyBTQkUsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAwNy0yMDEwIFJpc2luZyBUaWRlIFN5c3RlbXMKKyAqIENvcHlyaWdodCAoYykgMjAwOC0yMDEwIExpbnV4LWlTQ1NJLm9yZworICoKKyAqIE5pY2hvbGFzIEEuIEJlbGxpbmdlciA8bmFiQGtlcm5lbC5vcmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisjaW5jbHVkZSA8bGludXgvbmV0Lmg+CisjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpLmg+CisjaW5jbHVkZSA8YXNtL3VuYWxpZ25lZC5oPgorCisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2Jhc2UuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdHJhbnNwb3J0Lmg+CisKKyNpbmNsdWRlICJ0YXJnZXRfY29yZV9zY2RiLmgiCisKKy8qCXNwbGl0X2NkYl9YWF82KCk6CisgKgorICogICAgICAyMS1iaXQgTEJBIHcvIDgtYml0IFNFQ1RPUlMKKyAqLwordm9pZCBzcGxpdF9jZGJfWFhfNigKKwl1bnNpZ25lZCBsb25nIGxvbmcgbGJhLAorCXUzMiAqc2VjdG9ycywKKwl1bnNpZ25lZCBjaGFyICpjZGIpCit7CisJY2RiWzFdID0gKGxiYSA+PiAxNikgJiAweDFmOworCWNkYlsyXSA9IChsYmEgPj4gOCkgJiAweGZmOworCWNkYlszXSA9IGxiYSAmIDB4ZmY7CisJY2RiWzRdID0gKnNlY3RvcnMgJiAweGZmOworfQorCisvKglzcGxpdF9jZGJfWFhfMTAoKToKKyAqCisgKgkzMi1iaXQgTEJBIHcvIDE2LWJpdCBTRUNUT1JTCisgKi8KK3ZvaWQgc3BsaXRfY2RiX1hYXzEwKAorCXVuc2lnbmVkIGxvbmcgbG9uZyBsYmEsCisJdTMyICpzZWN0b3JzLAorCXVuc2lnbmVkIGNoYXIgKmNkYikKK3sKKwlwdXRfdW5hbGlnbmVkX2JlMzIobGJhLCAmY2RiWzJdKTsKKwlwdXRfdW5hbGlnbmVkX2JlMTYoKnNlY3RvcnMsICZjZGJbN10pOworfQorCisvKglzcGxpdF9jZGJfWFhfMTIoKToKKyAqCisgKgkzMi1iaXQgTEJBIHcvIDMyLWJpdCBTRUNUT1JTCisgKi8KK3ZvaWQgc3BsaXRfY2RiX1hYXzEyKAorCXVuc2lnbmVkIGxvbmcgbG9uZyBsYmEsCisJdTMyICpzZWN0b3JzLAorCXVuc2lnbmVkIGNoYXIgKmNkYikKK3sKKwlwdXRfdW5hbGlnbmVkX2JlMzIobGJhLCAmY2RiWzJdKTsKKwlwdXRfdW5hbGlnbmVkX2JlMzIoKnNlY3RvcnMsICZjZGJbNl0pOworfQorCisvKglzcGxpdF9jZGJfWFhfMTYoKToKKyAqCisgKgk2NC1iaXQgTEJBIHcvIDMyLWJpdCBTRUNUT1JTCisgKi8KK3ZvaWQgc3BsaXRfY2RiX1hYXzE2KAorCXVuc2lnbmVkIGxvbmcgbG9uZyBsYmEsCisJdTMyICpzZWN0b3JzLAorCXVuc2lnbmVkIGNoYXIgKmNkYikKK3sKKwlwdXRfdW5hbGlnbmVkX2JlNjQobGJhLCAmY2RiWzJdKTsKKwlwdXRfdW5hbGlnbmVkX2JlMzIoKnNlY3RvcnMsICZjZGJbMTBdKTsKK30KKworLyoKKyAqCXNwbGl0X2NkYl9YWF8zMigpOgorICoKKyAqIAk2NC1iaXQgTEJBIHcvIDMyLWJpdCBTRUNUT1JTIHN1Y2ggYXMgUkVBRF8zMiwgV1JJVEVfMzIgYW5kIGVtdWxhdGVkIFhEV1JJVEVSRUFEXzMyCisgKi8KK3ZvaWQgc3BsaXRfY2RiX1hYXzMyKAorCXVuc2lnbmVkIGxvbmcgbG9uZyBsYmEsCisJdTMyICpzZWN0b3JzLAorCXVuc2lnbmVkIGNoYXIgKmNkYikKK3sKKwlwdXRfdW5hbGlnbmVkX2JlNjQobGJhLCAmY2RiWzEyXSk7CisJcHV0X3VuYWxpZ25lZF9iZTMyKCpzZWN0b3JzLCAmY2RiWzI4XSk7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9zY2RiLmggYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9zY2RiLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOThjZDFjMAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX3NjZGIuaApAQCAtMCwwICsxLDEwIEBACisjaWZuZGVmIFRBUkdFVF9DT1JFX1NDREJfSAorI2RlZmluZSBUQVJHRVRfQ09SRV9TQ0RCX0gKKworZXh0ZXJuIHZvaWQgc3BsaXRfY2RiX1hYXzYodW5zaWduZWQgbG9uZyBsb25nLCB1MzIgKiwgdW5zaWduZWQgY2hhciAqKTsKK2V4dGVybiB2b2lkIHNwbGl0X2NkYl9YWF8xMCh1bnNpZ25lZCBsb25nIGxvbmcsIHUzMiAqLCB1bnNpZ25lZCBjaGFyICopOworZXh0ZXJuIHZvaWQgc3BsaXRfY2RiX1hYXzEyKHVuc2lnbmVkIGxvbmcgbG9uZywgdTMyICosIHVuc2lnbmVkIGNoYXIgKik7CitleHRlcm4gdm9pZCBzcGxpdF9jZGJfWFhfMTYodW5zaWduZWQgbG9uZyBsb25nLCB1MzIgKiwgdW5zaWduZWQgY2hhciAqKTsKK2V4dGVybiB2b2lkIHNwbGl0X2NkYl9YWF8zMih1bnNpZ25lZCBsb25nIGxvbmcsIHUzMiAqLCB1bnNpZ25lZCBjaGFyICopOworCisjZW5kaWYgLyogVEFSR0VUX0NPUkVfU0NEQl9IICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV90bXIuYyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX3Rtci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjE1OGNlY2IKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV90bXIuYwpAQCAtMCwwICsxLDQwNCBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIEZpbGVuYW1lOiAgdGFyZ2V0X2NvcmVfdG1yLmMKKyAqCisgKiBUaGlzIGZpbGUgY29udGFpbnMgU1BDLTMgdGFzayBtYW5hZ2VtZW50IGluZnJhc3RydWN0dXJlCisgKgorICogQ29weXJpZ2h0IChjKSAyMDA5LDIwMTAgUmlzaW5nIFRpZGUgU3lzdGVtcworICogQ29weXJpZ2h0IChjKSAyMDA5LDIwMTAgTGludXgtaVNDU0kub3JnCisgKgorICogTmljaG9sYXMgQS4gQmVsbGluZ2VyIDxuYWJAa2VybmVsLm9yZz4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCisgKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICoKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKyNpbmNsdWRlIDxsaW51eC92ZXJzaW9uLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CisjaW5jbHVkZSA8bGludXgvbGlzdC5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaS5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV9jbW5kLmg+CisKKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfYmFzZS5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdG1yLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX3RyYW5zcG9ydC5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfb3BzLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2NvbmZpZ2ZzLmg+CisKKyNpbmNsdWRlICJ0YXJnZXRfY29yZV9hbHVhLmgiCisjaW5jbHVkZSAidGFyZ2V0X2NvcmVfcHIuaCIKKworI2RlZmluZSBERUJVR19MVU5fUkVTRVQKKyNpZmRlZiBERUJVR19MVU5fUkVTRVQKKyNkZWZpbmUgREVCVUdfTFIoeC4uLikgcHJpbnRrKEtFUk5fSU5GTyB4KQorI2Vsc2UKKyNkZWZpbmUgREVCVUdfTFIoeC4uLikKKyNlbmRpZgorCitzdHJ1Y3Qgc2VfdG1yX3JlcSAqY29yZV90bXJfYWxsb2NfcmVxKAorCXN0cnVjdCBzZV9jbWQgKnNlX2NtZCwKKwl2b2lkICpmYWJyaWNfdG1yX3B0ciwKKwl1OCBmdW5jdGlvbikKK3sKKwlzdHJ1Y3Qgc2VfdG1yX3JlcSAqdG1yOworCisJdG1yID0ga21lbV9jYWNoZV96YWxsb2Moc2VfdG1yX3JlcV9jYWNoZSwgR0ZQX0tFUk5FTCk7CisJaWYgKCEodG1yKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBzdHJ1Y3Qgc2VfdG1yX3JlcVxuIik7CisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCX0KKwl0bXItPnRhc2tfY21kID0gc2VfY21kOworCXRtci0+ZmFicmljX3Rtcl9wdHIgPSBmYWJyaWNfdG1yX3B0cjsKKwl0bXItPmZ1bmN0aW9uID0gZnVuY3Rpb247CisJSU5JVF9MSVNUX0hFQUQoJnRtci0+dG1yX2xpc3QpOworCisJcmV0dXJuIHRtcjsKK30KK0VYUE9SVF9TWU1CT0woY29yZV90bXJfYWxsb2NfcmVxKTsKKwordm9pZCBjb3JlX3Rtcl9yZWxlYXNlX3JlcSgKKwlzdHJ1Y3Qgc2VfdG1yX3JlcSAqdG1yKQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IHRtci0+dG1yX2RldjsKKworCXNwaW5fbG9jaygmZGV2LT5zZV90bXJfbG9jayk7CisJbGlzdF9kZWwoJnRtci0+dG1yX2xpc3QpOworCWttZW1fY2FjaGVfZnJlZShzZV90bXJfcmVxX2NhY2hlLCB0bXIpOworCXNwaW5fdW5sb2NrKCZkZXYtPnNlX3Rtcl9sb2NrKTsKK30KKworc3RhdGljIHZvaWQgY29yZV90bXJfaGFuZGxlX3Rhc19hYm9ydCgKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKnRtcl9uYWNsLAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwlpbnQgdGFzLAorCWludCBmZV9jb3VudCkKK3sKKwlpZiAoIShmZV9jb3VudCkpIHsKKwkJdHJhbnNwb3J0X2NtZF9maW5pc2hfYWJvcnQoY21kLCAxKTsKKwkJcmV0dXJuOworCX0KKwkvKgorCSAqIFRBU0sgQUJPUlRFRCBzdGF0dXMgKFRBUykgYml0IHN1cHBvcnQKKwkqLworCWlmICgoKHRtcl9uYWNsICE9IE5VTEwpICYmCisJICAgICAodG1yX25hY2wgPT0gY21kLT5zZV9zZXNzLT5zZV9ub2RlX2FjbCkpIHx8IHRhcykKKwkJdHJhbnNwb3J0X3NlbmRfdGFza19hYm9ydChjbWQpOworCisJdHJhbnNwb3J0X2NtZF9maW5pc2hfYWJvcnQoY21kLCAwKTsKK30KKworaW50IGNvcmVfdG1yX2x1bl9yZXNldCgKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsCisJc3RydWN0IHNlX3Rtcl9yZXEgKnRtciwKKwlzdHJ1Y3QgbGlzdF9oZWFkICpwcmVlbXB0X2FuZF9hYm9ydF9saXN0LAorCXN0cnVjdCBzZV9jbWQgKnByb3V0X2NtZCkKK3sKKwlzdHJ1Y3Qgc2VfY21kICpjbWQ7CisJc3RydWN0IHNlX3F1ZXVlX3JlcSAqcXIsICpxcl90bXA7CisJc3RydWN0IHNlX25vZGVfYWNsICp0bXJfbmFjbCA9IE5VTEw7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdG1yX3RwZyA9IE5VTEw7CisJc3RydWN0IHNlX3F1ZXVlX29iaiAqcW9iaiA9IGRldi0+ZGV2X3F1ZXVlX29iajsKKwlzdHJ1Y3Qgc2VfdG1yX3JlcSAqdG1yX3AsICp0bXJfcHA7CisJc3RydWN0IHNlX3Rhc2sgKnRhc2ssICp0YXNrX3RtcDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCBmZV9jb3VudCwgc3RhdGUsIHRhczsKKwkvKgorCSAqIFRBU0tfQUJPUlRFRCBzdGF0dXMgYml0LCB0aGlzIGlzIGNvbmZpZ3VyYWJsZSB2aWEgQ29uZmlnRlMKKwkgKiBzdHJ1Y3Qgc2VfZGV2aWNlIGF0dHJpYnV0ZXMuICBzcGM0cjE3IHNlY3Rpb24gNy40LjYgQ29udHJvbCBtb2RlIHBhZ2UKKwkgKgorCSAqIEEgdGFzayBhYm9ydGVkIHN0YXR1cyAoVEFTKSBiaXQgc2V0IHRvIHplcm8gc3BlY2lmaWVzIHRoYXQgYWJvcnRlZAorCSAqIHRhc2tzIHNoYWxsIGJlIHRlcm1pbmF0ZWQgYnkgdGhlIGRldmljZSBzZXJ2ZXIgd2l0aG91dCBhbnkgcmVzcG9uc2UKKwkgKiB0byB0aGUgYXBwbGljYXRpb24gY2xpZW50LiBBIFRBUyBiaXQgc2V0IHRvIG9uZSBzcGVjaWZpZXMgdGhhdCB0YXNrcworCSAqIGFib3J0ZWQgYnkgdGhlIGFjdGlvbnMgb2YgYW4gSV9UIG5leHVzIG90aGVyIHRoYW4gdGhlIElfVCBuZXh1cyBvbgorCSAqIHdoaWNoIHRoZSBjb21tYW5kIHdhcyByZWNlaXZlZCBzaGFsbCBiZSBjb21wbGV0ZWQgd2l0aCBUQVNLIEFCT1JURUQKKwkgKiBzdGF0dXMgKHNlZSBTQU0tNCkuCisJICovCisJdGFzID0gREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3RhczsKKwkvKgorCSAqIERldGVybWluZSBpZiB0aGlzIHNlX3RtciBpcyBjb21pbmcgZnJvbSBhICRGQUJSSUNfTU9ECisJICogb3Igc3RydWN0IHNlX2RldmljZSBwYXNzdGhyb3VnaC4uCisJICovCisJaWYgKHRtciAmJiB0bXItPnRhc2tfY21kICYmIHRtci0+dGFza19jbWQtPnNlX3Nlc3MpIHsKKwkJdG1yX25hY2wgPSB0bXItPnRhc2tfY21kLT5zZV9zZXNzLT5zZV9ub2RlX2FjbDsKKwkJdG1yX3RwZyA9IHRtci0+dGFza19jbWQtPnNlX3Nlc3MtPnNlX3RwZzsKKwkJaWYgKHRtcl9uYWNsICYmIHRtcl90cGcpIHsKKwkJCURFQlVHX0xSKCJMVU5fUkVTRVQ6IFRNUiBjYWxsZXIgZmFicmljOiAlcyIKKwkJCQkiIGluaXRpYXRvciBwb3J0ICVzXG4iLAorCQkJCVRQR19URk8odG1yX3RwZyktPmdldF9mYWJyaWNfbmFtZSgpLAorCQkJCXRtcl9uYWNsLT5pbml0aWF0b3JuYW1lKTsKKwkJfQorCX0KKwlERUJVR19MUigiTFVOX1JFU0VUOiAlcyBzdGFydGluZyBmb3IgWyVzXSwgdGFzOiAlZFxuIiwKKwkJKHByZWVtcHRfYW5kX2Fib3J0X2xpc3QpID8gIlByZWVtcHQiIDogIlRNUiIsCisJCVRSQU5TUE9SVChkZXYpLT5uYW1lLCB0YXMpOworCS8qCisJICogUmVsZWFzZSBhbGwgcGVuZGluZyBhbmQgb3V0Z29pbmcgVE1ScyBhc2lkZSBmcm9tIHRoZSByZWNlaXZlZAorCSAqIExVTl9SRVNFVCB0bXIuLgorCSAqLworCXNwaW5fbG9jaygmZGV2LT5zZV90bXJfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHRtcl9wLCB0bXJfcHAsICZkZXYtPmRldl90bXJfbGlzdCwgdG1yX2xpc3QpIHsKKwkJLyoKKwkJICogQWxsb3cgdGhlIHJlY2VpdmVkIFRNUiB0byByZXR1cm4gd2l0aCBGVU5DVElPTl9DT01QTEVURS4KKwkJICovCisJCWlmICh0bXIgJiYgKHRtcl9wID09IHRtcikpCisJCQljb250aW51ZTsKKworCQljbWQgPSB0bXJfcC0+dGFza19jbWQ7CisJCWlmICghKGNtZCkpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGxvY2F0ZSBzdHJ1Y3Qgc2VfY21kIGZvciBUTVJcbiIpOworCQkJY29udGludWU7CisJCX0KKwkJLyoKKwkJICogSWYgdGhpcyBmdW5jdGlvbiB3YXMgY2FsbGVkIHdpdGggYSB2YWxpZCBwcl9yZXNfa2V5CisJCSAqIHBhcmFtZXRlciAoZWc6IGZvciBQUk9VVCBQUkVFTVBUX0FORF9BQk9SVCBzZXJ2aWNlIGFjdGlvbgorCQkgKiBza2lwIG5vbiByZWdpc3JhdGlvbiBrZXkgbWF0Y2hpbmcgVE1Scy4KKwkJICovCisJCWlmICgocHJlZW1wdF9hbmRfYWJvcnRfbGlzdCAhPSBOVUxMKSAmJgorCQkgICAgKGNvcmVfc2NzaTNfY2hlY2tfY2RiX2Fib3J0X2FuZF9wcmVlbXB0KAorCQkJCQlwcmVlbXB0X2FuZF9hYm9ydF9saXN0LCBjbWQpICE9IDApKQorCQkJY29udGludWU7CisJCXNwaW5fdW5sb2NrKCZkZXYtPnNlX3Rtcl9sb2NrKTsKKworCQlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCQlpZiAoIShhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X2FjdGl2ZSkpKSB7CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJCQlzcGluX2xvY2soJmRldi0+c2VfdG1yX2xvY2spOworCQkJY29udGludWU7CisJCX0KKwkJaWYgKGNtZC0+dF9zdGF0ZSA9PSBUUkFOU1BPUlRfSVNUQVRFX1BST0NFU1NJTkcpIHsKKwkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwkJCXNwaW5fbG9jaygmZGV2LT5zZV90bXJfbG9jayk7CisJCQljb250aW51ZTsKKwkJfQorCQlERUJVR19MUigiTFVOX1JFU0VUOiAlcyByZWxlYXNpbmcgVE1SICVwIEZ1bmN0aW9uOiAweCUwMngsIgorCQkJIiBSZXNwb25zZTogMHglMDJ4LCB0X3N0YXRlOiAlZFxuIiwKKwkJCShwcmVlbXB0X2FuZF9hYm9ydF9saXN0KSA/ICJQcmVlbXB0IiA6ICIiLCB0bXJfcCwKKwkJCXRtcl9wLT5mdW5jdGlvbiwgdG1yX3AtPnJlc3BvbnNlLCBjbWQtPnRfc3RhdGUpOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisKKwkJdHJhbnNwb3J0X2NtZF9maW5pc2hfYWJvcnRfdG1yKGNtZCk7CisJCXNwaW5fbG9jaygmZGV2LT5zZV90bXJfbG9jayk7CisJfQorCXNwaW5fdW5sb2NrKCZkZXYtPnNlX3Rtcl9sb2NrKTsKKwkvKgorCSAqIENvbXBsZXRlIG91dHN0YW5kaW5nIHN0cnVjdCBzZV90YXNrIENEQnMgd2l0aCBUQVNLX0FCT1JURUQgU0FNIHN0YXR1cy4KKwkgKiBUaGlzIGlzIGZvbGxvd2luZyBzYW00cjE3LCBzZWN0aW9uIDUuNiBBYm9ydGluZyBjb21tYW5kcywgVGFibGUgMzgKKwkgKiBmb3IgVE1SIExVTl9SRVNFVDoKKwkgKgorCSAqIGEpICJZZXMiIGluZGljYXRlcyB0aGF0IGVhY2ggY29tbWFuZCB0aGF0IGlzIGFib3J0ZWQgb24gYW4gSV9UIG5leHVzCisJICogb3RoZXIgdGhhbiB0aGUgb25lIHRoYXQgY2F1c2VkIHRoZSBTQ1NJIGRldmljZSBjb25kaXRpb24gaXMKKwkgKiBjb21wbGV0ZWQgd2l0aCBUQVNLIEFCT1JURUQgc3RhdHVzLCBpZiB0aGUgVEFTIGJpdCBpcyBzZXQgdG8gb25lIGluCisJICogdGhlIENvbnRyb2wgbW9kZSBwYWdlIChzZWUgU1BDLTQpLiAiTm8iIGluZGljYXRlcyB0aGF0IG5vIHN0YXR1cyBpcworCSAqIHJldHVybmVkIGZvciBhYm9ydGVkIGNvbW1hbmRzLgorCSAqCisJICogZCkgSWYgdGhlIGxvZ2ljYWwgdW5pdCByZXNldCBpcyBjYXVzZWQgYnkgYSBwYXJ0aWN1bGFyIElfVCBuZXh1cworCSAqIChlLmcuLCBieSBhIExPR0lDQUwgVU5JVCBSRVNFVCB0YXNrIG1hbmFnZW1lbnQgZnVuY3Rpb24pLCB0aGVuICJ5ZXMiCisJICogKFRBU0tfQUJPUlRFRCBzdGF0dXMpIGFwcGxpZXMuCisJICoKKwkgKiBPdGhlcndpc2UgKGUuZy4sIGlmIHRyaWdnZXJlZCBieSBhIGhhcmQgcmVzZXQpLCAibm8iCisJICogKG5vIFRBU0tfQUJPUlRFRCBTQU0gc3RhdHVzKSBhcHBsaWVzLgorCSAqCisJICogTm90ZSB0aGF0IHRoaXMgc2VlbXMgdG8gYmUgaW5kZXBlbmRlbnQgb2YgVEFTIChUYXNrIEFib3J0ZWQgU3RhdHVzKQorCSAqIGluIHRoZSBDb250cm9sIE1vZGUgUGFnZS4KKwkgKi8KKwlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2LT5leGVjdXRlX3Rhc2tfbG9jaywgZmxhZ3MpOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSh0YXNrLCB0YXNrX3RtcCwgJmRldi0+c3RhdGVfdGFza19saXN0LAorCQkJCXRfc3RhdGVfbGlzdCkgeworCQlpZiAoIShUQVNLX0NNRCh0YXNrKSkpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiVEFTS19DTUQodGFzaykgaXMgTlVMTCFcbiIpOworCQkJY29udGludWU7CisJCX0KKwkJY21kID0gVEFTS19DTUQodGFzayk7CisKKwkJaWYgKCFUX1RBU0soY21kKSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJUX1RBU0soY21kKSBpcyBOVUxMIGZvciB0YXNrOiAlcCBjbWQ6IgorCQkJCSIgJXAgSVRUOiAweCUwOHhcbiIsIHRhc2ssIGNtZCwKKwkJCQlDTURfVEZPKGNtZCktPmdldF90YXNrX3RhZyhjbWQpKTsKKwkJCWNvbnRpbnVlOworCQl9CisJCS8qCisJCSAqIEZvciBQUkVFTVBUX0FORF9BQk9SVCB1c2FnZSwgb25seSBwcm9jZXNzIGNvbW1hbmRzCisJCSAqIHdpdGggYSBtYXRjaGluZyByZXNlcnZhdGlvbiBrZXkuCisJCSAqLworCQlpZiAoKHByZWVtcHRfYW5kX2Fib3J0X2xpc3QgIT0gTlVMTCkgJiYKKwkJICAgIChjb3JlX3Njc2kzX2NoZWNrX2NkYl9hYm9ydF9hbmRfcHJlZW1wdCgKKwkJCQkJcHJlZW1wdF9hbmRfYWJvcnRfbGlzdCwgY21kKSAhPSAwKSkKKwkJCWNvbnRpbnVlOworCQkvKgorCQkgKiBOb3QgYWJvcnRpbmcgUFJPVVQgUFJFRU1QVF9BTkRfQUJPUlQgQ0RCLi4KKwkJICovCisJCWlmIChwcm91dF9jbWQgPT0gY21kKQorCQkJY29udGludWU7CisKKwkJbGlzdF9kZWwoJnRhc2stPnRfc3RhdGVfbGlzdCk7CisJCWF0b21pY19zZXQoJnRhc2stPnRhc2tfc3RhdGVfYWN0aXZlLCAwKTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGV2LT5leGVjdXRlX3Rhc2tfbG9jaywgZmxhZ3MpOworCisJCXNwaW5fbG9ja19pcnFzYXZlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJCURFQlVHX0xSKCJMVU5fUkVTRVQ6ICVzIGNtZDogJXAgdGFzazogJXAiCisJCQkiIElUVC9DbWRTTjogMHglMDh4LzB4JTA4eCwgaV9zdGF0ZTogJWQsIHRfc3RhdGUvIgorCQkJImRlZl90X3N0YXRlOiAlZC8lZCBjZGI6IDB4JTAyeFxuIiwKKwkJCShwcmVlbXB0X2FuZF9hYm9ydF9saXN0KSA/ICJQcmVlbXB0IiA6ICIiLCBjbWQsIHRhc2ssCisJCQlDTURfVEZPKGNtZCktPmdldF90YXNrX3RhZyhjbWQpLCAwLAorCQkJQ01EX1RGTyhjbWQpLT5nZXRfY21kX3N0YXRlKGNtZCksIGNtZC0+dF9zdGF0ZSwKKwkJCWNtZC0+ZGVmZXJyZWRfdF9zdGF0ZSwgVF9UQVNLKGNtZCktPnRfdGFza19jZGJbMF0pOworCQlERUJVR19MUigiTFVOX1JFU0VUOiBJVFRbMHglMDh4XSAtIHByX3Jlc19rZXk6IDB4JTAxNkx4IgorCQkJIiB0X3Rhc2tfY2RiczogJWQgdF90YXNrX2NkYnNfbGVmdDogJWQiCisJCQkiIHRfdGFza19jZGJzX3NlbnQ6ICVkIC0tIHRfdHJhbnNwb3J0X2FjdGl2ZTogJWQiCisJCQkiIHRfdHJhbnNwb3J0X3N0b3A6ICVkIHRfdHJhbnNwb3J0X3NlbnQ6ICVkXG4iLAorCQkJQ01EX1RGTyhjbWQpLT5nZXRfdGFza190YWcoY21kKSwgY21kLT5wcl9yZXNfa2V5LAorCQkJVF9UQVNLKGNtZCktPnRfdGFza19jZGJzLAorCQkJYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X3Rhc2tfY2Ric19sZWZ0KSwKKwkJCWF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF90YXNrX2NkYnNfc2VudCksCisJCQlhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X2FjdGl2ZSksCisJCQlhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X3N0b3ApLAorCQkJYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X3RyYW5zcG9ydF9zZW50KSk7CisKKwkJaWYgKGF0b21pY19yZWFkKCZ0YXNrLT50YXNrX2FjdGl2ZSkpIHsKKwkJCWF0b21pY19zZXQoJnRhc2stPnRhc2tfc3RvcCwgMSk7CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKAorCQkJCSZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisKKwkJCURFQlVHX0xSKCJMVU5fUkVTRVQ6IFdhaXRpbmcgZm9yIHRhc2s6ICVwIHRvIHNodXRkb3duIgorCQkJCSIgZm9yIGRldjogJXBcbiIsIHRhc2ssIGRldik7CisJCQl3YWl0X2Zvcl9jb21wbGV0aW9uKCZ0YXNrLT50YXNrX3N0b3BfY29tcCk7CisJCQlERUJVR19MUigiTFVOX1JFU0VUIENvbXBsZXRlZCB0YXNrOiAlcCBzaHV0ZG93biBmb3IiCisJCQkJIiBkZXY6ICVwXG4iLCB0YXNrLCBkZXYpOworCQkJc3Bpbl9sb2NrX2lycXNhdmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwkJCWF0b21pY19kZWMoJlRfVEFTSyhjbWQpLT50X3Rhc2tfY2Ric19sZWZ0KTsKKworCQkJYXRvbWljX3NldCgmdGFzay0+dGFza19hY3RpdmUsIDApOworCQkJYXRvbWljX3NldCgmdGFzay0+dGFza19zdG9wLCAwKTsKKwkJfQorCQlfX3RyYW5zcG9ydF9zdG9wX3Rhc2tfdGltZXIodGFzaywgJmZsYWdzKTsKKworCQlpZiAoIShhdG9taWNfZGVjX2FuZF90ZXN0KCZUX1RBU0soY21kKS0+dF90YXNrX2NkYnNfZXhfbGVmdCkpKSB7CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKAorCQkJCQkmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCQkJREVCVUdfTFIoIkxVTl9SRVNFVDogU2tpcHBpbmcgdGFzazogJXAsIGRldjogJXAgZm9yIgorCQkJCSIgdF90YXNrX2NkYnNfZXhfbGVmdDogJWRcbiIsIHRhc2ssIGRldiwKKwkJCQlhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfdGFza19jZGJzX2V4X2xlZnQpKTsKKworCQkJc3Bpbl9sb2NrX2lycXNhdmUoJmRldi0+ZXhlY3V0ZV90YXNrX2xvY2ssIGZsYWdzKTsKKwkJCWNvbnRpbnVlOworCQl9CisJCWZlX2NvdW50ID0gYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X2ZlX2NvdW50KTsKKworCQlpZiAoYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X3RyYW5zcG9ydF9hY3RpdmUpKSB7CisJCQlERUJVR19MUigiTFVOX1JFU0VUOiBnb3QgdF90cmFuc3BvcnRfYWN0aXZlID0gMSBmb3IiCisJCQkJIiB0YXNrOiAlcCwgdF9mZV9jb3VudDogJWQgZGV2OiAlcFxuIiwgdGFzaywKKwkJCQlmZV9jb3VudCwgZGV2KTsKKwkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssCisJCQkJCQlmbGFncyk7CisJCQljb3JlX3Rtcl9oYW5kbGVfdGFzX2Fib3J0KHRtcl9uYWNsLCBjbWQsIHRhcywgZmVfY291bnQpOworCisJCQlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2LT5leGVjdXRlX3Rhc2tfbG9jaywgZmxhZ3MpOworCQkJY29udGludWU7CisJCX0KKwkJREVCVUdfTFIoIkxVTl9SRVNFVDogR290IHRfdHJhbnNwb3J0X2FjdGl2ZSA9IDAgZm9yIHRhc2s6ICVwLCIKKwkJCSIgdF9mZV9jb3VudDogJWQgZGV2OiAlcFxuIiwgdGFzaywgZmVfY291bnQsIGRldik7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwkJY29yZV90bXJfaGFuZGxlX3Rhc19hYm9ydCh0bXJfbmFjbCwgY21kLCB0YXMsIGZlX2NvdW50KTsKKworCQlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2LT5leGVjdXRlX3Rhc2tfbG9jaywgZmxhZ3MpOworCX0KKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXYtPmV4ZWN1dGVfdGFza19sb2NrLCBmbGFncyk7CisJLyoKKwkgKiBSZWxlYXNlIGFsbCBjb21tYW5kcyByZW1haW5pbmcgaW4gdGhlIHN0cnVjdCBzZV9kZXZpY2UgY21kIHF1ZXVlLgorCSAqCisJICogVGhpcyBmb2xsb3dzIHRoZSBzYW1lIGxvZ2ljIGFzIGFib3ZlIGZvciB0aGUgc3RydWN0IHNlX2RldmljZQorCSAqIHN0cnVjdCBzZV90YXNrIHN0YXRlIGxpc3QsIHdoZXJlIGNvbW1hbmRzIGFyZSByZXR1cm5lZCB3aXRoCisJICogVEFTS19BQk9SVEVEIHN0YXR1cywgaWYgdGhlcmUgaXMgYW4gb3V0c3RhbmRpbmcgJEZBQlJJQ19NT0QKKwkgKiByZWZlcmVuY2UsIG90aGVyd2lzZSB0aGUgc3RydWN0IHNlX2NtZCBpcyByZWxlYXNlZC4KKwkgKi8KKwlzcGluX2xvY2tfaXJxc2F2ZSgmcW9iai0+Y21kX3F1ZXVlX2xvY2ssIGZsYWdzKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocXIsIHFyX3RtcCwgJnFvYmotPnFvYmpfbGlzdCwgcXJfbGlzdCkgeworCQljbWQgPSAoc3RydWN0IHNlX2NtZCAqKXFyLT5jbWQ7CisJCWlmICghKGNtZCkpIHsKKwkJCS8qCisJCQkgKiBTa2lwIHRoZXNlIGZvciBub24gUFJFRU1QVF9BTkRfQUJPUlQgdXNhZ2UuLgorCQkJICovCisJCQlpZiAocHJlZW1wdF9hbmRfYWJvcnRfbGlzdCAhPSBOVUxMKQorCQkJCWNvbnRpbnVlOworCisJCQlhdG9taWNfZGVjKCZxb2JqLT5xdWV1ZV9jbnQpOworCQkJbGlzdF9kZWwoJnFyLT5xcl9saXN0KTsKKwkJCWtmcmVlKHFyKTsKKwkJCWNvbnRpbnVlOworCQl9CisJCS8qCisJCSAqIEZvciBQUkVFTVBUX0FORF9BQk9SVCB1c2FnZSwgb25seSBwcm9jZXNzIGNvbW1hbmRzCisJCSAqIHdpdGggYSBtYXRjaGluZyByZXNlcnZhdGlvbiBrZXkuCisJCSAqLworCQlpZiAoKHByZWVtcHRfYW5kX2Fib3J0X2xpc3QgIT0gTlVMTCkgJiYKKwkJICAgIChjb3JlX3Njc2kzX2NoZWNrX2NkYl9hYm9ydF9hbmRfcHJlZW1wdCgKKwkJCQkJcHJlZW1wdF9hbmRfYWJvcnRfbGlzdCwgY21kKSAhPSAwKSkKKwkJCWNvbnRpbnVlOworCQkvKgorCQkgKiBOb3QgYWJvcnRpbmcgUFJPVVQgUFJFRU1QVF9BTkRfQUJPUlQgQ0RCLi4KKwkJICovCisJCWlmIChwcm91dF9jbWQgPT0gY21kKQorCQkJY29udGludWU7CisKKwkJYXRvbWljX2RlYygmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X3F1ZXVlX2FjdGl2ZSk7CisJCWF0b21pY19kZWMoJnFvYmotPnF1ZXVlX2NudCk7CisJCWxpc3RfZGVsKCZxci0+cXJfbGlzdCk7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnFvYmotPmNtZF9xdWV1ZV9sb2NrLCBmbGFncyk7CisKKwkJc3RhdGUgPSBxci0+c3RhdGU7CisJCWtmcmVlKHFyKTsKKworCQlERUJVR19MUigiTFVOX1JFU0VUOiAlcyBmcm9tIERldmljZSBRdWV1ZTogY21kOiAlcCB0X3N0YXRlOiIKKwkJCSIgJWQgdF9mZV9jb3VudDogJWRcbiIsIChwcmVlbXB0X2FuZF9hYm9ydF9saXN0KSA/CisJCQkiUHJlZW1wdCIgOiAiIiwgY21kLCBzdGF0ZSwKKwkJCWF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF9mZV9jb3VudCkpOworCQkvKgorCQkgKiBTaWduYWwgdGhhdCB0aGUgY29tbWFuZCBoYXMgZmFpbGVkIHZpYSBjbWQtPnNlX2NtZF9mbGFncywKKwkJICogYW5kIGNhbGwgVEZPLT5uZXdfY21kX2ZhaWx1cmUoKSB0byB3YWtldXAgYW55IGZhYnJpYworCQkgKiBkZXBlbmRlbnQgY29kZSB1c2VkIHRvIHdhaXQgZm9yIHVuc29saWNpdGVkIGRhdGEgb3V0CisJCSAqIGFsbG9jYXRpb24gdG8gY29tcGxldGUuICBUaGUgZmFicmljIG1vZHVsZSBpcyBleHBlY3RlZAorCQkgKiB0byBkdW1wIGFueSByZW1haW5pbmcgdW5zb2xpY2l0ZWQgZGF0YSBvdXQgZm9yIHRoZSBhYm9ydGVkCisJCSAqIGNvbW1hbmQgYXQgdGhpcyBwb2ludC4KKwkJICovCisJCXRyYW5zcG9ydF9uZXdfY21kX2ZhaWx1cmUoY21kKTsKKworCQljb3JlX3Rtcl9oYW5kbGVfdGFzX2Fib3J0KHRtcl9uYWNsLCBjbWQsIHRhcywKKwkJCQlhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfZmVfY291bnQpKTsKKwkJc3Bpbl9sb2NrX2lycXNhdmUoJnFvYmotPmNtZF9xdWV1ZV9sb2NrLCBmbGFncyk7CisJfQorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnFvYmotPmNtZF9xdWV1ZV9sb2NrLCBmbGFncyk7CisJLyoKKwkgKiBDbGVhciBhbnkgbGVnYWN5IFNQQy0yIHJlc2VydmF0aW9uIHdoZW4gY2FsbGVkIGR1cmluZworCSAqIExPR0lDQUwgVU5JVCBSRVNFVAorCSAqLworCWlmICghKHByZWVtcHRfYW5kX2Fib3J0X2xpc3QpICYmCisJICAgICAoZGV2LT5kZXZfZmxhZ3MgJiBERl9TUEMyX1JFU0VSVkFUSU9OUykpIHsKKwkJc3Bpbl9sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwkJZGV2LT5kZXZfcmVzZXJ2ZWRfbm9kZV9hY2wgPSBOVUxMOworCQlkZXYtPmRldl9mbGFncyAmPSB+REZfU1BDMl9SRVNFUlZBVElPTlM7CisJCXNwaW5fdW5sb2NrKCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwkJcHJpbnRrKEtFUk5fSU5GTyAiTFVOX1JFU0VUOiBTQ1NJLTIgUmVsZWFzZWQgcmVzZXJ2YXRpb25cbiIpOworCX0KKworCXNwaW5fbG9jaygmZGV2LT5zdGF0c19sb2NrKTsKKwlkZXYtPm51bV9yZXNldHMrKzsKKwlzcGluX3VubG9jaygmZGV2LT5zdGF0c19sb2NrKTsKKworCURFQlVHX0xSKCJMVU5fUkVTRVQ6ICVzIGZvciBbJXNdIENvbXBsZXRlXG4iLAorCQkJKHByZWVtcHRfYW5kX2Fib3J0X2xpc3QpID8gIlByZWVtcHQiIDogIlRNUiIsCisJCQlUUkFOU1BPUlQoZGV2KS0+bmFtZSk7CisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV90cGcuYyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX3RwZy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmFiZmE4MWEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV90cGcuYwpAQCAtMCwwICsxLDgyNiBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIEZpbGVuYW1lOiAgdGFyZ2V0X2NvcmVfdHBnLmMKKyAqCisgKiBUaGlzIGZpbGUgY29udGFpbnMgZ2VuZXJpYyBUYXJnZXQgUG9ydGFsIEdyb3VwIHJlbGF0ZWQgZnVuY3Rpb25zLgorICoKKyAqIENvcHlyaWdodCAoYykgMjAwMiwgMjAwMywgMjAwNCwgMjAwNSBQeVggVGVjaG5vbG9naWVzLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUsIDIwMDYsIDIwMDcgU0JFLCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMDctMjAxMCBSaXNpbmcgVGlkZSBTeXN0ZW1zCisgKiBDb3B5cmlnaHQgKGMpIDIwMDgtMjAxMCBMaW51eC1pU0NTSS5vcmcKKyAqCisgKiBOaWNob2xhcyBBLiBCZWxsaW5nZXIgPG5hYkBrZXJuZWwub3JnPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworI2luY2x1ZGUgPGxpbnV4L25ldC5oPgorI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgorI2luY2x1ZGUgPGxpbnV4L3RpbWVyLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CisjaW5jbHVkZSA8bGludXgvc21wX2xvY2suaD4KKyNpbmNsdWRlIDxsaW51eC9pbi5oPgorI2luY2x1ZGUgPG5ldC9zb2NrLmg+CisjaW5jbHVkZSA8bmV0L3RjcC5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaS5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV9jbW5kLmg+CisKKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfYmFzZS5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdHBnLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX3RyYW5zcG9ydC5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfb3BzLmg+CisKKyNpbmNsdWRlICJ0YXJnZXRfY29yZV9oYmEuaCIKKworLyoJY29yZV9jbGVhcl9pbml0aWF0b3Jfbm9kZV9mcm9tX3RwZygpOgorICoKKyAqCisgKi8KK3N0YXRpYyB2b2lkIGNvcmVfY2xlYXJfaW5pdGlhdG9yX25vZGVfZnJvbV90cGcoCisJc3RydWN0IHNlX25vZGVfYWNsICpuYWNsLAorCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZykKK3sKKwlpbnQgaTsKKwlzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICpkZXZlOworCXN0cnVjdCBzZV9sdW4gKmx1bjsKKwlzdHJ1Y3Qgc2VfbHVuX2FjbCAqYWNsLCAqYWNsX3RtcDsKKworCXNwaW5fbG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCWZvciAoaSA9IDA7IGkgPCBUUkFOU1BPUlRfTUFYX0xVTlNfUEVSX1RQRzsgaSsrKSB7CisJCWRldmUgPSAmbmFjbC0+ZGV2aWNlX2xpc3RbaV07CisKKwkJaWYgKCEoZGV2ZS0+bHVuX2ZsYWdzICYgVFJBTlNQT1JUX0xVTkZMQUdTX0lOSVRJQVRPUl9BQ0NFU1MpKQorCQkJY29udGludWU7CisKKwkJaWYgKCFkZXZlLT5zZV9sdW4pIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiJXMgZGV2aWNlIGVudHJpZXMgZGV2aWNlIHBvaW50ZXIgaXMiCisJCQkJIiBOVUxMLCBidXQgSW5pdGlhdG9yIGhhcyBhY2Nlc3MuXG4iLAorCQkJCVRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCkpOworCQkJY29udGludWU7CisJCX0KKworCQlsdW4gPSBkZXZlLT5zZV9sdW47CisJCXNwaW5fdW5sb2NrX2lycSgmbmFjbC0+ZGV2aWNlX2xpc3RfbG9jayk7CisJCWNvcmVfdXBkYXRlX2RldmljZV9saXN0X2Zvcl9ub2RlKGx1biwgTlVMTCwgZGV2ZS0+bWFwcGVkX2x1biwKKwkJCVRSQU5TUE9SVF9MVU5GTEFHU19OT19BQ0NFU1MsIG5hY2wsIHRwZywgMCk7CisKKwkJc3Bpbl9sb2NrKCZsdW4tPmx1bl9hY2xfbG9jayk7CisJCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShhY2wsIGFjbF90bXAsCisJCQkJCSZsdW4tPmx1bl9hY2xfbGlzdCwgbGFjbF9saXN0KSB7CisJCQlpZiAoIShzdHJjbXAoYWNsLT5pbml0aWF0b3JuYW1lLAorCQkJCQluYWNsLT5pbml0aWF0b3JuYW1lKSkgJiYKKwkJCSAgICAgKGFjbC0+bWFwcGVkX2x1biA9PSBkZXZlLT5tYXBwZWRfbHVuKSkKKwkJCQlicmVhazsKKwkJfQorCisJCWlmICghYWNsKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2NhdGUgc3RydWN0IHNlX2x1bl9hY2wgZm9yICVzLCIKKwkJCQkiIG1hcHBlZF9sdW46ICV1XG4iLCBuYWNsLT5pbml0aWF0b3JuYW1lLAorCQkJCWRldmUtPm1hcHBlZF9sdW4pOworCQkJc3Bpbl91bmxvY2soJmx1bi0+bHVuX2FjbF9sb2NrKTsKKwkJCXNwaW5fbG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCQkJY29udGludWU7CisJCX0KKworCQlsaXN0X2RlbCgmYWNsLT5sYWNsX2xpc3QpOworCQlzcGluX3VubG9jaygmbHVuLT5sdW5fYWNsX2xvY2spOworCisJCXNwaW5fbG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCQlrZnJlZShhY2wpOworCX0KKwlzcGluX3VubG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworfQorCisvKglfX2NvcmVfdHBnX2dldF9pbml0aWF0b3Jfbm9kZV9hY2woKToKKyAqCisgKglzcGluX2xvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7IG11c3QgYmUgaGVsZCB3aGVuIGNhbGxpbmcKKyAqLworc3RydWN0IHNlX25vZGVfYWNsICpfX2NvcmVfdHBnX2dldF9pbml0aWF0b3Jfbm9kZV9hY2woCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnLAorCWNvbnN0IGNoYXIgKmluaXRpYXRvcm5hbWUpCit7CisJc3RydWN0IHNlX25vZGVfYWNsICphY2w7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGFjbCwgJnRwZy0+YWNsX25vZGVfbGlzdCwgYWNsX2xpc3QpIHsKKwkJaWYgKCEoc3RyY21wKGFjbC0+aW5pdGlhdG9ybmFtZSwgaW5pdGlhdG9ybmFtZSkpKQorCQkJcmV0dXJuIGFjbDsKKwl9CisKKwlyZXR1cm4gTlVMTDsKK30KKworLyoJY29yZV90cGdfZ2V0X2luaXRpYXRvcl9ub2RlX2FjbCgpOgorICoKKyAqCisgKi8KK3N0cnVjdCBzZV9ub2RlX2FjbCAqY29yZV90cGdfZ2V0X2luaXRpYXRvcl9ub2RlX2FjbCgKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcsCisJdW5zaWduZWQgY2hhciAqaW5pdGlhdG9ybmFtZSkKK3sKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKmFjbDsKKworCXNwaW5fbG9ja19iaCgmdHBnLT5hY2xfbm9kZV9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGFjbCwgJnRwZy0+YWNsX25vZGVfbGlzdCwgYWNsX2xpc3QpIHsKKwkJaWYgKCEoc3RyY21wKGFjbC0+aW5pdGlhdG9ybmFtZSwgaW5pdGlhdG9ybmFtZSkpICYmCisJCSAgICghKGFjbC0+ZHluYW1pY19ub2RlX2FjbCkpKSB7CisJCQlzcGluX3VubG9ja19iaCgmdHBnLT5hY2xfbm9kZV9sb2NrKTsKKwkJCXJldHVybiBhY2w7CisJCX0KKwl9CisJc3Bpbl91bmxvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7CisKKwlyZXR1cm4gTlVMTDsKK30KKworLyoJY29yZV90cGdfYWRkX25vZGVfdG9fZGV2cygpOgorICoKKyAqCisgKi8KK3ZvaWQgY29yZV90cGdfYWRkX25vZGVfdG9fZGV2cygKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKmFjbCwKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcpCit7CisJaW50IGkgPSAwOworCXUzMiBsdW5fYWNjZXNzID0gMDsKKwlzdHJ1Y3Qgc2VfbHVuICpsdW47CisJc3RydWN0IHNlX2RldmljZSAqZGV2OworCisJc3Bpbl9sb2NrKCZ0cGctPnRwZ19sdW5fbG9jayk7CisJZm9yIChpID0gMDsgaSA8IFRSQU5TUE9SVF9NQVhfTFVOU19QRVJfVFBHOyBpKyspIHsKKwkJbHVuID0gJnRwZy0+dHBnX2x1bl9saXN0W2ldOworCQlpZiAobHVuLT5sdW5fc3RhdHVzICE9IFRSQU5TUE9SVF9MVU5fU1RBVFVTX0FDVElWRSkKKwkJCWNvbnRpbnVlOworCisJCXNwaW5fdW5sb2NrKCZ0cGctPnRwZ19sdW5fbG9jayk7CisKKwkJZGV2ID0gbHVuLT5sdW5fc2VfZGV2OworCQkvKgorCQkgKiBCeSBkZWZhdWx0IGluIExJTy1UYXJnZXQgJEZBQlJJQ19NT0QsCisJCSAqIGRlbW9fbW9kZV93cml0ZV9wcm90ZWN0IGlzIE9OLCBvciBSRUFEX09OTFk7CisJCSAqLworCQlpZiAoIShUUEdfVEZPKHRwZyktPnRwZ19jaGVja19kZW1vX21vZGVfd3JpdGVfcHJvdGVjdCh0cGcpKSkgeworCQkJaWYgKGRldi0+ZGV2X2ZsYWdzICYgREZfUkVBRF9PTkxZKQorCQkJCWx1bl9hY2Nlc3MgPSBUUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9PTkxZOworCQkJZWxzZQorCQkJCWx1bl9hY2Nlc3MgPSBUUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9XUklURTsKKwkJfSBlbHNlIHsKKwkJCS8qCisJCQkgKiBBbGxvdyBvbmx5IG9wdGljYWwgZHJpdmVzIHRvIGlzc3VlIFIvVyBpbiBkZWZhdWx0IFJPCisJCQkgKiBkZW1vIG1vZGUuCisJCQkgKi8KKwkJCWlmIChUUkFOU1BPUlQoZGV2KS0+Z2V0X2RldmljZV90eXBlKGRldikgPT0gVFlQRV9ESVNLKQorCQkJCWx1bl9hY2Nlc3MgPSBUUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9PTkxZOworCQkJZWxzZQorCQkJCWx1bl9hY2Nlc3MgPSBUUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9XUklURTsKKwkJfQorCisJCXByaW50ayhLRVJOX0lORk8gIlRBUkdFVF9DT1JFWyVzXS0+VFBHWyV1XV9MVU5bJXVdIC0gQWRkaW5nICVzIgorCQkJIiBhY2Nlc3MgZm9yIExVTiBpbiBEZW1vIE1vZGVcbiIsCisJCQlUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpLAorCQkJVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3RhZyh0cGcpLCBsdW4tPnVucGFja2VkX2x1biwKKwkJCShsdW5fYWNjZXNzID09IFRSQU5TUE9SVF9MVU5GTEFHU19SRUFEX1dSSVRFKSA/CisJCQkiUkVBRC1XUklURSIgOiAiUkVBRC1PTkxZIik7CisKKwkJY29yZV91cGRhdGVfZGV2aWNlX2xpc3RfZm9yX25vZGUobHVuLCBOVUxMLCBsdW4tPnVucGFja2VkX2x1biwKKwkJCQlsdW5fYWNjZXNzLCBhY2wsIHRwZywgMSk7CisJCXNwaW5fbG9jaygmdHBnLT50cGdfbHVuX2xvY2spOworCX0KKwlzcGluX3VubG9jaygmdHBnLT50cGdfbHVuX2xvY2spOworfQorCisvKiAgICAgIGNvcmVfc2V0X3F1ZXVlX2RlcHRoX2Zvcl9ub2RlKCk6CisgKgorICoKKyAqLworc3RhdGljIGludCBjb3JlX3NldF9xdWV1ZV9kZXB0aF9mb3Jfbm9kZSgKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcsCisJc3RydWN0IHNlX25vZGVfYWNsICphY2wpCit7CisJaWYgKCFhY2wtPnF1ZXVlX2RlcHRoKSB7CisJCXByaW50ayhLRVJOX0VSUiAiUXVldWUgZGVwdGggZm9yICVzIEluaXRpYXRvciBOb2RlOiAlcyBpcyAwLCIKKwkJCSJkZWZhdWx0aW5nIHRvIDEuXG4iLCBUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpLAorCQkJYWNsLT5pbml0aWF0b3JuYW1lKTsKKwkJYWNsLT5xdWV1ZV9kZXB0aCA9IDE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKy8qICAgICAgY29yZV9jcmVhdGVfZGV2aWNlX2xpc3RfZm9yX25vZGUoKToKKyAqCisgKgorICovCitzdGF0aWMgaW50IGNvcmVfY3JlYXRlX2RldmljZV9saXN0X2Zvcl9ub2RlKHN0cnVjdCBzZV9ub2RlX2FjbCAqbmFjbCkKK3sKKwlzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICpkZXZlOworCWludCBpOworCisJbmFjbC0+ZGV2aWNlX2xpc3QgPSBremFsbG9jKHNpemVvZihzdHJ1Y3Qgc2VfZGV2X2VudHJ5KSAqCisJCQkJVFJBTlNQT1JUX01BWF9MVU5TX1BFUl9UUEcsIEdGUF9LRVJORUwpOworCWlmICghKG5hY2wtPmRldmljZV9saXN0KSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIgorCQkJIiBzdHJ1Y3Qgc2Vfbm9kZV9hY2wtPmRldmljZV9saXN0XG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwlmb3IgKGkgPSAwOyBpIDwgVFJBTlNQT1JUX01BWF9MVU5TX1BFUl9UUEc7IGkrKykgeworCQlkZXZlID0gJm5hY2wtPmRldmljZV9saXN0W2ldOworCisJCWF0b21pY19zZXQoJmRldmUtPnVhX2NvdW50LCAwKTsKKwkJYXRvbWljX3NldCgmZGV2ZS0+cHJfcmVmX2NvdW50LCAwKTsKKwkJc3Bpbl9sb2NrX2luaXQoJmRldmUtPnVhX2xvY2spOworCQlJTklUX0xJU1RfSEVBRCgmZGV2ZS0+YWx1YV9wb3J0X2xpc3QpOworCQlJTklUX0xJU1RfSEVBRCgmZGV2ZS0+dWFfbGlzdCk7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKy8qCWNvcmVfdHBnX2NoZWNrX2luaXRpYXRvcl9ub2RlX2FjbCgpCisgKgorICoKKyAqLworc3RydWN0IHNlX25vZGVfYWNsICpjb3JlX3RwZ19jaGVja19pbml0aWF0b3Jfbm9kZV9hY2woCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnLAorCXVuc2lnbmVkIGNoYXIgKmluaXRpYXRvcm5hbWUpCit7CisJc3RydWN0IHNlX25vZGVfYWNsICphY2w7CisKKwlhY2wgPSBjb3JlX3RwZ19nZXRfaW5pdGlhdG9yX25vZGVfYWNsKHRwZywgaW5pdGlhdG9ybmFtZSk7CisJaWYgKChhY2wpKQorCQlyZXR1cm4gYWNsOworCisJaWYgKCEoVFBHX1RGTyh0cGcpLT50cGdfY2hlY2tfZGVtb19tb2RlKHRwZykpKQorCQlyZXR1cm4gTlVMTDsKKworCWFjbCA9ICBUUEdfVEZPKHRwZyktPnRwZ19hbGxvY19mYWJyaWNfYWNsKHRwZyk7CisJaWYgKCEoYWNsKSkKKwkJcmV0dXJuIE5VTEw7CisKKwlJTklUX0xJU1RfSEVBRCgmYWNsLT5hY2xfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJmFjbC0+YWNsX3Nlc3NfbGlzdCk7CisJc3Bpbl9sb2NrX2luaXQoJmFjbC0+ZGV2aWNlX2xpc3RfbG9jayk7CisJc3Bpbl9sb2NrX2luaXQoJmFjbC0+bmFjbF9zZXNzX2xvY2spOworCWF0b21pY19zZXQoJmFjbC0+YWNsX3ByX3JlZl9jb3VudCwgMCk7CisJYXRvbWljX3NldCgmYWNsLT5taWJfcmVmX2NvdW50LCAwKTsKKwlhY2wtPnF1ZXVlX2RlcHRoID0gVFBHX1RGTyh0cGcpLT50cGdfZ2V0X2RlZmF1bHRfZGVwdGgodHBnKTsKKwlzbnByaW50ZihhY2wtPmluaXRpYXRvcm5hbWUsIFRSQU5TUE9SVF9JUU5fTEVOLCAiJXMiLCBpbml0aWF0b3JuYW1lKTsKKwlhY2wtPnNlX3RwZyA9IHRwZzsKKwlhY2wtPmFjbF9pbmRleCA9IHNjc2lfZ2V0X25ld19pbmRleChTQ1NJX0FVVEhfSU5UUl9JTkRFWCk7CisJc3Bpbl9sb2NrX2luaXQoJmFjbC0+c3RhdHNfbG9jayk7CisJYWNsLT5keW5hbWljX25vZGVfYWNsID0gMTsKKworCVRQR19URk8odHBnKS0+c2V0X2RlZmF1bHRfbm9kZV9hdHRyaWJ1dGVzKGFjbCk7CisKKwlpZiAoY29yZV9jcmVhdGVfZGV2aWNlX2xpc3RfZm9yX25vZGUoYWNsKSA8IDApIHsKKwkJVFBHX1RGTyh0cGcpLT50cGdfcmVsZWFzZV9mYWJyaWNfYWNsKHRwZywgYWNsKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJaWYgKGNvcmVfc2V0X3F1ZXVlX2RlcHRoX2Zvcl9ub2RlKHRwZywgYWNsKSA8IDApIHsKKwkJY29yZV9mcmVlX2RldmljZV9saXN0X2Zvcl9ub2RlKGFjbCwgdHBnKTsKKwkJVFBHX1RGTyh0cGcpLT50cGdfcmVsZWFzZV9mYWJyaWNfYWNsKHRwZywgYWNsKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJY29yZV90cGdfYWRkX25vZGVfdG9fZGV2cyhhY2wsIHRwZyk7CisKKwlzcGluX2xvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7CisJbGlzdF9hZGRfdGFpbCgmYWNsLT5hY2xfbGlzdCwgJnRwZy0+YWNsX25vZGVfbGlzdCk7CisJdHBnLT5udW1fbm9kZV9hY2xzKys7CisJc3Bpbl91bmxvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7CisKKwlwcmludGsoIiVzX1RQR1sldV0gLSBBZGRlZCBEWU5BTUlDIEFDTCB3aXRoIFRDUSBEZXB0aDogJWQgZm9yICVzIgorCQkiIEluaXRpYXRvciBOb2RlOiAlc1xuIiwgVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3RhZyh0cGcpLCBhY2wtPnF1ZXVlX2RlcHRoLAorCQlUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpLCBpbml0aWF0b3JuYW1lKTsKKworCXJldHVybiBhY2w7Cit9CitFWFBPUlRfU1lNQk9MKGNvcmVfdHBnX2NoZWNrX2luaXRpYXRvcl9ub2RlX2FjbCk7CisKK3ZvaWQgY29yZV90cGdfd2FpdF9mb3JfbmFjbF9wcl9yZWYoc3RydWN0IHNlX25vZGVfYWNsICpuYWNsKQoreworCXdoaWxlIChhdG9taWNfcmVhZCgmbmFjbC0+YWNsX3ByX3JlZl9jb3VudCkgIT0gMCkKKwkJY3B1X3JlbGF4KCk7Cit9CisKK3ZvaWQgY29yZV90cGdfd2FpdF9mb3JfbWliX3JlZihzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKm5hY2wpCit7CisJd2hpbGUgKGF0b21pY19yZWFkKCZuYWNsLT5taWJfcmVmX2NvdW50KSAhPSAwKQorCQljcHVfcmVsYXgoKTsKK30KKwordm9pZCBjb3JlX3RwZ19jbGVhcl9vYmplY3RfbHVucyhzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcpCit7CisJaW50IGksIHJldDsKKwlzdHJ1Y3Qgc2VfbHVuICpsdW47CisKKwlzcGluX2xvY2soJnRwZy0+dHBnX2x1bl9sb2NrKTsKKwlmb3IgKGkgPSAwOyBpIDwgVFJBTlNQT1JUX01BWF9MVU5TX1BFUl9UUEc7IGkrKykgeworCQlsdW4gPSAmdHBnLT50cGdfbHVuX2xpc3RbaV07CisKKwkJaWYgKChsdW4tPmx1bl9zdGF0dXMgIT0gVFJBTlNQT1JUX0xVTl9TVEFUVVNfQUNUSVZFKSB8fAorCQkgICAgKGx1bi0+bHVuX3NlX2RldiA9PSBOVUxMKSkKKwkJCWNvbnRpbnVlOworCisJCXNwaW5fdW5sb2NrKCZ0cGctPnRwZ19sdW5fbG9jayk7CisJCXJldCA9IGNvcmVfZGV2X2RlbF9sdW4odHBnLCBsdW4tPnVucGFja2VkX2x1bik7CisJCXNwaW5fbG9jaygmdHBnLT50cGdfbHVuX2xvY2spOworCX0KKwlzcGluX3VubG9jaygmdHBnLT50cGdfbHVuX2xvY2spOworfQorRVhQT1JUX1NZTUJPTChjb3JlX3RwZ19jbGVhcl9vYmplY3RfbHVucyk7CisKKy8qCWNvcmVfdHBnX2FkZF9pbml0aWF0b3Jfbm9kZV9hY2woKToKKyAqCisgKgorICovCitzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKmNvcmVfdHBnX2FkZF9pbml0aWF0b3Jfbm9kZV9hY2woCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnLAorCXN0cnVjdCBzZV9ub2RlX2FjbCAqc2VfbmFjbCwKKwljb25zdCBjaGFyICppbml0aWF0b3JuYW1lLAorCXUzMiBxdWV1ZV9kZXB0aCkKK3sKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKmFjbCA9IE5VTEw7CisKKwlzcGluX2xvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7CisJYWNsID0gX19jb3JlX3RwZ19nZXRfaW5pdGlhdG9yX25vZGVfYWNsKHRwZywgaW5pdGlhdG9ybmFtZSk7CisJaWYgKChhY2wpKSB7CisJCWlmIChhY2wtPmR5bmFtaWNfbm9kZV9hY2wpIHsKKwkJCWFjbC0+ZHluYW1pY19ub2RlX2FjbCA9IDA7CisJCQlwcmludGsoS0VSTl9JTkZPICIlc19UUEdbJXVdIC0gUmVwbGFjaW5nIGR5bmFtaWMgQUNMIgorCQkJCSIgZm9yICVzXG4iLCBUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpLAorCQkJCVRQR19URk8odHBnKS0+dHBnX2dldF90YWcodHBnKSwgaW5pdGlhdG9ybmFtZSk7CisJCQlzcGluX3VubG9ja19iaCgmdHBnLT5hY2xfbm9kZV9sb2NrKTsKKwkJCS8qCisJCQkgKiBSZWxlYXNlIHRoZSBsb2NhbGx5IGFsbG9jYXRlZCBzdHJ1Y3Qgc2Vfbm9kZV9hY2wKKwkJCSAqIGJlY2F1c2UgKiBjb3JlX3RwZ19hZGRfaW5pdGlhdG9yX25vZGVfYWNsKCkgcmV0dXJuZWQKKwkJCSAqIGEgcG9pbnRlciB0byBhbiBleGlzdGluZyBkZW1vIG1vZGUgbm9kZSBBQ0wuCisJCQkgKi8KKwkJCWlmIChzZV9uYWNsKQorCQkJCVRQR19URk8odHBnKS0+dHBnX3JlbGVhc2VfZmFicmljX2FjbCh0cGcsCisJCQkJCQkJc2VfbmFjbCk7CisJCQlnb3RvIGRvbmU7CisJCX0KKworCQlwcmludGsoS0VSTl9FUlIgIkFDTCBlbnRyeSBmb3IgJXMgSW5pdGlhdG9yIgorCQkJIiBOb2RlICVzIGFscmVhZHkgZXhpc3RzIGZvciBUUEcgJXUsIGlnbm9yaW5nIgorCQkJIiByZXF1ZXN0LlxuIiwgIFRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCQlpbml0aWF0b3JuYW1lLCBUUEdfVEZPKHRwZyktPnRwZ19nZXRfdGFnKHRwZykpOworCQlzcGluX3VubG9ja19iaCgmdHBnLT5hY2xfbm9kZV9sb2NrKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVFWElTVCk7CisJfQorCXNwaW5fdW5sb2NrX2JoKCZ0cGctPmFjbF9ub2RlX2xvY2spOworCisJaWYgKCEoc2VfbmFjbCkpIHsKKwkJcHJpbnRrKCJzdHJ1Y3Qgc2Vfbm9kZV9hY2wgcG9pbnRlciBpcyBOVUxMXG4iKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisJfQorCS8qCisJICogRm9yIHY0LnggbG9naWMgdGhlIHNlX25vZGVfYWNsX3MgaXMgaGFuZ2luZyBvZmYgYSBmYWJyaWMKKwkgKiBkZXBlbmRlbnQgc3RydWN0dXJlIGFsbG9jYXRlZCB2aWEKKwkgKiBzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcy0+ZmFicmljX21ha2Vfbm9kZWFjbCgpCisJICovCisJYWNsID0gc2VfbmFjbDsKKworCUlOSVRfTElTVF9IRUFEKCZhY2wtPmFjbF9saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmYWNsLT5hY2xfc2Vzc19saXN0KTsKKwlzcGluX2xvY2tfaW5pdCgmYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmYWNsLT5uYWNsX3Nlc3NfbG9jayk7CisJYXRvbWljX3NldCgmYWNsLT5hY2xfcHJfcmVmX2NvdW50LCAwKTsKKwlhY2wtPnF1ZXVlX2RlcHRoID0gcXVldWVfZGVwdGg7CisJc25wcmludGYoYWNsLT5pbml0aWF0b3JuYW1lLCBUUkFOU1BPUlRfSVFOX0xFTiwgIiVzIiwgaW5pdGlhdG9ybmFtZSk7CisJYWNsLT5zZV90cGcgPSB0cGc7CisJYWNsLT5hY2xfaW5kZXggPSBzY3NpX2dldF9uZXdfaW5kZXgoU0NTSV9BVVRIX0lOVFJfSU5ERVgpOworCXNwaW5fbG9ja19pbml0KCZhY2wtPnN0YXRzX2xvY2spOworCisJVFBHX1RGTyh0cGcpLT5zZXRfZGVmYXVsdF9ub2RlX2F0dHJpYnV0ZXMoYWNsKTsKKworCWlmIChjb3JlX2NyZWF0ZV9kZXZpY2VfbGlzdF9mb3Jfbm9kZShhY2wpIDwgMCkgeworCQlUUEdfVEZPKHRwZyktPnRwZ19yZWxlYXNlX2ZhYnJpY19hY2wodHBnLCBhY2wpOworCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKwl9CisKKwlpZiAoY29yZV9zZXRfcXVldWVfZGVwdGhfZm9yX25vZGUodHBnLCBhY2wpIDwgMCkgeworCQljb3JlX2ZyZWVfZGV2aWNlX2xpc3RfZm9yX25vZGUoYWNsLCB0cGcpOworCQlUUEdfVEZPKHRwZyktPnRwZ19yZWxlYXNlX2ZhYnJpY19hY2wodHBnLCBhY2wpOworCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKKwl9CisKKwlzcGluX2xvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7CisJbGlzdF9hZGRfdGFpbCgmYWNsLT5hY2xfbGlzdCwgJnRwZy0+YWNsX25vZGVfbGlzdCk7CisJdHBnLT5udW1fbm9kZV9hY2xzKys7CisJc3Bpbl91bmxvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7CisKK2RvbmU6CisJcHJpbnRrKEtFUk5fSU5GTyAiJXNfVFBHWyVodV0gLSBBZGRlZCBBQ0wgd2l0aCBUQ1EgRGVwdGg6ICVkIGZvciAlcyIKKwkJIiBJbml0aWF0b3IgTm9kZTogJXNcbiIsIFRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCVRQR19URk8odHBnKS0+dHBnX2dldF90YWcodHBnKSwgYWNsLT5xdWV1ZV9kZXB0aCwKKwkJVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSwgaW5pdGlhdG9ybmFtZSk7CisKKwlyZXR1cm4gYWNsOworfQorRVhQT1JUX1NZTUJPTChjb3JlX3RwZ19hZGRfaW5pdGlhdG9yX25vZGVfYWNsKTsKKworLyoJY29yZV90cGdfZGVsX2luaXRpYXRvcl9ub2RlX2FjbCgpOgorICoKKyAqCisgKi8KK2ludCBjb3JlX3RwZ19kZWxfaW5pdGlhdG9yX25vZGVfYWNsKAorCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZywKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKmFjbCwKKwlpbnQgZm9yY2UpCit7CisJc3RydWN0IHNlX3Nlc3Npb24gKnNlc3MsICpzZXNzX3RtcDsKKwlpbnQgZHluYW1pY19hY2wgPSAwOworCisJc3Bpbl9sb2NrX2JoKCZ0cGctPmFjbF9ub2RlX2xvY2spOworCWlmIChhY2wtPmR5bmFtaWNfbm9kZV9hY2wpIHsKKwkJYWNsLT5keW5hbWljX25vZGVfYWNsID0gMDsKKwkJZHluYW1pY19hY2wgPSAxOworCX0KKwlsaXN0X2RlbCgmYWNsLT5hY2xfbGlzdCk7CisJdHBnLT5udW1fbm9kZV9hY2xzLS07CisJc3Bpbl91bmxvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7CisKKwlzcGluX2xvY2tfYmgoJnRwZy0+c2Vzc2lvbl9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoc2Vzcywgc2Vzc190bXAsCisJCQkJJnRwZy0+dHBnX3Nlc3NfbGlzdCwgc2Vzc19saXN0KSB7CisJCWlmIChzZXNzLT5zZV9ub2RlX2FjbCAhPSBhY2wpCisJCQljb250aW51ZTsKKwkJLyoKKwkJICogRGV0ZXJtaW5lIGlmIHRoZSBzZXNzaW9uIG5lZWRzIHRvIGJlIGNsb3NlZCBieSBvdXIgY29udGV4dC4KKwkJICovCisJCWlmICghKFRQR19URk8odHBnKS0+c2h1dGRvd25fc2Vzc2lvbihzZXNzKSkpCisJCQljb250aW51ZTsKKworCQlzcGluX3VubG9ja19iaCgmdHBnLT5zZXNzaW9uX2xvY2spOworCQkvKgorCQkgKiBJZiB0aGUgJEZBQlJJQ19NT0Qgc2Vzc2lvbiBmb3IgdGhlIEluaXRpYXRvciBOb2RlIEFDTCBleGlzdHMsCisJCSAqIGZvcmNlZnVsbHkgc2h1dGRvd24gdGhlICRGQUJSSUNfTU9EIHNlc3Npb24vbmV4dXMuCisJCSAqLworCQlUUEdfVEZPKHRwZyktPmNsb3NlX3Nlc3Npb24oc2Vzcyk7CisKKwkJc3Bpbl9sb2NrX2JoKCZ0cGctPnNlc3Npb25fbG9jayk7CisJfQorCXNwaW5fdW5sb2NrX2JoKCZ0cGctPnNlc3Npb25fbG9jayk7CisKKwljb3JlX3RwZ193YWl0X2Zvcl9uYWNsX3ByX3JlZihhY2wpOworCWNvcmVfdHBnX3dhaXRfZm9yX21pYl9yZWYoYWNsKTsKKwljb3JlX2NsZWFyX2luaXRpYXRvcl9ub2RlX2Zyb21fdHBnKGFjbCwgdHBnKTsKKwljb3JlX2ZyZWVfZGV2aWNlX2xpc3RfZm9yX25vZGUoYWNsLCB0cGcpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiJXNfVFBHWyVodV0gLSBEZWxldGVkIEFDTCB3aXRoIFRDUSBEZXB0aDogJWQgZm9yICVzIgorCQkiIEluaXRpYXRvciBOb2RlOiAlc1xuIiwgVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3RhZyh0cGcpLCBhY2wtPnF1ZXVlX2RlcHRoLAorCQlUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpLCBhY2wtPmluaXRpYXRvcm5hbWUpOworCisJcmV0dXJuIDA7Cit9CitFWFBPUlRfU1lNQk9MKGNvcmVfdHBnX2RlbF9pbml0aWF0b3Jfbm9kZV9hY2wpOworCisvKgljb3JlX3RwZ19zZXRfaW5pdGlhdG9yX25vZGVfcXVldWVfZGVwdGgoKToKKyAqCisgKgorICovCitpbnQgY29yZV90cGdfc2V0X2luaXRpYXRvcl9ub2RlX3F1ZXVlX2RlcHRoKAorCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZywKKwl1bnNpZ25lZCBjaGFyICppbml0aWF0b3JuYW1lLAorCXUzMiBxdWV1ZV9kZXB0aCwKKwlpbnQgZm9yY2UpCit7CisJc3RydWN0IHNlX3Nlc3Npb24gKnNlc3MsICppbml0X3Nlc3MgPSBOVUxMOworCXN0cnVjdCBzZV9ub2RlX2FjbCAqYWNsOworCWludCBkeW5hbWljX2FjbCA9IDA7CisKKwlzcGluX2xvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7CisJYWNsID0gX19jb3JlX3RwZ19nZXRfaW5pdGlhdG9yX25vZGVfYWNsKHRwZywgaW5pdGlhdG9ybmFtZSk7CisJaWYgKCEoYWNsKSkgeworCQlwcmludGsoS0VSTl9FUlIgIkFjY2VzcyBDb250cm9sIExpc3QgZW50cnkgZm9yICVzIEluaXRpYXRvciIKKwkJCSIgTm9kZSAlcyBkb2VzIG5vdCBleGlzdHMgZm9yIFRQRyAlaHUsIGlnbm9yaW5nIgorCQkJIiByZXF1ZXN0LlxuIiwgVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJCWluaXRpYXRvcm5hbWUsIFRQR19URk8odHBnKS0+dHBnX2dldF90YWcodHBnKSk7CisJCXNwaW5fdW5sb2NrX2JoKCZ0cGctPmFjbF9ub2RlX2xvY2spOworCQlyZXR1cm4gLUVOT0RFVjsKKwl9CisJaWYgKGFjbC0+ZHluYW1pY19ub2RlX2FjbCkgeworCQlhY2wtPmR5bmFtaWNfbm9kZV9hY2wgPSAwOworCQlkeW5hbWljX2FjbCA9IDE7CisJfQorCXNwaW5fdW5sb2NrX2JoKCZ0cGctPmFjbF9ub2RlX2xvY2spOworCisJc3Bpbl9sb2NrX2JoKCZ0cGctPnNlc3Npb25fbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShzZXNzLCAmdHBnLT50cGdfc2Vzc19saXN0LCBzZXNzX2xpc3QpIHsKKwkJaWYgKHNlc3MtPnNlX25vZGVfYWNsICE9IGFjbCkKKwkJCWNvbnRpbnVlOworCisJCWlmICghZm9yY2UpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGNoYW5nZSBxdWV1ZSBkZXB0aCBmb3IgJXMiCisJCQkJIiBJbml0aWF0b3IgTm9kZTogJXMgd2hpbGUgc2Vzc2lvbiBpcyIKKwkJCQkiIG9wZXJhdGlvbmFsLiAgVG8gZm9yY2VmdWxseSBjaGFuZ2UgdGhlIHF1ZXVlIgorCQkJCSIgZGVwdGggYW5kIGZvcmNlIHNlc3Npb24gcmVpbnN0YXRlbWVudCIKKwkJCQkiIHVzZSB0aGUgXCJmb3JjZT0xXCIgcGFyYW1ldGVyLlxuIiwKKwkJCQlUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpLCBpbml0aWF0b3JuYW1lKTsKKwkJCXNwaW5fdW5sb2NrX2JoKCZ0cGctPnNlc3Npb25fbG9jayk7CisKKwkJCXNwaW5fbG9ja19iaCgmdHBnLT5hY2xfbm9kZV9sb2NrKTsKKwkJCWlmIChkeW5hbWljX2FjbCkKKwkJCQlhY2wtPmR5bmFtaWNfbm9kZV9hY2wgPSAxOworCQkJc3Bpbl91bmxvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7CisJCQlyZXR1cm4gLUVFWElTVDsKKwkJfQorCQkvKgorCQkgKiBEZXRlcm1pbmUgaWYgdGhlIHNlc3Npb24gbmVlZHMgdG8gYmUgY2xvc2VkIGJ5IG91ciBjb250ZXh0LgorCQkgKi8KKwkJaWYgKCEoVFBHX1RGTyh0cGcpLT5zaHV0ZG93bl9zZXNzaW9uKHNlc3MpKSkKKwkJCWNvbnRpbnVlOworCisJCWluaXRfc2VzcyA9IHNlc3M7CisJCWJyZWFrOworCX0KKworCS8qCisJICogVXNlciBoYXMgcmVxdWVzdGVkIHRvIGNoYW5nZSB0aGUgcXVldWUgZGVwdGggZm9yIGEgSW5pdGlhdG9yIE5vZGUuCisJICogQ2hhbmdlIHRoZSB2YWx1ZSBpbiB0aGUgTm9kZSdzIHN0cnVjdCBzZV9ub2RlX2FjbCwgYW5kIGNhbGwKKwkgKiBjb3JlX3NldF9xdWV1ZV9kZXB0aF9mb3Jfbm9kZSgpIHRvIGFkZCB0aGUgcmVxdWVzdGVkIHF1ZXVlIGRlcHRoLgorCSAqCisJICogRmluYWxseSBjYWxsICBUUEdfVEZPKHRwZyktPmNsb3NlX3Nlc3Npb24oKSB0byBmb3JjZSBzZXNzaW9uCisJICogcmVpbnN0YXRlbWVudCB0byBvY2N1ciBpZiB0aGVyZSBpcyBhbiBhY3RpdmUgc2Vzc2lvbiBmb3IgdGhlCisJICogJEZBQlJJQ19NT0QgSW5pdGlhdG9yIE5vZGUgaW4gcXVlc3Rpb24uCisJICovCisJYWNsLT5xdWV1ZV9kZXB0aCA9IHF1ZXVlX2RlcHRoOworCisJaWYgKGNvcmVfc2V0X3F1ZXVlX2RlcHRoX2Zvcl9ub2RlKHRwZywgYWNsKSA8IDApIHsKKwkJc3Bpbl91bmxvY2tfYmgoJnRwZy0+c2Vzc2lvbl9sb2NrKTsKKwkJLyoKKwkJICogRm9yY2Ugc2Vzc2lvbiByZWluc3RhdGVtZW50IGlmCisJCSAqIGNvcmVfc2V0X3F1ZXVlX2RlcHRoX2Zvcl9ub2RlKCkgZmFpbGVkLCBiZWNhdXNlIHdlIGFzc3VtZQorCQkgKiB0aGUgJEZBQlJJQ19NT0QgaGFzIGFscmVhZHkgdGhlIHNldCBzZXNzaW9uIHJlaW5zdGF0ZW1lbnQKKwkJICogYml0IGZyb20gVFBHX1RGTyh0cGcpLT5zaHV0ZG93bl9zZXNzaW9uKCkgY2FsbGVkIGFib3ZlLgorCQkgKi8KKwkJaWYgKGluaXRfc2VzcykKKwkJCVRQR19URk8odHBnKS0+Y2xvc2Vfc2Vzc2lvbihpbml0X3Nlc3MpOworCisJCXNwaW5fbG9ja19iaCgmdHBnLT5hY2xfbm9kZV9sb2NrKTsKKwkJaWYgKGR5bmFtaWNfYWNsKQorCQkJYWNsLT5keW5hbWljX25vZGVfYWNsID0gMTsKKwkJc3Bpbl91bmxvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlzcGluX3VubG9ja19iaCgmdHBnLT5zZXNzaW9uX2xvY2spOworCS8qCisJICogSWYgdGhlICRGQUJSSUNfTU9EIHNlc3Npb24gZm9yIHRoZSBJbml0aWF0b3IgTm9kZSBBQ0wgZXhpc3RzLAorCSAqIGZvcmNlZnVsbHkgc2h1dGRvd24gdGhlICRGQUJSSUNfTU9EIHNlc3Npb24vbmV4dXMuCisJICovCisJaWYgKGluaXRfc2VzcykKKwkJVFBHX1RGTyh0cGcpLT5jbG9zZV9zZXNzaW9uKGluaXRfc2Vzcyk7CisKKwlwcmludGsoS0VSTl9JTkZPICJTdWNjZXNzZnVseSBjaGFuZ2VkIHF1ZXVlIGRlcHRoIHRvOiAlZCBmb3IgSW5pdGlhdG9yIgorCQkiIE5vZGU6ICVzIG9uICVzIFRhcmdldCBQb3J0YWwgR3JvdXA6ICV1XG4iLCBxdWV1ZV9kZXB0aCwKKwkJaW5pdGlhdG9ybmFtZSwgVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSwKKwkJVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3RhZyh0cGcpKTsKKworCXNwaW5fbG9ja19iaCgmdHBnLT5hY2xfbm9kZV9sb2NrKTsKKwlpZiAoZHluYW1pY19hY2wpCisJCWFjbC0+ZHluYW1pY19ub2RlX2FjbCA9IDE7CisJc3Bpbl91bmxvY2tfYmgoJnRwZy0+YWNsX25vZGVfbG9jayk7CisKKwlyZXR1cm4gMDsKK30KK0VYUE9SVF9TWU1CT0woY29yZV90cGdfc2V0X2luaXRpYXRvcl9ub2RlX3F1ZXVlX2RlcHRoKTsKKworc3RhdGljIGludCBjb3JlX3RwZ19zZXR1cF92aXJ0dWFsX2x1bjAoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnKQoreworCS8qIFNldCBpbiBjb3JlX2Rldl9zZXR1cF92aXJ0dWFsX2x1bjAoKSAqLworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IHNlX2dsb2JhbC0+Z19sdW4wX2RldjsKKwlzdHJ1Y3Qgc2VfbHVuICpsdW4gPSAmc2VfdHBnLT50cGdfdmlydF9sdW4wOworCXUzMiBsdW5fYWNjZXNzID0gVFJBTlNQT1JUX0xVTkZMQUdTX1JFQURfT05MWTsKKwlpbnQgcmV0OworCisJbHVuLT51bnBhY2tlZF9sdW4gPSAwOworCWx1bi0+bHVuX3N0YXR1cyA9IFRSQU5TUE9SVF9MVU5fU1RBVFVTX0ZSRUU7CisJYXRvbWljX3NldCgmbHVuLT5sdW5fYWNsX2NvdW50LCAwKTsKKwlpbml0X2NvbXBsZXRpb24oJmx1bi0+bHVuX3NodXRkb3duX2NvbXApOworCUlOSVRfTElTVF9IRUFEKCZsdW4tPmx1bl9hY2xfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJmx1bi0+bHVuX2NtZF9saXN0KTsKKwlzcGluX2xvY2tfaW5pdCgmbHVuLT5sdW5fYWNsX2xvY2spOworCXNwaW5fbG9ja19pbml0KCZsdW4tPmx1bl9jbWRfbG9jayk7CisJc3Bpbl9sb2NrX2luaXQoJmx1bi0+bHVuX3NlcF9sb2NrKTsKKworCXJldCA9IGNvcmVfdHBnX3Bvc3RfYWRkbHVuKHNlX3RwZywgbHVuLCBsdW5fYWNjZXNzLCBkZXYpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gLTE7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgY29yZV90cGdfcmVsZWFzZV92aXJ0dWFsX2x1bjAoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnKQoreworCXN0cnVjdCBzZV9sdW4gKmx1biA9ICZzZV90cGctPnRwZ192aXJ0X2x1bjA7CisKKwljb3JlX3RwZ19wb3N0X2RlbGx1bihzZV90cGcsIGx1bik7Cit9CisKK2ludCBjb3JlX3RwZ19yZWdpc3RlcigKKwlzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcyAqdGZvLAorCXN0cnVjdCBzZV93d24gKnNlX3d3biwKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcsCisJdm9pZCAqdHBnX2ZhYnJpY19wdHIsCisJaW50IHNlX3RwZ190eXBlKQoreworCXN0cnVjdCBzZV9sdW4gKmx1bjsKKwl1MzIgaTsKKworCXNlX3RwZy0+dHBnX2x1bl9saXN0ID0ga3phbGxvYygoc2l6ZW9mKHN0cnVjdCBzZV9sdW4pICoKKwkJCQlUUkFOU1BPUlRfTUFYX0xVTlNfUEVSX1RQRyksIEdGUF9LRVJORUwpOworCWlmICghKHNlX3RwZy0+dHBnX2x1bl9saXN0KSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwLT4iCisJCQkJInRwZ19sdW5fbGlzdFxuIik7CisJCXJldHVybiAtRU5PTUVNOworCX0KKworCWZvciAoaSA9IDA7IGkgPCBUUkFOU1BPUlRfTUFYX0xVTlNfUEVSX1RQRzsgaSsrKSB7CisJCWx1biA9ICZzZV90cGctPnRwZ19sdW5fbGlzdFtpXTsKKwkJbHVuLT51bnBhY2tlZF9sdW4gPSBpOworCQlsdW4tPmx1bl9zdGF0dXMgPSBUUkFOU1BPUlRfTFVOX1NUQVRVU19GUkVFOworCQlhdG9taWNfc2V0KCZsdW4tPmx1bl9hY2xfY291bnQsIDApOworCQlpbml0X2NvbXBsZXRpb24oJmx1bi0+bHVuX3NodXRkb3duX2NvbXApOworCQlJTklUX0xJU1RfSEVBRCgmbHVuLT5sdW5fYWNsX2xpc3QpOworCQlJTklUX0xJU1RfSEVBRCgmbHVuLT5sdW5fY21kX2xpc3QpOworCQlzcGluX2xvY2tfaW5pdCgmbHVuLT5sdW5fYWNsX2xvY2spOworCQlzcGluX2xvY2tfaW5pdCgmbHVuLT5sdW5fY21kX2xvY2spOworCQlzcGluX2xvY2tfaW5pdCgmbHVuLT5sdW5fc2VwX2xvY2spOworCX0KKworCXNlX3RwZy0+c2VfdHBnX3R5cGUgPSBzZV90cGdfdHlwZTsKKwlzZV90cGctPnNlX3RwZ19mYWJyaWNfcHRyID0gdHBnX2ZhYnJpY19wdHI7CisJc2VfdHBnLT5zZV90cGdfdGZvID0gdGZvOworCXNlX3RwZy0+c2VfdHBnX3d3biA9IHNlX3d3bjsKKwlhdG9taWNfc2V0KCZzZV90cGctPnRwZ19wcl9yZWZfY291bnQsIDApOworCUlOSVRfTElTVF9IRUFEKCZzZV90cGctPmFjbF9ub2RlX2xpc3QpOworCUlOSVRfTElTVF9IRUFEKCZzZV90cGctPnNlX3RwZ19saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmc2VfdHBnLT50cGdfc2Vzc19saXN0KTsKKwlzcGluX2xvY2tfaW5pdCgmc2VfdHBnLT5hY2xfbm9kZV9sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmc2VfdHBnLT5zZXNzaW9uX2xvY2spOworCXNwaW5fbG9ja19pbml0KCZzZV90cGctPnRwZ19sdW5fbG9jayk7CisKKwlpZiAoc2VfdHBnLT5zZV90cGdfdHlwZSA9PSBUUkFOU1BPUlRfVFBHX1RZUEVfTk9STUFMKSB7CisJCWlmIChjb3JlX3RwZ19zZXR1cF92aXJ0dWFsX2x1bjAoc2VfdHBnKSA8IDApIHsKKwkJCWtmcmVlKHNlX3RwZyk7CisJCQlyZXR1cm4gLUVOT01FTTsKKwkJfQorCX0KKworCXNwaW5fbG9ja19iaCgmc2VfZ2xvYmFsLT5zZV90cGdfbG9jayk7CisJbGlzdF9hZGRfdGFpbCgmc2VfdHBnLT5zZV90cGdfbGlzdCwgJnNlX2dsb2JhbC0+Z19zZV90cGdfbGlzdCk7CisJc3Bpbl91bmxvY2tfYmgoJnNlX2dsb2JhbC0+c2VfdHBnX2xvY2spOworCisJcHJpbnRrKEtFUk5fSU5GTyAiVEFSR0VUX0NPUkVbJXNdOiBBbGxvY2F0ZWQgJXMgc3RydWN0IHNlX3BvcnRhbF9ncm91cCBmb3IiCisJCSIgZW5kcG9pbnQ6ICVzLCBQb3J0YWwgVGFnOiAldVxuIiwgdGZvLT5nZXRfZmFicmljX25hbWUoKSwKKwkJKHNlX3RwZy0+c2VfdHBnX3R5cGUgPT0gVFJBTlNQT1JUX1RQR19UWVBFX05PUk1BTCkgPworCQkiTm9ybWFsIiA6ICJEaXNjb3ZlcnkiLCAodGZvLT50cGdfZ2V0X3d3bihzZV90cGcpID09IE5VTEwpID8KKwkJIk5vbmUiIDogdGZvLT50cGdfZ2V0X3d3bihzZV90cGcpLCB0Zm8tPnRwZ19nZXRfdGFnKHNlX3RwZykpOworCisJcmV0dXJuIDA7Cit9CitFWFBPUlRfU1lNQk9MKGNvcmVfdHBnX3JlZ2lzdGVyKTsKKworaW50IGNvcmVfdHBnX2RlcmVnaXN0ZXIoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnKQoreworCXByaW50ayhLRVJOX0lORk8gIlRBUkdFVF9DT1JFWyVzXTogRGVhbGxvY2F0aW5nICVzIHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAiCisJCSIgZm9yIGVuZHBvaW50OiAlcyBQb3J0YWwgVGFnICV1XG4iLAorCQkoc2VfdHBnLT5zZV90cGdfdHlwZSA9PSBUUkFOU1BPUlRfVFBHX1RZUEVfTk9STUFMKSA/CisJCSJOb3JtYWwiIDogIkRpc2NvdmVyeSIsIFRQR19URk8oc2VfdHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCVRQR19URk8oc2VfdHBnKS0+dHBnX2dldF93d24oc2VfdHBnKSwKKwkJVFBHX1RGTyhzZV90cGcpLT50cGdfZ2V0X3RhZyhzZV90cGcpKTsKKworCXNwaW5fbG9ja19iaCgmc2VfZ2xvYmFsLT5zZV90cGdfbG9jayk7CisJbGlzdF9kZWwoJnNlX3RwZy0+c2VfdHBnX2xpc3QpOworCXNwaW5fdW5sb2NrX2JoKCZzZV9nbG9iYWwtPnNlX3RwZ19sb2NrKTsKKworCXdoaWxlIChhdG9taWNfcmVhZCgmc2VfdHBnLT50cGdfcHJfcmVmX2NvdW50KSAhPSAwKQorCQljcHVfcmVsYXgoKTsKKworCWlmIChzZV90cGctPnNlX3RwZ190eXBlID09IFRSQU5TUE9SVF9UUEdfVFlQRV9OT1JNQUwpCisJCWNvcmVfdHBnX3JlbGVhc2VfdmlydHVhbF9sdW4wKHNlX3RwZyk7CisKKwlzZV90cGctPnNlX3RwZ19mYWJyaWNfcHRyID0gTlVMTDsKKwlrZnJlZShzZV90cGctPnRwZ19sdW5fbGlzdCk7CisJcmV0dXJuIDA7Cit9CitFWFBPUlRfU1lNQk9MKGNvcmVfdHBnX2RlcmVnaXN0ZXIpOworCitzdHJ1Y3Qgc2VfbHVuICpjb3JlX3RwZ19wcmVfYWRkbHVuKAorCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnRwZywKKwl1MzIgdW5wYWNrZWRfbHVuKQoreworCXN0cnVjdCBzZV9sdW4gKmx1bjsKKworCWlmICh1bnBhY2tlZF9sdW4gPiAoVFJBTlNQT1JUX01BWF9MVU5TX1BFUl9UUEctMSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICIlcyBMVU46ICV1IGV4Y2VlZHMgVFJBTlNQT1JUX01BWF9MVU5TX1BFUl9UUEciCisJCQkiLTE6ICV1IGZvciBUYXJnZXQgUG9ydGFsIEdyb3VwOiAldVxuIiwKKwkJCVRQR19URk8odHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCQl1bnBhY2tlZF9sdW4sIFRSQU5TUE9SVF9NQVhfTFVOU19QRVJfVFBHLTEsCisJCQlUUEdfVEZPKHRwZyktPnRwZ19nZXRfdGFnKHRwZykpOworCQlyZXR1cm4gRVJSX1BUUigtRU9WRVJGTE9XKTsKKwl9CisKKwlzcGluX2xvY2soJnRwZy0+dHBnX2x1bl9sb2NrKTsKKwlsdW4gPSAmdHBnLT50cGdfbHVuX2xpc3RbdW5wYWNrZWRfbHVuXTsKKwlpZiAobHVuLT5sdW5fc3RhdHVzID09IFRSQU5TUE9SVF9MVU5fU1RBVFVTX0FDVElWRSkgeworCQlwcmludGsoS0VSTl9FUlIgIlRQRyBMb2dpY2FsIFVuaXQgTnVtYmVyOiAldSBpcyBhbHJlYWR5IGFjdGl2ZSIKKwkJCSIgb24gJXMgVGFyZ2V0IFBvcnRhbCBHcm91cDogJXUsIGlnbm9yaW5nIHJlcXVlc3QuXG4iLAorCQkJdW5wYWNrZWRfbHVuLCBUUEdfVEZPKHRwZyktPmdldF9mYWJyaWNfbmFtZSgpLAorCQkJVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3RhZyh0cGcpKTsKKwkJc3Bpbl91bmxvY2soJnRwZy0+dHBnX2x1bl9sb2NrKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisJfQorCXNwaW5fdW5sb2NrKCZ0cGctPnRwZ19sdW5fbG9jayk7CisKKwlyZXR1cm4gbHVuOworfQorCitpbnQgY29yZV90cGdfcG9zdF9hZGRsdW4oCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnLAorCXN0cnVjdCBzZV9sdW4gKmx1biwKKwl1MzIgbHVuX2FjY2VzcywKKwl2b2lkICpsdW5fcHRyKQoreworCWlmIChjb3JlX2Rldl9leHBvcnQobHVuX3B0ciwgdHBnLCBsdW4pIDwgMCkKKwkJcmV0dXJuIC0xOworCisJc3Bpbl9sb2NrKCZ0cGctPnRwZ19sdW5fbG9jayk7CisJbHVuLT5sdW5fYWNjZXNzID0gbHVuX2FjY2VzczsKKwlsdW4tPmx1bl9zdGF0dXMgPSBUUkFOU1BPUlRfTFVOX1NUQVRVU19BQ1RJVkU7CisJc3Bpbl91bmxvY2soJnRwZy0+dHBnX2x1bl9sb2NrKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBjb3JlX3RwZ19zaHV0ZG93bl9sdW4oCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnLAorCXN0cnVjdCBzZV9sdW4gKmx1bikKK3sKKwljb3JlX2NsZWFyX2x1bl9mcm9tX3RwZyhsdW4sIHRwZyk7CisJdHJhbnNwb3J0X2NsZWFyX2x1bl9mcm9tX3Nlc3Npb25zKGx1bik7Cit9CisKK3N0cnVjdCBzZV9sdW4gKmNvcmVfdHBnX3ByZV9kZWxsdW4oCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnLAorCXUzMiB1bnBhY2tlZF9sdW4sCisJaW50ICpyZXQpCit7CisJc3RydWN0IHNlX2x1biAqbHVuOworCisJaWYgKHVucGFja2VkX2x1biA+IChUUkFOU1BPUlRfTUFYX0xVTlNfUEVSX1RQRy0xKSkgeworCQlwcmludGsoS0VSTl9FUlIgIiVzIExVTjogJXUgZXhjZWVkcyBUUkFOU1BPUlRfTUFYX0xVTlNfUEVSX1RQRyIKKwkJCSItMTogJXUgZm9yIFRhcmdldCBQb3J0YWwgR3JvdXA6ICV1XG4iLAorCQkJVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSwgdW5wYWNrZWRfbHVuLAorCQkJVFJBTlNQT1JUX01BWF9MVU5TX1BFUl9UUEctMSwKKwkJCVRQR19URk8odHBnKS0+dHBnX2dldF90YWcodHBnKSk7CisJCXJldHVybiBFUlJfUFRSKC1FT1ZFUkZMT1cpOworCX0KKworCXNwaW5fbG9jaygmdHBnLT50cGdfbHVuX2xvY2spOworCWx1biA9ICZ0cGctPnRwZ19sdW5fbGlzdFt1bnBhY2tlZF9sdW5dOworCWlmIChsdW4tPmx1bl9zdGF0dXMgIT0gVFJBTlNQT1JUX0xVTl9TVEFUVVNfQUNUSVZFKSB7CisJCXByaW50ayhLRVJOX0VSUiAiJXMgTG9naWNhbCBVbml0IE51bWJlcjogJXUgaXMgbm90IGFjdGl2ZSBvbiIKKwkJCSIgVGFyZ2V0IFBvcnRhbCBHcm91cDogJXUsIGlnbm9yaW5nIHJlcXVlc3QuXG4iLAorCQkJVFBHX1RGTyh0cGcpLT5nZXRfZmFicmljX25hbWUoKSwgdW5wYWNrZWRfbHVuLAorCQkJVFBHX1RGTyh0cGcpLT50cGdfZ2V0X3RhZyh0cGcpKTsKKwkJc3Bpbl91bmxvY2soJnRwZy0+dHBnX2x1bl9sb2NrKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT0RFVik7CisJfQorCXNwaW5fdW5sb2NrKCZ0cGctPnRwZ19sdW5fbG9jayk7CisKKwlyZXR1cm4gbHVuOworfQorCitpbnQgY29yZV90cGdfcG9zdF9kZWxsdW4oCisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqdHBnLAorCXN0cnVjdCBzZV9sdW4gKmx1bikKK3sKKwljb3JlX3RwZ19zaHV0ZG93bl9sdW4odHBnLCBsdW4pOworCisJY29yZV9kZXZfdW5leHBvcnQobHVuLT5sdW5fc2VfZGV2LCB0cGcsIGx1bik7CisKKwlzcGluX2xvY2soJnRwZy0+dHBnX2x1bl9sb2NrKTsKKwlsdW4tPmx1bl9zdGF0dXMgPSBUUkFOU1BPUlRfTFVOX1NUQVRVU19GUkVFOworCXNwaW5fdW5sb2NrKCZ0cGctPnRwZ19sdW5fbG9jayk7CisKKwlyZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX3RyYW5zcG9ydC5jIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfdHJhbnNwb3J0LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjhiNjI5MmZmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfdHJhbnNwb3J0LmMKQEAgLTAsMCArMSw2MTM0IEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogRmlsZW5hbWU6ICB0YXJnZXRfY29yZV90cmFuc3BvcnQuYworICoKKyAqIFRoaXMgZmlsZSBjb250YWlucyB0aGUgR2VuZXJpYyBUYXJnZXQgRW5naW5lIENvcmUuCisgKgorICogQ29weXJpZ2h0IChjKSAyMDAyLCAyMDAzLCAyMDA0LCAyMDA1IFB5WCBUZWNobm9sb2dpZXMsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAwNSwgMjAwNiwgMjAwNyBTQkUsIEluYy4KKyAqIENvcHlyaWdodCAoYykgMjAwNy0yMDEwIFJpc2luZyBUaWRlIFN5c3RlbXMKKyAqIENvcHlyaWdodCAoYykgMjAwOC0yMDEwIExpbnV4LWlTQ1NJLm9yZworICoKKyAqIE5pY2hvbGFzIEEuIEJlbGxpbmdlciA8bmFiQGtlcm5lbC5vcmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisjaW5jbHVkZSA8bGludXgvdmVyc2lvbi5oPgorI2luY2x1ZGUgPGxpbnV4L25ldC5oPgorI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CisjaW5jbHVkZSA8bGludXgvdGltZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvYmxrZGV2Lmg+CisjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KKyNpbmNsdWRlIDxsaW51eC9zbXBfbG9jay5oPgorI2luY2x1ZGUgPGxpbnV4L2t0aHJlYWQuaD4KKyNpbmNsdWRlIDxsaW51eC9pbi5oPgorI2luY2x1ZGUgPGxpbnV4L2Nkcm9tLmg+CisjaW5jbHVkZSA8YXNtL3VuYWxpZ25lZC5oPgorI2luY2x1ZGUgPG5ldC9zb2NrLmg+CisjaW5jbHVkZSA8bmV0L3RjcC5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaS5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV9jbW5kLmg+CisjaW5jbHVkZSA8c2NzaS9saWJzYXMuaD4gLyogRm9yIFRBU0tfQVRUUl8qICovCisKKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfYmFzZS5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdG1yLmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX3RwZy5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV90cmFuc3BvcnQuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX29wcy5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9jb25maWdmcy5oPgorCisjaW5jbHVkZSAidGFyZ2V0X2NvcmVfYWx1YS5oIgorI2luY2x1ZGUgInRhcmdldF9jb3JlX2hiYS5oIgorI2luY2x1ZGUgInRhcmdldF9jb3JlX3ByLmgiCisjaW5jbHVkZSAidGFyZ2V0X2NvcmVfc2NkYi5oIgorI2luY2x1ZGUgInRhcmdldF9jb3JlX3VhLmgiCisKKy8qICNkZWZpbmUgREVCVUdfQ0RCX0hBTkRMRVIgKi8KKyNpZmRlZiBERUJVR19DREJfSEFORExFUgorI2RlZmluZSBERUJVR19DREJfSCh4Li4uKSBwcmludGsoS0VSTl9JTkZPIHgpCisjZWxzZQorI2RlZmluZSBERUJVR19DREJfSCh4Li4uKQorI2VuZGlmCisKKy8qICNkZWZpbmUgREVCVUdfQ01EX01BUCAqLworI2lmZGVmIERFQlVHX0NNRF9NQVAKKyNkZWZpbmUgREVCVUdfQ01EX00oeC4uLikgcHJpbnRrKEtFUk5fSU5GTyB4KQorI2Vsc2UKKyNkZWZpbmUgREVCVUdfQ01EX00oeC4uLikKKyNlbmRpZgorCisvKiAjZGVmaW5lIERFQlVHX01FTV9BTExPQyAqLworI2lmZGVmIERFQlVHX01FTV9BTExPQworI2RlZmluZSBERUJVR19NRU0oeC4uLikgcHJpbnRrKEtFUk5fSU5GTyB4KQorI2Vsc2UKKyNkZWZpbmUgREVCVUdfTUVNKHguLi4pCisjZW5kaWYKKworLyogI2RlZmluZSBERUJVR19NRU0yX0FMTE9DICovCisjaWZkZWYgREVCVUdfTUVNMl9BTExPQworI2RlZmluZSBERUJVR19NRU0yKHguLi4pIHByaW50ayhLRVJOX0lORk8geCkKKyNlbHNlCisjZGVmaW5lIERFQlVHX01FTTIoeC4uLikKKyNlbmRpZgorCisvKiAjZGVmaW5lIERFQlVHX1NHX0NBTEMgKi8KKyNpZmRlZiBERUJVR19TR19DQUxDCisjZGVmaW5lIERFQlVHX1NDKHguLi4pIHByaW50ayhLRVJOX0lORk8geCkKKyNlbHNlCisjZGVmaW5lIERFQlVHX1NDKHguLi4pCisjZW5kaWYKKworLyogI2RlZmluZSBERUJVR19TRV9PQkogKi8KKyNpZmRlZiBERUJVR19TRV9PQkoKKyNkZWZpbmUgREVCVUdfU08oeC4uLikgcHJpbnRrKEtFUk5fSU5GTyB4KQorI2Vsc2UKKyNkZWZpbmUgREVCVUdfU08oeC4uLikKKyNlbmRpZgorCisvKiAjZGVmaW5lIERFQlVHX0NNRF9WT0wgKi8KKyNpZmRlZiBERUJVR19DTURfVk9MCisjZGVmaW5lIERFQlVHX1ZPTCh4Li4uKSBwcmludGsoS0VSTl9JTkZPIHgpCisjZWxzZQorI2RlZmluZSBERUJVR19WT0woeC4uLikKKyNlbmRpZgorCisvKiAjZGVmaW5lIERFQlVHX0NNRF9TVE9QICovCisjaWZkZWYgREVCVUdfQ01EX1NUT1AKKyNkZWZpbmUgREVCVUdfQ1MoeC4uLikgcHJpbnRrKEtFUk5fSU5GTyB4KQorI2Vsc2UKKyNkZWZpbmUgREVCVUdfQ1MoeC4uLikKKyNlbmRpZgorCisvKiAjZGVmaW5lIERFQlVHX1BBU1NUSFJPVUdIICovCisjaWZkZWYgREVCVUdfUEFTU1RIUk9VR0gKKyNkZWZpbmUgREVCVUdfUFQoeC4uLikgcHJpbnRrKEtFUk5fSU5GTyB4KQorI2Vsc2UKKyNkZWZpbmUgREVCVUdfUFQoeC4uLikKKyNlbmRpZgorCisvKiAjZGVmaW5lIERFQlVHX1RBU0tfU1RPUCAqLworI2lmZGVmIERFQlVHX1RBU0tfU1RPUAorI2RlZmluZSBERUJVR19UUyh4Li4uKSBwcmludGsoS0VSTl9JTkZPIHgpCisjZWxzZQorI2RlZmluZSBERUJVR19UUyh4Li4uKQorI2VuZGlmCisKKy8qICNkZWZpbmUgREVCVUdfVFJBTlNQT1JUX1NUT1AgKi8KKyNpZmRlZiBERUJVR19UUkFOU1BPUlRfU1RPUAorI2RlZmluZSBERUJVR19UUkFOU1BPUlRfUyh4Li4uKSBwcmludGsoS0VSTl9JTkZPIHgpCisjZWxzZQorI2RlZmluZSBERUJVR19UUkFOU1BPUlRfUyh4Li4uKQorI2VuZGlmCisKKy8qICNkZWZpbmUgREVCVUdfVEFTS19GQUlMVVJFICovCisjaWZkZWYgREVCVUdfVEFTS19GQUlMVVJFCisjZGVmaW5lIERFQlVHX1RGKHguLi4pIHByaW50ayhLRVJOX0lORk8geCkKKyNlbHNlCisjZGVmaW5lIERFQlVHX1RGKHguLi4pCisjZW5kaWYKKworLyogI2RlZmluZSBERUJVR19ERVZfT0ZGTElORSAqLworI2lmZGVmIERFQlVHX0RFVl9PRkZMSU5FCisjZGVmaW5lIERFQlVHX0RPKHguLi4pIHByaW50ayhLRVJOX0lORk8geCkKKyNlbHNlCisjZGVmaW5lIERFQlVHX0RPKHguLi4pCisjZW5kaWYKKworLyogI2RlZmluZSBERUJVR19UQVNLX1NUQVRFICovCisjaWZkZWYgREVCVUdfVEFTS19TVEFURQorI2RlZmluZSBERUJVR19UU1RBVEUoeC4uLikgcHJpbnRrKEtFUk5fSU5GTyB4KQorI2Vsc2UKKyNkZWZpbmUgREVCVUdfVFNUQVRFKHguLi4pCisjZW5kaWYKKworLyogI2RlZmluZSBERUJVR19TVEFUVVNfVEhSICovCisjaWZkZWYgREVCVUdfU1RBVFVTX1RIUgorI2RlZmluZSBERUJVR19TVCh4Li4uKSBwcmludGsoS0VSTl9JTkZPIHgpCisjZWxzZQorI2RlZmluZSBERUJVR19TVCh4Li4uKQorI2VuZGlmCisKKy8qICNkZWZpbmUgREVCVUdfVEFTS19USU1FT1VUICovCisjaWZkZWYgREVCVUdfVEFTS19USU1FT1VUCisjZGVmaW5lIERFQlVHX1RUKHguLi4pIHByaW50ayhLRVJOX0lORk8geCkKKyNlbHNlCisjZGVmaW5lIERFQlVHX1RUKHguLi4pCisjZW5kaWYKKworLyogI2RlZmluZSBERUJVR19HRU5FUklDX1JFUVVFU1RfRkFJTFVSRSAqLworI2lmZGVmIERFQlVHX0dFTkVSSUNfUkVRVUVTVF9GQUlMVVJFCisjZGVmaW5lIERFQlVHX0dSRih4Li4uKSBwcmludGsoS0VSTl9JTkZPIHgpCisjZWxzZQorI2RlZmluZSBERUJVR19HUkYoeC4uLikKKyNlbmRpZgorCisvKiAjZGVmaW5lIERFQlVHX1NBTV9UQVNLX0FUVFJTICovCisjaWZkZWYgREVCVUdfU0FNX1RBU0tfQVRUUlMKKyNkZWZpbmUgREVCVUdfU1RBKHguLi4pIHByaW50ayhLRVJOX0lORk8geCkKKyNlbHNlCisjZGVmaW5lIERFQlVHX1NUQSh4Li4uKQorI2VuZGlmCisKK3N0cnVjdCBzZV9nbG9iYWwgKnNlX2dsb2JhbDsKKworc3RhdGljIHN0cnVjdCBrbWVtX2NhY2hlICpzZV9jbWRfY2FjaGU7CitzdGF0aWMgc3RydWN0IGttZW1fY2FjaGUgKnNlX3Nlc3NfY2FjaGU7CitzdHJ1Y3Qga21lbV9jYWNoZSAqc2VfdG1yX3JlcV9jYWNoZTsKK3N0cnVjdCBrbWVtX2NhY2hlICpzZV91YV9jYWNoZTsKK3N0cnVjdCBrbWVtX2NhY2hlICpzZV9tZW1fY2FjaGU7CitzdHJ1Y3Qga21lbV9jYWNoZSAqdDEwX3ByX3JlZ19jYWNoZTsKK3N0cnVjdCBrbWVtX2NhY2hlICp0MTBfYWx1YV9sdV9ncF9jYWNoZTsKK3N0cnVjdCBrbWVtX2NhY2hlICp0MTBfYWx1YV9sdV9ncF9tZW1fY2FjaGU7CitzdHJ1Y3Qga21lbV9jYWNoZSAqdDEwX2FsdWFfdGdfcHRfZ3BfY2FjaGU7CitzdHJ1Y3Qga21lbV9jYWNoZSAqdDEwX2FsdWFfdGdfcHRfZ3BfbWVtX2NhY2hlOworCisvKiBVc2VkIGZvciB0cmFuc3BvcnRfZGV2X2dldF9tYXBfKigpICovCit0eXBlZGVmIGludCAoKm1hcF9mdW5jX3QpKHN0cnVjdCBzZV90YXNrICosIHUzMik7CisKK3N0YXRpYyBpbnQgdHJhbnNwb3J0X2dlbmVyaWNfd3JpdGVfcGVuZGluZyhzdHJ1Y3Qgc2VfY21kICopOworc3RhdGljIGludCB0cmFuc3BvcnRfcHJvY2Vzc2luZ190aHJlYWQodm9pZCAqKTsKK3N0YXRpYyBpbnQgX190cmFuc3BvcnRfZXhlY3V0ZV90YXNrcyhzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpOworc3RhdGljIHZvaWQgdHJhbnNwb3J0X2NvbXBsZXRlX3Rhc2tfYXR0cihzdHJ1Y3Qgc2VfY21kICpjbWQpOworc3RhdGljIHZvaWQgdHJhbnNwb3J0X2RpcmVjdF9yZXF1ZXN0X3RpbWVvdXQoc3RydWN0IHNlX2NtZCAqY21kKTsKK3N0YXRpYyB2b2lkIHRyYW5zcG9ydF9mcmVlX2Rldl90YXNrcyhzdHJ1Y3Qgc2VfY21kICpjbWQpOworc3RhdGljIHUzMiB0cmFuc3BvcnRfZ2VuZXJpY19nZXRfY2RiX2NvdW50KHN0cnVjdCBzZV9jbWQgKmNtZCwKKwkJdW5zaWduZWQgbG9uZyBsb25nIHN0YXJ0aW5nX2xiYSwgdTMyIHNlY3RvcnMsCisJCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRhdGFfZGlyZWN0aW9uLAorCQlzdHJ1Y3QgbGlzdF9oZWFkICptZW1fbGlzdCwgaW50IHNldF9jb3VudHMpOworc3RhdGljIGludCB0cmFuc3BvcnRfZ2VuZXJpY19nZXRfbWVtKHN0cnVjdCBzZV9jbWQgKmNtZCwgdTMyIGxlbmd0aCwKKwkJdTMyIGRtYV9zaXplKTsKK3N0YXRpYyBpbnQgdHJhbnNwb3J0X2dlbmVyaWNfcmVtb3ZlKHN0cnVjdCBzZV9jbWQgKmNtZCwKKwkJaW50IHJlbGVhc2VfdG9fcG9vbCwgaW50IHNlc3Npb25fcmVpbnN0YXRlbWVudCk7CitzdGF0aWMgaW50IHRyYW5zcG9ydF9nZXRfc2VjdG9ycyhzdHJ1Y3Qgc2VfY21kICpjbWQpOworc3RhdGljIHN0cnVjdCBsaXN0X2hlYWQgKnRyYW5zcG9ydF9pbml0X3NlX21lbV9saXN0KHZvaWQpOworc3RhdGljIGludCB0cmFuc3BvcnRfbWFwX3NnX3RvX21lbShzdHJ1Y3Qgc2VfY21kICpjbWQsCisJCXN0cnVjdCBsaXN0X2hlYWQgKnNlX21lbV9saXN0LCB2b2lkICppbl9tZW0sCisJCXUzMiAqc2VfbWVtX2NudCk7CitzdGF0aWMgdm9pZCB0cmFuc3BvcnRfbWVtY3B5X3NlX21lbV9yZWFkX2NvbnRpZyhzdHJ1Y3Qgc2VfY21kICpjbWQsCisJCXVuc2lnbmVkIGNoYXIgKmRzdCwgc3RydWN0IGxpc3RfaGVhZCAqc2VfbWVtX2xpc3QpOworc3RhdGljIHZvaWQgdHJhbnNwb3J0X3JlbGVhc2VfZmVfY21kKHN0cnVjdCBzZV9jbWQgKmNtZCk7CitzdGF0aWMgdm9pZCB0cmFuc3BvcnRfcmVtb3ZlX2NtZF9mcm9tX3F1ZXVlKHN0cnVjdCBzZV9jbWQgKmNtZCwKKwkJc3RydWN0IHNlX3F1ZXVlX29iaiAqcW9iaik7CitzdGF0aWMgaW50IHRyYW5zcG9ydF9zZXRfc2Vuc2VfY29kZXMoc3RydWN0IHNlX2NtZCAqY21kLCB1OCBhc2MsIHU4IGFzY3EpOworc3RhdGljIHZvaWQgdHJhbnNwb3J0X3N0b3BfYWxsX3Rhc2tfdGltZXJzKHN0cnVjdCBzZV9jbWQgKmNtZCk7CisKK2ludCB0cmFuc3BvcnRfZW11bGF0ZV9jb250cm9sX2NkYihzdHJ1Y3Qgc2VfdGFzayAqdGFzayk7CisKK2ludCBpbml0X3NlX2dsb2JhbCh2b2lkKQoreworCXN0cnVjdCBzZV9nbG9iYWwgKmdsb2JhbDsKKworCWdsb2JhbCA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBzZV9nbG9iYWwpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIShnbG9iYWwpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIG1lbW9yeSBmb3Igc3RydWN0IHNlX2dsb2JhbFxuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwlJTklUX0xJU1RfSEVBRCgmZ2xvYmFsLT5nX2x1X2dwc19saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmZ2xvYmFsLT5nX3NlX3RwZ19saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmZ2xvYmFsLT5nX2hiYV9saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmZ2xvYmFsLT5nX3NlX2Rldl9saXN0KTsKKwlzcGluX2xvY2tfaW5pdCgmZ2xvYmFsLT5nX2RldmljZV9sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmZ2xvYmFsLT5oYmFfbG9jayk7CisJc3Bpbl9sb2NrX2luaXQoJmdsb2JhbC0+c2VfdHBnX2xvY2spOworCXNwaW5fbG9ja19pbml0KCZnbG9iYWwtPmx1X2dwc19sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmZ2xvYmFsLT5wbHVnaW5fY2xhc3NfbG9jayk7CisKKwlzZV9jbWRfY2FjaGUgPSBrbWVtX2NhY2hlX2NyZWF0ZSgic2VfY21kX2NhY2hlIiwKKwkJCXNpemVvZihzdHJ1Y3Qgc2VfY21kKSwgX19hbGlnbm9mX18oc3RydWN0IHNlX2NtZCksIDAsIE5VTEwpOworCWlmICghKHNlX2NtZF9jYWNoZSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJrbWVtX2NhY2hlX2NyZWF0ZSBmb3Igc3RydWN0IHNlX2NtZCBmYWlsZWRcbiIpOworCQlnb3RvIG91dDsKKwl9CisJc2VfdG1yX3JlcV9jYWNoZSA9IGttZW1fY2FjaGVfY3JlYXRlKCJzZV90bXJfY2FjaGUiLAorCQkJc2l6ZW9mKHN0cnVjdCBzZV90bXJfcmVxKSwgX19hbGlnbm9mX18oc3RydWN0IHNlX3Rtcl9yZXEpLAorCQkJMCwgTlVMTCk7CisJaWYgKCEoc2VfdG1yX3JlcV9jYWNoZSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJrbWVtX2NhY2hlX2NyZWF0ZSgpIGZvciBzdHJ1Y3Qgc2VfdG1yX3JlcSIKKwkJCQkiIGZhaWxlZFxuIik7CisJCWdvdG8gb3V0OworCX0KKwlzZV9zZXNzX2NhY2hlID0ga21lbV9jYWNoZV9jcmVhdGUoInNlX3Nlc3NfY2FjaGUiLAorCQkJc2l6ZW9mKHN0cnVjdCBzZV9zZXNzaW9uKSwgX19hbGlnbm9mX18oc3RydWN0IHNlX3Nlc3Npb24pLAorCQkJMCwgTlVMTCk7CisJaWYgKCEoc2Vfc2Vzc19jYWNoZSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJrbWVtX2NhY2hlX2NyZWF0ZSgpIGZvciBzdHJ1Y3Qgc2Vfc2Vzc2lvbiIKKwkJCQkiIGZhaWxlZFxuIik7CisJCWdvdG8gb3V0OworCX0KKwlzZV91YV9jYWNoZSA9IGttZW1fY2FjaGVfY3JlYXRlKCJzZV91YV9jYWNoZSIsCisJCQlzaXplb2Yoc3RydWN0IHNlX3VhKSwgX19hbGlnbm9mX18oc3RydWN0IHNlX3VhKSwKKwkJCTAsIE5VTEwpOworCWlmICghKHNlX3VhX2NhY2hlKSkgeworCQlwcmludGsoS0VSTl9FUlIgImttZW1fY2FjaGVfY3JlYXRlKCkgZm9yIHN0cnVjdCBzZV91YSBmYWlsZWRcbiIpOworCQlnb3RvIG91dDsKKwl9CisJc2VfbWVtX2NhY2hlID0ga21lbV9jYWNoZV9jcmVhdGUoInNlX21lbV9jYWNoZSIsCisJCQlzaXplb2Yoc3RydWN0IHNlX21lbSksIF9fYWxpZ25vZl9fKHN0cnVjdCBzZV9tZW0pLCAwLCBOVUxMKTsKKwlpZiAoIShzZV9tZW1fY2FjaGUpKSB7CisJCXByaW50ayhLRVJOX0VSUiAia21lbV9jYWNoZV9jcmVhdGUoKSBmb3Igc3RydWN0IHNlX21lbSBmYWlsZWRcbiIpOworCQlnb3RvIG91dDsKKwl9CisJdDEwX3ByX3JlZ19jYWNoZSA9IGttZW1fY2FjaGVfY3JlYXRlKCJ0MTBfcHJfcmVnX2NhY2hlIiwKKwkJCXNpemVvZihzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiksCisJCQlfX2FsaWdub2ZfXyhzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiksIDAsIE5VTEwpOworCWlmICghKHQxMF9wcl9yZWdfY2FjaGUpKSB7CisJCXByaW50ayhLRVJOX0VSUiAia21lbV9jYWNoZV9jcmVhdGUoKSBmb3Igc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24iCisJCQkJIiBmYWlsZWRcbiIpOworCQlnb3RvIG91dDsKKwl9CisJdDEwX2FsdWFfbHVfZ3BfY2FjaGUgPSBrbWVtX2NhY2hlX2NyZWF0ZSgidDEwX2FsdWFfbHVfZ3BfY2FjaGUiLAorCQkJc2l6ZW9mKHN0cnVjdCB0MTBfYWx1YV9sdV9ncCksIF9fYWxpZ25vZl9fKHN0cnVjdCB0MTBfYWx1YV9sdV9ncCksCisJCQkwLCBOVUxMKTsKKwlpZiAoISh0MTBfYWx1YV9sdV9ncF9jYWNoZSkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJrbWVtX2NhY2hlX2NyZWF0ZSgpIGZvciB0MTBfYWx1YV9sdV9ncF9jYWNoZSIKKwkJCQkiIGZhaWxlZFxuIik7CisJCWdvdG8gb3V0OworCX0KKwl0MTBfYWx1YV9sdV9ncF9tZW1fY2FjaGUgPSBrbWVtX2NhY2hlX2NyZWF0ZSgidDEwX2FsdWFfbHVfZ3BfbWVtX2NhY2hlIiwKKwkJCXNpemVvZihzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3BfbWVtYmVyKSwKKwkJCV9fYWxpZ25vZl9fKHN0cnVjdCB0MTBfYWx1YV9sdV9ncF9tZW1iZXIpLCAwLCBOVUxMKTsKKwlpZiAoISh0MTBfYWx1YV9sdV9ncF9tZW1fY2FjaGUpKSB7CisJCXByaW50ayhLRVJOX0VSUiAia21lbV9jYWNoZV9jcmVhdGUoKSBmb3IgdDEwX2FsdWFfbHVfZ3BfbWVtXyIKKwkJCQkiY2FjaGUgZmFpbGVkXG4iKTsKKwkJZ290byBvdXQ7CisJfQorCXQxMF9hbHVhX3RnX3B0X2dwX2NhY2hlID0ga21lbV9jYWNoZV9jcmVhdGUoInQxMF9hbHVhX3RnX3B0X2dwX2NhY2hlIiwKKwkJCXNpemVvZihzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3ApLAorCQkJX19hbGlnbm9mX18oc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwKSwgMCwgTlVMTCk7CisJaWYgKCEodDEwX2FsdWFfdGdfcHRfZ3BfY2FjaGUpKSB7CisJCXByaW50ayhLRVJOX0VSUiAia21lbV9jYWNoZV9jcmVhdGUoKSBmb3IgdDEwX2FsdWFfdGdfcHRfZ3BfIgorCQkJCSJjYWNoZSBmYWlsZWRcbiIpOworCQlnb3RvIG91dDsKKwl9CisJdDEwX2FsdWFfdGdfcHRfZ3BfbWVtX2NhY2hlID0ga21lbV9jYWNoZV9jcmVhdGUoCisJCQkidDEwX2FsdWFfdGdfcHRfZ3BfbWVtX2NhY2hlIiwKKwkJCXNpemVvZihzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3BfbWVtYmVyKSwKKwkJCV9fYWxpZ25vZl9fKHN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncF9tZW1iZXIpLAorCQkJMCwgTlVMTCk7CisJaWYgKCEodDEwX2FsdWFfdGdfcHRfZ3BfbWVtX2NhY2hlKSkgeworCQlwcmludGsoS0VSTl9FUlIgImttZW1fY2FjaGVfY3JlYXRlKCkgZm9yIHQxMF9hbHVhX3RnX3B0X2dwXyIKKwkJCQkibWVtX3QgZmFpbGVkXG4iKTsKKwkJZ290byBvdXQ7CisJfQorCisJc2VfZ2xvYmFsID0gZ2xvYmFsOworCisJcmV0dXJuIDA7CitvdXQ6CisJaWYgKHNlX2NtZF9jYWNoZSkKKwkJa21lbV9jYWNoZV9kZXN0cm95KHNlX2NtZF9jYWNoZSk7CisJaWYgKHNlX3Rtcl9yZXFfY2FjaGUpCisJCWttZW1fY2FjaGVfZGVzdHJveShzZV90bXJfcmVxX2NhY2hlKTsKKwlpZiAoc2Vfc2Vzc19jYWNoZSkKKwkJa21lbV9jYWNoZV9kZXN0cm95KHNlX3Nlc3NfY2FjaGUpOworCWlmIChzZV91YV9jYWNoZSkKKwkJa21lbV9jYWNoZV9kZXN0cm95KHNlX3VhX2NhY2hlKTsKKwlpZiAoc2VfbWVtX2NhY2hlKQorCQlrbWVtX2NhY2hlX2Rlc3Ryb3koc2VfbWVtX2NhY2hlKTsKKwlpZiAodDEwX3ByX3JlZ19jYWNoZSkKKwkJa21lbV9jYWNoZV9kZXN0cm95KHQxMF9wcl9yZWdfY2FjaGUpOworCWlmICh0MTBfYWx1YV9sdV9ncF9jYWNoZSkKKwkJa21lbV9jYWNoZV9kZXN0cm95KHQxMF9hbHVhX2x1X2dwX2NhY2hlKTsKKwlpZiAodDEwX2FsdWFfbHVfZ3BfbWVtX2NhY2hlKQorCQlrbWVtX2NhY2hlX2Rlc3Ryb3kodDEwX2FsdWFfbHVfZ3BfbWVtX2NhY2hlKTsKKwlpZiAodDEwX2FsdWFfdGdfcHRfZ3BfY2FjaGUpCisJCWttZW1fY2FjaGVfZGVzdHJveSh0MTBfYWx1YV90Z19wdF9ncF9jYWNoZSk7CisJaWYgKHQxMF9hbHVhX3RnX3B0X2dwX21lbV9jYWNoZSkKKwkJa21lbV9jYWNoZV9kZXN0cm95KHQxMF9hbHVhX3RnX3B0X2dwX21lbV9jYWNoZSk7CisJa2ZyZWUoZ2xvYmFsKTsKKwlyZXR1cm4gLTE7Cit9CisKK3ZvaWQgcmVsZWFzZV9zZV9nbG9iYWwodm9pZCkKK3sKKwlzdHJ1Y3Qgc2VfZ2xvYmFsICpnbG9iYWw7CisKKwlnbG9iYWwgPSBzZV9nbG9iYWw7CisJaWYgKCEoZ2xvYmFsKSkKKwkJcmV0dXJuOworCisJa21lbV9jYWNoZV9kZXN0cm95KHNlX2NtZF9jYWNoZSk7CisJa21lbV9jYWNoZV9kZXN0cm95KHNlX3Rtcl9yZXFfY2FjaGUpOworCWttZW1fY2FjaGVfZGVzdHJveShzZV9zZXNzX2NhY2hlKTsKKwlrbWVtX2NhY2hlX2Rlc3Ryb3koc2VfdWFfY2FjaGUpOworCWttZW1fY2FjaGVfZGVzdHJveShzZV9tZW1fY2FjaGUpOworCWttZW1fY2FjaGVfZGVzdHJveSh0MTBfcHJfcmVnX2NhY2hlKTsKKwlrbWVtX2NhY2hlX2Rlc3Ryb3kodDEwX2FsdWFfbHVfZ3BfY2FjaGUpOworCWttZW1fY2FjaGVfZGVzdHJveSh0MTBfYWx1YV9sdV9ncF9tZW1fY2FjaGUpOworCWttZW1fY2FjaGVfZGVzdHJveSh0MTBfYWx1YV90Z19wdF9ncF9jYWNoZSk7CisJa21lbV9jYWNoZV9kZXN0cm95KHQxMF9hbHVhX3RnX3B0X2dwX21lbV9jYWNoZSk7CisJa2ZyZWUoZ2xvYmFsKTsKKworCXNlX2dsb2JhbCA9IE5VTEw7Cit9CisKK3ZvaWQgdHJhbnNwb3J0X2luaXRfcXVldWVfb2JqKHN0cnVjdCBzZV9xdWV1ZV9vYmogKnFvYmopCit7CisJYXRvbWljX3NldCgmcW9iai0+cXVldWVfY250LCAwKTsKKwlJTklUX0xJU1RfSEVBRCgmcW9iai0+cW9ial9saXN0KTsKKwlpbml0X3dhaXRxdWV1ZV9oZWFkKCZxb2JqLT50aHJlYWRfd3EpOworCXNwaW5fbG9ja19pbml0KCZxb2JqLT5jbWRfcXVldWVfbG9jayk7Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9pbml0X3F1ZXVlX29iaik7CisKK3N0YXRpYyBpbnQgdHJhbnNwb3J0X3N1YnN5c3RlbV9yZXFtb2RzKHZvaWQpCit7CisJaW50IHJldDsKKworCXJldCA9IHJlcXVlc3RfbW9kdWxlKCJ0YXJnZXRfY29yZV9pYmxvY2siKTsKKwlpZiAocmV0ICE9IDApCisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGxvYWQgdGFyZ2V0X2NvcmVfaWJsb2NrXG4iKTsKKworCXJldCA9IHJlcXVlc3RfbW9kdWxlKCJ0YXJnZXRfY29yZV9maWxlIik7CisJaWYgKHJldCAhPSAwKQorCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2FkIHRhcmdldF9jb3JlX2ZpbGVcbiIpOworCisJcmV0ID0gcmVxdWVzdF9tb2R1bGUoInRhcmdldF9jb3JlX3BzY3NpIik7CisJaWYgKHJldCAhPSAwKQorCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2FkIHRhcmdldF9jb3JlX3BzY3NpXG4iKTsKKworCXJldCA9IHJlcXVlc3RfbW9kdWxlKCJ0YXJnZXRfY29yZV9zdGd0Iik7CisJaWYgKHJldCAhPSAwKQorCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2FkIHRhcmdldF9jb3JlX3N0Z3RcbiIpOworCisJcmV0dXJuIDA7Cit9CisKK2ludCB0cmFuc3BvcnRfc3Vic3lzdGVtX2NoZWNrX2luaXQodm9pZCkKK3sKKwlpZiAoc2VfZ2xvYmFsLT5nX3N1Yl9hcGlfaW5pdGlhbGl6ZWQpCisJCXJldHVybiAwOworCS8qCisJICogUmVxdWVzdCB0aGUgbG9hZGluZyBvZiBrbm93biBUQ00gc3Vic3lzdGVtIHBsdWdpbnMuLgorCSAqLworCWlmICh0cmFuc3BvcnRfc3Vic3lzdGVtX3JlcW1vZHMoKSA8IDApCisJCXJldHVybiAtMTsKKworCXNlX2dsb2JhbC0+Z19zdWJfYXBpX2luaXRpYWxpemVkID0gMTsKKwlyZXR1cm4gMDsKK30KKworc3RydWN0IHNlX3Nlc3Npb24gKnRyYW5zcG9ydF9pbml0X3Nlc3Npb24odm9pZCkKK3sKKwlzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqc2Vfc2VzczsKKworCXNlX3Nlc3MgPSBrbWVtX2NhY2hlX3phbGxvYyhzZV9zZXNzX2NhY2hlLCBHRlBfS0VSTkVMKTsKKwlpZiAoIShzZV9zZXNzKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBzdHJ1Y3Qgc2Vfc2Vzc2lvbiBmcm9tIgorCQkJCSIgc2Vfc2Vzc19jYWNoZVxuIik7CisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCX0KKwlJTklUX0xJU1RfSEVBRCgmc2Vfc2Vzcy0+c2Vzc19saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmc2Vfc2Vzcy0+c2Vzc19hY2xfbGlzdCk7CisJYXRvbWljX3NldCgmc2Vfc2Vzcy0+bWliX3JlZl9jb3VudCwgMCk7CisKKwlyZXR1cm4gc2Vfc2VzczsKK30KK0VYUE9SVF9TWU1CT0wodHJhbnNwb3J0X2luaXRfc2Vzc2lvbik7CisKKy8qCisgKiBDYWxsZWQgd2l0aCBzcGluX2xvY2tfYmgoJnN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAtPnNlc3Npb25fbG9jayBjYWxsZWQuCisgKi8KK3ZvaWQgX190cmFuc3BvcnRfcmVnaXN0ZXJfc2Vzc2lvbigKKwlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICpzZV90cGcsCisJc3RydWN0IHNlX25vZGVfYWNsICpzZV9uYWNsLAorCXN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzLAorCXZvaWQgKmZhYnJpY19zZXNzX3B0cikKK3sKKwl1bnNpZ25lZCBjaGFyIGJ1ZltQUl9SRUdfSVNJRF9MRU5dOworCisJc2Vfc2Vzcy0+c2VfdHBnID0gc2VfdHBnOworCXNlX3Nlc3MtPmZhYnJpY19zZXNzX3B0ciA9IGZhYnJpY19zZXNzX3B0cjsKKwkvKgorCSAqIFVzZWQgYnkgc3RydWN0IHNlX25vZGVfYWNsJ3MgdW5kZXIgQ29uZmlnRlMgdG8gbG9jYXRlIGFjdGl2ZSBzZV9zZXNzaW9uLXQKKwkgKgorCSAqIE9ubHkgc2V0IGZvciBzdHJ1Y3Qgc2Vfc2Vzc2lvbidzIHRoYXQgd2lsbCBhY3R1YWxseSBiZSBtb3ZpbmcgSS9PLgorCSAqIGVnOiAqTk9UKiBkaXNjb3Zlcnkgc2Vzc2lvbnMuCisJICovCisJaWYgKHNlX25hY2wpIHsKKwkJLyoKKwkJICogSWYgdGhlIGZhYnJpYyBtb2R1bGUgc3VwcG9ydHMgYW4gSVNJRCBiYXNlZCBUcmFuc3BvcnRJRCwKKwkJICogc2F2ZSB0aGlzIHZhbHVlIGluIGJpbmFyeSBmcm9tIHRoZSBmYWJyaWMgSV9UIE5leHVzIG5vdy4KKwkJICovCisJCWlmIChUUEdfVEZPKHNlX3RwZyktPnNlc3NfZ2V0X2luaXRpYXRvcl9zaWQgIT0gTlVMTCkgeworCQkJbWVtc2V0KCZidWZbMF0sIDAsIFBSX1JFR19JU0lEX0xFTik7CisJCQlUUEdfVEZPKHNlX3RwZyktPnNlc3NfZ2V0X2luaXRpYXRvcl9zaWQoc2Vfc2VzcywKKwkJCQkJJmJ1ZlswXSwgUFJfUkVHX0lTSURfTEVOKTsKKwkJCXNlX3Nlc3MtPnNlc3NfYmluX2lzaWQgPSBnZXRfdW5hbGlnbmVkX2JlNjQoJmJ1ZlswXSk7CisJCX0KKwkJc3Bpbl9sb2NrX2lycSgmc2VfbmFjbC0+bmFjbF9zZXNzX2xvY2spOworCQkvKgorCQkgKiBUaGUgc2VfbmFjbC0+bmFjbF9zZXNzIHBvaW50ZXIgd2lsbCBiZSBzZXQgdG8gdGhlCisJCSAqIGxhc3QgYWN0aXZlIElfVCBOZXh1cyBmb3IgZWFjaCBzdHJ1Y3Qgc2Vfbm9kZV9hY2wuCisJCSAqLworCQlzZV9uYWNsLT5uYWNsX3Nlc3MgPSBzZV9zZXNzOworCisJCWxpc3RfYWRkX3RhaWwoJnNlX3Nlc3MtPnNlc3NfYWNsX2xpc3QsCisJCQkgICAgICAmc2VfbmFjbC0+YWNsX3Nlc3NfbGlzdCk7CisJCXNwaW5fdW5sb2NrX2lycSgmc2VfbmFjbC0+bmFjbF9zZXNzX2xvY2spOworCX0KKwlsaXN0X2FkZF90YWlsKCZzZV9zZXNzLT5zZXNzX2xpc3QsICZzZV90cGctPnRwZ19zZXNzX2xpc3QpOworCisJcHJpbnRrKEtFUk5fSU5GTyAiVEFSR0VUX0NPUkVbJXNdOiBSZWdpc3RlcmVkIGZhYnJpY19zZXNzX3B0cjogJXBcbiIsCisJCVRQR19URk8oc2VfdHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksIHNlX3Nlc3MtPmZhYnJpY19zZXNzX3B0cik7Cit9CitFWFBPUlRfU1lNQk9MKF9fdHJhbnNwb3J0X3JlZ2lzdGVyX3Nlc3Npb24pOworCit2b2lkIHRyYW5zcG9ydF9yZWdpc3Rlcl9zZXNzaW9uKAorCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZywKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKnNlX25hY2wsCisJc3RydWN0IHNlX3Nlc3Npb24gKnNlX3Nlc3MsCisJdm9pZCAqZmFicmljX3Nlc3NfcHRyKQoreworCXNwaW5fbG9ja19iaCgmc2VfdHBnLT5zZXNzaW9uX2xvY2spOworCV9fdHJhbnNwb3J0X3JlZ2lzdGVyX3Nlc3Npb24oc2VfdHBnLCBzZV9uYWNsLCBzZV9zZXNzLCBmYWJyaWNfc2Vzc19wdHIpOworCXNwaW5fdW5sb2NrX2JoKCZzZV90cGctPnNlc3Npb25fbG9jayk7Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9yZWdpc3Rlcl9zZXNzaW9uKTsKKwordm9pZCB0cmFuc3BvcnRfZGVyZWdpc3Rlcl9zZXNzaW9uX2NvbmZpZ2ZzKHN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzKQoreworCXN0cnVjdCBzZV9ub2RlX2FjbCAqc2VfbmFjbDsKKworCS8qCisJICogVXNlZCBieSBzdHJ1Y3Qgc2Vfbm9kZV9hY2wncyB1bmRlciBDb25maWdGUyB0byBsb2NhdGUgYWN0aXZlIHN0cnVjdCBzZV9zZXNzaW9uCisJICovCisJc2VfbmFjbCA9IHNlX3Nlc3MtPnNlX25vZGVfYWNsOworCWlmICgoc2VfbmFjbCkpIHsKKwkJc3Bpbl9sb2NrX2lycSgmc2VfbmFjbC0+bmFjbF9zZXNzX2xvY2spOworCQlsaXN0X2RlbCgmc2Vfc2Vzcy0+c2Vzc19hY2xfbGlzdCk7CisJCS8qCisJCSAqIElmIHRoZSBzZXNzaW9uIGxpc3QgaXMgZW1wdHksIHRoZW4gY2xlYXIgdGhlIHBvaW50ZXIuCisJCSAqIE90aGVyd2lzZSwgc2V0IHRoZSBzdHJ1Y3Qgc2Vfc2Vzc2lvbiBwb2ludGVyIGZyb20gdGhlIHRhaWwKKwkJICogZWxlbWVudCBvZiB0aGUgcGVyIHN0cnVjdCBzZV9ub2RlX2FjbCBhY3RpdmUgc2Vzc2lvbiBsaXN0LgorCQkgKi8KKwkJaWYgKGxpc3RfZW1wdHkoJnNlX25hY2wtPmFjbF9zZXNzX2xpc3QpKQorCQkJc2VfbmFjbC0+bmFjbF9zZXNzID0gTlVMTDsKKwkJZWxzZSB7CisJCQlzZV9uYWNsLT5uYWNsX3Nlc3MgPSBjb250YWluZXJfb2YoCisJCQkJCXNlX25hY2wtPmFjbF9zZXNzX2xpc3QucHJldiwKKwkJCQkJc3RydWN0IHNlX3Nlc3Npb24sIHNlc3NfYWNsX2xpc3QpOworCQl9CisJCXNwaW5fdW5sb2NrX2lycSgmc2VfbmFjbC0+bmFjbF9zZXNzX2xvY2spOworCX0KK30KK0VYUE9SVF9TWU1CT0wodHJhbnNwb3J0X2RlcmVnaXN0ZXJfc2Vzc2lvbl9jb25maWdmcyk7CisKK3ZvaWQgdHJhbnNwb3J0X2ZyZWVfc2Vzc2lvbihzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqc2Vfc2VzcykKK3sKKwlrbWVtX2NhY2hlX2ZyZWUoc2Vfc2Vzc19jYWNoZSwgc2Vfc2Vzcyk7Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9mcmVlX3Nlc3Npb24pOworCit2b2lkIHRyYW5zcG9ydF9kZXJlZ2lzdGVyX3Nlc3Npb24oc3RydWN0IHNlX3Nlc3Npb24gKnNlX3Nlc3MpCit7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnID0gc2Vfc2Vzcy0+c2VfdHBnOworCXN0cnVjdCBzZV9ub2RlX2FjbCAqc2VfbmFjbDsKKworCWlmICghKHNlX3RwZykpIHsKKwkJdHJhbnNwb3J0X2ZyZWVfc2Vzc2lvbihzZV9zZXNzKTsKKwkJcmV0dXJuOworCX0KKwkvKgorCSAqIFdhaXQgZm9yIHBvc3NpYmxlIHJlZmVyZW5jZSBpbiBkcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9taWIuYzoKKwkgKiBzY3NpX2F0dF9pbnRyX3BvcnRfc2VxX3Nob3coKQorCSAqLworCXdoaWxlIChhdG9taWNfcmVhZCgmc2Vfc2Vzcy0+bWliX3JlZl9jb3VudCkgIT0gMCkKKwkJY3B1X3JlbGF4KCk7CisKKwlzcGluX2xvY2tfYmgoJnNlX3RwZy0+c2Vzc2lvbl9sb2NrKTsKKwlsaXN0X2RlbCgmc2Vfc2Vzcy0+c2Vzc19saXN0KTsKKwlzZV9zZXNzLT5zZV90cGcgPSBOVUxMOworCXNlX3Nlc3MtPmZhYnJpY19zZXNzX3B0ciA9IE5VTEw7CisJc3Bpbl91bmxvY2tfYmgoJnNlX3RwZy0+c2Vzc2lvbl9sb2NrKTsKKworCS8qCisJICogRGV0ZXJtaW5lIGlmIHdlIG5lZWQgdG8gZG8gZXh0cmEgd29yayBmb3IgdGhpcyBpbml0aWF0b3Igbm9kZSdzCisJICogc3RydWN0IHNlX25vZGVfYWNsIGlmIGl0IGhhZCBiZWVuIHByZXZpb3VzbHkgZHluYW1pY2FsbHkgZ2VuZXJhdGVkLgorCSAqLworCXNlX25hY2wgPSBzZV9zZXNzLT5zZV9ub2RlX2FjbDsKKwlpZiAoKHNlX25hY2wpKSB7CisJCXNwaW5fbG9ja19iaCgmc2VfdHBnLT5hY2xfbm9kZV9sb2NrKTsKKwkJaWYgKHNlX25hY2wtPmR5bmFtaWNfbm9kZV9hY2wpIHsKKwkJCWlmICghKFRQR19URk8oc2VfdHBnKS0+dHBnX2NoZWNrX2RlbW9fbW9kZV9jYWNoZSgKKwkJCQkJc2VfdHBnKSkpIHsKKwkJCQlsaXN0X2RlbCgmc2VfbmFjbC0+YWNsX2xpc3QpOworCQkJCXNlX3RwZy0+bnVtX25vZGVfYWNscy0tOworCQkJCXNwaW5fdW5sb2NrX2JoKCZzZV90cGctPmFjbF9ub2RlX2xvY2spOworCisJCQkJY29yZV90cGdfd2FpdF9mb3JfbmFjbF9wcl9yZWYoc2VfbmFjbCk7CisJCQkJY29yZV90cGdfd2FpdF9mb3JfbWliX3JlZihzZV9uYWNsKTsKKwkJCQljb3JlX2ZyZWVfZGV2aWNlX2xpc3RfZm9yX25vZGUoc2VfbmFjbCwgc2VfdHBnKTsKKwkJCQlUUEdfVEZPKHNlX3RwZyktPnRwZ19yZWxlYXNlX2ZhYnJpY19hY2woc2VfdHBnLAorCQkJCQkJc2VfbmFjbCk7CisJCQkJc3Bpbl9sb2NrX2JoKCZzZV90cGctPmFjbF9ub2RlX2xvY2spOworCQkJfQorCQl9CisJCXNwaW5fdW5sb2NrX2JoKCZzZV90cGctPmFjbF9ub2RlX2xvY2spOworCX0KKworCXRyYW5zcG9ydF9mcmVlX3Nlc3Npb24oc2Vfc2Vzcyk7CisKKwlwcmludGsoS0VSTl9JTkZPICJUQVJHRVRfQ09SRVslc106IERlcmVnaXN0ZXJlZCBmYWJyaWNfc2Vzc1xuIiwKKwkJVFBHX1RGTyhzZV90cGcpLT5nZXRfZmFicmljX25hbWUoKSk7Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9kZXJlZ2lzdGVyX3Nlc3Npb24pOworCisvKgorICogQ2FsbGVkIHdpdGggVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jayBoZWxkLgorICovCitzdGF0aWMgdm9pZCB0cmFuc3BvcnRfYWxsX3Rhc2tfZGV2X3JlbW92ZV9zdGF0ZShzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2OworCXN0cnVjdCBzZV90YXNrICp0YXNrOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlpZiAoIVRfVEFTSyhjbWQpKQorCQlyZXR1cm47CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHRhc2ssICZUX1RBU0soY21kKS0+dF90YXNrX2xpc3QsIHRfbGlzdCkgeworCQlkZXYgPSB0YXNrLT5zZV9kZXY7CisJCWlmICghKGRldikpCisJCQljb250aW51ZTsKKworCQlpZiAoYXRvbWljX3JlYWQoJnRhc2stPnRhc2tfYWN0aXZlKSkKKwkJCWNvbnRpbnVlOworCisJCWlmICghKGF0b21pY19yZWFkKCZ0YXNrLT50YXNrX3N0YXRlX2FjdGl2ZSkpKQorCQkJY29udGludWU7CisKKwkJc3Bpbl9sb2NrX2lycXNhdmUoJmRldi0+ZXhlY3V0ZV90YXNrX2xvY2ssIGZsYWdzKTsKKwkJbGlzdF9kZWwoJnRhc2stPnRfc3RhdGVfbGlzdCk7CisJCURFQlVHX1RTVEFURSgiUmVtb3ZlZCBJVFQ6IDB4JTA4eCBkZXY6ICVwIHRhc2tbJXBdXG4iLAorCQkJQ01EX1RGTyhjbWQpLT50Zm9fZ2V0X3Rhc2tfdGFnKGNtZCksIGRldiwgdGFzayk7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRldi0+ZXhlY3V0ZV90YXNrX2xvY2ssIGZsYWdzKTsKKworCQlhdG9taWNfc2V0KCZ0YXNrLT50YXNrX3N0YXRlX2FjdGl2ZSwgMCk7CisJCWF0b21pY19kZWMoJlRfVEFTSyhjbWQpLT50X3Rhc2tfY2Ric19leF9sZWZ0KTsKKwl9Cit9CisKKy8qCXRyYW5zcG9ydF9jbWRfY2hlY2tfc3RvcCgpOgorICoKKyAqCSd0cmFuc3BvcnRfb2ZmID0gMScgZGV0ZXJtaW5lcyBpZiB0X3RyYW5zcG9ydF9hY3RpdmUgc2hvdWxkIGJlIGNsZWFyZWQuCisgKgkndHJhbnNwb3J0X29mZiA9IDInIGRldGVybWluZXMgaWYgdGFza19kZXZfc3RhdGUgc2hvdWxkIGJlIHJlbW92ZWQuCisgKgorICoJQSBub24temVybyB1OCB0X3N0YXRlIHNldHMgY21kLT50X3N0YXRlLgorICoJUmV0dXJucyAxIHdoZW4gY29tbWFuZCBpcyBzdG9wcGVkLCBlbHNlIDAuCisgKi8KK3N0YXRpYyBpbnQgdHJhbnNwb3J0X2NtZF9jaGVja19zdG9wKAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwlpbnQgdHJhbnNwb3J0X29mZiwKKwl1OCB0X3N0YXRlKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCS8qCisJICogRGV0ZXJtaW5lIGlmIElPQ1RMIGNvbnRleHQgY2FsbGVyIGluIHJlcXVlc3RpbmcgdGhlIHN0b3BwaW5nIG9mIHRoaXMKKwkgKiBjb21tYW5kIGZvciBMVU4gc2h1dGRvd24gcHVycG9zZXMuCisJICovCisJaWYgKGF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dHJhbnNwb3J0X2x1bl9zdG9wKSkgeworCQlERUJVR19DUygiJXM6JWQgYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50cmFuc3BvcnRfbHVuX3N0b3ApIgorCQkJIiA9PSBUUlVFIGZvciBJVFQ6IDB4JTA4eFxuIiwgX19mdW5jX18sIF9fTElORV9fLAorCQkJQ01EX1RGTyhjbWQpLT5nZXRfdGFza190YWcoY21kKSk7CisKKwkJY21kLT5kZWZlcnJlZF90X3N0YXRlID0gY21kLT50X3N0YXRlOworCQljbWQtPnRfc3RhdGUgPSBUUkFOU1BPUlRfREVGRVJSRURfQ01EOworCQlhdG9taWNfc2V0KCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfYWN0aXZlLCAwKTsKKwkJaWYgKHRyYW5zcG9ydF9vZmYgPT0gMikKKwkJCXRyYW5zcG9ydF9hbGxfdGFza19kZXZfcmVtb3ZlX3N0YXRlKGNtZCk7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKworCQljb21wbGV0ZSgmVF9UQVNLKGNtZCktPnRyYW5zcG9ydF9sdW5fc3RvcF9jb21wKTsKKwkJcmV0dXJuIDE7CisJfQorCS8qCisJICogRGV0ZXJtaW5lIGlmIGZyb250ZW5kIGNvbnRleHQgY2FsbGVyIGlzIHJlcXVlc3RpbmcgdGhlIHN0b3BwaW5nIG9mCisJICogdGhpcyBjb21tYW5kIGZvciBmcm9udGVuZCBleGNwZWN0aW9ucy4KKwkgKi8KKwlpZiAoYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X3RyYW5zcG9ydF9zdG9wKSkgeworCQlERUJVR19DUygiJXM6JWQgYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X3RyYW5zcG9ydF9zdG9wKSA9PSIKKwkJCSIgVFJVRSBmb3IgSVRUOiAweCUwOHhcbiIsIF9fZnVuY19fLCBfX0xJTkVfXywKKwkJCUNNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCkpOworCisJCWNtZC0+ZGVmZXJyZWRfdF9zdGF0ZSA9IGNtZC0+dF9zdGF0ZTsKKwkJY21kLT50X3N0YXRlID0gVFJBTlNQT1JUX0RFRkVSUkVEX0NNRDsKKwkJaWYgKHRyYW5zcG9ydF9vZmYgPT0gMikKKwkJCXRyYW5zcG9ydF9hbGxfdGFza19kZXZfcmVtb3ZlX3N0YXRlKGNtZCk7CisKKwkJLyoKKwkJICogQ2xlYXIgc3RydWN0IHNlX2NtZC0+c2VfbHVuIGJlZm9yZSB0aGUgdHJhbnNwb3J0X29mZiA9PSAyIGhhbmRvZmYKKwkJICogdG8gRkUuCisJCSAqLworCQlpZiAodHJhbnNwb3J0X29mZiA9PSAyKQorCQkJY21kLT5zZV9sdW4gPSBOVUxMOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisKKwkJY29tcGxldGUoJlRfVEFTSyhjbWQpLT50X3RyYW5zcG9ydF9zdG9wX2NvbXApOworCQlyZXR1cm4gMTsKKwl9CisJaWYgKHRyYW5zcG9ydF9vZmYpIHsKKwkJYXRvbWljX3NldCgmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X2FjdGl2ZSwgMCk7CisJCWlmICh0cmFuc3BvcnRfb2ZmID09IDIpIHsKKwkJCXRyYW5zcG9ydF9hbGxfdGFza19kZXZfcmVtb3ZlX3N0YXRlKGNtZCk7CisJCQkvKgorCQkJICogQ2xlYXIgc3RydWN0IHNlX2NtZC0+c2VfbHVuIGJlZm9yZSB0aGUgdHJhbnNwb3J0X29mZiA9PSAyCisJCQkgKiBoYW5kb2ZmIHRvIGZhYnJpYyBtb2R1bGUuCisJCQkgKi8KKwkJCWNtZC0+c2VfbHVuID0gTlVMTDsKKwkJCS8qCisJCQkgKiBTb21lIGZhYnJpYyBtb2R1bGVzIGxpa2UgdGNtX2xvb3AgY2FuIHJlbGVhc2UKKwkJCSAqIHRoZWlyIGludGVybmFsbHkgYWxsb2NhdGVkIEkvTyByZWZyZW5jZSBub3cgYW5kCisJCQkgKiBzdHJ1Y3Qgc2VfY21kIG5vdy4KKwkJCSAqLworCQkJaWYgKENNRF9URk8oY21kKS0+Y2hlY2tfc3RvcF9mcmVlICE9IE5VTEwpIHsKKwkJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKAorCQkJCQkmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCisJCQkJQ01EX1RGTyhjbWQpLT5jaGVja19zdG9wX2ZyZWUoY21kKTsKKwkJCQlyZXR1cm4gMTsKKwkJCX0KKwkJfQorCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisKKwkJcmV0dXJuIDA7CisJfSBlbHNlIGlmICh0X3N0YXRlKQorCQljbWQtPnRfc3RhdGUgPSB0X3N0YXRlOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHRyYW5zcG9ydF9jbWRfY2hlY2tfc3RvcF90b19mYWJyaWMoc3RydWN0IHNlX2NtZCAqY21kKQoreworCXJldHVybiB0cmFuc3BvcnRfY21kX2NoZWNrX3N0b3AoY21kLCAyLCAwKTsKK30KKworc3RhdGljIHZvaWQgdHJhbnNwb3J0X2x1bl9yZW1vdmVfY21kKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlzdHJ1Y3Qgc2VfbHVuICpsdW4gPSBTRV9MVU4oY21kKTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJaWYgKCFsdW4pCisJCXJldHVybjsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJaWYgKCEoYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50cmFuc3BvcnRfZGV2X2FjdGl2ZSkpKSB7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwkJZ290byBjaGVja19sdW47CisJfQorCWF0b21pY19zZXQoJlRfVEFTSyhjbWQpLT50cmFuc3BvcnRfZGV2X2FjdGl2ZSwgMCk7CisJdHJhbnNwb3J0X2FsbF90YXNrX2Rldl9yZW1vdmVfc3RhdGUoY21kKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisKKwl0cmFuc3BvcnRfZnJlZV9kZXZfdGFza3MoY21kKTsKKworY2hlY2tfbHVuOgorCXNwaW5fbG9ja19pcnFzYXZlKCZsdW4tPmx1bl9jbWRfbG9jaywgZmxhZ3MpOworCWlmIChhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRyYW5zcG9ydF9sdW5fYWN0aXZlKSkgeworCQlsaXN0X2RlbCgmY21kLT5zZV9sdW5fbGlzdCk7CisJCWF0b21pY19zZXQoJlRfVEFTSyhjbWQpLT50cmFuc3BvcnRfbHVuX2FjdGl2ZSwgMCk7CisjaWYgMAorCQlwcmludGsoS0VSTl9JTkZPICJSZW1vdmVkIElUVDogMHglMDh4IGZyb20gTFVOIExJU1RbJWRdXG4iCisJCQlDTURfVEZPKGNtZCktPmdldF90YXNrX3RhZyhjbWQpLCBsdW4tPnVucGFja2VkX2x1bik7CisjZW5kaWYKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmbHVuLT5sdW5fY21kX2xvY2ssIGZsYWdzKTsKK30KKwordm9pZCB0cmFuc3BvcnRfY21kX2ZpbmlzaF9hYm9ydChzdHJ1Y3Qgc2VfY21kICpjbWQsIGludCByZW1vdmUpCit7CisJdHJhbnNwb3J0X3JlbW92ZV9jbWRfZnJvbV9xdWV1ZShjbWQsIFNFX0RFVihjbWQpLT5kZXZfcXVldWVfb2JqKTsKKwl0cmFuc3BvcnRfbHVuX3JlbW92ZV9jbWQoY21kKTsKKworCWlmICh0cmFuc3BvcnRfY21kX2NoZWNrX3N0b3BfdG9fZmFicmljKGNtZCkpCisJCXJldHVybjsKKwlpZiAocmVtb3ZlKQorCQl0cmFuc3BvcnRfZ2VuZXJpY19yZW1vdmUoY21kLCAwLCAwKTsKK30KKwordm9pZCB0cmFuc3BvcnRfY21kX2ZpbmlzaF9hYm9ydF90bXIoc3RydWN0IHNlX2NtZCAqY21kKQoreworCXRyYW5zcG9ydF9yZW1vdmVfY21kX2Zyb21fcXVldWUoY21kLCBTRV9ERVYoY21kKS0+ZGV2X3F1ZXVlX29iaik7CisKKwlpZiAodHJhbnNwb3J0X2NtZF9jaGVja19zdG9wX3RvX2ZhYnJpYyhjbWQpKQorCQlyZXR1cm47CisKKwl0cmFuc3BvcnRfZ2VuZXJpY19yZW1vdmUoY21kLCAwLCAwKTsKK30KKworc3RhdGljIGludCB0cmFuc3BvcnRfYWRkX2NtZF90b19xdWV1ZSgKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJaW50IHRfc3RhdGUpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gY21kLT5zZV9kZXY7CisJc3RydWN0IHNlX3F1ZXVlX29iaiAqcW9iaiA9IGRldi0+ZGV2X3F1ZXVlX29iajsKKwlzdHJ1Y3Qgc2VfcXVldWVfcmVxICpxcjsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJcXIgPSBremFsbG9jKHNpemVvZihzdHJ1Y3Qgc2VfcXVldWVfcmVxKSwgR0ZQX0FUT01JQyk7CisJaWYgKCEocXIpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIG1lbW9yeSBmb3IiCisJCQkJIiBzdHJ1Y3Qgc2VfcXVldWVfcmVxXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwlJTklUX0xJU1RfSEVBRCgmcXItPnFyX2xpc3QpOworCisJcXItPmNtZCA9ICh2b2lkICopY21kOworCXFyLT5zdGF0ZSA9IHRfc3RhdGU7CisKKwlpZiAodF9zdGF0ZSkgeworCQlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCQljbWQtPnRfc3RhdGUgPSB0X3N0YXRlOworCQlhdG9taWNfc2V0KCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfYWN0aXZlLCAxKTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCX0KKworCXNwaW5fbG9ja19pcnFzYXZlKCZxb2JqLT5jbWRfcXVldWVfbG9jaywgZmxhZ3MpOworCWxpc3RfYWRkX3RhaWwoJnFyLT5xcl9saXN0LCAmcW9iai0+cW9ial9saXN0KTsKKwlhdG9taWNfaW5jKCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfcXVldWVfYWN0aXZlKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZxb2JqLT5jbWRfcXVldWVfbG9jaywgZmxhZ3MpOworCisJYXRvbWljX2luYygmcW9iai0+cXVldWVfY250KTsKKwl3YWtlX3VwX2ludGVycnVwdGlibGUoJnFvYmotPnRocmVhZF93cSk7CisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBDYWxsZWQgd2l0aCBzdHJ1Y3Qgc2VfcXVldWVfb2JqLT5jbWRfcXVldWVfbG9jayBoZWxkLgorICovCitzdGF0aWMgc3RydWN0IHNlX3F1ZXVlX3JlcSAqCitfX3RyYW5zcG9ydF9nZXRfcXJfZnJvbV9xdWV1ZShzdHJ1Y3Qgc2VfcXVldWVfb2JqICpxb2JqKQoreworCXN0cnVjdCBzZV9jbWQgKmNtZDsKKwlzdHJ1Y3Qgc2VfcXVldWVfcmVxICpxciA9IE5VTEw7CisKKwlpZiAobGlzdF9lbXB0eSgmcW9iai0+cW9ial9saXN0KSkKKwkJcmV0dXJuIE5VTEw7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHFyLCAmcW9iai0+cW9ial9saXN0LCBxcl9saXN0KQorCQlicmVhazsKKworCWlmIChxci0+Y21kKSB7CisJCWNtZCA9IChzdHJ1Y3Qgc2VfY21kICopcXItPmNtZDsKKwkJYXRvbWljX2RlYygmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X3F1ZXVlX2FjdGl2ZSk7CisJfQorCWxpc3RfZGVsKCZxci0+cXJfbGlzdCk7CisJYXRvbWljX2RlYygmcW9iai0+cXVldWVfY250KTsKKworCXJldHVybiBxcjsKK30KKworc3RhdGljIHN0cnVjdCBzZV9xdWV1ZV9yZXEgKgordHJhbnNwb3J0X2dldF9xcl9mcm9tX3F1ZXVlKHN0cnVjdCBzZV9xdWV1ZV9vYmogKnFvYmopCit7CisJc3RydWN0IHNlX2NtZCAqY21kOworCXN0cnVjdCBzZV9xdWV1ZV9yZXEgKnFyOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmcW9iai0+Y21kX3F1ZXVlX2xvY2ssIGZsYWdzKTsKKwlpZiAobGlzdF9lbXB0eSgmcW9iai0+cW9ial9saXN0KSkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZxb2JqLT5jbWRfcXVldWVfbG9jaywgZmxhZ3MpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHFyLCAmcW9iai0+cW9ial9saXN0LCBxcl9saXN0KQorCQlicmVhazsKKworCWlmIChxci0+Y21kKSB7CisJCWNtZCA9IChzdHJ1Y3Qgc2VfY21kICopcXItPmNtZDsKKwkJYXRvbWljX2RlYygmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X3F1ZXVlX2FjdGl2ZSk7CisJfQorCWxpc3RfZGVsKCZxci0+cXJfbGlzdCk7CisJYXRvbWljX2RlYygmcW9iai0+cXVldWVfY250KTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZxb2JqLT5jbWRfcXVldWVfbG9jaywgZmxhZ3MpOworCisJcmV0dXJuIHFyOworfQorCitzdGF0aWMgdm9pZCB0cmFuc3BvcnRfcmVtb3ZlX2NtZF9mcm9tX3F1ZXVlKHN0cnVjdCBzZV9jbWQgKmNtZCwKKwkJc3RydWN0IHNlX3F1ZXVlX29iaiAqcW9iaikKK3sKKwlzdHJ1Y3Qgc2VfY21kICpxX2NtZDsKKwlzdHJ1Y3Qgc2VfcXVldWVfcmVxICpxciA9IE5VTEwsICpxcl9wID0gTlVMTDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJnFvYmotPmNtZF9xdWV1ZV9sb2NrLCBmbGFncyk7CisJaWYgKCEoYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X3RyYW5zcG9ydF9xdWV1ZV9hY3RpdmUpKSkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZxb2JqLT5jbWRfcXVldWVfbG9jaywgZmxhZ3MpOworCQlyZXR1cm47CisJfQorCisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHFyLCBxcl9wLCAmcW9iai0+cW9ial9saXN0LCBxcl9saXN0KSB7CisJCXFfY21kID0gKHN0cnVjdCBzZV9jbWQgKilxci0+Y21kOworCQlpZiAocV9jbWQgIT0gY21kKQorCQkJY29udGludWU7CisKKwkJYXRvbWljX2RlYygmVF9UQVNLKHFfY21kKS0+dF90cmFuc3BvcnRfcXVldWVfYWN0aXZlKTsKKwkJYXRvbWljX2RlYygmcW9iai0+cXVldWVfY250KTsKKwkJbGlzdF9kZWwoJnFyLT5xcl9saXN0KTsKKwkJa2ZyZWUocXIpOworCX0KKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZxb2JqLT5jbWRfcXVldWVfbG9jaywgZmxhZ3MpOworCisJaWYgKGF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfcXVldWVfYWN0aXZlKSkgeworCQlwcmludGsoS0VSTl9FUlIgIklUVDogMHglMDh4IHRfdHJhbnNwb3J0X3F1ZXVlX2FjdGl2ZTogJWRcbiIsCisJCQlDTURfVEZPKGNtZCktPmdldF90YXNrX3RhZyhjbWQpLAorCQkJYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X3RyYW5zcG9ydF9xdWV1ZV9hY3RpdmUpKTsKKwl9Cit9CisKKy8qCisgKiBDb21wbGV0aW9uIGZ1bmN0aW9uIHVzZWQgYnkgVENNIHN1YnN5c3RlbSBwbHVnaW5zIChzdWNoIGFzIEZJTEVJTykKKyAqIGZvciBxdWV1ZWluZyB1cCByZXNwb25zZSBmcm9tIHN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpLT5kb190YXNrKCkKKyAqLwordm9pZCB0cmFuc3BvcnRfY29tcGxldGVfc3luY19jYWNoZShzdHJ1Y3Qgc2VfY21kICpjbWQsIGludCBnb29kKQoreworCXN0cnVjdCBzZV90YXNrICp0YXNrID0gbGlzdF9lbnRyeShUX1RBU0soY21kKS0+dF90YXNrX2xpc3QubmV4dCwKKwkJCQlzdHJ1Y3Qgc2VfdGFzaywgdF9saXN0KTsKKworCWlmIChnb29kKSB7CisJCWNtZC0+c2NzaV9zdGF0dXMgPSBTQU1fU1RBVF9HT09EOworCQl0YXNrLT50YXNrX3Njc2lfc3RhdHVzID0gR09PRDsKKwl9IGVsc2UgeworCQl0YXNrLT50YXNrX3Njc2lfc3RhdHVzID0gU0FNX1NUQVRfQ0hFQ0tfQ09ORElUSU9OOworCQl0YXNrLT50YXNrX2Vycm9yX3N0YXR1cyA9IFBZWF9UUkFOU1BPUlRfSUxMRUdBTF9SRVFVRVNUOworCQlUQVNLX0NNRCh0YXNrKS0+dHJhbnNwb3J0X2Vycm9yX3N0YXR1cyA9CisJCQkJCVBZWF9UUkFOU1BPUlRfSUxMRUdBTF9SRVFVRVNUOworCX0KKworCXRyYW5zcG9ydF9jb21wbGV0ZV90YXNrKHRhc2ssIGdvb2QpOworfQorRVhQT1JUX1NZTUJPTCh0cmFuc3BvcnRfY29tcGxldGVfc3luY19jYWNoZSk7CisKKy8qCXRyYW5zcG9ydF9jb21wbGV0ZV90YXNrKCk6CisgKgorICoJQ2FsbGVkIGZyb20gaW50ZXJydXB0IGFuZCBub24gaW50ZXJydXB0IGNvbnRleHQgZGVwZW5kaW5nCisgKglvbiB0aGUgdHJhbnNwb3J0IHBsdWdpbi4KKyAqLwordm9pZCB0cmFuc3BvcnRfY29tcGxldGVfdGFzayhzdHJ1Y3Qgc2VfdGFzayAqdGFzaywgaW50IHN1Y2Nlc3MpCit7CisJc3RydWN0IHNlX2NtZCAqY21kID0gVEFTS19DTUQodGFzayk7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gdGFzay0+c2VfZGV2OworCWludCB0X3N0YXRlOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisjaWYgMAorCXByaW50ayhLRVJOX0lORk8gInRhc2s6ICVwIENEQjogMHglMDJ4IG9ial9wdHI6ICVwXG4iLCB0YXNrLAorCQkJVF9UQVNLKGNtZCktPnRfdGFza19jZGJbMF0sIGRldik7CisjZW5kaWYKKwlpZiAoZGV2KSB7CisJCXNwaW5fbG9ja19pcnFzYXZlKCZTRV9IQkEoZGV2KS0+aGJhX3F1ZXVlX2xvY2ssIGZsYWdzKTsKKwkJYXRvbWljX2luYygmZGV2LT5kZXB0aF9sZWZ0KTsKKwkJYXRvbWljX2luYygmU0VfSEJBKGRldiktPmxlZnRfcXVldWVfZGVwdGgpOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZTRV9IQkEoZGV2KS0+aGJhX3F1ZXVlX2xvY2ssIGZsYWdzKTsKKwl9CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCWF0b21pY19zZXQoJnRhc2stPnRhc2tfYWN0aXZlLCAwKTsKKworCS8qCisJICogU2VlIGlmIGFueSBzZW5zZSBkYXRhIGV4aXN0cywgaWYgc28gc2V0IHRoZSBUQVNLX1NFTlNFIGZsYWcuCisJICogQWxzbyBjaGVjayBmb3IgYW55IG90aGVyIHBvc3QgY29tcGxldGlvbiB3b3JrIHRoYXQgbmVlZHMgdG8gYmUKKwkgKiBkb25lIGJ5IHRoZSBwbHVnaW5zLgorCSAqLworCWlmIChkZXYgJiYgZGV2LT50cmFuc3BvcnQtPnRyYW5zcG9ydF9jb21wbGV0ZSkgeworCQlpZiAoZGV2LT50cmFuc3BvcnQtPnRyYW5zcG9ydF9jb21wbGV0ZSh0YXNrKSAhPSAwKSB7CisJCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfVFJBTlNQT1JUX1RBU0tfU0VOU0U7CisJCQl0YXNrLT50YXNrX3NlbnNlID0gMTsKKwkJCXN1Y2Nlc3MgPSAxOworCQl9CisJfQorCisJLyoKKwkgKiBTZWUgaWYgd2UgYXJlIHdhaXRpbmcgZm9yIG91dHN0YW5kaW5nIHN0cnVjdCBzZV90YXNrCisJICogdG8gY29tcGxldGUgZm9yIGFuIGV4Y2VwdGlvbiBjb25kaXRpb24KKwkgKi8KKwlpZiAoYXRvbWljX3JlYWQoJnRhc2stPnRhc2tfc3RvcCkpIHsKKwkJLyoKKwkJICogRGVjcmVtZW50IFRfVEFTSyhjbWQpLT50X3NlX2NvdW50IGlmIHRoaXMgdGFzayBoYWQKKwkJICogcHJldmlvdXNseSB0aHJvd24gaXRzIHRpbWVvdXQgZXhjZXB0aW9uIGhhbmRsZXIuCisJCSAqLworCQlpZiAoYXRvbWljX3JlYWQoJnRhc2stPnRhc2tfdGltZW91dCkpIHsKKwkJCWF0b21pY19kZWMoJlRfVEFTSyhjbWQpLT50X3NlX2NvdW50KTsKKwkJCWF0b21pY19zZXQoJnRhc2stPnRhc2tfdGltZW91dCwgMCk7CisJCX0KKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCisJCWNvbXBsZXRlKCZ0YXNrLT50YXNrX3N0b3BfY29tcCk7CisJCXJldHVybjsKKwl9CisJLyoKKwkgKiBJZiB0aGUgdGFzaydzIHRpbWVvdXQgaGFuZGxlciBoYXMgZmlyZWQsIHVzZSB0aGUgdF90YXNrX2NkYnNfdGltZW91dAorCSAqIGxlZnQgY291bnRlciB0byBkZXRlcm1pbmUgd2hlbiB0aGUgc3RydWN0IHNlX2NtZCBpcyByZWFkeSB0byBiZSBxdWV1ZWQgdG8KKwkgKiB0aGUgcHJvY2Vzc2luZyB0aHJlYWQuCisJICovCisJaWYgKGF0b21pY19yZWFkKCZ0YXNrLT50YXNrX3RpbWVvdXQpKSB7CisJCWlmICghKGF0b21pY19kZWNfYW5kX3Rlc3QoCisJCQkJJlRfVEFTSyhjbWQpLT50X3Rhc2tfY2Ric190aW1lb3V0X2xlZnQpKSkgeworCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywKKwkJCQlmbGFncyk7CisJCQlyZXR1cm47CisJCX0KKwkJdF9zdGF0ZSA9IFRSQU5TUE9SVF9DT01QTEVURV9USU1FT1VUOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisKKwkJdHJhbnNwb3J0X2FkZF9jbWRfdG9fcXVldWUoY21kLCB0X3N0YXRlKTsKKwkJcmV0dXJuOworCX0KKwlhdG9taWNfZGVjKCZUX1RBU0soY21kKS0+dF90YXNrX2NkYnNfdGltZW91dF9sZWZ0KTsKKworCS8qCisJICogRGVjcmVtZW50IHRoZSBvdXRzdGFuZGluZyB0X3Rhc2tfY2Ric19sZWZ0IGNvdW50LiAgVGhlIGxhc3QKKwkgKiBzdHJ1Y3Qgc2VfdGFzayBmcm9tIHN0cnVjdCBzZV9jbWQgd2lsbCBjb21wbGV0ZSBpdHNlbGYgaW50byB0aGUKKwkgKiBkZXZpY2UgcXVldWUgZGVwZW5kaW5nIHVwb24gaW50IHN1Y2Nlc3MuCisJICovCisJaWYgKCEoYXRvbWljX2RlY19hbmRfdGVzdCgmVF9UQVNLKGNtZCktPnRfdGFza19jZGJzX2xlZnQpKSkgeworCQlpZiAoIXN1Y2Nlc3MpCisJCQlUX1RBU0soY21kKS0+dF90YXNrc19mYWlsZWQgPSAxOworCisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwkJcmV0dXJuOworCX0KKworCWlmICghc3VjY2VzcyB8fCBUX1RBU0soY21kKS0+dF90YXNrc19mYWlsZWQpIHsKKwkJdF9zdGF0ZSA9IFRSQU5TUE9SVF9DT01QTEVURV9GQUlMVVJFOworCQlpZiAoIXRhc2stPnRhc2tfZXJyb3Jfc3RhdHVzKSB7CisJCQl0YXNrLT50YXNrX2Vycm9yX3N0YXR1cyA9CisJCQkJUFlYX1RSQU5TUE9SVF9VTktOT1dOX1NBTV9PUENPREU7CisJCQljbWQtPnRyYW5zcG9ydF9lcnJvcl9zdGF0dXMgPQorCQkJCVBZWF9UUkFOU1BPUlRfVU5LTk9XTl9TQU1fT1BDT0RFOworCQl9CisJfSBlbHNlIHsKKwkJYXRvbWljX3NldCgmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X2NvbXBsZXRlLCAxKTsKKwkJdF9zdGF0ZSA9IFRSQU5TUE9SVF9DT01QTEVURV9PSzsKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCisJdHJhbnNwb3J0X2FkZF9jbWRfdG9fcXVldWUoY21kLCB0X3N0YXRlKTsKK30KK0VYUE9SVF9TWU1CT0wodHJhbnNwb3J0X2NvbXBsZXRlX3Rhc2spOworCisvKgorICogQ2FsbGVkIGJ5IHRyYW5zcG9ydF9hZGRfdGFza3NfZnJvbV9jbWQoKSBvbmNlIGEgc3RydWN0IHNlX2NtZCdzCisgKiBzdHJ1Y3Qgc2VfdGFzayBsaXN0IGFyZSByZWFkeSB0byBiZSBhZGRlZCB0byB0aGUgYWN0aXZlIGV4ZWN1dGlvbiBsaXN0CisgKiBzdHJ1Y3Qgc2VfZGV2aWNlCisKKyAqIENhbGxlZCB3aXRoIHNlX2Rldl90LT5leGVjdXRlX3Rhc2tfbG9jayBjYWxsZWQuCisgKi8KK3N0YXRpYyBpbmxpbmUgaW50IHRyYW5zcG9ydF9hZGRfdGFza19jaGVja19zYW1fYXR0cigKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzaywKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFza19wcmV2LAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldikKK3sKKwkvKgorCSAqIE5vIFNBTSBUYXNrIGF0dHJpYnV0ZSBlbXVsYXRpb24gZW5hYmxlZCwgYWRkIHRvIHRhaWwgb2YKKwkgKiBleGVjdXRpb24gcXVldWUKKwkgKi8KKwlpZiAoZGV2LT5kZXZfdGFza19hdHRyX3R5cGUgIT0gU0FNX1RBU0tfQVRUUl9FTVVMQVRFRCkgeworCQlsaXN0X2FkZF90YWlsKCZ0YXNrLT50X2V4ZWN1dGVfbGlzdCwgJmRldi0+ZXhlY3V0ZV90YXNrX2xpc3QpOworCQlyZXR1cm4gMDsKKwl9CisJLyoKKwkgKiBIRUFEX09GX1FVRVVFIGF0dHJpYnV0ZSBmb3IgcmVjZWl2ZWQgQ0RCLCB3aGljaCBtZWFucworCSAqIHRoZSBmaXJzdCB0YXNrIHRoYXQgaXMgYXNzb2NpYXRlZCB3aXRoIGEgc3RydWN0IHNlX2NtZCBnb2VzIHRvCisJICogaGVhZCBvZiB0aGUgc3RydWN0IHNlX2RldmljZS0+ZXhlY3V0ZV90YXNrX2xpc3QsIGFuZCB0YXNrX3ByZXYKKwkgKiBhZnRlciB0aGF0IGZvciBlYWNoIHN1YnNlcXVlbnQgdGFzaworCSAqLworCWlmICh0YXNrLT50YXNrX3NlX2NtZC0+c2FtX3Rhc2tfYXR0ciA9PSBUQVNLX0FUVFJfSE9RKSB7CisJCWxpc3RfYWRkKCZ0YXNrLT50X2V4ZWN1dGVfbGlzdCwKKwkJCQkodGFza19wcmV2ICE9IE5VTEwpID8KKwkJCQkmdGFza19wcmV2LT50X2V4ZWN1dGVfbGlzdCA6CisJCQkJJmRldi0+ZXhlY3V0ZV90YXNrX2xpc3QpOworCisJCURFQlVHX1NUQSgiU2V0IEhFQURfT0ZfUVVFVUUgZm9yIHRhc2sgQ0RCOiAweCUwMngiCisJCQkJIiBpbiBleGVjdXRpb24gcXVldWVcbiIsCisJCQkJVF9UQVNLKHRhc2stPnRhc2tfc2VfY21kKS0+dF90YXNrX2NkYlswXSk7CisJCXJldHVybiAxOworCX0KKwkvKgorCSAqIEZvciBPUkRFUkVELCBTSU1QTEUgb3IgVU5UQUdHRUQgYXR0cmlidXRlIHRhc2tzIG9uY2UgdGhleSBoYXZlIGJlZW4KKwkgKiB0cmFuc2l0aW9uZWQgZnJvbSBEZXJtYW50IC0+IEFjdGl2ZSBzdGF0ZSwgYW5kIGFyZSBhZGRlZCB0byB0aGUgZW5kCisJICogb2YgdGhlIHN0cnVjdCBzZV9kZXZpY2UtPmV4ZWN1dGVfdGFza19saXN0CisJICovCisJbGlzdF9hZGRfdGFpbCgmdGFzay0+dF9leGVjdXRlX2xpc3QsICZkZXYtPmV4ZWN1dGVfdGFza19saXN0KTsKKwlyZXR1cm4gMDsKK30KKworLyoJX190cmFuc3BvcnRfYWRkX3Rhc2tfdG9fZXhlY3V0ZV9xdWV1ZSgpOgorICoKKyAqCUNhbGxlZCB3aXRoIHNlX2Rldl90LT5leGVjdXRlX3Rhc2tfbG9jayBjYWxsZWQuCisgKi8KK3N0YXRpYyB2b2lkIF9fdHJhbnNwb3J0X2FkZF90YXNrX3RvX2V4ZWN1dGVfcXVldWUoCisJc3RydWN0IHNlX3Rhc2sgKnRhc2ssCisJc3RydWN0IHNlX3Rhc2sgKnRhc2tfcHJldiwKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpCit7CisJaW50IGhlYWRfb2ZfcXVldWU7CisKKwloZWFkX29mX3F1ZXVlID0gdHJhbnNwb3J0X2FkZF90YXNrX2NoZWNrX3NhbV9hdHRyKHRhc2ssIHRhc2tfcHJldiwgZGV2KTsKKwlhdG9taWNfaW5jKCZkZXYtPmV4ZWN1dGVfdGFza3MpOworCisJaWYgKGF0b21pY19yZWFkKCZ0YXNrLT50YXNrX3N0YXRlX2FjdGl2ZSkpCisJCXJldHVybjsKKwkvKgorCSAqIERldGVybWluZSBpZiB0aGlzIHRhc2sgbmVlZHMgdG8gZ28gdG8gSEVBRF9PRl9RVUVVRSBmb3IgdGhlCisJICogc3RhdGUgbGlzdCBhcyB3ZWxsLiAgUnVubmluZyB3aXRoIFNBTSBUYXNrIEF0dHJpYnV0ZSBlbXVsYXRpb24KKwkgKiB3aWxsIGFsd2F5cyByZXR1cm4gaGVhZF9vZl9xdWV1ZSA9PSAwIGhlcmUKKwkgKi8KKwlpZiAoaGVhZF9vZl9xdWV1ZSkKKwkJbGlzdF9hZGQoJnRhc2stPnRfc3RhdGVfbGlzdCwgKHRhc2tfcHJldikgPworCQkJCSZ0YXNrX3ByZXYtPnRfc3RhdGVfbGlzdCA6CisJCQkJJmRldi0+c3RhdGVfdGFza19saXN0KTsKKwllbHNlCisJCWxpc3RfYWRkX3RhaWwoJnRhc2stPnRfc3RhdGVfbGlzdCwgJmRldi0+c3RhdGVfdGFza19saXN0KTsKKworCWF0b21pY19zZXQoJnRhc2stPnRhc2tfc3RhdGVfYWN0aXZlLCAxKTsKKworCURFQlVHX1RTVEFURSgiQWRkZWQgSVRUOiAweCUwOHggdGFza1slcF0gdG8gZGV2OiAlcFxuIiwKKwkJQ01EX1RGTyh0YXNrLT50YXNrX3NlX2NtZCktPmdldF90YXNrX3RhZyh0YXNrLT50YXNrX3NlX2NtZCksCisJCXRhc2ssIGRldik7Cit9CisKK3N0YXRpYyB2b2lkIHRyYW5zcG9ydF9hZGRfdGFza3NfdG9fc3RhdGVfcXVldWUoc3RydWN0IHNlX2NtZCAqY21kKQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldjsKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzazsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHRhc2ssICZUX1RBU0soY21kKS0+dF90YXNrX2xpc3QsIHRfbGlzdCkgeworCQlkZXYgPSB0YXNrLT5zZV9kZXY7CisKKwkJaWYgKGF0b21pY19yZWFkKCZ0YXNrLT50YXNrX3N0YXRlX2FjdGl2ZSkpCisJCQljb250aW51ZTsKKworCQlzcGluX2xvY2soJmRldi0+ZXhlY3V0ZV90YXNrX2xvY2spOworCQlsaXN0X2FkZF90YWlsKCZ0YXNrLT50X3N0YXRlX2xpc3QsICZkZXYtPnN0YXRlX3Rhc2tfbGlzdCk7CisJCWF0b21pY19zZXQoJnRhc2stPnRhc2tfc3RhdGVfYWN0aXZlLCAxKTsKKworCQlERUJVR19UU1RBVEUoIkFkZGVkIElUVDogMHglMDh4IHRhc2tbJXBdIHRvIGRldjogJXBcbiIsCisJCQlDTURfVEZPKHRhc2stPnRhc2tfc2VfY21kKS0+Z2V0X3Rhc2tfdGFnKAorCQkJdGFzay0+dGFza19zZV9jbWQpLCB0YXNrLCBkZXYpOworCisJCXNwaW5fdW5sb2NrKCZkZXYtPmV4ZWN1dGVfdGFza19sb2NrKTsKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworfQorCitzdGF0aWMgdm9pZCB0cmFuc3BvcnRfYWRkX3Rhc2tzX2Zyb21fY21kKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzaywgKnRhc2tfcHJldiA9IE5VTEw7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZkZXYtPmV4ZWN1dGVfdGFza19sb2NrLCBmbGFncyk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeSh0YXNrLCAmVF9UQVNLKGNtZCktPnRfdGFza19saXN0LCB0X2xpc3QpIHsKKwkJaWYgKGF0b21pY19yZWFkKCZ0YXNrLT50YXNrX2V4ZWN1dGVfcXVldWUpKQorCQkJY29udGludWU7CisJCS8qCisJCSAqIF9fdHJhbnNwb3J0X2FkZF90YXNrX3RvX2V4ZWN1dGVfcXVldWUoKSBoYW5kbGVzIHRoZQorCQkgKiBTQU0gVGFzayBBdHRyaWJ1dGUgZW11bGF0aW9uIGlmIGVuYWJsZWQKKwkJICovCisJCV9fdHJhbnNwb3J0X2FkZF90YXNrX3RvX2V4ZWN1dGVfcXVldWUodGFzaywgdGFza19wcmV2LCBkZXYpOworCQlhdG9taWNfc2V0KCZ0YXNrLT50YXNrX2V4ZWN1dGVfcXVldWUsIDEpOworCQl0YXNrX3ByZXYgPSB0YXNrOworCX0KKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXYtPmV4ZWN1dGVfdGFza19sb2NrLCBmbGFncyk7CisKKwlyZXR1cm47Cit9CisKKy8qCXRyYW5zcG9ydF9nZXRfdGFza19mcm9tX2V4ZWN1dGVfcXVldWUoKToKKyAqCisgKglDYWxsZWQgd2l0aCBkZXYtPmV4ZWN1dGVfdGFza19sb2NrIGhlbGQuCisgKi8KK3N0YXRpYyBzdHJ1Y3Qgc2VfdGFzayAqCit0cmFuc3BvcnRfZ2V0X3Rhc2tfZnJvbV9leGVjdXRlX3F1ZXVlKHN0cnVjdCBzZV9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzazsKKworCWlmIChsaXN0X2VtcHR5KCZkZXYtPmV4ZWN1dGVfdGFza19saXN0KSkKKwkJcmV0dXJuIE5VTEw7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHRhc2ssICZkZXYtPmV4ZWN1dGVfdGFza19saXN0LCB0X2V4ZWN1dGVfbGlzdCkKKwkJYnJlYWs7CisKKwlsaXN0X2RlbCgmdGFzay0+dF9leGVjdXRlX2xpc3QpOworCWF0b21pY19kZWMoJmRldi0+ZXhlY3V0ZV90YXNrcyk7CisKKwlyZXR1cm4gdGFzazsKK30KKworLyoJdHJhbnNwb3J0X3JlbW92ZV90YXNrX2Zyb21fZXhlY3V0ZV9xdWV1ZSgpOgorICoKKyAqCisgKi8KK3N0YXRpYyB2b2lkIHRyYW5zcG9ydF9yZW1vdmVfdGFza19mcm9tX2V4ZWN1dGVfcXVldWUoCisJc3RydWN0IHNlX3Rhc2sgKnRhc2ssCisJc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2LT5leGVjdXRlX3Rhc2tfbG9jaywgZmxhZ3MpOworCWxpc3RfZGVsKCZ0YXNrLT50X2V4ZWN1dGVfbGlzdCk7CisJYXRvbWljX2RlYygmZGV2LT5leGVjdXRlX3Rhc2tzKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXYtPmV4ZWN1dGVfdGFza19sb2NrLCBmbGFncyk7Cit9CisKK3Vuc2lnbmVkIGNoYXIgKnRyYW5zcG9ydF9kdW1wX2NtZF9kaXJlY3Rpb24oc3RydWN0IHNlX2NtZCAqY21kKQoreworCXN3aXRjaCAoY21kLT5kYXRhX2RpcmVjdGlvbikgeworCWNhc2UgRE1BX05PTkU6CisJCXJldHVybiAiTk9ORSI7CisJY2FzZSBETUFfRlJPTV9ERVZJQ0U6CisJCXJldHVybiAiUkVBRCI7CisJY2FzZSBETUFfVE9fREVWSUNFOgorCQlyZXR1cm4gIldSSVRFIjsKKwljYXNlIERNQV9CSURJUkVDVElPTkFMOgorCQlyZXR1cm4gIkJJREkiOworCWRlZmF1bHQ6CisJCWJyZWFrOworCX0KKworCXJldHVybiAiVU5LTk9XTiI7Cit9CisKK3ZvaWQgdHJhbnNwb3J0X2R1bXBfZGV2X3N0YXRlKAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwljaGFyICpiLAorCWludCAqYmwpCit7CisJKmJsICs9IHNwcmludGYoYiArICpibCwgIlN0YXR1czogIik7CisJc3dpdGNoIChkZXYtPmRldl9zdGF0dXMpIHsKKwljYXNlIFRSQU5TUE9SVF9ERVZJQ0VfQUNUSVZBVEVEOgorCQkqYmwgKz0gc3ByaW50ZihiICsgKmJsLCAiQUNUSVZBVEVEIik7CisJCWJyZWFrOworCWNhc2UgVFJBTlNQT1JUX0RFVklDRV9ERUFDVElWQVRFRDoKKwkJKmJsICs9IHNwcmludGYoYiArICpibCwgIkRFQUNUSVZBVEVEIik7CisJCWJyZWFrOworCWNhc2UgVFJBTlNQT1JUX0RFVklDRV9TSFVURE9XTjoKKwkJKmJsICs9IHNwcmludGYoYiArICpibCwgIlNIVVRET1dOIik7CisJCWJyZWFrOworCWNhc2UgVFJBTlNQT1JUX0RFVklDRV9PRkZMSU5FX0FDVElWQVRFRDoKKwljYXNlIFRSQU5TUE9SVF9ERVZJQ0VfT0ZGTElORV9ERUFDVElWQVRFRDoKKwkJKmJsICs9IHNwcmludGYoYiArICpibCwgIk9GRkxJTkUiKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJKmJsICs9IHNwcmludGYoYiArICpibCwgIlVOS05PV049JWQiLCBkZXYtPmRldl9zdGF0dXMpOworCQlicmVhazsKKwl9CisKKwkqYmwgKz0gc3ByaW50ZihiICsgKmJsLCAiICBFeGVjdXRlL0xlZnQvTWF4IFF1ZXVlIERlcHRoOiAlZC8lZC8lZCIsCisJCWF0b21pY19yZWFkKCZkZXYtPmV4ZWN1dGVfdGFza3MpLCBhdG9taWNfcmVhZCgmZGV2LT5kZXB0aF9sZWZ0KSwKKwkJZGV2LT5xdWV1ZV9kZXB0aCk7CisJKmJsICs9IHNwcmludGYoYiArICpibCwgIiAgU2VjdG9yU2l6ZTogJXUgIE1heFNlY3RvcnM6ICV1XG4iLAorCQlERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUsIERFVl9BVFRSSUIoZGV2KS0+bWF4X3NlY3RvcnMpOworCSpibCArPSBzcHJpbnRmKGIgKyAqYmwsICIgICAgICAgICIpOworfQorCisvKgl0cmFuc3BvcnRfcmVsZWFzZV9hbGxfY21kcygpOgorICoKKyAqCisgKi8KK3N0YXRpYyB2b2lkIHRyYW5zcG9ydF9yZWxlYXNlX2FsbF9jbWRzKHN0cnVjdCBzZV9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3Qgc2VfY21kICpjbWQgPSBOVUxMOworCXN0cnVjdCBzZV9xdWV1ZV9yZXEgKnFyID0gTlVMTCwgKnFyX3AgPSBOVUxMOworCWludCBidWdfb3V0ID0gMCwgdF9zdGF0ZTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmRldi0+ZGV2X3F1ZXVlX29iai0+Y21kX3F1ZXVlX2xvY2ssIGZsYWdzKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocXIsIHFyX3AsICZkZXYtPmRldl9xdWV1ZV9vYmotPnFvYmpfbGlzdCwKKwkJCQlxcl9saXN0KSB7CisKKwkJY21kID0gKHN0cnVjdCBzZV9jbWQgKilxci0+Y21kOworCQl0X3N0YXRlID0gcXItPnN0YXRlOworCQlsaXN0X2RlbCgmcXItPnFyX2xpc3QpOworCQlrZnJlZShxcik7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRldi0+ZGV2X3F1ZXVlX29iai0+Y21kX3F1ZXVlX2xvY2ssCisJCQkJZmxhZ3MpOworCisJCXByaW50ayhLRVJOX0VSUiAiUmVsZWFzaW5nIElUVDogMHglMDh4LCBpX3N0YXRlOiAldSwiCisJCQkiIHRfc3RhdGU6ICV1IGRpcmVjdGx5XG4iLAorCQkJQ01EX1RGTyhjbWQpLT5nZXRfdGFza190YWcoY21kKSwKKwkJCUNNRF9URk8oY21kKS0+Z2V0X2NtZF9zdGF0ZShjbWQpLCB0X3N0YXRlKTsKKworCQl0cmFuc3BvcnRfcmVsZWFzZV9mZV9jbWQoY21kKTsKKwkJYnVnX291dCA9IDE7CisKKwkJc3Bpbl9sb2NrX2lycXNhdmUoJmRldi0+ZGV2X3F1ZXVlX29iai0+Y21kX3F1ZXVlX2xvY2ssIGZsYWdzKTsKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGV2LT5kZXZfcXVldWVfb2JqLT5jbWRfcXVldWVfbG9jaywgZmxhZ3MpOworI2lmIDAKKwlpZiAoYnVnX291dCkKKwkJQlVHKCk7CisjZW5kaWYKK30KKwordm9pZCB0cmFuc3BvcnRfZHVtcF92cGRfcHJvdG9faWQoCisJc3RydWN0IHQxMF92cGQgKnZwZCwKKwl1bnNpZ25lZCBjaGFyICpwX2J1ZiwKKwlpbnQgcF9idWZfbGVuKQoreworCXVuc2lnbmVkIGNoYXIgYnVmW1ZQRF9UTVBfQlVGX1NJWkVdOworCWludCBsZW47CisKKwltZW1zZXQoYnVmLCAwLCBWUERfVE1QX0JVRl9TSVpFKTsKKwlsZW4gPSBzcHJpbnRmKGJ1ZiwgIlQxMCBWUEQgUHJvdG9jb2wgSWRlbnRpZmllcjogIik7CisKKwlzd2l0Y2ggKHZwZC0+cHJvdG9jb2xfaWRlbnRpZmllcikgeworCWNhc2UgMHgwMDoKKwkJc3ByaW50ZihidWYrbGVuLCAiRmlicmUgQ2hhbm5lbFxuIik7CisJCWJyZWFrOworCWNhc2UgMHgxMDoKKwkJc3ByaW50ZihidWYrbGVuLCAiUGFyYWxsZWwgU0NTSVxuIik7CisJCWJyZWFrOworCWNhc2UgMHgyMDoKKwkJc3ByaW50ZihidWYrbGVuLCAiU1NBXG4iKTsKKwkJYnJlYWs7CisJY2FzZSAweDMwOgorCQlzcHJpbnRmKGJ1ZitsZW4sICJJRUVFIDEzOTRcbiIpOworCQlicmVhazsKKwljYXNlIDB4NDA6CisJCXNwcmludGYoYnVmK2xlbiwgIlNDU0kgUmVtb3RlIERpcmVjdCBNZW1vcnkgQWNjZXNzIgorCQkJCSIgUHJvdG9jb2xcbiIpOworCQlicmVhazsKKwljYXNlIDB4NTA6CisJCXNwcmludGYoYnVmK2xlbiwgIkludGVybmV0IFNDU0kgKGlTQ1NJKVxuIik7CisJCWJyZWFrOworCWNhc2UgMHg2MDoKKwkJc3ByaW50ZihidWYrbGVuLCAiU0FTIFNlcmlhbCBTQ1NJIFByb3RvY29sXG4iKTsKKwkJYnJlYWs7CisJY2FzZSAweDcwOgorCQlzcHJpbnRmKGJ1ZitsZW4sICJBdXRvbWF0aW9uL0RyaXZlIEludGVyZmFjZSBUcmFuc3BvcnQiCisJCQkJIiBQcm90b2NvbFxuIik7CisJCWJyZWFrOworCWNhc2UgMHg4MDoKKwkJc3ByaW50ZihidWYrbGVuLCAiQVQgQXR0YWNobWVudCBJbnRlcmZhY2UgQVRBL0FUQVBJXG4iKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJc3ByaW50ZihidWYrbGVuLCAiVW5rbm93biAweCUwMnhcbiIsCisJCQkJdnBkLT5wcm90b2NvbF9pZGVudGlmaWVyKTsKKwkJYnJlYWs7CisJfQorCisJaWYgKHBfYnVmKQorCQlzdHJuY3B5KHBfYnVmLCBidWYsIHBfYnVmX2xlbik7CisJZWxzZQorCQlwcmludGsoS0VSTl9JTkZPICIlcyIsIGJ1Zik7Cit9CisKK3ZvaWQKK3RyYW5zcG9ydF9zZXRfdnBkX3Byb3RvX2lkKHN0cnVjdCB0MTBfdnBkICp2cGQsIHVuc2lnbmVkIGNoYXIgKnBhZ2VfODMpCit7CisJLyoKKwkgKiBDaGVjayBpZiB0aGUgUHJvdG9jb2wgSWRlbnRpZmllciBWYWxpZCAoUElWKSBiaXQgaXMgc2V0Li4KKwkgKgorCSAqIGZyb20gc3BjM3IyMy5wZGYgc2VjdGlvbiA3LjUuMQorCSAqLworCSBpZiAocGFnZV84M1sxXSAmIDB4ODApIHsKKwkJdnBkLT5wcm90b2NvbF9pZGVudGlmaWVyID0gKHBhZ2VfODNbMF0gJiAweGYwKTsKKwkJdnBkLT5wcm90b2NvbF9pZGVudGlmaWVyX3NldCA9IDE7CisJCXRyYW5zcG9ydF9kdW1wX3ZwZF9wcm90b19pZCh2cGQsIE5VTEwsIDApOworCX0KK30KK0VYUE9SVF9TWU1CT0wodHJhbnNwb3J0X3NldF92cGRfcHJvdG9faWQpOworCitpbnQgdHJhbnNwb3J0X2R1bXBfdnBkX2Fzc29jKAorCXN0cnVjdCB0MTBfdnBkICp2cGQsCisJdW5zaWduZWQgY2hhciAqcF9idWYsCisJaW50IHBfYnVmX2xlbikKK3sKKwl1bnNpZ25lZCBjaGFyIGJ1ZltWUERfVE1QX0JVRl9TSVpFXTsKKwlpbnQgcmV0ID0gMCwgbGVuOworCisJbWVtc2V0KGJ1ZiwgMCwgVlBEX1RNUF9CVUZfU0laRSk7CisJbGVuID0gc3ByaW50ZihidWYsICJUMTAgVlBEIElkZW50aWZpZXIgQXNzb2NpYXRpb246ICIpOworCisJc3dpdGNoICh2cGQtPmFzc29jaWF0aW9uKSB7CisJY2FzZSAweDAwOgorCQlzcHJpbnRmKGJ1ZitsZW4sICJhZGRyZXNzZWQgbG9naWNhbCB1bml0XG4iKTsKKwkJYnJlYWs7CisJY2FzZSAweDEwOgorCQlzcHJpbnRmKGJ1ZitsZW4sICJ0YXJnZXQgcG9ydFxuIik7CisJCWJyZWFrOworCWNhc2UgMHgyMDoKKwkJc3ByaW50ZihidWYrbGVuLCAiU0NTSSB0YXJnZXQgZGV2aWNlXG4iKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJc3ByaW50ZihidWYrbGVuLCAiVW5rbm93biAweCUwMnhcbiIsIHZwZC0+YXNzb2NpYXRpb24pOworCQlyZXQgPSAtMTsKKwkJYnJlYWs7CisJfQorCisJaWYgKHBfYnVmKQorCQlzdHJuY3B5KHBfYnVmLCBidWYsIHBfYnVmX2xlbik7CisJZWxzZQorCQlwcmludGsoIiVzIiwgYnVmKTsKKworCXJldHVybiByZXQ7Cit9CisKK2ludCB0cmFuc3BvcnRfc2V0X3ZwZF9hc3NvYyhzdHJ1Y3QgdDEwX3ZwZCAqdnBkLCB1bnNpZ25lZCBjaGFyICpwYWdlXzgzKQoreworCS8qCisJICogVGhlIFZQRCBpZGVudGlmaWNhdGlvbiBhc3NvY2lhdGlvbi4uCisJICoKKwkgKiBmcm9tIHNwYzNyMjMucGRmIFNlY3Rpb24gNy42LjMuMSBUYWJsZSAyOTcKKwkgKi8KKwl2cGQtPmFzc29jaWF0aW9uID0gKHBhZ2VfODNbMV0gJiAweDMwKTsKKwlyZXR1cm4gdHJhbnNwb3J0X2R1bXBfdnBkX2Fzc29jKHZwZCwgTlVMTCwgMCk7Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9zZXRfdnBkX2Fzc29jKTsKKworaW50IHRyYW5zcG9ydF9kdW1wX3ZwZF9pZGVudF90eXBlKAorCXN0cnVjdCB0MTBfdnBkICp2cGQsCisJdW5zaWduZWQgY2hhciAqcF9idWYsCisJaW50IHBfYnVmX2xlbikKK3sKKwl1bnNpZ25lZCBjaGFyIGJ1ZltWUERfVE1QX0JVRl9TSVpFXTsKKwlpbnQgcmV0ID0gMCwgbGVuOworCisJbWVtc2V0KGJ1ZiwgMCwgVlBEX1RNUF9CVUZfU0laRSk7CisJbGVuID0gc3ByaW50ZihidWYsICJUMTAgVlBEIElkZW50aWZpZXIgVHlwZTogIik7CisKKwlzd2l0Y2ggKHZwZC0+ZGV2aWNlX2lkZW50aWZpZXJfdHlwZSkgeworCWNhc2UgMHgwMDoKKwkJc3ByaW50ZihidWYrbGVuLCAiVmVuZG9yIHNwZWNpZmljXG4iKTsKKwkJYnJlYWs7CisJY2FzZSAweDAxOgorCQlzcHJpbnRmKGJ1ZitsZW4sICJUMTAgVmVuZG9yIElEIGJhc2VkXG4iKTsKKwkJYnJlYWs7CisJY2FzZSAweDAyOgorCQlzcHJpbnRmKGJ1ZitsZW4sICJFVUktNjQgYmFzZWRcbiIpOworCQlicmVhazsKKwljYXNlIDB4MDM6CisJCXNwcmludGYoYnVmK2xlbiwgIk5BQVxuIik7CisJCWJyZWFrOworCWNhc2UgMHgwNDoKKwkJc3ByaW50ZihidWYrbGVuLCAiUmVsYXRpdmUgdGFyZ2V0IHBvcnQgaWRlbnRpZmllclxuIik7CisJCWJyZWFrOworCWNhc2UgMHgwODoKKwkJc3ByaW50ZihidWYrbGVuLCAiU0NTSSBuYW1lIHN0cmluZ1xuIik7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXNwcmludGYoYnVmK2xlbiwgIlVuc3VwcG9ydGVkOiAweCUwMnhcbiIsCisJCQkJdnBkLT5kZXZpY2VfaWRlbnRpZmllcl90eXBlKTsKKwkJcmV0ID0gLTE7CisJCWJyZWFrOworCX0KKworCWlmIChwX2J1ZikKKwkJc3RybmNweShwX2J1ZiwgYnVmLCBwX2J1Zl9sZW4pOworCWVsc2UKKwkJcHJpbnRrKCIlcyIsIGJ1Zik7CisKKwlyZXR1cm4gcmV0OworfQorCitpbnQgdHJhbnNwb3J0X3NldF92cGRfaWRlbnRfdHlwZShzdHJ1Y3QgdDEwX3ZwZCAqdnBkLCB1bnNpZ25lZCBjaGFyICpwYWdlXzgzKQoreworCS8qCisJICogVGhlIFZQRCBpZGVudGlmaWVyIHR5cGUuLgorCSAqCisJICogZnJvbSBzcGMzcjIzLnBkZiBTZWN0aW9uIDcuNi4zLjEgVGFibGUgMjk4CisJICovCisJdnBkLT5kZXZpY2VfaWRlbnRpZmllcl90eXBlID0gKHBhZ2VfODNbMV0gJiAweDBmKTsKKwlyZXR1cm4gdHJhbnNwb3J0X2R1bXBfdnBkX2lkZW50X3R5cGUodnBkLCBOVUxMLCAwKTsKK30KK0VYUE9SVF9TWU1CT0wodHJhbnNwb3J0X3NldF92cGRfaWRlbnRfdHlwZSk7CisKK2ludCB0cmFuc3BvcnRfZHVtcF92cGRfaWRlbnQoCisJc3RydWN0IHQxMF92cGQgKnZwZCwKKwl1bnNpZ25lZCBjaGFyICpwX2J1ZiwKKwlpbnQgcF9idWZfbGVuKQoreworCXVuc2lnbmVkIGNoYXIgYnVmW1ZQRF9UTVBfQlVGX1NJWkVdOworCWludCByZXQgPSAwOworCisJbWVtc2V0KGJ1ZiwgMCwgVlBEX1RNUF9CVUZfU0laRSk7CisKKwlzd2l0Y2ggKHZwZC0+ZGV2aWNlX2lkZW50aWZpZXJfY29kZV9zZXQpIHsKKwljYXNlIDB4MDE6IC8qIEJpbmFyeSAqLworCQlzcHJpbnRmKGJ1ZiwgIlQxMCBWUEQgQmluYXJ5IERldmljZSBJZGVudGlmaWVyOiAlc1xuIiwKKwkJCSZ2cGQtPmRldmljZV9pZGVudGlmaWVyWzBdKTsKKwkJYnJlYWs7CisJY2FzZSAweDAyOiAvKiBBU0NJSSAqLworCQlzcHJpbnRmKGJ1ZiwgIlQxMCBWUEQgQVNDSUkgRGV2aWNlIElkZW50aWZpZXI6ICVzXG4iLAorCQkJJnZwZC0+ZGV2aWNlX2lkZW50aWZpZXJbMF0pOworCQlicmVhazsKKwljYXNlIDB4MDM6IC8qIFVURi04ICovCisJCXNwcmludGYoYnVmLCAiVDEwIFZQRCBVVEYtOCBEZXZpY2UgSWRlbnRpZmllcjogJXNcbiIsCisJCQkmdnBkLT5kZXZpY2VfaWRlbnRpZmllclswXSk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXNwcmludGYoYnVmLCAiVDEwIFZQRCBEZXZpY2UgSWRlbnRpZmllciBlbmNvZGluZyB1bnN1cHBvcnRlZDoiCisJCQkiIDB4JTAyeCIsIHZwZC0+ZGV2aWNlX2lkZW50aWZpZXJfY29kZV9zZXQpOworCQlyZXQgPSAtMTsKKwkJYnJlYWs7CisJfQorCisJaWYgKHBfYnVmKQorCQlzdHJuY3B5KHBfYnVmLCBidWYsIHBfYnVmX2xlbik7CisJZWxzZQorCQlwcmludGsoIiVzIiwgYnVmKTsKKworCXJldHVybiByZXQ7Cit9CisKK2ludAordHJhbnNwb3J0X3NldF92cGRfaWRlbnQoc3RydWN0IHQxMF92cGQgKnZwZCwgdW5zaWduZWQgY2hhciAqcGFnZV84MykKK3sKKwlzdGF0aWMgY29uc3QgY2hhciBoZXhfc3RyW10gPSAiMDEyMzQ1Njc4OWFiY2RlZiI7CisJaW50IGogPSAwLCBpID0gNDsgLyogb2Zmc2V0IHRvIHN0YXJ0IG9mIHRoZSBpZGVudGlmZXIgKi8KKworCS8qCisJICogVGhlIFZQRCBDb2RlIFNldCAoZW5jb2RpbmcpCisJICoKKwkgKiBmcm9tIHNwYzNyMjMucGRmIFNlY3Rpb24gNy42LjMuMSBUYWJsZSAyOTYKKwkgKi8KKwl2cGQtPmRldmljZV9pZGVudGlmaWVyX2NvZGVfc2V0ID0gKHBhZ2VfODNbMF0gJiAweDBmKTsKKwlzd2l0Y2ggKHZwZC0+ZGV2aWNlX2lkZW50aWZpZXJfY29kZV9zZXQpIHsKKwljYXNlIDB4MDE6IC8qIEJpbmFyeSAqLworCQl2cGQtPmRldmljZV9pZGVudGlmaWVyW2orK10gPQorCQkJCWhleF9zdHJbdnBkLT5kZXZpY2VfaWRlbnRpZmllcl90eXBlXTsKKwkJd2hpbGUgKGkgPCAoNCArIHBhZ2VfODNbM10pKSB7CisJCQl2cGQtPmRldmljZV9pZGVudGlmaWVyW2orK10gPQorCQkJCWhleF9zdHJbKHBhZ2VfODNbaV0gJiAweGYwKSA+PiA0XTsKKwkJCXZwZC0+ZGV2aWNlX2lkZW50aWZpZXJbaisrXSA9CisJCQkJaGV4X3N0cltwYWdlXzgzW2ldICYgMHgwZl07CisJCQlpKys7CisJCX0KKwkJYnJlYWs7CisJY2FzZSAweDAyOiAvKiBBU0NJSSAqLworCWNhc2UgMHgwMzogLyogVVRGLTggKi8KKwkJd2hpbGUgKGkgPCAoNCArIHBhZ2VfODNbM10pKQorCQkJdnBkLT5kZXZpY2VfaWRlbnRpZmllcltqKytdID0gcGFnZV84M1tpKytdOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlicmVhazsKKwl9CisKKwlyZXR1cm4gdHJhbnNwb3J0X2R1bXBfdnBkX2lkZW50KHZwZCwgTlVMTCwgMCk7Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9zZXRfdnBkX2lkZW50KTsKKworc3RhdGljIHZvaWQgY29yZV9zZXR1cF90YXNrX2F0dHJfZW11bGF0aW9uKHN0cnVjdCBzZV9kZXZpY2UgKmRldikKK3sKKwkvKgorCSAqIElmIHRoaXMgZGV2aWNlIGlzIGZyb20gVGFyZ2V0X0NvcmVfTW9kL3BTQ1NJLCBkaXNhYmxlIHRoZQorCSAqIFNBTSBUYXNrIEF0dHJpYnV0ZSBlbXVsYXRpb24uCisJICoKKwkgKiBUaGlzIGlzIGN1cnJlbnRseSBub3QgYXZhaWxhYmxlIGluIHVwc3JlYW0gTGludXgvU0NTSSBUYXJnZXQKKwkgKiBtb2RlIGNvZGUsIGFuZCBpcyBhc3N1bWVkIHRvIGJlIGRpc2FibGVkIHdoaWxlIHVzaW5nIFRDTS9wU0NTSS4KKwkgKi8KKwlpZiAoVFJBTlNQT1JUKGRldiktPnRyYW5zcG9ydF90eXBlID09IFRSQU5TUE9SVF9QTFVHSU5fUEhCQV9QREVWKSB7CisJCWRldi0+ZGV2X3Rhc2tfYXR0cl90eXBlID0gU0FNX1RBU0tfQVRUUl9QQVNTVEhST1VHSDsKKwkJcmV0dXJuOworCX0KKworCWRldi0+ZGV2X3Rhc2tfYXR0cl90eXBlID0gU0FNX1RBU0tfQVRUUl9FTVVMQVRFRDsKKwlERUJVR19TVEEoIiVzOiBVc2luZyBTQU1fVEFTS19BVFRSX0VNVUxBVEVEIGZvciBTUEM6IDB4JTAyeCIKKwkJIiBkZXZpY2VcbiIsIFRSQU5TUE9SVChkZXYpLT5uYW1lLAorCQlUUkFOU1BPUlQoZGV2KS0+Z2V0X2RldmljZV9yZXYoZGV2KSk7Cit9CisKK3N0YXRpYyB2b2lkIHNjc2lfZHVtcF9pbnF1aXJ5KHN0cnVjdCBzZV9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgdDEwX3d3biAqd3duID0gREVWX1QxMF9XV04oZGV2KTsKKwlpbnQgaSwgZGV2aWNlX3R5cGU7CisJLyoKKwkgKiBQcmludCBMaW51eC9TQ1NJIHN0eWxlIElOUVVJUlkgZm9ybWF0dGluZyB0byB0aGUga2VybmVsIHJpbmcgYnVmZmVyCisJICovCisJcHJpbnRrKCIgIFZlbmRvcjogIik7CisJZm9yIChpID0gMDsgaSA8IDg7IGkrKykKKwkJaWYgKHd3bi0+dmVuZG9yW2ldID49IDB4MjApCisJCQlwcmludGsoIiVjIiwgd3duLT52ZW5kb3JbaV0pOworCQllbHNlCisJCQlwcmludGsoIiAiKTsKKworCXByaW50aygiICBNb2RlbDogIik7CisJZm9yIChpID0gMDsgaSA8IDE2OyBpKyspCisJCWlmICh3d24tPm1vZGVsW2ldID49IDB4MjApCisJCQlwcmludGsoIiVjIiwgd3duLT5tb2RlbFtpXSk7CisJCWVsc2UKKwkJCXByaW50aygiICIpOworCisJcHJpbnRrKCIgIFJldmlzaW9uOiAiKTsKKwlmb3IgKGkgPSAwOyBpIDwgNDsgaSsrKQorCQlpZiAod3duLT5yZXZpc2lvbltpXSA+PSAweDIwKQorCQkJcHJpbnRrKCIlYyIsIHd3bi0+cmV2aXNpb25baV0pOworCQllbHNlCisJCQlwcmludGsoIiAiKTsKKworCXByaW50aygiXG4iKTsKKworCWRldmljZV90eXBlID0gVFJBTlNQT1JUKGRldiktPmdldF9kZXZpY2VfdHlwZShkZXYpOworCXByaW50aygiICBUeXBlOiAgICVzICIsIHNjc2lfZGV2aWNlX3R5cGUoZGV2aWNlX3R5cGUpKTsKKwlwcmludGsoIiAgICAgICAgICAgICAgICAgQU5TSSBTQ1NJIHJldmlzaW9uOiAlMDJ4XG4iLAorCQkJCVRSQU5TUE9SVChkZXYpLT5nZXRfZGV2aWNlX3JldihkZXYpKTsKK30KKworc3RydWN0IHNlX2RldmljZSAqdHJhbnNwb3J0X2FkZF9kZXZpY2VfdG9fY29yZV9oYmEoCisJc3RydWN0IHNlX2hiYSAqaGJhLAorCXN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpICp0cmFuc3BvcnQsCisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnNlX2RldiwKKwl1MzIgZGV2aWNlX2ZsYWdzLAorCXZvaWQgKnRyYW5zcG9ydF9kZXYsCisJc3RydWN0IHNlX2Rldl9saW1pdHMgKmRldl9saW1pdHMsCisJY29uc3QgY2hhciAqaW5xdWlyeV9wcm9kLAorCWNvbnN0IGNoYXIgKmlucXVpcnlfcmV2KQoreworCWludCByZXQgPSAwLCBmb3JjZV9wdDsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICAqZGV2OworCisJZGV2ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHNlX2RldmljZSksIEdGUF9LRVJORUwpOworCWlmICghKGRldikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgbWVtb3J5IGZvciBzZV9kZXZfdFxuIik7CisJCXJldHVybiBOVUxMOworCX0KKwlkZXYtPmRldl9xdWV1ZV9vYmogPSBremFsbG9jKHNpemVvZihzdHJ1Y3Qgc2VfcXVldWVfb2JqKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCEoZGV2LT5kZXZfcXVldWVfb2JqKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIgorCQkJCSIgZGV2LT5kZXZfcXVldWVfb2JqXG4iKTsKKwkJa2ZyZWUoZGV2KTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCXRyYW5zcG9ydF9pbml0X3F1ZXVlX29iaihkZXYtPmRldl9xdWV1ZV9vYmopOworCisJZGV2LT5kZXZfc3RhdHVzX3F1ZXVlX29iaiA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBzZV9xdWV1ZV9vYmopLAorCQkJCQlHRlBfS0VSTkVMKTsKKwlpZiAoIShkZXYtPmRldl9zdGF0dXNfcXVldWVfb2JqKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIgorCQkJCSIgZGV2LT5kZXZfc3RhdHVzX3F1ZXVlX29ialxuIik7CisJCWtmcmVlKGRldi0+ZGV2X3F1ZXVlX29iaik7CisJCWtmcmVlKGRldik7CisJCXJldHVybiBOVUxMOworCX0KKwl0cmFuc3BvcnRfaW5pdF9xdWV1ZV9vYmooZGV2LT5kZXZfc3RhdHVzX3F1ZXVlX29iaik7CisKKwlkZXYtPmRldl9mbGFncwkJPSBkZXZpY2VfZmxhZ3M7CisJZGV2LT5kZXZfc3RhdHVzCQl8PSBUUkFOU1BPUlRfREVWSUNFX0RFQUNUSVZBVEVEOworCWRldi0+ZGV2X3B0cgkJPSAodm9pZCAqKSB0cmFuc3BvcnRfZGV2OworCWRldi0+c2VfaGJhCQk9IGhiYTsKKwlkZXYtPnNlX3N1Yl9kZXYJCT0gc2VfZGV2OworCWRldi0+dHJhbnNwb3J0CQk9IHRyYW5zcG9ydDsKKwlhdG9taWNfc2V0KCZkZXYtPmFjdGl2ZV9jbWRzLCAwKTsKKwlJTklUX0xJU1RfSEVBRCgmZGV2LT5kZXZfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJmRldi0+ZGV2X3NlcF9saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmZGV2LT5kZXZfdG1yX2xpc3QpOworCUlOSVRfTElTVF9IRUFEKCZkZXYtPmV4ZWN1dGVfdGFza19saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmZGV2LT5kZWxheWVkX2NtZF9saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmZGV2LT5vcmRlcmVkX2NtZF9saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmZGV2LT5zdGF0ZV90YXNrX2xpc3QpOworCXNwaW5fbG9ja19pbml0KCZkZXYtPmV4ZWN1dGVfdGFza19sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmZGV2LT5kZWxheWVkX2NtZF9sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmZGV2LT5vcmRlcmVkX2NtZF9sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmZGV2LT5zdGF0ZV90YXNrX2xvY2spOworCXNwaW5fbG9ja19pbml0KCZkZXYtPmRldl9hbHVhX2xvY2spOworCXNwaW5fbG9ja19pbml0KCZkZXYtPmRldl9yZXNlcnZhdGlvbl9sb2NrKTsKKwlzcGluX2xvY2tfaW5pdCgmZGV2LT5kZXZfc3RhdHVzX2xvY2spOworCXNwaW5fbG9ja19pbml0KCZkZXYtPmRldl9zdGF0dXNfdGhyX2xvY2spOworCXNwaW5fbG9ja19pbml0KCZkZXYtPnNlX3BvcnRfbG9jayk7CisJc3Bpbl9sb2NrX2luaXQoJmRldi0+c2VfdG1yX2xvY2spOworCisJZGV2LT5xdWV1ZV9kZXB0aAk9IGRldl9saW1pdHMtPnF1ZXVlX2RlcHRoOworCWF0b21pY19zZXQoJmRldi0+ZGVwdGhfbGVmdCwgZGV2LT5xdWV1ZV9kZXB0aCk7CisJYXRvbWljX3NldCgmZGV2LT5kZXZfb3JkZXJlZF9pZCwgMCk7CisKKwlzZV9kZXZfc2V0X2RlZmF1bHRfYXR0cmlicyhkZXYsIGRldl9saW1pdHMpOworCisJZGV2LT5kZXZfaW5kZXggPSBzY3NpX2dldF9uZXdfaW5kZXgoU0NTSV9ERVZJQ0VfSU5ERVgpOworCWRldi0+Y3JlYXRpb25fdGltZSA9IGdldF9qaWZmaWVzXzY0KCk7CisJc3Bpbl9sb2NrX2luaXQoJmRldi0+c3RhdHNfbG9jayk7CisKKwlzcGluX2xvY2soJmhiYS0+ZGV2aWNlX2xvY2spOworCWxpc3RfYWRkX3RhaWwoJmRldi0+ZGV2X2xpc3QsICZoYmEtPmhiYV9kZXZfbGlzdCk7CisJaGJhLT5kZXZfY291bnQrKzsKKwlzcGluX3VubG9jaygmaGJhLT5kZXZpY2VfbG9jayk7CisJLyoKKwkgKiBTZXR1cCB0aGUgU0FNIFRhc2sgQXR0cmlidXRlIGVtdWxhdGlvbiBmb3Igc3RydWN0IHNlX2RldmljZQorCSAqLworCWNvcmVfc2V0dXBfdGFza19hdHRyX2VtdWxhdGlvbihkZXYpOworCS8qCisJICogRm9yY2UgUFIgYW5kIEFMVUEgcGFzc3Rocm91Z2ggZW11bGF0aW9uIHdpdGggaW50ZXJuYWwgb2JqZWN0IHVzZS4KKwkgKi8KKwlmb3JjZV9wdCA9IChoYmEtPmhiYV9mbGFncyAmIEhCQV9GTEFHU19JTlRFUk5BTF9VU0UpOworCS8qCisJICogU2V0dXAgdGhlIFJlc2VydmF0aW9ucyBpbmZyYXN0cnVjdHVyZSBmb3Igc3RydWN0IHNlX2RldmljZQorCSAqLworCWNvcmVfc2V0dXBfcmVzZXJ2YXRpb25zKGRldiwgZm9yY2VfcHQpOworCS8qCisJICogU2V0dXAgdGhlIEFzeW1tZXRyaWMgTG9naWNhbCBVbml0IEFzc2lnbm1lbnQgZm9yIHN0cnVjdCBzZV9kZXZpY2UKKwkgKi8KKwlpZiAoY29yZV9zZXR1cF9hbHVhKGRldiwgZm9yY2VfcHQpIDwgMCkKKwkJZ290byBvdXQ7CisKKwkvKgorCSAqIFN0YXJ0dXAgdGhlIHN0cnVjdCBzZV9kZXZpY2UgcHJvY2Vzc2luZyB0aHJlYWQKKwkgKi8KKwlkZXYtPnByb2Nlc3NfdGhyZWFkID0ga3RocmVhZF9ydW4odHJhbnNwb3J0X3Byb2Nlc3NpbmdfdGhyZWFkLCBkZXYsCisJCQkJCSAgIkxJT18lcyIsIFRSQU5TUE9SVChkZXYpLT5uYW1lKTsKKwlpZiAoSVNfRVJSKGRldi0+cHJvY2Vzc190aHJlYWQpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGNyZWF0ZSBrdGhyZWFkOiBMSU9fJXNcbiIsCisJCQlUUkFOU1BPUlQoZGV2KS0+bmFtZSk7CisJCWdvdG8gb3V0OworCX0KKworCS8qCisJICogUHJlbG9hZCB0aGUgaW5pdGlhbCBJTlFVSVJZIGNvbnN0IHZhbHVlcyBpZiB3ZSBhcmUgZG9pbmcKKwkgKiBhbnl0aGluZyB2aXJ0dWFsIChJQkxPQ0ssIEZJTEVJTywgUkFNRElTSyksIGJ1dCBub3QgZm9yIFRDTS9wU0NTSQorCSAqIHBhc3N0aHJvdWdoIGJlY2F1c2UgdGhpcyBpcyBiZWluZyBwcm92aWRlZCBieSB0aGUgYmFja2VuZCBMTEQuCisJICogVGhpcyBpcyByZXF1aXJlZCBzbyB0aGF0IHRyYW5zcG9ydF9nZXRfaW5xdWlyeSgpIGNvcGllcyB0aGVzZQorCSAqIG9yaWdpbmFscyBvbmNlIGJhY2sgaW50byBERVZfVDEwX1dXTihkZXYpIGZvciB0aGUgdmlydHVhbCBkZXZpY2UKKwkgKiBzZXR1cC4KKwkgKi8KKwlpZiAoVFJBTlNQT1JUKGRldiktPnRyYW5zcG9ydF90eXBlICE9IFRSQU5TUE9SVF9QTFVHSU5fUEhCQV9QREVWKSB7CisJCWlmICghKGlucXVpcnlfcHJvZCkgfHwgIShpbnF1aXJ5X3Byb2QpKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIkFsbCBub24gVENNL3BTQ1NJIHBsdWdpbnMgcmVxdWlyZSIKKwkJCQkiIElOUVVJUlkgY29uc3RzXG4iKTsKKwkJCWdvdG8gb3V0OworCQl9CisKKwkJc3RybmNweSgmREVWX1QxMF9XV04oZGV2KS0+dmVuZG9yWzBdLCAiTElPLU9SRyIsIDgpOworCQlzdHJuY3B5KCZERVZfVDEwX1dXTihkZXYpLT5tb2RlbFswXSwgaW5xdWlyeV9wcm9kLCAxNik7CisJCXN0cm5jcHkoJkRFVl9UMTBfV1dOKGRldiktPnJldmlzaW9uWzBdLCBpbnF1aXJ5X3JldiwgNCk7CisJfQorCXNjc2lfZHVtcF9pbnF1aXJ5KGRldik7CisKK291dDoKKwlpZiAoIXJldCkKKwkJcmV0dXJuIGRldjsKKwlrdGhyZWFkX3N0b3AoZGV2LT5wcm9jZXNzX3RocmVhZCk7CisKKwlzcGluX2xvY2soJmhiYS0+ZGV2aWNlX2xvY2spOworCWxpc3RfZGVsKCZkZXYtPmRldl9saXN0KTsKKwloYmEtPmRldl9jb3VudC0tOworCXNwaW5fdW5sb2NrKCZoYmEtPmRldmljZV9sb2NrKTsKKworCXNlX3JlbGVhc2VfdnBkX2Zvcl9kZXYoZGV2KTsKKworCWtmcmVlKGRldi0+ZGV2X3N0YXR1c19xdWV1ZV9vYmopOworCWtmcmVlKGRldi0+ZGV2X3F1ZXVlX29iaik7CisJa2ZyZWUoZGV2KTsKKworCXJldHVybiBOVUxMOworfQorRVhQT1JUX1NZTUJPTCh0cmFuc3BvcnRfYWRkX2RldmljZV90b19jb3JlX2hiYSk7CisKKy8qCXRyYW5zcG9ydF9nZW5lcmljX3ByZXBhcmVfY2RiKCk6CisgKgorICoJU2luY2UgdGhlIEluaXRpYXRvciBzZWVzIGlTQ1NJIGRldmljZXMgYXMgTFVOcywgIHRoZSBTQ1NJIENEQiB3aWxsCisgKgljb250YWluIHRoZSBpU0NTSSBMVU4gaW4gYml0cyA3LTUgb2YgYnl0ZSAxIGFzIHBlciBTQU0tMi4KKyAqCVRoZSBwb2ludCBvZiB0aGlzIGlzIHNpbmNlIHdlIGFyZSBtYXBwaW5nIGlTQ1NJIExVTnMgdG8KKyAqCVNDU0kgVGFyZ2V0IElEcyBoYXZpbmcgYSBub24temVybyBMVU4gaW4gdGhlIENEQiB3aWxsIHRocm93IHRoZQorICoJZGV2aWNlcyBhbmQgSEJBcyBmb3IgYSBsb29wLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgdHJhbnNwb3J0X2dlbmVyaWNfcHJlcGFyZV9jZGIoCisJdW5zaWduZWQgY2hhciAqY2RiKQoreworCXN3aXRjaCAoY2RiWzBdKSB7CisJY2FzZSBSRUFEXzEwOiAvKiBTQkMgLSBSRFByb3RlY3QgKi8KKwljYXNlIFJFQURfMTI6IC8qIFNCQyAtIFJEUHJvdGVjdCAqLworCWNhc2UgUkVBRF8xNjogLyogU0JDIC0gUkRQcm90ZWN0ICovCisJY2FzZSBTRU5EX0RJQUdOT1NUSUM6IC8qIFNQQyAtIFNFTEYtVEVTVCBDb2RlICovCisJY2FzZSBWRVJJRlk6IC8qIFNCQyAtIFZSUHJvdGVjdCAqLworCWNhc2UgVkVSSUZZXzE2OiAvKiBTQkMgLSBWUlByb3RlY3QgKi8KKwljYXNlIFdSSVRFX1ZFUklGWTogLyogU0JDIC0gVlJQcm90ZWN0ICovCisJY2FzZSBXUklURV9WRVJJRllfMTI6IC8qIFNCQyAtIFZSUHJvdGVjdCAqLworCQlicmVhazsKKwlkZWZhdWx0OgorCQljZGJbMV0gJj0gMHgxZjsgLyogY2xlYXIgbG9naWNhbCB1bml0IG51bWJlciAqLworCQlicmVhazsKKwl9Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc2VfdGFzayAqCit0cmFuc3BvcnRfZ2VuZXJpY19nZXRfdGFzayhzdHJ1Y3Qgc2VfY21kICpjbWQsCisJCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRhdGFfZGlyZWN0aW9uKQoreworCXN0cnVjdCBzZV90YXNrICp0YXNrOworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IFNFX0RFVihjbWQpOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwl0YXNrID0gZGV2LT50cmFuc3BvcnQtPmFsbG9jX3Rhc2soY21kKTsKKwlpZiAoIXRhc2spIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgc3RydWN0IHNlX3Rhc2tcbiIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlJTklUX0xJU1RfSEVBRCgmdGFzay0+dF9saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmdGFzay0+dF9leGVjdXRlX2xpc3QpOworCUlOSVRfTElTVF9IRUFEKCZ0YXNrLT50X3N0YXRlX2xpc3QpOworCWluaXRfY29tcGxldGlvbigmdGFzay0+dGFza19zdG9wX2NvbXApOworCXRhc2stPnRhc2tfbm8gPSBUX1RBU0soY21kKS0+dF90YXNrc19ubysrOworCXRhc2stPnRhc2tfc2VfY21kID0gY21kOworCXRhc2stPnNlX2RldiA9IGRldjsKKwl0YXNrLT50YXNrX2RhdGFfZGlyZWN0aW9uID0gZGF0YV9kaXJlY3Rpb247CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCWxpc3RfYWRkX3RhaWwoJnRhc2stPnRfbGlzdCwgJlRfVEFTSyhjbWQpLT50X3Rhc2tfbGlzdCk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCisJcmV0dXJuIHRhc2s7Cit9CisKK3N0YXRpYyBpbnQgdHJhbnNwb3J0X2dlbmVyaWNfY21kX3NlcXVlbmNlcihzdHJ1Y3Qgc2VfY21kICosIHVuc2lnbmVkIGNoYXIgKik7CisKK3ZvaWQgdHJhbnNwb3J0X2RldmljZV9zZXR1cF9jbWQoc3RydWN0IHNlX2NtZCAqY21kKQoreworCWNtZC0+c2VfZGV2ID0gU0VfTFVOKGNtZCktPmx1bl9zZV9kZXY7Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9kZXZpY2Vfc2V0dXBfY21kKTsKKworLyoKKyAqIFVzZWQgYnkgZmFicmljIG1vZHVsZXMgY29udGFpbmluZyBhIGxvY2FsIHN0cnVjdCBzZV9jbWQgd2l0aGluIHRoZWlyCisgKiBmYWJyaWMgZGVwZW5kZW50IHBlciBJL08gZGVzY3JpcHRvci4KKyAqLwordm9pZCB0cmFuc3BvcnRfaW5pdF9zZV9jbWQoCisJc3RydWN0IHNlX2NtZCAqY21kLAorCXN0cnVjdCB0YXJnZXRfY29yZV9mYWJyaWNfb3BzICp0Zm8sCisJc3RydWN0IHNlX3Nlc3Npb24gKnNlX3Nlc3MsCisJdTMyIGRhdGFfbGVuZ3RoLAorCWludCBkYXRhX2RpcmVjdGlvbiwKKwlpbnQgdGFza19hdHRyLAorCXVuc2lnbmVkIGNoYXIgKnNlbnNlX2J1ZmZlcikKK3sKKwlJTklUX0xJU1RfSEVBRCgmY21kLT5zZV9sdW5fbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJmNtZC0+c2VfZGVsYXllZF9saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmY21kLT5zZV9vcmRlcmVkX2xpc3QpOworCS8qCisJICogU2V0dXAgdF90YXNrIHBvaW50ZXIgdG8gdF90YXNrX2JhY2tzdG9yZQorCSAqLworCWNtZC0+dF90YXNrID0gJmNtZC0+dF90YXNrX2JhY2tzdG9yZTsKKworCUlOSVRfTElTVF9IRUFEKCZUX1RBU0soY21kKS0+dF90YXNrX2xpc3QpOworCWluaXRfY29tcGxldGlvbigmVF9UQVNLKGNtZCktPnRyYW5zcG9ydF9sdW5fZmVfc3RvcF9jb21wKTsKKwlpbml0X2NvbXBsZXRpb24oJlRfVEFTSyhjbWQpLT50cmFuc3BvcnRfbHVuX3N0b3BfY29tcCk7CisJaW5pdF9jb21wbGV0aW9uKCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfc3RvcF9jb21wKTsKKwlzcGluX2xvY2tfaW5pdCgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jayk7CisJYXRvbWljX3NldCgmVF9UQVNLKGNtZCktPnRyYW5zcG9ydF9kZXZfYWN0aXZlLCAxKTsKKworCWNtZC0+c2VfdGZvID0gdGZvOworCWNtZC0+c2Vfc2VzcyA9IHNlX3Nlc3M7CisJY21kLT5kYXRhX2xlbmd0aCA9IGRhdGFfbGVuZ3RoOworCWNtZC0+ZGF0YV9kaXJlY3Rpb24gPSBkYXRhX2RpcmVjdGlvbjsKKwljbWQtPnNhbV90YXNrX2F0dHIgPSB0YXNrX2F0dHI7CisJY21kLT5zZW5zZV9idWZmZXIgPSBzZW5zZV9idWZmZXI7Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9pbml0X3NlX2NtZCk7CisKK3N0YXRpYyBpbnQgdHJhbnNwb3J0X2NoZWNrX2FsbG9jX3Rhc2tfYXR0cihzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJLyoKKwkgKiBDaGVjayBpZiBTQU0gVGFzayBBdHRyaWJ1dGUgZW11bGF0aW9uIGlzIGVuYWJsZWQgZm9yIHRoaXMKKwkgKiBzdHJ1Y3Qgc2VfZGV2aWNlIHN0b3JhZ2Ugb2JqZWN0CisJICovCisJaWYgKFNFX0RFVihjbWQpLT5kZXZfdGFza19hdHRyX3R5cGUgIT0gU0FNX1RBU0tfQVRUUl9FTVVMQVRFRCkKKwkJcmV0dXJuIDA7CisKKwlpZiAoY21kLT5zYW1fdGFza19hdHRyID09IFRBU0tfQVRUUl9BQ0EpIHsKKwkJREVCVUdfU1RBKCJTQU0gVGFzayBBdHRyaWJ1dGUgQUNBIgorCQkJIiBlbXVsYXRpb24gaXMgbm90IHN1cHBvcnRlZFxuIik7CisJCXJldHVybiAtMTsKKwl9CisJLyoKKwkgKiBVc2VkIHRvIGRldGVybWluZSB3aGVuIE9SREVSRUQgY29tbWFuZHMgc2hvdWxkIGdvIGZyb20KKwkgKiBEb3JtYW50IHRvIEFjdGl2ZSBzdGF0dXMuCisJICovCisJY21kLT5zZV9vcmRlcmVkX2lkID0gYXRvbWljX2luY19yZXR1cm4oJlNFX0RFVihjbWQpLT5kZXZfb3JkZXJlZF9pZCk7CisJc21wX21iX19hZnRlcl9hdG9taWNfaW5jKCk7CisJREVCVUdfU1RBKCJBbGxvY2F0ZWQgc2Vfb3JkZXJlZF9pZDogJXUgZm9yIFRhc2sgQXR0cjogMHglMDJ4IG9uICVzXG4iLAorCQkJY21kLT5zZV9vcmRlcmVkX2lkLCBjbWQtPnNhbV90YXNrX2F0dHIsCisJCQlUUkFOU1BPUlQoY21kLT5zZV9kZXYpLT5uYW1lKTsKKwlyZXR1cm4gMDsKK30KKwordm9pZCB0cmFuc3BvcnRfZnJlZV9zZV9jbWQoCisJc3RydWN0IHNlX2NtZCAqc2VfY21kKQoreworCWlmIChzZV9jbWQtPnNlX3Rtcl9yZXEpCisJCWNvcmVfdG1yX3JlbGVhc2VfcmVxKHNlX2NtZC0+c2VfdG1yX3JlcSk7CisJLyoKKwkgKiBDaGVjayBhbmQgZnJlZSBhbnkgZXh0ZW5kZWQgQ0RCIGJ1ZmZlciB0aGF0IHdhcyBhbGxvY2F0ZWQKKwkgKi8KKwlpZiAoVF9UQVNLKHNlX2NtZCktPnRfdGFza19jZGIgIT0gVF9UQVNLKHNlX2NtZCktPl9fdF90YXNrX2NkYikKKwkJa2ZyZWUoVF9UQVNLKHNlX2NtZCktPnRfdGFza19jZGIpOworfQorRVhQT1JUX1NZTUJPTCh0cmFuc3BvcnRfZnJlZV9zZV9jbWQpOworCitzdGF0aWMgdm9pZCB0cmFuc3BvcnRfZ2VuZXJpY193YWl0X2Zvcl90YXNrcyhzdHJ1Y3Qgc2VfY21kICosIGludCwgaW50KTsKKworLyoJdHJhbnNwb3J0X2dlbmVyaWNfYWxsb2NhdGVfdGFza3MoKToKKyAqCisgKglDYWxsZWQgZnJvbSBmYWJyaWMgUlggVGhyZWFkLgorICovCitpbnQgdHJhbnNwb3J0X2dlbmVyaWNfYWxsb2NhdGVfdGFza3MoCisJc3RydWN0IHNlX2NtZCAqY21kLAorCXVuc2lnbmVkIGNoYXIgKmNkYikKK3sKKwlpbnQgcmV0OworCisJdHJhbnNwb3J0X2dlbmVyaWNfcHJlcGFyZV9jZGIoY2RiKTsKKworCS8qCisJICogVGhpcyBpcyBuZWVkZWQgZm9yIGVhcmx5IGV4Y2VwdGlvbnMuCisJICovCisJY21kLT50cmFuc3BvcnRfd2FpdF9mb3JfdGFza3MgPSAmdHJhbnNwb3J0X2dlbmVyaWNfd2FpdF9mb3JfdGFza3M7CisKKwl0cmFuc3BvcnRfZGV2aWNlX3NldHVwX2NtZChjbWQpOworCS8qCisJICogRW5zdXJlIHRoYXQgdGhlIHJlY2VpdmVkIENEQiBpcyBsZXNzIHRoYW4gdGhlIG1heCAoMjUyICsgOCkgYnl0ZXMKKwkgKiBmb3IgVkFSSUFCTEVfTEVOR1RIX0NNRAorCSAqLworCWlmIChzY3NpX2NvbW1hbmRfc2l6ZShjZGIpID4gU0NTSV9NQVhfVkFSTEVOX0NEQl9TSVpFKSB7CisJCXByaW50ayhLRVJOX0VSUiAiUmVjZWl2ZWQgU0NTSSBDREIgd2l0aCBjb21tYW5kX3NpemU6ICVkIHRoYXQiCisJCQkiIGV4Y2VlZHMgU0NTSV9NQVhfVkFSTEVOX0NEQl9TSVpFOiAlZFxuIiwKKwkJCXNjc2lfY29tbWFuZF9zaXplKGNkYiksIFNDU0lfTUFYX1ZBUkxFTl9DREJfU0laRSk7CisJCXJldHVybiAtMTsKKwl9CisJLyoKKwkgKiBJZiB0aGUgcmVjZWl2ZWQgQ0RCIGlzIGxhcmdlciB0aGFuIFRDTV9NQVhfQ09NTUFORF9TSVpFLAorCSAqIGFsbG9jYXRlIHRoZSBhZGRpdGlvbmFsIGV4dGVuZGVkIENEQiBidWZmZXIgbm93Li4gIE90aGVyd2lzZQorCSAqIHNldHVwIHRoZSBwb2ludGVyIGZyb20gX190X3Rhc2tfY2RiIHRvIHRfdGFza19jZGIuCisJICovCisJaWYgKHNjc2lfY29tbWFuZF9zaXplKGNkYikgPiBzaXplb2YoVF9UQVNLKGNtZCktPl9fdF90YXNrX2NkYikpIHsKKwkJVF9UQVNLKGNtZCktPnRfdGFza19jZGIgPSBremFsbG9jKHNjc2lfY29tbWFuZF9zaXplKGNkYiksCisJCQkJCQlHRlBfS0VSTkVMKTsKKwkJaWYgKCEoVF9UQVNLKGNtZCktPnRfdGFza19jZGIpKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBUX1RBU0soY21kKS0+dF90YXNrX2NkYiIKKwkJCQkiICV1ID4gc2l6ZW9mKFRfVEFTSyhjbWQpLT5fX3RfdGFza19jZGIpOiAlbHUgb3BzXG4iLAorCQkJCXNjc2lfY29tbWFuZF9zaXplKGNkYiksCisJCQkJKHVuc2lnbmVkIGxvbmcpc2l6ZW9mKFRfVEFTSyhjbWQpLT5fX3RfdGFza19jZGIpKTsKKwkJCXJldHVybiAtMTsKKwkJfQorCX0gZWxzZQorCQlUX1RBU0soY21kKS0+dF90YXNrX2NkYiA9ICZUX1RBU0soY21kKS0+X190X3Rhc2tfY2RiWzBdOworCS8qCisJICogQ29weSB0aGUgb3JpZ2luYWwgQ0RCIGludG8gVF9UQVNLKGNtZCkuCisJICovCisJbWVtY3B5KFRfVEFTSyhjbWQpLT50X3Rhc2tfY2RiLCBjZGIsIHNjc2lfY29tbWFuZF9zaXplKGNkYikpOworCS8qCisJICogU2V0dXAgdGhlIHJlY2VpdmVkIENEQiBiYXNlZCBvbiBTQ1NJIGRlZmluZWQgb3Bjb2RlcyBhbmQKKwkgKiBwZXJmb3JtIHVuaXQgYXR0ZW50aW9uLCBwZXJzaXN0ZW50IHJlc2VydmF0aW9ucyBhbmQgQUxVQQorCSAqIGNoZWNrcyBmb3IgdmlydHVhbCBkZXZpY2UgYmFja2VuZHMuICBUaGUgVF9UQVNLKGNtZCktPnRfdGFza19jZGIKKwkgKiBwb2ludGVyIGlzIGV4cGVjdGVkIHRvIGJlIHNldHVwIGJlZm9yZSB3ZSByZWFjaCB0aGlzIHBvaW50LgorCSAqLworCXJldCA9IHRyYW5zcG9ydF9nZW5lcmljX2NtZF9zZXF1ZW5jZXIoY21kLCBjZGIpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCS8qCisJICogQ2hlY2sgZm9yIFNBTSBUYXNrIEF0dHJpYnV0ZSBFbXVsYXRpb24KKwkgKi8KKwlpZiAodHJhbnNwb3J0X2NoZWNrX2FsbG9jX3Rhc2tfYXR0cihjbWQpIDwgMCkgeworCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DREJfRVhDRVBUSU9OOworCQljbWQtPnNjc2lfc2Vuc2VfcmVhc29uID0gVENNX0lOVkFMSURfQ0RCX0ZJRUxEOworCQlyZXR1cm4gLTI7CisJfQorCXNwaW5fbG9jaygmY21kLT5zZV9sdW4tPmx1bl9zZXBfbG9jayk7CisJaWYgKGNtZC0+c2VfbHVuLT5sdW5fc2VwKQorCQljbWQtPnNlX2x1bi0+bHVuX3NlcC0+c2VwX3N0YXRzLmNtZF9wZHVzKys7CisJc3Bpbl91bmxvY2soJmNtZC0+c2VfbHVuLT5sdW5fc2VwX2xvY2spOworCXJldHVybiAwOworfQorRVhQT1JUX1NZTUJPTCh0cmFuc3BvcnRfZ2VuZXJpY19hbGxvY2F0ZV90YXNrcyk7CisKKy8qCisgKiBVc2VkIGJ5IGZhYnJpYyBtb2R1bGUgZnJvbnRlbmRzIG5vdCBkZWZpbmluZyBhIFRGTy0+bmV3X2NtZF9tYXAoKQorICogdG8gcXVldWUgdXAgYSBuZXdseSBzZXR1cCBzZV9jbWQgdy8gVFJBTlNQT1JUX05FV19DTUQgc3RhdGlzCisgKi8KK2ludCB0cmFuc3BvcnRfZ2VuZXJpY19oYW5kbGVfY2RiKAorCXN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlpZiAoIVNFX0xVTihjbWQpKSB7CisJCWR1bXBfc3RhY2soKTsKKwkJcHJpbnRrKEtFUk5fRVJSICJTRV9MVU4oY21kKSBpcyBOVUxMXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXRyYW5zcG9ydF9hZGRfY21kX3RvX3F1ZXVlKGNtZCwgVFJBTlNQT1JUX05FV19DTUQpOworCXJldHVybiAwOworfQorRVhQT1JUX1NZTUJPTCh0cmFuc3BvcnRfZ2VuZXJpY19oYW5kbGVfY2RiKTsKKworLyoKKyAqIFVzZWQgYnkgZmFicmljIG1vZHVsZSBmcm9udGVuZHMgZGVmaW5pbmcgYSBURk8tPm5ld19jbWRfbWFwKCkgY2FsbGVyCisgKiB0byAgcXVldWUgdXAgYSBuZXdseSBzZXR1cCBzZV9jbWQgdy8gVFJBTlNQT1JUX05FV19DTURfTUFQIGluIG9yZGVyIHRvCisgKiBjb21wbGV0ZSBzZXR1cCBpbiBUQ00gcHJvY2VzcyBjb250ZXh0IHcvIFRGTy0+bmV3X2NtZF9tYXAoKS4KKyAqLworaW50IHRyYW5zcG9ydF9nZW5lcmljX2hhbmRsZV9jZGJfbWFwKAorCXN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlpZiAoIVNFX0xVTihjbWQpKSB7CisJCWR1bXBfc3RhY2soKTsKKwkJcHJpbnRrKEtFUk5fRVJSICJTRV9MVU4oY21kKSBpcyBOVUxMXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXRyYW5zcG9ydF9hZGRfY21kX3RvX3F1ZXVlKGNtZCwgVFJBTlNQT1JUX05FV19DTURfTUFQKTsKKwlyZXR1cm4gMDsKK30KK0VYUE9SVF9TWU1CT0wodHJhbnNwb3J0X2dlbmVyaWNfaGFuZGxlX2NkYl9tYXApOworCisvKgl0cmFuc3BvcnRfZ2VuZXJpY19oYW5kbGVfZGF0YSgpOgorICoKKyAqCisgKi8KK2ludCB0cmFuc3BvcnRfZ2VuZXJpY19oYW5kbGVfZGF0YSgKKwlzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJLyoKKwkgKiBGb3IgdGhlIHNvZnR3YXJlIGZhYnJpYyBjYXNlLCB0aGVuIHdlIGFzc3VtZSB0aGUgbmV4dXMgaXMgYmVpbmcKKwkgKiBmYWlsZWQvc2h1dGRvd24gd2hlbiBzaWduYWxzIGFyZSBwZW5kaW5nIGZyb20gdGhlIGt0aHJlYWQgY29udGV4dAorCSAqIGNhbGxlciwgc28gd2UgcmV0dXJuIGEgZmFpbHVyZS4gIEZvciB0aGUgSFcgdGFyZ2V0IG1vZGUgY2FzZSBydW5uaW5nCisJICogaW4gaW50ZXJydXB0IGNvZGUsIHRoZSBzaWduYWxfcGVuZGluZygpIGNoZWNrIGlzIHNraXBwZWQuCisJICovCisJaWYgKCFpbl9pbnRlcnJ1cHQoKSAmJiBzaWduYWxfcGVuZGluZyhjdXJyZW50KSkKKwkJcmV0dXJuIC0xOworCS8qCisJICogSWYgdGhlIHJlY2VpdmVkIENEQiBoYXMgYWxlYWR5IGJlZW4gQUJPUlRFRCBieSB0aGUgZ2VuZXJpYworCSAqIHRhcmdldCBlbmdpbmUsIHdlIG5vdyBjYWxsIHRyYW5zcG9ydF9jaGVja19hYm9ydGVkX3N0YXR1cygpCisJICogdG8gcXVldWUgYW55IGRlbGF0ZWQgVEFTS19BQk9SVEVEIHN0YXR1cyBmb3IgdGhlIHJlY2VpdmVkIENEQiB0byB0aGUKKwkgKiBmYWJyaWMgbW9kdWxlIGFzIHdlIGFyZSBleHBlY3Rpbmcgbm8gZnV0aGVyIGluY29taW5nIERBVEEgT1VUCisJICogc2VxdWVuY2VzIGF0IHRoaXMgcG9pbnQuCisJICovCisJaWYgKHRyYW5zcG9ydF9jaGVja19hYm9ydGVkX3N0YXR1cyhjbWQsIDEpICE9IDApCisJCXJldHVybiAwOworCisJdHJhbnNwb3J0X2FkZF9jbWRfdG9fcXVldWUoY21kLCBUUkFOU1BPUlRfUFJPQ0VTU19XUklURSk7CisJcmV0dXJuIDA7Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9nZW5lcmljX2hhbmRsZV9kYXRhKTsKKworLyoJdHJhbnNwb3J0X2dlbmVyaWNfaGFuZGxlX3RtcigpOgorICoKKyAqCisgKi8KK2ludCB0cmFuc3BvcnRfZ2VuZXJpY19oYW5kbGVfdG1yKAorCXN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwkvKgorCSAqIFRoaXMgaXMgbmVlZGVkIGZvciBlYXJseSBleGNlcHRpb25zLgorCSAqLworCWNtZC0+dHJhbnNwb3J0X3dhaXRfZm9yX3Rhc2tzID0gJnRyYW5zcG9ydF9nZW5lcmljX3dhaXRfZm9yX3Rhc2tzOworCXRyYW5zcG9ydF9kZXZpY2Vfc2V0dXBfY21kKGNtZCk7CisKKwl0cmFuc3BvcnRfYWRkX2NtZF90b19xdWV1ZShjbWQsIFRSQU5TUE9SVF9QUk9DRVNTX1RNUik7CisJcmV0dXJuIDA7Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9nZW5lcmljX2hhbmRsZV90bXIpOworCitzdGF0aWMgaW50IHRyYW5zcG9ydF9zdG9wX3Rhc2tzX2Zvcl9jbWQoc3RydWN0IHNlX2NtZCAqY21kKQoreworCXN0cnVjdCBzZV90YXNrICp0YXNrLCAqdGFza190bXA7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgcmV0ID0gMDsKKworCURFQlVHX1RTKCJJVFRbMHglMDh4XSAtIFN0b3BwaW5nIHRhc2tzXG4iLAorCQlDTURfVEZPKGNtZCktPmdldF90YXNrX3RhZyhjbWQpKTsKKworCS8qCisJICogTm8gdGFza3MgcmVtYWluIGluIHRoZSBleGVjdXRpb24gcXVldWUKKwkgKi8KKwlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSh0YXNrLCB0YXNrX3RtcCwKKwkJCQkmVF9UQVNLKGNtZCktPnRfdGFza19saXN0LCB0X2xpc3QpIHsKKwkJREVCVUdfVFMoInRhc2tfbm9bJWRdIC0gUHJvY2Vzc2luZyB0YXNrICVwXG4iLAorCQkJCXRhc2stPnRhc2tfbm8sIHRhc2spOworCQkvKgorCQkgKiBJZiB0aGUgc3RydWN0IHNlX3Rhc2sgaGFzIG5vdCBiZWVuIHNlbnQgYW5kIGlzIG5vdCBhY3RpdmUsCisJCSAqIHJlbW92ZSB0aGUgc3RydWN0IHNlX3Rhc2sgZnJvbSB0aGUgZXhlY3V0aW9uIHF1ZXVlLgorCQkgKi8KKwkJaWYgKCFhdG9taWNfcmVhZCgmdGFzay0+dGFza19zZW50KSAmJgorCQkgICAgIWF0b21pY19yZWFkKCZ0YXNrLT50YXNrX2FjdGl2ZSkpIHsKKwkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssCisJCQkJCWZsYWdzKTsKKwkJCXRyYW5zcG9ydF9yZW1vdmVfdGFza19mcm9tX2V4ZWN1dGVfcXVldWUodGFzaywKKwkJCQkJdGFzay0+c2VfZGV2KTsKKworCQkJREVCVUdfVFMoInRhc2tfbm9bJWRdIC0gUmVtb3ZlZCBmcm9tIGV4ZWN1dGUgcXVldWVcbiIsCisJCQkJdGFzay0+dGFza19ubyk7CisJCQlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCQkJY29udGludWU7CisJCX0KKworCQkvKgorCQkgKiBJZiB0aGUgc3RydWN0IHNlX3Rhc2sgaXMgYWN0aXZlLCBzbGVlcCB1bnRpbCBpdCBpcyByZXR1cm5lZAorCQkgKiBmcm9tIHRoZSBwbHVnaW4uCisJCSAqLworCQlpZiAoYXRvbWljX3JlYWQoJnRhc2stPnRhc2tfYWN0aXZlKSkgeworCQkJYXRvbWljX3NldCgmdGFzay0+dGFza19zdG9wLCAxKTsKKwkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssCisJCQkJCWZsYWdzKTsKKworCQkJREVCVUdfVFMoInRhc2tfbm9bJWRdIC0gV2FpdGluZyB0byBjb21wbGV0ZVxuIiwKKwkJCQl0YXNrLT50YXNrX25vKTsKKwkJCXdhaXRfZm9yX2NvbXBsZXRpb24oJnRhc2stPnRhc2tfc3RvcF9jb21wKTsKKwkJCURFQlVHX1RTKCJ0YXNrX25vWyVkXSAtIFN0b3BwZWQgc3VjY2Vzc2Z1bGx5XG4iLAorCQkJCXRhc2stPnRhc2tfbm8pOworCisJCQlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCQkJYXRvbWljX2RlYygmVF9UQVNLKGNtZCktPnRfdGFza19jZGJzX2xlZnQpOworCisJCQlhdG9taWNfc2V0KCZ0YXNrLT50YXNrX2FjdGl2ZSwgMCk7CisJCQlhdG9taWNfc2V0KCZ0YXNrLT50YXNrX3N0b3AsIDApOworCQl9IGVsc2UgeworCQkJREVCVUdfVFMoInRhc2tfbm9bJWRdIC0gRGlkIG5vdGhpbmdcbiIsIHRhc2stPnRhc2tfbm8pOworCQkJcmV0Kys7CisJCX0KKworCQlfX3RyYW5zcG9ydF9zdG9wX3Rhc2tfdGltZXIodGFzaywgJmZsYWdzKTsKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgdHJhbnNwb3J0X2ZhaWx1cmVfcmVzZXRfcXVldWVfZGVwdGgoc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmU0VfSEJBKGRldiktPmhiYV9xdWV1ZV9sb2NrLCBmbGFncyk7OworCWF0b21pY19pbmMoJmRldi0+ZGVwdGhfbGVmdCk7CisJYXRvbWljX2luYygmU0VfSEJBKGRldiktPmxlZnRfcXVldWVfZGVwdGgpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlNFX0hCQShkZXYpLT5oYmFfcXVldWVfbG9jaywgZmxhZ3MpOworfQorCisvKgorICogSGFuZGxlIFNBTS1lc3F1ZSBlbXVsYXRpb24gZm9yIGdlbmVyaWMgdHJhbnNwb3J0IHJlcXVlc3QgZmFpbHVyZXMuCisgKi8KK3N0YXRpYyB2b2lkIHRyYW5zcG9ydF9nZW5lcmljX3JlcXVlc3RfZmFpbHVyZSgKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCWludCBjb21wbGV0ZSwKKwlpbnQgc2MpCit7CisJREVCVUdfR1JGKCItLS0tLVsgU3RvcmFnZSBFbmdpbmUgRXhjZXB0aW9uIGZvciBjbWQ6ICVwIElUVDogMHglMDh4IgorCQkiIENEQjogMHglMDJ4XG4iLCBjbWQsIENNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCksCisJCVRfVEFTSyhjbWQpLT50X3Rhc2tfY2RiWzBdKTsKKwlERUJVR19HUkYoIi0tLS0tWyBpX3N0YXRlOiAlZCB0X3N0YXRlL2RlZl90X3N0YXRlOiIKKwkJIiAlZC8lZCB0cmFuc3BvcnRfZXJyb3Jfc3RhdHVzOiAlZFxuIiwKKwkJQ01EX1RGTyhjbWQpLT5nZXRfY21kX3N0YXRlKGNtZCksCisJCWNtZC0+dF9zdGF0ZSwgY21kLT5kZWZlcnJlZF90X3N0YXRlLAorCQljbWQtPnRyYW5zcG9ydF9lcnJvcl9zdGF0dXMpOworCURFQlVHX0dSRigiLS0tLS1bIHRfdGFza19jZGJzOiAlZCB0X3Rhc2tfY2Ric19sZWZ0OiAlZCIKKwkJIiB0X3Rhc2tfY2Ric19zZW50OiAlZCB0X3Rhc2tfY2Ric19leF9sZWZ0OiAlZCAtLSIKKwkJIiB0X3RyYW5zcG9ydF9hY3RpdmU6ICVkIHRfdHJhbnNwb3J0X3N0b3A6ICVkIgorCQkiIHRfdHJhbnNwb3J0X3NlbnQ6ICVkXG4iLCBUX1RBU0soY21kKS0+dF90YXNrX2NkYnMsCisJCWF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF90YXNrX2NkYnNfbGVmdCksCisJCWF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF90YXNrX2NkYnNfc2VudCksCisJCWF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF90YXNrX2NkYnNfZXhfbGVmdCksCisJCWF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfYWN0aXZlKSwKKwkJYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X3RyYW5zcG9ydF9zdG9wKSwKKwkJYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X3RyYW5zcG9ydF9zZW50KSk7CisKKwl0cmFuc3BvcnRfc3RvcF9hbGxfdGFza190aW1lcnMoY21kKTsKKworCWlmIChkZXYpCisJCXRyYW5zcG9ydF9mYWlsdXJlX3Jlc2V0X3F1ZXVlX2RlcHRoKGRldik7CisJLyoKKwkgKiBGb3IgU0FNIFRhc2sgQXR0cmlidXRlIGVtdWxhdGlvbiBmb3IgZmFpbGVkIHN0cnVjdCBzZV9jbWQKKwkgKi8KKwlpZiAoY21kLT5zZV9kZXYtPmRldl90YXNrX2F0dHJfdHlwZSA9PSBTQU1fVEFTS19BVFRSX0VNVUxBVEVEKQorCQl0cmFuc3BvcnRfY29tcGxldGVfdGFza19hdHRyKGNtZCk7CisKKwlpZiAoY29tcGxldGUpIHsKKwkJdHJhbnNwb3J0X2RpcmVjdF9yZXF1ZXN0X3RpbWVvdXQoY21kKTsKKwkJY21kLT50cmFuc3BvcnRfZXJyb3Jfc3RhdHVzID0gUFlYX1RSQU5TUE9SVF9MVV9DT01NX0ZBSUxVUkU7CisJfQorCisJc3dpdGNoIChjbWQtPnRyYW5zcG9ydF9lcnJvcl9zdGF0dXMpIHsKKwljYXNlIFBZWF9UUkFOU1BPUlRfVU5LTk9XTl9TQU1fT1BDT0RFOgorCQljbWQtPnNjc2lfc2Vuc2VfcmVhc29uID0gVENNX1VOU1VQUE9SVEVEX1NDU0lfT1BDT0RFOworCQlicmVhazsKKwljYXNlIFBZWF9UUkFOU1BPUlRfUkVRX1RPT19NQU5ZX1NFQ1RPUlM6CisJCWNtZC0+c2NzaV9zZW5zZV9yZWFzb24gPSBUQ01fU0VDVE9SX0NPVU5UX1RPT19NQU5ZOworCQlicmVhazsKKwljYXNlIFBZWF9UUkFOU1BPUlRfSU5WQUxJRF9DREJfRklFTEQ6CisJCWNtZC0+c2NzaV9zZW5zZV9yZWFzb24gPSBUQ01fSU5WQUxJRF9DREJfRklFTEQ7CisJCWJyZWFrOworCWNhc2UgUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOgorCQljbWQtPnNjc2lfc2Vuc2VfcmVhc29uID0gVENNX0lOVkFMSURfUEFSQU1FVEVSX0xJU1Q7CisJCWJyZWFrOworCWNhc2UgUFlYX1RSQU5TUE9SVF9PVVRfT0ZfTUVNT1JZX1JFU09VUkNFUzoKKwkJaWYgKCFzYykKKwkJCXRyYW5zcG9ydF9uZXdfY21kX2ZhaWx1cmUoY21kKTsKKwkJLyoKKwkJICogQ3VycmVudGx5IGZvciBQWVhfVFJBTlNQT1JUX09VVF9PRl9NRU1PUllfUkVTT1VSQ0VTLAorCQkgKiB3ZSBmb3JjZSB0aGlzIHNlc3Npb24gdG8gZmFsbCBiYWNrIHRvIHNlc3Npb24KKwkJICogcmVjb3ZlcnkuCisJCSAqLworCQlDTURfVEZPKGNtZCktPmZhbGxfYmFja190b19lcmwwKGNtZC0+c2Vfc2Vzcyk7CisJCUNNRF9URk8oY21kKS0+c3RvcF9zZXNzaW9uKGNtZC0+c2Vfc2VzcywgMCwgMCk7CisKKwkJZ290byBjaGVja19zdG9wOworCWNhc2UgUFlYX1RSQU5TUE9SVF9MVV9DT01NX0ZBSUxVUkU6CisJY2FzZSBQWVhfVFJBTlNQT1JUX0lMTEVHQUxfUkVRVUVTVDoKKwkJY21kLT5zY3NpX3NlbnNlX3JlYXNvbiA9IFRDTV9MT0dJQ0FMX1VOSVRfQ09NTVVOSUNBVElPTl9GQUlMVVJFOworCQlicmVhazsKKwljYXNlIFBZWF9UUkFOU1BPUlRfVU5LTk9XTl9NT0RFX1BBR0U6CisJCWNtZC0+c2NzaV9zZW5zZV9yZWFzb24gPSBUQ01fVU5LTk9XTl9NT0RFX1BBR0U7CisJCWJyZWFrOworCWNhc2UgUFlYX1RSQU5TUE9SVF9XUklURV9QUk9URUNURUQ6CisJCWNtZC0+c2NzaV9zZW5zZV9yZWFzb24gPSBUQ01fV1JJVEVfUFJPVEVDVEVEOworCQlicmVhazsKKwljYXNlIFBZWF9UUkFOU1BPUlRfUkVTRVJWQVRJT05fQ09ORkxJQ1Q6CisJCS8qCisJCSAqIE5vIFNFTlNFIERhdGEgcGF5bG9hZCBmb3IgdGhpcyBjYXNlLCBzZXQgU0NTSSBTdGF0dXMKKwkJICogYW5kIHF1ZXVlIHRoZSByZXNwb25zZSB0byAkRkFCUklDX01PRC4KKwkJICoKKwkJICogVXNlcyBsaW51eC9pbmNsdWRlL3Njc2kvc2NzaS5oIFNBTSBzdGF0dXMgY29kZXMgZGVmcworCQkgKi8KKwkJY21kLT5zY3NpX3N0YXR1cyA9IFNBTV9TVEFUX1JFU0VSVkFUSU9OX0NPTkZMSUNUOworCQkvKgorCQkgKiBGb3IgVUEgSW50ZXJsb2NrIENvZGUgMTFiLCBhIFJFU0VSVkFUSU9OIENPTkZMSUNUIHdpbGwKKwkJICogZXN0YWJsaXNoIGEgVU5JVCBBVFRFTlRJT04gd2l0aCBQUkVWSU9VUyBSRVNFUlZBVElPTgorCQkgKiBDT05GTElDVCBTVEFUVVMuCisJCSAqCisJCSAqIFNlZSBzcGM0cjE3LCBzZWN0aW9uIDcuNC42IENvbnRyb2wgTW9kZSBQYWdlLCBUYWJsZSAzNDkKKwkJICovCisJCWlmIChTRV9TRVNTKGNtZCkgJiYKKwkJICAgIERFVl9BVFRSSUIoY21kLT5zZV9kZXYpLT5lbXVsYXRlX3VhX2ludGxja19jdHJsID09IDIpCisJCQljb3JlX3Njc2kzX3VhX2FsbG9jYXRlKFNFX1NFU1MoY21kKS0+c2Vfbm9kZV9hY2wsCisJCQkJY21kLT5vcmlnX2ZlX2x1biwgMHgyQywKKwkJCQlBU0NRXzJDSF9QUkVWSU9VU19SRVNFUlZBVElPTl9DT05GTElDVF9TVEFUVVMpOworCisJCUNNRF9URk8oY21kKS0+cXVldWVfc3RhdHVzKGNtZCk7CisJCWdvdG8gY2hlY2tfc3RvcDsKKwljYXNlIFBZWF9UUkFOU1BPUlRfVVNFX1NFTlNFX1JFQVNPTjoKKwkJLyoKKwkJICogc3RydWN0IHNlX2NtZC0+c2NzaV9zZW5zZV9yZWFzb24gYWxyZWFkeSBzZXQKKwkJICovCisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXByaW50ayhLRVJOX0VSUiAiVW5rbm93biB0cmFuc3BvcnQgZXJyb3IgZm9yIENEQiAweCUwMng6ICVkXG4iLAorCQkJVF9UQVNLKGNtZCktPnRfdGFza19jZGJbMF0sCisJCQljbWQtPnRyYW5zcG9ydF9lcnJvcl9zdGF0dXMpOworCQljbWQtPnNjc2lfc2Vuc2VfcmVhc29uID0gVENNX1VOU1VQUE9SVEVEX1NDU0lfT1BDT0RFOworCQlicmVhazsKKwl9CisKKwlpZiAoIXNjKQorCQl0cmFuc3BvcnRfbmV3X2NtZF9mYWlsdXJlKGNtZCk7CisJZWxzZQorCQl0cmFuc3BvcnRfc2VuZF9jaGVja19jb25kaXRpb25fYW5kX3NlbnNlKGNtZCwKKwkJCWNtZC0+c2NzaV9zZW5zZV9yZWFzb24sIDApOworY2hlY2tfc3RvcDoKKwl0cmFuc3BvcnRfbHVuX3JlbW92ZV9jbWQoY21kKTsKKwlpZiAoISh0cmFuc3BvcnRfY21kX2NoZWNrX3N0b3BfdG9fZmFicmljKGNtZCkpKQorCQk7Cit9CisKK3N0YXRpYyB2b2lkIHRyYW5zcG9ydF9kaXJlY3RfcmVxdWVzdF90aW1lb3V0KHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwlpZiAoIShhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X3RpbWVvdXQpKSkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJCXJldHVybjsKKwl9CisJaWYgKGF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF90YXNrX2NkYnNfdGltZW91dF9sZWZ0KSkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJCXJldHVybjsKKwl9CisKKwlhdG9taWNfc3ViKGF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfdGltZW91dCksCisJCSAgICZUX1RBU0soY21kKS0+dF9zZV9jb3VudCk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworfQorCitzdGF0aWMgdm9pZCB0cmFuc3BvcnRfZ2VuZXJpY19yZXF1ZXN0X3RpbWVvdXQoc3RydWN0IHNlX2NtZCAqY21kKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwkvKgorCSAqIFJlc2V0IFRfVEFTSyhjbWQpLT50X3NlX2NvdW50IHRvIGFsbG93IHRyYW5zcG9ydF9nZW5lcmljX3JlbW92ZSgpCisJICogdG8gYWxsb3cgbGFzdCBjYWxsIHRvIGZyZWUgbWVtb3J5IHJlc291cmNlcy4KKwkgKi8KKwlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCWlmIChhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X3RpbWVvdXQpID4gMSkgeworCQlpbnQgdG1wID0gKGF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfdGltZW91dCkgLSAxKTsKKworCQlhdG9taWNfc3ViKHRtcCwgJlRfVEFTSyhjbWQpLT50X3NlX2NvdW50KTsKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCisJdHJhbnNwb3J0X2dlbmVyaWNfcmVtb3ZlKGNtZCwgMCwgMCk7Cit9CisKK3N0YXRpYyBpbnQKK3RyYW5zcG9ydF9nZW5lcmljX2FsbG9jYXRlX2J1ZihzdHJ1Y3Qgc2VfY21kICpjbWQsIHUzMiBkYXRhX2xlbmd0aCkKK3sKKwl1bnNpZ25lZCBjaGFyICpidWY7CisKKwlidWYgPSBremFsbG9jKGRhdGFfbGVuZ3RoLCBHRlBfS0VSTkVMKTsKKwlpZiAoIShidWYpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIG1lbW9yeSBmb3IgYnVmZmVyXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCVRfVEFTSyhjbWQpLT50X3Rhc2tzX3NlX251bSA9IDA7CisJVF9UQVNLKGNtZCktPnRfdGFza19idWYgPSBidWY7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSB1MzIgdHJhbnNwb3J0X2xiYV8yMSh1bnNpZ25lZCBjaGFyICpjZGIpCit7CisJcmV0dXJuICgoY2RiWzFdICYgMHgxZikgPDwgMTYpIHwgKGNkYlsyXSA8PCA4KSB8IGNkYlszXTsKK30KKworc3RhdGljIGlubGluZSB1MzIgdHJhbnNwb3J0X2xiYV8zMih1bnNpZ25lZCBjaGFyICpjZGIpCit7CisJcmV0dXJuIChjZGJbMl0gPDwgMjQpIHwgKGNkYlszXSA8PCAxNikgfCAoY2RiWzRdIDw8IDgpIHwgY2RiWzVdOworfQorCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgbG9uZyB0cmFuc3BvcnRfbGJhXzY0KHVuc2lnbmVkIGNoYXIgKmNkYikKK3sKKwl1bnNpZ25lZCBpbnQgX192MSwgX192MjsKKworCV9fdjEgPSAoY2RiWzJdIDw8IDI0KSB8IChjZGJbM10gPDwgMTYpIHwgKGNkYls0XSA8PCA4KSB8IGNkYls1XTsKKwlfX3YyID0gKGNkYls2XSA8PCAyNCkgfCAoY2RiWzddIDw8IDE2KSB8IChjZGJbOF0gPDwgOCkgfCBjZGJbOV07CisKKwlyZXR1cm4gKCh1bnNpZ25lZCBsb25nIGxvbmcpX192MikgfCAodW5zaWduZWQgbG9uZyBsb25nKV9fdjEgPDwgMzI7Cit9CisKKy8qCisgKiBGb3IgVkFSSUFCTEVfTEVOR1RIX0NEQiB3LyAzMiBieXRlIGV4dGVuZGVkIENEQnMKKyAqLworc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIGxvbmcgdHJhbnNwb3J0X2xiYV82NF9leHQodW5zaWduZWQgY2hhciAqY2RiKQoreworCXVuc2lnbmVkIGludCBfX3YxLCBfX3YyOworCisJX192MSA9IChjZGJbMTJdIDw8IDI0KSB8IChjZGJbMTNdIDw8IDE2KSB8IChjZGJbMTRdIDw8IDgpIHwgY2RiWzE1XTsKKwlfX3YyID0gKGNkYlsxNl0gPDwgMjQpIHwgKGNkYlsxN10gPDwgMTYpIHwgKGNkYlsxOF0gPDwgOCkgfCBjZGJbMTldOworCisJcmV0dXJuICgodW5zaWduZWQgbG9uZyBsb25nKV9fdjIpIHwgKHVuc2lnbmVkIGxvbmcgbG9uZylfX3YxIDw8IDMyOworfQorCitzdGF0aWMgdm9pZCB0cmFuc3BvcnRfc2V0X3N1cHBvcnRlZF9TQU1fb3Bjb2RlKHN0cnVjdCBzZV9jbWQgKnNlX2NtZCkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJlRfVEFTSyhzZV9jbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwlzZV9jbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU1VQUE9SVEVEX1NBTV9PUENPREU7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKHNlX2NtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworfQorCisvKgorICogQ2FsbGVkIGZyb20gaW50ZXJydXB0IGNvbnRleHQuCisgKi8KK3N0YXRpYyB2b2lkIHRyYW5zcG9ydF90YXNrX3RpbWVvdXRfaGFuZGxlcih1bnNpZ25lZCBsb25nIGRhdGEpCit7CisJc3RydWN0IHNlX3Rhc2sgKnRhc2sgPSAoc3RydWN0IHNlX3Rhc2sgKilkYXRhOworCXN0cnVjdCBzZV9jbWQgKmNtZCA9IFRBU0tfQ01EKHRhc2spOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlERUJVR19UVCgidHJhbnNwb3J0IHRhc2sgdGltZW91dCBmaXJlZCEgdGFzazogJXAgY21kOiAlcFxuIiwgdGFzaywgY21kKTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJaWYgKHRhc2stPnRhc2tfZmxhZ3MgJiBURl9TVE9QKSB7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwkJcmV0dXJuOworCX0KKwl0YXNrLT50YXNrX2ZsYWdzICY9IH5URl9SVU5OSU5HOworCisJLyoKKwkgKiBEZXRlcm1pbmUgaWYgdHJhbnNwb3J0X2NvbXBsZXRlX3Rhc2soKSBoYXMgYWxyZWFkeSBiZWVuIGNhbGxlZC4KKwkgKi8KKwlpZiAoIShhdG9taWNfcmVhZCgmdGFzay0+dGFza19hY3RpdmUpKSkgeworCQlERUJVR19UVCgidHJhbnNwb3J0IHRhc2s6ICVwIGNtZDogJXAgdGltZW91dCB0YXNrX2FjdGl2ZSIKKwkJCQkiID09IDBcbiIsIHRhc2ssIGNtZCk7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwkJcmV0dXJuOworCX0KKworCWF0b21pY19pbmMoJlRfVEFTSyhjbWQpLT50X3NlX2NvdW50KTsKKwlhdG9taWNfaW5jKCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfdGltZW91dCk7CisJVF9UQVNLKGNtZCktPnRfdGFza3NfZmFpbGVkID0gMTsKKworCWF0b21pY19zZXQoJnRhc2stPnRhc2tfdGltZW91dCwgMSk7CisJdGFzay0+dGFza19lcnJvcl9zdGF0dXMgPSBQWVhfVFJBTlNQT1JUX1RBU0tfVElNRU9VVDsKKwl0YXNrLT50YXNrX3Njc2lfc3RhdHVzID0gMTsKKworCWlmIChhdG9taWNfcmVhZCgmdGFzay0+dGFza19zdG9wKSkgeworCQlERUJVR19UVCgidHJhbnNwb3J0IHRhc2s6ICVwIGNtZDogJXAgdGltZW91dCB0YXNrX3N0b3AiCisJCQkJIiA9PSAxXG4iLCB0YXNrLCBjbWQpOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJCWNvbXBsZXRlKCZ0YXNrLT50YXNrX3N0b3BfY29tcCk7CisJCXJldHVybjsKKwl9CisKKwlpZiAoIShhdG9taWNfZGVjX2FuZF90ZXN0KCZUX1RBU0soY21kKS0+dF90YXNrX2NkYnNfbGVmdCkpKSB7CisJCURFQlVHX1RUKCJ0cmFuc3BvcnQgdGFzazogJXAgY21kOiAlcCB0aW1lb3V0IG5vbiB6ZXJvIgorCQkJCSIgdF90YXNrX2NkYnNfbGVmdFxuIiwgdGFzaywgY21kKTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCQlyZXR1cm47CisJfQorCURFQlVHX1RUKCJ0cmFuc3BvcnQgdGFzazogJXAgY21kOiAlcCB0aW1lb3V0IFpFUk8gdF90YXNrX2NkYnNfbGVmdFxuIiwKKwkJCXRhc2ssIGNtZCk7CisKKwljbWQtPnRfc3RhdGUgPSBUUkFOU1BPUlRfQ09NUExFVEVfRkFJTFVSRTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisKKwl0cmFuc3BvcnRfYWRkX2NtZF90b19xdWV1ZShjbWQsIFRSQU5TUE9SVF9DT01QTEVURV9GQUlMVVJFKTsKK30KKworLyoKKyAqIENhbGxlZCB3aXRoIFRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2sgaGVsZC4KKyAqLworc3RhdGljIHZvaWQgdHJhbnNwb3J0X3N0YXJ0X3Rhc2tfdGltZXIoc3RydWN0IHNlX3Rhc2sgKnRhc2spCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gdGFzay0+c2VfZGV2OworCWludCB0aW1lb3V0OworCisJaWYgKHRhc2stPnRhc2tfZmxhZ3MgJiBURl9SVU5OSU5HKQorCQlyZXR1cm47CisJLyoKKwkgKiBJZiB0aGUgdGFza190aW1lb3V0IGlzIGRpc2FibGVkLCBleGl0IG5vdy4KKwkgKi8KKwl0aW1lb3V0ID0gREVWX0FUVFJJQihkZXYpLT50YXNrX3RpbWVvdXQ7CisJaWYgKCEodGltZW91dCkpCisJCXJldHVybjsKKworCWluaXRfdGltZXIoJnRhc2stPnRhc2tfdGltZXIpOworCXRhc2stPnRhc2tfdGltZXIuZXhwaXJlcyA9IChnZXRfamlmZmllc182NCgpICsgdGltZW91dCAqIEhaKTsKKwl0YXNrLT50YXNrX3RpbWVyLmRhdGEgPSAodW5zaWduZWQgbG9uZykgdGFzazsKKwl0YXNrLT50YXNrX3RpbWVyLmZ1bmN0aW9uID0gdHJhbnNwb3J0X3Rhc2tfdGltZW91dF9oYW5kbGVyOworCisJdGFzay0+dGFza19mbGFncyB8PSBURl9SVU5OSU5HOworCWFkZF90aW1lcigmdGFzay0+dGFza190aW1lcik7CisjaWYgMAorCXByaW50ayhLRVJOX0lORk8gIlN0YXJ0aW5nIHRhc2sgdGltZXIgZm9yIGNtZDogJXAgdGFzazogJXAgc2Vjb25kczoiCisJCSIgJWRcbiIsIHRhc2stPnRhc2tfc2VfY21kLCB0YXNrLCB0aW1lb3V0KTsKKyNlbmRpZgorfQorCisvKgorICogQ2FsbGVkIHdpdGggc3Bpbl9sb2NrX2lycSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaykgaGVsZC4KKyAqLwordm9pZCBfX3RyYW5zcG9ydF9zdG9wX3Rhc2tfdGltZXIoc3RydWN0IHNlX3Rhc2sgKnRhc2ssIHVuc2lnbmVkIGxvbmcgKmZsYWdzKQoreworCXN0cnVjdCBzZV9jbWQgKmNtZCA9IFRBU0tfQ01EKHRhc2spOworCisJaWYgKCEodGFzay0+dGFza19mbGFncyAmIFRGX1JVTk5JTkcpKQorCQlyZXR1cm47CisKKwl0YXNrLT50YXNrX2ZsYWdzIHw9IFRGX1NUT1A7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgKmZsYWdzKTsKKworCWRlbF90aW1lcl9zeW5jKCZ0YXNrLT50YXNrX3RpbWVyKTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCAqZmxhZ3MpOworCXRhc2stPnRhc2tfZmxhZ3MgJj0gflRGX1JVTk5JTkc7CisJdGFzay0+dGFza19mbGFncyAmPSB+VEZfU1RPUDsKK30KKworc3RhdGljIHZvaWQgdHJhbnNwb3J0X3N0b3BfYWxsX3Rhc2tfdGltZXJzKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzayA9IE5VTEwsICp0YXNrX3RtcDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUodGFzaywgdGFza190bXAsCisJCQkJJlRfVEFTSyhjbWQpLT50X3Rhc2tfbGlzdCwgdF9saXN0KQorCQlfX3RyYW5zcG9ydF9zdG9wX3Rhc2tfdGltZXIodGFzaywgJmZsYWdzKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHRyYW5zcG9ydF90Y3Ffd2luZG93X2Nsb3NlZChzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpCit7CisJaWYgKGRldi0+ZGV2X3RjcV93aW5kb3dfY2xvc2VkKysgPAorCQkJUFlYX1RSQU5TUE9SVF9XSU5ET1dfQ0xPU0VEX1RIUkVTSE9MRCkgeworCQltc2xlZXAoUFlYX1RSQU5TUE9SVF9XSU5ET1dfQ0xPU0VEX1dBSVRfU0hPUlQpOworCX0gZWxzZQorCQltc2xlZXAoUFlYX1RSQU5TUE9SVF9XSU5ET1dfQ0xPU0VEX1dBSVRfTE9ORyk7CisKKwl3YWtlX3VwX2ludGVycnVwdGlibGUoJmRldi0+ZGV2X3F1ZXVlX29iai0+dGhyZWFkX3dxKTsKKwlyZXR1cm4gMDsKK30KKworLyoKKyAqIENhbGxlZCBmcm9tIEZhYnJpYyBNb2R1bGUgY29udGV4dCBmcm9tIHRyYW5zcG9ydF9leGVjdXRlX3Rhc2tzKCkKKyAqCisgKiBUaGUgcmV0dXJuIG9mIHRoaXMgZnVuY3Rpb24gZGV0ZXJtaW5zIGlmIHRoZSB0YXNrcyBmcm9tIHN0cnVjdCBzZV9jbWQKKyAqIGdldCBhZGRlZCB0byB0aGUgZXhlY3V0aW9uIHF1ZXVlIGluIHRyYW5zcG9ydF9leGVjdXRlX3Rhc2tzKCksCisgKiBvciBhcmUgYWRkZWQgdG8gdGhlIGRlbGF5ZWQgb3Igb3JkZXJlZCBsaXN0cyBoZXJlLgorICovCitzdGF0aWMgaW5saW5lIGludCB0cmFuc3BvcnRfZXhlY3V0ZV90YXNrX2F0dHIoc3RydWN0IHNlX2NtZCAqY21kKQoreworCWlmIChTRV9ERVYoY21kKS0+ZGV2X3Rhc2tfYXR0cl90eXBlICE9IFNBTV9UQVNLX0FUVFJfRU1VTEFURUQpCisJCXJldHVybiAxOworCS8qCisJICogQ2hlY2sgZm9yIHRoZSBleGlzdGFuY2Ugb2YgSEVBRF9PRl9RVUVVRSwgYW5kIGlmIHRydWUgcmV0dXJuIDEKKwkgKiB0byBhbGxvdyB0aGUgcGFzc2VkIHN0cnVjdCBzZV9jbWQgbGlzdCBvZiB0YXNrcyB0byB0aGUgZnJvbnQgb2YgdGhlIGxpc3QuCisJICovCisJIGlmIChjbWQtPnNhbV90YXNrX2F0dHIgPT0gVEFTS19BVFRSX0hPUSkgeworCQlhdG9taWNfaW5jKCZTRV9ERVYoY21kKS0+ZGV2X2hvcV9jb3VudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2luYygpOworCQlERUJVR19TVEEoIkFkZGVkIEhFQURfT0ZfUVVFVUUgZm9yIENEQjoiCisJCQkiIDB4JTAyeCwgc2Vfb3JkZXJlZF9pZDogJXVcbiIsCisJCQlUX1RBU0soY21kKS0+dF90YXNrX2NkYlswXSwKKwkJCWNtZC0+c2Vfb3JkZXJlZF9pZCk7CisJCXJldHVybiAxOworCX0gZWxzZSBpZiAoY21kLT5zYW1fdGFza19hdHRyID09IFRBU0tfQVRUUl9PUkRFUkVEKSB7CisJCXNwaW5fbG9jaygmU0VfREVWKGNtZCktPm9yZGVyZWRfY21kX2xvY2spOworCQlsaXN0X2FkZF90YWlsKCZjbWQtPnNlX29yZGVyZWRfbGlzdCwKKwkJCQkmU0VfREVWKGNtZCktPm9yZGVyZWRfY21kX2xpc3QpOworCQlzcGluX3VubG9jaygmU0VfREVWKGNtZCktPm9yZGVyZWRfY21kX2xvY2spOworCisJCWF0b21pY19pbmMoJlNFX0RFVihjbWQpLT5kZXZfb3JkZXJlZF9zeW5jKTsKKwkJc21wX21iX19hZnRlcl9hdG9taWNfaW5jKCk7CisKKwkJREVCVUdfU1RBKCJBZGRlZCBPUkRFUkVEIGZvciBDREI6IDB4JTAyeCB0byBvcmRlcmVkIgorCQkJCSIgbGlzdCwgc2Vfb3JkZXJlZF9pZDogJXVcbiIsCisJCQkJVF9UQVNLKGNtZCktPnRfdGFza19jZGJbMF0sCisJCQkJY21kLT5zZV9vcmRlcmVkX2lkKTsKKwkJLyoKKwkJICogQWRkIE9SREVSRUQgY29tbWFuZCB0byB0YWlsIG9mIGV4ZWN1dGlvbiBxdWV1ZSBpZgorCQkgKiBubyBvdGhlciBvbGRlciBjb21tYW5kcyBleGlzdCB0aGF0IG5lZWQgdG8gYmUKKwkJICogY29tcGxldGVkIGZpcnN0LgorCQkgKi8KKwkJaWYgKCEoYXRvbWljX3JlYWQoJlNFX0RFVihjbWQpLT5zaW1wbGVfY21kcykpKQorCQkJcmV0dXJuIDE7CisJfSBlbHNlIHsKKwkJLyoKKwkJICogRm9yIFNJTVBMRSBhbmQgVU5UQUdHRUQgVGFzayBBdHRyaWJ1dGUgY29tbWFuZHMKKwkJICovCisJCWF0b21pY19pbmMoJlNFX0RFVihjbWQpLT5zaW1wbGVfY21kcyk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2luYygpOworCX0KKwkvKgorCSAqIE90aGVyd2lzZSBpZiBvbmUgb3IgbW9yZSBvdXRzdGFuZGluZyBPUkRFUkVEIHRhc2sgYXR0cmlidXRlIGV4aXN0LAorCSAqIGFkZCB0aGUgZG9ybWFudCB0YXNrKHMpIGJ1aWx0IGZvciB0aGUgcGFzc2VkIHN0cnVjdCBzZV9jbWQgdG8gdGhlCisJICogZXhlY3V0aW9uIHF1ZXVlIGFuZCBiZWNvbWUgaW4gQWN0aXZlIHN0YXRlIGZvciB0aGlzIHN0cnVjdCBzZV9kZXZpY2UuCisJICovCisJaWYgKGF0b21pY19yZWFkKCZTRV9ERVYoY21kKS0+ZGV2X29yZGVyZWRfc3luYykgIT0gMCkgeworCQkvKgorCQkgKiBPdGhlcndpc2UsIGFkZCBjbWQgdy8gdGFza3MgdG8gZGVsYXllZCBjbWQgcXVldWUgdGhhdAorCQkgKiB3aWxsIGJlIGRyYWluZWQgdXBvbiBjb21wZXRpb24gb2YgSEVBRF9PRl9RVUVVRSB0YXNrLgorCQkgKi8KKwkJc3Bpbl9sb2NrKCZTRV9ERVYoY21kKS0+ZGVsYXllZF9jbWRfbG9jayk7CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9ERUxBWUVEX0NNRF9GUk9NX1NBTV9BVFRSOworCQlsaXN0X2FkZF90YWlsKCZjbWQtPnNlX2RlbGF5ZWRfbGlzdCwKKwkJCQkmU0VfREVWKGNtZCktPmRlbGF5ZWRfY21kX2xpc3QpOworCQlzcGluX3VubG9jaygmU0VfREVWKGNtZCktPmRlbGF5ZWRfY21kX2xvY2spOworCisJCURFQlVHX1NUQSgiQWRkZWQgQ0RCOiAweCUwMnggVGFzayBBdHRyOiAweCUwMnggdG8iCisJCQkiIGRlbGF5ZWQgQ01EIGxpc3QsIHNlX29yZGVyZWRfaWQ6ICV1XG4iLAorCQkJVF9UQVNLKGNtZCktPnRfdGFza19jZGJbMF0sIGNtZC0+c2FtX3Rhc2tfYXR0ciwKKwkJCWNtZC0+c2Vfb3JkZXJlZF9pZCk7CisJCS8qCisJCSAqIFJldHVybiB6ZXJvIHRvIGxldCB0cmFuc3BvcnRfZXhlY3V0ZV90YXNrcygpIGtub3cKKwkJICogbm90IHRvIGFkZCB0aGUgZGVsYXllZCB0YXNrcyB0byB0aGUgZXhlY3V0aW9uIGxpc3QuCisJCSAqLworCQlyZXR1cm4gMDsKKwl9CisJLyoKKwkgKiBPdGhlcndpc2UsIG5vIE9SREVSRUQgdGFzayBhdHRyaWJ1dGVzIGV4aXN0Li4KKwkgKi8KKwlyZXR1cm4gMTsKK30KKworLyoKKyAqIENhbGxlZCBmcm9tIGZhYnJpYyBtb2R1bGUgY29udGV4dCBpbiB0cmFuc3BvcnRfZ2VuZXJpY19uZXdfY21kKCkgYW5kCisgKiB0cmFuc3BvcnRfZ2VuZXJpY19wcm9jZXNzX3dyaXRlKCkKKyAqLworc3RhdGljIGludCB0cmFuc3BvcnRfZXhlY3V0ZV90YXNrcyhzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJaW50IGFkZF90YXNrczsKKworCWlmICghKGNtZC0+c2VfY21kX2ZsYWdzICYgU0NGX1NFX0RJU0FCTEVfT05MSU5FX0NIRUNLKSkgeworCQlpZiAoc2VfZGV2X2NoZWNrX29ubGluZShjbWQtPnNlX29yaWdfb2JqX3B0cikgIT0gMCkgeworCQkJY21kLT50cmFuc3BvcnRfZXJyb3Jfc3RhdHVzID0KKwkJCQlQWVhfVFJBTlNQT1JUX0xVX0NPTU1fRkFJTFVSRTsKKwkJCXRyYW5zcG9ydF9nZW5lcmljX3JlcXVlc3RfZmFpbHVyZShjbWQsIE5VTEwsIDAsIDEpOworCQkJcmV0dXJuIDA7CisJCX0KKwl9CisJLyoKKwkgKiBDYWxsIHRyYW5zcG9ydF9jbWRfY2hlY2tfc3RvcCgpIHRvIHNlZSBpZiBhIGZhYnJpYyBleGNlcHRpb24KKwkgKiBoYXMgb2NjdXJlZCB0aGF0IHByZXZlbnRzIGV4ZWN1dGlvbi4KKwkgKi8KKwlpZiAoISh0cmFuc3BvcnRfY21kX2NoZWNrX3N0b3AoY21kLCAwLCBUUkFOU1BPUlRfUFJPQ0VTU0lORykpKSB7CisJCS8qCisJCSAqIENoZWNrIGZvciBTQU0gVGFzayBBdHRyaWJ1dGUgZW11bGF0aW9uIGFuZCBIRUFEX09GX1FVRVVFCisJCSAqIGF0dHJpYnV0ZSBmb3IgdGhlIHRhc2tzIG9mIHRoZSByZWNlaXZlZCBzdHJ1Y3Qgc2VfY21kIENEQgorCQkgKi8KKwkJYWRkX3Rhc2tzID0gdHJhbnNwb3J0X2V4ZWN1dGVfdGFza19hdHRyKGNtZCk7CisJCWlmIChhZGRfdGFza3MgPT0gMCkKKwkJCWdvdG8gZXhlY3V0ZV90YXNrczsKKwkJLyoKKwkJICogVGhpcyBjYWxscyB0cmFuc3BvcnRfYWRkX3Rhc2tzX2Zyb21fY21kKCkgdG8gaGFuZGxlCisJCSAqIEhFQURfT0ZfUVVFVUUgb3JkZXJpbmcgZm9yIFNBTSBUYXNrIEF0dHJpYnV0ZSBlbXVsYXRpb24KKwkJICogKGlmIGVuYWJsZWQpIGluIF9fdHJhbnNwb3J0X2FkZF90YXNrX3RvX2V4ZWN1dGVfcXVldWUoKSBhbmQKKwkJICogdHJhbnNwb3J0X2FkZF90YXNrX2NoZWNrX3NhbV9hdHRyKCkuCisJCSAqLworCQl0cmFuc3BvcnRfYWRkX3Rhc2tzX2Zyb21fY21kKGNtZCk7CisJfQorCS8qCisJICogS2ljayB0aGUgZXhlY3V0aW9uIHF1ZXVlIGZvciB0aGUgY21kIGFzc29jaWF0ZWQgc3RydWN0IHNlX2RldmljZQorCSAqIHN0b3JhZ2Ugb2JqZWN0LgorCSAqLworZXhlY3V0ZV90YXNrczoKKwlfX3RyYW5zcG9ydF9leGVjdXRlX3Rhc2tzKFNFX0RFVihjbWQpKTsKKwlyZXR1cm4gMDsKK30KKworLyoKKyAqIENhbGxlZCB0byBjaGVjayBzdHJ1Y3Qgc2VfZGV2aWNlIHRjcSBkZXB0aCB3aW5kb3csIGFuZCBvbmNlIG9wZW4gcHVsbCBzdHJ1Y3Qgc2VfdGFzaworICogZnJvbSBzdHJ1Y3Qgc2VfZGV2aWNlLT5leGVjdXRlX3Rhc2tfbGlzdCBhbmQKKyAqCisgKiBDYWxsZWQgZnJvbSB0cmFuc3BvcnRfcHJvY2Vzc2luZ190aHJlYWQoKQorICovCitzdGF0aWMgaW50IF9fdHJhbnNwb3J0X2V4ZWN1dGVfdGFza3Moc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCWludCBlcnJvcjsKKwlzdHJ1Y3Qgc2VfY21kICpjbWQgPSBOVUxMOworCXN0cnVjdCBzZV90YXNrICp0YXNrOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwkvKgorCSAqIENoZWNrIGlmIHRoZXJlIGlzIGVub3VnaCByb29tIGluIHRoZSBkZXZpY2UgYW5kIEhCQSBxdWV1ZSB0byBzZW5kCisJICogc3RydWN0IHNlX3RyYW5zcG9ydF90YXNrJ3MgdG8gdGhlIHNlbGVjdGVkIHRyYW5zcG9ydC4KKwkgKi8KK2NoZWNrX2RlcHRoOgorCXNwaW5fbG9ja19pcnFzYXZlKCZTRV9IQkEoZGV2KS0+aGJhX3F1ZXVlX2xvY2ssIGZsYWdzKTsKKwlpZiAoIShhdG9taWNfcmVhZCgmZGV2LT5kZXB0aF9sZWZ0KSkgfHwKKwkgICAgIShhdG9taWNfcmVhZCgmU0VfSEJBKGRldiktPmxlZnRfcXVldWVfZGVwdGgpKSkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZTRV9IQkEoZGV2KS0+aGJhX3F1ZXVlX2xvY2ssIGZsYWdzKTsKKwkJcmV0dXJuIHRyYW5zcG9ydF90Y3Ffd2luZG93X2Nsb3NlZChkZXYpOworCX0KKwlkZXYtPmRldl90Y3Ffd2luZG93X2Nsb3NlZCA9IDA7CisKKwlzcGluX2xvY2soJmRldi0+ZXhlY3V0ZV90YXNrX2xvY2spOworCXRhc2sgPSB0cmFuc3BvcnRfZ2V0X3Rhc2tfZnJvbV9leGVjdXRlX3F1ZXVlKGRldik7CisJc3Bpbl91bmxvY2soJmRldi0+ZXhlY3V0ZV90YXNrX2xvY2spOworCisJaWYgKCF0YXNrKSB7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlNFX0hCQShkZXYpLT5oYmFfcXVldWVfbG9jaywgZmxhZ3MpOworCQlyZXR1cm4gMDsKKwl9CisKKwlhdG9taWNfZGVjKCZkZXYtPmRlcHRoX2xlZnQpOworCWF0b21pY19kZWMoJlNFX0hCQShkZXYpLT5sZWZ0X3F1ZXVlX2RlcHRoKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZTRV9IQkEoZGV2KS0+aGJhX3F1ZXVlX2xvY2ssIGZsYWdzKTsKKworCWNtZCA9IFRBU0tfQ01EKHRhc2spOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwlhdG9taWNfc2V0KCZ0YXNrLT50YXNrX2FjdGl2ZSwgMSk7CisJYXRvbWljX3NldCgmdGFzay0+dGFza19zZW50LCAxKTsKKwlhdG9taWNfaW5jKCZUX1RBU0soY21kKS0+dF90YXNrX2NkYnNfc2VudCk7CisKKwlpZiAoYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X3Rhc2tfY2Ric19zZW50KSA9PQorCSAgICBUX1RBU0soY21kKS0+dF90YXNrX2NkYnMpCisJCWF0b21pY19zZXQoJmNtZC0+dHJhbnNwb3J0X3NlbnQsIDEpOworCisJdHJhbnNwb3J0X3N0YXJ0X3Rhc2tfdGltZXIodGFzayk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCS8qCisJICogVGhlIHN0cnVjdCBzZV9jbWQtPnRyYW5zcG9ydF9lbXVsYXRlX2NkYigpIGZ1bmN0aW9uIHBvaW50ZXIgaXMgdXNlZAorCSAqIHRvIGdyYWIgUkVQT1JUX0xVTlMgQ0RCcyBiZWZvcmUgdGhleSBoaXQgdGhlCisJICogc3RydWN0IHNlX3N1YnN5c3RlbV9hcGktPmRvX3Rhc2soKSBjYWxsZXIgYmVsb3cuCisJICovCisJaWYgKGNtZC0+dHJhbnNwb3J0X2VtdWxhdGVfY2RiKSB7CisJCWVycm9yID0gY21kLT50cmFuc3BvcnRfZW11bGF0ZV9jZGIoY21kKTsKKwkJaWYgKGVycm9yICE9IDApIHsKKwkJCWNtZC0+dHJhbnNwb3J0X2Vycm9yX3N0YXR1cyA9IGVycm9yOworCQkJYXRvbWljX3NldCgmdGFzay0+dGFza19hY3RpdmUsIDApOworCQkJYXRvbWljX3NldCgmY21kLT50cmFuc3BvcnRfc2VudCwgMCk7CisJCQl0cmFuc3BvcnRfc3RvcF90YXNrc19mb3JfY21kKGNtZCk7CisJCQl0cmFuc3BvcnRfZ2VuZXJpY19yZXF1ZXN0X2ZhaWx1cmUoY21kLCBkZXYsIDAsIDEpOworCQkJZ290byBjaGVja19kZXB0aDsKKwkJfQorCQkvKgorCQkgKiBIYW5kbGUgdGhlIHN1Y2Nlc3NmdWwgY29tcGxldGlvbiBmb3IgdHJhbnNwb3J0X2VtdWxhdGVfY2RiKCkKKwkJICogZm9yIHN5bmNocm9ub3VzIG9wZXJhdGlvbiwgZm9sbG93aW5nIFNDRl9FTVVMQVRFX0NEQl9BU1lOQworCQkgKiBPdGhlcndpc2UgdGhlIGNhbGxlciBpcyBleHBlY3RlZCB0byBjb21wbGV0ZSB0aGUgdGFzayB3aXRoCisJCSAqIHByb3BlciBzdGF0dXMuCisJCSAqLworCQlpZiAoIShjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9FTVVMQVRFX0NEQl9BU1lOQykpIHsKKwkJCWNtZC0+c2NzaV9zdGF0dXMgPSBTQU1fU1RBVF9HT09EOworCQkJdGFzay0+dGFza19zY3NpX3N0YXR1cyA9IEdPT0Q7CisJCQl0cmFuc3BvcnRfY29tcGxldGVfdGFzayh0YXNrLCAxKTsKKwkJfQorCX0gZWxzZSB7CisJCS8qCisJCSAqIEN1cnJlbnRseSBmb3IgYWxsIHZpcnR1YWwgVENNIHBsdWdpbnMgaW5jbHVkaW5nIElCTE9DSywgRklMRUlPIGFuZAorCQkgKiBSQU1ESVNLIHdlIHVzZSB0aGUgaW50ZXJuYWwgdHJhbnNwb3J0X2VtdWxhdGVfY29udHJvbF9jZGIoKSBsb2dpYworCQkgKiB3aXRoIHN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpIGNhbGxlcnMgZm9yIHRoZSBwcmltYXJ5IFNQQy0zIFRZUEVfRElTSworCQkgKiBMVU4gZW11bGF0aW9uIGNvZGUuCisJCSAqCisJCSAqIEZvciBUQ00vcFNDU0kgYW5kIGFsbCBvdGhlciBTQ0ZfU0NTSV9EQVRBX1NHX0lPX0NEQiBJL08gdGFza3Mgd2UKKwkJICogY2FsbCAtPmRvX3Rhc2soKSBkaXJlY3RseSBhbmQgbGV0IHRoZSB1bmRlcmx5aW5nIFRDTSBzdWJzeXN0ZW0gcGx1Z2luCisJCSAqIGNvZGUgaGFuZGxlIHRoZSBDREIgZW11bGF0aW9uLgorCQkgKi8KKwkJaWYgKChUUkFOU1BPUlQoZGV2KS0+dHJhbnNwb3J0X3R5cGUgIT0gVFJBTlNQT1JUX1BMVUdJTl9QSEJBX1BERVYpICYmCisJCSAgICAoIShUQVNLX0NNRCh0YXNrKS0+c2VfY21kX2ZsYWdzICYgU0NGX1NDU0lfREFUQV9TR19JT19DREIpKSkKKwkJCWVycm9yID0gdHJhbnNwb3J0X2VtdWxhdGVfY29udHJvbF9jZGIodGFzayk7CisJCWVsc2UKKwkJCWVycm9yID0gVFJBTlNQT1JUKGRldiktPmRvX3Rhc2sodGFzayk7CisKKwkJaWYgKGVycm9yICE9IDApIHsKKwkJCWNtZC0+dHJhbnNwb3J0X2Vycm9yX3N0YXR1cyA9IGVycm9yOworCQkJYXRvbWljX3NldCgmdGFzay0+dGFza19hY3RpdmUsIDApOworCQkJYXRvbWljX3NldCgmY21kLT50cmFuc3BvcnRfc2VudCwgMCk7CisJCQl0cmFuc3BvcnRfc3RvcF90YXNrc19mb3JfY21kKGNtZCk7CisJCQl0cmFuc3BvcnRfZ2VuZXJpY19yZXF1ZXN0X2ZhaWx1cmUoY21kLCBkZXYsIDAsIDEpOworCQl9CisJfQorCisJZ290byBjaGVja19kZXB0aDsKKworCXJldHVybiAwOworfQorCit2b2lkIHRyYW5zcG9ydF9uZXdfY21kX2ZhaWx1cmUoc3RydWN0IHNlX2NtZCAqc2VfY21kKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJLyoKKwkgKiBBbnkgdW5zb2xpY2l0ZWQgZGF0YSB3aWxsIGdldCBkdW1wZWQgZm9yIGZhaWxlZCBjb21tYW5kIGluc2lkZSBvZgorCSAqIHRoZSBmYWJyaWMgcGx1Z2luCisJICovCisJc3Bpbl9sb2NrX2lycXNhdmUoJlRfVEFTSyhzZV9jbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwlzZV9jbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0VfQ01EX0ZBSUxFRDsKKwlzZV9jbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DREJfRVhDRVBUSU9OOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhzZV9jbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKworCUNNRF9URk8oc2VfY21kKS0+bmV3X2NtZF9mYWlsdXJlKHNlX2NtZCk7Cit9CisKK3N0YXRpYyB2b2lkIHRyYW5zcG9ydF9ub3Bfd2FpdF9mb3JfdGFza3Moc3RydWN0IHNlX2NtZCAqLCBpbnQsIGludCk7CisKK3N0YXRpYyBpbmxpbmUgdTMyIHRyYW5zcG9ydF9nZXRfc2VjdG9yc182KAorCXVuc2lnbmVkIGNoYXIgKmNkYiwKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJaW50ICpyZXQpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gU0VfTFVOKGNtZCktPmx1bl9zZV9kZXY7CisKKwkvKgorCSAqIEFzc3VtZSBUWVBFX0RJU0sgZm9yIG5vbiBzdHJ1Y3Qgc2VfZGV2aWNlIG9iamVjdHMuCisJICogVXNlIDgtYml0IHNlY3RvciB2YWx1ZS4KKwkgKi8KKwlpZiAoIWRldikKKwkJZ290byB0eXBlX2Rpc2s7CisKKwkvKgorCSAqIFVzZSAyNC1iaXQgYWxsb2NhdGlvbiBsZW5ndGggZm9yIFRZUEVfVEFQRS4KKwkgKi8KKwlpZiAoVFJBTlNQT1JUKGRldiktPmdldF9kZXZpY2VfdHlwZShkZXYpID09IFRZUEVfVEFQRSkKKwkJcmV0dXJuICh1MzIpKGNkYlsyXSA8PCAxNikgKyAoY2RiWzNdIDw8IDgpICsgY2RiWzRdOworCisJLyoKKwkgKiBFdmVyeXRoaW5nIGVsc2UgYXNzdW1lIFRZUEVfRElTSyBTZWN0b3IgQ0RCIGxvY2F0aW9uLgorCSAqIFVzZSA4LWJpdCBzZWN0b3IgdmFsdWUuCisJICovCit0eXBlX2Rpc2s6CisJcmV0dXJuICh1MzIpY2RiWzRdOworfQorCitzdGF0aWMgaW5saW5lIHUzMiB0cmFuc3BvcnRfZ2V0X3NlY3RvcnNfMTAoCisJdW5zaWduZWQgY2hhciAqY2RiLAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwlpbnQgKnJldCkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9MVU4oY21kKS0+bHVuX3NlX2RldjsKKworCS8qCisJICogQXNzdW1lIFRZUEVfRElTSyBmb3Igbm9uIHN0cnVjdCBzZV9kZXZpY2Ugb2JqZWN0cy4KKwkgKiBVc2UgMTYtYml0IHNlY3RvciB2YWx1ZS4KKwkgKi8KKwlpZiAoIWRldikKKwkJZ290byB0eXBlX2Rpc2s7CisKKwkvKgorCSAqIFhYWF8xMCBpcyBub3QgZGVmaW5lZCBpbiBTU0MsIHRocm93IGFuIGV4Y2VwdGlvbgorCSAqLworCWlmIChUUkFOU1BPUlQoZGV2KS0+Z2V0X2RldmljZV90eXBlKGRldikgPT0gVFlQRV9UQVBFKSB7CisJCSpyZXQgPSAtMTsKKwkJcmV0dXJuIDA7CisJfQorCisJLyoKKwkgKiBFdmVyeXRoaW5nIGVsc2UgYXNzdW1lIFRZUEVfRElTSyBTZWN0b3IgQ0RCIGxvY2F0aW9uLgorCSAqIFVzZSAxNi1iaXQgc2VjdG9yIHZhbHVlLgorCSAqLwordHlwZV9kaXNrOgorCXJldHVybiAodTMyKShjZGJbN10gPDwgOCkgKyBjZGJbOF07Cit9CisKK3N0YXRpYyBpbmxpbmUgdTMyIHRyYW5zcG9ydF9nZXRfc2VjdG9yc18xMigKKwl1bnNpZ25lZCBjaGFyICpjZGIsCisJc3RydWN0IHNlX2NtZCAqY21kLAorCWludCAqcmV0KQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IFNFX0xVTihjbWQpLT5sdW5fc2VfZGV2OworCisJLyoKKwkgKiBBc3N1bWUgVFlQRV9ESVNLIGZvciBub24gc3RydWN0IHNlX2RldmljZSBvYmplY3RzLgorCSAqIFVzZSAzMi1iaXQgc2VjdG9yIHZhbHVlLgorCSAqLworCWlmICghZGV2KQorCQlnb3RvIHR5cGVfZGlzazsKKworCS8qCisJICogWFhYXzEyIGlzIG5vdCBkZWZpbmVkIGluIFNTQywgdGhyb3cgYW4gZXhjZXB0aW9uCisJICovCisJaWYgKFRSQU5TUE9SVChkZXYpLT5nZXRfZGV2aWNlX3R5cGUoZGV2KSA9PSBUWVBFX1RBUEUpIHsKKwkJKnJldCA9IC0xOworCQlyZXR1cm4gMDsKKwl9CisKKwkvKgorCSAqIEV2ZXJ5dGhpbmcgZWxzZSBhc3N1bWUgVFlQRV9ESVNLIFNlY3RvciBDREIgbG9jYXRpb24uCisJICogVXNlIDMyLWJpdCBzZWN0b3IgdmFsdWUuCisJICovCit0eXBlX2Rpc2s6CisJcmV0dXJuICh1MzIpKGNkYls2XSA8PCAyNCkgKyAoY2RiWzddIDw8IDE2KSArIChjZGJbOF0gPDwgOCkgKyBjZGJbOV07Cit9CisKK3N0YXRpYyBpbmxpbmUgdTMyIHRyYW5zcG9ydF9nZXRfc2VjdG9yc18xNigKKwl1bnNpZ25lZCBjaGFyICpjZGIsCisJc3RydWN0IHNlX2NtZCAqY21kLAorCWludCAqcmV0KQoreworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IFNFX0xVTihjbWQpLT5sdW5fc2VfZGV2OworCisJLyoKKwkgKiBBc3N1bWUgVFlQRV9ESVNLIGZvciBub24gc3RydWN0IHNlX2RldmljZSBvYmplY3RzLgorCSAqIFVzZSAzMi1iaXQgc2VjdG9yIHZhbHVlLgorCSAqLworCWlmICghZGV2KQorCQlnb3RvIHR5cGVfZGlzazsKKworCS8qCisJICogVXNlIDI0LWJpdCBhbGxvY2F0aW9uIGxlbmd0aCBmb3IgVFlQRV9UQVBFLgorCSAqLworCWlmIChUUkFOU1BPUlQoZGV2KS0+Z2V0X2RldmljZV90eXBlKGRldikgPT0gVFlQRV9UQVBFKQorCQlyZXR1cm4gKHUzMikoY2RiWzEyXSA8PCAxNikgKyAoY2RiWzEzXSA8PCA4KSArIGNkYlsxNF07CisKK3R5cGVfZGlzazoKKwlyZXR1cm4gKHUzMikoY2RiWzEwXSA8PCAyNCkgKyAoY2RiWzExXSA8PCAxNikgKworCQkgICAgKGNkYlsxMl0gPDwgOCkgKyBjZGJbMTNdOworfQorCisvKgorICogVXNlZCBmb3IgVkFSSUFCTEVfTEVOR1RIX0NEQiBXUklURV8zMiBhbmQgUkVBRF8zMiB2YXJpYW50cworICovCitzdGF0aWMgaW5saW5lIHUzMiB0cmFuc3BvcnRfZ2V0X3NlY3RvcnNfMzIoCisJdW5zaWduZWQgY2hhciAqY2RiLAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwlpbnQgKnJldCkKK3sKKwkvKgorCSAqIEFzc3VtZSBUWVBFX0RJU0sgZm9yIG5vbiBzdHJ1Y3Qgc2VfZGV2aWNlIG9iamVjdHMuCisJICogVXNlIDMyLWJpdCBzZWN0b3IgdmFsdWUuCisJICovCisJcmV0dXJuICh1MzIpKGNkYlsyOF0gPDwgMjQpICsgKGNkYlsyOV0gPDwgMTYpICsKKwkJICAgIChjZGJbMzBdIDw8IDgpICsgY2RiWzMxXTsKKworfQorCitzdGF0aWMgaW5saW5lIHUzMiB0cmFuc3BvcnRfZ2V0X3NpemUoCisJdTMyIHNlY3RvcnMsCisJdW5zaWduZWQgY2hhciAqY2RiLAorCXN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKworCWlmIChUUkFOU1BPUlQoZGV2KS0+Z2V0X2RldmljZV90eXBlKGRldikgPT0gVFlQRV9UQVBFKSB7CisJCWlmIChjZGJbMV0gJiAxKSB7IC8qIHNlY3RvcnMgKi8KKwkJCXJldHVybiBERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUgKiBzZWN0b3JzOworCQl9IGVsc2UgLyogYnl0ZXMgKi8KKwkJCXJldHVybiBzZWN0b3JzOworCX0KKyNpZiAwCisJcHJpbnRrKEtFUk5fSU5GTyAiUmV0dXJuaW5nIGJsb2NrX3NpemU6ICV1LCBzZWN0b3JzOiAldSA9PSAldSBmb3IiCisJCQkiICVzIG9iamVjdFxuIiwgREVWX0FUVFJJQihkZXYpLT5ibG9ja19zaXplLCBzZWN0b3JzLAorCQkJREVWX0FUVFJJQihkZXYpLT5ibG9ja19zaXplICogc2VjdG9ycywKKwkJCVRSQU5TUE9SVChkZXYpLT5uYW1lKTsKKyNlbmRpZgorCXJldHVybiBERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUgKiBzZWN0b3JzOworfQorCit1bnNpZ25lZCBjaGFyIHRyYW5zcG9ydF9hc2NpaWhleF90b19iaW5hcnloZXgodW5zaWduZWQgY2hhciB2YWxbMl0pCit7CisJdW5zaWduZWQgY2hhciByZXN1bHQgPSAwOworCS8qCisJICogTVNCCisJICovCisJaWYgKCh2YWxbMF0gPj0gJ2EnKSAmJiAodmFsWzBdIDw9ICdmJykpCisJCXJlc3VsdCA9ICgodmFsWzBdIC0gJ2EnICsgMTApICYgMHhmKSA8PCA0OworCWVsc2UKKwkJaWYgKCh2YWxbMF0gPj0gJ0EnKSAmJiAodmFsWzBdIDw9ICdGJykpCisJCQlyZXN1bHQgPSAoKHZhbFswXSAtICdBJyArIDEwKSAmIDB4ZikgPDwgNDsKKwkJZWxzZSAvKiBkaWdpdCAqLworCQkJcmVzdWx0ID0gKCh2YWxbMF0gLSAnMCcpICYgMHhmKSA8PCA0OworCS8qCisJICogTFNCCisJICovCisJaWYgKCh2YWxbMV0gPj0gJ2EnKSAmJiAodmFsWzFdIDw9ICdmJykpCisJCXJlc3VsdCB8PSAoKHZhbFsxXSAtICdhJyArIDEwKSAmIDB4Zik7CisJZWxzZQorCQlpZiAoKHZhbFsxXSA+PSAnQScpICYmICh2YWxbMV0gPD0gJ0YnKSkKKwkJCXJlc3VsdCB8PSAoKHZhbFsxXSAtICdBJyArIDEwKSAmIDB4Zik7CisJCWVsc2UgLyogZGlnaXQgKi8KKwkJCXJlc3VsdCB8PSAoKHZhbFsxXSAtICcwJykgJiAweGYpOworCisJcmV0dXJuIHJlc3VsdDsKK30KK0VYUE9SVF9TWU1CT0wodHJhbnNwb3J0X2FzY2lpaGV4X3RvX2JpbmFyeWhleCk7CisKK3N0YXRpYyB2b2lkIHRyYW5zcG9ydF94b3JfY2FsbGJhY2soc3RydWN0IHNlX2NtZCAqY21kKQoreworCXVuc2lnbmVkIGNoYXIgKmJ1ZiwgKmFkZHI7CisJc3RydWN0IHNlX21lbSAqc2VfbWVtOworCXVuc2lnbmVkIGludCBvZmZzZXQ7CisJaW50IGk7CisJLyoKKwkgKiBGcm9tIHNiYzNyMjIucGRmIHNlY3Rpb24gNS40OCBYRFdSSVRFUkVBRCAoMTApIGNvbW1hbmQKKwkgKgorCSAqIDEpIHJlYWQgdGhlIHNwZWNpZmllZCBsb2dpY2FsIGJsb2NrKHMpOworCSAqIDIpIHRyYW5zZmVyIGxvZ2ljYWwgYmxvY2tzIGZyb20gdGhlIGRhdGEtb3V0IGJ1ZmZlcjsKKwkgKiAzKSBYT1IgdGhlIGxvZ2ljYWwgYmxvY2tzIHRyYW5zZmVycmVkIGZyb20gdGhlIGRhdGEtb3V0IGJ1ZmZlciB3aXRoCisJICogICAgdGhlIGxvZ2ljYWwgYmxvY2tzIHJlYWQsIHN0b3JpbmcgdGhlIHJlc3VsdGluZyBYT1IgZGF0YSBpbiBhIGJ1ZmZlcjsKKwkgKiA0KSBpZiB0aGUgRElTQUJMRSBXUklURSBiaXQgaXMgc2V0IHRvIHplcm8sIHRoZW4gd3JpdGUgdGhlIGxvZ2ljYWwKKwkgKiAgICBibG9ja3MgdHJhbnNmZXJyZWQgZnJvbSB0aGUgZGF0YS1vdXQgYnVmZmVyOyBhbmQKKwkgKiA1KSB0cmFuc2ZlciB0aGUgcmVzdWx0aW5nIFhPUiBkYXRhIHRvIHRoZSBkYXRhLWluIGJ1ZmZlci4KKwkgKi8KKwlidWYgPSBrbWFsbG9jKGNtZC0+ZGF0YV9sZW5ndGgsIEdGUF9LRVJORUwpOworCWlmICghKGJ1ZikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gYWxsb2NhdGUgeG9yX2NhbGxiYWNrIGJ1ZlxuIik7CisJCXJldHVybjsKKwl9CisJLyoKKwkgKiBDb3B5IHRoZSBzY2F0dGVybGlzdCBXUklURSBidWZmZXIgbG9jYXRlZCBhdCBUX1RBU0soY21kKS0+dF9tZW1fbGlzdAorCSAqIGludG8gdGhlIGxvY2FsbHkgYWxsb2NhdGVkICpidWYKKwkgKi8KKwl0cmFuc3BvcnRfbWVtY3B5X3NlX21lbV9yZWFkX2NvbnRpZyhjbWQsIGJ1ZiwgVF9UQVNLKGNtZCktPnRfbWVtX2xpc3QpOworCS8qCisJICogTm93IHBlcmZvcm0gdGhlIFhPUiBhZ2FpbnN0IHRoZSBCSURJIHJlYWQgbWVtb3J5IGxvY2F0ZWQgYXQKKwkgKiBUX1RBU0soY21kKS0+dF9tZW1fYmlkaV9saXN0CisJICovCisKKwlvZmZzZXQgPSAwOworCWxpc3RfZm9yX2VhY2hfZW50cnkoc2VfbWVtLCBUX1RBU0soY21kKS0+dF9tZW1fYmlkaV9saXN0LCBzZV9saXN0KSB7CisJCWFkZHIgPSAodW5zaWduZWQgY2hhciAqKWttYXBfYXRvbWljKHNlX21lbS0+c2VfcGFnZSwgS01fVVNFUjApOworCQlpZiAoIShhZGRyKSkKKwkJCWdvdG8gb3V0OworCisJCWZvciAoaSA9IDA7IGkgPCBzZV9tZW0tPnNlX2xlbjsgaSsrKQorCQkJKihhZGRyICsgc2VfbWVtLT5zZV9vZmYgKyBpKSBePSAqKGJ1ZiArIG9mZnNldCArIGkpOworCisJCW9mZnNldCArPSBzZV9tZW0tPnNlX2xlbjsKKwkJa3VubWFwX2F0b21pYyhhZGRyLCBLTV9VU0VSMCk7CisJfQorb3V0OgorCWtmcmVlKGJ1Zik7Cit9CisKKy8qCisgKiBVc2VkIHRvIG9idGFpbiBTZW5zZSBEYXRhIGZyb20gdW5kZXJseWluZyBMaW51eC9TQ1NJIHN0cnVjdCBzY3NpX2NtbmQKKyAqLworc3RhdGljIGludCB0cmFuc3BvcnRfZ2V0X3NlbnNlX2RhdGEoc3RydWN0IHNlX2NtZCAqY21kKQoreworCXVuc2lnbmVkIGNoYXIgKmJ1ZmZlciA9IGNtZC0+c2Vuc2VfYnVmZmVyLCAqc2Vuc2VfYnVmZmVyID0gTlVMTDsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXY7CisJc3RydWN0IHNlX3Rhc2sgKnRhc2sgPSBOVUxMLCAqdGFza190bXA7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwl1MzIgb2Zmc2V0ID0gMDsKKworCWlmICghU0VfTFVOKGNtZCkpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJTRV9MVU4oY21kKSBpcyBOVUxMXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKwlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCWlmIChjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9TRU5UX0NIRUNLX0NPTkRJVElPTikgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJCXJldHVybiAwOworCX0KKworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSh0YXNrLCB0YXNrX3RtcCwKKwkJCQkmVF9UQVNLKGNtZCktPnRfdGFza19saXN0LCB0X2xpc3QpIHsKKworCQlpZiAoIXRhc2stPnRhc2tfc2Vuc2UpCisJCQljb250aW51ZTsKKworCQlkZXYgPSB0YXNrLT5zZV9kZXY7CisJCWlmICghKGRldikpCisJCQljb250aW51ZTsKKworCQlpZiAoIVRSQU5TUE9SVChkZXYpLT5nZXRfc2Vuc2VfYnVmZmVyKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIlRSQU5TUE9SVChkZXYpLT5nZXRfc2Vuc2VfYnVmZmVyIgorCQkJCQkiIGlzIE5VTExcbiIpOworCQkJY29udGludWU7CisJCX0KKworCQlzZW5zZV9idWZmZXIgPSBUUkFOU1BPUlQoZGV2KS0+Z2V0X3NlbnNlX2J1ZmZlcih0YXNrKTsKKwkJaWYgKCEoc2Vuc2VfYnVmZmVyKSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJJVFRbMHglMDh4XV9UQVNLWyVkXTogVW5hYmxlIHRvIGxvY2F0ZSIKKwkJCQkiIHNlbnNlIGJ1ZmZlciBmb3IgdGFzayB3aXRoIHNlbnNlXG4iLAorCQkJCUNNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCksIHRhc2stPnRhc2tfbm8pOworCQkJY29udGludWU7CisJCX0KKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCisJCW9mZnNldCA9IENNRF9URk8oY21kKS0+c2V0X2ZhYnJpY19zZW5zZV9sZW4oY21kLAorCQkJCVRSQU5TUE9SVF9TRU5TRV9CVUZGRVIpOworCisJCW1lbWNweSgodm9pZCAqKSZidWZmZXJbb2Zmc2V0XSwgKHZvaWQgKilzZW5zZV9idWZmZXIsCisJCQkJVFJBTlNQT1JUX1NFTlNFX0JVRkZFUik7CisJCWNtZC0+c2NzaV9zdGF0dXMgPSB0YXNrLT50YXNrX3Njc2lfc3RhdHVzOworCQkvKiBBdXRvbWF0aWNhbGx5IHBhZGRlZCAqLworCQljbWQtPnNjc2lfc2Vuc2VfbGVuZ3RoID0KKwkJCQkoVFJBTlNQT1JUX1NFTlNFX0JVRkZFUiArIG9mZnNldCk7CisKKwkJcHJpbnRrKEtFUk5fSU5GTyAiSEJBX1sldV1fUExVR1slc106IFNldCBTQU0gU1RBVFVTOiAweCUwMngiCisJCQkJIiBhbmQgc2Vuc2VcbiIsCisJCQlkZXYtPnNlX2hiYS0+aGJhX2lkLCBUUkFOU1BPUlQoZGV2KS0+bmFtZSwKKwkJCQljbWQtPnNjc2lfc3RhdHVzKTsKKwkJcmV0dXJuIDA7CisJfQorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKworCXJldHVybiAtMTsKK30KKworc3RhdGljIGludCB0cmFuc3BvcnRfYWxsb2NhdGVfcmVzb3VyY2VzKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwl1MzIgbGVuZ3RoID0gY21kLT5kYXRhX2xlbmd0aDsKKworCWlmICgoY21kLT5zZV9jbWRfZmxhZ3MgJiBTQ0ZfU0NTSV9EQVRBX1NHX0lPX0NEQikgfHwKKwkgICAgKGNtZC0+c2VfY21kX2ZsYWdzICYgU0NGX1NDU0lfQ09OVFJPTF9TR19JT19DREIpKQorCQlyZXR1cm4gdHJhbnNwb3J0X2dlbmVyaWNfZ2V0X21lbShjbWQsIGxlbmd0aCwgUEFHRV9TSVpFKTsKKwllbHNlIGlmIChjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9TQ1NJX0NPTlRST0xfTk9OU0dfSU9fQ0RCKQorCQlyZXR1cm4gdHJhbnNwb3J0X2dlbmVyaWNfYWxsb2NhdGVfYnVmKGNtZCwgbGVuZ3RoKTsKKwllbHNlCisJCXJldHVybiAwOworfQorCitzdGF0aWMgaW50Cit0cmFuc3BvcnRfaGFuZGxlX3Jlc2VydmF0aW9uX2NvbmZsaWN0KHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwljbWQtPnRyYW5zcG9ydF93YWl0X2Zvcl90YXNrcyA9ICZ0cmFuc3BvcnRfbm9wX3dhaXRfZm9yX3Rhc2tzOworCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0NEQl9FWENFUFRJT047CisJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfUkVTRVJWQVRJT05fQ09ORkxJQ1Q7CisJY21kLT5zY3NpX3N0YXR1cyA9IFNBTV9TVEFUX1JFU0VSVkFUSU9OX0NPTkZMSUNUOworCS8qCisJICogRm9yIFVBIEludGVybG9jayBDb2RlIDExYiwgYSBSRVNFUlZBVElPTiBDT05GTElDVCB3aWxsCisJICogZXN0YWJsaXNoIGEgVU5JVCBBVFRFTlRJT04gd2l0aCBQUkVWSU9VUyBSRVNFUlZBVElPTgorCSAqIENPTkZMSUNUIFNUQVRVUy4KKwkgKgorCSAqIFNlZSBzcGM0cjE3LCBzZWN0aW9uIDcuNC42IENvbnRyb2wgTW9kZSBQYWdlLCBUYWJsZSAzNDkKKwkgKi8KKwlpZiAoU0VfU0VTUyhjbWQpICYmCisJICAgIERFVl9BVFRSSUIoY21kLT5zZV9kZXYpLT5lbXVsYXRlX3VhX2ludGxja19jdHJsID09IDIpCisJCWNvcmVfc2NzaTNfdWFfYWxsb2NhdGUoU0VfU0VTUyhjbWQpLT5zZV9ub2RlX2FjbCwKKwkJCWNtZC0+b3JpZ19mZV9sdW4sIDB4MkMsCisJCQlBU0NRXzJDSF9QUkVWSU9VU19SRVNFUlZBVElPTl9DT05GTElDVF9TVEFUVVMpOworCXJldHVybiAtMjsKK30KKworLyoJdHJhbnNwb3J0X2dlbmVyaWNfY21kX3NlcXVlbmNlcigpOgorICoKKyAqCUdlbmVyaWMgQ29tbWFuZCBTZXF1ZW5jZXIgdGhhdCBzaG91bGQgd29yayBmb3IgbW9zdCBEQVMgdHJhbnNwb3J0CisgKglkcml2ZXJzLgorICoKKyAqCUNhbGxlZCBmcm9tIHRyYW5zcG9ydF9nZW5lcmljX2FsbG9jYXRlX3Rhc2tzKCkgaW4gdGhlICRGQUJSSUNfTU9ECisgKglSWCBUaHJlYWQuCisgKgorICoJRklYTUU6IE5lZWQgdG8gc3VwcG9ydCBvdGhlciBTQ1NJIE9QQ09ERVMgd2hlcmUgYXMgd2VsbC4KKyAqLworc3RhdGljIGludCB0cmFuc3BvcnRfZ2VuZXJpY19jbWRfc2VxdWVuY2VyKAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwl1bnNpZ25lZCBjaGFyICpjZGIpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gU0VfREVWKGNtZCk7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnN1X2RldiA9IGRldi0+c2Vfc3ViX2RldjsKKwlpbnQgcmV0ID0gMCwgc2VjdG9yX3JldCA9IDAsIHBhc3N0aHJvdWdoOworCXUzMiBzZWN0b3JzID0gMCwgc2l6ZSA9IDAsIHByX3JlZ190eXBlID0gMDsKKwl1MTYgc2VydmljZV9hY3Rpb247CisJdTggYWx1YV9hc2NxID0gMDsKKwkvKgorCSAqIENoZWNrIGZvciBhbiBleGlzdGluZyBVTklUIEFUVEVOVElPTiBjb25kaXRpb24KKwkgKi8KKwlpZiAoY29yZV9zY3NpM191YV9jaGVjayhjbWQsIGNkYikgPCAwKSB7CisJCWNtZC0+dHJhbnNwb3J0X3dhaXRfZm9yX3Rhc2tzID0KKwkJCQkmdHJhbnNwb3J0X25vcF93YWl0X2Zvcl90YXNrczsKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ0RCX0VYQ0VQVElPTjsKKwkJY21kLT5zY3NpX3NlbnNlX3JlYXNvbiA9IFRDTV9DSEVDS19DT05ESVRJT05fVU5JVF9BVFRFTlRJT047CisJCXJldHVybiAtMjsKKwl9CisJLyoKKwkgKiBDaGVjayBzdGF0dXMgb2YgQXN5bW1ldHJpYyBMb2dpY2FsIFVuaXQgQXNzaWdubWVudCBwb3J0CisJICovCisJcmV0ID0gVDEwX0FMVUEoc3VfZGV2KS0+YWx1YV9zdGF0ZV9jaGVjayhjbWQsIGNkYiwgJmFsdWFfYXNjcSk7CisJaWYgKHJldCAhPSAwKSB7CisJCWNtZC0+dHJhbnNwb3J0X3dhaXRfZm9yX3Rhc2tzID0gJnRyYW5zcG9ydF9ub3Bfd2FpdF9mb3JfdGFza3M7CisJCS8qCisJCSAqIFNldCBTQ1NJIGFkZGl0aW9uYWwgc2Vuc2UgY29kZSAoQVNDKSB0byAnTFVOIE5vdCBBY2Nlc3NhYmxlJzsKKwkJICogVGhlIEFMVUEgYWRkaXRpb25hbCBzZW5zZSBjb2RlIHF1YWxpZmllciAoQVNDUSkgaXMgZGV0ZXJtaW5lZAorCQkgKiBieSB0aGUgQUxVQSBwcmltYXJ5IG9yIHNlY29uZGFyeSBhY2Nlc3Mgc3RhdGUuLgorCQkgKi8KKwkJaWYgKHJldCA+IDApIHsKKyNpZiAwCisJCQlwcmludGsoS0VSTl9JTkZPICJbJXNdOiBBTFVBIFRHIFBvcnQgbm90IGF2YWlsYWJsZSwiCisJCQkJIiBTZW5zZUtleTogTk9UX1JFQURZLCBBU0MvQVNDUTogMHgwNC8weCUwMnhcbiIsCisJCQkJQ01EX1RGTyhjbWQpLT5nZXRfZmFicmljX25hbWUoKSwgYWx1YV9hc2NxKTsKKyNlbmRpZgorCQkJdHJhbnNwb3J0X3NldF9zZW5zZV9jb2RlcyhjbWQsIDB4MDQsIGFsdWFfYXNjcSk7CisJCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DREJfRVhDRVBUSU9OOworCQkJY21kLT5zY3NpX3NlbnNlX3JlYXNvbiA9IFRDTV9DSEVDS19DT05ESVRJT05fTk9UX1JFQURZOworCQkJcmV0dXJuIC0yOworCQl9CisJCWdvdG8gb3V0X2ludmFsaWRfY2RiX2ZpZWxkOworCX0KKwkvKgorCSAqIENoZWNrIHN0YXR1cyBmb3IgU1BDLTMgUGVyc2lzdGVudCBSZXNlcnZhdGlvbnMKKwkgKi8KKwlpZiAoVDEwX1BSX09QUyhzdV9kZXYpLT50MTBfcmVzZXJ2YXRpb25fY2hlY2soY21kLCAmcHJfcmVnX3R5cGUpICE9IDApIHsKKwkJaWYgKFQxMF9QUl9PUFMoc3VfZGV2KS0+dDEwX3NlcV9ub25faG9sZGVyKAorCQkJCQljbWQsIGNkYiwgcHJfcmVnX3R5cGUpICE9IDApCisJCQlyZXR1cm4gdHJhbnNwb3J0X2hhbmRsZV9yZXNlcnZhdGlvbl9jb25mbGljdChjbWQpOworCQkvKgorCQkgKiBUaGlzIG1lYW5zIHRoZSBDREIgaXMgYWxsb3dlZCBmb3IgdGhlIFNDU0kgSW5pdGlhdG9yIHBvcnQKKwkJICogd2hlbiBzYWlkIHBvcnQgaXMgKk5PVCogaG9sZGluZyB0aGUgbGVnYWN5IFNQQy0yIG9yCisJCSAqIFNQQy0zIFBlcnNpc3RlbnQgUmVzZXJ2YXRpb24uCisJCSAqLworCX0KKworCXN3aXRjaCAoY2RiWzBdKSB7CisJY2FzZSBSRUFEXzY6CisJCXNlY3RvcnMgPSB0cmFuc3BvcnRfZ2V0X3NlY3RvcnNfNihjZGIsIGNtZCwgJnNlY3Rvcl9yZXQpOworCQlpZiAoc2VjdG9yX3JldCkKKwkJCWdvdG8gb3V0X3Vuc3VwcG9ydGVkX2NkYjsKKwkJc2l6ZSA9IHRyYW5zcG9ydF9nZXRfc2l6ZShzZWN0b3JzLCBjZGIsIGNtZCk7CisJCWNtZC0+dHJhbnNwb3J0X3NwbGl0X2NkYiA9ICZzcGxpdF9jZGJfWFhfNjsKKwkJVF9UQVNLKGNtZCktPnRfdGFza19sYmEgPSB0cmFuc3BvcnRfbGJhXzIxKGNkYik7CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0RBVEFfU0dfSU9fQ0RCOworCQlicmVhazsKKwljYXNlIFJFQURfMTA6CisJCXNlY3RvcnMgPSB0cmFuc3BvcnRfZ2V0X3NlY3RvcnNfMTAoY2RiLCBjbWQsICZzZWN0b3JfcmV0KTsKKwkJaWYgKHNlY3Rvcl9yZXQpCisJCQlnb3RvIG91dF91bnN1cHBvcnRlZF9jZGI7CisJCXNpemUgPSB0cmFuc3BvcnRfZ2V0X3NpemUoc2VjdG9ycywgY2RiLCBjbWQpOworCQljbWQtPnRyYW5zcG9ydF9zcGxpdF9jZGIgPSAmc3BsaXRfY2RiX1hYXzEwOworCQlUX1RBU0soY21kKS0+dF90YXNrX2xiYSA9IHRyYW5zcG9ydF9sYmFfMzIoY2RiKTsKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfREFUQV9TR19JT19DREI7CisJCWJyZWFrOworCWNhc2UgUkVBRF8xMjoKKwkJc2VjdG9ycyA9IHRyYW5zcG9ydF9nZXRfc2VjdG9yc18xMihjZGIsIGNtZCwgJnNlY3Rvcl9yZXQpOworCQlpZiAoc2VjdG9yX3JldCkKKwkJCWdvdG8gb3V0X3Vuc3VwcG9ydGVkX2NkYjsKKwkJc2l6ZSA9IHRyYW5zcG9ydF9nZXRfc2l6ZShzZWN0b3JzLCBjZGIsIGNtZCk7CisJCWNtZC0+dHJhbnNwb3J0X3NwbGl0X2NkYiA9ICZzcGxpdF9jZGJfWFhfMTI7CisJCVRfVEFTSyhjbWQpLT50X3Rhc2tfbGJhID0gdHJhbnNwb3J0X2xiYV8zMihjZGIpOworCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9EQVRBX1NHX0lPX0NEQjsKKwkJYnJlYWs7CisJY2FzZSBSRUFEXzE2OgorCQlzZWN0b3JzID0gdHJhbnNwb3J0X2dldF9zZWN0b3JzXzE2KGNkYiwgY21kLCAmc2VjdG9yX3JldCk7CisJCWlmIChzZWN0b3JfcmV0KQorCQkJZ290byBvdXRfdW5zdXBwb3J0ZWRfY2RiOworCQlzaXplID0gdHJhbnNwb3J0X2dldF9zaXplKHNlY3RvcnMsIGNkYiwgY21kKTsKKwkJY21kLT50cmFuc3BvcnRfc3BsaXRfY2RiID0gJnNwbGl0X2NkYl9YWF8xNjsKKwkJVF9UQVNLKGNtZCktPnRfdGFza19sYmEgPSB0cmFuc3BvcnRfbGJhXzY0KGNkYik7CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0RBVEFfU0dfSU9fQ0RCOworCQlicmVhazsKKwljYXNlIFdSSVRFXzY6CisJCXNlY3RvcnMgPSB0cmFuc3BvcnRfZ2V0X3NlY3RvcnNfNihjZGIsIGNtZCwgJnNlY3Rvcl9yZXQpOworCQlpZiAoc2VjdG9yX3JldCkKKwkJCWdvdG8gb3V0X3Vuc3VwcG9ydGVkX2NkYjsKKwkJc2l6ZSA9IHRyYW5zcG9ydF9nZXRfc2l6ZShzZWN0b3JzLCBjZGIsIGNtZCk7CisJCWNtZC0+dHJhbnNwb3J0X3NwbGl0X2NkYiA9ICZzcGxpdF9jZGJfWFhfNjsKKwkJVF9UQVNLKGNtZCktPnRfdGFza19sYmEgPSB0cmFuc3BvcnRfbGJhXzIxKGNkYik7CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0RBVEFfU0dfSU9fQ0RCOworCQlicmVhazsKKwljYXNlIFdSSVRFXzEwOgorCQlzZWN0b3JzID0gdHJhbnNwb3J0X2dldF9zZWN0b3JzXzEwKGNkYiwgY21kLCAmc2VjdG9yX3JldCk7CisJCWlmIChzZWN0b3JfcmV0KQorCQkJZ290byBvdXRfdW5zdXBwb3J0ZWRfY2RiOworCQlzaXplID0gdHJhbnNwb3J0X2dldF9zaXplKHNlY3RvcnMsIGNkYiwgY21kKTsKKwkJY21kLT50cmFuc3BvcnRfc3BsaXRfY2RiID0gJnNwbGl0X2NkYl9YWF8xMDsKKwkJVF9UQVNLKGNtZCktPnRfdGFza19sYmEgPSB0cmFuc3BvcnRfbGJhXzMyKGNkYik7CisJCVRfVEFTSyhjbWQpLT50X3Rhc2tzX2Z1YSA9IChjZGJbMV0gJiAweDgpOworCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9EQVRBX1NHX0lPX0NEQjsKKwkJYnJlYWs7CisJY2FzZSBXUklURV8xMjoKKwkJc2VjdG9ycyA9IHRyYW5zcG9ydF9nZXRfc2VjdG9yc18xMihjZGIsIGNtZCwgJnNlY3Rvcl9yZXQpOworCQlpZiAoc2VjdG9yX3JldCkKKwkJCWdvdG8gb3V0X3Vuc3VwcG9ydGVkX2NkYjsKKwkJc2l6ZSA9IHRyYW5zcG9ydF9nZXRfc2l6ZShzZWN0b3JzLCBjZGIsIGNtZCk7CisJCWNtZC0+dHJhbnNwb3J0X3NwbGl0X2NkYiA9ICZzcGxpdF9jZGJfWFhfMTI7CisJCVRfVEFTSyhjbWQpLT50X3Rhc2tfbGJhID0gdHJhbnNwb3J0X2xiYV8zMihjZGIpOworCQlUX1RBU0soY21kKS0+dF90YXNrc19mdWEgPSAoY2RiWzFdICYgMHg4KTsKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfREFUQV9TR19JT19DREI7CisJCWJyZWFrOworCWNhc2UgV1JJVEVfMTY6CisJCXNlY3RvcnMgPSB0cmFuc3BvcnRfZ2V0X3NlY3RvcnNfMTYoY2RiLCBjbWQsICZzZWN0b3JfcmV0KTsKKwkJaWYgKHNlY3Rvcl9yZXQpCisJCQlnb3RvIG91dF91bnN1cHBvcnRlZF9jZGI7CisJCXNpemUgPSB0cmFuc3BvcnRfZ2V0X3NpemUoc2VjdG9ycywgY2RiLCBjbWQpOworCQljbWQtPnRyYW5zcG9ydF9zcGxpdF9jZGIgPSAmc3BsaXRfY2RiX1hYXzE2OworCQlUX1RBU0soY21kKS0+dF90YXNrX2xiYSA9IHRyYW5zcG9ydF9sYmFfNjQoY2RiKTsKKwkJVF9UQVNLKGNtZCktPnRfdGFza3NfZnVhID0gKGNkYlsxXSAmIDB4OCk7CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0RBVEFfU0dfSU9fQ0RCOworCQlicmVhazsKKwljYXNlIFhEV1JJVEVSRUFEXzEwOgorCQlpZiAoKGNtZC0+ZGF0YV9kaXJlY3Rpb24gIT0gRE1BX1RPX0RFVklDRSkgfHwKKwkJICAgICEoVF9UQVNLKGNtZCktPnRfdGFza3NfYmlkaSkpCisJCQlnb3RvIG91dF9pbnZhbGlkX2NkYl9maWVsZDsKKwkJc2VjdG9ycyA9IHRyYW5zcG9ydF9nZXRfc2VjdG9yc18xMChjZGIsIGNtZCwgJnNlY3Rvcl9yZXQpOworCQlpZiAoc2VjdG9yX3JldCkKKwkJCWdvdG8gb3V0X3Vuc3VwcG9ydGVkX2NkYjsKKwkJc2l6ZSA9IHRyYW5zcG9ydF9nZXRfc2l6ZShzZWN0b3JzLCBjZGIsIGNtZCk7CisJCWNtZC0+dHJhbnNwb3J0X3NwbGl0X2NkYiA9ICZzcGxpdF9jZGJfWFhfMTA7CisJCVRfVEFTSyhjbWQpLT50X3Rhc2tfbGJhID0gdHJhbnNwb3J0X2xiYV8zMihjZGIpOworCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9EQVRBX1NHX0lPX0NEQjsKKwkJcGFzc3Rocm91Z2ggPSAoVFJBTlNQT1JUKGRldiktPnRyYW5zcG9ydF90eXBlID09CisJCQkJVFJBTlNQT1JUX1BMVUdJTl9QSEJBX1BERVYpOworCQkvKgorCQkgKiBTa2lwIHRoZSByZW1haW5pbmcgYXNzaWdubWVudHMgZm9yIFRDTS9QU0NTSSBwYXNzdGhyb3VnaAorCQkgKi8KKwkJaWYgKHBhc3N0aHJvdWdoKQorCQkJYnJlYWs7CisJCS8qCisJCSAqIFNldHVwIEJJREkgWE9SIGNhbGxiYWNrIHRvIGJlIHJ1biBkdXJpbmcgdHJhbnNwb3J0X2dlbmVyaWNfY29tcGxldGVfb2soKQorCQkgKi8KKwkJY21kLT50cmFuc3BvcnRfY29tcGxldGVfY2FsbGJhY2sgPSAmdHJhbnNwb3J0X3hvcl9jYWxsYmFjazsKKwkJVF9UQVNLKGNtZCktPnRfdGFza3NfZnVhID0gKGNkYlsxXSAmIDB4OCk7CisJCWJyZWFrOworCWNhc2UgVkFSSUFCTEVfTEVOR1RIX0NNRDoKKwkJc2VydmljZV9hY3Rpb24gPSBnZXRfdW5hbGlnbmVkX2JlMTYoJmNkYls4XSk7CisJCS8qCisJCSAqIERldGVybWluZSBpZiB0aGlzIGlzIFRDTS9QU0NTSSBkZXZpY2UgYW5kIHdlIHNob3VsZCBkaXNhYmxlCisJCSAqIGludGVybmFsIGVtdWxhdGlvbiBmb3IgdGhpcyBDREIuCisJCSAqLworCQlwYXNzdGhyb3VnaCA9IChUUkFOU1BPUlQoZGV2KS0+dHJhbnNwb3J0X3R5cGUgPT0KKwkJCQkJVFJBTlNQT1JUX1BMVUdJTl9QSEJBX1BERVYpOworCisJCXN3aXRjaCAoc2VydmljZV9hY3Rpb24pIHsKKwkJY2FzZSBYRFdSSVRFUkVBRF8zMjoKKwkJCXNlY3RvcnMgPSB0cmFuc3BvcnRfZ2V0X3NlY3RvcnNfMzIoY2RiLCBjbWQsICZzZWN0b3JfcmV0KTsKKwkJCWlmIChzZWN0b3JfcmV0KQorCQkJCWdvdG8gb3V0X3Vuc3VwcG9ydGVkX2NkYjsKKwkJCXNpemUgPSB0cmFuc3BvcnRfZ2V0X3NpemUoc2VjdG9ycywgY2RiLCBjbWQpOworCQkJLyoKKwkJCSAqIFVzZSBXUklURV8zMiBhbmQgUkVBRF8zMiBvcGNvZGVzIGZvciB0aGUgZW11bGF0ZWQKKwkJCSAqIFhEV1JJVEVfUkVBRF8zMiBsb2dpYy4KKwkJCSAqLworCQkJY21kLT50cmFuc3BvcnRfc3BsaXRfY2RiID0gJnNwbGl0X2NkYl9YWF8zMjsKKwkJCVRfVEFTSyhjbWQpLT50X3Rhc2tfbGJhID0gdHJhbnNwb3J0X2xiYV82NF9leHQoY2RiKTsKKwkJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0RBVEFfU0dfSU9fQ0RCOworCisJCQkvKgorCQkJICogU2tpcCB0aGUgcmVtYWluaW5nIGFzc2lnbm1lbnRzIGZvciBUQ00vUFNDU0kgcGFzc3Rocm91Z2gKKwkJCSAqLworCQkJaWYgKHBhc3N0aHJvdWdoKQorCQkJCWJyZWFrOworCisJCQkvKgorCQkJICogU2V0dXAgQklESSBYT1IgY2FsbGJhY2sgdG8gYmUgcnVuIGR1cmluZworCQkJICogdHJhbnNwb3J0X2dlbmVyaWNfY29tcGxldGVfb2soKQorCQkJICovCisJCQljbWQtPnRyYW5zcG9ydF9jb21wbGV0ZV9jYWxsYmFjayA9ICZ0cmFuc3BvcnRfeG9yX2NhbGxiYWNrOworCQkJVF9UQVNLKGNtZCktPnRfdGFza3NfZnVhID0gKGNkYlsxMF0gJiAweDgpOworCQkJYnJlYWs7CisJCWNhc2UgV1JJVEVfU0FNRV8zMjoKKwkJCXNlY3RvcnMgPSB0cmFuc3BvcnRfZ2V0X3NlY3RvcnNfMzIoY2RiLCBjbWQsICZzZWN0b3JfcmV0KTsKKwkJCWlmIChzZWN0b3JfcmV0KQorCQkJCWdvdG8gb3V0X3Vuc3VwcG9ydGVkX2NkYjsKKwkJCXNpemUgPSB0cmFuc3BvcnRfZ2V0X3NpemUoc2VjdG9ycywgY2RiLCBjbWQpOworCQkJVF9UQVNLKGNtZCktPnRfdGFza19sYmEgPSBnZXRfdW5hbGlnbmVkX2JlNjQoJmNkYlsxMl0pOworCQkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ09OVFJPTF9TR19JT19DREI7CisKKwkJCS8qCisJCQkgKiBTa2lwIHRoZSByZW1haW5pbmcgYXNzaWdubWVudHMgZm9yIFRDTS9QU0NTSSBwYXNzdGhyb3VnaAorCQkJICovCisJCQlpZiAocGFzc3Rocm91Z2gpCisJCQkJYnJlYWs7CisKKwkJCWlmICgoY2RiWzEwXSAmIDB4MDQpIHx8IChjZGJbMTBdICYgMHgwMikpIHsKKwkJCQlwcmludGsoS0VSTl9FUlIgIldSSVRFX1NBTUUgUEJEQVRBIGFuZCBMQkRBVEEiCisJCQkJCSIgYml0cyBub3Qgc3VwcG9ydGVkIGZvciBCbG9jayBEaXNjYXJkIgorCQkJCQkiIEVtdWxhdGlvblxuIik7CisJCQkJZ290byBvdXRfaW52YWxpZF9jZGJfZmllbGQ7CisJCQl9CisJCQkvKgorCQkJICogQ3VycmVudGx5IGZvciB0aGUgZW11bGF0ZWQgY2FzZSB3ZSBvbmx5IGFjY2VwdAorCQkJICogdHB3cyB3aXRoIHRoZSBVTk1BUD0xIGJpdCBzZXQuCisJCQkgKi8KKwkJCWlmICghKGNkYlsxMF0gJiAweDA4KSkgeworCQkJCXByaW50ayhLRVJOX0VSUiAiV1JJVEVfU0FNRSB3L28gVU5NQVAgYml0IG5vdCIKKwkJCQkJIiBzdXBwb3J0ZWQgZm9yIEJsb2NrIERpc2NhcmQgRW11bGF0aW9uXG4iKTsKKwkJCQlnb3RvIG91dF9pbnZhbGlkX2NkYl9maWVsZDsKKwkJCX0KKwkJCWJyZWFrOworCQlkZWZhdWx0OgorCQkJcHJpbnRrKEtFUk5fRVJSICJWQVJJQUJMRV9MRU5HVEhfQ01EIHNlcnZpY2UgYWN0aW9uIgorCQkJCSIgMHglMDR4IG5vdCBzdXBwb3J0ZWRcbiIsIHNlcnZpY2VfYWN0aW9uKTsKKwkJCWdvdG8gb3V0X3Vuc3VwcG9ydGVkX2NkYjsKKwkJfQorCQlicmVhazsKKwljYXNlIDB4YTM6CisJCWlmIChUUkFOU1BPUlQoZGV2KS0+Z2V0X2RldmljZV90eXBlKGRldikgIT0gVFlQRV9ST00pIHsKKwkJCS8qIE1BSU5URU5BTkNFX0lOIGZyb20gU0NDLTIgKi8KKwkJCS8qCisJCQkgKiBDaGVjayBmb3IgZW11bGF0ZWQgTUlfUkVQT1JUX1RBUkdFVF9QR1MuCisJCQkgKi8KKwkJCWlmIChjZGJbMV0gPT0gTUlfUkVQT1JUX1RBUkdFVF9QR1MpIHsKKwkJCQljbWQtPnRyYW5zcG9ydF9lbXVsYXRlX2NkYiA9CisJCQkJKFQxMF9BTFVBKHN1X2RldiktPmFsdWFfdHlwZSA9PQorCQkJCSBTUEMzX0FMVUFfRU1VTEFURUQpID8KKwkJCQkmY29yZV9lbXVsYXRlX3JlcG9ydF90YXJnZXRfcG9ydF9ncm91cHMgOgorCQkJCU5VTEw7CisJCQl9CisJCQlzaXplID0gKGNkYls2XSA8PCAyNCkgfCAoY2RiWzddIDw8IDE2KSB8CisJCQkgICAgICAgKGNkYls4XSA8PCA4KSB8IGNkYls5XTsKKwkJfSBlbHNlIHsKKwkJCS8qIEdQQ01EX1NFTkRfS0VZIGZyb20gbXVsdGkgbWVkaWEgY29tbWFuZHMgKi8KKwkJCXNpemUgPSAoY2RiWzhdIDw8IDgpICsgY2RiWzldOworCQl9CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0NPTlRST0xfTk9OU0dfSU9fQ0RCOworCQlicmVhazsKKwljYXNlIE1PREVfU0VMRUNUOgorCQlzaXplID0gY2RiWzRdOworCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DT05UUk9MX1NHX0lPX0NEQjsKKwkJYnJlYWs7CisJY2FzZSBNT0RFX1NFTEVDVF8xMDoKKwkJc2l6ZSA9IChjZGJbN10gPDwgOCkgKyBjZGJbOF07CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0NPTlRST0xfU0dfSU9fQ0RCOworCQlicmVhazsKKwljYXNlIE1PREVfU0VOU0U6CisJCXNpemUgPSBjZGJbNF07CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0NPTlRST0xfTk9OU0dfSU9fQ0RCOworCQlicmVhazsKKwljYXNlIE1PREVfU0VOU0VfMTA6CisJY2FzZSBHUENNRF9SRUFEX0JVRkZFUl9DQVBBQ0lUWToKKwljYXNlIEdQQ01EX1NFTkRfT1BDOgorCWNhc2UgTE9HX1NFTEVDVDoKKwljYXNlIExPR19TRU5TRToKKwkJc2l6ZSA9IChjZGJbN10gPDwgOCkgKyBjZGJbOF07CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0NPTlRST0xfTk9OU0dfSU9fQ0RCOworCQlicmVhazsKKwljYXNlIFJFQURfQkxPQ0tfTElNSVRTOgorCQlzaXplID0gUkVBRF9CTE9DS19MRU47CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0NPTlRST0xfTk9OU0dfSU9fQ0RCOworCQlicmVhazsKKwljYXNlIEdQQ01EX0dFVF9DT05GSUdVUkFUSU9OOgorCWNhc2UgR1BDTURfUkVBRF9GT1JNQVRfQ0FQQUNJVElFUzoKKwljYXNlIEdQQ01EX1JFQURfRElTQ19JTkZPOgorCWNhc2UgR1BDTURfUkVBRF9UUkFDS19SWk9ORV9JTkZPOgorCQlzaXplID0gKGNkYls3XSA8PCA4KSArIGNkYls4XTsKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ09OVFJPTF9TR19JT19DREI7CisJCWJyZWFrOworCWNhc2UgUEVSU0lTVEVOVF9SRVNFUlZFX0lOOgorCWNhc2UgUEVSU0lTVEVOVF9SRVNFUlZFX09VVDoKKwkJY21kLT50cmFuc3BvcnRfZW11bGF0ZV9jZGIgPQorCQkJKFQxMF9SRVMoc3VfZGV2KS0+cmVzX3R5cGUgPT0KKwkJCSBTUEMzX1BFUlNJU1RFTlRfUkVTRVJWQVRJT05TKSA/CisJCQkmY29yZV9zY3NpM19lbXVsYXRlX3ByIDogTlVMTDsKKwkJc2l6ZSA9IChjZGJbN10gPDwgOCkgKyBjZGJbOF07CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0NPTlRST0xfTk9OU0dfSU9fQ0RCOworCQlicmVhazsKKwljYXNlIEdQQ01EX01FQ0hBTklTTV9TVEFUVVM6CisJY2FzZSBHUENNRF9SRUFEX0RWRF9TVFJVQ1RVUkU6CisJCXNpemUgPSAoY2RiWzhdIDw8IDgpICsgY2RiWzldOworCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DT05UUk9MX1NHX0lPX0NEQjsKKwkJYnJlYWs7CisJY2FzZSBSRUFEX1BPU0lUSU9OOgorCQlzaXplID0gUkVBRF9QT1NJVElPTl9MRU47CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0NPTlRST0xfTk9OU0dfSU9fQ0RCOworCQlicmVhazsKKwljYXNlIDB4YTQ6CisJCWlmIChUUkFOU1BPUlQoZGV2KS0+Z2V0X2RldmljZV90eXBlKGRldikgIT0gVFlQRV9ST00pIHsKKwkJCS8qIE1BSU5URU5BTkNFX09VVCBmcm9tIFNDQy0yCisJCQkgKgorCQkJICogQ2hlY2sgZm9yIGVtdWxhdGVkIE1PX1NFVF9UQVJHRVRfUEdTLgorCQkJICovCisJCQlpZiAoY2RiWzFdID09IE1PX1NFVF9UQVJHRVRfUEdTKSB7CisJCQkJY21kLT50cmFuc3BvcnRfZW11bGF0ZV9jZGIgPQorCQkJCShUMTBfQUxVQShzdV9kZXYpLT5hbHVhX3R5cGUgPT0KKwkJCQkJU1BDM19BTFVBX0VNVUxBVEVEKSA/CisJCQkJJmNvcmVfZW11bGF0ZV9zZXRfdGFyZ2V0X3BvcnRfZ3JvdXBzIDoKKwkJCQlOVUxMOworCQkJfQorCisJCQlzaXplID0gKGNkYls2XSA8PCAyNCkgfCAoY2RiWzddIDw8IDE2KSB8CisJCQkgICAgICAgKGNkYls4XSA8PCA4KSB8IGNkYls5XTsKKwkJfSBlbHNlICB7CisJCQkvKiBHUENNRF9SRVBPUlRfS0VZIGZyb20gbXVsdGkgbWVkaWEgY29tbWFuZHMgKi8KKwkJCXNpemUgPSAoY2RiWzhdIDw8IDgpICsgY2RiWzldOworCQl9CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0NPTlRST0xfTk9OU0dfSU9fQ0RCOworCQlicmVhazsKKwljYXNlIElOUVVJUlk6CisJCXNpemUgPSAoY2RiWzNdIDw8IDgpICsgY2RiWzRdOworCQkvKgorCQkgKiBEbyBpbXBsaWN0IEhFQURfT0ZfUVVFVUUgcHJvY2Vzc2luZyBmb3IgSU5RVUlSWS4KKwkJICogU2VlIHNwYzRyMTcgc2VjdGlvbiA1LjMKKwkJICovCisJCWlmIChTRV9ERVYoY21kKS0+ZGV2X3Rhc2tfYXR0cl90eXBlID09IFNBTV9UQVNLX0FUVFJfRU1VTEFURUQpCisJCQljbWQtPnNhbV90YXNrX2F0dHIgPSBUQVNLX0FUVFJfSE9ROworCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DT05UUk9MX05PTlNHX0lPX0NEQjsKKwkJYnJlYWs7CisJY2FzZSBSRUFEX0JVRkZFUjoKKwkJc2l6ZSA9IChjZGJbNl0gPDwgMTYpICsgKGNkYls3XSA8PCA4KSArIGNkYls4XTsKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ09OVFJPTF9OT05TR19JT19DREI7CisJCWJyZWFrOworCWNhc2UgUkVBRF9DQVBBQ0lUWToKKwkJc2l6ZSA9IFJFQURfQ0FQX0xFTjsKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ09OVFJPTF9OT05TR19JT19DREI7CisJCWJyZWFrOworCWNhc2UgUkVBRF9NRURJQV9TRVJJQUxfTlVNQkVSOgorCWNhc2UgU0VDVVJJVFlfUFJPVE9DT0xfSU46CisJY2FzZSBTRUNVUklUWV9QUk9UT0NPTF9PVVQ6CisJCXNpemUgPSAoY2RiWzZdIDw8IDI0KSB8IChjZGJbN10gPDwgMTYpIHwgKGNkYls4XSA8PCA4KSB8IGNkYls5XTsKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ09OVFJPTF9OT05TR19JT19DREI7CisJCWJyZWFrOworCWNhc2UgU0VSVklDRV9BQ1RJT05fSU46CisJY2FzZSBBQ0NFU1NfQ09OVFJPTF9JTjoKKwljYXNlIEFDQ0VTU19DT05UUk9MX09VVDoKKwljYXNlIEVYVEVOREVEX0NPUFk6CisJY2FzZSBSRUFEX0FUVFJJQlVURToKKwljYXNlIFJFQ0VJVkVfQ09QWV9SRVNVTFRTOgorCWNhc2UgV1JJVEVfQVRUUklCVVRFOgorCQlzaXplID0gKGNkYlsxMF0gPDwgMjQpIHwgKGNkYlsxMV0gPDwgMTYpIHwKKwkJICAgICAgIChjZGJbMTJdIDw8IDgpIHwgY2RiWzEzXTsKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ09OVFJPTF9OT05TR19JT19DREI7CisJCWJyZWFrOworCWNhc2UgUkVDRUlWRV9ESUFHTk9TVElDOgorCWNhc2UgU0VORF9ESUFHTk9TVElDOgorCQlzaXplID0gKGNkYlszXSA8PCA4KSB8IGNkYls0XTsKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ09OVFJPTF9OT05TR19JT19DREI7CisJCWJyZWFrOworLyogI3dhcm5pbmcgRklYTUU6IEZpZ3VyZSBvdXQgY29ycmVjdCBHUENNRF9SRUFEX0NEIGJsb2Nrc2l6ZS4gKi8KKyNpZiAwCisJY2FzZSBHUENNRF9SRUFEX0NEOgorCQlzZWN0b3JzID0gKGNkYls2XSA8PCAxNikgKyAoY2RiWzddIDw8IDgpICsgY2RiWzhdOworCQlzaXplID0gKDIzMzYgKiBzZWN0b3JzKTsKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ09OVFJPTF9OT05TR19JT19DREI7CisJCWJyZWFrOworI2VuZGlmCisJY2FzZSBSRUFEX1RPQzoKKwkJc2l6ZSA9IGNkYls4XTsKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ09OVFJPTF9OT05TR19JT19DREI7CisJCWJyZWFrOworCWNhc2UgUkVRVUVTVF9TRU5TRToKKwkJc2l6ZSA9IGNkYls0XTsKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ09OVFJPTF9OT05TR19JT19DREI7CisJCWJyZWFrOworCWNhc2UgUkVBRF9FTEVNRU5UX1NUQVRVUzoKKwkJc2l6ZSA9IDY1NTM2ICogY2RiWzddICsgMjU2ICogY2RiWzhdICsgY2RiWzldOworCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DT05UUk9MX05PTlNHX0lPX0NEQjsKKwkJYnJlYWs7CisJY2FzZSBXUklURV9CVUZGRVI6CisJCXNpemUgPSAoY2RiWzZdIDw8IDE2KSArIChjZGJbN10gPDwgOCkgKyBjZGJbOF07CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX0NPTlRST0xfTk9OU0dfSU9fQ0RCOworCQlicmVhazsKKwljYXNlIFJFU0VSVkU6CisJY2FzZSBSRVNFUlZFXzEwOgorCQkvKgorCQkgKiBUaGUgU1BDLTIgUkVTRVJWRSBkb2VzIG5vdCBjb250YWluIGEgc2l6ZSBpbiB0aGUgU0NTSSBDREIuCisJCSAqIEFzc3VtZSB0aGUgcGFzc3Rocm91Z2ggb3IgJEZBQlJJQ19NT0Qgd2lsbCB0ZWxsIHVzIGFib3V0IGl0LgorCQkgKi8KKwkJaWYgKGNkYlswXSA9PSBSRVNFUlZFXzEwKQorCQkJc2l6ZSA9IChjZGJbN10gPDwgOCkgfCBjZGJbOF07CisJCWVsc2UKKwkJCXNpemUgPSBjbWQtPmRhdGFfbGVuZ3RoOworCisJCS8qCisJCSAqIFNldHVwIHRoZSBsZWdhY3kgZW11bGF0ZWQgaGFuZGxlciBmb3IgU1BDLTIgYW5kCisJCSAqID49IFNQQy0zIGNvbXBhdGlibGUgcmVzZXJ2YXRpb24gaGFuZGxpbmcgKENSSD0xKQorCQkgKiBPdGhlcndpc2UsIHdlIGFzc3VtZSB0aGUgdW5kZXJseWluZyBTQ1NJIGxvZ2ljIGlzCisJCSAqIGlzIHJ1bm5pbmcgaW4gU1BDX1BBU1NUSFJPVUdILCBhbmQgd2FudHMgcmVzZXJ2YXRpb25zCisJCSAqIGVtdWxhdGlvbiBkaXNhYmxlZC4KKwkJICovCisJCWNtZC0+dHJhbnNwb3J0X2VtdWxhdGVfY2RiID0KKwkJCQkoVDEwX1JFUyhzdV9kZXYpLT5yZXNfdHlwZSAhPQorCQkJCSBTUENfUEFTU1RIUk9VR0gpID8KKwkJCQkmY29yZV9zY3NpMl9lbXVsYXRlX2NyaCA6IE5VTEw7CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX05PTl9EQVRBX0NEQjsKKwkJYnJlYWs7CisJY2FzZSBSRUxFQVNFOgorCWNhc2UgUkVMRUFTRV8xMDoKKwkJLyoKKwkJICogVGhlIFNQQy0yIFJFTEVBU0UgZG9lcyBub3QgY29udGFpbiBhIHNpemUgaW4gdGhlIFNDU0kgQ0RCLgorCQkgKiBBc3N1bWUgdGhlIHBhc3N0aHJvdWdoIG9yICRGQUJSSUNfTU9EIHdpbGwgdGVsbCB1cyBhYm91dCBpdC4KKwkJKi8KKwkJaWYgKGNkYlswXSA9PSBSRUxFQVNFXzEwKQorCQkJc2l6ZSA9IChjZGJbN10gPDwgOCkgfCBjZGJbOF07CisJCWVsc2UKKwkJCXNpemUgPSBjbWQtPmRhdGFfbGVuZ3RoOworCisJCWNtZC0+dHJhbnNwb3J0X2VtdWxhdGVfY2RiID0KKwkJCQkoVDEwX1JFUyhzdV9kZXYpLT5yZXNfdHlwZSAhPQorCQkJCSBTUENfUEFTU1RIUk9VR0gpID8KKwkJCQkmY29yZV9zY3NpMl9lbXVsYXRlX2NyaCA6IE5VTEw7CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX05PTl9EQVRBX0NEQjsKKwkJYnJlYWs7CisJY2FzZSBTWU5DSFJPTklaRV9DQUNIRToKKwljYXNlIDB4OTE6IC8qIFNZTkNIUk9OSVpFX0NBQ0hFXzE2OiAqLworCQkvKgorCQkgKiBFeHRyYWN0IExCQSBhbmQgcmFuZ2UgdG8gYmUgZmx1c2hlZCBmb3IgZW11bGF0ZWQgU1lOQ0hST05JWkVfQ0FDSEUKKwkJICovCisJCWlmIChjZGJbMF0gPT0gU1lOQ0hST05JWkVfQ0FDSEUpIHsKKwkJCXNlY3RvcnMgPSB0cmFuc3BvcnRfZ2V0X3NlY3RvcnNfMTAoY2RiLCBjbWQsICZzZWN0b3JfcmV0KTsKKwkJCVRfVEFTSyhjbWQpLT50X3Rhc2tfbGJhID0gdHJhbnNwb3J0X2xiYV8zMihjZGIpOworCQl9IGVsc2UgeworCQkJc2VjdG9ycyA9IHRyYW5zcG9ydF9nZXRfc2VjdG9yc18xNihjZGIsIGNtZCwgJnNlY3Rvcl9yZXQpOworCQkJVF9UQVNLKGNtZCktPnRfdGFza19sYmEgPSB0cmFuc3BvcnRfbGJhXzY0KGNkYik7CisJCX0KKwkJaWYgKHNlY3Rvcl9yZXQpCisJCQlnb3RvIG91dF91bnN1cHBvcnRlZF9jZGI7CisKKwkJc2l6ZSA9IHRyYW5zcG9ydF9nZXRfc2l6ZShzZWN0b3JzLCBjZGIsIGNtZCk7CisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9TQ1NJX05PTl9EQVRBX0NEQjsKKworCQkvKgorCQkgKiBGb3IgVENNL3BTQ1NJIHBhc3N0aHJvdWdoLCBza2lwIGNtZC0+dHJhbnNwb3J0X2VtdWxhdGVfY2RiKCkKKwkJICovCisJCWlmIChUUkFOU1BPUlQoZGV2KS0+dHJhbnNwb3J0X3R5cGUgPT0gVFJBTlNQT1JUX1BMVUdJTl9QSEJBX1BERVYpCisJCQlicmVhazsKKwkJLyoKKwkJICogU2V0IFNDRl9FTVVMQVRFX0NEQl9BU1lOQyB0byBlbnN1cmUgYXN5bmNocm9ub3VzIG9wZXJhdGlvbgorCQkgKiBmb3IgU1lOQ0hST05JWkVfQ0FDSEUqIEltbWVkPTEgY2FzZSBpbiBfX3RyYW5zcG9ydF9leGVjdXRlX3Rhc2tzKCkKKwkJICovCisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9FTVVMQVRFX0NEQl9BU1lOQzsKKwkJLyoKKwkJICogQ2hlY2sgdG8gZW5zdXJlIHRoYXQgTEJBICsgUmFuZ2UgZG9lcyBub3QgZXhjZWVkIHBhc3QgZW5kIG9mCisJCSAqIGRldmljZS4KKwkJICovCisJCWlmICh0cmFuc3BvcnRfZ2V0X3NlY3RvcnMoY21kKSA8IDApCisJCQlnb3RvIG91dF9pbnZhbGlkX2NkYl9maWVsZDsKKwkJYnJlYWs7CisJY2FzZSBVTk1BUDoKKwkJc2l6ZSA9IGdldF91bmFsaWduZWRfYmUxNigmY2RiWzddKTsKKwkJcGFzc3Rocm91Z2ggPSAoVFJBTlNQT1JUKGRldiktPnRyYW5zcG9ydF90eXBlID09CisJCQkJVFJBTlNQT1JUX1BMVUdJTl9QSEJBX1BERVYpOworCQkvKgorCQkgKiBEZXRlcm1pbmUgaWYgdGhlIHJlY2VpdmVkIFVOTUFQIHVzZWQgdG8gZm9yIGRpcmVjdCBwYXNzdGhyb3VnaAorCQkgKiBpbnRvIExpbnV4L1NDU0kgd2l0aCBzdHJ1Y3QgcmVxdWVzdCB2aWEgVENNL3BTQ1NJIG9yIHdlIGFyZQorCQkgKiBzaWduYWxpbmcgdGhlIHVzZSBvZiBpbnRlcm5hbCB0cmFuc3BvcnRfZ2VuZXJpY191bm1hcCgpIGVtdWxhdGlvbgorCQkgKiBmb3IgVU5NQVAgLT4gTGludXgvQkxPQ0sgZGlzYmFyZCB3aXRoIFRDTS9JQkxPQ0sgYW5kIFRDTS9GSUxFSU8KKwkJICogc3Vic3lzdGVtIHBsdWdpbiBiYWNrc3RvcmVzLgorCQkgKi8KKwkJaWYgKCEocGFzc3Rocm91Z2gpKQorCQkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX0VNVUxBVEVfU1lOQ19VTk1BUDsKKworCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DT05UUk9MX05PTlNHX0lPX0NEQjsKKwkJYnJlYWs7CisJY2FzZSBXUklURV9TQU1FXzE2OgorCQlzZWN0b3JzID0gdHJhbnNwb3J0X2dldF9zZWN0b3JzXzE2KGNkYiwgY21kLCAmc2VjdG9yX3JldCk7CisJCWlmIChzZWN0b3JfcmV0KQorCQkJZ290byBvdXRfdW5zdXBwb3J0ZWRfY2RiOworCQlzaXplID0gdHJhbnNwb3J0X2dldF9zaXplKHNlY3RvcnMsIGNkYiwgY21kKTsKKwkJVF9UQVNLKGNtZCktPnRfdGFza19sYmEgPSBnZXRfdW5hbGlnbmVkX2JlMTYoJmNkYlsyXSk7CisJCXBhc3N0aHJvdWdoID0gKFRSQU5TUE9SVChkZXYpLT50cmFuc3BvcnRfdHlwZSA9PQorCQkJCVRSQU5TUE9SVF9QTFVHSU5fUEhCQV9QREVWKTsKKwkJLyoKKwkJICogRGV0ZXJtaW5lIGlmIHRoZSByZWNlaXZlZCBXUklURV9TQU1FXzE2IGlzIHVzZWQgdG8gZm9yIGRpcmVjdAorCQkgKiBwYXNzdGhyb3VnaCBpbnRvIExpbnV4L1NDU0kgd2l0aCBzdHJ1Y3QgcmVxdWVzdCB2aWEgVENNL3BTQ1NJCisJCSAqIG9yIHdlIGFyZSBzaWduYWxpbmcgdGhlIHVzZSBvZiBpbnRlcm5hbCBXUklURV9TQU1FICsgVU5NQVA9MQorCQkgKiBlbXVsYXRpb24gZm9yIC0+IExpbnV4L0JMT0NLIGRpc2JhcmQgd2l0aCBUQ00vSUJMT0NLIGFuZAorCQkgKiBUQ00vRklMRUlPIHN1YnN5c3RlbSBwbHVnaW4gYmFja3N0b3Jlcy4KKwkJICovCisJCWlmICghKHBhc3N0aHJvdWdoKSkgeworCQkJaWYgKChjZGJbMV0gJiAweDA0KSB8fCAoY2RiWzFdICYgMHgwMikpIHsKKwkJCQlwcmludGsoS0VSTl9FUlIgIldSSVRFX1NBTUUgUEJEQVRBIGFuZCBMQkRBVEEiCisJCQkJCSIgYml0cyBub3Qgc3VwcG9ydGVkIGZvciBCbG9jayBEaXNjYXJkIgorCQkJCQkiIEVtdWxhdGlvblxuIik7CisJCQkJZ290byBvdXRfaW52YWxpZF9jZGJfZmllbGQ7CisJCQl9CisJCQkvKgorCQkJICogQ3VycmVudGx5IGZvciB0aGUgZW11bGF0ZWQgY2FzZSB3ZSBvbmx5IGFjY2VwdAorCQkJICogdHB3cyB3aXRoIHRoZSBVTk1BUD0xIGJpdCBzZXQuCisJCQkgKi8KKwkJCWlmICghKGNkYlsxXSAmIDB4MDgpKSB7CisJCQkJcHJpbnRrKEtFUk5fRVJSICJXUklURV9TQU1FIHcvbyBVTk1BUCBiaXQgbm90ICIKKwkJCQkJIiBzdXBwb3J0ZWQgZm9yIEJsb2NrIERpc2NhcmQgRW11bGF0aW9uXG4iKTsKKwkJCQlnb3RvIG91dF9pbnZhbGlkX2NkYl9maWVsZDsKKwkJCX0KKwkJfQorCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DT05UUk9MX1NHX0lPX0NEQjsKKwkJYnJlYWs7CisJY2FzZSBBTExPV19NRURJVU1fUkVNT1ZBTDoKKwljYXNlIEdQQ01EX0NMT1NFX1RSQUNLOgorCWNhc2UgRVJBU0U6CisJY2FzZSBJTklUSUFMSVpFX0VMRU1FTlRfU1RBVFVTOgorCWNhc2UgR1BDTURfTE9BRF9VTkxPQUQ6CisJY2FzZSBSRVpFUk9fVU5JVDoKKwljYXNlIFNFRUtfMTA6CisJY2FzZSBHUENNRF9TRVRfU1BFRUQ6CisJY2FzZSBTUEFDRToKKwljYXNlIFNUQVJUX1NUT1A6CisJY2FzZSBURVNUX1VOSVRfUkVBRFk6CisJY2FzZSBWRVJJRlk6CisJY2FzZSBXUklURV9GSUxFTUFSS1M6CisJY2FzZSBNT1ZFX01FRElVTToKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfTk9OX0RBVEFfQ0RCOworCQlicmVhazsKKwljYXNlIFJFUE9SVF9MVU5TOgorCQljbWQtPnRyYW5zcG9ydF9lbXVsYXRlX2NkYiA9CisJCQkJJnRyYW5zcG9ydF9jb3JlX3JlcG9ydF9sdW5fcmVzcG9uc2U7CisJCXNpemUgPSAoY2RiWzZdIDw8IDI0KSB8IChjZGJbN10gPDwgMTYpIHwgKGNkYls4XSA8PCA4KSB8IGNkYls5XTsKKwkJLyoKKwkJICogRG8gaW1wbGljdCBIRUFEX09GX1FVRVVFIHByb2Nlc3NpbmcgZm9yIFJFUE9SVF9MVU5TCisJCSAqIFNlZSBzcGM0cjE3IHNlY3Rpb24gNS4zCisJCSAqLworCQlpZiAoU0VfREVWKGNtZCktPmRldl90YXNrX2F0dHJfdHlwZSA9PSBTQU1fVEFTS19BVFRSX0VNVUxBVEVEKQorCQkJY21kLT5zYW1fdGFza19hdHRyID0gVEFTS19BVFRSX0hPUTsKKwkJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ09OVFJPTF9OT05TR19JT19DREI7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXByaW50ayhLRVJOX1dBUk5JTkcgIlRBUkdFVF9DT1JFWyVzXTogVW5zdXBwb3J0ZWQgU0NTSSBPcGNvZGUiCisJCQkiIDB4JTAyeCwgc2VuZGluZyBDSEVDS19DT05ESVRJT04uXG4iLAorCQkJQ01EX1RGTyhjbWQpLT5nZXRfZmFicmljX25hbWUoKSwgY2RiWzBdKTsKKwkJY21kLT50cmFuc3BvcnRfd2FpdF9mb3JfdGFza3MgPSAmdHJhbnNwb3J0X25vcF93YWl0X2Zvcl90YXNrczsKKwkJZ290byBvdXRfdW5zdXBwb3J0ZWRfY2RiOworCX0KKworCWlmIChzaXplICE9IGNtZC0+ZGF0YV9sZW5ndGgpIHsKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAiVEFSR0VUX0NPUkVbJXNdOiBFeHBlY3RlZCBUcmFuc2ZlciBMZW5ndGg6IgorCQkJIiAldSBkb2VzIG5vdCBtYXRjaCBTQ1NJIENEQiBMZW5ndGg6ICV1IGZvciBTQU0gT3Bjb2RlOiIKKwkJCSIgMHglMDJ4XG4iLCBDTURfVEZPKGNtZCktPmdldF9mYWJyaWNfbmFtZSgpLAorCQkJCWNtZC0+ZGF0YV9sZW5ndGgsIHNpemUsIGNkYlswXSk7CisKKwkJY21kLT5jbWRfc3BkdGwgPSBzaXplOworCisJCWlmIChjbWQtPmRhdGFfZGlyZWN0aW9uID09IERNQV9UT19ERVZJQ0UpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiUmVqZWN0aW5nIHVuZGVyZmxvdy9vdmVyZmxvdyIKKwkJCQkJIiBXUklURSBkYXRhXG4iKTsKKwkJCWdvdG8gb3V0X2ludmFsaWRfY2RiX2ZpZWxkOworCQl9CisJCS8qCisJCSAqIFJlamVjdCBSRUFEXyogb3IgV1JJVEVfKiB3aXRoIG92ZXJmbG93L3VuZGVyZmxvdyBmb3IKKwkJICogdHlwZSBTQ0ZfU0NTSV9EQVRBX1NHX0lPX0NEQi4KKwkJICovCisJCWlmICghKHJldCkgJiYgKERFVl9BVFRSSUIoZGV2KS0+YmxvY2tfc2l6ZSAhPSA1MTIpKSAgeworCQkJcHJpbnRrKEtFUk5fRVJSICJGYWlsaW5nIE9WRVJGTE9XL1VOREVSRkxPVyBmb3IgTEJBIG9wIgorCQkJCSIgQ0RCIG9uIG5vbiA1MTItYnl0ZSBzZWN0b3Igc2V0dXAgc3Vic3lzdGVtIgorCQkJCSIgcGx1Z2luOiAlc1xuIiwgVFJBTlNQT1JUKGRldiktPm5hbWUpOworCQkJLyogUmV0dXJucyBDSEVDS19DT05ESVRJT04gKyBJTlZBTElEX0NEQl9GSUVMRCAqLworCQkJZ290byBvdXRfaW52YWxpZF9jZGJfZmllbGQ7CisJCX0KKworCQlpZiAoc2l6ZSA+IGNtZC0+ZGF0YV9sZW5ndGgpIHsKKwkJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9PVkVSRkxPV19CSVQ7CisJCQljbWQtPnJlc2lkdWFsX2NvdW50ID0gKHNpemUgLSBjbWQtPmRhdGFfbGVuZ3RoKTsKKwkJfSBlbHNlIHsKKwkJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9VTkRFUkZMT1dfQklUOworCQkJY21kLT5yZXNpZHVhbF9jb3VudCA9IChjbWQtPmRhdGFfbGVuZ3RoIC0gc2l6ZSk7CisJCX0KKwkJY21kLT5kYXRhX2xlbmd0aCA9IHNpemU7CisJfQorCisJdHJhbnNwb3J0X3NldF9zdXBwb3J0ZWRfU0FNX29wY29kZShjbWQpOworCXJldHVybiByZXQ7CisKK291dF91bnN1cHBvcnRlZF9jZGI6CisJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NDU0lfQ0RCX0VYQ0VQVElPTjsKKwljbWQtPnNjc2lfc2Vuc2VfcmVhc29uID0gVENNX1VOU1VQUE9SVEVEX1NDU0lfT1BDT0RFOworCXJldHVybiAtMjsKK291dF9pbnZhbGlkX2NkYl9maWVsZDoKKwljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DREJfRVhDRVBUSU9OOworCWNtZC0+c2NzaV9zZW5zZV9yZWFzb24gPSBUQ01fSU5WQUxJRF9DREJfRklFTEQ7CisJcmV0dXJuIC0yOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgdHJhbnNwb3J0X3JlbGVhc2VfdGFza3Moc3RydWN0IHNlX2NtZCAqKTsKKworLyoKKyAqIFRoaXMgZnVuY3Rpb24gd2lsbCBjb3B5IGEgY29udGlndW91cyAqc3JjIGJ1ZmZlciBpbnRvIGEgZGVzdGluYXRpb24KKyAqIHN0cnVjdCBzY2F0dGVybGlzdCBhcnJheS4KKyAqLworc3RhdGljIHZvaWQgdHJhbnNwb3J0X21lbWNweV93cml0ZV9jb250aWcoCisJc3RydWN0IHNlX2NtZCAqY21kLAorCXN0cnVjdCBzY2F0dGVybGlzdCAqc2dfZCwKKwl1bnNpZ25lZCBjaGFyICpzcmMpCit7CisJdTMyIGkgPSAwLCBsZW5ndGggPSAwLCB0b3RhbF9sZW5ndGggPSBjbWQtPmRhdGFfbGVuZ3RoOworCXZvaWQgKmRzdDsKKworCXdoaWxlICh0b3RhbF9sZW5ndGgpIHsKKwkJbGVuZ3RoID0gc2dfZFtpXS5sZW5ndGg7CisKKwkJaWYgKGxlbmd0aCA+IHRvdGFsX2xlbmd0aCkKKwkJCWxlbmd0aCA9IHRvdGFsX2xlbmd0aDsKKworCQlkc3QgPSBzZ192aXJ0KCZzZ19kW2ldKTsKKworCQltZW1jcHkoZHN0LCBzcmMsIGxlbmd0aCk7CisKKwkJaWYgKCEodG90YWxfbGVuZ3RoIC09IGxlbmd0aCkpCisJCQlyZXR1cm47CisKKwkJc3JjICs9IGxlbmd0aDsKKwkJaSsrOworCX0KK30KKworLyoKKyAqIFRoaXMgZnVuY3Rpb24gd2lsbCBjb3B5IGEgc3RydWN0IHNjYXR0ZXJsaXN0IGFycmF5ICpzZ19zIGludG8gYSBkZXN0aW5hdGlvbgorICogY29udGlndW91cyAqZHN0IGJ1ZmZlci4KKyAqLworc3RhdGljIHZvaWQgdHJhbnNwb3J0X21lbWNweV9yZWFkX2NvbnRpZygKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJdW5zaWduZWQgY2hhciAqZHN0LAorCXN0cnVjdCBzY2F0dGVybGlzdCAqc2dfcykKK3sKKwl1MzIgaSA9IDAsIGxlbmd0aCA9IDAsIHRvdGFsX2xlbmd0aCA9IGNtZC0+ZGF0YV9sZW5ndGg7CisJdm9pZCAqc3JjOworCisJd2hpbGUgKHRvdGFsX2xlbmd0aCkgeworCQlsZW5ndGggPSBzZ19zW2ldLmxlbmd0aDsKKworCQlpZiAobGVuZ3RoID4gdG90YWxfbGVuZ3RoKQorCQkJbGVuZ3RoID0gdG90YWxfbGVuZ3RoOworCisJCXNyYyA9IHNnX3ZpcnQoJnNnX3NbaV0pOworCisJCW1lbWNweShkc3QsIHNyYywgbGVuZ3RoKTsKKworCQlpZiAoISh0b3RhbF9sZW5ndGggLT0gbGVuZ3RoKSkKKwkJCXJldHVybjsKKworCQlkc3QgKz0gbGVuZ3RoOworCQlpKys7CisJfQorfQorCitzdGF0aWMgdm9pZCB0cmFuc3BvcnRfbWVtY3B5X3NlX21lbV9yZWFkX2NvbnRpZygKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJdW5zaWduZWQgY2hhciAqZHN0LAorCXN0cnVjdCBsaXN0X2hlYWQgKnNlX21lbV9saXN0KQoreworCXN0cnVjdCBzZV9tZW0gKnNlX21lbTsKKwl2b2lkICpzcmM7CisJdTMyIGxlbmd0aCA9IDAsIHRvdGFsX2xlbmd0aCA9IGNtZC0+ZGF0YV9sZW5ndGg7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHNlX21lbSwgc2VfbWVtX2xpc3QsIHNlX2xpc3QpIHsKKwkJbGVuZ3RoID0gc2VfbWVtLT5zZV9sZW47CisKKwkJaWYgKGxlbmd0aCA+IHRvdGFsX2xlbmd0aCkKKwkJCWxlbmd0aCA9IHRvdGFsX2xlbmd0aDsKKworCQlzcmMgPSBwYWdlX2FkZHJlc3Moc2VfbWVtLT5zZV9wYWdlKSArIHNlX21lbS0+c2Vfb2ZmOworCisJCW1lbWNweShkc3QsIHNyYywgbGVuZ3RoKTsKKworCQlpZiAoISh0b3RhbF9sZW5ndGggLT0gbGVuZ3RoKSkKKwkJCXJldHVybjsKKworCQlkc3QgKz0gbGVuZ3RoOworCX0KK30KKworLyoKKyAqIENhbGxlZCBmcm9tIHRyYW5zcG9ydF9nZW5lcmljX2NvbXBsZXRlX29rKCkgYW5kCisgKiB0cmFuc3BvcnRfZ2VuZXJpY19yZXF1ZXN0X2ZhaWx1cmUoKSB0byBkZXRlcm1pbmUgd2hpY2ggZG9ybWFudC9kZWxheWVkCisgKiBhbmQgb3JkZXJlZCBjbWRzIG5lZWQgdG8gaGF2ZSB0aGVpciB0YXNrcyBhZGRlZCB0byB0aGUgZXhlY3V0aW9uIHF1ZXVlLgorICovCitzdGF0aWMgdm9pZCB0cmFuc3BvcnRfY29tcGxldGVfdGFza19hdHRyKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKwlzdHJ1Y3Qgc2VfY21kICpjbWRfcCwgKmNtZF90bXA7CisJaW50IG5ld19hY3RpdmVfdGFza3MgPSAwOworCisJaWYgKGNtZC0+c2FtX3Rhc2tfYXR0ciA9PSBUQVNLX0FUVFJfU0lNUExFKSB7CisJCWF0b21pY19kZWMoJmRldi0+c2ltcGxlX2NtZHMpOworCQlzbXBfbWJfX2FmdGVyX2F0b21pY19kZWMoKTsKKwkJZGV2LT5kZXZfY3VyX29yZGVyZWRfaWQrKzsKKwkJREVCVUdfU1RBKCJJbmNyZW1lbnRlZCBkZXYtPmRldl9jdXJfb3JkZXJlZF9pZDogJXUgZm9yIgorCQkJIiBTSU1QTEU6ICV1XG4iLCBkZXYtPmRldl9jdXJfb3JkZXJlZF9pZCwKKwkJCWNtZC0+c2Vfb3JkZXJlZF9pZCk7CisJfSBlbHNlIGlmIChjbWQtPnNhbV90YXNrX2F0dHIgPT0gVEFTS19BVFRSX0hPUSkgeworCQlhdG9taWNfZGVjKCZkZXYtPmRldl9ob3FfY291bnQpOworCQlzbXBfbWJfX2FmdGVyX2F0b21pY19kZWMoKTsKKwkJZGV2LT5kZXZfY3VyX29yZGVyZWRfaWQrKzsKKwkJREVCVUdfU1RBKCJJbmNyZW1lbnRlZCBkZXZfY3VyX29yZGVyZWRfaWQ6ICV1IGZvciIKKwkJCSIgSEVBRF9PRl9RVUVVRTogJXVcbiIsIGRldi0+ZGV2X2N1cl9vcmRlcmVkX2lkLAorCQkJY21kLT5zZV9vcmRlcmVkX2lkKTsKKwl9IGVsc2UgaWYgKGNtZC0+c2FtX3Rhc2tfYXR0ciA9PSBUQVNLX0FUVFJfT1JERVJFRCkgeworCQlzcGluX2xvY2soJmRldi0+b3JkZXJlZF9jbWRfbG9jayk7CisJCWxpc3RfZGVsKCZjbWQtPnNlX29yZGVyZWRfbGlzdCk7CisJCWF0b21pY19kZWMoJmRldi0+ZGV2X29yZGVyZWRfc3luYyk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworCQlzcGluX3VubG9jaygmZGV2LT5vcmRlcmVkX2NtZF9sb2NrKTsKKworCQlkZXYtPmRldl9jdXJfb3JkZXJlZF9pZCsrOworCQlERUJVR19TVEEoIkluY3JlbWVudGVkIGRldl9jdXJfb3JkZXJlZF9pZDogJXUgZm9yIE9SREVSRUQ6IgorCQkJIiAldVxuIiwgZGV2LT5kZXZfY3VyX29yZGVyZWRfaWQsIGNtZC0+c2Vfb3JkZXJlZF9pZCk7CisJfQorCS8qCisJICogUHJvY2VzcyBhbGwgY29tbWFuZHMgdXAgdG8gdGhlIGxhc3QgcmVjZWl2ZWQKKwkgKiBPUkRFUkVEIHRhc2sgYXR0cmlidXRlIHdoaWNoIHJlcXVpcmVzIGFub3RoZXIgYmxvY2tpbmcKKwkgKiBib3VuZGFyeQorCSAqLworCXNwaW5fbG9jaygmZGV2LT5kZWxheWVkX2NtZF9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoY21kX3AsIGNtZF90bXAsCisJCQkmZGV2LT5kZWxheWVkX2NtZF9saXN0LCBzZV9kZWxheWVkX2xpc3QpIHsKKworCQlsaXN0X2RlbCgmY21kX3AtPnNlX2RlbGF5ZWRfbGlzdCk7CisJCXNwaW5fdW5sb2NrKCZkZXYtPmRlbGF5ZWRfY21kX2xvY2spOworCisJCURFQlVHX1NUQSgiQ2FsbGluZyBhZGRfdGFza3MoKSBmb3IiCisJCQkiIGNtZF9wOiAweCUwMnggVGFzayBBdHRyOiAweCUwMngiCisJCQkiIERvcm1hbnQgLT4gQWN0aXZlLCBzZV9vcmRlcmVkX2lkOiAldVxuIiwKKwkJCVRfVEFTSyhjbWRfcCktPnRfdGFza19jZGJbMF0sCisJCQljbWRfcC0+c2FtX3Rhc2tfYXR0ciwgY21kX3AtPnNlX29yZGVyZWRfaWQpOworCisJCXRyYW5zcG9ydF9hZGRfdGFza3NfZnJvbV9jbWQoY21kX3ApOworCQluZXdfYWN0aXZlX3Rhc2tzKys7CisKKwkJc3Bpbl9sb2NrKCZkZXYtPmRlbGF5ZWRfY21kX2xvY2spOworCQlpZiAoY21kX3AtPnNhbV90YXNrX2F0dHIgPT0gVEFTS19BVFRSX09SREVSRUQpCisJCQlicmVhazsKKwl9CisJc3Bpbl91bmxvY2soJmRldi0+ZGVsYXllZF9jbWRfbG9jayk7CisJLyoKKwkgKiBJZiBuZXcgdGFza3MgaGF2ZSBiZWNvbWUgYWN0aXZlLCB3YWtlIHVwIHRoZSB0cmFuc3BvcnQgdGhyZWFkCisJICogdG8gZG8gdGhlIHByb2Nlc3Npbmcgb2YgdGhlIEFjdGl2ZSB0YXNrcy4KKwkgKi8KKwlpZiAobmV3X2FjdGl2ZV90YXNrcyAhPSAwKQorCQl3YWtlX3VwX2ludGVycnVwdGlibGUoJmRldi0+ZGV2X3F1ZXVlX29iai0+dGhyZWFkX3dxKTsKK30KKworc3RhdGljIHZvaWQgdHJhbnNwb3J0X2dlbmVyaWNfY29tcGxldGVfb2soc3RydWN0IHNlX2NtZCAqY21kKQoreworCWludCByZWFzb24gPSAwOworCS8qCisJICogQ2hlY2sgaWYgd2UgbmVlZCB0byBtb3ZlIGRlbGF5ZWQvZG9ybWFudCB0YXNrcyBmcm9tIGNtZHMgb24gdGhlCisJICogZGVsYXllZCBleGVjdXRpb24gbGlzdCBhZnRlciBhIEhFQURfT0ZfUVVFVUUgb3IgT1JERVJFRCBUYXNrCisJICogQXR0cmlidXRlLgorCSAqLworCWlmIChTRV9ERVYoY21kKS0+ZGV2X3Rhc2tfYXR0cl90eXBlID09IFNBTV9UQVNLX0FUVFJfRU1VTEFURUQpCisJCXRyYW5zcG9ydF9jb21wbGV0ZV90YXNrX2F0dHIoY21kKTsKKwkvKgorCSAqIENoZWNrIGlmIHdlIG5lZWQgdG8gcmV0cmlldmUgYSBzZW5zZSBidWZmZXIgZnJvbQorCSAqIHRoZSBzdHJ1Y3Qgc2VfY21kIGluIHF1ZXN0aW9uLgorCSAqLworCWlmIChjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9UUkFOU1BPUlRfVEFTS19TRU5TRSkgeworCQlpZiAodHJhbnNwb3J0X2dldF9zZW5zZV9kYXRhKGNtZCkgPCAwKQorCQkJcmVhc29uID0gVENNX05PTl9FWElTVEVOVF9MVU47CisKKwkJLyoKKwkJICogT25seSBzZXQgd2hlbiBhbiBzdHJ1Y3Qgc2VfdGFzay0+dGFza19zY3NpX3N0YXR1cyByZXR1cm5lZAorCQkgKiBhIG5vbiBHT09EIHN0YXR1cy4KKwkJICovCisJCWlmIChjbWQtPnNjc2lfc3RhdHVzKSB7CisJCQl0cmFuc3BvcnRfc2VuZF9jaGVja19jb25kaXRpb25fYW5kX3NlbnNlKAorCQkJCQljbWQsIHJlYXNvbiwgMSk7CisJCQl0cmFuc3BvcnRfbHVuX3JlbW92ZV9jbWQoY21kKTsKKwkJCXRyYW5zcG9ydF9jbWRfY2hlY2tfc3RvcF90b19mYWJyaWMoY21kKTsKKwkJCXJldHVybjsKKwkJfQorCX0KKwkvKgorCSAqIENoZWNrIGZvciBhIGNhbGxiYWNrLCB1c2VkIGJ5IGFtb3VuZ3N0IG90aGVyIHRoaW5ncworCSAqIFhEV1JJVEVfUkVBRF8xMCBlbXVsYXRpb24uCisJICovCisJaWYgKGNtZC0+dHJhbnNwb3J0X2NvbXBsZXRlX2NhbGxiYWNrKQorCQljbWQtPnRyYW5zcG9ydF9jb21wbGV0ZV9jYWxsYmFjayhjbWQpOworCisJc3dpdGNoIChjbWQtPmRhdGFfZGlyZWN0aW9uKSB7CisJY2FzZSBETUFfRlJPTV9ERVZJQ0U6CisJCXNwaW5fbG9jaygmY21kLT5zZV9sdW4tPmx1bl9zZXBfbG9jayk7CisJCWlmIChTRV9MVU4oY21kKS0+bHVuX3NlcCkgeworCQkJU0VfTFVOKGNtZCktPmx1bl9zZXAtPnNlcF9zdGF0cy50eF9kYXRhX29jdGV0cyArPQorCQkJCQljbWQtPmRhdGFfbGVuZ3RoOworCQl9CisJCXNwaW5fdW5sb2NrKCZjbWQtPnNlX2x1bi0+bHVuX3NlcF9sb2NrKTsKKwkJLyoKKwkJICogSWYgZW5hYmxlZCBieSBUQ00gZmFiaXJjIG1vZHVsZSBwcmUtcmVnaXN0ZXJlZCBTR0wKKwkJICogbWVtb3J5LCBwZXJmb3JtIHRoZSBtZW1jcHkoKSBmcm9tIHRoZSBUQ00gaW50ZXJuYWwKKwkJICogY29udGlnaW91cyBidWZmZXIgYmFjayB0byB0aGUgb3JpZ2luYWwgU0dMLgorCQkgKi8KKwkJaWYgKGNtZC0+c2VfY21kX2ZsYWdzICYgU0NGX1BBU1NUSFJPVUdIX0NPTlRJR19UT19TRykKKwkJCXRyYW5zcG9ydF9tZW1jcHlfd3JpdGVfY29udGlnKGNtZCwKKwkJCQkgVF9UQVNLKGNtZCktPnRfdGFza19wdF9zZ2wsCisJCQkJIFRfVEFTSyhjbWQpLT50X3Rhc2tfYnVmKTsKKworCQlDTURfVEZPKGNtZCktPnF1ZXVlX2RhdGFfaW4oY21kKTsKKwkJYnJlYWs7CisJY2FzZSBETUFfVE9fREVWSUNFOgorCQlzcGluX2xvY2soJmNtZC0+c2VfbHVuLT5sdW5fc2VwX2xvY2spOworCQlpZiAoU0VfTFVOKGNtZCktPmx1bl9zZXApIHsKKwkJCVNFX0xVTihjbWQpLT5sdW5fc2VwLT5zZXBfc3RhdHMucnhfZGF0YV9vY3RldHMgKz0KKwkJCQljbWQtPmRhdGFfbGVuZ3RoOworCQl9CisJCXNwaW5fdW5sb2NrKCZjbWQtPnNlX2x1bi0+bHVuX3NlcF9sb2NrKTsKKwkJLyoKKwkJICogQ2hlY2sgaWYgd2UgbmVlZCB0byBzZW5kIFJFQUQgcGF5bG9hZCBmb3IgQklESS1DT01NQU5ECisJCSAqLworCQlpZiAoVF9UQVNLKGNtZCktPnRfbWVtX2JpZGlfbGlzdCAhPSBOVUxMKSB7CisJCQlzcGluX2xvY2soJmNtZC0+c2VfbHVuLT5sdW5fc2VwX2xvY2spOworCQkJaWYgKFNFX0xVTihjbWQpLT5sdW5fc2VwKSB7CisJCQkJU0VfTFVOKGNtZCktPmx1bl9zZXAtPnNlcF9zdGF0cy50eF9kYXRhX29jdGV0cyArPQorCQkJCQljbWQtPmRhdGFfbGVuZ3RoOworCQkJfQorCQkJc3Bpbl91bmxvY2soJmNtZC0+c2VfbHVuLT5sdW5fc2VwX2xvY2spOworCQkJQ01EX1RGTyhjbWQpLT5xdWV1ZV9kYXRhX2luKGNtZCk7CisJCQlicmVhazsKKwkJfQorCQkvKiBGYWxsIHRocm91Z2ggZm9yIERNQV9UT19ERVZJQ0UgKi8KKwljYXNlIERNQV9OT05FOgorCQlDTURfVEZPKGNtZCktPnF1ZXVlX3N0YXR1cyhjbWQpOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlicmVhazsKKwl9CisKKwl0cmFuc3BvcnRfbHVuX3JlbW92ZV9jbWQoY21kKTsKKwl0cmFuc3BvcnRfY21kX2NoZWNrX3N0b3BfdG9fZmFicmljKGNtZCk7Cit9CisKK3N0YXRpYyB2b2lkIHRyYW5zcG9ydF9mcmVlX2Rldl90YXNrcyhzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHNlX3Rhc2sgKnRhc2ssICp0YXNrX3RtcDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUodGFzaywgdGFza190bXAsCisJCQkJJlRfVEFTSyhjbWQpLT50X3Rhc2tfbGlzdCwgdF9saXN0KSB7CisJCWlmIChhdG9taWNfcmVhZCgmdGFzay0+dGFza19hY3RpdmUpKQorCQkJY29udGludWU7CisKKwkJa2ZyZWUodGFzay0+dGFza19zZ19iaWRpKTsKKwkJa2ZyZWUodGFzay0+dGFza19zZyk7CisKKwkJbGlzdF9kZWwoJnRhc2stPnRfbGlzdCk7CisKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCQlpZiAodGFzay0+c2VfZGV2KQorCQkJVFJBTlNQT1JUKHRhc2stPnNlX2RldiktPmZyZWVfdGFzayh0YXNrKTsKKwkJZWxzZQorCQkJcHJpbnRrKEtFUk5fRVJSICJ0YXNrWyV1XSAtIHRhc2stPnNlX2RldiBpcyBOVUxMXG4iLAorCQkJCXRhc2stPnRhc2tfbm8pOworCQlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCX0KKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCB0cmFuc3BvcnRfZnJlZV9wYWdlcyhzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHNlX21lbSAqc2VfbWVtLCAqc2VfbWVtX3RtcDsKKwlpbnQgZnJlZV9wYWdlID0gMTsKKworCWlmIChjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9QQVNTVEhST1VHSF9TR19UT19NRU1fTk9BTExPQykKKwkJZnJlZV9wYWdlID0gMDsKKwlpZiAoY21kLT5zZV9kZXYtPnRyYW5zcG9ydC0+ZG9fc2VfbWVtX21hcCkKKwkJZnJlZV9wYWdlID0gMDsKKworCWlmIChUX1RBU0soY21kKS0+dF90YXNrX2J1ZikgeworCQlrZnJlZShUX1RBU0soY21kKS0+dF90YXNrX2J1Zik7CisJCVRfVEFTSyhjbWQpLT50X3Rhc2tfYnVmID0gTlVMTDsKKwkJcmV0dXJuOworCX0KKworCS8qCisJICogQ2FsbGVyIHdpbGwgaGFuZGxlIHJlbGVhc2luZyBvZiBzdHJ1Y3Qgc2VfbWVtLgorCSAqLworCWlmIChjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9DTURfUEFTU1RIUk9VR0hfTk9BTExPQykKKwkJcmV0dXJuOworCisJaWYgKCEoVF9UQVNLKGNtZCktPnRfdGFza3Nfc2VfbnVtKSkKKwkJcmV0dXJuOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHNlX21lbSwgc2VfbWVtX3RtcCwKKwkJCVRfVEFTSyhjbWQpLT50X21lbV9saXN0LCBzZV9saXN0KSB7CisJCS8qCisJCSAqIFdlIG9ubHkgcmVsZWFzZSBjYWxsIF9fZnJlZV9wYWdlKHN0cnVjdCBzZV9tZW0tPnNlX3BhZ2UpIHdoZW4KKwkJICogU0NGX1BBU1NUSFJPVUdIX1NHX1RPX01FTV9OT0FMTE9DIGlzIE5PVCBpbiB1c2UsCisJCSAqLworCQlpZiAoZnJlZV9wYWdlKQorCQkJX19mcmVlX3BhZ2Uoc2VfbWVtLT5zZV9wYWdlKTsKKworCQlsaXN0X2RlbCgmc2VfbWVtLT5zZV9saXN0KTsKKwkJa21lbV9jYWNoZV9mcmVlKHNlX21lbV9jYWNoZSwgc2VfbWVtKTsKKwl9CisKKwlpZiAoVF9UQVNLKGNtZCktPnRfbWVtX2JpZGlfbGlzdCAmJiBUX1RBU0soY21kKS0+dF90YXNrc19zZV9iaWRpX251bSkgeworCQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoc2VfbWVtLCBzZV9tZW1fdG1wLAorCQkJCVRfVEFTSyhjbWQpLT50X21lbV9iaWRpX2xpc3QsIHNlX2xpc3QpIHsKKwkJCS8qCisJCQkgKiBXZSBvbmx5IHJlbGVhc2UgY2FsbCBfX2ZyZWVfcGFnZShzdHJ1Y3Qgc2VfbWVtLT5zZV9wYWdlKSB3aGVuCisJCQkgKiBTQ0ZfUEFTU1RIUk9VR0hfU0dfVE9fTUVNX05PQUxMT0MgaXMgTk9UIGluIHVzZSwKKwkJCSAqLworCQkJaWYgKGZyZWVfcGFnZSkKKwkJCQlfX2ZyZWVfcGFnZShzZV9tZW0tPnNlX3BhZ2UpOworCisJCQlsaXN0X2RlbCgmc2VfbWVtLT5zZV9saXN0KTsKKwkJCWttZW1fY2FjaGVfZnJlZShzZV9tZW1fY2FjaGUsIHNlX21lbSk7CisJCX0KKwl9CisKKwlrZnJlZShUX1RBU0soY21kKS0+dF9tZW1fYmlkaV9saXN0KTsKKwlUX1RBU0soY21kKS0+dF9tZW1fYmlkaV9saXN0ID0gTlVMTDsKKwlrZnJlZShUX1RBU0soY21kKS0+dF9tZW1fbGlzdCk7CisJVF9UQVNLKGNtZCktPnRfbWVtX2xpc3QgPSBOVUxMOworCVRfVEFTSyhjbWQpLT50X3Rhc2tzX3NlX251bSA9IDA7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCB0cmFuc3BvcnRfcmVsZWFzZV90YXNrcyhzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJdHJhbnNwb3J0X2ZyZWVfZGV2X3Rhc2tzKGNtZCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHRyYW5zcG9ydF9kZWNfYW5kX2NoZWNrKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwlpZiAoYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X2ZlX2NvdW50KSkgeworCQlpZiAoIShhdG9taWNfZGVjX2FuZF90ZXN0KCZUX1RBU0soY21kKS0+dF9mZV9jb3VudCkpKSB7CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLAorCQkJCQlmbGFncyk7CisJCQlyZXR1cm4gMTsKKwkJfQorCX0KKworCWlmIChhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfc2VfY291bnQpKSB7CisJCWlmICghKGF0b21pY19kZWNfYW5kX3Rlc3QoJlRfVEFTSyhjbWQpLT50X3NlX2NvdW50KSkpIHsKKwkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssCisJCQkJCWZsYWdzKTsKKwkJCXJldHVybiAxOworCQl9CisJfQorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCB0cmFuc3BvcnRfcmVsZWFzZV9mZV9jbWQoc3RydWN0IHNlX2NtZCAqY21kKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlpZiAodHJhbnNwb3J0X2RlY19hbmRfY2hlY2soY21kKSkKKwkJcmV0dXJuOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwlpZiAoIShhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRyYW5zcG9ydF9kZXZfYWN0aXZlKSkpIHsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCQlnb3RvIGZyZWVfcGFnZXM7CisJfQorCWF0b21pY19zZXQoJlRfVEFTSyhjbWQpLT50cmFuc3BvcnRfZGV2X2FjdGl2ZSwgMCk7CisJdHJhbnNwb3J0X2FsbF90YXNrX2Rldl9yZW1vdmVfc3RhdGUoY21kKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisKKwl0cmFuc3BvcnRfcmVsZWFzZV90YXNrcyhjbWQpOworZnJlZV9wYWdlczoKKwl0cmFuc3BvcnRfZnJlZV9wYWdlcyhjbWQpOworCXRyYW5zcG9ydF9mcmVlX3NlX2NtZChjbWQpOworCUNNRF9URk8oY21kKS0+cmVsZWFzZV9jbWRfZGlyZWN0KGNtZCk7Cit9CisKK3N0YXRpYyBpbnQgdHJhbnNwb3J0X2dlbmVyaWNfcmVtb3ZlKAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwlpbnQgcmVsZWFzZV90b19wb29sLAorCWludCBzZXNzaW9uX3JlaW5zdGF0ZW1lbnQpCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCWlmICghKFRfVEFTSyhjbWQpKSkKKwkJZ290byByZWxlYXNlX2NtZDsKKworCWlmICh0cmFuc3BvcnRfZGVjX2FuZF9jaGVjayhjbWQpKSB7CisJCWlmIChzZXNzaW9uX3JlaW5zdGF0ZW1lbnQpIHsKKwkJCXNwaW5fbG9ja19pcnFzYXZlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJCQl0cmFuc3BvcnRfYWxsX3Rhc2tfZGV2X3JlbW92ZV9zdGF0ZShjbWQpOworCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywKKwkJCQkJZmxhZ3MpOworCQl9CisJCXJldHVybiAxOworCX0KKworCXNwaW5fbG9ja19pcnFzYXZlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJaWYgKCEoYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50cmFuc3BvcnRfZGV2X2FjdGl2ZSkpKSB7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwkJZ290byBmcmVlX3BhZ2VzOworCX0KKwlhdG9taWNfc2V0KCZUX1RBU0soY21kKS0+dHJhbnNwb3J0X2Rldl9hY3RpdmUsIDApOworCXRyYW5zcG9ydF9hbGxfdGFza19kZXZfcmVtb3ZlX3N0YXRlKGNtZCk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCisJdHJhbnNwb3J0X3JlbGVhc2VfdGFza3MoY21kKTsKK2ZyZWVfcGFnZXM6CisJdHJhbnNwb3J0X2ZyZWVfcGFnZXMoY21kKTsKKworcmVsZWFzZV9jbWQ6CisJaWYgKHJlbGVhc2VfdG9fcG9vbCkgeworCQl0cmFuc3BvcnRfcmVsZWFzZV9jbWRfdG9fcG9vbChjbWQpOworCX0gZWxzZSB7CisJCXRyYW5zcG9ydF9mcmVlX3NlX2NtZChjbWQpOworCQlDTURfVEZPKGNtZCktPnJlbGVhc2VfY21kX2RpcmVjdChjbWQpOworCX0KKworCXJldHVybiAwOworfQorCisvKgorICogdHJhbnNwb3J0X2dlbmVyaWNfbWFwX21lbV90b19jbWQgLSBQZXJmb3JtIFNHTCAtPiBzdHJ1Y3Qgc2VfbWVtIG1hcAorICogQGNtZDogIEFzc29jaWF0ZWQgc2VfY21kIGRlc2NyaXB0b3IKKyAqIEBtZW06ICBTR0wgc3R5bGUgbWVtb3J5IGZvciBUQ00gV1JJVEUgLyBSRUFECisgKiBAc2dfbWVtX251bTogTnVtYmVyIG9mIFNHTCBlbGVtZW50cworICogQG1lbV9iaWRpX2luOiBTR0wgc3R5bGUgbWVtb3J5IGZvciBUQ00gQklESSBSRUFECisgKiBAc2dfbWVtX2JpZGlfbnVtOiBOdW1iZXIgb2YgQklESSBSRUFEIFNHTCBlbGVtZW50cworICoKKyAqIFJldHVybjogbm9uemVybyByZXR1cm4gY21kIHdhcyByZWplY3RlZCBmb3IgLUVOT01FTSBvciBpbnByb3BlciB1c2FnZQorICogb2YgcGFyYW1ldGVycy4KKyAqLworaW50IHRyYW5zcG9ydF9nZW5lcmljX21hcF9tZW1fdG9fY21kKAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKm1lbSwKKwl1MzIgc2dfbWVtX251bSwKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKm1lbV9iaWRpX2luLAorCXUzMiBzZ19tZW1fYmlkaV9udW0pCit7CisJdTMyIHNlX21lbV9jbnRfb3V0ID0gMDsKKwlpbnQgcmV0OworCisJaWYgKCEobWVtKSB8fCAhKHNnX21lbV9udW0pKQorCQlyZXR1cm4gMDsKKwkvKgorCSAqIFBhc3NlZCAqbWVtIHdpbGwgY29udGFpbiBhIGxpc3RfaGVhZCBjb250YWluaW5nIHByZWZvcm1hdHRlZAorCSAqIHN0cnVjdCBzZV9tZW0gZWxlbWVudHMuLi4KKwkgKi8KKwlpZiAoIShjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9QQVNTVEhST1VHSF9TR19UT19NRU0pKSB7CisJCWlmICgobWVtX2JpZGlfaW4pIHx8IChzZ19tZW1fYmlkaV9udW0pKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIlNDRl9DTURfUEFTU1RIUk9VR0hfTk9BTExPQyBub3Qgc3VwcG9ydGVkIgorCQkJCSIgd2l0aCBCSURJLUNPTU1BTkRcbiIpOworCQkJcmV0dXJuIC1FTk9TWVM7CisJCX0KKworCQlUX1RBU0soY21kKS0+dF9tZW1fbGlzdCA9IChzdHJ1Y3QgbGlzdF9oZWFkICopbWVtOworCQlUX1RBU0soY21kKS0+dF90YXNrc19zZV9udW0gPSBzZ19tZW1fbnVtOworCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfQ01EX1BBU1NUSFJPVUdIX05PQUxMT0M7CisJCXJldHVybiAwOworCX0KKwkvKgorCSAqIE90aGVyd2lzZSwgYXNzdW1lIHRoZSBjYWxsZXIgaXMgcGFzc2luZyBhIHN0cnVjdCBzY2F0dGVybGlzdAorCSAqIGFycmF5IGZyb20gaW5jbHVkZS9saW51eC9zY2F0dGVybGlzdC5oCisJICovCisJaWYgKChjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9TQ1NJX0RBVEFfU0dfSU9fQ0RCKSB8fAorCSAgICAoY21kLT5zZV9jbWRfZmxhZ3MgJiBTQ0ZfU0NTSV9DT05UUk9MX1NHX0lPX0NEQikpIHsKKwkJLyoKKwkJICogRm9yIENEQiB1c2luZyBUQ00gc3RydWN0IHNlX21lbSBsaW5rZWQgbGlzdCBzY2F0dGVybGlzdCBtZW1vcnkKKwkJICogcHJvY2Vzc2VkIGludG8gYSBUQ00gc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYsIHdlIGRvIHRoZSBtYXBwaW5nCisJCSAqIGZyb20gdGhlIHBhc3NlZCBwaHlzaWNhbCBtZW1vcnkgdG8gc3RydWN0IHNlX21lbS0+c2VfcGFnZSBoZXJlLgorCQkgKi8KKwkJVF9UQVNLKGNtZCktPnRfbWVtX2xpc3QgPSB0cmFuc3BvcnRfaW5pdF9zZV9tZW1fbGlzdCgpOworCQlpZiAoIShUX1RBU0soY21kKS0+dF9tZW1fbGlzdCkpCisJCQlyZXR1cm4gLUVOT01FTTsKKworCQlyZXQgPSB0cmFuc3BvcnRfbWFwX3NnX3RvX21lbShjbWQsCisJCQlUX1RBU0soY21kKS0+dF9tZW1fbGlzdCwgbWVtLCAmc2VfbWVtX2NudF9vdXQpOworCQlpZiAocmV0IDwgMCkKKwkJCXJldHVybiAtRU5PTUVNOworCisJCVRfVEFTSyhjbWQpLT50X3Rhc2tzX3NlX251bSA9IHNlX21lbV9jbnRfb3V0OworCQkvKgorCQkgKiBTZXR1cCBCSURJIFJFQUQgbGlzdCBvZiBzdHJ1Y3Qgc2VfbWVtIGVsZW1lbnRzCisJCSAqLworCQlpZiAoKG1lbV9iaWRpX2luKSAmJiAoc2dfbWVtX2JpZGlfbnVtKSkgeworCQkJVF9UQVNLKGNtZCktPnRfbWVtX2JpZGlfbGlzdCA9IHRyYW5zcG9ydF9pbml0X3NlX21lbV9saXN0KCk7CisJCQlpZiAoIShUX1RBU0soY21kKS0+dF9tZW1fYmlkaV9saXN0KSkgeworCQkJCWtmcmVlKFRfVEFTSyhjbWQpLT50X21lbV9saXN0KTsKKwkJCQlyZXR1cm4gLUVOT01FTTsKKwkJCX0KKwkJCXNlX21lbV9jbnRfb3V0ID0gMDsKKworCQkJcmV0ID0gdHJhbnNwb3J0X21hcF9zZ190b19tZW0oY21kLAorCQkJCVRfVEFTSyhjbWQpLT50X21lbV9iaWRpX2xpc3QsIG1lbV9iaWRpX2luLAorCQkJCSZzZV9tZW1fY250X291dCk7CisJCQlpZiAocmV0IDwgMCkgeworCQkJCWtmcmVlKFRfVEFTSyhjbWQpLT50X21lbV9saXN0KTsKKwkJCQlyZXR1cm4gLUVOT01FTTsKKwkJCX0KKworCQkJVF9UQVNLKGNtZCktPnRfdGFza3Nfc2VfYmlkaV9udW0gPSBzZV9tZW1fY250X291dDsKKwkJfQorCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfUEFTU1RIUk9VR0hfU0dfVE9fTUVNX05PQUxMT0M7CisKKwl9IGVsc2UgaWYgKGNtZC0+c2VfY21kX2ZsYWdzICYgU0NGX1NDU0lfQ09OVFJPTF9OT05TR19JT19DREIpIHsKKwkJaWYgKG1lbV9iaWRpX2luIHx8IHNnX21lbV9iaWRpX251bSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJCSURJLUNvbW1hbmRzIG5vdCBzdXBwb3J0ZWQgdXNpbmcgIgorCQkJCSJTQ0ZfU0NTSV9DT05UUk9MX05PTlNHX0lPX0NEQlxuIik7CisJCQlyZXR1cm4gLUVOT1NZUzsKKwkJfQorCQkvKgorCQkgKiBGb3IgaW5jb21pbmcgQ0RCcyB1c2luZyBhIGNvbnRpZ3VvdXMgYnVmZmVyIGludGVybmFsbCB3aXRoIFRDTSwKKwkJICogc2F2ZSB0aGUgcGFzc2VkIHN0cnVjdCBzY2F0dGVybGlzdCBtZW1vcnkuICBBZnRlciBUQ00gc3RvcmFnZSBvYmplY3QKKwkJICogcHJvY2Vzc2luZyBoYXMgY29tcGxldGVkIGZvciB0aGlzIHN0cnVjdCBzZV9jbWQsIFRDTSBjb3JlIHdpbGwgY2FsbAorCQkgKiB0cmFuc3BvcnRfbWVtY3B5X1t3cml0ZSxyZWFkXV9jb250aWcoKSBhcyBuZWNlc3NhcnkgZnJvbQorCQkgKiB0cmFuc3BvcnRfZ2VuZXJpY19jb21wbGV0ZV9vaygpIGFuZCB0cmFuc3BvcnRfd3JpdGVfcGVuZGluZygpIGluIG9yZGVyCisJCSAqIHRvIGNvcHkgdGhlIFRDTSBidWZmZXIgdG8vZnJvbSB0aGUgb3JpZ2luYWwgcGFzc2VkICptZW0gaW4gU0dMIC0+CisJCSAqIHN0cnVjdCBzY2F0dGVybGlzdCBmb3JtYXQuCisJCSAqLworCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfUEFTU1RIUk9VR0hfQ09OVElHX1RPX1NHOworCQlUX1RBU0soY21kKS0+dF90YXNrX3B0X3NnbCA9IG1lbTsKKwl9CisKKwlyZXR1cm4gMDsKK30KK0VYUE9SVF9TWU1CT0wodHJhbnNwb3J0X2dlbmVyaWNfbWFwX21lbV90b19jbWQpOworCisKK3N0YXRpYyBpbmxpbmUgbG9uZyBsb25nIHRyYW5zcG9ydF9kZXZfZW5kX2xiYShzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpCit7CisJcmV0dXJuIGRldi0+dHJhbnNwb3J0LT5nZXRfYmxvY2tzKGRldikgKyAxOworfQorCitzdGF0aWMgaW50IHRyYW5zcG9ydF9nZXRfc2VjdG9ycyhzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gU0VfREVWKGNtZCk7CisKKwlUX1RBU0soY21kKS0+dF90YXNrc19zZWN0b3JzID0KKwkJKGNtZC0+ZGF0YV9sZW5ndGggLyBERVZfQVRUUklCKGRldiktPmJsb2NrX3NpemUpOworCWlmICghKFRfVEFTSyhjbWQpLT50X3Rhc2tzX3NlY3RvcnMpKQorCQlUX1RBU0soY21kKS0+dF90YXNrc19zZWN0b3JzID0gMTsKKworCWlmIChUUkFOU1BPUlQoZGV2KS0+Z2V0X2RldmljZV90eXBlKGRldikgIT0gVFlQRV9ESVNLKQorCQlyZXR1cm4gMDsKKworCWlmICgoVF9UQVNLKGNtZCktPnRfdGFza19sYmEgKyBUX1RBU0soY21kKS0+dF90YXNrc19zZWN0b3JzKSA+CisJICAgICB0cmFuc3BvcnRfZGV2X2VuZF9sYmEoZGV2KSkgeworCQlwcmludGsoS0VSTl9FUlIgIkxCQTogJWxsdSBTZWN0b3JzOiAldSBleGNlZWRzIgorCQkJIiB0cmFuc3BvcnRfZGV2X2VuZF9sYmEoKTogJWxsdVxuIiwKKwkJCVRfVEFTSyhjbWQpLT50X3Rhc2tfbGJhLCBUX1RBU0soY21kKS0+dF90YXNrc19zZWN0b3JzLAorCQkJdHJhbnNwb3J0X2Rldl9lbmRfbGJhKGRldikpOworCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DREJfRVhDRVBUSU9OOworCQljbWQtPnNjc2lfc2Vuc2VfcmVhc29uID0gVENNX1NFQ1RPUl9DT1VOVF9UT09fTUFOWTsKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfUkVRX1RPT19NQU5ZX1NFQ1RPUlM7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgdHJhbnNwb3J0X25ld19jbWRfb2JqKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKwl1MzIgdGFza19jZGJzID0gMCwgcmM7CisKKwlpZiAoIShjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9TQ1NJX0RBVEFfU0dfSU9fQ0RCKSkgeworCQl0YXNrX2NkYnMrKzsKKwkJVF9UQVNLKGNtZCktPnRfdGFza19jZGJzKys7CisJfSBlbHNlIHsKKwkJaW50IHNldF9jb3VudHMgPSAxOworCisJCS8qCisJCSAqIFNldHVwIGFueSBCSURJIFJFQUQgdGFza3MgYW5kIG1lbW9yeSBmcm9tCisJCSAqIFRfVEFTSyhjbWQpLT50X21lbV9iaWRpX2xpc3Qgc28gdGhlIFJFQUQgc3RydWN0IHNlX3Rhc2tzCisJCSAqIGFyZSBxdWV1ZWQgZmlyc3QgZm9yIHRoZSBub24gcFNDU0kgcGFzc3Rocm91Z2ggY2FzZS4KKwkJICovCisJCWlmICgoVF9UQVNLKGNtZCktPnRfbWVtX2JpZGlfbGlzdCAhPSBOVUxMKSAmJgorCQkgICAgKFRSQU5TUE9SVChkZXYpLT50cmFuc3BvcnRfdHlwZSAhPSBUUkFOU1BPUlRfUExVR0lOX1BIQkFfUERFVikpIHsKKwkJCXJjID0gdHJhbnNwb3J0X2dlbmVyaWNfZ2V0X2NkYl9jb3VudChjbWQsCisJCQkJVF9UQVNLKGNtZCktPnRfdGFza19sYmEsCisJCQkJVF9UQVNLKGNtZCktPnRfdGFza3Nfc2VjdG9ycywKKwkJCQlETUFfRlJPTV9ERVZJQ0UsIFRfVEFTSyhjbWQpLT50X21lbV9iaWRpX2xpc3QsCisJCQkJc2V0X2NvdW50cyk7CisJCQlpZiAoIShyYykpIHsKKwkJCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DREJfRVhDRVBUSU9OOworCQkJCWNtZC0+c2NzaV9zZW5zZV9yZWFzb24gPQorCQkJCQlUQ01fTE9HSUNBTF9VTklUX0NPTU1VTklDQVRJT05fRkFJTFVSRTsKKwkJCQlyZXR1cm4gUFlYX1RSQU5TUE9SVF9MVV9DT01NX0ZBSUxVUkU7CisJCQl9CisJCQlzZXRfY291bnRzID0gMDsKKwkJfQorCQkvKgorCQkgKiBTZXR1cCB0aGUgdGFza3MgYW5kIG1lbW9yeSBmcm9tIFRfVEFTSyhjbWQpLT50X21lbV9saXN0CisJCSAqIE5vdGUgZm9yIEJJREkgdHJhbnNmZXJzIHRoaXMgd2lsbCBjb250YWluIHRoZSBXUklURSBwYXlsb2FkCisJCSAqLworCQl0YXNrX2NkYnMgPSB0cmFuc3BvcnRfZ2VuZXJpY19nZXRfY2RiX2NvdW50KGNtZCwKKwkJCQlUX1RBU0soY21kKS0+dF90YXNrX2xiYSwKKwkJCQlUX1RBU0soY21kKS0+dF90YXNrc19zZWN0b3JzLAorCQkJCWNtZC0+ZGF0YV9kaXJlY3Rpb24sIFRfVEFTSyhjbWQpLT50X21lbV9saXN0LAorCQkJCXNldF9jb3VudHMpOworCQlpZiAoISh0YXNrX2NkYnMpKSB7CisJCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0NTSV9DREJfRVhDRVBUSU9OOworCQkJY21kLT5zY3NpX3NlbnNlX3JlYXNvbiA9CisJCQkJCVRDTV9MT0dJQ0FMX1VOSVRfQ09NTVVOSUNBVElPTl9GQUlMVVJFOworCQkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfTFVfQ09NTV9GQUlMVVJFOworCQl9CisJCVRfVEFTSyhjbWQpLT50X3Rhc2tfY2RicyArPSB0YXNrX2NkYnM7CisKKyNpZiAwCisJCXByaW50ayhLRVJOX0lORk8gImRhdGFfbGVuZ3RoOiAldSwgTEJBOiAlbGx1IHRfdGFza3Nfc2VjdG9yczoiCisJCQkiICV1LCB0X3Rhc2tfY2RiczogJXVcbiIsIG9ial9wdHIsIGNtZC0+ZGF0YV9sZW5ndGgsCisJCQlUX1RBU0soY21kKS0+dF90YXNrX2xiYSwgVF9UQVNLKGNtZCktPnRfdGFza3Nfc2VjdG9ycywKKwkJCVRfVEFTSyhjbWQpLT50X3Rhc2tfY2Ricyk7CisjZW5kaWYKKwl9CisKKwlhdG9taWNfc2V0KCZUX1RBU0soY21kKS0+dF90YXNrX2NkYnNfbGVmdCwgdGFza19jZGJzKTsKKwlhdG9taWNfc2V0KCZUX1RBU0soY21kKS0+dF90YXNrX2NkYnNfZXhfbGVmdCwgdGFza19jZGJzKTsKKwlhdG9taWNfc2V0KCZUX1RBU0soY21kKS0+dF90YXNrX2NkYnNfdGltZW91dF9sZWZ0LCB0YXNrX2NkYnMpOworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IGxpc3RfaGVhZCAqdHJhbnNwb3J0X2luaXRfc2VfbWVtX2xpc3Qodm9pZCkKK3sKKwlzdHJ1Y3QgbGlzdF9oZWFkICpzZV9tZW1fbGlzdDsKKworCXNlX21lbV9saXN0ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGxpc3RfaGVhZCksIEdGUF9LRVJORUwpOworCWlmICghKHNlX21lbV9saXN0KSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIHNlX21lbV9saXN0XG4iKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCUlOSVRfTElTVF9IRUFEKHNlX21lbV9saXN0KTsKKworCXJldHVybiBzZV9tZW1fbGlzdDsKK30KKworc3RhdGljIGludAordHJhbnNwb3J0X2dlbmVyaWNfZ2V0X21lbShzdHJ1Y3Qgc2VfY21kICpjbWQsIHUzMiBsZW5ndGgsIHUzMiBkbWFfc2l6ZSkKK3sKKwl1bnNpZ25lZCBjaGFyICpidWY7CisJc3RydWN0IHNlX21lbSAqc2VfbWVtOworCisJVF9UQVNLKGNtZCktPnRfbWVtX2xpc3QgPSB0cmFuc3BvcnRfaW5pdF9zZV9tZW1fbGlzdCgpOworCWlmICghKFRfVEFTSyhjbWQpLT50X21lbV9saXN0KSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwkvKgorCSAqIElmIHRoZSBkZXZpY2UgdXNlcyBtZW1vcnkgbWFwcGluZyB0aGlzIGlzIGVub3VnaC4KKwkgKi8KKwlpZiAoY21kLT5zZV9kZXYtPnRyYW5zcG9ydC0+ZG9fc2VfbWVtX21hcCkKKwkJcmV0dXJuIDA7CisKKwkvKgorCSAqIFNldHVwIEJJREktQ09NTUFORCBSRUFEIGxpc3Qgb2Ygc3RydWN0IHNlX21lbSBlbGVtZW50cworCSAqLworCWlmIChUX1RBU0soY21kKS0+dF90YXNrc19iaWRpKSB7CisJCVRfVEFTSyhjbWQpLT50X21lbV9iaWRpX2xpc3QgPSB0cmFuc3BvcnRfaW5pdF9zZV9tZW1fbGlzdCgpOworCQlpZiAoIShUX1RBU0soY21kKS0+dF9tZW1fYmlkaV9saXN0KSkgeworCQkJa2ZyZWUoVF9UQVNLKGNtZCktPnRfbWVtX2xpc3QpOworCQkJcmV0dXJuIC1FTk9NRU07CisJCX0KKwl9CisKKwl3aGlsZSAobGVuZ3RoKSB7CisJCXNlX21lbSA9IGttZW1fY2FjaGVfemFsbG9jKHNlX21lbV9jYWNoZSwgR0ZQX0tFUk5FTCk7CisJCWlmICghKHNlX21lbSkpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIHN0cnVjdCBzZV9tZW1cbiIpOworCQkJZ290byBvdXQ7CisJCX0KKwkJSU5JVF9MSVNUX0hFQUQoJnNlX21lbS0+c2VfbGlzdCk7CisJCXNlX21lbS0+c2VfbGVuID0gKGxlbmd0aCA+IGRtYV9zaXplKSA/IGRtYV9zaXplIDogbGVuZ3RoOworCisvKiAjd2FybmluZyBGSVhNRSBBbGxvY2F0ZSBjb250aWdvdXMgcGFnZXMgZm9yIHN0cnVjdCBzZV9tZW0gZWxlbWVudHMgKi8KKwkJc2VfbWVtLT5zZV9wYWdlID0gKHN0cnVjdCBwYWdlICopIGFsbG9jX3BhZ2VzKEdGUF9LRVJORUwsIDApOworCQlpZiAoIShzZV9tZW0tPnNlX3BhZ2UpKSB7CisJCQlwcmludGsoS0VSTl9FUlIgImFsbG9jX3BhZ2VzKCkgZmFpbGVkXG4iKTsKKwkJCWdvdG8gb3V0OworCQl9CisKKwkJYnVmID0ga21hcF9hdG9taWMoc2VfbWVtLT5zZV9wYWdlLCBLTV9JUlEwKTsKKwkJaWYgKCEoYnVmKSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJrbWFwX2F0b21pYygpIGZhaWxlZFxuIik7CisJCQlnb3RvIG91dDsKKwkJfQorCQltZW1zZXQoYnVmLCAwLCBzZV9tZW0tPnNlX2xlbik7CisJCWt1bm1hcF9hdG9taWMoYnVmLCBLTV9JUlEwKTsKKworCQlsaXN0X2FkZF90YWlsKCZzZV9tZW0tPnNlX2xpc3QsIFRfVEFTSyhjbWQpLT50X21lbV9saXN0KTsKKwkJVF9UQVNLKGNtZCktPnRfdGFza3Nfc2VfbnVtKys7CisKKwkJREVCVUdfTUVNKCJBbGxvY2F0ZWQgc3RydWN0IHNlX21lbSBwYWdlKCVwKSBMZW5ndGgoJXUpIgorCQkJIiBPZmZzZXQoJXUpXG4iLCBzZV9tZW0tPnNlX3BhZ2UsIHNlX21lbS0+c2VfbGVuLAorCQkJc2VfbWVtLT5zZV9vZmYpOworCisJCWxlbmd0aCAtPSBzZV9tZW0tPnNlX2xlbjsKKwl9CisKKwlERUJVR19NRU0oIkFsbG9jYXRlZCB0b3RhbCBzdHJ1Y3Qgc2VfbWVtIGVsZW1lbnRzKCV1KVxuIiwKKwkJCVRfVEFTSyhjbWQpLT50X3Rhc2tzX3NlX251bSk7CisKKwlyZXR1cm4gMDsKK291dDoKKwlyZXR1cm4gLTE7Cit9CisKK2V4dGVybiB1MzIgdHJhbnNwb3J0X2NhbGNfc2dfbnVtKAorCXN0cnVjdCBzZV90YXNrICp0YXNrLAorCXN0cnVjdCBzZV9tZW0gKmluX3NlX21lbSwKKwl1MzIgdGFza19vZmZzZXQpCit7CisJc3RydWN0IHNlX2NtZCAqc2VfY21kID0gdGFzay0+dGFza19zZV9jbWQ7CisJc3RydWN0IHNlX2RldmljZSAqc2VfZGV2ID0gU0VfREVWKHNlX2NtZCk7CisJc3RydWN0IHNlX21lbSAqc2VfbWVtID0gaW5fc2VfbWVtOworCXN0cnVjdCB0YXJnZXRfY29yZV9mYWJyaWNfb3BzICp0Zm8gPSBDTURfVEZPKHNlX2NtZCk7CisJdTMyIHNnX2xlbmd0aCwgdGFza19zaXplID0gdGFzay0+dGFza19zaXplLCB0YXNrX3NnX251bV9wYWRkZWQ7CisKKwl3aGlsZSAodGFza19zaXplICE9IDApIHsKKwkJREVCVUdfU0MoInNlX21lbS0+c2VfcGFnZSglcCkgc2VfbWVtLT5zZV9sZW4oJXUpIgorCQkJIiBzZV9tZW0tPnNlX29mZigldSkgdGFza19vZmZzZXQoJXUpXG4iLAorCQkJc2VfbWVtLT5zZV9wYWdlLCBzZV9tZW0tPnNlX2xlbiwKKwkJCXNlX21lbS0+c2Vfb2ZmLCB0YXNrX29mZnNldCk7CisKKwkJaWYgKHRhc2tfb2Zmc2V0ID09IDApIHsKKwkJCWlmICh0YXNrX3NpemUgPj0gc2VfbWVtLT5zZV9sZW4pIHsKKwkJCQlzZ19sZW5ndGggPSBzZV9tZW0tPnNlX2xlbjsKKworCQkJCWlmICghKGxpc3RfaXNfbGFzdCgmc2VfbWVtLT5zZV9saXN0LAorCQkJCQkJVF9UQVNLKHNlX2NtZCktPnRfbWVtX2xpc3QpKSkKKwkJCQkJc2VfbWVtID0gbGlzdF9lbnRyeShzZV9tZW0tPnNlX2xpc3QubmV4dCwKKwkJCQkJCQlzdHJ1Y3Qgc2VfbWVtLCBzZV9saXN0KTsKKwkJCX0gZWxzZSB7CisJCQkJc2dfbGVuZ3RoID0gdGFza19zaXplOworCQkJCXRhc2tfc2l6ZSAtPSBzZ19sZW5ndGg7CisJCQkJZ290byBuZXh0OworCQkJfQorCisJCQlERUJVR19TQygic2dfbGVuZ3RoKCV1KSB0YXNrX3NpemUoJXUpXG4iLAorCQkJCQlzZ19sZW5ndGgsIHRhc2tfc2l6ZSk7CisJCX0gZWxzZSB7CisJCQlpZiAoKHNlX21lbS0+c2VfbGVuIC0gdGFza19vZmZzZXQpID4gdGFza19zaXplKSB7CisJCQkJc2dfbGVuZ3RoID0gdGFza19zaXplOworCQkJCXRhc2tfc2l6ZSAtPSBzZ19sZW5ndGg7CisJCQkJZ290byBuZXh0OworCQkJIH0gZWxzZSB7CisJCQkJc2dfbGVuZ3RoID0gKHNlX21lbS0+c2VfbGVuIC0gdGFza19vZmZzZXQpOworCisJCQkJaWYgKCEobGlzdF9pc19sYXN0KCZzZV9tZW0tPnNlX2xpc3QsCisJCQkJCQlUX1RBU0soc2VfY21kKS0+dF9tZW1fbGlzdCkpKQorCQkJCQlzZV9tZW0gPSBsaXN0X2VudHJ5KHNlX21lbS0+c2VfbGlzdC5uZXh0LAorCQkJCQkJCXN0cnVjdCBzZV9tZW0sIHNlX2xpc3QpOworCQkJfQorCisJCQlERUJVR19TQygic2dfbGVuZ3RoKCV1KSB0YXNrX3NpemUoJXUpXG4iLAorCQkJCQlzZ19sZW5ndGgsIHRhc2tfc2l6ZSk7CisKKwkJCXRhc2tfb2Zmc2V0ID0gMDsKKwkJfQorCQl0YXNrX3NpemUgLT0gc2dfbGVuZ3RoOworbmV4dDoKKwkJREVCVUdfU0MoInRhc2tbJXVdIC0gUmVkdWNpbmcgdGFza19zaXplIHRvKCV1KVxuIiwKKwkJCXRhc2stPnRhc2tfbm8sIHRhc2tfc2l6ZSk7CisKKwkJdGFzay0+dGFza19zZ19udW0rKzsKKwl9CisJLyoKKwkgKiBDaGVjayBpZiB0aGUgZmFicmljIG1vZHVsZSBkcml2ZXIgaXMgcmVxdWVzdGluZyB0aGF0IGFsbAorCSAqIHN0cnVjdCBzZV90YXNrLT50YXNrX3NnW10gYmUgY2hhaW5lZCB0b2dldGhlci4uICBJZiBzbywKKwkgKiB0aGVuIGFsbG9jYXRlIGFuIGV4dHJhIHBhZGRpbmcgU0cgZW50cnkgZm9yIGxpbmtpbmcgYW5kCisJICogbWFya2luZyB0aGUgZW5kIG9mIHRoZSBjaGFpbmVkIFNHTC4KKwkgKi8KKwlpZiAodGZvLT50YXNrX3NnX2NoYWluaW5nKSB7CisJCXRhc2tfc2dfbnVtX3BhZGRlZCA9ICh0YXNrLT50YXNrX3NnX251bSArIDEpOworCQl0YXNrLT50YXNrX3BhZGRlZF9zZyA9IDE7CisJfSBlbHNlCisJCXRhc2tfc2dfbnVtX3BhZGRlZCA9IHRhc2stPnRhc2tfc2dfbnVtOworCisJdGFzay0+dGFza19zZyA9IGt6YWxsb2ModGFza19zZ19udW1fcGFkZGVkICoKKwkJCXNpemVvZihzdHJ1Y3Qgc2NhdHRlcmxpc3QpLCBHRlBfS0VSTkVMKTsKKwlpZiAoISh0YXNrLT50YXNrX3NnKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIgorCQkJCSIgdGFzay0+dGFza19zZ1xuIik7CisJCXJldHVybiAwOworCX0KKwlzZ19pbml0X3RhYmxlKCZ0YXNrLT50YXNrX3NnWzBdLCB0YXNrX3NnX251bV9wYWRkZWQpOworCS8qCisJICogU2V0dXAgdGFzay0+dGFza19zZ19iaWRpIGZvciBTQ1NJIFJFQUQgcGF5bG9hZCBmb3IKKwkgKiBUQ00vcFNDU0kgcGFzc3Rocm91Z2ggaWYgcHJlc2VudCBmb3IgQklESS1DT01NQU5ECisJICovCisJaWYgKChUX1RBU0soc2VfY21kKS0+dF9tZW1fYmlkaV9saXN0ICE9IE5VTEwpICYmCisJICAgIChUUkFOU1BPUlQoc2VfZGV2KS0+dHJhbnNwb3J0X3R5cGUgPT0gVFJBTlNQT1JUX1BMVUdJTl9QSEJBX1BERVYpKSB7CisJCXRhc2stPnRhc2tfc2dfYmlkaSA9IGt6YWxsb2ModGFza19zZ19udW1fcGFkZGVkICoKKwkJCQlzaXplb2Yoc3RydWN0IHNjYXR0ZXJsaXN0KSwgR0ZQX0tFUk5FTCk7CisJCWlmICghKHRhc2stPnRhc2tfc2dfYmlkaSkpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIG1lbW9yeSBmb3IiCisJCQkJIiB0YXNrLT50YXNrX3NnX2JpZGlcbiIpOworCQkJcmV0dXJuIDA7CisJCX0KKwkJc2dfaW5pdF90YWJsZSgmdGFzay0+dGFza19zZ19iaWRpWzBdLCB0YXNrX3NnX251bV9wYWRkZWQpOworCX0KKwkvKgorCSAqIEZvciB0aGUgY2hhaW5pbmcgY2FzZSwgc2V0dXAgdGhlIHByb3BlciBlbmQgb2YgU0dMIGZvciB0aGUKKwkgKiBpbml0aWFsIHN1Ym1pc3Npb24gc3RydWN0IHRhc2sgaW50byBzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2FwaS4KKwkgKiBUaGlzIHdpbGwgYmUgY2xlYXJlZCBsYXRlciBieSB0cmFuc3BvcnRfZG9fdGFza19zZ19jaGFpbigpCisJICovCisJaWYgKHRhc2stPnRhc2tfcGFkZGVkX3NnKSB7CisJCXNnX21hcmtfZW5kKCZ0YXNrLT50YXNrX3NnW3Rhc2stPnRhc2tfc2dfbnVtIC0gMV0pOworCQkvKgorCQkgKiBBZGRlZCB0aGUgJ2lmJyBjaGVjayBiZWZvcmUgbWFya2luZyBlbmQgb2YgYmktZGlyZWN0aW9uYWwKKwkJICogc2NhdHRlcmxpc3QgKHdoaWNoIGdldHMgY3JlYXRlZCBvbmx5IGluIGNhc2Ugb2YgcmVxdWVzdAorCQkgKiAoUkQgKyBXUikuCisJCSAqLworCQlpZiAodGFzay0+dGFza19zZ19iaWRpKQorCQkJc2dfbWFya19lbmQoJnRhc2stPnRhc2tfc2dfYmlkaVt0YXNrLT50YXNrX3NnX251bSAtIDFdKTsKKwl9CisKKwlERUJVR19TQygiU3VjY2Vzc2Z1bGx5IGFsbG9jYXRlZCB0YXNrLT50YXNrX3NnX251bSgldSksIgorCQkiIHRhc2tfc2dfbnVtX3BhZGRlZCgldSlcbiIsIHRhc2stPnRhc2tfc2dfbnVtLAorCQl0YXNrX3NnX251bV9wYWRkZWQpOworCisJcmV0dXJuIHRhc2stPnRhc2tfc2dfbnVtOworfQorCitzdGF0aWMgaW5saW5lIGludCB0cmFuc3BvcnRfc2V0X3Rhc2tzX3NlY3RvcnNfZGlzaygKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzaywKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYsCisJdW5zaWduZWQgbG9uZyBsb25nIGxiYSwKKwl1MzIgc2VjdG9ycywKKwlpbnQgKm1heF9zZWN0b3JzX3NldCkKK3sKKwlpZiAoKGxiYSArIHNlY3RvcnMpID4gdHJhbnNwb3J0X2Rldl9lbmRfbGJhKGRldikpIHsKKwkJdGFzay0+dGFza19zZWN0b3JzID0gKCh0cmFuc3BvcnRfZGV2X2VuZF9sYmEoZGV2KSAtIGxiYSkgKyAxKTsKKworCQlpZiAodGFzay0+dGFza19zZWN0b3JzID4gREVWX0FUVFJJQihkZXYpLT5tYXhfc2VjdG9ycykgeworCQkJdGFzay0+dGFza19zZWN0b3JzID0gREVWX0FUVFJJQihkZXYpLT5tYXhfc2VjdG9yczsKKwkJCSptYXhfc2VjdG9yc19zZXQgPSAxOworCQl9CisJfSBlbHNlIHsKKwkJaWYgKHNlY3RvcnMgPiBERVZfQVRUUklCKGRldiktPm1heF9zZWN0b3JzKSB7CisJCQl0YXNrLT50YXNrX3NlY3RvcnMgPSBERVZfQVRUUklCKGRldiktPm1heF9zZWN0b3JzOworCQkJKm1heF9zZWN0b3JzX3NldCA9IDE7CisJCX0gZWxzZQorCQkJdGFzay0+dGFza19zZWN0b3JzID0gc2VjdG9yczsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSBpbnQgdHJhbnNwb3J0X3NldF90YXNrc19zZWN0b3JzX25vbl9kaXNrKAorCXN0cnVjdCBzZV90YXNrICp0YXNrLAorCXN0cnVjdCBzZV9kZXZpY2UgKmRldiwKKwl1bnNpZ25lZCBsb25nIGxvbmcgbGJhLAorCXUzMiBzZWN0b3JzLAorCWludCAqbWF4X3NlY3RvcnNfc2V0KQoreworCWlmIChzZWN0b3JzID4gREVWX0FUVFJJQihkZXYpLT5tYXhfc2VjdG9ycykgeworCQl0YXNrLT50YXNrX3NlY3RvcnMgPSBERVZfQVRUUklCKGRldiktPm1heF9zZWN0b3JzOworCQkqbWF4X3NlY3RvcnNfc2V0ID0gMTsKKwl9IGVsc2UKKwkJdGFzay0+dGFza19zZWN0b3JzID0gc2VjdG9yczsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW5saW5lIGludCB0cmFuc3BvcnRfc2V0X3Rhc2tzX3NlY3RvcnMoCisJc3RydWN0IHNlX3Rhc2sgKnRhc2ssCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCXVuc2lnbmVkIGxvbmcgbG9uZyBsYmEsCisJdTMyIHNlY3RvcnMsCisJaW50ICptYXhfc2VjdG9yc19zZXQpCit7CisJcmV0dXJuIChUUkFOU1BPUlQoZGV2KS0+Z2V0X2RldmljZV90eXBlKGRldikgPT0gVFlQRV9ESVNLKSA/CisJCXRyYW5zcG9ydF9zZXRfdGFza3Nfc2VjdG9yc19kaXNrKHRhc2ssIGRldiwgbGJhLCBzZWN0b3JzLAorCQkJCW1heF9zZWN0b3JzX3NldCkgOgorCQl0cmFuc3BvcnRfc2V0X3Rhc2tzX3NlY3RvcnNfbm9uX2Rpc2sodGFzaywgZGV2LCBsYmEsIHNlY3RvcnMsCisJCQkJbWF4X3NlY3RvcnNfc2V0KTsKK30KKworc3RhdGljIGludCB0cmFuc3BvcnRfbWFwX3NnX3RvX21lbSgKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJc3RydWN0IGxpc3RfaGVhZCAqc2VfbWVtX2xpc3QsCisJdm9pZCAqaW5fbWVtLAorCXUzMiAqc2VfbWVtX2NudCkKK3sKKwlzdHJ1Y3Qgc2VfbWVtICpzZV9tZW07CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZzsKKwl1MzIgc2dfY291bnQgPSAxLCBjbWRfc2l6ZSA9IGNtZC0+ZGF0YV9sZW5ndGg7CisKKwlpZiAoIWluX21lbSkgeworCQlwcmludGsoS0VSTl9FUlIgIk5vIHNvdXJjZSBzY2F0dGVybGlzdFxuIik7CisJCXJldHVybiAtMTsKKwl9CisJc2cgPSAoc3RydWN0IHNjYXR0ZXJsaXN0ICopaW5fbWVtOworCisJd2hpbGUgKGNtZF9zaXplKSB7CisJCXNlX21lbSA9IGttZW1fY2FjaGVfemFsbG9jKHNlX21lbV9jYWNoZSwgR0ZQX0tFUk5FTCk7CisJCWlmICghKHNlX21lbSkpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIHN0cnVjdCBzZV9tZW1cbiIpOworCQkJcmV0dXJuIC0xOworCQl9CisJCUlOSVRfTElTVF9IRUFEKCZzZV9tZW0tPnNlX2xpc3QpOworCQlERUJVR19NRU0oInNnX3RvX21lbTogU3RhcnRpbmcgbG9vcCB3aXRoIGNtZF9zaXplOiAldSIKKwkJCSIgc2dfcGFnZTogJXAgb2Zmc2V0OiAlZCBsZW5ndGg6ICVkXG4iLCBjbWRfc2l6ZSwKKwkJCXNnX3BhZ2Uoc2cpLCBzZy0+b2Zmc2V0LCBzZy0+bGVuZ3RoKTsKKworCQlzZV9tZW0tPnNlX3BhZ2UgPSBzZ19wYWdlKHNnKTsKKwkJc2VfbWVtLT5zZV9vZmYgPSBzZy0+b2Zmc2V0OworCisJCWlmIChjbWRfc2l6ZSA+IHNnLT5sZW5ndGgpIHsKKwkJCXNlX21lbS0+c2VfbGVuID0gc2ctPmxlbmd0aDsKKwkJCXNnID0gc2dfbmV4dChzZyk7CisJCQlzZ19jb3VudCsrOworCQl9IGVsc2UKKwkJCXNlX21lbS0+c2VfbGVuID0gY21kX3NpemU7CisKKwkJY21kX3NpemUgLT0gc2VfbWVtLT5zZV9sZW47CisKKwkJREVCVUdfTUVNKCJzZ190b19tZW06ICpzZV9tZW1fY250OiAldSBjbWRfc2l6ZTogJXVcbiIsCisJCQkJKnNlX21lbV9jbnQsIGNtZF9zaXplKTsKKwkJREVCVUdfTUVNKCJzZ190b19tZW06IEZpbmFsIHNlX3BhZ2U6ICVwIHNlX29mZjogJWQgc2VfbGVuOiAlZFxuIiwKKwkJCQlzZV9tZW0tPnNlX3BhZ2UsIHNlX21lbS0+c2Vfb2ZmLCBzZV9tZW0tPnNlX2xlbik7CisKKwkJbGlzdF9hZGRfdGFpbCgmc2VfbWVtLT5zZV9saXN0LCBzZV9tZW1fbGlzdCk7CisJCSgqc2VfbWVtX2NudCkrKzsKKwl9CisKKwlERUJVR19NRU0oInRhc2tbMF0gLSBNYXBwZWQoJXUpIHN0cnVjdCBzY2F0dGVybGlzdCBzZWdtZW50cyB0bygldSkiCisJCSIgc3RydWN0IHNlX21lbVxuIiwgc2dfY291bnQsICpzZV9tZW1fY250KTsKKworCWlmIChzZ19jb3VudCAhPSAqc2VfbWVtX2NudCkKKwkJQlVHKCk7CisKKwlyZXR1cm4gMDsKK30KKworLyoJdHJhbnNwb3J0X21hcF9tZW1fdG9fc2coKToKKyAqCisgKgorICovCitpbnQgdHJhbnNwb3J0X21hcF9tZW1fdG9fc2coCisJc3RydWN0IHNlX3Rhc2sgKnRhc2ssCisJc3RydWN0IGxpc3RfaGVhZCAqc2VfbWVtX2xpc3QsCisJdm9pZCAqaW5fbWVtLAorCXN0cnVjdCBzZV9tZW0gKmluX3NlX21lbSwKKwlzdHJ1Y3Qgc2VfbWVtICoqb3V0X3NlX21lbSwKKwl1MzIgKnNlX21lbV9jbnQsCisJdTMyICp0YXNrX29mZnNldCkKK3sKKwlzdHJ1Y3Qgc2VfY21kICpzZV9jbWQgPSB0YXNrLT50YXNrX3NlX2NtZDsKKwlzdHJ1Y3Qgc2VfbWVtICpzZV9tZW0gPSBpbl9zZV9tZW07CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZyA9IChzdHJ1Y3Qgc2NhdHRlcmxpc3QgKilpbl9tZW07CisJdTMyIHRhc2tfc2l6ZSA9IHRhc2stPnRhc2tfc2l6ZSwgc2dfbm8gPSAwOworCisJaWYgKCFzZykgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBsb2NhdGUgdmFsaWQgc3RydWN0IgorCQkJCSIgc2NhdHRlcmxpc3QgcG9pbnRlclxuIik7CisJCXJldHVybiAtMTsKKwl9CisKKwl3aGlsZSAodGFza19zaXplICE9IDApIHsKKwkJLyoKKwkJICogU2V0dXAgdGhlIGNvbnRpZ2lvdXMgYXJyYXkgb2Ygc2NhdHRlcmxpc3RzIGZvcgorCQkgKiB0aGlzIHN0cnVjdCBzZV90YXNrLgorCQkgKi8KKwkJc2dfYXNzaWduX3BhZ2Uoc2csIHNlX21lbS0+c2VfcGFnZSk7CisKKwkJaWYgKCp0YXNrX29mZnNldCA9PSAwKSB7CisJCQlzZy0+b2Zmc2V0ID0gc2VfbWVtLT5zZV9vZmY7CisKKwkJCWlmICh0YXNrX3NpemUgPj0gc2VfbWVtLT5zZV9sZW4pIHsKKwkJCQlzZy0+bGVuZ3RoID0gc2VfbWVtLT5zZV9sZW47CisKKwkJCQlpZiAoIShsaXN0X2lzX2xhc3QoJnNlX21lbS0+c2VfbGlzdCwKKwkJCQkJCVRfVEFTSyhzZV9jbWQpLT50X21lbV9saXN0KSkpIHsKKwkJCQkJc2VfbWVtID0gbGlzdF9lbnRyeShzZV9tZW0tPnNlX2xpc3QubmV4dCwKKwkJCQkJCQlzdHJ1Y3Qgc2VfbWVtLCBzZV9saXN0KTsKKwkJCQkJKCpzZV9tZW1fY250KSsrOworCQkJCX0KKwkJCX0gZWxzZSB7CisJCQkJc2ctPmxlbmd0aCA9IHRhc2tfc2l6ZTsKKwkJCQkvKgorCQkJCSAqIERldGVybWluZSBpZiB3ZSBuZWVkIHRvIGNhbGN1bGF0ZSBhbiBvZmZzZXQKKwkJCQkgKiBpbnRvIHRoZSBzdHJ1Y3Qgc2VfbWVtIG9uIHRoZSBuZXh0IGdvIGFyb3VuZC4uCisJCQkJICovCisJCQkJdGFza19zaXplIC09IHNnLT5sZW5ndGg7CisJCQkJaWYgKCEodGFza19zaXplKSkKKwkJCQkJKnRhc2tfb2Zmc2V0ID0gc2ctPmxlbmd0aDsKKworCQkJCWdvdG8gbmV4dDsKKwkJCX0KKworCQl9IGVsc2UgeworCQkJc2ctPm9mZnNldCA9ICgqdGFza19vZmZzZXQgKyBzZV9tZW0tPnNlX29mZik7CisKKwkJCWlmICgoc2VfbWVtLT5zZV9sZW4gLSAqdGFza19vZmZzZXQpID4gdGFza19zaXplKSB7CisJCQkJc2ctPmxlbmd0aCA9IHRhc2tfc2l6ZTsKKwkJCQkvKgorCQkJCSAqIERldGVybWluZSBpZiB3ZSBuZWVkIHRvIGNhbGN1bGF0ZSBhbiBvZmZzZXQKKwkJCQkgKiBpbnRvIHRoZSBzdHJ1Y3Qgc2VfbWVtIG9uIHRoZSBuZXh0IGdvIGFyb3VuZC4uCisJCQkJICovCisJCQkJdGFza19zaXplIC09IHNnLT5sZW5ndGg7CisJCQkJaWYgKCEodGFza19zaXplKSkKKwkJCQkJKnRhc2tfb2Zmc2V0ICs9IHNnLT5sZW5ndGg7CisKKwkJCQlnb3RvIG5leHQ7CisJCQl9IGVsc2UgeworCQkJCXNnLT5sZW5ndGggPSAoc2VfbWVtLT5zZV9sZW4gLSAqdGFza19vZmZzZXQpOworCisJCQkJaWYgKCEobGlzdF9pc19sYXN0KCZzZV9tZW0tPnNlX2xpc3QsCisJCQkJCQlUX1RBU0soc2VfY21kKS0+dF9tZW1fbGlzdCkpKSB7CisJCQkJCXNlX21lbSA9IGxpc3RfZW50cnkoc2VfbWVtLT5zZV9saXN0Lm5leHQsCisJCQkJCQkJc3RydWN0IHNlX21lbSwgc2VfbGlzdCk7CisJCQkJCSgqc2VfbWVtX2NudCkrKzsKKwkJCQl9CisJCQl9CisKKwkJCSp0YXNrX29mZnNldCA9IDA7CisJCX0KKwkJdGFza19zaXplIC09IHNnLT5sZW5ndGg7CituZXh0OgorCQlERUJVR19NRU0oInRhc2tbJXVdIG1lbV90b19zZyAtIHNnWyV1XSglcCkoJXUpKCV1KSAtIFJlZHVjaW5nIgorCQkJIiB0YXNrX3NpemUgdG8oJXUpLCB0YXNrX29mZnNldDogJXVcbiIsIHRhc2stPnRhc2tfbm8sIHNnX25vLAorCQkJc2dfcGFnZShzZyksIHNnLT5sZW5ndGgsIHNnLT5vZmZzZXQsIHRhc2tfc2l6ZSwgKnRhc2tfb2Zmc2V0KTsKKworCQlzZ19ubysrOworCQlpZiAoISh0YXNrX3NpemUpKQorCQkJYnJlYWs7CisKKwkJc2cgPSBzZ19uZXh0KHNnKTsKKworCQlpZiAodGFza19zaXplID4gc2VfY21kLT5kYXRhX2xlbmd0aCkKKwkJCUJVRygpOworCX0KKwkqb3V0X3NlX21lbSA9IHNlX21lbTsKKworCURFQlVHX01FTSgidGFza1sldV0gLSBNYXBwZWQoJXUpIHN0cnVjdCBzZV9tZW0gc2VnbWVudHMgdG8gdG90YWwoJXUpIgorCQkiIFNHc1xuIiwgdGFzay0+dGFza19ubywgKnNlX21lbV9jbnQsIHNnX25vKTsKKworCXJldHVybiAwOworfQorCisvKgorICogVGhpcyBmdW5jdGlvbiBjYW4gYmUgdXNlZCBieSBIVyB0YXJnZXQgbW9kZSBkcml2ZXJzIHRvIGNyZWF0ZSBhIGxpbmtlZAorICogc2NhdHRlcmxpc3QgZnJvbSBhbGwgY29udGlndW91c2x5IGFsbG9jYXRlZCBzdHJ1Y3Qgc2VfdGFzay0+dGFza19zZ1tdLgorICogVGhpcyBpcyBpbnRlbmRlZCB0byBiZSBjYWxsZWQgZHVyaW5nIHRoZSBjb21wbGV0aW9uIHBhdGggYnkgVENNIENvcmUKKyAqIHdoZW4gc3RydWN0IHRhcmdldF9jb3JlX2ZhYnJpY19vcHMtPmNoZWNrX3Rhc2tfc2dfY2hhaW5pbmcgaXMgZW5hYmxlZC4KKyAqLwordm9pZCB0cmFuc3BvcnRfZG9fdGFza19zZ19jaGFpbihzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZ19oZWFkID0gTlVMTCwgKnNnX2xpbmsgPSBOVUxMLCAqc2dfZmlyc3QgPSBOVUxMOworCXN0cnVjdCBzY2F0dGVybGlzdCAqc2dfaGVhZF9jdXIgPSBOVUxMLCAqc2dfbGlua19jdXIgPSBOVUxMOworCXN0cnVjdCBzY2F0dGVybGlzdCAqc2csICpzZ19lbmQgPSBOVUxMLCAqc2dfZW5kX2N1ciA9IE5VTEw7CisJc3RydWN0IHNlX3Rhc2sgKnRhc2s7CisJc3RydWN0IHRhcmdldF9jb3JlX2ZhYnJpY19vcHMgKnRmbyA9IENNRF9URk8oY21kKTsKKwl1MzIgdGFza19zZ19udW0gPSAwLCBzZ19jb3VudCA9IDA7CisJaW50IGk7CisKKwlpZiAodGZvLT50YXNrX3NnX2NoYWluaW5nID09IDApIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJ0YXNrX3NnX2NoYWluaW5nIGlzIGRpYWJsZWQgZm9yIGZhYnJpYyBtb2R1bGU6IgorCQkJCSIgJXNcbiIsIHRmby0+Z2V0X2ZhYnJpY19uYW1lKCkpOworCQlkdW1wX3N0YWNrKCk7CisJCXJldHVybjsKKwl9CisJLyoKKwkgKiBXYWxrIHRoZSBzdHJ1Y3Qgc2VfdGFzayBsaXN0IGFuZCBzZXR1cCBzY2F0dGVybGlzdCBjaGFpbnMKKwkgKiBmb3IgZWFjaCBjb250aWd1b3NseSBhbGxvY2F0ZWQgc3RydWN0IHNlX3Rhc2stPnRhc2tfc2dbXS4KKwkgKi8KKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHRhc2ssICZUX1RBU0soY21kKS0+dF90YXNrX2xpc3QsIHRfbGlzdCkgeworCQlpZiAoISh0YXNrLT50YXNrX3NnKSB8fCAhKHRhc2stPnRhc2tfcGFkZGVkX3NnKSkKKwkJCWNvbnRpbnVlOworCisJCWlmIChzZ19oZWFkICYmIHNnX2xpbmspIHsKKwkJCXNnX2hlYWRfY3VyID0gJnRhc2stPnRhc2tfc2dbMF07CisJCQlzZ19saW5rX2N1ciA9ICZ0YXNrLT50YXNrX3NnW3Rhc2stPnRhc2tfc2dfbnVtXTsKKwkJCS8qCisJCQkgKiBFaXRoZXIgYWRkIGNoYWluIG9yIG1hcmsgZW5kIG9mIHNjYXR0ZXJsaXN0CisJCQkgKi8KKwkJCWlmICghKGxpc3RfaXNfbGFzdCgmdGFzay0+dF9saXN0LAorCQkJCQkmVF9UQVNLKGNtZCktPnRfdGFza19saXN0KSkpIHsKKwkJCQkvKgorCQkJCSAqIENsZWFyIGV4aXN0aW5nIFNHTCB0ZXJtaW5hdGlvbiBiaXQgc2V0IGluCisJCQkJICogdHJhbnNwb3J0X2NhbGNfc2dfbnVtKCksIHNlZSBzZ19tYXJrX2VuZCgpCisJCQkJICovCisJCQkJc2dfZW5kX2N1ciA9ICZ0YXNrLT50YXNrX3NnW3Rhc2stPnRhc2tfc2dfbnVtIC0gMV07CisJCQkJc2dfZW5kX2N1ci0+cGFnZV9saW5rICY9IH4weDAyOworCisJCQkJc2dfY2hhaW4oc2dfaGVhZCwgdGFza19zZ19udW0sIHNnX2hlYWRfY3VyKTsKKwkJCQlzZ19jb3VudCArPSAodGFzay0+dGFza19zZ19udW0gKyAxKTsKKwkJCX0gZWxzZQorCQkJCXNnX2NvdW50ICs9IHRhc2stPnRhc2tfc2dfbnVtOworCisJCQlzZ19oZWFkID0gc2dfaGVhZF9jdXI7CisJCQlzZ19saW5rID0gc2dfbGlua19jdXI7CisJCQl0YXNrX3NnX251bSA9IHRhc2stPnRhc2tfc2dfbnVtOworCQkJY29udGludWU7CisJCX0KKwkJc2dfaGVhZCA9IHNnX2ZpcnN0ID0gJnRhc2stPnRhc2tfc2dbMF07CisJCXNnX2xpbmsgPSAmdGFzay0+dGFza19zZ1t0YXNrLT50YXNrX3NnX251bV07CisJCXRhc2tfc2dfbnVtID0gdGFzay0+dGFza19zZ19udW07CisJCS8qCisJCSAqIENoZWNrIGZvciBzaW5nbGUgdGFzay4uCisJCSAqLworCQlpZiAoIShsaXN0X2lzX2xhc3QoJnRhc2stPnRfbGlzdCwgJlRfVEFTSyhjbWQpLT50X3Rhc2tfbGlzdCkpKSB7CisJCQkvKgorCQkJICogQ2xlYXIgZXhpc3RpbmcgU0dMIHRlcm1pbmF0aW9uIGJpdCBzZXQgaW4KKwkJCSAqIHRyYW5zcG9ydF9jYWxjX3NnX251bSgpLCBzZWUgc2dfbWFya19lbmQoKQorCQkJICovCisJCQlzZ19lbmQgPSAmdGFzay0+dGFza19zZ1t0YXNrLT50YXNrX3NnX251bSAtIDFdOworCQkJc2dfZW5kLT5wYWdlX2xpbmsgJj0gfjB4MDI7CisJCQlzZ19jb3VudCArPSAodGFzay0+dGFza19zZ19udW0gKyAxKTsKKwkJfSBlbHNlCisJCQlzZ19jb3VudCArPSB0YXNrLT50YXNrX3NnX251bTsKKwl9CisJLyoKKwkgKiBTZXR1cCB0aGUgc3RhcnRpbmcgcG9pbnRlciBhbmQgdG90YWwgdF90YXNrc19zZ19saW5rZWRfbm8gaW5jbHVkaW5nCisJICogcGFkZGluZyBTR3MgZm9yIGxpbmtpbmcgYW5kIHRvIG1hcmsgdGhlIGVuZC4KKwkgKi8KKwlUX1RBU0soY21kKS0+dF90YXNrc19zZ19jaGFpbmVkID0gc2dfZmlyc3Q7CisJVF9UQVNLKGNtZCktPnRfdGFza3Nfc2dfY2hhaW5lZF9ubyA9IHNnX2NvdW50OworCisJREVCVUdfQ01EX00oIlNldHVwIFRfVEFTSyhjbWQpLT50X3Rhc2tzX3NnX2NoYWluZWQ6ICVwIGFuZCIKKwkJIiB0X3Rhc2tzX3NnX2NoYWluZWRfbm86ICV1XG4iLCBUX1RBU0soY21kKS0+dF90YXNrc19zZ19jaGFpbmVkLAorCQlUX1RBU0soY21kKS0+dF90YXNrc19zZ19jaGFpbmVkX25vKTsKKworCWZvcl9lYWNoX3NnKFRfVEFTSyhjbWQpLT50X3Rhc2tzX3NnX2NoYWluZWQsIHNnLAorCQkJVF9UQVNLKGNtZCktPnRfdGFza3Nfc2dfY2hhaW5lZF9ubywgaSkgeworCisJCURFQlVHX0NNRF9NKCJTRzogJXAgcGFnZTogJXAgbGVuZ3RoOiAlZCBvZmZzZXQ6ICVkXG4iLAorCQkJc2csIHNnX3BhZ2Uoc2cpLCBzZy0+bGVuZ3RoLCBzZy0+b2Zmc2V0KTsKKwkJaWYgKHNnX2lzX2NoYWluKHNnKSkKKwkJCURFQlVHX0NNRF9NKCJTRzogJXAgc2dfaXNfY2hhaW49MVxuIiwgc2cpOworCQlpZiAoc2dfaXNfbGFzdChzZykpCisJCQlERUJVR19DTURfTSgiU0c6ICVwIHNnX2lzX2xhc3Q9MVxuIiwgc2cpOworCX0KKworfQorRVhQT1JUX1NZTUJPTCh0cmFuc3BvcnRfZG9fdGFza19zZ19jaGFpbik7CisKK3N0YXRpYyBpbnQgdHJhbnNwb3J0X2RvX3NlX21lbV9tYXAoCisJc3RydWN0IHNlX2RldmljZSAqZGV2LAorCXN0cnVjdCBzZV90YXNrICp0YXNrLAorCXN0cnVjdCBsaXN0X2hlYWQgKnNlX21lbV9saXN0LAorCXZvaWQgKmluX21lbSwKKwlzdHJ1Y3Qgc2VfbWVtICppbl9zZV9tZW0sCisJc3RydWN0IHNlX21lbSAqKm91dF9zZV9tZW0sCisJdTMyICpzZV9tZW1fY250LAorCXUzMiAqdGFza19vZmZzZXRfaW4pCit7CisJdTMyIHRhc2tfb2Zmc2V0ID0gKnRhc2tfb2Zmc2V0X2luOworCWludCByZXQgPSAwOworCS8qCisJICogc2Vfc3Vic3lzdGVtX2FwaV90LT5kb19zZV9tZW1fbWFwIGlzIHVzZWQgd2hlbiBpbnRlcm5hbCBhbGxvY2F0aW9uCisJICogaGFzIGJlZW4gZG9uZSBieSB0aGUgdHJhbnNwb3J0IHBsdWdpbi4KKwkgKi8KKwlpZiAoVFJBTlNQT1JUKGRldiktPmRvX3NlX21lbV9tYXApIHsKKwkJcmV0ID0gVFJBTlNQT1JUKGRldiktPmRvX3NlX21lbV9tYXAodGFzaywgc2VfbWVtX2xpc3QsCisJCQkJaW5fbWVtLCBpbl9zZV9tZW0sIG91dF9zZV9tZW0sIHNlX21lbV9jbnQsCisJCQkJdGFza19vZmZzZXRfaW4pOworCQlpZiAocmV0ID09IDApCisJCQlUX1RBU0sodGFzay0+dGFza19zZV9jbWQpLT50X3Rhc2tzX3NlX251bSArPSAqc2VfbWVtX2NudDsKKworCQlyZXR1cm4gcmV0OworCX0KKwkvKgorCSAqIFRoaXMgaXMgdGhlIG5vcm1hbCBwYXRoIGZvciBhbGwgbm9ybWFsIG5vbiBCSURJIGFuZCBCSURJLUNPTU1BTkQKKwkgKiBXUklURSBwYXlsb2Fkcy4uICBJZiB3ZSBuZWVkIHRvIGRvIEJJREkgUkVBRCBwYXNzdGhyb3VnaCBmb3IKKwkgKiBUQ00vcFNDU0kgdGhlIGZpcnN0IGNhbGwgdG8gdHJhbnNwb3J0X2RvX3NlX21lbV9tYXAgLT4KKwkgKiB0cmFuc3BvcnRfY2FsY19zZ19udW0oKSAtPiB0cmFuc3BvcnRfbWFwX21lbV90b19zZygpIHdpbGwgZG8gdGhlCisJICogYWxsb2NhdGlvbiBmb3IgdGFzay0+dGFza19zZ19iaWRpLCBhbmQgdGhlIHN1YnNlcXVlbnQgY2FsbCB0bworCSAqIHRyYW5zcG9ydF9kb19zZV9tZW1fbWFwKCkgZnJvbSB0cmFuc3BvcnRfZ2VuZXJpY19nZXRfY2RiX2NvdW50KCkKKwkgKi8KKwlpZiAoISh0YXNrLT50YXNrX3NnX2JpZGkpKSB7CisJCS8qCisJCSAqIEFzc3VtZSBkZWZhdWx0IHRoYXQgdHJhbnNwb3J0IHBsdWdpbiBzcGVha3MgcHJlYWxsb2NhdGVkCisJCSAqIHNjYXR0ZXJsaXN0cy4KKwkJICovCisJCWlmICghKHRyYW5zcG9ydF9jYWxjX3NnX251bSh0YXNrLCBpbl9zZV9tZW0sIHRhc2tfb2Zmc2V0KSkpCisJCQlyZXR1cm4gLTE7CisJCS8qCisJCSAqIHN0cnVjdCBzZV90YXNrLT50YXNrX3NnIG5vdyBjb250YWlucyB0aGUgc3RydWN0IHNjYXR0ZXJsaXN0IGFycmF5LgorCQkgKi8KKwkJcmV0dXJuIHRyYW5zcG9ydF9tYXBfbWVtX3RvX3NnKHRhc2ssIHNlX21lbV9saXN0LCB0YXNrLT50YXNrX3NnLAorCQkJCQlpbl9zZV9tZW0sIG91dF9zZV9tZW0sIHNlX21lbV9jbnQsCisJCQkJCXRhc2tfb2Zmc2V0X2luKTsKKwl9CisJLyoKKwkgKiBIYW5kbGUgdGhlIHNlX21lbV9saXN0IC0+IHN0cnVjdCB0YXNrLT50YXNrX3NnX2JpZGkKKwkgKiBtZW1vcnkgbWFwIGZvciB0aGUgZXh0cmEgQklESSBSRUFEIHBheWxvYWQKKwkgKi8KKwlyZXR1cm4gdHJhbnNwb3J0X21hcF9tZW1fdG9fc2codGFzaywgc2VfbWVtX2xpc3QsIHRhc2stPnRhc2tfc2dfYmlkaSwKKwkJCQlpbl9zZV9tZW0sIG91dF9zZV9tZW0sIHNlX21lbV9jbnQsCisJCQkJdGFza19vZmZzZXRfaW4pOworfQorCitzdGF0aWMgdTMyIHRyYW5zcG9ydF9nZW5lcmljX2dldF9jZGJfY291bnQoCisJc3RydWN0IHNlX2NtZCAqY21kLAorCXVuc2lnbmVkIGxvbmcgbG9uZyBsYmEsCisJdTMyIHNlY3RvcnMsCisJZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGF0YV9kaXJlY3Rpb24sCisJc3RydWN0IGxpc3RfaGVhZCAqbWVtX2xpc3QsCisJaW50IHNldF9jb3VudHMpCit7CisJdW5zaWduZWQgY2hhciAqY2RiID0gTlVMTDsKKwlzdHJ1Y3Qgc2VfdGFzayAqdGFzazsKKwlzdHJ1Y3Qgc2VfbWVtICpzZV9tZW0gPSBOVUxMLCAqc2VfbWVtX2xvdXQgPSBOVUxMOworCXN0cnVjdCBzZV9tZW0gKnNlX21lbV9iaWRpID0gTlVMTCwgKnNlX21lbV9iaWRpX2xvdXQgPSBOVUxMOworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IFNFX0RFVihjbWQpOworCWludCBtYXhfc2VjdG9yc19zZXQgPSAwLCByZXQ7CisJdTMyIHRhc2tfb2Zmc2V0X2luID0gMCwgc2VfbWVtX2NudCA9IDAsIHNlX21lbV9iaWRpX2NudCA9IDAsIHRhc2tfY2RicyA9IDA7CisKKwlpZiAoIW1lbV9saXN0KSB7CisJCXByaW50ayhLRVJOX0VSUiAibWVtX2xpc3QgaXMgTlVMTCBpbiB0cmFuc3BvcnRfZ2VuZXJpY19nZXQiCisJCQkJIl9jZGJfY291bnQoKVxuIik7CisJCXJldHVybiAwOworCX0KKwkvKgorCSAqIFdoaWxlIHVzaW5nIFJBTURJU0tfRFIgYmFja3N0b3JlcyBpcyB0aGUgb25seSBjYXNlIHdoZXJlCisJICogbWVtX2xpc3Qgd2lsbCBldmVyIGJlIGVtcHR5IGF0IHRoaXMgcG9pbnQuCisJICovCisJaWYgKCEobGlzdF9lbXB0eShtZW1fbGlzdCkpKQorCQlzZV9tZW0gPSBsaXN0X2VudHJ5KG1lbV9saXN0LT5uZXh0LCBzdHJ1Y3Qgc2VfbWVtLCBzZV9saXN0KTsKKwkvKgorCSAqIENoZWNrIGZvciBleHRyYSBzZV9tZW1fYmlkaSBtYXBwaW5nIGZvciBCSURJLUNPTU1BTkRzIHRvCisJICogc3RydWN0IHNlX3Rhc2stPnRhc2tfc2dfYmlkaSBmb3IgVENNL3BTQ1NJIHBhc3N0aHJvdWdoIG9wZXJhdGlvbgorCSAqLworCWlmICgoVF9UQVNLKGNtZCktPnRfbWVtX2JpZGlfbGlzdCAhPSBOVUxMKSAmJgorCSAgICAhKGxpc3RfZW1wdHkoVF9UQVNLKGNtZCktPnRfbWVtX2JpZGlfbGlzdCkpICYmCisJICAgIChUUkFOU1BPUlQoZGV2KS0+dHJhbnNwb3J0X3R5cGUgPT0gVFJBTlNQT1JUX1BMVUdJTl9QSEJBX1BERVYpKQorCQlzZV9tZW1fYmlkaSA9IGxpc3RfZW50cnkoVF9UQVNLKGNtZCktPnRfbWVtX2JpZGlfbGlzdC0+bmV4dCwKKwkJCQkJc3RydWN0IHNlX21lbSwgc2VfbGlzdCk7CisKKwl3aGlsZSAoc2VjdG9ycykgeworCQlERUJVR19WT0woIklUVFsweCUwOHhdIExCQSglbGx1KSBTZWN0b3JzTGVmdCgldSkgRU9CSiglbGx1KVxuIiwKKwkJCUNNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCksIGxiYSwgc2VjdG9ycywKKwkJCXRyYW5zcG9ydF9kZXZfZW5kX2xiYShkZXYpKTsKKworCQl0YXNrID0gdHJhbnNwb3J0X2dlbmVyaWNfZ2V0X3Rhc2soY21kLCBkYXRhX2RpcmVjdGlvbik7CisJCWlmICghKHRhc2spKQorCQkJZ290byBvdXQ7CisKKwkJdHJhbnNwb3J0X3NldF90YXNrc19zZWN0b3JzKHRhc2ssIGRldiwgbGJhLCBzZWN0b3JzLAorCQkJCSZtYXhfc2VjdG9yc19zZXQpOworCisJCXRhc2stPnRhc2tfbGJhID0gbGJhOworCQlsYmEgKz0gdGFzay0+dGFza19zZWN0b3JzOworCQlzZWN0b3JzIC09IHRhc2stPnRhc2tfc2VjdG9yczsKKwkJdGFzay0+dGFza19zaXplID0gKHRhc2stPnRhc2tfc2VjdG9ycyAqCisJCQkJICAgREVWX0FUVFJJQihkZXYpLT5ibG9ja19zaXplKTsKKworCQljZGIgPSBUUkFOU1BPUlQoZGV2KS0+Z2V0X2NkYih0YXNrKTsKKwkJaWYgKChjZGIpKSB7CisJCQltZW1jcHkoY2RiLCBUX1RBU0soY21kKS0+dF90YXNrX2NkYiwKKwkJCQlzY3NpX2NvbW1hbmRfc2l6ZShUX1RBU0soY21kKS0+dF90YXNrX2NkYikpOworCQkJY21kLT50cmFuc3BvcnRfc3BsaXRfY2RiKHRhc2stPnRhc2tfbGJhLAorCQkJCQkmdGFzay0+dGFza19zZWN0b3JzLCBjZGIpOworCQl9CisKKwkJLyoKKwkJICogUGVyZm9ybSB0aGUgU0UgT0JKIHBsdWdpbiBhbmQvb3IgVHJhbnNwb3J0IHBsdWdpbiBzcGVjaWZpYworCQkgKiBtYXBwaW5nIGZvciBUX1RBU0soY21kKS0+dF9tZW1fbGlzdC4gQW5kIHNldHVwIHRoZQorCQkgKiB0YXNrLT50YXNrX3NnIGFuZCBpZiBuZWNlc3NhcnkgdGFzay0+dGFza19zZ19iaWRpCisJCSAqLworCQlyZXQgPSB0cmFuc3BvcnRfZG9fc2VfbWVtX21hcChkZXYsIHRhc2ssIG1lbV9saXN0LAorCQkJCU5VTEwsIHNlX21lbSwgJnNlX21lbV9sb3V0LCAmc2VfbWVtX2NudCwKKwkJCQkmdGFza19vZmZzZXRfaW4pOworCQlpZiAocmV0IDwgMCkKKwkJCWdvdG8gb3V0OworCisJCXNlX21lbSA9IHNlX21lbV9sb3V0OworCQkvKgorCQkgKiBTZXR1cCB0aGUgVF9UQVNLKGNtZCktPnRfbWVtX2JpZGlfbGlzdCAtPiB0YXNrLT50YXNrX3NnX2JpZGkKKwkJICogbWFwcGluZyBmb3IgU0NTSSBSRUFEIGZvciBCSURJLUNPTU1BTkQgcGFzc3Rocm91Z2ggd2l0aCBUQ00vcFNDU0kKKwkJICoKKwkJICogTm90ZSB0aGF0IHRoZSBmaXJzdCBjYWxsIHRvIHRyYW5zcG9ydF9kb19zZV9tZW1fbWFwKCkgYWJvdmUgd2lsbAorCQkgKiBhbGxvY2F0ZSBzdHJ1Y3Qgc2VfdGFzay0+dGFza19zZ19iaWRpIGluIHRyYW5zcG9ydF9kb19zZV9tZW1fbWFwKCkKKwkJICogLT4gdHJhbnNwb3J0X2NhbGNfc2dfbnVtKCksIGFuZCB0aGUgc2Vjb25kIGhlcmUgd2lsbCBkbyB0aGUKKwkJICogbWFwcGluZyBmb3IgU0NTSSBSRUFEIGZvciBCSURJLUNPTU1BTkQgcGFzc3Rocm91Z2ggd2l0aCBUQ00vcFNDU0kuCisJCSAqLworCQlpZiAodGFzay0+dGFza19zZ19iaWRpICE9IE5VTEwpIHsKKwkJCXJldCA9IHRyYW5zcG9ydF9kb19zZV9tZW1fbWFwKGRldiwgdGFzaywKKwkJCQlUX1RBU0soY21kKS0+dF9tZW1fYmlkaV9saXN0LCBOVUxMLAorCQkJCXNlX21lbV9iaWRpLCAmc2VfbWVtX2JpZGlfbG91dCwgJnNlX21lbV9iaWRpX2NudCwKKwkJCQkmdGFza19vZmZzZXRfaW4pOworCQkJaWYgKHJldCA8IDApCisJCQkJZ290byBvdXQ7CisKKwkJCXNlX21lbV9iaWRpID0gc2VfbWVtX2JpZGlfbG91dDsKKwkJfQorCQl0YXNrX2NkYnMrKzsKKworCQlERUJVR19WT0woIkluY3JlbWVudGVkIHRhc2tfY2RicygldSkgdGFzay0+dGFza19zZ19udW0oJXUpXG4iLAorCQkJCXRhc2tfY2RicywgdGFzay0+dGFza19zZ19udW0pOworCisJCWlmIChtYXhfc2VjdG9yc19zZXQpIHsKKwkJCW1heF9zZWN0b3JzX3NldCA9IDA7CisJCQljb250aW51ZTsKKwkJfQorCisJCWlmICghc2VjdG9ycykKKwkJCWJyZWFrOworCX0KKworCWlmIChzZXRfY291bnRzKSB7CisJCWF0b21pY19pbmMoJlRfVEFTSyhjbWQpLT50X2ZlX2NvdW50KTsKKwkJYXRvbWljX2luYygmVF9UQVNLKGNtZCktPnRfc2VfY291bnQpOworCX0KKworCURFQlVHX1ZPTCgiSVRUWzB4JTA4eF0gdG90YWwgJXMgY2RicygldSlcbiIsCisJCUNNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCksIChkYXRhX2RpcmVjdGlvbiA9PSBETUFfVE9fREVWSUNFKQorCQk/ICJETUFfVE9fREVWSUNFIiA6ICJETUFfRlJPTV9ERVZJQ0UiLCB0YXNrX2NkYnMpOworCisJcmV0dXJuIHRhc2tfY2RiczsKK291dDoKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludAordHJhbnNwb3J0X21hcF9jb250cm9sX2NtZF90b190YXNrKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKwl1bnNpZ25lZCBjaGFyICpjZGI7CisJc3RydWN0IHNlX3Rhc2sgKnRhc2s7CisJaW50IHJldDsKKworCXRhc2sgPSB0cmFuc3BvcnRfZ2VuZXJpY19nZXRfdGFzayhjbWQsIGNtZC0+ZGF0YV9kaXJlY3Rpb24pOworCWlmICghdGFzaykKKwkJcmV0dXJuIFBZWF9UUkFOU1BPUlRfT1VUX09GX01FTU9SWV9SRVNPVVJDRVM7CisKKwljZGIgPSBUUkFOU1BPUlQoZGV2KS0+Z2V0X2NkYih0YXNrKTsKKwlpZiAoY2RiKQorCQltZW1jcHkoY2RiLCBjbWQtPnRfdGFzay0+dF90YXNrX2NkYiwKKwkJCXNjc2lfY29tbWFuZF9zaXplKGNtZC0+dF90YXNrLT50X3Rhc2tfY2RiKSk7CisKKwl0YXNrLT50YXNrX3NpemUgPSBjbWQtPmRhdGFfbGVuZ3RoOworCXRhc2stPnRhc2tfc2dfbnVtID0KKwkJKGNtZC0+c2VfY21kX2ZsYWdzICYgU0NGX1NDU0lfQ09OVFJPTF9TR19JT19DREIpID8gMSA6IDA7CisKKwlhdG9taWNfaW5jKCZjbWQtPnRfdGFzay0+dF9mZV9jb3VudCk7CisJYXRvbWljX2luYygmY21kLT50X3Rhc2stPnRfc2VfY291bnQpOworCisJaWYgKGNtZC0+c2VfY21kX2ZsYWdzICYgU0NGX1NDU0lfQ09OVFJPTF9TR19JT19DREIpIHsKKwkJc3RydWN0IHNlX21lbSAqc2VfbWVtID0gTlVMTCwgKnNlX21lbV9sb3V0ID0gTlVMTDsKKwkJdTMyIHNlX21lbV9jbnQgPSAwLCB0YXNrX29mZnNldCA9IDA7CisKKwkJQlVHX09OKGxpc3RfZW1wdHkoY21kLT50X3Rhc2stPnRfbWVtX2xpc3QpKTsKKworCQlyZXQgPSB0cmFuc3BvcnRfZG9fc2VfbWVtX21hcChkZXYsIHRhc2ssCisJCQkJY21kLT50X3Rhc2stPnRfbWVtX2xpc3QsIE5VTEwsIHNlX21lbSwKKwkJCQkmc2VfbWVtX2xvdXQsICZzZV9tZW1fY250LCAmdGFza19vZmZzZXQpOworCQlpZiAocmV0IDwgMCkKKwkJCXJldHVybiBQWVhfVFJBTlNQT1JUX09VVF9PRl9NRU1PUllfUkVTT1VSQ0VTOworCisJCWlmIChkZXYtPnRyYW5zcG9ydC0+bWFwX3Rhc2tfU0cpCisJCQlyZXR1cm4gZGV2LT50cmFuc3BvcnQtPm1hcF90YXNrX1NHKHRhc2spOworCQlyZXR1cm4gMDsKKwl9IGVsc2UgaWYgKGNtZC0+c2VfY21kX2ZsYWdzICYgU0NGX1NDU0lfQ09OVFJPTF9OT05TR19JT19DREIpIHsKKwkJaWYgKGRldi0+dHJhbnNwb3J0LT5tYXBfdGFza19ub25fU0cpCisJCQlyZXR1cm4gZGV2LT50cmFuc3BvcnQtPm1hcF90YXNrX25vbl9TRyh0YXNrKTsKKwkJcmV0dXJuIDA7CisJfSBlbHNlIGlmIChjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9TQ1NJX05PTl9EQVRBX0NEQikgeworCQlpZiAoZGV2LT50cmFuc3BvcnQtPmNkYl9ub25lKQorCQkJcmV0dXJuIGRldi0+dHJhbnNwb3J0LT5jZGJfbm9uZSh0YXNrKTsKKwkJcmV0dXJuIDA7CisJfSBlbHNlIHsKKwkJQlVHKCk7CisJCXJldHVybiBQWVhfVFJBTlNQT1JUX09VVF9PRl9NRU1PUllfUkVTT1VSQ0VTOworCX0KK30KKworLyoJIHRyYW5zcG9ydF9nZW5lcmljX25ld19jbWQoKTogQ2FsbGVkIGZyb20gdHJhbnNwb3J0X3Byb2Nlc3NpbmdfdGhyZWFkKCkKKyAqCisgKgkgQWxsb2NhdGUgc3RvcmFnZSB0cmFuc3BvcnQgcmVzb3VyY2VzIGZyb20gYSBzZXQgb2YgdmFsdWVzIHByZWRlZmluZWQKKyAqCSBieSB0cmFuc3BvcnRfZ2VuZXJpY19jbWRfc2VxdWVuY2VyKCkgZnJvbSB0aGUgaVNDU0kgVGFyZ2V0IFJYIHByb2Nlc3MuCisgKgkgQW55IG5vbiB6ZXJvIHJldHVybiBoZXJlIGlzIHRyZWF0ZWQgYXMgYW4gIm91dCBvZiByZXNvdXJjZScgb3AgaGVyZS4KKyAqLworCS8qCisJICogR2VuZXJhdGUgc3RydWN0IHNlX3Rhc2socykgYW5kL29yIHRoZWlyIHBheWxvYWRzIGZvciB0aGlzIENEQi4KKwkgKi8KK3N0YXRpYyBpbnQgdHJhbnNwb3J0X2dlbmVyaWNfbmV3X2NtZChzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnOworCXN0cnVjdCBzZV90YXNrICp0YXNrOworCXN0cnVjdCBzZV9kZXZpY2UgKmRldiA9IFNFX0RFVihjbWQpOworCWludCByZXQgPSAwOworCisJLyoKKwkgKiBEZXRlcm1pbmUgaXMgdGhlIFRDTSBmYWJyaWMgbW9kdWxlIGhhcyBhbHJlYWR5IGFsbG9jYXRlZCBwaHlzaWNhbAorCSAqIG1lbW9yeSwgYW5kIGlzIGRpcmVjdGx5IGNhbGxpbmcgdHJhbnNwb3J0X2dlbmVyaWNfbWFwX21lbV90b19jbWQoKQorCSAqIHRvIHNldHVwIGJlZm9yZWhhbmQgdGhlIGxpbmtlZCBsaXN0IG9mIHBoeXNpY2FsIG1lbW9yeSBhdAorCSAqIFRfVEFTSyhjbWQpLT50X21lbV9saXN0IG9mIHN0cnVjdCBzZV9tZW0tPnNlX3BhZ2UKKwkgKi8KKwlpZiAoIShjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9QQVNTVEhST1VHSF9TR19UT19NRU1fTk9BTExPQykpIHsKKwkJcmV0ID0gdHJhbnNwb3J0X2FsbG9jYXRlX3Jlc291cmNlcyhjbWQpOworCQlpZiAocmV0IDwgMCkKKwkJCXJldHVybiByZXQ7CisJfQorCisJcmV0ID0gdHJhbnNwb3J0X2dldF9zZWN0b3JzKGNtZCk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlyZXQgPSB0cmFuc3BvcnRfbmV3X2NtZF9vYmooY21kKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCS8qCisJICogRGV0ZXJtaW5lIGlmIHRoZSBjYWxsaW5nIFRDTSBmYWJyaWMgbW9kdWxlIGlzIHRhbGtpbmcgdG8KKwkgKiBMaW51eC9ORVQgdmlhIGtlcm5lbCBzb2NrZXRzIGFuZCBuZWVkcyB0byBhbGxvY2F0ZSBhCisJICogc3RydWN0IGlvdmVjIGFycmF5IHRvIGNvbXBsZXRlIHRoZSBzdHJ1Y3Qgc2VfY21kCisJICovCisJc2VfdHBnID0gU0VfTFVOKGNtZCktPmx1bl9zZXAtPnNlcF90cGc7CisJaWYgKFRQR19URk8oc2VfdHBnKS0+YWxsb2NfY21kX2lvdmVjcyAhPSBOVUxMKSB7CisJCXJldCA9IFRQR19URk8oc2VfdHBnKS0+YWxsb2NfY21kX2lvdmVjcyhjbWQpOworCQlpZiAocmV0IDwgMCkKKwkJCXJldHVybiBQWVhfVFJBTlNQT1JUX09VVF9PRl9NRU1PUllfUkVTT1VSQ0VTOworCX0KKworCWlmIChjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9TQ1NJX0RBVEFfU0dfSU9fQ0RCKSB7CisJCWxpc3RfZm9yX2VhY2hfZW50cnkodGFzaywgJlRfVEFTSyhjbWQpLT50X3Rhc2tfbGlzdCwgdF9saXN0KSB7CisJCQlpZiAoYXRvbWljX3JlYWQoJnRhc2stPnRhc2tfc2VudCkpCisJCQkJY29udGludWU7CisJCQlpZiAoIWRldi0+dHJhbnNwb3J0LT5tYXBfdGFza19TRykKKwkJCQljb250aW51ZTsKKworCQkJcmV0ID0gZGV2LT50cmFuc3BvcnQtPm1hcF90YXNrX1NHKHRhc2spOworCQkJaWYgKHJldCA8IDApCisJCQkJcmV0dXJuIHJldDsKKwkJfQorCX0gZWxzZSB7CisJCXJldCA9IHRyYW5zcG9ydF9tYXBfY29udHJvbF9jbWRfdG9fdGFzayhjbWQpOworCQlpZiAocmV0IDwgMCkKKwkJCXJldHVybiByZXQ7CisJfQorCisJLyoKKwkgKiBGb3IgV1JJVEVzLCBsZXQgdGhlIGlTQ1NJIFRhcmdldCBSWCBUaHJlYWQga25vdyBpdHMgYnVmZmVyIGlzIHJlYWR5Li4KKwkgKiBUaGlzIFdSSVRFIHN0cnVjdCBzZV9jbWQgKGFuZCBhbGwgb2YgaXRzIGFzc29jaWF0ZWQgc3RydWN0IHNlX3Rhc2sncykKKwkgKiB3aWxsIGJlIGFkZGVkIHRvIHRoZSBzdHJ1Y3Qgc2VfZGV2aWNlIGV4ZWN1dGlvbiBxdWV1ZSBhZnRlciBpdHMgV1JJVEUKKwkgKiBkYXRhIGhhcyBhcnJpdmVkLiAoaWU6IEl0IGdldHMgaGFuZGxlZCBieSB0aGUgdHJhbnNwb3J0IHByb2Nlc3NpbmcKKwkgKiB0aHJlYWQgYSBzZWNvbmQgdGltZSkKKwkgKi8KKwlpZiAoY21kLT5kYXRhX2RpcmVjdGlvbiA9PSBETUFfVE9fREVWSUNFKSB7CisJCXRyYW5zcG9ydF9hZGRfdGFza3NfdG9fc3RhdGVfcXVldWUoY21kKTsKKwkJcmV0dXJuIHRyYW5zcG9ydF9nZW5lcmljX3dyaXRlX3BlbmRpbmcoY21kKTsKKwl9CisJLyoKKwkgKiBFdmVyeXRoaW5nIGVsc2UgYnV0IGEgV1JJVEUsIGFkZCB0aGUgc3RydWN0IHNlX2NtZCdzIHN0cnVjdCBzZV90YXNrJ3MKKwkgKiB0byB0aGUgZXhlY3V0aW9uIHF1ZXVlLgorCSAqLworCXRyYW5zcG9ydF9leGVjdXRlX3Rhc2tzKGNtZCk7CisJcmV0dXJuIDA7Cit9CisKKy8qCXRyYW5zcG9ydF9nZW5lcmljX3Byb2Nlc3Nfd3JpdGUoKToKKyAqCisgKgorICovCit2b2lkIHRyYW5zcG9ydF9nZW5lcmljX3Byb2Nlc3Nfd3JpdGUoc3RydWN0IHNlX2NtZCAqY21kKQoreworI2lmIDAKKwkvKgorCSAqIENvcHkgU0NTSSBQcmVzZW50ZWQgRFRMIHNlY3RvcihzKSBmcm9tIHJlY2VpdmVkIGJ1ZmZlcnMgYWxsb2NhdGVkIHRvCisJICogb3JpZ2luYWwgRURUTAorCSAqLworCWlmIChjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9VTkRFUkZMT1dfQklUKSB7CisJCWlmICghVF9UQVNLKGNtZCktPnRfdGFza3Nfc2VfbnVtKSB7CisJCQl1bnNpZ25lZCBjaGFyICpkc3QsICpidWYgPQorCQkJCSh1bnNpZ25lZCBjaGFyICopVF9UQVNLKGNtZCktPnRfdGFza19idWY7CisKKwkJCWRzdCA9IGt6YWxsb2MoY21kLT5jbWRfc3BkdGwpLCBHRlBfS0VSTkVMKTsKKwkJCWlmICghKGRzdCkpIHsKKwkJCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIgorCQkJCQkJIiBXUklURSB1bmRlcmZsb3dcbiIpOworCQkJCXRyYW5zcG9ydF9nZW5lcmljX3JlcXVlc3RfZmFpbHVyZShjbWQsIE5VTEwsCisJCQkJCVBZWF9UUkFOU1BPUlRfUkVRX1RPT19NQU5ZX1NFQ1RPUlMsIDEpOworCQkJCXJldHVybjsKKwkJCX0KKwkJCW1lbWNweShkc3QsIGJ1ZiwgY21kLT5jbWRfc3BkdGwpOworCisJCQlrZnJlZShUX1RBU0soY21kKS0+dF90YXNrX2J1Zik7CisJCQlUX1RBU0soY21kKS0+dF90YXNrX2J1ZiA9IGRzdDsKKwkJfSBlbHNlIHsKKwkJCXN0cnVjdCBzY2F0dGVybGlzdCAqc2cgPQorCQkJCShzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnKVRfVEFTSyhjbWQpLT50X3Rhc2tfYnVmOworCQkJc3RydWN0IHNjYXR0ZXJsaXN0ICpvcmlnX3NnOworCisJCQlvcmlnX3NnID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHNjYXR0ZXJsaXN0KSAqCisJCQkJCVRfVEFTSyhjbWQpLT50X3Rhc2tzX3NlX251bSwKKwkJCQkJR0ZQX0tFUk5FTCkpKSB7CisJCQlpZiAoIShvcmlnX3NnKSkgeworCQkJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIGFsbG9jYXRlIG1lbW9yeSIKKwkJCQkJCSIgZm9yIFdSSVRFIHVuZGVyZmxvd1xuIik7CisJCQkJdHJhbnNwb3J0X2dlbmVyaWNfcmVxdWVzdF9mYWlsdXJlKGNtZCwgTlVMTCwKKwkJCQkJUFlYX1RSQU5TUE9SVF9SRVFfVE9PX01BTllfU0VDVE9SUywgMSk7CisJCQkJcmV0dXJuOworCQkJfQorCisJCQltZW1jcHkob3JpZ19zZywgVF9UQVNLKGNtZCktPnRfdGFza19idWYsCisJCQkJCXNpemVvZihzdHJ1Y3Qgc2NhdHRlcmxpc3QpICoKKwkJCQkJVF9UQVNLKGNtZCktPnRfdGFza3Nfc2VfbnVtKTsKKworCQkJY21kLT5kYXRhX2xlbmd0aCA9IGNtZC0+Y21kX3NwZHRsOworCQkJLyoKKwkJCSAqIEZJWE1FLCBjbGVhciBvdXQgb3JpZ2luYWwgc3RydWN0IHNlX3Rhc2sgYW5kIHN0YXRlCisJCQkgKiBpbmZvcm1hdGlvbi4KKwkJCSAqLworCQkJaWYgKHRyYW5zcG9ydF9nZW5lcmljX25ld19jbWQoY21kKSA8IDApIHsKKwkJCQl0cmFuc3BvcnRfZ2VuZXJpY19yZXF1ZXN0X2ZhaWx1cmUoY21kLCBOVUxMLAorCQkJCQlQWVhfVFJBTlNQT1JUX1JFUV9UT09fTUFOWV9TRUNUT1JTLCAxKTsKKwkJCQlrZnJlZShvcmlnX3NnKTsKKwkJCQlyZXR1cm47CisJCQl9CisKKwkJCXRyYW5zcG9ydF9tZW1jcHlfd3JpdGVfc2coY21kLCBvcmlnX3NnKTsKKwkJfQorCX0KKyNlbmRpZgorCXRyYW5zcG9ydF9leGVjdXRlX3Rhc2tzKGNtZCk7Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9nZW5lcmljX3Byb2Nlc3Nfd3JpdGUpOworCisvKgl0cmFuc3BvcnRfZ2VuZXJpY193cml0ZV9wZW5kaW5nKCk6CisgKgorICoKKyAqLworc3RhdGljIGludCB0cmFuc3BvcnRfZ2VuZXJpY193cml0ZV9wZW5kaW5nKHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCByZXQ7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCWNtZC0+dF9zdGF0ZSA9IFRSQU5TUE9SVF9XUklURV9QRU5ESU5HOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwkvKgorCSAqIEZvciB0aGUgVENNIGNvbnRyb2wgQ0RCcyB1c2luZyBhIGNvbnRpZ3VvdXMgYnVmZmVyLCBkbyB0aGUgbWVtY3B5CisJICogZnJvbSB0aGUgcGFzc2VkIExpbnV4L1NDU0kgc3RydWN0IHNjYXR0ZXJsaXN0IGxvY2F0ZWQgYXQKKwkgKiBUX1RBU0soc2VfY21kKS0+dF90YXNrX3B0X2J1ZiB0byB0aGUgY29udGlndW91cyBidWZmZXIgYXQKKwkgKiBUX1RBU0soc2VfY21kKS0+dF90YXNrX2J1Zi4KKwkgKi8KKwlpZiAoY21kLT5zZV9jbWRfZmxhZ3MgJiBTQ0ZfUEFTU1RIUk9VR0hfQ09OVElHX1RPX1NHKQorCQl0cmFuc3BvcnRfbWVtY3B5X3JlYWRfY29udGlnKGNtZCwKKwkJCQlUX1RBU0soY21kKS0+dF90YXNrX2J1ZiwKKwkJCQlUX1RBU0soY21kKS0+dF90YXNrX3B0X3NnbCk7CisJLyoKKwkgKiBDbGVhciB0aGUgc2VfY21kIGZvciBXUklURV9QRU5ESU5HIHN0YXR1cyBpbiBvcmRlciB0byBzZXQKKwkgKiBUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfYWN0aXZlPTAgc28gdGhhdCB0cmFuc3BvcnRfZ2VuZXJpY19oYW5kbGVfZGF0YQorCSAqIGNhbiBiZSBjYWxsZWQgZnJvbSBIVyB0YXJnZXQgbW9kZSBpbnRlcnJ1cHQgY29kZS4gIFRoaXMgaXMgc2FmZQorCSAqIHRvIGJlIGNhbGxlZCB3aXRoIHRyYW5zcG9ydF9vZmY9MSBiZWZvcmUgdGhlIENNRF9URk8oY21kKS0+d3JpdGVfcGVuZGluZworCSAqIGJlY2F1c2UgdGhlIHNlX2NtZC0+c2VfbHVuIHBvaW50ZXIgaXMgbm90IGJlaW5nIGNsZWFyZWQuCisJICovCisJdHJhbnNwb3J0X2NtZF9jaGVja19zdG9wKGNtZCwgMSwgMCk7CisKKwkvKgorCSAqIENhbGwgdGhlIGZhYnJpYyB3cml0ZV9wZW5kaW5nIGZ1bmN0aW9uIGhlcmUgdG8gbGV0IHRoZQorCSAqIGZyb250ZW5kIGtub3cgdGhhdCBXUklURSBidWZmZXJzIGFyZSByZWFkeS4KKwkgKi8KKwlyZXQgPSBDTURfVEZPKGNtZCktPndyaXRlX3BlbmRpbmcoY21kKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCXJldHVybiBQWVhfVFJBTlNQT1JUX1dSSVRFX1BFTkRJTkc7Cit9CisKKy8qCXRyYW5zcG9ydF9yZWxlYXNlX2NtZF90b19wb29sKCk6CisgKgorICoKKyAqLwordm9pZCB0cmFuc3BvcnRfcmVsZWFzZV9jbWRfdG9fcG9vbChzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJQlVHX09OKCFUX1RBU0soY21kKSk7CisJQlVHX09OKCFDTURfVEZPKGNtZCkpOworCisJdHJhbnNwb3J0X2ZyZWVfc2VfY21kKGNtZCk7CisJQ01EX1RGTyhjbWQpLT5yZWxlYXNlX2NtZF90b19wb29sKGNtZCk7Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9yZWxlYXNlX2NtZF90b19wb29sKTsKKworLyoJdHJhbnNwb3J0X2dlbmVyaWNfZnJlZV9jbWQoKToKKyAqCisgKglDYWxsZWQgZnJvbSBwcm9jZXNzaW5nIGZyb250ZW5kIHRvIHJlbGVhc2Ugc3RvcmFnZSBlbmdpbmUgcmVzb3VyY2VzCisgKi8KK3ZvaWQgdHJhbnNwb3J0X2dlbmVyaWNfZnJlZV9jbWQoCisJc3RydWN0IHNlX2NtZCAqY21kLAorCWludCB3YWl0X2Zvcl90YXNrcywKKwlpbnQgcmVsZWFzZV90b19wb29sLAorCWludCBzZXNzaW9uX3JlaW5zdGF0ZW1lbnQpCit7CisJaWYgKCEoY21kLT5zZV9jbWRfZmxhZ3MgJiBTQ0ZfU0VfTFVOX0NNRCkgfHwgIVRfVEFTSyhjbWQpKQorCQl0cmFuc3BvcnRfcmVsZWFzZV9jbWRfdG9fcG9vbChjbWQpOworCWVsc2UgeworCQljb3JlX2RlY19sYWNsX2NvdW50KGNtZC0+c2Vfc2Vzcy0+c2Vfbm9kZV9hY2wsIGNtZCk7CisKKwkJaWYgKFNFX0xVTihjbWQpKSB7CisjaWYgMAorCQkJcHJpbnRrKEtFUk5fSU5GTyAiY21kOiAlcCBJVFQ6IDB4JTA4eCBjb250YWlucyIKKwkJCQkiIFNFX0xVTihjbWQpXG4iLCBjbWQsCisJCQkJQ01EX1RGTyhjbWQpLT5nZXRfdGFza190YWcoY21kKSk7CisjZW5kaWYKKwkJCXRyYW5zcG9ydF9sdW5fcmVtb3ZlX2NtZChjbWQpOworCQl9CisKKwkJaWYgKHdhaXRfZm9yX3Rhc2tzICYmIGNtZC0+dHJhbnNwb3J0X3dhaXRfZm9yX3Rhc2tzKQorCQkJY21kLT50cmFuc3BvcnRfd2FpdF9mb3JfdGFza3MoY21kLCAwLCAwKTsKKworCQl0cmFuc3BvcnRfZ2VuZXJpY19yZW1vdmUoY21kLCByZWxlYXNlX3RvX3Bvb2wsCisJCQkJc2Vzc2lvbl9yZWluc3RhdGVtZW50KTsKKwl9Cit9CitFWFBPUlRfU1lNQk9MKHRyYW5zcG9ydF9nZW5lcmljX2ZyZWVfY21kKTsKKworc3RhdGljIHZvaWQgdHJhbnNwb3J0X25vcF93YWl0X2Zvcl90YXNrcygKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJaW50IHJlbW92ZV9jbWQsCisJaW50IHNlc3Npb25fcmVpbnN0YXRlbWVudCkKK3sKKwlyZXR1cm47Cit9CisKKy8qCXRyYW5zcG9ydF9sdW5fd2FpdF9mb3JfdGFza3MoKToKKyAqCisgKglDYWxsZWQgZnJvbSBDb25maWdGUyBjb250ZXh0IHRvIHN0b3AgdGhlIHBhc3NlZCBzdHJ1Y3Qgc2VfY21kIHRvIGFsbG93CisgKglhbiBzdHJ1Y3Qgc2VfbHVuIHRvIGJlIHN1Y2Nlc3NmdWxseSBzaHV0ZG93bi4KKyAqLworc3RhdGljIGludCB0cmFuc3BvcnRfbHVuX3dhaXRfZm9yX3Rhc2tzKHN0cnVjdCBzZV9jbWQgKmNtZCwgc3RydWN0IHNlX2x1biAqbHVuKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJaW50IHJldDsKKwkvKgorCSAqIElmIHRoZSBmcm9udGVuZCBoYXMgYWxyZWFkeSByZXF1ZXN0ZWQgdGhpcyBzdHJ1Y3Qgc2VfY21kIHRvCisJICogYmUgc3RvcHBlZCwgd2UgY2FuIHNhZmVseSBpZ25vcmUgdGhpcyBzdHJ1Y3Qgc2VfY21kLgorCSAqLworCXNwaW5fbG9ja19pcnFzYXZlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJaWYgKGF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfc3RvcCkpIHsKKwkJYXRvbWljX3NldCgmVF9UQVNLKGNtZCktPnRyYW5zcG9ydF9sdW5fc3RvcCwgMCk7CisJCURFQlVHX1RSQU5TUE9SVF9TKCJDb25maWdGUyBJVFRbMHglMDh4XSAtIHRfdHJhbnNwb3J0X3N0b3AgPT0iCisJCQkiIFRSVUUsIHNraXBwaW5nXG4iLCBDTURfVEZPKGNtZCktPmdldF90YXNrX3RhZyhjbWQpKTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCQl0cmFuc3BvcnRfY21kX2NoZWNrX3N0b3AoY21kLCAxLCAwKTsKKwkJcmV0dXJuIC0xOworCX0KKwlhdG9taWNfc2V0KCZUX1RBU0soY21kKS0+dHJhbnNwb3J0X2x1bl9mZV9zdG9wLCAxKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisKKwl3YWtlX3VwX2ludGVycnVwdGlibGUoJlNFX0RFVihjbWQpLT5kZXZfcXVldWVfb2JqLT50aHJlYWRfd3EpOworCisJcmV0ID0gdHJhbnNwb3J0X3N0b3BfdGFza3NfZm9yX2NtZChjbWQpOworCisJREVCVUdfVFJBTlNQT1JUX1MoIkNvbmZpZ0ZTOiBjbWQ6ICVwIHRfdGFza19jZGJzOiAlZCBzdG9wIHRhc2tzIHJldDoiCisJCQkiICVkXG4iLCBjbWQsIFRfVEFTSyhjbWQpLT50X3Rhc2tfY2RicywgcmV0KTsKKwlpZiAoIXJldCkgeworCQlERUJVR19UUkFOU1BPUlRfUygiQ29uZmlnRlM6IElUVFsweCUwOHhdIC0gc3RvcHBpbmcgY21kLi4uLlxuIiwKKwkJCQlDTURfVEZPKGNtZCktPmdldF90YXNrX3RhZyhjbWQpKTsKKwkJd2FpdF9mb3JfY29tcGxldGlvbigmVF9UQVNLKGNtZCktPnRyYW5zcG9ydF9sdW5fc3RvcF9jb21wKTsKKwkJREVCVUdfVFJBTlNQT1JUX1MoIkNvbmZpZ0ZTOiBJVFRbMHglMDh4XSAtIHN0b3BwZWQgY21kLi4uLlxuIiwKKwkJCQlDTURfVEZPKGNtZCktPmdldF90YXNrX3RhZyhjbWQpKTsKKwl9CisJdHJhbnNwb3J0X3JlbW92ZV9jbWRfZnJvbV9xdWV1ZShjbWQsIFNFX0RFVihjbWQpLT5kZXZfcXVldWVfb2JqKTsKKworCXJldHVybiAwOworfQorCisvKiAjZGVmaW5lIERFQlVHX0NMRUFSX0xVTiAqLworI2lmZGVmIERFQlVHX0NMRUFSX0xVTgorI2RlZmluZSBERUJVR19DTEVBUl9MKHguLi4pIHByaW50ayhLRVJOX0lORk8geCkKKyNlbHNlCisjZGVmaW5lIERFQlVHX0NMRUFSX0woeC4uLikKKyNlbmRpZgorCitzdGF0aWMgdm9pZCBfX3RyYW5zcG9ydF9jbGVhcl9sdW5fZnJvbV9zZXNzaW9ucyhzdHJ1Y3Qgc2VfbHVuICpsdW4pCit7CisJc3RydWN0IHNlX2NtZCAqY21kID0gTlVMTDsKKwl1bnNpZ25lZCBsb25nIGx1bl9mbGFncywgY21kX2ZsYWdzOworCS8qCisJICogRG8gZXhjZXB0aW9uIHByb2Nlc3NpbmcgYW5kIHJldHVybiBDSEVDS19DT05ESVRJT04gc3RhdHVzIHRvIHRoZQorCSAqIEluaXRpYXRvciBQb3J0LgorCSAqLworCXNwaW5fbG9ja19pcnFzYXZlKCZsdW4tPmx1bl9jbWRfbG9jaywgbHVuX2ZsYWdzKTsKKwl3aGlsZSAoIWxpc3RfZW1wdHlfY2FyZWZ1bCgmbHVuLT5sdW5fY21kX2xpc3QpKSB7CisJCWNtZCA9IGxpc3RfZW50cnkobHVuLT5sdW5fY21kX2xpc3QubmV4dCwKKwkJCXN0cnVjdCBzZV9jbWQsIHNlX2x1bl9saXN0KTsKKwkJbGlzdF9kZWwoJmNtZC0+c2VfbHVuX2xpc3QpOworCisJCWlmICghKFRfVEFTSyhjbWQpKSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJJVFQ6IDB4JTA4eCwgVF9UQVNLKGNtZCkgPSBOVUxMIgorCQkJCSJbaSx0XV9zdGF0ZTogJXUvJXVcbiIsCisJCQkJQ01EX1RGTyhjbWQpLT5nZXRfdGFza190YWcoY21kKSwKKwkJCQlDTURfVEZPKGNtZCktPmdldF9jbWRfc3RhdGUoY21kKSwgY21kLT50X3N0YXRlKTsKKwkJCUJVRygpOworCQl9CisJCWF0b21pY19zZXQoJlRfVEFTSyhjbWQpLT50cmFuc3BvcnRfbHVuX2FjdGl2ZSwgMCk7CisJCS8qCisJCSAqIFRoaXMgd2lsbCBub3RpZnkgaXNjc2lfdGFyZ2V0X3RyYW5zcG9ydC5jOgorCQkgKiB0cmFuc3BvcnRfY21kX2NoZWNrX3N0b3AoKSB0aGF0IGEgTFVOIHNodXRkb3duIGlzIGluCisJCSAqIHByb2dyZXNzIGZvciB0aGUgaXNjc2lfY21kX3QuCisJCSAqLworCQlzcGluX2xvY2soJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2spOworCQlERUJVR19DTEVBUl9MKCJTRV9MVU5bJWRdIC0gU2V0dGluZyBUX1RBU0soY21kKS0+dHJhbnNwb3J0IgorCQkJIl9sdW5fc3RvcCBmb3IgIElUVDogMHglMDh4XG4iLAorCQkJU0VfTFVOKGNtZCktPnVucGFja2VkX2x1biwKKwkJCUNNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCkpOworCQlhdG9taWNfc2V0KCZUX1RBU0soY21kKS0+dHJhbnNwb3J0X2x1bl9zdG9wLCAxKTsKKwkJc3Bpbl91bmxvY2soJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2spOworCisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmx1bi0+bHVuX2NtZF9sb2NrLCBsdW5fZmxhZ3MpOworCisJCWlmICghKFNFX0xVTihjbWQpKSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJJVFQ6IDB4JTA4eCwgW2ksdF1fc3RhdGU6ICV1LyV1XG4iLAorCQkJCUNNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCksCisJCQkJQ01EX1RGTyhjbWQpLT5nZXRfY21kX3N0YXRlKGNtZCksIGNtZC0+dF9zdGF0ZSk7CisJCQlCVUcoKTsKKwkJfQorCQkvKgorCQkgKiBJZiB0aGUgU3RvcmFnZSBlbmdpbmUgc3RpbGwgb3ducyB0aGUgaXNjc2lfY21kX3QsIGRldGVybWluZQorCQkgKiBhbmQvb3Igc3RvcCBpdHMgY29udGV4dC4KKwkJICovCisJCURFQlVHX0NMRUFSX0woIlNFX0xVTlslZF0gLSBJVFQ6IDB4JTA4eCBiZWZvcmUgdHJhbnNwb3J0IgorCQkJIl9sdW5fd2FpdF9mb3JfdGFza3MoKVxuIiwgU0VfTFVOKGNtZCktPnVucGFja2VkX2x1biwKKwkJCUNNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCkpOworCisJCWlmICh0cmFuc3BvcnRfbHVuX3dhaXRfZm9yX3Rhc2tzKGNtZCwgU0VfTFVOKGNtZCkpIDwgMCkgeworCQkJc3Bpbl9sb2NrX2lycXNhdmUoJmx1bi0+bHVuX2NtZF9sb2NrLCBsdW5fZmxhZ3MpOworCQkJY29udGludWU7CisJCX0KKworCQlERUJVR19DTEVBUl9MKCJTRV9MVU5bJWRdIC0gSVRUOiAweCUwOHggYWZ0ZXIgdHJhbnNwb3J0X2x1biIKKwkJCSJfd2FpdF9mb3JfdGFza3MoKTogU1VDQ0VTU1xuIiwKKwkJCVNFX0xVTihjbWQpLT51bnBhY2tlZF9sdW4sCisJCQlDTURfVEZPKGNtZCktPmdldF90YXNrX3RhZyhjbWQpKTsKKworCQlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgY21kX2ZsYWdzKTsKKwkJaWYgKCEoYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50cmFuc3BvcnRfZGV2X2FjdGl2ZSkpKSB7CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBjbWRfZmxhZ3MpOworCQkJZ290byBjaGVja19jb25kOworCQl9CisJCWF0b21pY19zZXQoJlRfVEFTSyhjbWQpLT50cmFuc3BvcnRfZGV2X2FjdGl2ZSwgMCk7CisJCXRyYW5zcG9ydF9hbGxfdGFza19kZXZfcmVtb3ZlX3N0YXRlKGNtZCk7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGNtZF9mbGFncyk7CisKKwkJdHJhbnNwb3J0X2ZyZWVfZGV2X3Rhc2tzKGNtZCk7CisJCS8qCisJCSAqIFRoZSBTdG9yYWdlIGVuZ2luZSBzdG9wcGVkIHRoaXMgc3RydWN0IHNlX2NtZCBiZWZvcmUgaXQgd2FzCisJCSAqIHNlbmQgdG8gdGhlIGZhYnJpYyBmcm9udGVuZCBmb3IgZGVsaXZlcnkgYmFjayB0byB0aGUKKwkJICogSW5pdGlhdG9yIE5vZGUuICBSZXR1cm4gdGhpcyBTQ1NJIENEQiBiYWNrIHdpdGggYW4KKwkJICogQ0hFQ0tfQ09ORElUSU9OIHN0YXR1cy4KKwkJICovCitjaGVja19jb25kOgorCQl0cmFuc3BvcnRfc2VuZF9jaGVja19jb25kaXRpb25fYW5kX3NlbnNlKGNtZCwKKwkJCQlUQ01fTk9OX0VYSVNURU5UX0xVTiwgMCk7CisJCS8qCisJCSAqICBJZiB0aGUgZmFicmljIGZyb250ZW5kIGlzIHdhaXRpbmcgZm9yIHRoaXMgaXNjc2lfY21kX3QgdG8KKwkJICogYmUgcmVsZWFzZWQsIG5vdGlmeSB0aGUgd2FpdGluZyB0aHJlYWQgbm93IHRoYXQgTFUgaGFzCisJCSAqIGZpbmlzaGVkIGFjY2Vzc2luZyBpdC4KKwkJICovCisJCXNwaW5fbG9ja19pcnFzYXZlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBjbWRfZmxhZ3MpOworCQlpZiAoYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50cmFuc3BvcnRfbHVuX2ZlX3N0b3ApKSB7CisJCQlERUJVR19DTEVBUl9MKCJTRV9MVU5bJWRdIC0gRGV0ZWN0ZWQgRkUgc3RvcCBmb3IiCisJCQkJIiBzdHJ1Y3Qgc2VfY21kOiAlcCBJVFQ6IDB4JTA4eFxuIiwKKwkJCQlsdW4tPnVucGFja2VkX2x1biwKKwkJCQljbWQsIENNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCkpOworCisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLAorCQkJCQljbWRfZmxhZ3MpOworCQkJdHJhbnNwb3J0X2NtZF9jaGVja19zdG9wKGNtZCwgMSwgMCk7CisJCQljb21wbGV0ZSgmVF9UQVNLKGNtZCktPnRyYW5zcG9ydF9sdW5fZmVfc3RvcF9jb21wKTsKKwkJCXNwaW5fbG9ja19pcnFzYXZlKCZsdW4tPmx1bl9jbWRfbG9jaywgbHVuX2ZsYWdzKTsKKwkJCWNvbnRpbnVlOworCQl9CisJCURFQlVHX0NMRUFSX0woIlNFX0xVTlslZF0gLSBJVFQ6IDB4JTA4eCBmaW5pc2hlZCBwcm9jZXNzaW5nXG4iLAorCQkJbHVuLT51bnBhY2tlZF9sdW4sIENNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCkpOworCisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGNtZF9mbGFncyk7CisJCXNwaW5fbG9ja19pcnFzYXZlKCZsdW4tPmx1bl9jbWRfbG9jaywgbHVuX2ZsYWdzKTsKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmbHVuLT5sdW5fY21kX2xvY2ssIGx1bl9mbGFncyk7Cit9CisKK3N0YXRpYyBpbnQgdHJhbnNwb3J0X2NsZWFyX2x1bl90aHJlYWQodm9pZCAqcCkKK3sKKwlzdHJ1Y3Qgc2VfbHVuICpsdW4gPSAoc3RydWN0IHNlX2x1biAqKXA7CisKKwlfX3RyYW5zcG9ydF9jbGVhcl9sdW5fZnJvbV9zZXNzaW9ucyhsdW4pOworCWNvbXBsZXRlKCZsdW4tPmx1bl9zaHV0ZG93bl9jb21wKTsKKworCXJldHVybiAwOworfQorCitpbnQgdHJhbnNwb3J0X2NsZWFyX2x1bl9mcm9tX3Nlc3Npb25zKHN0cnVjdCBzZV9sdW4gKmx1bikKK3sKKwlzdHJ1Y3QgdGFza19zdHJ1Y3QgKmt0OworCisJa3QgPSBrdGhyZWFkX3J1bih0cmFuc3BvcnRfY2xlYXJfbHVuX3RocmVhZCwgKHZvaWQgKilsdW4sCisJCQkidGNtX2NsXyV1IiwgbHVuLT51bnBhY2tlZF9sdW4pOworCWlmIChJU19FUlIoa3QpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIHN0YXJ0IGNsZWFyX2x1biB0aHJlYWRcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCXdhaXRfZm9yX2NvbXBsZXRpb24oJmx1bi0+bHVuX3NodXRkb3duX2NvbXApOworCisJcmV0dXJuIDA7Cit9CisKKy8qCXRyYW5zcG9ydF9nZW5lcmljX3dhaXRfZm9yX3Rhc2tzKCk6CisgKgorICoJQ2FsbGVkIGZyb20gZnJvbnRlbmQgb3IgcGFzc3Rocm91Z2ggY29udGV4dCB0byB3YWl0IGZvciBzdG9yYWdlIGVuZ2luZQorICoJdG8gcGF1c2UgYW5kL29yIHJlbGVhc2UgZnJvbnRlbmQgZ2VuZXJhdGVkIHN0cnVjdCBzZV9jbWQuCisgKi8KK3N0YXRpYyB2b2lkIHRyYW5zcG9ydF9nZW5lcmljX3dhaXRfZm9yX3Rhc2tzKAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwlpbnQgcmVtb3ZlX2NtZCwKKwlpbnQgc2Vzc2lvbl9yZWluc3RhdGVtZW50KQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlpZiAoIShjbWQtPnNlX2NtZF9mbGFncyAmIFNDRl9TRV9MVU5fQ01EKSAmJiAhKGNtZC0+c2VfdG1yX3JlcSkpCisJCXJldHVybjsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJLyoKKwkgKiBJZiB3ZSBhcmUgYWxyZWFkeSBzdG9wcGVkIGR1ZSB0byBhbiBleHRlcm5hbCBldmVudCAoaWU6IExVTiBzaHV0ZG93bikKKwkgKiBzbGVlcCB1bnRpbCB0aGUgY29ubmVjdGlvbiBjYW4gaGF2ZSB0aGUgcGFzc2VkIHN0cnVjdCBzZV9jbWQgYmFjay4KKwkgKiBUaGUgVF9UQVNLKGNtZCktPnRyYW5zcG9ydF9sdW5fc3RvcHBlZF9zZW0gd2lsbCBiZSB1cHBlZCBieQorCSAqIHRyYW5zcG9ydF9jbGVhcl9sdW5fZnJvbV9zZXNzaW9ucygpIG9uY2UgdGhlIENvbmZpZ0ZTIGNvbnRleHQgY2FsbGVyCisJICogaGFzIGNvbXBsZXRlZCBpdHMgb3BlcmF0aW9uIG9uIHRoZSBzdHJ1Y3Qgc2VfY21kLgorCSAqLworCWlmIChhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRyYW5zcG9ydF9sdW5fc3RvcCkpIHsKKworCQlERUJVR19UUkFOU1BPUlRfUygid2FpdF9mb3JfdGFza3M6IFN0b3BwaW5nIgorCQkJIiB3YWl0X2Zvcl9jb21wbGV0aW9uKCZUX1RBU0soY21kKXRyYW5zcG9ydF9sdW5fZmUiCisJCQkiX3N0b3BfY29tcCk7IGZvciBJVFQ6IDB4JTA4eFxuIiwKKwkJCUNNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCkpOworCQkvKgorCQkgKiBUaGVyZSBpcyBhIHNwZWNpYWwgY2FzZSBmb3IgV1JJVEVTIHdoZXJlIGEgRkUgZXhjZXB0aW9uICsKKwkJICogTFVOIHNodXRkb3duIG1lYW5zIENvbmZpZ0ZTIGNvbnRleHQgaXMgc3RpbGwgc2xlZXBpbmcgb24KKwkJICogdHJhbnNwb3J0X2x1bl9zdG9wX2NvbXAgaW4gdHJhbnNwb3J0X2x1bl93YWl0X2Zvcl90YXNrcygpLgorCQkgKiBXZSBnbyBhaGVhZCBhbmQgdXAgdHJhbnNwb3J0X2x1bl9zdG9wX2NvbXAganVzdCB0byBiZSBzdXJlCisJCSAqIGhlcmUuCisJCSAqLworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJCWNvbXBsZXRlKCZUX1RBU0soY21kKS0+dHJhbnNwb3J0X2x1bl9zdG9wX2NvbXApOworCQl3YWl0X2Zvcl9jb21wbGV0aW9uKCZUX1RBU0soY21kKS0+dHJhbnNwb3J0X2x1bl9mZV9zdG9wX2NvbXApOworCQlzcGluX2xvY2tfaXJxc2F2ZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCisJCXRyYW5zcG9ydF9hbGxfdGFza19kZXZfcmVtb3ZlX3N0YXRlKGNtZCk7CisJCS8qCisJCSAqIEF0IHRoaXMgcG9pbnQsIHRoZSBmcm9udGVuZCB3aG8gd2FzIHRoZSBvcmlnaW5hdG9yIG9mIHRoaXMKKwkJICogc3RydWN0IHNlX2NtZCwgbm93IG93bnMgdGhlIHN0cnVjdHVyZSBhbmQgY2FuIGJlIHJlbGVhc2VkIHRocm91Z2gKKwkJICogbm9ybWFsIG1lYW5zIGJlbG93LgorCQkgKi8KKwkJREVCVUdfVFJBTlNQT1JUX1MoIndhaXRfZm9yX3Rhc2tzOiBTdG9wcGVkIgorCQkJIiB3YWl0X2Zvcl9jb21wbGV0aW9uKCZUX1RBU0soY21kKXRyYW5zcG9ydF9sdW5fZmVfIgorCQkJInN0b3BfY29tcCk7IGZvciBJVFQ6IDB4JTA4eFxuIiwKKwkJCUNNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCkpOworCisJCWF0b21pY19zZXQoJlRfVEFTSyhjbWQpLT50cmFuc3BvcnRfbHVuX3N0b3AsIDApOworCX0KKwlpZiAoIWF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfYWN0aXZlKSkKKwkJZ290byByZW1vdmU7CisKKwlhdG9taWNfc2V0KCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfc3RvcCwgMSk7CisKKwlERUJVR19UUkFOU1BPUlRfUygid2FpdF9mb3JfdGFza3M6IFN0b3BwaW5nICVwIElUVDogMHglMDh4IgorCQkiIGlfc3RhdGU6ICVkLCB0X3N0YXRlL2RlZl90X3N0YXRlOiAlZC8lZCwgdF90cmFuc3BvcnRfc3RvcCIKKwkJIiA9IFRSVUVcbiIsIGNtZCwgQ01EX1RGTyhjbWQpLT5nZXRfdGFza190YWcoY21kKSwKKwkJQ01EX1RGTyhjbWQpLT5nZXRfY21kX3N0YXRlKGNtZCksIGNtZC0+dF9zdGF0ZSwKKwkJY21kLT5kZWZlcnJlZF90X3N0YXRlKTsKKworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKworCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmU0VfREVWKGNtZCktPmRldl9xdWV1ZV9vYmotPnRocmVhZF93cSk7CisKKwl3YWl0X2Zvcl9jb21wbGV0aW9uKCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfc3RvcF9jb21wKTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJYXRvbWljX3NldCgmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X2FjdGl2ZSwgMCk7CisJYXRvbWljX3NldCgmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X3N0b3AsIDApOworCisJREVCVUdfVFJBTlNQT1JUX1MoIndhaXRfZm9yX3Rhc2tzOiBTdG9wcGVkIHdhaXRfZm9yX2NvbXBsdGlvbigiCisJCSImVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X3N0b3BfY29tcCkgZm9yIElUVDogMHglMDh4XG4iLAorCQlDTURfVEZPKGNtZCktPmdldF90YXNrX3RhZyhjbWQpKTsKK3JlbW92ZToKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJaWYgKCFyZW1vdmVfY21kKQorCQlyZXR1cm47CisKKwl0cmFuc3BvcnRfZ2VuZXJpY19mcmVlX2NtZChjbWQsIDAsIDAsIHNlc3Npb25fcmVpbnN0YXRlbWVudCk7Cit9CisKK3N0YXRpYyBpbnQgdHJhbnNwb3J0X2dldF9zZW5zZV9jb2RlcygKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJdTggKmFzYywKKwl1OCAqYXNjcSkKK3sKKwkqYXNjID0gY21kLT5zY3NpX2FzYzsKKwkqYXNjcSA9IGNtZC0+c2NzaV9hc2NxOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgdHJhbnNwb3J0X3NldF9zZW5zZV9jb2RlcygKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJdTggYXNjLAorCXU4IGFzY3EpCit7CisJY21kLT5zY3NpX2FzYyA9IGFzYzsKKwljbWQtPnNjc2lfYXNjcSA9IGFzY3E7CisKKwlyZXR1cm4gMDsKK30KKworaW50IHRyYW5zcG9ydF9zZW5kX2NoZWNrX2NvbmRpdGlvbl9hbmRfc2Vuc2UoCisJc3RydWN0IHNlX2NtZCAqY21kLAorCXU4IHJlYXNvbiwKKwlpbnQgZnJvbV90cmFuc3BvcnQpCit7CisJdW5zaWduZWQgY2hhciAqYnVmZmVyID0gY21kLT5zZW5zZV9idWZmZXI7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgb2Zmc2V0OworCXU4IGFzYyA9IDAsIGFzY3EgPSAwOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwlpZiAoY21kLT5zZV9jbWRfZmxhZ3MgJiBTQ0ZfU0VOVF9DSEVDS19DT05ESVRJT04pIHsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmVF9UQVNLKGNtZCktPnRfc3RhdGVfbG9jaywgZmxhZ3MpOworCQlyZXR1cm4gMDsKKwl9CisJY21kLT5zZV9jbWRfZmxhZ3MgfD0gU0NGX1NFTlRfQ0hFQ0tfQ09ORElUSU9OOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKworCWlmICghcmVhc29uICYmIGZyb21fdHJhbnNwb3J0KQorCQlnb3RvIGFmdGVyX3JlYXNvbjsKKworCWlmICghZnJvbV90cmFuc3BvcnQpCisJCWNtZC0+c2VfY21kX2ZsYWdzIHw9IFNDRl9FTVVMQVRFRF9UQVNLX1NFTlNFOworCS8qCisJICogRGF0YSBTZWdtZW50IGFuZCBTZW5zZUxlbmd0aCBvZiB0aGUgZmFicmljIHJlc3BvbnNlIFBEVS4KKwkgKgorCSAqIFRSQU5TUE9SVF9TRU5TRV9CVUZGRVIgaXMgbm93IHNldCB0byBTQ1NJX1NFTlNFX0JVRkZFUlNJWkUKKwkgKiBmcm9tIGluY2x1ZGUvc2NzaS9zY3NpX2NtbmQuaAorCSAqLworCW9mZnNldCA9IENNRF9URk8oY21kKS0+c2V0X2ZhYnJpY19zZW5zZV9sZW4oY21kLAorCQkJCVRSQU5TUE9SVF9TRU5TRV9CVUZGRVIpOworCS8qCisJICogQWN0dWFsIFNFTlNFIERBVEEsIHNlZSBTUEMtMyA3LjIzLjIgIFNQQ19TRU5TRV9LRVlfT0ZGU0VUIHVzZXMKKwkgKiBTRU5TRSBLRVkgdmFsdWVzIGZyb20gaW5jbHVkZS9zY3NpL3Njc2kuaAorCSAqLworCXN3aXRjaCAocmVhc29uKSB7CisJY2FzZSBUQ01fTk9OX0VYSVNURU5UX0xVTjoKKwljYXNlIFRDTV9VTlNVUFBPUlRFRF9TQ1NJX09QQ09ERToKKwljYXNlIFRDTV9TRUNUT1JfQ09VTlRfVE9PX01BTlk6CisJCS8qIENVUlJFTlQgRVJST1IgKi8KKwkJYnVmZmVyW29mZnNldF0gPSAweDcwOworCQkvKiBJTExFR0FMIFJFUVVFU1QgKi8KKwkJYnVmZmVyW29mZnNldCtTUENfU0VOU0VfS0VZX09GRlNFVF0gPSBJTExFR0FMX1JFUVVFU1Q7CisJCS8qIElOVkFMSUQgQ09NTUFORCBPUEVSQVRJT04gQ09ERSAqLworCQlidWZmZXJbb2Zmc2V0K1NQQ19BU0NfS0VZX09GRlNFVF0gPSAweDIwOworCQlicmVhazsKKwljYXNlIFRDTV9VTktOT1dOX01PREVfUEFHRToKKwkJLyogQ1VSUkVOVCBFUlJPUiAqLworCQlidWZmZXJbb2Zmc2V0XSA9IDB4NzA7CisJCS8qIElMTEVHQUwgUkVRVUVTVCAqLworCQlidWZmZXJbb2Zmc2V0K1NQQ19TRU5TRV9LRVlfT0ZGU0VUXSA9IElMTEVHQUxfUkVRVUVTVDsKKwkJLyogSU5WQUxJRCBGSUVMRCBJTiBDREIgKi8KKwkJYnVmZmVyW29mZnNldCtTUENfQVNDX0tFWV9PRkZTRVRdID0gMHgyNDsKKwkJYnJlYWs7CisJY2FzZSBUQ01fQ0hFQ0tfQ09ORElUSU9OX0FCT1JUX0NNRDoKKwkJLyogQ1VSUkVOVCBFUlJPUiAqLworCQlidWZmZXJbb2Zmc2V0XSA9IDB4NzA7CisJCS8qIEFCT1JURUQgQ09NTUFORCAqLworCQlidWZmZXJbb2Zmc2V0K1NQQ19TRU5TRV9LRVlfT0ZGU0VUXSA9IEFCT1JURURfQ09NTUFORDsKKwkJLyogQlVTIERFVklDRSBSRVNFVCBGVU5DVElPTiBPQ0NVUlJFRCAqLworCQlidWZmZXJbb2Zmc2V0K1NQQ19BU0NfS0VZX09GRlNFVF0gPSAweDI5OworCQlidWZmZXJbb2Zmc2V0K1NQQ19BU0NRX0tFWV9PRkZTRVRdID0gMHgwMzsKKwkJYnJlYWs7CisJY2FzZSBUQ01fSU5DT1JSRUNUX0FNT1VOVF9PRl9EQVRBOgorCQkvKiBDVVJSRU5UIEVSUk9SICovCisJCWJ1ZmZlcltvZmZzZXRdID0gMHg3MDsKKwkJLyogQUJPUlRFRCBDT01NQU5EICovCisJCWJ1ZmZlcltvZmZzZXQrU1BDX1NFTlNFX0tFWV9PRkZTRVRdID0gQUJPUlRFRF9DT01NQU5EOworCQkvKiBXUklURSBFUlJPUiAqLworCQlidWZmZXJbb2Zmc2V0K1NQQ19BU0NfS0VZX09GRlNFVF0gPSAweDBjOworCQkvKiBOT1QgRU5PVUdIIFVOU09MSUNJVEVEIERBVEEgKi8KKwkJYnVmZmVyW29mZnNldCtTUENfQVNDUV9LRVlfT0ZGU0VUXSA9IDB4MGQ7CisJCWJyZWFrOworCWNhc2UgVENNX0lOVkFMSURfQ0RCX0ZJRUxEOgorCQkvKiBDVVJSRU5UIEVSUk9SICovCisJCWJ1ZmZlcltvZmZzZXRdID0gMHg3MDsKKwkJLyogQUJPUlRFRCBDT01NQU5EICovCisJCWJ1ZmZlcltvZmZzZXQrU1BDX1NFTlNFX0tFWV9PRkZTRVRdID0gQUJPUlRFRF9DT01NQU5EOworCQkvKiBJTlZBTElEIEZJRUxEIElOIENEQiAqLworCQlidWZmZXJbb2Zmc2V0K1NQQ19BU0NfS0VZX09GRlNFVF0gPSAweDI0OworCQlicmVhazsKKwljYXNlIFRDTV9JTlZBTElEX1BBUkFNRVRFUl9MSVNUOgorCQkvKiBDVVJSRU5UIEVSUk9SICovCisJCWJ1ZmZlcltvZmZzZXRdID0gMHg3MDsKKwkJLyogQUJPUlRFRCBDT01NQU5EICovCisJCWJ1ZmZlcltvZmZzZXQrU1BDX1NFTlNFX0tFWV9PRkZTRVRdID0gQUJPUlRFRF9DT01NQU5EOworCQkvKiBJTlZBTElEIEZJRUxEIElOIFBBUkFNRVRFUiBMSVNUICovCisJCWJ1ZmZlcltvZmZzZXQrU1BDX0FTQ19LRVlfT0ZGU0VUXSA9IDB4MjY7CisJCWJyZWFrOworCWNhc2UgVENNX1VORVhQRUNURURfVU5TT0xJQ0lURURfREFUQToKKwkJLyogQ1VSUkVOVCBFUlJPUiAqLworCQlidWZmZXJbb2Zmc2V0XSA9IDB4NzA7CisJCS8qIEFCT1JURUQgQ09NTUFORCAqLworCQlidWZmZXJbb2Zmc2V0K1NQQ19TRU5TRV9LRVlfT0ZGU0VUXSA9IEFCT1JURURfQ09NTUFORDsKKwkJLyogV1JJVEUgRVJST1IgKi8KKwkJYnVmZmVyW29mZnNldCtTUENfQVNDX0tFWV9PRkZTRVRdID0gMHgwYzsKKwkJLyogVU5FWFBFQ1RFRF9VTlNPTElDSVRFRF9EQVRBICovCisJCWJ1ZmZlcltvZmZzZXQrU1BDX0FTQ1FfS0VZX09GRlNFVF0gPSAweDBjOworCQlicmVhazsKKwljYXNlIFRDTV9TRVJWSUNFX0NSQ19FUlJPUjoKKwkJLyogQ1VSUkVOVCBFUlJPUiAqLworCQlidWZmZXJbb2Zmc2V0XSA9IDB4NzA7CisJCS8qIEFCT1JURUQgQ09NTUFORCAqLworCQlidWZmZXJbb2Zmc2V0K1NQQ19TRU5TRV9LRVlfT0ZGU0VUXSA9IEFCT1JURURfQ09NTUFORDsKKwkJLyogUFJPVE9DT0wgU0VSVklDRSBDUkMgRVJST1IgKi8KKwkJYnVmZmVyW29mZnNldCtTUENfQVNDX0tFWV9PRkZTRVRdID0gMHg0NzsKKwkJLyogTi9BICovCisJCWJ1ZmZlcltvZmZzZXQrU1BDX0FTQ1FfS0VZX09GRlNFVF0gPSAweDA1OworCQlicmVhazsKKwljYXNlIFRDTV9TTkFDS19SRUpFQ1RFRDoKKwkJLyogQ1VSUkVOVCBFUlJPUiAqLworCQlidWZmZXJbb2Zmc2V0XSA9IDB4NzA7CisJCS8qIEFCT1JURUQgQ09NTUFORCAqLworCQlidWZmZXJbb2Zmc2V0K1NQQ19TRU5TRV9LRVlfT0ZGU0VUXSA9IEFCT1JURURfQ09NTUFORDsKKwkJLyogUkVBRCBFUlJPUiAqLworCQlidWZmZXJbb2Zmc2V0K1NQQ19BU0NfS0VZX09GRlNFVF0gPSAweDExOworCQkvKiBGQUlMRUQgUkVUUkFOU01JU1NJT04gUkVRVUVTVCAqLworCQlidWZmZXJbb2Zmc2V0K1NQQ19BU0NRX0tFWV9PRkZTRVRdID0gMHgxMzsKKwkJYnJlYWs7CisJY2FzZSBUQ01fV1JJVEVfUFJPVEVDVEVEOgorCQkvKiBDVVJSRU5UIEVSUk9SICovCisJCWJ1ZmZlcltvZmZzZXRdID0gMHg3MDsKKwkJLyogREFUQSBQUk9URUNUICovCisJCWJ1ZmZlcltvZmZzZXQrU1BDX1NFTlNFX0tFWV9PRkZTRVRdID0gREFUQV9QUk9URUNUOworCQkvKiBXUklURSBQUk9URUNURUQgKi8KKwkJYnVmZmVyW29mZnNldCtTUENfQVNDX0tFWV9PRkZTRVRdID0gMHgyNzsKKwkJYnJlYWs7CisJY2FzZSBUQ01fQ0hFQ0tfQ09ORElUSU9OX1VOSVRfQVRURU5USU9OOgorCQkvKiBDVVJSRU5UIEVSUk9SICovCisJCWJ1ZmZlcltvZmZzZXRdID0gMHg3MDsKKwkJLyogVU5JVCBBVFRFTlRJT04gKi8KKwkJYnVmZmVyW29mZnNldCtTUENfU0VOU0VfS0VZX09GRlNFVF0gPSBVTklUX0FUVEVOVElPTjsKKwkJY29yZV9zY3NpM191YV9mb3JfY2hlY2tfY29uZGl0aW9uKGNtZCwgJmFzYywgJmFzY3EpOworCQlidWZmZXJbb2Zmc2V0K1NQQ19BU0NfS0VZX09GRlNFVF0gPSBhc2M7CisJCWJ1ZmZlcltvZmZzZXQrU1BDX0FTQ1FfS0VZX09GRlNFVF0gPSBhc2NxOworCQlicmVhazsKKwljYXNlIFRDTV9DSEVDS19DT05ESVRJT05fTk9UX1JFQURZOgorCQkvKiBDVVJSRU5UIEVSUk9SICovCisJCWJ1ZmZlcltvZmZzZXRdID0gMHg3MDsKKwkJLyogTm90IFJlYWR5ICovCisJCWJ1ZmZlcltvZmZzZXQrU1BDX1NFTlNFX0tFWV9PRkZTRVRdID0gTk9UX1JFQURZOworCQl0cmFuc3BvcnRfZ2V0X3NlbnNlX2NvZGVzKGNtZCwgJmFzYywgJmFzY3EpOworCQlidWZmZXJbb2Zmc2V0K1NQQ19BU0NfS0VZX09GRlNFVF0gPSBhc2M7CisJCWJ1ZmZlcltvZmZzZXQrU1BDX0FTQ1FfS0VZX09GRlNFVF0gPSBhc2NxOworCQlicmVhazsKKwljYXNlIFRDTV9MT0dJQ0FMX1VOSVRfQ09NTVVOSUNBVElPTl9GQUlMVVJFOgorCWRlZmF1bHQ6CisJCS8qIENVUlJFTlQgRVJST1IgKi8KKwkJYnVmZmVyW29mZnNldF0gPSAweDcwOworCQkvKiBJTExFR0FMIFJFUVVFU1QgKi8KKwkJYnVmZmVyW29mZnNldCtTUENfU0VOU0VfS0VZX09GRlNFVF0gPSBJTExFR0FMX1JFUVVFU1Q7CisJCS8qIExPR0lDQUwgVU5JVCBDT01NVU5JQ0FUSU9OIEZBSUxVUkUgKi8KKwkJYnVmZmVyW29mZnNldCtTUENfQVNDX0tFWV9PRkZTRVRdID0gMHg4MDsKKwkJYnJlYWs7CisJfQorCS8qCisJICogVGhpcyBjb2RlIHVzZXMgbGludXgvaW5jbHVkZS9zY3NpL3Njc2kuaCBTQU0gc3RhdHVzIGNvZGVzIQorCSAqLworCWNtZC0+c2NzaV9zdGF0dXMgPSBTQU1fU1RBVF9DSEVDS19DT05ESVRJT047CisJLyoKKwkgKiBBdXRvbWF0aWNhbGx5IHBhZGRlZCwgdGhpcyB2YWx1ZSBpcyBlbmNvZGVkIGluIHRoZSBmYWJyaWMncworCSAqIGRhdGFfbGVuZ3RoIHJlc3BvbnNlIFBEVSBjb250YWluaW5nIHRoZSBTQ1NJIGRlZmluZWQgc2Vuc2UgZGF0YS4KKwkgKi8KKwljbWQtPnNjc2lfc2Vuc2VfbGVuZ3RoICA9IFRSQU5TUE9SVF9TRU5TRV9CVUZGRVIgKyBvZmZzZXQ7CisKK2FmdGVyX3JlYXNvbjoKKwlDTURfVEZPKGNtZCktPnF1ZXVlX3N0YXR1cyhjbWQpOworCXJldHVybiAwOworfQorRVhQT1JUX1NZTUJPTCh0cmFuc3BvcnRfc2VuZF9jaGVja19jb25kaXRpb25fYW5kX3NlbnNlKTsKKworaW50IHRyYW5zcG9ydF9jaGVja19hYm9ydGVkX3N0YXR1cyhzdHJ1Y3Qgc2VfY21kICpjbWQsIGludCBzZW5kX3N0YXR1cykKK3sKKwlpbnQgcmV0ID0gMDsKKworCWlmIChhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X2Fib3J0ZWQpICE9IDApIHsKKwkJaWYgKCEoc2VuZF9zdGF0dXMpIHx8CisJCSAgICAgKGNtZC0+c2VfY21kX2ZsYWdzICYgU0NGX1NFTlRfREVMQVlFRF9UQVMpKQorCQkJcmV0dXJuIDE7CisjaWYgMAorCQlwcmludGsoS0VSTl9JTkZPICJTZW5kaW5nIGRlbGF5ZWQgU0FNX1NUQVRfVEFTS19BQk9SVEVEIgorCQkJIiBzdGF0dXMgZm9yIENEQjogMHglMDJ4IElUVDogMHglMDh4XG4iLAorCQkJVF9UQVNLKGNtZCktPnRfdGFza19jZGJbMF0sCisJCQlDTURfVEZPKGNtZCktPmdldF90YXNrX3RhZyhjbWQpKTsKKyNlbmRpZgorCQljbWQtPnNlX2NtZF9mbGFncyB8PSBTQ0ZfU0VOVF9ERUxBWUVEX1RBUzsKKwkJQ01EX1RGTyhjbWQpLT5xdWV1ZV9zdGF0dXMoY21kKTsKKwkJcmV0ID0gMTsKKwl9CisJcmV0dXJuIHJldDsKK30KK0VYUE9SVF9TWU1CT0wodHJhbnNwb3J0X2NoZWNrX2Fib3J0ZWRfc3RhdHVzKTsKKwordm9pZCB0cmFuc3BvcnRfc2VuZF90YXNrX2Fib3J0KHN0cnVjdCBzZV9jbWQgKmNtZCkKK3sKKwkvKgorCSAqIElmIHRoZXJlIGFyZSBzdGlsbCBleHBlY3RlZCBpbmNvbWluZyBmYWJyaWMgV1JJVEVzLCB3ZSB3YWl0CisJICogdW50aWwgdW50aWwgdGhleSBoYXZlIGNvbXBsZXRlZCBiZWZvcmUgc2VuZGluZyBhIFRBU0tfQUJPUlRFRAorCSAqIHJlc3BvbnNlLiAgVGhpcyByZXNwb25zZSB3aXRoIFRBU0tfQUJPUlRFRCBzdGF0dXMgd2lsbCBiZQorCSAqIHF1ZXVlZCBiYWNrIHRvIGZhYnJpYyBtb2R1bGUgYnkgdHJhbnNwb3J0X2NoZWNrX2Fib3J0ZWRfc3RhdHVzKCkuCisJICovCisJaWYgKGNtZC0+ZGF0YV9kaXJlY3Rpb24gPT0gRE1BX1RPX0RFVklDRSkgeworCQlpZiAoQ01EX1RGTyhjbWQpLT53cml0ZV9wZW5kaW5nX3N0YXR1cyhjbWQpICE9IDApIHsKKwkJCWF0b21pY19pbmMoJlRfVEFTSyhjbWQpLT50X3RyYW5zcG9ydF9hYm9ydGVkKTsKKwkJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2luYygpOworCQkJY21kLT5zY3NpX3N0YXR1cyA9IFNBTV9TVEFUX1RBU0tfQUJPUlRFRDsKKwkJCXRyYW5zcG9ydF9uZXdfY21kX2ZhaWx1cmUoY21kKTsKKwkJCXJldHVybjsKKwkJfQorCX0KKwljbWQtPnNjc2lfc3RhdHVzID0gU0FNX1NUQVRfVEFTS19BQk9SVEVEOworI2lmIDAKKwlwcmludGsoS0VSTl9JTkZPICJTZXR0aW5nIFNBTV9TVEFUX1RBU0tfQUJPUlRFRCBzdGF0dXMgZm9yIENEQjogMHglMDJ4LCIKKwkJIiBJVFQ6IDB4JTA4eFxuIiwgVF9UQVNLKGNtZCktPnRfdGFza19jZGJbMF0sCisJCUNNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCkpOworI2VuZGlmCisJQ01EX1RGTyhjbWQpLT5xdWV1ZV9zdGF0dXMoY21kKTsKK30KKworLyoJdHJhbnNwb3J0X2dlbmVyaWNfZG9fdG1yKCk6CisgKgorICoKKyAqLworaW50IHRyYW5zcG9ydF9nZW5lcmljX2RvX3RtcihzdHJ1Y3Qgc2VfY21kICpjbWQpCit7CisJc3RydWN0IHNlX2NtZCAqcmVmX2NtZDsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKwlzdHJ1Y3Qgc2VfdG1yX3JlcSAqdG1yID0gY21kLT5zZV90bXJfcmVxOworCWludCByZXQ7CisKKwlzd2l0Y2ggKHRtci0+ZnVuY3Rpb24pIHsKKwljYXNlIEFCT1JUX1RBU0s6CisJCXJlZl9jbWQgPSB0bXItPnJlZl9jbWQ7CisJCXRtci0+cmVzcG9uc2UgPSBUTVJfRlVOQ1RJT05fUkVKRUNURUQ7CisJCWJyZWFrOworCWNhc2UgQUJPUlRfVEFTS19TRVQ6CisJY2FzZSBDTEVBUl9BQ0E6CisJY2FzZSBDTEVBUl9UQVNLX1NFVDoKKwkJdG1yLT5yZXNwb25zZSA9IFRNUl9UQVNLX01HTVRfRlVOQ1RJT05fTk9UX1NVUFBPUlRFRDsKKwkJYnJlYWs7CisJY2FzZSBMVU5fUkVTRVQ6CisJCXJldCA9IGNvcmVfdG1yX2x1bl9yZXNldChkZXYsIHRtciwgTlVMTCwgTlVMTCk7CisJCXRtci0+cmVzcG9uc2UgPSAoIXJldCkgPyBUTVJfRlVOQ1RJT05fQ09NUExFVEUgOgorCQkJCQkgVE1SX0ZVTkNUSU9OX1JFSkVDVEVEOworCQlicmVhazsKKyNpZiAwCisJY2FzZSBUQVJHRVRfV0FSTV9SRVNFVDoKKwkJdHJhbnNwb3J0X2dlbmVyaWNfaG9zdF9yZXNldChkZXYtPnNlX2hiYSk7CisJCXRtci0+cmVzcG9uc2UgPSBUTVJfRlVOQ1RJT05fUkVKRUNURUQ7CisJCWJyZWFrOworCWNhc2UgVEFSR0VUX0NPTERfUkVTRVQ6CisJCXRyYW5zcG9ydF9nZW5lcmljX2hvc3RfcmVzZXQoZGV2LT5zZV9oYmEpOworCQl0cmFuc3BvcnRfZ2VuZXJpY19jb2xkX3Jlc2V0KGRldi0+c2VfaGJhKTsKKwkJdG1yLT5yZXNwb25zZSA9IFRNUl9GVU5DVElPTl9SRUpFQ1RFRDsKKwkJYnJlYWs7CisjZW5kaWYKKwlkZWZhdWx0OgorCQlwcmludGsoS0VSTl9FUlIgIlVrbm93biBUTVIgZnVuY3Rpb246IDB4JTAyeC5cbiIsCisJCQkJdG1yLT5mdW5jdGlvbik7CisJCXRtci0+cmVzcG9uc2UgPSBUTVJfRlVOQ1RJT05fUkVKRUNURUQ7CisJCWJyZWFrOworCX0KKworCWNtZC0+dF9zdGF0ZSA9IFRSQU5TUE9SVF9JU1RBVEVfUFJPQ0VTU0lORzsKKwlDTURfVEZPKGNtZCktPnF1ZXVlX3RtX3JzcChjbWQpOworCisJdHJhbnNwb3J0X2NtZF9jaGVja19zdG9wKGNtZCwgMiwgMCk7CisJcmV0dXJuIDA7Cit9CisKKy8qCisgKglDYWxsZWQgd2l0aCBzcGluX2xvY2tfaXJxKCZkZXYtPmV4ZWN1dGVfdGFza19sb2NrKTsgaGVsZAorICoKKyAqLworc3RhdGljIHN0cnVjdCBzZV90YXNrICoKK3RyYW5zcG9ydF9nZXRfdGFza19mcm9tX3N0YXRlX2xpc3Qoc3RydWN0IHNlX2RldmljZSAqZGV2KQoreworCXN0cnVjdCBzZV90YXNrICp0YXNrOworCisJaWYgKGxpc3RfZW1wdHkoJmRldi0+c3RhdGVfdGFza19saXN0KSkKKwkJcmV0dXJuIE5VTEw7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHRhc2ssICZkZXYtPnN0YXRlX3Rhc2tfbGlzdCwgdF9zdGF0ZV9saXN0KQorCQlicmVhazsKKworCWxpc3RfZGVsKCZ0YXNrLT50X3N0YXRlX2xpc3QpOworCWF0b21pY19zZXQoJnRhc2stPnRhc2tfc3RhdGVfYWN0aXZlLCAwKTsKKworCXJldHVybiB0YXNrOworfQorCitzdGF0aWMgdm9pZCB0cmFuc3BvcnRfcHJvY2Vzc2luZ19zaHV0ZG93bihzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHNlX2NtZCAqY21kOworCXN0cnVjdCBzZV9xdWV1ZV9yZXEgKnFyOworCXN0cnVjdCBzZV90YXNrICp0YXNrOworCXU4IHN0YXRlOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJLyoKKwkgKiBFbXB0eSB0aGUgc3RydWN0IHNlX2RldmljZSdzIHN0cnVjdCBzZV90YXNrIHN0YXRlIGxpc3QuCisJICovCisJc3Bpbl9sb2NrX2lycXNhdmUoJmRldi0+ZXhlY3V0ZV90YXNrX2xvY2ssIGZsYWdzKTsKKwl3aGlsZSAoKHRhc2sgPSB0cmFuc3BvcnRfZ2V0X3Rhc2tfZnJvbV9zdGF0ZV9saXN0KGRldikpKSB7CisJCWlmICghKFRBU0tfQ01EKHRhc2spKSkgeworCQkJcHJpbnRrKEtFUk5fRVJSICJUQVNLX0NNRCh0YXNrKSBpcyBOVUxMIVxuIik7CisJCQljb250aW51ZTsKKwkJfQorCQljbWQgPSBUQVNLX0NNRCh0YXNrKTsKKworCQlpZiAoIVRfVEFTSyhjbWQpKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIlRfVEFTSyhjbWQpIGlzIE5VTEwgZm9yIHRhc2s6ICVwIGNtZDoiCisJCQkJIiAlcCBJVFQ6IDB4JTA4eFxuIiwgdGFzaywgY21kLAorCQkJCUNNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCkpOworCQkJY29udGludWU7CisJCX0KKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGV2LT5leGVjdXRlX3Rhc2tfbG9jaywgZmxhZ3MpOworCisJCXNwaW5fbG9ja19pcnFzYXZlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisKKwkJREVCVUdfRE8oIlBUOiBjbWQ6ICVwIHRhc2s6ICVwIElUVC9DbWRTTjogMHglMDh4LzB4JTA4eCwiCisJCQkiIGlfc3RhdGUvZGVmX2lfc3RhdGU6ICVkLyVkLCB0X3N0YXRlL2RlZl90X3N0YXRlOiIKKwkJCSIgJWQvJWQgY2RiOiAweCUwMnhcbiIsIGNtZCwgdGFzaywKKwkJCUNNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCksIGNtZC0+Y21kX3NuLAorCQkJQ01EX1RGTyhjbWQpLT5nZXRfY21kX3N0YXRlKGNtZCksIGNtZC0+ZGVmZXJyZWRfaV9zdGF0ZSwKKwkJCWNtZC0+dF9zdGF0ZSwgY21kLT5kZWZlcnJlZF90X3N0YXRlLAorCQkJVF9UQVNLKGNtZCktPnRfdGFza19jZGJbMF0pOworCQlERUJVR19ETygiUFQ6IElUVFsweCUwOHhdIC0gdF90YXNrX2NkYnM6ICVkIHRfdGFza19jZGJzX2xlZnQ6IgorCQkJIiAlZCB0X3Rhc2tfY2Ric19zZW50OiAlZCAtLSB0X3RyYW5zcG9ydF9hY3RpdmU6ICVkIgorCQkJIiB0X3RyYW5zcG9ydF9zdG9wOiAlZCB0X3RyYW5zcG9ydF9zZW50OiAlZFxuIiwKKwkJCUNNRF9URk8oY21kKS0+Z2V0X3Rhc2tfdGFnKGNtZCksCisJCQlUX1RBU0soY21kKS0+dF90YXNrX2NkYnMsCisJCQlhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfdGFza19jZGJzX2xlZnQpLAorCQkJYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X3Rhc2tfY2Ric19zZW50KSwKKwkJCWF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfYWN0aXZlKSwKKwkJCWF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF90cmFuc3BvcnRfc3RvcCksCisJCQlhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X3NlbnQpKTsKKworCQlpZiAoYXRvbWljX3JlYWQoJnRhc2stPnRhc2tfYWN0aXZlKSkgeworCQkJYXRvbWljX3NldCgmdGFzay0+dGFza19zdG9wLCAxKTsKKwkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoCisJCQkJJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKworCQkJREVCVUdfRE8oIldhaXRpbmcgZm9yIHRhc2s6ICVwIHRvIHNodXRkb3duIGZvciBkZXY6IgorCQkJCSIgJXBcbiIsIHRhc2ssIGRldik7CisJCQl3YWl0X2Zvcl9jb21wbGV0aW9uKCZ0YXNrLT50YXNrX3N0b3BfY29tcCk7CisJCQlERUJVR19ETygiQ29tcGxldGVkIHRhc2s6ICVwIHNodXRkb3duIGZvciBkZXY6ICVwXG4iLAorCQkJCXRhc2ssIGRldik7CisKKwkJCXNwaW5fbG9ja19pcnFzYXZlKCZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJCQlhdG9taWNfZGVjKCZUX1RBU0soY21kKS0+dF90YXNrX2NkYnNfbGVmdCk7CisKKwkJCWF0b21pY19zZXQoJnRhc2stPnRhc2tfYWN0aXZlLCAwKTsKKwkJCWF0b21pY19zZXQoJnRhc2stPnRhc2tfc3RvcCwgMCk7CisJCX0KKwkJX190cmFuc3BvcnRfc3RvcF90YXNrX3RpbWVyKHRhc2ssICZmbGFncyk7CisKKwkJaWYgKCEoYXRvbWljX2RlY19hbmRfdGVzdCgmVF9UQVNLKGNtZCktPnRfdGFza19jZGJzX2V4X2xlZnQpKSkgeworCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgKKwkJCQkJJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKworCQkJREVCVUdfRE8oIlNraXBwaW5nIHRhc2s6ICVwLCBkZXY6ICVwIGZvciIKKwkJCQkiIHRfdGFza19jZGJzX2V4X2xlZnQ6ICVkXG4iLCB0YXNrLCBkZXYsCisJCQkJYXRvbWljX3JlYWQoJlRfVEFTSyhjbWQpLT50X3Rhc2tfY2Ric19leF9sZWZ0KSk7CisKKwkJCXNwaW5fbG9ja19pcnFzYXZlKCZkZXYtPmV4ZWN1dGVfdGFza19sb2NrLCBmbGFncyk7CisJCQljb250aW51ZTsKKwkJfQorCisJCWlmIChhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfdHJhbnNwb3J0X2FjdGl2ZSkpIHsKKwkJCURFQlVHX0RPKCJnb3QgdF90cmFuc3BvcnRfYWN0aXZlID0gMSBmb3IgdGFzazogJXAsIGRldjoiCisJCQkJCSIgJXBcbiIsIHRhc2ssIGRldik7CisKKwkJCWlmIChhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfZmVfY291bnQpKSB7CisJCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgKKwkJCQkJJlRfVEFTSyhjbWQpLT50X3N0YXRlX2xvY2ssIGZsYWdzKTsKKwkJCQl0cmFuc3BvcnRfc2VuZF9jaGVja19jb25kaXRpb25fYW5kX3NlbnNlKAorCQkJCQljbWQsIFRDTV9MT0dJQ0FMX1VOSVRfQ09NTVVOSUNBVElPTl9GQUlMVVJFLAorCQkJCQkwKTsKKwkJCQl0cmFuc3BvcnRfcmVtb3ZlX2NtZF9mcm9tX3F1ZXVlKGNtZCwKKwkJCQkJU0VfREVWKGNtZCktPmRldl9xdWV1ZV9vYmopOworCisJCQkJdHJhbnNwb3J0X2x1bl9yZW1vdmVfY21kKGNtZCk7CisJCQkJdHJhbnNwb3J0X2NtZF9jaGVja19zdG9wKGNtZCwgMSwgMCk7CisJCQl9IGVsc2UgeworCQkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoCisJCQkJCSZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisKKwkJCQl0cmFuc3BvcnRfcmVtb3ZlX2NtZF9mcm9tX3F1ZXVlKGNtZCwKKwkJCQkJU0VfREVWKGNtZCktPmRldl9xdWV1ZV9vYmopOworCisJCQkJdHJhbnNwb3J0X2x1bl9yZW1vdmVfY21kKGNtZCk7CisKKwkJCQlpZiAodHJhbnNwb3J0X2NtZF9jaGVja19zdG9wKGNtZCwgMSwgMCkpCisJCQkJCXRyYW5zcG9ydF9nZW5lcmljX3JlbW92ZShjbWQsIDAsIDApOworCQkJfQorCisJCQlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2LT5leGVjdXRlX3Rhc2tfbG9jaywgZmxhZ3MpOworCQkJY29udGludWU7CisJCX0KKwkJREVCVUdfRE8oIkdvdCB0X3RyYW5zcG9ydF9hY3RpdmUgPSAwIGZvciB0YXNrOiAlcCwgZGV2OiAlcFxuIiwKKwkJCQl0YXNrLCBkZXYpOworCisJCWlmIChhdG9taWNfcmVhZCgmVF9UQVNLKGNtZCktPnRfZmVfY291bnQpKSB7CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKAorCQkJCSZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisJCQl0cmFuc3BvcnRfc2VuZF9jaGVja19jb25kaXRpb25fYW5kX3NlbnNlKGNtZCwKKwkJCQlUQ01fTE9HSUNBTF9VTklUX0NPTU1VTklDQVRJT05fRkFJTFVSRSwgMCk7CisJCQl0cmFuc3BvcnRfcmVtb3ZlX2NtZF9mcm9tX3F1ZXVlKGNtZCwKKwkJCQlTRV9ERVYoY21kKS0+ZGV2X3F1ZXVlX29iaik7CisKKwkJCXRyYW5zcG9ydF9sdW5fcmVtb3ZlX2NtZChjbWQpOworCQkJdHJhbnNwb3J0X2NtZF9jaGVja19zdG9wKGNtZCwgMSwgMCk7CisJCX0gZWxzZSB7CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKAorCQkJCSZUX1RBU0soY21kKS0+dF9zdGF0ZV9sb2NrLCBmbGFncyk7CisKKwkJCXRyYW5zcG9ydF9yZW1vdmVfY21kX2Zyb21fcXVldWUoY21kLAorCQkJCVNFX0RFVihjbWQpLT5kZXZfcXVldWVfb2JqKTsKKwkJCXRyYW5zcG9ydF9sdW5fcmVtb3ZlX2NtZChjbWQpOworCisJCQlpZiAodHJhbnNwb3J0X2NtZF9jaGVja19zdG9wKGNtZCwgMSwgMCkpCisJCQkJdHJhbnNwb3J0X2dlbmVyaWNfcmVtb3ZlKGNtZCwgMCwgMCk7CisJCX0KKworCQlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2LT5leGVjdXRlX3Rhc2tfbG9jaywgZmxhZ3MpOworCX0KKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXYtPmV4ZWN1dGVfdGFza19sb2NrLCBmbGFncyk7CisJLyoKKwkgKiBFbXB0eSB0aGUgc3RydWN0IHNlX2RldmljZSdzIHN0cnVjdCBzZV9jbWQgbGlzdC4KKwkgKi8KKwlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2LT5kZXZfcXVldWVfb2JqLT5jbWRfcXVldWVfbG9jaywgZmxhZ3MpOworCXdoaWxlICgocXIgPSBfX3RyYW5zcG9ydF9nZXRfcXJfZnJvbV9xdWV1ZShkZXYtPmRldl9xdWV1ZV9vYmopKSkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKAorCQkJCSZkZXYtPmRldl9xdWV1ZV9vYmotPmNtZF9xdWV1ZV9sb2NrLCBmbGFncyk7CisJCWNtZCA9IChzdHJ1Y3Qgc2VfY21kICopcXItPmNtZDsKKwkJc3RhdGUgPSBxci0+c3RhdGU7CisJCWtmcmVlKHFyKTsKKworCQlERUJVR19ETygiRnJvbSBEZXZpY2UgUXVldWU6IGNtZDogJXAgdF9zdGF0ZTogJWRcbiIsCisJCQkJY21kLCBzdGF0ZSk7CisKKwkJaWYgKGF0b21pY19yZWFkKCZUX1RBU0soY21kKS0+dF9mZV9jb3VudCkpIHsKKwkJCXRyYW5zcG9ydF9zZW5kX2NoZWNrX2NvbmRpdGlvbl9hbmRfc2Vuc2UoY21kLAorCQkJCVRDTV9MT0dJQ0FMX1VOSVRfQ09NTVVOSUNBVElPTl9GQUlMVVJFLCAwKTsKKworCQkJdHJhbnNwb3J0X2x1bl9yZW1vdmVfY21kKGNtZCk7CisJCQl0cmFuc3BvcnRfY21kX2NoZWNrX3N0b3AoY21kLCAxLCAwKTsKKwkJfSBlbHNlIHsKKwkJCXRyYW5zcG9ydF9sdW5fcmVtb3ZlX2NtZChjbWQpOworCQkJaWYgKHRyYW5zcG9ydF9jbWRfY2hlY2tfc3RvcChjbWQsIDEsIDApKQorCQkJCXRyYW5zcG9ydF9nZW5lcmljX3JlbW92ZShjbWQsIDAsIDApOworCQl9CisJCXNwaW5fbG9ja19pcnFzYXZlKCZkZXYtPmRldl9xdWV1ZV9vYmotPmNtZF9xdWV1ZV9sb2NrLCBmbGFncyk7CisJfQorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRldi0+ZGV2X3F1ZXVlX29iai0+Y21kX3F1ZXVlX2xvY2ssIGZsYWdzKTsKK30KKworLyoJdHJhbnNwb3J0X3Byb2Nlc3NpbmdfdGhyZWFkKCk6CisgKgorICoKKyAqLworc3RhdGljIGludCB0cmFuc3BvcnRfcHJvY2Vzc2luZ190aHJlYWQodm9pZCAqcGFyYW0pCit7CisJaW50IHJldCwgdF9zdGF0ZTsKKwlzdHJ1Y3Qgc2VfY21kICpjbWQ7CisJc3RydWN0IHNlX2RldmljZSAqZGV2ID0gKHN0cnVjdCBzZV9kZXZpY2UgKikgcGFyYW07CisJc3RydWN0IHNlX3F1ZXVlX3JlcSAqcXI7CisKKwlzZXRfdXNlcl9uaWNlKGN1cnJlbnQsIC0yMCk7CisKKwl3aGlsZSAoIWt0aHJlYWRfc2hvdWxkX3N0b3AoKSkgeworCQlyZXQgPSB3YWl0X2V2ZW50X2ludGVycnVwdGlibGUoZGV2LT5kZXZfcXVldWVfb2JqLT50aHJlYWRfd3EsCisJCQkJYXRvbWljX3JlYWQoJmRldi0+ZGV2X3F1ZXVlX29iai0+cXVldWVfY250KSB8fAorCQkJCWt0aHJlYWRfc2hvdWxkX3N0b3AoKSk7CisJCWlmIChyZXQgPCAwKQorCQkJZ290byBvdXQ7CisKKwkJc3Bpbl9sb2NrX2lycSgmZGV2LT5kZXZfc3RhdHVzX2xvY2spOworCQlpZiAoZGV2LT5kZXZfc3RhdHVzICYgVFJBTlNQT1JUX0RFVklDRV9TSFVURE9XTikgeworCQkJc3Bpbl91bmxvY2tfaXJxKCZkZXYtPmRldl9zdGF0dXNfbG9jayk7CisJCQl0cmFuc3BvcnRfcHJvY2Vzc2luZ19zaHV0ZG93bihkZXYpOworCQkJY29udGludWU7CisJCX0KKwkJc3Bpbl91bmxvY2tfaXJxKCZkZXYtPmRldl9zdGF0dXNfbG9jayk7CisKK2dldF9jbWQ6CisJCV9fdHJhbnNwb3J0X2V4ZWN1dGVfdGFza3MoZGV2KTsKKworCQlxciA9IHRyYW5zcG9ydF9nZXRfcXJfZnJvbV9xdWV1ZShkZXYtPmRldl9xdWV1ZV9vYmopOworCQlpZiAoIShxcikpCisJCQljb250aW51ZTsKKworCQljbWQgPSAoc3RydWN0IHNlX2NtZCAqKXFyLT5jbWQ7CisJCXRfc3RhdGUgPSBxci0+c3RhdGU7CisJCWtmcmVlKHFyKTsKKworCQlzd2l0Y2ggKHRfc3RhdGUpIHsKKwkJY2FzZSBUUkFOU1BPUlRfTkVXX0NNRF9NQVA6CisJCQlpZiAoIShDTURfVEZPKGNtZCktPm5ld19jbWRfbWFwKSkgeworCQkJCXByaW50ayhLRVJOX0VSUiAiQ01EX1RGTyhjbWQpLT5uZXdfY21kX21hcCBpcyIKKwkJCQkJIiBOVUxMIGZvciBUUkFOU1BPUlRfTkVXX0NNRF9NQVBcbiIpOworCQkJCUJVRygpOworCQkJfQorCQkJcmV0ID0gQ01EX1RGTyhjbWQpLT5uZXdfY21kX21hcChjbWQpOworCQkJaWYgKHJldCA8IDApIHsKKwkJCQljbWQtPnRyYW5zcG9ydF9lcnJvcl9zdGF0dXMgPSByZXQ7CisJCQkJdHJhbnNwb3J0X2dlbmVyaWNfcmVxdWVzdF9mYWlsdXJlKGNtZCwgTlVMTCwKKwkJCQkJCTAsIChjbWQtPmRhdGFfZGlyZWN0aW9uICE9CisJCQkJCQkgICAgRE1BX1RPX0RFVklDRSkpOworCQkJCWJyZWFrOworCQkJfQorCQkJLyogRmFsbCB0aHJvdWdoICovCisJCWNhc2UgVFJBTlNQT1JUX05FV19DTUQ6CisJCQlyZXQgPSB0cmFuc3BvcnRfZ2VuZXJpY19uZXdfY21kKGNtZCk7CisJCQlpZiAocmV0IDwgMCkgeworCQkJCWNtZC0+dHJhbnNwb3J0X2Vycm9yX3N0YXR1cyA9IHJldDsKKwkJCQl0cmFuc3BvcnRfZ2VuZXJpY19yZXF1ZXN0X2ZhaWx1cmUoY21kLCBOVUxMLAorCQkJCQkwLCAoY21kLT5kYXRhX2RpcmVjdGlvbiAhPQorCQkJCQkgRE1BX1RPX0RFVklDRSkpOworCQkJfQorCQkJYnJlYWs7CisJCWNhc2UgVFJBTlNQT1JUX1BST0NFU1NfV1JJVEU6CisJCQl0cmFuc3BvcnRfZ2VuZXJpY19wcm9jZXNzX3dyaXRlKGNtZCk7CisJCQlicmVhazsKKwkJY2FzZSBUUkFOU1BPUlRfQ09NUExFVEVfT0s6CisJCQl0cmFuc3BvcnRfc3RvcF9hbGxfdGFza190aW1lcnMoY21kKTsKKwkJCXRyYW5zcG9ydF9nZW5lcmljX2NvbXBsZXRlX29rKGNtZCk7CisJCQlicmVhazsKKwkJY2FzZSBUUkFOU1BPUlRfUkVNT1ZFOgorCQkJdHJhbnNwb3J0X2dlbmVyaWNfcmVtb3ZlKGNtZCwgMSwgMCk7CisJCQlicmVhazsKKwkJY2FzZSBUUkFOU1BPUlRfUFJPQ0VTU19UTVI6CisJCQl0cmFuc3BvcnRfZ2VuZXJpY19kb190bXIoY21kKTsKKwkJCWJyZWFrOworCQljYXNlIFRSQU5TUE9SVF9DT01QTEVURV9GQUlMVVJFOgorCQkJdHJhbnNwb3J0X2dlbmVyaWNfcmVxdWVzdF9mYWlsdXJlKGNtZCwgTlVMTCwgMSwgMSk7CisJCQlicmVhazsKKwkJY2FzZSBUUkFOU1BPUlRfQ09NUExFVEVfVElNRU9VVDoKKwkJCXRyYW5zcG9ydF9zdG9wX2FsbF90YXNrX3RpbWVycyhjbWQpOworCQkJdHJhbnNwb3J0X2dlbmVyaWNfcmVxdWVzdF90aW1lb3V0KGNtZCk7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5rbm93biB0X3N0YXRlOiAlZCBkZWZlcnJlZF90X3N0YXRlOiIKKwkJCQkiICVkIGZvciBJVFQ6IDB4JTA4eCBpX3N0YXRlOiAlZCBvbiBTRSBMVU46IgorCQkJCSIgJXVcbiIsIHRfc3RhdGUsIGNtZC0+ZGVmZXJyZWRfdF9zdGF0ZSwKKwkJCQlDTURfVEZPKGNtZCktPmdldF90YXNrX3RhZyhjbWQpLAorCQkJCUNNRF9URk8oY21kKS0+Z2V0X2NtZF9zdGF0ZShjbWQpLAorCQkJCVNFX0xVTihjbWQpLT51bnBhY2tlZF9sdW4pOworCQkJQlVHKCk7CisJCX0KKworCQlnb3RvIGdldF9jbWQ7CisJfQorCitvdXQ6CisJdHJhbnNwb3J0X3JlbGVhc2VfYWxsX2NtZHMoZGV2KTsKKwlkZXYtPnByb2Nlc3NfdGhyZWFkID0gTlVMTDsKKwlyZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX3VhLmMgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV91YS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmEyZWYzNDYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV91YS5jCkBAIC0wLDAgKzEsMzMyIEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogRmlsZW5hbWU6IHRhcmdldF9jb3JlX3VhLmMKKyAqCisgKiBUaGlzIGZpbGUgY29udGFpbnMgbG9naWMgZm9yIFNQQy0zIFVuaXQgQXR0ZW50aW9uIGVtdWxhdGlvbgorICoKKyAqIENvcHlyaWdodCAoYykgMjAwOSwyMDEwIFJpc2luZyBUaWRlIFN5c3RlbXMKKyAqIENvcHlyaWdodCAoYykgMjAwOSwyMDEwIExpbnV4LWlTQ1NJLm9yZworICoKKyAqIE5pY2hvbGFzIEEuIEJlbGxpbmdlciA8bmFiQGtlcm5lbC5vcmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisjaW5jbHVkZSA8bGludXgvdmVyc2lvbi5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaS5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV9jbW5kLmg+CisKKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfYmFzZS5oPgorI2luY2x1ZGUgPHRhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfdHJhbnNwb3J0Lmg+CisjaW5jbHVkZSA8dGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19vcHMuaD4KKyNpbmNsdWRlIDx0YXJnZXQvdGFyZ2V0X2NvcmVfY29uZmlnZnMuaD4KKworI2luY2x1ZGUgInRhcmdldF9jb3JlX2FsdWEuaCIKKyNpbmNsdWRlICJ0YXJnZXRfY29yZV9oYmEuaCIKKyNpbmNsdWRlICJ0YXJnZXRfY29yZV9wci5oIgorI2luY2x1ZGUgInRhcmdldF9jb3JlX3VhLmgiCisKK2ludCBjb3JlX3Njc2kzX3VhX2NoZWNrKAorCXN0cnVjdCBzZV9jbWQgKmNtZCwKKwl1bnNpZ25lZCBjaGFyICpjZGIpCit7CisJc3RydWN0IHNlX2Rldl9lbnRyeSAqZGV2ZTsKKwlzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqc2VzcyA9IGNtZC0+c2Vfc2VzczsKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKm5hY2w7CisKKwlpZiAoIShzZXNzKSkKKwkJcmV0dXJuIDA7CisKKwluYWNsID0gc2Vzcy0+c2Vfbm9kZV9hY2w7CisJaWYgKCEobmFjbCkpCisJCXJldHVybiAwOworCisJZGV2ZSA9ICZuYWNsLT5kZXZpY2VfbGlzdFtjbWQtPm9yaWdfZmVfbHVuXTsKKwlpZiAoIShhdG9taWNfcmVhZCgmZGV2ZS0+dWFfY291bnQpKSkKKwkJcmV0dXJuIDA7CisJLyoKKwkgKiBGcm9tIHNhbTRyMTQsIHNlY3Rpb24gNS4xNCBVbml0IGF0dGVudGlvbiBjb25kaXRpb246CisJICoKKwkgKiBhKSBpZiBhbiBJTlFVSVJZIGNvbW1hbmQgZW50ZXJzIHRoZSBlbmFibGVkIGNvbW1hbmQgc3RhdGUsIHRoZQorCSAqICAgIGRldmljZSBzZXJ2ZXIgc2hhbGwgcHJvY2VzcyB0aGUgSU5RVUlSWSBjb21tYW5kIGFuZCBzaGFsbCBuZWl0aGVyCisJICogICAgcmVwb3J0IG5vciBjbGVhciBhbnkgdW5pdCBhdHRlbnRpb24gY29uZGl0aW9uOworCSAqIGIpIGlmIGEgUkVQT1JUIExVTlMgY29tbWFuZCBlbnRlcnMgdGhlIGVuYWJsZWQgY29tbWFuZCBzdGF0ZSwgdGhlCisJICogICAgZGV2aWNlIHNlcnZlciBzaGFsbCBwcm9jZXNzIHRoZSBSRVBPUlQgTFVOUyBjb21tYW5kIGFuZCBzaGFsbCBub3QKKwkgKiAgICByZXBvcnQgYW55IHVuaXQgYXR0ZW50aW9uIGNvbmRpdGlvbjsKKwkgKiBlKSBpZiBhIFJFUVVFU1QgU0VOU0UgY29tbWFuZCBlbnRlcnMgdGhlIGVuYWJsZWQgY29tbWFuZCBzdGF0ZSB3aGlsZQorCSAqICAgIGEgdW5pdCBhdHRlbnRpb24gY29uZGl0aW9uIGV4aXN0cyBmb3IgdGhlIFNDU0kgaW5pdGlhdG9yIHBvcnQKKwkgKiAgICBhc3NvY2lhdGVkIHdpdGggdGhlIElfVCBuZXh1cyBvbiB3aGljaCB0aGUgUkVRVUVTVCBTRU5TRSBjb21tYW5kCisJICogICAgd2FzIHJlY2VpdmVkLCB0aGVuIHRoZSBkZXZpY2Ugc2VydmVyIHNoYWxsIHByb2Nlc3MgdGhlIGNvbW1hbmQKKwkgKiAgICBhbmQgZWl0aGVyOgorCSAqLworCXN3aXRjaCAoY2RiWzBdKSB7CisJY2FzZSBJTlFVSVJZOgorCWNhc2UgUkVQT1JUX0xVTlM6CisJY2FzZSBSRVFVRVNUX1NFTlNFOgorCQlyZXR1cm4gMDsKKwlkZWZhdWx0OgorCQlyZXR1cm4gLTE7CisJfQorCisJcmV0dXJuIC0xOworfQorCitpbnQgY29yZV9zY3NpM191YV9hbGxvY2F0ZSgKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKm5hY2wsCisJdTMyIHVucGFja2VkX2x1biwKKwl1OCBhc2MsCisJdTggYXNjcSkKK3sKKwlzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICpkZXZlOworCXN0cnVjdCBzZV91YSAqdWEsICp1YV9wLCAqdWFfdG1wOworCS8qCisJICogUEFTU1RIUk9VR0ggT1BTCisJICovCisJaWYgKCEobmFjbCkpCisJCXJldHVybiAtMTsKKworCXVhID0ga21lbV9jYWNoZV96YWxsb2Moc2VfdWFfY2FjaGUsIEdGUF9BVE9NSUMpOworCWlmICghKHVhKSkgeworCQlwcmludGsoS0VSTl9FUlIgIlVuYWJsZSB0byBhbGxvY2F0ZSBzdHJ1Y3Qgc2VfdWFcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCUlOSVRfTElTVF9IRUFEKCZ1YS0+dWFfZGV2X2xpc3QpOworCUlOSVRfTElTVF9IRUFEKCZ1YS0+dWFfbmFjbF9saXN0KTsKKworCXVhLT51YV9uYWNsID0gbmFjbDsKKwl1YS0+dWFfYXNjID0gYXNjOworCXVhLT51YV9hc2NxID0gYXNjcTsKKworCXNwaW5fbG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCWRldmUgPSAmbmFjbC0+ZGV2aWNlX2xpc3RbdW5wYWNrZWRfbHVuXTsKKworCXNwaW5fbG9jaygmZGV2ZS0+dWFfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHVhX3AsIHVhX3RtcCwgJmRldmUtPnVhX2xpc3QsIHVhX25hY2xfbGlzdCkgeworCQkvKgorCQkgKiBEbyBub3QgcmVwb3J0IHRoZSBzYW1lIFVOSVQgQVRURU5USU9OIHR3aWNlLi4KKwkJICovCisJCWlmICgodWFfcC0+dWFfYXNjID09IGFzYykgJiYgKHVhX3AtPnVhX2FzY3EgPT0gYXNjcSkpIHsKKwkJCXNwaW5fdW5sb2NrKCZkZXZlLT51YV9sb2NrKTsKKwkJCXNwaW5fdW5sb2NrX2lycSgmbmFjbC0+ZGV2aWNlX2xpc3RfbG9jayk7CisJCQlrbWVtX2NhY2hlX2ZyZWUoc2VfdWFfY2FjaGUsIHVhKTsKKwkJCXJldHVybiAwOworCQl9CisJCS8qCisJCSAqIEF0dGFjaCB0aGUgaGlnaGVzdCBwcmlvcml0eSBVbml0IEF0dGVudGlvbiB0bworCQkgKiB0aGUgaGVhZCBvZiB0aGUgbGlzdCBmb2xsb3dpbmcgc2FtNHIxNCwKKwkJICogU2VjdGlvbiA1LjE0IFVuaXQgQXR0ZW50aW9uIENvbmRpdGlvbjoKKwkJICoKKwkJICogUE9XRVIgT04sIFJFU0VULCBPUiBCVVMgREVWSUNFIFJFU0VUIE9DQ1VSUkVEIGhpZ2hlc3QKKwkJICogUE9XRVIgT04gT0NDVVJSRUQgb3IKKwkJICogREVWSUNFIElOVEVSTkFMIFJFU0VUCisJCSAqIFNDU0kgQlVTIFJFU0VUIE9DQ1VSUkVEIG9yCisJCSAqIE1JQ1JPQ09ERSBIQVMgQkVFTiBDSEFOR0VEIG9yCisJCSAqIHByb3RvY29sIHNwZWNpZmljCisJCSAqIEJVUyBERVZJQ0UgUkVTRVQgRlVOQ1RJT04gT0NDVVJSRUQKKwkJICogSV9UIE5FWFVTIExPU1MgT0NDVVJSRUQKKwkJICogQ09NTUFORFMgQ0xFQVJFRCBCWSBQT1dFUiBMT1NTIE5PVElGSUNBVElPTgorCQkgKiBhbGwgb3RoZXJzICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTG93ZXN0CisJCSAqCisJCSAqIEVhY2ggb2YgdGhlIEFTQ1EgY29kZXMgbGlzdGVkIGFib3ZlIGFyZSBkZWZpbmVkIGluCisJCSAqIHRoZSAyOWggQVNDIGZhbWlseSwgc2VlIHNwYzRyMTcgVGFibGUgRC4xCisJCSAqLworCQlpZiAodWFfcC0+dWFfYXNjID09IDB4MjkpIHsKKwkJCWlmICgoYXNjID09IDB4MjkpICYmIChhc2NxID4gdWFfcC0+dWFfYXNjcSkpCisJCQkJbGlzdF9hZGQoJnVhLT51YV9uYWNsX2xpc3QsCisJCQkJCQkmZGV2ZS0+dWFfbGlzdCk7CisJCQllbHNlCisJCQkJbGlzdF9hZGRfdGFpbCgmdWEtPnVhX25hY2xfbGlzdCwKKwkJCQkJCSZkZXZlLT51YV9saXN0KTsKKwkJfSBlbHNlIGlmICh1YV9wLT51YV9hc2MgPT0gMHgyYSkgeworCQkJLyoKKwkJCSAqIEluY29taW5nIEZhbWlseSAyOWggQVNDUSBjb2RlcyB3aWxsIG92ZXJyaWRlCisJCQkgKiBGYW1pbHkgMkFIaCBBU0NRIGNvZGVzIGZvciBVbml0IEF0dGVudGlvbiBjb25kaXRpb24uCisJCQkgKi8KKwkJCWlmICgoYXNjID09IDB4MjkpIHx8IChhc2NxID4gdWFfcC0+dWFfYXNjKSkKKwkJCQlsaXN0X2FkZCgmdWEtPnVhX25hY2xfbGlzdCwKKwkJCQkJJmRldmUtPnVhX2xpc3QpOworCQkJZWxzZQorCQkJCWxpc3RfYWRkX3RhaWwoJnVhLT51YV9uYWNsX2xpc3QsCisJCQkJCQkmZGV2ZS0+dWFfbGlzdCk7CisJCX0gZWxzZQorCQkJbGlzdF9hZGRfdGFpbCgmdWEtPnVhX25hY2xfbGlzdCwKKwkJCQkmZGV2ZS0+dWFfbGlzdCk7CisJCXNwaW5fdW5sb2NrKCZkZXZlLT51YV9sb2NrKTsKKwkJc3Bpbl91bmxvY2tfaXJxKCZuYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKworCQlhdG9taWNfaW5jKCZkZXZlLT51YV9jb3VudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2luYygpOworCQlyZXR1cm4gMDsKKwl9CisJbGlzdF9hZGRfdGFpbCgmdWEtPnVhX25hY2xfbGlzdCwgJmRldmUtPnVhX2xpc3QpOworCXNwaW5fdW5sb2NrKCZkZXZlLT51YV9sb2NrKTsKKwlzcGluX3VubG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCisJcHJpbnRrKEtFUk5fSU5GTyAiWyVzXTogQWxsb2NhdGVkIFVOSVQgQVRURU5USU9OLCBtYXBwZWQgTFVOOiAldSwgQVNDOiIKKwkJIiAweCUwMngsIEFTQ1E6IDB4JTAyeFxuIiwKKwkJVFBHX1RGTyhuYWNsLT5zZV90cGcpLT5nZXRfZmFicmljX25hbWUoKSwgdW5wYWNrZWRfbHVuLAorCQlhc2MsIGFzY3EpOworCisJYXRvbWljX2luYygmZGV2ZS0+dWFfY291bnQpOworCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2luYygpOworCXJldHVybiAwOworfQorCit2b2lkIGNvcmVfc2NzaTNfdWFfcmVsZWFzZV9hbGwoCisJc3RydWN0IHNlX2Rldl9lbnRyeSAqZGV2ZSkKK3sKKwlzdHJ1Y3Qgc2VfdWEgKnVhLCAqdWFfcDsKKworCXNwaW5fbG9jaygmZGV2ZS0+dWFfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHVhLCB1YV9wLCAmZGV2ZS0+dWFfbGlzdCwgdWFfbmFjbF9saXN0KSB7CisJCWxpc3RfZGVsKCZ1YS0+dWFfbmFjbF9saXN0KTsKKwkJa21lbV9jYWNoZV9mcmVlKHNlX3VhX2NhY2hlLCB1YSk7CisKKwkJYXRvbWljX2RlYygmZGV2ZS0+dWFfY291bnQpOworCQlzbXBfbWJfX2FmdGVyX2F0b21pY19kZWMoKTsKKwl9CisJc3Bpbl91bmxvY2soJmRldmUtPnVhX2xvY2spOworfQorCit2b2lkIGNvcmVfc2NzaTNfdWFfZm9yX2NoZWNrX2NvbmRpdGlvbigKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJdTggKmFzYywKKwl1OCAqYXNjcSkKK3sKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpkZXYgPSBTRV9ERVYoY21kKTsKKwlzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICpkZXZlOworCXN0cnVjdCBzZV9zZXNzaW9uICpzZXNzID0gY21kLT5zZV9zZXNzOworCXN0cnVjdCBzZV9ub2RlX2FjbCAqbmFjbDsKKwlzdHJ1Y3Qgc2VfdWEgKnVhID0gTlVMTCwgKnVhX3A7CisJaW50IGhlYWQgPSAxOworCisJaWYgKCEoc2VzcykpCisJCXJldHVybjsKKworCW5hY2wgPSBzZXNzLT5zZV9ub2RlX2FjbDsKKwlpZiAoIShuYWNsKSkKKwkJcmV0dXJuOworCisJc3Bpbl9sb2NrX2lycSgmbmFjbC0+ZGV2aWNlX2xpc3RfbG9jayk7CisJZGV2ZSA9ICZuYWNsLT5kZXZpY2VfbGlzdFtjbWQtPm9yaWdfZmVfbHVuXTsKKwlpZiAoIShhdG9taWNfcmVhZCgmZGV2ZS0+dWFfY291bnQpKSkgeworCQlzcGluX3VubG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCQlyZXR1cm47CisJfQorCS8qCisJICogVGhlIGhpZ2hlc3QgcHJpb3JpdHkgVW5pdCBBdHRlbnRpb25zIGFyZSBwbGFjZWQgYXQgdGhlIGhlYWQgb2YgdGhlCisJICogc3RydWN0IHNlX2Rldl9lbnRyeS0+dWFfbGlzdCwgYW5kIHdpbGwgYmUgcmV0dXJuZWQgaW4gQ0hFQ0tfQ09ORElUSU9OICsKKwkgKiBzZW5zZSBkYXRhIGZvciB0aGUgcmVjZWl2ZWQgQ0RCLgorCSAqLworCXNwaW5fbG9jaygmZGV2ZS0+dWFfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHVhLCB1YV9wLCAmZGV2ZS0+dWFfbGlzdCwgdWFfbmFjbF9saXN0KSB7CisJCS8qCisJCSAqIEZvciB1YV9pbnRsY2tfY3RybCBjb2RlIG5vdCBlcXVhbCB0byAwMGIsIG9ubHkgcmVwb3J0IHRoZQorCQkgKiBoaWdoZXN0IHByaW9yaXR5IFVOSVRfQVRURU5USU9OIGFuZCBBU0MvQVNDUSB3aXRob3V0CisJCSAqIGNsZWFyaW5nIGl0LgorCQkgKi8KKwkJaWYgKERFVl9BVFRSSUIoZGV2KS0+ZW11bGF0ZV91YV9pbnRsY2tfY3RybCAhPSAwKSB7CisJCQkqYXNjID0gdWEtPnVhX2FzYzsKKwkJCSphc2NxID0gdWEtPnVhX2FzY3E7CisJCQlicmVhazsKKwkJfQorCQkvKgorCQkgKiBPdGhlcndpc2UgZm9yIHRoZSBkZWZhdWx0IDAwYiwgcmVsZWFzZSB0aGUgVU5JVCBBVFRFTlRJT04KKwkJICogY29uZGl0aW9uLiAgUmV0dXJuIHRoZSBBU0MvQVNDUSBvZiB0aGUgaGlnZXN0IHByaW9yaXR5IFVBCisJCSAqIChoZWFkIG9mIHRoZSBsaXN0KSBpbiB0aGUgb3V0Z29pbmcgQ0hFQ0tfQ09ORElUSU9OICsgc2Vuc2UuCisJCSAqLworCQlpZiAoaGVhZCkgeworCQkJKmFzYyA9IHVhLT51YV9hc2M7CisJCQkqYXNjcSA9IHVhLT51YV9hc2NxOworCQkJaGVhZCA9IDA7CisJCX0KKwkJbGlzdF9kZWwoJnVhLT51YV9uYWNsX2xpc3QpOworCQlrbWVtX2NhY2hlX2ZyZWUoc2VfdWFfY2FjaGUsIHVhKTsKKworCQlhdG9taWNfZGVjKCZkZXZlLT51YV9jb3VudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworCX0KKwlzcGluX3VubG9jaygmZGV2ZS0+dWFfbG9jayk7CisJc3Bpbl91bmxvY2tfaXJxKCZuYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKworCXByaW50ayhLRVJOX0lORk8gIlslc106ICVzIFVOSVQgQVRURU5USU9OIGNvbmRpdGlvbiB3aXRoIgorCQkiIElOVExDS19DVFJMOiAlZCwgbWFwcGVkIExVTjogJXUsIGdvdCBDREI6IDB4JTAyeCIKKwkJIiByZXBvcnRlZCBBU0M6IDB4JTAyeCwgQVNDUTogMHglMDJ4XG4iLAorCQlUUEdfVEZPKG5hY2wtPnNlX3RwZyktPmdldF9mYWJyaWNfbmFtZSgpLAorCQkoREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3VhX2ludGxja19jdHJsICE9IDApID8gIlJlcG9ydGluZyIgOgorCQkiUmVsZWFzaW5nIiwgREVWX0FUVFJJQihkZXYpLT5lbXVsYXRlX3VhX2ludGxja19jdHJsLAorCQljbWQtPm9yaWdfZmVfbHVuLCBUX1RBU0soY21kKS0+dF90YXNrX2NkYlswXSwgKmFzYywgKmFzY3EpOworfQorCitpbnQgY29yZV9zY3NpM191YV9jbGVhcl9mb3JfcmVxdWVzdF9zZW5zZSgKKwlzdHJ1Y3Qgc2VfY21kICpjbWQsCisJdTggKmFzYywKKwl1OCAqYXNjcSkKK3sKKwlzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICpkZXZlOworCXN0cnVjdCBzZV9zZXNzaW9uICpzZXNzID0gY21kLT5zZV9zZXNzOworCXN0cnVjdCBzZV9ub2RlX2FjbCAqbmFjbDsKKwlzdHJ1Y3Qgc2VfdWEgKnVhID0gTlVMTCwgKnVhX3A7CisJaW50IGhlYWQgPSAxOworCisJaWYgKCEoc2VzcykpCisJCXJldHVybiAtMTsKKworCW5hY2wgPSBzZXNzLT5zZV9ub2RlX2FjbDsKKwlpZiAoIShuYWNsKSkKKwkJcmV0dXJuIC0xOworCisJc3Bpbl9sb2NrX2lycSgmbmFjbC0+ZGV2aWNlX2xpc3RfbG9jayk7CisJZGV2ZSA9ICZuYWNsLT5kZXZpY2VfbGlzdFtjbWQtPm9yaWdfZmVfbHVuXTsKKwlpZiAoIShhdG9taWNfcmVhZCgmZGV2ZS0+dWFfY291bnQpKSkgeworCQlzcGluX3VubG9ja19pcnEoJm5hY2wtPmRldmljZV9saXN0X2xvY2spOworCQlyZXR1cm4gLTE7CisJfQorCS8qCisJICogVGhlIGhpZ2hlc3QgcHJpb3JpdHkgVW5pdCBBdHRlbnRpb25zIGFyZSBwbGFjZWQgYXQgdGhlIGhlYWQgb2YgdGhlCisJICogc3RydWN0IHNlX2Rldl9lbnRyeS0+dWFfbGlzdC4gIFRoZSBGaXJzdCAoYW5kIGhlbmNlIGhpZ2hlc3QgcHJpb3JpdHkpCisJICogQVNDL0FTQ1Egd2lsbCBiZSByZXR1cm5lZCBpbiBSRVFVRVNUX1NFTlNFIHBheWxvYWQgZGF0YSBmb3IgdGhlCisJICogbWF0Y2hpbmcgc3RydWN0IHNlX2x1bi4KKwkgKgorCSAqIE9uY2UgdGhlIHJldHVybmluZyBBU0MvQVNDUSB2YWx1ZXMgYXJlIHNldCwgd2UgZ28gYWhlYWQgYW5kCisJICogcmVsZWFzZSBhbGwgb2YgdGhlIFVuaXQgQXR0ZW50aW9uIGNvbmRpdGlvbnMgZm9yIHRoZSBhc3NvaWNhdGVkCisJICogc3RydWN0IHNlX2x1bi4KKwkgKi8KKwlzcGluX2xvY2soJmRldmUtPnVhX2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSh1YSwgdWFfcCwgJmRldmUtPnVhX2xpc3QsIHVhX25hY2xfbGlzdCkgeworCQlpZiAoaGVhZCkgeworCQkJKmFzYyA9IHVhLT51YV9hc2M7CisJCQkqYXNjcSA9IHVhLT51YV9hc2NxOworCQkJaGVhZCA9IDA7CisJCX0KKwkJbGlzdF9kZWwoJnVhLT51YV9uYWNsX2xpc3QpOworCQlrbWVtX2NhY2hlX2ZyZWUoc2VfdWFfY2FjaGUsIHVhKTsKKworCQlhdG9taWNfZGVjKCZkZXZlLT51YV9jb3VudCk7CisJCXNtcF9tYl9fYWZ0ZXJfYXRvbWljX2RlYygpOworCX0KKwlzcGluX3VubG9jaygmZGV2ZS0+dWFfbG9jayk7CisJc3Bpbl91bmxvY2tfaXJxKCZuYWNsLT5kZXZpY2VfbGlzdF9sb2NrKTsKKworCXByaW50ayhLRVJOX0lORk8gIlslc106IFJlbGVhc2VkIFVOSVQgQVRURU5USU9OIGNvbmRpdGlvbiwgbWFwcGVkIgorCQkiIExVTjogJXUsIGdvdCBSRVFVRVNUX1NFTlNFIHJlcG9ydGVkIEFTQzogMHglMDJ4LCIKKwkJIiBBU0NROiAweCUwMnhcbiIsIFRQR19URk8obmFjbC0+c2VfdHBnKS0+Z2V0X2ZhYnJpY19uYW1lKCksCisJCWNtZC0+b3JpZ19mZV9sdW4sICphc2MsICphc2NxKTsKKworCXJldHVybiAoaGVhZCkgPyAtMSA6IDA7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV91YS5oIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfdWEuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ZTZiMDM0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfdWEuaApAQCAtMCwwICsxLDM2IEBACisjaWZuZGVmIFRBUkdFVF9DT1JFX1VBX0gKKworLyoKKyAqIEZyb20gc3BjNHIxNywgVGFibGUgRC4xOiBBU0MgYW5kIEFTQ1EgQXNzaWduZW1lbnQKKyAqLworI2RlZmluZSBBU0NRXzI5SF9QT1dFUl9PTl9SRVNFVF9PUl9CVVNfREVWSUNFX1JFU0VUX09DQ1VSRUQJMHgwMAorI2RlZmluZSBBU0NRXzI5SF9QT1dFUl9PTl9PQ0NVUlJFRAkJCQkweDAxCisjZGVmaW5lIEFTQ1FfMjlIX1NDU0lfQlVTX1JFU0VUX09DQ1VSRUQJCQkJMHgwMgorI2RlZmluZSBBU0NRXzI5SF9CVVNfREVWSUNFX1JFU0VUX0ZVTkNUSU9OX09DQ1VSUkVECQkweDAzCisjZGVmaW5lIEFTQ1FfMjlIX0RFVklDRV9JTlRFUk5BTF9SRVNFVAkJCQkweDA0CisjZGVmaW5lIEFTQ1FfMjlIX1RSQU5TQ0VJVkVSX01PREVfQ0hBTkdFRF9UT19TSU5HTEVfRU5ERUQJMHgwNQorI2RlZmluZSBBU0NRXzI5SF9UUkFOU0NFSVZFUl9NT0RFX0NIQU5HRURfVE9fTFZECQkweDA2CisjZGVmaW5lIEFTQ1FfMjlIX05FWFVTX0xPU1NfT0NDVVJSRUQJCQkJMHgwNworCisjZGVmaW5lIEFTQ1FfMkFIX1BBUkFNRVRFUlNfQ0hBTkdFRAkJCQkweDAwCisjZGVmaW5lIEFTQ1FfMkFIX01PREVfUEFSQU1FVEVSU19DSEFOR0VECQkJMHgwMQorI2RlZmluZSBBU0NRXzJBSF9MT0dfUEFSQU1FVEVSU19DSEFOR0VECQkJCTB4MDIKKyNkZWZpbmUgQVNDUV8yQUhfUkVTRVJWQVRJT05TX1BSRUVNUFRFRAkJCQkweDAzCisjZGVmaW5lIEFTQ1FfMkFIX1JFU0VSVkFUSU9OU19SRUxFQVNFRAkJCQkweDA0CisjZGVmaW5lIEFTQ1FfMkFIX1JFR0lTVFJBVElPTlNfUFJFRU1QVEVECQkJMHgwNQorI2RlZmluZSBBU0NRXzJBSF9BU1lNTUVUUklDX0FDQ0VTU19TVEFURV9DSEFOR0VECQkweDA2CisjZGVmaW5lIEFTQ1FfMkFIX0lNUExJQ1RfQVNZTU1FVFJJQ19BQ0NFU1NfU1RBVEVfVFJBTlNJVElPTl9GQUlMRUQgMHgwNworI2RlZmluZSBBU0NRXzJBSF9QUklPUklUWV9DSEFOR0VECQkJCTB4MDgKKworI2RlZmluZSBBU0NRXzJDSF9QUkVWSU9VU19SRVNFUlZBVElPTl9DT05GTElDVF9TVEFUVVMJCTB4MDkKKworZXh0ZXJuIHN0cnVjdCBrbWVtX2NhY2hlICpzZV91YV9jYWNoZTsKKworZXh0ZXJuIGludCBjb3JlX3Njc2kzX3VhX2NoZWNrKHN0cnVjdCBzZV9jbWQgKiwgdW5zaWduZWQgY2hhciAqKTsKK2V4dGVybiBpbnQgY29yZV9zY3NpM191YV9hbGxvY2F0ZShzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKiwgdTMyLCB1OCwgdTgpOworZXh0ZXJuIHZvaWQgY29yZV9zY3NpM191YV9yZWxlYXNlX2FsbChzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICopOworZXh0ZXJuIHZvaWQgY29yZV9zY3NpM191YV9mb3JfY2hlY2tfY29uZGl0aW9uKHN0cnVjdCBzZV9jbWQgKiwgdTggKiwgdTggKik7CitleHRlcm4gaW50IGNvcmVfc2NzaTNfdWFfY2xlYXJfZm9yX3JlcXVlc3Rfc2Vuc2Uoc3RydWN0IHNlX2NtZCAqLAorCQkJCQkJdTggKiwgdTggKik7CisKKyNlbmRpZiAvKiBUQVJHRVRfQ09SRV9VQV9IICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3RoZXJtYWwvS2NvbmZpZyBiL2RyaXZlcnMvdGhlcm1hbC9LY29uZmlnCmluZGV4IGJmN2M2ODcuLmY3YTVkYmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdGhlcm1hbC9LY29uZmlnCisrKyBiL2RyaXZlcnMvdGhlcm1hbC9LY29uZmlnCkBAIC00LDYgKzQsNyBAQAogCiBtZW51Y29uZmlnIFRIRVJNQUwKIAl0cmlzdGF0ZSAiR2VuZXJpYyBUaGVybWFsIHN5c2ZzIGRyaXZlciIKKwlkZXBlbmRzIG9uIE5FVAogCWhlbHAKIAkgIEdlbmVyaWMgVGhlcm1hbCBTeXNmcyBkcml2ZXIgb2ZmZXJzIGEgZ2VuZXJpYyBtZWNoYW5pc20gZm9yCiAJICB0aGVybWFsIG1hbmFnZW1lbnQuIFVzdWFsbHkgaXQncyBtYWRlIHVwIG9mIG9uZSBvciBtb3JlIHRoZXJtYWwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGhlcm1hbC90aGVybWFsX3N5cy5jIGIvZHJpdmVycy90aGVybWFsL3RoZXJtYWxfc3lzLmMKaW5kZXggMTNjNzJjNi4uN2QwZTYzYyAxMDA2NDQKLS0tIGEvZHJpdmVycy90aGVybWFsL3RoZXJtYWxfc3lzLmMKKysrIGIvZHJpdmVycy90aGVybWFsL3RoZXJtYWxfc3lzLmMKQEAgLTMyLDYgKzMyLDggQEAKICNpbmNsdWRlIDxsaW51eC90aGVybWFsLmg+CiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KICNpbmNsdWRlIDxsaW51eC9yZWJvb3QuaD4KKyNpbmNsdWRlIDxuZXQvbmV0bGluay5oPgorI2luY2x1ZGUgPG5ldC9nZW5ldGxpbmsuaD4KIAogTU9EVUxFX0FVVEhPUigiWmhhbmcgUnVpIik7CiBNT0RVTEVfREVTQ1JJUFRJT04oIkdlbmVyaWMgdGhlcm1hbCBtYW5hZ2VtZW50IHN5c2ZzIHN1cHBvcnQiKTsKQEAgLTU4LDYgKzYwLDIyIEBACiBzdGF0aWMgTElTVF9IRUFEKHRoZXJtYWxfY2Rldl9saXN0KTsKIHN0YXRpYyBERUZJTkVfTVVURVgodGhlcm1hbF9saXN0X2xvY2spOwogCitzdGF0aWMgdW5zaWduZWQgaW50IHRoZXJtYWxfZXZlbnRfc2VxbnVtOworCitzdGF0aWMgc3RydWN0IGdlbmxfZmFtaWx5IHRoZXJtYWxfZXZlbnRfZ2VubF9mYW1pbHkgPSB7CisJLmlkID0gR0VOTF9JRF9HRU5FUkFURSwKKwkubmFtZSA9IFRIRVJNQUxfR0VOTF9GQU1JTFlfTkFNRSwKKwkudmVyc2lvbiA9IFRIRVJNQUxfR0VOTF9WRVJTSU9OLAorCS5tYXhhdHRyID0gVEhFUk1BTF9HRU5MX0FUVFJfTUFYLAorfTsKKworc3RhdGljIHN0cnVjdCBnZW5sX211bHRpY2FzdF9ncm91cCB0aGVybWFsX2V2ZW50X21jZ3JwID0geworCS5uYW1lID0gVEhFUk1BTF9HRU5MX01DQVNUX0dST1VQX05BTUUsCit9OworCitzdGF0aWMgaW50IGdlbmV0bGlua19pbml0KHZvaWQpOworc3RhdGljIHZvaWQgZ2VuZXRsaW5rX2V4aXQodm9pZCk7CisKIHN0YXRpYyBpbnQgZ2V0X2lkcihzdHJ1Y3QgaWRyICppZHIsIHN0cnVjdCBtdXRleCAqbG9jaywgaW50ICppZCkKIHsKIAlpbnQgZXJyOwpAQCAtODIzLDExICs4NDEsOCBAQAogICogQGRldmRhdGE6CWRldmljZSBwcml2YXRlIGRhdGEuCiAgKiBAb3BzOgkJc3RhbmRhcmQgdGhlcm1hbCBjb29saW5nIGRldmljZXMgY2FsbGJhY2tzLgogICovCi1zdHJ1Y3QgdGhlcm1hbF9jb29saW5nX2RldmljZSAqdGhlcm1hbF9jb29saW5nX2RldmljZV9yZWdpc3RlcihjaGFyICp0eXBlLAotCQkJCQkJCSAgICAgICB2b2lkICpkZXZkYXRhLAotCQkJCQkJCSAgICAgICBzdHJ1Y3QKLQkJCQkJCQkgICAgICAgdGhlcm1hbF9jb29saW5nX2RldmljZV9vcHMKLQkJCQkJCQkgICAgICAgKm9wcykKK3N0cnVjdCB0aGVybWFsX2Nvb2xpbmdfZGV2aWNlICp0aGVybWFsX2Nvb2xpbmdfZGV2aWNlX3JlZ2lzdGVyKAorICAgICBjaGFyICp0eXBlLCB2b2lkICpkZXZkYXRhLCBjb25zdCBzdHJ1Y3QgdGhlcm1hbF9jb29saW5nX2RldmljZV9vcHMgKm9wcykKIHsKIAlzdHJ1Y3QgdGhlcm1hbF9jb29saW5nX2RldmljZSAqY2RldjsKIAlzdHJ1Y3QgdGhlcm1hbF96b25lX2RldmljZSAqcG9zOwpAQCAtMTA0OCwxMyArMTA2Myw5IEBACiAgKiBzZWN0aW9uIDExLjEuNS4xIG9mIHRoZSBBQ1BJIHNwZWNpZmljYXRpb24gMy4wLgogICovCiBzdHJ1Y3QgdGhlcm1hbF96b25lX2RldmljZSAqdGhlcm1hbF96b25lX2RldmljZV9yZWdpc3RlcihjaGFyICp0eXBlLAotCQkJCQkJCSBpbnQgdHJpcHMsCi0JCQkJCQkJIHZvaWQgKmRldmRhdGEsIHN0cnVjdAotCQkJCQkJCSB0aGVybWFsX3pvbmVfZGV2aWNlX29wcwotCQkJCQkJCSAqb3BzLCBpbnQgdGMxLCBpbnQKLQkJCQkJCQkgdGMyLAotCQkJCQkJCSBpbnQgcGFzc2l2ZV9kZWxheSwKLQkJCQkJCQkgaW50IHBvbGxpbmdfZGVsYXkpCisJaW50IHRyaXBzLCB2b2lkICpkZXZkYXRhLAorCWNvbnN0IHN0cnVjdCB0aGVybWFsX3pvbmVfZGV2aWNlX29wcyAqb3BzLAorCWludCB0YzEsIGludCB0YzIsIGludCBwYXNzaXZlX2RlbGF5LCBpbnQgcG9sbGluZ19kZWxheSkKIHsKIAlzdHJ1Y3QgdGhlcm1hbF96b25lX2RldmljZSAqdHo7CiAJc3RydWN0IHRoZXJtYWxfY29vbGluZ19kZXZpY2UgKnBvczsKQEAgLTEyMTQsNiArMTIyNSw4MiBAQAogCiBFWFBPUlRfU1lNQk9MKHRoZXJtYWxfem9uZV9kZXZpY2VfdW5yZWdpc3Rlcik7CiAKK2ludCBnZW5lcmF0ZV9uZXRsaW5rX2V2ZW50KHUzMiBvcmlnLCBlbnVtIGV2ZW50cyBldmVudCkKK3sKKwlzdHJ1Y3Qgc2tfYnVmZiAqc2tiOworCXN0cnVjdCBubGF0dHIgKmF0dHI7CisJc3RydWN0IHRoZXJtYWxfZ2VubF9ldmVudCAqdGhlcm1hbF9ldmVudDsKKwl2b2lkICptc2dfaGVhZGVyOworCWludCBzaXplOworCWludCByZXN1bHQ7CisKKwkvKiBhbGxvY2F0ZSBtZW1vcnkgKi8KKwlzaXplID0gbmxhX3RvdGFsX3NpemUoc2l6ZW9mKHN0cnVjdCB0aGVybWFsX2dlbmxfZXZlbnQpKSArIFwKKwkJCQlubGFfdG90YWxfc2l6ZSgwKTsKKworCXNrYiA9IGdlbmxtc2dfbmV3KHNpemUsIEdGUF9BVE9NSUMpOworCWlmICghc2tiKQorCQlyZXR1cm4gLUVOT01FTTsKKworCS8qIGFkZCB0aGUgZ2VuZXRsaW5rIG1lc3NhZ2UgaGVhZGVyICovCisJbXNnX2hlYWRlciA9IGdlbmxtc2dfcHV0KHNrYiwgMCwgdGhlcm1hbF9ldmVudF9zZXFudW0rKywKKwkJCQkgJnRoZXJtYWxfZXZlbnRfZ2VubF9mYW1pbHksIDAsCisJCQkJIFRIRVJNQUxfR0VOTF9DTURfRVZFTlQpOworCWlmICghbXNnX2hlYWRlcikgeworCQlubG1zZ19mcmVlKHNrYik7CisJCXJldHVybiAtRU5PTUVNOworCX0KKworCS8qIGZpbGwgdGhlIGRhdGEgKi8KKwlhdHRyID0gbmxhX3Jlc2VydmUoc2tiLCBUSEVSTUFMX0dFTkxfQVRUUl9FVkVOVCwgXAorCQkJc2l6ZW9mKHN0cnVjdCB0aGVybWFsX2dlbmxfZXZlbnQpKTsKKworCWlmICghYXR0cikgeworCQlubG1zZ19mcmVlKHNrYik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXRoZXJtYWxfZXZlbnQgPSBubGFfZGF0YShhdHRyKTsKKwlpZiAoIXRoZXJtYWxfZXZlbnQpIHsKKwkJbmxtc2dfZnJlZShza2IpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwltZW1zZXQodGhlcm1hbF9ldmVudCwgMCwgc2l6ZW9mKHN0cnVjdCB0aGVybWFsX2dlbmxfZXZlbnQpKTsKKworCXRoZXJtYWxfZXZlbnQtPm9yaWcgPSBvcmlnOworCXRoZXJtYWxfZXZlbnQtPmV2ZW50ID0gZXZlbnQ7CisKKwkvKiBzZW5kIG11bHRpY2FzdCBnZW5ldGxpbmsgbWVzc2FnZSAqLworCXJlc3VsdCA9IGdlbmxtc2dfZW5kKHNrYiwgbXNnX2hlYWRlcik7CisJaWYgKHJlc3VsdCA8IDApIHsKKwkJbmxtc2dfZnJlZShza2IpOworCQlyZXR1cm4gcmVzdWx0OworCX0KKworCXJlc3VsdCA9IGdlbmxtc2dfbXVsdGljYXN0KHNrYiwgMCwgdGhlcm1hbF9ldmVudF9tY2dycC5pZCwgR0ZQX0FUT01JQyk7CisJaWYgKHJlc3VsdCkKKwkJcHJpbnRrKEtFUk5fSU5GTyAiZmFpbGVkIHRvIHNlbmQgbmV0bGluayBldmVudDolZCIsIHJlc3VsdCk7CisKKwlyZXR1cm4gcmVzdWx0OworfQorRVhQT1JUX1NZTUJPTChnZW5lcmF0ZV9uZXRsaW5rX2V2ZW50KTsKKworc3RhdGljIGludCBnZW5ldGxpbmtfaW5pdCh2b2lkKQoreworCWludCByZXN1bHQ7CisKKwlyZXN1bHQgPSBnZW5sX3JlZ2lzdGVyX2ZhbWlseSgmdGhlcm1hbF9ldmVudF9nZW5sX2ZhbWlseSk7CisJaWYgKHJlc3VsdCkKKwkJcmV0dXJuIHJlc3VsdDsKKworCXJlc3VsdCA9IGdlbmxfcmVnaXN0ZXJfbWNfZ3JvdXAoJnRoZXJtYWxfZXZlbnRfZ2VubF9mYW1pbHksCisJCQkJCSZ0aGVybWFsX2V2ZW50X21jZ3JwKTsKKwlpZiAocmVzdWx0KQorCQlnZW5sX3VucmVnaXN0ZXJfZmFtaWx5KCZ0aGVybWFsX2V2ZW50X2dlbmxfZmFtaWx5KTsKKwlyZXR1cm4gcmVzdWx0OworfQorCiBzdGF0aWMgaW50IF9faW5pdCB0aGVybWFsX2luaXQodm9pZCkKIHsKIAlpbnQgcmVzdWx0ID0gMDsKQEAgLTEyMjUsOSArMTMxMiwxNSBAQAogCQltdXRleF9kZXN0cm95KCZ0aGVybWFsX2lkcl9sb2NrKTsKIAkJbXV0ZXhfZGVzdHJveSgmdGhlcm1hbF9saXN0X2xvY2spOwogCX0KKwlyZXN1bHQgPSBnZW5ldGxpbmtfaW5pdCgpOwogCXJldHVybiByZXN1bHQ7CiB9CiAKK3N0YXRpYyB2b2lkIGdlbmV0bGlua19leGl0KHZvaWQpCit7CisJZ2VubF91bnJlZ2lzdGVyX2ZhbWlseSgmdGhlcm1hbF9ldmVudF9nZW5sX2ZhbWlseSk7Cit9CisKIHN0YXRpYyB2b2lkIF9fZXhpdCB0aGVybWFsX2V4aXQodm9pZCkKIHsKIAljbGFzc191bnJlZ2lzdGVyKCZ0aGVybWFsX2NsYXNzKTsKQEAgLTEyMzUsNyArMTMyOCw4IEBACiAJaWRyX2Rlc3Ryb3koJnRoZXJtYWxfY2Rldl9pZHIpOwogCW11dGV4X2Rlc3Ryb3koJnRoZXJtYWxfaWRyX2xvY2spOwogCW11dGV4X2Rlc3Ryb3koJnRoZXJtYWxfbGlzdF9sb2NrKTsKKwlnZW5ldGxpbmtfZXhpdCgpOwogfQogCi1zdWJzeXNfaW5pdGNhbGwodGhlcm1hbF9pbml0KTsKK2ZzX2luaXRjYWxsKHRoZXJtYWxfaW5pdCk7CiBtb2R1bGVfZXhpdCh0aGVybWFsX2V4aXQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvTWFrZWZpbGUgYi9kcml2ZXJzL3R0eS9NYWtlZmlsZQppbmRleCBjNDNlZjQ4Li4zOTYyNzcyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL3R0eS9NYWtlZmlsZQpAQCAtOSwzICs5LDUgQEAKIG9iai0kKENPTkZJR19SMzk2NCkJCSs9IG5fcjM5NjQubwogCiBvYmoteQkJCQkrPSB2dC8KK29iai0kKENPTkZJR19IVkNfRFJJVkVSKQkrPSBodmMvCitvYmoteQkJCQkrPSBzZXJpYWwvCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9odmMvTWFrZWZpbGUgYi9kcml2ZXJzL3R0eS9odmMvTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDc5ZTdlOQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvdHR5L2h2Yy9NYWtlZmlsZQpAQCAtMCwwICsxLDEyIEBACitvYmotJChDT05GSUdfSFZDX0NPTlNPTEUpCSs9IGh2Y192aW8ubyBodnNpLm8KK29iai0kKENPTkZJR19IVkNfSVNFUklFUykJKz0gaHZjX2lzZXJpZXMubworb2JqLSQoQ09ORklHX0hWQ19SVEFTKQkJKz0gaHZjX3J0YXMubworb2JqLSQoQ09ORklHX0hWQ19USUxFKQkJKz0gaHZjX3RpbGUubworb2JqLSQoQ09ORklHX0hWQ19EQ0MpCQkrPSBodmNfZGNjLm8KK29iai0kKENPTkZJR19IVkNfQkVBVCkJCSs9IGh2Y19iZWF0Lm8KK29iai0kKENPTkZJR19IVkNfRFJJVkVSKQkrPSBodmNfY29uc29sZS5vCitvYmotJChDT05GSUdfSFZDX0lSUSkJCSs9IGh2Y19pcnEubworb2JqLSQoQ09ORklHX0hWQ19YRU4pCQkrPSBodmNfeGVuLm8KK29iai0kKENPTkZJR19IVkNfSVVDVikJCSs9IGh2Y19pdWN2Lm8KK29iai0kKENPTkZJR19IVkNfVURCRykJCSs9IGh2Y191ZGJnLm8KK29iai0kKENPTkZJR19IVkNTKQkJKz0gaHZjcy5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvaHZjX2JlYXQuYyBiL2RyaXZlcnMvdHR5L2h2Yy9odmNfYmVhdC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL2NoYXIvaHZjX2JlYXQuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvaHZjL2h2Y19iZWF0LmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9odmNfY29uc29sZS5jIGIvZHJpdmVycy90dHkvaHZjL2h2Y19jb25zb2xlLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvY2hhci9odmNfY29uc29sZS5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9odmMvaHZjX2NvbnNvbGUuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2h2Y19jb25zb2xlLmggYi9kcml2ZXJzL3R0eS9odmMvaHZjX2NvbnNvbGUuaApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9jaGFyL2h2Y19jb25zb2xlLmgKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L2h2Yy9odmNfY29uc29sZS5oCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvaHZjX2RjYy5jIGIvZHJpdmVycy90dHkvaHZjL2h2Y19kY2MuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9jaGFyL2h2Y19kY2MuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvaHZjL2h2Y19kY2MuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2h2Y19pcnEuYyBiL2RyaXZlcnMvdHR5L2h2Yy9odmNfaXJxLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvY2hhci9odmNfaXJxLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L2h2Yy9odmNfaXJxLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9odmNfaXNlcmllcy5jIGIvZHJpdmVycy90dHkvaHZjL2h2Y19pc2VyaWVzLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvY2hhci9odmNfaXNlcmllcy5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9odmMvaHZjX2lzZXJpZXMuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2h2Y19pdWN2LmMgYi9kcml2ZXJzL3R0eS9odmMvaHZjX2l1Y3YuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9jaGFyL2h2Y19pdWN2LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L2h2Yy9odmNfaXVjdi5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvaHZjX3J0YXMuYyBiL2RyaXZlcnMvdHR5L2h2Yy9odmNfcnRhcy5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL2NoYXIvaHZjX3J0YXMuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvaHZjL2h2Y19ydGFzLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9odmNfdGlsZS5jIGIvZHJpdmVycy90dHkvaHZjL2h2Y190aWxlLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvY2hhci9odmNfdGlsZS5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9odmMvaHZjX3RpbGUuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2h2Y191ZGJnLmMgYi9kcml2ZXJzL3R0eS9odmMvaHZjX3VkYmcuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9jaGFyL2h2Y191ZGJnLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L2h2Yy9odmNfdWRiZy5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvaHZjX3Zpby5jIGIvZHJpdmVycy90dHkvaHZjL2h2Y192aW8uYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9jaGFyL2h2Y192aW8uYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvaHZjL2h2Y192aW8uYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2h2Y194ZW4uYyBiL2RyaXZlcnMvdHR5L2h2Yy9odmNfeGVuLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvY2hhci9odmNfeGVuLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L2h2Yy9odmNfeGVuLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9odmNzLmMgYi9kcml2ZXJzL3R0eS9odmMvaHZjcy5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL2NoYXIvaHZjcy5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9odmMvaHZjcy5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvaHZzaS5jIGIvZHJpdmVycy90dHkvaHZjL2h2c2kuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9jaGFyL2h2c2kuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvaHZjL2h2c2kuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvbl9nc20uYyBiL2RyaXZlcnMvdHR5L25fZ3NtLmMKaW5kZXggNDRiODQxMi4uYWEyZTVkMyAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvbl9nc20uYworKysgYi9kcml2ZXJzL3R0eS9uX2dzbS5jCkBAIC0yNDE0LDYgKzI0MTQsNyBAQAogCiAJZ3NtLT5pbml0aWF0b3IgPSBjLT5pbml0aWF0b3I7CiAJZ3NtLT5tcnUgPSBjLT5tcnU7CisJZ3NtLT5tdHUgPSBjLT5tdHU7CiAJZ3NtLT5lbmNvZGluZyA9IGMtPmVuY2Fwc3VsYXRpb247CiAJZ3NtLT5hZGFwdGlvbiA9IGMtPmFkYXB0aW9uOwogCWdzbS0+bjIgPSBjLT5uMjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L25faGRsYy5jIGIvZHJpdmVycy90dHkvbl9oZGxjLmMKaW5kZXggNDdkMzIyOC4uNTJmYzBjOSAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvbl9oZGxjLmMKKysrIGIvZHJpdmVycy90dHkvbl9oZGxjLmMKQEAgLTU4MSw4ICs1ODEsOSBAQAogCQkJICAgX191OCBfX3VzZXIgKmJ1Ziwgc2l6ZV90IG5yKQogewogCXN0cnVjdCBuX2hkbGMgKm5faGRsYyA9IHR0eTJuX2hkbGModHR5KTsKLQlpbnQgcmV0OworCWludCByZXQgPSAwOwogCXN0cnVjdCBuX2hkbGNfYnVmICpyYnVmOworCURFQ0xBUkVfV0FJVFFVRVVFKHdhaXQsIGN1cnJlbnQpOwogCiAJaWYgKGRlYnVnbGV2ZWwgPj0gREVCVUdfTEVWRUxfSU5GTykJCiAJCXByaW50aygiJXMoJWQpbl9oZGxjX3R0eV9yZWFkKCkgY2FsbGVkXG4iLF9fRklMRV9fLF9fTElORV9fKTsKQEAgLTU5OCw1NyArNTk5LDU1IEBACiAJCXJldHVybiAtRUZBVUxUOwogCX0KIAotCXR0eV9sb2NrKCk7CisJYWRkX3dhaXRfcXVldWUoJnR0eS0+cmVhZF93YWl0LCAmd2FpdCk7CiAKIAlmb3IgKDs7KSB7CiAJCWlmICh0ZXN0X2JpdChUVFlfT1RIRVJfQ0xPU0VELCAmdHR5LT5mbGFncykpIHsKLQkJCXR0eV91bmxvY2soKTsKLQkJCXJldHVybiAtRUlPOworCQkJcmV0ID0gLUVJTzsKKwkJCWJyZWFrOwogCQl9CisJCWlmICh0dHlfaHVuZ191cF9wKGZpbGUpKQorCQkJYnJlYWs7CiAKLQkJbl9oZGxjID0gdHR5Mm5faGRsYyAodHR5KTsKLQkJaWYgKCFuX2hkbGMgfHwgbl9oZGxjLT5tYWdpYyAhPSBIRExDX01BR0lDIHx8Ci0JCQkgdHR5ICE9IG5faGRsYy0+dHR5KSB7Ci0JCQl0dHlfdW5sb2NrKCk7Ci0JCQlyZXR1cm4gMDsKLQkJfQorCQlzZXRfY3VycmVudF9zdGF0ZShUQVNLX0lOVEVSUlVQVElCTEUpOwogCiAJCXJidWYgPSBuX2hkbGNfYnVmX2dldCgmbl9oZGxjLT5yeF9idWZfbGlzdCk7Ci0JCWlmIChyYnVmKQorCQlpZiAocmJ1ZikgeworCQkJaWYgKHJidWYtPmNvdW50ID4gbnIpIHsKKwkJCQkvKiB0b28gbGFyZ2UgZm9yIGNhbGxlcidzIGJ1ZmZlciAqLworCQkJCXJldCA9IC1FT1ZFUkZMT1c7CisJCQl9IGVsc2UgeworCQkJCWlmIChjb3B5X3RvX3VzZXIoYnVmLCByYnVmLT5idWYsIHJidWYtPmNvdW50KSkKKwkJCQkJcmV0ID0gLUVGQVVMVDsKKwkJCQllbHNlCisJCQkJCXJldCA9IHJidWYtPmNvdW50OworCQkJfQorCisJCQlpZiAobl9oZGxjLT5yeF9mcmVlX2J1Zl9saXN0LmNvdW50ID4KKwkJCSAgICBERUZBVUxUX1JYX0JVRl9DT1VOVCkKKwkJCQlrZnJlZShyYnVmKTsKKwkJCWVsc2UKKwkJCQluX2hkbGNfYnVmX3B1dCgmbl9oZGxjLT5yeF9mcmVlX2J1Zl9saXN0LCByYnVmKTsKIAkJCWJyZWFrOworCQl9CiAJCQkKIAkJLyogbm8gZGF0YSAqLwogCQlpZiAoZmlsZS0+Zl9mbGFncyAmIE9fTk9OQkxPQ0spIHsKLQkJCXR0eV91bmxvY2soKTsKLQkJCXJldHVybiAtRUFHQUlOOworCQkJcmV0ID0gLUVBR0FJTjsKKwkJCWJyZWFrOwogCQl9Ci0JCQkKLQkJaW50ZXJydXB0aWJsZV9zbGVlcF9vbiAoJnR0eS0+cmVhZF93YWl0KTsKKworCQlzY2hlZHVsZSgpOworCiAJCWlmIChzaWduYWxfcGVuZGluZyhjdXJyZW50KSkgewotCQkJdHR5X3VubG9jaygpOwotCQkJcmV0dXJuIC1FSU5UUjsKKwkJCXJldCA9IC1FSU5UUjsKKwkJCWJyZWFrOwogCQl9CiAJfQotCQkKLQlpZiAocmJ1Zi0+Y291bnQgPiBucikKLQkJLyogZnJhbWUgdG9vIGxhcmdlIGZvciBjYWxsZXIncyBidWZmZXIgKGRpc2NhcmQgZnJhbWUpICovCi0JCXJldCA9IC1FT1ZFUkZMT1c7Ci0JZWxzZSB7Ci0JCS8qIENvcHkgdGhlIGRhdGEgdG8gdGhlIGNhbGxlcidzIGJ1ZmZlciAqLwotCQlpZiAoY29weV90b191c2VyKGJ1ZiwgcmJ1Zi0+YnVmLCByYnVmLT5jb3VudCkpCi0JCQlyZXQgPSAtRUZBVUxUOwotCQllbHNlCi0JCQlyZXQgPSByYnVmLT5jb3VudDsKLQl9Ci0JCi0JLyogcmV0dXJuIEhETEMgYnVmZmVyIHRvIGZyZWUgbGlzdCB1bmxlc3MgdGhlIGZyZWUgbGlzdCAqLwotCS8qIGNvdW50IGhhcyBleGNlZWRlZCB0aGUgZGVmYXVsdCB2YWx1ZSwgaW4gd2hpY2ggY2FzZSB0aGUgKi8KLQkvKiBidWZmZXIgaXMgZnJlZWQgYmFjayB0byB0aGUgT1MgdG8gY29uc2VydmUgbWVtb3J5ICovCi0JaWYgKG5faGRsYy0+cnhfZnJlZV9idWZfbGlzdC5jb3VudCA+IERFRkFVTFRfUlhfQlVGX0NPVU5UKQotCQlrZnJlZShyYnVmKTsKLQllbHNlCQotCQluX2hkbGNfYnVmX3B1dCgmbl9oZGxjLT5yeF9mcmVlX2J1Zl9saXN0LHJidWYpOwotCXR0eV91bmxvY2soKTsKKworCXJlbW92ZV93YWl0X3F1ZXVlKCZ0dHktPnJlYWRfd2FpdCwgJndhaXQpOworCV9fc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19SVU5OSU5HKTsKKwogCXJldHVybiByZXQ7CiAJCiB9CS8qIGVuZCBvZiBuX2hkbGNfdHR5X3JlYWQoKSAqLwpAQCAtNjkxLDE0ICs2OTAsMTUgQEAKIAkJY291bnQgPSBtYXhmcmFtZTsKIAl9CiAJCi0JdHR5X2xvY2soKTsKLQogCWFkZF93YWl0X3F1ZXVlKCZ0dHktPndyaXRlX3dhaXQsICZ3YWl0KTsKLQlzZXRfY3VycmVudF9zdGF0ZShUQVNLX0lOVEVSUlVQVElCTEUpOworCisJZm9yICg7OykgeworCQlzZXRfY3VycmVudF9zdGF0ZShUQVNLX0lOVEVSUlVQVElCTEUpOwogCQotCS8qIEFsbG9jYXRlIHRyYW5zbWl0IGJ1ZmZlciAqLwotCS8qIHNsZWVwIHVudGlsIHRyYW5zbWl0IGJ1ZmZlciBhdmFpbGFibGUgKi8JCQotCXdoaWxlICghKHRidWYgPSBuX2hkbGNfYnVmX2dldCgmbl9oZGxjLT50eF9mcmVlX2J1Zl9saXN0KSkpIHsKKwkJdGJ1ZiA9IG5faGRsY19idWZfZ2V0KCZuX2hkbGMtPnR4X2ZyZWVfYnVmX2xpc3QpOworCQlpZiAodGJ1ZikKKwkJCWJyZWFrOworCiAJCWlmIChmaWxlLT5mX2ZsYWdzICYgT19OT05CTE9DSykgewogCQkJZXJyb3IgPSAtRUFHQUlOOwogCQkJYnJlYWs7CkBAIC03MTksNyArNzE5LDcgQEAKIAkJfQogCX0KIAotCXNldF9jdXJyZW50X3N0YXRlKFRBU0tfUlVOTklORyk7CisJX19zZXRfY3VycmVudF9zdGF0ZShUQVNLX1JVTk5JTkcpOwogCXJlbW92ZV93YWl0X3F1ZXVlKCZ0dHktPndyaXRlX3dhaXQsICZ3YWl0KTsKIAogCWlmICghZXJyb3IpIHsJCQpAQCAtNzMxLDcgKzczMSw3IEBACiAJCW5faGRsY19idWZfcHV0KCZuX2hkbGMtPnR4X2J1Zl9saXN0LHRidWYpOwogCQluX2hkbGNfc2VuZF9mcmFtZXMobl9oZGxjLHR0eSk7CiAJfQotCXR0eV91bmxvY2soKTsKKwogCXJldHVybiBlcnJvcjsKIAkKIH0JLyogZW5kIG9mIG5faGRsY190dHlfd3JpdGUoKSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvMjEyODUuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC8yMTI4NS5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC8yMTI4NS5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvMjEyODUuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvNjgzMjhzZXJpYWwuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC82ODMyOHNlcmlhbC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC82ODMyOHNlcmlhbC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvNjgzMjhzZXJpYWwuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvNjgzMjhzZXJpYWwuaCBiL2RyaXZlcnMvdHR5L3NlcmlhbC82ODMyOHNlcmlhbC5oCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC82ODMyOHNlcmlhbC5oCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvNjgzMjhzZXJpYWwuaApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvNjgzNjBzZXJpYWwuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC82ODM2MHNlcmlhbC5jCnNpbWlsYXJpdHkgaW5kZXggOTklCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsLzY4MzYwc2VyaWFsLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC82ODM2MHNlcmlhbC5jCmluZGV4IDg4YjEzMzUuLmJjMjFlZWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2VyaWFsLzY4MzYwc2VyaWFsLmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsLzY4MzYwc2VyaWFsLmMKQEAgLTI0MjgsNiArMjQyOCw3IEBACiAJLyogLnJlYWRfcHJvYyA9IHJzXzM2MF9yZWFkX3Byb2MsICovCiAJLnRpb2NtZ2V0ID0gcnNfMzYwX3Rpb2NtZ2V0LAogCS50aW9jbXNldCA9IHJzXzM2MF90aW9jbXNldCwKKwkuZ2V0X2ljb3VudCA9IHJzXzM2MF9nZXRfaWNvdW50LAogfTsKIAogc3RhdGljIGludCBfX2luaXQgcnNfMzYwX2luaXQodm9pZCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsLzgyNTAuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC84MjUwLmMKc2ltaWxhcml0eSBpbmRleCA5OSUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvODI1MC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvODI1MC5jCmluZGV4IGIyNWU2ZTQuLjM5NzVkZjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2VyaWFsLzgyNTAuYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvODI1MC5jCkBAIC0yMzYsNyArMjM2LDggQEAKIAkJLmZpZm9fc2l6ZQk9IDEyOCwKIAkJLnR4X2xvYWRzegk9IDEyOCwKIAkJLmZjcgkJPSBVQVJUX0ZDUl9FTkFCTEVfRklGTyB8IFVBUlRfRkNSX1JfVFJJR18xMCwKLQkJLmZsYWdzCQk9IFVBUlRfQ0FQX0ZJRk8gfCBVQVJUX0NBUF9FRlIgfCBVQVJUX0NBUF9TTEVFUCwKKwkJLyogVUFSVF9DQVBfRUZSIGJyZWFrcyBiaWxsaW9ub24gQ0YgYmx1ZXRvb3RoIGNhcmQuICovCisJCS5mbGFncwkJPSBVQVJUX0NBUF9GSUZPIHwgVUFSVF9DQVBfU0xFRVAsCiAJfSwKIAlbUE9SVF8xNjY1NF0gPSB7CiAJCS5uYW1lCQk9ICJTVDE2NjU0IiwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsLzgyNTAuaCBiL2RyaXZlcnMvdHR5L3NlcmlhbC84MjUwLmgKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsLzgyNTAuaApyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsLzgyNTAuaApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvODI1MF9hY2NlbnQuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC84MjUwX2FjY2VudC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC84MjUwX2FjY2VudC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvODI1MF9hY2NlbnQuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvODI1MF9hY29ybi5jIGIvZHJpdmVycy90dHkvc2VyaWFsLzgyNTBfYWNvcm4uYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvODI1MF9hY29ybi5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvODI1MF9hY29ybi5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC84MjUwX2JvY2EuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC84MjUwX2JvY2EuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvODI1MF9ib2NhLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC84MjUwX2JvY2EuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvODI1MF9lYXJseS5jIGIvZHJpdmVycy90dHkvc2VyaWFsLzgyNTBfZWFybHkuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvODI1MF9lYXJseS5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvODI1MF9lYXJseS5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC84MjUwX2V4YXJfc3QxNmM1NTQuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC84MjUwX2V4YXJfc3QxNmM1NTQuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvODI1MF9leGFyX3N0MTZjNTU0LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC84MjUwX2V4YXJfc3QxNmM1NTQuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvODI1MF9mb3VycG9ydC5jIGIvZHJpdmVycy90dHkvc2VyaWFsLzgyNTBfZm91cnBvcnQuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvODI1MF9mb3VycG9ydC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvODI1MF9mb3VycG9ydC5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC84MjUwX2dzYy5jIGIvZHJpdmVycy90dHkvc2VyaWFsLzgyNTBfZ3NjLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsLzgyNTBfZ3NjLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC84MjUwX2dzYy5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC84MjUwX2hwMzAwLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvODI1MF9ocDMwMC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC84MjUwX2hwMzAwLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC84MjUwX2hwMzAwLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsLzgyNTBfaHViNi5jIGIvZHJpdmVycy90dHkvc2VyaWFsLzgyNTBfaHViNi5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC84MjUwX2h1YjYuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsLzgyNTBfaHViNi5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC84MjUwX21jYS5jIGIvZHJpdmVycy90dHkvc2VyaWFsLzgyNTBfbWNhLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsLzgyNTBfbWNhLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC84MjUwX21jYS5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC84MjUwX3BjaS5jIGIvZHJpdmVycy90dHkvc2VyaWFsLzgyNTBfcGNpLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsLzgyNTBfcGNpLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC84MjUwX3BjaS5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC84MjUwX3BucC5jIGIvZHJpdmVycy90dHkvc2VyaWFsLzgyNTBfcG5wLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsLzgyNTBfcG5wLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC84MjUwX3BucC5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9LY29uZmlnIGIvZHJpdmVycy90dHkvc2VyaWFsL0tjb25maWcKc2ltaWxhcml0eSBpbmRleCA5OSUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvS2NvbmZpZwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL0tjb25maWcKaW5kZXggYzFkZjc2Ny4uMmI4MzM0NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zZXJpYWwvS2NvbmZpZworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvS2NvbmZpZwpAQCAtODEsNyArODEsNyBAQAogCWRlZmF1bHQgU0VSSUFMXzgyNTAKIAogY29uZmlnIFNFUklBTF84MjUwX1BDSQotCXRyaXN0YXRlICI4MjUwLzE2NTUwIFBDSSBkZXZpY2Ugc3VwcG9ydCIgaWYgRU1CRURERUQKKwl0cmlzdGF0ZSAiODI1MC8xNjU1MCBQQ0kgZGV2aWNlIHN1cHBvcnQiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gU0VSSUFMXzgyNTAgJiYgUENJCiAJZGVmYXVsdCBTRVJJQUxfODI1MAogCWhlbHAKQEAgLTkwLDcgKzkwLDcgQEAKIAkgIFNhdmVzIGFib3V0IDlLLgogCiBjb25maWcgU0VSSUFMXzgyNTBfUE5QCi0JdHJpc3RhdGUgIjgyNTAvMTY1NTAgUE5QIGRldmljZSBzdXBwb3J0IiBpZiBFTUJFRERFRAorCXRyaXN0YXRlICI4MjUwLzE2NTUwIFBOUCBkZXZpY2Ugc3VwcG9ydCIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBTRVJJQUxfODI1MCAmJiBQTlAKIAlkZWZhdWx0IFNFUklBTF84MjUwCiAJaGVscApAQCAtMTUxOCw2ICsxNTE4LDcgQEAKIGNvbmZpZyBTRVJJQUxfR1JMSUJfR0FJU0xFUl9BUEJVQVJUCiAJdHJpc3RhdGUgIkdSTElCIEFQQlVBUlQgc2VyaWFsIHN1cHBvcnQiCiAJZGVwZW5kcyBvbiBPRgorCXNlbGVjdCBTRVJJQUxfQ09SRQogCS0tLWhlbHAtLS0KIAlBZGQgc3VwcG9ydCBmb3IgdGhlIEdSTElCIEFQQlVBUlQgc2VyaWFsIHBvcnQuCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL01ha2VmaWxlIGIvZHJpdmVycy90dHkvc2VyaWFsL01ha2VmaWxlCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9NYWtlZmlsZQpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL01ha2VmaWxlCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9hbHRlcmFfanRhZ3VhcnQuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9hbHRlcmFfanRhZ3VhcnQuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvYWx0ZXJhX2p0YWd1YXJ0LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9hbHRlcmFfanRhZ3VhcnQuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvYWx0ZXJhX3VhcnQuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9hbHRlcmFfdWFydC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9hbHRlcmFfdWFydC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvYWx0ZXJhX3VhcnQuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvYW1iYS1wbDAxMC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL2FtYmEtcGwwMTAuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvYW1iYS1wbDAxMC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvYW1iYS1wbDAxMC5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9hbWJhLXBsMDExLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvYW1iYS1wbDAxMS5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9hbWJhLXBsMDExLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9hbWJhLXBsMDExLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL2FwYnVhcnQuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9hcGJ1YXJ0LmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL2FwYnVhcnQuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL2FwYnVhcnQuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvYXBidWFydC5oIGIvZHJpdmVycy90dHkvc2VyaWFsL2FwYnVhcnQuaApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvYXBidWFydC5oCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvYXBidWFydC5oCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9hdG1lbF9zZXJpYWwuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9hdG1lbF9zZXJpYWwuYwpzaW1pbGFyaXR5IGluZGV4IDk5JQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9hdG1lbF9zZXJpYWwuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL2F0bWVsX3NlcmlhbC5jCmluZGV4IDM4OTI2NjYuLjJhMWQ1MmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2VyaWFsL2F0bWVsX3NlcmlhbC5jCisrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9hdG1lbF9zZXJpYWwuYwpAQCAtMTczMiw2ICsxNzMyLDExIEBACiAJZGV2aWNlX2luaXRfd2FrZXVwKCZwZGV2LT5kZXYsIDEpOwogCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIHBvcnQpOwogCisJaWYgKHBvcnQtPnJzNDg1LmZsYWdzICYgU0VSX1JTNDg1X0VOQUJMRUQpIHsKKwkJVUFSVF9QVVRfTVIoJnBvcnQtPnVhcnQsIEFUTUVMX1VTX1VTTU9ERV9OT1JNQUwpOworCQlVQVJUX1BVVF9DUigmcG9ydC0+dWFydCwgQVRNRUxfVVNfUlRTRU4pOworCX0KKwogCXJldHVybiAwOwogCiBlcnJfYWRkX3BvcnQ6CmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9iY202M3h4X3VhcnQuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9iY202M3h4X3VhcnQuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvYmNtNjN4eF91YXJ0LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9iY202M3h4X3VhcnQuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvYmZpbl81eHguYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9iZmluXzV4eC5jCnNpbWlsYXJpdHkgaW5kZXggOTglCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL2JmaW5fNXh4LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9iZmluXzV4eC5jCmluZGV4IGUzODFiODkuLjliMWZmMmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2VyaWFsL2JmaW5fNXh4LmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL2JmaW5fNXh4LmMKQEAgLTM3MCwxMCArMzcwLDggQEAKIHsKIAlzdHJ1Y3QgYmZpbl9zZXJpYWxfcG9ydCAqdWFydCA9IGRldl9pZDsKIAotCXNwaW5fbG9jaygmdWFydC0+cG9ydC5sb2NrKTsKIAl3aGlsZSAoVUFSVF9HRVRfTFNSKHVhcnQpICYgRFIpCiAJCWJmaW5fc2VyaWFsX3J4X2NoYXJzKHVhcnQpOwotCXNwaW5fdW5sb2NrKCZ1YXJ0LT5wb3J0LmxvY2spOwogCiAJcmV0dXJuIElSUV9IQU5ETEVEOwogfQpAQCAtNDkwLDkgKzQ4OCw4IEBACiB7CiAJaW50IHhfcG9zLCBwb3M7CiAKLQlkbWFfZGlzYWJsZV9pcnEodWFydC0+dHhfZG1hX2NoYW5uZWwpOwotCWRtYV9kaXNhYmxlX2lycSh1YXJ0LT5yeF9kbWFfY2hhbm5lbCk7Ci0Jc3Bpbl9sb2NrX2JoKCZ1YXJ0LT5wb3J0LmxvY2spOworCWRtYV9kaXNhYmxlX2lycV9ub3N5bmModWFydC0+cnhfZG1hX2NoYW5uZWwpOworCXNwaW5fbG9ja19iaCgmdWFydC0+cnhfbG9jayk7CiAKIAkvKiAyRCBETUEgUlggYnVmZmVyIHJpbmcgaXMgdXNlZC4gQmVjYXVzZSBjdXJyX3lfY291bnQgYW5kCiAJICogY3Vycl94X2NvdW50IGNhbid0IGJlIHJlYWQgYXMgYW4gYXRvbWljIG9wZXJhdGlvbiwKQEAgLTUyMyw4ICs1MjAsNyBAQAogCQl1YXJ0LT5yeF9kbWFfYnVmLnRhaWwgPSB1YXJ0LT5yeF9kbWFfYnVmLmhlYWQ7CiAJfQogCi0Jc3Bpbl91bmxvY2tfYmgoJnVhcnQtPnBvcnQubG9jayk7Ci0JZG1hX2VuYWJsZV9pcnEodWFydC0+dHhfZG1hX2NoYW5uZWwpOworCXNwaW5fdW5sb2NrX2JoKCZ1YXJ0LT5yeF9sb2NrKTsKIAlkbWFfZW5hYmxlX2lycSh1YXJ0LT5yeF9kbWFfY2hhbm5lbCk7CiAKIAltb2RfdGltZXIoJih1YXJ0LT5yeF9kbWFfdGltZXIpLCBqaWZmaWVzICsgRE1BX1JYX0ZMVVNIX0pJRkZJRVMpOwpAQCAtNTcxLDcgKzU2Nyw3IEBACiAJdW5zaWduZWQgc2hvcnQgaXJxc3RhdDsKIAlpbnQgeF9wb3MsIHBvczsKIAotCXNwaW5fbG9jaygmdWFydC0+cG9ydC5sb2NrKTsKKwlzcGluX2xvY2soJnVhcnQtPnJ4X2xvY2spOwogCWlycXN0YXQgPSBnZXRfZG1hX2N1cnJfaXJxc3RhdCh1YXJ0LT5yeF9kbWFfY2hhbm5lbCk7CiAJY2xlYXJfZG1hX2lycXN0YXQodWFydC0+cnhfZG1hX2NoYW5uZWwpOwogCkBAIC01ODksNyArNTg1LDcgQEAKIAkJdWFydC0+cnhfZG1hX2J1Zi50YWlsID0gdWFydC0+cnhfZG1hX2J1Zi5oZWFkOwogCX0KIAotCXNwaW5fdW5sb2NrKCZ1YXJ0LT5wb3J0LmxvY2spOworCXNwaW5fdW5sb2NrKCZ1YXJ0LT5yeF9sb2NrKTsKIAogCXJldHVybiBJUlFfSEFORExFRDsKIH0KQEAgLTEzMzIsNiArMTMyOCw3IEBACiAJCX0KIAogI2lmZGVmIENPTkZJR19TRVJJQUxfQkZJTl9ETUEKKwkJc3Bpbl9sb2NrX2luaXQoJnVhcnQtPnJ4X2xvY2spOwogCQl1YXJ0LT50eF9kb25lCSAgICA9IDE7CiAJCXVhcnQtPnR4X2NvdW50CSAgICA9IDA7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL2JmaW5fc3BvcnRfdWFydC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL2JmaW5fc3BvcnRfdWFydC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9iZmluX3Nwb3J0X3VhcnQuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL2JmaW5fc3BvcnRfdWFydC5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9iZmluX3Nwb3J0X3VhcnQuaCBiL2RyaXZlcnMvdHR5L3NlcmlhbC9iZmluX3Nwb3J0X3VhcnQuaApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvYmZpbl9zcG9ydF91YXJ0LmgKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9iZmluX3Nwb3J0X3VhcnQuaApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvY2xwczcxMXguYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9jbHBzNzExeC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9jbHBzNzExeC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvY2xwczcxMXguYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvY3BtX3VhcnQvTWFrZWZpbGUgYi9kcml2ZXJzL3R0eS9zZXJpYWwvY3BtX3VhcnQvTWFrZWZpbGUKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL2NwbV91YXJ0L01ha2VmaWxlCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvY3BtX3VhcnQvTWFrZWZpbGUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL2NwbV91YXJ0L2NwbV91YXJ0LmggYi9kcml2ZXJzL3R0eS9zZXJpYWwvY3BtX3VhcnQvY3BtX3VhcnQuaApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvY3BtX3VhcnQvY3BtX3VhcnQuaApyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL2NwbV91YXJ0L2NwbV91YXJ0LmgKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL2NwbV91YXJ0L2NwbV91YXJ0X2NvcmUuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9jcG1fdWFydC9jcG1fdWFydF9jb3JlLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL2NwbV91YXJ0L2NwbV91YXJ0X2NvcmUuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL2NwbV91YXJ0L2NwbV91YXJ0X2NvcmUuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvY3BtX3VhcnQvY3BtX3VhcnRfY3BtMS5jIGIvZHJpdmVycy90dHkvc2VyaWFsL2NwbV91YXJ0L2NwbV91YXJ0X2NwbTEuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvY3BtX3VhcnQvY3BtX3VhcnRfY3BtMS5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvY3BtX3VhcnQvY3BtX3VhcnRfY3BtMS5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9jcG1fdWFydC9jcG1fdWFydF9jcG0xLmggYi9kcml2ZXJzL3R0eS9zZXJpYWwvY3BtX3VhcnQvY3BtX3VhcnRfY3BtMS5oCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9jcG1fdWFydC9jcG1fdWFydF9jcG0xLmgKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9jcG1fdWFydC9jcG1fdWFydF9jcG0xLmgKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL2NwbV91YXJ0L2NwbV91YXJ0X2NwbTIuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9jcG1fdWFydC9jcG1fdWFydF9jcG0yLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL2NwbV91YXJ0L2NwbV91YXJ0X2NwbTIuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL2NwbV91YXJ0L2NwbV91YXJ0X2NwbTIuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvY3BtX3VhcnQvY3BtX3VhcnRfY3BtMi5oIGIvZHJpdmVycy90dHkvc2VyaWFsL2NwbV91YXJ0L2NwbV91YXJ0X2NwbTIuaApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvY3BtX3VhcnQvY3BtX3VhcnRfY3BtMi5oCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvY3BtX3VhcnQvY3BtX3VhcnRfY3BtMi5oCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9jcmlzdjEwLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvY3Jpc3YxMC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9jcmlzdjEwLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9jcmlzdjEwLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL2NyaXN2MTAuaCBiL2RyaXZlcnMvdHR5L3NlcmlhbC9jcmlzdjEwLmgKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL2NyaXN2MTAuaApyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL2NyaXN2MTAuaApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvZHouYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9kei5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9kei5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvZHouYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvZHouaCBiL2RyaXZlcnMvdHR5L3NlcmlhbC9kei5oCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9kei5oCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvZHouaApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvaWNvbS5jIGIvZHJpdmVycy90dHkvc2VyaWFsL2ljb20uYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvaWNvbS5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvaWNvbS5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9pY29tLmggYi9kcml2ZXJzL3R0eS9zZXJpYWwvaWNvbS5oCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9pY29tLmgKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9pY29tLmgKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL2lmeDZ4NjAuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9pZng2eDYwLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL2lmeDZ4NjAuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL2lmeDZ4NjAuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvaWZ4Nng2MC5oIGIvZHJpdmVycy90dHkvc2VyaWFsL2lmeDZ4NjAuaApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvaWZ4Nng2MC5oCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvaWZ4Nng2MC5oCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9pbXguYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9pbXguYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvaW14LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9pbXguYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvaW9jM19zZXJpYWwuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9pb2MzX3NlcmlhbC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9pb2MzX3NlcmlhbC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvaW9jM19zZXJpYWwuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvaW9jNF9zZXJpYWwuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9pb2M0X3NlcmlhbC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9pb2M0X3NlcmlhbC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvaW9jNF9zZXJpYWwuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvaXAyMnppbG9nLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvaXAyMnppbG9nLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL2lwMjJ6aWxvZy5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvaXAyMnppbG9nLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL2lwMjJ6aWxvZy5oIGIvZHJpdmVycy90dHkvc2VyaWFsL2lwMjJ6aWxvZy5oCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9pcDIyemlsb2cuaApyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL2lwMjJ6aWxvZy5oCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9qc20vTWFrZWZpbGUgYi9kcml2ZXJzL3R0eS9zZXJpYWwvanNtL01ha2VmaWxlCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9qc20vTWFrZWZpbGUKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9qc20vTWFrZWZpbGUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL2pzbS9qc20uaCBiL2RyaXZlcnMvdHR5L3NlcmlhbC9qc20vanNtLmgKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL2pzbS9qc20uaApyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL2pzbS9qc20uaApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvanNtL2pzbV9kcml2ZXIuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9qc20vanNtX2RyaXZlci5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9qc20vanNtX2RyaXZlci5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvanNtL2pzbV9kcml2ZXIuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvanNtL2pzbV9uZW8uYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9qc20vanNtX25lby5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9qc20vanNtX25lby5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvanNtL2pzbV9uZW8uYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvanNtL2pzbV90dHkuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9qc20vanNtX3R0eS5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9qc20vanNtX3R0eS5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvanNtL2pzbV90dHkuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwva2dkYm9jLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwva2dkYm9jLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL2tnZGJvYy5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwva2dkYm9jLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL20zMnJfc2lvLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvbTMycl9zaW8uYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvbTMycl9zaW8uYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL20zMnJfc2lvLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL20zMnJfc2lvLmggYi9kcml2ZXJzL3R0eS9zZXJpYWwvbTMycl9zaW8uaApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvbTMycl9zaW8uaApyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL20zMnJfc2lvLmgKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL20zMnJfc2lvX3JlZy5oIGIvZHJpdmVycy90dHkvc2VyaWFsL20zMnJfc2lvX3JlZy5oCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9tMzJyX3Npb19yZWcuaApyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL20zMnJfc2lvX3JlZy5oCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9tYXgzMTAwLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvbWF4MzEwMC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9tYXgzMTAwLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9tYXgzMTAwLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL21heDMxMDctYWF2YS5jIGIvZHJpdmVycy90dHkvc2VyaWFsL21heDMxMDctYWF2YS5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9tYXgzMTA3LWFhdmEuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL21heDMxMDctYWF2YS5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9tYXgzMTA3LmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvbWF4MzEwNy5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9tYXgzMTA3LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9tYXgzMTA3LmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL21heDMxMDcuaCBiL2RyaXZlcnMvdHR5L3NlcmlhbC9tYXgzMTA3LmgKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL21heDMxMDcuaApyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL21heDMxMDcuaApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvbWNmLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvbWNmLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL21jZi5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvbWNmLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL21mZC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL21mZC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9tZmQuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL21mZC5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9tcGM1Mnh4X3VhcnQuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9tcGM1Mnh4X3VhcnQuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvbXBjNTJ4eF91YXJ0LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9tcGM1Mnh4X3VhcnQuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvbXBzYy5jIGIvZHJpdmVycy90dHkvc2VyaWFsL21wc2MuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvbXBzYy5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvbXBzYy5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9tcnN0X21heDMxMTAuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9tcnN0X21heDMxMTAuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvbXJzdF9tYXgzMTEwLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9tcnN0X21heDMxMTAuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvbXJzdF9tYXgzMTEwLmggYi9kcml2ZXJzL3R0eS9zZXJpYWwvbXJzdF9tYXgzMTEwLmgKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL21yc3RfbWF4MzExMC5oCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvbXJzdF9tYXgzMTEwLmgKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL21zbV9zZXJpYWwuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9tc21fc2VyaWFsLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL21zbV9zZXJpYWwuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL21zbV9zZXJpYWwuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvbXNtX3NlcmlhbC5oIGIvZHJpdmVycy90dHkvc2VyaWFsL21zbV9zZXJpYWwuaApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvbXNtX3NlcmlhbC5oCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvbXNtX3NlcmlhbC5oCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9tdXguYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9tdXguYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvbXV4LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9tdXguYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvbmV0eC1zZXJpYWwuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9uZXR4LXNlcmlhbC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9uZXR4LXNlcmlhbC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvbmV0eC1zZXJpYWwuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvbndwc2VyaWFsLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvbndwc2VyaWFsLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL253cHNlcmlhbC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvbndwc2VyaWFsLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL29mX3NlcmlhbC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL29mX3NlcmlhbC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9vZl9zZXJpYWwuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL29mX3NlcmlhbC5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9vbWFwLXNlcmlhbC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL29tYXAtc2VyaWFsLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL29tYXAtc2VyaWFsLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9vbWFwLXNlcmlhbC5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9wY2hfdWFydC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3BjaF91YXJ0LmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3BjaF91YXJ0LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9wY2hfdWFydC5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9wbWFjX3ppbG9nLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvcG1hY196aWxvZy5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9wbWFjX3ppbG9nLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9wbWFjX3ppbG9nLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3BtYWNfemlsb2cuaCBiL2RyaXZlcnMvdHR5L3NlcmlhbC9wbWFjX3ppbG9nLmgKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3BtYWNfemlsb2cuaApyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3BtYWNfemlsb2cuaApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvcG54OHh4eF91YXJ0LmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvcG54OHh4eF91YXJ0LmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3BueDh4eHhfdWFydC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvcG54OHh4eF91YXJ0LmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3B4YS5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3B4YS5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9weGEuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3B4YS5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9zM2MyNDAwLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvczNjMjQwMC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9zM2MyNDAwLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9zM2MyNDAwLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3MzYzI0MTAuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zM2MyNDEwLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3MzYzI0MTAuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3MzYzI0MTAuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvczNjMjQxMi5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3MzYzI0MTIuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvczNjMjQxMi5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvczNjMjQxMi5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9zM2MyNDQwLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvczNjMjQ0MC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9zM2MyNDQwLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9zM2MyNDQwLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3MzYzI0YTAuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zM2MyNGEwLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3MzYzI0YTAuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3MzYzI0YTAuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvczNjNjQwMC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3MzYzY0MDAuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvczNjNjQwMC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvczNjNjQwMC5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9zNXB2MjEwLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvczVwdjIxMC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9zNXB2MjEwLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9zNXB2MjEwLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3NhMTEwMC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3NhMTEwMC5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9zYTExMDAuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3NhMTEwMC5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9zYW1zdW5nLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc2Ftc3VuZy5jCnNpbWlsYXJpdHkgaW5kZXggOTklCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3NhbXN1bmcuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3NhbXN1bmcuYwppbmRleCA3YWMyYmY1Li4yMzM1ZWRhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3NlcmlhbC9zYW1zdW5nLmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL3NhbXN1bmcuYwpAQCAtODgzLDEwICs4ODMsMTAgQEAKIAogc3RhdGljIHN0cnVjdCB1YXJ0X2RyaXZlciBzM2MyNHh4X3VhcnRfZHJ2ID0gewogCS5vd25lcgkJPSBUSElTX01PRFVMRSwKLQkuZGV2X25hbWUJPSAiczNjMjQxMF9zZXJpYWwiLAorCS5kcml2ZXJfbmFtZQk9ICJzM2MyNDEwX3NlcmlhbCIsCiAJLm5yCQk9IENPTkZJR19TRVJJQUxfU0FNU1VOR19VQVJUUywKIAkuY29ucwkJPSBTM0MyNFhYX1NFUklBTF9DT05TT0xFLAotCS5kcml2ZXJfbmFtZQk9IFMzQzI0WFhfU0VSSUFMX05BTUUsCisJLmRldl9uYW1lCT0gUzNDMjRYWF9TRVJJQUxfTkFNRSwKIAkubWFqb3IJCT0gUzNDMjRYWF9TRVJJQUxfTUFKT1IsCiAJLm1pbm9yCQk9IFMzQzI0WFhfU0VSSUFMX01JTk9SLAogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3NhbXN1bmcuaCBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zYW1zdW5nLmgKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3NhbXN1bmcuaApyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3NhbXN1bmcuaApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvc2IxMjUwLWR1YXJ0LmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc2IxMjUwLWR1YXJ0LmMKc2ltaWxhcml0eSBpbmRleCA5OSUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvc2IxMjUwLWR1YXJ0LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9zYjEyNTAtZHVhcnQuYwppbmRleCBhMmYyYjMyLi42MDJkOTg0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3NlcmlhbC9zYjEyNTAtZHVhcnQuYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc2IxMjUwLWR1YXJ0LmMKQEAgLTgyOSw3ICs4MjksNyBAQAogI2lmZGVmIENPTkZJR19TRVJJQUxfU0IxMjUwX0RVQVJUX0NPTlNPTEUKIC8qCiAgKiBTZXJpYWwgY29uc29sZSBzdHVmZi4gIFZlcnkgYmFzaWMsIHBvbGxpbmcgZHJpdmVyIGZvciBkb2luZyBzZXJpYWwKLSAqIGNvbnNvbGUgb3V0cHV0LiAgVGhlIGNvbnNvbGVfc2VtIGlzIGhlbGQgYnkgdGhlIGNhbGxlciwgc28gd2UKKyAqIGNvbnNvbGUgb3V0cHV0LiAgVGhlIGNvbnNvbGVfbG9jayBpcyBoZWxkIGJ5IHRoZSBjYWxsZXIsIHNvIHdlCiAgKiBzaG91bGRuJ3QgYmUgaW50ZXJydXB0ZWQgZm9yIG1vcmUgY29uc29sZSBhY3Rpdml0eS4KICAqLwogc3RhdGljIHZvaWQgc2JkX2NvbnNvbGVfcHV0Y2hhcihzdHJ1Y3QgdWFydF9wb3J0ICp1cG9ydCwgaW50IGNoKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvc2MyNnh4LmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc2MyNnh4LmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3NjMjZ4eC5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvc2MyNnh4LmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3NlcmlhbF9jb3JlLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX2NvcmUuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvc2VyaWFsX2NvcmUuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3NlcmlhbF9jb3JlLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3NlcmlhbF9jcy5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3NlcmlhbF9jcy5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9zZXJpYWxfY3MuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3NlcmlhbF9jcy5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9zZXJpYWxfa3M4Njk1LmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX2tzODY5NS5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9zZXJpYWxfa3M4Njk1LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9zZXJpYWxfa3M4Njk1LmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3NlcmlhbF9saDdhNDB4LmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX2xoN2E0MHguYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvc2VyaWFsX2xoN2E0MHguYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3NlcmlhbF9saDdhNDB4LmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3NlcmlhbF90eHg5LmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX3R4eDkuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvc2VyaWFsX3R4eDkuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3NlcmlhbF90eHg5LmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3NoLXNjaS5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3NoLXNjaS5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9zaC1zY2kuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3NoLXNjaS5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9zaC1zY2kuaCBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zaC1zY2kuaApzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvc2gtc2NpLmgKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9zaC1zY2kuaApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvc25fY29uc29sZS5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3NuX2NvbnNvbGUuYwpzaW1pbGFyaXR5IGluZGV4IDEwMCUKcmVuYW1lIGZyb20gZHJpdmVycy9zZXJpYWwvc25fY29uc29sZS5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvc25fY29uc29sZS5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9zdW5jb3JlLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc3VuY29yZS5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9zdW5jb3JlLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9zdW5jb3JlLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3N1bmNvcmUuaCBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zdW5jb3JlLmgKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3N1bmNvcmUuaApyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3N1bmNvcmUuaApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvc3VuaHYuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zdW5odi5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9zdW5odi5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvc3VuaHYuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvc3Vuc2FiLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc3Vuc2FiLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3N1bnNhYi5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvc3Vuc2FiLmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3N1bnNhYi5oIGIvZHJpdmVycy90dHkvc2VyaWFsL3N1bnNhYi5oCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC9zdW5zYWIuaApyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3N1bnNhYi5oCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9zdW5zdS5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3N1bnN1LmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3N1bnN1LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9zdW5zdS5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9zdW56aWxvZy5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3N1bnppbG9nLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3N1bnppbG9nLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9zdW56aWxvZy5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC9zdW56aWxvZy5oIGIvZHJpdmVycy90dHkvc2VyaWFsL3N1bnppbG9nLmgKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3N1bnppbG9nLmgKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC9zdW56aWxvZy5oCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC90aW1idWFydC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3RpbWJ1YXJ0LmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3RpbWJ1YXJ0LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC90aW1idWFydC5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC90aW1idWFydC5oIGIvZHJpdmVycy90dHkvc2VyaWFsL3RpbWJ1YXJ0LmgKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3RpbWJ1YXJ0LmgKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC90aW1idWFydC5oCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC91YXJ0bGl0ZS5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3VhcnRsaXRlLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3VhcnRsaXRlLmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC91YXJ0bGl0ZS5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC91Y2NfdWFydC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3VjY191YXJ0LmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3VjY191YXJ0LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC91Y2NfdWFydC5jCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NlcmlhbC92cjQxeHhfc2l1LmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvdnI0MXh4X3NpdS5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC92cjQxeHhfc2l1LmMKcmVuYW1lIHRvIGRyaXZlcnMvdHR5L3NlcmlhbC92cjQxeHhfc2l1LmMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3Z0ODUwMF9zZXJpYWwuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC92dDg1MDBfc2VyaWFsLmMKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIGRyaXZlcnMvc2VyaWFsL3Z0ODUwMF9zZXJpYWwuYwpyZW5hbWUgdG8gZHJpdmVycy90dHkvc2VyaWFsL3Z0ODUwMF9zZXJpYWwuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvenMuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC96cy5jCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC96cy5jCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvenMuYwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvenMuaCBiL2RyaXZlcnMvdHR5L3NlcmlhbC96cy5oCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSBkcml2ZXJzL3NlcmlhbC96cy5oCnJlbmFtZSB0byBkcml2ZXJzL3R0eS9zZXJpYWwvenMuaApkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc3lzcnEuYyBiL2RyaXZlcnMvdHR5L3N5c3JxLmMKaW5kZXggYzU1NmVkOS4uOGUwZGQyNSAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc3lzcnEuYworKysgYi9kcml2ZXJzL3R0eS9zeXNycS5jCkBAIC00Niw3ICs0Niw3IEBACiAjaW5jbHVkZSA8YXNtL2lycV9yZWdzLmg+CiAKIC8qIFdoZXRoZXIgd2UgcmVhY3Qgb24gc3lzcnEga2V5cyBvciBqdXN0IGlnbm9yZSB0aGVtICovCi1zdGF0aWMgaW50IF9fcmVhZF9tb3N0bHkgc3lzcnFfZW5hYmxlZCA9IDE7CitzdGF0aWMgaW50IF9fcmVhZF9tb3N0bHkgc3lzcnFfZW5hYmxlZCA9IFNZU1JRX0RFRkFVTFRfRU5BQkxFOwogc3RhdGljIGJvb2wgX19yZWFkX21vc3RseSBzeXNycV9hbHdheXNfZW5hYmxlZDsKIAogc3RhdGljIGJvb2wgc3lzcnFfb24odm9pZCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3R0eV9pby5jIGIvZHJpdmVycy90dHkvdHR5X2lvLmMKaW5kZXggNDY0ZDA5ZC4uMDA2NWRhNCAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvdHR5X2lvLmMKKysrIGIvZHJpdmVycy90dHkvdHR5X2lvLmMKQEAgLTMyNTYsOCArMzI1Niw4IEBACiAJc3RydWN0IGNvbnNvbGUgKmM7CiAJc3NpemVfdCBjb3VudCA9IDA7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7Ci0JZm9yIChjID0gY29uc29sZV9kcml2ZXJzOyBjOyBjID0gYy0+bmV4dCkgeworCWNvbnNvbGVfbG9jaygpOworCWZvcl9lYWNoX2NvbnNvbGUoYykgewogCQlpZiAoIWMtPmRldmljZSkKIAkJCWNvbnRpbnVlOwogCQlpZiAoIWMtPndyaXRlKQpAQCAtMzI3MSw3ICszMjcxLDcgQEAKIAl3aGlsZSAoaS0tKQogCQljb3VudCArPSBzcHJpbnRmKGJ1ZiArIGNvdW50LCAiJXMlZCVjIiwKIAkJCQkgY3NbaV0tPm5hbWUsIGNzW2ldLT5pbmRleCwgaSA/ICcgJzonXG4nKTsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCXJldHVybiBjb3VudDsKIH0KQEAgLTMzMDYsNyArMzMwNiw3IEBACiAJaWYgKElTX0VSUihjb25zZGV2KSkKIAkJY29uc2RldiA9IE5VTEw7CiAJZWxzZQotCQlkZXZpY2VfY3JlYXRlX2ZpbGUoY29uc2RldiwgJmRldl9hdHRyX2FjdGl2ZSk7CisJCVdBUk5fT04oZGV2aWNlX2NyZWF0ZV9maWxlKGNvbnNkZXYsICZkZXZfYXR0cl9hY3RpdmUpIDwgMCk7CiAKICNpZmRlZiBDT05GSUdfVlQKIAl2dHlfaW5pdCgmY29uc29sZV9mb3BzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3Z0L3NlbGVjdGlvbi5jIGIvZHJpdmVycy90dHkvdnQvc2VsZWN0aW9uLmMKaW5kZXggZWJhZTM0NC4uYzk1NmVkNiAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvdnQvc2VsZWN0aW9uLmMKKysrIGIvZHJpdmVycy90dHkvdnQvc2VsZWN0aW9uLmMKQEAgLTMxNiw5ICszMTYsOSBAQAogCS8qIGFsd2F5cyBjYWxsZWQgd2l0aCBCVE0gZnJvbSB2dF9pb2N0bCAqLwogCVdBUk5fT04oIXR0eV9sb2NrZWQoKSk7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJcG9rZV9ibGFua2VkX2NvbnNvbGUoKTsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCWxkID0gdHR5X2xkaXNjX3JlZih0dHkpOwogCWlmICghbGQpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3Z0L3ZjX3NjcmVlbi5jIGIvZHJpdmVycy90dHkvdnQvdmNfc2NyZWVuLmMKaW5kZXggZWFiM2ExZi4uYTY3MmVkMSAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvdnQvdmNfc2NyZWVuLmMKKysrIGIvZHJpdmVycy90dHkvdnQvdmNfc2NyZWVuLmMKQEAgLTIwMiw3ICsyMDIsNyBAQAogCS8qIFNlbGVjdCB0aGUgcHJvcGVyIGN1cnJlbnQgY29uc29sZSBhbmQgdmVyaWZ5CiAJICogc2FuaXR5IG9mIHRoZSBzaXR1YXRpb24gdW5kZXIgdGhlIGNvbnNvbGUgbG9jay4KIAkgKi8KLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAKIAlhdHRyID0gKGN1cnJjb25zICYgMTI4KTsKIAljdXJyY29ucyA9IChjdXJyY29ucyAmIDEyNyk7CkBAIC0zMzYsOSArMzM2LDkgQEAKIAkJICogdGhlIHBhZ2VmYXVsdCBoYW5kbGluZyBjb2RlIG1heSB3YW50IHRvIGNhbGwgcHJpbnRrKCkuCiAJCSAqLwogCi0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAkJcmV0ID0gY29weV90b191c2VyKGJ1ZiwgY29uX2J1Zl9zdGFydCwgb3JpZ19jb3VudCk7Ci0JCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV9sb2NrKCk7CiAKIAkJaWYgKHJldCkgewogCQkJcmVhZCArPSAob3JpZ19jb3VudCAtIHJldCk7CkBAIC0zNTQsNyArMzU0LDcgQEAKIAlpZiAocmVhZCkKIAkJcmV0ID0gcmVhZDsKIHVubG9ja19vdXQ6Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJbXV0ZXhfdW5sb2NrKCZjb25fYnVmX210eCk7CiAJcmV0dXJuIHJldDsKIH0KQEAgLTM3OSw3ICszNzksNyBAQAogCS8qIFNlbGVjdCB0aGUgcHJvcGVyIGN1cnJlbnQgY29uc29sZSBhbmQgdmVyaWZ5CiAJICogc2FuaXR5IG9mIHRoZSBzaXR1YXRpb24gdW5kZXIgdGhlIGNvbnNvbGUgbG9jay4KIAkgKi8KLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAKIAlhdHRyID0gKGN1cnJjb25zICYgMTI4KTsKIAljdXJyY29ucyA9IChjdXJyY29ucyAmIDEyNyk7CkBAIC00MTQsOSArNDE0LDkgQEAKIAkJLyogVGVtcG9yYXJpbHkgZHJvcCB0aGUgY29uc29sZSBsb2NrIHNvIHRoYXQgd2UgY2FuIHJlYWQKIAkJICogaW4gdGhlIHdyaXRlIGRhdGEgZnJvbSB1c2Vyc3BhY2Ugc2FmZWx5LgogCQkgKi8KLQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX3VubG9jaygpOwogCQlyZXQgPSBjb3B5X2Zyb21fdXNlcihjb25fYnVmLCBidWYsIHRoaXNfcm91bmQpOwotCQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfbG9jaygpOwogCiAJCWlmIChyZXQpIHsKIAkJCXRoaXNfcm91bmQgLT0gcmV0OwpAQCAtNTQyLDcgKzU0Miw3IEBACiAJCXZjc19zY3JfdXBkYXRlZCh2Yyk7CiAKIHVubG9ja19vdXQ6Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAltdXRleF91bmxvY2soJmNvbl9idWZfbXR4KTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvdnQvdnQuYyBiL2RyaXZlcnMvdHR5L3Z0L3Z0LmMKaW5kZXggNzY0MDdlYy4uMTQ3ZWRlMzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3Z0L3Z0LmMKKysrIGIvZHJpdmVycy90dHkvdnQvdnQuYwpAQCAtMTAwMyw5ICsxMDAzLDkgQEAKIAlzdHJ1Y3QgdmNfZGF0YSAqdmMgPSB0dHktPmRyaXZlcl9kYXRhOwogCWludCByZXQ7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJcmV0ID0gdmNfZG9fcmVzaXplKHR0eSwgdmMsIHdzLT53c19jb2wsIHdzLT53c19yb3cpOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCXJldHVybiByZXQ7CiB9CiAKQEAgLTEyNzEsNyArMTI3MSw3IEBACiAJdmMtPnZjX2NvbG9yID0gdmMtPnZjX2RlZl9jb2xvcjsKIH0KIAotLyogY29uc29sZV9zZW0gaXMgaGVsZCAqLworLyogY29uc29sZV9sb2NrIGlzIGhlbGQgKi8KIHN0YXRpYyB2b2lkIGNzaV9tKHN0cnVjdCB2Y19kYXRhICp2YykKIHsKIAlpbnQgaTsKQEAgLTE0MTUsNyArMTQxNSw3IEBACiAJcmV0dXJuIHZjX2NvbnNbZmdfY29uc29sZV0uZC0+dmNfcmVwb3J0X21vdXNlOwogfQogCi0vKiBjb25zb2xlX3NlbSBpcyBoZWxkICovCisvKiBjb25zb2xlX2xvY2sgaXMgaGVsZCAqLwogc3RhdGljIHZvaWQgc2V0X21vZGUoc3RydWN0IHZjX2RhdGEgKnZjLCBpbnQgb25fb2ZmKQogewogCWludCBpOwpAQCAtMTQ4NSw3ICsxNDg1LDcgQEAKIAkJfQogfQogCi0vKiBjb25zb2xlX3NlbSBpcyBoZWxkICovCisvKiBjb25zb2xlX2xvY2sgaXMgaGVsZCAqLwogc3RhdGljIHZvaWQgc2V0dGVybV9jb21tYW5kKHN0cnVjdCB2Y19kYXRhICp2YykKIHsKIAlzd2l0Y2godmMtPnZjX3BhclswXSkgewpAQCAtMTU0NSw3ICsxNTQ1LDcgQEAKIAl9CiB9CiAKLS8qIGNvbnNvbGVfc2VtIGlzIGhlbGQgKi8KKy8qIGNvbnNvbGVfbG9jayBpcyBoZWxkICovCiBzdGF0aWMgdm9pZCBjc2lfYXQoc3RydWN0IHZjX2RhdGEgKnZjLCB1bnNpZ25lZCBpbnQgbnIpCiB7CiAJaWYgKG5yID4gdmMtPnZjX2NvbHMgLSB2Yy0+dmNfeCkKQEAgLTE1NTUsNyArMTU1NSw3IEBACiAJaW5zZXJ0X2NoYXIodmMsIG5yKTsKIH0KIAotLyogY29uc29sZV9zZW0gaXMgaGVsZCAqLworLyogY29uc29sZV9sb2NrIGlzIGhlbGQgKi8KIHN0YXRpYyB2b2lkIGNzaV9MKHN0cnVjdCB2Y19kYXRhICp2YywgdW5zaWduZWQgaW50IG5yKQogewogCWlmIChuciA+IHZjLT52Y19yb3dzIC0gdmMtPnZjX3kpCkBAIC0xNTY2LDcgKzE1NjYsNyBAQAogCXZjLT52Y19uZWVkX3dyYXAgPSAwOwogfQogCi0vKiBjb25zb2xlX3NlbSBpcyBoZWxkICovCisvKiBjb25zb2xlX2xvY2sgaXMgaGVsZCAqLwogc3RhdGljIHZvaWQgY3NpX1Aoc3RydWN0IHZjX2RhdGEgKnZjLCB1bnNpZ25lZCBpbnQgbnIpCiB7CiAJaWYgKG5yID4gdmMtPnZjX2NvbHMgLSB2Yy0+dmNfeCkKQEAgLTE1NzYsNyArMTU3Niw3IEBACiAJZGVsZXRlX2NoYXIodmMsIG5yKTsKIH0KIAotLyogY29uc29sZV9zZW0gaXMgaGVsZCAqLworLyogY29uc29sZV9sb2NrIGlzIGhlbGQgKi8KIHN0YXRpYyB2b2lkIGNzaV9NKHN0cnVjdCB2Y19kYXRhICp2YywgdW5zaWduZWQgaW50IG5yKQogewogCWlmIChuciA+IHZjLT52Y19yb3dzIC0gdmMtPnZjX3kpCkBAIC0xNTg3LDcgKzE1ODcsNyBAQAogCXZjLT52Y19uZWVkX3dyYXAgPSAwOwogfQogCi0vKiBjb25zb2xlX3NlbSBpcyBoZWxkIChleGNlcHQgdmlhIHZjX2luaXQtPnJlc2V0X3Rlcm1pbmFsICovCisvKiBjb25zb2xlX2xvY2sgaXMgaGVsZCAoZXhjZXB0IHZpYSB2Y19pbml0LT5yZXNldF90ZXJtaW5hbCAqLwogc3RhdGljIHZvaWQgc2F2ZV9jdXIoc3RydWN0IHZjX2RhdGEgKnZjKQogewogCXZjLT52Y19zYXZlZF94CQk9IHZjLT52Y194OwpAQCAtMTYwMyw3ICsxNjAzLDcgQEAKIAl2Yy0+dmNfc2F2ZWRfRzEJCT0gdmMtPnZjX0cxX2NoYXJzZXQ7CiB9CiAKLS8qIGNvbnNvbGVfc2VtIGlzIGhlbGQgKi8KKy8qIGNvbnNvbGVfbG9jayBpcyBoZWxkICovCiBzdGF0aWMgdm9pZCByZXN0b3JlX2N1cihzdHJ1Y3QgdmNfZGF0YSAqdmMpCiB7CiAJZ290b3h5KHZjLCB2Yy0+dmNfc2F2ZWRfeCwgdmMtPnZjX3NhdmVkX3kpOwpAQCAtMTYyNSw3ICsxNjI1LDcgQEAKIAlFU2hhc2gsIEVTc2V0RzAsIEVTc2V0RzEsIEVTcGVyY2VudCwgRVNpZ25vcmUsIEVTbm9uc3RkLAogCUVTcGFsZXR0ZSB9OwogCi0vKiBjb25zb2xlX3NlbSBpcyBoZWxkIChleGNlcHQgdmlhIHZjX2luaXQoKSkgKi8KKy8qIGNvbnNvbGVfbG9jayBpcyBoZWxkIChleGNlcHQgdmlhIHZjX2luaXQoKSkgKi8KIHN0YXRpYyB2b2lkIHJlc2V0X3Rlcm1pbmFsKHN0cnVjdCB2Y19kYXRhICp2YywgaW50IGRvX2NsZWFyKQogewogCXZjLT52Y190b3AJCT0gMDsKQEAgLTE2ODUsNyArMTY4NSw3IEBACiAJICAgIGNzaV9KKHZjLCAyKTsKIH0KIAotLyogY29uc29sZV9zZW0gaXMgaGVsZCAqLworLyogY29uc29sZV9sb2NrIGlzIGhlbGQgKi8KIHN0YXRpYyB2b2lkIGRvX2Nvbl90cm9sKHN0cnVjdCB0dHlfc3RydWN0ICp0dHksIHN0cnVjdCB2Y19kYXRhICp2YywgaW50IGMpCiB7CiAJLyoKQEAgLTIxMTksNyArMjExOSw3IEBACiAJcmV0dXJuIGJpc2VhcmNoKHVjcywgZG91YmxlX3dpZHRoLCBBUlJBWV9TSVpFKGRvdWJsZV93aWR0aCkgLSAxKTsKIH0KIAotLyogYWNxdWlyZXMgY29uc29sZV9zZW0gKi8KKy8qIGFjcXVpcmVzIGNvbnNvbGVfbG9jayAqLwogc3RhdGljIGludCBkb19jb25fd3JpdGUoc3RydWN0IHR0eV9zdHJ1Y3QgKnR0eSwgY29uc3QgdW5zaWduZWQgY2hhciAqYnVmLCBpbnQgY291bnQpCiB7CiAjaWZkZWYgVlRfQlVGX1ZSQU1fT05MWQpAQCAtMjE0NywxMSArMjE0NywxMSBAQAogCiAJbWlnaHRfc2xlZXAoKTsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAl2YyA9IHR0eS0+ZHJpdmVyX2RhdGE7CiAJaWYgKHZjID09IE5VTEwpIHsKIAkJcHJpbnRrKEtFUk5fRVJSICJ2dDogYXJnaCwgZHJpdmVyX2RhdGEgaXMgTlVMTCAhXG4iKTsKLQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX3VubG9jaygpOwogCQlyZXR1cm4gMDsKIAl9CiAKQEAgLTIxNTksNyArMjE1OSw3IEBACiAJaWYgKCF2Y19jb25zX2FsbG9jYXRlZChjdXJyY29ucykpIHsKIAkgICAgLyogY291bGQgdGhpcyBoYXBwZW4/ICovCiAJCXByaW50a19vbmNlKCJjb25fd3JpdGU6IHR0eSAlZCBub3QgYWxsb2NhdGVkXG4iLCBjdXJyY29ucysxKTsKLQkgICAgcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCSAgICBjb25zb2xlX3VubG9jaygpOwogCSAgICByZXR1cm4gMDsKIAl9CiAKQEAgLTIzNzUsNyArMjM3NSw3IEBACiAJfQogCUZMVVNICiAJY29uc29sZV9jb25kaXRpb25hbF9zY2hlZHVsZSgpOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCW5vdGlmeV91cGRhdGUodmMpOwogCXJldHVybiBuOwogI3VuZGVmIEZMVVNICkBAIC0yMzg4LDExICsyMzg4LDExIEBACiAgKiB1cyB0byBkbyB0aGUgc3dpdGNoZXMgYXN5bmNocm9ub3VzbHkgKG5lZWRlZCB3aGVuIHdlIHdhbnQKICAqIHRvIHN3aXRjaCBkdWUgdG8gYSBrZXlib2FyZCBpbnRlcnJ1cHQpLiAgU3luY2hyb25pemF0aW9uCiAgKiB3aXRoIG90aGVyIGNvbnNvbGUgY29kZSBhbmQgcHJldmVudGlvbiBvZiByZS1lbnRyYW5jeSBpcwotICogZW5zdXJlZCB3aXRoIGNvbnNvbGVfc2VtLgorICogZW5zdXJlZCB3aXRoIGNvbnNvbGVfbG9jay4KICAqLwogc3RhdGljIHZvaWQgY29uc29sZV9jYWxsYmFjayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKmlnbm9yZWQpCiB7Ci0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCiAJaWYgKHdhbnRfY29uc29sZSA+PSAwKSB7CiAJCWlmICh3YW50X2NvbnNvbGUgIT0gZmdfY29uc29sZSAmJgpAQCAtMjQyMiw3ICsyNDIyLDcgQEAKIAl9CiAJbm90aWZ5X3VwZGF0ZSh2Y19jb25zW2ZnX2NvbnNvbGVdLmQpOwogCi0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiB9CiAKIGludCBzZXRfY29uc29sZShpbnQgbnIpCkBAIC0yNjAzLDcgKzI2MDMsNyBAQAogICovCiAKIC8qCi0gKiBHZW5lcmFsbHkgYSBiaXQgcmFjeSB3aXRoIHJlc3BlY3QgdG8gY29uc29sZV9zZW0oKS4KKyAqIEdlbmVyYWxseSBhIGJpdCByYWN5IHdpdGggcmVzcGVjdCB0byBjb25zb2xlX2xvY2soKTsuCiAgKgogICogVGhlcmUgYXJlIHNvbWUgZnVuY3Rpb25zIHdoaWNoIGRvbid0IG5lZWQgaXQuCiAgKgpAQCAtMjYyOSwxNyArMjYyOSwxNyBAQAogCXN3aXRjaCAodHlwZSkKIAl7CiAJCWNhc2UgVElPQ0xfU0VUU0VMOgotCQkJYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCQkJY29uc29sZV9sb2NrKCk7CiAJCQlyZXQgPSBzZXRfc2VsZWN0aW9uKChzdHJ1Y3QgdGlvY2xfc2VsZWN0aW9uIF9fdXNlciAqKShwKzEpLCB0dHkpOwotCQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQkJY29uc29sZV91bmxvY2soKTsKIAkJCWJyZWFrOwogCQljYXNlIFRJT0NMX1BBU1RFU0VMOgogCQkJcmV0ID0gcGFzdGVfc2VsZWN0aW9uKHR0eSk7CiAJCQlicmVhazsKIAkJY2FzZSBUSU9DTF9VTkJMQU5LU0NSRUVOOgotCQkJYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCQkJY29uc29sZV9sb2NrKCk7CiAJCQl1bmJsYW5rX3NjcmVlbigpOwotCQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQkJY29uc29sZV91bmxvY2soKTsKIAkJCWJyZWFrOwogCQljYXNlIFRJT0NMX1NFTExPQURMVVQ6CiAJCQlyZXQgPSBzZWxfbG9hZGx1dChwKTsKQEAgLTI2ODgsMTAgKzI2ODgsMTAgQEAKIAkJCX0KIAkJCWJyZWFrOwogCQljYXNlIFRJT0NMX0JMQU5LU0NSRUVOOgkvKiB1bnRpbCBleHBsaWNpdGx5IHVuYmxhbmtlZCwgbm90IG9ubHkgcG9rZWQgKi8KLQkJCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwkJCWNvbnNvbGVfbG9jaygpOwogCQkJaWdub3JlX3Bva2UgPSAxOwogCQkJZG9fYmxhbmtfc2NyZWVuKDApOwotCQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQkJY29uc29sZV91bmxvY2soKTsKIAkJCWJyZWFrOwogCQljYXNlIFRJT0NMX0JMQU5LRURTQ1JFRU46CiAJCQlyZXQgPSBjb25zb2xlX2JsYW5rZWQ7CkBAIC0yNzkwLDExICsyNzkwLDExIEBACiAJCXJldHVybjsKIAogCS8qIGlmIHdlIHJhY2Ugd2l0aCBjb25fY2xvc2UoKSwgdnQgbWF5IGJlIG51bGwgKi8KLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJdmMgPSB0dHktPmRyaXZlcl9kYXRhOwogCWlmICh2YykKIAkJc2V0X2N1cnNvcih2Yyk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiB9CiAKIC8qCkBAIC0yODA1LDcgKzI4MDUsNyBAQAogCXVuc2lnbmVkIGludCBjdXJyY29ucyA9IHR0eS0+aW5kZXg7CiAJaW50IHJldCA9IDA7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJaWYgKHR0eS0+ZHJpdmVyX2RhdGEgPT0gTlVMTCkgewogCQlyZXQgPSB2Y19hbGxvY2F0ZShjdXJyY29ucyk7CiAJCWlmIChyZXQgPT0gMCkgewpAQCAtMjgxMyw3ICsyODEzLDcgQEAKIAogCQkJLyogU3RpbGwgYmVpbmcgZnJlZWQgKi8KIAkJCWlmICh2Yy0+cG9ydC50dHkpIHsKLQkJCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCQkJY29uc29sZV91bmxvY2soKTsKIAkJCQlyZXR1cm4gLUVSRVNUQVJUU1lTOwogCQkJfQogCQkJdHR5LT5kcml2ZXJfZGF0YSA9IHZjOwpAQCAtMjgyNywxMSArMjgyNywxMSBAQAogCQkJCXR0eS0+dGVybWlvcy0+Y19pZmxhZyB8PSBJVVRGODsKIAkJCWVsc2UKIAkJCQl0dHktPnRlcm1pb3MtPmNfaWZsYWcgJj0gfklVVEY4OwotCQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQkJY29uc29sZV91bmxvY2soKTsKIAkJCXJldHVybiByZXQ7CiAJCX0KIAl9Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtMjg0NCw5ICsyODQ0LDkgQEAKIHsKIAlzdHJ1Y3QgdmNfZGF0YSAqdmMgPSB0dHktPmRyaXZlcl9kYXRhOwogCUJVR19PTih2YyA9PSBOVUxMKTsKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJdmMtPnBvcnQudHR5ID0gTlVMTDsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAl0dHlfc2h1dGRvd24odHR5KTsKIH0KIApAQCAtMjg5MywxMyArMjg5MywxMyBAQAogCXN0cnVjdCB2Y19kYXRhICp2YzsKIAl1bnNpZ25lZCBpbnQgY3VycmNvbnMgPSAwLCBpOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCiAJaWYgKGNvbnN3aXRjaHApCiAJCWRpc3BsYXlfZGVzYyA9IGNvbnN3aXRjaHAtPmNvbl9zdGFydHVwKCk7CiAJaWYgKCFkaXNwbGF5X2Rlc2MpIHsKIAkJZmdfY29uc29sZSA9IDA7Ci0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAkJcmV0dXJuIDA7CiAJfQogCkBAIC0yOTQ2LDcgKzI5NDYsNyBAQAogCXByaW50YWJsZSA9IDE7CiAJcHJpbnRrKCJcbiIpOwogCi0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKICNpZmRlZiBDT05GSUdfVlRfQ09OU09MRQogCXJlZ2lzdGVyX2NvbnNvbGUoJnZ0X2NvbnNvbGVfZHJpdmVyKTsKQEAgLTI5OTQsNyArMjk5NCw3IEBACiAJaWYgKElTX0VSUih0dHkwZGV2KSkKIAkJdHR5MGRldiA9IE5VTEw7CiAJZWxzZQotCQlkZXZpY2VfY3JlYXRlX2ZpbGUodHR5MGRldiwgJmRldl9hdHRyX2FjdGl2ZSk7CisJCVdBUk5fT04oZGV2aWNlX2NyZWF0ZV9maWxlKHR0eTBkZXYsICZkZXZfYXR0cl9hY3RpdmUpIDwgMCk7CiAKIAl2Y3NfaW5pdCgpOwogCkBAIC0zMDM3LDcgKzMwMzcsNyBAQAogCWlmICghdHJ5X21vZHVsZV9nZXQob3duZXIpKQogCQlyZXR1cm4gLUVOT0RFVjsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAogCS8qIGNoZWNrIGlmIGRyaXZlciBpcyByZWdpc3RlcmVkICovCiAJZm9yIChpID0gMDsgaSA8IE1BWF9OUl9DT05fRFJJVkVSOyBpKyspIHsKQEAgLTMxMjIsNyArMzEyMiw3IEBACiAKIAlyZXR2YWwgPSAwOwogZXJyOgotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCW1vZHVsZV9wdXQob3duZXIpOwogCXJldHVybiByZXR2YWw7CiB9OwpAQCAtMzE3MSw3ICszMTcxLDcgQEAKIAlpZiAoIXRyeV9tb2R1bGVfZ2V0KG93bmVyKSkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAKIAkvKiBjaGVjayBpZiBkcml2ZXIgaXMgcmVnaXN0ZXJlZCBhbmQgaWYgaXQgaXMgdW5iaW5kYWJsZSAqLwogCWZvciAoaSA9IDA7IGkgPCBNQVhfTlJfQ09OX0RSSVZFUjsgaSsrKSB7CkBAIC0zMTg1LDcgKzMxODUsNyBAQAogCX0KIAogCWlmIChyZXR2YWwpIHsKLQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX3VubG9jaygpOwogCQlnb3RvIGVycjsKIAl9CiAKQEAgLTMyMDQsMTIgKzMyMDQsMTIgQEAKIAl9CiAKIAlpZiAocmV0dmFsKSB7Ci0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAkJZ290byBlcnI7CiAJfQogCiAJaWYgKCFjb25faXNfYm91bmQoY3N3KSkgewotCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfdW5sb2NrKCk7CiAJCWdvdG8gZXJyOwogCX0KIApAQCAtMzIzOCw3ICszMjM4LDcgQEAKIAlpZiAoIWNvbl9pc19ib3VuZChjc3cpKQogCQljb25fZHJpdmVyLT5mbGFnICY9IH5DT05fRFJJVkVSX0ZMQUdfSU5JVDsKIAotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCS8qIGlnbm9yZSByZXR1cm4gdmFsdWUsIGJpbmRpbmcgc2hvdWxkIG5vdCBmYWlsICovCiAJYmluZF9jb25fZHJpdmVyKGRlZmNzdywgZmlyc3QsIGxhc3QsIGRlZmx0KTsKIGVycjoKQEAgLTM1MzgsMTQgKzM1MzgsMTQgQEAKIAlpZiAoIXRyeV9tb2R1bGVfZ2V0KG93bmVyKSkKIAkJcmV0dXJuIC1FTk9ERVY7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgTUFYX05SX0NPTl9EUklWRVI7IGkrKykgewogCQljb25fZHJpdmVyID0gJnJlZ2lzdGVyZWRfY29uX2RyaXZlcltpXTsKIAogCQkvKiBhbHJlYWR5IHJlZ2lzdGVyZWQgKi8KIAkJaWYgKGNvbl9kcml2ZXItPmNvbiA9PSBjc3cpCi0JCQlyZXR2YWwgPSAtRUlOVkFMOworCQkJcmV0dmFsID0gLUVCVVNZOwogCX0KIAogCWlmIChyZXR2YWwpCkBAIC0zNTkyLDcgKzM1OTIsNyBAQAogCX0KIAogZXJyOgotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCW1vZHVsZV9wdXQob3duZXIpOwogCXJldHVybiByZXR2YWw7CiB9CkBAIC0zNjEzLDcgKzM2MTMsNyBAQAogewogCWludCBpLCByZXR2YWwgPSAtRU5PREVWOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCiAJLyogY2Fubm90IHVucmVnaXN0ZXIgYSBib3VuZCBkcml2ZXIgKi8KIAlpZiAoY29uX2lzX2JvdW5kKGNzdykpCkBAIC0zNjM5LDcgKzM2MzksNyBAQAogCQl9CiAJfQogZXJyOgotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCXJldHVybiByZXR2YWw7CiB9CiBFWFBPUlRfU1lNQk9MKHVucmVnaXN0ZXJfY29uX2RyaXZlcik7CkBAIC0zNjU2LDcgKzM2NTYsMTIgQEAKIAlpbnQgZXJyOwogCiAJZXJyID0gcmVnaXN0ZXJfY29uX2RyaXZlcihjc3csIGZpcnN0LCBsYXN0KTsKLQorCS8qIGlmIHdlIGdldCBhbiBidXN5IGVycm9yIHdlIHN0aWxsIHdhbnQgdG8gYmluZCB0aGUgY29uc29sZSBkcml2ZXIKKwkgKiBhbmQgcmV0dXJuIHN1Y2Nlc3MsIGFzIHdlIG1heSBoYXZlIHVuYm91bmQgdGhlIGNvbnNvbGUgZHJpdmVyCisJwqAqIGJ1dCBub3QgdW5yZWdpc3RlcmVkIGl0LgorCSovCisJaWYgKGVyciA9PSAtRUJVU1kpCisJCWVyciA9IDA7CiAJaWYgKCFlcnIpCiAJCWJpbmRfY29uX2RyaXZlcihjc3csIGZpcnN0LCBsYXN0LCBkZWZsdCk7CiAKQEAgLTM5MzQsOSArMzkzOSw5IEBACiB7CiAJaW50IHJjOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCXJjID0gc2V0X2dldF9jbWFwIChhcmcsMSk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAlyZXR1cm4gcmM7CiB9CkBAIC0zOTQ1LDkgKzM5NTAsOSBAQAogewogCWludCByYzsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlyYyA9IHNldF9nZXRfY21hcCAoYXJnLDApOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCiAJcmV0dXJuIHJjOwogfQpAQCAtMzk5NCwxMiArMzk5OSwxMiBAQAogCX0gZWxzZQogCQlmb250LmRhdGEgPSBOVUxMOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWlmICh2Yy0+dmNfc3ctPmNvbl9mb250X2dldCkKIAkJcmMgPSB2Yy0+dmNfc3ctPmNvbl9mb250X2dldCh2YywgJmZvbnQpOwogCWVsc2UKIAkJcmMgPSAtRU5PU1lTOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCiAJaWYgKHJjKQogCQlnb3RvIG91dDsKQEAgLTQwNzYsMTIgKzQwODEsMTIgQEAKIAlmb250LmRhdGEgPSBtZW1kdXBfdXNlcihvcC0+ZGF0YSwgc2l6ZSk7CiAJaWYgKElTX0VSUihmb250LmRhdGEpKQogCQlyZXR1cm4gUFRSX0VSUihmb250LmRhdGEpOwotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlpZiAodmMtPnZjX3N3LT5jb25fZm9udF9zZXQpCiAJCXJjID0gdmMtPnZjX3N3LT5jb25fZm9udF9zZXQodmMsICZmb250LCBvcC0+ZmxhZ3MpOwogCWVsc2UKIAkJcmMgPSAtRU5PU1lTOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCWtmcmVlKGZvbnQuZGF0YSk7CiAJcmV0dXJuIHJjOwogfQpAQCAtNDEwMywxMiArNDEwOCwxMiBAQAogCWVsc2UKIAkJbmFtZVtNQVhfRk9OVF9OQU1FIC0gMV0gPSAwOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWlmICh2Yy0+dmNfc3ctPmNvbl9mb250X2RlZmF1bHQpCiAJCXJjID0gdmMtPnZjX3N3LT5jb25fZm9udF9kZWZhdWx0KHZjLCAmZm9udCwgcyk7CiAJZWxzZQogCQlyYyA9IC1FTk9TWVM7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJaWYgKCFyYykgewogCQlvcC0+d2lkdGggPSBmb250LndpZHRoOwogCQlvcC0+aGVpZ2h0ID0gZm9udC5oZWlnaHQ7CkBAIC00MTI0LDcgKzQxMjksNyBAQAogCWlmICh2Yy0+dmNfbW9kZSAhPSBLRF9URVhUKQogCQlyZXR1cm4gLUVJTlZBTDsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlpZiAoIXZjLT52Y19zdy0+Y29uX2ZvbnRfY29weSkKIAkJcmMgPSAtRU5PU1lTOwogCWVsc2UgaWYgKGNvbiA8IDAgfHwgIXZjX2NvbnNfYWxsb2NhdGVkKGNvbikpCkBAIC00MTMzLDcgKzQxMzgsNyBAQAogCQlyYyA9IDA7CiAJZWxzZQogCQlyYyA9IHZjLT52Y19zdy0+Y29uX2ZvbnRfY29weSh2YywgY29uKTsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAlyZXR1cm4gcmM7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3Z0L3Z0X2lvY3RsLmMgYi9kcml2ZXJzL3R0eS92dC92dF9pb2N0bC5jCmluZGV4IDZiNjhhMGYuLjEyMzVlYmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3Z0L3Z0X2lvY3RsLmMKKysrIGIvZHJpdmVycy90dHkvdnQvdnRfaW9jdGwuYwpAQCAtNjQ5LDEyICs2NDksMTIgQEAKIAkJLyoKIAkJICogZXhwbGljaXRseSBibGFuay91bmJsYW5rIHRoZSBzY3JlZW4gaWYgc3dpdGNoaW5nIG1vZGVzCiAJCSAqLwotCQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfbG9jaygpOwogCQlpZiAoYXJnID09IEtEX1RFWFQpCiAJCQlkb191bmJsYW5rX3NjcmVlbigxKTsKIAkJZWxzZQogCQkJZG9fYmxhbmtfc2NyZWVuKDEpOwotCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfdW5sb2NrKCk7CiAJCWJyZWFrOwogCiAJY2FzZSBLREdFVE1PREU6CkBAIC04OTMsNyArODkzLDcgQEAKIAkJCXJldCA9IC1FSU5WQUw7CiAJCQlnb3RvIG91dDsKIAkJfQotCQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfbG9jaygpOwogCQl2Yy0+dnRfbW9kZSA9IHRtcDsKIAkJLyogdGhlIGZyc2lnIGlzIGlnbm9yZWQsIHNvIHdlIHNldCBpdCB0byAwICovCiAJCXZjLT52dF9tb2RlLmZyc2lnID0gMDsKQEAgLTkwMSw3ICs5MDEsNyBAQAogCQl2Yy0+dnRfcGlkID0gZ2V0X3BpZCh0YXNrX3BpZChjdXJyZW50KSk7CiAJCS8qIG5vIHN3aXRjaCBpcyByZXF1aXJlZCAtLSBzYXdAc2hhZGUubXN1LnJ1ICovCiAJCXZjLT52dF9uZXd2dCA9IC0xOwotCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfdW5sb2NrKCk7CiAJCWJyZWFrOwogCX0KIApAQCAtOTEwLDkgKzkxMCw5IEBACiAJCXN0cnVjdCB2dF9tb2RlIHRtcDsKIAkJaW50IHJjOwogCi0JCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV9sb2NrKCk7CiAJCW1lbWNweSgmdG1wLCAmdmMtPnZ0X21vZGUsIHNpemVvZihzdHJ1Y3QgdnRfbW9kZSkpOwotCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAkJcmMgPSBjb3B5X3RvX3VzZXIodXAsICZ0bXAsIHNpemVvZihzdHJ1Y3QgdnRfbW9kZSkpOwogCQlpZiAocmMpCkBAIC05NjUsOSArOTY1LDkgQEAKIAkJCXJldCA9ICAtRU5YSU87CiAJCWVsc2UgewogCQkJYXJnLS07Ci0JCQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJCQljb25zb2xlX2xvY2soKTsKIAkJCXJldCA9IHZjX2FsbG9jYXRlKGFyZyk7Ci0JCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCQljb25zb2xlX3VubG9jaygpOwogCQkJaWYgKHJldCkKIAkJCQlicmVhazsKIAkJCXNldF9jb25zb2xlKGFyZyk7CkBAIC05OTAsNyArOTkwLDcgQEAKIAkJCXJldCA9IC1FTlhJTzsKIAkJZWxzZSB7CiAJCQl2c2EuY29uc29sZS0tOwotCQkJYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCQkJY29uc29sZV9sb2NrKCk7CiAJCQlyZXQgPSB2Y19hbGxvY2F0ZSh2c2EuY29uc29sZSk7CiAJCQlpZiAocmV0ID09IDApIHsKIAkJCQlzdHJ1Y3QgdmNfZGF0YSAqbnZjOwpAQCAtMTAwMyw3ICsxMDAzLDcgQEAKIAkJCQlwdXRfcGlkKG52Yy0+dnRfcGlkKTsKIAkJCQludmMtPnZ0X3BpZCA9IGdldF9waWQodGFza19waWQoY3VycmVudCkpOwogCQkJfQotCQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQkJY29uc29sZV91bmxvY2soKTsKIAkJCWlmIChyZXQpCiAJCQkJYnJlYWs7CiAJCQkvKiBDb21tZW5jZSBzd2l0Y2ggYW5kIGxvY2sgKi8KQEAgLTEwNDQsNyArMTA0NCw3IEBACiAJCS8qCiAJCSAqIFN3aXRjaGluZy1mcm9tIHJlc3BvbnNlCiAJCSAqLwotCQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfbG9jaygpOwogCQlpZiAodmMtPnZ0X25ld3Z0ID49IDApIHsKIAkJCWlmIChhcmcgPT0gMCkKIAkJCQkvKgpAQCAtMTA2Myw3ICsxMDYzLDcgQEAKIAkJCQl2Yy0+dnRfbmV3dnQgPSAtMTsKIAkJCQlyZXQgPSB2Y19hbGxvY2F0ZShuZXd2dCk7CiAJCQkJaWYgKHJldCkgewotCQkJCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCQkJCWNvbnNvbGVfdW5sb2NrKCk7CiAJCQkJCWJyZWFrOwogCQkJCX0KIAkJCQkvKgpAQCAtMTA4Myw3ICsxMDgzLDcgQEAKIAkJCWlmIChhcmcgIT0gVlRfQUNLQUNRKQogCQkJCXJldCA9IC1FSU5WQUw7CiAJCX0KLQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX3VubG9jaygpOwogCQlicmVhazsKIAogCSAvKgpAQCAtMTA5NiwyMCArMTA5NiwyMCBAQAogCQl9CiAJCWlmIChhcmcgPT0gMCkgewogCQkgICAgLyogZGVhbGxvY2F0ZSBhbGwgdW51c2VkIGNvbnNvbGVzLCBidXQgbGVhdmUgMCAqLwotCQkJYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCQkJY29uc29sZV9sb2NrKCk7CiAJCQlmb3IgKGk9MTsgaTxNQVhfTlJfQ09OU09MRVM7IGkrKykKIAkJCQlpZiAoISBWVF9CVVNZKGkpKQogCQkJCQl2Y19kZWFsbG9jYXRlKGkpOwotCQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQkJY29uc29sZV91bmxvY2soKTsKIAkJfSBlbHNlIHsKIAkJCS8qIGRlYWxsb2NhdGUgYSBzaW5nbGUgY29uc29sZSwgaWYgcG9zc2libGUgKi8KIAkJCWFyZy0tOwogCQkJaWYgKFZUX0JVU1koYXJnKSkKIAkJCQlyZXQgPSAtRUJVU1k7CiAJCQllbHNlIGlmIChhcmcpIHsJCQkgICAgICAvKiBsZWF2ZSAwICovCi0JCQkJYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCQkJCWNvbnNvbGVfbG9jaygpOwogCQkJCXZjX2RlYWxsb2NhdGUoYXJnKTsKLQkJCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCQkJY29uc29sZV91bmxvY2soKTsKIAkJCX0KIAkJfQogCQlicmVhazsKQEAgLTExMjYsNyArMTEyNiw3IEBACiAJCSAgICBnZXRfdXNlcihjYywgJnZ0c2l6ZXMtPnZfY29scykpCiAJCQlyZXQgPSAtRUZBVUxUOwogCQllbHNlIHsKLQkJCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwkJCWNvbnNvbGVfbG9jaygpOwogCQkJZm9yIChpID0gMDsgaSA8IE1BWF9OUl9DT05TT0xFUzsgaSsrKSB7CiAJCQkJdmMgPSB2Y19jb25zW2ldLmQ7CiAKQEAgLTExMzUsNyArMTEzNSw3IEBACiAJCQkJCXZjX3Jlc2l6ZSh2Y19jb25zW2ldLmQsIGNjLCBsbCk7CiAJCQkJfQogCQkJfQotCQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQkJY29uc29sZV91bmxvY2soKTsKIAkJfQogCQlicmVhazsKIAl9CkBAIC0xMTg3LDE0ICsxMTg3LDE0IEBACiAJCWZvciAoaSA9IDA7IGkgPCBNQVhfTlJfQ09OU09MRVM7IGkrKykgewogCQkJaWYgKCF2Y19jb25zW2ldLmQpCiAJCQkJY29udGludWU7Ci0JCQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJCQljb25zb2xlX2xvY2soKTsKIAkJCWlmICh2bGluKQogCQkJCXZjX2NvbnNbaV0uZC0+dmNfc2Nhbl9saW5lcyA9IHZsaW47CiAJCQlpZiAoY2xpbikKIAkJCQl2Y19jb25zW2ldLmQtPnZjX2ZvbnQuaGVpZ2h0ID0gY2xpbjsKIAkJCXZjX2NvbnNbaV0uZC0+dmNfcmVzaXplX3VzZXIgPSAxOwogCQkJdmNfcmVzaXplKHZjX2NvbnNbaV0uZCwgY2MsIGxsKTsKLQkJCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJCWNvbnNvbGVfdW5sb2NrKCk7CiAJCX0KIAkJYnJlYWs7CiAJfQpAQCAtMTM2Nyw3ICsxMzY3LDcgQEAKIAlzdHJ1Y3QgdmNfZGF0YSAqdmM7CiAJc3RydWN0IHR0eV9zdHJ1Y3QgKnR0eTsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAl2YyA9IHZjX2Nvbi0+ZDsKIAlpZiAodmMpIHsKIAkJdHR5ID0gdmMtPnBvcnQudHR5OwpAQCAtMTM3OSw3ICsxMzc5LDcgQEAKIAkJCV9fZG9fU0FLKHR0eSk7CiAJCXJlc2V0X3ZjKHZjKTsKIAl9Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiB9CiAKICNpZmRlZiBDT05GSUdfQ09NUEFUCkBAIC0xNzM3LDEwICsxNzM3LDEwIEBACiB7CiAJaW50IHByZXY7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJLyogR3JhcGhpY3MgbW9kZSAtIHVwIHRvIFggKi8KIAlpZiAoZGlzYWJsZV92dF9zd2l0Y2gpIHsKLQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX3VubG9jaygpOwogCQlyZXR1cm4gMDsKIAl9CiAJcHJldiA9IGZnX2NvbnNvbGU7CkBAIC0xNzQ4LDcgKzE3NDgsNyBAQAogCWlmIChhbGxvYyAmJiB2Y19hbGxvY2F0ZSh2dCkpIHsKIAkJLyogd2UgY2FuJ3QgaGF2ZSBhIGZyZWUgVkMgZm9yIG5vdy4gVG9vIGJhZCwKIAkJICogd2UgZG9uJ3Qgd2FudCB0byBtZXNzIHRoZSBzY3JlZW4gZm9yIG5vdy4gKi8KLQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX3VubG9jaygpOwogCQlyZXR1cm4gLUVOT1NQQzsKIAl9CiAKQEAgLTE3NTgsMTAgKzE3NTgsMTAgQEAKIAkJICogTGV0IHRoZSBjYWxsaW5nIGZ1bmN0aW9uIGtub3cgc28gaXQgY2FuIGRlY2lkZQogCQkgKiB3aGF0IHRvIGRvLgogCQkgKi8KLQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX3VubG9jaygpOwogCQlyZXR1cm4gLUVJTzsKIAl9Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJdHR5X2xvY2soKTsKIAlpZiAodnRfd2FpdGFjdGl2ZSh2dCArIDEpKSB7CiAJCXByX2RlYnVnKCJTdXNwZW5kOiBDYW4ndCBzd2l0Y2ggVkNzLiIpOwpAQCAtMTc4MSw4ICsxNzgxLDggQEAKICAqLwogdm9pZCBwbV9zZXRfdnRfc3dpdGNoKGludCBkb19zd2l0Y2gpCiB7Ci0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWRpc2FibGVfdnRfc3dpdGNoID0gIWRvX3N3aXRjaDsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIH0KIEVYUE9SVF9TWU1CT0wocG1fc2V0X3Z0X3N3aXRjaCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jbGFzcy9jZGMtYWNtLmMgYi9kcml2ZXJzL3VzYi9jbGFzcy9jZGMtYWNtLmMKaW5kZXggZDZlZGU5OC4uNGFiNDlkNCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvY2xhc3MvY2RjLWFjbS5jCisrKyBiL2RyaXZlcnMvdXNiL2NsYXNzL2NkYy1hY20uYwpAQCAtMTYwNyw2ICsxNjA3LDcgQEAKIAl7IE5PS0lBX1BDU1VJVEVfQUNNX0lORk8oMHgwMTU0KSwgfSwgLyogTm9raWEgNTgwMCBYcHJlc3NNdXNpYyAqLwogCXsgTk9LSUFfUENTVUlURV9BQ01fSU5GTygweDA0Y2UpLCB9LCAvKiBOb2tpYSBFOTAgKi8KIAl7IE5PS0lBX1BDU1VJVEVfQUNNX0lORk8oMHgwMWQ0KSwgfSwgLyogTm9raWEgRTU1ICovCisJeyBOT0tJQV9QQ1NVSVRFX0FDTV9JTkZPKDB4MDMwMiksIH0sIC8qIE5va2lhIE44ICovCiAJeyBTQU1TVU5HX1BDU1VJVEVfQUNNX0lORk8oMHg2NjUxKSwgfSwgLyogU2Ftc3VuZyBHVGk4NTEwIChJTk5PVjgpICovCiAKIAkvKiBOT1RFOiBub24tTm9raWEgQ09NTS9BQ00vMHhmZiBpcyBsaWtlbHkgTVNGVCBSTkRJUy4uLiBOT1QgYSBtb2RlbSEgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NsYXNzL2NkYy13ZG0uYyBiL2RyaXZlcnMvdXNiL2NsYXNzL2NkYy13ZG0uYwppbmRleCA2ZWU0NDUxLi40NzA4NWU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9jbGFzcy9jZGMtd2RtLmMKKysrIGIvZHJpdmVycy91c2IvY2xhc3MvY2RjLXdkbS5jCkBAIC0zNDIsNyArMzQyLDcgQEAKIAkJZ290byBvdXRucDsKIAl9CiAKLQlpZiAoIWZpbGUtPmZfZmxhZ3MgJiYgT19OT05CTE9DSykKKwlpZiAoIShmaWxlLT5mX2ZsYWdzICYgT19OT05CTE9DSykpCiAJCXIgPSB3YWl0X2V2ZW50X2ludGVycnVwdGlibGUoZGVzYy0+d2FpdCwgIXRlc3RfYml0KFdETV9JTl9VU0UsCiAJCQkJCQkJCSZkZXNjLT5mbGFncykpOwogCWVsc2UKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NvcmUvS2NvbmZpZyBiL2RyaXZlcnMvdXNiL2NvcmUvS2NvbmZpZwppbmRleCBiY2MyNDc3Li4xOGQwMmUzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9jb3JlL0tjb25maWcKKysrIGIvZHJpdmVycy91c2IvY29yZS9LY29uZmlnCkBAIC0xMjMsOSArMTIzLDkgQEAKIAogY29uZmlnIFVTQl9PVEdfV0hJVEVMSVNUCiAJYm9vbCAiUmVseSBvbiBPVEcgVGFyZ2V0ZWQgUGVyaXBoZXJhbHMgTGlzdCIKLQlkZXBlbmRzIG9uIFVTQl9PVEcgfHwgRU1CRURERUQKKwlkZXBlbmRzIG9uIFVTQl9PVEcgfHwgRVhQRVJUCiAJZGVmYXVsdCB5IGlmIFVTQl9PVEcKLQlkZWZhdWx0IG4gaWYgRU1CRURERUQKKwlkZWZhdWx0IG4gaWYgRVhQRVJUCiAJaGVscAogCSAgSWYgeW91IHNheSBZIGhlcmUsIHRoZSAib3RnX3doaXRlbGlzdC5oIiBmaWxlIHdpbGwgYmUgdXNlZCBhcyBhCiAJICBwcm9kdWN0IHdoaXRlbGlzdCwgc28gVVNCIHBlcmlwaGVyYWxzIG5vdCBsaXN0ZWQgdGhlcmUgd2lsbCBiZQpAQCAtMTQxLDcgKzE0MSw3IEBACiAKIGNvbmZpZyBVU0JfT1RHX0JMQUNLTElTVF9IVUIKIAlib29sICJEaXNhYmxlIGV4dGVybmFsIGh1YnMiCi0JZGVwZW5kcyBvbiBVU0JfT1RHIHx8IEVNQkVEREVECisJZGVwZW5kcyBvbiBVU0JfT1RHIHx8IEVYUEVSVAogCWhlbHAKIAkgIElmIHlvdSBzYXkgWSBoZXJlLCB0aGVuIExpbnV4IHdpbGwgcmVmdXNlIHRvIGVudW1lcmF0ZQogCSAgZXh0ZXJuYWwgaHVicy4gIE9URyBob3N0cyBhcmUgYWxsb3dlZCB0byByZWR1Y2UgaGFyZHdhcmUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NvcmUvZW5kcG9pbnQuYyBiL2RyaXZlcnMvdXNiL2NvcmUvZW5kcG9pbnQuYwppbmRleCA5ZGEyNTA1Li5kZjUwMmE5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9jb3JlL2VuZHBvaW50LmMKKysrIGIvZHJpdmVycy91c2IvY29yZS9lbmRwb2ludC5jCkBAIC0xOTIsMTIgKzE5MiwxMiBAQAogCWVwX2Rldi0+ZGV2LnBhcmVudCA9IHBhcmVudDsKIAllcF9kZXYtPmRldi5yZWxlYXNlID0gZXBfZGV2aWNlX3JlbGVhc2U7CiAJZGV2X3NldF9uYW1lKCZlcF9kZXYtPmRldiwgImVwXyUwMngiLCBlbmRwb2ludC0+ZGVzYy5iRW5kcG9pbnRBZGRyZXNzKTsKLQlkZXZpY2VfZW5hYmxlX2FzeW5jX3N1c3BlbmQoJmVwX2Rldi0+ZGV2KTsKIAogCXJldHZhbCA9IGRldmljZV9yZWdpc3RlcigmZXBfZGV2LT5kZXYpOwogCWlmIChyZXR2YWwpCiAJCWdvdG8gZXJyb3JfcmVnaXN0ZXI7CiAKKwlkZXZpY2VfZW5hYmxlX2FzeW5jX3N1c3BlbmQoJmVwX2Rldi0+ZGV2KTsKIAllbmRwb2ludC0+ZXBfZGV2ID0gZXBfZGV2OwogCXJldHVybiByZXR2YWw7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NvcmUvaGNkLXBjaS5jIGIvZHJpdmVycy91c2IvY29yZS9oY2QtcGNpLmMKaW5kZXggYjU1ZDQ2MDcuLmY3MWU4ZTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2NvcmUvaGNkLXBjaS5jCisrKyBiL2RyaXZlcnMvdXNiL2NvcmUvaGNkLXBjaS5jCkBAIC00MDUsNyArNDA1LDEyIEBACiAJCQlyZXR1cm4gcmV0dmFsOwogCX0KIAotCXN5bmNocm9uaXplX2lycShwY2lfZGV2LT5pcnEpOworCS8qIElmIE1TSS1YIGlzIGVuYWJsZWQsIHRoZSBkcml2ZXIgd2lsbCBoYXZlIHN5bmNocm9uaXplZCBhbGwgdmVjdG9ycworCSAqIGluIHBjaV9zdXNwZW5kKCkuIElmIE1TSSBvciBsZWdhY3kgUENJIGlzIGVuYWJsZWQsIHRoYXQgd2lsbCBiZQorCSAqIHN5bmNocm9uaXplZCBoZXJlLgorCSAqLworCWlmICghaGNkLT5tc2l4X2VuYWJsZWQpCisJCXN5bmNocm9uaXplX2lycShwY2lfZGV2LT5pcnEpOwogCiAJLyogRG93bnN0cmVhbSBwb3J0cyBmcm9tIHRoaXMgcm9vdCBodWIgc2hvdWxkIGFscmVhZHkgYmUgcXVpZXNjZWQsIHNvCiAJICogdGhlcmUgd2lsbCBiZSBubyBETUEgYWN0aXZpdHkuICBOb3cgd2UgY2FuIHNodXQgZG93biB0aGUgdXBzdHJlYW0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NvcmUvaGNkLmMgYi9kcml2ZXJzL3VzYi9jb3JlL2hjZC5jCmluZGV4IDZhOTUwMTcuLmU5MzVmNzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2NvcmUvaGNkLmMKKysrIGIvZHJpdmVycy91c2IvY29yZS9oY2QuYwpAQCAtMTk1NSw3ICsxOTU1LDYgQEAKIAogCWRldl9kYmcoJnJoZGV2LT5kZXYsICJ1c2IgJXMlc1xuIiwKIAkJCShtc2cuZXZlbnQgJiBQTV9FVkVOVF9BVVRPID8gImF1dG8tIiA6ICIiKSwgInJlc3VtZSIpOwotCWNsZWFyX2JpdChIQ0RfRkxBR19XQUtFVVBfUEVORElORywgJmhjZC0+ZmxhZ3MpOwogCWlmICghaGNkLT5kcml2ZXItPmJ1c19yZXN1bWUpCiAJCXJldHVybiAtRU5PRU5UOwogCWlmIChoY2QtPnN0YXRlID09IEhDX1NUQVRFX1JVTk5JTkcpCkBAIC0xOTYzLDYgKzE5NjIsNyBAQAogCiAJaGNkLT5zdGF0ZSA9IEhDX1NUQVRFX1JFU1VNSU5HOwogCXN0YXR1cyA9IGhjZC0+ZHJpdmVyLT5idXNfcmVzdW1lKGhjZCk7CisJY2xlYXJfYml0KEhDRF9GTEFHX1dBS0VVUF9QRU5ESU5HLCAmaGNkLT5mbGFncyk7CiAJaWYgKHN0YXR1cyA9PSAwKSB7CiAJCS8qIFRSU01SQ1kgPSAxMCBtc2VjICovCiAJCW1zbGVlcCgxMCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jb3JlL2h1Yi5jIGIvZHJpdmVycy91c2IvY29yZS9odWIuYwppbmRleCBiOThlZmFlLi5kMDQxYzY4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9jb3JlL2h1Yi5jCisrKyBiL2RyaXZlcnMvdXNiL2NvcmUvaHViLmMKQEAgLTY3Niw2ICs2NzYsOCBAQAogc3RhdGljIHZvaWQgaHViX2FjdGl2YXRlKHN0cnVjdCB1c2JfaHViICpodWIsIGVudW0gaHViX2FjdGl2YXRpb25fdHlwZSB0eXBlKQogewogCXN0cnVjdCB1c2JfZGV2aWNlICpoZGV2ID0gaHViLT5oZGV2OworCXN0cnVjdCB1c2JfaGNkICpoY2Q7CisJaW50IHJldDsKIAlpbnQgcG9ydDE7CiAJaW50IHN0YXR1czsKIAlib29sIG5lZWRfZGVib3VuY2VfZGVsYXkgPSBmYWxzZTsKQEAgLTcxNCw2ICs3MTYsMjUgQEAKIAkJCXVzYl9hdXRvcG1fZ2V0X2ludGVyZmFjZV9ub19yZXN1bWUoCiAJCQkJCXRvX3VzYl9pbnRlcmZhY2UoaHViLT5pbnRmZGV2KSk7CiAJCQlyZXR1cm47CQkvKiBDb250aW51ZXMgYXQgaW5pdDI6IGJlbG93ICovCisJCX0gZWxzZSBpZiAodHlwZSA9PSBIVUJfUkVTRVRfUkVTVU1FKSB7CisJCQkvKiBUaGUgaW50ZXJuYWwgaG9zdCBjb250cm9sbGVyIHN0YXRlIGZvciB0aGUgaHViIGRldmljZQorCQkJICogbWF5IGJlIGdvbmUgYWZ0ZXIgYSBob3N0IHBvd2VyIGxvc3Mgb24gc3lzdGVtIHJlc3VtZS4KKwkJCSAqIFVwZGF0ZSB0aGUgZGV2aWNlJ3MgaW5mbyBzbyB0aGUgSFcga25vd3MgaXQncyBhIGh1Yi4KKwkJCSAqLworCQkJaGNkID0gYnVzX3RvX2hjZChoZGV2LT5idXMpOworCQkJaWYgKGhjZC0+ZHJpdmVyLT51cGRhdGVfaHViX2RldmljZSkgeworCQkJCXJldCA9IGhjZC0+ZHJpdmVyLT51cGRhdGVfaHViX2RldmljZShoY2QsIGhkZXYsCisJCQkJCQkmaHViLT50dCwgR0ZQX05PSU8pOworCQkJCWlmIChyZXQgPCAwKSB7CisJCQkJCWRldl9lcnIoaHViLT5pbnRmZGV2LCAiSG9zdCBub3QgIgorCQkJCQkJCSJhY2NlcHRpbmcgaHViIGluZm8gIgorCQkJCQkJCSJ1cGRhdGUuXG4iKTsKKwkJCQkJZGV2X2VycihodWItPmludGZkZXYsICJMUy9GUyBkZXZpY2VzICIKKwkJCQkJCQkiYW5kIGh1YnMgbWF5IG5vdCB3b3JrICIKKwkJCQkJCQkidW5kZXIgdGhpcyBodWJcbi4iKTsKKwkJCQl9CisJCQl9CisJCQlodWJfcG93ZXJfb24oaHViLCB0cnVlKTsKIAkJfSBlbHNlIHsKIAkJCWh1Yl9wb3dlcl9vbihodWIsIHRydWUpOwogCQl9CkBAIC0yNzMyLDYgKzI3NTMsMTEgQEAKIAkJdWRldi0+dHRwb3J0ID0gaGRldi0+dHRwb3J0OwogCX0gZWxzZSBpZiAodWRldi0+c3BlZWQgIT0gVVNCX1NQRUVEX0hJR0gKIAkJCSYmIGhkZXYtPnNwZWVkID09IFVTQl9TUEVFRF9ISUdIKSB7CisJCWlmICghaHViLT50dC5odWIpIHsKKwkJCWRldl9lcnIoJnVkZXYtPmRldiwgInBhcmVudCBodWIgaGFzIG5vIFRUXG4iKTsKKwkJCXJldHZhbCA9IC1FSU5WQUw7CisJCQlnb3RvIGZhaWw7CisJCX0KIAkJdWRldi0+dHQgPSAmaHViLT50dDsKIAkJdWRldi0+dHRwb3J0ID0gcG9ydDE7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvZ2FkZ2V0L0tjb25maWcgYi9kcml2ZXJzL3VzYi9nYWRnZXQvS2NvbmZpZwppbmRleCAxZGM5NzM5Li5kNTAwOTk2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvS2NvbmZpZworKysgYi9kcml2ZXJzL3VzYi9nYWRnZXQvS2NvbmZpZwpAQCAtNTA5LDcgKzUwOSw3IEBACiAJc2VsZWN0IFVTQl9HQURHRVRfU0VMRUNURUQKIAogY29uZmlnIFVTQl9HQURHRVRfRUcyMFQKLQlib29sZWFuICJJbnRlbCBFRzIwVChUb3BjbGlmZikgVVNCIERldmljZSBjb250cm9sbGVyIgorCWJvb2xlYW4gIkludGVsIEVHMjBUIFBDSC9PS0kgU0VNSUNPTkRVQ1RPUiBNTDcyMTMgSU9IIFVEQyIKIAlkZXBlbmRzIG9uIFBDSQogCXNlbGVjdCBVU0JfR0FER0VUX0RVQUxTUEVFRAogCWhlbHAKQEAgLTUyNSw2ICs1MjUsMTEgQEAKIAkgIFRoaXMgZHJpdmVyIGRvc2Ugbm90IHN1cHBvcnQgaW50ZXJydXB0IHRyYW5zZmVyIG9yIGlzb2Nocm9ub3VzCiAJICB0cmFuc2ZlciBtb2Rlcy4KIAorCSAgVGhpcyBkcml2ZXIgYWxzbyBjYW4gYmUgdXNlZCBmb3IgT0tJIFNFTUlDT05EVUNUT1IncyBNTDcyMTMgd2hpY2ggaXMKKwkgIGZvciBJVkkoSW4tVmVoaWNsZSBJbmZvdGFpbm1lbnQpIHVzZS4KKwkgIE1MNzIxMyBpcyBjb21wYW5pb24gY2hpcCBmb3IgSW50ZWwgQXRvbSBFNnh4IHNlcmllcy4KKwkgIE1MNzIxMyBpcyBjb21wbGV0ZWx5IGNvbXBhdGlibGUgZm9yIEludGVsIEVHMjBUIFBDSC4KKwogY29uZmlnIFVTQl9FRzIwVAogCXRyaXN0YXRlCiAJZGVwZW5kcyBvbiBVU0JfR0FER0VUX0VHMjBUCkBAIC01NDEsNiArNTQ2LDggQEAKIAkgIGNpMTN4eHhfdWRjIGNvcmUuCiAJICBUaGlzIGRyaXZlciBkZXBlbmRzIG9uIE9URyBkcml2ZXIgZm9yIFBIWSBpbml0aWFsaXphdGlvbiwKIAkgIGNsb2NrIG1hbmFnZW1lbnQsIHBvd2VyaW5nIHVwIFZCVVMsIGFuZCBwb3dlciBtYW5hZ2VtZW50LgorCSAgVGhpcyBkcml2ZXIgaXMgbm90IHN1cHBvcnRlZCBvbiBib2FyZHMgbGlrZSB0cm91dCB3aGljaAorCSAgaGFzIGFuIGV4dGVybmFsIFBIWS4KIAogCSAgU2F5ICJ5IiB0byBsaW5rIHRoZSBkcml2ZXIgc3RhdGljYWxseSwgb3IgIm0iIHRvIGJ1aWxkIGEKIAkgIGR5bmFtaWNhbGx5IGxpbmtlZCBtb2R1bGUgY2FsbGVkICJjaTEzeHh4X21zbSIgYW5kIGZvcmNlIGFsbApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvZ2FkZ2V0L2NpMTN4eHhfdWRjLmMgYi9kcml2ZXJzL3VzYi9nYWRnZXQvY2kxM3h4eF91ZGMuYwppbmRleCAzMTY1NmEyLi5hMWM2N2FlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvY2kxM3h4eF91ZGMuYworKysgYi9kcml2ZXJzL3VzYi9nYWRnZXQvY2kxM3h4eF91ZGMuYwpAQCAtNzYsMTAgKzc2LDIxIEBACiAKIC8qIGNvbnRyb2wgZW5kcG9pbnQgZGVzY3JpcHRpb24gKi8KIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2VuZHBvaW50X2Rlc2NyaXB0b3IKLWN0cmxfZW5kcHRfZGVzYyA9IHsKK2N0cmxfZW5kcHRfb3V0X2Rlc2MgPSB7CiAJLmJMZW5ndGggICAgICAgICA9IFVTQl9EVF9FTkRQT0lOVF9TSVpFLAogCS5iRGVzY3JpcHRvclR5cGUgPSBVU0JfRFRfRU5EUE9JTlQsCiAKKwkuYkVuZHBvaW50QWRkcmVzcyA9IFVTQl9ESVJfT1VULAorCS5ibUF0dHJpYnV0ZXMgICAgPSBVU0JfRU5EUE9JTlRfWEZFUl9DT05UUk9MLAorCS53TWF4UGFja2V0U2l6ZSAgPSBjcHVfdG9fbGUxNihDVFJMX1BBWUxPQURfTUFYKSwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdXNiX2VuZHBvaW50X2Rlc2NyaXB0b3IKK2N0cmxfZW5kcHRfaW5fZGVzYyA9IHsKKwkuYkxlbmd0aCAgICAgICAgID0gVVNCX0RUX0VORFBPSU5UX1NJWkUsCisJLmJEZXNjcmlwdG9yVHlwZSA9IFVTQl9EVF9FTkRQT0lOVCwKKworCS5iRW5kcG9pbnRBZGRyZXNzID0gVVNCX0RJUl9JTiwKIAkuYm1BdHRyaWJ1dGVzICAgID0gVVNCX0VORFBPSU5UX1hGRVJfQ09OVFJPTCwKIAkud01heFBhY2tldFNpemUgID0gY3B1X3RvX2xlMTYoQ1RSTF9QQVlMT0FEX01BWCksCiB9OwpAQCAtMjY1LDEwICsyNzYsMTAgQEAKIAlod19iYW5rLnNpemUgLz0gc2l6ZW9mKHUzMik7CiAKIAlyZWcgPSBod19hcmVhZChBQlNfRENDUEFSQU1TLCBEQ0NQQVJBTVNfREVOKSA+PiBmZnNfbnIoRENDUEFSQU1TX0RFTik7Ci0JaWYgKHJlZyA9PSAwIHx8IHJlZyA+IEVORFBUX01BWCkKLQkJcmV0dXJuIC1FTk9ERVY7CisJaHdfZXBfbWF4ID0gcmVnICogMjsgICAvKiBjYWNoZSBodyBFTkRQVF9NQVggKi8KIAotCWh3X2VwX21heCA9IHJlZzsgICAvKiBjYWNoZSBodyBFTkRQVF9NQVggKi8KKwlpZiAoaHdfZXBfbWF4ID09IDAgfHwgaHdfZXBfbWF4ID4gRU5EUFRfTUFYKQorCQlyZXR1cm4gLUVOT0RFVjsKIAogCS8qIHNldHVwIGxvY2sgbW9kZSA/ICovCiAKQEAgLTExOTcsMTYgKzEyMDgsMTcgQEAKIAl9CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSh1ZGMtPmxvY2ssIGZsYWdzKTsKLQlmb3IgKGkgPSAwOyBpIDwgaHdfZXBfbWF4OyBpKyspIHsKLQkJc3RydWN0IGNpMTN4eHhfZXAgKm1FcCA9ICZ1ZGMtPmNpMTN4eHhfZXBbaV07CisJZm9yIChpID0gMDsgaSA8IGh3X2VwX21heC8yOyBpKyspIHsKKwkJc3RydWN0IGNpMTN4eHhfZXAgKm1FcFJ4ID0gJnVkYy0+Y2kxM3h4eF9lcFtpXTsKKwkJc3RydWN0IGNpMTN4eHhfZXAgKm1FcFR4ID0gJnVkYy0+Y2kxM3h4eF9lcFtpICsgaHdfZXBfbWF4LzJdOwogCQluICs9IHNjbnByaW50ZihidWYgKyBuLCBQQUdFX1NJWkUgLSBuLAogCQkJICAgICAgICJFUD0lMDJpOiBSWD0lMDhYIFRYPSUwOFhcbiIsCi0JCQkgICAgICAgaSwgKHUzMiltRXAtPnFoW1JYXS5kbWEsICh1MzIpbUVwLT5xaFtUWF0uZG1hKTsKKwkJCSAgICAgICBpLCAodTMyKW1FcFJ4LT5xaC5kbWEsICh1MzIpbUVwVHgtPnFoLmRtYSk7CiAJCWZvciAoaiA9IDA7IGogPCAoc2l6ZW9mKHN0cnVjdCBjaTEzeHh4X3FoKS9zaXplb2YodTMyKSk7IGorKykgewogCQkJbiArPSBzY25wcmludGYoYnVmICsgbiwgUEFHRV9TSVpFIC0gbiwKIAkJCQkgICAgICAgIiAlMDRYOiAgICAlMDhYICAgICUwOFhcbiIsIGosCi0JCQkJICAgICAgICooKHUzMiAqKW1FcC0+cWhbUlhdLnB0ciArIGopLAotCQkJCSAgICAgICAqKCh1MzIgKiltRXAtPnFoW1RYXS5wdHIgKyBqKSk7CisJCQkJICAgICAgICooKHUzMiAqKW1FcFJ4LT5xaC5wdHIgKyBqKSwKKwkJCQkgICAgICAgKigodTMyICopbUVwVHgtPnFoLnB0ciArIGopKTsKIAkJfQogCX0KIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKHVkYy0+bG9jaywgZmxhZ3MpOwpAQCAtMTI5Myw3ICsxMzA1LDcgQEAKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCXN0cnVjdCBsaXN0X2hlYWQgICAqcHRyID0gTlVMTDsKIAlzdHJ1Y3QgY2kxM3h4eF9yZXEgKnJlcSA9IE5VTEw7Ci0JdW5zaWduZWQgaSwgaiwgaywgbiA9IDAsIHFTaXplID0gc2l6ZW9mKHN0cnVjdCBjaTEzeHh4X3RkKS9zaXplb2YodTMyKTsKKwl1bnNpZ25lZCBpLCBqLCBuID0gMCwgcVNpemUgPSBzaXplb2Yoc3RydWN0IGNpMTN4eHhfdGQpL3NpemVvZih1MzIpOwogCiAJZGJnX3RyYWNlKCJbJXNdICVwXG4iLCBfX2Z1bmNfXywgYnVmKTsKIAlpZiAoYXR0ciA9PSBOVUxMIHx8IGJ1ZiA9PSBOVUxMKSB7CkBAIC0xMzAzLDIyICsxMzE1LDIwIEBACiAKIAlzcGluX2xvY2tfaXJxc2F2ZSh1ZGMtPmxvY2ssIGZsYWdzKTsKIAlmb3IgKGkgPSAwOyBpIDwgaHdfZXBfbWF4OyBpKyspCi0JCWZvciAoayA9IFJYOyBrIDw9IFRYOyBrKyspCi0JCQlsaXN0X2Zvcl9lYWNoKHB0ciwgJnVkYy0+Y2kxM3h4eF9lcFtpXS5xaFtrXS5xdWV1ZSkKLQkJCXsKLQkJCQlyZXEgPSBsaXN0X2VudHJ5KHB0ciwKLQkJCQkJCSBzdHJ1Y3QgY2kxM3h4eF9yZXEsIHF1ZXVlKTsKKwkJbGlzdF9mb3JfZWFjaChwdHIsICZ1ZGMtPmNpMTN4eHhfZXBbaV0ucWgucXVldWUpCisJCXsKKwkJCXJlcSA9IGxpc3RfZW50cnkocHRyLCBzdHJ1Y3QgY2kxM3h4eF9yZXEsIHF1ZXVlKTsKIAorCQkJbiArPSBzY25wcmludGYoYnVmICsgbiwgUEFHRV9TSVpFIC0gbiwKKwkJCQkJIkVQPSUwMmk6IFREPSUwOFggJXNcbiIsCisJCQkJCWkgJSBod19lcF9tYXgvMiwgKHUzMilyZXEtPmRtYSwKKwkJCQkJKChpIDwgaHdfZXBfbWF4LzIpID8gIlJYIiA6ICJUWCIpKTsKKworCQkJZm9yIChqID0gMDsgaiA8IHFTaXplOyBqKyspCiAJCQkJbiArPSBzY25wcmludGYoYnVmICsgbiwgUEFHRV9TSVpFIC0gbiwKLQkJCQkJICAgICAgICJFUD0lMDJpOiBURD0lMDhYICVzXG4iLAotCQkJCQkgICAgICAgaSwgKHUzMilyZXEtPmRtYSwKLQkJCQkJICAgICAgICgoayA9PSBSWCkgPyAiUlgiIDogIlRYIikpOwotCi0JCQkJZm9yIChqID0gMDsgaiA8IHFTaXplOyBqKyspCi0JCQkJCW4gKz0gc2NucHJpbnRmKGJ1ZiArIG4sIFBBR0VfU0laRSAtIG4sCi0JCQkJCQkgICAgICAgIiAlMDRYOiAgICAlMDhYXG4iLCBqLAotCQkJCQkJICAgICAgICooKHUzMiAqKXJlcS0+cHRyICsgaikpOwotCQkJfQorCQkJCQkJIiAlMDRYOiAgICAlMDhYXG4iLCBqLAorCQkJCQkJKigodTMyICopcmVxLT5wdHIgKyBqKSk7CisJCX0KIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKHVkYy0+bG9jaywgZmxhZ3MpOwogCiAJcmV0dXJuIG47CkBAIC0xNDY3LDEyICsxNDc3LDEyIEBACiAJICogIEF0IHRoaXMgcG9pbnQgaXQncyBndWFyYW50ZWVkIGV4Y2x1c2l2ZSBhY2Nlc3MgdG8gcWhlYWQKIAkgKiAgKGVuZHB0IGlzIG5vdCBwcmltZWQpIHNvIGl0J3Mgbm8gbmVlZCB0byB1c2UgdHJpcHdpcmUKIAkgKi8KLQltRXAtPnFoW21FcC0+ZGlyXS5wdHItPnRkLm5leHQgICA9IG1SZXEtPmRtYTsgICAgLyogVEVSTUlOQVRFID0gMCAqLwotCW1FcC0+cWhbbUVwLT5kaXJdLnB0ci0+dGQudG9rZW4gJj0gflREX1NUQVRVUzsgICAvKiBjbGVhciBzdGF0dXMgKi8KKwltRXAtPnFoLnB0ci0+dGQubmV4dCAgID0gbVJlcS0+ZG1hOyAgICAvKiBURVJNSU5BVEUgPSAwICovCisJbUVwLT5xaC5wdHItPnRkLnRva2VuICY9IH5URF9TVEFUVVM7ICAgLyogY2xlYXIgc3RhdHVzICovCiAJaWYgKG1SZXEtPnJlcS56ZXJvID09IDApCi0JCW1FcC0+cWhbbUVwLT5kaXJdLnB0ci0+Y2FwIHw9ICBRSF9aTFQ7CisJCW1FcC0+cWgucHRyLT5jYXAgfD0gIFFIX1pMVDsKIAllbHNlCi0JCW1FcC0+cWhbbUVwLT5kaXJdLnB0ci0+Y2FwICY9IH5RSF9aTFQ7CisJCW1FcC0+cWgucHRyLT5jYXAgJj0gflFIX1pMVDsKIAogCXdtYigpOyAgIC8qIHN5bmNocm9uaXplIGJlZm9yZSBlcCBwcmltZSAqLwogCkBAIC0xNTQyLDExICsxNTUyLDExIEBACiAKIAlod19lcF9mbHVzaChtRXAtPm51bSwgbUVwLT5kaXIpOwogCi0Jd2hpbGUgKCFsaXN0X2VtcHR5KCZtRXAtPnFoW21FcC0+ZGlyXS5xdWV1ZSkpIHsKKwl3aGlsZSAoIWxpc3RfZW1wdHkoJm1FcC0+cWgucXVldWUpKSB7CiAKIAkJLyogcG9wIG9sZGVzdCByZXF1ZXN0ICovCiAJCXN0cnVjdCBjaTEzeHh4X3JlcSAqbVJlcSA9IFwKLQkJCWxpc3RfZW50cnkobUVwLT5xaFttRXAtPmRpcl0ucXVldWUubmV4dCwKKwkJCWxpc3RfZW50cnkobUVwLT5xaC5xdWV1ZS5uZXh0LAogCQkJCSAgIHN0cnVjdCBjaTEzeHh4X3JlcSwgcXVldWUpOwogCQlsaXN0X2RlbF9pbml0KCZtUmVxLT5xdWV1ZSk7CiAJCW1SZXEtPnJlcS5zdGF0dXMgPSAtRVNIVVRET1dOOwpAQCAtMTU3MSw4ICsxNTgxLDYgQEAKIHsKIAlzdHJ1Y3QgdXNiX2VwICplcDsKIAlzdHJ1Y3QgY2kxM3h4eCAgICAqdWRjID0gY29udGFpbmVyX29mKGdhZGdldCwgc3RydWN0IGNpMTN4eHgsIGdhZGdldCk7Ci0Jc3RydWN0IGNpMTN4eHhfZXAgKm1FcCA9IGNvbnRhaW5lcl9vZihnYWRnZXQtPmVwMCwKLQkJCQkJICAgICAgc3RydWN0IGNpMTN4eHhfZXAsIGVwKTsKIAogCXRyYWNlKCIlcCIsIGdhZGdldCk7CiAKQEAgLTE1ODMsNyArMTU5MSw4IEBACiAJZ2FkZ2V0X2Zvcl9lYWNoX2VwKGVwLCBnYWRnZXQpIHsKIAkJdXNiX2VwX2ZpZm9fZmx1c2goZXApOwogCX0KLQl1c2JfZXBfZmlmb19mbHVzaChnYWRnZXQtPmVwMCk7CisJdXNiX2VwX2ZpZm9fZmx1c2goJnVkYy0+ZXAwb3V0LmVwKTsKKwl1c2JfZXBfZmlmb19mbHVzaCgmdWRjLT5lcDBpbi5lcCk7CiAKIAl1ZGMtPmRyaXZlci0+ZGlzY29ubmVjdChnYWRnZXQpOwogCkBAIC0xNTkxLDExICsxNjAwLDEyIEBACiAJZ2FkZ2V0X2Zvcl9lYWNoX2VwKGVwLCBnYWRnZXQpIHsKIAkJdXNiX2VwX2Rpc2FibGUoZXApOwogCX0KLQl1c2JfZXBfZGlzYWJsZShnYWRnZXQtPmVwMCk7CisJdXNiX2VwX2Rpc2FibGUoJnVkYy0+ZXAwb3V0LmVwKTsKKwl1c2JfZXBfZGlzYWJsZSgmdWRjLT5lcDBpbi5lcCk7CiAKLQlpZiAobUVwLT5zdGF0dXMgIT0gTlVMTCkgewotCQl1c2JfZXBfZnJlZV9yZXF1ZXN0KGdhZGdldC0+ZXAwLCBtRXAtPnN0YXR1cyk7Ci0JCW1FcC0+c3RhdHVzID0gTlVMTDsKKwlpZiAodWRjLT5zdGF0dXMgIT0gTlVMTCkgeworCQl1c2JfZXBfZnJlZV9yZXF1ZXN0KCZ1ZGMtPmVwMGluLmVwLCB1ZGMtPnN0YXR1cyk7CisJCXVkYy0+c3RhdHVzID0gTlVMTDsKIAl9CiAKIAlyZXR1cm4gMDsKQEAgLTE2MTQsNyArMTYyNCw2IEBACiBfX3JlbGVhc2VzKHVkYy0+bG9jaykKIF9fYWNxdWlyZXModWRjLT5sb2NrKQogewotCXN0cnVjdCBjaTEzeHh4X2VwICptRXAgPSAmdWRjLT5jaTEzeHh4X2VwWzBdOwogCWludCByZXR2YWw7CiAKIAl0cmFjZSgiJXAiLCB1ZGMpOwpAQCAtMTYzNSwxMSArMTY0NCwxNSBAQAogCWlmIChyZXR2YWwpCiAJCWdvdG8gZG9uZTsKIAotCXJldHZhbCA9IHVzYl9lcF9lbmFibGUoJm1FcC0+ZXAsICZjdHJsX2VuZHB0X2Rlc2MpOworCXJldHZhbCA9IHVzYl9lcF9lbmFibGUoJnVkYy0+ZXAwb3V0LmVwLCAmY3RybF9lbmRwdF9vdXRfZGVzYyk7CisJaWYgKHJldHZhbCkKKwkJZ290byBkb25lOworCisJcmV0dmFsID0gdXNiX2VwX2VuYWJsZSgmdWRjLT5lcDBpbi5lcCwgJmN0cmxfZW5kcHRfaW5fZGVzYyk7CiAJaWYgKCFyZXR2YWwpIHsKLQkJbUVwLT5zdGF0dXMgPSB1c2JfZXBfYWxsb2NfcmVxdWVzdCgmbUVwLT5lcCwgR0ZQX0FUT01JQyk7Ci0JCWlmIChtRXAtPnN0YXR1cyA9PSBOVUxMKSB7Ci0JCQl1c2JfZXBfZGlzYWJsZSgmbUVwLT5lcCk7CisJCXVkYy0+c3RhdHVzID0gdXNiX2VwX2FsbG9jX3JlcXVlc3QoJnVkYy0+ZXAwaW4uZXAsIEdGUF9BVE9NSUMpOworCQlpZiAodWRjLT5zdGF0dXMgPT0gTlVMTCkgeworCQkJdXNiX2VwX2Rpc2FibGUoJnVkYy0+ZXAwb3V0LmVwKTsKIAkJCXJldHZhbCA9IC1FTk9NRU07CiAJCX0KIAl9CkBAIC0xNjcyLDE2ICsxNjg1LDE3IEBACiAKIC8qKgogICogaXNyX2dldF9zdGF0dXNfcmVzcG9uc2U6IGdldF9zdGF0dXMgcmVxdWVzdCByZXNwb25zZQotICogQGVwOiAgICBlbmRwb2ludAorICogQHVkYzogdWRjIHN0cnVjdAogICogQHNldHVwOiBzZXR1cCByZXF1ZXN0IHBhY2tldAogICoKICAqIFRoaXMgZnVuY3Rpb24gcmV0dXJucyBhbiBlcnJvciBjb2RlCiAgKi8KLXN0YXRpYyBpbnQgaXNyX2dldF9zdGF0dXNfcmVzcG9uc2Uoc3RydWN0IGNpMTN4eHhfZXAgKm1FcCwKK3N0YXRpYyBpbnQgaXNyX2dldF9zdGF0dXNfcmVzcG9uc2Uoc3RydWN0IGNpMTN4eHggKnVkYywKIAkJCQkgICBzdHJ1Y3QgdXNiX2N0cmxyZXF1ZXN0ICpzZXR1cCkKIF9fcmVsZWFzZXMobUVwLT5sb2NrKQogX19hY3F1aXJlcyhtRXAtPmxvY2spCiB7CisJc3RydWN0IGNpMTN4eHhfZXAgKm1FcCA9ICZ1ZGMtPmVwMGluOwogCXN0cnVjdCB1c2JfcmVxdWVzdCAqcmVxID0gTlVMTDsKIAlnZnBfdCBnZnBfZmxhZ3MgPSBHRlBfQVRPTUlDOwogCWludCBkaXIsIG51bSwgcmV0dmFsOwpAQCAtMTczNiwyNyArMTc1MCwyMyBAQAogCiAvKioKICAqIGlzcl9zZXR1cF9zdGF0dXNfcGhhc2U6IHF1ZXVlcyB0aGUgc3RhdHVzIHBoYXNlIG9mIGEgc2V0dXAgdHJhbnNhdGlvbgotICogQG1FcDogZW5kcG9pbnQKKyAqIEB1ZGM6IHVkYyBzdHJ1Y3QKICAqCiAgKiBUaGlzIGZ1bmN0aW9uIHJldHVybnMgYW4gZXJyb3IgY29kZQogICovCi1zdGF0aWMgaW50IGlzcl9zZXR1cF9zdGF0dXNfcGhhc2Uoc3RydWN0IGNpMTN4eHhfZXAgKm1FcCkKK3N0YXRpYyBpbnQgaXNyX3NldHVwX3N0YXR1c19waGFzZShzdHJ1Y3QgY2kxM3h4eCAqdWRjKQogX19yZWxlYXNlcyhtRXAtPmxvY2spCiBfX2FjcXVpcmVzKG1FcC0+bG9jaykKIHsKIAlpbnQgcmV0dmFsOworCXN0cnVjdCBjaTEzeHh4X2VwICptRXA7CiAKLQl0cmFjZSgiJXAiLCBtRXApOworCXRyYWNlKCIlcCIsIHVkYyk7CiAKLQkvKiBtRXAgaXMgYWx3YXlzIHZhbGlkICYgY29uZmlndXJlZCAqLwotCi0JaWYgKG1FcC0+dHlwZSA9PSBVU0JfRU5EUE9JTlRfWEZFUl9DT05UUk9MKQotCQltRXAtPmRpciA9IChtRXAtPmRpciA9PSBUWCkgPyBSWCA6IFRYOwotCi0JbUVwLT5zdGF0dXMtPm5vX2ludGVycnVwdCA9IDE7CisJbUVwID0gKHVkYy0+ZXAwX2RpciA9PSBUWCkgPyAmdWRjLT5lcDBvdXQgOiAmdWRjLT5lcDBpbjsKIAogCXNwaW5fdW5sb2NrKG1FcC0+bG9jayk7Ci0JcmV0dmFsID0gdXNiX2VwX3F1ZXVlKCZtRXAtPmVwLCBtRXAtPnN0YXR1cywgR0ZQX0FUT01JQyk7CisJcmV0dmFsID0gdXNiX2VwX3F1ZXVlKCZtRXAtPmVwLCB1ZGMtPnN0YXR1cywgR0ZQX0FUT01JQyk7CiAJc3Bpbl9sb2NrKG1FcC0+bG9jayk7CiAKIAlyZXR1cm4gcmV0dmFsOwpAQCAtMTc3OCwxMSArMTc4OCwxMSBAQAogCiAJdHJhY2UoIiVwIiwgbUVwKTsKIAotCWlmIChsaXN0X2VtcHR5KCZtRXAtPnFoW21FcC0+ZGlyXS5xdWV1ZSkpCisJaWYgKGxpc3RfZW1wdHkoJm1FcC0+cWgucXVldWUpKQogCQlyZXR1cm4gLUVJTlZBTDsKIAogCS8qIHBvcCBvbGRlc3QgcmVxdWVzdCAqLwotCW1SZXEgPSBsaXN0X2VudHJ5KG1FcC0+cWhbbUVwLT5kaXJdLnF1ZXVlLm5leHQsCisJbVJlcSA9IGxpc3RfZW50cnkobUVwLT5xaC5xdWV1ZS5uZXh0LAogCQkJICBzdHJ1Y3QgY2kxM3h4eF9yZXEsIHF1ZXVlKTsKIAlsaXN0X2RlbF9pbml0KCZtUmVxLT5xdWV1ZSk7CiAKQEAgLTE3OTQsMTAgKzE4MDQsMTAgQEAKIAogCWRiZ19kb25lKF91c2JfYWRkcihtRXApLCBtUmVxLT5wdHItPnRva2VuLCByZXR2YWwpOwogCi0JaWYgKCFsaXN0X2VtcHR5KCZtRXAtPnFoW21FcC0+ZGlyXS5xdWV1ZSkpIHsKKwlpZiAoIWxpc3RfZW1wdHkoJm1FcC0+cWgucXVldWUpKSB7CiAJCXN0cnVjdCBjaTEzeHh4X3JlcSogbVJlcUVucTsKIAotCQltUmVxRW5xID0gbGlzdF9lbnRyeShtRXAtPnFoW21FcC0+ZGlyXS5xdWV1ZS5uZXh0LAorCQltUmVxRW5xID0gbGlzdF9lbnRyeShtRXAtPnFoLnF1ZXVlLm5leHQsCiAJCQkJICBzdHJ1Y3QgY2kxM3h4eF9yZXEsIHF1ZXVlKTsKIAkJX2hhcmR3YXJlX2VucXVldWUobUVwLCBtUmVxRW5xKTsKIAl9CkBAIC0xODM2LDE2ICsxODQ2LDE0IEBACiAJCWludCB0eXBlLCBudW0sIGVyciA9IC1FSU5WQUw7CiAJCXN0cnVjdCB1c2JfY3RybHJlcXVlc3QgcmVxOwogCi0KIAkJaWYgKG1FcC0+ZGVzYyA9PSBOVUxMKQogCQkJY29udGludWU7ICAgLyogbm90IGNvbmZpZ3VyZWQgKi8KIAotCQlpZiAoKG1FcC0+ZGlyID09IFJYICYmIGh3X3Rlc3RfYW5kX2NsZWFyX2NvbXBsZXRlKGkpKSB8fAotCQkgICAgKG1FcC0+ZGlyID09IFRYICYmIGh3X3Rlc3RfYW5kX2NsZWFyX2NvbXBsZXRlKGkgKyAxNikpKSB7CisJCWlmIChod190ZXN0X2FuZF9jbGVhcl9jb21wbGV0ZShpKSkgewogCQkJZXJyID0gaXNyX3RyX2NvbXBsZXRlX2xvdyhtRXApOwogCQkJaWYgKG1FcC0+dHlwZSA9PSBVU0JfRU5EUE9JTlRfWEZFUl9DT05UUk9MKSB7CiAJCQkJaWYgKGVyciA+IDApICAgLyogbmVlZHMgc3RhdHVzIHBoYXNlICovCi0JCQkJCWVyciA9IGlzcl9zZXR1cF9zdGF0dXNfcGhhc2UobUVwKTsKKwkJCQkJZXJyID0gaXNyX3NldHVwX3N0YXR1c19waGFzZSh1ZGMpOwogCQkJCWlmIChlcnIgPCAwKSB7CiAJCQkJCWRiZ19ldmVudChfdXNiX2FkZHIobUVwKSwKIAkJCQkJCSAgIkVSUk9SIiwgZXJyKTsKQEAgLTE4NjYsMTUgKzE4NzQsMjIgQEAKIAkJCWNvbnRpbnVlOwogCQl9CiAKKwkJLyoKKwkJICogRmx1c2ggZGF0YSBhbmQgaGFuZHNoYWtlIHRyYW5zYWN0aW9ucyBvZiBwcmV2aW91cworCQkgKiBzZXR1cCBwYWNrZXQuCisJCSAqLworCQlfZXBfbnVrZSgmdWRjLT5lcDBvdXQpOworCQlfZXBfbnVrZSgmdWRjLT5lcDBpbik7CisKIAkJLyogcmVhZF9zZXR1cF9wYWNrZXQgKi8KIAkJZG8gewogCQkJaHdfdGVzdF9hbmRfc2V0X3NldHVwX2d1YXJkKCk7Ci0JCQltZW1jcHkoJnJlcSwgJm1FcC0+cWhbUlhdLnB0ci0+c2V0dXAsIHNpemVvZihyZXEpKTsKKwkJCW1lbWNweSgmcmVxLCAmbUVwLT5xaC5wdHItPnNldHVwLCBzaXplb2YocmVxKSk7CiAJCX0gd2hpbGUgKCFod190ZXN0X2FuZF9jbGVhcl9zZXR1cF9ndWFyZCgpKTsKIAogCQl0eXBlID0gcmVxLmJSZXF1ZXN0VHlwZTsKIAotCQltRXAtPmRpciA9ICh0eXBlICYgVVNCX0RJUl9JTikgPyBUWCA6IFJYOworCQl1ZGMtPmVwMF9kaXIgPSAodHlwZSAmIFVTQl9ESVJfSU4pID8gVFggOiBSWDsKIAogCQlkYmdfc2V0dXAoX3VzYl9hZGRyKG1FcCksICZyZXEpOwogCkBAIC0xODk1LDcgKzE5MTAsNyBAQAogCQkJCWlmIChlcnIpCiAJCQkJCWJyZWFrOwogCQkJfQotCQkJZXJyID0gaXNyX3NldHVwX3N0YXR1c19waGFzZShtRXApOworCQkJZXJyID0gaXNyX3NldHVwX3N0YXR1c19waGFzZSh1ZGMpOwogCQkJYnJlYWs7CiAJCWNhc2UgVVNCX1JFUV9HRVRfU1RBVFVTOgogCQkJaWYgKHR5cGUgIT0gKFVTQl9ESVJfSU58VVNCX1JFQ0lQX0RFVklDRSkgICAmJgpAQCAtMTkwNSw3ICsxOTIwLDcgQEAKIAkJCWlmIChsZTE2X3RvX2NwdShyZXEud0xlbmd0aCkgIT0gMiB8fAogCQkJICAgIGxlMTZfdG9fY3B1KHJlcS53VmFsdWUpICAhPSAwKQogCQkJCWJyZWFrOwotCQkJZXJyID0gaXNyX2dldF9zdGF0dXNfcmVzcG9uc2UobUVwLCAmcmVxKTsKKwkJCWVyciA9IGlzcl9nZXRfc3RhdHVzX3Jlc3BvbnNlKHVkYywgJnJlcSk7CiAJCQlicmVhazsKIAkJY2FzZSBVU0JfUkVRX1NFVF9BRERSRVNTOgogCQkJaWYgKHR5cGUgIT0gKFVTQl9ESVJfT1VUfFVTQl9SRUNJUF9ERVZJQ0UpKQpAQCAtMTkxNiw3ICsxOTMxLDcgQEAKIAkJCWVyciA9IGh3X3VzYl9zZXRfYWRkcmVzcygodTgpbGUxNl90b19jcHUocmVxLndWYWx1ZSkpOwogCQkJaWYgKGVycikKIAkJCQlicmVhazsKLQkJCWVyciA9IGlzcl9zZXR1cF9zdGF0dXNfcGhhc2UobUVwKTsKKwkJCWVyciA9IGlzcl9zZXR1cF9zdGF0dXNfcGhhc2UodWRjKTsKIAkJCWJyZWFrOwogCQljYXNlIFVTQl9SRVFfU0VUX0ZFQVRVUkU6CiAJCQlpZiAodHlwZSAhPSAoVVNCX0RJUl9PVVR8VVNCX1JFQ0lQX0VORFBPSU5UKSAmJgpAQCAtMTkzMiwxMiArMTk0NywxMiBAQAogCQkJc3Bpbl9sb2NrKHVkYy0+bG9jayk7CiAJCQlpZiAoZXJyKQogCQkJCWJyZWFrOwotCQkJZXJyID0gaXNyX3NldHVwX3N0YXR1c19waGFzZShtRXApOworCQkJZXJyID0gaXNyX3NldHVwX3N0YXR1c19waGFzZSh1ZGMpOwogCQkJYnJlYWs7CiAJCWRlZmF1bHQ6CiBkZWxlZ2F0ZToKIAkJCWlmIChyZXEud0xlbmd0aCA9PSAwKSAgIC8qIG5vIGRhdGEgcGhhc2UgKi8KLQkJCQltRXAtPmRpciA9IFRYOworCQkJCXVkYy0+ZXAwX2RpciA9IFRYOwogCiAJCQlzcGluX3VubG9jayh1ZGMtPmxvY2spOwogCQkJZXJyID0gdWRjLT5kcml2ZXItPnNldHVwKCZ1ZGMtPmdhZGdldCwgJnJlcSk7CkBAIC0xOTY4LDcgKzE5ODMsNyBAQAogCQkgICAgIGNvbnN0IHN0cnVjdCB1c2JfZW5kcG9pbnRfZGVzY3JpcHRvciAqZGVzYykKIHsKIAlzdHJ1Y3QgY2kxM3h4eF9lcCAqbUVwID0gY29udGFpbmVyX29mKGVwLCBzdHJ1Y3QgY2kxM3h4eF9lcCwgZXApOwotCWludCBkaXJlY3Rpb24sIHJldHZhbCA9IDA7CisJaW50IHJldHZhbCA9IDA7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCXRyYWNlKCIlcCwgJXAiLCBlcCwgZGVzYyk7CkBAIC0xOTgyLDcgKzE5OTcsNyBAQAogCiAJbUVwLT5kZXNjID0gZGVzYzsKIAotCWlmICghbGlzdF9lbXB0eSgmbUVwLT5xaFttRXAtPmRpcl0ucXVldWUpKQorCWlmICghbGlzdF9lbXB0eSgmbUVwLT5xaC5xdWV1ZSkpCiAJCXdhcm4oImVuYWJsaW5nIGEgbm9uLWVtcHR5IGVuZHBvaW50ISIpOwogCiAJbUVwLT5kaXIgID0gdXNiX2VuZHBvaW50X2Rpcl9pbihkZXNjKSA/IFRYIDogUlg7CkBAIC0xOTkxLDI5ICsyMDA2LDIyIEBACiAKIAltRXAtPmVwLm1heHBhY2tldCA9IF9fY29uc3RhbnRfbGUxNl90b19jcHUoZGVzYy0+d01heFBhY2tldFNpemUpOwogCi0JZGlyZWN0aW9uID0gbUVwLT5kaXI7Ci0JZG8gewotCQlkYmdfZXZlbnQoX3VzYl9hZGRyKG1FcCksICJFTkFCTEUiLCAwKTsKKwlkYmdfZXZlbnQoX3VzYl9hZGRyKG1FcCksICJFTkFCTEUiLCAwKTsKIAotCQltRXAtPnFoW21FcC0+ZGlyXS5wdHItPmNhcCA9IDA7CisJbUVwLT5xaC5wdHItPmNhcCA9IDA7CiAKLQkJaWYgKG1FcC0+dHlwZSA9PSBVU0JfRU5EUE9JTlRfWEZFUl9DT05UUk9MKQotCQkJbUVwLT5xaFttRXAtPmRpcl0ucHRyLT5jYXAgfD0gIFFIX0lPUzsKLQkJZWxzZSBpZiAobUVwLT50eXBlID09IFVTQl9FTkRQT0lOVF9YRkVSX0lTT0MpCi0JCQltRXAtPnFoW21FcC0+ZGlyXS5wdHItPmNhcCAmPSB+UUhfTVVMVDsKLQkJZWxzZQotCQkJbUVwLT5xaFttRXAtPmRpcl0ucHRyLT5jYXAgJj0gflFIX1pMVDsKKwlpZiAobUVwLT50eXBlID09IFVTQl9FTkRQT0lOVF9YRkVSX0NPTlRST0wpCisJCW1FcC0+cWgucHRyLT5jYXAgfD0gIFFIX0lPUzsKKwllbHNlIGlmIChtRXAtPnR5cGUgPT0gVVNCX0VORFBPSU5UX1hGRVJfSVNPQykKKwkJbUVwLT5xaC5wdHItPmNhcCAmPSB+UUhfTVVMVDsKKwllbHNlCisJCW1FcC0+cWgucHRyLT5jYXAgJj0gflFIX1pMVDsKIAotCQltRXAtPnFoW21FcC0+ZGlyXS5wdHItPmNhcCB8PQotCQkJKG1FcC0+ZXAubWF4cGFja2V0IDw8IGZmc19ucihRSF9NQVhfUEtUKSkgJiBRSF9NQVhfUEtUOwotCQltRXAtPnFoW21FcC0+ZGlyXS5wdHItPnRkLm5leHQgfD0gVERfVEVSTUlOQVRFOyAgIC8qIG5lZWRlZD8gKi8KKwltRXAtPnFoLnB0ci0+Y2FwIHw9CisJCShtRXAtPmVwLm1heHBhY2tldCA8PCBmZnNfbnIoUUhfTUFYX1BLVCkpICYgUUhfTUFYX1BLVDsKKwltRXAtPnFoLnB0ci0+dGQubmV4dCB8PSBURF9URVJNSU5BVEU7ICAgLyogbmVlZGVkPyAqLwogCi0JCXJldHZhbCB8PSBod19lcF9lbmFibGUobUVwLT5udW0sIG1FcC0+ZGlyLCBtRXAtPnR5cGUpOwotCi0JCWlmIChtRXAtPnR5cGUgPT0gVVNCX0VORFBPSU5UX1hGRVJfQ09OVFJPTCkKLQkJCW1FcC0+ZGlyID0gKG1FcC0+ZGlyID09IFRYKSA/IFJYIDogVFg7Ci0KLQl9IHdoaWxlIChtRXAtPmRpciAhPSBkaXJlY3Rpb24pOworCXJldHZhbCB8PSBod19lcF9lbmFibGUobUVwLT5udW0sIG1FcC0+ZGlyLCBtRXAtPnR5cGUpOwogCiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZShtRXAtPmxvY2ssIGZsYWdzKTsKIAlyZXR1cm4gcmV0dmFsOwpAQCAtMjE0Niw3ICsyMTU0LDcgQEAKIAlzcGluX2xvY2tfaXJxc2F2ZShtRXAtPmxvY2ssIGZsYWdzKTsKIAogCWlmIChtRXAtPnR5cGUgPT0gVVNCX0VORFBPSU5UX1hGRVJfQ09OVFJPTCAmJgotCSAgICAhbGlzdF9lbXB0eSgmbUVwLT5xaFttRXAtPmRpcl0ucXVldWUpKSB7CisJICAgICFsaXN0X2VtcHR5KCZtRXAtPnFoLnF1ZXVlKSkgewogCQlfZXBfbnVrZShtRXApOwogCQlyZXR2YWwgPSAtRU9WRVJGTE9XOwogCQl3YXJuKCJlbmRwb2ludCBjdHJsICVYIG51a2VkIiwgX3VzYl9hZGRyKG1FcCkpOwpAQCAtMjE3MCw5ICsyMTc4LDkgQEAKIAkvKiBwdXNoIHJlcXVlc3QgKi8KIAltUmVxLT5yZXEuc3RhdHVzID0gLUVJTlBST0dSRVNTOwogCW1SZXEtPnJlcS5hY3R1YWwgPSAwOwotCWxpc3RfYWRkX3RhaWwoJm1SZXEtPnF1ZXVlLCAmbUVwLT5xaFttRXAtPmRpcl0ucXVldWUpOworCWxpc3RfYWRkX3RhaWwoJm1SZXEtPnF1ZXVlLCAmbUVwLT5xaC5xdWV1ZSk7CiAKLQlpZiAobGlzdF9pc19zaW5ndWxhcigmbUVwLT5xaFttRXAtPmRpcl0ucXVldWUpKQorCWlmIChsaXN0X2lzX3Npbmd1bGFyKCZtRXAtPnFoLnF1ZXVlKSkKIAkJcmV0dmFsID0gX2hhcmR3YXJlX2VucXVldWUobUVwLCBtUmVxKTsKIAogCWlmIChyZXR2YWwgPT0gLUVBTFJFQURZKSB7CkBAIC0yMTk5LDcgKzIyMDcsNyBAQAogCXRyYWNlKCIlcCwgJXAiLCBlcCwgcmVxKTsKIAogCWlmIChlcCA9PSBOVUxMIHx8IHJlcSA9PSBOVUxMIHx8IG1FcC0+ZGVzYyA9PSBOVUxMIHx8Ci0JICAgIGxpc3RfZW1wdHkoJm1SZXEtPnF1ZXVlKSAgfHwgbGlzdF9lbXB0eSgmbUVwLT5xaFttRXAtPmRpcl0ucXVldWUpKQorCSAgICBsaXN0X2VtcHR5KCZtUmVxLT5xdWV1ZSkgIHx8IGxpc3RfZW1wdHkoJm1FcC0+cWgucXVldWUpKQogCQlyZXR1cm4gLUVJTlZBTDsKIAogCXNwaW5fbG9ja19pcnFzYXZlKG1FcC0+bG9jaywgZmxhZ3MpOwpAQCAtMjI0NCw3ICsyMjUyLDcgQEAKICNpZm5kZWYgU1RBTExfSU4KIAkvKiBnX2ZpbGVfc3RvcmFnZSBNUyBjb21wbGlhbnQgYnV0IGdfemVybyBmYWlscyBjaGFwdGVyIDkgY29tcGxpYW5jZSAqLwogCWlmICh2YWx1ZSAmJiBtRXAtPnR5cGUgPT0gVVNCX0VORFBPSU5UX1hGRVJfQlVMSyAmJiBtRXAtPmRpciA9PSBUWCAmJgotCSAgICAhbGlzdF9lbXB0eSgmbUVwLT5xaFttRXAtPmRpcl0ucXVldWUpKSB7CisJICAgICFsaXN0X2VtcHR5KCZtRXAtPnFoLnF1ZXVlKSkgewogCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKG1FcC0+bG9jaywgZmxhZ3MpOwogCQlyZXR1cm4gLUVBR0FJTjsKIAl9CkBAIC0yMzU1LDcgKzIzNjMsNyBAQAogCQlpZiAoaXNfYWN0aXZlKSB7CiAJCQlwbV9ydW50aW1lX2dldF9zeW5jKCZfZ2FkZ2V0LT5kZXYpOwogCQkJaHdfZGV2aWNlX3Jlc2V0KHVkYyk7Ci0JCQlod19kZXZpY2Vfc3RhdGUodWRjLT5jaTEzeHh4X2VwWzBdLnFoW1JYXS5kbWEpOworCQkJaHdfZGV2aWNlX3N0YXRlKHVkYy0+ZXAwb3V0LnFoLmRtYSk7CiAJCX0gZWxzZSB7CiAJCQlod19kZXZpY2Vfc3RhdGUoMCk7CiAJCQlpZiAodWRjLT51ZGNfZHJpdmVyLT5ub3RpZnlfZXZlbnQpCkBAIC0yMzkwLDcgKzIzOTgsOCBAQAogCQlpbnQgKCpiaW5kKShzdHJ1Y3QgdXNiX2dhZGdldCAqKSkKIHsKIAlzdHJ1Y3QgY2kxM3h4eCAqdWRjID0gX3VkYzsKLQl1bnNpZ25lZCBsb25nIGksIGssIGZsYWdzOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJaW50IGksIGo7CiAJaW50IHJldHZhbCA9IC1FTk9NRU07CiAKIAl0cmFjZSgiJXAiLCBkcml2ZXIpOwpAQCAtMjQyNyw0NSArMjQzNiw0NiBAQAogCiAJaW5mbygiaHdfZXBfbWF4ID0gJWQiLCBod19lcF9tYXgpOwogCi0JdWRjLT5kcml2ZXIgPSBkcml2ZXI7CiAJdWRjLT5nYWRnZXQuZGV2LmRyaXZlciA9IE5VTEw7CiAKIAlyZXR2YWwgPSAwOwotCWZvciAoaSA9IDA7IGkgPCBod19lcF9tYXg7IGkrKykgewotCQlzdHJ1Y3QgY2kxM3h4eF9lcCAqbUVwID0gJnVkYy0+Y2kxM3h4eF9lcFtpXTsKKwlmb3IgKGkgPSAwOyBpIDwgaHdfZXBfbWF4LzI7IGkrKykgeworCQlmb3IgKGogPSBSWDsgaiA8PSBUWDsgaisrKSB7CisJCQlpbnQgayA9IGkgKyBqICogaHdfZXBfbWF4LzI7CisJCQlzdHJ1Y3QgY2kxM3h4eF9lcCAqbUVwID0gJnVkYy0+Y2kxM3h4eF9lcFtrXTsKIAotCQlzY25wcmludGYobUVwLT5uYW1lLCBzaXplb2YobUVwLT5uYW1lKSwgImVwJWkiLCAoaW50KWkpOworCQkJc2NucHJpbnRmKG1FcC0+bmFtZSwgc2l6ZW9mKG1FcC0+bmFtZSksICJlcCVpJXMiLCBpLAorCQkJCQkoaiA9PSBUWCkgID8gImluIiA6ICJvdXQiKTsKIAotCQltRXAtPmxvY2sgICAgICAgICA9IHVkYy0+bG9jazsKLQkJbUVwLT5kZXZpY2UgICAgICAgPSAmdWRjLT5nYWRnZXQuZGV2OwotCQltRXAtPnRkX3Bvb2wgICAgICA9IHVkYy0+dGRfcG9vbDsKKwkJCW1FcC0+bG9jayAgICAgICAgID0gdWRjLT5sb2NrOworCQkJbUVwLT5kZXZpY2UgICAgICAgPSAmdWRjLT5nYWRnZXQuZGV2OworCQkJbUVwLT50ZF9wb29sICAgICAgPSB1ZGMtPnRkX3Bvb2w7CiAKLQkJbUVwLT5lcC5uYW1lICAgICAgPSBtRXAtPm5hbWU7Ci0JCW1FcC0+ZXAub3BzICAgICAgID0gJnVzYl9lcF9vcHM7Ci0JCW1FcC0+ZXAubWF4cGFja2V0ID0gQ1RSTF9QQVlMT0FEX01BWDsKKwkJCW1FcC0+ZXAubmFtZSAgICAgID0gbUVwLT5uYW1lOworCQkJbUVwLT5lcC5vcHMgICAgICAgPSAmdXNiX2VwX29wczsKKwkJCW1FcC0+ZXAubWF4cGFja2V0ID0gQ1RSTF9QQVlMT0FEX01BWDsKIAotCQkvKiB0aGlzIGFsbG9jYXRpb24gY2Fubm90IGJlIHJhbmRvbSAqLwotCQlmb3IgKGsgPSBSWDsgayA8PSBUWDsgaysrKSB7Ci0JCQlJTklUX0xJU1RfSEVBRCgmbUVwLT5xaFtrXS5xdWV1ZSk7CisJCQlJTklUX0xJU1RfSEVBRCgmbUVwLT5xaC5xdWV1ZSk7CiAJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKHVkYy0+bG9jaywgZmxhZ3MpOwotCQkJbUVwLT5xaFtrXS5wdHIgPSBkbWFfcG9vbF9hbGxvYyh1ZGMtPnFoX3Bvb2wsCi0JCQkJCQkJR0ZQX0tFUk5FTCwKLQkJCQkJCQkmbUVwLT5xaFtrXS5kbWEpOworCQkJbUVwLT5xaC5wdHIgPSBkbWFfcG9vbF9hbGxvYyh1ZGMtPnFoX3Bvb2wsIEdGUF9LRVJORUwsCisJCQkJCSZtRXAtPnFoLmRtYSk7CiAJCQlzcGluX2xvY2tfaXJxc2F2ZSh1ZGMtPmxvY2ssIGZsYWdzKTsKLQkJCWlmIChtRXAtPnFoW2tdLnB0ciA9PSBOVUxMKQorCQkJaWYgKG1FcC0+cWgucHRyID09IE5VTEwpCiAJCQkJcmV0dmFsID0gLUVOT01FTTsKIAkJCWVsc2UKLQkJCQltZW1zZXQobUVwLT5xaFtrXS5wdHIsIDAsCi0JCQkJICAgICAgIHNpemVvZigqbUVwLT5xaFtrXS5wdHIpKTsKLQkJfQotCQlpZiAoaSA9PSAwKQotCQkJdWRjLT5nYWRnZXQuZXAwID0gJm1FcC0+ZXA7Ci0JCWVsc2UKKwkJCQltZW1zZXQobUVwLT5xaC5wdHIsIDAsIHNpemVvZigqbUVwLT5xaC5wdHIpKTsKKworCQkJLyogc2tpcCBlcDAgb3V0IGFuZCBpbiBlbmRwb2ludHMgKi8KKwkJCWlmIChpID09IDApCisJCQkJY29udGludWU7CisKIAkJCWxpc3RfYWRkX3RhaWwoJm1FcC0+ZXAuZXBfbGlzdCwgJnVkYy0+Z2FkZ2V0LmVwX2xpc3QpOworCQl9CiAJfQogCWlmIChyZXR2YWwpCiAJCWdvdG8gZG9uZTsKIAorCXVkYy0+Z2FkZ2V0LmVwMCA9ICZ1ZGMtPmVwMGluLmVwOwogCS8qIGJpbmQgZ2FkZ2V0ICovCiAJZHJpdmVyLT5kcml2ZXIuYnVzICAgICA9IE5VTEw7CiAJdWRjLT5nYWRnZXQuZGV2LmRyaXZlciA9ICZkcml2ZXItPmRyaXZlcjsKQEAgLTI0NzksNiArMjQ4OSw3IEBACiAJCWdvdG8gZG9uZTsKIAl9CiAKKwl1ZGMtPmRyaXZlciA9IGRyaXZlcjsKIAlwbV9ydW50aW1lX2dldF9zeW5jKCZ1ZGMtPmdhZGdldC5kZXYpOwogCWlmICh1ZGMtPnVkY19kcml2ZXItPmZsYWdzICYgQ0kxM1hYWF9QVUxMVVBfT05fVkJVUykgewogCQlpZiAodWRjLT52YnVzX2FjdGl2ZSkgewpAQCAtMjQ5MCwxNCArMjUwMSwxMiBAQAogCQl9CiAJfQogCi0JcmV0dmFsID0gaHdfZGV2aWNlX3N0YXRlKHVkYy0+Y2kxM3h4eF9lcFswXS5xaFtSWF0uZG1hKTsKKwlyZXR2YWwgPSBod19kZXZpY2Vfc3RhdGUodWRjLT5lcDBvdXQucWguZG1hKTsKIAlpZiAocmV0dmFsKQogCQlwbV9ydW50aW1lX3B1dF9zeW5jKCZ1ZGMtPmdhZGdldC5kZXYpOwogCiAgZG9uZToKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKHVkYy0+bG9jaywgZmxhZ3MpOwotCWlmIChyZXR2YWwpCi0JCXVzYl9nYWRnZXRfdW5yZWdpc3Rlcl9kcml2ZXIoZHJpdmVyKTsKIAlyZXR1cm4gcmV0dmFsOwogfQogRVhQT1JUX1NZTUJPTCh1c2JfZ2FkZ2V0X3Byb2JlX2RyaXZlcik7CkBAIC0yNTEwLDcgKzI1MTksNyBAQAogaW50IHVzYl9nYWRnZXRfdW5yZWdpc3Rlcl9kcml2ZXIoc3RydWN0IHVzYl9nYWRnZXRfZHJpdmVyICpkcml2ZXIpCiB7CiAJc3RydWN0IGNpMTN4eHggKnVkYyA9IF91ZGM7Ci0JdW5zaWduZWQgbG9uZyBpLCBrLCBmbGFnczsKKwl1bnNpZ25lZCBsb25nIGksIGZsYWdzOwogCiAJdHJhY2UoIiVwIiwgZHJpdmVyKTsKIApAQCAtMjU0NiwxNyArMjU1NSwxNCBAQAogCWZvciAoaSA9IDA7IGkgPCBod19lcF9tYXg7IGkrKykgewogCQlzdHJ1Y3QgY2kxM3h4eF9lcCAqbUVwID0gJnVkYy0+Y2kxM3h4eF9lcFtpXTsKIAotCQlpZiAoaSA9PSAwKQotCQkJdWRjLT5nYWRnZXQuZXAwID0gTlVMTDsKLQkJZWxzZSBpZiAoIWxpc3RfZW1wdHkoJm1FcC0+ZXAuZXBfbGlzdCkpCisJCWlmICghbGlzdF9lbXB0eSgmbUVwLT5lcC5lcF9saXN0KSkKIAkJCWxpc3RfZGVsX2luaXQoJm1FcC0+ZXAuZXBfbGlzdCk7CiAKLQkJZm9yIChrID0gUlg7IGsgPD0gVFg7IGsrKykKLQkJCWlmIChtRXAtPnFoW2tdLnB0ciAhPSBOVUxMKQotCQkJCWRtYV9wb29sX2ZyZWUodWRjLT5xaF9wb29sLAotCQkJCQkgICAgICBtRXAtPnFoW2tdLnB0ciwgbUVwLT5xaFtrXS5kbWEpOworCQlpZiAobUVwLT5xaC5wdHIgIT0gTlVMTCkKKwkJCWRtYV9wb29sX2ZyZWUodWRjLT5xaF9wb29sLCBtRXAtPnFoLnB0ciwgbUVwLT5xaC5kbWEpOwogCX0KIAorCXVkYy0+Z2FkZ2V0LmVwMCA9IE5VTEw7CiAJdWRjLT5kcml2ZXIgPSBOVUxMOwogCiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSh1ZGMtPmxvY2ssIGZsYWdzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2dhZGdldC9jaTEzeHh4X3VkYy5oIGIvZHJpdmVycy91c2IvZ2FkZ2V0L2NpMTN4eHhfdWRjLmgKaW5kZXggZjYxZmVkMC4uYTI0OTJiNiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvZ2FkZ2V0L2NpMTN4eHhfdWRjLmgKKysrIGIvZHJpdmVycy91c2IvZ2FkZ2V0L2NpMTN4eHhfdWRjLmgKQEAgLTIwLDcgKzIwLDcgQEAKICAqIERFRklORQogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogI2RlZmluZSBDSTEzWFhYX1BBR0VfU0laRSAgNDA5NnVsIC8qIHBhZ2Ugc2l6ZSBmb3IgVEQncyAqLwotI2RlZmluZSBFTkRQVF9NQVggICAgICAgICAgKDE2KQorI2RlZmluZSBFTkRQVF9NQVggICAgICAgICAgKDMyKQogI2RlZmluZSBDVFJMX1BBWUxPQURfTUFYICAgKDY0KQogI2RlZmluZSBSWCAgICAgICAgKDApICAvKiBzaW1pbGFyIHRvIFVTQl9ESVJfT1VUIGJ1dCBjYW4gYmUgdXNlZCBhcyBhbiBpbmRleCAqLwogI2RlZmluZSBUWCAgICAgICAgKDEpICAvKiBzaW1pbGFyIHRvIFVTQl9ESVJfSU4gIGJ1dCBjYW4gYmUgdXNlZCBhcyBhbiBpbmRleCAqLwpAQCAtODgsOCArODgsNyBAQAogCQlzdHJ1Y3QgbGlzdF9oZWFkICAgcXVldWU7CiAJCXN0cnVjdCBjaTEzeHh4X3FoICpwdHI7CiAJCWRtYV9hZGRyX3QgICAgICAgICBkbWE7Ci0JfSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcWhbMl07Ci0Jc3RydWN0IHVzYl9yZXF1ZXN0ICAgICAgICAgICAgICAgICAgICAqc3RhdHVzOworCX0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHFoOwogCWludCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHdlZGdlOwogCiAJLyogZ2xvYmFsIHJlc291cmNlcyAqLwpAQCAtMTE5LDkgKzExOCwxMyBAQAogCiAJc3RydWN0IGRtYV9wb29sICAgICAgICAgICAqcWhfcG9vbDsgICAvKiBETUEgcG9vbCBmb3IgcXVldWUgaGVhZHMgKi8KIAlzdHJ1Y3QgZG1hX3Bvb2wgICAgICAgICAgICp0ZF9wb29sOyAgIC8qIERNQSBwb29sIGZvciB0cmFuc2ZlciBkZXNjcyAqLworCXN0cnVjdCB1c2JfcmVxdWVzdCAgICAgICAgKnN0YXR1czsgICAgLyogZXAwIHN0YXR1cyByZXF1ZXN0ICovCiAKIAlzdHJ1Y3QgdXNiX2dhZGdldCAgICAgICAgICBnYWRnZXQ7ICAgICAvKiBVU0Igc2xhdmUgZGV2aWNlICovCiAJc3RydWN0IGNpMTN4eHhfZXAgICAgICAgICAgY2kxM3h4eF9lcFtFTkRQVF9NQVhdOyAvKiBleHRlbmRlZCBlbmRwdHMgKi8KKwl1MzIgICAgICAgICAgICAgICAgICAgICAgICBlcDBfZGlyOyAgICAvKiBlcDAgZGlyZWN0aW9uICovCisjZGVmaW5lIGVwMG91dCBjaTEzeHh4X2VwWzBdCisjZGVmaW5lIGVwMGluICBjaTEzeHh4X2VwWzE2XQogCiAJc3RydWN0IHVzYl9nYWRnZXRfZHJpdmVyICAqZHJpdmVyOyAgICAgLyogM3JkIHBhcnR5IGdhZGdldCBkcml2ZXIgKi8KIAlzdHJ1Y3QgY2kxM3h4eF91ZGNfZHJpdmVyICp1ZGNfZHJpdmVyOyAvKiBkZXZpY2UgY29udHJvbGxlciBkcml2ZXIgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2dhZGdldC9jb21wb3NpdGUuYyBiL2RyaXZlcnMvdXNiL2dhZGdldC9jb21wb3NpdGUuYwppbmRleCBmNmZmODQ1Li4xYmE0YmVmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvY29tcG9zaXRlLmMKKysrIGIvZHJpdmVycy91c2IvZ2FkZ2V0L2NvbXBvc2l0ZS5jCkBAIC05MjgsOCArOTI4LDkgQEAKIAkJICovCiAJCXN3aXRjaCAoY3RybC0+YlJlcXVlc3RUeXBlICYgVVNCX1JFQ0lQX01BU0spIHsKIAkJY2FzZSBVU0JfUkVDSVBfSU5URVJGQUNFOgotCQkJaWYgKGNkZXYtPmNvbmZpZykKLQkJCQlmID0gY2Rldi0+Y29uZmlnLT5pbnRlcmZhY2VbaW50Zl07CisJCQlpZiAoIWNkZXYtPmNvbmZpZyB8fCB3X2luZGV4ID49IE1BWF9DT05GSUdfSU5URVJGQUNFUykKKwkJCQlicmVhazsKKwkJCWYgPSBjZGV2LT5jb25maWctPmludGVyZmFjZVtpbnRmXTsKIAkJCWJyZWFrOwogCiAJCWNhc2UgVVNCX1JFQ0lQX0VORFBPSU5UOgpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvZ2FkZ2V0L2ZfbWFzc19zdG9yYWdlLmMgYi9kcml2ZXJzL3VzYi9nYWRnZXQvZl9tYXNzX3N0b3JhZ2UuYwppbmRleCBiNWRiYjIzLi42ZDhlNTMzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvZl9tYXNzX3N0b3JhZ2UuYworKysgYi9kcml2ZXJzL3VzYi9nYWRnZXQvZl9tYXNzX3N0b3JhZ2UuYwpAQCAtMjkzLDYgKzI5Myw3IEBACiAKICNpbmNsdWRlIDxsaW51eC91c2IvY2g5Lmg+CiAjaW5jbHVkZSA8bGludXgvdXNiL2dhZGdldC5oPgorI2luY2x1ZGUgPGxpbnV4L3VzYi9jb21wb3NpdGUuaD4KIAogI2luY2x1ZGUgImdhZGdldF9jaGlwcy5oIgogCkBAIC0yNzYzLDcgKzI3NjQsNyBAQAogCQkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CiAJCWNvbW1vbi0+ZnJlZV9zdG9yYWdlX29uX3JlbGVhc2UgPSAxOwogCX0gZWxzZSB7Ci0JCW1lbXNldChjb21tb24sIDAsIHNpemVvZiBjb21tb24pOworCQltZW1zZXQoY29tbW9uLCAwLCBzaXplb2YgKmNvbW1vbik7CiAJCWNvbW1vbi0+ZnJlZV9zdG9yYWdlX29uX3JlbGVhc2UgPSAwOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvZ2FkZ2V0L3BjaF91ZGMuYyBiL2RyaXZlcnMvdXNiL2dhZGdldC9wY2hfdWRjLmMKaW5kZXggMGM4ZGQ4MS4uYjEyMGRiYiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvZ2FkZ2V0L3BjaF91ZGMuYworKysgYi9kcml2ZXJzL3VzYi9nYWRnZXQvcGNoX3VkYy5jCkBAIC0xOTgsMTAgKzE5OCwxMCBAQAogI2RlZmluZSBQQ0hfVURDX0JSTEVOCQkweDBGCS8qIEJ1cnN0IGxlbmd0aCAqLwogI2RlZmluZSBQQ0hfVURDX1RITEVOCQkweDFGCS8qIFRocmVzaG9sZCBsZW5ndGggKi8KIC8qIFZhbHVlIG9mIEVQIEJ1ZmZlciBTaXplICovCi0jZGVmaW5lIFVEQ19FUDBJTl9CVUZGX1NJWkUJNjQKLSNkZWZpbmUgVURDX0VQSU5fQlVGRl9TSVpFCTUxMgotI2RlZmluZSBVRENfRVAwT1VUX0JVRkZfU0laRQk2NAotI2RlZmluZSBVRENfRVBPVVRfQlVGRl9TSVpFCTUxMgorI2RlZmluZSBVRENfRVAwSU5fQlVGRl9TSVpFCTE2CisjZGVmaW5lIFVEQ19FUElOX0JVRkZfU0laRQkyNTYKKyNkZWZpbmUgVURDX0VQME9VVF9CVUZGX1NJWkUJMTYKKyNkZWZpbmUgVURDX0VQT1VUX0JVRkZfU0laRQkyNTYKIC8qIFZhbHVlIG9mIEVQIG1heGltdW0gcGFja2V0IHNpemUgKi8KICNkZWZpbmUgVURDX0VQMElOX01BWF9QS1RfU0laRQk2NAogI2RlZmluZSBVRENfRVAwT1VUX01BWF9QS1RfU0laRQk2NApAQCAtMzUxLDcgKzM1MSw3IEBACiAJc3RydWN0IHBjaV9wb29sCQkqZGF0YV9yZXF1ZXN0czsKIAlzdHJ1Y3QgcGNpX3Bvb2wJCSpzdHBfcmVxdWVzdHM7CiAJZG1hX2FkZHJfdAkJCWRtYV9hZGRyOwotCXVuc2lnbmVkIGxvbmcJCQllcDBvdXRfYnVmWzY0XTsKKwl2b2lkCQkJCSplcDBvdXRfYnVmOwogCXN0cnVjdCB1c2JfY3RybHJlcXVlc3QJCXNldHVwX2RhdGE7CiAJdW5zaWduZWQgbG9uZwkJCXBoeXNfYWRkcjsKIAl2b2lkIF9faW9tZW0JCQkqYmFzZV9hZGRyOwpAQCAtMzYxLDYgKzM2MSw4IEBACiAKICNkZWZpbmUgUENIX1VEQ19QQ0lfQkFSCQkJMQogI2RlZmluZSBQQ0lfREVWSUNFX0lEX0lOVEVMX0VHMjBUX1VEQwkweDg4MDgKKyNkZWZpbmUgUENJX1ZFTkRPUl9JRF9ST0hNCQkweDEwREIKKyNkZWZpbmUgUENJX0RFVklDRV9JRF9NTDcyMTNfSU9IX1VEQwkweDgwMUQKIAogc3RhdGljIGNvbnN0IGNoYXIJZXAwX3N0cmluZ1tdID0gImVwMGluIjsKIHN0YXRpYyBERUZJTkVfU1BJTkxPQ0sodWRjX3N0YWxsX3NwaW5sb2NrKTsJLyogc3RhbGwgc3BpbiBsb2NrICovCkBAIC0xMjE5LDExICsxMjIxLDExIEBACiAJZGV2ID0gZXAtPmRldjsKIAlpZiAocmVxLT5kbWFfbWFwcGVkKSB7CiAJCWlmIChlcC0+aW4pCi0JCQlwY2lfdW5tYXBfc2luZ2xlKGRldi0+cGRldiwgcmVxLT5yZXEuZG1hLAotCQkJCQkgcmVxLT5yZXEubGVuZ3RoLCBQQ0lfRE1BX1RPREVWSUNFKTsKKwkJCWRtYV91bm1hcF9zaW5nbGUoJmRldi0+cGRldi0+ZGV2LCByZXEtPnJlcS5kbWEsCisJCQkJCSByZXEtPnJlcS5sZW5ndGgsIERNQV9UT19ERVZJQ0UpOwogCQllbHNlCi0JCQlwY2lfdW5tYXBfc2luZ2xlKGRldi0+cGRldiwgcmVxLT5yZXEuZG1hLAotCQkJCQkgcmVxLT5yZXEubGVuZ3RoLCBQQ0lfRE1BX0ZST01ERVZJQ0UpOworCQkJZG1hX3VubWFwX3NpbmdsZSgmZGV2LT5wZGV2LT5kZXYsIHJlcS0+cmVxLmRtYSwKKwkJCQkJIHJlcS0+cmVxLmxlbmd0aCwgRE1BX0ZST01fREVWSUNFKTsKIAkJcmVxLT5kbWFfbWFwcGVkID0gMDsKIAkJcmVxLT5yZXEuZG1hID0gRE1BX0FERFJfSU5WQUxJRDsKIAl9CkBAIC0xNDE0LDcgKzE0MTYsNiBAQAogCiAJcGNoX3VkY19jbGVhcl9kbWEoZXAtPmRldiwgRE1BX0RJUl9SWCk7CiAJdGRfZGF0YSA9IHJlcS0+dGRfZGF0YTsKLQllcC0+dGRfZGF0YSA9IHJlcS0+dGRfZGF0YTsKIAkvKiBTZXQgdGhlIHN0YXR1cyBiaXRzIGZvciBhbGwgZGVzY3JpcHRvcnMgKi8KIAl3aGlsZSAoMSkgewogCQl0ZF9kYXRhLT5zdGF0dXMgPSAodGRfZGF0YS0+c3RhdHVzICYgflBDSF9VRENfQlVGRl9TVFMpIHwKQEAgLTE2MTMsMTUgKzE2MTQsMTkgQEAKIAlpZiAodXNicmVxLT5sZW5ndGggJiYKIAkgICAgKCh1c2JyZXEtPmRtYSA9PSBETUFfQUREUl9JTlZBTElEKSB8fCAhdXNicmVxLT5kbWEpKSB7CiAJCWlmIChlcC0+aW4pCi0JCQl1c2JyZXEtPmRtYSA9IHBjaV9tYXBfc2luZ2xlKGRldi0+cGRldiwgdXNicmVxLT5idWYsCi0JCQkJCXVzYnJlcS0+bGVuZ3RoLCBQQ0lfRE1BX1RPREVWSUNFKTsKKwkJCXVzYnJlcS0+ZG1hID0gZG1hX21hcF9zaW5nbGUoJmRldi0+cGRldi0+ZGV2LAorCQkJCQkJICAgICB1c2JyZXEtPmJ1ZiwKKwkJCQkJCSAgICAgdXNicmVxLT5sZW5ndGgsCisJCQkJCQkgICAgIERNQV9UT19ERVZJQ0UpOwogCQllbHNlCi0JCQl1c2JyZXEtPmRtYSA9IHBjaV9tYXBfc2luZ2xlKGRldi0+cGRldiwgdXNicmVxLT5idWYsCi0JCQkJCXVzYnJlcS0+bGVuZ3RoLCBQQ0lfRE1BX0ZST01ERVZJQ0UpOworCQkJdXNicmVxLT5kbWEgPSBkbWFfbWFwX3NpbmdsZSgmZGV2LT5wZGV2LT5kZXYsCisJCQkJCQkgICAgIHVzYnJlcS0+YnVmLAorCQkJCQkJICAgICB1c2JyZXEtPmxlbmd0aCwKKwkJCQkJCSAgICAgRE1BX0ZST01fREVWSUNFKTsKIAkJcmVxLT5kbWFfbWFwcGVkID0gMTsKIAl9CiAJaWYgKHVzYnJlcS0+bGVuZ3RoID4gMCkgewotCQlyZXR2YWwgPSBwcmVwYXJlX2RtYShlcCwgcmVxLCBnZnApOworCQlyZXR2YWwgPSBwcmVwYXJlX2RtYShlcCwgcmVxLCBHRlBfQVRPTUlDKTsKIAkJaWYgKHJldHZhbCkKIAkJCWdvdG8gcHJvYmVfZW5kOwogCX0KQEAgLTE2NDYsNyArMTY1MSw2IEBACiAJCQlwY2hfdWRjX3dhaXRfZXBfc3RhbGwoZXApOwogCQkJcGNoX3VkY19lcF9jbGVhcl9uYWsoZXApOwogCQkJcGNoX3VkY19lbmFibGVfZXBfaW50ZXJydXB0cyhlcC0+ZGV2LCAoMSA8PCBlcC0+bnVtKSk7Ci0JCQlwY2hfdWRjX3NldF9kbWEoZGV2LCBETUFfRElSX1RYKTsKIAkJfQogCX0KIAkvKiBOb3cgYWRkIHRoaXMgcmVxdWVzdCB0byB0aGUgZXAncyBwZW5kaW5nIHJlcXVlc3RzICovCkBAIC0xOTI2LDYgKzE5MzAsNyBAQAogCSAgICBQQ0hfVURDX0JTX0RNQV9ET05FKQogCQlyZXR1cm47CiAJcGNoX3VkY19jbGVhcl9kbWEoZXAtPmRldiwgRE1BX0RJUl9SWCk7CisJcGNoX3VkY19lcF9zZXRfZGRwdHIoZXAsIDApOwogCWlmICgocmVxLT50ZF9kYXRhX2xhc3QtPnN0YXR1cyAmIFBDSF9VRENfUlhUWF9TVFMpICE9CiAJICAgIFBDSF9VRENfUlRTX1NVQ0MpIHsKIAkJZGV2X2VycigmZGV2LT5wZGV2LT5kZXYsICJJbnZhbGlkIFJYVFggc3RhdHVzICgweCUwOHgpICIKQEAgLTE5NjMsNyArMTk2OCw3IEBACiAJdTMyCWVwc3RzOwogCXN0cnVjdCBwY2hfdWRjX2VwCSplcDsKIAotCWVwID0gJmRldi0+ZXBbMiplcF9udW1dOworCWVwID0gJmRldi0+ZXBbVURDX0VQSU5fSURYKGVwX251bSldOwogCWVwc3RzID0gZXAtPmVwc3RzOwogCWVwLT5lcHN0cyA9IDA7CiAKQEAgLTIwMDgsNyArMjAxMyw3IEBACiAJc3RydWN0IHBjaF91ZGNfZXAJCSplcDsKIAlzdHJ1Y3QgcGNoX3VkY19yZXF1ZXN0CQkqcmVxID0gTlVMTDsKIAotCWVwID0gJmRldi0+ZXBbMiplcF9udW0gKyAxXTsKKwllcCA9ICZkZXYtPmVwW1VEQ19FUE9VVF9JRFgoZXBfbnVtKV07CiAJZXBzdHMgPSBlcC0+ZXBzdHM7CiAJZXAtPmVwc3RzID0gMDsKIApAQCAtMjAyNSwxMCArMjAzMCwxMSBAQAogCX0KIAlpZiAoZXBzdHMgJiBVRENfRVBTVFNfSEUpCiAJCXJldHVybjsKLQlpZiAoZXBzdHMgJiBVRENfRVBTVFNfUlNTKQorCWlmIChlcHN0cyAmIFVEQ19FUFNUU19SU1MpIHsKIAkJcGNoX3VkY19lcF9zZXRfc3RhbGwoZXApOwogCQlwY2hfdWRjX2VuYWJsZV9lcF9pbnRlcnJ1cHRzKGVwLT5kZXYsCiAJCQkJCSAgICAgUENIX1VEQ19FUElOVChlcC0+aW4sIGVwLT5udW0pKTsKKwl9CiAJaWYgKGVwc3RzICYgVURDX0VQU1RTX1JDUykgewogCQlpZiAoIWRldi0+cHJvdF9zdGFsbCkgewogCQkJcGNoX3VkY19lcF9jbGVhcl9zdGFsbChlcCk7CkBAIC0yMDYwLDggKzIwNjYsMTAgQEAKIHsKIAl1MzIJZXBzdHM7CiAJc3RydWN0IHBjaF91ZGNfZXAJKmVwOworCXN0cnVjdCBwY2hfdWRjX2VwCSplcF9vdXQ7CiAKIAllcCA9ICZkZXYtPmVwW1VEQ19FUDBJTl9JRFhdOworCWVwX291dCA9ICZkZXYtPmVwW1VEQ19FUDBPVVRfSURYXTsKIAllcHN0cyA9IGVwLT5lcHN0czsKIAllcC0+ZXBzdHMgPSAwOwogCkBAIC0yMDczLDggKzIwODEsMTYgQEAKIAkJcmV0dXJuOwogCWlmIChlcHN0cyAmIFVEQ19FUFNUU19IRSkKIAkJcmV0dXJuOwotCWlmICgoZXBzdHMgJiBVRENfRVBTVFNfVERDKSAmJiAoIWRldi0+c3RhbGwpKQorCWlmICgoZXBzdHMgJiBVRENfRVBTVFNfVERDKSAmJiAoIWRldi0+c3RhbGwpKSB7CiAJCXBjaF91ZGNfY29tcGxldGVfdHJhbnNmZXIoZXApOworCQlwY2hfdWRjX2NsZWFyX2RtYShkZXYsIERNQV9ESVJfUlgpOworCQllcF9vdXQtPnRkX2RhdGEtPnN0YXR1cyA9IChlcF9vdXQtPnRkX2RhdGEtPnN0YXR1cyAmCisJCQkJCX5QQ0hfVURDX0JVRkZfU1RTKSB8CisJCQkJCVBDSF9VRENfQlNfSFNUX1JEWTsKKwkJcGNoX3VkY19lcF9jbGVhcl9uYWsoZXBfb3V0KTsKKwkJcGNoX3VkY19zZXRfZG1hKGRldiwgRE1BX0RJUl9SWCk7CisJCXBjaF91ZGNfZXBfc2V0X3JyZHkoZXBfb3V0KTsKKwl9CiAJLyogT24gSU4gaW50ZXJydXB0LCBwcm92aWRlIGRhdGEgaWYgd2UgaGF2ZSBhbnkgKi8KIAlpZiAoKGVwc3RzICYgVURDX0VQU1RTX0lOKSAmJiAhKGVwc3RzICYgVURDX0VQU1RTX1REQykgJiYKIAkgICAgICEoZXBzdHMgJiBVRENfRVBTVFNfVFhFTVBUWSkpCkBAIC0yMTAyLDExICsyMTE4LDkgQEAKIAkJZGV2LT5zdGFsbCA9IDA7CiAJCWRldi0+ZXBbVURDX0VQMElOX0lEWF0uaGFsdGVkID0gMDsKIAkJZGV2LT5lcFtVRENfRVAwT1VUX0lEWF0uaGFsdGVkID0gMDsKLQkJLyogSW4gZGF0YSBub3QgcmVhZHkgKi8KLQkJcGNoX3VkY19lcF9zZXRfbmFrKCYoZGV2LT5lcFtVRENfRVAwSU5fSURYXSkpOwogCQlkZXYtPnNldHVwX2RhdGEgPSBlcC0+dGRfc3RwLT5yZXF1ZXN0OwogCQlwY2hfdWRjX2luaXRfc2V0dXBfYnVmZihlcC0+dGRfc3RwKTsKLQkJcGNoX3VkY19jbGVhcl9kbWEoZGV2LCBETUFfRElSX1RYKTsKKwkJcGNoX3VkY19jbGVhcl9kbWEoZGV2LCBETUFfRElSX1JYKTsKIAkJcGNoX3VkY19lcF9maWZvX2ZsdXNoKCYoZGV2LT5lcFtVRENfRVAwSU5fSURYXSksCiAJCQkJICAgICAgZGV2LT5lcFtVRENfRVAwSU5fSURYXS5pbik7CiAJCWlmICgoZGV2LT5zZXR1cF9kYXRhLmJSZXF1ZXN0VHlwZSAmIFVTQl9ESVJfSU4pKQpAQCAtMjEyMiwxNCArMjEzNiwyMyBAQAogCQlzZXR1cF9zdXBwb3J0ZWQgPSBkZXYtPmRyaXZlci0+c2V0dXAoJmRldi0+Z2FkZ2V0LAogCQkJCQkJICAgICAmZGV2LT5zZXR1cF9kYXRhKTsKIAkJc3Bpbl9sb2NrKCZkZXYtPmxvY2spOworCisJCWlmIChkZXYtPnNldHVwX2RhdGEuYlJlcXVlc3RUeXBlICYgVVNCX0RJUl9JTikgeworCQkJZXAtPnRkX2RhdGEtPnN0YXR1cyA9IChlcC0+dGRfZGF0YS0+c3RhdHVzICYKKwkJCQkJCX5QQ0hfVURDX0JVRkZfU1RTKSB8CisJCQkJCQlQQ0hfVURDX0JTX0hTVF9SRFk7CisJCQlwY2hfdWRjX2VwX3NldF9kZHB0cihlcCwgZXAtPnRkX2RhdGFfcGh5cyk7CisJCX0KIAkJLyogZXAwIGluIHJldHVybnMgZGF0YSBvbiBJTiBwaGFzZSAqLwogCQlpZiAoc2V0dXBfc3VwcG9ydGVkID49IDAgJiYgc2V0dXBfc3VwcG9ydGVkIDwKIAkJCQkJICAgIFVEQ19FUDBJTl9NQVhfUEtUX1NJWkUpIHsKIAkJCXBjaF91ZGNfZXBfY2xlYXJfbmFrKCYoZGV2LT5lcFtVRENfRVAwSU5fSURYXSkpOwogCQkJLyogR2FkZ2V0IHdvdWxkIGhhdmUgcXVldWVkIGEgcmVxdWVzdCB3aGVuCiAJCQkgKiB3ZSBjYWxsZWQgdGhlIHNldHVwICovCi0JCQlwY2hfdWRjX3NldF9kbWEoZGV2LCBETUFfRElSX1JYKTsKLQkJCXBjaF91ZGNfZXBfY2xlYXJfbmFrKGVwKTsKKwkJCWlmICghKGRldi0+c2V0dXBfZGF0YS5iUmVxdWVzdFR5cGUgJiBVU0JfRElSX0lOKSkgeworCQkJCXBjaF91ZGNfc2V0X2RtYShkZXYsIERNQV9ESVJfUlgpOworCQkJCXBjaF91ZGNfZXBfY2xlYXJfbmFrKGVwKTsKKwkJCX0KIAkJfSBlbHNlIGlmIChzZXR1cF9zdXBwb3J0ZWQgPCAwKSB7CiAJCQkvKiBpZiB1bnN1cHBvcnRlZCByZXF1ZXN0LCB0aGVuIHN0YWxsICovCiAJCQlwY2hfdWRjX2VwX3NldF9zdGFsbCgmKGRldi0+ZXBbVURDX0VQMElOX0lEWF0pKTsKQEAgLTIxNDIsMjIgKzIxNjUsMTMgQEAKIAkJfQogCX0gZWxzZSBpZiAoKCgoc3RhdCAmIFVEQ19FUFNUU19PVVRfTUFTSykgPj4gVURDX0VQU1RTX09VVF9TSElGVCkgPT0KIAkJICAgICBVRENfRVBTVFNfT1VUX0RBVEEpICYmICFkZXYtPnN0YWxsKSB7Ci0JCWlmIChsaXN0X2VtcHR5KCZlcC0+cXVldWUpKSB7Ci0JCQlkZXZfZXJyKCZkZXYtPnBkZXYtPmRldiwgIiVzOiBObyByZXF1ZXN0XG4iLCBfX2Z1bmNfXyk7Ci0JCQllcC0+dGRfZGF0YS0+c3RhdHVzID0gKGVwLT50ZF9kYXRhLT5zdGF0dXMgJgotCQkJCQkgICAgICAgflBDSF9VRENfQlVGRl9TVFMpIHwKLQkJCQkJICAgICAgIFBDSF9VRENfQlNfSFNUX1JEWTsKLQkJCXBjaF91ZGNfc2V0X2RtYShkZXYsIERNQV9ESVJfUlgpOwotCQl9IGVsc2UgewotCQkJLyogY29udHJvbCB3cml0ZSAqLwotCQkJLyogbmV4dCBmdW5jdGlvbiB3aWxsIHBpY2t1byBhbiBjbGVhciB0aGUgc3RhdHVzICovCisJCXBjaF91ZGNfY2xlYXJfZG1hKGRldiwgRE1BX0RJUl9SWCk7CisJCXBjaF91ZGNfZXBfc2V0X2RkcHRyKGVwLCAwKTsKKwkJaWYgKCFsaXN0X2VtcHR5KCZlcC0+cXVldWUpKSB7CiAJCQllcC0+ZXBzdHMgPSBzdGF0OwotCi0JCQlwY2hfdWRjX3N2Y19kYXRhX291dChkZXYsIDApOwotCQkJLyogcmUtcHJvZ3JhbSBkZXNjLiBwb2ludGVyIGZvciBwb3NzaWJsZSBaTFBzICovCi0JCQlwY2hfdWRjX2VwX3NldF9kZHB0cihlcCwgZXAtPnRkX2RhdGFfcGh5cyk7Ci0JCQlwY2hfdWRjX3NldF9kbWEoZGV2LCBETUFfRElSX1JYKTsKKwkJCXBjaF91ZGNfc3ZjX2RhdGFfb3V0KGRldiwgUENIX1VEQ19FUDApOwogCQl9CisJCXBjaF91ZGNfc2V0X2RtYShkZXYsIERNQV9ESVJfUlgpOwogCX0KIAlwY2hfdWRjX2VwX3NldF9ycmR5KGVwKTsKIH0KQEAgLTIxNzQsNyArMjE4OCw3IEBACiAJc3RydWN0IHBjaF91ZGNfZXAJKmVwOwogCXN0cnVjdCBwY2hfdWRjX3JlcXVlc3QgKnJlcTsKIAotCWVwID0gJmRldi0+ZXBbMiplcF9udW1dOworCWVwID0gJmRldi0+ZXBbVURDX0VQSU5fSURYKGVwX251bSldOwogCWlmICghbGlzdF9lbXB0eSgmZXAtPnF1ZXVlKSkgewogCQlyZXEgPSBsaXN0X2VudHJ5KGVwLT5xdWV1ZS5uZXh0LCBzdHJ1Y3QgcGNoX3VkY19yZXF1ZXN0LCBxdWV1ZSk7CiAJCXBjaF91ZGNfZW5hYmxlX2VwX2ludGVycnVwdHMoZXAtPmRldiwKQEAgLTIxOTYsMTMgKzIyMTAsMTMgQEAKIAlmb3IgKGkgPSAwOyBpIDwgUENIX1VEQ19VU0VEX0VQX05VTTsgaSsrKSB7CiAJCS8qIElOICovCiAJCWlmIChlcF9pbnRyICYgKDB4MSA8PCBpKSkgewotCQkJZXAgPSAmZGV2LT5lcFsyKmldOworCQkJZXAgPSAmZGV2LT5lcFtVRENfRVBJTl9JRFgoaSldOwogCQkJZXAtPmVwc3RzID0gcGNoX3VkY19yZWFkX2VwX3N0YXR1cyhlcCk7CiAJCQlwY2hfdWRjX2NsZWFyX2VwX3N0YXR1cyhlcCwgZXAtPmVwc3RzKTsKIAkJfQogCQkvKiBPVVQgKi8KIAkJaWYgKGVwX2ludHIgJiAoMHgxMDAwMCA8PCBpKSkgewotCQkJZXAgPSAmZGV2LT5lcFsyKmkrMV07CisJCQllcCA9ICZkZXYtPmVwW1VEQ19FUE9VVF9JRFgoaSldOwogCQkJZXAtPmVwc3RzID0gcGNoX3VkY19yZWFkX2VwX3N0YXR1cyhlcCk7CiAJCQlwY2hfdWRjX2NsZWFyX2VwX3N0YXR1cyhlcCwgZXAtPmVwc3RzKTsKIAkJfQpAQCAtMjU2Myw5ICsyNTc3LDYgQEAKIAlkZXYtPmVwW1VEQ19FUDBJTl9JRFhdLmVwLm1heHBhY2tldCA9IFVEQ19FUDBJTl9NQVhfUEtUX1NJWkU7CiAJZGV2LT5lcFtVRENfRVAwT1VUX0lEWF0uZXAubWF4cGFja2V0ID0gVURDX0VQME9VVF9NQVhfUEtUX1NJWkU7CiAKLQlkZXYtPmRtYV9hZGRyID0gcGNpX21hcF9zaW5nbGUoZGV2LT5wZGV2LCBkZXYtPmVwMG91dF9idWYsIDI1NiwKLQkJCQkgIFBDSV9ETUFfRlJPTURFVklDRSk7Ci0KIAkvKiByZW1vdmUgZXAwIGluIGFuZCBvdXQgZnJvbSB0aGUgbGlzdC4gIFRoZXkgaGF2ZSBvd24gcG9pbnRlciAqLwogCWxpc3RfZGVsX2luaXQoJmRldi0+ZXBbVURDX0VQMElOX0lEWF0uZXAuZXBfbGlzdCk7CiAJbGlzdF9kZWxfaW5pdCgmZGV2LT5lcFtVRENfRVAwT1VUX0lEWF0uZXAuZXBfbGlzdCk7CkBAIC0yNjM3LDYgKzI2NDgsMTMgQEAKIAlkZXYtPmVwW1VEQ19FUDBJTl9JRFhdLnRkX3N0cF9waHlzID0gMDsKIAlkZXYtPmVwW1VEQ19FUDBJTl9JRFhdLnRkX2RhdGEgPSBOVUxMOwogCWRldi0+ZXBbVURDX0VQMElOX0lEWF0udGRfZGF0YV9waHlzID0gMDsKKworCWRldi0+ZXAwb3V0X2J1ZiA9IGt6YWxsb2MoVURDX0VQME9VVF9CVUZGX1NJWkUgKiA0LCBHRlBfS0VSTkVMKTsKKwlpZiAoIWRldi0+ZXAwb3V0X2J1ZikKKwkJcmV0dXJuIC1FTk9NRU07CisJZGV2LT5kbWFfYWRkciA9IGRtYV9tYXBfc2luZ2xlKCZkZXYtPnBkZXYtPmRldiwgZGV2LT5lcDBvdXRfYnVmLAorCQkJCSAgICAgICBVRENfRVAwT1VUX0JVRkZfU0laRSAqIDQsCisJCQkJICAgICAgIERNQV9GUk9NX0RFVklDRSk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTI3MDAsNyArMjcxOCw4IEBACiAKIAlwY2hfdWRjX2Rpc2FibGVfaW50ZXJydXB0cyhkZXYsIFVEQ19ERVZJTlRfTVNLKTsKIAotCS8qIEFzc3VlcyB0aGF0IHRoZXJlIGFyZSBubyBwZW5kaW5nIHJlcXVldHMgd2l0aCB0aGlzIGRyaXZlciAqLworCS8qIEFzc3VyZXMgdGhhdCB0aGVyZSBhcmUgbm8gcGVuZGluZyByZXF1ZXN0cyB3aXRoIHRoaXMgZHJpdmVyICovCisJZHJpdmVyLT5kaXNjb25uZWN0KCZkZXYtPmdhZGdldCk7CiAJZHJpdmVyLT51bmJpbmQoJmRldi0+Z2FkZ2V0KTsKIAlkZXYtPmdhZGdldC5kZXYuZHJpdmVyID0gTlVMTDsKIAlkZXYtPmRyaXZlciA9IE5VTEw7CkBAIC0yNzUwLDYgKzI3NjksMTEgQEAKIAkJcGNpX3Bvb2xfZGVzdHJveShkZXYtPnN0cF9yZXF1ZXN0cyk7CiAJfQogCisJaWYgKGRldi0+ZG1hX2FkZHIpCisJCWRtYV91bm1hcF9zaW5nbGUoJmRldi0+cGRldi0+ZGV2LCBkZXYtPmRtYV9hZGRyLAorCQkJCSBVRENfRVAwT1VUX0JVRkZfU0laRSAqIDQsIERNQV9GUk9NX0RFVklDRSk7CisJa2ZyZWUoZGV2LT5lcDBvdXRfYnVmKTsKKwogCXBjaF91ZGNfZXhpdChkZXYpOwogCiAJaWYgKGRldi0+aXJxX3JlZ2lzdGVyZWQpCkBAIC0yNzkyLDExICsyODE2LDcgQEAKIAlpbnQgcmV0OwogCiAJcGNpX3NldF9wb3dlcl9zdGF0ZShwZGV2LCBQQ0lfRDApOwotCXJldCA9IHBjaV9yZXN0b3JlX3N0YXRlKHBkZXYpOwotCWlmIChyZXQpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAiJXM6IHBjaV9yZXN0b3JlX3N0YXRlIGZhaWxlZFxuIiwgX19mdW5jX18pOwotCQlyZXR1cm4gcmV0OwotCX0KKwlwY2lfcmVzdG9yZV9zdGF0ZShwZGV2KTsKIAlyZXQgPSBwY2lfZW5hYmxlX2RldmljZShwZGV2KTsKIAlpZiAocmV0KSB7CiAJCWRldl9lcnIoJnBkZXYtPmRldiwgIiVzOiBwY2lfZW5hYmxlX2RldmljZSBmYWlsZWRcbiIsIF9fZnVuY19fKTsKQEAgLTI5MTQsNiArMjkzNCwxMSBAQAogCQkuY2xhc3MgPSAoUENJX0NMQVNTX1NFUklBTF9VU0IgPDwgOCkgfCAweGZlLAogCQkuY2xhc3NfbWFzayA9IDB4ZmZmZmZmZmYsCiAJfSwKKwl7CisJCVBDSV9ERVZJQ0UoUENJX1ZFTkRPUl9JRF9ST0hNLCBQQ0lfREVWSUNFX0lEX01MNzIxM19JT0hfVURDKSwKKwkJLmNsYXNzID0gKFBDSV9DTEFTU19TRVJJQUxfVVNCIDw8IDgpIHwgMHhmZSwKKwkJLmNsYXNzX21hc2sgPSAweGZmZmZmZmZmLAorCX0sCiAJeyAwIH0sCiB9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9nYWRnZXQvcHJpbnRlci5jIGIvZHJpdmVycy91c2IvZ2FkZ2V0L3ByaW50ZXIuYwppbmRleCAyZmM4NjM2Li4xMmZmNmNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvcHJpbnRlci5jCisrKyBiL2RyaXZlcnMvdXNiL2dhZGdldC9wcmludGVyLmMKQEAgLTEzMSwzMSArMTMxLDMxIEBACiAgKiBwYXJhbWV0ZXJzIGFyZSBpbiBVVEYtOCAoc3VwZXJzZXQgb2YgQVNDSUkncyA3IGJpdCBjaGFyYWN0ZXJzKS4KICAqLwogCi1zdGF0aWMgdXNob3J0IF9faW5pdGRhdGEgaWRWZW5kb3I7CitzdGF0aWMgdXNob3J0IGlkVmVuZG9yOwogbW9kdWxlX3BhcmFtKGlkVmVuZG9yLCB1c2hvcnQsIFNfSVJVR08pOwogTU9EVUxFX1BBUk1fREVTQyhpZFZlbmRvciwgIlVTQiBWZW5kb3IgSUQiKTsKIAotc3RhdGljIHVzaG9ydCBfX2luaXRkYXRhIGlkUHJvZHVjdDsKK3N0YXRpYyB1c2hvcnQgaWRQcm9kdWN0OwogbW9kdWxlX3BhcmFtKGlkUHJvZHVjdCwgdXNob3J0LCBTX0lSVUdPKTsKIE1PRFVMRV9QQVJNX0RFU0MoaWRQcm9kdWN0LCAiVVNCIFByb2R1Y3QgSUQiKTsKIAotc3RhdGljIHVzaG9ydCBfX2luaXRkYXRhIGJjZERldmljZTsKK3N0YXRpYyB1c2hvcnQgYmNkRGV2aWNlOwogbW9kdWxlX3BhcmFtKGJjZERldmljZSwgdXNob3J0LCBTX0lSVUdPKTsKIE1PRFVMRV9QQVJNX0RFU0MoYmNkRGV2aWNlLCAiVVNCIERldmljZSB2ZXJzaW9uIChCQ0QpIik7CiAKLXN0YXRpYyBjaGFyICpfX2luaXRkYXRhIGlNYW51ZmFjdHVyZXI7CitzdGF0aWMgY2hhciAqaU1hbnVmYWN0dXJlcjsKIG1vZHVsZV9wYXJhbShpTWFudWZhY3R1cmVyLCBjaGFycCwgU19JUlVHTyk7CiBNT0RVTEVfUEFSTV9ERVNDKGlNYW51ZmFjdHVyZXIsICJVU0IgTWFudWZhY3R1cmVyIHN0cmluZyIpOwogCi1zdGF0aWMgY2hhciAqX19pbml0ZGF0YSBpUHJvZHVjdDsKK3N0YXRpYyBjaGFyICppUHJvZHVjdDsKIG1vZHVsZV9wYXJhbShpUHJvZHVjdCwgY2hhcnAsIFNfSVJVR08pOwogTU9EVUxFX1BBUk1fREVTQyhpUHJvZHVjdCwgIlVTQiBQcm9kdWN0IHN0cmluZyIpOwogCi1zdGF0aWMgY2hhciAqX19pbml0ZGF0YSBpU2VyaWFsTnVtOworc3RhdGljIGNoYXIgKmlTZXJpYWxOdW07CiBtb2R1bGVfcGFyYW0oaVNlcmlhbE51bSwgY2hhcnAsIFNfSVJVR08pOwogTU9EVUxFX1BBUk1fREVTQyhpU2VyaWFsTnVtLCAiMSIpOwogCi1zdGF0aWMgY2hhciAqX19pbml0ZGF0YSBpUE5Qc3RyaW5nOworc3RhdGljIGNoYXIgKmlQTlBzdHJpbmc7CiBtb2R1bGVfcGFyYW0oaVBOUHN0cmluZywgY2hhcnAsIFNfSVJVR08pOwogTU9EVUxFX1BBUk1fREVTQyhpUE5Qc3RyaW5nLCAiTUZHOmxpbnV4O01ETDpnX3ByaW50ZXI7Q0xTOlBSSU5URVI7U046MTsiKTsKIApAQCAtMTU5NiwxMyArMTU5NiwxMiBAQAogCWludCBzdGF0dXM7CiAKIAltdXRleF9sb2NrKCZ1c2JfcHJpbnRlcl9nYWRnZXQubG9ja19wcmludGVyX2lvKTsKLQljbGFzc19kZXN0cm95KHVzYl9nYWRnZXRfY2xhc3MpOwotCXVucmVnaXN0ZXJfY2hyZGV2X3JlZ2lvbihnX3ByaW50ZXJfZGV2bm8sIDIpOwotCiAJc3RhdHVzID0gdXNiX2dhZGdldF91bnJlZ2lzdGVyX2RyaXZlcigmcHJpbnRlcl9kcml2ZXIpOwogCWlmIChzdGF0dXMpCiAJCUVSUk9SKGRldiwgInVzYl9nYWRnZXRfdW5yZWdpc3Rlcl9kcml2ZXIgJXhcbiIsIHN0YXR1cyk7CiAKKwl1bnJlZ2lzdGVyX2NocmRldl9yZWdpb24oZ19wcmludGVyX2Rldm5vLCAyKTsKKwljbGFzc19kZXN0cm95KHVzYl9nYWRnZXRfY2xhc3MpOwogCW11dGV4X3VubG9jaygmdXNiX3ByaW50ZXJfZ2FkZ2V0LmxvY2tfcHJpbnRlcl9pbyk7CiB9CiBtb2R1bGVfZXhpdChjbGVhbnVwKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2dhZGdldC9yOGE2NjU5Ny11ZGMuYyBiL2RyaXZlcnMvdXNiL2dhZGdldC9yOGE2NjU5Ny11ZGMuYwppbmRleCAyMGQ0M2RhLi4wMTUxMTg1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvcjhhNjY1OTctdWRjLmMKKysrIGIvZHJpdmVycy91c2IvZ2FkZ2V0L3I4YTY2NTk3LXVkYy5jCkBAIC0yNTgsNyArMjU4LDcgQEAKIAkJYnJlYWs7CiAJY2FzZSBSOEE2NjU5N19CVUxLOgogCQkvKiBpc29jaHJvbm91cyBwaXBlcyBtYXkgYmUgdXNlZCBhcyBidWxrIHBpcGVzICovCi0JCWlmIChpbmZvLT5waXBlID4gUjhBNjY1OTdfQkFTRV9QSVBFTlVNX0JVTEspCisJCWlmIChpbmZvLT5waXBlID49IFI4QTY2NTk3X0JBU0VfUElQRU5VTV9CVUxLKQogCQkJYnVmbnVtID0gaW5mby0+cGlwZSAtIFI4QTY2NTk3X0JBU0VfUElQRU5VTV9CVUxLOwogCQllbHNlCiAJCQlidWZudW0gPSBpbmZvLT5waXBlIC0gUjhBNjY1OTdfQkFTRV9QSVBFTlVNX0lTT0M7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L0tjb25maWcgYi9kcml2ZXJzL3VzYi9ob3N0L0tjb25maWcKaW5kZXggMjQwNDZjMC4uMGU2YWZhMiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvaG9zdC9LY29uZmlnCisrKyBiL2RyaXZlcnMvdXNiL2hvc3QvS2NvbmZpZwpAQCAtMTUxLDYgKzE1MSw4IEBACiAJICBRdWFsY29tbSBjaGlwc2V0cy4gUm9vdCBIdWIgaGFzIGluYnVpbHQgVFQuCiAJICBUaGlzIGRyaXZlciBkZXBlbmRzIG9uIE9URyBkcml2ZXIgZm9yIFBIWSBpbml0aWFsaXphdGlvbiwKIAkgIGNsb2NrIG1hbmFnZW1lbnQsIHBvd2VyaW5nIHVwIFZCVVMsIGFuZCBwb3dlciBtYW5hZ2VtZW50LgorCSAgVGhpcyBkcml2ZXIgaXMgbm90IHN1cHBvcnRlZCBvbiBib2FyZHMgbGlrZSB0cm91dCB3aGljaAorCSAgaGFzIGFuIGV4dGVybmFsIFBIWS4KIAogY29uZmlnIFVTQl9FSENJX0hDRF9QUENfT0YKIAlib29sICJFSENJIHN1cHBvcnQgZm9yIFBQQyBVU0IgY29udHJvbGxlciBvbiBPRiBwbGF0Zm9ybSBidXMiCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L2VoY2ktYXUxeHh4LmMgYi9kcml2ZXJzL3VzYi9ob3N0L2VoY2ktYXUxeHh4LmMKaW5kZXggMmJhZjhhOC4uYTg2OWUzYyAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvaG9zdC9laGNpLWF1MXh4eC5jCisrKyBiL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS1hdTF4eHguYwpAQCAtMjI3LDggKzIyNyw4IEBACiAJICogbWFyayBIVyB1bmFjY2Vzc2libGUuICBUaGUgUE0gYW5kIFVTQiBjb3JlcyBtYWtlIHN1cmUgdGhhdAogCSAqIHRoZSByb290IGh1YiBpcyBlaXRoZXIgc3VzcGVuZGVkIG9yIHN0b3BwZWQuCiAJICovCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmVoY2ktPmxvY2ssIGZsYWdzKTsKIAllaGNpX3ByZXBhcmVfcG9ydHNfZm9yX2NvbnRyb2xsZXJfc3VzcGVuZChlaGNpLCBkZXZpY2VfbWF5X3dha2V1cChkZXYpKTsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZWhjaS0+bG9jaywgZmxhZ3MpOwogCWVoY2lfd3JpdGVsKGVoY2ksIDAsICZlaGNpLT5yZWdzLT5pbnRyX2VuYWJsZSk7CiAJKHZvaWQpZWhjaV9yZWFkbChlaGNpLCAmZWhjaS0+cmVncy0+aW50cl9lbmFibGUpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L2VoY2ktZnNsLmMgYi9kcml2ZXJzL3VzYi9ob3N0L2VoY2ktZnNsLmMKaW5kZXggODZlNDI4OS4uNWM3NjFkZiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvaG9zdC9laGNpLWZzbC5jCisrKyBiL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS1mc2wuYwpAQCAtNTIsNyArNTIsNiBAQAogCXN0cnVjdCByZXNvdXJjZSAqcmVzOwogCWludCBpcnE7CiAJaW50IHJldHZhbDsKLQl1bnNpZ25lZCBpbnQgdGVtcDsKIAogCXByX2RlYnVnKCJpbml0aWFsaXppbmcgRlNMLVNPQyBVU0IgQ29udHJvbGxlclxuIik7CiAKQEAgLTEyNiwxOCArMTI1LDYgQEAKIAkJZ290byBlcnIzOwogCX0KIAotCS8qCi0JICogQ2hlY2sgaWYgaXQgaXMgTVBDNTEyMSBTb0MsIG90aGVyd2lzZSBzZXQgcGRhdGEtPmhhdmVfc3lzaWZfcmVncwotCSAqIGZsYWcgZm9yIDgzeHggb3IgODUzNiBzeXN0ZW0gaW50ZXJmYWNlIHJlZ2lzdGVycy4KLQkgKi8KLQlpZiAocGRhdGEtPmJpZ19lbmRpYW5fbW1pbykKLQkJdGVtcCA9IGluX2JlMzIoaGNkLT5yZWdzICsgRlNMX1NPQ19VU0JfSUQpOwotCWVsc2UKLQkJdGVtcCA9IGluX2xlMzIoaGNkLT5yZWdzICsgRlNMX1NPQ19VU0JfSUQpOwotCi0JaWYgKCh0ZW1wICYgSURfTVNLKSAhPSAofigodGVtcCAmIE5JRF9NU0spID4+IDgpICYgSURfTVNLKSkKLQkJcGRhdGEtPmhhdmVfc3lzaWZfcmVncyA9IDE7Ci0KIAkvKiBFbmFibGUgVVNCIGNvbnRyb2xsZXIsIDgzeHggb3IgODUzNiAqLwogCWlmIChwZGF0YS0+aGF2ZV9zeXNpZl9yZWdzKQogCQlzZXRiaXRzMzIoaGNkLT5yZWdzICsgRlNMX1NPQ19VU0JfQ1RSTCwgMHg0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS1mc2wuaCBiL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS1mc2wuaAppbmRleCAyYzgzNTM3Li4zZmFiZWQzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9ob3N0L2VoY2ktZnNsLmgKKysrIGIvZHJpdmVycy91c2IvaG9zdC9laGNpLWZzbC5oCkBAIC0xOSw5ICsxOSw2IEBACiAjZGVmaW5lIF9FSENJX0ZTTF9ICiAKIC8qIG9mZnNldHMgZm9yIHRoZSBub24tZWhjaSByZWdpc3RlcnMgaW4gdGhlIEZTTCBTT0MgVVNCIGNvbnRyb2xsZXIgKi8KLSNkZWZpbmUgRlNMX1NPQ19VU0JfSUQJCTB4MAotI2RlZmluZSBJRF9NU0sJCQkweDNmCi0jZGVmaW5lIE5JRF9NU0sJCQkweDNmMDAKICNkZWZpbmUgRlNMX1NPQ19VU0JfVUxQSVZQCTB4MTcwCiAjZGVmaW5lIEZTTF9TT0NfVVNCX1BPUlRTQzEJMHgxODQKICNkZWZpbmUgUE9SVF9QVFNfTVNLCQkoMzw8MzApCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L2VoY2ktaGNkLmMgYi9kcml2ZXJzL3VzYi9ob3N0L2VoY2ktaGNkLmMKaW5kZXggNmZlZTNjZC4uNzRkY2Y0OSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvaG9zdC9laGNpLWhjZC5jCisrKyBiL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS1oY2QuYwpAQCAtNTcyLDYgKzU3Miw4IEBACiAJZWhjaS0+aWFhX3dhdGNoZG9nLmZ1bmN0aW9uID0gZWhjaV9pYWFfd2F0Y2hkb2c7CiAJZWhjaS0+aWFhX3dhdGNoZG9nLmRhdGEgPSAodW5zaWduZWQgbG9uZykgZWhjaTsKIAorCWhjY19wYXJhbXMgPSBlaGNpX3JlYWRsKGVoY2ksICZlaGNpLT5jYXBzLT5oY2NfcGFyYW1zKTsKKwogCS8qCiAJICogaHcgZGVmYXVsdDogMUsgcGVyaW9kaWMgbGlzdCBoZWFkcywgb25lIHBlciBmcmFtZS4KIAkgKiBwZXJpb2RpY19zaXplIGNhbiBzaHJpbmsgYnkgVVNCQ01EIHVwZGF0ZSBpZiBoY2NfcGFyYW1zIGFsbG93cy4KQEAgLTU3OSwxMSArNTgxLDIwIEBACiAJZWhjaS0+cGVyaW9kaWNfc2l6ZSA9IERFRkFVTFRfSV9URFBTOwogCUlOSVRfTElTVF9IRUFEKCZlaGNpLT5jYWNoZWRfaXRkX2xpc3QpOwogCUlOSVRfTElTVF9IRUFEKCZlaGNpLT5jYWNoZWRfc2l0ZF9saXN0KTsKKworCWlmIChIQ0NfUEdNX0ZSQU1FTElTVExFTihoY2NfcGFyYW1zKSkgeworCQkvKiBwZXJpb2RpYyBzY2hlZHVsZSBzaXplIGNhbiBiZSBzbWFsbGVyIHRoYW4gZGVmYXVsdCAqLworCQlzd2l0Y2ggKEVIQ0lfVFVORV9GTFMpIHsKKwkJY2FzZSAwOiBlaGNpLT5wZXJpb2RpY19zaXplID0gMTAyNDsgYnJlYWs7CisJCWNhc2UgMTogZWhjaS0+cGVyaW9kaWNfc2l6ZSA9IDUxMjsgYnJlYWs7CisJCWNhc2UgMjogZWhjaS0+cGVyaW9kaWNfc2l6ZSA9IDI1NjsgYnJlYWs7CisJCWRlZmF1bHQ6CUJVRygpOworCQl9CisJfQogCWlmICgocmV0dmFsID0gZWhjaV9tZW1faW5pdChlaGNpLCBHRlBfS0VSTkVMKSkgPCAwKQogCQlyZXR1cm4gcmV0dmFsOwogCiAJLyogY29udHJvbGxlcnMgbWF5IGNhY2hlIHNvbWUgb2YgdGhlIHBlcmlvZGljIHNjaGVkdWxlIC4uLiAqLwotCWhjY19wYXJhbXMgPSBlaGNpX3JlYWRsKGVoY2ksICZlaGNpLT5jYXBzLT5oY2NfcGFyYW1zKTsKIAlpZiAoSENDX0lTT0NfQ0FDSEUoaGNjX3BhcmFtcykpCQkvLyBmdWxsIGZyYW1lIGNhY2hlCiAJCWVoY2ktPmlfdGhyZXNoID0gMiArIDg7CiAJZWxzZQkJCQkJLy8gTiBtaWNyb2ZyYW1lcyBjYWNoZWQKQEAgLTYzNywxMiArNjQ4LDYgQEAKIAkJLyogcGVyaW9kaWMgc2NoZWR1bGUgc2l6ZSBjYW4gYmUgc21hbGxlciB0aGFuIGRlZmF1bHQgKi8KIAkJdGVtcCAmPSB+KDMgPDwgMik7CiAJCXRlbXAgfD0gKEVIQ0lfVFVORV9GTFMgPDwgMik7Ci0JCXN3aXRjaCAoRUhDSV9UVU5FX0ZMUykgewotCQljYXNlIDA6IGVoY2ktPnBlcmlvZGljX3NpemUgPSAxMDI0OyBicmVhazsKLQkJY2FzZSAxOiBlaGNpLT5wZXJpb2RpY19zaXplID0gNTEyOyBicmVhazsKLQkJY2FzZSAyOiBlaGNpLT5wZXJpb2RpY19zaXplID0gMjU2OyBicmVhazsKLQkJZGVmYXVsdDoJQlVHKCk7Ci0JCX0KIAl9CiAJaWYgKEhDQ19MUE0oaGNjX3BhcmFtcykpIHsKIAkJLyogc3VwcG9ydCBsaW5rIHBvd2VyIG1hbmFnZW1lbnQgRUhDSSAxLjEgYWRkZW5kdW0gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS1odWIuYyBiL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS1odWIuYwppbmRleCA3OTZlYTBjLi44YTUxNWYwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9ob3N0L2VoY2ktaHViLmMKKysrIGIvZHJpdmVycy91c2IvaG9zdC9laGNpLWh1Yi5jCkBAIC0xMTEsNiArMTExLDcgQEAKIHsKIAlpbnQJCXBvcnQ7CiAJdTMyCQl0ZW1wOworCXVuc2lnbmVkIGxvbmcJZmxhZ3M7CiAKIAkvKiBJZiByZW1vdGUgd2FrZXVwIGlzIGVuYWJsZWQgZm9yIHRoZSByb290IGh1YiBidXQgZGlzYWJsZWQKIAkgKiBmb3IgdGhlIGNvbnRyb2xsZXIsIHdlIG11c3QgYWRqdXN0IGFsbCB0aGUgcG9ydCB3YWtldXAgZmxhZ3MKQEAgLTEyMCw2ICsxMjEsOCBAQAogCWlmICghZWhjaV90b19oY2QoZWhjaSktPnNlbGYucm9vdF9odWItPmRvX3JlbW90ZV93YWtldXAgfHwgZG9fd2FrZXVwKQogCQlyZXR1cm47CiAKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZWhjaS0+bG9jaywgZmxhZ3MpOworCiAJLyogY2xlYXIgcGh5IGxvdy1wb3dlciBtb2RlIGJlZm9yZSBjaGFuZ2luZyB3YWtldXAgZmxhZ3MgKi8KIAlpZiAoZWhjaS0+aGFzX2hvc3RwYykgewogCQlwb3J0ID0gSENTX05fUE9SVFMoZWhjaS0+aGNzX3BhcmFtcyk7CkBAIC0xMzEsNyArMTM0LDkgQEAKIAkJCXRlbXAgPSBlaGNpX3JlYWRsKGVoY2ksIGhvc3RwY19yZWcpOwogCQkJZWhjaV93cml0ZWwoZWhjaSwgdGVtcCAmIH5IT1NUUENfUEhDRCwgaG9zdHBjX3JlZyk7CiAJCX0KKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZWhjaS0+bG9jaywgZmxhZ3MpOwogCQltc2xlZXAoNSk7CisJCXNwaW5fbG9ja19pcnFzYXZlKCZlaGNpLT5sb2NrLCBmbGFncyk7CiAJfQogCiAJcG9ydCA9IEhDU19OX1BPUlRTKGVoY2ktPmhjc19wYXJhbXMpOwpAQCAtMTcwLDYgKzE3NSw4IEBACiAJLyogRG9lcyB0aGUgcm9vdCBodWIgaGF2ZSBhIHBvcnQgd2FrZXVwIHBlbmRpbmc/ICovCiAJaWYgKCFzdXNwZW5kaW5nICYmIChlaGNpX3JlYWRsKGVoY2ksICZlaGNpLT5yZWdzLT5zdGF0dXMpICYgU1RTX1BDRCkpCiAJCXVzYl9oY2RfcmVzdW1lX3Jvb3RfaHViKGVoY2lfdG9faGNkKGVoY2kpKTsKKworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmVoY2ktPmxvY2ssIGZsYWdzKTsKIH0KIAogc3RhdGljIGludCBlaGNpX2J1c19zdXNwZW5kIChzdHJ1Y3QgdXNiX2hjZCAqaGNkKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC9laGNpLW14Yy5jIGIvZHJpdmVycy91c2IvaG9zdC9laGNpLW14Yy5jCmluZGV4IGZhNTliMjYuLmM4ZTM2MGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS1teGMuYworKysgYi9kcml2ZXJzL3VzYi9ob3N0L2VoY2ktbXhjLmMKQEAgLTIxLDEwICsyMSwxMyBAQAogI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiAjaW5jbHVkZSA8bGludXgvdXNiL290Zy5oPgorI2luY2x1ZGUgPGxpbnV4L3VzYi91bHBpLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogCiAjaW5jbHVkZSA8bWFjaC9teGNfZWhjaS5oPgogCisjaW5jbHVkZSA8YXNtL21hY2gtdHlwZXMuaD4KKwogI2RlZmluZSBVTFBJX1ZJRVdQT1JUX09GRlNFVAkweDE3MAogCiBzdHJ1Y3QgZWhjaV9teGNfcHJpdiB7CkBAIC0xMTQsNiArMTE3LDcgQEAKIAlzdHJ1Y3QgdXNiX2hjZCAqaGNkOwogCXN0cnVjdCByZXNvdXJjZSAqcmVzOwogCWludCBpcnEsIHJldDsKKwl1bnNpZ25lZCBpbnQgZmxhZ3M7CiAJc3RydWN0IGVoY2lfbXhjX3ByaXYgKnByaXY7CiAJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKIAlzdHJ1Y3QgZWhjaV9oY2QgKmVoY2k7CkBAIC0xNzcsOCArMTgxLDggQEAKIAkJY2xrX2VuYWJsZShwcml2LT5haGJjbGspOwogCX0KIAotCS8qICJkciIgZGV2aWNlIGhhcyBpdHMgb3duIGNsb2NrICovCi0JaWYgKHBkZXYtPmlkID09IDApIHsKKwkvKiAiZHIiIGRldmljZSBoYXMgaXRzIG93biBjbG9jayBvbiBpLk1YNTEgKi8KKwlpZiAoY3B1X2lzX214NTEoKSAmJiAocGRldi0+aWQgPT0gMCkpIHsKIAkJcHJpdi0+cGh5MWNsayA9IGNsa19nZXQoZGV2LCAidXNiX3BoeTEiKTsKIAkJaWYgKElTX0VSUihwcml2LT5waHkxY2xrKSkgewogCQkJcmV0ID0gUFRSX0VSUihwcml2LT5waHkxY2xrKTsKQEAgLTI0MCw2ICsyNDQsMjMgQEAKIAlpZiAocmV0KQogCQlnb3RvIGVycl9hZGQ7CiAKKwlpZiAocGRhdGEtPm90ZykgeworCQkvKgorCQkgKiBlZmlrYW14IGFuZCBlZmlrYXNiIGhhdmUgc29tZSBoYXJkd2FyZSBidWcgd2hpY2ggaXMKKwkJICogcHJldmVudGluZyB1c2IgdG8gd29yayB1bmxlc3MgQ0hSR1ZCVVMgaXMgc2V0LgorCQkgKiBJdCdzIGluIHZpb2xhdGlvbiBvZiBVU0Igc3BlY3MKKwkJICovCisJCWlmIChtYWNoaW5lX2lzX214NTFfZWZpa2FteCgpIHx8IG1hY2hpbmVfaXNfbXg1MV9lZmlrYXNiKCkpIHsKKwkJCWZsYWdzID0gb3RnX2lvX3JlYWQocGRhdGEtPm90ZywgVUxQSV9PVEdfQ1RSTCk7CisJCQlmbGFncyB8PSBVTFBJX09UR19DVFJMX0NIUkdWQlVTOworCQkJcmV0ID0gb3RnX2lvX3dyaXRlKHBkYXRhLT5vdGcsIGZsYWdzLCBVTFBJX09UR19DVFJMKTsKKwkJCWlmIChyZXQpIHsKKwkJCQlkZXZfZXJyKGRldiwgInVuYWJsZSB0byBzZXQgQ0hSVkJVU1xuIik7CisJCQkJZ290byBlcnJfYWRkOworCQkJfQorCQl9CisJfQorCiAJcmV0dXJuIDA7CiAKIGVycl9hZGQ6CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L2VoY2ktb21hcC5jIGIvZHJpdmVycy91c2IvaG9zdC9laGNpLW9tYXAuYwppbmRleCA2ODBmMmVmLi5mNzg0Y2ViIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9ob3N0L2VoY2ktb21hcC5jCisrKyBiL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS1vbWFwLmMKQEAgLTc5Niw3ICs3OTYsNyBAQAogCWhjZCA9IHVzYl9jcmVhdGVfaGNkKCZlaGNpX29tYXBfaGNfZHJpdmVyLCAmcGRldi0+ZGV2LAogCQkJZGV2X25hbWUoJnBkZXYtPmRldikpOwogCWlmICghaGNkKSB7Ci0JCWRldl9kYmcoJnBkZXYtPmRldiwgImZhaWxlZCB0byBjcmVhdGUgaGNkIHdpdGggZXJyICVkXG4iLCByZXQpOworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gY3JlYXRlIGhjZCB3aXRoIGVyciAlZFxuIiwgcmV0KTsKIAkJcmV0ID0gLUVOT01FTTsKIAkJZ290byBlcnJfY3JlYXRlX2hjZDsKIAl9CkBAIC04NjQsNyArODY0LDcgQEAKIAogCXJldCA9IG9tYXBfc3RhcnRfZWhjKG9tYXAsIGhjZCk7CiAJaWYgKHJldCkgewotCQlkZXZfZGJnKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gc3RhcnQgZWhjaVxuIik7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgImZhaWxlZCB0byBzdGFydCBlaGNpIHdpdGggZXJyICVkXG4iLCByZXQpOwogCQlnb3RvIGVycl9zdGFydDsKIAl9CiAKQEAgLTg3OSw3ICs4NzksNyBAQAogCiAJcmV0ID0gdXNiX2FkZF9oY2QoaGNkLCBpcnEsIElSUUZfRElTQUJMRUQgfCBJUlFGX1NIQVJFRCk7CiAJaWYgKHJldCkgewotCQlkZXZfZGJnKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gYWRkIGhjZCB3aXRoIGVyciAlZFxuIiwgcmV0KTsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIGFkZCBoY2Qgd2l0aCBlcnIgJWRcbiIsIHJldCk7CiAJCWdvdG8gZXJyX2FkZF9oY2Q7CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L2VoY2ktcGNpLmMgYi9kcml2ZXJzL3VzYi9ob3N0L2VoY2ktcGNpLmMKaW5kZXggNzYxNzljMy4uMDdiYjk4MiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvaG9zdC9laGNpLXBjaS5jCisrKyBiL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS1wY2kuYwpAQCAtNDQsMjggKzQ0LDM1IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgZWhjaV9xdWlya19hbWRfU0I4MDAoc3RydWN0IGVoY2lfaGNkICplaGNpKQorc3RhdGljIGludCBlaGNpX3F1aXJrX2FtZF9odWRzb24oc3RydWN0IGVoY2lfaGNkICplaGNpKQogewogCXN0cnVjdCBwY2lfZGV2ICphbWRfc21idXNfZGV2OwogCXU4IHJldiA9IDA7CiAKIAlhbWRfc21idXNfZGV2ID0gcGNpX2dldF9kZXZpY2UoUENJX1ZFTkRPUl9JRF9BVEksIDB4NDM4NSwgTlVMTCk7Ci0JaWYgKCFhbWRfc21idXNfZGV2KQotCQlyZXR1cm4gMDsKLQotCXBjaV9yZWFkX2NvbmZpZ19ieXRlKGFtZF9zbWJ1c19kZXYsIFBDSV9SRVZJU0lPTl9JRCwgJnJldik7Ci0JaWYgKHJldiA8IDB4NDApIHsKLQkJcGNpX2Rldl9wdXQoYW1kX3NtYnVzX2Rldik7Ci0JCWFtZF9zbWJ1c19kZXYgPSBOVUxMOwotCQlyZXR1cm4gMDsKKwlpZiAoYW1kX3NtYnVzX2RldikgeworCQlwY2lfcmVhZF9jb25maWdfYnl0ZShhbWRfc21idXNfZGV2LCBQQ0lfUkVWSVNJT05fSUQsICZyZXYpOworCQlpZiAocmV2IDwgMHg0MCkgeworCQkJcGNpX2Rldl9wdXQoYW1kX3NtYnVzX2Rldik7CisJCQlhbWRfc21idXNfZGV2ID0gTlVMTDsKKwkJCXJldHVybiAwOworCQl9CisJfSBlbHNlIHsKKwkJYW1kX3NtYnVzX2RldiA9IHBjaV9nZXRfZGV2aWNlKFBDSV9WRU5ET1JfSURfQU1ELCAweDc4MGIsIE5VTEwpOworCQlpZiAoIWFtZF9zbWJ1c19kZXYpCisJCQlyZXR1cm4gMDsKKwkJcGNpX3JlYWRfY29uZmlnX2J5dGUoYW1kX3NtYnVzX2RldiwgUENJX1JFVklTSU9OX0lELCAmcmV2KTsKKwkJaWYgKHJldiA8IDB4MTEgfHwgcmV2ID4gMHgxOCkgeworCQkJcGNpX2Rldl9wdXQoYW1kX3NtYnVzX2Rldik7CisJCQlhbWRfc21idXNfZGV2ID0gTlVMTDsKKwkJCXJldHVybiAwOworCQl9CiAJfQogCiAJaWYgKCFhbWRfbmJfZGV2KQogCQlhbWRfbmJfZGV2ID0gcGNpX2dldF9kZXZpY2UoUENJX1ZFTkRPUl9JRF9BTUQsIDB4MTUxMCwgTlVMTCk7Ci0JaWYgKCFhbWRfbmJfZGV2KQotCQllaGNpX2VycihlaGNpLCAiUVVJUks6IHVuYWJsZSB0byBnZXQgQU1EIE5CIGRldmljZVxuIik7CiAKLQllaGNpX2luZm8oZWhjaSwgIlFVSVJLOiBFbmFibGUgQU1EIFNCODAwIEwxIGZpeFxuIik7CisJZWhjaV9pbmZvKGVoY2ksICJRVUlSSzogRW5hYmxlIGV4Y2VwdGlvbiBmb3IgQU1EIEh1ZHNvbiBBU1BNXG4iKTsKIAogCXBjaV9kZXZfcHV0KGFtZF9zbWJ1c19kZXYpOwogCWFtZF9zbWJ1c19kZXYgPSBOVUxMOwpAQCAtMTMxLDcgKzEzOCw3IEBACiAJLyogY2FjaGUgdGhpcyByZWFkb25seSBkYXRhOyBtaW5pbWl6ZSBjaGlwIHJlYWRzICovCiAJZWhjaS0+aGNzX3BhcmFtcyA9IGVoY2lfcmVhZGwoZWhjaSwgJmVoY2ktPmNhcHMtPmhjc19wYXJhbXMpOwogCi0JaWYgKGVoY2lfcXVpcmtfYW1kX1NCODAwKGVoY2kpKQorCWlmIChlaGNpX3F1aXJrX2FtZF9odWRzb24oZWhjaSkpCiAJCWVoY2ktPmFtZF9sMV9maXggPSAxOwogCiAJcmV0dmFsID0gZWhjaV9oYWx0KGVoY2kpOwpAQCAtMzYwLDggKzM2Nyw4IEBACiAJICogbWFyayBIVyB1bmFjY2Vzc2libGUuICBUaGUgUE0gYW5kIFVTQiBjb3JlcyBtYWtlIHN1cmUgdGhhdAogCSAqIHRoZSByb290IGh1YiBpcyBlaXRoZXIgc3VzcGVuZGVkIG9yIHN0b3BwZWQuCiAJICovCi0Jc3Bpbl9sb2NrX2lycXNhdmUgKCZlaGNpLT5sb2NrLCBmbGFncyk7CiAJZWhjaV9wcmVwYXJlX3BvcnRzX2Zvcl9jb250cm9sbGVyX3N1c3BlbmQoZWhjaSwgZG9fd2FrZXVwKTsKKwlzcGluX2xvY2tfaXJxc2F2ZSAoJmVoY2ktPmxvY2ssIGZsYWdzKTsKIAllaGNpX3dyaXRlbChlaGNpLCAwLCAmZWhjaS0+cmVncy0+aW50cl9lbmFibGUpOwogCSh2b2lkKWVoY2lfcmVhZGwoZWhjaSwgJmVoY2ktPnJlZ3MtPmludHJfZW5hYmxlKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC9mc2wtbXBoLWRyLW9mLmMgYi9kcml2ZXJzL3VzYi9ob3N0L2ZzbC1tcGgtZHItb2YuYwppbmRleCA1NzRiOTllLi43OWE2NmQ2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9ob3N0L2ZzbC1tcGgtZHItb2YuYworKysgYi9kcml2ZXJzL3VzYi9ob3N0L2ZzbC1tcGgtZHItb2YuYwpAQCAtMjYyLDE5ICsyNjIsMjQgQEAKIAl9CiB9CiAKLXN0cnVjdCBmc2xfdXNiMl9wbGF0Zm9ybV9kYXRhIGZzbF91c2IyX21wYzUxMjFfcGQgPSB7CitzdGF0aWMgc3RydWN0IGZzbF91c2IyX3BsYXRmb3JtX2RhdGEgZnNsX3VzYjJfbXBjNTEyMV9wZCA9IHsKIAkuYmlnX2VuZGlhbl9kZXNjID0gMSwKIAkuYmlnX2VuZGlhbl9tbWlvID0gMSwKIAkuZXMgPSAxLAorCS5oYXZlX3N5c2lmX3JlZ3MgPSAwLAogCS5sZV9zZXR1cF9idWYgPSAxLAogCS5pbml0ID0gZnNsX3VzYjJfbXBjNTEyMV9pbml0LAogCS5leGl0ID0gZnNsX3VzYjJfbXBjNTEyMV9leGl0LAogfTsKICNlbmRpZiAvKiBDT05GSUdfUFBDX01QQzUxMnggKi8KIAorc3RhdGljIHN0cnVjdCBmc2xfdXNiMl9wbGF0Zm9ybV9kYXRhIGZzbF91c2IyX21wYzh4eHhfcGQgPSB7CisJLmhhdmVfc3lzaWZfcmVncyA9IDEsCit9OworCiBzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBmc2xfdXNiMl9tcGhfZHJfb2ZfbWF0Y2hbXSA9IHsKLQl7IC5jb21wYXRpYmxlID0gImZzbC11c2IyLW1waCIsIH0sCi0JeyAuY29tcGF0aWJsZSA9ICJmc2wtdXNiMi1kciIsIH0sCisJeyAuY29tcGF0aWJsZSA9ICJmc2wtdXNiMi1tcGgiLCAuZGF0YSA9ICZmc2xfdXNiMl9tcGM4eHh4X3BkLCB9LAorCXsgLmNvbXBhdGlibGUgPSAiZnNsLXVzYjItZHIiLCAuZGF0YSA9ICZmc2xfdXNiMl9tcGM4eHh4X3BkLCB9LAogI2lmZGVmIENPTkZJR19QUENfTVBDNTEyeAogCXsgLmNvbXBhdGlibGUgPSAiZnNsLG1wYzUxMjEtdXNiMi1kciIsIC5kYXRhID0gJmZzbF91c2IyX21wYzUxMjFfcGQsIH0sCiAjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2hvc3Qvc2w4MTEtaGNkLmMgYi9kcml2ZXJzL3VzYi9ob3N0L3NsODExLWhjZC5jCmluZGV4IDk5MGYwNmIuLjJlOTYwMmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2hvc3Qvc2w4MTEtaGNkLmMKKysrIGIvZHJpdmVycy91c2IvaG9zdC9zbDgxMS1oY2QuYwpAQCAtODYxLDYgKzg2MSw3IEBACiAJCQlEQkcoImRldiAlZCBlcCVkIG1heHBhY2tldCAlZFxuIiwKIAkJCQl1ZGV2LT5kZXZudW0sIGVwbnVtLCBlcC0+bWF4cGFja2V0KTsKIAkJCXJldHZhbCA9IC1FSU5WQUw7CisJCQlrZnJlZShlcCk7CiAJCQlnb3RvIGZhaWw7CiAJCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC94aGNpLXJpbmcuYyBiL2RyaXZlcnMvdXNiL2hvc3QveGhjaS1yaW5nLmMKaW5kZXggZGY1NThmNi4uM2U4MjExYyAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvaG9zdC94aGNpLXJpbmcuYworKysgYi9kcml2ZXJzL3VzYi9ob3N0L3hoY2ktcmluZy5jCkBAIC0zMDgsMTEgKzMwOCw4IEBACiAvKiBSaW5nIHRoZSBob3N0IGNvbnRyb2xsZXIgZG9vcmJlbGwgYWZ0ZXIgcGxhY2luZyBhIGNvbW1hbmQgb24gdGhlIHJpbmcgKi8KIHZvaWQgeGhjaV9yaW5nX2NtZF9kYihzdHJ1Y3QgeGhjaV9oY2QgKnhoY2kpCiB7Ci0JdTMyIHRlbXA7Ci0KIAl4aGNpX2RiZyh4aGNpLCAiLy8gRGluZyBkb25nIVxuIik7Ci0JdGVtcCA9IHhoY2lfcmVhZGwoeGhjaSwgJnhoY2ktPmRiYS0+ZG9vcmJlbGxbMF0pICYgREJfTUFTSzsKLQl4aGNpX3dyaXRlbCh4aGNpLCB0ZW1wIHwgREJfVEFSR0VUX0hPU1QsICZ4aGNpLT5kYmEtPmRvb3JiZWxsWzBdKTsKKwl4aGNpX3dyaXRlbCh4aGNpLCBEQl9WQUxVRV9IT1NULCAmeGhjaS0+ZGJhLT5kb29yYmVsbFswXSk7CiAJLyogRmx1c2ggUENJIHBvc3RlZCB3cml0ZXMgKi8KIAl4aGNpX3JlYWRsKHhoY2ksICZ4aGNpLT5kYmEtPmRvb3JiZWxsWzBdKTsKIH0KQEAgLTMyMiwyNiArMzE5LDI0IEBACiAJCXVuc2lnbmVkIGludCBlcF9pbmRleCwKIAkJdW5zaWduZWQgaW50IHN0cmVhbV9pZCkKIHsKLQlzdHJ1Y3QgeGhjaV92aXJ0X2VwICplcDsKLQl1bnNpZ25lZCBpbnQgZXBfc3RhdGU7Ci0JdTMyIGZpZWxkOwogCV9fdTMyIF9faW9tZW0gKmRiX2FkZHIgPSAmeGhjaS0+ZGJhLT5kb29yYmVsbFtzbG90X2lkXTsKKwlzdHJ1Y3QgeGhjaV92aXJ0X2VwICplcCA9ICZ4aGNpLT5kZXZzW3Nsb3RfaWRdLT5lcHNbZXBfaW5kZXhdOworCXVuc2lnbmVkIGludCBlcF9zdGF0ZSA9IGVwLT5lcF9zdGF0ZTsKIAotCWVwID0gJnhoY2ktPmRldnNbc2xvdF9pZF0tPmVwc1tlcF9pbmRleF07Ci0JZXBfc3RhdGUgPSBlcC0+ZXBfc3RhdGU7CiAJLyogRG9uJ3QgcmluZyB0aGUgZG9vcmJlbGwgZm9yIHRoaXMgZW5kcG9pbnQgaWYgdGhlcmUgYXJlIHBlbmRpbmcKLQkgKiBjYW5jZWxsYXRpb25zIGJlY2F1c2UgdGhlIHdlIGRvbid0IHdhbnQgdG8gaW50ZXJydXB0IHByb2Nlc3NpbmcuCisJICogY2FuY2VsbGF0aW9ucyBiZWNhdXNlIHdlIGRvbid0IHdhbnQgdG8gaW50ZXJydXB0IHByb2Nlc3NpbmcuCiAJICogV2UgZG9uJ3Qgd2FudCB0byByZXN0YXJ0IGFueSBzdHJlYW0gcmluZ3MgaWYgdGhlcmUncyBhIHNldCBkZXF1ZXVlCiAJICogcG9pbnRlciBjb21tYW5kIHBlbmRpbmcgYmVjYXVzZSB0aGUgZGV2aWNlIGNhbiBjaG9vc2UgdG8gc3RhcnQgYW55CiAJICogc3RyZWFtIG9uY2UgdGhlIGVuZHBvaW50IGlzIG9uIHRoZSBIVyBzY2hlZHVsZS4KIAkgKiBGSVhNRSAtIGNoZWNrIGFsbCB0aGUgc3RyZWFtIHJpbmdzIGZvciBwZW5kaW5nIGNhbmNlbGxhdGlvbnMuCiAJICovCi0JaWYgKCEoZXBfc3RhdGUgJiBFUF9IQUxUX1BFTkRJTkcpICYmICEoZXBfc3RhdGUgJiBTRVRfREVRX1BFTkRJTkcpCi0JCQkmJiAhKGVwX3N0YXRlICYgRVBfSEFMVEVEKSkgewotCQlmaWVsZCA9IHhoY2lfcmVhZGwoeGhjaSwgZGJfYWRkcikgJiBEQl9NQVNLOwotCQlmaWVsZCB8PSBFUElfVE9fREIoZXBfaW5kZXgpIHwgU1RSRUFNX0lEX1RPX0RCKHN0cmVhbV9pZCk7Ci0JCXhoY2lfd3JpdGVsKHhoY2ksIGZpZWxkLCBkYl9hZGRyKTsKLQl9CisJaWYgKChlcF9zdGF0ZSAmIEVQX0hBTFRfUEVORElORykgfHwgKGVwX3N0YXRlICYgU0VUX0RFUV9QRU5ESU5HKSB8fAorCSAgICAoZXBfc3RhdGUgJiBFUF9IQUxURUQpKQorCQlyZXR1cm47CisJeGhjaV93cml0ZWwoeGhjaSwgREJfVkFMVUUoZXBfaW5kZXgsIHN0cmVhbV9pZCksIGRiX2FkZHIpOworCS8qIFRoZSBDUFUgaGFzIGJldHRlciB0aGluZ3MgdG8gZG8gYXQgdGhpcyBwb2ludCB0aGFuIHdhaXQgZm9yIGEKKwkgKiB3cml0ZS1wb3N0aW5nIGZsdXNoLiAgSXQnbGwgZ2V0IHRoZXJlIHNvb24gZW5vdWdoLgorCSAqLwogfQogCiAvKiBSaW5nIHRoZSBkb29yYmVsbCBmb3IgYW55IHJpbmdzIHdpdGggcGVuZGluZyBVUkJzICovCkBAIC0xMTg4LDcgKzExODMsNyBAQAogCiAJYWRkciA9ICZ4aGNpLT5vcF9yZWdzLT5wb3J0X3N0YXR1c19iYXNlICsgTlVNX1BPUlRfUkVHUyAqIChwb3J0X2lkIC0gMSk7CiAJdGVtcCA9IHhoY2lfcmVhZGwoeGhjaSwgYWRkcik7Ci0JaWYgKCh0ZW1wICYgUE9SVF9DT05ORUNUKSAmJiAoaGNkLT5zdGF0ZSA9PSBIQ19TVEFURV9TVVNQRU5ERUQpKSB7CisJaWYgKGhjZC0+c3RhdGUgPT0gSENfU1RBVEVfU1VTUEVOREVEKSB7CiAJCXhoY2lfZGJnKHhoY2ksICJyZXN1bWUgcm9vdCBodWJcbiIpOwogCQl1c2JfaGNkX3Jlc3VtZV9yb290X2h1YihoY2QpOwogCX0KQEAgLTE3MTAsOCArMTcwNSw3IEBACiAJCS8qIE90aGVycyBhbHJlYWR5IGhhbmRsZWQgYWJvdmUgKi8KIAkJYnJlYWs7CiAJfQotCWRldl9kYmcoJnRkLT51cmItPmRldi0+ZGV2LAotCQkJImVwICUjeCAtIGFza2VkIGZvciAlZCBieXRlcywgIgorCXhoY2lfZGJnKHhoY2ksICJlcCAlI3ggLSBhc2tlZCBmb3IgJWQgYnl0ZXMsICIKIAkJCSIlZCBieXRlcyB1bnRyYW5zZmVycmVkXG4iLAogCQkJdGQtPnVyYi0+ZXAtPmRlc2MuYkVuZHBvaW50QWRkcmVzcywKIAkJCXRkLT51cmItPnRyYW5zZmVyX2J1ZmZlcl9sZW5ndGgsCkBAIC0yMzg5LDcgKzIzODMsOCBAQAogCX0KIAl4aGNpX2RiZyh4aGNpLCAiXG4iKTsKIAlpZiAoIWluX2ludGVycnVwdCgpKQotCQlkZXZfZGJnKCZ1cmItPmRldi0+ZGV2LCAiZXAgJSN4IC0gdXJiIGxlbiA9ICVkLCBzZ2xpc3QgdXNlZCwgbnVtX3RyYnMgPSAlZFxuIiwKKwkJeGhjaV9kYmcoeGhjaSwgImVwICUjeCAtIHVyYiBsZW4gPSAlZCwgc2dsaXN0IHVzZWQsICIKKwkJCQkibnVtX3RyYnMgPSAlZFxuIiwKIAkJCQl1cmItPmVwLT5kZXNjLmJFbmRwb2ludEFkZHJlc3MsCiAJCQkJdXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoLAogCQkJCW51bV90cmJzKTsKQEAgLTI0MTQsMTQgKzI0MDksMTcgQEAKIAogc3RhdGljIHZvaWQgZ2l2ZWJhY2tfZmlyc3RfdHJiKHN0cnVjdCB4aGNpX2hjZCAqeGhjaSwgaW50IHNsb3RfaWQsCiAJCXVuc2lnbmVkIGludCBlcF9pbmRleCwgdW5zaWduZWQgaW50IHN0cmVhbV9pZCwgaW50IHN0YXJ0X2N5Y2xlLAotCQlzdHJ1Y3QgeGhjaV9nZW5lcmljX3RyYiAqc3RhcnRfdHJiLCBzdHJ1Y3QgeGhjaV90ZCAqdGQpCisJCXN0cnVjdCB4aGNpX2dlbmVyaWNfdHJiICpzdGFydF90cmIpCiB7CiAJLyoKIAkgKiBQYXNzIGFsbCB0aGUgVFJCcyB0byB0aGUgaGFyZHdhcmUgYXQgb25jZSBhbmQgbWFrZSBzdXJlIHRoaXMgd3JpdGUKIAkgKiBpc24ndCByZW9yZGVyZWQuCiAJICovCiAJd21iKCk7Ci0Jc3RhcnRfdHJiLT5maWVsZFszXSB8PSBzdGFydF9jeWNsZTsKKwlpZiAoc3RhcnRfY3ljbGUpCisJCXN0YXJ0X3RyYi0+ZmllbGRbM10gfD0gc3RhcnRfY3ljbGU7CisJZWxzZQorCQlzdGFydF90cmItPmZpZWxkWzNdICY9IH4weDE7CiAJeGhjaV9yaW5nX2VwX2Rvb3JiZWxsKHhoY2ksIHNsb3RfaWQsIGVwX2luZGV4LCBzdHJlYW1faWQpOwogfQogCkBAIC0yNDQ5LDcgKzI0NDcsNyBAQAogCSAqIHRvIHNldCB0aGUgcG9sbGluZyBpbnRlcnZhbCAob25jZSB0aGUgQVBJIGlzIGFkZGVkKS4KIAkgKi8KIAlpZiAoeGhjaV9pbnRlcnZhbCAhPSBlcF9pbnRlcnZhbCkgewotCQlpZiAoIXByaW50a19yYXRlbGltaXQoKSkKKwkJaWYgKHByaW50a19yYXRlbGltaXQoKSkKIAkJCWRldl9kYmcoJnVyYi0+ZGV2LT5kZXYsICJEcml2ZXIgdXNlcyBkaWZmZXJlbnQgaW50ZXJ2YWwiCiAJCQkJCSIgKCVkIG1pY3JvZnJhbWUlcykgdGhhbiB4SENJICIKIAkJCQkJIiglZCBtaWNyb2ZyYW1lJXMpXG4iLApAQCAtMjU1MSw5ICsyNTQ5LDExIEBACiAJCXUzMiByZW1haW5kZXIgPSAwOwogCiAJCS8qIERvbid0IGNoYW5nZSB0aGUgY3ljbGUgYml0IG9mIHRoZSBmaXJzdCBUUkIgdW50aWwgbGF0ZXIgKi8KLQkJaWYgKGZpcnN0X3RyYikKKwkJaWYgKGZpcnN0X3RyYikgewogCQkJZmlyc3RfdHJiID0gZmFsc2U7Ci0JCWVsc2UKKwkJCWlmIChzdGFydF9jeWNsZSA9PSAwKQorCQkJCWZpZWxkIHw9IDB4MTsKKwkJfSBlbHNlCiAJCQlmaWVsZCB8PSBlcF9yaW5nLT5jeWNsZV9zdGF0ZTsKIAogCQkvKiBDaGFpbiBhbGwgdGhlIFRSQnMgdG9nZXRoZXI7IGNsZWFyIHRoZSBjaGFpbiBiaXQgaW4gdGhlIGxhc3QKQEAgLTI2MjUsNyArMjYyNSw3IEBACiAKIAljaGVja190cmJfbWF0aCh1cmIsIG51bV90cmJzLCBydW5uaW5nX3RvdGFsKTsKIAlnaXZlYmFja19maXJzdF90cmIoeGhjaSwgc2xvdF9pZCwgZXBfaW5kZXgsIHVyYi0+c3RyZWFtX2lkLAotCQkJc3RhcnRfY3ljbGUsIHN0YXJ0X3RyYiwgdGQpOworCQkJc3RhcnRfY3ljbGUsIHN0YXJ0X3RyYik7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTI2NzEsNyArMjY3MSw4IEBACiAJLyogRklYTUU6IHRoaXMgZG9lc24ndCBkZWFsIHdpdGggVVJCX1pFUk9fUEFDS0VUIC0gbmVlZCBvbmUgbW9yZSAqLwogCiAJaWYgKCFpbl9pbnRlcnJ1cHQoKSkKLQkJZGV2X2RiZygmdXJiLT5kZXYtPmRldiwgImVwICUjeCAtIHVyYiBsZW4gPSAlI3ggKCVkKSwgYWRkciA9ICUjbGx4LCBudW1fdHJicyA9ICVkXG4iLAorCQl4aGNpX2RiZyh4aGNpLCAiZXAgJSN4IC0gdXJiIGxlbiA9ICUjeCAoJWQpLCAiCisJCQkJImFkZHIgPSAlI2xseCwgbnVtX3RyYnMgPSAlZFxuIiwKIAkJCQl1cmItPmVwLT5kZXNjLmJFbmRwb2ludEFkZHJlc3MsCiAJCQkJdXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoLAogCQkJCXVyYi0+dHJhbnNmZXJfYnVmZmVyX2xlbmd0aCwKQEAgLTI3MTEsOSArMjcxMiwxMSBAQAogCQlmaWVsZCA9IDA7CiAKIAkJLyogRG9uJ3QgY2hhbmdlIHRoZSBjeWNsZSBiaXQgb2YgdGhlIGZpcnN0IFRSQiB1bnRpbCBsYXRlciAqLwotCQlpZiAoZmlyc3RfdHJiKQorCQlpZiAoZmlyc3RfdHJiKSB7CiAJCQlmaXJzdF90cmIgPSBmYWxzZTsKLQkJZWxzZQorCQkJaWYgKHN0YXJ0X2N5Y2xlID09IDApCisJCQkJZmllbGQgfD0gMHgxOworCQl9IGVsc2UKIAkJCWZpZWxkIHw9IGVwX3JpbmctPmN5Y2xlX3N0YXRlOwogCiAJCS8qIENoYWluIGFsbCB0aGUgVFJCcyB0b2dldGhlcjsgY2xlYXIgdGhlIGNoYWluIGJpdCBpbiB0aGUgbGFzdApAQCAtMjc1Nyw3ICsyNzYwLDcgQEAKIAogCWNoZWNrX3RyYl9tYXRoKHVyYiwgbnVtX3RyYnMsIHJ1bm5pbmdfdG90YWwpOwogCWdpdmViYWNrX2ZpcnN0X3RyYih4aGNpLCBzbG90X2lkLCBlcF9pbmRleCwgdXJiLT5zdHJlYW1faWQsCi0JCQlzdGFydF9jeWNsZSwgc3RhcnRfdHJiLCB0ZCk7CisJCQlzdGFydF9jeWNsZSwgc3RhcnRfdHJiKTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtMjgxOCwxMyArMjgyMSwxNyBAQAogCS8qIFF1ZXVlIHNldHVwIFRSQiAtIHNlZSBzZWN0aW9uIDYuNC4xLjIuMSAqLwogCS8qIEZJWE1FIGJldHRlciB3YXkgdG8gdHJhbnNsYXRlIHNldHVwX3BhY2tldCBpbnRvIHR3byB1MzIgZmllbGRzPyAqLwogCXNldHVwID0gKHN0cnVjdCB1c2JfY3RybHJlcXVlc3QgKikgdXJiLT5zZXR1cF9wYWNrZXQ7CisJZmllbGQgPSAwOworCWZpZWxkIHw9IFRSQl9JRFQgfCBUUkJfVFlQRShUUkJfU0VUVVApOworCWlmIChzdGFydF9jeWNsZSA9PSAwKQorCQlmaWVsZCB8PSAweDE7CiAJcXVldWVfdHJiKHhoY2ksIGVwX3JpbmcsIGZhbHNlLCB0cnVlLAogCQkJLyogRklYTUUgZW5kaWFubmVzcyBpcyBwcm9iYWJseSBnb2luZyB0byBiaXRlIG15IGFzcyBoZXJlLiAqLwogCQkJc2V0dXAtPmJSZXF1ZXN0VHlwZSB8IHNldHVwLT5iUmVxdWVzdCA8PCA4IHwgc2V0dXAtPndWYWx1ZSA8PCAxNiwKIAkJCXNldHVwLT53SW5kZXggfCBzZXR1cC0+d0xlbmd0aCA8PCAxNiwKIAkJCVRSQl9MRU4oOCkgfCBUUkJfSU5UUl9UQVJHRVQoMCksCiAJCQkvKiBJbW1lZGlhdGUgZGF0YSBpbiBwb2ludGVyICovCi0JCQlUUkJfSURUIHwgVFJCX1RZUEUoVFJCX1NFVFVQKSk7CisJCQlmaWVsZCk7CiAKIAkvKiBJZiB0aGVyZSdzIGRhdGEsIHF1ZXVlIGRhdGEgVFJCcyAqLwogCWZpZWxkID0gMDsKQEAgLTI4NTksNyArMjg2Niw3IEBACiAJCQlmaWVsZCB8IFRSQl9JT0MgfCBUUkJfVFlQRShUUkJfU1RBVFVTKSB8IGVwX3JpbmctPmN5Y2xlX3N0YXRlKTsKIAogCWdpdmViYWNrX2ZpcnN0X3RyYih4aGNpLCBzbG90X2lkLCBlcF9pbmRleCwgMCwKLQkJCXN0YXJ0X2N5Y2xlLCBzdGFydF90cmIsIHRkKTsKKwkJCXN0YXJ0X2N5Y2xlLCBzdGFydF90cmIpOwogCXJldHVybiAwOwogfQogCkBAIC0yOTAwLDYgKzI5MDcsNyBAQAogCWludCBydW5uaW5nX3RvdGFsLCB0cmJfYnVmZl9sZW4sIHRkX2xlbiwgdGRfcmVtYWluX2xlbiwgcmV0OwogCXU2NCBzdGFydF9hZGRyLCBhZGRyOwogCWludCBpLCBqOworCWJvb2wgbW9yZV90cmJzX2NvbWluZzsKIAogCWVwX3JpbmcgPSB4aGNpLT5kZXZzW3Nsb3RfaWRdLT5lcHNbZXBfaW5kZXhdLnJpbmc7CiAKQEAgLTI5MTAsNyArMjkxOCw3IEBACiAJfQogCiAJaWYgKCFpbl9pbnRlcnJ1cHQoKSkKLQkJZGV2X2RiZygmdXJiLT5kZXYtPmRldiwgImVwICUjeCAtIHVyYiBsZW4gPSAlI3ggKCVkKSwiCisJCXhoY2lfZGJnKHhoY2ksICJlcCAlI3ggLSB1cmIgbGVuID0gJSN4ICglZCksIgogCQkJCSIgYWRkciA9ICUjbGx4LCBudW1fdGRzID0gJWRcbiIsCiAJCQkJdXJiLT5lcC0+ZGVzYy5iRW5kcG9pbnRBZGRyZXNzLAogCQkJCXVyYi0+dHJhbnNmZXJfYnVmZmVyX2xlbmd0aCwKQEAgLTI5NTAsNyArMjk1OCwxMCBAQAogCQkJCWZpZWxkIHw9IFRSQl9UWVBFKFRSQl9JU09DKTsKIAkJCQkvKiBBc3N1bWUgVVJCX0lTT19BU0FQIGlzIHNldCAqLwogCQkJCWZpZWxkIHw9IFRSQl9TSUE7Ci0JCQkJaWYgKGkgPiAwKQorCQkJCWlmIChpID09IDApIHsKKwkJCQkJaWYgKHN0YXJ0X2N5Y2xlID09IDApCisJCQkJCQlmaWVsZCB8PSAweDE7CisJCQkJfSBlbHNlCiAJCQkJCWZpZWxkIHw9IGVwX3JpbmctPmN5Y2xlX3N0YXRlOwogCQkJCWZpcnN0X3RyYiA9IGZhbHNlOwogCQkJfSBlbHNlIHsKQEAgLTI5NjUsOSArMjk3NiwxMSBAQAogCQkJICovCiAJCQlpZiAoaiA8IHRyYnNfcGVyX3RkIC0gMSkgewogCQkJCWZpZWxkIHw9IFRSQl9DSEFJTjsKKwkJCQltb3JlX3RyYnNfY29taW5nID0gdHJ1ZTsKIAkJCX0gZWxzZSB7CiAJCQkJdGQtPmxhc3RfdHJiID0gZXBfcmluZy0+ZW5xdWV1ZTsKIAkJCQlmaWVsZCB8PSBUUkJfSU9DOworCQkJCW1vcmVfdHJic19jb21pbmcgPSBmYWxzZTsKIAkJCX0KIAogCQkJLyogQ2FsY3VsYXRlIFRSQiBsZW5ndGggKi8KQEAgLTI5ODAsNyArMjk5Myw3IEBACiAJCQlsZW5ndGhfZmllbGQgPSBUUkJfTEVOKHRyYl9idWZmX2xlbikgfAogCQkJCXJlbWFpbmRlciB8CiAJCQkJVFJCX0lOVFJfVEFSR0VUKDApOwotCQkJcXVldWVfdHJiKHhoY2ksIGVwX3JpbmcsIGZhbHNlLCBmYWxzZSwKKwkJCXF1ZXVlX3RyYih4aGNpLCBlcF9yaW5nLCBmYWxzZSwgbW9yZV90cmJzX2NvbWluZywKIAkJCQlsb3dlcl8zMl9iaXRzKGFkZHIpLAogCQkJCXVwcGVyXzMyX2JpdHMoYWRkciksCiAJCQkJbGVuZ3RoX2ZpZWxkLApAQCAtMzAwMywxMCArMzAxNiw4IEBACiAJCX0KIAl9CiAKLQl3bWIoKTsKLQlzdGFydF90cmItPmZpZWxkWzNdIHw9IHN0YXJ0X2N5Y2xlOwotCi0JeGhjaV9yaW5nX2VwX2Rvb3JiZWxsKHhoY2ksIHNsb3RfaWQsIGVwX2luZGV4LCB1cmItPnN0cmVhbV9pZCk7CisJZ2l2ZWJhY2tfZmlyc3RfdHJiKHhoY2ksIHNsb3RfaWQsIGVwX2luZGV4LCB1cmItPnN0cmVhbV9pZCwKKwkJCXN0YXJ0X2N5Y2xlLCBzdGFydF90cmIpOwogCXJldHVybiAwOwogfQogCkBAIC0zMDY0LDcgKzMwNzUsNyBAQAogCSAqIHRvIHNldCB0aGUgcG9sbGluZyBpbnRlcnZhbCAob25jZSB0aGUgQVBJIGlzIGFkZGVkKS4KIAkgKi8KIAlpZiAoeGhjaV9pbnRlcnZhbCAhPSBlcF9pbnRlcnZhbCkgewotCQlpZiAoIXByaW50a19yYXRlbGltaXQoKSkKKwkJaWYgKHByaW50a19yYXRlbGltaXQoKSkKIAkJCWRldl9kYmcoJnVyYi0+ZGV2LT5kZXYsICJEcml2ZXIgdXNlcyBkaWZmZXJlbnQgaW50ZXJ2YWwiCiAJCQkJCSIgKCVkIG1pY3JvZnJhbWUlcykgdGhhbiB4SENJICIKIAkJCQkJIiglZCBtaWNyb2ZyYW1lJXMpXG4iLApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC94aGNpLmMgYi9kcml2ZXJzL3VzYi9ob3N0L3hoY2kuYwppbmRleCA0NWU0YTMxLi4zNGNmNGUxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9ob3N0L3hoY2kuYworKysgYi9kcml2ZXJzL3VzYi9ob3N0L3hoY2kuYwpAQCAtMjI2LDcgKzIyNiw4IEBACiBzdGF0aWMgaW50IHhoY2lfc2V0dXBfbXNpeChzdHJ1Y3QgeGhjaV9oY2QgKnhoY2kpCiB7CiAJaW50IGksIHJldCA9IDA7Ci0Jc3RydWN0IHBjaV9kZXYgKnBkZXYgPSB0b19wY2lfZGV2KHhoY2lfdG9faGNkKHhoY2kpLT5zZWxmLmNvbnRyb2xsZXIpOworCXN0cnVjdCB1c2JfaGNkICpoY2QgPSB4aGNpX3RvX2hjZCh4aGNpKTsKKwlzdHJ1Y3QgcGNpX2RldiAqcGRldiA9IHRvX3BjaV9kZXYoaGNkLT5zZWxmLmNvbnRyb2xsZXIpOwogCiAJLyoKIAkgKiBjYWxjdWxhdGUgbnVtYmVyIG9mIG1zaS14IHZlY3RvcnMgc3VwcG9ydGVkLgpAQCAtMjY1LDYgKzI2Niw3IEBACiAJCQlnb3RvIGRpc2FibGVfbXNpeDsKIAl9CiAKKwloY2QtPm1zaXhfZW5hYmxlZCA9IDE7CiAJcmV0dXJuIHJldDsKIAogZGlzYWJsZV9tc2l4OgpAQCAtMjgwLDcgKzI4Miw4IEBACiAvKiBGcmVlIGFueSBJUlFzIGFuZCBkaXNhYmxlIE1TSS1YICovCiBzdGF0aWMgdm9pZCB4aGNpX2NsZWFudXBfbXNpeChzdHJ1Y3QgeGhjaV9oY2QgKnhoY2kpCiB7Ci0Jc3RydWN0IHBjaV9kZXYgKnBkZXYgPSB0b19wY2lfZGV2KHhoY2lfdG9faGNkKHhoY2kpLT5zZWxmLmNvbnRyb2xsZXIpOworCXN0cnVjdCB1c2JfaGNkICpoY2QgPSB4aGNpX3RvX2hjZCh4aGNpKTsKKwlzdHJ1Y3QgcGNpX2RldiAqcGRldiA9IHRvX3BjaV9kZXYoaGNkLT5zZWxmLmNvbnRyb2xsZXIpOwogCiAJeGhjaV9mcmVlX2lycSh4aGNpKTsKIApAQCAtMjkyLDYgKzI5NSw3IEBACiAJCXBjaV9kaXNhYmxlX21zaShwZGV2KTsKIAl9CiAKKwloY2QtPm1zaXhfZW5hYmxlZCA9IDA7CiAJcmV0dXJuOwogfQogCkBAIC01MDgsOSArNTEyLDEwIEBACiAJc3Bpbl9sb2NrX2lycSgmeGhjaS0+bG9jayk7CiAJeGhjaV9oYWx0KHhoY2kpOwogCXhoY2lfcmVzZXQoeGhjaSk7Ci0JeGhjaV9jbGVhbnVwX21zaXgoeGhjaSk7CiAJc3Bpbl91bmxvY2tfaXJxKCZ4aGNpLT5sb2NrKTsKIAorCXhoY2lfY2xlYW51cF9tc2l4KHhoY2kpOworCiAjaWZkZWYgQ09ORklHX1VTQl9YSENJX0hDRF9ERUJVR0dJTkcKIAkvKiBUZWxsIHRoZSBldmVudCByaW5nIHBvbGwgZnVuY3Rpb24gbm90IHRvIHJlc2NoZWR1bGUgKi8KIAl4aGNpLT56b21iaWUgPSAxOwpAQCAtNTQ0LDkgKzU0OSwxMCBAQAogCiAJc3Bpbl9sb2NrX2lycSgmeGhjaS0+bG9jayk7CiAJeGhjaV9oYWx0KHhoY2kpOwotCXhoY2lfY2xlYW51cF9tc2l4KHhoY2kpOwogCXNwaW5fdW5sb2NrX2lycSgmeGhjaS0+bG9jayk7CiAKKwl4aGNpX2NsZWFudXBfbXNpeCh4aGNpKTsKKwogCXhoY2lfZGJnKHhoY2ksICJ4aGNpX3NodXRkb3duIGNvbXBsZXRlZCAtIHN0YXR1cyA9ICV4XG4iLAogCQkgICAgeGhjaV9yZWFkbCh4aGNpLCAmeGhjaS0+b3BfcmVncy0+c3RhdHVzKSk7CiB9CkBAIC02NDcsNiArNjUzLDcgQEAKIAlpbnQJCQlyYyA9IDA7CiAJc3RydWN0IHVzYl9oY2QJCSpoY2QgPSB4aGNpX3RvX2hjZCh4aGNpKTsKIAl1MzIJCQljb21tYW5kOworCWludAkJCWk7CiAKIAlzcGluX2xvY2tfaXJxKCZ4aGNpLT5sb2NrKTsKIAljbGVhcl9iaXQoSENEX0ZMQUdfSFdfQUNDRVNTSUJMRSwgJmhjZC0+ZmxhZ3MpOwpAQCAtNjc3LDEwICs2ODQsMTUgQEAKIAkJc3Bpbl91bmxvY2tfaXJxKCZ4aGNpLT5sb2NrKTsKIAkJcmV0dXJuIC1FVElNRURPVVQ7CiAJfQotCS8qIHN0ZXAgNTogcmVtb3ZlIGNvcmUgd2VsbCBwb3dlciAqLwotCXhoY2lfY2xlYW51cF9tc2l4KHhoY2kpOwogCXNwaW5fdW5sb2NrX2lycSgmeGhjaS0+bG9jayk7CiAKKwkvKiBzdGVwIDU6IHJlbW92ZSBjb3JlIHdlbGwgcG93ZXIgKi8KKwkvKiBzeW5jaHJvbml6ZSBpcnEgd2hlbiB1c2luZyBNU0ktWCAqLworCWlmICh4aGNpLT5tc2l4X2VudHJpZXMpIHsKKwkJZm9yIChpID0gMDsgaSA8IHhoY2ktPm1zaXhfY291bnQ7IGkrKykKKwkJCXN5bmNocm9uaXplX2lycSh4aGNpLT5tc2l4X2VudHJpZXNbaV0udmVjdG9yKTsKKwl9CisKIAlyZXR1cm4gcmM7CiB9CiAKQEAgLTY5NCw3ICs3MDYsNiBAQAogewogCXUzMgkJCWNvbW1hbmQsIHRlbXAgPSAwOwogCXN0cnVjdCB1c2JfaGNkCQkqaGNkID0geGhjaV90b19oY2QoeGhjaSk7Ci0Jc3RydWN0IHBjaV9kZXYJCSpwZGV2ID0gdG9fcGNpX2RldihoY2QtPnNlbGYuY29udHJvbGxlcik7CiAJaW50CW9sZF9zdGF0ZSwgcmV0dmFsOwogCiAJb2xkX3N0YXRlID0gaGNkLT5zdGF0ZTsKQEAgLTcyOSw5ICs3NDAsOCBAQAogCQl4aGNpX2RiZyh4aGNpLCAiU3RvcCBIQ0RcbiIpOwogCQl4aGNpX2hhbHQoeGhjaSk7CiAJCXhoY2lfcmVzZXQoeGhjaSk7Ci0JCWlmIChoaWJlcm5hdGVkKQotCQkJeGhjaV9jbGVhbnVwX21zaXgoeGhjaSk7CiAJCXNwaW5fdW5sb2NrX2lycSgmeGhjaS0+bG9jayk7CisJCXhoY2lfY2xlYW51cF9tc2l4KHhoY2kpOwogCiAjaWZkZWYgQ09ORklHX1VTQl9YSENJX0hDRF9ERUJVR0dJTkcKIAkJLyogVGVsbCB0aGUgZXZlbnQgcmluZyBwb2xsIGZ1bmN0aW9uIG5vdCB0byByZXNjaGVkdWxlICovCkBAIC03NjUsMzAgKzc3NSw2IEBACiAJCXJldHVybiByZXR2YWw7CiAJfQogCi0Jc3Bpbl91bmxvY2tfaXJxKCZ4aGNpLT5sb2NrKTsKLQkvKiBSZS1zZXR1cCBNU0ktWCAqLwotCWlmIChoY2QtPmlycSkKLQkJZnJlZV9pcnEoaGNkLT5pcnEsIGhjZCk7Ci0JaGNkLT5pcnEgPSAtMTsKLQotCXJldHZhbCA9IHhoY2lfc2V0dXBfbXNpeCh4aGNpKTsKLQlpZiAocmV0dmFsKQotCQkvKiBmYWxsIGJhY2sgdG8gbXNpKi8KLQkJcmV0dmFsID0geGhjaV9zZXR1cF9tc2koeGhjaSk7Ci0KLQlpZiAocmV0dmFsKSB7Ci0JCS8qIGZhbGwgYmFjayB0byBsZWdhY3kgaW50ZXJydXB0Ki8KLQkJcmV0dmFsID0gcmVxdWVzdF9pcnEocGRldi0+aXJxLCAmdXNiX2hjZF9pcnEsIElSUUZfU0hBUkVELAotCQkJCQloY2QtPmlycV9kZXNjciwgaGNkKTsKLQkJaWYgKHJldHZhbCkgewotCQkJeGhjaV9lcnIoeGhjaSwgInJlcXVlc3QgaW50ZXJydXB0ICVkIGZhaWxlZFxuIiwKLQkJCQkJcGRldi0+aXJxKTsKLQkJCXJldHVybiByZXR2YWw7Ci0JCX0KLQkJaGNkLT5pcnEgPSBwZGV2LT5pcnE7Ci0JfQotCi0Jc3Bpbl9sb2NrX2lycSgmeGhjaS0+bG9jayk7CiAJLyogc3RlcCA0OiBzZXQgUnVuL1N0b3AgYml0ICovCiAJY29tbWFuZCA9IHhoY2lfcmVhZGwoeGhjaSwgJnhoY2ktPm9wX3JlZ3MtPmNvbW1hbmQpOwogCWNvbW1hbmQgfD0gQ01EX1JVTjsKQEAgLTI0NDUsOCArMjQzMSwxMiBAQAogCQl4aGNpX2Vycih4aGNpLCAiRXJyb3Igd2hpbGUgYXNzaWduaW5nIGRldmljZSBzbG90IElEXG4iKTsKIAkJcmV0dXJuIDA7CiAJfQotCS8qIHhoY2lfYWxsb2NfdmlydF9kZXZpY2UoKSBkb2VzIG5vdCB0b3VjaCByaW5nczsgbm8gbmVlZCB0byBsb2NrICovCi0JaWYgKCF4aGNpX2FsbG9jX3ZpcnRfZGV2aWNlKHhoY2ksIHhoY2ktPnNsb3RfaWQsIHVkZXYsIEdGUF9LRVJORUwpKSB7CisJLyogeGhjaV9hbGxvY192aXJ0X2RldmljZSgpIGRvZXMgbm90IHRvdWNoIHJpbmdzOyBubyBuZWVkIHRvIGxvY2suCisJICogVXNlIEdGUF9OT0lPLCBzaW5jZSB0aGlzIGZ1bmN0aW9uIGNhbiBiZSBjYWxsZWQgZnJvbQorCSAqIHhoY2lfZGlzY292ZXJfb3JfcmVzZXRfZGV2aWNlKCksIHdoaWNoIG1heSBiZSBjYWxsZWQgYXMgcGFydCBvZgorCSAqIG1hc3Mgc3RvcmFnZSBkcml2ZXIgZXJyb3IgaGFuZGxpbmcuCisJICovCisJaWYgKCF4aGNpX2FsbG9jX3ZpcnRfZGV2aWNlKHhoY2ksIHhoY2ktPnNsb3RfaWQsIHVkZXYsIEdGUF9OT0lPKSkgewogCQkvKiBEaXNhYmxlIHNsb3QsIGlmIHdlIGNhbiBkbyBpdCB3aXRob3V0IG1lbSBhbGxvYyAqLwogCQl4aGNpX3dhcm4oeGhjaSwgIkNvdWxkIG5vdCBhbGxvY2F0ZSB4SENJIFVTQiBkZXZpY2UgZGF0YSBzdHJ1Y3R1cmVzXG4iKTsKIAkJc3Bpbl9sb2NrX2lycXNhdmUoJnhoY2ktPmxvY2ssIGZsYWdzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2hvc3QveGhjaS5oIGIvZHJpdmVycy91c2IvaG9zdC94aGNpLmgKaW5kZXggMTcwYzM2Ny4uN2YyMzZmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvaG9zdC94aGNpLmgKKysrIGIvZHJpdmVycy91c2IvaG9zdC94aGNpLmgKQEAgLTQzNiwyMiArNDM2LDE4IEBACiAvKioKICAqIHN0cnVjdCBkb29yYmVsbF9hcnJheQogICoKKyAqIEJpdHMgIDAgLSAgNzogRW5kcG9pbnQgdGFyZ2V0CisgKiBCaXRzICA4IC0gMTU6IFJzdmRaCisgKiBCaXRzIDE2IC0gMzE6IFN0cmVhbSBJRAorICoKICAqIFNlY3Rpb24gNS42CiAgKi8KIHN0cnVjdCB4aGNpX2Rvb3JiZWxsX2FycmF5IHsKIAl1MzIJZG9vcmJlbGxbMjU2XTsKIH07CiAKLSNkZWZpbmUJREJfVEFSR0VUX01BU0sJCTB4RkZGRkZGMDAKLSNkZWZpbmUJREJfU1RSRUFNX0lEX01BU0sJMHgwMDAwRkZGRgotI2RlZmluZQlEQl9UQVJHRVRfSE9TVAkJMHgwCi0jZGVmaW5lCURCX1NUUkVBTV9JRF9IT1NUCTB4MAotI2RlZmluZQlEQl9NQVNLCQkJKDB4ZmYgPDwgOCkKLQotLyogRW5kcG9pbnQgVGFyZ2V0IC0gYml0cyAwOjcgKi8KLSNkZWZpbmUgRVBJX1RPX0RCKHApCQkoKChwKSArIDEpICYgMHhmZikKLSNkZWZpbmUgU1RSRUFNX0lEX1RPX0RCKHApCSgoKHApICYgMHhmZmZmKSA8PCAxNikKLQorI2RlZmluZSBEQl9WQUxVRShlcCwgc3RyZWFtKQkoKCgoZXApICsgMSkgJiAweGZmKSB8ICgoc3RyZWFtKSA8PCAxNikpCisjZGVmaW5lIERCX1ZBTFVFX0hPU1QJCTB4MDAwMDAwMDAKIAogLyoqCiAgKiBzdHJ1Y3QgeGhjaV9wcm90b2NvbF9jYXBzCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9taXNjL3VzYmxlZC5jIGIvZHJpdmVycy91c2IvbWlzYy91c2JsZWQuYwppbmRleCAxNzMyZDliLi4xNjE2YWQxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9taXNjL3VzYmxlZC5jCisrKyBiL2RyaXZlcnMvdXNiL21pc2MvdXNibGVkLmMKQEAgLTQ1LDcgKzQ1LDcgQEAKIAogc3RhdGljIHZvaWQgY2hhbmdlX2NvbG9yKHN0cnVjdCB1c2JfbGVkICpsZWQpCiB7Ci0JaW50IHJldHZhbDsKKwlpbnQgcmV0dmFsID0gMDsKIAl1bnNpZ25lZCBjaGFyICpidWZmZXI7CiAKIAlidWZmZXIgPSBrbWFsbG9jKDgsIEdGUF9LRVJORUwpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvbWlzYy91c3M3MjAuYyBiL2RyaXZlcnMvdXNiL21pc2MvdXNzNzIwLmMKaW5kZXggNGZmMjE1OC4uZjdhMjA1NyAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvbWlzYy91c3M3MjAuYworKysgYi9kcml2ZXJzL3VzYi9taXNjL3VzczcyMC5jCkBAIC03NzYsNyArNzc2LDYgQEAKIAl7IFVTQl9ERVZJQ0UoMHgwNTU3LCAweDIwMDEpIH0sCiAJeyBVU0JfREVWSUNFKDB4MDcyOSwgMHgxMjg0KSB9LAogCXsgVVNCX0RFVklDRSgweDEyOTMsIDB4MDAwMikgfSwKLQl7IFVTQl9ERVZJQ0UoMHgxMjkzLCAweDAwMDIpIH0sCiAJeyBVU0JfREVWSUNFKDB4MDUwZCwgMHgwMDAyKSB9LAogCXsgfQkJCQkJCS8qIFRlcm1pbmF0aW5nIGVudHJ5ICovCiB9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvbXVzYi9ibGFja2Zpbi5jIGIvZHJpdmVycy91c2IvbXVzYi9ibGFja2Zpbi5jCmluZGV4IGVlYmEyMjguLjlkNDlkMWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL211c2IvYmxhY2tmaW4uYworKysgYi9kcml2ZXJzL3VzYi9tdXNiL2JsYWNrZmluLmMKQEAgLTQwNCw2ICs0MDQsNyBAQAogCQltdXNiLT54Y2Vpdi0+c2V0X3Bvd2VyID0gYmZpbl9tdXNiX3NldF9wb3dlcjsKIAogCW11c2ItPmlzciA9IGJsYWNrZmluX2ludGVycnVwdDsKKwltdXNiLT5kb3VibGVfYnVmZmVyX25vdF9vayA9IHRydWU7CiAKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL211c2IvbXVzYl9jb3JlLmMgYi9kcml2ZXJzL3VzYi9tdXNiL211c2JfY29yZS5jCmluZGV4IDA3Y2YzOTQuLjU0YThiZDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL211c2IvbXVzYl9jb3JlLmMKKysrIGIvZHJpdmVycy91c2IvbXVzYi9tdXNiX2NvcmUuYwpAQCAtMTI4LDEyICsxMjgsNyBAQAogCiBzdGF0aWMgaW5saW5lIHN0cnVjdCBtdXNiICpkZXZfdG9fbXVzYihzdHJ1Y3QgZGV2aWNlICpkZXYpCiB7Ci0jaWZkZWYgQ09ORklHX1VTQl9NVVNCX0hEUkNfSENECi0JLyogdXNiY29yZSBpbnNpc3RzIGRldi0+ZHJpdmVyX2RhdGEgaXMgYSAic3RydWN0IGhjZCAqIiAqLwotCXJldHVybiBoY2RfdG9fbXVzYihkZXZfZ2V0X2RydmRhdGEoZGV2KSk7Ci0jZWxzZQogCXJldHVybiBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKLSNlbmRpZgogfQogCiAvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpAQCAtMTg3NiwxMCArMTg3MSw5IEBACiAJbXVzYiA9IGt6YWxsb2Moc2l6ZW9mICptdXNiLCBHRlBfS0VSTkVMKTsKIAlpZiAoIW11c2IpCiAJCXJldHVybiBOVUxMOwotCWRldl9zZXRfZHJ2ZGF0YShkZXYsIG11c2IpOwogCiAjZW5kaWYKLQorCWRldl9zZXRfZHJ2ZGF0YShkZXYsIG11c2IpOwogCW11c2ItPm1yZWdzID0gbWJhc2U7CiAJbXVzYi0+Y3RybF9iYXNlID0gbWJhc2U7CiAJbXVzYi0+bklycSA9IC1FTk9ERVY7CkBAIC0yMTkxLDcgKzIxODUsNyBAQAogCXZvaWQgX19pb21lbQkqYmFzZTsKIAogCWlvbWVtID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsKLQlpZiAoIWlvbWVtIHx8IGlycSA9PSAwKQorCWlmICghaW9tZW0gfHwgaXJxIDw9IDApCiAJCXJldHVybiAtRU5PREVWOwogCiAJYmFzZSA9IGlvcmVtYXAoaW9tZW0tPnN0YXJ0LCByZXNvdXJjZV9zaXplKGlvbWVtKSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9tdXNiL211c2JfY29yZS5oIGIvZHJpdmVycy91c2IvbXVzYi9tdXNiX2NvcmUuaAppbmRleCBkMGMyMzZmLi5kNzRhODExIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9tdXNiL211c2JfY29yZS5oCisrKyBiL2RyaXZlcnMvdXNiL211c2IvbXVzYl9jb3JlLmgKQEAgLTQ4OCw2ICs0ODgsMTggQEAKIAl1bnNpZ25lZAkJc2V0X2FkZHJlc3M6MTsKIAl1bnNpZ25lZAkJdGVzdF9tb2RlOjE7CiAJdW5zaWduZWQJCXNvZnRjb25uZWN0OjE7CisJLyoKKwkgKiBGSVhNRTogUmVtb3ZlIHRoaXMgZmxhZy4KKwkgKgorCSAqIFRoaXMgaXMgb25seSBhZGRlZCB0byBhbGxvdyBCbGFja2ZpbiB0byB3b3JrCisJICogd2l0aCBjdXJyZW50IGRyaXZlci4gRm9yIHNvbWUgdW5rbm93biByZWFzb24KKwkgKiBCbGFja2ZpbiBkb2Vzbid0IHdvcmsgd2l0aCBkb3VibGUgYnVmZmVyaW5nCisJICogYW5kIHRoYXQncyBlbmFibGVkIGJ5IGRlZmF1bHQuCisJICoKKwkgKiBXZSBhZGRlZCB0aGlzIGZsYWcgdG8gZm9yY2VmdWxseSBkaXNhYmxlIGRvdWJsZQorCSAqIGJ1ZmZlcmluZyB1bnRpbCB3ZSBnZXQgaXQgd29ya2luZy4KKwkgKi8KKwl1bnNpZ25lZCAgICAgICAgICAgICAgICBkb3VibGVfYnVmZmVyX25vdF9vazoxIF9fZGVwcmVjYXRlZDsKIAogCXU4CQkJYWRkcmVzczsKIAl1OAkJCXRlc3RfbW9kZV9ucjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL211c2IvbXVzYl9kbWEuaCBiL2RyaXZlcnMvdXNiL211c2IvbXVzYl9kbWEuaAppbmRleCA5MTYwNjViLi4zYTk3YzRlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9tdXNiL211c2JfZG1hLmgKKysrIGIvZHJpdmVycy91c2IvbXVzYi9tdXNiX2RtYS5oCkBAIC0xNjksNiArMTY5LDkgQEAKIAkJCQkJCQlkbWFfYWRkcl90IGRtYV9hZGRyLAogCQkJCQkJCXUzMiBsZW5ndGgpOwogCWludAkJCSgqY2hhbm5lbF9hYm9ydCkoc3RydWN0IGRtYV9jaGFubmVsICopOworCWludAkJCSgqaXNfY29tcGF0aWJsZSkoc3RydWN0IGRtYV9jaGFubmVsICpjaGFubmVsLAorCQkJCQkJCXUxNiBtYXhwYWNrZXQsCisJCQkJCQkJdm9pZCAqYnVmLCB1MzIgbGVuZ3RoKTsKIH07CiAKIC8qIGNhbGxlZCBhZnRlciBjaGFubmVsX3Byb2dyYW0oKSwgbWF5IGluZGljYXRlIGEgZmF1bHQgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL211c2IvbXVzYl9nYWRnZXQuYyBiL2RyaXZlcnMvdXNiL211c2IvbXVzYl9nYWRnZXQuYwppbmRleCBlZDU4YzZjLi4yZmUzMDQ2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9tdXNiL211c2JfZ2FkZ2V0LmMKKysrIGIvZHJpdmVycy91c2IvbXVzYi9tdXNiX2dhZGdldC5jCkBAIC05MiwxMSArOTIsMzMgQEAKIAogLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KIAorI2RlZmluZSBpc19idWZmZXJfbWFwcGVkKHJlcSkgKGlzX2RtYV9jYXBhYmxlKCkgJiYgXAorCQkJCQkocmVxLT5tYXBfc3RhdGUgIT0gVU5fTUFQUEVEKSkKKwogLyogTWFwcyB0aGUgYnVmZmVyIHRvIGRtYSAgKi8KIAogc3RhdGljIGlubGluZSB2b2lkIG1hcF9kbWFfYnVmZmVyKHN0cnVjdCBtdXNiX3JlcXVlc3QgKnJlcXVlc3QsCi0JCQkJc3RydWN0IG11c2IgKm11c2IpCisJCQlzdHJ1Y3QgbXVzYiAqbXVzYiwgc3RydWN0IG11c2JfZXAgKm11c2JfZXApCiB7CisJaW50IGNvbXBhdGlibGUgPSB0cnVlOworCXN0cnVjdCBkbWFfY29udHJvbGxlciAqZG1hID0gbXVzYi0+ZG1hX2NvbnRyb2xsZXI7CisKKwlyZXF1ZXN0LT5tYXBfc3RhdGUgPSBVTl9NQVBQRUQ7CisKKwlpZiAoIWlzX2RtYV9jYXBhYmxlKCkgfHwgIW11c2JfZXAtPmRtYSkKKwkJcmV0dXJuOworCisJLyogQ2hlY2sgaWYgRE1BIGVuZ2luZSBjYW4gaGFuZGxlIHRoaXMgcmVxdWVzdC4KKwkgKiBETUEgY29kZSBtdXN0IHJlamVjdCB0aGUgVVNCIHJlcXVlc3QgZXhwbGljaXRseS4KKwkgKiBEZWZhdWx0IGJlaGF2aW91ciBpcyB0byBtYXAgdGhlIHJlcXVlc3QuCisJICovCisJaWYgKGRtYS0+aXNfY29tcGF0aWJsZSkKKwkJY29tcGF0aWJsZSA9IGRtYS0+aXNfY29tcGF0aWJsZShtdXNiX2VwLT5kbWEsCisJCQkJbXVzYl9lcC0+cGFja2V0X3N6LCByZXF1ZXN0LT5yZXF1ZXN0LmJ1ZiwKKwkJCQlyZXF1ZXN0LT5yZXF1ZXN0Lmxlbmd0aCk7CisJaWYgKCFjb21wYXRpYmxlKQorCQlyZXR1cm47CisKIAlpZiAocmVxdWVzdC0+cmVxdWVzdC5kbWEgPT0gRE1BX0FERFJfSU5WQUxJRCkgewogCQlyZXF1ZXN0LT5yZXF1ZXN0LmRtYSA9IGRtYV9tYXBfc2luZ2xlKAogCQkJCW11c2ItPmNvbnRyb2xsZXIsCkBAIC0xMDUsNyArMTI3LDcgQEAKIAkJCQlyZXF1ZXN0LT50eAogCQkJCQk/IERNQV9UT19ERVZJQ0UKIAkJCQkJOiBETUFfRlJPTV9ERVZJQ0UpOwotCQlyZXF1ZXN0LT5tYXBwZWQgPSAxOworCQlyZXF1ZXN0LT5tYXBfc3RhdGUgPSBNVVNCX01BUFBFRDsKIAl9IGVsc2UgewogCQlkbWFfc3luY19zaW5nbGVfZm9yX2RldmljZShtdXNiLT5jb250cm9sbGVyLAogCQkJcmVxdWVzdC0+cmVxdWVzdC5kbWEsCkBAIC0xMTMsNyArMTM1LDcgQEAKIAkJCXJlcXVlc3QtPnR4CiAJCQkJPyBETUFfVE9fREVWSUNFCiAJCQkJOiBETUFfRlJPTV9ERVZJQ0UpOwotCQlyZXF1ZXN0LT5tYXBwZWQgPSAwOworCQlyZXF1ZXN0LT5tYXBfc3RhdGUgPSBQUkVfTUFQUEVEOwogCX0KIH0KIApAQCAtMTIxLDExICsxNDMsMTQgQEAKIHN0YXRpYyBpbmxpbmUgdm9pZCB1bm1hcF9kbWFfYnVmZmVyKHN0cnVjdCBtdXNiX3JlcXVlc3QgKnJlcXVlc3QsCiAJCQkJc3RydWN0IG11c2IgKm11c2IpCiB7CisJaWYgKCFpc19idWZmZXJfbWFwcGVkKHJlcXVlc3QpKQorCQlyZXR1cm47CisKIAlpZiAocmVxdWVzdC0+cmVxdWVzdC5kbWEgPT0gRE1BX0FERFJfSU5WQUxJRCkgewogCQlEQkcoMjAsICJub3QgdW5tYXBwaW5nIGEgbmV2ZXIgbWFwcGVkIGJ1ZmZlclxuIik7CiAJCXJldHVybjsKIAl9Ci0JaWYgKHJlcXVlc3QtPm1hcHBlZCkgeworCWlmIChyZXF1ZXN0LT5tYXBfc3RhdGUgPT0gTVVTQl9NQVBQRUQpIHsKIAkJZG1hX3VubWFwX3NpbmdsZShtdXNiLT5jb250cm9sbGVyLAogCQkJcmVxdWVzdC0+cmVxdWVzdC5kbWEsCiAJCQlyZXF1ZXN0LT5yZXF1ZXN0Lmxlbmd0aCwKQEAgLTEzMywxNiArMTU4LDE1IEBACiAJCQkJPyBETUFfVE9fREVWSUNFCiAJCQkJOiBETUFfRlJPTV9ERVZJQ0UpOwogCQlyZXF1ZXN0LT5yZXF1ZXN0LmRtYSA9IERNQV9BRERSX0lOVkFMSUQ7Ci0JCXJlcXVlc3QtPm1hcHBlZCA9IDA7Ci0JfSBlbHNlIHsKKwl9IGVsc2UgeyAvKiBQUkVfTUFQUEVEICovCiAJCWRtYV9zeW5jX3NpbmdsZV9mb3JfY3B1KG11c2ItPmNvbnRyb2xsZXIsCiAJCQlyZXF1ZXN0LT5yZXF1ZXN0LmRtYSwKIAkJCXJlcXVlc3QtPnJlcXVlc3QubGVuZ3RoLAogCQkJcmVxdWVzdC0+dHgKIAkJCQk/IERNQV9UT19ERVZJQ0UKIAkJCQk6IERNQV9GUk9NX0RFVklDRSk7Ci0KIAl9CisJcmVxdWVzdC0+bWFwX3N0YXRlID0gVU5fTUFQUEVEOwogfQogCiAvKgpAQCAtMTcyLDggKzE5Niw3IEBACiAKIAllcC0+YnVzeSA9IDE7CiAJc3Bpbl91bmxvY2soJm11c2ItPmxvY2spOwotCWlmIChpc19kbWFfY2FwYWJsZSgpICYmIGVwLT5kbWEpCi0JCXVubWFwX2RtYV9idWZmZXIocmVxLCBtdXNiKTsKKwl1bm1hcF9kbWFfYnVmZmVyKHJlcSwgbXVzYik7CiAJaWYgKHJlcXVlc3QtPnN0YXR1cyA9PSAwKQogCQlEQkcoNSwgIiVzIGRvbmUgcmVxdWVzdCAlcCwgICVkLyVkXG4iLAogCQkJCWVwLT5lbmRfcG9pbnQubmFtZSwgcmVxdWVzdCwKQEAgLTMzNSw3ICszNTgsNyBAQAogCQkJY3NyKTsKIAogI2lmbmRlZglDT05GSUdfTVVTQl9QSU9fT05MWQotCWlmIChpc19kbWFfY2FwYWJsZSgpICYmIG11c2JfZXAtPmRtYSkgeworCWlmIChpc19idWZmZXJfbWFwcGVkKHJlcSkpIHsKIAkJc3RydWN0IGRtYV9jb250cm9sbGVyCSpjID0gbXVzYi0+ZG1hX2NvbnRyb2xsZXI7CiAJCXNpemVfdCByZXF1ZXN0X3NpemU7CiAKQEAgLTQzNiw4ICs0NTksNyBAQAogCQkgKiBVbm1hcCB0aGUgZG1hIGJ1ZmZlciBiYWNrIHRvIGNwdSBpZiBkbWEgY2hhbm5lbAogCQkgKiBwcm9ncmFtbWluZyBmYWlscwogCQkgKi8KLQkJaWYgKGlzX2RtYV9jYXBhYmxlKCkgJiYgbXVzYl9lcC0+ZG1hKQotCQkJdW5tYXBfZG1hX2J1ZmZlcihyZXEsIG11c2IpOworCQl1bm1hcF9kbWFfYnVmZmVyKHJlcSwgbXVzYik7CiAKIAkJbXVzYl93cml0ZV9maWZvKG11c2JfZXAtPmh3X2VwLCBmaWZvX2NvdW50LAogCQkJCSh1OCAqKSAocmVxdWVzdC0+YnVmICsgcmVxdWVzdC0+YWN0dWFsKSk7CkBAIC02MjcsNyArNjQ5LDcgQEAKIAkJcmV0dXJuOwogCX0KIAotCWlmIChpc19jcHBpX2VuYWJsZWQoKSAmJiBtdXNiX2VwLT5kbWEpIHsKKwlpZiAoaXNfY3BwaV9lbmFibGVkKCkgJiYgaXNfYnVmZmVyX21hcHBlZChyZXEpKSB7CiAJCXN0cnVjdCBkbWFfY29udHJvbGxlcgkqYyA9IG11c2ItPmRtYV9jb250cm9sbGVyOwogCQlzdHJ1Y3QgZG1hX2NoYW5uZWwJKmNoYW5uZWwgPSBtdXNiX2VwLT5kbWE7CiAKQEAgLTY1OCw3ICs2ODAsNyBAQAogCQlsZW4gPSBtdXNiX3JlYWR3KGVwaW8sIE1VU0JfUlhDT1VOVCk7CiAJCWlmIChyZXF1ZXN0LT5hY3R1YWwgPCByZXF1ZXN0LT5sZW5ndGgpIHsKICNpZmRlZiBDT05GSUdfVVNCX0lOVkVOVFJBX0RNQQotCQkJaWYgKGlzX2RtYV9jYXBhYmxlKCkgJiYgbXVzYl9lcC0+ZG1hKSB7CisJCQlpZiAoaXNfYnVmZmVyX21hcHBlZChyZXEpKSB7CiAJCQkJc3RydWN0IGRtYV9jb250cm9sbGVyCSpjOwogCQkJCXN0cnVjdCBkbWFfY2hhbm5lbAkqY2hhbm5lbDsKIAkJCQlpbnQJCQl1c2VfZG1hID0gMDsKQEAgLTc0Miw3ICs3NjQsNyBAQAogCQkJZmlmb19jb3VudCA9IG1pbl90KHVuc2lnbmVkLCBsZW4sIGZpZm9fY291bnQpOwogCiAjaWZkZWYJQ09ORklHX1VTQl9UVVNCX09NQVBfRE1BCi0JCQlpZiAodHVzYl9kbWFfb21hcCgpICYmIG11c2JfZXAtPmRtYSkgeworCQkJaWYgKHR1c2JfZG1hX29tYXAoKSAmJiBpc19idWZmZXJfbWFwcGVkKHJlcSkpIHsKIAkJCQlzdHJ1Y3QgZG1hX2NvbnRyb2xsZXIgKmMgPSBtdXNiLT5kbWFfY29udHJvbGxlcjsKIAkJCQlzdHJ1Y3QgZG1hX2NoYW5uZWwgKmNoYW5uZWwgPSBtdXNiX2VwLT5kbWE7CiAJCQkJdTMyIGRtYV9hZGRyID0gcmVxdWVzdC0+ZG1hICsgcmVxdWVzdC0+YWN0dWFsOwpAQCAtNzYyLDcgKzc4NCw3IEBACiAJCQkgKiBwcm9ncmFtbWluZyBmYWlscy4gVGhpcyBidWZmZXIgaXMgbWFwcGVkIGlmIHRoZQogCQkJICogY2hhbm5lbCBhbGxvY2F0aW9uIGlzIHN1Y2Nlc3NmdWwKIAkJCSAqLwotCQkJIGlmIChpc19kbWFfY2FwYWJsZSgpICYmIG11c2JfZXAtPmRtYSkgeworCQkJIGlmIChpc19idWZmZXJfbWFwcGVkKHJlcSkpIHsKIAkJCQl1bm1hcF9kbWFfYnVmZmVyKHJlcSwgbXVzYik7CiAKIAkJCQkvKgpAQCAtOTg5LDcgKzEwMTEsMTEgQEAKIAkJLyogU2V0IFRYTUFYUCB3aXRoIHRoZSBGSUZPIHNpemUgb2YgdGhlIGVuZHBvaW50CiAJCSAqIHRvIGRpc2FibGUgZG91YmxlIGJ1ZmZlcmluZyBtb2RlLgogCQkgKi8KLQkJbXVzYl93cml0ZXcocmVncywgTVVTQl9UWE1BWFAsIG11c2JfZXAtPnBhY2tldF9zeiB8IChtdXNiX2VwLT5oYl9tdWx0IDw8IDExKSk7CisJCWlmIChtdXNiLT5kb3VibGVfYnVmZmVyX25vdF9vaykKKwkJCW11c2Jfd3JpdGV3KHJlZ3MsIE1VU0JfVFhNQVhQLCBod19lcC0+bWF4X3BhY2tldF9zel90eCk7CisJCWVsc2UKKwkJCW11c2Jfd3JpdGV3KHJlZ3MsIE1VU0JfVFhNQVhQLCBtdXNiX2VwLT5wYWNrZXRfc3oKKwkJCQkJfCAobXVzYl9lcC0+aGJfbXVsdCA8PCAxMSkpOwogCiAJCWNzciA9IE1VU0JfVFhDU1JfTU9ERSB8IE1VU0JfVFhDU1JfQ0xSREFUQVRPRzsKIAkJaWYgKG11c2JfcmVhZHcocmVncywgTVVTQl9UWENTUikKQEAgLTEwMjUsNyArMTA1MSwxMSBAQAogCQkvKiBTZXQgUlhNQVhQIHdpdGggdGhlIEZJRk8gc2l6ZSBvZiB0aGUgZW5kcG9pbnQKIAkJICogdG8gZGlzYWJsZSBkb3VibGUgYnVmZmVyaW5nIG1vZGUuCiAJCSAqLwotCQltdXNiX3dyaXRldyhyZWdzLCBNVVNCX1JYTUFYUCwgbXVzYl9lcC0+cGFja2V0X3N6IHwgKG11c2JfZXAtPmhiX211bHQgPDwgMTEpKTsKKwkJaWYgKG11c2ItPmRvdWJsZV9idWZmZXJfbm90X29rKQorCQkJbXVzYl93cml0ZXcocmVncywgTVVTQl9SWE1BWFAsIGh3X2VwLT5tYXhfcGFja2V0X3N6X3R4KTsKKwkJZWxzZQorCQkJbXVzYl93cml0ZXcocmVncywgTVVTQl9SWE1BWFAsIG11c2JfZXAtPnBhY2tldF9zegorCQkJCQl8IChtdXNiX2VwLT5oYl9tdWx0IDw8IDExKSk7CiAKIAkJLyogZm9yY2Ugc2hhcmVkIGZpZm8gdG8gT1VULW9ubHkgbW9kZSAqLwogCQlpZiAoaHdfZXAtPmlzX3NoYXJlZF9maWZvKSB7CkBAIC0xMjE0LDEwICsxMjQ0LDcgQEAKIAlyZXF1ZXN0LT5lcG51bSA9IG11c2JfZXAtPmN1cnJlbnRfZXBudW07CiAJcmVxdWVzdC0+dHggPSBtdXNiX2VwLT5pc19pbjsKIAotCWlmIChpc19kbWFfY2FwYWJsZSgpICYmIG11c2JfZXAtPmRtYSkKLQkJbWFwX2RtYV9idWZmZXIocmVxdWVzdCwgbXVzYik7Ci0JZWxzZQotCQlyZXF1ZXN0LT5tYXBwZWQgPSAwOworCW1hcF9kbWFfYnVmZmVyKHJlcXVlc3QsIG11c2IsIG11c2JfZXApOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJm11c2ItPmxvY2ssIGxvY2tmbGFncyk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL211c2IvbXVzYl9nYWRnZXQuaCBiL2RyaXZlcnMvdXNiL211c2IvbXVzYl9nYWRnZXQuaAppbmRleCBkZWM4ZGMwLi5hNTUzNTRmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9tdXNiL211c2JfZ2FkZ2V0LmgKKysrIGIvZHJpdmVycy91c2IvbXVzYi9tdXNiX2dhZGdldC5oCkBAIC0zNSwxMyArMzUsMTkgQEAKICNpZm5kZWYgX19NVVNCX0dBREdFVF9ICiAjZGVmaW5lIF9fTVVTQl9HQURHRVRfSAogCitlbnVtIGJ1ZmZlcl9tYXBfc3RhdGUgeworCVVOX01BUFBFRCA9IDAsCisJUFJFX01BUFBFRCwKKwlNVVNCX01BUFBFRAorfTsKKwogc3RydWN0IG11c2JfcmVxdWVzdCB7CiAJc3RydWN0IHVzYl9yZXF1ZXN0CXJlcXVlc3Q7CiAJc3RydWN0IG11c2JfZXAJCSplcDsKIAlzdHJ1Y3QgbXVzYgkJKm11c2I7CiAJdTggdHg7CQkJLyogZW5kcG9pbnQgZGlyZWN0aW9uICovCiAJdTggZXBudW07Ci0JdTggbWFwcGVkOworCWVudW0gYnVmZmVyX21hcF9zdGF0ZSBtYXBfc3RhdGU7CiB9OwogCiBzdGF0aWMgaW5saW5lIHN0cnVjdCBtdXNiX3JlcXVlc3QgKnRvX211c2JfcmVxdWVzdChzdHJ1Y3QgdXNiX3JlcXVlc3QgKnJlcSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL211c2IvbXVzYl9ob3N0LmMgYi9kcml2ZXJzL3VzYi9tdXNiL211c2JfaG9zdC5jCmluZGV4IDRkNWJjYjQuLjBmNTIzZDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL211c2IvbXVzYl9ob3N0LmMKKysrIGIvZHJpdmVycy91c2IvbXVzYi9tdXNiX2hvc3QuYwpAQCAtNjA5LDcgKzYwOSw3IEBACiAJLyogU2V0IFJYTUFYUCB3aXRoIHRoZSBGSUZPIHNpemUgb2YgdGhlIGVuZHBvaW50CiAJICogdG8gZGlzYWJsZSBkb3VibGUgYnVmZmVyIG1vZGUuCiAJICovCi0JaWYgKG11c2ItPmh3dmVycyA8IE1VU0JfSFdWRVJTXzIwMDApCisJaWYgKG11c2ItPmRvdWJsZV9idWZmZXJfbm90X29rKQogCQltdXNiX3dyaXRldyhlcC0+cmVncywgTVVTQl9SWE1BWFAsIGVwLT5tYXhfcGFja2V0X3N6X3J4KTsKIAllbHNlCiAJCW11c2Jfd3JpdGV3KGVwLT5yZWdzLCBNVVNCX1JYTUFYUCwKQEAgLTc4NCwxNCArNzg0LDEzIEBACiAJCS8qIHByb3RvY29sL2VuZHBvaW50L2ludGVydmFsL05BS2xpbWl0ICovCiAJCWlmIChlcG51bSkgewogCQkJbXVzYl93cml0ZWIoZXBpbywgTVVTQl9UWFRZUEUsIHFoLT50eXBlX3JlZyk7Ci0JCQlpZiAoY2FuX2J1bGtfc3BsaXQobXVzYiwgcWgtPnR5cGUpKQorCQkJaWYgKG11c2ItPmRvdWJsZV9idWZmZXJfbm90X29rKQogCQkJCW11c2Jfd3JpdGV3KGVwaW8sIE1VU0JfVFhNQVhQLAotCQkJCQlwYWNrZXRfc3oKLQkJCQkJfCAoKGh3X2VwLT5tYXhfcGFja2V0X3N6X3R4IC8KLQkJCQkJCXBhY2tldF9zeikgLSAxKSA8PCAxMSk7CisJCQkJCQlod19lcC0+bWF4X3BhY2tldF9zel90eCk7CiAJCQllbHNlCiAJCQkJbXVzYl93cml0ZXcoZXBpbywgTVVTQl9UWE1BWFAsCi0JCQkJCXBhY2tldF9zeik7CisJCQkJCQlxaC0+bWF4cGFja2V0IHwKKwkJCQkJCSgocWgtPmhiX211bHQgLSAxKSA8PCAxMSkpOwogCQkJbXVzYl93cml0ZWIoZXBpbywgTVVTQl9UWElOVEVSVkFMLCBxaC0+aW50dl9yZWcpOwogCQl9IGVsc2UgewogCQkJbXVzYl93cml0ZWIoZXBpbywgTVVTQl9OQUtMSU1JVDAsIHFoLT5pbnR2X3JlZyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9tdXNiL211c2Joc2RtYS5oIGIvZHJpdmVycy91c2IvbXVzYi9tdXNiaHNkbWEuaAppbmRleCBmNzYzZDYyLi4yMTA1NmM5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9tdXNiL211c2Joc2RtYS5oCisrKyBiL2RyaXZlcnMvdXNiL211c2IvbXVzYmhzZG1hLmgKQEAgLTk0LDI0ICs5NCwzMyBAQAogewogCW11c2Jfd3JpdGV3KG1iYXNlLAogCQlNVVNCX0hTRE1BX0NIQU5ORUxfT0ZGU0VUKGJjaGFubmVsLCBNVVNCX0hTRE1BX0FERFJfTE9XKSwKLQkJKCh1MTYpKCh1MzIpIGRtYV9hZGRyICYgMHhGRkZGKSkpOworCQlkbWFfYWRkcik7CiAJbXVzYl93cml0ZXcobWJhc2UsCiAJCU1VU0JfSFNETUFfQ0hBTk5FTF9PRkZTRVQoYmNoYW5uZWwsIE1VU0JfSFNETUFfQUREUl9ISUdIKSwKLQkJKCh1MTYpKCgodTMyKSBkbWFfYWRkciA+PiAxNikgJiAweEZGRkYpKSk7CisJCShkbWFfYWRkciA+PiAxNikpOwogfQogCiBzdGF0aWMgaW5saW5lIHUzMiBtdXNiX3JlYWRfaHNkbWFfY291bnQodm9pZCBfX2lvbWVtICptYmFzZSwgdTggYmNoYW5uZWwpCiB7Ci0JcmV0dXJuIG11c2JfcmVhZGwobWJhc2UsCisJdTMyIGNvdW50ID0gbXVzYl9yZWFkdyhtYmFzZSwKIAkJTVVTQl9IU0RNQV9DSEFOTkVMX09GRlNFVChiY2hhbm5lbCwgTVVTQl9IU0RNQV9DT1VOVF9ISUdIKSk7CisKKwljb3VudCA9IGNvdW50IDw8IDE2OworCisJY291bnQgfD0gbXVzYl9yZWFkdyhtYmFzZSwKKwkJTVVTQl9IU0RNQV9DSEFOTkVMX09GRlNFVChiY2hhbm5lbCwgTVVTQl9IU0RNQV9DT1VOVF9MT1cpKTsKKworCXJldHVybiBjb3VudDsKIH0KIAogc3RhdGljIGlubGluZSB2b2lkIG11c2Jfd3JpdGVfaHNkbWFfY291bnQodm9pZCBfX2lvbWVtICptYmFzZSwKIAkJCQl1OCBiY2hhbm5lbCwgdTMyIGxlbikKIHsKLQltdXNiX3dyaXRlbChtYmFzZSwKKwltdXNiX3dyaXRldyhtYmFzZSwKKwkJTVVTQl9IU0RNQV9DSEFOTkVMX09GRlNFVChiY2hhbm5lbCwgTVVTQl9IU0RNQV9DT1VOVF9MT1cpLGxlbik7CisJbXVzYl93cml0ZXcobWJhc2UsCiAJCU1VU0JfSFNETUFfQ0hBTk5FTF9PRkZTRVQoYmNoYW5uZWwsIE1VU0JfSFNETUFfQ09VTlRfSElHSCksCi0JCWxlbik7CisJCShsZW4gPj4gMTYpKTsKIH0KIAogI2VuZGlmIC8qIENPTkZJR19CTEFDS0ZJTiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivb3RnL0tjb25maWcgYi9kcml2ZXJzL3VzYi9vdGcvS2NvbmZpZwppbmRleCA5ZmI4NzVkLi45ZmZjODIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9vdGcvS2NvbmZpZworKysgYi9kcml2ZXJzL3VzYi9vdGcvS2NvbmZpZwpAQCAtMTAzLDYgKzEwMyw4IEBACiAJICByZXF1aXJlZCBhZnRlciByZXNldHRpbmcgdGhlIGhhcmR3YXJlIGFuZCBwb3dlciBtYW5hZ2VtZW50LgogCSAgVGhpcyBkcml2ZXIgaXMgcmVxdWlyZWQgZXZlbiBmb3IgcGVyaXBoZXJhbCBvbmx5IG9yIGhvc3Qgb25seQogCSAgbW9kZSBjb25maWd1cmF0aW9ucy4KKwkgIFRoaXMgZHJpdmVyIGlzIG5vdCBzdXBwb3J0ZWQgb24gYm9hcmRzIGxpa2UgdHJvdXQgd2hpY2gKKwkgIGhhcyBhbiBleHRlcm5hbCBQSFkuCiAKIGNvbmZpZyBBQjg1MDBfVVNCCiAgICAgICAgIHRyaXN0YXRlICJBQjg1MDAgVVNCIFRyYW5zY2VpdmVyIERyaXZlciIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL290Zy9ub3AtdXNiLXhjZWl2LmMgYi9kcml2ZXJzL3VzYi9vdGcvbm9wLXVzYi14Y2Vpdi5jCmluZGV4IGU3MDAxNGEuLjhhY2YxNjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL290Zy9ub3AtdXNiLXhjZWl2LmMKKysrIGIvZHJpdmVycy91c2Ivb3RnL25vcC11c2IteGNlaXYuYwpAQCAtMTMyLDYgKzEzMiw4IEBACiAKIAlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBub3ApOwogCisJQkxPQ0tJTkdfSU5JVF9OT1RJRklFUl9IRUFEKCZub3AtPm90Zy5ub3RpZmllcik7CisKIAlyZXR1cm4gMDsKIGV4aXQ6CiAJa2ZyZWUobm9wKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL290Zy91bHBpLmMgYi9kcml2ZXJzL3VzYi9vdGcvdWxwaS5jCmluZGV4IDA1OWQ5YWMuLjc3MGQ3OTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL290Zy91bHBpLmMKKysrIGIvZHJpdmVycy91c2Ivb3RnL3VscGkuYwpAQCAtNDUsNyArNDUsNyBAQAogLyogVUxQSSBoYXJkY29kZWQgSURzLCB1c2VkIGZvciBwcm9iaW5nICovCiBzdGF0aWMgc3RydWN0IHVscGlfaW5mbyB1bHBpX2lkc1tdID0gewogCVVMUElfSU5GTyhVTFBJX0lEKDB4MDRjYywgMHgxNTA0KSwgIk5YUCBJU1AxNTA0IiksCi0JVUxQSV9JTkZPKFVMUElfSUQoMHgwNDI0LCAweDAwMDYpLCAiU01TQyBVU0IzMzE5IiksCisJVUxQSV9JTkZPKFVMUElfSUQoMHgwNDI0LCAweDAwMDYpLCAiU01TQyBVU0IzMzF4IiksCiB9OwogCiBzdGF0aWMgaW50IHVscGlfc2V0X290Z19mbGFncyhzdHJ1Y3Qgb3RnX3RyYW5zY2VpdmVyICpvdGcpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvY2gzNDEuYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9jaDM0MS5jCmluZGV4IDYzZjdjYzQuLjdiODgxNWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9jaDM0MS5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9jaDM0MS5jCkBAIC00ODYsMTIgKzQ4NiwyMiBAQAogCWlmIChhY3R1YWxfbGVuZ3RoID49IDQpIHsKIAkJc3RydWN0IGNoMzQxX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7CiAJCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJCXU4IHByZXZfbGluZV9zdGF0dXMgPSBwcml2LT5saW5lX3N0YXR1czsKIAogCQlzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+bG9jaywgZmxhZ3MpOwogCQlwcml2LT5saW5lX3N0YXR1cyA9ICh+KGRhdGFbMl0pKSAmIENIMzQxX0JJVFNfTU9ERU1fU1RBVDsKIAkJaWYgKChkYXRhWzFdICYgQ0gzNDFfTVVMVF9TVEFUKSkKIAkJCXByaXYtPm11bHRpX3N0YXR1c19jaGFuZ2UgPSAxOwogCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5sb2NrLCBmbGFncyk7CisKKwkJaWYgKChwcml2LT5saW5lX3N0YXR1cyBeIHByZXZfbGluZV9zdGF0dXMpICYgQ0gzNDFfQklUX0RDRCkgeworCQkJc3RydWN0IHR0eV9zdHJ1Y3QgKnR0eSA9IHR0eV9wb3J0X3R0eV9nZXQoJnBvcnQtPnBvcnQpOworCQkJaWYgKHR0eSkKKwkJCQl1c2Jfc2VyaWFsX2hhbmRsZV9kY2RfY2hhbmdlKHBvcnQsIHR0eSwKKwkJCQkJICAgIHByaXYtPmxpbmVfc3RhdHVzICYgQ0gzNDFfQklUX0RDRCk7CisJCQl0dHlfa3JlZl9wdXQodHR5KTsKKwkJfQorCiAJCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmcHJpdi0+ZGVsdGFfbXNyX3dhaXQpOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc2VyaWFsL2NwMjEweC5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL2NwMjEweC5jCmluZGV4IDhkNzczMWQuLjczNWVhMDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9jcDIxMHguYworKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwvY3AyMTB4LmMKQEAgLTQ5LDcgKzQ5LDYgQEAKIHN0YXRpYyB2b2lkIGNwMjEweF9icmVha19jdGwoc3RydWN0IHR0eV9zdHJ1Y3QgKiwgaW50KTsKIHN0YXRpYyBpbnQgY3AyMTB4X3N0YXJ0dXAoc3RydWN0IHVzYl9zZXJpYWwgKik7CiBzdGF0aWMgdm9pZCBjcDIxMHhfZHRyX3J0cyhzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwLCBpbnQgb24pOwotc3RhdGljIGludCBjcDIxMHhfY2Fycmllcl9yYWlzZWQoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcCk7CiAKIHN0YXRpYyBpbnQgZGVidWc7CiAKQEAgLTg3LDcgKzg2LDYgQEAKIAl7IFVTQl9ERVZJQ0UoMHgxMEM0LCAweDgxMTUpIH0sIC8qIEFyeWdvbiBORkMvTWlmYXJlIFJlYWRlciAqLwogCXsgVVNCX0RFVklDRSgweDEwQzQsIDB4ODEzRCkgfSwgLyogQnVybnNpZGUgVGVsZWNvbSBEZXNrbW9iaWxlICovCiAJeyBVU0JfREVWSUNFKDB4MTBDNCwgMHg4MTNGKSB9LCAvKiBUYW1zIE1hc3RlciBFYXN5IENvbnRyb2wgKi8KLQl7IFVTQl9ERVZJQ0UoMHgxMEM0LCAweDgxNDkpIH0sIC8qIFdlc3QgTW91bnRhaW4gUmFkaW8gQ29tcHV0ZXJpemVkIEJhdHRlcnkgQW5hbHl6ZXIgKi8KIAl7IFVTQl9ERVZJQ0UoMHgxMEM0LCAweDgxNEEpIH0sIC8qIFdlc3QgTW91bnRhaW4gUmFkaW8gUklHYmxhc3RlciBQJlAgKi8KIAl7IFVTQl9ERVZJQ0UoMHgxMEM0LCAweDgxNEIpIH0sIC8qIFdlc3QgTW91bnRhaW4gUmFkaW8gUklHdGFsayAqLwogCXsgVVNCX0RFVklDRSgweDEwQzQsIDB4ODE1NikgfSwgLyogQiZHIEgzMDAwIGxpbmsgY2FibGUgKi8KQEAgLTExMCw3ICsxMDgsOSBAQAogCXsgVVNCX0RFVklDRSgweDEwQzQsIDB4ODM0MSkgfSwgLyogU2llbWVucyBNQzM1UFUgR1BSUyBNb2RlbSAqLwogCXsgVVNCX0RFVklDRSgweDEwQzQsIDB4ODM4MikgfSwgLyogQ3lnbmFsIEludGVncmF0ZWQgUHJvZHVjdHMsIEluYy4gKi8KIAl7IFVTQl9ERVZJQ0UoMHgxMEM0LCAweDgzQTgpIH0sIC8qIEFtYmVyIFdpcmVsZXNzIEFNQjI1NjAgKi8KKwl7IFVTQl9ERVZJQ0UoMHgxMEM0LCAweDgzRDgpIH0sIC8qIERla1RlYyBEVEEgUGx1cyBWSEYvVUhGIEJvb3N0ZXIvQXR0ZW51YXRvciAqLwogCXsgVVNCX0RFVklDRSgweDEwQzQsIDB4ODQxMSkgfSwgLyogS3lvY2VyYSBHUFMgTW9kdWxlICovCisJeyBVU0JfREVWSUNFKDB4MTBDNCwgMHg4NDE4KSB9LCAvKiBJUlogQXV0b21hdGlvbiBUZWxlcG9ydCBTRy0xMCBHU00vR1BSUyBNb2RlbSAqLwogCXsgVVNCX0RFVklDRSgweDEwQzQsIDB4ODQ2RSkgfSwgLyogQkVJIFVTQiBTZW5zb3IgSW50ZXJmYWNlIChWQ1ApICovCiAJeyBVU0JfREVWSUNFKDB4MTBDNCwgMHg4NDc3KSB9LCAvKiBCYWxsdWZmIFJGSUQgKi8KIAl7IFVTQl9ERVZJQ0UoMHgxMEM0LCAweEVBNjApIH0sIC8qIFNpbGljb24gTGFicyBmYWN0b3J5IGRlZmF1bHQgKi8KQEAgLTE2NSw4ICsxNjUsNyBAQAogCS50aW9jbWdldCAJCT0gY3AyMTB4X3Rpb2NtZ2V0LAogCS50aW9jbXNldAkJPSBjcDIxMHhfdGlvY21zZXQsCiAJLmF0dGFjaAkJCT0gY3AyMTB4X3N0YXJ0dXAsCi0JLmR0cl9ydHMJCT0gY3AyMTB4X2R0cl9ydHMsCi0JLmNhcnJpZXJfcmFpc2VkCQk9IGNwMjEweF9jYXJyaWVyX3JhaXNlZAorCS5kdHJfcnRzCQk9IGNwMjEweF9kdHJfcnRzCiB9OwogCiAvKiBDb25maWcgcmVxdWVzdCB0eXBlcyAqLwpAQCAtNzY1LDE1ICs3NjQsNiBAQAogCXJldHVybiByZXN1bHQ7CiB9CiAKLXN0YXRpYyBpbnQgY3AyMTB4X2NhcnJpZXJfcmFpc2VkKHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnApCi17Ci0JdW5zaWduZWQgaW50IGNvbnRyb2w7Ci0JY3AyMTB4X2dldF9jb25maWcocCwgQ1AyMTBYX0dFVF9NRE1TVFMsICZjb250cm9sLCAxKTsKLQlpZiAoY29udHJvbCAmIENPTlRST0xfRENEKQotCQlyZXR1cm4gMTsKLQlyZXR1cm4gMDsKLX0KLQogc3RhdGljIHZvaWQgY3AyMTB4X2JyZWFrX2N0bCAoc3RydWN0IHR0eV9zdHJ1Y3QgKnR0eSwgaW50IGJyZWFrX3N0YXRlKQogewogCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB0dHktPmRyaXZlcl9kYXRhOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc2VyaWFsL2RpZ2lfYWNjZWxlcG9ydC5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL2RpZ2lfYWNjZWxlcG9ydC5jCmluZGV4IGI5MjA3MGMuLjY2NmU1YTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9kaWdpX2FjY2VsZXBvcnQuYworKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwvZGlnaV9hY2NlbGVwb3J0LmMKQEAgLTQ1NSw3ICs0NTUsNiBAQAogc3RhdGljIGludCBkaWdpX2NoYXJzX2luX2J1ZmZlcihzdHJ1Y3QgdHR5X3N0cnVjdCAqdHR5KTsKIHN0YXRpYyBpbnQgZGlnaV9vcGVuKHN0cnVjdCB0dHlfc3RydWN0ICp0dHksIHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQpOwogc3RhdGljIHZvaWQgZGlnaV9jbG9zZShzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0KTsKLXN0YXRpYyBpbnQgZGlnaV9jYXJyaWVyX3JhaXNlZChzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0KTsKIHN0YXRpYyB2b2lkIGRpZ2lfZHRyX3J0cyhzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0LCBpbnQgb24pOwogc3RhdGljIGludCBkaWdpX3N0YXJ0dXBfZGV2aWNlKHN0cnVjdCB1c2Jfc2VyaWFsICpzZXJpYWwpOwogc3RhdGljIGludCBkaWdpX3N0YXJ0dXAoc3RydWN0IHVzYl9zZXJpYWwgKnNlcmlhbCk7CkBAIC01MTEsNyArNTEwLDYgQEAKIAkub3BlbiA9CQkJCWRpZ2lfb3BlbiwKIAkuY2xvc2UgPQkJCWRpZ2lfY2xvc2UsCiAJLmR0cl9ydHMgPQkJCWRpZ2lfZHRyX3J0cywKLQkuY2Fycmllcl9yYWlzZWQgPQkJZGlnaV9jYXJyaWVyX3JhaXNlZCwKIAkud3JpdGUgPQkJCWRpZ2lfd3JpdGUsCiAJLndyaXRlX3Jvb20gPQkJCWRpZ2lfd3JpdGVfcm9vbSwKIAkud3JpdGVfYnVsa19jYWxsYmFjayA9IAkJZGlnaV93cml0ZV9idWxrX2NhbGxiYWNrLApAQCAtMTMzOSwxNCArMTMzNyw2IEBACiAJZGlnaV9zZXRfbW9kZW1fc2lnbmFscyhwb3J0LCBvbiAqIChUSU9DTV9EVFJ8VElPQ01fUlRTKSwgMSk7CiB9CiAKLXN0YXRpYyBpbnQgZGlnaV9jYXJyaWVyX3JhaXNlZChzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0KQotewotCXN0cnVjdCBkaWdpX3BvcnQgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7Ci0JaWYgKHByaXYtPmRwX21vZGVtX3NpZ25hbHMgJiBUSU9DTV9DRCkKLQkJcmV0dXJuIDE7Ci0JcmV0dXJuIDA7Ci19Ci0KIHN0YXRpYyBpbnQgZGlnaV9vcGVuKHN0cnVjdCB0dHlfc3RydWN0ICp0dHksIHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQpCiB7CiAJaW50IHJldDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9mdGRpX3Npby5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL2Z0ZGlfc2lvLmMKaW5kZXggYTI2NjhkMC4uZjM0OWEzNiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL2Z0ZGlfc2lvLmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL2Z0ZGlfc2lvLmMKQEAgLTEwMCw2ICsxMDAsNyBAQAogc3RhdGljIGludCAgIGZ0ZGlfanRhZ19wcm9iZShzdHJ1Y3QgdXNiX3NlcmlhbCAqc2VyaWFsKTsKIHN0YXRpYyBpbnQgICBmdGRpX210eG9yYl9oYWNrX3NldHVwKHN0cnVjdCB1c2Jfc2VyaWFsICpzZXJpYWwpOwogc3RhdGljIGludCAgIGZ0ZGlfTkRJX2RldmljZV9zZXR1cChzdHJ1Y3QgdXNiX3NlcmlhbCAqc2VyaWFsKTsKK3N0YXRpYyBpbnQgICBmdGRpX3N0bWNsaXRlX3Byb2JlKHN0cnVjdCB1c2Jfc2VyaWFsICpzZXJpYWwpOwogc3RhdGljIHZvaWQgIGZ0ZGlfVVNCX1VJUlRfc2V0dXAoc3RydWN0IGZ0ZGlfcHJpdmF0ZSAqcHJpdik7CiBzdGF0aWMgdm9pZCAgZnRkaV9IRV9USVJBMV9zZXR1cChzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2KTsKIApAQCAtMTIzLDYgKzEyNCwxMCBAQAogCS5wb3J0X3Byb2JlID0gZnRkaV9IRV9USVJBMV9zZXR1cCwKIH07CiAKK3N0YXRpYyBzdHJ1Y3QgZnRkaV9zaW9fcXVpcmsgZnRkaV9zdG1jbGl0ZV9xdWlyayA9IHsKKwkucHJvYmUJPSBmdGRpX3N0bWNsaXRlX3Byb2JlLAorfTsKKwogLyoKICAqIFRoZSA4VTIzMkFNIGhhcyB0aGUgc2FtZSBBUEkgYXMgdGhlIHNpbyBleGNlcHQgZm9yOgogICogLSBpdCBjYW4gc3VwcG9ydCBNVUNIIGhpZ2hlciBiYXVkcmF0ZXM7IHVwIHRvOgpAQCAtNjE2LDYgKzYyMSw3IEBACiAJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX09DRUFOSUNfUElEKSB9LAogCXsgVVNCX0RFVklDRShUVElfVklELCBUVElfUUwzNTVQX1BJRCkgfSwKIAl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfUk1fQ0FOVklFV19QSUQpIH0sCisJeyBVU0JfREVWSUNFKEFDVE9OX1ZJRCwgQUNUT05fU1BFQ1RSQVBST19QSUQpIH0sCiAJeyBVU0JfREVWSUNFKENPTlRFQ19WSUQsIENPTlRFQ19DT00xVVNCSF9QSUQpIH0sCiAJeyBVU0JfREVWSUNFKEJBTkRCX1ZJRCwgQkFOREJfVVNPVEw0X1BJRCkgfSwKIAl7IFVTQl9ERVZJQ0UoQkFOREJfVklELCBCQU5EQl9VU1RMNF9QSUQpIH0sCkBAIC02NzYsNyArNjgyLDE3IEBACiAJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX1BDREpfREFDMl9QSUQpIH0sCiAJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX1JSQ0lSS0lUU19MT0NPQlVGRkVSX1BJRCkgfSwKIAl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfQVNLX1JEUjQwMF9QSUQpIH0sCi0JeyBVU0JfREVWSUNFKElDT01fSUQxX1ZJRCwgSUNPTV9JRDFfUElEKSB9LAorCXsgVVNCX0RFVklDRShJQ09NX1ZJRCwgSUNPTV9JRF8xX1BJRCkgfSwKKwl7IFVTQl9ERVZJQ0UoSUNPTV9WSUQsIElDT01fT1BDX1VfVUNfUElEKSB9LAorCXsgVVNCX0RFVklDRShJQ09NX1ZJRCwgSUNPTV9JRF9SUDJDMV9QSUQpIH0sCisJeyBVU0JfREVWSUNFKElDT01fVklELCBJQ09NX0lEX1JQMkMyX1BJRCkgfSwKKwl7IFVTQl9ERVZJQ0UoSUNPTV9WSUQsIElDT01fSURfUlAyRF9QSUQpIH0sCisJeyBVU0JfREVWSUNFKElDT01fVklELCBJQ09NX0lEX1JQMlZUX1BJRCkgfSwKKwl7IFVTQl9ERVZJQ0UoSUNPTV9WSUQsIElDT01fSURfUlAyVlJfUElEKSB9LAorCXsgVVNCX0RFVklDRShJQ09NX1ZJRCwgSUNPTV9JRF9SUDRLVlRfUElEKSB9LAorCXsgVVNCX0RFVklDRShJQ09NX1ZJRCwgSUNPTV9JRF9SUDRLVlJfUElEKSB9LAorCXsgVVNCX0RFVklDRShJQ09NX1ZJRCwgSUNPTV9JRF9SUDJLVlRfUElEKSB9LAorCXsgVVNCX0RFVklDRShJQ09NX1ZJRCwgSUNPTV9JRF9SUDJLVlJfUElEKSB9LAogCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9BQ0dfSEZEVUFMX1BJRCkgfSwKIAl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfWUVJX1NFUlZPQ0VOVEVSMzFfUElEKSB9LAogCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9USE9STEFCU19QSUQpIH0sCkBAIC04MDAsNiArODE2LDggQEAKIAl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfRE9URUNfUElEKSB9LAogCXsgVVNCX0RFVklDRShRSUhBUkRXQVJFX1ZJRCwgTUlMS1lNSVNUT05FX0pUQUdTRVJJQUxfUElEKSwKIAkJLmRyaXZlcl9pbmZvID0gKGtlcm5lbF91bG9uZ190KSZmdGRpX2p0YWdfcXVpcmsgfSwKKwl7IFVTQl9ERVZJQ0UoU1RfVklELCBTVF9TVE1DTFQxMDMwX1BJRCksCisJCS5kcml2ZXJfaW5mbyA9IChrZXJuZWxfdWxvbmdfdCkmZnRkaV9zdG1jbGl0ZV9xdWlyayB9LAogCXsgfSwJCQkJCS8qIE9wdGlvbmFsIHBhcmFtZXRlciBlbnRyeSAqLwogCXsgfQkJCQkJLyogVGVybWluYXRpbmcgZW50cnkgKi8KIH07CkBAIC0xNjk5LDYgKzE3MTcsMjUgQEAKIH0KIAogLyoKKyAqIEZpcnN0IGFuZCBzZWNvbmQgcG9ydCBvbiBTVE1DTGl0ZWFkYXB0b3JzIGlzIHJlc2VydmVkIGZvciBKVEFHIGludGVyZmFjZQorICogYW5kIHRoZSBmb3J0aCBwb3J0IGZvciBwaW8KKyAqLworc3RhdGljIGludCBmdGRpX3N0bWNsaXRlX3Byb2JlKHN0cnVjdCB1c2Jfc2VyaWFsICpzZXJpYWwpCit7CisJc3RydWN0IHVzYl9kZXZpY2UgKnVkZXYgPSBzZXJpYWwtPmRldjsKKwlzdHJ1Y3QgdXNiX2ludGVyZmFjZSAqaW50ZXJmYWNlID0gc2VyaWFsLT5pbnRlcmZhY2U7CisKKwlkYmcoIiVzIiwgX19mdW5jX18pOworCisJaWYgKGludGVyZmFjZSA9PSB1ZGV2LT5hY3Rjb25maWctPmludGVyZmFjZVsyXSkKKwkJcmV0dXJuIDA7CisKKwlkZXZfaW5mbygmdWRldi0+ZGV2LCAiSWdub3Jpbmcgc2VyaWFsIHBvcnQgcmVzZXJ2ZWQgZm9yIEpUQUdcbiIpOworCisJcmV0dXJuIC1FTk9ERVY7Cit9CisKKy8qCiAgKiBUaGUgTWF0cml4IE9yYml0YWwgVksyMDQtMjUtVVNCIGhhcyBhbiBpbnZhbGlkIElOIGVuZHBvaW50LgogICogV2UgaGF2ZSB0byBjb3JyZWN0IGl0IGlmIHdlIHdhbnQgdG8gcmVhZCBmcm9tIGl0LgogICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvZnRkaV9zaW9faWRzLmggYi9kcml2ZXJzL3VzYi9zZXJpYWwvZnRkaV9zaW9faWRzLmgKaW5kZXggYmYwODY3Mi4uMTE3ZThlNiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL2Z0ZGlfc2lvX2lkcy5oCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9mdGRpX3Npb19pZHMuaApAQCAtNTE4LDYgKzUxOCwxMiBAQAogI2RlZmluZSBSQVRPQ19QUk9EVUNUX0lEX1VTQjYwRgkweGIwMjAKIAogLyoKKyAqIEFjdG9uIFJlc2VhcmNoIENvcnAuCisgKi8KKyNkZWZpbmUgQUNUT05fVklECQkweDA2NDcJLyogVmVuZG9yIElEICovCisjZGVmaW5lIEFDVE9OX1NQRUNUUkFQUk9fUElECTB4MDEwMAorCisvKgogICogQ29udGVjIHByb2R1Y3RzIChodHRwOi8vd3d3LmNvbnRlYy5jb20pCiAgKiBTdWJtaXR0ZWQgYnkgRGFuaWVsIFNhbmdvcnJpbgogICovCkBAIC01NjksMTEgKzU3NSwyMyBAQAogI2RlZmluZSBPQ1RfVVMxMDFfUElECQkweDA0MjEJLyogT0NUIFVTMTAxIFVTQiB0byBSUy0yMzIgKi8KIAogLyoKLSAqIEljb20gSUQtMSBkaWdpdGFsIHRyYW5zY2VpdmVyCisgKiBEZWZpbml0aW9ucyBmb3IgSWNvbSBJbmMuIGRldmljZXMKICAqLwotCi0jZGVmaW5lIElDT01fSUQxX1ZJRCAgICAgICAgICAgIDB4MEMyNgotI2RlZmluZSBJQ09NX0lEMV9QSUQgICAgICAgICAgICAweDAwMDQKKyNkZWZpbmUgSUNPTV9WSUQJCTB4MEMyNiAvKiBJY29tIHZlbmRvciBJRCAqLworLyogTm90ZTogSUQtMSBpcyBhIGNvbW11bmljYXRpb25zIHRyYW5jZWl2ZXIgZm9yIEhBTS1yYWRpbyBvcGVyYXRvcnMgKi8KKyNkZWZpbmUgSUNPTV9JRF8xX1BJRAkJMHgwMDA0IC8qIElELTEgVVNCIHRvIFJTLTIzMiAqLworLyogTm90ZTogT1BDIGlzIGFuIE9wdGlvbmFsIGNhYmxlIHRvIGNvbm5lY3QgYW4gSWNvbSBUcmFuY2VpdmVyICovCisjZGVmaW5lIElDT01fT1BDX1VfVUNfUElECTB4MDAxOCAvKiBPUEMtNDc4VUMsIE9QQy0xMTIyVSBjbG9uaW5nIGNhYmxlICovCisvKiBOb3RlOiBJRC1SUCogZGV2aWNlcyBhcmUgSWNvbSBSZXBlYXRlciBEZXZpY2VzIGZvciBIQU0tcmFkaW8gKi8KKyNkZWZpbmUgSUNPTV9JRF9SUDJDMV9QSUQJMHgwMDA5IC8qIElELVJQMkMgQXNzZXQgMSB0byBSUy0yMzIgKi8KKyNkZWZpbmUgSUNPTV9JRF9SUDJDMl9QSUQJMHgwMDBBIC8qIElELVJQMkMgQXNzZXQgMiB0byBSUy0yMzIgKi8KKyNkZWZpbmUgSUNPTV9JRF9SUDJEX1BJRAkweDAwMEIgLyogSUQtUlAyRCBjb25maWd1cmF0aW9uIHBvcnQqLworI2RlZmluZSBJQ09NX0lEX1JQMlZUX1BJRAkweDAwMEMgLyogSUQtUlAyViBUcmFuc21pdCBjb25maWcgcG9ydCAqLworI2RlZmluZSBJQ09NX0lEX1JQMlZSX1BJRAkweDAwMEQgLyogSUQtUlAyViBSZWNlaXZlIGNvbmZpZyBwb3J0ICovCisjZGVmaW5lIElDT01fSURfUlA0S1ZUX1BJRAkweDAwMTAgLyogSUQtUlA0MDAwViBUcmFuc21pdCBjb25maWcgcG9ydCAqLworI2RlZmluZSBJQ09NX0lEX1JQNEtWUl9QSUQJMHgwMDExIC8qIElELVJQNDAwMFYgUmVjZWl2ZSBjb25maWcgcG9ydCAqLworI2RlZmluZSBJQ09NX0lEX1JQMktWVF9QSUQJMHgwMDEyIC8qIElELVJQMjAwMFYgVHJhbnNtaXQgY29uZmlnIHBvcnQgKi8KKyNkZWZpbmUgSUNPTV9JRF9SUDJLVlJfUElECTB4MDAxMyAvKiBJRC1SUDIwMDBWIFJlY2VpdmUgY29uZmlnIHBvcnQgKi8KIAogLyoKICAqIEdOIE90b21ldHJpY3MgKGh0dHA6Ly93d3cub3RvbWV0cmljcy5jb20pCkBAIC0xMDIyLDYgKzEwNDAsMTIgQEAKICNkZWZpbmUgV0hUX1BJRAkJCTB4MDAwNCAvKiBXaXJlbGVzcyBIYW5kaGVsZCBUZXJtaW5hbCAqLwogCiAvKgorICogU1RNaWNyb2VsZWN0b25pY3MKKyAqLworI2RlZmluZSBTVF9WSUQJCQkweDA0ODMKKyNkZWZpbmUgU1RfU1RNQ0xUMTAzMF9QSUQJMHgzNzQ3IC8qIFNUIE1pY3JvIENvbm5lY3QgTGl0ZSBTVE1DTFQxMDMwICovCisKKy8qCiAgKiBQYXBvdWNoIHByb2R1Y3RzIChodHRwOi8vd3d3LnBhcG91Y2guY29tLykKICAqIFN1Ym1pdHRlZCBieSBGb2xrZXJ0IHZhbiBIZXVzZGVuCiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9nZW5lcmljLmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvZ2VuZXJpYy5jCmluZGV4IGU2ODMzZTIuLmU0ZGI1YWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9nZW5lcmljLmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL2dlbmVyaWMuYwpAQCAtNDc5LDYgKzQ3OSwyNiBAQAogfQogRVhQT1JUX1NZTUJPTF9HUEwodXNiX3NlcmlhbF9oYW5kbGVfYnJlYWspOwogCisvKioKKyAqCXVzYl9zZXJpYWxfaGFuZGxlX2RjZF9jaGFuZ2UgLSBoYW5kbGUgYSBjaGFuZ2Ugb2YgY2FycmllciBkZXRlY3Qgc3RhdGUKKyAqCUBwb3J0OiB1c2Jfc2VyaWFsX3BvcnQgc3RydWN0dXJlIGZvciB0aGUgb3BlbiBwb3J0CisgKglAdHR5OiB0dHlfc3RydWN0IHN0cnVjdHVyZSBmb3IgdGhlIHBvcnQKKyAqCUBzdGF0dXM6IG5ldyBjYXJyaWVyIGRldGVjdCBzdGF0dXMsIG5vbnplcm8gaWYgYWN0aXZlCisgKi8KK3ZvaWQgdXNiX3NlcmlhbF9oYW5kbGVfZGNkX2NoYW5nZShzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICp1c2JfcG9ydCwKKwkJCQlzdHJ1Y3QgdHR5X3N0cnVjdCAqdHR5LCB1bnNpZ25lZCBpbnQgc3RhdHVzKQoreworCXN0cnVjdCB0dHlfcG9ydCAqcG9ydCA9ICZ1c2JfcG9ydC0+cG9ydDsKKworCWRiZygiJXMgLSBwb3J0ICVkLCBzdGF0dXMgJWQiLCBfX2Z1bmNfXywgdXNiX3BvcnQtPm51bWJlciwgc3RhdHVzKTsKKworCWlmIChzdGF0dXMpCisJCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmcG9ydC0+b3Blbl93YWl0KTsKKwllbHNlIGlmICh0dHkgJiYgIUNfQ0xPQ0FMKHR0eSkpCisJCXR0eV9oYW5ndXAodHR5KTsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKHVzYl9zZXJpYWxfaGFuZGxlX2RjZF9jaGFuZ2UpOworCiBpbnQgdXNiX3NlcmlhbF9nZW5lcmljX3Jlc3VtZShzdHJ1Y3QgdXNiX3NlcmlhbCAqc2VyaWFsKQogewogCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvaW9fZWRnZXBvcnQuYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9pb19lZGdlcG9ydC5jCmluZGV4IGNkNzY5ZWYuLjNiMjQ2ZDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9pb19lZGdlcG9ydC5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9pb19lZGdlcG9ydC5jCkBAIC0yODg5LDggKzI4ODksOCBAQAogCiAJZGJnKCIlcyAlZC4lZC4lZCIsIGZ3X2luZm8sIHJlYy0+ZGF0YVswXSwgcmVjLT5kYXRhWzFdLCBidWlsZCk7CiAKLQllZGdlX3NlcmlhbC0+cHJvZHVjdF9pbmZvLkZpcm13YXJlTWFqb3JWZXJzaW9uID0gZnctPmRhdGFbMF07Ci0JZWRnZV9zZXJpYWwtPnByb2R1Y3RfaW5mby5GaXJtd2FyZU1pbm9yVmVyc2lvbiA9IGZ3LT5kYXRhWzFdOworCWVkZ2Vfc2VyaWFsLT5wcm9kdWN0X2luZm8uRmlybXdhcmVNYWpvclZlcnNpb24gPSByZWMtPmRhdGFbMF07CisJZWRnZV9zZXJpYWwtPnByb2R1Y3RfaW5mby5GaXJtd2FyZU1pbm9yVmVyc2lvbiA9IHJlYy0+ZGF0YVsxXTsKIAllZGdlX3NlcmlhbC0+cHJvZHVjdF9pbmZvLkZpcm13YXJlQnVpbGROdW1iZXIgPSBjcHVfdG9fbGUxNihidWlsZCk7CiAKIAlmb3IgKHJlYyA9IGloZXhfbmV4dF9iaW5yZWMocmVjKTsgcmVjOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc2VyaWFsL2lvX3RhYmxlcy5oIGIvZHJpdmVycy91c2Ivc2VyaWFsL2lvX3RhYmxlcy5oCmluZGV4IDZhYjJhM2YuLjE3OGIyMmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9pb190YWJsZXMuaAorKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwvaW9fdGFibGVzLmgKQEAgLTE5OSw2ICsxOTksNyBAQAogCQkubmFtZQkJPSAiZXBpYyIsCiAJfSwKIAkuZGVzY3JpcHRpb24JCT0gIkVQaUMgZGV2aWNlIiwKKwkudXNiX2RyaXZlcgkJPSAmaW9fZHJpdmVyLAogCS5pZF90YWJsZQkJPSBFcGljX3BvcnRfaWRfdGFibGUsCiAJLm51bV9wb3J0cwkJPSAxLAogCS5vcGVuCQkJPSBlZGdlX29wZW4sCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvaXV1X3Bob2VuaXguYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9pdXVfcGhvZW5peC5jCmluZGV4IDEyZWQ1OTQuLjk5Yjk3YzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9pdXVfcGhvZW5peC5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9pdXVfcGhvZW5peC5jCkBAIC0xMjc1LDYgKzEyNzUsNyBAQAogCQkgICAubmFtZSA9ICJpdXVfcGhvZW5peCIsCiAJCSAgIH0sCiAJLmlkX3RhYmxlID0gaWRfdGFibGUsCisJLnVzYl9kcml2ZXIgPSAmaXV1X2RyaXZlciwKIAkubnVtX3BvcnRzID0gMSwKIAkuYnVsa19pbl9zaXplID0gNTEyLAogCS5idWxrX291dF9zaXplID0gNTEyLApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc2VyaWFsL2tleXNwYW4uaCBiL2RyaXZlcnMvdXNiL3NlcmlhbC9rZXlzcGFuLmgKaW5kZXggMmQ4YmFmNi4uY2UxMzRkYyAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL2tleXNwYW4uaAorKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwva2V5c3Bhbi5oCkBAIC01NDYsNiArNTQ2LDcgQEAKIAkJLm5hbWUJCT0gImtleXNwYW5fbm9fZmlybSIsCiAJfSwKIAkuZGVzY3JpcHRpb24JCT0gIktleXNwYW4gLSAod2l0aG91dCBmaXJtd2FyZSkiLAorCS51c2JfZHJpdmVyCQk9ICZrZXlzcGFuX2RyaXZlciwKIAkuaWRfdGFibGUJCT0ga2V5c3Bhbl9wcmVfaWRzLAogCS5udW1fcG9ydHMJCT0gMSwKIAkuYXR0YWNoCQkJPSBrZXlzcGFuX2Zha2Vfc3RhcnR1cCwKQEAgLTU1Nyw2ICs1NTgsNyBAQAogCQkubmFtZQkJPSAia2V5c3Bhbl8xIiwKIAl9LAogCS5kZXNjcmlwdGlvbgkJPSAiS2V5c3BhbiAxIHBvcnQgYWRhcHRlciIsCisJLnVzYl9kcml2ZXIJCT0gJmtleXNwYW5fZHJpdmVyLAogCS5pZF90YWJsZQkJPSBrZXlzcGFuXzFwb3J0X2lkcywKIAkubnVtX3BvcnRzCQk9IDEsCiAJLm9wZW4JCQk9IGtleXNwYW5fb3BlbiwKQEAgLTU3OSw2ICs1ODEsNyBAQAogCQkubmFtZQkJPSAia2V5c3Bhbl8yIiwKIAl9LAogCS5kZXNjcmlwdGlvbgkJPSAiS2V5c3BhbiAyIHBvcnQgYWRhcHRlciIsCisJLnVzYl9kcml2ZXIJCT0gJmtleXNwYW5fZHJpdmVyLAogCS5pZF90YWJsZQkJPSBrZXlzcGFuXzJwb3J0X2lkcywKIAkubnVtX3BvcnRzCQk9IDIsCiAJLm9wZW4JCQk9IGtleXNwYW5fb3BlbiwKQEAgLTYwMSw2ICs2MDQsNyBAQAogCQkubmFtZQkJPSAia2V5c3Bhbl80IiwKIAl9LAogCS5kZXNjcmlwdGlvbgkJPSAiS2V5c3BhbiA0IHBvcnQgYWRhcHRlciIsCisJLnVzYl9kcml2ZXIJCT0gJmtleXNwYW5fZHJpdmVyLAogCS5pZF90YWJsZQkJPSBrZXlzcGFuXzRwb3J0X2lkcywKIAkubnVtX3BvcnRzCQk9IDQsCiAJLm9wZW4JCQk9IGtleXNwYW5fb3BlbiwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9rZXlzcGFuX3BkYS5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL2tleXNwYW5fcGRhLmMKaW5kZXggYTEwZGQ1Ni4uNTU0YTg2OSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL2tleXNwYW5fcGRhLmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL2tleXNwYW5fcGRhLmMKQEAgLTY3OSwyMiArNjc5LDYgQEAKIAl9CiB9CiAKLXN0YXRpYyBpbnQga2V5c3Bhbl9wZGFfY2Fycmllcl9yYWlzZWQoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCkKLXsKLQlzdHJ1Y3QgdXNiX3NlcmlhbCAqc2VyaWFsID0gcG9ydC0+c2VyaWFsOwotCXVuc2lnbmVkIGNoYXIgbW9kZW1iaXRzOwotCi0JLyogSWYgd2UgY2FuIHJlYWQgdGhlIG1vZGVtIHN0YXR1cyBhbmQgdGhlIERDRCBpcyBsb3cgdGhlbgotCSAgIGNhcnJpZXIgaXMgbm90IHJhaXNlZCB5ZXQgKi8KLQlpZiAoa2V5c3Bhbl9wZGFfZ2V0X21vZGVtX2luZm8oc2VyaWFsLCAmbW9kZW1iaXRzKSA+PSAwKSB7Ci0JCWlmICghKG1vZGVtYml0cyAmICgxPj42KSkpCi0JCQlyZXR1cm4gMDsKLQl9Ci0JLyogQ2FycmllciByYWlzZWQsIG9yIHdlIGZhaWxlZCAoZWcgZGlzY29ubmVjdGVkKSBzbwotCSAgIHByb2dyZXNzIGFjY29yZGluZ2x5ICovCi0JcmV0dXJuIDE7Ci19Ci0KIAogc3RhdGljIGludCBrZXlzcGFuX3BkYV9vcGVuKHN0cnVjdCB0dHlfc3RydWN0ICp0dHksCiAJCQkJCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQpCkBAIC04ODEsNyArODY1LDYgQEAKIAkuaWRfdGFibGUgPQkJaWRfdGFibGVfc3RkLAogCS5udW1fcG9ydHMgPQkJMSwKIAkuZHRyX3J0cyA9CQlrZXlzcGFuX3BkYV9kdHJfcnRzLAotCS5jYXJyaWVyX3JhaXNlZAk9CWtleXNwYW5fcGRhX2NhcnJpZXJfcmFpc2VkLAogCS5vcGVuID0JCQlrZXlzcGFuX3BkYV9vcGVuLAogCS5jbG9zZSA9CQlrZXlzcGFuX3BkYV9jbG9zZSwKIAkud3JpdGUgPQkJa2V5c3Bhbl9wZGFfd3JpdGUsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvbW90b19tb2RlbS5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL21vdG9fbW9kZW0uYwppbmRleCBjZjE3MTgzLi42NTM0NjVmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zZXJpYWwvbW90b19tb2RlbS5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9tb3RvX21vZGVtLmMKQEAgLTQ0LDYgKzQ0LDcgQEAKIAkJLm5hbWUgPQkJIm1vdG8tbW9kZW0iLAogCX0sCiAJLmlkX3RhYmxlID0JCWlkX3RhYmxlLAorCS51c2JfZHJpdmVyID0JCSZtb3RvX2RyaXZlciwKIAkubnVtX3BvcnRzID0JCTEsCiB9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvb3B0aW9uLmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvb3B0aW9uLmMKaW5kZXggNzQ4Nzc4Mi4uNWY0NjgzOCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL29wdGlvbi5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9vcHRpb24uYwpAQCAtMzgyLDcgKzM4MiwxNiBAQAogI2RlZmluZSBIQUlFUl9WRU5ET1JfSUQJCQkJMHgyMDFlCiAjZGVmaW5lIEhBSUVSX1BST0RVQ1RfQ0UxMDAJCQkweDIwMDkKIAotI2RlZmluZSBDSU5URVJJT05fVkVORE9SX0lECQkJMHgwNjgxCisvKiBDaW50ZXJpb24gKGZvcm1lcmx5IFNpZW1lbnMpIHByb2R1Y3RzICovCisjZGVmaW5lIFNJRU1FTlNfVkVORE9SX0lECQkJCTB4MDY4MQorI2RlZmluZSBDSU5URVJJT05fVkVORE9SX0lECQkJCTB4MWUyZAorI2RlZmluZSBDSU5URVJJT05fUFJPRFVDVF9IQzI1X01ETQkJMHgwMDQ3CisjZGVmaW5lIENJTlRFUklPTl9QUk9EVUNUX0hDMjVfTURNTkVUCTB4MDA0MAorI2RlZmluZSBDSU5URVJJT05fUFJPRFVDVF9IQzI4X01ETQkJMHgwMDRDCisjZGVmaW5lIENJTlRFUklPTl9QUk9EVUNUX0hDMjhfTURNTkVUCTB4MDA0QSAvKiBzYW1lIGZvciBIQzI4SiAqLworI2RlZmluZSBDSU5URVJJT05fUFJPRFVDVF9FVTNfRQkJCTB4MDA1MQorI2RlZmluZSBDSU5URVJJT05fUFJPRFVDVF9FVTNfUAkJCTB4MDA1MgorI2RlZmluZSBDSU5URVJJT05fUFJPRFVDVF9QSDgJCQkweDAwNTMKIAogLyogT2xpdmV0dGkgcHJvZHVjdHMgKi8KICNkZWZpbmUgT0xJVkVUVElfVkVORE9SX0lECQkJMHgwYjNjCkBAIC05NDQsNyArOTUzLDE3IEBACiAJeyBVU0JfREVWSUNFKFBJUkVMTElfVkVORE9SX0lELCBQSVJFTExJX1BST0RVQ1RfMTAwRikgfSwKIAl7IFVTQl9ERVZJQ0UoUElSRUxMSV9WRU5ET1JfSUQsIFBJUkVMTElfUFJPRFVDVF8xMDExKX0sCiAJeyBVU0JfREVWSUNFKFBJUkVMTElfVkVORE9SX0lELCBQSVJFTExJX1BST0RVQ1RfMTAxMil9LAotCXsgVVNCX0RFVklDRShDSU5URVJJT05fVkVORE9SX0lELCAweDAwNDcpIH0sCisJLyogQ2ludGVyaW9uICovCisJeyBVU0JfREVWSUNFKENJTlRFUklPTl9WRU5ET1JfSUQsIENJTlRFUklPTl9QUk9EVUNUX0VVM19FKSB9LAorCXsgVVNCX0RFVklDRShDSU5URVJJT05fVkVORE9SX0lELCBDSU5URVJJT05fUFJPRFVDVF9FVTNfUCkgfSwKKwl7IFVTQl9ERVZJQ0UoQ0lOVEVSSU9OX1ZFTkRPUl9JRCwgQ0lOVEVSSU9OX1BST0RVQ1RfUEg4KSB9LAorCXsgVVNCX0RFVklDRShDSU5URVJJT05fVkVORE9SX0lELCBDSU5URVJJT05fUFJPRFVDVF9IQzI4X01ETSkgfSwgCisJeyBVU0JfREVWSUNFKENJTlRFUklPTl9WRU5ET1JfSUQsIENJTlRFUklPTl9QUk9EVUNUX0hDMjhfTURNTkVUKSB9LAorCXsgVVNCX0RFVklDRShTSUVNRU5TX1ZFTkRPUl9JRCwgQ0lOVEVSSU9OX1BST0RVQ1RfSEMyNV9NRE0pIH0sCisJeyBVU0JfREVWSUNFKFNJRU1FTlNfVkVORE9SX0lELCBDSU5URVJJT05fUFJPRFVDVF9IQzI1X01ETU5FVCkgfSwKKwl7IFVTQl9ERVZJQ0UoU0lFTUVOU19WRU5ET1JfSUQsIENJTlRFUklPTl9QUk9EVUNUX0hDMjhfTURNKSB9LCAvKiBIQzI4IGVudW1lcmF0ZXMgd2l0aCBTaWVtZW5zIG9yIENpbnRlcmlvbiBWSUQgZGVwZW5kaW5nIG9uIEZXIHJldmlzaW9uICovCisJeyBVU0JfREVWSUNFKFNJRU1FTlNfVkVORE9SX0lELCBDSU5URVJJT05fUFJPRFVDVF9IQzI4X01ETU5FVCkgfSwKKwogCXsgVVNCX0RFVklDRShPTElWRVRUSV9WRU5ET1JfSUQsIE9MSVZFVFRJX1BST0RVQ1RfT0xJQ0FSRDEwMCkgfSwKIAl7IFVTQl9ERVZJQ0UoQ0VMT1RfVkVORE9SX0lELCBDRUxPVF9QUk9EVUNUX0NUNjgwTSkgfSwgLyogQ1QtNjUwIENETUEgNDUwIDF4RVZETyBtb2RlbSAqLwogCXsgVVNCX0RFVklDRShPTkRBX1ZFTkRPUl9JRCwgT05EQV9NVDgyNVVQKSB9LCAvKiBPTkRBIE1UODI1VVAgbW9kZW0gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9vdGk2ODU4LmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvb3RpNjg1OC5jCmluZGV4IDViZTg2NmIuLjczNjEzMjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9vdGk2ODU4LmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL290aTY4NTguYwpAQCAtMTU3LDYgKzE1Nyw3IEBACiAJCS5uYW1lID0JCSJvdGk2ODU4IiwKIAl9LAogCS5pZF90YWJsZSA9CQlpZF90YWJsZSwKKwkudXNiX2RyaXZlciA9CQkmb3RpNjg1OF9kcml2ZXIsCiAJLm51bV9wb3J0cyA9CQkxLAogCS5vcGVuID0JCQlvdGk2ODU4X29wZW4sCiAJLmNsb3NlID0JCW90aTY4NThfY2xvc2UsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvcGwyMzAzLmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvcGwyMzAzLmMKaW5kZXggOGFlNGM2Yy4uMDhjOTE4MSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL3BsMjMwMy5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9wbDIzMDMuYwpAQCAtNTAsNiArNTAsNyBAQAogCXsgVVNCX0RFVklDRShQTDIzMDNfVkVORE9SX0lELCBQTDIzMDNfUFJPRFVDVF9JRF9NTVgpIH0sCiAJeyBVU0JfREVWSUNFKFBMMjMwM19WRU5ET1JfSUQsIFBMMjMwM19QUk9EVUNUX0lEX0dQUlMpIH0sCiAJeyBVU0JfREVWSUNFKFBMMjMwM19WRU5ET1JfSUQsIFBMMjMwM19QUk9EVUNUX0lEX0hDUjMzMSkgfSwKKwl7IFVTQl9ERVZJQ0UoUEwyMzAzX1ZFTkRPUl9JRCwgUEwyMzAzX1BST0RVQ1RfSURfTU9UT1JPTEEpIH0sCiAJeyBVU0JfREVWSUNFKElPREFUQV9WRU5ET1JfSUQsIElPREFUQV9QUk9EVUNUX0lEKSB9LAogCXsgVVNCX0RFVklDRShJT0RBVEFfVkVORE9SX0lELCBJT0RBVEFfUFJPRFVDVF9JRF9SU0FRNSkgfSwKIAl7IFVTQl9ERVZJQ0UoQVRFTl9WRU5ET1JfSUQsIEFURU5fUFJPRFVDVF9JRCkgfSwKQEAgLTY3Nyw5ICs2NzgsMTEgQEAKIHsKIAogCXN0cnVjdCBwbDIzMDNfcHJpdmF0ZSAqcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKKwlzdHJ1Y3QgdHR5X3N0cnVjdCAqdHR5OwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJdTggc3RhdHVzX2lkeCA9IFVBUlRfU1RBVEU7CiAJdTggbGVuZ3RoID0gVUFSVF9TVEFURSArIDE7CisJdTggcHJldl9saW5lX3N0YXR1czsKIAl1MTYgaWR2LCBpZHA7CiAKIAlpZHYgPSBsZTE2X3RvX2NwdShwb3J0LT5zZXJpYWwtPmRldi0+ZGVzY3JpcHRvci5pZFZlbmRvcik7CkBAIC03MDEsMTEgKzcwNCwyMCBAQAogCiAJLyogU2F2ZSBvZmYgdGhlIHVhcnQgc3RhdHVzIGZvciBvdGhlcnMgdG8gbG9vayBhdCAqLwogCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5sb2NrLCBmbGFncyk7CisJcHJldl9saW5lX3N0YXR1cyA9IHByaXYtPmxpbmVfc3RhdHVzOwogCXByaXYtPmxpbmVfc3RhdHVzID0gZGF0YVtzdGF0dXNfaWR4XTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5sb2NrLCBmbGFncyk7CiAJaWYgKHByaXYtPmxpbmVfc3RhdHVzICYgVUFSVF9CUkVBS19FUlJPUikKIAkJdXNiX3NlcmlhbF9oYW5kbGVfYnJlYWsocG9ydCk7CiAJd2FrZV91cF9pbnRlcnJ1cHRpYmxlKCZwcml2LT5kZWx0YV9tc3Jfd2FpdCk7CisKKwl0dHkgPSB0dHlfcG9ydF90dHlfZ2V0KCZwb3J0LT5wb3J0KTsKKwlpZiAoIXR0eSkKKwkJcmV0dXJuOworCWlmICgocHJpdi0+bGluZV9zdGF0dXMgXiBwcmV2X2xpbmVfc3RhdHVzKSAmIFVBUlRfRENEKQorCQl1c2Jfc2VyaWFsX2hhbmRsZV9kY2RfY2hhbmdlKHBvcnQsIHR0eSwKKwkJCQlwcml2LT5saW5lX3N0YXR1cyAmIFVBUlRfRENEKTsKKwl0dHlfa3JlZl9wdXQodHR5KTsKIH0KIAogc3RhdGljIHZvaWQgcGwyMzAzX3JlYWRfaW50X2NhbGxiYWNrKHN0cnVjdCB1cmIgKnVyYikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9wbDIzMDMuaCBiL2RyaXZlcnMvdXNiL3NlcmlhbC9wbDIzMDMuaAppbmRleCA0M2ViOWJkLi4xYjAyNWY3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zZXJpYWwvcGwyMzAzLmgKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL3BsMjMwMy5oCkBAIC0yMSw2ICsyMSw3IEBACiAjZGVmaW5lIFBMMjMwM19QUk9EVUNUX0lEX01NWAkJMHgwNjEyCiAjZGVmaW5lIFBMMjMwM19QUk9EVUNUX0lEX0dQUlMJCTB4MDYwOQogI2RlZmluZSBQTDIzMDNfUFJPRFVDVF9JRF9IQ1IzMzEJMHgzMzFhCisjZGVmaW5lIFBMMjMwM19QUk9EVUNUX0lEX01PVE9ST0xBCTB4MDMwNwogCiAjZGVmaW5lIEFURU5fVkVORE9SX0lECQkweDA1NTcKICNkZWZpbmUgQVRFTl9WRU5ET1JfSUQyCQkweDA1NDcKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9xY2F1eC5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL3FjYXV4LmMKaW5kZXggMjE0YTNlNS4uMzBiNzNlNiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL3FjYXV4LmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL3FjYXV4LmMKQEAgLTM2LDYgKzM2LDcgQEAKICNkZWZpbmUgVVRTVEFSQ09NX1BST0RVQ1RfVU0xNzVfVjEJCTB4MzcxMgogI2RlZmluZSBVVFNUQVJDT01fUFJPRFVDVF9VTTE3NV9WMgkJMHgzNzE0CiAjZGVmaW5lIFVUU1RBUkNPTV9QUk9EVUNUX1VNMTc1X0FMTFRFTAkJMHgzNzE1CisjZGVmaW5lIFBBTlRFQ0hfUFJPRFVDVF9VTUwyOTBfVlpXCQkweDM3MTgKIAogLyogQ01PVEVDSCBkZXZpY2VzICovCiAjZGVmaW5lIENNT1RFQ0hfVkVORE9SX0lECQkJMHgxNmQ4CkBAIC02Niw2ICs2Nyw3IEBACiAJeyBVU0JfREVWSUNFX0FORF9JTlRFUkZBQ0VfSU5GTyhMR19WRU5ET1JfSUQsIExHX1BST0RVQ1RfVlg0NDAwXzYwMDAsIDB4ZmYsIDB4ZmYsIDB4MDApIH0sCiAJeyBVU0JfREVWSUNFX0FORF9JTlRFUkZBQ0VfSU5GTyhTQU5ZT19WRU5ET1JfSUQsIFNBTllPX1BST0RVQ1RfS0FUQU5BX0xYLCAweGZmLCAweGZmLCAweDAwKSB9LAogCXsgVVNCX0RFVklDRV9BTkRfSU5URVJGQUNFX0lORk8oU0FNU1VOR19WRU5ET1JfSUQsIFNBTVNVTkdfUFJPRFVDVF9VNTIwLCAweGZmLCAweDAwLCAweDAwKSB9LAorCXsgVVNCX0RFVklDRV9BTkRfSU5URVJGQUNFX0lORk8oVVRTVEFSQ09NX1ZFTkRPUl9JRCwgUEFOVEVDSF9QUk9EVUNUX1VNTDI5MF9WWlcsIDB4ZmYsIDB4ZmYsIDB4ZmYpIH0sCiAJeyB9LAogfTsKIE1PRFVMRV9ERVZJQ0VfVEFCTEUodXNiLCBpZF90YWJsZSk7CkBAIC04NCw2ICs4Niw3IEBACiAJCS5uYW1lID0JCSJxY2F1eCIsCiAJfSwKIAkuaWRfdGFibGUgPQkJaWRfdGFibGUsCisJLnVzYl9kcml2ZXIgPQkJJnFjYXV4X2RyaXZlciwKIAkubnVtX3BvcnRzID0JCTEsCiB9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvc2llbWVuc19tcGkuYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9zaWVtZW5zX21waS5jCmluZGV4IGNiODE5NWMuLjc0Y2Q0Y2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9zaWVtZW5zX21waS5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9zaWVtZW5zX21waS5jCkBAIC00Miw2ICs0Miw3IEBACiAJCS5uYW1lID0JCSJzaWVtZW5zX21waSIsCiAJfSwKIAkuaWRfdGFibGUgPQkJaWRfdGFibGUsCisJLnVzYl9kcml2ZXIgPQkJJnNpZW1lbnNfdXNiX21waV9kcml2ZXIsCiAJLm51bV9wb3J0cyA9CQkxLAogfTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc2VyaWFsL3NwY3A4eDUuYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9zcGNwOHg1LmMKaW5kZXggNzY1YWE5OC4uY2JmYjcwYiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL3NwY3A4eDUuYworKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwvc3BjcDh4NS5jCkBAIC0xMzMsNyArMTMzLDcgQEAKIAogLyogaG93IGNvbWUgPz8/ICovCiAjZGVmaW5lIFVBUlRfU1RBVEUJCQkweDA4Ci0jZGVmaW5lIFVBUlRfU1RBVEVfVFJBTlNJRU5UX01BU0sJMHg3NAorI2RlZmluZSBVQVJUX1NUQVRFX1RSQU5TSUVOVF9NQVNLCTB4NzUKICNkZWZpbmUgVUFSVF9EQ0QJCQkweDAxCiAjZGVmaW5lIFVBUlRfRFNSCQkJMHgwMgogI2RlZmluZSBVQVJUX0JSRUFLX0VSUk9SCQkweDA0CkBAIC01MjUsNiArNTI1LDEwIEBACiAJCS8qIG92ZXJydW4gaXMgc3BlY2lhbCwgbm90IGFzc29jaWF0ZWQgd2l0aCBhIGNoYXIgKi8KIAkJaWYgKHN0YXR1cyAmIFVBUlRfT1ZFUlJVTl9FUlJPUikKIAkJCXR0eV9pbnNlcnRfZmxpcF9jaGFyKHR0eSwgMCwgVFRZX09WRVJSVU4pOworCisJCWlmIChzdGF0dXMgJiBVQVJUX0RDRCkKKwkJCXVzYl9zZXJpYWxfaGFuZGxlX2RjZF9jaGFuZ2UocG9ydCwgdHR5LAorCQkJCSAgIHByaXYtPmxpbmVfc3RhdHVzICYgTVNSX1NUQVRVU19MSU5FX0RDRCk7CiAJfQogCiAJdHR5X2luc2VydF9mbGlwX3N0cmluZ19maXhlZF9mbGFnKHR0eSwgZGF0YSwgdHR5X2ZsYWcsCkBAIC02NDUsNiArNjQ5LDcgQEAKIAkJLm5hbWUgPQkJIlNQQ1A4eDUiLAogCX0sCiAJLmlkX3RhYmxlCQk9IGlkX3RhYmxlLAorCS51c2JfZHJpdmVyCQk9ICZzcGNwOHg1X2RyaXZlciwKIAkubnVtX3BvcnRzCQk9IDEsCiAJLm9wZW4gCQkJPSBzcGNwOHg1X29wZW4sCiAJLmR0cl9ydHMJCT0gc3BjcDh4NV9kdHJfcnRzLApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc2VyaWFsL3RpX3VzYl8zNDEwXzUwNTIuYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC90aV91c2JfMzQxMF81MDUyLmMKaW5kZXggYjI5MDJmMy4uYTkxMDAwNCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL3RpX3VzYl8zNDEwXzUwNTIuYworKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwvdGlfdXNiXzM0MTBfNTA1Mi5jCkBAIC0zNjksOSArMzY5LDkgQEAKIAogc3RhdGljIHZvaWQgX19leGl0IHRpX2V4aXQodm9pZCkKIHsKKwl1c2JfZGVyZWdpc3RlcigmdGlfdXNiX2RyaXZlcik7CiAJdXNiX3NlcmlhbF9kZXJlZ2lzdGVyKCZ0aV8xcG9ydF9kZXZpY2UpOwogCXVzYl9zZXJpYWxfZGVyZWdpc3RlcigmdGlfMnBvcnRfZGV2aWNlKTsKLQl1c2JfZGVyZWdpc3RlcigmdGlfdXNiX2RyaXZlcik7CiB9CiAKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc2VyaWFsL3VzYi1zZXJpYWwuYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC91c2Itc2VyaWFsLmMKaW5kZXggNjk1NGRlNS4uNTQ2YTUyMSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL3VzYi1zZXJpYWwuYworKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwvdXNiLXNlcmlhbC5jCkBAIC0xMzQ0LDExICsxMzQ0LDE1IEBACiAJCXJldHVybiAtRU5PREVWOwogCiAJZml4dXBfZ2VuZXJpYyhkcml2ZXIpOwotCWlmIChkcml2ZXItPnVzYl9kcml2ZXIpCi0JCWRyaXZlci0+dXNiX2RyaXZlci0+c3VwcG9ydHNfYXV0b3N1c3BlbmQgPSAxOwogCiAJaWYgKCFkcml2ZXItPmRlc2NyaXB0aW9uKQogCQlkcml2ZXItPmRlc2NyaXB0aW9uID0gZHJpdmVyLT5kcml2ZXIubmFtZTsKKwlpZiAoIWRyaXZlci0+dXNiX2RyaXZlcikgeworCQlXQVJOKDEsICJTZXJpYWwgZHJpdmVyICVzIGhhcyBubyB1c2JfZHJpdmVyXG4iLAorCQkJCWRyaXZlci0+ZGVzY3JpcHRpb24pOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJZHJpdmVyLT51c2JfZHJpdmVyLT5zdXBwb3J0c19hdXRvc3VzcGVuZCA9IDE7CiAKIAkvKiBBZGQgdGhpcyBkZXZpY2UgdG8gb3VyIGxpc3Qgb2YgZGV2aWNlcyAqLwogCW11dGV4X2xvY2soJnRhYmxlX2xvY2spOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc2VyaWFsL3VzYl9kZWJ1Zy5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL3VzYl9kZWJ1Zy5jCmluZGV4IGYyZWQ2YTMuLjk1YTgyMTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC91c2JfZGVidWcuYworKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwvdXNiX2RlYnVnLmMKQEAgLTc1LDYgKzc1LDcgQEAKIAkJLm5hbWUgPQkJImRlYnVnIiwKIAl9LAogCS5pZF90YWJsZSA9CQlpZF90YWJsZSwKKwkudXNiX2RyaXZlciA9CQkmZGVidWdfZHJpdmVyLAogCS5udW1fcG9ydHMgPQkJMSwKIAkuYnVsa19vdXRfc2l6ZSA9CVVTQl9ERUJVR19NQVhfUEFDS0VUX1NJWkUsCiAJLmJyZWFrX2N0bCA9CQl1c2JfZGVidWdfYnJlYWtfY3RsLApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc3RvcmFnZS91bnVzdWFsX2N5cHJlc3MuaCBiL2RyaXZlcnMvdXNiL3N0b3JhZ2UvdW51c3VhbF9jeXByZXNzLmgKaW5kZXggYzg1NGZkZS4uMmM4NTUzMCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc3RvcmFnZS91bnVzdWFsX2N5cHJlc3MuaAorKysgYi9kcml2ZXJzL3VzYi9zdG9yYWdlL3VudXN1YWxfY3lwcmVzcy5oCkBAIC0zMSw0ICszMSw5IEBACiAJCSJDeXByZXNzIElTRC0zMDBMUCIsCiAJCVVTQl9TQ19DWVBfQVRBQ0IsIFVTQl9QUl9ERVZJQ0UsIE5VTEwsIDApLAogCitVTlVTVUFMX0RFViggMHgxNGNkLCAweDYxMTYsIDB4MDAwMCwgMHg5OTk5LAorCQkiU3VwZXIgVG9wIiwKKwkJIlVTQiAyLjAgIFNBVEEgQlJJREdFIiwKKwkJVVNCX1NDX0NZUF9BVEFDQiwgVVNCX1BSX0RFVklDRSwgTlVMTCwgMCksCisKICNlbmRpZiAvKiBkZWZpbmVkKENPTkZJR19VU0JfU1RPUkFHRV9DWVBSRVNTX0FUQUNCKSB8fCAuLi4gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3N0b3JhZ2UvdW51c3VhbF9kZXZzLmggYi9kcml2ZXJzL3VzYi9zdG9yYWdlL3VudXN1YWxfZGV2cy5oCmluZGV4IGZjYzFlMzIuLmMxNjAyYjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3N0b3JhZ2UvdW51c3VhbF9kZXZzLmgKKysrIGIvZHJpdmVycy91c2Ivc3RvcmFnZS91bnVzdWFsX2RldnMuaApAQCAtMTA0NCw2ICsxMDQ0LDE1IEBACiAJCVVTQl9TQ19ERVZJQ0UsIFVTQl9QUl9ERVZJQ0UsIE5VTEwsCiAJCVVTX0ZMX0JVTEszMiksCiAKKy8qIFJlcG9ydGVkIGJ5IDx0dGtzcGFtQGZyZWUuZnI+CisgKiBUaGUgZGV2aWNlIHJlcG9ydHMgYSB2ZW5kb3Itc3BlY2lmaWMgZGV2aWNlIGNsYXNzLCByZXF1aXJpbmcgYW4KKyAqIGV4cGxpY2l0IHZlbmRvci9wcm9kdWN0IG1hdGNoLgorICovCitVTlVTVUFMX0RFViggIDB4MDg1MSwgMHgxNTQyLCAweDAwMDIsIDB4MDAwMiwKKwkJIk1hZ2ljUGl4ZWwiLAorCQkiRldfT21lZ2EyIiwKKwkJVVNCX1NDX0RFVklDRSwgVVNCX1BSX0RFVklDRSwgTlVMTCwgMCksCisKIC8qIEFuZHJldyBMdW5uIDxhbmRyZXdAbHVubi5jaD4KICAqIFBhbkRpZ2l0YWwgRGlnaXRhbCBQaWN0dXJlIEZyYW1lLiBEb2VzIG5vdCBsaWtlIEFMTE9XX01FRElVTV9SRU1PVkFMCiAgKiBvbiBMVU4gNC4KQEAgLTEzODgsNiArMTM5NywxMyBAQAogCQlVU0JfU0NfREVWSUNFLCBVU0JfUFJfREVWSUNFLCBOVUxMLAogCQlVU19GTF9JR05PUkVfUkVTSURVRSApLAogCisvKiBTdWJtaXR0ZWQgYnkgTmljayBIb2xsb3dheSAqLworVU5VU1VBTF9ERVYoIDB4MGY4OCwgMHgwNDJlLCAweDAxMDAsIDB4MDEwMCwKKwkJIlZUZWNoIiwKKwkJIktpZGl6b29tIiwKKwkJVVNCX1NDX0RFVklDRSwgVVNCX1BSX0RFVklDRSwgTlVMTCwKKwkJVVNfRkxfRklYX0NBUEFDSVRZICksCisKIC8qIFJlcG9ydGVkIGJ5IE1pY2hhZWwgU3RhdHRtYW5uIDxtaWNoYWVsQHN0YXR0bWFubi5jb20+ICovCiBVTlVTVUFMX0RFViggIDB4MGZjZSwgMHhkMDA4LCAweDAwMDAsIDB4MDAwMCwKIAkJIlNvbnkgRXJpY3Nzb24iLApAQCAtMTg3Miw2ICsxODg4LDIyIEBACiAJCVVTQl9TQ19ERVZJQ0UsIFVTQl9QUl9ERVZJQ0UsIE5VTEwsCiAJCVVTX0ZMX05PX1JFQURfRElTQ19JTkZPICksCiAKKy8qIFBhdGNoIGJ5IFJpY2hhcmQgU2No/HR6IDxyLnNjaHR6QHQtb25saW5lLmRlPgorICogVGhpcyBleHRlcm5hbCBoYXJkIGRyaXZlIGVuY2xvc3VyZSB1c2VzIGEgSk1pY3JvbiBjaGlwIHdoaWNoCisgKiBuZWVkcyB0aGUgVVNfRkxfSUdOT1JFX1JFU0lEVUUgZmxhZyB0byB3b3JrIHByb3Blcmx5LiAqLworVU5VU1VBTF9ERVYoICAweDFlNjgsIDB4MDAxYiwgMHgwMDAwLCAweDAwMDAsCisJCSJUcmVrU3RvciBHbWJIICYgQ28uIEtHIiwKKwkJIkRhdGFTdGF0aW9uIG1heGkgZy51IiwKKwkJVVNCX1NDX0RFVklDRSwgVVNCX1BSX0RFVklDRSwgTlVMTCwKKwkJVVNfRkxfSUdOT1JFX1JFU0lEVUUgfCBVU19GTF9TQU5FX1NFTlNFICksCisKKy8qIFJlcG9ydGVkIGJ5IEphc3BlciBNYWNrZW56aWUgPHNjYXJsZXRwaW1wZXJuYWxAaG90bWFpbC5jb20+ICovCitVTlVTVUFMX0RFViggMHgxZTc0LCAweDQ2MjEsIDB4MDAwMCwgMHgwMDAwLAorCQkiQ29ieSBFbGVjdHJvbmljcyIsCisJCSJNUDMgUGxheWVyIiwKKwkJVVNCX1NDX0RFVklDRSwgVVNCX1BSX0RFVklDRSwgTlVMTCwKKwkJVVNfRkxfQlVMS19JR05PUkVfVEFHIHwgVVNfRkxfTUFYX1NFQ1RPUlNfNjQgKSwKKwogVU5VU1VBTF9ERVYoIDB4MjExNiwgMHgwMzIwLCAweDAwMDEsIDB4MDAwMSwKIAkJIlNUIiwKIAkJIjJBIiwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmhvc3QvbmV0LmMgYi9kcml2ZXJzL3Zob3N0L25ldC5jCmluZGV4IDliM2NhMTAuLmY2MTZjZWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmhvc3QvbmV0LmMKKysrIGIvZHJpdmVycy92aG9zdC9uZXQuYwpAQCAtMTI4LDggKzEyOCw3IEBACiAJc2l6ZV90IGhkcl9zaXplOwogCXN0cnVjdCBzb2NrZXQgKnNvY2s7CiAKLQkvKiBUT0RPOiBjaGVjayB0aGF0IHdlIGFyZSBydW5uaW5nIGZyb20gdmhvc3Rfd29ya2VyPwotCSAqIE5vdCBzdXJlIGl0J3Mgd29ydGggaXQsIGl0J3Mgc3RyYWlnaHQtZm9yd2FyZCBlbm91Z2guICovCisJLyogVE9ETzogY2hlY2sgdGhhdCB3ZSBhcmUgcnVubmluZyBmcm9tIHZob3N0X3dvcmtlcj8gKi8KIAlzb2NrID0gcmN1X2RlcmVmZXJlbmNlX2NoZWNrKHZxLT5wcml2YXRlX2RhdGEsIDEpOwogCWlmICghc29jaykKIAkJcmV0dXJuOwpAQCAtMzA2LDcgKzMwNSw4IEBACiAJc2l6ZV90IGxlbiwgdG90YWxfbGVuID0gMDsKIAlpbnQgZXJyOwogCXNpemVfdCBoZHJfc2l6ZTsKLQlzdHJ1Y3Qgc29ja2V0ICpzb2NrID0gcmN1X2RlcmVmZXJlbmNlKHZxLT5wcml2YXRlX2RhdGEpOworCS8qIFRPRE86IGNoZWNrIHRoYXQgd2UgYXJlIHJ1bm5pbmcgZnJvbSB2aG9zdF93b3JrZXI/ICovCisJc3RydWN0IHNvY2tldCAqc29jayA9IHJjdV9kZXJlZmVyZW5jZV9jaGVjayh2cS0+cHJpdmF0ZV9kYXRhLCAxKTsKIAlpZiAoIXNvY2sgfHwgc2tiX3F1ZXVlX2VtcHR5KCZzb2NrLT5zay0+c2tfcmVjZWl2ZV9xdWV1ZSkpCiAJCXJldHVybjsKIApAQCAtNDE1LDcgKzQxNSw4IEBACiAJaW50IGVyciwgaGVhZGNvdW50OwogCXNpemVfdCB2aG9zdF9obGVuLCBzb2NrX2hsZW47CiAJc2l6ZV90IHZob3N0X2xlbiwgc29ja19sZW47Ci0Jc3RydWN0IHNvY2tldCAqc29jayA9IHJjdV9kZXJlZmVyZW5jZSh2cS0+cHJpdmF0ZV9kYXRhKTsKKwkvKiBUT0RPOiBjaGVjayB0aGF0IHdlIGFyZSBydW5uaW5nIGZyb20gdmhvc3Rfd29ya2VyPyAqLworCXN0cnVjdCBzb2NrZXQgKnNvY2sgPSByY3VfZGVyZWZlcmVuY2VfY2hlY2sodnEtPnByaXZhdGVfZGF0YSwgMSk7CiAJaWYgKCFzb2NrIHx8IHNrYl9xdWV1ZV9lbXB0eSgmc29jay0+c2stPnNrX3JlY2VpdmVfcXVldWUpKQogCQlyZXR1cm47CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmhvc3Qvdmhvc3QuYyBiL2RyaXZlcnMvdmhvc3Qvdmhvc3QuYwppbmRleCAzODI0NGY1Li5hZGUwNTY4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Zob3N0L3Zob3N0LmMKKysrIGIvZHJpdmVycy92aG9zdC92aG9zdC5jCkBAIC05NywyMiArOTcsMjYgQEAKIAlyZW1vdmVfd2FpdF9xdWV1ZShwb2xsLT53cWgsICZwb2xsLT53YWl0KTsKIH0KIAorc3RhdGljIGJvb2wgdmhvc3Rfd29ya19zZXFfZG9uZShzdHJ1Y3Qgdmhvc3RfZGV2ICpkZXYsIHN0cnVjdCB2aG9zdF93b3JrICp3b3JrLAorCQkJCXVuc2lnbmVkIHNlcSkKK3sKKwlpbnQgbGVmdDsKKwlzcGluX2xvY2tfaXJxKCZkZXYtPndvcmtfbG9jayk7CisJbGVmdCA9IHNlcSAtIHdvcmstPmRvbmVfc2VxOworCXNwaW5fdW5sb2NrX2lycSgmZGV2LT53b3JrX2xvY2spOworCXJldHVybiBsZWZ0IDw9IDA7Cit9CisKIHN0YXRpYyB2b2lkIHZob3N0X3dvcmtfZmx1c2goc3RydWN0IHZob3N0X2RldiAqZGV2LCBzdHJ1Y3Qgdmhvc3Rfd29yayAqd29yaykKIHsKIAl1bnNpZ25lZCBzZXE7Ci0JaW50IGxlZnQ7CiAJaW50IGZsdXNoaW5nOwogCiAJc3Bpbl9sb2NrX2lycSgmZGV2LT53b3JrX2xvY2spOwogCXNlcSA9IHdvcmstPnF1ZXVlX3NlcTsKIAl3b3JrLT5mbHVzaGluZysrOwogCXNwaW5fdW5sb2NrX2lycSgmZGV2LT53b3JrX2xvY2spOwotCXdhaXRfZXZlbnQod29yay0+ZG9uZSwgKHsKLQkJICAgc3Bpbl9sb2NrX2lycSgmZGV2LT53b3JrX2xvY2spOwotCQkgICBsZWZ0ID0gc2VxIC0gd29yay0+ZG9uZV9zZXEgPD0gMDsKLQkJICAgc3Bpbl91bmxvY2tfaXJxKCZkZXYtPndvcmtfbG9jayk7Ci0JCSAgIGxlZnQ7Ci0JfSkpOworCXdhaXRfZXZlbnQod29yay0+ZG9uZSwgdmhvc3Rfd29ya19zZXFfZG9uZShkZXYsIHdvcmssIHNlcSkpOwogCXNwaW5fbG9ja19pcnEoJmRldi0+d29ya19sb2NrKTsKIAlmbHVzaGluZyA9IC0td29yay0+Zmx1c2hpbmc7CiAJc3Bpbl91bmxvY2tfaXJxKCZkZXYtPndvcmtfbG9jayk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Zob3N0L3Zob3N0LmggYi9kcml2ZXJzL3Zob3N0L3Zob3N0LmgKaW5kZXggMmFmNDRiNy4uYjMzNjNhZSAxMDA2NDQKLS0tIGEvZHJpdmVycy92aG9zdC92aG9zdC5oCisrKyBiL2RyaXZlcnMvdmhvc3Qvdmhvc3QuaApAQCAtMTczLDkgKzE3Myw5IEBACiB7CiAJdW5zaWduZWQgYWNrZWRfZmVhdHVyZXM7CiAKLQlhY2tlZF9mZWF0dXJlcyA9Ci0JCXJjdV9kZXJlZmVyZW5jZV9pbmRleF9jaGVjayhkZXYtPmFja2VkX2ZlYXR1cmVzLAotCQkJCQkgICAgbG9ja2RlcF9pc19oZWxkKCZkZXYtPm11dGV4KSk7CisJLyogVE9ETzogY2hlY2sgdGhhdCB3ZSBhcmUgcnVubmluZyBmcm9tIHZob3N0X3dvcmtlciBvciBkZXYgbXV0ZXggaXMKKwkgKiBoZWxkPyAqLworCWFja2VkX2ZlYXR1cmVzID0gcmN1X2RlcmVmZXJlbmNlX2luZGV4X2NoZWNrKGRldi0+YWNrZWRfZmVhdHVyZXMsIDEpOwogCXJldHVybiBhY2tlZF9mZWF0dXJlcyAmICgxIDw8IGJpdCk7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vS2NvbmZpZyBiL2RyaXZlcnMvdmlkZW8vS2NvbmZpZwppbmRleCBkOTE2YWMwLi42YmFmYjUxYiAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9LY29uZmlnCisrKyBiL2RyaXZlcnMvdmlkZW8vS2NvbmZpZwpAQCAtMTIyNyw3ICsxMjI3LDcgQEAKIAogY29uZmlnIEZCX0lOVEVMCiAJdHJpc3RhdGUgIkludGVsIDgzME0vODQ1Ry84NTJHTS84NTVHTS84NjVHLzkxNUcvOTQ1Ry85NDVHTS85NjVHLzk2NUdNIHN1cHBvcnQgKEVYUEVSSU1FTlRBTCkiCi0JZGVwZW5kcyBvbiBFWFBFUklNRU5UQUwgJiYgRkIgJiYgUENJICYmIFg4NiAmJiBBR1BfSU5URUwgJiYgRU1CRURERUQKKwlkZXBlbmRzIG9uIEVYUEVSSU1FTlRBTCAmJiBGQiAmJiBQQ0kgJiYgWDg2ICYmIEFHUF9JTlRFTCAmJiBFWFBFUlQKIAlzZWxlY3QgRkJfTU9ERV9IRUxQRVJTCiAJc2VsZWN0IEZCX0NGQl9GSUxMUkVDVAogCXNlbGVjdCBGQl9DRkJfQ09QWUFSRUEKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vYXJrZmIuYyBiL2RyaXZlcnMvdmlkZW8vYXJrZmIuYwppbmRleCBkNTgzYmVhLi4zOTFhYzkzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2Fya2ZiLmMKKysrIGIvZHJpdmVycy92aWRlby9hcmtmYi5jCkBAIC0yMyw3ICsyMyw3IEBACiAjaW5jbHVkZSA8bGludXgvc3ZnYS5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KLSNpbmNsdWRlIDxsaW51eC9jb25zb2xlLmg+IC8qIFdoeSBzaG91bGQgZmIgZHJpdmVyIGNhbGwgY29uc29sZSBmdW5jdGlvbnM/IGJlY2F1c2UgYWNxdWlyZV9jb25zb2xlX3NlbSgpICovCisjaW5jbHVkZSA8bGludXgvY29uc29sZS5oPiAvKiBXaHkgc2hvdWxkIGZiIGRyaXZlciBjYWxsIGNvbnNvbGUgZnVuY3Rpb25zPyBiZWNhdXNlIGNvbnNvbGVfbG9jaygpICovCiAjaW5jbHVkZSA8dmlkZW8vdmdhLmg+CiAKICNpZmRlZiBDT05GSUdfTVRSUgpAQCAtMTA5MSwxMiArMTA5MSwxMiBAQAogCiAJZGV2X2luZm8oaW5mby0+ZGV2aWNlLCAic3VzcGVuZFxuIik7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJbXV0ZXhfbG9jaygmKHBhci0+b3Blbl9sb2NrKSk7CiAKIAlpZiAoKHN0YXRlLmV2ZW50ID09IFBNX0VWRU5UX0ZSRUVaRSkgfHwgKHBhci0+cmVmX2NvdW50ID09IDApKSB7CiAJCW11dGV4X3VubG9jaygmKHBhci0+b3Blbl9sb2NrKSk7Ci0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAkJcmV0dXJuIDA7CiAJfQogCkBAIC0xMTA3LDcgKzExMDcsNyBAQAogCXBjaV9zZXRfcG93ZXJfc3RhdGUoZGV2LCBwY2lfY2hvb3NlX3N0YXRlKGRldiwgc3RhdGUpKTsKIAogCW11dGV4X3VubG9jaygmKHBhci0+b3Blbl9sb2NrKSk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTExMjIsNyArMTEyMiw3IEBACiAKIAlkZXZfaW5mbyhpbmZvLT5kZXZpY2UsICJyZXN1bWVcbiIpOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCW11dGV4X2xvY2soJihwYXItPm9wZW5fbG9jaykpOwogCiAJaWYgKHBhci0+cmVmX2NvdW50ID09IDApCkBAIC0xMTQxLDcgKzExNDEsNyBAQAogCiBmYWlsOgogCW11dGV4X3VubG9jaygmKHBhci0+b3Blbl9sb2NrKSk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJcmV0dXJuIDA7CiB9CiAjZWxzZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9hdHkvYXR5MTI4ZmIuYyBiL2RyaXZlcnMvdmlkZW8vYXR5L2F0eTEyOGZiLmMKaW5kZXggZGQ5ZGUyZS4uNGNiNmE1NyAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9hdHkvYXR5MTI4ZmIuYworKysgYi9kcml2ZXJzL3ZpZGVvL2F0eS9hdHkxMjhmYi5jCkBAIC0xODYwLDExICsxODYwLDExIEBACiB7CiAgICAgICAgIHN0cnVjdCBhdHkxMjhmYl9wYXIgKnBhciA9IGRhdGE7CiAKLQlpZiAodHJ5X2FjcXVpcmVfY29uc29sZV9zZW0oKSkKKwlpZiAoIWNvbnNvbGVfdHJ5bG9jaygpKQogCQlyZXR1cm47CiAJcGNpX3Jlc3RvcmVfc3RhdGUocGFyLT5wZGV2KTsKIAlhdHkxMjhfZG9fcmVzdW1lKHBhci0+cGRldik7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiB9CiAjZW5kaWYgLyogQ09ORklHX1BQQ19QTUFDICovCiAKQEAgLTI0MzgsNyArMjQzOCw3IEBACiAKIAlwcmludGsoS0VSTl9ERUJVRyAiYXR5MTI4ZmI6IHN1c3BlbmRpbmcuLi5cbiIpOwogCQotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAogCWZiX3NldF9zdXNwZW5kKGluZm8sIDEpOwogCkBAIC0yNDcwLDcgKzI0NzAsNyBAQAogCWlmIChzdGF0ZS5ldmVudCAhPSBQTV9FVkVOVF9PTikKIAkJYXR5MTI4X3NldF9zdXNwZW5kKHBhciwgMSk7CiAKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCXBkZXYtPmRldi5wb3dlci5wb3dlcl9zdGF0ZSA9IHN0YXRlOwogCkBAIC0yNTI3LDkgKzI1MjcsOSBAQAogewogCWludCByYzsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlyYyA9IGF0eTEyOF9kb19yZXN1bWUocGRldik7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAlyZXR1cm4gcmM7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2F0eS9hdHlmYl9iYXNlLmMgYi9kcml2ZXJzL3ZpZGVvL2F0eS9hdHlmYl9iYXNlLmMKaW5kZXggNzY3YWI0Zi4uOTRlMjkzZiAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9hdHkvYXR5ZmJfYmFzZS5jCisrKyBiL2RyaXZlcnMvdmlkZW8vYXR5L2F0eWZiX2Jhc2UuYwpAQCAtMjA2OSw3ICsyMDY5LDcgQEAKIAlpZiAoc3RhdGUuZXZlbnQgPT0gcGRldi0+ZGV2LnBvd2VyLnBvd2VyX3N0YXRlLmV2ZW50KQogCQlyZXR1cm4gMDsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAogCWZiX3NldF9zdXNwZW5kKGluZm8sIDEpOwogCkBAIC0yMDk3LDE0ICsyMDk3LDE0IEBACiAJCXBhci0+bG9ja19ibGFuayA9IDA7CiAJCWF0eWZiX2JsYW5rKEZCX0JMQU5LX1VOQkxBTkssIGluZm8pOwogCQlmYl9zZXRfc3VzcGVuZChpbmZvLCAwKTsKLQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX3VubG9jaygpOwogCQlyZXR1cm4gLUVJTzsKIAl9CiAjZWxzZQogCXBjaV9zZXRfcG93ZXJfc3RhdGUocGRldiwgcGNpX2Nob29zZV9zdGF0ZShwZGV2LCBzdGF0ZSkpOwogI2VuZGlmCiAKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCXBkZXYtPmRldi5wb3dlci5wb3dlcl9zdGF0ZSA9IHN0YXRlOwogCkBAIC0yMTMzLDcgKzIxMzMsNyBAQAogCWlmIChwZGV2LT5kZXYucG93ZXIucG93ZXJfc3RhdGUuZXZlbnQgPT0gUE1fRVZFTlRfT04pCiAJCXJldHVybiAwOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCiAJLyoKIAkgKiBQQ0kgc3RhdGUgd2lsbCBoYXZlIGJlZW4gcmVzdG9yZWQgYnkgdGhlIGNvcmUsIHNvCkBAIC0yMTYxLDcgKzIxNjEsNyBAQAogCXBhci0+bG9ja19ibGFuayA9IDA7CiAJYXR5ZmJfYmxhbmsoRkJfQkxBTktfVU5CTEFOSywgaW5mbyk7CiAKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCXBkZXYtPmRldi5wb3dlci5wb3dlcl9zdGF0ZSA9IFBNU0dfT047CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vYXR5L3JhZGVvbl9wbS5jIGIvZHJpdmVycy92aWRlby9hdHkvcmFkZW9uX3BtLmMKaW5kZXggYzRlMTc2NC4uOTJiZGE1OCAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9hdHkvcmFkZW9uX3BtLmMKKysrIGIvZHJpdmVycy92aWRlby9hdHkvcmFkZW9uX3BtLmMKQEAgLTI2MjYsNyArMjYyNiw3IEBACiAJCWdvdG8gZG9uZTsKIAl9CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAKIAlmYl9zZXRfc3VzcGVuZChpbmZvLCAxKTsKIApAQCAtMjY5MCw3ICsyNjkwLDcgQEAKIAlpZiAocmluZm8tPnBtX21vZGUgJiByYWRlb25fcG1fZDIpCiAJCXJhZGVvbl9zZXRfc3VzcGVuZChyaW5mbywgMSk7CiAKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogIGRvbmU6CiAJcGRldi0+ZGV2LnBvd2VyLnBvd2VyX3N0YXRlID0gbWVzZzsKQEAgLTI3MTUsMTAgKzI3MTUsMTAgQEAKIAkJcmV0dXJuIDA7CiAKIAlpZiAocmluZm8tPm5vX3NjaGVkdWxlKSB7Ci0JCWlmICh0cnlfYWNxdWlyZV9jb25zb2xlX3NlbSgpKQorCQlpZiAoIWNvbnNvbGVfdHJ5bG9jaygpKQogCQkJcmV0dXJuIDA7CiAJfSBlbHNlCi0JCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV9sb2NrKCk7CiAKIAlwcmludGsoS0VSTl9ERUJVRyAicmFkZW9uZmIgKCVzKTogcmVzdW1pbmcgZnJvbSBzdGF0ZTogJWQuLi5cbiIsCiAJICAgICAgIHBjaV9uYW1lKHBkZXYpLCBwZGV2LT5kZXYucG93ZXIucG93ZXJfc3RhdGUuZXZlbnQpOwpAQCAtMjc4Myw3ICsyNzgzLDcgQEAKIAlwZGV2LT5kZXYucG93ZXIucG93ZXJfc3RhdGUgPSBQTVNHX09OOwogCiAgYmFpbDoKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCXJldHVybiByYzsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vYmFja2xpZ2h0Lzg4cG04NjB4X2JsLmMgYi9kcml2ZXJzL3ZpZGVvL2JhY2tsaWdodC84OHBtODYweF9ibC5jCmluZGV4IGM3ODljNDYuLmIyMjQzOTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vYmFja2xpZ2h0Lzg4cG04NjB4X2JsLmMKKysrIGIvZHJpdmVycy92aWRlby9iYWNrbGlnaHQvODhwbTg2MHhfYmwuYwpAQCAtMjEsNyArMjEsNyBAQAogI2RlZmluZSBNQVhfQlJJR0hUTkVTUwkJKDB4RkYpCiAjZGVmaW5lIE1JTl9CUklHSFRORVNTCQkoMCkKIAotI2RlZmluZSBDVVJSRU5UX01BU0sJCSgweDFGIDw8IDEpCisjZGVmaW5lIENVUlJFTlRfQklUTUFTSwkJKDB4MUYgPDwgMSkKIAogc3RydWN0IHBtODYweF9iYWNrbGlnaHRfZGF0YSB7CiAJc3RydWN0IHBtODYweF9jaGlwICpjaGlwOwpAQCAtODUsNyArODUsNyBAQAogCWlmICgoZGF0YS0+Y3VycmVudF9icmlnaHRuZXNzID09IDApICYmIGJyaWdodG5lc3MpIHsKIAkJaWYgKGRhdGEtPmlzZXQpIHsKIAkJCXJldCA9IHBtODYweF9zZXRfYml0cyhkYXRhLT5pMmMsIHdsZWRfaWRjKGRhdGEtPnBvcnQpLAotCQkJCQkgICAgICBDVVJSRU5UX01BU0ssIGRhdGEtPmlzZXQpOworCQkJCQkgICAgICBDVVJSRU5UX0JJVE1BU0ssIGRhdGEtPmlzZXQpOwogCQkJaWYgKHJldCA8IDApCiAJCQkJZ290byBvdXQ7CiAJCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vYmY1MzctbHEwMzUuYyBiL2RyaXZlcnMvdmlkZW8vYmY1MzctbHEwMzUuYwppbmRleCAxOGM1MDc4Li40N2MyMWZiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2JmNTM3LWxxMDM1LmMKKysrIGIvZHJpdmVycy92aWRlby9iZjUzNy1scTAzNS5jCkBAIC02OTYsNiArNjk2LDcgQEAKIHsKIAlzdHJ1Y3QgYmFja2xpZ2h0X3Byb3BlcnRpZXMgcHJvcHM7CiAJZG1hX2FkZHJfdCBkbWFfaGFuZGxlOworCWludCByZXQ7CiAKIAlpZiAocmVxdWVzdF9kbWEoQ0hfUFBJLCBLQlVJTERfTU9ETkFNRSkpIHsKIAkJcHJfZXJyKCJjb3VsZG4ndCByZXF1ZXN0IFBQSSBETUFcbiIpOwpAQCAtNzA0LDE3ICs3MDUsMTYgQEAKIAogCWlmIChyZXF1ZXN0X3BvcnRzKCkpIHsKIAkJcHJfZXJyKCJjb3VsZG4ndCByZXF1ZXN0IGdwaW8gcG9ydFxuIik7Ci0JCWZyZWVfZG1hKENIX1BQSSk7Ci0JCXJldHVybiAtRUZBVUxUOworCQlyZXQgPSAtRUZBVUxUOworCQlnb3RvIG91dF9wb3J0czsKIAl9CiAKIAlmYl9idWZmZXIgPSBkbWFfYWxsb2NfY29oZXJlbnQoTlVMTCwgVE9UQUxfVklERU9fTUVNX1NJWkUsCiAJCQkJICAgICAgICZkbWFfaGFuZGxlLCBHRlBfS0VSTkVMKTsKIAlpZiAoZmJfYnVmZmVyID09IE5VTEwpIHsKIAkJcHJfZXJyKCJjb3VsZG4ndCBhbGxvY2F0ZSBkbWEgYnVmZmVyXG4iKTsKLQkJZnJlZV9kbWEoQ0hfUFBJKTsKLQkJZnJlZV9wb3J0cygpOwotCQlyZXR1cm4gLUVOT01FTTsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBvdXRfZG1hX2NvaGVyZW50OwogCX0KIAogCWlmIChMMV9EQVRBX0FfTEVOR1RIKQpAQCAtNzI1LDEwICs3MjUsOCBAQAogCiAJaWYgKGRtYV9kZXNjX3RhYmxlID09IE5VTEwpIHsKIAkJcHJfZXJyKCJjb3VsZG4ndCBhbGxvY2F0ZSBkbWEgZGVzY3JpcHRvclxuIik7Ci0JCWZyZWVfZG1hKENIX1BQSSk7Ci0JCWZyZWVfcG9ydHMoKTsKLQkJZG1hX2ZyZWVfY29oZXJlbnQoTlVMTCwgVE9UQUxfVklERU9fTUVNX1NJWkUsIGZiX2J1ZmZlciwgMCk7Ci0JCXJldHVybiAtRU5PTUVNOworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIG91dF90YWJsZTsKIAl9CiAKIAliZmluX2xxMDM1X2ZiLnNjcmVlbl9iYXNlID0gKHZvaWQgKilmYl9idWZmZXI7CkBAIC03NzEsMzEgKzc2OSwyMSBAQAogCWJmaW5fbHEwMzVfZmIucHNldWRvX3BhbGV0dGUgPSBremFsbG9jKHNpemVvZih1MzIpICogMTYsIEdGUF9LRVJORUwpOwogCWlmIChiZmluX2xxMDM1X2ZiLnBzZXVkb19wYWxldHRlID09IE5VTEwpIHsKIAkJcHJfZXJyKCJmYWlsZWQgdG8gYWxsb2NhdGUgcHNldWRvX3BhbGV0dGVcbiIpOwotCQlmcmVlX2RtYShDSF9QUEkpOwotCQlmcmVlX3BvcnRzKCk7Ci0JCWRtYV9mcmVlX2NvaGVyZW50KE5VTEwsIFRPVEFMX1ZJREVPX01FTV9TSVpFLCBmYl9idWZmZXIsIDApOwotCQlyZXR1cm4gLUVOT01FTTsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBvdXRfcGFsZXR0ZTsKIAl9CiAKIAlpZiAoZmJfYWxsb2NfY21hcCgmYmZpbl9scTAzNV9mYi5jbWFwLCBOQlJfUEFMRVRURSwgMCkgPCAwKSB7CiAJCXByX2VycigiZmFpbGVkIHRvIGFsbG9jYXRlIGNvbG9ybWFwICglZCBlbnRyaWVzKVxuIiwKIAkJCU5CUl9QQUxFVFRFKTsKLQkJZnJlZV9kbWEoQ0hfUFBJKTsKLQkJZnJlZV9wb3J0cygpOwotCQlkbWFfZnJlZV9jb2hlcmVudChOVUxMLCBUT1RBTF9WSURFT19NRU1fU0laRSwgZmJfYnVmZmVyLCAwKTsKLQkJa2ZyZWUoYmZpbl9scTAzNV9mYi5wc2V1ZG9fcGFsZXR0ZSk7Ci0JCXJldHVybiAtRUZBVUxUOworCQlyZXQgPSAtRUZBVUxUOworCQlnb3RvIG91dF9jbWFwOwogCX0KIAogCWlmIChyZWdpc3Rlcl9mcmFtZWJ1ZmZlcigmYmZpbl9scTAzNV9mYikgPCAwKSB7CiAJCXByX2VycigidW5hYmxlIHRvIHJlZ2lzdGVyIGZyYW1lYnVmZmVyXG4iKTsKLQkJZnJlZV9kbWEoQ0hfUFBJKTsKLQkJZnJlZV9wb3J0cygpOwotCQlkbWFfZnJlZV9jb2hlcmVudChOVUxMLCBUT1RBTF9WSURFT19NRU1fU0laRSwgZmJfYnVmZmVyLCAwKTsKLQkJZmJfYnVmZmVyID0gTlVMTDsKLQkJa2ZyZWUoYmZpbl9scTAzNV9mYi5wc2V1ZG9fcGFsZXR0ZSk7Ci0JCWZiX2RlYWxsb2NfY21hcCgmYmZpbl9scTAzNV9mYi5jbWFwKTsKLQkJcmV0dXJuIC1FSU5WQUw7CisJCXJldCA9IC1FSU5WQUw7CisJCWdvdG8gb3V0X3JlZzsKIAl9CiAKIAlpMmNfYWRkX2RyaXZlcigmYWQ1MjgwX2RyaXZlcik7CkBAIC04MDcsMTEgKzc5NSwzMSBAQAogCiAJbGNkX2RldiA9IGxjZF9kZXZpY2VfcmVnaXN0ZXIoS0JVSUxEX01PRE5BTUUsICZwZGV2LT5kZXYsIE5VTEwsCiAJCQkJICAgICAgJmJmaW5fbGNkX29wcyk7CisJaWYgKElTX0VSUihsY2RfZGV2KSkgeworCQlwcl9lcnIoInVuYWJsZSB0byByZWdpc3RlciBsY2RcbiIpOworCQlyZXQgPSBQVFJfRVJSKGxjZF9kZXYpOworCQlnb3RvIG91dF9sY2Q7CisJfQogCWxjZF9kZXYtPnByb3BzLm1heF9jb250cmFzdCA9IDI1NSwKIAogCXByX2luZm8oImluaXRpYWxpemVkIik7CiAKIAlyZXR1cm4gMDsKK291dF9sY2Q6CisJdW5yZWdpc3Rlcl9mcmFtZWJ1ZmZlcigmYmZpbl9scTAzNV9mYik7CitvdXRfcmVnOgorCWZiX2RlYWxsb2NfY21hcCgmYmZpbl9scTAzNV9mYi5jbWFwKTsKK291dF9jbWFwOgorCWtmcmVlKGJmaW5fbHEwMzVfZmIucHNldWRvX3BhbGV0dGUpOworb3V0X3BhbGV0dGU6CitvdXRfdGFibGU6CisJZG1hX2ZyZWVfY29oZXJlbnQoTlVMTCwgVE9UQUxfVklERU9fTUVNX1NJWkUsIGZiX2J1ZmZlciwgMCk7CisJZmJfYnVmZmVyID0gTlVMTDsKK291dF9kbWFfY29oZXJlbnQ6CisJZnJlZV9wb3J0cygpOworb3V0X3BvcnRzOgorCWZyZWVfZG1hKENIX1BQSSk7CisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIGludCBfX2RldmV4aXQgYmZpbl9scTAzNV9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vY2hpcHNmYi5jIGIvZHJpdmVycy92aWRlby9jaGlwc2ZiLmMKaW5kZXggZDYzN2UxZi4uY2ZmNzQyYSAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9jaGlwc2ZiLmMKKysrIGIvZHJpdmVycy92aWRlby9jaGlwc2ZiLmMKQEAgLTQ2MCwxMCArNDYwLDEwIEBACiAJaWYgKCEoc3RhdGUuZXZlbnQgJiBQTV9FVkVOVF9TTEVFUCkpCiAJCWdvdG8gZG9uZTsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAljaGlwc2ZiX2JsYW5rKDEsIHApOwogCWZiX3NldF9zdXNwZW5kKHAsIDEpOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogIGRvbmU6CiAJcGRldi0+ZGV2LnBvd2VyLnBvd2VyX3N0YXRlID0gc3RhdGU7CiAJcmV0dXJuIDA7CkBAIC00NzMsMTAgKzQ3MywxMCBAQAogewogICAgICAgICBzdHJ1Y3QgZmJfaW5mbyAqcCA9IHBjaV9nZXRfZHJ2ZGF0YShwZGV2KTsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlmYl9zZXRfc3VzcGVuZChwLCAwKTsKIAljaGlwc2ZiX2JsYW5rKDAsIHApOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCiAJcGRldi0+ZGV2LnBvd2VyLnBvd2VyX3N0YXRlID0gUE1TR19PTjsKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vY29uc29sZS9LY29uZmlnIGIvZHJpdmVycy92aWRlby9jb25zb2xlL0tjb25maWcKaW5kZXggNWEzNWYyMi4uMjIwOWUzNSAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9jb25zb2xlL0tjb25maWcKKysrIGIvZHJpdmVycy92aWRlby9jb25zb2xlL0tjb25maWcKQEAgLTUsNyArNSw3IEBACiBtZW51ICJDb25zb2xlIGRpc3BsYXkgZHJpdmVyIHN1cHBvcnQiCiAKIGNvbmZpZyBWR0FfQ09OU09MRQotCWJvb2wgIlZHQSB0ZXh0IGNvbnNvbGUiIGlmIEVNQkVEREVEIHx8ICFYODYKKwlib29sICJWR0EgdGV4dCBjb25zb2xlIiBpZiBFWFBFUlQgfHwgIVg4NgogCWRlcGVuZHMgb24gITR4eCAmJiAhOHh4ICYmICFTUEFSQyAmJiAhTTY4SyAmJiAhUEFSSVNDICYmICFGUlYgJiYgIVNVUEVSSCAmJiAhQkxBQ0tGSU4gJiYgIUFWUjMyICYmICFNTjEwMzAwICYmICghQVJNIHx8IEFSQ0hfRk9PVEJSSURHRSB8fCBBUkNIX0lOVEVHUkFUT1IgfHwgQVJDSF9ORVRXSU5ERVIpCiAJZGVmYXVsdCB5CiAJaGVscApkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9jb25zb2xlL2ZiY29uLmMgYi9kcml2ZXJzL3ZpZGVvL2NvbnNvbGUvZmJjb24uYwppbmRleCA3Y2NjOTY3Li45YzA5MmI4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2NvbnNvbGUvZmJjb24uYworKysgYi9kcml2ZXJzL3ZpZGVvL2NvbnNvbGUvZmJjb24uYwpAQCAtMzc1LDE0ICszNzUsMTQgQEAKIAlpbnQgYzsKIAlpbnQgbW9kZTsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlpZiAob3BzICYmIG9wcy0+Y3VycmNvbiAhPSAtMSkKIAkJdmMgPSB2Y19jb25zW29wcy0+Y3VycmNvbl0uZDsKIAogCWlmICghdmMgfHwgIUNPTl9JU19WSVNJQkxFKHZjKSB8fAogIAkgICAgcmVnaXN0ZXJlZF9mYltjb24yZmJfbWFwW3ZjLT52Y19udW1dXSAhPSBpbmZvIHx8CiAJICAgIHZjLT52Y19kZWNjbSAhPSAxKSB7Ci0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtMzkyLDcgKzM5Miw3IEBACiAJCUNNX0VSQVNFIDogQ01fRFJBVzsKIAlvcHMtPmN1cnNvcih2YywgaW5mbywgbW9kZSwgc29mdGJhY2tfbGluZXMsIGdldF9jb2xvcih2YywgaW5mbywgYywgMSksCiAJCSAgICBnZXRfY29sb3IodmMsIGluZm8sIGMsIDApKTsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIH0KIAogc3RhdGljIHZvaWQgY3Vyc29yX3RpbWVyX2hhbmRsZXIodW5zaWduZWQgbG9uZyBkZXZfYWRkcikKQEAgLTgzNiw3ICs4MzYsNyBAQAogCiAJZm91bmQgPSBzZWFyY2hfZmJfaW5fbWFwKG5ld2lkeCk7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJY29uMmZiX21hcFt1bml0XSA9IG5ld2lkeDsKIAlpZiAoIWVyciAmJiAhZm91bmQpCiAgCQllcnIgPSBjb24yZmJfYWNxdWlyZV9uZXdpbmZvKHZjLCBpbmZvLCB1bml0LCBvbGRpZHgpOwpAQCAtODYzLDcgKzg2Myw3IEBACiAJaWYgKCFzZWFyY2hfZmJfaW5fbWFwKGluZm9faWR4KSkKIAkJaW5mb19pZHggPSBuZXdpZHg7CiAKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKICAJcmV0dXJuIGVycjsKIH0KIApAQCAtMzMyMSw3ICszMzIxLDcgQEAKIAlpZiAoZmJjb25faGFzX2V4aXRlZCkKIAkJcmV0dXJuIGNvdW50OwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWlkeCA9IGNvbjJmYl9tYXBbZmdfY29uc29sZV07CiAKIAlpZiAoaWR4ID09IC0xIHx8IHJlZ2lzdGVyZWRfZmJbaWR4XSA9PSBOVUxMKQpAQCAtMzMzMSw3ICszMzMxLDcgQEAKIAlyb3RhdGUgPSBzaW1wbGVfc3RydG91bChidWYsIGxhc3QsIDApOwogCWZiY29uX3JvdGF0ZShpbmZvLCByb3RhdGUpOwogZXJyOgotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCXJldHVybiBjb3VudDsKIH0KIApAQCAtMzM0Niw3ICszMzQ2LDcgQEAKIAlpZiAoZmJjb25faGFzX2V4aXRlZCkKIAkJcmV0dXJuIGNvdW50OwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWlkeCA9IGNvbjJmYl9tYXBbZmdfY29uc29sZV07CiAKIAlpZiAoaWR4ID09IC0xIHx8IHJlZ2lzdGVyZWRfZmJbaWR4XSA9PSBOVUxMKQpAQCAtMzM1Niw3ICszMzU2LDcgQEAKIAlyb3RhdGUgPSBzaW1wbGVfc3RydG91bChidWYsIGxhc3QsIDApOwogCWZiY29uX3JvdGF0ZV9hbGwoaW5mbywgcm90YXRlKTsKIGVycjoKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAlyZXR1cm4gY291bnQ7CiB9CiAKQEAgLTMzNjksNyArMzM2OSw3IEBACiAJaWYgKGZiY29uX2hhc19leGl0ZWQpCiAJCXJldHVybiAwOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWlkeCA9IGNvbjJmYl9tYXBbZmdfY29uc29sZV07CiAKIAlpZiAoaWR4ID09IC0xIHx8IHJlZ2lzdGVyZWRfZmJbaWR4XSA9PSBOVUxMKQpAQCAtMzM3OCw3ICszMzc4LDcgQEAKIAlpbmZvID0gcmVnaXN0ZXJlZF9mYltpZHhdOwogCXJvdGF0ZSA9IGZiY29uX2dldF9yb3RhdGUoaW5mbyk7CiBlcnI6Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJcmV0dXJuIHNucHJpbnRmKGJ1ZiwgUEFHRV9TSVpFLCAiJWRcbiIsIHJvdGF0ZSk7CiB9CiAKQEAgLTMzOTIsNyArMzM5Miw3IEBACiAJaWYgKGZiY29uX2hhc19leGl0ZWQpCiAJCXJldHVybiAwOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWlkeCA9IGNvbjJmYl9tYXBbZmdfY29uc29sZV07CiAKIAlpZiAoaWR4ID09IC0xIHx8IHJlZ2lzdGVyZWRfZmJbaWR4XSA9PSBOVUxMKQpAQCAtMzQwNiw3ICszNDA2LDcgQEAKIAogCWJsaW5rID0gKG9wcy0+ZmxhZ3MgJiBGQkNPTl9GTEFHU19DVVJTT1JfVElNRVIpID8gMSA6IDA7CiBlcnI6Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJcmV0dXJuIHNucHJpbnRmKGJ1ZiwgUEFHRV9TSVpFLCAiJWRcbiIsIGJsaW5rKTsKIH0KIApAQCAtMzQyMSw3ICszNDIxLDcgQEAKIAlpZiAoZmJjb25faGFzX2V4aXRlZCkKIAkJcmV0dXJuIGNvdW50OwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWlkeCA9IGNvbjJmYl9tYXBbZmdfY29uc29sZV07CiAKIAlpZiAoaWR4ID09IC0xIHx8IHJlZ2lzdGVyZWRfZmJbaWR4XSA9PSBOVUxMKQpAQCAtMzQ0Myw3ICszNDQzLDcgQEAKIAl9CiAKIGVycjoKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAlyZXR1cm4gY291bnQ7CiB9CiAKQEAgLTM0ODIsNyArMzQ4Miw3IEBACiAJaWYgKG51bV9yZWdpc3RlcmVkX2ZiKSB7CiAJCWludCBpOwogCi0JCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV9sb2NrKCk7CiAKIAkJZm9yIChpID0gMDsgaSA8IEZCX01BWDsgaSsrKSB7CiAJCQlpZiAocmVnaXN0ZXJlZF9mYltpXSAhPSBOVUxMKSB7CkBAIC0zNDkxLDcgKzM0OTEsNyBAQAogCQkJfQogCQl9CiAKLQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX3VubG9jaygpOwogCQlmYmNvbl90YWtlb3ZlcigwKTsKIAl9CiB9CkBAIC0zNTUyLDcgKzM1NTIsNyBAQAogewogCWludCBpOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWZiX3JlZ2lzdGVyX2NsaWVudCgmZmJjb25fZXZlbnRfbm90aWZpZXIpOwogCWZiY29uX2RldmljZSA9IGRldmljZV9jcmVhdGUoZmJfY2xhc3MsIE5VTEwsIE1LREVWKDAsIDApLCBOVUxMLAogCQkJCSAgICAgImZiY29uIik7CkBAIC0zNTY4LDcgKzM1NjgsNyBAQAogCWZvciAoaSA9IDA7IGkgPCBNQVhfTlJfQ09OU09MRVM7IGkrKykKIAkJY29uMmZiX21hcFtpXSA9IC0xOwogCi0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJZmJjb25fc3RhcnQoKTsKIAlyZXR1cm4gMDsKIH0KQEAgLTM1OTEsMTIgKzM1OTEsMTIgQEAKIAogc3RhdGljIHZvaWQgX19leGl0IGZiX2NvbnNvbGVfZXhpdCh2b2lkKQogewotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlmYl91bnJlZ2lzdGVyX2NsaWVudCgmZmJjb25fZXZlbnRfbm90aWZpZXIpOwogCWZiY29uX2RlaW5pdF9kZXZpY2UoKTsKIAlkZXZpY2VfZGVzdHJveShmYl9jbGFzcywgTUtERVYoMCwgMCkpOwogCWZiY29uX2V4aXQoKTsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAl1bnJlZ2lzdGVyX2Nvbl9kcml2ZXIoJmZiX2Nvbik7CiB9CQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2NvbnNvbGUvdmdhY29uLmMgYi9kcml2ZXJzL3ZpZGVvL2NvbnNvbGUvdmdhY29uLmMKaW5kZXggYzk3NDkxYi4uOTE1ZmQ3NCAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9jb25zb2xlL3ZnYWNvbi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vY29uc29sZS92Z2Fjb24uYwpAQCAtMjAyLDExICsyMDIsNyBAQAogCX0KIH0KIAotLyoKLSAqIENhbGxlZCBvbmx5IGR1aW5nIGluaXQgc28gY2FsbCBvZiBhbGxvY19ib290bWVuIGlzIG9rLgotICogTWFya2VkIF9faW5pdF9yZWZvayB0byBzaWxlbmNlIG1vZHBvc3QuCi0gKi8KLXN0YXRpYyB2b2lkIF9faW5pdF9yZWZvayB2Z2Fjb25fc2Nyb2xsYmFja19zdGFydHVwKHZvaWQpCitzdGF0aWMgdm9pZCB2Z2Fjb25fc2Nyb2xsYmFja19zdGFydHVwKHZvaWQpCiB7CiAJdmdhY29uX3Njcm9sbGJhY2sgPSBrY2FsbG9jKENPTkZJR19WR0FDT05fU09GVF9TQ1JPTExCQUNLX1NJWkUsIDEwMjQsIEdGUF9OT1dBSVQpOwogCXZnYWNvbl9zY3JvbGxiYWNrX2luaXQodmdhX3ZpZGVvX251bV9jb2x1bW5zICogMik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2RhOHh4LWZiLmMgYi9kcml2ZXJzL3ZpZGVvL2RhOHh4LWZiLmMKaW5kZXggYzI2NWFlZC4uOGQ2MWVmOSAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9kYTh4eC1mYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vZGE4eHgtZmIuYwpAQCAtMTA5Miw5ICsxMDkyLDEwIEBACiAKIGlycV9mcmVxOgogI2lmZGVmIENPTkZJR19DUFVfRlJFUQorCWxjZF9kYTh4eF9jcHVmcmVxX2RlcmVnaXN0ZXIocGFyKTsKKyNlbmRpZgogZXJyX2NwdV9mcmVxOgogCXVucmVnaXN0ZXJfZnJhbWVidWZmZXIoZGE4eHhfZmJfaW5mbyk7Ci0jZW5kaWYKIAogZXJyX2RlYWxsb2NfY21hcDoKIAlmYl9kZWFsbG9jX2NtYXAoJmRhOHh4X2ZiX2luZm8tPmNtYXApOwpAQCAtMTEzMCwxNCArMTEzMSwxNCBAQAogCXN0cnVjdCBmYl9pbmZvICppbmZvID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEoZGV2KTsKIAlzdHJ1Y3QgZGE4eHhfZmJfcGFyICpwYXIgPSBpbmZvLT5wYXI7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJaWYgKHBhci0+cGFuZWxfcG93ZXJfY3RybCkKIAkJcGFyLT5wYW5lbF9wb3dlcl9jdHJsKDApOwogCiAJZmJfc2V0X3N1c3BlbmQoaW5mbywgMSk7CiAJbGNkX2Rpc2FibGVfcmFzdGVyKCk7CiAJY2xrX2Rpc2FibGUocGFyLT5sY2RjX2Nsayk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTExNDYsMTQgKzExNDcsMTQgQEAKIAlzdHJ1Y3QgZmJfaW5mbyAqaW5mbyA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKGRldik7CiAJc3RydWN0IGRhOHh4X2ZiX3BhciAqcGFyID0gaW5mby0+cGFyOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWlmIChwYXItPnBhbmVsX3Bvd2VyX2N0cmwpCiAJCXBhci0+cGFuZWxfcG93ZXJfY3RybCgxKTsKIAogCWNsa19lbmFibGUocGFyLT5sY2RjX2Nsayk7CiAJbGNkX2VuYWJsZV9yYXN0ZXIoKTsKIAlmYl9zZXRfc3VzcGVuZChpbmZvLCAwKTsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9lcDkzeHgtZmIuYyBiL2RyaXZlcnMvdmlkZW8vZXA5M3h4LWZiLmMKaW5kZXggMGM5OWRlMC4uYjM1OGQwNCAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9lcDkzeHgtZmIuYworKysgYi9kcml2ZXJzL3ZpZGVvL2VwOTN4eC1mYi5jCkBAIC00ODMsNyArNDgzLDcgQEAKIAkJCQkgIGluZm8tPnNjcmVlbl9iYXNlLCBpbmZvLT5maXguc21lbV9zdGFydCk7CiB9CiAKLXN0YXRpYyBpbnQgX19pbml0IGVwOTN4eGZiX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCitzdGF0aWMgaW50IF9fZGV2aW5pdCBlcDkzeHhmYl9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogewogCXN0cnVjdCBlcDkzeHhmYl9tYWNoX2luZm8gKm1hY2hfaW5mbyA9IHBkZXYtPmRldi5wbGF0Zm9ybV9kYXRhOwogCXN0cnVjdCBmYl9pbmZvICppbmZvOwpAQCAtNTk4LDcgKzU5OCw3IEBACiAJcmV0dXJuIGVycjsKIH0KIAotc3RhdGljIGludCBlcDkzeHhmYl9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3N0YXRpYyBpbnQgX19kZXZleGl0IGVwOTN4eGZiX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogewogCXN0cnVjdCBmYl9pbmZvICppbmZvID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7CiAJc3RydWN0IGVwOTN4eF9mYmkgKmZiaSA9IGluZm8tPnBhcjsKQEAgLTYyMiw3ICs2MjIsNyBAQAogCiBzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBlcDkzeHhmYl9kcml2ZXIgPSB7CiAJLnByb2JlCQk9IGVwOTN4eGZiX3Byb2JlLAotCS5yZW1vdmUJCT0gZXA5M3h4ZmJfcmVtb3ZlLAorCS5yZW1vdmUJCT0gX19kZXZleGl0X3AoZXA5M3h4ZmJfcmVtb3ZlKSwKIAkuZHJpdmVyID0gewogCQkubmFtZQk9ICJlcDkzeHgtZmIiLAogCQkub3duZXIJPSBUSElTX01PRFVMRSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vZmJtZW0uYyBiL2RyaXZlcnMvdmlkZW8vZmJtZW0uYwppbmRleCA0YWMxMjAxLi5lMmJmOTUzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2ZibWVtLmMKKysrIGIvZHJpdmVycy92aWRlby9mYm1lbS5jCkBAIC0xMDM2LDExICsxMDM2LDExIEBACiAJCQlyZXR1cm4gLUVGQVVMVDsKIAkJaWYgKCFsb2NrX2ZiX2luZm8oaW5mbykpCiAJCQlyZXR1cm4gLUVOT0RFVjsKLQkJYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX2xvY2soKTsKIAkJaW5mby0+ZmxhZ3MgfD0gRkJJTkZPX01JU0NfVVNFUkVWRU5UOwogCQlyZXQgPSBmYl9zZXRfdmFyKGluZm8sICZ2YXIpOwogCQlpbmZvLT5mbGFncyAmPSB+RkJJTkZPX01JU0NfVVNFUkVWRU5UOwotCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfdW5sb2NrKCk7CiAJCXVubG9ja19mYl9pbmZvKGluZm8pOwogCQlpZiAoIXJldCAmJiBjb3B5X3RvX3VzZXIoYXJncCwgJnZhciwgc2l6ZW9mKHZhcikpKQogCQkJcmV0ID0gLUVGQVVMVDsKQEAgLTEwNzIsOSArMTA3Miw5IEBACiAJCQlyZXR1cm4gLUVGQVVMVDsKIAkJaWYgKCFsb2NrX2ZiX2luZm8oaW5mbykpCiAJCQlyZXR1cm4gLUVOT0RFVjsKLQkJYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX2xvY2soKTsKIAkJcmV0ID0gZmJfcGFuX2Rpc3BsYXkoaW5mbywgJnZhcik7Ci0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAkJdW5sb2NrX2ZiX2luZm8oaW5mbyk7CiAJCWlmIChyZXQgPT0gMCAmJiBjb3B5X3RvX3VzZXIoYXJncCwgJnZhciwgc2l6ZW9mKHZhcikpKQogCQkJcmV0dXJuIC1FRkFVTFQ7CkBAIC0xMTE5LDExICsxMTE5LDExIEBACiAJY2FzZSBGQklPQkxBTks6CiAJCWlmICghbG9ja19mYl9pbmZvKGluZm8pKQogCQkJcmV0dXJuIC1FTk9ERVY7Ci0JCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV9sb2NrKCk7CiAJCWluZm8tPmZsYWdzIHw9IEZCSU5GT19NSVNDX1VTRVJFVkVOVDsKIAkJcmV0ID0gZmJfYmxhbmsoaW5mbywgYXJnKTsKIAkJaW5mby0+ZmxhZ3MgJj0gfkZCSU5GT19NSVNDX1VTRVJFVkVOVDsKLQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX3VubG9jaygpOwogCQl1bmxvY2tfZmJfaW5mbyhpbmZvKTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vZmJzeXNmcy5jIGIvZHJpdmVycy92aWRlby9mYnN5c2ZzLmMKaW5kZXggMGEwOGYxMy4uZjRhMzI3NyAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9mYnN5c2ZzLmMKKysrIGIvZHJpdmVycy92aWRlby9mYnN5c2ZzLmMKQEAgLTkwLDExICs5MCwxMSBAQAogCWludCBlcnI7CiAKIAl2YXItPmFjdGl2YXRlIHw9IEZCX0FDVElWQVRFX0ZPUkNFOwotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlmYl9pbmZvLT5mbGFncyB8PSBGQklORk9fTUlTQ19VU0VSRVZFTlQ7CiAJZXJyID0gZmJfc2V0X3ZhcihmYl9pbmZvLCB2YXIpOwogCWZiX2luZm8tPmZsYWdzICY9IH5GQklORk9fTUlTQ19VU0VSRVZFTlQ7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJaWYgKGVycikKIAkJcmV0dXJuIGVycjsKIAlyZXR1cm4gMDsKQEAgLTE3NSw3ICsxNzUsNyBAQAogCWlmIChpICogc2l6ZW9mKHN0cnVjdCBmYl92aWRlb21vZGUpICE9IGNvdW50KQogCQlyZXR1cm4gLUVJTlZBTDsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlsaXN0X3NwbGljZSgmZmJfaW5mby0+bW9kZWxpc3QsICZvbGRfbGlzdCk7CiAJZmJfdmlkZW9tb2RlX3RvX21vZGVsaXN0KChjb25zdCBzdHJ1Y3QgZmJfdmlkZW9tb2RlICopYnVmLCBpLAogCQkJCSAmZmJfaW5mby0+bW9kZWxpc3QpOwpAQCAtMTg1LDcgKzE4NSw3IEBACiAJfSBlbHNlCiAJCWZiX2Rlc3Ryb3lfbW9kZWxpc3QoJm9sZF9saXN0KTsKIAotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCiAJcmV0dXJuIDA7CiB9CkBAIC0zMDEsMTEgKzMwMSwxMSBAQAogCWNoYXIgKmxhc3QgPSBOVUxMOwogCWludCBlcnI7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJZmJfaW5mby0+ZmxhZ3MgfD0gRkJJTkZPX01JU0NfVVNFUkVWRU5UOwogCWVyciA9IGZiX2JsYW5rKGZiX2luZm8sIHNpbXBsZV9zdHJ0b3VsKGJ1ZiwgJmxhc3QsIDApKTsKIAlmYl9pbmZvLT5mbGFncyAmPSB+RkJJTkZPX01JU0NfVVNFUkVWRU5UOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCWlmIChlcnIgPCAwKQogCQlyZXR1cm4gZXJyOwogCXJldHVybiBjb3VudDsKQEAgLTM2NCw5ICszNjQsOSBAQAogCQlyZXR1cm4gLUVJTlZBTDsKIAl2YXIueW9mZnNldCA9IHNpbXBsZV9zdHJ0b3VsKGxhc3QsICZsYXN0LCAwKTsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAllcnIgPSBmYl9wYW5fZGlzcGxheShmYl9pbmZvLCAmdmFyKTsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCWlmIChlcnIgPCAwKQogCQlyZXR1cm4gZXJyOwpAQCAtMzk5LDkgKzM5OSw5IEBACiAKIAlzdGF0ZSA9IHNpbXBsZV9zdHJ0b3VsKGJ1ZiwgJmxhc3QsIDApOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWZiX3NldF9zdXNwZW5kKGZiX2luZm8sIChpbnQpc3RhdGUpOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCiAJcmV0dXJuIGNvdW50OwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9nZW9kZS9neGZiX2NvcmUuYyBiL2RyaXZlcnMvdmlkZW8vZ2VvZGUvZ3hmYl9jb3JlLmMKaW5kZXggNzBiMWQ5ZC4uYjRmMTlkYiAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9nZW9kZS9neGZiX2NvcmUuYworKysgYi9kcml2ZXJzL3ZpZGVvL2dlb2RlL2d4ZmJfY29yZS5jCkBAIC0zNDQsMTAgKzM0NCwxMCBAQAogCXN0cnVjdCBmYl9pbmZvICppbmZvID0gcGNpX2dldF9kcnZkYXRhKHBkZXYpOwogCiAJaWYgKHN0YXRlLmV2ZW50ID09IFBNX0VWRU5UX1NVU1BFTkQpIHsKLQkJYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX2xvY2soKTsKIAkJZ3hfcG93ZXJkb3duKGluZm8pOwogCQlmYl9zZXRfc3VzcGVuZChpbmZvLCAxKTsKLQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX3VubG9jaygpOwogCX0KIAogCS8qIHRoZXJlJ3Mgbm8gcG9pbnQgaW4gc2V0dGluZyBQQ0kgc3RhdGVzOyB3ZSBlbXVsYXRlIFBDSSwgc28KQEAgLTM2MSw3ICszNjEsNyBAQAogCXN0cnVjdCBmYl9pbmZvICppbmZvID0gcGNpX2dldF9kcnZkYXRhKHBkZXYpOwogCWludCByZXQ7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJcmV0ID0gZ3hfcG93ZXJ1cChpbmZvKTsKIAlpZiAocmV0KSB7CiAJCXByaW50ayhLRVJOX0VSUiAiZ3hmYjogIHBvd2VyIHVwIGZhaWxlZCFcbiIpOwpAQCAtMzY5LDcgKzM2OSw3IEBACiAJfQogCiAJZmJfc2V0X3N1c3BlbmQoaW5mbywgMCk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJcmV0dXJuIDA7CiB9CiAjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vZ2VvZGUvbHhmYl9jb3JlLmMgYi9kcml2ZXJzL3ZpZGVvL2dlb2RlL2x4ZmJfY29yZS5jCmluZGV4IDM5YmRiZWQuLjQxNjg1MWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vZ2VvZGUvbHhmYl9jb3JlLmMKKysrIGIvZHJpdmVycy92aWRlby9nZW9kZS9seGZiX2NvcmUuYwpAQCAtNDY1LDEwICs0NjUsMTAgQEAKIAlzdHJ1Y3QgZmJfaW5mbyAqaW5mbyA9IHBjaV9nZXRfZHJ2ZGF0YShwZGV2KTsKIAogCWlmIChzdGF0ZS5ldmVudCA9PSBQTV9FVkVOVF9TVVNQRU5EKSB7Ci0JCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV9sb2NrKCk7CiAJCWx4X3Bvd2VyZG93bihpbmZvKTsKIAkJZmJfc2V0X3N1c3BlbmQoaW5mbywgMSk7Ci0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAl9CiAKIAkvKiB0aGVyZSdzIG5vIHBvaW50IGluIHNldHRpbmcgUENJIHN0YXRlczsgd2UgZW11bGF0ZSBQQ0ksIHNvCkBAIC00ODIsNyArNDgyLDcgQEAKIAlzdHJ1Y3QgZmJfaW5mbyAqaW5mbyA9IHBjaV9nZXRfZHJ2ZGF0YShwZGV2KTsKIAlpbnQgcmV0OwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCXJldCA9IGx4X3Bvd2VydXAoaW5mbyk7CiAJaWYgKHJldCkgewogCQlwcmludGsoS0VSTl9FUlIgImx4ZmI6ICBwb3dlciB1cCBmYWlsZWQhXG4iKTsKQEAgLTQ5MCw3ICs0OTAsNyBAQAogCX0KIAogCWZiX3NldF9zdXNwZW5kKGluZm8sIDApOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCXJldHVybiAwOwogfQogI2Vsc2UKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vaTgxMC9pODEwX21haW4uYyBiL2RyaXZlcnMvdmlkZW8vaTgxMC9pODEwX21haW4uYwppbmRleCA1NzQzZWEyLi4zMThmNmZiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2k4MTAvaTgxMF9tYWluLmMKKysrIGIvZHJpdmVycy92aWRlby9pODEwL2k4MTBfbWFpbi5jCkBAIC0xNTc0LDcgKzE1NzQsNyBAQAogCQlyZXR1cm4gMDsKIAl9CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJZmJfc2V0X3N1c3BlbmQoaW5mbywgMSk7CiAKIAlpZiAoaW5mby0+ZmJvcHMtPmZiX3N5bmMpCkBAIC0xNTg3LDcgKzE1ODcsNyBAQAogCXBjaV9zYXZlX3N0YXRlKGRldik7CiAJcGNpX2Rpc2FibGVfZGV2aWNlKGRldik7CiAJcGNpX3NldF9wb3dlcl9zdGF0ZShkZXYsIHBjaV9jaG9vc2Vfc3RhdGUoZGV2LCBtZXNnKSk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTE2MDUsNyArMTYwNSw3IEBACiAJCXJldHVybiAwOwogCX0KIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlwY2lfc2V0X3Bvd2VyX3N0YXRlKGRldiwgUENJX0QwKTsKIAlwY2lfcmVzdG9yZV9zdGF0ZShkZXYpOwogCkBAIC0xNjIxLDcgKzE2MjEsNyBAQAogCWZiX3NldF9zdXNwZW5kIChpbmZvLCAwKTsKIAlpbmZvLT5mYm9wcy0+ZmJfYmxhbmsoVkVTQV9OT19CTEFOS0lORywgaW5mbyk7CiBmYWlsOgotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCXJldHVybiAwOwogfQogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2p6NDc0MF9mYi5jIGIvZHJpdmVycy92aWRlby9qejQ3NDBfZmIuYwppbmRleCA2NzBlY2FhLi5kZTM2NjkzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL2p6NDc0MF9mYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vano0NzQwX2ZiLmMKQEAgLTc3OCw5ICs3NzgsOSBAQAogewogCXN0cnVjdCBqemZiICpqemZiID0gZGV2X2dldF9kcnZkYXRhKGRldik7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJZmJfc2V0X3N1c3BlbmQoanpmYi0+ZmIsIDEpOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCiAJbXV0ZXhfbG9jaygmanpmYi0+bG9jayk7CiAJaWYgKGp6ZmItPmlzX2VuYWJsZWQpCkBAIC04MDAsOSArODAwLDkgQEAKIAkJanpmYl9lbmFibGUoanpmYik7CiAJbXV0ZXhfdW5sb2NrKCZqemZiLT5sb2NrKTsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlmYl9zZXRfc3VzcGVuZChqemZiLT5mYiwgMCk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vbXgzZmIuYyBiL2RyaXZlcnMvdmlkZW8vbXgzZmIuYwppbmRleCBjYjAxMzkxLi43ZTNhNDkwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL214M2ZiLmMKKysrIGIvZHJpdmVycy92aWRlby9teDNmYi5jCkBAIC0xMTc3LDkgKzExNzcsOSBAQAogCXN0cnVjdCBteDNmYl9kYXRhICpteDNmYiA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOwogCXN0cnVjdCBteDNmYl9pbmZvICpteDNfZmJpID0gbXgzZmItPmZiaS0+cGFyOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWZiX3NldF9zdXNwZW5kKG14M2ZiLT5mYmksIDEpOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCiAJaWYgKG14M19mYmktPmJsYW5rID09IEZCX0JMQU5LX1VOQkxBTkspIHsKIAkJc2RjX2Rpc2FibGVfY2hhbm5lbChteDNfZmJpKTsKQEAgLTEyMDIsOSArMTIwMiw5IEBACiAJCXNkY19zZXRfYnJpZ2h0bmVzcyhteDNmYiwgbXgzZmItPmJhY2tsaWdodF9sZXZlbCk7CiAJfQogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWZiX3NldF9zdXNwZW5kKG14M2ZiLT5mYmksIDApOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL251YzkwMGZiLmMgYi9kcml2ZXJzL3ZpZGVvL251YzkwMGZiLmMKaW5kZXggNjI0OThiZC4uZjgzOGQ5ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9udWM5MDBmYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vbnVjOTAwZmIuYwpAQCAtNjk2LDYgKzY5Niw4IEBACiAJbnVjOTAwZmJfc3RvcF9sY2QoZmJpbmZvKTsKIAltc2xlZXAoMSk7CiAKKwl1bnJlZ2lzdGVyX2ZyYW1lYnVmZmVyKGZiaW5mbyk7CisJbnVjOTAwZmJfY3B1ZnJlcV9kZXJlZ2lzdGVyKGZiaSk7CiAJbnVjOTAwZmJfdW5tYXBfdmlkZW9fbWVtb3J5KGZiaW5mbyk7CiAKIAlpb3VubWFwKGZiaS0+aW8pOwpAQCAtNzIzLDcgKzcyNSw3IEBACiAJc3RydWN0IGZiX2luZm8JICAgKmZiaW5mbyA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKGRldik7CiAJc3RydWN0IG51YzkwMGZiX2luZm8gKmluZm8gPSBmYmluZm8tPnBhcjsKIAotCW51YzkwMGZiX3N0b3BfbGNkKCk7CisJbnVjOTAwZmJfc3RvcF9sY2QoZmJpbmZvKTsKIAltc2xlZXAoMSk7CiAJY2xrX2Rpc2FibGUoaW5mby0+Y2xrKTsKIAlyZXR1cm4gMDsKQEAgLTc0MCw3ICs3NDIsNyBAQAogCW1zbGVlcCgxKTsKIAogCW51YzkwMGZiX2luaXRfcmVnaXN0ZXJzKGZiaW5mbyk7Ci0JbnVjOTAwZmJfYWN0aXZhdGVfdmFyKGJmaW5mbyk7CisJbnVjOTAwZmJfYWN0aXZhdGVfdmFyKGZiaW5mbyk7CiAKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vbnZpZGlhL252aWRpYS5jIGIvZHJpdmVycy92aWRlby9udmlkaWEvbnZpZGlhLmMKaW5kZXggZWZlMTBmZi4uMDgxZGM0NyAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9udmlkaWEvbnZpZGlhLmMKKysrIGIvZHJpdmVycy92aWRlby9udmlkaWEvbnZpZGlhLmMKQEAgLTEwNTcsNyArMTA1Nyw3IEBACiAKIAlpZiAobWVzZy5ldmVudCA9PSBQTV9FVkVOVF9QUkVUSEFXKQogCQltZXNnLmV2ZW50ID0gUE1fRVZFTlRfRlJFRVpFOwotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlwYXItPnBtX3N0YXRlID0gbWVzZy5ldmVudDsKIAogCWlmIChtZXNnLmV2ZW50ICYgUE1fRVZFTlRfU0xFRVApIHsKQEAgLTEwNzAsNyArMTA3MCw3IEBACiAJfQogCWRldi0+ZGV2LnBvd2VyLnBvd2VyX3N0YXRlID0gbWVzZzsKIAotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCXJldHVybiAwOwogfQogCkBAIC0xMDc5LDcgKzEwNzksNyBAQAogCXN0cnVjdCBmYl9pbmZvICppbmZvID0gcGNpX2dldF9kcnZkYXRhKGRldik7CiAJc3RydWN0IG52aWRpYV9wYXIgKnBhciA9IGluZm8tPnBhcjsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlwY2lfc2V0X3Bvd2VyX3N0YXRlKGRldiwgUENJX0QwKTsKIAogCWlmIChwYXItPnBtX3N0YXRlICE9IFBNX0VWRU5UX0ZSRUVaRSkgewpAQCAtMTA5Nyw3ICsxMDk3LDcgQEAKIAludmlkaWFmYl9ibGFuayhGQl9CTEFOS19VTkJMQU5LLCBpbmZvKTsKIAogZmFpbDoKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAlyZXR1cm4gMDsKIH0KICNlbHNlCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3BzM2ZiLmMgYi9kcml2ZXJzL3ZpZGVvL3BzM2ZiLmMKaW5kZXggOWMwMTQ0ZS4uNjU1NjBhMSAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9wczNmYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vcHMzZmIuYwpAQCAtNTEzLDkgKzUxMyw5IEBACiAJaWYgKGF0b21pY19kZWNfYW5kX3Rlc3QoJnBzM2ZiLmZfY291bnQpKSB7CiAJCWlmIChhdG9taWNfcmVhZCgmcHMzZmIuZXh0X2ZsaXApKSB7CiAJCQlhdG9taWNfc2V0KCZwczNmYi5leHRfZmxpcCwgMCk7Ci0JCQlpZiAoIXRyeV9hY3F1aXJlX2NvbnNvbGVfc2VtKCkpIHsKKwkJCWlmIChjb25zb2xlX3RyeWxvY2soKSkgewogCQkJCXBzM2ZiX3N5bmMoaW5mbywgMCk7CS8qIHNpbmdsZSBidWZmZXIgKi8KLQkJCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCQkJY29uc29sZV91bmxvY2soKTsKIAkJCX0KIAkJfQogCX0KQEAgLTgzMCwxNCArODMwLDE0IEBACiAJCQlpZiAodm1vZGUpIHsKIAkJCQl2YXIgPSBpbmZvLT52YXI7CiAJCQkJZmJfdmlkZW9tb2RlX3RvX3ZhcigmdmFyLCB2bW9kZSk7Ci0JCQkJYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCQkJCWNvbnNvbGVfbG9jaygpOwogCQkJCWluZm8tPmZsYWdzIHw9IEZCSU5GT19NSVNDX1VTRVJFVkVOVDsKIAkJCQkvKiBGb3JjZSwgaW4gY2FzZSBvbmx5IHNwZWNpYWwgYml0cyBjaGFuZ2VkICovCiAJCQkJdmFyLmFjdGl2YXRlIHw9IEZCX0FDVElWQVRFX0ZPUkNFOwogCQkJCXBhci0+bmV3X21vZGVfaWQgPSB2YWw7CiAJCQkJcmV0dmFsID0gZmJfc2V0X3ZhcihpbmZvLCAmdmFyKTsKIAkJCQlpbmZvLT5mbGFncyAmPSB+RkJJTkZPX01JU0NfVVNFUkVWRU5UOwotCQkJCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJCQljb25zb2xlX3VubG9jaygpOwogCQkJfQogCQkJYnJlYWs7CiAJCX0KQEAgLTg4MSw5ICs4ODEsOSBAQAogCQkJYnJlYWs7CiAKIAkJZGV2X2RiZyhpbmZvLT5kZXZpY2UsICJQUzNGQl9JT0NUTF9GU0VMOiVkXG4iLCB2YWwpOwotCQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfbG9jaygpOwogCQlyZXR2YWwgPSBwczNmYl9zeW5jKGluZm8sIHZhbCk7Ci0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAkJYnJlYWs7CiAKIAlkZWZhdWx0OgpAQCAtOTAzLDkgKzkwMyw5IEBACiAJCXNldF9jdXJyZW50X3N0YXRlKFRBU0tfSU5URVJSVVBUSUJMRSk7CiAJCWlmIChwczNmYi5pc19raWNrZWQpIHsKIAkJCXBzM2ZiLmlzX2tpY2tlZCA9IDA7Ci0JCQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJCQljb25zb2xlX2xvY2soKTsKIAkJCXBzM2ZiX3N5bmMoaW5mbywgMCk7CS8qIHNpbmdsZSBidWZmZXIgKi8KLQkJCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJCWNvbnNvbGVfdW5sb2NrKCk7CiAJCX0KIAkJc2NoZWR1bGUoKTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3B4YTE2OGZiLmMgYi9kcml2ZXJzL3ZpZGVvL3B4YTE2OGZiLmMKaW5kZXggY2VhNjQwMy4uMzVmNjFkZCAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9weGExNjhmYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vcHhhMTY4ZmIuYwpAQCAtNzAxLDE2ICs3MDEsMTIgQEAKIAkgKi8KIAlweGExNjhmYl9pbml0X21vZGUoaW5mbywgbWkpOwogCi0JcmV0ID0gcHhhMTY4ZmJfY2hlY2tfdmFyKCZpbmZvLT52YXIsIGluZm8pOwotCWlmIChyZXQpCi0JCWdvdG8gZmFpbGVkX2ZyZWVfZmJtZW07Ci0KIAkvKgogCSAqIEZpbGwgaW4gc2FuZSBkZWZhdWx0cy4KIAkgKi8KIAlyZXQgPSBweGExNjhmYl9jaGVja192YXIoJmluZm8tPnZhciwgaW5mbyk7CiAJaWYgKHJldCkKLQkJZ290byBmYWlsZWQ7CisJCWdvdG8gZmFpbGVkX2ZyZWVfZmJtZW07CiAKIAkvKgogCSAqIGVuYWJsZSBjb250cm9sbGVyIGNsb2NrCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3B4YTN4eC1nY3UuYyBiL2RyaXZlcnMvdmlkZW8vcHhhM3h4LWdjdS5jCmluZGV4IGI4MTE2OGQuLmNmNGJlYjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vcHhhM3h4LWdjdS5jCisrKyBiL2RyaXZlcnMvdmlkZW8vcHhhM3h4LWdjdS5jCkBAIC0xLDUgKzEsNSBAQAogLyoKLSAqICBweGEzeHgtZ2MuYyAtIExpbnV4IGtlcm5lbCBtb2R1bGUgZm9yIFBYQTN4eCBncmFwaGljcyBjb250cm9sbGVycworICogIHB4YTN4eC1nY3UuYyAtIExpbnV4IGtlcm5lbCBtb2R1bGUgZm9yIFBYQTN4eCBncmFwaGljcyBjb250cm9sbGVycwogICoKICAqICBUaGlzIGRyaXZlciBuZWVkcyBhIERpcmVjdEZCIGNvdW50ZXJwYXJ0IGluIHVzZXIgc3BhY2UsIGNvbW11bmljYXRpb24KICAqICBpcyBoYW5kbGVkIHZpYSBtbWFwKCllZCBtZW1vcnkgYXJlYXMgYW5kIGFuIGlvY3RsLgpAQCAtNDIxLDcgKzQyMSw3IEBACiAJCWJ1ZmZlci0+bmV4dCA9IHByaXYtPmZyZWU7CiAJCXByaXYtPmZyZWUgPSBidWZmZXI7CiAJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPnNwaW5sb2NrLCBmbGFncyk7Ci0JCXJldHVybiByZXQ7CisJCXJldHVybiAtRUZBVUxUOwogCX0KIAogCWJ1ZmZlci0+bGVuZ3RoID0gd29yZHM7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3MzZmIuYyBiL2RyaXZlcnMvdmlkZW8vczNmYi5jCmluZGV4IGRjZThjOTcuLjc1NzM4YTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vczNmYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vczNmYi5jCkBAIC0yMiw3ICsyMiw3IEBACiAjaW5jbHVkZSA8bGludXgvc3ZnYS5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KLSNpbmNsdWRlIDxsaW51eC9jb25zb2xlLmg+IC8qIFdoeSBzaG91bGQgZmIgZHJpdmVyIGNhbGwgY29uc29sZSBmdW5jdGlvbnM/IGJlY2F1c2UgYWNxdWlyZV9jb25zb2xlX3NlbSgpICovCisjaW5jbHVkZSA8bGludXgvY29uc29sZS5oPiAvKiBXaHkgc2hvdWxkIGZiIGRyaXZlciBjYWxsIGNvbnNvbGUgZnVuY3Rpb25zPyBiZWNhdXNlIGNvbnNvbGVfbG9jaygpICovCiAjaW5jbHVkZSA8dmlkZW8vdmdhLmg+CiAKICNpZmRlZiBDT05GSUdfTVRSUgpAQCAtMTExMywxMiArMTExMywxMiBAQAogCiAJZGV2X2luZm8oaW5mby0+ZGV2aWNlLCAic3VzcGVuZFxuIik7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJbXV0ZXhfbG9jaygmKHBhci0+b3Blbl9sb2NrKSk7CiAKIAlpZiAoKHN0YXRlLmV2ZW50ID09IFBNX0VWRU5UX0ZSRUVaRSkgfHwgKHBhci0+cmVmX2NvdW50ID09IDApKSB7CiAJCW11dGV4X3VubG9jaygmKHBhci0+b3Blbl9sb2NrKSk7Ci0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAkJcmV0dXJuIDA7CiAJfQogCkBAIC0xMTI5LDcgKzExMjksNyBAQAogCXBjaV9zZXRfcG93ZXJfc3RhdGUoZGV2LCBwY2lfY2hvb3NlX3N0YXRlKGRldiwgc3RhdGUpKTsKIAogCW11dGV4X3VubG9jaygmKHBhci0+b3Blbl9sb2NrKSk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTExNDUsMTIgKzExNDUsMTIgQEAKIAogCWRldl9pbmZvKGluZm8tPmRldmljZSwgInJlc3VtZVxuIik7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJbXV0ZXhfbG9jaygmKHBhci0+b3Blbl9sb2NrKSk7CiAKIAlpZiAocGFyLT5yZWZfY291bnQgPT0gMCkgewogCQltdXRleF91bmxvY2soJihwYXItPm9wZW5fbG9jaykpOwotCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfdW5sb2NrKCk7CiAJCXJldHVybiAwOwogCX0KIApAQCAtMTE1OSw3ICsxMTU5LDcgQEAKIAllcnIgPSBwY2lfZW5hYmxlX2RldmljZShkZXYpOwogCWlmIChlcnIpIHsKIAkJbXV0ZXhfdW5sb2NrKCYocGFyLT5vcGVuX2xvY2spKTsKLQkJcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCQljb25zb2xlX3VubG9jaygpOwogCQlkZXZfZXJyKGluZm8tPmRldmljZSwgImVycm9yICVkIGVuYWJsaW5nIGRldmljZSBmb3IgcmVzdW1lXG4iLCBlcnIpOwogCQlyZXR1cm4gZXJyOwogCX0KQEAgLTExNjksNyArMTE2OSw3IEBACiAJZmJfc2V0X3N1c3BlbmQoaW5mbywgMCk7CiAKIAltdXRleF91bmxvY2soJihwYXItPm9wZW5fbG9jaykpOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3NhdmFnZS9zYXZhZ2VmYl9kcml2ZXIuYyBiL2RyaXZlcnMvdmlkZW8vc2F2YWdlL3NhdmFnZWZiX2RyaXZlci5jCmluZGV4IDg0MmQxNTcuLjQ4NzkxMWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vc2F2YWdlL3NhdmFnZWZiX2RyaXZlci5jCisrKyBiL2RyaXZlcnMvdmlkZW8vc2F2YWdlL3NhdmFnZWZiX2RyaXZlci5jCkBAIC0yMzczLDcgKzIzNzMsNyBAQAogCWlmIChtZXNnLmV2ZW50ID09IFBNX0VWRU5UX0ZSRUVaRSkKIAkJcmV0dXJuIDA7CiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJZmJfc2V0X3N1c3BlbmQoaW5mbywgMSk7CiAKIAlpZiAoaW5mby0+ZmJvcHMtPmZiX3N5bmMpCkBAIC0yMzg1LDcgKzIzODUsNyBAQAogCXBjaV9zYXZlX3N0YXRlKGRldik7CiAJcGNpX2Rpc2FibGVfZGV2aWNlKGRldik7CiAJcGNpX3NldF9wb3dlcl9zdGF0ZShkZXYsIHBjaV9jaG9vc2Vfc3RhdGUoZGV2LCBtZXNnKSk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTI0MDksNyArMjQwOSw3IEBACiAJCXJldHVybiAwOwogCX0KIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAogCXBjaV9zZXRfcG93ZXJfc3RhdGUoZGV2LCBQQ0lfRDApOwogCXBjaV9yZXN0b3JlX3N0YXRlKGRldik7CkBAIC0yNDIzLDcgKzI0MjMsNyBAQAogCXNhdmFnZWZiX3NldF9wYXIoaW5mbyk7CiAJZmJfc2V0X3N1c3BlbmQoaW5mbywgMCk7CiAJc2F2YWdlZmJfYmxhbmsoRkJfQkxBTktfVU5CTEFOSywgaW5mbyk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vc2hfbW9iaWxlX2hkbWkuYyBiL2RyaXZlcnMvdmlkZW8vc2hfbW9iaWxlX2hkbWkuYwppbmRleCA3NGQ5ZjU0Li4yYjllNTZhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL3NoX21vYmlsZV9oZG1pLmMKKysrIGIvZHJpdmVycy92aWRlby9zaF9tb2JpbGVfaGRtaS5jCkBAIC0xMTUxLDcgKzExNTEsNyBAQAogCiAJCWNoID0gaW5mby0+cGFyOwogCi0JCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV9sb2NrKCk7CiAKIAkJLyogSERNSSBwbHVnIGluICovCiAJCWlmICghc2hfaGRtaV9tdXN0X3JlY29uZmlndXJlKGhkbWkpICYmCkBAIC0xMTcxLDcgKzExNzEsNyBAQAogCQkJZmJfc2V0X3N1c3BlbmQoaW5mbywgMCk7CiAJCX0KIAotCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfdW5sb2NrKCk7CiAJfSBlbHNlIHsKIAkJcmV0ID0gMDsKIAkJaWYgKCFoZG1pLT5pbmZvKQpAQCAtMTE4MSwxMiArMTE4MSwxMiBAQAogCQlmYl9kZXN0cm95X21vZGVkYihoZG1pLT5tb25zcGVjLm1vZGVkYik7CiAJCWhkbWktPm1vbnNwZWMubW9kZWRiID0gTlVMTDsKIAotCQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfbG9jaygpOwogCiAJCS8qIEhETUkgZGlzY29ubmVjdCAqLwogCQlmYl9zZXRfc3VzcGVuZChoZG1pLT5pbmZvLCAxKTsKIAotCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfdW5sb2NrKCk7CiAJCXBtX3J1bnRpbWVfcHV0KGhkbWktPmRldik7CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3NoX21vYmlsZV9sY2RjZmIuYyBiL2RyaXZlcnMvdmlkZW8vc2hfbW9iaWxlX2xjZGNmYi5jCmluZGV4IGJkNDg0MGEuLmJmMTJlNTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vc2hfbW9iaWxlX2xjZGNmYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vc2hfbW9iaWxlX2xjZGNmYi5jCkBAIC05MTIsOSArOTEyLDkgQEAKIAogCS8qIE5vdGhpbmcgdG8gcmVjb25maWd1cmUsIHdoZW4gY2FsbGVkIGZyb20gZmJjb24gKi8KIAlpZiAodXNlcikgewotCQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfbG9jaygpOwogCQlzaF9tb2JpbGVfZmJfcmVjb25maWcoaW5mbyk7Ci0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV91bmxvY2soKTsKIAl9CiAKIAltdXRleF91bmxvY2soJmNoLT5vcGVuX2xvY2spOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9zbTUwMWZiLmMgYi9kcml2ZXJzL3ZpZGVvL3NtNTAxZmIuYwppbmRleCBiN2RjMTgwLi5iY2I0NGE1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL3NtNTAxZmIuYworKysgYi9kcml2ZXJzL3ZpZGVvL3NtNTAxZmIuYwpAQCAtMjAxMCw5ICsyMDEwLDkgQEAKIAogCS8qIHRlbGwgY29uc29sZS9mYiBkcml2ZXIgd2UgYXJlIHN1c3BlbmRpbmcgKi8KIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlmYl9zZXRfc3VzcGVuZChmYmksIDEpOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCiAJLyogYmFja3VwIGNvcGllcyBpbiBjYXNlIGNoaXAgaXMgcG93ZXJlZCBkb3duIG92ZXIgc3VzcGVuZCAqLwogCkBAIC0yMDY5LDkgKzIwNjksOSBAQAogCQltZW1jcHlfdG9pbyhwYXItPmN1cnNvci5rX2FkZHIsIHBhci0+c3RvcmVfY3Vyc29yLAogCQkJICAgIHBhci0+Y3Vyc29yLnNpemUpOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWZiX3NldF9zdXNwZW5kKGZiaSwgMCk7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAKIAl2ZnJlZShwYXItPnN0b3JlX2ZiKTsKIAl2ZnJlZShwYXItPnN0b3JlX2N1cnNvcik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3RtaW9mYi5jIGIvZHJpdmVycy92aWRlby90bWlvZmIuYwppbmRleCA2OTEzZmUxLi5kZmVmODhjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL3RtaW9mYi5jCisrKyBiL2RyaXZlcnMvdmlkZW8vdG1pb2ZiLmMKQEAgLTI1LDcgKzI1LDcgQEAKICNpbmNsdWRlIDxsaW51eC9mYi5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+Ci0vKiBXaHkgc2hvdWxkIGZiIGRyaXZlciBjYWxsIGNvbnNvbGUgZnVuY3Rpb25zPyBiZWNhdXNlIGFjcXVpcmVfY29uc29sZV9zZW0oKSAqLworLyogV2h5IHNob3VsZCBmYiBkcml2ZXIgY2FsbCBjb25zb2xlIGZ1bmN0aW9ucz8gYmVjYXVzZSBjb25zb2xlX2xvY2soKSAqLwogI2luY2x1ZGUgPGxpbnV4L2NvbnNvbGUuaD4KICNpbmNsdWRlIDxsaW51eC9tZmQvY29yZS5oPgogI2luY2x1ZGUgPGxpbnV4L21mZC90bWlvLmg+CkBAIC05NDQsNyArOTQ0LDcgQEAKIAlzdHJ1Y3QgbWZkX2NlbGwgKmNlbGwgPSBkZXYtPmRldi5wbGF0Zm9ybV9kYXRhOwogCWludCByZXR2YWwgPSAwOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCiAJZmJfc2V0X3N1c3BlbmQoaW5mbywgMSk7CiAKQEAgLTk2NSw3ICs5NjUsNyBAQAogCWlmIChjZWxsLT5zdXNwZW5kKQogCQlyZXR2YWwgPSBjZWxsLT5zdXNwZW5kKGRldik7CiAKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCXJldHVybiByZXR2YWw7CiB9CkBAIC05NzYsNyArOTc2LDcgQEAKIAlzdHJ1Y3QgbWZkX2NlbGwgKmNlbGwgPSBkZXYtPmRldi5wbGF0Zm9ybV9kYXRhOwogCWludCByZXR2YWwgPSAwOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCiAJaWYgKGNlbGwtPnJlc3VtZSkgewogCQlyZXR2YWwgPSBjZWxsLT5yZXN1bWUoZGV2KTsKQEAgLTk5Miw3ICs5OTIsNyBAQAogCiAJZmJfc2V0X3N1c3BlbmQoaW5mbywgMCk7CiBvdXQ6Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJcmV0dXJuIHJldHZhbDsKIH0KICNlbHNlCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3ZpYS92aWFmYmRldi5jIGIvZHJpdmVycy92aWRlby92aWEvdmlhZmJkZXYuYwppbmRleCAyODllZGQ1Li40ZTY2MzQ5ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby92aWEvdmlhZmJkZXYuYworKysgYi9kcml2ZXJzL3ZpZGVvL3ZpYS92aWFmYmRldi5jCkBAIC0xNjc0LDE3ICsxNjc0LDE3IEBACiAjaWZkZWYgQ09ORklHX1BNCiBzdGF0aWMgaW50IHZpYWZiX3N1c3BlbmQodm9pZCAqdW51c2VkKQogewotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlmYl9zZXRfc3VzcGVuZCh2aWFmYmluZm8sIDEpOwogCXZpYWZiX3N5bmModmlhZmJpbmZvKTsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCXJldHVybiAwOwogfQogCiBzdGF0aWMgaW50IHZpYWZiX3Jlc3VtZSh2b2lkICp1bnVzZWQpCiB7Ci0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWlmICh2aWFwYXJpbmZvLT5zaGFyZWQtPnZkZXYtPmVuZ2luZV9tbWlvKQogCQl2aWFmYl9yZXNldF9lbmdpbmUodmlhcGFyaW5mbyk7CiAJdmlhZmJfc2V0X3Bhcih2aWFmYmluZm8pOwpAQCAtMTY5Miw3ICsxNjkyLDcgQEAKIAkJdmlhZmJfc2V0X3Bhcih2aWFmYmluZm8xKTsKIAlmYl9zZXRfc3VzcGVuZCh2aWFmYmluZm8sIDApOwogCi0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vdnQ4NjIzZmIuYyBiL2RyaXZlcnMvdmlkZW8vdnQ4NjIzZmIuYwppbmRleCA4NWQ3NmVjLi5hMjk2NWFiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpZGVvL3Z0ODYyM2ZiLmMKKysrIGIvZHJpdmVycy92aWRlby92dDg2MjNmYi5jCkBAIC0yMyw3ICsyMyw3IEBACiAjaW5jbHVkZSA8bGludXgvc3ZnYS5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KLSNpbmNsdWRlIDxsaW51eC9jb25zb2xlLmg+IC8qIFdoeSBzaG91bGQgZmIgZHJpdmVyIGNhbGwgY29uc29sZSBmdW5jdGlvbnM/IGJlY2F1c2UgYWNxdWlyZV9jb25zb2xlX3NlbSgpICovCisjaW5jbHVkZSA8bGludXgvY29uc29sZS5oPiAvKiBXaHkgc2hvdWxkIGZiIGRyaXZlciBjYWxsIGNvbnNvbGUgZnVuY3Rpb25zPyBiZWNhdXNlIGNvbnNvbGVfbG9jaygpICovCiAjaW5jbHVkZSA8dmlkZW8vdmdhLmg+CiAKICNpZmRlZiBDT05GSUdfTVRSUgpAQCAtODE5LDEyICs4MTksMTIgQEAKIAogCWRldl9pbmZvKGluZm8tPmRldmljZSwgInN1c3BlbmRcbiIpOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCW11dGV4X2xvY2soJihwYXItPm9wZW5fbG9jaykpOwogCiAJaWYgKChzdGF0ZS5ldmVudCA9PSBQTV9FVkVOVF9GUkVFWkUpIHx8IChwYXItPnJlZl9jb3VudCA9PSAwKSkgewogCQltdXRleF91bmxvY2soJihwYXItPm9wZW5fbG9jaykpOwotCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJCWNvbnNvbGVfdW5sb2NrKCk7CiAJCXJldHVybiAwOwogCX0KIApAQCAtODM1LDcgKzgzNSw3IEBACiAJcGNpX3NldF9wb3dlcl9zdGF0ZShkZXYsIHBjaV9jaG9vc2Vfc3RhdGUoZGV2LCBzdGF0ZSkpOwogCiAJbXV0ZXhfdW5sb2NrKCYocGFyLT5vcGVuX2xvY2spKTsKLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAogCXJldHVybiAwOwogfQpAQCAtODUwLDcgKzg1MCw3IEBACiAKIAlkZXZfaW5mbyhpbmZvLT5kZXZpY2UsICJyZXN1bWVcbiIpOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCW11dGV4X2xvY2soJihwYXItPm9wZW5fbG9jaykpOwogCiAJaWYgKHBhci0+cmVmX2NvdW50ID09IDApCkBAIC04NjksNyArODY5LDcgQEAKIAogZmFpbDoKIAltdXRleF91bmxvY2soJihwYXItPm9wZW5fbG9jaykpOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3hlbi1mYmZyb250LmMgYi9kcml2ZXJzL3ZpZGVvL3hlbi1mYmZyb250LmMKaW5kZXggM2U2OTM0ZC4uYTIwMjE4YyAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby94ZW4tZmJmcm9udC5jCisrKyBiL2RyaXZlcnMvdmlkZW8veGVuLWZiZnJvbnQuYwpAQCAtNDkxLDEyICs0OTEsMTIgQEAKIAlpZiAoY29uc29sZV9zZXRfb25fY21kbGluZSkKIAkJcmV0dXJuOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWZvcl9lYWNoX2NvbnNvbGUoYykgewogCQlpZiAoIXN0cmNtcChjLT5uYW1lLCAidHR5IikgJiYgYy0+aW5kZXggPT0gMCkKIAkJCWJyZWFrOwogCX0KLQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV91bmxvY2soKTsKIAlpZiAoYykgewogCQl1bnJlZ2lzdGVyX2NvbnNvbGUoYyk7CiAJCWMtPmZsYWdzIHw9IENPTl9DT05TREVWOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aXJ0aW8vdmlydGlvX3BjaS5jIGIvZHJpdmVycy92aXJ0aW8vdmlydGlvX3BjaS5jCmluZGV4IGVmOGQ5ZDUuLjRmYjViMmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlydGlvL3ZpcnRpb19wY2kuYworKysgYi9kcml2ZXJzL3ZpcnRpby92aXJ0aW9fcGNpLmMKQEAgLTk2LDExICs5Niw2IEBACiAKIE1PRFVMRV9ERVZJQ0VfVEFCTEUocGNpLCB2aXJ0aW9fcGNpX2lkX3RhYmxlKTsKIAotLyogQSBQQ0kgZGV2aWNlIGhhcyBpdCdzIG93biBzdHJ1Y3QgZGV2aWNlIGFuZCBzbyBkb2VzIGEgdmlydGlvIGRldmljZSBzbwotICogd2UgY3JlYXRlIGEgcGxhY2UgZm9yIHRoZSB2aXJ0aW8gZGV2aWNlcyB0byBzaG93IHVwIGluIHN5c2ZzLiAgSSB0aGluayBpdAotICogd291bGQgbWFrZSBtb3JlIHNlbnNlIGZvciB2aXJ0aW8gdG8gbm90IGluc2lzdCBvbiBoYXZpbmcgaXQncyBvd24gZGV2aWNlLiAqLwotc3RhdGljIHN0cnVjdCBkZXZpY2UgKnZpcnRpb19wY2lfcm9vdDsKLQogLyogQ29udmVydCBhIGdlbmVyaWMgdmlydGlvIGRldmljZSB0byBvdXIgc3RydWN0dXJlICovCiBzdGF0aWMgc3RydWN0IHZpcnRpb19wY2lfZGV2aWNlICp0b192cF9kZXZpY2Uoc3RydWN0IHZpcnRpb19kZXZpY2UgKnZkZXYpCiB7CkBAIC02MjksNyArNjI0LDcgQEAKIAlpZiAodnBfZGV2ID09IE5VTEwpCiAJCXJldHVybiAtRU5PTUVNOwogCi0JdnBfZGV2LT52ZGV2LmRldi5wYXJlbnQgPSB2aXJ0aW9fcGNpX3Jvb3Q7CisJdnBfZGV2LT52ZGV2LmRldi5wYXJlbnQgPSAmcGNpX2Rldi0+ZGV2OwogCXZwX2Rldi0+dmRldi5kZXYucmVsZWFzZSA9IHZpcnRpb19wY2lfcmVsZWFzZV9kZXY7CiAJdnBfZGV2LT52ZGV2LmNvbmZpZyA9ICZ2aXJ0aW9fcGNpX2NvbmZpZ19vcHM7CiAJdnBfZGV2LT5wY2lfZGV2ID0gcGNpX2RldjsKQEAgLTcxNywxNyArNzEyLDcgQEAKIAogc3RhdGljIGludCBfX2luaXQgdmlydGlvX3BjaV9pbml0KHZvaWQpCiB7Ci0JaW50IGVycjsKLQotCXZpcnRpb19wY2lfcm9vdCA9IHJvb3RfZGV2aWNlX3JlZ2lzdGVyKCJ2aXJ0aW8tcGNpIik7Ci0JaWYgKElTX0VSUih2aXJ0aW9fcGNpX3Jvb3QpKQotCQlyZXR1cm4gUFRSX0VSUih2aXJ0aW9fcGNpX3Jvb3QpOwotCi0JZXJyID0gcGNpX3JlZ2lzdGVyX2RyaXZlcigmdmlydGlvX3BjaV9kcml2ZXIpOwotCWlmIChlcnIpCi0JCXJvb3RfZGV2aWNlX3VucmVnaXN0ZXIodmlydGlvX3BjaV9yb290KTsKLQotCXJldHVybiBlcnI7CisJcmV0dXJuIHBjaV9yZWdpc3Rlcl9kcml2ZXIoJnZpcnRpb19wY2lfZHJpdmVyKTsKIH0KIAogbW9kdWxlX2luaXQodmlydGlvX3BjaV9pbml0KTsKQEAgLTczNSw3ICs3MjAsNiBAQAogc3RhdGljIHZvaWQgX19leGl0IHZpcnRpb19wY2lfZXhpdCh2b2lkKQogewogCXBjaV91bnJlZ2lzdGVyX2RyaXZlcigmdmlydGlvX3BjaV9kcml2ZXIpOwotCXJvb3RfZGV2aWNlX3VucmVnaXN0ZXIodmlydGlvX3BjaV9yb290KTsKIH0KIAogbW9kdWxlX2V4aXQodmlydGlvX3BjaV9leGl0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdzEvbWFzdGVycy9vbWFwX2hkcS5jIGIvZHJpdmVycy93MS9tYXN0ZXJzL29tYXBfaGRxLmMKaW5kZXggM2E3ZTlmZi4uMzhlOTZhYiAxMDA2NDQKLS0tIGEvZHJpdmVycy93MS9tYXN0ZXJzL29tYXBfaGRxLmMKKysrIGIvZHJpdmVycy93MS9tYXN0ZXJzL29tYXBfaGRxLmMKQEAgLTU5MywxOSArNTkzLDE3IEBACiAKIAkvKiBnZXQgaW50ZXJmYWNlICYgZnVuY3Rpb25hbCBjbG9jayBvYmplY3RzICovCiAJaGRxX2RhdGEtPmhkcV9pY2sgPSBjbGtfZ2V0KCZwZGV2LT5kZXYsICJpY2siKTsKLQloZHFfZGF0YS0+aGRxX2ZjayA9IGNsa19nZXQoJnBkZXYtPmRldiwgImZjayIpOworCWlmIChJU19FUlIoaGRxX2RhdGEtPmhkcV9pY2spKSB7CisJCWRldl9kYmcoJnBkZXYtPmRldiwgIkNhbid0IGdldCBIRFEgaWNrIGNsb2NrIG9iamVjdFxuIik7CisJCXJldCA9IFBUUl9FUlIoaGRxX2RhdGEtPmhkcV9pY2spOworCQlnb3RvIGVycl9pY2s7CisJfQogCi0JaWYgKElTX0VSUihoZHFfZGF0YS0+aGRxX2ljaykgfHwgSVNfRVJSKGhkcV9kYXRhLT5oZHFfZmNrKSkgewotCQlkZXZfZGJnKCZwZGV2LT5kZXYsICJDYW4ndCBnZXQgSERRIGNsb2NrIG9iamVjdHNcbiIpOwotCQlpZiAoSVNfRVJSKGhkcV9kYXRhLT5oZHFfaWNrKSkgewotCQkJcmV0ID0gUFRSX0VSUihoZHFfZGF0YS0+aGRxX2ljayk7Ci0JCQlnb3RvIGVycl9jbGs7Ci0JCX0KLQkJaWYgKElTX0VSUihoZHFfZGF0YS0+aGRxX2ZjaykpIHsKLQkJCXJldCA9IFBUUl9FUlIoaGRxX2RhdGEtPmhkcV9mY2spOwotCQkJY2xrX3B1dChoZHFfZGF0YS0+aGRxX2ljayk7Ci0JCQlnb3RvIGVycl9jbGs7Ci0JCX0KKwloZHFfZGF0YS0+aGRxX2ZjayA9IGNsa19nZXQoJnBkZXYtPmRldiwgImZjayIpOworCWlmIChJU19FUlIoaGRxX2RhdGEtPmhkcV9mY2spKSB7CisJCWRldl9kYmcoJnBkZXYtPmRldiwgIkNhbid0IGdldCBIRFEgZmNrIGNsb2NrIG9iamVjdFxuIik7CisJCXJldCA9IFBUUl9FUlIoaGRxX2RhdGEtPmhkcV9mY2spOworCQlnb3RvIGVycl9mY2s7CiAJfQogCiAJaGRxX2RhdGEtPmhkcV91c2Vjb3VudCA9IDA7CkBAIC02NjUsMTAgKzY2MywxMiBAQAogCWNsa19kaXNhYmxlKGhkcV9kYXRhLT5oZHFfaWNrKTsKIAogZXJyX2ludGZjbGs6Ci0JY2xrX3B1dChoZHFfZGF0YS0+aGRxX2ljayk7CiAJY2xrX3B1dChoZHFfZGF0YS0+aGRxX2Zjayk7CiAKLWVycl9jbGs6CitlcnJfZmNrOgorCWNsa19wdXQoaGRxX2RhdGEtPmhkcV9pY2spOworCitlcnJfaWNrOgogCWlvdW5tYXAoaGRxX2RhdGEtPmhkcV9iYXNlKTsKIAogZXJyX2lvcmVtYXA6CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9LY29uZmlnIGIvZHJpdmVycy94ZW4vS2NvbmZpZwppbmRleCA1YTQ4Y2U5Li4wN2JlYzA5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9LY29uZmlnCisrKyBiL2RyaXZlcnMveGVuL0tjb25maWcKQEAgLTcxLDExICs3MSwxOCBAQAogCSBidXQgd2lsbCBoYXZlIG5vIHhlbiBjb250ZW50cy4KIAogY29uZmlnIFhFTl9YRU5CVVNfRlJPTlRFTkQKLSAgICAgICB0cmlzdGF0ZQorCXRyaXN0YXRlCisKK2NvbmZpZyBYRU5fR05UREVWCisJdHJpc3RhdGUgInVzZXJzcGFjZSBncmFudCBhY2Nlc3MgZGV2aWNlIGRyaXZlciIKKwlkZXBlbmRzIG9uIFhFTgorCXNlbGVjdCBNTVVfTk9USUZJRVIKKwloZWxwCisJICBBbGxvd3MgdXNlcnNwYWNlIHByb2Nlc3NlcyB0byB1c2UgZ3JhbnRzLgogCiBjb25maWcgWEVOX1BMQVRGT1JNX1BDSQogCXRyaXN0YXRlICJ4ZW4gcGxhdGZvcm0gcGNpIGRldmljZSBkcml2ZXIiCi0JZGVwZW5kcyBvbiBYRU5fUFZIVk0KKwlkZXBlbmRzIG9uIFhFTl9QVkhWTSAmJiBQQ0kKIAlkZWZhdWx0IG0KIAloZWxwCiAJICBEcml2ZXIgZm9yIHRoZSBYZW4gUENJIFBsYXRmb3JtIGRldmljZTogaXQgaXMgcmVzcG9uc2libGUgZm9yCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9NYWtlZmlsZSBiL2RyaXZlcnMveGVuL01ha2VmaWxlCmluZGV4IDUzM2ExOTkuLjUwODhjYzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL01ha2VmaWxlCisrKyBiL2RyaXZlcnMveGVuL01ha2VmaWxlCkBAIC05LDExICs5LDE0IEBACiBvYmotJChDT05GSUdfWEVOX1hFTkNPTU0pCSs9IHhlbmNvbW0ubwogb2JqLSQoQ09ORklHX1hFTl9CQUxMT09OKQkrPSBiYWxsb29uLm8KIG9iai0kKENPTkZJR19YRU5fREVWX0VWVENITikJKz0geGVuLWV2dGNobi5vCitvYmotJChDT05GSUdfWEVOX0dOVERFVikJKz0geGVuLWdudGRldi5vCiBvYmotJChDT05GSUdfWEVORlMpCQkrPSB4ZW5mcy8KIG9iai0kKENPTkZJR19YRU5fU1lTX0hZUEVSVklTT1IpCSs9IHN5cy1oeXBlcnZpc29yLm8KLW9iai0kKENPTkZJR19YRU5fUExBVEZPUk1fUENJKQkrPSBwbGF0Zm9ybS1wY2kubworb2JqLSQoQ09ORklHX1hFTl9QTEFURk9STV9QQ0kpCSs9IHhlbi1wbGF0Zm9ybS1wY2kubwogb2JqLSQoQ09ORklHX1NXSU9UTEJfWEVOKQkrPSBzd2lvdGxiLXhlbi5vCiBvYmotJChDT05GSUdfWEVOX0RPTTApCQkrPSBwY2kubwogCiB4ZW4tZXZ0Y2huLXkJCQk6PSBldnRjaG4ubworeGVuLWdudGRldi15CQkJCTo9IGdudGRldi5vCiAKK3hlbi1wbGF0Zm9ybS1wY2kteQkJOj0gcGxhdGZvcm0tcGNpLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2dudGRldi5jIGIvZHJpdmVycy94ZW4vZ250ZGV2LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMWUzMWNkYwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMveGVuL2dudGRldi5jCkBAIC0wLDAgKzEsNjY1IEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBnbnRkZXYuYworICoKKyAqIERldmljZSBmb3IgYWNjZXNzaW5nIChpbiB1c2VyLXNwYWNlKSBwYWdlcyB0aGF0IGhhdmUgYmVlbiBncmFudGVkIGJ5IG90aGVyCisgKiBkb21haW5zLgorICoKKyAqIENvcHlyaWdodCAoYykgMjAwNi0yMDA3LCBEIEcgTXVycmF5LgorICogICAgICAgICAgIChjKSAyMDA5IEdlcmQgSG9mZm1hbm4gPGtyYXhlbEByZWRoYXQuY29tPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UsIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAgMDIxMTEtMTMwNyAgVVNBCisgKi8KKworI3VuZGVmIERFQlVHCisKKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvbWlzY2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5jbHVkZSA8bGludXgvbW0uaD4KKyNpbmNsdWRlIDxsaW51eC9tbWFuLmg+CisjaW5jbHVkZSA8bGludXgvbW11X25vdGlmaWVyLmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KKyNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKworI2luY2x1ZGUgPHhlbi94ZW4uaD4KKyNpbmNsdWRlIDx4ZW4vZ3JhbnRfdGFibGUuaD4KKyNpbmNsdWRlIDx4ZW4vZ250ZGV2Lmg+CisjaW5jbHVkZSA8YXNtL3hlbi9oeXBlcnZpc29yLmg+CisjaW5jbHVkZSA8YXNtL3hlbi9oeXBlcmNhbGwuaD4KKyNpbmNsdWRlIDxhc20veGVuL3BhZ2UuaD4KKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FVVEhPUigiRGVyZWsgRy4gTXVycmF5IDxEZXJlay5NdXJyYXlAY2wuY2FtLmFjLnVrPiwgIgorCSAgICAgICJHZXJkIEhvZmZtYW5uIDxrcmF4ZWxAcmVkaGF0LmNvbT4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiVXNlci1zcGFjZSBncmFudGVkIHBhZ2UgYWNjZXNzIGRyaXZlciIpOworCitzdGF0aWMgaW50IGxpbWl0ID0gMTAyNDsKK21vZHVsZV9wYXJhbShsaW1pdCwgaW50LCAwNjQ0KTsKK01PRFVMRV9QQVJNX0RFU0MobGltaXQsICJNYXhpbXVtIG51bWJlciBvZiBncmFudHMgdGhhdCBtYXkgYmUgbWFwcGVkIGF0ICIKKwkJIm9uY2UgYnkgYSBnbnRkZXYgaW5zdGFuY2UiKTsKKworc3RydWN0IGdudGRldl9wcml2IHsKKwlzdHJ1Y3QgbGlzdF9oZWFkIG1hcHM7CisJdWludDMyX3QgdXNlZDsKKwl1aW50MzJfdCBsaW1pdDsKKwkvKiBsb2NrIHByb3RlY3RzIG1hcHMgZnJvbSBjb25jdXJyZW50IGNoYW5nZXMgKi8KKwlzcGlubG9ja190IGxvY2s7CisJc3RydWN0IG1tX3N0cnVjdCAqbW07CisJc3RydWN0IG1tdV9ub3RpZmllciBtbjsKK307CisKK3N0cnVjdCBncmFudF9tYXAgeworCXN0cnVjdCBsaXN0X2hlYWQgbmV4dDsKKwlzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXY7CisJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWE7CisJaW50IGluZGV4OworCWludCBjb3VudDsKKwlpbnQgZmxhZ3M7CisJaW50IGlzX21hcHBlZDsKKwlzdHJ1Y3QgaW9jdGxfZ250ZGV2X2dyYW50X3JlZiAqZ3JhbnRzOworCXN0cnVjdCBnbnR0YWJfbWFwX2dyYW50X3JlZiAgICptYXBfb3BzOworCXN0cnVjdCBnbnR0YWJfdW5tYXBfZ3JhbnRfcmVmICp1bm1hcF9vcHM7CisJc3RydWN0IHBhZ2UgKipwYWdlczsKK307CisKKy8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLworCitzdGF0aWMgdm9pZCBnbnRkZXZfcHJpbnRfbWFwcyhzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYsCisJCQkgICAgICBjaGFyICp0ZXh0LCBpbnQgdGV4dF9pbmRleCkKK3sKKyNpZmRlZiBERUJVRworCXN0cnVjdCBncmFudF9tYXAgKm1hcDsKKworCXByX2RlYnVnKCJtYXBzIGxpc3QgKHByaXYgJXAsIHVzYWdlICVkLyVkKVxuIiwKKwkgICAgICAgcHJpdiwgcHJpdi0+dXNlZCwgcHJpdi0+bGltaXQpOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShtYXAsICZwcml2LT5tYXBzLCBuZXh0KQorCQlwcl9kZWJ1ZygiICBpbmRleCAlMmQsIGNvdW50ICUyZCAlc1xuIiwKKwkJICAgICAgIG1hcC0+aW5kZXgsIG1hcC0+Y291bnQsCisJCSAgICAgICBtYXAtPmluZGV4ID09IHRleHRfaW5kZXggJiYgdGV4dCA/IHRleHQgOiAiIik7CisjZW5kaWYKK30KKworc3RhdGljIHN0cnVjdCBncmFudF9tYXAgKmdudGRldl9hbGxvY19tYXAoc3RydWN0IGdudGRldl9wcml2ICpwcml2LCBpbnQgY291bnQpCit7CisJc3RydWN0IGdyYW50X21hcCAqYWRkOworCWludCBpOworCisJYWRkID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGdyYW50X21hcCksIEdGUF9LRVJORUwpOworCWlmIChOVUxMID09IGFkZCkKKwkJcmV0dXJuIE5VTEw7CisKKwlhZGQtPmdyYW50cyAgICA9IGt6YWxsb2Moc2l6ZW9mKGFkZC0+Z3JhbnRzWzBdKSAgICAqIGNvdW50LCBHRlBfS0VSTkVMKTsKKwlhZGQtPm1hcF9vcHMgICA9IGt6YWxsb2Moc2l6ZW9mKGFkZC0+bWFwX29wc1swXSkgICAqIGNvdW50LCBHRlBfS0VSTkVMKTsKKwlhZGQtPnVubWFwX29wcyA9IGt6YWxsb2Moc2l6ZW9mKGFkZC0+dW5tYXBfb3BzWzBdKSAqIGNvdW50LCBHRlBfS0VSTkVMKTsKKwlhZGQtPnBhZ2VzICAgICA9IGt6YWxsb2Moc2l6ZW9mKGFkZC0+cGFnZXNbMF0pICAgICAqIGNvdW50LCBHRlBfS0VSTkVMKTsKKwlpZiAoTlVMTCA9PSBhZGQtPmdyYW50cyAgICB8fAorCSAgICBOVUxMID09IGFkZC0+bWFwX29wcyAgIHx8CisJICAgIE5VTEwgPT0gYWRkLT51bm1hcF9vcHMgfHwKKwkgICAgTlVMTCA9PSBhZGQtPnBhZ2VzKQorCQlnb3RvIGVycjsKKworCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsrKSB7CisJCWFkZC0+cGFnZXNbaV0gPSBhbGxvY19wYWdlKEdGUF9LRVJORUwgfCBfX0dGUF9ISUdITUVNKTsKKwkJaWYgKGFkZC0+cGFnZXNbaV0gPT0gTlVMTCkKKwkJCWdvdG8gZXJyOworCX0KKworCWFkZC0+aW5kZXggPSAwOworCWFkZC0+Y291bnQgPSBjb3VudDsKKwlhZGQtPnByaXYgID0gcHJpdjsKKworCWlmIChhZGQtPmNvdW50ICsgcHJpdi0+dXNlZCA+IHByaXYtPmxpbWl0KQorCQlnb3RvIGVycjsKKworCXJldHVybiBhZGQ7CisKK2VycjoKKwlpZiAoYWRkLT5wYWdlcykKKwkJZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspIHsKKwkJCWlmIChhZGQtPnBhZ2VzW2ldKQorCQkJCV9fZnJlZV9wYWdlKGFkZC0+cGFnZXNbaV0pOworCQl9CisJa2ZyZWUoYWRkLT5wYWdlcyk7CisJa2ZyZWUoYWRkLT5ncmFudHMpOworCWtmcmVlKGFkZC0+bWFwX29wcyk7CisJa2ZyZWUoYWRkLT51bm1hcF9vcHMpOworCWtmcmVlKGFkZCk7CisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyB2b2lkIGdudGRldl9hZGRfbWFwKHN0cnVjdCBnbnRkZXZfcHJpdiAqcHJpdiwgc3RydWN0IGdyYW50X21hcCAqYWRkKQoreworCXN0cnVjdCBncmFudF9tYXAgKm1hcDsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkobWFwLCAmcHJpdi0+bWFwcywgbmV4dCkgeworCQlpZiAoYWRkLT5pbmRleCArIGFkZC0+Y291bnQgPCBtYXAtPmluZGV4KSB7CisJCQlsaXN0X2FkZF90YWlsKCZhZGQtPm5leHQsICZtYXAtPm5leHQpOworCQkJZ290byBkb25lOworCQl9CisJCWFkZC0+aW5kZXggPSBtYXAtPmluZGV4ICsgbWFwLT5jb3VudDsKKwl9CisJbGlzdF9hZGRfdGFpbCgmYWRkLT5uZXh0LCAmcHJpdi0+bWFwcyk7CisKK2RvbmU6CisJcHJpdi0+dXNlZCArPSBhZGQtPmNvdW50OworCWdudGRldl9wcmludF9tYXBzKHByaXYsICJbbmV3XSIsIGFkZC0+aW5kZXgpOworfQorCitzdGF0aWMgc3RydWN0IGdyYW50X21hcCAqZ250ZGV2X2ZpbmRfbWFwX2luZGV4KHN0cnVjdCBnbnRkZXZfcHJpdiAqcHJpdiwKKwkJaW50IGluZGV4LCBpbnQgY291bnQpCit7CisJc3RydWN0IGdyYW50X21hcCAqbWFwOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShtYXAsICZwcml2LT5tYXBzLCBuZXh0KSB7CisJCWlmIChtYXAtPmluZGV4ICE9IGluZGV4KQorCQkJY29udGludWU7CisJCWlmIChtYXAtPmNvdW50ICE9IGNvdW50KQorCQkJY29udGludWU7CisJCXJldHVybiBtYXA7CisJfQorCXJldHVybiBOVUxMOworfQorCitzdGF0aWMgc3RydWN0IGdyYW50X21hcCAqZ250ZGV2X2ZpbmRfbWFwX3ZhZGRyKHN0cnVjdCBnbnRkZXZfcHJpdiAqcHJpdiwKKwkJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgdmFkZHIpCit7CisJc3RydWN0IGdyYW50X21hcCAqbWFwOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShtYXAsICZwcml2LT5tYXBzLCBuZXh0KSB7CisJCWlmICghbWFwLT52bWEpCisJCQljb250aW51ZTsKKwkJaWYgKHZhZGRyIDwgbWFwLT52bWEtPnZtX3N0YXJ0KQorCQkJY29udGludWU7CisJCWlmICh2YWRkciA+PSBtYXAtPnZtYS0+dm1fZW5kKQorCQkJY29udGludWU7CisJCXJldHVybiBtYXA7CisJfQorCXJldHVybiBOVUxMOworfQorCitzdGF0aWMgaW50IGdudGRldl9kZWxfbWFwKHN0cnVjdCBncmFudF9tYXAgKm1hcCkKK3sKKwlpbnQgaTsKKworCWlmIChtYXAtPnZtYSkKKwkJcmV0dXJuIC1FQlVTWTsKKwlmb3IgKGkgPSAwOyBpIDwgbWFwLT5jb3VudDsgaSsrKQorCQlpZiAobWFwLT51bm1hcF9vcHNbaV0uaGFuZGxlKQorCQkJcmV0dXJuIC1FQlVTWTsKKworCW1hcC0+cHJpdi0+dXNlZCAtPSBtYXAtPmNvdW50OworCWxpc3RfZGVsKCZtYXAtPm5leHQpOworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBnbnRkZXZfZnJlZV9tYXAoc3RydWN0IGdyYW50X21hcCAqbWFwKQoreworCWludCBpOworCisJaWYgKCFtYXApCisJCXJldHVybjsKKworCWlmIChtYXAtPnBhZ2VzKQorCQlmb3IgKGkgPSAwOyBpIDwgbWFwLT5jb3VudDsgaSsrKSB7CisJCQlpZiAobWFwLT5wYWdlc1tpXSkKKwkJCQlfX2ZyZWVfcGFnZShtYXAtPnBhZ2VzW2ldKTsKKwkJfQorCWtmcmVlKG1hcC0+cGFnZXMpOworCWtmcmVlKG1hcC0+Z3JhbnRzKTsKKwlrZnJlZShtYXAtPm1hcF9vcHMpOworCWtmcmVlKG1hcC0+dW5tYXBfb3BzKTsKKwlrZnJlZShtYXApOworfQorCisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KKworc3RhdGljIGludCBmaW5kX2dyYW50X3B0ZXMocHRlX3QgKnB0ZSwgcGd0YWJsZV90IHRva2VuLAorCQl1bnNpZ25lZCBsb25nIGFkZHIsIHZvaWQgKmRhdGEpCit7CisJc3RydWN0IGdyYW50X21hcCAqbWFwID0gZGF0YTsKKwl1bnNpZ25lZCBpbnQgcGduciA9IChhZGRyIC0gbWFwLT52bWEtPnZtX3N0YXJ0KSA+PiBQQUdFX1NISUZUOworCXU2NCBwdGVfbWFkZHI7CisKKwlCVUdfT04ocGduciA+PSBtYXAtPmNvdW50KTsKKwlwdGVfbWFkZHIgPSBhcmJpdHJhcnlfdmlydF90b19tYWNoaW5lKHB0ZSkubWFkZHI7CisKKwlnbnR0YWJfc2V0X21hcF9vcCgmbWFwLT5tYXBfb3BzW3BnbnJdLCBwdGVfbWFkZHIsCisJCQkgIEdOVE1BUF9jb250YWluc19wdGUgfCBtYXAtPmZsYWdzLAorCQkJICBtYXAtPmdyYW50c1twZ25yXS5yZWYsCisJCQkgIG1hcC0+Z3JhbnRzW3BnbnJdLmRvbWlkKTsKKwlnbnR0YWJfc2V0X3VubWFwX29wKCZtYXAtPnVubWFwX29wc1twZ25yXSwgcHRlX21hZGRyLAorCQkJICAgIEdOVE1BUF9jb250YWluc19wdGUgfCBtYXAtPmZsYWdzLAorCQkJICAgIDAgLyogaGFuZGxlICovKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBtYXBfZ3JhbnRfcGFnZXMoc3RydWN0IGdyYW50X21hcCAqbWFwKQoreworCWludCBpLCBlcnIgPSAwOworCisJcHJfZGVidWcoIm1hcCAlZCslZFxuIiwgbWFwLT5pbmRleCwgbWFwLT5jb3VudCk7CisJZXJyID0gZ250dGFiX21hcF9yZWZzKG1hcC0+bWFwX29wcywgbWFwLT5wYWdlcywgbWFwLT5jb3VudCk7CisJaWYgKGVycikKKwkJcmV0dXJuIGVycjsKKworCWZvciAoaSA9IDA7IGkgPCBtYXAtPmNvdW50OyBpKyspIHsKKwkJaWYgKG1hcC0+bWFwX29wc1tpXS5zdGF0dXMpCisJCQllcnIgPSAtRUlOVkFMOworCQltYXAtPnVubWFwX29wc1tpXS5oYW5kbGUgPSBtYXAtPm1hcF9vcHNbaV0uaGFuZGxlOworCX0KKwlyZXR1cm4gZXJyOworfQorCitzdGF0aWMgaW50IHVubWFwX2dyYW50X3BhZ2VzKHN0cnVjdCBncmFudF9tYXAgKm1hcCwgaW50IG9mZnNldCwgaW50IHBhZ2VzKQoreworCWludCBpLCBlcnIgPSAwOworCisJcHJfZGVidWcoIm1hcCAlZCslZCBbJWQrJWRdXG4iLCBtYXAtPmluZGV4LCBtYXAtPmNvdW50LCBvZmZzZXQsIHBhZ2VzKTsKKwllcnIgPSBnbnR0YWJfdW5tYXBfcmVmcyhtYXAtPnVubWFwX29wcyArIG9mZnNldCwgbWFwLT5wYWdlcywgcGFnZXMpOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CisKKwlmb3IgKGkgPSAwOyBpIDwgcGFnZXM7IGkrKykgeworCQlpZiAobWFwLT51bm1hcF9vcHNbb2Zmc2V0K2ldLnN0YXR1cykKKwkJCWVyciA9IC1FSU5WQUw7CisJCW1hcC0+dW5tYXBfb3BzW29mZnNldCtpXS5oYW5kbGUgPSAwOworCX0KKwlyZXR1cm4gZXJyOworfQorCisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KKworc3RhdGljIHZvaWQgZ250ZGV2X3ZtYV9jbG9zZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlzdHJ1Y3QgZ3JhbnRfbWFwICptYXAgPSB2bWEtPnZtX3ByaXZhdGVfZGF0YTsKKworCXByX2RlYnVnKCJjbG9zZSAlcFxuIiwgdm1hKTsKKwltYXAtPmlzX21hcHBlZCA9IDA7CisJbWFwLT52bWEgPSBOVUxMOworCXZtYS0+dm1fcHJpdmF0ZV9kYXRhID0gTlVMTDsKK30KKworc3RhdGljIGludCBnbnRkZXZfdm1hX2ZhdWx0KHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLCBzdHJ1Y3Qgdm1fZmF1bHQgKnZtZikKK3sKKwlwcl9kZWJ1ZygidmFkZHIgJXAsIHBnb2ZmICVsZCAoc2hvdWxkbid0IGhhcHBlbilcbiIsCisJCQl2bWYtPnZpcnR1YWxfYWRkcmVzcywgdm1mLT5wZ29mZik7CisJdm1mLT5mbGFncyA9IFZNX0ZBVUxUX0VSUk9SOworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IHZtX29wZXJhdGlvbnNfc3RydWN0IGdudGRldl92bW9wcyA9IHsKKwkuY2xvc2UgPSBnbnRkZXZfdm1hX2Nsb3NlLAorCS5mYXVsdCA9IGdudGRldl92bWFfZmF1bHQsCit9OworCisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KKworc3RhdGljIHZvaWQgbW5faW52bF9yYW5nZV9zdGFydChzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKKwkJCQlzdHJ1Y3QgbW1fc3RydWN0ICptbSwKKwkJCQl1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIGVuZCkKK3sKKwlzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYgPSBjb250YWluZXJfb2YobW4sIHN0cnVjdCBnbnRkZXZfcHJpdiwgbW4pOworCXN0cnVjdCBncmFudF9tYXAgKm1hcDsKKwl1bnNpZ25lZCBsb25nIG1zdGFydCwgbWVuZDsKKwlpbnQgZXJyOworCisJc3Bpbl9sb2NrKCZwcml2LT5sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KG1hcCwgJnByaXYtPm1hcHMsIG5leHQpIHsKKwkJaWYgKCFtYXAtPnZtYSkKKwkJCWNvbnRpbnVlOworCQlpZiAoIW1hcC0+aXNfbWFwcGVkKQorCQkJY29udGludWU7CisJCWlmIChtYXAtPnZtYS0+dm1fc3RhcnQgPj0gZW5kKQorCQkJY29udGludWU7CisJCWlmIChtYXAtPnZtYS0+dm1fZW5kIDw9IHN0YXJ0KQorCQkJY29udGludWU7CisJCW1zdGFydCA9IG1heChzdGFydCwgbWFwLT52bWEtPnZtX3N0YXJ0KTsKKwkJbWVuZCAgID0gbWluKGVuZCwgICBtYXAtPnZtYS0+dm1fZW5kKTsKKwkJcHJfZGVidWcoIm1hcCAlZCslZCAoJWx4ICVseCksIHJhbmdlICVseCAlbHgsIG1yYW5nZSAlbHggJWx4XG4iLAorCQkJCW1hcC0+aW5kZXgsIG1hcC0+Y291bnQsCisJCQkJbWFwLT52bWEtPnZtX3N0YXJ0LCBtYXAtPnZtYS0+dm1fZW5kLAorCQkJCXN0YXJ0LCBlbmQsIG1zdGFydCwgbWVuZCk7CisJCWVyciA9IHVubWFwX2dyYW50X3BhZ2VzKG1hcCwKKwkJCQkJKG1zdGFydCAtIG1hcC0+dm1hLT52bV9zdGFydCkgPj4gUEFHRV9TSElGVCwKKwkJCQkJKG1lbmQgLSBtc3RhcnQpID4+IFBBR0VfU0hJRlQpOworCQlXQVJOX09OKGVycik7CisJfQorCXNwaW5fdW5sb2NrKCZwcml2LT5sb2NrKTsKK30KKworc3RhdGljIHZvaWQgbW5faW52bF9wYWdlKHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLAorCQkJIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJIHVuc2lnbmVkIGxvbmcgYWRkcmVzcykKK3sKKwltbl9pbnZsX3JhbmdlX3N0YXJ0KG1uLCBtbSwgYWRkcmVzcywgYWRkcmVzcyArIFBBR0VfU0laRSk7Cit9CisKK3N0YXRpYyB2b2lkIG1uX3JlbGVhc2Uoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sCisJCSAgICAgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSkKK3sKKwlzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYgPSBjb250YWluZXJfb2YobW4sIHN0cnVjdCBnbnRkZXZfcHJpdiwgbW4pOworCXN0cnVjdCBncmFudF9tYXAgKm1hcDsKKwlpbnQgZXJyOworCisJc3Bpbl9sb2NrKCZwcml2LT5sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KG1hcCwgJnByaXYtPm1hcHMsIG5leHQpIHsKKwkJaWYgKCFtYXAtPnZtYSkKKwkJCWNvbnRpbnVlOworCQlwcl9kZWJ1ZygibWFwICVkKyVkICglbHggJWx4KVxuIiwKKwkJCQltYXAtPmluZGV4LCBtYXAtPmNvdW50LAorCQkJCW1hcC0+dm1hLT52bV9zdGFydCwgbWFwLT52bWEtPnZtX2VuZCk7CisJCWVyciA9IHVubWFwX2dyYW50X3BhZ2VzKG1hcCwgLyogb2Zmc2V0ICovIDAsIG1hcC0+Y291bnQpOworCQlXQVJOX09OKGVycik7CisJfQorCXNwaW5fdW5sb2NrKCZwcml2LT5sb2NrKTsKK30KKworc3RydWN0IG1tdV9ub3RpZmllcl9vcHMgZ250ZGV2X21tdV9vcHMgPSB7CisJLnJlbGVhc2UgICAgICAgICAgICAgICAgPSBtbl9yZWxlYXNlLAorCS5pbnZhbGlkYXRlX3BhZ2UgICAgICAgID0gbW5faW52bF9wYWdlLAorCS5pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0ID0gbW5faW52bF9yYW5nZV9zdGFydCwKK307CisKKy8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLworCitzdGF0aWMgaW50IGdudGRldl9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmbGlwKQoreworCXN0cnVjdCBnbnRkZXZfcHJpdiAqcHJpdjsKKwlpbnQgcmV0ID0gMDsKKworCXByaXYgPSBremFsbG9jKHNpemVvZigqcHJpdiksIEdGUF9LRVJORUwpOworCWlmICghcHJpdikKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlJTklUX0xJU1RfSEVBRCgmcHJpdi0+bWFwcyk7CisJc3Bpbl9sb2NrX2luaXQoJnByaXYtPmxvY2spOworCXByaXYtPmxpbWl0ID0gbGltaXQ7CisKKwlwcml2LT5tbSA9IGdldF90YXNrX21tKGN1cnJlbnQpOworCWlmICghcHJpdi0+bW0pIHsKKwkJa2ZyZWUocHJpdik7CisJCXJldHVybiAtRU5PTUVNOworCX0KKwlwcml2LT5tbi5vcHMgPSAmZ250ZGV2X21tdV9vcHM7CisJcmV0ID0gbW11X25vdGlmaWVyX3JlZ2lzdGVyKCZwcml2LT5tbiwgcHJpdi0+bW0pOworCW1tcHV0KHByaXYtPm1tKTsKKworCWlmIChyZXQpIHsKKwkJa2ZyZWUocHJpdik7CisJCXJldHVybiByZXQ7CisJfQorCisJZmxpcC0+cHJpdmF0ZV9kYXRhID0gcHJpdjsKKwlwcl9kZWJ1ZygicHJpdiAlcFxuIiwgcHJpdik7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBnbnRkZXZfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmxpcCkKK3sKKwlzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYgPSBmbGlwLT5wcml2YXRlX2RhdGE7CisJc3RydWN0IGdyYW50X21hcCAqbWFwOworCWludCBlcnI7CisKKwlwcl9kZWJ1ZygicHJpdiAlcFxuIiwgcHJpdik7CisKKwlzcGluX2xvY2soJnByaXYtPmxvY2spOworCXdoaWxlICghbGlzdF9lbXB0eSgmcHJpdi0+bWFwcykpIHsKKwkJbWFwID0gbGlzdF9lbnRyeShwcml2LT5tYXBzLm5leHQsIHN0cnVjdCBncmFudF9tYXAsIG5leHQpOworCQllcnIgPSBnbnRkZXZfZGVsX21hcChtYXApOworCQlpZiAoV0FSTl9PTihlcnIpKQorCQkJZ250ZGV2X2ZyZWVfbWFwKG1hcCk7CisKKwl9CisJc3Bpbl91bmxvY2soJnByaXYtPmxvY2spOworCisJbW11X25vdGlmaWVyX3VucmVnaXN0ZXIoJnByaXYtPm1uLCBwcml2LT5tbSk7CisJa2ZyZWUocHJpdik7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBsb25nIGdudGRldl9pb2N0bF9tYXBfZ3JhbnRfcmVmKHN0cnVjdCBnbnRkZXZfcHJpdiAqcHJpdiwKKwkJCQkgICAgICAgc3RydWN0IGlvY3RsX2dudGRldl9tYXBfZ3JhbnRfcmVmIF9fdXNlciAqdSkKK3sKKwlzdHJ1Y3QgaW9jdGxfZ250ZGV2X21hcF9ncmFudF9yZWYgb3A7CisJc3RydWN0IGdyYW50X21hcCAqbWFwOworCWludCBlcnI7CisKKwlpZiAoY29weV9mcm9tX3VzZXIoJm9wLCB1LCBzaXplb2Yob3ApKSAhPSAwKQorCQlyZXR1cm4gLUVGQVVMVDsKKwlwcl9kZWJ1ZygicHJpdiAlcCwgYWRkICVkXG4iLCBwcml2LCBvcC5jb3VudCk7CisJaWYgKHVubGlrZWx5KG9wLmNvdW50IDw9IDApKQorCQlyZXR1cm4gLUVJTlZBTDsKKwlpZiAodW5saWtlbHkob3AuY291bnQgPiBwcml2LT5saW1pdCkpCisJCXJldHVybiAtRUlOVkFMOworCisJZXJyID0gLUVOT01FTTsKKwltYXAgPSBnbnRkZXZfYWxsb2NfbWFwKHByaXYsIG9wLmNvdW50KTsKKwlpZiAoIW1hcCkKKwkJcmV0dXJuIGVycjsKKwlpZiAoY29weV9mcm9tX3VzZXIobWFwLT5ncmFudHMsICZ1LT5yZWZzLAorCQkJICAgc2l6ZW9mKG1hcC0+Z3JhbnRzWzBdKSAqIG9wLmNvdW50KSAhPSAwKSB7CisJCWdudGRldl9mcmVlX21hcChtYXApOworCQlyZXR1cm4gZXJyOworCX0KKworCXNwaW5fbG9jaygmcHJpdi0+bG9jayk7CisJZ250ZGV2X2FkZF9tYXAocHJpdiwgbWFwKTsKKwlvcC5pbmRleCA9IG1hcC0+aW5kZXggPDwgUEFHRV9TSElGVDsKKwlzcGluX3VubG9jaygmcHJpdi0+bG9jayk7CisKKwlpZiAoY29weV90b191c2VyKHUsICZvcCwgc2l6ZW9mKG9wKSkgIT0gMCkgeworCQlzcGluX2xvY2soJnByaXYtPmxvY2spOworCQlnbnRkZXZfZGVsX21hcChtYXApOworCQlzcGluX3VubG9jaygmcHJpdi0+bG9jayk7CisJCWdudGRldl9mcmVlX21hcChtYXApOworCQlyZXR1cm4gZXJyOworCX0KKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGxvbmcgZ250ZGV2X2lvY3RsX3VubWFwX2dyYW50X3JlZihzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYsCisJCQkJCSBzdHJ1Y3QgaW9jdGxfZ250ZGV2X3VubWFwX2dyYW50X3JlZiBfX3VzZXIgKnUpCit7CisJc3RydWN0IGlvY3RsX2dudGRldl91bm1hcF9ncmFudF9yZWYgb3A7CisJc3RydWN0IGdyYW50X21hcCAqbWFwOworCWludCBlcnIgPSAtRU5PRU5UOworCisJaWYgKGNvcHlfZnJvbV91c2VyKCZvcCwgdSwgc2l6ZW9mKG9wKSkgIT0gMCkKKwkJcmV0dXJuIC1FRkFVTFQ7CisJcHJfZGVidWcoInByaXYgJXAsIGRlbCAlZCslZFxuIiwgcHJpdiwgKGludClvcC5pbmRleCwgKGludClvcC5jb3VudCk7CisKKwlzcGluX2xvY2soJnByaXYtPmxvY2spOworCW1hcCA9IGdudGRldl9maW5kX21hcF9pbmRleChwcml2LCBvcC5pbmRleCA+PiBQQUdFX1NISUZULCBvcC5jb3VudCk7CisJaWYgKG1hcCkKKwkJZXJyID0gZ250ZGV2X2RlbF9tYXAobWFwKTsKKwlzcGluX3VubG9jaygmcHJpdi0+bG9jayk7CisJaWYgKCFlcnIpCisJCWdudGRldl9mcmVlX21hcChtYXApOworCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyBsb25nIGdudGRldl9pb2N0bF9nZXRfb2Zmc2V0X2Zvcl92YWRkcihzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYsCisJCQkJCSAgICAgIHN0cnVjdCBpb2N0bF9nbnRkZXZfZ2V0X29mZnNldF9mb3JfdmFkZHIgX191c2VyICp1KQoreworCXN0cnVjdCBpb2N0bF9nbnRkZXZfZ2V0X29mZnNldF9mb3JfdmFkZHIgb3A7CisJc3RydWN0IGdyYW50X21hcCAqbWFwOworCisJaWYgKGNvcHlfZnJvbV91c2VyKCZvcCwgdSwgc2l6ZW9mKG9wKSkgIT0gMCkKKwkJcmV0dXJuIC1FRkFVTFQ7CisJcHJfZGVidWcoInByaXYgJXAsIG9mZnNldCBmb3IgdmFkZHIgJWx4XG4iLCBwcml2LCAodW5zaWduZWQgbG9uZylvcC52YWRkcik7CisKKwlzcGluX2xvY2soJnByaXYtPmxvY2spOworCW1hcCA9IGdudGRldl9maW5kX21hcF92YWRkcihwcml2LCBvcC52YWRkcik7CisJaWYgKG1hcCA9PSBOVUxMIHx8CisJICAgIG1hcC0+dm1hLT52bV9zdGFydCAhPSBvcC52YWRkcikgeworCQlzcGluX3VubG9jaygmcHJpdi0+bG9jayk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlvcC5vZmZzZXQgPSBtYXAtPmluZGV4IDw8IFBBR0VfU0hJRlQ7CisJb3AuY291bnQgPSBtYXAtPmNvdW50OworCXNwaW5fdW5sb2NrKCZwcml2LT5sb2NrKTsKKworCWlmIChjb3B5X3RvX3VzZXIodSwgJm9wLCBzaXplb2Yob3ApKSAhPSAwKQorCQlyZXR1cm4gLUVGQVVMVDsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGxvbmcgZ250ZGV2X2lvY3RsX3NldF9tYXhfZ3JhbnRzKHN0cnVjdCBnbnRkZXZfcHJpdiAqcHJpdiwKKwkJCQkJc3RydWN0IGlvY3RsX2dudGRldl9zZXRfbWF4X2dyYW50cyBfX3VzZXIgKnUpCit7CisJc3RydWN0IGlvY3RsX2dudGRldl9zZXRfbWF4X2dyYW50cyBvcDsKKworCWlmIChjb3B5X2Zyb21fdXNlcigmb3AsIHUsIHNpemVvZihvcCkpICE9IDApCisJCXJldHVybiAtRUZBVUxUOworCXByX2RlYnVnKCJwcml2ICVwLCBsaW1pdCAlZFxuIiwgcHJpdiwgb3AuY291bnQpOworCWlmIChvcC5jb3VudCA+IGxpbWl0KQorCQlyZXR1cm4gLUUyQklHOworCisJc3Bpbl9sb2NrKCZwcml2LT5sb2NrKTsKKwlwcml2LT5saW1pdCA9IG9wLmNvdW50OworCXNwaW5fdW5sb2NrKCZwcml2LT5sb2NrKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGxvbmcgZ250ZGV2X2lvY3RsKHN0cnVjdCBmaWxlICpmbGlwLAorCQkJIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQoreworCXN0cnVjdCBnbnRkZXZfcHJpdiAqcHJpdiA9IGZsaXAtPnByaXZhdGVfZGF0YTsKKwl2b2lkIF9fdXNlciAqcHRyID0gKHZvaWQgX191c2VyICopYXJnOworCisJc3dpdGNoIChjbWQpIHsKKwljYXNlIElPQ1RMX0dOVERFVl9NQVBfR1JBTlRfUkVGOgorCQlyZXR1cm4gZ250ZGV2X2lvY3RsX21hcF9ncmFudF9yZWYocHJpdiwgcHRyKTsKKworCWNhc2UgSU9DVExfR05UREVWX1VOTUFQX0dSQU5UX1JFRjoKKwkJcmV0dXJuIGdudGRldl9pb2N0bF91bm1hcF9ncmFudF9yZWYocHJpdiwgcHRyKTsKKworCWNhc2UgSU9DVExfR05UREVWX0dFVF9PRkZTRVRfRk9SX1ZBRERSOgorCQlyZXR1cm4gZ250ZGV2X2lvY3RsX2dldF9vZmZzZXRfZm9yX3ZhZGRyKHByaXYsIHB0cik7CisKKwljYXNlIElPQ1RMX0dOVERFVl9TRVRfTUFYX0dSQU5UUzoKKwkJcmV0dXJuIGdudGRldl9pb2N0bF9zZXRfbWF4X2dyYW50cyhwcml2LCBwdHIpOworCisJZGVmYXVsdDoKKwkJcHJfZGVidWcoInByaXYgJXAsIHVua25vd24gY21kICV4XG4iLCBwcml2LCBjbWQpOworCQlyZXR1cm4gLUVOT0lPQ1RMQ01EOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGdudGRldl9tbWFwKHN0cnVjdCBmaWxlICpmbGlwLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYgPSBmbGlwLT5wcml2YXRlX2RhdGE7CisJaW50IGluZGV4ID0gdm1hLT52bV9wZ29mZjsKKwlpbnQgY291bnQgPSAodm1hLT52bV9lbmQgLSB2bWEtPnZtX3N0YXJ0KSA+PiBQQUdFX1NISUZUOworCXN0cnVjdCBncmFudF9tYXAgKm1hcDsKKwlpbnQgZXJyID0gLUVJTlZBTDsKKworCWlmICgodm1hLT52bV9mbGFncyAmIFZNX1dSSVRFKSAmJiAhKHZtYS0+dm1fZmxhZ3MgJiBWTV9TSEFSRUQpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCXByX2RlYnVnKCJtYXAgJWQrJWQgYXQgJWx4IChwZ29mZiAlbHgpXG4iLAorCQkJaW5kZXgsIGNvdW50LCB2bWEtPnZtX3N0YXJ0LCB2bWEtPnZtX3Bnb2ZmKTsKKworCXNwaW5fbG9jaygmcHJpdi0+bG9jayk7CisJbWFwID0gZ250ZGV2X2ZpbmRfbWFwX2luZGV4KHByaXYsIGluZGV4LCBjb3VudCk7CisJaWYgKCFtYXApCisJCWdvdG8gdW5sb2NrX291dDsKKwlpZiAobWFwLT52bWEpCisJCWdvdG8gdW5sb2NrX291dDsKKwlpZiAocHJpdi0+bW0gIT0gdm1hLT52bV9tbSkgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJIdWg/IE90aGVyIG1tP1xuIik7CisJCWdvdG8gdW5sb2NrX291dDsKKwl9CisKKwl2bWEtPnZtX29wcyA9ICZnbnRkZXZfdm1vcHM7CisKKwl2bWEtPnZtX2ZsYWdzIHw9IFZNX1JFU0VSVkVEfFZNX0RPTlRDT1BZfFZNX0RPTlRFWFBBTkR8Vk1fUEZOTUFQOworCisJdm1hLT52bV9wcml2YXRlX2RhdGEgPSBtYXA7CisJbWFwLT52bWEgPSB2bWE7CisKKwltYXAtPmZsYWdzID0gR05UTUFQX2hvc3RfbWFwIHwgR05UTUFQX2FwcGxpY2F0aW9uX21hcDsKKwlpZiAoISh2bWEtPnZtX2ZsYWdzICYgVk1fV1JJVEUpKQorCQltYXAtPmZsYWdzIHw9IEdOVE1BUF9yZWFkb25seTsKKworCXNwaW5fdW5sb2NrKCZwcml2LT5sb2NrKTsKKworCWVyciA9IGFwcGx5X3RvX3BhZ2VfcmFuZ2Uodm1hLT52bV9tbSwgdm1hLT52bV9zdGFydCwKKwkJCQkgIHZtYS0+dm1fZW5kIC0gdm1hLT52bV9zdGFydCwKKwkJCQkgIGZpbmRfZ3JhbnRfcHRlcywgbWFwKTsKKwlpZiAoZXJyKSB7CisJCXByaW50ayhLRVJOX1dBUk5JTkcgImZpbmRfZ3JhbnRfcHRlcygpIGZhaWx1cmUuXG4iKTsKKwkJcmV0dXJuIGVycjsKKwl9CisKKwllcnIgPSBtYXBfZ3JhbnRfcGFnZXMobWFwKTsKKwlpZiAoZXJyKSB7CisJCXByaW50ayhLRVJOX1dBUk5JTkcgIm1hcF9ncmFudF9wYWdlcygpIGZhaWx1cmUuXG4iKTsKKwkJcmV0dXJuIGVycjsKKwl9CisKKwltYXAtPmlzX21hcHBlZCA9IDE7CisKKwlyZXR1cm4gMDsKKwordW5sb2NrX291dDoKKwlzcGluX3VubG9jaygmcHJpdi0+bG9jayk7CisJcmV0dXJuIGVycjsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgZ250ZGV2X2ZvcHMgPSB7CisJLm93bmVyID0gVEhJU19NT0RVTEUsCisJLm9wZW4gPSBnbnRkZXZfb3BlbiwKKwkucmVsZWFzZSA9IGdudGRldl9yZWxlYXNlLAorCS5tbWFwID0gZ250ZGV2X21tYXAsCisJLnVubG9ja2VkX2lvY3RsID0gZ250ZGV2X2lvY3RsCit9OworCitzdGF0aWMgc3RydWN0IG1pc2NkZXZpY2UgZ250ZGV2X21pc2NkZXYgPSB7CisJLm1pbm9yICAgICAgICA9IE1JU0NfRFlOQU1JQ19NSU5PUiwKKwkubmFtZSAgICAgICAgID0gInhlbi9nbnRkZXYiLAorCS5mb3BzICAgICAgICAgPSAmZ250ZGV2X2ZvcHMsCit9OworCisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KKworc3RhdGljIGludCBfX2luaXQgZ250ZGV2X2luaXQodm9pZCkKK3sKKwlpbnQgZXJyOworCisJaWYgKCF4ZW5fZG9tYWluKCkpCisJCXJldHVybiAtRU5PREVWOworCisJZXJyID0gbWlzY19yZWdpc3RlcigmZ250ZGV2X21pc2NkZXYpOworCWlmIChlcnIgIT0gMCkgeworCQlwcmludGsoS0VSTl9FUlIgIkNvdWxkIG5vdCByZWdpc3RlciBnbnRkZXYgZGV2aWNlXG4iKTsKKwkJcmV0dXJuIGVycjsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBnbnRkZXZfZXhpdCh2b2lkKQoreworCW1pc2NfZGVyZWdpc3RlcigmZ250ZGV2X21pc2NkZXYpOworfQorCittb2R1bGVfaW5pdChnbnRkZXZfaW5pdCk7Cittb2R1bGVfZXhpdChnbnRkZXZfZXhpdCk7CisKKy8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vZ3JhbnQtdGFibGUuYyBiL2RyaXZlcnMveGVuL2dyYW50LXRhYmxlLmMKaW5kZXggNmM0NTMxOC4uOWVmNTRlYiAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vZ3JhbnQtdGFibGUuYworKysgYi9kcml2ZXJzL3hlbi9ncmFudC10YWJsZS5jCkBAIC00NDcsNiArNDQ3LDUyIEBACiB9CiBFWFBPUlRfU1lNQk9MX0dQTChnbnR0YWJfbWF4X2dyYW50X2ZyYW1lcyk7CiAKK2ludCBnbnR0YWJfbWFwX3JlZnMoc3RydWN0IGdudHRhYl9tYXBfZ3JhbnRfcmVmICptYXBfb3BzLAorCQkgICAgc3RydWN0IHBhZ2UgKipwYWdlcywgdW5zaWduZWQgaW50IGNvdW50KQoreworCWludCBpLCByZXQ7CisJcHRlX3QgKnB0ZTsKKwl1bnNpZ25lZCBsb25nIG1mbjsKKworCXJldCA9IEhZUEVSVklTT1JfZ3JhbnRfdGFibGVfb3AoR05UVEFCT1BfbWFwX2dyYW50X3JlZiwgbWFwX29wcywgY291bnQpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykgeworCQkvKiBtMnAgb3ZlcnJpZGUgb25seSBzdXBwb3J0ZWQgZm9yIEdOVE1BUF9jb250YWluc19wdGUgbWFwcGluZ3MgKi8KKwkJaWYgKCEobWFwX29wc1tpXS5mbGFncyAmIEdOVE1BUF9jb250YWluc19wdGUpKQorCQkJY29udGludWU7CisJCXB0ZSA9IChwdGVfdCAqKSAobWZuX3RvX3ZpcnQoUEZOX0RPV04obWFwX29wc1tpXS5ob3N0X2FkZHIpKSArCisJCQkJKG1hcF9vcHNbaV0uaG9zdF9hZGRyICYgflBBR0VfTUFTSykpOworCQltZm4gPSBwdGVfbWZuKCpwdGUpOworCQlyZXQgPSBtMnBfYWRkX292ZXJyaWRlKG1mbiwgcGFnZXNbaV0pOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorRVhQT1JUX1NZTUJPTF9HUEwoZ250dGFiX21hcF9yZWZzKTsKKworaW50IGdudHRhYl91bm1hcF9yZWZzKHN0cnVjdCBnbnR0YWJfdW5tYXBfZ3JhbnRfcmVmICp1bm1hcF9vcHMsCisJCXN0cnVjdCBwYWdlICoqcGFnZXMsIHVuc2lnbmVkIGludCBjb3VudCkKK3sKKwlpbnQgaSwgcmV0OworCisJcmV0ID0gSFlQRVJWSVNPUl9ncmFudF90YWJsZV9vcChHTlRUQUJPUF91bm1hcF9ncmFudF9yZWYsIHVubWFwX29wcywgY291bnQpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykgeworCQlyZXQgPSBtMnBfcmVtb3ZlX292ZXJyaWRlKHBhZ2VzW2ldKTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7CisJfQorCisJcmV0dXJuIHJldDsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKGdudHRhYl91bm1hcF9yZWZzKTsKKwogc3RhdGljIGludCBnbnR0YWJfbWFwKHVuc2lnbmVkIGludCBzdGFydF9pZHgsIHVuc2lnbmVkIGludCBlbmRfaWR4KQogewogCXN0cnVjdCBnbnR0YWJfc2V0dXBfdGFibGUgc2V0dXA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9wbGF0Zm9ybS1wY2kuYyBiL2RyaXZlcnMveGVuL3BsYXRmb3JtLXBjaS5jCmluZGV4IGMwMWI1ZGQuLmFmYmUwNDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL3BsYXRmb3JtLXBjaS5jCisrKyBiL2RyaXZlcnMveGVuL3BsYXRmb3JtLXBjaS5jCkBAIC0xMDUsNyArMTA1LDcgQEAKIAkJCQkgICAgICAgY29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgKmVudCkKIHsKIAlpbnQgaSwgcmV0OwotCWxvbmcgaW9hZGRyLCBpb2xlbjsKKwlsb25nIGlvYWRkcjsKIAlsb25nIG1taW9fYWRkciwgbW1pb19sZW47CiAJdW5zaWduZWQgaW50IG1heF9ucl9nZnJhbWVzOwogCkBAIC0xMTQsNyArMTE0LDYgQEAKIAkJcmV0dXJuIGk7CiAKIAlpb2FkZHIgPSBwY2lfcmVzb3VyY2Vfc3RhcnQocGRldiwgMCk7Ci0JaW9sZW4gPSBwY2lfcmVzb3VyY2VfbGVuKHBkZXYsIDApOwogCiAJbW1pb19hZGRyID0gcGNpX3Jlc291cmNlX3N0YXJ0KHBkZXYsIDEpOwogCW1taW9fbGVuID0gcGNpX3Jlc291cmNlX2xlbihwZGV2LCAxKTsKQEAgLTEyNSwxOSArMTI0LDEzIEBACiAJCWdvdG8gcGNpX291dDsKIAl9CiAKLQlpZiAocmVxdWVzdF9tZW1fcmVnaW9uKG1taW9fYWRkciwgbW1pb19sZW4sIERSVl9OQU1FKSA9PSBOVUxMKSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgIk1FTSBJL08gcmVzb3VyY2UgMHglbHggQCAweCVseCBidXN5XG4iLAotCQkgICAgICAgbW1pb19hZGRyLCBtbWlvX2xlbik7Ci0JCXJldCA9IC1FQlVTWTsKKwlyZXQgPSBwY2lfcmVxdWVzdF9yZWdpb24ocGRldiwgMSwgRFJWX05BTUUpOworCWlmIChyZXQgPCAwKQogCQlnb3RvIHBjaV9vdXQ7Ci0JfQogCi0JaWYgKHJlcXVlc3RfcmVnaW9uKGlvYWRkciwgaW9sZW4sIERSVl9OQU1FKSA9PSBOVUxMKSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgIkkvTyByZXNvdXJjZSAweCVseCBAIDB4JWx4IGJ1c3lcbiIsCi0JCSAgICAgICBpb2xlbiwgaW9hZGRyKTsKLQkJcmV0ID0gLUVCVVNZOworCXJldCA9IHBjaV9yZXF1ZXN0X3JlZ2lvbihwZGV2LCAwLCBEUlZfTkFNRSk7CisJaWYgKHJldCA8IDApCiAJCWdvdG8gbWVtX291dDsKLQl9CiAKIAlwbGF0Zm9ybV9tbWlvID0gbW1pb19hZGRyOwogCXBsYXRmb3JtX21taW9sZW4gPSBtbWlvX2xlbjsKQEAgLTE2OSw5ICsxNjIsOSBAQAogCXJldHVybiAwOwogCiBvdXQ6Ci0JcmVsZWFzZV9yZWdpb24oaW9hZGRyLCBpb2xlbik7CisJcGNpX3JlbGVhc2VfcmVnaW9uKHBkZXYsIDApOwogbWVtX291dDoKLQlyZWxlYXNlX21lbV9yZWdpb24obW1pb19hZGRyLCBtbWlvX2xlbik7CisJcGNpX3JlbGVhc2VfcmVnaW9uKHBkZXYsIDEpOwogcGNpX291dDoKIAlwY2lfZGlzYWJsZV9kZXZpY2UocGRldik7CiAJcmV0dXJuIHJldDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL3hlbmZzL3hlbmJ1cy5jIGIvZHJpdmVycy94ZW4veGVuZnMveGVuYnVzLmMKaW5kZXggMWMxMjM2MC4uYmJkMDAwZiAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4veGVuZnMveGVuYnVzLmMKKysrIGIvZHJpdmVycy94ZW4veGVuZnMveGVuYnVzLmMKQEAgLTEyMiw2ICsxMjIsNyBAQAogCWludCByZXQ7CiAKIAltdXRleF9sb2NrKCZ1LT5yZXBseV9tdXRleCk7CithZ2FpbjoKIAl3aGlsZSAobGlzdF9lbXB0eSgmdS0+cmVhZF9idWZmZXJzKSkgewogCQltdXRleF91bmxvY2soJnUtPnJlcGx5X211dGV4KTsKIAkJaWYgKGZpbHAtPmZfZmxhZ3MgJiBPX05PTkJMT0NLKQpAQCAtMTQ0LDcgKzE0NSw3IEBACiAJCWkgKz0gc3ogLSByZXQ7CiAJCXJiLT5jb25zICs9IHN6IC0gcmV0OwogCi0JCWlmIChyZXQgIT0gc3opIHsKKwkJaWYgKHJldCAhPSAwKSB7CiAJCQlpZiAoaSA9PSAwKQogCQkJCWkgPSAtRUZBVUxUOwogCQkJZ290byBvdXQ7CkBAIC0xNjAsNiArMTYxLDggQEAKIAkJCQkJc3RydWN0IHJlYWRfYnVmZmVyLCBsaXN0KTsKIAkJfQogCX0KKwlpZiAoaSA9PSAwKQorCQlnb3RvIGFnYWluOwogCiBvdXQ6CiAJbXV0ZXhfdW5sb2NrKCZ1LT5yZXBseV9tdXRleCk7CkBAIC00MDcsNiArNDEwLDcgQEAKIAogCQltdXRleF9sb2NrKCZ1LT5yZXBseV9tdXRleCk7CiAJCXJjID0gcXVldWVfcmVwbHkoJnUtPnJlYWRfYnVmZmVycywgJnJlcGx5LCBzaXplb2YocmVwbHkpKTsKKwkJd2FrZV91cCgmdS0+cmVhZF93YWl0cSk7CiAJCW11dGV4X3VubG9jaygmdS0+cmVwbHlfbXV0ZXgpOwogCX0KIApAQCAtNDU1LDcgKzQ1OSw3IEBACiAKIAlyZXQgPSBjb3B5X2Zyb21fdXNlcih1LT51LmJ1ZmZlciArIHUtPmxlbiwgdWJ1ZiwgbGVuKTsKIAotCWlmIChyZXQgPT0gbGVuKSB7CisJaWYgKHJldCAhPSAwKSB7CiAJCXJjID0gLUVGQVVMVDsKIAkJZ290byBvdXQ7CiAJfQpAQCAtNDg4LDIxICs0OTIsNiBAQAogCW1zZ190eXBlID0gdS0+dS5tc2cudHlwZTsKIAogCXN3aXRjaCAobXNnX3R5cGUpIHsKLQljYXNlIFhTX1RSQU5TQUNUSU9OX1NUQVJUOgotCWNhc2UgWFNfVFJBTlNBQ1RJT05fRU5EOgotCWNhc2UgWFNfRElSRUNUT1JZOgotCWNhc2UgWFNfUkVBRDoKLQljYXNlIFhTX0dFVF9QRVJNUzoKLQljYXNlIFhTX1JFTEVBU0U6Ci0JY2FzZSBYU19HRVRfRE9NQUlOX1BBVEg6Ci0JY2FzZSBYU19XUklURToKLQljYXNlIFhTX01LRElSOgotCWNhc2UgWFNfUk06Ci0JY2FzZSBYU19TRVRfUEVSTVM6Ci0JCS8qIFNlbmQgb3V0IGEgdHJhbnNhY3Rpb24gKi8KLQkJcmV0ID0geGVuYnVzX3dyaXRlX3RyYW5zYWN0aW9uKG1zZ190eXBlLCB1KTsKLQkJYnJlYWs7Ci0KIAljYXNlIFhTX1dBVENIOgogCWNhc2UgWFNfVU5XQVRDSDoKIAkJLyogKFVuKUFzayBmb3Igc29tZSBwYXRoIHRvIGJlIHdhdGNoZWQgZm9yIGNoYW5nZXMgKi8KQEAgLTUxMCw3ICs0OTksOCBAQAogCQlicmVhazsKIAogCWRlZmF1bHQ6Ci0JCXJldCA9IC1FSU5WQUw7CisJCS8qIFNlbmQgb3V0IGEgdHJhbnNhY3Rpb24gKi8KKwkJcmV0ID0geGVuYnVzX3dyaXRlX3RyYW5zYWN0aW9uKG1zZ190eXBlLCB1KTsKIAkJYnJlYWs7CiAJfQogCWlmIChyZXQgIT0gMCkKQEAgLTU1NSw2ICs1NDUsNyBAQAogCXN0cnVjdCB4ZW5idXNfZmlsZV9wcml2ICp1ID0gZmlscC0+cHJpdmF0ZV9kYXRhOwogCXN0cnVjdCB4ZW5idXNfdHJhbnNhY3Rpb25faG9sZGVyICp0cmFucywgKnRtcDsKIAlzdHJ1Y3Qgd2F0Y2hfYWRhcHRlciAqd2F0Y2gsICp0bXBfd2F0Y2g7CisJc3RydWN0IHJlYWRfYnVmZmVyICpyYiwgKnRtcF9yYjsKIAogCS8qCiAJICogTm8gbmVlZCBmb3IgbG9ja2luZyBoZXJlIGJlY2F1c2UgdGhlcmUgYXJlIG5vIG90aGVyIHVzZXJzLApAQCAtNTczLDYgKzU2NCwxMCBAQAogCQlmcmVlX3dhdGNoX2FkYXB0ZXIod2F0Y2gpOwogCX0KIAorCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShyYiwgdG1wX3JiLCAmdS0+cmVhZF9idWZmZXJzLCBsaXN0KSB7CisJCWxpc3RfZGVsKCZyYi0+bGlzdCk7CisJCWtmcmVlKHJiKTsKKwl9CiAJa2ZyZWUodSk7CiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2ZzL0tjb25maWcgYi9mcy9LY29uZmlnCmluZGV4IDc3MWY0NTcuLjNkYjljYWEgMTAwNjQ0Ci0tLSBhL2ZzL0tjb25maWcKKysrIGIvZnMvS2NvbmZpZwpAQCAtMzAsMTUgKzMwLDYgQEAKIHNvdXJjZSAiZnMvcmVpc2VyZnMvS2NvbmZpZyIKIHNvdXJjZSAiZnMvamZzL0tjb25maWciCiAKLWNvbmZpZyBGU19QT1NJWF9BQ0wKLSMgUG9zaXggQUNMIHV0aWxpdHkgcm91dGluZXMgKGZvciBub3csIG9ubHkgZXh0Mi9leHQzL2pmcy9yZWlzZXJmcy9uZnM0KQotIwotIyBOT1RFOiB5b3UgY2FuIGltcGxlbWVudCBQb3NpeCBBQ0xzIHdpdGhvdXQgdGhlc2UgaGVscGVycyAoWEZTIGRvZXMpLgotIyAJTmV2ZXIgdXNlIHRoaXMgc3ltYm9sIGZvciBpZmRlZnMuCi0jCi0JYm9vbAotCWRlZmF1bHQgbgotCiBzb3VyY2UgImZzL3hmcy9LY29uZmlnIgogc291cmNlICJmcy9nZnMyL0tjb25maWciCiBzb3VyY2UgImZzL29jZnMyL0tjb25maWciCkBAIC00NywxMSArMzgsMTkgQEAKIAogZW5kaWYgIyBCTE9DSwogCisjIFBvc2l4IEFDTCB1dGlsaXR5IHJvdXRpbmVzCisjCisjIE5vdGU6IFBvc2l4IEFDTHMgY2FuIGJlIGltcGxlbWVudGVkIHdpdGhvdXQgdGhlc2UgaGVscGVycy4gIE5ldmVyIHVzZQorIyB0aGlzIHN5bWJvbCBmb3IgaWZkZWZzIGluIGNvcmUgY29kZS4KKyMKK2NvbmZpZyBGU19QT1NJWF9BQ0wKKwlkZWZfYm9vbCBuCisKIGNvbmZpZyBFWFBPUlRGUwogCXRyaXN0YXRlCiAKIGNvbmZpZyBGSUxFX0xPQ0tJTkcKLQlib29sICJFbmFibGUgUE9TSVggZmlsZSBsb2NraW5nIEFQSSIgaWYgRU1CRURERUQKKwlib29sICJFbmFibGUgUE9TSVggZmlsZSBsb2NraW5nIEFQSSIgaWYgRVhQRVJUCiAJZGVmYXVsdCB5CiAJaGVscAogCSAgVGhpcyBvcHRpb24gZW5hYmxlcyBzdGFuZGFyZCBmaWxlIGxvY2tpbmcgc3VwcG9ydCwgcmVxdWlyZWQKZGlmZiAtLWdpdCBhL2ZzL2Fmcy9jbXNlcnZpY2UuYyBiL2ZzL2Fmcy9jbXNlcnZpY2UuYwppbmRleCBhM2JjZWM3Li4xYzhjNmNjIDEwMDY0NAotLS0gYS9mcy9hZnMvY21zZXJ2aWNlLmMKKysrIGIvZnMvYWZzL2Ntc2VydmljZS5jCkBAIC0yODksNyArMjg5LDcgQEAKIAljYWxsLT5zZXJ2ZXIgPSBzZXJ2ZXI7CiAKIAlJTklUX1dPUksoJmNhbGwtPndvcmssIFNSWEFGU0NCX0NhbGxCYWNrKTsKLQlzY2hlZHVsZV93b3JrKCZjYWxsLT53b3JrKTsKKwlxdWV1ZV93b3JrKGFmc193cSwgJmNhbGwtPndvcmspOwogCXJldHVybiAwOwogfQogCkBAIC0zMzYsNyArMzM2LDcgQEAKIAljYWxsLT5zZXJ2ZXIgPSBzZXJ2ZXI7CiAKIAlJTklUX1dPUksoJmNhbGwtPndvcmssIFNSWEFGU0NCX0luaXRDYWxsQmFja1N0YXRlKTsKLQlzY2hlZHVsZV93b3JrKCZjYWxsLT53b3JrKTsKKwlxdWV1ZV93b3JrKGFmc193cSwgJmNhbGwtPndvcmspOwogCXJldHVybiAwOwogfQogCkBAIC0zNjcsNyArMzY3LDcgQEAKIAljYWxsLT5zZXJ2ZXIgPSBzZXJ2ZXI7CiAKIAlJTklUX1dPUksoJmNhbGwtPndvcmssIFNSWEFGU0NCX0luaXRDYWxsQmFja1N0YXRlKTsKLQlzY2hlZHVsZV93b3JrKCZjYWxsLT53b3JrKTsKKwlxdWV1ZV93b3JrKGFmc193cSwgJmNhbGwtPndvcmspOwogCXJldHVybiAwOwogfQogCkBAIC00MDAsNyArNDAwLDcgQEAKIAljYWxsLT5zdGF0ZSA9IEFGU19DQUxMX1JFUExZSU5HOwogCiAJSU5JVF9XT1JLKCZjYWxsLT53b3JrLCBTUlhBRlNDQl9Qcm9iZSk7Ci0Jc2NoZWR1bGVfd29yaygmY2FsbC0+d29yayk7CisJcXVldWVfd29yayhhZnNfd3EsICZjYWxsLT53b3JrKTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtNDk2LDcgKzQ5Niw3IEBACiAJY2FsbC0+c3RhdGUgPSBBRlNfQ0FMTF9SRVBMWUlORzsKIAogCUlOSVRfV09SSygmY2FsbC0+d29yaywgU1JYQUZTQ0JfUHJvYmVVdWlkKTsKLQlzY2hlZHVsZV93b3JrKCZjYWxsLT53b3JrKTsKKwlxdWV1ZV93b3JrKGFmc193cSwgJmNhbGwtPndvcmspOwogCXJldHVybiAwOwogfQogCkBAIC01ODAsNiArNTgwLDYgQEAKIAljYWxsLT5zdGF0ZSA9IEFGU19DQUxMX1JFUExZSU5HOwogCiAJSU5JVF9XT1JLKCZjYWxsLT53b3JrLCBTUlhBRlNDQl9UZWxsTWVBYm91dFlvdXJzZWxmKTsKLQlzY2hlZHVsZV93b3JrKCZjYWxsLT53b3JrKTsKKwlxdWV1ZV93b3JrKGFmc193cSwgJmNhbGwtPndvcmspOwogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZnMvYWZzL2Rpci5jIGIvZnMvYWZzL2Rpci5jCmluZGV4IGU2YTRhYjkuLjIwYzEwNmYgMTAwNjQ0Ci0tLSBhL2ZzL2Fmcy9kaXIuYworKysgYi9mcy9hZnMvZGlyLmMKQEAgLTY2LDYgKzY2LDcgQEAKIAkuZF9yZXZhbGlkYXRlCT0gYWZzX2RfcmV2YWxpZGF0ZSwKIAkuZF9kZWxldGUJPSBhZnNfZF9kZWxldGUsCiAJLmRfcmVsZWFzZQk9IGFmc19kX3JlbGVhc2UsCisJLmRfYXV0b21vdW50CT0gYWZzX2RfYXV0b21vdW50LAogfTsKIAogI2RlZmluZSBBRlNfRElSX0hBU0hUQkxfU0laRQkxMjgKZGlmZiAtLWdpdCBhL2ZzL2Fmcy9pbm9kZS5jIGIvZnMvYWZzL2lub2RlLmMKaW5kZXggMDc0NzMzOS4uZGI2NmM1MiAxMDA2NDQKLS0tIGEvZnMvYWZzL2lub2RlLmMKKysrIGIvZnMvYWZzL2lub2RlLmMKQEAgLTE4NCw3ICsxODQsOCBAQAogCWlub2RlLT5pX2dlbmVyYXRpb24JPSAwOwogCiAJc2V0X2JpdChBRlNfVk5PREVfUFNFVURPRElSLCAmdm5vZGUtPmZsYWdzKTsKLQlpbm9kZS0+aV9mbGFncyB8PSBTX05PQVRJTUU7CisJc2V0X2JpdChBRlNfVk5PREVfTU9VTlRQT0lOVCwgJnZub2RlLT5mbGFncyk7CisJaW5vZGUtPmlfZmxhZ3MgfD0gU19BVVRPTU9VTlQgfCBTX05PQVRJTUU7CiAJdW5sb2NrX25ld19pbm9kZShpbm9kZSk7CiAJX2xlYXZlKCIgPSAlcCIsIGlub2RlKTsKIAlyZXR1cm4gaW5vZGU7CmRpZmYgLS1naXQgYS9mcy9hZnMvaW50ZXJuYWwuaCBiL2ZzL2Fmcy9pbnRlcm5hbC5oCmluZGV4IGFiNmRiNWEuLjVhOWI2ODQgMTAwNjQ0Ci0tLSBhL2ZzL2Fmcy9pbnRlcm5hbC5oCisrKyBiL2ZzL2Fmcy9pbnRlcm5hbC5oCkBAIC01NzcsNiArNTc3LDcgQEAKIC8qCiAgKiBtYWluLmMKICAqLworZXh0ZXJuIHN0cnVjdCB3b3JrcXVldWVfc3RydWN0ICphZnNfd3E7CiBleHRlcm4gc3RydWN0IGFmc191dWlkIGFmc191dWlkOwogCiAvKgpAQCAtNTkxLDYgKzU5Miw3IEBACiBleHRlcm4gY29uc3Qgc3RydWN0IGlub2RlX29wZXJhdGlvbnMgYWZzX2F1dG9jZWxsX2lub2RlX29wZXJhdGlvbnM7CiBleHRlcm4gY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBhZnNfbW50cHRfZmlsZV9vcGVyYXRpb25zOwogCitleHRlcm4gc3RydWN0IHZmc21vdW50ICphZnNfZF9hdXRvbW91bnQoc3RydWN0IHBhdGggKik7CiBleHRlcm4gaW50IGFmc19tbnRwdF9jaGVja19zeW1saW5rKHN0cnVjdCBhZnNfdm5vZGUgKiwgc3RydWN0IGtleSAqKTsKIGV4dGVybiB2b2lkIGFmc19tbnRwdF9raWxsX3RpbWVyKHZvaWQpOwogCmRpZmYgLS1naXQgYS9mcy9hZnMvbWFpbi5jIGIvZnMvYWZzL21haW4uYwppbmRleCBjZmQxY2JlLi40MmRkMmU0IDEwMDY0NAotLS0gYS9mcy9hZnMvbWFpbi5jCisrKyBiL2ZzL2Fmcy9tYWluLmMKQEAgLTMwLDYgKzMwLDcgQEAKIE1PRFVMRV9QQVJNX0RFU0Mocm9vdGNlbGwsICJyb290IEFGUyBjZWxsIG5hbWUgYW5kIFZMIHNlcnZlciBJUCBhZGRyIGxpc3QiKTsKIAogc3RydWN0IGFmc191dWlkIGFmc191dWlkOworc3RydWN0IHdvcmtxdWV1ZV9zdHJ1Y3QgKmFmc193cTsKIAogLyoKICAqIGdldCBhIGNsaWVudCBVVUlECkBAIC04NywxMCArODgsMTYgQEAKIAlpZiAocmV0IDwgMCkKIAkJcmV0dXJuIHJldDsKIAorCS8qIGNyZWF0ZSB3b3JrcXVldWUgKi8KKwlyZXQgPSAtRU5PTUVNOworCWFmc193cSA9IGFsbG9jX3dvcmtxdWV1ZSgiYWZzIiwgMCwgMCk7CisJaWYgKCFhZnNfd3EpCisJCXJldHVybiByZXQ7CisKIAkvKiByZWdpc3RlciB0aGUgL3Byb2Mgc3R1ZmYgKi8KIAlyZXQgPSBhZnNfcHJvY19pbml0KCk7CiAJaWYgKHJldCA8IDApCi0JCXJldHVybiByZXQ7CisJCWdvdG8gZXJyb3JfcHJvYzsKIAogI2lmZGVmIENPTkZJR19BRlNfRlNDQUNIRQogCS8qIHdlIHdhbnQgdG8gYmUgYWJsZSB0byBjYWNoZSAqLwpAQCAtMTQwLDYgKzE0Nyw4IEBACiBlcnJvcl9jYWNoZToKICNlbmRpZgogCWFmc19wcm9jX2NsZWFudXAoKTsKK2Vycm9yX3Byb2M6CisJZGVzdHJveV93b3JrcXVldWUoYWZzX3dxKTsKIAlyY3VfYmFycmllcigpOwogCXByaW50ayhLRVJOX0VSUiAia0FGUzogZmFpbGVkIHRvIHJlZ2lzdGVyOiAlZFxuIiwgcmV0KTsKIAlyZXR1cm4gcmV0OwpAQCAtMTYzLDcgKzE3Miw3IEBACiAJYWZzX3B1cmdlX3NlcnZlcnMoKTsKIAlhZnNfY2FsbGJhY2tfdXBkYXRlX2tpbGwoKTsKIAlhZnNfdmxvY2F0aW9uX3B1cmdlKCk7Ci0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKKwlkZXN0cm95X3dvcmtxdWV1ZShhZnNfd3EpOwogCWFmc19jZWxsX3B1cmdlKCk7CiAjaWZkZWYgQ09ORklHX0FGU19GU0NBQ0hFCiAJZnNjYWNoZV91bnJlZ2lzdGVyX25ldGZzKCZhZnNfY2FjaGVfbmV0ZnMpOwpkaWZmIC0tZ2l0IGEvZnMvYWZzL21udHB0LmMgYi9mcy9hZnMvbW50cHQuYwppbmRleCA2MTUzNDE3Li5hYTU5MTg0IDEwMDY0NAotLS0gYS9mcy9hZnMvbW50cHQuYworKysgYi9mcy9hZnMvbW50cHQuYwpAQCAtMjQsNyArMjQsNiBAQAogCQkJCSAgICAgICBzdHJ1Y3QgZGVudHJ5ICpkZW50cnksCiAJCQkJICAgICAgIHN0cnVjdCBuYW1laWRhdGEgKm5kKTsKIHN0YXRpYyBpbnQgYWZzX21udHB0X29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpOwotc3RhdGljIHZvaWQgKmFmc19tbnRwdF9mb2xsb3dfbGluayhzdHJ1Y3QgZGVudHJ5ICpkZW50cnksIHN0cnVjdCBuYW1laWRhdGEgKm5kKTsKIHN0YXRpYyB2b2lkIGFmc19tbnRwdF9leHBpcnlfdGltZWRfb3V0KHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yayk7CiAKIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgYWZzX21udHB0X2ZpbGVfb3BlcmF0aW9ucyA9IHsKQEAgLTM0LDEzICszMywxMSBAQAogCiBjb25zdCBzdHJ1Y3QgaW5vZGVfb3BlcmF0aW9ucyBhZnNfbW50cHRfaW5vZGVfb3BlcmF0aW9ucyA9IHsKIAkubG9va3VwCQk9IGFmc19tbnRwdF9sb29rdXAsCi0JLmZvbGxvd19saW5rCT0gYWZzX21udHB0X2ZvbGxvd19saW5rLAogCS5yZWFkbGluawk9IHBhZ2VfcmVhZGxpbmssCiAJLmdldGF0dHIJPSBhZnNfZ2V0YXR0ciwKIH07CiAKIGNvbnN0IHN0cnVjdCBpbm9kZV9vcGVyYXRpb25zIGFmc19hdXRvY2VsbF9pbm9kZV9vcGVyYXRpb25zID0gewotCS5mb2xsb3dfbGluawk9IGFmc19tbnRwdF9mb2xsb3dfbGluaywKIAkuZ2V0YXR0cgk9IGFmc19nZXRhdHRyLAogfTsKIApAQCAtODgsNiArODUsNyBAQAogCQlfZGVidWcoInN5bWxpbmsgaXMgYSBtb3VudHBvaW50Iik7CiAJCXNwaW5fbG9jaygmdm5vZGUtPmxvY2spOwogCQlzZXRfYml0KEFGU19WTk9ERV9NT1VOVFBPSU5ULCAmdm5vZGUtPmZsYWdzKTsKKwkJdm5vZGUtPnZmc19pbm9kZS5pX2ZsYWdzIHw9IFNfQVVUT01PVU5UOwogCQlzcGluX3VubG9jaygmdm5vZGUtPmxvY2spOwogCX0KIApAQCAtMjM4LDUyICsyMzYsMjQgQEAKIH0KIAogLyoKLSAqIGZvbGxvdyBhIGxpbmsgZnJvbSBhIG1vdW50cG9pbnQgZGlyZWN0b3J5LCB0aHVzIGNhdXNpbmcgaXQgdG8gYmUgbW91bnRlZAorICogaGFuZGxlIGFuIGF1dG9tb3VudCBwb2ludAogICovCi1zdGF0aWMgdm9pZCAqYWZzX21udHB0X2ZvbGxvd19saW5rKHN0cnVjdCBkZW50cnkgKmRlbnRyeSwgc3RydWN0IG5hbWVpZGF0YSAqbmQpCitzdHJ1Y3QgdmZzbW91bnQgKmFmc19kX2F1dG9tb3VudChzdHJ1Y3QgcGF0aCAqcGF0aCkKIHsKIAlzdHJ1Y3QgdmZzbW91bnQgKm5ld21udDsKLQlpbnQgZXJyOwogCi0JX2VudGVyKCIlcHslc30seyVzOiVweyVzfSx9IiwKLQkgICAgICAgZGVudHJ5LAotCSAgICAgICBkZW50cnktPmRfbmFtZS5uYW1lLAotCSAgICAgICBuZC0+cGF0aC5tbnQtPm1udF9kZXZuYW1lLAotCSAgICAgICBkZW50cnksCi0JICAgICAgIG5kLT5wYXRoLmRlbnRyeS0+ZF9uYW1lLm5hbWUpOworCV9lbnRlcigieyVzLCVzfSIsIHBhdGgtPm1udC0+bW50X2Rldm5hbWUsIHBhdGgtPmRlbnRyeS0+ZF9uYW1lLm5hbWUpOwogCi0JZHB1dChuZC0+cGF0aC5kZW50cnkpOwotCW5kLT5wYXRoLmRlbnRyeSA9IGRnZXQoZGVudHJ5KTsKKwluZXdtbnQgPSBhZnNfbW50cHRfZG9fYXV0b21vdW50KHBhdGgtPmRlbnRyeSk7CisJaWYgKElTX0VSUihuZXdtbnQpKQorCQlyZXR1cm4gbmV3bW50OwogCi0JbmV3bW50ID0gYWZzX21udHB0X2RvX2F1dG9tb3VudChuZC0+cGF0aC5kZW50cnkpOwotCWlmIChJU19FUlIobmV3bW50KSkgewotCQlwYXRoX3B1dCgmbmQtPnBhdGgpOwotCQlyZXR1cm4gKHZvaWQgKiluZXdtbnQ7Ci0JfQotCi0JbW50Z2V0KG5ld21udCk7Ci0JZXJyID0gZG9fYWRkX21vdW50KG5ld21udCwgJm5kLT5wYXRoLCBNTlRfU0hSSU5LQUJMRSwgJmFmc192ZnNtb3VudHMpOwotCXN3aXRjaCAoZXJyKSB7Ci0JY2FzZSAwOgotCQlwYXRoX3B1dCgmbmQtPnBhdGgpOwotCQluZC0+cGF0aC5tbnQgPSBuZXdtbnQ7Ci0JCW5kLT5wYXRoLmRlbnRyeSA9IGRnZXQobmV3bW50LT5tbnRfcm9vdCk7Ci0JCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmYWZzX21udHB0X2V4cGlyeV90aW1lciwKLQkJCQkgICAgICBhZnNfbW50cHRfZXhwaXJ5X3RpbWVvdXQgKiBIWik7Ci0JCWJyZWFrOwotCWNhc2UgLUVCVVNZOgotCQkvKiBzb21lb25lIGVsc2UgbWFkZSBhIG1vdW50IGhlcmUgd2hpbHN0IHdlIHdlcmUgYnVzeSAqLwotCQl3aGlsZSAoZF9tb3VudHBvaW50KG5kLT5wYXRoLmRlbnRyeSkgJiYKLQkJICAgICAgIGZvbGxvd19kb3duKCZuZC0+cGF0aCkpCi0JCQk7Ci0JCWVyciA9IDA7Ci0JZGVmYXVsdDoKLQkJbW50cHV0KG5ld21udCk7Ci0JCWJyZWFrOwotCX0KLQotCV9sZWF2ZSgiID0gJWQiLCBlcnIpOwotCXJldHVybiBFUlJfUFRSKGVycik7CisJbW50Z2V0KG5ld21udCk7IC8qIHByZXZlbnQgaW1tZWRpYXRlIGV4cGlyYXRpb24gKi8KKwltbnRfc2V0X2V4cGlyeShuZXdtbnQsICZhZnNfdmZzbW91bnRzKTsKKwlxdWV1ZV9kZWxheWVkX3dvcmsoYWZzX3dxLCAmYWZzX21udHB0X2V4cGlyeV90aW1lciwKKwkJCSAgIGFmc19tbnRwdF9leHBpcnlfdGltZW91dCAqIEhaKTsKKwlfbGVhdmUoIiA9ICVwIHslc30iLCBuZXdtbnQsIG5ld21udC0+bW50X2Rldm5hbWUpOworCXJldHVybiBuZXdtbnQ7CiB9CiAKIC8qCkBAIC0yOTUsOCArMjY1LDggQEAKIAogCWlmICghbGlzdF9lbXB0eSgmYWZzX3Zmc21vdW50cykpIHsKIAkJbWFya19tb3VudHNfZm9yX2V4cGlyeSgmYWZzX3Zmc21vdW50cyk7Ci0JCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmYWZzX21udHB0X2V4cGlyeV90aW1lciwKLQkJCQkgICAgICBhZnNfbW50cHRfZXhwaXJ5X3RpbWVvdXQgKiBIWik7CisJCXF1ZXVlX2RlbGF5ZWRfd29yayhhZnNfd3EsICZhZnNfbW50cHRfZXhwaXJ5X3RpbWVyLAorCQkJCSAgIGFmc19tbnRwdF9leHBpcnlfdGltZW91dCAqIEhaKTsKIAl9CiAKIAlfbGVhdmUoIiIpOwpAQCAtMzEwLDYgKzI4MCw1IEBACiAJX2VudGVyKCIiKTsKIAogCUFTU0VSVChsaXN0X2VtcHR5KCZhZnNfdmZzbW91bnRzKSk7Ci0JY2FuY2VsX2RlbGF5ZWRfd29yaygmYWZzX21udHB0X2V4cGlyeV90aW1lcik7Ci0JZmx1c2hfc2NoZWR1bGVkX3dvcmsoKTsKKwljYW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJmFmc19tbnRwdF9leHBpcnlfdGltZXIpOwogfQpkaWZmIC0tZ2l0IGEvZnMvYWZzL3J4cnBjLmMgYi9mcy9hZnMvcnhycGMuYwppbmRleCA2NTRkOGZkLi5lNDVhMzIzIDEwMDY0NAotLS0gYS9mcy9hZnMvcnhycGMuYworKysgYi9mcy9hZnMvcnhycGMuYwpAQCAtNDEwLDcgKzQxMCw3IEBACiAJaWYgKCFjYWxsKSB7CiAJCS8qIGl0cyBhbiBpbmNvbWluZyBjYWxsIGZvciBvdXIgY2FsbGJhY2sgc2VydmljZSAqLwogCQlza2JfcXVldWVfdGFpbCgmYWZzX2luY29taW5nX2NhbGxzLCBza2IpOwotCQlzY2hlZHVsZV93b3JrKCZhZnNfY29sbGVjdF9pbmNvbWluZ19jYWxsX3dvcmspOworCQlxdWV1ZV93b3JrKGFmc193cSwgJmFmc19jb2xsZWN0X2luY29taW5nX2NhbGxfd29yayk7CiAJfSBlbHNlIHsKIAkJLyogcm91dGUgdGhlIG1lc3NhZ2VzIGRpcmVjdGx5IHRvIHRoZSBhcHByb3ByaWF0ZSBjYWxsICovCiAJCXNrYl9xdWV1ZV90YWlsKCZjYWxsLT5yeF9xdWV1ZSwgc2tiKTsKZGlmZiAtLWdpdCBhL2ZzL2Fmcy9zZXJ2ZXIuYyBiL2ZzL2Fmcy9zZXJ2ZXIuYwppbmRleCA5ZmRjN2ZlLi5kNTliNzUxIDEwMDY0NAotLS0gYS9mcy9hZnMvc2VydmVyLmMKKysrIGIvZnMvYWZzL3NlcnZlci5jCkBAIC0yMzgsOCArMjM4LDggQEAKIAlpZiAoYXRvbWljX3JlYWQoJnNlcnZlci0+dXNhZ2UpID09IDApIHsKIAkJbGlzdF9tb3ZlX3RhaWwoJnNlcnZlci0+Z3JhdmUsICZhZnNfc2VydmVyX2dyYXZleWFyZCk7CiAJCXNlcnZlci0+dGltZV9vZl9kZWF0aCA9IGdldF9zZWNvbmRzKCk7Ci0JCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmYWZzX3NlcnZlcl9yZWFwZXIsCi0JCQkJICAgICAgYWZzX3NlcnZlcl90aW1lb3V0ICogSFopOworCQlxdWV1ZV9kZWxheWVkX3dvcmsoYWZzX3dxLCAmYWZzX3NlcnZlcl9yZWFwZXIsCisJCQkJICAgYWZzX3NlcnZlcl90aW1lb3V0ICogSFopOwogCX0KIAlzcGluX3VubG9jaygmYWZzX3NlcnZlcl9ncmF2ZXlhcmRfbG9jayk7CiAJX2xlYXZlKCIgW2RlYWRdIik7CkBAIC0yODUsMTAgKzI4NSwxMSBAQAogCQlleHBpcnkgPSBzZXJ2ZXItPnRpbWVfb2ZfZGVhdGggKyBhZnNfc2VydmVyX3RpbWVvdXQ7CiAJCWlmIChleHBpcnkgPiBub3cpIHsKIAkJCWRlbGF5ID0gKGV4cGlyeSAtIG5vdykgKiBIWjsKLQkJCWlmICghc2NoZWR1bGVfZGVsYXllZF93b3JrKCZhZnNfc2VydmVyX3JlYXBlciwgZGVsYXkpKSB7CisJCQlpZiAoIXF1ZXVlX2RlbGF5ZWRfd29yayhhZnNfd3EsICZhZnNfc2VydmVyX3JlYXBlciwKKwkJCQkJCWRlbGF5KSkgewogCQkJCWNhbmNlbF9kZWxheWVkX3dvcmsoJmFmc19zZXJ2ZXJfcmVhcGVyKTsKLQkJCQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJmFmc19zZXJ2ZXJfcmVhcGVyLAotCQkJCQkJICAgICAgZGVsYXkpOworCQkJCXF1ZXVlX2RlbGF5ZWRfd29yayhhZnNfd3EsICZhZnNfc2VydmVyX3JlYXBlciwKKwkJCQkJCSAgIGRlbGF5KTsKIAkJCX0KIAkJCWJyZWFrOwogCQl9CkBAIC0zMjMsNSArMzI0LDUgQEAKIHsKIAlhZnNfc2VydmVyX3RpbWVvdXQgPSAwOwogCWNhbmNlbF9kZWxheWVkX3dvcmsoJmFmc19zZXJ2ZXJfcmVhcGVyKTsKLQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJmFmc19zZXJ2ZXJfcmVhcGVyLCAwKTsKKwlxdWV1ZV9kZWxheWVkX3dvcmsoYWZzX3dxLCAmYWZzX3NlcnZlcl9yZWFwZXIsIDApOwogfQpkaWZmIC0tZ2l0IGEvZnMvYWZzL3Zsb2NhdGlvbi5jIGIvZnMvYWZzL3Zsb2NhdGlvbi5jCmluZGV4IDlhYzI2MGQuLjQzMTk4NGQgMTAwNjQ0Ci0tLSBhL2ZzL2Fmcy92bG9jYXRpb24uYworKysgYi9mcy9hZnMvdmxvY2F0aW9uLmMKQEAgLTUwNyw4ICs1MDcsOCBAQAogCQlfZGVidWcoImJ1cmllZCIpOwogCQlsaXN0X21vdmVfdGFpbCgmdmwtPmdyYXZlLCAmYWZzX3Zsb2NhdGlvbl9ncmF2ZXlhcmQpOwogCQl2bC0+dGltZV9vZl9kZWF0aCA9IGdldF9zZWNvbmRzKCk7Ci0JCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmYWZzX3Zsb2NhdGlvbl9yZWFwLAotCQkJCSAgICAgIGFmc192bG9jYXRpb25fdGltZW91dCAqIEhaKTsKKwkJcXVldWVfZGVsYXllZF93b3JrKGFmc193cSwgJmFmc192bG9jYXRpb25fcmVhcCwKKwkJCQkgICBhZnNfdmxvY2F0aW9uX3RpbWVvdXQgKiBIWik7CiAKIAkJLyogc3VzcGVuZCB1cGRhdGVzIG9uIHRoaXMgcmVjb3JkICovCiAJCWlmICghbGlzdF9lbXB0eSgmdmwtPnVwZGF0ZSkpIHsKQEAgLTU2MSwxMSArNTYxLDExIEBACiAJCWlmIChleHBpcnkgPiBub3cpIHsKIAkJCWRlbGF5ID0gKGV4cGlyeSAtIG5vdykgKiBIWjsKIAkJCV9kZWJ1ZygiZGVsYXkgJWx1IiwgZGVsYXkpOwotCQkJaWYgKCFzY2hlZHVsZV9kZWxheWVkX3dvcmsoJmFmc192bG9jYXRpb25fcmVhcCwKLQkJCQkJCSAgIGRlbGF5KSkgeworCQkJaWYgKCFxdWV1ZV9kZWxheWVkX3dvcmsoYWZzX3dxLCAmYWZzX3Zsb2NhdGlvbl9yZWFwLAorCQkJCQkJZGVsYXkpKSB7CiAJCQkJY2FuY2VsX2RlbGF5ZWRfd29yaygmYWZzX3Zsb2NhdGlvbl9yZWFwKTsKLQkJCQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJmFmc192bG9jYXRpb25fcmVhcCwKLQkJCQkJCSAgICAgIGRlbGF5KTsKKwkJCQlxdWV1ZV9kZWxheWVkX3dvcmsoYWZzX3dxLCAmYWZzX3Zsb2NhdGlvbl9yZWFwLAorCQkJCQkJICAgZGVsYXkpOwogCQkJfQogCQkJYnJlYWs7CiAJCX0KQEAgLTYyMCw3ICs2MjAsNyBAQAogCWRlc3Ryb3lfd29ya3F1ZXVlKGFmc192bG9jYXRpb25fdXBkYXRlX3dvcmtlcik7CiAKIAljYW5jZWxfZGVsYXllZF93b3JrKCZhZnNfdmxvY2F0aW9uX3JlYXApOwotCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmYWZzX3Zsb2NhdGlvbl9yZWFwLCAwKTsKKwlxdWV1ZV9kZWxheWVkX3dvcmsoYWZzX3dxLCAmYWZzX3Zsb2NhdGlvbl9yZWFwLCAwKTsKIH0KIAogLyoKZGlmZiAtLWdpdCBhL2ZzL2Fpby5jIGIvZnMvYWlvLmMKaW5kZXggNWUwMGYxNS4uZmM1NTdhMyAxMDA2NDQKLS0tIGEvZnMvYWlvLmMKKysrIGIvZnMvYWlvLmMKQEAgLTg3LDcgKzg3LDcgQEAKIAogCWFpb193cSA9IGNyZWF0ZV93b3JrcXVldWUoImFpbyIpOwogCWFiZV9wb29sID0gbWVtcG9vbF9jcmVhdGVfa21hbGxvY19wb29sKDEsIHNpemVvZihzdHJ1Y3QgYWlvX2JhdGNoX2VudHJ5KSk7Ci0JQlVHX09OKCFhYmVfcG9vbCk7CisJQlVHX09OKCFhaW9fd3EgfHwgIWFiZV9wb29sKTsKIAogCXByX2RlYnVnKCJhaW9fc2V0dXA6IHNpemVvZihzdHJ1Y3QgcGFnZSkgPSAlZFxuIiwgKGludClzaXplb2Yoc3RydWN0IHBhZ2UpKTsKIApkaWZmIC0tZ2l0IGEvZnMvYW5vbl9pbm9kZXMuYyBiL2ZzL2Fub25faW5vZGVzLmMKaW5kZXggY2JlNTdmMy4uYzU1NjdjYiAxMDA2NDQKLS0tIGEvZnMvYW5vbl9pbm9kZXMuYworKysgYi9mcy9hbm9uX2lub2Rlcy5jCkBAIC0yMzMsNyArMjMzLDcgQEAKIAlyZXR1cm4gMDsKIAogZXJyX21udHB1dDoKLQltbnRwdXRfbG9uZyhhbm9uX2lub2RlX21udCk7CisJbW50cHV0KGFub25faW5vZGVfbW50KTsKIGVycl91bnJlZ2lzdGVyX2ZpbGVzeXN0ZW06CiAJdW5yZWdpc3Rlcl9maWxlc3lzdGVtKCZhbm9uX2lub2RlX2ZzX3R5cGUpOwogZXJyX2V4aXQ6CmRpZmYgLS1naXQgYS9mcy9hdXRvZnM0L2F1dG9mc19pLmggYi9mcy9hdXRvZnM0L2F1dG9mc19pLmgKaW5kZXggMGZmZmUxYy4uNTRmOTIzNyAxMDA2NDQKLS0tIGEvZnMvYXV0b2ZzNC9hdXRvZnNfaS5oCisrKyBiL2ZzL2F1dG9mczQvYXV0b2ZzX2kuaApAQCAtODgsMTggKzg4LDkgQEAKIAogCXVpZF90IHVpZDsKIAlnaWRfdCBnaWQ7Ci0KLQltb2RlX3QJbW9kZTsKLQlzaXplX3QJc2l6ZTsKLQotCXZvaWQgKCpmcmVlKShzdHJ1Y3QgYXV0b2ZzX2luZm8gKik7Ci0JdW5pb24gewotCQljb25zdCBjaGFyICpzeW1saW5rOwotCX0gdTsKIH07CiAKICNkZWZpbmUgQVVUT0ZTX0lORl9FWFBJUklORwkoMTw8MCkgLyogZGVudHJ5IGlzIGluIHRoZSBwcm9jZXNzIG9mIGV4cGlyaW5nICovCi0jZGVmaW5lIEFVVE9GU19JTkZfTU9VTlRQT0lOVAkoMTw8MSkgLyogbW91bnRwb2ludCBzdGF0dXMgZm9yIGRpcmVjdCBleHBpcmUgKi8KICNkZWZpbmUgQVVUT0ZTX0lORl9QRU5ESU5HCSgxPDwyKSAvKiBkZW50cnkgcGVuZGluZyBtb3VudCAqLwogCiBzdHJ1Y3QgYXV0b2ZzX3dhaXRfcXVldWUgewpAQCAtMTc2LDE0ICsxNjcsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW5saW5lIHZvaWQgYXV0b2ZzNF9jb3B5X2F0aW1lKHN0cnVjdCBmaWxlICpzcmMsIHN0cnVjdCBmaWxlICpkc3QpCi17Ci0JZHN0LT5mX3BhdGguZGVudHJ5LT5kX2lub2RlLT5pX2F0aW1lID0KLQkJc3JjLT5mX3BhdGguZGVudHJ5LT5kX2lub2RlLT5pX2F0aW1lOwotCXJldHVybjsKLX0KLQotc3RydWN0IGlub2RlICphdXRvZnM0X2dldF9pbm9kZShzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiwgc3RydWN0IGF1dG9mc19pbmZvICopOworc3RydWN0IGlub2RlICphdXRvZnM0X2dldF9pbm9kZShzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiwgbW9kZV90KTsKIHZvaWQgYXV0b2ZzNF9mcmVlX2lubyhzdHJ1Y3QgYXV0b2ZzX2luZm8gKik7CiAKIC8qIEV4cGlyYXRpb24gKi8KQEAgLTIxMiwxNiArMTk2LDg5IEBACiAKIGV4dGVybiBjb25zdCBzdHJ1Y3QgaW5vZGVfb3BlcmF0aW9ucyBhdXRvZnM0X3N5bWxpbmtfaW5vZGVfb3BlcmF0aW9uczsKIGV4dGVybiBjb25zdCBzdHJ1Y3QgaW5vZGVfb3BlcmF0aW9ucyBhdXRvZnM0X2Rpcl9pbm9kZV9vcGVyYXRpb25zOwotZXh0ZXJuIGNvbnN0IHN0cnVjdCBpbm9kZV9vcGVyYXRpb25zIGF1dG9mczRfcm9vdF9pbm9kZV9vcGVyYXRpb25zOwotZXh0ZXJuIGNvbnN0IHN0cnVjdCBpbm9kZV9vcGVyYXRpb25zIGF1dG9mczRfaW5kaXJlY3Rfcm9vdF9pbm9kZV9vcGVyYXRpb25zOwotZXh0ZXJuIGNvbnN0IHN0cnVjdCBpbm9kZV9vcGVyYXRpb25zIGF1dG9mczRfZGlyZWN0X3Jvb3RfaW5vZGVfb3BlcmF0aW9uczsKIGV4dGVybiBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGF1dG9mczRfZGlyX29wZXJhdGlvbnM7CiBleHRlcm4gY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBhdXRvZnM0X3Jvb3Rfb3BlcmF0aW9uczsKK2V4dGVybiBjb25zdCBzdHJ1Y3QgZGVudHJ5X29wZXJhdGlvbnMgYXV0b2ZzNF9kZW50cnlfb3BlcmF0aW9uczsKKworLyogVkZTIGF1dG9tb3VudCBmbGFncyBtYW5hZ2VtZW50IGZ1bmN0aW9ucyAqLworCitzdGF0aWMgaW5saW5lIHZvaWQgX19tYW5hZ2VkX2RlbnRyeV9zZXRfYXV0b21vdW50KHN0cnVjdCBkZW50cnkgKmRlbnRyeSkKK3sKKwlkZW50cnktPmRfZmxhZ3MgfD0gRENBQ0hFX05FRURfQVVUT01PVU5UOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgbWFuYWdlZF9kZW50cnlfc2V0X2F1dG9tb3VudChzdHJ1Y3QgZGVudHJ5ICpkZW50cnkpCit7CisJc3Bpbl9sb2NrKCZkZW50cnktPmRfbG9jayk7CisJX19tYW5hZ2VkX2RlbnRyeV9zZXRfYXV0b21vdW50KGRlbnRyeSk7CisJc3Bpbl91bmxvY2soJmRlbnRyeS0+ZF9sb2NrKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIF9fbWFuYWdlZF9kZW50cnlfY2xlYXJfYXV0b21vdW50KHN0cnVjdCBkZW50cnkgKmRlbnRyeSkKK3sKKwlkZW50cnktPmRfZmxhZ3MgJj0gfkRDQUNIRV9ORUVEX0FVVE9NT1VOVDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIG1hbmFnZWRfZGVudHJ5X2NsZWFyX2F1dG9tb3VudChzdHJ1Y3QgZGVudHJ5ICpkZW50cnkpCit7CisJc3Bpbl9sb2NrKCZkZW50cnktPmRfbG9jayk7CisJX19tYW5hZ2VkX2RlbnRyeV9jbGVhcl9hdXRvbW91bnQoZGVudHJ5KTsKKwlzcGluX3VubG9jaygmZGVudHJ5LT5kX2xvY2spOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgX19tYW5hZ2VkX2RlbnRyeV9zZXRfdHJhbnNpdChzdHJ1Y3QgZGVudHJ5ICpkZW50cnkpCit7CisJZGVudHJ5LT5kX2ZsYWdzIHw9IERDQUNIRV9NQU5BR0VfVFJBTlNJVDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIG1hbmFnZWRfZGVudHJ5X3NldF90cmFuc2l0KHN0cnVjdCBkZW50cnkgKmRlbnRyeSkKK3sKKwlzcGluX2xvY2soJmRlbnRyeS0+ZF9sb2NrKTsKKwlfX21hbmFnZWRfZGVudHJ5X3NldF90cmFuc2l0KGRlbnRyeSk7CisJc3Bpbl91bmxvY2soJmRlbnRyeS0+ZF9sb2NrKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIF9fbWFuYWdlZF9kZW50cnlfY2xlYXJfdHJhbnNpdChzdHJ1Y3QgZGVudHJ5ICpkZW50cnkpCit7CisJZGVudHJ5LT5kX2ZsYWdzICY9IH5EQ0FDSEVfTUFOQUdFX1RSQU5TSVQ7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBtYW5hZ2VkX2RlbnRyeV9jbGVhcl90cmFuc2l0KHN0cnVjdCBkZW50cnkgKmRlbnRyeSkKK3sKKwlzcGluX2xvY2soJmRlbnRyeS0+ZF9sb2NrKTsKKwlfX21hbmFnZWRfZGVudHJ5X2NsZWFyX3RyYW5zaXQoZGVudHJ5KTsKKwlzcGluX3VubG9jaygmZGVudHJ5LT5kX2xvY2spOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgX19tYW5hZ2VkX2RlbnRyeV9zZXRfbWFuYWdlZChzdHJ1Y3QgZGVudHJ5ICpkZW50cnkpCit7CisJZGVudHJ5LT5kX2ZsYWdzIHw9IChEQ0FDSEVfTkVFRF9BVVRPTU9VTlR8RENBQ0hFX01BTkFHRV9UUkFOU0lUKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIG1hbmFnZWRfZGVudHJ5X3NldF9tYW5hZ2VkKHN0cnVjdCBkZW50cnkgKmRlbnRyeSkKK3sKKwlzcGluX2xvY2soJmRlbnRyeS0+ZF9sb2NrKTsKKwlfX21hbmFnZWRfZGVudHJ5X3NldF9tYW5hZ2VkKGRlbnRyeSk7CisJc3Bpbl91bmxvY2soJmRlbnRyeS0+ZF9sb2NrKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIF9fbWFuYWdlZF9kZW50cnlfY2xlYXJfbWFuYWdlZChzdHJ1Y3QgZGVudHJ5ICpkZW50cnkpCit7CisJZGVudHJ5LT5kX2ZsYWdzICY9IH4oRENBQ0hFX05FRURfQVVUT01PVU5UfERDQUNIRV9NQU5BR0VfVFJBTlNJVCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBtYW5hZ2VkX2RlbnRyeV9jbGVhcl9tYW5hZ2VkKHN0cnVjdCBkZW50cnkgKmRlbnRyeSkKK3sKKwlzcGluX2xvY2soJmRlbnRyeS0+ZF9sb2NrKTsKKwlfX21hbmFnZWRfZGVudHJ5X2NsZWFyX21hbmFnZWQoZGVudHJ5KTsKKwlzcGluX3VubG9jaygmZGVudHJ5LT5kX2xvY2spOworfQogCiAvKiBJbml0aWFsaXppbmcgZnVuY3Rpb24gKi8KIAogaW50IGF1dG9mczRfZmlsbF9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiwgdm9pZCAqLCBpbnQpOwotc3RydWN0IGF1dG9mc19pbmZvICphdXRvZnM0X2luaXRfaW5vKHN0cnVjdCBhdXRvZnNfaW5mbyAqLCBzdHJ1Y3QgYXV0b2ZzX3NiX2luZm8gKnNiaSwgbW9kZV90IG1vZGUpOworc3RydWN0IGF1dG9mc19pbmZvICphdXRvZnM0X25ld19pbm8oc3RydWN0IGF1dG9mc19zYl9pbmZvICopOwordm9pZCBhdXRvZnM0X2NsZWFuX2lubyhzdHJ1Y3QgYXV0b2ZzX2luZm8gKik7CiAKIC8qIFF1ZXVlIG1hbmFnZW1lbnQgZnVuY3Rpb25zICovCiAKQEAgLTIyOSwxOSArMjg2LDYgQEAKIGludCBhdXRvZnM0X3dhaXRfcmVsZWFzZShzdHJ1Y3QgYXV0b2ZzX3NiX2luZm8gKixhdXRvZnNfd3F0X3QsaW50KTsKIHZvaWQgYXV0b2ZzNF9jYXRhdG9uaWNfbW9kZShzdHJ1Y3QgYXV0b2ZzX3NiX2luZm8gKik7CiAKLXN0YXRpYyBpbmxpbmUgaW50IGF1dG9mczRfZm9sbG93X21vdW50KHN0cnVjdCBwYXRoICpwYXRoKQotewotCWludCByZXMgPSAwOwotCi0Jd2hpbGUgKGRfbW91bnRwb2ludChwYXRoLT5kZW50cnkpKSB7Ci0JCWludCBmb2xsb3dlZCA9IGZvbGxvd19kb3duKHBhdGgpOwotCQlpZiAoIWZvbGxvd2VkKQotCQkJYnJlYWs7Ci0JCXJlcyA9IDE7Ci0JfQotCXJldHVybiByZXM7Ci19Ci0KIHN0YXRpYyBpbmxpbmUgdTMyIGF1dG9mczRfZ2V0X2RldihzdHJ1Y3QgYXV0b2ZzX3NiX2luZm8gKnNiaSkKIHsKIAlyZXR1cm4gbmV3X2VuY29kZV9kZXYoc2JpLT5zYi0+c19kZXYpOwpAQCAtMjk0LDUgKzMzOCw0IEBACiAJcmV0dXJuOwogfQogCi12b2lkIGF1dG9mczRfZGVudHJ5X3JlbGVhc2Uoc3RydWN0IGRlbnRyeSAqKTsKIGV4dGVybiB2b2lkIGF1dG9mczRfa2lsbF9zYihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKik7CmRpZmYgLS1naXQgYS9mcy9hdXRvZnM0L2Rldi1pb2N0bC5jIGIvZnMvYXV0b2ZzNC9kZXYtaW9jdGwuYwppbmRleCBlZmY5YTQxLi4xNDQyZGE0IDEwMDY0NAotLS0gYS9mcy9hdXRvZnM0L2Rldi1pb2N0bC5jCisrKyBiL2ZzL2F1dG9mczQvZGV2LWlvY3RsLmMKQEAgLTU1MSw3ICs1NTEsNyBAQAogCiAJCWVyciA9IGhhdmVfc3VibW91bnRzKHBhdGguZGVudHJ5KTsKIAotCQlpZiAoZm9sbG93X2Rvd24oJnBhdGgpKQorCQlpZiAoZm9sbG93X2Rvd25fb25lKCZwYXRoKSkKIAkJCW1hZ2ljID0gcGF0aC5tbnQtPm1udF9zYi0+c19tYWdpYzsKIAl9CiAKZGlmZiAtLWdpdCBhL2ZzL2F1dG9mczQvZXhwaXJlLmMgYi9mcy9hdXRvZnM0L2V4cGlyZS5jCmluZGV4IGNjMWQwMTMuLmY0MzEwMGIgMTAwNjQ0Ci0tLSBhL2ZzL2F1dG9mczQvZXhwaXJlLmMKKysrIGIvZnMvYXV0b2ZzNC9leHBpcmUuYwpAQCAtMjYsMTAgKzI2LDYgQEAKIAlpZiAoaW5vID09IE5VTEwpCiAJCXJldHVybiAwOwogCi0JLyogTm8gcG9pbnQgZXhwaXJpbmcgYSBwZW5kaW5nIG1vdW50ICovCi0JaWYgKGluby0+ZmxhZ3MgJiBBVVRPRlNfSU5GX1BFTkRJTkcpCi0JCXJldHVybiAwOwotCiAJaWYgKCFkb19ub3cpIHsKIAkJLyogVG9vIHlvdW5nIHRvIGRpZSAqLwogCQlpZiAoIXRpbWVvdXQgfHwgdGltZV9hZnRlcihpbm8tPmxhc3RfdXNlZCArIHRpbWVvdXQsIG5vdykpCkBAIC01Niw3ICs1Miw3IEBACiAKIAlwYXRoX2dldCgmcGF0aCk7CiAKLQlpZiAoIWZvbGxvd19kb3duKCZwYXRoKSkKKwlpZiAoIWZvbGxvd19kb3duX29uZSgmcGF0aCkpCiAJCWdvdG8gZG9uZTsKIAogCWlmIChpc19hdXRvZnM0X2RlbnRyeShwYXRoLmRlbnRyeSkpIHsKQEAgLTEwMCw3ICs5Niw3IEBACiAJc3RydWN0IGRlbnRyeSAqcCwgKnJldDsKIAogCWlmIChwcmV2ID09IE5VTEwpCi0JCXJldHVybiBkZ2V0KHByZXYpOworCQlyZXR1cm4gZGdldChyb290KTsKIAogCXNwaW5fbG9jaygmYXV0b2ZzNF9sb2NrKTsKIHJlbG9jazoKQEAgLTEzNyw3ICsxMzMsNyBAQAogCXNwaW5fbG9ja19uZXN0ZWQoJnJldC0+ZF9sb2NrLCBERU5UUllfRF9MT0NLX05FU1RFRCk7CiAJLyogTmVnYXRpdmUgZGVudHJ5IC0gdHJ5IG5leHQgKi8KIAlpZiAoIXNpbXBsZV9wb3NpdGl2ZShyZXQpKSB7Ci0JCXNwaW5fdW5sb2NrKCZyZXQtPmRfbG9jayk7CisJCXNwaW5fdW5sb2NrKCZwLT5kX2xvY2spOwogCQlwID0gcmV0OwogCQlnb3RvIGFnYWluOwogCX0KQEAgLTI4Myw2ICsyNzksNyBAQAogCXVuc2lnbmVkIGxvbmcgdGltZW91dDsKIAlzdHJ1Y3QgZGVudHJ5ICpyb290ID0gZGdldChzYi0+c19yb290KTsKIAlpbnQgZG9fbm93ID0gaG93ICYgQVVUT0ZTX0VYUF9JTU1FRElBVEU7CisJc3RydWN0IGF1dG9mc19pbmZvICppbm87CiAKIAlpZiAoIXJvb3QpCiAJCXJldHVybiBOVUxMOwpAQCAtMjkxLDE5ICsyODgsMjEgQEAKIAl0aW1lb3V0ID0gc2JpLT5leHBfdGltZW91dDsKIAogCXNwaW5fbG9jaygmc2JpLT5mc19sb2NrKTsKKwlpbm8gPSBhdXRvZnM0X2RlbnRyeV9pbm8ocm9vdCk7CisJLyogTm8gcG9pbnQgZXhwaXJpbmcgYSBwZW5kaW5nIG1vdW50ICovCisJaWYgKGluby0+ZmxhZ3MgJiBBVVRPRlNfSU5GX1BFTkRJTkcpIHsKKwkJc3Bpbl91bmxvY2soJnNiaS0+ZnNfbG9jayk7CisJCXJldHVybiBOVUxMOworCX0KKwltYW5hZ2VkX2RlbnRyeV9zZXRfdHJhbnNpdChyb290KTsKIAlpZiAoIWF1dG9mczRfZGlyZWN0X2J1c3kobW50LCByb290LCB0aW1lb3V0LCBkb19ub3cpKSB7CiAJCXN0cnVjdCBhdXRvZnNfaW5mbyAqaW5vID0gYXV0b2ZzNF9kZW50cnlfaW5vKHJvb3QpOwotCQlpZiAoZF9tb3VudHBvaW50KHJvb3QpKSB7Ci0JCQlpbm8tPmZsYWdzIHw9IEFVVE9GU19JTkZfTU9VTlRQT0lOVDsKLQkJCXNwaW5fbG9jaygmcm9vdC0+ZF9sb2NrKTsKLQkJCXJvb3QtPmRfZmxhZ3MgJj0gfkRDQUNIRV9NT1VOVEVEOwotCQkJc3Bpbl91bmxvY2soJnJvb3QtPmRfbG9jayk7Ci0JCX0KIAkJaW5vLT5mbGFncyB8PSBBVVRPRlNfSU5GX0VYUElSSU5HOwogCQlpbml0X2NvbXBsZXRpb24oJmluby0+ZXhwaXJlX2NvbXBsZXRlKTsKIAkJc3Bpbl91bmxvY2soJnNiaS0+ZnNfbG9jayk7CiAJCXJldHVybiByb290OwogCX0KKwltYW5hZ2VkX2RlbnRyeV9jbGVhcl90cmFuc2l0KHJvb3QpOwogCXNwaW5fdW5sb2NrKCZzYmktPmZzX2xvY2spOwogCWRwdXQocm9vdCk7CiAKQEAgLTM0MCw2ICszMzksMTAgQEAKIAl3aGlsZSAoKGRlbnRyeSA9IGdldF9uZXh0X3Bvc2l0aXZlX2RlbnRyeShkZW50cnksIHJvb3QpKSkgewogCQlzcGluX2xvY2soJnNiaS0+ZnNfbG9jayk7CiAJCWlubyA9IGF1dG9mczRfZGVudHJ5X2lubyhkZW50cnkpOworCQkvKiBObyBwb2ludCBleHBpcmluZyBhIHBlbmRpbmcgbW91bnQgKi8KKwkJaWYgKGluby0+ZmxhZ3MgJiBBVVRPRlNfSU5GX1BFTkRJTkcpCisJCQlnb3RvIGNvbnQ7CisJCW1hbmFnZWRfZGVudHJ5X3NldF90cmFuc2l0KGRlbnRyeSk7CiAKIAkJLyoKIAkJICogQ2FzZSAxOiAoaSkgaW5kaXJlY3QgbW91bnQgb3IgdG9wIGxldmVsIHBzZXVkbyBkaXJlY3QgbW91bnQKQEAgLTM5OSw2ICs0MDIsOCBAQAogCQkJfQogCQl9CiBuZXh0OgorCQltYW5hZ2VkX2RlbnRyeV9jbGVhcl90cmFuc2l0KGRlbnRyeSk7Citjb250OgogCQlzcGluX3VubG9jaygmc2JpLT5mc19sb2NrKTsKIAl9CiAJcmV0dXJuIE5VTEw7CkBAIC00NzksNiArNDg0LDggQEAKIAlzcGluX2xvY2soJnNiaS0+ZnNfbG9jayk7CiAJaW5vID0gYXV0b2ZzNF9kZW50cnlfaW5vKGRlbnRyeSk7CiAJaW5vLT5mbGFncyAmPSB+QVVUT0ZTX0lORl9FWFBJUklORzsKKwlpZiAoIWRfdW5oYXNoZWQoZGVudHJ5KSkKKwkJbWFuYWdlZF9kZW50cnlfY2xlYXJfdHJhbnNpdChkZW50cnkpOwogCWNvbXBsZXRlX2FsbCgmaW5vLT5leHBpcmVfY29tcGxldGUpOwogCXNwaW5fdW5sb2NrKCZzYmktPmZzX2xvY2spOwogCkBAIC01MDQsMTggKzUxMSwxOCBAQAogCQlyZXQgPSBhdXRvZnM0X3dhaXQoc2JpLCBkZW50cnksIE5GWV9FWFBJUkUpOwogCiAJCXNwaW5fbG9jaygmc2JpLT5mc19sb2NrKTsKLQkJaWYgKGluby0+ZmxhZ3MgJiBBVVRPRlNfSU5GX01PVU5UUE9JTlQpIHsKLQkJCXNwaW5fbG9jaygmc2ItPnNfcm9vdC0+ZF9sb2NrKTsKLQkJCS8qCi0JCQkgKiBJZiB3ZSBoYXZlbid0IGJlZW4gZXhwaXJlZCBhd2F5LCB0aGVuIHJlc2V0Ci0JCQkgKiBtb3VudGVkIHN0YXR1cy4KLQkJCSAqLwotCQkJaWYgKG1udC0+bW50X3BhcmVudCAhPSBtbnQpCi0JCQkJc2ItPnNfcm9vdC0+ZF9mbGFncyB8PSBEQ0FDSEVfTU9VTlRFRDsKLQkJCXNwaW5fdW5sb2NrKCZzYi0+c19yb290LT5kX2xvY2spOwotCQkJaW5vLT5mbGFncyAmPSB+QVVUT0ZTX0lORl9NT1VOVFBPSU5UOwotCQl9CiAJCWluby0+ZmxhZ3MgJj0gfkFVVE9GU19JTkZfRVhQSVJJTkc7CisJCXNwaW5fbG9jaygmZGVudHJ5LT5kX2xvY2spOworCQlpZiAocmV0KQorCQkJX19tYW5hZ2VkX2RlbnRyeV9jbGVhcl90cmFuc2l0KGRlbnRyeSk7CisJCWVsc2UgeworCQkJaWYgKChJU19ST09UKGRlbnRyeSkgfHwKKwkJCSAgICAoYXV0b2ZzX3R5cGVfaW5kaXJlY3Qoc2JpLT50eXBlKSAmJgorCQkJICAgICBJU19ST09UKGRlbnRyeS0+ZF9wYXJlbnQpKSkgJiYKKwkJCSAgICAhKGRlbnRyeS0+ZF9mbGFncyAmIERDQUNIRV9ORUVEX0FVVE9NT1VOVCkpCisJCQkJX19tYW5hZ2VkX2RlbnRyeV9zZXRfYXV0b21vdW50KGRlbnRyeSk7CisJCX0KKwkJc3Bpbl91bmxvY2soJmRlbnRyeS0+ZF9sb2NrKTsKIAkJY29tcGxldGVfYWxsKCZpbm8tPmV4cGlyZV9jb21wbGV0ZSk7CiAJCXNwaW5fdW5sb2NrKCZzYmktPmZzX2xvY2spOwogCQlkcHV0KGRlbnRyeSk7CmRpZmYgLS1naXQgYS9mcy9hdXRvZnM0L2lub2RlLmMgYi9mcy9hdXRvZnM0L2lub2RlLmMKaW5kZXggYTdiZGI5ZC4uMTgwZmEyNCAxMDA2NDQKLS0tIGEvZnMvYXV0b2ZzNC9pbm9kZS5jCisrKyBiL2ZzL2F1dG9mczQvaW5vZGUuYwpAQCAtMjIsNzcgKzIyLDI3IEBACiAjaW5jbHVkZSAiYXV0b2ZzX2kuaCIKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KIAotc3RhdGljIHZvaWQgaW5vX2xua2ZyZWUoc3RydWN0IGF1dG9mc19pbmZvICppbm8pCitzdHJ1Y3QgYXV0b2ZzX2luZm8gKmF1dG9mczRfbmV3X2lubyhzdHJ1Y3QgYXV0b2ZzX3NiX2luZm8gKnNiaSkKIHsKLQlpZiAoaW5vLT51LnN5bWxpbmspIHsKLQkJa2ZyZWUoaW5vLT51LnN5bWxpbmspOwotCQlpbm8tPnUuc3ltbGluayA9IE5VTEw7CisJc3RydWN0IGF1dG9mc19pbmZvICppbm8gPSBremFsbG9jKHNpemVvZigqaW5vKSwgR0ZQX0tFUk5FTCk7CisJaWYgKGlubykgeworCQlJTklUX0xJU1RfSEVBRCgmaW5vLT5hY3RpdmUpOworCQlJTklUX0xJU1RfSEVBRCgmaW5vLT5leHBpcmluZyk7CisJCWluby0+bGFzdF91c2VkID0gamlmZmllczsKKwkJaW5vLT5zYmkgPSBzYmk7CiAJfQorCXJldHVybiBpbm87CiB9CiAKLXN0cnVjdCBhdXRvZnNfaW5mbyAqYXV0b2ZzNF9pbml0X2lubyhzdHJ1Y3QgYXV0b2ZzX2luZm8gKmlubywKLQkJCQkgICAgIHN0cnVjdCBhdXRvZnNfc2JfaW5mbyAqc2JpLCBtb2RlX3QgbW9kZSkKK3ZvaWQgYXV0b2ZzNF9jbGVhbl9pbm8oc3RydWN0IGF1dG9mc19pbmZvICppbm8pCiB7Ci0JaW50IHJlaW5pdCA9IDE7Ci0KLQlpZiAoaW5vID09IE5VTEwpIHsKLQkJcmVpbml0ID0gMDsKLQkJaW5vID0ga21hbGxvYyhzaXplb2YoKmlubyksIEdGUF9LRVJORUwpOwotCX0KLQotCWlmIChpbm8gPT0gTlVMTCkKLQkJcmV0dXJuIE5VTEw7Ci0KLQlpZiAoIXJlaW5pdCkgewotCQlpbm8tPmZsYWdzID0gMDsKLQkJaW5vLT5pbm9kZSA9IE5VTEw7Ci0JCWluby0+ZGVudHJ5ID0gTlVMTDsKLQkJaW5vLT5zaXplID0gMDsKLQkJSU5JVF9MSVNUX0hFQUQoJmluby0+YWN0aXZlKTsKLQkJaW5vLT5hY3RpdmVfY291bnQgPSAwOwotCQlJTklUX0xJU1RfSEVBRCgmaW5vLT5leHBpcmluZyk7Ci0JCWF0b21pY19zZXQoJmluby0+Y291bnQsIDApOwotCX0KLQogCWluby0+dWlkID0gMDsKIAlpbm8tPmdpZCA9IDA7Ci0JaW5vLT5tb2RlID0gbW9kZTsKIAlpbm8tPmxhc3RfdXNlZCA9IGppZmZpZXM7Ci0KLQlpbm8tPnNiaSA9IHNiaTsKLQotCWlmIChyZWluaXQgJiYgaW5vLT5mcmVlKQotCQkoaW5vLT5mcmVlKShpbm8pOwotCi0JbWVtc2V0KCZpbm8tPnUsIDAsIHNpemVvZihpbm8tPnUpKTsKLQotCWluby0+ZnJlZSA9IE5VTEw7Ci0KLQlpZiAoU19JU0xOSyhtb2RlKSkKLQkJaW5vLT5mcmVlID0gaW5vX2xua2ZyZWU7Ci0KLQlyZXR1cm4gaW5vOwogfQogCiB2b2lkIGF1dG9mczRfZnJlZV9pbm8oc3RydWN0IGF1dG9mc19pbmZvICppbm8pCiB7Ci0Jc3RydWN0IGF1dG9mc19pbmZvICpwX2lubzsKLQotCWlmIChpbm8tPmRlbnRyeSkgewotCQlpbm8tPmRlbnRyeS0+ZF9mc2RhdGEgPSBOVUxMOwotCQlpZiAoaW5vLT5kZW50cnktPmRfaW5vZGUpIHsKLQkJCXN0cnVjdCBkZW50cnkgKnBhcmVudCA9IGluby0+ZGVudHJ5LT5kX3BhcmVudDsKLQkJCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZpbm8tPmNvdW50KSkgewotCQkJCXBfaW5vID0gYXV0b2ZzNF9kZW50cnlfaW5vKHBhcmVudCk7Ci0JCQkJaWYgKHBfaW5vICYmIHBhcmVudCAhPSBpbm8tPmRlbnRyeSkKLQkJCQkJYXRvbWljX2RlYygmcF9pbm8tPmNvdW50KTsKLQkJCX0KLQkJCWRwdXQoaW5vLT5kZW50cnkpOwotCQl9Ci0JCWluby0+ZGVudHJ5ID0gTlVMTDsKLQl9Ci0JaWYgKGluby0+ZnJlZSkKLQkJKGluby0+ZnJlZSkoaW5vKTsKIAlrZnJlZShpbm8pOwogfQogCkBAIC0xNDgsOSArOTgsMTYgQEAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIHZvaWQgYXV0b2ZzNF9ldmljdF9pbm9kZShzdHJ1Y3QgaW5vZGUgKmlub2RlKQoreworCWVuZF93cml0ZWJhY2soaW5vZGUpOworCWtmcmVlKGlub2RlLT5pX3ByaXZhdGUpOworfQorCiBzdGF0aWMgY29uc3Qgc3RydWN0IHN1cGVyX29wZXJhdGlvbnMgYXV0b2ZzNF9zb3BzID0gewogCS5zdGF0ZnMJCT0gc2ltcGxlX3N0YXRmcywKIAkuc2hvd19vcHRpb25zCT0gYXV0b2ZzNF9zaG93X29wdGlvbnMsCisJLmV2aWN0X2lub2RlCT0gYXV0b2ZzNF9ldmljdF9pbm9kZSwKIH07CiAKIGVudW0ge09wdF9lcnIsIE9wdF9mZCwgT3B0X3VpZCwgT3B0X2dpZCwgT3B0X3BncnAsIE9wdF9taW5wcm90bywgT3B0X21heHByb3RvLApAQCAtMjQwLDIxICsxOTcsNiBAQAogCXJldHVybiAoKnBpcGVmZCA8IDApOwogfQogCi1zdGF0aWMgc3RydWN0IGF1dG9mc19pbmZvICphdXRvZnM0X21rcm9vdChzdHJ1Y3QgYXV0b2ZzX3NiX2luZm8gKnNiaSkKLXsKLQlzdHJ1Y3QgYXV0b2ZzX2luZm8gKmlubzsKLQotCWlubyA9IGF1dG9mczRfaW5pdF9pbm8oTlVMTCwgc2JpLCBTX0lGRElSIHwgMDc1NSk7Ci0JaWYgKCFpbm8pCi0JCXJldHVybiBOVUxMOwotCi0JcmV0dXJuIGlubzsKLX0KLQotc3RhdGljIGNvbnN0IHN0cnVjdCBkZW50cnlfb3BlcmF0aW9ucyBhdXRvZnM0X3NiX2RlbnRyeV9vcGVyYXRpb25zID0gewotCS5kX3JlbGVhc2UgICAgICA9IGF1dG9mczRfZGVudHJ5X3JlbGVhc2UsCi19OwotCiBpbnQgYXV0b2ZzNF9maWxsX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqcywgdm9pZCAqZGF0YSwgaW50IHNpbGVudCkKIHsKIAlzdHJ1Y3QgaW5vZGUgKiByb290X2lub2RlOwpAQCAtMjkyLDE1ICsyMzQsMTYgQEAKIAlzLT5zX2Jsb2Nrc2l6ZV9iaXRzID0gMTA7CiAJcy0+c19tYWdpYyA9IEFVVE9GU19TVVBFUl9NQUdJQzsKIAlzLT5zX29wID0gJmF1dG9mczRfc29wczsKKwlzLT5zX2Rfb3AgPSAmYXV0b2ZzNF9kZW50cnlfb3BlcmF0aW9uczsKIAlzLT5zX3RpbWVfZ3JhbiA9IDE7CiAKIAkvKgogCSAqIEdldCB0aGUgcm9vdCBpbm9kZSBhbmQgZGVudHJ5LCBidXQgZGVmZXIgY2hlY2tpbmcgZm9yIGVycm9ycy4KIAkgKi8KLQlpbm8gPSBhdXRvZnM0X21rcm9vdChzYmkpOworCWlubyA9IGF1dG9mczRfbmV3X2lubyhzYmkpOwogCWlmICghaW5vKQogCQlnb3RvIGZhaWxfZnJlZTsKLQlyb290X2lub2RlID0gYXV0b2ZzNF9nZXRfaW5vZGUocywgaW5vKTsKKwlyb290X2lub2RlID0gYXV0b2ZzNF9nZXRfaW5vZGUocywgU19JRkRJUiB8IDA3NTUpOwogCWlmICghcm9vdF9pbm9kZSkKIAkJZ290byBmYWlsX2lubzsKIApAQCAtMzA5LDcgKzI1Miw2IEBACiAJCWdvdG8gZmFpbF9pcHV0OwogCXBpcGUgPSBOVUxMOwogCi0JZF9zZXRfZF9vcChyb290LCAmYXV0b2ZzNF9zYl9kZW50cnlfb3BlcmF0aW9ucyk7CiAJcm9vdC0+ZF9mc2RhdGEgPSBpbm87CiAKIAkvKiBDYW4gdGhpcyBjYWxsIGJsb2NrPyAqLwpAQCAtMzIwLDEwICsyNjIsMTEgQEAKIAkJZ290byBmYWlsX2RwdXQ7CiAJfQogCisJaWYgKGF1dG9mc190eXBlX3RyaWdnZXIoc2JpLT50eXBlKSkKKwkJX19tYW5hZ2VkX2RlbnRyeV9zZXRfbWFuYWdlZChyb290KTsKKwogCXJvb3RfaW5vZGUtPmlfZm9wID0gJmF1dG9mczRfcm9vdF9vcGVyYXRpb25zOwotCXJvb3RfaW5vZGUtPmlfb3AgPSBhdXRvZnNfdHlwZV90cmlnZ2VyKHNiaS0+dHlwZSkgPwotCQkJJmF1dG9mczRfZGlyZWN0X3Jvb3RfaW5vZGVfb3BlcmF0aW9ucyA6Ci0JCQkmYXV0b2ZzNF9pbmRpcmVjdF9yb290X2lub2RlX29wZXJhdGlvbnM7CisJcm9vdF9pbm9kZS0+aV9vcCA9ICZhdXRvZnM0X2Rpcl9pbm9kZV9vcGVyYXRpb25zOwogCiAJLyogQ291bGRuJ3QgdGhpcyBiZSB0ZXN0ZWQgZWFybGllcj8gKi8KIAlpZiAoc2JpLT5tYXhfcHJvdG8gPCBBVVRPRlNfTUlOX1BST1RPX1ZFUlNJT04gfHwKQEAgLTM4MywxNiArMzI2LDE0IEBACiAJcmV0dXJuIC1FSU5WQUw7CiB9CiAKLXN0cnVjdCBpbm9kZSAqYXV0b2ZzNF9nZXRfaW5vZGUoc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwKLQkJCQlzdHJ1Y3QgYXV0b2ZzX2luZm8gKmluZikKK3N0cnVjdCBpbm9kZSAqYXV0b2ZzNF9nZXRfaW5vZGUoc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgbW9kZV90IG1vZGUpCiB7CiAJc3RydWN0IGlub2RlICppbm9kZSA9IG5ld19pbm9kZShzYik7CiAKIAlpZiAoaW5vZGUgPT0gTlVMTCkKIAkJcmV0dXJuIE5VTEw7CiAKLQlpbmYtPmlub2RlID0gaW5vZGU7Ci0JaW5vZGUtPmlfbW9kZSA9IGluZi0+bW9kZTsKKwlpbm9kZS0+aV9tb2RlID0gbW9kZTsKIAlpZiAoc2ItPnNfcm9vdCkgewogCQlpbm9kZS0+aV91aWQgPSBzYi0+c19yb290LT5kX2lub2RlLT5pX3VpZDsKIAkJaW5vZGUtPmlfZ2lkID0gc2ItPnNfcm9vdC0+ZF9pbm9kZS0+aV9naWQ7CkBAIC00MDAsMTIgKzM0MSwxMSBAQAogCWlub2RlLT5pX2F0aW1lID0gaW5vZGUtPmlfbXRpbWUgPSBpbm9kZS0+aV9jdGltZSA9IENVUlJFTlRfVElNRTsKIAlpbm9kZS0+aV9pbm8gPSBnZXRfbmV4dF9pbm8oKTsKIAotCWlmIChTX0lTRElSKGluZi0+bW9kZSkpIHsKKwlpZiAoU19JU0RJUihtb2RlKSkgewogCQlpbm9kZS0+aV9ubGluayA9IDI7CiAJCWlub2RlLT5pX29wID0gJmF1dG9mczRfZGlyX2lub2RlX29wZXJhdGlvbnM7CiAJCWlub2RlLT5pX2ZvcCA9ICZhdXRvZnM0X2Rpcl9vcGVyYXRpb25zOwotCX0gZWxzZSBpZiAoU19JU0xOSyhpbmYtPm1vZGUpKSB7Ci0JCWlub2RlLT5pX3NpemUgPSBpbmYtPnNpemU7CisJfSBlbHNlIGlmIChTX0lTTE5LKG1vZGUpKSB7CiAJCWlub2RlLT5pX29wID0gJmF1dG9mczRfc3ltbGlua19pbm9kZV9vcGVyYXRpb25zOwogCX0KIApkaWZmIC0tZ2l0IGEvZnMvYXV0b2ZzNC9yb290LmMgYi9mcy9hdXRvZnM0L3Jvb3QuYwppbmRleCA2NTFlNGVmLi4wMTRlN2FiIDEwMDY0NAotLS0gYS9mcy9hdXRvZnM0L3Jvb3QuYworKysgYi9mcy9hdXRvZnM0L3Jvb3QuYwpAQCAtMzUsMTAgKzM1LDkgQEAKICNlbmRpZgogc3RhdGljIGludCBhdXRvZnM0X2Rpcl9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKTsKIHN0YXRpYyBzdHJ1Y3QgZGVudHJ5ICphdXRvZnM0X2xvb2t1cChzdHJ1Y3QgaW5vZGUgKixzdHJ1Y3QgZGVudHJ5ICosIHN0cnVjdCBuYW1laWRhdGEgKik7Ci1zdGF0aWMgdm9pZCAqYXV0b2ZzNF9mb2xsb3dfbGluayhzdHJ1Y3QgZGVudHJ5ICosIHN0cnVjdCBuYW1laWRhdGEgKik7Ci0KLSNkZWZpbmUgVFJJR0dFUl9GTEFHUyAgIChMT09LVVBfQ09OVElOVUUgfCBMT09LVVBfRElSRUNUT1JZKQotI2RlZmluZSBUUklHR0VSX0lOVEVOVFMgKExPT0tVUF9PUEVOIHwgTE9PS1VQX0NSRUFURSkKK3N0YXRpYyBzdHJ1Y3QgdmZzbW91bnQgKmF1dG9mczRfZF9hdXRvbW91bnQoc3RydWN0IHBhdGggKik7CitzdGF0aWMgaW50IGF1dG9mczRfZF9tYW5hZ2Uoc3RydWN0IGRlbnRyeSAqLCBib29sLCBib29sKTsKK3N0YXRpYyB2b2lkIGF1dG9mczRfZGVudHJ5X3JlbGVhc2Uoc3RydWN0IGRlbnRyeSAqKTsKIAogY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBhdXRvZnM0X3Jvb3Rfb3BlcmF0aW9ucyA9IHsKIAkub3BlbgkJPSBkY2FjaGVfZGlyX29wZW4sCkBAIC02MCwyMiArNTksNiBAQAogCS5sbHNlZWsJCT0gZGNhY2hlX2Rpcl9sc2VlaywKIH07CiAKLWNvbnN0IHN0cnVjdCBpbm9kZV9vcGVyYXRpb25zIGF1dG9mczRfaW5kaXJlY3Rfcm9vdF9pbm9kZV9vcGVyYXRpb25zID0gewotCS5sb29rdXAJCT0gYXV0b2ZzNF9sb29rdXAsCi0JLnVubGluawkJPSBhdXRvZnM0X2Rpcl91bmxpbmssCi0JLnN5bWxpbmsJPSBhdXRvZnM0X2Rpcl9zeW1saW5rLAotCS5ta2RpcgkJPSBhdXRvZnM0X2Rpcl9ta2RpciwKLQkucm1kaXIJCT0gYXV0b2ZzNF9kaXJfcm1kaXIsCi19OwotCi1jb25zdCBzdHJ1Y3QgaW5vZGVfb3BlcmF0aW9ucyBhdXRvZnM0X2RpcmVjdF9yb290X2lub2RlX29wZXJhdGlvbnMgPSB7Ci0JLmxvb2t1cAkJPSBhdXRvZnM0X2xvb2t1cCwKLQkudW5saW5rCQk9IGF1dG9mczRfZGlyX3VubGluaywKLQkubWtkaXIJCT0gYXV0b2ZzNF9kaXJfbWtkaXIsCi0JLnJtZGlyCQk9IGF1dG9mczRfZGlyX3JtZGlyLAotCS5mb2xsb3dfbGluawk9IGF1dG9mczRfZm9sbG93X2xpbmssCi19OwotCiBjb25zdCBzdHJ1Y3QgaW5vZGVfb3BlcmF0aW9ucyBhdXRvZnM0X2Rpcl9pbm9kZV9vcGVyYXRpb25zID0gewogCS5sb29rdXAJCT0gYXV0b2ZzNF9sb29rdXAsCiAJLnVubGluawkJPSBhdXRvZnM0X2Rpcl91bmxpbmssCkBAIC04NCw2ICs2NywxMiBAQAogCS5ybWRpcgkJPSBhdXRvZnM0X2Rpcl9ybWRpciwKIH07CiAKK2NvbnN0IHN0cnVjdCBkZW50cnlfb3BlcmF0aW9ucyBhdXRvZnM0X2RlbnRyeV9vcGVyYXRpb25zID0geworCS5kX2F1dG9tb3VudAk9IGF1dG9mczRfZF9hdXRvbW91bnQsCisJLmRfbWFuYWdlCT0gYXV0b2ZzNF9kX21hbmFnZSwKKwkuZF9yZWxlYXNlCT0gYXV0b2ZzNF9kZW50cnlfcmVsZWFzZSwKK307CisKIHN0YXRpYyB2b2lkIGF1dG9mczRfYWRkX2FjdGl2ZShzdHJ1Y3QgZGVudHJ5ICpkZW50cnkpCiB7CiAJc3RydWN0IGF1dG9mc19zYl9pbmZvICpzYmkgPSBhdXRvZnM0X3NiaShkZW50cnktPmRfc2IpOwpAQCAtMTE2LDE0ICsxMDUsNiBAQAogCXJldHVybjsKIH0KIAotc3RhdGljIHVuc2lnbmVkIGludCBhdXRvZnM0X25lZWRfbW91bnQodW5zaWduZWQgaW50IGZsYWdzKQotewotCXVuc2lnbmVkIGludCByZXMgPSAwOwotCWlmIChmbGFncyAmIChUUklHR0VSX0ZMQUdTIHwgVFJJR0dFUl9JTlRFTlRTKSkKLQkJcmVzID0gMTsKLQlyZXR1cm4gcmVzOwotfQotCiBzdGF0aWMgaW50IGF1dG9mczRfZGlyX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCiB7CiAJc3RydWN0IGRlbnRyeSAqZGVudHJ5ID0gZmlsZS0+Zl9wYXRoLmRlbnRyeTsKQEAgLTE1OCwyNzkgKzEzOSwyOCBAQAogCXJldHVybiBkY2FjaGVfZGlyX29wZW4oaW5vZGUsIGZpbGUpOwogfQogCi1zdGF0aWMgaW50IHRyeV90b19maWxsX2RlbnRyeShzdHJ1Y3QgZGVudHJ5ICpkZW50cnksIGludCBmbGFncykKK3N0YXRpYyB2b2lkIGF1dG9mczRfZGVudHJ5X3JlbGVhc2Uoc3RydWN0IGRlbnRyeSAqZGUpCiB7Ci0Jc3RydWN0IGF1dG9mc19zYl9pbmZvICpzYmkgPSBhdXRvZnM0X3NiaShkZW50cnktPmRfc2IpOwotCXN0cnVjdCBhdXRvZnNfaW5mbyAqaW5vID0gYXV0b2ZzNF9kZW50cnlfaW5vKGRlbnRyeSk7Ci0JaW50IHN0YXR1czsKLQotCURQUklOVEsoImRlbnRyeT0lcCAlLipzIGlubz0lcCIsCi0JCSBkZW50cnksIGRlbnRyeS0+ZF9uYW1lLmxlbiwgZGVudHJ5LT5kX25hbWUubmFtZSwgZGVudHJ5LT5kX2lub2RlKTsKLQotCS8qCi0JICogV2FpdCBmb3IgYSBwZW5kaW5nIG1vdW50LCB0cmlnZ2VyaW5nIG9uZSBpZiB0aGVyZQotCSAqIGlzbid0IG9uZSBhbHJlYWR5Ci0JICovCi0JaWYgKGRlbnRyeS0+ZF9pbm9kZSA9PSBOVUxMKSB7Ci0JCURQUklOVEsoIndhaXRpbmcgZm9yIG1vdW50IG5hbWU9JS4qcyIsCi0JCQkgZGVudHJ5LT5kX25hbWUubGVuLCBkZW50cnktPmRfbmFtZS5uYW1lKTsKLQotCQlzdGF0dXMgPSBhdXRvZnM0X3dhaXQoc2JpLCBkZW50cnksIE5GWV9NT1VOVCk7Ci0KLQkJRFBSSU5USygibW91bnQgZG9uZSBzdGF0dXM9JWQiLCBzdGF0dXMpOwotCi0JCS8qIFR1cm4gdGhpcyBpbnRvIGEgcmVhbCBuZWdhdGl2ZSBkZW50cnk/ICovCi0JCWlmIChzdGF0dXMgPT0gLUVOT0VOVCkgewotCQkJc3Bpbl9sb2NrKCZzYmktPmZzX2xvY2spOwotCQkJaW5vLT5mbGFncyAmPSB+QVVUT0ZTX0lORl9QRU5ESU5HOwotCQkJc3Bpbl91bmxvY2soJnNiaS0+ZnNfbG9jayk7Ci0JCQlyZXR1cm4gc3RhdHVzOwotCQl9IGVsc2UgaWYgKHN0YXR1cykgewotCQkJLyogUmV0dXJuIGEgbmVnYXRpdmUgZGVudHJ5LCBidXQgbGVhdmUgaXQgInBlbmRpbmciICovCi0JCQlyZXR1cm4gc3RhdHVzOwotCQl9Ci0JLyogVHJpZ2dlciBtb3VudCBmb3IgcGF0aCBjb21wb25lbnQgb3IgZm9sbG93IGxpbmsgKi8KLQl9IGVsc2UgaWYgKGluby0+ZmxhZ3MgJiBBVVRPRlNfSU5GX1BFTkRJTkcgfHwKLQkJCWF1dG9mczRfbmVlZF9tb3VudChmbGFncykpIHsKLQkJRFBSSU5USygid2FpdGluZyBmb3IgbW91bnQgbmFtZT0lLipzIiwKLQkJCWRlbnRyeS0+ZF9uYW1lLmxlbiwgZGVudHJ5LT5kX25hbWUubmFtZSk7Ci0KLQkJc3Bpbl9sb2NrKCZzYmktPmZzX2xvY2spOwotCQlpbm8tPmZsYWdzIHw9IEFVVE9GU19JTkZfUEVORElORzsKLQkJc3Bpbl91bmxvY2soJnNiaS0+ZnNfbG9jayk7Ci0JCXN0YXR1cyA9IGF1dG9mczRfd2FpdChzYmksIGRlbnRyeSwgTkZZX01PVU5UKTsKLQotCQlEUFJJTlRLKCJtb3VudCBkb25lIHN0YXR1cz0lZCIsIHN0YXR1cyk7Ci0KLQkJaWYgKHN0YXR1cykgewotCQkJc3Bpbl9sb2NrKCZzYmktPmZzX2xvY2spOwotCQkJaW5vLT5mbGFncyAmPSB+QVVUT0ZTX0lORl9QRU5ESU5HOwotCQkJc3Bpbl91bmxvY2soJnNiaS0+ZnNfbG9jayk7Ci0JCQlyZXR1cm4gc3RhdHVzOwotCQl9Ci0JfQotCi0JLyogSW5pdGlhbGl6ZSBleHBpcnkgY291bnRlciBhZnRlciBzdWNjZXNzZnVsIG1vdW50ICovCi0JaW5vLT5sYXN0X3VzZWQgPSBqaWZmaWVzOwotCi0Jc3Bpbl9sb2NrKCZzYmktPmZzX2xvY2spOwotCWluby0+ZmxhZ3MgJj0gfkFVVE9GU19JTkZfUEVORElORzsKLQlzcGluX3VubG9jaygmc2JpLT5mc19sb2NrKTsKLQotCXJldHVybiAwOwotfQotCi0vKiBGb3IgYXV0b2ZzIGRpcmVjdCBtb3VudHMgdGhlIGZvbGxvdyBsaW5rIHRyaWdnZXJzIHRoZSBtb3VudCAqLwotc3RhdGljIHZvaWQgKmF1dG9mczRfZm9sbG93X2xpbmsoc3RydWN0IGRlbnRyeSAqZGVudHJ5LCBzdHJ1Y3QgbmFtZWlkYXRhICpuZCkKLXsKLQlzdHJ1Y3QgYXV0b2ZzX3NiX2luZm8gKnNiaSA9IGF1dG9mczRfc2JpKGRlbnRyeS0+ZF9zYik7Ci0Jc3RydWN0IGF1dG9mc19pbmZvICppbm8gPSBhdXRvZnM0X2RlbnRyeV9pbm8oZGVudHJ5KTsKLQlpbnQgb3pfbW9kZSA9IGF1dG9mczRfb3pfbW9kZShzYmkpOwotCXVuc2lnbmVkIGludCBsb29rdXBfdHlwZTsKLQlpbnQgc3RhdHVzOwotCi0JRFBSSU5USygiZGVudHJ5PSVwICUuKnMgb3pfbW9kZT0lZCBuZC0+ZmxhZ3M9JWQiLAotCQlkZW50cnksIGRlbnRyeS0+ZF9uYW1lLmxlbiwgZGVudHJ5LT5kX25hbWUubmFtZSwgb3pfbW9kZSwKLQkJbmQtPmZsYWdzKTsKLQkvKgotCSAqIEZvciBhbiBleHBpcmUgb2YgYSBjb3ZlcmVkIGRpcmVjdCBvciBvZmZzZXQgbW91bnQgd2UgbmVlZAotCSAqIHRvIGJyZWFrIG91dCBvZiBmb2xsb3dfZG93bigpIGF0IHRoZSBhdXRvZnMgbW91bnQgdHJpZ2dlcgotCSAqIChkX21vdW50ZWQtLSksIHNvIHdlIGNhbiBzZWUgdGhlIGV4cGlyaW5nIGZsYWcsIGFuZCBtYW5hZ2UKLQkgKiB0aGUgYmxvY2tpbmcgYW5kIGZvbGxvd2luZyBoZXJlIHVudGlsIHRoZSBleHBpcmUgaXMgY29tcGxldGVkLgotCSAqLwotCWlmIChvel9tb2RlKSB7Ci0JCXNwaW5fbG9jaygmc2JpLT5mc19sb2NrKTsKLQkJaWYgKGluby0+ZmxhZ3MgJiBBVVRPRlNfSU5GX0VYUElSSU5HKSB7Ci0JCQlzcGluX3VubG9jaygmc2JpLT5mc19sb2NrKTsKLQkJCS8qIEZvbGxvdyBkb3duIHRvIG91ciBjb3ZlcmluZyBtb3VudC4gKi8KLQkJCWlmICghZm9sbG93X2Rvd24oJm5kLT5wYXRoKSkKLQkJCQlnb3RvIGRvbmU7Ci0JCQlnb3RvIGZvbGxvdzsKLQkJfQotCQlzcGluX3VubG9jaygmc2JpLT5mc19sb2NrKTsKLQkJZ290byBkb25lOwotCX0KLQotCS8qIElmIGFuIGV4cGlyZSByZXF1ZXN0IGlzIHBlbmRpbmcgZXZlcnlvbmUgbXVzdCB3YWl0LiAqLwotCWF1dG9mczRfZXhwaXJlX3dhaXQoZGVudHJ5KTsKLQotCS8qIFdlIHRyaWdnZXIgYSBtb3VudCBmb3IgYWxtb3N0IGFsbCBmbGFncyAqLwotCWxvb2t1cF90eXBlID0gYXV0b2ZzNF9uZWVkX21vdW50KG5kLT5mbGFncyk7Ci0Jc3Bpbl9sb2NrKCZzYmktPmZzX2xvY2spOwotCXNwaW5fbG9jaygmYXV0b2ZzNF9sb2NrKTsKLQlzcGluX2xvY2soJmRlbnRyeS0+ZF9sb2NrKTsKLQlpZiAoIShsb29rdXBfdHlwZSB8fCBpbm8tPmZsYWdzICYgQVVUT0ZTX0lORl9QRU5ESU5HKSkgewotCQlzcGluX3VubG9jaygmZGVudHJ5LT5kX2xvY2spOwotCQlzcGluX3VubG9jaygmYXV0b2ZzNF9sb2NrKTsKLQkJc3Bpbl91bmxvY2soJnNiaS0+ZnNfbG9jayk7Ci0JCWdvdG8gZm9sbG93OwotCX0KLQotCS8qCi0JICogSWYgdGhlIGRlbnRyeSBjb250YWlucyBkaXJlY3RvcmllcyB0aGVuIGl0IGlzIGFuIGF1dG9mcwotCSAqIG11bHRpLW1vdW50IHdpdGggbm8gcm9vdCBtb3VudCBvZmZzZXQuIFNvIGRvbid0IHRyeSB0bwotCSAqIG1vdW50IGl0IGFnYWluLgotCSAqLwotCWlmIChpbm8tPmZsYWdzICYgQVVUT0ZTX0lORl9QRU5ESU5HIHx8Ci0JICAgICghZF9tb3VudHBvaW50KGRlbnRyeSkgJiYgbGlzdF9lbXB0eSgmZGVudHJ5LT5kX3N1YmRpcnMpKSkgewotCQlzcGluX3VubG9jaygmZGVudHJ5LT5kX2xvY2spOwotCQlzcGluX3VubG9jaygmYXV0b2ZzNF9sb2NrKTsKLQkJc3Bpbl91bmxvY2soJnNiaS0+ZnNfbG9jayk7Ci0KLQkJc3RhdHVzID0gdHJ5X3RvX2ZpbGxfZGVudHJ5KGRlbnRyeSwgbmQtPmZsYWdzKTsKLQkJaWYgKHN0YXR1cykKLQkJCWdvdG8gb3V0X2Vycm9yOwotCi0JCWdvdG8gZm9sbG93OwotCX0KLQlzcGluX3VubG9jaygmZGVudHJ5LT5kX2xvY2spOwotCXNwaW5fdW5sb2NrKCZhdXRvZnM0X2xvY2spOwotCXNwaW5fdW5sb2NrKCZzYmktPmZzX2xvY2spOwotZm9sbG93OgotCS8qCi0JICogSWYgdGhlcmUgaXMgbm8gcm9vdCBtb3VudCBpdCBtdXN0IGJlIGFuIGF1dG9mcwotCSAqIG11bHRpLW1vdW50IHdpdGggbm8gcm9vdCBvZmZzZXQgc28gd2UgZG9uJ3QgbmVlZAotCSAqIHRvIGZvbGxvdyBpdC4KLQkgKi8KLQlpZiAoZF9tb3VudHBvaW50KGRlbnRyeSkpIHsKLQkJaWYgKCFhdXRvZnM0X2ZvbGxvd19tb3VudCgmbmQtPnBhdGgpKSB7Ci0JCQlzdGF0dXMgPSAtRU5PRU5UOwotCQkJZ290byBvdXRfZXJyb3I7Ci0JCX0KLQl9Ci0KLWRvbmU6Ci0JcmV0dXJuIE5VTEw7Ci0KLW91dF9lcnJvcjoKLQlwYXRoX3B1dCgmbmQtPnBhdGgpOwotCXJldHVybiBFUlJfUFRSKHN0YXR1cyk7Ci19Ci0KLS8qCi0gKiBSZXZhbGlkYXRlIGlzIGNhbGxlZCBvbiBldmVyeSBjYWNoZSBsb29rdXAuICBTb21lIG9mIHRob3NlCi0gKiBjYWNoZSBsb29rdXBzIG1heSBhY3R1YWxseSBoYXBwZW4gd2hpbGUgdGhlIGRlbnRyeSBpcyBub3QKLSAqIHlldCBjb21wbGV0ZWx5IGZpbGxlZCBpbiwgYW5kIHJldmFsaWRhdGUgaGFzIHRvIGRlbGF5IHN1Y2gKLSAqIGxvb2t1cHMuLgotICovCi1zdGF0aWMgaW50IGF1dG9mczRfcmV2YWxpZGF0ZShzdHJ1Y3QgZGVudHJ5ICpkZW50cnksIHN0cnVjdCBuYW1laWRhdGEgKm5kKQotewotCXN0cnVjdCBpbm9kZSAqZGlyOwotCXN0cnVjdCBhdXRvZnNfc2JfaW5mbyAqc2JpOwotCWludCBvel9tb2RlOwotCWludCBmbGFncyA9IG5kID8gbmQtPmZsYWdzIDogMDsKLQlpbnQgc3RhdHVzID0gMTsKLQotCWlmIChmbGFncyAmIExPT0tVUF9SQ1UpCi0JCXJldHVybiAtRUNISUxEOwotCi0JZGlyID0gZGVudHJ5LT5kX3BhcmVudC0+ZF9pbm9kZTsKLQlzYmkgPSBhdXRvZnM0X3NiaShkaXItPmlfc2IpOwotCW96X21vZGUgPSBhdXRvZnM0X296X21vZGUoc2JpKTsKLQotCS8qIFBlbmRpbmcgZGVudHJ5ICovCi0Jc3Bpbl9sb2NrKCZzYmktPmZzX2xvY2spOwotCWlmIChhdXRvZnM0X2lzcGVuZGluZyhkZW50cnkpKSB7Ci0JCS8qIFRoZSBkYWVtb24gbmV2ZXIgY2F1c2VzIGEgbW91bnQgdG8gdHJpZ2dlciAqLwotCQlzcGluX3VubG9jaygmc2JpLT5mc19sb2NrKTsKLQotCQlpZiAob3pfbW9kZSkKLQkJCXJldHVybiAxOwotCi0JCS8qCi0JCSAqIElmIHRoZSBkaXJlY3RvcnkgaGFzIGdvbmUgYXdheSBkdWUgdG8gYW4gZXhwaXJlCi0JCSAqIHdlIGhhdmUgYmVlbiBjYWxsZWQgYXMgLT5kX3JldmFsaWRhdGUoKSBhbmQgc28KLQkJICogd2UgbmVlZCB0byByZXR1cm4gZmFsc2UgYW5kIHByb2NlZWQgdG8gLT5sb29rdXAoKS4KLQkJICovCi0JCWlmIChhdXRvZnM0X2V4cGlyZV93YWl0KGRlbnRyeSkgPT0gLUVBR0FJTikKLQkJCXJldHVybiAwOwotCi0JCS8qCi0JCSAqIEEgemVybyBzdGF0dXMgaXMgc3VjY2VzcyBvdGhlcndpc2Ugd2UgaGF2ZSBhCi0JCSAqIG5lZ2F0aXZlIGVycm9yIGNvZGUuCi0JCSAqLwotCQlzdGF0dXMgPSB0cnlfdG9fZmlsbF9kZW50cnkoZGVudHJ5LCBmbGFncyk7Ci0JCWlmIChzdGF0dXMgPT0gMCkKLQkJCXJldHVybiAxOwotCi0JCXJldHVybiBzdGF0dXM7Ci0JfQotCXNwaW5fdW5sb2NrKCZzYmktPmZzX2xvY2spOwotCi0JLyogTmVnYXRpdmUgZGVudHJ5Li4gaW52YWxpZGF0ZSBpZiAib2xkIiAqLwotCWlmIChkZW50cnktPmRfaW5vZGUgPT0gTlVMTCkKLQkJcmV0dXJuIDA7Ci0KLQkvKiBDaGVjayBmb3IgYSBub24tbW91bnRwb2ludCBkaXJlY3Rvcnkgd2l0aCBubyBjb250ZW50cyAqLwotCXNwaW5fbG9jaygmYXV0b2ZzNF9sb2NrKTsKLQlzcGluX2xvY2soJmRlbnRyeS0+ZF9sb2NrKTsKLQlpZiAoU19JU0RJUihkZW50cnktPmRfaW5vZGUtPmlfbW9kZSkgJiYKLQkgICAgIWRfbW91bnRwb2ludChkZW50cnkpICYmIGxpc3RfZW1wdHkoJmRlbnRyeS0+ZF9zdWJkaXJzKSkgewotCQlEUFJJTlRLKCJkZW50cnk9JXAgJS4qcywgZW1wdHlkaXIiLAotCQkJIGRlbnRyeSwgZGVudHJ5LT5kX25hbWUubGVuLCBkZW50cnktPmRfbmFtZS5uYW1lKTsKLQkJc3Bpbl91bmxvY2soJmRlbnRyeS0+ZF9sb2NrKTsKLQkJc3Bpbl91bmxvY2soJmF1dG9mczRfbG9jayk7Ci0KLQkJLyogVGhlIGRhZW1vbiBuZXZlciBjYXVzZXMgYSBtb3VudCB0byB0cmlnZ2VyICovCi0JCWlmIChvel9tb2RlKQotCQkJcmV0dXJuIDE7Ci0KLQkJLyoKLQkJICogQSB6ZXJvIHN0YXR1cyBpcyBzdWNjZXNzIG90aGVyd2lzZSB3ZSBoYXZlIGEKLQkJICogbmVnYXRpdmUgZXJyb3IgY29kZS4KLQkJICovCi0JCXN0YXR1cyA9IHRyeV90b19maWxsX2RlbnRyeShkZW50cnksIGZsYWdzKTsKLQkJaWYgKHN0YXR1cyA9PSAwKQotCQkJcmV0dXJuIDE7Ci0KLQkJcmV0dXJuIHN0YXR1czsKLQl9Ci0Jc3Bpbl91bmxvY2soJmRlbnRyeS0+ZF9sb2NrKTsKLQlzcGluX3VubG9jaygmYXV0b2ZzNF9sb2NrKTsKLQotCXJldHVybiAxOwotfQotCi12b2lkIGF1dG9mczRfZGVudHJ5X3JlbGVhc2Uoc3RydWN0IGRlbnRyeSAqZGUpCi17Ci0Jc3RydWN0IGF1dG9mc19pbmZvICppbmY7CisJc3RydWN0IGF1dG9mc19pbmZvICppbm8gPSBhdXRvZnM0X2RlbnRyeV9pbm8oZGUpOworCXN0cnVjdCBhdXRvZnNfc2JfaW5mbyAqc2JpID0gYXV0b2ZzNF9zYmkoZGUtPmRfc2IpOwogCiAJRFBSSU5USygicmVsZWFzaW5nICVwIiwgZGUpOwogCi0JaW5mID0gYXV0b2ZzNF9kZW50cnlfaW5vKGRlKTsKLQlkZS0+ZF9mc2RhdGEgPSBOVUxMOworCWlmICghaW5vKQorCQlyZXR1cm47CiAKLQlpZiAoaW5mKSB7Ci0JCXN0cnVjdCBhdXRvZnNfc2JfaW5mbyAqc2JpID0gYXV0b2ZzNF9zYmkoZGUtPmRfc2IpOwotCi0JCWlmIChzYmkpIHsKLQkJCXNwaW5fbG9jaygmc2JpLT5sb29rdXBfbG9jayk7Ci0JCQlpZiAoIWxpc3RfZW1wdHkoJmluZi0+YWN0aXZlKSkKLQkJCQlsaXN0X2RlbCgmaW5mLT5hY3RpdmUpOwotCQkJaWYgKCFsaXN0X2VtcHR5KCZpbmYtPmV4cGlyaW5nKSkKLQkJCQlsaXN0X2RlbCgmaW5mLT5leHBpcmluZyk7Ci0JCQlzcGluX3VubG9jaygmc2JpLT5sb29rdXBfbG9jayk7Ci0JCX0KLQotCQlpbmYtPmRlbnRyeSA9IE5VTEw7Ci0JCWluZi0+aW5vZGUgPSBOVUxMOwotCi0JCWF1dG9mczRfZnJlZV9pbm8oaW5mKTsKKwlpZiAoc2JpKSB7CisJCXNwaW5fbG9jaygmc2JpLT5sb29rdXBfbG9jayk7CisJCWlmICghbGlzdF9lbXB0eSgmaW5vLT5hY3RpdmUpKQorCQkJbGlzdF9kZWwoJmluby0+YWN0aXZlKTsKKwkJaWYgKCFsaXN0X2VtcHR5KCZpbm8tPmV4cGlyaW5nKSkKKwkJCWxpc3RfZGVsKCZpbm8tPmV4cGlyaW5nKTsKKwkJc3Bpbl91bmxvY2soJnNiaS0+bG9va3VwX2xvY2spOwogCX0KKworCWF1dG9mczRfZnJlZV9pbm8oaW5vKTsKIH0KIAotLyogRm9yIGRlbnRyaWVzIG9mIGRpcmVjdG9yaWVzIGluIHRoZSByb290IGRpciAqLwotc3RhdGljIGNvbnN0IHN0cnVjdCBkZW50cnlfb3BlcmF0aW9ucyBhdXRvZnM0X3Jvb3RfZGVudHJ5X29wZXJhdGlvbnMgPSB7Ci0JLmRfcmV2YWxpZGF0ZQk9IGF1dG9mczRfcmV2YWxpZGF0ZSwKLQkuZF9yZWxlYXNlCT0gYXV0b2ZzNF9kZW50cnlfcmVsZWFzZSwKLX07Ci0KLS8qIEZvciBvdGhlciBkZW50cmllcyAqLwotc3RhdGljIGNvbnN0IHN0cnVjdCBkZW50cnlfb3BlcmF0aW9ucyBhdXRvZnM0X2RlbnRyeV9vcGVyYXRpb25zID0gewotCS5kX3JldmFsaWRhdGUJPSBhdXRvZnM0X3JldmFsaWRhdGUsCi0JLmRfcmVsZWFzZQk9IGF1dG9mczRfZGVudHJ5X3JlbGVhc2UsCi19OwotCiBzdGF0aWMgc3RydWN0IGRlbnRyeSAqYXV0b2ZzNF9sb29rdXBfYWN0aXZlKHN0cnVjdCBkZW50cnkgKmRlbnRyeSkKIHsKIAlzdHJ1Y3QgYXV0b2ZzX3NiX2luZm8gKnNiaSA9IGF1dG9mczRfc2JpKGRlbnRyeS0+ZF9zYik7CkBAIC01NDEsNTEgKzI3MSwyNDYgQEAKIAlyZXR1cm4gTlVMTDsKIH0KIAorc3RhdGljIGludCBhdXRvZnM0X21vdW50X3dhaXQoc3RydWN0IGRlbnRyeSAqZGVudHJ5KQoreworCXN0cnVjdCBhdXRvZnNfc2JfaW5mbyAqc2JpID0gYXV0b2ZzNF9zYmkoZGVudHJ5LT5kX3NiKTsKKwlzdHJ1Y3QgYXV0b2ZzX2luZm8gKmlubyA9IGF1dG9mczRfZGVudHJ5X2lubyhkZW50cnkpOworCWludCBzdGF0dXM7CisKKwlpZiAoaW5vLT5mbGFncyAmIEFVVE9GU19JTkZfUEVORElORykgeworCQlEUFJJTlRLKCJ3YWl0aW5nIGZvciBtb3VudCBuYW1lPSUuKnMiLAorCQkJZGVudHJ5LT5kX25hbWUubGVuLCBkZW50cnktPmRfbmFtZS5uYW1lKTsKKwkJc3RhdHVzID0gYXV0b2ZzNF93YWl0KHNiaSwgZGVudHJ5LCBORllfTU9VTlQpOworCQlEUFJJTlRLKCJtb3VudCB3YWl0IGRvbmUgc3RhdHVzPSVkIiwgc3RhdHVzKTsKKwkJaW5vLT5sYXN0X3VzZWQgPSBqaWZmaWVzOworCQlyZXR1cm4gc3RhdHVzOworCX0KKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBkb19leHBpcmVfd2FpdChzdHJ1Y3QgZGVudHJ5ICpkZW50cnkpCit7CisJc3RydWN0IGRlbnRyeSAqZXhwaXJpbmc7CisKKwlleHBpcmluZyA9IGF1dG9mczRfbG9va3VwX2V4cGlyaW5nKGRlbnRyeSk7CisJaWYgKCFleHBpcmluZykKKwkJcmV0dXJuIGF1dG9mczRfZXhwaXJlX3dhaXQoZGVudHJ5KTsKKwllbHNlIHsKKwkJLyoKKwkJICogSWYgd2UgYXJlIHJhY2luZyB3aXRoIGV4cGlyZSB0aGUgcmVxdWVzdCBtaWdodCBub3QKKwkJICogYmUgcXVpdGUgY29tcGxldGUsIGJ1dCB0aGUgZGlyZWN0b3J5IGhhcyBiZWVuIHJlbW92ZWQKKwkJICogc28gaXQgbXVzdCBoYXZlIGJlZW4gc3VjY2Vzc2Z1bCwganVzdCB3YWl0IGZvciBpdC4KKwkJICovCisJCWF1dG9mczRfZXhwaXJlX3dhaXQoZXhwaXJpbmcpOworCQlhdXRvZnM0X2RlbF9leHBpcmluZyhleHBpcmluZyk7CisJCWRwdXQoZXhwaXJpbmcpOworCX0KKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCBkZW50cnkgKmF1dG9mczRfbW91bnRwb2ludF9jaGFuZ2VkKHN0cnVjdCBwYXRoICpwYXRoKQoreworCXN0cnVjdCBkZW50cnkgKmRlbnRyeSA9IHBhdGgtPmRlbnRyeTsKKwlzdHJ1Y3QgYXV0b2ZzX3NiX2luZm8gKnNiaSA9IGF1dG9mczRfc2JpKGRlbnRyeS0+ZF9zYik7CisKKwkvKgorCSAqIElmIHRoaXMgaXMgYW4gaW5kaXJlY3QgbW91bnQgdGhlIGRlbnRyeSBjb3VsZCBoYXZlIGdvbmUgYXdheQorCSAqIGFzIGEgcmVzdWx0IG9mIGFuIGV4cGlyZSBhbmQgYSBuZXcgb25lIGNyZWF0ZWQuCisJICovCisJaWYgKGF1dG9mc190eXBlX2luZGlyZWN0KHNiaS0+dHlwZSkgJiYgZF91bmhhc2hlZChkZW50cnkpKSB7CisJCXN0cnVjdCBkZW50cnkgKnBhcmVudCA9IGRlbnRyeS0+ZF9wYXJlbnQ7CisJCXN0cnVjdCBkZW50cnkgKm5ldyA9IGRfbG9va3VwKHBhcmVudCwgJmRlbnRyeS0+ZF9uYW1lKTsKKwkJaWYgKCFuZXcpCisJCQlyZXR1cm4gTlVMTDsKKwkJZHB1dChwYXRoLT5kZW50cnkpOworCQlwYXRoLT5kZW50cnkgPSBuZXc7CisJfQorCXJldHVybiBwYXRoLT5kZW50cnk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgdmZzbW91bnQgKmF1dG9mczRfZF9hdXRvbW91bnQoc3RydWN0IHBhdGggKnBhdGgpCit7CisJc3RydWN0IGRlbnRyeSAqZGVudHJ5ID0gcGF0aC0+ZGVudHJ5OworCXN0cnVjdCBhdXRvZnNfc2JfaW5mbyAqc2JpID0gYXV0b2ZzNF9zYmkoZGVudHJ5LT5kX3NiKTsKKwlzdHJ1Y3QgYXV0b2ZzX2luZm8gKmlubyA9IGF1dG9mczRfZGVudHJ5X2lubyhkZW50cnkpOworCWludCBzdGF0dXM7CisKKwlEUFJJTlRLKCJkZW50cnk9JXAgJS4qcyIsCisJCWRlbnRyeSwgZGVudHJ5LT5kX25hbWUubGVuLCBkZW50cnktPmRfbmFtZS5uYW1lKTsKKworCS8qCisJICogU29tZW9uZSBtYXkgaGF2ZSBtYW51YWxseSB1bW91bnRlZCB0aGlzIG9yIGl0IHdhcyBhIHN1Ym1vdW50CisJICogdGhhdCBoYXMgZ29uZSBhd2F5LgorCSAqLworCXNwaW5fbG9jaygmZGVudHJ5LT5kX2xvY2spOworCWlmICghZF9tb3VudHBvaW50KGRlbnRyeSkgJiYgbGlzdF9lbXB0eSgmZGVudHJ5LT5kX3N1YmRpcnMpKSB7CisJCWlmICghKGRlbnRyeS0+ZF9mbGFncyAmIERDQUNIRV9NQU5BR0VfVFJBTlNJVCkgJiYKKwkJICAgICAoZGVudHJ5LT5kX2ZsYWdzICYgRENBQ0hFX05FRURfQVVUT01PVU5UKSkKKwkJCV9fbWFuYWdlZF9kZW50cnlfc2V0X3RyYW5zaXQocGF0aC0+ZGVudHJ5KTsKKwl9CisJc3Bpbl91bmxvY2soJmRlbnRyeS0+ZF9sb2NrKTsKKworCS8qIFRoZSBkYWVtb24gbmV2ZXIgdHJpZ2dlcnMgYSBtb3VudC4gKi8KKwlpZiAoYXV0b2ZzNF9vel9tb2RlKHNiaSkpCisJCXJldHVybiBOVUxMOworCisJLyoKKwkgKiBJZiBhbiBleHBpcmUgcmVxdWVzdCBpcyBwZW5kaW5nIGV2ZXJ5b25lIG11c3Qgd2FpdC4KKwkgKiBJZiB0aGUgZXhwaXJlIGZhaWxzIHdlJ3JlIHN0aWxsIG1vdW50ZWQgc28gY29udGludWUKKwkgKiB0aGUgZm9sbG93IGFuZCByZXR1cm4uIEEgcmV0dXJuIG9mIC1FQUdBSU4gKHdoaWNoIG9ubHkKKwkgKiBoYXBwZW5zIHdpdGggaW5kaXJlY3QgbW91bnRzKSBtZWFucyB0aGUgZXhwaXJlIGNvbXBsZXRlZAorCSAqIGFuZCB0aGUgZGlyZWN0b3J5IHdhcyByZW1vdmVkLCBzbyBqdXN0IGdvIGFoZWFkIGFuZCB0cnkKKwkgKiB0aGUgbW91bnQuCisJICovCisJc3RhdHVzID0gZG9fZXhwaXJlX3dhaXQoZGVudHJ5KTsKKwlpZiAoc3RhdHVzICYmIHN0YXR1cyAhPSAtRUFHQUlOKQorCQlyZXR1cm4gTlVMTDsKKworCS8qIENhbGxiYWNrIHRvIHRoZSBkYWVtb24gdG8gcGVyZm9ybSB0aGUgbW91bnQgb3Igd2FpdCAqLworCXNwaW5fbG9jaygmc2JpLT5mc19sb2NrKTsKKwlpZiAoaW5vLT5mbGFncyAmIEFVVE9GU19JTkZfUEVORElORykgeworCQlzcGluX3VubG9jaygmc2JpLT5mc19sb2NrKTsKKwkJc3RhdHVzID0gYXV0b2ZzNF9tb3VudF93YWl0KGRlbnRyeSk7CisJCWlmIChzdGF0dXMpCisJCQlyZXR1cm4gRVJSX1BUUihzdGF0dXMpOworCQlzcGluX2xvY2soJnNiaS0+ZnNfbG9jayk7CisJCWdvdG8gZG9uZTsKKwl9CisKKwkvKgorCSAqIElmIHRoZSBkZW50cnkgaXMgYSBzeW1saW5rIGl0J3MgZXF1aXZhbGVudCB0byBhIGRpcmVjdG9yeQorCSAqIGhhdmluZyBkX21vdW50cG9pbnQoKSB0cnVlLCBzbyB0aGVyZSdzIG5vIG5lZWQgdG8gY2FsbCBiYWNrCisJICogdG8gdGhlIGRhZW1vbi4KKwkgKi8KKwlpZiAoZGVudHJ5LT5kX2lub2RlICYmIFNfSVNMTksoZGVudHJ5LT5kX2lub2RlLT5pX21vZGUpKQorCQlnb3RvIGRvbmU7CisJaWYgKCFkX21vdW50cG9pbnQoZGVudHJ5KSkgeworCQkvKgorCQkgKiBJdCdzIHBvc3NpYmxlIHRoYXQgdXNlciBzcGFjZSBoYXNuJ3QgcmVtb3ZlZCBkaXJlY3RvcmllcworCQkgKiBhZnRlciB1bW91bnRpbmcgYSByb290bGVzcyBtdWx0aS1tb3VudCwgYWx0aG91Z2ggaXQKKwkJICogc2hvdWxkLiBGb3IgdjUgaGF2ZV9zdWJtb3VudHMoKSBpcyBzdWZmaWNpZW50IHRvIGhhbmRsZQorCQkgKiB0aGlzIGJlY2F1c2UgdGhlIGxlYXZlcyBvZiB0aGUgZGlyZWN0b3J5IHRyZWUgdW5kZXIgdGhlCisJCSAqIG1vdW50IG5ldmVyIHRyaWdnZXIgbW91bnRzIHRoZW1zZWx2ZXMgKHRoZXkgaGF2ZSBhbiBhdXRvZnMKKwkJICogdHJpZ2dlciBtb3VudCBtb3VudGVkIG9uIHRoZW0pLiBCdXQgdjQgcHNldWRvIGRpcmVjdCBtb3VudHMKKwkJICogZG8gbmVlZCB0aGUgbGVhdmVzIHRvIHRvIHRyaWdnZXIgbW91bnRzLiBJbiB0aGlzIGNhc2Ugd2UKKwkJICogaGF2ZSBubyBjaG9pY2UgYnV0IHRvIHVzZSB0aGUgbGlzdF9lbXB0eSgpIGNoZWNrIGFuZAorCQkgKiByZXF1aXJlIHVzZXIgc3BhY2UgYmVoYXZlLgorCQkgKi8KKwkJaWYgKHNiaS0+dmVyc2lvbiA+IDQpIHsKKwkJCWlmIChoYXZlX3N1Ym1vdW50cyhkZW50cnkpKQorCQkJCWdvdG8gZG9uZTsKKwkJfSBlbHNlIHsKKwkJCXNwaW5fbG9jaygmZGVudHJ5LT5kX2xvY2spOworCQkJaWYgKCFsaXN0X2VtcHR5KCZkZW50cnktPmRfc3ViZGlycykpIHsKKwkJCQlzcGluX3VubG9jaygmZGVudHJ5LT5kX2xvY2spOworCQkJCWdvdG8gZG9uZTsKKwkJCX0KKwkJCXNwaW5fdW5sb2NrKCZkZW50cnktPmRfbG9jayk7CisJCX0KKwkJaW5vLT5mbGFncyB8PSBBVVRPRlNfSU5GX1BFTkRJTkc7CisJCXNwaW5fdW5sb2NrKCZzYmktPmZzX2xvY2spOworCQlzdGF0dXMgPSBhdXRvZnM0X21vdW50X3dhaXQoZGVudHJ5KTsKKwkJaWYgKHN0YXR1cykKKwkJCXJldHVybiBFUlJfUFRSKHN0YXR1cyk7CisJCXNwaW5fbG9jaygmc2JpLT5mc19sb2NrKTsKKwkJaW5vLT5mbGFncyAmPSB+QVVUT0ZTX0lORl9QRU5ESU5HOworCX0KK2RvbmU6CisJaWYgKCEoaW5vLT5mbGFncyAmIEFVVE9GU19JTkZfRVhQSVJJTkcpKSB7CisJCS8qCisJCSAqIEFueSBuZWVkZWQgbW91bnRpbmcgaGFzIGJlZW4gY29tcGxldGVkIGFuZCB0aGUgcGF0aCB1cGRhdGVkCisJCSAqIHNvIHR1cm4gdGhpcyBpbnRvIGEgbm9ybWFsIGRlbnRyeSBzbyB3ZSBkb24ndCBjb250aW51YWxseQorCQkgKiBjYWxsIC0+ZF9hdXRvbW91bnQoKSBhbmQgLT5kX21hbmFnZSgpLgorCQkgKi8KKwkJc3Bpbl9sb2NrKCZkZW50cnktPmRfbG9jayk7CisJCV9fbWFuYWdlZF9kZW50cnlfY2xlYXJfdHJhbnNpdChkZW50cnkpOworCQkvKgorCQkgKiBPbmx5IGNsZWFyIERNQU5BR0VEX0FVVE9NT1VOVCBmb3Igcm9vdGxlc3MgbXVsdGktbW91bnRzIGFuZAorCQkgKiBzeW1saW5rcyBhcyBpbiBhbGwgb3RoZXIgY2FzZXMgdGhlIGRlbnRyeSB3aWxsIGJlIGNvdmVyZWQgYnkKKwkJICogYW4gYWN0dWFsIG1vdW50IHNvIC0+ZF9hdXRvbW91bnQoKSB3b24ndCBiZSBjYWxsZWQgZHVyaW5nCisJCSAqIHRoZSBmb2xsb3cuCisJCSAqLworCQlpZiAoKCFkX21vdW50cG9pbnQoZGVudHJ5KSAmJgorCQkgICAgIWxpc3RfZW1wdHkoJmRlbnRyeS0+ZF9zdWJkaXJzKSkgfHwKKwkJICAgIChkZW50cnktPmRfaW5vZGUgJiYgU19JU0xOSyhkZW50cnktPmRfaW5vZGUtPmlfbW9kZSkpKQorCQkJX19tYW5hZ2VkX2RlbnRyeV9jbGVhcl9hdXRvbW91bnQoZGVudHJ5KTsKKwkJc3Bpbl91bmxvY2soJmRlbnRyeS0+ZF9sb2NrKTsKKwl9CisJc3Bpbl91bmxvY2soJnNiaS0+ZnNfbG9jayk7CisKKwkvKiBNb3VudCBzdWNjZWVkZWQsIGNoZWNrIGlmIHdlIGVuZGVkIHVwIHdpdGggYSBuZXcgZGVudHJ5ICovCisJZGVudHJ5ID0gYXV0b2ZzNF9tb3VudHBvaW50X2NoYW5nZWQocGF0aCk7CisJaWYgKCFkZW50cnkpCisJCXJldHVybiBFUlJfUFRSKC1FTk9FTlQpOworCisJcmV0dXJuIE5VTEw7Cit9CisKK2ludCBhdXRvZnM0X2RfbWFuYWdlKHN0cnVjdCBkZW50cnkgKmRlbnRyeSwgYm9vbCBtb3VudGluZ19oZXJlLCBib29sIHJjdV93YWxrKQoreworCXN0cnVjdCBhdXRvZnNfc2JfaW5mbyAqc2JpID0gYXV0b2ZzNF9zYmkoZGVudHJ5LT5kX3NiKTsKKworCURQUklOVEsoImRlbnRyeT0lcCAlLipzIiwKKwkJZGVudHJ5LCBkZW50cnktPmRfbmFtZS5sZW4sIGRlbnRyeS0+ZF9uYW1lLm5hbWUpOworCisJLyogVGhlIGRhZW1vbiBuZXZlciB3YWl0cy4gKi8KKwlpZiAoYXV0b2ZzNF9vel9tb2RlKHNiaSkgfHwgbW91bnRpbmdfaGVyZSkgeworCQlpZiAoIWRfbW91bnRwb2ludChkZW50cnkpKQorCQkJcmV0dXJuIC1FSVNESVI7CisJCXJldHVybiAwOworCX0KKworCS8qIFdlIG5lZWQgdG8gc2xlZXAsIHNvIHdlIG5lZWQgcGF0aHdhbGsgdG8gYmUgaW4gcmVmLW1vZGUgKi8KKwlpZiAocmN1X3dhbGspCisJCXJldHVybiAtRUNISUxEOworCisJLyogV2FpdCBmb3IgcGVuZGluZyBleHBpcmVzICovCisJZG9fZXhwaXJlX3dhaXQoZGVudHJ5KTsKKworCS8qCisJICogVGhpcyBkZW50cnkgbWF5IGJlIHVuZGVyIGNvbnN0cnVjdGlvbiBzbyB3YWl0IG9uIG1vdW50CisJICogY29tcGxldGlvbi4KKwkgKi8KKwlyZXR1cm4gYXV0b2ZzNF9tb3VudF93YWl0KGRlbnRyeSk7Cit9CisKIC8qIExvb2t1cHMgaW4gdGhlIHJvb3QgZGlyZWN0b3J5ICovCiBzdGF0aWMgc3RydWN0IGRlbnRyeSAqYXV0b2ZzNF9sb29rdXAoc3RydWN0IGlub2RlICpkaXIsIHN0cnVjdCBkZW50cnkgKmRlbnRyeSwgc3RydWN0IG5hbWVpZGF0YSAqbmQpCiB7CiAJc3RydWN0IGF1dG9mc19zYl9pbmZvICpzYmk7CiAJc3RydWN0IGF1dG9mc19pbmZvICppbm87Ci0Jc3RydWN0IGRlbnRyeSAqZXhwaXJpbmcsICphY3RpdmU7Ci0JaW50IG96X21vZGU7CisJc3RydWN0IGRlbnRyeSAqYWN0aXZlOwogCi0JRFBSSU5USygibmFtZSA9ICUuKnMiLAotCQlkZW50cnktPmRfbmFtZS5sZW4sIGRlbnRyeS0+ZF9uYW1lLm5hbWUpOworCURQUklOVEsoIm5hbWUgPSAlLipzIiwgZGVudHJ5LT5kX25hbWUubGVuLCBkZW50cnktPmRfbmFtZS5uYW1lKTsKIAogCS8qIEZpbGUgbmFtZSB0b28gbG9uZyB0byBleGlzdCAqLwogCWlmIChkZW50cnktPmRfbmFtZS5sZW4gPiBOQU1FX01BWCkKIAkJcmV0dXJuIEVSUl9QVFIoLUVOQU1FVE9PTE9ORyk7CiAKIAlzYmkgPSBhdXRvZnM0X3NiaShkaXItPmlfc2IpOwotCW96X21vZGUgPSBhdXRvZnM0X296X21vZGUoc2JpKTsKIAogCURQUklOVEsoInBpZCA9ICV1LCBwZ3JwID0gJXUsIGNhdGF0b25pYyA9ICVkLCBvel9tb2RlID0gJWQiLAotCQkgY3VycmVudC0+cGlkLCB0YXNrX3BncnBfbnIoY3VycmVudCksIHNiaS0+Y2F0YXRvbmljLCBvel9tb2RlKTsKKwkJY3VycmVudC0+cGlkLCB0YXNrX3BncnBfbnIoY3VycmVudCksIHNiaS0+Y2F0YXRvbmljLAorCQlhdXRvZnM0X296X21vZGUoc2JpKSk7CiAKIAlhY3RpdmUgPSBhdXRvZnM0X2xvb2t1cF9hY3RpdmUoZGVudHJ5KTsKIAlpZiAoYWN0aXZlKSB7Ci0JCWRlbnRyeSA9IGFjdGl2ZTsKLQkJaW5vID0gYXV0b2ZzNF9kZW50cnlfaW5vKGRlbnRyeSk7CisJCXJldHVybiBhY3RpdmU7CiAJfSBlbHNlIHsKIAkJLyoKLQkJICogTWFyayB0aGUgZGVudHJ5IGluY29tcGxldGUgYnV0IGRvbid0IGhhc2ggaXQuIFdlIGRvIHRoaXMKLQkJICogdG8gc2VyaWFsaXplIG91ciBpbm9kZSBjcmVhdGlvbiBvcGVyYXRpb25zIChzeW1saW5rIGFuZAotCQkgKiBta2Rpcikgd2hpY2ggcHJldmVudHMgZGVhZGxvY2sgZHVyaW5nIHRoZSBjYWxsYmFjayB0bwotCQkgKiB0aGUgZGFlbW9uLiBTdWJzZXF1ZW50IHVzZXIgc3BhY2UgbG9va3VwcyBmb3IgdGhlIHNhbWUKLQkJICogZGVudHJ5IGFyZSBwbGFjZWQgb24gdGhlIHdhaXQgcXVldWUgd2hpbGUgdGhlIGRhZW1vbgotCQkgKiBpdHNlbGYgaXMgYWxsb3dlZCBwYXNzYWdlIHVucmVzdGljdGVkIHNvIHRoZSBjcmVhdGUKLQkJICogb3BlcmF0aW9uIGl0c2VsZiBjYW4gdGhlbiBoYXNoIHRoZSBkZW50cnkuIEZpbmFsbHksCi0JCSAqIHdlIGNoZWNrIGZvciB0aGUgaGFzaGVkIGRlbnRyeSBhbmQgcmV0dXJuIHRoZSBuZXdseQotCQkgKiBoYXNoZWQgZGVudHJ5LgorCQkgKiBBIGRlbnRyeSB0aGF0IGlzIG5vdCB3aXRoaW4gdGhlIHJvb3QgY2FuIG5ldmVyIHRyaWdnZXIgYQorCQkgKiBtb3VudCBvcGVyYXRpb24sIHVubGVzcyB0aGUgZGlyZWN0b3J5IGFscmVhZHkgZXhpc3RzLCBzbyB3ZQorCQkgKiBjYW4gcmV0dXJuIGZhaWwgaW1tZWRpYXRlbHkuICBUaGUgZGFlbW9uIGhvd2V2ZXIgZG9lcyBuZWVkCisJCSAqIHRvIGNyZWF0ZSBkaXJlY3RvcmllcyB3aXRoaW4gdGhlIGZpbGUgc3lzdGVtLgogCQkgKi8KLQkJZF9zZXRfZF9vcChkZW50cnksICZhdXRvZnM0X3Jvb3RfZGVudHJ5X29wZXJhdGlvbnMpOworCQlpZiAoIWF1dG9mczRfb3pfbW9kZShzYmkpICYmICFJU19ST09UKGRlbnRyeS0+ZF9wYXJlbnQpKQorCQkJcmV0dXJuIEVSUl9QVFIoLUVOT0VOVCk7CiAKLQkJLyoKLQkJICogQW5kIHdlIG5lZWQgdG8gZW5zdXJlIHRoYXQgdGhlIHNhbWUgZGVudHJ5IGlzIHVzZWQgZm9yCi0JCSAqIGFsbCBmb2xsb3dpbmcgbG9va3VwIGNhbGxzIHVudGlsIGl0IGlzIGhhc2hlZCBzbyB0aGF0Ci0JCSAqIHRoZSBkZW50cnkgZmxhZ3MgYXJlIHBlcnNpc3RlbnQgdGhyb3VnaG91dCB0aGUgcmVxdWVzdC4KLQkJICovCi0JCWlubyA9IGF1dG9mczRfaW5pdF9pbm8oTlVMTCwgc2JpLCAwNTU1KTsKKwkJLyogTWFyayBlbnRyaWVzIGluIHRoZSByb290IGFzIG1vdW50IHRyaWdnZXJzICovCisJCWlmIChhdXRvZnNfdHlwZV9pbmRpcmVjdChzYmktPnR5cGUpICYmIElTX1JPT1QoZGVudHJ5LT5kX3BhcmVudCkpCisJCQlfX21hbmFnZWRfZGVudHJ5X3NldF9tYW5hZ2VkKGRlbnRyeSk7CisKKwkJaW5vID0gYXV0b2ZzNF9uZXdfaW5vKHNiaSk7CiAJCWlmICghaW5vKQogCQkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CiAKQEAgLTU5Niw4MiArNTIxLDYgQEAKIAogCQlkX2luc3RhbnRpYXRlKGRlbnRyeSwgTlVMTCk7CiAJfQotCi0JaWYgKCFvel9tb2RlKSB7Ci0JCW11dGV4X3VubG9jaygmZGlyLT5pX211dGV4KTsKLQkJZXhwaXJpbmcgPSBhdXRvZnM0X2xvb2t1cF9leHBpcmluZyhkZW50cnkpOwotCQlpZiAoZXhwaXJpbmcpIHsKLQkJCS8qCi0JCQkgKiBJZiB3ZSBhcmUgcmFjaW5nIHdpdGggZXhwaXJlIHRoZSByZXF1ZXN0IG1pZ2h0IG5vdAotCQkJICogYmUgcXVpdGUgY29tcGxldGUgYnV0IHRoZSBkaXJlY3RvcnkgaGFzIGJlZW4gcmVtb3ZlZAotCQkJICogc28gaXQgbXVzdCBoYXZlIGJlZW4gc3VjY2Vzc2Z1bCwgc28ganVzdCB3YWl0IGZvciBpdC4KLQkJCSAqLwotCQkJYXV0b2ZzNF9leHBpcmVfd2FpdChleHBpcmluZyk7Ci0JCQlhdXRvZnM0X2RlbF9leHBpcmluZyhleHBpcmluZyk7Ci0JCQlkcHV0KGV4cGlyaW5nKTsKLQkJfQotCi0JCXNwaW5fbG9jaygmc2JpLT5mc19sb2NrKTsKLQkJaW5vLT5mbGFncyB8PSBBVVRPRlNfSU5GX1BFTkRJTkc7Ci0JCXNwaW5fdW5sb2NrKCZzYmktPmZzX2xvY2spOwotCQlpZiAoZGVudHJ5LT5kX29wICYmIGRlbnRyeS0+ZF9vcC0+ZF9yZXZhbGlkYXRlKQotCQkJKGRlbnRyeS0+ZF9vcC0+ZF9yZXZhbGlkYXRlKShkZW50cnksIG5kKTsKLQkJbXV0ZXhfbG9jaygmZGlyLT5pX211dGV4KTsKLQl9Ci0KLQkvKgotCSAqIElmIHdlIGFyZSBzdGlsbCBwZW5kaW5nLCBjaGVjayBpZiB3ZSBoYWQgdG8gaGFuZGxlCi0JICogYSBzaWduYWwuIElmIHNvIHdlIGNhbiBmb3JjZSBhIHJlc3RhcnQuLgotCSAqLwotCWlmIChpbm8tPmZsYWdzICYgQVVUT0ZTX0lORl9QRU5ESU5HKSB7Ci0JCS8qIFNlZSBpZiB3ZSB3ZXJlIGludGVycnVwdGVkICovCi0JCWlmIChzaWduYWxfcGVuZGluZyhjdXJyZW50KSkgewotCQkJc2lnc2V0X3QgKnNpZ3NldCA9ICZjdXJyZW50LT5wZW5kaW5nLnNpZ25hbDsKLQkJCWlmIChzaWdpc21lbWJlciAoc2lnc2V0LCBTSUdLSUxMKSB8fAotCQkJICAgIHNpZ2lzbWVtYmVyIChzaWdzZXQsIFNJR1FVSVQpIHx8Ci0JCQkgICAgc2lnaXNtZW1iZXIgKHNpZ3NldCwgU0lHSU5UKSkgewotCQkJICAgIGlmIChhY3RpdmUpCi0JCQkJZHB1dChhY3RpdmUpOwotCQkJICAgIHJldHVybiBFUlJfUFRSKC1FUkVTVEFSVE5PSU5UUik7Ci0JCQl9Ci0JCX0KLQkJaWYgKCFvel9tb2RlKSB7Ci0JCQlzcGluX2xvY2soJnNiaS0+ZnNfbG9jayk7Ci0JCQlpbm8tPmZsYWdzICY9IH5BVVRPRlNfSU5GX1BFTkRJTkc7Ci0JCQlzcGluX3VubG9jaygmc2JpLT5mc19sb2NrKTsKLQkJfQotCX0KLQotCS8qCi0JICogSWYgdGhpcyBkZW50cnkgaXMgdW5oYXNoZWQsIHRoZW4gd2Ugc2hvdWxkbid0IGhvbm91ciB0aGlzCi0JICogbG9va3VwLiAgUmV0dXJuaW5nIEVOT0VOVCBoZXJlIGRvZXNuJ3QgZG8gdGhlIHJpZ2h0IHRoaW5nCi0JICogZm9yIGFsbCBzeXN0ZW0gY2FsbHMsIGJ1dCBpdCBzaG91bGQgYmUgT0sgZm9yIHRoZSBvcGVyYXRpb25zCi0JICogd2UgcGVybWl0IGZyb20gYW4gYXV0b2ZzLgotCSAqLwotCWlmICghb3pfbW9kZSAmJiBkX3VuaGFzaGVkKGRlbnRyeSkpIHsKLQkJLyoKLQkJICogQSB1c2VyIHNwYWNlIGFwcGxpY2F0aW9uIGNhbiAoYW5kIGhhcyBkb25lIGluIHRoZSBwYXN0KQotCQkgKiByZW1vdmUgYW5kIHJlLWNyZWF0ZSB0aGlzIGRpcmVjdG9yeSBkdXJpbmcgdGhlIGNhbGxiYWNrLgotCQkgKiBUaGlzIGNhbiBsZWF2ZSB1cyB3aXRoIGFuIHVuaGFzaGVkIGRlbnRyeSwgYnV0IGEKLQkJICogc3VjY2Vzc2Z1bCBtb3VudCEgIFNvIHdlIG5lZWQgdG8gcGVyZm9ybSBhbm90aGVyCi0JCSAqIGNhY2hlZCBsb29rdXAgaW4gY2FzZSB0aGUgZGVudHJ5IG5vdyBleGlzdHMuCi0JCSAqLwotCQlzdHJ1Y3QgZGVudHJ5ICpwYXJlbnQgPSBkZW50cnktPmRfcGFyZW50OwotCQlzdHJ1Y3QgZGVudHJ5ICpuZXcgPSBkX2xvb2t1cChwYXJlbnQsICZkZW50cnktPmRfbmFtZSk7Ci0JCWlmIChuZXcgIT0gTlVMTCkKLQkJCWRlbnRyeSA9IG5ldzsKLQkJZWxzZQotCQkJZGVudHJ5ID0gRVJSX1BUUigtRU5PRU5UKTsKLQotCQlpZiAoYWN0aXZlKQotCQkJZHB1dChhY3RpdmUpOwotCi0JCXJldHVybiBkZW50cnk7Ci0JfQotCi0JaWYgKGFjdGl2ZSkKLQkJcmV0dXJuIGFjdGl2ZTsKLQogCXJldHVybiBOVUxMOwogfQogCkBAIC02ODMsNiArNTMyLDcgQEAKIAlzdHJ1Y3QgYXV0b2ZzX2luZm8gKmlubyA9IGF1dG9mczRfZGVudHJ5X2lubyhkZW50cnkpOwogCXN0cnVjdCBhdXRvZnNfaW5mbyAqcF9pbm87CiAJc3RydWN0IGlub2RlICppbm9kZTsKKwlzaXplX3Qgc2l6ZSA9IHN0cmxlbihzeW1uYW1lKTsKIAljaGFyICpjcDsKIAogCURQUklOVEsoIiVzIDwtICUuKnMiLCBzeW1uYW1lLApAQCAtNjkxLDQ1ICs1NDEsMzUgQEAKIAlpZiAoIWF1dG9mczRfb3pfbW9kZShzYmkpKQogCQlyZXR1cm4gLUVBQ0NFUzsKIAotCWlubyA9IGF1dG9mczRfaW5pdF9pbm8oaW5vLCBzYmksIFNfSUZMTksgfCAwNTU1KTsKLQlpZiAoIWlubykKLQkJcmV0dXJuIC1FTk9NRU07CisJQlVHX09OKCFpbm8pOworCisJYXV0b2ZzNF9jbGVhbl9pbm8oaW5vKTsKIAogCWF1dG9mczRfZGVsX2FjdGl2ZShkZW50cnkpOwogCi0JaW5vLT5zaXplID0gc3RybGVuKHN5bW5hbWUpOwotCWNwID0ga21hbGxvYyhpbm8tPnNpemUgKyAxLCBHRlBfS0VSTkVMKTsKLQlpZiAoIWNwKSB7Ci0JCWlmICghZGVudHJ5LT5kX2ZzZGF0YSkKLQkJCWtmcmVlKGlubyk7CisJY3AgPSBrbWFsbG9jKHNpemUgKyAxLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWNwKQogCQlyZXR1cm4gLUVOT01FTTsKLQl9CiAKIAlzdHJjcHkoY3AsIHN5bW5hbWUpOwogCi0JaW5vZGUgPSBhdXRvZnM0X2dldF9pbm9kZShkaXItPmlfc2IsIGlubyk7CisJaW5vZGUgPSBhdXRvZnM0X2dldF9pbm9kZShkaXItPmlfc2IsIFNfSUZMTksgfCAwNTU1KTsKIAlpZiAoIWlub2RlKSB7CiAJCWtmcmVlKGNwKTsKIAkJaWYgKCFkZW50cnktPmRfZnNkYXRhKQogCQkJa2ZyZWUoaW5vKTsKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQorCWlub2RlLT5pX3ByaXZhdGUgPSBjcDsKKwlpbm9kZS0+aV9zaXplID0gc2l6ZTsKIAlkX2FkZChkZW50cnksIGlub2RlKTsKIAotCWlmIChkaXIgPT0gZGlyLT5pX3NiLT5zX3Jvb3QtPmRfaW5vZGUpCi0JCWRfc2V0X2Rfb3AoZGVudHJ5LCAmYXV0b2ZzNF9yb290X2RlbnRyeV9vcGVyYXRpb25zKTsKLQllbHNlCi0JCWRfc2V0X2Rfb3AoZGVudHJ5LCAmYXV0b2ZzNF9kZW50cnlfb3BlcmF0aW9ucyk7Ci0KLQlkZW50cnktPmRfZnNkYXRhID0gaW5vOwotCWluby0+ZGVudHJ5ID0gZGdldChkZW50cnkpOworCWRnZXQoZGVudHJ5KTsKIAlhdG9taWNfaW5jKCZpbm8tPmNvdW50KTsKIAlwX2lubyA9IGF1dG9mczRfZGVudHJ5X2lubyhkZW50cnktPmRfcGFyZW50KTsKIAlpZiAocF9pbm8gJiYgZGVudHJ5LT5kX3BhcmVudCAhPSBkZW50cnkpCiAJCWF0b21pY19pbmMoJnBfaW5vLT5jb3VudCk7Ci0JaW5vLT5pbm9kZSA9IGlub2RlOwogCi0JaW5vLT51LnN5bWxpbmsgPSBjcDsKIAlkaXItPmlfbXRpbWUgPSBDVVJSRU5UX1RJTUU7CiAKIAlyZXR1cm4gMDsKQEAgLTc4Miw2ICs2MjIsNTggQEAKIAlyZXR1cm4gMDsKIH0KIAorLyoKKyAqIFZlcnNpb24gNCBvZiBhdXRvZnMgcHJvdmlkZXMgYSBwc2V1ZG8gZGlyZWN0IG1vdW50IGltcGxlbWVudGF0aW9uCisgKiB0aGF0IHJlbGllcyBvbiBkaXJlY3RvcmllcyBhdCB0aGUgbGVhdmVzIG9mIGEgZGlyZWN0b3J5IHRyZWUgdW5kZXIKKyAqIGFuIGluZGlyZWN0IG1vdW50IHRvIHRyaWdnZXIgbW91bnRzLiBUbyBhbGxvdyBmb3IgdGhpcyB3ZSBuZWVkIHRvCisgKiBzZXQgdGhlIERNQU5BR0VEX0FVVE9NT1VOVCBhbmQgRE1BTkFHRURfVFJBTlNJVCBmbGFncyBvbiB0aGUgbGVhdmVzCisgKiBvZiB0aGUgZGlyZWN0b3J5IHRyZWUuIFRoZXJlIGlzIG5vIG5lZWQgdG8gY2xlYXIgdGhlIGF1dG9tb3VudCBmbGFnCisgKiBmb2xsb3dpbmcgYSBtb3VudCBvciByZXN0b3JlIGl0IGFmdGVyIGFuIGV4cGlyZSBiZWNhdXNlIHRoZXNlIG1vdW50cworICogYXJlIGFsd2F5cyBjb3ZlcmVkLiBIb3dldmVyLCBpdCBpcyBuZWNjZXNzYXJ5IHRvIGVuc3VyZSB0aGF0IHRoZXNlCisgKiBmbGFncyBhcmUgY2xlYXIgb24gbm9uLWVtcHR5IGRpcmVjdG9yaWVzIHRvIGF2b2lkIHVubmVjZXNzYXJ5IGNhbGxzCisgKiBkdXJpbmcgcGF0aCB3YWxrcy4KKyAqLworc3RhdGljIHZvaWQgYXV0b2ZzX3NldF9sZWFmX2F1dG9tb3VudF9mbGFncyhzdHJ1Y3QgZGVudHJ5ICpkZW50cnkpCit7CisJc3RydWN0IGRlbnRyeSAqcGFyZW50OworCisJLyogcm9vdCBhbmQgZGVudHJ5cyBpbiB0aGUgcm9vdCBhcmUgYWxyZWFkeSBoYW5kbGVkICovCisJaWYgKElTX1JPT1QoZGVudHJ5LT5kX3BhcmVudCkpCisJCXJldHVybjsKKworCW1hbmFnZWRfZGVudHJ5X3NldF9tYW5hZ2VkKGRlbnRyeSk7CisKKwlwYXJlbnQgPSBkZW50cnktPmRfcGFyZW50OworCS8qIG9ubHkgY29uc2lkZXIgcGFyZW50cyBiZWxvdyBkZW50cnlzIGluIHRoZSByb290ICovCisJaWYgKElTX1JPT1QocGFyZW50LT5kX3BhcmVudCkpCisJCXJldHVybjsKKwltYW5hZ2VkX2RlbnRyeV9jbGVhcl9tYW5hZ2VkKHBhcmVudCk7CisJcmV0dXJuOworfQorCitzdGF0aWMgdm9pZCBhdXRvZnNfY2xlYXJfbGVhZl9hdXRvbW91bnRfZmxhZ3Moc3RydWN0IGRlbnRyeSAqZGVudHJ5KQoreworCXN0cnVjdCBsaXN0X2hlYWQgKmRfY2hpbGQ7CisJc3RydWN0IGRlbnRyeSAqcGFyZW50OworCisJLyogZmxhZ3MgZm9yIGRlbnRyeXMgaW4gdGhlIHJvb3QgYXJlIGhhbmRsZWQgZWxzZXdoZXJlICovCisJaWYgKElTX1JPT1QoZGVudHJ5LT5kX3BhcmVudCkpCisJCXJldHVybjsKKworCW1hbmFnZWRfZGVudHJ5X2NsZWFyX21hbmFnZWQoZGVudHJ5KTsKKworCXBhcmVudCA9IGRlbnRyeS0+ZF9wYXJlbnQ7CisJLyogb25seSBjb25zaWRlciBwYXJlbnRzIGJlbG93IGRlbnRyeXMgaW4gdGhlIHJvb3QgKi8KKwlpZiAoSVNfUk9PVChwYXJlbnQtPmRfcGFyZW50KSkKKwkJcmV0dXJuOworCWRfY2hpbGQgPSAmZGVudHJ5LT5kX3UuZF9jaGlsZDsKKwkvKiBTZXQgcGFyZW50IG1hbmFnZWQgaWYgaXQncyBiZWNvbWluZyBlbXB0eSAqLworCWlmIChkX2NoaWxkLT5uZXh0ID09ICZwYXJlbnQtPmRfc3ViZGlycyAmJgorCSAgICBkX2NoaWxkLT5wcmV2ID09ICZwYXJlbnQtPmRfc3ViZGlycykKKwkJbWFuYWdlZF9kZW50cnlfc2V0X21hbmFnZWQocGFyZW50KTsKKwlyZXR1cm47Cit9CisKIHN0YXRpYyBpbnQgYXV0b2ZzNF9kaXJfcm1kaXIoc3RydWN0IGlub2RlICpkaXIsIHN0cnVjdCBkZW50cnkgKmRlbnRyeSkKIHsKIAlzdHJ1Y3QgYXV0b2ZzX3NiX2luZm8gKnNiaSA9IGF1dG9mczRfc2JpKGRpci0+aV9zYik7CkBAIC04MDksNiArNzAxLDkgQEAKIAlzcGluX3VubG9jaygmZGVudHJ5LT5kX2xvY2spOwogCXNwaW5fdW5sb2NrKCZhdXRvZnM0X2xvY2spOwogCisJaWYgKHNiaS0+dmVyc2lvbiA8IDUpCisJCWF1dG9mc19jbGVhcl9sZWFmX2F1dG9tb3VudF9mbGFncyhkZW50cnkpOworCiAJaWYgKGF0b21pY19kZWNfYW5kX3Rlc3QoJmluby0+Y291bnQpKSB7CiAJCXBfaW5vID0gYXV0b2ZzNF9kZW50cnlfaW5vKGRlbnRyeS0+ZF9wYXJlbnQpOwogCQlpZiAocF9pbm8gJiYgZGVudHJ5LT5kX3BhcmVudCAhPSBkZW50cnkpCkBAIC04MzcsMzIgKzczMiwyNSBAQAogCURQUklOVEsoImRlbnRyeSAlcCwgY3JlYXRpbmcgJS4qcyIsCiAJCWRlbnRyeSwgZGVudHJ5LT5kX25hbWUubGVuLCBkZW50cnktPmRfbmFtZS5uYW1lKTsKIAotCWlubyA9IGF1dG9mczRfaW5pdF9pbm8oaW5vLCBzYmksIFNfSUZESVIgfCAwNTU1KTsKLQlpZiAoIWlubykKLQkJcmV0dXJuIC1FTk9NRU07CisJQlVHX09OKCFpbm8pOworCisJYXV0b2ZzNF9jbGVhbl9pbm8oaW5vKTsKIAogCWF1dG9mczRfZGVsX2FjdGl2ZShkZW50cnkpOwogCi0JaW5vZGUgPSBhdXRvZnM0X2dldF9pbm9kZShkaXItPmlfc2IsIGlubyk7Ci0JaWYgKCFpbm9kZSkgewotCQlpZiAoIWRlbnRyeS0+ZF9mc2RhdGEpCi0JCQlrZnJlZShpbm8pOworCWlub2RlID0gYXV0b2ZzNF9nZXRfaW5vZGUoZGlyLT5pX3NiLCBTX0lGRElSIHwgMDU1NSk7CisJaWYgKCFpbm9kZSkKIAkJcmV0dXJuIC1FTk9NRU07Ci0JfQogCWRfYWRkKGRlbnRyeSwgaW5vZGUpOwogCi0JaWYgKGRpciA9PSBkaXItPmlfc2ItPnNfcm9vdC0+ZF9pbm9kZSkKLQkJZF9zZXRfZF9vcChkZW50cnksICZhdXRvZnM0X3Jvb3RfZGVudHJ5X29wZXJhdGlvbnMpOwotCWVsc2UKLQkJZF9zZXRfZF9vcChkZW50cnksICZhdXRvZnM0X2RlbnRyeV9vcGVyYXRpb25zKTsKKwlpZiAoc2JpLT52ZXJzaW9uIDwgNSkKKwkJYXV0b2ZzX3NldF9sZWFmX2F1dG9tb3VudF9mbGFncyhkZW50cnkpOwogCi0JZGVudHJ5LT5kX2ZzZGF0YSA9IGlubzsKLQlpbm8tPmRlbnRyeSA9IGRnZXQoZGVudHJ5KTsKKwlkZ2V0KGRlbnRyeSk7CiAJYXRvbWljX2luYygmaW5vLT5jb3VudCk7CiAJcF9pbm8gPSBhdXRvZnM0X2RlbnRyeV9pbm8oZGVudHJ5LT5kX3BhcmVudCk7CiAJaWYgKHBfaW5vICYmIGRlbnRyeS0+ZF9wYXJlbnQgIT0gZGVudHJ5KQogCQlhdG9taWNfaW5jKCZwX2luby0+Y291bnQpOwotCWluby0+aW5vZGUgPSBpbm9kZTsKIAlpbmNfbmxpbmsoZGlyKTsKIAlkaXItPmlfbXRpbWUgPSBDVVJSRU5UX1RJTUU7CiAKQEAgLTk0NCw4ICs4MzIsNyBAQAogaW50IGlzX2F1dG9mczRfZGVudHJ5KHN0cnVjdCBkZW50cnkgKmRlbnRyeSkKIHsKIAlyZXR1cm4gZGVudHJ5ICYmIGRlbnRyeS0+ZF9pbm9kZSAmJgotCQkoZGVudHJ5LT5kX29wID09ICZhdXRvZnM0X3Jvb3RfZGVudHJ5X29wZXJhdGlvbnMgfHwKLQkJIGRlbnRyeS0+ZF9vcCA9PSAmYXV0b2ZzNF9kZW50cnlfb3BlcmF0aW9ucykgJiYKKwkJZGVudHJ5LT5kX29wID09ICZhdXRvZnM0X2RlbnRyeV9vcGVyYXRpb25zICYmCiAJCWRlbnRyeS0+ZF9mc2RhdGEgIT0gTlVMTDsKIH0KIApkaWZmIC0tZ2l0IGEvZnMvYXV0b2ZzNC9zeW1saW5rLmMgYi9mcy9hdXRvZnM0L3N5bWxpbmsuYwppbmRleCBiNGVhODI5Li5mMjdjMDk0IDEwMDY0NAotLS0gYS9mcy9hdXRvZnM0L3N5bWxpbmsuYworKysgYi9mcy9hdXRvZnM0L3N5bWxpbmsuYwpAQCAtMTQsOCArMTQsNyBAQAogCiBzdGF0aWMgdm9pZCAqYXV0b2ZzNF9mb2xsb3dfbGluayhzdHJ1Y3QgZGVudHJ5ICpkZW50cnksIHN0cnVjdCBuYW1laWRhdGEgKm5kKQogewotCXN0cnVjdCBhdXRvZnNfaW5mbyAqaW5vID0gYXV0b2ZzNF9kZW50cnlfaW5vKGRlbnRyeSk7Ci0JbmRfc2V0X2xpbmsobmQsIChjaGFyICopaW5vLT51LnN5bWxpbmspOworCW5kX3NldF9saW5rKG5kLCBkZW50cnktPmRfaW5vZGUtPmlfcHJpdmF0ZSk7CiAJcmV0dXJuIE5VTEw7CiB9CiAKZGlmZiAtLWdpdCBhL2ZzL2F1dG9mczQvd2FpdHEuYyBiL2ZzL2F1dG9mczQvd2FpdHEuYwppbmRleCBjNWY4NDU5Li41NjAxMDA1IDEwMDY0NAotLS0gYS9mcy9hdXRvZnM0L3dhaXRxLmMKKysrIGIvZnMvYXV0b2ZzNC93YWl0cS5jCkBAIC0zMDksNiArMzA5LDkgQEAKIAkgKiBjb21wbGV0ZWQgd2hpbGUgd2Ugd2FpdGVkIG9uIHRoZSBtdXRleCAuLi4KIAkgKi8KIAlpZiAobm90aWZ5ID09IE5GWV9NT1VOVCkgeworCQlzdHJ1Y3QgZGVudHJ5ICpuZXcgPSBOVUxMOworCQlpbnQgdmFsaWQgPSAxOworCiAJCS8qCiAJCSAqIElmIHRoZSBkZW50cnkgd2FzIHN1Y2Nlc3NmdWxseSBtb3VudGVkIHdoaWxlIHdlIHNsZXB0CiAJCSAqIG9uIHRoZSB3YWl0IHF1ZXVlIG11dGV4IHdlIGNhbiByZXR1cm4gc3VjY2Vzcy4gSWYgaXQKQEAgLTMxNiw4ICszMTksMjAgQEAKIAkJICogYSBtdWx0aS1tb3VudCB3aXRoIG5vIG1vdW50IGF0IGl0J3MgYmFzZSkgd2UgY2FuCiAJCSAqIGNvbnRpbnVlIG9uIGFuZCBjcmVhdGUgYSBuZXcgcmVxdWVzdC4KIAkJICovCisJCWlmICghSVNfUk9PVChkZW50cnkpKSB7CisJCQlpZiAoZGVudHJ5LT5kX2lub2RlICYmIGRfdW5oYXNoZWQoZGVudHJ5KSkgeworCQkJCXN0cnVjdCBkZW50cnkgKnBhcmVudCA9IGRlbnRyeS0+ZF9wYXJlbnQ7CisJCQkJbmV3ID0gZF9sb29rdXAocGFyZW50LCAmZGVudHJ5LT5kX25hbWUpOworCQkJCWlmIChuZXcpCisJCQkJCWRlbnRyeSA9IG5ldzsKKwkJCX0KKwkJfQogCQlpZiAoaGF2ZV9zdWJtb3VudHMoZGVudHJ5KSkKLQkJCXJldHVybiAwOworCQkJdmFsaWQgPSAwOworCisJCWlmIChuZXcpCisJCQlkcHV0KG5ldyk7CisJCXJldHVybiB2YWxpZDsKIAl9CiAKIAlyZXR1cm4gMTsKZGlmZiAtLWdpdCBhL2ZzL2Jsb2NrX2Rldi5jIGIvZnMvYmxvY2tfZGV2LmMKaW5kZXggZmUzZjU5YzEuLjMzM2E3YmIgMTAwNjQ0Ci0tLSBhL2ZzL2Jsb2NrX2Rldi5jCisrKyBiL2ZzL2Jsb2NrX2Rldi5jCkBAIC00MzIsNiArNDMyLDkgQEAKIAltdXRleF9pbml0KCZiZGV2LT5iZF9tdXRleCk7CiAJSU5JVF9MSVNUX0hFQUQoJmJkZXYtPmJkX2lub2Rlcyk7CiAJSU5JVF9MSVNUX0hFQUQoJmJkZXYtPmJkX2xpc3QpOworI2lmZGVmIENPTkZJR19TWVNGUworCUlOSVRfTElTVF9IRUFEKCZiZGV2LT5iZF9ob2xkZXJfZGlza3MpOworI2VuZGlmCiAJaW5vZGVfaW5pdF9vbmNlKCZlaS0+dmZzX2lub2RlKTsKIAkvKiBJbml0aWFsaXplIG11dGV4IGZvciBmcmVlemUuICovCiAJbXV0ZXhfaW5pdCgmYmRldi0+YmRfZnNmcmVlemVfbXV0ZXgpOwpAQCAtNzc5LDYgKzc4MiwyMyBAQAogfQogCiAjaWZkZWYgQ09ORklHX1NZU0ZTCitzdHJ1Y3QgYmRfaG9sZGVyX2Rpc2sgeworCXN0cnVjdCBsaXN0X2hlYWQJbGlzdDsKKwlzdHJ1Y3QgZ2VuZGlzawkJKmRpc2s7CisJaW50CQkJcmVmY250OworfTsKKworc3RhdGljIHN0cnVjdCBiZF9ob2xkZXJfZGlzayAqYmRfZmluZF9ob2xkZXJfZGlzayhzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LAorCQkJCQkJICBzdHJ1Y3QgZ2VuZGlzayAqZGlzaykKK3sKKwlzdHJ1Y3QgYmRfaG9sZGVyX2Rpc2sgKmhvbGRlcjsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkoaG9sZGVyLCAmYmRldi0+YmRfaG9sZGVyX2Rpc2tzLCBsaXN0KQorCQlpZiAoaG9sZGVyLT5kaXNrID09IGRpc2spCisJCQlyZXR1cm4gaG9sZGVyOworCXJldHVybiBOVUxMOworfQorCiBzdGF0aWMgaW50IGFkZF9zeW1saW5rKHN0cnVjdCBrb2JqZWN0ICpmcm9tLCBzdHJ1Y3Qga29iamVjdCAqdG8pCiB7CiAJcmV0dXJuIHN5c2ZzX2NyZWF0ZV9saW5rKGZyb20sIHRvLCBrb2JqZWN0X25hbWUodG8pKTsKQEAgLTc5NCw2ICs4MTQsOCBAQAogICogQGJkZXY6IHRoZSBjbGFpbWVkIHNsYXZlIGJkZXYKICAqIEBkaXNrOiB0aGUgaG9sZGluZyBkaXNrCiAgKgorICogRE9OJ1QgVVNFIFRISVMgVU5MRVNTIFlPVSdSRSBBTFJFQURZIFVTSU5HIElULgorICoKICAqIFRoaXMgZnVuY3Rpb25zIGNyZWF0ZXMgdGhlIGZvbGxvd2luZyBzeXNmcyBzeW1saW5rcy4KICAqCiAgKiAtIGZyb20gInNsYXZlcyIgZGlyZWN0b3J5IG9mIHRoZSBob2xkZXIgQGRpc2sgdG8gdGhlIGNsYWltZWQgQGJkZXYKQEAgLTgxNyw0NyArODM5LDgzIEBACiAgKi8KIGludCBiZF9saW5rX2Rpc2tfaG9sZGVyKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsIHN0cnVjdCBnZW5kaXNrICpkaXNrKQogeworCXN0cnVjdCBiZF9ob2xkZXJfZGlzayAqaG9sZGVyOwogCWludCByZXQgPSAwOwogCiAJbXV0ZXhfbG9jaygmYmRldi0+YmRfbXV0ZXgpOwogCi0JV0FSTl9PTl9PTkNFKCFiZGV2LT5iZF9ob2xkZXIgfHwgYmRldi0+YmRfaG9sZGVyX2Rpc2spOworCVdBUk5fT05fT05DRSghYmRldi0+YmRfaG9sZGVyKTsKIAogCS8qIEZJWE1FOiByZW1vdmUgdGhlIGZvbGxvd2luZyBvbmNlIGFkZF9kaXNrKCkgaGFuZGxlcyBlcnJvcnMgKi8KIAlpZiAoV0FSTl9PTighZGlzay0+c2xhdmVfZGlyIHx8ICFiZGV2LT5iZF9wYXJ0LT5ob2xkZXJfZGlyKSkKIAkJZ290byBvdXRfdW5sb2NrOwogCi0JcmV0ID0gYWRkX3N5bWxpbmsoZGlzay0+c2xhdmVfZGlyLCAmcGFydF90b19kZXYoYmRldi0+YmRfcGFydCktPmtvYmopOwotCWlmIChyZXQpCi0JCWdvdG8gb3V0X3VubG9jazsKLQotCXJldCA9IGFkZF9zeW1saW5rKGJkZXYtPmJkX3BhcnQtPmhvbGRlcl9kaXIsICZkaXNrX3RvX2RldihkaXNrKS0+a29iaik7Ci0JaWYgKHJldCkgewotCQlkZWxfc3ltbGluayhkaXNrLT5zbGF2ZV9kaXIsICZwYXJ0X3RvX2RldihiZGV2LT5iZF9wYXJ0KS0+a29iaik7CisJaG9sZGVyID0gYmRfZmluZF9ob2xkZXJfZGlzayhiZGV2LCBkaXNrKTsKKwlpZiAoaG9sZGVyKSB7CisJCWhvbGRlci0+cmVmY250Kys7CiAJCWdvdG8gb3V0X3VubG9jazsKIAl9CiAKLQliZGV2LT5iZF9ob2xkZXJfZGlzayA9IGRpc2s7CisJaG9sZGVyID0ga3phbGxvYyhzaXplb2YoKmhvbGRlciksIEdGUF9LRVJORUwpOworCWlmICghaG9sZGVyKSB7CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gb3V0X3VubG9jazsKKwl9CisKKwlJTklUX0xJU1RfSEVBRCgmaG9sZGVyLT5saXN0KTsKKwlob2xkZXItPmRpc2sgPSBkaXNrOworCWhvbGRlci0+cmVmY250ID0gMTsKKworCXJldCA9IGFkZF9zeW1saW5rKGRpc2stPnNsYXZlX2RpciwgJnBhcnRfdG9fZGV2KGJkZXYtPmJkX3BhcnQpLT5rb2JqKTsKKwlpZiAocmV0KQorCQlnb3RvIG91dF9mcmVlOworCisJcmV0ID0gYWRkX3N5bWxpbmsoYmRldi0+YmRfcGFydC0+aG9sZGVyX2RpciwgJmRpc2tfdG9fZGV2KGRpc2spLT5rb2JqKTsKKwlpZiAocmV0KQorCQlnb3RvIG91dF9kZWw7CisKKwlsaXN0X2FkZCgmaG9sZGVyLT5saXN0LCAmYmRldi0+YmRfaG9sZGVyX2Rpc2tzKTsKKwlnb3RvIG91dF91bmxvY2s7CisKK291dF9kZWw6CisJZGVsX3N5bWxpbmsoZGlzay0+c2xhdmVfZGlyLCAmcGFydF90b19kZXYoYmRldi0+YmRfcGFydCktPmtvYmopOworb3V0X2ZyZWU6CisJa2ZyZWUoaG9sZGVyKTsKIG91dF91bmxvY2s6CiAJbXV0ZXhfdW5sb2NrKCZiZGV2LT5iZF9tdXRleCk7CiAJcmV0dXJuIHJldDsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGJkX2xpbmtfZGlza19ob2xkZXIpOwogCi1zdGF0aWMgdm9pZCBiZF91bmxpbmtfZGlza19ob2xkZXIoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldikKKy8qKgorICogYmRfdW5saW5rX2Rpc2tfaG9sZGVyIC0gZGVzdHJveSBzeW1saW5rcyBjcmVhdGVkIGJ5IGJkX2xpbmtfZGlza19ob2xkZXIoKQorICogQGJkZXY6IHRoZSBjYWxpbWVkIHNsYXZlIGJkZXYKKyAqIEBkaXNrOiB0aGUgaG9sZGluZyBkaXNrCisgKgorICogRE9OJ1QgVVNFIFRISVMgVU5MRVNTIFlPVSdSRSBBTFJFQURZIFVTSU5HIElULgorICoKKyAqIENPTlRFWFQ6CisgKiBNaWdodCBzbGVlcC4KKyAqLwordm9pZCBiZF91bmxpbmtfZGlza19ob2xkZXIoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgc3RydWN0IGdlbmRpc2sgKmRpc2spCiB7Ci0Jc3RydWN0IGdlbmRpc2sgKmRpc2sgPSBiZGV2LT5iZF9ob2xkZXJfZGlzazsKKwlzdHJ1Y3QgYmRfaG9sZGVyX2Rpc2sgKmhvbGRlcjsKIAotCWJkZXYtPmJkX2hvbGRlcl9kaXNrID0gTlVMTDsKLQlpZiAoIWRpc2spCi0JCXJldHVybjsKKwltdXRleF9sb2NrKCZiZGV2LT5iZF9tdXRleCk7CiAKLQlkZWxfc3ltbGluayhkaXNrLT5zbGF2ZV9kaXIsICZwYXJ0X3RvX2RldihiZGV2LT5iZF9wYXJ0KS0+a29iaik7Ci0JZGVsX3N5bWxpbmsoYmRldi0+YmRfcGFydC0+aG9sZGVyX2RpciwgJmRpc2tfdG9fZGV2KGRpc2spLT5rb2JqKTsKKwlob2xkZXIgPSBiZF9maW5kX2hvbGRlcl9kaXNrKGJkZXYsIGRpc2spOworCisJaWYgKCFXQVJOX09OX09OQ0UoaG9sZGVyID09IE5VTEwpICYmICEtLWhvbGRlci0+cmVmY250KSB7CisJCWRlbF9zeW1saW5rKGRpc2stPnNsYXZlX2RpciwgJnBhcnRfdG9fZGV2KGJkZXYtPmJkX3BhcnQpLT5rb2JqKTsKKwkJZGVsX3N5bWxpbmsoYmRldi0+YmRfcGFydC0+aG9sZGVyX2RpciwKKwkJCSAgICAmZGlza190b19kZXYoZGlzayktPmtvYmopOworCQlsaXN0X2RlbF9pbml0KCZob2xkZXItPmxpc3QpOworCQlrZnJlZShob2xkZXIpOworCX0KKworCW11dGV4X3VubG9jaygmYmRldi0+YmRfbXV0ZXgpOwogfQotI2Vsc2UKLXN0YXRpYyBpbmxpbmUgdm9pZCBiZF91bmxpbmtfZGlza19ob2xkZXIoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldikKLXsgfQorRVhQT1JUX1NZTUJPTF9HUEwoYmRfdW5saW5rX2Rpc2tfaG9sZGVyKTsKICNlbmRpZgogCiAvKioKQEAgLTEzODAsNyArMTQzOCw2IEBACiAJCSAqIHVuYmxvY2sgZXZwb2xsIGlmIGl0IHdhcyBhIHdyaXRlIGhvbGRlci4KIAkJICovCiAJCWlmIChiZGV2X2ZyZWUpIHsKLQkJCWJkX3VubGlua19kaXNrX2hvbGRlcihiZGV2KTsKIAkJCWlmIChiZGV2LT5iZF93cml0ZV9ob2xkZXIpIHsKIAkJCQlkaXNrX3VuYmxvY2tfZXZlbnRzKGJkZXYtPmJkX2Rpc2spOwogCQkJCWJkZXYtPmJkX3dyaXRlX2hvbGRlciA9IGZhbHNlOwpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvS2NvbmZpZyBiL2ZzL2J0cmZzL0tjb25maWcKaW5kZXggN2JiM2MwMi4uZWNiOWZkMyAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvS2NvbmZpZworKysgYi9mcy9idHJmcy9LY29uZmlnCkBAIC00LDYgKzQsOCBAQAogCXNlbGVjdCBMSUJDUkMzMkMKIAlzZWxlY3QgWkxJQl9JTkZMQVRFCiAJc2VsZWN0IFpMSUJfREVGTEFURQorCXNlbGVjdCBMWk9fQ09NUFJFU1MKKwlzZWxlY3QgTFpPX0RFQ09NUFJFU1MKIAloZWxwCiAJICBCdHJmcyBpcyBhIG5ldyBmaWxlc3lzdGVtIHdpdGggZXh0ZW50cywgd3JpdGFibGUgc25hcHNob3R0aW5nLAogCSAgc3VwcG9ydCBmb3IgbXVsdGlwbGUgZGV2aWNlcyBhbmQgbWFueSBtb3JlIGZlYXR1cmVzLgpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvTWFrZWZpbGUgYi9mcy9idHJmcy9NYWtlZmlsZQppbmRleCBhMzVlYjM2Li4zMTYxMGVhIDEwMDY0NAotLS0gYS9mcy9idHJmcy9NYWtlZmlsZQorKysgYi9mcy9idHJmcy9NYWtlZmlsZQpAQCAtNiw1ICs2LDUgQEAKIAkgICB0cmFuc2FjdGlvbi5vIGlub2RlLm8gZmlsZS5vIHRyZWUtZGVmcmFnLm8gXAogCSAgIGV4dGVudF9tYXAubyBzeXNmcy5vIHN0cnVjdC1mdW5jcy5vIHhhdHRyLm8gb3JkZXJlZC1kYXRhLm8gXAogCSAgIGV4dGVudF9pby5vIHZvbHVtZXMubyBhc3luYy10aHJlYWQubyBpb2N0bC5vIGxvY2tpbmcubyBvcnBoYW4ubyBcCi0JICAgZXhwb3J0Lm8gdHJlZS1sb2cubyBhY2wubyBmcmVlLXNwYWNlLWNhY2hlLm8gemxpYi5vIFwKKwkgICBleHBvcnQubyB0cmVlLWxvZy5vIGFjbC5vIGZyZWUtc3BhY2UtY2FjaGUubyB6bGliLm8gbHpvLm8gXAogCSAgIGNvbXByZXNzaW9uLm8gZGVsYXllZC1yZWYubyByZWxvY2F0aW9uLm8KZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL2FjbC5jIGIvZnMvYnRyZnMvYWNsLmMKaW5kZXggNmFlMmM4Yy4uOWM5NDkzNCAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvYWNsLmMKKysrIGIvZnMvYnRyZnMvYWNsLmMKQEAgLTM3LDYgKzM3LDkgQEAKIAljaGFyICp2YWx1ZSA9IE5VTEw7CiAJc3RydWN0IHBvc2l4X2FjbCAqYWNsOwogCisJaWYgKCFJU19QT1NJWEFDTChpbm9kZSkpCisJCXJldHVybiBOVUxMOworCiAJYWNsID0gZ2V0X2NhY2hlZF9hY2woaW5vZGUsIHR5cGUpOwogCWlmIChhY2wgIT0gQUNMX05PVF9DQUNIRUQpCiAJCXJldHVybiBhY2w7CkBAIC02MCw4ICs2MywxMCBAQAogCQlzaXplID0gX19idHJmc19nZXR4YXR0cihpbm9kZSwgbmFtZSwgdmFsdWUsIHNpemUpOwogCQlpZiAoc2l6ZSA+IDApIHsKIAkJCWFjbCA9IHBvc2l4X2FjbF9mcm9tX3hhdHRyKHZhbHVlLCBzaXplKTsKLQkJCWlmIChJU19FUlIoYWNsKSkKKwkJCWlmIChJU19FUlIoYWNsKSkgeworCQkJCWtmcmVlKHZhbHVlKTsKIAkJCQlyZXR1cm4gYWNsOworCQkJfQogCQkJc2V0X2NhY2hlZF9hY2woaW5vZGUsIHR5cGUsIGFjbCk7CiAJCX0KIAkJa2ZyZWUodmFsdWUpOwpAQCAtODIsNiArODcsOSBAQAogCXN0cnVjdCBwb3NpeF9hY2wgKmFjbDsKIAlpbnQgcmV0ID0gMDsKIAorCWlmICghSVNfUE9TSVhBQ0woZGVudHJ5LT5kX2lub2RlKSkKKwkJcmV0dXJuIC1FT1BOT1RTVVBQOworCiAJYWNsID0gYnRyZnNfZ2V0X2FjbChkZW50cnktPmRfaW5vZGUsIHR5cGUpOwogCiAJaWYgKElTX0VSUihhY2wpKQpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvYnRyZnNfaW5vZGUuaCBiL2ZzL2J0cmZzL2J0cmZzX2lub2RlLmgKaW5kZXggNmFkNjNmMS4uY2NjOTkxYyAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvYnRyZnNfaW5vZGUuaAorKysgYi9mcy9idHJmcy9idHJmc19pbm9kZS5oCkBAIC0xNTcsNyArMTU3LDcgQEAKIAkvKgogCSAqIGFsd2F5cyBjb21wcmVzcyB0aGlzIG9uZSBmaWxlCiAJICovCi0JdW5zaWduZWQgZm9yY2VfY29tcHJlc3M6MTsKKwl1bnNpZ25lZCBmb3JjZV9jb21wcmVzczo0OwogCiAJc3RydWN0IGlub2RlIHZmc19pbm9kZTsKIH07CmRpZmYgLS1naXQgYS9mcy9idHJmcy9jb21wcmVzc2lvbi5jIGIvZnMvYnRyZnMvY29tcHJlc3Npb24uYwppbmRleCBiNTBiYzRiLi40ZDIxMTBlIDEwMDY0NAotLS0gYS9mcy9idHJmcy9jb21wcmVzc2lvbi5jCisrKyBiL2ZzL2J0cmZzL2NvbXByZXNzaW9uLmMKQEAgLTYyLDYgKzYyLDkgQEAKIAkvKiBudW1iZXIgb2YgYnl0ZXMgb24gZGlzayAqLwogCXVuc2lnbmVkIGxvbmcgY29tcHJlc3NlZF9sZW47CiAKKwkvKiB0aGUgY29tcHJlc3Npb24gYWxnb3JpdGhtIGZvciB0aGlzIGJpbyAqLworCWludCBjb21wcmVzc190eXBlOworCiAJLyogbnVtYmVyIG9mIGNvbXByZXNzZWQgcGFnZXMgaW4gdGhlIGFycmF5ICovCiAJdW5zaWduZWQgbG9uZyBucl9wYWdlczsKIApAQCAtMTczLDExICsxNzYsMTIgQEAKIAkvKiBvaywgd2UncmUgdGhlIGxhc3QgYmlvIGZvciB0aGlzIGV4dGVudCwgbGV0cyBzdGFydAogCSAqIHRoZSBkZWNvbXByZXNzaW9uLgogCSAqLwotCXJldCA9IGJ0cmZzX3psaWJfZGVjb21wcmVzc19iaW92ZWMoY2ItPmNvbXByZXNzZWRfcGFnZXMsCi0JCQkJCWNiLT5zdGFydCwKLQkJCQkJY2ItPm9yaWdfYmlvLT5iaV9pb192ZWMsCi0JCQkJCWNiLT5vcmlnX2Jpby0+YmlfdmNudCwKLQkJCQkJY2ItPmNvbXByZXNzZWRfbGVuKTsKKwlyZXQgPSBidHJmc19kZWNvbXByZXNzX2Jpb3ZlYyhjYi0+Y29tcHJlc3NfdHlwZSwKKwkJCQkgICAgICBjYi0+Y29tcHJlc3NlZF9wYWdlcywKKwkJCQkgICAgICBjYi0+c3RhcnQsCisJCQkJICAgICAgY2ItPm9yaWdfYmlvLT5iaV9pb192ZWMsCisJCQkJICAgICAgY2ItPm9yaWdfYmlvLT5iaV92Y250LAorCQkJCSAgICAgIGNiLT5jb21wcmVzc2VkX2xlbik7CiBjc3VtX2ZhaWxlZDoKIAlpZiAocmV0KQogCQljYi0+ZXJyb3JzID0gMTsKQEAgLTU1OCw3ICs1NjIsNyBAQAogCXU2NCBlbV9sZW47CiAJdTY0IGVtX3N0YXJ0OwogCXN0cnVjdCBleHRlbnRfbWFwICplbTsKLQlpbnQgcmV0OworCWludCByZXQgPSAtRU5PTUVNOwogCXUzMiAqc3VtczsKIAogCXRyZWUgPSAmQlRSRlNfSShpbm9kZSktPmlvX3RyZWU7CkBAIC01NzMsNiArNTc3LDkgQEAKIAogCWNvbXByZXNzZWRfbGVuID0gZW0tPmJsb2NrX2xlbjsKIAljYiA9IGttYWxsb2MoY29tcHJlc3NlZF9iaW9fc2l6ZShyb290LCBjb21wcmVzc2VkX2xlbiksIEdGUF9OT0ZTKTsKKwlpZiAoIWNiKQorCQlnb3RvIG91dDsKKwogCWF0b21pY19zZXQoJmNiLT5wZW5kaW5nX2Jpb3MsIDApOwogCWNiLT5lcnJvcnMgPSAwOwogCWNiLT5pbm9kZSA9IGlub2RlOwpAQCAtNTg4LDE3ICs1OTUsMjMgQEAKIAogCWNiLT5sZW4gPSB1bmNvbXByZXNzZWRfbGVuOwogCWNiLT5jb21wcmVzc2VkX2xlbiA9IGNvbXByZXNzZWRfbGVuOworCWNiLT5jb21wcmVzc190eXBlID0gZXh0ZW50X2NvbXByZXNzX3R5cGUoYmlvX2ZsYWdzKTsKIAljYi0+b3JpZ19iaW8gPSBiaW87CiAKIAlucl9wYWdlcyA9IChjb21wcmVzc2VkX2xlbiArIFBBR0VfQ0FDSEVfU0laRSAtIDEpIC8KIAkJCQkgUEFHRV9DQUNIRV9TSVpFOwotCWNiLT5jb21wcmVzc2VkX3BhZ2VzID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IHBhZ2UgKikgKiBucl9wYWdlcywKKwljYi0+Y29tcHJlc3NlZF9wYWdlcyA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBwYWdlICopICogbnJfcGFnZXMsCiAJCQkJICAgICAgIEdGUF9OT0ZTKTsKKwlpZiAoIWNiLT5jb21wcmVzc2VkX3BhZ2VzKQorCQlnb3RvIGZhaWwxOworCiAJYmRldiA9IEJUUkZTX0koaW5vZGUpLT5yb290LT5mc19pbmZvLT5mc19kZXZpY2VzLT5sYXRlc3RfYmRldjsKIAogCWZvciAocGFnZV9pbmRleCA9IDA7IHBhZ2VfaW5kZXggPCBucl9wYWdlczsgcGFnZV9pbmRleCsrKSB7CiAJCWNiLT5jb21wcmVzc2VkX3BhZ2VzW3BhZ2VfaW5kZXhdID0gYWxsb2NfcGFnZShHRlBfTk9GUyB8CiAJCQkJCQkJICAgICAgX19HRlBfSElHSE1FTSk7CisJCWlmICghY2ItPmNvbXByZXNzZWRfcGFnZXNbcGFnZV9pbmRleF0pCisJCQlnb3RvIGZhaWwyOwogCX0KIAljYi0+bnJfcGFnZXMgPSBucl9wYWdlczsKIApAQCAtNjA5LDYgKzYyMiw4IEBACiAJY2ItPmxlbiA9IHVuY29tcHJlc3NlZF9sZW47CiAKIAljb21wX2JpbyA9IGNvbXByZXNzZWRfYmlvX2FsbG9jKGJkZXYsIGN1cl9kaXNrX2J5dGUsIEdGUF9OT0ZTKTsKKwlpZiAoIWNvbXBfYmlvKQorCQlnb3RvIGZhaWwyOwogCWNvbXBfYmlvLT5iaV9wcml2YXRlID0gY2I7CiAJY29tcF9iaW8tPmJpX2VuZF9pbyA9IGVuZF9jb21wcmVzc2VkX2Jpb19yZWFkOwogCWF0b21pY19pbmMoJmNiLT5wZW5kaW5nX2Jpb3MpOwpAQCAtNjc2LDQgKzY5MSwzMjkgQEAKIAogCWJpb19wdXQoY29tcF9iaW8pOwogCXJldHVybiAwOworCitmYWlsMjoKKwlmb3IgKHBhZ2VfaW5kZXggPSAwOyBwYWdlX2luZGV4IDwgbnJfcGFnZXM7IHBhZ2VfaW5kZXgrKykKKwkJZnJlZV9wYWdlKCh1bnNpZ25lZCBsb25nKWNiLT5jb21wcmVzc2VkX3BhZ2VzW3BhZ2VfaW5kZXhdKTsKKworCWtmcmVlKGNiLT5jb21wcmVzc2VkX3BhZ2VzKTsKK2ZhaWwxOgorCWtmcmVlKGNiKTsKK291dDoKKwlmcmVlX2V4dGVudF9tYXAoZW0pOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgbGlzdF9oZWFkIGNvbXBfaWRsZV93b3Jrc3BhY2VbQlRSRlNfQ09NUFJFU1NfVFlQRVNdOworc3RhdGljIHNwaW5sb2NrX3QgY29tcF93b3Jrc3BhY2VfbG9ja1tCVFJGU19DT01QUkVTU19UWVBFU107CitzdGF0aWMgaW50IGNvbXBfbnVtX3dvcmtzcGFjZVtCVFJGU19DT01QUkVTU19UWVBFU107CitzdGF0aWMgYXRvbWljX3QgY29tcF9hbGxvY193b3Jrc3BhY2VbQlRSRlNfQ09NUFJFU1NfVFlQRVNdOworc3RhdGljIHdhaXRfcXVldWVfaGVhZF90IGNvbXBfd29ya3NwYWNlX3dhaXRbQlRSRlNfQ09NUFJFU1NfVFlQRVNdOworCitzdHJ1Y3QgYnRyZnNfY29tcHJlc3Nfb3AgKmJ0cmZzX2NvbXByZXNzX29wW10gPSB7CisJJmJ0cmZzX3psaWJfY29tcHJlc3MsCisJJmJ0cmZzX2x6b19jb21wcmVzcywKK307CisKK2ludCBfX2luaXQgYnRyZnNfaW5pdF9jb21wcmVzcyh2b2lkKQoreworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IEJUUkZTX0NPTVBSRVNTX1RZUEVTOyBpKyspIHsKKwkJSU5JVF9MSVNUX0hFQUQoJmNvbXBfaWRsZV93b3Jrc3BhY2VbaV0pOworCQlzcGluX2xvY2tfaW5pdCgmY29tcF93b3Jrc3BhY2VfbG9ja1tpXSk7CisJCWF0b21pY19zZXQoJmNvbXBfYWxsb2Nfd29ya3NwYWNlW2ldLCAwKTsKKwkJaW5pdF93YWl0cXVldWVfaGVhZCgmY29tcF93b3Jrc3BhY2Vfd2FpdFtpXSk7CisJfQorCXJldHVybiAwOworfQorCisvKgorICogdGhpcyBmaW5kcyBhbiBhdmFpbGFibGUgd29ya3NwYWNlIG9yIGFsbG9jYXRlcyBhIG5ldyBvbmUKKyAqIEVSUl9QVFIgaXMgcmV0dXJuZWQgaWYgdGhpbmdzIGdvIGJhZC4KKyAqLworc3RhdGljIHN0cnVjdCBsaXN0X2hlYWQgKmZpbmRfd29ya3NwYWNlKGludCB0eXBlKQoreworCXN0cnVjdCBsaXN0X2hlYWQgKndvcmtzcGFjZTsKKwlpbnQgY3B1cyA9IG51bV9vbmxpbmVfY3B1cygpOworCWludCBpZHggPSB0eXBlIC0gMTsKKworCXN0cnVjdCBsaXN0X2hlYWQgKmlkbGVfd29ya3NwYWNlCT0gJmNvbXBfaWRsZV93b3Jrc3BhY2VbaWR4XTsKKwlzcGlubG9ja190ICp3b3Jrc3BhY2VfbG9jawkJPSAmY29tcF93b3Jrc3BhY2VfbG9ja1tpZHhdOworCWF0b21pY190ICphbGxvY193b3Jrc3BhY2UJCT0gJmNvbXBfYWxsb2Nfd29ya3NwYWNlW2lkeF07CisJd2FpdF9xdWV1ZV9oZWFkX3QgKndvcmtzcGFjZV93YWl0CT0gJmNvbXBfd29ya3NwYWNlX3dhaXRbaWR4XTsKKwlpbnQgKm51bV93b3Jrc3BhY2UJCQk9ICZjb21wX251bV93b3Jrc3BhY2VbaWR4XTsKK2FnYWluOgorCXNwaW5fbG9jayh3b3Jrc3BhY2VfbG9jayk7CisJaWYgKCFsaXN0X2VtcHR5KGlkbGVfd29ya3NwYWNlKSkgeworCQl3b3Jrc3BhY2UgPSBpZGxlX3dvcmtzcGFjZS0+bmV4dDsKKwkJbGlzdF9kZWwod29ya3NwYWNlKTsKKwkJKCpudW1fd29ya3NwYWNlKS0tOworCQlzcGluX3VubG9jayh3b3Jrc3BhY2VfbG9jayk7CisJCXJldHVybiB3b3Jrc3BhY2U7CisKKwl9CisJaWYgKGF0b21pY19yZWFkKGFsbG9jX3dvcmtzcGFjZSkgPiBjcHVzKSB7CisJCURFRklORV9XQUlUKHdhaXQpOworCisJCXNwaW5fdW5sb2NrKHdvcmtzcGFjZV9sb2NrKTsKKwkJcHJlcGFyZV90b193YWl0KHdvcmtzcGFjZV93YWl0LCAmd2FpdCwgVEFTS19VTklOVEVSUlVQVElCTEUpOworCQlpZiAoYXRvbWljX3JlYWQoYWxsb2Nfd29ya3NwYWNlKSA+IGNwdXMgJiYgISpudW1fd29ya3NwYWNlKQorCQkJc2NoZWR1bGUoKTsKKwkJZmluaXNoX3dhaXQod29ya3NwYWNlX3dhaXQsICZ3YWl0KTsKKwkJZ290byBhZ2FpbjsKKwl9CisJYXRvbWljX2luYyhhbGxvY193b3Jrc3BhY2UpOworCXNwaW5fdW5sb2NrKHdvcmtzcGFjZV9sb2NrKTsKKworCXdvcmtzcGFjZSA9IGJ0cmZzX2NvbXByZXNzX29wW2lkeF0tPmFsbG9jX3dvcmtzcGFjZSgpOworCWlmIChJU19FUlIod29ya3NwYWNlKSkgeworCQlhdG9taWNfZGVjKGFsbG9jX3dvcmtzcGFjZSk7CisJCXdha2VfdXAod29ya3NwYWNlX3dhaXQpOworCX0KKwlyZXR1cm4gd29ya3NwYWNlOworfQorCisvKgorICogcHV0IGEgd29ya3NwYWNlIHN0cnVjdCBiYWNrIG9uIHRoZSBsaXN0IG9yIGZyZWUgaXQgaWYgd2UgaGF2ZSBlbm91Z2gKKyAqIGlkbGUgb25lcyBzaXR0aW5nIGFyb3VuZAorICovCitzdGF0aWMgdm9pZCBmcmVlX3dvcmtzcGFjZShpbnQgdHlwZSwgc3RydWN0IGxpc3RfaGVhZCAqd29ya3NwYWNlKQoreworCWludCBpZHggPSB0eXBlIC0gMTsKKwlzdHJ1Y3QgbGlzdF9oZWFkICppZGxlX3dvcmtzcGFjZQk9ICZjb21wX2lkbGVfd29ya3NwYWNlW2lkeF07CisJc3BpbmxvY2tfdCAqd29ya3NwYWNlX2xvY2sJCT0gJmNvbXBfd29ya3NwYWNlX2xvY2tbaWR4XTsKKwlhdG9taWNfdCAqYWxsb2Nfd29ya3NwYWNlCQk9ICZjb21wX2FsbG9jX3dvcmtzcGFjZVtpZHhdOworCXdhaXRfcXVldWVfaGVhZF90ICp3b3Jrc3BhY2Vfd2FpdAk9ICZjb21wX3dvcmtzcGFjZV93YWl0W2lkeF07CisJaW50ICpudW1fd29ya3NwYWNlCQkJPSAmY29tcF9udW1fd29ya3NwYWNlW2lkeF07CisKKwlzcGluX2xvY2sod29ya3NwYWNlX2xvY2spOworCWlmICgqbnVtX3dvcmtzcGFjZSA8IG51bV9vbmxpbmVfY3B1cygpKSB7CisJCWxpc3RfYWRkX3RhaWwod29ya3NwYWNlLCBpZGxlX3dvcmtzcGFjZSk7CisJCSgqbnVtX3dvcmtzcGFjZSkrKzsKKwkJc3Bpbl91bmxvY2sod29ya3NwYWNlX2xvY2spOworCQlnb3RvIHdha2U7CisJfQorCXNwaW5fdW5sb2NrKHdvcmtzcGFjZV9sb2NrKTsKKworCWJ0cmZzX2NvbXByZXNzX29wW2lkeF0tPmZyZWVfd29ya3NwYWNlKHdvcmtzcGFjZSk7CisJYXRvbWljX2RlYyhhbGxvY193b3Jrc3BhY2UpOword2FrZToKKwlpZiAod2FpdHF1ZXVlX2FjdGl2ZSh3b3Jrc3BhY2Vfd2FpdCkpCisJCXdha2VfdXAod29ya3NwYWNlX3dhaXQpOworfQorCisvKgorICogY2xlYW51cCBmdW5jdGlvbiBmb3IgbW9kdWxlIGV4aXQKKyAqLworc3RhdGljIHZvaWQgZnJlZV93b3Jrc3BhY2VzKHZvaWQpCit7CisJc3RydWN0IGxpc3RfaGVhZCAqd29ya3NwYWNlOworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IEJUUkZTX0NPTVBSRVNTX1RZUEVTOyBpKyspIHsKKwkJd2hpbGUgKCFsaXN0X2VtcHR5KCZjb21wX2lkbGVfd29ya3NwYWNlW2ldKSkgeworCQkJd29ya3NwYWNlID0gY29tcF9pZGxlX3dvcmtzcGFjZVtpXS5uZXh0OworCQkJbGlzdF9kZWwod29ya3NwYWNlKTsKKwkJCWJ0cmZzX2NvbXByZXNzX29wW2ldLT5mcmVlX3dvcmtzcGFjZSh3b3Jrc3BhY2UpOworCQkJYXRvbWljX2RlYygmY29tcF9hbGxvY193b3Jrc3BhY2VbaV0pOworCQl9CisJfQorfQorCisvKgorICogZ2l2ZW4gYW4gYWRkcmVzcyBzcGFjZSBhbmQgc3RhcnQvbGVuLCBjb21wcmVzcyB0aGUgYnl0ZXMuCisgKgorICogcGFnZXMgYXJlIGFsbG9jYXRlZCB0byBob2xkIHRoZSBjb21wcmVzc2VkIHJlc3VsdCBhbmQgc3RvcmVkCisgKiBpbiAncGFnZXMnCisgKgorICogb3V0X3BhZ2VzIGlzIHVzZWQgdG8gcmV0dXJuIHRoZSBudW1iZXIgb2YgcGFnZXMgYWxsb2NhdGVkLiAgVGhlcmUKKyAqIG1heSBiZSBwYWdlcyBhbGxvY2F0ZWQgZXZlbiBpZiB3ZSByZXR1cm4gYW4gZXJyb3IKKyAqCisgKiB0b3RhbF9pbiBpcyB1c2VkIHRvIHJldHVybiB0aGUgbnVtYmVyIG9mIGJ5dGVzIGFjdHVhbGx5IHJlYWQuICBJdAorICogbWF5IGJlIHNtYWxsZXIgdGhlbiBsZW4gaWYgd2UgaGFkIHRvIGV4aXQgZWFybHkgYmVjYXVzZSB3ZQorICogcmFuIG91dCBvZiByb29tIGluIHRoZSBwYWdlcyBhcnJheSBvciBiZWNhdXNlIHdlIGNyb3NzIHRoZQorICogbWF4X291dCB0aHJlc2hvbGQuCisgKgorICogdG90YWxfb3V0IGlzIHVzZWQgdG8gcmV0dXJuIHRoZSB0b3RhbCBudW1iZXIgb2YgY29tcHJlc3NlZCBieXRlcworICoKKyAqIG1heF9vdXQgdGVsbHMgdXMgdGhlIG1heCBudW1iZXIgb2YgYnl0ZXMgdGhhdCB3ZSdyZSBhbGxvd2VkIHRvCisgKiBzdHVmZiBpbnRvIHBhZ2VzCisgKi8KK2ludCBidHJmc19jb21wcmVzc19wYWdlcyhpbnQgdHlwZSwgc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmcsCisJCQkgdTY0IHN0YXJ0LCB1bnNpZ25lZCBsb25nIGxlbiwKKwkJCSBzdHJ1Y3QgcGFnZSAqKnBhZ2VzLAorCQkJIHVuc2lnbmVkIGxvbmcgbnJfZGVzdF9wYWdlcywKKwkJCSB1bnNpZ25lZCBsb25nICpvdXRfcGFnZXMsCisJCQkgdW5zaWduZWQgbG9uZyAqdG90YWxfaW4sCisJCQkgdW5zaWduZWQgbG9uZyAqdG90YWxfb3V0LAorCQkJIHVuc2lnbmVkIGxvbmcgbWF4X291dCkKK3sKKwlzdHJ1Y3QgbGlzdF9oZWFkICp3b3Jrc3BhY2U7CisJaW50IHJldDsKKworCXdvcmtzcGFjZSA9IGZpbmRfd29ya3NwYWNlKHR5cGUpOworCWlmIChJU19FUlIod29ya3NwYWNlKSkKKwkJcmV0dXJuIC0xOworCisJcmV0ID0gYnRyZnNfY29tcHJlc3Nfb3BbdHlwZS0xXS0+Y29tcHJlc3NfcGFnZXMod29ya3NwYWNlLCBtYXBwaW5nLAorCQkJCQkJICAgICAgc3RhcnQsIGxlbiwgcGFnZXMsCisJCQkJCQkgICAgICBucl9kZXN0X3BhZ2VzLCBvdXRfcGFnZXMsCisJCQkJCQkgICAgICB0b3RhbF9pbiwgdG90YWxfb3V0LAorCQkJCQkJICAgICAgbWF4X291dCk7CisJZnJlZV93b3Jrc3BhY2UodHlwZSwgd29ya3NwYWNlKTsKKwlyZXR1cm4gcmV0OworfQorCisvKgorICogcGFnZXNfaW4gaXMgYW4gYXJyYXkgb2YgcGFnZXMgd2l0aCBjb21wcmVzc2VkIGRhdGEuCisgKgorICogZGlza19zdGFydCBpcyB0aGUgc3RhcnRpbmcgbG9naWNhbCBvZmZzZXQgb2YgdGhpcyBhcnJheSBpbiB0aGUgZmlsZQorICoKKyAqIGJ2ZWMgaXMgYSBiaW9fdmVjIG9mIHBhZ2VzIGZyb20gdGhlIGZpbGUgdGhhdCB3ZSB3YW50IHRvIGRlY29tcHJlc3MgaW50bworICoKKyAqIHZjbnQgaXMgdGhlIGNvdW50IG9mIHBhZ2VzIGluIHRoZSBiaW92ZWMKKyAqCisgKiBzcmNsZW4gaXMgdGhlIG51bWJlciBvZiBieXRlcyBpbiBwYWdlc19pbgorICoKKyAqIFRoZSBiYXNpYyBpZGVhIGlzIHRoYXQgd2UgaGF2ZSBhIGJpbyB0aGF0IHdhcyBjcmVhdGVkIGJ5IHJlYWRwYWdlcy4KKyAqIFRoZSBwYWdlcyBpbiB0aGUgYmlvIGFyZSBmb3IgdGhlIHVuY29tcHJlc3NlZCBkYXRhLCBhbmQgdGhleSBtYXkgbm90CisgKiBiZSBjb250aWd1b3VzLiAgVGhleSBhbGwgY29ycmVzcG9uZCB0byB0aGUgcmFuZ2Ugb2YgYnl0ZXMgY292ZXJlZCBieQorICogdGhlIGNvbXByZXNzZWQgZXh0ZW50LgorICovCitpbnQgYnRyZnNfZGVjb21wcmVzc19iaW92ZWMoaW50IHR5cGUsIHN0cnVjdCBwYWdlICoqcGFnZXNfaW4sIHU2NCBkaXNrX3N0YXJ0LAorCQkJICAgIHN0cnVjdCBiaW9fdmVjICpidmVjLCBpbnQgdmNudCwgc2l6ZV90IHNyY2xlbikKK3sKKwlzdHJ1Y3QgbGlzdF9oZWFkICp3b3Jrc3BhY2U7CisJaW50IHJldDsKKworCXdvcmtzcGFjZSA9IGZpbmRfd29ya3NwYWNlKHR5cGUpOworCWlmIChJU19FUlIod29ya3NwYWNlKSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlyZXQgPSBidHJmc19jb21wcmVzc19vcFt0eXBlLTFdLT5kZWNvbXByZXNzX2Jpb3ZlYyh3b3Jrc3BhY2UsIHBhZ2VzX2luLAorCQkJCQkJCSBkaXNrX3N0YXJ0LAorCQkJCQkJCSBidmVjLCB2Y250LCBzcmNsZW4pOworCWZyZWVfd29ya3NwYWNlKHR5cGUsIHdvcmtzcGFjZSk7CisJcmV0dXJuIHJldDsKK30KKworLyoKKyAqIGEgbGVzcyBjb21wbGV4IGRlY29tcHJlc3Npb24gcm91dGluZS4gIE91ciBjb21wcmVzc2VkIGRhdGEgZml0cyBpbiBhCisgKiBzaW5nbGUgcGFnZSwgYW5kIHdlIHdhbnQgdG8gcmVhZCBhIHNpbmdsZSBwYWdlIG91dCBvZiBpdC4KKyAqIHN0YXJ0X2J5dGUgdGVsbHMgdXMgdGhlIG9mZnNldCBpbnRvIHRoZSBjb21wcmVzc2VkIGRhdGEgd2UncmUgaW50ZXJlc3RlZCBpbgorICovCitpbnQgYnRyZnNfZGVjb21wcmVzcyhpbnQgdHlwZSwgdW5zaWduZWQgY2hhciAqZGF0YV9pbiwgc3RydWN0IHBhZ2UgKmRlc3RfcGFnZSwKKwkJICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0X2J5dGUsIHNpemVfdCBzcmNsZW4sIHNpemVfdCBkZXN0bGVuKQoreworCXN0cnVjdCBsaXN0X2hlYWQgKndvcmtzcGFjZTsKKwlpbnQgcmV0OworCisJd29ya3NwYWNlID0gZmluZF93b3Jrc3BhY2UodHlwZSk7CisJaWYgKElTX0VSUih3b3Jrc3BhY2UpKQorCQlyZXR1cm4gLUVOT01FTTsKKworCXJldCA9IGJ0cmZzX2NvbXByZXNzX29wW3R5cGUtMV0tPmRlY29tcHJlc3Mod29ya3NwYWNlLCBkYXRhX2luLAorCQkJCQkJICBkZXN0X3BhZ2UsIHN0YXJ0X2J5dGUsCisJCQkJCQkgIHNyY2xlbiwgZGVzdGxlbik7CisKKwlmcmVlX3dvcmtzcGFjZSh0eXBlLCB3b3Jrc3BhY2UpOworCXJldHVybiByZXQ7Cit9CisKK3ZvaWQgYnRyZnNfZXhpdF9jb21wcmVzcyh2b2lkKQoreworCWZyZWVfd29ya3NwYWNlcygpOworfQorCisvKgorICogQ29weSB1bmNvbXByZXNzZWQgZGF0YSBmcm9tIHdvcmtpbmcgYnVmZmVyIHRvIHBhZ2VzLgorICoKKyAqIGJ1Zl9zdGFydCBpcyB0aGUgYnl0ZSBvZmZzZXQgd2UncmUgb2YgdGhlIHN0YXJ0IG9mIG91ciB3b3Jrc3BhY2UgYnVmZmVyLgorICoKKyAqIHRvdGFsX291dCBpcyB0aGUgbGFzdCBieXRlIG9mIHRoZSBidWZmZXIKKyAqLworaW50IGJ0cmZzX2RlY29tcHJlc3NfYnVmMnBhZ2UoY2hhciAqYnVmLCB1bnNpZ25lZCBsb25nIGJ1Zl9zdGFydCwKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgdG90YWxfb3V0LCB1NjQgZGlza19zdGFydCwKKwkJCSAgICAgIHN0cnVjdCBiaW9fdmVjICpidmVjLCBpbnQgdmNudCwKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgKnBhZ2VfaW5kZXgsCisJCQkgICAgICB1bnNpZ25lZCBsb25nICpwZ19vZmZzZXQpCit7CisJdW5zaWduZWQgbG9uZyBidWZfb2Zmc2V0OworCXVuc2lnbmVkIGxvbmcgY3VycmVudF9idWZfc3RhcnQ7CisJdW5zaWduZWQgbG9uZyBzdGFydF9ieXRlOworCXVuc2lnbmVkIGxvbmcgd29ya2luZ19ieXRlcyA9IHRvdGFsX291dCAtIGJ1Zl9zdGFydDsKKwl1bnNpZ25lZCBsb25nIGJ5dGVzOworCWNoYXIgKmthZGRyOworCXN0cnVjdCBwYWdlICpwYWdlX291dCA9IGJ2ZWNbKnBhZ2VfaW5kZXhdLmJ2X3BhZ2U7CisKKwkvKgorCSAqIHN0YXJ0IGJ5dGUgaXMgdGhlIGZpcnN0IGJ5dGUgb2YgdGhlIHBhZ2Ugd2UncmUgY3VycmVudGx5CisJICogY29weWluZyBpbnRvIHJlbGF0aXZlIHRvIHRoZSBzdGFydCBvZiB0aGUgY29tcHJlc3NlZCBkYXRhLgorCSAqLworCXN0YXJ0X2J5dGUgPSBwYWdlX29mZnNldChwYWdlX291dCkgLSBkaXNrX3N0YXJ0OworCisJLyogd2UgaGF2ZW4ndCB5ZXQgaGl0IGRhdGEgY29ycmVzcG9uZGluZyB0byB0aGlzIHBhZ2UgKi8KKwlpZiAodG90YWxfb3V0IDw9IHN0YXJ0X2J5dGUpCisJCXJldHVybiAxOworCisJLyoKKwkgKiB0aGUgc3RhcnQgb2YgdGhlIGRhdGEgd2UgY2FyZSBhYm91dCBpcyBvZmZzZXQgaW50bworCSAqIHRoZSBtaWRkbGUgb2Ygb3VyIHdvcmtpbmcgYnVmZmVyCisJICovCisJaWYgKHRvdGFsX291dCA+IHN0YXJ0X2J5dGUgJiYgYnVmX3N0YXJ0IDwgc3RhcnRfYnl0ZSkgeworCQlidWZfb2Zmc2V0ID0gc3RhcnRfYnl0ZSAtIGJ1Zl9zdGFydDsKKwkJd29ya2luZ19ieXRlcyAtPSBidWZfb2Zmc2V0OworCX0gZWxzZSB7CisJCWJ1Zl9vZmZzZXQgPSAwOworCX0KKwljdXJyZW50X2J1Zl9zdGFydCA9IGJ1Zl9zdGFydDsKKworCS8qIGNvcHkgYnl0ZXMgZnJvbSB0aGUgd29ya2luZyBidWZmZXIgaW50byB0aGUgcGFnZXMgKi8KKwl3aGlsZSAod29ya2luZ19ieXRlcyA+IDApIHsKKwkJYnl0ZXMgPSBtaW4oUEFHRV9DQUNIRV9TSVpFIC0gKnBnX29mZnNldCwKKwkJCSAgICBQQUdFX0NBQ0hFX1NJWkUgLSBidWZfb2Zmc2V0KTsKKwkJYnl0ZXMgPSBtaW4oYnl0ZXMsIHdvcmtpbmdfYnl0ZXMpOworCQlrYWRkciA9IGttYXBfYXRvbWljKHBhZ2Vfb3V0LCBLTV9VU0VSMCk7CisJCW1lbWNweShrYWRkciArICpwZ19vZmZzZXQsIGJ1ZiArIGJ1Zl9vZmZzZXQsIGJ5dGVzKTsKKwkJa3VubWFwX2F0b21pYyhrYWRkciwgS01fVVNFUjApOworCQlmbHVzaF9kY2FjaGVfcGFnZShwYWdlX291dCk7CisKKwkJKnBnX29mZnNldCArPSBieXRlczsKKwkJYnVmX29mZnNldCArPSBieXRlczsKKwkJd29ya2luZ19ieXRlcyAtPSBieXRlczsKKwkJY3VycmVudF9idWZfc3RhcnQgKz0gYnl0ZXM7CisKKwkJLyogY2hlY2sgaWYgd2UgbmVlZCB0byBwaWNrIGFub3RoZXIgcGFnZSAqLworCQlpZiAoKnBnX29mZnNldCA9PSBQQUdFX0NBQ0hFX1NJWkUpIHsKKwkJCSgqcGFnZV9pbmRleCkrKzsKKwkJCWlmICgqcGFnZV9pbmRleCA+PSB2Y250KQorCQkJCXJldHVybiAwOworCisJCQlwYWdlX291dCA9IGJ2ZWNbKnBhZ2VfaW5kZXhdLmJ2X3BhZ2U7CisJCQkqcGdfb2Zmc2V0ID0gMDsKKwkJCXN0YXJ0X2J5dGUgPSBwYWdlX29mZnNldChwYWdlX291dCkgLSBkaXNrX3N0YXJ0OworCisJCQkvKgorCQkJICogbWFrZSBzdXJlIG91ciBuZXcgcGFnZSBpcyBjb3ZlcmVkIGJ5IHRoaXMKKwkJCSAqIHdvcmtpbmcgYnVmZmVyCisJCQkgKi8KKwkJCWlmICh0b3RhbF9vdXQgPD0gc3RhcnRfYnl0ZSkKKwkJCQlyZXR1cm4gMTsKKworCQkJLyoKKwkJCSAqIHRoZSBuZXh0IHBhZ2UgaW4gdGhlIGJpb3ZlYyBtaWdodCBub3QgYmUgYWRqYWNlbnQKKwkJCSAqIHRvIHRoZSBsYXN0IHBhZ2UsIGJ1dCBpdCBtaWdodCBzdGlsbCBiZSBmb3VuZAorCQkJICogaW5zaWRlIHRoaXMgd29ya2luZyBidWZmZXIuIGJ1bXAgb3VyIG9mZnNldCBwb2ludGVyCisJCQkgKi8KKwkJCWlmICh0b3RhbF9vdXQgPiBzdGFydF9ieXRlICYmCisJCQkgICAgY3VycmVudF9idWZfc3RhcnQgPCBzdGFydF9ieXRlKSB7CisJCQkJYnVmX29mZnNldCA9IHN0YXJ0X2J5dGUgLSBidWZfc3RhcnQ7CisJCQkJd29ya2luZ19ieXRlcyA9IHRvdGFsX291dCAtIHN0YXJ0X2J5dGU7CisJCQkJY3VycmVudF9idWZfc3RhcnQgPSBidWZfc3RhcnQgKyBidWZfb2Zmc2V0OworCQkJfQorCQl9CisJfQorCisJcmV0dXJuIDE7CiB9CmRpZmYgLS1naXQgYS9mcy9idHJmcy9jb21wcmVzc2lvbi5oIGIvZnMvYnRyZnMvY29tcHJlc3Npb24uaAppbmRleCA0MjFmNWI0Li41MTAwMDE3IDEwMDY0NAotLS0gYS9mcy9idHJmcy9jb21wcmVzc2lvbi5oCisrKyBiL2ZzL2J0cmZzL2NvbXByZXNzaW9uLmgKQEAgLTE5LDI0ICsxOSwyNyBAQAogI2lmbmRlZiBfX0JUUkZTX0NPTVBSRVNTSU9OXwogI2RlZmluZSBfX0JUUkZTX0NPTVBSRVNTSU9OXwogCi1pbnQgYnRyZnNfemxpYl9kZWNvbXByZXNzKHVuc2lnbmVkIGNoYXIgKmRhdGFfaW4sCi0JCQkgIHN0cnVjdCBwYWdlICpkZXN0X3BhZ2UsCi0JCQkgIHVuc2lnbmVkIGxvbmcgc3RhcnRfYnl0ZSwKLQkJCSAgc2l6ZV90IHNyY2xlbiwgc2l6ZV90IGRlc3RsZW4pOwotaW50IGJ0cmZzX3psaWJfY29tcHJlc3NfcGFnZXMoc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmcsCi0JCQkgICAgICB1NjQgc3RhcnQsIHVuc2lnbmVkIGxvbmcgbGVuLAotCQkJICAgICAgc3RydWN0IHBhZ2UgKipwYWdlcywKLQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgbnJfZGVzdF9wYWdlcywKLQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgKm91dF9wYWdlcywKLQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgKnRvdGFsX2luLAotCQkJICAgICAgdW5zaWduZWQgbG9uZyAqdG90YWxfb3V0LAotCQkJICAgICAgdW5zaWduZWQgbG9uZyBtYXhfb3V0KTsKLWludCBidHJmc196bGliX2RlY29tcHJlc3NfYmlvdmVjKHN0cnVjdCBwYWdlICoqcGFnZXNfaW4sCi0JCQkgICAgICB1NjQgZGlza19zdGFydCwKLQkJCSAgICAgIHN0cnVjdCBiaW9fdmVjICpidmVjLAotCQkJICAgICAgaW50IHZjbnQsCi0JCQkgICAgICBzaXplX3Qgc3JjbGVuKTsKLXZvaWQgYnRyZnNfemxpYl9leGl0KHZvaWQpOworaW50IGJ0cmZzX2luaXRfY29tcHJlc3Modm9pZCk7Cit2b2lkIGJ0cmZzX2V4aXRfY29tcHJlc3Modm9pZCk7CisKK2ludCBidHJmc19jb21wcmVzc19wYWdlcyhpbnQgdHlwZSwgc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmcsCisJCQkgdTY0IHN0YXJ0LCB1bnNpZ25lZCBsb25nIGxlbiwKKwkJCSBzdHJ1Y3QgcGFnZSAqKnBhZ2VzLAorCQkJIHVuc2lnbmVkIGxvbmcgbnJfZGVzdF9wYWdlcywKKwkJCSB1bnNpZ25lZCBsb25nICpvdXRfcGFnZXMsCisJCQkgdW5zaWduZWQgbG9uZyAqdG90YWxfaW4sCisJCQkgdW5zaWduZWQgbG9uZyAqdG90YWxfb3V0LAorCQkJIHVuc2lnbmVkIGxvbmcgbWF4X291dCk7CitpbnQgYnRyZnNfZGVjb21wcmVzc19iaW92ZWMoaW50IHR5cGUsIHN0cnVjdCBwYWdlICoqcGFnZXNfaW4sIHU2NCBkaXNrX3N0YXJ0LAorCQkJICAgIHN0cnVjdCBiaW9fdmVjICpidmVjLCBpbnQgdmNudCwgc2l6ZV90IHNyY2xlbik7CitpbnQgYnRyZnNfZGVjb21wcmVzcyhpbnQgdHlwZSwgdW5zaWduZWQgY2hhciAqZGF0YV9pbiwgc3RydWN0IHBhZ2UgKmRlc3RfcGFnZSwKKwkJICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0X2J5dGUsIHNpemVfdCBzcmNsZW4sIHNpemVfdCBkZXN0bGVuKTsKK2ludCBidHJmc19kZWNvbXByZXNzX2J1ZjJwYWdlKGNoYXIgKmJ1ZiwgdW5zaWduZWQgbG9uZyBidWZfc3RhcnQsCisJCQkgICAgICB1bnNpZ25lZCBsb25nIHRvdGFsX291dCwgdTY0IGRpc2tfc3RhcnQsCisJCQkgICAgICBzdHJ1Y3QgYmlvX3ZlYyAqYnZlYywgaW50IHZjbnQsCisJCQkgICAgICB1bnNpZ25lZCBsb25nICpwYWdlX2luZGV4LAorCQkJICAgICAgdW5zaWduZWQgbG9uZyAqcGdfb2Zmc2V0KTsKKwogaW50IGJ0cmZzX3N1Ym1pdF9jb21wcmVzc2VkX3dyaXRlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHU2NCBzdGFydCwKIAkJCQkgIHVuc2lnbmVkIGxvbmcgbGVuLCB1NjQgZGlza19zdGFydCwKIAkJCQkgIHVuc2lnbmVkIGxvbmcgY29tcHJlc3NlZF9sZW4sCkBAIC00NCw0ICs0NywzNyBAQAogCQkJCSAgdW5zaWduZWQgbG9uZyBucl9wYWdlcyk7CiBpbnQgYnRyZnNfc3VibWl0X2NvbXByZXNzZWRfcmVhZChzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgYmlvICpiaW8sCiAJCQkJIGludCBtaXJyb3JfbnVtLCB1bnNpZ25lZCBsb25nIGJpb19mbGFncyk7CisKK3N0cnVjdCBidHJmc19jb21wcmVzc19vcCB7CisJc3RydWN0IGxpc3RfaGVhZCAqKCphbGxvY193b3Jrc3BhY2UpKHZvaWQpOworCisJdm9pZCAoKmZyZWVfd29ya3NwYWNlKShzdHJ1Y3QgbGlzdF9oZWFkICp3b3Jrc3BhY2UpOworCisJaW50ICgqY29tcHJlc3NfcGFnZXMpKHN0cnVjdCBsaXN0X2hlYWQgKndvcmtzcGFjZSwKKwkJCSAgICAgIHN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nLAorCQkJICAgICAgdTY0IHN0YXJ0LCB1bnNpZ25lZCBsb25nIGxlbiwKKwkJCSAgICAgIHN0cnVjdCBwYWdlICoqcGFnZXMsCisJCQkgICAgICB1bnNpZ25lZCBsb25nIG5yX2Rlc3RfcGFnZXMsCisJCQkgICAgICB1bnNpZ25lZCBsb25nICpvdXRfcGFnZXMsCisJCQkgICAgICB1bnNpZ25lZCBsb25nICp0b3RhbF9pbiwKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgKnRvdGFsX291dCwKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgbWF4X291dCk7CisKKwlpbnQgKCpkZWNvbXByZXNzX2Jpb3ZlYykoc3RydWN0IGxpc3RfaGVhZCAqd29ya3NwYWNlLAorCQkJCSBzdHJ1Y3QgcGFnZSAqKnBhZ2VzX2luLAorCQkJCSB1NjQgZGlza19zdGFydCwKKwkJCQkgc3RydWN0IGJpb192ZWMgKmJ2ZWMsCisJCQkJIGludCB2Y250LAorCQkJCSBzaXplX3Qgc3JjbGVuKTsKKworCWludCAoKmRlY29tcHJlc3MpKHN0cnVjdCBsaXN0X2hlYWQgKndvcmtzcGFjZSwKKwkJCSAgdW5zaWduZWQgY2hhciAqZGF0YV9pbiwKKwkJCSAgc3RydWN0IHBhZ2UgKmRlc3RfcGFnZSwKKwkJCSAgdW5zaWduZWQgbG9uZyBzdGFydF9ieXRlLAorCQkJICBzaXplX3Qgc3JjbGVuLCBzaXplX3QgZGVzdGxlbik7Cit9OworCitleHRlcm4gc3RydWN0IGJ0cmZzX2NvbXByZXNzX29wIGJ0cmZzX3psaWJfY29tcHJlc3M7CitleHRlcm4gc3RydWN0IGJ0cmZzX2NvbXByZXNzX29wIGJ0cmZzX2x6b19jb21wcmVzczsKKwogI2VuZGlmCmRpZmYgLS1naXQgYS9mcy9idHJmcy9jdHJlZS5jIGIvZnMvYnRyZnMvY3RyZWUuYwppbmRleCA5YWMxNzE1Li5iNWJhZmYwIDEwMDY0NAotLS0gYS9mcy9idHJmcy9jdHJlZS5jCisrKyBiL2ZzL2J0cmZzL2N0cmVlLmMKQEAgLTEwNSw2ICsxMDUsOCBAQAogLyogdGhpcyBhbHNvIHJlbGVhc2VzIHRoZSBwYXRoICovCiB2b2lkIGJ0cmZzX2ZyZWVfcGF0aChzdHJ1Y3QgYnRyZnNfcGF0aCAqcCkKIHsKKwlpZiAoIXApCisJCXJldHVybjsKIAlidHJmc19yZWxlYXNlX3BhdGgoTlVMTCwgcCk7CiAJa21lbV9jYWNoZV9mcmVlKGJ0cmZzX3BhdGhfY2FjaGVwLCBwKTsKIH0KQEAgLTI1MTQsNiArMjUxNiw5IEBACiAJYnRyZnNfYXNzZXJ0X3RyZWVfbG9ja2VkKHBhdGgtPm5vZGVzWzFdKTsKIAogCXJpZ2h0ID0gcmVhZF9ub2RlX3Nsb3Qocm9vdCwgdXBwZXIsIHNsb3QgKyAxKTsKKwlpZiAocmlnaHQgPT0gTlVMTCkKKwkJcmV0dXJuIDE7CisKIAlidHJmc190cmVlX2xvY2socmlnaHQpOwogCWJ0cmZzX3NldF9sb2NrX2Jsb2NraW5nKHJpZ2h0KTsKIApAQCAtMjc2NCw2ICsyNzY5LDkgQEAKIAlidHJmc19hc3NlcnRfdHJlZV9sb2NrZWQocGF0aC0+bm9kZXNbMV0pOwogCiAJbGVmdCA9IHJlYWRfbm9kZV9zbG90KHJvb3QsIHBhdGgtPm5vZGVzWzFdLCBzbG90IC0gMSk7CisJaWYgKGxlZnQgPT0gTlVMTCkKKwkJcmV0dXJuIDE7CisKIAlidHJmc190cmVlX2xvY2sobGVmdCk7CiAJYnRyZnNfc2V0X2xvY2tfYmxvY2tpbmcobGVmdCk7CiAKZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL2N0cmVlLmggYi9mcy9idHJmcy9jdHJlZS5oCmluZGV4IGExNDJkMjAuLjJjOThiM2EgMTAwNjQ0Ci0tLSBhL2ZzL2J0cmZzL2N0cmVlLmgKKysrIGIvZnMvYnRyZnMvY3RyZWUuaApAQCAtMjcsNiArMjcsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2JhY2tpbmctZGV2Lmg+CiAjaW5jbHVkZSA8bGludXgvd2FpdC5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9rb2JqZWN0Lmg+CiAjaW5jbHVkZSA8YXNtL2ttYXBfdHlwZXMuaD4KICNpbmNsdWRlICJleHRlbnRfaW8uaCIKICNpbmNsdWRlICJleHRlbnRfbWFwLmgiCkBAIC0yOTQsNiArMjk1LDE0IEBACiAjZGVmaW5lIEJUUkZTX0ZTSURfU0laRSAxNgogI2RlZmluZSBCVFJGU19IRUFERVJfRkxBR19XUklUVEVOCSgxVUxMIDw8IDApCiAjZGVmaW5lIEJUUkZTX0hFQURFUl9GTEFHX1JFTE9DCQkoMVVMTCA8PCAxKQorCisvKgorICogRmlsZSBzeXN0ZW0gc3RhdGVzCisgKi8KKworLyogRXJyb3JzIGRldGVjdGVkICovCisjZGVmaW5lIEJUUkZTX1NVUEVSX0ZMQUdfRVJST1IJCSgxVUxMIDw8IDIpCisKICNkZWZpbmUgQlRSRlNfU1VQRVJfRkxBR19TRUVESU5HCSgxVUxMIDw8IDMyKQogI2RlZmluZSBCVFJGU19TVVBFUl9GTEFHX01FVEFEVU1QCSgxVUxMIDw8IDMzKQogCkBAIC0zOTgsMTMgKzQwNywxNSBAQAogI2RlZmluZSBCVFJGU19GRUFUVVJFX0lOQ09NUEFUX01JWEVEX0JBQ0tSRUYJKDFVTEwgPDwgMCkKICNkZWZpbmUgQlRSRlNfRkVBVFVSRV9JTkNPTVBBVF9ERUZBVUxUX1NVQlZPTAkoMVVMTCA8PCAxKQogI2RlZmluZSBCVFJGU19GRUFUVVJFX0lOQ09NUEFUX01JWEVEX0dST1VQUwkoMVVMTCA8PCAyKQorI2RlZmluZSBCVFJGU19GRUFUVVJFX0lOQ09NUEFUX0NPTVBSRVNTX0xaTwkoMVVMTCA8PCAzKQogCiAjZGVmaW5lIEJUUkZTX0ZFQVRVUkVfQ09NUEFUX1NVUFAJCTBVTEwKICNkZWZpbmUgQlRSRlNfRkVBVFVSRV9DT01QQVRfUk9fU1VQUAkJMFVMTAogI2RlZmluZSBCVFJGU19GRUFUVVJFX0lOQ09NUEFUX1NVUFAJCQlcCiAJKEJUUkZTX0ZFQVRVUkVfSU5DT01QQVRfTUlYRURfQkFDS1JFRiB8CQlcCiAJIEJUUkZTX0ZFQVRVUkVfSU5DT01QQVRfREVGQVVMVF9TVUJWT0wgfAlcCi0JIEJUUkZTX0ZFQVRVUkVfSU5DT01QQVRfTUlYRURfR1JPVVBTKQorCSBCVFJGU19GRUFUVVJFX0lOQ09NUEFUX01JWEVEX0dST1VQUyB8CQlcCisJIEJUUkZTX0ZFQVRVUkVfSU5DT01QQVRfQ09NUFJFU1NfTFpPKQogCiAvKgogICogQSBsZWFmIGlzIGZ1bGwgb2YgaXRlbXMuIG9mZnNldCBhbmQgc2l6ZSB0ZWxsIHVzIHdoZXJlIHRvIGZpbmQKQEAgLTU1MSw5ICs1NjIsMTEgQEAKIH0gX19hdHRyaWJ1dGVfXyAoKF9fcGFja2VkX18pKTsKIAogZW51bSBidHJmc19jb21wcmVzc2lvbl90eXBlIHsKLQlCVFJGU19DT01QUkVTU19OT05FID0gMCwKLQlCVFJGU19DT01QUkVTU19aTElCID0gMSwKLQlCVFJGU19DT01QUkVTU19MQVNUID0gMiwKKwlCVFJGU19DT01QUkVTU19OT05FICA9IDAsCisJQlRSRlNfQ09NUFJFU1NfWkxJQiAgPSAxLAorCUJUUkZTX0NPTVBSRVNTX0xaTyAgID0gMiwKKwlCVFJGU19DT01QUkVTU19UWVBFUyA9IDIsCisJQlRSRlNfQ09NUFJFU1NfTEFTVCAgPSAzLAogfTsKIAogc3RydWN0IGJ0cmZzX2lub2RlX2l0ZW0gewpAQCAtNTk3LDYgKzYxMCw4IEBACiAJdTggdHlwZTsKIH0gX19hdHRyaWJ1dGVfXyAoKF9fcGFja2VkX18pKTsKIAorI2RlZmluZSBCVFJGU19ST09UX1NVQlZPTF9SRE9OTFkJKDFVTEwgPDwgMCkKKwogc3RydWN0IGJ0cmZzX3Jvb3RfaXRlbSB7CiAJc3RydWN0IGJ0cmZzX2lub2RlX2l0ZW0gaW5vZGU7CiAJX19sZTY0IGdlbmVyYXRpb247CkBAIC04OTUsNyArOTEwLDggQEAKIAkgKi8KIAl1NjQgbGFzdF90cmFuc19sb2dfZnVsbF9jb21taXQ7CiAJdTY0IG9wZW5faW9jdGxfdHJhbnM7Ci0JdW5zaWduZWQgbG9uZyBtb3VudF9vcHQ7CisJdW5zaWduZWQgbG9uZyBtb3VudF9vcHQ6MjA7CisJdW5zaWduZWQgbG9uZyBjb21wcmVzc190eXBlOjQ7CiAJdTY0IG1heF9pbmxpbmU7CiAJdTY0IGFsbG9jX3N0YXJ0OwogCXN0cnVjdCBidHJmc190cmFuc2FjdGlvbiAqcnVubmluZ190cmFuc2FjdGlvbjsKQEAgLTEwNTAsNiArMTA2Niw5IEBACiAJdW5zaWduZWQgbWV0YWRhdGFfcmF0aW87CiAKIAl2b2lkICpiZGV2X2hvbGRlcjsKKworCS8qIGZpbGVzeXN0ZW0gc3RhdGUgKi8KKwl1NjQgZnNfc3RhdGU7CiB9OwogCiAvKgpAQCAtMTg5Myw2ICsxOTEyLDExIEBACiBCVFJGU19TRVRHRVRfU1RBQ0tfRlVOQ1Mocm9vdF9sYXN0X3NuYXBzaG90LCBzdHJ1Y3QgYnRyZnNfcm9vdF9pdGVtLAogCQkJIGxhc3Rfc25hcHNob3QsIDY0KTsKIAorc3RhdGljIGlubGluZSBib29sIGJ0cmZzX3Jvb3RfcmVhZG9ubHkoc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QpCit7CisJcmV0dXJuIHJvb3QtPnJvb3RfaXRlbS5mbGFncyAmIEJUUkZTX1JPT1RfU1VCVk9MX1JET05MWTsKK30KKwogLyogc3RydWN0IGJ0cmZzX3N1cGVyX2Jsb2NrICovCiAKIEJUUkZTX1NFVEdFVF9TVEFDS19GVU5DUyhzdXBlcl9ieXRlbnIsIHN0cnVjdCBidHJmc19zdXBlcl9ibG9jaywgYnl0ZW5yLCA2NCk7CkBAIC0yMTQ1LDYgKzIxNjksNyBAQAogaW50IGJ0cmZzX3JlbW92ZV9ibG9ja19ncm91cChzdHJ1Y3QgYnRyZnNfdHJhbnNfaGFuZGxlICp0cmFucywKIAkJCSAgICAgc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QsIHU2NCBncm91cF9zdGFydCk7CiB1NjQgYnRyZnNfcmVkdWNlX2FsbG9jX3Byb2ZpbGUoc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QsIHU2NCBmbGFncyk7Cit1NjQgYnRyZnNfZ2V0X2FsbG9jX3Byb2ZpbGUoc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QsIGludCBkYXRhKTsKIHZvaWQgYnRyZnNfc2V0X2lub2RlX3NwYWNlX2luZm8oc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QsIHN0cnVjdCBpbm9kZSAqaW9uZGUpOwogdm9pZCBidHJmc19jbGVhcl9zcGFjZV9pbmZvX2Z1bGwoc3RydWN0IGJ0cmZzX2ZzX2luZm8gKmluZm8pOwogaW50IGJ0cmZzX2NoZWNrX2RhdGFfZnJlZV9zcGFjZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCB1NjQgYnl0ZXMpOwpAQCAtMjE4OCw2ICsyMjEzLDEyIEBACiBpbnQgYnRyZnNfc2V0X2Jsb2NrX2dyb3VwX3J3KHN0cnVjdCBidHJmc19yb290ICpyb290LAogCQkJICAgICBzdHJ1Y3QgYnRyZnNfYmxvY2tfZ3JvdXBfY2FjaGUgKmNhY2hlKTsKIHZvaWQgYnRyZnNfcHV0X2Jsb2NrX2dyb3VwX2NhY2hlKHN0cnVjdCBidHJmc19mc19pbmZvICppbmZvKTsKK3U2NCBidHJmc19hY2NvdW50X3JvX2Jsb2NrX2dyb3Vwc19mcmVlX3NwYWNlKHN0cnVjdCBidHJmc19zcGFjZV9pbmZvICpzaW5mbyk7CitpbnQgYnRyZnNfZXJyb3JfdW5waW5fZXh0ZW50X3JhbmdlKHN0cnVjdCBidHJmc19yb290ICpyb290LAorCQkJCSAgIHU2NCBzdGFydCwgdTY0IGVuZCk7CitpbnQgYnRyZnNfZXJyb3JfZGlzY2FyZF9leHRlbnQoc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QsIHU2NCBieXRlbnIsCisJCQkgICAgICAgdTY0IG51bV9ieXRlcyk7CisKIC8qIGN0cmVlLmMgKi8KIGludCBidHJmc19iaW5fc2VhcmNoKHN0cnVjdCBleHRlbnRfYnVmZmVyICplYiwgc3RydWN0IGJ0cmZzX2tleSAqa2V5LAogCQkgICAgIGludCBsZXZlbCwgaW50ICpzbG90KTsKQEAgLTI1NDEsNiArMjU3MiwxNCBAQAogLyogc3VwZXIuYyAqLwogaW50IGJ0cmZzX3BhcnNlX29wdGlvbnMoc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QsIGNoYXIgKm9wdGlvbnMpOwogaW50IGJ0cmZzX3N5bmNfZnMoc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHdhaXQpOwordm9pZCBfX2J0cmZzX3N0ZF9lcnJvcihzdHJ1Y3QgYnRyZnNfZnNfaW5mbyAqZnNfaW5mbywgY29uc3QgY2hhciAqZnVuY3Rpb24sCisJCSAgICAgdW5zaWduZWQgaW50IGxpbmUsIGludCBlcnJubyk7CisKKyNkZWZpbmUgYnRyZnNfc3RkX2Vycm9yKGZzX2luZm8sIGVycm5vKQkJCQlcCitkbyB7CQkJCQkJCQlcCisJaWYgKChlcnJubykpCQkJCQkJXAorCQlfX2J0cmZzX3N0ZF9lcnJvcigoZnNfaW5mbyksIF9fZnVuY19fLCBfX0xJTkVfXywgKGVycm5vKSk7XAorfSB3aGlsZSAoMCkKIAogLyogYWNsLmMgKi8KICNpZmRlZiBDT05GSUdfQlRSRlNfRlNfUE9TSVhfQUNMCmRpZmYgLS1naXQgYS9mcy9idHJmcy9kaXNrLWlvLmMgYi9mcy9idHJmcy9kaXNrLWlvLmMKaW5kZXggNTFkMmU0ZC4uZmRjZTg3OSAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvZGlzay1pby5jCisrKyBiL2ZzL2J0cmZzL2Rpc2staW8uYwpAQCAtNDQsNiArNDQsMjAgQEAKIHN0YXRpYyBzdHJ1Y3QgZXh0ZW50X2lvX29wcyBidHJlZV9leHRlbnRfaW9fb3BzOwogc3RhdGljIHZvaWQgZW5kX3dvcmtxdWV1ZV9mbihzdHJ1Y3QgYnRyZnNfd29yayAqd29yayk7CiBzdGF0aWMgdm9pZCBmcmVlX2ZzX3Jvb3Qoc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QpOworc3RhdGljIHZvaWQgYnRyZnNfY2hlY2tfc3VwZXJfdmFsaWQoc3RydWN0IGJ0cmZzX2ZzX2luZm8gKmZzX2luZm8sCisJCQkJICAgIGludCByZWFkX29ubHkpOworc3RhdGljIGludCBidHJmc19kZXN0cm95X29yZGVyZWRfb3BlcmF0aW9ucyhzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCk7CitzdGF0aWMgaW50IGJ0cmZzX2Rlc3Ryb3lfb3JkZXJlZF9leHRlbnRzKHN0cnVjdCBidHJmc19yb290ICpyb290KTsKK3N0YXRpYyBpbnQgYnRyZnNfZGVzdHJveV9kZWxheWVkX3JlZnMoc3RydWN0IGJ0cmZzX3RyYW5zYWN0aW9uICp0cmFucywKKwkJCQkgICAgICBzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCk7CitzdGF0aWMgaW50IGJ0cmZzX2Rlc3Ryb3lfcGVuZGluZ19zbmFwc2hvdHMoc3RydWN0IGJ0cmZzX3RyYW5zYWN0aW9uICp0KTsKK3N0YXRpYyBpbnQgYnRyZnNfZGVzdHJveV9kZWxhbGxvY19pbm9kZXMoc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QpOworc3RhdGljIGludCBidHJmc19kZXN0cm95X21hcmtlZF9leHRlbnRzKHN0cnVjdCBidHJmc19yb290ICpyb290LAorCQkJCQlzdHJ1Y3QgZXh0ZW50X2lvX3RyZWUgKmRpcnR5X3BhZ2VzLAorCQkJCQlpbnQgbWFyayk7CitzdGF0aWMgaW50IGJ0cmZzX2Rlc3Ryb3lfcGlubmVkX2V4dGVudChzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCwKKwkJCQkgICAgICAgc3RydWN0IGV4dGVudF9pb190cmVlICpwaW5uZWRfZXh0ZW50cyk7CitzdGF0aWMgaW50IGJ0cmZzX2NsZWFudXBfdHJhbnNhY3Rpb24oc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QpOwogCiAvKgogICogZW5kX2lvX3dxIHN0cnVjdHMgYXJlIHVzZWQgdG8gZG8gcHJvY2Vzc2luZyBpbiB0YXNrIGNvbnRleHQgd2hlbiBhbiBJTyBpcwpAQCAtMzUzLDYgKzM2NywxMCBAQAogCVdBUk5fT04obGVuID09IDApOwogCiAJZWIgPSBhbGxvY19leHRlbnRfYnVmZmVyKHRyZWUsIHN0YXJ0LCBsZW4sIHBhZ2UsIEdGUF9OT0ZTKTsKKwlpZiAoZWIgPT0gTlVMTCkgeworCQlXQVJOX09OKDEpOworCQlnb3RvIG91dDsKKwl9CiAJcmV0ID0gYnRyZWVfcmVhZF9leHRlbnRfYnVmZmVyX3BhZ2VzKHJvb3QsIGViLCBzdGFydCArIFBBR0VfQ0FDSEVfU0laRSwKIAkJCQkJICAgICBidHJmc19oZWFkZXJfZ2VuZXJhdGlvbihlYikpOwogCUJVR19PTihyZXQpOwpAQCAtNDI3LDYgKzQ0NSwxMCBAQAogCVdBUk5fT04obGVuID09IDApOwogCiAJZWIgPSBhbGxvY19leHRlbnRfYnVmZmVyKHRyZWUsIHN0YXJ0LCBsZW4sIHBhZ2UsIEdGUF9OT0ZTKTsKKwlpZiAoZWIgPT0gTlVMTCkgeworCQlyZXQgPSAtRUlPOworCQlnb3RvIG91dDsKKwl9CiAKIAlmb3VuZF9zdGFydCA9IGJ0cmZzX2hlYWRlcl9ieXRlbnIoZWIpOwogCWlmIChmb3VuZF9zdGFydCAhPSBzdGFydCkgewpAQCAtMTE0NSw2ICsxMTY3LDcgQEAKIAl9CiAJYnRyZnNfZnJlZV9wYXRoKHBhdGgpOwogCWlmIChyZXQpIHsKKwkJa2ZyZWUocm9vdCk7CiAJCWlmIChyZXQgPiAwKQogCQkJcmV0ID0gLUVOT0VOVDsKIAkJcmV0dXJuIEVSUl9QVFIocmV0KTsKQEAgLTE1MjcsNiArMTU1MCw3IEBACiAJCXNwaW5fdW5sb2NrKCZyb290LT5mc19pbmZvLT5uZXdfdHJhbnNfbG9jayk7CiAKIAkJdHJhbnMgPSBidHJmc19qb2luX3RyYW5zYWN0aW9uKHJvb3QsIDEpOworCQlCVUdfT04oSVNfRVJSKHRyYW5zKSk7CiAJCWlmICh0cmFuc2lkID09IHRyYW5zLT50cmFuc2lkKSB7CiAJCQlyZXQgPSBidHJmc19jb21taXRfdHJhbnNhY3Rpb24odHJhbnMsIHJvb3QpOwogCQkJQlVHX09OKHJldCk7CkBAIC0xNzEzLDggKzE3MzcsMTAgQEAKIAkJICAgICBmc19pbmZvLCBCVFJGU19ST09UX1RSRUVfT0JKRUNUSUQpOwogCiAJYmggPSBidHJmc19yZWFkX2Rldl9zdXBlcihmc19kZXZpY2VzLT5sYXRlc3RfYmRldik7Ci0JaWYgKCFiaCkKKwlpZiAoIWJoKSB7CisJCWVyciA9IC1FSU5WQUw7CiAJCWdvdG8gZmFpbF9pcHV0OworCX0KIAogCW1lbWNweSgmZnNfaW5mby0+c3VwZXJfY29weSwgYmgtPmJfZGF0YSwgc2l6ZW9mKGZzX2luZm8tPnN1cGVyX2NvcHkpKTsKIAltZW1jcHkoJmZzX2luZm8tPnN1cGVyX2Zvcl9jb21taXQsICZmc19pbmZvLT5zdXBlcl9jb3B5LApAQCAtMTcyNyw2ICsxNzUzLDExIEBACiAJaWYgKCFidHJmc19zdXBlcl9yb290KGRpc2tfc3VwZXIpKQogCQlnb3RvIGZhaWxfaXB1dDsKIAorCS8qIGNoZWNrIEZTIHN0YXRlLCB3aGV0aGVyIEZTIGlzIGJyb2tlbi4gKi8KKwlmc19pbmZvLT5mc19zdGF0ZSB8PSBidHJmc19zdXBlcl9mbGFncyhkaXNrX3N1cGVyKTsKKworCWJ0cmZzX2NoZWNrX3N1cGVyX3ZhbGlkKGZzX2luZm8sIHNiLT5zX2ZsYWdzICYgTVNfUkRPTkxZKTsKKwogCXJldCA9IGJ0cmZzX3BhcnNlX29wdGlvbnModHJlZV9yb290LCBvcHRpb25zKTsKIAlpZiAocmV0KSB7CiAJCWVyciA9IHJldDsKQEAgLTE3NDQsMTAgKzE3NzUsMTAgQEAKIAl9CiAKIAlmZWF0dXJlcyA9IGJ0cmZzX3N1cGVyX2luY29tcGF0X2ZsYWdzKGRpc2tfc3VwZXIpOwotCWlmICghKGZlYXR1cmVzICYgQlRSRlNfRkVBVFVSRV9JTkNPTVBBVF9NSVhFRF9CQUNLUkVGKSkgewotCQlmZWF0dXJlcyB8PSBCVFJGU19GRUFUVVJFX0lOQ09NUEFUX01JWEVEX0JBQ0tSRUY7Ci0JCWJ0cmZzX3NldF9zdXBlcl9pbmNvbXBhdF9mbGFncyhkaXNrX3N1cGVyLCBmZWF0dXJlcyk7Ci0JfQorCWZlYXR1cmVzIHw9IEJUUkZTX0ZFQVRVUkVfSU5DT01QQVRfTUlYRURfQkFDS1JFRjsKKwlpZiAodHJlZV9yb290LT5mc19pbmZvLT5jb21wcmVzc190eXBlICYgQlRSRlNfQ09NUFJFU1NfTFpPKQorCQlmZWF0dXJlcyB8PSBCVFJGU19GRUFUVVJFX0lOQ09NUEFUX0NPTVBSRVNTX0xaTzsKKwlidHJmc19zZXRfc3VwZXJfaW5jb21wYXRfZmxhZ3MoZGlza19zdXBlciwgZmVhdHVyZXMpOwogCiAJZmVhdHVyZXMgPSBidHJmc19zdXBlcl9jb21wYXRfcm9fZmxhZ3MoZGlza19zdXBlcikgJgogCQl+QlRSRlNfRkVBVFVSRV9DT01QQVRfUk9fU1VQUDsKQEAgLTE5NTcsNyArMTk4OCw5IEBACiAJCWJ0cmZzX3NldF9vcHQoZnNfaW5mby0+bW91bnRfb3B0LCBTU0QpOwogCX0KIAotCWlmIChidHJmc19zdXBlcl9sb2dfcm9vdChkaXNrX3N1cGVyKSAhPSAwKSB7CisJLyogZG8gbm90IG1ha2UgZGlzayBjaGFuZ2VzIGluIGJyb2tlbiBGUyAqLworCWlmIChidHJmc19zdXBlcl9sb2dfcm9vdChkaXNrX3N1cGVyKSAhPSAwICYmCisJICAgICEoZnNfaW5mby0+ZnNfc3RhdGUgJiBCVFJGU19TVVBFUl9GTEFHX0VSUk9SKSkgewogCQl1NjQgYnl0ZW5yID0gYnRyZnNfc3VwZXJfbG9nX3Jvb3QoZGlza19zdXBlcik7CiAKIAkJaWYgKGZzX2RldmljZXMtPnJ3X2RldmljZXMgPT0gMCkgewpAQCAtMjQyMSwxMCArMjQ1NCwxNCBAQAogCXVwX3dyaXRlKCZyb290LT5mc19pbmZvLT5jbGVhbnVwX3dvcmtfc2VtKTsKIAogCXRyYW5zID0gYnRyZnNfam9pbl90cmFuc2FjdGlvbihyb290LCAxKTsKKwlpZiAoSVNfRVJSKHRyYW5zKSkKKwkJcmV0dXJuIFBUUl9FUlIodHJhbnMpOwogCXJldCA9IGJ0cmZzX2NvbW1pdF90cmFuc2FjdGlvbih0cmFucywgcm9vdCk7CiAJQlVHX09OKHJldCk7CiAJLyogcnVuIGNvbW1pdCBhZ2FpbiB0byBkcm9wIHRoZSBvcmlnaW5hbCBzbmFwc2hvdCAqLwogCXRyYW5zID0gYnRyZnNfam9pbl90cmFuc2FjdGlvbihyb290LCAxKTsKKwlpZiAoSVNfRVJSKHRyYW5zKSkKKwkJcmV0dXJuIFBUUl9FUlIodHJhbnMpOwogCWJ0cmZzX2NvbW1pdF90cmFuc2FjdGlvbih0cmFucywgcm9vdCk7CiAJcmV0ID0gYnRyZnNfd3JpdGVfYW5kX3dhaXRfdHJhbnNhY3Rpb24oTlVMTCwgcm9vdCk7CiAJQlVHX09OKHJldCk7CkBAIC0yNDQyLDggKzI0NzksMjggQEAKIAlzbXBfbWIoKTsKIAogCWJ0cmZzX3B1dF9ibG9ja19ncm91cF9jYWNoZShmc19pbmZvKTsKKworCS8qCisJICogSGVyZSBjb21lIDIgc2l0dWF0aW9ucyB3aGVuIGJ0cmZzIGlzIGJyb2tlbiB0byBmbGlwIHJlYWRvbmx5OgorCSAqCisJICogMS4gd2hlbiBidHJmcyBmbGlwcyByZWFkb25seSBzb21ld2hlcmUgZWxzZSBiZWZvcmUKKwkgKiBidHJmc19jb21taXRfc3VwZXIsIHNiLT5zX2ZsYWdzIGhhcyBNU19SRE9OTFkgZmxhZywKKwkgKiBhbmQgYnRyZnMgd2lsbCBza2lwIHRvIHdyaXRlIHNiIGRpcmVjdGx5IHRvIGtlZXAKKwkgKiBFUlJPUiBzdGF0ZSBvbiBkaXNrLgorCSAqCisJICogMi4gd2hlbiBidHJmcyBmbGlwcyByZWFkb25seSBqdXN0IGluIGJ0cmZzX2NvbW1pdF9zdXBlciwKKwkgKiBhbmQgaW4gc3VjaCBjYXNlLCBidHJmcyBjYW5ubm90IHdyaXRlIHNiIHZpYSBidHJmc19jb21taXRfc3VwZXIsCisJICogYW5kIHNpbmNlIGZzX3N0YXRlIGhhcyBiZWVuIHNldCBCVFJGU19TVVBFUl9GTEFHX0VSUk9SIGZsYWcsCisJICogYnRyZnMgd2lsbCBjbGVhbnVwIGFsbCBGUyByZXNvdXJjZXMgZmlyc3QgYW5kIHdyaXRlIHNiIHRoZW4uCisJICovCiAJaWYgKCEoZnNfaW5mby0+c2ItPnNfZmxhZ3MgJiBNU19SRE9OTFkpKSB7Ci0JCXJldCA9ICBidHJmc19jb21taXRfc3VwZXIocm9vdCk7CisJCXJldCA9IGJ0cmZzX2NvbW1pdF9zdXBlcihyb290KTsKKwkJaWYgKHJldCkKKwkJCXByaW50ayhLRVJOX0VSUiAiYnRyZnM6IGNvbW1pdCBzdXBlciByZXQgJWRcbiIsIHJldCk7CisJfQorCisJaWYgKGZzX2luZm8tPmZzX3N0YXRlICYgQlRSRlNfU1VQRVJfRkxBR19FUlJPUikgeworCQlyZXQgPSBidHJmc19lcnJvcl9jb21taXRfc3VwZXIocm9vdCk7CiAJCWlmIChyZXQpCiAJCQlwcmludGsoS0VSTl9FUlIgImJ0cmZzOiBjb21taXQgc3VwZXIgcmV0ICVkXG4iLCByZXQpOwogCX0KQEAgLTI1MDIsNiArMjU1OSw4IEBACiAJa2ZyZWUoZnNfaW5mby0+Y2h1bmtfcm9vdCk7CiAJa2ZyZWUoZnNfaW5mby0+ZGV2X3Jvb3QpOwogCWtmcmVlKGZzX2luZm8tPmNzdW1fcm9vdCk7CisJa2ZyZWUoZnNfaW5mbyk7CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtMjYxOSw2ICsyNjc4LDM1MiBAQAogCXJldHVybiAwOwogfQogCitzdGF0aWMgdm9pZCBidHJmc19jaGVja19zdXBlcl92YWxpZChzdHJ1Y3QgYnRyZnNfZnNfaW5mbyAqZnNfaW5mbywKKwkJCSAgICAgIGludCByZWFkX29ubHkpCit7CisJaWYgKHJlYWRfb25seSkKKwkJcmV0dXJuOworCisJaWYgKGZzX2luZm8tPmZzX3N0YXRlICYgQlRSRlNfU1VQRVJfRkxBR19FUlJPUikKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAid2FybmluZzogbW91bnQgZnMgd2l0aCBlcnJvcnMsICIKKwkJICAgICAgICJydW5uaW5nIGJ0cmZzY2sgaXMgcmVjb21tZW5kZWRcbiIpOworfQorCitpbnQgYnRyZnNfZXJyb3JfY29tbWl0X3N1cGVyKHN0cnVjdCBidHJmc19yb290ICpyb290KQoreworCWludCByZXQ7CisKKwltdXRleF9sb2NrKCZyb290LT5mc19pbmZvLT5jbGVhbmVyX211dGV4KTsKKwlidHJmc19ydW5fZGVsYXllZF9pcHV0cyhyb290KTsKKwltdXRleF91bmxvY2soJnJvb3QtPmZzX2luZm8tPmNsZWFuZXJfbXV0ZXgpOworCisJZG93bl93cml0ZSgmcm9vdC0+ZnNfaW5mby0+Y2xlYW51cF93b3JrX3NlbSk7CisJdXBfd3JpdGUoJnJvb3QtPmZzX2luZm8tPmNsZWFudXBfd29ya19zZW0pOworCisJLyogY2xlYW51cCBGUyB2aWEgdHJhbnNhY3Rpb24gKi8KKwlidHJmc19jbGVhbnVwX3RyYW5zYWN0aW9uKHJvb3QpOworCisJcmV0ID0gd3JpdGVfY3RyZWVfc3VwZXIoTlVMTCwgcm9vdCwgMCk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGJ0cmZzX2Rlc3Ryb3lfb3JkZXJlZF9vcGVyYXRpb25zKHN0cnVjdCBidHJmc19yb290ICpyb290KQoreworCXN0cnVjdCBidHJmc19pbm9kZSAqYnRyZnNfaW5vZGU7CisJc3RydWN0IGxpc3RfaGVhZCBzcGxpY2U7CisKKwlJTklUX0xJU1RfSEVBRCgmc3BsaWNlKTsKKworCW11dGV4X2xvY2soJnJvb3QtPmZzX2luZm8tPm9yZGVyZWRfb3BlcmF0aW9uc19tdXRleCk7CisJc3Bpbl9sb2NrKCZyb290LT5mc19pbmZvLT5vcmRlcmVkX2V4dGVudF9sb2NrKTsKKworCWxpc3Rfc3BsaWNlX2luaXQoJnJvb3QtPmZzX2luZm8tPm9yZGVyZWRfb3BlcmF0aW9ucywgJnNwbGljZSk7CisJd2hpbGUgKCFsaXN0X2VtcHR5KCZzcGxpY2UpKSB7CisJCWJ0cmZzX2lub2RlID0gbGlzdF9lbnRyeShzcGxpY2UubmV4dCwgc3RydWN0IGJ0cmZzX2lub2RlLAorCQkJCQkgb3JkZXJlZF9vcGVyYXRpb25zKTsKKworCQlsaXN0X2RlbF9pbml0KCZidHJmc19pbm9kZS0+b3JkZXJlZF9vcGVyYXRpb25zKTsKKworCQlidHJmc19pbnZhbGlkYXRlX2lub2RlcyhidHJmc19pbm9kZS0+cm9vdCk7CisJfQorCisJc3Bpbl91bmxvY2soJnJvb3QtPmZzX2luZm8tPm9yZGVyZWRfZXh0ZW50X2xvY2spOworCW11dGV4X3VubG9jaygmcm9vdC0+ZnNfaW5mby0+b3JkZXJlZF9vcGVyYXRpb25zX211dGV4KTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJ0cmZzX2Rlc3Ryb3lfb3JkZXJlZF9leHRlbnRzKHN0cnVjdCBidHJmc19yb290ICpyb290KQoreworCXN0cnVjdCBsaXN0X2hlYWQgc3BsaWNlOworCXN0cnVjdCBidHJmc19vcmRlcmVkX2V4dGVudCAqb3JkZXJlZDsKKwlzdHJ1Y3QgaW5vZGUgKmlub2RlOworCisJSU5JVF9MSVNUX0hFQUQoJnNwbGljZSk7CisKKwlzcGluX2xvY2soJnJvb3QtPmZzX2luZm8tPm9yZGVyZWRfZXh0ZW50X2xvY2spOworCisJbGlzdF9zcGxpY2VfaW5pdCgmcm9vdC0+ZnNfaW5mby0+b3JkZXJlZF9leHRlbnRzLCAmc3BsaWNlKTsKKwl3aGlsZSAoIWxpc3RfZW1wdHkoJnNwbGljZSkpIHsKKwkJb3JkZXJlZCA9IGxpc3RfZW50cnkoc3BsaWNlLm5leHQsIHN0cnVjdCBidHJmc19vcmRlcmVkX2V4dGVudCwKKwkJCQkgICAgIHJvb3RfZXh0ZW50X2xpc3QpOworCisJCWxpc3RfZGVsX2luaXQoJm9yZGVyZWQtPnJvb3RfZXh0ZW50X2xpc3QpOworCQlhdG9taWNfaW5jKCZvcmRlcmVkLT5yZWZzKTsKKworCQkvKiB0aGUgaW5vZGUgbWF5IGJlIGdldHRpbmcgZnJlZWQgKGluIHN5c191bmxpbmsgcGF0aCkuICovCisJCWlub2RlID0gaWdyYWIob3JkZXJlZC0+aW5vZGUpOworCisJCXNwaW5fdW5sb2NrKCZyb290LT5mc19pbmZvLT5vcmRlcmVkX2V4dGVudF9sb2NrKTsKKwkJaWYgKGlub2RlKQorCQkJaXB1dChpbm9kZSk7CisKKwkJYXRvbWljX3NldCgmb3JkZXJlZC0+cmVmcywgMSk7CisJCWJ0cmZzX3B1dF9vcmRlcmVkX2V4dGVudChvcmRlcmVkKTsKKworCQlzcGluX2xvY2soJnJvb3QtPmZzX2luZm8tPm9yZGVyZWRfZXh0ZW50X2xvY2spOworCX0KKworCXNwaW5fdW5sb2NrKCZyb290LT5mc19pbmZvLT5vcmRlcmVkX2V4dGVudF9sb2NrKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJ0cmZzX2Rlc3Ryb3lfZGVsYXllZF9yZWZzKHN0cnVjdCBidHJmc190cmFuc2FjdGlvbiAqdHJhbnMsCisJCQkJICAgICAgc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QpCit7CisJc3RydWN0IHJiX25vZGUgKm5vZGU7CisJc3RydWN0IGJ0cmZzX2RlbGF5ZWRfcmVmX3Jvb3QgKmRlbGF5ZWRfcmVmczsKKwlzdHJ1Y3QgYnRyZnNfZGVsYXllZF9yZWZfbm9kZSAqcmVmOworCWludCByZXQgPSAwOworCisJZGVsYXllZF9yZWZzID0gJnRyYW5zLT5kZWxheWVkX3JlZnM7CisKKwlzcGluX2xvY2soJmRlbGF5ZWRfcmVmcy0+bG9jayk7CisJaWYgKGRlbGF5ZWRfcmVmcy0+bnVtX2VudHJpZXMgPT0gMCkgeworCQlwcmludGsoS0VSTl9JTkZPICJkZWxheWVkX3JlZnMgaGFzIE5PIGVudHJ5XG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlub2RlID0gcmJfZmlyc3QoJmRlbGF5ZWRfcmVmcy0+cm9vdCk7CisJd2hpbGUgKG5vZGUpIHsKKwkJcmVmID0gcmJfZW50cnkobm9kZSwgc3RydWN0IGJ0cmZzX2RlbGF5ZWRfcmVmX25vZGUsIHJiX25vZGUpOworCQlub2RlID0gcmJfbmV4dChub2RlKTsKKworCQlyZWYtPmluX3RyZWUgPSAwOworCQlyYl9lcmFzZSgmcmVmLT5yYl9ub2RlLCAmZGVsYXllZF9yZWZzLT5yb290KTsKKwkJZGVsYXllZF9yZWZzLT5udW1fZW50cmllcy0tOworCisJCWF0b21pY19zZXQoJnJlZi0+cmVmcywgMSk7CisJCWlmIChidHJmc19kZWxheWVkX3JlZl9pc19oZWFkKHJlZikpIHsKKwkJCXN0cnVjdCBidHJmc19kZWxheWVkX3JlZl9oZWFkICpoZWFkOworCisJCQloZWFkID0gYnRyZnNfZGVsYXllZF9ub2RlX3RvX2hlYWQocmVmKTsKKwkJCW11dGV4X2xvY2soJmhlYWQtPm11dGV4KTsKKwkJCWtmcmVlKGhlYWQtPmV4dGVudF9vcCk7CisJCQlkZWxheWVkX3JlZnMtPm51bV9oZWFkcy0tOworCQkJaWYgKGxpc3RfZW1wdHkoJmhlYWQtPmNsdXN0ZXIpKQorCQkJCWRlbGF5ZWRfcmVmcy0+bnVtX2hlYWRzX3JlYWR5LS07CisJCQlsaXN0X2RlbF9pbml0KCZoZWFkLT5jbHVzdGVyKTsKKwkJCW11dGV4X3VubG9jaygmaGVhZC0+bXV0ZXgpOworCQl9CisKKwkJc3Bpbl91bmxvY2soJmRlbGF5ZWRfcmVmcy0+bG9jayk7CisJCWJ0cmZzX3B1dF9kZWxheWVkX3JlZihyZWYpOworCisJCWNvbmRfcmVzY2hlZCgpOworCQlzcGluX2xvY2soJmRlbGF5ZWRfcmVmcy0+bG9jayk7CisJfQorCisJc3Bpbl91bmxvY2soJmRlbGF5ZWRfcmVmcy0+bG9jayk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGJ0cmZzX2Rlc3Ryb3lfcGVuZGluZ19zbmFwc2hvdHMoc3RydWN0IGJ0cmZzX3RyYW5zYWN0aW9uICp0KQoreworCXN0cnVjdCBidHJmc19wZW5kaW5nX3NuYXBzaG90ICpzbmFwc2hvdDsKKwlzdHJ1Y3QgbGlzdF9oZWFkIHNwbGljZTsKKworCUlOSVRfTElTVF9IRUFEKCZzcGxpY2UpOworCisJbGlzdF9zcGxpY2VfaW5pdCgmdC0+cGVuZGluZ19zbmFwc2hvdHMsICZzcGxpY2UpOworCisJd2hpbGUgKCFsaXN0X2VtcHR5KCZzcGxpY2UpKSB7CisJCXNuYXBzaG90ID0gbGlzdF9lbnRyeShzcGxpY2UubmV4dCwKKwkJCQkgICAgICBzdHJ1Y3QgYnRyZnNfcGVuZGluZ19zbmFwc2hvdCwKKwkJCQkgICAgICBsaXN0KTsKKworCQlsaXN0X2RlbF9pbml0KCZzbmFwc2hvdC0+bGlzdCk7CisKKwkJa2ZyZWUoc25hcHNob3QpOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJ0cmZzX2Rlc3Ryb3lfZGVsYWxsb2NfaW5vZGVzKHN0cnVjdCBidHJmc19yb290ICpyb290KQoreworCXN0cnVjdCBidHJmc19pbm9kZSAqYnRyZnNfaW5vZGU7CisJc3RydWN0IGxpc3RfaGVhZCBzcGxpY2U7CisKKwlJTklUX0xJU1RfSEVBRCgmc3BsaWNlKTsKKworCWxpc3Rfc3BsaWNlX2luaXQoJnJvb3QtPmZzX2luZm8tPmRlbGFsbG9jX2lub2RlcywgJnNwbGljZSk7CisKKwlzcGluX2xvY2soJnJvb3QtPmZzX2luZm8tPmRlbGFsbG9jX2xvY2spOworCisJd2hpbGUgKCFsaXN0X2VtcHR5KCZzcGxpY2UpKSB7CisJCWJ0cmZzX2lub2RlID0gbGlzdF9lbnRyeShzcGxpY2UubmV4dCwgc3RydWN0IGJ0cmZzX2lub2RlLAorCQkJCSAgICBkZWxhbGxvY19pbm9kZXMpOworCisJCWxpc3RfZGVsX2luaXQoJmJ0cmZzX2lub2RlLT5kZWxhbGxvY19pbm9kZXMpOworCisJCWJ0cmZzX2ludmFsaWRhdGVfaW5vZGVzKGJ0cmZzX2lub2RlLT5yb290KTsKKwl9CisKKwlzcGluX3VubG9jaygmcm9vdC0+ZnNfaW5mby0+ZGVsYWxsb2NfbG9jayk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBidHJmc19kZXN0cm95X21hcmtlZF9leHRlbnRzKHN0cnVjdCBidHJmc19yb290ICpyb290LAorCQkJCQlzdHJ1Y3QgZXh0ZW50X2lvX3RyZWUgKmRpcnR5X3BhZ2VzLAorCQkJCQlpbnQgbWFyaykKK3sKKwlpbnQgcmV0OworCXN0cnVjdCBwYWdlICpwYWdlOworCXN0cnVjdCBpbm9kZSAqYnRyZWVfaW5vZGUgPSByb290LT5mc19pbmZvLT5idHJlZV9pbm9kZTsKKwlzdHJ1Y3QgZXh0ZW50X2J1ZmZlciAqZWI7CisJdTY0IHN0YXJ0ID0gMDsKKwl1NjQgZW5kOworCXU2NCBvZmZzZXQ7CisJdW5zaWduZWQgbG9uZyBpbmRleDsKKworCXdoaWxlICgxKSB7CisJCXJldCA9IGZpbmRfZmlyc3RfZXh0ZW50X2JpdChkaXJ0eV9wYWdlcywgc3RhcnQsICZzdGFydCwgJmVuZCwKKwkJCQkJICAgIG1hcmspOworCQlpZiAocmV0KQorCQkJYnJlYWs7CisKKwkJY2xlYXJfZXh0ZW50X2JpdHMoZGlydHlfcGFnZXMsIHN0YXJ0LCBlbmQsIG1hcmssIEdGUF9OT0ZTKTsKKwkJd2hpbGUgKHN0YXJ0IDw9IGVuZCkgeworCQkJaW5kZXggPSBzdGFydCA+PiBQQUdFX0NBQ0hFX1NISUZUOworCQkJc3RhcnQgPSAodTY0KShpbmRleCArIDEpIDw8IFBBR0VfQ0FDSEVfU0hJRlQ7CisJCQlwYWdlID0gZmluZF9nZXRfcGFnZShidHJlZV9pbm9kZS0+aV9tYXBwaW5nLCBpbmRleCk7CisJCQlpZiAoIXBhZ2UpCisJCQkJY29udGludWU7CisJCQlvZmZzZXQgPSBwYWdlX29mZnNldChwYWdlKTsKKworCQkJc3Bpbl9sb2NrKCZkaXJ0eV9wYWdlcy0+YnVmZmVyX2xvY2spOworCQkJZWIgPSByYWRpeF90cmVlX2xvb2t1cCgKKwkJCSAgICAgJigmQlRSRlNfSShwYWdlLT5tYXBwaW5nLT5ob3N0KS0+aW9fdHJlZSktPmJ1ZmZlciwKKwkJCQkJICAgICAgIG9mZnNldCA+PiBQQUdFX0NBQ0hFX1NISUZUKTsKKwkJCXNwaW5fdW5sb2NrKCZkaXJ0eV9wYWdlcy0+YnVmZmVyX2xvY2spOworCQkJaWYgKGViKSB7CisJCQkJcmV0ID0gdGVzdF9hbmRfY2xlYXJfYml0KEVYVEVOVF9CVUZGRVJfRElSVFksCisJCQkJCQkJICZlYi0+YmZsYWdzKTsKKwkJCQlhdG9taWNfc2V0KCZlYi0+cmVmcywgMSk7CisJCQl9CisJCQlpZiAoUGFnZVdyaXRlYmFjayhwYWdlKSkKKwkJCQllbmRfcGFnZV93cml0ZWJhY2socGFnZSk7CisKKwkJCWxvY2tfcGFnZShwYWdlKTsKKwkJCWlmIChQYWdlRGlydHkocGFnZSkpIHsKKwkJCQljbGVhcl9wYWdlX2RpcnR5X2Zvcl9pbyhwYWdlKTsKKwkJCQlzcGluX2xvY2tfaXJxKCZwYWdlLT5tYXBwaW5nLT50cmVlX2xvY2spOworCQkJCXJhZGl4X3RyZWVfdGFnX2NsZWFyKCZwYWdlLT5tYXBwaW5nLT5wYWdlX3RyZWUsCisJCQkJCQkJcGFnZV9pbmRleChwYWdlKSwKKwkJCQkJCQlQQUdFQ0FDSEVfVEFHX0RJUlRZKTsKKwkJCQlzcGluX3VubG9ja19pcnEoJnBhZ2UtPm1hcHBpbmctPnRyZWVfbG9jayk7CisJCQl9CisKKwkJCXBhZ2UtPm1hcHBpbmctPmFfb3BzLT5pbnZhbGlkYXRlcGFnZShwYWdlLCAwKTsKKwkJCXVubG9ja19wYWdlKHBhZ2UpOworCQl9CisJfQorCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBidHJmc19kZXN0cm95X3Bpbm5lZF9leHRlbnQoc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QsCisJCQkJICAgICAgIHN0cnVjdCBleHRlbnRfaW9fdHJlZSAqcGlubmVkX2V4dGVudHMpCit7CisJc3RydWN0IGV4dGVudF9pb190cmVlICp1bnBpbjsKKwl1NjQgc3RhcnQ7CisJdTY0IGVuZDsKKwlpbnQgcmV0OworCisJdW5waW4gPSBwaW5uZWRfZXh0ZW50czsKKwl3aGlsZSAoMSkgeworCQlyZXQgPSBmaW5kX2ZpcnN0X2V4dGVudF9iaXQodW5waW4sIDAsICZzdGFydCwgJmVuZCwKKwkJCQkJICAgIEVYVEVOVF9ESVJUWSk7CisJCWlmIChyZXQpCisJCQlicmVhazsKKworCQkvKiBvcHRfZGlzY2FyZCAqLworCQlyZXQgPSBidHJmc19lcnJvcl9kaXNjYXJkX2V4dGVudChyb290LCBzdGFydCwgZW5kICsgMSAtIHN0YXJ0KTsKKworCQljbGVhcl9leHRlbnRfZGlydHkodW5waW4sIHN0YXJ0LCBlbmQsIEdGUF9OT0ZTKTsKKwkJYnRyZnNfZXJyb3JfdW5waW5fZXh0ZW50X3JhbmdlKHJvb3QsIHN0YXJ0LCBlbmQpOworCQljb25kX3Jlc2NoZWQoKTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBidHJmc19jbGVhbnVwX3RyYW5zYWN0aW9uKHN0cnVjdCBidHJmc19yb290ICpyb290KQoreworCXN0cnVjdCBidHJmc190cmFuc2FjdGlvbiAqdDsKKwlMSVNUX0hFQUQobGlzdCk7CisKKwlXQVJOX09OKDEpOworCisJbXV0ZXhfbG9jaygmcm9vdC0+ZnNfaW5mby0+dHJhbnNfbXV0ZXgpOworCW11dGV4X2xvY2soJnJvb3QtPmZzX2luZm8tPnRyYW5zYWN0aW9uX2t0aHJlYWRfbXV0ZXgpOworCisJbGlzdF9zcGxpY2VfaW5pdCgmcm9vdC0+ZnNfaW5mby0+dHJhbnNfbGlzdCwgJmxpc3QpOworCXdoaWxlICghbGlzdF9lbXB0eSgmbGlzdCkpIHsKKwkJdCA9IGxpc3RfZW50cnkobGlzdC5uZXh0LCBzdHJ1Y3QgYnRyZnNfdHJhbnNhY3Rpb24sIGxpc3QpOworCQlpZiAoIXQpCisJCQlicmVhazsKKworCQlidHJmc19kZXN0cm95X29yZGVyZWRfb3BlcmF0aW9ucyhyb290KTsKKworCQlidHJmc19kZXN0cm95X29yZGVyZWRfZXh0ZW50cyhyb290KTsKKworCQlidHJmc19kZXN0cm95X2RlbGF5ZWRfcmVmcyh0LCByb290KTsKKworCQlidHJmc19ibG9ja19yc3ZfcmVsZWFzZShyb290LAorCQkJCQkmcm9vdC0+ZnNfaW5mby0+dHJhbnNfYmxvY2tfcnN2LAorCQkJCQl0LT5kaXJ0eV9wYWdlcy5kaXJ0eV9ieXRlcyk7CisKKwkJLyogRklYTUU6IGNsZWFudXAgd2FpdCBmb3IgY29tbWl0ICovCisJCXQtPmluX2NvbW1pdCA9IDE7CisJCXQtPmJsb2NrZWQgPSAxOworCQlpZiAod2FpdHF1ZXVlX2FjdGl2ZSgmcm9vdC0+ZnNfaW5mby0+dHJhbnNhY3Rpb25fYmxvY2tlZF93YWl0KSkKKwkJCXdha2VfdXAoJnJvb3QtPmZzX2luZm8tPnRyYW5zYWN0aW9uX2Jsb2NrZWRfd2FpdCk7CisKKwkJdC0+YmxvY2tlZCA9IDA7CisJCWlmICh3YWl0cXVldWVfYWN0aXZlKCZyb290LT5mc19pbmZvLT50cmFuc2FjdGlvbl93YWl0KSkKKwkJCXdha2VfdXAoJnJvb3QtPmZzX2luZm8tPnRyYW5zYWN0aW9uX3dhaXQpOworCQltdXRleF91bmxvY2soJnJvb3QtPmZzX2luZm8tPnRyYW5zX211dGV4KTsKKworCQltdXRleF9sb2NrKCZyb290LT5mc19pbmZvLT50cmFuc19tdXRleCk7CisJCXQtPmNvbW1pdF9kb25lID0gMTsKKwkJaWYgKHdhaXRxdWV1ZV9hY3RpdmUoJnQtPmNvbW1pdF93YWl0KSkKKwkJCXdha2VfdXAoJnQtPmNvbW1pdF93YWl0KTsKKwkJbXV0ZXhfdW5sb2NrKCZyb290LT5mc19pbmZvLT50cmFuc19tdXRleCk7CisKKwkJbXV0ZXhfbG9jaygmcm9vdC0+ZnNfaW5mby0+dHJhbnNfbXV0ZXgpOworCisJCWJ0cmZzX2Rlc3Ryb3lfcGVuZGluZ19zbmFwc2hvdHModCk7CisKKwkJYnRyZnNfZGVzdHJveV9kZWxhbGxvY19pbm9kZXMocm9vdCk7CisKKwkJc3Bpbl9sb2NrKCZyb290LT5mc19pbmZvLT5uZXdfdHJhbnNfbG9jayk7CisJCXJvb3QtPmZzX2luZm8tPnJ1bm5pbmdfdHJhbnNhY3Rpb24gPSBOVUxMOworCQlzcGluX3VubG9jaygmcm9vdC0+ZnNfaW5mby0+bmV3X3RyYW5zX2xvY2spOworCisJCWJ0cmZzX2Rlc3Ryb3lfbWFya2VkX2V4dGVudHMocm9vdCwgJnQtPmRpcnR5X3BhZ2VzLAorCQkJCQkgICAgIEVYVEVOVF9ESVJUWSk7CisKKwkJYnRyZnNfZGVzdHJveV9waW5uZWRfZXh0ZW50KHJvb3QsCisJCQkJCSAgICByb290LT5mc19pbmZvLT5waW5uZWRfZXh0ZW50cyk7CisKKwkJdC0+dXNlX2NvdW50ID0gMDsKKwkJbGlzdF9kZWxfaW5pdCgmdC0+bGlzdCk7CisJCW1lbXNldCh0LCAwLCBzaXplb2YoKnQpKTsKKwkJa21lbV9jYWNoZV9mcmVlKGJ0cmZzX3RyYW5zYWN0aW9uX2NhY2hlcCwgdCk7CisJfQorCisJbXV0ZXhfdW5sb2NrKCZyb290LT5mc19pbmZvLT50cmFuc2FjdGlvbl9rdGhyZWFkX211dGV4KTsKKwltdXRleF91bmxvY2soJnJvb3QtPmZzX2luZm8tPnRyYW5zX211dGV4KTsKKworCXJldHVybiAwOworfQorCiBzdGF0aWMgc3RydWN0IGV4dGVudF9pb19vcHMgYnRyZWVfZXh0ZW50X2lvX29wcyA9IHsKIAkud3JpdGVfY2FjaGVfcGFnZXNfbG9ja19ob29rID0gYnRyZWVfbG9ja19wYWdlX2hvb2ssCiAJLnJlYWRwYWdlX2VuZF9pb19ob29rID0gYnRyZWVfcmVhZHBhZ2VfZW5kX2lvX2hvb2ssCmRpZmYgLS1naXQgYS9mcy9idHJmcy9kaXNrLWlvLmggYi9mcy9idHJmcy9kaXNrLWlvLmgKaW5kZXggODhlODI1YS4uMDdiMjBkYyAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvZGlzay1pby5oCisrKyBiL2ZzL2J0cmZzL2Rpc2staW8uaApAQCAtNTIsNiArNTIsNyBAQAogCQkgICAgICBzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCwgaW50IG1heF9taXJyb3JzKTsKIHN0cnVjdCBidWZmZXJfaGVhZCAqYnRyZnNfcmVhZF9kZXZfc3VwZXIoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldik7CiBpbnQgYnRyZnNfY29tbWl0X3N1cGVyKHN0cnVjdCBidHJmc19yb290ICpyb290KTsKK2ludCBidHJmc19lcnJvcl9jb21taXRfc3VwZXIoc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QpOwogc3RydWN0IGV4dGVudF9idWZmZXIgKmJ0cmZzX2ZpbmRfdHJlZV9ibG9jayhzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCwKIAkJCQkJICAgIHU2NCBieXRlbnIsIHUzMiBibG9ja3NpemUpOwogc3RydWN0IGJ0cmZzX3Jvb3QgKmJ0cmZzX2xvb2t1cF9mc19yb290KHN0cnVjdCBidHJmc19mc19pbmZvICpmc19pbmZvLApkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvZXhwb3J0LmMgYi9mcy9idHJmcy9leHBvcnQuYwppbmRleCA5Nzg2OTYzLi5mZjI3ZDdhIDEwMDY0NAotLS0gYS9mcy9idHJmcy9leHBvcnQuYworKysgYi9mcy9idHJmcy9leHBvcnQuYwpAQCAtMTcxLDYgKzE3MSw4IEBACiAJaW50IHJldDsKIAogCXBhdGggPSBidHJmc19hbGxvY19wYXRoKCk7CisJaWYgKCFwYXRoKQorCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKIAogCWlmIChkaXItPmlfaW5vID09IEJUUkZTX0ZJUlNUX0ZSRUVfT0JKRUNUSUQpIHsKIAkJa2V5Lm9iamVjdGlkID0gcm9vdC0+cm9vdF9rZXkub2JqZWN0aWQ7CmRpZmYgLS1naXQgYS9mcy9idHJmcy9leHRlbnQtdHJlZS5jIGIvZnMvYnRyZnMvZXh0ZW50LXRyZWUuYwppbmRleCAyMjdlNTgxLi40ZTdlMDEyIDEwMDY0NAotLS0gYS9mcy9idHJmcy9leHRlbnQtdHJlZS5jCisrKyBiL2ZzL2J0cmZzL2V4dGVudC10cmVlLmMKQEAgLTMyMCwxMSArMzIwLDYgQEAKIAlpZiAoIXBhdGgpCiAJCXJldHVybiAtRU5PTUVNOwogCi0JZXhjbHVkZV9zdXBlcl9zdHJpcGVzKGV4dGVudF9yb290LCBibG9ja19ncm91cCk7Ci0Jc3Bpbl9sb2NrKCZibG9ja19ncm91cC0+c3BhY2VfaW5mby0+bG9jayk7Ci0JYmxvY2tfZ3JvdXAtPnNwYWNlX2luZm8tPmJ5dGVzX3JlYWRvbmx5ICs9IGJsb2NrX2dyb3VwLT5ieXRlc19zdXBlcjsKLQlzcGluX3VubG9jaygmYmxvY2tfZ3JvdXAtPnNwYWNlX2luZm8tPmxvY2spOwotCiAJbGFzdCA9IG1heF90KHU2NCwgYmxvY2tfZ3JvdXAtPmtleS5vYmplY3RpZCwgQlRSRlNfU1VQRVJfSU5GT19PRkZTRVQpOwogCiAJLyoKQEAgLTQ2Nyw4ICs0NjIsMTAgQEAKIAkJCWNhY2hlLT5jYWNoZWQgPSBCVFJGU19DQUNIRV9OTzsKIAkJfQogCQlzcGluX3VubG9jaygmY2FjaGUtPmxvY2spOwotCQlpZiAocmV0ID09IDEpCisJCWlmIChyZXQgPT0gMSkgeworCQkJZnJlZV9leGNsdWRlZF9leHRlbnRzKGZzX2luZm8tPmV4dGVudF9yb290LCBjYWNoZSk7CiAJCQlyZXR1cm4gMDsKKwkJfQogCX0KIAogCWlmIChsb2FkX2NhY2hlX29ubHkpCkBAIC0zMDg5LDcgKzMwODYsNyBAQAogCXJldHVybiBidHJmc19yZWR1Y2VfYWxsb2NfcHJvZmlsZShyb290LCBmbGFncyk7CiB9CiAKLXN0YXRpYyB1NjQgYnRyZnNfZ2V0X2FsbG9jX3Byb2ZpbGUoc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QsIGludCBkYXRhKQordTY0IGJ0cmZzX2dldF9hbGxvY19wcm9maWxlKHN0cnVjdCBidHJmc19yb290ICpyb290LCBpbnQgZGF0YSkKIHsKIAl1NjQgZmxhZ3M7CiAKQEAgLTMxNjEsOCArMzE1OCwxMiBAQAogCQkJCQkgICAgIGJ5dGVzICsgMiAqIDEwMjQgKiAxMDI0LAogCQkJCQkgICAgIGFsbG9jX3RhcmdldCwgMCk7CiAJCQlidHJmc19lbmRfdHJhbnNhY3Rpb24odHJhbnMsIHJvb3QpOwotCQkJaWYgKHJldCA8IDApCi0JCQkJcmV0dXJuIHJldDsKKwkJCWlmIChyZXQgPCAwKSB7CisJCQkJaWYgKHJldCAhPSAtRU5PU1BDKQorCQkJCQlyZXR1cm4gcmV0OworCQkJCWVsc2UKKwkJCQkJZ290byBjb21taXRfdHJhbnM7CisJCQl9CiAKIAkJCWlmICghZGF0YV9zaW5mbykgewogCQkJCWJ0cmZzX3NldF9pbm9kZV9zcGFjZV9pbmZvKHJvb3QsIGlub2RlKTsKQEAgLTMxNzMsNiArMzE3NCw3IEBACiAJCXNwaW5fdW5sb2NrKCZkYXRhX3NpbmZvLT5sb2NrKTsKIAogCQkvKiBjb21taXQgdGhlIGN1cnJlbnQgdHJhbnNhY3Rpb24gYW5kIHRyeSBhZ2FpbiAqLworY29tbWl0X3RyYW5zOgogCQlpZiAoIWNvbW1pdHRlZCAmJiAhcm9vdC0+ZnNfaW5mby0+b3Blbl9pb2N0bF90cmFucykgewogCQkJY29tbWl0dGVkID0gMTsKIAkJCXRyYW5zID0gYnRyZnNfam9pbl90cmFuc2FjdGlvbihyb290LCAxKTsKQEAgLTMzMzksOCArMzM0MSwxMCBAQAogCXU2NCByZXNlcnZlZDsKIAl1NjQgbWF4X3JlY2xhaW07CiAJdTY0IHJlY2xhaW1lZCA9IDA7CisJbG9uZyB0aW1lX2xlZnQ7CiAJaW50IHBhdXNlID0gMTsKIAlpbnQgbnJfcGFnZXMgPSAoMiAqIDEwMjQgKiAxMDI0KSA+PiBQQUdFX0NBQ0hFX1NISUZUOworCWludCBsb29wcyA9IDA7CiAKIAlibG9ja19yc3YgPSAmcm9vdC0+ZnNfaW5mby0+ZGVsYWxsb2NfYmxvY2tfcnN2OwogCXNwYWNlX2luZm8gPSBibG9ja19yc3YtPnNwYWNlX2luZm87CkBAIC0zMzUzLDcgKzMzNTcsNyBAQAogCiAJbWF4X3JlY2xhaW0gPSBtaW4ocmVzZXJ2ZWQsIHRvX3JlY2xhaW0pOwogCi0Jd2hpbGUgKDEpIHsKKwl3aGlsZSAobG9vcHMgPCAxMDI0KSB7CiAJCS8qIGhhdmUgdGhlIGZsdXNoZXIgdGhyZWFkcyBqdW1wIGluIGFuZCBkbyBzb21lIElPICovCiAJCXNtcF9tYigpOwogCQlucl9wYWdlcyA9IG1pbl90KHVuc2lnbmVkIGxvbmcsIG5yX3BhZ2VzLApAQCAtMzM2MSw4ICszMzY1LDEyIEBACiAJCXdyaXRlYmFja19pbm9kZXNfc2JfbnJfaWZfaWRsZShyb290LT5mc19pbmZvLT5zYiwgbnJfcGFnZXMpOwogCiAJCXNwaW5fbG9jaygmc3BhY2VfaW5mby0+bG9jayk7Ci0JCWlmIChyZXNlcnZlZCA+IHNwYWNlX2luZm8tPmJ5dGVzX3Jlc2VydmVkKQorCQlpZiAocmVzZXJ2ZWQgPiBzcGFjZV9pbmZvLT5ieXRlc19yZXNlcnZlZCkgeworCQkJbG9vcHMgPSAwOwogCQkJcmVjbGFpbWVkICs9IHJlc2VydmVkIC0gc3BhY2VfaW5mby0+Ynl0ZXNfcmVzZXJ2ZWQ7CisJCX0gZWxzZSB7CisJCQlsb29wcysrOworCQl9CiAJCXJlc2VydmVkID0gc3BhY2VfaW5mby0+Ynl0ZXNfcmVzZXJ2ZWQ7CiAJCXNwaW5fdW5sb2NrKCZzcGFjZV9pbmZvLT5sb2NrKTsKIApAQCAtMzM3Myw3ICszMzgxLDEyIEBACiAJCQlyZXR1cm4gLUVBR0FJTjsKIAogCQlfX3NldF9jdXJyZW50X3N0YXRlKFRBU0tfSU5URVJSVVBUSUJMRSk7Ci0JCXNjaGVkdWxlX3RpbWVvdXQocGF1c2UpOworCQl0aW1lX2xlZnQgPSBzY2hlZHVsZV90aW1lb3V0KHBhdXNlKTsKKworCQkvKiBXZSB3ZXJlIGludGVycnVwdGVkLCBleGl0ICovCisJCWlmICh0aW1lX2xlZnQpCisJCQlicmVhazsKKwogCQlwYXVzZSA8PD0gMTsKIAkJaWYgKHBhdXNlID4gSFogLyAxMCkKIAkJCXBhdXNlID0gSFogLyAxMDsKQEAgLTM1ODMsOCArMzU5NiwyMCBAQAogCiAJaWYgKG51bV9ieXRlcyA+IDApIHsKIAkJaWYgKGRlc3QpIHsKLQkJCWJsb2NrX3Jzdl9hZGRfYnl0ZXMoZGVzdCwgbnVtX2J5dGVzLCAwKTsKLQkJfSBlbHNlIHsKKwkJCXNwaW5fbG9jaygmZGVzdC0+bG9jayk7CisJCQlpZiAoIWRlc3QtPmZ1bGwpIHsKKwkJCQl1NjQgYnl0ZXNfdG9fYWRkOworCisJCQkJYnl0ZXNfdG9fYWRkID0gZGVzdC0+c2l6ZSAtIGRlc3QtPnJlc2VydmVkOworCQkJCWJ5dGVzX3RvX2FkZCA9IG1pbihudW1fYnl0ZXMsIGJ5dGVzX3RvX2FkZCk7CisJCQkJZGVzdC0+cmVzZXJ2ZWQgKz0gYnl0ZXNfdG9fYWRkOworCQkJCWlmIChkZXN0LT5yZXNlcnZlZCA+PSBkZXN0LT5zaXplKQorCQkJCQlkZXN0LT5mdWxsID0gMTsKKwkJCQludW1fYnl0ZXMgLT0gYnl0ZXNfdG9fYWRkOworCQkJfQorCQkJc3Bpbl91bmxvY2soJmRlc3QtPmxvY2spOworCQl9CisJCWlmIChudW1fYnl0ZXMpIHsKIAkJCXNwaW5fbG9jaygmc3BhY2VfaW5mby0+bG9jayk7CiAJCQlzcGFjZV9pbmZvLT5ieXRlc19yZXNlcnZlZCAtPSBudW1fYnl0ZXM7CiAJCQlzcGluX3VubG9jaygmc3BhY2VfaW5mby0+bG9jayk7CkBAIC0zNzIxLDExICszNzQ2LDYgQEAKIAkJcmV0dXJuIDA7CiAJfQogCi0JV0FSTl9PTigxKTsKLQlwcmludGsoS0VSTl9JTkZPImJsb2NrX3JzdiBzaXplICVsbHUgcmVzZXJ2ZWQgJWxsdSBmcmVlZCAlbGx1ICVsbHVcbiIsCi0JCWJsb2NrX3Jzdi0+c2l6ZSwgYmxvY2tfcnN2LT5yZXNlcnZlZCwKLQkJYmxvY2tfcnN2LT5mcmVlZFswXSwgYmxvY2tfcnN2LT5mcmVlZFsxXSk7Ci0KIAlyZXR1cm4gLUVOT1NQQzsKIH0KIApAQCAtNDAxMiw2ICs0MDMyLDcgQEAKIAogCW51bV9ieXRlcyA9IEFMSUdOKG51bV9ieXRlcywgcm9vdC0+c2VjdG9yc2l6ZSk7CiAJYXRvbWljX2RlYygmQlRSRlNfSShpbm9kZSktPm91dHN0YW5kaW5nX2V4dGVudHMpOworCVdBUk5fT04oYXRvbWljX3JlYWQoJkJUUkZTX0koaW5vZGUpLT5vdXRzdGFuZGluZ19leHRlbnRzKSA8IDApOwogCiAJc3Bpbl9sb2NrKCZCVFJGU19JKGlub2RlKS0+YWNjb3VudGluZ19sb2NrKTsKIAlucl9leHRlbnRzID0gYXRvbWljX3JlYWQoJkJUUkZTX0koaW5vZGUpLT5vdXRzdGFuZGluZ19leHRlbnRzKTsKQEAgLTU2MzMsNiArNTY1NCw3IEBACiAJICAgICAgc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QsIHUzMiBibG9ja3NpemUpCiB7CiAJc3RydWN0IGJ0cmZzX2Jsb2NrX3JzdiAqYmxvY2tfcnN2OworCXN0cnVjdCBidHJmc19ibG9ja19yc3YgKmdsb2JhbF9yc3YgPSAmcm9vdC0+ZnNfaW5mby0+Z2xvYmFsX2Jsb2NrX3JzdjsKIAlpbnQgcmV0OwogCiAJYmxvY2tfcnN2ID0gZ2V0X2Jsb2NrX3Jzdih0cmFucywgcm9vdCk7CkBAIC01NjQwLDE0ICs1NjYyLDM5IEBACiAJaWYgKGJsb2NrX3Jzdi0+c2l6ZSA9PSAwKSB7CiAJCXJldCA9IHJlc2VydmVfbWV0YWRhdGFfYnl0ZXModHJhbnMsIHJvb3QsIGJsb2NrX3JzdiwKIAkJCQkJICAgICBibG9ja3NpemUsIDApOwotCQlpZiAocmV0KQorCQkvKgorCQkgKiBJZiB3ZSBjb3VsZG4ndCByZXNlcnZlIG1ldGFkYXRhIGJ5dGVzIHRyeSBhbmQgdXNlIHNvbWUgZnJvbQorCQkgKiB0aGUgZ2xvYmFsIHJlc2VydmUuCisJCSAqLworCQlpZiAocmV0ICYmIGJsb2NrX3JzdiAhPSBnbG9iYWxfcnN2KSB7CisJCQlyZXQgPSBibG9ja19yc3ZfdXNlX2J5dGVzKGdsb2JhbF9yc3YsIGJsb2Nrc2l6ZSk7CisJCQlpZiAoIXJldCkKKwkJCQlyZXR1cm4gZ2xvYmFsX3JzdjsKIAkJCXJldHVybiBFUlJfUFRSKHJldCk7CisJCX0gZWxzZSBpZiAocmV0KSB7CisJCQlyZXR1cm4gRVJSX1BUUihyZXQpOworCQl9CiAJCXJldHVybiBibG9ja19yc3Y7CiAJfQogCiAJcmV0ID0gYmxvY2tfcnN2X3VzZV9ieXRlcyhibG9ja19yc3YsIGJsb2Nrc2l6ZSk7CiAJaWYgKCFyZXQpCiAJCXJldHVybiBibG9ja19yc3Y7CisJaWYgKHJldCkgeworCQlXQVJOX09OKDEpOworCQlyZXQgPSByZXNlcnZlX21ldGFkYXRhX2J5dGVzKHRyYW5zLCByb290LCBibG9ja19yc3YsIGJsb2Nrc2l6ZSwKKwkJCQkJICAgICAwKTsKKwkJaWYgKCFyZXQpIHsKKwkJCXNwaW5fbG9jaygmYmxvY2tfcnN2LT5sb2NrKTsKKwkJCWJsb2NrX3Jzdi0+c2l6ZSArPSBibG9ja3NpemU7CisJCQlzcGluX3VubG9jaygmYmxvY2tfcnN2LT5sb2NrKTsKKwkJCXJldHVybiBibG9ja19yc3Y7CisJCX0gZWxzZSBpZiAocmV0ICYmIGJsb2NrX3JzdiAhPSBnbG9iYWxfcnN2KSB7CisJCQlyZXQgPSBibG9ja19yc3ZfdXNlX2J5dGVzKGdsb2JhbF9yc3YsIGJsb2Nrc2l6ZSk7CisJCQlpZiAoIXJldCkKKwkJCQlyZXR1cm4gZ2xvYmFsX3JzdjsKKwkJfQorCX0KIAogCXJldHVybiBFUlJfUFRSKC1FTk9TUEMpOwogfQpAQCAtNjIyMSw2ICs2MjY4LDggQEAKIAlCVUdfT04oIXdjKTsKIAogCXRyYW5zID0gYnRyZnNfc3RhcnRfdHJhbnNhY3Rpb24odHJlZV9yb290LCAwKTsKKwlCVUdfT04oSVNfRVJSKHRyYW5zKSk7CisKIAlpZiAoYmxvY2tfcnN2KQogCQl0cmFucy0+YmxvY2tfcnN2ID0gYmxvY2tfcnN2OwogCkBAIC02MzE4LDYgKzYzNjcsNyBAQAogCiAJCQlidHJmc19lbmRfdHJhbnNhY3Rpb25fdGhyb3R0bGUodHJhbnMsIHRyZWVfcm9vdCk7CiAJCQl0cmFucyA9IGJ0cmZzX3N0YXJ0X3RyYW5zYWN0aW9uKHRyZWVfcm9vdCwgMCk7CisJCQlCVUdfT04oSVNfRVJSKHRyYW5zKSk7CiAJCQlpZiAoYmxvY2tfcnN2KQogCQkJCXRyYW5zLT5ibG9ja19yc3YgPSBibG9ja19yc3Y7CiAJCX0KQEAgLTY0NDYsNiArNjQ5Niw4IEBACiAJaW50IHJldCA9IDA7CiAKIAlyYSA9IGt6YWxsb2Moc2l6ZW9mKCpyYSksIEdGUF9OT0ZTKTsKKwlpZiAoIXJhKQorCQlyZXR1cm4gLUVOT01FTTsKIAogCW11dGV4X2xvY2soJmlub2RlLT5pX211dGV4KTsKIAlmaXJzdF9pbmRleCA9IHN0YXJ0ID4+IFBBR0VfQ0FDSEVfU0hJRlQ7CkBAIC03NDc3LDcgKzc1MjksNyBAQAogCQlCVUdfT04ocmVsb2Nfcm9vdC0+Y29tbWl0X3Jvb3QgIT0gTlVMTCk7CiAJCXdoaWxlICgxKSB7CiAJCQl0cmFucyA9IGJ0cmZzX2pvaW5fdHJhbnNhY3Rpb24ocm9vdCwgMSk7Ci0JCQlCVUdfT04oIXRyYW5zKTsKKwkJCUJVR19PTihJU19FUlIodHJhbnMpKTsKIAogCQkJbXV0ZXhfbG9jaygmcm9vdC0+ZnNfaW5mby0+ZHJvcF9tdXRleCk7CiAJCQlyZXQgPSBidHJmc19kcm9wX3NuYXBzaG90KHRyYW5zLCByZWxvY19yb290KTsKQEAgLTc1MzUsNyArNzU4Nyw3IEBACiAKIAlpZiAoZm91bmQpIHsKIAkJdHJhbnMgPSBidHJmc19zdGFydF90cmFuc2FjdGlvbihyb290LCAxKTsKLQkJQlVHX09OKCF0cmFucyk7CisJCUJVR19PTihJU19FUlIodHJhbnMpKTsKIAkJcmV0ID0gYnRyZnNfY29tbWl0X3RyYW5zYWN0aW9uKHRyYW5zLCByb290KTsKIAkJQlVHX09OKHJldCk7CiAJfQpAQCAtNzc3OSw3ICs3ODMxLDcgQEAKIAogCiAJdHJhbnMgPSBidHJmc19zdGFydF90cmFuc2FjdGlvbihleHRlbnRfcm9vdCwgMSk7Ci0JQlVHX09OKCF0cmFucyk7CisJQlVHX09OKElTX0VSUih0cmFucykpOwogCiAJaWYgKGV4dGVudF9rZXktPm9iamVjdGlkID09IDApIHsKIAkJcmV0ID0gZGVsX2V4dGVudF96ZXJvKHRyYW5zLCBleHRlbnRfcm9vdCwgcGF0aCwgZXh0ZW50X2tleSk7CkBAIC03OTcwLDEzICs4MDIyLDE0IEBACiAKIAlpZiAoc2luZm8tPmJ5dGVzX3VzZWQgKyBzaW5mby0+Ynl0ZXNfcmVzZXJ2ZWQgKyBzaW5mby0+Ynl0ZXNfcGlubmVkICsKIAkgICAgc2luZm8tPmJ5dGVzX21heV91c2UgKyBzaW5mby0+Ynl0ZXNfcmVhZG9ubHkgKwotCSAgICBjYWNoZS0+cmVzZXJ2ZWRfcGlubmVkICsgbnVtX2J5dGVzIDwgc2luZm8tPnRvdGFsX2J5dGVzKSB7CisJICAgIGNhY2hlLT5yZXNlcnZlZF9waW5uZWQgKyBudW1fYnl0ZXMgPD0gc2luZm8tPnRvdGFsX2J5dGVzKSB7CiAJCXNpbmZvLT5ieXRlc19yZWFkb25seSArPSBudW1fYnl0ZXM7CiAJCXNpbmZvLT5ieXRlc19yZXNlcnZlZCArPSBjYWNoZS0+cmVzZXJ2ZWRfcGlubmVkOwogCQljYWNoZS0+cmVzZXJ2ZWRfcGlubmVkID0gMDsKIAkJY2FjaGUtPnJvID0gMTsKIAkJcmV0ID0gMDsKIAl9CisKIAlzcGluX3VubG9jaygmY2FjaGUtPmxvY2spOwogCXNwaW5fdW5sb2NrKCZzaW5mby0+bG9jayk7CiAJcmV0dXJuIHJldDsKQEAgLTgwMTIsNiArODA2NSw2MiBAQAogCXJldHVybiByZXQ7CiB9CiAKKy8qCisgKiBoZWxwZXIgdG8gYWNjb3VudCB0aGUgdW51c2VkIHNwYWNlIG9mIGFsbCB0aGUgcmVhZG9ubHkgYmxvY2sgZ3JvdXAgaW4gdGhlCisgKiBsaXN0LiB0YWtlcyBtaXJyb3JzIGludG8gYWNjb3VudC4KKyAqLworc3RhdGljIHU2NCBfX2J0cmZzX2dldF9yb19ibG9ja19ncm91cF9mcmVlX3NwYWNlKHN0cnVjdCBsaXN0X2hlYWQgKmdyb3Vwc19saXN0KQoreworCXN0cnVjdCBidHJmc19ibG9ja19ncm91cF9jYWNoZSAqYmxvY2tfZ3JvdXA7CisJdTY0IGZyZWVfYnl0ZXMgPSAwOworCWludCBmYWN0b3I7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGJsb2NrX2dyb3VwLCBncm91cHNfbGlzdCwgbGlzdCkgeworCQlzcGluX2xvY2soJmJsb2NrX2dyb3VwLT5sb2NrKTsKKworCQlpZiAoIWJsb2NrX2dyb3VwLT5ybykgeworCQkJc3Bpbl91bmxvY2soJmJsb2NrX2dyb3VwLT5sb2NrKTsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJaWYgKGJsb2NrX2dyb3VwLT5mbGFncyAmIChCVFJGU19CTE9DS19HUk9VUF9SQUlEMSB8CisJCQkJCSAgQlRSRlNfQkxPQ0tfR1JPVVBfUkFJRDEwIHwKKwkJCQkJICBCVFJGU19CTE9DS19HUk9VUF9EVVApKQorCQkJZmFjdG9yID0gMjsKKwkJZWxzZQorCQkJZmFjdG9yID0gMTsKKworCQlmcmVlX2J5dGVzICs9IChibG9ja19ncm91cC0+a2V5Lm9mZnNldCAtCisJCQkgICAgICAgYnRyZnNfYmxvY2tfZ3JvdXBfdXNlZCgmYmxvY2tfZ3JvdXAtPml0ZW0pKSAqCisJCQkgICAgICAgZmFjdG9yOworCisJCXNwaW5fdW5sb2NrKCZibG9ja19ncm91cC0+bG9jayk7CisJfQorCisJcmV0dXJuIGZyZWVfYnl0ZXM7Cit9CisKKy8qCisgKiBoZWxwZXIgdG8gYWNjb3VudCB0aGUgdW51c2VkIHNwYWNlIG9mIGFsbCB0aGUgcmVhZG9ubHkgYmxvY2sgZ3JvdXAgaW4gdGhlCisgKiBzcGFjZV9pbmZvLiB0YWtlcyBtaXJyb3JzIGludG8gYWNjb3VudC4KKyAqLwordTY0IGJ0cmZzX2FjY291bnRfcm9fYmxvY2tfZ3JvdXBzX2ZyZWVfc3BhY2Uoc3RydWN0IGJ0cmZzX3NwYWNlX2luZm8gKnNpbmZvKQoreworCWludCBpOworCXU2NCBmcmVlX2J5dGVzID0gMDsKKworCXNwaW5fbG9jaygmc2luZm8tPmxvY2spOworCisJZm9yKGkgPSAwOyBpIDwgQlRSRlNfTlJfUkFJRF9UWVBFUzsgaSsrKQorCQlpZiAoIWxpc3RfZW1wdHkoJnNpbmZvLT5ibG9ja19ncm91cHNbaV0pKQorCQkJZnJlZV9ieXRlcyArPSBfX2J0cmZzX2dldF9yb19ibG9ja19ncm91cF9mcmVlX3NwYWNlKAorCQkJCQkJJnNpbmZvLT5ibG9ja19ncm91cHNbaV0pOworCisJc3Bpbl91bmxvY2soJnNpbmZvLT5sb2NrKTsKKworCXJldHVybiBmcmVlX2J5dGVzOworfQorCiBpbnQgYnRyZnNfc2V0X2Jsb2NrX2dyb3VwX3J3KHN0cnVjdCBidHJmc19yb290ICpyb290LAogCQkJICAgICAgc3RydWN0IGJ0cmZzX2Jsb2NrX2dyb3VwX2NhY2hlICpjYWNoZSkKIHsKQEAgLTgwOTIsNyArODIwMSw3IEBACiAJbXV0ZXhfbG9jaygmcm9vdC0+ZnNfaW5mby0+Y2h1bmtfbXV0ZXgpOwogCWxpc3RfZm9yX2VhY2hfZW50cnkoZGV2aWNlLCAmZnNfZGV2aWNlcy0+YWxsb2NfbGlzdCwgZGV2X2FsbG9jX2xpc3QpIHsKIAkJdTY0IG1pbl9mcmVlID0gYnRyZnNfYmxvY2tfZ3JvdXBfdXNlZCgmYmxvY2tfZ3JvdXAtPml0ZW0pOwotCQl1NjQgZGV2X29mZnNldCwgbWF4X2F2YWlsOworCQl1NjQgZGV2X29mZnNldDsKIAogCQkvKgogCQkgKiBjaGVjayB0byBtYWtlIHN1cmUgd2UgY2FuIGFjdHVhbGx5IGZpbmQgYSBjaHVuayB3aXRoIGVub3VnaApAQCAtODEwMCw3ICs4MjA5LDcgQEAKIAkJICovCiAJCWlmIChkZXZpY2UtPnRvdGFsX2J5dGVzID4gZGV2aWNlLT5ieXRlc191c2VkICsgbWluX2ZyZWUpIHsKIAkJCXJldCA9IGZpbmRfZnJlZV9kZXZfZXh0ZW50KE5VTEwsIGRldmljZSwgbWluX2ZyZWUsCi0JCQkJCQkgICAmZGV2X29mZnNldCwgJm1heF9hdmFpbCk7CisJCQkJCQkgICAmZGV2X29mZnNldCwgTlVMTCk7CiAJCQlpZiAoIXJldCkKIAkJCQlicmVhazsKIAkJCXJldCA9IC0xOwpAQCAtODIxMyw2ICs4MzIyLDEzIEBACiAJCWlmIChibG9ja19ncm91cC0+Y2FjaGVkID09IEJUUkZTX0NBQ0hFX1NUQVJURUQpCiAJCQl3YWl0X2Jsb2NrX2dyb3VwX2NhY2hlX2RvbmUoYmxvY2tfZ3JvdXApOwogCisJCS8qCisJCSAqIFdlIGhhdmVuJ3QgY2FjaGVkIHRoaXMgYmxvY2sgZ3JvdXAsIHdoaWNoIG1lYW5zIHdlIGNvdWxkCisJCSAqIHBvc3NpYmx5IGhhdmUgZXhjbHVkZWQgZXh0ZW50cyBvbiB0aGlzIGJsb2NrIGdyb3VwLgorCQkgKi8KKwkJaWYgKGJsb2NrX2dyb3VwLT5jYWNoZWQgPT0gQlRSRlNfQ0FDSEVfTk8pCisJCQlmcmVlX2V4Y2x1ZGVkX2V4dGVudHMoaW5mby0+ZXh0ZW50X3Jvb3QsIGJsb2NrX2dyb3VwKTsKKwogCQlidHJmc19yZW1vdmVfZnJlZV9zcGFjZV9jYWNoZShibG9ja19ncm91cCk7CiAJCWJ0cmZzX3B1dF9ibG9ja19ncm91cChibG9ja19ncm91cCk7CiAKQEAgLTgzMjgsNiArODQ0NCwxMyBAQAogCQljYWNoZS0+c2VjdG9yc2l6ZSA9IHJvb3QtPnNlY3RvcnNpemU7CiAKIAkJLyoKKwkJICogV2UgbmVlZCB0byBleGNsdWRlIHRoZSBzdXBlciBzdHJpcGVzIG5vdyBzbyB0aGF0IHRoZSBzcGFjZQorCQkgKiBpbmZvIGhhcyBzdXBlciBieXRlcyBhY2NvdW50ZWQgZm9yLCBvdGhlcndpc2Ugd2UnbGwgdGhpbmsKKwkJICogd2UgaGF2ZSBtb3JlIHNwYWNlIHRoYW4gd2UgYWN0dWFsbHkgZG8uCisJCSAqLworCQlleGNsdWRlX3N1cGVyX3N0cmlwZXMocm9vdCwgY2FjaGUpOworCisJCS8qCiAJCSAqIGNoZWNrIGZvciB0d28gY2FzZXMsIGVpdGhlciB3ZSBhcmUgZnVsbCwgYW5kIHRoZXJlZm9yZQogCQkgKiBkb24ndCBuZWVkIHRvIGJvdGhlciB3aXRoIHRoZSBjYWNoaW5nIHdvcmsgc2luY2Ugd2Ugd29uJ3QKIAkJICogZmluZCBhbnkgc3BhY2UsIG9yIHdlIGFyZSBlbXB0eSwgYW5kIHdlIGNhbiBqdXN0IGFkZCBhbGwKQEAgLTgzMzUsMTIgKzg0NTgsMTAgQEAKIAkJICogdGltZSwgcGFydGljdWxhcmx5IGluIHRoZSBmdWxsIGNhc2UuCiAJCSAqLwogCQlpZiAoZm91bmRfa2V5Lm9mZnNldCA9PSBidHJmc19ibG9ja19ncm91cF91c2VkKCZjYWNoZS0+aXRlbSkpIHsKLQkJCWV4Y2x1ZGVfc3VwZXJfc3RyaXBlcyhyb290LCBjYWNoZSk7CiAJCQljYWNoZS0+bGFzdF9ieXRlX3RvX3VucGluID0gKHU2NCktMTsKIAkJCWNhY2hlLT5jYWNoZWQgPSBCVFJGU19DQUNIRV9GSU5JU0hFRDsKIAkJCWZyZWVfZXhjbHVkZWRfZXh0ZW50cyhyb290LCBjYWNoZSk7CiAJCX0gZWxzZSBpZiAoYnRyZnNfYmxvY2tfZ3JvdXBfdXNlZCgmY2FjaGUtPml0ZW0pID09IDApIHsKLQkJCWV4Y2x1ZGVfc3VwZXJfc3RyaXBlcyhyb290LCBjYWNoZSk7CiAJCQljYWNoZS0+bGFzdF9ieXRlX3RvX3VucGluID0gKHU2NCktMTsKIAkJCWNhY2hlLT5jYWNoZWQgPSBCVFJGU19DQUNIRV9GSU5JU0hFRDsKIAkJCWFkZF9uZXdfZnJlZV9zcGFjZShjYWNoZSwgcm9vdC0+ZnNfaW5mbywKQEAgLTg1ODQsMyArODcwNSwxNCBAQAogCWJ0cmZzX2ZyZWVfcGF0aChwYXRoKTsKIAlyZXR1cm4gcmV0OwogfQorCitpbnQgYnRyZnNfZXJyb3JfdW5waW5fZXh0ZW50X3JhbmdlKHN0cnVjdCBidHJmc19yb290ICpyb290LCB1NjQgc3RhcnQsIHU2NCBlbmQpCit7CisJcmV0dXJuIHVucGluX2V4dGVudF9yYW5nZShyb290LCBzdGFydCwgZW5kKTsKK30KKworaW50IGJ0cmZzX2Vycm9yX2Rpc2NhcmRfZXh0ZW50KHN0cnVjdCBidHJmc19yb290ICpyb290LCB1NjQgYnl0ZW5yLAorCQkJICAgICAgIHU2NCBudW1fYnl0ZXMpCit7CisJcmV0dXJuIGJ0cmZzX2Rpc2NhcmRfZXh0ZW50KHJvb3QsIGJ5dGVuciwgbnVtX2J5dGVzKTsKK30KZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL2V4dGVudF9pby5jIGIvZnMvYnRyZnMvZXh0ZW50X2lvLmMKaW5kZXggM2U4NmI5Zi4uNWU3NmE0NyAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvZXh0ZW50X2lvLmMKKysrIGIvZnMvYnRyZnMvZXh0ZW50X2lvLmMKQEAgLTE4NjUsNyArMTg2NSw3IEBACiAJYmlvX2dldChiaW8pOwogCiAJaWYgKHRyZWUtPm9wcyAmJiB0cmVlLT5vcHMtPnN1Ym1pdF9iaW9faG9vaykKLQkJdHJlZS0+b3BzLT5zdWJtaXRfYmlvX2hvb2socGFnZS0+bWFwcGluZy0+aG9zdCwgcncsIGJpbywKKwkJcmV0ID0gdHJlZS0+b3BzLT5zdWJtaXRfYmlvX2hvb2socGFnZS0+bWFwcGluZy0+aG9zdCwgcncsIGJpbywKIAkJCQkJICAgbWlycm9yX251bSwgYmlvX2ZsYWdzLCBzdGFydCk7CiAJZWxzZQogCQlzdWJtaXRfYmlvKHJ3LCBiaW8pOwpAQCAtMTkyMCw2ICsxOTIwLDggQEAKIAkJbnIgPSBiaW9fZ2V0X25yX3ZlY3MoYmRldik7CiAKIAliaW8gPSBidHJmc19iaW9fYWxsb2MoYmRldiwgc2VjdG9yLCBuciwgR0ZQX05PRlMgfCBfX0dGUF9ISUdIKTsKKwlpZiAoIWJpbykKKwkJcmV0dXJuIC1FTk9NRU07CiAKIAliaW9fYWRkX3BhZ2UoYmlvLCBwYWdlLCBwYWdlX3NpemUsIG9mZnNldCk7CiAJYmlvLT5iaV9lbmRfaW8gPSBlbmRfaW9fZnVuYzsKQEAgLTIwMjgsOCArMjAzMCwxMSBAQAogCQlCVUdfT04oZXh0ZW50X21hcF9lbmQoZW0pIDw9IGN1cik7CiAJCUJVR19PTihlbmQgPCBjdXIpOwogCi0JCWlmICh0ZXN0X2JpdChFWFRFTlRfRkxBR19DT01QUkVTU0VELCAmZW0tPmZsYWdzKSkKKwkJaWYgKHRlc3RfYml0KEVYVEVOVF9GTEFHX0NPTVBSRVNTRUQsICZlbS0+ZmxhZ3MpKSB7CiAJCQl0aGlzX2Jpb19mbGFnID0gRVhURU5UX0JJT19DT01QUkVTU0VEOworCQkJZXh0ZW50X3NldF9jb21wcmVzc190eXBlKCZ0aGlzX2Jpb19mbGFnLAorCQkJCQkJIGVtLT5jb21wcmVzc190eXBlKTsKKwkJfQogCiAJCWlvc2l6ZSA9IG1pbihleHRlbnRfbWFwX2VuZChlbSkgLSBjdXIsIGVuZCAtIGN1ciArIDEpOwogCQljdXJfZW5kID0gbWluKGV4dGVudF9tYXBfZW5kKGVtKSAtIDEsIGVuZCk7CkBAIC0yMTIzLDcgKzIxMjgsNyBAQAogCXJldCA9IF9fZXh0ZW50X3JlYWRfZnVsbF9wYWdlKHRyZWUsIHBhZ2UsIGdldF9leHRlbnQsICZiaW8sIDAsCiAJCQkJICAgICAgJmJpb19mbGFncyk7CiAJaWYgKGJpbykKLQkJc3VibWl0X29uZV9iaW8oUkVBRCwgYmlvLCAwLCBiaW9fZmxhZ3MpOworCQlyZXQgPSBzdWJtaXRfb25lX2JpbyhSRUFELCBiaW8sIDAsIGJpb19mbGFncyk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtMzA3Miw2ICszMDc3LDggQEAKICNlbmRpZgogCiAJZWIgPSBrbWVtX2NhY2hlX3phbGxvYyhleHRlbnRfYnVmZmVyX2NhY2hlLCBtYXNrKTsKKwlpZiAoZWIgPT0gTlVMTCkKKwkJcmV0dXJuIE5VTEw7CiAJZWItPnN0YXJ0ID0gc3RhcnQ7CiAJZWItPmxlbiA9IGxlbjsKIAlzcGluX2xvY2tfaW5pdCgmZWItPmxvY2spOwpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvZXh0ZW50X2lvLmggYi9mcy9idHJmcy9leHRlbnRfaW8uaAppbmRleCA0MTgzYzgxLi43MDgzY2ZhIDEwMDY0NAotLS0gYS9mcy9idHJmcy9leHRlbnRfaW8uaAorKysgYi9mcy9idHJmcy9leHRlbnRfaW8uaApAQCAtMjAsOCArMjAsMTIgQEAKICNkZWZpbmUgRVhURU5UX0lPQklUUyAoRVhURU5UX0xPQ0tFRCB8IEVYVEVOVF9XUklURUJBQ0spCiAjZGVmaW5lIEVYVEVOVF9DVExCSVRTIChFWFRFTlRfRE9fQUNDT1VOVElORyB8IEVYVEVOVF9GSVJTVF9ERUxBTExPQykKIAotLyogZmxhZ3MgZm9yIGJpbyBzdWJtaXNzaW9uICovCisvKgorICogZmxhZ3MgZm9yIGJpbyBzdWJtaXNzaW9uLiBUaGUgaGlnaCBiaXRzIGluZGljYXRlIHRoZSBjb21wcmVzc2lvbgorICogdHlwZSBmb3IgdGhpcyBiaW8KKyAqLwogI2RlZmluZSBFWFRFTlRfQklPX0NPTVBSRVNTRUQgMQorI2RlZmluZSBFWFRFTlRfQklPX0ZMQUdfU0hJRlQgMTYKIAogLyogdGhlc2UgYXJlIGJpdCBudW1iZXJzIGZvciB0ZXN0L3NldCBiaXQgKi8KICNkZWZpbmUgRVhURU5UX0JVRkZFUl9VUFRPREFURSAwCkBAIC0xMzUsNiArMTM5LDE3IEBACiAJd2FpdF9xdWV1ZV9oZWFkX3QgbG9ja193cTsKIH07CiAKK3N0YXRpYyBpbmxpbmUgdm9pZCBleHRlbnRfc2V0X2NvbXByZXNzX3R5cGUodW5zaWduZWQgbG9uZyAqYmlvX2ZsYWdzLAorCQkJCQkgICAgaW50IGNvbXByZXNzX3R5cGUpCit7CisJKmJpb19mbGFncyB8PSBjb21wcmVzc190eXBlIDw8IEVYVEVOVF9CSU9fRkxBR19TSElGVDsKK30KKworc3RhdGljIGlubGluZSBpbnQgZXh0ZW50X2NvbXByZXNzX3R5cGUodW5zaWduZWQgbG9uZyBiaW9fZmxhZ3MpCit7CisJcmV0dXJuIGJpb19mbGFncyA+PiBFWFRFTlRfQklPX0ZMQUdfU0hJRlQ7Cit9CisKIHN0cnVjdCBleHRlbnRfbWFwX3RyZWU7CiAKIHN0YXRpYyBpbmxpbmUgc3RydWN0IGV4dGVudF9zdGF0ZSAqZXh0ZW50X3N0YXRlX25leHQoc3RydWN0IGV4dGVudF9zdGF0ZSAqc3RhdGUpCmRpZmYgLS1naXQgYS9mcy9idHJmcy9leHRlbnRfbWFwLmMgYi9mcy9idHJmcy9leHRlbnRfbWFwLmMKaW5kZXggMjNjYjhkYS4uYjBlMWZjZSAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvZXh0ZW50X21hcC5jCisrKyBiL2ZzL2J0cmZzL2V4dGVudF9tYXAuYwpAQCAtMyw2ICszLDcgQEAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgogI2luY2x1ZGUgPGxpbnV4L2hhcmRpcnEuaD4KKyNpbmNsdWRlICJjdHJlZS5oIgogI2luY2x1ZGUgImV4dGVudF9tYXAuaCIKIAogCkBAIC01NCw2ICs1NSw3IEBACiAJCXJldHVybiBlbTsKIAllbS0+aW5fdHJlZSA9IDA7CiAJZW0tPmZsYWdzID0gMDsKKwllbS0+Y29tcHJlc3NfdHlwZSA9IEJUUkZTX0NPTVBSRVNTX05PTkU7CiAJYXRvbWljX3NldCgmZW0tPnJlZnMsIDEpOwogCXJldHVybiBlbTsKIH0KZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL2V4dGVudF9tYXAuaCBiL2ZzL2J0cmZzL2V4dGVudF9tYXAuaAppbmRleCBhYjZkNzRiLi4yOGI0NGRiIDEwMDY0NAotLS0gYS9mcy9idHJmcy9leHRlbnRfbWFwLmgKKysrIGIvZnMvYnRyZnMvZXh0ZW50X21hcC5oCkBAIC0yNiw3ICsyNiw4IEBACiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAlzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2OwogCWF0b21pY190IHJlZnM7Ci0JaW50IGluX3RyZWU7CisJdW5zaWduZWQgaW50IGluX3RyZWU6MTsKKwl1bnNpZ25lZCBpbnQgY29tcHJlc3NfdHlwZTo0OwogfTsKIAogc3RydWN0IGV4dGVudF9tYXBfdHJlZSB7CmRpZmYgLS1naXQgYS9mcy9idHJmcy9maWxlLWl0ZW0uYyBiL2ZzL2J0cmZzL2ZpbGUtaXRlbS5jCmluZGV4IGE1NjJhMjUuLjRmMTlhM2UgMTAwNjQ0Ci0tLSBhL2ZzL2J0cmZzL2ZpbGUtaXRlbS5jCisrKyBiL2ZzL2J0cmZzL2ZpbGUtaXRlbS5jCkBAIC01MzYsNiArNTM2LDggQEAKIAlyb290ID0gcm9vdC0+ZnNfaW5mby0+Y3N1bV9yb290OwogCiAJcGF0aCA9IGJ0cmZzX2FsbG9jX3BhdGgoKTsKKwlpZiAoIXBhdGgpCisJCXJldHVybiAtRU5PTUVNOwogCiAJd2hpbGUgKDEpIHsKIAkJa2V5Lm9iamVjdGlkID0gQlRSRlNfRVhURU5UX0NTVU1fT0JKRUNUSUQ7CkBAIC01NDgsNyArNTUwLDEwIEBACiAJCQlpZiAocGF0aC0+c2xvdHNbMF0gPT0gMCkKIAkJCQlnb3RvIG91dDsKIAkJCXBhdGgtPnNsb3RzWzBdLS07CisJCX0gZWxzZSBpZiAocmV0IDwgMCkgeworCQkJZ290byBvdXQ7CiAJCX0KKwogCQlsZWFmID0gcGF0aC0+bm9kZXNbMF07CiAJCWJ0cmZzX2l0ZW1fa2V5X3RvX2NwdShsZWFmLCAma2V5LCBwYXRoLT5zbG90c1swXSk7CiAKZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL2ZpbGUuYyBiL2ZzL2J0cmZzL2ZpbGUuYwppbmRleCA2NjgzNmQ4Li5jMWQzYTgxIDEwMDY0NAotLS0gYS9mcy9idHJmcy9maWxlLmMKKysrIGIvZnMvYnRyZnMvZmlsZS5jCkBAIC0yNCw2ICsyNCw3IEBACiAjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvYmFja2luZy1kZXYuaD4KICNpbmNsdWRlIDxsaW51eC9tcGFnZS5oPgorI2luY2x1ZGUgPGxpbnV4L2ZhbGxvYy5oPgogI2luY2x1ZGUgPGxpbnV4L3N3YXAuaD4KICNpbmNsdWRlIDxsaW51eC93cml0ZWJhY2suaD4KICNpbmNsdWRlIDxsaW51eC9zdGF0ZnMuaD4KQEAgLTIyNCw2ICsyMjUsNyBAQAogCiAJCQlzcGxpdC0+YmRldiA9IGVtLT5iZGV2OwogCQkJc3BsaXQtPmZsYWdzID0gZmxhZ3M7CisJCQlzcGxpdC0+Y29tcHJlc3NfdHlwZSA9IGVtLT5jb21wcmVzc190eXBlOwogCQkJcmV0ID0gYWRkX2V4dGVudF9tYXBwaW5nKGVtX3RyZWUsIHNwbGl0KTsKIAkJCUJVR19PTihyZXQpOwogCQkJZnJlZV9leHRlbnRfbWFwKHNwbGl0KTsKQEAgLTIzOCw2ICsyNDAsNyBAQAogCQkJc3BsaXQtPmxlbiA9IGVtLT5zdGFydCArIGVtLT5sZW4gLSAoc3RhcnQgKyBsZW4pOwogCQkJc3BsaXQtPmJkZXYgPSBlbS0+YmRldjsKIAkJCXNwbGl0LT5mbGFncyA9IGZsYWdzOworCQkJc3BsaXQtPmNvbXByZXNzX3R5cGUgPSBlbS0+Y29tcHJlc3NfdHlwZTsKIAogCQkJaWYgKGNvbXByZXNzZWQpIHsKIAkJCQlzcGxpdC0+YmxvY2tfbGVuID0gZW0tPmJsb2NrX2xlbjsKQEAgLTc5MCw4ICs3OTMsMTIgQEAKIAlmb3IgKGkgPSAwOyBpIDwgbnVtX3BhZ2VzOyBpKyspIHsKIAkJcGFnZXNbaV0gPSBncmFiX2NhY2hlX3BhZ2UoaW5vZGUtPmlfbWFwcGluZywgaW5kZXggKyBpKTsKIAkJaWYgKCFwYWdlc1tpXSkgewotCQkJZXJyID0gLUVOT01FTTsKLQkJCUJVR19PTigxKTsKKwkJCWludCBjOworCQkJZm9yIChjID0gaSAtIDE7IGMgPj0gMDsgYy0tKSB7CisJCQkJdW5sb2NrX3BhZ2UocGFnZXNbY10pOworCQkJCXBhZ2VfY2FjaGVfcmVsZWFzZShwYWdlc1tjXSk7CisJCQl9CisJCQlyZXR1cm4gLUVOT01FTTsKIAkJfQogCQl3YWl0X29uX3BhZ2Vfd3JpdGViYWNrKHBhZ2VzW2ldKTsKIAl9CkBAIC04OTAsNiArODk3LDE3IEBACiAJaWYgKGVycikKIAkJZ290byBvdXQ7CiAKKwkvKgorCSAqIElmIEJUUkZTIGZsaXBzIHJlYWRvbmx5IGR1ZSB0byBzb21lIGltcG9zc2libGUgZXJyb3IKKwkgKiAoZnNfaW5mby0+ZnNfc3RhdGUgbm93IGhhcyBCVFJGU19TVVBFUl9GTEFHX0VSUk9SKSwKKwkgKiBhbHRob3VnaCB3ZSBoYXZlIG9wZW5lZCBhIGZpbGUgYXMgd3JpdGFibGUsIHdlIGhhdmUKKwkgKiB0byBzdG9wIHRoaXMgd3JpdGUgb3BlcmF0aW9uIHRvIGVuc3VyZSBGUyBjb25zaXN0ZW5jeS4KKwkgKi8KKwlpZiAocm9vdC0+ZnNfaW5mby0+ZnNfc3RhdGUgJiBCVFJGU19TVVBFUl9GTEFHX0VSUk9SKSB7CisJCWVyciA9IC1FUk9GUzsKKwkJZ290byBvdXQ7CisJfQorCiAJZmlsZV91cGRhdGVfdGltZShmaWxlKTsKIAlCVFJGU19JKGlub2RlKS0+c2VxdWVuY2UrKzsKIApAQCAtOTMyLDYgKzk1MCwxMCBAQAogCQkgICAgIFBBR0VfQ0FDSEVfU0laRSwgUEFHRV9DQUNIRV9TSVpFIC8KIAkJICAgICAoc2l6ZW9mKHN0cnVjdCBwYWdlICopKSk7CiAJcGFnZXMgPSBrbWFsbG9jKG5ycHRycyAqIHNpemVvZihzdHJ1Y3QgcGFnZSAqKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFwYWdlcykgeworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIG91dDsKKwl9CiAKIAkvKiBnZW5lcmljX3dyaXRlX2NoZWNrcyBjYW4gY2hhbmdlIG91ciBwb3MgKi8KIAlzdGFydF9wb3MgPSBwb3M7CkBAIC05NzAsOCArOTkyLDggQEAKIAkJc2l6ZV90IHdyaXRlX2J5dGVzID0gbWluKGlvdl9pdGVyX2NvdW50KCZpKSwKIAkJCQkJIG5ycHRycyAqIChzaXplX3QpUEFHRV9DQUNIRV9TSVpFIC0KIAkJCQkJIG9mZnNldCk7Ci0JCXNpemVfdCBudW1fcGFnZXMgPSAod3JpdGVfYnl0ZXMgKyBQQUdFX0NBQ0hFX1NJWkUgLSAxKSA+PgotCQkJCQlQQUdFX0NBQ0hFX1NISUZUOworCQlzaXplX3QgbnVtX3BhZ2VzID0gKHdyaXRlX2J5dGVzICsgb2Zmc2V0ICsKKwkJCQkgICAgUEFHRV9DQUNIRV9TSVpFIC0gMSkgPj4gUEFHRV9DQUNIRV9TSElGVDsKIAogCQlXQVJOX09OKG51bV9wYWdlcyA+IG5ycHRycyk7CiAJCW1lbXNldChwYWdlcywgMCwgc2l6ZW9mKHN0cnVjdCBwYWdlICopICogbnJwdHJzKTsKQEAgLTEwMDEsOCArMTAyMyw4IEBACiAKIAkJY29waWVkID0gYnRyZnNfY29weV9mcm9tX3VzZXIocG9zLCBudW1fcGFnZXMsCiAJCQkJCSAgIHdyaXRlX2J5dGVzLCBwYWdlcywgJmkpOwotCQlkaXJ0eV9wYWdlcyA9IChjb3BpZWQgKyBQQUdFX0NBQ0hFX1NJWkUgLSAxKSA+PgotCQkJCQlQQUdFX0NBQ0hFX1NISUZUOworCQlkaXJ0eV9wYWdlcyA9IChjb3BpZWQgKyBvZmZzZXQgKyBQQUdFX0NBQ0hFX1NJWkUgLSAxKSA+PgorCQkJCVBBR0VfQ0FDSEVfU0hJRlQ7CiAKIAkJaWYgKG51bV9wYWdlcyA+IGRpcnR5X3BhZ2VzKSB7CiAJCQlpZiAoY29waWVkID4gMCkKQEAgLTEyMzcsNiArMTI1OSwxMTcgQEAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIGxvbmcgYnRyZnNfZmFsbG9jYXRlKHN0cnVjdCBmaWxlICpmaWxlLCBpbnQgbW9kZSwKKwkJCSAgICBsb2ZmX3Qgb2Zmc2V0LCBsb2ZmX3QgbGVuKQoreworCXN0cnVjdCBpbm9kZSAqaW5vZGUgPSBmaWxlLT5mX3BhdGguZGVudHJ5LT5kX2lub2RlOworCXN0cnVjdCBleHRlbnRfc3RhdGUgKmNhY2hlZF9zdGF0ZSA9IE5VTEw7CisJdTY0IGN1cl9vZmZzZXQ7CisJdTY0IGxhc3RfYnl0ZTsKKwl1NjQgYWxsb2Nfc3RhcnQ7CisJdTY0IGFsbG9jX2VuZDsKKwl1NjQgYWxsb2NfaGludCA9IDA7CisJdTY0IGxvY2tlZF9lbmQ7CisJdTY0IG1hc2sgPSBCVFJGU19JKGlub2RlKS0+cm9vdC0+c2VjdG9yc2l6ZSAtIDE7CisJc3RydWN0IGV4dGVudF9tYXAgKmVtOworCWludCByZXQ7CisKKwlhbGxvY19zdGFydCA9IG9mZnNldCAmIH5tYXNrOworCWFsbG9jX2VuZCA9ICAob2Zmc2V0ICsgbGVuICsgbWFzaykgJiB+bWFzazsKKworCS8qIFdlIG9ubHkgc3VwcG9ydCB0aGUgRkFMTE9DX0ZMX0tFRVBfU0laRSBtb2RlICovCisJaWYgKG1vZGUgJiB+RkFMTE9DX0ZMX0tFRVBfU0laRSkKKwkJcmV0dXJuIC1FT1BOT1RTVVBQOworCisJLyoKKwkgKiB3YWl0IGZvciBvcmRlcmVkIElPIGJlZm9yZSB3ZSBoYXZlIGFueSBsb2Nrcy4gIFdlJ2xsIGxvb3AgYWdhaW4KKwkgKiBiZWxvdyB3aXRoIHRoZSBsb2NrcyBoZWxkLgorCSAqLworCWJ0cmZzX3dhaXRfb3JkZXJlZF9yYW5nZShpbm9kZSwgYWxsb2Nfc3RhcnQsIGFsbG9jX2VuZCAtIGFsbG9jX3N0YXJ0KTsKKworCW11dGV4X2xvY2soJmlub2RlLT5pX211dGV4KTsKKwlyZXQgPSBpbm9kZV9uZXdzaXplX29rKGlub2RlLCBhbGxvY19lbmQpOworCWlmIChyZXQpCisJCWdvdG8gb3V0OworCisJaWYgKGFsbG9jX3N0YXJ0ID4gaW5vZGUtPmlfc2l6ZSkgeworCQlyZXQgPSBidHJmc19jb250X2V4cGFuZChpbm9kZSwgYWxsb2Nfc3RhcnQpOworCQlpZiAocmV0KQorCQkJZ290byBvdXQ7CisJfQorCisJcmV0ID0gYnRyZnNfY2hlY2tfZGF0YV9mcmVlX3NwYWNlKGlub2RlLCBhbGxvY19lbmQgLSBhbGxvY19zdGFydCk7CisJaWYgKHJldCkKKwkJZ290byBvdXQ7CisKKwlsb2NrZWRfZW5kID0gYWxsb2NfZW5kIC0gMTsKKwl3aGlsZSAoMSkgeworCQlzdHJ1Y3QgYnRyZnNfb3JkZXJlZF9leHRlbnQgKm9yZGVyZWQ7CisKKwkJLyogdGhlIGV4dGVudCBsb2NrIGlzIG9yZGVyZWQgaW5zaWRlIHRoZSBydW5uaW5nCisJCSAqIHRyYW5zYWN0aW9uCisJCSAqLworCQlsb2NrX2V4dGVudF9iaXRzKCZCVFJGU19JKGlub2RlKS0+aW9fdHJlZSwgYWxsb2Nfc3RhcnQsCisJCQkJIGxvY2tlZF9lbmQsIDAsICZjYWNoZWRfc3RhdGUsIEdGUF9OT0ZTKTsKKwkJb3JkZXJlZCA9IGJ0cmZzX2xvb2t1cF9maXJzdF9vcmRlcmVkX2V4dGVudChpbm9kZSwKKwkJCQkJCQkgICAgYWxsb2NfZW5kIC0gMSk7CisJCWlmIChvcmRlcmVkICYmCisJCSAgICBvcmRlcmVkLT5maWxlX29mZnNldCArIG9yZGVyZWQtPmxlbiA+IGFsbG9jX3N0YXJ0ICYmCisJCSAgICBvcmRlcmVkLT5maWxlX29mZnNldCA8IGFsbG9jX2VuZCkgeworCQkJYnRyZnNfcHV0X29yZGVyZWRfZXh0ZW50KG9yZGVyZWQpOworCQkJdW5sb2NrX2V4dGVudF9jYWNoZWQoJkJUUkZTX0koaW5vZGUpLT5pb190cmVlLAorCQkJCQkgICAgIGFsbG9jX3N0YXJ0LCBsb2NrZWRfZW5kLAorCQkJCQkgICAgICZjYWNoZWRfc3RhdGUsIEdGUF9OT0ZTKTsKKwkJCS8qCisJCQkgKiB3ZSBjYW4ndCB3YWl0IG9uIHRoZSByYW5nZSB3aXRoIHRoZSB0cmFuc2FjdGlvbgorCQkJICogcnVubmluZyBvciB3aXRoIHRoZSBleHRlbnQgbG9jayBoZWxkCisJCQkgKi8KKwkJCWJ0cmZzX3dhaXRfb3JkZXJlZF9yYW5nZShpbm9kZSwgYWxsb2Nfc3RhcnQsCisJCQkJCQkgYWxsb2NfZW5kIC0gYWxsb2Nfc3RhcnQpOworCQl9IGVsc2UgeworCQkJaWYgKG9yZGVyZWQpCisJCQkJYnRyZnNfcHV0X29yZGVyZWRfZXh0ZW50KG9yZGVyZWQpOworCQkJYnJlYWs7CisJCX0KKwl9CisKKwljdXJfb2Zmc2V0ID0gYWxsb2Nfc3RhcnQ7CisJd2hpbGUgKDEpIHsKKwkJZW0gPSBidHJmc19nZXRfZXh0ZW50KGlub2RlLCBOVUxMLCAwLCBjdXJfb2Zmc2V0LAorCQkJCSAgICAgIGFsbG9jX2VuZCAtIGN1cl9vZmZzZXQsIDApOworCQlCVUdfT04oSVNfRVJSKGVtKSB8fCAhZW0pOworCQlsYXN0X2J5dGUgPSBtaW4oZXh0ZW50X21hcF9lbmQoZW0pLCBhbGxvY19lbmQpOworCQlsYXN0X2J5dGUgPSAobGFzdF9ieXRlICsgbWFzaykgJiB+bWFzazsKKwkJaWYgKGVtLT5ibG9ja19zdGFydCA9PSBFWFRFTlRfTUFQX0hPTEUgfHwKKwkJICAgIChjdXJfb2Zmc2V0ID49IGlub2RlLT5pX3NpemUgJiYKKwkJICAgICAhdGVzdF9iaXQoRVhURU5UX0ZMQUdfUFJFQUxMT0MsICZlbS0+ZmxhZ3MpKSkgeworCQkJcmV0ID0gYnRyZnNfcHJlYWxsb2NfZmlsZV9yYW5nZShpbm9kZSwgbW9kZSwgY3VyX29mZnNldCwKKwkJCQkJCQlsYXN0X2J5dGUgLSBjdXJfb2Zmc2V0LAorCQkJCQkJCTEgPDwgaW5vZGUtPmlfYmxrYml0cywKKwkJCQkJCQlvZmZzZXQgKyBsZW4sCisJCQkJCQkJJmFsbG9jX2hpbnQpOworCQkJaWYgKHJldCA8IDApIHsKKwkJCQlmcmVlX2V4dGVudF9tYXAoZW0pOworCQkJCWJyZWFrOworCQkJfQorCQl9CisJCWZyZWVfZXh0ZW50X21hcChlbSk7CisKKwkJY3VyX29mZnNldCA9IGxhc3RfYnl0ZTsKKwkJaWYgKGN1cl9vZmZzZXQgPj0gYWxsb2NfZW5kKSB7CisJCQlyZXQgPSAwOworCQkJYnJlYWs7CisJCX0KKwl9CisJdW5sb2NrX2V4dGVudF9jYWNoZWQoJkJUUkZTX0koaW5vZGUpLT5pb190cmVlLCBhbGxvY19zdGFydCwgbG9ja2VkX2VuZCwKKwkJCSAgICAgJmNhY2hlZF9zdGF0ZSwgR0ZQX05PRlMpOworCisJYnRyZnNfZnJlZV9yZXNlcnZlZF9kYXRhX3NwYWNlKGlub2RlLCBhbGxvY19lbmQgLSBhbGxvY19zdGFydCk7CitvdXQ6CisJbXV0ZXhfdW5sb2NrKCZpbm9kZS0+aV9tdXRleCk7CisJcmV0dXJuIHJldDsKK30KKwogY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBidHJmc19maWxlX29wZXJhdGlvbnMgPSB7CiAJLmxsc2VlawkJPSBnZW5lcmljX2ZpbGVfbGxzZWVrLAogCS5yZWFkCQk9IGRvX3N5bmNfcmVhZCwKQEAgLTEyNDgsNiArMTM4MSw3IEBACiAJLm9wZW4JCT0gZ2VuZXJpY19maWxlX29wZW4sCiAJLnJlbGVhc2UJPSBidHJmc19yZWxlYXNlX2ZpbGUsCiAJLmZzeW5jCQk9IGJ0cmZzX3N5bmNfZmlsZSwKKwkuZmFsbG9jYXRlCT0gYnRyZnNfZmFsbG9jYXRlLAogCS51bmxvY2tlZF9pb2N0bAk9IGJ0cmZzX2lvY3RsLAogI2lmZGVmIENPTkZJR19DT01QQVQKIAkuY29tcGF0X2lvY3RsCT0gYnRyZnNfaW9jdGwsCmRpZmYgLS1naXQgYS9mcy9idHJmcy9mcmVlLXNwYWNlLWNhY2hlLmMgYi9mcy9idHJmcy9mcmVlLXNwYWNlLWNhY2hlLmMKaW5kZXggNjBkNjg0Mi4uYTAzOTA2NSAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvZnJlZS1zcGFjZS1jYWNoZS5jCisrKyBiL2ZzL2J0cmZzL2ZyZWUtc3BhY2UtY2FjaGUuYwpAQCAtOTg3LDExICs5ODcsMTggQEAKIAlyZXR1cm4gZW50cnk7CiB9CiAKLXN0YXRpYyB2b2lkIHVubGlua19mcmVlX3NwYWNlKHN0cnVjdCBidHJmc19ibG9ja19ncm91cF9jYWNoZSAqYmxvY2tfZ3JvdXAsCi0JCQkgICAgICBzdHJ1Y3QgYnRyZnNfZnJlZV9zcGFjZSAqaW5mbykKK3N0YXRpYyBpbmxpbmUgdm9pZAorX191bmxpbmtfZnJlZV9zcGFjZShzdHJ1Y3QgYnRyZnNfYmxvY2tfZ3JvdXBfY2FjaGUgKmJsb2NrX2dyb3VwLAorCQkgICAgc3RydWN0IGJ0cmZzX2ZyZWVfc3BhY2UgKmluZm8pCiB7CiAJcmJfZXJhc2UoJmluZm8tPm9mZnNldF9pbmRleCwgJmJsb2NrX2dyb3VwLT5mcmVlX3NwYWNlX29mZnNldCk7CiAJYmxvY2tfZ3JvdXAtPmZyZWVfZXh0ZW50cy0tOworfQorCitzdGF0aWMgdm9pZCB1bmxpbmtfZnJlZV9zcGFjZShzdHJ1Y3QgYnRyZnNfYmxvY2tfZ3JvdXBfY2FjaGUgKmJsb2NrX2dyb3VwLAorCQkJICAgICAgc3RydWN0IGJ0cmZzX2ZyZWVfc3BhY2UgKmluZm8pCit7CisJX191bmxpbmtfZnJlZV9zcGFjZShibG9ja19ncm91cCwgaW5mbyk7CiAJYmxvY2tfZ3JvdXAtPmZyZWVfc3BhY2UgLT0gaW5mby0+Ynl0ZXM7CiB9CiAKQEAgLTEwMTYsMTQgKzEwMjMsMTggQEAKIAl1NjQgbWF4X2J5dGVzOwogCXU2NCBiaXRtYXBfYnl0ZXM7CiAJdTY0IGV4dGVudF9ieXRlczsKKwl1NjQgc2l6ZSA9IGJsb2NrX2dyb3VwLT5rZXkub2Zmc2V0OwogCiAJLyoKIAkgKiBUaGUgZ29hbCBpcyB0byBrZWVwIHRoZSB0b3RhbCBhbW91bnQgb2YgbWVtb3J5IHVzZWQgcGVyIDFnYiBvZiBzcGFjZQogCSAqIGF0IG9yIGJlbG93IDMyaywgc28gd2UgbmVlZCB0byBhZGp1c3QgaG93IG11Y2ggbWVtb3J5IHdlIGFsbG93IHRvIGJlCiAJICogdXNlZCBieSBleHRlbnQgYmFzZWQgZnJlZSBzcGFjZSB0cmFja2luZwogCSAqLwotCW1heF9ieXRlcyA9IE1BWF9DQUNIRV9CWVRFU19QRVJfR0lHICoKLQkJKGRpdjY0X3U2NChibG9ja19ncm91cC0+a2V5Lm9mZnNldCwgMTAyNCAqIDEwMjQgKiAxMDI0KSk7CisJaWYgKHNpemUgPCAxMDI0ICogMTAyNCAqIDEwMjQpCisJCW1heF9ieXRlcyA9IE1BWF9DQUNIRV9CWVRFU19QRVJfR0lHOworCWVsc2UKKwkJbWF4X2J5dGVzID0gTUFYX0NBQ0hFX0JZVEVTX1BFUl9HSUcgKgorCQkJZGl2NjRfdTY0KHNpemUsIDEwMjQgKiAxMDI0ICogMTAyNCk7CiAKIAkvKgogCSAqIHdlIHdhbnQgdG8gYWNjb3VudCBmb3IgMSBtb3JlIGJpdG1hcCB0aGFuIHdoYXQgd2UgaGF2ZSBzbyB3ZSBjYW4gbWFrZQpAQCAtMTE3MSw2ICsxMTgyLDE2IEBACiAJcmVjYWxjdWxhdGVfdGhyZXNob2xkcyhibG9ja19ncm91cCk7CiB9CiAKK3N0YXRpYyB2b2lkIGZyZWVfYml0bWFwKHN0cnVjdCBidHJmc19ibG9ja19ncm91cF9jYWNoZSAqYmxvY2tfZ3JvdXAsCisJCQlzdHJ1Y3QgYnRyZnNfZnJlZV9zcGFjZSAqYml0bWFwX2luZm8pCit7CisJdW5saW5rX2ZyZWVfc3BhY2UoYmxvY2tfZ3JvdXAsIGJpdG1hcF9pbmZvKTsKKwlrZnJlZShiaXRtYXBfaW5mby0+Yml0bWFwKTsKKwlrZnJlZShiaXRtYXBfaW5mbyk7CisJYmxvY2tfZ3JvdXAtPnRvdGFsX2JpdG1hcHMtLTsKKwlyZWNhbGN1bGF0ZV90aHJlc2hvbGRzKGJsb2NrX2dyb3VwKTsKK30KKwogc3RhdGljIG5vaW5saW5lIGludCByZW1vdmVfZnJvbV9iaXRtYXAoc3RydWN0IGJ0cmZzX2Jsb2NrX2dyb3VwX2NhY2hlICpibG9ja19ncm91cCwKIAkJCSAgICAgIHN0cnVjdCBidHJmc19mcmVlX3NwYWNlICpiaXRtYXBfaW5mbywKIAkJCSAgICAgIHU2NCAqb2Zmc2V0LCB1NjQgKmJ5dGVzKQpAQCAtMTE5NSw2ICsxMjE2LDcgQEAKIAkgKi8KIAlzZWFyY2hfc3RhcnQgPSAqb2Zmc2V0OwogCXNlYXJjaF9ieXRlcyA9ICpieXRlczsKKwlzZWFyY2hfYnl0ZXMgPSBtaW4oc2VhcmNoX2J5dGVzLCBlbmQgLSBzZWFyY2hfc3RhcnQgKyAxKTsKIAlyZXQgPSBzZWFyY2hfYml0bWFwKGJsb2NrX2dyb3VwLCBiaXRtYXBfaW5mbywgJnNlYXJjaF9zdGFydCwKIAkJCSAgICAmc2VhcmNoX2J5dGVzKTsKIAlCVUdfT04ocmV0IDwgMCB8fCBzZWFyY2hfc3RhcnQgIT0gKm9mZnNldCk7CkBAIC0xMjExLDEzICsxMjMzLDggQEAKIAogCWlmICgqYnl0ZXMpIHsKIAkJc3RydWN0IHJiX25vZGUgKm5leHQgPSByYl9uZXh0KCZiaXRtYXBfaW5mby0+b2Zmc2V0X2luZGV4KTsKLQkJaWYgKCFiaXRtYXBfaW5mby0+Ynl0ZXMpIHsKLQkJCXVubGlua19mcmVlX3NwYWNlKGJsb2NrX2dyb3VwLCBiaXRtYXBfaW5mbyk7Ci0JCQlrZnJlZShiaXRtYXBfaW5mby0+Yml0bWFwKTsKLQkJCWtmcmVlKGJpdG1hcF9pbmZvKTsKLQkJCWJsb2NrX2dyb3VwLT50b3RhbF9iaXRtYXBzLS07Ci0JCQlyZWNhbGN1bGF0ZV90aHJlc2hvbGRzKGJsb2NrX2dyb3VwKTsKLQkJfQorCQlpZiAoIWJpdG1hcF9pbmZvLT5ieXRlcykKKwkJCWZyZWVfYml0bWFwKGJsb2NrX2dyb3VwLCBiaXRtYXBfaW5mbyk7CiAKIAkJLyoKIAkJICogbm8gZW50cnkgYWZ0ZXIgdGhpcyBiaXRtYXAsIGJ1dCB3ZSBzdGlsbCBoYXZlIGJ5dGVzIHRvCkBAIC0xMjUwLDEzICsxMjY3LDggQEAKIAkJCXJldHVybiAtRUFHQUlOOwogCiAJCWdvdG8gYWdhaW47Ci0JfSBlbHNlIGlmICghYml0bWFwX2luZm8tPmJ5dGVzKSB7Ci0JCXVubGlua19mcmVlX3NwYWNlKGJsb2NrX2dyb3VwLCBiaXRtYXBfaW5mbyk7Ci0JCWtmcmVlKGJpdG1hcF9pbmZvLT5iaXRtYXApOwotCQlrZnJlZShiaXRtYXBfaW5mbyk7Ci0JCWJsb2NrX2dyb3VwLT50b3RhbF9iaXRtYXBzLS07Ci0JCXJlY2FsY3VsYXRlX3RocmVzaG9sZHMoYmxvY2tfZ3JvdXApOwotCX0KKwl9IGVsc2UgaWYgKCFiaXRtYXBfaW5mby0+Ynl0ZXMpCisJCWZyZWVfYml0bWFwKGJsb2NrX2dyb3VwLCBiaXRtYXBfaW5mbyk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTEzNTksMjIgKzEzNzEsMTQgQEAKIAlyZXR1cm4gcmV0OwogfQogCi1pbnQgYnRyZnNfYWRkX2ZyZWVfc3BhY2Uoc3RydWN0IGJ0cmZzX2Jsb2NrX2dyb3VwX2NhY2hlICpibG9ja19ncm91cCwKLQkJCSB1NjQgb2Zmc2V0LCB1NjQgYnl0ZXMpCitib29sIHRyeV9tZXJnZV9mcmVlX3NwYWNlKHN0cnVjdCBidHJmc19ibG9ja19ncm91cF9jYWNoZSAqYmxvY2tfZ3JvdXAsCisJCQkgIHN0cnVjdCBidHJmc19mcmVlX3NwYWNlICppbmZvLCBib29sIHVwZGF0ZV9zdGF0KQogewotCXN0cnVjdCBidHJmc19mcmVlX3NwYWNlICpyaWdodF9pbmZvID0gTlVMTDsKLQlzdHJ1Y3QgYnRyZnNfZnJlZV9zcGFjZSAqbGVmdF9pbmZvID0gTlVMTDsKLQlzdHJ1Y3QgYnRyZnNfZnJlZV9zcGFjZSAqaW5mbyA9IE5VTEw7Ci0JaW50IHJldCA9IDA7Ci0KLQlpbmZvID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGJ0cmZzX2ZyZWVfc3BhY2UpLCBHRlBfTk9GUyk7Ci0JaWYgKCFpbmZvKQotCQlyZXR1cm4gLUVOT01FTTsKLQotCWluZm8tPm9mZnNldCA9IG9mZnNldDsKLQlpbmZvLT5ieXRlcyA9IGJ5dGVzOwotCi0Jc3Bpbl9sb2NrKCZibG9ja19ncm91cC0+dHJlZV9sb2NrKTsKKwlzdHJ1Y3QgYnRyZnNfZnJlZV9zcGFjZSAqbGVmdF9pbmZvOworCXN0cnVjdCBidHJmc19mcmVlX3NwYWNlICpyaWdodF9pbmZvOworCWJvb2wgbWVyZ2VkID0gZmFsc2U7CisJdTY0IG9mZnNldCA9IGluZm8tPm9mZnNldDsKKwl1NjQgYnl0ZXMgPSBpbmZvLT5ieXRlczsKIAogCS8qCiAJICogZmlyc3Qgd2Ugd2FudCB0byBzZWUgaWYgdGhlcmUgaXMgZnJlZSBzcGFjZSBhZGphY2VudCB0byB0aGUgcmFuZ2Ugd2UKQEAgLTEzODgsMzcgKzEzOTIsNjIgQEAKIAllbHNlCiAJCWxlZnRfaW5mbyA9IHRyZWVfc2VhcmNoX29mZnNldChibG9ja19ncm91cCwgb2Zmc2V0IC0gMSwgMCwgMCk7CiAKLQkvKgotCSAqIElmIHRoZXJlIHdhcyBubyBleHRlbnQgZGlyZWN0bHkgdG8gdGhlIGxlZnQgb3IgcmlnaHQgb2YgdGhpcyBuZXcKLQkgKiBleHRlbnQgdGhlbiB3ZSBrbm93IHdlJ3JlIGdvaW5nIHRvIGhhdmUgdG8gYWxsb2NhdGUgYSBuZXcgZXh0ZW50LCBzbwotCSAqIGJlZm9yZSB3ZSBkbyB0aGF0IHNlZSBpZiB3ZSBuZWVkIHRvIGRyb3AgdGhpcyBpbnRvIGEgYml0bWFwCi0JICovCi0JaWYgKCghbGVmdF9pbmZvIHx8IGxlZnRfaW5mby0+Yml0bWFwKSAmJgotCSAgICAoIXJpZ2h0X2luZm8gfHwgcmlnaHRfaW5mby0+Yml0bWFwKSkgewotCQlyZXQgPSBpbnNlcnRfaW50b19iaXRtYXAoYmxvY2tfZ3JvdXAsIGluZm8pOwotCi0JCWlmIChyZXQgPCAwKSB7Ci0JCQlnb3RvIG91dDsKLQkJfSBlbHNlIGlmIChyZXQpIHsKLQkJCXJldCA9IDA7Ci0JCQlnb3RvIG91dDsKLQkJfQotCX0KLQogCWlmIChyaWdodF9pbmZvICYmICFyaWdodF9pbmZvLT5iaXRtYXApIHsKLQkJdW5saW5rX2ZyZWVfc3BhY2UoYmxvY2tfZ3JvdXAsIHJpZ2h0X2luZm8pOworCQlpZiAodXBkYXRlX3N0YXQpCisJCQl1bmxpbmtfZnJlZV9zcGFjZShibG9ja19ncm91cCwgcmlnaHRfaW5mbyk7CisJCWVsc2UKKwkJCV9fdW5saW5rX2ZyZWVfc3BhY2UoYmxvY2tfZ3JvdXAsIHJpZ2h0X2luZm8pOwogCQlpbmZvLT5ieXRlcyArPSByaWdodF9pbmZvLT5ieXRlczsKIAkJa2ZyZWUocmlnaHRfaW5mbyk7CisJCW1lcmdlZCA9IHRydWU7CiAJfQogCiAJaWYgKGxlZnRfaW5mbyAmJiAhbGVmdF9pbmZvLT5iaXRtYXAgJiYKIAkgICAgbGVmdF9pbmZvLT5vZmZzZXQgKyBsZWZ0X2luZm8tPmJ5dGVzID09IG9mZnNldCkgewotCQl1bmxpbmtfZnJlZV9zcGFjZShibG9ja19ncm91cCwgbGVmdF9pbmZvKTsKKwkJaWYgKHVwZGF0ZV9zdGF0KQorCQkJdW5saW5rX2ZyZWVfc3BhY2UoYmxvY2tfZ3JvdXAsIGxlZnRfaW5mbyk7CisJCWVsc2UKKwkJCV9fdW5saW5rX2ZyZWVfc3BhY2UoYmxvY2tfZ3JvdXAsIGxlZnRfaW5mbyk7CiAJCWluZm8tPm9mZnNldCA9IGxlZnRfaW5mby0+b2Zmc2V0OwogCQlpbmZvLT5ieXRlcyArPSBsZWZ0X2luZm8tPmJ5dGVzOwogCQlrZnJlZShsZWZ0X2luZm8pOworCQltZXJnZWQgPSB0cnVlOwogCX0KIAorCXJldHVybiBtZXJnZWQ7Cit9CisKK2ludCBidHJmc19hZGRfZnJlZV9zcGFjZShzdHJ1Y3QgYnRyZnNfYmxvY2tfZ3JvdXBfY2FjaGUgKmJsb2NrX2dyb3VwLAorCQkJIHU2NCBvZmZzZXQsIHU2NCBieXRlcykKK3sKKwlzdHJ1Y3QgYnRyZnNfZnJlZV9zcGFjZSAqaW5mbzsKKwlpbnQgcmV0ID0gMDsKKworCWluZm8gPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgYnRyZnNfZnJlZV9zcGFjZSksIEdGUF9OT0ZTKTsKKwlpZiAoIWluZm8pCisJCXJldHVybiAtRU5PTUVNOworCisJaW5mby0+b2Zmc2V0ID0gb2Zmc2V0OworCWluZm8tPmJ5dGVzID0gYnl0ZXM7CisKKwlzcGluX2xvY2soJmJsb2NrX2dyb3VwLT50cmVlX2xvY2spOworCisJaWYgKHRyeV9tZXJnZV9mcmVlX3NwYWNlKGJsb2NrX2dyb3VwLCBpbmZvLCB0cnVlKSkKKwkJZ290byBsaW5rOworCisJLyoKKwkgKiBUaGVyZSB3YXMgbm8gZXh0ZW50IGRpcmVjdGx5IHRvIHRoZSBsZWZ0IG9yIHJpZ2h0IG9mIHRoaXMgbmV3CisJICogZXh0ZW50IHRoZW4gd2Uga25vdyB3ZSdyZSBnb2luZyB0byBoYXZlIHRvIGFsbG9jYXRlIGEgbmV3IGV4dGVudCwgc28KKwkgKiBiZWZvcmUgd2UgZG8gdGhhdCBzZWUgaWYgd2UgbmVlZCB0byBkcm9wIHRoaXMgaW50byBhIGJpdG1hcAorCSAqLworCXJldCA9IGluc2VydF9pbnRvX2JpdG1hcChibG9ja19ncm91cCwgaW5mbyk7CisJaWYgKHJldCA8IDApIHsKKwkJZ290byBvdXQ7CisJfSBlbHNlIGlmIChyZXQpIHsKKwkJcmV0ID0gMDsKKwkJZ290byBvdXQ7CisJfQorbGluazoKIAlyZXQgPSBsaW5rX2ZyZWVfc3BhY2UoYmxvY2tfZ3JvdXAsIGluZm8pOwogCWlmIChyZXQpCiAJCWtmcmVlKGluZm8pOwpAQCAtMTYyMSw2ICsxNjUwLDcgQEAKIAkJbm9kZSA9IHJiX25leHQoJmVudHJ5LT5vZmZzZXRfaW5kZXgpOwogCQlyYl9lcmFzZSgmZW50cnktPm9mZnNldF9pbmRleCwgJmNsdXN0ZXItPnJvb3QpOwogCQlCVUdfT04oZW50cnktPmJpdG1hcCk7CisJCXRyeV9tZXJnZV9mcmVlX3NwYWNlKGJsb2NrX2dyb3VwLCBlbnRyeSwgZmFsc2UpOwogCQl0cmVlX2luc2VydF9vZmZzZXQoJmJsb2NrX2dyb3VwLT5mcmVlX3NwYWNlX29mZnNldCwKIAkJCQkgICBlbnRyeS0+b2Zmc2V0LCAmZW50cnktPm9mZnNldF9pbmRleCwgMCk7CiAJfQpAQCAtMTY4NSwxMyArMTcxNSw4IEBACiAJcmV0ID0gb2Zmc2V0OwogCWlmIChlbnRyeS0+Yml0bWFwKSB7CiAJCWJpdG1hcF9jbGVhcl9iaXRzKGJsb2NrX2dyb3VwLCBlbnRyeSwgb2Zmc2V0LCBieXRlcyk7Ci0JCWlmICghZW50cnktPmJ5dGVzKSB7Ci0JCQl1bmxpbmtfZnJlZV9zcGFjZShibG9ja19ncm91cCwgZW50cnkpOwotCQkJa2ZyZWUoZW50cnktPmJpdG1hcCk7Ci0JCQlrZnJlZShlbnRyeSk7Ci0JCQlibG9ja19ncm91cC0+dG90YWxfYml0bWFwcy0tOwotCQkJcmVjYWxjdWxhdGVfdGhyZXNob2xkcyhibG9ja19ncm91cCk7Ci0JCX0KKwkJaWYgKCFlbnRyeS0+Ynl0ZXMpCisJCQlmcmVlX2JpdG1hcChibG9ja19ncm91cCwgZW50cnkpOwogCX0gZWxzZSB7CiAJCXVubGlua19mcmVlX3NwYWNlKGJsb2NrX2dyb3VwLCBlbnRyeSk7CiAJCWVudHJ5LT5vZmZzZXQgKz0gYnl0ZXM7CkBAIC0xNzg5LDYgKzE4MTQsOCBAQAogCiAJcmV0ID0gc2VhcmNoX3N0YXJ0OwogCWJpdG1hcF9jbGVhcl9iaXRzKGJsb2NrX2dyb3VwLCBlbnRyeSwgcmV0LCBieXRlcyk7CisJaWYgKGVudHJ5LT5ieXRlcyA9PSAwKQorCQlmcmVlX2JpdG1hcChibG9ja19ncm91cCwgZW50cnkpOwogb3V0OgogCXNwaW5fdW5sb2NrKCZjbHVzdGVyLT5sb2NrKTsKIAlzcGluX3VubG9jaygmYmxvY2tfZ3JvdXAtPnRyZWVfbG9jayk7CkBAIC0xODQyLDE1ICsxODY5LDI2IEBACiAJCWVudHJ5LT5vZmZzZXQgKz0gYnl0ZXM7CiAJCWVudHJ5LT5ieXRlcyAtPSBieXRlczsKIAotCQlpZiAoZW50cnktPmJ5dGVzID09IDApIHsKKwkJaWYgKGVudHJ5LT5ieXRlcyA9PSAwKQogCQkJcmJfZXJhc2UoJmVudHJ5LT5vZmZzZXRfaW5kZXgsICZjbHVzdGVyLT5yb290KTsKLQkJCWtmcmVlKGVudHJ5KTsKLQkJfQogCQlicmVhazsKIAl9CiBvdXQ6CiAJc3Bpbl91bmxvY2soJmNsdXN0ZXItPmxvY2spOwogCisJaWYgKCFyZXQpCisJCXJldHVybiAwOworCisJc3Bpbl9sb2NrKCZibG9ja19ncm91cC0+dHJlZV9sb2NrKTsKKworCWJsb2NrX2dyb3VwLT5mcmVlX3NwYWNlIC09IGJ5dGVzOworCWlmIChlbnRyeS0+Ynl0ZXMgPT0gMCkgeworCQlibG9ja19ncm91cC0+ZnJlZV9leHRlbnRzLS07CisJCWtmcmVlKGVudHJ5KTsKKwl9CisKKwlzcGluX3VubG9jaygmYmxvY2tfZ3JvdXAtPnRyZWVfbG9jayk7CisKIAlyZXR1cm4gcmV0OwogfQogCmRpZmYgLS1naXQgYS9mcy9idHJmcy9pbm9kZS5jIGIvZnMvYnRyZnMvaW5vZGUuYwppbmRleCBhMzc5OGEzLi5iY2M0NjFhIDEwMDY0NAotLS0gYS9mcy9idHJmcy9pbm9kZS5jCisrKyBiL2ZzL2J0cmZzL2lub2RlLmMKQEAgLTEyMiwxMCArMTIyLDEwIEBACiAJc2l6ZV90IGN1cl9zaXplID0gc2l6ZTsKIAlzaXplX3QgZGF0YXNpemU7CiAJdW5zaWduZWQgbG9uZyBvZmZzZXQ7Ci0JaW50IHVzZV9jb21wcmVzcyA9IDA7CisJaW50IGNvbXByZXNzX3R5cGUgPSBCVFJGU19DT01QUkVTU19OT05FOwogCiAJaWYgKGNvbXByZXNzZWRfc2l6ZSAmJiBjb21wcmVzc2VkX3BhZ2VzKSB7Ci0JCXVzZV9jb21wcmVzcyA9IDE7CisJCWNvbXByZXNzX3R5cGUgPSByb290LT5mc19pbmZvLT5jb21wcmVzc190eXBlOwogCQljdXJfc2l6ZSA9IGNvbXByZXNzZWRfc2l6ZTsKIAl9CiAKQEAgLTE1OSw3ICsxNTksNyBAQAogCWJ0cmZzX3NldF9maWxlX2V4dGVudF9yYW1fYnl0ZXMobGVhZiwgZWksIHNpemUpOwogCXB0ciA9IGJ0cmZzX2ZpbGVfZXh0ZW50X2lubGluZV9zdGFydChlaSk7CiAKLQlpZiAodXNlX2NvbXByZXNzKSB7CisJaWYgKGNvbXByZXNzX3R5cGUgIT0gQlRSRlNfQ09NUFJFU1NfTk9ORSkgewogCQlzdHJ1Y3QgcGFnZSAqY3BhZ2U7CiAJCWludCBpID0gMDsKIAkJd2hpbGUgKGNvbXByZXNzZWRfc2l6ZSA+IDApIHsKQEAgLTE3Niw3ICsxNzYsNyBAQAogCQkJY29tcHJlc3NlZF9zaXplIC09IGN1cl9zaXplOwogCQl9CiAJCWJ0cmZzX3NldF9maWxlX2V4dGVudF9jb21wcmVzc2lvbihsZWFmLCBlaSwKLQkJCQkJCSAgQlRSRlNfQ09NUFJFU1NfWkxJQik7CisJCQkJCQkgIGNvbXByZXNzX3R5cGUpOwogCX0gZWxzZSB7CiAJCXBhZ2UgPSBmaW5kX2dldF9wYWdlKGlub2RlLT5pX21hcHBpbmcsCiAJCQkJICAgICBzdGFydCA+PiBQQUdFX0NBQ0hFX1NISUZUKTsKQEAgLTI2Myw2ICsyNjMsNyBAQAogCXU2NCBjb21wcmVzc2VkX3NpemU7CiAJc3RydWN0IHBhZ2UgKipwYWdlczsKIAl1bnNpZ25lZCBsb25nIG5yX3BhZ2VzOworCWludCBjb21wcmVzc190eXBlOwogCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKIH07CiAKQEAgLTI4MCw3ICsyODEsOCBAQAogCQkJCSAgICAgdTY0IHN0YXJ0LCB1NjQgcmFtX3NpemUsCiAJCQkJICAgICB1NjQgY29tcHJlc3NlZF9zaXplLAogCQkJCSAgICAgc3RydWN0IHBhZ2UgKipwYWdlcywKLQkJCQkgICAgIHVuc2lnbmVkIGxvbmcgbnJfcGFnZXMpCisJCQkJICAgICB1bnNpZ25lZCBsb25nIG5yX3BhZ2VzLAorCQkJCSAgICAgaW50IGNvbXByZXNzX3R5cGUpCiB7CiAJc3RydWN0IGFzeW5jX2V4dGVudCAqYXN5bmNfZXh0ZW50OwogCkBAIC0yOTAsNiArMjkyLDcgQEAKIAlhc3luY19leHRlbnQtPmNvbXByZXNzZWRfc2l6ZSA9IGNvbXByZXNzZWRfc2l6ZTsKIAlhc3luY19leHRlbnQtPnBhZ2VzID0gcGFnZXM7CiAJYXN5bmNfZXh0ZW50LT5ucl9wYWdlcyA9IG5yX3BhZ2VzOworCWFzeW5jX2V4dGVudC0+Y29tcHJlc3NfdHlwZSA9IGNvbXByZXNzX3R5cGU7CiAJbGlzdF9hZGRfdGFpbCgmYXN5bmNfZXh0ZW50LT5saXN0LCAmY293LT5leHRlbnRzKTsKIAlyZXR1cm4gMDsKIH0KQEAgLTMzMiw2ICszMzUsNyBAQAogCXVuc2lnbmVkIGxvbmcgbWF4X3VuY29tcHJlc3NlZCA9IDEyOCAqIDEwMjQ7CiAJaW50IGk7CiAJaW50IHdpbGxfY29tcHJlc3M7CisJaW50IGNvbXByZXNzX3R5cGUgPSByb290LT5mc19pbmZvLT5jb21wcmVzc190eXBlOwogCiAJYWN0dWFsX2VuZCA9IG1pbl90KHU2NCwgaXNpemUsIGVuZCArIDEpOwogYWdhaW46CkBAIC0zODEsMTIgKzM4NSwxNiBAQAogCQlXQVJOX09OKHBhZ2VzKTsKIAkJcGFnZXMgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgcGFnZSAqKSAqIG5yX3BhZ2VzLCBHRlBfTk9GUyk7CiAKLQkJcmV0ID0gYnRyZnNfemxpYl9jb21wcmVzc19wYWdlcyhpbm9kZS0+aV9tYXBwaW5nLCBzdGFydCwKLQkJCQkJCXRvdGFsX2NvbXByZXNzZWQsIHBhZ2VzLAotCQkJCQkJbnJfcGFnZXMsICZucl9wYWdlc19yZXQsCi0JCQkJCQkmdG90YWxfaW4sCi0JCQkJCQkmdG90YWxfY29tcHJlc3NlZCwKLQkJCQkJCW1heF9jb21wcmVzc2VkKTsKKwkJaWYgKEJUUkZTX0koaW5vZGUpLT5mb3JjZV9jb21wcmVzcykKKwkJCWNvbXByZXNzX3R5cGUgPSBCVFJGU19JKGlub2RlKS0+Zm9yY2VfY29tcHJlc3M7CisKKwkJcmV0ID0gYnRyZnNfY29tcHJlc3NfcGFnZXMoY29tcHJlc3NfdHlwZSwKKwkJCQkJICAgaW5vZGUtPmlfbWFwcGluZywgc3RhcnQsCisJCQkJCSAgIHRvdGFsX2NvbXByZXNzZWQsIHBhZ2VzLAorCQkJCQkgICBucl9wYWdlcywgJm5yX3BhZ2VzX3JldCwKKwkJCQkJICAgJnRvdGFsX2luLAorCQkJCQkgICAmdG90YWxfY29tcHJlc3NlZCwKKwkJCQkJICAgbWF4X2NvbXByZXNzZWQpOwogCiAJCWlmICghcmV0KSB7CiAJCQl1bnNpZ25lZCBsb25nIG9mZnNldCA9IHRvdGFsX2NvbXByZXNzZWQgJgpAQCAtNDA4LDcgKzQxNiw3IEBACiAJfQogCWlmIChzdGFydCA9PSAwKSB7CiAJCXRyYW5zID0gYnRyZnNfam9pbl90cmFuc2FjdGlvbihyb290LCAxKTsKLQkJQlVHX09OKCF0cmFucyk7CisJCUJVR19PTihJU19FUlIodHJhbnMpKTsKIAkJYnRyZnNfc2V0X3RyYW5zX2Jsb2NrX2dyb3VwKHRyYW5zLCBpbm9kZSk7CiAJCXRyYW5zLT5ibG9ja19yc3YgPSAmcm9vdC0+ZnNfaW5mby0+ZGVsYWxsb2NfYmxvY2tfcnN2OwogCkBAIC00OTMsNyArNTAxLDggQEAKIAkJICogYW5kIHdpbGwgc3VibWl0IHRoZW0gdG8gdGhlIGVsZXZhdG9yLgogCQkgKi8KIAkJYWRkX2FzeW5jX2V4dGVudChhc3luY19jb3csIHN0YXJ0LCBudW1fYnl0ZXMsCi0JCQkJIHRvdGFsX2NvbXByZXNzZWQsIHBhZ2VzLCBucl9wYWdlc19yZXQpOworCQkJCSB0b3RhbF9jb21wcmVzc2VkLCBwYWdlcywgbnJfcGFnZXNfcmV0LAorCQkJCSBjb21wcmVzc190eXBlKTsKIAogCQlpZiAoc3RhcnQgKyBudW1fYnl0ZXMgPCBlbmQpIHsKIAkJCXN0YXJ0ICs9IG51bV9ieXRlczsKQEAgLTUxNSw3ICs1MjQsOCBAQAogCQkJX19zZXRfcGFnZV9kaXJ0eV9ub2J1ZmZlcnMobG9ja2VkX3BhZ2UpOwogCQkJLyogdW5sb2NrZWQgbGF0ZXIgb24gaW4gdGhlIGFzeW5jIGhhbmRsZXJzICovCiAJCX0KLQkJYWRkX2FzeW5jX2V4dGVudChhc3luY19jb3csIHN0YXJ0LCBlbmQgLSBzdGFydCArIDEsIDAsIE5VTEwsIDApOworCQlhZGRfYXN5bmNfZXh0ZW50KGFzeW5jX2Nvdywgc3RhcnQsIGVuZCAtIHN0YXJ0ICsgMSwKKwkJCQkgMCwgTlVMTCwgMCwgQlRSRlNfQ09NUFJFU1NfTk9ORSk7CiAJCSpudW1fYWRkZWQgKz0gMTsKIAl9CiAKQEAgLTYwMiw2ICs2MTIsNyBAQAogCQkJICAgIEdGUF9OT0ZTKTsKIAogCQl0cmFucyA9IGJ0cmZzX2pvaW5fdHJhbnNhY3Rpb24ocm9vdCwgMSk7CisJCUJVR19PTihJU19FUlIodHJhbnMpKTsKIAkJcmV0ID0gYnRyZnNfcmVzZXJ2ZV9leHRlbnQodHJhbnMsIHJvb3QsCiAJCQkJCSAgIGFzeW5jX2V4dGVudC0+Y29tcHJlc3NlZF9zaXplLAogCQkJCQkgICBhc3luY19leHRlbnQtPmNvbXByZXNzZWRfc2l6ZSwKQEAgLTY0MCw2ICs2NTEsNyBAQAogCQllbS0+YmxvY2tfc3RhcnQgPSBpbnMub2JqZWN0aWQ7CiAJCWVtLT5ibG9ja19sZW4gPSBpbnMub2Zmc2V0OwogCQllbS0+YmRldiA9IHJvb3QtPmZzX2luZm8tPmZzX2RldmljZXMtPmxhdGVzdF9iZGV2OworCQllbS0+Y29tcHJlc3NfdHlwZSA9IGFzeW5jX2V4dGVudC0+Y29tcHJlc3NfdHlwZTsKIAkJc2V0X2JpdChFWFRFTlRfRkxBR19QSU5ORUQsICZlbS0+ZmxhZ3MpOwogCQlzZXRfYml0KEVYVEVOVF9GTEFHX0NPTVBSRVNTRUQsICZlbS0+ZmxhZ3MpOwogCkBAIC02NTYsMTEgKzY2OCwxMyBAQAogCQkJCQkJYXN5bmNfZXh0ZW50LT5yYW1fc2l6ZSAtIDEsIDApOwogCQl9CiAKLQkJcmV0ID0gYnRyZnNfYWRkX29yZGVyZWRfZXh0ZW50KGlub2RlLCBhc3luY19leHRlbnQtPnN0YXJ0LAotCQkJCQkgICAgICAgaW5zLm9iamVjdGlkLAotCQkJCQkgICAgICAgYXN5bmNfZXh0ZW50LT5yYW1fc2l6ZSwKLQkJCQkJICAgICAgIGlucy5vZmZzZXQsCi0JCQkJCSAgICAgICBCVFJGU19PUkRFUkVEX0NPTVBSRVNTRUQpOworCQlyZXQgPSBidHJmc19hZGRfb3JkZXJlZF9leHRlbnRfY29tcHJlc3MoaW5vZGUsCisJCQkJCQlhc3luY19leHRlbnQtPnN0YXJ0LAorCQkJCQkJaW5zLm9iamVjdGlkLAorCQkJCQkJYXN5bmNfZXh0ZW50LT5yYW1fc2l6ZSwKKwkJCQkJCWlucy5vZmZzZXQsCisJCQkJCQlCVFJGU19PUkRFUkVEX0NPTVBSRVNTRUQsCisJCQkJCQlhc3luY19leHRlbnQtPmNvbXByZXNzX3R5cGUpOwogCQlCVUdfT04ocmV0KTsKIAogCQkvKgpAQCAtNzU4LDcgKzc3Miw3IEBACiAKIAlCVUdfT04ocm9vdCA9PSByb290LT5mc19pbmZvLT50cmVlX3Jvb3QpOwogCXRyYW5zID0gYnRyZnNfam9pbl90cmFuc2FjdGlvbihyb290LCAxKTsKLQlCVUdfT04oIXRyYW5zKTsKKwlCVUdfT04oSVNfRVJSKHRyYW5zKSk7CiAJYnRyZnNfc2V0X3RyYW5zX2Jsb2NrX2dyb3VwKHRyYW5zLCBpbm9kZSk7CiAJdHJhbnMtPmJsb2NrX3JzdiA9ICZyb290LT5mc19pbmZvLT5kZWxhbGxvY19ibG9ja19yc3Y7CiAKQEAgLTEwMzYsNyArMTA1MCw3IEBACiAJfSBlbHNlIHsKIAkJdHJhbnMgPSBidHJmc19qb2luX3RyYW5zYWN0aW9uKHJvb3QsIDEpOwogCX0KLQlCVUdfT04oIXRyYW5zKTsKKwlCVUdfT04oSVNfRVJSKHRyYW5zKSk7CiAKIAljb3dfc3RhcnQgPSAodTY0KS0xOwogCWN1cl9vZmZzZXQgPSBzdGFydDsKQEAgLTE1NDQsNiArMTU1OCw3IEBACiBvdXRfcGFnZToKIAl1bmxvY2tfcGFnZShwYWdlKTsKIAlwYWdlX2NhY2hlX3JlbGVhc2UocGFnZSk7CisJa2ZyZWUoZml4dXApOwogfQogCiAvKgpAQCAtMTY3MCw3ICsxNjg1LDcgQEAKIAlzdHJ1Y3QgYnRyZnNfb3JkZXJlZF9leHRlbnQgKm9yZGVyZWRfZXh0ZW50ID0gTlVMTDsKIAlzdHJ1Y3QgZXh0ZW50X2lvX3RyZWUgKmlvX3RyZWUgPSAmQlRSRlNfSShpbm9kZSktPmlvX3RyZWU7CiAJc3RydWN0IGV4dGVudF9zdGF0ZSAqY2FjaGVkX3N0YXRlID0gTlVMTDsKLQlpbnQgY29tcHJlc3NlZCA9IDA7CisJaW50IGNvbXByZXNzX3R5cGUgPSAwOwogCWludCByZXQ7CiAJYm9vbCBub2xvY2sgPSBmYWxzZTsKIApAQCAtMTY5MCw3ICsxNzA1LDcgQEAKIAkJCQl0cmFucyA9IGJ0cmZzX2pvaW5fdHJhbnNhY3Rpb25fbm9sb2NrKHJvb3QsIDEpOwogCQkJZWxzZQogCQkJCXRyYW5zID0gYnRyZnNfam9pbl90cmFuc2FjdGlvbihyb290LCAxKTsKLQkJCUJVR19PTighdHJhbnMpOworCQkJQlVHX09OKElTX0VSUih0cmFucykpOwogCQkJYnRyZnNfc2V0X3RyYW5zX2Jsb2NrX2dyb3VwKHRyYW5zLCBpbm9kZSk7CiAJCQl0cmFucy0+YmxvY2tfcnN2ID0gJnJvb3QtPmZzX2luZm8tPmRlbGFsbG9jX2Jsb2NrX3JzdjsKIAkJCXJldCA9IGJ0cmZzX3VwZGF0ZV9pbm9kZSh0cmFucywgcm9vdCwgaW5vZGUpOwpAQCAtMTcwNywxMyArMTcyMiwxNCBAQAogCQl0cmFucyA9IGJ0cmZzX2pvaW5fdHJhbnNhY3Rpb25fbm9sb2NrKHJvb3QsIDEpOwogCWVsc2UKIAkJdHJhbnMgPSBidHJmc19qb2luX3RyYW5zYWN0aW9uKHJvb3QsIDEpOworCUJVR19PTihJU19FUlIodHJhbnMpKTsKIAlidHJmc19zZXRfdHJhbnNfYmxvY2tfZ3JvdXAodHJhbnMsIGlub2RlKTsKIAl0cmFucy0+YmxvY2tfcnN2ID0gJnJvb3QtPmZzX2luZm8tPmRlbGFsbG9jX2Jsb2NrX3JzdjsKIAogCWlmICh0ZXN0X2JpdChCVFJGU19PUkRFUkVEX0NPTVBSRVNTRUQsICZvcmRlcmVkX2V4dGVudC0+ZmxhZ3MpKQotCQljb21wcmVzc2VkID0gMTsKKwkJY29tcHJlc3NfdHlwZSA9IG9yZGVyZWRfZXh0ZW50LT5jb21wcmVzc190eXBlOwogCWlmICh0ZXN0X2JpdChCVFJGU19PUkRFUkVEX1BSRUFMTE9DLCAmb3JkZXJlZF9leHRlbnQtPmZsYWdzKSkgewotCQlCVUdfT04oY29tcHJlc3NlZCk7CisJCUJVR19PTihjb21wcmVzc190eXBlKTsKIAkJcmV0ID0gYnRyZnNfbWFya19leHRlbnRfd3JpdHRlbih0cmFucywgaW5vZGUsCiAJCQkJCQlvcmRlcmVkX2V4dGVudC0+ZmlsZV9vZmZzZXQsCiAJCQkJCQlvcmRlcmVkX2V4dGVudC0+ZmlsZV9vZmZzZXQgKwpAQCAtMTcyNyw3ICsxNzQzLDcgQEAKIAkJCQkJCW9yZGVyZWRfZXh0ZW50LT5kaXNrX2xlbiwKIAkJCQkJCW9yZGVyZWRfZXh0ZW50LT5sZW4sCiAJCQkJCQlvcmRlcmVkX2V4dGVudC0+bGVuLAotCQkJCQkJY29tcHJlc3NlZCwgMCwgMCwKKwkJCQkJCWNvbXByZXNzX3R5cGUsIDAsIDAsCiAJCQkJCQlCVFJGU19GSUxFX0VYVEVOVF9SRUcpOwogCQl1bnBpbl9leHRlbnRfY2FjaGUoJkJUUkZTX0koaW5vZGUpLT5leHRlbnRfdHJlZSwKIAkJCQkgICBvcmRlcmVkX2V4dGVudC0+ZmlsZV9vZmZzZXQsCkBAIC0xODI5LDYgKzE4NDUsOCBAQAogCQlpZiAodGVzdF9iaXQoRVhURU5UX0ZMQUdfQ09NUFJFU1NFRCwgJmVtLT5mbGFncykpIHsKIAkJCWxvZ2ljYWwgPSBlbS0+YmxvY2tfc3RhcnQ7CiAJCQlmYWlscmVjLT5iaW9fZmxhZ3MgPSBFWFRFTlRfQklPX0NPTVBSRVNTRUQ7CisJCQlleHRlbnRfc2V0X2NvbXByZXNzX3R5cGUoJmZhaWxyZWMtPmJpb19mbGFncywKKwkJCQkJCSBlbS0+Y29tcHJlc3NfdHlwZSk7CiAJCX0KIAkJZmFpbHJlYy0+bG9naWNhbCA9IGxvZ2ljYWw7CiAJCWZyZWVfZXh0ZW50X21hcChlbSk7CkBAIC0yMzM5LDYgKzIzNTcsNyBAQAogCQkgKi8KIAkJaWYgKGlzX2JhZF9pbm9kZShpbm9kZSkpIHsKIAkJCXRyYW5zID0gYnRyZnNfc3RhcnRfdHJhbnNhY3Rpb24ocm9vdCwgMCk7CisJCQlCVUdfT04oSVNfRVJSKHRyYW5zKSk7CiAJCQlidHJmc19vcnBoYW5fZGVsKHRyYW5zLCBpbm9kZSk7CiAJCQlidHJmc19lbmRfdHJhbnNhY3Rpb24odHJhbnMsIHJvb3QpOwogCQkJaXB1dChpbm9kZSk7CkBAIC0yMzY2LDYgKzIzODUsNyBAQAogCiAJaWYgKHJvb3QtPm9ycGhhbl9ibG9ja19yc3YgfHwgcm9vdC0+b3JwaGFuX2l0ZW1faW5zZXJ0ZWQpIHsKIAkJdHJhbnMgPSBidHJmc19qb2luX3RyYW5zYWN0aW9uKHJvb3QsIDEpOworCQlCVUdfT04oSVNfRVJSKHRyYW5zKSk7CiAJCWJ0cmZzX2VuZF90cmFuc2FjdGlvbih0cmFucywgcm9vdCk7CiAJfQogCkBAIC0yNjI2LDcgKzI2NDYsNyBAQAogCXBhdGggPSBidHJmc19hbGxvY19wYXRoKCk7CiAJaWYgKCFwYXRoKSB7CiAJCXJldCA9IC1FTk9NRU07Ci0JCWdvdG8gZXJyOworCQlnb3RvIG91dDsKIAl9CiAKIAlwYXRoLT5sZWF2ZV9zcGlubmluZyA9IDE7CkBAIC0yNjk5LDkgKzI3MTksMTAgQEAKIAlzdHJ1Y3QgZXh0ZW50X2J1ZmZlciAqZWI7CiAJaW50IGxldmVsOwogCXU2NCByZWZzID0gMTsKLQlpbnQgdW5pbml0aWFsaXplZF92YXIocmV0KTsKIAogCWZvciAobGV2ZWwgPSAwOyBsZXZlbCA8IEJUUkZTX01BWF9MRVZFTDsgbGV2ZWwrKykgeworCQlpbnQgcmV0OworCiAJCWlmICghcGF0aC0+bm9kZXNbbGV2ZWxdKQogCQkJYnJlYWs7CiAJCWViID0gcGF0aC0+bm9kZXNbbGV2ZWxdOwpAQCAtMjcxMiw3ICsyNzMzLDcgQEAKIAkJaWYgKHJlZnMgPiAxKQogCQkJcmV0dXJuIDE7CiAJfQotCXJldHVybiByZXQ7IC8qIFhYWCBjYWxsZXJzPyAqLworCXJldHVybiAwOwogfQogCiAvKgpAQCAtMzY3MSw4ICszNjkyLDEyIEBACiBzdGF0aWMgaW50IGJ0cmZzX3NldGF0dHIoc3RydWN0IGRlbnRyeSAqZGVudHJ5LCBzdHJ1Y3QgaWF0dHIgKmF0dHIpCiB7CiAJc3RydWN0IGlub2RlICppbm9kZSA9IGRlbnRyeS0+ZF9pbm9kZTsKKwlzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCA9IEJUUkZTX0koaW5vZGUpLT5yb290OwogCWludCBlcnI7CiAKKwlpZiAoYnRyZnNfcm9vdF9yZWFkb25seShyb290KSkKKwkJcmV0dXJuIC1FUk9GUzsKKwogCWVyciA9IGlub2RlX2NoYW5nZV9vayhpbm9kZSwgYXR0cik7CiAJaWYgKGVycikKIAkJcmV0dXJuIGVycjsKQEAgLTQxMTUsNyArNDE0MCw3IEBACiAJfQogCXNyY3VfcmVhZF91bmxvY2soJnJvb3QtPmZzX2luZm8tPnN1YnZvbF9zcmN1LCBpbmRleCk7CiAKLQlpZiAocm9vdCAhPSBzdWJfcm9vdCkgeworCWlmICghSVNfRVJSKGlub2RlKSAmJiByb290ICE9IHN1Yl9yb290KSB7CiAJCWRvd25fcmVhZCgmcm9vdC0+ZnNfaW5mby0+Y2xlYW51cF93b3JrX3NlbSk7CiAJCWlmICghKGlub2RlLT5pX3NiLT5zX2ZsYWdzICYgTVNfUkRPTkxZKSkKIAkJCWJ0cmZzX29ycGhhbl9jbGVhbnVwKHN1Yl9yb290KTsKQEAgLTQzMjgsNiArNDM1Myw4IEBACiAJCQl0cmFucyA9IGJ0cmZzX2pvaW5fdHJhbnNhY3Rpb25fbm9sb2NrKHJvb3QsIDEpOwogCQllbHNlCiAJCQl0cmFucyA9IGJ0cmZzX2pvaW5fdHJhbnNhY3Rpb24ocm9vdCwgMSk7CisJCWlmIChJU19FUlIodHJhbnMpKQorCQkJcmV0dXJuIFBUUl9FUlIodHJhbnMpOwogCQlidHJmc19zZXRfdHJhbnNfYmxvY2tfZ3JvdXAodHJhbnMsIGlub2RlKTsKIAkJaWYgKG5vbG9jaykKIAkJCXJldCA9IGJ0cmZzX2VuZF90cmFuc2FjdGlvbl9ub2xvY2sodHJhbnMsIHJvb3QpOwpAQCAtNDM1Myw2ICs0MzgwLDcgQEAKIAkJcmV0dXJuOwogCiAJdHJhbnMgPSBidHJmc19qb2luX3RyYW5zYWN0aW9uKHJvb3QsIDEpOworCUJVR19PTihJU19FUlIodHJhbnMpKTsKIAlidHJmc19zZXRfdHJhbnNfYmxvY2tfZ3JvdXAodHJhbnMsIGlub2RlKTsKIAogCXJldCA9IGJ0cmZzX3VwZGF0ZV9pbm9kZSh0cmFucywgcm9vdCwgaW5vZGUpOwpAQCAtNDkyOCw4ICs0OTU2LDEwIEBACiAJc2l6ZV90IG1heF9zaXplOwogCXVuc2lnbmVkIGxvbmcgaW5saW5lX3NpemU7CiAJdW5zaWduZWQgbG9uZyBwdHI7CisJaW50IGNvbXByZXNzX3R5cGU7CiAKIAlXQVJOX09OKHBnX29mZnNldCAhPSAwKTsKKwljb21wcmVzc190eXBlID0gYnRyZnNfZmlsZV9leHRlbnRfY29tcHJlc3Npb24obGVhZiwgaXRlbSk7CiAJbWF4X3NpemUgPSBidHJmc19maWxlX2V4dGVudF9yYW1fYnl0ZXMobGVhZiwgaXRlbSk7CiAJaW5saW5lX3NpemUgPSBidHJmc19maWxlX2V4dGVudF9pbmxpbmVfaXRlbV9sZW4obGVhZiwKIAkJCQkJYnRyZnNfaXRlbV9ucihsZWFmLCBwYXRoLT5zbG90c1swXSkpOwpAQCAtNDkzOSw4ICs0OTY5LDggQEAKIAlyZWFkX2V4dGVudF9idWZmZXIobGVhZiwgdG1wLCBwdHIsIGlubGluZV9zaXplKTsKIAogCW1heF9zaXplID0gbWluX3QodW5zaWduZWQgbG9uZywgUEFHRV9DQUNIRV9TSVpFLCBtYXhfc2l6ZSk7Ci0JcmV0ID0gYnRyZnNfemxpYl9kZWNvbXByZXNzKHRtcCwgcGFnZSwgZXh0ZW50X29mZnNldCwKLQkJCQkgICAgaW5saW5lX3NpemUsIG1heF9zaXplKTsKKwlyZXQgPSBidHJmc19kZWNvbXByZXNzKGNvbXByZXNzX3R5cGUsIHRtcCwgcGFnZSwKKwkJCSAgICAgICBleHRlbnRfb2Zmc2V0LCBpbmxpbmVfc2l6ZSwgbWF4X3NpemUpOwogCWlmIChyZXQpIHsKIAkJY2hhciAqa2FkZHIgPSBrbWFwX2F0b21pYyhwYWdlLCBLTV9VU0VSMCk7CiAJCXVuc2lnbmVkIGxvbmcgY29weV9zaXplID0gbWluX3QodTY0LApAQCAtNDk4Miw3ICs1MDEyLDcgQEAKIAlzdHJ1Y3QgZXh0ZW50X21hcF90cmVlICplbV90cmVlID0gJkJUUkZTX0koaW5vZGUpLT5leHRlbnRfdHJlZTsKIAlzdHJ1Y3QgZXh0ZW50X2lvX3RyZWUgKmlvX3RyZWUgPSAmQlRSRlNfSShpbm9kZSktPmlvX3RyZWU7CiAJc3RydWN0IGJ0cmZzX3RyYW5zX2hhbmRsZSAqdHJhbnMgPSBOVUxMOwotCWludCBjb21wcmVzc2VkOworCWludCBjb21wcmVzc190eXBlOwogCiBhZ2FpbjoKIAlyZWFkX2xvY2soJmVtX3RyZWUtPmxvY2spOwpAQCAtNTA0MSw3ICs1MDcxLDcgQEAKIAogCWZvdW5kX3R5cGUgPSBidHJmc19maWxlX2V4dGVudF90eXBlKGxlYWYsIGl0ZW0pOwogCWV4dGVudF9zdGFydCA9IGZvdW5kX2tleS5vZmZzZXQ7Ci0JY29tcHJlc3NlZCA9IGJ0cmZzX2ZpbGVfZXh0ZW50X2NvbXByZXNzaW9uKGxlYWYsIGl0ZW0pOworCWNvbXByZXNzX3R5cGUgPSBidHJmc19maWxlX2V4dGVudF9jb21wcmVzc2lvbihsZWFmLCBpdGVtKTsKIAlpZiAoZm91bmRfdHlwZSA9PSBCVFJGU19GSUxFX0VYVEVOVF9SRUcgfHwKIAkgICAgZm91bmRfdHlwZSA9PSBCVFJGU19GSUxFX0VYVEVOVF9QUkVBTExPQykgewogCQlleHRlbnRfZW5kID0gZXh0ZW50X3N0YXJ0ICsKQEAgLTUwODcsOCArNTExNyw5IEBACiAJCQllbS0+YmxvY2tfc3RhcnQgPSBFWFRFTlRfTUFQX0hPTEU7CiAJCQlnb3RvIGluc2VydDsKIAkJfQotCQlpZiAoY29tcHJlc3NlZCkgeworCQlpZiAoY29tcHJlc3NfdHlwZSAhPSBCVFJGU19DT01QUkVTU19OT05FKSB7CiAJCQlzZXRfYml0KEVYVEVOVF9GTEFHX0NPTVBSRVNTRUQsICZlbS0+ZmxhZ3MpOworCQkJZW0tPmNvbXByZXNzX3R5cGUgPSBjb21wcmVzc190eXBlOwogCQkJZW0tPmJsb2NrX3N0YXJ0ID0gYnl0ZW5yOwogCQkJZW0tPmJsb2NrX2xlbiA9IGJ0cmZzX2ZpbGVfZXh0ZW50X2Rpc2tfbnVtX2J5dGVzKGxlYWYsCiAJCQkJCQkJCQkgaXRlbSk7CkBAIC01MTIyLDEyICs1MTUzLDE0IEBACiAJCWVtLT5sZW4gPSAoY29weV9zaXplICsgcm9vdC0+c2VjdG9yc2l6ZSAtIDEpICYKIAkJCX4oKHU2NClyb290LT5zZWN0b3JzaXplIC0gMSk7CiAJCWVtLT5vcmlnX3N0YXJ0ID0gRVhURU5UX01BUF9JTkxJTkU7Ci0JCWlmIChjb21wcmVzc2VkKQorCQlpZiAoY29tcHJlc3NfdHlwZSkgewogCQkJc2V0X2JpdChFWFRFTlRfRkxBR19DT01QUkVTU0VELCAmZW0tPmZsYWdzKTsKKwkJCWVtLT5jb21wcmVzc190eXBlID0gY29tcHJlc3NfdHlwZTsKKwkJfQogCQlwdHIgPSBidHJmc19maWxlX2V4dGVudF9pbmxpbmVfc3RhcnQoaXRlbSkgKyBleHRlbnRfb2Zmc2V0OwogCQlpZiAoY3JlYXRlID09IDAgJiYgIVBhZ2VVcHRvZGF0ZShwYWdlKSkgewotCQkJaWYgKGJ0cmZzX2ZpbGVfZXh0ZW50X2NvbXByZXNzaW9uKGxlYWYsIGl0ZW0pID09Ci0JCQkgICAgQlRSRlNfQ09NUFJFU1NfWkxJQikgeworCQkJaWYgKGJ0cmZzX2ZpbGVfZXh0ZW50X2NvbXByZXNzaW9uKGxlYWYsIGl0ZW0pICE9CisJCQkgICAgQlRSRlNfQ09NUFJFU1NfTk9ORSkgewogCQkJCXJldCA9IHVuY29tcHJlc3NfaW5saW5lKHBhdGgsIGlub2RlLCBwYWdlLAogCQkJCQkJCXBnX29mZnNldCwKIAkJCQkJCQlleHRlbnRfb2Zmc2V0LCBpdGVtKTsKQEAgLTUxNTIsNiArNTE4NSw4IEBACiAJCQkJZW0gPSBOVUxMOwogCQkJCWJ0cmZzX3JlbGVhc2VfcGF0aChyb290LCBwYXRoKTsKIAkJCQl0cmFucyA9IGJ0cmZzX2pvaW5fdHJhbnNhY3Rpb24ocm9vdCwgMSk7CisJCQkJaWYgKElTX0VSUih0cmFucykpCisJCQkJCXJldHVybiBFUlJfQ0FTVCh0cmFucyk7CiAJCQkJZ290byBhZ2FpbjsKIAkJCX0KIAkJCW1hcCA9IGttYXAocGFnZSk7CkBAIC01MjU2LDggKzUyOTEsOCBAQAogCWJ0cmZzX2Ryb3BfZXh0ZW50X2NhY2hlKGlub2RlLCBzdGFydCwgc3RhcnQgKyBsZW4gLSAxLCAwKTsKIAogCXRyYW5zID0gYnRyZnNfam9pbl90cmFuc2FjdGlvbihyb290LCAwKTsKLQlpZiAoIXRyYW5zKQotCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKwlpZiAoSVNfRVJSKHRyYW5zKSkKKwkJcmV0dXJuIEVSUl9DQVNUKHRyYW5zKTsKIAogCXRyYW5zLT5ibG9ja19yc3YgPSAmcm9vdC0+ZnNfaW5mby0+ZGVsYWxsb2NfYmxvY2tfcnN2OwogCkBAIC01NDgxLDcgKzU1MTYsNyBAQAogCQkgKiB3aGlsZSB3ZSBsb29rIGZvciBub2NvdyBjcm9zcyByZWZzCiAJCSAqLwogCQl0cmFucyA9IGJ0cmZzX2pvaW5fdHJhbnNhY3Rpb24ocm9vdCwgMCk7Ci0JCWlmICghdHJhbnMpCisJCWlmIChJU19FUlIodHJhbnMpKQogCQkJZ290byBtdXN0X2NvdzsKIAogCQlpZiAoY2FuX25vY293X29kaXJlY3QodHJhbnMsIGlub2RlLCBzdGFydCwgbGVuKSA9PSAxKSB7CkBAIC01NjE2LDcgKzU2NTEsNyBAQAogCUJVR19PTighb3JkZXJlZCk7CiAKIAl0cmFucyA9IGJ0cmZzX2pvaW5fdHJhbnNhY3Rpb24ocm9vdCwgMSk7Ci0JaWYgKCF0cmFucykgeworCWlmIChJU19FUlIodHJhbnMpKSB7CiAJCWVyciA9IC1FTk9NRU07CiAJCWdvdG8gb3V0OwogCX0KQEAgLTY0NzcsNyArNjUxMiw3IEBACiAJZWktPm9yZGVyZWRfZGF0YV9jbG9zZSA9IDA7CiAJZWktPm9ycGhhbl9tZXRhX3Jlc2VydmVkID0gMDsKIAllaS0+ZHVtbXlfaW5vZGUgPSAwOwotCWVpLT5mb3JjZV9jb21wcmVzcyA9IDA7CisJZWktPmZvcmNlX2NvbXByZXNzID0gQlRSRlNfQ09NUFJFU1NfTk9ORTsKIAogCWlub2RlID0gJmVpLT52ZnNfaW5vZGU7CiAJZXh0ZW50X21hcF90cmVlX2luaXQoJmVpLT5leHRlbnRfdHJlZSwgR0ZQX05PRlMpOwpAQCAtNzA5OCwxMTYgKzcxMzMsNiBAQAogCQkJCQkgICBtaW5fc2l6ZSwgYWN0dWFsX2xlbiwgYWxsb2NfaGludCwgdHJhbnMpOwogfQogCi1zdGF0aWMgbG9uZyBidHJmc19mYWxsb2NhdGUoc3RydWN0IGlub2RlICppbm9kZSwgaW50IG1vZGUsCi0JCQkgICAgbG9mZl90IG9mZnNldCwgbG9mZl90IGxlbikKLXsKLQlzdHJ1Y3QgZXh0ZW50X3N0YXRlICpjYWNoZWRfc3RhdGUgPSBOVUxMOwotCXU2NCBjdXJfb2Zmc2V0OwotCXU2NCBsYXN0X2J5dGU7Ci0JdTY0IGFsbG9jX3N0YXJ0OwotCXU2NCBhbGxvY19lbmQ7Ci0JdTY0IGFsbG9jX2hpbnQgPSAwOwotCXU2NCBsb2NrZWRfZW5kOwotCXU2NCBtYXNrID0gQlRSRlNfSShpbm9kZSktPnJvb3QtPnNlY3RvcnNpemUgLSAxOwotCXN0cnVjdCBleHRlbnRfbWFwICplbTsKLQlpbnQgcmV0OwotCi0JYWxsb2Nfc3RhcnQgPSBvZmZzZXQgJiB+bWFzazsKLQlhbGxvY19lbmQgPSAgKG9mZnNldCArIGxlbiArIG1hc2spICYgfm1hc2s7Ci0KLQkvKiBXZSBvbmx5IHN1cHBvcnQgdGhlIEZBTExPQ19GTF9LRUVQX1NJWkUgbW9kZSAqLwotCWlmIChtb2RlICYmIChtb2RlICE9IEZBTExPQ19GTF9LRUVQX1NJWkUpKQotCQlyZXR1cm4gLUVPUE5PVFNVUFA7Ci0KLQkvKgotCSAqIHdhaXQgZm9yIG9yZGVyZWQgSU8gYmVmb3JlIHdlIGhhdmUgYW55IGxvY2tzLiAgV2UnbGwgbG9vcCBhZ2FpbgotCSAqIGJlbG93IHdpdGggdGhlIGxvY2tzIGhlbGQuCi0JICovCi0JYnRyZnNfd2FpdF9vcmRlcmVkX3JhbmdlKGlub2RlLCBhbGxvY19zdGFydCwgYWxsb2NfZW5kIC0gYWxsb2Nfc3RhcnQpOwotCi0JbXV0ZXhfbG9jaygmaW5vZGUtPmlfbXV0ZXgpOwotCXJldCA9IGlub2RlX25ld3NpemVfb2soaW5vZGUsIGFsbG9jX2VuZCk7Ci0JaWYgKHJldCkKLQkJZ290byBvdXQ7Ci0KLQlpZiAoYWxsb2Nfc3RhcnQgPiBpbm9kZS0+aV9zaXplKSB7Ci0JCXJldCA9IGJ0cmZzX2NvbnRfZXhwYW5kKGlub2RlLCBhbGxvY19zdGFydCk7Ci0JCWlmIChyZXQpCi0JCQlnb3RvIG91dDsKLQl9Ci0KLQlyZXQgPSBidHJmc19jaGVja19kYXRhX2ZyZWVfc3BhY2UoaW5vZGUsIGFsbG9jX2VuZCAtIGFsbG9jX3N0YXJ0KTsKLQlpZiAocmV0KQotCQlnb3RvIG91dDsKLQotCWxvY2tlZF9lbmQgPSBhbGxvY19lbmQgLSAxOwotCXdoaWxlICgxKSB7Ci0JCXN0cnVjdCBidHJmc19vcmRlcmVkX2V4dGVudCAqb3JkZXJlZDsKLQotCQkvKiB0aGUgZXh0ZW50IGxvY2sgaXMgb3JkZXJlZCBpbnNpZGUgdGhlIHJ1bm5pbmcKLQkJICogdHJhbnNhY3Rpb24KLQkJICovCi0JCWxvY2tfZXh0ZW50X2JpdHMoJkJUUkZTX0koaW5vZGUpLT5pb190cmVlLCBhbGxvY19zdGFydCwKLQkJCQkgbG9ja2VkX2VuZCwgMCwgJmNhY2hlZF9zdGF0ZSwgR0ZQX05PRlMpOwotCQlvcmRlcmVkID0gYnRyZnNfbG9va3VwX2ZpcnN0X29yZGVyZWRfZXh0ZW50KGlub2RlLAotCQkJCQkJCSAgICBhbGxvY19lbmQgLSAxKTsKLQkJaWYgKG9yZGVyZWQgJiYKLQkJICAgIG9yZGVyZWQtPmZpbGVfb2Zmc2V0ICsgb3JkZXJlZC0+bGVuID4gYWxsb2Nfc3RhcnQgJiYKLQkJICAgIG9yZGVyZWQtPmZpbGVfb2Zmc2V0IDwgYWxsb2NfZW5kKSB7Ci0JCQlidHJmc19wdXRfb3JkZXJlZF9leHRlbnQob3JkZXJlZCk7Ci0JCQl1bmxvY2tfZXh0ZW50X2NhY2hlZCgmQlRSRlNfSShpbm9kZSktPmlvX3RyZWUsCi0JCQkJCSAgICAgYWxsb2Nfc3RhcnQsIGxvY2tlZF9lbmQsCi0JCQkJCSAgICAgJmNhY2hlZF9zdGF0ZSwgR0ZQX05PRlMpOwotCQkJLyoKLQkJCSAqIHdlIGNhbid0IHdhaXQgb24gdGhlIHJhbmdlIHdpdGggdGhlIHRyYW5zYWN0aW9uCi0JCQkgKiBydW5uaW5nIG9yIHdpdGggdGhlIGV4dGVudCBsb2NrIGhlbGQKLQkJCSAqLwotCQkJYnRyZnNfd2FpdF9vcmRlcmVkX3JhbmdlKGlub2RlLCBhbGxvY19zdGFydCwKLQkJCQkJCSBhbGxvY19lbmQgLSBhbGxvY19zdGFydCk7Ci0JCX0gZWxzZSB7Ci0JCQlpZiAob3JkZXJlZCkKLQkJCQlidHJmc19wdXRfb3JkZXJlZF9leHRlbnQob3JkZXJlZCk7Ci0JCQlicmVhazsKLQkJfQotCX0KLQotCWN1cl9vZmZzZXQgPSBhbGxvY19zdGFydDsKLQl3aGlsZSAoMSkgewotCQllbSA9IGJ0cmZzX2dldF9leHRlbnQoaW5vZGUsIE5VTEwsIDAsIGN1cl9vZmZzZXQsCi0JCQkJICAgICAgYWxsb2NfZW5kIC0gY3VyX29mZnNldCwgMCk7Ci0JCUJVR19PTihJU19FUlIoZW0pIHx8ICFlbSk7Ci0JCWxhc3RfYnl0ZSA9IG1pbihleHRlbnRfbWFwX2VuZChlbSksIGFsbG9jX2VuZCk7Ci0JCWxhc3RfYnl0ZSA9IChsYXN0X2J5dGUgKyBtYXNrKSAmIH5tYXNrOwotCQlpZiAoZW0tPmJsb2NrX3N0YXJ0ID09IEVYVEVOVF9NQVBfSE9MRSB8fAotCQkgICAgKGN1cl9vZmZzZXQgPj0gaW5vZGUtPmlfc2l6ZSAmJgotCQkgICAgICF0ZXN0X2JpdChFWFRFTlRfRkxBR19QUkVBTExPQywgJmVtLT5mbGFncykpKSB7Ci0JCQlyZXQgPSBidHJmc19wcmVhbGxvY19maWxlX3JhbmdlKGlub2RlLCBtb2RlLCBjdXJfb2Zmc2V0LAotCQkJCQkJCWxhc3RfYnl0ZSAtIGN1cl9vZmZzZXQsCi0JCQkJCQkJMSA8PCBpbm9kZS0+aV9ibGtiaXRzLAotCQkJCQkJCW9mZnNldCArIGxlbiwKLQkJCQkJCQkmYWxsb2NfaGludCk7Ci0JCQlpZiAocmV0IDwgMCkgewotCQkJCWZyZWVfZXh0ZW50X21hcChlbSk7Ci0JCQkJYnJlYWs7Ci0JCQl9Ci0JCX0KLQkJZnJlZV9leHRlbnRfbWFwKGVtKTsKLQotCQljdXJfb2Zmc2V0ID0gbGFzdF9ieXRlOwotCQlpZiAoY3VyX29mZnNldCA+PSBhbGxvY19lbmQpIHsKLQkJCXJldCA9IDA7Ci0JCQlicmVhazsKLQkJfQotCX0KLQl1bmxvY2tfZXh0ZW50X2NhY2hlZCgmQlRSRlNfSShpbm9kZSktPmlvX3RyZWUsIGFsbG9jX3N0YXJ0LCBsb2NrZWRfZW5kLAotCQkJICAgICAmY2FjaGVkX3N0YXRlLCBHRlBfTk9GUyk7Ci0KLQlidHJmc19mcmVlX3Jlc2VydmVkX2RhdGFfc3BhY2UoaW5vZGUsIGFsbG9jX2VuZCAtIGFsbG9jX3N0YXJ0KTsKLW91dDoKLQltdXRleF91bmxvY2soJmlub2RlLT5pX211dGV4KTsKLQlyZXR1cm4gcmV0OwotfQotCiBzdGF0aWMgaW50IGJ0cmZzX3NldF9wYWdlX2RpcnR5KHN0cnVjdCBwYWdlICpwYWdlKQogewogCXJldHVybiBfX3NldF9wYWdlX2RpcnR5X25vYnVmZmVycyhwYWdlKTsKQEAgLTcyMTUsNiArNzE0MCwxMCBAQAogCiBzdGF0aWMgaW50IGJ0cmZzX3Blcm1pc3Npb24oc3RydWN0IGlub2RlICppbm9kZSwgaW50IG1hc2ssIHVuc2lnbmVkIGludCBmbGFncykKIHsKKwlzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCA9IEJUUkZTX0koaW5vZGUpLT5yb290OworCisJaWYgKGJ0cmZzX3Jvb3RfcmVhZG9ubHkocm9vdCkgJiYgKG1hc2sgJiBNQVlfV1JJVEUpKQorCQlyZXR1cm4gLUVST0ZTOwogCWlmICgoQlRSRlNfSShpbm9kZSktPmZsYWdzICYgQlRSRlNfSU5PREVfUkVBRE9OTFkpICYmIChtYXNrICYgTUFZX1dSSVRFKSkKIAkJcmV0dXJuIC1FQUNDRVM7CiAJcmV0dXJuIGdlbmVyaWNfcGVybWlzc2lvbihpbm9kZSwgbWFzaywgZmxhZ3MsIGJ0cmZzX2NoZWNrX2FjbCk7CkBAIC03MzEwLDcgKzcyMzksNiBAQAogCS5saXN0eGF0dHIgICAgICA9IGJ0cmZzX2xpc3R4YXR0ciwKIAkucmVtb3ZleGF0dHIJPSBidHJmc19yZW1vdmV4YXR0ciwKIAkucGVybWlzc2lvbgk9IGJ0cmZzX3Blcm1pc3Npb24sCi0JLmZhbGxvY2F0ZQk9IGJ0cmZzX2ZhbGxvY2F0ZSwKIAkuZmllbWFwCQk9IGJ0cmZzX2ZpZW1hcCwKIH07CiBzdGF0aWMgY29uc3Qgc3RydWN0IGlub2RlX29wZXJhdGlvbnMgYnRyZnNfc3BlY2lhbF9pbm9kZV9vcGVyYXRpb25zID0gewpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvaW9jdGwuYyBiL2ZzL2J0cmZzL2lvY3RsLmMKaW5kZXggZjg3NTUyYS4uMDJkMjI0ZSAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvaW9jdGwuYworKysgYi9mcy9idHJmcy9pb2N0bC5jCkBAIC0xNDcsNiArMTQ3LDkgQEAKIAl1bnNpZ25lZCBpbnQgZmxhZ3MsIG9sZGZsYWdzOwogCWludCByZXQ7CiAKKwlpZiAoYnRyZnNfcm9vdF9yZWFkb25seShyb290KSkKKwkJcmV0dXJuIC1FUk9GUzsKKwogCWlmIChjb3B5X2Zyb21fdXNlcigmZmxhZ3MsIGFyZywgc2l6ZW9mKGZsYWdzKSkpCiAJCXJldHVybiAtRUZBVUxUOwogCkBAIC0yMDAsNyArMjAzLDcgQEAKIAogCiAJdHJhbnMgPSBidHJmc19qb2luX3RyYW5zYWN0aW9uKHJvb3QsIDEpOwotCUJVR19PTighdHJhbnMpOworCUJVR19PTihJU19FUlIodHJhbnMpKTsKIAogCXJldCA9IGJ0cmZzX3VwZGF0ZV9pbm9kZSh0cmFucywgcm9vdCwgaW5vZGUpOwogCUJVR19PTihyZXQpOwpAQCAtMzYwLDcgKzM2Myw4IEBACiB9CiAKIHN0YXRpYyBpbnQgY3JlYXRlX3NuYXBzaG90KHN0cnVjdCBidHJmc19yb290ICpyb290LCBzdHJ1Y3QgZGVudHJ5ICpkZW50cnksCi0JCQkgICBjaGFyICpuYW1lLCBpbnQgbmFtZWxlbiwgdTY0ICphc3luY190cmFuc2lkKQorCQkJICAgY2hhciAqbmFtZSwgaW50IG5hbWVsZW4sIHU2NCAqYXN5bmNfdHJhbnNpZCwKKwkJCSAgIGJvb2wgcmVhZG9ubHkpCiB7CiAJc3RydWN0IGlub2RlICppbm9kZTsKIAlzdHJ1Y3QgZGVudHJ5ICpwYXJlbnQ7CkBAIC0zNzgsNiArMzgyLDcgQEAKIAlidHJmc19pbml0X2Jsb2NrX3JzdigmcGVuZGluZ19zbmFwc2hvdC0+YmxvY2tfcnN2KTsKIAlwZW5kaW5nX3NuYXBzaG90LT5kZW50cnkgPSBkZW50cnk7CiAJcGVuZGluZ19zbmFwc2hvdC0+cm9vdCA9IHJvb3Q7CisJcGVuZGluZ19zbmFwc2hvdC0+cmVhZG9ubHkgPSByZWFkb25seTsKIAogCXRyYW5zID0gYnRyZnNfc3RhcnRfdHJhbnNhY3Rpb24ocm9vdC0+ZnNfaW5mby0+ZXh0ZW50X3Jvb3QsIDUpOwogCWlmIChJU19FUlIodHJhbnMpKSB7CkBAIC01MDksNyArNTE0LDcgQEAKIHN0YXRpYyBub2lubGluZSBpbnQgYnRyZnNfbWtzdWJ2b2woc3RydWN0IHBhdGggKnBhcmVudCwKIAkJCQkgICBjaGFyICpuYW1lLCBpbnQgbmFtZWxlbiwKIAkJCQkgICBzdHJ1Y3QgYnRyZnNfcm9vdCAqc25hcF9zcmMsCi0JCQkJICAgdTY0ICphc3luY190cmFuc2lkKQorCQkJCSAgIHU2NCAqYXN5bmNfdHJhbnNpZCwgYm9vbCByZWFkb25seSkKIHsKIAlzdHJ1Y3QgaW5vZGUgKmRpciAgPSBwYXJlbnQtPmRlbnRyeS0+ZF9pbm9kZTsKIAlzdHJ1Y3QgZGVudHJ5ICpkZW50cnk7CkBAIC01NDEsNyArNTQ2LDcgQEAKIAogCWlmIChzbmFwX3NyYykgewogCQllcnJvciA9IGNyZWF0ZV9zbmFwc2hvdChzbmFwX3NyYywgZGVudHJ5LAotCQkJCQluYW1lLCBuYW1lbGVuLCBhc3luY190cmFuc2lkKTsKKwkJCQkJbmFtZSwgbmFtZWxlbiwgYXN5bmNfdHJhbnNpZCwgcmVhZG9ubHkpOwogCX0gZWxzZSB7CiAJCWVycm9yID0gY3JlYXRlX3N1YnZvbChCVFJGU19JKGRpciktPnJvb3QsIGRlbnRyeSwKIAkJCQkgICAgICBuYW1lLCBuYW1lbGVuLCBhc3luY190cmFuc2lkKTsKQEAgLTYzOCw5ICs2NDMsMTEgQEAKIAlzdHJ1Y3QgZXh0ZW50X2lvX3RyZWUgKmlvX3RyZWUgPSAmQlRSRlNfSShpbm9kZSktPmlvX3RyZWU7CiAJc3RydWN0IGJ0cmZzX29yZGVyZWRfZXh0ZW50ICpvcmRlcmVkOwogCXN0cnVjdCBwYWdlICpwYWdlOworCXN0cnVjdCBidHJmc19zdXBlcl9ibG9jayAqZGlza19zdXBlcjsKIAl1bnNpZ25lZCBsb25nIGxhc3RfaW5kZXg7CiAJdW5zaWduZWQgbG9uZyByYV9wYWdlcyA9IHJvb3QtPmZzX2luZm8tPmJkaS5yYV9wYWdlczsKIAl1bnNpZ25lZCBsb25nIHRvdGFsX3JlYWQgPSAwOworCXU2NCBmZWF0dXJlczsKIAl1NjQgcGFnZV9zdGFydDsKIAl1NjQgcGFnZV9lbmQ7CiAJdTY0IGxhc3RfbGVuID0gMDsKQEAgLTY0OCw2ICs2NTUsMTQgQEAKIAl1NjQgZGVmcmFnX2VuZCA9IDA7CiAJdW5zaWduZWQgbG9uZyBpOwogCWludCByZXQ7CisJaW50IGNvbXByZXNzX3R5cGUgPSBCVFJGU19DT01QUkVTU19aTElCOworCisJaWYgKHJhbmdlLT5mbGFncyAmIEJUUkZTX0RFRlJBR19SQU5HRV9DT01QUkVTUykgeworCQlpZiAocmFuZ2UtPmNvbXByZXNzX3R5cGUgPiBCVFJGU19DT01QUkVTU19UWVBFUykKKwkJCXJldHVybiAtRUlOVkFMOworCQlpZiAocmFuZ2UtPmNvbXByZXNzX3R5cGUpCisJCQljb21wcmVzc190eXBlID0gcmFuZ2UtPmNvbXByZXNzX3R5cGU7CisJfQogCiAJaWYgKGlub2RlLT5pX3NpemUgPT0gMCkKIAkJcmV0dXJuIDA7CkBAIC02ODMsNyArNjk4LDcgQEAKIAkJdG90YWxfcmVhZCsrOwogCQltdXRleF9sb2NrKCZpbm9kZS0+aV9tdXRleCk7CiAJCWlmIChyYW5nZS0+ZmxhZ3MgJiBCVFJGU19ERUZSQUdfUkFOR0VfQ09NUFJFU1MpCi0JCQlCVFJGU19JKGlub2RlKS0+Zm9yY2VfY29tcHJlc3MgPSAxOworCQkJQlRSRlNfSShpbm9kZSktPmZvcmNlX2NvbXByZXNzID0gY29tcHJlc3NfdHlwZTsKIAogCQlyZXQgID0gYnRyZnNfZGVsYWxsb2NfcmVzZXJ2ZV9zcGFjZShpbm9kZSwgUEFHRV9DQUNIRV9TSVpFKTsKIAkJaWYgKHJldCkKQEAgLTc4MSwxMCArNzk2LDE3IEBACiAJCWF0b21pY19kZWMoJnJvb3QtPmZzX2luZm8tPmFzeW5jX3N1Ym1pdF9kcmFpbmluZyk7CiAKIAkJbXV0ZXhfbG9jaygmaW5vZGUtPmlfbXV0ZXgpOwotCQlCVFJGU19JKGlub2RlKS0+Zm9yY2VfY29tcHJlc3MgPSAwOworCQlCVFJGU19JKGlub2RlKS0+Zm9yY2VfY29tcHJlc3MgPSBCVFJGU19DT01QUkVTU19OT05FOwogCQltdXRleF91bmxvY2soJmlub2RlLT5pX211dGV4KTsKIAl9CiAKKwlkaXNrX3N1cGVyID0gJnJvb3QtPmZzX2luZm8tPnN1cGVyX2NvcHk7CisJZmVhdHVyZXMgPSBidHJmc19zdXBlcl9pbmNvbXBhdF9mbGFncyhkaXNrX3N1cGVyKTsKKwlpZiAocmFuZ2UtPmNvbXByZXNzX3R5cGUgPT0gQlRSRlNfQ09NUFJFU1NfTFpPKSB7CisJCWZlYXR1cmVzIHw9IEJUUkZTX0ZFQVRVUkVfSU5DT01QQVRfQ09NUFJFU1NfTFpPOworCQlidHJmc19zZXRfc3VwZXJfaW5jb21wYXRfZmxhZ3MoZGlza19zdXBlciwgZmVhdHVyZXMpOworCX0KKwogCXJldHVybiAwOwogCiBlcnJfcmVzZXJ2YXRpb25zOgpAQCAtODg1LDYgKzkwNywxMCBAQAogCiAJaWYgKG5ld19zaXplID4gb2xkX3NpemUpIHsKIAkJdHJhbnMgPSBidHJmc19zdGFydF90cmFuc2FjdGlvbihyb290LCAwKTsKKwkJaWYgKElTX0VSUih0cmFucykpIHsKKwkJCXJldCA9IFBUUl9FUlIodHJhbnMpOworCQkJZ290byBvdXRfdW5sb2NrOworCQl9CiAJCXJldCA9IGJ0cmZzX2dyb3dfZGV2aWNlKHRyYW5zLCBkZXZpY2UsIG5ld19zaXplKTsKIAkJYnRyZnNfY29tbWl0X3RyYW5zYWN0aW9uKHRyYW5zLCByb290KTsKIAl9IGVsc2UgewpAQCAtOTAxLDcgKzkyNyw4IEBACiAJCQkJCQkgICAgY2hhciAqbmFtZSwKIAkJCQkJCSAgICB1bnNpZ25lZCBsb25nIGZkLAogCQkJCQkJICAgIGludCBzdWJ2b2wsCi0JCQkJCQkgICAgdTY0ICp0cmFuc2lkKQorCQkJCQkJICAgIHU2NCAqdHJhbnNpZCwKKwkJCQkJCSAgICBib29sIHJlYWRvbmx5KQogewogCXN0cnVjdCBidHJmc19yb290ICpyb290ID0gQlRSRlNfSShmZGVudHJ5KGZpbGUpLT5kX2lub2RlKS0+cm9vdDsKIAlzdHJ1Y3QgZmlsZSAqc3JjX2ZpbGU7CkBAIC05MTksNyArOTQ2LDcgQEAKIAogCWlmIChzdWJ2b2wpIHsKIAkJcmV0ID0gYnRyZnNfbWtzdWJ2b2woJmZpbGUtPmZfcGF0aCwgbmFtZSwgbmFtZWxlbiwKLQkJCQkgICAgIE5VTEwsIHRyYW5zaWQpOworCQkJCSAgICAgTlVMTCwgdHJhbnNpZCwgcmVhZG9ubHkpOwogCX0gZWxzZSB7CiAJCXN0cnVjdCBpbm9kZSAqc3JjX2lub2RlOwogCQlzcmNfZmlsZSA9IGZnZXQoZmQpOwpAQCAtOTM4LDcgKzk2NSw3IEBACiAJCX0KIAkJcmV0ID0gYnRyZnNfbWtzdWJ2b2woJmZpbGUtPmZfcGF0aCwgbmFtZSwgbmFtZWxlbiwKIAkJCQkgICAgIEJUUkZTX0koc3JjX2lub2RlKS0+cm9vdCwKLQkJCQkgICAgIHRyYW5zaWQpOworCQkJCSAgICAgdHJhbnNpZCwgcmVhZG9ubHkpOwogCQlmcHV0KHNyY19maWxlKTsKIAl9CiBvdXQ6CkBAIC05NDYsNTggKzk3MywxMzkgQEAKIH0KIAogc3RhdGljIG5vaW5saW5lIGludCBidHJmc19pb2N0bF9zbmFwX2NyZWF0ZShzdHJ1Y3QgZmlsZSAqZmlsZSwKLQkJCQkJICAgIHZvaWQgX191c2VyICphcmcsIGludCBzdWJ2b2wsCi0JCQkJCSAgICBpbnQgdjIpCisJCQkJCSAgICB2b2lkIF9fdXNlciAqYXJnLCBpbnQgc3Vidm9sKQogewotCXN0cnVjdCBidHJmc19pb2N0bF92b2xfYXJncyAqdm9sX2FyZ3MgPSBOVUxMOwotCXN0cnVjdCBidHJmc19pb2N0bF92b2xfYXJnc192MiAqdm9sX2FyZ3NfdjIgPSBOVUxMOwotCWNoYXIgKm5hbWU7Ci0JdTY0IGZkOworCXN0cnVjdCBidHJmc19pb2N0bF92b2xfYXJncyAqdm9sX2FyZ3M7CiAJaW50IHJldDsKIAotCWlmICh2MikgewotCQl1NjQgdHJhbnNpZCA9IDA7Ci0JCXU2NCAqcHRyID0gTlVMTDsKKwl2b2xfYXJncyA9IG1lbWR1cF91c2VyKGFyZywgc2l6ZW9mKCp2b2xfYXJncykpOworCWlmIChJU19FUlIodm9sX2FyZ3MpKQorCQlyZXR1cm4gUFRSX0VSUih2b2xfYXJncyk7CisJdm9sX2FyZ3MtPm5hbWVbQlRSRlNfUEFUSF9OQU1FX01BWF0gPSAnXDAnOwogCi0JCXZvbF9hcmdzX3YyID0gbWVtZHVwX3VzZXIoYXJnLCBzaXplb2YoKnZvbF9hcmdzX3YyKSk7Ci0JCWlmIChJU19FUlIodm9sX2FyZ3NfdjIpKQotCQkJcmV0dXJuIFBUUl9FUlIodm9sX2FyZ3NfdjIpOworCXJldCA9IGJ0cmZzX2lvY3RsX3NuYXBfY3JlYXRlX3RyYW5zaWQoZmlsZSwgdm9sX2FyZ3MtPm5hbWUsCisJCQkJCSAgICAgIHZvbF9hcmdzLT5mZCwgc3Vidm9sLAorCQkJCQkgICAgICBOVUxMLCBmYWxzZSk7CiAKLQkJaWYgKHZvbF9hcmdzX3YyLT5mbGFncyAmIH5CVFJGU19TVUJWT0xfQ1JFQVRFX0FTWU5DKSB7Ci0JCQlyZXQgPSAtRUlOVkFMOwotCQkJZ290byBvdXQ7Ci0JCX0KKwlrZnJlZSh2b2xfYXJncyk7CisJcmV0dXJuIHJldDsKK30KIAotCQluYW1lID0gdm9sX2FyZ3NfdjItPm5hbWU7Ci0JCWZkID0gdm9sX2FyZ3NfdjItPmZkOwotCQl2b2xfYXJnc192Mi0+bmFtZVtCVFJGU19TVUJWT0xfTkFNRV9NQVhdID0gJ1wwJzsKK3N0YXRpYyBub2lubGluZSBpbnQgYnRyZnNfaW9jdGxfc25hcF9jcmVhdGVfdjIoc3RydWN0IGZpbGUgKmZpbGUsCisJCQkJCSAgICAgICB2b2lkIF9fdXNlciAqYXJnLCBpbnQgc3Vidm9sKQoreworCXN0cnVjdCBidHJmc19pb2N0bF92b2xfYXJnc192MiAqdm9sX2FyZ3M7CisJaW50IHJldDsKKwl1NjQgdHJhbnNpZCA9IDA7CisJdTY0ICpwdHIgPSBOVUxMOworCWJvb2wgcmVhZG9ubHkgPSBmYWxzZTsKIAotCQlpZiAodm9sX2FyZ3NfdjItPmZsYWdzICYgQlRSRlNfU1VCVk9MX0NSRUFURV9BU1lOQykKLQkJCXB0ciA9ICZ0cmFuc2lkOworCXZvbF9hcmdzID0gbWVtZHVwX3VzZXIoYXJnLCBzaXplb2YoKnZvbF9hcmdzKSk7CisJaWYgKElTX0VSUih2b2xfYXJncykpCisJCXJldHVybiBQVFJfRVJSKHZvbF9hcmdzKTsKKwl2b2xfYXJncy0+bmFtZVtCVFJGU19TVUJWT0xfTkFNRV9NQVhdID0gJ1wwJzsKIAotCQlyZXQgPSBidHJmc19pb2N0bF9zbmFwX2NyZWF0ZV90cmFuc2lkKGZpbGUsIG5hbWUsIGZkLAotCQkJCQkJICAgICAgc3Vidm9sLCBwdHIpOwotCi0JCWlmIChyZXQgPT0gMCAmJiBwdHIgJiYKLQkJICAgIGNvcHlfdG9fdXNlcihhcmcgKwotCQkJCSBvZmZzZXRvZihzdHJ1Y3QgYnRyZnNfaW9jdGxfdm9sX2FyZ3NfdjIsCi0JCQkJCSAgdHJhbnNpZCksIHB0ciwgc2l6ZW9mKCpwdHIpKSkKLQkJCXJldCA9IC1FRkFVTFQ7Ci0JfSBlbHNlIHsKLQkJdm9sX2FyZ3MgPSBtZW1kdXBfdXNlcihhcmcsIHNpemVvZigqdm9sX2FyZ3MpKTsKLQkJaWYgKElTX0VSUih2b2xfYXJncykpCi0JCQlyZXR1cm4gUFRSX0VSUih2b2xfYXJncyk7Ci0JCW5hbWUgPSB2b2xfYXJncy0+bmFtZTsKLQkJZmQgPSB2b2xfYXJncy0+ZmQ7Ci0JCXZvbF9hcmdzLT5uYW1lW0JUUkZTX1BBVEhfTkFNRV9NQVhdID0gJ1wwJzsKLQotCQlyZXQgPSBidHJmc19pb2N0bF9zbmFwX2NyZWF0ZV90cmFuc2lkKGZpbGUsIG5hbWUsIGZkLAotCQkJCQkJICAgICAgc3Vidm9sLCBOVUxMKTsKKwlpZiAodm9sX2FyZ3MtPmZsYWdzICYKKwkgICAgfihCVFJGU19TVUJWT0xfQ1JFQVRFX0FTWU5DIHwgQlRSRlNfU1VCVk9MX1JET05MWSkpIHsKKwkJcmV0ID0gLUVPUE5PVFNVUFA7CisJCWdvdG8gb3V0OwogCX0KKworCWlmICh2b2xfYXJncy0+ZmxhZ3MgJiBCVFJGU19TVUJWT0xfQ1JFQVRFX0FTWU5DKQorCQlwdHIgPSAmdHJhbnNpZDsKKwlpZiAodm9sX2FyZ3MtPmZsYWdzICYgQlRSRlNfU1VCVk9MX1JET05MWSkKKwkJcmVhZG9ubHkgPSB0cnVlOworCisJcmV0ID0gYnRyZnNfaW9jdGxfc25hcF9jcmVhdGVfdHJhbnNpZChmaWxlLCB2b2xfYXJncy0+bmFtZSwKKwkJCQkJICAgICAgdm9sX2FyZ3MtPmZkLCBzdWJ2b2wsCisJCQkJCSAgICAgIHB0ciwgcmVhZG9ubHkpOworCisJaWYgKHJldCA9PSAwICYmIHB0ciAmJgorCSAgICBjb3B5X3RvX3VzZXIoYXJnICsKKwkJCSBvZmZzZXRvZihzdHJ1Y3QgYnRyZnNfaW9jdGxfdm9sX2FyZ3NfdjIsCisJCQkJICB0cmFuc2lkKSwgcHRyLCBzaXplb2YoKnB0cikpKQorCQlyZXQgPSAtRUZBVUxUOwogb3V0OgogCWtmcmVlKHZvbF9hcmdzKTsKLQlrZnJlZSh2b2xfYXJnc192Mik7CisJcmV0dXJuIHJldDsKK30KIAorc3RhdGljIG5vaW5saW5lIGludCBidHJmc19pb2N0bF9zdWJ2b2xfZ2V0ZmxhZ3Moc3RydWN0IGZpbGUgKmZpbGUsCisJCQkJCQl2b2lkIF9fdXNlciAqYXJnKQoreworCXN0cnVjdCBpbm9kZSAqaW5vZGUgPSBmZGVudHJ5KGZpbGUpLT5kX2lub2RlOworCXN0cnVjdCBidHJmc19yb290ICpyb290ID0gQlRSRlNfSShpbm9kZSktPnJvb3Q7CisJaW50IHJldCA9IDA7CisJdTY0IGZsYWdzID0gMDsKKworCWlmIChpbm9kZS0+aV9pbm8gIT0gQlRSRlNfRklSU1RfRlJFRV9PQkpFQ1RJRCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlkb3duX3JlYWQoJnJvb3QtPmZzX2luZm8tPnN1YnZvbF9zZW0pOworCWlmIChidHJmc19yb290X3JlYWRvbmx5KHJvb3QpKQorCQlmbGFncyB8PSBCVFJGU19TVUJWT0xfUkRPTkxZOworCXVwX3JlYWQoJnJvb3QtPmZzX2luZm8tPnN1YnZvbF9zZW0pOworCisJaWYgKGNvcHlfdG9fdXNlcihhcmcsICZmbGFncywgc2l6ZW9mKGZsYWdzKSkpCisJCXJldCA9IC1FRkFVTFQ7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgbm9pbmxpbmUgaW50IGJ0cmZzX2lvY3RsX3N1YnZvbF9zZXRmbGFncyhzdHJ1Y3QgZmlsZSAqZmlsZSwKKwkJCQkJICAgICAgdm9pZCBfX3VzZXIgKmFyZykKK3sKKwlzdHJ1Y3QgaW5vZGUgKmlub2RlID0gZmRlbnRyeShmaWxlKS0+ZF9pbm9kZTsKKwlzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCA9IEJUUkZTX0koaW5vZGUpLT5yb290OworCXN0cnVjdCBidHJmc190cmFuc19oYW5kbGUgKnRyYW5zOworCXU2NCByb290X2ZsYWdzOworCXU2NCBmbGFnczsKKwlpbnQgcmV0ID0gMDsKKworCWlmIChyb290LT5mc19pbmZvLT5zYi0+c19mbGFncyAmIE1TX1JET05MWSkKKwkJcmV0dXJuIC1FUk9GUzsKKworCWlmIChpbm9kZS0+aV9pbm8gIT0gQlRSRlNfRklSU1RfRlJFRV9PQkpFQ1RJRCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoY29weV9mcm9tX3VzZXIoJmZsYWdzLCBhcmcsIHNpemVvZihmbGFncykpKQorCQlyZXR1cm4gLUVGQVVMVDsKKworCWlmIChmbGFncyAmIH5CVFJGU19TVUJWT0xfQ1JFQVRFX0FTWU5DKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlmIChmbGFncyAmIH5CVFJGU19TVUJWT0xfUkRPTkxZKQorCQlyZXR1cm4gLUVPUE5PVFNVUFA7CisKKwlkb3duX3dyaXRlKCZyb290LT5mc19pbmZvLT5zdWJ2b2xfc2VtKTsKKworCS8qIG5vdGhpbmcgdG8gZG8gKi8KKwlpZiAoISEoZmxhZ3MgJiBCVFJGU19TVUJWT0xfUkRPTkxZKSA9PSBidHJmc19yb290X3JlYWRvbmx5KHJvb3QpKQorCQlnb3RvIG91dDsKKworCXJvb3RfZmxhZ3MgPSBidHJmc19yb290X2ZsYWdzKCZyb290LT5yb290X2l0ZW0pOworCWlmIChmbGFncyAmIEJUUkZTX1NVQlZPTF9SRE9OTFkpCisJCWJ0cmZzX3NldF9yb290X2ZsYWdzKCZyb290LT5yb290X2l0ZW0sCisJCQkJICAgICByb290X2ZsYWdzIHwgQlRSRlNfUk9PVF9TVUJWT0xfUkRPTkxZKTsKKwllbHNlCisJCWJ0cmZzX3NldF9yb290X2ZsYWdzKCZyb290LT5yb290X2l0ZW0sCisJCQkJICAgICByb290X2ZsYWdzICYgfkJUUkZTX1JPT1RfU1VCVk9MX1JET05MWSk7CisKKwl0cmFucyA9IGJ0cmZzX3N0YXJ0X3RyYW5zYWN0aW9uKHJvb3QsIDEpOworCWlmIChJU19FUlIodHJhbnMpKSB7CisJCXJldCA9IFBUUl9FUlIodHJhbnMpOworCQlnb3RvIG91dF9yZXNldDsKKwl9CisKKwlyZXQgPSBidHJmc191cGRhdGVfcm9vdCh0cmFucywgcm9vdCwKKwkJCQkmcm9vdC0+cm9vdF9rZXksICZyb290LT5yb290X2l0ZW0pOworCisJYnRyZnNfY29tbWl0X3RyYW5zYWN0aW9uKHRyYW5zLCByb290KTsKK291dF9yZXNldDoKKwlpZiAocmV0KQorCQlidHJmc19zZXRfcm9vdF9mbGFncygmcm9vdC0+cm9vdF9pdGVtLCByb290X2ZsYWdzKTsKK291dDoKKwl1cF93cml0ZSgmcm9vdC0+ZnNfaW5mby0+c3Vidm9sX3NlbSk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtMTUwOSw2ICsxNjE3LDkgQEAKIAlzdHJ1Y3QgYnRyZnNfaW9jdGxfZGVmcmFnX3JhbmdlX2FyZ3MgKnJhbmdlOwogCWludCByZXQ7CiAKKwlpZiAoYnRyZnNfcm9vdF9yZWFkb25seShyb290KSkKKwkJcmV0dXJuIC1FUk9GUzsKKwogCXJldCA9IG1udF93YW50X3dyaXRlKGZpbGUtPmZfcGF0aC5tbnQpOwogCWlmIChyZXQpCiAJCXJldHVybiByZXQ7CkBAIC0xNjM3LDYgKzE3NDgsOSBAQAogCWlmICghKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSB8fCAoZmlsZS0+Zl9mbGFncyAmIE9fQVBQRU5EKSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKKwlpZiAoYnRyZnNfcm9vdF9yZWFkb25seShyb290KSkKKwkJcmV0dXJuIC1FUk9GUzsKKwogCXJldCA9IG1udF93YW50X3dyaXRlKGZpbGUtPmZfcGF0aC5tbnQpOwogCWlmIChyZXQpCiAJCXJldHVybiByZXQ7CkBAIC0xNzg4LDcgKzE5MDIsMTAgQEAKIAogCQkJbWVtY3B5KCZuZXdfa2V5LCAma2V5LCBzaXplb2YobmV3X2tleSkpOwogCQkJbmV3X2tleS5vYmplY3RpZCA9IGlub2RlLT5pX2lubzsKLQkJCW5ld19rZXkub2Zmc2V0ID0ga2V5Lm9mZnNldCArIGRlc3RvZmYgLSBvZmY7CisJCQlpZiAob2ZmIDw9IGtleS5vZmZzZXQpCisJCQkJbmV3X2tleS5vZmZzZXQgPSBrZXkub2Zmc2V0ICsgZGVzdG9mZiAtIG9mZjsKKwkJCWVsc2UKKwkJCQluZXdfa2V5Lm9mZnNldCA9IGRlc3RvZmY7CiAKIAkJCXRyYW5zID0gYnRyZnNfc3RhcnRfdHJhbnNhY3Rpb24ocm9vdCwgMSk7CiAJCQlpZiAoSVNfRVJSKHRyYW5zKSkgewpAQCAtMTk1OCw2ICsyMDc1LDEwIEBACiAJaWYgKGZpbGUtPnByaXZhdGVfZGF0YSkKIAkJZ290byBvdXQ7CiAKKwlyZXQgPSAtRVJPRlM7CisJaWYgKGJ0cmZzX3Jvb3RfcmVhZG9ubHkocm9vdCkpCisJCWdvdG8gb3V0OworCiAJcmV0ID0gbW50X3dhbnRfd3JpdGUoZmlsZS0+Zl9wYXRoLm1udCk7CiAJaWYgKHJldCkKIAkJZ290byBvdXQ7CkBAIC0xOTY4LDcgKzIwODksNyBAQAogCiAJcmV0ID0gLUVOT01FTTsKIAl0cmFucyA9IGJ0cmZzX3N0YXJ0X2lvY3RsX3RyYW5zYWN0aW9uKHJvb3QsIDApOwotCWlmICghdHJhbnMpCisJaWYgKElTX0VSUih0cmFucykpCiAJCWdvdG8gb3V0X2Ryb3A7CiAKIAlmaWxlLT5wcml2YXRlX2RhdGEgPSB0cmFuczsKQEAgLTIwMjQsOSArMjE0NSw5IEBACiAJcGF0aC0+bGVhdmVfc3Bpbm5pbmcgPSAxOwogCiAJdHJhbnMgPSBidHJmc19zdGFydF90cmFuc2FjdGlvbihyb290LCAxKTsKLQlpZiAoIXRyYW5zKSB7CisJaWYgKElTX0VSUih0cmFucykpIHsKIAkJYnRyZnNfZnJlZV9wYXRoKHBhdGgpOwotCQlyZXR1cm4gLUVOT01FTTsKKwkJcmV0dXJuIFBUUl9FUlIodHJhbnMpOwogCX0KIAogCWRpcl9pZCA9IGJ0cmZzX3N1cGVyX3Jvb3RfZGlyKCZyb290LT5mc19pbmZvLT5zdXBlcl9jb3B5KTsKQEAgLTIyMjAsNiArMjM0MSw4IEBACiAJdTY0IHRyYW5zaWQ7CiAKIAl0cmFucyA9IGJ0cmZzX3N0YXJ0X3RyYW5zYWN0aW9uKHJvb3QsIDApOworCWlmIChJU19FUlIodHJhbnMpKQorCQlyZXR1cm4gUFRSX0VSUih0cmFucyk7CiAJdHJhbnNpZCA9IHRyYW5zLT50cmFuc2lkOwogCWJ0cmZzX2NvbW1pdF90cmFuc2FjdGlvbl9hc3luYyh0cmFucywgcm9vdCwgMCk7CiAKQEAgLTIyNTcsMTMgKzIzODAsMTcgQEAKIAljYXNlIEZTX0lPQ19HRVRWRVJTSU9OOgogCQlyZXR1cm4gYnRyZnNfaW9jdGxfZ2V0dmVyc2lvbihmaWxlLCBhcmdwKTsKIAljYXNlIEJUUkZTX0lPQ19TTkFQX0NSRUFURToKLQkJcmV0dXJuIGJ0cmZzX2lvY3RsX3NuYXBfY3JlYXRlKGZpbGUsIGFyZ3AsIDAsIDApOworCQlyZXR1cm4gYnRyZnNfaW9jdGxfc25hcF9jcmVhdGUoZmlsZSwgYXJncCwgMCk7CiAJY2FzZSBCVFJGU19JT0NfU05BUF9DUkVBVEVfVjI6Ci0JCXJldHVybiBidHJmc19pb2N0bF9zbmFwX2NyZWF0ZShmaWxlLCBhcmdwLCAwLCAxKTsKKwkJcmV0dXJuIGJ0cmZzX2lvY3RsX3NuYXBfY3JlYXRlX3YyKGZpbGUsIGFyZ3AsIDApOwogCWNhc2UgQlRSRlNfSU9DX1NVQlZPTF9DUkVBVEU6Ci0JCXJldHVybiBidHJmc19pb2N0bF9zbmFwX2NyZWF0ZShmaWxlLCBhcmdwLCAxLCAwKTsKKwkJcmV0dXJuIGJ0cmZzX2lvY3RsX3NuYXBfY3JlYXRlKGZpbGUsIGFyZ3AsIDEpOwogCWNhc2UgQlRSRlNfSU9DX1NOQVBfREVTVFJPWToKIAkJcmV0dXJuIGJ0cmZzX2lvY3RsX3NuYXBfZGVzdHJveShmaWxlLCBhcmdwKTsKKwljYXNlIEJUUkZTX0lPQ19TVUJWT0xfR0VURkxBR1M6CisJCXJldHVybiBidHJmc19pb2N0bF9zdWJ2b2xfZ2V0ZmxhZ3MoZmlsZSwgYXJncCk7CisJY2FzZSBCVFJGU19JT0NfU1VCVk9MX1NFVEZMQUdTOgorCQlyZXR1cm4gYnRyZnNfaW9jdGxfc3Vidm9sX3NldGZsYWdzKGZpbGUsIGFyZ3ApOwogCWNhc2UgQlRSRlNfSU9DX0RFRkFVTFRfU1VCVk9MOgogCQlyZXR1cm4gYnRyZnNfaW9jdGxfZGVmYXVsdF9zdWJ2b2woZmlsZSwgYXJncCk7CiAJY2FzZSBCVFJGU19JT0NfREVGUkFHOgpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvaW9jdGwuaCBiL2ZzL2J0cmZzL2lvY3RsLmgKaW5kZXggYzM0NGQxMi4uOGZiMzgyMSAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvaW9jdGwuaAorKysgYi9mcy9idHJmcy9pb2N0bC5oCkBAIC0zMSw2ICszMSw3IEBACiB9OwogCiAjZGVmaW5lIEJUUkZTX1NVQlZPTF9DUkVBVEVfQVNZTkMJKDFVTEwgPDwgMCkKKyNkZWZpbmUgQlRSRlNfU1VCVk9MX1JET05MWQkJKDFVTEwgPDwgMSkKIAogI2RlZmluZSBCVFJGU19TVUJWT0xfTkFNRV9NQVggNDAzOQogc3RydWN0IGJ0cmZzX2lvY3RsX3ZvbF9hcmdzX3YyIHsKQEAgLTEzMyw4ICsxMzQsMTUgQEAKIAkgKi8KIAlfX3UzMiBleHRlbnRfdGhyZXNoOwogCisJLyoKKwkgKiB3aGljaCBjb21wcmVzc2lvbiBtZXRob2QgdG8gdXNlIGlmIHR1cm5pbmcgb24gY29tcHJlc3Npb24KKwkgKiBmb3IgdGhpcyBkZWZyYWcgb3BlcmF0aW9uLiAgSWYgdW5zcGVjaWZpZWQsIHpsaWIgd2lsbAorCSAqIGJlIHVzZWQKKwkgKi8KKwlfX3UzMiBjb21wcmVzc190eXBlOworCiAJLyogc3BhcmUgZm9yIGxhdGVyICovCi0JX191MzIgdW51c2VkWzVdOworCV9fdTMyIHVudXNlZFs0XTsKIH07CiAKIHN0cnVjdCBidHJmc19pb2N0bF9zcGFjZV9pbmZvIHsKQEAgLTE5Myw0ICsyMDEsNiBAQAogI2RlZmluZSBCVFJGU19JT0NfV0FJVF9TWU5DICBfSU9XKEJUUkZTX0lPQ1RMX01BR0lDLCAyMiwgX191NjQpCiAjZGVmaW5lIEJUUkZTX0lPQ19TTkFQX0NSRUFURV9WMiBfSU9XKEJUUkZTX0lPQ1RMX01BR0lDLCAyMywgXAogCQkJCSAgIHN0cnVjdCBidHJmc19pb2N0bF92b2xfYXJnc192MikKKyNkZWZpbmUgQlRSRlNfSU9DX1NVQlZPTF9HRVRGTEFHUyBfSU9XKEJUUkZTX0lPQ1RMX01BR0lDLCAyNSwgX191NjQpCisjZGVmaW5lIEJUUkZTX0lPQ19TVUJWT0xfU0VURkxBR1MgX0lPVyhCVFJGU19JT0NUTF9NQUdJQywgMjYsIF9fdTY0KQogI2VuZGlmCmRpZmYgLS1naXQgYS9mcy9idHJmcy9sem8uYyBiL2ZzL2J0cmZzL2x6by5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmNjOWI0NTAKLS0tIC9kZXYvbnVsbAorKysgYi9mcy9idHJmcy9sem8uYwpAQCAtMCwwICsxLDQyMCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOCBPcmFjbGUuICBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSB2MiBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUKKyAqIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMTAtMTMwNywgVVNBLgorICovCisKKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvdm1hbGxvYy5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgorI2luY2x1ZGUgPGxpbnV4L3BhZ2VtYXAuaD4KKyNpbmNsdWRlIDxsaW51eC9iaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9sem8uaD4KKyNpbmNsdWRlICJjb21wcmVzc2lvbi5oIgorCisjZGVmaW5lIExaT19MRU4JNAorCitzdHJ1Y3Qgd29ya3NwYWNlIHsKKwl2b2lkICptZW07CisJdm9pZCAqYnVmOwkvKiB3aGVyZSBjb21wcmVzc2VkIGRhdGEgZ29lcyAqLworCXZvaWQgKmNidWY7CS8qIHdoZXJlIGRlY29tcHJlc3NlZCBkYXRhIGdvZXMgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7Cit9OworCitzdGF0aWMgdm9pZCBsem9fZnJlZV93b3Jrc3BhY2Uoc3RydWN0IGxpc3RfaGVhZCAqd3MpCit7CisJc3RydWN0IHdvcmtzcGFjZSAqd29ya3NwYWNlID0gbGlzdF9lbnRyeSh3cywgc3RydWN0IHdvcmtzcGFjZSwgbGlzdCk7CisKKwl2ZnJlZSh3b3Jrc3BhY2UtPmJ1Zik7CisJdmZyZWUod29ya3NwYWNlLT5jYnVmKTsKKwl2ZnJlZSh3b3Jrc3BhY2UtPm1lbSk7CisJa2ZyZWUod29ya3NwYWNlKTsKK30KKworc3RhdGljIHN0cnVjdCBsaXN0X2hlYWQgKmx6b19hbGxvY193b3Jrc3BhY2Uodm9pZCkKK3sKKwlzdHJ1Y3Qgd29ya3NwYWNlICp3b3Jrc3BhY2U7CisKKwl3b3Jrc3BhY2UgPSBremFsbG9jKHNpemVvZigqd29ya3NwYWNlKSwgR0ZQX05PRlMpOworCWlmICghd29ya3NwYWNlKQorCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKworCXdvcmtzcGFjZS0+bWVtID0gdm1hbGxvYyhMWk8xWF9NRU1fQ09NUFJFU1MpOworCXdvcmtzcGFjZS0+YnVmID0gdm1hbGxvYyhsem8xeF93b3JzdF9jb21wcmVzcyhQQUdFX0NBQ0hFX1NJWkUpKTsKKwl3b3Jrc3BhY2UtPmNidWYgPSB2bWFsbG9jKGx6bzF4X3dvcnN0X2NvbXByZXNzKFBBR0VfQ0FDSEVfU0laRSkpOworCWlmICghd29ya3NwYWNlLT5tZW0gfHwgIXdvcmtzcGFjZS0+YnVmIHx8ICF3b3Jrc3BhY2UtPmNidWYpCisJCWdvdG8gZmFpbDsKKworCUlOSVRfTElTVF9IRUFEKCZ3b3Jrc3BhY2UtPmxpc3QpOworCisJcmV0dXJuICZ3b3Jrc3BhY2UtPmxpc3Q7CitmYWlsOgorCWx6b19mcmVlX3dvcmtzcGFjZSgmd29ya3NwYWNlLT5saXN0KTsKKwlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHdyaXRlX2NvbXByZXNzX2xlbmd0aChjaGFyICpidWYsIHNpemVfdCBsZW4pCit7CisJX19sZTMyIGRsZW47CisKKwlkbGVuID0gY3B1X3RvX2xlMzIobGVuKTsKKwltZW1jcHkoYnVmLCAmZGxlbiwgTFpPX0xFTik7Cit9CisKK3N0YXRpYyBpbmxpbmUgc2l6ZV90IHJlYWRfY29tcHJlc3NfbGVuZ3RoKGNoYXIgKmJ1ZikKK3sKKwlfX2xlMzIgZGxlbjsKKworCW1lbWNweSgmZGxlbiwgYnVmLCBMWk9fTEVOKTsKKwlyZXR1cm4gbGUzMl90b19jcHUoZGxlbik7Cit9CisKK3N0YXRpYyBpbnQgbHpvX2NvbXByZXNzX3BhZ2VzKHN0cnVjdCBsaXN0X2hlYWQgKndzLAorCQkJICAgICAgc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmcsCisJCQkgICAgICB1NjQgc3RhcnQsIHVuc2lnbmVkIGxvbmcgbGVuLAorCQkJICAgICAgc3RydWN0IHBhZ2UgKipwYWdlcywKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgbnJfZGVzdF9wYWdlcywKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgKm91dF9wYWdlcywKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgKnRvdGFsX2luLAorCQkJICAgICAgdW5zaWduZWQgbG9uZyAqdG90YWxfb3V0LAorCQkJICAgICAgdW5zaWduZWQgbG9uZyBtYXhfb3V0KQoreworCXN0cnVjdCB3b3Jrc3BhY2UgKndvcmtzcGFjZSA9IGxpc3RfZW50cnkod3MsIHN0cnVjdCB3b3Jrc3BhY2UsIGxpc3QpOworCWludCByZXQgPSAwOworCWNoYXIgKmRhdGFfaW47CisJY2hhciAqY3BhZ2Vfb3V0OworCWludCBucl9wYWdlcyA9IDA7CisJc3RydWN0IHBhZ2UgKmluX3BhZ2UgPSBOVUxMOworCXN0cnVjdCBwYWdlICpvdXRfcGFnZSA9IE5VTEw7CisJdW5zaWduZWQgbG9uZyBieXRlc19sZWZ0OworCisJc2l6ZV90IGluX2xlbjsKKwlzaXplX3Qgb3V0X2xlbjsKKwljaGFyICpidWY7CisJdW5zaWduZWQgbG9uZyB0b3RfaW4gPSAwOworCXVuc2lnbmVkIGxvbmcgdG90X291dCA9IDA7CisJdW5zaWduZWQgbG9uZyBwZ19ieXRlc19sZWZ0OworCXVuc2lnbmVkIGxvbmcgb3V0X29mZnNldDsKKwl1bnNpZ25lZCBsb25nIGJ5dGVzOworCisJKm91dF9wYWdlcyA9IDA7CisJKnRvdGFsX291dCA9IDA7CisJKnRvdGFsX2luID0gMDsKKworCWluX3BhZ2UgPSBmaW5kX2dldF9wYWdlKG1hcHBpbmcsIHN0YXJ0ID4+IFBBR0VfQ0FDSEVfU0hJRlQpOworCWRhdGFfaW4gPSBrbWFwKGluX3BhZ2UpOworCisJLyoKKwkgKiBzdG9yZSB0aGUgc2l6ZSBvZiBhbGwgY2h1bmtzIG9mIGNvbXByZXNzZWQgZGF0YSBpbgorCSAqIHRoZSBmaXJzdCA0IGJ5dGVzCisJICovCisJb3V0X3BhZ2UgPSBhbGxvY19wYWdlKEdGUF9OT0ZTIHwgX19HRlBfSElHSE1FTSk7CisJaWYgKG91dF9wYWdlID09IE5VTEwpIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBvdXQ7CisJfQorCWNwYWdlX291dCA9IGttYXAob3V0X3BhZ2UpOworCW91dF9vZmZzZXQgPSBMWk9fTEVOOworCXRvdF9vdXQgPSBMWk9fTEVOOworCXBhZ2VzWzBdID0gb3V0X3BhZ2U7CisJbnJfcGFnZXMgPSAxOworCXBnX2J5dGVzX2xlZnQgPSBQQUdFX0NBQ0hFX1NJWkUgLSBMWk9fTEVOOworCisJLyogY29tcHJlc3MgYXQgbW9zdCBvbmUgcGFnZSBvZiBkYXRhIGVhY2ggdGltZSAqLworCWluX2xlbiA9IG1pbihsZW4sIFBBR0VfQ0FDSEVfU0laRSk7CisJd2hpbGUgKHRvdF9pbiA8IGxlbikgeworCQlyZXQgPSBsem8xeF8xX2NvbXByZXNzKGRhdGFfaW4sIGluX2xlbiwgd29ya3NwYWNlLT5jYnVmLAorCQkJCSAgICAgICAmb3V0X2xlbiwgd29ya3NwYWNlLT5tZW0pOworCQlpZiAocmV0ICE9IExaT19FX09LKSB7CisJCQlwcmludGsoS0VSTl9ERUJVRyAiYnRyZnMgZGVmbGF0ZSBpbiBsb29wIHJldHVybmVkICVkXG4iLAorCQkJICAgICAgIHJldCk7CisJCQlyZXQgPSAtMTsKKwkJCWdvdG8gb3V0OworCQl9CisKKwkJLyogc3RvcmUgdGhlIHNpemUgb2YgdGhpcyBjaHVuayBvZiBjb21wcmVzc2VkIGRhdGEgKi8KKwkJd3JpdGVfY29tcHJlc3NfbGVuZ3RoKGNwYWdlX291dCArIG91dF9vZmZzZXQsIG91dF9sZW4pOworCQl0b3Rfb3V0ICs9IExaT19MRU47CisJCW91dF9vZmZzZXQgKz0gTFpPX0xFTjsKKwkJcGdfYnl0ZXNfbGVmdCAtPSBMWk9fTEVOOworCisJCXRvdF9pbiArPSBpbl9sZW47CisJCXRvdF9vdXQgKz0gb3V0X2xlbjsKKworCQkvKiBjb3B5IGJ5dGVzIGZyb20gdGhlIHdvcmtpbmcgYnVmZmVyIGludG8gdGhlIHBhZ2VzICovCisJCWJ1ZiA9IHdvcmtzcGFjZS0+Y2J1ZjsKKwkJd2hpbGUgKG91dF9sZW4pIHsKKwkJCWJ5dGVzID0gbWluX3QodW5zaWduZWQgbG9uZywgcGdfYnl0ZXNfbGVmdCwgb3V0X2xlbik7CisKKwkJCW1lbWNweShjcGFnZV9vdXQgKyBvdXRfb2Zmc2V0LCBidWYsIGJ5dGVzKTsKKworCQkJb3V0X2xlbiAtPSBieXRlczsKKwkJCXBnX2J5dGVzX2xlZnQgLT0gYnl0ZXM7CisJCQlidWYgKz0gYnl0ZXM7CisJCQlvdXRfb2Zmc2V0ICs9IGJ5dGVzOworCisJCQkvKgorCQkJICogd2UgbmVlZCBhbm90aGVyIHBhZ2UgZm9yIHdyaXRpbmcgb3V0LgorCQkJICoKKwkJCSAqIE5vdGUgaWYgdGhlcmUncyBsZXNzIHRoYW4gNCBieXRlcyBsZWZ0LCB3ZSBqdXN0CisJCQkgKiBza2lwIHRvIGEgbmV3IHBhZ2UuCisJCQkgKi8KKwkJCWlmICgob3V0X2xlbiA9PSAwICYmIHBnX2J5dGVzX2xlZnQgPCBMWk9fTEVOKSB8fAorCQkJICAgIHBnX2J5dGVzX2xlZnQgPT0gMCkgeworCQkJCWlmIChwZ19ieXRlc19sZWZ0KSB7CisJCQkJCW1lbXNldChjcGFnZV9vdXQgKyBvdXRfb2Zmc2V0LCAwLAorCQkJCQkgICAgICAgcGdfYnl0ZXNfbGVmdCk7CisJCQkJCXRvdF9vdXQgKz0gcGdfYnl0ZXNfbGVmdDsKKwkJCQl9CisKKwkJCQkvKiB3ZSdyZSBkb25lLCBkb24ndCBhbGxvY2F0ZSBuZXcgcGFnZSAqLworCQkJCWlmIChvdXRfbGVuID09IDAgJiYgdG90X2luID49IGxlbikKKwkJCQkJYnJlYWs7CisKKwkJCQlrdW5tYXAob3V0X3BhZ2UpOworCQkJCWlmIChucl9wYWdlcyA9PSBucl9kZXN0X3BhZ2VzKSB7CisJCQkJCW91dF9wYWdlID0gTlVMTDsKKwkJCQkJcmV0ID0gLTE7CisJCQkJCWdvdG8gb3V0OworCQkJCX0KKworCQkJCW91dF9wYWdlID0gYWxsb2NfcGFnZShHRlBfTk9GUyB8IF9fR0ZQX0hJR0hNRU0pOworCQkJCWlmIChvdXRfcGFnZSA9PSBOVUxMKSB7CisJCQkJCXJldCA9IC1FTk9NRU07CisJCQkJCWdvdG8gb3V0OworCQkJCX0KKwkJCQljcGFnZV9vdXQgPSBrbWFwKG91dF9wYWdlKTsKKwkJCQlwYWdlc1tucl9wYWdlcysrXSA9IG91dF9wYWdlOworCisJCQkJcGdfYnl0ZXNfbGVmdCA9IFBBR0VfQ0FDSEVfU0laRTsKKwkJCQlvdXRfb2Zmc2V0ID0gMDsKKwkJCX0KKwkJfQorCisJCS8qIHdlJ3JlIG1ha2luZyBpdCBiaWdnZXIsIGdpdmUgdXAgKi8KKwkJaWYgKHRvdF9pbiA+IDgxOTIgJiYgdG90X2luIDwgdG90X291dCkKKwkJCWdvdG8gb3V0OworCisJCS8qIHdlJ3JlIGFsbCBkb25lICovCisJCWlmICh0b3RfaW4gPj0gbGVuKQorCQkJYnJlYWs7CisKKwkJaWYgKHRvdF9vdXQgPiBtYXhfb3V0KQorCQkJYnJlYWs7CisKKwkJYnl0ZXNfbGVmdCA9IGxlbiAtIHRvdF9pbjsKKwkJa3VubWFwKGluX3BhZ2UpOworCQlwYWdlX2NhY2hlX3JlbGVhc2UoaW5fcGFnZSk7CisKKwkJc3RhcnQgKz0gUEFHRV9DQUNIRV9TSVpFOworCQlpbl9wYWdlID0gZmluZF9nZXRfcGFnZShtYXBwaW5nLCBzdGFydCA+PiBQQUdFX0NBQ0hFX1NISUZUKTsKKwkJZGF0YV9pbiA9IGttYXAoaW5fcGFnZSk7CisJCWluX2xlbiA9IG1pbihieXRlc19sZWZ0LCBQQUdFX0NBQ0hFX1NJWkUpOworCX0KKworCWlmICh0b3Rfb3V0ID4gdG90X2luKQorCQlnb3RvIG91dDsKKworCS8qIHN0b3JlIHRoZSBzaXplIG9mIGFsbCBjaHVua3Mgb2YgY29tcHJlc3NlZCBkYXRhICovCisJY3BhZ2Vfb3V0ID0ga21hcChwYWdlc1swXSk7CisJd3JpdGVfY29tcHJlc3NfbGVuZ3RoKGNwYWdlX291dCwgdG90X291dCk7CisKKwlrdW5tYXAocGFnZXNbMF0pOworCisJcmV0ID0gMDsKKwkqdG90YWxfb3V0ID0gdG90X291dDsKKwkqdG90YWxfaW4gPSB0b3RfaW47CitvdXQ6CisJKm91dF9wYWdlcyA9IG5yX3BhZ2VzOworCWlmIChvdXRfcGFnZSkKKwkJa3VubWFwKG91dF9wYWdlKTsKKworCWlmIChpbl9wYWdlKSB7CisJCWt1bm1hcChpbl9wYWdlKTsKKwkJcGFnZV9jYWNoZV9yZWxlYXNlKGluX3BhZ2UpOworCX0KKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgbHpvX2RlY29tcHJlc3NfYmlvdmVjKHN0cnVjdCBsaXN0X2hlYWQgKndzLAorCQkJCSBzdHJ1Y3QgcGFnZSAqKnBhZ2VzX2luLAorCQkJCSB1NjQgZGlza19zdGFydCwKKwkJCQkgc3RydWN0IGJpb192ZWMgKmJ2ZWMsCisJCQkJIGludCB2Y250LAorCQkJCSBzaXplX3Qgc3JjbGVuKQoreworCXN0cnVjdCB3b3Jrc3BhY2UgKndvcmtzcGFjZSA9IGxpc3RfZW50cnkod3MsIHN0cnVjdCB3b3Jrc3BhY2UsIGxpc3QpOworCWludCByZXQgPSAwLCByZXQyOworCWNoYXIgKmRhdGFfaW47CisJdW5zaWduZWQgbG9uZyBwYWdlX2luX2luZGV4ID0gMDsKKwl1bnNpZ25lZCBsb25nIHBhZ2Vfb3V0X2luZGV4ID0gMDsKKwl1bnNpZ25lZCBsb25nIHRvdGFsX3BhZ2VzX2luID0gKHNyY2xlbiArIFBBR0VfQ0FDSEVfU0laRSAtIDEpIC8KKwkJCQkJUEFHRV9DQUNIRV9TSVpFOworCXVuc2lnbmVkIGxvbmcgYnVmX3N0YXJ0OworCXVuc2lnbmVkIGxvbmcgYnVmX29mZnNldCA9IDA7CisJdW5zaWduZWQgbG9uZyBieXRlczsKKwl1bnNpZ25lZCBsb25nIHdvcmtpbmdfYnl0ZXM7CisJdW5zaWduZWQgbG9uZyBwZ19vZmZzZXQ7CisKKwlzaXplX3QgaW5fbGVuOworCXNpemVfdCBvdXRfbGVuOworCXVuc2lnbmVkIGxvbmcgaW5fb2Zmc2V0OworCXVuc2lnbmVkIGxvbmcgaW5fcGFnZV9ieXRlc19sZWZ0OworCXVuc2lnbmVkIGxvbmcgdG90X2luOworCXVuc2lnbmVkIGxvbmcgdG90X291dDsKKwl1bnNpZ25lZCBsb25nIHRvdF9sZW47CisJY2hhciAqYnVmOworCisJZGF0YV9pbiA9IGttYXAocGFnZXNfaW5bMF0pOworCXRvdF9sZW4gPSByZWFkX2NvbXByZXNzX2xlbmd0aChkYXRhX2luKTsKKworCXRvdF9pbiA9IExaT19MRU47CisJaW5fb2Zmc2V0ID0gTFpPX0xFTjsKKwl0b3RfbGVuID0gbWluX3Qoc2l6ZV90LCBzcmNsZW4sIHRvdF9sZW4pOworCWluX3BhZ2VfYnl0ZXNfbGVmdCA9IFBBR0VfQ0FDSEVfU0laRSAtIExaT19MRU47CisKKwl0b3Rfb3V0ID0gMDsKKwlwZ19vZmZzZXQgPSAwOworCisJd2hpbGUgKHRvdF9pbiA8IHRvdF9sZW4pIHsKKwkJaW5fbGVuID0gcmVhZF9jb21wcmVzc19sZW5ndGgoZGF0YV9pbiArIGluX29mZnNldCk7CisJCWluX3BhZ2VfYnl0ZXNfbGVmdCAtPSBMWk9fTEVOOworCQlpbl9vZmZzZXQgKz0gTFpPX0xFTjsKKwkJdG90X2luICs9IExaT19MRU47CisKKwkJdG90X2luICs9IGluX2xlbjsKKwkJd29ya2luZ19ieXRlcyA9IGluX2xlbjsKKworCQkvKiBmYXN0IHBhdGg6IGF2b2lkIHVzaW5nIHRoZSB3b3JraW5nIGJ1ZmZlciAqLworCQlpZiAoaW5fcGFnZV9ieXRlc19sZWZ0ID49IGluX2xlbikgeworCQkJYnVmID0gZGF0YV9pbiArIGluX29mZnNldDsKKwkJCWJ5dGVzID0gaW5fbGVuOworCQkJZ290byBjb250OworCQl9CisKKwkJLyogY29weSBieXRlcyBmcm9tIHRoZSBwYWdlcyBpbnRvIHRoZSB3b3JraW5nIGJ1ZmZlciAqLworCQlidWYgPSB3b3Jrc3BhY2UtPmNidWY7CisJCWJ1Zl9vZmZzZXQgPSAwOworCQl3aGlsZSAod29ya2luZ19ieXRlcykgeworCQkJYnl0ZXMgPSBtaW4od29ya2luZ19ieXRlcywgaW5fcGFnZV9ieXRlc19sZWZ0KTsKKworCQkJbWVtY3B5KGJ1ZiArIGJ1Zl9vZmZzZXQsIGRhdGFfaW4gKyBpbl9vZmZzZXQsIGJ5dGVzKTsKKwkJCWJ1Zl9vZmZzZXQgKz0gYnl0ZXM7Citjb250OgorCQkJd29ya2luZ19ieXRlcyAtPSBieXRlczsKKwkJCWluX3BhZ2VfYnl0ZXNfbGVmdCAtPSBieXRlczsKKwkJCWluX29mZnNldCArPSBieXRlczsKKworCQkJLyogY2hlY2sgaWYgd2UgbmVlZCB0byBwaWNrIGFub3RoZXIgcGFnZSAqLworCQkJaWYgKCh3b3JraW5nX2J5dGVzID09IDAgJiYgaW5fcGFnZV9ieXRlc19sZWZ0IDwgTFpPX0xFTikKKwkJCSAgICB8fCBpbl9wYWdlX2J5dGVzX2xlZnQgPT0gMCkgeworCQkJCXRvdF9pbiArPSBpbl9wYWdlX2J5dGVzX2xlZnQ7CisKKwkJCQlpZiAod29ya2luZ19ieXRlcyA9PSAwICYmIHRvdF9pbiA+PSB0b3RfbGVuKQorCQkJCQlicmVhazsKKworCQkJCWt1bm1hcChwYWdlc19pbltwYWdlX2luX2luZGV4XSk7CisJCQkJcGFnZV9pbl9pbmRleCsrOworCQkJCWlmIChwYWdlX2luX2luZGV4ID49IHRvdGFsX3BhZ2VzX2luKSB7CisJCQkJCXJldCA9IC0xOworCQkJCQlkYXRhX2luID0gTlVMTDsKKwkJCQkJZ290byBkb25lOworCQkJCX0KKwkJCQlkYXRhX2luID0ga21hcChwYWdlc19pbltwYWdlX2luX2luZGV4XSk7CisKKwkJCQlpbl9wYWdlX2J5dGVzX2xlZnQgPSBQQUdFX0NBQ0hFX1NJWkU7CisJCQkJaW5fb2Zmc2V0ID0gMDsKKwkJCX0KKwkJfQorCisJCW91dF9sZW4gPSBsem8xeF93b3JzdF9jb21wcmVzcyhQQUdFX0NBQ0hFX1NJWkUpOworCQlyZXQgPSBsem8xeF9kZWNvbXByZXNzX3NhZmUoYnVmLCBpbl9sZW4sIHdvcmtzcGFjZS0+YnVmLAorCQkJCQkgICAgJm91dF9sZW4pOworCQlpZiAocmV0ICE9IExaT19FX09LKSB7CisJCQlwcmludGsoS0VSTl9XQVJOSU5HICJidHJmcyBkZWNvbXByZXNzIGZhaWxlZFxuIik7CisJCQlyZXQgPSAtMTsKKwkJCWJyZWFrOworCQl9CisKKwkJYnVmX3N0YXJ0ID0gdG90X291dDsKKwkJdG90X291dCArPSBvdXRfbGVuOworCisJCXJldDIgPSBidHJmc19kZWNvbXByZXNzX2J1ZjJwYWdlKHdvcmtzcGFjZS0+YnVmLCBidWZfc3RhcnQsCisJCQkJCQkgdG90X291dCwgZGlza19zdGFydCwKKwkJCQkJCSBidmVjLCB2Y250LAorCQkJCQkJICZwYWdlX291dF9pbmRleCwgJnBnX29mZnNldCk7CisJCWlmIChyZXQyID09IDApCisJCQlicmVhazsKKwl9Citkb25lOgorCWlmIChkYXRhX2luKQorCQlrdW5tYXAocGFnZXNfaW5bcGFnZV9pbl9pbmRleF0pOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgbHpvX2RlY29tcHJlc3Moc3RydWN0IGxpc3RfaGVhZCAqd3MsIHVuc2lnbmVkIGNoYXIgKmRhdGFfaW4sCisJCQkgIHN0cnVjdCBwYWdlICpkZXN0X3BhZ2UsCisJCQkgIHVuc2lnbmVkIGxvbmcgc3RhcnRfYnl0ZSwKKwkJCSAgc2l6ZV90IHNyY2xlbiwgc2l6ZV90IGRlc3RsZW4pCit7CisJc3RydWN0IHdvcmtzcGFjZSAqd29ya3NwYWNlID0gbGlzdF9lbnRyeSh3cywgc3RydWN0IHdvcmtzcGFjZSwgbGlzdCk7CisJc2l6ZV90IGluX2xlbjsKKwlzaXplX3Qgb3V0X2xlbjsKKwlzaXplX3QgdG90X2xlbjsKKwlpbnQgcmV0ID0gMDsKKwljaGFyICprYWRkcjsKKwl1bnNpZ25lZCBsb25nIGJ5dGVzOworCisJQlVHX09OKHNyY2xlbiA8IExaT19MRU4pOworCisJdG90X2xlbiA9IHJlYWRfY29tcHJlc3NfbGVuZ3RoKGRhdGFfaW4pOworCWRhdGFfaW4gKz0gTFpPX0xFTjsKKworCWluX2xlbiA9IHJlYWRfY29tcHJlc3NfbGVuZ3RoKGRhdGFfaW4pOworCWRhdGFfaW4gKz0gTFpPX0xFTjsKKworCW91dF9sZW4gPSBQQUdFX0NBQ0hFX1NJWkU7CisJcmV0ID0gbHpvMXhfZGVjb21wcmVzc19zYWZlKGRhdGFfaW4sIGluX2xlbiwgd29ya3NwYWNlLT5idWYsICZvdXRfbGVuKTsKKwlpZiAocmV0ICE9IExaT19FX09LKSB7CisJCXByaW50ayhLRVJOX1dBUk5JTkcgImJ0cmZzIGRlY29tcHJlc3MgZmFpbGVkIVxuIik7CisJCXJldCA9IC0xOworCQlnb3RvIG91dDsKKwl9CisKKwlpZiAob3V0X2xlbiA8IHN0YXJ0X2J5dGUpIHsKKwkJcmV0ID0gLTE7CisJCWdvdG8gb3V0OworCX0KKworCWJ5dGVzID0gbWluX3QodW5zaWduZWQgbG9uZywgZGVzdGxlbiwgb3V0X2xlbiAtIHN0YXJ0X2J5dGUpOworCisJa2FkZHIgPSBrbWFwX2F0b21pYyhkZXN0X3BhZ2UsIEtNX1VTRVIwKTsKKwltZW1jcHkoa2FkZHIsIHdvcmtzcGFjZS0+YnVmICsgc3RhcnRfYnl0ZSwgYnl0ZXMpOworCWt1bm1hcF9hdG9taWMoa2FkZHIsIEtNX1VTRVIwKTsKK291dDoKKwlyZXR1cm4gcmV0OworfQorCitzdHJ1Y3QgYnRyZnNfY29tcHJlc3Nfb3AgYnRyZnNfbHpvX2NvbXByZXNzID0geworCS5hbGxvY193b3Jrc3BhY2UJPSBsem9fYWxsb2Nfd29ya3NwYWNlLAorCS5mcmVlX3dvcmtzcGFjZQkJPSBsem9fZnJlZV93b3Jrc3BhY2UsCisJLmNvbXByZXNzX3BhZ2VzCQk9IGx6b19jb21wcmVzc19wYWdlcywKKwkuZGVjb21wcmVzc19iaW92ZWMJPSBsem9fZGVjb21wcmVzc19iaW92ZWMsCisJLmRlY29tcHJlc3MJCT0gbHpvX2RlY29tcHJlc3MsCit9OwpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvb3JkZXJlZC1kYXRhLmMgYi9mcy9idHJmcy9vcmRlcmVkLWRhdGEuYwppbmRleCBhZTc3MzdlLi4wODNhNTU0IDEwMDY0NAotLS0gYS9mcy9idHJmcy9vcmRlcmVkLWRhdGEuYworKysgYi9mcy9idHJmcy9vcmRlcmVkLWRhdGEuYwpAQCAtMTQxLDcgKzE0MSw3IEBACiAJCQkJCSAgdTY0IGZpbGVfb2Zmc2V0KQogewogCXN0cnVjdCByYl9yb290ICpyb290ID0gJnRyZWUtPnRyZWU7Ci0Jc3RydWN0IHJiX25vZGUgKnByZXY7CisJc3RydWN0IHJiX25vZGUgKnByZXYgPSBOVUxMOwogCXN0cnVjdCByYl9ub2RlICpyZXQ7CiAJc3RydWN0IGJ0cmZzX29yZGVyZWRfZXh0ZW50ICplbnRyeTsKIApAQCAtMTcyLDcgKzE3Miw3IEBACiAgKi8KIHN0YXRpYyBpbnQgX19idHJmc19hZGRfb3JkZXJlZF9leHRlbnQoc3RydWN0IGlub2RlICppbm9kZSwgdTY0IGZpbGVfb2Zmc2V0LAogCQkJCSAgICAgIHU2NCBzdGFydCwgdTY0IGxlbiwgdTY0IGRpc2tfbGVuLAotCQkJCSAgICAgIGludCB0eXBlLCBpbnQgZGlvKQorCQkJCSAgICAgIGludCB0eXBlLCBpbnQgZGlvLCBpbnQgY29tcHJlc3NfdHlwZSkKIHsKIAlzdHJ1Y3QgYnRyZnNfb3JkZXJlZF9pbm9kZV90cmVlICp0cmVlOwogCXN0cnVjdCByYl9ub2RlICpub2RlOwpAQCAtMTg5LDYgKzE4OSw3IEBACiAJZW50cnktPmRpc2tfbGVuID0gZGlza19sZW47CiAJZW50cnktPmJ5dGVzX2xlZnQgPSBsZW47CiAJZW50cnktPmlub2RlID0gaW5vZGU7CisJZW50cnktPmNvbXByZXNzX3R5cGUgPSBjb21wcmVzc190eXBlOwogCWlmICh0eXBlICE9IEJUUkZTX09SREVSRURfSU9fRE9ORSAmJiB0eXBlICE9IEJUUkZTX09SREVSRURfQ09NUExFVEUpCiAJCXNldF9iaXQodHlwZSwgJmVudHJ5LT5mbGFncyk7CiAKQEAgLTIyMCwxNCArMjIxLDI1IEBACiAJCQkgICAgIHU2NCBzdGFydCwgdTY0IGxlbiwgdTY0IGRpc2tfbGVuLCBpbnQgdHlwZSkKIHsKIAlyZXR1cm4gX19idHJmc19hZGRfb3JkZXJlZF9leHRlbnQoaW5vZGUsIGZpbGVfb2Zmc2V0LCBzdGFydCwgbGVuLAotCQkJCQkgIGRpc2tfbGVuLCB0eXBlLCAwKTsKKwkJCQkJICBkaXNrX2xlbiwgdHlwZSwgMCwKKwkJCQkJICBCVFJGU19DT01QUkVTU19OT05FKTsKIH0KIAogaW50IGJ0cmZzX2FkZF9vcmRlcmVkX2V4dGVudF9kaW8oc3RydWN0IGlub2RlICppbm9kZSwgdTY0IGZpbGVfb2Zmc2V0LAogCQkJCSB1NjQgc3RhcnQsIHU2NCBsZW4sIHU2NCBkaXNrX2xlbiwgaW50IHR5cGUpCiB7CiAJcmV0dXJuIF9fYnRyZnNfYWRkX29yZGVyZWRfZXh0ZW50KGlub2RlLCBmaWxlX29mZnNldCwgc3RhcnQsIGxlbiwKLQkJCQkJICBkaXNrX2xlbiwgdHlwZSwgMSk7CisJCQkJCSAgZGlza19sZW4sIHR5cGUsIDEsCisJCQkJCSAgQlRSRlNfQ09NUFJFU1NfTk9ORSk7Cit9CisKK2ludCBidHJmc19hZGRfb3JkZXJlZF9leHRlbnRfY29tcHJlc3Moc3RydWN0IGlub2RlICppbm9kZSwgdTY0IGZpbGVfb2Zmc2V0LAorCQkJCSAgICAgIHU2NCBzdGFydCwgdTY0IGxlbiwgdTY0IGRpc2tfbGVuLAorCQkJCSAgICAgIGludCB0eXBlLCBpbnQgY29tcHJlc3NfdHlwZSkKK3sKKwlyZXR1cm4gX19idHJmc19hZGRfb3JkZXJlZF9leHRlbnQoaW5vZGUsIGZpbGVfb2Zmc2V0LCBzdGFydCwgbGVuLAorCQkJCQkgIGRpc2tfbGVuLCB0eXBlLCAwLAorCQkJCQkgIGNvbXByZXNzX3R5cGUpOwogfQogCiAvKgpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvb3JkZXJlZC1kYXRhLmggYi9mcy9idHJmcy9vcmRlcmVkLWRhdGEuaAppbmRleCA2MWRjYTgzLi5mZjFmNjlhIDEwMDY0NAotLS0gYS9mcy9idHJmcy9vcmRlcmVkLWRhdGEuaAorKysgYi9mcy9idHJmcy9vcmRlcmVkLWRhdGEuaApAQCAtNjgsNyArNjgsNyBAQAogCiAjZGVmaW5lIEJUUkZTX09SREVSRURfTk9DT1cgMiAvKiBzZXQgd2hlbiB3ZSB3YW50IHRvIHdyaXRlIGluIHBsYWNlICovCiAKLSNkZWZpbmUgQlRSRlNfT1JERVJFRF9DT01QUkVTU0VEIDMgLyogd3JpdGluZyBhIGNvbXByZXNzZWQgZXh0ZW50ICovCisjZGVmaW5lIEJUUkZTX09SREVSRURfQ09NUFJFU1NFRCAzIC8qIHdyaXRpbmcgYSB6bGliIGNvbXByZXNzZWQgZXh0ZW50ICovCiAKICNkZWZpbmUgQlRSRlNfT1JERVJFRF9QUkVBTExPQyA0IC8qIHNldCB3aGVuIHdyaXRpbmcgdG8gcHJlYWxsb2NlZCBleHRlbnQgKi8KIApAQCAtOTMsNiArOTMsOSBAQAogCS8qIGZsYWdzIChkZXNjcmliZWQgYWJvdmUpICovCiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAorCS8qIGNvbXByZXNzaW9uIGFsZ29yaXRobSAqLworCWludCBjb21wcmVzc190eXBlOworCiAJLyogcmVmZXJlbmNlIGNvdW50ICovCiAJYXRvbWljX3QgcmVmczsKIApAQCAtMTQ4LDYgKzE1MSw5IEBACiAJCQkgICAgIHU2NCBzdGFydCwgdTY0IGxlbiwgdTY0IGRpc2tfbGVuLCBpbnQgdHlwZSk7CiBpbnQgYnRyZnNfYWRkX29yZGVyZWRfZXh0ZW50X2RpbyhzdHJ1Y3QgaW5vZGUgKmlub2RlLCB1NjQgZmlsZV9vZmZzZXQsCiAJCQkJIHU2NCBzdGFydCwgdTY0IGxlbiwgdTY0IGRpc2tfbGVuLCBpbnQgdHlwZSk7CitpbnQgYnRyZnNfYWRkX29yZGVyZWRfZXh0ZW50X2NvbXByZXNzKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHU2NCBmaWxlX29mZnNldCwKKwkJCQkgICAgICB1NjQgc3RhcnQsIHU2NCBsZW4sIHU2NCBkaXNrX2xlbiwKKwkJCQkgICAgICBpbnQgdHlwZSwgaW50IGNvbXByZXNzX3R5cGUpOwogaW50IGJ0cmZzX2FkZF9vcmRlcmVkX3N1bShzdHJ1Y3QgaW5vZGUgKmlub2RlLAogCQkJICBzdHJ1Y3QgYnRyZnNfb3JkZXJlZF9leHRlbnQgKmVudHJ5LAogCQkJICBzdHJ1Y3QgYnRyZnNfb3JkZXJlZF9zdW0gKnN1bSk7CmRpZmYgLS1naXQgYS9mcy9idHJmcy9wcmludC10cmVlLmMgYi9mcy9idHJmcy9wcmludC10cmVlLmMKaW5kZXggMGQxMjZiZS4uZmIyNjA1ZCAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvcHJpbnQtdHJlZS5jCisrKyBiL2ZzL2J0cmZzL3ByaW50LXRyZWUuYwpAQCAtMjYwLDYgKzI2MCw3IEBACiAjZWxzZQogCQkJQlVHKCk7CiAjZW5kaWYKKwkJCWJyZWFrOwogCQljYXNlIEJUUkZTX0JMT0NLX0dST1VQX0lURU1fS0VZOgogCQkJYmkgPSBidHJmc19pdGVtX3B0cihsLCBpLAogCQkJCQkgICAgc3RydWN0IGJ0cmZzX2Jsb2NrX2dyb3VwX2l0ZW0pOwpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvcmVsb2NhdGlvbi5jIGIvZnMvYnRyZnMvcmVsb2NhdGlvbi5jCmluZGV4IDA0NWM5YzIuLjFmNTU1NmFjIDEwMDY0NAotLS0gYS9mcy9idHJmcy9yZWxvY2F0aW9uLmMKKysrIGIvZnMvYnRyZnMvcmVsb2NhdGlvbi5jCkBAIC0yMDI4LDYgKzIwMjgsNyBAQAogCiAJd2hpbGUgKDEpIHsKIAkJdHJhbnMgPSBidHJmc19zdGFydF90cmFuc2FjdGlvbihyb290LCAwKTsKKwkJQlVHX09OKElTX0VSUih0cmFucykpOwogCQl0cmFucy0+YmxvY2tfcnN2ID0gcmMtPmJsb2NrX3JzdjsKIAogCQlyZXQgPSBidHJmc19ibG9ja19yc3ZfY2hlY2sodHJhbnMsIHJvb3QsIHJjLT5ibG9ja19yc3YsCkBAIC0yMTQ3LDYgKzIxNDgsMTIgQEAKIAl9CiAKIAl0cmFucyA9IGJ0cmZzX2pvaW5fdHJhbnNhY3Rpb24ocmMtPmV4dGVudF9yb290LCAxKTsKKwlpZiAoSVNfRVJSKHRyYW5zKSkgeworCQlpZiAoIWVycikKKwkJCWJ0cmZzX2Jsb2NrX3Jzdl9yZWxlYXNlKHJjLT5leHRlbnRfcm9vdCwKKwkJCQkJCXJjLT5ibG9ja19yc3YsIG51bV9ieXRlcyk7CisJCXJldHVybiBQVFJfRVJSKHRyYW5zKTsKKwl9CiAKIAlpZiAoIWVycikgewogCQlpZiAobnVtX2J5dGVzICE9IHJjLT5tZXJnaW5nX3Jzdl9zaXplKSB7CkBAIC0zMjIyLDYgKzMyMjksNyBAQAogCXRyYW5zID0gYnRyZnNfam9pbl90cmFuc2FjdGlvbihyb290LCAwKTsKIAlpZiAoSVNfRVJSKHRyYW5zKSkgewogCQlidHJmc19mcmVlX3BhdGgocGF0aCk7CisJCXJldCA9IFBUUl9FUlIodHJhbnMpOwogCQlnb3RvIG91dDsKIAl9CiAKQEAgLTM2MjgsNiArMzYzNiw3IEBACiAJc2V0X3JlbG9jX2NvbnRyb2wocmMpOwogCiAJdHJhbnMgPSBidHJmc19qb2luX3RyYW5zYWN0aW9uKHJjLT5leHRlbnRfcm9vdCwgMSk7CisJQlVHX09OKElTX0VSUih0cmFucykpOwogCWJ0cmZzX2NvbW1pdF90cmFuc2FjdGlvbih0cmFucywgcmMtPmV4dGVudF9yb290KTsKIAlyZXR1cm4gMDsKIH0KQEAgLTM2NTcsNiArMzY2Niw3IEBACiAKIAl3aGlsZSAoMSkgewogCQl0cmFucyA9IGJ0cmZzX3N0YXJ0X3RyYW5zYWN0aW9uKHJjLT5leHRlbnRfcm9vdCwgMCk7CisJCUJVR19PTihJU19FUlIodHJhbnMpKTsKIAogCQlpZiAodXBkYXRlX2JhY2tyZWZfY2FjaGUodHJhbnMsICZyYy0+YmFja3JlZl9jYWNoZSkpIHsKIAkJCWJ0cmZzX2VuZF90cmFuc2FjdGlvbih0cmFucywgcmMtPmV4dGVudF9yb290KTsKQEAgLTM4MDQsNyArMzgxNCwxMCBAQAogCiAJLyogZ2V0IHJpZCBvZiBwaW5uZWQgZXh0ZW50cyAqLwogCXRyYW5zID0gYnRyZnNfam9pbl90cmFuc2FjdGlvbihyYy0+ZXh0ZW50X3Jvb3QsIDEpOwotCWJ0cmZzX2NvbW1pdF90cmFuc2FjdGlvbih0cmFucywgcmMtPmV4dGVudF9yb290KTsKKwlpZiAoSVNfRVJSKHRyYW5zKSkKKwkJZXJyID0gUFRSX0VSUih0cmFucyk7CisJZWxzZQorCQlidHJmc19jb21taXRfdHJhbnNhY3Rpb24odHJhbnMsIHJjLT5leHRlbnRfcm9vdCk7CiBvdXRfZnJlZToKIAlidHJmc19mcmVlX2Jsb2NrX3JzdihyYy0+ZXh0ZW50X3Jvb3QsIHJjLT5ibG9ja19yc3YpOwogCWJ0cmZzX2ZyZWVfcGF0aChwYXRoKTsKQEAgLTQwMjIsNiArNDAzNSw3IEBACiAJaW50IHJldDsKIAogCXRyYW5zID0gYnRyZnNfc3RhcnRfdHJhbnNhY3Rpb24ocm9vdC0+ZnNfaW5mby0+dHJlZV9yb290LCAwKTsKKwlCVUdfT04oSVNfRVJSKHRyYW5zKSk7CiAKIAltZW1zZXQoJnJvb3QtPnJvb3RfaXRlbS5kcm9wX3Byb2dyZXNzLCAwLAogCQlzaXplb2Yocm9vdC0+cm9vdF9pdGVtLmRyb3BfcHJvZ3Jlc3MpKTsKQEAgLTQxMjUsNiArNDEzOSwxMSBAQAogCXNldF9yZWxvY19jb250cm9sKHJjKTsKIAogCXRyYW5zID0gYnRyZnNfam9pbl90cmFuc2FjdGlvbihyYy0+ZXh0ZW50X3Jvb3QsIDEpOworCWlmIChJU19FUlIodHJhbnMpKSB7CisJCXVuc2V0X3JlbG9jX2NvbnRyb2wocmMpOworCQllcnIgPSBQVFJfRVJSKHRyYW5zKTsKKwkJZ290byBvdXRfZnJlZTsKKwl9CiAKIAlyYy0+bWVyZ2VfcmVsb2NfdHJlZSA9IDE7CiAKQEAgLTQxNTQsOSArNDE3MywxMyBAQAogCXVuc2V0X3JlbG9jX2NvbnRyb2wocmMpOwogCiAJdHJhbnMgPSBidHJmc19qb2luX3RyYW5zYWN0aW9uKHJjLT5leHRlbnRfcm9vdCwgMSk7Ci0JYnRyZnNfY29tbWl0X3RyYW5zYWN0aW9uKHRyYW5zLCByYy0+ZXh0ZW50X3Jvb3QpOwotb3V0OgorCWlmIChJU19FUlIodHJhbnMpKQorCQllcnIgPSBQVFJfRVJSKHRyYW5zKTsKKwllbHNlCisJCWJ0cmZzX2NvbW1pdF90cmFuc2FjdGlvbih0cmFucywgcmMtPmV4dGVudF9yb290KTsKK291dF9mcmVlOgogCWtmcmVlKHJjKTsKK291dDoKIAl3aGlsZSAoIWxpc3RfZW1wdHkoJnJlbG9jX3Jvb3RzKSkgewogCQlyZWxvY19yb290ID0gbGlzdF9lbnRyeShyZWxvY19yb290cy5uZXh0LAogCQkJCQlzdHJ1Y3QgYnRyZnNfcm9vdCwgcm9vdF9saXN0KTsKZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL3N1cGVyLmMgYi9mcy9idHJmcy9zdXBlci5jCmluZGV4IDIyYWNkYWEuLmEwMDQwMDggMTAwNjQ0Ci0tLSBhL2ZzL2J0cmZzL3N1cGVyLmMKKysrIGIvZnMvYnRyZnMvc3VwZXIuYwpAQCAtNTQsNiArNTQsOTAgQEAKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBzdXBlcl9vcGVyYXRpb25zIGJ0cmZzX3N1cGVyX29wczsKIAorc3RhdGljIGNvbnN0IGNoYXIgKmJ0cmZzX2RlY29kZV9lcnJvcihzdHJ1Y3QgYnRyZnNfZnNfaW5mbyAqZnNfaW5mbywgaW50IGVycm5vLAorCQkJCSAgICAgIGNoYXIgbmJ1ZlsxNl0pCit7CisJY2hhciAqZXJyc3RyID0gTlVMTDsKKworCXN3aXRjaCAoZXJybm8pIHsKKwljYXNlIC1FSU86CisJCWVycnN0ciA9ICJJTyBmYWlsdXJlIjsKKwkJYnJlYWs7CisJY2FzZSAtRU5PTUVNOgorCQllcnJzdHIgPSAiT3V0IG9mIG1lbW9yeSI7CisJCWJyZWFrOworCWNhc2UgLUVST0ZTOgorCQllcnJzdHIgPSAiUmVhZG9ubHkgZmlsZXN5c3RlbSI7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWlmIChuYnVmKSB7CisJCQlpZiAoc25wcmludGYobmJ1ZiwgMTYsICJlcnJvciAlZCIsIC1lcnJubykgPj0gMCkKKwkJCQllcnJzdHIgPSBuYnVmOworCQl9CisJCWJyZWFrOworCX0KKworCXJldHVybiBlcnJzdHI7Cit9CisKK3N0YXRpYyB2b2lkIF9fc2F2ZV9lcnJvcl9pbmZvKHN0cnVjdCBidHJmc19mc19pbmZvICpmc19pbmZvKQoreworCS8qCisJICogdG9kYXkgd2Ugb25seSBzYXZlIHRoZSBlcnJvciBpbmZvIGludG8gcmFtLiAgTG9uZyB0ZXJtIHdlJ2xsCisJICogYWxzbyBzZW5kIGl0IGRvd24gdG8gdGhlIGRpc2sKKwkgKi8KKwlmc19pbmZvLT5mc19zdGF0ZSA9IEJUUkZTX1NVUEVSX0ZMQUdfRVJST1I7Cit9CisKKy8qIE5PVEU6CisgKglXZSBtb3ZlIHdyaXRlX3N1cGVyIHN0dWZmIGF0IHVtb3VudCBpbiBvcmRlciB0byBhdm9pZCBkZWFkbG9jaworICoJZm9yIHVtb3VudCBob2xkIGFsbCBsb2NrLgorICovCitzdGF0aWMgdm9pZCBzYXZlX2Vycm9yX2luZm8oc3RydWN0IGJ0cmZzX2ZzX2luZm8gKmZzX2luZm8pCit7CisJX19zYXZlX2Vycm9yX2luZm8oZnNfaW5mbyk7Cit9CisKKy8qIGJ0cmZzIGhhbmRsZSBlcnJvciBieSBmb3JjaW5nIHRoZSBmaWxlc3lzdGVtIHJlYWRvbmx5ICovCitzdGF0aWMgdm9pZCBidHJmc19oYW5kbGVfZXJyb3Ioc3RydWN0IGJ0cmZzX2ZzX2luZm8gKmZzX2luZm8pCit7CisJc3RydWN0IHN1cGVyX2Jsb2NrICpzYiA9IGZzX2luZm8tPnNiOworCisJaWYgKHNiLT5zX2ZsYWdzICYgTVNfUkRPTkxZKQorCQlyZXR1cm47CisKKwlpZiAoZnNfaW5mby0+ZnNfc3RhdGUgJiBCVFJGU19TVVBFUl9GTEFHX0VSUk9SKSB7CisJCXNiLT5zX2ZsYWdzIHw9IE1TX1JET05MWTsKKwkJcHJpbnRrKEtFUk5fSU5GTyAiYnRyZnMgaXMgZm9yY2VkIHJlYWRvbmx5XG4iKTsKKwl9Cit9CisKKy8qCisgKiBfX2J0cmZzX3N0ZF9lcnJvciBkZWNvZGVzIGV4cGVjdGVkIGVycm9ycyBmcm9tIHRoZSBjYWxsZXIgYW5kCisgKiBpbnZva2VzIHRoZSBhcHByb2NpYXRlIGVycm9yIHJlc3BvbnNlLgorICovCit2b2lkIF9fYnRyZnNfc3RkX2Vycm9yKHN0cnVjdCBidHJmc19mc19pbmZvICpmc19pbmZvLCBjb25zdCBjaGFyICpmdW5jdGlvbiwKKwkJICAgICB1bnNpZ25lZCBpbnQgbGluZSwgaW50IGVycm5vKQoreworCXN0cnVjdCBzdXBlcl9ibG9jayAqc2IgPSBmc19pbmZvLT5zYjsKKwljaGFyIG5idWZbMTZdOworCWNvbnN0IGNoYXIgKmVycnN0cjsKKworCS8qCisJICogU3BlY2lhbCBjYXNlOiBpZiB0aGUgZXJyb3IgaXMgRVJPRlMsIGFuZCB3ZSdyZSBhbHJlYWR5CisJICogdW5kZXIgTVNfUkRPTkxZLCB0aGVuIGl0IGlzIHNhZmUgaGVyZS4KKwkgKi8KKwlpZiAoZXJybm8gPT0gLUVST0ZTICYmIChzYi0+c19mbGFncyAmIE1TX1JET05MWSkpCisJCXJldHVybjsKKworCWVycnN0ciA9IGJ0cmZzX2RlY29kZV9lcnJvcihmc19pbmZvLCBlcnJubywgbmJ1Zik7CisJcHJpbnRrKEtFUk5fQ1JJVCAiQlRSRlMgZXJyb3IgKGRldmljZSAlcykgaW4gJXM6JWQ6ICVzXG4iLAorCQlzYi0+c19pZCwgZnVuY3Rpb24sIGxpbmUsIGVycnN0cik7CisJc2F2ZV9lcnJvcl9pbmZvKGZzX2luZm8pOworCisJYnRyZnNfaGFuZGxlX2Vycm9yKGZzX2luZm8pOworfQorCiBzdGF0aWMgdm9pZCBidHJmc19wdXRfc3VwZXIoc3RydWN0IHN1cGVyX2Jsb2NrICpzYikKIHsKIAlzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCA9IGJ0cmZzX3NiKHNiKTsKQEAgLTY5LDkgKzE1Myw5IEBACiAJT3B0X2RlZ3JhZGVkLCBPcHRfc3Vidm9sLCBPcHRfc3Vidm9saWQsIE9wdF9kZXZpY2UsIE9wdF9ub2RhdGFzdW0sCiAJT3B0X25vZGF0YWNvdywgT3B0X21heF9pbmxpbmUsIE9wdF9hbGxvY19zdGFydCwgT3B0X25vYmFycmllciwgT3B0X3NzZCwKIAlPcHRfbm9zc2QsIE9wdF9zc2Rfc3ByZWFkLCBPcHRfdGhyZWFkX3Bvb2wsIE9wdF9ub2FjbCwgT3B0X2NvbXByZXNzLAotCU9wdF9jb21wcmVzc19mb3JjZSwgT3B0X25vdHJlZWxvZywgT3B0X3JhdGlvLCBPcHRfZmx1c2hvbmNvbW1pdCwKLQlPcHRfZGlzY2FyZCwgT3B0X3NwYWNlX2NhY2hlLCBPcHRfY2xlYXJfY2FjaGUsIE9wdF9lcnIsCi0JT3B0X3VzZXJfc3Vidm9sX3JtX2FsbG93ZWQsCisJT3B0X2NvbXByZXNzX3R5cGUsIE9wdF9jb21wcmVzc19mb3JjZSwgT3B0X2NvbXByZXNzX2ZvcmNlX3R5cGUsCisJT3B0X25vdHJlZWxvZywgT3B0X3JhdGlvLCBPcHRfZmx1c2hvbmNvbW1pdCwgT3B0X2Rpc2NhcmQsCisJT3B0X3NwYWNlX2NhY2hlLCBPcHRfY2xlYXJfY2FjaGUsIE9wdF91c2VyX3N1YnZvbF9ybV9hbGxvd2VkLCBPcHRfZXJyLAogfTsKIAogc3RhdGljIG1hdGNoX3RhYmxlX3QgdG9rZW5zID0gewpAQCAtODYsNyArMTcwLDkgQEAKIAl7T3B0X2FsbG9jX3N0YXJ0LCAiYWxsb2Nfc3RhcnQ9JXMifSwKIAl7T3B0X3RocmVhZF9wb29sLCAidGhyZWFkX3Bvb2w9JWQifSwKIAl7T3B0X2NvbXByZXNzLCAiY29tcHJlc3MifSwKKwl7T3B0X2NvbXByZXNzX3R5cGUsICJjb21wcmVzcz0lcyJ9LAogCXtPcHRfY29tcHJlc3NfZm9yY2UsICJjb21wcmVzcy1mb3JjZSJ9LAorCXtPcHRfY29tcHJlc3NfZm9yY2VfdHlwZSwgImNvbXByZXNzLWZvcmNlPSVzIn0sCiAJe09wdF9zc2QsICJzc2QifSwKIAl7T3B0X3NzZF9zcHJlYWQsICJzc2Rfc3ByZWFkIn0sCiAJe09wdF9ub3NzZCwgIm5vc3NkIn0sCkBAIC0xMTIsNiArMTk4LDggQEAKIAljaGFyICpwLCAqbnVtLCAqb3JpZzsKIAlpbnQgaW50YXJnOwogCWludCByZXQgPSAwOworCWNoYXIgKmNvbXByZXNzX3R5cGU7CisJYm9vbCBjb21wcmVzc19mb3JjZSA9IGZhbHNlOwogCiAJaWYgKCFvcHRpb25zKQogCQlyZXR1cm4gMDsKQEAgLTE1NCwxNCArMjQyLDMyIEBACiAJCQlidHJmc19zZXRfb3B0KGluZm8tPm1vdW50X29wdCwgTk9EQVRBQ09XKTsKIAkJCWJ0cmZzX3NldF9vcHQoaW5mby0+bW91bnRfb3B0LCBOT0RBVEFTVU0pOwogCQkJYnJlYWs7Ci0JCWNhc2UgT3B0X2NvbXByZXNzOgotCQkJcHJpbnRrKEtFUk5fSU5GTyAiYnRyZnM6IHVzZSBjb21wcmVzc2lvblxuIik7Ci0JCQlidHJmc19zZXRfb3B0KGluZm8tPm1vdW50X29wdCwgQ09NUFJFU1MpOwotCQkJYnJlYWs7CiAJCWNhc2UgT3B0X2NvbXByZXNzX2ZvcmNlOgotCQkJcHJpbnRrKEtFUk5fSU5GTyAiYnRyZnM6IGZvcmNpbmcgY29tcHJlc3Npb25cbiIpOwotCQkJYnRyZnNfc2V0X29wdChpbmZvLT5tb3VudF9vcHQsIEZPUkNFX0NPTVBSRVNTKTsKKwkJY2FzZSBPcHRfY29tcHJlc3NfZm9yY2VfdHlwZToKKwkJCWNvbXByZXNzX2ZvcmNlID0gdHJ1ZTsKKwkJY2FzZSBPcHRfY29tcHJlc3M6CisJCWNhc2UgT3B0X2NvbXByZXNzX3R5cGU6CisJCQlpZiAodG9rZW4gPT0gT3B0X2NvbXByZXNzIHx8CisJCQkgICAgdG9rZW4gPT0gT3B0X2NvbXByZXNzX2ZvcmNlIHx8CisJCQkgICAgc3RyY21wKGFyZ3NbMF0uZnJvbSwgInpsaWIiKSA9PSAwKSB7CisJCQkJY29tcHJlc3NfdHlwZSA9ICJ6bGliIjsKKwkJCQlpbmZvLT5jb21wcmVzc190eXBlID0gQlRSRlNfQ09NUFJFU1NfWkxJQjsKKwkJCX0gZWxzZSBpZiAoc3RyY21wKGFyZ3NbMF0uZnJvbSwgImx6byIpID09IDApIHsKKwkJCQljb21wcmVzc190eXBlID0gImx6byI7CisJCQkJaW5mby0+Y29tcHJlc3NfdHlwZSA9IEJUUkZTX0NPTVBSRVNTX0xaTzsKKwkJCX0gZWxzZSB7CisJCQkJcmV0ID0gLUVJTlZBTDsKKwkJCQlnb3RvIG91dDsKKwkJCX0KKwogCQkJYnRyZnNfc2V0X29wdChpbmZvLT5tb3VudF9vcHQsIENPTVBSRVNTKTsKKwkJCWlmIChjb21wcmVzc19mb3JjZSkgeworCQkJCWJ0cmZzX3NldF9vcHQoaW5mby0+bW91bnRfb3B0LCBGT1JDRV9DT01QUkVTUyk7CisJCQkJcHJfaW5mbygiYnRyZnM6IGZvcmNlICVzIGNvbXByZXNzaW9uXG4iLAorCQkJCQljb21wcmVzc190eXBlKTsKKwkJCX0gZWxzZQorCQkJCXByX2luZm8oImJ0cmZzOiB1c2UgJXMgY29tcHJlc3Npb25cbiIsCisJCQkJCWNvbXByZXNzX3R5cGUpOwogCQkJYnJlYWs7CiAJCWNhc2UgT3B0X3NzZDoKIAkJCXByaW50ayhLRVJOX0lORk8gImJ0cmZzOiB1c2Ugc3NkIGFsbG9jYXRpb24gc2NoZW1lXG4iKTsKQEAgLTI3Nyw3ICszODMsNyBAQAogCQlzdHJ1Y3QgYnRyZnNfZnNfZGV2aWNlcyAqKmZzX2RldmljZXMpCiB7CiAJc3Vic3RyaW5nX3QgYXJnc1tNQVhfT1BUX0FSR1NdOwotCWNoYXIgKm9wdHMsICpwOworCWNoYXIgKm9wdHMsICpvcmlnLCAqcDsKIAlpbnQgZXJyb3IgPSAwOwogCWludCBpbnRhcmc7CiAKQEAgLTI5MSw2ICszOTcsNyBAQAogCW9wdHMgPSBrc3RyZHVwKG9wdGlvbnMsIEdGUF9LRVJORUwpOwogCWlmICghb3B0cykKIAkJcmV0dXJuIC1FTk9NRU07CisJb3JpZyA9IG9wdHM7CiAKIAl3aGlsZSAoKHAgPSBzdHJzZXAoJm9wdHMsICIsIikpICE9IE5VTEwpIHsKIAkJaW50IHRva2VuOwpAQCAtMzI2LDcgKzQzMyw3IEBACiAJfQogCiAgb3V0X2ZyZWVfb3B0czoKLQlrZnJlZShvcHRzKTsKKwlrZnJlZShvcmlnKTsKICBvdXQ6CiAJLyoKIAkgKiBJZiBubyBzdWJ2b2x1bWUgbmFtZSBpcyBzcGVjaWZpZWQgd2UgdXNlIHRoZSBkZWZhdWx0IG9uZS4gIEFsbG9jYXRlCkBAIC01MTcsNiArNjI0LDggQEAKIAlidHJmc193YWl0X29yZGVyZWRfZXh0ZW50cyhyb290LCAwLCAwKTsKIAogCXRyYW5zID0gYnRyZnNfc3RhcnRfdHJhbnNhY3Rpb24ocm9vdCwgMCk7CisJaWYgKElTX0VSUih0cmFucykpCisJCXJldHVybiBQVFJfRVJSKHRyYW5zKTsKIAlyZXQgPSBidHJmc19jb21taXRfdHJhbnNhY3Rpb24odHJhbnMsIHJvb3QpOwogCXJldHVybiByZXQ7CiB9CkBAIC02NTUsNiArNzY0LDggQEAKIAkJfQogCiAJCWJ0cmZzX2Nsb3NlX2RldmljZXMoZnNfZGV2aWNlcyk7CisJCWtmcmVlKGZzX2luZm8pOworCQlrZnJlZSh0cmVlX3Jvb3QpOwogCX0gZWxzZSB7CiAJCWNoYXIgYltCREVWTkFNRV9TSVpFXTsKIApAQCAtNzUzLDYgKzg2NCwxMjcgQEAKIAlyZXR1cm4gMDsKIH0KIAorLyoKKyAqIFRoZSBoZWxwZXIgdG8gY2FsYyB0aGUgZnJlZSBzcGFjZSBvbiB0aGUgZGV2aWNlcyB0aGF0IGNhbiBiZSB1c2VkIHRvIHN0b3JlCisgKiBmaWxlIGRhdGEuCisgKi8KK3N0YXRpYyBpbnQgYnRyZnNfY2FsY19hdmFpbF9kYXRhX3NwYWNlKHN0cnVjdCBidHJmc19yb290ICpyb290LCB1NjQgKmZyZWVfYnl0ZXMpCit7CisJc3RydWN0IGJ0cmZzX2ZzX2luZm8gKmZzX2luZm8gPSByb290LT5mc19pbmZvOworCXN0cnVjdCBidHJmc19kZXZpY2VfaW5mbyAqZGV2aWNlc19pbmZvOworCXN0cnVjdCBidHJmc19mc19kZXZpY2VzICpmc19kZXZpY2VzID0gZnNfaW5mby0+ZnNfZGV2aWNlczsKKwlzdHJ1Y3QgYnRyZnNfZGV2aWNlICpkZXZpY2U7CisJdTY0IHNraXBfc3BhY2U7CisJdTY0IHR5cGU7CisJdTY0IGF2YWlsX3NwYWNlOworCXU2NCB1c2VkX3NwYWNlOworCXU2NCBtaW5fc3RyaXBlX3NpemU7CisJaW50IG1pbl9zdHJpcGVzID0gMTsKKwlpbnQgaSA9IDAsIG5yX2RldmljZXM7CisJaW50IHJldDsKKworCW5yX2RldmljZXMgPSBmc19pbmZvLT5mc19kZXZpY2VzLT5yd19kZXZpY2VzOworCUJVR19PTighbnJfZGV2aWNlcyk7CisKKwlkZXZpY2VzX2luZm8gPSBrbWFsbG9jKHNpemVvZigqZGV2aWNlc19pbmZvKSAqIG5yX2RldmljZXMsCisJCQkgICAgICAgR0ZQX05PRlMpOworCWlmICghZGV2aWNlc19pbmZvKQorCQlyZXR1cm4gLUVOT01FTTsKKworCS8qIGNhbGMgbWluIHN0cmlwZSBudW1iZXIgZm9yIGRhdGEgc3BhY2UgYWxsb2N0aW9uICovCisJdHlwZSA9IGJ0cmZzX2dldF9hbGxvY19wcm9maWxlKHJvb3QsIDEpOworCWlmICh0eXBlICYgQlRSRlNfQkxPQ0tfR1JPVVBfUkFJRDApCisJCW1pbl9zdHJpcGVzID0gMjsKKwllbHNlIGlmICh0eXBlICYgQlRSRlNfQkxPQ0tfR1JPVVBfUkFJRDEpCisJCW1pbl9zdHJpcGVzID0gMjsKKwllbHNlIGlmICh0eXBlICYgQlRSRlNfQkxPQ0tfR1JPVVBfUkFJRDEwKQorCQltaW5fc3RyaXBlcyA9IDQ7CisKKwlpZiAodHlwZSAmIEJUUkZTX0JMT0NLX0dST1VQX0RVUCkKKwkJbWluX3N0cmlwZV9zaXplID0gMiAqIEJUUkZTX1NUUklQRV9MRU47CisJZWxzZQorCQltaW5fc3RyaXBlX3NpemUgPSBCVFJGU19TVFJJUEVfTEVOOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShkZXZpY2UsICZmc19kZXZpY2VzLT5hbGxvY19saXN0LCBkZXZfYWxsb2NfbGlzdCkgeworCQlpZiAoIWRldmljZS0+aW5fZnNfbWV0YWRhdGEpCisJCQljb250aW51ZTsKKworCQlhdmFpbF9zcGFjZSA9IGRldmljZS0+dG90YWxfYnl0ZXMgLSBkZXZpY2UtPmJ5dGVzX3VzZWQ7CisKKwkJLyogYWxpZ24gd2l0aCBzdHJpcGVfbGVuICovCisJCWRvX2RpdihhdmFpbF9zcGFjZSwgQlRSRlNfU1RSSVBFX0xFTik7CisJCWF2YWlsX3NwYWNlICo9IEJUUkZTX1NUUklQRV9MRU47CisKKwkJLyoKKwkJICogSW4gb3JkZXIgdG8gYXZvaWQgb3ZlcndyaXR0aW5nIHRoZSBzdXBlcmJsb2NrIG9uIHRoZSBkcml2ZSwKKwkJICogYnRyZnMgc3RhcnRzIGF0IGFuIG9mZnNldCBvZiBhdCBsZWFzdCAxTUIgd2hlbiBkb2luZyBjaHVuaworCQkgKiBhbGxvY2F0aW9uLgorCQkgKi8KKwkJc2tpcF9zcGFjZSA9IDEwMjQgKiAxMDI0OworCisJCS8qIHVzZXIgY2FuIHNldCB0aGUgb2Zmc2V0IGluIGZzX2luZm8tPmFsbG9jX3N0YXJ0LiAqLworCQlpZiAoZnNfaW5mby0+YWxsb2Nfc3RhcnQgKyBCVFJGU19TVFJJUEVfTEVOIDw9CisJCSAgICBkZXZpY2UtPnRvdGFsX2J5dGVzKQorCQkJc2tpcF9zcGFjZSA9IG1heChmc19pbmZvLT5hbGxvY19zdGFydCwgc2tpcF9zcGFjZSk7CisKKwkJLyoKKwkJICogYnRyZnMgY2FuIG5vdCB1c2UgdGhlIGZyZWUgc3BhY2UgaW4gWzAsIHNraXBfc3BhY2UgLSAxXSwKKwkJICogd2UgbXVzdCBzdWJ0cmFjdCBpdCBmcm9tIHRoZSB0b3RhbC4gSW4gb3JkZXIgdG8gaW1wbGVtZW50CisJCSAqIGl0LCB3ZSBhY2NvdW50IHRoZSB1c2VkIHNwYWNlIGluIHRoaXMgcmFuZ2UgZmlyc3QuCisJCSAqLworCQlyZXQgPSBidHJmc19hY2NvdW50X2Rldl9leHRlbnRzX3NpemUoZGV2aWNlLCAwLCBza2lwX3NwYWNlIC0gMSwKKwkJCQkJCSAgICAgJnVzZWRfc3BhY2UpOworCQlpZiAocmV0KSB7CisJCQlrZnJlZShkZXZpY2VzX2luZm8pOworCQkJcmV0dXJuIHJldDsKKwkJfQorCisJCS8qIGNhbGMgdGhlIGZyZWUgc3BhY2UgaW4gWzAsIHNraXBfc3BhY2UgLSAxXSAqLworCQlza2lwX3NwYWNlIC09IHVzZWRfc3BhY2U7CisKKwkJLyoKKwkJICogd2UgY2FuIHVzZSB0aGUgZnJlZSBzcGFjZSBpbiBbMCwgc2tpcF9zcGFjZSAtIDFdLCBzdWJ0cmFjdAorCQkgKiBpdCBmcm9tIHRoZSB0b3RhbC4KKwkJICovCisJCWlmIChhdmFpbF9zcGFjZSAmJiBhdmFpbF9zcGFjZSA+PSBza2lwX3NwYWNlKQorCQkJYXZhaWxfc3BhY2UgLT0gc2tpcF9zcGFjZTsKKwkJZWxzZQorCQkJYXZhaWxfc3BhY2UgPSAwOworCisJCWlmIChhdmFpbF9zcGFjZSA8IG1pbl9zdHJpcGVfc2l6ZSkKKwkJCWNvbnRpbnVlOworCisJCWRldmljZXNfaW5mb1tpXS5kZXYgPSBkZXZpY2U7CisJCWRldmljZXNfaW5mb1tpXS5tYXhfYXZhaWwgPSBhdmFpbF9zcGFjZTsKKworCQlpKys7CisJfQorCisJbnJfZGV2aWNlcyA9IGk7CisKKwlidHJmc19kZXNjZW5kaW5nX3NvcnRfZGV2aWNlcyhkZXZpY2VzX2luZm8sIG5yX2RldmljZXMpOworCisJaSA9IG5yX2RldmljZXMgLSAxOworCWF2YWlsX3NwYWNlID0gMDsKKwl3aGlsZSAobnJfZGV2aWNlcyA+PSBtaW5fc3RyaXBlcykgeworCQlpZiAoZGV2aWNlc19pbmZvW2ldLm1heF9hdmFpbCA+PSBtaW5fc3RyaXBlX3NpemUpIHsKKwkJCWludCBqOworCQkJdTY0IGFsbG9jX3NpemU7CisKKwkJCWF2YWlsX3NwYWNlICs9IGRldmljZXNfaW5mb1tpXS5tYXhfYXZhaWwgKiBtaW5fc3RyaXBlczsKKwkJCWFsbG9jX3NpemUgPSBkZXZpY2VzX2luZm9baV0ubWF4X2F2YWlsOworCQkJZm9yIChqID0gaSArIDEgLSBtaW5fc3RyaXBlczsgaiA8PSBpOyBqKyspCisJCQkJZGV2aWNlc19pbmZvW2pdLm1heF9hdmFpbCAtPSBhbGxvY19zaXplOworCQl9CisJCWktLTsKKwkJbnJfZGV2aWNlcy0tOworCX0KKworCWtmcmVlKGRldmljZXNfaW5mbyk7CisJKmZyZWVfYnl0ZXMgPSBhdmFpbF9zcGFjZTsKKwlyZXR1cm4gMDsKK30KKwogc3RhdGljIGludCBidHJmc19zdGF0ZnMoc3RydWN0IGRlbnRyeSAqZGVudHJ5LCBzdHJ1Y3Qga3N0YXRmcyAqYnVmKQogewogCXN0cnVjdCBidHJmc19yb290ICpyb290ID0gYnRyZnNfc2IoZGVudHJ5LT5kX3NiKTsKQEAgLTc2MCwxNyArOTkyLDIxIEBACiAJc3RydWN0IGxpc3RfaGVhZCAqaGVhZCA9ICZyb290LT5mc19pbmZvLT5zcGFjZV9pbmZvOwogCXN0cnVjdCBidHJmc19zcGFjZV9pbmZvICpmb3VuZDsKIAl1NjQgdG90YWxfdXNlZCA9IDA7Ci0JdTY0IHRvdGFsX3VzZWRfZGF0YSA9IDA7CisJdTY0IHRvdGFsX2ZyZWVfZGF0YSA9IDA7CiAJaW50IGJpdHMgPSBkZW50cnktPmRfc2ItPnNfYmxvY2tzaXplX2JpdHM7CiAJX19iZTMyICpmc2lkID0gKF9fYmUzMiAqKXJvb3QtPmZzX2luZm8tPmZzaWQ7CisJaW50IHJldDsKIAorCS8qIGhvbGRpbmcgY2h1bmtfbXVleHQgdG8gYXZvaWQgYWxsb2NhdGluZyBuZXcgY2h1bmtzICovCisJbXV0ZXhfbG9jaygmcm9vdC0+ZnNfaW5mby0+Y2h1bmtfbXV0ZXgpOwogCXJjdV9yZWFkX2xvY2soKTsKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShmb3VuZCwgaGVhZCwgbGlzdCkgewotCQlpZiAoZm91bmQtPmZsYWdzICYgKEJUUkZTX0JMT0NLX0dST1VQX01FVEFEQVRBIHwKLQkJCQkgICAgQlRSRlNfQkxPQ0tfR1JPVVBfU1lTVEVNKSkKLQkJCXRvdGFsX3VzZWRfZGF0YSArPSBmb3VuZC0+ZGlza190b3RhbDsKLQkJZWxzZQotCQkJdG90YWxfdXNlZF9kYXRhICs9IGZvdW5kLT5kaXNrX3VzZWQ7CisJCWlmIChmb3VuZC0+ZmxhZ3MgJiBCVFJGU19CTE9DS19HUk9VUF9EQVRBKSB7CisJCQl0b3RhbF9mcmVlX2RhdGEgKz0gZm91bmQtPmRpc2tfdG90YWwgLSBmb3VuZC0+ZGlza191c2VkOworCQkJdG90YWxfZnJlZV9kYXRhIC09CisJCQkJYnRyZnNfYWNjb3VudF9yb19ibG9ja19ncm91cHNfZnJlZV9zcGFjZShmb3VuZCk7CisJCX0KKwogCQl0b3RhbF91c2VkICs9IGZvdW5kLT5kaXNrX3VzZWQ7CiAJfQogCXJjdV9yZWFkX3VubG9jaygpOwpAQCAtNzc4LDkgKzEwMTQsMTcgQEAKIAlidWYtPmZfbmFtZWxlbiA9IEJUUkZTX05BTUVfTEVOOwogCWJ1Zi0+Zl9ibG9ja3MgPSBidHJmc19zdXBlcl90b3RhbF9ieXRlcyhkaXNrX3N1cGVyKSA+PiBiaXRzOwogCWJ1Zi0+Zl9iZnJlZSA9IGJ1Zi0+Zl9ibG9ja3MgLSAodG90YWxfdXNlZCA+PiBiaXRzKTsKLQlidWYtPmZfYmF2YWlsID0gYnVmLT5mX2Jsb2NrcyAtICh0b3RhbF91c2VkX2RhdGEgPj4gYml0cyk7CiAJYnVmLT5mX2JzaXplID0gZGVudHJ5LT5kX3NiLT5zX2Jsb2Nrc2l6ZTsKIAlidWYtPmZfdHlwZSA9IEJUUkZTX1NVUEVSX01BR0lDOworCWJ1Zi0+Zl9iYXZhaWwgPSB0b3RhbF9mcmVlX2RhdGE7CisJcmV0ID0gYnRyZnNfY2FsY19hdmFpbF9kYXRhX3NwYWNlKHJvb3QsICZ0b3RhbF9mcmVlX2RhdGEpOworCWlmIChyZXQpIHsKKwkJbXV0ZXhfdW5sb2NrKCZyb290LT5mc19pbmZvLT5jaHVua19tdXRleCk7CisJCXJldHVybiByZXQ7CisJfQorCWJ1Zi0+Zl9iYXZhaWwgKz0gdG90YWxfZnJlZV9kYXRhOworCWJ1Zi0+Zl9iYXZhaWwgPSBidWYtPmZfYmF2YWlsID4+IGJpdHM7CisJbXV0ZXhfdW5sb2NrKCZyb290LT5mc19pbmZvLT5jaHVua19tdXRleCk7CiAKIAkvKiBXZSB0cmVhdCBpdCBhcyBjb25zdGFudCBlbmRpYW5uZXNzIChpdCBkb2Vzbid0IG1hdHRlciBfd2hpY2hfKQogCSAgIGJlY2F1c2Ugd2Ugd2FudCB0aGUgZnNpZCB0byBjb21lIG91dCB0aGUgc2FtZSB3aGV0aGVyIG1vdW50ZWQKQEAgLTg5NywxMCArMTE0MSwxNCBAQAogCWlmIChlcnIpCiAJCXJldHVybiBlcnI7CiAKLQllcnIgPSBidHJmc19pbml0X2NhY2hlcCgpOworCWVyciA9IGJ0cmZzX2luaXRfY29tcHJlc3MoKTsKIAlpZiAoZXJyKQogCQlnb3RvIGZyZWVfc3lzZnM7CiAKKwllcnIgPSBidHJmc19pbml0X2NhY2hlcCgpOworCWlmIChlcnIpCisJCWdvdG8gZnJlZV9jb21wcmVzczsKKwogCWVyciA9IGV4dGVudF9pb19pbml0KCk7CiAJaWYgKGVycikKIAkJZ290byBmcmVlX2NhY2hlcDsKQEAgLTkyOCw2ICsxMTc2LDggQEAKIAlleHRlbnRfaW9fZXhpdCgpOwogZnJlZV9jYWNoZXA6CiAJYnRyZnNfZGVzdHJveV9jYWNoZXAoKTsKK2ZyZWVfY29tcHJlc3M6CisJYnRyZnNfZXhpdF9jb21wcmVzcygpOwogZnJlZV9zeXNmczoKIAlidHJmc19leGl0X3N5c2ZzKCk7CiAJcmV0dXJuIGVycjsKQEAgLTk0Miw3ICsxMTkyLDcgQEAKIAl1bnJlZ2lzdGVyX2ZpbGVzeXN0ZW0oJmJ0cmZzX2ZzX3R5cGUpOwogCWJ0cmZzX2V4aXRfc3lzZnMoKTsKIAlidHJmc19jbGVhbnVwX2ZzX3V1aWRzKCk7Ci0JYnRyZnNfemxpYl9leGl0KCk7CisJYnRyZnNfZXhpdF9jb21wcmVzcygpOwogfQogCiBtb2R1bGVfaW5pdChpbml0X2J0cmZzX2ZzKQpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvdHJhbnNhY3Rpb24uYyBiL2ZzL2J0cmZzL3RyYW5zYWN0aW9uLmMKaW5kZXggZjUwZTkzMS4uM2Q3M2M4ZCAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvdHJhbnNhY3Rpb24uYworKysgYi9mcy9idHJmcy90cmFuc2FjdGlvbi5jCkBAIC0xODEsNiArMTgxLDkgQEAKIAlzdHJ1Y3QgYnRyZnNfdHJhbnNfaGFuZGxlICpoOwogCXN0cnVjdCBidHJmc190cmFuc2FjdGlvbiAqY3VyX3RyYW5zOwogCWludCByZXQ7CisKKwlpZiAocm9vdC0+ZnNfaW5mby0+ZnNfc3RhdGUgJiBCVFJGU19TVVBFUl9GTEFHX0VSUk9SKQorCQlyZXR1cm4gRVJSX1BUUigtRVJPRlMpOwogYWdhaW46CiAJaCA9IGttZW1fY2FjaGVfYWxsb2MoYnRyZnNfdHJhbnNfaGFuZGxlX2NhY2hlcCwgR0ZQX05PRlMpOwogCWlmICghaCkKQEAgLTkxMCw2ICs5MTMsNyBAQAogCXU2NCB0b19yZXNlcnZlID0gMDsKIAl1NjQgaW5kZXggPSAwOwogCXU2NCBvYmplY3RpZDsKKwl1NjQgcm9vdF9mbGFnczsKIAogCW5ld19yb290X2l0ZW0gPSBrbWFsbG9jKHNpemVvZigqbmV3X3Jvb3RfaXRlbSksIEdGUF9OT0ZTKTsKIAlpZiAoIW5ld19yb290X2l0ZW0pIHsKQEAgLTk2Nyw2ICs5NzEsMTMgQEAKIAlidHJmc19zZXRfcm9vdF9sYXN0X3NuYXBzaG90KCZyb290LT5yb290X2l0ZW0sIHRyYW5zLT50cmFuc2lkKTsKIAltZW1jcHkobmV3X3Jvb3RfaXRlbSwgJnJvb3QtPnJvb3RfaXRlbSwgc2l6ZW9mKCpuZXdfcm9vdF9pdGVtKSk7CiAKKwlyb290X2ZsYWdzID0gYnRyZnNfcm9vdF9mbGFncyhuZXdfcm9vdF9pdGVtKTsKKwlpZiAocGVuZGluZy0+cmVhZG9ubHkpCisJCXJvb3RfZmxhZ3MgfD0gQlRSRlNfUk9PVF9TVUJWT0xfUkRPTkxZOworCWVsc2UKKwkJcm9vdF9mbGFncyAmPSB+QlRSRlNfUk9PVF9TVUJWT0xfUkRPTkxZOworCWJ0cmZzX3NldF9yb290X2ZsYWdzKG5ld19yb290X2l0ZW0sIHJvb3RfZmxhZ3MpOworCiAJb2xkID0gYnRyZnNfbG9ja19yb290X25vZGUocm9vdCk7CiAJYnRyZnNfY293X2Jsb2NrKHRyYW5zLCByb290LCBvbGQsIE5VTEwsIDAsICZvbGQpOwogCWJ0cmZzX3NldF9sb2NrX2Jsb2NraW5nKG9sZCk7CkBAIC0xMTUwLDYgKzExNjEsMTEgQEAKIAlJTklUX0RFTEFZRURfV09SSygmYWMtPndvcmssIGRvX2FzeW5jX2NvbW1pdCk7CiAJYWMtPnJvb3QgPSByb290OwogCWFjLT5uZXd0cmFucyA9IGJ0cmZzX2pvaW5fdHJhbnNhY3Rpb24ocm9vdCwgMCk7CisJaWYgKElTX0VSUihhYy0+bmV3dHJhbnMpKSB7CisJCWludCBlcnIgPSBQVFJfRVJSKGFjLT5uZXd0cmFucyk7CisJCWtmcmVlKGFjKTsKKwkJcmV0dXJuIGVycjsKKwl9CiAKIAkvKiB0YWtlIHRyYW5zYWN0aW9uIHJlZmVyZW5jZSAqLwogCW11dGV4X2xvY2soJnJvb3QtPmZzX2luZm8tPnRyYW5zX211dGV4KTsKZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL3RyYW5zYWN0aW9uLmggYi9mcy9idHJmcy90cmFuc2FjdGlvbi5oCmluZGV4IGYxMDRiNTcuLjIyOWE1OTQgMTAwNjQ0Ci0tLSBhL2ZzL2J0cmZzL3RyYW5zYWN0aW9uLmgKKysrIGIvZnMvYnRyZnMvdHJhbnNhY3Rpb24uaApAQCAtNjIsNiArNjIsNyBAQAogCXN0cnVjdCBidHJmc19ibG9ja19yc3YgYmxvY2tfcnN2OwogCS8qIGV4dHJhIG1ldGFkYXRhIHJlc2VyYXRpb24gZm9yIHJlbG9jYXRpb24gKi8KIAlpbnQgZXJyb3I7CisJYm9vbCByZWFkb25seTsKIAlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7CiB9OwogCmRpZmYgLS1naXQgYS9mcy9idHJmcy90cmVlLWxvZy5jIGIvZnMvYnRyZnMvdHJlZS1sb2cuYwppbmRleCAwNTQ3NDRhLi5hNGJiYjg1IDEwMDY0NAotLS0gYS9mcy9idHJmcy90cmVlLWxvZy5jCisrKyBiL2ZzL2J0cmZzL3RyZWUtbG9nLmMKQEAgLTMzOCw2ICszMzgsMTIgQEAKIAkJfQogCQlkc3RfY29weSA9IGttYWxsb2MoaXRlbV9zaXplLCBHRlBfTk9GUyk7CiAJCXNyY19jb3B5ID0ga21hbGxvYyhpdGVtX3NpemUsIEdGUF9OT0ZTKTsKKwkJaWYgKCFkc3RfY29weSB8fCAhc3JjX2NvcHkpIHsKKwkJCWJ0cmZzX3JlbGVhc2VfcGF0aChyb290LCBwYXRoKTsKKwkJCWtmcmVlKGRzdF9jb3B5KTsKKwkJCWtmcmVlKHNyY19jb3B5KTsKKwkJCXJldHVybiAtRU5PTUVNOworCQl9CiAKIAkJcmVhZF9leHRlbnRfYnVmZmVyKGViLCBzcmNfY29weSwgc3JjX3B0ciwgaXRlbV9zaXplKTsKIApAQCAtNjY1LDYgKzY3MSw5IEBACiAJYnRyZnNfZGlyX2l0ZW1fa2V5X3RvX2NwdShsZWFmLCBkaSwgJmxvY2F0aW9uKTsKIAluYW1lX2xlbiA9IGJ0cmZzX2Rpcl9uYW1lX2xlbihsZWFmLCBkaSk7CiAJbmFtZSA9IGttYWxsb2MobmFtZV9sZW4sIEdGUF9OT0ZTKTsKKwlpZiAoIW5hbWUpCisJCXJldHVybiAtRU5PTUVNOworCiAJcmVhZF9leHRlbnRfYnVmZmVyKGxlYWYsIG5hbWUsICh1bnNpZ25lZCBsb25nKShkaSArIDEpLCBuYW1lX2xlbik7CiAJYnRyZnNfcmVsZWFzZV9wYXRoKHJvb3QsIHBhdGgpOwogCkBAIC03NDQsNiArNzUzLDkgQEAKIAlpbnQgbWF0Y2ggPSAwOwogCiAJcGF0aCA9IGJ0cmZzX2FsbG9jX3BhdGgoKTsKKwlpZiAoIXBhdGgpCisJCXJldHVybiAtRU5PTUVNOworCiAJcmV0ID0gYnRyZnNfc2VhcmNoX3Nsb3QoTlVMTCwgbG9nLCBrZXksIHBhdGgsIDAsIDApOwogCWlmIChyZXQgIT0gMCkKIAkJZ290byBvdXQ7CkBAIC05NjcsNiArOTc5LDggQEAKIAlrZXkub2Zmc2V0ID0gKHU2NCktMTsKIAogCXBhdGggPSBidHJmc19hbGxvY19wYXRoKCk7CisJaWYgKCFwYXRoKQorCQlyZXR1cm4gLUVOT01FTTsKIAogCXdoaWxlICgxKSB7CiAJCXJldCA9IGJ0cmZzX3NlYXJjaF9zbG90KE5VTEwsIHJvb3QsICZrZXksIHBhdGgsIDAsIDApOwpAQCAtMTE3OCw2ICsxMTkyLDkgQEAKIAogCW5hbWVfbGVuID0gYnRyZnNfZGlyX25hbWVfbGVuKGViLCBkaSk7CiAJbmFtZSA9IGttYWxsb2MobmFtZV9sZW4sIEdGUF9OT0ZTKTsKKwlpZiAoIW5hbWUpCisJCXJldHVybiAtRU5PTUVNOworCiAJbG9nX3R5cGUgPSBidHJmc19kaXJfdHlwZShlYiwgZGkpOwogCXJlYWRfZXh0ZW50X2J1ZmZlcihlYiwgbmFtZSwgKHVuc2lnbmVkIGxvbmcpKGRpICsgMSksCiAJCSAgIG5hbWVfbGVuKTsKQEAgLTE2OTIsNiArMTcwOSw4IEBACiAJCXJvb3Rfb3duZXIgPSBidHJmc19oZWFkZXJfb3duZXIocGFyZW50KTsKIAogCQluZXh0ID0gYnRyZnNfZmluZF9jcmVhdGVfdHJlZV9ibG9jayhyb290LCBieXRlbnIsIGJsb2Nrc2l6ZSk7CisJCWlmICghbmV4dCkKKwkJCXJldHVybiAtRU5PTUVNOwogCiAJCWlmICgqbGV2ZWwgPT0gMSkgewogCQkJd2MtPnByb2Nlc3NfZnVuYyhyb290LCBuZXh0LCB3YywgcHRyX2dlbik7CkBAIC0yMDMyLDYgKzIwNTEsNyBAQAogCQl3YWl0X2xvZ19jb21taXQodHJhbnMsIGxvZ19yb290X3RyZWUsCiAJCQkJbG9nX3Jvb3RfdHJlZS0+bG9nX3RyYW5zaWQpOwogCQltdXRleF91bmxvY2soJmxvZ19yb290X3RyZWUtPmxvZ19tdXRleCk7CisJCXJldCA9IDA7CiAJCWdvdG8gb3V0OwogCX0KIAlhdG9taWNfc2V0KCZsb2dfcm9vdF90cmVlLT5sb2dfY29tbWl0W2luZGV4Ml0sIDEpOwpAQCAtMjA5Niw3ICsyMTE2LDcgQEAKIAlzbXBfbWIoKTsKIAlpZiAod2FpdHF1ZXVlX2FjdGl2ZSgmcm9vdC0+bG9nX2NvbW1pdF93YWl0W2luZGV4MV0pKQogCQl3YWtlX3VwKCZyb290LT5sb2dfY29tbWl0X3dhaXRbaW5kZXgxXSk7Ci0JcmV0dXJuIDA7CisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIHZvaWQgZnJlZV9sb2dfdHJlZShzdHJ1Y3QgYnRyZnNfdHJhbnNfaGFuZGxlICp0cmFucywKQEAgLTIxOTQsNiArMjIxNCw5IEBACiAKIAlsb2cgPSByb290LT5sb2dfcm9vdDsKIAlwYXRoID0gYnRyZnNfYWxsb2NfcGF0aCgpOworCWlmICghcGF0aCkKKwkJcmV0dXJuIC1FTk9NRU07CisKIAlkaSA9IGJ0cmZzX2xvb2t1cF9kaXJfaXRlbSh0cmFucywgbG9nLCBwYXRoLCBkaXItPmlfaW5vLAogCQkJCSAgIG5hbWUsIG5hbWVfbGVuLCAtMSk7CiAJaWYgKElTX0VSUihkaSkpIHsKQEAgLTI1OTQsNiArMjYxNyw5IEBACiAKIAlpbnNfZGF0YSA9IGttYWxsb2MobnIgKiBzaXplb2Yoc3RydWN0IGJ0cmZzX2tleSkgKwogCQkJICAgbnIgKiBzaXplb2YodTMyKSwgR0ZQX05PRlMpOworCWlmICghaW5zX2RhdGEpCisJCXJldHVybiAtRU5PTUVNOworCiAJaW5zX3NpemVzID0gKHUzMiAqKWluc19kYXRhOwogCWluc19rZXlzID0gKHN0cnVjdCBidHJmc19rZXkgKikoaW5zX2RhdGEgKyBuciAqIHNpemVvZih1MzIpKTsKIApAQCAtMjcyNSw3ICsyNzUxLDEzIEBACiAJbG9nID0gcm9vdC0+bG9nX3Jvb3Q7CiAKIAlwYXRoID0gYnRyZnNfYWxsb2NfcGF0aCgpOworCWlmICghcGF0aCkKKwkJcmV0dXJuIC1FTk9NRU07CiAJZHN0X3BhdGggPSBidHJmc19hbGxvY19wYXRoKCk7CisJaWYgKCFkc3RfcGF0aCkgeworCQlidHJmc19mcmVlX3BhdGgocGF0aCk7CisJCXJldHVybiAtRU5PTUVNOworCX0KIAogCW1pbl9rZXkub2JqZWN0aWQgPSBpbm9kZS0+aV9pbm87CiAJbWluX2tleS50eXBlID0gQlRSRlNfSU5PREVfSVRFTV9LRVk7CkBAIC0zMDgwLDYgKzMxMTIsNyBAQAogCUJVR19PTighcGF0aCk7CiAKIAl0cmFucyA9IGJ0cmZzX3N0YXJ0X3RyYW5zYWN0aW9uKGZzX2luZm8tPnRyZWVfcm9vdCwgMCk7CisJQlVHX09OKElTX0VSUih0cmFucykpOwogCiAJd2MudHJhbnMgPSB0cmFuczsKIAl3Yy5waW4gPSAxOwpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvdm9sdW1lcy5jIGIvZnMvYnRyZnMvdm9sdW1lcy5jCmluZGV4IDE3MThlMWEuLjI2MzZhMDUgMTAwNjQ0Ci0tLSBhL2ZzL2J0cmZzL3ZvbHVtZXMuYworKysgYi9mcy9idHJmcy92b2x1bWVzLmMKQEAgLTIyLDYgKzIyLDcgQEAKICNpbmNsdWRlIDxsaW51eC9ibGtkZXYuaD4KICNpbmNsdWRlIDxsaW51eC9yYW5kb20uaD4KICNpbmNsdWRlIDxsaW51eC9pb2NvbnRleHQuaD4KKyNpbmNsdWRlIDxsaW51eC9jYXBhYmlsaXR5Lmg+CiAjaW5jbHVkZSA8YXNtL2RpdjY0Lmg+CiAjaW5jbHVkZSAiY29tcGF0LmgiCiAjaW5jbHVkZSAiY3RyZWUuaCIKQEAgLTYwMCw4ICs2MDEsMTAgQEAKIAkJc2V0X2Jsb2Nrc2l6ZShiZGV2LCA0MDk2KTsKIAogCQliaCA9IGJ0cmZzX3JlYWRfZGV2X3N1cGVyKGJkZXYpOwotCQlpZiAoIWJoKQorCQlpZiAoIWJoKSB7CisJCQlyZXQgPSAtRUlOVkFMOwogCQkJZ290byBlcnJvcl9jbG9zZTsKKwkJfQogCiAJCWRpc2tfc3VwZXIgPSAoc3RydWN0IGJ0cmZzX3N1cGVyX2Jsb2NrICopYmgtPmJfZGF0YTsKIAkJZGV2aWQgPSBidHJmc19zdGFja19kZXZpY2VfaWQoJmRpc2tfc3VwZXItPmRldl9pdGVtKTsKQEAgLTcwMyw3ICs3MDYsNyBAQAogCQlnb3RvIGVycm9yX2Nsb3NlOwogCWJoID0gYnRyZnNfcmVhZF9kZXZfc3VwZXIoYmRldik7CiAJaWYgKCFiaCkgewotCQlyZXQgPSAtRUlPOworCQlyZXQgPSAtRUlOVkFMOwogCQlnb3RvIGVycm9yX2Nsb3NlOwogCX0KIAlkaXNrX3N1cGVyID0gKHN0cnVjdCBidHJmc19zdXBlcl9ibG9jayAqKWJoLT5iX2RhdGE7CkBAIC03MjksNTkgKzczMiw0MiBAQAogCXJldHVybiByZXQ7CiB9CiAKLS8qCi0gKiB0aGlzIHVzZXMgYSBwcmV0dHkgc2ltcGxlIHNlYXJjaCwgdGhlIGV4cGVjdGF0aW9uIGlzIHRoYXQgaXQgaXMKLSAqIGNhbGxlZCB2ZXJ5IGluZnJlcXVlbnRseSBhbmQgdGhhdCBhIGdpdmVuIGRldmljZSBoYXMgYSBzbWFsbCBudW1iZXIKLSAqIG9mIGV4dGVudHMKLSAqLwotaW50IGZpbmRfZnJlZV9kZXZfZXh0ZW50KHN0cnVjdCBidHJmc190cmFuc19oYW5kbGUgKnRyYW5zLAotCQkJIHN0cnVjdCBidHJmc19kZXZpY2UgKmRldmljZSwgdTY0IG51bV9ieXRlcywKLQkJCSB1NjQgKnN0YXJ0LCB1NjQgKm1heF9hdmFpbCkKKy8qIGhlbHBlciB0byBhY2NvdW50IHRoZSB1c2VkIGRldmljZSBzcGFjZSBpbiB0aGUgcmFuZ2UgKi8KK2ludCBidHJmc19hY2NvdW50X2Rldl9leHRlbnRzX3NpemUoc3RydWN0IGJ0cmZzX2RldmljZSAqZGV2aWNlLCB1NjQgc3RhcnQsCisJCQkJICAgdTY0IGVuZCwgdTY0ICpsZW5ndGgpCiB7CiAJc3RydWN0IGJ0cmZzX2tleSBrZXk7CiAJc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QgPSBkZXZpY2UtPmRldl9yb290OwotCXN0cnVjdCBidHJmc19kZXZfZXh0ZW50ICpkZXZfZXh0ZW50ID0gTlVMTDsKKwlzdHJ1Y3QgYnRyZnNfZGV2X2V4dGVudCAqZGV2X2V4dGVudDsKIAlzdHJ1Y3QgYnRyZnNfcGF0aCAqcGF0aDsKLQl1NjQgaG9sZV9zaXplID0gMDsKLQl1NjQgbGFzdF9ieXRlID0gMDsKLQl1NjQgc2VhcmNoX3N0YXJ0ID0gMDsKLQl1NjQgc2VhcmNoX2VuZCA9IGRldmljZS0+dG90YWxfYnl0ZXM7CisJdTY0IGV4dGVudF9lbmQ7CiAJaW50IHJldDsKLQlpbnQgc2xvdCA9IDA7Ci0JaW50IHN0YXJ0X2ZvdW5kOworCWludCBzbG90OwogCXN0cnVjdCBleHRlbnRfYnVmZmVyICpsOwogCisJKmxlbmd0aCA9IDA7CisKKwlpZiAoc3RhcnQgPj0gZGV2aWNlLT50b3RhbF9ieXRlcykKKwkJcmV0dXJuIDA7CisKIAlwYXRoID0gYnRyZnNfYWxsb2NfcGF0aCgpOwogCWlmICghcGF0aCkKIAkJcmV0dXJuIC1FTk9NRU07CiAJcGF0aC0+cmVhZGEgPSAyOwotCXN0YXJ0X2ZvdW5kID0gMDsKLQotCS8qIEZJWE1FIHVzZSBsYXN0IGZyZWUgb2Ygc29tZSBraW5kICovCi0KLQkvKiB3ZSBkb24ndCB3YW50IHRvIG92ZXJ3cml0ZSB0aGUgc3VwZXJibG9jayBvbiB0aGUgZHJpdmUsCi0JICogc28gd2UgbWFrZSBzdXJlIHRvIHN0YXJ0IGF0IGFuIG9mZnNldCBvZiBhdCBsZWFzdCAxTUIKLQkgKi8KLQlzZWFyY2hfc3RhcnQgPSBtYXgoKHU2NCkxMDI0ICogMTAyNCwgc2VhcmNoX3N0YXJ0KTsKLQotCWlmIChyb290LT5mc19pbmZvLT5hbGxvY19zdGFydCArIG51bV9ieXRlcyA8PSBkZXZpY2UtPnRvdGFsX2J5dGVzKQotCQlzZWFyY2hfc3RhcnQgPSBtYXgocm9vdC0+ZnNfaW5mby0+YWxsb2Nfc3RhcnQsIHNlYXJjaF9zdGFydCk7CiAKIAlrZXkub2JqZWN0aWQgPSBkZXZpY2UtPmRldmlkOwotCWtleS5vZmZzZXQgPSBzZWFyY2hfc3RhcnQ7CisJa2V5Lm9mZnNldCA9IHN0YXJ0OwogCWtleS50eXBlID0gQlRSRlNfREVWX0VYVEVOVF9LRVk7Ci0JcmV0ID0gYnRyZnNfc2VhcmNoX3Nsb3QodHJhbnMsIHJvb3QsICZrZXksIHBhdGgsIDAsIDApOworCisJcmV0ID0gYnRyZnNfc2VhcmNoX3Nsb3QoTlVMTCwgcm9vdCwgJmtleSwgcGF0aCwgMCwgMCk7CiAJaWYgKHJldCA8IDApCi0JCWdvdG8gZXJyb3I7CisJCWdvdG8gb3V0OwogCWlmIChyZXQgPiAwKSB7CiAJCXJldCA9IGJ0cmZzX3ByZXZpb3VzX2l0ZW0ocm9vdCwgcGF0aCwga2V5Lm9iamVjdGlkLCBrZXkudHlwZSk7CiAJCWlmIChyZXQgPCAwKQotCQkJZ290byBlcnJvcjsKLQkJaWYgKHJldCA+IDApCi0JCQlzdGFydF9mb3VuZCA9IDE7CisJCQlnb3RvIG91dDsKIAl9Ci0JbCA9IHBhdGgtPm5vZGVzWzBdOwotCWJ0cmZzX2l0ZW1fa2V5X3RvX2NwdShsLCAma2V5LCBwYXRoLT5zbG90c1swXSk7CisKIAl3aGlsZSAoMSkgewogCQlsID0gcGF0aC0+bm9kZXNbMF07CiAJCXNsb3QgPSBwYXRoLT5zbG90c1swXTsKQEAgLTc5MCwyNCArNzc2LDkgQEAKIAkJCWlmIChyZXQgPT0gMCkKIAkJCQljb250aW51ZTsKIAkJCWlmIChyZXQgPCAwKQotCQkJCWdvdG8gZXJyb3I7Ci1ub19tb3JlX2l0ZW1zOgotCQkJaWYgKCFzdGFydF9mb3VuZCkgewotCQkJCWlmIChzZWFyY2hfc3RhcnQgPj0gc2VhcmNoX2VuZCkgewotCQkJCQlyZXQgPSAtRU5PU1BDOwotCQkJCQlnb3RvIGVycm9yOwotCQkJCX0KLQkJCQkqc3RhcnQgPSBzZWFyY2hfc3RhcnQ7Ci0JCQkJc3RhcnRfZm91bmQgPSAxOwotCQkJCWdvdG8gY2hlY2tfcGVuZGluZzsKLQkJCX0KLQkJCSpzdGFydCA9IGxhc3RfYnl0ZSA+IHNlYXJjaF9zdGFydCA/Ci0JCQkJbGFzdF9ieXRlIDogc2VhcmNoX3N0YXJ0OwotCQkJaWYgKHNlYXJjaF9lbmQgPD0gKnN0YXJ0KSB7Ci0JCQkJcmV0ID0gLUVOT1NQQzsKLQkJCQlnb3RvIGVycm9yOwotCQkJfQotCQkJZ290byBjaGVja19wZW5kaW5nOworCQkJCWdvdG8gb3V0OworCisJCQlicmVhazsKIAkJfQogCQlidHJmc19pdGVtX2tleV90b19jcHUobCwgJmtleSwgc2xvdCk7CiAKQEAgLTgxNSw0OCArNzg2LDE4NyBAQAogCQkJZ290byBuZXh0OwogCiAJCWlmIChrZXkub2JqZWN0aWQgPiBkZXZpY2UtPmRldmlkKQotCQkJZ290byBub19tb3JlX2l0ZW1zOworCQkJYnJlYWs7CiAKLQkJaWYgKGtleS5vZmZzZXQgPj0gc2VhcmNoX3N0YXJ0ICYmIGtleS5vZmZzZXQgPiBsYXN0X2J5dGUgJiYKLQkJICAgIHN0YXJ0X2ZvdW5kKSB7Ci0JCQlpZiAobGFzdF9ieXRlIDwgc2VhcmNoX3N0YXJ0KQotCQkJCWxhc3RfYnl0ZSA9IHNlYXJjaF9zdGFydDsKLQkJCWhvbGVfc2l6ZSA9IGtleS5vZmZzZXQgLSBsYXN0X2J5dGU7Ci0KLQkJCWlmIChob2xlX3NpemUgPiAqbWF4X2F2YWlsKQotCQkJCSptYXhfYXZhaWwgPSBob2xlX3NpemU7Ci0KLQkJCWlmIChrZXkub2Zmc2V0ID4gbGFzdF9ieXRlICYmCi0JCQkgICAgaG9sZV9zaXplID49IG51bV9ieXRlcykgewotCQkJCSpzdGFydCA9IGxhc3RfYnl0ZTsKLQkJCQlnb3RvIGNoZWNrX3BlbmRpbmc7Ci0JCQl9Ci0JCX0KIAkJaWYgKGJ0cmZzX2tleV90eXBlKCZrZXkpICE9IEJUUkZTX0RFVl9FWFRFTlRfS0VZKQogCQkJZ290byBuZXh0OwogCi0JCXN0YXJ0X2ZvdW5kID0gMTsKIAkJZGV2X2V4dGVudCA9IGJ0cmZzX2l0ZW1fcHRyKGwsIHNsb3QsIHN0cnVjdCBidHJmc19kZXZfZXh0ZW50KTsKLQkJbGFzdF9ieXRlID0ga2V5Lm9mZnNldCArIGJ0cmZzX2Rldl9leHRlbnRfbGVuZ3RoKGwsIGRldl9leHRlbnQpOworCQlleHRlbnRfZW5kID0ga2V5Lm9mZnNldCArIGJ0cmZzX2Rldl9leHRlbnRfbGVuZ3RoKGwsCisJCQkJCQkJCSAgZGV2X2V4dGVudCk7CisJCWlmIChrZXkub2Zmc2V0IDw9IHN0YXJ0ICYmIGV4dGVudF9lbmQgPiBlbmQpIHsKKwkJCSpsZW5ndGggPSBlbmQgLSBzdGFydCArIDE7CisJCQlicmVhazsKKwkJfSBlbHNlIGlmIChrZXkub2Zmc2V0IDw9IHN0YXJ0ICYmIGV4dGVudF9lbmQgPiBzdGFydCkKKwkJCSpsZW5ndGggKz0gZXh0ZW50X2VuZCAtIHN0YXJ0OworCQllbHNlIGlmIChrZXkub2Zmc2V0ID4gc3RhcnQgJiYgZXh0ZW50X2VuZCA8PSBlbmQpCisJCQkqbGVuZ3RoICs9IGV4dGVudF9lbmQgLSBrZXkub2Zmc2V0OworCQllbHNlIGlmIChrZXkub2Zmc2V0ID4gc3RhcnQgJiYga2V5Lm9mZnNldCA8PSBlbmQpIHsKKwkJCSpsZW5ndGggKz0gZW5kIC0ga2V5Lm9mZnNldCArIDE7CisJCQlicmVhazsKKwkJfSBlbHNlIGlmIChrZXkub2Zmc2V0ID4gZW5kKQorCQkJYnJlYWs7CisKK25leHQ6CisJCXBhdGgtPnNsb3RzWzBdKys7CisJfQorCXJldCA9IDA7CitvdXQ6CisJYnRyZnNfZnJlZV9wYXRoKHBhdGgpOworCXJldHVybiByZXQ7Cit9CisKKy8qCisgKiBmaW5kX2ZyZWVfZGV2X2V4dGVudCAtIGZpbmQgZnJlZSBzcGFjZSBpbiB0aGUgc3BlY2lmaWVkIGRldmljZQorICogQHRyYW5zOgl0cmFuc2FjdGlvbiBoYW5kbGVyCisgKiBAZGV2aWNlOgl0aGUgZGV2aWNlIHdoaWNoIHdlIHNlYXJjaCB0aGUgZnJlZSBzcGFjZSBpbgorICogQG51bV9ieXRlczoJdGhlIHNpemUgb2YgdGhlIGZyZWUgc3BhY2UgdGhhdCB3ZSBuZWVkCisgKiBAc3RhcnQ6CXN0b3JlIHRoZSBzdGFydCBvZiB0aGUgZnJlZSBzcGFjZS4KKyAqIEBsZW46CXRoZSBzaXplIG9mIHRoZSBmcmVlIHNwYWNlLiB0aGF0IHdlIGZpbmQsIG9yIHRoZSBzaXplIG9mIHRoZSBtYXgKKyAqIAkJZnJlZSBzcGFjZSBpZiB3ZSBkb24ndCBmaW5kIHN1aXRhYmxlIGZyZWUgc3BhY2UKKyAqCisgKiB0aGlzIHVzZXMgYSBwcmV0dHkgc2ltcGxlIHNlYXJjaCwgdGhlIGV4cGVjdGF0aW9uIGlzIHRoYXQgaXQgaXMKKyAqIGNhbGxlZCB2ZXJ5IGluZnJlcXVlbnRseSBhbmQgdGhhdCBhIGdpdmVuIGRldmljZSBoYXMgYSBzbWFsbCBudW1iZXIKKyAqIG9mIGV4dGVudHMKKyAqCisgKiBAc3RhcnQgaXMgdXNlZCB0byBzdG9yZSB0aGUgc3RhcnQgb2YgdGhlIGZyZWUgc3BhY2UgaWYgd2UgZmluZC4gQnV0IGlmIHdlCisgKiBkb24ndCBmaW5kIHN1aXRhYmxlIGZyZWUgc3BhY2UsIGl0IHdpbGwgYmUgdXNlZCB0byBzdG9yZSB0aGUgc3RhcnQgcG9zaXRpb24KKyAqIG9mIHRoZSBtYXggZnJlZSBzcGFjZS4KKyAqCisgKiBAbGVuIGlzIHVzZWQgdG8gc3RvcmUgdGhlIHNpemUgb2YgdGhlIGZyZWUgc3BhY2UgdGhhdCB3ZSBmaW5kLgorICogQnV0IGlmIHdlIGRvbid0IGZpbmQgc3VpdGFibGUgZnJlZSBzcGFjZSwgaXQgaXMgdXNlZCB0byBzdG9yZSB0aGUgc2l6ZSBvZgorICogdGhlIG1heCBmcmVlIHNwYWNlLgorICovCitpbnQgZmluZF9mcmVlX2Rldl9leHRlbnQoc3RydWN0IGJ0cmZzX3RyYW5zX2hhbmRsZSAqdHJhbnMsCisJCQkgc3RydWN0IGJ0cmZzX2RldmljZSAqZGV2aWNlLCB1NjQgbnVtX2J5dGVzLAorCQkJIHU2NCAqc3RhcnQsIHU2NCAqbGVuKQoreworCXN0cnVjdCBidHJmc19rZXkga2V5OworCXN0cnVjdCBidHJmc19yb290ICpyb290ID0gZGV2aWNlLT5kZXZfcm9vdDsKKwlzdHJ1Y3QgYnRyZnNfZGV2X2V4dGVudCAqZGV2X2V4dGVudDsKKwlzdHJ1Y3QgYnRyZnNfcGF0aCAqcGF0aDsKKwl1NjQgaG9sZV9zaXplOworCXU2NCBtYXhfaG9sZV9zdGFydDsKKwl1NjQgbWF4X2hvbGVfc2l6ZTsKKwl1NjQgZXh0ZW50X2VuZDsKKwl1NjQgc2VhcmNoX3N0YXJ0OworCXU2NCBzZWFyY2hfZW5kID0gZGV2aWNlLT50b3RhbF9ieXRlczsKKwlpbnQgcmV0OworCWludCBzbG90OworCXN0cnVjdCBleHRlbnRfYnVmZmVyICpsOworCisJLyogRklYTUUgdXNlIGxhc3QgZnJlZSBvZiBzb21lIGtpbmQgKi8KKworCS8qIHdlIGRvbid0IHdhbnQgdG8gb3ZlcndyaXRlIHRoZSBzdXBlcmJsb2NrIG9uIHRoZSBkcml2ZSwKKwkgKiBzbyB3ZSBtYWtlIHN1cmUgdG8gc3RhcnQgYXQgYW4gb2Zmc2V0IG9mIGF0IGxlYXN0IDFNQgorCSAqLworCXNlYXJjaF9zdGFydCA9IDEwMjQgKiAxMDI0OworCisJaWYgKHJvb3QtPmZzX2luZm8tPmFsbG9jX3N0YXJ0ICsgbnVtX2J5dGVzIDw9IHNlYXJjaF9lbmQpCisJCXNlYXJjaF9zdGFydCA9IG1heChyb290LT5mc19pbmZvLT5hbGxvY19zdGFydCwgc2VhcmNoX3N0YXJ0KTsKKworCW1heF9ob2xlX3N0YXJ0ID0gc2VhcmNoX3N0YXJ0OworCW1heF9ob2xlX3NpemUgPSAwOworCisJaWYgKHNlYXJjaF9zdGFydCA+PSBzZWFyY2hfZW5kKSB7CisJCXJldCA9IC1FTk9TUEM7CisJCWdvdG8gZXJyb3I7CisJfQorCisJcGF0aCA9IGJ0cmZzX2FsbG9jX3BhdGgoKTsKKwlpZiAoIXBhdGgpIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBlcnJvcjsKKwl9CisJcGF0aC0+cmVhZGEgPSAyOworCisJa2V5Lm9iamVjdGlkID0gZGV2aWNlLT5kZXZpZDsKKwlrZXkub2Zmc2V0ID0gc2VhcmNoX3N0YXJ0OworCWtleS50eXBlID0gQlRSRlNfREVWX0VYVEVOVF9LRVk7CisKKwlyZXQgPSBidHJmc19zZWFyY2hfc2xvdCh0cmFucywgcm9vdCwgJmtleSwgcGF0aCwgMCwgMCk7CisJaWYgKHJldCA8IDApCisJCWdvdG8gb3V0OworCWlmIChyZXQgPiAwKSB7CisJCXJldCA9IGJ0cmZzX3ByZXZpb3VzX2l0ZW0ocm9vdCwgcGF0aCwga2V5Lm9iamVjdGlkLCBrZXkudHlwZSk7CisJCWlmIChyZXQgPCAwKQorCQkJZ290byBvdXQ7CisJfQorCisJd2hpbGUgKDEpIHsKKwkJbCA9IHBhdGgtPm5vZGVzWzBdOworCQlzbG90ID0gcGF0aC0+c2xvdHNbMF07CisJCWlmIChzbG90ID49IGJ0cmZzX2hlYWRlcl9ucml0ZW1zKGwpKSB7CisJCQlyZXQgPSBidHJmc19uZXh0X2xlYWYocm9vdCwgcGF0aCk7CisJCQlpZiAocmV0ID09IDApCisJCQkJY29udGludWU7CisJCQlpZiAocmV0IDwgMCkKKwkJCQlnb3RvIG91dDsKKworCQkJYnJlYWs7CisJCX0KKwkJYnRyZnNfaXRlbV9rZXlfdG9fY3B1KGwsICZrZXksIHNsb3QpOworCisJCWlmIChrZXkub2JqZWN0aWQgPCBkZXZpY2UtPmRldmlkKQorCQkJZ290byBuZXh0OworCisJCWlmIChrZXkub2JqZWN0aWQgPiBkZXZpY2UtPmRldmlkKQorCQkJYnJlYWs7CisKKwkJaWYgKGJ0cmZzX2tleV90eXBlKCZrZXkpICE9IEJUUkZTX0RFVl9FWFRFTlRfS0VZKQorCQkJZ290byBuZXh0OworCisJCWlmIChrZXkub2Zmc2V0ID4gc2VhcmNoX3N0YXJ0KSB7CisJCQlob2xlX3NpemUgPSBrZXkub2Zmc2V0IC0gc2VhcmNoX3N0YXJ0OworCisJCQlpZiAoaG9sZV9zaXplID4gbWF4X2hvbGVfc2l6ZSkgeworCQkJCW1heF9ob2xlX3N0YXJ0ID0gc2VhcmNoX3N0YXJ0OworCQkJCW1heF9ob2xlX3NpemUgPSBob2xlX3NpemU7CisJCQl9CisKKwkJCS8qCisJCQkgKiBJZiB0aGlzIGZyZWUgc3BhY2UgaXMgZ3JlYXRlciB0aGFuIHdoaWNoIHdlIG5lZWQsCisJCQkgKiBpdCBtdXN0IGJlIHRoZSBtYXggZnJlZSBzcGFjZSB0aGF0IHdlIGhhdmUgZm91bmQKKwkJCSAqIHVudGlsIG5vdywgc28gbWF4X2hvbGVfc3RhcnQgbXVzdCBwb2ludCB0byB0aGUgc3RhcnQKKwkJCSAqIG9mIHRoaXMgZnJlZSBzcGFjZSBhbmQgdGhlIGxlbmd0aCBvZiB0aGlzIGZyZWUgc3BhY2UKKwkJCSAqIGlzIHN0b3JlZCBpbiBtYXhfaG9sZV9zaXplLiBUaHVzLCB3ZSByZXR1cm4KKwkJCSAqIG1heF9ob2xlX3N0YXJ0IGFuZCBtYXhfaG9sZV9zaXplIGFuZCBnbyBiYWNrIHRvIHRoZQorCQkJICogY2FsbGVyLgorCQkJICovCisJCQlpZiAoaG9sZV9zaXplID49IG51bV9ieXRlcykgeworCQkJCXJldCA9IDA7CisJCQkJZ290byBvdXQ7CisJCQl9CisJCX0KKworCQlkZXZfZXh0ZW50ID0gYnRyZnNfaXRlbV9wdHIobCwgc2xvdCwgc3RydWN0IGJ0cmZzX2Rldl9leHRlbnQpOworCQlleHRlbnRfZW5kID0ga2V5Lm9mZnNldCArIGJ0cmZzX2Rldl9leHRlbnRfbGVuZ3RoKGwsCisJCQkJCQkJCSAgZGV2X2V4dGVudCk7CisJCWlmIChleHRlbnRfZW5kID4gc2VhcmNoX3N0YXJ0KQorCQkJc2VhcmNoX3N0YXJ0ID0gZXh0ZW50X2VuZDsKIG5leHQ6CiAJCXBhdGgtPnNsb3RzWzBdKys7CiAJCWNvbmRfcmVzY2hlZCgpOwogCX0KLWNoZWNrX3BlbmRpbmc6Ci0JLyogd2UgaGF2ZSB0byBtYWtlIHN1cmUgd2UgZGlkbid0IGZpbmQgYW4gZXh0ZW50IHRoYXQgaGFzIGFscmVhZHkKLQkgKiBiZWVuIGFsbG9jYXRlZCBieSB0aGUgbWFwIHRyZWUgb3IgdGhlIG9yaWdpbmFsIGFsbG9jYXRpb24KLQkgKi8KLQlCVUdfT04oKnN0YXJ0IDwgc2VhcmNoX3N0YXJ0KTsKIAotCWlmICgqc3RhcnQgKyBudW1fYnl0ZXMgPiBzZWFyY2hfZW5kKSB7Ci0JCXJldCA9IC1FTk9TUEM7Ci0JCWdvdG8gZXJyb3I7CisJaG9sZV9zaXplID0gc2VhcmNoX2VuZC0gc2VhcmNoX3N0YXJ0OworCWlmIChob2xlX3NpemUgPiBtYXhfaG9sZV9zaXplKSB7CisJCW1heF9ob2xlX3N0YXJ0ID0gc2VhcmNoX3N0YXJ0OworCQltYXhfaG9sZV9zaXplID0gaG9sZV9zaXplOwogCX0KLQkvKiBjaGVjayBmb3IgcGVuZGluZyBpbnNlcnRzIGhlcmUgKi8KLQlyZXQgPSAwOwogCi1lcnJvcjoKKwkvKiBTZWUgYWJvdmUuICovCisJaWYgKGhvbGVfc2l6ZSA8IG51bV9ieXRlcykKKwkJcmV0ID0gLUVOT1NQQzsKKwllbHNlCisJCXJldCA9IDA7CisKK291dDoKIAlidHJmc19mcmVlX3BhdGgocGF0aCk7CitlcnJvcjoKKwkqc3RhcnQgPSBtYXhfaG9sZV9zdGFydDsKKwlpZiAobGVuKQorCQkqbGVuID0gbWF4X2hvbGVfc2l6ZTsKIAlyZXR1cm4gcmV0OwogfQogCkBAIC0xMTAzLDYgKzEyMTMsMTAgQEAKIAkJcmV0dXJuIC1FTk9NRU07CiAKIAl0cmFucyA9IGJ0cmZzX3N0YXJ0X3RyYW5zYWN0aW9uKHJvb3QsIDApOworCWlmIChJU19FUlIodHJhbnMpKSB7CisJCWJ0cmZzX2ZyZWVfcGF0aChwYXRoKTsKKwkJcmV0dXJuIFBUUl9FUlIodHJhbnMpOworCX0KIAlrZXkub2JqZWN0aWQgPSBCVFJGU19ERVZfSVRFTVNfT0JKRUNUSUQ7CiAJa2V5LnR5cGUgPSBCVFJGU19ERVZfSVRFTV9LRVk7CiAJa2V5Lm9mZnNldCA9IGRldmljZS0+ZGV2aWQ7CkBAIC0xMTk2LDcgKzEzMTAsNyBAQAogCQlzZXRfYmxvY2tzaXplKGJkZXYsIDQwOTYpOwogCQliaCA9IGJ0cmZzX3JlYWRfZGV2X3N1cGVyKGJkZXYpOwogCQlpZiAoIWJoKSB7Ci0JCQlyZXQgPSAtRUlPOworCQkJcmV0ID0gLUVJTlZBTDsKIAkJCWdvdG8gZXJyb3JfY2xvc2U7CiAJCX0KIAkJZGlza19zdXBlciA9IChzdHJ1Y3QgYnRyZnNfc3VwZXJfYmxvY2sgKiliaC0+Yl9kYXRhOwpAQCAtMTQ5Niw2ICsxNjEwLDEyIEBACiAJfQogCiAJdHJhbnMgPSBidHJmc19zdGFydF90cmFuc2FjdGlvbihyb290LCAwKTsKKwlpZiAoSVNfRVJSKHRyYW5zKSkgeworCQlrZnJlZShkZXZpY2UpOworCQlyZXQgPSBQVFJfRVJSKHRyYW5zKTsKKwkJZ290byBlcnJvcjsKKwl9CisKIAlsb2NrX2NodW5rcyhyb290KTsKIAogCWRldmljZS0+d3JpdGVhYmxlID0gMTsKQEAgLTE3NjMsNyArMTg4Myw3IEBACiAJCXJldHVybiByZXQ7CiAKIAl0cmFucyA9IGJ0cmZzX3N0YXJ0X3RyYW5zYWN0aW9uKHJvb3QsIDApOwotCUJVR19PTighdHJhbnMpOworCUJVR19PTihJU19FUlIodHJhbnMpKTsKIAogCWxvY2tfY2h1bmtzKHJvb3QpOwogCkBAIC0xOTE2LDYgKzIwMzYsOSBAQAogCWlmIChkZXZfcm9vdC0+ZnNfaW5mby0+c2ItPnNfZmxhZ3MgJiBNU19SRE9OTFkpCiAJCXJldHVybiAtRVJPRlM7CiAKKwlpZiAoIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCisJCXJldHVybiAtRVBFUk07CisKIAltdXRleF9sb2NrKCZkZXZfcm9vdC0+ZnNfaW5mby0+dm9sdW1lX211dGV4KTsKIAlkZXZfcm9vdCA9IGRldl9yb290LT5mc19pbmZvLT5kZXZfcm9vdDsKIApAQCAtMTkzNCw3ICsyMDU3LDcgQEAKIAkJQlVHX09OKHJldCk7CiAKIAkJdHJhbnMgPSBidHJmc19zdGFydF90cmFuc2FjdGlvbihkZXZfcm9vdCwgMCk7Ci0JCUJVR19PTighdHJhbnMpOworCQlCVUdfT04oSVNfRVJSKHRyYW5zKSk7CiAKIAkJcmV0ID0gYnRyZnNfZ3Jvd19kZXZpY2UodHJhbnMsIGRldmljZSwgb2xkX3NpemUpOwogCQlCVUdfT04ocmV0KTsKQEAgLTIxMDAsNiArMjIyMywxMSBAQAogCiAJLyogU2hyaW5raW5nIHN1Y2NlZWRlZCwgZWxzZSB3ZSB3b3VsZCBiZSBhdCAiZG9uZSIuICovCiAJdHJhbnMgPSBidHJmc19zdGFydF90cmFuc2FjdGlvbihyb290LCAwKTsKKwlpZiAoSVNfRVJSKHRyYW5zKSkgeworCQlyZXQgPSBQVFJfRVJSKHRyYW5zKTsKKwkJZ290byBkb25lOworCX0KKwogCWxvY2tfY2h1bmtzKHJvb3QpOwogCiAJZGV2aWNlLT5kaXNrX3RvdGFsX2J5dGVzID0gbmV3X3NpemU7CkBAIC0yMTU0LDY2ICsyMjgyLDY3IEBACiAJCXJldHVybiBjYWxjX3NpemUgKiBudW1fc3RyaXBlczsKIH0KIAotc3RhdGljIGludCBfX2J0cmZzX2FsbG9jX2NodW5rKHN0cnVjdCBidHJmc190cmFuc19oYW5kbGUgKnRyYW5zLAotCQkJICAgICAgIHN0cnVjdCBidHJmc19yb290ICpleHRlbnRfcm9vdCwKLQkJCSAgICAgICBzdHJ1Y3QgbWFwX2xvb2t1cCAqKm1hcF9yZXQsCi0JCQkgICAgICAgdTY0ICpudW1fYnl0ZXMsIHU2NCAqc3RyaXBlX3NpemUsCi0JCQkgICAgICAgdTY0IHN0YXJ0LCB1NjQgdHlwZSkKKy8qIFVzZWQgdG8gc29ydCB0aGUgZGV2aWNlcyBieSBtYXhfYXZhaWwoZGVzY2VuZGluZyBzb3J0KSAqLworaW50IGJ0cmZzX2NtcF9kZXZpY2VfZnJlZV9ieXRlcyhjb25zdCB2b2lkICpkZXZfaW5mbzEsIGNvbnN0IHZvaWQgKmRldl9pbmZvMikKIHsKLQlzdHJ1Y3QgYnRyZnNfZnNfaW5mbyAqaW5mbyA9IGV4dGVudF9yb290LT5mc19pbmZvOwotCXN0cnVjdCBidHJmc19kZXZpY2UgKmRldmljZSA9IE5VTEw7Ci0Jc3RydWN0IGJ0cmZzX2ZzX2RldmljZXMgKmZzX2RldmljZXMgPSBpbmZvLT5mc19kZXZpY2VzOwotCXN0cnVjdCBsaXN0X2hlYWQgKmN1cjsKLQlzdHJ1Y3QgbWFwX2xvb2t1cCAqbWFwID0gTlVMTDsKLQlzdHJ1Y3QgZXh0ZW50X21hcF90cmVlICplbV90cmVlOwotCXN0cnVjdCBleHRlbnRfbWFwICplbTsKLQlzdHJ1Y3QgbGlzdF9oZWFkIHByaXZhdGVfZGV2czsKLQlpbnQgbWluX3N0cmlwZV9zaXplID0gMSAqIDEwMjQgKiAxMDI0OwotCXU2NCBjYWxjX3NpemUgPSAxMDI0ICogMTAyNCAqIDEwMjQ7Ci0JdTY0IG1heF9jaHVua19zaXplID0gY2FsY19zaXplOwotCXU2NCBtaW5fZnJlZTsKLQl1NjQgYXZhaWw7Ci0JdTY0IG1heF9hdmFpbCA9IDA7Ci0JdTY0IGRldl9vZmZzZXQ7Ci0JaW50IG51bV9zdHJpcGVzID0gMTsKLQlpbnQgbWluX3N0cmlwZXMgPSAxOwotCWludCBzdWJfc3RyaXBlcyA9IDA7Ci0JaW50IGxvb3BlZCA9IDA7Ci0JaW50IHJldDsKLQlpbnQgaW5kZXg7Ci0JaW50IHN0cmlwZV9sZW4gPSA2NCAqIDEwMjQ7CisJaWYgKCgoc3RydWN0IGJ0cmZzX2RldmljZV9pbmZvICopZGV2X2luZm8xKS0+bWF4X2F2YWlsID4KKwkgICAgKChzdHJ1Y3QgYnRyZnNfZGV2aWNlX2luZm8gKilkZXZfaW5mbzIpLT5tYXhfYXZhaWwpCisJCXJldHVybiAtMTsKKwllbHNlIGlmICgoKHN0cnVjdCBidHJmc19kZXZpY2VfaW5mbyAqKWRldl9pbmZvMSktPm1heF9hdmFpbCA8CisJCSAoKHN0cnVjdCBidHJmc19kZXZpY2VfaW5mbyAqKWRldl9pbmZvMiktPm1heF9hdmFpbCkKKwkJcmV0dXJuIDE7CisJZWxzZQorCQlyZXR1cm4gMDsKK30KIAotCWlmICgodHlwZSAmIEJUUkZTX0JMT0NLX0dST1VQX1JBSUQxKSAmJgotCSAgICAodHlwZSAmIEJUUkZTX0JMT0NLX0dST1VQX0RVUCkpIHsKLQkJV0FSTl9PTigxKTsKLQkJdHlwZSAmPSB+QlRSRlNfQkxPQ0tfR1JPVVBfRFVQOwotCX0KLQlpZiAobGlzdF9lbXB0eSgmZnNfZGV2aWNlcy0+YWxsb2NfbGlzdCkpCi0JCXJldHVybiAtRU5PU1BDOworc3RhdGljIGludCBfX2J0cmZzX2NhbGNfbnN0cmlwZXMoc3RydWN0IGJ0cmZzX2ZzX2RldmljZXMgKmZzX2RldmljZXMsIHU2NCB0eXBlLAorCQkJCSBpbnQgKm51bV9zdHJpcGVzLCBpbnQgKm1pbl9zdHJpcGVzLAorCQkJCSBpbnQgKnN1Yl9zdHJpcGVzKQoreworCSpudW1fc3RyaXBlcyA9IDE7CisJKm1pbl9zdHJpcGVzID0gMTsKKwkqc3ViX3N0cmlwZXMgPSAwOwogCiAJaWYgKHR5cGUgJiAoQlRSRlNfQkxPQ0tfR1JPVVBfUkFJRDApKSB7Ci0JCW51bV9zdHJpcGVzID0gZnNfZGV2aWNlcy0+cndfZGV2aWNlczsKLQkJbWluX3N0cmlwZXMgPSAyOworCQkqbnVtX3N0cmlwZXMgPSBmc19kZXZpY2VzLT5yd19kZXZpY2VzOworCQkqbWluX3N0cmlwZXMgPSAyOwogCX0KIAlpZiAodHlwZSAmIChCVFJGU19CTE9DS19HUk9VUF9EVVApKSB7Ci0JCW51bV9zdHJpcGVzID0gMjsKLQkJbWluX3N0cmlwZXMgPSAyOworCQkqbnVtX3N0cmlwZXMgPSAyOworCQkqbWluX3N0cmlwZXMgPSAyOwogCX0KIAlpZiAodHlwZSAmIChCVFJGU19CTE9DS19HUk9VUF9SQUlEMSkpIHsKIAkJaWYgKGZzX2RldmljZXMtPnJ3X2RldmljZXMgPCAyKQogCQkJcmV0dXJuIC1FTk9TUEM7Ci0JCW51bV9zdHJpcGVzID0gMjsKLQkJbWluX3N0cmlwZXMgPSAyOworCQkqbnVtX3N0cmlwZXMgPSAyOworCQkqbWluX3N0cmlwZXMgPSAyOwogCX0KIAlpZiAodHlwZSAmIChCVFJGU19CTE9DS19HUk9VUF9SQUlEMTApKSB7Ci0JCW51bV9zdHJpcGVzID0gZnNfZGV2aWNlcy0+cndfZGV2aWNlczsKLQkJaWYgKG51bV9zdHJpcGVzIDwgNCkKKwkJKm51bV9zdHJpcGVzID0gZnNfZGV2aWNlcy0+cndfZGV2aWNlczsKKwkJaWYgKCpudW1fc3RyaXBlcyA8IDQpCiAJCQlyZXR1cm4gLUVOT1NQQzsKLQkJbnVtX3N0cmlwZXMgJj0gfih1MzIpMTsKLQkJc3ViX3N0cmlwZXMgPSAyOwotCQltaW5fc3RyaXBlcyA9IDQ7CisJCSpudW1fc3RyaXBlcyAmPSB+KHUzMikxOworCQkqc3ViX3N0cmlwZXMgPSAyOworCQkqbWluX3N0cmlwZXMgPSA0OwogCX0KIAorCXJldHVybiAwOworfQorCitzdGF0aWMgdTY0IF9fYnRyZnNfY2FsY19zdHJpcGVfc2l6ZShzdHJ1Y3QgYnRyZnNfZnNfZGV2aWNlcyAqZnNfZGV2aWNlcywKKwkJCQkgICAgdTY0IHByb3Bvc2VkX3NpemUsIHU2NCB0eXBlLAorCQkJCSAgICBpbnQgbnVtX3N0cmlwZXMsIGludCBzbWFsbF9zdHJpcGUpCit7CisJaW50IG1pbl9zdHJpcGVfc2l6ZSA9IDEgKiAxMDI0ICogMTAyNDsKKwl1NjQgY2FsY19zaXplID0gcHJvcG9zZWRfc2l6ZTsKKwl1NjQgbWF4X2NodW5rX3NpemUgPSBjYWxjX3NpemU7CisJaW50IG5jb3BpZXMgPSAxOworCisJaWYgKHR5cGUgJiAoQlRSRlNfQkxPQ0tfR1JPVVBfUkFJRDEgfAorCQkgICAgQlRSRlNfQkxPQ0tfR1JPVVBfRFVQIHwKKwkJICAgIEJUUkZTX0JMT0NLX0dST1VQX1JBSUQxMCkpCisJCW5jb3BpZXMgPSAyOworCiAJaWYgKHR5cGUgJiBCVFJGU19CTE9DS19HUk9VUF9EQVRBKSB7CiAJCW1heF9jaHVua19zaXplID0gMTAgKiBjYWxjX3NpemU7CiAJCW1pbl9zdHJpcGVfc2l6ZSA9IDY0ICogMTAyNCAqIDEwMjQ7CkBAIC0yMjMwLDUxICsyMzU5LDIwOSBAQAogCW1heF9jaHVua19zaXplID0gbWluKGRpdl9mYWN0b3IoZnNfZGV2aWNlcy0+dG90YWxfcndfYnl0ZXMsIDEpLAogCQkJICAgICBtYXhfY2h1bmtfc2l6ZSk7CiAKLWFnYWluOgotCW1heF9hdmFpbCA9IDA7Ci0JaWYgKCFtYXAgfHwgbWFwLT5udW1fc3RyaXBlcyAhPSBudW1fc3RyaXBlcykgewotCQlrZnJlZShtYXApOwotCQltYXAgPSBrbWFsbG9jKG1hcF9sb29rdXBfc2l6ZShudW1fc3RyaXBlcyksIEdGUF9OT0ZTKTsKLQkJaWYgKCFtYXApCi0JCQlyZXR1cm4gLUVOT01FTTsKLQkJbWFwLT5udW1fc3RyaXBlcyA9IG51bV9zdHJpcGVzOwotCX0KLQotCWlmIChjYWxjX3NpemUgKiBudW1fc3RyaXBlcyA+IG1heF9jaHVua19zaXplKSB7Ci0JCWNhbGNfc2l6ZSA9IG1heF9jaHVua19zaXplOworCWlmIChjYWxjX3NpemUgKiBudW1fc3RyaXBlcyA+IG1heF9jaHVua19zaXplICogbmNvcGllcykgeworCQljYWxjX3NpemUgPSBtYXhfY2h1bmtfc2l6ZSAqIG5jb3BpZXM7CiAJCWRvX2RpdihjYWxjX3NpemUsIG51bV9zdHJpcGVzKTsKLQkJZG9fZGl2KGNhbGNfc2l6ZSwgc3RyaXBlX2xlbik7Ci0JCWNhbGNfc2l6ZSAqPSBzdHJpcGVfbGVuOworCQlkb19kaXYoY2FsY19zaXplLCBCVFJGU19TVFJJUEVfTEVOKTsKKwkJY2FsY19zaXplICo9IEJUUkZTX1NUUklQRV9MRU47CiAJfQogCiAJLyogd2UgZG9uJ3Qgd2FudCB0aW55IHN0cmlwZXMgKi8KLQlpZiAoIWxvb3BlZCkKKwlpZiAoIXNtYWxsX3N0cmlwZSkKIAkJY2FsY19zaXplID0gbWF4X3QodTY0LCBtaW5fc3RyaXBlX3NpemUsIGNhbGNfc2l6ZSk7CiAKIAkvKgotCSAqIHdlJ3JlIGFib3V0IHRvIGRvX2RpdiBieSB0aGUgc3RyaXBlX2xlbiBzbyBsZXRzIG1ha2Ugc3VyZQorCSAqIHdlJ3JlIGFib3V0IHRvIGRvX2RpdiBieSB0aGUgQlRSRlNfU1RSSVBFX0xFTiBzbyBsZXRzIG1ha2Ugc3VyZQogCSAqIHdlIGVuZCB1cCB3aXRoIHNvbWV0aGluZyBiaWdnZXIgdGhhbiBhIHN0cmlwZQogCSAqLwotCWNhbGNfc2l6ZSA9IG1heF90KHU2NCwgY2FsY19zaXplLCBzdHJpcGVfbGVuICogNCk7CisJY2FsY19zaXplID0gbWF4X3QodTY0LCBjYWxjX3NpemUsIEJUUkZTX1NUUklQRV9MRU4pOwogCi0JZG9fZGl2KGNhbGNfc2l6ZSwgc3RyaXBlX2xlbik7Ci0JY2FsY19zaXplICo9IHN0cmlwZV9sZW47CisJZG9fZGl2KGNhbGNfc2l6ZSwgQlRSRlNfU1RSSVBFX0xFTik7CisJY2FsY19zaXplICo9IEJUUkZTX1NUUklQRV9MRU47CisKKwlyZXR1cm4gY2FsY19zaXplOworfQorCitzdGF0aWMgc3RydWN0IG1hcF9sb29rdXAgKl9fc2hyaW5rX21hcF9sb29rdXBfc3RyaXBlcyhzdHJ1Y3QgbWFwX2xvb2t1cCAqbWFwLAorCQkJCQkJICAgICAgaW50IG51bV9zdHJpcGVzKQoreworCXN0cnVjdCBtYXBfbG9va3VwICpuZXc7CisJc2l6ZV90IGxlbiA9IG1hcF9sb29rdXBfc2l6ZShudW1fc3RyaXBlcyk7CisKKwlCVUdfT04obWFwLT5udW1fc3RyaXBlcyA8IG51bV9zdHJpcGVzKTsKKworCWlmIChtYXAtPm51bV9zdHJpcGVzID09IG51bV9zdHJpcGVzKQorCQlyZXR1cm4gbWFwOworCisJbmV3ID0ga21hbGxvYyhsZW4sIEdGUF9OT0ZTKTsKKwlpZiAoIW5ldykgeworCQkvKiBqdXN0IGNoYW5nZSBtYXAtPm51bV9zdHJpcGVzICovCisJCW1hcC0+bnVtX3N0cmlwZXMgPSBudW1fc3RyaXBlczsKKwkJcmV0dXJuIG1hcDsKKwl9CisKKwltZW1jcHkobmV3LCBtYXAsIGxlbik7CisJbmV3LT5udW1fc3RyaXBlcyA9IG51bV9zdHJpcGVzOworCWtmcmVlKG1hcCk7CisJcmV0dXJuIG5ldzsKK30KKworLyoKKyAqIGhlbHBlciB0byBhbGxvY2F0ZSBkZXZpY2Ugc3BhY2UgZnJvbSBidHJmc19kZXZpY2VfaW5mbywgaW4gd2hpY2ggd2Ugc3RvcmVkCisgKiBtYXggZnJlZSBzcGFjZSBpbmZvcm1hdGlvbiBvZiBldmVyeSBkZXZpY2UuIEl0IGlzIHVzZWQgd2hlbiB3ZSBjYW4gbm90CisgKiBhbGxvY2F0ZSBjaHVua3MgYnkgZGVmYXVsdCBzaXplLgorICoKKyAqIEJ5IHRoaXMgaGVscGVyLCB3ZSBjYW4gYWxsb2NhdGUgYSBuZXcgY2h1bmsgYXMgbGFyZ2VyIGFzIHBvc3NpYmxlLgorICovCitzdGF0aWMgaW50IF9fYnRyZnNfYWxsb2NfdGlueV9zcGFjZShzdHJ1Y3QgYnRyZnNfdHJhbnNfaGFuZGxlICp0cmFucywKKwkJCQkgICAgc3RydWN0IGJ0cmZzX2ZzX2RldmljZXMgKmZzX2RldmljZXMsCisJCQkJICAgIHN0cnVjdCBidHJmc19kZXZpY2VfaW5mbyAqZGV2aWNlcywKKwkJCQkgICAgaW50IG5yX2RldmljZSwgdTY0IHR5cGUsCisJCQkJICAgIHN0cnVjdCBtYXBfbG9va3VwICoqbWFwX2xvb2t1cCwKKwkJCQkgICAgaW50IG1pbl9zdHJpcGVzLCB1NjQgKnN0cmlwZV9zaXplKQoreworCWludCBpLCBpbmRleCwgc29ydF9hZ2FpbiA9IDA7CisJaW50IG1pbl9kZXZpY2VzID0gbWluX3N0cmlwZXM7CisJdTY0IG1heF9hdmFpbCwgbWluX2ZyZWU7CisJc3RydWN0IG1hcF9sb29rdXAgKm1hcCA9ICptYXBfbG9va3VwOworCWludCByZXQ7CisKKwlpZiAobnJfZGV2aWNlIDwgbWluX3N0cmlwZXMpCisJCXJldHVybiAtRU5PU1BDOworCisJYnRyZnNfZGVzY2VuZGluZ19zb3J0X2RldmljZXMoZGV2aWNlcywgbnJfZGV2aWNlKTsKKworCW1heF9hdmFpbCA9IGRldmljZXNbMF0ubWF4X2F2YWlsOworCWlmICghbWF4X2F2YWlsKQorCQlyZXR1cm4gLUVOT1NQQzsKKworCWZvciAoaSA9IDA7IGkgPCBucl9kZXZpY2U7IGkrKykgeworCQkvKgorCQkgKiBpZiBkZXZfb2Zmc2V0ID0gMCwgaXQgbWVhbnMgdGhlIGZyZWUgc3BhY2Ugb2YgdGhpcyBkZXZpY2UKKwkJICogaXMgbGVzcyB0aGFuIHdoYXQgd2UgbmVlZCwgYW5kIHdlIGRpZG4ndCBzZWFyY2ggbWF4IGF2YWlsCisJCSAqIGV4dGVudCBvbiB0aGlzIGRldmljZSwgc28gZG8gaXQgbm93LgorCQkgKi8KKwkJaWYgKCFkZXZpY2VzW2ldLmRldl9vZmZzZXQpIHsKKwkJCXJldCA9IGZpbmRfZnJlZV9kZXZfZXh0ZW50KHRyYW5zLCBkZXZpY2VzW2ldLmRldiwKKwkJCQkJCSAgIG1heF9hdmFpbCwKKwkJCQkJCSAgICZkZXZpY2VzW2ldLmRldl9vZmZzZXQsCisJCQkJCQkgICAmZGV2aWNlc1tpXS5tYXhfYXZhaWwpOworCQkJaWYgKHJldCAhPSAwICYmIHJldCAhPSAtRU5PU1BDKQorCQkJCXJldHVybiByZXQ7CisJCQlzb3J0X2FnYWluID0gMTsKKwkJfQorCX0KKworCS8qIHdlIHVwZGF0ZSB0aGUgbWF4IGF2YWlsIGZyZWUgZXh0ZW50IG9mIGVhY2ggZGV2aWNlcywgc29ydCBhZ2FpbiAqLworCWlmIChzb3J0X2FnYWluKQorCQlidHJmc19kZXNjZW5kaW5nX3NvcnRfZGV2aWNlcyhkZXZpY2VzLCBucl9kZXZpY2UpOworCisJaWYgKHR5cGUgJiBCVFJGU19CTE9DS19HUk9VUF9EVVApCisJCW1pbl9kZXZpY2VzID0gMTsKKworCWlmICghZGV2aWNlc1ttaW5fZGV2aWNlcyAtIDFdLm1heF9hdmFpbCkKKwkJcmV0dXJuIC1FTk9TUEM7CisKKwltYXhfYXZhaWwgPSBkZXZpY2VzW21pbl9kZXZpY2VzIC0gMV0ubWF4X2F2YWlsOworCWlmICh0eXBlICYgQlRSRlNfQkxPQ0tfR1JPVVBfRFVQKQorCQlkb19kaXYobWF4X2F2YWlsLCAyKTsKKworCW1heF9hdmFpbCA9IF9fYnRyZnNfY2FsY19zdHJpcGVfc2l6ZShmc19kZXZpY2VzLCBtYXhfYXZhaWwsIHR5cGUsCisJCQkJCSAgICAgbWluX3N0cmlwZXMsIDEpOworCWlmICh0eXBlICYgQlRSRlNfQkxPQ0tfR1JPVVBfRFVQKQorCQltaW5fZnJlZSA9IG1heF9hdmFpbCAqIDI7CisJZWxzZQorCQltaW5fZnJlZSA9IG1heF9hdmFpbDsKKworCWlmIChtaW5fZnJlZSA+IGRldmljZXNbbWluX2RldmljZXMgLSAxXS5tYXhfYXZhaWwpCisJCXJldHVybiAtRU5PU1BDOworCisJbWFwID0gX19zaHJpbmtfbWFwX2xvb2t1cF9zdHJpcGVzKG1hcCwgbWluX3N0cmlwZXMpOworCSpzdHJpcGVfc2l6ZSA9IG1heF9hdmFpbDsKKworCWluZGV4ID0gMDsKKwlmb3IgKGkgPSAwOyBpIDwgbWluX3N0cmlwZXM7IGkrKykgeworCQltYXAtPnN0cmlwZXNbaV0uZGV2ID0gZGV2aWNlc1tpbmRleF0uZGV2OworCQltYXAtPnN0cmlwZXNbaV0ucGh5c2ljYWwgPSBkZXZpY2VzW2luZGV4XS5kZXZfb2Zmc2V0OworCQlpZiAodHlwZSAmIEJUUkZTX0JMT0NLX0dST1VQX0RVUCkgeworCQkJaSsrOworCQkJbWFwLT5zdHJpcGVzW2ldLmRldiA9IGRldmljZXNbaW5kZXhdLmRldjsKKwkJCW1hcC0+c3RyaXBlc1tpXS5waHlzaWNhbCA9IGRldmljZXNbaW5kZXhdLmRldl9vZmZzZXQgKworCQkJCQkJICAgbWF4X2F2YWlsOworCQl9CisJCWluZGV4Kys7CisJfQorCSptYXBfbG9va3VwID0gbWFwOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgX19idHJmc19hbGxvY19jaHVuayhzdHJ1Y3QgYnRyZnNfdHJhbnNfaGFuZGxlICp0cmFucywKKwkJCSAgICAgICBzdHJ1Y3QgYnRyZnNfcm9vdCAqZXh0ZW50X3Jvb3QsCisJCQkgICAgICAgc3RydWN0IG1hcF9sb29rdXAgKiptYXBfcmV0LAorCQkJICAgICAgIHU2NCAqbnVtX2J5dGVzLCB1NjQgKnN0cmlwZV9zaXplLAorCQkJICAgICAgIHU2NCBzdGFydCwgdTY0IHR5cGUpCit7CisJc3RydWN0IGJ0cmZzX2ZzX2luZm8gKmluZm8gPSBleHRlbnRfcm9vdC0+ZnNfaW5mbzsKKwlzdHJ1Y3QgYnRyZnNfZGV2aWNlICpkZXZpY2UgPSBOVUxMOworCXN0cnVjdCBidHJmc19mc19kZXZpY2VzICpmc19kZXZpY2VzID0gaW5mby0+ZnNfZGV2aWNlczsKKwlzdHJ1Y3QgbGlzdF9oZWFkICpjdXI7CisJc3RydWN0IG1hcF9sb29rdXAgKm1hcDsKKwlzdHJ1Y3QgZXh0ZW50X21hcF90cmVlICplbV90cmVlOworCXN0cnVjdCBleHRlbnRfbWFwICplbTsKKwlzdHJ1Y3QgYnRyZnNfZGV2aWNlX2luZm8gKmRldmljZXNfaW5mbzsKKwlzdHJ1Y3QgbGlzdF9oZWFkIHByaXZhdGVfZGV2czsKKwl1NjQgY2FsY19zaXplID0gMTAyNCAqIDEwMjQgKiAxMDI0OworCXU2NCBtaW5fZnJlZTsKKwl1NjQgYXZhaWw7CisJdTY0IGRldl9vZmZzZXQ7CisJaW50IG51bV9zdHJpcGVzOworCWludCBtaW5fc3RyaXBlczsKKwlpbnQgc3ViX3N0cmlwZXM7CisJaW50IG1pbl9kZXZpY2VzOwkvKiB0aGUgbWluIG51bWJlciBvZiBkZXZpY2VzIHdlIG5lZWQgKi8KKwlpbnQgaTsKKwlpbnQgcmV0OworCWludCBpbmRleDsKKworCWlmICgodHlwZSAmIEJUUkZTX0JMT0NLX0dST1VQX1JBSUQxKSAmJgorCSAgICAodHlwZSAmIEJUUkZTX0JMT0NLX0dST1VQX0RVUCkpIHsKKwkJV0FSTl9PTigxKTsKKwkJdHlwZSAmPSB+QlRSRlNfQkxPQ0tfR1JPVVBfRFVQOworCX0KKwlpZiAobGlzdF9lbXB0eSgmZnNfZGV2aWNlcy0+YWxsb2NfbGlzdCkpCisJCXJldHVybiAtRU5PU1BDOworCisJcmV0ID0gX19idHJmc19jYWxjX25zdHJpcGVzKGZzX2RldmljZXMsIHR5cGUsICZudW1fc3RyaXBlcywKKwkJCQkgICAgJm1pbl9zdHJpcGVzLCAmc3ViX3N0cmlwZXMpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlkZXZpY2VzX2luZm8gPSBremFsbG9jKHNpemVvZigqZGV2aWNlc19pbmZvKSAqIGZzX2RldmljZXMtPnJ3X2RldmljZXMsCisJCQkgICAgICAgR0ZQX05PRlMpOworCWlmICghZGV2aWNlc19pbmZvKQorCQlyZXR1cm4gLUVOT01FTTsKKworCW1hcCA9IGttYWxsb2MobWFwX2xvb2t1cF9zaXplKG51bV9zdHJpcGVzKSwgR0ZQX05PRlMpOworCWlmICghbWFwKSB7CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gZXJyb3I7CisJfQorCW1hcC0+bnVtX3N0cmlwZXMgPSBudW1fc3RyaXBlczsKIAogCWN1ciA9IGZzX2RldmljZXMtPmFsbG9jX2xpc3QubmV4dDsKIAlpbmRleCA9IDA7CisJaSA9IDA7CiAKLQlpZiAodHlwZSAmIEJUUkZTX0JMT0NLX0dST1VQX0RVUCkKKwljYWxjX3NpemUgPSBfX2J0cmZzX2NhbGNfc3RyaXBlX3NpemUoZnNfZGV2aWNlcywgY2FsY19zaXplLCB0eXBlLAorCQkJCQkgICAgIG51bV9zdHJpcGVzLCAwKTsKKworCWlmICh0eXBlICYgQlRSRlNfQkxPQ0tfR1JPVVBfRFVQKSB7CiAJCW1pbl9mcmVlID0gY2FsY19zaXplICogMjsKLQllbHNlCisJCW1pbl9kZXZpY2VzID0gMTsKKwl9IGVsc2UgewogCQltaW5fZnJlZSA9IGNhbGNfc2l6ZTsKLQotCS8qCi0JICogd2UgYWRkIDFNQiBiZWNhdXNlIHdlIG5ldmVyIHVzZSB0aGUgZmlyc3QgMU1CIG9mIHRoZSBkZXZpY2UsIHVubGVzcwotCSAqIHdlJ3ZlIGxvb3BlZCwgdGhlbiB3ZSBhcmUgbGlrZWx5IGFsbG9jYXRpbmcgdGhlIG1heGltdW0gYW1vdW50IG9mCi0JICogc3BhY2UgbGVmdCBhbHJlYWR5Ci0JICovCi0JaWYgKCFsb29wZWQpCi0JCW1pbl9mcmVlICs9IDEwMjQgKiAxMDI0OworCQltaW5fZGV2aWNlcyA9IG1pbl9zdHJpcGVzOworCX0KIAogCUlOSVRfTElTVF9IRUFEKCZwcml2YXRlX2RldnMpOwogCXdoaWxlIChpbmRleCA8IG51bV9zdHJpcGVzKSB7CkBAIC0yMjg3LDI3ICsyNTc0LDM5IEBACiAJCWN1ciA9IGN1ci0+bmV4dDsKIAogCQlpZiAoZGV2aWNlLT5pbl9mc19tZXRhZGF0YSAmJiBhdmFpbCA+PSBtaW5fZnJlZSkgewotCQkJcmV0ID0gZmluZF9mcmVlX2Rldl9leHRlbnQodHJhbnMsIGRldmljZSwKLQkJCQkJCSAgIG1pbl9mcmVlLCAmZGV2X29mZnNldCwKLQkJCQkJCSAgICZtYXhfYXZhaWwpOworCQkJcmV0ID0gZmluZF9mcmVlX2Rldl9leHRlbnQodHJhbnMsIGRldmljZSwgbWluX2ZyZWUsCisJCQkJCQkgICAmZGV2aWNlc19pbmZvW2ldLmRldl9vZmZzZXQsCisJCQkJCQkgICAmZGV2aWNlc19pbmZvW2ldLm1heF9hdmFpbCk7CiAJCQlpZiAocmV0ID09IDApIHsKIAkJCQlsaXN0X21vdmVfdGFpbCgmZGV2aWNlLT5kZXZfYWxsb2NfbGlzdCwKIAkJCQkJICAgICAgICZwcml2YXRlX2RldnMpOwogCQkJCW1hcC0+c3RyaXBlc1tpbmRleF0uZGV2ID0gZGV2aWNlOwotCQkJCW1hcC0+c3RyaXBlc1tpbmRleF0ucGh5c2ljYWwgPSBkZXZfb2Zmc2V0OworCQkJCW1hcC0+c3RyaXBlc1tpbmRleF0ucGh5c2ljYWwgPQorCQkJCQkJZGV2aWNlc19pbmZvW2ldLmRldl9vZmZzZXQ7CiAJCQkJaW5kZXgrKzsKIAkJCQlpZiAodHlwZSAmIEJUUkZTX0JMT0NLX0dST1VQX0RVUCkgewogCQkJCQltYXAtPnN0cmlwZXNbaW5kZXhdLmRldiA9IGRldmljZTsKIAkJCQkJbWFwLT5zdHJpcGVzW2luZGV4XS5waHlzaWNhbCA9Ci0JCQkJCQlkZXZfb2Zmc2V0ICsgY2FsY19zaXplOworCQkJCQkJZGV2aWNlc19pbmZvW2ldLmRldl9vZmZzZXQgKworCQkJCQkJY2FsY19zaXplOwogCQkJCQlpbmRleCsrOwogCQkJCX0KLQkJCX0KLQkJfSBlbHNlIGlmIChkZXZpY2UtPmluX2ZzX21ldGFkYXRhICYmIGF2YWlsID4gbWF4X2F2YWlsKQotCQkJbWF4X2F2YWlsID0gYXZhaWw7CisJCQl9IGVsc2UgaWYgKHJldCAhPSAtRU5PU1BDKQorCQkJCWdvdG8gZXJyb3I7CisKKwkJCWRldmljZXNfaW5mb1tpXS5kZXYgPSBkZXZpY2U7CisJCQlpKys7CisJCX0gZWxzZSBpZiAoZGV2aWNlLT5pbl9mc19tZXRhZGF0YSAmJgorCQkJICAgYXZhaWwgPj0gQlRSRlNfU1RSSVBFX0xFTikgeworCQkJZGV2aWNlc19pbmZvW2ldLmRldiA9IGRldmljZTsKKwkJCWRldmljZXNfaW5mb1tpXS5tYXhfYXZhaWwgPSBhdmFpbDsKKwkJCWkrKzsKKwkJfQorCiAJCWlmIChjdXIgPT0gJmZzX2RldmljZXMtPmFsbG9jX2xpc3QpCiAJCQlicmVhazsKIAl9CisKIAlsaXN0X3NwbGljZSgmcHJpdmF0ZV9kZXZzLCAmZnNfZGV2aWNlcy0+YWxsb2NfbGlzdCk7CiAJaWYgKGluZGV4IDwgbnVtX3N0cmlwZXMpIHsKIAkJaWYgKGluZGV4ID49IG1pbl9zdHJpcGVzKSB7CkBAIC0yMzE2LDM0ICsyNjE1LDM2IEBACiAJCQkJbnVtX3N0cmlwZXMgLz0gc3ViX3N0cmlwZXM7CiAJCQkJbnVtX3N0cmlwZXMgKj0gc3ViX3N0cmlwZXM7CiAJCQl9Ci0JCQlsb29wZWQgPSAxOwotCQkJZ290byBhZ2FpbjsKKworCQkJbWFwID0gX19zaHJpbmtfbWFwX2xvb2t1cF9zdHJpcGVzKG1hcCwgbnVtX3N0cmlwZXMpOworCQl9IGVsc2UgaWYgKGkgPj0gbWluX2RldmljZXMpIHsKKwkJCXJldCA9IF9fYnRyZnNfYWxsb2NfdGlueV9zcGFjZSh0cmFucywgZnNfZGV2aWNlcywKKwkJCQkJCSAgICAgICBkZXZpY2VzX2luZm8sIGksIHR5cGUsCisJCQkJCQkgICAgICAgJm1hcCwgbWluX3N0cmlwZXMsCisJCQkJCQkgICAgICAgJmNhbGNfc2l6ZSk7CisJCQlpZiAocmV0KQorCQkJCWdvdG8gZXJyb3I7CisJCX0gZWxzZSB7CisJCQlyZXQgPSAtRU5PU1BDOworCQkJZ290byBlcnJvcjsKIAkJfQotCQlpZiAoIWxvb3BlZCAmJiBtYXhfYXZhaWwgPiAwKSB7Ci0JCQlsb29wZWQgPSAxOwotCQkJY2FsY19zaXplID0gbWF4X2F2YWlsOwotCQkJZ290byBhZ2FpbjsKLQkJfQotCQlrZnJlZShtYXApOwotCQlyZXR1cm4gLUVOT1NQQzsKIAl9CiAJbWFwLT5zZWN0b3Jfc2l6ZSA9IGV4dGVudF9yb290LT5zZWN0b3JzaXplOwotCW1hcC0+c3RyaXBlX2xlbiA9IHN0cmlwZV9sZW47Ci0JbWFwLT5pb19hbGlnbiA9IHN0cmlwZV9sZW47Ci0JbWFwLT5pb193aWR0aCA9IHN0cmlwZV9sZW47CisJbWFwLT5zdHJpcGVfbGVuID0gQlRSRlNfU1RSSVBFX0xFTjsKKwltYXAtPmlvX2FsaWduID0gQlRSRlNfU1RSSVBFX0xFTjsKKwltYXAtPmlvX3dpZHRoID0gQlRSRlNfU1RSSVBFX0xFTjsKIAltYXAtPnR5cGUgPSB0eXBlOwotCW1hcC0+bnVtX3N0cmlwZXMgPSBudW1fc3RyaXBlczsKIAltYXAtPnN1Yl9zdHJpcGVzID0gc3ViX3N0cmlwZXM7CiAKIAkqbWFwX3JldCA9IG1hcDsKIAkqc3RyaXBlX3NpemUgPSBjYWxjX3NpemU7CiAJKm51bV9ieXRlcyA9IGNodW5rX2J5dGVzX2J5X3R5cGUodHlwZSwgY2FsY19zaXplLAotCQkJCQkgbnVtX3N0cmlwZXMsIHN1Yl9zdHJpcGVzKTsKKwkJCQkJIG1hcC0+bnVtX3N0cmlwZXMsIHN1Yl9zdHJpcGVzKTsKIAogCWVtID0gYWxsb2NfZXh0ZW50X21hcChHRlBfTk9GUyk7CiAJaWYgKCFlbSkgewotCQlrZnJlZShtYXApOwotCQlyZXR1cm4gLUVOT01FTTsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBlcnJvcjsKIAl9CiAJZW0tPmJkZXYgPSAoc3RydWN0IGJsb2NrX2RldmljZSAqKW1hcDsKIAllbS0+c3RhcnQgPSBzdGFydDsKQEAgLTIzNzYsNyArMjY3NywxMyBAQAogCQlpbmRleCsrOwogCX0KIAorCWtmcmVlKGRldmljZXNfaW5mbyk7CiAJcmV0dXJuIDA7CisKK2Vycm9yOgorCWtmcmVlKG1hcCk7CisJa2ZyZWUoZGV2aWNlc19pbmZvKTsKKwlyZXR1cm4gcmV0OwogfQogCiBzdGF0aWMgaW50IF9fZmluaXNoX2NodW5rX2FsbG9jKHN0cnVjdCBidHJmc190cmFuc19oYW5kbGUgKnRyYW5zLApkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvdm9sdW1lcy5oIGIvZnMvYnRyZnMvdm9sdW1lcy5oCmluZGV4IDFiZTc4MTAuLjdmYjU5ZDQgMTAwNjQ0Ci0tLSBhL2ZzL2J0cmZzL3ZvbHVtZXMuaAorKysgYi9mcy9idHJmcy92b2x1bWVzLmgKQEAgLTIwLDggKzIwLDExIEBACiAjZGVmaW5lIF9fQlRSRlNfVk9MVU1FU18KIAogI2luY2x1ZGUgPGxpbnV4L2Jpby5oPgorI2luY2x1ZGUgPGxpbnV4L3NvcnQuaD4KICNpbmNsdWRlICJhc3luYy10aHJlYWQuaCIKIAorI2RlZmluZSBCVFJGU19TVFJJUEVfTEVOCSg2NCAqIDEwMjQpCisKIHN0cnVjdCBidWZmZXJfaGVhZDsKIHN0cnVjdCBidHJmc19wZW5kaW5nX2Jpb3MgewogCXN0cnVjdCBiaW8gKmhlYWQ7CkBAIC0xMzYsNiArMTM5LDMwIEBACiAJc3RydWN0IGJ0cmZzX2Jpb19zdHJpcGUgc3RyaXBlc1tdOwogfTsKIAorc3RydWN0IGJ0cmZzX2RldmljZV9pbmZvIHsKKwlzdHJ1Y3QgYnRyZnNfZGV2aWNlICpkZXY7CisJdTY0IGRldl9vZmZzZXQ7CisJdTY0IG1heF9hdmFpbDsKK307CisKKy8qIFVzZWQgdG8gc29ydCB0aGUgZGV2aWNlcyBieSBtYXhfYXZhaWwoZGVzY2VuZGluZyBzb3J0KSAqLworaW50IGJ0cmZzX2NtcF9kZXZpY2VfZnJlZV9ieXRlcyhjb25zdCB2b2lkICpkZXZfaW5mbzEsIGNvbnN0IHZvaWQgKmRldl9pbmZvMik7CisKKy8qCisgKiBzb3J0IHRoZSBkZXZpY2VzIGJ5IG1heF9hdmFpbCwgaW4gd2hpY2ggbWF4IGZyZWUgZXh0ZW50IHNpemUgb2YgZWFjaCBkZXZpY2UKKyAqIGlzIHN0b3JlZC4oRGVzY2VuZGluZyBTb3J0KQorICovCitzdGF0aWMgaW5saW5lIHZvaWQgYnRyZnNfZGVzY2VuZGluZ19zb3J0X2RldmljZXMoCisJCQkJCXN0cnVjdCBidHJmc19kZXZpY2VfaW5mbyAqZGV2aWNlcywKKwkJCQkJc2l6ZV90IG5yX2RldmljZXMpCit7CisJc29ydChkZXZpY2VzLCBucl9kZXZpY2VzLCBzaXplb2Yoc3RydWN0IGJ0cmZzX2RldmljZV9pbmZvKSwKKwkgICAgIGJ0cmZzX2NtcF9kZXZpY2VfZnJlZV9ieXRlcywgTlVMTCk7Cit9CisKK2ludCBidHJmc19hY2NvdW50X2Rldl9leHRlbnRzX3NpemUoc3RydWN0IGJ0cmZzX2RldmljZSAqZGV2aWNlLCB1NjQgc3RhcnQsCisJCQkJICAgdTY0IGVuZCwgdTY0ICpsZW5ndGgpOworCiAjZGVmaW5lIGJ0cmZzX211bHRpX2Jpb19zaXplKG4pIChzaXplb2Yoc3RydWN0IGJ0cmZzX211bHRpX2JpbykgKyBcCiAJCQkgICAgKHNpemVvZihzdHJ1Y3QgYnRyZnNfYmlvX3N0cmlwZSkgKiAobikpKQogCmRpZmYgLS1naXQgYS9mcy9idHJmcy94YXR0ci5jIGIvZnMvYnRyZnMveGF0dHIuYwppbmRleCA2OThmZGQyLi5hNTc3NjUzIDEwMDY0NAotLS0gYS9mcy9idHJmcy94YXR0ci5jCisrKyBiL2ZzL2J0cmZzL3hhdHRyLmMKQEAgLTMxNiw2ICszMTYsMTUgQEAKIGludCBidHJmc19zZXR4YXR0cihzdHJ1Y3QgZGVudHJ5ICpkZW50cnksIGNvbnN0IGNoYXIgKm5hbWUsIGNvbnN0IHZvaWQgKnZhbHVlLAogCQkgICBzaXplX3Qgc2l6ZSwgaW50IGZsYWdzKQogeworCXN0cnVjdCBidHJmc19yb290ICpyb290ID0gQlRSRlNfSShkZW50cnktPmRfaW5vZGUpLT5yb290OworCisJLyoKKwkgKiBUaGUgcGVybWlzc2lvbiBvbiBzZWN1cml0eS4qIGFuZCBzeXN0ZW0uKiBpcyBub3QgY2hlY2tlZAorCSAqIGluIHBlcm1pc3Npb24oKS4KKwkgKi8KKwlpZiAoYnRyZnNfcm9vdF9yZWFkb25seShyb290KSkKKwkJcmV0dXJuIC1FUk9GUzsKKwogCS8qCiAJICogSWYgdGhpcyBpcyBhIHJlcXVlc3QgZm9yIGEgc3ludGhldGljIGF0dHJpYnV0ZSBpbiB0aGUgc3lzdGVtLioKIAkgKiBuYW1lc3BhY2UgdXNlIHRoZSBnZW5lcmljIGluZnJhc3RydWN0dXJlIHRvIHJlc29sdmUgYSBoYW5kbGVyCkBAIC0zMzYsNiArMzQ1LDE1IEBACiAKIGludCBidHJmc19yZW1vdmV4YXR0cihzdHJ1Y3QgZGVudHJ5ICpkZW50cnksIGNvbnN0IGNoYXIgKm5hbWUpCiB7CisJc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QgPSBCVFJGU19JKGRlbnRyeS0+ZF9pbm9kZSktPnJvb3Q7CisKKwkvKgorCSAqIFRoZSBwZXJtaXNzaW9uIG9uIHNlY3VyaXR5LiogYW5kIHN5c3RlbS4qIGlzIG5vdCBjaGVja2VkCisJICogaW4gcGVybWlzc2lvbigpLgorCSAqLworCWlmIChidHJmc19yb290X3JlYWRvbmx5KHJvb3QpKQorCQlyZXR1cm4gLUVST0ZTOworCiAJLyoKIAkgKiBJZiB0aGlzIGlzIGEgcmVxdWVzdCBmb3IgYSBzeW50aGV0aWMgYXR0cmlidXRlIGluIHRoZSBzeXN0ZW0uKgogCSAqIG5hbWVzcGFjZSB1c2UgdGhlIGdlbmVyaWMgaW5mcmFzdHJ1Y3R1cmUgdG8gcmVzb2x2ZSBhIGhhbmRsZXIKZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL3psaWIuYyBiL2ZzL2J0cmZzL3psaWIuYwppbmRleCBiOWNkNTQ0Li5mNWVjMmQ0IDEwMDY0NAotLS0gYS9mcy9idHJmcy96bGliLmMKKysrIGIvZnMvYnRyZnMvemxpYi5jCkBAIC0zMiwxNSArMzIsNiBAQAogI2luY2x1ZGUgPGxpbnV4L2Jpby5oPgogI2luY2x1ZGUgImNvbXByZXNzaW9uLmgiCiAKLS8qIFBsYW46IGNhbGwgZGVmbGF0ZSgpIHdpdGggYXZhaWxfaW4gPT0gKnNvdXJjZWxlbiwKLQlhdmFpbF9vdXQgPSAqZHN0bGVuIC0gMTIgYW5kIGZsdXNoID09IFpfRklOSVNILgotCUlmIGl0IGRvZXNuJ3QgbWFuYWdlIHRvIGZpbmlzaCwJY2FsbCBpdCBhZ2FpbiB3aXRoCi0JYXZhaWxfaW4gPT0gMCBhbmQgYXZhaWxfb3V0IHNldCB0byB0aGUgcmVtYWluaW5nIDEyCi0JYnl0ZXMgZm9yIGl0IHRvIGNsZWFuIHVwLgotICAgUTogSXMgMTIgYnl0ZXMgc3VmZmljaWVudD8KLSovCi0jZGVmaW5lIFNUUkVBTV9FTkRfU1BBQ0UgMTIKLQogc3RydWN0IHdvcmtzcGFjZSB7CiAJel9zdHJlYW0gaW5mX3N0cm07CiAJel9zdHJlYW0gZGVmX3N0cm07CkBAIC00OCwxNTIgKzM5LDUxIEBACiAJc3RydWN0IGxpc3RfaGVhZCBsaXN0OwogfTsKIAotc3RhdGljIExJU1RfSEVBRChpZGxlX3dvcmtzcGFjZSk7Ci1zdGF0aWMgREVGSU5FX1NQSU5MT0NLKHdvcmtzcGFjZV9sb2NrKTsKLXN0YXRpYyB1bnNpZ25lZCBsb25nIG51bV93b3Jrc3BhY2U7Ci1zdGF0aWMgYXRvbWljX3QgYWxsb2Nfd29ya3NwYWNlID0gQVRPTUlDX0lOSVQoMCk7Ci1zdGF0aWMgREVDTEFSRV9XQUlUX1FVRVVFX0hFQUQod29ya3NwYWNlX3dhaXQpOwotCi0vKgotICogdGhpcyBmaW5kcyBhbiBhdmFpbGFibGUgemxpYiB3b3Jrc3BhY2Ugb3IgYWxsb2NhdGVzIGEgbmV3IG9uZQotICogTlVMTCBvciBhbiBFUlJfUFRSIGlzIHJldHVybmVkIGlmIHRoaW5ncyBnbyBiYWQuCi0gKi8KLXN0YXRpYyBzdHJ1Y3Qgd29ya3NwYWNlICpmaW5kX3psaWJfd29ya3NwYWNlKHZvaWQpCitzdGF0aWMgdm9pZCB6bGliX2ZyZWVfd29ya3NwYWNlKHN0cnVjdCBsaXN0X2hlYWQgKndzKQogewotCXN0cnVjdCB3b3Jrc3BhY2UgKndvcmtzcGFjZTsKLQlpbnQgcmV0OwotCWludCBjcHVzID0gbnVtX29ubGluZV9jcHVzKCk7CisJc3RydWN0IHdvcmtzcGFjZSAqd29ya3NwYWNlID0gbGlzdF9lbnRyeSh3cywgc3RydWN0IHdvcmtzcGFjZSwgbGlzdCk7CiAKLWFnYWluOgotCXNwaW5fbG9jaygmd29ya3NwYWNlX2xvY2spOwotCWlmICghbGlzdF9lbXB0eSgmaWRsZV93b3Jrc3BhY2UpKSB7Ci0JCXdvcmtzcGFjZSA9IGxpc3RfZW50cnkoaWRsZV93b3Jrc3BhY2UubmV4dCwgc3RydWN0IHdvcmtzcGFjZSwKLQkJCQkgICAgICAgbGlzdCk7Ci0JCWxpc3RfZGVsKCZ3b3Jrc3BhY2UtPmxpc3QpOwotCQludW1fd29ya3NwYWNlLS07Ci0JCXNwaW5fdW5sb2NrKCZ3b3Jrc3BhY2VfbG9jayk7Ci0JCXJldHVybiB3b3Jrc3BhY2U7Ci0KLQl9Ci0Jc3Bpbl91bmxvY2soJndvcmtzcGFjZV9sb2NrKTsKLQlpZiAoYXRvbWljX3JlYWQoJmFsbG9jX3dvcmtzcGFjZSkgPiBjcHVzKSB7Ci0JCURFRklORV9XQUlUKHdhaXQpOwotCQlwcmVwYXJlX3RvX3dhaXQoJndvcmtzcGFjZV93YWl0LCAmd2FpdCwgVEFTS19VTklOVEVSUlVQVElCTEUpOwotCQlpZiAoYXRvbWljX3JlYWQoJmFsbG9jX3dvcmtzcGFjZSkgPiBjcHVzKQotCQkJc2NoZWR1bGUoKTsKLQkJZmluaXNoX3dhaXQoJndvcmtzcGFjZV93YWl0LCAmd2FpdCk7Ci0JCWdvdG8gYWdhaW47Ci0JfQotCWF0b21pY19pbmMoJmFsbG9jX3dvcmtzcGFjZSk7Ci0Jd29ya3NwYWNlID0ga3phbGxvYyhzaXplb2YoKndvcmtzcGFjZSksIEdGUF9OT0ZTKTsKLQlpZiAoIXdvcmtzcGFjZSkgewotCQlyZXQgPSAtRU5PTUVNOwotCQlnb3RvIGZhaWw7Ci0JfQotCi0Jd29ya3NwYWNlLT5kZWZfc3RybS53b3Jrc3BhY2UgPSB2bWFsbG9jKHpsaWJfZGVmbGF0ZV93b3Jrc3BhY2VzaXplKCkpOwotCWlmICghd29ya3NwYWNlLT5kZWZfc3RybS53b3Jrc3BhY2UpIHsKLQkJcmV0ID0gLUVOT01FTTsKLQkJZ290byBmYWlsOwotCX0KLQl3b3Jrc3BhY2UtPmluZl9zdHJtLndvcmtzcGFjZSA9IHZtYWxsb2MoemxpYl9pbmZsYXRlX3dvcmtzcGFjZXNpemUoKSk7Ci0JaWYgKCF3b3Jrc3BhY2UtPmluZl9zdHJtLndvcmtzcGFjZSkgewotCQlyZXQgPSAtRU5PTUVNOwotCQlnb3RvIGZhaWxfaW5mbGF0ZTsKLQl9Ci0Jd29ya3NwYWNlLT5idWYgPSBrbWFsbG9jKFBBR0VfQ0FDSEVfU0laRSwgR0ZQX05PRlMpOwotCWlmICghd29ya3NwYWNlLT5idWYpIHsKLQkJcmV0ID0gLUVOT01FTTsKLQkJZ290byBmYWlsX2ttYWxsb2M7Ci0JfQotCXJldHVybiB3b3Jrc3BhY2U7Ci0KLWZhaWxfa21hbGxvYzoKLQl2ZnJlZSh3b3Jrc3BhY2UtPmluZl9zdHJtLndvcmtzcGFjZSk7Ci1mYWlsX2luZmxhdGU6Ci0JdmZyZWUod29ya3NwYWNlLT5kZWZfc3RybS53b3Jrc3BhY2UpOwotZmFpbDoKLQlrZnJlZSh3b3Jrc3BhY2UpOwotCWF0b21pY19kZWMoJmFsbG9jX3dvcmtzcGFjZSk7Ci0Jd2FrZV91cCgmd29ya3NwYWNlX3dhaXQpOwotCXJldHVybiBFUlJfUFRSKHJldCk7Ci19Ci0KLS8qCi0gKiBwdXQgYSB3b3Jrc3BhY2Ugc3RydWN0IGJhY2sgb24gdGhlIGxpc3Qgb3IgZnJlZSBpdCBpZiB3ZSBoYXZlIGVub3VnaAotICogaWRsZSBvbmVzIHNpdHRpbmcgYXJvdW5kCi0gKi8KLXN0YXRpYyBpbnQgZnJlZV93b3Jrc3BhY2Uoc3RydWN0IHdvcmtzcGFjZSAqd29ya3NwYWNlKQotewotCXNwaW5fbG9jaygmd29ya3NwYWNlX2xvY2spOwotCWlmIChudW1fd29ya3NwYWNlIDwgbnVtX29ubGluZV9jcHVzKCkpIHsKLQkJbGlzdF9hZGRfdGFpbCgmd29ya3NwYWNlLT5saXN0LCAmaWRsZV93b3Jrc3BhY2UpOwotCQludW1fd29ya3NwYWNlKys7Ci0JCXNwaW5fdW5sb2NrKCZ3b3Jrc3BhY2VfbG9jayk7Ci0JCWlmICh3YWl0cXVldWVfYWN0aXZlKCZ3b3Jrc3BhY2Vfd2FpdCkpCi0JCQl3YWtlX3VwKCZ3b3Jrc3BhY2Vfd2FpdCk7Ci0JCXJldHVybiAwOwotCX0KLQlzcGluX3VubG9jaygmd29ya3NwYWNlX2xvY2spOwogCXZmcmVlKHdvcmtzcGFjZS0+ZGVmX3N0cm0ud29ya3NwYWNlKTsKIAl2ZnJlZSh3b3Jrc3BhY2UtPmluZl9zdHJtLndvcmtzcGFjZSk7CiAJa2ZyZWUod29ya3NwYWNlLT5idWYpOwogCWtmcmVlKHdvcmtzcGFjZSk7Ci0KLQlhdG9taWNfZGVjKCZhbGxvY193b3Jrc3BhY2UpOwotCWlmICh3YWl0cXVldWVfYWN0aXZlKCZ3b3Jrc3BhY2Vfd2FpdCkpCi0JCXdha2VfdXAoJndvcmtzcGFjZV93YWl0KTsKLQlyZXR1cm4gMDsKIH0KIAotLyoKLSAqIGNsZWFudXAgZnVuY3Rpb24gZm9yIG1vZHVsZSBleGl0Ci0gKi8KLXN0YXRpYyB2b2lkIGZyZWVfd29ya3NwYWNlcyh2b2lkKQorc3RhdGljIHN0cnVjdCBsaXN0X2hlYWQgKnpsaWJfYWxsb2Nfd29ya3NwYWNlKHZvaWQpCiB7CiAJc3RydWN0IHdvcmtzcGFjZSAqd29ya3NwYWNlOwotCXdoaWxlICghbGlzdF9lbXB0eSgmaWRsZV93b3Jrc3BhY2UpKSB7Ci0JCXdvcmtzcGFjZSA9IGxpc3RfZW50cnkoaWRsZV93b3Jrc3BhY2UubmV4dCwgc3RydWN0IHdvcmtzcGFjZSwKLQkJCQkgICAgICAgbGlzdCk7Ci0JCWxpc3RfZGVsKCZ3b3Jrc3BhY2UtPmxpc3QpOwotCQl2ZnJlZSh3b3Jrc3BhY2UtPmRlZl9zdHJtLndvcmtzcGFjZSk7Ci0JCXZmcmVlKHdvcmtzcGFjZS0+aW5mX3N0cm0ud29ya3NwYWNlKTsKLQkJa2ZyZWUod29ya3NwYWNlLT5idWYpOwotCQlrZnJlZSh3b3Jrc3BhY2UpOwotCQlhdG9taWNfZGVjKCZhbGxvY193b3Jrc3BhY2UpOwotCX0KKworCXdvcmtzcGFjZSA9IGt6YWxsb2Moc2l6ZW9mKCp3b3Jrc3BhY2UpLCBHRlBfTk9GUyk7CisJaWYgKCF3b3Jrc3BhY2UpCisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCisJd29ya3NwYWNlLT5kZWZfc3RybS53b3Jrc3BhY2UgPSB2bWFsbG9jKHpsaWJfZGVmbGF0ZV93b3Jrc3BhY2VzaXplKCkpOworCXdvcmtzcGFjZS0+aW5mX3N0cm0ud29ya3NwYWNlID0gdm1hbGxvYyh6bGliX2luZmxhdGVfd29ya3NwYWNlc2l6ZSgpKTsKKwl3b3Jrc3BhY2UtPmJ1ZiA9IGttYWxsb2MoUEFHRV9DQUNIRV9TSVpFLCBHRlBfTk9GUyk7CisJaWYgKCF3b3Jrc3BhY2UtPmRlZl9zdHJtLndvcmtzcGFjZSB8fAorCSAgICAhd29ya3NwYWNlLT5pbmZfc3RybS53b3Jrc3BhY2UgfHwgIXdvcmtzcGFjZS0+YnVmKQorCQlnb3RvIGZhaWw7CisKKwlJTklUX0xJU1RfSEVBRCgmd29ya3NwYWNlLT5saXN0KTsKKworCXJldHVybiAmd29ya3NwYWNlLT5saXN0OworZmFpbDoKKwl6bGliX2ZyZWVfd29ya3NwYWNlKCZ3b3Jrc3BhY2UtPmxpc3QpOworCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwogfQogCi0vKgotICogZ2l2ZW4gYW4gYWRkcmVzcyBzcGFjZSBhbmQgc3RhcnQvbGVuLCBjb21wcmVzcyB0aGUgYnl0ZXMuCi0gKgotICogcGFnZXMgYXJlIGFsbG9jYXRlZCB0byBob2xkIHRoZSBjb21wcmVzc2VkIHJlc3VsdCBhbmQgc3RvcmVkCi0gKiBpbiAncGFnZXMnCi0gKgotICogb3V0X3BhZ2VzIGlzIHVzZWQgdG8gcmV0dXJuIHRoZSBudW1iZXIgb2YgcGFnZXMgYWxsb2NhdGVkLiAgVGhlcmUKLSAqIG1heSBiZSBwYWdlcyBhbGxvY2F0ZWQgZXZlbiBpZiB3ZSByZXR1cm4gYW4gZXJyb3IKLSAqCi0gKiB0b3RhbF9pbiBpcyB1c2VkIHRvIHJldHVybiB0aGUgbnVtYmVyIG9mIGJ5dGVzIGFjdHVhbGx5IHJlYWQuICBJdAotICogbWF5IGJlIHNtYWxsZXIgdGhlbiBsZW4gaWYgd2UgaGFkIHRvIGV4aXQgZWFybHkgYmVjYXVzZSB3ZQotICogcmFuIG91dCBvZiByb29tIGluIHRoZSBwYWdlcyBhcnJheSBvciBiZWNhdXNlIHdlIGNyb3NzIHRoZQotICogbWF4X291dCB0aHJlc2hvbGQuCi0gKgotICogdG90YWxfb3V0IGlzIHVzZWQgdG8gcmV0dXJuIHRoZSB0b3RhbCBudW1iZXIgb2YgY29tcHJlc3NlZCBieXRlcwotICoKLSAqIG1heF9vdXQgdGVsbHMgdXMgdGhlIG1heCBudW1iZXIgb2YgYnl0ZXMgdGhhdCB3ZSdyZSBhbGxvd2VkIHRvCi0gKiBzdHVmZiBpbnRvIHBhZ2VzCi0gKi8KLWludCBidHJmc196bGliX2NvbXByZXNzX3BhZ2VzKHN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nLAotCQkJICAgICAgdTY0IHN0YXJ0LCB1bnNpZ25lZCBsb25nIGxlbiwKLQkJCSAgICAgIHN0cnVjdCBwYWdlICoqcGFnZXMsCi0JCQkgICAgICB1bnNpZ25lZCBsb25nIG5yX2Rlc3RfcGFnZXMsCi0JCQkgICAgICB1bnNpZ25lZCBsb25nICpvdXRfcGFnZXMsCi0JCQkgICAgICB1bnNpZ25lZCBsb25nICp0b3RhbF9pbiwKLQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgKnRvdGFsX291dCwKLQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgbWF4X291dCkKK3N0YXRpYyBpbnQgemxpYl9jb21wcmVzc19wYWdlcyhzdHJ1Y3QgbGlzdF9oZWFkICp3cywKKwkJCSAgICAgICBzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqbWFwcGluZywKKwkJCSAgICAgICB1NjQgc3RhcnQsIHVuc2lnbmVkIGxvbmcgbGVuLAorCQkJICAgICAgIHN0cnVjdCBwYWdlICoqcGFnZXMsCisJCQkgICAgICAgdW5zaWduZWQgbG9uZyBucl9kZXN0X3BhZ2VzLAorCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgKm91dF9wYWdlcywKKwkJCSAgICAgICB1bnNpZ25lZCBsb25nICp0b3RhbF9pbiwKKwkJCSAgICAgICB1bnNpZ25lZCBsb25nICp0b3RhbF9vdXQsCisJCQkgICAgICAgdW5zaWduZWQgbG9uZyBtYXhfb3V0KQogeworCXN0cnVjdCB3b3Jrc3BhY2UgKndvcmtzcGFjZSA9IGxpc3RfZW50cnkod3MsIHN0cnVjdCB3b3Jrc3BhY2UsIGxpc3QpOwogCWludCByZXQ7Ci0Jc3RydWN0IHdvcmtzcGFjZSAqd29ya3NwYWNlOwogCWNoYXIgKmRhdGFfaW47CiAJY2hhciAqY3BhZ2Vfb3V0OwogCWludCBucl9wYWdlcyA9IDA7CkBAIC0yMDUsMTAgKzk1LDYgQEAKIAkqdG90YWxfb3V0ID0gMDsKIAkqdG90YWxfaW4gPSAwOwogCi0Jd29ya3NwYWNlID0gZmluZF96bGliX3dvcmtzcGFjZSgpOwotCWlmIChJU19FUlIod29ya3NwYWNlKSkKLQkJcmV0dXJuIC0xOwotCiAJaWYgKFpfT0sgIT0gemxpYl9kZWZsYXRlSW5pdCgmd29ya3NwYWNlLT5kZWZfc3RybSwgMykpIHsKIAkJcHJpbnRrKEtFUk5fV0FSTklORyAiZGVmbGF0ZUluaXQgZmFpbGVkXG4iKTsKIAkJcmV0ID0gLTE7CkBAIC0yMjIsNiArMTA4LDEwIEBACiAJZGF0YV9pbiA9IGttYXAoaW5fcGFnZSk7CiAKIAlvdXRfcGFnZSA9IGFsbG9jX3BhZ2UoR0ZQX05PRlMgfCBfX0dGUF9ISUdITUVNKTsKKwlpZiAob3V0X3BhZ2UgPT0gTlVMTCkgeworCQlyZXQgPSAtMTsKKwkJZ290byBvdXQ7CisJfQogCWNwYWdlX291dCA9IGttYXAob3V0X3BhZ2UpOwogCXBhZ2VzWzBdID0gb3V0X3BhZ2U7CiAJbnJfcGFnZXMgPSAxOwpAQCAtMjYwLDYgKzE1MCwxMCBAQAogCQkJCWdvdG8gb3V0OwogCQkJfQogCQkJb3V0X3BhZ2UgPSBhbGxvY19wYWdlKEdGUF9OT0ZTIHwgX19HRlBfSElHSE1FTSk7CisJCQlpZiAob3V0X3BhZ2UgPT0gTlVMTCkgeworCQkJCXJldCA9IC0xOworCQkJCWdvdG8gb3V0OworCQkJfQogCQkJY3BhZ2Vfb3V0ID0ga21hcChvdXRfcGFnZSk7CiAJCQlwYWdlc1tucl9wYWdlc10gPSBvdXRfcGFnZTsKIAkJCW5yX3BhZ2VzKys7CkBAIC0zMTQsNTUgKzIwOCwyNiBAQAogCQlrdW5tYXAoaW5fcGFnZSk7CiAJCXBhZ2VfY2FjaGVfcmVsZWFzZShpbl9wYWdlKTsKIAl9Ci0JZnJlZV93b3Jrc3BhY2Uod29ya3NwYWNlKTsKIAlyZXR1cm4gcmV0OwogfQogCi0vKgotICogcGFnZXNfaW4gaXMgYW4gYXJyYXkgb2YgcGFnZXMgd2l0aCBjb21wcmVzc2VkIGRhdGEuCi0gKgotICogZGlza19zdGFydCBpcyB0aGUgc3RhcnRpbmcgbG9naWNhbCBvZmZzZXQgb2YgdGhpcyBhcnJheSBpbiB0aGUgZmlsZQotICoKLSAqIGJ2ZWMgaXMgYSBiaW9fdmVjIG9mIHBhZ2VzIGZyb20gdGhlIGZpbGUgdGhhdCB3ZSB3YW50IHRvIGRlY29tcHJlc3MgaW50bwotICoKLSAqIHZjbnQgaXMgdGhlIGNvdW50IG9mIHBhZ2VzIGluIHRoZSBiaW92ZWMKLSAqCi0gKiBzcmNsZW4gaXMgdGhlIG51bWJlciBvZiBieXRlcyBpbiBwYWdlc19pbgotICoKLSAqIFRoZSBiYXNpYyBpZGVhIGlzIHRoYXQgd2UgaGF2ZSBhIGJpbyB0aGF0IHdhcyBjcmVhdGVkIGJ5IHJlYWRwYWdlcy4KLSAqIFRoZSBwYWdlcyBpbiB0aGUgYmlvIGFyZSBmb3IgdGhlIHVuY29tcHJlc3NlZCBkYXRhLCBhbmQgdGhleSBtYXkgbm90Ci0gKiBiZSBjb250aWd1b3VzLiAgVGhleSBhbGwgY29ycmVzcG9uZCB0byB0aGUgcmFuZ2Ugb2YgYnl0ZXMgY292ZXJlZCBieQotICogdGhlIGNvbXByZXNzZWQgZXh0ZW50LgotICovCi1pbnQgYnRyZnNfemxpYl9kZWNvbXByZXNzX2Jpb3ZlYyhzdHJ1Y3QgcGFnZSAqKnBhZ2VzX2luLAotCQkJICAgICAgdTY0IGRpc2tfc3RhcnQsCi0JCQkgICAgICBzdHJ1Y3QgYmlvX3ZlYyAqYnZlYywKLQkJCSAgICAgIGludCB2Y250LAotCQkJICAgICAgc2l6ZV90IHNyY2xlbikKK3N0YXRpYyBpbnQgemxpYl9kZWNvbXByZXNzX2Jpb3ZlYyhzdHJ1Y3QgbGlzdF9oZWFkICp3cywgc3RydWN0IHBhZ2UgKipwYWdlc19pbiwKKwkJCQkgIHU2NCBkaXNrX3N0YXJ0LAorCQkJCSAgc3RydWN0IGJpb192ZWMgKmJ2ZWMsCisJCQkJICBpbnQgdmNudCwKKwkJCQkgIHNpemVfdCBzcmNsZW4pCiB7Ci0JaW50IHJldCA9IDA7CisJc3RydWN0IHdvcmtzcGFjZSAqd29ya3NwYWNlID0gbGlzdF9lbnRyeSh3cywgc3RydWN0IHdvcmtzcGFjZSwgbGlzdCk7CisJaW50IHJldCA9IDAsIHJldDI7CiAJaW50IHdiaXRzID0gTUFYX1dCSVRTOwotCXN0cnVjdCB3b3Jrc3BhY2UgKndvcmtzcGFjZTsKIAljaGFyICpkYXRhX2luOwogCXNpemVfdCB0b3RhbF9vdXQgPSAwOwotCXVuc2lnbmVkIGxvbmcgcGFnZV9ieXRlc19sZWZ0OwogCXVuc2lnbmVkIGxvbmcgcGFnZV9pbl9pbmRleCA9IDA7CiAJdW5zaWduZWQgbG9uZyBwYWdlX291dF9pbmRleCA9IDA7Ci0Jc3RydWN0IHBhZ2UgKnBhZ2Vfb3V0OwogCXVuc2lnbmVkIGxvbmcgdG90YWxfcGFnZXNfaW4gPSAoc3JjbGVuICsgUEFHRV9DQUNIRV9TSVpFIC0gMSkgLwogCQkJCQlQQUdFX0NBQ0hFX1NJWkU7CiAJdW5zaWduZWQgbG9uZyBidWZfc3RhcnQ7Ci0JdW5zaWduZWQgbG9uZyBidWZfb2Zmc2V0OwotCXVuc2lnbmVkIGxvbmcgYnl0ZXM7Ci0JdW5zaWduZWQgbG9uZyB3b3JraW5nX2J5dGVzOwogCXVuc2lnbmVkIGxvbmcgcGdfb2Zmc2V0OwotCXVuc2lnbmVkIGxvbmcgc3RhcnRfYnl0ZTsKLQl1bnNpZ25lZCBsb25nIGN1cnJlbnRfYnVmX3N0YXJ0OwotCWNoYXIgKmthZGRyOwotCi0Jd29ya3NwYWNlID0gZmluZF96bGliX3dvcmtzcGFjZSgpOwotCWlmIChJU19FUlIod29ya3NwYWNlKSkKLQkJcmV0dXJuIC1FTk9NRU07CiAKIAlkYXRhX2luID0ga21hcChwYWdlc19pbltwYWdlX2luX2luZGV4XSk7CiAJd29ya3NwYWNlLT5pbmZfc3RybS5uZXh0X2luID0gZGF0YV9pbjsKQEAgLTM3Miw4ICsyMzcsNiBAQAogCXdvcmtzcGFjZS0+aW5mX3N0cm0udG90YWxfb3V0ID0gMDsKIAl3b3Jrc3BhY2UtPmluZl9zdHJtLm5leHRfb3V0ID0gd29ya3NwYWNlLT5idWY7CiAJd29ya3NwYWNlLT5pbmZfc3RybS5hdmFpbF9vdXQgPSBQQUdFX0NBQ0hFX1NJWkU7Ci0JcGFnZV9vdXQgPSBidmVjW3BhZ2Vfb3V0X2luZGV4XS5idl9wYWdlOwotCXBhZ2VfYnl0ZXNfbGVmdCA9IFBBR0VfQ0FDSEVfU0laRTsKIAlwZ19vZmZzZXQgPSAwOwogCiAJLyogSWYgaXQncyBkZWZsYXRlLCBhbmQgaXQncyBnb3Qgbm8gcHJlc2V0IGRpY3Rpb25hcnksIHRoZW4KQEAgLTM4OSwxMDcgKzI1MiwyOSBAQAogCiAJaWYgKFpfT0sgIT0gemxpYl9pbmZsYXRlSW5pdDIoJndvcmtzcGFjZS0+aW5mX3N0cm0sIHdiaXRzKSkgewogCQlwcmludGsoS0VSTl9XQVJOSU5HICJpbmZsYXRlSW5pdCBmYWlsZWRcbiIpOwotCQlyZXQgPSAtMTsKLQkJZ290byBvdXQ7CisJCXJldHVybiAtMTsKIAl9CiAJd2hpbGUgKHdvcmtzcGFjZS0+aW5mX3N0cm0udG90YWxfaW4gPCBzcmNsZW4pIHsKIAkJcmV0ID0gemxpYl9pbmZsYXRlKCZ3b3Jrc3BhY2UtPmluZl9zdHJtLCBaX05PX0ZMVVNIKTsKIAkJaWYgKHJldCAhPSBaX09LICYmIHJldCAhPSBaX1NUUkVBTV9FTkQpCiAJCQlicmVhazsKLQkJLyoKLQkJICogYnVmIHN0YXJ0IGlzIHRoZSBieXRlIG9mZnNldCB3ZSdyZSBvZiB0aGUgc3RhcnQgb2YKLQkJICogb3VyIHdvcmtzcGFjZSBidWZmZXIKLQkJICovCi0JCWJ1Zl9zdGFydCA9IHRvdGFsX291dDsKIAotCQkvKiB0b3RhbF9vdXQgaXMgdGhlIGxhc3QgYnl0ZSBvZiB0aGUgd29ya3NwYWNlIGJ1ZmZlciAqLworCQlidWZfc3RhcnQgPSB0b3RhbF9vdXQ7CiAJCXRvdGFsX291dCA9IHdvcmtzcGFjZS0+aW5mX3N0cm0udG90YWxfb3V0OwogCi0JCXdvcmtpbmdfYnl0ZXMgPSB0b3RhbF9vdXQgLSBidWZfc3RhcnQ7Ci0KLQkJLyoKLQkJICogc3RhcnQgYnl0ZSBpcyB0aGUgZmlyc3QgYnl0ZSBvZiB0aGUgcGFnZSB3ZSdyZSBjdXJyZW50bHkKLQkJICogY29weWluZyBpbnRvIHJlbGF0aXZlIHRvIHRoZSBzdGFydCBvZiB0aGUgY29tcHJlc3NlZCBkYXRhLgotCQkgKi8KLQkJc3RhcnRfYnl0ZSA9IHBhZ2Vfb2Zmc2V0KHBhZ2Vfb3V0KSAtIGRpc2tfc3RhcnQ7Ci0KLQkJaWYgKHdvcmtpbmdfYnl0ZXMgPT0gMCkgewotCQkJLyogd2UgZGlkbid0IG1ha2UgcHJvZ3Jlc3MgaW4gdGhpcyBpbmZsYXRlCi0JCQkgKiBjYWxsLCB3ZSdyZSBkb25lCi0JCQkgKi8KLQkJCWlmIChyZXQgIT0gWl9TVFJFQU1fRU5EKQotCQkJCXJldCA9IC0xOworCQkvKiB3ZSBkaWRuJ3QgbWFrZSBwcm9ncmVzcyBpbiB0aGlzIGluZmxhdGUgY2FsbCwgd2UncmUgZG9uZSAqLworCQlpZiAoYnVmX3N0YXJ0ID09IHRvdGFsX291dCkKIAkJCWJyZWFrOworCisJCXJldDIgPSBidHJmc19kZWNvbXByZXNzX2J1ZjJwYWdlKHdvcmtzcGFjZS0+YnVmLCBidWZfc3RhcnQsCisJCQkJCQkgdG90YWxfb3V0LCBkaXNrX3N0YXJ0LAorCQkJCQkJIGJ2ZWMsIHZjbnQsCisJCQkJCQkgJnBhZ2Vfb3V0X2luZGV4LCAmcGdfb2Zmc2V0KTsKKwkJaWYgKHJldDIgPT0gMCkgeworCQkJcmV0ID0gMDsKKwkJCWdvdG8gZG9uZTsKIAkJfQogCi0JCS8qIHdlIGhhdmVuJ3QgeWV0IGhpdCBkYXRhIGNvcnJlc3BvbmRpbmcgdG8gdGhpcyBwYWdlICovCi0JCWlmICh0b3RhbF9vdXQgPD0gc3RhcnRfYnl0ZSkKLQkJCWdvdG8gbmV4dDsKLQotCQkvKgotCQkgKiB0aGUgc3RhcnQgb2YgdGhlIGRhdGEgd2UgY2FyZSBhYm91dCBpcyBvZmZzZXQgaW50bwotCQkgKiB0aGUgbWlkZGxlIG9mIG91ciB3b3JraW5nIGJ1ZmZlcgotCQkgKi8KLQkJaWYgKHRvdGFsX291dCA+IHN0YXJ0X2J5dGUgJiYgYnVmX3N0YXJ0IDwgc3RhcnRfYnl0ZSkgewotCQkJYnVmX29mZnNldCA9IHN0YXJ0X2J5dGUgLSBidWZfc3RhcnQ7Ci0JCQl3b3JraW5nX2J5dGVzIC09IGJ1Zl9vZmZzZXQ7Ci0JCX0gZWxzZSB7Ci0JCQlidWZfb2Zmc2V0ID0gMDsKLQkJfQotCQljdXJyZW50X2J1Zl9zdGFydCA9IGJ1Zl9zdGFydDsKLQotCQkvKiBjb3B5IGJ5dGVzIGZyb20gdGhlIHdvcmtpbmcgYnVmZmVyIGludG8gdGhlIHBhZ2VzICovCi0JCXdoaWxlICh3b3JraW5nX2J5dGVzID4gMCkgewotCQkJYnl0ZXMgPSBtaW4oUEFHRV9DQUNIRV9TSVpFIC0gcGdfb2Zmc2V0LAotCQkJCSAgICBQQUdFX0NBQ0hFX1NJWkUgLSBidWZfb2Zmc2V0KTsKLQkJCWJ5dGVzID0gbWluKGJ5dGVzLCB3b3JraW5nX2J5dGVzKTsKLQkJCWthZGRyID0ga21hcF9hdG9taWMocGFnZV9vdXQsIEtNX1VTRVIwKTsKLQkJCW1lbWNweShrYWRkciArIHBnX29mZnNldCwgd29ya3NwYWNlLT5idWYgKyBidWZfb2Zmc2V0LAotCQkJICAgICAgIGJ5dGVzKTsKLQkJCWt1bm1hcF9hdG9taWMoa2FkZHIsIEtNX1VTRVIwKTsKLQkJCWZsdXNoX2RjYWNoZV9wYWdlKHBhZ2Vfb3V0KTsKLQotCQkJcGdfb2Zmc2V0ICs9IGJ5dGVzOwotCQkJcGFnZV9ieXRlc19sZWZ0IC09IGJ5dGVzOwotCQkJYnVmX29mZnNldCArPSBieXRlczsKLQkJCXdvcmtpbmdfYnl0ZXMgLT0gYnl0ZXM7Ci0JCQljdXJyZW50X2J1Zl9zdGFydCArPSBieXRlczsKLQotCQkJLyogY2hlY2sgaWYgd2UgbmVlZCB0byBwaWNrIGFub3RoZXIgcGFnZSAqLwotCQkJaWYgKHBhZ2VfYnl0ZXNfbGVmdCA9PSAwKSB7Ci0JCQkJcGFnZV9vdXRfaW5kZXgrKzsKLQkJCQlpZiAocGFnZV9vdXRfaW5kZXggPj0gdmNudCkgewotCQkJCQlyZXQgPSAwOwotCQkJCQlnb3RvIGRvbmU7Ci0JCQkJfQotCi0JCQkJcGFnZV9vdXQgPSBidmVjW3BhZ2Vfb3V0X2luZGV4XS5idl9wYWdlOwotCQkJCXBnX29mZnNldCA9IDA7Ci0JCQkJcGFnZV9ieXRlc19sZWZ0ID0gUEFHRV9DQUNIRV9TSVpFOwotCQkJCXN0YXJ0X2J5dGUgPSBwYWdlX29mZnNldChwYWdlX291dCkgLSBkaXNrX3N0YXJ0OwotCi0JCQkJLyoKLQkJCQkgKiBtYWtlIHN1cmUgb3VyIG5ldyBwYWdlIGlzIGNvdmVyZWQgYnkgdGhpcwotCQkJCSAqIHdvcmtpbmcgYnVmZmVyCi0JCQkJICovCi0JCQkJaWYgKHRvdGFsX291dCA8PSBzdGFydF9ieXRlKQotCQkJCQlnb3RvIG5leHQ7Ci0KLQkJCQkvKiB0aGUgbmV4dCBwYWdlIGluIHRoZSBiaW92ZWMgbWlnaHQgbm90Ci0JCQkJICogYmUgYWRqYWNlbnQgdG8gdGhlIGxhc3QgcGFnZSwgYnV0IGl0Ci0JCQkJICogbWlnaHQgc3RpbGwgYmUgZm91bmQgaW5zaWRlIHRoaXMgd29ya2luZwotCQkJCSAqIGJ1ZmZlci4gIGJ1bXAgb3VyIG9mZnNldCBwb2ludGVyCi0JCQkJICovCi0JCQkJaWYgKHRvdGFsX291dCA+IHN0YXJ0X2J5dGUgJiYKLQkJCQkgICAgY3VycmVudF9idWZfc3RhcnQgPCBzdGFydF9ieXRlKSB7Ci0JCQkJCWJ1Zl9vZmZzZXQgPSBzdGFydF9ieXRlIC0gYnVmX3N0YXJ0OwotCQkJCQl3b3JraW5nX2J5dGVzID0gdG90YWxfb3V0IC0gc3RhcnRfYnl0ZTsKLQkJCQkJY3VycmVudF9idWZfc3RhcnQgPSBidWZfc3RhcnQgKwotCQkJCQkJYnVmX29mZnNldDsKLQkJCQl9Ci0JCQl9Ci0JCX0KLW5leHQ6CiAJCXdvcmtzcGFjZS0+aW5mX3N0cm0ubmV4dF9vdXQgPSB3b3Jrc3BhY2UtPmJ1ZjsKIAkJd29ya3NwYWNlLT5pbmZfc3RybS5hdmFpbF9vdXQgPSBQQUdFX0NBQ0hFX1NJWkU7CiAKQEAgLTUxNiwzNSArMzAxLDIxIEBACiAJemxpYl9pbmZsYXRlRW5kKCZ3b3Jrc3BhY2UtPmluZl9zdHJtKTsKIAlpZiAoZGF0YV9pbikKIAkJa3VubWFwKHBhZ2VzX2luW3BhZ2VfaW5faW5kZXhdKTsKLW91dDoKLQlmcmVlX3dvcmtzcGFjZSh3b3Jrc3BhY2UpOwogCXJldHVybiByZXQ7CiB9CiAKLS8qCi0gKiBhIGxlc3MgY29tcGxleCBkZWNvbXByZXNzaW9uIHJvdXRpbmUuICBPdXIgY29tcHJlc3NlZCBkYXRhIGZpdHMgaW4gYQotICogc2luZ2xlIHBhZ2UsIGFuZCB3ZSB3YW50IHRvIHJlYWQgYSBzaW5nbGUgcGFnZSBvdXQgb2YgaXQuCi0gKiBzdGFydF9ieXRlIHRlbGxzIHVzIHRoZSBvZmZzZXQgaW50byB0aGUgY29tcHJlc3NlZCBkYXRhIHdlJ3JlIGludGVyZXN0ZWQgaW4KLSAqLwotaW50IGJ0cmZzX3psaWJfZGVjb21wcmVzcyh1bnNpZ25lZCBjaGFyICpkYXRhX2luLAotCQkJICBzdHJ1Y3QgcGFnZSAqZGVzdF9wYWdlLAotCQkJICB1bnNpZ25lZCBsb25nIHN0YXJ0X2J5dGUsCi0JCQkgIHNpemVfdCBzcmNsZW4sIHNpemVfdCBkZXN0bGVuKQorc3RhdGljIGludCB6bGliX2RlY29tcHJlc3Moc3RydWN0IGxpc3RfaGVhZCAqd3MsIHVuc2lnbmVkIGNoYXIgKmRhdGFfaW4sCisJCQkgICBzdHJ1Y3QgcGFnZSAqZGVzdF9wYWdlLAorCQkJICAgdW5zaWduZWQgbG9uZyBzdGFydF9ieXRlLAorCQkJICAgc2l6ZV90IHNyY2xlbiwgc2l6ZV90IGRlc3RsZW4pCiB7CisJc3RydWN0IHdvcmtzcGFjZSAqd29ya3NwYWNlID0gbGlzdF9lbnRyeSh3cywgc3RydWN0IHdvcmtzcGFjZSwgbGlzdCk7CiAJaW50IHJldCA9IDA7CiAJaW50IHdiaXRzID0gTUFYX1dCSVRTOwotCXN0cnVjdCB3b3Jrc3BhY2UgKndvcmtzcGFjZTsKIAl1bnNpZ25lZCBsb25nIGJ5dGVzX2xlZnQgPSBkZXN0bGVuOwogCXVuc2lnbmVkIGxvbmcgdG90YWxfb3V0ID0gMDsKIAljaGFyICprYWRkcjsKIAotCWlmIChkZXN0bGVuID4gUEFHRV9DQUNIRV9TSVpFKQotCQlyZXR1cm4gLUVOT01FTTsKLQotCXdvcmtzcGFjZSA9IGZpbmRfemxpYl93b3Jrc3BhY2UoKTsKLQlpZiAoSVNfRVJSKHdvcmtzcGFjZSkpCi0JCXJldHVybiAtRU5PTUVNOwotCiAJd29ya3NwYWNlLT5pbmZfc3RybS5uZXh0X2luID0gZGF0YV9pbjsKIAl3b3Jrc3BhY2UtPmluZl9zdHJtLmF2YWlsX2luID0gc3JjbGVuOwogCXdvcmtzcGFjZS0+aW5mX3N0cm0udG90YWxfaW4gPSAwOwpAQCAtNTY1LDggKzMzNiw3IEBACiAKIAlpZiAoWl9PSyAhPSB6bGliX2luZmxhdGVJbml0Migmd29ya3NwYWNlLT5pbmZfc3RybSwgd2JpdHMpKSB7CiAJCXByaW50ayhLRVJOX1dBUk5JTkcgImluZmxhdGVJbml0IGZhaWxlZFxuIik7Ci0JCXJldCA9IC0xOwotCQlnb3RvIG91dDsKKwkJcmV0dXJuIC0xOwogCX0KIAogCXdoaWxlIChieXRlc19sZWZ0ID4gMCkgewpAQCAtNjE2LDEyICszODYsMTMgQEAKIAkJcmV0ID0gMDsKIAogCXpsaWJfaW5mbGF0ZUVuZCgmd29ya3NwYWNlLT5pbmZfc3RybSk7Ci1vdXQ6Ci0JZnJlZV93b3Jrc3BhY2Uod29ya3NwYWNlKTsKIAlyZXR1cm4gcmV0OwogfQogCi12b2lkIGJ0cmZzX3psaWJfZXhpdCh2b2lkKQotewotICAgIGZyZWVfd29ya3NwYWNlcygpOwotfQorc3RydWN0IGJ0cmZzX2NvbXByZXNzX29wIGJ0cmZzX3psaWJfY29tcHJlc3MgPSB7CisJLmFsbG9jX3dvcmtzcGFjZQk9IHpsaWJfYWxsb2Nfd29ya3NwYWNlLAorCS5mcmVlX3dvcmtzcGFjZQkJPSB6bGliX2ZyZWVfd29ya3NwYWNlLAorCS5jb21wcmVzc19wYWdlcwkJPSB6bGliX2NvbXByZXNzX3BhZ2VzLAorCS5kZWNvbXByZXNzX2Jpb3ZlYwk9IHpsaWJfZGVjb21wcmVzc19iaW92ZWMsCisJLmRlY29tcHJlc3MJCT0gemxpYl9kZWNvbXByZXNzLAorfTsKZGlmZiAtLWdpdCBhL2ZzL2NlcGgvY2Fwcy5jIGIvZnMvY2VwaC9jYXBzLmMKaW5kZXggNjBkMjdiYy4uNmI2MWRlZCAxMDA2NDQKLS0tIGEvZnMvY2VwaC9jYXBzLmMKKysrIGIvZnMvY2VwaC9jYXBzLmMKQEAgLTE1NjAsOSArMTU2MCwxMCBAQAogCQkvKiBOT1RFOiBubyBzaWRlLWVmZmVjdHMgYWxsb3dlZCwgdW50aWwgd2UgdGFrZSBzX211dGV4ICovCiAKIAkJcmV2b2tpbmcgPSBjYXAtPmltcGxlbWVudGVkICYgfmNhcC0+aXNzdWVkOwotCQlpZiAocmV2b2tpbmcpCi0JCQlkb3V0KCIgbWRzJWQgcmV2b2tpbmcgJXNcbiIsIGNhcC0+bWRzLAotCQkJICAgICBjZXBoX2NhcF9zdHJpbmcocmV2b2tpbmcpKTsKKwkJZG91dCgiIG1kcyVkIGNhcCAlcCBpc3N1ZWQgJXMgaW1wbGVtZW50ZWQgJXMgcmV2b2tpbmcgJXNcbiIsCisJCSAgICAgY2FwLT5tZHMsIGNhcCwgY2VwaF9jYXBfc3RyaW5nKGNhcC0+aXNzdWVkKSwKKwkJICAgICBjZXBoX2NhcF9zdHJpbmcoY2FwLT5pbXBsZW1lbnRlZCksCisJCSAgICAgY2VwaF9jYXBfc3RyaW5nKHJldm9raW5nKSk7CiAKIAkJaWYgKGNhcCA9PSBjaS0+aV9hdXRoX2NhcCAmJgogCQkgICAgKGNhcC0+aXNzdWVkICYgQ0VQSF9DQVBfRklMRV9XUikpIHsKQEAgLTE2NTgsNiArMTY1OSw4IEBACiAKIAkJaWYgKGNhcCA9PSBjaS0+aV9hdXRoX2NhcCAmJiBjaS0+aV9kaXJ0eV9jYXBzKQogCQkJZmx1c2hpbmcgPSBfX21hcmtfY2Fwc19mbHVzaGluZyhpbm9kZSwgc2Vzc2lvbik7CisJCWVsc2UKKwkJCWZsdXNoaW5nID0gMDsKIAogCQltZHMgPSBjYXAtPm1kczsgIC8qIHJlbWVtYmVyIG1kcywgc28gd2UgZG9uJ3QgcmVwZWF0ICovCiAJCXNlbnQrKzsKQEAgLTE5NDAsNiArMTk0MywzNSBAQAogCX0KIH0KIAorc3RhdGljIHZvaWQga2lja19mbHVzaGluZ19pbm9kZV9jYXBzKHN0cnVjdCBjZXBoX21kc19jbGllbnQgKm1kc2MsCisJCQkJICAgICBzdHJ1Y3QgY2VwaF9tZHNfc2Vzc2lvbiAqc2Vzc2lvbiwKKwkJCQkgICAgIHN0cnVjdCBpbm9kZSAqaW5vZGUpCit7CisJc3RydWN0IGNlcGhfaW5vZGVfaW5mbyAqY2kgPSBjZXBoX2lub2RlKGlub2RlKTsKKwlzdHJ1Y3QgY2VwaF9jYXAgKmNhcDsKKwlpbnQgZGVsYXllZCA9IDA7CisKKwlzcGluX2xvY2soJmlub2RlLT5pX2xvY2spOworCWNhcCA9IGNpLT5pX2F1dGhfY2FwOworCWRvdXQoImtpY2tfZmx1c2hpbmdfaW5vZGVfY2FwcyAlcCBmbHVzaGluZyAlcyBmbHVzaF9zZXEgJWxsZFxuIiwgaW5vZGUsCisJICAgICBjZXBoX2NhcF9zdHJpbmcoY2ktPmlfZmx1c2hpbmdfY2FwcyksIGNpLT5pX2NhcF9mbHVzaF9zZXEpOworCV9fY2VwaF9mbHVzaF9zbmFwcyhjaSwgJnNlc3Npb24sIDEpOworCWlmIChjaS0+aV9mbHVzaGluZ19jYXBzKSB7CisJCWRlbGF5ZWQgPSBfX3NlbmRfY2FwKG1kc2MsIGNhcCwgQ0VQSF9DQVBfT1BfRkxVU0gsCisJCQkJICAgICBfX2NlcGhfY2Fwc191c2VkKGNpKSwKKwkJCQkgICAgIF9fY2VwaF9jYXBzX3dhbnRlZChjaSksCisJCQkJICAgICBjYXAtPmlzc3VlZCB8IGNhcC0+aW1wbGVtZW50ZWQsCisJCQkJICAgICBjaS0+aV9mbHVzaGluZ19jYXBzLCBOVUxMKTsKKwkJaWYgKGRlbGF5ZWQpIHsKKwkJCXNwaW5fbG9jaygmaW5vZGUtPmlfbG9jayk7CisJCQlfX2NhcF9kZWxheV9yZXF1ZXVlKG1kc2MsIGNpKTsKKwkJCXNwaW5fdW5sb2NrKCZpbm9kZS0+aV9sb2NrKTsKKwkJfQorCX0gZWxzZSB7CisJCXNwaW5fdW5sb2NrKCZpbm9kZS0+aV9sb2NrKTsKKwl9Cit9CisKIAogLyoKICAqIFRha2UgcmVmZXJlbmNlcyB0byBjYXBhYmlsaXRpZXMgd2UgaG9sZCwgc28gdGhhdCB3ZSBkb24ndCByZWxlYXNlCkBAIC0yNjg3LDcgKzI3MTksNyBAQAogCWNlcGhfYWRkX2NhcChpbm9kZSwgc2Vzc2lvbiwgY2FwX2lkLCAtMSwKIAkJICAgICBpc3N1ZWQsIHdhbnRlZCwgc2VxLCBtc2VxLCByZWFsbWlubywgQ0VQSF9DQVBfRkxBR19BVVRILAogCQkgICAgIE5VTEwgLyogbm8gY2FwcyBjb250ZXh0ICovKTsKLQl0cnlfZmx1c2hfY2Fwcyhpbm9kZSwgc2Vzc2lvbiwgTlVMTCk7CisJa2lja19mbHVzaGluZ19pbm9kZV9jYXBzKG1kc2MsIHNlc3Npb24sIGlub2RlKTsKIAl1cF9yZWFkKCZtZHNjLT5zbmFwX3J3c2VtKTsKIAogCS8qIG1ha2Ugc3VyZSB3ZSByZS1yZXF1ZXN0IG1heF9zaXplLCBpZiBuZWNlc3NhcnkgKi8KQEAgLTI3ODUsOCArMjgxNyw3IEBACiAJY2FzZSBDRVBIX0NBUF9PUF9JTVBPUlQ6CiAJCWhhbmRsZV9jYXBfaW1wb3J0KG1kc2MsIGlub2RlLCBoLCBzZXNzaW9uLAogCQkJCSAgc25hcHRyYWNlLCBzbmFwdHJhY2VfbGVuKTsKLQkJY2VwaF9jaGVja19jYXBzKGNlcGhfaW5vZGUoaW5vZGUpLCBDSEVDS19DQVBTX05PREVMQVksCi0JCQkJc2Vzc2lvbik7CisJCWNlcGhfY2hlY2tfY2FwcyhjZXBoX2lub2RlKGlub2RlKSwgMCwgc2Vzc2lvbik7CiAJCWdvdG8gZG9uZV91bmxvY2tlZDsKIAl9CiAKZGlmZiAtLWdpdCBhL2ZzL2NlcGgvaW5vZGUuYyBiL2ZzL2NlcGgvaW5vZGUuYwppbmRleCBlODM1ZWZmLi41NjI1NDYzIDEwMDY0NAotLS0gYS9mcy9jZXBoL2lub2RlLmMKKysrIGIvZnMvY2VwaC9pbm9kZS5jCkBAIC03MTAsMTAgKzcxMCw2IEBACiAJCQljaS0+aV9jZXBoX2ZsYWdzIHw9IENFUEhfSV9DT01QTEVURTsKIAkJCWNpLT5pX21heF9vZmZzZXQgPSAyOwogCQl9Ci0KLQkJLyogaXQgbWF5IGJlIGJldHRlciB0byBzZXQgc3Rfc2l6ZSBpbiBnZXRhdHRyIGluc3RlYWQ/ICovCi0JCWlmIChjZXBoX3Rlc3RfbW91bnRfb3B0KGNlcGhfc2JfdG9fY2xpZW50KGlub2RlLT5pX3NiKSwgUkJZVEVTKSkKLQkJCWlub2RlLT5pX3NpemUgPSBjaS0+aV9yYnl0ZXM7CiAJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCXByX2VycigiZmlsbF9pbm9kZSAlbGx4LiVsbHggQkFEIG1vZGUgMCVvXG4iLApAQCAtMTgxOSw3ICsxODE1LDExIEBACiAJCWVsc2UKIAkJCXN0YXQtPmRldiA9IDA7CiAJCWlmIChTX0lTRElSKGlub2RlLT5pX21vZGUpKSB7Ci0JCQlzdGF0LT5zaXplID0gY2ktPmlfcmJ5dGVzOworCQkJaWYgKGNlcGhfdGVzdF9tb3VudF9vcHQoY2VwaF9zYl90b19jbGllbnQoaW5vZGUtPmlfc2IpLAorCQkJCQkJUkJZVEVTKSkKKwkJCQlzdGF0LT5zaXplID0gY2ktPmlfcmJ5dGVzOworCQkJZWxzZQorCQkJCXN0YXQtPnNpemUgPSBjaS0+aV9maWxlcyArIGNpLT5pX3N1YmRpcnM7CiAJCQlzdGF0LT5ibG9ja3MgPSAwOwogCQkJc3RhdC0+Ymxrc2l6ZSA9IDY1NTM2OwogCQl9CmRpZmYgLS1naXQgYS9mcy9jZXBoL21kc19jbGllbnQuYyBiL2ZzL2NlcGgvbWRzX2NsaWVudC5jCmluZGV4IDFlMzBkMTkuLmExZWU4ZmEgMTAwNjQ0Ci0tLSBhL2ZzL2NlcGgvbWRzX2NsaWVudC5jCisrKyBiL2ZzL2NlcGgvbWRzX2NsaWVudC5jCkBAIC02OTMsOSArNjkzLDExIEBACiAJCQkJZG91dCgiY2hvb3NlX21kcyAlcCAlbGx4LiVsbHggIgogCQkJCSAgICAgImZyYWcgJXUgbWRzJWQgKCVkLyVkKVxuIiwKIAkJCQkgICAgIGlub2RlLCBjZXBoX3Zpbm9wKGlub2RlKSwKLQkJCQkgICAgIGZyYWcuZnJhZywgZnJhZy5tZHMsCisJCQkJICAgICBmcmFnLmZyYWcsIG1kcywKIAkJCQkgICAgIChpbnQpciwgZnJhZy5uZGlzdCk7Ci0JCQkJcmV0dXJuIG1kczsKKwkJCQlpZiAoY2VwaF9tZHNtYXBfZ2V0X3N0YXRlKG1kc2MtPm1kc21hcCwgbWRzKSA+PQorCQkJCSAgICBDRVBIX01EU19TVEFURV9BQ1RJVkUpCisJCQkJCXJldHVybiBtZHM7CiAJCQl9CiAKIAkJCS8qIHNpbmNlIHRoaXMgZmlsZS9kaXIgd2Fzbid0IGtub3duIHRvIGJlCkBAIC03MDgsNyArNzEwLDkgQEAKIAkJCQlkb3V0KCJjaG9vc2VfbWRzICVwICVsbHguJWxseCAiCiAJCQkJICAgICAiZnJhZyAldSBtZHMlZCAoYXV0aClcbiIsCiAJCQkJICAgICBpbm9kZSwgY2VwaF92aW5vcChpbm9kZSksIGZyYWcuZnJhZywgbWRzKTsKLQkJCQlyZXR1cm4gbWRzOworCQkJCWlmIChjZXBoX21kc21hcF9nZXRfc3RhdGUobWRzYy0+bWRzbWFwLCBtZHMpID49CisJCQkJICAgIENFUEhfTURTX1NUQVRFX0FDVElWRSkKKwkJCQkJcmV0dXJuIG1kczsKIAkJCX0KIAkJfQogCX0KZGlmZiAtLWdpdCBhL2ZzL2NlcGgvc3VwZXIuYyBiL2ZzL2NlcGgvc3VwZXIuYwppbmRleCBiZjZmMGYzLi45YzUwODU0IDEwMDY0NAotLS0gYS9mcy9jZXBoL3N1cGVyLmMKKysrIGIvZnMvY2VwaC9zdXBlci5jCkBAIC0yOTAsNiArMjkwLDggQEAKIAogICAgICAgICBmc29wdC0+cnNpemUgPSBDRVBIX01PVU5UX1JTSVpFX0RFRkFVTFQ7CiAgICAgICAgIGZzb3B0LT5zbmFwZGlyX25hbWUgPSBrc3RyZHVwKENFUEhfU05BUERJUk5BTUVfREVGQVVMVCwgR0ZQX0tFUk5FTCk7CisJZnNvcHQtPmNhcHNfd2FudGVkX2RlbGF5X21pbiA9IENFUEhfQ0FQU19XQU5URURfREVMQVlfTUlOX0RFRkFVTFQ7CisJZnNvcHQtPmNhcHNfd2FudGVkX2RlbGF5X21heCA9IENFUEhfQ0FQU19XQU5URURfREVMQVlfTUFYX0RFRkFVTFQ7CiAgICAgICAgIGZzb3B0LT5jYXBfcmVsZWFzZV9zYWZldHkgPSBDRVBIX0NBUF9SRUxFQVNFX1NBRkVUWV9ERUZBVUxUOwogICAgICAgICBmc29wdC0+bWF4X3JlYWRkaXIgPSBDRVBIX01BWF9SRUFERElSX0RFRkFVTFQ7CiAgICAgICAgIGZzb3B0LT5tYXhfcmVhZGRpcl9ieXRlcyA9IENFUEhfTUFYX1JFQURESVJfQllURVNfREVGQVVMVDsKZGlmZiAtLWdpdCBhL2ZzL2NlcGgveGF0dHIuYyBiL2ZzL2NlcGgveGF0dHIuYwppbmRleCA2ZTEyYTZiLi44YzllYmE2IDEwMDY0NAotLS0gYS9mcy9jZXBoL3hhdHRyLmMKKysrIGIvZnMvY2VwaC94YXR0ci5jCkBAIC0yMTksNiArMjE5LDcgQEAKIAlzdHJ1Y3QgcmJfbm9kZSAqKnA7CiAJc3RydWN0IHJiX25vZGUgKnBhcmVudCA9IE5VTEw7CiAJc3RydWN0IGNlcGhfaW5vZGVfeGF0dHIgKnhhdHRyID0gTlVMTDsKKwlpbnQgbmFtZV9sZW4gPSBzdHJsZW4obmFtZSk7CiAJaW50IGM7CiAKIAlwID0gJmNpLT5pX3hhdHRycy5pbmRleC5yYl9ub2RlOwpAQCAtMjI2LDYgKzIyNyw4IEBACiAJCXBhcmVudCA9ICpwOwogCQl4YXR0ciA9IHJiX2VudHJ5KHBhcmVudCwgc3RydWN0IGNlcGhfaW5vZGVfeGF0dHIsIG5vZGUpOwogCQljID0gc3RybmNtcChuYW1lLCB4YXR0ci0+bmFtZSwgeGF0dHItPm5hbWVfbGVuKTsKKwkJaWYgKGMgPT0gMCAmJiBuYW1lX2xlbiA+IHhhdHRyLT5uYW1lX2xlbikKKwkJCWMgPSAxOwogCQlpZiAoYyA8IDApCiAJCQlwID0gJigqcCktPnJiX2xlZnQ7CiAJCWVsc2UgaWYgKGMgPiAwKQpkaWZmIC0tZ2l0IGEvZnMvY2lmcy9LY29uZmlnIGIvZnMvY2lmcy9LY29uZmlnCmluZGV4IGVlNDU2NDguLjdjYjBmN2YgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvS2NvbmZpZworKysgYi9mcy9jaWZzL0tjb25maWcKQEAgLTMsNiArMyw3IEBACiAJZGVwZW5kcyBvbiBJTkVUCiAJc2VsZWN0IE5MUwogCXNlbGVjdCBDUllQVE8KKwlzZWxlY3QgQ1JZUFRPX01ENAogCXNlbGVjdCBDUllQVE9fTUQ1CiAJc2VsZWN0IENSWVBUT19ITUFDCiAJc2VsZWN0IENSWVBUT19BUkM0CmRpZmYgLS1naXQgYS9mcy9jaWZzL01ha2VmaWxlIGIvZnMvY2lmcy9NYWtlZmlsZQppbmRleCA0M2IxOWRkLi5kODc1NTg0IDEwMDY0NAotLS0gYS9mcy9jaWZzL01ha2VmaWxlCisrKyBiL2ZzL2NpZnMvTWFrZWZpbGUKQEAgLTUsNyArNSw3IEBACiAKIGNpZnMteSA6PSBjaWZzZnMubyBjaWZzc21iLm8gY2lmc19kZWJ1Zy5vIGNvbm5lY3QubyBkaXIubyBmaWxlLm8gaW5vZGUubyBcCiAJICBsaW5rLm8gbWlzYy5vIG5ldG1pc2MubyBzbWJkZXMubyBzbWJlbmNyeXB0Lm8gdHJhbnNwb3J0Lm8gYXNuMS5vIFwKLQkgIG1kNC5vIG1kNS5vIGNpZnNfdW5pY29kZS5vIG50ZXJyLm8geGF0dHIubyBjaWZzZW5jcnlwdC5vIFwKKwkgIGNpZnNfdW5pY29kZS5vIG50ZXJyLm8geGF0dHIubyBjaWZzZW5jcnlwdC5vIFwKIAkgIHJlYWRkaXIubyBpb2N0bC5vIHNlc3MubyBleHBvcnQubwogCiBjaWZzLSQoQ09ORklHX0NJRlNfQUNMKSArPSBjaWZzYWNsLm8KZGlmZiAtLWdpdCBhL2ZzL2NpZnMvUkVBRE1FIGIvZnMvY2lmcy9SRUFETUUKaW5kZXggNDZhZjk5YS4uZmUxNjgzNSAxMDA2NDQKLS0tIGEvZnMvY2lmcy9SRUFETUUKKysrIGIvZnMvY2lmcy9SRUFETUUKQEAgLTQ1Miw2ICs0NTIsMTEgQEAKIAkJaWYgb3Bsb2NrIChjYWNoaW5nIHRva2VuKSBpcyBncmFudGVkIGFuZCBoZWxkLiBOb3RlIHRoYXQKIAkJZGlyZWN0IGFsbG93cyB3cml0ZSBvcGVyYXRpb25zIGxhcmdlciB0aGFuIHBhZ2Ugc2l6ZQogCQl0byBiZSBzZW50IHRvIHRoZSBzZXJ2ZXIuCisgIHN0cmljdGNhY2hlICAgVXNlIGZvciBzd2l0Y2hpbmcgb24gc3RyaWN0IGNhY2hlIG1vZGUuIEluIHRoaXMgbW9kZSB0aGUKKwkJY2xpZW50IHJlYWQgZnJvbSB0aGUgY2FjaGUgYWxsIHRoZSB0aW1lIGl0IGhhcyBPcGxvY2sgTGV2ZWwgSUksCisJCW90aGVyd2lzZSAtIHJlYWQgZnJvbSB0aGUgc2VydmVyLiBBbGwgd3JpdHRlbiBkYXRhIGFyZSBzdG9yZWQKKwkJaW4gdGhlIGNhY2hlLCBidXQgaWYgdGhlIGNsaWVudCBkb2Vzbid0IGhhdmUgRXhjbHVzaXZlIE9wbG9jaywKKwkJaXQgd3JpdGVzIHRoZSBkYXRhIHRvIHRoZSBzZXJ2ZXIuCiAgIGFjbCAgIAlBbGxvdyBzZXRmYWNsIGFuZCBnZXRmYWNsIHRvIG1hbmFnZSBwb3NpeCBBQ0xzIGlmIHNlcnZlcgogCQlzdXBwb3J0cyB0aGVtLiAgKGRlZmF1bHQpCiAgIG5vYWNsIAlEbyBub3QgYWxsb3cgc2V0ZmFjbCBhbmQgZ2V0ZmFjbCBjYWxscyBvbiB0aGlzIG1vdW50CmRpZmYgLS1naXQgYS9mcy9jaWZzL2NpZnNfZGVidWcuYyBiL2ZzL2NpZnMvY2lmc19kZWJ1Zy5jCmluZGV4IGVkZTk4MzAuLjY1ODI5ZDMgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvY2lmc19kZWJ1Zy5jCisrKyBiL2ZzL2NpZnMvY2lmc19kZWJ1Zy5jCkBAIC03OSwxMSArNzksMTEgQEAKIAlzcGluX2xvY2soJkdsb2JhbE1pZF9Mb2NrKTsKIAlsaXN0X2Zvcl9lYWNoKHRtcCwgJnNlcnZlci0+cGVuZGluZ19taWRfcSkgewogCQltaWRfZW50cnkgPSBsaXN0X2VudHJ5KHRtcCwgc3RydWN0IG1pZF9xX2VudHJ5LCBxaGVhZCk7Ci0JCWNFUlJPUigxLCAiU3RhdGU6ICVkIENtZDogJWQgUGlkOiAlZCBUc2s6ICVwIE1pZCAlZCIsCisJCWNFUlJPUigxLCAiU3RhdGU6ICVkIENtZDogJWQgUGlkOiAlZCBDYmRhdGE6ICVwIE1pZCAlZCIsCiAJCQltaWRfZW50cnktPm1pZFN0YXRlLAogCQkJKGludCltaWRfZW50cnktPmNvbW1hbmQsCiAJCQltaWRfZW50cnktPnBpZCwKLQkJCW1pZF9lbnRyeS0+dHNrLAorCQkJbWlkX2VudHJ5LT5jYWxsYmFja19kYXRhLAogCQkJbWlkX2VudHJ5LT5taWQpOwogI2lmZGVmIENPTkZJR19DSUZTX1NUQVRTMgogCQljRVJST1IoMSwgIklzTGFyZ2U6ICVkIGJ1ZjogJXAgdGltZSByY3Y6ICVsZCBub3c6ICVsZCIsCkBAIC0yMTgsMTEgKzIxOCwxMSBAQAogCQkJCW1pZF9lbnRyeSA9IGxpc3RfZW50cnkodG1wMywgc3RydWN0IG1pZF9xX2VudHJ5LAogCQkJCQlxaGVhZCk7CiAJCQkJc2VxX3ByaW50ZihtLCAiXHRTdGF0ZTogJWQgY29tOiAlZCBwaWQ6IgotCQkJCQkJIiAlZCB0c2s6ICVwIG1pZCAlZFxuIiwKKwkJCQkJCSIgJWQgY2JkYXRhOiAlcCBtaWQgJWRcbiIsCiAJCQkJCQltaWRfZW50cnktPm1pZFN0YXRlLAogCQkJCQkJKGludCltaWRfZW50cnktPmNvbW1hbmQsCiAJCQkJCQltaWRfZW50cnktPnBpZCwKLQkJCQkJCW1pZF9lbnRyeS0+dHNrLAorCQkJCQkJbWlkX2VudHJ5LT5jYWxsYmFja19kYXRhLAogCQkJCQkJbWlkX2VudHJ5LT5taWQpOwogCQkJfQogCQkJc3Bpbl91bmxvY2soJkdsb2JhbE1pZF9Mb2NrKTsKQEAgLTMzMSw3ICszMzEsNyBAQAogCQkJCWF0b21pY19yZWFkKCZ0b3RTbUJ1ZkFsbG9jQ291bnQpKTsKICNlbmRpZiAvKiBDT05GSUdfQ0lGU19TVEFUUzIgKi8KIAotCXNlcV9wcmludGYobSwgIk9wZXJhdGlvbnMgKE1JRHMpOiAlZFxuIiwgbWlkQ291bnQuY291bnRlcik7CisJc2VxX3ByaW50ZihtLCAiT3BlcmF0aW9ucyAoTUlEcyk6ICVkXG4iLCBhdG9taWNfcmVhZCgmbWlkQ291bnQpKTsKIAlzZXFfcHJpbnRmKG0sCiAJCSJcbiVkIHNlc3Npb24gJWQgc2hhcmUgcmVjb25uZWN0c1xuIiwKIAkJdGNwU2VzUmVjb25uZWN0Q291bnQuY291bnRlciwgdGNvbkluZm9SZWNvbm5lY3RDb3VudC5jb3VudGVyKTsKZGlmZiAtLWdpdCBhL2ZzL2NpZnMvY2lmc19kZnNfcmVmLmMgYi9mcy9jaWZzL2NpZnNfZGZzX3JlZi5jCmluZGV4IGM2OGEwNTYuLjBhMjY1YWQgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvY2lmc19kZnNfcmVmLmMKKysrIGIvZnMvY2lmcy9jaWZzX2Rmc19yZWYuYwpAQCAtMjU1LDM1ICsyNTUsNiBAQAogCiB9CiAKLXN0YXRpYyBpbnQgYWRkX21vdW50X2hlbHBlcihzdHJ1Y3QgdmZzbW91bnQgKm5ld21udCwgc3RydWN0IG5hbWVpZGF0YSAqbmQsCi0JCQkJc3RydWN0IGxpc3RfaGVhZCAqbW50bGlzdCkKLXsKLQkvKiBzdG9sZW4gZnJvbSBhZnMgY29kZSAqLwotCWludCBlcnI7Ci0KLQltbnRnZXQobmV3bW50KTsKLQllcnIgPSBkb19hZGRfbW91bnQobmV3bW50LCAmbmQtPnBhdGgsIG5kLT5wYXRoLm1udC0+bW50X2ZsYWdzIHwgTU5UX1NIUklOS0FCTEUsIG1udGxpc3QpOwotCXN3aXRjaCAoZXJyKSB7Ci0JY2FzZSAwOgotCQlwYXRoX3B1dCgmbmQtPnBhdGgpOwotCQluZC0+cGF0aC5tbnQgPSBuZXdtbnQ7Ci0JCW5kLT5wYXRoLmRlbnRyeSA9IGRnZXQobmV3bW50LT5tbnRfcm9vdCk7Ci0JCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmY2lmc19kZnNfYXV0b21vdW50X3Rhc2ssCi0JCQkJICAgICAgY2lmc19kZnNfbW91bnRwb2ludF9leHBpcnlfdGltZW91dCk7Ci0JCWJyZWFrOwotCWNhc2UgLUVCVVNZOgotCQkvKiBzb21lb25lIGVsc2UgbWFkZSBhIG1vdW50IGhlcmUgd2hpbHN0IHdlIHdlcmUgYnVzeSAqLwotCQl3aGlsZSAoZF9tb3VudHBvaW50KG5kLT5wYXRoLmRlbnRyeSkgJiYKLQkJICAgICAgIGZvbGxvd19kb3duKCZuZC0+cGF0aCkpCi0JCQk7Ci0JCWVyciA9IDA7Ci0JZGVmYXVsdDoKLQkJbW50cHV0KG5ld21udCk7Ci0JCWJyZWFrOwotCX0KLQlyZXR1cm4gZXJyOwotfQotCiBzdGF0aWMgdm9pZCBkdW1wX3JlZmVycmFsKGNvbnN0IHN0cnVjdCBkZnNfaW5mbzNfcGFyYW0gKnJlZikKIHsKIAljRllJKDEsICJERlM6IHJlZiBwYXRoOiAlcyIsIHJlZi0+cGF0aF9uYW1lKTsKQEAgLTI5MywyNyArMjY0LDIzIEBACiAJCQkJcmVmLT5wYXRoX2NvbnN1bWVkKTsKIH0KIAotCi1zdGF0aWMgdm9pZCoKLWNpZnNfZGZzX2ZvbGxvd19tb3VudHBvaW50KHN0cnVjdCBkZW50cnkgKmRlbnRyeSwgc3RydWN0IG5hbWVpZGF0YSAqbmQpCisvKgorICogQ3JlYXRlIGEgdmZzbW91bnQgdGhhdCB3ZSBjYW4gYXV0b21vdW50CisgKi8KK3N0YXRpYyBzdHJ1Y3QgdmZzbW91bnQgKmNpZnNfZGZzX2RvX2F1dG9tb3VudChzdHJ1Y3QgZGVudHJ5ICptbnRwdCkKIHsKIAlzdHJ1Y3QgZGZzX2luZm8zX3BhcmFtICpyZWZlcnJhbHMgPSBOVUxMOwogCXVuc2lnbmVkIGludCBudW1fcmVmZXJyYWxzID0gMDsKIAlzdHJ1Y3QgY2lmc19zYl9pbmZvICpjaWZzX3NiOwogCXN0cnVjdCBjaWZzU2VzSW5mbyAqc2VzOwotCWNoYXIgKmZ1bGxfcGF0aCA9IE5VTEw7CisJY2hhciAqZnVsbF9wYXRoOwogCWludCB4aWQsIGk7Ci0JaW50IHJjID0gMDsKLQlzdHJ1Y3QgdmZzbW91bnQgKm1udCA9IEVSUl9QVFIoLUVOT0VOVCk7CisJaW50IHJjOworCXN0cnVjdCB2ZnNtb3VudCAqbW50OwogCXN0cnVjdCB0Y29uX2xpbmsgKnRsaW5rOwogCiAJY0ZZSSgxLCAiaW4gJXMiLCBfX2Z1bmNfXyk7Ci0JQlVHX09OKElTX1JPT1QoZGVudHJ5KSk7Ci0KLQl4aWQgPSBHZXRYaWQoKTsKLQotCWRwdXQobmQtPnBhdGguZGVudHJ5KTsKLQluZC0+cGF0aC5kZW50cnkgPSBkZ2V0KGRlbnRyeSk7CisJQlVHX09OKElTX1JPT1QobW50cHQpKTsKIAogCS8qCiAJICogVGhlIE1TREZTIHNwZWMgc3RhdGVzIHRoYXQgcGF0aHMgaW4gREZTIHJlZmVycmFsIHJlcXVlc3RzIGFuZApAQCAtMzIxLDY2ICsyODgsODMgQEAKIAkgKiB0aGUgZG91YmxlIGJhY2tzbGFzaGVzIHVzdWFsbHkgdXNlZCBpbiB0aGUgVU5DLiBUaGlzIGZ1bmN0aW9uCiAJICogZ2l2ZXMgdXMgdGhlIGxhdHRlciwgc28gd2UgbXVzdCBhZGp1c3QgdGhlIHJlc3VsdC4KIAkgKi8KLQlmdWxsX3BhdGggPSBidWlsZF9wYXRoX2Zyb21fZGVudHJ5KGRlbnRyeSk7Ci0JaWYgKGZ1bGxfcGF0aCA9PSBOVUxMKSB7Ci0JCXJjID0gLUVOT01FTTsKLQkJZ290byBvdXRfZXJyOwotCX0KKwltbnQgPSBFUlJfUFRSKC1FTk9NRU0pOworCWZ1bGxfcGF0aCA9IGJ1aWxkX3BhdGhfZnJvbV9kZW50cnkobW50cHQpOworCWlmIChmdWxsX3BhdGggPT0gTlVMTCkKKwkJZ290byBjZGRhX2V4aXQ7CiAKLQljaWZzX3NiID0gQ0lGU19TQihkZW50cnktPmRfaW5vZGUtPmlfc2IpOworCWNpZnNfc2IgPSBDSUZTX1NCKG1udHB0LT5kX2lub2RlLT5pX3NiKTsKIAl0bGluayA9IGNpZnNfc2JfdGxpbmsoY2lmc19zYik7CiAJaWYgKElTX0VSUih0bGluaykpIHsKLQkJcmMgPSBQVFJfRVJSKHRsaW5rKTsKLQkJZ290byBvdXRfZXJyOworCQltbnQgPSBFUlJfQ0FTVCh0bGluayk7CisJCWdvdG8gZnJlZV9mdWxsX3BhdGg7CiAJfQogCXNlcyA9IHRsaW5rX3Rjb24odGxpbmspLT5zZXM7CiAKKwl4aWQgPSBHZXRYaWQoKTsKIAlyYyA9IGdldF9kZnNfcGF0aCh4aWQsIHNlcywgZnVsbF9wYXRoICsgMSwgY2lmc19zYi0+bG9jYWxfbmxzLAogCQkmbnVtX3JlZmVycmFscywgJnJlZmVycmFscywKIAkJY2lmc19zYi0+bW50X2NpZnNfZmxhZ3MgJiBDSUZTX01PVU5UX01BUF9TUEVDSUFMX0NIUik7CisJRnJlZVhpZCh4aWQpOwogCiAJY2lmc19wdXRfdGxpbmsodGxpbmspOwogCisJbW50ID0gRVJSX1BUUigtRU5PRU5UKTsKIAlmb3IgKGkgPSAwOyBpIDwgbnVtX3JlZmVycmFsczsgaSsrKSB7CiAJCWludCBsZW47Ci0JCWR1bXBfcmVmZXJyYWwocmVmZXJyYWxzK2kpOworCQlkdW1wX3JlZmVycmFsKHJlZmVycmFscyArIGkpOwogCQkvKiBjb25uZWN0IHRvIGEgbm9kZSAqLwogCQlsZW4gPSBzdHJsZW4ocmVmZXJyYWxzW2ldLm5vZGVfbmFtZSk7CiAJCWlmIChsZW4gPCAyKSB7CiAJCQljRVJST1IoMSwgIiVzOiBOZXQgQWRkcmVzcyBwYXRoIHRvbyBzaG9ydDogJXMiLAogCQkJCQlfX2Z1bmNfXywgcmVmZXJyYWxzW2ldLm5vZGVfbmFtZSk7Ci0JCQlyYyA9IC1FSU5WQUw7Ci0JCQlnb3RvIG91dF9lcnI7CisJCQltbnQgPSBFUlJfUFRSKC1FSU5WQUwpOworCQkJYnJlYWs7CiAJCX0KIAkJbW50ID0gY2lmc19kZnNfZG9fcmVmbW91bnQoY2lmc19zYiwKIAkJCQlmdWxsX3BhdGgsIHJlZmVycmFscyArIGkpOwogCQljRllJKDEsICIlczogY2lmc19kZnNfZG9fcmVmbW91bnQ6JXMgLCBtbnQ6JXAiLCBfX2Z1bmNfXywKIAkJCQkJcmVmZXJyYWxzW2ldLm5vZGVfbmFtZSwgbW50KTsKLQotCQkvKiBjb21wbGV0ZSBtb3VudCBwcm9jZWR1cmUgaWYgd2UgYWNjdXJlZCBzdWJtb3VudCAqLwogCQlpZiAoIUlTX0VSUihtbnQpKQotCQkJYnJlYWs7CisJCQlnb3RvIHN1Y2Nlc3M7CiAJfQogCi0JLyogd2UgbmVlZCBpdCBjYXVzZSBmb3IoKSBhYm92ZSBjb3VsZCBleGl0IHdpdGhvdXQgdmFsaWQgc3VibW91bnQgKi8KLQlyYyA9IFBUUl9FUlIobW50KTsKLQlpZiAoSVNfRVJSKG1udCkpCi0JCWdvdG8gb3V0X2VycjsKKwkvKiBubyB2YWxpZCBzdWJtb3VudHMgd2VyZSBmb3VuZDsgcmV0dXJuIGVycm9yIGZyb20gZ2V0X2Rmc19wYXRoKCkgYnkKKwkgKiBwcmVmZXJlbmNlICovCisJaWYgKHJjICE9IDApCisJCW1udCA9IEVSUl9QVFIocmMpOwogCi0JcmMgPSBhZGRfbW91bnRfaGVscGVyKG1udCwgbmQsICZjaWZzX2Rmc19hdXRvbW91bnRfbGlzdCk7Ci0KLW91dDoKLQlGcmVlWGlkKHhpZCk7CitzdWNjZXNzOgogCWZyZWVfZGZzX2luZm9fYXJyYXkocmVmZXJyYWxzLCBudW1fcmVmZXJyYWxzKTsKK2ZyZWVfZnVsbF9wYXRoOgogCWtmcmVlKGZ1bGxfcGF0aCk7CitjZGRhX2V4aXQ6CiAJY0ZZSSgxLCAibGVhdmluZyAlcyIgLCBfX2Z1bmNfXyk7Ci0JcmV0dXJuIEVSUl9QVFIocmMpOwotb3V0X2VycjoKLQlwYXRoX3B1dCgmbmQtPnBhdGgpOwotCWdvdG8gb3V0OworCXJldHVybiBtbnQ7Cit9CisKKy8qCisgKiBBdHRlbXB0IHRvIGF1dG9tb3VudCB0aGUgcmVmZXJyYWwKKyAqLworc3RydWN0IHZmc21vdW50ICpjaWZzX2Rmc19kX2F1dG9tb3VudChzdHJ1Y3QgcGF0aCAqcGF0aCkKK3sKKwlzdHJ1Y3QgdmZzbW91bnQgKm5ld21udDsKKworCWNGWUkoMSwgImluICVzIiwgX19mdW5jX18pOworCisJbmV3bW50ID0gY2lmc19kZnNfZG9fYXV0b21vdW50KHBhdGgtPmRlbnRyeSk7CisJaWYgKElTX0VSUihuZXdtbnQpKSB7CisJCWNGWUkoMSwgImxlYXZpbmcgJXMgW2F1dG9tb3VudCBmYWlsZWRdIiAsIF9fZnVuY19fKTsKKwkJcmV0dXJuIG5ld21udDsKKwl9CisKKwltbnRnZXQobmV3bW50KTsgLyogcHJldmVudCBpbW1lZGlhdGUgZXhwaXJhdGlvbiAqLworCW1udF9zZXRfZXhwaXJ5KG5ld21udCwgJmNpZnNfZGZzX2F1dG9tb3VudF9saXN0KTsKKwlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJmNpZnNfZGZzX2F1dG9tb3VudF90YXNrLAorCQkJICAgICAgY2lmc19kZnNfbW91bnRwb2ludF9leHBpcnlfdGltZW91dCk7CisJY0ZZSSgxLCAibGVhdmluZyAlcyBbb2tdIiAsIF9fZnVuY19fKTsKKwlyZXR1cm4gbmV3bW50OwogfQogCiBjb25zdCBzdHJ1Y3QgaW5vZGVfb3BlcmF0aW9ucyBjaWZzX2Rmc19yZWZlcnJhbF9pbm9kZV9vcGVyYXRpb25zID0gewotCS5mb2xsb3dfbGluayA9IGNpZnNfZGZzX2ZvbGxvd19tb3VudHBvaW50LAogfTsKLQpkaWZmIC0tZ2l0IGEvZnMvY2lmcy9jaWZzX2ZzX3NiLmggYi9mcy9jaWZzL2NpZnNfZnNfc2IuaAppbmRleCA3ODUyY2Q2Li5hYzUxY2QyIDEwMDY0NAotLS0gYS9mcy9jaWZzL2NpZnNfZnNfc2IuaAorKysgYi9mcy9jaWZzL2NpZnNfZnNfc2IuaApAQCAtNDAsNiArNDAsNyBAQAogI2RlZmluZSBDSUZTX01PVU5UX0ZTQ0FDSEUJMHg4MDAwIC8qIGxvY2FsIGNhY2hpbmcgZW5hYmxlZCAqLwogI2RlZmluZSBDSUZTX01PVU5UX01GX1NZTUxJTktTCTB4MTAwMDAgLyogTWluc2hhbGwrRnJlbmNoIFN5bWxpbmtzIGVuYWJsZWQgKi8KICNkZWZpbmUgQ0lGU19NT1VOVF9NVUxUSVVTRVIJMHgyMDAwMCAvKiBtdWx0aXVzZXIgbW91bnQgKi8KKyNkZWZpbmUgQ0lGU19NT1VOVF9TVFJJQ1RfSU8JMHg0MDAwMCAvKiBzdHJpY3QgY2FjaGUgbW9kZSAqLwogCiBzdHJ1Y3QgY2lmc19zYl9pbmZvIHsKIAlzdHJ1Y3QgcmJfcm9vdCB0bGlua190cmVlOwpkaWZmIC0tZ2l0IGEvZnMvY2lmcy9jaWZzX3VuaWNvZGUuYyBiL2ZzL2NpZnMvY2lmc191bmljb2RlLmMKaW5kZXggNDMwZjUxMC4uZmMwZmQ0ZiAxMDA2NDQKLS0tIGEvZnMvY2lmcy9jaWZzX3VuaWNvZGUuYworKysgYi9mcy9jaWZzL2NpZnNfdW5pY29kZS5jCkBAIC00NCwxMCArNDQsMTQgQEAKIAlpbnQgY2hhcmxlbiwgb3V0bGVuID0gMDsKIAlpbnQgbWF4d29yZHMgPSBtYXhieXRlcyAvIDI7CiAJY2hhciB0bXBbTkxTX01BWF9DSEFSU0VUX1NJWkVdOworCV9fdTE2IGZ0bXA7CiAKLQlmb3IgKGkgPSAwOyBpIDwgbWF4d29yZHMgJiYgZnJvbVtpXTsgaSsrKSB7Ci0JCWNoYXJsZW4gPSBjb2RlcGFnZS0+dW5pMmNoYXIobGUxNl90b19jcHUoZnJvbVtpXSksIHRtcCwKLQkJCQkJICAgICBOTFNfTUFYX0NIQVJTRVRfU0laRSk7CisJZm9yIChpID0gMDsgaSA8IG1heHdvcmRzOyBpKyspIHsKKwkJZnRtcCA9IGdldF91bmFsaWduZWRfbGUxNigmZnJvbVtpXSk7CisJCWlmIChmdG1wID09IDApCisJCQlicmVhazsKKworCQljaGFybGVuID0gY29kZXBhZ2UtPnVuaTJjaGFyKGZ0bXAsIHRtcCwgTkxTX01BWF9DSEFSU0VUX1NJWkUpOwogCQlpZiAoY2hhcmxlbiA+IDApCiAJCQlvdXRsZW4gKz0gY2hhcmxlbjsKIAkJZWxzZQpAQCAtNTgsOSArNjIsOSBAQAogfQogCiAvKgotICogY2lmc19tYXBjaGFyIC0gY29udmVydCBhIGxpdHRsZS1lbmRpYW4gY2hhciB0byBwcm9wZXIgY2hhciBpbiBjb2RlcGFnZQorICogY2lmc19tYXBjaGFyIC0gY29udmVydCBhIGhvc3QtZW5kaWFuIGNoYXIgdG8gcHJvcGVyIGNoYXIgaW4gY29kZXBhZ2UKICAqIEB0YXJnZXQgLSB3aGVyZSBjb252ZXJ0ZWQgY2hhcmFjdGVyIHNob3VsZCBiZSBjb3BpZWQKLSAqIEBzcmNfY2hhciAtIDIgYnl0ZSBsaXR0bGUtZW5kaWFuIHNvdXJjZSBjaGFyYWN0ZXIKKyAqIEBzcmNfY2hhciAtIDIgYnl0ZSBob3N0LWVuZGlhbiBzb3VyY2UgY2hhcmFjdGVyCiAgKiBAY3AgLSBjb2RlcGFnZSB0byB3aGljaCBjaGFyYWN0ZXIgc2hvdWxkIGJlIGNvbnZlcnRlZAogICogQG1hcGNoYXIgLSBzaG91bGQgY2hhcmFjdGVyIGJlIG1hcHBlZCBhY2NvcmRpbmcgdG8gbWFwY2hhcnMgbW91bnQgb3B0aW9uPwogICoKQEAgLTY5LDcgKzczLDcgQEAKICAqIGVub3VnaCB0byBob2xkIHRoZSByZXN1bHQgb2YgdGhlIGNvbnZlcnNpb24gKGF0IGxlYXN0IE5MU19NQVhfQ0hBUlNFVF9TSVpFKS4KICAqLwogc3RhdGljIGludAotY2lmc19tYXBjaGFyKGNoYXIgKnRhcmdldCwgY29uc3QgX19sZTE2IHNyY19jaGFyLCBjb25zdCBzdHJ1Y3QgbmxzX3RhYmxlICpjcCwKK2NpZnNfbWFwY2hhcihjaGFyICp0YXJnZXQsIGNvbnN0IF9fdTE2IHNyY19jaGFyLCBjb25zdCBzdHJ1Y3QgbmxzX3RhYmxlICpjcCwKIAkgICAgIGJvb2wgbWFwY2hhcikKIHsKIAlpbnQgbGVuID0gMTsKQEAgLTgyLDcgKzg2LDcgQEAKIAkgKiAgICAgYnVpbGRfcGF0aF9mcm9tX2RlbnRyeSBhcmUgbW9kaWZpZWQsIGFzIHRoZXkgdXNlIHNsYXNoIGFzCiAJICogICAgIHNlcGFyYXRvci4KIAkgKi8KLQlzd2l0Y2ggKGxlMTZfdG9fY3B1KHNyY19jaGFyKSkgeworCXN3aXRjaCAoc3JjX2NoYXIpIHsKIAljYXNlIFVOSV9DT0xPTjoKIAkJKnRhcmdldCA9ICc6JzsKIAkJYnJlYWs7CkBAIC0xMDksOCArMTEzLDcgQEAKIAlyZXR1cm4gbGVuOwogCiBjcF9jb252ZXJ0OgotCWxlbiA9IGNwLT51bmkyY2hhcihsZTE2X3RvX2NwdShzcmNfY2hhciksIHRhcmdldCwKLQkJCSAgIE5MU19NQVhfQ0hBUlNFVF9TSVpFKTsKKwlsZW4gPSBjcC0+dW5pMmNoYXIoc3JjX2NoYXIsIHRhcmdldCwgTkxTX01BWF9DSEFSU0VUX1NJWkUpOwogCWlmIChsZW4gPD0gMCkgewogCQkqdGFyZ2V0ID0gJz8nOwogCQlsZW4gPSAxOwpAQCAtMTQ5LDYgKzE1Miw3IEBACiAJaW50IG51bGxzaXplID0gbmxzX251bGxzaXplKGNvZGVwYWdlKTsKIAlpbnQgZnJvbXdvcmRzID0gZnJvbWxlbiAvIDI7CiAJY2hhciB0bXBbTkxTX01BWF9DSEFSU0VUX1NJWkVdOworCV9fdTE2IGZ0bXA7CiAKIAkvKgogCSAqIGJlY2F1c2UgdGhlIGNoYXJzIGNhbiBiZSBvZiB2YXJ5aW5nIHdpZHRocywgd2UgbmVlZCB0byB0YWtlIGNhcmUKQEAgLTE1OCwxOSArMTYyLDIzIEBACiAJICovCiAJc2FmZWxlbiA9IHRvbGVuIC0gKE5MU19NQVhfQ0hBUlNFVF9TSVpFICsgbnVsbHNpemUpOwogCi0JZm9yIChpID0gMDsgaSA8IGZyb213b3JkcyAmJiBmcm9tW2ldOyBpKyspIHsKKwlmb3IgKGkgPSAwOyBpIDwgZnJvbXdvcmRzOyBpKyspIHsKKwkJZnRtcCA9IGdldF91bmFsaWduZWRfbGUxNigmZnJvbVtpXSk7CisJCWlmIChmdG1wID09IDApCisJCQlicmVhazsKKwogCQkvKgogCQkgKiBjaGVjayB0byBzZWUgaWYgY29udmVydGluZyB0aGlzIGNoYXJhY3RlciBtaWdodCBtYWtlIHRoZQogCQkgKiBjb252ZXJzaW9uIGJsZWVkIGludG8gdGhlIG51bGwgdGVybWluYXRvcgogCQkgKi8KIAkJaWYgKG91dGxlbiA+PSBzYWZlbGVuKSB7Ci0JCQljaGFybGVuID0gY2lmc19tYXBjaGFyKHRtcCwgZnJvbVtpXSwgY29kZXBhZ2UsIG1hcGNoYXIpOworCQkJY2hhcmxlbiA9IGNpZnNfbWFwY2hhcih0bXAsIGZ0bXAsIGNvZGVwYWdlLCBtYXBjaGFyKTsKIAkJCWlmICgob3V0bGVuICsgY2hhcmxlbikgPiAodG9sZW4gLSBudWxsc2l6ZSkpCiAJCQkJYnJlYWs7CiAJCX0KIAogCQkvKiBwdXQgY29udmVydGVkIGNoYXIgaW50byAndG8nIGJ1ZmZlciAqLwotCQljaGFybGVuID0gY2lmc19tYXBjaGFyKCZ0b1tvdXRsZW5dLCBmcm9tW2ldLCBjb2RlcGFnZSwgbWFwY2hhcik7CisJCWNoYXJsZW4gPSBjaWZzX21hcGNoYXIoJnRvW291dGxlbl0sIGZ0bXAsIGNvZGVwYWdlLCBtYXBjaGFyKTsKIAkJb3V0bGVuICs9IGNoYXJsZW47CiAJfQogCkBAIC0xOTMsMjQgKzIwMSwyMSBAQAogewogCWludCBjaGFybGVuOwogCWludCBpOwotCXdjaGFyX3QgKndjaGFyX3RvID0gKHdjaGFyX3QgKil0bzsgLyogbmVlZGVkIHRvIHF1aWV0IHNwYXJzZSAqLworCXdjaGFyX3Qgd2NoYXJfdG87IC8qIG5lZWRlZCB0byBxdWlldCBzcGFyc2UgKi8KIAogCWZvciAoaSA9IDA7IGxlbiAmJiAqZnJvbTsgaSsrLCBmcm9tICs9IGNoYXJsZW4sIGxlbiAtPSBjaGFybGVuKSB7Ci0KLQkJLyogd29ya3MgZm9yIDIuNC4wIGtlcm5lbCBvciBsYXRlciAqLwotCQljaGFybGVuID0gY29kZXBhZ2UtPmNoYXIydW5pKGZyb20sIGxlbiwgJndjaGFyX3RvW2ldKTsKKwkJY2hhcmxlbiA9IGNvZGVwYWdlLT5jaGFyMnVuaShmcm9tLCBsZW4sICZ3Y2hhcl90byk7CiAJCWlmIChjaGFybGVuIDwgMSkgewotCQkJY0VSUk9SKDEsICJzdHJ0b1VDUzogY2hhcjJ1bmkgb2YgJWQgcmV0dXJuZWQgJWQiLAotCQkJCShpbnQpKmZyb20sIGNoYXJsZW4pOworCQkJY0VSUk9SKDEsICJzdHJ0b1VDUzogY2hhcjJ1bmkgb2YgMHgleCByZXR1cm5lZCAlZCIsCisJCQkJKmZyb20sIGNoYXJsZW4pOwogCQkJLyogQSBxdWVzdGlvbiBtYXJrICovCi0JCQl0b1tpXSA9IGNwdV90b19sZTE2KDB4MDAzZik7CisJCQl3Y2hhcl90byA9IDB4MDAzZjsKIAkJCWNoYXJsZW4gPSAxOwotCQl9IGVsc2UKLQkJCXRvW2ldID0gY3B1X3RvX2xlMTYod2NoYXJfdG9baV0pOwotCisJCX0KKwkJcHV0X3VuYWxpZ25lZF9sZTE2KHdjaGFyX3RvLCAmdG9baV0pOwogCX0KIAotCXRvW2ldID0gMDsKKwlwdXRfdW5hbGlnbmVkX2xlMTYoMCwgJnRvW2ldKTsKIAlyZXR1cm4gaTsKIH0KIApAQCAtMjUyLDMgKzI1Nyw3OSBAQAogCXJldHVybiBkc3Q7CiB9CiAKKy8qCisgKiBDb252ZXJ0IDE2IGJpdCBVbmljb2RlIHBhdGhuYW1lIHRvIHdpcmUgZm9ybWF0IGZyb20gc3RyaW5nIGluIGN1cnJlbnQgY29kZQorICogcGFnZS4gQ29udmVyc2lvbiBtYXkgaW52b2x2ZSByZW1hcHBpbmcgdXAgdGhlIHNpeCBjaGFyYWN0ZXJzIHRoYXQgYXJlCisgKiBvbmx5IGxlZ2FsIGluIFBPU0lYLWxpa2UgT1MgKGlmIHRoZXkgYXJlIHByZXNlbnQgaW4gdGhlIHN0cmluZykuIFBhdGgKKyAqIG5hbWVzIGFyZSBsaXR0bGUgZW5kaWFuIDE2IGJpdCBVbmljb2RlIG9uIHRoZSB3aXJlCisgKi8KK2ludAorY2lmc0NvbnZlcnRUb1VDUyhfX2xlMTYgKnRhcmdldCwgY29uc3QgY2hhciAqc291cmNlLCBpbnQgbWF4bGVuLAorCQkgY29uc3Qgc3RydWN0IG5sc190YWJsZSAqY3AsIGludCBtYXBDaGFycykKK3sKKwlpbnQgaSwgaiwgY2hhcmxlbjsKKwlpbnQgbGVuX3JlbWFpbmluZyA9IG1heGxlbjsKKwljaGFyIHNyY19jaGFyOworCV9fdTE2IHRlbXA7CisKKwlpZiAoIW1hcENoYXJzKQorCQlyZXR1cm4gY2lmc19zdHJ0b1VDUyh0YXJnZXQsIHNvdXJjZSwgUEFUSF9NQVgsIGNwKTsKKworCWZvciAoaSA9IDAsIGogPSAwOyBpIDwgbWF4bGVuOyBqKyspIHsKKwkJc3JjX2NoYXIgPSBzb3VyY2VbaV07CisJCXN3aXRjaCAoc3JjX2NoYXIpIHsKKwkJY2FzZSAwOgorCQkJcHV0X3VuYWxpZ25lZF9sZTE2KDAsICZ0YXJnZXRbal0pOworCQkJZ290byBjdG9VQ1Nfb3V0OworCQljYXNlICc6JzoKKwkJCXRlbXAgPSBVTklfQ09MT047CisJCQlicmVhazsKKwkJY2FzZSAnKic6CisJCQl0ZW1wID0gVU5JX0FTVEVSSUs7CisJCQlicmVhazsKKwkJY2FzZSAnPyc6CisJCQl0ZW1wID0gVU5JX1FVRVNUSU9OOworCQkJYnJlYWs7CisJCWNhc2UgJzwnOgorCQkJdGVtcCA9IFVOSV9MRVNTVEhBTjsKKwkJCWJyZWFrOworCQljYXNlICc+JzoKKwkJCXRlbXAgPSBVTklfR1JUUlRIQU47CisJCQlicmVhazsKKwkJY2FzZSAnfCc6CisJCQl0ZW1wID0gVU5JX1BJUEU7CisJCQlicmVhazsKKwkJLyoKKwkJICogRklYTUU6IFdlIGNhbiBub3QgaGFuZGxlIHJlbWFwcGluZyBiYWNrc2xhc2ggKFVOSV9TTEFTSCkKKwkJICogdW50aWwgYWxsIHRoZSBjYWxscyB0byBidWlsZF9wYXRoX2Zyb21fZGVudHJ5IGFyZSBtb2RpZmllZCwKKwkJICogYXMgdGhleSB1c2UgYmFja3NsYXNoIGFzIHNlcGFyYXRvci4KKwkJICovCisJCWRlZmF1bHQ6CisJCQljaGFybGVuID0gY3AtPmNoYXIydW5pKHNvdXJjZStpLCBsZW5fcmVtYWluaW5nLAorCQkJCQkJJnRlbXApOworCQkJLyoKKwkJCSAqIGlmIG5vIG1hdGNoLCB1c2UgcXVlc3Rpb24gbWFyaywgd2hpY2ggYXQgbGVhc3QgaW4KKwkJCSAqIHNvbWUgY2FzZXMgc2VydmVzIGFzIHdpbGQgY2FyZAorCQkJICovCisJCQlpZiAoY2hhcmxlbiA8IDEpIHsKKwkJCQl0ZW1wID0gMHgwMDNmOworCQkJCWNoYXJsZW4gPSAxOworCQkJfQorCQkJbGVuX3JlbWFpbmluZyAtPSBjaGFybGVuOworCQkJLyoKKwkJCSAqIGNoYXJhY3RlciBtYXkgdGFrZSBtb3JlIHRoYW4gb25lIGJ5dGUgaW4gdGhlIHNvdXJjZQorCQkJICogc3RyaW5nLCBidXQgd2lsbCB0YWtlIGV4YWN0bHkgdHdvIGJ5dGVzIGluIHRoZQorCQkJICogdGFyZ2V0IHN0cmluZworCQkJICovCisJCQlpICs9IGNoYXJsZW47CisJCQljb250aW51ZTsKKwkJfQorCQlwdXRfdW5hbGlnbmVkX2xlMTYodGVtcCwgJnRhcmdldFtqXSk7CisJCWkrKzsgLyogbW92ZSB0byBuZXh0IGNoYXIgaW4gc291cmNlIHN0cmluZyAqLworCQlsZW5fcmVtYWluaW5nLS07CisJfQorCitjdG9VQ1Nfb3V0OgorCXJldHVybiBpOworfQorCmRpZmYgLS1naXQgYS9mcy9jaWZzL2NpZnNhY2wuYyBiL2ZzL2NpZnMvY2lmc2FjbC5jCmluZGV4IGE0MzdlYzMuLmJlZWViZjEgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvY2lmc2FjbC5jCisrKyBiL2ZzL2NpZnMvY2lmc2FjbC5jCkBAIC00MSw5ICs0MSwxMiBAQAogOwogCiAKLS8qIHNlY3VyaXR5IGlkIGZvciBldmVyeW9uZSAqLworLyogc2VjdXJpdHkgaWQgZm9yIGV2ZXJ5b25lL3dvcmxkIHN5c3RlbSBncm91cCAqLwogc3RhdGljIGNvbnN0IHN0cnVjdCBjaWZzX3NpZCBzaWRfZXZlcnlvbmUgPSB7CiAJMSwgMSwgezAsIDAsIDAsIDAsIDAsIDF9LCB7MH0gfTsKKy8qIHNlY3VyaXR5IGlkIGZvciBBdXRoZW50aWNhdGVkIFVzZXJzIHN5c3RlbSBncm91cCAqLworc3RhdGljIGNvbnN0IHN0cnVjdCBjaWZzX3NpZCBzaWRfYXV0aHVzZXJzID0geworCTEsIDEsIHswLCAwLCAwLCAwLCAwLCA1fSwgezExfSB9OwogLyogZ3JvdXAgdXNlcnMgKi8KIHN0YXRpYyBjb25zdCBzdHJ1Y3QgY2lmc19zaWQgc2lkX3VzZXIgPSB7MSwgMiAsIHswLCAwLCAwLCAwLCAwLCA1fSwge30gfTsKIApAQCAtMzY1LDEwICszNjgsMTQgQEAKIAlpZiAobnVtX2FjZXMgID4gMCkgewogCQl1bW9kZV90IHVzZXJfbWFzayA9IFNfSVJXWFU7CiAJCXVtb2RlX3QgZ3JvdXBfbWFzayA9IFNfSVJXWEc7Ci0JCXVtb2RlX3Qgb3RoZXJfbWFzayA9IFNfSVJXWE87CisJCXVtb2RlX3Qgb3RoZXJfbWFzayA9IFNfSVJXWFUgfCBTX0lSV1hHIHwgU19JUldYTzsKIAogCQlwcGFjZSA9IGttYWxsb2MobnVtX2FjZXMgKiBzaXplb2Yoc3RydWN0IGNpZnNfYWNlICopLAogCQkJCUdGUF9LRVJORUwpOworCQlpZiAoIXBwYWNlKSB7CisJCQljRVJST1IoMSwgIkRBQ0wgbWVtb3J5IGFsbG9jYXRpb24gZXJyb3IiKTsKKwkJCXJldHVybjsKKwkJfQogCiAJCWZvciAoaSA9IDA7IGkgPCBudW1fYWNlczsgKytpKSB7CiAJCQlwcGFjZVtpXSA9IChzdHJ1Y3QgY2lmc19hY2UgKikgKGFjbF9iYXNlICsgYWNsX3NpemUpOwpAQCAtMzkwLDYgKzM5NywxMiBAQAogCQkJCQkJICAgICBwcGFjZVtpXS0+dHlwZSwKIAkJCQkJCSAgICAgJmZhdHRyLT5jZl9tb2RlLAogCQkJCQkJICAgICAmb3RoZXJfbWFzayk7CisJCQlpZiAoY29tcGFyZV9zaWRzKCYocHBhY2VbaV0tPnNpZCksICZzaWRfYXV0aHVzZXJzKSkKKwkJCQlhY2Nlc3NfZmxhZ3NfdG9fbW9kZShwcGFjZVtpXS0+YWNjZXNzX3JlcSwKKwkJCQkJCSAgICAgcHBhY2VbaV0tPnR5cGUsCisJCQkJCQkgICAgICZmYXR0ci0+Y2ZfbW9kZSwKKwkJCQkJCSAgICAgJm90aGVyX21hc2spOworCiAKIC8qCQkJbWVtY3B5KCh2b2lkICopKCYoY2lmc2NyZWQtPmFjZXNbaV0pKSwKIAkJCQkodm9pZCAqKXBwYWNlW2ldLApkaWZmIC0tZ2l0IGEvZnMvY2lmcy9jaWZzZW5jcnlwdC5jIGIvZnMvY2lmcy9jaWZzZW5jcnlwdC5jCmluZGV4IDY2ZjNkNTAuLmE1MTU4NWYgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvY2lmc2VuY3J5cHQuYworKysgYi9mcy9jaWZzL2NpZnNlbmNyeXB0LmMKQEAgLTI0LDcgKzI0LDYgQEAKICNpbmNsdWRlICJjaWZzcGR1LmgiCiAjaW5jbHVkZSAiY2lmc2dsb2IuaCIKICNpbmNsdWRlICJjaWZzX2RlYnVnLmgiCi0jaW5jbHVkZSAibWQ1LmgiCiAjaW5jbHVkZSAiY2lmc191bmljb2RlLmgiCiAjaW5jbHVkZSAiY2lmc3Byb3RvLmgiCiAjaW5jbHVkZSAibnRsbXNzcC5oIgpAQCAtMzcsMTEgKzM2LDYgQEAKIC8qIE5vdGUgdGhhdCB0aGUgc21iIGhlYWRlciBzaWduYXR1cmUgZmllbGQgb24gaW5wdXQgY29udGFpbnMgdGhlCiAJc2VxdWVuY2UgbnVtYmVyIGJlZm9yZSB0aGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCAqLwogCi1leHRlcm4gdm9pZCBtZGZvdXIodW5zaWduZWQgY2hhciAqb3V0LCB1bnNpZ25lZCBjaGFyICppbiwgaW50IG4pOwotZXh0ZXJuIHZvaWQgRV9tZDRoYXNoKGNvbnN0IHVuc2lnbmVkIGNoYXIgKnBhc3N3ZCwgdW5zaWduZWQgY2hhciAqcDE2KTsKLWV4dGVybiB2b2lkIFNNQmVuY3J5cHQodW5zaWduZWQgY2hhciAqcGFzc3dkLCBjb25zdCB1bnNpZ25lZCBjaGFyICpjOCwKLQkJICAgICAgIHVuc2lnbmVkIGNoYXIgKnAyNCk7Ci0KIHN0YXRpYyBpbnQgY2lmc19jYWxjdWxhdGVfc2lnbmF0dXJlKGNvbnN0IHN0cnVjdCBzbWJfaGRyICpjaWZzX3BkdSwKIAkJCQlzdHJ1Y3QgVENQX1NlcnZlcl9JbmZvICpzZXJ2ZXIsIGNoYXIgKnNpZ25hdHVyZSkKIHsKQEAgLTIzNCw2ICsyMjgsNyBAQAogLyogZmlyc3QgY2FsY3VsYXRlIDI0IGJ5dGVzIG50bG0gcmVzcG9uc2UgYW5kIHRoZW4gMTYgYnl0ZSBzZXNzaW9uIGtleSAqLwogaW50IHNldHVwX250bG1fcmVzcG9uc2Uoc3RydWN0IGNpZnNTZXNJbmZvICpzZXMpCiB7CisJaW50IHJjID0gMDsKIAl1bnNpZ25lZCBpbnQgdGVtcF9sZW4gPSBDSUZTX1NFU1NfS0VZX1NJWkUgKyBDSUZTX0FVVEhfUkVTUF9TSVpFOwogCWNoYXIgdGVtcF9rZXlbQ0lGU19TRVNTX0tFWV9TSVpFXTsKIApAQCAtMjQ3LDEzICsyNDIsMjYgQEAKIAl9CiAJc2VzLT5hdXRoX2tleS5sZW4gPSB0ZW1wX2xlbjsKIAotCVNNQk5UZW5jcnlwdChzZXMtPnBhc3N3b3JkLCBzZXMtPnNlcnZlci0+Y3J5cHRrZXksCisJcmMgPSBTTUJOVGVuY3J5cHQoc2VzLT5wYXNzd29yZCwgc2VzLT5zZXJ2ZXItPmNyeXB0a2V5LAogCQkJc2VzLT5hdXRoX2tleS5yZXNwb25zZSArIENJRlNfU0VTU19LRVlfU0laRSk7CisJaWYgKHJjKSB7CisJCWNGWUkoMSwgIiVzIENhbid0IGdlbmVyYXRlIE5UTE0gcmVzcG9uc2UsIGVycm9yOiAlZCIsCisJCQlfX2Z1bmNfXywgcmMpOworCQlyZXR1cm4gcmM7CisJfQogCi0JRV9tZDRoYXNoKHNlcy0+cGFzc3dvcmQsIHRlbXBfa2V5KTsKLQltZGZvdXIoc2VzLT5hdXRoX2tleS5yZXNwb25zZSwgdGVtcF9rZXksIENJRlNfU0VTU19LRVlfU0laRSk7CisJcmMgPSBFX21kNGhhc2goc2VzLT5wYXNzd29yZCwgdGVtcF9rZXkpOworCWlmIChyYykgeworCQljRllJKDEsICIlcyBDYW4ndCBnZW5lcmF0ZSBOVCBoYXNoLCBlcnJvcjogJWQiLCBfX2Z1bmNfXywgcmMpOworCQlyZXR1cm4gcmM7CisJfQogCi0JcmV0dXJuIDA7CisJcmMgPSBtZGZvdXIoc2VzLT5hdXRoX2tleS5yZXNwb25zZSwgdGVtcF9rZXksIENJRlNfU0VTU19LRVlfU0laRSk7CisJaWYgKHJjKQorCQljRllJKDEsICIlcyBDYW4ndCBnZW5lcmF0ZSBOVExNIHNlc3Npb24ga2V5LCBlcnJvcjogJWQiLAorCQkJX19mdW5jX18sIHJjKTsKKworCXJldHVybiByYzsKIH0KIAogI2lmZGVmIENPTkZJR19DSUZTX1dFQUtfUFdfSEFTSApAQCAtNjQ5LDkgKzY1NywxMCBAQAogCWdldF9yYW5kb21fYnl0ZXMoc2VjX2tleSwgQ0lGU19TRVNTX0tFWV9TSVpFKTsKIAogCXRmbV9hcmM0ID0gY3J5cHRvX2FsbG9jX2Jsa2NpcGhlcigiZWNiKGFyYzQpIiwgMCwgQ1JZUFRPX0FMR19BU1lOQyk7Ci0JaWYgKCF0Zm1fYXJjNCB8fCBJU19FUlIodGZtX2FyYzQpKSB7CisJaWYgKElTX0VSUih0Zm1fYXJjNCkpIHsKKwkJcmMgPSBQVFJfRVJSKHRmbV9hcmM0KTsKIAkJY0VSUk9SKDEsICJjb3VsZCBub3QgYWxsb2NhdGUgY3J5cHRvIEFQSSBhcmM0XG4iKTsKLQkJcmV0dXJuIFBUUl9FUlIodGZtX2FyYzQpOworCQlyZXR1cm4gcmM7CiAJfQogCiAJZGVzYy50Zm0gPSB0Zm1fYXJjNDsKQEAgLTcwMCwxNCArNzA5LDEzIEBACiAJdW5zaWduZWQgaW50IHNpemU7CiAKIAlzZXJ2ZXItPnNlY21lY2guaG1hY21kNSA9IGNyeXB0b19hbGxvY19zaGFzaCgiaG1hYyhtZDUpIiwgMCwgMCk7Ci0JaWYgKCFzZXJ2ZXItPnNlY21lY2guaG1hY21kNSB8fAotCQkJSVNfRVJSKHNlcnZlci0+c2VjbWVjaC5obWFjbWQ1KSkgeworCWlmIChJU19FUlIoc2VydmVyLT5zZWNtZWNoLmhtYWNtZDUpKSB7CiAJCWNFUlJPUigxLCAiY291bGQgbm90IGFsbG9jYXRlIGNyeXB0byBobWFjbWQ1XG4iKTsKIAkJcmV0dXJuIFBUUl9FUlIoc2VydmVyLT5zZWNtZWNoLmhtYWNtZDUpOwogCX0KIAogCXNlcnZlci0+c2VjbWVjaC5tZDUgPSBjcnlwdG9fYWxsb2Nfc2hhc2goIm1kNSIsIDAsIDApOwotCWlmICghc2VydmVyLT5zZWNtZWNoLm1kNSB8fCBJU19FUlIoc2VydmVyLT5zZWNtZWNoLm1kNSkpIHsKKwlpZiAoSVNfRVJSKHNlcnZlci0+c2VjbWVjaC5tZDUpKSB7CiAJCWNFUlJPUigxLCAiY291bGQgbm90IGFsbG9jYXRlIGNyeXB0byBtZDVcbiIpOwogCQlyYyA9IFBUUl9FUlIoc2VydmVyLT5zZWNtZWNoLm1kNSk7CiAJCWdvdG8gY3J5cHRvX2FsbG9jYXRlX21kNV9mYWlsOwpkaWZmIC0tZ2l0IGEvZnMvY2lmcy9jaWZzZW5jcnlwdC5oIGIvZnMvY2lmcy9jaWZzZW5jcnlwdC5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxNWQyZWMwLi4wMDAwMDAwCi0tLSBhL2ZzL2NpZnMvY2lmc2VuY3J5cHQuaAorKysgL2Rldi9udWxsCkBAIC0xLDMzICswLDAgQEAKLS8qCi0gKiAgIGZzL2NpZnMvY2lmc2VuY3J5cHQuaAotICoKLSAqICAgQ29weXJpZ2h0IChjKSBJbnRlcm5hdGlvbmFsIEJ1c2luZXNzIE1hY2hpbmVzICBDb3JwLiwgMjAwNQotICogICBBdXRob3Iocyk6IFN0ZXZlIEZyZW5jaCAoc2ZyZW5jaEB1cy5pYm0uY29tKQotICoKLSAqICAgRXh0ZXJucyBmb3IgbWlzYy4gc21hbGwgZW5jcnlwdGlvbiByb3V0aW5lcwotICogICBzbyB3ZSBkbyBub3QgaGF2ZSB0byBwdXQgdGhlbSBpbiBjaWZzcHJvdG8uaAotICoKLSAqICAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkCi0gKiAgIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIuMSBvZiB0aGUgTGljZW5zZSwgb3IKLSAqICAgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiAgIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUKLSAqICAgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiAgIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCi0gKiAgIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSwgU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcgVVNBCi0gKi8KLQotLyogbWQ0LmMgKi8KLWV4dGVybiB2b2lkIG1kZm91cih1bnNpZ25lZCBjaGFyICpvdXQsIHVuc2lnbmVkIGNoYXIgKmluLCBpbnQgbik7Ci0vKiBzbWJkZXMuYyAqLwotZXh0ZXJuIHZvaWQgRV9QMTYodW5zaWduZWQgY2hhciAqcDE0LCB1bnNpZ25lZCBjaGFyICpwMTYpOwotZXh0ZXJuIHZvaWQgRV9QMjQodW5zaWduZWQgY2hhciAqcDIxLCBjb25zdCB1bnNpZ25lZCBjaGFyICpjOCwKLQkJICB1bnNpZ25lZCBjaGFyICpwMjQpOwotCi0KLQpkaWZmIC0tZ2l0IGEvZnMvY2lmcy9jaWZzZnMuYyBiL2ZzL2NpZnMvY2lmc2ZzLmMKaW5kZXggZDlmNjUyYS4uZjI5NzAxMyAxMDA2NDQKLS0tIGEvZnMvY2lmcy9jaWZzZnMuYworKysgYi9mcy9jaWZzL2NpZnNmcy5jCkBAIC03Nyw3ICs3NywxMSBAQAogbW9kdWxlX3BhcmFtKGNpZnNfbWF4X3BlbmRpbmcsIGludCwgMCk7CiBNT0RVTEVfUEFSTV9ERVNDKGNpZnNfbWF4X3BlbmRpbmcsICJTaW11bHRhbmVvdXMgcmVxdWVzdHMgdG8gc2VydmVyLiAiCiAJCQkJICAgIkRlZmF1bHQ6IDUwIFJhbmdlOiAyIHRvIDI1NiIpOwotCit1bnNpZ25lZCBzaG9ydCBlY2hvX3JldHJpZXMgPSA1OworbW9kdWxlX3BhcmFtKGVjaG9fcmV0cmllcywgdXNob3J0LCAwNjQ0KTsKK01PRFVMRV9QQVJNX0RFU0MoZWNob19yZXRyaWVzLCAiTnVtYmVyIG9mIGVjaG8gYXR0ZW1wdHMgYmVmb3JlIGdpdmluZyB1cCBhbmQgIgorCQkJICAgICAgICJyZWNvbm5lY3Rpbmcgc2VydmVyLiBEZWZhdWx0OiA1LiAwIG1lYW5zICIKKwkJCSAgICAgICAibmV2ZXIgcmVjb25uZWN0LiIpOwogZXh0ZXJuIG1lbXBvb2xfdCAqY2lmc19zbV9yZXFfcG9vbHA7CiBleHRlcm4gbWVtcG9vbF90ICpjaWZzX3JlcV9wb29scDsKIGV4dGVybiBtZW1wb29sX3QgKmNpZnNfbWlkX3Bvb2xwOwpAQCAtNTk2LDEwICs2MDAsMTcgQEAKIHsKIAlzdHJ1Y3QgaW5vZGUgKmlub2RlID0gaW9jYi0+a2lfZmlscC0+Zl9wYXRoLmRlbnRyeS0+ZF9pbm9kZTsKIAlzc2l6ZV90IHdyaXR0ZW47CisJaW50IHJjOwogCiAJd3JpdHRlbiA9IGdlbmVyaWNfZmlsZV9haW9fd3JpdGUoaW9jYiwgaW92LCBucl9zZWdzLCBwb3MpOwotCWlmICghQ0lGU19JKGlub2RlKS0+Y2xpZW50Q2FuQ2FjaGVBbGwpCi0JCWZpbGVtYXBfZmRhdGF3cml0ZShpbm9kZS0+aV9tYXBwaW5nKTsKKworCWlmIChDSUZTX0koaW5vZGUpLT5jbGllbnRDYW5DYWNoZUFsbCkKKwkJcmV0dXJuIHdyaXR0ZW47CisKKwlyYyA9IGZpbGVtYXBfZmRhdGF3cml0ZShpbm9kZS0+aV9tYXBwaW5nKTsKKwlpZiAocmMpCisJCWNGWUkoMSwgImNpZnNfZmlsZV9haW9fd3JpdGU6ICVkIHJjIG9uICVwIGlub2RlIiwgcmMsIGlub2RlKTsKKwogCXJldHVybiB3cml0dGVuOwogfQogCkBAIC03MjksNiArNzQwLDI1IEBACiAJLnNldGxlYXNlID0gY2lmc19zZXRsZWFzZSwKIH07CiAKK2NvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgY2lmc19maWxlX3N0cmljdF9vcHMgPSB7CisJLnJlYWQgPSBkb19zeW5jX3JlYWQsCisJLndyaXRlID0gZG9fc3luY193cml0ZSwKKwkuYWlvX3JlYWQgPSBjaWZzX3N0cmljdF9yZWFkdiwKKwkuYWlvX3dyaXRlID0gY2lmc19zdHJpY3Rfd3JpdGV2LAorCS5vcGVuID0gY2lmc19vcGVuLAorCS5yZWxlYXNlID0gY2lmc19jbG9zZSwKKwkubG9jayA9IGNpZnNfbG9jaywKKwkuZnN5bmMgPSBjaWZzX3N0cmljdF9mc3luYywKKwkuZmx1c2ggPSBjaWZzX2ZsdXNoLAorCS5tbWFwID0gY2lmc19maWxlX3N0cmljdF9tbWFwLAorCS5zcGxpY2VfcmVhZCA9IGdlbmVyaWNfZmlsZV9zcGxpY2VfcmVhZCwKKwkubGxzZWVrID0gY2lmc19sbHNlZWssCisjaWZkZWYgQ09ORklHX0NJRlNfUE9TSVgKKwkudW5sb2NrZWRfaW9jdGwJPSBjaWZzX2lvY3RsLAorI2VuZGlmIC8qIENPTkZJR19DSUZTX1BPU0lYICovCisJLnNldGxlYXNlID0gY2lmc19zZXRsZWFzZSwKK307CisKIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgY2lmc19maWxlX2RpcmVjdF9vcHMgPSB7CiAJLyogbm8gYWlvLCBubyByZWFkdiAtCiAJICAgQkIgcmVldmFsdWF0ZSB3aGV0aGVyIHRoZXkgY2FuIGJlIGRvbmUgd2l0aCBkaXJlY3Rpbywgbm8gY2FjaGUgKi8KQEAgLTc0Nyw2ICs3NzcsNyBAQAogCS5sbHNlZWsgPSBjaWZzX2xsc2VlaywKIAkuc2V0bGVhc2UgPSBjaWZzX3NldGxlYXNlLAogfTsKKwogY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBjaWZzX2ZpbGVfbm9icmxfb3BzID0gewogCS5yZWFkID0gZG9fc3luY19yZWFkLAogCS53cml0ZSA9IGRvX3N5bmNfd3JpdGUsCkBAIC03NjUsNiArNzk2LDI0IEBACiAJLnNldGxlYXNlID0gY2lmc19zZXRsZWFzZSwKIH07CiAKK2NvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgY2lmc19maWxlX3N0cmljdF9ub2JybF9vcHMgPSB7CisJLnJlYWQgPSBkb19zeW5jX3JlYWQsCisJLndyaXRlID0gZG9fc3luY193cml0ZSwKKwkuYWlvX3JlYWQgPSBjaWZzX3N0cmljdF9yZWFkdiwKKwkuYWlvX3dyaXRlID0gY2lmc19zdHJpY3Rfd3JpdGV2LAorCS5vcGVuID0gY2lmc19vcGVuLAorCS5yZWxlYXNlID0gY2lmc19jbG9zZSwKKwkuZnN5bmMgPSBjaWZzX3N0cmljdF9mc3luYywKKwkuZmx1c2ggPSBjaWZzX2ZsdXNoLAorCS5tbWFwID0gY2lmc19maWxlX3N0cmljdF9tbWFwLAorCS5zcGxpY2VfcmVhZCA9IGdlbmVyaWNfZmlsZV9zcGxpY2VfcmVhZCwKKwkubGxzZWVrID0gY2lmc19sbHNlZWssCisjaWZkZWYgQ09ORklHX0NJRlNfUE9TSVgKKwkudW5sb2NrZWRfaW9jdGwJPSBjaWZzX2lvY3RsLAorI2VuZGlmIC8qIENPTkZJR19DSUZTX1BPU0lYICovCisJLnNldGxlYXNlID0gY2lmc19zZXRsZWFzZSwKK307CisKIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgY2lmc19maWxlX2RpcmVjdF9ub2JybF9vcHMgPSB7CiAJLyogbm8gbW1hcCwgbm8gYWlvLCBubyByZWFkdiAtCiAJICAgQkIgcmVldmFsdWF0ZSB3aGV0aGVyIHRoZXkgY2FuIGJlIGRvbmUgd2l0aCBkaXJlY3Rpbywgbm8gY2FjaGUgKi8KZGlmZiAtLWdpdCBhL2ZzL2NpZnMvY2lmc2ZzLmggYi9mcy9jaWZzL2NpZnNmcy5oCmluZGV4IDg5N2IyYjIuLjRhMzMzMDIgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvY2lmc2ZzLmgKKysrIGIvZnMvY2lmcy9jaWZzZnMuaApAQCAtNjEsNiArNjEsNyBAQAogCQkgICAgICAgc3RydWN0IGRlbnRyeSAqKTsKIGV4dGVybiBpbnQgY2lmc19yZXZhbGlkYXRlX2ZpbGUoc3RydWN0IGZpbGUgKmZpbHApOwogZXh0ZXJuIGludCBjaWZzX3JldmFsaWRhdGVfZGVudHJ5KHN0cnVjdCBkZW50cnkgKik7CitleHRlcm4gdm9pZCBjaWZzX2ludmFsaWRhdGVfbWFwcGluZyhzdHJ1Y3QgaW5vZGUgKmlub2RlKTsKIGV4dGVybiBpbnQgY2lmc19nZXRhdHRyKHN0cnVjdCB2ZnNtb3VudCAqLCBzdHJ1Y3QgZGVudHJ5ICosIHN0cnVjdCBrc3RhdCAqKTsKIGV4dGVybiBpbnQgY2lmc19zZXRhdHRyKHN0cnVjdCBkZW50cnkgKiwgc3RydWN0IGlhdHRyICopOwogCkBAIC03MiwxOSArNzMsMjcgQEAKIC8qIEZ1bmN0aW9ucyByZWxhdGVkIHRvIGZpbGVzIGFuZCBkaXJlY3RvcmllcyAqLwogZXh0ZXJuIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgY2lmc19maWxlX29wczsKIGV4dGVybiBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGNpZnNfZmlsZV9kaXJlY3Rfb3BzOyAvKiBpZiBkaXJlY3RpbyBtbnQgKi8KLWV4dGVybiBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGNpZnNfZmlsZV9ub2JybF9vcHM7Ci1leHRlcm4gY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBjaWZzX2ZpbGVfZGlyZWN0X25vYnJsX29wczsgLyogbm8gYnJsb2NrcyAqLworZXh0ZXJuIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgY2lmc19maWxlX3N0cmljdF9vcHM7IC8qIGlmIHN0cmljdGlvIG1udCAqLworZXh0ZXJuIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgY2lmc19maWxlX25vYnJsX29wczsgLyogbm8gYnJsb2NrcyAqLworZXh0ZXJuIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgY2lmc19maWxlX2RpcmVjdF9ub2JybF9vcHM7CitleHRlcm4gY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBjaWZzX2ZpbGVfc3RyaWN0X25vYnJsX29wczsKIGV4dGVybiBpbnQgY2lmc19vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKTsKIGV4dGVybiBpbnQgY2lmc19jbG9zZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSk7CiBleHRlcm4gaW50IGNpZnNfY2xvc2VkaXIoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpOwogZXh0ZXJuIHNzaXplX3QgY2lmc191c2VyX3JlYWQoc3RydWN0IGZpbGUgKmZpbGUsIGNoYXIgX191c2VyICpyZWFkX2RhdGEsCi0JCQkgc2l6ZV90IHJlYWRfc2l6ZSwgbG9mZl90ICpwb2Zmc2V0KTsKKwkJCSAgICAgIHNpemVfdCByZWFkX3NpemUsIGxvZmZfdCAqcG9mZnNldCk7CitleHRlcm4gc3NpemVfdCBjaWZzX3N0cmljdF9yZWFkdihzdHJ1Y3Qga2lvY2IgKmlvY2IsIGNvbnN0IHN0cnVjdCBpb3ZlYyAqaW92LAorCQkJCSB1bnNpZ25lZCBsb25nIG5yX3NlZ3MsIGxvZmZfdCBwb3MpOwogZXh0ZXJuIHNzaXplX3QgY2lmc191c2VyX3dyaXRlKHN0cnVjdCBmaWxlICpmaWxlLCBjb25zdCBjaGFyIF9fdXNlciAqd3JpdGVfZGF0YSwKLQkJCSBzaXplX3Qgd3JpdGVfc2l6ZSwgbG9mZl90ICpwb2Zmc2V0KTsKKwkJCSAgICAgICBzaXplX3Qgd3JpdGVfc2l6ZSwgbG9mZl90ICpwb2Zmc2V0KTsKK2V4dGVybiBzc2l6ZV90IGNpZnNfc3RyaWN0X3dyaXRldihzdHJ1Y3Qga2lvY2IgKmlvY2IsIGNvbnN0IHN0cnVjdCBpb3ZlYyAqaW92LAorCQkJCSAgdW5zaWduZWQgbG9uZyBucl9zZWdzLCBsb2ZmX3QgcG9zKTsKIGV4dGVybiBpbnQgY2lmc19sb2NrKHN0cnVjdCBmaWxlICosIGludCwgc3RydWN0IGZpbGVfbG9jayAqKTsKIGV4dGVybiBpbnQgY2lmc19mc3luYyhzdHJ1Y3QgZmlsZSAqLCBpbnQpOworZXh0ZXJuIGludCBjaWZzX3N0cmljdF9mc3luYyhzdHJ1Y3QgZmlsZSAqLCBpbnQpOwogZXh0ZXJuIGludCBjaWZzX2ZsdXNoKHN0cnVjdCBmaWxlICosIGZsX293bmVyX3QgaWQpOwogZXh0ZXJuIGludCBjaWZzX2ZpbGVfbW1hcChzdHJ1Y3QgZmlsZSAqICwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICopOworZXh0ZXJuIGludCBjaWZzX2ZpbGVfc3RyaWN0X21tYXAoc3RydWN0IGZpbGUgKiAsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqKTsKIGV4dGVybiBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGNpZnNfZGlyX29wczsKIGV4dGVybiBpbnQgY2lmc19kaXJfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSk7CiBleHRlcm4gaW50IGNpZnNfcmVhZGRpcihzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqZGlyZW50cnksIGZpbGxkaXJfdCBmaWxsZGlyKTsKQEAgLTkzLDYgKzEwMiwxMiBAQAogZXh0ZXJuIGNvbnN0IHN0cnVjdCBkZW50cnlfb3BlcmF0aW9ucyBjaWZzX2RlbnRyeV9vcHM7CiBleHRlcm4gY29uc3Qgc3RydWN0IGRlbnRyeV9vcGVyYXRpb25zIGNpZnNfY2lfZGVudHJ5X29wczsKIAorI2lmZGVmIENPTkZJR19DSUZTX0RGU19VUENBTEwKK2V4dGVybiBzdHJ1Y3QgdmZzbW91bnQgKmNpZnNfZGZzX2RfYXV0b21vdW50KHN0cnVjdCBwYXRoICpwYXRoKTsKKyNlbHNlCisjZGVmaW5lIGNpZnNfZGZzX2RfYXV0b21vdW50IE5VTEwKKyNlbmRpZgorCiAvKiBGdW5jdGlvbnMgcmVsYXRlZCB0byBzeW1saW5rcyAqLwogZXh0ZXJuIHZvaWQgKmNpZnNfZm9sbG93X2xpbmsoc3RydWN0IGRlbnRyeSAqZGlyZW50cnksIHN0cnVjdCBuYW1laWRhdGEgKm5kKTsKIGV4dGVybiB2b2lkIGNpZnNfcHV0X2xpbmsoc3RydWN0IGRlbnRyeSAqZGlyZW50cnksCkBAIC0xMTIsNSArMTI3LDUgQEAKIGV4dGVybiBjb25zdCBzdHJ1Y3QgZXhwb3J0X29wZXJhdGlvbnMgY2lmc19leHBvcnRfb3BzOwogI2VuZGlmIC8qIEVYUEVSSU1FTlRBTCAqLwogCi0jZGVmaW5lIENJRlNfVkVSU0lPTiAgICIxLjY4IgorI2RlZmluZSBDSUZTX1ZFUlNJT04gICAiMS43MCIKICNlbmRpZgkJCQkvKiBfQ0lGU0ZTX0ggKi8KZGlmZiAtLWdpdCBhL2ZzL2NpZnMvY2lmc2dsb2IuaCBiL2ZzL2NpZnMvY2lmc2dsb2IuaAppbmRleCA2MDZjYThiLi4xN2FmYjBmIDEwMDY0NAotLS0gYS9mcy9jaWZzL2NpZnNnbG9iLmgKKysrIGIvZnMvY2lmcy9jaWZzZ2xvYi5oCkBAIC0xNjEsNDYgKzE2MSw0MSBAQAogCWludCBzcnZfY291bnQ7IC8qIHJlZmVyZW5jZSBjb3VudGVyICovCiAJLyogMTUgY2hhcmFjdGVyIHNlcnZlciBuYW1lICsgMHgyMCAxNnRoIGJ5dGUgaW5kaWNhdGluZyB0eXBlID0gc3J2ICovCiAJY2hhciBzZXJ2ZXJfUkZDMTAwMV9uYW1lW1JGQzEwMDFfTkFNRV9MRU5fV0lUSF9OVUxMXTsKKwllbnVtIHN0YXR1c0VudW0gdGNwU3RhdHVzOyAvKiB3aGF0IHdlIHRoaW5rIHRoZSBzdGF0dXMgaXMgKi8KIAljaGFyICpob3N0bmFtZTsgLyogaG9zdG5hbWUgcG9ydGlvbiBvZiBVTkMgc3RyaW5nICovCiAJc3RydWN0IHNvY2tldCAqc3NvY2tldDsKIAlzdHJ1Y3Qgc29ja2FkZHJfc3RvcmFnZSBkc3RhZGRyOwogCXN0cnVjdCBzb2NrYWRkcl9zdG9yYWdlIHNyY2FkZHI7IC8qIGxvY2FsbHkgYmluZCB0byB0aGlzIElQICovCisjaWZkZWYgQ09ORklHX05FVF9OUworCXN0cnVjdCBuZXQgKm5ldDsKKyNlbmRpZgogCXdhaXRfcXVldWVfaGVhZF90IHJlc3BvbnNlX3E7CiAJd2FpdF9xdWV1ZV9oZWFkX3QgcmVxdWVzdF9xOyAvKiBpZiBtb3JlIHRoYW4gbWF4bXB4IHRvIHNydnIgbXVzdCBibG9jayovCiAJc3RydWN0IGxpc3RfaGVhZCBwZW5kaW5nX21pZF9xOwotCXZvaWQgKlNlcnZlcl9ObHNJbmZvOwkvKiBCQiAtIHBsYWNlaG9sZGVyIGZvciBmdXR1cmUgTkxTIGluZm8gICovCi0JdW5zaWduZWQgc2hvcnQgc2VydmVyX2NvZGVwYWdlOwkvKiBjb2RlcGFnZSBmb3IgdGhlIHNlcnZlciAgICAqLwotCWVudW0gcHJvdG9jb2xFbnVtIHByb3RvY29sVHlwZTsKLQljaGFyIHZlcnNpb25NYWpvcjsKLQljaGFyIHZlcnNpb25NaW5vcjsKLQlib29sIHN2bG9jYWw6MTsJCQkvKiBsb2NhbCBzZXJ2ZXIgb3IgcmVtb3RlICovCiAJYm9vbCBub2Jsb2Nrc25kOwkJLyogdXNlIGJsb2NraW5nIHNlbmRtc2cgKi8KIAlib29sIG5vYXV0b3R1bmU7CQkvKiBkbyBub3QgYXV0b3R1bmUgc2VuZCBidWYgc2l6ZXMgKi8KIAlib29sIHRjcF9ub2RlbGF5OwogCWF0b21pY190IGluRmxpZ2h0OyAgLyogbnVtYmVyIG9mIHJlcXVlc3RzIG9uIHRoZSB3aXJlIHRvIHNlcnZlciAqLwotI2lmZGVmIENPTkZJR19DSUZTX1NUQVRTMgotCWF0b21pY190IGluU2VuZDsgLyogcmVxdWVzdHMgdHJ5aW5nIHRvIHNlbmQgKi8KLQlhdG9taWNfdCBudW1fd2FpdGVyczsgICAvKiBibG9ja2VkIHdhaXRpbmcgdG8gZ2V0IGluIHNlbmRyZWN2ICovCi0jZW5kaWYKLQllbnVtIHN0YXR1c0VudW0gdGNwU3RhdHVzOyAvKiB3aGF0IHdlIHRoaW5rIHRoZSBzdGF0dXMgaXMgKi8KIAlzdHJ1Y3QgbXV0ZXggc3J2X211dGV4OwogCXN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrOwogCWNoYXIgc2VydmVyX0dVSURbMTZdOwogCWNoYXIgc2VjTW9kZTsKKwlib29sIHNlc3Npb25fZXN0YWI7IC8qIG1hcmsgd2hlbiB2ZXJ5IGZpcnN0IHNlc3MgaXMgZXN0YWJsaXNoZWQgKi8KKwl1MTYgZGlhbGVjdDsgLyogZGlhbGVjdCBpbmRleCB0aGF0IHNlcnZlciBjaG9zZSAqLwogCWVudW0gc2VjdXJpdHlFbnVtIHNlY1R5cGU7CiAJdW5zaWduZWQgaW50IG1heFJlcTsJLyogQ2xpZW50cyBzaG91bGQgc3VibWl0IG5vIG1vcmUgKi8KIAkvKiB0aGFuIG1heFJlcSBkaXN0aW5jdCB1bmFuc3dlcmVkIFNNQnMgdG8gdGhlIHNlcnZlciB3aGVuIHVzaW5nICAqLwogCS8qIG11bHRpcGxleGVkIHJlYWRzIG9yIHdyaXRlcyAqLwogCXVuc2lnbmVkIGludCBtYXhCdWY7CS8qIG1heEJ1ZiBzcGVjaWZpZXMgdGhlIG1heGltdW0gKi8KIAkvKiBtZXNzYWdlIHNpemUgdGhlIHNlcnZlciBjYW4gc2VuZCBvciByZWNlaXZlIGZvciBub24tcmF3IFNNQnMgKi8KKwkvKiBtYXhCdWYgaXMgcmV0dXJuZWQgYnkgU01CIE5lZ290aWF0ZVByb3RvY29sIHNvIG1heEJ1ZiBpcyBvbmx5IDAgKi8KKwkvKiB3aGVuIHNvY2tldCBpcyBzZXR1cCAoYW5kIGR1cmluZyByZWNvbm5lY3QpIGJlZm9yZSBOZWdQcm90IHNlbnQgKi8KIAl1bnNpZ25lZCBpbnQgbWF4X3J3OwkvKiBtYXhSdyBzcGVjaWZpZXMgdGhlIG1heGltdW0gKi8KIAkvKiBtZXNzYWdlIHNpemUgdGhlIHNlcnZlciBjYW4gc2VuZCBvciByZWNlaXZlIGZvciAqLwogCS8qIFNNQl9DT01fV1JJVEVfUkFXIG9yIFNNQl9DT01fUkVBRF9SQVcuICovCiAJdW5zaWduZWQgaW50IG1heF92Y3M7CS8qIG1heGltdW0gbnVtYmVyIG9mIHNtYiBzZXNzaW9ucywgYXQgbGVhc3QKIAkJCQkgICB0aG9zZSB0aGF0IGNhbiBiZSBzcGVjaWZpZWQgdW5pcXVlbHkgd2l0aAogCQkJCSAgIHZjbnVtYmVycyAqLwotCWNoYXIgc2Vzc2lkWzRdOwkJLyogdW5pcXVlIHRva2VuIGlkIGZvciB0aGlzIHNlc3Npb24gKi8KLQkvKiAocmV0dXJuZWQgb24gTmVnb3RpYXRlICovCiAJaW50IGNhcGFiaWxpdGllczsgLyogYWxsb3cgc2VsZWN0aXZlIGRpc2FibGluZyBvZiBjYXBzIGJ5IHNtYiBzZXNzICovCiAJaW50IHRpbWVBZGo7ICAvKiBBZGp1c3QgZm9yIGRpZmZlcmVuY2UgaW4gc2VydmVyIHRpbWUgem9uZSBpbiBzZWMgKi8KIAlfX3UxNiBDdXJyZW50TWlkOyAgICAgICAgIC8qIG11bHRpcGxleCBpZCAtIHJvdGF0aW5nIGNvdW50ZXIgKi8KQEAgLTIxMCwyMCArMjA1LDUzIEBACiAJX191MzIgc2VxdWVuY2VfbnVtYmVyOyAvKiBmb3Igc2lnbmluZywgcHJvdGVjdGVkIGJ5IHNydl9tdXRleCAqLwogCXN0cnVjdCBzZXNzaW9uX2tleSBzZXNzaW9uX2tleTsKIAl1bnNpZ25lZCBsb25nIGxzdHJwOyAvKiB3aGVuIHdlIGdvdCBsYXN0IHJlc3BvbnNlIGZyb20gdGhpcyBzZXJ2ZXIgKi8KLQl1MTYgZGlhbGVjdDsgLyogZGlhbGVjdCBpbmRleCB0aGF0IHNlcnZlciBjaG9zZSAqLwogCXN0cnVjdCBjaWZzX3NlY21lY2ggc2VjbWVjaDsgLyogY3J5cHRvIHNlYyBtZWNoIGZ1bmN0cywgZGVzY3JpcHRvcnMgKi8KIAkvKiBleHRlbmRlZCBzZWN1cml0eSBmbGF2b3JzIHRoYXQgc2VydmVyIHN1cHBvcnRzICovCisJYm9vbAlzZWNfbnRsbXNzcDsJCS8qIHN1cHBvcnRzIE5UTE1TU1AgKi8KKwlib29sCXNlY19rZXJiZXJvc3UydTsJLyogc3VwcG9ydHMgVTJVIEtlcmJlcm9zICovCiAJYm9vbAlzZWNfa2VyYmVyb3M7CQkvKiBzdXBwb3J0cyBwbGFpbiBLZXJiZXJvcyAqLwogCWJvb2wJc2VjX21za2VyYmVyb3M7CQkvKiBzdXBwb3J0cyBsZWdhY3kgTVMgS2VyYmVyb3MgKi8KLQlib29sCXNlY19rZXJiZXJvc3UydTsJLyogc3VwcG9ydHMgVTJVIEtlcmJlcm9zICovCi0JYm9vbAlzZWNfbnRsbXNzcDsJCS8qIHN1cHBvcnRzIE5UTE1TU1AgKi8KLQlib29sIHNlc3Npb25fZXN0YWI7IC8qIG1hcmsgd2hlbiB2ZXJ5IGZpcnN0IHNlc3MgaXMgZXN0YWJsaXNoZWQgKi8KKwlzdHJ1Y3QgZGVsYXllZF93b3JrCWVjaG87IC8qIGVjaG8gcGluZyB3b3JrcXVldWUgam9iICovCiAjaWZkZWYgQ09ORklHX0NJRlNfRlNDQUNIRQogCXN0cnVjdCBmc2NhY2hlX2Nvb2tpZSAgICpmc2NhY2hlOyAvKiBjbGllbnQgaW5kZXggY2FjaGUgY29va2llICovCiAjZW5kaWYKKyNpZmRlZiBDT05GSUdfQ0lGU19TVEFUUzIKKwlhdG9taWNfdCBpblNlbmQ7IC8qIHJlcXVlc3RzIHRyeWluZyB0byBzZW5kICovCisJYXRvbWljX3QgbnVtX3dhaXRlcnM7ICAgLyogYmxvY2tlZCB3YWl0aW5nIHRvIGdldCBpbiBzZW5kcmVjdiAqLworI2VuZGlmCiB9OwogCiAvKgorICogTWFjcm9zIHRvIGFsbG93IHRoZSBUQ1BfU2VydmVyX0luZm8tPm5ldCBmaWVsZCBhbmQgcmVsYXRlZCBjb2RlIHRvIGRyb3Agb3V0CisgKiB3aGVuIENPTkZJR19ORVRfTlMgaXNuJ3Qgc2V0LgorICovCisKKyNpZmRlZiBDT05GSUdfTkVUX05TCisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IG5ldCAqY2lmc19uZXRfbnMoc3RydWN0IFRDUF9TZXJ2ZXJfSW5mbyAqc3J2KQoreworCXJldHVybiBzcnYtPm5ldDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGNpZnNfc2V0X25ldF9ucyhzdHJ1Y3QgVENQX1NlcnZlcl9JbmZvICpzcnYsIHN0cnVjdCBuZXQgKm5ldCkKK3sKKwlzcnYtPm5ldCA9IG5ldDsKK30KKworI2Vsc2UKKworc3RhdGljIGlubGluZSBzdHJ1Y3QgbmV0ICpjaWZzX25ldF9ucyhzdHJ1Y3QgVENQX1NlcnZlcl9JbmZvICpzcnYpCit7CisJcmV0dXJuICZpbml0X25ldDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGNpZnNfc2V0X25ldF9ucyhzdHJ1Y3QgVENQX1NlcnZlcl9JbmZvICpzcnYsIHN0cnVjdCBuZXQgKm5ldCkKK3sKK30KKworI2VuZGlmCisKKy8qCiAgKiBTZXNzaW9uIHN0cnVjdHVyZS4gIE9uZSBvZiB0aGVzZSBmb3IgZWFjaCB1aWQgc2Vzc2lvbiB3aXRoIGEgcGFydGljdWxhciBob3N0CiAgKi8KIHN0cnVjdCBjaWZzU2VzSW5mbyB7CkBAIC00NDYsMTEgKzQ3NCwxMSBAQAogCS8qIEJCIGFkZCBpbiBsaXN0cyBmb3IgZGlydHkgcGFnZXMgaS5lLiB3cml0ZSBjYWNoaW5nIGluZm8gZm9yIG9wbG9jayAqLwogCXN0cnVjdCBsaXN0X2hlYWQgb3BlbkZpbGVMaXN0OwogCV9fdTMyIGNpZnNBdHRyczsgLyogZS5nLiBET1MgYXJjaGl2ZSBiaXQsIHNwYXJzZSwgY29tcHJlc3NlZCwgc3lzdGVtICovCi0JdW5zaWduZWQgbG9uZyB0aW1lOwkvKiBqaWZmaWVzIG9mIGxhc3QgdXBkYXRlL2NoZWNrIG9mIGlub2RlICovCi0JYm9vbCBjbGllbnRDYW5DYWNoZVJlYWQ6MTsJLyogcmVhZCBvcGxvY2sgKi8KLQlib29sIGNsaWVudENhbkNhY2hlQWxsOjE7CS8qIHJlYWQgYW5kIHdyaXRlYmVoaW5kIG9wbG9jayAqLwotCWJvb2wgZGVsZXRlX3BlbmRpbmc6MTsJCS8qIERFTEVURV9PTl9DTE9TRSBpcyBzZXQgKi8KLQlib29sIGludmFsaWRfbWFwcGluZzoxOwkJLyogcGFnZWNhY2hlIGlzIGludmFsaWQgKi8KKwlib29sIGNsaWVudENhbkNhY2hlUmVhZDsJLyogcmVhZCBvcGxvY2sgKi8KKwlib29sIGNsaWVudENhbkNhY2hlQWxsOwkJLyogcmVhZCBhbmQgd3JpdGViZWhpbmQgb3Bsb2NrICovCisJYm9vbCBkZWxldGVfcGVuZGluZzsJCS8qIERFTEVURV9PTl9DTE9TRSBpcyBzZXQgKi8KKwlib29sIGludmFsaWRfbWFwcGluZzsJCS8qIHBhZ2VjYWNoZSBpcyBpbnZhbGlkICovCisJdW5zaWduZWQgbG9uZyB0aW1lOwkJLyogamlmZmllcyBvZiBsYXN0IHVwZGF0ZSBvZiBpbm9kZSAqLwogCXU2NCAgc2VydmVyX2VvZjsJCS8qIGN1cnJlbnQgZmlsZSBzaXplIG9uIHNlcnZlciAqLwogCXU2NCAgdW5pcXVlaWQ7CQkJLyogc2VydmVyIGlub2RlIG51bWJlciAqLwogCXU2NCAgY3JlYXRldGltZTsJCS8qIGNyZWF0aW9uIHRpbWUgb24gc2VydmVyICovCkBAIC01MDgsNiArNTM2LDE4IEBACiAKICNlbmRpZgogCitzdHJ1Y3QgbWlkX3FfZW50cnk7CisKKy8qCisgKiBUaGlzIGlzIHRoZSBwcm90b3R5cGUgZm9yIHRoZSBtaWQgY2FsbGJhY2sgZnVuY3Rpb24uIFdoZW4gY3JlYXRpbmcgb25lLAorICogdGFrZSBzcGVjaWFsIGNhcmUgdG8gYXZvaWQgZGVhZGxvY2tzLiBUaGluZ3MgdG8gYmVhciBpbiBtaW5kOgorICoKKyAqIC0gaXQgd2lsbCBiZSBjYWxsZWQgYnkgY2lmc2QKKyAqIC0gdGhlIEdsb2JhbE1pZF9Mb2NrIHdpbGwgYmUgaGVsZAorICogLSB0aGUgbWlkIHdpbGwgYmUgcmVtb3ZlZCBmcm9tIHRoZSBwZW5kaW5nX21pZF9xIGxpc3QKKyAqLwordHlwZWRlZiB2b2lkIChtaWRfY2FsbGJhY2tfdCkoc3RydWN0IG1pZF9xX2VudHJ5ICptaWQpOworCiAvKiBvbmUgb2YgdGhlc2UgZm9yIGV2ZXJ5IHBlbmRpbmcgQ0lGUyByZXF1ZXN0IHRvIHRoZSBzZXJ2ZXIgKi8KIHN0cnVjdCBtaWRfcV9lbnRyeSB7CiAJc3RydWN0IGxpc3RfaGVhZCBxaGVhZDsJLyogbWlkcyB3YWl0aW5nIG9uIHJlcGx5IGZyb20gdGhpcyBzZXJ2ZXIgKi8KQEAgLTUxOSw3ICs1NTksOCBAQAogCXVuc2lnbmVkIGxvbmcgd2hlbl9zZW50OyAvKiB0aW1lIHdoZW4gc21iIHNlbmQgZmluaXNoZWQgKi8KIAl1bnNpZ25lZCBsb25nIHdoZW5fcmVjZWl2ZWQ7IC8qIHdoZW4gZGVtdXggY29tcGxldGUgKHRha2VuIG9mZiB3aXJlKSAqLwogI2VuZGlmCi0Jc3RydWN0IHRhc2tfc3RydWN0ICp0c2s7CS8qIHRhc2sgd2FpdGluZyBmb3IgcmVzcG9uc2UgKi8KKwltaWRfY2FsbGJhY2tfdCAqY2FsbGJhY2s7IC8qIGNhbGwgY29tcGxldGlvbiBjYWxsYmFjayAqLworCXZvaWQgKmNhbGxiYWNrX2RhdGE7CSAgLyogZ2VuZXJhbCBwdXJwb3NlIHBvaW50ZXIgZm9yIGNhbGxiYWNrICovCiAJc3RydWN0IHNtYl9oZHIgKnJlc3BfYnVmOwkvKiByZXNwb25zZSBidWZmZXIgKi8KIAlpbnQgbWlkU3RhdGU7CS8qIHdpc2ggdGhpcyB3ZXJlIGVudW0gYnV0IGNhbiBub3QgcGFzcyB0byB3YWl0X2V2ZW50ICovCiAJX191OCBjb21tYW5kOwkvKiBzbWIgY29tbWFuZCBjb2RlICovCkBAIC02MTMsNyArNjU0LDcgQEAKICNkZWZpbmUgICBNSURfUkVRVUVTVF9TVUJNSVRURUQgMgogI2RlZmluZSAgIE1JRF9SRVNQT05TRV9SRUNFSVZFRCA0CiAjZGVmaW5lICAgTUlEX1JFVFJZX05FRURFRCAgICAgIDggLyogc2Vzc2lvbiBjbG9zZWQgd2hpbGUgdGhpcyByZXF1ZXN0IG91dCAqLwotI2RlZmluZSAgIE1JRF9OT19SRVNQX05FRURFRCAweDEwCisjZGVmaW5lICAgTUlEX1JFU1BPTlNFX01BTEZPUk1FRCAweDEwCiAKIC8qIFR5cGVzIG9mIHJlc3BvbnNlIGJ1ZmZlciByZXR1cm5lZCBmcm9tIFNlbmRSZWNlaXZlMiAqLwogI2RlZmluZSAgIENJRlNfTk9fQlVGRkVSICAgICAgICAwICAgIC8qIFJlc3BvbnNlIGJ1ZmZlciBub3QgcmV0dXJuZWQgKi8KQEAgLTYyMiwxMiArNjYzLDkgQEAKICNkZWZpbmUgICBDSUZTX0lPVkVDICAgICAgICAgICAgNCAgICAvKiBhcnJheSBvZiByZXNwb25zZSBidWZmZXJzICovCiAKIC8qIFR5cGUgb2YgUmVxdWVzdCB0byBTZW5kUmVjZWl2ZTIgKi8KLSNkZWZpbmUgICBDSUZTX1NURF9PUAkgICAgICAgIDAgICAgLyogbm9ybWFsIHJlcXVlc3QgdGltZW91dCAqLwotI2RlZmluZSAgIENJRlNfTE9OR19PUCAgICAgICAgICAxICAgIC8qIGxvbmcgb3AgKHVwIHRvIDQ1IHNlYywgb3Bsb2NrIHRpbWUpICovCi0jZGVmaW5lICAgQ0lGU19WTE9OR19PUCAgICAgICAgIDIgICAgLyogc2xvb3cgb3AgLSBjYW4gdGFrZSB1cCB0byAxODAgc2Vjb25kcyAqLwotI2RlZmluZSAgIENJRlNfQkxPQ0tJTkdfT1AgICAgICA0ICAgIC8qIG9wZXJhdGlvbiBjYW4gYmxvY2sgKi8KLSNkZWZpbmUgICBDSUZTX0FTWU5DX09QICAgICAgICAgOCAgICAvKiBkbyBub3Qgd2FpdCBmb3IgcmVzcG9uc2UgKi8KLSNkZWZpbmUgICBDSUZTX1RJTUVPVVRfTUFTSyAweDAwRiAgICAvKiBvbmx5IG9uZSBvZiA1IGFib3ZlIHNldCBpbiByZXEgKi8KKyNkZWZpbmUgICBDSUZTX0JMT0NLSU5HX09QICAgICAgMSAgICAvKiBvcGVyYXRpb24gY2FuIGJsb2NrICovCisjZGVmaW5lICAgQ0lGU19BU1lOQ19PUCAgICAgICAgIDIgICAgLyogZG8gbm90IHdhaXQgZm9yIHJlc3BvbnNlICovCisjZGVmaW5lICAgQ0lGU19USU1FT1VUX01BU0sgMHgwMDMgICAgLyogb25seSBvbmUgb2YgYWJvdmUgc2V0IGluIHJlcSAqLwogI2RlZmluZSAgIENJRlNfTE9HX0VSUk9SICAgIDB4MDEwICAgIC8qIGxvZyBOVCBTVEFUVVMgaWYgbm9uLXplcm8gKi8KICNkZWZpbmUgICBDSUZTX0xBUkdFX0JVRl9PUCAweDAyMCAgICAvKiBsYXJnZSByZXF1ZXN0IGJ1ZmZlciAqLwogI2RlZmluZSAgIENJRlNfTk9fUkVTUCAgICAgIDB4MDQwICAgIC8qIG5vIHJlc3BvbnNlIGJ1ZmZlciByZXF1aXJlZCAqLwpAQCAtNzkwLDYgKzgyOCw5IEBACiBHTE9CQUxfRVhURVJOIHVuc2lnbmVkIGludCBjaWZzX21pbl9zbWFsbDsgIC8qIG1pbiBzaXplIG9mIHNtYWxsIGJ1ZiBwb29sICovCiBHTE9CQUxfRVhURVJOIHVuc2lnbmVkIGludCBjaWZzX21heF9wZW5kaW5nOyAvKiBNQVggcmVxdWVzdHMgYXQgb25jZSB0byBzZXJ2ZXIqLwogCisvKiByZWNvbm5lY3QgYWZ0ZXIgdGhpcyBtYW55IGZhaWxlZCBlY2hvIGF0dGVtcHRzICovCitHTE9CQUxfRVhURVJOIHVuc2lnbmVkIHNob3J0IGVjaG9fcmV0cmllczsKKwogdm9pZCBjaWZzX29wbG9ja19icmVhayhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspOwogdm9pZCBjaWZzX29wbG9ja19icmVha19nZXQoc3RydWN0IGNpZnNGaWxlSW5mbyAqY2ZpbGUpOwogdm9pZCBjaWZzX29wbG9ja19icmVha19wdXQoc3RydWN0IGNpZnNGaWxlSW5mbyAqY2ZpbGUpOwpkaWZmIC0tZ2l0IGEvZnMvY2lmcy9jaWZzcGR1LmggYi9mcy9jaWZzL2NpZnNwZHUuaAppbmRleCBkZTM2YjA5Li5iNWM4Y2M1IDEwMDY0NAotLS0gYS9mcy9jaWZzL2NpZnNwZHUuaAorKysgYi9mcy9jaWZzL2NpZnNwZHUuaApAQCAtMjMsNiArMjMsNyBAQAogI2RlZmluZSBfQ0lGU1BEVV9ICiAKICNpbmNsdWRlIDxuZXQvc29jay5oPgorI2luY2x1ZGUgPGFzbS91bmFsaWduZWQuaD4KICNpbmNsdWRlICJzbWJmc2N0bC5oIgogCiAjaWZkZWYgQ09ORklHX0NJRlNfV0VBS19QV19IQVNICkBAIC01MCw2ICs1MSw3IEBACiAjZGVmaW5lIFNNQl9DT01fU0VUQVRUUiAgICAgICAgICAgICAgIDB4MDkgLyogdHJpdmlhbCByZXNwb25zZSAqLwogI2RlZmluZSBTTUJfQ09NX0xPQ0tJTkdfQU5EWCAgICAgICAgICAweDI0IC8qIHRyaXZpYWwgcmVzcG9uc2UgKi8KICNkZWZpbmUgU01CX0NPTV9DT1BZICAgICAgICAgICAgICAgICAgMHgyOSAvKiB0cml2aWFsIHJzcCwgZmFpbCBmaWxlbmFtZSBpZ25yZCovCisjZGVmaW5lIFNNQl9DT01fRUNITyAgICAgICAgICAgICAgICAgIDB4MkIgLyogZWNobyByZXF1ZXN0ICovCiAjZGVmaW5lIFNNQl9DT01fT1BFTl9BTkRYICAgICAgICAgICAgIDB4MkQgLyogTGVnYWN5IG9wZW4gZm9yIG9sZCBzZXJ2ZXJzICovCiAjZGVmaW5lIFNNQl9DT01fUkVBRF9BTkRYICAgICAgICAgICAgIDB4MkUKICNkZWZpbmUgU01CX0NPTV9XUklURV9BTkRYICAgICAgICAgICAgMHgyRgpAQCAtNDI1LDExICs0MjcsNDkgQEAKIAlfX3UxNiBNaWQ7CiAJX191OCBXb3JkQ291bnQ7CiB9IF9fYXR0cmlidXRlX18oKHBhY2tlZCkpOwotLyogZ2l2ZW4gYSBwb2ludGVyIHRvIGFuIHNtYl9oZHIgcmV0cmlldmUgdGhlIHZhbHVlIG9mIGJ5dGUgY291bnQgKi8KLSNkZWZpbmUgQkNDKHNtYl92YXIpICgqKF9fdTE2ICopKChjaGFyICopKHNtYl92YXIpICsgc2l6ZW9mKHN0cnVjdCBzbWJfaGRyKSArICgyICogKHNtYl92YXIpLT5Xb3JkQ291bnQpKSkKLSNkZWZpbmUgQkNDX0xFKHNtYl92YXIpICgqKF9fbGUxNiAqKSgoY2hhciAqKShzbWJfdmFyKSArIHNpemVvZihzdHJ1Y3Qgc21iX2hkcikgKyAoMiAqIChzbWJfdmFyKS0+V29yZENvdW50KSkpCisKKy8qIGdpdmVuIGEgcG9pbnRlciB0byBhbiBzbWJfaGRyIHJldHJpZXZlIGEgY2hhciBwb2ludGVyIHRvIHRoZSBieXRlIGNvdW50ICovCisjZGVmaW5lIEJDQyhzbWJfdmFyKSAoKHVuc2lnbmVkIGNoYXIgKikoc21iX3ZhcikgKyBzaXplb2Yoc3RydWN0IHNtYl9oZHIpICsgXAorCQkJICgyICogKHNtYl92YXIpLT5Xb3JkQ291bnQpKQorCiAvKiBnaXZlbiBhIHBvaW50ZXIgdG8gYW4gc21iX2hkciByZXRyaWV2ZSB0aGUgcG9pbnRlciB0byB0aGUgYnl0ZSBhcmVhICovCi0jZGVmaW5lIHBCeXRlQXJlYShzbWJfdmFyKSAoKHVuc2lnbmVkIGNoYXIgKikoc21iX3ZhcikgKyBzaXplb2Yoc3RydWN0IHNtYl9oZHIpICsgKDIgKiAoc21iX3ZhciktPldvcmRDb3VudCkgKyAyKQorI2RlZmluZSBwQnl0ZUFyZWEoc21iX3ZhcikgKEJDQyhzbWJfdmFyKSArIDIpCisKKy8qIGdldCB0aGUgY29udmVydGVkIEJ5dGVDb3VudCBmb3IgYSBTTUIgcGFja2V0IGFuZCByZXR1cm4gaXQgKi8KK3N0YXRpYyBpbmxpbmUgX191MTYKK2dldF9iY2Moc3RydWN0IHNtYl9oZHIgKmhkcikKK3sKKwlfX3UxNiAqYmNfcHRyID0gKF9fdTE2ICopQkNDKGhkcik7CisKKwlyZXR1cm4gZ2V0X3VuYWxpZ25lZChiY19wdHIpOworfQorCisvKiBnZXQgdGhlIHVuY29udmVydGVkIEJ5dGVDb3VudCBmb3IgYSBTTUIgcGFja2V0IGFuZCByZXR1cm4gaXQgKi8KK3N0YXRpYyBpbmxpbmUgX191MTYKK2dldF9iY2NfbGUoc3RydWN0IHNtYl9oZHIgKmhkcikKK3sKKwlfX2xlMTYgKmJjX3B0ciA9IChfX2xlMTYgKilCQ0MoaGRyKTsKKworCXJldHVybiBnZXRfdW5hbGlnbmVkX2xlMTYoYmNfcHRyKTsKK30KKworLyogc2V0IHRoZSBCeXRlQ291bnQgZm9yIGEgU01CIHBhY2tldCBpbiBob3N0LWJ5dGUgb3JkZXIgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZAorcHV0X2JjYyhfX3UxNiBjb3VudCwgc3RydWN0IHNtYl9oZHIgKmhkcikKK3sKKwlfX3UxNiAqYmNfcHRyID0gKF9fdTE2ICopQkNDKGhkcik7CisKKwlwdXRfdW5hbGlnbmVkKGNvdW50LCBiY19wdHIpOworfQorCisvKiBzZXQgdGhlIEJ5dGVDb3VudCBmb3IgYSBTTUIgcGFja2V0IGluIGxpdHRsZS1lbmRpYW4gKi8KK3N0YXRpYyBpbmxpbmUgdm9pZAorcHV0X2JjY19sZShfX3UxNiBjb3VudCwgc3RydWN0IHNtYl9oZHIgKmhkcikKK3sKKwlfX2xlMTYgKmJjX3B0ciA9IChfX2xlMTYgKilCQ0MoaGRyKTsKKworCXB1dF91bmFsaWduZWRfbGUxNihjb3VudCwgYmNfcHRyKTsKK30KIAogLyoKICAqIENvbXB1dGVyIE5hbWUgTGVuZ3RoIChzaW5jZSBOZXRiaW9zIG5hbWUgd2FzIGxlbmd0aCAxNiB3aXRoIGxhc3QgYnl0ZSAweDIwKQpAQCAtNzYwLDYgKzgwMCwyMCBAQAogICoKICAqLwogCit0eXBlZGVmIHN0cnVjdCBzbWJfY29tX2VjaG9fcmVxIHsKKwlzdHJ1Y3QJc21iX2hkciBoZHI7CisJX19sZTE2CUVjaG9Db3VudDsKKwlfX2xlMTYJQnl0ZUNvdW50OworCWNoYXIJRGF0YVsxXTsKK30gX19hdHRyaWJ1dGVfXygocGFja2VkKSkgRUNIT19SRVE7CisKK3R5cGVkZWYgc3RydWN0IHNtYl9jb21fZWNob19yc3AgeworCXN0cnVjdAlzbWJfaGRyIGhkcjsKKwlfX2xlMTYJU2VxdWVuY2VOdW1iZXI7CisJX19sZTE2CUJ5dGVDb3VudDsKKwljaGFyCURhdGFbMV07Cit9IF9fYXR0cmlidXRlX18oKHBhY2tlZCkpIEVDSE9fUlNQOworCiB0eXBlZGVmIHN0cnVjdCBzbWJfY29tX2xvZ29mZl9hbmR4X3JlcSB7CiAJc3RydWN0IHNtYl9oZHIgaGRyOwkvKiB3Y3QgPSAyICovCiAJX191OCBBbmRYQ29tbWFuZDsKZGlmZiAtLWdpdCBhL2ZzL2NpZnMvY2lmc3Byb3RvLmggYi9mcy9jaWZzL2NpZnNwcm90by5oCmluZGV4IGU2ZDE0ODEuLjgwOTZmMjcgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvY2lmc3Byb3RvLmgKKysrIGIvZnMvY2lmcy9jaWZzcHJvdG8uaApAQCAtNjEsNiArNjEsMTIgQEAKIAkJY29uc3QgY2hhciAqZnVsbHBhdGgsIGNvbnN0IHN0cnVjdCBkZnNfaW5mbzNfcGFyYW0gKnJlZiwKIAkJY2hhciAqKmRldm5hbWUpOwogLyogZXh0ZXJuIHZvaWQgcmVuZXdfcGFyZW50YWxfdGltZXN0YW1wcyhzdHJ1Y3QgZGVudHJ5ICpkaXJlbnRyeSk7Ki8KK2V4dGVybiBzdHJ1Y3QgbWlkX3FfZW50cnkgKkFsbG9jTWlkUUVudHJ5KGNvbnN0IHN0cnVjdCBzbWJfaGRyICpzbWJfYnVmZmVyLAorCQkJCQlzdHJ1Y3QgVENQX1NlcnZlcl9JbmZvICpzZXJ2ZXIpOworZXh0ZXJuIHZvaWQgRGVsZXRlTWlkUUVudHJ5KHN0cnVjdCBtaWRfcV9lbnRyeSAqbWlkRW50cnkpOworZXh0ZXJuIGludCBjaWZzX2NhbGxfYXN5bmMoc3RydWN0IFRDUF9TZXJ2ZXJfSW5mbyAqc2VydmVyLAorCQkJICAgc3RydWN0IHNtYl9oZHIgKmluX2J1ZiwgbWlkX2NhbGxiYWNrX3QgKmNhbGxiYWNrLAorCQkJICAgdm9pZCAqY2JkYXRhKTsKIGV4dGVybiBpbnQgU2VuZFJlY2VpdmUoY29uc3QgdW5zaWduZWQgaW50IC8qIHhpZCAqLyAsIHN0cnVjdCBjaWZzU2VzSW5mbyAqLAogCQkJc3RydWN0IHNtYl9oZHIgKiAvKiBpbnB1dCAqLyAsCiAJCQlzdHJ1Y3Qgc21iX2hkciAqIC8qIG91dCAqLyAsCkBAIC03OSw2ICs4NSw4IEBACiBleHRlcm4gYm9vbCBpc192YWxpZF9vcGxvY2tfYnJlYWsoc3RydWN0IHNtYl9oZHIgKnNtYiwKIAkJCQkgIHN0cnVjdCBUQ1BfU2VydmVyX0luZm8gKik7CiBleHRlcm4gYm9vbCBpc19zaXplX3NhZmVfdG9fY2hhbmdlKHN0cnVjdCBjaWZzSW5vZGVJbmZvICosIF9fdTY0IGVvZik7CitleHRlcm4gdm9pZCBjaWZzX3VwZGF0ZV9lb2Yoc3RydWN0IGNpZnNJbm9kZUluZm8gKmNpZnNpLCBsb2ZmX3Qgb2Zmc2V0LAorCQkJICAgIHVuc2lnbmVkIGludCBieXRlc193cml0dGVuKTsKIGV4dGVybiBzdHJ1Y3QgY2lmc0ZpbGVJbmZvICpmaW5kX3dyaXRhYmxlX2ZpbGUoc3RydWN0IGNpZnNJbm9kZUluZm8gKiwgYm9vbCk7CiBleHRlcm4gc3RydWN0IGNpZnNGaWxlSW5mbyAqZmluZF9yZWFkYWJsZV9maWxlKHN0cnVjdCBjaWZzSW5vZGVJbmZvICosIGJvb2wpOwogZXh0ZXJuIHVuc2lnbmVkIGludCBzbWJDYWxjU2l6ZShzdHJ1Y3Qgc21iX2hkciAqcHRyKTsKQEAgLTM0NywxMiArMzU1LDEzIEBACiAJCQljb25zdCBfX3UxNiBuZXRmaWQsIGNvbnN0IF9fdTY0IGxlbiwKIAkJCWNvbnN0IF9fdTY0IG9mZnNldCwgY29uc3QgX191MzIgbnVtVW5sb2NrLAogCQkJY29uc3QgX191MzIgbnVtTG9jaywgY29uc3QgX191OCBsb2NrVHlwZSwKLQkJCWNvbnN0IGJvb2wgd2FpdEZsYWcpOworCQkJY29uc3QgYm9vbCB3YWl0RmxhZywgY29uc3QgX191OCBvcGxvY2tfbGV2ZWwpOwogZXh0ZXJuIGludCBDSUZTU01CUG9zaXhMb2NrKGNvbnN0IGludCB4aWQsIHN0cnVjdCBjaWZzVGNvbkluZm8gKnRjb24sCiAJCQljb25zdCBfX3UxNiBzbWJfZmlsZV9pZCwgY29uc3QgaW50IGdldF9mbGFnLAogCQkJY29uc3QgX191NjQgbGVuLCBzdHJ1Y3QgZmlsZV9sb2NrICosCiAJCQljb25zdCBfX3UxNiBsb2NrX3R5cGUsIGNvbnN0IGJvb2wgd2FpdEZsYWcpOwogZXh0ZXJuIGludCBDSUZTU01CVERpcyhjb25zdCBpbnQgeGlkLCBzdHJ1Y3QgY2lmc1Rjb25JbmZvICp0Y29uKTsKK2V4dGVybiBpbnQgQ0lGU1NNQkVjaG8oc3RydWN0IFRDUF9TZXJ2ZXJfSW5mbyAqc2VydmVyKTsKIGV4dGVybiBpbnQgQ0lGU1NNQkxvZ29mZihjb25zdCBpbnQgeGlkLCBzdHJ1Y3QgY2lmc1Nlc0luZm8gKnNlcyk7CiAKIGV4dGVybiBzdHJ1Y3QgY2lmc1Nlc0luZm8gKnNlc0luZm9BbGxvYyh2b2lkKTsKQEAgLTM2Niw3ICszNzUsNyBAQAogZXh0ZXJuIGludCBjaWZzX3ZlcmlmeV9zaWduYXR1cmUoc3RydWN0IHNtYl9oZHIgKiwKIAkJCQkgc3RydWN0IFRDUF9TZXJ2ZXJfSW5mbyAqc2VydmVyLAogCQkJCV9fdTMyIGV4cGVjdGVkX3NlcXVlbmNlX251bWJlcik7Ci1leHRlcm4gdm9pZCBTTUJOVGVuY3J5cHQodW5zaWduZWQgY2hhciAqLCB1bnNpZ25lZCBjaGFyICosIHVuc2lnbmVkIGNoYXIgKik7CitleHRlcm4gaW50IFNNQk5UZW5jcnlwdCh1bnNpZ25lZCBjaGFyICosIHVuc2lnbmVkIGNoYXIgKiwgdW5zaWduZWQgY2hhciAqKTsKIGV4dGVybiBpbnQgc2V0dXBfbnRsbV9yZXNwb25zZShzdHJ1Y3QgY2lmc1Nlc0luZm8gKik7CiBleHRlcm4gaW50IHNldHVwX250bG12Ml9yc3Aoc3RydWN0IGNpZnNTZXNJbmZvICosIGNvbnN0IHN0cnVjdCBubHNfdGFibGUgKik7CiBleHRlcm4gaW50IGNpZnNfY3J5cHRvX3NoYXNoX2FsbG9jYXRlKHN0cnVjdCBUQ1BfU2VydmVyX0luZm8gKik7CkBAIC00MTYsNCArNDI1LDExIEBACiBleHRlcm4gaW50IENJRlNDaGVja01GU3ltbGluayhzdHJ1Y3QgY2lmc19mYXR0ciAqZmF0dHIsCiAJCWNvbnN0IHVuc2lnbmVkIGNoYXIgKnBhdGgsCiAJCXN0cnVjdCBjaWZzX3NiX2luZm8gKmNpZnNfc2IsIGludCB4aWQpOworZXh0ZXJuIGludCBtZGZvdXIodW5zaWduZWQgY2hhciAqLCB1bnNpZ25lZCBjaGFyICosIGludCk7CitleHRlcm4gaW50IEVfbWQ0aGFzaChjb25zdCB1bnNpZ25lZCBjaGFyICpwYXNzd2QsIHVuc2lnbmVkIGNoYXIgKnAxNik7CitleHRlcm4gdm9pZCBTTUJlbmNyeXB0KHVuc2lnbmVkIGNoYXIgKnBhc3N3ZCwgY29uc3QgdW5zaWduZWQgY2hhciAqYzgsCisJCQl1bnNpZ25lZCBjaGFyICpwMjQpOworZXh0ZXJuIHZvaWQgRV9QMTYodW5zaWduZWQgY2hhciAqcDE0LCB1bnNpZ25lZCBjaGFyICpwMTYpOworZXh0ZXJuIHZvaWQgRV9QMjQodW5zaWduZWQgY2hhciAqcDIxLCBjb25zdCB1bnNpZ25lZCBjaGFyICpjOCwKKwkJCXVuc2lnbmVkIGNoYXIgKnAyNCk7CiAjZW5kaWYJCQkvKiBfQ0lGU1BST1RPX0ggKi8KZGlmZiAtLWdpdCBhL2ZzL2NpZnMvY2lmc3NtYi5jIGIvZnMvY2lmcy9jaWZzc21iLmMKaW5kZXggMmY2Nzk1ZS4uOTA0YWE0NyAxMDA2NDQKLS0tIGEvZnMvY2lmcy9jaWZzc21iLmMKKysrIGIvZnMvY2lmcy9jaWZzc21iLmMKQEAgLTEzNiw5ICsxMzYsNiBAQAogCQl9CiAJfQogCi0JaWYgKHNlcy0+c3RhdHVzID09IENpZnNFeGl0aW5nKQotCQlyZXR1cm4gLUVJTzsKLQogCS8qCiAJICogR2l2ZSBkZW11bHRpcGxleCB0aHJlYWQgdXAgdG8gMTAgc2Vjb25kcyB0byByZWNvbm5lY3QsIHNob3VsZCBiZQogCSAqIGdyZWF0ZXIgdGhhbiBjaWZzIHNvY2tldCB0aW1lb3V0IHdoaWNoIGlzIDcgc2Vjb25kcwpAQCAtMTU2LDcgKzE1Myw3IEBACiAJCSAqIHJldHJ5aW5nIHVudGlsIHByb2Nlc3MgaXMga2lsbGVkIG9yIHNlcnZlciBjb21lcwogCQkgKiBiYWNrIG9uLWxpbmUKIAkJICovCi0JCWlmICghdGNvbi0+cmV0cnkgfHwgc2VzLT5zdGF0dXMgPT0gQ2lmc0V4aXRpbmcpIHsKKwkJaWYgKCF0Y29uLT5yZXRyeSkgewogCQkJY0ZZSSgxLCAiZ2F2ZSB1cCB3YWl0aW5nIG9uIHJlY29ubmVjdCBpbiBzbWJfaW5pdCIpOwogCQkJcmV0dXJuIC1FSE9TVERPV047CiAJCX0KQEAgLTMzMSwzNyArMzI4LDM1IEBACiAKIHN0YXRpYyBpbnQgdmFsaWRhdGVfdDIoc3RydWN0IHNtYl90Ml9yc3AgKnBTTUIpCiB7Ci0JaW50IHJjID0gLUVJTlZBTDsKLQlpbnQgdG90YWxfc2l6ZTsKLQljaGFyICpwQkNDOworCXVuc2lnbmVkIGludCB0b3RhbF9zaXplOwogCi0JLyogY2hlY2sgZm9yIHBsYXVzaWJsZSB3Y3QsIGJjYyBhbmQgdDIgZGF0YSBhbmQgcGFybSBzaXplcyAqLworCS8qIGNoZWNrIGZvciBwbGF1c2libGUgd2N0ICovCisJaWYgKHBTTUItPmhkci5Xb3JkQ291bnQgPCAxMCkKKwkJZ290byB2dDJfZXJyOworCiAJLyogY2hlY2sgZm9yIHBhcm0gYW5kIGRhdGEgb2Zmc2V0IGdvaW5nIGJleW9uZCBlbmQgb2Ygc21iICovCi0JaWYgKHBTTUItPmhkci5Xb3JkQ291bnQgPj0gMTApIHsKLQkJaWYgKChsZTE2X3RvX2NwdShwU01CLT50Ml9yc3AuUGFyYW1ldGVyT2Zmc2V0KSA8PSAxMDI0KSAmJgotCQkgICAobGUxNl90b19jcHUocFNNQi0+dDJfcnNwLkRhdGFPZmZzZXQpIDw9IDEwMjQpKSB7Ci0JCQkvKiBjaGVjayB0aGF0IGJjYyBpcyBhdCBsZWFzdCBhcyBiaWcgYXMgcGFybXMgKyBkYXRhICovCi0JCQkvKiBjaGVjayB0aGF0IGJjYyBpcyBsZXNzIHRoYW4gbmVnb3RpYXRlZCBzbWIgYnVmZmVyICovCi0JCQl0b3RhbF9zaXplID0gbGUxNl90b19jcHUocFNNQi0+dDJfcnNwLlBhcmFtZXRlckNvdW50KTsKLQkJCWlmICh0b3RhbF9zaXplIDwgNTEyKSB7Ci0JCQkJdG90YWxfc2l6ZSArPQotCQkJCQlsZTE2X3RvX2NwdShwU01CLT50Ml9yc3AuRGF0YUNvdW50KTsKLQkJCQkvKiBCQ0MgbGUgY29udmVydGVkIGluIFNlbmRSZWNlaXZlICovCi0JCQkJcEJDQyA9IChwU01CLT5oZHIuV29yZENvdW50ICogMikgKwotCQkJCQlzaXplb2Yoc3RydWN0IHNtYl9oZHIpICsKLQkJCQkJKGNoYXIgKilwU01COwotCQkJCWlmICgodG90YWxfc2l6ZSA8PSAoKih1MTYgKilwQkNDKSkgJiYKLQkJCQkgICAodG90YWxfc2l6ZSA8Ci0JCQkJCUNJRlNNYXhCdWZTaXplK01BWF9DSUZTX0hEUl9TSVpFKSkgewotCQkJCQlyZXR1cm4gMDsKLQkJCQl9Ci0JCQl9Ci0JCX0KLQl9CisJaWYgKGdldF91bmFsaWduZWRfbGUxNigmcFNNQi0+dDJfcnNwLlBhcmFtZXRlck9mZnNldCkgPiAxMDI0IHx8CisJICAgIGdldF91bmFsaWduZWRfbGUxNigmcFNNQi0+dDJfcnNwLkRhdGFPZmZzZXQpID4gMTAyNCkKKwkJZ290byB2dDJfZXJyOworCisJLyogY2hlY2sgdGhhdCBiY2MgaXMgYXQgbGVhc3QgYXMgYmlnIGFzIHBhcm1zICsgZGF0YSAqLworCS8qIGNoZWNrIHRoYXQgYmNjIGlzIGxlc3MgdGhhbiBuZWdvdGlhdGVkIHNtYiBidWZmZXIgKi8KKwl0b3RhbF9zaXplID0gZ2V0X3VuYWxpZ25lZF9sZTE2KCZwU01CLT50Ml9yc3AuUGFyYW1ldGVyQ291bnQpOworCWlmICh0b3RhbF9zaXplID49IDUxMikKKwkJZ290byB2dDJfZXJyOworCisJdG90YWxfc2l6ZSArPSBnZXRfdW5hbGlnbmVkX2xlMTYoJnBTTUItPnQyX3JzcC5EYXRhQ291bnQpOworCWlmICh0b3RhbF9zaXplID4gZ2V0X2JjYygmcFNNQi0+aGRyKSB8fAorCSAgICB0b3RhbF9zaXplID49IENJRlNNYXhCdWZTaXplICsgTUFYX0NJRlNfSERSX1NJWkUpCisJCWdvdG8gdnQyX2VycjsKKworCXJldHVybiAwOwordnQyX2VycjoKIAljaWZzX2R1bXBfbWVtKCJJbnZhbGlkIHRyYW5zYWN0MiBTTUI6ICIsIChjaGFyICopcFNNQiwKIAkJc2l6ZW9mKHN0cnVjdCBzbWJfdDJfcnNwKSArIDE2KTsKLQlyZXR1cm4gcmM7CisJcmV0dXJuIC1FSU5WQUw7CiB9CisKIGludAogQ0lGU1NNQk5lZ290aWF0ZSh1bnNpZ25lZCBpbnQgeGlkLCBzdHJ1Y3QgY2lmc1Nlc0luZm8gKnNlcykKIHsKQEAgLTQ1Miw3ICs0NDcsNiBAQAogCQlzZXJ2ZXItPm1heEJ1ZiA9IG1pbigoX191MzIpbGUxNl90b19jcHUocnNwLT5NYXhCdWZTaXplKSwKIAkJCQkoX191MzIpQ0lGU01heEJ1ZlNpemUgKyBNQVhfQ0lGU19IRFJfU0laRSk7CiAJCXNlcnZlci0+bWF4X3ZjcyA9IGxlMTZfdG9fY3B1KHJzcC0+TWF4TnVtYmVyVmNzKTsKLQkJR0VUVTMyKHNlcnZlci0+c2Vzc2lkKSA9IGxlMzJfdG9fY3B1KHJzcC0+U2Vzc2lvbktleSk7CiAJCS8qIGV2ZW4gdGhvdWdoIHdlIGRvIG5vdCB1c2UgcmF3IHdlIG1pZ2h0IGFzIHdlbGwgc2V0IHRoaXMKIAkJYWNjdXJhdGVseSwgaW4gY2FzZSB3ZSBldmVyIGZpbmQgYSBuZWVkIGZvciBpdCAqLwogCQlpZiAoKGxlMTZfdG9fY3B1KHJzcC0+UmF3TW9kZSkgJiBSQVdfRU5BQkxFKSA9PSBSQVdfRU5BQkxFKSB7CkBAIC01NjYsNyArNTYwLDYgQEAKIAkJCShfX3UzMikgQ0lGU01heEJ1ZlNpemUgKyBNQVhfQ0lGU19IRFJfU0laRSk7CiAJc2VydmVyLT5tYXhfcncgPSBsZTMyX3RvX2NwdShwU01Cci0+TWF4UmF3U2l6ZSk7CiAJY0ZZSShEQkcyLCAiTWF4IGJ1ZiA9ICVkIiwgc2VzLT5zZXJ2ZXItPm1heEJ1Zik7Ci0JR0VUVTMyKHNlcy0+c2VydmVyLT5zZXNzaWQpID0gbGUzMl90b19jcHUocFNNQnItPlNlc3Npb25LZXkpOwogCXNlcnZlci0+Y2FwYWJpbGl0aWVzID0gbGUzMl90b19jcHUocFNNQnItPkNhcGFiaWxpdGllcyk7CiAJc2VydmVyLT50aW1lQWRqID0gKGludCkoX19zMTYpbGUxNl90b19jcHUocFNNQnItPlNlcnZlclRpbWVab25lKTsKIAlzZXJ2ZXItPnRpbWVBZGogKj0gNjA7CkBAIC03MDYsNiArNjk5LDUzIEBACiAJcmV0dXJuIHJjOwogfQogCisvKgorICogVGhpcyBpcyBhIG5vLW9wIGZvciBub3cuIFdlJ3JlIG5vdCByZWFsbHkgaW50ZXJlc3RlZCBpbiB0aGUgcmVwbHksIGJ1dAorICogcmF0aGVyIGluIHRoZSBmYWN0IHRoYXQgdGhlIHNlcnZlciBzZW50IG9uZSBhbmQgdGhhdCBzZXJ2ZXItPmxzdHJwCisgKiBnZXRzIHVwZGF0ZWQuCisgKgorICogRklYTUU6IG1heWJlIHdlIHNob3VsZCBjb25zaWRlciBjaGVja2luZyB0aGF0IHRoZSByZXBseSBtYXRjaGVzIHJlcXVlc3Q/CisgKi8KK3N0YXRpYyB2b2lkCitjaWZzX2VjaG9fY2FsbGJhY2soc3RydWN0IG1pZF9xX2VudHJ5ICptaWQpCit7CisJc3RydWN0IFRDUF9TZXJ2ZXJfSW5mbyAqc2VydmVyID0gbWlkLT5jYWxsYmFja19kYXRhOworCisJRGVsZXRlTWlkUUVudHJ5KG1pZCk7CisJYXRvbWljX2RlYygmc2VydmVyLT5pbkZsaWdodCk7CisJd2FrZV91cCgmc2VydmVyLT5yZXF1ZXN0X3EpOworfQorCitpbnQKK0NJRlNTTUJFY2hvKHN0cnVjdCBUQ1BfU2VydmVyX0luZm8gKnNlcnZlcikKK3sKKwlFQ0hPX1JFUSAqc21iOworCWludCByYyA9IDA7CisKKwljRllJKDEsICJJbiBlY2hvIHJlcXVlc3QiKTsKKworCXJjID0gc21hbGxfc21iX2luaXQoU01CX0NPTV9FQ0hPLCAwLCBOVUxMLCAodm9pZCAqKikmc21iKTsKKwlpZiAocmMpCisJCXJldHVybiByYzsKKworCS8qIHNldCB1cCBlY2hvIHJlcXVlc3QgKi8KKwlzbWItPmhkci5UaWQgPSBjcHVfdG9fbGUxNigweGZmZmYpOworCXNtYi0+aGRyLldvcmRDb3VudCA9IDE7CisJcHV0X3VuYWxpZ25lZF9sZTE2KDEsICZzbWItPkVjaG9Db3VudCk7CisJcHV0X2JjY19sZSgxLCAmc21iLT5oZHIpOworCXNtYi0+RGF0YVswXSA9ICdhJzsKKwlzbWItPmhkci5zbWJfYnVmX2xlbmd0aCArPSAzOworCisJcmMgPSBjaWZzX2NhbGxfYXN5bmMoc2VydmVyLCAoc3RydWN0IHNtYl9oZHIgKilzbWIsCisJCQkJY2lmc19lY2hvX2NhbGxiYWNrLCBzZXJ2ZXIpOworCWlmIChyYykKKwkJY0ZZSSgxLCAiRWNobyByZXF1ZXN0IGZhaWxlZDogJWQiLCByYyk7CisKKwljaWZzX3NtYWxsX2J1Zl9yZWxlYXNlKHNtYik7CisKKwlyZXR1cm4gcmM7Cit9CisKIGludAogQ0lGU1NNQkxvZ29mZihjb25zdCBpbnQgeGlkLCBzdHJ1Y3QgY2lmc1Nlc0luZm8gKnNlcykKIHsKQEAgLTExOTMsNyArMTIzMyw3IEBACiAJcFNNQi0+Qnl0ZUNvdW50ID0gY3B1X3RvX2xlMTYoY291bnQpOwogCS8qIGxvbmdfb3Agc2V0IHRvIDEgdG8gYWxsb3cgZm9yIG9wbG9jayBicmVhayB0aW1lb3V0cyAqLwogCXJjID0gU2VuZFJlY2VpdmUoeGlkLCB0Y29uLT5zZXMsIChzdHJ1Y3Qgc21iX2hkciAqKSBwU01CLAotCQkJKHN0cnVjdCBzbWJfaGRyICopcFNNQnIsICZieXRlc19yZXR1cm5lZCwgQ0lGU19MT05HX09QKTsKKwkJCShzdHJ1Y3Qgc21iX2hkciAqKXBTTUJyLCAmYnl0ZXNfcmV0dXJuZWQsIDApOwogCWNpZnNfc3RhdHNfaW5jKCZ0Y29uLT5udW1fb3BlbnMpOwogCWlmIChyYykgewogCQljRllJKDEsICJFcnJvciBpbiBPcGVuID0gJWQiLCByYyk7CkBAIC0xMzA2LDcgKzEzNDYsNyBAQAogCXBTTUItPkJ5dGVDb3VudCA9IGNwdV90b19sZTE2KGNvdW50KTsKIAkvKiBsb25nX29wIHNldCB0byAxIHRvIGFsbG93IGZvciBvcGxvY2sgYnJlYWsgdGltZW91dHMgKi8KIAlyYyA9IFNlbmRSZWNlaXZlKHhpZCwgdGNvbi0+c2VzLCAoc3RydWN0IHNtYl9oZHIgKikgcFNNQiwKLQkJCShzdHJ1Y3Qgc21iX2hkciAqKXBTTUJyLCAmYnl0ZXNfcmV0dXJuZWQsIENJRlNfTE9OR19PUCk7CisJCQkoc3RydWN0IHNtYl9oZHIgKilwU01CciwgJmJ5dGVzX3JldHVybmVkLCAwKTsKIAljaWZzX3N0YXRzX2luYygmdGNvbi0+bnVtX29wZW5zKTsKIAlpZiAocmMpIHsKIAkJY0ZZSSgxLCAiRXJyb3IgaW4gT3BlbiA9ICVkIiwgcmMpOwpAQCAtMTM4OCw3ICsxNDI4LDcgQEAKIAlpb3ZbMF0uaW92X2Jhc2UgPSAoY2hhciAqKXBTTUI7CiAJaW92WzBdLmlvdl9sZW4gPSBwU01CLT5oZHIuc21iX2J1Zl9sZW5ndGggKyA0OwogCXJjID0gU2VuZFJlY2VpdmUyKHhpZCwgdGNvbi0+c2VzLCBpb3YsIDEgLyogbnVtIGlvdmVjcyAqLywKLQkJCSAmcmVzcF9idWZfdHlwZSwgQ0lGU19TVERfT1AgfCBDSUZTX0xPR19FUlJPUik7CisJCQkgJnJlc3BfYnVmX3R5cGUsIENJRlNfTE9HX0VSUk9SKTsKIAljaWZzX3N0YXRzX2luYygmdGNvbi0+bnVtX3JlYWRzKTsKIAlwU01CciA9IChSRUFEX1JTUCAqKWlvdlswXS5pb3ZfYmFzZTsKIAlpZiAocmMpIHsKQEAgLTE2NjMsNyArMTcwMyw4IEBACiBDSUZTU01CTG9jayhjb25zdCBpbnQgeGlkLCBzdHJ1Y3QgY2lmc1Rjb25JbmZvICp0Y29uLAogCSAgICBjb25zdCBfX3UxNiBzbWJfZmlsZV9pZCwgY29uc3QgX191NjQgbGVuLAogCSAgICBjb25zdCBfX3U2NCBvZmZzZXQsIGNvbnN0IF9fdTMyIG51bVVubG9jaywKLQkgICAgY29uc3QgX191MzIgbnVtTG9jaywgY29uc3QgX191OCBsb2NrVHlwZSwgY29uc3QgYm9vbCB3YWl0RmxhZykKKwkgICAgY29uc3QgX191MzIgbnVtTG9jaywgY29uc3QgX191OCBsb2NrVHlwZSwKKwkgICAgY29uc3QgYm9vbCB3YWl0RmxhZywgY29uc3QgX191OCBvcGxvY2tfbGV2ZWwpCiB7CiAJaW50IHJjID0gMDsKIAlMT0NLX1JFUSAqcFNNQiA9IE5VTEw7CkBAIC0xNjkxLDYgKzE3MzIsNyBAQAogCXBTTUItPk51bWJlck9mTG9ja3MgPSBjcHVfdG9fbGUxNihudW1Mb2NrKTsKIAlwU01CLT5OdW1iZXJPZlVubG9ja3MgPSBjcHVfdG9fbGUxNihudW1VbmxvY2spOwogCXBTTUItPkxvY2tUeXBlID0gbG9ja1R5cGU7CisJcFNNQi0+T3Bsb2NrTGV2ZWwgPSBvcGxvY2tfbGV2ZWw7CiAJcFNNQi0+QW5kWENvbW1hbmQgPSAweEZGOwkvKiBub25lICovCiAJcFNNQi0+RmlkID0gc21iX2ZpbGVfaWQ7IC8qIG5ldGZpZCBzdGF5cyBsZSAqLwogCkBAIC0zMDg3LDcgKzMxMjksNyBAQAogCWlvdlswXS5pb3ZfbGVuID0gcFNNQi0+aGRyLnNtYl9idWZfbGVuZ3RoICsgNDsKIAogCXJjID0gU2VuZFJlY2VpdmUyKHhpZCwgdGNvbi0+c2VzLCBpb3YsIDEgLyogbnVtIGlvdmVjICovLCAmYnVmX3R5cGUsCi0JCQkgQ0lGU19TVERfT1ApOworCQkJIDApOwogCWNpZnNfc3RhdHNfaW5jKCZ0Y29uLT5udW1fYWNsX2dldCk7CiAJaWYgKHJjKSB7CiAJCWNGWUkoMSwgIlNlbmQgZXJyb3IgaW4gUXVlcnlTZWNEZXNjID0gJWQiLCByYyk7CkBAIC00ODY5LDcgKzQ5MTEsNiBAQAogCQkgICBfX3UxNiBmaWQsIF9fdTMyIHBpZF9vZl9vcGVuZXIsIGJvb2wgU2V0QWxsb2NhdGlvbikKIHsKIAlzdHJ1Y3Qgc21iX2NvbV90cmFuc2FjdGlvbjJfc2ZpX3JlcSAqcFNNQiAgPSBOVUxMOwotCWNoYXIgKmRhdGFfb2Zmc2V0OwogCXN0cnVjdCBmaWxlX2VuZF9vZl9maWxlX2luZm8gKnBhcm1fZGF0YTsKIAlpbnQgcmMgPSAwOwogCV9fdTE2IHBhcmFtcywgcGFyYW1fb2Zmc2V0LCBvZmZzZXQsIGJ5dGVfY291bnQsIGNvdW50OwpAQCAtNDg5Myw4ICs0OTM0LDYgQEAKIAlwYXJhbV9vZmZzZXQgPSBvZmZzZXRvZihzdHJ1Y3Qgc21iX2NvbV90cmFuc2FjdGlvbjJfc2ZpX3JlcSwgRmlkKSAtIDQ7CiAJb2Zmc2V0ID0gcGFyYW1fb2Zmc2V0ICsgcGFyYW1zOwogCi0JZGF0YV9vZmZzZXQgPSAoY2hhciAqKSAoJnBTTUItPmhkci5Qcm90b2NvbCkgKyBvZmZzZXQ7Ci0KIAljb3VudCA9IHNpemVvZihzdHJ1Y3QgZmlsZV9lbmRfb2ZfZmlsZV9pbmZvKTsKIAlwU01CLT5NYXhQYXJhbWV0ZXJDb3VudCA9IGNwdV90b19sZTE2KDIpOwogCS8qIEJCIGZpbmQgZXhhY3QgbWF4IFNNQiBQRFUgZnJvbSBzZXNzIHN0cnVjdHVyZSBCQiAqLwpAQCAtNTU2Miw3ICs1NjAxLDcgQEAKIAl9CiAKIAkvKiBtYWtlIHN1cmUgbGlzdF9sZW4gZG9lc24ndCBnbyBwYXN0IGVuZCBvZiBTTUIgKi8KLQllbmRfb2Zfc21iID0gKGNoYXIgKilwQnl0ZUFyZWEoJnBTTUJyLT5oZHIpICsgQkNDKCZwU01Cci0+aGRyKTsKKwllbmRfb2Zfc21iID0gKGNoYXIgKilwQnl0ZUFyZWEoJnBTTUJyLT5oZHIpICsgZ2V0X2JjYygmcFNNQnItPmhkcik7CiAJaWYgKChjaGFyICopZWFfcmVzcG9uc2VfZGF0YSArIGxpc3RfbGVuID4gZW5kX29mX3NtYikgewogCQljRllJKDEsICJFQSBsaXN0IGFwcGVhcnMgdG8gZ28gYmV5b25kIFNNQiIpOwogCQlyYyA9IC1FSU87CmRpZmYgLS1naXQgYS9mcy9jaWZzL2Nvbm5lY3QuYyBiL2ZzL2NpZnMvY29ubmVjdC5jCmluZGV4IGE2NWQzMTEuLjhkNmMxN2EgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvY29ubmVjdC5jCisrKyBiL2ZzL2NpZnMvY29ubmVjdC5jCkBAIC01Miw4ICs1Miw4IEBACiAjZGVmaW5lIENJRlNfUE9SVCA0NDUKICNkZWZpbmUgUkZDMTAwMV9QT1JUIDEzOQogCi1leHRlcm4gdm9pZCBTTUJOVGVuY3J5cHQodW5zaWduZWQgY2hhciAqcGFzc3dkLCB1bnNpZ25lZCBjaGFyICpjOCwKLQkJCSB1bnNpZ25lZCBjaGFyICpwMjQpOworLyogU01CIGVjaG8gInRpbWVvdXQiIC0tIEZJWE1FOiB0dW5hYmxlPyAqLworI2RlZmluZSBTTUJfRUNIT19JTlRFUlZBTCAoNjAgKiBIWikKIAogZXh0ZXJuIG1lbXBvb2xfdCAqY2lmc19yZXFfcG9vbHA7CiAKQEAgLTg0LDYgKzg0LDcgQEAKIAlib29sIG5vX3hhdHRyOjE7ICAgLyogc2V0IGlmIHhhdHRyIChFQSkgc3VwcG9ydCBzaG91bGQgYmUgZGlzYWJsZWQqLwogCWJvb2wgc2VydmVyX2lubzoxOyAvKiB1c2UgaW5vZGUgbnVtYmVycyBmcm9tIHNlcnZlciBpZSBVbmlxdWVJZCAqLwogCWJvb2wgZGlyZWN0X2lvOjE7CisJYm9vbCBzdHJpY3RfaW86MTsgLyogc3RyaWN0IGNhY2hlIGJlaGF2aW9yICovCiAJYm9vbCByZW1hcDoxOyAgICAgIC8qIHNldCB0byByZW1hcCBzZXZlbiByZXNlcnZlZCBjaGFycyBpbiBmaWxlbmFtZXMgKi8KIAlib29sIHBvc2l4X3BhdGhzOjE7IC8qIHVuc2V0IHRvIG5vdCBhc2sgZm9yIHBvc2l4IHBhdGhuYW1lcy4gKi8KIAlib29sIG5vX2xpbnV4X2V4dDoxOwpAQCAtMTUyLDYgKzE1Myw3IEBACiAKIAkvKiBiZWZvcmUgcmVjb25uZWN0aW5nIHRoZSB0Y3Agc2Vzc2lvbiwgbWFyayB0aGUgc21iIHNlc3Npb24gKHVpZCkKIAkJYW5kIHRoZSB0aWQgYmFkIHNvIHRoZXkgYXJlIG5vdCB1c2VkIHVudGlsIHJlY29ubmVjdGVkICovCisJY0ZZSSgxLCAiJXM6IG1hcmtpbmcgc2Vzc2lvbnMgYW5kIHRjb25zIGZvciByZWNvbm5lY3QiLCBfX2Z1bmNfXyk7CiAJc3Bpbl9sb2NrKCZjaWZzX3RjcF9zZXNfbG9jayk7CiAJbGlzdF9mb3JfZWFjaCh0bXAsICZzZXJ2ZXItPnNtYl9zZXNfbGlzdCkgewogCQlzZXMgPSBsaXN0X2VudHJ5KHRtcCwgc3RydWN0IGNpZnNTZXNJbmZvLCBzbWJfc2VzX2xpc3QpOwpAQCAtMTYzLDcgKzE2NSw5IEBACiAJCX0KIAl9CiAJc3Bpbl91bmxvY2soJmNpZnNfdGNwX3Nlc19sb2NrKTsKKwogCS8qIGRvIG5vdCB3YW50IHRvIGJlIHNlbmRpbmcgZGF0YSBvbiBhIHNvY2tldCB3ZSBhcmUgZnJlZWluZyAqLworCWNGWUkoMSwgIiVzOiB0ZWFyaW5nIGRvd24gc29ja2V0IiwgX19mdW5jX18pOwogCW11dGV4X2xvY2soJnNlcnZlci0+c3J2X211dGV4KTsKIAlpZiAoc2VydmVyLT5zc29ja2V0KSB7CiAJCWNGWUkoMSwgIlN0YXRlOiAweCV4IEZsYWdzOiAweCVseCIsIHNlcnZlci0+c3NvY2tldC0+c3RhdGUsCkBAIC0xODAsMjIgKzE4NCwyMCBAQAogCWtmcmVlKHNlcnZlci0+c2Vzc2lvbl9rZXkucmVzcG9uc2UpOwogCXNlcnZlci0+c2Vzc2lvbl9rZXkucmVzcG9uc2UgPSBOVUxMOwogCXNlcnZlci0+c2Vzc2lvbl9rZXkubGVuID0gMDsKKwlzZXJ2ZXItPmxzdHJwID0gamlmZmllczsKKwltdXRleF91bmxvY2soJnNlcnZlci0+c3J2X211dGV4KTsKIAorCS8qIG1hcmsgc3VibWl0dGVkIE1JRHMgZm9yIHJldHJ5IGFuZCBpc3N1ZSBjYWxsYmFjayAqLworCWNGWUkoMSwgIiVzOiBpc3N1aW5nIG1pZCBjYWxsYmFja3MiLCBfX2Z1bmNfXyk7CiAJc3Bpbl9sb2NrKCZHbG9iYWxNaWRfTG9jayk7Ci0JbGlzdF9mb3JfZWFjaCh0bXAsICZzZXJ2ZXItPnBlbmRpbmdfbWlkX3EpIHsKLQkJbWlkX2VudHJ5ID0gbGlzdF9lbnRyeSh0bXAsIHN0cnVjdAotCQkJCQltaWRfcV9lbnRyeSwKLQkJCQkJcWhlYWQpOwotCQlpZiAobWlkX2VudHJ5LT5taWRTdGF0ZSA9PSBNSURfUkVRVUVTVF9TVUJNSVRURUQpIHsKLQkJCQkvKiBNYXJrIG90aGVyIGludHJhbnNpdCByZXF1ZXN0cyBhcyBuZWVkaW5nCi0JCQkJICAgcmV0cnkgc28gd2UgZG8gbm90IGltbWVkaWF0ZWx5IG1hcmsgdGhlCi0JCQkJICAgc2Vzc2lvbiBiYWQgYWdhaW4gKGllIGFmdGVyIHdlIHJlY29ubmVjdAotCQkJCSAgIGJlbG93KSBhcyB0aGV5IHRpbWVvdXQgdG9vICovCisJbGlzdF9mb3JfZWFjaF9zYWZlKHRtcCwgdG1wMiwgJnNlcnZlci0+cGVuZGluZ19taWRfcSkgeworCQltaWRfZW50cnkgPSBsaXN0X2VudHJ5KHRtcCwgc3RydWN0IG1pZF9xX2VudHJ5LCBxaGVhZCk7CisJCWlmIChtaWRfZW50cnktPm1pZFN0YXRlID09IE1JRF9SRVFVRVNUX1NVQk1JVFRFRCkKIAkJCW1pZF9lbnRyeS0+bWlkU3RhdGUgPSBNSURfUkVUUllfTkVFREVEOwotCQl9CisJCWxpc3RfZGVsX2luaXQoJm1pZF9lbnRyeS0+cWhlYWQpOworCQltaWRfZW50cnktPmNhbGxiYWNrKG1pZF9lbnRyeSk7CiAJfQogCXNwaW5fdW5sb2NrKCZHbG9iYWxNaWRfTG9jayk7Ci0JbXV0ZXhfdW5sb2NrKCZzZXJ2ZXItPnNydl9tdXRleCk7CiAKIAl3aGlsZSAoKHNlcnZlci0+dGNwU3RhdHVzICE9IENpZnNFeGl0aW5nKSAmJgogCSAgICAgICAoc2VydmVyLT50Y3BTdGF0dXMgIT0gQ2lmc0dvb2QpKSB7CkBAIC0yMTIsMTAgKzIxNCw5IEBACiAJCQlpZiAoc2VydmVyLT50Y3BTdGF0dXMgIT0gQ2lmc0V4aXRpbmcpCiAJCQkJc2VydmVyLT50Y3BTdGF0dXMgPSBDaWZzR29vZDsKIAkJCXNwaW5fdW5sb2NrKCZHbG9iYWxNaWRfTG9jayk7Ci0JLyoJCWF0b21pY19zZXQoJnNlcnZlci0+aW5GbGlnaHQsMCk7Ki8KLQkJCXdha2VfdXAoJnNlcnZlci0+cmVzcG9uc2VfcSk7CiAJCX0KIAl9CisKIAlyZXR1cm4gcmM7CiB9CiAKQEAgLTIyOSw5ICsyMzAsOCBAQAogc3RhdGljIGludCBjaGVjazJuZFQyKHN0cnVjdCBzbWJfaGRyICpwU01CLCB1bnNpZ25lZCBpbnQgbWF4QnVmU2l6ZSkKIHsKIAlzdHJ1Y3Qgc21iX3QyX3JzcCAqcFNNQnQ7Ci0JaW50IHRvdGFsX2RhdGFfc2l6ZTsKLQlpbnQgZGF0YV9pbl90aGlzX3JzcDsKIAlpbnQgcmVtYWluaW5nOworCV9fdTE2IHRvdGFsX2RhdGFfc2l6ZSwgZGF0YV9pbl90aGlzX3JzcDsKIAogCWlmIChwU01CLT5Db21tYW5kICE9IFNNQl9DT01fVFJBTlNBQ1RJT04yKQogCQlyZXR1cm4gMDsKQEAgLTI0NSw4ICsyNDUsOCBAQAogCiAJcFNNQnQgPSAoc3RydWN0IHNtYl90Ml9yc3AgKilwU01COwogCi0JdG90YWxfZGF0YV9zaXplID0gbGUxNl90b19jcHUocFNNQnQtPnQyX3JzcC5Ub3RhbERhdGFDb3VudCk7Ci0JZGF0YV9pbl90aGlzX3JzcCA9IGxlMTZfdG9fY3B1KHBTTUJ0LT50Ml9yc3AuRGF0YUNvdW50KTsKKwl0b3RhbF9kYXRhX3NpemUgPSBnZXRfdW5hbGlnbmVkX2xlMTYoJnBTTUJ0LT50Ml9yc3AuVG90YWxEYXRhQ291bnQpOworCWRhdGFfaW5fdGhpc19yc3AgPSBnZXRfdW5hbGlnbmVkX2xlMTYoJnBTTUJ0LT50Ml9yc3AuRGF0YUNvdW50KTsKIAogCXJlbWFpbmluZyA9IHRvdGFsX2RhdGFfc2l6ZSAtIGRhdGFfaW5fdGhpc19yc3A7CiAKQEAgLTI3MiwyMSArMjcyLDE4IEBACiB7CiAJc3RydWN0IHNtYl90Ml9yc3AgKnBTTUIyID0gKHN0cnVjdCBzbWJfdDJfcnNwICopcHNlY29uZDsKIAlzdHJ1Y3Qgc21iX3QyX3JzcCAqcFNNQnQgID0gKHN0cnVjdCBzbWJfdDJfcnNwICopcFRhcmdldFNNQjsKLQlpbnQgdG90YWxfZGF0YV9zaXplOwotCWludCB0b3RhbF9pbl9idWY7Ci0JaW50IHJlbWFpbmluZzsKLQlpbnQgdG90YWxfaW5fYnVmMjsKIAljaGFyICpkYXRhX2FyZWFfb2ZfdGFyZ2V0OwogCWNoYXIgKmRhdGFfYXJlYV9vZl9idWYyOwotCV9fdTE2IGJ5dGVfY291bnQ7CisJaW50IHJlbWFpbmluZzsKKwlfX3UxNiBieXRlX2NvdW50LCB0b3RhbF9kYXRhX3NpemUsIHRvdGFsX2luX2J1ZiwgdG90YWxfaW5fYnVmMjsKIAotCXRvdGFsX2RhdGFfc2l6ZSA9IGxlMTZfdG9fY3B1KHBTTUJ0LT50Ml9yc3AuVG90YWxEYXRhQ291bnQpOworCXRvdGFsX2RhdGFfc2l6ZSA9IGdldF91bmFsaWduZWRfbGUxNigmcFNNQnQtPnQyX3JzcC5Ub3RhbERhdGFDb3VudCk7CiAKLQlpZiAodG90YWxfZGF0YV9zaXplICE9IGxlMTZfdG9fY3B1KHBTTUIyLT50Ml9yc3AuVG90YWxEYXRhQ291bnQpKSB7CisJaWYgKHRvdGFsX2RhdGFfc2l6ZSAhPQorCSAgICBnZXRfdW5hbGlnbmVkX2xlMTYoJnBTTUIyLT50Ml9yc3AuVG90YWxEYXRhQ291bnQpKQogCQljRllJKDEsICJ0b3RhbCBkYXRhIHNpemUgb2YgcHJpbWFyeSBhbmQgc2Vjb25kYXJ5IHQyIGRpZmZlciIpOwotCX0KIAotCXRvdGFsX2luX2J1ZiA9IGxlMTZfdG9fY3B1KHBTTUJ0LT50Ml9yc3AuRGF0YUNvdW50KTsKKwl0b3RhbF9pbl9idWYgPSBnZXRfdW5hbGlnbmVkX2xlMTYoJnBTTUJ0LT50Ml9yc3AuRGF0YUNvdW50KTsKIAogCXJlbWFpbmluZyA9IHRvdGFsX2RhdGFfc2l6ZSAtIHRvdGFsX2luX2J1ZjsKIApAQCAtMjk2LDI4ICsyOTMsMjggQEAKIAlpZiAocmVtYWluaW5nID09IDApIC8qIG5vdGhpbmcgdG8gZG8sIGlnbm9yZSAqLwogCQlyZXR1cm4gMDsKIAotCXRvdGFsX2luX2J1ZjIgPSBsZTE2X3RvX2NwdShwU01CMi0+dDJfcnNwLkRhdGFDb3VudCk7CisJdG90YWxfaW5fYnVmMiA9IGdldF91bmFsaWduZWRfbGUxNigmcFNNQjItPnQyX3JzcC5EYXRhQ291bnQpOwogCWlmIChyZW1haW5pbmcgPCB0b3RhbF9pbl9idWYyKSB7CiAJCWNGWUkoMSwgInRyYW5zYWN0MiAybmQgcmVzcG9uc2UgY29udGFpbnMgdG9vIG11Y2ggZGF0YSIpOwogCX0KIAogCS8qIGZpbmQgZW5kIG9mIGZpcnN0IFNNQiBkYXRhIGFyZWEgKi8KIAlkYXRhX2FyZWFfb2ZfdGFyZ2V0ID0gKGNoYXIgKikmcFNNQnQtPmhkci5Qcm90b2NvbCArCi0JCQkJbGUxNl90b19jcHUocFNNQnQtPnQyX3JzcC5EYXRhT2Zmc2V0KTsKKwkJCQlnZXRfdW5hbGlnbmVkX2xlMTYoJnBTTUJ0LT50Ml9yc3AuRGF0YU9mZnNldCk7CiAJLyogdmFsaWRhdGUgdGFyZ2V0IGFyZWEgKi8KIAotCWRhdGFfYXJlYV9vZl9idWYyID0gKGNoYXIgKikgJnBTTUIyLT5oZHIuUHJvdG9jb2wgKwotCQkJCQlsZTE2X3RvX2NwdShwU01CMi0+dDJfcnNwLkRhdGFPZmZzZXQpOworCWRhdGFfYXJlYV9vZl9idWYyID0gKGNoYXIgKikmcFNNQjItPmhkci5Qcm90b2NvbCArCisJCQkJZ2V0X3VuYWxpZ25lZF9sZTE2KCZwU01CMi0+dDJfcnNwLkRhdGFPZmZzZXQpOwogCiAJZGF0YV9hcmVhX29mX3RhcmdldCArPSB0b3RhbF9pbl9idWY7CiAKIAkvKiBjb3B5IHNlY29uZCBidWZmZXIgaW50byBlbmQgb2YgZmlyc3QgYnVmZmVyICovCiAJbWVtY3B5KGRhdGFfYXJlYV9vZl90YXJnZXQsIGRhdGFfYXJlYV9vZl9idWYyLCB0b3RhbF9pbl9idWYyKTsKIAl0b3RhbF9pbl9idWYgKz0gdG90YWxfaW5fYnVmMjsKLQlwU01CdC0+dDJfcnNwLkRhdGFDb3VudCA9IGNwdV90b19sZTE2KHRvdGFsX2luX2J1Zik7Ci0JYnl0ZV9jb3VudCA9IGxlMTZfdG9fY3B1KEJDQ19MRShwVGFyZ2V0U01CKSk7CisJcHV0X3VuYWxpZ25lZF9sZTE2KHRvdGFsX2luX2J1ZiwgJnBTTUJ0LT50Ml9yc3AuRGF0YUNvdW50KTsKKwlieXRlX2NvdW50ID0gZ2V0X2JjY19sZShwVGFyZ2V0U01CKTsKIAlieXRlX2NvdW50ICs9IHRvdGFsX2luX2J1ZjI7Ci0JQkNDX0xFKHBUYXJnZXRTTUIpID0gY3B1X3RvX2xlMTYoYnl0ZV9jb3VudCk7CisJcHV0X2JjY19sZShieXRlX2NvdW50LCBwVGFyZ2V0U01CKTsKIAogCWJ5dGVfY291bnQgPSBwVGFyZ2V0U01CLT5zbWJfYnVmX2xlbmd0aDsKIAlieXRlX2NvdW50ICs9IHRvdGFsX2luX2J1ZjI7CkBAIC0zMzEsNyArMzI4LDMxIEBACiAJCXJldHVybiAwOyAvKiB3ZSBhcmUgZG9uZSAqLwogCX0gZWxzZSAvKiBtb3JlIHJlc3BvbnNlcyB0byBnbyAqLwogCQlyZXR1cm4gMTsKK30KIAorc3RhdGljIHZvaWQKK2NpZnNfZWNob19yZXF1ZXN0KHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKK3sKKwlpbnQgcmM7CisJc3RydWN0IFRDUF9TZXJ2ZXJfSW5mbyAqc2VydmVyID0gY29udGFpbmVyX29mKHdvcmssCisJCQkJCXN0cnVjdCBUQ1BfU2VydmVyX0luZm8sIGVjaG8ud29yayk7CisKKwkvKgorCSAqIFdlIGNhbm5vdCBzZW5kIGFuIGVjaG8gdW50aWwgdGhlIE5FR09USUFURV9QUk9UT0NPTCByZXF1ZXN0IGlzCisJICogZG9uZSwgd2hpY2ggaXMgaW5kaWNhdGVkIGJ5IG1heEJ1ZiAhPSAwLiBBbHNvLCBubyBuZWVkIHRvIHBpbmcgaWYKKwkgKiB3ZSBnb3QgYSByZXNwb25zZSByZWNlbnRseQorCSAqLworCWlmIChzZXJ2ZXItPm1heEJ1ZiA9PSAwIHx8CisJICAgIHRpbWVfYmVmb3JlKGppZmZpZXMsIHNlcnZlci0+bHN0cnAgKyBTTUJfRUNIT19JTlRFUlZBTCAtIEhaKSkKKwkJZ290byByZXF1ZXVlX2VjaG87CisKKwlyYyA9IENJRlNTTUJFY2hvKHNlcnZlcik7CisJaWYgKHJjKQorCQljRllJKDEsICJVbmFibGUgdG8gc2VuZCBlY2hvIHJlcXVlc3QgdG8gc2VydmVyOiAlcyIsCisJCQlzZXJ2ZXItPmhvc3RuYW1lKTsKKworcmVxdWV1ZV9lY2hvOgorCXF1ZXVlX2RlbGF5ZWRfd29yayhzeXN0ZW1fbnJ0X3dxLCAmc2VydmVyLT5lY2hvLCBTTUJfRUNIT19JTlRFUlZBTCk7CiB9CiAKIHN0YXRpYyBpbnQKQEAgLTM0NSw4ICszNjYsNyBAQAogCXN0cnVjdCBtc2doZHIgc21iX21zZzsKIAlzdHJ1Y3Qga3ZlYyBpb3Y7CiAJc3RydWN0IHNvY2tldCAqY3NvY2tldCA9IHNlcnZlci0+c3NvY2tldDsKLQlzdHJ1Y3QgbGlzdF9oZWFkICp0bXA7Ci0Jc3RydWN0IGNpZnNTZXNJbmZvICpzZXM7CisJc3RydWN0IGxpc3RfaGVhZCAqdG1wLCAqdG1wMjsKIAlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2tfdG9fd2FrZSA9IE5VTEw7CiAJc3RydWN0IG1pZF9xX2VudHJ5ICptaWRfZW50cnk7CiAJY2hhciB0ZW1wOwpAQCAtMzk5LDcgKzQxOSwyMCBAQAogCQlzbWJfbXNnLm1zZ19jb250cm9sID0gTlVMTDsKIAkJc21iX21zZy5tc2dfY29udHJvbGxlbiA9IDA7CiAJCXBkdV9sZW5ndGggPSA0OyAvKiBlbm91Z2ggdG8gZ2V0IFJGQzEwMDEgaGVhZGVyICovCisKIGluY29tcGxldGVfcmN2OgorCQlpZiAoZWNob19yZXRyaWVzID4gMCAmJgorCQkgICAgdGltZV9hZnRlcihqaWZmaWVzLCBzZXJ2ZXItPmxzdHJwICsKKwkJCQkJKGVjaG9fcmV0cmllcyAqIFNNQl9FQ0hPX0lOVEVSVkFMKSkpIHsKKwkJCWNFUlJPUigxLCAiU2VydmVyICVzIGhhcyBub3QgcmVzcG9uZGVkIGluICVkIHNlY29uZHMuICIKKwkJCQkgICJSZWNvbm5lY3RpbmcuLi4iLCBzZXJ2ZXItPmhvc3RuYW1lLAorCQkJCSAgKGVjaG9fcmV0cmllcyAqIFNNQl9FQ0hPX0lOVEVSVkFMIC8gSFopKTsKKwkJCWNpZnNfcmVjb25uZWN0KHNlcnZlcik7CisJCQljc29ja2V0ID0gc2VydmVyLT5zc29ja2V0OworCQkJd2FrZV91cCgmc2VydmVyLT5yZXNwb25zZV9xKTsKKwkJCWNvbnRpbnVlOworCQl9CisKIAkJbGVuZ3RoID0KIAkJICAgIGtlcm5lbF9yZWN2bXNnKGNzb2NrZXQsICZzbWJfbXNnLAogCQkJCSZpb3YsIDEsIHBkdV9sZW5ndGgsIDAgLyogQkIgb3RoZXIgZmxhZ3M/ICovKTsKQEAgLTU1MCwyNSArNTgzLDM2IEBACiAJCWVsc2UgaWYgKHJlY29ubmVjdCA9PSAxKQogCQkJY29udGludWU7CiAKLQkJbGVuZ3RoICs9IDQ7IC8qIGFjY291bnQgZm9yIHJmYzEwMDIgaGRyICovCisJCXRvdGFsX3JlYWQgKz0gNDsgLyogYWNjb3VudCBmb3IgcmZjMTAwMiBoZHIgKi8KIAorCQlkdW1wX3NtYihzbWJfYnVmZmVyLCB0b3RhbF9yZWFkKTsKIAotCQlkdW1wX3NtYihzbWJfYnVmZmVyLCBsZW5ndGgpOwotCQlpZiAoY2hlY2tTTUIoc21iX2J1ZmZlciwgc21iX2J1ZmZlci0+TWlkLCB0b3RhbF9yZWFkKzQpKSB7Ci0JCQljaWZzX2R1bXBfbWVtKCJCYWQgU01COiAiLCBzbWJfYnVmZmVyLCA0OCk7Ci0JCQljb250aW51ZTsKLQkJfQorCQkvKgorCQkgKiBXZSBrbm93IHRoYXQgd2UgcmVjZWl2ZWQgZW5vdWdoIHRvIGdldCB0byB0aGUgTUlEIGFzIHdlCisJCSAqIGNoZWNrZWQgdGhlIHBkdV9sZW5ndGggZWFybGllci4gTm93IGNoZWNrIHRvIHNlZQorCQkgKiBpZiB0aGUgcmVzdCBvZiB0aGUgaGVhZGVyIGlzIE9LLiBXZSBib3Jyb3cgdGhlIGxlbmd0aAorCQkgKiB2YXIgZm9yIHRoZSByZXN0IG9mIHRoZSBsb29wIHRvIGF2b2lkIGEgbmV3IHN0YWNrIHZhci4KKwkJICoKKwkJICogNDggYnl0ZXMgaXMgZW5vdWdoIHRvIGRpc3BsYXkgdGhlIGhlYWRlciBhbmQgYSBsaXR0bGUgYml0CisJCSAqIGludG8gdGhlIHBheWxvYWQgZm9yIGRlYnVnZ2luZyBwdXJwb3Nlcy4KKwkJICovCisJCWxlbmd0aCA9IGNoZWNrU01CKHNtYl9idWZmZXIsIHNtYl9idWZmZXItPk1pZCwgdG90YWxfcmVhZCk7CisJCWlmIChsZW5ndGggIT0gMCkKKwkJCWNpZnNfZHVtcF9tZW0oIkJhZCBTTUI6ICIsIHNtYl9idWZmZXIsCisJCQkJCW1pbl90KHVuc2lnbmVkIGludCwgdG90YWxfcmVhZCwgNDgpKTsKIAorCQltaWRfZW50cnkgPSBOVUxMOworCQlzZXJ2ZXItPmxzdHJwID0gamlmZmllczsKIAotCQl0YXNrX3RvX3dha2UgPSBOVUxMOwogCQlzcGluX2xvY2soJkdsb2JhbE1pZF9Mb2NrKTsKLQkJbGlzdF9mb3JfZWFjaCh0bXAsICZzZXJ2ZXItPnBlbmRpbmdfbWlkX3EpIHsKKwkJbGlzdF9mb3JfZWFjaF9zYWZlKHRtcCwgdG1wMiwgJnNlcnZlci0+cGVuZGluZ19taWRfcSkgewogCQkJbWlkX2VudHJ5ID0gbGlzdF9lbnRyeSh0bXAsIHN0cnVjdCBtaWRfcV9lbnRyeSwgcWhlYWQpOwogCiAJCQlpZiAoKG1pZF9lbnRyeS0+bWlkID09IHNtYl9idWZmZXItPk1pZCkgJiYKIAkJCSAgICAobWlkX2VudHJ5LT5taWRTdGF0ZSA9PSBNSURfUkVRVUVTVF9TVUJNSVRURUQpICYmCiAJCQkgICAgKG1pZF9lbnRyeS0+Y29tbWFuZCA9PSBzbWJfYnVmZmVyLT5Db21tYW5kKSkgewotCQkJCWlmIChjaGVjazJuZFQyKHNtYl9idWZmZXIsc2VydmVyLT5tYXhCdWYpID4gMCkgeworCQkJCWlmIChsZW5ndGggPT0gMCAmJgorCQkJCSAgIGNoZWNrMm5kVDIoc21iX2J1ZmZlciwgc2VydmVyLT5tYXhCdWYpID4gMCkgewogCQkJCQkvKiBXZSBoYXZlIGEgbXVsdGlwYXJ0IHRyYW5zYWN0MiByZXNwICovCiAJCQkJCWlzTXVsdGlSc3AgPSB0cnVlOwogCQkJCQlpZiAobWlkX2VudHJ5LT5yZXNwX2J1ZikgewpAQCAtNjAzLDIwICs2NDcsMjQgQEAKIAkJCQltaWRfZW50cnktPnJlc3BfYnVmID0gc21iX2J1ZmZlcjsKIAkJCQltaWRfZW50cnktPmxhcmdlQnVmID0gaXNMYXJnZUJ1ZjsKIG11bHRpX3QyX2ZuZDoKLQkJCQl0YXNrX3RvX3dha2UgPSBtaWRfZW50cnktPnRzazsKLQkJCQltaWRfZW50cnktPm1pZFN0YXRlID0gTUlEX1JFU1BPTlNFX1JFQ0VJVkVEOworCQkJCWlmIChsZW5ndGggPT0gMCkKKwkJCQkJbWlkX2VudHJ5LT5taWRTdGF0ZSA9CisJCQkJCQkJTUlEX1JFU1BPTlNFX1JFQ0VJVkVEOworCQkJCWVsc2UKKwkJCQkJbWlkX2VudHJ5LT5taWRTdGF0ZSA9CisJCQkJCQkJTUlEX1JFU1BPTlNFX01BTEZPUk1FRDsKICNpZmRlZiBDT05GSUdfQ0lGU19TVEFUUzIKIAkJCQltaWRfZW50cnktPndoZW5fcmVjZWl2ZWQgPSBqaWZmaWVzOwogI2VuZGlmCi0JCQkJLyogc28gd2UgZG8gbm90IHRpbWUgb3V0IHJlcXVlc3RzIHRvICBzZXJ2ZXIKLQkJCQl3aGljaCBpcyBzdGlsbCByZXNwb25kaW5nIChzaW5jZSBzZXJ2ZXIgY291bGQKLQkJCQliZSBidXN5IGJ1dCBub3QgZGVhZCkgKi8KLQkJCQlzZXJ2ZXItPmxzdHJwID0gamlmZmllczsKKwkJCQlsaXN0X2RlbF9pbml0KCZtaWRfZW50cnktPnFoZWFkKTsKKwkJCQltaWRfZW50cnktPmNhbGxiYWNrKG1pZF9lbnRyeSk7CiAJCQkJYnJlYWs7CiAJCQl9CisJCQltaWRfZW50cnkgPSBOVUxMOwogCQl9CiAJCXNwaW5fdW5sb2NrKCZHbG9iYWxNaWRfTG9jayk7Ci0JCWlmICh0YXNrX3RvX3dha2UpIHsKKworCQlpZiAobWlkX2VudHJ5ICE9IE5VTEwpIHsKIAkJCS8qIFdhcyBwcmV2aW91cyBidWYgcHV0IGluIG1weCBzdHJ1Y3QgZm9yIG11bHRpLXJzcD8gKi8KIAkJCWlmICghaXNNdWx0aVJzcCkgewogCQkJCS8qIHNtYiBidWZmZXIgd2lsbCBiZSBmcmVlZCBieSB1c2VyIHRocmVhZCAqLwpAQCAtNjI1LDExICs2NzMsMTMgQEAKIAkJCQllbHNlCiAJCQkJCXNtYWxsYnVmID0gTlVMTDsKIAkJCX0KLQkJCXdha2VfdXBfcHJvY2Vzcyh0YXNrX3RvX3dha2UpOworCQl9IGVsc2UgaWYgKGxlbmd0aCAhPSAwKSB7CisJCQkvKiByZXNwb25zZSBzYW5pdHkgY2hlY2tzIGZhaWxlZCAqLworCQkJY29udGludWU7CiAJCX0gZWxzZSBpZiAoIWlzX3ZhbGlkX29wbG9ja19icmVhayhzbWJfYnVmZmVyLCBzZXJ2ZXIpICYmCiAJCQkgICAhaXNNdWx0aVJzcCkgewogCQkJY0VSUk9SKDEsICJObyB0YXNrIHRvIHdha2UsIHVua25vd24gZnJhbWUgcmVjZWl2ZWQhICIKLQkJCQkgICAiTnVtTWlkcyAlZCIsIG1pZENvdW50LmNvdW50ZXIpOworCQkJCSAgICJOdW1NaWRzICVkIiwgYXRvbWljX3JlYWQoJm1pZENvdW50KSk7CiAJCQljaWZzX2R1bXBfbWVtKCJSZWNlaXZlZCBEYXRhIGlzOiAiLCAoY2hhciAqKXNtYl9idWZmZXIsCiAJCQkJICAgICAgc2l6ZW9mKHN0cnVjdCBzbWJfaGRyKSk7CiAjaWZkZWYgQ09ORklHX0NJRlNfREVCVUcyCkBAIC02NzcsNDQgKzcyNywxNiBAQAogCWlmIChzbWFsbGJ1ZikgLyogbm8gc2Vuc2UgbG9nZ2luZyBhIGRlYnVnIG1lc3NhZ2UgaWYgTlVMTCAqLwogCQljaWZzX3NtYWxsX2J1Zl9yZWxlYXNlKHNtYWxsYnVmKTsKIAotCS8qCi0JICogQkI6IHdlIHNob3VsZG4ndCBoYXZlIHRvIGRvIGFueSBvZiB0aGlzLiBJdCBzaG91bGRuJ3QgYmUKLQkgKiBwb3NzaWJsZSB0byBleGl0IGZyb20gdGhlIHRocmVhZCB3aXRoIGFjdGl2ZSBTTUIgc2Vzc2lvbnMKLQkgKi8KLQlzcGluX2xvY2soJmNpZnNfdGNwX3Nlc19sb2NrKTsKLQlpZiAobGlzdF9lbXB0eSgmc2VydmVyLT5wZW5kaW5nX21pZF9xKSkgewotCQkvKiBsb29wIHRocm91Z2ggc2VydmVyIHNlc3Npb24gc3RydWN0dXJlcyBhdHRhY2hlZCB0byB0aGlzIGFuZAotCQkgICAgbWFyayB0aGVtIGRlYWQgKi8KLQkJbGlzdF9mb3JfZWFjaCh0bXAsICZzZXJ2ZXItPnNtYl9zZXNfbGlzdCkgewotCQkJc2VzID0gbGlzdF9lbnRyeSh0bXAsIHN0cnVjdCBjaWZzU2VzSW5mbywKLQkJCQkJIHNtYl9zZXNfbGlzdCk7Ci0JCQlzZXMtPnN0YXR1cyA9IENpZnNFeGl0aW5nOwotCQkJc2VzLT5zZXJ2ZXIgPSBOVUxMOwotCQl9Ci0JCXNwaW5fdW5sb2NrKCZjaWZzX3RjcF9zZXNfbG9jayk7Ci0JfSBlbHNlIHsKLQkJLyogYWx0aG91Z2ggd2UgY2FuIG5vdCB6ZXJvIHRoZSBzZXJ2ZXIgc3RydWN0IHBvaW50ZXIgeWV0LAotCQlzaW5jZSB0aGVyZSBhcmUgYWN0aXZlIHJlcXVlc3RzIHdoaWNoIG1heSBkZXBuZCBvbiB0aGVtLAotCQltYXJrIHRoZSBjb3JyZXNwb25kaW5nIFNNQiBzZXNzaW9ucyBhcyBleGl0aW5nIHRvbyAqLwotCQlsaXN0X2Zvcl9lYWNoKHRtcCwgJnNlcnZlci0+c21iX3Nlc19saXN0KSB7Ci0JCQlzZXMgPSBsaXN0X2VudHJ5KHRtcCwgc3RydWN0IGNpZnNTZXNJbmZvLAotCQkJCQkgc21iX3Nlc19saXN0KTsKLQkJCXNlcy0+c3RhdHVzID0gQ2lmc0V4aXRpbmc7Ci0JCX0KLQorCWlmICghbGlzdF9lbXB0eSgmc2VydmVyLT5wZW5kaW5nX21pZF9xKSkgewogCQlzcGluX2xvY2soJkdsb2JhbE1pZF9Mb2NrKTsKLQkJbGlzdF9mb3JfZWFjaCh0bXAsICZzZXJ2ZXItPnBlbmRpbmdfbWlkX3EpIHsKLQkJbWlkX2VudHJ5ID0gbGlzdF9lbnRyeSh0bXAsIHN0cnVjdCBtaWRfcV9lbnRyeSwgcWhlYWQpOwotCQkJaWYgKG1pZF9lbnRyeS0+bWlkU3RhdGUgPT0gTUlEX1JFUVVFU1RfU1VCTUlUVEVEKSB7Ci0JCQkJY0ZZSSgxLCAiQ2xlYXJpbmcgTWlkIDB4JXggLSB3YWtpbmcgdXAgIiwKKwkJbGlzdF9mb3JfZWFjaF9zYWZlKHRtcCwgdG1wMiwgJnNlcnZlci0+cGVuZGluZ19taWRfcSkgeworCQkJbWlkX2VudHJ5ID0gbGlzdF9lbnRyeSh0bXAsIHN0cnVjdCBtaWRfcV9lbnRyeSwgcWhlYWQpOworCQkJY0ZZSSgxLCAiQ2xlYXJpbmcgTWlkIDB4JXggLSBpc3N1aW5nIGNhbGxiYWNrIiwKIAkJCQkJIG1pZF9lbnRyeS0+bWlkKTsKLQkJCQl0YXNrX3RvX3dha2UgPSBtaWRfZW50cnktPnRzazsKLQkJCQlpZiAodGFza190b193YWtlKQotCQkJCQl3YWtlX3VwX3Byb2Nlc3ModGFza190b193YWtlKTsKLQkJCX0KKwkJCWxpc3RfZGVsX2luaXQoJm1pZF9lbnRyeS0+cWhlYWQpOworCQkJbWlkX2VudHJ5LT5jYWxsYmFjayhtaWRfZW50cnkpOwogCQl9CiAJCXNwaW5fdW5sb2NrKCZHbG9iYWxNaWRfTG9jayk7Ci0JCXNwaW5fdW5sb2NrKCZjaWZzX3RjcF9zZXNfbG9jayk7CiAJCS8qIDEvOHRoIG9mIHNlYyBpcyBtb3JlIHRoYW4gZW5vdWdoIHRpbWUgZm9yIHRoZW0gdG8gZXhpdCAqLwogCQltc2xlZXAoMTI1KTsKIAl9CkBAIC03MzIsMTggKzc1NCw2IEBACiAJCWNvbWluZyBob21lIG5vdCBtdWNoIGVsc2Ugd2UgY2FuIGRvIGJ1dCBmcmVlIHRoZSBtZW1vcnkgKi8KIAl9CiAKLQkvKiBsYXN0IGNoYW5jZSB0byBtYXJrIHNlcyBwb2ludGVycyBpbnZhbGlkCi0JaWYgdGhlcmUgYXJlIGFueSBwb2ludGluZyB0byB0aGlzIChlLmcKLQlpZiBhIGNyYXp5IHJvb3QgdXNlciB0cmllZCB0byBraWxsIGNpZnNkCi0Ja2VybmVsIHRocmVhZCBleHBsaWNpdGx5IHRoaXMgbWlnaHQgaGFwcGVuKSAqLwotCS8qIEJCOiBUaGlzIHNob3VsZG4ndCBiZSBuZWNlc3NhcnksIHNlZSBhYm92ZSAqLwotCXNwaW5fbG9jaygmY2lmc190Y3Bfc2VzX2xvY2spOwotCWxpc3RfZm9yX2VhY2godG1wLCAmc2VydmVyLT5zbWJfc2VzX2xpc3QpIHsKLQkJc2VzID0gbGlzdF9lbnRyeSh0bXAsIHN0cnVjdCBjaWZzU2VzSW5mbywgc21iX3Nlc19saXN0KTsKLQkJc2VzLT5zZXJ2ZXIgPSBOVUxMOwotCX0KLQlzcGluX3VubG9jaygmY2lmc190Y3Bfc2VzX2xvY2spOwotCiAJa2ZyZWUoc2VydmVyLT5ob3N0bmFtZSk7CiAJdGFza190b193YWtlID0geGNoZygmc2VydmVyLT50c2ssIE5VTEwpOwogCWtmcmVlKHNlcnZlcik7CkBAIC0xMTEzLDYgKzExMjMsOCBAQAogCQl9IGVsc2UgaWYgKCFzdHJuaWNtcChkYXRhLCAidWlkIiwgMykgJiYgdmFsdWUgJiYgKnZhbHVlKSB7CiAJCQl2b2wtPmxpbnV4X3VpZCA9IHNpbXBsZV9zdHJ0b3VsKHZhbHVlLCAmdmFsdWUsIDApOwogCQkJdWlkX3NwZWNpZmllZCA9IHRydWU7CisJCX0gZWxzZSBpZiAoIXN0cm5pY21wKGRhdGEsICJjcnVpZCIsIDUpICYmIHZhbHVlICYmICp2YWx1ZSkgeworCQkJdm9sLT5jcmVkX3VpZCA9IHNpbXBsZV9zdHJ0b3VsKHZhbHVlLCAmdmFsdWUsIDApOwogCQl9IGVsc2UgaWYgKCFzdHJuaWNtcChkYXRhLCAiZm9yY2V1aWQiLCA4KSkgewogCQkJb3ZlcnJpZGVfdWlkID0gMTsKIAkJfSBlbHNlIGlmICghc3RybmljbXAoZGF0YSwgIm5vZm9yY2V1aWQiLCAxMCkpIHsKQEAgLTEzNTMsNiArMTM2NSw4IEBACiAJCQl2b2wtPmRpcmVjdF9pbyA9IDE7CiAJCX0gZWxzZSBpZiAoc3RybmljbXAoZGF0YSwgImZvcmNlZGlyZWN0aW8iLCAxMykgPT0gMCkgewogCQkJdm9sLT5kaXJlY3RfaW8gPSAxOworCQl9IGVsc2UgaWYgKHN0cm5pY21wKGRhdGEsICJzdHJpY3RjYWNoZSIsIDExKSA9PSAwKSB7CisJCQl2b2wtPnN0cmljdF9pbyA9IDE7CiAJCX0gZWxzZSBpZiAoc3RybmljbXAoZGF0YSwgIm5vYWMiLCA0KSA9PSAwKSB7CiAJCQlwcmludGsoS0VSTl9XQVJOSU5HICJDSUZTOiBNb3VudCBvcHRpb24gbm9hYyBub3QgIgogCQkJCSJzdXBwb3J0ZWQuIEluc3RlYWQgc2V0ICIKQEAgLTE1NzcsNiArMTU5MSw5IEBACiAKIAlzcGluX2xvY2soJmNpZnNfdGNwX3Nlc19sb2NrKTsKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KHNlcnZlciwgJmNpZnNfdGNwX3Nlc19saXN0LCB0Y3Bfc2VzX2xpc3QpIHsKKwkJaWYgKCFuZXRfZXEoY2lmc19uZXRfbnMoc2VydmVyKSwgY3VycmVudC0+bnNwcm94eS0+bmV0X25zKSkKKwkJCWNvbnRpbnVlOworCiAJCWlmICghbWF0Y2hfYWRkcmVzcyhzZXJ2ZXIsIGFkZHIsCiAJCQkJICAgKHN0cnVjdCBzb2NrYWRkciAqKSZ2b2wtPnNyY2FkZHIpKQogCQkJY29udGludWU7CkBAIC0xNjA3LDkgKzE2MjQsMTMgQEAKIAkJcmV0dXJuOwogCX0KIAorCXB1dF9uZXQoY2lmc19uZXRfbnMoc2VydmVyKSk7CisKIAlsaXN0X2RlbF9pbml0KCZzZXJ2ZXItPnRjcF9zZXNfbGlzdCk7CiAJc3Bpbl91bmxvY2soJmNpZnNfdGNwX3Nlc19sb2NrKTsKIAorCWNhbmNlbF9kZWxheWVkX3dvcmtfc3luYygmc2VydmVyLT5lY2hvKTsKKwogCXNwaW5fbG9jaygmR2xvYmFsTWlkX0xvY2spOwogCXNlcnZlci0+dGNwU3RhdHVzID0gQ2lmc0V4aXRpbmc7CiAJc3Bpbl91bmxvY2soJkdsb2JhbE1pZF9Mb2NrKTsKQEAgLTE2NzksNiArMTcwMCw3IEBACiAJCWdvdG8gb3V0X2VycjsKIAl9CiAKKwljaWZzX3NldF9uZXRfbnModGNwX3NlcywgZ2V0X25ldChjdXJyZW50LT5uc3Byb3h5LT5uZXRfbnMpKTsKIAl0Y3Bfc2VzLT5ob3N0bmFtZSA9IGV4dHJhY3RfaG9zdG5hbWUodm9sdW1lX2luZm8tPlVOQyk7CiAJaWYgKElTX0VSUih0Y3Bfc2VzLT5ob3N0bmFtZSkpIHsKIAkJcmMgPSBQVFJfRVJSKHRjcF9zZXMtPmhvc3RuYW1lKTsKQEAgLTE2OTksOCArMTcyMSwxMCBAQAogCQl2b2x1bWVfaW5mby0+dGFyZ2V0X3JmYzEwMDFfbmFtZSwgUkZDMTAwMV9OQU1FX0xFTl9XSVRIX05VTEwpOwogCXRjcF9zZXMtPnNlc3Npb25fZXN0YWIgPSBmYWxzZTsKIAl0Y3Bfc2VzLT5zZXF1ZW5jZV9udW1iZXIgPSAwOworCXRjcF9zZXMtPmxzdHJwID0gamlmZmllczsKIAlJTklUX0xJU1RfSEVBRCgmdGNwX3Nlcy0+dGNwX3Nlc19saXN0KTsKIAlJTklUX0xJU1RfSEVBRCgmdGNwX3Nlcy0+c21iX3Nlc19saXN0KTsKKwlJTklUX0RFTEFZRURfV09SSygmdGNwX3Nlcy0+ZWNobywgY2lmc19lY2hvX3JlcXVlc3QpOwogCiAJLyoKIAkgKiBhdCB0aGlzIHBvaW50IHdlIGFyZSB0aGUgb25seSBvbmVzIHdpdGggdGhlIHBvaW50ZXIKQEAgLTE3NDksMTEgKzE3NzMsMTYgQEAKIAogCWNpZnNfZnNjYWNoZV9nZXRfY2xpZW50X2Nvb2tpZSh0Y3Bfc2VzKTsKIAorCS8qIHF1ZXVlIGVjaG8gcmVxdWVzdCBkZWxheWVkIHdvcmsgKi8KKwlxdWV1ZV9kZWxheWVkX3dvcmsoc3lzdGVtX25ydF93cSwgJnRjcF9zZXMtPmVjaG8sIFNNQl9FQ0hPX0lOVEVSVkFMKTsKKwogCXJldHVybiB0Y3Bfc2VzOwogCiBvdXRfZXJyX2NyeXB0b19yZWxlYXNlOgogCWNpZnNfY3J5cHRvX3NoYXNoX3JlbGVhc2UodGNwX3Nlcyk7CiAKKwlwdXRfbmV0KGNpZnNfbmV0X25zKHRjcF9zZXMpKTsKKwogb3V0X2VycjoKIAlpZiAodGNwX3NlcykgewogCQlpZiAoIUlTX0VSUih0Y3Bfc2VzLT5ob3N0bmFtZSkpCkBAIC0yMjY1LDggKzIyOTQsOCBAQAogCX0KIAogCWlmIChzb2NrZXQgPT0gTlVMTCkgewotCQlyYyA9IHNvY2tfY3JlYXRlX2tlcm4oc2ZhbWlseSwgU09DS19TVFJFQU0sCi0JCQkJICAgICAgSVBQUk9UT19UQ1AsICZzb2NrZXQpOworCQlyYyA9IF9fc29ja19jcmVhdGUoY2lmc19uZXRfbnMoc2VydmVyKSwgc2ZhbWlseSwgU09DS19TVFJFQU0sCisJCQkJICAgSVBQUk9UT19UQ1AsICZzb2NrZXQsIDEpOwogCQlpZiAocmMgPCAwKSB7CiAJCQljRVJST1IoMSwgIkVycm9yICVkIGNyZWF0aW5nIHNvY2tldCIsIHJjKTsKIAkJCXNlcnZlci0+c3NvY2tldCA9IE5VTEw7CkBAIC0yNTc4LDYgKzI2MDcsOCBAQAogCWlmIChwdm9sdW1lX2luZm8tPm11bHRpdXNlcikKIAkJY2lmc19zYi0+bW50X2NpZnNfZmxhZ3MgfD0gKENJRlNfTU9VTlRfTVVMVElVU0VSIHwKIAkJCQkJICAgIENJRlNfTU9VTlRfTk9fUEVSTSk7CisJaWYgKHB2b2x1bWVfaW5mby0+c3RyaWN0X2lvKQorCQljaWZzX3NiLT5tbnRfY2lmc19mbGFncyB8PSBDSUZTX01PVU5UX1NUUklDVF9JTzsKIAlpZiAocHZvbHVtZV9pbmZvLT5kaXJlY3RfaW8pIHsKIAkJY0ZZSSgxLCAibW91bnRpbmcgc2hhcmUgdXNpbmcgZGlyZWN0IGkvbyIpOwogCQljaWZzX3NiLT5tbnRfY2lmc19mbGFncyB8PSBDSUZTX01PVU5UX0RJUkVDVF9JTzsKQEAgLTI5MzQsOCArMjk2NSw4IEBACiAJVENPTlhfUlNQICpwU01CcjsKIAl1bnNpZ25lZCBjaGFyICpiY2NfcHRyOwogCWludCByYyA9IDA7Ci0JaW50IGxlbmd0aCwgYnl0ZXNfbGVmdDsKLQlfX3UxNiBjb3VudDsKKwlpbnQgbGVuZ3RoOworCV9fdTE2IGJ5dGVzX2xlZnQsIGNvdW50OwogCiAJaWYgKHNlcyA9PSBOVUxMKQogCQlyZXR1cm4gLUVJTzsKQEAgLTI5NjMsNyArMjk5NCw3IEBACiAJCWJjY19wdHIrKzsgICAgICAgICAgICAgIC8qIHNraXAgcGFzc3dvcmQgKi8KIAkJLyogYWxyZWFkeSBhbGlnbmVkIHNvIG5vIG5lZWQgdG8gZG8gaXQgYmVsb3cgKi8KIAl9IGVsc2UgewotCQlwU01CLT5QYXNzd29yZExlbmd0aCA9IGNwdV90b19sZTE2KENJRlNfU0VTU19LRVlfU0laRSk7CisJCXBTTUItPlBhc3N3b3JkTGVuZ3RoID0gY3B1X3RvX2xlMTYoQ0lGU19BVVRIX1JFU1BfU0laRSk7CiAJCS8qIEJCIEZJWE1FIGFkZCBjb2RlIHRvIGZhaWwgdGhpcyBpZiBOVExNdjIgb3IgS2VyYmVyb3MKIAkJICAgc3BlY2lmaWVkIGFzIHJlcXVpcmVkICh3aGVuIHRoYXQgc3VwcG9ydCBpcyBhZGRlZCB0bwogCQkgICB0aGUgdmZzIGluIHRoZSBmdXR1cmUpIGFzIG9ubHkgTlRMTSBvciB0aGUgbXVjaApAQCAtMjk3OSw5ICszMDEwLDEwIEBACiAJCQkJCSBiY2NfcHRyKTsKIAkJZWxzZQogI2VuZGlmIC8qIENJRlNfV0VBS19QV19IQVNIICovCi0JCVNNQk5UZW5jcnlwdCh0Y29uLT5wYXNzd29yZCwgc2VzLT5zZXJ2ZXItPmNyeXB0a2V5LCBiY2NfcHRyKTsKKwkJcmMgPSBTTUJOVGVuY3J5cHQodGNvbi0+cGFzc3dvcmQsIHNlcy0+c2VydmVyLT5jcnlwdGtleSwKKwkJCQkJYmNjX3B0cik7CiAKLQkJYmNjX3B0ciArPSBDSUZTX1NFU1NfS0VZX1NJWkU7CisJCWJjY19wdHIgKz0gQ0lGU19BVVRIX1JFU1BfU0laRTsKIAkJaWYgKHNlcy0+Y2FwYWJpbGl0aWVzICYgQ0FQX1VOSUNPREUpIHsKIAkJCS8qIG11c3QgYWxpZ24gdW5pY29kZSBzdHJpbmdzICovCiAJCQkqYmNjX3B0ciA9IDA7IC8qIG51bGwgYnl0ZSBwYXNzd29yZCAqLwpAQCAtMzAxOSw3ICszMDUxLDcgQEAKIAlwU01CLT5CeXRlQ291bnQgPSBjcHVfdG9fbGUxNihjb3VudCk7CiAKIAlyYyA9IFNlbmRSZWNlaXZlKHhpZCwgc2VzLCBzbWJfYnVmZmVyLCBzbWJfYnVmZmVyX3Jlc3BvbnNlLCAmbGVuZ3RoLAotCQkJIENJRlNfU1REX09QKTsKKwkJCSAwKTsKIAogCS8qIGFib3ZlIG5vdyBkb25lIGluIFNlbmRSZWNlaXZlICovCiAJaWYgKChyYyA9PSAwKSAmJiAodGNvbiAhPSBOVUxMKSkgewpAQCAtMzAyOSw3ICszMDYxLDcgQEAKIAkJdGNvbi0+bmVlZF9yZWNvbm5lY3QgPSBmYWxzZTsKIAkJdGNvbi0+dGlkID0gc21iX2J1ZmZlcl9yZXNwb25zZS0+VGlkOwogCQliY2NfcHRyID0gcEJ5dGVBcmVhKHNtYl9idWZmZXJfcmVzcG9uc2UpOwotCQlieXRlc19sZWZ0ID0gQkNDKHNtYl9idWZmZXJfcmVzcG9uc2UpOworCQlieXRlc19sZWZ0ID0gZ2V0X2JjYyhzbWJfYnVmZmVyX3Jlc3BvbnNlKTsKIAkJbGVuZ3RoID0gc3RybmxlbihiY2NfcHRyLCBieXRlc19sZWZ0IC0gMik7CiAJCWlmIChzbWJfYnVmZmVyLT5GbGFnczIgJiBTTUJGTEcyX1VOSUNPREUpCiAJCQlpc191bmljb2RlID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL2ZzL2NpZnMvZGlyLmMgYi9mcy9jaWZzL2Rpci5jCmluZGV4IDFlOTVkZDYuLmRkNWYyMjkgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvZGlyLmMKKysrIGIvZnMvY2lmcy9kaXIuYwpAQCAtNjc1LDYgKzY3NSw3IEBACiAKIGNvbnN0IHN0cnVjdCBkZW50cnlfb3BlcmF0aW9ucyBjaWZzX2RlbnRyeV9vcHMgPSB7CiAJLmRfcmV2YWxpZGF0ZSA9IGNpZnNfZF9yZXZhbGlkYXRlLAorCS5kX2F1dG9tb3VudCA9IGNpZnNfZGZzX2RfYXV0b21vdW50LAogLyogZF9kZWxldGU6ICAgICAgIGNpZnNfZF9kZWxldGUsICAgICAgKi8gLyogbm90IG5lZWRlZCBleGNlcHQgZm9yIGRlYnVnZ2luZyAqLwogfTsKIApAQCAtNzExLDQgKzcxMiw1IEBACiAJLmRfcmV2YWxpZGF0ZSA9IGNpZnNfZF9yZXZhbGlkYXRlLAogCS5kX2hhc2ggPSBjaWZzX2NpX2hhc2gsCiAJLmRfY29tcGFyZSA9IGNpZnNfY2lfY29tcGFyZSwKKwkuZF9hdXRvbW91bnQgPSBjaWZzX2Rmc19kX2F1dG9tb3VudCwKIH07CmRpZmYgLS1naXQgYS9mcy9jaWZzL2ZpbGUuYyBiL2ZzL2NpZnMvZmlsZS5jCmluZGV4IGQ4NDM2MzEuLmU5NjRiMWMgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvZmlsZS5jCisrKyBiL2ZzL2NpZnMvZmlsZS5jCkBAIC0yODcsNiArMjg3LDcgQEAKIAlzdHJ1Y3QgaW5vZGUgKmlub2RlID0gY2lmc19maWxlLT5kZW50cnktPmRfaW5vZGU7CiAJc3RydWN0IGNpZnNUY29uSW5mbyAqdGNvbiA9IHRsaW5rX3Rjb24oY2lmc19maWxlLT50bGluayk7CiAJc3RydWN0IGNpZnNJbm9kZUluZm8gKmNpZnNpID0gQ0lGU19JKGlub2RlKTsKKwlzdHJ1Y3QgY2lmc19zYl9pbmZvICpjaWZzX3NiID0gQ0lGU19TQihpbm9kZS0+aV9zYik7CiAJc3RydWN0IGNpZnNMb2NrSW5mbyAqbGksICp0bXA7CiAKIAlzcGluX2xvY2soJmNpZnNfZmlsZV9saXN0X2xvY2spOwpAQCAtMzAyLDYgKzMwMywxMyBAQAogCWlmIChsaXN0X2VtcHR5KCZjaWZzaS0+b3BlbkZpbGVMaXN0KSkgewogCQljRllJKDEsICJjbG9zaW5nIGxhc3Qgb3BlbiBpbnN0YW5jZSBmb3IgaW5vZGUgJXAiLAogCQkJY2lmc19maWxlLT5kZW50cnktPmRfaW5vZGUpOworCisJCS8qIGluIHN0cmljdCBjYWNoZSBtb2RlIHdlIG5lZWQgaW52YWxpZGF0ZSBtYXBwaW5nIG9uIHRoZSBsYXN0CisJCSAgIGNsb3NlICBiZWNhdXNlIGl0IG1heSBjYXVzZSBhIGVycm9yIHdoZW4gd2Ugb3BlbiB0aGlzIGZpbGUKKwkJICAgYWdhaW4gYW5kIGdldCBhdCBsZWFzdCBsZXZlbCBJSSBvcGxvY2sgKi8KKwkJaWYgKGNpZnNfc2ItPm1udF9jaWZzX2ZsYWdzICYgQ0lGU19NT1VOVF9TVFJJQ1RfSU8pCisJCQlDSUZTX0koaW5vZGUpLT5pbnZhbGlkX21hcHBpbmcgPSB0cnVlOworCiAJCWNpZnNfc2V0X29wbG9ja19sZXZlbChjaWZzaSwgMCk7CiAJfQogCXNwaW5fdW5sb2NrKCZjaWZzX2ZpbGVfbGlzdF9sb2NrKTsKQEAgLTMzOCw3ICszNDYsNiBAQAogCXN0cnVjdCBjaWZzVGNvbkluZm8gKnRjb247CiAJc3RydWN0IHRjb25fbGluayAqdGxpbms7CiAJc3RydWN0IGNpZnNGaWxlSW5mbyAqcENpZnNGaWxlID0gTlVMTDsKLQlzdHJ1Y3QgY2lmc0lub2RlSW5mbyAqcENpZnNJbm9kZTsKIAljaGFyICpmdWxsX3BhdGggPSBOVUxMOwogCWJvb2wgcG9zaXhfb3Blbl9vayA9IGZhbHNlOwogCV9fdTE2IG5ldGZpZDsKQEAgLTM1Myw4ICszNjAsNiBAQAogCX0KIAl0Y29uID0gdGxpbmtfdGNvbih0bGluayk7CiAKLQlwQ2lmc0lub2RlID0gQ0lGU19JKGZpbGUtPmZfcGF0aC5kZW50cnktPmRfaW5vZGUpOwotCiAJZnVsbF9wYXRoID0gYnVpbGRfcGF0aF9mcm9tX2RlbnRyeShmaWxlLT5mX3BhdGguZGVudHJ5KTsKIAlpZiAoZnVsbF9wYXRoID09IE5VTEwpIHsKIAkJcmMgPSAtRU5PTUVNOwpAQCAtNzI2LDEyICs3MzEsMTIgQEAKIAogCQkvKiBCQiB3ZSBjb3VsZCBjaGFpbiB0aGVzZSBpbnRvIG9uZSBsb2NrIHJlcXVlc3QgQkIgKi8KIAkJcmMgPSBDSUZTU01CTG9jayh4aWQsIHRjb24sIG5ldGZpZCwgbGVuZ3RoLCBwZkxvY2stPmZsX3N0YXJ0LAotCQkJCSAwLCAxLCBsb2NrVHlwZSwgMCAvKiB3YWl0IGZsYWcgKi8gKTsKKwkJCQkgMCwgMSwgbG9ja1R5cGUsIDAgLyogd2FpdCBmbGFnICovLCAwKTsKIAkJaWYgKHJjID09IDApIHsKIAkJCXJjID0gQ0lGU1NNQkxvY2soeGlkLCB0Y29uLCBuZXRmaWQsIGxlbmd0aCwKIAkJCQkJIHBmTG9jay0+Zmxfc3RhcnQsIDEgLyogbnVtVW5sb2NrICovICwKIAkJCQkJIDAgLyogbnVtTG9jayAqLyAsIGxvY2tUeXBlLAotCQkJCQkgMCAvKiB3YWl0IGZsYWcgKi8gKTsKKwkJCQkJIDAgLyogd2FpdCBmbGFnICovLCAwKTsKIAkJCXBmTG9jay0+ZmxfdHlwZSA9IEZfVU5MQ0s7CiAJCQlpZiAocmMgIT0gMCkKIAkJCQljRVJST1IoMSwgIkVycm9yIHVubG9ja2luZyBwcmV2aW91c2x5IGxvY2tlZCAiCkBAIC03NDgsMTMgKzc1MywxMyBAQAogCQkJCXJjID0gQ0lGU1NNQkxvY2soeGlkLCB0Y29uLCBuZXRmaWQsIGxlbmd0aCwKIAkJCQkJcGZMb2NrLT5mbF9zdGFydCwgMCwgMSwKIAkJCQkJbG9ja1R5cGUgfCBMT0NLSU5HX0FORFhfU0hBUkVEX0xPQ0ssCi0JCQkJCTAgLyogd2FpdCBmbGFnICovKTsKKwkJCQkJMCAvKiB3YWl0IGZsYWcgKi8sIDApOwogCQkJCWlmIChyYyA9PSAwKSB7CiAJCQkJCXJjID0gQ0lGU1NNQkxvY2soeGlkLCB0Y29uLCBuZXRmaWQsCiAJCQkJCQlsZW5ndGgsIHBmTG9jay0+Zmxfc3RhcnQsIDEsIDAsCiAJCQkJCQlsb2NrVHlwZSB8CiAJCQkJCQlMT0NLSU5HX0FORFhfU0hBUkVEX0xPQ0ssCi0JCQkJCQkwIC8qIHdhaXQgZmxhZyAqLyk7CisJCQkJCQkwIC8qIHdhaXQgZmxhZyAqLywgMCk7CiAJCQkJCXBmTG9jay0+ZmxfdHlwZSA9IEZfUkRMQ0s7CiAJCQkJCWlmIChyYyAhPSAwKQogCQkJCQkJY0VSUk9SKDEsICJFcnJvciB1bmxvY2tpbmcgIgpAQCAtNzk3LDggKzgwMiw4IEBACiAKIAkJaWYgKG51bUxvY2spIHsKIAkJCXJjID0gQ0lGU1NNQkxvY2soeGlkLCB0Y29uLCBuZXRmaWQsIGxlbmd0aCwKLQkJCQkJcGZMb2NrLT5mbF9zdGFydCwKLQkJCQkJMCwgbnVtTG9jaywgbG9ja1R5cGUsIHdhaXRfZmxhZyk7CisJCQkJCSBwZkxvY2stPmZsX3N0YXJ0LCAwLCBudW1Mb2NrLCBsb2NrVHlwZSwKKwkJCQkJIHdhaXRfZmxhZywgMCk7CiAKIAkJCWlmIChyYyA9PSAwKSB7CiAJCQkJLyogRm9yIFdpbmRvd3MgbG9ja3Mgd2UgbXVzdCBzdG9yZSB0aGVtLiAqLwpAQCAtODE4LDkgKzgyMyw5IEBACiAJCQkJCQkocGZMb2NrLT5mbF9zdGFydCArIGxlbmd0aCkgPj0KIAkJCQkJCShsaS0+b2Zmc2V0ICsgbGktPmxlbmd0aCkpIHsKIAkJCQkJc3RvcmVkX3JjID0gQ0lGU1NNQkxvY2soeGlkLCB0Y29uLAotCQkJCQkJCW5ldGZpZCwKLQkJCQkJCQlsaS0+bGVuZ3RoLCBsaS0+b2Zmc2V0LAotCQkJCQkJCTEsIDAsIGxpLT50eXBlLCBmYWxzZSk7CisJCQkJCQkJbmV0ZmlkLCBsaS0+bGVuZ3RoLAorCQkJCQkJCWxpLT5vZmZzZXQsIDEsIDAsCisJCQkJCQkJbGktPnR5cGUsIGZhbHNlLCAwKTsKIAkJCQkJaWYgKHN0b3JlZF9yYykKIAkJCQkJCXJjID0gc3RvcmVkX3JjOwogCQkJCQllbHNlIHsKQEAgLTgzOSwzMSArODQ0LDggQEAKIAlyZXR1cm4gcmM7CiB9CiAKLS8qCi0gKiBTZXQgdGhlIHRpbWVvdXQgb24gd3JpdGUgcmVxdWVzdHMgcGFzdCBFT0YuIEZvciBzb21lIHNlcnZlcnMgKFdpbmRvd3MpCi0gKiB0aGVzZSBjYWxscyBjYW4gYmUgdmVyeSBsb25nLgotICoKLSAqIElmIHdlJ3JlIHdyaXRpbmcgPjEwTSBwYXN0IHRoZSBFT0Ygd2UgZ2l2ZSBhIDE4MHMgdGltZW91dC4gQW55dGhpbmcgbGVzcwotICogdGhhbiB0aGF0IGdldHMgYSA0NXMgdGltZW91dC4gV3JpdGVzIG5vdCBwYXN0IEVPRiBnZXQgMTVzIHRpbWVvdXRzLgotICogVGhlIDEwTSBjdXRvZmYgaXMgdG90YWxseSBhcmJpdHJhcnkuIEEgYmV0dGVyIHNjaGVtZSBmb3IgdGhpcyB3b3VsZCBiZQotICogd2VsY29tZSBpZiBzb21lb25lIHdhbnRzIHRvIHN1Z2dlc3Qgb25lLgotICoKLSAqIFdlIG1heSBiZSBhYmxlIHRvIGRvIGEgYmV0dGVyIGpvYiB3aXRoIHRoaXMgaWYgdGhlcmUgd2VyZSBzb21lIHdheSB0bwotICogZGVjbGFyZSB0aGF0IGEgZmlsZSBzaG91bGQgYmUgc3BhcnNlLgotICovCi1zdGF0aWMgaW50Ci1jaWZzX3dyaXRlX3RpbWVvdXQoc3RydWN0IGNpZnNJbm9kZUluZm8gKmNpZnNpLCBsb2ZmX3Qgb2Zmc2V0KQotewotCWlmIChvZmZzZXQgPD0gY2lmc2ktPnNlcnZlcl9lb2YpCi0JCXJldHVybiBDSUZTX1NURF9PUDsKLQllbHNlIGlmIChvZmZzZXQgPiAoY2lmc2ktPnNlcnZlcl9lb2YgKyAoMTAgKiAxMDI0ICogMTAyNCkpKQotCQlyZXR1cm4gQ0lGU19WTE9OR19PUDsKLQllbHNlCi0JCXJldHVybiBDSUZTX0xPTkdfT1A7Ci19Ci0KIC8qIHVwZGF0ZSB0aGUgZmlsZSBzaXplIChpZiBuZWVkZWQpIGFmdGVyIGEgd3JpdGUgKi8KLXN0YXRpYyB2b2lkCit2b2lkCiBjaWZzX3VwZGF0ZV9lb2Yoc3RydWN0IGNpZnNJbm9kZUluZm8gKmNpZnNpLCBsb2ZmX3Qgb2Zmc2V0LAogCQkgICAgICB1bnNpZ25lZCBpbnQgYnl0ZXNfd3JpdHRlbikKIHsKQEAgLTg4Miw3ICs4NjQsNyBAQAogCXVuc2lnbmVkIGludCB0b3RhbF93cml0dGVuOwogCXN0cnVjdCBjaWZzX3NiX2luZm8gKmNpZnNfc2I7CiAJc3RydWN0IGNpZnNUY29uSW5mbyAqcFRjb247Ci0JaW50IHhpZCwgbG9uZ19vcDsKKwlpbnQgeGlkOwogCXN0cnVjdCBjaWZzRmlsZUluZm8gKm9wZW5fZmlsZTsKIAlzdHJ1Y3QgY2lmc0lub2RlSW5mbyAqY2lmc2kgPSBDSUZTX0koaW5vZGUpOwogCkBAIC05MDMsNyArODg1LDYgQEAKIAogCXhpZCA9IEdldFhpZCgpOwogCi0JbG9uZ19vcCA9IGNpZnNfd3JpdGVfdGltZW91dChjaWZzaSwgKnBvZmZzZXQpOwogCWZvciAodG90YWxfd3JpdHRlbiA9IDA7IHdyaXRlX3NpemUgPiB0b3RhbF93cml0dGVuOwogCSAgICAgdG90YWxfd3JpdHRlbiArPSBieXRlc193cml0dGVuKSB7CiAJCXJjID0gLUVBR0FJTjsKQEAgLTkzMSw3ICs5MTIsNyBAQAogCQkJCW1pbl90KGNvbnN0IGludCwgY2lmc19zYi0+d3NpemUsCiAJCQkJICAgICAgd3JpdGVfc2l6ZSAtIHRvdGFsX3dyaXR0ZW4pLAogCQkJCSpwb2Zmc2V0LCAmYnl0ZXNfd3JpdHRlbiwKLQkJCQlOVUxMLCB3cml0ZV9kYXRhICsgdG90YWxfd3JpdHRlbiwgbG9uZ19vcCk7CisJCQkJTlVMTCwgd3JpdGVfZGF0YSArIHRvdGFsX3dyaXR0ZW4sIDApOwogCQl9CiAJCWlmIChyYyB8fCAoYnl0ZXNfd3JpdHRlbiA9PSAwKSkgewogCQkJaWYgKHRvdGFsX3dyaXR0ZW4pCkBAIC05NDQsOCArOTI1LDYgQEAKIAkJCWNpZnNfdXBkYXRlX2VvZihjaWZzaSwgKnBvZmZzZXQsIGJ5dGVzX3dyaXR0ZW4pOwogCQkJKnBvZmZzZXQgKz0gYnl0ZXNfd3JpdHRlbjsKIAkJfQotCQlsb25nX29wID0gQ0lGU19TVERfT1A7IC8qIHN1YnNlcXVlbnQgd3JpdGVzIGZhc3QgLQotCQkJCSAgICAxNSBzZWNvbmRzIGlzIHBsZW50eSAqLwogCX0KIAogCWNpZnNfc3RhdHNfYnl0ZXNfd3JpdHRlbihwVGNvbiwgdG90YWxfd3JpdHRlbik7CkBAIC05NzQsNyArOTUzLDcgQEAKIAl1bnNpZ25lZCBpbnQgdG90YWxfd3JpdHRlbjsKIAlzdHJ1Y3QgY2lmc19zYl9pbmZvICpjaWZzX3NiOwogCXN0cnVjdCBjaWZzVGNvbkluZm8gKnBUY29uOwotCWludCB4aWQsIGxvbmdfb3A7CisJaW50IHhpZDsKIAlzdHJ1Y3QgZGVudHJ5ICpkZW50cnkgPSBvcGVuX2ZpbGUtPmRlbnRyeTsKIAlzdHJ1Y3QgY2lmc0lub2RlSW5mbyAqY2lmc2kgPSBDSUZTX0koZGVudHJ5LT5kX2lub2RlKTsKIApAQCAtOTg3LDcgKzk2Niw2IEBACiAKIAl4aWQgPSBHZXRYaWQoKTsKIAotCWxvbmdfb3AgPSBjaWZzX3dyaXRlX3RpbWVvdXQoY2lmc2ksICpwb2Zmc2V0KTsKIAlmb3IgKHRvdGFsX3dyaXR0ZW4gPSAwOyB3cml0ZV9zaXplID4gdG90YWxfd3JpdHRlbjsKIAkgICAgIHRvdGFsX3dyaXR0ZW4gKz0gYnl0ZXNfd3JpdHRlbikgewogCQlyYyA9IC1FQUdBSU47CkBAIC0xMDE3LDcgKzk5NSw3IEBACiAJCQkJcmMgPSBDSUZTU01CV3JpdGUyKHhpZCwgcFRjb24sCiAJCQkJCQlvcGVuX2ZpbGUtPm5ldGZpZCwgbGVuLAogCQkJCQkJKnBvZmZzZXQsICZieXRlc193cml0dGVuLAotCQkJCQkJaW92LCAxLCBsb25nX29wKTsKKwkJCQkJCWlvdiwgMSwgMCk7CiAJCQl9IGVsc2UKIAkJCQlyYyA9IENJRlNTTUJXcml0ZSh4aWQsIHBUY29uLAogCQkJCQkgb3Blbl9maWxlLT5uZXRmaWQsCkBAIC0xMDI1LDcgKzEwMDMsNyBAQAogCQkJCQkgICAgICAgd3JpdGVfc2l6ZSAtIHRvdGFsX3dyaXR0ZW4pLAogCQkJCQkgKnBvZmZzZXQsICZieXRlc193cml0dGVuLAogCQkJCQkgd3JpdGVfZGF0YSArIHRvdGFsX3dyaXR0ZW4sCi0JCQkJCSBOVUxMLCBsb25nX29wKTsKKwkJCQkJIE5VTEwsIDApOwogCQl9CiAJCWlmIChyYyB8fCAoYnl0ZXNfd3JpdHRlbiA9PSAwKSkgewogCQkJaWYgKHRvdGFsX3dyaXR0ZW4pCkBAIC0xMDM4LDggKzEwMTYsNiBAQAogCQkJY2lmc191cGRhdGVfZW9mKGNpZnNpLCAqcG9mZnNldCwgYnl0ZXNfd3JpdHRlbik7CiAJCQkqcG9mZnNldCArPSBieXRlc193cml0dGVuOwogCQl9Ci0JCWxvbmdfb3AgPSBDSUZTX1NURF9PUDsgLyogc3Vic2VxdWVudCB3cml0ZXMgZmFzdCAtCi0JCQkJICAgIDE1IHNlY29uZHMgaXMgcGxlbnR5ICovCiAJfQogCiAJY2lmc19zdGF0c19ieXRlc193cml0dGVuKHBUY29uLCB0b3RhbF93cml0dGVuKTsKQEAgLTExNjcsNyArMTE0Myw2IEBACiAJY2hhciAqd3JpdGVfZGF0YTsKIAlpbnQgcmMgPSAtRUZBVUxUOwogCWludCBieXRlc193cml0dGVuID0gMDsKLQlzdHJ1Y3QgY2lmc19zYl9pbmZvICpjaWZzX3NiOwogCXN0cnVjdCBpbm9kZSAqaW5vZGU7CiAJc3RydWN0IGNpZnNGaWxlSW5mbyAqb3Blbl9maWxlOwogCkBAIC0xMTc1LDcgKzExNTAsNiBAQAogCQlyZXR1cm4gLUVGQVVMVDsKIAogCWlub2RlID0gcGFnZS0+bWFwcGluZy0+aG9zdDsKLQljaWZzX3NiID0gQ0lGU19TQihpbm9kZS0+aV9zYik7CiAKIAlvZmZzZXQgKz0gKGxvZmZfdClmcm9tOwogCXdyaXRlX2RhdGEgPSBrbWFwKHBhZ2UpOwpAQCAtMTIzOSw3ICsxMjEzLDcgQEAKIAlzdHJ1Y3QgcGFnZXZlYyBwdmVjOwogCWludCByYyA9IDA7CiAJaW50IHNjYW5uZWQgPSAwOwotCWludCB4aWQsIGxvbmdfb3A7CisJaW50IHhpZDsKIAogCWNpZnNfc2IgPSBDSUZTX1NCKG1hcHBpbmctPmhvc3QtPmlfc2IpOwogCkBAIC0xMzc3LDQzICsxMzUxLDY3IEBACiAJCQkJYnJlYWs7CiAJCX0KIAkJaWYgKG5faW92KSB7CityZXRyeV93cml0ZToKIAkJCW9wZW5fZmlsZSA9IGZpbmRfd3JpdGFibGVfZmlsZShDSUZTX0kobWFwcGluZy0+aG9zdCksCiAJCQkJCQkJZmFsc2UpOwogCQkJaWYgKCFvcGVuX2ZpbGUpIHsKIAkJCQljRVJST1IoMSwgIk5vIHdyaXRhYmxlIGhhbmRsZXMgZm9yIGlub2RlIik7CiAJCQkJcmMgPSAtRUJBREY7CiAJCQl9IGVsc2UgewotCQkJCWxvbmdfb3AgPSBjaWZzX3dyaXRlX3RpbWVvdXQoY2lmc2ksIG9mZnNldCk7CiAJCQkJcmMgPSBDSUZTU01CV3JpdGUyKHhpZCwgdGNvbiwgb3Blbl9maWxlLT5uZXRmaWQsCiAJCQkJCQkgICBieXRlc190b193cml0ZSwgb2Zmc2V0LAogCQkJCQkJICAgJmJ5dGVzX3dyaXR0ZW4sIGlvdiwgbl9pb3YsCi0JCQkJCQkgICBsb25nX29wKTsKKwkJCQkJCSAgIDApOwogCQkJCWNpZnNGaWxlSW5mb19wdXQob3Blbl9maWxlKTsKLQkJCQljaWZzX3VwZGF0ZV9lb2YoY2lmc2ksIG9mZnNldCwgYnl0ZXNfd3JpdHRlbik7CiAJCQl9CiAKLQkJCWlmIChyYyB8fCBieXRlc193cml0dGVuIDwgYnl0ZXNfdG9fd3JpdGUpIHsKLQkJCQljRVJST1IoMSwgIldyaXRlMiByZXQgJWQsIHdyb3RlICVkIiwKLQkJCQkJICByYywgYnl0ZXNfd3JpdHRlbik7Ci0JCQkJbWFwcGluZ19zZXRfZXJyb3IobWFwcGluZywgcmMpOwotCQkJfSBlbHNlIHsKKwkJCWNGWUkoMSwgIldyaXRlMiByYz0lZCwgd3JvdGU9JXUiLCByYywgYnl0ZXNfd3JpdHRlbik7CisKKwkJCS8qCisJCQkgKiBGb3Igbm93LCB0cmVhdCBhIHNob3J0IHdyaXRlIGFzIGlmIG5vdGhpbmcgZ290CisJCQkgKiB3cml0dGVuLiBBIHplcm8gbGVuZ3RoIHdyaXRlIGhvd2V2ZXIgaW5kaWNhdGVzCisJCQkgKiBFTk9TUEMgb3IgRUZCSUcuIFdlIGhhdmUgbm8gd2F5IHRvIGtub3cgd2hpY2gKKwkJCSAqIHRob3VnaCwgc28gY2FsbCBpdCBFTk9TUEMgZm9yIG5vdy4gRUZCSUcgd291bGQKKwkJCSAqIGdldCB0cmFuc2xhdGVkIHRvIEFTX0VJTyBhbnl3YXkuCisJCQkgKgorCQkJICogRklYTUU6IG1ha2UgaXQgdGFrZSBpbnRvIGFjY291bnQgdGhlIGRhdGEgdGhhdCBkaWQKKwkJCSAqCSAgZ2V0IHdyaXR0ZW4KKwkJCSAqLworCQkJaWYgKHJjID09IDApIHsKKwkJCQlpZiAoYnl0ZXNfd3JpdHRlbiA9PSAwKQorCQkJCQlyYyA9IC1FTk9TUEM7CisJCQkJZWxzZSBpZiAoYnl0ZXNfd3JpdHRlbiA8IGJ5dGVzX3RvX3dyaXRlKQorCQkJCQlyYyA9IC1FQUdBSU47CisJCQl9CisKKwkJCS8qIHJldHJ5IG9uIGRhdGEtaW50ZWdyaXR5IGZsdXNoICovCisJCQlpZiAod2JjLT5zeW5jX21vZGUgPT0gV0JfU1lOQ19BTEwgJiYgcmMgPT0gLUVBR0FJTikKKwkJCQlnb3RvIHJldHJ5X3dyaXRlOworCisJCQkvKiBmaXggdGhlIHN0YXRzIGFuZCBFT0YgKi8KKwkJCWlmIChieXRlc193cml0dGVuID4gMCkgewogCQkJCWNpZnNfc3RhdHNfYnl0ZXNfd3JpdHRlbih0Y29uLCBieXRlc193cml0dGVuKTsKKwkJCQljaWZzX3VwZGF0ZV9lb2YoY2lmc2ksIG9mZnNldCwgYnl0ZXNfd3JpdHRlbik7CiAJCQl9CiAKIAkJCWZvciAoaSA9IDA7IGkgPCBuX2lvdjsgaSsrKSB7CiAJCQkJcGFnZSA9IHB2ZWMucGFnZXNbZmlyc3QgKyBpXTsKLQkJCQkvKiBTaG91bGQgd2UgYWxzbyBzZXQgcGFnZSBlcnJvciBvbgotCQkJCXN1Y2Nlc3MgcmMgYnV0IHRvbyBsaXR0bGUgZGF0YSB3cml0dGVuPyAqLwotCQkJCS8qIEJCIGludmVzdGlnYXRlIHJldHJ5IGxvZ2ljIG9uIHRlbXBvcmFyeQotCQkJCXNlcnZlciBjcmFzaCBjYXNlcyBhbmQgaG93IHJlY292ZXJ5IHdvcmtzCi0JCQkJd2hlbiBwYWdlIG1hcmtlZCBhcyBlcnJvciAqLwotCQkJCWlmIChyYykKKwkJCQkvKiBvbiByZXRyeWFibGUgd3JpdGUgZXJyb3IsIHJlZGlydHkgcGFnZSAqLworCQkJCWlmIChyYyA9PSAtRUFHQUlOKQorCQkJCQlyZWRpcnR5X3BhZ2VfZm9yX3dyaXRlcGFnZSh3YmMsIHBhZ2UpOworCQkJCWVsc2UgaWYgKHJjICE9IDApCiAJCQkJCVNldFBhZ2VFcnJvcihwYWdlKTsKIAkJCQlrdW5tYXAocGFnZSk7CiAJCQkJdW5sb2NrX3BhZ2UocGFnZSk7CiAJCQkJZW5kX3BhZ2Vfd3JpdGViYWNrKHBhZ2UpOwogCQkJCXBhZ2VfY2FjaGVfcmVsZWFzZShwYWdlKTsKIAkJCX0KKworCQkJaWYgKHJjICE9IC1FQUdBSU4pCisJCQkJbWFwcGluZ19zZXRfZXJyb3IobWFwcGluZywgcmMpOworCQkJZWxzZQorCQkJCXJjID0gMDsKKwogCQkJaWYgKCh3YmMtPm5yX3RvX3dyaXRlIC09IG5faW92KSA8PSAwKQogCQkJCWRvbmUgPSAxOwogCQkJaW5kZXggPSBuZXh0OwpAQCAtMTUyNSwyNyArMTUyMyw0NyBAQAogCXJldHVybiByYzsKIH0KIAotaW50IGNpZnNfZnN5bmMoc3RydWN0IGZpbGUgKmZpbGUsIGludCBkYXRhc3luYykKK2ludCBjaWZzX3N0cmljdF9mc3luYyhzdHJ1Y3QgZmlsZSAqZmlsZSwgaW50IGRhdGFzeW5jKQogewogCWludCB4aWQ7CiAJaW50IHJjID0gMDsKIAlzdHJ1Y3QgY2lmc1Rjb25JbmZvICp0Y29uOwogCXN0cnVjdCBjaWZzRmlsZUluZm8gKnNtYmZpbGUgPSBmaWxlLT5wcml2YXRlX2RhdGE7CiAJc3RydWN0IGlub2RlICppbm9kZSA9IGZpbGUtPmZfcGF0aC5kZW50cnktPmRfaW5vZGU7CisJc3RydWN0IGNpZnNfc2JfaW5mbyAqY2lmc19zYiA9IENJRlNfU0IoaW5vZGUtPmlfc2IpOwogCiAJeGlkID0gR2V0WGlkKCk7CiAKIAljRllJKDEsICJTeW5jIGZpbGUgLSBuYW1lOiAlcyBkYXRhc3luYzogMHgleCIsCiAJCWZpbGUtPmZfcGF0aC5kZW50cnktPmRfbmFtZS5uYW1lLCBkYXRhc3luYyk7CiAKLQlyYyA9IGZpbGVtYXBfd3JpdGVfYW5kX3dhaXQoaW5vZGUtPmlfbWFwcGluZyk7Ci0JaWYgKHJjID09IDApIHsKLQkJc3RydWN0IGNpZnNfc2JfaW5mbyAqY2lmc19zYiA9IENJRlNfU0IoaW5vZGUtPmlfc2IpOworCWlmICghQ0lGU19JKGlub2RlKS0+Y2xpZW50Q2FuQ2FjaGVSZWFkKQorCQljaWZzX2ludmFsaWRhdGVfbWFwcGluZyhpbm9kZSk7CiAKLQkJdGNvbiA9IHRsaW5rX3Rjb24oc21iZmlsZS0+dGxpbmspOwotCQlpZiAoIShjaWZzX3NiLT5tbnRfY2lmc19mbGFncyAmIENJRlNfTU9VTlRfTk9TU1lOQykpCi0JCQlyYyA9IENJRlNTTUJGbHVzaCh4aWQsIHRjb24sIHNtYmZpbGUtPm5ldGZpZCk7Ci0JfQorCXRjb24gPSB0bGlua190Y29uKHNtYmZpbGUtPnRsaW5rKTsKKwlpZiAoIShjaWZzX3NiLT5tbnRfY2lmc19mbGFncyAmIENJRlNfTU9VTlRfTk9TU1lOQykpCisJCXJjID0gQ0lGU1NNQkZsdXNoKHhpZCwgdGNvbiwgc21iZmlsZS0+bmV0ZmlkKTsKKworCUZyZWVYaWQoeGlkKTsKKwlyZXR1cm4gcmM7Cit9CisKK2ludCBjaWZzX2ZzeW5jKHN0cnVjdCBmaWxlICpmaWxlLCBpbnQgZGF0YXN5bmMpCit7CisJaW50IHhpZDsKKwlpbnQgcmMgPSAwOworCXN0cnVjdCBjaWZzVGNvbkluZm8gKnRjb247CisJc3RydWN0IGNpZnNGaWxlSW5mbyAqc21iZmlsZSA9IGZpbGUtPnByaXZhdGVfZGF0YTsKKwlzdHJ1Y3QgY2lmc19zYl9pbmZvICpjaWZzX3NiID0gQ0lGU19TQihmaWxlLT5mX3BhdGguZGVudHJ5LT5kX3NiKTsKKworCXhpZCA9IEdldFhpZCgpOworCisJY0ZZSSgxLCAiU3luYyBmaWxlIC0gbmFtZTogJXMgZGF0YXN5bmM6IDB4JXgiLAorCQlmaWxlLT5mX3BhdGguZGVudHJ5LT5kX25hbWUubmFtZSwgZGF0YXN5bmMpOworCisJdGNvbiA9IHRsaW5rX3Rjb24oc21iZmlsZS0+dGxpbmspOworCWlmICghKGNpZnNfc2ItPm1udF9jaWZzX2ZsYWdzICYgQ0lGU19NT1VOVF9OT1NTWU5DKSkKKwkJcmMgPSBDSUZTU01CRmx1c2goeGlkLCB0Y29uLCBzbWJmaWxlLT5uZXRmaWQpOwogCiAJRnJlZVhpZCh4aWQpOwogCXJldHVybiByYzsKQEAgLTE1OTYsNDIgKzE2MTQsMjQ0IEBACiAJcmV0dXJuIHJjOwogfQogCi1zc2l6ZV90IGNpZnNfdXNlcl9yZWFkKHN0cnVjdCBmaWxlICpmaWxlLCBjaGFyIF9fdXNlciAqcmVhZF9kYXRhLAotCXNpemVfdCByZWFkX3NpemUsIGxvZmZfdCAqcG9mZnNldCkKK3N0YXRpYyBpbnQKK2NpZnNfd3JpdGVfYWxsb2NhdGVfcGFnZXMoc3RydWN0IHBhZ2UgKipwYWdlcywgdW5zaWduZWQgbG9uZyBudW1fcGFnZXMpCiB7Ci0JaW50IHJjID0gLUVBQ0NFUzsKKwlpbnQgcmMgPSAwOworCXVuc2lnbmVkIGxvbmcgaTsKKworCWZvciAoaSA9IDA7IGkgPCBudW1fcGFnZXM7IGkrKykgeworCQlwYWdlc1tpXSA9IGFsbG9jX3BhZ2UoX19HRlBfSElHSE1FTSk7CisJCWlmICghcGFnZXNbaV0pIHsKKwkJCS8qCisJCQkgKiBzYXZlIG51bWJlciBvZiBwYWdlcyB3ZSBoYXZlIGFscmVhZHkgYWxsb2NhdGVkIGFuZAorCQkJICogcmV0dXJuIHdpdGggRU5PTUVNIGVycm9yCisJCQkgKi8KKwkJCW51bV9wYWdlcyA9IGk7CisJCQlyYyA9IC1FTk9NRU07CisJCQlnb3RvIGVycm9yOworCQl9CisJfQorCisJcmV0dXJuIHJjOworCitlcnJvcjoKKwlmb3IgKGkgPSAwOyBpIDwgbnVtX3BhZ2VzOyBpKyspCisJCXB1dF9wYWdlKHBhZ2VzW2ldKTsKKwlyZXR1cm4gcmM7Cit9CisKK3N0YXRpYyBpbmxpbmUKK3NpemVfdCBnZXRfbnVtcGFnZXMoY29uc3Qgc2l6ZV90IHdzaXplLCBjb25zdCBzaXplX3QgbGVuLCBzaXplX3QgKmN1cl9sZW4pCit7CisJc2l6ZV90IG51bV9wYWdlczsKKwlzaXplX3QgY2xlbjsKKworCWNsZW4gPSBtaW5fdChjb25zdCBzaXplX3QsIGxlbiwgd3NpemUpOworCW51bV9wYWdlcyA9IGNsZW4gLyBQQUdFX0NBQ0hFX1NJWkU7CisJaWYgKGNsZW4gJSBQQUdFX0NBQ0hFX1NJWkUpCisJCW51bV9wYWdlcysrOworCisJaWYgKGN1cl9sZW4pCisJCSpjdXJfbGVuID0gY2xlbjsKKworCXJldHVybiBudW1fcGFnZXM7Cit9CisKK3N0YXRpYyBzc2l6ZV90CitjaWZzX2lvdmVjX3dyaXRlKHN0cnVjdCBmaWxlICpmaWxlLCBjb25zdCBzdHJ1Y3QgaW92ZWMgKmlvdiwKKwkJIHVuc2lnbmVkIGxvbmcgbnJfc2VncywgbG9mZl90ICpwb2Zmc2V0KQoreworCXVuc2lnbmVkIGludCB3cml0dGVuOworCXVuc2lnbmVkIGxvbmcgbnVtX3BhZ2VzLCBucGFnZXMsIGk7CisJc2l6ZV90IGNvcGllZCwgbGVuLCBjdXJfbGVuOworCXNzaXplX3QgdG90YWxfd3JpdHRlbiA9IDA7CisJc3RydWN0IGt2ZWMgKnRvX3NlbmQ7CisJc3RydWN0IHBhZ2UgKipwYWdlczsKKwlzdHJ1Y3QgaW92X2l0ZXIgaXQ7CisJc3RydWN0IGlub2RlICppbm9kZTsKKwlzdHJ1Y3QgY2lmc0ZpbGVJbmZvICpvcGVuX2ZpbGU7CisJc3RydWN0IGNpZnNUY29uSW5mbyAqcFRjb247CisJc3RydWN0IGNpZnNfc2JfaW5mbyAqY2lmc19zYjsKKwlpbnQgeGlkLCByYzsKKworCWxlbiA9IGlvdl9sZW5ndGgoaW92LCBucl9zZWdzKTsKKwlpZiAoIWxlbikKKwkJcmV0dXJuIDA7CisKKwlyYyA9IGdlbmVyaWNfd3JpdGVfY2hlY2tzKGZpbGUsIHBvZmZzZXQsICZsZW4sIDApOworCWlmIChyYykKKwkJcmV0dXJuIHJjOworCisJY2lmc19zYiA9IENJRlNfU0IoZmlsZS0+Zl9wYXRoLmRlbnRyeS0+ZF9zYik7CisJbnVtX3BhZ2VzID0gZ2V0X251bXBhZ2VzKGNpZnNfc2ItPndzaXplLCBsZW4sICZjdXJfbGVuKTsKKworCXBhZ2VzID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IHBhZ2VzICopKm51bV9wYWdlcywgR0ZQX0tFUk5FTCk7CisJaWYgKCFwYWdlcykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwl0b19zZW5kID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IGt2ZWMpKihudW1fcGFnZXMgKyAxKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCF0b19zZW5kKSB7CisJCWtmcmVlKHBhZ2VzKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJcmMgPSBjaWZzX3dyaXRlX2FsbG9jYXRlX3BhZ2VzKHBhZ2VzLCBudW1fcGFnZXMpOworCWlmIChyYykgeworCQlrZnJlZShwYWdlcyk7CisJCWtmcmVlKHRvX3NlbmQpOworCQlyZXR1cm4gcmM7CisJfQorCisJeGlkID0gR2V0WGlkKCk7CisJb3Blbl9maWxlID0gZmlsZS0+cHJpdmF0ZV9kYXRhOworCXBUY29uID0gdGxpbmtfdGNvbihvcGVuX2ZpbGUtPnRsaW5rKTsKKwlpbm9kZSA9IGZpbGUtPmZfcGF0aC5kZW50cnktPmRfaW5vZGU7CisKKwlpb3ZfaXRlcl9pbml0KCZpdCwgaW92LCBucl9zZWdzLCBsZW4sIDApOworCW5wYWdlcyA9IG51bV9wYWdlczsKKworCWRvIHsKKwkJc2l6ZV90IHNhdmVfbGVuID0gY3VyX2xlbjsKKwkJZm9yIChpID0gMDsgaSA8IG5wYWdlczsgaSsrKSB7CisJCQljb3BpZWQgPSBtaW5fdChjb25zdCBzaXplX3QsIGN1cl9sZW4sIFBBR0VfQ0FDSEVfU0laRSk7CisJCQljb3BpZWQgPSBpb3ZfaXRlcl9jb3B5X2Zyb21fdXNlcihwYWdlc1tpXSwgJml0LCAwLAorCQkJCQkJCSBjb3BpZWQpOworCQkJY3VyX2xlbiAtPSBjb3BpZWQ7CisJCQlpb3ZfaXRlcl9hZHZhbmNlKCZpdCwgY29waWVkKTsKKwkJCXRvX3NlbmRbaSsxXS5pb3ZfYmFzZSA9IGttYXAocGFnZXNbaV0pOworCQkJdG9fc2VuZFtpKzFdLmlvdl9sZW4gPSBjb3BpZWQ7CisJCX0KKworCQljdXJfbGVuID0gc2F2ZV9sZW4gLSBjdXJfbGVuOworCisJCWRvIHsKKwkJCWlmIChvcGVuX2ZpbGUtPmludmFsaWRIYW5kbGUpIHsKKwkJCQlyYyA9IGNpZnNfcmVvcGVuX2ZpbGUob3Blbl9maWxlLCBmYWxzZSk7CisJCQkJaWYgKHJjICE9IDApCisJCQkJCWJyZWFrOworCQkJfQorCQkJcmMgPSBDSUZTU01CV3JpdGUyKHhpZCwgcFRjb24sIG9wZW5fZmlsZS0+bmV0ZmlkLAorCQkJCQkgICBjdXJfbGVuLCAqcG9mZnNldCwgJndyaXR0ZW4sCisJCQkJCSAgIHRvX3NlbmQsIG5wYWdlcywgMCk7CisJCX0gd2hpbGUgKHJjID09IC1FQUdBSU4pOworCisJCWZvciAoaSA9IDA7IGkgPCBucGFnZXM7IGkrKykKKwkJCWt1bm1hcChwYWdlc1tpXSk7CisKKwkJaWYgKHdyaXR0ZW4pIHsKKwkJCWxlbiAtPSB3cml0dGVuOworCQkJdG90YWxfd3JpdHRlbiArPSB3cml0dGVuOworCQkJY2lmc191cGRhdGVfZW9mKENJRlNfSShpbm9kZSksICpwb2Zmc2V0LCB3cml0dGVuKTsKKwkJCSpwb2Zmc2V0ICs9IHdyaXR0ZW47CisJCX0gZWxzZSBpZiAocmMgPCAwKSB7CisJCQlpZiAoIXRvdGFsX3dyaXR0ZW4pCisJCQkJdG90YWxfd3JpdHRlbiA9IHJjOworCQkJYnJlYWs7CisJCX0KKworCQkvKiBnZXQgbGVuZ3RoIGFuZCBudW1iZXIgb2Yga3ZlY3Mgb2YgdGhlIG5leHQgd3JpdGUgKi8KKwkJbnBhZ2VzID0gZ2V0X251bXBhZ2VzKGNpZnNfc2ItPndzaXplLCBsZW4sICZjdXJfbGVuKTsKKwl9IHdoaWxlIChsZW4gPiAwKTsKKworCWlmICh0b3RhbF93cml0dGVuID4gMCkgeworCQlzcGluX2xvY2soJmlub2RlLT5pX2xvY2spOworCQlpZiAoKnBvZmZzZXQgPiBpbm9kZS0+aV9zaXplKQorCQkJaV9zaXplX3dyaXRlKGlub2RlLCAqcG9mZnNldCk7CisJCXNwaW5fdW5sb2NrKCZpbm9kZS0+aV9sb2NrKTsKKwl9CisKKwljaWZzX3N0YXRzX2J5dGVzX3dyaXR0ZW4ocFRjb24sIHRvdGFsX3dyaXR0ZW4pOworCW1hcmtfaW5vZGVfZGlydHlfc3luYyhpbm9kZSk7CisKKwlmb3IgKGkgPSAwOyBpIDwgbnVtX3BhZ2VzOyBpKyspCisJCXB1dF9wYWdlKHBhZ2VzW2ldKTsKKwlrZnJlZSh0b19zZW5kKTsKKwlrZnJlZShwYWdlcyk7CisJRnJlZVhpZCh4aWQpOworCXJldHVybiB0b3RhbF93cml0dGVuOworfQorCitzdGF0aWMgc3NpemVfdCBjaWZzX3VzZXJfd3JpdGV2KHN0cnVjdCBraW9jYiAqaW9jYiwgY29uc3Qgc3RydWN0IGlvdmVjICppb3YsCisJCQkJdW5zaWduZWQgbG9uZyBucl9zZWdzLCBsb2ZmX3QgcG9zKQoreworCXNzaXplX3Qgd3JpdHRlbjsKKwlzdHJ1Y3QgaW5vZGUgKmlub2RlOworCisJaW5vZGUgPSBpb2NiLT5raV9maWxwLT5mX3BhdGguZGVudHJ5LT5kX2lub2RlOworCisJLyoKKwkgKiBCQiAtIG9wdGltaXplIHRoZSB3YXkgd2hlbiBzaWduaW5nIGlzIGRpc2FibGVkLiBXZSBjYW4gZHJvcCB0aGlzCisJICogZXh0cmEgbWVtb3J5LXRvLW1lbW9yeSBjb3B5aW5nIGFuZCB1c2UgaW92ZWMgYnVmZmVycyBmb3IgY29uc3RydWN0aW5nCisJICogd3JpdGUgcmVxdWVzdC4KKwkgKi8KKworCXdyaXR0ZW4gPSBjaWZzX2lvdmVjX3dyaXRlKGlvY2ItPmtpX2ZpbHAsIGlvdiwgbnJfc2VncywgJnBvcyk7CisJaWYgKHdyaXR0ZW4gPiAwKSB7CisJCUNJRlNfSShpbm9kZSktPmludmFsaWRfbWFwcGluZyA9IHRydWU7CisJCWlvY2ItPmtpX3BvcyA9IHBvczsKKwl9CisKKwlyZXR1cm4gd3JpdHRlbjsKK30KKworc3NpemVfdCBjaWZzX3N0cmljdF93cml0ZXYoc3RydWN0IGtpb2NiICppb2NiLCBjb25zdCBzdHJ1Y3QgaW92ZWMgKmlvdiwKKwkJCSAgIHVuc2lnbmVkIGxvbmcgbnJfc2VncywgbG9mZl90IHBvcykKK3sKKwlzdHJ1Y3QgaW5vZGUgKmlub2RlOworCisJaW5vZGUgPSBpb2NiLT5raV9maWxwLT5mX3BhdGguZGVudHJ5LT5kX2lub2RlOworCisJaWYgKENJRlNfSShpbm9kZSktPmNsaWVudENhbkNhY2hlQWxsKQorCQlyZXR1cm4gZ2VuZXJpY19maWxlX2Fpb193cml0ZShpb2NiLCBpb3YsIG5yX3NlZ3MsIHBvcyk7CisKKwkvKgorCSAqIEluIHN0cmljdCBjYWNoZSBtb2RlIHdlIG5lZWQgdG8gd3JpdGUgdGhlIGRhdGEgdG8gdGhlIHNlcnZlciBleGFjdGx5CisJICogZnJvbSB0aGUgcG9zIHRvIHBvcytsZW4tMSByYXRoZXIgdGhhbiBmbHVzaCBhbGwgYWZmZWN0ZWQgcGFnZXMKKwkgKiBiZWNhdXNlIGl0IG1heSBjYXVzZSBhIGVycm9yIHdpdGggbWFuZGF0b3J5IGxvY2tzIG9uIHRoZXNlIHBhZ2VzIGJ1dAorCSAqIG5vdCBvbiB0aGUgcmVnaW9uIGZyb20gcG9zIHRvIHBwb3MrbGVuLTEuCisJICovCisKKwlyZXR1cm4gY2lmc191c2VyX3dyaXRldihpb2NiLCBpb3YsIG5yX3NlZ3MsIHBvcyk7Cit9CisKK3N0YXRpYyBzc2l6ZV90CitjaWZzX2lvdmVjX3JlYWQoc3RydWN0IGZpbGUgKmZpbGUsIGNvbnN0IHN0cnVjdCBpb3ZlYyAqaW92LAorCQkgdW5zaWduZWQgbG9uZyBucl9zZWdzLCBsb2ZmX3QgKnBvZmZzZXQpCit7CisJaW50IHJjOworCWludCB4aWQ7CisJc3NpemVfdCB0b3RhbF9yZWFkOwogCXVuc2lnbmVkIGludCBieXRlc19yZWFkID0gMDsKLQl1bnNpZ25lZCBpbnQgdG90YWxfcmVhZCA9IDA7Ci0JdW5zaWduZWQgaW50IGN1cnJlbnRfcmVhZF9zaXplOworCXNpemVfdCBsZW4sIGN1cl9sZW47CisJaW50IGlvdl9vZmZzZXQgPSAwOwogCXN0cnVjdCBjaWZzX3NiX2luZm8gKmNpZnNfc2I7CiAJc3RydWN0IGNpZnNUY29uSW5mbyAqcFRjb247Ci0JaW50IHhpZDsKIAlzdHJ1Y3QgY2lmc0ZpbGVJbmZvICpvcGVuX2ZpbGU7Ci0JY2hhciAqc21iX3JlYWRfZGF0YTsKLQljaGFyIF9fdXNlciAqY3VycmVudF9vZmZzZXQ7CiAJc3RydWN0IHNtYl9jb21fcmVhZF9yc3AgKnBTTUJyOworCWNoYXIgKnJlYWRfZGF0YTsKKworCWlmICghbnJfc2VncykKKwkJcmV0dXJuIDA7CisKKwlsZW4gPSBpb3ZfbGVuZ3RoKGlvdiwgbnJfc2Vncyk7CisJaWYgKCFsZW4pCisJCXJldHVybiAwOwogCiAJeGlkID0gR2V0WGlkKCk7CiAJY2lmc19zYiA9IENJRlNfU0IoZmlsZS0+Zl9wYXRoLmRlbnRyeS0+ZF9zYik7CiAKLQlpZiAoZmlsZS0+cHJpdmF0ZV9kYXRhID09IE5VTEwpIHsKLQkJcmMgPSAtRUJBREY7Ci0JCUZyZWVYaWQoeGlkKTsKLQkJcmV0dXJuIHJjOwotCX0KIAlvcGVuX2ZpbGUgPSBmaWxlLT5wcml2YXRlX2RhdGE7CiAJcFRjb24gPSB0bGlua190Y29uKG9wZW5fZmlsZS0+dGxpbmspOwogCiAJaWYgKChmaWxlLT5mX2ZsYWdzICYgT19BQ0NNT0RFKSA9PSBPX1dST05MWSkKIAkJY0ZZSSgxLCAiYXR0ZW1wdGluZyByZWFkIG9uIHdyaXRlIG9ubHkgZmlsZSBpbnN0YW5jZSIpOwogCi0JZm9yICh0b3RhbF9yZWFkID0gMCwgY3VycmVudF9vZmZzZXQgPSByZWFkX2RhdGE7Ci0JICAgICByZWFkX3NpemUgPiB0b3RhbF9yZWFkOwotCSAgICAgdG90YWxfcmVhZCArPSBieXRlc19yZWFkLCBjdXJyZW50X29mZnNldCArPSBieXRlc19yZWFkKSB7Ci0JCWN1cnJlbnRfcmVhZF9zaXplID0gbWluX3QoY29uc3QgaW50LCByZWFkX3NpemUgLSB0b3RhbF9yZWFkLAotCQkJCQkgIGNpZnNfc2ItPnJzaXplKTsKKwlmb3IgKHRvdGFsX3JlYWQgPSAwOyB0b3RhbF9yZWFkIDwgbGVuOyB0b3RhbF9yZWFkICs9IGJ5dGVzX3JlYWQpIHsKKwkJY3VyX2xlbiA9IG1pbl90KGNvbnN0IHNpemVfdCwgbGVuIC0gdG90YWxfcmVhZCwgY2lmc19zYi0+cnNpemUpOwogCQlyYyA9IC1FQUdBSU47Ci0JCXNtYl9yZWFkX2RhdGEgPSBOVUxMOworCQlyZWFkX2RhdGEgPSBOVUxMOworCiAJCXdoaWxlIChyYyA9PSAtRUFHQUlOKSB7CiAJCQlpbnQgYnVmX3R5cGUgPSBDSUZTX05PX0JVRkZFUjsKIAkJCWlmIChvcGVuX2ZpbGUtPmludmFsaWRIYW5kbGUpIHsKQEAgLTE2MzksMjcgKzE4NTksMjUgQEAKIAkJCQlpZiAocmMgIT0gMCkKIAkJCQkJYnJlYWs7CiAJCQl9Ci0JCQlyYyA9IENJRlNTTUJSZWFkKHhpZCwgcFRjb24sCi0JCQkJCSBvcGVuX2ZpbGUtPm5ldGZpZCwKLQkJCQkJIGN1cnJlbnRfcmVhZF9zaXplLCAqcG9mZnNldCwKLQkJCQkJICZieXRlc19yZWFkLCAmc21iX3JlYWRfZGF0YSwKLQkJCQkJICZidWZfdHlwZSk7Ci0JCQlwU01CciA9IChzdHJ1Y3Qgc21iX2NvbV9yZWFkX3JzcCAqKXNtYl9yZWFkX2RhdGE7Ci0JCQlpZiAoc21iX3JlYWRfZGF0YSkgewotCQkJCWlmIChjb3B5X3RvX3VzZXIoY3VycmVudF9vZmZzZXQsCi0JCQkJCQlzbWJfcmVhZF9kYXRhICsKLQkJCQkJCTQgLyogUkZDMTAwMSBsZW5ndGggZmllbGQgKi8gKwotCQkJCQkJbGUxNl90b19jcHUocFNNQnItPkRhdGFPZmZzZXQpLAotCQkJCQkJYnl0ZXNfcmVhZCkpCisJCQlyYyA9IENJRlNTTUJSZWFkKHhpZCwgcFRjb24sIG9wZW5fZmlsZS0+bmV0ZmlkLAorCQkJCQkgY3VyX2xlbiwgKnBvZmZzZXQsICZieXRlc19yZWFkLAorCQkJCQkgJnJlYWRfZGF0YSwgJmJ1Zl90eXBlKTsKKwkJCXBTTUJyID0gKHN0cnVjdCBzbWJfY29tX3JlYWRfcnNwICopcmVhZF9kYXRhOworCQkJaWYgKHJlYWRfZGF0YSkgeworCQkJCWNoYXIgKmRhdGFfb2Zmc2V0ID0gcmVhZF9kYXRhICsgNCArCisJCQkJCQlsZTE2X3RvX2NwdShwU01Cci0+RGF0YU9mZnNldCk7CisJCQkJaWYgKG1lbWNweV90b2lvdmVjZW5kKGlvdiwgZGF0YV9vZmZzZXQsCisJCQkJCQkgICAgICBpb3Zfb2Zmc2V0LCBieXRlc19yZWFkKSkKIAkJCQkJcmMgPSAtRUZBVUxUOwotCiAJCQkJaWYgKGJ1Zl90eXBlID09IENJRlNfU01BTExfQlVGRkVSKQotCQkJCQljaWZzX3NtYWxsX2J1Zl9yZWxlYXNlKHNtYl9yZWFkX2RhdGEpOworCQkJCQljaWZzX3NtYWxsX2J1Zl9yZWxlYXNlKHJlYWRfZGF0YSk7CiAJCQkJZWxzZSBpZiAoYnVmX3R5cGUgPT0gQ0lGU19MQVJHRV9CVUZGRVIpCi0JCQkJCWNpZnNfYnVmX3JlbGVhc2Uoc21iX3JlYWRfZGF0YSk7Ci0JCQkJc21iX3JlYWRfZGF0YSA9IE5VTEw7CisJCQkJCWNpZnNfYnVmX3JlbGVhc2UocmVhZF9kYXRhKTsKKwkJCQlyZWFkX2RhdGEgPSBOVUxMOworCQkJCWlvdl9vZmZzZXQgKz0gYnl0ZXNfcmVhZDsKIAkJCX0KIAkJfQorCiAJCWlmIChyYyB8fCAoYnl0ZXNfcmVhZCA9PSAwKSkgewogCQkJaWYgKHRvdGFsX3JlYWQpIHsKIAkJCQlicmVhazsKQEAgLTE2NzIsMTMgKzE4OTAsNTcgQEAKIAkJCSpwb2Zmc2V0ICs9IGJ5dGVzX3JlYWQ7CiAJCX0KIAl9CisKIAlGcmVlWGlkKHhpZCk7CiAJcmV0dXJuIHRvdGFsX3JlYWQ7CiB9CiAKK3NzaXplX3QgY2lmc191c2VyX3JlYWQoc3RydWN0IGZpbGUgKmZpbGUsIGNoYXIgX191c2VyICpyZWFkX2RhdGEsCisJCSAgICAgICBzaXplX3QgcmVhZF9zaXplLCBsb2ZmX3QgKnBvZmZzZXQpCit7CisJc3RydWN0IGlvdmVjIGlvdjsKKwlpb3YuaW92X2Jhc2UgPSByZWFkX2RhdGE7CisJaW92Lmlvdl9sZW4gPSByZWFkX3NpemU7CisKKwlyZXR1cm4gY2lmc19pb3ZlY19yZWFkKGZpbGUsICZpb3YsIDEsIHBvZmZzZXQpOworfQorCitzdGF0aWMgc3NpemVfdCBjaWZzX3VzZXJfcmVhZHYoc3RydWN0IGtpb2NiICppb2NiLCBjb25zdCBzdHJ1Y3QgaW92ZWMgKmlvdiwKKwkJCSAgICAgICB1bnNpZ25lZCBsb25nIG5yX3NlZ3MsIGxvZmZfdCBwb3MpCit7CisJc3NpemVfdCByZWFkOworCisJcmVhZCA9IGNpZnNfaW92ZWNfcmVhZChpb2NiLT5raV9maWxwLCBpb3YsIG5yX3NlZ3MsICZwb3MpOworCWlmIChyZWFkID4gMCkKKwkJaW9jYi0+a2lfcG9zID0gcG9zOworCisJcmV0dXJuIHJlYWQ7Cit9CisKK3NzaXplX3QgY2lmc19zdHJpY3RfcmVhZHYoc3RydWN0IGtpb2NiICppb2NiLCBjb25zdCBzdHJ1Y3QgaW92ZWMgKmlvdiwKKwkJCSAgdW5zaWduZWQgbG9uZyBucl9zZWdzLCBsb2ZmX3QgcG9zKQoreworCXN0cnVjdCBpbm9kZSAqaW5vZGU7CisKKwlpbm9kZSA9IGlvY2ItPmtpX2ZpbHAtPmZfcGF0aC5kZW50cnktPmRfaW5vZGU7CisKKwlpZiAoQ0lGU19JKGlub2RlKS0+Y2xpZW50Q2FuQ2FjaGVSZWFkKQorCQlyZXR1cm4gZ2VuZXJpY19maWxlX2Fpb19yZWFkKGlvY2IsIGlvdiwgbnJfc2VncywgcG9zKTsKKworCS8qCisJICogSW4gc3RyaWN0IGNhY2hlIG1vZGUgd2UgbmVlZCB0byByZWFkIGZyb20gdGhlIHNlcnZlciBhbGwgdGhlIHRpbWUKKwkgKiBpZiB3ZSBkb24ndCBoYXZlIGxldmVsIElJIG9wbG9jayBiZWNhdXNlIHRoZSBzZXJ2ZXIgY2FuIGRlbGF5IG10aW1lCisJICogY2hhbmdlIC0gc28gd2UgY2FuJ3QgbWFrZSBhIGRlY2lzaW9uIGFib3V0IGlub2RlIGludmFsaWRhdGluZy4KKwkgKiBBbmQgd2UgY2FuIGFsc28gZmFpbCB3aXRoIHBhZ2VyZWFkaW5nIGlmIHRoZXJlIGFyZSBtYW5kYXRvcnkgbG9ja3MKKwkgKiBvbiBwYWdlcyBhZmZlY3RlZCBieSB0aGlzIHJlYWQgYnV0IG5vdCBvbiB0aGUgcmVnaW9uIGZyb20gcG9zIHRvCisJICogcG9zK2xlbi0xLgorCSAqLworCisJcmV0dXJuIGNpZnNfdXNlcl9yZWFkdihpb2NiLCBpb3YsIG5yX3NlZ3MsIHBvcyk7Cit9CiAKIHN0YXRpYyBzc2l6ZV90IGNpZnNfcmVhZChzdHJ1Y3QgZmlsZSAqZmlsZSwgY2hhciAqcmVhZF9kYXRhLCBzaXplX3QgcmVhZF9zaXplLAotCWxvZmZfdCAqcG9mZnNldCkKKwkJCSBsb2ZmX3QgKnBvZmZzZXQpCiB7CiAJaW50IHJjID0gLUVBQ0NFUzsKIAl1bnNpZ25lZCBpbnQgYnl0ZXNfcmVhZCA9IDA7CkBAIC0xNzQ2LDYgKzIwMDgsMjEgQEAKIAlyZXR1cm4gdG90YWxfcmVhZDsKIH0KIAoraW50IGNpZnNfZmlsZV9zdHJpY3RfbW1hcChzdHJ1Y3QgZmlsZSAqZmlsZSwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCit7CisJaW50IHJjLCB4aWQ7CisJc3RydWN0IGlub2RlICppbm9kZSA9IGZpbGUtPmZfcGF0aC5kZW50cnktPmRfaW5vZGU7CisKKwl4aWQgPSBHZXRYaWQoKTsKKworCWlmICghQ0lGU19JKGlub2RlKS0+Y2xpZW50Q2FuQ2FjaGVSZWFkKQorCQljaWZzX2ludmFsaWRhdGVfbWFwcGluZyhpbm9kZSk7CisKKwlyYyA9IGdlbmVyaWNfZmlsZV9tbWFwKGZpbGUsIHZtYSk7CisJRnJlZVhpZCh4aWQpOworCXJldHVybiByYzsKK30KKwogaW50IGNpZnNfZmlsZV9tbWFwKHN0cnVjdCBmaWxlICpmaWxlLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKIHsKIAlpbnQgcmMsIHhpZDsKQEAgLTIxOTIsNyArMjQ2OSw4IEBACiAJICovCiAJaWYgKCFjZmlsZS0+b3Bsb2NrX2JyZWFrX2NhbmNlbGxlZCkgewogCQlyYyA9IENJRlNTTUJMb2NrKDAsIHRsaW5rX3Rjb24oY2ZpbGUtPnRsaW5rKSwgY2ZpbGUtPm5ldGZpZCwgMCwKLQkJCQkgMCwgMCwgMCwgTE9DS0lOR19BTkRYX09QTE9DS19SRUxFQVNFLCBmYWxzZSk7CisJCQkJIDAsIDAsIDAsIExPQ0tJTkdfQU5EWF9PUExPQ0tfUkVMRUFTRSwgZmFsc2UsCisJCQkJIGNpbm9kZS0+Y2xpZW50Q2FuQ2FjaGVSZWFkID8gMSA6IDApOwogCQljRllJKDEsICJPcGxvY2sgcmVsZWFzZSByYyA9ICVkIiwgcmMpOwogCX0KIApkaWZmIC0tZ2l0IGEvZnMvY2lmcy9pbm9kZS5jIGIvZnMvY2lmcy9pbm9kZS5jCmluZGV4IGIwNmI2MDYuLjg4NTI0NzAgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvaW5vZGUuYworKysgYi9mcy9jaWZzL2lub2RlLmMKQEAgLTMyLDcgKzMyLDcgQEAKICNpbmNsdWRlICJmc2NhY2hlLmgiCiAKIAotc3RhdGljIHZvaWQgY2lmc19zZXRfb3BzKHN0cnVjdCBpbm9kZSAqaW5vZGUsIGNvbnN0IGJvb2wgaXNfZGZzX3JlZmVycmFsKQorc3RhdGljIHZvaWQgY2lmc19zZXRfb3BzKHN0cnVjdCBpbm9kZSAqaW5vZGUpCiB7CiAJc3RydWN0IGNpZnNfc2JfaW5mbyAqY2lmc19zYiA9IENJRlNfU0IoaW5vZGUtPmlfc2IpOwogCkBAIC00NCwxMyArNDQsMTcgQEAKIAkJCQlpbm9kZS0+aV9mb3AgPSAmY2lmc19maWxlX2RpcmVjdF9ub2JybF9vcHM7CiAJCQllbHNlCiAJCQkJaW5vZGUtPmlfZm9wID0gJmNpZnNfZmlsZV9kaXJlY3Rfb3BzOworCQl9IGVsc2UgaWYgKGNpZnNfc2ItPm1udF9jaWZzX2ZsYWdzICYgQ0lGU19NT1VOVF9TVFJJQ1RfSU8pIHsKKwkJCWlmIChjaWZzX3NiLT5tbnRfY2lmc19mbGFncyAmIENJRlNfTU9VTlRfTk9fQlJMKQorCQkJCWlub2RlLT5pX2ZvcCA9ICZjaWZzX2ZpbGVfc3RyaWN0X25vYnJsX29wczsKKwkJCWVsc2UKKwkJCQlpbm9kZS0+aV9mb3AgPSAmY2lmc19maWxlX3N0cmljdF9vcHM7CiAJCX0gZWxzZSBpZiAoY2lmc19zYi0+bW50X2NpZnNfZmxhZ3MgJiBDSUZTX01PVU5UX05PX0JSTCkKIAkJCWlub2RlLT5pX2ZvcCA9ICZjaWZzX2ZpbGVfbm9icmxfb3BzOwogCQllbHNlIHsgLyogbm90IGRpcmVjdCwgc2VuZCBieXRlIHJhbmdlIGxvY2tzICovCiAJCQlpbm9kZS0+aV9mb3AgPSAmY2lmc19maWxlX29wczsKIAkJfQogCi0KIAkJLyogY2hlY2sgaWYgc2VydmVyIGNhbiBzdXBwb3J0IHJlYWRwYWdlcyAqLwogCQlpZiAoY2lmc19zYl9tYXN0ZXJfdGNvbihjaWZzX3NiKS0+c2VzLT5zZXJ2ZXItPm1heEJ1ZiA8CiAJCQkJUEFHRV9DQUNIRV9TSVpFICsgTUFYX0NJRlNfSERSX1NJWkUpCkBAIC02MCw3ICs2NCw3IEBACiAJCWJyZWFrOwogCWNhc2UgU19JRkRJUjoKICNpZmRlZiBDT05GSUdfQ0lGU19ERlNfVVBDQUxMCi0JCWlmIChpc19kZnNfcmVmZXJyYWwpIHsKKwkJaWYgKElTX0FVVE9NT1VOVChpbm9kZSkpIHsKIAkJCWlub2RlLT5pX29wID0gJmNpZnNfZGZzX3JlZmVycmFsX2lub2RlX29wZXJhdGlvbnM7CiAJCX0gZWxzZSB7CiAjZWxzZSAvKiBOTyBERlMgc3VwcG9ydCwgdHJlYXQgYXMgYSBkaXJlY3RvcnkgKi8KQEAgLTE2Nyw3ICsxNzEsOSBAQAogCX0KIAlzcGluX3VubG9jaygmaW5vZGUtPmlfbG9jayk7CiAKLQljaWZzX3NldF9vcHMoaW5vZGUsIGZhdHRyLT5jZl9mbGFncyAmIENJRlNfRkFUVFJfREZTX1JFRkVSUkFMKTsKKwlpZiAoZmF0dHItPmNmX2ZsYWdzICYgQ0lGU19GQVRUUl9ERlNfUkVGRVJSQUwpCisJCWlub2RlLT5pX2ZsYWdzIHw9IFNfQVVUT01PVU5UOworCWNpZnNfc2V0X29wcyhpbm9kZSk7CiB9CiAKIHZvaWQKQEAgLTE2NzcsNyArMTY4Myw3IEBACiAvKgogICogWmFwIHRoZSBjYWNoZS4gQ2FsbGVkIHdoZW4gaW52YWxpZF9tYXBwaW5nIGZsYWcgaXMgc2V0LgogICovCi1zdGF0aWMgdm9pZAordm9pZAogY2lmc19pbnZhbGlkYXRlX21hcHBpbmcoc3RydWN0IGlub2RlICppbm9kZSkKIHsKIAlpbnQgcmM7CmRpZmYgLS1naXQgYS9mcy9jaWZzL2xpbmsuYyBiL2ZzL2NpZnMvbGluay5jCmluZGV4IDMwNjc2OWQuLmU4ODA0ZDMgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvbGluay5jCisrKyBiL2ZzL2NpZnMvbGluay5jCkBAIC0yOCw3ICsyOCw2IEBACiAjaW5jbHVkZSAiY2lmc3Byb3RvLmgiCiAjaW5jbHVkZSAiY2lmc19kZWJ1Zy5oIgogI2luY2x1ZGUgImNpZnNfZnNfc2IuaCIKLSNpbmNsdWRlICJtZDUuaCIKIAogI2RlZmluZSBDSUZTX01GX1NZTUxJTktfTEVOX09GRlNFVCAoNCsxKQogI2RlZmluZSBDSUZTX01GX1NZTUxJTktfTUQ1X09GRlNFVCAoQ0lGU19NRl9TWU1MSU5LX0xFTl9PRkZTRVQrKDQrMSkpCkBAIC00Nyw2ICs0Niw0NSBAQAogCW1kNV9oYXNoWzEyXSwgbWQ1X2hhc2hbMTNdLCBtZDVfaGFzaFsxNF0sIG1kNV9oYXNoWzE1XQogCiBzdGF0aWMgaW50CitzeW1saW5rX2hhc2godW5zaWduZWQgaW50IGxpbmtfbGVuLCBjb25zdCBjaGFyICpsaW5rX3N0ciwgdTggKm1kNV9oYXNoKQoreworCWludCByYzsKKwl1bnNpZ25lZCBpbnQgc2l6ZTsKKwlzdHJ1Y3QgY3J5cHRvX3NoYXNoICptZDU7CisJc3RydWN0IHNkZXNjICpzZGVzY21kNTsKKworCW1kNSA9IGNyeXB0b19hbGxvY19zaGFzaCgibWQ1IiwgMCwgMCk7CisJaWYgKElTX0VSUihtZDUpKSB7CisJCXJjID0gUFRSX0VSUihtZDUpOworCQljRVJST1IoMSwgIiVzOiBDcnlwdG8gbWQ1IGFsbG9jYXRpb24gZXJyb3IgJWRcbiIsIF9fZnVuY19fLCByYyk7CisJCXJldHVybiByYzsKKwl9CisJc2l6ZSA9IHNpemVvZihzdHJ1Y3Qgc2hhc2hfZGVzYykgKyBjcnlwdG9fc2hhc2hfZGVzY3NpemUobWQ1KTsKKwlzZGVzY21kNSA9IGttYWxsb2Moc2l6ZSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFzZGVzY21kNSkgeworCQlyYyA9IC1FTk9NRU07CisJCWNFUlJPUigxLCAiJXM6IE1lbW9yeSBhbGxvY2F0aW9uIGZhaWx1cmVcbiIsIF9fZnVuY19fKTsKKwkJZ290byBzeW1saW5rX2hhc2hfZXJyOworCX0KKwlzZGVzY21kNS0+c2hhc2gudGZtID0gbWQ1OworCXNkZXNjbWQ1LT5zaGFzaC5mbGFncyA9IDB4MDsKKworCXJjID0gY3J5cHRvX3NoYXNoX2luaXQoJnNkZXNjbWQ1LT5zaGFzaCk7CisJaWYgKHJjKSB7CisJCWNFUlJPUigxLCAiJXM6IENvdWxkIG5vdCBpbml0IG1kNSBzaGFzaFxuIiwgX19mdW5jX18pOworCQlnb3RvIHN5bWxpbmtfaGFzaF9lcnI7CisJfQorCWNyeXB0b19zaGFzaF91cGRhdGUoJnNkZXNjbWQ1LT5zaGFzaCwgbGlua19zdHIsIGxpbmtfbGVuKTsKKwlyYyA9IGNyeXB0b19zaGFzaF9maW5hbCgmc2Rlc2NtZDUtPnNoYXNoLCBtZDVfaGFzaCk7CisKK3N5bWxpbmtfaGFzaF9lcnI6CisJY3J5cHRvX2ZyZWVfc2hhc2gobWQ1KTsKKwlrZnJlZShzZGVzY21kNSk7CisKKwlyZXR1cm4gcmM7Cit9CisKK3N0YXRpYyBpbnQKIENJRlNQYXJzZU1GU3ltbGluayhjb25zdCB1OCAqYnVmLAogCQkgICB1bnNpZ25lZCBpbnQgYnVmX2xlbiwKIAkJICAgdW5zaWduZWQgaW50ICpfbGlua19sZW4sCkBAIC01Niw3ICs5NCw2IEBACiAJdW5zaWduZWQgaW50IGxpbmtfbGVuOwogCWNvbnN0IGNoYXIgKm1kNV9zdHIxOwogCWNvbnN0IGNoYXIgKmxpbmtfc3RyOwotCXN0cnVjdCBNRDVDb250ZXh0IG1kNV9jdHg7CiAJdTggbWQ1X2hhc2hbMTZdOwogCWNoYXIgbWQ1X3N0cjJbMzRdOwogCkBAIC03MCw5ICsxMDcsMTEgQEAKIAlpZiAocmMgIT0gMSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKLQljaWZzX01ENV9pbml0KCZtZDVfY3R4KTsKLQljaWZzX01ENV91cGRhdGUoJm1kNV9jdHgsIChjb25zdCB1OCAqKWxpbmtfc3RyLCBsaW5rX2xlbik7Ci0JY2lmc19NRDVfZmluYWwobWQ1X2hhc2gsICZtZDVfY3R4KTsKKwlyYyA9IHN5bWxpbmtfaGFzaChsaW5rX2xlbiwgbGlua19zdHIsIG1kNV9oYXNoKTsKKwlpZiAocmMpIHsKKwkJY0ZZSSgxLCAiJXM6IE1ENSBoYXNoIGZhaWx1cmU6ICVkXG4iLCBfX2Z1bmNfXywgcmMpOworCQlyZXR1cm4gcmM7CisJfQogCiAJc25wcmludGYobWQ1X3N0cjIsIHNpemVvZihtZDVfc3RyMiksCiAJCSBDSUZTX01GX1NZTUxJTktfTUQ1X0ZPUk1BVCwKQEAgLTk0LDkgKzEzMyw5IEBACiBzdGF0aWMgaW50CiBDSUZTRm9ybWF0TUZTeW1saW5rKHU4ICpidWYsIHVuc2lnbmVkIGludCBidWZfbGVuLCBjb25zdCBjaGFyICpsaW5rX3N0cikKIHsKKwlpbnQgcmM7CiAJdW5zaWduZWQgaW50IGxpbmtfbGVuOwogCXVuc2lnbmVkIGludCBvZnM7Ci0Jc3RydWN0IE1ENUNvbnRleHQgbWQ1X2N0eDsKIAl1OCBtZDVfaGFzaFsxNl07CiAKIAlpZiAoYnVmX2xlbiAhPSBDSUZTX01GX1NZTUxJTktfRklMRV9TSVpFKQpAQCAtMTA3LDkgKzE0NiwxMSBAQAogCWlmIChsaW5rX2xlbiA+IENJRlNfTUZfU1lNTElOS19MSU5LX01BWExFTikKIAkJcmV0dXJuIC1FTkFNRVRPT0xPTkc7CiAKLQljaWZzX01ENV9pbml0KCZtZDVfY3R4KTsKLQljaWZzX01ENV91cGRhdGUoJm1kNV9jdHgsIChjb25zdCB1OCAqKWxpbmtfc3RyLCBsaW5rX2xlbik7Ci0JY2lmc19NRDVfZmluYWwobWQ1X2hhc2gsICZtZDVfY3R4KTsKKwlyYyA9IHN5bWxpbmtfaGFzaChsaW5rX2xlbiwgbGlua19zdHIsIG1kNV9oYXNoKTsKKwlpZiAocmMpIHsKKwkJY0ZZSSgxLCAiJXM6IE1ENSBoYXNoIGZhaWx1cmU6ICVkXG4iLCBfX2Z1bmNfXywgcmMpOworCQlyZXR1cm4gcmM7CisJfQogCiAJc25wcmludGYoYnVmLCBidWZfbGVuLAogCQkgQ0lGU19NRl9TWU1MSU5LX0xFTl9GT1JNQVQgQ0lGU19NRl9TWU1MSU5LX01ENV9GT1JNQVQsCmRpZmYgLS1naXQgYS9mcy9jaWZzL21kNC5jIGIvZnMvY2lmcy9tZDQuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTcyNWMyNi4uMDAwMDAwMAotLS0gYS9mcy9jaWZzL21kNC5jCisrKyAvZGV2L251bGwKQEAgLTEsMjA1ICswLDAgQEAKLS8qCi0gICBVbml4IFNNQi9OZXRiaW9zIGltcGxlbWVudGF0aW9uLgotICAgVmVyc2lvbiAxLjkuCi0gICBhIGltcGxlbWVudGF0aW9uIG9mIE1ENCBkZXNpZ25lZCBmb3IgdXNlIGluIHRoZSBTTUIgYXV0aGVudGljYXRpb24gcHJvdG9jb2wKLSAgIENvcHlyaWdodCAoQykgQW5kcmV3IFRyaWRnZWxsIDE5OTctMTk5OC4KLSAgIE1vZGlmaWVkIGJ5IFN0ZXZlIEZyZW5jaCAoc2ZyZW5jaEB1cy5pYm0uY29tKSAyMDAyLTIwMDMKLQotICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAgIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICAgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLQotICAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLQotICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAgIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCi0gICBGb3VuZGF0aW9uLCBJbmMuLCA2NzUgTWFzcyBBdmUsIENhbWJyaWRnZSwgTUEgMDIxMzksIFVTQS4KLSovCi0jaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Ci0jaW5jbHVkZSA8bGludXgvZnMuaD4KLSNpbmNsdWRlICJjaWZzZW5jcnlwdC5oIgotCi0vKiBOT1RFOiBUaGlzIGNvZGUgbWFrZXMgbm8gYXR0ZW1wdCB0byBiZSBmYXN0ISAqLwotCi1zdGF0aWMgX191MzIKLUYoX191MzIgWCwgX191MzIgWSwgX191MzIgWikKLXsKLQlyZXR1cm4gKFggJiBZKSB8ICgoflgpICYgWik7Ci19Ci0KLXN0YXRpYyBfX3UzMgotRyhfX3UzMiBYLCBfX3UzMiBZLCBfX3UzMiBaKQotewotCXJldHVybiAoWCAmIFkpIHwgKFggJiBaKSB8IChZICYgWik7Ci19Ci0KLXN0YXRpYyBfX3UzMgotSChfX3UzMiBYLCBfX3UzMiBZLCBfX3UzMiBaKQotewotCXJldHVybiBYIF4gWSBeIFo7Ci19Ci0KLXN0YXRpYyBfX3UzMgotbHNoaWZ0KF9fdTMyIHgsIGludCBzKQotewotCXggJj0gMHhGRkZGRkZGRjsKLQlyZXR1cm4gKCh4IDw8IHMpICYgMHhGRkZGRkZGRikgfCAoeCA+PiAoMzIgLSBzKSk7Ci19Ci0KLSNkZWZpbmUgUk9VTkQxKGEsYixjLGQsayxzKSAoKmEpID0gbHNoaWZ0KCgqYSkgKyBGKCpiLCpjLCpkKSArIFhba10sIHMpCi0jZGVmaW5lIFJPVU5EMihhLGIsYyxkLGsscykgKCphKSA9IGxzaGlmdCgoKmEpICsgRygqYiwqYywqZCkgKyBYW2tdICsgKF9fdTMyKTB4NUE4Mjc5OTkscykKLSNkZWZpbmUgUk9VTkQzKGEsYixjLGQsayxzKSAoKmEpID0gbHNoaWZ0KCgqYSkgKyBIKCpiLCpjLCpkKSArIFhba10gKyAoX191MzIpMHg2RUQ5RUJBMSxzKQotCi0vKiB0aGlzIGFwcGxpZXMgbWQ0IHRvIDY0IGJ5dGUgY2h1bmtzICovCi1zdGF0aWMgdm9pZAotbWRmb3VyNjQoX191MzIgKk0sIF9fdTMyICpBLCBfX3UzMiAqQiwgX191MzIgKkMsIF9fdTMyICpEKQotewotCWludCBqOwotCV9fdTMyIEFBLCBCQiwgQ0MsIEREOwotCV9fdTMyIFhbMTZdOwotCi0KLQlmb3IgKGogPSAwOyBqIDwgMTY7IGorKykKLQkJWFtqXSA9IE1bal07Ci0KLQlBQSA9ICpBOwotCUJCID0gKkI7Ci0JQ0MgPSAqQzsKLQlERCA9ICpEOwotCi0JUk9VTkQxKEEsIEIsIEMsIEQsIDAsIDMpOwotCVJPVU5EMShELCBBLCBCLCBDLCAxLCA3KTsKLQlST1VORDEoQywgRCwgQSwgQiwgMiwgMTEpOwotCVJPVU5EMShCLCBDLCBELCBBLCAzLCAxOSk7Ci0JUk9VTkQxKEEsIEIsIEMsIEQsIDQsIDMpOwotCVJPVU5EMShELCBBLCBCLCBDLCA1LCA3KTsKLQlST1VORDEoQywgRCwgQSwgQiwgNiwgMTEpOwotCVJPVU5EMShCLCBDLCBELCBBLCA3LCAxOSk7Ci0JUk9VTkQxKEEsIEIsIEMsIEQsIDgsIDMpOwotCVJPVU5EMShELCBBLCBCLCBDLCA5LCA3KTsKLQlST1VORDEoQywgRCwgQSwgQiwgMTAsIDExKTsKLQlST1VORDEoQiwgQywgRCwgQSwgMTEsIDE5KTsKLQlST1VORDEoQSwgQiwgQywgRCwgMTIsIDMpOwotCVJPVU5EMShELCBBLCBCLCBDLCAxMywgNyk7Ci0JUk9VTkQxKEMsIEQsIEEsIEIsIDE0LCAxMSk7Ci0JUk9VTkQxKEIsIEMsIEQsIEEsIDE1LCAxOSk7Ci0KLQlST1VORDIoQSwgQiwgQywgRCwgMCwgMyk7Ci0JUk9VTkQyKEQsIEEsIEIsIEMsIDQsIDUpOwotCVJPVU5EMihDLCBELCBBLCBCLCA4LCA5KTsKLQlST1VORDIoQiwgQywgRCwgQSwgMTIsIDEzKTsKLQlST1VORDIoQSwgQiwgQywgRCwgMSwgMyk7Ci0JUk9VTkQyKEQsIEEsIEIsIEMsIDUsIDUpOwotCVJPVU5EMihDLCBELCBBLCBCLCA5LCA5KTsKLQlST1VORDIoQiwgQywgRCwgQSwgMTMsIDEzKTsKLQlST1VORDIoQSwgQiwgQywgRCwgMiwgMyk7Ci0JUk9VTkQyKEQsIEEsIEIsIEMsIDYsIDUpOwotCVJPVU5EMihDLCBELCBBLCBCLCAxMCwgOSk7Ci0JUk9VTkQyKEIsIEMsIEQsIEEsIDE0LCAxMyk7Ci0JUk9VTkQyKEEsIEIsIEMsIEQsIDMsIDMpOwotCVJPVU5EMihELCBBLCBCLCBDLCA3LCA1KTsKLQlST1VORDIoQywgRCwgQSwgQiwgMTEsIDkpOwotCVJPVU5EMihCLCBDLCBELCBBLCAxNSwgMTMpOwotCi0JUk9VTkQzKEEsIEIsIEMsIEQsIDAsIDMpOwotCVJPVU5EMyhELCBBLCBCLCBDLCA4LCA5KTsKLQlST1VORDMoQywgRCwgQSwgQiwgNCwgMTEpOwotCVJPVU5EMyhCLCBDLCBELCBBLCAxMiwgMTUpOwotCVJPVU5EMyhBLCBCLCBDLCBELCAyLCAzKTsKLQlST1VORDMoRCwgQSwgQiwgQywgMTAsIDkpOwotCVJPVU5EMyhDLCBELCBBLCBCLCA2LCAxMSk7Ci0JUk9VTkQzKEIsIEMsIEQsIEEsIDE0LCAxNSk7Ci0JUk9VTkQzKEEsIEIsIEMsIEQsIDEsIDMpOwotCVJPVU5EMyhELCBBLCBCLCBDLCA5LCA5KTsKLQlST1VORDMoQywgRCwgQSwgQiwgNSwgMTEpOwotCVJPVU5EMyhCLCBDLCBELCBBLCAxMywgMTUpOwotCVJPVU5EMyhBLCBCLCBDLCBELCAzLCAzKTsKLQlST1VORDMoRCwgQSwgQiwgQywgMTEsIDkpOwotCVJPVU5EMyhDLCBELCBBLCBCLCA3LCAxMSk7Ci0JUk9VTkQzKEIsIEMsIEQsIEEsIDE1LCAxNSk7Ci0KLQkqQSArPSBBQTsKLQkqQiArPSBCQjsKLQkqQyArPSBDQzsKLQkqRCArPSBERDsKLQotCSpBICY9IDB4RkZGRkZGRkY7Ci0JKkIgJj0gMHhGRkZGRkZGRjsKLQkqQyAmPSAweEZGRkZGRkZGOwotCSpEICY9IDB4RkZGRkZGRkY7Ci0KLQlmb3IgKGogPSAwOyBqIDwgMTY7IGorKykKLQkJWFtqXSA9IDA7Ci19Ci0KLXN0YXRpYyB2b2lkCi1jb3B5NjQoX191MzIgKk0sIHVuc2lnbmVkIGNoYXIgKmluKQotewotCWludCBpOwotCi0JZm9yIChpID0gMDsgaSA8IDE2OyBpKyspCi0JCU1baV0gPSAoaW5baSAqIDQgKyAzXSA8PCAyNCkgfCAoaW5baSAqIDQgKyAyXSA8PCAxNikgfAotCQkgICAgKGluW2kgKiA0ICsgMV0gPDwgOCkgfCAoaW5baSAqIDQgKyAwXSA8PCAwKTsKLX0KLQotc3RhdGljIHZvaWQKLWNvcHk0KHVuc2lnbmVkIGNoYXIgKm91dCwgX191MzIgeCkKLXsKLQlvdXRbMF0gPSB4ICYgMHhGRjsKLQlvdXRbMV0gPSAoeCA+PiA4KSAmIDB4RkY7Ci0Jb3V0WzJdID0gKHggPj4gMTYpICYgMHhGRjsKLQlvdXRbM10gPSAoeCA+PiAyNCkgJiAweEZGOwotfQotCi0vKiBwcm9kdWNlIGEgbWQ0IG1lc3NhZ2UgZGlnZXN0IGZyb20gZGF0YSBvZiBsZW5ndGggbiBieXRlcyAqLwotdm9pZAotbWRmb3VyKHVuc2lnbmVkIGNoYXIgKm91dCwgdW5zaWduZWQgY2hhciAqaW4sIGludCBuKQotewotCXVuc2lnbmVkIGNoYXIgYnVmWzEyOF07Ci0JX191MzIgTVsxNl07Ci0JX191MzIgYiA9IG4gKiA4OwotCWludCBpOwotCV9fdTMyIEEgPSAweDY3NDUyMzAxOwotCV9fdTMyIEIgPSAweGVmY2RhYjg5OwotCV9fdTMyIEMgPSAweDk4YmFkY2ZlOwotCV9fdTMyIEQgPSAweDEwMzI1NDc2OwotCi0Jd2hpbGUgKG4gPiA2NCkgewotCQljb3B5NjQoTSwgaW4pOwotCQltZGZvdXI2NChNLCAmQSwgJkIsICZDLCAmRCk7Ci0JCWluICs9IDY0OwotCQluIC09IDY0OwotCX0KLQotCWZvciAoaSA9IDA7IGkgPCAxMjg7IGkrKykKLQkJYnVmW2ldID0gMDsKLQltZW1jcHkoYnVmLCBpbiwgbik7Ci0JYnVmW25dID0gMHg4MDsKLQotCWlmIChuIDw9IDU1KSB7Ci0JCWNvcHk0KGJ1ZiArIDU2LCBiKTsKLQkJY29weTY0KE0sIGJ1Zik7Ci0JCW1kZm91cjY0KE0sICZBLCAmQiwgJkMsICZEKTsKLQl9IGVsc2UgewotCQljb3B5NChidWYgKyAxMjAsIGIpOwotCQljb3B5NjQoTSwgYnVmKTsKLQkJbWRmb3VyNjQoTSwgJkEsICZCLCAmQywgJkQpOwotCQljb3B5NjQoTSwgYnVmICsgNjQpOwotCQltZGZvdXI2NChNLCAmQSwgJkIsICZDLCAmRCk7Ci0JfQotCi0JZm9yIChpID0gMDsgaSA8IDEyODsgaSsrKQotCQlidWZbaV0gPSAwOwotCWNvcHk2NChNLCBidWYpOwotCi0JY29weTQob3V0LCBBKTsKLQljb3B5NChvdXQgKyA0LCBCKTsKLQljb3B5NChvdXQgKyA4LCBDKTsKLQljb3B5NChvdXQgKyAxMiwgRCk7Ci0KLQlBID0gQiA9IEMgPSBEID0gMDsKLX0KZGlmZiAtLWdpdCBhL2ZzL2NpZnMvbWQ1LmMgYi9mcy9jaWZzL21kNS5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5OGI2NmE1Li4wMDAwMDAwCi0tLSBhL2ZzL2NpZnMvbWQ1LmMKKysrIC9kZXYvbnVsbApAQCAtMSwzNjYgKzAsMCBAQAotLyoKLSAqIFRoaXMgY29kZSBpbXBsZW1lbnRzIHRoZSBNRDUgbWVzc2FnZS1kaWdlc3QgYWxnb3JpdGhtLgotICogVGhlIGFsZ29yaXRobSBpcyBkdWUgdG8gUm9uIFJpdmVzdC4gIFRoaXMgY29kZSB3YXMKLSAqIHdyaXR0ZW4gYnkgQ29saW4gUGx1bWIgaW4gMTk5Mywgbm8gY29weXJpZ2h0IGlzIGNsYWltZWQuCi0gKiBUaGlzIGNvZGUgaXMgaW4gdGhlIHB1YmxpYyBkb21haW47IGRvIHdpdGggaXQgd2hhdCB5b3Ugd2lzaC4KLSAqCi0gKiBFcXVpdmFsZW50IGNvZGUgaXMgYXZhaWxhYmxlIGZyb20gUlNBIERhdGEgU2VjdXJpdHksIEluYy4KLSAqIFRoaXMgY29kZSBoYXMgYmVlbiB0ZXN0ZWQgYWdhaW5zdCB0aGF0LCBhbmQgaXMgZXF1aXZhbGVudCwKLSAqIGV4Y2VwdCB0aGF0IHlvdSBkb24ndCBuZWVkIHRvIGluY2x1ZGUgdHdvIHBhZ2VzIG9mIGxlZ2FsZXNlCi0gKiB3aXRoIGV2ZXJ5IGNvcHkuCi0gKgotICogVG8gY29tcHV0ZSB0aGUgbWVzc2FnZSBkaWdlc3Qgb2YgYSBjaHVuayBvZiBieXRlcywgZGVjbGFyZSBhbgotICogTUQ1Q29udGV4dCBzdHJ1Y3R1cmUsIHBhc3MgaXQgdG8gY2lmc19NRDVfaW5pdCwgY2FsbCBjaWZzX01ENV91cGRhdGUgYXMKLSAqIG5lZWRlZCBvbiBidWZmZXJzIGZ1bGwgb2YgYnl0ZXMsIGFuZCB0aGVuIGNhbGwgY2lmc19NRDVfZmluYWwsIHdoaWNoCi0gKiB3aWxsIGZpbGwgYSBzdXBwbGllZCAxNi1ieXRlIGFycmF5IHdpdGggdGhlIGRpZ2VzdC4KLSAqLwotCi0vKiBUaGlzIGNvZGUgc2xpZ2h0bHkgbW9kaWZpZWQgdG8gZml0IGludG8gU2FtYmEgYnkKLSAgIGFiYXJ0bGV0QHNhbWJhLm9yZyBKdW4gMjAwMQotICAgYW5kIHRvIGZpdCB0aGUgY2lmcyB2ZnMgYnkKLSAgIFN0ZXZlIEZyZW5jaCBzZnJlbmNoQHVzLmlibS5jb20gKi8KLQotI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgotI2luY2x1ZGUgIm1kNS5oIgotCi1zdGF0aWMgdm9pZCBNRDVUcmFuc2Zvcm0oX191MzIgYnVmWzRdLCBfX3UzMiBjb25zdCBpblsxNl0pOwotCi0vKgotICogTm90ZTogdGhpcyBjb2RlIGlzIGhhcm1sZXNzIG9uIGxpdHRsZS1lbmRpYW4gbWFjaGluZXMuCi0gKi8KLXN0YXRpYyB2b2lkCi1ieXRlUmV2ZXJzZSh1bnNpZ25lZCBjaGFyICpidWYsIHVuc2lnbmVkIGxvbmdzKQotewotCV9fdTMyIHQ7Ci0JZG8gewotCQl0ID0gKF9fdTMyKSAoKHVuc2lnbmVkKSBidWZbM10gPDwgOCB8IGJ1ZlsyXSkgPDwgMTYgfAotCQkgICAgKCh1bnNpZ25lZCkgYnVmWzFdIDw8IDggfCBidWZbMF0pOwotCQkqKF9fdTMyICopIGJ1ZiA9IHQ7Ci0JCWJ1ZiArPSA0OwotCX0gd2hpbGUgKC0tbG9uZ3MpOwotfQotCi0vKgotICogU3RhcnQgTUQ1IGFjY3VtdWxhdGlvbi4gIFNldCBiaXQgY291bnQgdG8gMCBhbmQgYnVmZmVyIHRvIG15c3RlcmlvdXMKLSAqIGluaXRpYWxpemF0aW9uIGNvbnN0YW50cy4KLSAqLwotdm9pZAotY2lmc19NRDVfaW5pdChzdHJ1Y3QgTUQ1Q29udGV4dCAqY3R4KQotewotCWN0eC0+YnVmWzBdID0gMHg2NzQ1MjMwMTsKLQljdHgtPmJ1ZlsxXSA9IDB4ZWZjZGFiODk7Ci0JY3R4LT5idWZbMl0gPSAweDk4YmFkY2ZlOwotCWN0eC0+YnVmWzNdID0gMHgxMDMyNTQ3NjsKLQotCWN0eC0+Yml0c1swXSA9IDA7Ci0JY3R4LT5iaXRzWzFdID0gMDsKLX0KLQotLyoKLSAqIFVwZGF0ZSBjb250ZXh0IHRvIHJlZmxlY3QgdGhlIGNvbmNhdGVuYXRpb24gb2YgYW5vdGhlciBidWZmZXIgZnVsbAotICogb2YgYnl0ZXMuCi0gKi8KLXZvaWQKLWNpZnNfTUQ1X3VwZGF0ZShzdHJ1Y3QgTUQ1Q29udGV4dCAqY3R4LCB1bnNpZ25lZCBjaGFyIGNvbnN0ICpidWYsIHVuc2lnbmVkIGxlbikKLXsKLQlyZWdpc3RlciBfX3UzMiB0OwotCi0JLyogVXBkYXRlIGJpdGNvdW50ICovCi0KLQl0ID0gY3R4LT5iaXRzWzBdOwotCWlmICgoY3R4LT5iaXRzWzBdID0gdCArICgoX191MzIpIGxlbiA8PCAzKSkgPCB0KQotCQljdHgtPmJpdHNbMV0rKzsJLyogQ2FycnkgZnJvbSBsb3cgdG8gaGlnaCAqLwotCWN0eC0+Yml0c1sxXSArPSBsZW4gPj4gMjk7Ci0KLQl0ID0gKHQgPj4gMykgJiAweDNmOwkvKiBCeXRlcyBhbHJlYWR5IGluIHNoc0luZm8tPmRhdGEgKi8KLQotCS8qIEhhbmRsZSBhbnkgbGVhZGluZyBvZGQtc2l6ZWQgY2h1bmtzICovCi0KLQlpZiAodCkgewotCQl1bnNpZ25lZCBjaGFyICpwID0gKHVuc2lnbmVkIGNoYXIgKikgY3R4LT5pbiArIHQ7Ci0KLQkJdCA9IDY0IC0gdDsKLQkJaWYgKGxlbiA8IHQpIHsKLQkJCW1lbW1vdmUocCwgYnVmLCBsZW4pOwotCQkJcmV0dXJuOwotCQl9Ci0JCW1lbW1vdmUocCwgYnVmLCB0KTsKLQkJYnl0ZVJldmVyc2UoY3R4LT5pbiwgMTYpOwotCQlNRDVUcmFuc2Zvcm0oY3R4LT5idWYsIChfX3UzMiAqKSBjdHgtPmluKTsKLQkJYnVmICs9IHQ7Ci0JCWxlbiAtPSB0OwotCX0KLQkvKiBQcm9jZXNzIGRhdGEgaW4gNjQtYnl0ZSBjaHVua3MgKi8KLQotCXdoaWxlIChsZW4gPj0gNjQpIHsKLQkJbWVtbW92ZShjdHgtPmluLCBidWYsIDY0KTsKLQkJYnl0ZVJldmVyc2UoY3R4LT5pbiwgMTYpOwotCQlNRDVUcmFuc2Zvcm0oY3R4LT5idWYsIChfX3UzMiAqKSBjdHgtPmluKTsKLQkJYnVmICs9IDY0OwotCQlsZW4gLT0gNjQ7Ci0JfQotCi0JLyogSGFuZGxlIGFueSByZW1haW5pbmcgYnl0ZXMgb2YgZGF0YS4gKi8KLQotCW1lbW1vdmUoY3R4LT5pbiwgYnVmLCBsZW4pOwotfQotCi0vKgotICogRmluYWwgd3JhcHVwIC0gcGFkIHRvIDY0LWJ5dGUgYm91bmRhcnkgd2l0aCB0aGUgYml0IHBhdHRlcm4KLSAqIDEgMCogKDY0LWJpdCBjb3VudCBvZiBiaXRzIHByb2Nlc3NlZCwgTVNCLWZpcnN0KQotICovCi12b2lkCi1jaWZzX01ENV9maW5hbCh1bnNpZ25lZCBjaGFyIGRpZ2VzdFsxNl0sIHN0cnVjdCBNRDVDb250ZXh0ICpjdHgpCi17Ci0JdW5zaWduZWQgaW50IGNvdW50OwotCXVuc2lnbmVkIGNoYXIgKnA7Ci0KLQkvKiBDb21wdXRlIG51bWJlciBvZiBieXRlcyBtb2QgNjQgKi8KLQljb3VudCA9IChjdHgtPmJpdHNbMF0gPj4gMykgJiAweDNGOwotCi0JLyogU2V0IHRoZSBmaXJzdCBjaGFyIG9mIHBhZGRpbmcgdG8gMHg4MC4gIFRoaXMgaXMgc2FmZSBzaW5jZSB0aGVyZSBpcwotCSAgIGFsd2F5cyBhdCBsZWFzdCBvbmUgYnl0ZSBmcmVlICovCi0JcCA9IGN0eC0+aW4gKyBjb3VudDsKLQkqcCsrID0gMHg4MDsKLQotCS8qIEJ5dGVzIG9mIHBhZGRpbmcgbmVlZGVkIHRvIG1ha2UgNjQgYnl0ZXMgKi8KLQljb3VudCA9IDY0IC0gMSAtIGNvdW50OwotCi0JLyogUGFkIG91dCB0byA1NiBtb2QgNjQgKi8KLQlpZiAoY291bnQgPCA4KSB7Ci0JCS8qIFR3byBsb3RzIG9mIHBhZGRpbmc6ICBQYWQgdGhlIGZpcnN0IGJsb2NrIHRvIDY0IGJ5dGVzICovCi0JCW1lbXNldChwLCAwLCBjb3VudCk7Ci0JCWJ5dGVSZXZlcnNlKGN0eC0+aW4sIDE2KTsKLQkJTUQ1VHJhbnNmb3JtKGN0eC0+YnVmLCAoX191MzIgKikgY3R4LT5pbik7Ci0KLQkJLyogTm93IGZpbGwgdGhlIG5leHQgYmxvY2sgd2l0aCA1NiBieXRlcyAqLwotCQltZW1zZXQoY3R4LT5pbiwgMCwgNTYpOwotCX0gZWxzZSB7Ci0JCS8qIFBhZCBibG9jayB0byA1NiBieXRlcyAqLwotCQltZW1zZXQocCwgMCwgY291bnQgLSA4KTsKLQl9Ci0JYnl0ZVJldmVyc2UoY3R4LT5pbiwgMTQpOwotCi0JLyogQXBwZW5kIGxlbmd0aCBpbiBiaXRzIGFuZCB0cmFuc2Zvcm0gKi8KLQkoKF9fdTMyICopIGN0eC0+aW4pWzE0XSA9IGN0eC0+Yml0c1swXTsKLQkoKF9fdTMyICopIGN0eC0+aW4pWzE1XSA9IGN0eC0+Yml0c1sxXTsKLQotCU1ENVRyYW5zZm9ybShjdHgtPmJ1ZiwgKF9fdTMyICopIGN0eC0+aW4pOwotCWJ5dGVSZXZlcnNlKCh1bnNpZ25lZCBjaGFyICopIGN0eC0+YnVmLCA0KTsKLQltZW1tb3ZlKGRpZ2VzdCwgY3R4LT5idWYsIDE2KTsKLQltZW1zZXQoY3R4LCAwLCBzaXplb2YoKmN0eCkpOwkvKiBJbiBjYXNlIGl0J3Mgc2Vuc2l0aXZlICovCi19Ci0KLS8qIFRoZSBmb3VyIGNvcmUgZnVuY3Rpb25zIC0gRjEgaXMgb3B0aW1pemVkIHNvbWV3aGF0ICovCi0KLS8qICNkZWZpbmUgRjEoeCwgeSwgeikgKHggJiB5IHwgfnggJiB6KSAqLwotI2RlZmluZSBGMSh4LCB5LCB6KSAoeiBeICh4ICYgKHkgXiB6KSkpCi0jZGVmaW5lIEYyKHgsIHksIHopIEYxKHosIHgsIHkpCi0jZGVmaW5lIEYzKHgsIHksIHopICh4IF4geSBeIHopCi0jZGVmaW5lIEY0KHgsIHksIHopICh5IF4gKHggfCB+eikpCi0KLS8qIFRoaXMgaXMgdGhlIGNlbnRyYWwgc3RlcCBpbiB0aGUgTUQ1IGFsZ29yaXRobS4gKi8KLSNkZWZpbmUgTUQ1U1RFUChmLCB3LCB4LCB5LCB6LCBkYXRhLCBzKSBcCi0JKHcgKz0gZih4LCB5LCB6KSArIGRhdGEsICB3ID0gdzw8cyB8IHc+PigzMi1zKSwgIHcgKz0geCkKLQotLyoKLSAqIFRoZSBjb3JlIG9mIHRoZSBNRDUgYWxnb3JpdGhtLCB0aGlzIGFsdGVycyBhbiBleGlzdGluZyBNRDUgaGFzaCB0bwotICogcmVmbGVjdCB0aGUgYWRkaXRpb24gb2YgMTYgbG9uZ3dvcmRzIG9mIG5ldyBkYXRhLiAgY2lmc19NRDVfdXBkYXRlIGJsb2NrcwotICogdGhlIGRhdGEgYW5kIGNvbnZlcnRzIGJ5dGVzIGludG8gbG9uZ3dvcmRzIGZvciB0aGlzIHJvdXRpbmUuCi0gKi8KLXN0YXRpYyB2b2lkCi1NRDVUcmFuc2Zvcm0oX191MzIgYnVmWzRdLCBfX3UzMiBjb25zdCBpblsxNl0pCi17Ci0JcmVnaXN0ZXIgX191MzIgYSwgYiwgYywgZDsKLQotCWEgPSBidWZbMF07Ci0JYiA9IGJ1ZlsxXTsKLQljID0gYnVmWzJdOwotCWQgPSBidWZbM107Ci0KLQlNRDVTVEVQKEYxLCBhLCBiLCBjLCBkLCBpblswXSArIDB4ZDc2YWE0NzgsIDcpOwotCU1ENVNURVAoRjEsIGQsIGEsIGIsIGMsIGluWzFdICsgMHhlOGM3Yjc1NiwgMTIpOwotCU1ENVNURVAoRjEsIGMsIGQsIGEsIGIsIGluWzJdICsgMHgyNDIwNzBkYiwgMTcpOwotCU1ENVNURVAoRjEsIGIsIGMsIGQsIGEsIGluWzNdICsgMHhjMWJkY2VlZSwgMjIpOwotCU1ENVNURVAoRjEsIGEsIGIsIGMsIGQsIGluWzRdICsgMHhmNTdjMGZhZiwgNyk7Ci0JTUQ1U1RFUChGMSwgZCwgYSwgYiwgYywgaW5bNV0gKyAweDQ3ODdjNjJhLCAxMik7Ci0JTUQ1U1RFUChGMSwgYywgZCwgYSwgYiwgaW5bNl0gKyAweGE4MzA0NjEzLCAxNyk7Ci0JTUQ1U1RFUChGMSwgYiwgYywgZCwgYSwgaW5bN10gKyAweGZkNDY5NTAxLCAyMik7Ci0JTUQ1U1RFUChGMSwgYSwgYiwgYywgZCwgaW5bOF0gKyAweDY5ODA5OGQ4LCA3KTsKLQlNRDVTVEVQKEYxLCBkLCBhLCBiLCBjLCBpbls5XSArIDB4OGI0NGY3YWYsIDEyKTsKLQlNRDVTVEVQKEYxLCBjLCBkLCBhLCBiLCBpblsxMF0gKyAweGZmZmY1YmIxLCAxNyk7Ci0JTUQ1U1RFUChGMSwgYiwgYywgZCwgYSwgaW5bMTFdICsgMHg4OTVjZDdiZSwgMjIpOwotCU1ENVNURVAoRjEsIGEsIGIsIGMsIGQsIGluWzEyXSArIDB4NmI5MDExMjIsIDcpOwotCU1ENVNURVAoRjEsIGQsIGEsIGIsIGMsIGluWzEzXSArIDB4ZmQ5ODcxOTMsIDEyKTsKLQlNRDVTVEVQKEYxLCBjLCBkLCBhLCBiLCBpblsxNF0gKyAweGE2Nzk0MzhlLCAxNyk7Ci0JTUQ1U1RFUChGMSwgYiwgYywgZCwgYSwgaW5bMTVdICsgMHg0OWI0MDgyMSwgMjIpOwotCi0JTUQ1U1RFUChGMiwgYSwgYiwgYywgZCwgaW5bMV0gKyAweGY2MWUyNTYyLCA1KTsKLQlNRDVTVEVQKEYyLCBkLCBhLCBiLCBjLCBpbls2XSArIDB4YzA0MGIzNDAsIDkpOwotCU1ENVNURVAoRjIsIGMsIGQsIGEsIGIsIGluWzExXSArIDB4MjY1ZTVhNTEsIDE0KTsKLQlNRDVTVEVQKEYyLCBiLCBjLCBkLCBhLCBpblswXSArIDB4ZTliNmM3YWEsIDIwKTsKLQlNRDVTVEVQKEYyLCBhLCBiLCBjLCBkLCBpbls1XSArIDB4ZDYyZjEwNWQsIDUpOwotCU1ENVNURVAoRjIsIGQsIGEsIGIsIGMsIGluWzEwXSArIDB4MDI0NDE0NTMsIDkpOwotCU1ENVNURVAoRjIsIGMsIGQsIGEsIGIsIGluWzE1XSArIDB4ZDhhMWU2ODEsIDE0KTsKLQlNRDVTVEVQKEYyLCBiLCBjLCBkLCBhLCBpbls0XSArIDB4ZTdkM2ZiYzgsIDIwKTsKLQlNRDVTVEVQKEYyLCBhLCBiLCBjLCBkLCBpbls5XSArIDB4MjFlMWNkZTYsIDUpOwotCU1ENVNURVAoRjIsIGQsIGEsIGIsIGMsIGluWzE0XSArIDB4YzMzNzA3ZDYsIDkpOwotCU1ENVNURVAoRjIsIGMsIGQsIGEsIGIsIGluWzNdICsgMHhmNGQ1MGQ4NywgMTQpOwotCU1ENVNURVAoRjIsIGIsIGMsIGQsIGEsIGluWzhdICsgMHg0NTVhMTRlZCwgMjApOwotCU1ENVNURVAoRjIsIGEsIGIsIGMsIGQsIGluWzEzXSArIDB4YTllM2U5MDUsIDUpOwotCU1ENVNURVAoRjIsIGQsIGEsIGIsIGMsIGluWzJdICsgMHhmY2VmYTNmOCwgOSk7Ci0JTUQ1U1RFUChGMiwgYywgZCwgYSwgYiwgaW5bN10gKyAweDY3NmYwMmQ5LCAxNCk7Ci0JTUQ1U1RFUChGMiwgYiwgYywgZCwgYSwgaW5bMTJdICsgMHg4ZDJhNGM4YSwgMjApOwotCi0JTUQ1U1RFUChGMywgYSwgYiwgYywgZCwgaW5bNV0gKyAweGZmZmEzOTQyLCA0KTsKLQlNRDVTVEVQKEYzLCBkLCBhLCBiLCBjLCBpbls4XSArIDB4ODc3MWY2ODEsIDExKTsKLQlNRDVTVEVQKEYzLCBjLCBkLCBhLCBiLCBpblsxMV0gKyAweDZkOWQ2MTIyLCAxNik7Ci0JTUQ1U1RFUChGMywgYiwgYywgZCwgYSwgaW5bMTRdICsgMHhmZGU1MzgwYywgMjMpOwotCU1ENVNURVAoRjMsIGEsIGIsIGMsIGQsIGluWzFdICsgMHhhNGJlZWE0NCwgNCk7Ci0JTUQ1U1RFUChGMywgZCwgYSwgYiwgYywgaW5bNF0gKyAweDRiZGVjZmE5LCAxMSk7Ci0JTUQ1U1RFUChGMywgYywgZCwgYSwgYiwgaW5bN10gKyAweGY2YmI0YjYwLCAxNik7Ci0JTUQ1U1RFUChGMywgYiwgYywgZCwgYSwgaW5bMTBdICsgMHhiZWJmYmM3MCwgMjMpOwotCU1ENVNURVAoRjMsIGEsIGIsIGMsIGQsIGluWzEzXSArIDB4Mjg5YjdlYzYsIDQpOwotCU1ENVNURVAoRjMsIGQsIGEsIGIsIGMsIGluWzBdICsgMHhlYWExMjdmYSwgMTEpOwotCU1ENVNURVAoRjMsIGMsIGQsIGEsIGIsIGluWzNdICsgMHhkNGVmMzA4NSwgMTYpOwotCU1ENVNURVAoRjMsIGIsIGMsIGQsIGEsIGluWzZdICsgMHgwNDg4MWQwNSwgMjMpOwotCU1ENVNURVAoRjMsIGEsIGIsIGMsIGQsIGluWzldICsgMHhkOWQ0ZDAzOSwgNCk7Ci0JTUQ1U1RFUChGMywgZCwgYSwgYiwgYywgaW5bMTJdICsgMHhlNmRiOTllNSwgMTEpOwotCU1ENVNURVAoRjMsIGMsIGQsIGEsIGIsIGluWzE1XSArIDB4MWZhMjdjZjgsIDE2KTsKLQlNRDVTVEVQKEYzLCBiLCBjLCBkLCBhLCBpblsyXSArIDB4YzRhYzU2NjUsIDIzKTsKLQotCU1ENVNURVAoRjQsIGEsIGIsIGMsIGQsIGluWzBdICsgMHhmNDI5MjI0NCwgNik7Ci0JTUQ1U1RFUChGNCwgZCwgYSwgYiwgYywgaW5bN10gKyAweDQzMmFmZjk3LCAxMCk7Ci0JTUQ1U1RFUChGNCwgYywgZCwgYSwgYiwgaW5bMTRdICsgMHhhYjk0MjNhNywgMTUpOwotCU1ENVNURVAoRjQsIGIsIGMsIGQsIGEsIGluWzVdICsgMHhmYzkzYTAzOSwgMjEpOwotCU1ENVNURVAoRjQsIGEsIGIsIGMsIGQsIGluWzEyXSArIDB4NjU1YjU5YzMsIDYpOwotCU1ENVNURVAoRjQsIGQsIGEsIGIsIGMsIGluWzNdICsgMHg4ZjBjY2M5MiwgMTApOwotCU1ENVNURVAoRjQsIGMsIGQsIGEsIGIsIGluWzEwXSArIDB4ZmZlZmY0N2QsIDE1KTsKLQlNRDVTVEVQKEY0LCBiLCBjLCBkLCBhLCBpblsxXSArIDB4ODU4NDVkZDEsIDIxKTsKLQlNRDVTVEVQKEY0LCBhLCBiLCBjLCBkLCBpbls4XSArIDB4NmZhODdlNGYsIDYpOwotCU1ENVNURVAoRjQsIGQsIGEsIGIsIGMsIGluWzE1XSArIDB4ZmUyY2U2ZTAsIDEwKTsKLQlNRDVTVEVQKEY0LCBjLCBkLCBhLCBiLCBpbls2XSArIDB4YTMwMTQzMTQsIDE1KTsKLQlNRDVTVEVQKEY0LCBiLCBjLCBkLCBhLCBpblsxM10gKyAweDRlMDgxMWExLCAyMSk7Ci0JTUQ1U1RFUChGNCwgYSwgYiwgYywgZCwgaW5bNF0gKyAweGY3NTM3ZTgyLCA2KTsKLQlNRDVTVEVQKEY0LCBkLCBhLCBiLCBjLCBpblsxMV0gKyAweGJkM2FmMjM1LCAxMCk7Ci0JTUQ1U1RFUChGNCwgYywgZCwgYSwgYiwgaW5bMl0gKyAweDJhZDdkMmJiLCAxNSk7Ci0JTUQ1U1RFUChGNCwgYiwgYywgZCwgYSwgaW5bOV0gKyAweGViODZkMzkxLCAyMSk7Ci0KLQlidWZbMF0gKz0gYTsKLQlidWZbMV0gKz0gYjsKLQlidWZbMl0gKz0gYzsKLQlidWZbM10gKz0gZDsKLX0KLQotI2lmIDAgICAvKiBjdXJyZW50bHkgdW51c2VkICovCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSB0aGUgcmZjIDIxMDQgdmVyc2lvbiBvZiBobWFjX21kNSBpbml0aWFsaXNhdGlvbi4KLSoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotc3RhdGljIHZvaWQKLWhtYWNfbWQ1X2luaXRfcmZjMjEwNCh1bnNpZ25lZCBjaGFyICprZXksIGludCBrZXlfbGVuLAotCQkgICAgICBzdHJ1Y3QgSE1BQ01ENUNvbnRleHQgKmN0eCkKLXsKLQlpbnQgaTsKLQotCS8qIGlmIGtleSBpcyBsb25nZXIgdGhhbiA2NCBieXRlcyByZXNldCBpdCB0byBrZXk9TUQ1KGtleSkgKi8KLQlpZiAoa2V5X2xlbiA+IDY0KSB7Ci0JCXVuc2lnbmVkIGNoYXIgdGtbMTZdOwotCQlzdHJ1Y3QgTUQ1Q29udGV4dCB0Y3R4OwotCi0JCWNpZnNfTUQ1X2luaXQoJnRjdHgpOwotCQljaWZzX01ENV91cGRhdGUoJnRjdHgsIGtleSwga2V5X2xlbik7Ci0JCWNpZnNfTUQ1X2ZpbmFsKHRrLCAmdGN0eCk7Ci0KLQkJa2V5ID0gdGs7Ci0JCWtleV9sZW4gPSAxNjsKLQl9Ci0KLQkvKiBzdGFydCBvdXQgYnkgc3RvcmluZyBrZXkgaW4gcGFkcyAqLwotCW1lbXNldChjdHgtPmtfaXBhZCwgMCwgc2l6ZW9mKGN0eC0+a19pcGFkKSk7Ci0JbWVtc2V0KGN0eC0+a19vcGFkLCAwLCBzaXplb2YoY3R4LT5rX29wYWQpKTsKLQltZW1jcHkoY3R4LT5rX2lwYWQsIGtleSwga2V5X2xlbik7Ci0JbWVtY3B5KGN0eC0+a19vcGFkLCBrZXksIGtleV9sZW4pOwotCi0JLyogWE9SIGtleSB3aXRoIGlwYWQgYW5kIG9wYWQgdmFsdWVzICovCi0JZm9yIChpID0gMDsgaSA8IDY0OyBpKyspIHsKLQkJY3R4LT5rX2lwYWRbaV0gXj0gMHgzNjsKLQkJY3R4LT5rX29wYWRbaV0gXj0gMHg1YzsKLQl9Ci0KLQljaWZzX01ENV9pbml0KCZjdHgtPmN0eCk7Ci0JY2lmc19NRDVfdXBkYXRlKCZjdHgtPmN0eCwgY3R4LT5rX2lwYWQsIDY0KTsKLX0KLSNlbmRpZgotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSB0aGUgbWljcm9zb2Z0IHZlcnNpb24gb2YgaG1hY19tZDUgaW5pdGlhbGlzYXRpb24uCi0qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXZvaWQKLWhtYWNfbWQ1X2luaXRfbGltS190b182NChjb25zdCB1bnNpZ25lZCBjaGFyICprZXksIGludCBrZXlfbGVuLAotCQkJIHN0cnVjdCBITUFDTUQ1Q29udGV4dCAqY3R4KQotewotCWludCBpOwotCi0JLyogaWYga2V5IGlzIGxvbmdlciB0aGFuIDY0IGJ5dGVzIHRydW5jYXRlIGl0ICovCi0JaWYgKGtleV9sZW4gPiA2NCkKLQkJa2V5X2xlbiA9IDY0OwotCi0JLyogc3RhcnQgb3V0IGJ5IHN0b3Jpbmcga2V5IGluIHBhZHMgKi8KLQltZW1zZXQoY3R4LT5rX2lwYWQsIDAsIHNpemVvZihjdHgtPmtfaXBhZCkpOwotCW1lbXNldChjdHgtPmtfb3BhZCwgMCwgc2l6ZW9mKGN0eC0+a19vcGFkKSk7Ci0JbWVtY3B5KGN0eC0+a19pcGFkLCBrZXksIGtleV9sZW4pOwotCW1lbWNweShjdHgtPmtfb3BhZCwga2V5LCBrZXlfbGVuKTsKLQotCS8qIFhPUiBrZXkgd2l0aCBpcGFkIGFuZCBvcGFkIHZhbHVlcyAqLwotCWZvciAoaSA9IDA7IGkgPCA2NDsgaSsrKSB7Ci0JCWN0eC0+a19pcGFkW2ldIF49IDB4MzY7Ci0JCWN0eC0+a19vcGFkW2ldIF49IDB4NWM7Ci0JfQotCi0JY2lmc19NRDVfaW5pdCgmY3R4LT5jdHgpOwotCWNpZnNfTUQ1X3VwZGF0ZSgmY3R4LT5jdHgsIGN0eC0+a19pcGFkLCA2NCk7Ci19Ci0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotIHVwZGF0ZSBobWFjX21kNSAiaW5uZXIiIGJ1ZmZlcgotKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi12b2lkCi1obWFjX21kNV91cGRhdGUoY29uc3QgdW5zaWduZWQgY2hhciAqdGV4dCwgaW50IHRleHRfbGVuLAotCQlzdHJ1Y3QgSE1BQ01ENUNvbnRleHQgKmN0eCkKLXsKLQljaWZzX01ENV91cGRhdGUoJmN0eC0+Y3R4LCB0ZXh0LCB0ZXh0X2xlbik7CS8qIHRoZW4gdGV4dCBvZiBkYXRhZ3JhbSAqLwotfQotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSBmaW5pc2ggb2ZmIGhtYWNfbWQ1ICJpbm5lciIgYnVmZmVyIGFuZCBnZW5lcmF0ZSBvdXRlciBvbmUuCi0qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLXZvaWQKLWhtYWNfbWQ1X2ZpbmFsKHVuc2lnbmVkIGNoYXIgKmRpZ2VzdCwgc3RydWN0IEhNQUNNRDVDb250ZXh0ICpjdHgpCi17Ci0Jc3RydWN0IE1ENUNvbnRleHQgY3R4X287Ci0KLQljaWZzX01ENV9maW5hbChkaWdlc3QsICZjdHgtPmN0eCk7Ci0KLQljaWZzX01ENV9pbml0KCZjdHhfbyk7Ci0JY2lmc19NRDVfdXBkYXRlKCZjdHhfbywgY3R4LT5rX29wYWQsIDY0KTsKLQljaWZzX01ENV91cGRhdGUoJmN0eF9vLCBkaWdlc3QsIDE2KTsKLQljaWZzX01ENV9maW5hbChkaWdlc3QsICZjdHhfbyk7Ci19Ci0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgotIHNpbmdsZSBmdW5jdGlvbiB0byBjYWxjdWxhdGUgYW4gSE1BQyBNRDUgZGlnZXN0IGZyb20gZGF0YS4KLSB1c2UgdGhlIG1pY3Jvc29mdCBobWFjbWQ1IGluaXQgbWV0aG9kIGJlY2F1c2UgdGhlIGtleSBpcyAxNiBieXRlcy4KLSoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLSNpZiAwIC8qIGN1cnJlbnRseSB1bnVzZWQgKi8KLXN0YXRpYyB2b2lkCi1obWFjX21kNSh1bnNpZ25lZCBjaGFyIGtleVsxNl0sIHVuc2lnbmVkIGNoYXIgKmRhdGEsIGludCBkYXRhX2xlbiwKLQkgdW5zaWduZWQgY2hhciAqZGlnZXN0KQotewotCXN0cnVjdCBITUFDTUQ1Q29udGV4dCBjdHg7Ci0JaG1hY19tZDVfaW5pdF9saW1LX3RvXzY0KGtleSwgMTYsICZjdHgpOwotCWlmIChkYXRhX2xlbiAhPSAwKQotCQlobWFjX21kNV91cGRhdGUoZGF0YSwgZGF0YV9sZW4sICZjdHgpOwotCi0JaG1hY19tZDVfZmluYWwoZGlnZXN0LCAmY3R4KTsKLX0KLSNlbmRpZgpkaWZmIC0tZ2l0IGEvZnMvY2lmcy9tZDUuaCBiL2ZzL2NpZnMvbWQ1LmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDZmYmE4Y2IuLjAwMDAwMDAKLS0tIGEvZnMvY2lmcy9tZDUuaAorKysgL2Rldi9udWxsCkBAIC0xLDM4ICswLDAgQEAKLSNpZm5kZWYgTUQ1X0gKLSNkZWZpbmUgTUQ1X0gKLSNpZm5kZWYgSEVBREVSX01ENV9ICi0vKiBUcnkgdG8gYXZvaWQgY2xhc2hlcyB3aXRoIE9wZW5TU0wgKi8KLSNkZWZpbmUgSEVBREVSX01ENV9ICi0jZW5kaWYKLQotc3RydWN0IE1ENUNvbnRleHQgewotCV9fdTMyIGJ1Zls0XTsKLQlfX3UzMiBiaXRzWzJdOwotCXVuc2lnbmVkIGNoYXIgaW5bNjRdOwotfTsKLSNlbmRpZgkJCQkvKiAhTUQ1X0ggKi8KLQotI2lmbmRlZiBfSE1BQ19NRDVfSAotc3RydWN0IEhNQUNNRDVDb250ZXh0IHsKLQlzdHJ1Y3QgTUQ1Q29udGV4dCBjdHg7Ci0JdW5zaWduZWQgY2hhciBrX2lwYWRbNjVdOwotCXVuc2lnbmVkIGNoYXIga19vcGFkWzY1XTsKLX07Ci0jZW5kaWYJCQkJLyogX0hNQUNfTUQ1X0ggKi8KLQotdm9pZCBjaWZzX01ENV9pbml0KHN0cnVjdCBNRDVDb250ZXh0ICpjb250ZXh0KTsKLXZvaWQgY2lmc19NRDVfdXBkYXRlKHN0cnVjdCBNRDVDb250ZXh0ICpjb250ZXh0LCB1bnNpZ25lZCBjaGFyIGNvbnN0ICpidWYsCi0JCQl1bnNpZ25lZCBsZW4pOwotdm9pZCBjaWZzX01ENV9maW5hbCh1bnNpZ25lZCBjaGFyIGRpZ2VzdFsxNl0sIHN0cnVjdCBNRDVDb250ZXh0ICpjb250ZXh0KTsKLQotLyogVGhlIGZvbGxvd2luZyBkZWZpbml0aW9ucyBjb21lIGZyb20gbGliL2htYWNtZDUuYyAgKi8KLQotLyogdm9pZCBobWFjX21kNV9pbml0X3JmYzIxMDQodW5zaWduZWQgY2hhciAqa2V5LCBpbnQga2V5X2xlbiwKLQkJCXN0cnVjdCBITUFDTUQ1Q29udGV4dCAqY3R4KTsqLwotdm9pZCBobWFjX21kNV9pbml0X2xpbUtfdG9fNjQoY29uc3QgdW5zaWduZWQgY2hhciAqa2V5LCBpbnQga2V5X2xlbiwKLQkJCXN0cnVjdCBITUFDTUQ1Q29udGV4dCAqY3R4KTsKLXZvaWQgaG1hY19tZDVfdXBkYXRlKGNvbnN0IHVuc2lnbmVkIGNoYXIgKnRleHQsIGludCB0ZXh0X2xlbiwKLQkJCXN0cnVjdCBITUFDTUQ1Q29udGV4dCAqY3R4KTsKLXZvaWQgaG1hY19tZDVfZmluYWwodW5zaWduZWQgY2hhciAqZGlnZXN0LCBzdHJ1Y3QgSE1BQ01ENUNvbnRleHQgKmN0eCk7Ci0vKiB2b2lkIGhtYWNfbWQ1KHVuc2lnbmVkIGNoYXIga2V5WzE2XSwgdW5zaWduZWQgY2hhciAqZGF0YSwgaW50IGRhdGFfbGVuLAotCQkJdW5zaWduZWQgY2hhciAqZGlnZXN0KTsqLwpkaWZmIC0tZ2l0IGEvZnMvY2lmcy9taXNjLmMgYi9mcy9jaWZzL21pc2MuYwppbmRleCA0M2YxMDI4Li4yYTkzMGE3IDEwMDY0NAotLS0gYS9mcy9jaWZzL21pc2MuYworKysgYi9mcy9jaWZzL21pc2MuYwpAQCAtMjM2LDEwICsyMzYsNyBAQAogewogCV9fdTE2IG1pZCA9IDA7CiAJX191MTYgbGFzdF9taWQ7Ci0JaW50ICAgY29sbGlzaW9uOwotCi0JaWYgKHNlcnZlciA9PSBOVUxMKQotCQlyZXR1cm4gbWlkOworCWJvb2wgY29sbGlzaW9uOwogCiAJc3Bpbl9sb2NrKCZHbG9iYWxNaWRfTG9jayk7CiAJbGFzdF9taWQgPSBzZXJ2ZXItPkN1cnJlbnRNaWQ7IC8qIHdlIGRvIG5vdCB3YW50IHRvIGxvb3AgZm9yZXZlciAqLwpAQCAtMjUyLDI0ICsyNDksMzggQEAKIAkoYW5kIGl0IHdvdWxkIGFsc28gaGF2ZSB0byBoYXZlIGJlZW4gYSByZXF1ZXN0IHRoYXQKIAkgZGlkIG5vdCB0aW1lIG91dCkgKi8KIAl3aGlsZSAoc2VydmVyLT5DdXJyZW50TWlkICE9IGxhc3RfbWlkKSB7Ci0JCXN0cnVjdCBsaXN0X2hlYWQgKnRtcDsKIAkJc3RydWN0IG1pZF9xX2VudHJ5ICptaWRfZW50cnk7CisJCXVuc2lnbmVkIGludCBudW1fbWlkczsKIAotCQljb2xsaXNpb24gPSAwOworCQljb2xsaXNpb24gPSBmYWxzZTsKIAkJaWYgKHNlcnZlci0+Q3VycmVudE1pZCA9PSAwKQogCQkJc2VydmVyLT5DdXJyZW50TWlkKys7CiAKLQkJbGlzdF9mb3JfZWFjaCh0bXAsICZzZXJ2ZXItPnBlbmRpbmdfbWlkX3EpIHsKLQkJCW1pZF9lbnRyeSA9IGxpc3RfZW50cnkodG1wLCBzdHJ1Y3QgbWlkX3FfZW50cnksIHFoZWFkKTsKLQotCQkJaWYgKChtaWRfZW50cnktPm1pZCA9PSBzZXJ2ZXItPkN1cnJlbnRNaWQpICYmCi0JCQkgICAgKG1pZF9lbnRyeS0+bWlkU3RhdGUgPT0gTUlEX1JFUVVFU1RfU1VCTUlUVEVEKSkgeworCQludW1fbWlkcyA9IDA7CisJCWxpc3RfZm9yX2VhY2hfZW50cnkobWlkX2VudHJ5LCAmc2VydmVyLT5wZW5kaW5nX21pZF9xLCBxaGVhZCkgeworCQkJKytudW1fbWlkczsKKwkJCWlmIChtaWRfZW50cnktPm1pZCA9PSBzZXJ2ZXItPkN1cnJlbnRNaWQgJiYKKwkJCSAgICBtaWRfZW50cnktPm1pZFN0YXRlID09IE1JRF9SRVFVRVNUX1NVQk1JVFRFRCkgewogCQkJCS8qIFRoaXMgbWlkIGlzIGluIHVzZSwgdHJ5IGEgZGlmZmVyZW50IG9uZSAqLwotCQkJCWNvbGxpc2lvbiA9IDE7CisJCQkJY29sbGlzaW9uID0gdHJ1ZTsKIAkJCQlicmVhazsKIAkJCX0KIAkJfQotCQlpZiAoY29sbGlzaW9uID09IDApIHsKKworCQkvKgorCQkgKiBpZiB3ZSBoYXZlIG1vcmUgdGhhbiAzMmsgbWlkcyBpbiB0aGUgbGlzdCwgdGhlbiBzb21ldGhpbmcKKwkJICogaXMgdmVyeSB3cm9uZy4gUG9zc2libHkgYSBsb2NhbCB1c2VyIGlzIHRyeWluZyB0byBEb1MgdGhlCisJCSAqIGJveCBieSBpc3N1aW5nIGxvbmctcnVubmluZyBjYWxscyBhbmQgU0lHS0lMTCdpbmcgdGhlbS4gSWYKKwkJICogd2UgZ2V0IHRvIDJeMTYgbWlkcyB0aGVuIHdlJ3JlIGluIGJpZyB0cm91YmxlIGFzIHRoaXMKKwkJICogZnVuY3Rpb24gY291bGQgbG9vcCBmb3JldmVyLgorCQkgKgorCQkgKiBHbyBhaGVhZCBhbmQgYXNzaWduIG91dCB0aGUgbWlkIGluIHRoaXMgc2l0dWF0aW9uLCBidXQgZm9yY2UKKwkJICogYW4gZXZlbnR1YWwgcmVjb25uZWN0IHRvIGNsZWFuIG91dCB0aGUgcGVuZGluZ19taWRfcS4KKwkJICovCisJCWlmIChudW1fbWlkcyA+IDMyNzY4KQorCQkJc2VydmVyLT50Y3BTdGF0dXMgPSBDaWZzTmVlZFJlY29ubmVjdDsKKworCQlpZiAoIWNvbGxpc2lvbikgewogCQkJbWlkID0gc2VydmVyLT5DdXJyZW50TWlkOwogCQkJYnJlYWs7CiAJCX0KQEAgLTM4MSwyOSArMzkyLDMxIEBACiB9CiAKIHN0YXRpYyBpbnQKLWNoZWNrU01CaGRyKHN0cnVjdCBzbWJfaGRyICpzbWIsIF9fdTE2IG1pZCkKK2NoZWNrX3NtYl9oZHIoc3RydWN0IHNtYl9oZHIgKnNtYiwgX191MTYgbWlkKQogewotCS8qIE1ha2Ugc3VyZSB0aGF0IHRoaXMgcmVhbGx5IGlzIGFuIFNNQiwgdGhhdCBpdCBpcyBhIHJlc3BvbnNlLAotCSAgIGFuZCB0aGF0IHRoZSBtZXNzYWdlIGlkcyBtYXRjaCAqLwotCWlmICgoKihfX2xlMzIgKikgc21iLT5Qcm90b2NvbCA9PSBjcHVfdG9fbGUzMigweDQyNGQ1M2ZmKSkgJiYKLQkJKG1pZCA9PSBzbWItPk1pZCkpIHsKLQkJaWYgKHNtYi0+RmxhZ3MgJiBTTUJGTEdfUkVTUE9OU0UpCi0JCQlyZXR1cm4gMDsKLQkJZWxzZSB7Ci0JCS8qIG9ubHkgb25lIHZhbGlkIGNhc2Ugd2hlcmUgc2VydmVyIHNlbmRzIHVzIHJlcXVlc3QgKi8KLQkJCWlmIChzbWItPkNvbW1hbmQgPT0gU01CX0NPTV9MT0NLSU5HX0FORFgpCi0JCQkJcmV0dXJuIDA7Ci0JCQllbHNlCi0JCQkJY0VSUk9SKDEsICJSZWNlaXZlZCBSZXF1ZXN0IG5vdCByZXNwb25zZSIpOwotCQl9Ci0JfSBlbHNlIHsgLyogYmFkIHNpZ25hdHVyZSBvciBtaWQgKi8KLQkJaWYgKCooX19sZTMyICopIHNtYi0+UHJvdG9jb2wgIT0gY3B1X3RvX2xlMzIoMHg0MjRkNTNmZikpCi0JCQljRVJST1IoMSwgIkJhZCBwcm90b2NvbCBzdHJpbmcgc2lnbmF0dXJlIGhlYWRlciAleCIsCi0JCQkJKih1bnNpZ25lZCBpbnQgKikgc21iLT5Qcm90b2NvbCk7Ci0JCWlmIChtaWQgIT0gc21iLT5NaWQpCi0JCQljRVJST1IoMSwgIk1pZHMgZG8gbm90IG1hdGNoIik7CisJLyogZG9lcyBpdCBoYXZlIHRoZSByaWdodCBTTUIgInNpZ25hdHVyZSIgPyAqLworCWlmICgqKF9fbGUzMiAqKSBzbWItPlByb3RvY29sICE9IGNwdV90b19sZTMyKDB4NDI0ZDUzZmYpKSB7CisJCWNFUlJPUigxLCAiQmFkIHByb3RvY29sIHN0cmluZyBzaWduYXR1cmUgaGVhZGVyIDB4JXgiLAorCQkJKih1bnNpZ25lZCBpbnQgKilzbWItPlByb3RvY29sKTsKKwkJcmV0dXJuIDE7CiAJfQotCWNFUlJPUigxLCAiYmFkIHNtYiBkZXRlY3RlZC4gVGhlIE1pZD0lZCIsIHNtYi0+TWlkKTsKKworCS8qIE1ha2Ugc3VyZSB0aGF0IG1lc3NhZ2UgaWRzIG1hdGNoICovCisJaWYgKG1pZCAhPSBzbWItPk1pZCkgeworCQljRVJST1IoMSwgIk1pZHMgZG8gbm90IG1hdGNoLiByZWNlaXZlZD0ldSBleHBlY3RlZD0ldSIsCisJCQlzbWItPk1pZCwgbWlkKTsKKwkJcmV0dXJuIDE7CisJfQorCisJLyogaWYgaXQncyBhIHJlc3BvbnNlIHRoZW4gYWNjZXB0ICovCisJaWYgKHNtYi0+RmxhZ3MgJiBTTUJGTEdfUkVTUE9OU0UpCisJCXJldHVybiAwOworCisJLyogb25seSBvbmUgdmFsaWQgY2FzZSB3aGVyZSBzZXJ2ZXIgc2VuZHMgdXMgcmVxdWVzdCAqLworCWlmIChzbWItPkNvbW1hbmQgPT0gU01CX0NPTV9MT0NLSU5HX0FORFgpCisJCXJldHVybiAwOworCisJY0VSUk9SKDEsICJTZXJ2ZXIgc2VudCByZXF1ZXN0LCBub3QgcmVzcG9uc2UuIG1pZD0ldSIsIHNtYi0+TWlkKTsKIAlyZXR1cm4gMTsKIH0KIApAQCAtNDQ4LDcgKzQ2MSw3IEBACiAJCXJldHVybiAxOwogCX0KIAotCWlmIChjaGVja1NNQmhkcihzbWIsIG1pZCkpCisJaWYgKGNoZWNrX3NtYl9oZHIoc21iLCBtaWQpKQogCQlyZXR1cm4gMTsKIAljbGNfbGVuID0gc21iQ2FsY1NpemVfTEUoc21iKTsKIApAQCAtNDY1LDI1ICs0NzgsMjYgQEAKIAkJCWlmICgoKDQgKyBsZW4pICYgMHhGRkZGKSA9PSAoY2xjX2xlbiAmIDB4RkZGRikpCiAJCQkJcmV0dXJuIDA7IC8qIGJjYyB3cmFwcGVkICovCiAJCX0KLQkJY0ZZSSgxLCAiQ2FsY3VsYXRlZCBzaXplICVkIHZzIGxlbmd0aCAlZCBtaXNtYXRjaCBmb3IgbWlkICVkIiwKKwkJY0ZZSSgxLCAiQ2FsY3VsYXRlZCBzaXplICV1IHZzIGxlbmd0aCAldSBtaXNtYXRjaCBmb3IgbWlkPSV1IiwKIAkJCQljbGNfbGVuLCA0ICsgbGVuLCBzbWItPk1pZCk7Ci0JCS8qIFdpbmRvd3MgWFAgY2FuIHJldHVybiBhIGZldyBieXRlcyB0b28gbXVjaCwgcHJlc3VtYWJseQotCQlhbiBpbGxlZ2FsIHBhZCwgYXQgdGhlIGVuZCBvZiBieXRlIHJhbmdlIGxvY2sgcmVzcG9uc2VzCi0JCXNvIHdlIGFsbG93IGZvciB0aGF0IHRocmVlIGJ5dGUgcGFkLCBhcyBsb25nIGFzIGFjdHVhbAotCQlyZWNlaXZlZCBsZW5ndGggaXMgYXMgbG9uZyBvciBsb25nZXIgdGhhbiBjYWxjdWxhdGVkIGxlbmd0aCAqLwotCQkvKiBXZSBoYXZlIG5vdyBoYWQgdG8gZXh0ZW5kIHRoaXMgbW9yZSwgc2luY2UgdGhlcmUgaXMgYQotCQljYXNlIGluIHdoaWNoIGl0IG5lZWRzIHRvIGJlIGJpZ2dlciBzdGlsbCB0byBoYW5kbGUgYQotCQltYWxmb3JtZWQgcmVzcG9uc2UgdG8gdHJhbnNhY3QyIGZpbmRmaXJzdCBmcm9tIFdpblhQIHdoZW4KLQkJYWNjZXNzIGRlbmllZCBpcyByZXR1cm5lZCBhbmQgdGh1cyBiY2MgYW5kIHdjdCBhcmUgemVybwotCQlidXQgc2VydmVyIHNheXMgbGVuZ3RoIGlzIDB4MjEgYnl0ZXMgdG9vIGxvbmcgYXMgaWYgdGhlIHNlcnZlcgotCQlmb3JnZXQgdG8gcmVzZXQgdGhlIHNtYiByZmMxMDAxIGxlbmd0aCB3aGVuIGl0IHJlc2V0IHRoZQotCQl3Y3QgYW5kIGJjYyB0byBtaW5pbXVtIHNpemUgYW5kIGRyb3AgdGhlIHQyIHBhcm1zIGFuZCBkYXRhICovCi0JCWlmICgoNCtsZW4gPiBjbGNfbGVuKSAmJiAobGVuIDw9IGNsY19sZW4gKyA1MTIpKQotCQkJcmV0dXJuIDA7Ci0JCWVsc2UgewotCQkJY0VSUk9SKDEsICJSRkMxMDAxIHNpemUgJWQgYmlnZ2VyIHRoYW4gU01CIGZvciBNaWQ9JWQiLAorCisJCWlmICg0ICsgbGVuIDwgY2xjX2xlbikgeworCQkJY0VSUk9SKDEsICJSRkMxMDAxIHNpemUgJXUgc21hbGxlciB0aGFuIFNNQiBmb3IgbWlkPSV1IiwKIAkJCQkJbGVuLCBzbWItPk1pZCk7CiAJCQlyZXR1cm4gMTsKKwkJfSBlbHNlIGlmIChsZW4gPiBjbGNfbGVuICsgNTEyKSB7CisJCQkvKgorCQkJICogU29tZSBzZXJ2ZXJzIChXaW5kb3dzIFhQIGluIHBhcnRpY3VsYXIpIHNlbmQgbW9yZQorCQkJICogZGF0YSB0aGFuIHRoZSBsZW5ndGhzIGluIHRoZSBTTUIgcGFja2V0IHdvdWxkCisJCQkgKiBpbmRpY2F0ZSBvbiBjZXJ0YWluIGNhbGxzIChieXRlIHJhbmdlIGxvY2tzIGFuZAorCQkJICogdHJhbnMyIGZpbmQgZmlyc3QgY2FsbHMgaW4gcGFydGljdWxhcikuIFdoaWxlIHRoZQorCQkJICogY2xpZW50IGNhbiBoYW5kbGUgc3VjaCBhIGZyYW1lIGJ5IGlnbm9yaW5nIHRoZQorCQkJICogdHJhaWxpbmcgZGF0YSwgd2UgY2hvb3NlIGxpbWl0IHRoZSBhbW91bnQgb2YgZXh0cmEKKwkJCSAqIGRhdGEgdG8gNTEyIGJ5dGVzLgorCQkJICovCisJCQljRVJST1IoMSwgIlJGQzEwMDEgc2l6ZSAldSBtb3JlIHRoYW4gNTEyIGJ5dGVzIGxhcmdlciAiCisJCQkJICAidGhhbiBTTUIgZm9yIG1pZD0ldSIsIGxlbiwgc21iLT5NaWQpOworCQkJcmV0dXJuIDE7CiAJCX0KIAl9CiAJcmV0dXJuIDA7CkBAIC01NzEsNyArNTg1LDcgQEAKIAkJCQlwQ2lmc0lub2RlID0gQ0lGU19JKG5ldGZpbGUtPmRlbnRyeS0+ZF9pbm9kZSk7CiAKIAkJCQljaWZzX3NldF9vcGxvY2tfbGV2ZWwocENpZnNJbm9kZSwKLQkJCQkJCSAgICAgIHBTTUItPk9wbG9ja0xldmVsKTsKKwkJCQkJcFNNQi0+T3Bsb2NrTGV2ZWwgPyBPUExPQ0tfUkVBRCA6IDApOwogCQkJCS8qCiAJCQkJICogY2lmc19vcGxvY2tfYnJlYWtfcHV0KCkgY2FuJ3QgYmUgY2FsbGVkCiAJCQkJICogZnJvbSBoZXJlLiAgR2V0IHJlZmVyZW5jZSBhZnRlciBxdWV1ZWluZwpAQCAtNjM3LDc3ICs2NTEsNiBAQAogCXJldHVybjsKIH0KIAotLyogQ29udmVydCAxNiBiaXQgVW5pY29kZSBwYXRobmFtZSB0byB3aXJlIGZvcm1hdCBmcm9tIHN0cmluZyBpbiBjdXJyZW50IGNvZGUKLSAgIHBhZ2UuICBDb252ZXJzaW9uIG1heSBpbnZvbHZlIHJlbWFwcGluZyB1cCB0aGUgc2V2ZW4gY2hhcmFjdGVycyB0aGF0IGFyZQotICAgb25seSBsZWdhbCBpbiBQT1NJWC1saWtlIE9TIChpZiB0aGV5IGFyZSBwcmVzZW50IGluIHRoZSBzdHJpbmcpLiBQYXRoCi0gICBuYW1lcyBhcmUgbGl0dGxlIGVuZGlhbiAxNiBiaXQgVW5pY29kZSBvbiB0aGUgd2lyZSAqLwotaW50Ci1jaWZzQ29udmVydFRvVUNTKF9fbGUxNiAqdGFyZ2V0LCBjb25zdCBjaGFyICpzb3VyY2UsIGludCBtYXhsZW4sCi0JCSBjb25zdCBzdHJ1Y3QgbmxzX3RhYmxlICpjcCwgaW50IG1hcENoYXJzKQotewotCWludCBpLCBqLCBjaGFybGVuOwotCWludCBsZW5fcmVtYWluaW5nID0gbWF4bGVuOwotCWNoYXIgc3JjX2NoYXI7Ci0JX191MTYgdGVtcDsKLQotCWlmICghbWFwQ2hhcnMpCi0JCXJldHVybiBjaWZzX3N0cnRvVUNTKHRhcmdldCwgc291cmNlLCBQQVRIX01BWCwgY3ApOwotCi0JZm9yIChpID0gMCwgaiA9IDA7IGkgPCBtYXhsZW47IGorKykgewotCQlzcmNfY2hhciA9IHNvdXJjZVtpXTsKLQkJc3dpdGNoIChzcmNfY2hhcikgewotCQkJY2FzZSAwOgotCQkJCXRhcmdldFtqXSA9IDA7Ci0JCQkJZ290byBjdG9VQ1Nfb3V0OwotCQkJY2FzZSAnOic6Ci0JCQkJdGFyZ2V0W2pdID0gY3B1X3RvX2xlMTYoVU5JX0NPTE9OKTsKLQkJCQlicmVhazsKLQkJCWNhc2UgJyonOgotCQkJCXRhcmdldFtqXSA9IGNwdV90b19sZTE2KFVOSV9BU1RFUklLKTsKLQkJCQlicmVhazsKLQkJCWNhc2UgJz8nOgotCQkJCXRhcmdldFtqXSA9IGNwdV90b19sZTE2KFVOSV9RVUVTVElPTik7Ci0JCQkJYnJlYWs7Ci0JCQljYXNlICc8JzoKLQkJCQl0YXJnZXRbal0gPSBjcHVfdG9fbGUxNihVTklfTEVTU1RIQU4pOwotCQkJCWJyZWFrOwotCQkJY2FzZSAnPic6Ci0JCQkJdGFyZ2V0W2pdID0gY3B1X3RvX2xlMTYoVU5JX0dSVFJUSEFOKTsKLQkJCQlicmVhazsKLQkJCWNhc2UgJ3wnOgotCQkJCXRhcmdldFtqXSA9IGNwdV90b19sZTE2KFVOSV9QSVBFKTsKLQkJCQlicmVhazsKLQkJCS8qIEJCIFdlIGNhbiBub3QgaGFuZGxlIHJlbWFwcGluZyBzbGFzaCB1bnRpbAotCQkJICAgYWxsIHRoZSBjYWxscyB0byBidWlsZF9wYXRoX2Zyb21fZGVudHJ5Ci0JCQkgICBhcmUgbW9kaWZpZWQsIGFzIHRoZXkgdXNlIHNsYXNoIGFzIHNlcGFyYXRvciBCQiAqLwotCQkJLyogY2FzZSAnXFwnOgotCQkJCXRhcmdldFtqXSA9IGNwdV90b19sZTE2KFVOSV9TTEFTSCk7Ci0JCQkJYnJlYWs7Ki8KLQkJCWRlZmF1bHQ6Ci0JCQkJY2hhcmxlbiA9IGNwLT5jaGFyMnVuaShzb3VyY2UraSwKLQkJCQkJbGVuX3JlbWFpbmluZywgJnRlbXApOwotCQkJCS8qIGlmIG5vIG1hdGNoLCB1c2UgcXVlc3Rpb24gbWFyaywgd2hpY2gKLQkJCQlhdCBsZWFzdCBpbiBzb21lIGNhc2VzIHNlcnZlcnMgYXMgd2lsZCBjYXJkICovCi0JCQkJaWYgKGNoYXJsZW4gPCAxKSB7Ci0JCQkJCXRhcmdldFtqXSA9IGNwdV90b19sZTE2KDB4MDAzZik7Ci0JCQkJCWNoYXJsZW4gPSAxOwotCQkJCX0gZWxzZQotCQkJCQl0YXJnZXRbal0gPSBjcHVfdG9fbGUxNih0ZW1wKTsKLQkJCQlsZW5fcmVtYWluaW5nIC09IGNoYXJsZW47Ci0JCQkJLyogY2hhcmFjdGVyIG1heSB0YWtlIG1vcmUgdGhhbiBvbmUgYnl0ZSBpbiB0aGUKLQkJCQkgICB0aGUgc291cmNlIHN0cmluZywgYnV0IHdpbGwgdGFrZSBleGFjdGx5IHR3bwotCQkJCSAgIGJ5dGVzIGluIHRoZSB0YXJnZXQgc3RyaW5nICovCi0JCQkJaSArPSBjaGFybGVuOwotCQkJCWNvbnRpbnVlOwotCQl9Ci0JCWkrKzsgLyogbW92ZSB0byBuZXh0IGNoYXIgaW4gc291cmNlIHN0cmluZyAqLwotCQlsZW5fcmVtYWluaW5nLS07Ci0JfQotCi1jdG9VQ1Nfb3V0OgotCXJldHVybiBpOwotfQotCiB2b2lkCiBjaWZzX2F1dG9kaXNhYmxlX3NlcnZlcmlubyhzdHJ1Y3QgY2lmc19zYl9pbmZvICpjaWZzX3NiKQogewpkaWZmIC0tZ2l0IGEvZnMvY2lmcy9uZXRtaXNjLmMgYi9mcy9jaWZzL25ldG1pc2MuYwppbmRleCA5YWFkNDdhLi44ZDkxODlmIDEwMDY0NAotLS0gYS9mcy9jaWZzL25ldG1pc2MuYworKysgYi9mcy9jaWZzL25ldG1pc2MuYwpAQCAtODk5LDggKzg5OSw4IEBACiAJfQogCS8qIGVsc2UgRVJSSFJEIGNsYXNzIGVycm9ycyBvciBqdW5rICAtIHJldHVybiBFSU8gKi8KIAotCWNGWUkoMSwgIk1hcHBpbmcgc21iIGVycm9yIGNvZGUgJWQgdG8gUE9TSVggZXJyICVkIiwKLQkJIHNtYmVycmNvZGUsIHJjKTsKKwljRllJKDEsICJNYXBwaW5nIHNtYiBlcnJvciBjb2RlIDB4JXggdG8gUE9TSVggZXJyICVkIiwKKwkJIGxlMzJfdG9fY3B1KHNtYi0+U3RhdHVzLkNpZnNFcnJvciksIHJjKTsKIAogCS8qIGdlbmVyaWMgY29ycmVjdGl2ZSBhY3Rpb24gZS5nLiByZWNvbm5lY3QgU01CIHNlc3Npb24gb24KIAkgKiBFUlJiYWR1aWQgY291bGQgYmUgYWRkZWQgKi8KQEAgLTkxNiwxNCArOTE2LDE0IEBACiBzbWJDYWxjU2l6ZShzdHJ1Y3Qgc21iX2hkciAqcHRyKQogewogCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBzbWJfaGRyKSArICgyICogcHRyLT5Xb3JkQ291bnQpICsKLQkJMiAvKiBzaXplIG9mIHRoZSBiY2MgZmllbGQgKi8gKyBCQ0MocHRyKSk7CisJCTIgLyogc2l6ZSBvZiB0aGUgYmNjIGZpZWxkICovICsgZ2V0X2JjYyhwdHIpKTsKIH0KIAogdW5zaWduZWQgaW50CiBzbWJDYWxjU2l6ZV9MRShzdHJ1Y3Qgc21iX2hkciAqcHRyKQogewogCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBzbWJfaGRyKSArICgyICogcHRyLT5Xb3JkQ291bnQpICsKLQkJMiAvKiBzaXplIG9mIHRoZSBiY2MgZmllbGQgKi8gKyBsZTE2X3RvX2NwdShCQ0NfTEUocHRyKSkpOworCQkyIC8qIHNpemUgb2YgdGhlIGJjYyBmaWVsZCAqLyArIGdldF9iY2NfbGUocHRyKSk7CiB9CiAKIC8qIFRoZSBmb2xsb3dpbmcgYXJlIHRha2VuIGZyb20gZnMvbnRmcy91dGlsLmMgKi8KZGlmZiAtLWdpdCBhL2ZzL2NpZnMvcmVhZGRpci5jIGIvZnMvY2lmcy9yZWFkZGlyLmMKaW5kZXggN2YyNWNjMy4uZjhlNGNkMiAxMDA2NDQKLS0tIGEvZnMvY2lmcy9yZWFkZGlyLmMKKysrIGIvZnMvY2lmcy9yZWFkZGlyLmMKQEAgLTc2NCw3ICs3NjQsNiBAQAogewogCWludCByYyA9IDA7CiAJaW50IHhpZCwgaTsKLQlzdHJ1Y3QgY2lmc19zYl9pbmZvICpjaWZzX3NiOwogCXN0cnVjdCBjaWZzVGNvbkluZm8gKnBUY29uOwogCXN0cnVjdCBjaWZzRmlsZUluZm8gKmNpZnNGaWxlID0gTlVMTDsKIAljaGFyICpjdXJyZW50X2VudHJ5OwpAQCAtNzc1LDggKzc3NCw2IEBACiAKIAl4aWQgPSBHZXRYaWQoKTsKIAotCWNpZnNfc2IgPSBDSUZTX1NCKGZpbGUtPmZfcGF0aC5kZW50cnktPmRfc2IpOwotCiAJLyoKIAkgKiBFbnN1cmUgRmluZEZpcnN0IGRvZXNuJ3QgZmFpbCBiZWZvcmUgZG9pbmcgZmlsbGRpcigpIGZvciAnLicgYW5kCiAJICogJy4uJy4gT3RoZXJ3aXNlIHdlIHdvbid0IGJlIGFibGUgdG8gbm90aWZ5IFZGUyBpbiBjYXNlIG9mIGZhaWx1cmUuCmRpZmYgLS1naXQgYS9mcy9jaWZzL3Nlc3MuYyBiL2ZzL2NpZnMvc2Vzcy5jCmluZGV4IGViNzQ2NDguLjFhZGM5NjIgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvc2Vzcy5jCisrKyBiL2ZzL2NpZnMvc2Vzcy5jCkBAIC0yNzcsNyArMjc3LDcgQEAKIH0KIAogc3RhdGljIHZvaWQKLWRlY29kZV91bmljb2RlX3NzZXR1cChjaGFyICoqcGJjY19hcmVhLCBpbnQgYmxlZnQsIHN0cnVjdCBjaWZzU2VzSW5mbyAqc2VzLAorZGVjb2RlX3VuaWNvZGVfc3NldHVwKGNoYXIgKipwYmNjX2FyZWEsIF9fdTE2IGJsZWZ0LCBzdHJ1Y3QgY2lmc1Nlc0luZm8gKnNlcywKIAkJICAgICAgY29uc3Qgc3RydWN0IG5sc190YWJsZSAqbmxzX2NwKQogewogCWludCBsZW47CkBAIC0zMjMsNyArMzIzLDcgQEAKIAlyZXR1cm47CiB9CiAKLXN0YXRpYyBpbnQgZGVjb2RlX2FzY2lpX3NzZXR1cChjaGFyICoqcGJjY19hcmVhLCBpbnQgYmxlZnQsCitzdGF0aWMgaW50IGRlY29kZV9hc2NpaV9zc2V0dXAoY2hhciAqKnBiY2NfYXJlYSwgX191MTYgYmxlZnQsCiAJCQkgICAgICAgc3RydWN0IGNpZnNTZXNJbmZvICpzZXMsCiAJCQkgICAgICAgY29uc3Qgc3RydWN0IG5sc190YWJsZSAqbmxzX2NwKQogewpAQCAtNTc1LDEyICs1NzUsMTEgQEAKIAljaGFyICpzdHJfYXJlYTsKIAlTRVNTSU9OX1NFVFVQX0FORFggKnBTTUI7CiAJX191MzIgY2FwYWJpbGl0aWVzOwotCWludCBjb3VudDsKKwlfX3UxNiBjb3VudDsKIAlpbnQgcmVzcF9idWZfdHlwZTsKIAlzdHJ1Y3Qga3ZlYyBpb3ZbM107CiAJZW51bSBzZWN1cml0eUVudW0gdHlwZTsKLQlfX3UxNiBhY3Rpb247Ci0JaW50IGJ5dGVzX3JlbWFpbmluZzsKKwlfX3UxNiBhY3Rpb24sIGJ5dGVzX3JlbWFpbmluZzsKIAlzdHJ1Y3Qga2V5ICpzcG5lZ29fa2V5ID0gTlVMTDsKIAlfX2xlMzIgcGhhc2UgPSBOdExtTmVnb3RpYXRlOyAvKiBOVExNU1NQLCBpZiBuZWVkZWQsIGlzIG11bHRpc3RhZ2UgKi8KIAl1MTYgYmxvYl9sZW47CkBAIC04NzYsMTAgKzg3NSwxMCBAQAogCWNvdW50ID0gaW92WzFdLmlvdl9sZW4gKyBpb3ZbMl0uaW92X2xlbjsKIAlzbWJfYnVmLT5zbWJfYnVmX2xlbmd0aCArPSBjb3VudDsKIAotCUJDQ19MRShzbWJfYnVmKSA9IGNwdV90b19sZTE2KGNvdW50KTsKKwlwdXRfYmNjX2xlKGNvdW50LCBzbWJfYnVmKTsKIAogCXJjID0gU2VuZFJlY2VpdmUyKHhpZCwgc2VzLCBpb3YsIDMgLyogbnVtX2lvdmVjcyAqLywgJnJlc3BfYnVmX3R5cGUsCi0JCQkgIENJRlNfU1REX09QIC8qIG5vdCBsb25nICovIHwgQ0lGU19MT0dfRVJST1IpOworCQkJICBDSUZTX0xPR19FUlJPUik7CiAJLyogU01CIHJlcXVlc3QgYnVmIGZyZWVkIGluIFNlbmRSZWNlaXZlMiAqLwogCiAJcFNNQiA9IChTRVNTSU9OX1NFVFVQX0FORFggKilpb3ZbMF0uaW92X2Jhc2U7CkBAIC05MTAsNyArOTA5LDcgQEAKIAljRllJKDEsICJVSUQgPSAlZCAiLCBzZXMtPlN1aWQpOwogCS8qIHJlc3BvbnNlIGNhbiBoYXZlIGVpdGhlciAzIG9yIDQgd29yZCBjb3VudCAtIFNhbWJhIHNlbmRzIDMgKi8KIAkvKiBhbmQgbGFubWFuIHJlc3BvbnNlIGlzIDMgKi8KLQlieXRlc19yZW1haW5pbmcgPSBCQ0Moc21iX2J1Zik7CisJYnl0ZXNfcmVtYWluaW5nID0gZ2V0X2JjYyhzbWJfYnVmKTsKIAliY2NfcHRyID0gcEJ5dGVBcmVhKHNtYl9idWYpOwogCiAJaWYgKHNtYl9idWYtPldvcmRDb3VudCA9PSA0KSB7CmRpZmYgLS1naXQgYS9mcy9jaWZzL3NtYmRlcy5jIGIvZnMvY2lmcy9zbWJkZXMuYwppbmRleCBiNmI2ZGNiLi4wNDcyMTQ4IDEwMDY0NAotLS0gYS9mcy9jaWZzL3NtYmRlcy5jCisrKyBiL2ZzL2NpZnMvc21iZGVzLmMKQEAgLTQ1LDcgKzQ1LDYgQEAKICAgIHVwIHdpdGggYSBkaWZmZXJlbnQgYW5zd2VyIHRvIHRoZSBvbmUgYWJvdmUpCiAqLwogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KLSNpbmNsdWRlICJjaWZzZW5jcnlwdC5oIgogI2RlZmluZSB1Y2hhciB1bnNpZ25lZCBjaGFyCiAKIHN0YXRpYyB1Y2hhciBwZXJtMVs1Nl0gPSB7IDU3LCA0OSwgNDEsIDMzLCAyNSwgMTcsIDksCmRpZmYgLS1naXQgYS9mcy9jaWZzL3NtYmVuY3J5cHQuYyBiL2ZzL2NpZnMvc21iZW5jcnlwdC5jCmluZGV4IDE5MmVhNTEuLmI1MDQxYzggMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvc21iZW5jcnlwdC5jCisrKyBiL2ZzL2NpZnMvc21iZW5jcnlwdC5jCkBAIC0zMiw5ICszMiw4IEBACiAjaW5jbHVkZSAiY2lmc191bmljb2RlLmgiCiAjaW5jbHVkZSAiY2lmc3BkdS5oIgogI2luY2x1ZGUgImNpZnNnbG9iLmgiCi0jaW5jbHVkZSAibWQ1LmgiCiAjaW5jbHVkZSAiY2lmc19kZWJ1Zy5oIgotI2luY2x1ZGUgImNpZnNlbmNyeXB0LmgiCisjaW5jbHVkZSAiY2lmc3Byb3RvLmgiCiAKICNpZm5kZWYgZmFsc2UKICNkZWZpbmUgZmFsc2UgMApAQCAtNDgsMTQgKzQ3LDU4IEBACiAjZGVmaW5lIFNTVkFMWChidWYscG9zLHZhbCkgKENWQUwoYnVmLHBvcyk9KHZhbCkmMHhGRixDVkFMKGJ1Zixwb3MrMSk9KHZhbCk+PjgpCiAjZGVmaW5lIFNTVkFMKGJ1Zixwb3MsdmFsKSBTU1ZBTFgoKGJ1ZiksKHBvcyksKChfX3UxNikodmFsKSkpCiAKLS8qVGhlIGZvbGxvd2luZyBkZWZpbml0aW9ucyBjb21lIGZyb20gIGxpYnNtYi9zbWJlbmNyeXB0LmMgICovCisvKiBwcm9kdWNlIGEgbWQ0IG1lc3NhZ2UgZGlnZXN0IGZyb20gZGF0YSBvZiBsZW5ndGggbiBieXRlcyAqLworaW50CittZGZvdXIodW5zaWduZWQgY2hhciAqbWQ0X2hhc2gsIHVuc2lnbmVkIGNoYXIgKmxpbmtfc3RyLCBpbnQgbGlua19sZW4pCit7CisJaW50IHJjOworCXVuc2lnbmVkIGludCBzaXplOworCXN0cnVjdCBjcnlwdG9fc2hhc2ggKm1kNDsKKwlzdHJ1Y3Qgc2Rlc2MgKnNkZXNjbWQ0OwogCi12b2lkIFNNQmVuY3J5cHQodW5zaWduZWQgY2hhciAqcGFzc3dkLCBjb25zdCB1bnNpZ25lZCBjaGFyICpjOCwKLQkJdW5zaWduZWQgY2hhciAqcDI0KTsKLXZvaWQgRV9tZDRoYXNoKGNvbnN0IHVuc2lnbmVkIGNoYXIgKnBhc3N3ZCwgdW5zaWduZWQgY2hhciAqcDE2KTsKLXN0YXRpYyB2b2lkIFNNQk9XRmVuY3J5cHQodW5zaWduZWQgY2hhciBwYXNzd2RbMTZdLCBjb25zdCB1bnNpZ25lZCBjaGFyICpjOCwKLQkJICAgdW5zaWduZWQgY2hhciBwMjRbMjRdKTsKLXZvaWQgU01CTlRlbmNyeXB0KHVuc2lnbmVkIGNoYXIgKnBhc3N3ZCwgdW5zaWduZWQgY2hhciAqYzgsIHVuc2lnbmVkIGNoYXIgKnAyNCk7CisJbWQ0ID0gY3J5cHRvX2FsbG9jX3NoYXNoKCJtZDQiLCAwLCAwKTsKKwlpZiAoSVNfRVJSKG1kNCkpIHsKKwkJcmMgPSBQVFJfRVJSKG1kNCk7CisJCWNFUlJPUigxLCAiJXM6IENyeXB0byBtZDQgYWxsb2NhdGlvbiBlcnJvciAlZFxuIiwgX19mdW5jX18sIHJjKTsKKwkJcmV0dXJuIHJjOworCX0KKwlzaXplID0gc2l6ZW9mKHN0cnVjdCBzaGFzaF9kZXNjKSArIGNyeXB0b19zaGFzaF9kZXNjc2l6ZShtZDQpOworCXNkZXNjbWQ0ID0ga21hbGxvYyhzaXplLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXNkZXNjbWQ0KSB7CisJCXJjID0gLUVOT01FTTsKKwkJY0VSUk9SKDEsICIlczogTWVtb3J5IGFsbG9jYXRpb24gZmFpbHVyZVxuIiwgX19mdW5jX18pOworCQlnb3RvIG1kZm91cl9lcnI7CisJfQorCXNkZXNjbWQ0LT5zaGFzaC50Zm0gPSBtZDQ7CisJc2Rlc2NtZDQtPnNoYXNoLmZsYWdzID0gMHgwOworCisJcmMgPSBjcnlwdG9fc2hhc2hfaW5pdCgmc2Rlc2NtZDQtPnNoYXNoKTsKKwlpZiAocmMpIHsKKwkJY0VSUk9SKDEsICIlczogQ291bGQgbm90IGluaXQgbWQ0IHNoYXNoXG4iLCBfX2Z1bmNfXyk7CisJCWdvdG8gbWRmb3VyX2VycjsKKwl9CisJY3J5cHRvX3NoYXNoX3VwZGF0ZSgmc2Rlc2NtZDQtPnNoYXNoLCBsaW5rX3N0ciwgbGlua19sZW4pOworCXJjID0gY3J5cHRvX3NoYXNoX2ZpbmFsKCZzZGVzY21kNC0+c2hhc2gsIG1kNF9oYXNoKTsKKworbWRmb3VyX2VycjoKKwljcnlwdG9fZnJlZV9zaGFzaChtZDQpOworCWtmcmVlKHNkZXNjbWQ0KTsKKworCXJldHVybiByYzsKK30KKworLyogRG9lcyB0aGUgZGVzIGVuY3J5cHRpb24gZnJvbSB0aGUgTlQgb3IgTE0gTUQ0IGhhc2guICovCitzdGF0aWMgdm9pZAorU01CT1dGZW5jcnlwdCh1bnNpZ25lZCBjaGFyIHBhc3N3ZFsxNl0sIGNvbnN0IHVuc2lnbmVkIGNoYXIgKmM4LAorCSAgICAgIHVuc2lnbmVkIGNoYXIgcDI0WzI0XSkKK3sKKwl1bnNpZ25lZCBjaGFyIHAyMVsyMV07CisKKwltZW1zZXQocDIxLCAnXDAnLCAyMSk7CisKKwltZW1jcHkocDIxLCBwYXNzd2QsIDE2KTsKKwlFX1AyNChwMjEsIGM4LCBwMjQpOworfQogCiAvKgogICAgVGhpcyBpbXBsZW1lbnRzIHRoZSBYL09wZW4gU01CIHBhc3N3b3JkIGVuY3J5cHRpb24KQEAgLTExOCw5ICsxNjEsMTAgQEAKICAqIENyZWF0ZXMgdGhlIE1ENCBIYXNoIG9mIHRoZSB1c2VycyBwYXNzd29yZCBpbiBOVCBVTklDT0RFLgogICovCiAKLXZvaWQKK2ludAogRV9tZDRoYXNoKGNvbnN0IHVuc2lnbmVkIGNoYXIgKnBhc3N3ZCwgdW5zaWduZWQgY2hhciAqcDE2KQogeworCWludCByYzsKIAlpbnQgbGVuOwogCV9fdTE2IHdwd2RbMTI5XTsKIApAQCAtMTM5LDggKzE4MywxMCBAQAogCS8qIENhbGN1bGF0ZSBsZW5ndGggaW4gYnl0ZXMgKi8KIAlsZW4gPSBfbXlfd2NzbGVuKHdwd2QpICogc2l6ZW9mKF9fdTE2KTsKIAotCW1kZm91cihwMTYsICh1bnNpZ25lZCBjaGFyICopIHdwd2QsIGxlbik7CisJcmMgPSBtZGZvdXIocDE2LCAodW5zaWduZWQgY2hhciAqKSB3cHdkLCBsZW4pOwogCW1lbXNldCh3cHdkLCAwLCAxMjkgKiAyKTsKKworCXJldHVybiByYzsKIH0KIAogI2lmIDAgLyogY3VycmVudGx5IHVudXNlZCAqLwpAQCAtMjEyLDE5ICsyNTgsNiBAQAogfQogI2VuZGlmCiAKLS8qIERvZXMgdGhlIGRlcyBlbmNyeXB0aW9uIGZyb20gdGhlIE5UIG9yIExNIE1ENCBoYXNoLiAqLwotc3RhdGljIHZvaWQKLVNNQk9XRmVuY3J5cHQodW5zaWduZWQgY2hhciBwYXNzd2RbMTZdLCBjb25zdCB1bnNpZ25lZCBjaGFyICpjOCwKLQkgICAgICB1bnNpZ25lZCBjaGFyIHAyNFsyNF0pCi17Ci0JdW5zaWduZWQgY2hhciBwMjFbMjFdOwotCi0JbWVtc2V0KHAyMSwgJ1wwJywgMjEpOwotCi0JbWVtY3B5KHAyMSwgcGFzc3dkLCAxNik7Ci0JRV9QMjQocDIxLCBjOCwgcDI0KTsKLX0KLQogLyogRG9lcyB0aGUgZGVzIGVuY3J5cHRpb24gZnJvbSB0aGUgRklSU1QgOCBCWVRFUyBvZiB0aGUgTlQgb3IgTE0gTUQ0IGhhc2guICovCiAjaWYgMCAvKiBjdXJyZW50bHkgdW51c2VkICovCiBzdGF0aWMgdm9pZApAQCAtMjQyLDE2ICsyNzUsMjEgQEAKICNlbmRpZgogCiAvKiBEb2VzIHRoZSBOVCBNRDQgaGFzaCB0aGVuIGRlcyBlbmNyeXB0aW9uLiAqLwotCi12b2lkCitpbnQKIFNNQk5UZW5jcnlwdCh1bnNpZ25lZCBjaGFyICpwYXNzd2QsIHVuc2lnbmVkIGNoYXIgKmM4LCB1bnNpZ25lZCBjaGFyICpwMjQpCiB7CisJaW50IHJjOwogCXVuc2lnbmVkIGNoYXIgcDIxWzIxXTsKIAogCW1lbXNldChwMjEsICdcMCcsIDIxKTsKIAotCUVfbWQ0aGFzaChwYXNzd2QsIHAyMSk7CisJcmMgPSBFX21kNGhhc2gocGFzc3dkLCBwMjEpOworCWlmIChyYykgeworCQljRllJKDEsICIlcyBDYW4ndCBnZW5lcmF0ZSBOVCBoYXNoLCBlcnJvcjogJWQiLCBfX2Z1bmNfXywgcmMpOworCQlyZXR1cm4gcmM7CisJfQogCVNNQk9XRmVuY3J5cHQocDIxLCBjOCwgcDI0KTsKKwlyZXR1cm4gcmM7CiB9CiAKIApkaWZmIC0tZ2l0IGEvZnMvY2lmcy90cmFuc3BvcnQuYyBiL2ZzL2NpZnMvdHJhbnNwb3J0LmMKaW5kZXggNTljYTgxYi4uNDZkODc1NmYgMTAwNjQ0Ci0tLSBhL2ZzL2NpZnMvdHJhbnNwb3J0LmMKKysrIGIvZnMvY2lmcy90cmFuc3BvcnQuYwpAQCAtMzYsNyArMzYsMTMgQEAKIAogZXh0ZXJuIG1lbXBvb2xfdCAqY2lmc19taWRfcG9vbHA7CiAKLXN0YXRpYyBzdHJ1Y3QgbWlkX3FfZW50cnkgKgorc3RhdGljIHZvaWQKK3dha2VfdXBfdGFzayhzdHJ1Y3QgbWlkX3FfZW50cnkgKm1pZCkKK3sKKwl3YWtlX3VwX3Byb2Nlc3MobWlkLT5jYWxsYmFja19kYXRhKTsKK30KKworc3RydWN0IG1pZF9xX2VudHJ5ICoKIEFsbG9jTWlkUUVudHJ5KGNvbnN0IHN0cnVjdCBzbWJfaGRyICpzbWJfYnVmZmVyLCBzdHJ1Y3QgVENQX1NlcnZlcl9JbmZvICpzZXJ2ZXIpCiB7CiAJc3RydWN0IG1pZF9xX2VudHJ5ICp0ZW1wOwpAQCAtNTgsMjggKzY0LDI4IEBACiAJLyoJZG9fZ2V0dGltZW9mZGF5KCZ0ZW1wLT53aGVuX3NlbnQpOyovIC8qIGVhc2llciB0byB1c2UgamlmZmllcyAqLwogCQkvKiB3aGVuIG1pZCBhbGxvY2F0ZWQgY2FuIGJlIGJlZm9yZSB3aGVuIHNlbnQgKi8KIAkJdGVtcC0+d2hlbl9hbGxvYyA9IGppZmZpZXM7Ci0JCXRlbXAtPnRzayA9IGN1cnJlbnQ7CisKKwkJLyoKKwkJICogVGhlIGRlZmF1bHQgaXMgZm9yIHRoZSBtaWQgdG8gYmUgc3luY2hyb25vdXMsIHNvIHRoZQorCQkgKiBkZWZhdWx0IGNhbGxiYWNrIGp1c3Qgd2FrZXMgdXAgdGhlIGN1cnJlbnQgdGFzay4KKwkJICovCisJCXRlbXAtPmNhbGxiYWNrID0gd2FrZV91cF90YXNrOworCQl0ZW1wLT5jYWxsYmFja19kYXRhID0gY3VycmVudDsKIAl9CiAKLQlzcGluX2xvY2soJkdsb2JhbE1pZF9Mb2NrKTsKLQlsaXN0X2FkZF90YWlsKCZ0ZW1wLT5xaGVhZCwgJnNlcnZlci0+cGVuZGluZ19taWRfcSk7CiAJYXRvbWljX2luYygmbWlkQ291bnQpOwogCXRlbXAtPm1pZFN0YXRlID0gTUlEX1JFUVVFU1RfQUxMT0NBVEVEOwotCXNwaW5fdW5sb2NrKCZHbG9iYWxNaWRfTG9jayk7CiAJcmV0dXJuIHRlbXA7CiB9CiAKLXN0YXRpYyB2b2lkCit2b2lkCiBEZWxldGVNaWRRRW50cnkoc3RydWN0IG1pZF9xX2VudHJ5ICptaWRFbnRyeSkKIHsKICNpZmRlZiBDT05GSUdfQ0lGU19TVEFUUzIKIAl1bnNpZ25lZCBsb25nIG5vdzsKICNlbmRpZgotCXNwaW5fbG9jaygmR2xvYmFsTWlkX0xvY2spOwogCW1pZEVudHJ5LT5taWRTdGF0ZSA9IE1JRF9GUkVFOwotCWxpc3RfZGVsKCZtaWRFbnRyeS0+cWhlYWQpOwogCWF0b21pY19kZWMoJm1pZENvdW50KTsKLQlzcGluX3VubG9jaygmR2xvYmFsTWlkX0xvY2spOwogCWlmIChtaWRFbnRyeS0+bGFyZ2VCdWYpCiAJCWNpZnNfYnVmX3JlbGVhc2UobWlkRW50cnktPnJlc3BfYnVmKTsKIAllbHNlCkBAIC0xMDMsNiArMTA5LDE2IEBACiAJbWVtcG9vbF9mcmVlKG1pZEVudHJ5LCBjaWZzX21pZF9wb29scCk7CiB9CiAKK3N0YXRpYyB2b2lkCitkZWxldGVfbWlkKHN0cnVjdCBtaWRfcV9lbnRyeSAqbWlkKQoreworCXNwaW5fbG9jaygmR2xvYmFsTWlkX0xvY2spOworCWxpc3RfZGVsKCZtaWQtPnFoZWFkKTsKKwlzcGluX3VubG9jaygmR2xvYmFsTWlkX0xvY2spOworCisJRGVsZXRlTWlkUUVudHJ5KG1pZCk7Cit9CisKIHN0YXRpYyBpbnQKIHNtYl9zZW5kdihzdHJ1Y3QgVENQX1NlcnZlcl9JbmZvICpzZXJ2ZXIsIHN0cnVjdCBrdmVjICppb3YsIGludCBuX3ZlYykKIHsKQEAgLTIyMCw5ICsyMzYsOSBAQAogCQlzZXJ2ZXItPnRjcFN0YXR1cyA9IENpZnNOZWVkUmVjb25uZWN0OwogCX0KIAotCWlmIChyYyA8IDApIHsKKwlpZiAocmMgPCAwICYmIHJjICE9IC1FSU5UUikKIAkJY0VSUk9SKDEsICJFcnJvciAlZCBzZW5kaW5nIGRhdGEgb24gc29ja2V0IHRvIHNlcnZlciIsIHJjKTsKLQl9IGVsc2UKKwllbHNlCiAJCXJjID0gMDsKIAogCS8qIERvbid0IHdhbnQgdG8gbW9kaWZ5IHRoZSBidWZmZXIgYXMgYQpAQCAtMjQ0LDMxICsyNjAsMzEgQEAKIAlyZXR1cm4gc21iX3NlbmR2KHNlcnZlciwgJmlvdiwgMSk7CiB9CiAKLXN0YXRpYyBpbnQgd2FpdF9mb3JfZnJlZV9yZXF1ZXN0KHN0cnVjdCBjaWZzU2VzSW5mbyAqc2VzLCBjb25zdCBpbnQgbG9uZ19vcCkKK3N0YXRpYyBpbnQgd2FpdF9mb3JfZnJlZV9yZXF1ZXN0KHN0cnVjdCBUQ1BfU2VydmVyX0luZm8gKnNlcnZlciwKKwkJCQkgY29uc3QgaW50IGxvbmdfb3ApCiB7CiAJaWYgKGxvbmdfb3AgPT0gQ0lGU19BU1lOQ19PUCkgewogCQkvKiBvcGxvY2sgYnJlYWtzIG11c3Qgbm90IGJlIGhlbGQgdXAgKi8KLQkJYXRvbWljX2luYygmc2VzLT5zZXJ2ZXItPmluRmxpZ2h0KTsKKwkJYXRvbWljX2luYygmc2VydmVyLT5pbkZsaWdodCk7CiAJCXJldHVybiAwOwogCX0KIAogCXNwaW5fbG9jaygmR2xvYmFsTWlkX0xvY2spOwogCXdoaWxlICgxKSB7Ci0JCWlmIChhdG9taWNfcmVhZCgmc2VzLT5zZXJ2ZXItPmluRmxpZ2h0KSA+PQotCQkJCWNpZnNfbWF4X3BlbmRpbmcpeworCQlpZiAoYXRvbWljX3JlYWQoJnNlcnZlci0+aW5GbGlnaHQpID49IGNpZnNfbWF4X3BlbmRpbmcpIHsKIAkJCXNwaW5fdW5sb2NrKCZHbG9iYWxNaWRfTG9jayk7CiAjaWZkZWYgQ09ORklHX0NJRlNfU1RBVFMyCi0JCQlhdG9taWNfaW5jKCZzZXMtPnNlcnZlci0+bnVtX3dhaXRlcnMpOworCQkJYXRvbWljX2luYygmc2VydmVyLT5udW1fd2FpdGVycyk7CiAjZW5kaWYKLQkJCXdhaXRfZXZlbnQoc2VzLT5zZXJ2ZXItPnJlcXVlc3RfcSwKLQkJCQkgICBhdG9taWNfcmVhZCgmc2VzLT5zZXJ2ZXItPmluRmxpZ2h0KQorCQkJd2FpdF9ldmVudChzZXJ2ZXItPnJlcXVlc3RfcSwKKwkJCQkgICBhdG9taWNfcmVhZCgmc2VydmVyLT5pbkZsaWdodCkKIAkJCQkgICAgIDwgY2lmc19tYXhfcGVuZGluZyk7CiAjaWZkZWYgQ09ORklHX0NJRlNfU1RBVFMyCi0JCQlhdG9taWNfZGVjKCZzZXMtPnNlcnZlci0+bnVtX3dhaXRlcnMpOworCQkJYXRvbWljX2RlYygmc2VydmVyLT5udW1fd2FpdGVycyk7CiAjZW5kaWYKIAkJCXNwaW5fbG9jaygmR2xvYmFsTWlkX0xvY2spOwogCQl9IGVsc2UgewotCQkJaWYgKHNlcy0+c2VydmVyLT50Y3BTdGF0dXMgPT0gQ2lmc0V4aXRpbmcpIHsKKwkJCWlmIChzZXJ2ZXItPnRjcFN0YXR1cyA9PSBDaWZzRXhpdGluZykgewogCQkJCXNwaW5fdW5sb2NrKCZHbG9iYWxNaWRfTG9jayk7CiAJCQkJcmV0dXJuIC1FTk9FTlQ7CiAJCQl9CkBAIC0yNzgsNyArMjk0LDcgQEAKIAogCQkJLyogdXBkYXRlICMgb2YgcmVxdWVzdHMgb24gdGhlIHdpcmUgdG8gc2VydmVyICovCiAJCQlpZiAobG9uZ19vcCAhPSBDSUZTX0JMT0NLSU5HX09QKQotCQkJCWF0b21pY19pbmMoJnNlcy0+c2VydmVyLT5pbkZsaWdodCk7CisJCQkJYXRvbWljX2luYygmc2VydmVyLT5pbkZsaWdodCk7CiAJCQlzcGluX3VubG9jaygmR2xvYmFsTWlkX0xvY2spOwogCQkJYnJlYWs7CiAJCX0KQEAgLTMwOCw1NSArMzI0LDg3IEBACiAJKnBwbWlkUSA9IEFsbG9jTWlkUUVudHJ5KGluX2J1Ziwgc2VzLT5zZXJ2ZXIpOwogCWlmICgqcHBtaWRRID09IE5VTEwpCiAJCXJldHVybiAtRU5PTUVNOworCXNwaW5fbG9jaygmR2xvYmFsTWlkX0xvY2spOworCWxpc3RfYWRkX3RhaWwoJigqcHBtaWRRKS0+cWhlYWQsICZzZXMtPnNlcnZlci0+cGVuZGluZ19taWRfcSk7CisJc3Bpbl91bmxvY2soJkdsb2JhbE1pZF9Mb2NrKTsKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCB3YWl0X2Zvcl9yZXNwb25zZShzdHJ1Y3QgY2lmc1Nlc0luZm8gKnNlcywKLQkJCXN0cnVjdCBtaWRfcV9lbnRyeSAqbWlkUSwKLQkJCXVuc2lnbmVkIGxvbmcgdGltZW91dCwKLQkJCXVuc2lnbmVkIGxvbmcgdGltZV90b193YWl0KQorc3RhdGljIGludAord2FpdF9mb3JfcmVzcG9uc2Uoc3RydWN0IFRDUF9TZXJ2ZXJfSW5mbyAqc2VydmVyLCBzdHJ1Y3QgbWlkX3FfZW50cnkgKm1pZFEpCiB7Ci0JdW5zaWduZWQgbG9uZyBjdXJyX3RpbWVvdXQ7CisJaW50IGVycm9yOwogCi0JZm9yICg7OykgewotCQljdXJyX3RpbWVvdXQgPSB0aW1lb3V0ICsgamlmZmllczsKLQkJd2FpdF9ldmVudF90aW1lb3V0KHNlcy0+c2VydmVyLT5yZXNwb25zZV9xLAotCQkJbWlkUS0+bWlkU3RhdGUgIT0gTUlEX1JFUVVFU1RfU1VCTUlUVEVELCB0aW1lb3V0KTsKKwllcnJvciA9IHdhaXRfZXZlbnRfa2lsbGFibGUoc2VydmVyLT5yZXNwb25zZV9xLAorCQkJCSAgICBtaWRRLT5taWRTdGF0ZSAhPSBNSURfUkVRVUVTVF9TVUJNSVRURUQpOworCWlmIChlcnJvciA8IDApCisJCXJldHVybiAtRVJFU1RBUlRTWVM7CiAKLQkJaWYgKHRpbWVfYWZ0ZXIoamlmZmllcywgY3Vycl90aW1lb3V0KSAmJgotCQkJKG1pZFEtPm1pZFN0YXRlID09IE1JRF9SRVFVRVNUX1NVQk1JVFRFRCkgJiYKLQkJCSgoc2VzLT5zZXJ2ZXItPnRjcFN0YXR1cyA9PSBDaWZzR29vZCkgfHwKLQkJCSAoc2VzLT5zZXJ2ZXItPnRjcFN0YXR1cyA9PSBDaWZzTmV3KSkpIHsKLQotCQkJdW5zaWduZWQgbG9uZyBscnQ7Ci0KLQkJCS8qIFdlIHRpbWVkIG91dC4gSXMgdGhlIHNlcnZlciBzdGlsbAotCQkJICAgc2VuZGluZyByZXBsaWVzID8gKi8KLQkJCXNwaW5fbG9jaygmR2xvYmFsTWlkX0xvY2spOwotCQkJbHJ0ID0gc2VzLT5zZXJ2ZXItPmxzdHJwOwotCQkJc3Bpbl91bmxvY2soJkdsb2JhbE1pZF9Mb2NrKTsKLQotCQkJLyogQ2FsY3VsYXRlIHRpbWVfdG9fd2FpdCBwYXN0IGxhc3QgcmVjZWl2ZSB0aW1lLgotCQkJIEFsdGhvdWdoIHdlIHByZWZlciBub3QgdG8gdGltZSBvdXQgaWYgdGhlCi0JCQkgc2VydmVyIGlzIHN0aWxsIHJlc3BvbmRpbmcgLSB3ZSB3aWxsIHRpbWUKLQkJCSBvdXQgaWYgdGhlIHNlcnZlciB0YWtlcyBtb3JlIHRoYW4gMTUgKG9yIDQ1Ci0JCQkgb3IgMTgwKSBzZWNvbmRzIHRvIHJlc3BvbmQgdG8gdGhpcyByZXF1ZXN0Ci0JCQkgYW5kIGhhcyBub3QgcmVzcG9uZGVkIHRvIGFueSByZXF1ZXN0IGZyb20KLQkJCSBvdGhlciB0aHJlYWRzIG9uIHRoZSBjbGllbnQgd2l0aGluIDEwIHNlY29uZHMgKi8KLQkJCWxydCArPSB0aW1lX3RvX3dhaXQ7Ci0JCQlpZiAodGltZV9hZnRlcihqaWZmaWVzLCBscnQpKSB7Ci0JCQkJLyogTm8gcmVwbGllcyBmb3IgdGltZV90b193YWl0LiAqLwotCQkJCWNFUlJPUigxLCAic2VydmVyIG5vdCByZXNwb25kaW5nIik7Ci0JCQkJcmV0dXJuIC0xOwotCQkJfQotCQl9IGVsc2UgewotCQkJcmV0dXJuIDA7Ci0JCX0KLQl9CisJcmV0dXJuIDA7CiB9CiAKIAogLyoKKyAqIFNlbmQgYSBTTUIgcmVxdWVzdCBhbmQgc2V0IHRoZSBjYWxsYmFjayBmdW5jdGlvbiBpbiB0aGUgbWlkIHRvIGhhbmRsZQorICogdGhlIHJlc3VsdC4gQ2FsbGVyIGlzIHJlc3BvbnNpYmxlIGZvciBkZWFsaW5nIHdpdGggdGltZW91dHMuCisgKi8KK2ludAorY2lmc19jYWxsX2FzeW5jKHN0cnVjdCBUQ1BfU2VydmVyX0luZm8gKnNlcnZlciwgc3RydWN0IHNtYl9oZHIgKmluX2J1ZiwKKwkJbWlkX2NhbGxiYWNrX3QgKmNhbGxiYWNrLCB2b2lkICpjYmRhdGEpCit7CisJaW50IHJjOworCXN0cnVjdCBtaWRfcV9lbnRyeSAqbWlkOworCisJcmMgPSB3YWl0X2Zvcl9mcmVlX3JlcXVlc3Qoc2VydmVyLCBDSUZTX0FTWU5DX09QKTsKKwlpZiAocmMpCisJCXJldHVybiByYzsKKworCS8qIGVuYWJsZSBzaWduaW5nIGlmIHNlcnZlciByZXF1aXJlcyBpdCAqLworCWlmIChzZXJ2ZXItPnNlY01vZGUgJiAoU0VDTU9ERV9TSUdOX1JFUVVJUkVEIHwgU0VDTU9ERV9TSUdOX0VOQUJMRUQpKQorCQlpbl9idWYtPkZsYWdzMiB8PSBTTUJGTEcyX1NFQ1VSSVRZX1NJR05BVFVSRTsKKworCW11dGV4X2xvY2soJnNlcnZlci0+c3J2X211dGV4KTsKKwltaWQgPSBBbGxvY01pZFFFbnRyeShpbl9idWYsIHNlcnZlcik7CisJaWYgKG1pZCA9PSBOVUxMKSB7CisJCW11dGV4X3VubG9jaygmc2VydmVyLT5zcnZfbXV0ZXgpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwkvKiBwdXQgaXQgb24gdGhlIHBlbmRpbmdfbWlkX3EgKi8KKwlzcGluX2xvY2soJkdsb2JhbE1pZF9Mb2NrKTsKKwlsaXN0X2FkZF90YWlsKCZtaWQtPnFoZWFkLCAmc2VydmVyLT5wZW5kaW5nX21pZF9xKTsKKwlzcGluX3VubG9jaygmR2xvYmFsTWlkX0xvY2spOworCisJcmMgPSBjaWZzX3NpZ25fc21iKGluX2J1Ziwgc2VydmVyLCAmbWlkLT5zZXF1ZW5jZV9udW1iZXIpOworCWlmIChyYykgeworCQltdXRleF91bmxvY2soJnNlcnZlci0+c3J2X211dGV4KTsKKwkJZ290byBvdXRfZXJyOworCX0KKworCW1pZC0+Y2FsbGJhY2sgPSBjYWxsYmFjazsKKwltaWQtPmNhbGxiYWNrX2RhdGEgPSBjYmRhdGE7CisJbWlkLT5taWRTdGF0ZSA9IE1JRF9SRVFVRVNUX1NVQk1JVFRFRDsKKyNpZmRlZiBDT05GSUdfQ0lGU19TVEFUUzIKKwlhdG9taWNfaW5jKCZzZXJ2ZXItPmluU2VuZCk7CisjZW5kaWYKKwlyYyA9IHNtYl9zZW5kKHNlcnZlciwgaW5fYnVmLCBpbl9idWYtPnNtYl9idWZfbGVuZ3RoKTsKKyNpZmRlZiBDT05GSUdfQ0lGU19TVEFUUzIKKwlhdG9taWNfZGVjKCZzZXJ2ZXItPmluU2VuZCk7CisJbWlkLT53aGVuX3NlbnQgPSBqaWZmaWVzOworI2VuZGlmCisJbXV0ZXhfdW5sb2NrKCZzZXJ2ZXItPnNydl9tdXRleCk7CisJaWYgKHJjKQorCQlnb3RvIG91dF9lcnI7CisKKwlyZXR1cm4gcmM7CitvdXRfZXJyOgorCWRlbGV0ZV9taWQobWlkKTsKKwlhdG9taWNfZGVjKCZzZXJ2ZXItPmluRmxpZ2h0KTsKKwl3YWtlX3VwKCZzZXJ2ZXItPnJlcXVlc3RfcSk7CisJcmV0dXJuIHJjOworfQorCisvKgogICoKICAqIFNlbmQgYW4gU01CIFJlcXVlc3QuICBObyByZXNwb25zZSBpbmZvIChvdGhlciB0aGFuIHJldHVybiBjb2RlKQogICogbmVlZHMgdG8gYmUgcGFyc2VkLgpAQCAtMzgyLDYgKzQzMCw4NCBAQAogCXJldHVybiByYzsKIH0KIAorc3RhdGljIGludAorc3luY19taWRfcmVzdWx0KHN0cnVjdCBtaWRfcV9lbnRyeSAqbWlkLCBzdHJ1Y3QgVENQX1NlcnZlcl9JbmZvICpzZXJ2ZXIpCit7CisJaW50IHJjID0gMDsKKworCWNGWUkoMSwgIiVzOiBjbWQ9JWQgbWlkPSVkIHN0YXRlPSVkIiwgX19mdW5jX18sIG1pZC0+Y29tbWFuZCwKKwkJbWlkLT5taWQsIG1pZC0+bWlkU3RhdGUpOworCisJc3Bpbl9sb2NrKCZHbG9iYWxNaWRfTG9jayk7CisJLyogZW5zdXJlIHRoYXQgaXQncyBubyBsb25nZXIgb24gdGhlIHBlbmRpbmdfbWlkX3EgKi8KKwlsaXN0X2RlbF9pbml0KCZtaWQtPnFoZWFkKTsKKworCXN3aXRjaCAobWlkLT5taWRTdGF0ZSkgeworCWNhc2UgTUlEX1JFU1BPTlNFX1JFQ0VJVkVEOgorCQlzcGluX3VubG9jaygmR2xvYmFsTWlkX0xvY2spOworCQlyZXR1cm4gcmM7CisJY2FzZSBNSURfUkVRVUVTVF9TVUJNSVRURUQ6CisJCS8qIHNvY2tldCBpcyBnb2luZyBkb3duLCByZWplY3QgYWxsIGNhbGxzICovCisJCWlmIChzZXJ2ZXItPnRjcFN0YXR1cyA9PSBDaWZzRXhpdGluZykgeworCQkJY0VSUk9SKDEsICIlczogY2FuY2VsaW5nIG1pZD0lZCBjbWQ9MHgleCBzdGF0ZT0lZCIsCisJCQkgICAgICAgX19mdW5jX18sIG1pZC0+bWlkLCBtaWQtPmNvbW1hbmQsIG1pZC0+bWlkU3RhdGUpOworCQkJcmMgPSAtRUhPU1RET1dOOworCQkJYnJlYWs7CisJCX0KKwljYXNlIE1JRF9SRVRSWV9ORUVERUQ6CisJCXJjID0gLUVBR0FJTjsKKwkJYnJlYWs7CisJY2FzZSBNSURfUkVTUE9OU0VfTUFMRk9STUVEOgorCQlyYyA9IC1FSU87CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWNFUlJPUigxLCAiJXM6IGludmFsaWQgbWlkIHN0YXRlIG1pZD0lZCBzdGF0ZT0lZCIsIF9fZnVuY19fLAorCQkJbWlkLT5taWQsIG1pZC0+bWlkU3RhdGUpOworCQlyYyA9IC1FSU87CisJfQorCXNwaW5fdW5sb2NrKCZHbG9iYWxNaWRfTG9jayk7CisKKwlEZWxldGVNaWRRRW50cnkobWlkKTsKKwlyZXR1cm4gcmM7Cit9CisKKy8qCisgKiBBbiBOVCBjYW5jZWwgcmVxdWVzdCBoZWFkZXIgbG9va3MganVzdCBsaWtlIHRoZSBvcmlnaW5hbCByZXF1ZXN0IGV4Y2VwdDoKKyAqCisgKiBUaGUgQ29tbWFuZCBpcyBTTUJfQ09NX05UX0NBTkNFTAorICogVGhlIFdvcmRDb3VudCBpcyB6ZXJvZWQgb3V0CisgKiBUaGUgQnl0ZUNvdW50IGlzIHplcm9lZCBvdXQKKyAqCisgKiBUaGlzIGZ1bmN0aW9uIG1hbmdsZXMgYW4gZXhpc3RpbmcgcmVxdWVzdCBidWZmZXIgaW50byBhCisgKiBTTUJfQ09NX05UX0NBTkNFTCByZXF1ZXN0IGFuZCB0aGVuIHNlbmRzIGl0LgorICovCitzdGF0aWMgaW50CitzZW5kX250X2NhbmNlbChzdHJ1Y3QgVENQX1NlcnZlcl9JbmZvICpzZXJ2ZXIsIHN0cnVjdCBzbWJfaGRyICppbl9idWYsCisJCXN0cnVjdCBtaWRfcV9lbnRyeSAqbWlkKQoreworCWludCByYyA9IDA7CisKKwkvKiAtNCBmb3IgUkZDMTAwMSBsZW5ndGggYW5kICsyIGZvciBCQ0MgZmllbGQgKi8KKwlpbl9idWYtPnNtYl9idWZfbGVuZ3RoID0gc2l6ZW9mKHN0cnVjdCBzbWJfaGRyKSAtIDQgICsgMjsKKwlpbl9idWYtPkNvbW1hbmQgPSBTTUJfQ09NX05UX0NBTkNFTDsKKwlpbl9idWYtPldvcmRDb3VudCA9IDA7CisJcHV0X2JjY19sZSgwLCBpbl9idWYpOworCisJbXV0ZXhfbG9jaygmc2VydmVyLT5zcnZfbXV0ZXgpOworCXJjID0gY2lmc19zaWduX3NtYihpbl9idWYsIHNlcnZlciwgJm1pZC0+c2VxdWVuY2VfbnVtYmVyKTsKKwlpZiAocmMpIHsKKwkJbXV0ZXhfdW5sb2NrKCZzZXJ2ZXItPnNydl9tdXRleCk7CisJCXJldHVybiByYzsKKwl9CisJcmMgPSBzbWJfc2VuZChzZXJ2ZXIsIGluX2J1ZiwgaW5fYnVmLT5zbWJfYnVmX2xlbmd0aCk7CisJbXV0ZXhfdW5sb2NrKCZzZXJ2ZXItPnNydl9tdXRleCk7CisKKwljRllJKDEsICJpc3N1ZWQgTlRfQ0FOQ0VMIGZvciBtaWQgJXUsIHJjID0gJWQiLAorCQlpbl9idWYtPk1pZCwgcmMpOworCisJcmV0dXJuIHJjOworfQorCiBpbnQKIFNlbmRSZWNlaXZlMihjb25zdCB1bnNpZ25lZCBpbnQgeGlkLCBzdHJ1Y3QgY2lmc1Nlc0luZm8gKnNlcywKIAkgICAgIHN0cnVjdCBrdmVjICppb3YsIGludCBuX3ZlYywgaW50ICpwUmVzcEJ1ZlR5cGUgLyogcmV0ICovLApAQCAtMzkwLDcgKzUxNiw2IEBACiAJaW50IHJjID0gMDsKIAlpbnQgbG9uZ19vcDsKIAl1bnNpZ25lZCBpbnQgcmVjZWl2ZV9sZW47Ci0JdW5zaWduZWQgbG9uZyB0aW1lb3V0OwogCXN0cnVjdCBtaWRfcV9lbnRyeSAqbWlkUTsKIAlzdHJ1Y3Qgc21iX2hkciAqaW5fYnVmID0gaW92WzBdLmlvdl9iYXNlOwogCkBAIC00MTMsNyArNTM4LDcgQEAKIAkgICB0byB0aGUgc2FtZSBzZXJ2ZXIuIFdlIG1heSBtYWtlIHRoaXMgY29uZmlndXJhYmxlIGxhdGVyIG9yCiAJICAgdXNlIHNlcy0+bWF4UmVxICovCiAKLQlyYyA9IHdhaXRfZm9yX2ZyZWVfcmVxdWVzdChzZXMsIGxvbmdfb3ApOworCXJjID0gd2FpdF9mb3JfZnJlZV9yZXF1ZXN0KHNlcy0+c2VydmVyLCBsb25nX29wKTsKIAlpZiAocmMpIHsKIAkJY2lmc19zbWFsbF9idWZfcmVsZWFzZShpbl9idWYpOwogCQlyZXR1cm4gcmM7CkBAIC00NTIsNzAgKzU3Nyw0MSBAQAogI2VuZGlmCiAKIAltdXRleF91bmxvY2soJnNlcy0+c2VydmVyLT5zcnZfbXV0ZXgpOwotCWNpZnNfc21hbGxfYnVmX3JlbGVhc2UoaW5fYnVmKTsKIAotCWlmIChyYyA8IDApCi0JCWdvdG8gb3V0OwotCi0JaWYgKGxvbmdfb3AgPT0gQ0lGU19TVERfT1ApCi0JCXRpbWVvdXQgPSAxNSAqIEhaOwotCWVsc2UgaWYgKGxvbmdfb3AgPT0gQ0lGU19WTE9OR19PUCkgLyogZS5nLiBzbG93IHdyaXRlcyBwYXN0IEVPRiAqLwotCQl0aW1lb3V0ID0gMTgwICogSFo7Ci0JZWxzZSBpZiAobG9uZ19vcCA9PSBDSUZTX0xPTkdfT1ApCi0JCXRpbWVvdXQgPSA0NSAqIEhaOyAvKiBzaG91bGQgYmUgZ3JlYXRlciB0aGFuCi0JCQlzZXJ2ZXJzIG9wbG9jayBicmVhayB0aW1lb3V0IChhYm91dCA0MyBzZWNvbmRzKSAqLwotCWVsc2UgaWYgKGxvbmdfb3AgPT0gQ0lGU19BU1lOQ19PUCkKLQkJZ290byBvdXQ7Ci0JZWxzZSBpZiAobG9uZ19vcCA9PSBDSUZTX0JMT0NLSU5HX09QKQotCQl0aW1lb3V0ID0gMHg3RkZGRkZGRjsgLyogIGxhcmdlLCBidXQgbm90IHNvIGxhcmdlIGFzIHRvIHdyYXAgKi8KLQllbHNlIHsKLQkJY0VSUk9SKDEsICJ1bmtub3duIHRpbWVvdXQgZmxhZyAlZCIsIGxvbmdfb3ApOwotCQlyYyA9IC1FSU87CisJaWYgKHJjIDwgMCkgeworCQljaWZzX3NtYWxsX2J1Zl9yZWxlYXNlKGluX2J1Zik7CiAJCWdvdG8gb3V0OwogCX0KIAotCS8qIHdhaXQgZm9yIDE1IHNlY29uZHMgb3IgdW50aWwgd29rZW4gdXAgZHVlIHRvIHJlc3BvbnNlIGFycml2aW5nIG9yCi0JICAgZHVlIHRvIGxhc3QgY29ubmVjdGlvbiB0byB0aGlzIHNlcnZlciBiZWluZyB1bm1vdW50ZWQgKi8KLQlpZiAoc2lnbmFsX3BlbmRpbmcoY3VycmVudCkpIHsKLQkJLyogaWYgc2lnbmFsIHBlbmRpbmcgZG8gbm90IGhvbGQgdXAgdXNlciBmb3IgZnVsbCBzbWIgdGltZW91dAotCQlidXQgd2Ugc3RpbGwgZ2l2ZSByZXNwb25zZSBhIGNoYW5jZSB0byBjb21wbGV0ZSAqLwotCQl0aW1lb3V0ID0gMiAqIEhaOworCWlmIChsb25nX29wID09IENJRlNfQVNZTkNfT1ApIHsKKwkJY2lmc19zbWFsbF9idWZfcmVsZWFzZShpbl9idWYpOworCQlnb3RvIG91dDsKIAl9CiAKLQkvKiBObyB1c2VyIGludGVycnVwdHMgaW4gd2FpdCAtIHdyZWFrcyBoYXZvYyB3aXRoIHBlcmZvcm1hbmNlICovCi0Jd2FpdF9mb3JfcmVzcG9uc2Uoc2VzLCBtaWRRLCB0aW1lb3V0LCAxMCAqIEhaKTsKLQotCXNwaW5fbG9jaygmR2xvYmFsTWlkX0xvY2spOwotCi0JaWYgKG1pZFEtPnJlc3BfYnVmID09IE5VTEwpIHsKLQkJY0VSUk9SKDEsICJObyByZXNwb25zZSB0byBjbWQgJWQgbWlkICVkIiwKLQkJCW1pZFEtPmNvbW1hbmQsIG1pZFEtPm1pZCk7CisJcmMgPSB3YWl0X2Zvcl9yZXNwb25zZShzZXMtPnNlcnZlciwgbWlkUSk7CisJaWYgKHJjICE9IDApIHsKKwkJc2VuZF9udF9jYW5jZWwoc2VzLT5zZXJ2ZXIsIGluX2J1ZiwgbWlkUSk7CisJCXNwaW5fbG9jaygmR2xvYmFsTWlkX0xvY2spOwogCQlpZiAobWlkUS0+bWlkU3RhdGUgPT0gTUlEX1JFUVVFU1RfU1VCTUlUVEVEKSB7Ci0JCQlpZiAoc2VzLT5zZXJ2ZXItPnRjcFN0YXR1cyA9PSBDaWZzRXhpdGluZykKLQkJCQlyYyA9IC1FSE9TVERPV047Ci0JCQllbHNlIHsKLQkJCQlzZXMtPnNlcnZlci0+dGNwU3RhdHVzID0gQ2lmc05lZWRSZWNvbm5lY3Q7Ci0JCQkJbWlkUS0+bWlkU3RhdGUgPSBNSURfUkVUUllfTkVFREVEOwotCQkJfQotCQl9Ci0KLQkJaWYgKHJjICE9IC1FSE9TVERPV04pIHsKLQkJCWlmIChtaWRRLT5taWRTdGF0ZSA9PSBNSURfUkVUUllfTkVFREVEKSB7Ci0JCQkJcmMgPSAtRUFHQUlOOwotCQkJCWNGWUkoMSwgIm1hcmtpbmcgcmVxdWVzdCBmb3IgcmV0cnkiKTsKLQkJCX0gZWxzZSB7Ci0JCQkJcmMgPSAtRUlPOwotCQkJfQorCQkJbWlkUS0+Y2FsbGJhY2sgPSBEZWxldGVNaWRRRW50cnk7CisJCQlzcGluX3VubG9jaygmR2xvYmFsTWlkX0xvY2spOworCQkJY2lmc19zbWFsbF9idWZfcmVsZWFzZShpbl9idWYpOworCQkJYXRvbWljX2RlYygmc2VzLT5zZXJ2ZXItPmluRmxpZ2h0KTsKKwkJCXdha2VfdXAoJnNlcy0+c2VydmVyLT5yZXF1ZXN0X3EpOworCQkJcmV0dXJuIHJjOwogCQl9CiAJCXNwaW5fdW5sb2NrKCZHbG9iYWxNaWRfTG9jayk7Ci0JCURlbGV0ZU1pZFFFbnRyeShtaWRRKTsKLQkJLyogVXBkYXRlICMgb2YgcmVxdWVzdHMgb24gd2lyZSB0byBzZXJ2ZXIgKi8KKwl9CisKKwljaWZzX3NtYWxsX2J1Zl9yZWxlYXNlKGluX2J1Zik7CisKKwlyYyA9IHN5bmNfbWlkX3Jlc3VsdChtaWRRLCBzZXMtPnNlcnZlcik7CisJaWYgKHJjICE9IDApIHsKIAkJYXRvbWljX2RlYygmc2VzLT5zZXJ2ZXItPmluRmxpZ2h0KTsKIAkJd2FrZV91cCgmc2VzLT5zZXJ2ZXItPnJlcXVlc3RfcSk7CiAJCXJldHVybiByYzsKIAl9CiAKLQlzcGluX3VubG9jaygmR2xvYmFsTWlkX0xvY2spOwogCXJlY2VpdmVfbGVuID0gbWlkUS0+cmVzcF9idWYtPnNtYl9idWZfbGVuZ3RoOwogCiAJaWYgKHJlY2VpdmVfbGVuID4gQ0lGU01heEJ1ZlNpemUgKyBNQVhfQ0lGU19IRFJfU0laRSkgewpAQCAtNTU5LDE5ICs2NTUsMTggQEAKIAkJaWYgKHJlY2VpdmVfbGVuID49IHNpemVvZihzdHJ1Y3Qgc21iX2hkcikgLSA0CiAJCSAgICAvKiBkbyBub3QgY291bnQgUkZDMTAwMSBoZWFkZXIgKi8gICsKIAkJICAgICgyICogbWlkUS0+cmVzcF9idWYtPldvcmRDb3VudCkgKyAyIC8qIGJjYyAqLyApCi0JCQlCQ0MobWlkUS0+cmVzcF9idWYpID0KLQkJCQlsZTE2X3RvX2NwdShCQ0NfTEUobWlkUS0+cmVzcF9idWYpKTsKKwkJCXB1dF9iY2MoZ2V0X2JjY19sZShtaWRRLT5yZXNwX2J1ZiksIG1pZFEtPnJlc3BfYnVmKTsKIAkJaWYgKChmbGFncyAmIENJRlNfTk9fUkVTUCkgPT0gMCkKIAkJCW1pZFEtPnJlc3BfYnVmID0gTlVMTDsgIC8qIG1hcmsgaXQgc28gYnVmIHdpbGwKIAkJCQkJCSAgIG5vdCBiZSBmcmVlZCBieQotCQkJCQkJICAgRGVsZXRlTWlkUUVudHJ5ICovCisJCQkJCQkgICBkZWxldGVfbWlkICovCiAJfSBlbHNlIHsKIAkJcmMgPSAtRUlPOwogCQljRllJKDEsICJCYWQgTUlEIHN0YXRlPyIpOwogCX0KIAogb3V0OgotCURlbGV0ZU1pZFFFbnRyeShtaWRRKTsKKwlkZWxldGVfbWlkKG1pZFEpOwogCWF0b21pY19kZWMoJnNlcy0+c2VydmVyLT5pbkZsaWdodCk7CiAJd2FrZV91cCgmc2VzLT5zZXJ2ZXItPnJlcXVlc3RfcSk7CiAKQEAgLTU4NSw3ICs2ODAsNiBAQAogewogCWludCByYyA9IDA7CiAJdW5zaWduZWQgaW50IHJlY2VpdmVfbGVuOwotCXVuc2lnbmVkIGxvbmcgdGltZW91dDsKIAlzdHJ1Y3QgbWlkX3FfZW50cnkgKm1pZFE7CiAKIAlpZiAoc2VzID09IE5VTEwpIHsKQEAgLTYxMCw3ICs3MDQsNyBAQAogCQlyZXR1cm4gLUVJTzsKIAl9CiAKLQlyYyA9IHdhaXRfZm9yX2ZyZWVfcmVxdWVzdChzZXMsIGxvbmdfb3ApOworCXJjID0gd2FpdF9mb3JfZnJlZV9yZXF1ZXN0KHNlcy0+c2VydmVyLCBsb25nX29wKTsKIAlpZiAocmMpCiAJCXJldHVybiByYzsKIApAQCAtNjQ5LDY0ICs3NDMsMzEgQEAKIAlpZiAocmMgPCAwKQogCQlnb3RvIG91dDsKIAotCWlmIChsb25nX29wID09IENJRlNfU1REX09QKQotCQl0aW1lb3V0ID0gMTUgKiBIWjsKLQkvKiB3YWl0IGZvciAxNSBzZWNvbmRzIG9yIHVudGlsIHdva2VuIHVwIGR1ZSB0byByZXNwb25zZSBhcnJpdmluZyBvcgotCSAgIGR1ZSB0byBsYXN0IGNvbm5lY3Rpb24gdG8gdGhpcyBzZXJ2ZXIgYmVpbmcgdW5tb3VudGVkICovCi0JZWxzZSBpZiAobG9uZ19vcCA9PSBDSUZTX0FTWU5DX09QKQorCWlmIChsb25nX29wID09IENJRlNfQVNZTkNfT1ApCiAJCWdvdG8gb3V0OwotCWVsc2UgaWYgKGxvbmdfb3AgPT0gQ0lGU19WTE9OR19PUCkgLyogd3JpdGVzIHBhc3QgRU9GIGNhbiBiZSBzbG93ICovCi0JCXRpbWVvdXQgPSAxODAgKiBIWjsKLQllbHNlIGlmIChsb25nX29wID09IENJRlNfTE9OR19PUCkKLQkJdGltZW91dCA9IDQ1ICogSFo7IC8qIHNob3VsZCBiZSBncmVhdGVyIHRoYW4KLQkJCXNlcnZlcnMgb3Bsb2NrIGJyZWFrIHRpbWVvdXQgKGFib3V0IDQzIHNlY29uZHMpICovCi0JZWxzZSBpZiAobG9uZ19vcCA9PSBDSUZTX0JMT0NLSU5HX09QKQotCQl0aW1lb3V0ID0gMHg3RkZGRkZGRjsgLyogbGFyZ2UgYnV0IG5vIHNvIGxhcmdlIGFzIHRvIHdyYXAgKi8KLQllbHNlIHsKLQkJY0VSUk9SKDEsICJ1bmtub3duIHRpbWVvdXQgZmxhZyAlZCIsIGxvbmdfb3ApOwotCQlyYyA9IC1FSU87Ci0JCWdvdG8gb3V0OwotCX0KIAotCWlmIChzaWduYWxfcGVuZGluZyhjdXJyZW50KSkgewotCQkvKiBpZiBzaWduYWwgcGVuZGluZyBkbyBub3QgaG9sZCB1cCB1c2VyIGZvciBmdWxsIHNtYiB0aW1lb3V0Ci0JCWJ1dCB3ZSBzdGlsbCBnaXZlIHJlc3BvbnNlIGEgY2hhbmNlIHRvIGNvbXBsZXRlICovCi0JCXRpbWVvdXQgPSAyICogSFo7Ci0JfQotCi0JLyogTm8gdXNlciBpbnRlcnJ1cHRzIGluIHdhaXQgLSB3cmVha3MgaGF2b2Mgd2l0aCBwZXJmb3JtYW5jZSAqLwotCXdhaXRfZm9yX3Jlc3BvbnNlKHNlcywgbWlkUSwgdGltZW91dCwgMTAgKiBIWik7Ci0KLQlzcGluX2xvY2soJkdsb2JhbE1pZF9Mb2NrKTsKLQlpZiAobWlkUS0+cmVzcF9idWYgPT0gTlVMTCkgewotCQljRVJST1IoMSwgIk5vIHJlc3BvbnNlIGZvciBjbWQgJWQgbWlkICVkIiwKLQkJCSAgbWlkUS0+Y29tbWFuZCwgbWlkUS0+bWlkKTsKKwlyYyA9IHdhaXRfZm9yX3Jlc3BvbnNlKHNlcy0+c2VydmVyLCBtaWRRKTsKKwlpZiAocmMgIT0gMCkgeworCQlzZW5kX250X2NhbmNlbChzZXMtPnNlcnZlciwgaW5fYnVmLCBtaWRRKTsKKwkJc3Bpbl9sb2NrKCZHbG9iYWxNaWRfTG9jayk7CiAJCWlmIChtaWRRLT5taWRTdGF0ZSA9PSBNSURfUkVRVUVTVF9TVUJNSVRURUQpIHsKLQkJCWlmIChzZXMtPnNlcnZlci0+dGNwU3RhdHVzID09IENpZnNFeGl0aW5nKQotCQkJCXJjID0gLUVIT1NURE9XTjsKLQkJCWVsc2UgewotCQkJCXNlcy0+c2VydmVyLT50Y3BTdGF0dXMgPSBDaWZzTmVlZFJlY29ubmVjdDsKLQkJCQltaWRRLT5taWRTdGF0ZSA9IE1JRF9SRVRSWV9ORUVERUQ7Ci0JCQl9Ci0JCX0KLQotCQlpZiAocmMgIT0gLUVIT1NURE9XTikgewotCQkJaWYgKG1pZFEtPm1pZFN0YXRlID09IE1JRF9SRVRSWV9ORUVERUQpIHsKLQkJCQlyYyA9IC1FQUdBSU47Ci0JCQkJY0ZZSSgxLCAibWFya2luZyByZXF1ZXN0IGZvciByZXRyeSIpOwotCQkJfSBlbHNlIHsKLQkJCQlyYyA9IC1FSU87Ci0JCQl9CisJCQkvKiBubyBsb25nZXIgY29uc2lkZXJlZCB0byBiZSAiaW4tZmxpZ2h0IiAqLworCQkJbWlkUS0+Y2FsbGJhY2sgPSBEZWxldGVNaWRRRW50cnk7CisJCQlzcGluX3VubG9jaygmR2xvYmFsTWlkX0xvY2spOworCQkJYXRvbWljX2RlYygmc2VzLT5zZXJ2ZXItPmluRmxpZ2h0KTsKKwkJCXdha2VfdXAoJnNlcy0+c2VydmVyLT5yZXF1ZXN0X3EpOworCQkJcmV0dXJuIHJjOwogCQl9CiAJCXNwaW5fdW5sb2NrKCZHbG9iYWxNaWRfTG9jayk7Ci0JCURlbGV0ZU1pZFFFbnRyeShtaWRRKTsKLQkJLyogVXBkYXRlICMgb2YgcmVxdWVzdHMgb24gd2lyZSB0byBzZXJ2ZXIgKi8KKwl9CisKKwlyYyA9IHN5bmNfbWlkX3Jlc3VsdChtaWRRLCBzZXMtPnNlcnZlcik7CisJaWYgKHJjICE9IDApIHsKIAkJYXRvbWljX2RlYygmc2VzLT5zZXJ2ZXItPmluRmxpZ2h0KTsKIAkJd2FrZV91cCgmc2VzLT5zZXJ2ZXItPnJlcXVlc3RfcSk7CiAJCXJldHVybiByYzsKIAl9CiAKLQlzcGluX3VubG9jaygmR2xvYmFsTWlkX0xvY2spOwogCXJlY2VpdmVfbGVuID0gbWlkUS0+cmVzcF9idWYtPnNtYl9idWZfbGVuZ3RoOwogCiAJaWYgKHJlY2VpdmVfbGVuID4gQ0lGU01heEJ1ZlNpemUgKyBNQVhfQ0lGU19IRFJfU0laRSkgewpAQCAtNzQ4LDQzICs4MDksMjAgQEAKIAkJaWYgKHJlY2VpdmVfbGVuID49IHNpemVvZihzdHJ1Y3Qgc21iX2hkcikgLSA0CiAJCSAgICAvKiBkbyBub3QgY291bnQgUkZDMTAwMSBoZWFkZXIgKi8gICsKIAkJICAgICgyICogb3V0X2J1Zi0+V29yZENvdW50KSArIDIgLyogYmNjICovICkKLQkJCUJDQyhvdXRfYnVmKSA9IGxlMTZfdG9fY3B1KEJDQ19MRShvdXRfYnVmKSk7CisJCQlwdXRfYmNjKGdldF9iY2NfbGUobWlkUS0+cmVzcF9idWYpLCBtaWRRLT5yZXNwX2J1Zik7CiAJfSBlbHNlIHsKIAkJcmMgPSAtRUlPOwogCQljRVJST1IoMSwgIkJhZCBNSUQgc3RhdGU/Iik7CiAJfQogCiBvdXQ6Ci0JRGVsZXRlTWlkUUVudHJ5KG1pZFEpOworCWRlbGV0ZV9taWQobWlkUSk7CiAJYXRvbWljX2RlYygmc2VzLT5zZXJ2ZXItPmluRmxpZ2h0KTsKIAl3YWtlX3VwKCZzZXMtPnNlcnZlci0+cmVxdWVzdF9xKTsKIAogCXJldHVybiByYzsKIH0KIAotLyogU2VuZCBhbiBOVF9DQU5DRUwgU01CIHRvIGNhdXNlIHRoZSBQT1NJWCBibG9ja2luZyBsb2NrIHRvIHJldHVybi4gKi8KLQotc3RhdGljIGludAotc2VuZF9udF9jYW5jZWwoc3RydWN0IGNpZnNUY29uSW5mbyAqdGNvbiwgc3RydWN0IHNtYl9oZHIgKmluX2J1ZiwKLQkJc3RydWN0IG1pZF9xX2VudHJ5ICptaWRRKQotewotCWludCByYyA9IDA7Ci0Jc3RydWN0IGNpZnNTZXNJbmZvICpzZXMgPSB0Y29uLT5zZXM7Ci0JX191MTYgbWlkID0gaW5fYnVmLT5NaWQ7Ci0KLQloZWFkZXJfYXNzZW1ibGUoaW5fYnVmLCBTTUJfQ09NX05UX0NBTkNFTCwgdGNvbiwgMCk7Ci0JaW5fYnVmLT5NaWQgPSBtaWQ7Ci0JbXV0ZXhfbG9jaygmc2VzLT5zZXJ2ZXItPnNydl9tdXRleCk7Ci0JcmMgPSBjaWZzX3NpZ25fc21iKGluX2J1Ziwgc2VzLT5zZXJ2ZXIsICZtaWRRLT5zZXF1ZW5jZV9udW1iZXIpOwotCWlmIChyYykgewotCQltdXRleF91bmxvY2soJnNlcy0+c2VydmVyLT5zcnZfbXV0ZXgpOwotCQlyZXR1cm4gcmM7Ci0JfQotCXJjID0gc21iX3NlbmQoc2VzLT5zZXJ2ZXIsIGluX2J1ZiwgaW5fYnVmLT5zbWJfYnVmX2xlbmd0aCk7Ci0JbXV0ZXhfdW5sb2NrKCZzZXMtPnNlcnZlci0+c3J2X211dGV4KTsKLQlyZXR1cm4gcmM7Ci19Ci0KIC8qIFdlIHNlbmQgYSBMT0NLSU5HWF9DQU5DRUxfTE9DSyB0byBjYXVzZSB0aGUgV2luZG93cwogICAgYmxvY2tpbmcgbG9jayB0byByZXR1cm4uICovCiAKQEAgLTgwNyw3ICs4NDUsNyBAQAogCXBTTUItPmhkci5NaWQgPSBHZXROZXh0TWlkKHNlcy0+c2VydmVyKTsKIAogCXJldHVybiBTZW5kUmVjZWl2ZSh4aWQsIHNlcywgaW5fYnVmLCBvdXRfYnVmLAotCQkJJmJ5dGVzX3JldHVybmVkLCBDSUZTX1NURF9PUCk7CisJCQkmYnl0ZXNfcmV0dXJuZWQsIDApOwogfQogCiBpbnQKQEAgLTg0NSw3ICs4ODMsNyBAQAogCQlyZXR1cm4gLUVJTzsKIAl9CiAKLQlyYyA9IHdhaXRfZm9yX2ZyZWVfcmVxdWVzdChzZXMsIENJRlNfQkxPQ0tJTkdfT1ApOworCXJjID0gd2FpdF9mb3JfZnJlZV9yZXF1ZXN0KHNlcy0+c2VydmVyLCBDSUZTX0JMT0NLSU5HX09QKTsKIAlpZiAocmMpCiAJCXJldHVybiByYzsKIApAQCAtODYzLDcgKzkwMSw3IEBACiAKIAlyYyA9IGNpZnNfc2lnbl9zbWIoaW5fYnVmLCBzZXMtPnNlcnZlciwgJm1pZFEtPnNlcXVlbmNlX251bWJlcik7CiAJaWYgKHJjKSB7Ci0JCURlbGV0ZU1pZFFFbnRyeShtaWRRKTsKKwkJZGVsZXRlX21pZChtaWRRKTsKIAkJbXV0ZXhfdW5sb2NrKCZzZXMtPnNlcnZlci0+c3J2X211dGV4KTsKIAkJcmV0dXJuIHJjOwogCX0KQEAgLTg4MCw3ICs5MTgsNyBAQAogCW11dGV4X3VubG9jaygmc2VzLT5zZXJ2ZXItPnNydl9tdXRleCk7CiAKIAlpZiAocmMgPCAwKSB7Ci0JCURlbGV0ZU1pZFFFbnRyeShtaWRRKTsKKwkJZGVsZXRlX21pZChtaWRRKTsKIAkJcmV0dXJuIHJjOwogCX0KIApAQCAtODk5LDEwICs5MzcsOSBAQAogCQlpZiAoaW5fYnVmLT5Db21tYW5kID09IFNNQl9DT01fVFJBTlNBQ1RJT04yKSB7CiAJCQkvKiBQT1NJWCBsb2NrLiBXZSBzZW5kIGEgTlRfQ0FOQ0VMIFNNQiB0byBjYXVzZSB0aGUKIAkJCSAgIGJsb2NraW5nIGxvY2sgdG8gcmV0dXJuLiAqLwotCi0JCQlyYyA9IHNlbmRfbnRfY2FuY2VsKHRjb24sIGluX2J1ZiwgbWlkUSk7CisJCQlyYyA9IHNlbmRfbnRfY2FuY2VsKHNlcy0+c2VydmVyLCBpbl9idWYsIG1pZFEpOwogCQkJaWYgKHJjKSB7Ci0JCQkJRGVsZXRlTWlkUUVudHJ5KG1pZFEpOworCQkJCWRlbGV0ZV9taWQobWlkUSk7CiAJCQkJcmV0dXJuIHJjOwogCQkJfQogCQl9IGVsc2UgewpAQCAtOTE0LDQ3ICs5NTEsMzMgQEAKIAkJCS8qIElmIHdlIGdldCAtRU5PTENLIGJhY2sgdGhlIGxvY2sgbWF5IGhhdmUKIAkJCSAgIGFscmVhZHkgYmVlbiByZW1vdmVkLiBEb24ndCBleGl0IGluIHRoaXMgY2FzZS4gKi8KIAkJCWlmIChyYyAmJiByYyAhPSAtRU5PTENLKSB7Ci0JCQkJRGVsZXRlTWlkUUVudHJ5KG1pZFEpOworCQkJCWRlbGV0ZV9taWQobWlkUSk7CiAJCQkJcmV0dXJuIHJjOwogCQkJfQogCQl9CiAKLQkJLyogV2FpdCA1IHNlY29uZHMgZm9yIHRoZSByZXNwb25zZS4gKi8KLQkJaWYgKHdhaXRfZm9yX3Jlc3BvbnNlKHNlcywgbWlkUSwgNSAqIEhaLCA1ICogSFopID09IDApIHsKLQkJCS8qIFdlIGdvdCB0aGUgcmVzcG9uc2UgLSByZXN0YXJ0IHN5c3RlbSBjYWxsLiAqLwotCQkJcnN0YXJ0ID0gMTsKKwkJcmMgPSB3YWl0X2Zvcl9yZXNwb25zZShzZXMtPnNlcnZlciwgbWlkUSk7CisJCWlmIChyYykgeworCQkJc2VuZF9udF9jYW5jZWwoc2VzLT5zZXJ2ZXIsIGluX2J1ZiwgbWlkUSk7CisJCQlzcGluX2xvY2soJkdsb2JhbE1pZF9Mb2NrKTsKKwkJCWlmIChtaWRRLT5taWRTdGF0ZSA9PSBNSURfUkVRVUVTVF9TVUJNSVRURUQpIHsKKwkJCQkvKiBubyBsb25nZXIgY29uc2lkZXJlZCB0byBiZSAiaW4tZmxpZ2h0IiAqLworCQkJCW1pZFEtPmNhbGxiYWNrID0gRGVsZXRlTWlkUUVudHJ5OworCQkJCXNwaW5fdW5sb2NrKCZHbG9iYWxNaWRfTG9jayk7CisJCQkJcmV0dXJuIHJjOworCQkJfQorCQkJc3Bpbl91bmxvY2soJkdsb2JhbE1pZF9Mb2NrKTsKIAkJfQorCisJCS8qIFdlIGdvdCB0aGUgcmVzcG9uc2UgLSByZXN0YXJ0IHN5c3RlbSBjYWxsLiAqLworCQlyc3RhcnQgPSAxOwogCX0KIAotCXNwaW5fbG9jaygmR2xvYmFsTWlkX0xvY2spOwotCWlmIChtaWRRLT5yZXNwX2J1ZikgewotCQlzcGluX3VubG9jaygmR2xvYmFsTWlkX0xvY2spOwotCQlyZWNlaXZlX2xlbiA9IG1pZFEtPnJlc3BfYnVmLT5zbWJfYnVmX2xlbmd0aDsKLQl9IGVsc2UgewotCQljRVJST1IoMSwgIk5vIHJlc3BvbnNlIGZvciBjbWQgJWQgbWlkICVkIiwKLQkJCSAgbWlkUS0+Y29tbWFuZCwgbWlkUS0+bWlkKTsKLQkJaWYgKG1pZFEtPm1pZFN0YXRlID09IE1JRF9SRVFVRVNUX1NVQk1JVFRFRCkgewotCQkJaWYgKHNlcy0+c2VydmVyLT50Y3BTdGF0dXMgPT0gQ2lmc0V4aXRpbmcpCi0JCQkJcmMgPSAtRUhPU1RET1dOOwotCQkJZWxzZSB7Ci0JCQkJc2VzLT5zZXJ2ZXItPnRjcFN0YXR1cyA9IENpZnNOZWVkUmVjb25uZWN0OwotCQkJCW1pZFEtPm1pZFN0YXRlID0gTUlEX1JFVFJZX05FRURFRDsKLQkJCX0KLQkJfQotCi0JCWlmIChyYyAhPSAtRUhPU1RET1dOKSB7Ci0JCQlpZiAobWlkUS0+bWlkU3RhdGUgPT0gTUlEX1JFVFJZX05FRURFRCkgewotCQkJCXJjID0gLUVBR0FJTjsKLQkJCQljRllJKDEsICJtYXJraW5nIHJlcXVlc3QgZm9yIHJldHJ5Iik7Ci0JCQl9IGVsc2UgewotCQkJCXJjID0gLUVJTzsKLQkJCX0KLQkJfQotCQlzcGluX3VubG9jaygmR2xvYmFsTWlkX0xvY2spOwotCQlEZWxldGVNaWRRRW50cnkobWlkUSk7CisJcmMgPSBzeW5jX21pZF9yZXN1bHQobWlkUSwgc2VzLT5zZXJ2ZXIpOworCWlmIChyYyAhPSAwKQogCQlyZXR1cm4gcmM7Ci0JfQogCisJcmVjZWl2ZV9sZW4gPSBtaWRRLT5yZXNwX2J1Zi0+c21iX2J1Zl9sZW5ndGg7CiAJaWYgKHJlY2VpdmVfbGVuID4gQ0lGU01heEJ1ZlNpemUgKyBNQVhfQ0lGU19IRFJfU0laRSkgewogCQljRVJST1IoMSwgIkZyYW1lIHRvbyBsYXJnZSByZWNlaXZlZC4gIExlbmd0aDogJWQgIFhpZDogJWQiLAogCQkJcmVjZWl2ZV9sZW4sIHhpZCk7CkBAIC05OTgsMTAgKzEwMjEsMTAgQEAKIAlpZiAocmVjZWl2ZV9sZW4gPj0gc2l6ZW9mKHN0cnVjdCBzbWJfaGRyKSAtIDQKIAkgICAgLyogZG8gbm90IGNvdW50IFJGQzEwMDEgaGVhZGVyICovICArCiAJICAgICgyICogb3V0X2J1Zi0+V29yZENvdW50KSArIDIgLyogYmNjICovICkKLQkJQkNDKG91dF9idWYpID0gbGUxNl90b19jcHUoQkNDX0xFKG91dF9idWYpKTsKKwkJcHV0X2JjYyhnZXRfYmNjX2xlKG91dF9idWYpLCBvdXRfYnVmKTsKIAogb3V0OgotCURlbGV0ZU1pZFFFbnRyeShtaWRRKTsKKwlkZWxldGVfbWlkKG1pZFEpOwogCWlmIChyc3RhcnQgJiYgcmMgPT0gLUVBQ0NFUykKIAkJcmV0dXJuIC1FUkVTVEFSVFNZUzsKIAlyZXR1cm4gcmM7CmRpZmYgLS1naXQgYS9mcy9jb21wYXQuYyBiL2ZzL2NvbXBhdC5jCmluZGV4IGViMTc0MGEuLmY2ZmQwYTAgMTAwNjQ0Ci0tLSBhL2ZzL2NvbXBhdC5jCisrKyBiL2ZzL2NvbXBhdC5jCkBAIC0yNTcsNyArMjU3LDcgQEAKIH0KIAogLyoKLSAqIFRoZSBmb2xsb3dpbmcgc3RhdGZzIGNhbGxzIGFyZSBjb3BpZXMgb2YgY29kZSBmcm9tIGZzL29wZW4uYyBhbmQKKyAqIFRoZSBmb2xsb3dpbmcgc3RhdGZzIGNhbGxzIGFyZSBjb3BpZXMgb2YgY29kZSBmcm9tIGZzL3N0YXRmcy5jIGFuZAogICogc2hvdWxkIGJlIGNoZWNrZWQgYWdhaW5zdCB0aG9zZSBmcm9tIHRpbWUgdG8gdGltZQogICovCiBhc21saW5rYWdlIGxvbmcgY29tcGF0X3N5c19zdGF0ZnMoY29uc3QgY2hhciBfX3VzZXIgKnBhdGhuYW1lLCBzdHJ1Y3QgY29tcGF0X3N0YXRmcyBfX3VzZXIgKmJ1ZikKQEAgLTMyMCw3ICszMjAsOSBAQAogCSAgICBfX3B1dF91c2VyKGtidWYtPmZfbmFtZWxlbiwgJnVidWYtPmZfbmFtZWxlbikgfHwKIAkgICAgX19wdXRfdXNlcihrYnVmLT5mX2ZzaWQudmFsWzBdLCAmdWJ1Zi0+Zl9mc2lkLnZhbFswXSkgfHwKIAkgICAgX19wdXRfdXNlcihrYnVmLT5mX2ZzaWQudmFsWzFdLCAmdWJ1Zi0+Zl9mc2lkLnZhbFsxXSkgfHwKLQkgICAgX19wdXRfdXNlcihrYnVmLT5mX2Zyc2l6ZSwgJnVidWYtPmZfZnJzaXplKSkKKwkgICAgX19wdXRfdXNlcihrYnVmLT5mX2Zyc2l6ZSwgJnVidWYtPmZfZnJzaXplKSB8fAorCSAgICBfX3B1dF91c2VyKGtidWYtPmZfZmxhZ3MsICZ1YnVmLT5mX2ZsYWdzKSB8fAorCSAgICBfX2NsZWFyX3VzZXIodWJ1Zi0+Zl9zcGFyZSwgc2l6ZW9mKHVidWYtPmZfc3BhcmUpKSkKIAkJcmV0dXJuIC1FRkFVTFQ7CiAJcmV0dXJuIDA7CiB9CkBAIC01OTcsMTAgKzU5OSw4IEBACiAJaWYgKG5yX3NlZ3MgPiBmYXN0X3NlZ3MpIHsKIAkJcmV0ID0gLUVOT01FTTsKIAkJaW92ID0ga21hbGxvYyhucl9zZWdzKnNpemVvZihzdHJ1Y3QgaW92ZWMpLCBHRlBfS0VSTkVMKTsKLQkJaWYgKGlvdiA9PSBOVUxMKSB7Ci0JCQkqcmV0X3BvaW50ZXIgPSBmYXN0X3BvaW50ZXI7CisJCWlmIChpb3YgPT0gTlVMTCkKIAkJCWdvdG8gb3V0OwotCQl9CiAJfQogCSpyZXRfcG9pbnRlciA9IGlvdjsKIApkaWZmIC0tZ2l0IGEvZnMvY29uZmlnZnMvS2NvbmZpZyBiL2ZzL2NvbmZpZ2ZzL0tjb25maWcKaW5kZXggMTM1ODdjYy4uOWZlYmNkZSAxMDA2NDQKLS0tIGEvZnMvY29uZmlnZnMvS2NvbmZpZworKysgYi9mcy9jb25maWdmcy9LY29uZmlnCkBAIC0xLDggKzEsOCBAQAogY29uZmlnIENPTkZJR0ZTX0ZTCiAJdHJpc3RhdGUgIlVzZXJzcGFjZS1kcml2ZW4gY29uZmlndXJhdGlvbiBmaWxlc3lzdGVtIgotCWRlcGVuZHMgb24gU1lTRlMKKwlzZWxlY3QgU1lTRlMKIAloZWxwCi0JICBjb25maWdmcyBpcyBhIHJhbS1iYXNlZCBmaWxlc3lzdGVtIHRoYXQgcHJvdmlkZXMgdGhlIGNvbnZlcnNlCisJICBjb25maWdmcyBpcyBhIFJBTS1iYXNlZCBmaWxlc3lzdGVtIHRoYXQgcHJvdmlkZXMgdGhlIGNvbnZlcnNlCiAJICBvZiBzeXNmcydzIGZ1bmN0aW9uYWxpdHkuIFdoZXJlIHN5c2ZzIGlzIGEgZmlsZXN5c3RlbS1iYXNlZAogCSAgdmlldyBvZiBrZXJuZWwgb2JqZWN0cywgY29uZmlnZnMgaXMgYSBmaWxlc3lzdGVtLWJhc2VkIG1hbmFnZXIKIAkgIG9mIGtlcm5lbCBvYmplY3RzLCBvciBjb25maWdfaXRlbXMuCmRpZmYgLS1naXQgYS9mcy9kY2FjaGUuYyBiL2ZzL2RjYWNoZS5jCmluZGV4IDBjNmQ1YzUuLjJhNmJkOWE0IDEwMDY0NAotLS0gYS9mcy9kY2FjaGUuYworKysgYi9mcy9kY2FjaGUuYwpAQCAtMTc2LDYgKzE3Niw3IEBACiAKIC8qKgogICogZGVudHJ5X3JjdXdhbGtfYmFycmllciAtIGludmFsaWRhdGUgaW4tcHJvZ3Jlc3MgcmN1LXdhbGsgbG9va3VwcworICogQGRlbnRyeTogdGhlIHRhcmdldCBkZW50cnkKICAqIEFmdGVyIHRoaXMgY2FsbCwgaW4tcHJvZ3Jlc3MgcmN1LXdhbGsgcGF0aCBsb29rdXAgd2lsbCBmYWlsLiBUaGlzCiAgKiBzaG91bGQgYmUgY2FsbGVkIGFmdGVyIHVuaGFzaGluZywgYW5kIGFmdGVyIGNoYW5naW5nIGRfaW5vZGUgKGlmCiAgKiB0aGUgZGVudHJ5IGhhcyBub3QgYWxyZWFkeSBiZWVuIHVuaGFzaGVkKS4KQEAgLTI4MSw2ICsyODIsNyBAQAogLyoqCiAgKiBkX2tpbGwgLSBraWxsIGRlbnRyeSBhbmQgcmV0dXJuIHBhcmVudAogICogQGRlbnRyeTogZGVudHJ5IHRvIGtpbGwKKyAqIEBwYXJlbnQ6IHBhcmVudCBkZW50cnkKICAqCiAgKiBUaGUgZGVudHJ5IG11c3QgYWxyZWFkeSBiZSB1bmhhc2hlZCBhbmQgcmVtb3ZlZCBmcm9tIHRoZSBMUlUuCiAgKgpAQCAtMTM1Nyw4ICsxMzU5LDggQEAKIAogdm9pZCBkX3NldF9kX29wKHN0cnVjdCBkZW50cnkgKmRlbnRyeSwgY29uc3Qgc3RydWN0IGRlbnRyeV9vcGVyYXRpb25zICpvcCkKIHsKLQlCVUdfT04oZGVudHJ5LT5kX29wKTsKLQlCVUdfT04oZGVudHJ5LT5kX2ZsYWdzICYgKERDQUNIRV9PUF9IQVNICXwKKwlXQVJOX09OX09OQ0UoZGVudHJ5LT5kX29wKTsKKwlXQVJOX09OX09OQ0UoZGVudHJ5LT5kX2ZsYWdzICYgKERDQUNIRV9PUF9IQVNICXwKIAkJCQlEQ0FDSEVfT1BfQ09NUEFSRQl8CiAJCQkJRENBQ0hFX09QX1JFVkFMSURBVEUJfAogCQkJCURDQUNIRV9PUF9ERUxFVEUgKSk7CkBAIC0xMzgwLDggKzEzODIsMTEgQEAKIHN0YXRpYyB2b2lkIF9fZF9pbnN0YW50aWF0ZShzdHJ1Y3QgZGVudHJ5ICpkZW50cnksIHN0cnVjdCBpbm9kZSAqaW5vZGUpCiB7CiAJc3Bpbl9sb2NrKCZkZW50cnktPmRfbG9jayk7Ci0JaWYgKGlub2RlKQorCWlmIChpbm9kZSkgeworCQlpZiAodW5saWtlbHkoSVNfQVVUT01PVU5UKGlub2RlKSkpCisJCQlkZW50cnktPmRfZmxhZ3MgfD0gRENBQ0hFX05FRURfQVVUT01PVU5UOwogCQlsaXN0X2FkZCgmZGVudHJ5LT5kX2FsaWFzLCAmaW5vZGUtPmlfZGVudHJ5KTsKKwl9CiAJZGVudHJ5LT5kX2lub2RlID0gaW5vZGU7CiAJZGVudHJ5X3JjdXdhbGtfYmFycmllcihkZW50cnkpOwogCXNwaW5fdW5sb2NrKCZkZW50cnktPmRfbG9jayk7CkBAIC0xOTcwLDcgKzE5NzUsNyBAQAogLyoqCiAgKiBkX3ZhbGlkYXRlIC0gdmVyaWZ5IGRlbnRyeSBwcm92aWRlZCBmcm9tIGluc2VjdXJlIHNvdXJjZSAoZGVwcmVjYXRlZCkKICAqIEBkZW50cnk6IFRoZSBkZW50cnkgYWxsZWdlZCB0byBiZSB2YWxpZCBjaGlsZCBvZiBAZHBhcmVudAotICogQHBhcmVudDogVGhlIHBhcmVudCBkZW50cnkgKGtub3duIHRvIGJlIHZhbGlkKQorICogQGRwYXJlbnQ6IFRoZSBwYXJlbnQgZGVudHJ5IChrbm93biB0byBiZSB2YWxpZCkKICAqCiAgKiBBbiBpbnNlY3VyZSBzb3VyY2UgaGFzIHNlbnQgdXMgYSBkZW50cnksIGhlcmUgd2UgdmVyaWZ5IGl0IGFuZCBkZ2V0KCkgaXQuCiAgKiBUaGlzIGlzIHVzZWQgYnkgbmNwZnMgaW4gaXRzIHJlYWRkaXIgaW1wbGVtZW50YXRpb24uCmRpZmYgLS1naXQgYS9mcy9kaXJlY3QtaW8uYyBiL2ZzL2RpcmVjdC1pby5jCmluZGV4IDgyMDFjMjU1Li5kY2I1NTc3IDEwMDY0NAotLS0gYS9mcy9kaXJlY3QtaW8uYworKysgYi9mcy9kaXJlY3QtaW8uYwpAQCAtMzI1LDEyICszMjUsMTYgQEAKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGRpb19lbmRfaW8pOwogCi1zdGF0aWMgaW50CitzdGF0aWMgdm9pZAogZGlvX2Jpb19hbGxvYyhzdHJ1Y3QgZGlvICpkaW8sIHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsCiAJCXNlY3Rvcl90IGZpcnN0X3NlY3RvciwgaW50IG5yX3ZlY3MpCiB7CiAJc3RydWN0IGJpbyAqYmlvOwogCisJLyoKKwkgKiBiaW9fYWxsb2MoKSBpcyBndWFyYW50ZWVkIHRvIHJldHVybiBhIGJpbyB3aGVuIGNhbGxlZCB3aXRoCisJICogX19HRlBfV0FJVCBhbmQgd2UgcmVxdWVzdCBhIHZhbGlkIG51bWJlciBvZiB2ZWN0b3JzLgorCSAqLwogCWJpbyA9IGJpb19hbGxvYyhHRlBfS0VSTkVMLCBucl92ZWNzKTsKIAogCWJpby0+YmlfYmRldiA9IGJkZXY7CkBAIC0zNDIsNyArMzQ2LDYgQEAKIAogCWRpby0+YmlvID0gYmlvOwogCWRpby0+bG9naWNhbF9vZmZzZXRfaW5fYmlvID0gZGlvLT5jdXJfcGFnZV9mc19vZmZzZXQ7Ci0JcmV0dXJuIDA7CiB9CiAKIC8qCkBAIC01ODMsOCArNTg2LDkgQEAKIAkJZ290byBvdXQ7CiAJc2VjdG9yID0gc3RhcnRfc2VjdG9yIDw8IChkaW8tPmJsa2JpdHMgLSA5KTsKIAlucl9wYWdlcyA9IG1pbihkaW8tPnBhZ2VzX2luX2lvLCBiaW9fZ2V0X25yX3ZlY3MoZGlvLT5tYXBfYmguYl9iZGV2KSk7CisJbnJfcGFnZXMgPSBtaW4obnJfcGFnZXMsIEJJT19NQVhfUEFHRVMpOwogCUJVR19PTihucl9wYWdlcyA8PSAwKTsKLQlyZXQgPSBkaW9fYmlvX2FsbG9jKGRpbywgZGlvLT5tYXBfYmguYl9iZGV2LCBzZWN0b3IsIG5yX3BhZ2VzKTsKKwlkaW9fYmlvX2FsbG9jKGRpbywgZGlvLT5tYXBfYmguYl9iZGV2LCBzZWN0b3IsIG5yX3BhZ2VzKTsKIAlkaW8tPmJvdW5kYXJ5ID0gMDsKIG91dDoKIAlyZXR1cm4gcmV0OwpkaWZmIC0tZ2l0IGEvZnMvZGxtL0tjb25maWcgYi9mcy9kbG0vS2NvbmZpZwppbmRleCAyZGJiNDIyLi4xODk3ZWIxYiAxMDA2NDQKLS0tIGEvZnMvZGxtL0tjb25maWcKKysrIGIvZnMvZGxtL0tjb25maWcKQEAgLTEsOCArMSw3IEBACiBtZW51Y29uZmlnIERMTQogCXRyaXN0YXRlICJEaXN0cmlidXRlZCBMb2NrIE1hbmFnZXIgKERMTSkiCiAJZGVwZW5kcyBvbiBFWFBFUklNRU5UQUwgJiYgSU5FVAotCWRlcGVuZHMgb24gU1lTRlMgJiYgKElQVjYgfHwgSVBWNj1uKQotCXNlbGVjdCBDT05GSUdGU19GUworCWRlcGVuZHMgb24gU1lTRlMgJiYgQ09ORklHRlNfRlMgJiYgKElQVjYgfHwgSVBWNj1uKQogCXNlbGVjdCBJUF9TQ1RQCiAJaGVscAogCUEgZ2VuZXJhbCBwdXJwb3NlIGRpc3RyaWJ1dGVkIGxvY2sgbWFuYWdlciBmb3Iga2VybmVsIG9yIHVzZXJzcGFjZQpkaWZmIC0tZ2l0IGEvZnMvZGxtL2xvd2NvbW1zLmMgYi9mcy9kbG0vbG93Y29tbXMuYwppbmRleCA5YzY0YWU5Li4yZDhjODdiIDEwMDY0NAotLS0gYS9mcy9kbG0vbG93Y29tbXMuYworKysgYi9mcy9kbG0vbG93Y29tbXMuYwpAQCAtMTQ2OCwxNSArMTQ2OCwxMyBAQAogCiBzdGF0aWMgaW50IHdvcmtfc3RhcnQodm9pZCkKIHsKLQlyZWN2X3dvcmtxdWV1ZSA9IGFsbG9jX3dvcmtxdWV1ZSgiZGxtX3JlY3YiLCBXUV9NRU1fUkVDTEFJTSB8Ci0JCQkJCSBXUV9ISUdIUFJJIHwgV1FfRlJFRVpFQUJMRSwgMCk7CisJcmVjdl93b3JrcXVldWUgPSBjcmVhdGVfc2luZ2xldGhyZWFkX3dvcmtxdWV1ZSgiZGxtX3JlY3YiKTsKIAlpZiAoIXJlY3Zfd29ya3F1ZXVlKSB7CiAJCWxvZ19wcmludCgiY2FuJ3Qgc3RhcnQgZGxtX3JlY3YiKTsKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQogCi0Jc2VuZF93b3JrcXVldWUgPSBhbGxvY193b3JrcXVldWUoImRsbV9zZW5kIiwgV1FfTUVNX1JFQ0xBSU0gfAotCQkJCQkgV1FfSElHSFBSSSB8IFdRX0ZSRUVaRUFCTEUsIDApOworCXNlbmRfd29ya3F1ZXVlID0gY3JlYXRlX3NpbmdsZXRocmVhZF93b3JrcXVldWUoImRsbV9zZW5kIik7CiAJaWYgKCFzZW5kX3dvcmtxdWV1ZSkgewogCQlsb2dfcHJpbnQoImNhbid0IHN0YXJ0IGRsbV9zZW5kIik7CiAJCWRlc3Ryb3lfd29ya3F1ZXVlKHJlY3Zfd29ya3F1ZXVlKTsKZGlmZiAtLWdpdCBhL2ZzL2VjcnlwdGZzL2NyeXB0by5jIGIvZnMvZWNyeXB0ZnMvY3J5cHRvLmMKaW5kZXggY2JhZGMxYi4uYmZkOGI2OCAxMDA2NDQKLS0tIGEvZnMvZWNyeXB0ZnMvY3J5cHRvLmMKKysrIGIvZnMvZWNyeXB0ZnMvY3J5cHRvLmMKQEAgLTM0OCw3ICszNDgsNyBAQAogCUJVR19PTighY3J5cHRfc3RhdCB8fCAhY3J5cHRfc3RhdC0+dGZtCiAJICAgICAgIHx8ICEoY3J5cHRfc3RhdC0+ZmxhZ3MgJiBFQ1JZUFRGU19TVFJVQ1RfSU5JVElBTElaRUQpKTsKIAlpZiAodW5saWtlbHkoZWNyeXB0ZnNfdmVyYm9zaXR5ID4gMCkpIHsKLQkJZWNyeXB0ZnNfcHJpbnRrKEtFUk5fREVCVUcsICJLZXkgc2l6ZSBbJWRdOyBrZXk6XG4iLAorCQllY3J5cHRmc19wcmludGsoS0VSTl9ERUJVRywgIktleSBzaXplIFslemRdOyBrZXk6XG4iLAogCQkJCWNyeXB0X3N0YXQtPmtleV9zaXplKTsKIAkJZWNyeXB0ZnNfZHVtcF9oZXgoY3J5cHRfc3RhdC0+a2V5LAogCQkJCSAgY3J5cHRfc3RhdC0+a2V5X3NpemUpOwpAQCAtNDEzLDEwICs0MTMsOSBAQAogCXJjID0gZWNyeXB0ZnNfZGVyaXZlX2l2KGV4dGVudF9pdiwgY3J5cHRfc3RhdCwKIAkJCQkoZXh0ZW50X2Jhc2UgKyBleHRlbnRfb2Zmc2V0KSk7CiAJaWYgKHJjKSB7Ci0JCWVjcnlwdGZzX3ByaW50ayhLRVJOX0VSUiwgIkVycm9yIGF0dGVtcHRpbmcgdG8gIgotCQkJCSJkZXJpdmUgSVYgZm9yIGV4dGVudCBbMHglLjE2eF07ICIKLQkJCQkicmMgPSBbJWRdXG4iLCAoZXh0ZW50X2Jhc2UgKyBleHRlbnRfb2Zmc2V0KSwKLQkJCQlyYyk7CisJCWVjcnlwdGZzX3ByaW50ayhLRVJOX0VSUiwgIkVycm9yIGF0dGVtcHRpbmcgdG8gZGVyaXZlIElWIGZvciAiCisJCQkiZXh0ZW50IFsweCUuMTZsbHhdOyByYyA9IFslZF1cbiIsCisJCQkodW5zaWduZWQgbG9uZyBsb25nKShleHRlbnRfYmFzZSArIGV4dGVudF9vZmZzZXQpLCByYyk7CiAJCWdvdG8gb3V0OwogCX0KIAlpZiAodW5saWtlbHkoZWNyeXB0ZnNfdmVyYm9zaXR5ID4gMCkpIHsKQEAgLTQ0Myw5ICs0NDIsOSBAQAogCX0KIAlyYyA9IDA7CiAJaWYgKHVubGlrZWx5KGVjcnlwdGZzX3ZlcmJvc2l0eSA+IDApKSB7Ci0JCWVjcnlwdGZzX3ByaW50ayhLRVJOX0RFQlVHLCAiRW5jcnlwdCBleHRlbnQgWzB4JS4xNnhdOyAiCi0JCQkJInJjID0gWyVkXVxuIiwgKGV4dGVudF9iYXNlICsgZXh0ZW50X29mZnNldCksCi0JCQkJcmMpOworCQllY3J5cHRmc19wcmludGsoS0VSTl9ERUJVRywgIkVuY3J5cHQgZXh0ZW50IFsweCUuMTZsbHhdOyAiCisJCQkicmMgPSBbJWRdXG4iLAorCQkJKHVuc2lnbmVkIGxvbmcgbG9uZykoZXh0ZW50X2Jhc2UgKyBleHRlbnRfb2Zmc2V0KSwgcmMpOwogCQllY3J5cHRmc19wcmludGsoS0VSTl9ERUJVRywgIkZpcnN0IDggYnl0ZXMgYWZ0ZXIgIgogCQkJCSJlbmNyeXB0aW9uOlxuIik7CiAJCWVjcnlwdGZzX2R1bXBfaGV4KChjaGFyICopKHBhZ2VfYWRkcmVzcyhlbmNfZXh0ZW50X3BhZ2UpKSwgOCk7CkBAIC01NDAsMTAgKzUzOSw5IEBACiAJcmMgPSBlY3J5cHRmc19kZXJpdmVfaXYoZXh0ZW50X2l2LCBjcnlwdF9zdGF0LAogCQkJCShleHRlbnRfYmFzZSArIGV4dGVudF9vZmZzZXQpKTsKIAlpZiAocmMpIHsKLQkJZWNyeXB0ZnNfcHJpbnRrKEtFUk5fRVJSLCAiRXJyb3IgYXR0ZW1wdGluZyB0byAiCi0JCQkJImRlcml2ZSBJViBmb3IgZXh0ZW50IFsweCUuMTZ4XTsgIgotCQkJCSJyYyA9IFslZF1cbiIsIChleHRlbnRfYmFzZSArIGV4dGVudF9vZmZzZXQpLAotCQkJCXJjKTsKKwkJZWNyeXB0ZnNfcHJpbnRrKEtFUk5fRVJSLCAiRXJyb3IgYXR0ZW1wdGluZyB0byBkZXJpdmUgSVYgZm9yICIKKwkJCSJleHRlbnQgWzB4JS4xNmxseF07IHJjID0gWyVkXVxuIiwKKwkJCSh1bnNpZ25lZCBsb25nIGxvbmcpKGV4dGVudF9iYXNlICsgZXh0ZW50X29mZnNldCksIHJjKTsKIAkJZ290byBvdXQ7CiAJfQogCWlmICh1bmxpa2VseShlY3J5cHRmc192ZXJib3NpdHkgPiAwKSkgewpAQCAtNTcxLDkgKzU2OSw5IEBACiAJfQogCXJjID0gMDsKIAlpZiAodW5saWtlbHkoZWNyeXB0ZnNfdmVyYm9zaXR5ID4gMCkpIHsKLQkJZWNyeXB0ZnNfcHJpbnRrKEtFUk5fREVCVUcsICJEZWNyeXB0IGV4dGVudCBbMHglLjE2eF07ICIKLQkJCQkicmMgPSBbJWRdXG4iLCAoZXh0ZW50X2Jhc2UgKyBleHRlbnRfb2Zmc2V0KSwKLQkJCQlyYyk7CisJCWVjcnlwdGZzX3ByaW50ayhLRVJOX0RFQlVHLCAiRGVjcnlwdCBleHRlbnQgWzB4JS4xNmxseF07ICIKKwkJCSJyYyA9IFslZF1cbiIsCisJCQkodW5zaWduZWQgbG9uZyBsb25nKShleHRlbnRfYmFzZSArIGV4dGVudF9vZmZzZXQpLCByYyk7CiAJCWVjcnlwdGZzX3ByaW50ayhLRVJOX0RFQlVHLCAiRmlyc3QgOCBieXRlcyBhZnRlciAiCiAJCQkJImRlY3J5cHRpb246XG4iKTsKIAkJZWNyeXB0ZnNfZHVtcF9oZXgoKGNoYXIgKikocGFnZV9hZGRyZXNzKHBhZ2UpCkBAIC03ODAsNyArNzc4LDcgQEAKIAl9CiAJZWNyeXB0ZnNfcHJpbnRrKEtFUk5fREVCVUcsCiAJCQkiSW5pdGlhbGl6aW5nIGNpcGhlciBbJXNdOyBzdHJsZW4gPSBbJWRdOyAiCi0JCQkia2V5X3NpemVfYml0cyA9IFslZF1cbiIsCisJCQkia2V5X3NpemVfYml0cyA9IFslemRdXG4iLAogCQkJY3J5cHRfc3RhdC0+Y2lwaGVyLCAoaW50KXN0cmxlbihjcnlwdF9zdGF0LT5jaXBoZXIpLAogCQkJY3J5cHRfc3RhdC0+a2V5X3NpemUgPDwgMyk7CiAJaWYgKGNyeXB0X3N0YXQtPnRmbSkgewpkaWZmIC0tZ2l0IGEvZnMvZWNyeXB0ZnMvZWNyeXB0ZnNfa2VybmVsLmggYi9mcy9lY3J5cHRmcy9lY3J5cHRmc19rZXJuZWwuaAppbmRleCA0MTNhM2M0Li5kYmM4NGVkIDEwMDY0NAotLS0gYS9mcy9lY3J5cHRmcy9lY3J5cHRmc19rZXJuZWwuaAorKysgYi9mcy9lY3J5cHRmcy9lY3J5cHRmc19rZXJuZWwuaApAQCAtMTkyLDcgKzE5Miw2IEBACiAJCSgoKHN0cnVjdCB1c2VyX2tleV9wYXlsb2FkKilrZXktPnBheWxvYWQuZGF0YSktPmRhdGEpOwogfQogCi0jZGVmaW5lIEVDUllQVEZTX1NVUEVSX01BR0lDIDB4ZjE1ZgogI2RlZmluZSBFQ1JZUFRGU19NQVhfS0VZU0VUX1NJWkUgMTAyNAogI2RlZmluZSBFQ1JZUFRGU19NQVhfQ0lQSEVSX05BTUVfU0laRSAzMgogI2RlZmluZSBFQ1JZUFRGU19NQVhfTlVNX0VOQ19LRVlTIDY0CkBAIC01ODQsNiArNTgzLDcgQEAKIAogI2RlZmluZSBlY3J5cHRmc19wcmludGsodHlwZSwgZm10LCBhcmcuLi4pIFwKICAgICAgICAgX19lY3J5cHRmc19wcmludGsodHlwZSAiJXM6ICIgZm10LCBfX2Z1bmNfXywgIyMgYXJnKTsKK19fYXR0cmlidXRlX18gKChmb3JtYXQocHJpbnRmLCAxLCAyKSkpCiB2b2lkIF9fZWNyeXB0ZnNfcHJpbnRrKGNvbnN0IGNoYXIgKmZtdCwgLi4uKTsKIAogZXh0ZXJuIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgZWNyeXB0ZnNfbWFpbl9mb3BzOwpkaWZmIC0tZ2l0IGEvZnMvZWNyeXB0ZnMvZmlsZS5jIGIvZnMvZWNyeXB0ZnMvZmlsZS5jCmluZGV4IDkxZGEwMjkuLjgxZTEwZTYgMTAwNjQ0Ci0tLSBhL2ZzL2VjcnlwdGZzL2ZpbGUuYworKysgYi9mcy9lY3J5cHRmcy9maWxlLmMKQEAgLTQ3LDcgKzQ3LDcgQEAKIAkJCQljb25zdCBzdHJ1Y3QgaW92ZWMgKmlvdiwKIAkJCQl1bnNpZ25lZCBsb25nIG5yX3NlZ3MsIGxvZmZfdCBwb3MpCiB7Ci0JaW50IHJjOworCXNzaXplX3QgcmM7CiAJc3RydWN0IGRlbnRyeSAqbG93ZXJfZGVudHJ5OwogCXN0cnVjdCB2ZnNtb3VudCAqbG93ZXJfdmZzbW91bnQ7CiAJc3RydWN0IGZpbGUgKmZpbGUgPSBpb2NiLT5raV9maWxwOwpAQCAtMTkxLDE4ICsxOTEsMTYgQEAKIAkJCQkgICAgICB8IEVDUllQVEZTX0VOQ1JZUFRFRCk7CiAJfQogCW11dGV4X3VubG9jaygmY3J5cHRfc3RhdC0+Y3NfbXV0ZXgpOwotCWlmICghZWNyeXB0ZnNfaW5vZGVfdG9fcHJpdmF0ZShpbm9kZSktPmxvd2VyX2ZpbGUpIHsKLQkJcmMgPSBlY3J5cHRmc19pbml0X3BlcnNpc3RlbnRfZmlsZShlY3J5cHRmc19kZW50cnkpOwotCQlpZiAocmMpIHsKLQkJCXByaW50ayhLRVJOX0VSUiAiJXM6IEVycm9yIGF0dGVtcHRpbmcgdG8gaW5pdGlhbGl6ZSAiCi0JCQkgICAgICAgInRoZSBwZXJzaXN0ZW50IGZpbGUgZm9yIHRoZSBkZW50cnkgd2l0aCBuYW1lICIKLQkJCSAgICAgICAiWyVzXTsgcmMgPSBbJWRdXG4iLCBfX2Z1bmNfXywKLQkJCSAgICAgICBlY3J5cHRmc19kZW50cnktPmRfbmFtZS5uYW1lLCByYyk7Ci0JCQlnb3RvIG91dF9mcmVlOwotCQl9CisJcmMgPSBlY3J5cHRmc19pbml0X3BlcnNpc3RlbnRfZmlsZShlY3J5cHRmc19kZW50cnkpOworCWlmIChyYykgeworCQlwcmludGsoS0VSTl9FUlIgIiVzOiBFcnJvciBhdHRlbXB0aW5nIHRvIGluaXRpYWxpemUgIgorCQkJInRoZSBwZXJzaXN0ZW50IGZpbGUgZm9yIHRoZSBkZW50cnkgd2l0aCBuYW1lICIKKwkJCSJbJXNdOyByYyA9IFslZF1cbiIsIF9fZnVuY19fLAorCQkJZWNyeXB0ZnNfZGVudHJ5LT5kX25hbWUubmFtZSwgcmMpOworCQlnb3RvIG91dF9mcmVlOwogCX0KLQlpZiAoKGVjcnlwdGZzX2lub2RlX3RvX3ByaXZhdGUoaW5vZGUpLT5sb3dlcl9maWxlLT5mX2ZsYWdzICYgT19SRE9OTFkpCi0JICAgICYmICEoZmlsZS0+Zl9mbGFncyAmIE9fUkRPTkxZKSkgeworCWlmICgoZWNyeXB0ZnNfaW5vZGVfdG9fcHJpdmF0ZShpbm9kZSktPmxvd2VyX2ZpbGUtPmZfZmxhZ3MgJiBPX0FDQ01PREUpCisJICAgID09IE9fUkRPTkxZICYmIChmaWxlLT5mX2ZsYWdzICYgT19BQ0NNT0RFKSAhPSBPX1JET05MWSkgewogCQlyYyA9IC1FUEVSTTsKIAkJcHJpbnRrKEtFUk5fV0FSTklORyAiJXM6IExvd2VyIHBlcnNpc3RlbnQgZmlsZSBpcyBSTzsgZUNyeXB0ZnMgIgogCQkgICAgICAgImZpbGUgbXVzdCBoZW5jZSBiZSBvcGVuZWQgUk9cbiIsIF9fZnVuY19fKTsKQEAgLTI0Myw5ICsyNDEsOSBAQAogCQl9CiAJfQogCW11dGV4X3VubG9jaygmY3J5cHRfc3RhdC0+Y3NfbXV0ZXgpOwotCWVjcnlwdGZzX3ByaW50ayhLRVJOX0RFQlVHLCAiaW5vZGUgdy8gYWRkciA9IFsweCVwXSwgaV9pbm8gPSBbMHglLjE2eF0gIgotCQkJInNpemU6IFsweCUuMTZ4XVxuIiwgaW5vZGUsIGlub2RlLT5pX2lubywKLQkJCWlfc2l6ZV9yZWFkKGlub2RlKSk7CisJZWNyeXB0ZnNfcHJpbnRrKEtFUk5fREVCVUcsICJpbm9kZSB3LyBhZGRyID0gWzB4JXBdLCBpX2lubyA9ICIKKwkJCSJbMHglLjE2bHhdIHNpemU6IFsweCUuMTZsbHhdXG4iLCBpbm9kZSwgaW5vZGUtPmlfaW5vLAorCQkJKHVuc2lnbmVkIGxvbmcgbG9uZylpX3NpemVfcmVhZChpbm9kZSkpOwogCWdvdG8gb3V0Owogb3V0X2ZyZWU6CiAJa21lbV9jYWNoZV9mcmVlKGVjcnlwdGZzX2ZpbGVfaW5mb19jYWNoZSwKZGlmZiAtLWdpdCBhL2ZzL2VjcnlwdGZzL2lub2RlLmMgYi9mcy9lY3J5cHRmcy9pbm9kZS5jCmluZGV4IDY0ZmYwMjMuLmJkMzNmODcgMTAwNjQ0Ci0tLSBhL2ZzL2VjcnlwdGZzL2lub2RlLmMKKysrIGIvZnMvZWNyeXB0ZnMvaW5vZGUuYwpAQCAtMTg1LDE1ICsxODUsMTMgQEAKIAkJCQkiY29udGV4dDsgcmMgPSBbJWRdXG4iLCByYyk7CiAJCWdvdG8gb3V0OwogCX0KLQlpZiAoIWVjcnlwdGZzX2lub2RlX3RvX3ByaXZhdGUoZWNyeXB0ZnNfZGVudHJ5LT5kX2lub2RlKS0+bG93ZXJfZmlsZSkgewotCQlyYyA9IGVjcnlwdGZzX2luaXRfcGVyc2lzdGVudF9maWxlKGVjcnlwdGZzX2RlbnRyeSk7Ci0JCWlmIChyYykgewotCQkJcHJpbnRrKEtFUk5fRVJSICIlczogRXJyb3IgYXR0ZW1wdGluZyB0byBpbml0aWFsaXplICIKLQkJCSAgICAgICAidGhlIHBlcnNpc3RlbnQgZmlsZSBmb3IgdGhlIGRlbnRyeSB3aXRoIG5hbWUgIgotCQkJICAgICAgICJbJXNdOyByYyA9IFslZF1cbiIsIF9fZnVuY19fLAotCQkJICAgICAgIGVjcnlwdGZzX2RlbnRyeS0+ZF9uYW1lLm5hbWUsIHJjKTsKLQkJCWdvdG8gb3V0OwotCQl9CisJcmMgPSBlY3J5cHRmc19pbml0X3BlcnNpc3RlbnRfZmlsZShlY3J5cHRmc19kZW50cnkpOworCWlmIChyYykgeworCQlwcmludGsoS0VSTl9FUlIgIiVzOiBFcnJvciBhdHRlbXB0aW5nIHRvIGluaXRpYWxpemUgIgorCQkJInRoZSBwZXJzaXN0ZW50IGZpbGUgZm9yIHRoZSBkZW50cnkgd2l0aCBuYW1lICIKKwkJCSJbJXNdOyByYyA9IFslZF1cbiIsIF9fZnVuY19fLAorCQkJZWNyeXB0ZnNfZGVudHJ5LT5kX25hbWUubmFtZSwgcmMpOworCQlnb3RvIG91dDsKIAl9CiAJcmMgPSBlY3J5cHRmc193cml0ZV9tZXRhZGF0YShlY3J5cHRmc19kZW50cnkpOwogCWlmIChyYykgewpAQCAtMzAyLDE1ICszMDAsMTMgQEAKIAkJcmMgPSAtRU5PTUVNOwogCQlnb3RvIG91dDsKIAl9Ci0JaWYgKCFlY3J5cHRmc19pbm9kZV90b19wcml2YXRlKGVjcnlwdGZzX2RlbnRyeS0+ZF9pbm9kZSktPmxvd2VyX2ZpbGUpIHsKLQkJcmMgPSBlY3J5cHRmc19pbml0X3BlcnNpc3RlbnRfZmlsZShlY3J5cHRmc19kZW50cnkpOwotCQlpZiAocmMpIHsKLQkJCXByaW50ayhLRVJOX0VSUiAiJXM6IEVycm9yIGF0dGVtcHRpbmcgdG8gaW5pdGlhbGl6ZSAiCi0JCQkgICAgICAgInRoZSBwZXJzaXN0ZW50IGZpbGUgZm9yIHRoZSBkZW50cnkgd2l0aCBuYW1lICIKLQkJCSAgICAgICAiWyVzXTsgcmMgPSBbJWRdXG4iLCBfX2Z1bmNfXywKLQkJCSAgICAgICBlY3J5cHRmc19kZW50cnktPmRfbmFtZS5uYW1lLCByYyk7Ci0JCQlnb3RvIG91dF9mcmVlX2ttZW07Ci0JCX0KKwlyYyA9IGVjcnlwdGZzX2luaXRfcGVyc2lzdGVudF9maWxlKGVjcnlwdGZzX2RlbnRyeSk7CisJaWYgKHJjKSB7CisJCXByaW50ayhLRVJOX0VSUiAiJXM6IEVycm9yIGF0dGVtcHRpbmcgdG8gaW5pdGlhbGl6ZSAiCisJCQkidGhlIHBlcnNpc3RlbnQgZmlsZSBmb3IgdGhlIGRlbnRyeSB3aXRoIG5hbWUgIgorCQkJIlslc107IHJjID0gWyVkXVxuIiwgX19mdW5jX18sCisJCQllY3J5cHRmc19kZW50cnktPmRfbmFtZS5uYW1lLCByYyk7CisJCWdvdG8gb3V0X2ZyZWVfa21lbTsKIAl9CiAJY3J5cHRfc3RhdCA9ICZlY3J5cHRmc19pbm9kZV90b19wcml2YXRlKAogCQkJCQllY3J5cHRmc19kZW50cnktPmRfaW5vZGUpLT5jcnlwdF9zdGF0OwpkaWZmIC0tZ2l0IGEvZnMvZWNyeXB0ZnMva2V5c3RvcmUuYyBiL2ZzL2VjcnlwdGZzL2tleXN0b3JlLmMKaW5kZXggYjFmNjg1OC4uYzE0MzZjZiAxMDA2NDQKLS0tIGEvZnMvZWNyeXB0ZnMva2V5c3RvcmUuYworKysgYi9mcy9lY3J5cHRmcy9rZXlzdG9yZS5jCkBAIC01OSw3ICs1OSw3IEBACiAJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCWVjcnlwdGZzX3ByaW50ayhLRVJOX1dBUk5JTkcsICJVbmtub3duIGVycm9yIGNvZGU6ICIKLQkJCQkiWzB4JS4xNnhdXG4iLCBlcnJfY29kZSk7CisJCQkJIlsweCUuMTZseF1cbiIsIGVycl9jb2RlKTsKIAkJcmMgPSAtRUlOVkFMOwogCX0KIAlyZXR1cm4gcmM7CkBAIC0xMzAsNyArMTMwLDcgQEAKIAl9IGVsc2UgewogCQlyYyA9IC1FSU5WQUw7CiAJCWVjcnlwdGZzX3ByaW50ayhLRVJOX1dBUk5JTkcsCi0JCQkJIlVuc3VwcG9ydGVkIHBhY2tldCBzaXplOiBbJWRdXG4iLCBzaXplKTsKKwkJCQkiVW5zdXBwb3J0ZWQgcGFja2V0IHNpemU6IFslemRdXG4iLCBzaXplKTsKIAl9CiAJcmV0dXJuIHJjOwogfQpAQCAtMTY3Miw3ICsxNjcyLDcgQEAKIAkgICAgICAgYXV0aF90b2stPnNlc3Npb25fa2V5LmRlY3J5cHRlZF9rZXlfc2l6ZSk7CiAJY3J5cHRfc3RhdC0+ZmxhZ3MgfD0gRUNSWVBURlNfS0VZX1ZBTElEOwogCWlmICh1bmxpa2VseShlY3J5cHRmc192ZXJib3NpdHkgPiAwKSkgewotCQllY3J5cHRmc19wcmludGsoS0VSTl9ERUJVRywgIkZFSyBvZiBzaXplIFslZF06XG4iLAorCQllY3J5cHRmc19wcmludGsoS0VSTl9ERUJVRywgIkZFSyBvZiBzaXplIFslemRdOlxuIiwKIAkJCQljcnlwdF9zdGF0LT5rZXlfc2l6ZSk7CiAJCWVjcnlwdGZzX2R1bXBfaGV4KGNyeXB0X3N0YXQtPmtleSwKIAkJCQkgIGNyeXB0X3N0YXQtPmtleV9zaXplKTsKQEAgLTE3NTQsNyArMTc1NCw3IEBACiAJCQlpZiAoRUNSWVBURlNfU0lHX1NJWkUgIT0gdGFnXzExX2NvbnRlbnRzX3NpemUpIHsKIAkJCQllY3J5cHRmc19wcmludGsoS0VSTl9FUlIsICJFeHBlY3RlZCAiCiAJCQkJCQkic2lnbmF0dXJlIG9mIHNpemUgWyVkXTsgIgotCQkJCQkJInJlYWQgc2l6ZSBbJWRdXG4iLAorCQkJCQkJInJlYWQgc2l6ZSBbJXpkXVxuIiwKIAkJCQkJCUVDUllQVEZTX1NJR19TSVpFLAogCQkJCQkJdGFnXzExX2NvbnRlbnRzX3NpemUpOwogCQkJCXJjID0gLUVJTzsKQEAgLTE3ODcsOCArMTc4Nyw4IEBACiAJCQlnb3RvIG91dF93aXBlX2xpc3Q7CiAJCQlicmVhazsKIAkJZGVmYXVsdDoKLQkJCWVjcnlwdGZzX3ByaW50ayhLRVJOX0RFQlVHLCAiTm8gcGFja2V0IGF0IG9mZnNldCAiCi0JCQkJCSJbJWRdIG9mIHRoZSBmaWxlIGhlYWRlcjsgaGV4IHZhbHVlIG9mICIKKwkJCWVjcnlwdGZzX3ByaW50ayhLRVJOX0RFQlVHLCAiTm8gcGFja2V0IGF0IG9mZnNldCBbJXpkXSAiCisJCQkJCSJvZiB0aGUgZmlsZSBoZWFkZXI7IGhleCB2YWx1ZSBvZiAiCiAJCQkJCSJjaGFyYWN0ZXIgaXMgWzB4JS4yeF1cbiIsIGksIHNyY1tpXSk7CiAJCQluZXh0X3BhY2tldF9pc19hdXRoX3Rva19wYWNrZXQgPSAwOwogCQl9CkBAIC0xODY0LDggKzE4NjQsOCBAQAogCQkJCSJzZXNzaW9uIGtleSBmb3IgYXV0aGVudGljYXRpb24gdG9rZW4gd2l0aCBzaWcgIgogCQkJCSJbJS4qc107IHJjID0gWyVkXS4gUmVtb3ZpbmcgYXV0aCB0b2sgIgogCQkJCSJjYW5kaWRhdGUgZnJvbSB0aGUgbGlzdCBhbmQgc2VhcmNoaW5nIGZvciAiCi0JCQkJInRoZSBuZXh0IG1hdGNoLlxuIiwgY2FuZGlkYXRlX2F1dGhfdG9rX3NpZywKLQkJCQlFQ1JZUFRGU19TSUdfU0laRV9IRVgsIHJjKTsKKwkJCQkidGhlIG5leHQgbWF0Y2guXG4iLCBFQ1JZUFRGU19TSUdfU0laRV9IRVgsCisJCQkJY2FuZGlkYXRlX2F1dGhfdG9rX3NpZywJcmMpOwogCQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoYXV0aF90b2tfbGlzdF9pdGVtLAogCQkJCQkgYXV0aF90b2tfbGlzdF9pdGVtX3RtcCwKIAkJCQkJICZhdXRoX3Rva19saXN0LCBsaXN0KSB7CkBAIC0yMTY4LDcgKzIxNjgsNyBAQAogCWlmIChlbmNyeXB0ZWRfc2Vzc2lvbl9rZXlfdmFsaWQpIHsKIAkJZWNyeXB0ZnNfcHJpbnRrKEtFUk5fREVCVUcsICJlbmNyeXB0ZWRfc2Vzc2lvbl9rZXlfdmFsaWQgIT0gMDsgIgogCQkJCSJ1c2luZyBhdXRoX3Rvay0+c2Vzc2lvbl9rZXkuZW5jcnlwdGVkX2tleSwgIgotCQkJCSJ3aGVyZSBrZXlfcmVjLT5lbmNfa2V5X3NpemUgPSBbJWRdXG4iLAorCQkJCSJ3aGVyZSBrZXlfcmVjLT5lbmNfa2V5X3NpemUgPSBbJXpkXVxuIiwKIAkJCQlrZXlfcmVjLT5lbmNfa2V5X3NpemUpOwogCQltZW1jcHkoa2V5X3JlYy0+ZW5jX2tleSwKIAkJICAgICAgIGF1dGhfdG9rLT5zZXNzaW9uX2tleS5lbmNyeXB0ZWRfa2V5LApAQCAtMjE5OCw3ICsyMTk4LDcgQEAKIAlpZiAocmMgPCAxIHx8IHJjID4gMikgewogCQllY3J5cHRmc19wcmludGsoS0VSTl9FUlIsICJFcnJvciBnZW5lcmF0aW5nIHNjYXR0ZXJsaXN0ICIKIAkJCQkiZm9yIGNyeXB0X3N0YXQgc2Vzc2lvbiBrZXk7IGV4cGVjdGVkIHJjID0gMTsgIgotCQkJCSJnb3QgcmMgPSBbJWRdLiBrZXlfcmVjLT5lbmNfa2V5X3NpemUgPSBbJWRdXG4iLAorCQkJCSJnb3QgcmMgPSBbJWRdLiBrZXlfcmVjLT5lbmNfa2V5X3NpemUgPSBbJXpkXVxuIiwKIAkJCQlyYywga2V5X3JlYy0+ZW5jX2tleV9zaXplKTsKIAkJcmMgPSAtRU5PTUVNOwogCQlnb3RvIG91dDsKQEAgLTIyMDksNyArMjIwOSw3IEBACiAJCWVjcnlwdGZzX3ByaW50ayhLRVJOX0VSUiwgIkVycm9yIGdlbmVyYXRpbmcgc2NhdHRlcmxpc3QgIgogCQkJCSJmb3IgY3J5cHRfc3RhdCBlbmNyeXB0ZWQgc2Vzc2lvbiBrZXk7ICIKIAkJCQkiZXhwZWN0ZWQgcmMgPSAxOyBnb3QgcmMgPSBbJWRdLiAiCi0JCQkJImtleV9yZWMtPmVuY19rZXlfc2l6ZSA9IFslZF1cbiIsIHJjLAorCQkJCSJrZXlfcmVjLT5lbmNfa2V5X3NpemUgPSBbJXpkXVxuIiwgcmMsCiAJCQkJa2V5X3JlYy0+ZW5jX2tleV9zaXplKTsKIAkJcmMgPSAtRU5PTUVNOwogCQlnb3RvIG91dDsKQEAgLTIyMjQsNyArMjIyNCw3IEBACiAJCWdvdG8gb3V0OwogCX0KIAlyYyA9IDA7Ci0JZWNyeXB0ZnNfcHJpbnRrKEtFUk5fREVCVUcsICJFbmNyeXB0aW5nIFslZF0gYnl0ZXMgb2YgdGhlIGtleVxuIiwKKwllY3J5cHRmc19wcmludGsoS0VSTl9ERUJVRywgIkVuY3J5cHRpbmcgWyV6ZF0gYnl0ZXMgb2YgdGhlIGtleVxuIiwKIAkJCWNyeXB0X3N0YXQtPmtleV9zaXplKTsKIAlyYyA9IGNyeXB0b19ibGtjaXBoZXJfZW5jcnlwdCgmZGVzYywgZHN0X3NnLCBzcmNfc2csCiAJCQkJICAgICAgKCprZXlfcmVjKS5lbmNfa2V5X3NpemUpOwpAQCAtMjIzNSw3ICsyMjM1LDcgQEAKIAl9CiAJZWNyeXB0ZnNfcHJpbnRrKEtFUk5fREVCVUcsICJUaGlzIHNob3VsZCBiZSB0aGUgZW5jcnlwdGVkIGtleTpcbiIpOwogCWlmIChlY3J5cHRmc192ZXJib3NpdHkgPiAwKSB7Ci0JCWVjcnlwdGZzX3ByaW50ayhLRVJOX0RFQlVHLCAiRUZFSyBvZiBzaXplIFslZF06XG4iLAorCQllY3J5cHRmc19wcmludGsoS0VSTl9ERUJVRywgIkVGRUsgb2Ygc2l6ZSBbJXpkXTpcbiIsCiAJCQkJa2V5X3JlYy0+ZW5jX2tleV9zaXplKTsKIAkJZWNyeXB0ZnNfZHVtcF9oZXgoa2V5X3JlYy0+ZW5jX2tleSwKIAkJCQkgIGtleV9yZWMtPmVuY19rZXlfc2l6ZSk7CmRpZmYgLS1naXQgYS9mcy9lY3J5cHRmcy9tYWluLmMgYi9mcy9lY3J5cHRmcy9tYWluLmMKaW5kZXggOWVkNDc2OS4uNzU4MzIzYSAxMDA2NDQKLS0tIGEvZnMvZWNyeXB0ZnMvbWFpbi5jCisrKyBiL2ZzL2VjcnlwdGZzL21haW4uYwpAQCAtMzYsNiArMzYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3BhcnNlci5oPgogI2luY2x1ZGUgPGxpbnV4L2ZzX3N0YWNrLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L21hZ2ljLmg+CiAjaW5jbHVkZSAiZWNyeXB0ZnNfa2VybmVsLmgiCiAKIC8qKgpAQCAtMTQxLDEzICsxNDIsMTIgQEAKIAlyZXR1cm4gcmM7CiB9CiAKLXN0YXRpYyBpbm9kZSAqZWNyeXB0ZnNfZ2V0X2lub2RlKHN0cnVjdCBpbm9kZSAqbG93ZXJfaW5vZGUsCitzdGF0aWMgc3RydWN0IGlub2RlICplY3J5cHRmc19nZXRfaW5vZGUoc3RydWN0IGlub2RlICpsb3dlcl9pbm9kZSwKIAkJICAgICAgIHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCiB7CiAJc3RydWN0IGlub2RlICppbm9kZTsKIAlpbnQgcmMgPSAwOwogCi0JbG93ZXJfaW5vZGUgPSBsb3dlcl9kZW50cnktPmRfaW5vZGU7CiAJaWYgKGxvd2VyX2lub2RlLT5pX3NiICE9IGVjcnlwdGZzX3N1cGVyYmxvY2tfdG9fbG93ZXIoc2IpKSB7CiAJCXJjID0gLUVYREVWOwogCQlnb3RvIG91dDsKQEAgLTIwMiw3ICsyMDIsNyBAQAogewogCXN0cnVjdCBpbm9kZSAqbG93ZXJfaW5vZGUgPSBsb3dlcl9kZW50cnktPmRfaW5vZGU7CiAJc3RydWN0IGlub2RlICppbm9kZSA9IGVjcnlwdGZzX2dldF9pbm9kZShsb3dlcl9pbm9kZSwgc2IpOwotCWlmIChJU19FUlIoaW5vZGUpCisJaWYgKElTX0VSUihpbm9kZSkpCiAJCXJldHVybiBQVFJfRVJSKGlub2RlKTsKIAlpZiAoZmxhZ3MgJiBFQ1JZUFRGU19JTlRFUlBPU0VfRkxBR19EX0FERCkKIAkJZF9hZGQoZGVudHJ5LCBpbm9kZSk7CkBAIC01NjUsNiArNTY1LDcgQEAKIAllY3J5cHRmc19zZXRfc3VwZXJibG9ja19sb3dlcihzLCBwYXRoLmRlbnRyeS0+ZF9zYik7CiAJcy0+c19tYXhieXRlcyA9IHBhdGguZGVudHJ5LT5kX3NiLT5zX21heGJ5dGVzOwogCXMtPnNfYmxvY2tzaXplID0gcGF0aC5kZW50cnktPmRfc2ItPnNfYmxvY2tzaXplOworCXMtPnNfbWFnaWMgPSBFQ1JZUFRGU19TVVBFUl9NQUdJQzsKIAogCWlub2RlID0gZWNyeXB0ZnNfZ2V0X2lub2RlKHBhdGguZGVudHJ5LT5kX2lub2RlLCBzKTsKIAlyYyA9IFBUUl9FUlIoaW5vZGUpOwpAQCAtODA5LDkgKzgxMCwxMCBAQAogCQllY3J5cHRmc19wcmludGsoS0VSTl9FUlIsICJUaGUgZUNyeXB0ZnMgZXh0ZW50IHNpemUgaXMgIgogCQkJCSJsYXJnZXIgdGhhbiB0aGUgaG9zdCdzIHBhZ2Ugc2l6ZSwgYW5kIHNvICIKIAkJCQkiZUNyeXB0ZnMgY2Fubm90IHJ1biBvbiB0aGlzIHN5c3RlbS4gVGhlICIKLQkJCQkiZGVmYXVsdCBlQ3J5cHRmcyBleHRlbnQgc2l6ZSBpcyBbJWRdIGJ5dGVzOyAiCi0JCQkJInRoZSBwYWdlIHNpemUgaXMgWyVkXSBieXRlcy5cbiIsCi0JCQkJRUNSWVBURlNfREVGQVVMVF9FWFRFTlRfU0laRSwgUEFHRV9DQUNIRV9TSVpFKTsKKwkJCQkiZGVmYXVsdCBlQ3J5cHRmcyBleHRlbnQgc2l6ZSBpcyBbJXVdIGJ5dGVzOyAiCisJCQkJInRoZSBwYWdlIHNpemUgaXMgWyVsdV0gYnl0ZXMuXG4iLAorCQkJCUVDUllQVEZTX0RFRkFVTFRfRVhURU5UX1NJWkUsCisJCQkJKHVuc2lnbmVkIGxvbmcpUEFHRV9DQUNIRV9TSVpFKTsKIAkJZ290byBvdXQ7CiAJfQogCXJjID0gZWNyeXB0ZnNfaW5pdF9rbWVtX2NhY2hlcygpOwpkaWZmIC0tZ2l0IGEvZnMvZWNyeXB0ZnMvbW1hcC5jIGIvZnMvZWNyeXB0ZnMvbW1hcC5jCmluZGV4IGIxZDgyNzUuLmNjNjRmY2EgMTAwNjQ0Ci0tLSBhL2ZzL2VjcnlwdGZzL21tYXAuYworKysgYi9mcy9lY3J5cHRmcy9tbWFwLmMKQEAgLTY1LDcgKzY1LDcgQEAKIAlyYyA9IGVjcnlwdGZzX2VuY3J5cHRfcGFnZShwYWdlKTsKIAlpZiAocmMpIHsKIAkJZWNyeXB0ZnNfcHJpbnRrKEtFUk5fV0FSTklORywgIkVycm9yIGVuY3J5cHRpbmcgIgotCQkJCSJwYWdlICh1cHBlciBpbmRleCBbMHglLjE2eF0pXG4iLCBwYWdlLT5pbmRleCk7CisJCQkJInBhZ2UgKHVwcGVyIGluZGV4IFsweCUuMTZseF0pXG4iLCBwYWdlLT5pbmRleCk7CiAJCUNsZWFyUGFnZVVwdG9kYXRlKHBhZ2UpOwogCQlnb3RvIG91dDsKIAl9CkBAIC0yMzcsNyArMjM3LDcgQEAKIAkJQ2xlYXJQYWdlVXB0b2RhdGUocGFnZSk7CiAJZWxzZQogCQlTZXRQYWdlVXB0b2RhdGUocGFnZSk7Ci0JZWNyeXB0ZnNfcHJpbnRrKEtFUk5fREVCVUcsICJVbmxvY2tpbmcgcGFnZSB3aXRoIGluZGV4ID0gWzB4JS4xNnhdXG4iLAorCWVjcnlwdGZzX3ByaW50ayhLRVJOX0RFQlVHLCAiVW5sb2NraW5nIHBhZ2Ugd2l0aCBpbmRleCA9IFsweCUuMTZseF1cbiIsCiAJCQlwYWdlLT5pbmRleCk7CiAJdW5sb2NrX3BhZ2UocGFnZSk7CiAJcmV0dXJuIHJjOwpAQCAtMjkwLDYgKzI5MCw3IEBACiAJCXJldHVybiAtRU5PTUVNOwogCSpwYWdlcCA9IHBhZ2U7CiAKKwlwcmV2X3BhZ2VfZW5kX3NpemUgPSAoKGxvZmZfdClpbmRleCA8PCBQQUdFX0NBQ0hFX1NISUZUKTsKIAlpZiAoIVBhZ2VVcHRvZGF0ZShwYWdlKSkgewogCQlzdHJ1Y3QgZWNyeXB0ZnNfY3J5cHRfc3RhdCAqY3J5cHRfc3RhdCA9CiAJCQkmZWNyeXB0ZnNfaW5vZGVfdG9fcHJpdmF0ZShtYXBwaW5nLT5ob3N0KS0+Y3J5cHRfc3RhdDsKQEAgLTMzNSwxOCArMzM2LDIzIEBACiAJCQkJU2V0UGFnZVVwdG9kYXRlKHBhZ2UpOwogCQkJfQogCQl9IGVsc2UgewotCQkJcmMgPSBlY3J5cHRmc19kZWNyeXB0X3BhZ2UocGFnZSk7Ci0JCQlpZiAocmMpIHsKLQkJCQlwcmludGsoS0VSTl9FUlIgIiVzOiBFcnJvciBkZWNyeXB0aW5nIHBhZ2UgIgotCQkJCSAgICAgICAiYXQgaW5kZXggWyVsZF07IHJjID0gWyVkXVxuIiwKLQkJCQkgICAgICAgX19mdW5jX18sIHBhZ2UtPmluZGV4LCByYyk7Ci0JCQkJQ2xlYXJQYWdlVXB0b2RhdGUocGFnZSk7Ci0JCQkJZ290byBvdXQ7CisJCQlpZiAocHJldl9wYWdlX2VuZF9zaXplCisJCQkgICAgPj0gaV9zaXplX3JlYWQocGFnZS0+bWFwcGluZy0+aG9zdCkpIHsKKwkJCQl6ZXJvX3VzZXIocGFnZSwgMCwgUEFHRV9DQUNIRV9TSVpFKTsKKwkJCX0gZWxzZSB7CisJCQkJcmMgPSBlY3J5cHRmc19kZWNyeXB0X3BhZ2UocGFnZSk7CisJCQkJaWYgKHJjKSB7CisJCQkJCXByaW50ayhLRVJOX0VSUiAiJXM6IEVycm9yIGRlY3J5cHRpbmcgIgorCQkJCQkgICAgICAgInBhZ2UgYXQgaW5kZXggWyVsZF07ICIKKwkJCQkJICAgICAgICJyYyA9IFslZF1cbiIsCisJCQkJCSAgICAgICBfX2Z1bmNfXywgcGFnZS0+aW5kZXgsIHJjKTsKKwkJCQkJQ2xlYXJQYWdlVXB0b2RhdGUocGFnZSk7CisJCQkJCWdvdG8gb3V0OworCQkJCX0KIAkJCX0KIAkJCVNldFBhZ2VVcHRvZGF0ZShwYWdlKTsKIAkJfQogCX0KLQlwcmV2X3BhZ2VfZW5kX3NpemUgPSAoKGxvZmZfdClpbmRleCA8PCBQQUdFX0NBQ0hFX1NISUZUKTsKIAkvKiBJZiBjcmVhdGluZyBhIHBhZ2Ugb3IgbW9yZSBvZiBob2xlcywgemVybyB0aGVtIG91dCB2aWEgdHJ1bmNhdGUuCiAJICogTm90ZSwgdGhpcyB3aWxsIGluY3JlYXNlIGlfc2l6ZS4gKi8KIAlpZiAoaW5kZXggIT0gMCkgewpAQCAtNDg4LDcgKzQ5NCw3IEBACiAJfSBlbHNlCiAJCWVjcnlwdGZzX3ByaW50ayhLRVJOX0RFQlVHLCAiTm90IGEgbmV3IGZpbGVcbiIpOwogCWVjcnlwdGZzX3ByaW50ayhLRVJOX0RFQlVHLCAiQ2FsbGluZyBmaWxsX3plcm9zX3RvX2VuZF9vZl9wYWdlIgotCQkJIihwYWdlIHcvIGluZGV4ID0gWzB4JS4xNnhdLCB0byA9IFslZF0pXG4iLCBpbmRleCwgdG8pOworCQkJIihwYWdlIHcvIGluZGV4ID0gWzB4JS4xNmx4XSwgdG8gPSBbJWRdKVxuIiwgaW5kZXgsIHRvKTsKIAlpZiAoIShjcnlwdF9zdGF0LT5mbGFncyAmIEVDUllQVEZTX0VOQ1JZUFRFRCkpIHsKIAkJcmMgPSBlY3J5cHRmc193cml0ZV9sb3dlcl9wYWdlX3NlZ21lbnQoZWNyeXB0ZnNfaW5vZGUsIHBhZ2UsIDAsCiAJCQkJCQkgICAgICAgdG8pOwpAQCAtNTAzLDE5ICs1MDksMjAgQEAKIAlyYyA9IGZpbGxfemVyb3NfdG9fZW5kX29mX3BhZ2UocGFnZSwgdG8pOwogCWlmIChyYykgewogCQllY3J5cHRmc19wcmludGsoS0VSTl9XQVJOSU5HLCAiRXJyb3IgYXR0ZW1wdGluZyB0byBmaWxsICIKLQkJCSJ6ZXJvcyBpbiBwYWdlIHdpdGggaW5kZXggPSBbMHglLjE2eF1cbiIsIGluZGV4KTsKKwkJCSJ6ZXJvcyBpbiBwYWdlIHdpdGggaW5kZXggPSBbMHglLjE2bHhdXG4iLCBpbmRleCk7CiAJCWdvdG8gb3V0OwogCX0KIAlyYyA9IGVjcnlwdGZzX2VuY3J5cHRfcGFnZShwYWdlKTsKIAlpZiAocmMpIHsKIAkJZWNyeXB0ZnNfcHJpbnRrKEtFUk5fV0FSTklORywgIkVycm9yIGVuY3J5cHRpbmcgcGFnZSAodXBwZXIgIgotCQkJCSJpbmRleCBbMHglLjE2eF0pXG4iLCBpbmRleCk7CisJCQkJImluZGV4IFsweCUuMTZseF0pXG4iLCBpbmRleCk7CiAJCWdvdG8gb3V0OwogCX0KIAlpZiAocG9zICsgY29waWVkID4gaV9zaXplX3JlYWQoZWNyeXB0ZnNfaW5vZGUpKSB7CiAJCWlfc2l6ZV93cml0ZShlY3J5cHRmc19pbm9kZSwgcG9zICsgY29waWVkKTsKIAkJZWNyeXB0ZnNfcHJpbnRrKEtFUk5fREVCVUcsICJFeHBhbmRlZCBmaWxlIHNpemUgdG8gIgotCQkJCSJbMHglLjE2eF1cbiIsIGlfc2l6ZV9yZWFkKGVjcnlwdGZzX2lub2RlKSk7CisJCQkiWzB4JS4xNmxseF1cbiIsCisJCQkodW5zaWduZWQgbG9uZyBsb25nKWlfc2l6ZV9yZWFkKGVjcnlwdGZzX2lub2RlKSk7CiAJfQogCXJjID0gZWNyeXB0ZnNfd3JpdGVfaW5vZGVfc2l6ZV90b19tZXRhZGF0YShlY3J5cHRmc19pbm9kZSk7CiAJaWYgKHJjKQpkaWZmIC0tZ2l0IGEvZnMvZXZlbnRwb2xsLmMgYi9mcy9ldmVudHBvbGwuYwppbmRleCBjYzhhOWI3Li4yNjdkMGFkIDEwMDY0NAotLS0gYS9mcy9ldmVudHBvbGwuYworKysgYi9mcy9ldmVudHBvbGwuYwpAQCAtMTExNCw2ICsxMTE0LDE3IEBACiAJcmV0dXJuIGVwX3NjYW5fcmVhZHlfbGlzdChlcCwgZXBfc2VuZF9ldmVudHNfcHJvYywgJmVzZWQpOwogfQogCitzdGF0aWMgaW5saW5lIHN0cnVjdCB0aW1lc3BlYyBlcF9zZXRfbXN0aW1lb3V0KGxvbmcgbXMpCit7CisJc3RydWN0IHRpbWVzcGVjIG5vdywgdHMgPSB7CisJCS50dl9zZWMgPSBtcyAvIE1TRUNfUEVSX1NFQywKKwkJLnR2X25zZWMgPSBOU0VDX1BFUl9NU0VDICogKG1zICUgTVNFQ19QRVJfU0VDKSwKKwl9OworCisJa3RpbWVfZ2V0X3RzKCZub3cpOworCXJldHVybiB0aW1lc3BlY19hZGRfc2FmZShub3csIHRzKTsKK30KKwogc3RhdGljIGludCBlcF9wb2xsKHN0cnVjdCBldmVudHBvbGwgKmVwLCBzdHJ1Y3QgZXBvbGxfZXZlbnQgX191c2VyICpldmVudHMsCiAJCSAgIGludCBtYXhldmVudHMsIGxvbmcgdGltZW91dCkKIHsKQEAgLTExMjEsMTIgKzExMzIsMTEgQEAKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWxvbmcgc2xhY2s7CiAJd2FpdF9xdWV1ZV90IHdhaXQ7Ci0Jc3RydWN0IHRpbWVzcGVjIGVuZF90aW1lOwogCWt0aW1lX3QgZXhwaXJlcywgKnRvID0gTlVMTDsKIAogCWlmICh0aW1lb3V0ID4gMCkgewotCQlrdGltZV9nZXRfdHMoJmVuZF90aW1lKTsKLQkJdGltZXNwZWNfYWRkX25zKCZlbmRfdGltZSwgKHU2NCl0aW1lb3V0ICogTlNFQ19QRVJfTVNFQyk7CisJCXN0cnVjdCB0aW1lc3BlYyBlbmRfdGltZSA9IGVwX3NldF9tc3RpbWVvdXQodGltZW91dCk7CisKIAkJc2xhY2sgPSBzZWxlY3RfZXN0aW1hdGVfYWNjdXJhY3koJmVuZF90aW1lKTsKIAkJdG8gPSAmZXhwaXJlczsKIAkJKnRvID0gdGltZXNwZWNfdG9fa3RpbWUoZW5kX3RpbWUpOwpkaWZmIC0tZ2l0IGEvZnMvZXhlYy5jIGIvZnMvZXhlYy5jCmluZGV4IGM2MmVmY2IuLjUyYTQ0N2QgMTAwNjQ0Ci0tLSBhL2ZzL2V4ZWMuYworKysgYi9mcy9leGVjLmMKQEAgLTEyMCw3ICsxMjAsNyBAQAogCQlnb3RvIG91dDsKIAogCWZpbGUgPSBkb19maWxwX29wZW4oQVRfRkRDV0QsIHRtcCwKLQkJCQlPX0xBUkdFRklMRSB8IE9fUkRPTkxZIHwgRk1PREVfRVhFQywgMCwKKwkJCQlPX0xBUkdFRklMRSB8IE9fUkRPTkxZIHwgX19GTU9ERV9FWEVDLCAwLAogCQkJCU1BWV9SRUFEIHwgTUFZX0VYRUMgfCBNQVlfT1BFTik7CiAJcHV0bmFtZSh0bXApOwogCWVycm9yID0gUFRSX0VSUihmaWxlKTsKQEAgLTcyMyw3ICs3MjMsNyBAQAogCWludCBlcnI7CiAKIAlmaWxlID0gZG9fZmlscF9vcGVuKEFUX0ZEQ1dELCBuYW1lLAotCQkJCU9fTEFSR0VGSUxFIHwgT19SRE9OTFkgfCBGTU9ERV9FWEVDLCAwLAorCQkJCU9fTEFSR0VGSUxFIHwgT19SRE9OTFkgfCBfX0ZNT0RFX0VYRUMsIDAsCiAJCQkJTUFZX0VYRUMgfCBNQVlfT1BFTik7CiAJaWYgKElTX0VSUihmaWxlKSkKIAkJZ290byBvdXQ7CmRpZmYgLS1naXQgYS9mcy9leG9mcy9pbm9kZS5jIGIvZnMvZXhvZnMvaW5vZGUuYwppbmRleCA0MjY4NTQyLi5hNzU1NTIzIDEwMDY0NAotLS0gYS9mcy9leG9mcy9pbm9kZS5jCisrKyBiL2ZzL2V4b2ZzL2lub2RlLmMKQEAgLTEwMzAsNyArMTAzMCw2IEBACiAJCW1lbWNweShvaS0+aV9kYXRhLCBmY2IuaV9kYXRhLCBzaXplb2YoZmNiLmlfZGF0YSkpOwogCX0KIAotCWlub2RlLT5pX21hcHBpbmctPmJhY2tpbmdfZGV2X2luZm8gPSBzYi0+c19iZGk7CiAJaWYgKFNfSVNSRUcoaW5vZGUtPmlfbW9kZSkpIHsKIAkJaW5vZGUtPmlfb3AgPSAmZXhvZnNfZmlsZV9pbm9kZV9vcGVyYXRpb25zOwogCQlpbm9kZS0+aV9mb3AgPSAmZXhvZnNfZmlsZV9vcGVyYXRpb25zOwpAQCAtMTEzMSw3ICsxMTMwLDYgQEAKIAogCXNiaSA9IHNiLT5zX2ZzX2luZm87CiAKLQlpbm9kZS0+aV9tYXBwaW5nLT5iYWNraW5nX2Rldl9pbmZvID0gc2ItPnNfYmRpOwogCXNiLT5zX2RpcnQgPSAxOwogCWlub2RlX2luaXRfb3duZXIoaW5vZGUsIGRpciwgbW9kZSk7CiAJaW5vZGUtPmlfaW5vID0gc2JpLT5zX25leHRpZCsrOwpkaWZmIC0tZ2l0IGEvZnMvZXh0My9zdXBlci5jIGIvZnMvZXh0My9zdXBlci5jCmluZGV4IDdhYTc2N2QuLjg1YzhjYzggMTAwNjQ0Ci0tLSBhL2ZzL2V4dDMvc3VwZXIuYworKysgYi9mcy9leHQzL3N1cGVyLmMKQEAgLTc1NCw3ICs3NTQsNyBAQAogc3RhdGljIGludCBleHQzX21hcmtfZHF1b3RfZGlydHkoc3RydWN0IGRxdW90ICpkcXVvdCk7CiBzdGF0aWMgaW50IGV4dDNfd3JpdGVfaW5mbyhzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBpbnQgdHlwZSk7CiBzdGF0aWMgaW50IGV4dDNfcXVvdGFfb24oc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHR5cGUsIGludCBmb3JtYXRfaWQsCi0JCQkJY2hhciAqcGF0aCk7CisJCQkgc3RydWN0IHBhdGggKnBhdGgpOwogc3RhdGljIGludCBleHQzX3F1b3RhX29uX21vdW50KHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIGludCB0eXBlKTsKIHN0YXRpYyBzc2l6ZV90IGV4dDNfcXVvdGFfcmVhZChzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBpbnQgdHlwZSwgY2hhciAqZGF0YSwKIAkJCSAgICAgICBzaXplX3QgbGVuLCBsb2ZmX3Qgb2ZmKTsKQEAgLTI4NzcsMjcgKzI4NzcsMjAgQEAKICAqIFN0YW5kYXJkIGZ1bmN0aW9uIHRvIGJlIGNhbGxlZCBvbiBxdW90YV9vbgogICovCiBzdGF0aWMgaW50IGV4dDNfcXVvdGFfb24oc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHR5cGUsIGludCBmb3JtYXRfaWQsCi0JCQkgY2hhciAqbmFtZSkKKwkJCSBzdHJ1Y3QgcGF0aCAqcGF0aCkKIHsKIAlpbnQgZXJyOwotCXN0cnVjdCBwYXRoIHBhdGg7CiAKIAlpZiAoIXRlc3Rfb3B0KHNiLCBRVU9UQSkpCiAJCXJldHVybiAtRUlOVkFMOwogCi0JZXJyID0ga2Vybl9wYXRoKG5hbWUsIExPT0tVUF9GT0xMT1csICZwYXRoKTsKLQlpZiAoZXJyKQotCQlyZXR1cm4gZXJyOwotCiAJLyogUXVvdGFmaWxlIG5vdCBvbiB0aGUgc2FtZSBmaWxlc3lzdGVtPyAqLwotCWlmIChwYXRoLm1udC0+bW50X3NiICE9IHNiKSB7Ci0JCXBhdGhfcHV0KCZwYXRoKTsKKwlpZiAocGF0aC0+bW50LT5tbnRfc2IgIT0gc2IpCiAJCXJldHVybiAtRVhERVY7Ci0JfQogCS8qIEpvdXJuYWxpbmcgcXVvdGE/ICovCiAJaWYgKEVYVDNfU0Ioc2IpLT5zX3FmX25hbWVzW3R5cGVdKSB7CiAJCS8qIFF1b3RhZmlsZSBub3Qgb2YgZnMgcm9vdD8gKi8KLQkJaWYgKHBhdGguZGVudHJ5LT5kX3BhcmVudCAhPSBzYi0+c19yb290KQorCQlpZiAocGF0aC0+ZGVudHJ5LT5kX3BhcmVudCAhPSBzYi0+c19yb290KQogCQkJZXh0M19tc2coc2IsIEtFUk5fV0FSTklORywKIAkJCQkid2FybmluZzogUXVvdGEgZmlsZSBub3Qgb24gZmlsZXN5c3RlbSByb290LiAiCiAJCQkJIkpvdXJuYWxlZCBxdW90YSB3aWxsIG5vdCB3b3JrLiIpOwpAQCAtMjkwNyw3ICsyOTAwLDcgQEAKIAkgKiBXaGVuIHdlIGpvdXJuYWwgZGF0YSBvbiBxdW90YSBmaWxlLCB3ZSBoYXZlIHRvIGZsdXNoIGpvdXJuYWwgdG8gc2VlCiAJICogYWxsIHVwZGF0ZXMgdG8gdGhlIGZpbGUgd2hlbiB3ZSBieXBhc3MgcGFnZWNhY2hlLi4uCiAJICovCi0JaWYgKGV4dDNfc2hvdWxkX2pvdXJuYWxfZGF0YShwYXRoLmRlbnRyeS0+ZF9pbm9kZSkpIHsKKwlpZiAoZXh0M19zaG91bGRfam91cm5hbF9kYXRhKHBhdGgtPmRlbnRyeS0+ZF9pbm9kZSkpIHsKIAkJLyoKIAkJICogV2UgZG9uJ3QgbmVlZCB0byBsb2NrIHVwZGF0ZXMgYnV0IGpvdXJuYWxfZmx1c2goKSBjb3VsZAogCQkgKiBvdGhlcndpc2UgYmUgbGl2ZWxvY2tlZC4uLgpAQCAtMjkxNSwxNSArMjkwOCwxMSBAQAogCQlqb3VybmFsX2xvY2tfdXBkYXRlcyhFWFQzX1NCKHNiKS0+c19qb3VybmFsKTsKIAkJZXJyID0gam91cm5hbF9mbHVzaChFWFQzX1NCKHNiKS0+c19qb3VybmFsKTsKIAkJam91cm5hbF91bmxvY2tfdXBkYXRlcyhFWFQzX1NCKHNiKS0+c19qb3VybmFsKTsKLQkJaWYgKGVycikgewotCQkJcGF0aF9wdXQoJnBhdGgpOworCQlpZiAoZXJyKQogCQkJcmV0dXJuIGVycjsKLQkJfQogCX0KIAotCWVyciA9IGRxdW90X3F1b3RhX29uX3BhdGgoc2IsIHR5cGUsIGZvcm1hdF9pZCwgJnBhdGgpOwotCXBhdGhfcHV0KCZwYXRoKTsKLQlyZXR1cm4gZXJyOworCXJldHVybiBkcXVvdF9xdW90YV9vbihzYiwgdHlwZSwgZm9ybWF0X2lkLCBwYXRoKTsKIH0KIAogLyogUmVhZCBkYXRhIGZyb20gcXVvdGFmaWxlIC0gYXZvaWQgcGFnZWNhY2hlIGFuZCBzdWNoIGJlY2F1c2Ugd2UgY2Fubm90IGFmZm9yZApkaWZmIC0tZ2l0IGEvZnMvZXh0NC9leHQ0LmggYi9mcy9leHQ0L2V4dDQuaAppbmRleCAxZGU2NWY1Li4zYWEwYjcyIDEwMDY0NAotLS0gYS9mcy9leHQ0L2V4dDQuaAorKysgYi9mcy9leHQ0L2V4dDQuaApAQCAtODQ4LDYgKzg0OCw3IEBACiAJYXRvbWljX3QgaV9pb2VuZF9jb3VudDsJLyogTnVtYmVyIG9mIG91dHN0YW5kaW5nIGlvX2VuZCBzdHJ1Y3RzICovCiAJLyogY3VycmVudCBpb19lbmQgc3RydWN0dXJlIGZvciBhc3luYyBESU8gd3JpdGUqLwogCWV4dDRfaW9fZW5kX3QgKmN1cl9haW9fZGlvOworCWF0b21pY190IGlfYWlvZGlvX3Vud3JpdHRlbjsgLyogTnIuIG9mIGluZmxpZ2h0IGNvbnZlcnNpb25zIHBlbmRpbmcgKi8KIAogCXNwaW5sb2NrX3QgaV9ibG9ja19yZXNlcnZhdGlvbl9sb2NrOwogCkBAIC0yMDY1LDcgKzIwNjYsNyBAQAogZXh0ZXJuIHZvaWQgZXh0NF9leHRfdHJ1bmNhdGUoc3RydWN0IGlub2RlICopOwogZXh0ZXJuIHZvaWQgZXh0NF9leHRfaW5pdChzdHJ1Y3Qgc3VwZXJfYmxvY2sgKik7CiBleHRlcm4gdm9pZCBleHQ0X2V4dF9yZWxlYXNlKHN0cnVjdCBzdXBlcl9ibG9jayAqKTsKLWV4dGVybiBsb25nIGV4dDRfZmFsbG9jYXRlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIGludCBtb2RlLCBsb2ZmX3Qgb2Zmc2V0LAorZXh0ZXJuIGxvbmcgZXh0NF9mYWxsb2NhdGUoc3RydWN0IGZpbGUgKmZpbGUsIGludCBtb2RlLCBsb2ZmX3Qgb2Zmc2V0LAogCQkJICBsb2ZmX3QgbGVuKTsKIGV4dGVybiBpbnQgZXh0NF9jb252ZXJ0X3Vud3JpdHRlbl9leHRlbnRzKHN0cnVjdCBpbm9kZSAqaW5vZGUsIGxvZmZfdCBvZmZzZXQsCiAJCQkgIHNzaXplX3QgbGVuKTsKQEAgLTIxMTksNiArMjEyMCwxNSBAQAogCiAjZGVmaW5lIGluX3JhbmdlKGIsIGZpcnN0LCBsZW4pCSgoYikgPj0gKGZpcnN0KSAmJiAoYikgPD0gKGZpcnN0KSArIChsZW4pIC0gMSkKIAorLyogRm9yIGlvZW5kICYgYWlvIHVud3JpdHRlbiBjb252ZXJzaW9uIHdhaXQgcXVldWVzICovCisjZGVmaW5lIEVYVDRfV1FfSEFTSF9TWgkJMzcKKyNkZWZpbmUgZXh0NF9pb2VuZF93cSh2KSAgICgmZXh0NF9faW9lbmRfd3FbKCh1bnNpZ25lZCBsb25nKSh2KSkgJVwKKwkJCQkJICAgIEVYVDRfV1FfSEFTSF9TWl0pCisjZGVmaW5lIGV4dDRfYWlvX211dGV4KHYpICAoJmV4dDRfX2Fpb19tdXRleFsoKHVuc2lnbmVkIGxvbmcpKHYpKSAlXAorCQkJCQkgICAgIEVYVDRfV1FfSEFTSF9TWl0pCitleHRlcm4gd2FpdF9xdWV1ZV9oZWFkX3QgZXh0NF9faW9lbmRfd3FbRVhUNF9XUV9IQVNIX1NaXTsKK2V4dGVybiBzdHJ1Y3QgbXV0ZXggZXh0NF9fYWlvX211dGV4W0VYVDRfV1FfSEFTSF9TWl07CisKICNlbmRpZgkvKiBfX0tFUk5FTF9fICovCiAKICNlbmRpZgkvKiBfRVhUNF9IICovCmRpZmYgLS1naXQgYS9mcy9leHQ0L2V4dGVudHMuYyBiL2ZzL2V4dDQvZXh0ZW50cy5jCmluZGV4IDZiOTBiNjguLjY4NjI0MGUgMTAwNjQ0Ci0tLSBhL2ZzL2V4dDQvZXh0ZW50cy5jCisrKyBiL2ZzL2V4dDQvZXh0ZW50cy5jCkBAIC0zMTc0LDkgKzMxNzQsMTAgQEAKIAkJICogdGhhdCB0aGlzIElPIG5lZWRzIHRvIGNvbnZlcnRpb24gdG8gd3JpdHRlbiB3aGVuIElPIGlzCiAJCSAqIGNvbXBsZXRlZAogCQkgKi8KLQkJaWYgKGlvKQorCQlpZiAoaW8gJiYgIShpby0+ZmxhZyAmIEVYVDRfSU9fRU5EX1VOV1JJVFRFTikpIHsKIAkJCWlvLT5mbGFnID0gRVhUNF9JT19FTkRfVU5XUklUVEVOOwotCQllbHNlCisJCQlhdG9taWNfaW5jKCZFWFQ0X0koaW5vZGUpLT5pX2Fpb2Rpb191bndyaXR0ZW4pOworCQl9IGVsc2UKIAkJCWV4dDRfc2V0X2lub2RlX3N0YXRlKGlub2RlLCBFWFQ0X1NUQVRFX0RJT19VTldSSVRURU4pOwogCQlpZiAoZXh0NF9zaG91bGRfZGlvcmVhZF9ub2xvY2soaW5vZGUpKQogCQkJbWFwLT5tX2ZsYWdzIHw9IEVYVDRfTUFQX1VOSU5JVDsKQEAgLTM0NjMsOSArMzQ2NCwxMCBAQAogCQkgKiB0aGF0IHdlIG5lZWQgdG8gcGVyZm9ybSBjb252ZXJ0aW9uIHdoZW4gSU8gaXMgZG9uZS4KIAkJICovCiAJCWlmICgoZmxhZ3MgJiBFWFQ0X0dFVF9CTE9DS1NfUFJFX0lPKSkgewotCQkJaWYgKGlvKQorCQkJaWYgKGlvICYmICEoaW8tPmZsYWcgJiBFWFQ0X0lPX0VORF9VTldSSVRURU4pKSB7CiAJCQkJaW8tPmZsYWcgPSBFWFQ0X0lPX0VORF9VTldSSVRURU47Ci0JCQllbHNlCisJCQkJYXRvbWljX2luYygmRVhUNF9JKGlub2RlKS0+aV9haW9kaW9fdW53cml0dGVuKTsKKwkJCX0gZWxzZQogCQkJCWV4dDRfc2V0X2lub2RlX3N0YXRlKGlub2RlLAogCQkJCQkJICAgICBFWFQ0X1NUQVRFX0RJT19VTldSSVRURU4pOwogCQl9CkBAIC0zNjI3LDE0ICszNjI5LDE1IEBACiB9CiAKIC8qCi0gKiBwcmVhbGxvY2F0ZSBzcGFjZSBmb3IgYSBmaWxlLiBUaGlzIGltcGxlbWVudHMgZXh0NCdzIGZhbGxvY2F0ZSBpbm9kZQorICogcHJlYWxsb2NhdGUgc3BhY2UgZm9yIGEgZmlsZS4gVGhpcyBpbXBsZW1lbnRzIGV4dDQncyBmYWxsb2NhdGUgZmlsZQogICogb3BlcmF0aW9uLCB3aGljaCBnZXRzIGNhbGxlZCBmcm9tIHN5c19mYWxsb2NhdGUgc3lzdGVtIGNhbGwuCiAgKiBGb3IgYmxvY2stbWFwcGVkIGZpbGVzLCBwb3NpeF9mYWxsb2NhdGUgc2hvdWxkIGZhbGwgYmFjayB0byB0aGUgbWV0aG9kCiAgKiBvZiB3cml0aW5nIHplcm9lcyB0byB0aGUgcmVxdWlyZWQgbmV3IGJsb2NrcyAodGhlIHNhbWUgYmVoYXZpb3Igd2hpY2ggaXMKICAqIGV4cGVjdGVkIGZvciBmaWxlIHN5c3RlbXMgd2hpY2ggZG8gbm90IHN1cHBvcnQgZmFsbG9jYXRlKCkgc3lzdGVtIGNhbGwpLgogICovCi1sb25nIGV4dDRfZmFsbG9jYXRlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIGludCBtb2RlLCBsb2ZmX3Qgb2Zmc2V0LCBsb2ZmX3QgbGVuKQorbG9uZyBleHQ0X2ZhbGxvY2F0ZShzdHJ1Y3QgZmlsZSAqZmlsZSwgaW50IG1vZGUsIGxvZmZfdCBvZmZzZXQsIGxvZmZfdCBsZW4pCiB7CisJc3RydWN0IGlub2RlICppbm9kZSA9IGZpbGUtPmZfcGF0aC5kZW50cnktPmRfaW5vZGU7CiAJaGFuZGxlX3QgKmhhbmRsZTsKIAlsb2ZmX3QgbmV3X3NpemU7CiAJdW5zaWduZWQgaW50IG1heF9ibG9ja3M7CkBAIC0zNjQ1LDcgKzM2NDgsNyBAQAogCXVuc2lnbmVkIGludCBjcmVkaXRzLCBibGtiaXRzID0gaW5vZGUtPmlfYmxrYml0czsKIAogCS8qIFdlIG9ubHkgc3VwcG9ydCB0aGUgRkFMTE9DX0ZMX0tFRVBfU0laRSBtb2RlICovCi0JaWYgKG1vZGUgJiYgKG1vZGUgIT0gRkFMTE9DX0ZMX0tFRVBfU0laRSkpCisJaWYgKG1vZGUgJiB+RkFMTE9DX0ZMX0tFRVBfU0laRSkKIAkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCiAJLyoKQEAgLTM2NTUsMTAgKzM2NTgsNiBAQAogCWlmICghKGV4dDRfdGVzdF9pbm9kZV9mbGFnKGlub2RlLCBFWFQ0X0lOT0RFX0VYVEVOVFMpKSkKIAkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCi0JLyogcHJlYWxsb2NhdGlvbiB0byBkaXJlY3RvcmllcyBpcyBjdXJyZW50bHkgbm90IHN1cHBvcnRlZCAqLwotCWlmIChTX0lTRElSKGlub2RlLT5pX21vZGUpKQotCQlyZXR1cm4gLUVOT0RFVjsKLQogCW1hcC5tX2xibGsgPSBvZmZzZXQgPj4gYmxrYml0czsKIAkvKgogCSAqIFdlIGNhbid0IGp1c3QgY29udmVydCBsZW4gdG8gbWF4X2Jsb2NrcyBiZWNhdXNlCmRpZmYgLS1naXQgYS9mcy9leHQ0L2ZpbGUuYyBiL2ZzL2V4dDQvZmlsZS5jCmluZGV4IGJiMDAzZGMuLjdiODBkNTQgMTAwNjQ0Ci0tLSBhL2ZzL2V4dDQvZmlsZS5jCisrKyBiL2ZzL2V4dDQvZmlsZS5jCkBAIC01NSwxMSArNTUsNDcgQEAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIHZvaWQgZXh0NF9haW9kaW9fd2FpdChzdHJ1Y3QgaW5vZGUgKmlub2RlKQoreworCXdhaXRfcXVldWVfaGVhZF90ICp3cSA9IGV4dDRfaW9lbmRfd3EoaW5vZGUpOworCisJd2FpdF9ldmVudCgqd3EsIChhdG9taWNfcmVhZCgmRVhUNF9JKGlub2RlKS0+aV9haW9kaW9fdW53cml0dGVuKSA9PSAwKSk7Cit9CisKKy8qCisgKiBUaGlzIHRlc3RzIHdoZXRoZXIgdGhlIElPIGluIHF1ZXN0aW9uIGlzIGJsb2NrLWFsaWduZWQgb3Igbm90LgorICogRXh0NCB1dGlsaXplcyB1bndyaXR0ZW4gZXh0ZW50cyB3aGVuIGhvbGUtZmlsbGluZyBkdXJpbmcgZGlyZWN0IElPLCBhbmQgdGhleQorICogYXJlIGNvbnZlcnRlZCB0byB3cml0dGVuIG9ubHkgYWZ0ZXIgdGhlIElPIGlzIGNvbXBsZXRlLiAgVW50aWwgdGhleSBhcmUKKyAqIG1hcHBlZCwgdGhlc2UgYmxvY2tzIGFwcGVhciBhcyBob2xlcywgc28gZGlvX3plcm9fYmxvY2soKSB3aWxsIGFzc3VtZSB0aGF0CisgKiBpdCBuZWVkcyB0byB6ZXJvIG91dCBwb3J0aW9ucyBvZiB0aGUgc3RhcnQgYW5kL29yIGVuZCBibG9jay4gIElmIDIgQUlPCisgKiB0aHJlYWRzIGFyZSBhdCB3b3JrIG9uIHRoZSBzYW1lIHVud3JpdHRlbiBibG9jaywgdGhleSBtdXN0IGJlIHN5bmNocm9uaXplZAorICogb3Igb25lIHRocmVhZCB3aWxsIHplcm8gdGhlIG90aGVyJ3MgZGF0YSwgY2F1c2luZyBjb3JydXB0aW9uLgorICovCitzdGF0aWMgaW50CitleHQ0X3VuYWxpZ25lZF9haW8oc3RydWN0IGlub2RlICppbm9kZSwgY29uc3Qgc3RydWN0IGlvdmVjICppb3YsCisJCSAgIHVuc2lnbmVkIGxvbmcgbnJfc2VncywgbG9mZl90IHBvcykKK3sKKwlzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiID0gaW5vZGUtPmlfc2I7CisJaW50IGJsb2NrbWFzayA9IHNiLT5zX2Jsb2Nrc2l6ZSAtIDE7CisJc2l6ZV90IGNvdW50ID0gaW92X2xlbmd0aChpb3YsIG5yX3NlZ3MpOworCWxvZmZfdCBmaW5hbF9zaXplID0gcG9zICsgY291bnQ7CisKKwlpZiAocG9zID49IGlub2RlLT5pX3NpemUpCisJCXJldHVybiAwOworCisJaWYgKChwb3MgJiBibG9ja21hc2spIHx8IChmaW5hbF9zaXplICYgYmxvY2ttYXNrKSkKKwkJcmV0dXJuIDE7CisKKwlyZXR1cm4gMDsKK30KKwogc3RhdGljIHNzaXplX3QKIGV4dDRfZmlsZV93cml0ZShzdHJ1Y3Qga2lvY2IgKmlvY2IsIGNvbnN0IHN0cnVjdCBpb3ZlYyAqaW92LAogCQl1bnNpZ25lZCBsb25nIG5yX3NlZ3MsIGxvZmZfdCBwb3MpCiB7CiAJc3RydWN0IGlub2RlICppbm9kZSA9IGlvY2ItPmtpX2ZpbHAtPmZfcGF0aC5kZW50cnktPmRfaW5vZGU7CisJaW50IHVuYWxpZ25lZF9haW8gPSAwOworCWludCByZXQ7CiAKIAkvKgogCSAqIElmIHdlIGhhdmUgZW5jb3VudGVyZWQgYSBiaXRtYXAtZm9ybWF0IGZpbGUsIHRoZSBzaXplIGxpbWl0CkBAIC03OCw5ICsxMTQsMzEgQEAKIAkJCW5yX3NlZ3MgPSBpb3Zfc2hvcnRlbigoc3RydWN0IGlvdmVjICopaW92LCBucl9zZWdzLAogCQkJCQkgICAgICBzYmktPnNfYml0bWFwX21heGJ5dGVzIC0gcG9zKTsKIAkJfQorCX0gZWxzZSBpZiAodW5saWtlbHkoKGlvY2ItPmtpX2ZpbHAtPmZfZmxhZ3MgJiBPX0RJUkVDVCkgJiYKKwkJICAgIWlzX3N5bmNfa2lvY2IoaW9jYikpKSB7CisJCXVuYWxpZ25lZF9haW8gPSBleHQ0X3VuYWxpZ25lZF9haW8oaW5vZGUsIGlvdiwgbnJfc2VncywgcG9zKTsKIAl9CiAKLQlyZXR1cm4gZ2VuZXJpY19maWxlX2Fpb193cml0ZShpb2NiLCBpb3YsIG5yX3NlZ3MsIHBvcyk7CisJLyogVW5hbGlnbmVkIGRpcmVjdCBBSU8gbXVzdCBiZSBzZXJpYWxpemVkOyBzZWUgY29tbWVudCBhYm92ZSAqLworCWlmICh1bmFsaWduZWRfYWlvKSB7CisJCXN0YXRpYyB1bnNpZ25lZCBsb25nIHVuYWxpZ25lZF93YXJuX3RpbWU7CisKKwkJLyogV2FybiBhYm91dCB0aGlzIG9uY2UgcGVyIGRheSAqLworCQlpZiAocHJpbnRrX3RpbWVkX3JhdGVsaW1pdCgmdW5hbGlnbmVkX3dhcm5fdGltZSwgNjAqNjAqMjQqSFopKQorCQkJZXh0NF9tc2coaW5vZGUtPmlfc2IsIEtFUk5fV0FSTklORywKKwkJCQkgIlVuYWxpZ25lZCBBSU8vRElPIG9uIGlub2RlICVsZCBieSAlczsgIgorCQkJCSAicGVyZm9ybWFuY2Ugd2lsbCBiZSBwb29yLiIsCisJCQkJIGlub2RlLT5pX2lubywgY3VycmVudC0+Y29tbSk7CisJCW11dGV4X2xvY2soZXh0NF9haW9fbXV0ZXgoaW5vZGUpKTsKKwkJZXh0NF9haW9kaW9fd2FpdChpbm9kZSk7CisJfQorCisJcmV0ID0gZ2VuZXJpY19maWxlX2Fpb193cml0ZShpb2NiLCBpb3YsIG5yX3NlZ3MsIHBvcyk7CisKKwlpZiAodW5hbGlnbmVkX2FpbykKKwkJbXV0ZXhfdW5sb2NrKGV4dDRfYWlvX211dGV4KGlub2RlKSk7CisKKwlyZXR1cm4gcmV0OwogfQogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHZtX29wZXJhdGlvbnNfc3RydWN0IGV4dDRfZmlsZV92bV9vcHMgPSB7CkBAIC0yMTAsNiArMjY4LDcgQEAKIAkuZnN5bmMJCT0gZXh0NF9zeW5jX2ZpbGUsCiAJLnNwbGljZV9yZWFkCT0gZ2VuZXJpY19maWxlX3NwbGljZV9yZWFkLAogCS5zcGxpY2Vfd3JpdGUJPSBnZW5lcmljX2ZpbGVfc3BsaWNlX3dyaXRlLAorCS5mYWxsb2NhdGUJPSBleHQ0X2ZhbGxvY2F0ZSwKIH07CiAKIGNvbnN0IHN0cnVjdCBpbm9kZV9vcGVyYXRpb25zIGV4dDRfZmlsZV9pbm9kZV9vcGVyYXRpb25zID0gewpAQCAtMjIzLDcgKzI4Miw2IEBACiAJLnJlbW92ZXhhdHRyCT0gZ2VuZXJpY19yZW1vdmV4YXR0ciwKICNlbmRpZgogCS5jaGVja19hY2wJPSBleHQ0X2NoZWNrX2FjbCwKLQkuZmFsbG9jYXRlCT0gZXh0NF9mYWxsb2NhdGUsCiAJLmZpZW1hcAkJPSBleHQ0X2ZpZW1hcCwKIH07CiAKZGlmZiAtLWdpdCBhL2ZzL2V4dDQvbWJhbGxvYy5jIGIvZnMvZXh0NC9tYmFsbG9jLmMKaW5kZXggODUxZjQ5Yi4uZDFmZTA5YSAxMDA2NDQKLS0tIGEvZnMvZXh0NC9tYmFsbG9jLmMKKysrIGIvZnMvZXh0NC9tYmFsbG9jLmMKQEAgLTM0MiwxMCArMzQyLDE1IEBACiAvKiBXZSBjcmVhdGUgc2xhYiBjYWNoZXMgZm9yIGdyb3VwaW5mbyBkYXRhIHN0cnVjdHVyZXMgYmFzZWQgb24gdGhlCiAgKiBzdXBlcmJsb2NrIGJsb2NrIHNpemUuICBUaGVyZSB3aWxsIGJlIG9uZSBwZXIgbW91bnRlZCBmaWxlc3lzdGVtIGZvcgogICogZWFjaCB1bmlxdWUgc19ibG9ja3NpemVfYml0cyAqLwotI2RlZmluZSBOUl9HUlBJTkZPX0NBQ0hFUwlcCi0JKEVYVDRfTUFYX0JMT0NLX0xPR19TSVpFIC0gRVhUNF9NSU5fQkxPQ0tfTE9HX1NJWkUgKyAxKQorI2RlZmluZSBOUl9HUlBJTkZPX0NBQ0hFUyA4CiBzdGF0aWMgc3RydWN0IGttZW1fY2FjaGUgKmV4dDRfZ3JvdXBpbmZvX2NhY2hlc1tOUl9HUlBJTkZPX0NBQ0hFU107CiAKK3N0YXRpYyBjb25zdCBjaGFyICpleHQ0X2dyb3VwaW5mb19zbGFiX25hbWVzW05SX0dSUElORk9fQ0FDSEVTXSA9IHsKKwkiZXh0NF9ncm91cGluZm9fMWsiLCAiZXh0NF9ncm91cGluZm9fMmsiLCAiZXh0NF9ncm91cGluZm9fNGsiLAorCSJleHQ0X2dyb3VwaW5mb184ayIsICJleHQ0X2dyb3VwaW5mb18xNmsiLCAiZXh0NF9ncm91cGluZm9fMzJrIiwKKwkiZXh0NF9ncm91cGluZm9fNjRrIiwgImV4dDRfZ3JvdXBpbmZvXzEyOGsiCit9OworCiBzdGF0aWMgdm9pZCBleHQ0X21iX2dlbmVyYXRlX2Zyb21fcGEoc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgdm9pZCAqYml0bWFwLAogCQkJCQlleHQ0X2dyb3VwX3QgZ3JvdXApOwogc3RhdGljIHZvaWQgZXh0NF9tYl9nZW5lcmF0ZV9mcm9tX2ZyZWVsaXN0KHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHZvaWQgKmJpdG1hcCwKQEAgLTI0MTQsNiArMjQxOSw1NSBAQAogCXJldHVybiAtRU5PTUVNOwogfQogCitzdGF0aWMgdm9pZCBleHQ0X2dyb3VwaW5mb19kZXN0cm95X3NsYWJzKHZvaWQpCit7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgTlJfR1JQSU5GT19DQUNIRVM7IGkrKykgeworCQlpZiAoZXh0NF9ncm91cGluZm9fY2FjaGVzW2ldKQorCQkJa21lbV9jYWNoZV9kZXN0cm95KGV4dDRfZ3JvdXBpbmZvX2NhY2hlc1tpXSk7CisJCWV4dDRfZ3JvdXBpbmZvX2NhY2hlc1tpXSA9IE5VTEw7CisJfQorfQorCitzdGF0aWMgaW50IGV4dDRfZ3JvdXBpbmZvX2NyZWF0ZV9zbGFiKHNpemVfdCBzaXplKQoreworCXN0YXRpYyBERUZJTkVfTVVURVgoZXh0NF9ncnBpbmZvX3NsYWJfY3JlYXRlX211dGV4KTsKKwlpbnQgc2xhYl9zaXplOworCWludCBibG9ja3NpemVfYml0cyA9IG9yZGVyX2Jhc2VfMihzaXplKTsKKwlpbnQgY2FjaGVfaW5kZXggPSBibG9ja3NpemVfYml0cyAtIEVYVDRfTUlOX0JMT0NLX0xPR19TSVpFOworCXN0cnVjdCBrbWVtX2NhY2hlICpjYWNoZXA7CisKKwlpZiAoY2FjaGVfaW5kZXggPj0gTlJfR1JQSU5GT19DQUNIRVMpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKHVubGlrZWx5KGNhY2hlX2luZGV4IDwgMCkpCisJCWNhY2hlX2luZGV4ID0gMDsKKworCW11dGV4X2xvY2soJmV4dDRfZ3JwaW5mb19zbGFiX2NyZWF0ZV9tdXRleCk7CisJaWYgKGV4dDRfZ3JvdXBpbmZvX2NhY2hlc1tjYWNoZV9pbmRleF0pIHsKKwkJbXV0ZXhfdW5sb2NrKCZleHQ0X2dycGluZm9fc2xhYl9jcmVhdGVfbXV0ZXgpOworCQlyZXR1cm4gMDsJLyogQWxyZWFkeSBjcmVhdGVkICovCisJfQorCisJc2xhYl9zaXplID0gb2Zmc2V0b2Yoc3RydWN0IGV4dDRfZ3JvdXBfaW5mbywKKwkJCQliYl9jb3VudGVyc1tibG9ja3NpemVfYml0cyArIDJdKTsKKworCWNhY2hlcCA9IGttZW1fY2FjaGVfY3JlYXRlKGV4dDRfZ3JvdXBpbmZvX3NsYWJfbmFtZXNbY2FjaGVfaW5kZXhdLAorCQkJCQlzbGFiX3NpemUsIDAsIFNMQUJfUkVDTEFJTV9BQ0NPVU5ULAorCQkJCQlOVUxMKTsKKworCW11dGV4X3VubG9jaygmZXh0NF9ncnBpbmZvX3NsYWJfY3JlYXRlX211dGV4KTsKKwlpZiAoIWNhY2hlcCkgeworCQlwcmludGsoS0VSTl9FTUVSRyAiRVhUNDogbm8gbWVtb3J5IGZvciBncm91cGluZm8gc2xhYiBjYWNoZVxuIik7CisJCXJldHVybiAtRU5PTUVNOworCX0KKworCWV4dDRfZ3JvdXBpbmZvX2NhY2hlc1tjYWNoZV9pbmRleF0gPSBjYWNoZXA7CisKKwlyZXR1cm4gMDsKK30KKwogaW50IGV4dDRfbWJfaW5pdChzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBpbnQgbmVlZHNfcmVjb3ZlcnkpCiB7CiAJc3RydWN0IGV4dDRfc2JfaW5mbyAqc2JpID0gRVhUNF9TQihzYik7CkBAIC0yNDIxLDkgKzI0NzUsNiBAQAogCXVuc2lnbmVkIG9mZnNldDsKIAl1bnNpZ25lZCBtYXg7CiAJaW50IHJldDsKLQlpbnQgY2FjaGVfaW5kZXg7Ci0Jc3RydWN0IGttZW1fY2FjaGUgKmNhY2hlcDsKLQljaGFyICpuYW1lcCA9IE5VTEw7CiAKIAlpID0gKHNiLT5zX2Jsb2Nrc2l6ZV9iaXRzICsgMikgKiBzaXplb2YoKnNiaS0+c19tYl9vZmZzZXRzKTsKIApAQCAtMjQ0MCwzMCArMjQ5MSw5IEBACiAJCWdvdG8gb3V0OwogCX0KIAotCWNhY2hlX2luZGV4ID0gc2ItPnNfYmxvY2tzaXplX2JpdHMgLSBFWFQ0X01JTl9CTE9DS19MT0dfU0laRTsKLQljYWNoZXAgPSBleHQ0X2dyb3VwaW5mb19jYWNoZXNbY2FjaGVfaW5kZXhdOwotCWlmICghY2FjaGVwKSB7Ci0JCWNoYXIgbmFtZVszMl07Ci0JCWludCBsZW4gPSBvZmZzZXRvZihzdHJ1Y3QgZXh0NF9ncm91cF9pbmZvLAotCQkJCQliYl9jb3VudGVyc1tzYi0+c19ibG9ja3NpemVfYml0cyArIDJdKTsKLQotCQlzcHJpbnRmKG5hbWUsICJleHQ0X2dyb3VwaW5mb18lZCIsIHNiLT5zX2Jsb2Nrc2l6ZV9iaXRzKTsKLQkJbmFtZXAgPSBrc3RyZHVwKG5hbWUsIEdGUF9LRVJORUwpOwotCQlpZiAoIW5hbWVwKSB7Ci0JCQlyZXQgPSAtRU5PTUVNOwotCQkJZ290byBvdXQ7Ci0JCX0KLQotCQkvKiBOZWVkIHRvIGZyZWUgdGhlIGttZW1fY2FjaGVfbmFtZSgpIHdoZW4gd2UKLQkJICogZGVzdHJveSB0aGUgc2xhYiAqLwotCQljYWNoZXAgPSBrbWVtX2NhY2hlX2NyZWF0ZShuYW1lcCwgbGVuLCAwLAotCQkJCQkgICAgIFNMQUJfUkVDTEFJTV9BQ0NPVU5ULCBOVUxMKTsKLQkJaWYgKCFjYWNoZXApIHsKLQkJCXJldCA9IC1FTk9NRU07Ci0JCQlnb3RvIG91dDsKLQkJfQotCQlleHQ0X2dyb3VwaW5mb19jYWNoZXNbY2FjaGVfaW5kZXhdID0gY2FjaGVwOwotCX0KKwlyZXQgPSBleHQ0X2dyb3VwaW5mb19jcmVhdGVfc2xhYihzYi0+c19ibG9ja3NpemUpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIG91dDsKIAogCS8qIG9yZGVyIDAgaXMgcmVndWxhciBiaXRtYXAgKi8KIAlzYmktPnNfbWJfbWF4c1swXSA9IHNiLT5zX2Jsb2Nrc2l6ZSA8PCAzOwpAQCAtMjUyMCw3ICsyNTUwLDYgQEAKIAlpZiAocmV0KSB7CiAJCWtmcmVlKHNiaS0+c19tYl9vZmZzZXRzKTsKIAkJa2ZyZWUoc2JpLT5zX21iX21heHMpOwotCQlrZnJlZShuYW1lcCk7CiAJfQogCXJldHVybiByZXQ7CiB9CkBAIC0yNzM0LDcgKzI3NjMsNiBAQAogCiB2b2lkIGV4dDRfZXhpdF9tYmFsbG9jKHZvaWQpCiB7Ci0JaW50IGk7CiAJLyoKIAkgKiBXYWl0IGZvciBjb21wbGV0aW9uIG9mIGNhbGxfcmN1KCkncyBvbiBleHQ0X3BzcGFjZV9jYWNoZXAKIAkgKiBiZWZvcmUgZGVzdHJveWluZyB0aGUgc2xhYiBjYWNoZS4KQEAgLTI3NDMsMTUgKzI3NzEsNyBAQAogCWttZW1fY2FjaGVfZGVzdHJveShleHQ0X3BzcGFjZV9jYWNoZXApOwogCWttZW1fY2FjaGVfZGVzdHJveShleHQ0X2FjX2NhY2hlcCk7CiAJa21lbV9jYWNoZV9kZXN0cm95KGV4dDRfZnJlZV9leHRfY2FjaGVwKTsKLQotCWZvciAoaSA9IDA7IGkgPCBOUl9HUlBJTkZPX0NBQ0hFUzsgaSsrKSB7Ci0JCXN0cnVjdCBrbWVtX2NhY2hlICpjYWNoZXAgPSBleHQ0X2dyb3VwaW5mb19jYWNoZXNbaV07Ci0JCWlmIChjYWNoZXApIHsKLQkJCWNoYXIgKm5hbWUgPSAoY2hhciAqKWttZW1fY2FjaGVfbmFtZShjYWNoZXApOwotCQkJa21lbV9jYWNoZV9kZXN0cm95KGNhY2hlcCk7Ci0JCQlrZnJlZShuYW1lKTsKLQkJfQotCX0KKwlleHQ0X2dyb3VwaW5mb19kZXN0cm95X3NsYWJzKCk7CiAJZXh0NF9yZW1vdmVfZGVidWdmc19lbnRyeSgpOwogfQogCmRpZmYgLS1naXQgYS9mcy9leHQ0L3BhZ2UtaW8uYyBiL2ZzL2V4dDQvcGFnZS1pby5jCmluZGV4IDcyNzBkY2YuLjk1NWNjMzAgMTAwNjQ0Ci0tLSBhL2ZzL2V4dDQvcGFnZS1pby5jCisrKyBiL2ZzL2V4dDQvcGFnZS1pby5jCkBAIC0zMiwxNCArMzIsOCBAQAogCiBzdGF0aWMgc3RydWN0IGttZW1fY2FjaGUgKmlvX3BhZ2VfY2FjaGVwLCAqaW9fZW5kX2NhY2hlcDsKIAotI2RlZmluZSBXUV9IQVNIX1NaCQkzNwotI2RlZmluZSB0b19pb2VuZF93cSh2KQkoJmlvZW5kX3dxWygodW5zaWduZWQgbG9uZyl2KSAlIFdRX0hBU0hfU1pdKQotc3RhdGljIHdhaXRfcXVldWVfaGVhZF90IGlvZW5kX3dxW1dRX0hBU0hfU1pdOwotCiBpbnQgX19pbml0IGV4dDRfaW5pdF9wYWdlaW8odm9pZCkKIHsKLQlpbnQgaTsKLQogCWlvX3BhZ2VfY2FjaGVwID0gS01FTV9DQUNIRShleHQ0X2lvX3BhZ2UsIFNMQUJfUkVDTEFJTV9BQ0NPVU5UKTsKIAlpZiAoaW9fcGFnZV9jYWNoZXAgPT0gTlVMTCkKIAkJcmV0dXJuIC1FTk9NRU07CkBAIC00OCw5ICs0Miw2IEBACiAJCWttZW1fY2FjaGVfZGVzdHJveShpb19wYWdlX2NhY2hlcCk7CiAJCXJldHVybiAtRU5PTUVNOwogCX0KLQlmb3IgKGkgPSAwOyBpIDwgV1FfSEFTSF9TWjsgaSsrKQotCQlpbml0X3dhaXRxdWV1ZV9oZWFkKCZpb2VuZF93cVtpXSk7Ci0KIAlyZXR1cm4gMDsKIH0KIApAQCAtNjIsNyArNTMsNyBAQAogCiB2b2lkIGV4dDRfaW9lbmRfd2FpdChzdHJ1Y3QgaW5vZGUgKmlub2RlKQogewotCXdhaXRfcXVldWVfaGVhZF90ICp3cSA9IHRvX2lvZW5kX3dxKGlub2RlKTsKKwl3YWl0X3F1ZXVlX2hlYWRfdCAqd3EgPSBleHQ0X2lvZW5kX3dxKGlub2RlKTsKIAogCXdhaXRfZXZlbnQoKndxLCAoYXRvbWljX3JlYWQoJkVYVDRfSShpbm9kZSktPmlfaW9lbmRfY291bnQpID09IDApKTsKIH0KQEAgLTg3LDcgKzc4LDcgQEAKIAlmb3IgKGkgPSAwOyBpIDwgaW8tPm51bV9pb19wYWdlczsgaSsrKQogCQlwdXRfaW9fcGFnZShpby0+cGFnZXNbaV0pOwogCWlvLT5udW1faW9fcGFnZXMgPSAwOwotCXdxID0gdG9faW9lbmRfd3EoaW8tPmlub2RlKTsKKwl3cSA9IGV4dDRfaW9lbmRfd3EoaW8tPmlub2RlKTsKIAlpZiAoYXRvbWljX2RlY19hbmRfdGVzdCgmRVhUNF9JKGlvLT5pbm9kZSktPmlfaW9lbmRfY291bnQpICYmCiAJICAgIHdhaXRxdWV1ZV9hY3RpdmUod3EpKQogCQl3YWtlX3VwX2FsbCh3cSk7CkBAIC0xMDIsNiArOTMsNyBAQAogCXN0cnVjdCBpbm9kZSAqaW5vZGUgPSBpby0+aW5vZGU7CiAJbG9mZl90IG9mZnNldCA9IGlvLT5vZmZzZXQ7CiAJc3NpemVfdCBzaXplID0gaW8tPnNpemU7CisJd2FpdF9xdWV1ZV9oZWFkX3QgKndxOwogCWludCByZXQgPSAwOwogCiAJZXh0NF9kZWJ1ZygiZXh0NF9lbmRfaW9fbm9sb2NrOiBpbyAweCVwIGZyb20gaW5vZGUgJWx1LGxpc3QtPm5leHQgMHglcCwiCkBAIC0xMjYsNyArMTE4LDE2IEBACiAJaWYgKGlvLT5pb2NiKQogCQlhaW9fY29tcGxldGUoaW8tPmlvY2IsIGlvLT5yZXN1bHQsIDApOwogCS8qIGNsZWFyIHRoZSBESU8gQUlPIHVud3JpdHRlbiBmbGFnICovCi0JaW8tPmZsYWcgJj0gfkVYVDRfSU9fRU5EX1VOV1JJVFRFTjsKKwlpZiAoaW8tPmZsYWcgJiBFWFQ0X0lPX0VORF9VTldSSVRURU4pIHsKKwkJaW8tPmZsYWcgJj0gfkVYVDRfSU9fRU5EX1VOV1JJVFRFTjsKKwkJLyogV2FrZSB1cCBhbnlvbmUgd2FpdGluZyBvbiB1bndyaXR0ZW4gZXh0ZW50IGNvbnZlcnNpb24gKi8KKwkJd3EgPSBleHQ0X2lvZW5kX3dxKGlvLT5pbm9kZSk7CisJCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZFWFQ0X0koaW5vZGUpLT5pX2Fpb2Rpb191bndyaXR0ZW4pICYmCisJCSAgICB3YWl0cXVldWVfYWN0aXZlKHdxKSkgeworCQkJd2FrZV91cF9hbGwod3EpOworCQl9CisJfQorCiAJcmV0dXJuIHJldDsKIH0KIApAQCAtMTkwLDYgKzE5MSw3IEBACiAJc3RydWN0IGlub2RlICppbm9kZTsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCBpOworCXNlY3Rvcl90IGJpX3NlY3RvciA9IGJpby0+Ymlfc2VjdG9yOwogCiAJQlVHX09OKCFpb19lbmQpOwogCWJpby0+YmlfcHJpdmF0ZSA9IE5VTEw7CkBAIC0yMDcsOSArMjA5LDcgQEAKIAkJaWYgKGVycm9yKQogCQkJU2V0UGFnZUVycm9yKHBhZ2UpOwogCQlCVUdfT04oIWhlYWQpOwotCQlpZiAoaGVhZC0+Yl9zaXplID09IFBBR0VfQ0FDSEVfU0laRSkKLQkJCWNsZWFyX2J1ZmZlcl9kaXJ0eShoZWFkKTsKLQkJZWxzZSB7CisJCWlmIChoZWFkLT5iX3NpemUgIT0gUEFHRV9DQUNIRV9TSVpFKSB7CiAJCQlsb2ZmX3Qgb2Zmc2V0OwogCQkJbG9mZl90IGlvX2VuZF9vZmZzZXQgPSBpb19lbmQtPm9mZnNldCArIGlvX2VuZC0+c2l6ZTsKIApAQCAtMjIxLDcgKzIyMSw2IEBACiAJCQkJCWlmIChlcnJvcikKIAkJCQkJCWJ1ZmZlcl9pb19lcnJvcihiaCk7CiAKLQkJCQkJY2xlYXJfYnVmZmVyX2RpcnR5KGJoKTsKIAkJCQl9CiAJCQkJaWYgKGJ1ZmZlcl9kZWxheShiaCkpCiAJCQkJCXBhcnRpYWxfd3JpdGUgPSAxOwpAQCAtMjU3LDcgKzI1Niw3IEBACiAJCQkgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpIGlvX2VuZC0+b2Zmc2V0LAogCQkJICAgICAobG9uZykgaW9fZW5kLT5zaXplLAogCQkJICAgICAodW5zaWduZWQgbG9uZyBsb25nKQotCQkJICAgICBiaW8tPmJpX3NlY3RvciA+PiAoaW5vZGUtPmlfYmxrYml0cyAtIDkpKTsKKwkJCSAgICAgYmlfc2VjdG9yID4+IChpbm9kZS0+aV9ibGtiaXRzIC0gOSkpOwogCX0KIAogCS8qIEFkZCB0aGUgaW9fZW5kIHRvIHBlci1pbm9kZSBjb21wbGV0ZWQgaW8gbGlzdCovCkBAIC0zODAsNiArMzc5LDcgQEAKIAogCWJsb2Nrc2l6ZSA9IDEgPDwgaW5vZGUtPmlfYmxrYml0czsKIAorCUJVR19PTighUGFnZUxvY2tlZChwYWdlKSk7CiAJQlVHX09OKFBhZ2VXcml0ZWJhY2socGFnZSkpOwogCXNldF9wYWdlX3dyaXRlYmFjayhwYWdlKTsKIAlDbGVhclBhZ2VFcnJvcihwYWdlKTsKQEAgLTM5NywxMiArMzk3LDE0IEBACiAJZm9yIChiaCA9IGhlYWQgPSBwYWdlX2J1ZmZlcnMocGFnZSksIGJsb2NrX3N0YXJ0ID0gMDsKIAkgICAgIGJoICE9IGhlYWQgfHwgIWJsb2NrX3N0YXJ0OwogCSAgICAgYmxvY2tfc3RhcnQgPSBibG9ja19lbmQsIGJoID0gYmgtPmJfdGhpc19wYWdlKSB7CisKIAkJYmxvY2tfZW5kID0gYmxvY2tfc3RhcnQgKyBibG9ja3NpemU7CiAJCWlmIChibG9ja19zdGFydCA+PSBsZW4pIHsKIAkJCWNsZWFyX2J1ZmZlcl9kaXJ0eShiaCk7CiAJCQlzZXRfYnVmZmVyX3VwdG9kYXRlKGJoKTsKIAkJCWNvbnRpbnVlOwogCQl9CisJCWNsZWFyX2J1ZmZlcl9kaXJ0eShiaCk7CiAJCXJldCA9IGlvX3N1Ym1pdF9hZGRfYmgoaW8sIGlvX3BhZ2UsIGlub2RlLCB3YmMsIGJoKTsKIAkJaWYgKHJldCkgewogCQkJLyoKZGlmZiAtLWdpdCBhL2ZzL2V4dDQvc3VwZXIuYyBiL2ZzL2V4dDQvc3VwZXIuYwppbmRleCBjYjEwYTA2Li5mNmEzMThmIDEwMDY0NAotLS0gYS9mcy9leHQ0L3N1cGVyLmMKKysrIGIvZnMvZXh0NC9zdXBlci5jCkBAIC03Nyw2ICs3Nyw3IEBACiAJCSAgICAgICBjb25zdCBjaGFyICpkZXZfbmFtZSwgdm9pZCAqZGF0YSk7CiBzdGF0aWMgdm9pZCBleHQ0X2Rlc3Ryb3lfbGF6eWluaXRfdGhyZWFkKHZvaWQpOwogc3RhdGljIHZvaWQgZXh0NF91bnJlZ2lzdGVyX2xpX3JlcXVlc3Qoc3RydWN0IHN1cGVyX2Jsb2NrICpzYik7CitzdGF0aWMgdm9pZCBleHQ0X2NsZWFyX3JlcXVlc3RfbGlzdCh2b2lkKTsKIAogI2lmICFkZWZpbmVkKENPTkZJR19FWFQzX0ZTKSAmJiAhZGVmaW5lZChDT05GSUdfRVhUM19GU19NT0RVTEUpICYmIGRlZmluZWQoQ09ORklHX0VYVDRfVVNFX0ZPUl9FWFQyMykKIHN0YXRpYyBzdHJ1Y3QgZmlsZV9zeXN0ZW1fdHlwZSBleHQzX2ZzX3R5cGUgPSB7CkBAIC04MzIsNiArODMzLDcgQEAKIAllaS0+aV9zeW5jX3RpZCA9IDA7CiAJZWktPmlfZGF0YXN5bmNfdGlkID0gMDsKIAlhdG9taWNfc2V0KCZlaS0+aV9pb2VuZF9jb3VudCwgMCk7CisJYXRvbWljX3NldCgmZWktPmlfYWlvZGlvX3Vud3JpdHRlbiwgMCk7CiAKIAlyZXR1cm4gJmVpLT52ZnNfaW5vZGU7CiB9CkBAIC0xMTYxLDcgKzExNjMsNyBAQAogc3RhdGljIGludCBleHQ0X21hcmtfZHF1b3RfZGlydHkoc3RydWN0IGRxdW90ICpkcXVvdCk7CiBzdGF0aWMgaW50IGV4dDRfd3JpdGVfaW5mbyhzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBpbnQgdHlwZSk7CiBzdGF0aWMgaW50IGV4dDRfcXVvdGFfb24oc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHR5cGUsIGludCBmb3JtYXRfaWQsCi0JCQkJY2hhciAqcGF0aCk7CisJCQkgc3RydWN0IHBhdGggKnBhdGgpOwogc3RhdGljIGludCBleHQ0X3F1b3RhX29mZihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBpbnQgdHlwZSk7CiBzdGF0aWMgaW50IGV4dDRfcXVvdGFfb25fbW91bnQoc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHR5cGUpOwogc3RhdGljIHNzaXplX3QgZXh0NF9xdW90YV9yZWFkKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIGludCB0eXBlLCBjaGFyICpkYXRhLApAQCAtMjcxNiw2ICsyNzE4LDggQEAKIAltdXRleF91bmxvY2soJmV4dDRfbGlfaW5mby0+bGlfbGlzdF9tdHgpOwogfQogCitzdGF0aWMgc3RydWN0IHRhc2tfc3RydWN0ICpleHQ0X2xhenlpbml0X3Rhc2s7CisKIC8qCiAgKiBUaGlzIGlzIHRoZSBmdW5jdGlvbiB3aGVyZSBleHQ0bGF6eWluaXQgdGhyZWFkIGxpdmVzLiBJdCB3YWxrcwogICogdGhyb3VnaCB0aGUgcmVxdWVzdCBsaXN0IHNlYXJjaGluZyBmb3IgbmV4dCBzY2hlZHVsZWQgZmlsZXN5c3RlbS4KQEAgLTI3ODQsNiArMjc4OCwxMCBAQAogCQlpZiAodGltZV9iZWZvcmUoamlmZmllcywgbmV4dF93YWtldXApKQogCQkJc2NoZWR1bGUoKTsKIAkJZmluaXNoX3dhaXQoJmVsaS0+bGlfd2FpdF9kYWVtb24sICZ3YWl0KTsKKwkJaWYgKGt0aHJlYWRfc2hvdWxkX3N0b3AoKSkgeworCQkJZXh0NF9jbGVhcl9yZXF1ZXN0X2xpc3QoKTsKKwkJCWdvdG8gZXhpdF90aHJlYWQ7CisJCX0KIAl9CiAKIGV4aXRfdGhyZWFkOgpAQCAtMjgwOCw2ICsyODE2LDcgQEAKIAl3YWtlX3VwKCZlbGktPmxpX3dhaXRfdGFzayk7CiAKIAlrZnJlZShleHQ0X2xpX2luZm8pOworCWV4dDRfbGF6eWluaXRfdGFzayA9IE5VTEw7CiAJZXh0NF9saV9pbmZvID0gTlVMTDsKIAltdXRleF91bmxvY2soJmV4dDRfbGlfbXR4KTsKIApAQCAtMjgzMCwxMSArMjgzOSwxMCBAQAogCiBzdGF0aWMgaW50IGV4dDRfcnVuX2xhenlpbml0X3RocmVhZCh2b2lkKQogewotCXN0cnVjdCB0YXNrX3N0cnVjdCAqdDsKLQotCXQgPSBrdGhyZWFkX3J1bihleHQ0X2xhenlpbml0X3RocmVhZCwgZXh0NF9saV9pbmZvLCAiZXh0NGxhenlpbml0Iik7Ci0JaWYgKElTX0VSUih0KSkgewotCQlpbnQgZXJyID0gUFRSX0VSUih0KTsKKwlleHQ0X2xhenlpbml0X3Rhc2sgPSBrdGhyZWFkX3J1bihleHQ0X2xhenlpbml0X3RocmVhZCwKKwkJCQkJIGV4dDRfbGlfaW5mbywgImV4dDRsYXp5aW5pdCIpOworCWlmIChJU19FUlIoZXh0NF9sYXp5aW5pdF90YXNrKSkgeworCQlpbnQgZXJyID0gUFRSX0VSUihleHQ0X2xhenlpbml0X3Rhc2spOwogCQlleHQ0X2NsZWFyX3JlcXVlc3RfbGlzdCgpOwogCQlkZWxfdGltZXJfc3luYygmZXh0NF9saV9pbmZvLT5saV90aW1lcik7CiAJCWtmcmVlKGV4dDRfbGlfaW5mbyk7CkBAIC0yOTg1LDE2ICsyOTkzLDEwIEBACiAJICogSWYgdGhyZWFkIGV4aXRlZCBlYXJsaWVyCiAJICogdGhlcmUncyBub3RoaW5nIHRvIGJlIGRvbmUuCiAJICovCi0JaWYgKCFleHQ0X2xpX2luZm8pCisJaWYgKCFleHQ0X2xpX2luZm8gfHwgIWV4dDRfbGF6eWluaXRfdGFzaykKIAkJcmV0dXJuOwogCi0JZXh0NF9jbGVhcl9yZXF1ZXN0X2xpc3QoKTsKLQotCXdoaWxlIChleHQ0X2xpX2luZm8tPmxpX3Rhc2spIHsKLQkJd2FrZV91cCgmZXh0NF9saV9pbmZvLT5saV93YWl0X2RhZW1vbik7Ci0JCXdhaXRfZXZlbnQoZXh0NF9saV9pbmZvLT5saV93YWl0X3Rhc2ssCi0JCQkgICBleHQ0X2xpX2luZm8tPmxpX3Rhc2sgPT0gTlVMTCk7Ci0JfQorCWt0aHJlYWRfc3RvcChleHQ0X2xhenlpbml0X3Rhc2spOwogfQogCiBzdGF0aWMgaW50IGV4dDRfZmlsbF9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCB2b2lkICpkYXRhLCBpbnQgc2lsZW50KQpAQCAtNDU1OCwyNyArNDU2MCwyMCBAQAogICogU3RhbmRhcmQgZnVuY3Rpb24gdG8gYmUgY2FsbGVkIG9uIHF1b3RhX29uCiAgKi8KIHN0YXRpYyBpbnQgZXh0NF9xdW90YV9vbihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBpbnQgdHlwZSwgaW50IGZvcm1hdF9pZCwKLQkJCSBjaGFyICpuYW1lKQorCQkJIHN0cnVjdCBwYXRoICpwYXRoKQogewogCWludCBlcnI7Ci0Jc3RydWN0IHBhdGggcGF0aDsKIAogCWlmICghdGVzdF9vcHQoc2IsIFFVT1RBKSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKLQllcnIgPSBrZXJuX3BhdGgobmFtZSwgTE9PS1VQX0ZPTExPVywgJnBhdGgpOwotCWlmIChlcnIpCi0JCXJldHVybiBlcnI7Ci0KIAkvKiBRdW90YWZpbGUgbm90IG9uIHRoZSBzYW1lIGZpbGVzeXN0ZW0/ICovCi0JaWYgKHBhdGgubW50LT5tbnRfc2IgIT0gc2IpIHsKLQkJcGF0aF9wdXQoJnBhdGgpOworCWlmIChwYXRoLT5tbnQtPm1udF9zYiAhPSBzYikKIAkJcmV0dXJuIC1FWERFVjsKLQl9CiAJLyogSm91cm5hbGluZyBxdW90YT8gKi8KIAlpZiAoRVhUNF9TQihzYiktPnNfcWZfbmFtZXNbdHlwZV0pIHsKIAkJLyogUXVvdGFmaWxlIG5vdCBpbiBmcyByb290PyAqLwotCQlpZiAocGF0aC5kZW50cnktPmRfcGFyZW50ICE9IHNiLT5zX3Jvb3QpCisJCWlmIChwYXRoLT5kZW50cnktPmRfcGFyZW50ICE9IHNiLT5zX3Jvb3QpCiAJCQlleHQ0X21zZyhzYiwgS0VSTl9XQVJOSU5HLAogCQkJCSJRdW90YSBmaWxlIG5vdCBvbiBmaWxlc3lzdGVtIHJvb3QuICIKIAkJCQkiSm91cm5hbGVkIHF1b3RhIHdpbGwgbm90IHdvcmsiKTsKQEAgLTQ1ODksNyArNDU4NCw3IEBACiAJICogYWxsIHVwZGF0ZXMgdG8gdGhlIGZpbGUgd2hlbiB3ZSBieXBhc3MgcGFnZWNhY2hlLi4uCiAJICovCiAJaWYgKEVYVDRfU0Ioc2IpLT5zX2pvdXJuYWwgJiYKLQkgICAgZXh0NF9zaG91bGRfam91cm5hbF9kYXRhKHBhdGguZGVudHJ5LT5kX2lub2RlKSkgeworCSAgICBleHQ0X3Nob3VsZF9qb3VybmFsX2RhdGEocGF0aC0+ZGVudHJ5LT5kX2lub2RlKSkgewogCQkvKgogCQkgKiBXZSBkb24ndCBuZWVkIHRvIGxvY2sgdXBkYXRlcyBidXQgam91cm5hbF9mbHVzaCgpIGNvdWxkCiAJCSAqIG90aGVyd2lzZSBiZSBsaXZlbG9ja2VkLi4uCkBAIC00NTk3LDE1ICs0NTkyLDExIEBACiAJCWpiZDJfam91cm5hbF9sb2NrX3VwZGF0ZXMoRVhUNF9TQihzYiktPnNfam91cm5hbCk7CiAJCWVyciA9IGpiZDJfam91cm5hbF9mbHVzaChFWFQ0X1NCKHNiKS0+c19qb3VybmFsKTsKIAkJamJkMl9qb3VybmFsX3VubG9ja191cGRhdGVzKEVYVDRfU0Ioc2IpLT5zX2pvdXJuYWwpOwotCQlpZiAoZXJyKSB7Ci0JCQlwYXRoX3B1dCgmcGF0aCk7CisJCWlmIChlcnIpCiAJCQlyZXR1cm4gZXJyOwotCQl9CiAJfQogCi0JZXJyID0gZHF1b3RfcXVvdGFfb25fcGF0aChzYiwgdHlwZSwgZm9ybWF0X2lkLCAmcGF0aCk7Ci0JcGF0aF9wdXQoJnBhdGgpOwotCXJldHVybiBlcnI7CisJcmV0dXJuIGRxdW90X3F1b3RhX29uKHNiLCB0eXBlLCBmb3JtYXRfaWQsIHBhdGgpOwogfQogCiBzdGF0aWMgaW50IGV4dDRfcXVvdGFfb2ZmKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIGludCB0eXBlKQpAQCAtNDc3OSw3ICs0NzcwLDcgQEAKIAkuZnNfZmxhZ3MJPSBGU19SRVFVSVJFU19ERVYsCiB9OwogCi1pbnQgX19pbml0IGV4dDRfaW5pdF9mZWF0X2FkdmVydHModm9pZCkKK3N0YXRpYyBpbnQgX19pbml0IGV4dDRfaW5pdF9mZWF0X2FkdmVydHModm9pZCkKIHsKIAlzdHJ1Y3QgZXh0NF9mZWF0dXJlcyAqZWY7CiAJaW50IHJldCA9IC1FTk9NRU07CkBAIC00ODAzLDIzICs0Nzk0LDQ0IEBACiAJcmV0dXJuIHJldDsKIH0KIAorc3RhdGljIHZvaWQgZXh0NF9leGl0X2ZlYXRfYWR2ZXJ0cyh2b2lkKQoreworCWtvYmplY3RfcHV0KCZleHQ0X2ZlYXQtPmZfa29iaik7CisJd2FpdF9mb3JfY29tcGxldGlvbigmZXh0NF9mZWF0LT5mX2tvYmpfdW5yZWdpc3Rlcik7CisJa2ZyZWUoZXh0NF9mZWF0KTsKK30KKworLyogU2hhcmVkIGFjcm9zcyBhbGwgZXh0NCBmaWxlIHN5c3RlbXMgKi8KK3dhaXRfcXVldWVfaGVhZF90IGV4dDRfX2lvZW5kX3dxW0VYVDRfV1FfSEFTSF9TWl07CitzdHJ1Y3QgbXV0ZXggZXh0NF9fYWlvX211dGV4W0VYVDRfV1FfSEFTSF9TWl07CisKIHN0YXRpYyBpbnQgX19pbml0IGV4dDRfaW5pdF9mcyh2b2lkKQogewotCWludCBlcnI7CisJaW50IGksIGVycjsKIAogCWV4dDRfY2hlY2tfZmxhZ192YWx1ZXMoKTsKKworCWZvciAoaSA9IDA7IGkgPCBFWFQ0X1dRX0hBU0hfU1o7IGkrKykgeworCQltdXRleF9pbml0KCZleHQ0X19haW9fbXV0ZXhbaV0pOworCQlpbml0X3dhaXRxdWV1ZV9oZWFkKCZleHQ0X19pb2VuZF93cVtpXSk7CisJfQorCiAJZXJyID0gZXh0NF9pbml0X3BhZ2VpbygpOwogCWlmIChlcnIpCiAJCXJldHVybiBlcnI7CiAJZXJyID0gZXh0NF9pbml0X3N5c3RlbV96b25lKCk7CiAJaWYgKGVycikKLQkJZ290byBvdXQ1OworCQlnb3RvIG91dDc7CiAJZXh0NF9rc2V0ID0ga3NldF9jcmVhdGVfYW5kX2FkZCgiZXh0NCIsIE5VTEwsIGZzX2tvYmopOwogCWlmICghZXh0NF9rc2V0KQotCQlnb3RvIG91dDQ7CisJCWdvdG8gb3V0NjsKIAlleHQ0X3Byb2Nfcm9vdCA9IHByb2NfbWtkaXIoImZzL2V4dDQiLCBOVUxMKTsKKwlpZiAoIWV4dDRfcHJvY19yb290KQorCQlnb3RvIG91dDU7CiAKIAllcnIgPSBleHQ0X2luaXRfZmVhdF9hZHZlcnRzKCk7CisJaWYgKGVycikKKwkJZ290byBvdXQ0OwogCiAJZXJyID0gZXh0NF9pbml0X21iYWxsb2MoKTsKIAlpZiAoZXJyKQpAQCAtNDg0OSwxMiArNDg2MSwxNCBAQAogb3V0MjoKIAlleHQ0X2V4aXRfbWJhbGxvYygpOwogb3V0MzoKLQlrZnJlZShleHQ0X2ZlYXQpOwotCXJlbW92ZV9wcm9jX2VudHJ5KCJmcy9leHQ0IiwgTlVMTCk7Ci0Ja3NldF91bnJlZ2lzdGVyKGV4dDRfa3NldCk7CisJZXh0NF9leGl0X2ZlYXRfYWR2ZXJ0cygpOwogb3V0NDoKLQlleHQ0X2V4aXRfc3lzdGVtX3pvbmUoKTsKKwlyZW1vdmVfcHJvY19lbnRyeSgiZnMvZXh0NCIsIE5VTEwpOwogb3V0NToKKwlrc2V0X3VucmVnaXN0ZXIoZXh0NF9rc2V0KTsKK291dDY6CisJZXh0NF9leGl0X3N5c3RlbV96b25lKCk7CitvdXQ3OgogCWV4dDRfZXhpdF9wYWdlaW8oKTsKIAlyZXR1cm4gZXJyOwogfQpAQCAtNDg2OCw2ICs0ODgyLDcgQEAKIAlkZXN0cm95X2lub2RlY2FjaGUoKTsKIAlleHQ0X2V4aXRfeGF0dHIoKTsKIAlleHQ0X2V4aXRfbWJhbGxvYygpOworCWV4dDRfZXhpdF9mZWF0X2FkdmVydHMoKTsKIAlyZW1vdmVfcHJvY19lbnRyeSgiZnMvZXh0NCIsIE5VTEwpOwogCWtzZXRfdW5yZWdpc3RlcihleHQ0X2tzZXQpOwogCWV4dDRfZXhpdF9zeXN0ZW1fem9uZSgpOwpkaWZmIC0tZ2l0IGEvZnMvZmNudGwuYyBiL2ZzL2ZjbnRsLmMKaW5kZXggZWNjOGIzOS4uY2IxMDI2MSAxMDA2NDQKLS0tIGEvZnMvZmNudGwuYworKysgYi9mcy9mY250bC5jCkBAIC04MTUsNyArODE1LDcgQEAKIAkJX19PX1NZTkMJfCBPX0RTWU5DCXwgRkFTWU5DCXwKIAkJT19ESVJFQ1QJfCBPX0xBUkdFRklMRQl8IE9fRElSRUNUT1JZCXwKIAkJT19OT0ZPTExPVwl8IE9fTk9BVElNRQl8IE9fQ0xPRVhFQwl8Ci0JCUZNT0RFX0VYRUMKKwkJX19GTU9ERV9FWEVDCiAJCSkpOwogCiAJZmFzeW5jX2NhY2hlID0ga21lbV9jYWNoZV9jcmVhdGUoImZhc3luY19jYWNoZSIsCmRpZmYgLS1naXQgYS9mcy9maWxlX3RhYmxlLmMgYi9mcy9maWxlX3RhYmxlLmMKaW5kZXggYzNkZWUzOC4uZWIzNmI2YiAxMDA2NDQKLS0tIGEvZnMvZmlsZV90YWJsZS5jCisrKyBiL2ZzL2ZpbGVfdGFibGUuYwpAQCAtMTI1LDEzICsxMjUsMTMgQEAKIAkJZ290byBmYWlsOwogCiAJcGVyY3B1X2NvdW50ZXJfaW5jKCZucl9maWxlcyk7CisJZi0+Zl9jcmVkID0gZ2V0X2NyZWQoY3JlZCk7CiAJaWYgKHNlY3VyaXR5X2ZpbGVfYWxsb2MoZikpCiAJCWdvdG8gZmFpbF9zZWM7CiAKIAlJTklUX0xJU1RfSEVBRCgmZi0+Zl91LmZ1X2xpc3QpOwogCWF0b21pY19sb25nX3NldCgmZi0+Zl9jb3VudCwgMSk7CiAJcndsb2NrX2luaXQoJmYtPmZfb3duZXIubG9jayk7Ci0JZi0+Zl9jcmVkID0gZ2V0X2NyZWQoY3JlZCk7CiAJc3Bpbl9sb2NrX2luaXQoJmYtPmZfbG9jayk7CiAJZXZlbnRwb2xsX2luaXRfZmlsZShmKTsKIAkvKiBmLT5mX3ZlcnNpb246IDAgKi8KQEAgLTMxMSw3ICszMTEsNyBAQAogCXN0cnVjdCBmaWxlc19zdHJ1Y3QgKmZpbGVzID0gY3VycmVudC0+ZmlsZXM7CiAKIAkqZnB1dF9uZWVkZWQgPSAwOwotCWlmIChsaWtlbHkoKGF0b21pY19yZWFkKCZmaWxlcy0+Y291bnQpID09IDEpKSkgeworCWlmIChhdG9taWNfcmVhZCgmZmlsZXMtPmNvdW50KSA9PSAxKSB7CiAJCWZpbGUgPSBmY2hlY2tfZmlsZXMoZmlsZXMsIGZkKTsKIAl9IGVsc2UgewogCQlyY3VfcmVhZF9sb2NrKCk7CmRpZmYgLS1naXQgYS9mcy9mcy13cml0ZWJhY2suYyBiL2ZzL2ZzLXdyaXRlYmFjay5jCmluZGV4IDNkMDZjY2MuLjU5YzZlNDkgMTAwNjQ0Ci0tLSBhL2ZzL2ZzLXdyaXRlYmFjay5jCisrKyBiL2ZzL2ZzLXdyaXRlYmFjay5jCkBAIC04NCwxMyArODQsOSBAQAogCXJldHVybiBsaXN0X2VudHJ5KGhlYWQsIHN0cnVjdCBpbm9kZSwgaV93Yl9saXN0KTsKIH0KIAotc3RhdGljIHZvaWQgYmRpX3F1ZXVlX3dvcmsoc3RydWN0IGJhY2tpbmdfZGV2X2luZm8gKmJkaSwKLQkJc3RydWN0IHdiX3dyaXRlYmFja193b3JrICp3b3JrKQorLyogV2FrZXVwIGZsdXNoZXIgdGhyZWFkIG9yIGZvcmtlciB0aHJlYWQgdG8gZm9yayBpdC4gUmVxdWlyZXMgYmRpLT53Yl9sb2NrLiAqLworc3RhdGljIHZvaWQgYmRpX3dha2V1cF9mbHVzaGVyKHN0cnVjdCBiYWNraW5nX2Rldl9pbmZvICpiZGkpCiB7Ci0JdHJhY2Vfd3JpdGViYWNrX3F1ZXVlKGJkaSwgd29yayk7Ci0KLQlzcGluX2xvY2tfYmgoJmJkaS0+d2JfbG9jayk7Ci0JbGlzdF9hZGRfdGFpbCgmd29yay0+bGlzdCwgJmJkaS0+d29ya19saXN0KTsKIAlpZiAoYmRpLT53Yi50YXNrKSB7CiAJCXdha2VfdXBfcHJvY2VzcyhiZGktPndiLnRhc2spOwogCX0gZWxzZSB7CkBAIC05OCwxNSArOTQsMjYgQEAKIAkJICogVGhlIGJkaSB0aHJlYWQgaXNuJ3QgdGhlcmUsIHdha2UgdXAgdGhlIGZvcmtlciB0aHJlYWQgd2hpY2gKIAkJICogd2lsbCBjcmVhdGUgYW5kIHJ1biBpdC4KIAkJICovCi0JCXRyYWNlX3dyaXRlYmFja19ub3RocmVhZChiZGksIHdvcmspOwogCQl3YWtlX3VwX3Byb2Nlc3MoZGVmYXVsdF9iYWNraW5nX2Rldl9pbmZvLndiLnRhc2spOwogCX0KK30KKworc3RhdGljIHZvaWQgYmRpX3F1ZXVlX3dvcmsoc3RydWN0IGJhY2tpbmdfZGV2X2luZm8gKmJkaSwKKwkJCSAgIHN0cnVjdCB3Yl93cml0ZWJhY2tfd29yayAqd29yaykKK3sKKwl0cmFjZV93cml0ZWJhY2tfcXVldWUoYmRpLCB3b3JrKTsKKworCXNwaW5fbG9ja19iaCgmYmRpLT53Yl9sb2NrKTsKKwlsaXN0X2FkZF90YWlsKCZ3b3JrLT5saXN0LCAmYmRpLT53b3JrX2xpc3QpOworCWlmICghYmRpLT53Yi50YXNrKQorCQl0cmFjZV93cml0ZWJhY2tfbm90aHJlYWQoYmRpLCB3b3JrKTsKKwliZGlfd2FrZXVwX2ZsdXNoZXIoYmRpKTsKIAlzcGluX3VubG9ja19iaCgmYmRpLT53Yl9sb2NrKTsKIH0KIAogc3RhdGljIHZvaWQKIF9fYmRpX3N0YXJ0X3dyaXRlYmFjayhzdHJ1Y3QgYmFja2luZ19kZXZfaW5mbyAqYmRpLCBsb25nIG5yX3BhZ2VzLAotCQlib29sIHJhbmdlX2N5Y2xpYywgYm9vbCBmb3JfYmFja2dyb3VuZCkKKwkJICAgICAgYm9vbCByYW5nZV9jeWNsaWMpCiB7CiAJc3RydWN0IHdiX3dyaXRlYmFja193b3JrICp3b3JrOwogCkBAIC0xMjYsNyArMTMzLDYgQEAKIAl3b3JrLT5zeW5jX21vZGUJPSBXQl9TWU5DX05PTkU7CiAJd29yay0+bnJfcGFnZXMJPSBucl9wYWdlczsKIAl3b3JrLT5yYW5nZV9jeWNsaWMgPSByYW5nZV9jeWNsaWM7Ci0Jd29yay0+Zm9yX2JhY2tncm91bmQgPSBmb3JfYmFja2dyb3VuZDsKIAogCWJkaV9xdWV1ZV93b3JrKGJkaSwgd29yayk7CiB9CkBAIC0xNDQsNyArMTUwLDcgQEAKICAqLwogdm9pZCBiZGlfc3RhcnRfd3JpdGViYWNrKHN0cnVjdCBiYWNraW5nX2Rldl9pbmZvICpiZGksIGxvbmcgbnJfcGFnZXMpCiB7Ci0JX19iZGlfc3RhcnRfd3JpdGViYWNrKGJkaSwgbnJfcGFnZXMsIHRydWUsIGZhbHNlKTsKKwlfX2JkaV9zdGFydF93cml0ZWJhY2soYmRpLCBucl9wYWdlcywgdHJ1ZSk7CiB9CiAKIC8qKgpAQCAtMTUyLDEzICsxNTgsMjEgQEAKICAqIEBiZGk6IHRoZSBiYWNraW5nIGRldmljZSB0byB3cml0ZSBmcm9tCiAgKgogICogRGVzY3JpcHRpb246Ci0gKiAgIFRoaXMgZG9lcyBXQl9TWU5DX05PTkUgYmFja2dyb3VuZCB3cml0ZWJhY2suIFRoZSBJTyBpcyBvbmx5Ci0gKiAgIHN0YXJ0ZWQgd2hlbiB0aGlzIGZ1bmN0aW9uIHJldHVybnMsIHdlIG1ha2Ugbm8gZ3VhcmVudGVlcyBvbgotICogICBjb21wbGV0aW9uLiBDYWxsZXIgbmVlZCBub3QgaG9sZCBzYiBzX3Vtb3VudCBzZW1hcGhvcmUuCisgKiAgIFRoaXMgbWFrZXMgc3VyZSBXQl9TWU5DX05PTkUgYmFja2dyb3VuZCB3cml0ZWJhY2sgaGFwcGVucy4gV2hlbgorICogICB0aGlzIGZ1bmN0aW9uIHJldHVybnMsIGl0IGlzIG9ubHkgZ3VhcmFudGVlZCB0aGF0IGZvciBnaXZlbiBCREkKKyAqICAgc29tZSBJTyBpcyBoYXBwZW5pbmcgaWYgd2UgYXJlIG92ZXIgYmFja2dyb3VuZCBkaXJ0eSB0aHJlc2hvbGQuCisgKiAgIENhbGxlciBuZWVkIG5vdCBob2xkIHNiIHNfdW1vdW50IHNlbWFwaG9yZS4KICAqLwogdm9pZCBiZGlfc3RhcnRfYmFja2dyb3VuZF93cml0ZWJhY2soc3RydWN0IGJhY2tpbmdfZGV2X2luZm8gKmJkaSkKIHsKLQlfX2JkaV9zdGFydF93cml0ZWJhY2soYmRpLCBMT05HX01BWCwgdHJ1ZSwgdHJ1ZSk7CisJLyoKKwkgKiBXZSBqdXN0IHdha2UgdXAgdGhlIGZsdXNoZXIgdGhyZWFkLiBJdCB3aWxsIHBlcmZvcm0gYmFja2dyb3VuZAorCSAqIHdyaXRlYmFjayBhcyBzb29uIGFzIHRoZXJlIGlzIG5vIG90aGVyIHdvcmsgdG8gZG8uCisJICovCisJdHJhY2Vfd3JpdGViYWNrX3dha2VfYmFja2dyb3VuZChiZGkpOworCXNwaW5fbG9ja19iaCgmYmRpLT53Yl9sb2NrKTsKKwliZGlfd2FrZXVwX2ZsdXNoZXIoYmRpKTsKKwlzcGluX3VubG9ja19iaCgmYmRpLT53Yl9sb2NrKTsKIH0KIAogLyoKQEAgLTYxNiw2ICs2MzAsNyBAQAogCX07CiAJdW5zaWduZWQgbG9uZyBvbGRlc3RfamlmOwogCWxvbmcgd3JvdGUgPSAwOworCWxvbmcgd3JpdGVfY2h1bms7CiAJc3RydWN0IGlub2RlICppbm9kZTsKIAogCWlmICh3YmMuZm9yX2t1cGRhdGUpIHsKQEAgLTYyOCw2ICs2NDMsMjQgQEAKIAkJd2JjLnJhbmdlX2VuZCA9IExMT05HX01BWDsKIAl9CiAKKwkvKgorCSAqIFdCX1NZTkNfQUxMIG1vZGUgZG9lcyBsaXZlbG9jayBhdm9pZGFuY2UgYnkgc3luY2luZyBkaXJ0eQorCSAqIGlub2Rlcy9wYWdlcyBpbiBvbmUgYmlnIGxvb3AuIFNldHRpbmcgd2JjLm5yX3RvX3dyaXRlPUxPTkdfTUFYCisJICogaGVyZSBhdm9pZHMgY2FsbGluZyBpbnRvIHdyaXRlYmFja19pbm9kZXNfd2IoKSBtb3JlIHRoYW4gb25jZS4KKwkgKgorCSAqIFRoZSBpbnRlbmRlZCBjYWxsIHNlcXVlbmNlIGZvciBXQl9TWU5DX0FMTCB3cml0ZWJhY2sgaXM6CisJICoKKwkgKiAgICAgIHdiX3dyaXRlYmFjaygpCisJICogICAgICAgICAgX193cml0ZWJhY2tfaW5vZGVzX3NiKCkgICAgIDw9PSBjYWxsZWQgb25seSBvbmNlCisJICogICAgICAgICAgICAgIHdyaXRlX2NhY2hlX3BhZ2VzKCkgICAgIDw9PSBjYWxsZWQgb25jZSBmb3IgZWFjaCBpbm9kZQorCSAqICAgICAgICAgICAgICAgICAgIChxdWlja2x5KSB0YWcgY3VycmVudGx5IGRpcnR5IHBhZ2VzCisJICogICAgICAgICAgICAgICAgICAgKG1heWJlIHNsb3dseSkgc3luYyBhbGwgdGFnZ2VkIHBhZ2VzCisJICovCisJaWYgKHdiYy5zeW5jX21vZGUgPT0gV0JfU1lOQ19OT05FKQorCQl3cml0ZV9jaHVuayA9IE1BWF9XUklURUJBQ0tfUEFHRVM7CisJZWxzZQorCQl3cml0ZV9jaHVuayA9IExPTkdfTUFYOworCiAJd2JjLndiX3N0YXJ0ID0gamlmZmllczsgLyogbGl2ZWxvY2sgYXZvaWRhbmNlICovCiAJZm9yICg7OykgewogCQkvKgpAQCAtNjM3LDYgKzY3MCwxNiBAQAogCQkJYnJlYWs7CiAKIAkJLyoKKwkJICogQmFja2dyb3VuZCB3cml0ZW91dCBhbmQga3VwZGF0ZS1zdHlsZSB3cml0ZWJhY2sgbWF5CisJCSAqIHJ1biBmb3JldmVyLiBTdG9wIHRoZW0gaWYgdGhlcmUgaXMgb3RoZXIgd29yayB0byBkbworCQkgKiBzbyB0aGF0IGUuZy4gc3luYyBjYW4gcHJvY2VlZC4gVGhleSdsbCBiZSByZXN0YXJ0ZWQKKwkJICogYWZ0ZXIgdGhlIG90aGVyIHdvcmtzIGFyZSBhbGwgZG9uZS4KKwkJICovCisJCWlmICgod29yay0+Zm9yX2JhY2tncm91bmQgfHwgd29yay0+Zm9yX2t1cGRhdGUpICYmCisJCSAgICAhbGlzdF9lbXB0eSgmd2ItPmJkaS0+d29ya19saXN0KSkKKwkJCWJyZWFrOworCisJCS8qCiAJCSAqIEZvciBiYWNrZ3JvdW5kIHdyaXRlb3V0LCBzdG9wIHdoZW4gd2UgYXJlIGJlbG93IHRoZQogCQkgKiBiYWNrZ3JvdW5kIGRpcnR5IHRocmVzaG9sZAogCQkgKi8KQEAgLTY0NCw3ICs2ODcsNyBAQAogCQkJYnJlYWs7CiAKIAkJd2JjLm1vcmVfaW8gPSAwOwotCQl3YmMubnJfdG9fd3JpdGUgPSBNQVhfV1JJVEVCQUNLX1BBR0VTOworCQl3YmMubnJfdG9fd3JpdGUgPSB3cml0ZV9jaHVuazsKIAkJd2JjLnBhZ2VzX3NraXBwZWQgPSAwOwogCiAJCXRyYWNlX3diY193cml0ZWJhY2tfc3RhcnQoJndiYywgd2ItPmJkaSk7CkBAIC02NTQsOCArNjk3LDggQEAKIAkJCXdyaXRlYmFja19pbm9kZXNfd2Iod2IsICZ3YmMpOwogCQl0cmFjZV93YmNfd3JpdGViYWNrX3dyaXR0ZW4oJndiYywgd2ItPmJkaSk7CiAKLQkJd29yay0+bnJfcGFnZXMgLT0gTUFYX1dSSVRFQkFDS19QQUdFUyAtIHdiYy5ucl90b193cml0ZTsKLQkJd3JvdGUgKz0gTUFYX1dSSVRFQkFDS19QQUdFUyAtIHdiYy5ucl90b193cml0ZTsKKwkJd29yay0+bnJfcGFnZXMgLT0gd3JpdGVfY2h1bmsgLSB3YmMubnJfdG9fd3JpdGU7CisJCXdyb3RlICs9IHdyaXRlX2NodW5rIC0gd2JjLm5yX3RvX3dyaXRlOwogCiAJCS8qCiAJCSAqIElmIHdlIGNvbnN1bWVkIGV2ZXJ5dGhpbmcsIHNlZSBpZiB3ZSBoYXZlIG1vcmUKQEAgLTY3MCw3ICs3MTMsNyBAQAogCQkvKgogCQkgKiBEaWQgd2Ugd3JpdGUgc29tZXRoaW5nPyBUcnkgZm9yIG1vcmUKIAkJICovCi0JCWlmICh3YmMubnJfdG9fd3JpdGUgPCBNQVhfV1JJVEVCQUNLX1BBR0VTKQorCQlpZiAod2JjLm5yX3RvX3dyaXRlIDwgd3JpdGVfY2h1bmspCiAJCQljb250aW51ZTsKIAkJLyoKIAkJICogTm90aGluZyB3cml0dGVuLiBXYWl0IGZvciBzb21lIGlub2RlIHRvCkBAIC03MTgsNiArNzYxLDIzIEBACiAJCWdldF9ucl9kaXJ0eV9pbm9kZXMoKTsKIH0KIAorc3RhdGljIGxvbmcgd2JfY2hlY2tfYmFja2dyb3VuZF9mbHVzaChzdHJ1Y3QgYmRpX3dyaXRlYmFjayAqd2IpCit7CisJaWYgKG92ZXJfYmdyb3VuZF90aHJlc2goKSkgeworCisJCXN0cnVjdCB3Yl93cml0ZWJhY2tfd29yayB3b3JrID0geworCQkJLm5yX3BhZ2VzCT0gTE9OR19NQVgsCisJCQkuc3luY19tb2RlCT0gV0JfU1lOQ19OT05FLAorCQkJLmZvcl9iYWNrZ3JvdW5kCT0gMSwKKwkJCS5yYW5nZV9jeWNsaWMJPSAxLAorCQl9OworCisJCXJldHVybiB3Yl93cml0ZWJhY2sod2IsICZ3b3JrKTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKwogc3RhdGljIGxvbmcgd2JfY2hlY2tfb2xkX2RhdGFfZmx1c2goc3RydWN0IGJkaV93cml0ZWJhY2sgKndiKQogewogCXVuc2lnbmVkIGxvbmcgZXhwaXJlZDsKQEAgLTc4Nyw2ICs4NDcsNyBAQAogCSAqIENoZWNrIGZvciBwZXJpb2RpYyB3cml0ZWJhY2ssIGt1cGRhdGVkKCkgc3R5bGUKIAkgKi8KIAl3cm90ZSArPSB3Yl9jaGVja19vbGRfZGF0YV9mbHVzaCh3Yik7CisJd3JvdGUgKz0gd2JfY2hlY2tfYmFja2dyb3VuZF9mbHVzaCh3Yik7CiAJY2xlYXJfYml0KEJESV93cml0ZWJhY2tfcnVubmluZywgJndiLT5iZGktPnN0YXRlKTsKIAogCXJldHVybiB3cm90ZTsKQEAgLTg3Myw3ICs5MzQsNyBAQAogCWxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KGJkaSwgJmJkaV9saXN0LCBiZGlfbGlzdCkgewogCQlpZiAoIWJkaV9oYXNfZGlydHlfaW8oYmRpKSkKIAkJCWNvbnRpbnVlOwotCQlfX2JkaV9zdGFydF93cml0ZWJhY2soYmRpLCBucl9wYWdlcywgZmFsc2UsIGZhbHNlKTsKKwkJX19iZGlfc3RhcnRfd3JpdGViYWNrKGJkaSwgbnJfcGFnZXMsIGZhbHNlKTsKIAl9CiAJcmN1X3JlYWRfdW5sb2NrKCk7CiB9CkBAIC0xMTY0LDcgKzEyMjUsNyBAQAogICogQHNiOiB0aGUgc3VwZXJibG9jawogICoKICAqIFRoaXMgZnVuY3Rpb24gd3JpdGVzIGFuZCB3YWl0cyBvbiBhbnkgZGlydHkgaW5vZGUgYmVsb25naW5nIHRvIHRoaXMKLSAqIHN1cGVyX2Jsb2NrLiBUaGUgbnVtYmVyIG9mIHBhZ2VzIHN5bmNlZCBpcyByZXR1cm5lZC4KKyAqIHN1cGVyX2Jsb2NrLgogICovCiB2b2lkIHN5bmNfaW5vZGVzX3NiKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCiB7CkBAIC0xMjQyLDExICsxMzAzLDExIEBACiBFWFBPUlRfU1lNQk9MKHN5bmNfaW5vZGUpOwogCiAvKioKLSAqIHN5bmNfaW5vZGUgLSB3cml0ZSBhbiBpbm9kZSB0byBkaXNrCisgKiBzeW5jX2lub2RlX21ldGFkYXRhIC0gd3JpdGUgYW4gaW5vZGUgdG8gZGlzawogICogQGlub2RlOiB0aGUgaW5vZGUgdG8gc3luYwogICogQHdhaXQ6IHdhaXQgZm9yIEkvTyB0byBjb21wbGV0ZS4KICAqCi0gKiBXcml0ZSBhbiBpbm9kZSB0byBkaXNrIGFuZCBhZGp1c3QgaXQncyBkaXJ0eSBzdGF0ZSBhZnRlciBjb21wbGV0aW9uLgorICogV3JpdGUgYW4gaW5vZGUgdG8gZGlzayBhbmQgYWRqdXN0IGl0cyBkaXJ0eSBzdGF0ZSBhZnRlciBjb21wbGV0aW9uLgogICoKICAqIE5vdGU6IG9ubHkgd3JpdGVzIHRoZSBhY3R1YWwgaW5vZGUsIG5vIGFzc29jaWF0ZWQgZGF0YSBvciBvdGhlciBtZXRhZGF0YS4KICAqLwpkaWZmIC0tZ2l0IGEvZnMvZnNfc3RydWN0LmMgYi9mcy9mc19zdHJ1Y3QuYwppbmRleCA2OGNhNDg3Li43OGI1MTljIDEwMDY0NAotLS0gYS9mcy9mc19zdHJ1Y3QuYworKysgYi9mcy9mc19zdHJ1Y3QuYwpAQCAtNCw2ICs0LDE5IEBACiAjaW5jbHVkZSA8bGludXgvcGF0aC5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9mc19zdHJ1Y3QuaD4KKyNpbmNsdWRlICJpbnRlcm5hbC5oIgorCitzdGF0aWMgaW5saW5lIHZvaWQgcGF0aF9nZXRfbG9uZ3Rlcm0oc3RydWN0IHBhdGggKnBhdGgpCit7CisJcGF0aF9nZXQocGF0aCk7CisJbW50X21ha2VfbG9uZ3Rlcm0ocGF0aC0+bW50KTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHBhdGhfcHV0X2xvbmd0ZXJtKHN0cnVjdCBwYXRoICpwYXRoKQoreworCW1udF9tYWtlX3Nob3J0dGVybShwYXRoLT5tbnQpOworCXBhdGhfcHV0KHBhdGgpOworfQogCiAvKgogICogUmVwbGFjZSB0aGUgZnMtPntyb290bW50LHJvb3R9IHdpdGgge21udCxkZW50cnl9LiBQdXQgdGhlIG9sZCB2YWx1ZXMuCkBAIC0xNywxMSArMzAsMTEgQEAKIAl3cml0ZV9zZXFjb3VudF9iZWdpbigmZnMtPnNlcSk7CiAJb2xkX3Jvb3QgPSBmcy0+cm9vdDsKIAlmcy0+cm9vdCA9ICpwYXRoOwotCXBhdGhfZ2V0X2xvbmcocGF0aCk7CisJcGF0aF9nZXRfbG9uZ3Rlcm0ocGF0aCk7CiAJd3JpdGVfc2VxY291bnRfZW5kKCZmcy0+c2VxKTsKIAlzcGluX3VubG9jaygmZnMtPmxvY2spOwogCWlmIChvbGRfcm9vdC5kZW50cnkpCi0JCXBhdGhfcHV0X2xvbmcoJm9sZF9yb290KTsKKwkJcGF0aF9wdXRfbG9uZ3Rlcm0oJm9sZF9yb290KTsKIH0KIAogLyoKQEAgLTM2LDEyICs0OSwxMiBAQAogCXdyaXRlX3NlcWNvdW50X2JlZ2luKCZmcy0+c2VxKTsKIAlvbGRfcHdkID0gZnMtPnB3ZDsKIAlmcy0+cHdkID0gKnBhdGg7Ci0JcGF0aF9nZXRfbG9uZyhwYXRoKTsKKwlwYXRoX2dldF9sb25ndGVybShwYXRoKTsKIAl3cml0ZV9zZXFjb3VudF9lbmQoJmZzLT5zZXEpOwogCXNwaW5fdW5sb2NrKCZmcy0+bG9jayk7CiAKIAlpZiAob2xkX3B3ZC5kZW50cnkpCi0JCXBhdGhfcHV0X2xvbmcoJm9sZF9wd2QpOworCQlwYXRoX3B1dF9sb25ndGVybSgmb2xkX3B3ZCk7CiB9CiAKIHZvaWQgY2hyb290X2ZzX3JlZnMoc3RydWN0IHBhdGggKm9sZF9yb290LCBzdHJ1Y3QgcGF0aCAqbmV3X3Jvb3QpCkBAIC01OSwxMyArNzIsMTMgQEAKIAkJCXdyaXRlX3NlcWNvdW50X2JlZ2luKCZmcy0+c2VxKTsKIAkJCWlmIChmcy0+cm9vdC5kZW50cnkgPT0gb2xkX3Jvb3QtPmRlbnRyeQogCQkJICAgICYmIGZzLT5yb290Lm1udCA9PSBvbGRfcm9vdC0+bW50KSB7Ci0JCQkJcGF0aF9nZXRfbG9uZyhuZXdfcm9vdCk7CisJCQkJcGF0aF9nZXRfbG9uZ3Rlcm0obmV3X3Jvb3QpOwogCQkJCWZzLT5yb290ID0gKm5ld19yb290OwogCQkJCWNvdW50Kys7CiAJCQl9CiAJCQlpZiAoZnMtPnB3ZC5kZW50cnkgPT0gb2xkX3Jvb3QtPmRlbnRyeQogCQkJICAgICYmIGZzLT5wd2QubW50ID09IG9sZF9yb290LT5tbnQpIHsKLQkJCQlwYXRoX2dldF9sb25nKG5ld19yb290KTsKKwkJCQlwYXRoX2dldF9sb25ndGVybShuZXdfcm9vdCk7CiAJCQkJZnMtPnB3ZCA9ICpuZXdfcm9vdDsKIAkJCQljb3VudCsrOwogCQkJfQpAQCAtNzYsMTMgKzg5LDEzIEBACiAJfSB3aGlsZV9lYWNoX3RocmVhZChnLCBwKTsKIAlyZWFkX3VubG9jaygmdGFza2xpc3RfbG9jayk7CiAJd2hpbGUgKGNvdW50LS0pCi0JCXBhdGhfcHV0X2xvbmcob2xkX3Jvb3QpOworCQlwYXRoX3B1dF9sb25ndGVybShvbGRfcm9vdCk7CiB9CiAKIHZvaWQgZnJlZV9mc19zdHJ1Y3Qoc3RydWN0IGZzX3N0cnVjdCAqZnMpCiB7Ci0JcGF0aF9wdXRfbG9uZygmZnMtPnJvb3QpOwotCXBhdGhfcHV0X2xvbmcoJmZzLT5wd2QpOworCXBhdGhfcHV0X2xvbmd0ZXJtKCZmcy0+cm9vdCk7CisJcGF0aF9wdXRfbG9uZ3Rlcm0oJmZzLT5wd2QpOwogCWttZW1fY2FjaGVfZnJlZShmc19jYWNoZXAsIGZzKTsKIH0KIApAQCAtMTE4LDkgKzEzMSw5IEBACiAKIAkJc3Bpbl9sb2NrKCZvbGQtPmxvY2spOwogCQlmcy0+cm9vdCA9IG9sZC0+cm9vdDsKLQkJcGF0aF9nZXRfbG9uZygmZnMtPnJvb3QpOworCQlwYXRoX2dldF9sb25ndGVybSgmZnMtPnJvb3QpOwogCQlmcy0+cHdkID0gb2xkLT5wd2Q7Ci0JCXBhdGhfZ2V0X2xvbmcoJmZzLT5wd2QpOworCQlwYXRoX2dldF9sb25ndGVybSgmZnMtPnB3ZCk7CiAJCXNwaW5fdW5sb2NrKCZvbGQtPmxvY2spOwogCX0KIAlyZXR1cm4gZnM7CmRpZmYgLS1naXQgYS9mcy9mc2NhY2hlL29wZXJhdGlvbi5jIGIvZnMvZnNjYWNoZS9vcGVyYXRpb24uYwppbmRleCBiOWYzNGVhLi40OGExOGYxIDEwMDY0NAotLS0gYS9mcy9mc2NhY2hlL29wZXJhdGlvbi5jCisrKyBiL2ZzL2ZzY2FjaGUvb3BlcmF0aW9uLmMKQEAgLTEwMSw3ICsxMDEsNyBAQAogCQlvYmplY3QtPm5fb3BzKys7CiAJCW9iamVjdC0+bl9leGNsdXNpdmUrKzsJLyogcmVhZHMgYW5kIHdyaXRlcyBtdXN0IHdhaXQgKi8KIAotCQlpZiAob2JqZWN0LT5uX29wcyA+IDApIHsKKwkJaWYgKG9iamVjdC0+bl9vcHMgPiAxKSB7CiAJCQlhdG9taWNfaW5jKCZvcC0+dXNhZ2UpOwogCQkJbGlzdF9hZGRfdGFpbCgmb3AtPnBlbmRfbGluaywgJm9iamVjdC0+cGVuZGluZ19vcHMpOwogCQkJZnNjYWNoZV9zdGF0KCZmc2NhY2hlX25fb3BfcGVuZCk7CmRpZmYgLS1naXQgYS9mcy9nZnMyL2ZpbGUuYyBiL2ZzL2dmczIvZmlsZS5jCmluZGV4IGZjYTY2ODkuLjdjZmRjYjkgMTAwNjQ0Ci0tLSBhL2ZzL2dmczIvZmlsZS5jCisrKyBiL2ZzL2dmczIvZmlsZS5jCkBAIC0xOSw2ICsxOSw4IEBACiAjaW5jbHVkZSA8bGludXgvZnMuaD4KICNpbmNsdWRlIDxsaW51eC9nZnMyX29uZGlzay5oPgogI2luY2x1ZGUgPGxpbnV4L2V4dDJfZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9mYWxsb2MuaD4KKyNpbmNsdWRlIDxsaW51eC9zd2FwLmg+CiAjaW5jbHVkZSA8bGludXgvY3JjMzIuaD4KICNpbmNsdWRlIDxsaW51eC93cml0ZWJhY2suaD4KICNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgpAQCAtNjEwLDYgKzYxMiwyNjAgQEAKIAlyZXR1cm4gZ2VuZXJpY19maWxlX2Fpb193cml0ZShpb2NiLCBpb3YsIG5yX3NlZ3MsIHBvcyk7CiB9CiAKK3N0YXRpYyB2b2lkIGVtcHR5X3dyaXRlX2VuZChzdHJ1Y3QgcGFnZSAqcGFnZSwgdW5zaWduZWQgZnJvbSwKKwkJCSAgIHVuc2lnbmVkIHRvKQoreworCXN0cnVjdCBnZnMyX2lub2RlICppcCA9IEdGUzJfSShwYWdlLT5tYXBwaW5nLT5ob3N0KTsKKworCXBhZ2VfemVyb19uZXdfYnVmZmVycyhwYWdlLCBmcm9tLCB0byk7CisJZmx1c2hfZGNhY2hlX3BhZ2UocGFnZSk7CisJbWFya19wYWdlX2FjY2Vzc2VkKHBhZ2UpOworCisJaWYgKCFnZnMyX2lzX3dyaXRlYmFjayhpcCkpCisJCWdmczJfcGFnZV9hZGRfZGF0YWJ1ZnMoaXAsIHBhZ2UsIGZyb20sIHRvKTsKKworCWJsb2NrX2NvbW1pdF93cml0ZShwYWdlLCBmcm9tLCB0byk7Cit9CisKK3N0YXRpYyBpbnQgd3JpdGVfZW1wdHlfYmxvY2tzKHN0cnVjdCBwYWdlICpwYWdlLCB1bnNpZ25lZCBmcm9tLCB1bnNpZ25lZCB0bykKK3sKKwl1bnNpZ25lZCBzdGFydCwgZW5kLCBuZXh0OworCXN0cnVjdCBidWZmZXJfaGVhZCAqYmgsICpoZWFkOworCWludCBlcnJvcjsKKworCWlmICghcGFnZV9oYXNfYnVmZmVycyhwYWdlKSkgeworCQllcnJvciA9IF9fYmxvY2tfd3JpdGVfYmVnaW4ocGFnZSwgZnJvbSwgdG8gLSBmcm9tLCBnZnMyX2Jsb2NrX21hcCk7CisJCWlmICh1bmxpa2VseShlcnJvcikpCisJCQlyZXR1cm4gZXJyb3I7CisKKwkJZW1wdHlfd3JpdGVfZW5kKHBhZ2UsIGZyb20sIHRvKTsKKwkJcmV0dXJuIDA7CisJfQorCisJYmggPSBoZWFkID0gcGFnZV9idWZmZXJzKHBhZ2UpOworCW5leHQgPSBlbmQgPSAwOworCXdoaWxlIChuZXh0IDwgZnJvbSkgeworCQluZXh0ICs9IGJoLT5iX3NpemU7CisJCWJoID0gYmgtPmJfdGhpc19wYWdlOworCX0KKwlzdGFydCA9IG5leHQ7CisJZG8geworCQluZXh0ICs9IGJoLT5iX3NpemU7CisJCWlmIChidWZmZXJfbWFwcGVkKGJoKSkgeworCQkJaWYgKGVuZCkgeworCQkJCWVycm9yID0gX19ibG9ja193cml0ZV9iZWdpbihwYWdlLCBzdGFydCwgZW5kIC0gc3RhcnQsCisJCQkJCQkJICAgIGdmczJfYmxvY2tfbWFwKTsKKwkJCQlpZiAodW5saWtlbHkoZXJyb3IpKQorCQkJCQlyZXR1cm4gZXJyb3I7CisJCQkJZW1wdHlfd3JpdGVfZW5kKHBhZ2UsIHN0YXJ0LCBlbmQpOworCQkJCWVuZCA9IDA7CisJCQl9CisJCQlzdGFydCA9IG5leHQ7CisJCX0KKwkJZWxzZQorCQkJZW5kID0gbmV4dDsKKwkJYmggPSBiaC0+Yl90aGlzX3BhZ2U7CisJfSB3aGlsZSAobmV4dCA8IHRvKTsKKworCWlmIChlbmQpIHsKKwkJZXJyb3IgPSBfX2Jsb2NrX3dyaXRlX2JlZ2luKHBhZ2UsIHN0YXJ0LCBlbmQgLSBzdGFydCwgZ2ZzMl9ibG9ja19tYXApOworCQlpZiAodW5saWtlbHkoZXJyb3IpKQorCQkJcmV0dXJuIGVycm9yOworCQllbXB0eV93cml0ZV9lbmQocGFnZSwgc3RhcnQsIGVuZCk7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgZmFsbG9jYXRlX2NodW5rKHN0cnVjdCBpbm9kZSAqaW5vZGUsIGxvZmZfdCBvZmZzZXQsIGxvZmZfdCBsZW4sCisJCQkgICBpbnQgbW9kZSkKK3sKKwlzdHJ1Y3QgZ2ZzMl9pbm9kZSAqaXAgPSBHRlMyX0koaW5vZGUpOworCXN0cnVjdCBidWZmZXJfaGVhZCAqZGliaDsKKwlpbnQgZXJyb3I7CisJdTY0IHN0YXJ0ID0gb2Zmc2V0ID4+IFBBR0VfQ0FDSEVfU0hJRlQ7CisJdW5zaWduZWQgaW50IHN0YXJ0X29mZnNldCA9IG9mZnNldCAmIH5QQUdFX0NBQ0hFX01BU0s7CisJdTY0IGVuZCA9IChvZmZzZXQgKyBsZW4gLSAxKSA+PiBQQUdFX0NBQ0hFX1NISUZUOworCXBnb2ZmX3QgY3VycjsKKwlzdHJ1Y3QgcGFnZSAqcGFnZTsKKwl1bnNpZ25lZCBpbnQgZW5kX29mZnNldCA9IChvZmZzZXQgKyBsZW4pICYgflBBR0VfQ0FDSEVfTUFTSzsKKwl1bnNpZ25lZCBpbnQgZnJvbSwgdG87CisKKwlpZiAoIWVuZF9vZmZzZXQpCisJCWVuZF9vZmZzZXQgPSBQQUdFX0NBQ0hFX1NJWkU7CisKKwllcnJvciA9IGdmczJfbWV0YV9pbm9kZV9idWZmZXIoaXAsICZkaWJoKTsKKwlpZiAodW5saWtlbHkoZXJyb3IpKQorCQlnb3RvIG91dDsKKworCWdmczJfdHJhbnNfYWRkX2JoKGlwLT5pX2dsLCBkaWJoLCAxKTsKKworCWlmIChnZnMyX2lzX3N0dWZmZWQoaXApKSB7CisJCWVycm9yID0gZ2ZzMl91bnN0dWZmX2Rpbm9kZShpcCwgTlVMTCk7CisJCWlmICh1bmxpa2VseShlcnJvcikpCisJCQlnb3RvIG91dDsKKwl9CisKKwljdXJyID0gc3RhcnQ7CisJb2Zmc2V0ID0gc3RhcnQgPDwgUEFHRV9DQUNIRV9TSElGVDsKKwlmcm9tID0gc3RhcnRfb2Zmc2V0OworCXRvID0gUEFHRV9DQUNIRV9TSVpFOworCXdoaWxlIChjdXJyIDw9IGVuZCkgeworCQlwYWdlID0gZ3JhYl9jYWNoZV9wYWdlX3dyaXRlX2JlZ2luKGlub2RlLT5pX21hcHBpbmcsIGN1cnIsCisJCQkJCQkgICBBT1BfRkxBR19OT0ZTKTsKKwkJaWYgKHVubGlrZWx5KCFwYWdlKSkgeworCQkJZXJyb3IgPSAtRU5PTUVNOworCQkJZ290byBvdXQ7CisJCX0KKworCQlpZiAoY3VyciA9PSBlbmQpCisJCQl0byA9IGVuZF9vZmZzZXQ7CisJCWVycm9yID0gd3JpdGVfZW1wdHlfYmxvY2tzKHBhZ2UsIGZyb20sIHRvKTsKKwkJaWYgKCFlcnJvciAmJiBvZmZzZXQgKyB0byA+IGlub2RlLT5pX3NpemUgJiYKKwkJICAgICEobW9kZSAmIEZBTExPQ19GTF9LRUVQX1NJWkUpKSB7CisJCQlpX3NpemVfd3JpdGUoaW5vZGUsIG9mZnNldCArIHRvKTsKKwkJfQorCQl1bmxvY2tfcGFnZShwYWdlKTsKKwkJcGFnZV9jYWNoZV9yZWxlYXNlKHBhZ2UpOworCQlpZiAoZXJyb3IpCisJCQlnb3RvIG91dDsKKwkJY3VycisrOworCQlvZmZzZXQgKz0gUEFHRV9DQUNIRV9TSVpFOworCQlmcm9tID0gMDsKKwl9CisKKwlnZnMyX2Rpbm9kZV9vdXQoaXAsIGRpYmgtPmJfZGF0YSk7CisJbWFya19pbm9kZV9kaXJ0eShpbm9kZSk7CisKKwlicmVsc2UoZGliaCk7CisKK291dDoKKwlyZXR1cm4gZXJyb3I7Cit9CisKK3N0YXRpYyB2b2lkIGNhbGNfbWF4X3Jlc2VydihzdHJ1Y3QgZ2ZzMl9pbm9kZSAqaXAsIGxvZmZfdCBtYXgsIGxvZmZfdCAqbGVuLAorCQkJICAgIHVuc2lnbmVkIGludCAqZGF0YV9ibG9ja3MsIHVuc2lnbmVkIGludCAqaW5kX2Jsb2NrcykKK3sKKwljb25zdCBzdHJ1Y3QgZ2ZzMl9zYmQgKnNkcCA9IEdGUzJfU0IoJmlwLT5pX2lub2RlKTsKKwl1bnNpZ25lZCBpbnQgbWF4X2Jsb2NrcyA9IGlwLT5pX2FsbG9jLT5hbF9yZ2QtPnJkX2ZyZWVfY2xvbmU7CisJdW5zaWduZWQgaW50IHRtcCwgbWF4X2RhdGEgPSBtYXhfYmxvY2tzIC0gMyAqIChzZHAtPnNkX21heF9oZWlnaHQgLSAxKTsKKworCWZvciAodG1wID0gbWF4X2RhdGE7IHRtcCA+IHNkcC0+c2RfZGlwdHJzOykgeworCQl0bXAgPSBESVZfUk9VTkRfVVAodG1wLCBzZHAtPnNkX2lucHRycyk7CisJCW1heF9kYXRhIC09IHRtcDsKKwl9CisJLyogVGhpcyBjYWxjdWxhdGlvbiBpc24ndCB0aGUgZXhhY3QgcmV2ZXJzZSBvZiBnZnMyX3dyaXRlX2NhbGNfcmVzZXJ2ZSwKKwkgICBzbyBpdCBtaWdodCBlbmQgdXAgd2l0aCBmZXdlciBkYXRhIGJsb2NrcyAqLworCWlmIChtYXhfZGF0YSA8PSAqZGF0YV9ibG9ja3MpCisJCXJldHVybjsKKwkqZGF0YV9ibG9ja3MgPSBtYXhfZGF0YTsKKwkqaW5kX2Jsb2NrcyA9IG1heF9ibG9ja3MgLSBtYXhfZGF0YTsKKwkqbGVuID0gKChsb2ZmX3QpbWF4X2RhdGEgLSAzKSA8PCBzZHAtPnNkX3NiLnNiX2JzaXplX3NoaWZ0OworCWlmICgqbGVuID4gbWF4KSB7CisJCSpsZW4gPSBtYXg7CisJCWdmczJfd3JpdGVfY2FsY19yZXNlcnYoaXAsIG1heCwgZGF0YV9ibG9ja3MsIGluZF9ibG9ja3MpOworCX0KK30KKworc3RhdGljIGxvbmcgZ2ZzMl9mYWxsb2NhdGUoc3RydWN0IGZpbGUgKmZpbGUsIGludCBtb2RlLCBsb2ZmX3Qgb2Zmc2V0LAorCQkJICAgbG9mZl90IGxlbikKK3sKKwlzdHJ1Y3QgaW5vZGUgKmlub2RlID0gZmlsZS0+Zl9wYXRoLmRlbnRyeS0+ZF9pbm9kZTsKKwlzdHJ1Y3QgZ2ZzMl9zYmQgKnNkcCA9IEdGUzJfU0IoaW5vZGUpOworCXN0cnVjdCBnZnMyX2lub2RlICppcCA9IEdGUzJfSShpbm9kZSk7CisJdW5zaWduZWQgaW50IGRhdGFfYmxvY2tzID0gMCwgaW5kX2Jsb2NrcyA9IDAsIHJibG9ja3M7CisJbG9mZl90IGJ5dGVzLCBtYXhfYnl0ZXM7CisJc3RydWN0IGdmczJfYWxsb2MgKmFsOworCWludCBlcnJvcjsKKwlsb2ZmX3QgbmV4dCA9IChvZmZzZXQgKyBsZW4gLSAxKSA+PiBzZHAtPnNkX3NiLnNiX2JzaXplX3NoaWZ0OworCW5leHQgPSAobmV4dCArIDEpIDw8IHNkcC0+c2Rfc2Iuc2JfYnNpemVfc2hpZnQ7CisKKwkvKiBXZSBvbmx5IHN1cHBvcnQgdGhlIEZBTExPQ19GTF9LRUVQX1NJWkUgbW9kZSAqLworCWlmIChtb2RlICYgfkZBTExPQ19GTF9LRUVQX1NJWkUpCisJCXJldHVybiAtRU9QTk9UU1VQUDsKKworCW9mZnNldCA9IChvZmZzZXQgPj4gc2RwLT5zZF9zYi5zYl9ic2l6ZV9zaGlmdCkgPDwKKwkJIHNkcC0+c2Rfc2Iuc2JfYnNpemVfc2hpZnQ7CisKKwlsZW4gPSBuZXh0IC0gb2Zmc2V0OworCWJ5dGVzID0gc2RwLT5zZF9tYXhfcmdfZGF0YSAqIHNkcC0+c2Rfc2Iuc2JfYnNpemUgLyAyOworCWlmICghYnl0ZXMpCisJCWJ5dGVzID0gVUlOVF9NQVg7CisKKwlnZnMyX2hvbGRlcl9pbml0KGlwLT5pX2dsLCBMTV9TVF9FWENMVVNJVkUsIDAsICZpcC0+aV9naCk7CisJZXJyb3IgPSBnZnMyX2dsb2NrX25xKCZpcC0+aV9naCk7CisJaWYgKHVubGlrZWx5KGVycm9yKSkKKwkJZ290byBvdXRfdW5pbml0OworCisJaWYgKCFnZnMyX3dyaXRlX2FsbG9jX3JlcXVpcmVkKGlwLCBvZmZzZXQsIGxlbikpCisJCWdvdG8gb3V0X3VubG9jazsKKworCXdoaWxlIChsZW4gPiAwKSB7CisJCWlmIChsZW4gPCBieXRlcykKKwkJCWJ5dGVzID0gbGVuOworCQlhbCA9IGdmczJfYWxsb2NfZ2V0KGlwKTsKKwkJaWYgKCFhbCkgeworCQkJZXJyb3IgPSAtRU5PTUVNOworCQkJZ290byBvdXRfdW5sb2NrOworCQl9CisKKwkJZXJyb3IgPSBnZnMyX3F1b3RhX2xvY2tfY2hlY2soaXApOworCQlpZiAoZXJyb3IpCisJCQlnb3RvIG91dF9hbGxvY19wdXQ7CisKK3JldHJ5OgorCQlnZnMyX3dyaXRlX2NhbGNfcmVzZXJ2KGlwLCBieXRlcywgJmRhdGFfYmxvY2tzLCAmaW5kX2Jsb2Nrcyk7CisKKwkJYWwtPmFsX3JlcXVlc3RlZCA9IGRhdGFfYmxvY2tzICsgaW5kX2Jsb2NrczsKKwkJZXJyb3IgPSBnZnMyX2lucGxhY2VfcmVzZXJ2ZShpcCk7CisJCWlmIChlcnJvcikgeworCQkJaWYgKGVycm9yID09IC1FTk9TUEMgJiYgYnl0ZXMgPiBzZHAtPnNkX3NiLnNiX2JzaXplKSB7CisJCQkJYnl0ZXMgPj49IDE7CisJCQkJZ290byByZXRyeTsKKwkJCX0KKwkJCWdvdG8gb3V0X3F1bmxvY2s7CisJCX0KKwkJbWF4X2J5dGVzID0gYnl0ZXM7CisJCWNhbGNfbWF4X3Jlc2VydihpcCwgbGVuLCAmbWF4X2J5dGVzLCAmZGF0YV9ibG9ja3MsICZpbmRfYmxvY2tzKTsKKwkJYWwtPmFsX3JlcXVlc3RlZCA9IGRhdGFfYmxvY2tzICsgaW5kX2Jsb2NrczsKKworCQlyYmxvY2tzID0gUkVTX0RJTk9ERSArIGluZF9ibG9ja3MgKyBSRVNfU1RBVEZTICsgUkVTX1FVT1RBICsKKwkJCSAgUkVTX1JHX0hEUiArIGdmczJfcmdfYmxvY2tzKGFsKTsKKwkJaWYgKGdmczJfaXNfamRhdGEoaXApKQorCQkJcmJsb2NrcyArPSBkYXRhX2Jsb2NrcyA/IGRhdGFfYmxvY2tzIDogMTsKKworCQllcnJvciA9IGdmczJfdHJhbnNfYmVnaW4oc2RwLCByYmxvY2tzLAorCQkJCQkgUEFHRV9DQUNIRV9TSVpFL3NkcC0+c2Rfc2Iuc2JfYnNpemUpOworCQlpZiAoZXJyb3IpCisJCQlnb3RvIG91dF90cmFuc19mYWlsOworCisJCWVycm9yID0gZmFsbG9jYXRlX2NodW5rKGlub2RlLCBvZmZzZXQsIG1heF9ieXRlcywgbW9kZSk7CisJCWdmczJfdHJhbnNfZW5kKHNkcCk7CisKKwkJaWYgKGVycm9yKQorCQkJZ290byBvdXRfdHJhbnNfZmFpbDsKKworCQlsZW4gLT0gbWF4X2J5dGVzOworCQlvZmZzZXQgKz0gbWF4X2J5dGVzOworCQlnZnMyX2lucGxhY2VfcmVsZWFzZShpcCk7CisJCWdmczJfcXVvdGFfdW5sb2NrKGlwKTsKKwkJZ2ZzMl9hbGxvY19wdXQoaXApOworCX0KKwlnb3RvIG91dF91bmxvY2s7CisKK291dF90cmFuc19mYWlsOgorCWdmczJfaW5wbGFjZV9yZWxlYXNlKGlwKTsKK291dF9xdW5sb2NrOgorCWdmczJfcXVvdGFfdW5sb2NrKGlwKTsKK291dF9hbGxvY19wdXQ6CisJZ2ZzMl9hbGxvY19wdXQoaXApOworb3V0X3VubG9jazoKKwlnZnMyX2dsb2NrX2RxKCZpcC0+aV9naCk7CitvdXRfdW5pbml0OgorCWdmczJfaG9sZGVyX3VuaW5pdCgmaXAtPmlfZ2gpOworCXJldHVybiBlcnJvcjsKK30KKwogI2lmZGVmIENPTkZJR19HRlMyX0ZTX0xPQ0tJTkdfRExNCiAKIC8qKgpAQCAtNzY1LDYgKzEwMjEsNyBAQAogCS5zcGxpY2VfcmVhZAk9IGdlbmVyaWNfZmlsZV9zcGxpY2VfcmVhZCwKIAkuc3BsaWNlX3dyaXRlCT0gZ2VuZXJpY19maWxlX3NwbGljZV93cml0ZSwKIAkuc2V0bGVhc2UJPSBnZnMyX3NldGxlYXNlLAorCS5mYWxsb2NhdGUJPSBnZnMyX2ZhbGxvY2F0ZSwKIH07CiAKIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgZ2ZzMl9kaXJfZm9wcyA9IHsKQEAgLTc5NCw2ICsxMDUxLDcgQEAKIAkuc3BsaWNlX3JlYWQJPSBnZW5lcmljX2ZpbGVfc3BsaWNlX3JlYWQsCiAJLnNwbGljZV93cml0ZQk9IGdlbmVyaWNfZmlsZV9zcGxpY2Vfd3JpdGUsCiAJLnNldGxlYXNlCT0gZ2VuZXJpY19zZXRsZWFzZSwKKwkuZmFsbG9jYXRlCT0gZ2ZzMl9mYWxsb2NhdGUsCiB9OwogCiBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGdmczJfZGlyX2ZvcHNfbm9sb2NrID0gewpkaWZmIC0tZ2l0IGEvZnMvZ2ZzMi9pbm9kZS5jIGIvZnMvZ2ZzMi9pbm9kZS5jCmluZGV4IDIyMzJiM2MuLjdhYTdkNGYgMTAwNjQ0Ci0tLSBhL2ZzL2dmczIvaW5vZGUuYworKysgYi9mcy9nZnMyL2lub2RlLmMKQEAgLTc0LDE2ICs3NCwxNCBAQAogfQogCiAvKioKLSAqIEdGUzIgbG9va3VwIGNvZGUgZmlsbHMgaW4gdmZzIGlub2RlIGNvbnRlbnRzIGJhc2VkIG9uIGluZm8gb2J0YWluZWQKLSAqIGZyb20gZGlyZWN0b3J5IGVudHJ5IGluc2lkZSBnZnMyX2lub2RlX2xvb2t1cCgpLiBUaGlzIGhhcyBjYXVzZWQgaXNzdWVzCi0gKiB3aXRoIE5GUyBjb2RlIHBhdGggc2luY2UgaXRzIGdldF9kZW50cnkgcm91dGluZSBkb2Vzbid0IGhhdmUgdGhlIHJlbGV2YW50Ci0gKiBkaXJlY3RvcnkgZW50cnkgd2hlbiBnZnMyX2lub2RlX2xvb2t1cCgpIGlzIGludm9rZWQuIFBhcnQgb2YgdGhlIGNvZGUKLSAqIHNlZ21lbnQgaW5zaWRlIGdmczJfaW5vZGVfbG9va3VwIGNvZGUgbmVlZHMgdG8gZ2V0IG1vdmVkIGFyb3VuZC4KKyAqIGdmczJfc2V0X2lvcCAtIFNldHMgaW5vZGUgb3BlcmF0aW9ucworICogQGlub2RlOiBUaGUgaW5vZGUgd2l0aCBjb3JyZWN0IGlfbW9kZSBmaWxsZWQgaW4KICAqCi0gKiBDbGVhcnMgSV9ORVcgYXMgd2VsbC4KLSAqKi8KKyAqIEdGUzIgbG9va3VwIGNvZGUgZmlsbHMgaW4gdmZzIGlub2RlIGNvbnRlbnRzIGJhc2VkIG9uIGluZm8gb2J0YWluZWQKKyAqIGZyb20gZGlyZWN0b3J5IGVudHJ5IGluc2lkZSBnZnMyX2lub2RlX2xvb2t1cCgpLgorICovCiAKLXZvaWQgZ2ZzMl9zZXRfaW9wKHN0cnVjdCBpbm9kZSAqaW5vZGUpCitzdGF0aWMgdm9pZCBnZnMyX3NldF9pb3Aoc3RydWN0IGlub2RlICppbm9kZSkKIHsKIAlzdHJ1Y3QgZ2ZzMl9zYmQgKnNkcCA9IEdGUzJfU0IoaW5vZGUpOwogCXVtb2RlX3QgbW9kZSA9IGlub2RlLT5pX21vZGU7CkBAIC0xMDYsOCArMTA0LDYgQEAKIAkJaW5vZGUtPmlfb3AgPSAmZ2ZzMl9maWxlX2lvcHM7CiAJCWluaXRfc3BlY2lhbF9pbm9kZShpbm9kZSwgaW5vZGUtPmlfbW9kZSwgaW5vZGUtPmlfcmRldik7CiAJfQotCi0JdW5sb2NrX25ld19pbm9kZShpbm9kZSk7CiB9CiAKIC8qKgpAQCAtMTE5LDEwICsxMTUsOCBAQAogICogUmV0dXJuczogQSBWRlMgaW5vZGUsIG9yIGFuIGVycm9yCiAgKi8KIAotc3RydWN0IGlub2RlICpnZnMyX2lub2RlX2xvb2t1cChzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLAotCQkJCXVuc2lnbmVkIGludCB0eXBlLAotCQkJCXU2NCBub19hZGRyLAotCQkJCXU2NCBub19mb3JtYWxfaW5vKQorc3RydWN0IGlub2RlICpnZnMyX2lub2RlX2xvb2t1cChzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCB1bnNpZ25lZCBpbnQgdHlwZSwKKwkJCQl1NjQgbm9fYWRkciwgdTY0IG5vX2Zvcm1hbF9pbm8pCiB7CiAJc3RydWN0IGlub2RlICppbm9kZTsKIAlzdHJ1Y3QgZ2ZzMl9pbm9kZSAqaXA7CkBAIC0xNTIsNTEgKzE0NiwzNyBAQAogCQllcnJvciA9IGdmczJfZ2xvY2tfbnFfaW5pdChpb19nbCwgTE1fU1RfU0hBUkVELCBHTF9FWEFDVCwgJmlwLT5pX2lvcGVuX2doKTsKIAkJaWYgKHVubGlrZWx5KGVycm9yKSkKIAkJCWdvdG8gZmFpbF9pb3BlbjsKLQkJaXAtPmlfaW9wZW5fZ2guZ2hfZ2wtPmdsX29iamVjdCA9IGlwOwogCisJCWlwLT5pX2lvcGVuX2doLmdoX2dsLT5nbF9vYmplY3QgPSBpcDsKIAkJZ2ZzMl9nbG9ja19wdXQoaW9fZ2wpOwogCQlpb19nbCA9IE5VTEw7CiAKLQkJaWYgKCh0eXBlID09IERUX1VOS05PV04pICYmIChub19mb3JtYWxfaW5vID09IDApKQotCQkJZ290byBnZnMyX25mc2J5cGFzczsKLQotCQlpbm9kZS0+aV9tb2RlID0gRFQySUYodHlwZSk7Ci0KLQkJLyoKLQkJICogV2UgbXVzdCByZWFkIHRoZSBpbm9kZSBpbiBvcmRlciB0byB3b3JrIG91dCBpdHMgdHlwZSBpbgotCQkgKiB0aGlzIGNhc2UuIE5vdGUgdGhhdCB0aGlzIGRvZXNuJ3QgaGFwcGVuIG9mdGVuIGFzIHdlIG5vcm1hbGx5Ci0JCSAqIGtub3cgdGhlIHR5cGUgYmVmb3JlaGFuZC4gVGhpcyBjb2RlIHBhdGggb25seSBvY2N1cnMgZHVyaW5nCi0JCSAqIHVubGlua2VkIGlub2RlIHJlY292ZXJ5ICh3aGVyZSBpdCBpcyBzYWZlIHRvIGRvIHRoaXMgZ2xvY2ssCi0JCSAqIHdoaWNoIGlzIG5vdCB0cnVlIGluIHRoZSBnZW5lcmFsIGNhc2UpLgotCQkgKi8KIAkJaWYgKHR5cGUgPT0gRFRfVU5LTk9XTikgewotCQkJc3RydWN0IGdmczJfaG9sZGVyIGdoOwotCQkJZXJyb3IgPSBnZnMyX2dsb2NrX25xX2luaXQoaXAtPmlfZ2wsIExNX1NUX0VYQ0xVU0lWRSwgMCwgJmdoKTsKLQkJCWlmICh1bmxpa2VseShlcnJvcikpCi0JCQkJZ290byBmYWlsX2dsb2NrOwotCQkJLyogSW5vZGUgaXMgbm93IHVwdG9kYXRlICovCi0JCQlnZnMyX2dsb2NrX2RxX3VuaW5pdCgmZ2gpOworCQkJLyogSW5vZGUgZ2xvY2sgbXVzdCBiZSBsb2NrZWQgYWxyZWFkeSAqLworCQkJZXJyb3IgPSBnZnMyX2lub2RlX3JlZnJlc2goR0ZTMl9JKGlub2RlKSk7CisJCQlpZiAoZXJyb3IpCisJCQkJZ290byBmYWlsX3JlZnJlc2g7CisJCX0gZWxzZSB7CisJCQlpbm9kZS0+aV9tb2RlID0gRFQySUYodHlwZSk7CiAJCX0KIAogCQlnZnMyX3NldF9pb3AoaW5vZGUpOworCQl1bmxvY2tfbmV3X2lub2RlKGlub2RlKTsKIAl9CiAKLWdmczJfbmZzYnlwYXNzOgogCXJldHVybiBpbm9kZTsKLWZhaWxfZ2xvY2s6Ci0JZ2ZzMl9nbG9ja19kcSgmaXAtPmlfaW9wZW5fZ2gpOworCitmYWlsX3JlZnJlc2g6CisJaXAtPmlfaW9wZW5fZ2guZ2hfZ2wtPmdsX29iamVjdCA9IE5VTEw7CisJZ2ZzMl9nbG9ja19kcV91bmluaXQoJmlwLT5pX2lvcGVuX2doKTsKIGZhaWxfaW9wZW46CiAJaWYgKGlvX2dsKQogCQlnZnMyX2dsb2NrX3B1dChpb19nbCk7CiBmYWlsX3B1dDoKLQlpZiAoaW5vZGUtPmlfc3RhdGUgJiBJX05FVykKLQkJaXAtPmlfZ2wtPmdsX29iamVjdCA9IE5VTEw7CisJaXAtPmlfZ2wtPmdsX29iamVjdCA9IE5VTEw7CiAJZ2ZzMl9nbG9ja19wdXQoaXAtPmlfZ2wpOwogZmFpbDoKLQlpZiAoaW5vZGUtPmlfc3RhdGUgJiBJX05FVykKLQkJaWdldF9mYWlsZWQoaW5vZGUpOwotCWVsc2UKLQkJaXB1dChpbm9kZSk7CisJaWdldF9mYWlsZWQoaW5vZGUpOwogCXJldHVybiBFUlJfUFRSKGVycm9yKTsKIH0KIApAQCAtMjIxLDE0ICsyMDEsNiBAQAogCWlmIChJU19FUlIoaW5vZGUpKQogCQlnb3RvIGZhaWw7CiAKLQllcnJvciA9IGdmczJfaW5vZGVfcmVmcmVzaChHRlMyX0koaW5vZGUpKTsKLQlpZiAoZXJyb3IpCi0JCWdvdG8gZmFpbF9pcHV0OwotCi0JLyogUGljayB1cCB0aGUgd29ya3Mgd2UgYnlwYXNzIGluIGdmczJfaW5vZGVfbG9va3VwICovCi0JaWYgKGlub2RlLT5pX3N0YXRlICYgSV9ORVcpIAotCQlnZnMyX3NldF9pb3AoaW5vZGUpOwotCiAJLyogVHdvIGV4dHJhIGNoZWNrcyBmb3IgTkZTIG9ubHkgKi8KIAlpZiAobm9fZm9ybWFsX2lubykgewogCQllcnJvciA9IC1FU1RBTEU7CmRpZmYgLS1naXQgYS9mcy9nZnMyL2lub2RlLmggYi9mcy9nZnMyL2lub2RlLmgKaW5kZXggNzMyYTE4My4uM2UwMGE2NiAxMDA2NDQKLS0tIGEvZnMvZ2ZzMi9pbm9kZS5oCisrKyBiL2ZzL2dmczIvaW5vZGUuaApAQCAtOTYsNyArOTYsNiBAQAogCXJldHVybiAtRUlPOwogfQogCi1leHRlcm4gdm9pZCBnZnMyX3NldF9pb3Aoc3RydWN0IGlub2RlICppbm9kZSk7CiBleHRlcm4gc3RydWN0IGlub2RlICpnZnMyX2lub2RlX2xvb2t1cChzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCB1bnNpZ25lZCB0eXBlLCAKIAkJCQkgICAgICAgdTY0IG5vX2FkZHIsIHU2NCBub19mb3JtYWxfaW5vKTsKIGV4dGVybiBzdHJ1Y3QgaW5vZGUgKmdmczJfbG9va3VwX2J5X2ludW0oc3RydWN0IGdmczJfc2JkICpzZHAsIHU2NCBub19hZGRyLApkaWZmIC0tZ2l0IGEvZnMvZ2ZzMi9vcHNfaW5vZGUuYyBiL2ZzL2dmczIvb3BzX2lub2RlLmMKaW5kZXggMDQwYjVhMi4uZDhiMjZhYyAxMDA2NDQKLS0tIGEvZnMvZ2ZzMi9vcHNfaW5vZGUuYworKysgYi9mcy9nZnMyL29wc19pbm9kZS5jCkBAIC0xOCw4ICsxOCw2IEBACiAjaW5jbHVkZSA8bGludXgvZ2ZzMl9vbmRpc2suaD4KICNpbmNsdWRlIDxsaW51eC9jcmMzMi5oPgogI2luY2x1ZGUgPGxpbnV4L2ZpZW1hcC5oPgotI2luY2x1ZGUgPGxpbnV4L3N3YXAuaD4KLSNpbmNsdWRlIDxsaW51eC9mYWxsb2MuaD4KICNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgogCiAjaW5jbHVkZSAiZ2ZzMi5oIgpAQCAtMTI1NywyNjEgKzEyNTUsNiBAQAogCXJldHVybiByZXQ7CiB9CiAKLXN0YXRpYyB2b2lkIGVtcHR5X3dyaXRlX2VuZChzdHJ1Y3QgcGFnZSAqcGFnZSwgdW5zaWduZWQgZnJvbSwKLQkJCSAgIHVuc2lnbmVkIHRvKQotewotCXN0cnVjdCBnZnMyX2lub2RlICppcCA9IEdGUzJfSShwYWdlLT5tYXBwaW5nLT5ob3N0KTsKLQotCXBhZ2VfemVyb19uZXdfYnVmZmVycyhwYWdlLCBmcm9tLCB0byk7Ci0JZmx1c2hfZGNhY2hlX3BhZ2UocGFnZSk7Ci0JbWFya19wYWdlX2FjY2Vzc2VkKHBhZ2UpOwotCi0JaWYgKCFnZnMyX2lzX3dyaXRlYmFjayhpcCkpCi0JCWdmczJfcGFnZV9hZGRfZGF0YWJ1ZnMoaXAsIHBhZ2UsIGZyb20sIHRvKTsKLQotCWJsb2NrX2NvbW1pdF93cml0ZShwYWdlLCBmcm9tLCB0byk7Ci19Ci0KLQotc3RhdGljIGludCB3cml0ZV9lbXB0eV9ibG9ja3Moc3RydWN0IHBhZ2UgKnBhZ2UsIHVuc2lnbmVkIGZyb20sIHVuc2lnbmVkIHRvKQotewotCXVuc2lnbmVkIHN0YXJ0LCBlbmQsIG5leHQ7Ci0Jc3RydWN0IGJ1ZmZlcl9oZWFkICpiaCwgKmhlYWQ7Ci0JaW50IGVycm9yOwotCi0JaWYgKCFwYWdlX2hhc19idWZmZXJzKHBhZ2UpKSB7Ci0JCWVycm9yID0gX19ibG9ja193cml0ZV9iZWdpbihwYWdlLCBmcm9tLCB0byAtIGZyb20sIGdmczJfYmxvY2tfbWFwKTsKLQkJaWYgKHVubGlrZWx5KGVycm9yKSkKLQkJCXJldHVybiBlcnJvcjsKLQotCQllbXB0eV93cml0ZV9lbmQocGFnZSwgZnJvbSwgdG8pOwotCQlyZXR1cm4gMDsKLQl9Ci0KLQliaCA9IGhlYWQgPSBwYWdlX2J1ZmZlcnMocGFnZSk7Ci0JbmV4dCA9IGVuZCA9IDA7Ci0Jd2hpbGUgKG5leHQgPCBmcm9tKSB7Ci0JCW5leHQgKz0gYmgtPmJfc2l6ZTsKLQkJYmggPSBiaC0+Yl90aGlzX3BhZ2U7Ci0JfQotCXN0YXJ0ID0gbmV4dDsKLQlkbyB7Ci0JCW5leHQgKz0gYmgtPmJfc2l6ZTsKLQkJaWYgKGJ1ZmZlcl9tYXBwZWQoYmgpKSB7Ci0JCQlpZiAoZW5kKSB7Ci0JCQkJZXJyb3IgPSBfX2Jsb2NrX3dyaXRlX2JlZ2luKHBhZ2UsIHN0YXJ0LCBlbmQgLSBzdGFydCwKLQkJCQkJCQkgICAgZ2ZzMl9ibG9ja19tYXApOwotCQkJCWlmICh1bmxpa2VseShlcnJvcikpCi0JCQkJCXJldHVybiBlcnJvcjsKLQkJCQllbXB0eV93cml0ZV9lbmQocGFnZSwgc3RhcnQsIGVuZCk7Ci0JCQkJZW5kID0gMDsKLQkJCX0KLQkJCXN0YXJ0ID0gbmV4dDsKLQkJfQotCQllbHNlCi0JCQllbmQgPSBuZXh0OwotCQliaCA9IGJoLT5iX3RoaXNfcGFnZTsKLQl9IHdoaWxlIChuZXh0IDwgdG8pOwotCi0JaWYgKGVuZCkgewotCQllcnJvciA9IF9fYmxvY2tfd3JpdGVfYmVnaW4ocGFnZSwgc3RhcnQsIGVuZCAtIHN0YXJ0LCBnZnMyX2Jsb2NrX21hcCk7Ci0JCWlmICh1bmxpa2VseShlcnJvcikpCi0JCQlyZXR1cm4gZXJyb3I7Ci0JCWVtcHR5X3dyaXRlX2VuZChwYWdlLCBzdGFydCwgZW5kKTsKLQl9Ci0KLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIGludCBmYWxsb2NhdGVfY2h1bmsoc3RydWN0IGlub2RlICppbm9kZSwgbG9mZl90IG9mZnNldCwgbG9mZl90IGxlbiwKLQkJCSAgIGludCBtb2RlKQotewotCXN0cnVjdCBnZnMyX2lub2RlICppcCA9IEdGUzJfSShpbm9kZSk7Ci0Jc3RydWN0IGJ1ZmZlcl9oZWFkICpkaWJoOwotCWludCBlcnJvcjsKLQl1NjQgc3RhcnQgPSBvZmZzZXQgPj4gUEFHRV9DQUNIRV9TSElGVDsKLQl1bnNpZ25lZCBpbnQgc3RhcnRfb2Zmc2V0ID0gb2Zmc2V0ICYgflBBR0VfQ0FDSEVfTUFTSzsKLQl1NjQgZW5kID0gKG9mZnNldCArIGxlbiAtIDEpID4+IFBBR0VfQ0FDSEVfU0hJRlQ7Ci0JcGdvZmZfdCBjdXJyOwotCXN0cnVjdCBwYWdlICpwYWdlOwotCXVuc2lnbmVkIGludCBlbmRfb2Zmc2V0ID0gKG9mZnNldCArIGxlbikgJiB+UEFHRV9DQUNIRV9NQVNLOwotCXVuc2lnbmVkIGludCBmcm9tLCB0bzsKLQotCWlmICghZW5kX29mZnNldCkKLQkJZW5kX29mZnNldCA9IFBBR0VfQ0FDSEVfU0laRTsKLQotCWVycm9yID0gZ2ZzMl9tZXRhX2lub2RlX2J1ZmZlcihpcCwgJmRpYmgpOwotCWlmICh1bmxpa2VseShlcnJvcikpCi0JCWdvdG8gb3V0OwotCi0JZ2ZzMl90cmFuc19hZGRfYmgoaXAtPmlfZ2wsIGRpYmgsIDEpOwotCi0JaWYgKGdmczJfaXNfc3R1ZmZlZChpcCkpIHsKLQkJZXJyb3IgPSBnZnMyX3Vuc3R1ZmZfZGlub2RlKGlwLCBOVUxMKTsKLQkJaWYgKHVubGlrZWx5KGVycm9yKSkKLQkJCWdvdG8gb3V0OwotCX0KLQotCWN1cnIgPSBzdGFydDsKLQlvZmZzZXQgPSBzdGFydCA8PCBQQUdFX0NBQ0hFX1NISUZUOwotCWZyb20gPSBzdGFydF9vZmZzZXQ7Ci0JdG8gPSBQQUdFX0NBQ0hFX1NJWkU7Ci0Jd2hpbGUgKGN1cnIgPD0gZW5kKSB7Ci0JCXBhZ2UgPSBncmFiX2NhY2hlX3BhZ2Vfd3JpdGVfYmVnaW4oaW5vZGUtPmlfbWFwcGluZywgY3VyciwKLQkJCQkJCSAgIEFPUF9GTEFHX05PRlMpOwotCQlpZiAodW5saWtlbHkoIXBhZ2UpKSB7Ci0JCQllcnJvciA9IC1FTk9NRU07Ci0JCQlnb3RvIG91dDsKLQkJfQotCi0JCWlmIChjdXJyID09IGVuZCkKLQkJCXRvID0gZW5kX29mZnNldDsKLQkJZXJyb3IgPSB3cml0ZV9lbXB0eV9ibG9ja3MocGFnZSwgZnJvbSwgdG8pOwotCQlpZiAoIWVycm9yICYmIG9mZnNldCArIHRvID4gaW5vZGUtPmlfc2l6ZSAmJgotCQkgICAgIShtb2RlICYgRkFMTE9DX0ZMX0tFRVBfU0laRSkpIHsKLQkJCWlfc2l6ZV93cml0ZShpbm9kZSwgb2Zmc2V0ICsgdG8pOwotCQl9Ci0JCXVubG9ja19wYWdlKHBhZ2UpOwotCQlwYWdlX2NhY2hlX3JlbGVhc2UocGFnZSk7Ci0JCWlmIChlcnJvcikKLQkJCWdvdG8gb3V0OwotCQljdXJyKys7Ci0JCW9mZnNldCArPSBQQUdFX0NBQ0hFX1NJWkU7Ci0JCWZyb20gPSAwOwotCX0KLQotCWdmczJfZGlub2RlX291dChpcCwgZGliaC0+Yl9kYXRhKTsKLQltYXJrX2lub2RlX2RpcnR5KGlub2RlKTsKLQotCWJyZWxzZShkaWJoKTsKLQotb3V0OgotCXJldHVybiBlcnJvcjsKLX0KLQotc3RhdGljIHZvaWQgY2FsY19tYXhfcmVzZXJ2KHN0cnVjdCBnZnMyX2lub2RlICppcCwgbG9mZl90IG1heCwgbG9mZl90ICpsZW4sCi0JCQkgICAgdW5zaWduZWQgaW50ICpkYXRhX2Jsb2NrcywgdW5zaWduZWQgaW50ICppbmRfYmxvY2tzKQotewotCWNvbnN0IHN0cnVjdCBnZnMyX3NiZCAqc2RwID0gR0ZTMl9TQigmaXAtPmlfaW5vZGUpOwotCXVuc2lnbmVkIGludCBtYXhfYmxvY2tzID0gaXAtPmlfYWxsb2MtPmFsX3JnZC0+cmRfZnJlZV9jbG9uZTsKLQl1bnNpZ25lZCBpbnQgdG1wLCBtYXhfZGF0YSA9IG1heF9ibG9ja3MgLSAzICogKHNkcC0+c2RfbWF4X2hlaWdodCAtIDEpOwotCi0JZm9yICh0bXAgPSBtYXhfZGF0YTsgdG1wID4gc2RwLT5zZF9kaXB0cnM7KSB7Ci0JCXRtcCA9IERJVl9ST1VORF9VUCh0bXAsIHNkcC0+c2RfaW5wdHJzKTsKLQkJbWF4X2RhdGEgLT0gdG1wOwotCX0KLQkvKiBUaGlzIGNhbGN1bGF0aW9uIGlzbid0IHRoZSBleGFjdCByZXZlcnNlIG9mIGdmczJfd3JpdGVfY2FsY19yZXNlcnZlLAotCSAgIHNvIGl0IG1pZ2h0IGVuZCB1cCB3aXRoIGZld2VyIGRhdGEgYmxvY2tzICovCi0JaWYgKG1heF9kYXRhIDw9ICpkYXRhX2Jsb2NrcykKLQkJcmV0dXJuOwotCSpkYXRhX2Jsb2NrcyA9IG1heF9kYXRhOwotCSppbmRfYmxvY2tzID0gbWF4X2Jsb2NrcyAtIG1heF9kYXRhOwotCSpsZW4gPSAoKGxvZmZfdCltYXhfZGF0YSAtIDMpIDw8IHNkcC0+c2Rfc2Iuc2JfYnNpemVfc2hpZnQ7Ci0JaWYgKCpsZW4gPiBtYXgpIHsKLQkJKmxlbiA9IG1heDsKLQkJZ2ZzMl93cml0ZV9jYWxjX3Jlc2VydihpcCwgbWF4LCBkYXRhX2Jsb2NrcywgaW5kX2Jsb2Nrcyk7Ci0JfQotfQotCi1zdGF0aWMgbG9uZyBnZnMyX2ZhbGxvY2F0ZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBpbnQgbW9kZSwgbG9mZl90IG9mZnNldCwKLQkJCSAgIGxvZmZfdCBsZW4pCi17Ci0Jc3RydWN0IGdmczJfc2JkICpzZHAgPSBHRlMyX1NCKGlub2RlKTsKLQlzdHJ1Y3QgZ2ZzMl9pbm9kZSAqaXAgPSBHRlMyX0koaW5vZGUpOwotCXVuc2lnbmVkIGludCBkYXRhX2Jsb2NrcyA9IDAsIGluZF9ibG9ja3MgPSAwLCByYmxvY2tzOwotCWxvZmZfdCBieXRlcywgbWF4X2J5dGVzOwotCXN0cnVjdCBnZnMyX2FsbG9jICphbDsKLQlpbnQgZXJyb3I7Ci0JbG9mZl90IG5leHQgPSAob2Zmc2V0ICsgbGVuIC0gMSkgPj4gc2RwLT5zZF9zYi5zYl9ic2l6ZV9zaGlmdDsKLQluZXh0ID0gKG5leHQgKyAxKSA8PCBzZHAtPnNkX3NiLnNiX2JzaXplX3NoaWZ0OwotCi0JLyogV2Ugb25seSBzdXBwb3J0IHRoZSBGQUxMT0NfRkxfS0VFUF9TSVpFIG1vZGUgKi8KLQlpZiAobW9kZSAmJiAobW9kZSAhPSBGQUxMT0NfRkxfS0VFUF9TSVpFKSkKLQkJcmV0dXJuIC1FT1BOT1RTVVBQOwotCi0Jb2Zmc2V0ID0gKG9mZnNldCA+PiBzZHAtPnNkX3NiLnNiX2JzaXplX3NoaWZ0KSA8PAotCQkgc2RwLT5zZF9zYi5zYl9ic2l6ZV9zaGlmdDsKLQotCWxlbiA9IG5leHQgLSBvZmZzZXQ7Ci0JYnl0ZXMgPSBzZHAtPnNkX21heF9yZ19kYXRhICogc2RwLT5zZF9zYi5zYl9ic2l6ZSAvIDI7Ci0JaWYgKCFieXRlcykKLQkJYnl0ZXMgPSBVSU5UX01BWDsKLQotCWdmczJfaG9sZGVyX2luaXQoaXAtPmlfZ2wsIExNX1NUX0VYQ0xVU0lWRSwgMCwgJmlwLT5pX2doKTsKLQllcnJvciA9IGdmczJfZ2xvY2tfbnEoJmlwLT5pX2doKTsKLQlpZiAodW5saWtlbHkoZXJyb3IpKQotCQlnb3RvIG91dF91bmluaXQ7Ci0KLQlpZiAoIWdmczJfd3JpdGVfYWxsb2NfcmVxdWlyZWQoaXAsIG9mZnNldCwgbGVuKSkKLQkJZ290byBvdXRfdW5sb2NrOwotCi0Jd2hpbGUgKGxlbiA+IDApIHsKLQkJaWYgKGxlbiA8IGJ5dGVzKQotCQkJYnl0ZXMgPSBsZW47Ci0JCWFsID0gZ2ZzMl9hbGxvY19nZXQoaXApOwotCQlpZiAoIWFsKSB7Ci0JCQllcnJvciA9IC1FTk9NRU07Ci0JCQlnb3RvIG91dF91bmxvY2s7Ci0JCX0KLQotCQllcnJvciA9IGdmczJfcXVvdGFfbG9ja19jaGVjayhpcCk7Ci0JCWlmIChlcnJvcikKLQkJCWdvdG8gb3V0X2FsbG9jX3B1dDsKLQotcmV0cnk6Ci0JCWdmczJfd3JpdGVfY2FsY19yZXNlcnYoaXAsIGJ5dGVzLCAmZGF0YV9ibG9ja3MsICZpbmRfYmxvY2tzKTsKLQotCQlhbC0+YWxfcmVxdWVzdGVkID0gZGF0YV9ibG9ja3MgKyBpbmRfYmxvY2tzOwotCQllcnJvciA9IGdmczJfaW5wbGFjZV9yZXNlcnZlKGlwKTsKLQkJaWYgKGVycm9yKSB7Ci0JCQlpZiAoZXJyb3IgPT0gLUVOT1NQQyAmJiBieXRlcyA+IHNkcC0+c2Rfc2Iuc2JfYnNpemUpIHsKLQkJCQlieXRlcyA+Pj0gMTsKLQkJCQlnb3RvIHJldHJ5OwotCQkJfQotCQkJZ290byBvdXRfcXVubG9jazsKLQkJfQotCQltYXhfYnl0ZXMgPSBieXRlczsKLQkJY2FsY19tYXhfcmVzZXJ2KGlwLCBsZW4sICZtYXhfYnl0ZXMsICZkYXRhX2Jsb2NrcywgJmluZF9ibG9ja3MpOwotCQlhbC0+YWxfcmVxdWVzdGVkID0gZGF0YV9ibG9ja3MgKyBpbmRfYmxvY2tzOwotCi0JCXJibG9ja3MgPSBSRVNfRElOT0RFICsgaW5kX2Jsb2NrcyArIFJFU19TVEFURlMgKyBSRVNfUVVPVEEgKwotCQkJICBSRVNfUkdfSERSICsgZ2ZzMl9yZ19ibG9ja3MoYWwpOwotCQlpZiAoZ2ZzMl9pc19qZGF0YShpcCkpCi0JCQlyYmxvY2tzICs9IGRhdGFfYmxvY2tzID8gZGF0YV9ibG9ja3MgOiAxOwotCi0JCWVycm9yID0gZ2ZzMl90cmFuc19iZWdpbihzZHAsIHJibG9ja3MsCi0JCQkJCSBQQUdFX0NBQ0hFX1NJWkUvc2RwLT5zZF9zYi5zYl9ic2l6ZSk7Ci0JCWlmIChlcnJvcikKLQkJCWdvdG8gb3V0X3RyYW5zX2ZhaWw7Ci0KLQkJZXJyb3IgPSBmYWxsb2NhdGVfY2h1bmsoaW5vZGUsIG9mZnNldCwgbWF4X2J5dGVzLCBtb2RlKTsKLQkJZ2ZzMl90cmFuc19lbmQoc2RwKTsKLQotCQlpZiAoZXJyb3IpCi0JCQlnb3RvIG91dF90cmFuc19mYWlsOwotCi0JCWxlbiAtPSBtYXhfYnl0ZXM7Ci0JCW9mZnNldCArPSBtYXhfYnl0ZXM7Ci0JCWdmczJfaW5wbGFjZV9yZWxlYXNlKGlwKTsKLQkJZ2ZzMl9xdW90YV91bmxvY2soaXApOwotCQlnZnMyX2FsbG9jX3B1dChpcCk7Ci0JfQotCWdvdG8gb3V0X3VubG9jazsKLQotb3V0X3RyYW5zX2ZhaWw6Ci0JZ2ZzMl9pbnBsYWNlX3JlbGVhc2UoaXApOwotb3V0X3F1bmxvY2s6Ci0JZ2ZzMl9xdW90YV91bmxvY2soaXApOwotb3V0X2FsbG9jX3B1dDoKLQlnZnMyX2FsbG9jX3B1dChpcCk7Ci1vdXRfdW5sb2NrOgotCWdmczJfZ2xvY2tfZHEoJmlwLT5pX2doKTsKLW91dF91bmluaXQ6Ci0JZ2ZzMl9ob2xkZXJfdW5pbml0KCZpcC0+aV9naCk7Ci0JcmV0dXJuIGVycm9yOwotfQotCi0KIHN0YXRpYyBpbnQgZ2ZzMl9maWVtYXAoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpZW1hcF9leHRlbnRfaW5mbyAqZmllaW5mbywKIAkJICAgICAgIHU2NCBzdGFydCwgdTY0IGxlbikKIHsKQEAgLTE1NjIsNyArMTMwNSw2IEBACiAJLmdldHhhdHRyID0gZ2ZzMl9nZXR4YXR0ciwKIAkubGlzdHhhdHRyID0gZ2ZzMl9saXN0eGF0dHIsCiAJLnJlbW92ZXhhdHRyID0gZ2ZzMl9yZW1vdmV4YXR0ciwKLQkuZmFsbG9jYXRlID0gZ2ZzMl9mYWxsb2NhdGUsCiAJLmZpZW1hcCA9IGdmczJfZmllbWFwLAogfTsKIApkaWZmIC0tZ2l0IGEvZnMvZ2ZzMi9zdXBlci5jIGIvZnMvZ2ZzMi9zdXBlci5jCmluZGV4IDE2YzJlY2EuLmVjNzNlZDcgMTAwNjQ0Ci0tLSBhL2ZzL2dmczIvc3VwZXIuYworKysgYi9mcy9nZnMyL3N1cGVyLmMKQEAgLTEzMzYsNiArMTMzNiw3IEBACiAJaWYgKGVycm9yKQogCQlnb3RvIG91dF90cnVuY2F0ZTsKIAorCWlwLT5pX2lvcGVuX2doLmdoX2ZsYWdzIHw9IEdMX05PQ0FDSEU7CiAJZ2ZzMl9nbG9ja19kcV93YWl0KCZpcC0+aV9pb3Blbl9naCk7CiAJZ2ZzMl9ob2xkZXJfcmVpbml0KExNX1NUX0VYQ0xVU0lWRSwgTE1fRkxBR19UUllfMUNCIHwgR0xfTk9DQUNIRSwgJmlwLT5pX2lvcGVuX2doKTsKIAllcnJvciA9IGdmczJfZ2xvY2tfbnEoJmlwLT5pX2lvcGVuX2doKTsKZGlmZiAtLWdpdCBhL2ZzL2hmc3BsdXMvZXh0ZW50cy5jIGIvZnMvaGZzcGx1cy9leHRlbnRzLmMKaW5kZXggNTJhMGJjYS4uYjE5OTFhMiAxMDA2NDQKLS0tIGEvZnMvaGZzcGx1cy9leHRlbnRzLmMKKysrIGIvZnMvaGZzcGx1cy9leHRlbnRzLmMKQEAgLTM5Nyw4ICszOTcsOCBAQAogCXUzMiBzdGFydCwgbGVuLCBnb2FsOwogCWludCByZXM7CiAKLQlpZiAoc2JpLT50b3RhbF9ibG9ja3MgLSBzYmktPmZyZWVfYmxvY2tzICsgOCA+Ci0JCQlzYmktPmFsbG9jX2ZpbGUtPmlfc2l6ZSAqIDgpIHsKKwlpZiAoc2JpLT5hbGxvY19maWxlLT5pX3NpemUgKiA4IDwKKwkgICAgc2JpLT50b3RhbF9ibG9ja3MgLSBzYmktPmZyZWVfYmxvY2tzICsgOCkgewogCQkvKiBleHRlbmQgYWxsb2MgZmlsZSAqLwogCQlwcmludGsoS0VSTl9FUlIgImhmczogZXh0ZW5kIGFsbG9jIGZpbGUhICIKIAkJCQkiKCVsbHUsJXUsJXUpXG4iLApkaWZmIC0tZ2l0IGEvZnMvaGZzcGx1cy9wYXJ0X3RibC5jIGIvZnMvaGZzcGx1cy9wYXJ0X3RibC5jCmluZGV4IGQ2NmFkMTEuLjQwYWQ4OGMgMTAwNjQ0Ci0tLSBhL2ZzL2hmc3BsdXMvcGFydF90YmwuYworKysgYi9mcy9oZnNwbHVzL3BhcnRfdGJsLmMKQEAgLTEzNCw3ICsxMzQsNyBAQAogCXJlcyA9IGhmc3BsdXNfc3VibWl0X2JpbyhzYi0+c19iZGV2LCAqcGFydF9zdGFydCArIEhGU19QTUFQX0JMSywKIAkJCQkgZGF0YSwgUkVBRCk7CiAJaWYgKHJlcykKLQkJcmV0dXJuIHJlczsKKwkJZ290byBvdXQ7CiAKIAlzd2l0Y2ggKGJlMTZfdG9fY3B1KCooKF9fYmUxNiAqKWRhdGEpKSkgewogCWNhc2UgSEZTX09MRF9QTUFQX01BR0lDOgpAQCAtMTQ3LDcgKzE0Nyw3IEBACiAJCXJlcyA9IC1FTk9FTlQ7CiAJCWJyZWFrOwogCX0KLQorb3V0OgogCWtmcmVlKGRhdGEpOwogCXJldHVybiByZXM7CiB9CmRpZmYgLS1naXQgYS9mcy9oZnNwbHVzL3N1cGVyLmMgYi9mcy9oZnNwbHVzL3N1cGVyLmMKaW5kZXggOWEzYjQ3OS4uYjQ5YjU1NSAxMDA2NDQKLS0tIGEvZnMvaGZzcGx1cy9zdXBlci5jCisrKyBiL2ZzL2hmc3BsdXMvc3VwZXIuYwpAQCAtMzM4LDIwICszMzgsMjIgQEAKIAlzdHJ1Y3QgaW5vZGUgKnJvb3QsICppbm9kZTsKIAlzdHJ1Y3QgcXN0ciBzdHI7CiAJc3RydWN0IG5sc190YWJsZSAqbmxzID0gTlVMTDsKLQlpbnQgZXJyID0gLUVJTlZBTDsKKwlpbnQgZXJyOwogCisJZXJyID0gLUVJTlZBTDsKIAlzYmkgPSBremFsbG9jKHNpemVvZigqc2JpKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFzYmkpCi0JCXJldHVybiAtRU5PTUVNOworCQlnb3RvIG91dDsKIAogCXNiLT5zX2ZzX2luZm8gPSBzYmk7CiAJbXV0ZXhfaW5pdCgmc2JpLT5hbGxvY19tdXRleCk7CiAJbXV0ZXhfaW5pdCgmc2JpLT52aF9tdXRleCk7CiAJaGZzcGx1c19maWxsX2RlZmF1bHRzKHNiaSk7CisKKwllcnIgPSAtRUlOVkFMOwogCWlmICghaGZzcGx1c19wYXJzZV9vcHRpb25zKGRhdGEsIHNiaSkpIHsKIAkJcHJpbnRrKEtFUk5fRVJSICJoZnM6IHVuYWJsZSB0byBwYXJzZSBtb3VudCBvcHRpb25zXG4iKTsKLQkJZXJyID0gLUVJTlZBTDsKLQkJZ290byBjbGVhbnVwOworCQlnb3RvIG91dF91bmxvYWRfbmxzOwogCX0KIAogCS8qIHRlbXBvcmFyaWx5IHVzZSB1dGY4IHRvIGNvcnJlY3RseSBmaW5kIHRoZSBoaWRkZW4gZGlyIGJlbG93ICovCkBAIC0zNTksMTYgKzM2MSwxNCBAQAogCXNiaS0+bmxzID0gbG9hZF9ubHMoInV0ZjgiKTsKIAlpZiAoIXNiaS0+bmxzKSB7CiAJCXByaW50ayhLRVJOX0VSUiAiaGZzOiB1bmFibGUgdG8gbG9hZCBubHMgZm9yIHV0ZjhcbiIpOwotCQllcnIgPSAtRUlOVkFMOwotCQlnb3RvIGNsZWFudXA7CisJCWdvdG8gb3V0X3VubG9hZF9ubHM7CiAJfQogCiAJLyogR3JhYiB0aGUgdm9sdW1lIGhlYWRlciAqLwogCWlmIChoZnNwbHVzX3JlYWRfd3JhcHBlcihzYikpIHsKIAkJaWYgKCFzaWxlbnQpCiAJCQlwcmludGsoS0VSTl9XQVJOSU5HICJoZnM6IHVuYWJsZSB0byBmaW5kIEhGUysgc3VwZXJibG9ja1xuIik7Ci0JCWVyciA9IC1FSU5WQUw7Ci0JCWdvdG8gY2xlYW51cDsKKwkJZ290byBvdXRfdW5sb2FkX25sczsKIAl9CiAJdmhkciA9IHNiaS0+c192aGRyOwogCkBAIC0zNzcsNyArMzc3LDcgQEAKIAlpZiAoYmUxNl90b19jcHUodmhkci0+dmVyc2lvbikgPCBIRlNQTFVTX01JTl9WRVJTSU9OIHx8CiAJICAgIGJlMTZfdG9fY3B1KHZoZHItPnZlcnNpb24pID4gSEZTUExVU19DVVJSRU5UX1ZFUlNJT04pIHsKIAkJcHJpbnRrKEtFUk5fRVJSICJoZnM6IHdyb25nIGZpbGVzeXN0ZW0gdmVyc2lvblxuIik7Ci0JCWdvdG8gY2xlYW51cDsKKwkJZ290byBvdXRfZnJlZV92aGRyOwogCX0KIAlzYmktPnRvdGFsX2Jsb2NrcyA9IGJlMzJfdG9fY3B1KHZoZHItPnRvdGFsX2Jsb2Nrcyk7CiAJc2JpLT5mcmVlX2Jsb2NrcyA9IGJlMzJfdG9fY3B1KHZoZHItPmZyZWVfYmxvY2tzKTsKQEAgLTQyMSwxOSArNDIxLDE5IEBACiAJc2JpLT5leHRfdHJlZSA9IGhmc19idHJlZV9vcGVuKHNiLCBIRlNQTFVTX0VYVF9DTklEKTsKIAlpZiAoIXNiaS0+ZXh0X3RyZWUpIHsKIAkJcHJpbnRrKEtFUk5fRVJSICJoZnM6IGZhaWxlZCB0byBsb2FkIGV4dGVudHMgZmlsZVxuIik7Ci0JCWdvdG8gY2xlYW51cDsKKwkJZ290byBvdXRfZnJlZV92aGRyOwogCX0KIAlzYmktPmNhdF90cmVlID0gaGZzX2J0cmVlX29wZW4oc2IsIEhGU1BMVVNfQ0FUX0NOSUQpOwogCWlmICghc2JpLT5jYXRfdHJlZSkgewogCQlwcmludGsoS0VSTl9FUlIgImhmczogZmFpbGVkIHRvIGxvYWQgY2F0YWxvZyBmaWxlXG4iKTsKLQkJZ290byBjbGVhbnVwOworCQlnb3RvIG91dF9jbG9zZV9leHRfdHJlZTsKIAl9CiAKIAlpbm9kZSA9IGhmc3BsdXNfaWdldChzYiwgSEZTUExVU19BTExPQ19DTklEKTsKIAlpZiAoSVNfRVJSKGlub2RlKSkgewogCQlwcmludGsoS0VSTl9FUlIgImhmczogZmFpbGVkIHRvIGxvYWQgYWxsb2NhdGlvbiBmaWxlXG4iKTsKIAkJZXJyID0gUFRSX0VSUihpbm9kZSk7Ci0JCWdvdG8gY2xlYW51cDsKKwkJZ290byBvdXRfY2xvc2VfY2F0X3RyZWU7CiAJfQogCXNiaS0+YWxsb2NfZmlsZSA9IGlub2RlOwogCkBAIC00NDIsMTQgKzQ0Miw3IEBACiAJaWYgKElTX0VSUihyb290KSkgewogCQlwcmludGsoS0VSTl9FUlIgImhmczogZmFpbGVkIHRvIGxvYWQgcm9vdCBkaXJlY3RvcnlcbiIpOwogCQllcnIgPSBQVFJfRVJSKHJvb3QpOwotCQlnb3RvIGNsZWFudXA7Ci0JfQotCXNiLT5zX2Rfb3AgPSAmaGZzcGx1c19kZW50cnlfb3BlcmF0aW9uczsKLQlzYi0+c19yb290ID0gZF9hbGxvY19yb290KHJvb3QpOwotCWlmICghc2ItPnNfcm9vdCkgewotCQlpcHV0KHJvb3QpOwotCQllcnIgPSAtRU5PTUVNOwotCQlnb3RvIGNsZWFudXA7CisJCWdvdG8gb3V0X3B1dF9hbGxvY19maWxlOwogCX0KIAogCXN0ci5sZW4gPSBzaXplb2YoSEZTUF9ISURERU5ESVJfTkFNRSkgLSAxOwpAQCAtNDU5LDQ2ICs0NTIsNjkgQEAKIAlpZiAoIWhmc19icmVjX3JlYWQoJmZkLCAmZW50cnksIHNpemVvZihlbnRyeSkpKSB7CiAJCWhmc19maW5kX2V4aXQoJmZkKTsKIAkJaWYgKGVudHJ5LnR5cGUgIT0gY3B1X3RvX2JlMTYoSEZTUExVU19GT0xERVIpKQotCQkJZ290byBjbGVhbnVwOworCQkJZ290byBvdXRfcHV0X3Jvb3Q7CiAJCWlub2RlID0gaGZzcGx1c19pZ2V0KHNiLCBiZTMyX3RvX2NwdShlbnRyeS5mb2xkZXIuaWQpKTsKIAkJaWYgKElTX0VSUihpbm9kZSkpIHsKIAkJCWVyciA9IFBUUl9FUlIoaW5vZGUpOwotCQkJZ290byBjbGVhbnVwOworCQkJZ290byBvdXRfcHV0X3Jvb3Q7CiAJCX0KIAkJc2JpLT5oaWRkZW5fZGlyID0gaW5vZGU7CiAJfSBlbHNlCiAJCWhmc19maW5kX2V4aXQoJmZkKTsKIAotCWlmIChzYi0+c19mbGFncyAmIE1TX1JET05MWSkKLQkJZ290byBvdXQ7CisJaWYgKCEoc2ItPnNfZmxhZ3MgJiBNU19SRE9OTFkpKSB7CisJCS8qCisJCSAqIEgrTFggPT0gaGZzcGx1c3V0aWxzLCBIK0x4ID09IHRoaXMgZHJpdmVyLCBIK2x4IGlzIHVudXNlZAorCQkgKiBhbGwgdGhyZWUgYXJlIHJlZ2lzdGVyZWQgd2l0aCBBcHBsZSBmb3Igb3VyIHVzZQorCQkgKi8KKwkJdmhkci0+bGFzdF9tb3VudF92ZXJzID0gY3B1X3RvX2JlMzIoSEZTUF9NT1VOVF9WRVJTSU9OKTsKKwkJdmhkci0+bW9kaWZ5X2RhdGUgPSBoZnNwX25vdzJtdCgpOworCQliZTMyX2FkZF9jcHUoJnZoZHItPndyaXRlX2NvdW50LCAxKTsKKwkJdmhkci0+YXR0cmlidXRlcyAmPSBjcHVfdG9fYmUzMih+SEZTUExVU19WT0xfVU5NTlQpOworCQl2aGRyLT5hdHRyaWJ1dGVzIHw9IGNwdV90b19iZTMyKEhGU1BMVVNfVk9MX0lOQ05TVE5UKTsKKwkJaGZzcGx1c19zeW5jX2ZzKHNiLCAxKTsKIAotCS8qIEgrTFggPT0gaGZzcGx1c3V0aWxzLCBIK0x4ID09IHRoaXMgZHJpdmVyLCBIK2x4IGlzIHVudXNlZAotCSAqIGFsbCB0aHJlZSBhcmUgcmVnaXN0ZXJlZCB3aXRoIEFwcGxlIGZvciBvdXIgdXNlCi0JICovCi0Jdmhkci0+bGFzdF9tb3VudF92ZXJzID0gY3B1X3RvX2JlMzIoSEZTUF9NT1VOVF9WRVJTSU9OKTsKLQl2aGRyLT5tb2RpZnlfZGF0ZSA9IGhmc3Bfbm93Mm10KCk7Ci0JYmUzMl9hZGRfY3B1KCZ2aGRyLT53cml0ZV9jb3VudCwgMSk7Ci0Jdmhkci0+YXR0cmlidXRlcyAmPSBjcHVfdG9fYmUzMih+SEZTUExVU19WT0xfVU5NTlQpOwotCXZoZHItPmF0dHJpYnV0ZXMgfD0gY3B1X3RvX2JlMzIoSEZTUExVU19WT0xfSU5DTlNUTlQpOwotCWhmc3BsdXNfc3luY19mcyhzYiwgMSk7CisJCWlmICghc2JpLT5oaWRkZW5fZGlyKSB7CisJCQltdXRleF9sb2NrKCZzYmktPnZoX211dGV4KTsKKwkJCXNiaS0+aGlkZGVuX2RpciA9IGhmc3BsdXNfbmV3X2lub2RlKHNiLCBTX0lGRElSKTsKKwkJCWhmc3BsdXNfY3JlYXRlX2NhdChzYmktPmhpZGRlbl9kaXItPmlfaW5vLCByb290LCAmc3RyLAorCQkJCQkgICBzYmktPmhpZGRlbl9kaXIpOworCQkJbXV0ZXhfdW5sb2NrKCZzYmktPnZoX211dGV4KTsKIAotCWlmICghc2JpLT5oaWRkZW5fZGlyKSB7Ci0JCW11dGV4X2xvY2soJnNiaS0+dmhfbXV0ZXgpOwotCQlzYmktPmhpZGRlbl9kaXIgPSBoZnNwbHVzX25ld19pbm9kZShzYiwgU19JRkRJUik7Ci0JCWhmc3BsdXNfY3JlYXRlX2NhdChzYmktPmhpZGRlbl9kaXItPmlfaW5vLCBzYi0+c19yb290LT5kX2lub2RlLAotCQkJCSAgICZzdHIsIHNiaS0+aGlkZGVuX2Rpcik7Ci0JCW11dGV4X3VubG9jaygmc2JpLT52aF9tdXRleCk7Ci0KLQkJaGZzcGx1c19tYXJrX2lub2RlX2RpcnR5KHNiaS0+aGlkZGVuX2RpciwgSEZTUExVU19JX0NBVF9ESVJUWSk7CisJCQloZnNwbHVzX21hcmtfaW5vZGVfZGlydHkoc2JpLT5oaWRkZW5fZGlyLAorCQkJCQkJIEhGU1BMVVNfSV9DQVRfRElSVFkpOworCQl9CiAJfQotb3V0OgorCisJc2ItPnNfZF9vcCA9ICZoZnNwbHVzX2RlbnRyeV9vcGVyYXRpb25zOworCXNiLT5zX3Jvb3QgPSBkX2FsbG9jX3Jvb3Qocm9vdCk7CisJaWYgKCFzYi0+c19yb290KSB7CisJCWVyciA9IC1FTk9NRU07CisJCWdvdG8gb3V0X3B1dF9oaWRkZW5fZGlyOworCX0KKwogCXVubG9hZF9ubHMoc2JpLT5ubHMpOwogCXNiaS0+bmxzID0gbmxzOwogCXJldHVybiAwOwogCi1jbGVhbnVwOgotCWhmc3BsdXNfcHV0X3N1cGVyKHNiKTsKK291dF9wdXRfaGlkZGVuX2RpcjoKKwlpcHV0KHNiaS0+aGlkZGVuX2Rpcik7CitvdXRfcHV0X3Jvb3Q6CisJaXB1dChzYmktPmFsbG9jX2ZpbGUpOworb3V0X3B1dF9hbGxvY19maWxlOgorCWlwdXQoc2JpLT5hbGxvY19maWxlKTsKK291dF9jbG9zZV9jYXRfdHJlZToKKwloZnNfYnRyZWVfY2xvc2Uoc2JpLT5jYXRfdHJlZSk7CitvdXRfY2xvc2VfZXh0X3RyZWU6CisJaGZzX2J0cmVlX2Nsb3NlKHNiaS0+ZXh0X3RyZWUpOworb3V0X2ZyZWVfdmhkcjoKKwlrZnJlZShzYmktPnNfdmhkcik7CisJa2ZyZWUoc2JpLT5zX2JhY2t1cF92aGRyKTsKK291dF91bmxvYWRfbmxzOgorCXVubG9hZF9ubHMoc2JpLT5ubHMpOwogCXVubG9hZF9ubHMobmxzKTsKKwlrZnJlZShzYmkpOworb3V0OgogCXJldHVybiBlcnI7CiB9CiAKZGlmZiAtLWdpdCBhL2ZzL2hmc3BsdXMvd3JhcHBlci5jIGIvZnMvaGZzcGx1cy93cmFwcGVyLmMKaW5kZXggMTk2MjMxNy4uMzAzMWQ4MSAxMDA2NDQKLS0tIGEvZnMvaGZzcGx1cy93cmFwcGVyLmMKKysrIGIvZnMvaGZzcGx1cy93cmFwcGVyLmMKQEAgLTE2Nyw3ICsxNjcsNyBAQAogCQlicmVhazsKIAljYXNlIGNwdV90b19iZTE2KEhGU1BfV1JBUF9NQUdJQyk6CiAJCWlmICghaGZzcGx1c19yZWFkX21kYihzYmktPnNfdmhkciwgJndkKSkKLQkJCWdvdG8gb3V0OworCQkJZ290byBvdXRfZnJlZV9iYWNrdXBfdmhkcjsKIAkJd2QuYWJsa19zaXplID4+PSBIRlNQTFVTX1NFQ1RPUl9TSElGVDsKIAkJcGFydF9zdGFydCArPSB3ZC5hYmxrX3N0YXJ0ICsgd2QuZW1iZWRfc3RhcnQgKiB3ZC5hYmxrX3NpemU7CiAJCXBhcnRfc2l6ZSA9IHdkLmVtYmVkX2NvdW50ICogd2QuYWJsa19zaXplOwpAQCAtMTc5LDcgKzE3OSw3IEBACiAJCSAqIChzaG91bGQgZG8gdGhpcyBvbmx5IGZvciBjZHJvbS9sb29wIHRob3VnaCkKIAkJICovCiAJCWlmIChoZnNfcGFydF9maW5kKHNiLCAmcGFydF9zdGFydCwgJnBhcnRfc2l6ZSkpCi0JCQlnb3RvIG91dDsKKwkJCWdvdG8gb3V0X2ZyZWVfYmFja3VwX3ZoZHI7CiAJCWdvdG8gcmVyZWFkOwogCX0KIApkaWZmIC0tZ2l0IGEvZnMvaHBmcy9pbm9kZS5jIGIvZnMvaHBmcy9pbm9kZS5jCmluZGV4IDU2ZjBkYTEuLjFhZTM1YmEgMTAwNjQ0Ci0tLSBhL2ZzL2hwZnMvaW5vZGUuYworKysgYi9mcy9ocGZzL2lub2RlLmMKQEAgLTI4MSw3ICsyODEsNyBAQAogCSAgICBhdHRyLT5pYV9zaXplICE9IGlfc2l6ZV9yZWFkKGlub2RlKSkgewogCQllcnJvciA9IHZtdHJ1bmNhdGUoaW5vZGUsIGF0dHItPmlhX3NpemUpOwogCQlpZiAoZXJyb3IpCi0JCQlyZXR1cm4gZXJyb3I7CisJCQlnb3RvIG91dF91bmxvY2s7CiAJfQogCiAJc2V0YXR0cl9jb3B5KGlub2RlLCBhdHRyKTsKZGlmZiAtLWdpdCBhL2ZzL2ludGVybmFsLmggYi9mcy9pbnRlcm5hbC5oCmluZGV4IDk2ODdjMmUuLjA2NjM1NjggMTAwNjQ0Ci0tLSBhL2ZzL2ludGVybmFsLmgKKysrIGIvZnMvaW50ZXJuYWwuaApAQCAtNzAsNiArNzAsMTAgQEAKIGV4dGVybiB2b2lkIHJlbGVhc2VfbW91bnRzKHN0cnVjdCBsaXN0X2hlYWQgKik7CiBleHRlcm4gdm9pZCB1bW91bnRfdHJlZShzdHJ1Y3QgdmZzbW91bnQgKiwgaW50LCBzdHJ1Y3QgbGlzdF9oZWFkICopOwogZXh0ZXJuIHN0cnVjdCB2ZnNtb3VudCAqY29weV90cmVlKHN0cnVjdCB2ZnNtb3VudCAqLCBzdHJ1Y3QgZGVudHJ5ICosIGludCk7CitleHRlcm4gaW50IGZpbmlzaF9hdXRvbW91bnQoc3RydWN0IHZmc21vdW50ICosIHN0cnVjdCBwYXRoICopOworCitleHRlcm4gdm9pZCBtbnRfbWFrZV9sb25ndGVybShzdHJ1Y3QgdmZzbW91bnQgKik7CitleHRlcm4gdm9pZCBtbnRfbWFrZV9zaG9ydHRlcm0oc3RydWN0IHZmc21vdW50ICopOwogCiBleHRlcm4gdm9pZCBfX2luaXQgbW50X2luaXQodm9pZCk7CiAKZGlmZiAtLWdpdCBhL2ZzL2lvY3RsLmMgYi9mcy9pb2N0bC5jCmluZGV4IGQ2Y2MxNjQuLjFlZWJlYjcgMTAwNjQ0Ci0tLSBhL2ZzL2lvY3RsLmMKKysrIGIvZnMvaW9jdGwuYwpAQCAtODYsNyArODYsNyBAQAogCQkJICAgIHU2NCBwaHlzLCB1NjQgbGVuLCB1MzIgZmxhZ3MpCiB7CiAJc3RydWN0IGZpZW1hcF9leHRlbnQgZXh0ZW50OwotCXN0cnVjdCBmaWVtYXBfZXh0ZW50ICpkZXN0ID0gZmllaW5mby0+ZmlfZXh0ZW50c19zdGFydDsKKwlzdHJ1Y3QgZmllbWFwX2V4dGVudCBfX3VzZXIgKmRlc3QgPSBmaWVpbmZvLT5maV9leHRlbnRzX3N0YXJ0OwogCiAJLyogb25seSBjb3VudCB0aGUgZXh0ZW50cyAqLwogCWlmIChmaWVpbmZvLT5maV9leHRlbnRzX21heCA9PSAwKSB7CkBAIC0xNzMsNiArMTczLDcgQEAKIHN0YXRpYyBpbnQgaW9jdGxfZmllbWFwKHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBsb25nIGFyZykKIHsKIAlzdHJ1Y3QgZmllbWFwIGZpZW1hcDsKKwlzdHJ1Y3QgZmllbWFwIF9fdXNlciAqdWZpZW1hcCA9IChzdHJ1Y3QgZmllbWFwIF9fdXNlciAqKSBhcmc7CiAJc3RydWN0IGZpZW1hcF9leHRlbnRfaW5mbyBmaWVpbmZvID0geyAwLCB9OwogCXN0cnVjdCBpbm9kZSAqaW5vZGUgPSBmaWxwLT5mX3BhdGguZGVudHJ5LT5kX2lub2RlOwogCXN0cnVjdCBzdXBlcl9ibG9jayAqc2IgPSBpbm9kZS0+aV9zYjsKQEAgLTE4Miw4ICsxODMsNyBAQAogCWlmICghaW5vZGUtPmlfb3AtPmZpZW1hcCkKIAkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCi0JaWYgKGNvcHlfZnJvbV91c2VyKCZmaWVtYXAsIChzdHJ1Y3QgZmllbWFwIF9fdXNlciAqKWFyZywKLQkJCSAgIHNpemVvZihzdHJ1Y3QgZmllbWFwKSkpCisJaWYgKGNvcHlfZnJvbV91c2VyKCZmaWVtYXAsIHVmaWVtYXAsIHNpemVvZihmaWVtYXApKSkKIAkJcmV0dXJuIC1FRkFVTFQ7CiAKIAlpZiAoZmllbWFwLmZtX2V4dGVudF9jb3VudCA+IEZJRU1BUF9NQVhfRVhURU5UUykKQEAgLTE5Niw3ICsxOTYsNyBAQAogCiAJZmllaW5mby5maV9mbGFncyA9IGZpZW1hcC5mbV9mbGFnczsKIAlmaWVpbmZvLmZpX2V4dGVudHNfbWF4ID0gZmllbWFwLmZtX2V4dGVudF9jb3VudDsKLQlmaWVpbmZvLmZpX2V4dGVudHNfc3RhcnQgPSAoc3RydWN0IGZpZW1hcF9leHRlbnQgKikoYXJnICsgc2l6ZW9mKGZpZW1hcCkpOworCWZpZWluZm8uZmlfZXh0ZW50c19zdGFydCA9IHVmaWVtYXAtPmZtX2V4dGVudHM7CiAKIAlpZiAoZmllbWFwLmZtX2V4dGVudF9jb3VudCAhPSAwICYmCiAJICAgICFhY2Nlc3Nfb2soVkVSSUZZX1dSSVRFLCBmaWVpbmZvLmZpX2V4dGVudHNfc3RhcnQsCkBAIC0yMDksNyArMjA5LDcgQEAKIAllcnJvciA9IGlub2RlLT5pX29wLT5maWVtYXAoaW5vZGUsICZmaWVpbmZvLCBmaWVtYXAuZm1fc3RhcnQsIGxlbik7CiAJZmllbWFwLmZtX2ZsYWdzID0gZmllaW5mby5maV9mbGFnczsKIAlmaWVtYXAuZm1fbWFwcGVkX2V4dGVudHMgPSBmaWVpbmZvLmZpX2V4dGVudHNfbWFwcGVkOwotCWlmIChjb3B5X3RvX3VzZXIoKGNoYXIgKilhcmcsICZmaWVtYXAsIHNpemVvZihmaWVtYXApKSkKKwlpZiAoY29weV90b191c2VyKHVmaWVtYXAsICZmaWVtYXAsIHNpemVvZihmaWVtYXApKSkKIAkJZXJyb3IgPSAtRUZBVUxUOwogCiAJcmV0dXJuIGVycm9yOwpAQCAtMjczLDYgKzI3MywxMyBAQAogCQlsZW4gPSBpc2l6ZTsKIAl9CiAKKwkvKgorCSAqIFNvbWUgZmlsZXN5c3RlbXMgY2FuJ3QgZGVhbCB3aXRoIGJlaW5nIGFza2VkIHRvIG1hcCBsZXNzIHRoYW4KKwkgKiBibG9ja3NpemUsIHNvIG1ha2Ugc3VyZSBvdXIgbGVuIGlzIGF0IGxlYXN0IGJsb2NrIGxlbmd0aC4KKwkgKi8KKwlpZiAobG9naWNhbF90b19ibGsoaW5vZGUsIGxlbikgPT0gMCkKKwkJbGVuID0gYmxrX3RvX2xvZ2ljYWwoaW5vZGUsIDEpOworCiAJc3RhcnRfYmxrID0gbG9naWNhbF90b19ibGsoaW5vZGUsIHN0YXJ0KTsKIAlsYXN0X2JsayA9IGxvZ2ljYWxfdG9fYmxrKGlub2RlLCBzdGFydCArIGxlbiAtIDEpOwogCmRpZmYgLS1naXQgYS9mcy9qYmQyL2pvdXJuYWwuYyBiL2ZzL2piZDIvam91cm5hbC5jCmluZGV4IDllNDY4NjkuLjk3ZTczNDYgMTAwNjQ0Ci0tLSBhL2ZzL2piZDIvam91cm5hbC5jCisrKyBiL2ZzL2piZDIvam91cm5hbC5jCkBAIC00NzMsNyArNDczLDggQEAKIH0KIAogLyoKLSAqIENhbGxlZCB1bmRlciBqX3N0YXRlX2xvY2suICBSZXR1cm5zIHRydWUgaWYgYSB0cmFuc2FjdGlvbiBjb21taXQgd2FzIHN0YXJ0ZWQuCisgKiBDYWxsZWQgd2l0aCBqX3N0YXRlX2xvY2sgbG9ja2VkIGZvciB3cml0aW5nLgorICogUmV0dXJucyB0cnVlIGlmIGEgdHJhbnNhY3Rpb24gY29tbWl0IHdhcyBzdGFydGVkLgogICovCiBpbnQgX19qYmQyX2xvZ19zdGFydF9jb21taXQoam91cm5hbF90ICpqb3VybmFsLCB0aWRfdCB0YXJnZXQpCiB7CkBAIC01MjAsMTEgKzUyMSwxMyBAQAogewogCXRyYW5zYWN0aW9uX3QgKnRyYW5zYWN0aW9uID0gTlVMTDsKIAl0aWRfdCB0aWQ7CisJaW50IG5lZWRfdG9fc3RhcnQgPSAwOwogCiAJcmVhZF9sb2NrKCZqb3VybmFsLT5qX3N0YXRlX2xvY2spOwogCWlmIChqb3VybmFsLT5qX3J1bm5pbmdfdHJhbnNhY3Rpb24gJiYgIWN1cnJlbnQtPmpvdXJuYWxfaW5mbykgewogCQl0cmFuc2FjdGlvbiA9IGpvdXJuYWwtPmpfcnVubmluZ190cmFuc2FjdGlvbjsKLQkJX19qYmQyX2xvZ19zdGFydF9jb21taXQoam91cm5hbCwgdHJhbnNhY3Rpb24tPnRfdGlkKTsKKwkJaWYgKCF0aWRfZ2VxKGpvdXJuYWwtPmpfY29tbWl0X3JlcXVlc3QsIHRyYW5zYWN0aW9uLT50X3RpZCkpCisJCQluZWVkX3RvX3N0YXJ0ID0gMTsKIAl9IGVsc2UgaWYgKGpvdXJuYWwtPmpfY29tbWl0dGluZ190cmFuc2FjdGlvbikKIAkJdHJhbnNhY3Rpb24gPSBqb3VybmFsLT5qX2NvbW1pdHRpbmdfdHJhbnNhY3Rpb247CiAKQEAgLTUzNSw2ICs1MzgsOCBAQAogCiAJdGlkID0gdHJhbnNhY3Rpb24tPnRfdGlkOwogCXJlYWRfdW5sb2NrKCZqb3VybmFsLT5qX3N0YXRlX2xvY2spOworCWlmIChuZWVkX3RvX3N0YXJ0KQorCQlqYmQyX2xvZ19zdGFydF9jb21taXQoam91cm5hbCwgdGlkKTsKIAlqYmQyX2xvZ193YWl0X2NvbW1pdChqb3VybmFsLCB0aWQpOwogCXJldHVybiAxOwogfQpkaWZmIC0tZ2l0IGEvZnMvamJkMi90cmFuc2FjdGlvbi5jIGIvZnMvamJkMi90cmFuc2FjdGlvbi5jCmluZGV4IGZhYWQyYmQuLjFkMTE5MTAgMTAwNjQ0Ci0tLSBhL2ZzL2piZDIvdHJhbnNhY3Rpb24uYworKysgYi9mcy9qYmQyL3RyYW5zYWN0aW9uLmMKQEAgLTExNywxMCArMTE3LDEwIEBACiBzdGF0aWMgaW50IHN0YXJ0X3RoaXNfaGFuZGxlKGpvdXJuYWxfdCAqam91cm5hbCwgaGFuZGxlX3QgKmhhbmRsZSwKIAkJCSAgICAgaW50IGdmcF9tYXNrKQogewotCXRyYW5zYWN0aW9uX3QgKnRyYW5zYWN0aW9uOwotCWludCBuZWVkZWQ7Ci0JaW50IG5ibG9ja3MgPSBoYW5kbGUtPmhfYnVmZmVyX2NyZWRpdHM7Ci0JdHJhbnNhY3Rpb25fdCAqbmV3X3RyYW5zYWN0aW9uID0gTlVMTDsKKwl0cmFuc2FjdGlvbl90CSp0cmFuc2FjdGlvbiwgKm5ld190cmFuc2FjdGlvbiA9IE5VTEw7CisJdGlkX3QJCXRpZDsKKwlpbnQJCW5lZWRlZCwgbmVlZF90b19zdGFydDsKKwlpbnQJCW5ibG9ja3MgPSBoYW5kbGUtPmhfYnVmZmVyX2NyZWRpdHM7CiAKIAlpZiAobmJsb2NrcyA+IGpvdXJuYWwtPmpfbWF4X3RyYW5zYWN0aW9uX2J1ZmZlcnMpIHsKIAkJcHJpbnRrKEtFUk5fRVJSICJKQkQ6ICVzIHdhbnRzIHRvbyBtYW55IGNyZWRpdHMgKCVkID4gJWQpXG4iLApAQCAtMjIyLDggKzIyMiwxMSBAQAogCQlhdG9taWNfc3ViKG5ibG9ja3MsICZ0cmFuc2FjdGlvbi0+dF9vdXRzdGFuZGluZ19jcmVkaXRzKTsKIAkJcHJlcGFyZV90b193YWl0KCZqb3VybmFsLT5qX3dhaXRfdHJhbnNhY3Rpb25fbG9ja2VkLCAmd2FpdCwKIAkJCQlUQVNLX1VOSU5URVJSVVBUSUJMRSk7Ci0JCV9famJkMl9sb2dfc3RhcnRfY29tbWl0KGpvdXJuYWwsIHRyYW5zYWN0aW9uLT50X3RpZCk7CisJCXRpZCA9IHRyYW5zYWN0aW9uLT50X3RpZDsKKwkJbmVlZF90b19zdGFydCA9ICF0aWRfZ2VxKGpvdXJuYWwtPmpfY29tbWl0X3JlcXVlc3QsIHRpZCk7CiAJCXJlYWRfdW5sb2NrKCZqb3VybmFsLT5qX3N0YXRlX2xvY2spOworCQlpZiAobmVlZF90b19zdGFydCkKKwkJCWpiZDJfbG9nX3N0YXJ0X2NvbW1pdChqb3VybmFsLCB0aWQpOwogCQlzY2hlZHVsZSgpOwogCQlmaW5pc2hfd2FpdCgmam91cm5hbC0+al93YWl0X3RyYW5zYWN0aW9uX2xvY2tlZCwgJndhaXQpOwogCQlnb3RvIHJlcGVhdDsKQEAgLTQ0Miw3ICs0NDUsOCBAQAogewogCXRyYW5zYWN0aW9uX3QgKnRyYW5zYWN0aW9uID0gaGFuZGxlLT5oX3RyYW5zYWN0aW9uOwogCWpvdXJuYWxfdCAqam91cm5hbCA9IHRyYW5zYWN0aW9uLT50X2pvdXJuYWw7Ci0JaW50IHJldDsKKwl0aWRfdAkJdGlkOworCWludAkJbmVlZF90b19zdGFydCwgcmV0OwogCiAJLyogSWYgd2UndmUgaGFkIGFuIGFib3J0IG9mIGFueSB0eXBlLCBkb24ndCBldmVuIHRoaW5rIGFib3V0CiAJICogYWN0dWFsbHkgZG9pbmcgdGhlIHJlc3RhcnQhICovCkBAIC00NjUsOCArNDY5LDExIEBACiAJc3Bpbl91bmxvY2soJnRyYW5zYWN0aW9uLT50X2hhbmRsZV9sb2NrKTsKIAogCWpiZF9kZWJ1ZygyLCAicmVzdGFydGluZyBoYW5kbGUgJXBcbiIsIGhhbmRsZSk7Ci0JX19qYmQyX2xvZ19zdGFydF9jb21taXQoam91cm5hbCwgdHJhbnNhY3Rpb24tPnRfdGlkKTsKKwl0aWQgPSB0cmFuc2FjdGlvbi0+dF90aWQ7CisJbmVlZF90b19zdGFydCA9ICF0aWRfZ2VxKGpvdXJuYWwtPmpfY29tbWl0X3JlcXVlc3QsIHRpZCk7CiAJcmVhZF91bmxvY2soJmpvdXJuYWwtPmpfc3RhdGVfbG9jayk7CisJaWYgKG5lZWRfdG9fc3RhcnQpCisJCWpiZDJfbG9nX3N0YXJ0X2NvbW1pdChqb3VybmFsLCB0aWQpOwogCiAJbG9ja19tYXBfcmVsZWFzZSgmaGFuZGxlLT5oX2xvY2tkZXBfbWFwKTsKIAloYW5kbGUtPmhfYnVmZmVyX2NyZWRpdHMgPSBuYmxvY2tzOwpkaWZmIC0tZ2l0IGEvZnMvamZmczIvYnVpbGQuYyBiL2ZzL2pmZnMyL2J1aWxkLmMKaW5kZXggODVjNmJlMi4uMzAwNWVjNCAxMDA2NDQKLS0tIGEvZnMvamZmczIvYnVpbGQuYworKysgYi9mcy9qZmZzMi9idWlsZC5jCkBAIC0zMzYsMTQgKzMzNiwxMyBAQAogCXNpemUgPSBzaXplb2Yoc3RydWN0IGpmZnMyX2VyYXNlYmxvY2spICogYy0+bnJfYmxvY2tzOwogI2lmbmRlZiBfX0VDT1MKIAlpZiAoamZmczJfYmxvY2tzX3VzZV92bWFsbG9jKGMpKQotCQljLT5ibG9ja3MgPSB2bWFsbG9jKHNpemUpOworCQljLT5ibG9ja3MgPSB2emFsbG9jKHNpemUpOwogCWVsc2UKICNlbmRpZgotCQljLT5ibG9ja3MgPSBrbWFsbG9jKHNpemUsIEdGUF9LRVJORUwpOworCQljLT5ibG9ja3MgPSBremFsbG9jKHNpemUsIEdGUF9LRVJORUwpOwogCWlmICghYy0+YmxvY2tzKQogCQlyZXR1cm4gLUVOT01FTTsKIAotCW1lbXNldChjLT5ibG9ja3MsIDAsIHNpemUpOwogCWZvciAoaT0wOyBpPGMtPm5yX2Jsb2NrczsgaSsrKSB7CiAJCUlOSVRfTElTVF9IRUFEKCZjLT5ibG9ja3NbaV0ubGlzdCk7CiAJCWMtPmJsb2Nrc1tpXS5vZmZzZXQgPSBpICogYy0+c2VjdG9yX3NpemU7CmRpZmYgLS1naXQgYS9mcy9qZmZzMi9qZmZzMl9mc19zYi5oIGIvZnMvamZmczIvamZmczJfZnNfc2IuaAppbmRleCBmODY0MDA1Li4wYmM2YTZjIDEwMDY0NAotLS0gYS9mcy9qZmZzMi9qZmZzMl9mc19zYi5oCisrKyBiL2ZzL2pmZnMyL2pmZnMyX2ZzX3NiLmgKQEAgLTE0NCw0ICsxNDQsNCBAQAogCXZvaWQgKm9zX3ByaXY7CiB9OwogCi0jZW5kaWYgLyogX0pGRlMyX0ZCX1NCICovCisjZW5kaWYgLyogX0pGRlMyX0ZTX1NCICovCmRpZmYgLS1naXQgYS9mcy9qZmZzMi94YXR0ci5jIGIvZnMvamZmczIveGF0dHIuYwppbmRleCA5YjU3MmNhLi40ZjljYzA0IDEwMDY0NAotLS0gYS9mcy9qZmZzMi94YXR0ci5jCisrKyBiL2ZzL2pmZnMyL3hhdHRyLmMKQEAgLTE1MSw3ICsxNTEsNyBAQAogCQlKRkZTMl9FUlJPUigibm9kZSBDUkMgZmFpbGVkIGF0ICUjMDh4LCByZWFkPSUjMDh4LCBjYWxjPSUjMDh4XG4iLAogCQkJICAgIG9mZnNldCwgamUzMl90b19jcHUocnguaGRyX2NyYyksIGNyYyk7CiAJCXhkLT5mbGFncyB8PSBKRkZTMl9YRkxBR1NfSU5WQUxJRDsKLQkJcmV0dXJuIEVJTzsKKwkJcmV0dXJuIC1FSU87CiAJfQogCXRvdGxlbiA9IFBBRChzaXplb2YocngpICsgcngubmFtZV9sZW4gKyAxICsgamUxNl90b19jcHUocngudmFsdWVfbGVuKSk7CiAJaWYgKGplMTZfdG9fY3B1KHJ4Lm1hZ2ljKSAhPSBKRkZTMl9NQUdJQ19CSVRNQVNLCkBAIC0xNjcsNyArMTY3LDcgQEAKIAkJCSAgICBqZTMyX3RvX2NwdShyeC54aWQpLCB4ZC0+eGlkLAogCQkJICAgIGplMzJfdG9fY3B1KHJ4LnZlcnNpb24pLCB4ZC0+dmVyc2lvbik7CiAJCXhkLT5mbGFncyB8PSBKRkZTMl9YRkxBR1NfSU5WQUxJRDsKLQkJcmV0dXJuIEVJTzsKKwkJcmV0dXJuIC1FSU87CiAJfQogCXhkLT54cHJlZml4ID0gcngueHByZWZpeDsKIAl4ZC0+bmFtZV9sZW4gPSByeC5uYW1lX2xlbjsKQEAgLTIzMCw3ICsyMzAsNyBAQAogCQkJICAgICAgcmVmX29mZnNldCh4ZC0+bm9kZSksIHhkLT5kYXRhX2NyYywgY3JjKTsKIAkJa2ZyZWUoZGF0YSk7CiAJCXhkLT5mbGFncyB8PSBKRkZTMl9YRkxBR1NfSU5WQUxJRDsKLQkJcmV0dXJuIEVJTzsKKwkJcmV0dXJuIC1FSU87CiAJfQogCiAJeGQtPmZsYWdzIHw9IEpGRlMyX1hGTEFHU19IT1Q7CkBAIC0yNjgsNyArMjY4LDcgQEAKIAlpZiAoeGQtPnhuYW1lKQogCQlyZXR1cm4gMDsKIAlpZiAoeGQtPmZsYWdzICYgSkZGUzJfWEZMQUdTX0lOVkFMSUQpCi0JCXJldHVybiBFSU87CisJCXJldHVybiAtRUlPOwogCWlmICh1bmxpa2VseShpc194YXR0cl9kYXR1bV91bmNoZWNrZWQoYywgeGQpKSkKIAkJcmMgPSBkb192ZXJpZnlfeGF0dHJfZGF0dW0oYywgeGQpOwogCWlmICghcmMpCkBAIC00NjAsNyArNDYwLDcgQEAKIAlpZiAoY3JjICE9IGplMzJfdG9fY3B1KHJyLm5vZGVfY3JjKSkgewogCQlKRkZTMl9FUlJPUigibm9kZSBDUkMgZmFpbGVkIGF0ICUjMDh4LCByZWFkPSUjMDh4LCBjYWxjPSUjMDh4XG4iLAogCQkJICAgIG9mZnNldCwgamUzMl90b19jcHUocnIubm9kZV9jcmMpLCBjcmMpOwotCQlyZXR1cm4gRUlPOworCQlyZXR1cm4gLUVJTzsKIAl9CiAJaWYgKGplMTZfdG9fY3B1KHJyLm1hZ2ljKSAhPSBKRkZTMl9NQUdJQ19CSVRNQVNLCiAJICAgIHx8IGplMTZfdG9fY3B1KHJyLm5vZGV0eXBlKSAhPSBKRkZTMl9OT0RFVFlQRV9YUkVGCkBAIC00NzAsNyArNDcwLDcgQEAKIAkJCSAgICBvZmZzZXQsIGplMTZfdG9fY3B1KHJyLm1hZ2ljKSwgSkZGUzJfTUFHSUNfQklUTUFTSywKIAkJCSAgICBqZTE2X3RvX2NwdShyci5ub2RldHlwZSksIEpGRlMyX05PREVUWVBFX1hSRUYsCiAJCQkgICAgamUzMl90b19jcHUocnIudG90bGVuKSwgUEFEKHNpemVvZihycikpKTsKLQkJcmV0dXJuIEVJTzsKKwkJcmV0dXJuIC1FSU87CiAJfQogCXJlZi0+aW5vID0gamUzMl90b19jcHUocnIuaW5vKTsKIAlyZWYtPnhpZCA9IGplMzJfdG9fY3B1KHJyLnhpZCk7CmRpZmYgLS1naXQgYS9mcy9sb2NrZC9ob3N0LmMgYi9mcy9sb2NrZC9ob3N0LmMKaW5kZXggNWYxYmNiMi4uYjdjOTliZiAxMDA2NDQKLS0tIGEvZnMvbG9ja2QvaG9zdC5jCisrKyBiL2ZzL2xvY2tkL2hvc3QuYwpAQCAtNTIwLDcgKzUyMCw3IEBACiAJCQkJCXN0cnVjdCBuc21faGFuZGxlICpuc20sCiAJCQkJCWNvbnN0IHN0cnVjdCBubG1fcmVib290ICppbmZvKQogewotCXN0cnVjdCBubG1faG9zdCAqaG9zdCA9IE5VTEw7CisJc3RydWN0IG5sbV9ob3N0ICpob3N0OwogCXN0cnVjdCBobGlzdF9oZWFkICpjaGFpbjsKIAlzdHJ1Y3QgaGxpc3Rfbm9kZSAqcG9zOwogCkBAIC01MzIsMTIgKzUzMiwxMyBAQAogCQkJaG9zdC0+aF9zdGF0ZSsrOwogCiAJCQlubG1fZ2V0X2hvc3QoaG9zdCk7Ci0JCQlnb3RvIG91dDsKKwkJCW11dGV4X3VubG9jaygmbmxtX2hvc3RfbXV0ZXgpOworCQkJcmV0dXJuIGhvc3Q7CiAJCX0KIAl9Ci1vdXQ6CisKIAltdXRleF91bmxvY2soJm5sbV9ob3N0X211dGV4KTsKLQlyZXR1cm4gaG9zdDsKKwlyZXR1cm4gTlVMTDsKIH0KIAogLyoqCmRpZmYgLS1naXQgYS9mcy9sb2Nrcy5jIGIvZnMvbG9ja3MuYwppbmRleCAwODQxNWIyLi4wZjM5OTgyIDEwMDY0NAotLS0gYS9mcy9sb2Nrcy5jCisrKyBiL2ZzL2xvY2tzLmMKQEAgLTQ0NCwxNSArNDQ0LDkgQEAKIAlmbC0+ZmxfZmlsZS0+Zl9vd25lci5zaWdudW0gPSAwOwogfQogCi1zdGF0aWMgaW50IGxlYXNlX215bGVhc2VfY2FsbGJhY2soc3RydWN0IGZpbGVfbG9jayAqZmwsIHN0cnVjdCBmaWxlX2xvY2sgKnRyeSkKLXsKLQlyZXR1cm4gZmwtPmZsX2ZpbGUgPT0gdHJ5LT5mbF9maWxlOwotfQotCiBzdGF0aWMgY29uc3Qgc3RydWN0IGxvY2tfbWFuYWdlcl9vcGVyYXRpb25zIGxlYXNlX21hbmFnZXJfb3BzID0gewogCS5mbF9icmVhayA9IGxlYXNlX2JyZWFrX2NhbGxiYWNrLAogCS5mbF9yZWxlYXNlX3ByaXZhdGUgPSBsZWFzZV9yZWxlYXNlX3ByaXZhdGVfY2FsbGJhY2ssCi0JLmZsX215bGVhc2UgPSBsZWFzZV9teWxlYXNlX2NhbGxiYWNrLAogCS5mbF9jaGFuZ2UgPSBsZWFzZV9tb2RpZnksCiB9OwogCkBAIC0xNDA1LDcgKzEzOTksNyBAQAogCWZvciAoYmVmb3JlID0gJmlub2RlLT5pX2Zsb2NrOwogCQkJKChmbCA9ICpiZWZvcmUpICE9IE5VTEwpICYmIElTX0xFQVNFKGZsKTsKIAkJCWJlZm9yZSA9ICZmbC0+ZmxfbmV4dCkgewotCQlpZiAobGVhc2UtPmZsX2xtb3BzLT5mbF9teWxlYXNlKGZsLCBsZWFzZSkpCisJCWlmIChmbC0+ZmxfZmlsZSA9PSBmaWxwKQogCQkJbXlfYmVmb3JlID0gYmVmb3JlOwogCQllbHNlIGlmIChmbC0+ZmxfdHlwZSA9PSAoRl9JTlBST0dSRVNTIHwgRl9VTkxDSykpCiAJCQkvKgpkaWZmIC0tZ2l0IGEvZnMvbXBhZ2UuYyBiL2ZzL21wYWdlLmMKaW5kZXggZmQ1NmNhMi4uZDc4NDU1YSAxMDA2NDQKLS0tIGEvZnMvbXBhZ2UuYworKysgYi9mcy9tcGFnZS5jCkBAIC00MCw3ICs0MCw3IEBACiAgKiBzdGF0dXMgb2YgdGhhdCBwYWdlIGlzIGhhcmQuICBTZWUgZW5kX2J1ZmZlcl9hc3luY19yZWFkKCkgZm9yIHRoZSBkZXRhaWxzLgogICogVGhlcmUgaXMgbm8gcG9pbnQgaW4gZHVwbGljYXRpbmcgYWxsIHRoYXQgY29tcGxleGl0eS4KICAqLwotc3RhdGljIHZvaWQgbXBhZ2VfZW5kX2lvX3JlYWQoc3RydWN0IGJpbyAqYmlvLCBpbnQgZXJyKQorc3RhdGljIHZvaWQgbXBhZ2VfZW5kX2lvKHN0cnVjdCBiaW8gKmJpbywgaW50IGVycikKIHsKIAljb25zdCBpbnQgdXB0b2RhdGUgPSB0ZXN0X2JpdChCSU9fVVBUT0RBVEUsICZiaW8tPmJpX2ZsYWdzKTsKIAlzdHJ1Y3QgYmlvX3ZlYyAqYnZlYyA9IGJpby0+YmlfaW9fdmVjICsgYmlvLT5iaV92Y250IC0gMTsKQEAgLTUwLDQ0ICs1MCwyOSBAQAogCiAJCWlmICgtLWJ2ZWMgPj0gYmlvLT5iaV9pb192ZWMpCiAJCQlwcmVmZXRjaHcoJmJ2ZWMtPmJ2X3BhZ2UtPmZsYWdzKTsKLQotCQlpZiAodXB0b2RhdGUpIHsKLQkJCVNldFBhZ2VVcHRvZGF0ZShwYWdlKTsKLQkJfSBlbHNlIHsKLQkJCUNsZWFyUGFnZVVwdG9kYXRlKHBhZ2UpOwotCQkJU2V0UGFnZUVycm9yKHBhZ2UpOworCQlpZiAoYmlvX2RhdGFfZGlyKGJpbykgPT0gUkVBRCkgeworCQkJaWYgKHVwdG9kYXRlKSB7CisJCQkJU2V0UGFnZVVwdG9kYXRlKHBhZ2UpOworCQkJfSBlbHNlIHsKKwkJCQlDbGVhclBhZ2VVcHRvZGF0ZShwYWdlKTsKKwkJCQlTZXRQYWdlRXJyb3IocGFnZSk7CisJCQl9CisJCQl1bmxvY2tfcGFnZShwYWdlKTsKKwkJfSBlbHNlIHsgLyogYmlvX2RhdGFfZGlyKGJpbykgPT0gV1JJVEUgKi8KKwkJCWlmICghdXB0b2RhdGUpIHsKKwkJCQlTZXRQYWdlRXJyb3IocGFnZSk7CisJCQkJaWYgKHBhZ2UtPm1hcHBpbmcpCisJCQkJCXNldF9iaXQoQVNfRUlPLCAmcGFnZS0+bWFwcGluZy0+ZmxhZ3MpOworCQkJfQorCQkJZW5kX3BhZ2Vfd3JpdGViYWNrKHBhZ2UpOwogCQl9Ci0JCXVubG9ja19wYWdlKHBhZ2UpOwotCX0gd2hpbGUgKGJ2ZWMgPj0gYmlvLT5iaV9pb192ZWMpOwotCWJpb19wdXQoYmlvKTsKLX0KLQotc3RhdGljIHZvaWQgbXBhZ2VfZW5kX2lvX3dyaXRlKHN0cnVjdCBiaW8gKmJpbywgaW50IGVycikKLXsKLQljb25zdCBpbnQgdXB0b2RhdGUgPSB0ZXN0X2JpdChCSU9fVVBUT0RBVEUsICZiaW8tPmJpX2ZsYWdzKTsKLQlzdHJ1Y3QgYmlvX3ZlYyAqYnZlYyA9IGJpby0+YmlfaW9fdmVjICsgYmlvLT5iaV92Y250IC0gMTsKLQotCWRvIHsKLQkJc3RydWN0IHBhZ2UgKnBhZ2UgPSBidmVjLT5idl9wYWdlOwotCi0JCWlmICgtLWJ2ZWMgPj0gYmlvLT5iaV9pb192ZWMpCi0JCQlwcmVmZXRjaHcoJmJ2ZWMtPmJ2X3BhZ2UtPmZsYWdzKTsKLQotCQlpZiAoIXVwdG9kYXRlKXsKLQkJCVNldFBhZ2VFcnJvcihwYWdlKTsKLQkJCWlmIChwYWdlLT5tYXBwaW5nKQotCQkJCXNldF9iaXQoQVNfRUlPLCAmcGFnZS0+bWFwcGluZy0+ZmxhZ3MpOwotCQl9Ci0JCWVuZF9wYWdlX3dyaXRlYmFjayhwYWdlKTsKIAl9IHdoaWxlIChidmVjID49IGJpby0+YmlfaW9fdmVjKTsKIAliaW9fcHV0KGJpbyk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgYmlvICptcGFnZV9iaW9fc3VibWl0KGludCBydywgc3RydWN0IGJpbyAqYmlvKQogewotCWJpby0+YmlfZW5kX2lvID0gbXBhZ2VfZW5kX2lvX3JlYWQ7Ci0JaWYgKHJ3ID09IFdSSVRFKQotCQliaW8tPmJpX2VuZF9pbyA9IG1wYWdlX2VuZF9pb193cml0ZTsKKwliaW8tPmJpX2VuZF9pbyA9IG1wYWdlX2VuZF9pbzsKIAlzdWJtaXRfYmlvKHJ3LCBiaW8pOwogCXJldHVybiBOVUxMOwogfQpkaWZmIC0tZ2l0IGEvZnMvbmFtZWkuYyBiL2ZzL25hbWVpLmMKaW5kZXggMGIxNGY2OS4uZWM0YjJkMCAxMDA2NDQKLS0tIGEvZnMvbmFtZWkuYworKysgYi9mcy9uYW1laS5jCkBAIC0zNjgsMTggKzM2OCw2IEBACiBFWFBPUlRfU1lNQk9MKHBhdGhfZ2V0KTsKIAogLyoqCi0gKiBwYXRoX2dldF9sb25nIC0gZ2V0IGEgbG9uZyByZWZlcmVuY2UgdG8gYSBwYXRoCi0gKiBAcGF0aDogcGF0aCB0byBnZXQgdGhlIHJlZmVyZW5jZSB0bwotICoKLSAqIEdpdmVuIGEgcGF0aCBpbmNyZW1lbnQgdGhlIHJlZmVyZW5jZSBjb3VudCB0byB0aGUgZGVudHJ5IGFuZCB0aGUgdmZzbW91bnQuCi0gKi8KLXZvaWQgcGF0aF9nZXRfbG9uZyhzdHJ1Y3QgcGF0aCAqcGF0aCkKLXsKLQltbnRnZXRfbG9uZyhwYXRoLT5tbnQpOwotCWRnZXQocGF0aC0+ZGVudHJ5KTsKLX0KLQotLyoqCiAgKiBwYXRoX3B1dCAtIHB1dCBhIHJlZmVyZW5jZSB0byBhIHBhdGgKICAqIEBwYXRoOiBwYXRoIHRvIHB1dCB0aGUgcmVmZXJlbmNlIHRvCiAgKgpAQCAtMzkzLDE4ICszODEsNiBAQAogRVhQT1JUX1NZTUJPTChwYXRoX3B1dCk7CiAKIC8qKgotICogcGF0aF9wdXRfbG9uZyAtIHB1dCBhIGxvbmcgcmVmZXJlbmNlIHRvIGEgcGF0aAotICogQHBhdGg6IHBhdGggdG8gcHV0IHRoZSByZWZlcmVuY2UgdG8KLSAqCi0gKiBHaXZlbiBhIHBhdGggZGVjcmVtZW50IHRoZSByZWZlcmVuY2UgY291bnQgdG8gdGhlIGRlbnRyeSBhbmQgdGhlIHZmc21vdW50LgotICovCi12b2lkIHBhdGhfcHV0X2xvbmcoc3RydWN0IHBhdGggKnBhdGgpCi17Ci0JZHB1dChwYXRoLT5kZW50cnkpOwotCW1udHB1dF9sb25nKHBhdGgtPm1udCk7Ci19Ci0KLS8qKgogICogbmFtZWlkYXRhX2Ryb3BfcmN1IC0gZHJvcCB0aGlzIG5hbWVpZGF0YSBvdXQgb2YgcmN1LXdhbGsKICAqIEBuZDogbmFtZWlkYXRhIHBhdGh3YWxrIGRhdGEgdG8gZHJvcAogICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtRUNISUxEIG9uIGZhaWx1cmUKQEAgLTQ3OSw2ICs0NTUsMTQgQEAKIAlzdHJ1Y3QgZnNfc3RydWN0ICpmcyA9IGN1cnJlbnQtPmZzOwogCXN0cnVjdCBkZW50cnkgKnBhcmVudCA9IG5kLT5wYXRoLmRlbnRyeTsKIAorCS8qCisJICogSXQgY2FuIGJlIHBvc3NpYmxlIHRvIHJldmFsaWRhdGUgdGhlIGRlbnRyeSB0aGF0IHdlIHN0YXJ0ZWQKKwkgKiB0aGUgcGF0aCB3YWxrIHdpdGguIGZvcmNlX3JldmFsX3BhdGggbWF5IGFsc28gcmV2YWxpZGF0ZSB0aGUKKwkgKiBkZW50cnkgYWxyZWFkeSBjb21taXR0ZWQgdG8gdGhlIG5hbWVpZGF0YS4KKwkgKi8KKwlpZiAodW5saWtlbHkocGFyZW50ID09IGRlbnRyeSkpCisJCXJldHVybiBuYW1laWRhdGFfZHJvcF9yY3UobmQpOworCiAJQlVHX09OKCEobmQtPmZsYWdzICYgTE9PS1VQX1JDVSkpOwogCWlmIChuZC0+cm9vdC5tbnQpIHsKIAkJc3Bpbl9sb2NrKCZmcy0+bG9jayk7CkBAIC01NzcsMTIgKzU2MSwyMyBAQAogICovCiB2b2lkIHJlbGVhc2Vfb3Blbl9pbnRlbnQoc3RydWN0IG5hbWVpZGF0YSAqbmQpCiB7Ci0JaWYgKG5kLT5pbnRlbnQub3Blbi5maWxlLT5mX3BhdGguZGVudHJ5ID09IE5VTEwpCi0JCXB1dF9maWxwKG5kLT5pbnRlbnQub3Blbi5maWxlKTsKLQllbHNlCi0JCWZwdXQobmQtPmludGVudC5vcGVuLmZpbGUpOworCXN0cnVjdCBmaWxlICpmaWxlID0gbmQtPmludGVudC5vcGVuLmZpbGU7CisKKwlpZiAoZmlsZSAmJiAhSVNfRVJSKGZpbGUpKSB7CisJCWlmIChmaWxlLT5mX3BhdGguZGVudHJ5ID09IE5VTEwpCisJCQlwdXRfZmlscChmaWxlKTsKKwkJZWxzZQorCQkJZnB1dChmaWxlKTsKKwl9CiB9CiAKKy8qCisgKiBDYWxsIGRfcmV2YWxpZGF0ZSBhbmQgaGFuZGxlIGZpbGVzeXN0ZW1zIHRoYXQgcmVxdWVzdCByY3Utd2FsaworICogdG8gYmUgZHJvcHBlZC4gVGhpcyBtYXkgYmUgY2FsbGVkIGFuZCByZXR1cm4gaW4gcmN1LXdhbGsgbW9kZSwKKyAqIHJlZ2FyZGxlc3Mgb2Ygc3VjY2VzcyBvciBlcnJvci4gSWYgLUVDSElMRCBpcyByZXR1cm5lZCwgdGhlIGNhbGxlcgorICogbXVzdCByZXR1cm4gLUVDSElMRCBiYWNrIHVwIHRoZSBwYXRoIHdhbGsgc3RhY2sgc28gcGF0aCB3YWxrIG1heQorICogYmUgcmVzdGFydGVkIGluIHJlZi13YWxrIG1vZGUuCisgKi8KIHN0YXRpYyBpbnQgZF9yZXZhbGlkYXRlKHN0cnVjdCBkZW50cnkgKmRlbnRyeSwgc3RydWN0IG5hbWVpZGF0YSAqbmQpCiB7CiAJaW50IHN0YXR1czsKQEAgLTY3Myw2ICs2NjgsOSBAQAogCQlyZXR1cm4gMDsKIAogCWlmICghc3RhdHVzKSB7CisJCS8qIERvbid0IGRfaW52YWxpZGF0ZSBpbiByY3Utd2FsayBtb2RlICovCisJCWlmIChuYW1laWRhdGFfZHJvcF9yY3UobmQpKQorCQkJcmV0dXJuIC1FQ0hJTEQ7CiAJCWRfaW52YWxpZGF0ZShkZW50cnkpOwogCQlzdGF0dXMgPSAtRVNUQUxFOwogCX0KQEAgLTc2MSw3ICs3NTksOCBAQAogCQltbnRwdXQocGF0aC0+bW50KTsKIH0KIAotc3RhdGljIGlubGluZSB2b2lkIHBhdGhfdG9fbmFtZWlkYXRhKHN0cnVjdCBwYXRoICpwYXRoLCBzdHJ1Y3QgbmFtZWlkYXRhICpuZCkKK3N0YXRpYyBpbmxpbmUgdm9pZCBwYXRoX3RvX25hbWVpZGF0YShjb25zdCBzdHJ1Y3QgcGF0aCAqcGF0aCwKKwkJCQkJc3RydWN0IG5hbWVpZGF0YSAqbmQpCiB7CiAJaWYgKCEobmQtPmZsYWdzICYgTE9PS1VQX1JDVSkpIHsKIAkJZHB1dChuZC0+cGF0aC5kZW50cnkpOwpAQCAtNzczLDIwICs3NzIsMTYgQEAKIH0KIAogc3RhdGljIF9fYWx3YXlzX2lubGluZSBpbnQKLV9fZG9fZm9sbG93X2xpbmsoc3RydWN0IHBhdGggKnBhdGgsIHN0cnVjdCBuYW1laWRhdGEgKm5kLCB2b2lkICoqcCkKK19fZG9fZm9sbG93X2xpbmsoY29uc3Qgc3RydWN0IHBhdGggKmxpbmssIHN0cnVjdCBuYW1laWRhdGEgKm5kLCB2b2lkICoqcCkKIHsKIAlpbnQgZXJyb3I7Ci0Jc3RydWN0IGRlbnRyeSAqZGVudHJ5ID0gcGF0aC0+ZGVudHJ5OworCXN0cnVjdCBkZW50cnkgKmRlbnRyeSA9IGxpbmstPmRlbnRyeTsKIAotCXRvdWNoX2F0aW1lKHBhdGgtPm1udCwgZGVudHJ5KTsKKwl0b3VjaF9hdGltZShsaW5rLT5tbnQsIGRlbnRyeSk7CiAJbmRfc2V0X2xpbmsobmQsIE5VTEwpOwogCi0JaWYgKHBhdGgtPm1udCAhPSBuZC0+cGF0aC5tbnQpIHsKLQkJcGF0aF90b19uYW1laWRhdGEocGF0aCwgbmQpOwotCQluZC0+aW5vZGUgPSBuZC0+cGF0aC5kZW50cnktPmRfaW5vZGU7Ci0JCWRnZXQoZGVudHJ5KTsKLQl9Ci0JbW50Z2V0KHBhdGgtPm1udCk7CisJaWYgKGxpbmstPm1udCA9PSBuZC0+cGF0aC5tbnQpCisJCW1udGdldChsaW5rLT5tbnQpOwogCiAJbmQtPmxhc3RfdHlwZSA9IExBU1RfQklORDsKIAkqcCA9IGRlbnRyeS0+ZF9pbm9kZS0+aV9vcC0+Zm9sbG93X2xpbmsoZGVudHJ5LCBuZCk7CkBAIC04NzcsNTQgKzg3MiwxNDggQEAKIH0KIAogLyoKLSAqIHNlcmlhbGl6YXRpb24gaXMgdGFrZW4gY2FyZSBvZiBpbiBuYW1lc3BhY2UuYworICogUGVyZm9ybSBhbiBhdXRvbW91bnQKKyAqIC0gcmV0dXJuIC1FSVNESVIgdG8gdGVsbCBmb2xsb3dfbWFuYWdlZCgpIHRvIHN0b3AgYW5kIHJldHVybiB0aGUgcGF0aCB3ZQorICogICB3ZXJlIGNhbGxlZCB3aXRoLgogICovCi1zdGF0aWMgdm9pZCBfX2ZvbGxvd19tb3VudF9yY3Uoc3RydWN0IG5hbWVpZGF0YSAqbmQsIHN0cnVjdCBwYXRoICpwYXRoLAotCQkJCXN0cnVjdCBpbm9kZSAqKmlub2RlKQorc3RhdGljIGludCBmb2xsb3dfYXV0b21vdW50KHN0cnVjdCBwYXRoICpwYXRoLCB1bnNpZ25lZCBmbGFncywKKwkJCSAgICBib29sICpuZWVkX21udHB1dCkKIHsKLQl3aGlsZSAoZF9tb3VudHBvaW50KHBhdGgtPmRlbnRyeSkpIHsKLQkJc3RydWN0IHZmc21vdW50ICptb3VudGVkOwotCQltb3VudGVkID0gX19sb29rdXBfbW50KHBhdGgtPm1udCwgcGF0aC0+ZGVudHJ5LCAxKTsKLQkJaWYgKCFtb3VudGVkKQotCQkJcmV0dXJuOwotCQlwYXRoLT5tbnQgPSBtb3VudGVkOwotCQlwYXRoLT5kZW50cnkgPSBtb3VudGVkLT5tbnRfcm9vdDsKLQkJbmQtPnNlcSA9IHJlYWRfc2VxY291bnRfYmVnaW4oJnBhdGgtPmRlbnRyeS0+ZF9zZXEpOwotCQkqaW5vZGUgPSBwYXRoLT5kZW50cnktPmRfaW5vZGU7Ci0JfQotfQorCXN0cnVjdCB2ZnNtb3VudCAqbW50OworCWludCBlcnI7CiAKLXN0YXRpYyBpbnQgX19mb2xsb3dfbW91bnQoc3RydWN0IHBhdGggKnBhdGgpCi17Ci0JaW50IHJlcyA9IDA7Ci0Jd2hpbGUgKGRfbW91bnRwb2ludChwYXRoLT5kZW50cnkpKSB7Ci0JCXN0cnVjdCB2ZnNtb3VudCAqbW91bnRlZCA9IGxvb2t1cF9tbnQocGF0aCk7Ci0JCWlmICghbW91bnRlZCkKLQkJCWJyZWFrOworCWlmICghcGF0aC0+ZGVudHJ5LT5kX29wIHx8ICFwYXRoLT5kZW50cnktPmRfb3AtPmRfYXV0b21vdW50KQorCQlyZXR1cm4gLUVSRU1PVEU7CisKKwkvKiBXZSBkb24ndCB3YW50IHRvIG1vdW50IGlmIHNvbWVvbmUgc3VwcGxpZWQgQVRfTk9fQVVUT01PVU5UCisJICogYW5kIHRoaXMgaXMgdGhlIHRlcm1pbmFsIHBhcnQgb2YgdGhlIHBhdGguCisJICovCisJaWYgKChmbGFncyAmIExPT0tVUF9OT19BVVRPTU9VTlQpICYmICEoZmxhZ3MgJiBMT09LVVBfQ09OVElOVUUpKQorCQlyZXR1cm4gLUVJU0RJUjsgLyogd2UgYWN0dWFsbHkgd2FudCB0byBzdG9wIGhlcmUgKi8KKworCS8qIFdlIHdhbnQgdG8gbW91bnQgaWYgc29tZW9uZSBpcyB0cnlpbmcgdG8gb3Blbi9jcmVhdGUgYSBmaWxlIG9mIGFueQorCSAqIHR5cGUgdW5kZXIgdGhlIG1vdW50cG9pbnQsIHdhbnRzIHRvIHRyYXZlcnNlIHRocm91Z2ggdGhlIG1vdW50cG9pbnQKKwkgKiBvciB3YW50cyB0byBvcGVuIHRoZSBtb3VudGVkIGRpcmVjdG9yeS4KKwkgKgorCSAqIFdlIGRvbid0IHdhbnQgdG8gbW91bnQgaWYgc29tZW9uZSdzIGp1c3QgZG9pbmcgYSBzdGF0IGFuZCB0aGV5J3ZlCisJICogc2V0IEFUX1NZTUxJTktfTk9GT0xMT1cgLSB1bmxlc3MgdGhleSdyZSBzdGF0J2luZyBhIGRpcmVjdG9yeSBhbmQKKwkgKiBhcHBlbmRlZCBhICcvJyB0byB0aGUgbmFtZS4KKwkgKi8KKwlpZiAoIShmbGFncyAmIExPT0tVUF9GT0xMT1cpICYmCisJICAgICEoZmxhZ3MgJiAoTE9PS1VQX0NPTlRJTlVFIHwgTE9PS1VQX0RJUkVDVE9SWSB8CisJCSAgICAgICBMT09LVVBfT1BFTiB8IExPT0tVUF9DUkVBVEUpKSkKKwkJcmV0dXJuIC1FSVNESVI7CisKKwljdXJyZW50LT50b3RhbF9saW5rX2NvdW50Kys7CisJaWYgKGN1cnJlbnQtPnRvdGFsX2xpbmtfY291bnQgPj0gNDApCisJCXJldHVybiAtRUxPT1A7CisKKwltbnQgPSBwYXRoLT5kZW50cnktPmRfb3AtPmRfYXV0b21vdW50KHBhdGgpOworCWlmIChJU19FUlIobW50KSkgeworCQkvKgorCQkgKiBUaGUgZmlsZXN5c3RlbSBpcyBhbGxvd2VkIHRvIHJldHVybiAtRUlTRElSIGhlcmUgdG8gaW5kaWNhdGUKKwkJICogaXQgZG9lc24ndCB3YW50IHRvIGF1dG9tb3VudC4gIEZvciBpbnN0YW5jZSwgYXV0b2ZzIHdvdWxkIGRvCisJCSAqIHRoaXMgc28gdGhhdCBpdHMgdXNlcnNwYWNlIGRhZW1vbiBjYW4gbW91bnQgb24gdGhpcyBkZW50cnkuCisJCSAqCisJCSAqIEhvd2V2ZXIsIHdlIGNhbiBvbmx5IHBlcm1pdCB0aGlzIGlmIGl0J3MgYSB0ZXJtaW5hbCBwb2ludCBpbgorCQkgKiB0aGUgcGF0aCBiZWluZyBsb29rZWQgdXA7IGlmIGl0IHdhc24ndCB0aGVuIHRoZSByZW1haW5kZXIgb2YKKwkJICogdGhlIHBhdGggaXMgaW5hY2Nlc3NpYmxlIGFuZCB3ZSBzaG91bGQgc2F5IHNvLgorCQkgKi8KKwkJaWYgKFBUUl9FUlIobW50KSA9PSAtRUlTRElSICYmIChmbGFncyAmIExPT0tVUF9DT05USU5VRSkpCisJCQlyZXR1cm4gLUVSRU1PVEU7CisJCXJldHVybiBQVFJfRVJSKG1udCk7CisJfQorCisJaWYgKCFtbnQpIC8qIG1vdW50IGNvbGxpc2lvbiAqLworCQlyZXR1cm4gMDsKKworCWVyciA9IGZpbmlzaF9hdXRvbW91bnQobW50LCBwYXRoKTsKKworCXN3aXRjaCAoZXJyKSB7CisJY2FzZSAtRUJVU1k6CisJCS8qIFNvbWVvbmUgZWxzZSBtYWRlIGEgbW91bnQgaGVyZSB3aGlsc3Qgd2Ugd2VyZSBidXN5ICovCisJCXJldHVybiAwOworCWNhc2UgMDoKIAkJZHB1dChwYXRoLT5kZW50cnkpOwotCQlpZiAocmVzKQorCQlpZiAoKm5lZWRfbW50cHV0KQogCQkJbW50cHV0KHBhdGgtPm1udCk7Ci0JCXBhdGgtPm1udCA9IG1vdW50ZWQ7Ci0JCXBhdGgtPmRlbnRyeSA9IGRnZXQobW91bnRlZC0+bW50X3Jvb3QpOwotCQlyZXMgPSAxOworCQlwYXRoLT5tbnQgPSBtbnQ7CisJCXBhdGgtPmRlbnRyeSA9IGRnZXQobW50LT5tbnRfcm9vdCk7CisJCSpuZWVkX21udHB1dCA9IHRydWU7CisJCXJldHVybiAwOworCWRlZmF1bHQ6CisJCXJldHVybiBlcnI7CiAJfQotCXJldHVybiByZXM7CisKIH0KIAotc3RhdGljIHZvaWQgZm9sbG93X21vdW50KHN0cnVjdCBwYXRoICpwYXRoKQorLyoKKyAqIEhhbmRsZSBhIGRlbnRyeSB0aGF0IGlzIG1hbmFnZWQgaW4gc29tZSB3YXkuCisgKiAtIEZsYWdnZWQgZm9yIHRyYW5zaXQgbWFuYWdlbWVudCAoYXV0b2ZzKQorICogLSBGbGFnZ2VkIGFzIG1vdW50cG9pbnQKKyAqIC0gRmxhZ2dlZCBhcyBhdXRvbW91bnQgcG9pbnQKKyAqCisgKiBUaGlzIG1heSBvbmx5IGJlIGNhbGxlZCBpbiByZWZ3YWxrIG1vZGUuCisgKgorICogU2VyaWFsaXphdGlvbiBpcyB0YWtlbiBjYXJlIG9mIGluIG5hbWVzcGFjZS5jCisgKi8KK3N0YXRpYyBpbnQgZm9sbG93X21hbmFnZWQoc3RydWN0IHBhdGggKnBhdGgsIHVuc2lnbmVkIGZsYWdzKQogewotCXdoaWxlIChkX21vdW50cG9pbnQocGF0aC0+ZGVudHJ5KSkgewotCQlzdHJ1Y3QgdmZzbW91bnQgKm1vdW50ZWQgPSBsb29rdXBfbW50KHBhdGgpOwotCQlpZiAoIW1vdW50ZWQpCi0JCQlicmVhazsKLQkJZHB1dChwYXRoLT5kZW50cnkpOwotCQltbnRwdXQocGF0aC0+bW50KTsKLQkJcGF0aC0+bW50ID0gbW91bnRlZDsKLQkJcGF0aC0+ZGVudHJ5ID0gZGdldChtb3VudGVkLT5tbnRfcm9vdCk7CisJdW5zaWduZWQgbWFuYWdlZDsKKwlib29sIG5lZWRfbW50cHV0ID0gZmFsc2U7CisJaW50IHJldDsKKworCS8qIEdpdmVuIHRoYXQgd2UncmUgbm90IGhvbGRpbmcgYSBsb2NrIGhlcmUsIHdlIHJldGFpbiB0aGUgdmFsdWUgaW4gYQorCSAqIGxvY2FsIHZhcmlhYmxlIGZvciBlYWNoIGRlbnRyeSBhcyB3ZSBsb29rIGF0IGl0IHNvIHRoYXQgd2UgZG9uJ3Qgc2VlCisJICogdGhlIGNvbXBvbmVudHMgb2YgdGhhdCB2YWx1ZSBjaGFuZ2UgdW5kZXIgdXMgKi8KKwl3aGlsZSAobWFuYWdlZCA9IEFDQ0VTU19PTkNFKHBhdGgtPmRlbnRyeS0+ZF9mbGFncyksCisJICAgICAgIG1hbmFnZWQgJj0gRENBQ0hFX01BTkFHRURfREVOVFJZLAorCSAgICAgICB1bmxpa2VseShtYW5hZ2VkICE9IDApKSB7CisJCS8qIEFsbG93IHRoZSBmaWxlc3lzdGVtIHRvIG1hbmFnZSB0aGUgdHJhbnNpdCB3aXRob3V0IGlfbXV0ZXgKKwkJICogYmVpbmcgaGVsZC4gKi8KKwkJaWYgKG1hbmFnZWQgJiBEQ0FDSEVfTUFOQUdFX1RSQU5TSVQpIHsKKwkJCUJVR19PTighcGF0aC0+ZGVudHJ5LT5kX29wKTsKKwkJCUJVR19PTighcGF0aC0+ZGVudHJ5LT5kX29wLT5kX21hbmFnZSk7CisJCQlyZXQgPSBwYXRoLT5kZW50cnktPmRfb3AtPmRfbWFuYWdlKHBhdGgtPmRlbnRyeSwKKwkJCQkJCQkgICBmYWxzZSwgZmFsc2UpOworCQkJaWYgKHJldCA8IDApCisJCQkJcmV0dXJuIHJldCA9PSAtRUlTRElSID8gMCA6IHJldDsKKwkJfQorCisJCS8qIFRyYW5zaXQgdG8gYSBtb3VudGVkIGZpbGVzeXN0ZW0uICovCisJCWlmIChtYW5hZ2VkICYgRENBQ0hFX01PVU5URUQpIHsKKwkJCXN0cnVjdCB2ZnNtb3VudCAqbW91bnRlZCA9IGxvb2t1cF9tbnQocGF0aCk7CisJCQlpZiAobW91bnRlZCkgeworCQkJCWRwdXQocGF0aC0+ZGVudHJ5KTsKKwkJCQlpZiAobmVlZF9tbnRwdXQpCisJCQkJCW1udHB1dChwYXRoLT5tbnQpOworCQkJCXBhdGgtPm1udCA9IG1vdW50ZWQ7CisJCQkJcGF0aC0+ZGVudHJ5ID0gZGdldChtb3VudGVkLT5tbnRfcm9vdCk7CisJCQkJbmVlZF9tbnRwdXQgPSB0cnVlOworCQkJCWNvbnRpbnVlOworCQkJfQorCisJCQkvKiBTb21ldGhpbmcgaXMgbW91bnRlZCBvbiB0aGlzIGRlbnRyeSBpbiBhbm90aGVyCisJCQkgKiBuYW1lc3BhY2UgYW5kL29yIHdoYXRldmVyIHdhcyBtb3VudGVkIHRoZXJlIGluIHRoaXMKKwkJCSAqIG5hbWVzcGFjZSBnb3QgdW5tb3VudGVkIGJlZm9yZSB3ZSBtYW5hZ2VkIHRvIGdldCB0aGUKKwkJCSAqIHZmc21vdW50X2xvY2sgKi8KKwkJfQorCisJCS8qIEhhbmRsZSBhbiBhdXRvbW91bnQgcG9pbnQgKi8KKwkJaWYgKG1hbmFnZWQgJiBEQ0FDSEVfTkVFRF9BVVRPTU9VTlQpIHsKKwkJCXJldCA9IGZvbGxvd19hdXRvbW91bnQocGF0aCwgZmxhZ3MsICZuZWVkX21udHB1dCk7CisJCQlpZiAocmV0IDwgMCkKKwkJCQlyZXR1cm4gcmV0ID09IC1FSVNESVIgPyAwIDogcmV0OworCQkJY29udGludWU7CisJCX0KKworCQkvKiBXZSBkaWRuJ3QgY2hhbmdlIHRoZSBjdXJyZW50IHBhdGggcG9pbnQgKi8KKwkJYnJlYWs7CiAJfQorCXJldHVybiAwOwogfQogCi1pbnQgZm9sbG93X2Rvd24oc3RydWN0IHBhdGggKnBhdGgpCitpbnQgZm9sbG93X2Rvd25fb25lKHN0cnVjdCBwYXRoICpwYXRoKQogewogCXN0cnVjdCB2ZnNtb3VudCAqbW91bnRlZDsKIApAQCAtOTM5LDEzICsxMDI4LDQxIEBACiAJcmV0dXJuIDA7CiB9CiAKKy8qCisgKiBTa2lwIHRvIHRvcCBvZiBtb3VudHBvaW50IHBpbGUgaW4gcmN1d2FsayBtb2RlLiAgV2UgYWJvcnQgdGhlIHJjdS13YWxrIGlmIHdlCisgKiBtZWV0IGEgbWFuYWdlZCBkZW50cnkgYW5kIHdlJ3JlIG5vdCB3YWxraW5nIHRvICIuLiIuICBUcnVlIGlzIHJldHVybmVkIHRvCisgKiBjb250aW51ZSwgZmFsc2UgdG8gYWJvcnQuCisgKi8KK3N0YXRpYyBib29sIF9fZm9sbG93X21vdW50X3JjdShzdHJ1Y3QgbmFtZWlkYXRhICpuZCwgc3RydWN0IHBhdGggKnBhdGgsCisJCQkgICAgICAgc3RydWN0IGlub2RlICoqaW5vZGUsIGJvb2wgcmV2ZXJzZV90cmFuc2l0KQoreworCXdoaWxlIChkX21vdW50cG9pbnQocGF0aC0+ZGVudHJ5KSkgeworCQlzdHJ1Y3QgdmZzbW91bnQgKm1vdW50ZWQ7CisJCWlmICh1bmxpa2VseShwYXRoLT5kZW50cnktPmRfZmxhZ3MgJiBEQ0FDSEVfTUFOQUdFX1RSQU5TSVQpICYmCisJCSAgICAhcmV2ZXJzZV90cmFuc2l0ICYmCisJCSAgICBwYXRoLT5kZW50cnktPmRfb3AtPmRfbWFuYWdlKHBhdGgtPmRlbnRyeSwgZmFsc2UsIHRydWUpIDwgMCkKKwkJCXJldHVybiBmYWxzZTsKKwkJbW91bnRlZCA9IF9fbG9va3VwX21udChwYXRoLT5tbnQsIHBhdGgtPmRlbnRyeSwgMSk7CisJCWlmICghbW91bnRlZCkKKwkJCWJyZWFrOworCQlwYXRoLT5tbnQgPSBtb3VudGVkOworCQlwYXRoLT5kZW50cnkgPSBtb3VudGVkLT5tbnRfcm9vdDsKKwkJbmQtPnNlcSA9IHJlYWRfc2VxY291bnRfYmVnaW4oJnBhdGgtPmRlbnRyeS0+ZF9zZXEpOworCQkqaW5vZGUgPSBwYXRoLT5kZW50cnktPmRfaW5vZGU7CisJfQorCisJaWYgKHVubGlrZWx5KHBhdGgtPmRlbnRyeS0+ZF9mbGFncyAmIERDQUNIRV9ORUVEX0FVVE9NT1VOVCkpCisJCXJldHVybiByZXZlcnNlX3RyYW5zaXQ7CisJcmV0dXJuIHRydWU7Cit9CisKIHN0YXRpYyBpbnQgZm9sbG93X2RvdGRvdF9yY3Uoc3RydWN0IG5hbWVpZGF0YSAqbmQpCiB7CiAJc3RydWN0IGlub2RlICppbm9kZSA9IG5kLT5pbm9kZTsKIAogCXNldF9yb290X3JjdShuZCk7CiAKLQl3aGlsZSgxKSB7CisJd2hpbGUgKDEpIHsKIAkJaWYgKG5kLT5wYXRoLmRlbnRyeSA9PSBuZC0+cm9vdC5kZW50cnkgJiYKIAkJICAgIG5kLT5wYXRoLm1udCA9PSBuZC0+cm9vdC5tbnQpIHsKIAkJCWJyZWFrOwpAQCAtOTY4LDEyICsxMDg1LDgwIEBACiAJCW5kLT5zZXEgPSByZWFkX3NlcWNvdW50X2JlZ2luKCZuZC0+cGF0aC5kZW50cnktPmRfc2VxKTsKIAkJaW5vZGUgPSBuZC0+cGF0aC5kZW50cnktPmRfaW5vZGU7CiAJfQotCV9fZm9sbG93X21vdW50X3JjdShuZCwgJm5kLT5wYXRoLCAmaW5vZGUpOworCV9fZm9sbG93X21vdW50X3JjdShuZCwgJm5kLT5wYXRoLCAmaW5vZGUsIHRydWUpOwogCW5kLT5pbm9kZSA9IGlub2RlOwogCiAJcmV0dXJuIDA7CiB9CiAKKy8qCisgKiBGb2xsb3cgZG93biB0byB0aGUgY292ZXJpbmcgbW91bnQgY3VycmVudGx5IHZpc2libGUgdG8gdXNlcnNwYWNlLiAgQXQgZWFjaAorICogcG9pbnQsIHRoZSBmaWxlc3lzdGVtIG93bmluZyB0aGF0IGRlbnRyeSBtYXkgYmUgcXVlcmllZCBhcyB0byB3aGV0aGVyIHRoZQorICogY2FsbGVyIGlzIHBlcm1pdHRlZCB0byBwcm9jZWVkIG9yIG5vdC4KKyAqCisgKiBDYXJlIG11c3QgYmUgdGFrZW4gYXMgbmFtZXNwYWNlX3NlbSBtYXkgYmUgaGVsZCAoaW5kaWNhdGVkIGJ5IG1vdW50aW5nX2hlcmUKKyAqIGJlaW5nIHRydWUpLgorICovCitpbnQgZm9sbG93X2Rvd24oc3RydWN0IHBhdGggKnBhdGgsIGJvb2wgbW91bnRpbmdfaGVyZSkKK3sKKwl1bnNpZ25lZCBtYW5hZ2VkOworCWludCByZXQ7CisKKwl3aGlsZSAobWFuYWdlZCA9IEFDQ0VTU19PTkNFKHBhdGgtPmRlbnRyeS0+ZF9mbGFncyksCisJICAgICAgIHVubGlrZWx5KG1hbmFnZWQgJiBEQ0FDSEVfTUFOQUdFRF9ERU5UUlkpKSB7CisJCS8qIEFsbG93IHRoZSBmaWxlc3lzdGVtIHRvIG1hbmFnZSB0aGUgdHJhbnNpdCB3aXRob3V0IGlfbXV0ZXgKKwkJICogYmVpbmcgaGVsZC4KKwkJICoKKwkJICogV2UgaW5kaWNhdGUgdG8gdGhlIGZpbGVzeXN0ZW0gaWYgc29tZW9uZSBpcyB0cnlpbmcgdG8gbW91bnQKKwkJICogc29tZXRoaW5nIGhlcmUuICBUaGlzIGdpdmVzIGF1dG9mcyB0aGUgY2hhbmNlIHRvIGRlbnkgYW55b25lCisJCSAqIG90aGVyIHRoYW4gaXRzIGRhZW1vbiB0aGUgcmlnaHQgdG8gbW91bnQgb24gaXRzCisJCSAqIHN1cGVyc3RydWN0dXJlLgorCQkgKgorCQkgKiBUaGUgZmlsZXN5c3RlbSBtYXkgc2xlZXAgYXQgdGhpcyBwb2ludC4KKwkJICovCisJCWlmIChtYW5hZ2VkICYgRENBQ0hFX01BTkFHRV9UUkFOU0lUKSB7CisJCQlCVUdfT04oIXBhdGgtPmRlbnRyeS0+ZF9vcCk7CisJCQlCVUdfT04oIXBhdGgtPmRlbnRyeS0+ZF9vcC0+ZF9tYW5hZ2UpOworCQkJcmV0ID0gcGF0aC0+ZGVudHJ5LT5kX29wLT5kX21hbmFnZSgKKwkJCQlwYXRoLT5kZW50cnksIG1vdW50aW5nX2hlcmUsIGZhbHNlKTsKKwkJCWlmIChyZXQgPCAwKQorCQkJCXJldHVybiByZXQgPT0gLUVJU0RJUiA/IDAgOiByZXQ7CisJCX0KKworCQkvKiBUcmFuc2l0IHRvIGEgbW91bnRlZCBmaWxlc3lzdGVtLiAqLworCQlpZiAobWFuYWdlZCAmIERDQUNIRV9NT1VOVEVEKSB7CisJCQlzdHJ1Y3QgdmZzbW91bnQgKm1vdW50ZWQgPSBsb29rdXBfbW50KHBhdGgpOworCQkJaWYgKCFtb3VudGVkKQorCQkJCWJyZWFrOworCQkJZHB1dChwYXRoLT5kZW50cnkpOworCQkJbW50cHV0KHBhdGgtPm1udCk7CisJCQlwYXRoLT5tbnQgPSBtb3VudGVkOworCQkJcGF0aC0+ZGVudHJ5ID0gZGdldChtb3VudGVkLT5tbnRfcm9vdCk7CisJCQljb250aW51ZTsKKwkJfQorCisJCS8qIERvbid0IGhhbmRsZSBhdXRvbW91bnQgcG9pbnRzIGhlcmUgKi8KKwkJYnJlYWs7CisJfQorCXJldHVybiAwOworfQorCisvKgorICogU2tpcCB0byB0b3Agb2YgbW91bnRwb2ludCBwaWxlIGluIHJlZndhbGsgbW9kZSBmb3IgZm9sbG93X2RvdGRvdCgpCisgKi8KK3N0YXRpYyB2b2lkIGZvbGxvd19tb3VudChzdHJ1Y3QgcGF0aCAqcGF0aCkKK3sKKwl3aGlsZSAoZF9tb3VudHBvaW50KHBhdGgtPmRlbnRyeSkpIHsKKwkJc3RydWN0IHZmc21vdW50ICptb3VudGVkID0gbG9va3VwX21udChwYXRoKTsKKwkJaWYgKCFtb3VudGVkKQorCQkJYnJlYWs7CisJCWRwdXQocGF0aC0+ZGVudHJ5KTsKKwkJbW50cHV0KHBhdGgtPm1udCk7CisJCXBhdGgtPm1udCA9IG1vdW50ZWQ7CisJCXBhdGgtPmRlbnRyeSA9IGRnZXQobW91bnRlZC0+bW50X3Jvb3QpOworCX0KK30KKwogc3RhdGljIHZvaWQgZm9sbG93X2RvdGRvdChzdHJ1Y3QgbmFtZWlkYXRhICpuZCkKIHsKIAlzZXRfcm9vdChuZCk7CkBAIC0xMDM4LDEyICsxMjIzLDE0IEBACiAJc3RydWN0IHZmc21vdW50ICptbnQgPSBuZC0+cGF0aC5tbnQ7CiAJc3RydWN0IGRlbnRyeSAqZGVudHJ5LCAqcGFyZW50ID0gbmQtPnBhdGguZGVudHJ5OwogCXN0cnVjdCBpbm9kZSAqZGlyOworCWludCBlcnI7CisKIAkvKgogCSAqIFNlZSBpZiB0aGUgbG93LWxldmVsIGZpbGVzeXN0ZW0gbWlnaHQgd2FudAogCSAqIHRvIHVzZSBpdHMgb3duIGhhc2guLgogCSAqLwogCWlmICh1bmxpa2VseShwYXJlbnQtPmRfZmxhZ3MgJiBEQ0FDSEVfT1BfSEFTSCkpIHsKLQkJaW50IGVyciA9IHBhcmVudC0+ZF9vcC0+ZF9oYXNoKHBhcmVudCwgbmQtPmlub2RlLCBuYW1lKTsKKwkJZXJyID0gcGFyZW50LT5kX29wLT5kX2hhc2gocGFyZW50LCBuZC0+aW5vZGUsIG5hbWUpOwogCQlpZiAoZXJyIDwgMCkKIAkJCXJldHVybiBlcnI7CiAJfQpAQCAtMTA3MCwyMiArMTI1NywzMCBAQAogCQluZC0+c2VxID0gc2VxOwogCQlpZiAoZGVudHJ5LT5kX2ZsYWdzICYgRENBQ0hFX09QX1JFVkFMSURBVEUpCiAJCQlnb3RvIG5lZWRfcmV2YWxpZGF0ZTsKK2RvbmUyOgogCQlwYXRoLT5tbnQgPSBtbnQ7CiAJCXBhdGgtPmRlbnRyeSA9IGRlbnRyeTsKLQkJX19mb2xsb3dfbW91bnRfcmN1KG5kLCBwYXRoLCBpbm9kZSk7Ci0JfSBlbHNlIHsKLQkJZGVudHJ5ID0gX19kX2xvb2t1cChwYXJlbnQsIG5hbWUpOwotCQlpZiAoIWRlbnRyeSkKLQkJCWdvdG8gbmVlZF9sb29rdXA7Ci1mb3VuZDoKLQkJaWYgKGRlbnRyeS0+ZF9mbGFncyAmIERDQUNIRV9PUF9SRVZBTElEQVRFKQotCQkJZ290byBuZWVkX3JldmFsaWRhdGU7Ci1kb25lOgotCQlwYXRoLT5tbnQgPSBtbnQ7Ci0JCXBhdGgtPmRlbnRyeSA9IGRlbnRyeTsKLQkJX19mb2xsb3dfbW91bnQocGF0aCk7Ci0JCSppbm9kZSA9IHBhdGgtPmRlbnRyeS0+ZF9pbm9kZTsKKwkJaWYgKGxpa2VseShfX2ZvbGxvd19tb3VudF9yY3UobmQsIHBhdGgsIGlub2RlLCBmYWxzZSkpKQorCQkJcmV0dXJuIDA7CisJCWlmIChuYW1laWRhdGFfZHJvcF9yY3UobmQpKQorCQkJcmV0dXJuIC1FQ0hJTEQ7CisJCS8qIGZhbGx0aHJ1ICovCiAJfQorCWRlbnRyeSA9IF9fZF9sb29rdXAocGFyZW50LCBuYW1lKTsKKwlpZiAoIWRlbnRyeSkKKwkJZ290byBuZWVkX2xvb2t1cDsKK2ZvdW5kOgorCWlmIChkZW50cnktPmRfZmxhZ3MgJiBEQ0FDSEVfT1BfUkVWQUxJREFURSkKKwkJZ290byBuZWVkX3JldmFsaWRhdGU7Citkb25lOgorCXBhdGgtPm1udCA9IG1udDsKKwlwYXRoLT5kZW50cnkgPSBkZW50cnk7CisJZXJyID0gZm9sbG93X21hbmFnZWQocGF0aCwgbmQtPmZsYWdzKTsKKwlpZiAodW5saWtlbHkoZXJyIDwgMCkpIHsKKwkJcGF0aF9wdXRfY29uZGl0aW9uYWwocGF0aCwgbmQpOworCQlyZXR1cm4gZXJyOworCX0KKwkqaW5vZGUgPSBwYXRoLT5kZW50cnktPmRfaW5vZGU7CiAJcmV0dXJuIDA7CiAKIG5lZWRfbG9va3VwOgpAQCAtMTEyNCw2ICsxMzE5LDggQEAKIAkJZ290byBuZWVkX2xvb2t1cDsKIAlpZiAoSVNfRVJSKGRlbnRyeSkpCiAJCWdvdG8gZmFpbDsKKwlpZiAobmQtPmZsYWdzICYgTE9PS1VQX1JDVSkKKwkJZ290byBkb25lMjsKIAlnb3RvIGRvbmU7CiAKIGZhaWw6CkBAIC0xMTMxLDE3ICsxMzI4LDYgQEAKIH0KIAogLyoKLSAqIFRoaXMgaXMgYSB0ZW1wb3Jhcnkga2x1ZGdlIHRvIGRlYWwgd2l0aCAiYXV0b21vdW50IiBzeW1saW5rczsgcHJvcGVyCi0gKiBzb2x1dGlvbiBpcyB0byB0cmlnZ2VyIHRoZW0gb24gZm9sbG93X21vdW50KCksIHNvIHRoYXQgZG9fbG9va3VwKCkKLSAqIHdvdWxkIERUUlQuICBUbyBiZSBraWxsZWQgYmVmb3JlIDIuNi4zNC1maW5hbC4KLSAqLwotc3RhdGljIGlubGluZSBpbnQgZm9sbG93X29uX2ZpbmFsKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHVuc2lnbmVkIGxvb2t1cF9mbGFncykKLXsKLQlyZXR1cm4gaW5vZGUgJiYgdW5saWtlbHkoaW5vZGUtPmlfb3AtPmZvbGxvd19saW5rKSAmJgotCQkoKGxvb2t1cF9mbGFncyAmIExPT0tVUF9GT0xMT1cpIHx8IFNfSVNESVIoaW5vZGUtPmlfbW9kZSkpOwotfQotCi0vKgogICogTmFtZSByZXNvbHV0aW9uLgogICogVGhpcyBpcyB0aGUgYmFzaWMgbmFtZSByZXNvbHV0aW9uIGZ1bmN0aW9uLCB0dXJuaW5nIGEgcGF0aG5hbWUgaW50bwogICogdGhlIGZpbmFsIGRlbnRyeS4gV2UgZXhwZWN0ICdiYXNlJyB0byBiZSBwb3NpdGl2ZSBhbmQgYSBkaXJlY3RvcnkuCkBAIC0xMjc5LDcgKzE0NjUsOCBAQAogCQllcnIgPSBkb19sb29rdXAobmQsICZ0aGlzLCAmbmV4dCwgJmlub2RlKTsKIAkJaWYgKGVycikKIAkJCWJyZWFrOwotCQlpZiAoZm9sbG93X29uX2ZpbmFsKGlub2RlLCBsb29rdXBfZmxhZ3MpKSB7CisJCWlmIChpbm9kZSAmJiB1bmxpa2VseShpbm9kZS0+aV9vcC0+Zm9sbG93X2xpbmspICYmCisJCSAgICAobG9va3VwX2ZsYWdzICYgTE9PS1VQX0ZPTExPVykpIHsKIAkJCWlmIChuYW1laWRhdGFfZGVudHJ5X2Ryb3BfcmN1X21heWJlKG5kLCBuZXh0LmRlbnRyeSkpCiAJCQkJcmV0dXJuIC1FQ0hJTEQ7CiAJCQlCVUdfT04oaW5vZGUgIT0gbmV4dC5kZW50cnktPmRfaW5vZGUpOwpAQCAtMjA4Miw4ICsyMjY5LDYgQEAKIAlyZXR1cm4gZmlscDsKIAogZXhpdDoKLQlpZiAoIUlTX0VSUihuZC0+aW50ZW50Lm9wZW4uZmlsZSkpCi0JCXJlbGVhc2Vfb3Blbl9pbnRlbnQobmQpOwogCXBhdGhfcHV0KCZuZC0+cGF0aCk7CiAJcmV0dXJuIEVSUl9QVFIoZXJyb3IpOwogfQpAQCAtMjEwNSwxMSArMjI5MCwxMyBAQAogCQlkaXIgPSBuZC0+cGF0aC5kZW50cnk7CiAJY2FzZSBMQVNUX0RPVDoKIAkJaWYgKG5lZWRfcmV2YWxfZG90KGRpcikpIHsKLQkJCWVycm9yID0gZF9yZXZhbGlkYXRlKG5kLT5wYXRoLmRlbnRyeSwgbmQpOwotCQkJaWYgKCFlcnJvcikKLQkJCQllcnJvciA9IC1FU1RBTEU7Ci0JCQlpZiAoZXJyb3IgPCAwKQorCQkJaW50IHN0YXR1cyA9IGRfcmV2YWxpZGF0ZShuZC0+cGF0aC5kZW50cnksIG5kKTsKKwkJCWlmICghc3RhdHVzKQorCQkJCXN0YXR1cyA9IC1FU1RBTEU7CisJCQlpZiAoc3RhdHVzIDwgMCkgeworCQkJCWVycm9yID0gc3RhdHVzOwogCQkJCWdvdG8gZXhpdDsKKwkJCX0KIAkJfQogCQkvKiBmYWxsdGhyb3VnaCAqLwogCWNhc2UgTEFTVF9ST09UOgpAQCAtMjE3OSwxMSArMjM2Niw5IEBACiAJaWYgKG9wZW5fZmxhZyAmIE9fRVhDTCkKIAkJZ290byBleGl0X2RwdXQ7CiAKLQlpZiAoX19mb2xsb3dfbW91bnQocGF0aCkpIHsKLQkJZXJyb3IgPSAtRUxPT1A7Ci0JCWlmIChvcGVuX2ZsYWcgJiBPX05PRk9MTE9XKQotCQkJZ290byBleGl0X2RwdXQ7Ci0JfQorCWVycm9yID0gZm9sbG93X21hbmFnZWQocGF0aCwgbmQtPmZsYWdzKTsKKwlpZiAoZXJyb3IgPCAwKQorCQlnb3RvIGV4aXRfZHB1dDsKIAogCWVycm9yID0gLUVOT0VOVDsKIAlpZiAoIXBhdGgtPmRlbnRyeS0+ZF9pbm9kZSkKQEAgLTIyMDYsOCArMjM5MSw2IEBACiBleGl0X2RwdXQ6CiAJcGF0aF9wdXRfY29uZGl0aW9uYWwocGF0aCwgbmQpOwogZXhpdDoKLQlpZiAoIUlTX0VSUihuZC0+aW50ZW50Lm9wZW4uZmlsZSkpCi0JCXJlbGVhc2Vfb3Blbl9pbnRlbnQobmQpOwogCXBhdGhfcHV0KCZuZC0+cGF0aCk7CiAJcmV0dXJuIEVSUl9QVFIoZXJyb3IpOwogfQpAQCAtMjI5NCw2ICsyNDc3LDcgQEAKIAl9CiAJYXVkaXRfaW5vZGUocGF0aG5hbWUsIG5kLnBhdGguZGVudHJ5KTsKIAlmaWxwID0gZmluaXNoX29wZW4oJm5kLCBvcGVuX2ZsYWcsIGFjY19tb2RlKTsKKwlyZWxlYXNlX29wZW5faW50ZW50KCZuZCk7CiAJcmV0dXJuIGZpbHA7CiAKIGNyZWF0OgpAQCAtMjMyOCwxMSArMjUxMiwxMSBAQAogCW5kLmZsYWdzID0gZmxhZ3M7CiAJZmlscCA9IGRvX2xhc3QoJm5kLCAmcGF0aCwgb3Blbl9mbGFnLCBhY2NfbW9kZSwgbW9kZSwgcGF0aG5hbWUpOwogCXdoaWxlICh1bmxpa2VseSghZmlscCkpIHsgLyogdHJhaWxpbmcgc3ltbGluayAqLwotCQlzdHJ1Y3QgcGF0aCBob2xkZXI7CisJCXN0cnVjdCBwYXRoIGxpbmsgPSBwYXRoOworCQlzdHJ1Y3QgaW5vZGUgKmxpbmtpID0gbGluay5kZW50cnktPmRfaW5vZGU7CiAJCXZvaWQgKmNvb2tpZTsKIAkJZXJyb3IgPSAtRUxPT1A7Ci0JCS8qIFNfSVNESVIgcGFydCBpcyBhIHRlbXBvcmFyeSBhdXRvbW91bnQga2x1ZGdlICovCi0JCWlmICghKG5kLmZsYWdzICYgTE9PS1VQX0ZPTExPVykgJiYgIVNfSVNESVIobmQuaW5vZGUtPmlfbW9kZSkpCisJCWlmICghKG5kLmZsYWdzICYgTE9PS1VQX0ZPTExPVykpCiAJCQlnb3RvIGV4aXRfZHB1dDsKIAkJaWYgKGNvdW50KysgPT0gMzIpCiAJCQlnb3RvIGV4aXRfZHB1dDsKQEAgLTIzNDgsMjkgKzI1MzIsMjkgQEAKIAkJICoganVzdCBzZXQgTEFTVF9CSU5ELgogCQkgKi8KIAkJbmQuZmxhZ3MgfD0gTE9PS1VQX1BBUkVOVDsKLQkJZXJyb3IgPSBzZWN1cml0eV9pbm9kZV9mb2xsb3dfbGluayhwYXRoLmRlbnRyeSwgJm5kKTsKKwkJZXJyb3IgPSBzZWN1cml0eV9pbm9kZV9mb2xsb3dfbGluayhsaW5rLmRlbnRyeSwgJm5kKTsKIAkJaWYgKGVycm9yKQogCQkJZ290byBleGl0X2RwdXQ7Ci0JCWVycm9yID0gX19kb19mb2xsb3dfbGluaygmcGF0aCwgJm5kLCAmY29va2llKTsKKwkJZXJyb3IgPSBfX2RvX2ZvbGxvd19saW5rKCZsaW5rLCAmbmQsICZjb29raWUpOwogCQlpZiAodW5saWtlbHkoZXJyb3IpKSB7Ci0JCQlpZiAoIUlTX0VSUihjb29raWUpICYmIG5kLmlub2RlLT5pX29wLT5wdXRfbGluaykKLQkJCQluZC5pbm9kZS0+aV9vcC0+cHV0X2xpbmsocGF0aC5kZW50cnksICZuZCwgY29va2llKTsKKwkJCWlmICghSVNfRVJSKGNvb2tpZSkgJiYgbGlua2ktPmlfb3AtPnB1dF9saW5rKQorCQkJCWxpbmtpLT5pX29wLT5wdXRfbGluayhsaW5rLmRlbnRyeSwgJm5kLCBjb29raWUpOwogCQkJLyogbmQucGF0aCBoYWQgYmVlbiBkcm9wcGVkICovCi0JCQluZC5wYXRoID0gcGF0aDsKKwkJCW5kLnBhdGggPSBsaW5rOwogCQkJZ290byBvdXRfcGF0aDsKIAkJfQotCQlob2xkZXIgPSBwYXRoOwogCQluZC5mbGFncyAmPSB+TE9PS1VQX1BBUkVOVDsKIAkJZmlscCA9IGRvX2xhc3QoJm5kLCAmcGF0aCwgb3Blbl9mbGFnLCBhY2NfbW9kZSwgbW9kZSwgcGF0aG5hbWUpOwotCQlpZiAobmQuaW5vZGUtPmlfb3AtPnB1dF9saW5rKQotCQkJbmQuaW5vZGUtPmlfb3AtPnB1dF9saW5rKGhvbGRlci5kZW50cnksICZuZCwgY29va2llKTsKLQkJcGF0aF9wdXQoJmhvbGRlcik7CisJCWlmIChsaW5raS0+aV9vcC0+cHV0X2xpbmspCisJCQlsaW5raS0+aV9vcC0+cHV0X2xpbmsobGluay5kZW50cnksICZuZCwgY29va2llKTsKKwkJcGF0aF9wdXQoJmxpbmspOwogCX0KIG91dDoKIAlpZiAobmQucm9vdC5tbnQpCiAJCXBhdGhfcHV0KCZuZC5yb290KTsKIAlpZiAoZmlscCA9PSBFUlJfUFRSKC1FU1RBTEUpICYmICEoZmxhZ3MgJiBMT09LVVBfUkVWQUwpKQogCQlnb3RvIHJldmFsOworCXJlbGVhc2Vfb3Blbl9pbnRlbnQoJm5kKTsKIAlyZXR1cm4gZmlscDsKIAogZXhpdF9kcHV0OgpAQCAtMjM3OCw4ICsyNTYyLDYgQEAKIG91dF9wYXRoOgogCXBhdGhfcHV0KCZuZC5wYXRoKTsKIG91dF9maWxwOgotCWlmICghSVNfRVJSKG5kLmludGVudC5vcGVuLmZpbGUpKQotCQlyZWxlYXNlX29wZW5faW50ZW50KCZuZCk7CiAJZmlscCA9IEVSUl9QVFIoZXJyb3IpOwogCWdvdG8gb3V0OwogfQpAQCAtMzM5Miw2ICszNTc0LDcgQEAKIH07CiAKIEVYUE9SVF9TWU1CT0wodXNlcl9wYXRoX2F0KTsKK0VYUE9SVF9TWU1CT0woZm9sbG93X2Rvd25fb25lKTsKIEVYUE9SVF9TWU1CT0woZm9sbG93X2Rvd24pOwogRVhQT1JUX1NZTUJPTChmb2xsb3dfdXApOwogRVhQT1JUX1NZTUJPTChnZXRfd3JpdGVfYWNjZXNzKTsgLyogYmluZm10X2FvdXQgKi8KZGlmZiAtLWdpdCBhL2ZzL25hbWVzcGFjZS5jIGIvZnMvbmFtZXNwYWNlLmMKaW5kZXggM2RkZmQ5MC4uN2IwYjk1MyAxMDA2NDQKLS0tIGEvZnMvbmFtZXNwYWNlLmMKKysrIGIvZnMvbmFtZXNwYWNlLmMKQEAgLTE4Myw3ICsxODMsNyBAQAogdW5zaWduZWQgaW50IG1udF9nZXRfY291bnQoc3RydWN0IHZmc21vdW50ICptbnQpCiB7CiAjaWZkZWYgQ09ORklHX1NNUAotCXVuc2lnbmVkIGludCBjb3VudCA9IGF0b21pY19yZWFkKCZtbnQtPm1udF9sb25ncmVmcyk7CisJdW5zaWduZWQgaW50IGNvdW50ID0gMDsKIAlpbnQgY3B1OwogCiAJZm9yX2VhY2hfcG9zc2libGVfY3B1KGNwdSkgewpAQCAtMjE3LDcgKzIxNyw3IEBACiAJCWlmICghbW50LT5tbnRfcGNwKQogCQkJZ290byBvdXRfZnJlZV9kZXZuYW1lOwogCi0JCWF0b21pY19zZXQoJm1udC0+bW50X2xvbmdyZWZzLCAxKTsKKwkJdGhpc19jcHVfYWRkKG1udC0+bW50X3BjcC0+bW50X2NvdW50LCAxKTsKICNlbHNlCiAJCW1udC0+bW50X2NvdW50ID0gMTsKIAkJbW50LT5tbnRfd3JpdGVycyA9IDA7CkBAIC02MTEsNiArNjExLDIxIEBACiAJbGlzdF9hZGRfdGFpbCgmbW50LT5tbnRfY2hpbGQsICZwYXRoLT5tbnQtPm1udF9tb3VudHMpOwogfQogCitzdGF0aWMgaW5saW5lIHZvaWQgX19tbnRfbWFrZV9sb25ndGVybShzdHJ1Y3QgdmZzbW91bnQgKm1udCkKK3sKKyNpZmRlZiBDT05GSUdfU01QCisJYXRvbWljX2luYygmbW50LT5tbnRfbG9uZ3Rlcm0pOworI2VuZGlmCit9CisKKy8qIG5lZWRzIHZmc21vdW50IGxvY2sgZm9yIHdyaXRlICovCitzdGF0aWMgaW5saW5lIHZvaWQgX19tbnRfbWFrZV9zaG9ydHRlcm0oc3RydWN0IHZmc21vdW50ICptbnQpCit7CisjaWZkZWYgQ09ORklHX1NNUAorCWF0b21pY19kZWMoJm1udC0+bW50X2xvbmd0ZXJtKTsKKyNlbmRpZgorfQorCiAvKgogICogdmZzbW91bnQgbG9jayBtdXN0IGJlIGhlbGQgZm9yIHdyaXRlCiAgKi8KQEAgLTYyNCw4ICs2MzksMTEgQEAKIAlCVUdfT04ocGFyZW50ID09IG1udCk7CiAKIAlsaXN0X2FkZF90YWlsKCZoZWFkLCAmbW50LT5tbnRfbGlzdCk7Ci0JbGlzdF9mb3JfZWFjaF9lbnRyeShtLCAmaGVhZCwgbW50X2xpc3QpCisJbGlzdF9mb3JfZWFjaF9lbnRyeShtLCAmaGVhZCwgbW50X2xpc3QpIHsKIAkJbS0+bW50X25zID0gbjsKKwkJX19tbnRfbWFrZV9sb25ndGVybShtKTsKKwl9CisKIAlsaXN0X3NwbGljZSgmaGVhZCwgbi0+bGlzdC5wcmV2KTsKIAogCWxpc3RfYWRkX3RhaWwoJm1udC0+bW50X2hhc2gsIG1vdW50X2hhc2h0YWJsZSArCkBAIC03MzQsNTEgKzc1MiwzMCBAQAogCWRlYWN0aXZhdGVfc3VwZXIoc2IpOwogfQogCi0jaWZkZWYgQ09ORklHX1NNUAotc3RhdGljIGlubGluZSB2b2lkIF9fbW50cHV0KHN0cnVjdCB2ZnNtb3VudCAqbW50LCBpbnQgbG9uZ3JlZnMpCitzdGF0aWMgdm9pZCBtbnRwdXRfbm9fZXhwaXJlKHN0cnVjdCB2ZnNtb3VudCAqbW50KQogewotCWlmICghbG9uZ3JlZnMpIHsKIHB1dF9hZ2FpbjoKLQkJYnJfcmVhZF9sb2NrKHZmc21vdW50X2xvY2spOwotCQlpZiAobGlrZWx5KGF0b21pY19yZWFkKCZtbnQtPm1udF9sb25ncmVmcykpKSB7Ci0JCQltbnRfZGVjX2NvdW50KG1udCk7Ci0JCQlicl9yZWFkX3VubG9jayh2ZnNtb3VudF9sb2NrKTsKLQkJCXJldHVybjsKLQkJfQorI2lmZGVmIENPTkZJR19TTVAKKwlicl9yZWFkX2xvY2sodmZzbW91bnRfbG9jayk7CisJaWYgKGxpa2VseShhdG9taWNfcmVhZCgmbW50LT5tbnRfbG9uZ3Rlcm0pKSkgeworCQltbnRfZGVjX2NvdW50KG1udCk7CiAJCWJyX3JlYWRfdW5sb2NrKHZmc21vdW50X2xvY2spOwotCX0gZWxzZSB7Ci0JCUJVR19PTighYXRvbWljX3JlYWQoJm1udC0+bW50X2xvbmdyZWZzKSk7Ci0JCWlmIChhdG9taWNfYWRkX3VubGVzcygmbW50LT5tbnRfbG9uZ3JlZnMsIC0xLCAxKSkKLQkJCXJldHVybjsKKwkJcmV0dXJuOwogCX0KKwlicl9yZWFkX3VubG9jayh2ZnNtb3VudF9sb2NrKTsKIAogCWJyX3dyaXRlX2xvY2sodmZzbW91bnRfbG9jayk7Ci0JaWYgKCFsb25ncmVmcykKLQkJbW50X2RlY19jb3VudChtbnQpOwotCWVsc2UKLQkJYXRvbWljX2RlYygmbW50LT5tbnRfbG9uZ3JlZnMpOworCW1udF9kZWNfY291bnQobW50KTsKIAlpZiAobW50X2dldF9jb3VudChtbnQpKSB7CiAJCWJyX3dyaXRlX3VubG9jayh2ZnNtb3VudF9sb2NrKTsKIAkJcmV0dXJuOwogCX0KLQlpZiAodW5saWtlbHkobW50LT5tbnRfcGlubmVkKSkgewotCQltbnRfYWRkX2NvdW50KG1udCwgbW50LT5tbnRfcGlubmVkICsgMSk7Ci0JCW1udC0+bW50X3Bpbm5lZCA9IDA7Ci0JCWJyX3dyaXRlX3VubG9jayh2ZnNtb3VudF9sb2NrKTsKLQkJYWNjdF9hdXRvX2Nsb3NlX21udChtbnQpOwotCQlnb3RvIHB1dF9hZ2FpbjsKLQl9Ci0JYnJfd3JpdGVfdW5sb2NrKHZmc21vdW50X2xvY2spOwotCW1udGZyZWUobW50KTsKLX0KICNlbHNlCi1zdGF0aWMgaW5saW5lIHZvaWQgX19tbnRwdXQoc3RydWN0IHZmc21vdW50ICptbnQsIGludCBsb25ncmVmcykKLXsKLXB1dF9hZ2FpbjoKIAltbnRfZGVjX2NvdW50KG1udCk7CiAJaWYgKGxpa2VseShtbnRfZ2V0X2NvdW50KG1udCkpKQogCQlyZXR1cm47CiAJYnJfd3JpdGVfbG9jayh2ZnNtb3VudF9sb2NrKTsKKyNlbmRpZgogCWlmICh1bmxpa2VseShtbnQtPm1udF9waW5uZWQpKSB7CiAJCW1udF9hZGRfY291bnQobW50LCBtbnQtPm1udF9waW5uZWQgKyAxKTsKIAkJbW50LT5tbnRfcGlubmVkID0gMDsKQEAgLTc4OSwxMiArNzg2LDYgQEAKIAlicl93cml0ZV91bmxvY2sodmZzbW91bnRfbG9jayk7CiAJbW50ZnJlZShtbnQpOwogfQotI2VuZGlmCi0KLXN0YXRpYyB2b2lkIG1udHB1dF9ub19leHBpcmUoc3RydWN0IHZmc21vdW50ICptbnQpCi17Ci0JX19tbnRwdXQobW50LCAwKTsKLX0KIAogdm9pZCBtbnRwdXQoc3RydWN0IHZmc21vdW50ICptbnQpCiB7CkBAIC04MDIsNyArNzkzLDcgQEAKIAkJLyogYXZvaWQgY2FjaGVsaW5lIHBpbmdwb25nLCBob3BlIGdjYyBkb2Vzbid0IGdldCAic21hcnQiICovCiAJCWlmICh1bmxpa2VseShtbnQtPm1udF9leHBpcnlfbWFyaykpCiAJCQltbnQtPm1udF9leHBpcnlfbWFyayA9IDA7Ci0JCV9fbW50cHV0KG1udCwgMCk7CisJCW1udHB1dF9ub19leHBpcmUobW50KTsKIAl9CiB9CiBFWFBPUlRfU1lNQk9MKG1udHB1dCk7CkBAIC04MTUsMzMgKzgwNiw2IEBACiB9CiBFWFBPUlRfU1lNQk9MKG1udGdldCk7CiAKLXZvaWQgbW50cHV0X2xvbmcoc3RydWN0IHZmc21vdW50ICptbnQpCi17Ci0jaWZkZWYgQ09ORklHX1NNUAotCWlmIChtbnQpIHsKLQkJLyogYXZvaWQgY2FjaGVsaW5lIHBpbmdwb25nLCBob3BlIGdjYyBkb2Vzbid0IGdldCAic21hcnQiICovCi0JCWlmICh1bmxpa2VseShtbnQtPm1udF9leHBpcnlfbWFyaykpCi0JCQltbnQtPm1udF9leHBpcnlfbWFyayA9IDA7Ci0JCV9fbW50cHV0KG1udCwgMSk7Ci0JfQotI2Vsc2UKLQltbnRwdXQobW50KTsKLSNlbmRpZgotfQotRVhQT1JUX1NZTUJPTChtbnRwdXRfbG9uZyk7Ci0KLXN0cnVjdCB2ZnNtb3VudCAqbW50Z2V0X2xvbmcoc3RydWN0IHZmc21vdW50ICptbnQpCi17Ci0jaWZkZWYgQ09ORklHX1NNUAotCWlmIChtbnQpCi0JCWF0b21pY19pbmMoJm1udC0+bW50X2xvbmdyZWZzKTsKLQlyZXR1cm4gbW50OwotI2Vsc2UKLQlyZXR1cm4gbW50Z2V0KG1udCk7Ci0jZW5kaWYKLX0KLUVYUE9SVF9TWU1CT0wobW50Z2V0X2xvbmcpOwotCiB2b2lkIG1udF9waW4oc3RydWN0IHZmc21vdW50ICptbnQpCiB7CiAJYnJfd3JpdGVfbG9jayh2ZnNtb3VudF9sb2NrKTsKQEAgLTEyMTYsNyArMTE4MCw3IEBACiAJCQlkcHV0KGRlbnRyeSk7CiAJCQltbnRwdXQobSk7CiAJCX0KLQkJbW50cHV0X2xvbmcobW50KTsKKwkJbW50cHV0KG1udCk7CiAJfQogfQogCkBAIC0xMjI2LDE5ICsxMTkwLDIxIEBACiAgKi8KIHZvaWQgdW1vdW50X3RyZWUoc3RydWN0IHZmc21vdW50ICptbnQsIGludCBwcm9wYWdhdGUsIHN0cnVjdCBsaXN0X2hlYWQgKmtpbGwpCiB7CisJTElTVF9IRUFEKHRtcF9saXN0KTsKIAlzdHJ1Y3QgdmZzbW91bnQgKnA7CiAKIAlmb3IgKHAgPSBtbnQ7IHA7IHAgPSBuZXh0X21udChwLCBtbnQpKQotCQlsaXN0X21vdmUoJnAtPm1udF9oYXNoLCBraWxsKTsKKwkJbGlzdF9tb3ZlKCZwLT5tbnRfaGFzaCwgJnRtcF9saXN0KTsKIAogCWlmIChwcm9wYWdhdGUpCi0JCXByb3BhZ2F0ZV91bW91bnQoa2lsbCk7CisJCXByb3BhZ2F0ZV91bW91bnQoJnRtcF9saXN0KTsKIAotCWxpc3RfZm9yX2VhY2hfZW50cnkocCwga2lsbCwgbW50X2hhc2gpIHsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHAsICZ0bXBfbGlzdCwgbW50X2hhc2gpIHsKIAkJbGlzdF9kZWxfaW5pdCgmcC0+bW50X2V4cGlyZSk7CiAJCWxpc3RfZGVsX2luaXQoJnAtPm1udF9saXN0KTsKIAkJX190b3VjaF9tbnRfbmFtZXNwYWNlKHAtPm1udF9ucyk7CiAJCXAtPm1udF9ucyA9IE5VTEw7CisJCV9fbW50X21ha2Vfc2hvcnR0ZXJtKHApOwogCQlsaXN0X2RlbF9pbml0KCZwLT5tbnRfY2hpbGQpOwogCQlpZiAocC0+bW50X3BhcmVudCAhPSBwKSB7CiAJCQlwLT5tbnRfcGFyZW50LT5tbnRfZ2hvc3RzKys7CkBAIC0xMjQ2LDYgKzEyMTIsNyBAQAogCQl9CiAJCWNoYW5nZV9tbnRfcHJvcGFnYXRpb24ocCwgTVNfUFJJVkFURSk7CiAJfQorCWxpc3Rfc3BsaWNlKCZ0bXBfbGlzdCwga2lsbCk7CiB9CiAKIHN0YXRpYyB2b2lkIHNocmlua19zdWJtb3VudHMoc3RydWN0IHZmc21vdW50ICptbnQsIHN0cnVjdCBsaXN0X2hlYWQgKnVtb3VudHMpOwpAQCAtMTg0NCw5ICsxODExLDEwIEBACiAJCXJldHVybiBlcnI7CiAKIAlkb3duX3dyaXRlKCZuYW1lc3BhY2Vfc2VtKTsKLQl3aGlsZSAoZF9tb3VudHBvaW50KHBhdGgtPmRlbnRyeSkgJiYKLQkgICAgICAgZm9sbG93X2Rvd24ocGF0aCkpCi0JCTsKKwllcnIgPSBmb2xsb3dfZG93bihwYXRoLCB0cnVlKTsKKwlpZiAoZXJyIDwgMCkKKwkJZ290byBvdXQ7CisKIAllcnIgPSAtRUlOVkFMOwogCWlmICghY2hlY2tfbW50KHBhdGgtPm1udCkgfHwgIWNoZWNrX21udChvbGRfcGF0aC5tbnQpKQogCQlnb3RvIG91dDsKQEAgLTE5MDQsNiArMTg3Miw4IEBACiAJcmV0dXJuIGVycjsKIH0KIAorc3RhdGljIGludCBkb19hZGRfbW91bnQoc3RydWN0IHZmc21vdW50ICosIHN0cnVjdCBwYXRoICosIGludCk7CisKIC8qCiAgKiBjcmVhdGUgYSBuZXcgbW91bnQgZm9yIHVzZXJzcGFjZSBhbmQgcmVxdWVzdCBpdCB0byBiZSBhZGRlZCBpbnRvIHRoZQogICogbmFtZXNwYWNlJ3MgdHJlZQpAQCAtMTkxMiw2ICsxODgyLDcgQEAKIAkJCWludCBtbnRfZmxhZ3MsIGNoYXIgKm5hbWUsIHZvaWQgKmRhdGEpCiB7CiAJc3RydWN0IHZmc21vdW50ICptbnQ7CisJaW50IGVycjsKIAogCWlmICghdHlwZSkKIAkJcmV0dXJuIC1FSU5WQUw7CkBAIC0xOTI0LDE1ICsxODk1LDQ3IEBACiAJaWYgKElTX0VSUihtbnQpKQogCQlyZXR1cm4gUFRSX0VSUihtbnQpOwogCi0JcmV0dXJuIGRvX2FkZF9tb3VudChtbnQsIHBhdGgsIG1udF9mbGFncywgTlVMTCk7CisJZXJyID0gZG9fYWRkX21vdW50KG1udCwgcGF0aCwgbW50X2ZsYWdzKTsKKwlpZiAoZXJyKQorCQltbnRwdXQobW50KTsKKwlyZXR1cm4gZXJyOworfQorCitpbnQgZmluaXNoX2F1dG9tb3VudChzdHJ1Y3QgdmZzbW91bnQgKm0sIHN0cnVjdCBwYXRoICpwYXRoKQoreworCWludCBlcnI7CisJLyogVGhlIG5ldyBtb3VudCByZWNvcmQgc2hvdWxkIGhhdmUgYXQgbGVhc3QgMiByZWZzIHRvIHByZXZlbnQgaXQgYmVpbmcKKwkgKiBleHBpcmVkIGJlZm9yZSB3ZSBnZXQgYSBjaGFuY2UgdG8gYWRkIGl0CisJICovCisJQlVHX09OKG1udF9nZXRfY291bnQobSkgPCAyKTsKKworCWlmIChtLT5tbnRfc2IgPT0gcGF0aC0+bW50LT5tbnRfc2IgJiYKKwkgICAgbS0+bW50X3Jvb3QgPT0gcGF0aC0+ZGVudHJ5KSB7CisJCWVyciA9IC1FTE9PUDsKKwkJZ290byBmYWlsOworCX0KKworCWVyciA9IGRvX2FkZF9tb3VudChtLCBwYXRoLCBwYXRoLT5tbnQtPm1udF9mbGFncyB8IE1OVF9TSFJJTktBQkxFKTsKKwlpZiAoIWVycikKKwkJcmV0dXJuIDA7CitmYWlsOgorCS8qIHJlbW92ZSBtIGZyb20gYW55IGV4cGlyYXRpb24gbGlzdCBpdCBtYXkgYmUgb24gKi8KKwlpZiAoIWxpc3RfZW1wdHkoJm0tPm1udF9leHBpcmUpKSB7CisJCWRvd25fd3JpdGUoJm5hbWVzcGFjZV9zZW0pOworCQlicl93cml0ZV9sb2NrKHZmc21vdW50X2xvY2spOworCQlsaXN0X2RlbF9pbml0KCZtLT5tbnRfZXhwaXJlKTsKKwkJYnJfd3JpdGVfdW5sb2NrKHZmc21vdW50X2xvY2spOworCQl1cF93cml0ZSgmbmFtZXNwYWNlX3NlbSk7CisJfQorCW1udHB1dChtKTsKKwltbnRwdXQobSk7CisJcmV0dXJuIGVycjsKIH0KIAogLyoKICAqIGFkZCBhIG1vdW50IGludG8gYSBuYW1lc3BhY2UncyBtb3VudCB0cmVlCi0gKiAtIHByb3ZpZGUgdGhlIG9wdGlvbiBvZiBhZGRpbmcgdGhlIG5ldyBtb3VudCB0byBhbiBleHBpcmF0aW9uIGxpc3QKICAqLwotaW50IGRvX2FkZF9tb3VudChzdHJ1Y3QgdmZzbW91bnQgKm5ld21udCwgc3RydWN0IHBhdGggKnBhdGgsCi0JCSBpbnQgbW50X2ZsYWdzLCBzdHJ1Y3QgbGlzdF9oZWFkICpmc2xpc3QpCitzdGF0aWMgaW50IGRvX2FkZF9tb3VudChzdHJ1Y3QgdmZzbW91bnQgKm5ld21udCwgc3RydWN0IHBhdGggKnBhdGgsIGludCBtbnRfZmxhZ3MpCiB7CiAJaW50IGVycjsKIApAQCAtMTk0MCw5ICsxOTQzLDEwIEBACiAKIAlkb3duX3dyaXRlKCZuYW1lc3BhY2Vfc2VtKTsKIAkvKiBTb21ldGhpbmcgd2FzIG1vdW50ZWQgaGVyZSB3aGlsZSB3ZSBzbGVwdCAqLwotCXdoaWxlIChkX21vdW50cG9pbnQocGF0aC0+ZGVudHJ5KSAmJgotCSAgICAgICBmb2xsb3dfZG93bihwYXRoKSkKLQkJOworCWVyciA9IGZvbGxvd19kb3duKHBhdGgsIHRydWUpOworCWlmIChlcnIgPCAwKQorCQlnb3RvIHVubG9jazsKKwogCWVyciA9IC1FSU5WQUw7CiAJaWYgKCEobW50X2ZsYWdzICYgTU5UX1NIUklOS0FCTEUpICYmICFjaGVja19tbnQocGF0aC0+bW50KSkKIAkJZ290byB1bmxvY2s7CkBAIC0xOTU4LDIyICsxOTYyLDI5IEBACiAJCWdvdG8gdW5sb2NrOwogCiAJbmV3bW50LT5tbnRfZmxhZ3MgPSBtbnRfZmxhZ3M7Ci0JaWYgKChlcnIgPSBncmFmdF90cmVlKG5ld21udCwgcGF0aCkpKQotCQlnb3RvIHVubG9jazsKLQotCWlmIChmc2xpc3QpIC8qIGFkZCB0byB0aGUgc3BlY2lmaWVkIGV4cGlyYXRpb24gbGlzdCAqLwotCQlsaXN0X2FkZF90YWlsKCZuZXdtbnQtPm1udF9leHBpcmUsIGZzbGlzdCk7Ci0KLQl1cF93cml0ZSgmbmFtZXNwYWNlX3NlbSk7Ci0JcmV0dXJuIDA7CisJZXJyID0gZ3JhZnRfdHJlZShuZXdtbnQsIHBhdGgpOwogCiB1bmxvY2s6CiAJdXBfd3JpdGUoJm5hbWVzcGFjZV9zZW0pOwotCW1udHB1dF9sb25nKG5ld21udCk7CiAJcmV0dXJuIGVycjsKIH0KIAotRVhQT1JUX1NZTUJPTF9HUEwoZG9fYWRkX21vdW50KTsKKy8qKgorICogbW50X3NldF9leHBpcnkgLSBQdXQgYSBtb3VudCBvbiBhbiBleHBpcmF0aW9uIGxpc3QKKyAqIEBtbnQ6IFRoZSBtb3VudCB0byBsaXN0LgorICogQGV4cGlyeV9saXN0OiBUaGUgbGlzdCB0byBhZGQgdGhlIG1vdW50IHRvLgorICovCit2b2lkIG1udF9zZXRfZXhwaXJ5KHN0cnVjdCB2ZnNtb3VudCAqbW50LCBzdHJ1Y3QgbGlzdF9oZWFkICpleHBpcnlfbGlzdCkKK3sKKwlkb3duX3dyaXRlKCZuYW1lc3BhY2Vfc2VtKTsKKwlicl93cml0ZV9sb2NrKHZmc21vdW50X2xvY2spOworCisJbGlzdF9hZGRfdGFpbCgmbW50LT5tbnRfZXhwaXJlLCBleHBpcnlfbGlzdCk7CisKKwlicl93cml0ZV91bmxvY2sodmZzbW91bnRfbG9jayk7CisJdXBfd3JpdGUoJm5hbWVzcGFjZV9zZW0pOworfQorRVhQT1JUX1NZTUJPTChtbnRfc2V0X2V4cGlyeSk7CiAKIC8qCiAgKiBwcm9jZXNzIGEgbGlzdCBvZiBleHBpcmFibGUgbW91bnRwb2ludHMgd2l0aCB0aGUgaW50ZW50IG9mIGRpc2NhcmRpbmcgYW55CkBAIC0yMjYyLDYgKzIyNzMsMjIgQEAKIAlyZXR1cm4gbmV3X25zOwogfQogCit2b2lkIG1udF9tYWtlX2xvbmd0ZXJtKHN0cnVjdCB2ZnNtb3VudCAqbW50KQoreworCV9fbW50X21ha2VfbG9uZ3Rlcm0obW50KTsKK30KKwordm9pZCBtbnRfbWFrZV9zaG9ydHRlcm0oc3RydWN0IHZmc21vdW50ICptbnQpCit7CisjaWZkZWYgQ09ORklHX1NNUAorCWlmIChhdG9taWNfYWRkX3VubGVzcygmbW50LT5tbnRfbG9uZ3Rlcm0sIC0xLCAxKSkKKwkJcmV0dXJuOworCWJyX3dyaXRlX2xvY2sodmZzbW91bnRfbG9jayk7CisJYXRvbWljX2RlYygmbW50LT5tbnRfbG9uZ3Rlcm0pOworCWJyX3dyaXRlX3VubG9jayh2ZnNtb3VudF9sb2NrKTsKKyNlbmRpZgorfQorCiAvKgogICogQWxsb2NhdGUgYSBuZXcgbmFtZXNwYWNlIHN0cnVjdHVyZSBhbmQgcG9wdWxhdGUgaXQgd2l0aCBjb250ZW50cwogICogY29waWVkIGZyb20gdGhlIG5hbWVzcGFjZSBvZiB0aGUgcGFzc2VkIGluIHRhc2sgc3RydWN0dXJlLgpAQCAtMjI5OSwxNCArMjMyNiwxOSBAQAogCXEgPSBuZXdfbnMtPnJvb3Q7CiAJd2hpbGUgKHApIHsKIAkJcS0+bW50X25zID0gbmV3X25zOworCQlfX21udF9tYWtlX2xvbmd0ZXJtKHEpOwogCQlpZiAoZnMpIHsKIAkJCWlmIChwID09IGZzLT5yb290Lm1udCkgeworCQkJCWZzLT5yb290Lm1udCA9IG1udGdldChxKTsKKwkJCQlfX21udF9tYWtlX2xvbmd0ZXJtKHEpOworCQkJCW1udF9tYWtlX3Nob3J0dGVybShwKTsKIAkJCQlyb290bW50ID0gcDsKLQkJCQlmcy0+cm9vdC5tbnQgPSBtbnRnZXRfbG9uZyhxKTsKIAkJCX0KIAkJCWlmIChwID09IGZzLT5wd2QubW50KSB7CisJCQkJZnMtPnB3ZC5tbnQgPSBtbnRnZXQocSk7CisJCQkJX19tbnRfbWFrZV9sb25ndGVybShxKTsKKwkJCQltbnRfbWFrZV9zaG9ydHRlcm0ocCk7CiAJCQkJcHdkbW50ID0gcDsKLQkJCQlmcy0+cHdkLm1udCA9IG1udGdldF9sb25nKHEpOwogCQkJfQogCQl9CiAJCXAgPSBuZXh0X21udChwLCBtbnRfbnMtPnJvb3QpOwpAQCAtMjMxNSw5ICsyMzQ3LDkgQEAKIAl1cF93cml0ZSgmbmFtZXNwYWNlX3NlbSk7CiAKIAlpZiAocm9vdG1udCkKLQkJbW50cHV0X2xvbmcocm9vdG1udCk7CisJCW1udHB1dChyb290bW50KTsKIAlpZiAocHdkbW50KQotCQltbnRwdXRfbG9uZyhwd2RtbnQpOworCQltbnRwdXQocHdkbW50KTsKIAogCXJldHVybiBuZXdfbnM7CiB9CkBAIC0yMzUwLDYgKzIzODIsNyBAQAogCW5ld19ucyA9IGFsbG9jX21udF9ucygpOwogCWlmICghSVNfRVJSKG5ld19ucykpIHsKIAkJbW50LT5tbnRfbnMgPSBuZXdfbnM7CisJCV9fbW50X21ha2VfbG9uZ3Rlcm0obW50KTsKIAkJbmV3X25zLT5yb290ID0gbW50OwogCQlsaXN0X2FkZCgmbmV3X25zLT5saXN0LCAmbmV3X25zLT5yb290LT5tbnRfbGlzdCk7CiAJfQpkaWZmIC0tZ2l0IGEvZnMvbmZzL2NhbGxiYWNrLmMgYi9mcy9uZnMvY2FsbGJhY2suYwppbmRleCAxOTkwMTY1Li5lM2QyOTQyIDEwMDY0NAotLS0gYS9mcy9uZnMvY2FsbGJhY2suYworKysgYi9mcy9uZnMvY2FsbGJhY2suYwpAQCAtMTM1LDMzICsxMzUsNiBAQAogCiAjaWYgZGVmaW5lZChDT05GSUdfTkZTX1Y0XzEpCiAvKgotICogICogQ0JfU0VRVUVOQ0Ugb3BlcmF0aW9ucyB3aWxsIGZhaWwgdW50aWwgdGhlIGNhbGxiYWNrIHNlc3Npb25pZCBpcyBzZXQuCi0gKiAgICovCi1pbnQgbmZzNF9zZXRfY2FsbGJhY2tfc2Vzc2lvbmlkKHN0cnVjdCBuZnNfY2xpZW50ICpjbHApCi17Ci0Jc3RydWN0IHN2Y19zZXJ2ICpzZXJ2ID0gY2xwLT5jbF9ycGNjbGllbnQtPmNsX3hwcnQtPmJjX3NlcnY7Ci0Jc3RydWN0IG5mczRfc2Vzc2lvbmlkICpiY19zaWQ7Ci0KLQlpZiAoIXNlcnYtPnN2X2JjX3hwcnQpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JLyogb24gc3VjY2VzcyBmcmVlZCBpbiB4cHJ0X2ZyZWUgKi8KLQliY19zaWQgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3QgbmZzNF9zZXNzaW9uaWQpLCBHRlBfS0VSTkVMKTsKLQlpZiAoIWJjX3NpZCkKLQkJcmV0dXJuIC1FTk9NRU07Ci0JbWVtY3B5KGJjX3NpZC0+ZGF0YSwgJmNscC0+Y2xfc2Vzc2lvbi0+c2Vzc19pZC5kYXRhLAotCQlORlM0X01BWF9TRVNTSU9OSURfTEVOKTsKLQlzcGluX2xvY2tfYmgoJnNlcnYtPnN2X2NiX2xvY2spOwotCXNlcnYtPnN2X2JjX3hwcnQtPnhwdF9iY19zaWQgPSBiY19zaWQ7Ci0Jc3Bpbl91bmxvY2tfYmgoJnNlcnYtPnN2X2NiX2xvY2spOwotCWRwcmludGsoIiVzIHNldCB4cHRfYmNfc2lkPSV1OiV1OiV1OiV1IGZvciBzdl9iY194cHJ0ICVwXG4iLCBfX2Z1bmNfXywKLQkJKCh1MzIgKiliY19zaWQtPmRhdGEpWzBdLCAoKHUzMiAqKWJjX3NpZC0+ZGF0YSlbMV0sCi0JCSgodTMyICopYmNfc2lkLT5kYXRhKVsyXSwgKCh1MzIgKiliY19zaWQtPmRhdGEpWzNdLAotCQlzZXJ2LT5zdl9iY194cHJ0KTsKLQlyZXR1cm4gMDsKLX0KLQotLyoKICAqIFRoZSBjYWxsYmFjayBzZXJ2aWNlIGZvciBORlN2NC4xIGNhbGxiYWNrcwogICovCiBzdGF0aWMgaW50CkBAIC0yNjYsMTAgKzIzOSw2IEBACiAJCXN0cnVjdCBuZnNfY2FsbGJhY2tfZGF0YSAqY2JfaW5mbykKIHsKIH0KLWludCBuZnM0X3NldF9jYWxsYmFja19zZXNzaW9uaWQoc3RydWN0IG5mc19jbGllbnQgKmNscCkKLXsKLQlyZXR1cm4gMDsKLX0KICNlbmRpZiAvKiBDT05GSUdfTkZTX1Y0XzEgKi8KIAogLyoKQEAgLTM1OSw3OCArMzI4LDU4IEBACiAJbXV0ZXhfdW5sb2NrKCZuZnNfY2FsbGJhY2tfbXV0ZXgpOwogfQogCi1zdGF0aWMgaW50IGNoZWNrX2dzc19jYWxsYmFja19wcmluY2lwYWwoc3RydWN0IG5mc19jbGllbnQgKmNscCwKLQkJCQkJc3RydWN0IHN2Y19ycXN0ICpycXN0cCkKKy8qIEJvb2xlYW4gY2hlY2sgb2YgUlBDX0FVVEhfR1NTIHByaW5jaXBhbCAqLworaW50CitjaGVja19nc3NfY2FsbGJhY2tfcHJpbmNpcGFsKHN0cnVjdCBuZnNfY2xpZW50ICpjbHAsIHN0cnVjdCBzdmNfcnFzdCAqcnFzdHApCiB7CiAJc3RydWN0IHJwY19jbG50ICpyID0gY2xwLT5jbF9ycGNjbGllbnQ7CiAJY2hhciAqcCA9IHN2Y19nc3NfcHJpbmNpcGFsKHJxc3RwKTsKIAorCWlmIChycXN0cC0+cnFfYXV0aG9wLT5mbGF2b3VyICE9IFJQQ19BVVRIX0dTUykKKwkJcmV0dXJuIDE7CisKIAkvKiBObyBSUENfQVVUSF9HU1Mgb24gTkZTdjQuMSBiYWNrIGNoYW5uZWwgeWV0ICovCiAJaWYgKGNscC0+Y2xfbWlub3J2ZXJzaW9uICE9IDApCi0JCXJldHVybiBTVkNfRFJPUDsKKwkJcmV0dXJuIDA7CiAJLyoKIAkgKiBJdCBtaWdodCBqdXN0IGJlIGEgbm9ybWFsIHVzZXIgcHJpbmNpcGFsLCBpbiB3aGljaCBjYXNlCiAJICogdXNlcnNwYWNlIHdvbid0IGJvdGhlciB0byB0ZWxsIHVzIHRoZSBuYW1lIGF0IGFsbC4KIAkgKi8KIAlpZiAocCA9PSBOVUxMKQotCQlyZXR1cm4gU1ZDX0RFTklFRDsKKwkJcmV0dXJuIDA7CiAKIAkvKiBFeHBlY3QgYSBHU1NfQ19OVF9IT1NUQkFTRURfTkFNRSBsaWtlICJuZnNAc2VydmVyaG9zdG5hbWUiICovCiAKIAlpZiAobWVtY21wKHAsICJuZnNAIiwgNCkgIT0gMCkKLQkJcmV0dXJuIFNWQ19ERU5JRUQ7CisJCXJldHVybiAwOwogCXAgKz0gNDsKIAlpZiAoc3RyY21wKHAsIHItPmNsX3NlcnZlcikgIT0gMCkKLQkJcmV0dXJuIFNWQ19ERU5JRUQ7Ci0JcmV0dXJuIFNWQ19PSzsKKwkJcmV0dXJuIDA7CisJcmV0dXJuIDE7CiB9CiAKLS8qIHBnX2F1dGhlbnRpY2F0ZSBtZXRob2QgaGVscGVyICovCi1zdGF0aWMgc3RydWN0IG5mc19jbGllbnQgKm5mc19jYl9maW5kX2NsaWVudChzdHJ1Y3Qgc3ZjX3Jxc3QgKnJxc3RwKQotewotCXN0cnVjdCBuZnM0X3Nlc3Npb25pZCAqc2Vzc2lvbmlkID0gYmNfeHBydF9zaWQocnFzdHApOwotCWludCBpc19jYl9jb21wb3VuZCA9IHJxc3RwLT5ycV9wcm9jID09IENCX0NPTVBPVU5EID8gMSA6IDA7Ci0KLQlkcHJpbnRrKCItLT4gJXMgcnFfcHJvYyAlZFxuIiwgX19mdW5jX18sIHJxc3RwLT5ycV9wcm9jKTsKLQlpZiAoc3ZjX2lzX2JhY2tjaGFubmVsKHJxc3RwKSkKLQkJLyogU2Vzc2lvbmlkICh1c3VhbGx5KSBzZXQgYWZ0ZXIgQ0JfTlVMTCBwaW5nICovCi0JCXJldHVybiBuZnM0X2ZpbmRfY2xpZW50X3Nlc3Npb25pZChzdmNfYWRkcihycXN0cCksIHNlc3Npb25pZCwKLQkJCQkJCSAgaXNfY2JfY29tcG91bmQpOwotCWVsc2UKLQkJLyogTm8gY2FsbGJhY2sgaWRlbnRpZmllciBpbiBwZ19hdXRoZW50aWNhdGUgKi8KLQkJcmV0dXJuIG5mczRfZmluZF9jbGllbnRfbm9faWRlbnQoc3ZjX2FkZHIocnFzdHApKTsKLX0KLQotLyogcGdfYXV0aGVudGljYXRlIG1ldGhvZCBmb3IgbmZzdjQgY2FsbGJhY2sgdGhyZWFkcy4gKi8KKy8qCisgKiBwZ19hdXRoZW50aWNhdGUgbWV0aG9kIGZvciBuZnN2NCBjYWxsYmFjayB0aHJlYWRzLgorICoKKyAqIFRoZSBhdXRoZmxhdm9yIGhhcyBiZWVuIG5lZ290aWF0ZWQsIHNvIGFuIGluY29ycmVjdCBmbGF2b3IgaXMgYSBzZXJ2ZXIKKyAqIGJ1Zy4gRHJvcCBwYWNrZXRzIHdpdGggaW5jb3JyZWN0IGF1dGhmbGF2b3IuCisgKgorICogQWxsIG90aGVyIGNoZWNraW5nIGRvbmUgYWZ0ZXIgTkZTIGRlY29kaW5nIHdoZXJlIHRoZSBuZnNfY2xpZW50IGNhbiBiZQorICogZm91bmQgaW4gbmZzNF9jYWxsYmFja19jb21wb3VuZAorICovCiBzdGF0aWMgaW50IG5mc19jYWxsYmFja19hdXRoZW50aWNhdGUoc3RydWN0IHN2Y19ycXN0ICpycXN0cCkKIHsKLQlzdHJ1Y3QgbmZzX2NsaWVudCAqY2xwOwotCVJQQ19JRkRFQlVHKGNoYXIgYnVmW1JQQ19NQVhfQUREUkJVRkxFTl0pOwotCWludCByZXQgPSBTVkNfT0s7Ci0KLQkvKiBEb24ndCB0YWxrIHRvIHN0cmFuZ2VycyAqLwotCWNscCA9IG5mc19jYl9maW5kX2NsaWVudChycXN0cCk7Ci0JaWYgKGNscCA9PSBOVUxMKQotCQlyZXR1cm4gU1ZDX0RST1A7Ci0KLQlkcHJpbnRrKCIlczogJXMgTkZTdjQgY2FsbGJhY2shXG4iLCBfX2Z1bmNfXywKLQkJCXN2Y19wcmludF9hZGRyKHJxc3RwLCBidWYsIHNpemVvZihidWYpKSk7Ci0KIAlzd2l0Y2ggKHJxc3RwLT5ycV9hdXRob3AtPmZsYXZvdXIpIHsKLQkJY2FzZSBSUENfQVVUSF9OVUxMOgotCQkJaWYgKHJxc3RwLT5ycV9wcm9jICE9IENCX05VTEwpCi0JCQkJcmV0ID0gU1ZDX0RFTklFRDsKLQkJCWJyZWFrOwotCQljYXNlIFJQQ19BVVRIX1VOSVg6Ci0JCQlicmVhazsKLQkJY2FzZSBSUENfQVVUSF9HU1M6Ci0JCQlyZXQgPSBjaGVja19nc3NfY2FsbGJhY2tfcHJpbmNpcGFsKGNscCwgcnFzdHApOwotCQkJYnJlYWs7Ci0JCWRlZmF1bHQ6Ci0JCQlyZXQgPSBTVkNfREVOSUVEOworCWNhc2UgUlBDX0FVVEhfTlVMTDoKKwkJaWYgKHJxc3RwLT5ycV9wcm9jICE9IENCX05VTEwpCisJCQlyZXR1cm4gU1ZDX0RST1A7CisJCWJyZWFrOworCWNhc2UgUlBDX0FVVEhfR1NTOgorCQkvKiBObyBSUENfQVVUSF9HU1Mgc3VwcG9ydCB5ZXQgaW4gTkZTdjQuMSAqLworCQkgaWYgKHN2Y19pc19iYWNrY2hhbm5lbChycXN0cCkpCisJCQlyZXR1cm4gU1ZDX0RST1A7CiAJfQotCW5mc19wdXRfY2xpZW50KGNscCk7Ci0JcmV0dXJuIHJldDsKKwlyZXR1cm4gU1ZDX09LOwogfQogCiAvKgpkaWZmIC0tZ2l0IGEvZnMvbmZzL2NhbGxiYWNrLmggYi9mcy9uZnMvY2FsbGJhY2suaAppbmRleCBkM2I0NGY5Li40NmQ5M2NlIDEwMDY0NAotLS0gYS9mcy9uZnMvY2FsbGJhY2suaAorKysgYi9mcy9uZnMvY2FsbGJhY2suaApAQCAtNyw2ICs3LDcgQEAKICAqLwogI2lmbmRlZiBfX0xJTlVYX0ZTX05GU19DQUxMQkFDS19ICiAjZGVmaW5lIF9fTElOVVhfRlNfTkZTX0NBTExCQUNLX0gKKyNpbmNsdWRlIDxsaW51eC9zdW5ycGMvc3ZjLmg+CiAKICNkZWZpbmUgTkZTNF9DQUxMQkFDSyAweDQwMDAwMDAwCiAjZGVmaW5lIE5GUzRfQ0FMTEJBQ0tfWERSU0laRSAyMDQ4CkBAIC0zNyw3ICszOCw2IEBACiBzdHJ1Y3QgY2JfcHJvY2Vzc19zdGF0ZSB7CiAJX19iZTMyCQkJZHJjX3N0YXR1czsKIAlzdHJ1Y3QgbmZzX2NsaWVudAkqY2xwOwotCXN0cnVjdCBuZnM0X3Nlc3Npb25pZAkqc3ZjX3NpZDsgLyogdjQuMSBjYWxsYmFjayBzZXJ2aWNlIHNlc3Npb25pZCAqLwogfTsKIAogc3RydWN0IGNiX2NvbXBvdW5kX2hkcl9hcmcgewpAQCAtMTY4LDcgKzE2OCw3IEBACiBleHRlcm4gdm9pZCBuZnM0X2NoZWNrX2RyYWluX2JjX2NvbXBsZXRlKHN0cnVjdCBuZnM0X3Nlc3Npb24gKnNlcyk7CiBleHRlcm4gdm9pZCBuZnM0X2NiX3Rha2Vfc2xvdChzdHJ1Y3QgbmZzX2NsaWVudCAqY2xwKTsKICNlbmRpZiAvKiBDT05GSUdfTkZTX1Y0XzEgKi8KLQorZXh0ZXJuIGludCBjaGVja19nc3NfY2FsbGJhY2tfcHJpbmNpcGFsKHN0cnVjdCBuZnNfY2xpZW50ICosIHN0cnVjdCBzdmNfcnFzdCAqKTsKIGV4dGVybiBfX2JlMzIgbmZzNF9jYWxsYmFja19nZXRhdHRyKHN0cnVjdCBjYl9nZXRhdHRyYXJncyAqYXJncywKIAkJCQkgICAgc3RydWN0IGNiX2dldGF0dHJyZXMgKnJlcywKIAkJCQkgICAgc3RydWN0IGNiX3Byb2Nlc3Nfc3RhdGUgKmNwcyk7CmRpZmYgLS1naXQgYS9mcy9uZnMvY2FsbGJhY2tfcHJvYy5jIGIvZnMvbmZzL2NhbGxiYWNrX3Byb2MuYwppbmRleCA0YmI5MWNiLi44OTU4NzU3IDEwMDY0NAotLS0gYS9mcy9uZnMvY2FsbGJhY2tfcHJvYy5jCisrKyBiL2ZzL25mcy9jYWxsYmFja19wcm9jLmMKQEAgLTM3MywxNyArMzczLDExIEBACiB7CiAJc3RydWN0IG5mc19jbGllbnQgKmNscDsKIAlpbnQgaTsKLQlfX2JlMzIgc3RhdHVzOworCV9fYmUzMiBzdGF0dXMgPSBodG9ubChORlM0RVJSX0JBRFNFU1NJT04pOwogCiAJY3BzLT5jbHAgPSBOVUxMOwogCi0Jc3RhdHVzID0gaHRvbmwoTkZTNEVSUl9CQURTRVNTSU9OKTsKLQkvKiBJbmNvbWluZyBzZXNzaW9uIG11c3QgbWF0Y2ggdGhlIGNhbGxiYWNrIHNlc3Npb24gKi8KLQlpZiAobWVtY21wKCZhcmdzLT5jc2Ffc2Vzc2lvbmlkLCBjcHMtPnN2Y19zaWQsIE5GUzRfTUFYX1NFU1NJT05JRF9MRU4pKQotCQlnb3RvIG91dDsKLQotCWNscCA9IG5mczRfZmluZF9jbGllbnRfc2Vzc2lvbmlkKGFyZ3MtPmNzYV9hZGRyLAotCQkJCQkgJmFyZ3MtPmNzYV9zZXNzaW9uaWQsIDEpOworCWNscCA9IG5mczRfZmluZF9jbGllbnRfc2Vzc2lvbmlkKGFyZ3MtPmNzYV9hZGRyLCAmYXJncy0+Y3NhX3Nlc3Npb25pZCk7CiAJaWYgKGNscCA9PSBOVUxMKQogCQlnb3RvIG91dDsKIApAQCAtNDE0LDkgKzQwOCw5IEBACiAJcmVzLT5jc3JfaGlnaGVzdHNsb3RpZCA9IE5GUzQxX0JDX01BWF9DQUxMQkFDS1MgLSAxOwogCXJlcy0+Y3NyX3RhcmdldF9oaWdoZXN0c2xvdGlkID0gTkZTNDFfQkNfTUFYX0NBTExCQUNLUyAtIDE7CiAJbmZzNF9jYl90YWtlX3Nsb3QoY2xwKTsKLQljcHMtPmNscCA9IGNscDsgLyogcHV0IGluIG5mczRfY2FsbGJhY2tfY29tcG91bmQgKi8KIAogb3V0OgorCWNwcy0+Y2xwID0gY2xwOyAvKiBwdXQgaW4gbmZzNF9jYWxsYmFja19jb21wb3VuZCAqLwogCWZvciAoaSA9IDA7IGkgPCBhcmdzLT5jc2FfbnJjbGlzdHM7IGkrKykKIAkJa2ZyZWUoYXJncy0+Y3NhX3JjbGlzdHNbaV0ucmNsX3JlZmNhbGxzKTsKIAlrZnJlZShhcmdzLT5jc2FfcmNsaXN0cyk7CmRpZmYgLS1naXQgYS9mcy9uZnMvY2FsbGJhY2tfeGRyLmMgYi9mcy9uZnMvY2FsbGJhY2tfeGRyLmMKaW5kZXggMjMxMTJjMi4uMTRlMGY5MyAxMDA2NDQKLS0tIGEvZnMvbmZzL2NhbGxiYWNrX3hkci5jCisrKyBiL2ZzL25mcy9jYWxsYmFja194ZHIuYwpAQCAtNzk0LDEwICs3OTQsOSBAQAogCiAJaWYgKGhkcl9hcmcubWlub3J2ZXJzaW9uID09IDApIHsKIAkJY3BzLmNscCA9IG5mczRfZmluZF9jbGllbnRfaWRlbnQoaGRyX2FyZy5jYl9pZGVudCk7Ci0JCWlmICghY3BzLmNscCkKKwkJaWYgKCFjcHMuY2xwIHx8ICFjaGVja19nc3NfY2FsbGJhY2tfcHJpbmNpcGFsKGNwcy5jbHAsIHJxc3RwKSkKIAkJCXJldHVybiBycGNfZHJvcF9yZXBseTsKLQl9IGVsc2UKLQkJY3BzLnN2Y19zaWQgPSBiY194cHJ0X3NpZChycXN0cCk7CisJfQogCiAJaGRyX3Jlcy50YWdsZW4gPSBoZHJfYXJnLnRhZ2xlbjsKIAloZHJfcmVzLnRhZyA9IGhkcl9hcmcudGFnOwpkaWZmIC0tZ2l0IGEvZnMvbmZzL2NsaWVudC5jIGIvZnMvbmZzL2NsaWVudC5jCmluZGV4IDE5MmYyZjguLmJkM2NhMzIgMTAwNjQ0Ci0tLSBhL2ZzL25mcy9jbGllbnQuYworKysgYi9mcy9uZnMvY2xpZW50LmMKQEAgLTEyMDYsMTYgKzEyMDYsMTEgQEAKICAqIEZvciBDQl9DT01QT1VORCBjYWxscywgZmluZCBhIGNsaWVudCBieSBJUCBhZGRyZXNzLCBwcm90b2NvbCB2ZXJzaW9uLAogICogbWlub3J2ZXJzaW9uLCBhbmQgc2Vzc2lvbklECiAgKgotICogQ1JFQVRFX1NFU1NJT04gdHJpZ2dlcnMgYSBDQl9OVUxMIHBpbmcgZnJvbSBzZXJ2ZXJzLiBUaGUgY2FsbGJhY2sgc2VydmljZQotICogc2Vzc2lvbmlkIGNhbiBvbmx5IGJlIHNldCBhZnRlciB0aGUgQ1JFQVRFX1NFU1NJT04gcmV0dXJuLCBzbyBhIENCX05VTEwKLSAqIGNhbiBhcnJpdmUgYmVmb3JlIHRoZSBjYWxsYmFjayBzZXNzaW9uaWQgaXMgc2V0LiBGb3IgQ0JfTlVMTCBjYWxscywKLSAqIGZpbmQgYSBjbGllbnQgYnkgSVAgYWRkcmVzcyBwcm90b2NvbCB2ZXJzaW9uLCBhbmQgbWlub3J2ZXJzaW9uLgotICoKICAqIFJldHVybnMgTlVMTCBpZiBubyBzdWNoIGNsaWVudAogICovCiBzdHJ1Y3QgbmZzX2NsaWVudCAqCiBuZnM0X2ZpbmRfY2xpZW50X3Nlc3Npb25pZChjb25zdCBzdHJ1Y3Qgc29ja2FkZHIgKmFkZHIsCi0JCQkgICBzdHJ1Y3QgbmZzNF9zZXNzaW9uaWQgKnNpZCwgaW50IGlzX2NiX2NvbXBvdW5kKQorCQkJICAgc3RydWN0IG5mczRfc2Vzc2lvbmlkICpzaWQpCiB7CiAJc3RydWN0IG5mc19jbGllbnQgKmNscDsKIApAQCAtMTIyNyw5ICsxMjIyLDkgQEAKIAkJaWYgKCFuZnM0X2hhc19zZXNzaW9uKGNscCkpCiAJCQljb250aW51ZTsKIAotCQkvKiBNYXRjaCBzZXNzaW9uaWQgdW5sZXNzIGNiX251bGwgY2FsbCovCi0JCWlmIChpc19jYl9jb21wb3VuZCAmJiAobWVtY21wKGNscC0+Y2xfc2Vzc2lvbi0+c2Vzc19pZC5kYXRhLAotCQkgICAgc2lkLT5kYXRhLCBORlM0X01BWF9TRVNTSU9OSURfTEVOKSAhPSAwKSkKKwkJLyogTWF0Y2ggc2Vzc2lvbmlkKi8KKwkJaWYgKG1lbWNtcChjbHAtPmNsX3Nlc3Npb24tPnNlc3NfaWQuZGF0YSwKKwkJICAgIHNpZC0+ZGF0YSwgTkZTNF9NQVhfU0VTU0lPTklEX0xFTikgIT0gMCkKIAkJCWNvbnRpbnVlOwogCiAJCWF0b21pY19pbmMoJmNscC0+Y2xfY291bnQpOwpAQCAtMTI0NCw3ICsxMjM5LDcgQEAKIAogc3RydWN0IG5mc19jbGllbnQgKgogbmZzNF9maW5kX2NsaWVudF9zZXNzaW9uaWQoY29uc3Qgc3RydWN0IHNvY2thZGRyICphZGRyLAotCQkJICAgc3RydWN0IG5mczRfc2Vzc2lvbmlkICpzaWQsIGludCBpc19jYl9jb21wb3VuZCkKKwkJCSAgIHN0cnVjdCBuZnM0X3Nlc3Npb25pZCAqc2lkKQogewogCXJldHVybiBOVUxMOwogfQpkaWZmIC0tZ2l0IGEvZnMvbmZzL2RlbGVnYXRpb24uYyBiL2ZzL25mcy9kZWxlZ2F0aW9uLmMKaW5kZXggMzY0ZTQzMi4uYmJiYzZiZiAxMDA2NDQKLS0tIGEvZnMvbmZzL2RlbGVnYXRpb24uYworKysgYi9mcy9uZnMvZGVsZWdhdGlvbi5jCkBAIC0yMyw4ICsyMyw2IEBACiAKIHN0YXRpYyB2b2lkIG5mc19kb19mcmVlX2RlbGVnYXRpb24oc3RydWN0IG5mc19kZWxlZ2F0aW9uICpkZWxlZ2F0aW9uKQogewotCWlmIChkZWxlZ2F0aW9uLT5jcmVkKQotCQlwdXRfcnBjY3JlZChkZWxlZ2F0aW9uLT5jcmVkKTsKIAlrZnJlZShkZWxlZ2F0aW9uKTsKIH0KIApAQCAtMzcsNiArMzUsMTAgQEAKIAogc3RhdGljIHZvaWQgbmZzX2ZyZWVfZGVsZWdhdGlvbihzdHJ1Y3QgbmZzX2RlbGVnYXRpb24gKmRlbGVnYXRpb24pCiB7CisJaWYgKGRlbGVnYXRpb24tPmNyZWQpIHsKKwkJcHV0X3JwY2NyZWQoZGVsZWdhdGlvbi0+Y3JlZCk7CisJCWRlbGVnYXRpb24tPmNyZWQgPSBOVUxMOworCX0KIAljYWxsX3JjdSgmZGVsZWdhdGlvbi0+cmN1LCBuZnNfZnJlZV9kZWxlZ2F0aW9uX2NhbGxiYWNrKTsKIH0KIApkaWZmIC0tZ2l0IGEvZnMvbmZzL2Rpci5jIGIvZnMvbmZzL2Rpci5jCmluZGV4IDk1YjA4MWIuLjJjM2ViMzMgMTAwNjQ0Ci0tLSBhL2ZzL25mcy9kaXIuYworKysgYi9mcy9uZnMvZGlyLmMKQEAgLTk3MCw3ICs5NzAsNyBAQAogewogCXN0cnVjdCBuZnNfc2VydmVyICpzZXJ2ZXIgPSBORlNfU0VSVkVSKGlub2RlKTsKIAotCWlmICh0ZXN0X2JpdChORlNfSU5PX01PVU5UUE9JTlQsICZORlNfSShpbm9kZSktPmZsYWdzKSkKKwlpZiAoSVNfQVVUT01PVU5UKGlub2RlKSkKIAkJcmV0dXJuIDA7CiAJaWYgKG5kICE9IE5VTEwpIHsKIAkJLyogVkZTIHdhbnRzIGFuIG9uLXRoZS13aXJlIHJldmFsaWRhdGlvbiAqLwpAQCAtMTE3Myw2ICsxMTczLDcgQEAKIAkuZF9yZXZhbGlkYXRlCT0gbmZzX2xvb2t1cF9yZXZhbGlkYXRlLAogCS5kX2RlbGV0ZQk9IG5mc19kZW50cnlfZGVsZXRlLAogCS5kX2lwdXQJCT0gbmZzX2RlbnRyeV9pcHV0LAorCS5kX2F1dG9tb3VudAk9IG5mc19kX2F1dG9tb3VudCwKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgZGVudHJ5ICpuZnNfbG9va3VwKHN0cnVjdCBpbm9kZSAqZGlyLCBzdHJ1Y3QgZGVudHJ5ICogZGVudHJ5LCBzdHJ1Y3QgbmFtZWlkYXRhICpuZCkKQEAgLTEyNDYsNiArMTI0Nyw3IEBACiAJLmRfcmV2YWxpZGF0ZQk9IG5mc19vcGVuX3JldmFsaWRhdGUsCiAJLmRfZGVsZXRlCT0gbmZzX2RlbnRyeV9kZWxldGUsCiAJLmRfaXB1dAkJPSBuZnNfZGVudHJ5X2lwdXQsCisJLmRfYXV0b21vdW50CT0gbmZzX2RfYXV0b21vdW50LAogfTsKIAogLyoKQEAgLTE0MDYsMTEgKzE0MDgsMTUgQEAKIHN0YXRpYyBpbnQgbmZzX29wZW5fcmV2YWxpZGF0ZShzdHJ1Y3QgZGVudHJ5ICpkZW50cnksIHN0cnVjdCBuYW1laWRhdGEgKm5kKQogewogCXN0cnVjdCBkZW50cnkgKnBhcmVudCA9IE5VTEw7Ci0Jc3RydWN0IGlub2RlICppbm9kZSA9IGRlbnRyeS0+ZF9pbm9kZTsKKwlzdHJ1Y3QgaW5vZGUgKmlub2RlOwogCXN0cnVjdCBpbm9kZSAqZGlyOwogCXN0cnVjdCBuZnNfb3Blbl9jb250ZXh0ICpjdHg7CiAJaW50IG9wZW5mbGFncywgcmV0ID0gMDsKIAorCWlmIChuZC0+ZmxhZ3MgJiBMT09LVVBfUkNVKQorCQlyZXR1cm4gLUVDSElMRDsKKworCWlub2RlID0gZGVudHJ5LT5kX2lub2RlOwogCWlmICghaXNfYXRvbWljX29wZW4obmQpIHx8IGRfbW91bnRwb2ludChkZW50cnkpKQogCQlnb3RvIG5vX29wZW47CiAKQEAgLTE1NzksNiArMTU4NSw3IEBACiB7CiAJc3RydWN0IGlhdHRyIGF0dHI7CiAJaW50IGVycm9yOworCWludCBvcGVuX2ZsYWdzID0gMDsKIAogCWRmcHJpbnRrKFZGUywgIk5GUzogY3JlYXRlKCVzLyVsZCksICVzXG4iLAogCQkJZGlyLT5pX3NiLT5zX2lkLCBkaXItPmlfaW5vLCBkZW50cnktPmRfbmFtZS5uYW1lKTsKQEAgLTE1ODYsNyArMTU5MywxMCBAQAogCWF0dHIuaWFfbW9kZSA9IG1vZGU7CiAJYXR0ci5pYV92YWxpZCA9IEFUVFJfTU9ERTsKIAotCWVycm9yID0gTkZTX1BST1RPKGRpciktPmNyZWF0ZShkaXIsIGRlbnRyeSwgJmF0dHIsIDAsIE5VTEwpOworCWlmICgobmQtPmZsYWdzICYgTE9PS1VQX0NSRUFURSkgIT0gMCkKKwkJb3Blbl9mbGFncyA9IG5kLT5pbnRlbnQub3Blbi5mbGFnczsKKworCWVycm9yID0gTkZTX1BST1RPKGRpciktPmNyZWF0ZShkaXIsIGRlbnRyeSwgJmF0dHIsIG9wZW5fZmxhZ3MsIE5VTEwpOwogCWlmIChlcnJvciAhPSAwKQogCQlnb3RvIG91dF9lcnI7CiAJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9mcy9uZnMvZGlyZWN0LmMgYi9mcy9uZnMvZGlyZWN0LmMKaW5kZXggZTZhY2UwZC4uOTk0M2E3NSAxMDA2NDQKLS0tIGEvZnMvbmZzL2RpcmVjdC5jCisrKyBiL2ZzL25mcy9kaXJlY3QuYwpAQCAtNDA3LDE1ICs0MDcsMTggQEAKIAkJcG9zICs9IHZlYy0+aW92X2xlbjsKIAl9CiAKKwkvKgorCSAqIElmIG5vIGJ5dGVzIHdlcmUgc3RhcnRlZCwgcmV0dXJuIHRoZSBlcnJvciwgYW5kIGxldCB0aGUKKwkgKiBnZW5lcmljIGxheWVyIGhhbmRsZSB0aGUgY29tcGxldGlvbi4KKwkgKi8KKwlpZiAocmVxdWVzdGVkX2J5dGVzID09IDApIHsKKwkJbmZzX2RpcmVjdF9yZXFfcmVsZWFzZShkcmVxKTsKKwkJcmV0dXJuIHJlc3VsdCA8IDAgPyByZXN1bHQgOiAtRUlPOworCX0KKwogCWlmIChwdXRfZHJlcShkcmVxKSkKIAkJbmZzX2RpcmVjdF9jb21wbGV0ZShkcmVxKTsKLQotCWlmIChyZXF1ZXN0ZWRfYnl0ZXMgIT0gMCkKLQkJcmV0dXJuIDA7Ci0KLQlpZiAocmVzdWx0IDwgMCkKLQkJcmV0dXJuIHJlc3VsdDsKLQlyZXR1cm4gLUVJTzsKKwlyZXR1cm4gMDsKIH0KIAogc3RhdGljIHNzaXplX3QgbmZzX2RpcmVjdF9yZWFkKHN0cnVjdCBraW9jYiAqaW9jYiwgY29uc3Qgc3RydWN0IGlvdmVjICppb3YsCkBAIC04NDEsMTUgKzg0NCwxOCBAQAogCQlwb3MgKz0gdmVjLT5pb3ZfbGVuOwogCX0KIAorCS8qCisJICogSWYgbm8gYnl0ZXMgd2VyZSBzdGFydGVkLCByZXR1cm4gdGhlIGVycm9yLCBhbmQgbGV0IHRoZQorCSAqIGdlbmVyaWMgbGF5ZXIgaGFuZGxlIHRoZSBjb21wbGV0aW9uLgorCSAqLworCWlmIChyZXF1ZXN0ZWRfYnl0ZXMgPT0gMCkgeworCQluZnNfZGlyZWN0X3JlcV9yZWxlYXNlKGRyZXEpOworCQlyZXR1cm4gcmVzdWx0IDwgMCA/IHJlc3VsdCA6IC1FSU87CisJfQorCiAJaWYgKHB1dF9kcmVxKGRyZXEpKQogCQluZnNfZGlyZWN0X3dyaXRlX2NvbXBsZXRlKGRyZXEsIGRyZXEtPmlub2RlKTsKLQotCWlmIChyZXF1ZXN0ZWRfYnl0ZXMgIT0gMCkKLQkJcmV0dXJuIDA7Ci0KLQlpZiAocmVzdWx0IDwgMCkKLQkJcmV0dXJuIHJlc3VsdDsKLQlyZXR1cm4gLUVJTzsKKwlyZXR1cm4gMDsKIH0KIAogc3RhdGljIHNzaXplX3QgbmZzX2RpcmVjdF93cml0ZShzdHJ1Y3Qga2lvY2IgKmlvY2IsIGNvbnN0IHN0cnVjdCBpb3ZlYyAqaW92LApkaWZmIC0tZ2l0IGEvZnMvbmZzL2lub2RlLmMgYi9mcy9uZnMvaW5vZGUuYwppbmRleCBjZTAwYjcwLi4xY2M2MDBlIDEwMDY0NAotLS0gYS9mcy9uZnMvaW5vZGUuYworKysgYi9mcy9uZnMvaW5vZGUuYwpAQCAtMzAwLDcgKzMwMCw3IEBACiAJCQkJZWxzZQogCQkJCQlpbm9kZS0+aV9vcCA9ICZuZnNfbW91bnRwb2ludF9pbm9kZV9vcGVyYXRpb25zOwogCQkJCWlub2RlLT5pX2ZvcCA9IE5VTEw7Ci0JCQkJc2V0X2JpdChORlNfSU5PX01PVU5UUE9JTlQsICZuZnNpLT5mbGFncyk7CisJCQkJaW5vZGUtPmlfZmxhZ3MgfD0gU19BVVRPTU9VTlQ7CiAJCQl9CiAJCX0gZWxzZSBpZiAoU19JU0xOSyhpbm9kZS0+aV9tb2RlKSkKIAkJCWlub2RlLT5pX29wID0gJm5mc19zeW1saW5rX2lub2RlX29wZXJhdGlvbnM7CkBAIC04ODEsOSArODgxLDEwIEBACiAJcmV0dXJuIHJldDsKIH0KIAotc3RhdGljIHZvaWQgbmZzX3djY191cGRhdGVfaW5vZGUoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IG5mc19mYXR0ciAqZmF0dHIpCitzdGF0aWMgdW5zaWduZWQgbG9uZyBuZnNfd2NjX3VwZGF0ZV9pbm9kZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgbmZzX2ZhdHRyICpmYXR0cikKIHsKIAlzdHJ1Y3QgbmZzX2lub2RlICpuZnNpID0gTkZTX0koaW5vZGUpOworCXVuc2lnbmVkIGxvbmcgcmV0ID0gMDsKIAogCWlmICgoZmF0dHItPnZhbGlkICYgTkZTX0FUVFJfRkFUVFJfUFJFQ0hBTkdFKQogCQkJJiYgKGZhdHRyLT52YWxpZCAmIE5GU19BVFRSX0ZBVFRSX0NIQU5HRSkKQEAgLTg5MSwyNSArODkyLDMyIEBACiAJCW5mc2ktPmNoYW5nZV9hdHRyID0gZmF0dHItPmNoYW5nZV9hdHRyOwogCQlpZiAoU19JU0RJUihpbm9kZS0+aV9tb2RlKSkKIAkJCW5mc2ktPmNhY2hlX3ZhbGlkaXR5IHw9IE5GU19JTk9fSU5WQUxJRF9EQVRBOworCQlyZXQgfD0gTkZTX0lOT19JTlZBTElEX0FUVFI7CiAJfQogCS8qIElmIHdlIGhhdmUgYXRvbWljIFdDQyBkYXRhLCB3ZSBtYXkgdXBkYXRlIHNvbWUgYXR0cmlidXRlcyAqLwogCWlmICgoZmF0dHItPnZhbGlkICYgTkZTX0FUVFJfRkFUVFJfUFJFQ1RJTUUpCiAJCQkmJiAoZmF0dHItPnZhbGlkICYgTkZTX0FUVFJfRkFUVFJfQ1RJTUUpCi0JCQkmJiB0aW1lc3BlY19lcXVhbCgmaW5vZGUtPmlfY3RpbWUsICZmYXR0ci0+cHJlX2N0aW1lKSkKLQkJCW1lbWNweSgmaW5vZGUtPmlfY3RpbWUsICZmYXR0ci0+Y3RpbWUsIHNpemVvZihpbm9kZS0+aV9jdGltZSkpOworCQkJJiYgdGltZXNwZWNfZXF1YWwoJmlub2RlLT5pX2N0aW1lLCAmZmF0dHItPnByZV9jdGltZSkpIHsKKwkJbWVtY3B5KCZpbm9kZS0+aV9jdGltZSwgJmZhdHRyLT5jdGltZSwgc2l6ZW9mKGlub2RlLT5pX2N0aW1lKSk7CisJCXJldCB8PSBORlNfSU5PX0lOVkFMSURfQVRUUjsKKwl9CiAKIAlpZiAoKGZhdHRyLT52YWxpZCAmIE5GU19BVFRSX0ZBVFRSX1BSRU1USU1FKQogCQkJJiYgKGZhdHRyLT52YWxpZCAmIE5GU19BVFRSX0ZBVFRSX01USU1FKQogCQkJJiYgdGltZXNwZWNfZXF1YWwoJmlub2RlLT5pX210aW1lLCAmZmF0dHItPnByZV9tdGltZSkpIHsKLQkJCW1lbWNweSgmaW5vZGUtPmlfbXRpbWUsICZmYXR0ci0+bXRpbWUsIHNpemVvZihpbm9kZS0+aV9tdGltZSkpOwotCQkJaWYgKFNfSVNESVIoaW5vZGUtPmlfbW9kZSkpCi0JCQkJbmZzaS0+Y2FjaGVfdmFsaWRpdHkgfD0gTkZTX0lOT19JTlZBTElEX0RBVEE7CisJCW1lbWNweSgmaW5vZGUtPmlfbXRpbWUsICZmYXR0ci0+bXRpbWUsIHNpemVvZihpbm9kZS0+aV9tdGltZSkpOworCQlpZiAoU19JU0RJUihpbm9kZS0+aV9tb2RlKSkKKwkJCW5mc2ktPmNhY2hlX3ZhbGlkaXR5IHw9IE5GU19JTk9fSU5WQUxJRF9EQVRBOworCQlyZXQgfD0gTkZTX0lOT19JTlZBTElEX0FUVFI7CiAJfQogCWlmICgoZmF0dHItPnZhbGlkICYgTkZTX0FUVFJfRkFUVFJfUFJFU0laRSkKIAkJCSYmIChmYXR0ci0+dmFsaWQgJiBORlNfQVRUUl9GQVRUUl9TSVpFKQogCQkJJiYgaV9zaXplX3JlYWQoaW5vZGUpID09IG5mc19zaXplX3RvX2xvZmZfdChmYXR0ci0+cHJlX3NpemUpCi0JCQkmJiBuZnNpLT5ucGFnZXMgPT0gMCkKLQkJCWlfc2l6ZV93cml0ZShpbm9kZSwgbmZzX3NpemVfdG9fbG9mZl90KGZhdHRyLT5zaXplKSk7CisJCQkmJiBuZnNpLT5ucGFnZXMgPT0gMCkgeworCQlpX3NpemVfd3JpdGUoaW5vZGUsIG5mc19zaXplX3RvX2xvZmZfdChmYXR0ci0+c2l6ZSkpOworCQlyZXQgfD0gTkZTX0lOT19JTlZBTElEX0FUVFI7CisJfQorCXJldHVybiByZXQ7CiB9CiAKIC8qKgpAQCAtMTIwOCw3ICsxMjE2LDcgQEAKIAkvKiBVcGRhdGUgdGhlIGZzaWQ/ICovCiAJaWYgKFNfSVNESVIoaW5vZGUtPmlfbW9kZSkgJiYgKGZhdHRyLT52YWxpZCAmIE5GU19BVFRSX0ZBVFRSX0ZTSUQpICYmCiAJCQkhbmZzX2ZzaWRfZXF1YWwoJnNlcnZlci0+ZnNpZCwgJmZhdHRyLT5mc2lkKSAmJgotCQkJIXRlc3RfYml0KE5GU19JTk9fTU9VTlRQT0lOVCwgJm5mc2ktPmZsYWdzKSkKKwkJCSFJU19BVVRPTU9VTlQoaW5vZGUpKQogCQlzZXJ2ZXItPmZzaWQgPSBmYXR0ci0+ZnNpZDsKIAogCS8qCkBAIC0xMjIzLDcgKzEyMzEsNyBAQAogCQkJfCBORlNfSU5PX1JFVkFMX1BBR0VDQUNIRSk7CiAKIAkvKiBEbyBhdG9taWMgd2VhayBjYWNoZSBjb25zaXN0ZW5jeSB1cGRhdGVzICovCi0JbmZzX3djY191cGRhdGVfaW5vZGUoaW5vZGUsIGZhdHRyKTsKKwlpbnZhbGlkIHw9IG5mc193Y2NfdXBkYXRlX2lub2RlKGlub2RlLCBmYXR0cik7CiAKIAkvKiBNb3JlIGNhY2hlIGNvbnNpc3RlbmN5IGNoZWNrcyAqLwogCWlmIChmYXR0ci0+dmFsaWQgJiBORlNfQVRUUl9GQVRUUl9DSEFOR0UpIHsKZGlmZiAtLWdpdCBhL2ZzL25mcy9pbnRlcm5hbC5oIGIvZnMvbmZzL2ludGVybmFsLmgKaW5kZXggYmZhM2EzNC4uY2Y5ZmRiZCAxMDA2NDQKLS0tIGEvZnMvbmZzL2ludGVybmFsLmgKKysrIGIvZnMvbmZzL2ludGVybmFsLmgKQEAgLTEzMyw4ICsxMzMsNyBAQAogZXh0ZXJuIHN0cnVjdCBuZnNfY2xpZW50ICpuZnM0X2ZpbmRfY2xpZW50X25vX2lkZW50KGNvbnN0IHN0cnVjdCBzb2NrYWRkciAqKTsKIGV4dGVybiBzdHJ1Y3QgbmZzX2NsaWVudCAqbmZzNF9maW5kX2NsaWVudF9pZGVudChpbnQpOwogZXh0ZXJuIHN0cnVjdCBuZnNfY2xpZW50ICoKLW5mczRfZmluZF9jbGllbnRfc2Vzc2lvbmlkKGNvbnN0IHN0cnVjdCBzb2NrYWRkciAqLCBzdHJ1Y3QgbmZzNF9zZXNzaW9uaWQgKiwKLQkJCSAgIGludCk7CituZnM0X2ZpbmRfY2xpZW50X3Nlc3Npb25pZChjb25zdCBzdHJ1Y3Qgc29ja2FkZHIgKiwgc3RydWN0IG5mczRfc2Vzc2lvbmlkICopOwogZXh0ZXJuIHN0cnVjdCBuZnNfc2VydmVyICpuZnNfY3JlYXRlX3NlcnZlcigKIAkJCQkJY29uc3Qgc3RydWN0IG5mc19wYXJzZWRfbW91bnRfZGF0YSAqLAogCQkJCQlzdHJ1Y3QgbmZzX2ZoICopOwpAQCAtMjUyLDYgKzI1MSw3IEBACiAJCSAgICAgIGNvbnN0IHN0cnVjdCBkZW50cnkgKmRyb290LAogCQkgICAgICBjb25zdCBzdHJ1Y3QgZGVudHJ5ICpkZW50cnksCiAJCSAgICAgIGNoYXIgKmJ1ZmZlciwgc3NpemVfdCBidWZsZW4pOworZXh0ZXJuIHN0cnVjdCB2ZnNtb3VudCAqbmZzX2RfYXV0b21vdW50KHN0cnVjdCBwYXRoICpwYXRoKTsKIAogLyogZ2V0cm9vdC5jICovCiBleHRlcm4gc3RydWN0IGRlbnRyeSAqbmZzX2dldF9yb290KHN0cnVjdCBzdXBlcl9ibG9jayAqLCBzdHJ1Y3QgbmZzX2ZoICopOwpkaWZmIC0tZ2l0IGEvZnMvbmZzL25hbWVzcGFjZS5jIGIvZnMvbmZzL25hbWVzcGFjZS5jCmluZGV4IDc0YWFmMzkuLmYzMmI4NjAgMTAwNjQ0Ci0tLSBhL2ZzL25mcy9uYW1lc3BhY2UuYworKysgYi9mcy9uZnMvbmFtZXNwYWNlLmMKQEAgLTk3LDkgKzk3LDggQEAKIH0KIAogLyoKLSAqIG5mc19mb2xsb3dfbW91bnRwb2ludCAtIGhhbmRsZSBjcm9zc2luZyBhIG1vdW50cG9pbnQgb24gdGhlIHNlcnZlcgotICogQGRlbnRyeSAtIGRlbnRyeSBvZiBtb3VudHBvaW50Ci0gKiBAbmQgLSBuYW1laWRhdGEgaW5mbworICogbmZzX2RfYXV0b21vdW50IC0gSGFuZGxlIGNyb3NzaW5nIGEgbW91bnRwb2ludCBvbiB0aGUgc2VydmVyCisgKiBAcGF0aCAtIFRoZSBtb3VudHBvaW50CiAgKgogICogV2hlbiB3ZSBlbmNvdW50ZXIgYSBtb3VudHBvaW50IG9uIHRoZSBzZXJ2ZXIsIHdlIHdhbnQgdG8gc2V0IHVwCiAgKiBhIG1vdW50cG9pbnQgb24gdGhlIGNsaWVudCB0b28sIHRvIHByZXZlbnQgaW5vZGUgbnVtYmVycyBmcm9tCkBAIC0xMDksODcgKzEwOCw2NSBAQAogICogc2l0dWF0aW9uLCBhbmQgdGhhdCBkaWZmZXJlbnQgZmlsZXN5c3RlbXMgbWF5IHdhbnQgdG8gdXNlCiAgKiBkaWZmZXJlbnQgc2VjdXJpdHkgZmxhdm91cnMuCiAgKi8KLXN0YXRpYyB2b2lkICogbmZzX2ZvbGxvd19tb3VudHBvaW50KHN0cnVjdCBkZW50cnkgKmRlbnRyeSwgc3RydWN0IG5hbWVpZGF0YSAqbmQpCitzdHJ1Y3QgdmZzbW91bnQgKm5mc19kX2F1dG9tb3VudChzdHJ1Y3QgcGF0aCAqcGF0aCkKIHsKIAlzdHJ1Y3QgdmZzbW91bnQgKm1udDsKLQlzdHJ1Y3QgbmZzX3NlcnZlciAqc2VydmVyID0gTkZTX1NFUlZFUihkZW50cnktPmRfaW5vZGUpOworCXN0cnVjdCBuZnNfc2VydmVyICpzZXJ2ZXIgPSBORlNfU0VSVkVSKHBhdGgtPmRlbnRyeS0+ZF9pbm9kZSk7CiAJc3RydWN0IGRlbnRyeSAqcGFyZW50OwogCXN0cnVjdCBuZnNfZmggKmZoID0gTlVMTDsKIAlzdHJ1Y3QgbmZzX2ZhdHRyICpmYXR0ciA9IE5VTEw7CiAJaW50IGVycjsKIAotCWRwcmludGsoIi0tPiBuZnNfZm9sbG93X21vdW50cG9pbnQoKVxuIik7CisJZHByaW50aygiLS0+IG5mc19kX2F1dG9tb3VudCgpXG4iKTsKIAotCWVyciA9IC1FU1RBTEU7Ci0JaWYgKElTX1JPT1QoZGVudHJ5KSkKLQkJZ290byBvdXRfZXJyOworCW1udCA9IEVSUl9QVFIoLUVTVEFMRSk7CisJaWYgKElTX1JPT1QocGF0aC0+ZGVudHJ5KSkKKwkJZ290byBvdXRfbm9mcmVlOwogCi0JZXJyID0gLUVOT01FTTsKKwltbnQgPSBFUlJfUFRSKC1FTk9NRU0pOwogCWZoID0gbmZzX2FsbG9jX2ZoYW5kbGUoKTsKIAlmYXR0ciA9IG5mc19hbGxvY19mYXR0cigpOwogCWlmIChmaCA9PSBOVUxMIHx8IGZhdHRyID09IE5VTEwpCi0JCWdvdG8gb3V0X2VycjsKKwkJZ290byBvdXQ7CiAKIAlkcHJpbnRrKCIlczogZW50ZXJcbiIsIF9fZnVuY19fKTsKLQlkcHV0KG5kLT5wYXRoLmRlbnRyeSk7Ci0JbmQtPnBhdGguZGVudHJ5ID0gZGdldChkZW50cnkpOwogCi0JLyogTG9vayBpdCB1cCBhZ2FpbiAqLwotCXBhcmVudCA9IGRnZXRfcGFyZW50KG5kLT5wYXRoLmRlbnRyeSk7CisJLyogTG9vayBpdCB1cCBhZ2FpbiB0byBnZXQgaXRzIGF0dHJpYnV0ZXMgKi8KKwlwYXJlbnQgPSBkZ2V0X3BhcmVudChwYXRoLT5kZW50cnkpOwogCWVyciA9IHNlcnZlci0+bmZzX2NsaWVudC0+cnBjX29wcy0+bG9va3VwKHBhcmVudC0+ZF9pbm9kZSwKLQkJCQkJCSAgJm5kLT5wYXRoLmRlbnRyeS0+ZF9uYW1lLAorCQkJCQkJICAmcGF0aC0+ZGVudHJ5LT5kX25hbWUsCiAJCQkJCQkgIGZoLCBmYXR0cik7CiAJZHB1dChwYXJlbnQpOwotCWlmIChlcnIgIT0gMCkKLQkJZ290byBvdXRfZXJyOworCWlmIChlcnIgIT0gMCkgeworCQltbnQgPSBFUlJfUFRSKGVycik7CisJCWdvdG8gb3V0OworCX0KIAogCWlmIChmYXR0ci0+dmFsaWQgJiBORlNfQVRUUl9GQVRUUl9WNF9SRUZFUlJBTCkKLQkJbW50ID0gbmZzX2RvX3JlZm1vdW50KG5kLT5wYXRoLm1udCwgbmQtPnBhdGguZGVudHJ5KTsKKwkJbW50ID0gbmZzX2RvX3JlZm1vdW50KHBhdGgtPm1udCwgcGF0aC0+ZGVudHJ5KTsKIAllbHNlCi0JCW1udCA9IG5mc19kb19zdWJtb3VudChuZC0+cGF0aC5tbnQsIG5kLT5wYXRoLmRlbnRyeSwgZmgsCi0JCQkJICAgICAgZmF0dHIpOwotCWVyciA9IFBUUl9FUlIobW50KTsKKwkJbW50ID0gbmZzX2RvX3N1Ym1vdW50KHBhdGgtPm1udCwgcGF0aC0+ZGVudHJ5LCBmaCwgZmF0dHIpOwogCWlmIChJU19FUlIobW50KSkKLQkJZ290byBvdXRfZXJyOworCQlnb3RvIG91dDsKIAotCW1udGdldChtbnQpOwotCWVyciA9IGRvX2FkZF9tb3VudChtbnQsICZuZC0+cGF0aCwgbmQtPnBhdGgubW50LT5tbnRfZmxhZ3N8TU5UX1NIUklOS0FCTEUsCi0JCQkgICAmbmZzX2F1dG9tb3VudF9saXN0KTsKLQlpZiAoZXJyIDwgMCkgewotCQltbnRwdXQobW50KTsKLQkJaWYgKGVyciA9PSAtRUJVU1kpCi0JCQlnb3RvIG91dF9mb2xsb3c7Ci0JCWdvdG8gb3V0X2VycjsKLQl9Ci0JcGF0aF9wdXQoJm5kLT5wYXRoKTsKLQluZC0+cGF0aC5tbnQgPSBtbnQ7Ci0JbmQtPnBhdGguZGVudHJ5ID0gZGdldChtbnQtPm1udF9yb290KTsKKwlkcHJpbnRrKCIlczogZG9uZSwgc3VjY2Vzc1xuIiwgX19mdW5jX18pOworCW1udGdldChtbnQpOyAvKiBwcmV2ZW50IGltbWVkaWF0ZSBleHBpcmF0aW9uICovCisJbW50X3NldF9leHBpcnkobW50LCAmbmZzX2F1dG9tb3VudF9saXN0KTsKIAlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJm5mc19hdXRvbW91bnRfdGFzaywgbmZzX21vdW50cG9pbnRfZXhwaXJ5X3RpbWVvdXQpOworCiBvdXQ6CiAJbmZzX2ZyZWVfZmF0dHIoZmF0dHIpOwogCW5mc19mcmVlX2ZoYW5kbGUoZmgpOwotCWRwcmludGsoIiVzOiBkb25lLCByZXR1cm5lZCAlZFxuIiwgX19mdW5jX18sIGVycik7Ci0KLQlkcHJpbnRrKCI8LS0gbmZzX2ZvbGxvd19tb3VudHBvaW50KCkgPSAlZFxuIiwgZXJyKTsKLQlyZXR1cm4gRVJSX1BUUihlcnIpOwotb3V0X2VycjoKLQlwYXRoX3B1dCgmbmQtPnBhdGgpOwotCWdvdG8gb3V0Owotb3V0X2ZvbGxvdzoKLQl3aGlsZSAoZF9tb3VudHBvaW50KG5kLT5wYXRoLmRlbnRyeSkgJiYKLQkgICAgICAgZm9sbG93X2Rvd24oJm5kLT5wYXRoKSkKLQkJOwotCWVyciA9IDA7Ci0JZ290byBvdXQ7CitvdXRfbm9mcmVlOgorCWRwcmludGsoIjwtLSBuZnNfZm9sbG93X21vdW50cG9pbnQoKSA9ICVwXG4iLCBtbnQpOworCXJldHVybiBtbnQ7CiB9CiAKIGNvbnN0IHN0cnVjdCBpbm9kZV9vcGVyYXRpb25zIG5mc19tb3VudHBvaW50X2lub2RlX29wZXJhdGlvbnMgPSB7Ci0JLmZvbGxvd19saW5rCT0gbmZzX2ZvbGxvd19tb3VudHBvaW50LAogCS5nZXRhdHRyCT0gbmZzX2dldGF0dHIsCiB9OwogCiBjb25zdCBzdHJ1Y3QgaW5vZGVfb3BlcmF0aW9ucyBuZnNfcmVmZXJyYWxfaW5vZGVfb3BlcmF0aW9ucyA9IHsKLQkuZm9sbG93X2xpbmsJPSBuZnNfZm9sbG93X21vdW50cG9pbnQsCiB9OwogCiBzdGF0aWMgdm9pZCBuZnNfZXhwaXJlX2F1dG9tb3VudHMoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQpkaWZmIC0tZ2l0IGEvZnMvbmZzL25mczNhY2wuYyBiL2ZzL25mcy9uZnMzYWNsLmMKaW5kZXggOWY4OGM1Zi4uMjc0MzQyNyAxMDA2NDQKLS0tIGEvZnMvbmZzL25mczNhY2wuYworKysgYi9mcy9uZnMvbmZzM2FjbC5jCkBAIC0zMTEsOCArMzExLDggQEAKIAlpZiAoIW5mc19zZXJ2ZXJfY2FwYWJsZShpbm9kZSwgTkZTX0NBUF9BQ0xTKSkKIAkJZ290byBvdXQ7CiAKLQkvKiBXZSBhcmUgZG9pbmcgdGhpcyBoZXJlLCBiZWNhdXNlIFhEUiBtYXJzaGFsbGluZyBjYW4gb25seQotCSAgIHJldHVybiAtRU5PTUVNLiAqLworCS8qIFdlIGFyZSBkb2luZyB0aGlzIGhlcmUgYmVjYXVzZSBYRFIgbWFyc2hhbGxpbmcgZG9lcyBub3QKKwkgKiByZXR1cm4gYW55IHJlc3VsdHMsIGl0IEJVR3MuICovCiAJc3RhdHVzID0gLUVOT1NQQzsKIAlpZiAoYWNsICE9IE5VTEwgJiYgYWNsLT5hX2NvdW50ID4gTkZTX0FDTF9NQVhfRU5UUklFUykKIAkJZ290byBvdXQ7CmRpZmYgLS1naXQgYS9mcy9uZnMvbmZzM3hkci5jIGIvZnMvbmZzL25mczN4ZHIuYwppbmRleCAwMWM1ZThiLi4xODNjNmIxIDEwMDY0NAotLS0gYS9mcy9uZnMvbmZzM3hkci5jCisrKyBiL2ZzL25mcy9uZnMzeGRyLmMKQEAgLTEzMjgsMTAgKzEzMjgsMTMgQEAKIAogCWVuY29kZV9uZnNfZmgzKHhkciwgTkZTX0ZIKGFyZ3MtPmlub2RlKSk7CiAJZW5jb2RlX3VpbnQzMih4ZHIsIGFyZ3MtPm1hc2spOwotCWlmIChhcmdzLT5ucGFnZXMgIT0gMCkKLQkJeGRyX3dyaXRlX3BhZ2VzKHhkciwgYXJncy0+cGFnZXMsIDAsIGFyZ3MtPmxlbik7CiAKIAliYXNlID0gcmVxLT5ycV9zbGVuOworCWlmIChhcmdzLT5ucGFnZXMgIT0gMCkKKwkJeGRyX3dyaXRlX3BhZ2VzKHhkciwgYXJncy0+cGFnZXMsIDAsIGFyZ3MtPmxlbik7CisJZWxzZQorCQl4ZHJfcmVzZXJ2ZV9zcGFjZSh4ZHIsIE5GU19BQ0xfSU5MSU5FX0JVRlNJWkUpOworCiAJZXJyb3IgPSBuZnNhY2xfZW5jb2RlKHhkci0+YnVmLCBiYXNlLCBhcmdzLT5pbm9kZSwKIAkJCSAgICAoYXJncy0+bWFzayAmIE5GU19BQ0wpID8KIAkJCSAgICBhcmdzLT5hY2xfYWNjZXNzIDogTlVMTCwgMSwgMCk7CmRpZmYgLS1naXQgYS9mcy9uZnMvbmZzNGZpbGVsYXlvdXRkZXYuYyBiL2ZzL25mcy9uZnM0ZmlsZWxheW91dGRldi5jCmluZGV4IDUxZmU2NGEuLmY1YzliMTIgMTAwNjQ0Ci0tLSBhL2ZzL25mcy9uZnM0ZmlsZWxheW91dGRldi5jCisrKyBiL2ZzL25mcy9uZnM0ZmlsZWxheW91dGRldi5jCkBAIC0yMTQsNyArMjE0LDcgQEAKIAogCS8qIGlwdjYgbGVuZ3RoIHBsdXMgcG9ydCBpcyBsZWdhbCAqLwogCWlmIChybGVuID4gSU5FVDZfQUREUlNUUkxFTiArIDgpIHsKLQkJZHByaW50aygiJXMgSW52YWxpZCBhZGRyZXNzLCBsZW5ndGggJWRcbiIsIF9fZnVuY19fLAorCQlkcHJpbnRrKCIlczogSW52YWxpZCBhZGRyZXNzLCBsZW5ndGggJWRcbiIsIF9fZnVuY19fLAogCQkJcmxlbik7CiAJCWdvdG8gb3V0X2VycjsKIAl9CkBAIC0yMjUsNiArMjI1LDExIEBACiAJLyogcmVwbGFjZSB0aGUgcG9ydCBkb3RzIHdpdGggZGFzaGVzIGZvciB0aGUgaW40X3B0b24oKSBkZWxpbWl0ZXIqLwogCWZvciAoaSA9IDA7IGkgPCAyOyBpKyspIHsKIAkJY2hhciAqcmVzID0gc3RycmNocihidWYsICcuJyk7CisJCWlmICghcmVzKSB7CisJCQlkcHJpbnRrKCIlczogRmFpbGVkIGZpbmRpbmcgZXhwZWN0ZWQgZG90cyBpbiBwb3J0XG4iLAorCQkJCV9fZnVuY19fKTsKKwkJCWdvdG8gb3V0X2ZyZWU7CisJCX0KIAkJKnJlcyA9ICctJzsKIAl9CiAKQEAgLTI0MCw3ICsyNDUsNyBAQAogCXBvcnQgPSBodG9ucygodG1wWzBdIDw8IDgpIHwgKHRtcFsxXSkpOwogCiAJZHMgPSBuZnM0X3BuZnNfZHNfYWRkKGlub2RlLCBpcF9hZGRyLCBwb3J0KTsKLQlkcHJpbnRrKCIlcyBEZWNvZGVkIGFkZHJlc3MgYW5kIHBvcnQgJXNcbiIsIF9fZnVuY19fLCBidWYpOworCWRwcmludGsoIiVzOiBEZWNvZGVkIGFkZHJlc3MgYW5kIHBvcnQgJXNcbiIsIF9fZnVuY19fLCBidWYpOwogb3V0X2ZyZWU6CiAJa2ZyZWUoYnVmKTsKIG91dF9lcnI6CmRpZmYgLS1naXQgYS9mcy9uZnMvbmZzNHByb2MuYyBiL2ZzL25mcy9uZnM0cHJvYy5jCmluZGV4IDlkOTkyYjAuLjc4OTM2YTggMTAwNjQ0Ci0tLSBhL2ZzL25mcy9uZnM0cHJvYy5jCisrKyBiL2ZzL25mcy9uZnM0cHJvYy5jCkBAIC01MCw2ICs1MCw3IEBACiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvc3VucnBjL2JjX3hwcnQuaD4KICNpbmNsdWRlIDxsaW51eC94YXR0ci5oPgorI2luY2x1ZGUgPGxpbnV4L3V0c25hbWUuaD4KIAogI2luY2x1ZGUgIm5mczRfZnMuaCIKICNpbmNsdWRlICJkZWxlZ2F0aW9uLmgiCkBAIC00NTcyLDI3ICs0NTczLDE2IEBACiAJKnAgPSBodG9ubCgodTMyKWNscC0+Y2xfYm9vdF90aW1lLnR2X25zZWMpOwogCWFyZ3MudmVyaWZpZXIgPSAmdmVyaWZpZXI7CiAKLQl3aGlsZSAoMSkgewotCQlhcmdzLmlkX2xlbiA9IHNjbnByaW50ZihhcmdzLmlkLCBzaXplb2YoYXJncy5pZCksCi0JCQkJCSIlcy8lcyAldSIsCi0JCQkJCWNscC0+Y2xfaXBhZGRyLAotCQkJCQlycGNfcGVlcmFkZHIyc3RyKGNscC0+Y2xfcnBjY2xpZW50LAotCQkJCQkJCSBSUENfRElTUExBWV9BRERSKSwKLQkJCQkJY2xwLT5jbF9pZF91bmlxdWlmaWVyKTsKKwlhcmdzLmlkX2xlbiA9IHNjbnByaW50ZihhcmdzLmlkLCBzaXplb2YoYXJncy5pZCksCisJCQkJIiVzLyVzLiVzLyV1IiwKKwkJCQljbHAtPmNsX2lwYWRkciwKKwkJCQlpbml0X3V0c25hbWUoKS0+bm9kZW5hbWUsCisJCQkJaW5pdF91dHNuYW1lKCktPmRvbWFpbm5hbWUsCisJCQkJY2xwLT5jbF9ycGNjbGllbnQtPmNsX2F1dGgtPmF1X2ZsYXZvcik7CiAKLQkJc3RhdHVzID0gcnBjX2NhbGxfc3luYyhjbHAtPmNsX3JwY2NsaWVudCwgJm1zZywgMCk7Ci0KLQkJaWYgKHN0YXR1cyAhPSAtTkZTNEVSUl9DTElEX0lOVVNFKQotCQkJYnJlYWs7Ci0KLQkJaWYgKHNpZ25hbGxlZCgpKQotCQkJYnJlYWs7Ci0KLQkJaWYgKCsrY2xwLT5jbF9pZF91bmlxdWlmaWVyID09IDApCi0JCQlicmVhazsKLQl9Ci0KLQlzdGF0dXMgPSBuZnM0X2NoZWNrX2NsX2V4Y2hhbmdlX2ZsYWdzKGNscC0+Y2xfZXhjaGFuZ2VfZmxhZ3MpOworCXN0YXR1cyA9IHJwY19jYWxsX3N5bmMoY2xwLT5jbF9ycGNjbGllbnQsICZtc2csIDApOworCWlmICghc3RhdHVzKQorCQlzdGF0dXMgPSBuZnM0X2NoZWNrX2NsX2V4Y2hhbmdlX2ZsYWdzKGNscC0+Y2xfZXhjaGFuZ2VfZmxhZ3MpOwogCWRwcmludGsoIjwtLSAlcyBzdGF0dXM9ICVkXG4iLCBfX2Z1bmNfXywgc3RhdHVzKTsKIAlyZXR1cm4gc3RhdHVzOwogfQpkaWZmIC0tZ2l0IGEvZnMvbmZzL25mczRzdGF0ZS5jIGIvZnMvbmZzL25mczRzdGF0ZS5jCmluZGV4IDIzMzZkNTMuLmU2NzQyYjUgMTAwNjQ0Ci0tLSBhL2ZzL25mcy9uZnM0c3RhdGUuYworKysgYi9mcy9uZnMvbmZzNHN0YXRlLmMKQEAgLTIzMiwxMiArMjMyLDYgQEAKIAlzdGF0dXMgPSBuZnM0X3Byb2NfY3JlYXRlX3Nlc3Npb24oY2xwKTsKIAlpZiAoc3RhdHVzICE9IDApCiAJCWdvdG8gb3V0OwotCXN0YXR1cyA9IG5mczRfc2V0X2NhbGxiYWNrX3Nlc3Npb25pZChjbHApOwotCWlmIChzdGF0dXMgIT0gMCkgewotCQlwcmludGsoS0VSTl9XQVJOSU5HICJTZXNzaW9uaWQgbm90IHNldC4gTm8gY2FsbGJhY2sgc2VydmljZVxuIik7Ci0JCW5mc19jYWxsYmFja19kb3duKDEpOwotCQlzdGF0dXMgPSAwOwotCX0KIAluZnM0MV9zZXR1cF9zdGF0ZV9yZW5ld2FsKGNscCk7CiAJbmZzX21hcmtfY2xpZW50X3JlYWR5KGNscCwgTkZTX0NTX1JFQURZKTsKIG91dDoKZGlmZiAtLWdpdCBhL2ZzL25mcy9uZnM0eGRyLmMgYi9mcy9uZnMvbmZzNHhkci5jCmluZGV4IDJhYjhlNWMuLjRlMmMxNjggMTAwNjQ0Ci0tLSBhL2ZzL25mcy9uZnM0eGRyLmMKKysrIGIvZnMvbmZzL25mczR4ZHIuYwpAQCAtNjA4NiwxMSArNjA4NiwxMSBAQAogCV9fYmUzMiAqcCA9IHhkcl9pbmxpbmVfZGVjb2RlKHhkciwgNCk7CiAJaWYgKHVubGlrZWx5KCFwKSkKIAkJZ290byBvdXRfb3ZlcmZsb3c7Ci0JaWYgKCFudG9obCgqcCsrKSkgeworCWlmICgqcCA9PSB4ZHJfemVybykgewogCQlwID0geGRyX2lubGluZV9kZWNvZGUoeGRyLCA0KTsKIAkJaWYgKHVubGlrZWx5KCFwKSkKIAkJCWdvdG8gb3V0X292ZXJmbG93OwotCQlpZiAoIW50b2hsKCpwKyspKQorCQlpZiAoKnAgPT0geGRyX3plcm8pCiAJCQlyZXR1cm4gLUVBR0FJTjsKIAkJZW50cnktPmVvZiA9IDE7CiAJCXJldHVybiAtRUJBRENPT0tJRTsKQEAgLTYxMDEsNyArNjEwMSw3IEBACiAJCWdvdG8gb3V0X292ZXJmbG93OwogCWVudHJ5LT5wcmV2X2Nvb2tpZSA9IGVudHJ5LT5jb29raWU7CiAJcCA9IHhkcl9kZWNvZGVfaHlwZXIocCwgJmVudHJ5LT5jb29raWUpOwotCWVudHJ5LT5sZW4gPSBudG9obCgqcCsrKTsKKwllbnRyeS0+bGVuID0gYmUzMl90b19jcHVwKHApOwogCiAJcCA9IHhkcl9pbmxpbmVfZGVjb2RlKHhkciwgZW50cnktPmxlbik7CiAJaWYgKHVubGlrZWx5KCFwKSkKQEAgLTYxMzIsOSArNjEzMiw2IEBACiAJaWYgKGVudHJ5LT5mYXR0ci0+dmFsaWQgJiBORlNfQVRUUl9GQVRUUl9UWVBFKQogCQllbnRyeS0+ZF90eXBlID0gbmZzX3Vtb2RlX3RvX2R0eXBlKGVudHJ5LT5mYXR0ci0+bW9kZSk7CiAKLQlpZiAodmVyaWZ5X2F0dHJfbGVuKHhkciwgcCwgbGVuKSA8IDApCi0JCWdvdG8gb3V0X292ZXJmbG93OwotCiAJcmV0dXJuIDA7CiAKIG91dF9vdmVyZmxvdzoKZGlmZiAtLWdpdCBhL2ZzL25mcy9wbmZzLmMgYi9mcy9uZnMvcG5mcy5jCmluZGV4IGJjNDA4OTcuLjFiMWJjMWEgMTAwNjQ0Ci0tLSBhL2ZzL25mcy9wbmZzLmMKKysrIGIvZnMvbmZzL3BuZnMuYwpAQCAtOTUxLDcgKzk1MSw3IEBACiB7CiAJc3RydWN0IHBuZnNfZGV2aWNlaWRfY2FjaGUgKmxvY2FsID0gY2xwLT5jbF9kZXZpZF9jYWNoZTsKIAotCWRwcmludGsoIi0tPiAlcyBjbF9kZXZpZF9jYWNoZSAlcFxuIiwgX19mdW5jX18sIGNscC0+Y2xfZGV2aWRfY2FjaGUpOworCWRwcmludGsoIi0tPiAlcyAoeyVkfSlcbiIsIF9fZnVuY19fLCBhdG9taWNfcmVhZCgmbG9jYWwtPmRjX3JlZikpOwogCWlmIChhdG9taWNfZGVjX2FuZF9sb2NrKCZsb2NhbC0+ZGNfcmVmLCAmY2xwLT5jbF9sb2NrKSkgewogCQlpbnQgaTsKIAkJLyogVmVyaWZ5IGNhY2hlIGlzIGVtcHR5ICovCmRpZmYgLS1naXQgYS9mcy9uZnMvd3JpdGUuYyBiL2ZzL25mcy93cml0ZS5jCmluZGV4IDEwZDY0OGVhLi5jODI3OGY0IDEwMDY0NAotLS0gYS9mcy9uZnMvd3JpdGUuYworKysgYi9mcy9uZnMvd3JpdGUuYwpAQCAtOTMyLDcgKzkzMiw3IEBACiAJd2hpbGUgKCFsaXN0X2VtcHR5KCZsaXN0KSkgewogCQlkYXRhID0gbGlzdF9lbnRyeShsaXN0Lm5leHQsIHN0cnVjdCBuZnNfd3JpdGVfZGF0YSwgcGFnZXMpOwogCQlsaXN0X2RlbCgmZGF0YS0+cGFnZXMpOwotCQluZnNfd3JpdGVkYXRhX3JlbGVhc2UoZGF0YSk7CisJCW5mc193cml0ZWRhdGFfZnJlZShkYXRhKTsKIAl9CiAJbmZzX3JlZGlydHlfcmVxdWVzdChyZXEpOwogCXJldHVybiAtRU5PTUVNOwpkaWZmIC0tZ2l0IGEvZnMvbmZzX2NvbW1vbi9uZnNhY2wuYyBiL2ZzL25mc19jb21tb24vbmZzYWNsLmMKaW5kZXggZmMxYzUyNS4uODRjMjdkNiAxMDA2NDQKLS0tIGEvZnMvbmZzX2NvbW1vbi9uZnNhY2wuYworKysgYi9mcy9uZnNfY29tbW9uL25mc2FjbC5jCkBAIC00Miw2ICs0MiwxMSBAQAogCWdpZF90IGdpZDsKIH07CiAKK3N0cnVjdCBuZnNhY2xfc2ltcGxlX2FjbCB7CisJc3RydWN0IHBvc2l4X2FjbCBhY2w7CisJc3RydWN0IHBvc2l4X2FjbF9lbnRyeSBhY2VbNF07Cit9OworCiBzdGF0aWMgaW50CiB4ZHJfbmZzYWNlX2VuY29kZShzdHJ1Y3QgeGRyX2FycmF5Ml9kZXNjICpkZXNjLCB2b2lkICplbGVtKQogewpAQCAtNzIsOSArNzcsMjAgQEAKIAlyZXR1cm4gMDsKIH0KIAotdW5zaWduZWQgaW50Ci1uZnNhY2xfZW5jb2RlKHN0cnVjdCB4ZHJfYnVmICpidWYsIHVuc2lnbmVkIGludCBiYXNlLCBzdHJ1Y3QgaW5vZGUgKmlub2RlLAotCSAgICAgIHN0cnVjdCBwb3NpeF9hY2wgKmFjbCwgaW50IGVuY29kZV9lbnRyaWVzLCBpbnQgdHlwZWZsYWcpCisvKioKKyAqIG5mc2FjbF9lbmNvZGUgLSBFbmNvZGUgYW4gTkZTdjMgQUNMCisgKgorICogQGJ1ZjogZGVzdGluYXRpb24geGRyX2J1ZiB0byBjb250YWluIFhEUiBlbmNvZGVkIEFDTAorICogQGJhc2U6IGJ5dGUgb2Zmc2V0IGluIHhkcl9idWYgd2hlcmUgWERSJ2QgQUNMIGJlZ2lucworICogQGlub2RlOiBpbm9kZSBvZiBmaWxlIHdob3NlIEFDTCB0aGlzIGlzCisgKiBAYWNsOiBwb3NpeF9hY2wgdG8gZW5jb2RlCisgKiBAZW5jb2RlX2VudHJpZXM6IHdoZXRoZXIgdG8gZW5jb2RlIEFDRXMgYXMgd2VsbAorICogQHR5cGVmbGFnOiBBQ0wgdHlwZTogTkZTX0FDTF9ERUZBVUxUIG9yIHplcm8KKyAqCisgKiBSZXR1cm5zIHNpemUgb2YgZW5jb2RlZCBBQ0wgaW4gYnl0ZXMgb3IgYSBuZWdhdGl2ZSBlcnJubyB2YWx1ZS4KKyAqLworaW50IG5mc2FjbF9lbmNvZGUoc3RydWN0IHhkcl9idWYgKmJ1ZiwgdW5zaWduZWQgaW50IGJhc2UsIHN0cnVjdCBpbm9kZSAqaW5vZGUsCisJCSAgc3RydWN0IHBvc2l4X2FjbCAqYWNsLCBpbnQgZW5jb2RlX2VudHJpZXMsIGludCB0eXBlZmxhZykKIHsKIAlpbnQgZW50cmllcyA9IChhY2wgJiYgYWNsLT5hX2NvdW50KSA/IG1heF90KGludCwgYWNsLT5hX2NvdW50LCA0KSA6IDA7CiAJc3RydWN0IG5mc2FjbF9lbmNvZGVfZGVzYyBuZnNhY2xfZGVzYyA9IHsKQEAgLTg4LDE3ICsxMDQsMjIgQEAKIAkJLnVpZCA9IGlub2RlLT5pX3VpZCwKIAkJLmdpZCA9IGlub2RlLT5pX2dpZCwKIAl9OworCXN0cnVjdCBuZnNhY2xfc2ltcGxlX2FjbCBhY2xidWY7CiAJaW50IGVycjsKLQlzdHJ1Y3QgcG9zaXhfYWNsICphY2wyID0gTlVMTDsKIAogCWlmIChlbnRyaWVzID4gTkZTX0FDTF9NQVhfRU5UUklFUyB8fAogCSAgICB4ZHJfZW5jb2RlX3dvcmQoYnVmLCBiYXNlLCBlbnRyaWVzKSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAJaWYgKGVuY29kZV9lbnRyaWVzICYmIGFjbCAmJiBhY2wtPmFfY291bnQgPT0gMykgewotCQkvKiBGYWtlIHVwIGFuIEFDTF9NQVNLIGVudHJ5LiAqLwotCQlhY2wyID0gcG9zaXhfYWNsX2FsbG9jKDQsIEdGUF9LRVJORUwpOwotCQlpZiAoIWFjbDIpCi0JCQlyZXR1cm4gLUVOT01FTTsKKwkJc3RydWN0IHBvc2l4X2FjbCAqYWNsMiA9ICZhY2xidWYuYWNsOworCisJCS8qIEF2b2lkIHRoZSB1c2Ugb2YgcG9zaXhfYWNsX2FsbG9jKCkuICBuZnNhY2xfZW5jb2RlKCkgaXMKKwkJICogaW52b2tlZCBpbiBjb250ZXh0cyB3aGVyZSBhIG1lbW9yeSBhbGxvY2F0aW9uIGZhaWx1cmUgaXMKKwkJICogZmF0YWwuICBGb3J0dW5hdGVseSB0aGlzIGZha2UgQUNMIGlzIHNtYWxsIGVub3VnaCB0bworCQkgKiBjb25zdHJ1Y3Qgb24gdGhlIHN0YWNrLiAqLworCQltZW1zZXQoYWNsMiwgMCwgc2l6ZW9mKGFjbDIpKTsKKwkJcG9zaXhfYWNsX2luaXQoYWNsMiwgNCk7CisKIAkJLyogSW5zZXJ0IGVudHJpZXMgaW4gY2Fub25pY2FsIG9yZGVyOiBvdGhlciBvcmRlcnMgc2VlbQogCQkgdG8gY29uZnVzZSBTb2xhcmlzIFZ4RlMuICovCiAJCWFjbDItPmFfZW50cmllc1swXSA9IGFjbC0+YV9lbnRyaWVzWzBdOyAgLyogQUNMX1VTRVJfT0JKICovCkBAIC0xMDksOCArMTMwLDYgQEAKIAkJbmZzYWNsX2Rlc2MuYWNsID0gYWNsMjsKIAl9CiAJZXJyID0geGRyX2VuY29kZV9hcnJheTIoYnVmLCBiYXNlICsgNCwgJm5mc2FjbF9kZXNjLmRlc2MpOwotCWlmIChhY2wyKQotCQlwb3NpeF9hY2xfcmVsZWFzZShhY2wyKTsKIAlpZiAoIWVycikKIAkJZXJyID0gOCArIG5mc2FjbF9kZXNjLmRlc2MuZWxlbV9zaXplICoKIAkJCSAgbmZzYWNsX2Rlc2MuZGVzYy5hcnJheV9sZW47CkBAIC0yMjQsOSArMjQzLDE4IEBACiAJcmV0dXJuIDA7CiB9CiAKLXVuc2lnbmVkIGludAotbmZzYWNsX2RlY29kZShzdHJ1Y3QgeGRyX2J1ZiAqYnVmLCB1bnNpZ25lZCBpbnQgYmFzZSwgdW5zaWduZWQgaW50ICphY2xjbnQsCi0JICAgICAgc3RydWN0IHBvc2l4X2FjbCAqKnBhY2wpCisvKioKKyAqIG5mc2FjbF9kZWNvZGUgLSBEZWNvZGUgYW4gTkZTdjMgQUNMCisgKgorICogQGJ1ZjogeGRyX2J1ZiBjb250YWluaW5nIFhEUidkIEFDTCBkYXRhIHRvIGRlY29kZQorICogQGJhc2U6IGJ5dGUgb2Zmc2V0IGluIHhkcl9idWYgd2hlcmUgWERSJ2QgQUNMIGJlZ2lucworICogQGFjbGNudDogY291bnQgb2YgQUNFcyBpbiBkZWNvZGVkIHBvc2l4X2FjbAorICogQHBhY2w6IGJ1ZmZlciBpbiB3aGljaCB0byBwbGFjZSBkZWNvZGVkIHBvc2l4X2FjbAorICoKKyAqIFJldHVybnMgdGhlIGxlbmd0aCBvZiB0aGUgZGVjb2RlZCBBQ0wgaW4gYnl0ZXMsIG9yIGEgbmVnYXRpdmUgZXJybm8gdmFsdWUuCisgKi8KK2ludCBuZnNhY2xfZGVjb2RlKHN0cnVjdCB4ZHJfYnVmICpidWYsIHVuc2lnbmVkIGludCBiYXNlLCB1bnNpZ25lZCBpbnQgKmFjbGNudCwKKwkJICBzdHJ1Y3QgcG9zaXhfYWNsICoqcGFjbCkKIHsKIAlzdHJ1Y3QgbmZzYWNsX2RlY29kZV9kZXNjIG5mc2FjbF9kZXNjID0gewogCQkuZGVzYyA9IHsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbmZzNF9hY2wuaCBiL2ZzL25mc2QvYWNsLmgKc2ltaWxhcml0eSBpbmRleCA5NyUKcmVuYW1lIGZyb20gaW5jbHVkZS9saW51eC9uZnM0X2FjbC5oCnJlbmFtZSB0byBmcy9uZnNkL2FjbC5oCmluZGV4IGM5YzA1YTcuLjM0ZTVjNDAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbmZzNF9hY2wuaAorKysgYi9mcy9uZnNkL2FjbC5oCkBAIC0xLDYgKzEsNCBAQAogLyoKLSAqICBpbmNsdWRlL2xpbnV4L25mczRfYWNsLmMKLSAqCiAgKiAgQ29tbW9uIE5GU3Y0IEFDTCBoYW5kbGluZyBkZWZpbml0aW9ucy4KICAqCiAgKiAgQ29weXJpZ2h0IChjKSAyMDAyIFRoZSBSZWdlbnRzIG9mIHRoZSBVbml2ZXJzaXR5IG9mIE1pY2hpZ2FuLgpkaWZmIC0tZ2l0IGEvZnMvbmZzZC9leHBvcnQuYyBiL2ZzL25mc2QvZXhwb3J0LmMKaW5kZXggYzBmY2I3YS4uOGIzMWU1ZiAxMDA2NDQKLS0tIGEvZnMvbmZzZC9leHBvcnQuYworKysgYi9mcy9uZnNkL2V4cG9ydC5jCkBAIC0xLDQgKzEsMyBAQAotI2RlZmluZSBNU05GUwkvKiBIQUNLIEhBQ0sgKi8KIC8qCiAgKiBORlMgZXhwb3J0aW5nIGFuZCB2YWxpZGF0aW9uLgogICoKQEAgLTE0NDQsOSArMTQ0Myw2IEBACiAJeyBORlNFWFBfTk9TVUJUUkVFQ0hFQ0ssIHsibm9fc3VidHJlZV9jaGVjayIsICIifX0sCiAJeyBORlNFWFBfTk9BVVRITkxNLCB7Imluc2VjdXJlX2xvY2tzIiwgIiJ9fSwKIAl7IE5GU0VYUF9WNFJPT1QsIHsidjRyb290IiwgIiJ9fSwKLSNpZmRlZiBNU05GUwotCXsgTkZTRVhQX01TTkZTLCB7Im1zbmZzIiwgIiJ9fSwKLSNlbmRpZgogCXsgMCwgeyIiLCAiIn19CiB9OwogCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L25mc2RfaWRtYXAuaCBiL2ZzL25mc2QvaWRtYXAuaApzaW1pbGFyaXR5IGluZGV4IDkxJQpyZW5hbWUgZnJvbSBpbmNsdWRlL2xpbnV4L25mc2RfaWRtYXAuaApyZW5hbWUgdG8gZnMvbmZzZC9pZG1hcC5oCmluZGV4IGQ0YTJhYzEuLjJmM2JlMTMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbmZzZF9pZG1hcC5oCisrKyBiL2ZzL25mc2QvaWRtYXAuaApAQCAtMSw2ICsxLDQgQEAKIC8qCi0gKiAgaW5jbHVkZS9saW51eC9uZnNkX2lkbWFwLmgKLSAqCiAgKiAgTWFwcGluZyBvZiBVSUQgdG8gbmFtZSBhbmQgdmljZSB2ZXJzYS4KICAqCiAgKiAgQ29weXJpZ2h0IChjKSAyMDAyLCAyMDAzIFRoZSBSZWdlbnRzIG9mIHRoZSBVbml2ZXJzaXR5IG9mCkBAIC01Niw4ICs1NCw4IEBACiB9CiAjZW5kaWYKIAotaW50IG5mc2RfbWFwX25hbWVfdG9fdWlkKHN0cnVjdCBzdmNfcnFzdCAqLCBjb25zdCBjaGFyICosIHNpemVfdCwgX191MzIgKik7Ci1pbnQgbmZzZF9tYXBfbmFtZV90b19naWQoc3RydWN0IHN2Y19ycXN0ICosIGNvbnN0IGNoYXIgKiwgc2l6ZV90LCBfX3UzMiAqKTsKK19fYmUzMiBuZnNkX21hcF9uYW1lX3RvX3VpZChzdHJ1Y3Qgc3ZjX3Jxc3QgKiwgY29uc3QgY2hhciAqLCBzaXplX3QsIF9fdTMyICopOworX19iZTMyIG5mc2RfbWFwX25hbWVfdG9fZ2lkKHN0cnVjdCBzdmNfcnFzdCAqLCBjb25zdCBjaGFyICosIHNpemVfdCwgX191MzIgKik7CiBpbnQgbmZzZF9tYXBfdWlkX3RvX25hbWUoc3RydWN0IHN2Y19ycXN0ICosIF9fdTMyLCBjaGFyICopOwogaW50IG5mc2RfbWFwX2dpZF90b19uYW1lKHN0cnVjdCBzdmNfcnFzdCAqLCBfX3UzMiwgY2hhciAqKTsKIApkaWZmIC0tZ2l0IGEvZnMvbmZzZC9uZnMzcHJvYy5jIGIvZnMvbmZzZC9uZnMzcHJvYy5jCmluZGV4IDViN2UzMDIuLjIyNDdmYzkgMTAwNjQ0Ci0tLSBhL2ZzL25mc2QvbmZzM3Byb2MuYworKysgYi9mcy9uZnNkL25mczNwcm9jLmMKQEAgLTE1MSwxMCArMTUxLDEwIEBACiAJX19iZTMyCW5mc2VycjsKIAl1MzIJbWF4X2Jsb2Nrc2l6ZSA9IHN2Y19tYXhfcGF5bG9hZChycXN0cCk7CiAKLQlkcHJpbnRrKCJuZnNkOiBSRUFEKDMpICVzICVsdSBieXRlcyBhdCAlbHVcbiIsCisJZHByaW50aygibmZzZDogUkVBRCgzKSAlcyAlbHUgYnl0ZXMgYXQgJUx1XG4iLAogCQkJCVNWQ0ZIX2ZtdCgmYXJncC0+ZmgpLAogCQkJCSh1bnNpZ25lZCBsb25nKSBhcmdwLT5jb3VudCwKLQkJCQkodW5zaWduZWQgbG9uZykgYXJncC0+b2Zmc2V0KTsKKwkJCQkodW5zaWduZWQgbG9uZyBsb25nKSBhcmdwLT5vZmZzZXQpOwogCiAJLyogT2J0YWluIGJ1ZmZlciBwb2ludGVyIGZvciBwYXlsb2FkLgogCSAqIDEgKHN0YXR1cykgKyAyMiAocG9zdF9vcF9hdHRyKSArIDEgKGNvdW50KSArIDEgKGVvZikKQEAgLTE5MSwxMCArMTkxLDEwIEBACiAJX19iZTMyCW5mc2VycjsKIAl1bnNpZ25lZCBsb25nIGNudCA9IGFyZ3AtPmxlbjsKIAotCWRwcmludGsoIm5mc2Q6IFdSSVRFKDMpICAgICVzICVkIGJ5dGVzIGF0ICVsZCVzXG4iLAorCWRwcmludGsoIm5mc2Q6IFdSSVRFKDMpICAgICVzICVkIGJ5dGVzIGF0ICVMdSVzXG4iLAogCQkJCVNWQ0ZIX2ZtdCgmYXJncC0+ZmgpLAogCQkJCWFyZ3AtPmxlbiwKLQkJCQkodW5zaWduZWQgbG9uZykgYXJncC0+b2Zmc2V0LAorCQkJCSh1bnNpZ25lZCBsb25nIGxvbmcpIGFyZ3AtPm9mZnNldCwKIAkJCQlhcmdwLT5zdGFibGU/ICIgc3RhYmxlIiA6ICIiKTsKIAogCWZoX2NvcHkoJnJlc3AtPmZoLCAmYXJncC0+ZmgpOwpkaWZmIC0tZ2l0IGEvZnMvbmZzZC9uZnM0YWNsLmMgYi9mcy9uZnNkL25mczRhY2wuYwppbmRleCBlNDgwNTI2Li5hZDg4ZjFjIDEwMDY0NAotLS0gYS9mcy9uZnNkL25mczRhY2wuYworKysgYi9mcy9uZnNkL25mczRhY2wuYwpAQCAtMzYsNyArMzYsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L25mc19mcy5oPgotI2luY2x1ZGUgPGxpbnV4L25mczRfYWNsLmg+CisjaW5jbHVkZSAiYWNsLmgiCiAKIAogLyogbW9kZSBiaXQgdHJhbnNsYXRpb25zOiAqLwpkaWZmIC0tZ2l0IGEvZnMvbmZzZC9uZnM0Y2FsbGJhY2suYyBiL2ZzL25mc2QvbmZzNGNhbGxiYWNrLmMKaW5kZXggMjFhNjNkYS4uM2JlOTc1ZSAxMDA2NDQKLS0tIGEvZnMvbmZzZC9uZnM0Y2FsbGJhY2suYworKysgYi9mcy9uZnNkL25mczRjYWxsYmFjay5jCkBAIC02MjgsMTAgKzYyOCw4IEBACiAJcmV0dXJuIG1heChuZnNkNF9sZWFzZS8xMCwgKHRpbWVfdCkxKSAqIEhaOwogfQogCi0vKiBSZWZlcmVuY2UgY291bnRpbmcsIGNhbGxiYWNrIGNsZWFudXAsIGV0Yy4sIGFsbCBsb29rIHJhY3kgYXMgaGVjay4KLSAqIEFuZCB3aHkgaXMgY2xfY2Jfc2V0IGFuIGF0b21pYz8gKi8KIAotaW50IHNldHVwX2NhbGxiYWNrX2NsaWVudChzdHJ1Y3QgbmZzNF9jbGllbnQgKmNscCwgc3RydWN0IG5mczRfY2JfY29ubiAqY29ubikKK3N0YXRpYyBpbnQgc2V0dXBfY2FsbGJhY2tfY2xpZW50KHN0cnVjdCBuZnM0X2NsaWVudCAqY2xwLCBzdHJ1Y3QgbmZzNF9jYl9jb25uICpjb25uLCBzdHJ1Y3QgbmZzZDRfc2Vzc2lvbiAqc2VzKQogewogCXN0cnVjdCBycGNfdGltZW91dAl0aW1lcGFybXMgPSB7CiAJCS50b19pbml0dmFsCT0gbWF4X2NiX3RpbWUoKSwKQEAgLTY0MSw2ICs2MzksNyBAQAogCQkubmV0CQk9ICZpbml0X25ldCwKIAkJLmFkZHJlc3MJPSAoc3RydWN0IHNvY2thZGRyICopICZjb25uLT5jYl9hZGRyLAogCQkuYWRkcnNpemUJPSBjb25uLT5jYl9hZGRybGVuLAorCQkuc2FkZHJlc3MJPSAoc3RydWN0IHNvY2thZGRyICopICZjb25uLT5jYl9zYWRkciwKIAkJLnRpbWVvdXQJPSAmdGltZXBhcm1zLAogCQkucHJvZ3JhbQk9ICZjYl9wcm9ncmFtLAogCQkudmVyc2lvbgk9IDAsCkBAIC02NTcsNiArNjU2LDEwIEBACiAJCWFyZ3MucHJvdG9jb2wgPSBYUFJUX1RSQU5TUE9SVF9UQ1A7CiAJCWNscC0+Y2xfY2JfaWRlbnQgPSBjb25uLT5jYl9pZGVudDsKIAl9IGVsc2UgeworCQlpZiAoIWNvbm4tPmNiX3hwcnQpCisJCQlyZXR1cm4gLUVJTlZBTDsKKwkJY2xwLT5jbF9jYl9jb25uLmNiX3hwcnQgPSBjb25uLT5jYl94cHJ0OworCQljbHAtPmNsX2NiX3Nlc3Npb24gPSBzZXM7CiAJCWFyZ3MuYmNfeHBydCA9IGNvbm4tPmNiX3hwcnQ7CiAJCWFyZ3MucHJvZ251bWJlciA9IGNscC0+Y2xfY2Jfc2Vzc2lvbi0+c2VfY2JfcHJvZzsKIAkJYXJncy5wcm90b2NvbCA9IFhQUlRfVFJBTlNQT1JUX0JDX1RDUDsKQEAgLTY3OSwxNCArNjgyLDIwIEBACiAJCShpbnQpY2xwLT5jbF9uYW1lLmxlbiwgY2xwLT5jbF9uYW1lLmRhdGEsIHJlYXNvbik7CiB9CiAKK3N0YXRpYyB2b2lkIG5mc2Q0X21hcmtfY2JfZG93bihzdHJ1Y3QgbmZzNF9jbGllbnQgKmNscCwgaW50IHJlYXNvbikKK3sKKwljbHAtPmNsX2NiX3N0YXRlID0gTkZTRDRfQ0JfRE9XTjsKKwl3YXJuX25vX2NhbGxiYWNrX3BhdGgoY2xwLCByZWFzb24pOworfQorCiBzdGF0aWMgdm9pZCBuZnNkNF9jYl9wcm9iZV9kb25lKHN0cnVjdCBycGNfdGFzayAqdGFzaywgdm9pZCAqY2FsbGRhdGEpCiB7CiAJc3RydWN0IG5mczRfY2xpZW50ICpjbHAgPSBjb250YWluZXJfb2YoY2FsbGRhdGEsIHN0cnVjdCBuZnM0X2NsaWVudCwgY2xfY2JfbnVsbCk7CiAKIAlpZiAodGFzay0+dGtfc3RhdHVzKQotCQl3YXJuX25vX2NhbGxiYWNrX3BhdGgoY2xwLCB0YXNrLT50a19zdGF0dXMpOworCQluZnNkNF9tYXJrX2NiX2Rvd24oY2xwLCB0YXNrLT50a19zdGF0dXMpOwogCWVsc2UKLQkJYXRvbWljX3NldCgmY2xwLT5jbF9jYl9zZXQsIDEpOworCQljbHAtPmNsX2NiX3N0YXRlID0gTkZTRDRfQ0JfVVA7CiB9CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgcnBjX2NhbGxfb3BzIG5mc2Q0X2NiX3Byb2JlX29wcyA9IHsKQEAgLTcwOSw2ICs3MTgsMTEgQEAKIAogc3RhdGljIHN0cnVjdCB3b3JrcXVldWVfc3RydWN0ICpjYWxsYmFja193cTsKIAorc3RhdGljIHZvaWQgcnVuX25mc2Q0X2NiKHN0cnVjdCBuZnNkNF9jYWxsYmFjayAqY2IpCit7CisJcXVldWVfd29yayhjYWxsYmFja193cSwgJmNiLT5jYl93b3JrKTsKK30KKwogc3RhdGljIHZvaWQgZG9fcHJvYmVfY2FsbGJhY2soc3RydWN0IG5mczRfY2xpZW50ICpjbHApCiB7CiAJc3RydWN0IG5mc2Q0X2NhbGxiYWNrICpjYiA9ICZjbHAtPmNsX2NiX251bGw7CkBAIC03MjMsNyArNzM3LDcgQEAKIAogCWNiLT5jYl9vcHMgPSAmbmZzZDRfY2JfcHJvYmVfb3BzOwogCi0JcXVldWVfd29yayhjYWxsYmFja193cSwgJmNiLT5jYl93b3JrKTsKKwlydW5fbmZzZDRfY2IoY2IpOwogfQogCiAvKgpAQCAtNzMyLDE0ICs3NDYsMjEgQEAKICAqLwogdm9pZCBuZnNkNF9wcm9iZV9jYWxsYmFjayhzdHJ1Y3QgbmZzNF9jbGllbnQgKmNscCkKIHsKKwkvKiBYWFg6IGF0b21pY2l0eT8gIEFsc28sIHNob3VsZCB3ZSBiZSB1c2luZyBjbF9jYl9mbGFncz8gKi8KKwljbHAtPmNsX2NiX3N0YXRlID0gTkZTRDRfQ0JfVU5LTk9XTjsKIAlzZXRfYml0KE5GU0Q0X0NMSUVOVF9DQl9VUERBVEUsICZjbHAtPmNsX2NiX2ZsYWdzKTsKIAlkb19wcm9iZV9jYWxsYmFjayhjbHApOwogfQogCit2b2lkIG5mc2Q0X3Byb2JlX2NhbGxiYWNrX3N5bmMoc3RydWN0IG5mczRfY2xpZW50ICpjbHApCit7CisJbmZzZDRfcHJvYmVfY2FsbGJhY2soY2xwKTsKKwlmbHVzaF93b3JrcXVldWUoY2FsbGJhY2tfd3EpOworfQorCiB2b2lkIG5mc2Q0X2NoYW5nZV9jYWxsYmFjayhzdHJ1Y3QgbmZzNF9jbGllbnQgKmNscCwgc3RydWN0IG5mczRfY2JfY29ubiAqY29ubikKIHsKLQlCVUdfT04oYXRvbWljX3JlYWQoJmNscC0+Y2xfY2Jfc2V0KSk7Ci0KKwljbHAtPmNsX2NiX3N0YXRlID0gTkZTRDRfQ0JfVU5LTk9XTjsKIAlzcGluX2xvY2soJmNscC0+Y2xfbG9jayk7CiAJbWVtY3B5KCZjbHAtPmNsX2NiX2Nvbm4sIGNvbm4sIHNpemVvZihzdHJ1Y3QgbmZzNF9jYl9jb25uKSk7CiAJc3Bpbl91bmxvY2soJmNscC0+Y2xfbG9jayk7CkBAIC03NTAsMjQgKzc3MSwxNCBAQAogICogSWYgdGhlIHNsb3QgaXMgYXZhaWxhYmxlLCB0aGVuIG1hcmsgaXQgYnVzeS4gIE90aGVyd2lzZSwgc2V0IHRoZQogICogdGhyZWFkIGZvciBzbGVlcGluZyBvbiB0aGUgY2FsbGJhY2sgUlBDIHdhaXQgcXVldWUuCiAgKi8KLXN0YXRpYyBpbnQgbmZzZDQxX2NiX3NldHVwX3NlcXVlbmNlKHN0cnVjdCBuZnM0X2NsaWVudCAqY2xwLAotCQlzdHJ1Y3QgcnBjX3Rhc2sgKnRhc2spCitzdGF0aWMgYm9vbCBuZnNkNDFfY2JfZ2V0X3Nsb3Qoc3RydWN0IG5mczRfY2xpZW50ICpjbHAsIHN0cnVjdCBycGNfdGFzayAqdGFzaykKIHsKLQl1MzIgKnB0ciA9ICh1MzIgKiljbHAtPmNsX2NiX3Nlc3Npb24tPnNlX3Nlc3Npb25pZC5kYXRhOwotCWludCBzdGF0dXMgPSAwOwotCi0JZHByaW50aygiJXM6ICV1OiV1OiV1OiV1XG4iLCBfX2Z1bmNfXywKLQkJcHRyWzBdLCBwdHJbMV0sIHB0clsyXSwgcHRyWzNdKTsKLQogCWlmICh0ZXN0X2FuZF9zZXRfYml0KDAsICZjbHAtPmNsX2NiX3Nsb3RfYnVzeSkgIT0gMCkgewogCQlycGNfc2xlZXBfb24oJmNscC0+Y2xfY2Jfd2FpdHEsIHRhc2ssIE5VTEwpOwogCQlkcHJpbnRrKCIlcyBzbG90IGlzIGJ1c3lcbiIsIF9fZnVuY19fKTsKLQkJc3RhdHVzID0gLUVBR0FJTjsKLQkJZ290byBvdXQ7CisJCXJldHVybiBmYWxzZTsKIAl9Ci1vdXQ6Ci0JZHByaW50aygiJXMgc3RhdHVzPSVkXG4iLCBfX2Z1bmNfXywgc3RhdHVzKTsKLQlyZXR1cm4gc3RhdHVzOworCXJldHVybiB0cnVlOwogfQogCiAvKgpAQCAtNzgwLDIwICs3OTEsMTkgQEAKIAlzdHJ1Y3QgbmZzNF9kZWxlZ2F0aW9uICpkcCA9IGNvbnRhaW5lcl9vZihjYiwgc3RydWN0IG5mczRfZGVsZWdhdGlvbiwgZGxfcmVjYWxsKTsKIAlzdHJ1Y3QgbmZzNF9jbGllbnQgKmNscCA9IGRwLT5kbF9jbGllbnQ7CiAJdTMyIG1pbm9ydmVyc2lvbiA9IGNscC0+Y2xfbWlub3J2ZXJzaW9uOwotCWludCBzdGF0dXMgPSAwOwogCiAJY2ItPmNiX21pbm9ydmVyc2lvbiA9IG1pbm9ydmVyc2lvbjsKIAlpZiAobWlub3J2ZXJzaW9uKSB7Ci0JCXN0YXR1cyA9IG5mc2Q0MV9jYl9zZXR1cF9zZXF1ZW5jZShjbHAsIHRhc2spOwotCQlpZiAoc3RhdHVzKSB7Ci0JCQlpZiAoc3RhdHVzICE9IC1FQUdBSU4pIHsKLQkJCQkvKiB0ZXJtaW5hdGUgcnBjIHRhc2sgKi8KLQkJCQl0YXNrLT50a19zdGF0dXMgPSBzdGF0dXM7Ci0JCQkJdGFzay0+dGtfYWN0aW9uID0gTlVMTDsKLQkJCX0KKwkJaWYgKCFuZnNkNDFfY2JfZ2V0X3Nsb3QoY2xwLCB0YXNrKSkKIAkJCXJldHVybjsKLQkJfQogCX0KKwlzcGluX2xvY2soJmNscC0+Y2xfbG9jayk7CisJaWYgKGxpc3RfZW1wdHkoJmNiLT5jYl9wZXJfY2xpZW50KSkgeworCQkvKiBUaGlzIGlzIHRoZSBmaXJzdCBjYWxsLCBub3QgYSByZXN0YXJ0ICovCisJCWNiLT5jYl9kb25lID0gZmFsc2U7CisJCWxpc3RfYWRkKCZjYi0+Y2JfcGVyX2NsaWVudCwgJmNscC0+Y2xfY2FsbGJhY2tzKTsKKwl9CisJc3Bpbl91bmxvY2soJmNscC0+Y2xfbG9jayk7CiAJcnBjX2NhbGxfc3RhcnQodGFzayk7CiB9CiAKQEAgLTgyOSwxNSArODM5LDE4IEBACiAKIAluZnNkNF9jYl9kb25lKHRhc2ssIGNhbGxkYXRhKTsKIAotCWlmIChjdXJyZW50X3JwY19jbGllbnQgPT0gTlVMTCkgewotCQkvKiBXZSdyZSBzaHV0dGluZyBkb3duOyBnaXZlIHVwLiAqLwotCQkvKiBYWFg6IGVyciwgb3IgaXMgaXQgb2sganVzdCB0byBmYWxsIHRocm91Z2gKLQkJICogYW5kIHJwY19yZXN0YXJ0X2NhbGw/ICovCisJaWYgKGN1cnJlbnRfcnBjX2NsaWVudCAhPSB0YXNrLT50a19jbGllbnQpIHsKKwkJLyogV2UncmUgc2h1dHRpbmcgZG93biBvciBjaGFuZ2luZyBjbF9jYl9jbGllbnQ7IGxlYXZlCisJCSAqIGl0IHRvIG5mc2Q0X3Byb2Nlc3NfY2JfdXBkYXRlIHRvIHJlc3RhcnQgdGhlIGNhbGwgaWYKKwkJICogbmVjZXNzYXJ5LiAqLwogCQlyZXR1cm47CiAJfQogCisJaWYgKGNiLT5jYl9kb25lKQorCQlyZXR1cm47CiAJc3dpdGNoICh0YXNrLT50a19zdGF0dXMpIHsKIAljYXNlIDA6CisJCWNiLT5jYl9kb25lID0gdHJ1ZTsKIAkJcmV0dXJuOwogCWNhc2UgLUVCQURIQU5ETEU6CiAJY2FzZSAtTkZTNEVSUl9CQURfU1RBVEVJRDoKQEAgLTg0NiwzMiArODU5LDMwIEBACiAJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCS8qIE5ldHdvcmsgcGFydGl0aW9uPyAqLwotCQlhdG9taWNfc2V0KCZjbHAtPmNsX2NiX3NldCwgMCk7Ci0JCXdhcm5fbm9fY2FsbGJhY2tfcGF0aChjbHAsIHRhc2stPnRrX3N0YXR1cyk7Ci0JCWlmIChjdXJyZW50X3JwY19jbGllbnQgIT0gdGFzay0+dGtfY2xpZW50KSB7Ci0JCQkvKiBxdWV1ZSBhIGNhbGxiYWNrIG9uIHRoZSBuZXcgY29ubmVjdGlvbjogKi8KLQkJCWF0b21pY19pbmMoJmRwLT5kbF9jb3VudCk7Ci0JCQluZnNkNF9jYl9yZWNhbGwoZHApOwotCQkJcmV0dXJuOwotCQl9CisJCW5mc2Q0X21hcmtfY2JfZG93bihjbHAsIHRhc2stPnRrX3N0YXR1cyk7CiAJfQogCWlmIChkcC0+ZGxfcmV0cmllcy0tKSB7CiAJCXJwY19kZWxheSh0YXNrLCAyKkhaKTsKIAkJdGFzay0+dGtfc3RhdHVzID0gMDsKIAkJcnBjX3Jlc3RhcnRfY2FsbF9wcmVwYXJlKHRhc2spOwogCQlyZXR1cm47Ci0JfSBlbHNlIHsKLQkJYXRvbWljX3NldCgmY2xwLT5jbF9jYl9zZXQsIDApOwotCQl3YXJuX25vX2NhbGxiYWNrX3BhdGgoY2xwLCB0YXNrLT50a19zdGF0dXMpOwogCX0KKwluZnNkNF9tYXJrX2NiX2Rvd24oY2xwLCB0YXNrLT50a19zdGF0dXMpOworCWNiLT5jYl9kb25lID0gdHJ1ZTsKIH0KIAogc3RhdGljIHZvaWQgbmZzZDRfY2JfcmVjYWxsX3JlbGVhc2Uodm9pZCAqY2FsbGRhdGEpCiB7CiAJc3RydWN0IG5mc2Q0X2NhbGxiYWNrICpjYiA9IGNhbGxkYXRhOworCXN0cnVjdCBuZnM0X2NsaWVudCAqY2xwID0gY2ItPmNiX2NscDsKIAlzdHJ1Y3QgbmZzNF9kZWxlZ2F0aW9uICpkcCA9IGNvbnRhaW5lcl9vZihjYiwgc3RydWN0IG5mczRfZGVsZWdhdGlvbiwgZGxfcmVjYWxsKTsKIAotCW5mczRfcHV0X2RlbGVnYXRpb24oZHApOworCWlmIChjYi0+Y2JfZG9uZSkgeworCQlzcGluX2xvY2soJmNscC0+Y2xfbG9jayk7CisJCWxpc3RfZGVsKCZjYi0+Y2JfcGVyX2NsaWVudCk7CisJCXNwaW5fdW5sb2NrKCZjbHAtPmNsX2xvY2spOworCQluZnM0X3B1dF9kZWxlZ2F0aW9uKGRwKTsKKwl9CiB9CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgcnBjX2NhbGxfb3BzIG5mc2Q0X2NiX3JlY2FsbF9vcHMgPSB7CkBAIC05MDYsMTYgKzkxNywzMyBAQAogCWZsdXNoX3dvcmtxdWV1ZShjYWxsYmFja193cSk7CiB9CiAKLXZvaWQgbmZzZDRfcmVsZWFzZV9jYihzdHJ1Y3QgbmZzZDRfY2FsbGJhY2sgKmNiKQorc3RhdGljIHZvaWQgbmZzZDRfcmVsZWFzZV9jYihzdHJ1Y3QgbmZzZDRfY2FsbGJhY2sgKmNiKQogewogCWlmIChjYi0+Y2Jfb3BzLT5ycGNfcmVsZWFzZSkKIAkJY2ItPmNiX29wcy0+cnBjX3JlbGVhc2UoY2IpOwogfQogCi12b2lkIG5mc2Q0X3Byb2Nlc3NfY2JfdXBkYXRlKHN0cnVjdCBuZnNkNF9jYWxsYmFjayAqY2IpCisvKiByZXF1aXJlcyBjbF9sb2NrOiAqLworc3RhdGljIHN0cnVjdCBuZnNkNF9jb25uICogX19uZnNkNF9maW5kX2JhY2tjaGFubmVsKHN0cnVjdCBuZnM0X2NsaWVudCAqY2xwKQoreworCXN0cnVjdCBuZnNkNF9zZXNzaW9uICpzOworCXN0cnVjdCBuZnNkNF9jb25uICpjOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShzLCAmY2xwLT5jbF9zZXNzaW9ucywgc2VfcGVyY2xudCkgeworCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGMsICZzLT5zZV9jb25ucywgY25fcGVyc2Vzc2lvbikgeworCQkJaWYgKGMtPmNuX2ZsYWdzICYgTkZTNF9DREZDNF9CQUNLKQorCQkJCXJldHVybiBjOworCQl9CisJfQorCXJldHVybiBOVUxMOworfQorCitzdGF0aWMgdm9pZCBuZnNkNF9wcm9jZXNzX2NiX3VwZGF0ZShzdHJ1Y3QgbmZzZDRfY2FsbGJhY2sgKmNiKQogewogCXN0cnVjdCBuZnM0X2NiX2Nvbm4gY29ubjsKIAlzdHJ1Y3QgbmZzNF9jbGllbnQgKmNscCA9IGNiLT5jYl9jbHA7CisJc3RydWN0IG5mc2Q0X3Nlc3Npb24gKnNlcyA9IE5VTEw7CisJc3RydWN0IG5mc2Q0X2Nvbm4gKmM7CiAJaW50IGVycjsKIAogCS8qCkBAIC05MjYsNiArOTU0LDEwIEBACiAJCXJwY19zaHV0ZG93bl9jbGllbnQoY2xwLT5jbF9jYl9jbGllbnQpOwogCQljbHAtPmNsX2NiX2NsaWVudCA9IE5VTEw7CiAJfQorCWlmIChjbHAtPmNsX2NiX2Nvbm4uY2JfeHBydCkgeworCQlzdmNfeHBydF9wdXQoY2xwLT5jbF9jYl9jb25uLmNiX3hwcnQpOworCQljbHAtPmNsX2NiX2Nvbm4uY2JfeHBydCA9IE5VTEw7CisJfQogCWlmICh0ZXN0X2JpdChORlNENF9DTElFTlRfS0lMTCwgJmNscC0+Y2xfY2JfZmxhZ3MpKQogCQlyZXR1cm47CiAJc3Bpbl9sb2NrKCZjbHAtPmNsX2xvY2spOwpAQCAtOTM2LDExICs5NjgsMjIgQEAKIAlCVUdfT04oIWNscC0+Y2xfY2JfZmxhZ3MpOwogCWNsZWFyX2JpdChORlNENF9DTElFTlRfQ0JfVVBEQVRFLCAmY2xwLT5jbF9jYl9mbGFncyk7CiAJbWVtY3B5KCZjb25uLCAmY2ItPmNiX2NscC0+Y2xfY2JfY29ubiwgc2l6ZW9mKHN0cnVjdCBuZnM0X2NiX2Nvbm4pKTsKKwljID0gX19uZnNkNF9maW5kX2JhY2tjaGFubmVsKGNscCk7CisJaWYgKGMpIHsKKwkJc3ZjX3hwcnRfZ2V0KGMtPmNuX3hwcnQpOworCQljb25uLmNiX3hwcnQgPSBjLT5jbl94cHJ0OworCQlzZXMgPSBjLT5jbl9zZXNzaW9uOworCX0KIAlzcGluX3VubG9jaygmY2xwLT5jbF9sb2NrKTsKIAotCWVyciA9IHNldHVwX2NhbGxiYWNrX2NsaWVudChjbHAsICZjb25uKTsKLQlpZiAoZXJyKQorCWVyciA9IHNldHVwX2NhbGxiYWNrX2NsaWVudChjbHAsICZjb25uLCBzZXMpOworCWlmIChlcnIpIHsKIAkJd2Fybl9ub19jYWxsYmFja19wYXRoKGNscCwgZXJyKTsKKwkJcmV0dXJuOworCX0KKwkvKiBZYXksIHRoZSBjYWxsYmFjayBjaGFubmVsJ3MgYmFjayEgUmVzdGFydCBhbnkgY2FsbGJhY2tzOiAqLworCWxpc3RfZm9yX2VhY2hfZW50cnkoY2IsICZjbHAtPmNsX2NhbGxiYWNrcywgY2JfcGVyX2NsaWVudCkKKwkJcnVuX25mc2Q0X2NiKGNiKTsKIH0KIAogdm9pZCBuZnNkNF9kb19jYWxsYmFja19ycGMoc3RydWN0IHdvcmtfc3RydWN0ICp3KQpAQCAtOTY1LDEwICsxMDA4LDExIEBACiB2b2lkIG5mc2Q0X2NiX3JlY2FsbChzdHJ1Y3QgbmZzNF9kZWxlZ2F0aW9uICpkcCkKIHsKIAlzdHJ1Y3QgbmZzZDRfY2FsbGJhY2sgKmNiID0gJmRwLT5kbF9yZWNhbGw7CisJc3RydWN0IG5mczRfY2xpZW50ICpjbHAgPSBkcC0+ZGxfY2xpZW50OwogCiAJZHAtPmRsX3JldHJpZXMgPSAxOwogCWNiLT5jYl9vcCA9IGRwOwotCWNiLT5jYl9jbHAgPSBkcC0+ZGxfY2xpZW50OworCWNiLT5jYl9jbHAgPSBjbHA7CiAJY2ItPmNiX21zZy5ycGNfcHJvYyA9ICZuZnM0X2NiX3Byb2NlZHVyZXNbTkZTUFJPQzRfQ0xOVF9DQl9SRUNBTExdOwogCWNiLT5jYl9tc2cucnBjX2FyZ3AgPSBjYjsKIAljYi0+Y2JfbXNnLnJwY19yZXNwID0gY2I7CkBAIC05NzcsNSArMTAyMSw4IEBACiAJY2ItPmNiX29wcyA9ICZuZnNkNF9jYl9yZWNhbGxfb3BzOwogCWRwLT5kbF9yZXRyaWVzID0gMTsKIAotCXF1ZXVlX3dvcmsoY2FsbGJhY2tfd3EsICZkcC0+ZGxfcmVjYWxsLmNiX3dvcmspOworCUlOSVRfTElTVF9IRUFEKCZjYi0+Y2JfcGVyX2NsaWVudCk7CisJY2ItPmNiX2RvbmUgPSB0cnVlOworCisJcnVuX25mc2Q0X2NiKCZkcC0+ZGxfcmVjYWxsKTsKIH0KZGlmZiAtLWdpdCBhL2ZzL25mc2QvbmZzNGlkbWFwLmMgYi9mcy9uZnNkL25mczRpZG1hcC5jCmluZGV4IGYwNjk1ZTguLjZkMmMzOTcgMTAwNjQ0Ci0tLSBhL2ZzL25mc2QvbmZzNGlkbWFwLmMKKysrIGIvZnMvbmZzZC9uZnM0aWRtYXAuYwpAQCAtMzMsMTAgKzMzLDExIEBACiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgotI2luY2x1ZGUgPGxpbnV4L25mc2RfaWRtYXAuaD4KICNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgogI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgImlkbWFwLmgiCisjaW5jbHVkZSAibmZzZC5oIgogCiAvKgogICogQ2FjaGUgZW50cnkKQEAgLTUxNCw3ICs1MTUsNyBAQAogCXJldHVybiBjbHAtPm5hbWU7CiB9CiAKLXN0YXRpYyBpbnQKK3N0YXRpYyBfX2JlMzIKIGlkbWFwX25hbWVfdG9faWQoc3RydWN0IHN2Y19ycXN0ICpycXN0cCwgaW50IHR5cGUsIGNvbnN0IGNoYXIgKm5hbWUsIHUzMiBuYW1lbGVuLAogCQl1aWRfdCAqaWQpCiB7CkBAIC01MjQsMTUgKzUyNSwxNSBAQAogCWludCByZXQ7CiAKIAlpZiAobmFtZWxlbiArIDEgPiBzaXplb2Yoa2V5Lm5hbWUpKQotCQlyZXR1cm4gLUVJTlZBTDsKKwkJcmV0dXJuIG5mc2Vycl9iYWRvd25lcjsKIAltZW1jcHkoa2V5Lm5hbWUsIG5hbWUsIG5hbWVsZW4pOwogCWtleS5uYW1lW25hbWVsZW5dID0gJ1wwJzsKIAlzdHJsY3B5KGtleS5hdXRobmFtZSwgcnFzdF9hdXRobmFtZShycXN0cCksIHNpemVvZihrZXkuYXV0aG5hbWUpKTsKIAlyZXQgPSBpZG1hcF9sb29rdXAocnFzdHAsIG5hbWV0b2lkX2xvb2t1cCwgJmtleSwgJm5hbWV0b2lkX2NhY2hlLCAmaXRlbSk7CiAJaWYgKHJldCA9PSAtRU5PRU5UKQotCQlyZXQgPSAtRVNSQ0g7IC8qIG5mc2Vycl9iYWRuYW1lICovCisJCXJldHVybiBuZnNlcnJfYmFkb3duZXI7CiAJaWYgKHJldCkKLQkJcmV0dXJuIHJldDsKKwkJcmV0dXJuIG5mc2Vycm5vKHJldCk7CiAJKmlkID0gaXRlbS0+aWQ7CiAJY2FjaGVfcHV0KCZpdGVtLT5oLCAmbmFtZXRvaWRfY2FjaGUpOwogCXJldHVybiAwOwpAQCAtNTYwLDE0ICs1NjEsMTQgQEAKIAlyZXR1cm4gcmV0OwogfQogCi1pbnQKK19fYmUzMgogbmZzZF9tYXBfbmFtZV90b191aWQoc3RydWN0IHN2Y19ycXN0ICpycXN0cCwgY29uc3QgY2hhciAqbmFtZSwgc2l6ZV90IG5hbWVsZW4sCiAJCV9fdTMyICppZCkKIHsKIAlyZXR1cm4gaWRtYXBfbmFtZV90b19pZChycXN0cCwgSURNQVBfVFlQRV9VU0VSLCBuYW1lLCBuYW1lbGVuLCBpZCk7CiB9CiAKLWludAorX19iZTMyCiBuZnNkX21hcF9uYW1lX3RvX2dpZChzdHJ1Y3Qgc3ZjX3Jxc3QgKnJxc3RwLCBjb25zdCBjaGFyICpuYW1lLCBzaXplX3QgbmFtZWxlbiwKIAkJX191MzIgKmlkKQogewpkaWZmIC0tZ2l0IGEvZnMvbmZzZC9uZnM0cHJvYy5jIGIvZnMvbmZzZC9uZnM0cHJvYy5jCmluZGV4IDBjZGZkMDIuLmRiNTI1NDYgMTAwNjQ0Ci0tLSBhL2ZzL25mc2QvbmZzNHByb2MuYworKysgYi9mcy9uZnNkL25mczRwcm9jLmMKQEAgLTYwNCw5ICs2MDQsNyBAQAogCXJldHVybiBzdGF0dXM7CiB9CiAKLXN0YXRpYyBfX2JlMzIKLW5mc2Q0X2xvb2t1cHAoc3RydWN0IHN2Y19ycXN0ICpycXN0cCwgc3RydWN0IG5mc2Q0X2NvbXBvdW5kX3N0YXRlICpjc3RhdGUsCi0JICAgICAgdm9pZCAqYXJnKQorc3RhdGljIF9fYmUzMiBuZnNkNF9kb19sb29rdXBwKHN0cnVjdCBzdmNfcnFzdCAqcnFzdHAsIHN0cnVjdCBzdmNfZmggKmZoKQogewogCXN0cnVjdCBzdmNfZmggdG1wX2ZoOwogCV9fYmUzMiByZXQ7CkBAIC02MTUsMTMgKzYxMywxOSBAQAogCXJldCA9IGV4cF9wc2V1ZG9yb290KHJxc3RwLCAmdG1wX2ZoKTsKIAlpZiAocmV0KQogCQlyZXR1cm4gcmV0OwotCWlmICh0bXBfZmguZmhfZGVudHJ5ID09IGNzdGF0ZS0+Y3VycmVudF9maC5maF9kZW50cnkpIHsKKwlpZiAodG1wX2ZoLmZoX2RlbnRyeSA9PSBmaC0+ZmhfZGVudHJ5KSB7CiAJCWZoX3B1dCgmdG1wX2ZoKTsKIAkJcmV0dXJuIG5mc2Vycl9ub2VudDsKIAl9CiAJZmhfcHV0KCZ0bXBfZmgpOwotCXJldHVybiBuZnNkX2xvb2t1cChycXN0cCwgJmNzdGF0ZS0+Y3VycmVudF9maCwKLQkJCSAgICIuLiIsIDIsICZjc3RhdGUtPmN1cnJlbnRfZmgpOworCXJldHVybiBuZnNkX2xvb2t1cChycXN0cCwgZmgsICIuLiIsIDIsIGZoKTsKK30KKworc3RhdGljIF9fYmUzMgorbmZzZDRfbG9va3VwcChzdHJ1Y3Qgc3ZjX3Jxc3QgKnJxc3RwLCBzdHJ1Y3QgbmZzZDRfY29tcG91bmRfc3RhdGUgKmNzdGF0ZSwKKwkgICAgICB2b2lkICphcmcpCit7CisJcmV0dXJuIG5mc2Q0X2RvX2xvb2t1cHAocnFzdHAsICZjc3RhdGUtPmN1cnJlbnRfZmgpOwogfQogCiBzdGF0aWMgX19iZTMyCkBAIC03NjksMTAgKzc3MywzNiBAQAogCX0gZWxzZQogCQlzZWNpbmZvLT5zaV9leHAgPSBleHA7CiAJZHB1dChkZW50cnkpOworCWlmIChjc3RhdGUtPm1pbm9ydmVyc2lvbikKKwkJLyogU2VlIHJmYyA1NjYxIHNlY3Rpb24gMi42LjMuMS4xLjggKi8KKwkJZmhfcHV0KCZjc3RhdGUtPmN1cnJlbnRfZmgpOwogCXJldHVybiBlcnI7CiB9CiAKIHN0YXRpYyBfX2JlMzIKK25mc2Q0X3NlY2luZm9fbm9fbmFtZShzdHJ1Y3Qgc3ZjX3Jxc3QgKnJxc3RwLCBzdHJ1Y3QgbmZzZDRfY29tcG91bmRfc3RhdGUgKmNzdGF0ZSwKKwkgICAgICBzdHJ1Y3QgbmZzZDRfc2VjaW5mb19ub19uYW1lICpzaW4pCit7CisJX19iZTMyIGVycjsKKworCXN3aXRjaCAoc2luLT5zaW5fc3R5bGUpIHsKKwljYXNlIE5GUzRfU0VDSU5GT19TVFlMRTRfQ1VSUkVOVF9GSDoKKwkJYnJlYWs7CisJY2FzZSBORlM0X1NFQ0lORk9fU1RZTEU0X1BBUkVOVDoKKwkJZXJyID0gbmZzZDRfZG9fbG9va3VwcChycXN0cCwgJmNzdGF0ZS0+Y3VycmVudF9maCk7CisJCWlmIChlcnIpCisJCQlyZXR1cm4gZXJyOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlyZXR1cm4gbmZzZXJyX2ludmFsOworCX0KKwlleHBfZ2V0KGNzdGF0ZS0+Y3VycmVudF9maC5maF9leHBvcnQpOworCXNpbi0+c2luX2V4cCA9IGNzdGF0ZS0+Y3VycmVudF9maC5maF9leHBvcnQ7CisJZmhfcHV0KCZjc3RhdGUtPmN1cnJlbnRfZmgpOworCXJldHVybiBuZnNfb2s7Cit9CisKK3N0YXRpYyBfX2JlMzIKIG5mc2Q0X3NldGF0dHIoc3RydWN0IHN2Y19ycXN0ICpycXN0cCwgc3RydWN0IG5mc2Q0X2NvbXBvdW5kX3N0YXRlICpjc3RhdGUsCiAJICAgICAgc3RydWN0IG5mc2Q0X3NldGF0dHIgKnNldGF0dHIpCiB7CkBAIC05NzQsOCArMTAwNCw4IEBACiAgKiBBbHNvIG5vdGUsIGVuZm9yY2VkIGVsc2V3aGVyZToKICAqCS0gU0VRVUVOQ0Ugb3RoZXIgdGhhbiBhcyBmaXJzdCBvcCByZXN1bHRzIGluCiAgKgkgIE5GUzRFUlJfU0VRVUVOQ0VfUE9TLiAoRW5mb3JjZWQgaW4gbmZzZDRfc2VxdWVuY2UoKS4pCi0gKgktIEJJTkRfQ09OTl9UT19TRVNTSU9OIG11c3QgYmUgdGhlIG9ubHkgb3AgaW4gaXRzIGNvbXBvdW5kCi0gKgkgIChXaWxsIGJlIGVuZm9yY2VkIGluIG5mc2Q0X2JpbmRfY29ubl90b19zZXNzaW9uKCkuKQorICoJLSBCSU5EX0NPTk5fVE9fU0VTU0lPTiBtdXN0IGJlIHRoZSBvbmx5IG9wIGluIGl0cyBjb21wb3VuZC4KKyAqCSAgKEVuZm9yY2VkIGluIG5mc2Q0X2JpbmRfY29ubl90b19zZXNzaW9uKCkuKQogICoJLSBERVNUUk9ZX1NFU1NJT04gbXVzdCBiZSB0aGUgZmluYWwgb3BlcmF0aW9uIGluIGEgY29tcG91bmQsIGlmCiAgKgkgIHNlc3Npb25pZCdzIGluIFNFUVVFTkNFIGFuZCBERVNUUk9ZX1NFU1NJT04gYXJlIHRoZSBzYW1lLgogICoJICAoRW5mb3JjZWQgaW4gbmZzZDRfZGVzdHJveV9zZXNzaW9uKCkuKQpAQCAtMTEyNiwxMCArMTE1Niw2IEBACiAKIAkJbmZzZDRfaW5jcmVtZW50X29wX3N0YXRzKG9wLT5vcG51bSk7CiAJfQotCWlmICghcnFzdHAtPnJxX3VzZWRlZmVycmFsICYmIHN0YXR1cyA9PSBuZnNlcnJfZHJvcGl0KSB7Ci0JCWRwcmludGsoIiVzIERyb3BpdCAtIHNlbmQgTkZTNEVSUl9ERUxBWVxuIiwgX19mdW5jX18pOwotCQlzdGF0dXMgPSBuZnNlcnJfanVrZWJveDsKLQl9CiAKIAlyZXNwLT5jc3RhdGUuc3RhdHVzID0gc3RhdHVzOwogCWZoX3B1dCgmcmVzcC0+Y3N0YXRlLmN1cnJlbnRfZmgpOwpAQCAtMTMwMCw2ICsxMzI2LDExIEBACiAJCS5vcF9mbGFncyA9IEFMTE9XRURfV0lUSE9VVF9GSCB8IEFMTE9XRURfQVNfRklSU1RfT1AsCiAJCS5vcF9uYW1lID0gIk9QX0VYQ0hBTkdFX0lEIiwKIAl9LAorCVtPUF9CSU5EX0NPTk5fVE9fU0VTU0lPTl0gPSB7CisJCS5vcF9mdW5jID0gKG5mc2Q0b3BfZnVuYyluZnNkNF9iaW5kX2Nvbm5fdG9fc2Vzc2lvbiwKKwkJLm9wX2ZsYWdzID0gQUxMT1dFRF9XSVRIT1VUX0ZIIHwgQUxMT1dFRF9BU19GSVJTVF9PUCwKKwkJLm9wX25hbWUgPSAiT1BfQklORF9DT05OX1RPX1NFU1NJT04iLAorCX0sCiAJW09QX0NSRUFURV9TRVNTSU9OXSA9IHsKIAkJLm9wX2Z1bmMgPSAobmZzZDRvcF9mdW5jKW5mc2Q0X2NyZWF0ZV9zZXNzaW9uLAogCQkub3BfZmxhZ3MgPSBBTExPV0VEX1dJVEhPVVRfRkggfCBBTExPV0VEX0FTX0ZJUlNUX09QLApAQCAtMTMyMCw2ICsxMzUxLDEwIEBACiAJCS5vcF9mbGFncyA9IEFMTE9XRURfV0lUSE9VVF9GSCwKIAkJLm9wX25hbWUgPSAiT1BfUkVDTEFJTV9DT01QTEVURSIsCiAJfSwKKwlbT1BfU0VDSU5GT19OT19OQU1FXSA9IHsKKwkJLm9wX2Z1bmMgPSAobmZzZDRvcF9mdW5jKW5mc2Q0X3NlY2luZm9fbm9fbmFtZSwKKwkJLm9wX25hbWUgPSAiT1BfU0VDSU5GT19OT19OQU1FIiwKKwl9LAogfTsKIAogc3RhdGljIGNvbnN0IGNoYXIgKm5mc2Q0X29wX25hbWUodW5zaWduZWQgb3BudW0pCmRpZmYgLS1naXQgYS9mcy9uZnNkL25mczRyZWNvdmVyLmMgYi9mcy9uZnNkL25mczRyZWNvdmVyLmMKaW5kZXggN2UyNmNhYS4uZmZiNTllZiAxMDA2NDQKLS0tIGEvZnMvbmZzZC9uZnM0cmVjb3Zlci5jCisrKyBiL2ZzL25mc2QvbmZzNHJlY292ZXIuYwpAQCAtMzAyLDcgKzMwMiw2IEBACiB7CiAJaW50IHN0YXR1czsKIAotCS8qIG5vdGU6IHdlIGN1cnJlbnRseSB1c2UgdGhpcyBwYXRoIG9ubHkgZm9yIG1pbm9ydmVyc2lvbiAwICovCiAJaWYgKG5mczRfaGFzX3JlY2xhaW1lZF9zdGF0ZShjaGlsZC0+ZF9uYW1lLm5hbWUsIGZhbHNlKSkKIAkJcmV0dXJuIDA7CiAKZGlmZiAtLWdpdCBhL2ZzL25mc2QvbmZzNHN0YXRlLmMgYi9mcy9uZnNkL25mczRzdGF0ZS5jCmluZGV4IGZiZDE4YzMuLmQ5OGQwMjEgMTAwNjQ0Ci0tLSBhL2ZzL25mc2QvbmZzNHN0YXRlLmMKKysrIGIvZnMvbmZzZC9uZnM0c3RhdGUuYwpAQCAtMjMwLDcgKzIzMCw4IEBACiAJZHAtPmRsX2NsaWVudCA9IGNscDsKIAlnZXRfbmZzNF9maWxlKGZwKTsKIAlkcC0+ZGxfZmlsZSA9IGZwOwotCW5mczRfZmlsZV9nZXRfYWNjZXNzKGZwLCBPX1JET05MWSk7CisJZHAtPmRsX3Zmc19maWxlID0gZmluZF9yZWFkYWJsZV9maWxlKGZwKTsKKwlnZXRfZmlsZShkcC0+ZGxfdmZzX2ZpbGUpOwogCWRwLT5kbF9mbG9jayA9IE5VTEw7CiAJZHAtPmRsX3R5cGUgPSB0eXBlOwogCWRwLT5kbF9zdGF0ZWlkLnNpX2Jvb3QgPSBib290X3RpbWU7CkBAIC0yNTIsNiArMjUzLDcgQEAKIAlpZiAoYXRvbWljX2RlY19hbmRfdGVzdCgmZHAtPmRsX2NvdW50KSkgewogCQlkcHJpbnRrKCJORlNEOiBmcmVlaW5nIGRwICVwXG4iLGRwKTsKIAkJcHV0X25mczRfZmlsZShkcC0+ZGxfZmlsZSk7CisJCWZwdXQoZHAtPmRsX3Zmc19maWxlKTsKIAkJa21lbV9jYWNoZV9mcmVlKGRlbGVnX3NsYWIsIGRwKTsKIAkJbnVtX2RlbGVnYXRpb25zLS07CiAJfQpAQCAtMjY1LDEyICsyNjcsMTAgQEAKIHN0YXRpYyB2b2lkCiBuZnM0X2Nsb3NlX2RlbGVnYXRpb24oc3RydWN0IG5mczRfZGVsZWdhdGlvbiAqZHApCiB7Ci0Jc3RydWN0IGZpbGUgKmZpbHAgPSBmaW5kX3JlYWRhYmxlX2ZpbGUoZHAtPmRsX2ZpbGUpOwotCiAJZHByaW50aygiTkZTRDogY2xvc2VfZGVsZWdhdGlvbiBkcCAlcFxuIixkcCk7CisJLyogWFhYOiBkbyB3ZSBldmVuIG5lZWQgdGhpcyBjaGVjaz86ICovCiAJaWYgKGRwLT5kbF9mbG9jaykKLQkJdmZzX3NldGxlYXNlKGZpbHAsIEZfVU5MQ0ssICZkcC0+ZGxfZmxvY2spOwotCW5mczRfZmlsZV9wdXRfYWNjZXNzKGRwLT5kbF9maWxlLCBPX1JET05MWSk7CisJCXZmc19zZXRsZWFzZShkcC0+ZGxfdmZzX2ZpbGUsIEZfVU5MQ0ssICZkcC0+ZGxfZmxvY2spOwogfQogCiAvKiBDYWxsZWQgdW5kZXIgdGhlIHN0YXRlIGxvY2suICovCkBAIC02NDIsNiArNjQyLDcgQEAKIAkJZnJlZV9jb25uKGMpOwogCX0KIAlzcGluX3VubG9jaygmY2xwLT5jbF9sb2NrKTsKKwluZnNkNF9wcm9iZV9jYWxsYmFjayhjbHApOwogfQogCiBzdGF0aWMgc3RydWN0IG5mc2Q0X2Nvbm4gKmFsbG9jX2Nvbm4oc3RydWN0IHN2Y19ycXN0ICpycXN0cCwgdTMyIGZsYWdzKQpAQCAtNjc5LDE1ICs2ODAsMTIgQEAKIAlyZXR1cm4gcmVnaXN0ZXJfeHB0X3VzZXIoY29ubi0+Y25feHBydCwgJmNvbm4tPmNuX3hwdF91c2VyKTsKIH0KIAotc3RhdGljIF9fYmUzMiBuZnNkNF9uZXdfY29ubihzdHJ1Y3Qgc3ZjX3Jxc3QgKnJxc3RwLCBzdHJ1Y3QgbmZzZDRfc2Vzc2lvbiAqc2VzKQorc3RhdGljIF9fYmUzMiBuZnNkNF9uZXdfY29ubihzdHJ1Y3Qgc3ZjX3Jxc3QgKnJxc3RwLCBzdHJ1Y3QgbmZzZDRfc2Vzc2lvbiAqc2VzLCB1MzIgZGlyKQogewogCXN0cnVjdCBuZnNkNF9jb25uICpjb25uOwotCXUzMiBmbGFncyA9IE5GUzRfQ0RGQzRfRk9SRTsKIAlpbnQgcmV0OwogCi0JaWYgKHNlcy0+c2VfZmxhZ3MgJiBTRVNTSU9ONF9CQUNLX0NIQU4pCi0JCWZsYWdzIHw9IE5GUzRfQ0RGQzRfQkFDSzsKLQljb25uID0gYWxsb2NfY29ubihycXN0cCwgZmxhZ3MpOworCWNvbm4gPSBhbGxvY19jb25uKHJxc3RwLCBkaXIpOwogCWlmICghY29ubikKIAkJcmV0dXJuIG5mc2Vycl9qdWtlYm94OwogCW5mc2Q0X2hhc2hfY29ubihjb25uLCBzZXMpOwpAQCAtNjk4LDYgKzY5NiwxNyBAQAogCXJldHVybiBuZnNfb2s7CiB9CiAKK3N0YXRpYyBfX2JlMzIgbmZzZDRfbmV3X2Nvbm5fZnJvbV9jcnNlcyhzdHJ1Y3Qgc3ZjX3Jxc3QgKnJxc3RwLCBzdHJ1Y3QgbmZzZDRfc2Vzc2lvbiAqc2VzKQoreworCXUzMiBkaXIgPSBORlM0X0NERkM0X0ZPUkU7CisKKwlpZiAoc2VzLT5zZV9mbGFncyAmIFNFU1NJT040X0JBQ0tfQ0hBTikKKwkJZGlyIHw9IE5GUzRfQ0RGQzRfQkFDSzsKKworCXJldHVybiBuZnNkNF9uZXdfY29ubihycXN0cCwgc2VzLCBkaXIpOworfQorCisvKiBtdXN0IGJlIGNhbGxlZCB1bmRlciBjbGllbnRfbG9jayAqLwogc3RhdGljIHZvaWQgbmZzZDRfZGVsX2Nvbm5zKHN0cnVjdCBuZnNkNF9zZXNzaW9uICpzKQogewogCXN0cnVjdCBuZnM0X2NsaWVudCAqY2xwID0gcy0+c2VfY2xpZW50OwpAQCAtNzQ5LDYgKzc1OCw4IEBACiAJICovCiAJc2xvdHNpemUgPSBuZnNkNF9zYW5pdGl6ZV9zbG90X3NpemUoZmNoYW4tPm1heHJlc3BfY2FjaGVkKTsKIAludW1zbG90cyA9IG5mc2Q0X2dldF9kcmNfbWVtKHNsb3RzaXplLCBmY2hhbi0+bWF4cmVxcyk7CisJaWYgKG51bXNsb3RzIDwgMSkKKwkJcmV0dXJuIE5VTEw7CiAKIAluZXcgPSBhbGxvY19zZXNzaW9uKHNsb3RzaXplLCBudW1zbG90cyk7CiAJaWYgKCFuZXcpIHsKQEAgLTc2OSwyNSArNzgwLDMwIEBACiAJaWR4ID0gaGFzaF9zZXNzaW9uaWQoJm5ldy0+c2Vfc2Vzc2lvbmlkKTsKIAlzcGluX2xvY2soJmNsaWVudF9sb2NrKTsKIAlsaXN0X2FkZCgmbmV3LT5zZV9oYXNoLCAmc2Vzc2lvbmlkX2hhc2h0YmxbaWR4XSk7CisJc3Bpbl9sb2NrKCZjbHAtPmNsX2xvY2spOwogCWxpc3RfYWRkKCZuZXctPnNlX3BlcmNsbnQsICZjbHAtPmNsX3Nlc3Npb25zKTsKKwlzcGluX3VubG9jaygmY2xwLT5jbF9sb2NrKTsKIAlzcGluX3VubG9jaygmY2xpZW50X2xvY2spOwogCi0Jc3RhdHVzID0gbmZzZDRfbmV3X2Nvbm4ocnFzdHAsIG5ldyk7CisJc3RhdHVzID0gbmZzZDRfbmV3X2Nvbm5fZnJvbV9jcnNlcyhycXN0cCwgbmV3KTsKIAkvKiB3aG9vcHM6IGJlbm55IHBvaW50cyBvdXQsIHN0YXR1cyBpcyBpZ25vcmVkISAoZXJyLCBvciBib2d1cykgKi8KIAlpZiAoc3RhdHVzKSB7CiAJCWZyZWVfc2Vzc2lvbigmbmV3LT5zZV9yZWYpOwogCQlyZXR1cm4gTlVMTDsKIAl9Ci0JaWYgKCFjbHAtPmNsX2NiX3Nlc3Npb24gJiYgKGNzZXMtPmZsYWdzICYgU0VTU0lPTjRfQkFDS19DSEFOKSkgeworCWlmIChjc2VzLT5mbGFncyAmIFNFU1NJT040X0JBQ0tfQ0hBTikgewogCQlzdHJ1Y3Qgc29ja2FkZHIgKnNhID0gc3ZjX2FkZHIocnFzdHApOwotCi0JCWNscC0+Y2xfY2Jfc2Vzc2lvbiA9IG5ldzsKLQkJY2xwLT5jbF9jYl9jb25uLmNiX3hwcnQgPSBycXN0cC0+cnFfeHBydDsKLQkJc3ZjX3hwcnRfZ2V0KHJxc3RwLT5ycV94cHJ0KTsKKwkJLyoKKwkJICogVGhpcyBpcyBhIGxpdHRsZSBzaWxseTsgd2l0aCBzZXNzaW9ucyB0aGVyZSdzIG5vIHJlYWwKKwkJICogdXNlIGZvciB0aGUgY2FsbGJhY2sgYWRkcmVzcy4gIFVzZSB0aGUgcGVlciBhZGRyZXNzCisJCSAqIGFzIGEgcmVhc29uYWJsZSBkZWZhdWx0IGZvciBub3csIGJ1dCBjb25zaWRlciBmaXhpbmcKKwkJICogdGhlIHJwYyBjbGllbnQgbm90IHRvIHJlcXVpcmUgYW4gYWRkcmVzcyBpbiB0aGUKKwkJICogZnV0dXJlOgorCQkgKi8KIAkJcnBjX2NvcHlfYWRkcigoc3RydWN0IHNvY2thZGRyICopJmNscC0+Y2xfY2JfY29ubi5jYl9hZGRyLCBzYSk7CiAJCWNscC0+Y2xfY2JfY29ubi5jYl9hZGRybGVuID0gc3ZjX2FkZHJfbGVuKHNhKTsKLQkJbmZzZDRfcHJvYmVfY2FsbGJhY2soY2xwKTsKIAl9CisJbmZzZDRfcHJvYmVfY2FsbGJhY2soY2xwKTsKIAlyZXR1cm4gbmV3OwogfQogCkBAIC04MTcsNyArODMzLDkgQEAKIHVuaGFzaF9zZXNzaW9uKHN0cnVjdCBuZnNkNF9zZXNzaW9uICpzZXMpCiB7CiAJbGlzdF9kZWwoJnNlcy0+c2VfaGFzaCk7CisJc3Bpbl9sb2NrKCZzZXMtPnNlX2NsaWVudC0+Y2xfbG9jayk7CiAJbGlzdF9kZWwoJnNlcy0+c2VfcGVyY2xudCk7CisJc3Bpbl91bmxvY2soJnNlcy0+c2VfY2xpZW50LT5jbF9sb2NrKTsKIH0KIAogLyogbXVzdCBiZSBjYWxsZWQgdW5kZXIgdGhlIGNsaWVudF9sb2NrICovCkBAIC05MjMsOCArOTQxLDEwIEBACiAKIAltYXJrX2NsaWVudF9leHBpcmVkKGNscCk7CiAJbGlzdF9kZWwoJmNscC0+Y2xfbHJ1KTsKKwlzcGluX2xvY2soJmNscC0+Y2xfbG9jayk7CiAJbGlzdF9mb3JfZWFjaF9lbnRyeShzZXMsICZjbHAtPmNsX3Nlc3Npb25zLCBzZV9wZXJjbG50KQogCQlsaXN0X2RlbF9pbml0KCZzZXMtPnNlX2hhc2gpOworCXNwaW5fdW5sb2NrKCZjbHAtPmNsX2xvY2spOwogfQogCiBzdGF0aWMgdm9pZApAQCAtMTA1MSwxMiArMTA3MSwxMyBAQAogCiAJbWVtY3B5KGNscC0+Y2xfcmVjZGlyLCByZWNkaXIsIEhFWERJUl9MRU4pOwogCWF0b21pY19zZXQoJmNscC0+Y2xfcmVmY291bnQsIDApOwotCWF0b21pY19zZXQoJmNscC0+Y2xfY2Jfc2V0LCAwKTsKKwljbHAtPmNsX2NiX3N0YXRlID0gTkZTRDRfQ0JfVU5LTk9XTjsKIAlJTklUX0xJU1RfSEVBRCgmY2xwLT5jbF9pZGhhc2gpOwogCUlOSVRfTElTVF9IRUFEKCZjbHAtPmNsX3N0cmhhc2gpOwogCUlOSVRfTElTVF9IRUFEKCZjbHAtPmNsX29wZW5vd25lcnMpOwogCUlOSVRfTElTVF9IRUFEKCZjbHAtPmNsX2RlbGVnYXRpb25zKTsKIAlJTklUX0xJU1RfSEVBRCgmY2xwLT5jbF9scnUpOworCUlOSVRfTElTVF9IRUFEKCZjbHAtPmNsX2NhbGxiYWNrcyk7CiAJc3Bpbl9sb2NrX2luaXQoJmNscC0+Y2xfbG9jayk7CiAJSU5JVF9XT1JLKCZjbHAtPmNsX2NiX251bGwuY2Jfd29yaywgbmZzZDRfZG9fY2FsbGJhY2tfcnBjKTsKIAljbHAtPmNsX3RpbWUgPSBnZXRfc2Vjb25kcygpOwpAQCAtMTEzMiw1NCArMTE1Myw1NSBAQAogCXJldHVybiBOVUxMOwogfQogCi0vKgotICogUmV0dXJuIDEgaWZmIGNscCdzIGNsaWVudGlkIGVzdGFibGlzaG1lbnQgbWV0aG9kIG1hdGNoZXMgdGhlIHVzZV9leGNoYW5nZV9pZAotICogcGFyYW1ldGVyLiBNYXRjaGluZyBpcyBiYXNlZCBvbiB0aGUgZmFjdCB0aGUgYXQgbGVhc3Qgb25lIG9mIHRoZQotICogRVhDSEdJRDRfRkxBR19VU0Vfe05PTl9QTkZTLFBORlNfTURTLFBORlNfRFN9IGZsYWdzIG11c3QgYmUgc2V0IGZvciB2NC4xCi0gKgotICogRklYTUU6IHdlIG5lZWQgdG8gdW5pZnkgdGhlIGNsaWVudGlkIG5hbWVzcGFjZXMgZm9yIG5mc3Y0LngKLSAqIGFuZCBjb3JyZWN0bHkgZGVhbCB3aXRoIGNsaWVudCB1cGdyYWRlL2Rvd25ncmFkZSBpbiBFWENIQU5HRV9JRAotICogYW5kIFNFVF9DTElFTlRJRHssX0NPTkZJUk19Ci0gKi8KLXN0YXRpYyBpbmxpbmUgaW50Ci1tYXRjaF9jbGllbnRpZF9lc3RhYmxpc2htZW50KHN0cnVjdCBuZnM0X2NsaWVudCAqY2xwLCBib29sIHVzZV9leGNoYW5nZV9pZCkKK3N0YXRpYyBib29sIGNscF91c2VkX2V4Y2hhbmdlaWQoc3RydWN0IG5mczRfY2xpZW50ICpjbHApCiB7Ci0JYm9vbCBoYXNfZXhjaGFuZ2VfZmxhZ3MgPSAoY2xwLT5jbF9leGNoYW5nZV9mbGFncyAhPSAwKTsKLQlyZXR1cm4gdXNlX2V4Y2hhbmdlX2lkID09IGhhc19leGNoYW5nZV9mbGFnczsKLX0KKwlyZXR1cm4gY2xwLT5jbF9leGNoYW5nZV9mbGFncyAhPSAwOworfSAKIAogc3RhdGljIHN0cnVjdCBuZnM0X2NsaWVudCAqCi1maW5kX2NvbmZpcm1lZF9jbGllbnRfYnlfc3RyKGNvbnN0IGNoYXIgKmRuYW1lLCB1bnNpZ25lZCBpbnQgaGFzaHZhbCwKLQkJCSAgICAgYm9vbCB1c2VfZXhjaGFuZ2VfaWQpCitmaW5kX2NvbmZpcm1lZF9jbGllbnRfYnlfc3RyKGNvbnN0IGNoYXIgKmRuYW1lLCB1bnNpZ25lZCBpbnQgaGFzaHZhbCkKIHsKIAlzdHJ1Y3QgbmZzNF9jbGllbnQgKmNscDsKIAogCWxpc3RfZm9yX2VhY2hfZW50cnkoY2xwLCAmY29uZl9zdHJfaGFzaHRibFtoYXNodmFsXSwgY2xfc3RyaGFzaCkgewotCQlpZiAoc2FtZV9uYW1lKGNscC0+Y2xfcmVjZGlyLCBkbmFtZSkgJiYKLQkJICAgIG1hdGNoX2NsaWVudGlkX2VzdGFibGlzaG1lbnQoY2xwLCB1c2VfZXhjaGFuZ2VfaWQpKQorCQlpZiAoc2FtZV9uYW1lKGNscC0+Y2xfcmVjZGlyLCBkbmFtZSkpCiAJCQlyZXR1cm4gY2xwOwogCX0KIAlyZXR1cm4gTlVMTDsKIH0KIAogc3RhdGljIHN0cnVjdCBuZnM0X2NsaWVudCAqCi1maW5kX3VuY29uZmlybWVkX2NsaWVudF9ieV9zdHIoY29uc3QgY2hhciAqZG5hbWUsIHVuc2lnbmVkIGludCBoYXNodmFsLAotCQkJICAgICAgIGJvb2wgdXNlX2V4Y2hhbmdlX2lkKQorZmluZF91bmNvbmZpcm1lZF9jbGllbnRfYnlfc3RyKGNvbnN0IGNoYXIgKmRuYW1lLCB1bnNpZ25lZCBpbnQgaGFzaHZhbCkKIHsKIAlzdHJ1Y3QgbmZzNF9jbGllbnQgKmNscDsKIAogCWxpc3RfZm9yX2VhY2hfZW50cnkoY2xwLCAmdW5jb25mX3N0cl9oYXNodGJsW2hhc2h2YWxdLCBjbF9zdHJoYXNoKSB7Ci0JCWlmIChzYW1lX25hbWUoY2xwLT5jbF9yZWNkaXIsIGRuYW1lKSAmJgotCQkgICAgbWF0Y2hfY2xpZW50aWRfZXN0YWJsaXNobWVudChjbHAsIHVzZV9leGNoYW5nZV9pZCkpCisJCWlmIChzYW1lX25hbWUoY2xwLT5jbF9yZWNkaXIsIGRuYW1lKSkKIAkJCXJldHVybiBjbHA7CiAJfQogCXJldHVybiBOVUxMOwogfQogCitzdGF0aWMgdm9pZCBycGNfc3ZjYWRkcjJzb2NrYWRkcihzdHJ1Y3Qgc29ja2FkZHIgKnNhLCB1bnNpZ25lZCBzaG9ydCBmYW1pbHksIHVuaW9uIHN2Y19hZGRyX3UgKnN2Y2FkZHIpCit7CisJc3dpdGNoIChmYW1pbHkpIHsKKwljYXNlIEFGX0lORVQ6CisJCSgoc3RydWN0IHNvY2thZGRyX2luICopc2EpLT5zaW5fZmFtaWx5ID0gQUZfSU5FVDsKKwkJKChzdHJ1Y3Qgc29ja2FkZHJfaW4gKilzYSktPnNpbl9hZGRyID0gc3ZjYWRkci0+YWRkcjsKKwkJcmV0dXJuOworCWNhc2UgQUZfSU5FVDY6CisJCSgoc3RydWN0IHNvY2thZGRyX2luNiAqKXNhKS0+c2luNl9mYW1pbHkgPSBBRl9JTkVUNjsKKwkJKChzdHJ1Y3Qgc29ja2FkZHJfaW42ICopc2EpLT5zaW42X2FkZHIgPSBzdmNhZGRyLT5hZGRyNjsKKwkJcmV0dXJuOworCX0KK30KKwogc3RhdGljIHZvaWQKLWdlbl9jYWxsYmFjayhzdHJ1Y3QgbmZzNF9jbGllbnQgKmNscCwgc3RydWN0IG5mc2Q0X3NldGNsaWVudGlkICpzZSwgdTMyIHNjb3BlaWQpCitnZW5fY2FsbGJhY2soc3RydWN0IG5mczRfY2xpZW50ICpjbHAsIHN0cnVjdCBuZnNkNF9zZXRjbGllbnRpZCAqc2UsIHN0cnVjdCBzdmNfcnFzdCAqcnFzdHApCiB7CiAJc3RydWN0IG5mczRfY2JfY29ubiAqY29ubiA9ICZjbHAtPmNsX2NiX2Nvbm47CisJc3RydWN0IHNvY2thZGRyCSpzYSA9IHN2Y19hZGRyKHJxc3RwKTsKKwl1MzIgc2NvcGVpZCA9IHJwY19nZXRfc2NvcGVfaWQoc2EpOwogCXVuc2lnbmVkIHNob3J0IGV4cGVjdGVkX2ZhbWlseTsKIAogCS8qIEN1cnJlbnRseSwgd2Ugb25seSBzdXBwb3J0IHRjcCBhbmQgdGNwNiBmb3IgdGhlIGNhbGxiYWNrIGNoYW5uZWwgKi8KQEAgLTEyMDUsNiArMTIyNyw3IEBACiAKIAljb25uLT5jYl9wcm9nID0gc2UtPnNlX2NhbGxiYWNrX3Byb2c7CiAJY29ubi0+Y2JfaWRlbnQgPSBzZS0+c2VfY2FsbGJhY2tfaWRlbnQ7CisJcnBjX3N2Y2FkZHIyc29ja2FkZHIoKHN0cnVjdCBzb2NrYWRkciAqKSZjb25uLT5jYl9zYWRkciwgZXhwZWN0ZWRfZmFtaWx5LCAmcnFzdHAtPnJxX2RhZGRyKTsKIAlyZXR1cm47CiBvdXRfZXJyOgogCWNvbm4tPmNiX2FkZHIuc3NfZmFtaWx5ID0gQUZfVU5TUEVDOwpAQCAtMTM0NCw3ICsxMzY3LDcgQEAKIAljYXNlIFNQNF9OT05FOgogCQlicmVhazsKIAljYXNlIFNQNF9TU1Y6Ci0JCXJldHVybiBuZnNlcnJfZW5jcl9hbGdfdW5zdXBwOworCQlyZXR1cm4gbmZzZXJyX3NlcnZlcmZhdWx0OwogCWRlZmF1bHQ6CiAJCUJVRygpOwkJCQkvKiBjaGVja2VkIGJ5IHhkciBjb2RlICovCiAJY2FzZSBTUDRfTUFDSF9DUkVEOgpAQCAtMTM2MSw4ICsxMzg0LDEyIEBACiAJbmZzNF9sb2NrX3N0YXRlKCk7CiAJc3RhdHVzID0gbmZzX29rOwogCi0JY29uZiA9IGZpbmRfY29uZmlybWVkX2NsaWVudF9ieV9zdHIoZG5hbWUsIHN0cmhhc2h2YWwsIHRydWUpOworCWNvbmYgPSBmaW5kX2NvbmZpcm1lZF9jbGllbnRfYnlfc3RyKGRuYW1lLCBzdHJoYXNodmFsKTsKIAlpZiAoY29uZikgeworCQlpZiAoIWNscF91c2VkX2V4Y2hhbmdlaWQoY29uZikpIHsKKwkJCXN0YXR1cyA9IG5mc2Vycl9jbGlkX2ludXNlOyAvKiBYWFg6ID8gKi8KKwkJCWdvdG8gb3V0OworCQl9CiAJCWlmICghc2FtZV92ZXJmKCZ2ZXJmLCAmY29uZi0+Y2xfdmVyaWZpZXIpKSB7CiAJCQkvKiAxOC4zNS40IGNhc2UgOCAqLwogCQkJaWYgKGV4aWQtPmZsYWdzICYgRVhDSEdJRDRfRkxBR19VUERfQ09ORklSTUVEX1JFQ19BKSB7CkBAIC0xNDAzLDcgKzE0MzAsNyBAQAogCQlnb3RvIG91dDsKIAl9CiAKLQl1bmNvbmYgID0gZmluZF91bmNvbmZpcm1lZF9jbGllbnRfYnlfc3RyKGRuYW1lLCBzdHJoYXNodmFsLCB0cnVlKTsKKwl1bmNvbmYgID0gZmluZF91bmNvbmZpcm1lZF9jbGllbnRfYnlfc3RyKGRuYW1lLCBzdHJoYXNodmFsKTsKIAlpZiAodW5jb25mKSB7CiAJCS8qCiAJCSAqIFBvc3NpYmxlIHJldHJ5IG9yIGNsaWVudCByZXN0YXJ0LiAgUGVyIDE4LjM1LjQgY2FzZSA0LApAQCAtMTU2MCw2ICsxNTg3LDggQEAKIAlzdGF0dXMgPSBuZnNfb2s7CiAJbWVtY3B5KGNyX3Nlcy0+c2Vzc2lvbmlkLmRhdGEsIG5ldy0+c2Vfc2Vzc2lvbmlkLmRhdGEsCiAJICAgICAgIE5GUzRfTUFYX1NFU1NJT05JRF9MRU4pOworCW1lbWNweSgmY3Jfc2VzLT5mb3JlX2NoYW5uZWwsICZuZXctPnNlX2ZjaGFubmVsLAorCQlzaXplb2Yoc3RydWN0IG5mc2Q0X2NoYW5uZWxfYXR0cnMpKTsKIAljc19zbG90LT5zbF9zZXFpZCsrOwogCWNyX3Nlcy0+c2VxaWQgPSBjc19zbG90LT5zbF9zZXFpZDsKIApAQCAtMTU4MSw2ICsxNjEwLDQ1IEBACiAJcmV0dXJuIGFyZ3AtPm9wY250ID09IHJlc3AtPm9wY250OwogfQogCitzdGF0aWMgX19iZTMyIG5mc2Q0X21hcF9iY3RzX2Rpcih1MzIgKmRpcikKK3sKKwlzd2l0Y2ggKCpkaXIpIHsKKwljYXNlIE5GUzRfQ0RGQzRfRk9SRToKKwljYXNlIE5GUzRfQ0RGQzRfQkFDSzoKKwkJcmV0dXJuIG5mc19vazsKKwljYXNlIE5GUzRfQ0RGQzRfRk9SRV9PUl9CT1RIOgorCWNhc2UgTkZTNF9DREZDNF9CQUNLX09SX0JPVEg6CisJCSpkaXIgPSBORlM0X0NERkM0X0JPVEg7CisJCXJldHVybiBuZnNfb2s7CisJfTsKKwlyZXR1cm4gbmZzZXJyX2ludmFsOworfQorCitfX2JlMzIgbmZzZDRfYmluZF9jb25uX3RvX3Nlc3Npb24oc3RydWN0IHN2Y19ycXN0ICpycXN0cCwKKwkJICAgICBzdHJ1Y3QgbmZzZDRfY29tcG91bmRfc3RhdGUgKmNzdGF0ZSwKKwkJICAgICBzdHJ1Y3QgbmZzZDRfYmluZF9jb25uX3RvX3Nlc3Npb24gKmJjdHMpCit7CisJX19iZTMyIHN0YXR1czsKKworCWlmICghbmZzZDRfbGFzdF9jb21wb3VuZF9vcChycXN0cCkpCisJCXJldHVybiBuZnNlcnJfbm90X29ubHlfb3A7CisJc3Bpbl9sb2NrKCZjbGllbnRfbG9jayk7CisJY3N0YXRlLT5zZXNzaW9uID0gZmluZF9pbl9zZXNzaW9uaWRfaGFzaHRibCgmYmN0cy0+c2Vzc2lvbmlkKTsKKwkvKiBTb3J0YSB3ZWlyZDogd2Ugb25seSBuZWVkIHRoZSByZWZjbnQnaW5nIGJlY2F1c2UgbmV3X2Nvbm4gYWNxdWlyZXMKKwkgKiBjbGllbnRfbG9jayBpc2VsZjogKi8KKwlpZiAoY3N0YXRlLT5zZXNzaW9uKSB7CisJCW5mc2Q0X2dldF9zZXNzaW9uKGNzdGF0ZS0+c2Vzc2lvbik7CisJCWF0b21pY19pbmMoJmNzdGF0ZS0+c2Vzc2lvbi0+c2VfY2xpZW50LT5jbF9yZWZjb3VudCk7CisJfQorCXNwaW5fdW5sb2NrKCZjbGllbnRfbG9jayk7CisJaWYgKCFjc3RhdGUtPnNlc3Npb24pCisJCXJldHVybiBuZnNlcnJfYmFkc2Vzc2lvbjsKKworCXN0YXR1cyA9IG5mc2Q0X21hcF9iY3RzX2RpcigmYmN0cy0+ZGlyKTsKKwluZnNkNF9uZXdfY29ubihycXN0cCwgY3N0YXRlLT5zZXNzaW9uLCBiY3RzLT5kaXIpOworCXJldHVybiBuZnNfb2s7Cit9CisKIHN0YXRpYyBib29sIG5mc2Q0X2NvbXBvdW5kX2luX3Nlc3Npb24oc3RydWN0IG5mc2Q0X3Nlc3Npb24gKnNlc3Npb24sIHN0cnVjdCBuZnM0X3Nlc3Npb25pZCAqc2lkKQogewogCWlmICghc2Vzc2lvbikKQEAgLTE2MTksOCArMTY4Nyw3IEBACiAJc3Bpbl91bmxvY2soJmNsaWVudF9sb2NrKTsKIAogCW5mczRfbG9ja19zdGF0ZSgpOwotCS8qIHdhaXQgZm9yIGNhbGxiYWNrcyAqLwotCW5mc2Q0X3NodXRkb3duX2NhbGxiYWNrKHNlcy0+c2VfY2xpZW50KTsKKwluZnNkNF9wcm9iZV9jYWxsYmFja19zeW5jKHNlcy0+c2VfY2xpZW50KTsKIAluZnM0X3VubG9ja19zdGF0ZSgpOwogCiAJbmZzZDRfZGVsX2Nvbm5zKHNlcyk7CkBAIC0xNzMzLDggKzE4MDAsMTIgQEAKIG91dDoKIAkvKiBIb2xkIGEgc2Vzc2lvbiByZWZlcmVuY2UgdW50aWwgZG9uZSBwcm9jZXNzaW5nIHRoZSBjb21wb3VuZC4gKi8KIAlpZiAoY3N0YXRlLT5zZXNzaW9uKSB7CisJCXN0cnVjdCBuZnM0X2NsaWVudCAqY2xwID0gc2Vzc2lvbi0+c2VfY2xpZW50OworCiAJCW5mc2Q0X2dldF9zZXNzaW9uKGNzdGF0ZS0+c2Vzc2lvbik7Ci0JCWF0b21pY19pbmMoJnNlc3Npb24tPnNlX2NsaWVudC0+Y2xfcmVmY291bnQpOworCQlhdG9taWNfaW5jKCZjbHAtPmNsX3JlZmNvdW50KTsKKwkJaWYgKGNscC0+Y2xfY2Jfc3RhdGUgPT0gTkZTRDRfQ0JfRE9XTikKKwkJCXNlcS0+c3RhdHVzX2ZsYWdzIHw9IFNFUTRfU1RBVFVTX0NCX1BBVEhfRE9XTjsKIAl9CiAJa2ZyZWUoY29ubik7CiAJc3Bpbl91bmxvY2soJmNsaWVudF9sb2NrKTsKQEAgLTE3NzUsNyArMTg0Niw2IEBACiBuZnNkNF9zZXRjbGllbnRpZChzdHJ1Y3Qgc3ZjX3Jxc3QgKnJxc3RwLCBzdHJ1Y3QgbmZzZDRfY29tcG91bmRfc3RhdGUgKmNzdGF0ZSwKIAkJICBzdHJ1Y3QgbmZzZDRfc2V0Y2xpZW50aWQgKnNldGNsaWQpCiB7Ci0Jc3RydWN0IHNvY2thZGRyCQkqc2EgPSBzdmNfYWRkcihycXN0cCk7CiAJc3RydWN0IHhkcl9uZXRvYmogCWNsbmFtZSA9IHsgCiAJCS5sZW4gPSBzZXRjbGlkLT5zZV9uYW1lbGVuLAogCQkuZGF0YSA9IHNldGNsaWQtPnNlX25hbWUsCkBAIC0xODAxLDEwICsxODcxLDEyIEBACiAJc3RyaGFzaHZhbCA9IGNsaWVudHN0cl9oYXNodmFsKGRuYW1lKTsKIAogCW5mczRfbG9ja19zdGF0ZSgpOwotCWNvbmYgPSBmaW5kX2NvbmZpcm1lZF9jbGllbnRfYnlfc3RyKGRuYW1lLCBzdHJoYXNodmFsLCBmYWxzZSk7CisJY29uZiA9IGZpbmRfY29uZmlybWVkX2NsaWVudF9ieV9zdHIoZG5hbWUsIHN0cmhhc2h2YWwpOwogCWlmIChjb25mKSB7CiAJCS8qIFJGQyAzNTMwIDE0LjIuMzMgQ0FTRSAwOiAqLwogCQlzdGF0dXMgPSBuZnNlcnJfY2xpZF9pbnVzZTsKKwkJaWYgKGNscF91c2VkX2V4Y2hhbmdlaWQoY29uZikpCisJCQlnb3RvIG91dDsKIAkJaWYgKCFzYW1lX2NyZWRzKCZjb25mLT5jbF9jcmVkLCAmcnFzdHAtPnJxX2NyZWQpKSB7CiAJCQljaGFyIGFkZHJfc3RyW0lORVQ2X0FERFJTVFJMRU5dOwogCQkJcnBjX250b3AoKHN0cnVjdCBzb2NrYWRkciAqKSAmY29uZi0+Y2xfYWRkciwgYWRkcl9zdHIsCkBAIC0xODE5LDcgKzE4OTEsNyBAQAogCSAqIGhhcyBhIGRlc2NyaXB0aW9uIG9mIFNFVENMSUVOVElEIHJlcXVlc3QgcHJvY2Vzc2luZyBjb25zaXN0aW5nCiAJICogb2YgNSBidWxsZXQgcG9pbnRzLCBsYWJlbGVkIGFzIENBU0UwIC0gQ0FTRTQgYmVsb3cuCiAJICovCi0JdW5jb25mID0gZmluZF91bmNvbmZpcm1lZF9jbGllbnRfYnlfc3RyKGRuYW1lLCBzdHJoYXNodmFsLCBmYWxzZSk7CisJdW5jb25mID0gZmluZF91bmNvbmZpcm1lZF9jbGllbnRfYnlfc3RyKGRuYW1lLCBzdHJoYXNodmFsKTsKIAlzdGF0dXMgPSBuZnNlcnJfcmVzb3VyY2U7CiAJaWYgKCFjb25mKSB7CiAJCS8qCkBAIC0xODc2LDcgKzE5NDgsNyBAQAogCSAqIGZvciBjb25zaXN0ZW50IG1pbm9ydmVyc2lvbiB1c2UgdGhyb3VnaG91dDoKIAkgKi8KIAluZXctPmNsX21pbm9ydmVyc2lvbiA9IDA7Ci0JZ2VuX2NhbGxiYWNrKG5ldywgc2V0Y2xpZCwgcnBjX2dldF9zY29wZV9pZChzYSkpOworCWdlbl9jYWxsYmFjayhuZXcsIHNldGNsaWQsIHJxc3RwKTsKIAlhZGRfdG9fdW5jb25maXJtZWQobmV3LCBzdHJoYXNodmFsKTsKIAlzZXRjbGlkLT5zZV9jbGllbnRpZC5jbF9ib290ID0gbmV3LT5jbF9jbGllbnRpZC5jbF9ib290OwogCXNldGNsaWQtPnNlX2NsaWVudGlkLmNsX2lkID0gbmV3LT5jbF9jbGllbnRpZC5jbF9pZDsKQEAgLTE5MzUsNyArMjAwNyw2IEBACiAJCWlmICghc2FtZV9jcmVkcygmY29uZi0+Y2xfY3JlZCwgJnVuY29uZi0+Y2xfY3JlZCkpCiAJCQlzdGF0dXMgPSBuZnNlcnJfY2xpZF9pbnVzZTsKIAkJZWxzZSB7Ci0JCQlhdG9taWNfc2V0KCZjb25mLT5jbF9jYl9zZXQsIDApOwogCQkJbmZzZDRfY2hhbmdlX2NhbGxiYWNrKGNvbmYsICZ1bmNvbmYtPmNsX2NiX2Nvbm4pOwogCQkJbmZzZDRfcHJvYmVfY2FsbGJhY2soY29uZik7CiAJCQlleHBpcmVfY2xpZW50KHVuY29uZik7CkBAIC0xOTY0LDcgKzIwMzUsNyBAQAogCQkJdW5zaWduZWQgaW50IGhhc2ggPQogCQkJCWNsaWVudHN0cl9oYXNodmFsKHVuY29uZi0+Y2xfcmVjZGlyKTsKIAkJCWNvbmYgPSBmaW5kX2NvbmZpcm1lZF9jbGllbnRfYnlfc3RyKHVuY29uZi0+Y2xfcmVjZGlyLAotCQkJCQkJCSAgICBoYXNoLCBmYWxzZSk7CisJCQkJCQkJICAgIGhhc2gpOwogCQkJaWYgKGNvbmYpIHsKIAkJCQluZnNkNF9yZW1vdmVfY2xpZF9kaXIoY29uZik7CiAJCQkJZXhwaXJlX2NsaWVudChjb25mKTsKQEAgLTIzMDAsNDEgKzIzNzEsNiBAQAogCW5mc2Q0X2NiX3JlY2FsbChkcCk7CiB9CiAKLS8qCi0gKiBUaGUgZmlsZV9sb2NrIGlzIGJlaW5nIHJlYXBkLgotICoKLSAqIENhbGxlZCBieSBsb2Nrc19mcmVlX2xvY2soKSB3aXRoIGxvY2tfZmxvY2tzKCkgaGVsZC4KLSAqLwotc3RhdGljCi12b2lkIG5mc2RfcmVsZWFzZV9kZWxlZ19jYihzdHJ1Y3QgZmlsZV9sb2NrICpmbCkKLXsKLQlzdHJ1Y3QgbmZzNF9kZWxlZ2F0aW9uICpkcCA9IChzdHJ1Y3QgbmZzNF9kZWxlZ2F0aW9uICopZmwtPmZsX293bmVyOwotCi0JZHByaW50aygiTkZTRCBuZnNkX3JlbGVhc2VfZGVsZWdfY2I6IGZsICVwIGRwICVwIGRsX2NvdW50ICVkXG4iLCBmbCxkcCwgYXRvbWljX3JlYWQoJmRwLT5kbF9jb3VudCkpOwotCi0JaWYgKCEoZmwtPmZsX2ZsYWdzICYgRkxfTEVBU0UpIHx8ICFkcCkKLQkJcmV0dXJuOwotCWRwLT5kbF9mbG9jayA9IE5VTEw7Ci19Ci0KLS8qCi0gKiBDYWxsZWQgZnJvbSBzZXRsZWFzZSgpIHdpdGggbG9ja19mbG9ja3MoKSBoZWxkCi0gKi8KLXN0YXRpYwotaW50IG5mc2Rfc2FtZV9jbGllbnRfZGVsZWdfY2Ioc3RydWN0IGZpbGVfbG9jayAqb25saXN0LCBzdHJ1Y3QgZmlsZV9sb2NrICp0cnkpCi17Ci0Jc3RydWN0IG5mczRfZGVsZWdhdGlvbiAqb25saXN0ZCA9Ci0JCShzdHJ1Y3QgbmZzNF9kZWxlZ2F0aW9uICopb25saXN0LT5mbF9vd25lcjsKLQlzdHJ1Y3QgbmZzNF9kZWxlZ2F0aW9uICp0cnlkID0KLQkJKHN0cnVjdCBuZnM0X2RlbGVnYXRpb24gKil0cnktPmZsX293bmVyOwotCi0JaWYgKG9ubGlzdC0+ZmxfbG1vcHMgIT0gdHJ5LT5mbF9sbW9wcykKLQkJcmV0dXJuIDA7Ci0KLQlyZXR1cm4gb25saXN0ZC0+ZGxfY2xpZW50ID09IHRyeWQtPmRsX2NsaWVudDsKLX0KLQotCiBzdGF0aWMKIGludCBuZnNkX2NoYW5nZV9kZWxlZ19jYihzdHJ1Y3QgZmlsZV9sb2NrICoqb25saXN0LCBpbnQgYXJnKQogewpAQCAtMjM0Niw4ICsyMzgyLDYgQEAKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBsb2NrX21hbmFnZXJfb3BlcmF0aW9ucyBuZnNkX2xlYXNlX21uZ19vcHMgPSB7CiAJLmZsX2JyZWFrID0gbmZzZF9icmVha19kZWxlZ19jYiwKLQkuZmxfcmVsZWFzZV9wcml2YXRlID0gbmZzZF9yZWxlYXNlX2RlbGVnX2NiLAotCS5mbF9teWxlYXNlID0gbmZzZF9zYW1lX2NsaWVudF9kZWxlZ19jYiwKIAkuZmxfY2hhbmdlID0gbmZzZF9jaGFuZ2VfZGVsZWdfY2IsCiB9OwogCkBAIC0yNTE0LDggKzI1NDgsNiBAQAogCWlmICghZnAtPmZpX2Zkc1tvZmxhZ10pIHsKIAkJc3RhdHVzID0gbmZzZF9vcGVuKHJxc3RwLCBjdXJfZmgsIFNfSUZSRUcsIGFjY2VzcywKIAkJCSZmcC0+ZmlfZmRzW29mbGFnXSk7Ci0JCWlmIChzdGF0dXMgPT0gbmZzZXJyX2Ryb3BpdCkKLQkJCXN0YXR1cyA9IG5mc2Vycl9qdWtlYm94OwogCQlpZiAoc3RhdHVzKQogCQkJcmV0dXJuIHN0YXR1czsKIAl9CkBAIC0yNTk2LDYgKzI2MjgsMTkgQEAKIAlvcGVuLT5vcF9zdGF0ZW93bmVyLT5zb19jbGllbnQtPmNsX2ZpcnN0c3RhdGUgPSAxOwogfQogCisvKiBTaG91bGQgd2UgZ2l2ZSBvdXQgcmVjYWxsYWJsZSBzdGF0ZT86ICovCitzdGF0aWMgYm9vbCBuZnNkNF9jYl9jaGFubmVsX2dvb2Qoc3RydWN0IG5mczRfY2xpZW50ICpjbHApCit7CisJaWYgKGNscC0+Y2xfY2Jfc3RhdGUgPT0gTkZTRDRfQ0JfVVApCisJCXJldHVybiB0cnVlOworCS8qCisJICogSW4gdGhlIHNlc3Npb25zIGNhc2UsIHNpbmNlIHdlIGRvbid0IGhhdmUgdG8gZXN0YWJsaXNoIGEKKwkgKiBzZXBhcmF0ZSBjb25uZWN0aW9uIGZvciBjYWxsYmFja3MsIHdlIGFzc3VtZSBpdCdzIE9LCisJICogdW50aWwgd2UgaGVhciBvdGhlcndpc2U6CisJICovCisJcmV0dXJuIGNscC0+Y2xfbWlub3J2ZXJzaW9uICYmIGNscC0+Y2xfY2Jfc3RhdGUgPT0gTkZTRDRfQ0JfVU5LTk9XTjsKK30KKwogLyoKICAqIEF0dGVtcHQgdG8gaGFuZCBvdXQgYSBkZWxlZ2F0aW9uLgogICovCkBAIC0yNjA0LDEwICsyNjQ5LDExIEBACiB7CiAJc3RydWN0IG5mczRfZGVsZWdhdGlvbiAqZHA7CiAJc3RydWN0IG5mczRfc3RhdGVvd25lciAqc29wID0gc3RwLT5zdF9zdGF0ZW93bmVyOwotCWludCBjYl91cCA9IGF0b21pY19yZWFkKCZzb3AtPnNvX2NsaWVudC0+Y2xfY2Jfc2V0KTsKKwlpbnQgY2JfdXA7CiAJc3RydWN0IGZpbGVfbG9jayAqZmw7CiAJaW50IHN0YXR1cywgZmxhZyA9IDA7CiAKKwljYl91cCA9IG5mc2Q0X2NiX2NoYW5uZWxfZ29vZChzb3AtPnNvX2NsaWVudCk7CiAJZmxhZyA9IE5GUzRfT1BFTl9ERUxFR0FURV9OT05FOwogCW9wZW4tPm9wX3JlY2FsbCA9IDA7CiAJc3dpdGNoIChvcGVuLT5vcF9jbGFpbV90eXBlKSB7CkBAIC0yNjU1LDcgKzI3MDEsNyBAQAogCWRwLT5kbF9mbG9jayA9IGZsOwogCiAJLyogdmZzX3NldGxlYXNlIGNoZWNrcyB0byBzZWUgaWYgZGVsZWdhdGlvbiBzaG91bGQgYmUgaGFuZGVkIG91dC4KLQkgKiB0aGUgbG9ja19tYW5hZ2VyIGNhbGxiYWNrcyBmbF9teWxlYXNlIGFuZCBmbF9jaGFuZ2UgYXJlIHVzZWQKKwkgKiB0aGUgbG9ja19tYW5hZ2VyIGNhbGxiYWNrIGZsX2NoYW5nZSBpcyB1c2VkCiAJICovCiAJaWYgKChzdGF0dXMgPSB2ZnNfc2V0bGVhc2UoZmwtPmZsX2ZpbGUsIGZsLT5mbF90eXBlLCAmZmwpKSkgewogCQlkcHJpbnRrKCJORlNEOiBzZXRsZWFzZSBmYWlsZWQgWyVkXSwgbm8gZGVsZWdhdGlvblxuIiwgc3RhdHVzKTsKQEAgLTI3OTQsNyArMjg0MCw3IEBACiAJcmVuZXdfY2xpZW50KGNscCk7CiAJc3RhdHVzID0gbmZzZXJyX2NiX3BhdGhfZG93bjsKIAlpZiAoIWxpc3RfZW1wdHkoJmNscC0+Y2xfZGVsZWdhdGlvbnMpCi0JCQkmJiAhYXRvbWljX3JlYWQoJmNscC0+Y2xfY2Jfc2V0KSkKKwkJCSYmIGNscC0+Y2xfY2Jfc3RhdGUgIT0gTkZTRDRfQ0JfVVApCiAJCWdvdG8gb3V0OwogCXN0YXR1cyA9IG5mc19vazsKIG91dDoKQEAgLTMwODEsOSArMzEyNywxMCBAQAogCQlpZiAoc3RhdHVzKQogCQkJZ290byBvdXQ7CiAJCXJlbmV3X2NsaWVudChkcC0+ZGxfY2xpZW50KTsKLQkJaWYgKGZpbHBwKQorCQlpZiAoZmlscHApIHsKIAkJCSpmaWxwcCA9IGZpbmRfcmVhZGFibGVfZmlsZShkcC0+ZGxfZmlsZSk7Ci0JCUJVR19PTighKmZpbHBwKTsKKwkJCUJVR19PTighKmZpbHBwKTsKKwkJfQogCX0gZWxzZSB7IC8qIG9wZW4gb3IgbG9jayBzdGF0ZWlkICovCiAJCXN0cCA9IGZpbmRfc3RhdGVpZChzdGF0ZWlkLCBmbGFncyk7CiAJCWlmICghc3RwKQpAQCAtNDEwNyw3ICs0MTU0LDcgQEAKIAl1bnNpZ25lZCBpbnQgc3RyaGFzaHZhbCA9IGNsaWVudHN0cl9oYXNodmFsKG5hbWUpOwogCXN0cnVjdCBuZnM0X2NsaWVudCAqY2xwOwogCi0JY2xwID0gZmluZF9jb25maXJtZWRfY2xpZW50X2J5X3N0cihuYW1lLCBzdHJoYXNodmFsLCB1c2VfZXhjaGFuZ2VfaWQpOworCWNscCA9IGZpbmRfY29uZmlybWVkX2NsaWVudF9ieV9zdHIobmFtZSwgc3RyaGFzaHZhbCk7CiAJcmV0dXJuIGNscCA/IDEgOiAwOwogfQogCmRpZmYgLS1naXQgYS9mcy9uZnNkL25mczR4ZHIuYyBiL2ZzL25mc2QvbmZzNHhkci5jCmluZGV4IGYzNWE5NGEuLjk1NjYyOWIgMTAwNjQ0Ci0tLSBhL2ZzL25mc2QvbmZzNHhkci5jCisrKyBiL2ZzL25mc2QvbmZzNHhkci5jCkBAIC00NCwxMyArNDQsMTQgQEAKICNpbmNsdWRlIDxsaW51eC9uYW1laS5oPgogI2luY2x1ZGUgPGxpbnV4L3N0YXRmcy5oPgogI2luY2x1ZGUgPGxpbnV4L3V0c25hbWUuaD4KLSNpbmNsdWRlIDxsaW51eC9uZnNkX2lkbWFwLmg+Ci0jaW5jbHVkZSA8bGludXgvbmZzNF9hY2wuaD4KICNpbmNsdWRlIDxsaW51eC9zdW5ycGMvc3ZjYXV0aF9nc3MuaD4KIAorI2luY2x1ZGUgImlkbWFwLmgiCisjaW5jbHVkZSAiYWNsLmgiCiAjaW5jbHVkZSAieGRyNC5oIgogI2luY2x1ZGUgInZmcy5oIgogCisKICNkZWZpbmUgTkZTRERCR19GQUNJTElUWQkJTkZTRERCR19YRFIKIAogLyoKQEAgLTI4OCwxNyArMjg5LDE3IEBACiAJCQlsZW4gKz0gWERSX1FVQURMRU4oZHVtbXkzMikgPDwgMjsKIAkJCVJFQURNRU0oYnVmLCBkdW1teTMyKTsKIAkJCWFjZS0+d2hvdHlwZSA9IG5mczRfYWNsX2dldF93aG90eXBlKGJ1ZiwgZHVtbXkzMik7Ci0JCQlob3N0X2VyciA9IDA7CisJCQlzdGF0dXMgPSBuZnNfb2s7CiAJCQlpZiAoYWNlLT53aG90eXBlICE9IE5GUzRfQUNMX1dIT19OQU1FRCkKIAkJCQlhY2UtPndobyA9IDA7CiAJCQllbHNlIGlmIChhY2UtPmZsYWcgJiBORlM0X0FDRV9JREVOVElGSUVSX0dST1VQKQotCQkJCWhvc3RfZXJyID0gbmZzZF9tYXBfbmFtZV90b19naWQoYXJncC0+cnFzdHAsCisJCQkJc3RhdHVzID0gbmZzZF9tYXBfbmFtZV90b19naWQoYXJncC0+cnFzdHAsCiAJCQkJCQlidWYsIGR1bW15MzIsICZhY2UtPndobyk7CiAJCQllbHNlCi0JCQkJaG9zdF9lcnIgPSBuZnNkX21hcF9uYW1lX3RvX3VpZChhcmdwLT5ycXN0cCwKKwkJCQlzdGF0dXMgPSBuZnNkX21hcF9uYW1lX3RvX3VpZChhcmdwLT5ycXN0cCwKIAkJCQkJCWJ1ZiwgZHVtbXkzMiwgJmFjZS0+d2hvKTsKLQkJCWlmIChob3N0X2VycikKLQkJCQlnb3RvIG91dF9uZnNlcnI7CisJCQlpZiAoc3RhdHVzKQorCQkJCXJldHVybiBzdGF0dXM7CiAJCX0KIAl9IGVsc2UKIAkJKmFjbCA9IE5VTEw7CkBAIC00MjAsNiArNDIxLDIxIEBACiAJREVDT0RFX1RBSUw7CiB9CiAKK3N0YXRpYyBfX2JlMzIgbmZzZDRfZGVjb2RlX2JpbmRfY29ubl90b19zZXNzaW9uKHN0cnVjdCBuZnNkNF9jb21wb3VuZGFyZ3MgKmFyZ3AsIHN0cnVjdCBuZnNkNF9iaW5kX2Nvbm5fdG9fc2Vzc2lvbiAqYmN0cykKK3sKKwlERUNPREVfSEVBRDsKKwl1MzIgZHVtbXk7CisKKwlSRUFEX0JVRihORlM0X01BWF9TRVNTSU9OSURfTEVOICsgOCk7CisJQ09QWU1FTShiY3RzLT5zZXNzaW9uaWQuZGF0YSwgTkZTNF9NQVhfU0VTU0lPTklEX0xFTik7CisJUkVBRDMyKGJjdHMtPmRpcik7CisJLyogWFhYOiBQZXJoYXBzIFRvbSBUdWNrZXIgY291bGQgaGVscCB1cyBmaWd1cmUgb3V0IGhvdyB3ZQorCSAqIHNob3VsZCBiZSB1c2luZyBjdHNhX3VzZV9jb25uX2luX3JkbWFfbW9kZTogKi8KKwlSRUFEMzIoZHVtbXkpOworCisJREVDT0RFX1RBSUw7Cit9CisKIHN0YXRpYyBfX2JlMzIKIG5mc2Q0X2RlY29kZV9jbG9zZShzdHJ1Y3QgbmZzZDRfY29tcG91bmRhcmdzICphcmdwLCBzdHJ1Y3QgbmZzZDRfY2xvc2UgKmNsb3NlKQogewpAQCAtODQ3LDYgKzg2MywxNyBAQAogfQogCiBzdGF0aWMgX19iZTMyCituZnNkNF9kZWNvZGVfc2VjaW5mb19ub19uYW1lKHN0cnVjdCBuZnNkNF9jb21wb3VuZGFyZ3MgKmFyZ3AsCisJCSAgICAgc3RydWN0IG5mc2Q0X3NlY2luZm9fbm9fbmFtZSAqc2luKQoreworCURFQ09ERV9IRUFEOworCisJUkVBRF9CVUYoNCk7CisJUkVBRDMyKHNpbi0+c2luX3N0eWxlKTsKKwlERUNPREVfVEFJTDsKK30KKworc3RhdGljIF9fYmUzMgogbmZzZDRfZGVjb2RlX3NldGF0dHIoc3RydWN0IG5mc2Q0X2NvbXBvdW5kYXJncyAqYXJncCwgc3RydWN0IG5mc2Q0X3NldGF0dHIgKnNldGF0dHIpCiB7CiAJX19iZTMyIHN0YXR1czsKQEAgLTEwMDUsNyArMTAzMiw3IEBACiBuZnNkNF9kZWNvZGVfZXhjaGFuZ2VfaWQoc3RydWN0IG5mc2Q0X2NvbXBvdW5kYXJncyAqYXJncCwKIAkJCSBzdHJ1Y3QgbmZzZDRfZXhjaGFuZ2VfaWQgKmV4aWQpCiB7Ci0JaW50IGR1bW15OworCWludCBkdW1teSwgdG1wOwogCURFQ09ERV9IRUFEOwogCiAJUkVBRF9CVUYoTkZTNF9WRVJJRklFUl9TSVpFKTsKQEAgLTEwNTMsMTUgKzEwODAsMjMgQEAKIAogCQkvKiBzc3BfaGFzaF9hbGdzPD4gKi8KIAkJUkVBRF9CVUYoNCk7Ci0JCVJFQUQzMihkdW1teSk7Ci0JCVJFQURfQlVGKGR1bW15KTsKLQkJcCArPSBYRFJfUVVBRExFTihkdW1teSk7CisJCVJFQUQzMih0bXApOworCQl3aGlsZSAodG1wLS0pIHsKKwkJCVJFQURfQlVGKDQpOworCQkJUkVBRDMyKGR1bW15KTsKKwkJCVJFQURfQlVGKGR1bW15KTsKKwkJCXAgKz0gWERSX1FVQURMRU4oZHVtbXkpOworCQl9CiAKIAkJLyogc3NwX2VuY3JfYWxnczw+ICovCiAJCVJFQURfQlVGKDQpOwotCQlSRUFEMzIoZHVtbXkpOwotCQlSRUFEX0JVRihkdW1teSk7Ci0JCXAgKz0gWERSX1FVQURMRU4oZHVtbXkpOworCQlSRUFEMzIodG1wKTsKKwkJd2hpbGUgKHRtcC0tKSB7CisJCQlSRUFEX0JVRig0KTsKKwkJCVJFQUQzMihkdW1teSk7CisJCQlSRUFEX0JVRihkdW1teSk7CisJCQlwICs9IFhEUl9RVUFETEVOKGR1bW15KTsKKwkJfQogCiAJCS8qIHNzcF93aW5kb3cgYW5kIHNzcF9udW1fZ3NzX2hhbmRsZXMgKi8KIAkJUkVBRF9CVUYoOCk7CkBAIC0xMzM5LDcgKzEzNzQsNyBAQAogCiAJLyogbmV3IG9wZXJhdGlvbnMgZm9yIE5GU3Y0LjEgKi8KIAlbT1BfQkFDS0NIQU5ORUxfQ1RMXQk9IChuZnNkNF9kZWMpbmZzZDRfZGVjb2RlX25vdHN1cHAsCi0JW09QX0JJTkRfQ09OTl9UT19TRVNTSU9OXT0gKG5mc2Q0X2RlYyluZnNkNF9kZWNvZGVfbm90c3VwcCwKKwlbT1BfQklORF9DT05OX1RPX1NFU1NJT05dPSAobmZzZDRfZGVjKW5mc2Q0X2RlY29kZV9iaW5kX2Nvbm5fdG9fc2Vzc2lvbiwKIAlbT1BfRVhDSEFOR0VfSURdCT0gKG5mc2Q0X2RlYyluZnNkNF9kZWNvZGVfZXhjaGFuZ2VfaWQsCiAJW09QX0NSRUFURV9TRVNTSU9OXQk9IChuZnNkNF9kZWMpbmZzZDRfZGVjb2RlX2NyZWF0ZV9zZXNzaW9uLAogCVtPUF9ERVNUUk9ZX1NFU1NJT05dCT0gKG5mc2Q0X2RlYyluZnNkNF9kZWNvZGVfZGVzdHJveV9zZXNzaW9uLApAQCAtMTM1MCw3ICsxMzg1LDcgQEAKIAlbT1BfTEFZT1VUQ09NTUlUXQk9IChuZnNkNF9kZWMpbmZzZDRfZGVjb2RlX25vdHN1cHAsCiAJW09QX0xBWU9VVEdFVF0JCT0gKG5mc2Q0X2RlYyluZnNkNF9kZWNvZGVfbm90c3VwcCwKIAlbT1BfTEFZT1VUUkVUVVJOXQk9IChuZnNkNF9kZWMpbmZzZDRfZGVjb2RlX25vdHN1cHAsCi0JW09QX1NFQ0lORk9fTk9fTkFNRV0JPSAobmZzZDRfZGVjKW5mc2Q0X2RlY29kZV9ub3RzdXBwLAorCVtPUF9TRUNJTkZPX05PX05BTUVdCT0gKG5mc2Q0X2RlYyluZnNkNF9kZWNvZGVfc2VjaW5mb19ub19uYW1lLAogCVtPUF9TRVFVRU5DRV0JCT0gKG5mc2Q0X2RlYyluZnNkNF9kZWNvZGVfc2VxdWVuY2UsCiAJW09QX1NFVF9TU1ZdCQk9IChuZnNkNF9kZWMpbmZzZDRfZGVjb2RlX25vdHN1cHAsCiAJW09QX1RFU1RfU1RBVEVJRF0JPSAobmZzZDRfZGVjKW5mc2Q0X2RlY29kZV9ub3RzdXBwLApAQCAtMjMwOSw4ICsyMzQ0LDYgQEAKIAljYXNlIG5mc2Vycl9yZXNvdXJjZToKIAkJbmZzZXJyID0gbmZzZXJyX3Rvb3NtYWxsOwogCQlnb3RvIGZhaWw7Ci0JY2FzZSBuZnNlcnJfZHJvcGl0OgotCQlnb3RvIGZhaWw7CiAJY2FzZSBuZnNlcnJfbm9lbnQ6CiAJCWdvdG8gc2tpcF9lbnRyeTsKIAlkZWZhdWx0OgpAQCAtMjM2NSw2ICsyMzk4LDIxIEBACiAJcmV0dXJuIG5mc2VycjsKIH0KIAorc3RhdGljIF9fYmUzMiBuZnNkNF9lbmNvZGVfYmluZF9jb25uX3RvX3Nlc3Npb24oc3RydWN0IG5mc2Q0X2NvbXBvdW5kcmVzICpyZXNwLCBfX2JlMzIgbmZzZXJyLCBzdHJ1Y3QgbmZzZDRfYmluZF9jb25uX3RvX3Nlc3Npb24gKmJjdHMpCit7CisJX19iZTMyICpwOworCisJaWYgKCFuZnNlcnIpIHsKKwkJUkVTRVJWRV9TUEFDRShORlM0X01BWF9TRVNTSU9OSURfTEVOICsgOCk7CisJCVdSSVRFTUVNKGJjdHMtPnNlc3Npb25pZC5kYXRhLCBORlM0X01BWF9TRVNTSU9OSURfTEVOKTsKKwkJV1JJVEUzMihiY3RzLT5kaXIpOworCQkvKiBYWFg6ID8gKi8KKwkJV1JJVEUzMigwKTsKKwkJQURKVVNUX0FSR1MoKTsKKwl9CisJcmV0dXJuIG5mc2VycjsKK30KKwogc3RhdGljIF9fYmUzMgogbmZzZDRfZW5jb2RlX2Nsb3NlKHN0cnVjdCBuZnNkNF9jb21wb3VuZHJlcyAqcmVzcCwgX19iZTMyIG5mc2Vyciwgc3RydWN0IG5mc2Q0X2Nsb3NlICpjbG9zZSkKIHsKQEAgLTI4MjYsMTEgKzI4NzQsMTAgQEAKIH0KIAogc3RhdGljIF9fYmUzMgotbmZzZDRfZW5jb2RlX3NlY2luZm8oc3RydWN0IG5mc2Q0X2NvbXBvdW5kcmVzICpyZXNwLCBfX2JlMzIgbmZzZXJyLAotCQkgICAgIHN0cnVjdCBuZnNkNF9zZWNpbmZvICpzZWNpbmZvKQorbmZzZDRfZG9fZW5jb2RlX3NlY2luZm8oc3RydWN0IG5mc2Q0X2NvbXBvdW5kcmVzICpyZXNwLAorCQkJIF9fYmUzMiBuZnNlcnIsc3RydWN0IHN2Y19leHBvcnQgKmV4cCkKIHsKIAlpbnQgaSA9IDA7Ci0Jc3RydWN0IHN2Y19leHBvcnQgKmV4cCA9IHNlY2luZm8tPnNpX2V4cDsKIAl1MzIgbmZsYXZzOwogCXN0cnVjdCBleHBfZmxhdm9yX2luZm8gKmZsYXZzOwogCXN0cnVjdCBleHBfZmxhdm9yX2luZm8gZGVmX2ZsYXZzWzJdOwpAQCAtMjg5Miw2ICsyOTM5LDIwIEBACiAJcmV0dXJuIG5mc2VycjsKIH0KIAorc3RhdGljIF9fYmUzMgorbmZzZDRfZW5jb2RlX3NlY2luZm8oc3RydWN0IG5mc2Q0X2NvbXBvdW5kcmVzICpyZXNwLCBfX2JlMzIgbmZzZXJyLAorCQkgICAgIHN0cnVjdCBuZnNkNF9zZWNpbmZvICpzZWNpbmZvKQoreworCXJldHVybiBuZnNkNF9kb19lbmNvZGVfc2VjaW5mbyhyZXNwLCBuZnNlcnIsIHNlY2luZm8tPnNpX2V4cCk7Cit9CisKK3N0YXRpYyBfX2JlMzIKK25mc2Q0X2VuY29kZV9zZWNpbmZvX25vX25hbWUoc3RydWN0IG5mc2Q0X2NvbXBvdW5kcmVzICpyZXNwLCBfX2JlMzIgbmZzZXJyLAorCQkgICAgIHN0cnVjdCBuZnNkNF9zZWNpbmZvX25vX25hbWUgKnNlY2luZm8pCit7CisJcmV0dXJuIG5mc2Q0X2RvX2VuY29kZV9zZWNpbmZvKHJlc3AsIG5mc2Vyciwgc2VjaW5mby0+c2luX2V4cCk7Cit9CisKIC8qCiAgKiBUaGUgU0VUQVRUUiBlbmNvZGUgcm91dGluZSBpcyBzcGVjaWFsIC0tIGl0IGFsd2F5cyBlbmNvZGVzIGEgYml0bWFwLAogICogcmVnYXJkbGVzcyBvZiB0aGUgZXJyb3Igc3RhdHVzLgpAQCAtMzA3NiwxMyArMzEzNyw5IEBACiAJV1JJVEUzMihzZXEtPnNlcWlkKTsKIAlXUklURTMyKHNlcS0+c2xvdGlkKTsKIAlXUklURTMyKHNlcS0+bWF4c2xvdHMpOwotCS8qCi0JICogRklYTUU6IGZvciBub3c6Ci0JICogICB0YXJnZXRfbWF4c2xvdHMgPSBtYXhzbG90cwotCSAqICAgc3RhdHVzX2ZsYWdzID0gMAotCSAqLworCS8qIEZvciBub3c6IHRhcmdldF9tYXhzbG90cyA9IG1heHNsb3RzICovCiAJV1JJVEUzMihzZXEtPm1heHNsb3RzKTsKLQlXUklURTMyKDApOworCVdSSVRFMzIoc2VxLT5zdGF0dXNfZmxhZ3MpOwogCiAJQURKVVNUX0FSR1MoKTsKIAlyZXNwLT5jc3RhdGUuZGF0YXAgPSBwOyAvKiBEUkMgY2FjaGUgZGF0YSBwb2ludGVyICovCkBAIC0zMTQzLDcgKzMyMDAsNyBAQAogCiAJLyogTkZTdjQuMSBvcGVyYXRpb25zICovCiAJW09QX0JBQ0tDSEFOTkVMX0NUTF0JPSAobmZzZDRfZW5jKW5mc2Q0X2VuY29kZV9ub29wLAotCVtPUF9CSU5EX0NPTk5fVE9fU0VTU0lPTl0gPSAobmZzZDRfZW5jKW5mc2Q0X2VuY29kZV9ub29wLAorCVtPUF9CSU5EX0NPTk5fVE9fU0VTU0lPTl0gPSAobmZzZDRfZW5jKW5mc2Q0X2VuY29kZV9iaW5kX2Nvbm5fdG9fc2Vzc2lvbiwKIAlbT1BfRVhDSEFOR0VfSURdCT0gKG5mc2Q0X2VuYyluZnNkNF9lbmNvZGVfZXhjaGFuZ2VfaWQsCiAJW09QX0NSRUFURV9TRVNTSU9OXQk9IChuZnNkNF9lbmMpbmZzZDRfZW5jb2RlX2NyZWF0ZV9zZXNzaW9uLAogCVtPUF9ERVNUUk9ZX1NFU1NJT05dCT0gKG5mc2Q0X2VuYyluZnNkNF9lbmNvZGVfZGVzdHJveV9zZXNzaW9uLApAQCAtMzE1NCw3ICszMjExLDcgQEAKIAlbT1BfTEFZT1VUQ09NTUlUXQk9IChuZnNkNF9lbmMpbmZzZDRfZW5jb2RlX25vb3AsCiAJW09QX0xBWU9VVEdFVF0JCT0gKG5mc2Q0X2VuYyluZnNkNF9lbmNvZGVfbm9vcCwKIAlbT1BfTEFZT1VUUkVUVVJOXQk9IChuZnNkNF9lbmMpbmZzZDRfZW5jb2RlX25vb3AsCi0JW09QX1NFQ0lORk9fTk9fTkFNRV0JPSAobmZzZDRfZW5jKW5mc2Q0X2VuY29kZV9ub29wLAorCVtPUF9TRUNJTkZPX05PX05BTUVdCT0gKG5mc2Q0X2VuYyluZnNkNF9lbmNvZGVfc2VjaW5mb19ub19uYW1lLAogCVtPUF9TRVFVRU5DRV0JCT0gKG5mc2Q0X2VuYyluZnNkNF9lbmNvZGVfc2VxdWVuY2UsCiAJW09QX1NFVF9TU1ZdCQk9IChuZnNkNF9lbmMpbmZzZDRfZW5jb2RlX25vb3AsCiAJW09QX1RFU1RfU1RBVEVJRF0JPSAobmZzZDRfZW5jKW5mc2Q0X2VuY29kZV9ub29wLApkaWZmIC0tZ2l0IGEvZnMvbmZzZC9uZnNjdGwuYyBiL2ZzL25mc2QvbmZzY3RsLmMKaW5kZXggNDUxNGViYi4uMzNiM2UyYiAxMDA2NDQKLS0tIGEvZnMvbmZzZC9uZnNjdGwuYworKysgYi9mcy9uZnNkL25mc2N0bC5jCkBAIC04LDEyICs4LDEyIEBACiAjaW5jbHVkZSA8bGludXgvbmFtZWkuaD4KICNpbmNsdWRlIDxsaW51eC9jdHlwZS5oPgogCi0jaW5jbHVkZSA8bGludXgvbmZzZF9pZG1hcC5oPgogI2luY2x1ZGUgPGxpbnV4L3N1bnJwYy9zdmNzb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvbmZzZC9zeXNjYWxsLmg+CiAjaW5jbHVkZSA8bGludXgvbG9ja2QvbG9ja2QuaD4KICNpbmNsdWRlIDxsaW51eC9zdW5ycGMvY2xudC5oPgogCisjaW5jbHVkZSAiaWRtYXAuaCIKICNpbmNsdWRlICJuZnNkLmgiCiAjaW5jbHVkZSAiY2FjaGUuaCIKIApAQCAtMTI3LDYgKzEyNyw3IEBACiAKIHN0YXRpYyBzc2l6ZV90IG5mc2N0bF90cmFuc2FjdGlvbl9yZWFkKHN0cnVjdCBmaWxlICpmaWxlLCBjaGFyIF9fdXNlciAqYnVmLCBzaXplX3Qgc2l6ZSwgbG9mZl90ICpwb3MpCiB7CisjaWZkZWYgQ09ORklHX05GU0RfREVQUkVDQVRFRAogCXN0YXRpYyBpbnQgd2FybmVkOwogCWlmIChmaWxlLT5mX2RlbnRyeS0+ZF9uYW1lLm5hbWVbMF0gPT0gJy4nICYmICF3YXJuZWQpIHsKIAkJcHJpbnRrKEtFUk5fSU5GTwpAQCAtMTM1LDYgKzEzNiw3IEBACiAJCSAgICAgICBjdXJyZW50LT5jb21tLCBmaWxlLT5mX2RlbnRyeS0+ZF9uYW1lLm5hbWUpOwogCQl3YXJuZWQgPSAxOwogCX0KKyNlbmRpZgogCWlmICghIGZpbGUtPnByaXZhdGVfZGF0YSkgewogCQkvKiBBbiBhdHRlbXB0IHRvIHJlYWQgYSB0cmFuc2FjdGlvbiBmaWxlIHdpdGhvdXQgd3JpdGluZwogCQkgKiBjYXVzZXMgYSAwLWJ5dGUgd3JpdGUgc28gdGhhdCB0aGUgZmlsZSBjYW4gcmV0dXJuCmRpZmYgLS1naXQgYS9mcy9uZnNkL25mc2QuaCBiL2ZzL25mc2QvbmZzZC5oCmluZGV4IDZiNjQxY2YuLjdlY2ZhMjQgMTAwNjQ0Ci0tLSBhL2ZzL25mc2QvbmZzZC5oCisrKyBiL2ZzL25mc2QvbmZzZC5oCkBAIC0xNTgsNiArMTU4LDcgQEAKICNkZWZpbmUJbmZzZXJyX2F0dHJub3RzdXBwCWNwdV90b19iZTMyKE5GU0VSUl9BVFRSTk9UU1VQUCkKICNkZWZpbmUJbmZzZXJyX2JhZF94ZHIJCWNwdV90b19iZTMyKE5GU0VSUl9CQURfWERSKQogI2RlZmluZQluZnNlcnJfb3Blbm1vZGUJCWNwdV90b19iZTMyKE5GU0VSUl9PUEVOTU9ERSkKKyNkZWZpbmUJbmZzZXJyX2JhZG93bmVyCQljcHVfdG9fYmUzMihORlNFUlJfQkFET1dORVIpCiAjZGVmaW5lCW5mc2Vycl9sb2Nrc19oZWxkCWNwdV90b19iZTMyKE5GU0VSUl9MT0NLU19IRUxEKQogI2RlZmluZQluZnNlcnJfb3BfaWxsZWdhbAljcHVfdG9fYmUzMihORlNFUlJfT1BfSUxMRUdBTCkKICNkZWZpbmUJbmZzZXJyX2dyYWNlCQljcHVfdG9fYmUzMihORlNFUlJfR1JBQ0UpCmRpZmYgLS1naXQgYS9mcy9uZnNkL25mc3Byb2MuYyBiL2ZzL25mc2QvbmZzcHJvYy5jCmluZGV4IDA4ZTE3MjYuLmUxNWRjNDUgMTAwNjQ0Ci0tLSBhL2ZzL25mc2QvbmZzcHJvYy5jCisrKyBiL2ZzL25mc2QvbmZzcHJvYy5jCkBAIC03MzUsOSArNzM1LDkgQEAKIAkJeyBuZnNlcnJfc3RhbGUsIC1FU1RBTEUgfSwKIAkJeyBuZnNlcnJfanVrZWJveCwgLUVUSU1FRE9VVCB9LAogCQl7IG5mc2Vycl9qdWtlYm94LCAtRVJFU1RBUlRTWVMgfSwKLQkJeyBuZnNlcnJfZHJvcGl0LCAtRUFHQUlOIH0sCi0JCXsgbmZzZXJyX2Ryb3BpdCwgLUVOT01FTSB9LAotCQl7IG5mc2Vycl9iYWRuYW1lLCAtRVNSQ0ggfSwKKwkJeyBuZnNlcnJfanVrZWJveCwgLUVBR0FJTiB9LAorCQl7IG5mc2Vycl9qdWtlYm94LCAtRVdPVUxEQkxPQ0sgfSwKKwkJeyBuZnNlcnJfanVrZWJveCwgLUVOT01FTSB9LAogCQl7IG5mc2Vycl9pbywgLUVUWFRCU1kgfSwKIAkJeyBuZnNlcnJfbm90c3VwcCwgLUVPUE5PVFNVUFAgfSwKIAkJeyBuZnNlcnJfdG9vc21hbGwsIC1FVE9PU01BTEwgfSwKZGlmZiAtLWdpdCBhL2ZzL25mc2QvbmZzc3ZjLmMgYi9mcy9uZnNkL25mc3N2Yy5jCmluZGV4IDJiYWUxZDguLjE4NzQzYzQgMTAwNjQ0Ci0tLSBhL2ZzL25mc2QvbmZzc3ZjLmMKKysrIGIvZnMvbmZzZC9uZnNzdmMuYwpAQCAtNjA4LDcgKzYwOCw3IEBACiAJLyogTm93IGNhbGwgdGhlIHByb2NlZHVyZSBoYW5kbGVyLCBhbmQgZW5jb2RlIE5GUyBzdGF0dXMuICovCiAJbmZzZXJyID0gcHJvYy0+cGNfZnVuYyhycXN0cCwgcnFzdHAtPnJxX2FyZ3AsIHJxc3RwLT5ycV9yZXNwKTsKIAluZnNlcnIgPSBtYXBfbmV3X2Vycm9ycyhycXN0cC0+cnFfdmVycywgbmZzZXJyKTsKLQlpZiAobmZzZXJyID09IG5mc2Vycl9kcm9waXQpIHsKKwlpZiAobmZzZXJyID09IG5mc2Vycl9kcm9waXQgfHwgcnFzdHAtPnJxX2Ryb3BtZSkgewogCQlkcHJpbnRrKCJuZnNkOiBEcm9wcGluZyByZXF1ZXN0OyBtYXkgYmUgcmV2aXNpdGVkIGxhdGVyXG4iKTsKIAkJbmZzZF9jYWNoZV91cGRhdGUocnFzdHAsIFJDX05PQ0FDSEUsIE5VTEwpOwogCQlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2ZzL25mc2Qvc3RhdGUuaCBiL2ZzL25mc2Qvc3RhdGUuaAppbmRleCAzOWFkYzI3Li4zMDc0NjU2IDEwMDY0NAotLS0gYS9mcy9uZnNkL3N0YXRlLmgKKysrIGIvZnMvbmZzZC9zdGF0ZS5oCkBAIC02OCwxMCArNjgsMTIgQEAKIHN0cnVjdCBuZnNkNF9jYWxsYmFjayB7CiAJdm9pZCAqY2Jfb3A7CiAJc3RydWN0IG5mczRfY2xpZW50ICpjYl9jbHA7CisJc3RydWN0IGxpc3RfaGVhZCBjYl9wZXJfY2xpZW50OwogCXUzMiBjYl9taW5vcnZlcnNpb247CiAJc3RydWN0IHJwY19tZXNzYWdlIGNiX21zZzsKIAljb25zdCBzdHJ1Y3QgcnBjX2NhbGxfb3BzICpjYl9vcHM7CiAJc3RydWN0IHdvcmtfc3RydWN0IGNiX3dvcms7CisJYm9vbCBjYl9kb25lOwogfTsKIAogc3RydWN0IG5mczRfZGVsZWdhdGlvbiB7CkBAIC04MSw2ICs4Myw3IEBACiAJYXRvbWljX3QJCWRsX2NvdW50OyAgICAgICAvKiByZWYgY291bnQgKi8KIAlzdHJ1Y3QgbmZzNF9jbGllbnQJKmRsX2NsaWVudDsKIAlzdHJ1Y3QgbmZzNF9maWxlCSpkbF9maWxlOworCXN0cnVjdCBmaWxlCQkqZGxfdmZzX2ZpbGU7CiAJc3RydWN0IGZpbGVfbG9jawkqZGxfZmxvY2s7CiAJdTMyCQkJZGxfdHlwZTsKIAl0aW1lX3QJCQlkbF90aW1lOwpAQCAtOTUsNiArOTgsNyBAQAogc3RydWN0IG5mczRfY2JfY29ubiB7CiAJLyogU0VUQ0xJRU5USUQgaW5mbyAqLwogCXN0cnVjdCBzb2NrYWRkcl9zdG9yYWdlCWNiX2FkZHI7CisJc3RydWN0IHNvY2thZGRyX3N0b3JhZ2UJY2Jfc2FkZHI7CiAJc2l6ZV90CQkJY2JfYWRkcmxlbjsKIAl1MzIgICAgICAgICAgICAgICAgICAgICBjYl9wcm9nOyAvKiB1c2VkIG9ubHkgaW4gNC4wIGNhc2U7CiAJCQkJCSAgICBwZXItc2Vzc2lvbiBvdGhlcndpc2UgKi8KQEAgLTE0Niw2ICsxNTAsMTEgQEAKIAl1MzIJCQkJZ2lkOwogfTsKIAorc3RydWN0IG5mc2Q0X2JpbmRfY29ubl90b19zZXNzaW9uIHsKKwlzdHJ1Y3QgbmZzNF9zZXNzaW9uaWQJCXNlc3Npb25pZDsKKwl1MzIJCQkJZGlyOworfTsKKwogLyogVGhlIHNpbmdsZSBzbG90IGNsaWVudGlkIGNhY2hlIHN0cnVjdHVyZSAqLwogc3RydWN0IG5mc2Q0X2NsaWRfc2xvdCB7CiAJdTMyCQkJCXNsX3NlcWlkOwpAQCAtMjM1LDkgKzI0NCwxMyBAQAogCXVuc2lnbmVkIGxvbmcJCWNsX2NiX2ZsYWdzOwogCXN0cnVjdCBycGNfY2xudAkJKmNsX2NiX2NsaWVudDsKIAl1MzIJCQljbF9jYl9pZGVudDsKLQlhdG9taWNfdAkJY2xfY2Jfc2V0OworI2RlZmluZSBORlNENF9DQl9VUAkJMAorI2RlZmluZSBORlNENF9DQl9VTktOT1dOCTEKKyNkZWZpbmUgTkZTRDRfQ0JfRE9XTgkJMgorCWludAkJCWNsX2NiX3N0YXRlOwogCXN0cnVjdCBuZnNkNF9jYWxsYmFjawljbF9jYl9udWxsOwogCXN0cnVjdCBuZnNkNF9zZXNzaW9uCSpjbF9jYl9zZXNzaW9uOworCXN0cnVjdCBsaXN0X2hlYWQJY2xfY2FsbGJhY2tzOyAvKiBsaXN0IG9mIGluLXByb2dyZXNzIGNhbGxiYWNrcyAqLwogCiAJLyogZm9yIGFsbCBjbGllbnQgaW5mb3JtYXRpb24gdGhhdCBjYWxsYmFjayBjb2RlIG1pZ2h0IG5lZWQ6ICovCiAJc3BpbmxvY2tfdAkJY2xfbG9jazsKQEAgLTQ1NCw2ICs0NjcsNyBAQAogZXh0ZXJuIHZvaWQgbmZzNF9mcmVlX3N0YXRlb3duZXIoc3RydWN0IGtyZWYgKmtyZWYpOwogZXh0ZXJuIGludCBzZXRfY2FsbGJhY2tfY3JlZCh2b2lkKTsKIGV4dGVybiB2b2lkIG5mc2Q0X3Byb2JlX2NhbGxiYWNrKHN0cnVjdCBuZnM0X2NsaWVudCAqY2xwKTsKK2V4dGVybiB2b2lkIG5mc2Q0X3Byb2JlX2NhbGxiYWNrX3N5bmMoc3RydWN0IG5mczRfY2xpZW50ICpjbHApOwogZXh0ZXJuIHZvaWQgbmZzZDRfY2hhbmdlX2NhbGxiYWNrKHN0cnVjdCBuZnM0X2NsaWVudCAqY2xwLCBzdHJ1Y3QgbmZzNF9jYl9jb25uICopOwogZXh0ZXJuIHZvaWQgbmZzZDRfZG9fY2FsbGJhY2tfcnBjKHN0cnVjdCB3b3JrX3N0cnVjdCAqKTsKIGV4dGVybiB2b2lkIG5mc2Q0X2NiX3JlY2FsbChzdHJ1Y3QgbmZzNF9kZWxlZ2F0aW9uICpkcCk7CmRpZmYgLS1naXQgYS9mcy9uZnNkL3Zmcy5jIGIvZnMvbmZzZC92ZnMuYwppbmRleCAyMzBiNzlmLi42NDExMTdmIDEwMDY0NAotLS0gYS9mcy9uZnNkL3Zmcy5jCisrKyBiL2ZzL25mc2QvdmZzLmMKQEAgLTEsNCArMSwzIEBACi0jZGVmaW5lIE1TTkZTCS8qIEhBQ0sgSEFDSyAqLwogLyoKICAqIEZpbGUgb3BlcmF0aW9ucyB1c2VkIGJ5IG5mc2QuIFNvbWUgb2YgdGhlc2UgaGF2ZSBiZWVuIHJpcHBlZCBmcm9tCiAgKiBvdGhlciBwYXJ0cyBvZiB0aGUga2VybmVsIGJlY2F1c2UgdGhleSB3ZXJlbid0IGV4cG9ydGVkLCBvdGhlcnMKQEAgLTM1LDggKzM0LDggQEAKICNlbmRpZiAvKiBDT05GSUdfTkZTRF9WMyAqLwogCiAjaWZkZWYgQ09ORklHX05GU0RfVjQKLSNpbmNsdWRlIDxsaW51eC9uZnM0X2FjbC5oPgotI2luY2x1ZGUgPGxpbnV4L25mc2RfaWRtYXAuaD4KKyNpbmNsdWRlICJhY2wuaCIKKyNpbmNsdWRlICJpZG1hcC5oIgogI2VuZGlmIC8qIENPTkZJR19ORlNEX1Y0ICovCiAKICNpbmNsdWRlICJuZnNkLmgiCkBAIC04OCw4ICs4Nyw5IEBACiAJCQkgICAgLmRlbnRyeSA9IGRnZXQoZGVudHJ5KX07CiAJaW50IGVyciA9IDA7CiAKLQl3aGlsZSAoZF9tb3VudHBvaW50KHBhdGguZGVudHJ5KSAmJiBmb2xsb3dfZG93bigmcGF0aCkpCi0JCTsKKwllcnIgPSBmb2xsb3dfZG93bigmcGF0aCwgZmFsc2UpOworCWlmIChlcnIgPCAwKQorCQlnb3RvIG91dDsKIAogCWV4cDIgPSBycXN0X2V4cF9nZXRfYnlfbmFtZShycXN0cCwgJnBhdGgpOwogCWlmIChJU19FUlIoZXhwMikpIHsKQEAgLTI3Myw2ICsyNzMsMTMgQEAKIAlyZXR1cm4gZXJyOwogfQogCitzdGF0aWMgaW50IG5mc2RfYnJlYWtfbGVhc2Uoc3RydWN0IGlub2RlICppbm9kZSkKK3sKKwlpZiAoIVNfSVNSRUcoaW5vZGUtPmlfbW9kZSkpCisJCXJldHVybiAwOworCXJldHVybiBicmVha19sZWFzZShpbm9kZSwgT19XUk9OTFkgfCBPX05PTkJMT0NLKTsKK30KKwogLyoKICAqIENvbW1pdCBtZXRhZGF0YSBjaGFuZ2VzIHRvIHN0YWJsZSBzdG9yYWdlLgogICovCkBAIC0zNzUsMTYgKzM4Miw2IEBACiAJCQkJZ290byBvdXQ7CiAJCX0KIAotCQkvKgotCQkgKiBJZiB3ZSBhcmUgY2hhbmdpbmcgdGhlIHNpemUgb2YgdGhlIGZpbGUsIHRoZW4KLQkJICogd2UgbmVlZCB0byBicmVhayBhbGwgbGVhc2VzLgotCQkgKi8KLQkJaG9zdF9lcnIgPSBicmVha19sZWFzZShpbm9kZSwgT19XUk9OTFkgfCBPX05PTkJMT0NLKTsKLQkJaWYgKGhvc3RfZXJyID09IC1FV09VTERCTE9DSykKLQkJCWhvc3RfZXJyID0gLUVUSU1FRE9VVDsKLQkJaWYgKGhvc3RfZXJyKSAvKiBFTk9NRU0gb3IgRVdPVUxEQkxPQ0sgKi8KLQkJCWdvdG8gb3V0X25mc2VycjsKLQogCQlob3N0X2VyciA9IGdldF93cml0ZV9hY2Nlc3MoaW5vZGUpOwogCQlpZiAoaG9zdF9lcnIpCiAJCQlnb3RvIG91dF9uZnNlcnI7CkBAIC00MjUsNyArNDIyLDExIEBACiAKIAllcnIgPSBuZnNlcnJfbm90c3luYzsKIAlpZiAoIWNoZWNrX2d1YXJkIHx8IGd1YXJkdGltZSA9PSBpbm9kZS0+aV9jdGltZS50dl9zZWMpIHsKKwkJaG9zdF9lcnIgPSBuZnNkX2JyZWFrX2xlYXNlKGlub2RlKTsKKwkJaWYgKGhvc3RfZXJyKQorCQkJZ290byBvdXRfbmZzZXJyOwogCQlmaF9sb2NrKGZocCk7CisKIAkJaG9zdF9lcnIgPSBub3RpZnlfY2hhbmdlKGRlbnRyeSwgaWFwKTsKIAkJZXJyID0gbmZzZXJybm8oaG9zdF9lcnIpOwogCQlmaF91bmxvY2soZmhwKTsKQEAgLTc1Miw4ICs3NTMsNiBAQAogCSAqLwogCWlmICghKGFjY2VzcyAmIE5GU0RfTUFZX05PVF9CUkVBS19MRUFTRSkpCiAJCWhvc3RfZXJyID0gYnJlYWtfbGVhc2UoaW5vZGUsIE9fTk9OQkxPQ0sgfCAoKGFjY2VzcyAmIE5GU0RfTUFZX1dSSVRFKSA/IE9fV1JPTkxZIDogMCkpOwotCWlmIChob3N0X2VyciA9PSAtRVdPVUxEQkxPQ0spCi0JCWhvc3RfZXJyID0gLUVUSU1FRE9VVDsKIAlpZiAoaG9zdF9lcnIpIC8qIE5PTUVNIG9yIFdPVUxEQkxPQ0sgKi8KIAkJZ290byBvdXRfbmZzZXJyOwogCkBAIC04NzQsMTUgKzg3Myw2IEBACiAJcmV0dXJuIF9fc3BsaWNlX2Zyb21fcGlwZShwaXBlLCBzZCwgbmZzZF9zcGxpY2VfYWN0b3IpOwogfQogCi1zdGF0aWMgaW5saW5lIGludCBzdmNfbXNuZnMoc3RydWN0IHN2Y19maCAqZmZocCkKLXsKLSNpZmRlZiBNU05GUwotCXJldHVybiAoZmZocC0+ZmhfZXhwb3J0LT5leF9mbGFncyAmIE5GU0VYUF9NU05GUyk7Ci0jZWxzZQotCXJldHVybiAwOwotI2VuZGlmCi19Ci0KIHN0YXRpYyBfX2JlMzIKIG5mc2RfdmZzX3JlYWQoc3RydWN0IHN2Y19ycXN0ICpycXN0cCwgc3RydWN0IHN2Y19maCAqZmhwLCBzdHJ1Y3QgZmlsZSAqZmlsZSwKICAgICAgICAgICAgICAgbG9mZl90IG9mZnNldCwgc3RydWN0IGt2ZWMgKnZlYywgaW50IHZsZW4sIHVuc2lnbmVkIGxvbmcgKmNvdW50KQpAQCAtODk1LDkgKzg4NSw2IEBACiAJZXJyID0gbmZzZXJyX3Blcm07CiAJaW5vZGUgPSBmaWxlLT5mX3BhdGguZGVudHJ5LT5kX2lub2RlOwogCi0JaWYgKHN2Y19tc25mcyhmaHApICYmICFsb2NrX21heV9yZWFkKGlub2RlLCBvZmZzZXQsICpjb3VudCkpCi0JCWdvdG8gb3V0OwotCiAJaWYgKGZpbGUtPmZfb3AtPnNwbGljZV9yZWFkICYmIHJxc3RwLT5ycV9zcGxpY2Vfb2spIHsKIAkJc3RydWN0IHNwbGljZV9kZXNjIHNkID0gewogCQkJLmxlbgkJPSAwLApAQCAtOTIyLDcgKzkwOSw2IEBACiAJCWZzbm90aWZ5X2FjY2VzcyhmaWxlKTsKIAl9IGVsc2UgCiAJCWVyciA9IG5mc2Vycm5vKGhvc3RfZXJyKTsKLW91dDoKIAlyZXR1cm4gZXJyOwogfQogCkBAIC05ODcsMTQgKzk3Myw2IEBACiAJaW50CQkJc3RhYmxlID0gKnN0YWJsZXA7CiAJaW50CQkJdXNlX3dnYXRoZXI7CiAKLSNpZmRlZiBNU05GUwotCWVyciA9IG5mc2Vycl9wZXJtOwotCi0JaWYgKChmaHAtPmZoX2V4cG9ydC0+ZXhfZmxhZ3MgJiBORlNFWFBfTVNORlMpICYmCi0JCSghbG9ja19tYXlfd3JpdGUoZmlsZS0+Zl9wYXRoLmRlbnRyeS0+ZF9pbm9kZSwgb2Zmc2V0LCAqY250KSkpCi0JCWdvdG8gb3V0OwotI2VuZGlmCi0KIAlkZW50cnkgPSBmaWxlLT5mX3BhdGguZGVudHJ5OwogCWlub2RlID0gZGVudHJ5LT5kX2lub2RlOwogCWV4cCAgID0gZmhwLT5maF9leHBvcnQ7CkBAIC0xMDQ1LDcgKzEwMjMsNiBAQAogCQllcnIgPSAwOwogCWVsc2UKIAkJZXJyID0gbmZzZXJybm8oaG9zdF9lcnIpOwotb3V0OgogCXJldHVybiBlcnI7CiB9CiAKQEAgLTE2NjUsNiArMTY0MiwxMiBAQAogCQllcnIgPSBuZnNlcnJubyhob3N0X2Vycik7CiAJCWdvdG8gb3V0X2RwdXQ7CiAJfQorCWVyciA9IG5mc2Vycl9ub2VudDsKKwlpZiAoIWRvbGQtPmRfaW5vZGUpCisJCWdvdG8gb3V0X2Ryb3Bfd3JpdGU7CisJaG9zdF9lcnIgPSBuZnNkX2JyZWFrX2xlYXNlKGRvbGQtPmRfaW5vZGUpOworCWlmIChob3N0X2VycikKKwkJZ290byBvdXRfZHJvcF93cml0ZTsKIAlob3N0X2VyciA9IHZmc19saW5rKGRvbGQsIGRpcnAsIGRuZXcpOwogCWlmICghaG9zdF9lcnIpIHsKIAkJZXJyID0gbmZzZXJybm8oY29tbWl0X21ldGFkYXRhKGZmaHApKTsKQEAgLTE2NzYsNiArMTY1OSw3IEBACiAJCWVsc2UKIAkJCWVyciA9IG5mc2Vycm5vKGhvc3RfZXJyKTsKIAl9CitvdXRfZHJvcF93cml0ZToKIAltbnRfZHJvcF93cml0ZSh0ZmhwLT5maF9leHBvcnQtPmV4X3BhdGgubW50KTsKIG91dF9kcHV0OgogCWRwdXQoZG5ldyk7CkBAIC0xNzUwLDEyICsxNzM0LDYgQEAKIAlpZiAobmRlbnRyeSA9PSB0cmFwKQogCQlnb3RvIG91dF9kcHV0X25ldzsKIAotCWlmIChzdmNfbXNuZnMoZmZocCkgJiYKLQkJKChvZGVudHJ5LT5kX2NvdW50ID4gMSkgfHwgKG5kZW50cnktPmRfY291bnQgPiAxKSkpIHsKLQkJCWhvc3RfZXJyID0gLUVQRVJNOwotCQkJZ290byBvdXRfZHB1dF9uZXc7Ci0JfQotCiAJaG9zdF9lcnIgPSAtRVhERVY7CiAJaWYgKGZmaHAtPmZoX2V4cG9ydC0+ZXhfcGF0aC5tbnQgIT0gdGZocC0+ZmhfZXhwb3J0LT5leF9wYXRoLm1udCkKIAkJZ290byBvdXRfZHB1dF9uZXc7CkBAIC0xNzYzLDE1ICsxNzQxLDE3IEBACiAJaWYgKGhvc3RfZXJyKQogCQlnb3RvIG91dF9kcHV0X25ldzsKIAorCWhvc3RfZXJyID0gbmZzZF9icmVha19sZWFzZShvZGVudHJ5LT5kX2lub2RlKTsKKwlpZiAoaG9zdF9lcnIpCisJCWdvdG8gb3V0X2Ryb3Bfd3JpdGU7CiAJaG9zdF9lcnIgPSB2ZnNfcmVuYW1lKGZkaXIsIG9kZW50cnksIHRkaXIsIG5kZW50cnkpOwogCWlmICghaG9zdF9lcnIpIHsKIAkJaG9zdF9lcnIgPSBjb21taXRfbWV0YWRhdGEodGZocCk7CiAJCWlmICghaG9zdF9lcnIpCiAJCQlob3N0X2VyciA9IGNvbW1pdF9tZXRhZGF0YShmZmhwKTsKIAl9Ci0KK291dF9kcm9wX3dyaXRlOgogCW1udF9kcm9wX3dyaXRlKGZmaHAtPmZoX2V4cG9ydC0+ZXhfcGF0aC5tbnQpOwotCiAgb3V0X2RwdXRfbmV3OgogCWRwdXQobmRlbnRyeSk7CiAgb3V0X2RwdXRfb2xkOgpAQCAtMTgzNCwxOCArMTgxNCwxNCBAQAogCWlmIChob3N0X2VycikKIAkJZ290byBvdXRfbmZzZXJyOwogCi0JaWYgKHR5cGUgIT0gU19JRkRJUikgeyAvKiBJdCdzIFVOTElOSyAqLwotI2lmZGVmIE1TTkZTCi0JCWlmICgoZmhwLT5maF9leHBvcnQtPmV4X2ZsYWdzICYgTkZTRVhQX01TTkZTKSAmJgotCQkJKHJkZW50cnktPmRfY291bnQgPiAxKSkgewotCQkJaG9zdF9lcnIgPSAtRVBFUk07Ci0JCX0gZWxzZQotI2VuZGlmCisJaG9zdF9lcnIgPSBuZnNkX2JyZWFrX2xlYXNlKHJkZW50cnktPmRfaW5vZGUpOworCWlmIChob3N0X2VycikKKwkJZ290byBvdXRfcHV0OworCWlmICh0eXBlICE9IFNfSUZESVIpCiAJCWhvc3RfZXJyID0gdmZzX3VubGluayhkaXJwLCByZGVudHJ5KTsKLQl9IGVsc2UgeyAvKiBJdCdzIFJNRElSICovCisJZWxzZQogCQlob3N0X2VyciA9IHZmc19ybWRpcihkaXJwLCByZGVudHJ5KTsKLQl9Ci0KK291dF9wdXQ6CiAJZHB1dChyZGVudHJ5KTsKIAogCWlmICghaG9zdF9lcnIpCmRpZmYgLS1naXQgYS9mcy9uZnNkL3hkcjQuaCBiL2ZzL25mc2QveGRyNC5oCmluZGV4IDYwZmNlM2QuLjM2NjQwMWUgMTAwNjQ0Ci0tLSBhL2ZzL25mc2QveGRyNC5oCisrKyBiL2ZzL25mc2QveGRyNC5oCkBAIC0zMTEsNiArMzExLDExIEBACiAJc3RydWN0IHN2Y19leHBvcnQgKnNpX2V4cDsJCQkvKiByZXNwb25zZSAqLwogfTsKIAorc3RydWN0IG5mc2Q0X3NlY2luZm9fbm9fbmFtZSB7CisJdTMyIHNpbl9zdHlsZTsJCQkJCS8qIHJlcXVlc3QgKi8KKwlzdHJ1Y3Qgc3ZjX2V4cG9ydCAqc2luX2V4cDsJCQkvKiByZXNwb25zZSAqLworfTsKKwogc3RydWN0IG5mc2Q0X3NldGF0dHIgewogCXN0YXRlaWRfdAlzYV9zdGF0ZWlkOyAgICAgICAgIC8qIHJlcXVlc3QgKi8KIAl1MzIJCXNhX2JtdmFsWzNdOyAgICAgICAgLyogcmVxdWVzdCAqLwpAQCAtMzczLDggKzM3OCw4IEBACiAJdTMyCQkJY2FjaGV0aGlzOwkJLyogcmVxdWVzdCAqLwogI2lmIDAKIAl1MzIJCQl0YXJnZXRfbWF4c2xvdHM7CS8qIHJlc3BvbnNlICovCi0JdTMyCQkJc3RhdHVzX2ZsYWdzOwkJLyogcmVzcG9uc2UgKi8KICNlbmRpZiAvKiBub3QgeWV0ICovCisJdTMyCQkJc3RhdHVzX2ZsYWdzOwkJLyogcmVzcG9uc2UgKi8KIH07CiAKIHN0cnVjdCBuZnNkNF9kZXN0cm95X3Nlc3Npb24gewpAQCAtNDIyLDYgKzQyNyw3IEBACiAKIAkJLyogTkZTdjQuMSAqLwogCQlzdHJ1Y3QgbmZzZDRfZXhjaGFuZ2VfaWQJZXhjaGFuZ2VfaWQ7CisJCXN0cnVjdCBuZnNkNF9iaW5kX2Nvbm5fdG9fc2Vzc2lvbiBiaW5kX2Nvbm5fdG9fc2Vzc2lvbjsKIAkJc3RydWN0IG5mc2Q0X2NyZWF0ZV9zZXNzaW9uCWNyZWF0ZV9zZXNzaW9uOwogCQlzdHJ1Y3QgbmZzZDRfZGVzdHJveV9zZXNzaW9uCWRlc3Ryb3lfc2Vzc2lvbjsKIAkJc3RydWN0IG5mc2Q0X3NlcXVlbmNlCQlzZXF1ZW5jZTsKQEAgLTUxOCw2ICs1MjQsNyBAQAogCQlzdHJ1Y3QgbmZzZDRfc2VxdWVuY2UgKnNlcSk7CiBleHRlcm4gX19iZTMyIG5mc2Q0X2V4Y2hhbmdlX2lkKHN0cnVjdCBzdmNfcnFzdCAqcnFzdHAsCiAJCXN0cnVjdCBuZnNkNF9jb21wb3VuZF9zdGF0ZSAqLCBzdHJ1Y3QgbmZzZDRfZXhjaGFuZ2VfaWQgKik7CitleHRlcm4gX19iZTMyIG5mc2Q0X2JpbmRfY29ubl90b19zZXNzaW9uKHN0cnVjdCBzdmNfcnFzdCAqLCBzdHJ1Y3QgbmZzZDRfY29tcG91bmRfc3RhdGUgKiwgc3RydWN0IG5mc2Q0X2JpbmRfY29ubl90b19zZXNzaW9uICopOwogZXh0ZXJuIF9fYmUzMiBuZnNkNF9jcmVhdGVfc2Vzc2lvbihzdHJ1Y3Qgc3ZjX3Jxc3QgKiwKIAkJc3RydWN0IG5mc2Q0X2NvbXBvdW5kX3N0YXRlICosCiAJCXN0cnVjdCBuZnNkNF9jcmVhdGVfc2Vzc2lvbiAqKTsKZGlmZiAtLWdpdCBhL2ZzL25pbGZzMi9zdXBlci5jIGIvZnMvbmlsZnMyL3N1cGVyLmMKaW5kZXggMDk5NGY2YTcuLjU4ZmQ3MDcgMTAwNjQ0Ci0tLSBhL2ZzL25pbGZzMi9zdXBlci5jCisrKyBiL2ZzL25pbGZzMi9zdXBlci5jCkBAIC03MDQsNyArNzA0LDggQEAKIAlzYnBbMF0tPnNfc3RhdGUgPQogCQljcHVfdG9fbGUxNihsZTE2X3RvX2NwdShzYnBbMF0tPnNfc3RhdGUpICYgfk5JTEZTX1ZBTElEX0ZTKTsKIAkvKiBzeW5jaHJvbml6ZSBzYnBbMV0gd2l0aCBzYnBbMF0gKi8KLQltZW1jcHkoc2JwWzFdLCBzYnBbMF0sIG5pbGZzLT5uc19zYnNpemUpOworCWlmIChzYnBbMV0pCisJCW1lbWNweShzYnBbMV0sIHNicFswXSwgbmlsZnMtPm5zX3Nic2l6ZSk7CiAJcmV0dXJuIG5pbGZzX2NvbW1pdF9zdXBlcihzYmksIE5JTEZTX1NCX0NPTU1JVF9BTEwpOwogfQogCmRpZmYgLS1naXQgYS9mcy9udGZzL21mdC5jIGIvZnMvbnRmcy9tZnQuYwppbmRleCBiNTcyYjY3Li4zMjZlNzQ3IDEwMDY0NAotLS0gYS9mcy9udGZzL21mdC5jCisrKyBiL2ZzL250ZnMvbWZ0LmMKQEAgLTEsNyArMSw3IEBACiAvKioKICAqIG1mdC5jIC0gTlRGUyBrZXJuZWwgbWZ0IHJlY29yZCBvcGVyYXRpb25zLiBQYXJ0IG9mIHRoZSBMaW51eC1OVEZTIHByb2plY3QuCiAgKgotICogQ29weXJpZ2h0IChjKSAyMDAxLTIwMDYgQW50b24gQWx0YXBhcm1ha292CisgKiBDb3B5cmlnaHQgKGMpIDIwMDEtMjAxMSBBbnRvbiBBbHRhcGFybWFrb3YgYW5kIFR1eGVyYSBJbmMuCiAgKiBDb3B5cmlnaHQgKGMpIDIwMDIgUmljaGFyZCBSdXNzb24KICAqCiAgKiBUaGlzIHByb2dyYW0vaW5jbHVkZSBmaWxlIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgpAQCAtMjU3Niw2ICsyNTc2LDggQEAKIAlmbHVzaF9kY2FjaGVfcGFnZShwYWdlKTsKIAlTZXRQYWdlVXB0b2RhdGUocGFnZSk7CiAJaWYgKGJhc2VfbmkpIHsKKwkJTUZUX1JFQ09SRCAqbV90bXA7CisKIAkJLyoKIAkJICogU2V0dXAgdGhlIGJhc2UgbWZ0IHJlY29yZCBpbiB0aGUgZXh0ZW50IG1mdCByZWNvcmQuICBUaGlzCiAJCSAqIGNvbXBsZXRlcyBpbml0aWFsaXphdGlvbiBvZiB0aGUgYWxsb2NhdGVkIGV4dGVudCBtZnQgcmVjb3JkCkBAIC0yNTg4LDExICsyNTkwLDExIEBACiAJCSAqIGF0dGFjaCBpdCB0byB0aGUgYmFzZSBpbm9kZSBAYmFzZV9uaSBhbmQgbWFwLCBwaW4sIGFuZCBsb2NrCiAJCSAqIGl0cywgaS5lLiB0aGUgYWxsb2NhdGVkLCBtZnQgcmVjb3JkLgogCQkgKi8KLQkJbSA9IG1hcF9leHRlbnRfbWZ0X3JlY29yZChiYXNlX25pLCBiaXQsICZuaSk7Ci0JCWlmIChJU19FUlIobSkpIHsKKwkJbV90bXAgPSBtYXBfZXh0ZW50X21mdF9yZWNvcmQoYmFzZV9uaSwgYml0LCAmbmkpOworCQlpZiAoSVNfRVJSKG1fdG1wKSkgewogCQkJbnRmc19lcnJvcih2b2wtPnNiLCAiRmFpbGVkIHRvIG1hcCBhbGxvY2F0ZWQgZXh0ZW50ICIKIAkJCQkJIm1mdCByZWNvcmQgMHglbGx4LiIsIChsb25nIGxvbmcpYml0KTsKLQkJCWVyciA9IFBUUl9FUlIobSk7CisJCQllcnIgPSBQVFJfRVJSKG1fdG1wKTsKIAkJCS8qIFNldCB0aGUgbWZ0IHJlY29yZCBpdHNlbGYgbm90IGluIHVzZS4gKi8KIAkJCW0tPmZsYWdzICY9IGNwdV90b19sZTE2KAogCQkJCQl+bGUxNl90b19jcHUoTUZUX1JFQ09SRF9JTl9VU0UpKTsKQEAgLTI2MDMsNiArMjYwNSw3IEBACiAJCQludGZzX3VubWFwX3BhZ2UocGFnZSk7CiAJCQlnb3RvIHVuZG9fbWZ0Ym1wX2FsbG9jOwogCQl9CisJCUJVR19PTihtICE9IG1fdG1wKTsKIAkJLyoKIAkJICogTWFrZSBzdXJlIHRoZSBhbGxvY2F0ZWQgbWZ0IHJlY29yZCBpcyB3cml0dGVuIG91dCB0byBkaXNrLgogCQkgKiBObyBuZWVkIHRvIHNldCB0aGUgaW5vZGUgZGlydHkgYmVjYXVzZSB0aGUgY2FsbGVyIGlzIGdvaW5nCmRpZmYgLS1naXQgYS9mcy9vY2ZzMi9LY29uZmlnIGIvZnMvb2NmczIvS2NvbmZpZwppbmRleCBhYjE1MmMwLi43N2E4ZGU1IDEwMDY0NAotLS0gYS9mcy9vY2ZzMi9LY29uZmlnCisrKyBiL2ZzL29jZnMyL0tjb25maWcKQEAgLTEsNyArMSw2IEBACiBjb25maWcgT0NGUzJfRlMKIAl0cmlzdGF0ZSAiT0NGUzIgZmlsZSBzeXN0ZW0gc3VwcG9ydCIKLQlkZXBlbmRzIG9uIE5FVCAmJiBTWVNGUwotCXNlbGVjdCBDT05GSUdGU19GUworCWRlcGVuZHMgb24gTkVUICYmIFNZU0ZTICYmIENPTkZJR0ZTX0ZTCiAJc2VsZWN0IEpCRDIKIAlzZWxlY3QgQ1JDMzIKIAlzZWxlY3QgUVVPVEEKZGlmZiAtLWdpdCBhL2ZzL29jZnMyL2ZpbGUuYyBiL2ZzL29jZnMyL2ZpbGUuYwppbmRleCA2M2UzZmNhLi5hNjY1MTk1IDEwMDY0NAotLS0gYS9mcy9vY2ZzMi9maWxlLmMKKysrIGIvZnMvb2NmczIvZmlsZS5jCkBAIC0xOTg5LDIwICsxOTg5LDIwIEBACiAJcmV0dXJuIF9fb2NmczJfY2hhbmdlX2ZpbGVfc3BhY2UoZmlsZSwgaW5vZGUsIGZpbGUtPmZfcG9zLCBjbWQsIHNyLCAwKTsKIH0KIAotc3RhdGljIGxvbmcgb2NmczJfZmFsbG9jYXRlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIGludCBtb2RlLCBsb2ZmX3Qgb2Zmc2V0LAorc3RhdGljIGxvbmcgb2NmczJfZmFsbG9jYXRlKHN0cnVjdCBmaWxlICpmaWxlLCBpbnQgbW9kZSwgbG9mZl90IG9mZnNldCwKIAkJCSAgICBsb2ZmX3QgbGVuKQogeworCXN0cnVjdCBpbm9kZSAqaW5vZGUgPSBmaWxlLT5mX3BhdGguZGVudHJ5LT5kX2lub2RlOwogCXN0cnVjdCBvY2ZzMl9zdXBlciAqb3NiID0gT0NGUzJfU0IoaW5vZGUtPmlfc2IpOwogCXN0cnVjdCBvY2ZzMl9zcGFjZV9yZXN2IHNyOwogCWludCBjaGFuZ2Vfc2l6ZSA9IDE7CiAJaW50IGNtZCA9IE9DRlMyX0lPQ19SRVNWU1A2NDsKIAorCWlmIChtb2RlICYgfihGQUxMT0NfRkxfS0VFUF9TSVpFIHwgRkFMTE9DX0ZMX1BVTkNIX0hPTEUpKQorCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAJaWYgKCFvY2ZzMl93cml0ZXNfdW53cml0dGVuX2V4dGVudHMob3NiKSkKIAkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCi0JaWYgKFNfSVNESVIoaW5vZGUtPmlfbW9kZSkpCi0JCXJldHVybiAtRU5PREVWOwotCiAJaWYgKG1vZGUgJiBGQUxMT0NfRkxfS0VFUF9TSVpFKQogCQljaGFuZ2Vfc2l6ZSA9IDA7CiAKQEAgLTI2MTAsNyArMjYxMCw2IEBACiAJLmdldHhhdHRyCT0gZ2VuZXJpY19nZXR4YXR0ciwKIAkubGlzdHhhdHRyCT0gb2NmczJfbGlzdHhhdHRyLAogCS5yZW1vdmV4YXR0cgk9IGdlbmVyaWNfcmVtb3ZleGF0dHIsCi0JLmZhbGxvY2F0ZQk9IG9jZnMyX2ZhbGxvY2F0ZSwKIAkuZmllbWFwCQk9IG9jZnMyX2ZpZW1hcCwKIH07CiAKQEAgLTI2NDIsNiArMjY0MSw3IEBACiAJLmZsb2NrCQk9IG9jZnMyX2Zsb2NrLAogCS5zcGxpY2VfcmVhZAk9IG9jZnMyX2ZpbGVfc3BsaWNlX3JlYWQsCiAJLnNwbGljZV93cml0ZQk9IG9jZnMyX2ZpbGVfc3BsaWNlX3dyaXRlLAorCS5mYWxsb2NhdGUJPSBvY2ZzMl9mYWxsb2NhdGUsCiB9OwogCiBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIG9jZnMyX2RvcHMgPSB7CmRpZmYgLS1naXQgYS9mcy9vY2ZzMi9zdXBlci5jIGIvZnMvb2NmczIvc3VwZXIuYwppbmRleCAwNmQxZjc0Li4zOGY5ODZkIDEwMDY0NAotLS0gYS9mcy9vY2ZzMi9zdXBlci5jCisrKyBiL2ZzL29jZnMyL3N1cGVyLmMKQEAgLTk5Myw4ICs5OTMsNyBAQAogfQogCiAvKiBIYW5kbGUgcXVvdGEgb24gcXVvdGFjdGwgKi8KLXN0YXRpYyBpbnQgb2NmczJfcXVvdGFfb24oc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHR5cGUsIGludCBmb3JtYXRfaWQsCi0JCQkgIGNoYXIgKnBhdGgpCitzdGF0aWMgaW50IG9jZnMyX3F1b3RhX29uKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIGludCB0eXBlLCBpbnQgZm9ybWF0X2lkKQogewogCXVuc2lnbmVkIGludCBmZWF0dXJlW01BWFFVT1RBU10gPSB7IE9DRlMyX0ZFQVRVUkVfUk9fQ09NUEFUX1VTUlFVT1RBLAogCQkJCQkgICAgIE9DRlMyX0ZFQVRVUkVfUk9fQ09NUEFUX0dSUFFVT1RBfTsKQEAgLTEwMTMsNyArMTAxMiw3IEBACiB9CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgcXVvdGFjdGxfb3BzIG9jZnMyX3F1b3RhY3RsX29wcyA9IHsKLQkucXVvdGFfb24JPSBvY2ZzMl9xdW90YV9vbiwKKwkucXVvdGFfb25fbWV0YQk9IG9jZnMyX3F1b3RhX29uLAogCS5xdW90YV9vZmYJPSBvY2ZzMl9xdW90YV9vZmYsCiAJLnF1b3RhX3N5bmMJPSBkcXVvdF9xdW90YV9zeW5jLAogCS5nZXRfaW5mbwk9IGRxdW90X2dldF9kcWluZm8sCmRpZmYgLS1naXQgYS9mcy9vcGVuLmMgYi9mcy9vcGVuLmMKaW5kZXggNWI2ZWY3ZS4uNWEyYzZlYiAxMDA2NDQKLS0tIGEvZnMvb3Blbi5jCisrKyBiL2ZzL29wZW4uYwpAQCAtMjU1LDEwICsyNTUsMTAgQEAKIAlpZiAoKChvZmZzZXQgKyBsZW4pID4gaW5vZGUtPmlfc2ItPnNfbWF4Ynl0ZXMpIHx8ICgob2Zmc2V0ICsgbGVuKSA8IDApKQogCQlyZXR1cm4gLUVGQklHOwogCi0JaWYgKCFpbm9kZS0+aV9vcC0+ZmFsbG9jYXRlKQorCWlmICghZmlsZS0+Zl9vcC0+ZmFsbG9jYXRlKQogCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAKLQlyZXR1cm4gaW5vZGUtPmlfb3AtPmZhbGxvY2F0ZShpbm9kZSwgbW9kZSwgb2Zmc2V0LCBsZW4pOworCXJldHVybiBmaWxlLT5mX29wLT5mYWxsb2NhdGUoZmlsZSwgbW9kZSwgb2Zmc2V0LCBsZW4pOwogfQogCiBTWVNDQUxMX0RFRklORShmYWxsb2NhdGUpKGludCBmZCwgaW50IG1vZGUsIGxvZmZfdCBvZmZzZXQsIGxvZmZfdCBsZW4pCkBAIC03OTAsNiArNzkwLDggQEAKIAogCS8qIFBpY2sgdXAgdGhlIGZpbHAgZnJvbSB0aGUgb3BlbiBpbnRlbnQgKi8KIAlmaWxwID0gbmQtPmludGVudC5vcGVuLmZpbGU7CisJbmQtPmludGVudC5vcGVuLmZpbGUgPSBOVUxMOworCiAJLyogSGFzIHRoZSBmaWxlc3lzdGVtIGluaXRpYWxpc2VkIHRoZSBmaWxlIGZvciB1cz8gKi8KIAlpZiAoZmlscC0+Zl9wYXRoLmRlbnRyeSA9PSBOVUxMKSB7CiAJCXBhdGhfZ2V0KCZuZC0+cGF0aCk7CmRpZmYgLS1naXQgYS9mcy9waXBlLmMgYi9mcy9waXBlLmMKaW5kZXggZTJlOTVmYi4uZGE0MmY3ZCAxMDA2NDQKLS0tIGEvZnMvcGlwZS5jCisrKyBiL2ZzL3BpcGUuYwpAQCAtNDQxLDcgKzQ0MSw3IEBACiAJCQlicmVhazsKIAkJfQogCQlpZiAoZG9fd2FrZXVwKSB7Ci0JCQl3YWtlX3VwX2ludGVycnVwdGlibGVfc3luY19wb2xsKCZwaXBlLT53YWl0LCBQT0xMT1VUKTsKKwkJCXdha2VfdXBfaW50ZXJydXB0aWJsZV9zeW5jX3BvbGwoJnBpcGUtPndhaXQsIFBPTExPVVQgfCBQT0xMV1JOT1JNKTsKICAJCQlraWxsX2Zhc3luYygmcGlwZS0+ZmFzeW5jX3dyaXRlcnMsIFNJR0lPLCBQT0xMX09VVCk7CiAJCX0KIAkJcGlwZV93YWl0KHBpcGUpOwpAQCAtNDUwLDcgKzQ1MCw3IEBACiAKIAkvKiBTaWduYWwgd3JpdGVycyBhc3luY2hyb25vdXNseSB0aGF0IHRoZXJlIGlzIG1vcmUgcm9vbS4gKi8KIAlpZiAoZG9fd2FrZXVwKSB7Ci0JCXdha2VfdXBfaW50ZXJydXB0aWJsZV9zeW5jX3BvbGwoJnBpcGUtPndhaXQsIFBPTExPVVQpOworCQl3YWtlX3VwX2ludGVycnVwdGlibGVfc3luY19wb2xsKCZwaXBlLT53YWl0LCBQT0xMT1VUIHwgUE9MTFdSTk9STSk7CiAJCWtpbGxfZmFzeW5jKCZwaXBlLT5mYXN5bmNfd3JpdGVycywgU0lHSU8sIFBPTExfT1VUKTsKIAl9CiAJaWYgKHJldCA+IDApCkBAIC02MTIsNyArNjEyLDcgQEAKIAkJCWJyZWFrOwogCQl9CiAJCWlmIChkb193YWtldXApIHsKLQkJCXdha2VfdXBfaW50ZXJydXB0aWJsZV9zeW5jX3BvbGwoJnBpcGUtPndhaXQsIFBPTExJTik7CisJCQl3YWtlX3VwX2ludGVycnVwdGlibGVfc3luY19wb2xsKCZwaXBlLT53YWl0LCBQT0xMSU4gfCBQT0xMUkROT1JNKTsKIAkJCWtpbGxfZmFzeW5jKCZwaXBlLT5mYXN5bmNfcmVhZGVycywgU0lHSU8sIFBPTExfSU4pOwogCQkJZG9fd2FrZXVwID0gMDsKIAkJfQpAQCAtNjIzLDcgKzYyMyw3IEBACiBvdXQ6CiAJbXV0ZXhfdW5sb2NrKCZpbm9kZS0+aV9tdXRleCk7CiAJaWYgKGRvX3dha2V1cCkgewotCQl3YWtlX3VwX2ludGVycnVwdGlibGVfc3luY19wb2xsKCZwaXBlLT53YWl0LCBQT0xMSU4pOworCQl3YWtlX3VwX2ludGVycnVwdGlibGVfc3luY19wb2xsKCZwaXBlLT53YWl0LCBQT0xMSU4gfCBQT0xMUkROT1JNKTsKIAkJa2lsbF9mYXN5bmMoJnBpcGUtPmZhc3luY19yZWFkZXJzLCBTSUdJTywgUE9MTF9JTik7CiAJfQogCWlmIChyZXQgPiAwKQpAQCAtNzE1LDcgKzcxNSw3IEBACiAJaWYgKCFwaXBlLT5yZWFkZXJzICYmICFwaXBlLT53cml0ZXJzKSB7CiAJCWZyZWVfcGlwZV9pbmZvKGlub2RlKTsKIAl9IGVsc2UgewotCQl3YWtlX3VwX2ludGVycnVwdGlibGVfc3luY19wb2xsKCZwaXBlLT53YWl0LCBQT0xMSU4gfCBQT0xMT1VUKTsKKwkJd2FrZV91cF9pbnRlcnJ1cHRpYmxlX3N5bmNfcG9sbCgmcGlwZS0+d2FpdCwgUE9MTElOIHwgUE9MTE9VVCB8IFBPTExSRE5PUk0gfCBQT0xMV1JOT1JNIHwgUE9MTEVSUiB8IFBPTExIVVApOwogCQlraWxsX2Zhc3luYygmcGlwZS0+ZmFzeW5jX3JlYWRlcnMsIFNJR0lPLCBQT0xMX0lOKTsKIAkJa2lsbF9mYXN5bmMoJnBpcGUtPmZhc3luY193cml0ZXJzLCBTSUdJTywgUE9MTF9PVVQpOwogCX0KQEAgLTEyOTIsNyArMTI5Miw3IEBACiBzdGF0aWMgdm9pZCBfX2V4aXQgZXhpdF9waXBlX2ZzKHZvaWQpCiB7CiAJdW5yZWdpc3Rlcl9maWxlc3lzdGVtKCZwaXBlX2ZzX3R5cGUpOwotCW1udHB1dF9sb25nKHBpcGVfbW50KTsKKwltbnRwdXQocGlwZV9tbnQpOwogfQogCiBmc19pbml0Y2FsbChpbml0X3BpcGVfZnMpOwpkaWZmIC0tZ2l0IGEvZnMvcG9zaXhfYWNsLmMgYi9mcy9wb3NpeF9hY2wuYwppbmRleCAzOWRmOTVhLi5iMWNmNmJmIDEwMDY0NAotLS0gYS9mcy9wb3NpeF9hY2wuYworKysgYi9mcy9wb3NpeF9hY2wuYwpAQCAtMjIsNiArMjIsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KIAorRVhQT1JUX1NZTUJPTChwb3NpeF9hY2xfaW5pdCk7CiBFWFBPUlRfU1lNQk9MKHBvc2l4X2FjbF9hbGxvYyk7CiBFWFBPUlRfU1lNQk9MKHBvc2l4X2FjbF9jbG9uZSk7CiBFWFBPUlRfU1lNQk9MKHBvc2l4X2FjbF92YWxpZCk7CkBAIC0zMiw2ICszMywxNiBAQAogRVhQT1JUX1NZTUJPTChwb3NpeF9hY2xfcGVybWlzc2lvbik7CiAKIC8qCisgKiBJbml0IGEgZnJlc2ggcG9zaXhfYWNsCisgKi8KK3ZvaWQKK3Bvc2l4X2FjbF9pbml0KHN0cnVjdCBwb3NpeF9hY2wgKmFjbCwgaW50IGNvdW50KQoreworCWF0b21pY19zZXQoJmFjbC0+YV9yZWZjb3VudCwgMSk7CisJYWNsLT5hX2NvdW50ID0gY291bnQ7Cit9CisKKy8qCiAgKiBBbGxvY2F0ZSBhIG5ldyBBQ0wgd2l0aCB0aGUgc3BlY2lmaWVkIG51bWJlciBvZiBlbnRyaWVzLgogICovCiBzdHJ1Y3QgcG9zaXhfYWNsICoKQEAgLTQwLDEwICs1MSw4IEBACiAJY29uc3Qgc2l6ZV90IHNpemUgPSBzaXplb2Yoc3RydWN0IHBvc2l4X2FjbCkgKwogCSAgICAgICAgICAgICAgICAgICAgY291bnQgKiBzaXplb2Yoc3RydWN0IHBvc2l4X2FjbF9lbnRyeSk7CiAJc3RydWN0IHBvc2l4X2FjbCAqYWNsID0ga21hbGxvYyhzaXplLCBmbGFncyk7Ci0JaWYgKGFjbCkgewotCQlhdG9taWNfc2V0KCZhY2wtPmFfcmVmY291bnQsIDEpOwotCQlhY2wtPmFfY291bnQgPSBjb3VudDsKLQl9CisJaWYgKGFjbCkKKwkJcG9zaXhfYWNsX2luaXQoYWNsLCBjb3VudCk7CiAJcmV0dXJuIGFjbDsKIH0KIApkaWZmIC0tZ2l0IGEvZnMvcHJvYy9LY29uZmlnIGIvZnMvcHJvYy9LY29uZmlnCmluZGV4IDZhMDA2ODguLjE1YWY2MjIgMTAwNjQ0Ci0tLSBhL2ZzL3Byb2MvS2NvbmZpZworKysgYi9mcy9wcm9jL0tjb25maWcKQEAgLTEsNSArMSw1IEBACiBjb25maWcgUFJPQ19GUwotCWJvb2wgIi9wcm9jIGZpbGUgc3lzdGVtIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiL3Byb2MgZmlsZSBzeXN0ZW0gc3VwcG9ydCIgaWYgRVhQRVJUCiAJZGVmYXVsdCB5CiAJaGVscAogCSAgVGhpcyBpcyBhIHZpcnR1YWwgZmlsZSBzeXN0ZW0gcHJvdmlkaW5nIGluZm9ybWF0aW9uIGFib3V0IHRoZSBzdGF0dXMKQEAgLTQwLDcgKzQwLDcgQEAKICAgICAgICAgRXhwb3J0cyB0aGUgZHVtcCBpbWFnZSBvZiBjcmFzaGVkIGtlcm5lbCBpbiBFTEYgZm9ybWF0LgogCiBjb25maWcgUFJPQ19TWVNDVEwKLQlib29sICJTeXNjdGwgc3VwcG9ydCAoL3Byb2Mvc3lzKSIgaWYgRU1CRURERUQKKwlib29sICJTeXNjdGwgc3VwcG9ydCAoL3Byb2Mvc3lzKSIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBQUk9DX0ZTCiAJc2VsZWN0IFNZU0NUTAogCWRlZmF1bHQgeQpAQCAtNjEsNyArNjEsNyBAQAogY29uZmlnIFBST0NfUEFHRV9NT05JVE9SCiAgCWRlZmF1bHQgeQogCWRlcGVuZHMgb24gUFJPQ19GUyAmJiBNTVUKLQlib29sICJFbmFibGUgL3Byb2MgcGFnZSBtb25pdG9yaW5nIiBpZiBFTUJFRERFRAorCWJvb2wgIkVuYWJsZSAvcHJvYyBwYWdlIG1vbml0b3JpbmciIGlmIEVYUEVSVAogIAloZWxwCiAJICBWYXJpb3VzIC9wcm9jIGZpbGVzIGV4aXN0IHRvIG1vbml0b3IgcHJvY2VzcyBtZW1vcnkgdXRpbGl6YXRpb246CiAJICAvcHJvYy9waWQvc21hcHMsIC9wcm9jL3BpZC9jbGVhcl9yZWZzLCAvcHJvYy9waWQvcGFnZW1hcCwKZGlmZiAtLWdpdCBhL2ZzL3Byb2MvYmFzZS5jIGIvZnMvcHJvYy9iYXNlLmMKaW5kZXggOTNmMWNkZC4uOWQwOTZlOCAxMDA2NDQKLS0tIGEvZnMvcHJvYy9iYXNlLmMKKysrIGIvZnMvcHJvYy9iYXNlLmMKQEAgLTExNTEsNyArMTE1MSw3IEBACiAJCWdvdG8gZXJyX3Rhc2tfbG9jazsKIAl9CiAKLQlpZiAob29tX3Njb3JlX2FkaiA8IHRhc2stPnNpZ25hbC0+b29tX3Njb3JlX2FkaiAmJgorCWlmIChvb21fc2NvcmVfYWRqIDwgdGFzay0+c2lnbmFsLT5vb21fc2NvcmVfYWRqX21pbiAmJgogCQkJIWNhcGFibGUoQ0FQX1NZU19SRVNPVVJDRSkpIHsKIAkJZXJyID0gLUVBQ0NFUzsKIAkJZ290byBlcnJfc2lnaGFuZDsKQEAgLTExNjQsNiArMTE2NCw4IEBACiAJCQlhdG9taWNfZGVjKCZ0YXNrLT5tbS0+b29tX2Rpc2FibGVfY291bnQpOwogCX0KIAl0YXNrLT5zaWduYWwtPm9vbV9zY29yZV9hZGogPSBvb21fc2NvcmVfYWRqOworCWlmIChoYXNfY2FwYWJpbGl0eV9ub2F1ZGl0KGN1cnJlbnQsIENBUF9TWVNfUkVTT1VSQ0UpKQorCQl0YXNrLT5zaWduYWwtPm9vbV9zY29yZV9hZGpfbWluID0gb29tX3Njb3JlX2FkajsKIAkvKgogCSAqIFNjYWxlIC9wcm9jL3BpZC9vb21fYWRqIGFwcHJvcHJpYXRlbHkgZW5zdXJpbmcgdGhhdCBPT01fRElTQUJMRSBpcwogCSAqIGFsd2F5cyBhdHRhaW5hYmxlLgpkaWZmIC0tZ2l0IGEvZnMvcHJvYy9jb25zb2xlcy5jIGIvZnMvcHJvYy9jb25zb2xlcy5jCmluZGV4IGVhZmMyMmEuLmI3MDFlYWEgMTAwNjQ0Ci0tLSBhL2ZzL3Byb2MvY29uc29sZXMuYworKysgYi9mcy9wcm9jL2NvbnNvbGVzLmMKQEAgLTY3LDcgKzY3LDcgQEAKIAlzdHJ1Y3QgY29uc29sZSAqY29uOwogCWxvZmZfdCBvZmYgPSAwOwogCi0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWZvcl9lYWNoX2NvbnNvbGUoY29uKQogCQlpZiAob2ZmKysgPT0gKnBvcykKIAkJCWJyZWFrOwpAQCAtODQsNyArODQsNyBAQAogCiBzdGF0aWMgdm9pZCBjX3N0b3Aoc3RydWN0IHNlcV9maWxlICptLCB2b2lkICp2KQogewotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogfQogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHNlcV9vcGVyYXRpb25zIGNvbnNvbGVzX29wID0gewpkaWZmIC0tZ2l0IGEvZnMvcHJvYy9tZW1pbmZvLmMgYi9mcy9wcm9jL21lbWluZm8uYwppbmRleCBhNjUyMzljLi5lZDI1N2QxIDEwMDY0NAotLS0gYS9mcy9wcm9jL21lbWluZm8uYworKysgYi9mcy9wcm9jL21lbWluZm8uYwpAQCAtMTAxLDYgKzEwMSw5IEBACiAjaWZkZWYgQ09ORklHX01FTU9SWV9GQUlMVVJFCiAJCSJIYXJkd2FyZUNvcnJ1cHRlZDogJTVsdSBrQlxuIgogI2VuZGlmCisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCisJCSJBbm9uSHVnZVBhZ2VzOiAgJThsdSBrQlxuIgorI2VuZGlmCiAJCSwKIAkJSyhpLnRvdGFscmFtKSwKIAkJSyhpLmZyZWVyYW0pLApAQCAtMTI4LDcgKzEzMSwxMiBAQAogCQlLKGkuZnJlZXN3YXApLAogCQlLKGdsb2JhbF9wYWdlX3N0YXRlKE5SX0ZJTEVfRElSVFkpKSwKIAkJSyhnbG9iYWxfcGFnZV9zdGF0ZShOUl9XUklURUJBQ0spKSwKLQkJSyhnbG9iYWxfcGFnZV9zdGF0ZShOUl9BTk9OX1BBR0VTKSksCisJCUsoZ2xvYmFsX3BhZ2Vfc3RhdGUoTlJfQU5PTl9QQUdFUykKKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UKKwkJICArIGdsb2JhbF9wYWdlX3N0YXRlKE5SX0FOT05fVFJBTlNQQVJFTlRfSFVHRVBBR0VTKSAqCisJCSAgSFBBR0VfUE1EX05SCisjZW5kaWYKKwkJICApLAogCQlLKGdsb2JhbF9wYWdlX3N0YXRlKE5SX0ZJTEVfTUFQUEVEKSksCiAJCUsoZ2xvYmFsX3BhZ2Vfc3RhdGUoTlJfU0hNRU0pKSwKIAkJSyhnbG9iYWxfcGFnZV9zdGF0ZShOUl9TTEFCX1JFQ0xBSU1BQkxFKSArCkBAIC0xNTEsNiArMTU5LDEwIEBACiAjaWZkZWYgQ09ORklHX01FTU9SWV9GQUlMVVJFCiAJCSxhdG9taWNfbG9uZ19yZWFkKCZtY2VfYmFkX3BhZ2VzKSA8PCAoUEFHRV9TSElGVCAtIDEwKQogI2VuZGlmCisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCisJCSxLKGdsb2JhbF9wYWdlX3N0YXRlKE5SX0FOT05fVFJBTlNQQVJFTlRfSFVHRVBBR0VTKSAqCisJCSAgIEhQQUdFX1BNRF9OUikKKyNlbmRpZgogCQkpOwogCiAJaHVnZXRsYl9yZXBvcnRfbWVtaW5mbyhtKTsKZGlmZiAtLWdpdCBhL2ZzL3Byb2MvcGFnZS5jIGIvZnMvcHJvYy9wYWdlLmMKaW5kZXggYjA2YzY3NC4uNmQ4ZTZhOSAxMDA2NDQKLS0tIGEvZnMvcHJvYy9wYWdlLmMKKysrIGIvZnMvcHJvYy9wYWdlLmMKQEAgLTExNiwxNSArMTE2LDE3IEBACiAJaWYgKFBhZ2VIdWdlKHBhZ2UpKQogCQl1IHw9IDEgPDwgS1BGX0hVR0U7CiAKKwkvKgorCSAqIENhdmVhdHMgb24gaGlnaCBvcmRlciBwYWdlczogcGFnZS0+X2NvdW50IHdpbGwgb25seSBiZSBzZXQKKwkgKiAtMSBvbiB0aGUgaGVhZCBwYWdlOyBTTFVCL1NMUUIgZG8gdGhlIHNhbWUgZm9yIFBHX3NsYWI7CisJICogU0xPQiB3b24ndCBzZXQgUEdfc2xhYiBhdCBhbGwgb24gY29tcG91bmQgcGFnZXMuCisJICovCisJaWYgKFBhZ2VCdWRkeShwYWdlKSkKKwkJdSB8PSAxIDw8IEtQRl9CVUREWTsKKwogCXUgfD0ga3BmX2NvcHlfYml0KGssIEtQRl9MT0NLRUQsCVBHX2xvY2tlZCk7CiAKLQkvKgotCSAqIENhdmVhdHMgb24gaGlnaCBvcmRlciBwYWdlczoKLQkgKiBQR19idWRkeSB3aWxsIG9ubHkgYmUgc2V0IG9uIHRoZSBoZWFkIHBhZ2U7IFNMVUIvU0xRQiBkbyB0aGUgc2FtZQotCSAqIGZvciBQR19zbGFiOyBTTE9CIHdvbid0IHNldCBQR19zbGFiIGF0IGFsbCBvbiBjb21wb3VuZCBwYWdlcy4KLQkgKi8KIAl1IHw9IGtwZl9jb3B5X2JpdChrLCBLUEZfU0xBQiwJCVBHX3NsYWIpOwotCXUgfD0ga3BmX2NvcHlfYml0KGssIEtQRl9CVUREWSwJCVBHX2J1ZGR5KTsKIAogCXUgfD0ga3BmX2NvcHlfYml0KGssIEtQRl9FUlJPUiwJCVBHX2Vycm9yKTsKIAl1IHw9IGtwZl9jb3B5X2JpdChrLCBLUEZfRElSVFksCQlQR19kaXJ0eSk7CmRpZmYgLS1naXQgYS9mcy9wcm9jL3Rhc2tfbW11LmMgYi9mcy9wcm9jL3Rhc2tfbW11LmMKaW5kZXggYzM3NTViZC4uNjBiOTE0OCAxMDA2NDQKLS0tIGEvZnMvcHJvYy90YXNrX21tdS5jCisrKyBiL2ZzL3Byb2MvdGFza19tbXUuYwpAQCAtNDE4LDcgKzQxOCw4IEBACiAJCSAgICJBbm9ueW1vdXM6ICAgICAgJThsdSBrQlxuIgogCQkgICAiU3dhcDogICAgICAgICAgICU4bHUga0JcbiIKIAkJICAgIktlcm5lbFBhZ2VTaXplOiAlOGx1IGtCXG4iCi0JCSAgICJNTVVQYWdlU2l6ZTogICAgJThsdSBrQlxuIiwKKwkJICAgIk1NVVBhZ2VTaXplOiAgICAlOGx1IGtCXG4iCisJCSAgICJMb2NrZWQ6ICAgICAgICAgJThsdSBrQlxuIiwKIAkJICAgKHZtYS0+dm1fZW5kIC0gdm1hLT52bV9zdGFydCkgPj4gMTAsCiAJCSAgIG1zcy5yZXNpZGVudCA+PiAxMCwKIAkJICAgKHVuc2lnbmVkIGxvbmcpKG1zcy5wc3MgPj4gKDEwICsgUFNTX1NISUZUKSksCkBAIC00MzAsNyArNDMxLDkgQEAKIAkJICAgbXNzLmFub255bW91cyA+PiAxMCwKIAkJICAgbXNzLnN3YXAgPj4gMTAsCiAJCSAgIHZtYV9rZXJuZWxfcGFnZXNpemUodm1hKSA+PiAxMCwKLQkJICAgdm1hX21tdV9wYWdlc2l6ZSh2bWEpID4+IDEwKTsKKwkJICAgdm1hX21tdV9wYWdlc2l6ZSh2bWEpID4+IDEwLAorCQkgICAodm1hLT52bV9mbGFncyAmIFZNX0xPQ0tFRCkgPworCQkJKHVuc2lnbmVkIGxvbmcpKG1zcy5wc3MgPj4gKDEwICsgUFNTX1NISUZUKSkgOiAwKTsKIAogCWlmIChtLT5jb3VudCA8IG0tPnNpemUpICAvKiB2bWEgaXMgY29waWVkIHN1Y2Nlc3NmdWxseSAqLwogCQltLT52ZXJzaW9uID0gKHZtYSAhPSBnZXRfZ2F0ZV92bWEodGFzaykpID8gdm1hLT52bV9zdGFydCA6IDA7CmRpZmYgLS1naXQgYS9mcy9xdW90YS9kcXVvdC5jIGIvZnMvcXVvdGEvZHF1b3QuYwppbmRleCA4NGJlY2QzLi5hMmE2MjJlIDEwMDY0NAotLS0gYS9mcy9xdW90YS9kcXVvdC5jCisrKyBiL2ZzL3F1b3RhL2RxdW90LmMKQEAgLTIxODksOCArMjE4OSw4IEBACiB9CiBFWFBPUlRfU1lNQk9MKGRxdW90X3Jlc3VtZSk7CiAKLWludCBkcXVvdF9xdW90YV9vbl9wYXRoKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIGludCB0eXBlLCBpbnQgZm9ybWF0X2lkLAotCQkgICAgICBzdHJ1Y3QgcGF0aCAqcGF0aCkKK2ludCBkcXVvdF9xdW90YV9vbihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBpbnQgdHlwZSwgaW50IGZvcm1hdF9pZCwKKwkJICAgc3RydWN0IHBhdGggKnBhdGgpCiB7CiAJaW50IGVycm9yID0gc2VjdXJpdHlfcXVvdGFfb24ocGF0aC0+ZGVudHJ5KTsKIAlpZiAoZXJyb3IpCkBAIC0yMjA0LDIwICsyMjA0LDYgQEAKIAkJCQkJICAgICBEUVVPVF9MSU1JVFNfRU5BQkxFRCk7CiAJcmV0dXJuIGVycm9yOwogfQotRVhQT1JUX1NZTUJPTChkcXVvdF9xdW90YV9vbl9wYXRoKTsKLQotaW50IGRxdW90X3F1b3RhX29uKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIGludCB0eXBlLCBpbnQgZm9ybWF0X2lkLCBjaGFyICpuYW1lKQotewotCXN0cnVjdCBwYXRoIHBhdGg7Ci0JaW50IGVycm9yOwotCi0JZXJyb3IgPSBrZXJuX3BhdGgobmFtZSwgTE9PS1VQX0ZPTExPVywgJnBhdGgpOwotCWlmICghZXJyb3IpIHsKLQkJZXJyb3IgPSBkcXVvdF9xdW90YV9vbl9wYXRoKHNiLCB0eXBlLCBmb3JtYXRfaWQsICZwYXRoKTsKLQkJcGF0aF9wdXQoJnBhdGgpOwotCX0KLQlyZXR1cm4gZXJyb3I7Ci19CiBFWFBPUlRfU1lNQk9MKGRxdW90X3F1b3RhX29uKTsKIAogLyoKZGlmZiAtLWdpdCBhL2ZzL3F1b3RhL3F1b3RhLmMgYi9mcy9xdW90YS9xdW90YS5jCmluZGV4IGIyOTk5NjEuLmIzNGJkYjIgMTAwNjQ0Ci0tLSBhL2ZzL3F1b3RhL3F1b3RhLmMKKysrIGIvZnMvcXVvdGEvcXVvdGEuYwpAQCAtNjQsMTggKzY0LDE1IEBACiB9CiAKIHN0YXRpYyBpbnQgcXVvdGFfcXVvdGFvbihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBpbnQgdHlwZSwgaW50IGNtZCwgcWlkX3QgaWQsCi0JCSAgICAgICAgIHZvaWQgX191c2VyICphZGRyKQorCQkgICAgICAgICBzdHJ1Y3QgcGF0aCAqcGF0aCkKIHsKLQljaGFyICpwYXRobmFtZTsKLQlpbnQgcmV0ID0gLUVOT1NZUzsKLQotCXBhdGhuYW1lID0gZ2V0bmFtZShhZGRyKTsKLQlpZiAoSVNfRVJSKHBhdGhuYW1lKSkKLQkJcmV0dXJuIFBUUl9FUlIocGF0aG5hbWUpOwotCWlmIChzYi0+c19xY29wLT5xdW90YV9vbikKLQkJcmV0ID0gc2ItPnNfcWNvcC0+cXVvdGFfb24oc2IsIHR5cGUsIGlkLCBwYXRobmFtZSk7Ci0JcHV0bmFtZShwYXRobmFtZSk7Ci0JcmV0dXJuIHJldDsKKwlpZiAoIXNiLT5zX3Fjb3AtPnF1b3RhX29uICYmICFzYi0+c19xY29wLT5xdW90YV9vbl9tZXRhKQorCQlyZXR1cm4gLUVOT1NZUzsKKwlpZiAoc2ItPnNfcWNvcC0+cXVvdGFfb25fbWV0YSkKKwkJcmV0dXJuIHNiLT5zX3Fjb3AtPnF1b3RhX29uX21ldGEoc2IsIHR5cGUsIGlkKTsKKwlpZiAoSVNfRVJSKHBhdGgpKQorCQlyZXR1cm4gUFRSX0VSUihwYXRoKTsKKwlyZXR1cm4gc2ItPnNfcWNvcC0+cXVvdGFfb24oc2IsIHR5cGUsIGlkLCBwYXRoKTsKIH0KIAogc3RhdGljIGludCBxdW90YV9nZXRmbXQoc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHR5cGUsIHZvaWQgX191c2VyICphZGRyKQpAQCAtMjQxLDcgKzIzOCw3IEBACiAKIC8qIENvcHkgcGFyYW1ldGVycyBhbmQgY2FsbCBwcm9wZXIgZnVuY3Rpb24gKi8KIHN0YXRpYyBpbnQgZG9fcXVvdGFjdGwoc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHR5cGUsIGludCBjbWQsIHFpZF90IGlkLAotCQkgICAgICAgdm9pZCBfX3VzZXIgKmFkZHIpCisJCSAgICAgICB2b2lkIF9fdXNlciAqYWRkciwgc3RydWN0IHBhdGggKnBhdGgpCiB7CiAJaW50IHJldDsKIApAQCAtMjU2LDcgKzI1Myw3IEBACiAKIAlzd2l0Y2ggKGNtZCkgewogCWNhc2UgUV9RVU9UQU9OOgotCQlyZXR1cm4gcXVvdGFfcXVvdGFvbihzYiwgdHlwZSwgY21kLCBpZCwgYWRkcik7CisJCXJldHVybiBxdW90YV9xdW90YW9uKHNiLCB0eXBlLCBjbWQsIGlkLCBwYXRoKTsKIAljYXNlIFFfUVVPVEFPRkY6CiAJCWlmICghc2ItPnNfcWNvcC0+cXVvdGFfb2ZmKQogCQkJcmV0dXJuIC1FTk9TWVM7CkBAIC0zMzUsNiArMzMyLDcgQEAKIHsKIAl1aW50IGNtZHMsIHR5cGU7CiAJc3RydWN0IHN1cGVyX2Jsb2NrICpzYiA9IE5VTEw7CisJc3RydWN0IHBhdGggcGF0aCwgKnBhdGhwID0gTlVMTDsKIAlpbnQgcmV0OwogCiAJY21kcyA9IGNtZCA+PiBTVUJDTURTSElGVDsKQEAgLTM1MSwxMiArMzQ5LDI3IEBACiAJCXJldHVybiAtRU5PREVWOwogCX0KIAorCS8qCisJICogUGF0aCBmb3IgcXVvdGFvbiBoYXMgdG8gYmUgcmVzb2x2ZWQgYmVmb3JlIGdyYWJiaW5nIHN1cGVyYmxvY2sKKwkgKiBiZWNhdXNlIHRoYXQgZ2V0cyBzX3Vtb3VudCBzZW0gd2hpY2ggaXMgYWxzbyBwb3NzaWJseSBuZWVkZWQgYnkgcGF0aAorCSAqIHJlc29sdXRpb24gKHRoaW5rIGFib3V0IGF1dG9mcykgYW5kIHRodXMgZGVhZGxvY2tzIGNvdWxkIGFyaXNlLgorCSAqLworCWlmIChjbWRzID09IFFfUVVPVEFPTikgeworCQlyZXQgPSB1c2VyX3BhdGhfYXQoQVRfRkRDV0QsIGFkZHIsIExPT0tVUF9GT0xMT1csICZwYXRoKTsKKwkJaWYgKHJldCkKKwkJCXBhdGhwID0gRVJSX1BUUihyZXQpOworCQllbHNlCisJCQlwYXRocCA9ICZwYXRoOworCX0KKwogCXNiID0gcXVvdGFjdGxfYmxvY2soc3BlY2lhbCk7CiAJaWYgKElTX0VSUihzYikpCiAJCXJldHVybiBQVFJfRVJSKHNiKTsKIAotCXJldCA9IGRvX3F1b3RhY3RsKHNiLCB0eXBlLCBjbWRzLCBpZCwgYWRkcik7CisJcmV0ID0gZG9fcXVvdGFjdGwoc2IsIHR5cGUsIGNtZHMsIGlkLCBhZGRyLCBwYXRocCk7CiAKIAlkcm9wX3N1cGVyKHNiKTsKKwlpZiAocGF0aHAgJiYgIUlTX0VSUihwYXRocCkpCisJCXBhdGhfcHV0KHBhdGhwKTsKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0tZ2l0IGEvZnMvcmVpc2VyZnMvc3VwZXIuYyBiL2ZzL3JlaXNlcmZzL3N1cGVyLmMKaW5kZXggMjU3NTY4Mi4uMGFhYjA0ZiAxMDA2NDQKLS0tIGEvZnMvcmVpc2VyZnMvc3VwZXIuYworKysgYi9mcy9yZWlzZXJmcy9zdXBlci5jCkBAIC02MzIsNyArNjMyLDcgQEAKIHN0YXRpYyBpbnQgcmVpc2VyZnNfcmVsZWFzZV9kcXVvdChzdHJ1Y3QgZHF1b3QgKik7CiBzdGF0aWMgaW50IHJlaXNlcmZzX21hcmtfZHF1b3RfZGlydHkoc3RydWN0IGRxdW90ICopOwogc3RhdGljIGludCByZWlzZXJmc193cml0ZV9pbmZvKHN0cnVjdCBzdXBlcl9ibG9jayAqLCBpbnQpOwotc3RhdGljIGludCByZWlzZXJmc19xdW90YV9vbihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiwgaW50LCBpbnQsIGNoYXIgKik7CitzdGF0aWMgaW50IHJlaXNlcmZzX3F1b3RhX29uKHN0cnVjdCBzdXBlcl9ibG9jayAqLCBpbnQsIGludCwgc3RydWN0IHBhdGggKik7CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHF1b3Rfb3BlcmF0aW9ucyByZWlzZXJmc19xdW90YV9vcGVyYXRpb25zID0gewogCS53cml0ZV9kcXVvdCA9IHJlaXNlcmZzX3dyaXRlX2RxdW90LApAQCAtMjA0OCwyNSArMjA0OCwyMSBAQAogICogU3RhbmRhcmQgZnVuY3Rpb24gdG8gYmUgY2FsbGVkIG9uIHF1b3RhX29uCiAgKi8KIHN0YXRpYyBpbnQgcmVpc2VyZnNfcXVvdGFfb24oc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHR5cGUsIGludCBmb3JtYXRfaWQsCi0JCQkgICAgIGNoYXIgKm5hbWUpCisJCQkgICAgIHN0cnVjdCBwYXRoICpwYXRoKQogewogCWludCBlcnI7Ci0Jc3RydWN0IHBhdGggcGF0aDsKIAlzdHJ1Y3QgaW5vZGUgKmlub2RlOwogCXN0cnVjdCByZWlzZXJmc190cmFuc2FjdGlvbl9oYW5kbGUgdGg7CiAKIAlpZiAoIShSRUlTRVJGU19TQihzYiktPnNfbW91bnRfb3B0ICYgKDEgPDwgUkVJU0VSRlNfUVVPVEEpKSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKLQllcnIgPSBrZXJuX3BhdGgobmFtZSwgTE9PS1VQX0ZPTExPVywgJnBhdGgpOwotCWlmIChlcnIpCi0JCXJldHVybiBlcnI7CiAJLyogUXVvdGFmaWxlIG5vdCBvbiB0aGUgc2FtZSBmaWxlc3lzdGVtPyAqLwotCWlmIChwYXRoLm1udC0+bW50X3NiICE9IHNiKSB7CisJaWYgKHBhdGgtPm1udC0+bW50X3NiICE9IHNiKSB7CiAJCWVyciA9IC1FWERFVjsKIAkJZ290byBvdXQ7CiAJfQotCWlub2RlID0gcGF0aC5kZW50cnktPmRfaW5vZGU7CisJaW5vZGUgPSBwYXRoLT5kZW50cnktPmRfaW5vZGU7CiAJLyogV2UgbXVzdCBub3QgcGFjayB0YWlscyBmb3IgcXVvdGEgZmlsZXMgb24gcmVpc2VyZnMgZm9yIHF1b3RhIElPIHRvIHdvcmsgKi8KIAlpZiAoIShSRUlTRVJGU19JKGlub2RlKS0+aV9mbGFncyAmIGlfbm9wYWNrX21hc2spKSB7CiAJCWVyciA9IHJlaXNlcmZzX3VucGFjayhpbm9kZSwgTlVMTCk7CkBAIC0yMDgyLDcgKzIwNzgsNyBAQAogCS8qIEpvdXJuYWxpbmcgcXVvdGE/ICovCiAJaWYgKFJFSVNFUkZTX1NCKHNiKS0+c19xZl9uYW1lc1t0eXBlXSkgewogCQkvKiBRdW90YWZpbGUgbm90IG9mIGZzIHJvb3Q/ICovCi0JCWlmIChwYXRoLmRlbnRyeS0+ZF9wYXJlbnQgIT0gc2ItPnNfcm9vdCkKKwkJaWYgKHBhdGgtPmRlbnRyeS0+ZF9wYXJlbnQgIT0gc2ItPnNfcm9vdCkKIAkJCXJlaXNlcmZzX3dhcm5pbmcoc2IsICJzdXBlci02NTIxIiwKIAkJCQkgIlF1b3RhIGZpbGUgbm90IG9uIGZpbGVzeXN0ZW0gcm9vdC4gIgogCQkJCSAiSm91cm5hbGxlZCBxdW90YSB3aWxsIG5vdCB3b3JrLiIpOwpAQCAtMjEwMSw5ICsyMDk3LDggQEAKIAkJaWYgKGVycikKIAkJCWdvdG8gb3V0OwogCX0KLQllcnIgPSBkcXVvdF9xdW90YV9vbl9wYXRoKHNiLCB0eXBlLCBmb3JtYXRfaWQsICZwYXRoKTsKKwllcnIgPSBkcXVvdF9xdW90YV9vbihzYiwgdHlwZSwgZm9ybWF0X2lkLCBwYXRoKTsKIG91dDoKLQlwYXRoX3B1dCgmcGF0aCk7CiAJcmV0dXJuIGVycjsKIH0KIApkaWZmIC0tZ2l0IGEvZnMvc3F1YXNoZnMvS2NvbmZpZyBiL2ZzL3NxdWFzaGZzL0tjb25maWcKaW5kZXggZTVmNjNkYS4uYWE2OGE4YSAxMDA2NDQKLS0tIGEvZnMvc3F1YXNoZnMvS2NvbmZpZworKysgYi9mcy9zcXVhc2hmcy9LY29uZmlnCkBAIC0yOSw3ICsyOSw2IEBACiBjb25maWcgU1FVQVNIRlNfWEFUVFIKIAlib29sICJTcXVhc2hmcyBYQVRUUiBzdXBwb3J0IgogCWRlcGVuZHMgb24gU1FVQVNIRlMKLQlkZWZhdWx0IG4KIAloZWxwCiAJICBTYXlpbmcgWSBoZXJlIGluY2x1ZGVzIHN1cHBvcnQgZm9yIGV4dGVuZGVkIGF0dHJpYnV0ZXMgKHhhdHRycykuCiAJICBYYXR0cnMgYXJlIG5hbWU6dmFsdWUgcGFpcnMgYXNzb2NpYXRlZCB3aXRoIGlub2RlcyBieQpAQCAtNDAsNyArMzksNiBAQAogY29uZmlnIFNRVUFTSEZTX0xaTwogCWJvb2wgIkluY2x1ZGUgc3VwcG9ydCBmb3IgTFpPIGNvbXByZXNzZWQgZmlsZSBzeXN0ZW1zIgogCWRlcGVuZHMgb24gU1FVQVNIRlMKLQlkZWZhdWx0IG4KIAlzZWxlY3QgTFpPX0RFQ09NUFJFU1MKIAloZWxwCiAJICBTYXlpbmcgWSBoZXJlIGluY2x1ZGVzIHN1cHBvcnQgZm9yIHJlYWRpbmcgU3F1YXNoZnMgZmlsZSBzeXN0ZW1zCkBAIC01MywxMCArNTEsMjQgQEAKIAogCSAgSWYgdW5zdXJlLCBzYXkgTi4KIAorY29uZmlnIFNRVUFTSEZTX1haCisJYm9vbCAiSW5jbHVkZSBzdXBwb3J0IGZvciBYWiBjb21wcmVzc2VkIGZpbGUgc3lzdGVtcyIKKwlkZXBlbmRzIG9uIFNRVUFTSEZTCisJc2VsZWN0IFhaX0RFQworCWhlbHAKKwkgIFNheWluZyBZIGhlcmUgaW5jbHVkZXMgc3VwcG9ydCBmb3IgcmVhZGluZyBTcXVhc2hmcyBmaWxlIHN5c3RlbXMKKwkgIGNvbXByZXNzZWQgd2l0aCBYWiBjb21wcmVzc3Npb24uICBYWiBnaXZlcyBiZXR0ZXIgY29tcHJlc3Npb24gdGhhbgorCSAgdGhlIGRlZmF1bHQgemxpYiBjb21wcmVzc2lvbiwgYXQgdGhlIGV4cGVuc2Ugb2YgZ3JlYXRlciBDUFUgYW5kCisJICBtZW1vcnkgb3ZlcmhlYWQuCisKKwkgIFhaIGlzIG5vdCB0aGUgc3RhbmRhcmQgY29tcHJlc3Npb24gdXNlZCBpbiBTcXVhc2hmcyBhbmQgc28gbW9zdAorCSAgZmlsZSBzeXN0ZW1zIHdpbGwgYmUgcmVhZGFibGUgd2l0aG91dCBzZWxlY3RpbmcgdGhpcyBvcHRpb24uCisKKwkgIElmIHVuc3VyZSwgc2F5IE4uCisKIGNvbmZpZyBTUVVBU0hGU19FTUJFRERFRAogCWJvb2wgIkFkZGl0aW9uYWwgb3B0aW9uIGZvciBtZW1vcnktY29uc3RyYWluZWQgc3lzdGVtcyIKIAlkZXBlbmRzIG9uIFNRVUFTSEZTCi0JZGVmYXVsdCBuCiAJaGVscAogCSAgU2F5aW5nIFkgaGVyZSBhbGxvd3MgeW91IHRvIHNwZWNpZnkgY2FjaGUgc2l6ZS4KIApkaWZmIC0tZ2l0IGEvZnMvc3F1YXNoZnMvTWFrZWZpbGUgYi9mcy9zcXVhc2hmcy9NYWtlZmlsZQppbmRleCA3NjcyYmFjLi5jZWNmMmJlIDEwMDY0NAotLS0gYS9mcy9zcXVhc2hmcy9NYWtlZmlsZQorKysgYi9mcy9zcXVhc2hmcy9NYWtlZmlsZQpAQCAtNywzICs3LDQgQEAKIHNxdWFzaGZzLXkgKz0gbmFtZWkubyBzdXBlci5vIHN5bWxpbmsubyB6bGliX3dyYXBwZXIubyBkZWNvbXByZXNzb3Iubwogc3F1YXNoZnMtJChDT05GSUdfU1FVQVNIRlNfWEFUVFIpICs9IHhhdHRyLm8geGF0dHJfaWQubwogc3F1YXNoZnMtJChDT05GSUdfU1FVQVNIRlNfTFpPKSArPSBsem9fd3JhcHBlci5vCitzcXVhc2hmcy0kKENPTkZJR19TUVVBU0hGU19YWikgKz0geHpfd3JhcHBlci5vCmRpZmYgLS1naXQgYS9mcy9zcXVhc2hmcy9ibG9jay5jIGIvZnMvc3F1YXNoZnMvYmxvY2suYwppbmRleCA2NTNjMDMwLi44YWI0OGJjIDEwMDY0NAotLS0gYS9mcy9zcXVhc2hmcy9ibG9jay5jCisrKyBiL2ZzL3NxdWFzaGZzL2Jsb2NrLmMKQEAgLTM0LDcgKzM0LDYgQEAKIAogI2luY2x1ZGUgInNxdWFzaGZzX2ZzLmgiCiAjaW5jbHVkZSAic3F1YXNoZnNfZnNfc2IuaCIKLSNpbmNsdWRlICJzcXVhc2hmc19mc19pLmgiCiAjaW5jbHVkZSAic3F1YXNoZnMuaCIKICNpbmNsdWRlICJkZWNvbXByZXNzb3IuaCIKIApAQCAtNjQsNiArNjMsMTQgQEAKIAkJKmxlbmd0aCA9ICh1bnNpZ25lZCBjaGFyKSBiaC0+Yl9kYXRhWypvZmZzZXRdIHwKIAkJCSh1bnNpZ25lZCBjaGFyKSBiaC0+Yl9kYXRhWypvZmZzZXQgKyAxXSA8PCA4OwogCQkqb2Zmc2V0ICs9IDI7CisKKwkJaWYgKCpvZmZzZXQgPT0gbXNibGstPmRldmJsa3NpemUpIHsKKwkJCXB1dF9iaChiaCk7CisJCQliaCA9IHNiX2JyZWFkKHNiLCArKygqY3VyX2luZGV4KSk7CisJCQlpZiAoYmggPT0gTlVMTCkKKwkJCQlyZXR1cm4gTlVMTDsKKwkJCSpvZmZzZXQgPSAwOworCQl9CiAJfQogCiAJcmV0dXJuIGJoOwpkaWZmIC0tZ2l0IGEvZnMvc3F1YXNoZnMvY2FjaGUuYyBiL2ZzL3NxdWFzaGZzL2NhY2hlLmMKaW5kZXggNTczMTRiZS4uMjZiMTVhZSAxMDA2NDQKLS0tIGEvZnMvc3F1YXNoZnMvY2FjaGUuYworKysgYi9mcy9zcXVhc2hmcy9jYWNoZS5jCkBAIC01NSw3ICs1NSw2IEBACiAKICNpbmNsdWRlICJzcXVhc2hmc19mcy5oIgogI2luY2x1ZGUgInNxdWFzaGZzX2ZzX3NiLmgiCi0jaW5jbHVkZSAic3F1YXNoZnNfZnNfaS5oIgogI2luY2x1ZGUgInNxdWFzaGZzLmgiCiAKIC8qCmRpZmYgLS1naXQgYS9mcy9zcXVhc2hmcy9kZWNvbXByZXNzb3IuYyBiL2ZzL3NxdWFzaGZzL2RlY29tcHJlc3Nvci5jCmluZGV4IDI0YWY5Y2UuLmE1OTQwZTUgMTAwNjQ0Ci0tLSBhL2ZzL3NxdWFzaGZzL2RlY29tcHJlc3Nvci5jCisrKyBiL2ZzL3NxdWFzaGZzL2RlY29tcHJlc3Nvci5jCkBAIC0yNyw3ICsyNyw2IEBACiAKICNpbmNsdWRlICJzcXVhc2hmc19mcy5oIgogI2luY2x1ZGUgInNxdWFzaGZzX2ZzX3NiLmgiCi0jaW5jbHVkZSAic3F1YXNoZnNfZnNfaS5oIgogI2luY2x1ZGUgImRlY29tcHJlc3Nvci5oIgogI2luY2x1ZGUgInNxdWFzaGZzLmgiCiAKQEAgLTQxLDIzICs0MCwyNiBAQAogfTsKIAogI2lmbmRlZiBDT05GSUdfU1FVQVNIRlNfTFpPCi1zdGF0aWMgY29uc3Qgc3RydWN0IHNxdWFzaGZzX2RlY29tcHJlc3NvciBzcXVhc2hmc19sem9fdW5zdXBwb3J0ZWRfY29tcF9vcHMgPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHNxdWFzaGZzX2RlY29tcHJlc3NvciBzcXVhc2hmc19sem9fY29tcF9vcHMgPSB7CiAJTlVMTCwgTlVMTCwgTlVMTCwgTFpPX0NPTVBSRVNTSU9OLCAibHpvIiwgMAogfTsKICNlbmRpZgogCisjaWZuZGVmIENPTkZJR19TUVVBU0hGU19YWgorc3RhdGljIGNvbnN0IHN0cnVjdCBzcXVhc2hmc19kZWNvbXByZXNzb3Igc3F1YXNoZnNfeHpfY29tcF9vcHMgPSB7CisJTlVMTCwgTlVMTCwgTlVMTCwgWFpfQ09NUFJFU1NJT04sICJ4eiIsIDAKK307CisjZW5kaWYKKwogc3RhdGljIGNvbnN0IHN0cnVjdCBzcXVhc2hmc19kZWNvbXByZXNzb3Igc3F1YXNoZnNfdW5rbm93bl9jb21wX29wcyA9IHsKIAlOVUxMLCBOVUxMLCBOVUxMLCAwLCAidW5rbm93biIsIDAKIH07CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgc3F1YXNoZnNfZGVjb21wcmVzc29yICpkZWNvbXByZXNzb3JbXSA9IHsKIAkmc3F1YXNoZnNfemxpYl9jb21wX29wcywKLQkmc3F1YXNoZnNfbHptYV91bnN1cHBvcnRlZF9jb21wX29wcywKLSNpZmRlZiBDT05GSUdfU1FVQVNIRlNfTFpPCiAJJnNxdWFzaGZzX2x6b19jb21wX29wcywKLSNlbHNlCi0JJnNxdWFzaGZzX2x6b191bnN1cHBvcnRlZF9jb21wX29wcywKLSNlbmRpZgorCSZzcXVhc2hmc194el9jb21wX29wcywKKwkmc3F1YXNoZnNfbHptYV91bnN1cHBvcnRlZF9jb21wX29wcywKIAkmc3F1YXNoZnNfdW5rbm93bl9jb21wX29wcwogfTsKIApkaWZmIC0tZ2l0IGEvZnMvc3F1YXNoZnMvZGVjb21wcmVzc29yLmggYi9mcy9zcXVhc2hmcy9kZWNvbXByZXNzb3IuaAppbmRleCA3NDI1ZjgwLi4zYjMwNWE3IDEwMDY0NAotLS0gYS9mcy9zcXVhc2hmcy9kZWNvbXByZXNzb3IuaAorKysgYi9mcy9zcXVhc2hmcy9kZWNvbXByZXNzb3IuaApAQCAtNTIsNCArNTIsMTMgQEAKIAlyZXR1cm4gbXNibGstPmRlY29tcHJlc3Nvci0+ZGVjb21wcmVzcyhtc2JsaywgYnVmZmVyLCBiaCwgYiwgb2Zmc2V0LAogCQlsZW5ndGgsIHNyY2xlbmd0aCwgcGFnZXMpOwogfQorCisjaWZkZWYgQ09ORklHX1NRVUFTSEZTX1haCitleHRlcm4gY29uc3Qgc3RydWN0IHNxdWFzaGZzX2RlY29tcHJlc3NvciBzcXVhc2hmc194el9jb21wX29wczsKKyNlbmRpZgorCisjaWZkZWYgQ09ORklHX1NRVUFTSEZTX0xaTworZXh0ZXJuIGNvbnN0IHN0cnVjdCBzcXVhc2hmc19kZWNvbXByZXNzb3Igc3F1YXNoZnNfbHpvX2NvbXBfb3BzOworI2VuZGlmCisKICNlbmRpZgpkaWZmIC0tZ2l0IGEvZnMvc3F1YXNoZnMvZnJhZ21lbnQuYyBiL2ZzL3NxdWFzaGZzL2ZyYWdtZW50LmMKaW5kZXggN2M5MGJiZC4uN2VlZjU3MSAxMDA2NDQKLS0tIGEvZnMvc3F1YXNoZnMvZnJhZ21lbnQuYworKysgYi9mcy9zcXVhc2hmcy9mcmFnbWVudC5jCkBAIC0zOSw3ICszOSw2IEBACiAKICNpbmNsdWRlICJzcXVhc2hmc19mcy5oIgogI2luY2x1ZGUgInNxdWFzaGZzX2ZzX3NiLmgiCi0jaW5jbHVkZSAic3F1YXNoZnNfZnNfaS5oIgogI2luY2x1ZGUgInNxdWFzaGZzLmgiCiAKIC8qCmRpZmYgLS1naXQgYS9mcy9zcXVhc2hmcy9pZC5jIGIvZnMvc3F1YXNoZnMvaWQuYwppbmRleCBiN2Y2NGJjLi5kOGYzMjQ1IDEwMDY0NAotLS0gYS9mcy9zcXVhc2hmcy9pZC5jCisrKyBiL2ZzL3NxdWFzaGZzL2lkLmMKQEAgLTM3LDcgKzM3LDYgQEAKIAogI2luY2x1ZGUgInNxdWFzaGZzX2ZzLmgiCiAjaW5jbHVkZSAic3F1YXNoZnNfZnNfc2IuaCIKLSNpbmNsdWRlICJzcXVhc2hmc19mc19pLmgiCiAjaW5jbHVkZSAic3F1YXNoZnMuaCIKIAogLyoKZGlmZiAtLWdpdCBhL2ZzL3NxdWFzaGZzL2x6b193cmFwcGVyLmMgYi9mcy9zcXVhc2hmcy9sem9fd3JhcHBlci5jCmluZGV4IDVkODc3ODkuLjdkYTc1OWUgMTAwNjQ0Ci0tLSBhL2ZzL3NxdWFzaGZzL2x6b193cmFwcGVyLmMKKysrIGIvZnMvc3F1YXNoZnMvbHpvX3dyYXBwZXIuYwpAQCAtMjksNyArMjksNiBAQAogCiAjaW5jbHVkZSAic3F1YXNoZnNfZnMuaCIKICNpbmNsdWRlICJzcXVhc2hmc19mc19zYi5oIgotI2luY2x1ZGUgInNxdWFzaGZzX2ZzX2kuaCIKICNpbmNsdWRlICJzcXVhc2hmcy5oIgogI2luY2x1ZGUgImRlY29tcHJlc3Nvci5oIgogCmRpZmYgLS1naXQgYS9mcy9zcXVhc2hmcy9zcXVhc2hmcy5oIGIvZnMvc3F1YXNoZnMvc3F1YXNoZnMuaAppbmRleCA1ZDQ1NTY5Li5iYTcyOWQ4IDEwMDY0NAotLS0gYS9mcy9zcXVhc2hmcy9zcXVhc2hmcy5oCisrKyBiL2ZzL3NxdWFzaGZzL3NxdWFzaGZzLmgKQEAgLTI3LDExICsyNyw2IEBACiAKICNkZWZpbmUgV0FSTklORyhzLCBhcmdzLi4uKQlwcl93YXJuaW5nKCJTUVVBU0hGUzogInMsICMjIGFyZ3MpCiAKLXN0YXRpYyBpbmxpbmUgc3RydWN0IHNxdWFzaGZzX2lub2RlX2luZm8gKnNxdWFzaGZzX2koc3RydWN0IGlub2RlICppbm9kZSkKLXsKLQlyZXR1cm4gbGlzdF9lbnRyeShpbm9kZSwgc3RydWN0IHNxdWFzaGZzX2lub2RlX2luZm8sIHZmc19pbm9kZSk7Ci19Ci0KIC8qIGJsb2NrLmMgKi8KIGV4dGVybiBpbnQgc3F1YXNoZnNfcmVhZF9kYXRhKHN0cnVjdCBzdXBlcl9ibG9jayAqLCB2b2lkICoqLCB1NjQsIGludCwgdTY0ICosCiAJCQkJaW50LCBpbnQpOwpAQCAtMTA0LDYgKzk5LDMgQEAKIAogLyogemxpYl93cmFwcGVyLmMgKi8KIGV4dGVybiBjb25zdCBzdHJ1Y3Qgc3F1YXNoZnNfZGVjb21wcmVzc29yIHNxdWFzaGZzX3psaWJfY29tcF9vcHM7Ci0KLS8qIGx6b193cmFwcGVyLmMgKi8KLWV4dGVybiBjb25zdCBzdHJ1Y3Qgc3F1YXNoZnNfZGVjb21wcmVzc29yIHNxdWFzaGZzX2x6b19jb21wX29wczsKZGlmZiAtLWdpdCBhL2ZzL3NxdWFzaGZzL3NxdWFzaGZzX2ZzLmggYi9mcy9zcXVhc2hmcy9zcXVhc2hmc19mcy5oCmluZGV4IGM1MTM3ZmMuLjM5NTMzZmUgMTAwNjQ0Ci0tLSBhL2ZzL3NxdWFzaGZzL3NxdWFzaGZzX2ZzLmgKKysrIGIvZnMvc3F1YXNoZnMvc3F1YXNoZnNfZnMuaApAQCAtMjM4LDYgKzIzOCw3IEBACiAjZGVmaW5lIFpMSUJfQ09NUFJFU1NJT04JMQogI2RlZmluZSBMWk1BX0NPTVBSRVNTSU9OCTIKICNkZWZpbmUgTFpPX0NPTVBSRVNTSU9OCQkzCisjZGVmaW5lIFhaX0NPTVBSRVNTSU9OCQk0CiAKIHN0cnVjdCBzcXVhc2hmc19zdXBlcl9ibG9jayB7CiAJX19sZTMyCQkJc19tYWdpYzsKZGlmZiAtLWdpdCBhL2ZzL3NxdWFzaGZzL3NxdWFzaGZzX2ZzX2kuaCBiL2ZzL3NxdWFzaGZzL3NxdWFzaGZzX2ZzX2kuaAppbmRleCBkM2UzYTM3Li4zNTliYWVmIDEwMDY0NAotLS0gYS9mcy9zcXVhc2hmcy9zcXVhc2hmc19mc19pLmgKKysrIGIvZnMvc3F1YXNoZnMvc3F1YXNoZnNfZnNfaS5oCkBAIC00NSw0ICs0NSwxMCBAQAogCX07CiAJc3RydWN0IGlub2RlCXZmc19pbm9kZTsKIH07CisKKworc3RhdGljIGlubGluZSBzdHJ1Y3Qgc3F1YXNoZnNfaW5vZGVfaW5mbyAqc3F1YXNoZnNfaShzdHJ1Y3QgaW5vZGUgKmlub2RlKQoreworCXJldHVybiBsaXN0X2VudHJ5KGlub2RlLCBzdHJ1Y3Qgc3F1YXNoZnNfaW5vZGVfaW5mbywgdmZzX2lub2RlKTsKK30KICNlbmRpZgpkaWZmIC0tZ2l0IGEvZnMvc3F1YXNoZnMveGF0dHJfaWQuYyBiL2ZzL3NxdWFzaGZzL3hhdHRyX2lkLmMKaW5kZXggZDMzYmU1ZC4uMDUzODVkYiAxMDA2NDQKLS0tIGEvZnMvc3F1YXNoZnMveGF0dHJfaWQuYworKysgYi9mcy9zcXVhc2hmcy94YXR0cl9pZC5jCkBAIC0zMiw3ICszMiw2IEBACiAKICNpbmNsdWRlICJzcXVhc2hmc19mcy5oIgogI2luY2x1ZGUgInNxdWFzaGZzX2ZzX3NiLmgiCi0jaW5jbHVkZSAic3F1YXNoZnNfZnNfaS5oIgogI2luY2x1ZGUgInNxdWFzaGZzLmgiCiAjaW5jbHVkZSAieGF0dHIuaCIKIApkaWZmIC0tZ2l0IGEvZnMvc3F1YXNoZnMveHpfd3JhcHBlci5jIGIvZnMvc3F1YXNoZnMveHpfd3JhcHBlci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmM0ZWI0MDAKLS0tIC9kZXYvbnVsbAorKysgYi9mcy9zcXVhc2hmcy94el93cmFwcGVyLmMKQEAgLTAsMCArMSwxNDcgQEAKKy8qCisgKiBTcXVhc2hmcyAtIGEgY29tcHJlc3NlZCByZWFkIG9ubHkgZmlsZXN5c3RlbSBmb3IgTGludXgKKyAqCisgKiBDb3B5cmlnaHQgKGMpIDIwMDIsIDIwMDMsIDIwMDQsIDIwMDUsIDIwMDYsIDIwMDcsIDIwMDgsIDIwMDksIDIwMTAKKyAqIFBoaWxsaXAgTG91Z2hlciA8cGhpbGxpcEBsb3VnaGVyLmRlbW9uLmNvLnVrPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwKKyAqIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZvdW5kYXRpb24sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICoKKyAqIHh6X3dyYXBwZXIuYworICovCisKKworI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+CisjaW5jbHVkZSA8bGludXgvYnVmZmVyX2hlYWQuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgveHouaD4KKworI2luY2x1ZGUgInNxdWFzaGZzX2ZzLmgiCisjaW5jbHVkZSAic3F1YXNoZnNfZnNfc2IuaCIKKyNpbmNsdWRlICJzcXVhc2hmc19mc19pLmgiCisjaW5jbHVkZSAic3F1YXNoZnMuaCIKKyNpbmNsdWRlICJkZWNvbXByZXNzb3IuaCIKKworc3RydWN0IHNxdWFzaGZzX3h6IHsKKwlzdHJ1Y3QgeHpfZGVjICpzdGF0ZTsKKwlzdHJ1Y3QgeHpfYnVmIGJ1ZjsKK307CisKK3N0YXRpYyB2b2lkICpzcXVhc2hmc194el9pbml0KHN0cnVjdCBzcXVhc2hmc19zYl9pbmZvICptc2JsaykKK3sKKwlpbnQgYmxvY2tfc2l6ZSA9IG1heF90KGludCwgbXNibGstPmJsb2NrX3NpemUsIFNRVUFTSEZTX01FVEFEQVRBX1NJWkUpOworCisJc3RydWN0IHNxdWFzaGZzX3h6ICpzdHJlYW0gPSBrbWFsbG9jKHNpemVvZigqc3RyZWFtKSwgR0ZQX0tFUk5FTCk7CisJaWYgKHN0cmVhbSA9PSBOVUxMKQorCQlnb3RvIGZhaWxlZDsKKworCXN0cmVhbS0+c3RhdGUgPSB4el9kZWNfaW5pdChYWl9QUkVBTExPQywgYmxvY2tfc2l6ZSk7CisJaWYgKHN0cmVhbS0+c3RhdGUgPT0gTlVMTCkKKwkJZ290byBmYWlsZWQ7CisKKwlyZXR1cm4gc3RyZWFtOworCitmYWlsZWQ6CisJRVJST1IoIkZhaWxlZCB0byBhbGxvY2F0ZSB4eiB3b3Jrc3BhY2VcbiIpOworCWtmcmVlKHN0cmVhbSk7CisJcmV0dXJuIE5VTEw7Cit9CisKKworc3RhdGljIHZvaWQgc3F1YXNoZnNfeHpfZnJlZSh2b2lkICpzdHJtKQoreworCXN0cnVjdCBzcXVhc2hmc194eiAqc3RyZWFtID0gc3RybTsKKworCWlmIChzdHJlYW0pIHsKKwkJeHpfZGVjX2VuZChzdHJlYW0tPnN0YXRlKTsKKwkJa2ZyZWUoc3RyZWFtKTsKKwl9Cit9CisKKworc3RhdGljIGludCBzcXVhc2hmc194el91bmNvbXByZXNzKHN0cnVjdCBzcXVhc2hmc19zYl9pbmZvICptc2Jsaywgdm9pZCAqKmJ1ZmZlciwKKwlzdHJ1Y3QgYnVmZmVyX2hlYWQgKipiaCwgaW50IGIsIGludCBvZmZzZXQsIGludCBsZW5ndGgsIGludCBzcmNsZW5ndGgsCisJaW50IHBhZ2VzKQoreworCWVudW0geHpfcmV0IHh6X2VycjsKKwlpbnQgYXZhaWwsIHRvdGFsID0gMCwgayA9IDAsIHBhZ2UgPSAwOworCXN0cnVjdCBzcXVhc2hmc194eiAqc3RyZWFtID0gbXNibGstPnN0cmVhbTsKKworCW11dGV4X2xvY2soJm1zYmxrLT5yZWFkX2RhdGFfbXV0ZXgpOworCisJeHpfZGVjX3Jlc2V0KHN0cmVhbS0+c3RhdGUpOworCXN0cmVhbS0+YnVmLmluX3BvcyA9IDA7CisJc3RyZWFtLT5idWYuaW5fc2l6ZSA9IDA7CisJc3RyZWFtLT5idWYub3V0X3BvcyA9IDA7CisJc3RyZWFtLT5idWYub3V0X3NpemUgPSBQQUdFX0NBQ0hFX1NJWkU7CisJc3RyZWFtLT5idWYub3V0ID0gYnVmZmVyW3BhZ2UrK107CisKKwlkbyB7CisJCWlmIChzdHJlYW0tPmJ1Zi5pbl9wb3MgPT0gc3RyZWFtLT5idWYuaW5fc2l6ZSAmJiBrIDwgYikgeworCQkJYXZhaWwgPSBtaW4obGVuZ3RoLCBtc2Jsay0+ZGV2Ymxrc2l6ZSAtIG9mZnNldCk7CisJCQlsZW5ndGggLT0gYXZhaWw7CisJCQl3YWl0X29uX2J1ZmZlcihiaFtrXSk7CisJCQlpZiAoIWJ1ZmZlcl91cHRvZGF0ZShiaFtrXSkpCisJCQkJZ290byByZWxlYXNlX211dGV4OworCisJCQlzdHJlYW0tPmJ1Zi5pbiA9IGJoW2tdLT5iX2RhdGEgKyBvZmZzZXQ7CisJCQlzdHJlYW0tPmJ1Zi5pbl9zaXplID0gYXZhaWw7CisJCQlzdHJlYW0tPmJ1Zi5pbl9wb3MgPSAwOworCQkJb2Zmc2V0ID0gMDsKKwkJfQorCisJCWlmIChzdHJlYW0tPmJ1Zi5vdXRfcG9zID09IHN0cmVhbS0+YnVmLm91dF9zaXplCisJCQkJCQkJJiYgcGFnZSA8IHBhZ2VzKSB7CisJCQlzdHJlYW0tPmJ1Zi5vdXQgPSBidWZmZXJbcGFnZSsrXTsKKwkJCXN0cmVhbS0+YnVmLm91dF9wb3MgPSAwOworCQkJdG90YWwgKz0gUEFHRV9DQUNIRV9TSVpFOworCQl9CisKKwkJeHpfZXJyID0geHpfZGVjX3J1bihzdHJlYW0tPnN0YXRlLCAmc3RyZWFtLT5idWYpOworCisJCWlmIChzdHJlYW0tPmJ1Zi5pbl9wb3MgPT0gc3RyZWFtLT5idWYuaW5fc2l6ZSAmJiBrIDwgYikKKwkJCXB1dF9iaChiaFtrKytdKTsKKwl9IHdoaWxlICh4el9lcnIgPT0gWFpfT0spOworCisJaWYgKHh6X2VyciAhPSBYWl9TVFJFQU1fRU5EKSB7CisJCUVSUk9SKCJ4el9kZWNfcnVuIGVycm9yLCBkYXRhIHByb2JhYmx5IGNvcnJ1cHRcbiIpOworCQlnb3RvIHJlbGVhc2VfbXV0ZXg7CisJfQorCisJaWYgKGsgPCBiKSB7CisJCUVSUk9SKCJ4el91bmNvbXByZXNzIGVycm9yLCBpbnB1dCByZW1haW5pbmdcbiIpOworCQlnb3RvIHJlbGVhc2VfbXV0ZXg7CisJfQorCisJdG90YWwgKz0gc3RyZWFtLT5idWYub3V0X3BvczsKKwltdXRleF91bmxvY2soJm1zYmxrLT5yZWFkX2RhdGFfbXV0ZXgpOworCXJldHVybiB0b3RhbDsKKworcmVsZWFzZV9tdXRleDoKKwltdXRleF91bmxvY2soJm1zYmxrLT5yZWFkX2RhdGFfbXV0ZXgpOworCisJZm9yICg7IGsgPCBiOyBrKyspCisJCXB1dF9iaChiaFtrXSk7CisKKwlyZXR1cm4gLUVJTzsKK30KKworY29uc3Qgc3RydWN0IHNxdWFzaGZzX2RlY29tcHJlc3NvciBzcXVhc2hmc194el9jb21wX29wcyA9IHsKKwkuaW5pdCA9IHNxdWFzaGZzX3h6X2luaXQsCisJLmZyZWUgPSBzcXVhc2hmc194el9mcmVlLAorCS5kZWNvbXByZXNzID0gc3F1YXNoZnNfeHpfdW5jb21wcmVzcywKKwkuaWQgPSBYWl9DT01QUkVTU0lPTiwKKwkubmFtZSA9ICJ4eiIsCisJLnN1cHBvcnRlZCA9IDEKK307CmRpZmYgLS1naXQgYS9mcy9zcXVhc2hmcy96bGliX3dyYXBwZXIuYyBiL2ZzL3NxdWFzaGZzL3psaWJfd3JhcHBlci5jCmluZGV4IDdhNjAzODcuLjQ2NjFhZTIgMTAwNjQ0Ci0tLSBhL2ZzL3NxdWFzaGZzL3psaWJfd3JhcHBlci5jCisrKyBiL2ZzL3NxdWFzaGZzL3psaWJfd3JhcHBlci5jCkBAIC0yOSw3ICsyOSw2IEBACiAKICNpbmNsdWRlICJzcXVhc2hmc19mcy5oIgogI2luY2x1ZGUgInNxdWFzaGZzX2ZzX3NiLmgiCi0jaW5jbHVkZSAic3F1YXNoZnNfZnNfaS5oIgogI2luY2x1ZGUgInNxdWFzaGZzLmgiCiAjaW5jbHVkZSAiZGVjb21wcmVzc29yLmgiCiAKQEAgLTY2LDggKzY1LDggQEAKIAlzdHJ1Y3QgYnVmZmVyX2hlYWQgKipiaCwgaW50IGIsIGludCBvZmZzZXQsIGludCBsZW5ndGgsIGludCBzcmNsZW5ndGgsCiAJaW50IHBhZ2VzKQogewotCWludCB6bGliX2VyciA9IDAsIHpsaWJfaW5pdCA9IDA7Ci0JaW50IGF2YWlsLCBieXRlcywgayA9IDAsIHBhZ2UgPSAwOworCWludCB6bGliX2VyciwgemxpYl9pbml0ID0gMDsKKwlpbnQgayA9IDAsIHBhZ2UgPSAwOwogCXpfc3RyZWFtICpzdHJlYW0gPSBtc2Jsay0+c3RyZWFtOwogCiAJbXV0ZXhfbG9jaygmbXNibGstPnJlYWRfZGF0YV9tdXRleCk7CkBAIC03NSwyMSArNzQsMTQgQEAKIAlzdHJlYW0tPmF2YWlsX291dCA9IDA7CiAJc3RyZWFtLT5hdmFpbF9pbiA9IDA7CiAKLQlieXRlcyA9IGxlbmd0aDsKIAlkbyB7CiAJCWlmIChzdHJlYW0tPmF2YWlsX2luID09IDAgJiYgayA8IGIpIHsKLQkJCWF2YWlsID0gbWluKGJ5dGVzLCBtc2Jsay0+ZGV2Ymxrc2l6ZSAtIG9mZnNldCk7Ci0JCQlieXRlcyAtPSBhdmFpbDsKKwkJCWludCBhdmFpbCA9IG1pbihsZW5ndGgsIG1zYmxrLT5kZXZibGtzaXplIC0gb2Zmc2V0KTsKKwkJCWxlbmd0aCAtPSBhdmFpbDsKIAkJCXdhaXRfb25fYnVmZmVyKGJoW2tdKTsKIAkJCWlmICghYnVmZmVyX3VwdG9kYXRlKGJoW2tdKSkKIAkJCQlnb3RvIHJlbGVhc2VfbXV0ZXg7CiAKLQkJCWlmIChhdmFpbCA9PSAwKSB7Ci0JCQkJb2Zmc2V0ID0gMDsKLQkJCQlwdXRfYmgoYmhbaysrXSk7Ci0JCQkJY29udGludWU7Ci0JCQl9Ci0KIAkJCXN0cmVhbS0+bmV4dF9pbiA9IGJoW2tdLT5iX2RhdGEgKyBvZmZzZXQ7CiAJCQlzdHJlYW0tPmF2YWlsX2luID0gYXZhaWw7CiAJCQlvZmZzZXQgPSAwOwpAQCAtMTI4LDYgKzEyMCwxMSBAQAogCQlnb3RvIHJlbGVhc2VfbXV0ZXg7CiAJfQogCisJaWYgKGsgPCBiKSB7CisJCUVSUk9SKCJ6bGliX3VuY29tcHJlc3MgZXJyb3IsIGRhdGEgcmVtYWluaW5nXG4iKTsKKwkJZ290byByZWxlYXNlX211dGV4OworCX0KKwogCWxlbmd0aCA9IHN0cmVhbS0+dG90YWxfb3V0OwogCW11dGV4X3VubG9jaygmbXNibGstPnJlYWRfZGF0YV9tdXRleCk7CiAJcmV0dXJuIGxlbmd0aDsKZGlmZiAtLWdpdCBhL2ZzL3N0YXQuYyBiL2ZzL3N0YXQuYwppbmRleCAxMmU5MGUyLi5kNWM2MWNmIDEwMDY0NAotLS0gYS9mcy9zdGF0LmMKKysrIGIvZnMvc3RhdC5jCkBAIC03NSwxMSArNzUsMTMgQEAKIAlpbnQgZXJyb3IgPSAtRUlOVkFMOwogCWludCBsb29rdXBfZmxhZ3MgPSAwOwogCi0JaWYgKChmbGFnICYgfkFUX1NZTUxJTktfTk9GT0xMT1cpICE9IDApCisJaWYgKChmbGFnICYgfihBVF9TWU1MSU5LX05PRk9MTE9XIHwgQVRfTk9fQVVUT01PVU5UKSkgIT0gMCkKIAkJZ290byBvdXQ7CiAKIAlpZiAoIShmbGFnICYgQVRfU1lNTElOS19OT0ZPTExPVykpCiAJCWxvb2t1cF9mbGFncyB8PSBMT09LVVBfRk9MTE9XOworCWlmIChmbGFnICYgQVRfTk9fQVVUT01PVU5UKQorCQlsb29rdXBfZmxhZ3MgfD0gTE9PS1VQX05PX0FVVE9NT1VOVDsKIAogCWVycm9yID0gdXNlcl9wYXRoX2F0KGRmZCwgZmlsZW5hbWUsIGxvb2t1cF9mbGFncywgJnBhdGgpOwogCWlmIChlcnJvcikKZGlmZiAtLWdpdCBhL2ZzL3N1cGVyLmMgYi9mcy9zdXBlci5jCmluZGV4IDRmNmEzNTcuLjdlOWRkNGMgMTAwNjQ0Ci0tLSBhL2ZzL3N1cGVyLmMKKysrIGIvZnMvc3VwZXIuYwpAQCAtMTc3LDYgKzE3NywxMSBAQAogCXN0cnVjdCBmaWxlX3N5c3RlbV90eXBlICpmcyA9IHMtPnNfdHlwZTsKIAlpZiAoYXRvbWljX2RlY19hbmRfdGVzdCgmcy0+c19hY3RpdmUpKSB7CiAJCWZzLT5raWxsX3NiKHMpOworCQkvKgorCQkgKiBXZSBuZWVkIHRvIGNhbGwgcmN1X2JhcnJpZXIgc28gYWxsIHRoZSBkZWxheWVkIHJjdSBmcmVlCisJCSAqIGlub2RlcyBhcmUgZmx1c2hlZCBiZWZvcmUgd2UgcmVsZWFzZSB0aGUgZnMgbW9kdWxlLgorCQkgKi8KKwkJcmN1X2JhcnJpZXIoKTsKIAkJcHV0X2ZpbGVzeXN0ZW0oZnMpOwogCQlwdXRfc3VwZXIocyk7CiAJfSBlbHNlIHsKQEAgLTExNDEsNyArMTE0Niw3IEBACiAJcmV0dXJuIG1udDsKIAogIGVycjoKLQltbnRwdXRfbG9uZyhtbnQpOworCW1udHB1dChtbnQpOwogCXJldHVybiBFUlJfUFRSKGVycik7CiB9CiAKZGlmZiAtLWdpdCBhL2ZzL3N5c2ZzL0tjb25maWcgYi9mcy9zeXNmcy9LY29uZmlnCmluZGV4IGY0YjY3NTguLjhjNDFmZWEgMTAwNjQ0Ci0tLSBhL2ZzL3N5c2ZzL0tjb25maWcKKysrIGIvZnMvc3lzZnMvS2NvbmZpZwpAQCAtMSw1ICsxLDUgQEAKIGNvbmZpZyBTWVNGUwotCWJvb2wgInN5c2ZzIGZpbGUgc3lzdGVtIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAic3lzZnMgZmlsZSBzeXN0ZW0gc3VwcG9ydCIgaWYgRVhQRVJUCiAJZGVmYXVsdCB5CiAJaGVscAogCVRoZSBzeXNmcyBmaWxlc3lzdGVtIGlzIGEgdmlydHVhbCBmaWxlc3lzdGVtIHRoYXQgdGhlIGtlcm5lbCB1c2VzIHRvCmRpZmYgLS1naXQgYS9mcy94ZnMvTWFrZWZpbGUgYi9mcy94ZnMvTWFrZWZpbGUKaW5kZXggMGRjZTk2OS4uZmFjYTQ0OSAxMDA2NDQKLS0tIGEvZnMveGZzL01ha2VmaWxlCisrKyBiL2ZzL3hmcy9NYWtlZmlsZQpAQCAtOTgsNiArOTgsNyBAQAogCQkJCSAgIGttZW0ubyBcCiAJCQkJICAgeGZzX2FvcHMubyBcCiAJCQkJICAgeGZzX2J1Zi5vIFwKKwkJCQkgICB4ZnNfZGlzY2FyZC5vIFwKIAkJCQkgICB4ZnNfZXhwb3J0Lm8gXAogCQkJCSAgIHhmc19maWxlLm8gXAogCQkJCSAgIHhmc19mc19zdWJyLm8gXApkaWZmIC0tZ2l0IGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfYnVmLmMgYi9mcy94ZnMvbGludXgtMi42L3hmc19idWYuYwppbmRleCA5MmYxZjJhLi5hYzFjN2U4IDEwMDY0NAotLS0gYS9mcy94ZnMvbGludXgtMi42L3hmc19idWYuYworKysgYi9mcy94ZnMvbGludXgtMi42L3hmc19idWYuYwpAQCAtODk2LDcgKzg5Niw2IEBACiAJdHJhY2VfeGZzX2J1Zl9yZWxlKGJwLCBfUkVUX0lQXyk7CiAKIAlpZiAoIXBhZykgewotCQlBU1NFUlQoIWJwLT5iX3JlbHNlKTsKIAkJQVNTRVJUKGxpc3RfZW1wdHkoJmJwLT5iX2xydSkpOwogCQlBU1NFUlQoUkJfRU1QVFlfTk9ERSgmYnAtPmJfcmJub2RlKSk7CiAJCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZicC0+Yl9ob2xkKSkKQEAgLTkwOCwxMSArOTA3LDcgQEAKIAogCUFTU0VSVChhdG9taWNfcmVhZCgmYnAtPmJfaG9sZCkgPiAwKTsKIAlpZiAoYXRvbWljX2RlY19hbmRfbG9jaygmYnAtPmJfaG9sZCwgJnBhZy0+cGFnX2J1Zl9sb2NrKSkgewotCQlpZiAoYnAtPmJfcmVsc2UpIHsKLQkJCWF0b21pY19pbmMoJmJwLT5iX2hvbGQpOwotCQkJc3Bpbl91bmxvY2soJnBhZy0+cGFnX2J1Zl9sb2NrKTsKLQkJCWJwLT5iX3JlbHNlKGJwKTsKLQkJfSBlbHNlIGlmICghKGJwLT5iX2ZsYWdzICYgWEJGX1NUQUxFKSAmJgorCQlpZiAoIShicC0+Yl9mbGFncyAmIFhCRl9TVEFMRSkgJiYKIAkJCSAgIGF0b21pY19yZWFkKCZicC0+Yl9scnVfcmVmKSkgewogCQkJeGZzX2J1Zl9scnVfYWRkKGJwKTsKIAkJCXNwaW5fdW5sb2NrKCZwYWctPnBhZ19idWZfbG9jayk7CmRpZmYgLS1naXQgYS9mcy94ZnMvbGludXgtMi42L3hmc19idWYuaCBiL2ZzL3hmcy9saW51eC0yLjYveGZzX2J1Zi5oCmluZGV4IGE3NmMyNDIuLmNiZTY1OTUgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy9saW51eC0yLjYveGZzX2J1Zi5oCisrKyBiL2ZzL3hmcy9saW51eC0yLjYveGZzX2J1Zi5oCkBAIC0xNTIsOCArMTUyLDYgQEAKIAogc3RydWN0IHhmc19idWY7CiB0eXBlZGVmIHZvaWQgKCp4ZnNfYnVmX2lvZG9uZV90KShzdHJ1Y3QgeGZzX2J1ZiAqKTsKLXR5cGVkZWYgdm9pZCAoKnhmc19idWZfcmVsc2VfdCkoc3RydWN0IHhmc19idWYgKik7Ci10eXBlZGVmIGludCAoKnhmc19idWZfYmRzdHJhdF90KShzdHJ1Y3QgeGZzX2J1ZiAqKTsKIAogI2RlZmluZSBYQl9QQUdFUwkyCiAKQEAgLTE4Myw3ICsxODEsNiBAQAogCXZvaWQJCQkqYl9hZGRyOwkvKiB2aXJ0dWFsIGFkZHJlc3Mgb2YgYnVmZmVyICovCiAJc3RydWN0IHdvcmtfc3RydWN0CWJfaW9kb25lX3dvcms7CiAJeGZzX2J1Zl9pb2RvbmVfdAliX2lvZG9uZTsJLyogSS9PIGNvbXBsZXRpb24gZnVuY3Rpb24gKi8KLQl4ZnNfYnVmX3JlbHNlX3QJCWJfcmVsc2U7CS8qIHJlbGVhc2luZyBmdW5jdGlvbiAqLwogCXN0cnVjdCBjb21wbGV0aW9uCWJfaW93YWl0OwkvKiBxdWV1ZSBmb3IgSS9PIHdhaXRlcnMgKi8KIAl2b2lkCQkJKmJfZnNwcml2OwogCXZvaWQJCQkqYl9mc3ByaXYyOwpAQCAtMzIzLDcgKzMyMCw2IEBACiAjZGVmaW5lIFhGU19CVUZfRlNQUklWQVRFMihicCwgdHlwZSkJCSgodHlwZSkoYnApLT5iX2ZzcHJpdjIpCiAjZGVmaW5lIFhGU19CVUZfU0VUX0ZTUFJJVkFURTIoYnAsIHZhbCkJCSgoYnApLT5iX2ZzcHJpdjIgPSAodm9pZCopKHZhbCkpCiAjZGVmaW5lIFhGU19CVUZfU0VUX1NUQVJUKGJwKQkJCWRvIHsgfSB3aGlsZSAoMCkKLSNkZWZpbmUgWEZTX0JVRl9TRVRfQlJFTFNFX0ZVTkMoYnAsIGZ1bmMpCSgoYnApLT5iX3JlbHNlID0gKGZ1bmMpKQogCiAjZGVmaW5lIFhGU19CVUZfUFRSKGJwKQkJCSh4ZnNfY2FkZHJfdCkoKGJwKS0+Yl9hZGRyKQogI2RlZmluZSBYRlNfQlVGX1NFVF9QVFIoYnAsIHZhbCwgY250KQl4ZnNfYnVmX2Fzc29jaWF0ZV9tZW1vcnkoYnAsIHZhbCwgY250KQpAQCAtMzYwLDggKzM1Niw3IEBACiAKIHN0YXRpYyBpbmxpbmUgdm9pZCB4ZnNfYnVmX3JlbHNlKHhmc19idWZfdCAqYnApCiB7Ci0JaWYgKCFicC0+Yl9yZWxzZSkKLQkJeGZzX2J1Zl91bmxvY2soYnApOworCXhmc19idWZfdW5sb2NrKGJwKTsKIAl4ZnNfYnVmX3JlbGUoYnApOwogfQogCmRpZmYgLS1naXQgYS9mcy94ZnMvbGludXgtMi42L3hmc19kaXNjYXJkLmMgYi9mcy94ZnMvbGludXgtMi42L3hmc19kaXNjYXJkLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMDUyMDFhZQotLS0gL2Rldi9udWxsCisrKyBiL2ZzL3hmcy9saW51eC0yLjYveGZzX2Rpc2NhcmQuYwpAQCAtMCwwICsxLDE5MSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBSZWQgSGF0LCBJbmMuCisgKiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3b3VsZCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKKyAqIEluYy4sICA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICovCisjaW5jbHVkZSAieGZzLmgiCisjaW5jbHVkZSAieGZzX3NiLmgiCisjaW5jbHVkZSAieGZzX2ludW0uaCIKKyNpbmNsdWRlICJ4ZnNfbG9nLmgiCisjaW5jbHVkZSAieGZzX2FnLmgiCisjaW5jbHVkZSAieGZzX21vdW50LmgiCisjaW5jbHVkZSAieGZzX3F1b3RhLmgiCisjaW5jbHVkZSAieGZzX3RyYW5zLmgiCisjaW5jbHVkZSAieGZzX2FsbG9jX2J0cmVlLmgiCisjaW5jbHVkZSAieGZzX2JtYXBfYnRyZWUuaCIKKyNpbmNsdWRlICJ4ZnNfaWFsbG9jX2J0cmVlLmgiCisjaW5jbHVkZSAieGZzX2J0cmVlLmgiCisjaW5jbHVkZSAieGZzX2lub2RlLmgiCisjaW5jbHVkZSAieGZzX2FsbG9jLmgiCisjaW5jbHVkZSAieGZzX2Vycm9yLmgiCisjaW5jbHVkZSAieGZzX2Rpc2NhcmQuaCIKKyNpbmNsdWRlICJ4ZnNfdHJhY2UuaCIKKworU1RBVElDIGludAoreGZzX3RyaW1fZXh0ZW50cygKKwlzdHJ1Y3QgeGZzX21vdW50CSptcCwKKwl4ZnNfYWdudW1iZXJfdAkJYWdubywKKwl4ZnNfZnNibG9ja190CQlzdGFydCwKKwl4ZnNfZnNibG9ja190CQlsZW4sCisJeGZzX2ZzYmxvY2tfdAkJbWlubGVuLAorCV9fdWludDY0X3QJCSpibG9ja3NfdHJpbW1lZCkKK3sKKwlzdHJ1Y3QgYmxvY2tfZGV2aWNlCSpiZGV2ID0gbXAtPm1fZGRldl90YXJncC0+YnRfYmRldjsKKwlzdHJ1Y3QgeGZzX2J0cmVlX2N1cgkqY3VyOworCXN0cnVjdCB4ZnNfYnVmCQkqYWdicDsKKwlzdHJ1Y3QgeGZzX3BlcmFnCSpwYWc7CisJaW50CQkJZXJyb3I7CisJaW50CQkJaTsKKworCXBhZyA9IHhmc19wZXJhZ19nZXQobXAsIGFnbm8pOworCisJZXJyb3IgPSB4ZnNfYWxsb2NfcmVhZF9hZ2YobXAsIE5VTEwsIGFnbm8sIDAsICZhZ2JwKTsKKwlpZiAoZXJyb3IgfHwgIWFnYnApCisJCWdvdG8gb3V0X3B1dF9wZXJhZzsKKworCWN1ciA9IHhmc19hbGxvY2J0X2luaXRfY3Vyc29yKG1wLCBOVUxMLCBhZ2JwLCBhZ25vLCBYRlNfQlROVU1fQ05UKTsKKworCS8qCisJICogRm9yY2Ugb3V0IHRoZSBsb2cuICBUaGlzIG1lYW5zIGFueSB0cmFuc2FjdGlvbnMgdGhhdCBtaWdodCBoYXZlIGZyZWVkCisJICogc3BhY2UgYmVmb3JlIHdlIHRvb2sgdGhlIEFHRiBidWZmZXIgbG9jayBhcmUgbm93IG9uIGRpc2ssIGFuZCB0aGUKKwkgKiB2b2xhdGlsZSBkaXNrIGNhY2hlIGlzIGZsdXNoZWQuCisJICovCisJeGZzX2xvZ19mb3JjZShtcCwgWEZTX0xPR19TWU5DKTsKKworCS8qCisJICogTG9vayB1cCB0aGUgbG9uZ2VzdCBidHJlZSBpbiB0aGUgQUdGIGFuZCBzdGFydCB3aXRoIGl0LgorCSAqLworCWVycm9yID0geGZzX2FsbG9jX2xvb2t1cF9sZShjdXIsIDAsCisJCQkJICAgIFhGU19CVUZfVE9fQUdGKGFnYnApLT5hZ2ZfbG9uZ2VzdCwgJmkpOworCWlmIChlcnJvcikKKwkJZ290byBvdXRfZGVsX2N1cnNvcjsKKworCS8qCisJICogTG9vcCB1bnRpbCB3ZSBhcmUgZG9uZSB3aXRoIGFsbCBleHRlbnRzIHRoYXQgYXJlIGxhcmdlCisJICogZW5vdWdoIHRvIGJlIHdvcnRoIGRpc2NhcmRpbmcuCisJICovCisJd2hpbGUgKGkpIHsKKwkJeGZzX2FnYmxvY2tfdCBmYm5vOworCQl4ZnNfZXh0bGVuX3QgZmxlbjsKKworCQllcnJvciA9IHhmc19hbGxvY19nZXRfcmVjKGN1ciwgJmZibm8sICZmbGVuLCAmaSk7CisJCWlmIChlcnJvcikKKwkJCWdvdG8gb3V0X2RlbF9jdXJzb3I7CisJCVhGU19XQU5UX0NPUlJVUFRFRF9HT1RPKGkgPT0gMSwgb3V0X2RlbF9jdXJzb3IpOworCQlBU1NFUlQoZmxlbiA8PSBYRlNfQlVGX1RPX0FHRihhZ2JwKS0+YWdmX2xvbmdlc3QpOworCisJCS8qCisJCSAqIFRvbyBzbWFsbD8gIEdpdmUgdXAuCisJCSAqLworCQlpZiAoZmxlbiA8IG1pbmxlbikgeworCQkJdHJhY2VfeGZzX2Rpc2NhcmRfdG9vc21hbGwobXAsIGFnbm8sIGZibm8sIGZsZW4pOworCQkJZ290byBvdXRfZGVsX2N1cnNvcjsKKwkJfQorCisJCS8qCisJCSAqIElmIHRoZSBleHRlbnQgaXMgZW50aXJlbHkgb3V0c2lkZSBvZiB0aGUgcmFuZ2Ugd2UgYXJlCisJCSAqIHN1cHBvc2VkIHRvIGRpc2NhcmQgc2tpcCBpdC4gIERvIG5vdCBib3RoZXIgdG8gdHJpbQorCQkgKiBkb3duIHBhcnRpYWxseSBvdmVybGFwcGluZyByYW5nZXMgZm9yIG5vdy4KKwkJICovCisJCWlmIChYRlNfQUdCX1RPX0ZTQihtcCwgYWdubywgZmJubykgKyBmbGVuIDwgc3RhcnQgfHwKKwkJICAgIFhGU19BR0JfVE9fRlNCKG1wLCBhZ25vLCBmYm5vKSA+PSBzdGFydCArIGxlbikgeworCQkJdHJhY2VfeGZzX2Rpc2NhcmRfZXhjbHVkZShtcCwgYWdubywgZmJubywgZmxlbik7CisJCQlnb3RvIG5leHRfZXh0ZW50OworCQl9CisKKwkJLyoKKwkJICogSWYgYW55IGJsb2NrcyBpbiB0aGUgcmFuZ2UgYXJlIHN0aWxsIGJ1c3ksIHNraXAgdGhlCisJCSAqIGRpc2NhcmQgYW5kIHRyeSBhZ2FpbiB0aGUgbmV4dCB0aW1lLgorCQkgKi8KKwkJaWYgKHhmc19hbGxvY19idXN5X3NlYXJjaChtcCwgYWdubywgZmJubywgZmxlbikpIHsKKwkJCXRyYWNlX3hmc19kaXNjYXJkX2J1c3kobXAsIGFnbm8sIGZibm8sIGZsZW4pOworCQkJZ290byBuZXh0X2V4dGVudDsKKwkJfQorCisJCXRyYWNlX3hmc19kaXNjYXJkX2V4dGVudChtcCwgYWdubywgZmJubywgZmxlbik7CisJCWVycm9yID0gLWJsa2Rldl9pc3N1ZV9kaXNjYXJkKGJkZXYsCisJCQkJWEZTX0FHQl9UT19EQUREUihtcCwgYWdubywgZmJubyksCisJCQkJWEZTX0ZTQl9UT19CQihtcCwgZmxlbiksCisJCQkJR0ZQX05PRlMsIDApOworCQlpZiAoZXJyb3IpCisJCQlnb3RvIG91dF9kZWxfY3Vyc29yOworCQkqYmxvY2tzX3RyaW1tZWQgKz0gZmxlbjsKKworbmV4dF9leHRlbnQ6CisJCWVycm9yID0geGZzX2J0cmVlX2RlY3JlbWVudChjdXIsIDAsICZpKTsKKwkJaWYgKGVycm9yKQorCQkJZ290byBvdXRfZGVsX2N1cnNvcjsKKwl9CisKK291dF9kZWxfY3Vyc29yOgorCXhmc19idHJlZV9kZWxfY3Vyc29yKGN1ciwgZXJyb3IgPyBYRlNfQlRSRUVfRVJST1IgOiBYRlNfQlRSRUVfTk9FUlJPUik7CisJeGZzX2J1Zl9yZWxzZShhZ2JwKTsKK291dF9wdXRfcGVyYWc6CisJeGZzX3BlcmFnX3B1dChwYWcpOworCXJldHVybiBlcnJvcjsKK30KKworaW50Cit4ZnNfaW9jX3RyaW0oCisJc3RydWN0IHhmc19tb3VudAkJKm1wLAorCXN0cnVjdCBmc3RyaW1fcmFuZ2UgX191c2VyCSp1cmFuZ2UpCit7CisJc3RydWN0IHJlcXVlc3RfcXVldWUJKnEgPSBtcC0+bV9kZGV2X3RhcmdwLT5idF9iZGV2LT5iZF9kaXNrLT5xdWV1ZTsKKwl1bnNpZ25lZCBpbnQJCWdyYW51bGFyaXR5ID0gcS0+bGltaXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHk7CisJc3RydWN0IGZzdHJpbV9yYW5nZQlyYW5nZTsKKwl4ZnNfZnNibG9ja190CQlzdGFydCwgbGVuLCBtaW5sZW47CisJeGZzX2FnbnVtYmVyX3QJCXN0YXJ0X2Fnbm8sIGVuZF9hZ25vLCBhZ25vOworCV9fdWludDY0X3QJCWJsb2Nrc190cmltbWVkID0gMDsKKwlpbnQJCQllcnJvciwgbGFzdF9lcnJvciA9IDA7CisKKwlpZiAoIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCisJCXJldHVybiAtWEZTX0VSUk9SKEVQRVJNKTsKKwlpZiAoY29weV9mcm9tX3VzZXIoJnJhbmdlLCB1cmFuZ2UsIHNpemVvZihyYW5nZSkpKQorCQlyZXR1cm4gLVhGU19FUlJPUihFRkFVTFQpOworCisJLyoKKwkgKiBUcnVuY2F0aW5nIGRvd24gdGhlIGxlbiBpc24ndCBhY3R1YWxseSBxdWl0ZSBjb3JyZWN0LCBidXQgdXNpbmcKKwkgKiBYRlNfQl9UT19GU0Igd291bGQgbWVhbiB3ZSB0cml2aWFsbHkgZ2V0IG92ZXJmbG93cyBmb3IgdmFsdWVzCisJICogb2YgVUxMT05HX01BWCBvciBzbGlnaHRseSBsb3dlci4gIEFuZCBVTExPTkdfTUFYIGlzIHRoZSBkZWZhdWx0CisJICogdXNlZCBieSB0aGUgZnN0cmltIGFwcGxpY2F0aW9uLiAgSW4gdGhlIGVuZCBpdCByZWFsbHkgZG9lc24ndAorCSAqIG1hdHRlciBhcyB0cmltbWluZyBibG9ja3MgaXMgYW4gYWR2aXNvcnkgaW50ZXJmYWNlLgorCSAqLworCXN0YXJ0ID0gWEZTX0JfVE9fRlNCVChtcCwgcmFuZ2Uuc3RhcnQpOworCWxlbiA9IFhGU19CX1RPX0ZTQlQobXAsIHJhbmdlLmxlbik7CisJbWlubGVuID0gWEZTX0JfVE9fRlNCKG1wLCBtYXhfdCh1NjQsIGdyYW51bGFyaXR5LCByYW5nZS5taW5sZW4pKTsKKworCXN0YXJ0X2Fnbm8gPSBYRlNfRlNCX1RPX0FHTk8obXAsIHN0YXJ0KTsKKwlpZiAoc3RhcnRfYWdubyA+PSBtcC0+bV9zYi5zYl9hZ2NvdW50KQorCQlyZXR1cm4gLVhGU19FUlJPUihFSU5WQUwpOworCisJZW5kX2Fnbm8gPSBYRlNfRlNCX1RPX0FHTk8obXAsIHN0YXJ0ICsgbGVuKTsKKwlpZiAoZW5kX2Fnbm8gPj0gbXAtPm1fc2Iuc2JfYWdjb3VudCkKKwkJZW5kX2Fnbm8gPSBtcC0+bV9zYi5zYl9hZ2NvdW50IC0gMTsKKworCWZvciAoYWdubyA9IHN0YXJ0X2Fnbm87IGFnbm8gPD0gZW5kX2Fnbm87IGFnbm8rKykgeworCQllcnJvciA9IC14ZnNfdHJpbV9leHRlbnRzKG1wLCBhZ25vLCBzdGFydCwgbGVuLCBtaW5sZW4sCisJCQkJCSAgJmJsb2Nrc190cmltbWVkKTsKKwkJaWYgKGVycm9yKQorCQkJbGFzdF9lcnJvciA9IGVycm9yOworCX0KKworCWlmIChsYXN0X2Vycm9yKQorCQlyZXR1cm4gbGFzdF9lcnJvcjsKKworCXJhbmdlLmxlbiA9IFhGU19GU0JfVE9fQihtcCwgYmxvY2tzX3RyaW1tZWQpOworCWlmIChjb3B5X3RvX3VzZXIodXJhbmdlLCAmcmFuZ2UsIHNpemVvZihyYW5nZSkpKQorCQlyZXR1cm4gLVhGU19FUlJPUihFRkFVTFQpOworCXJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfZGlzY2FyZC5oIGIvZnMveGZzL2xpbnV4LTIuNi94ZnNfZGlzY2FyZC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmU4MmI2ZGQKLS0tIC9kZXYvbnVsbAorKysgYi9mcy94ZnMvbGludXgtMi42L3hmc19kaXNjYXJkLmgKQEAgLTAsMCArMSw4IEBACisjaWZuZGVmIFhGU19ESVNDQVJEX0gKKyNkZWZpbmUgWEZTX0RJU0NBUkRfSCAxCisKK3N0cnVjdCBmc3RyaW1fcmFuZ2U7CisKK2V4dGVybiBpbnQJeGZzX2lvY190cmltKHN0cnVjdCB4ZnNfbW91bnQgKiwgc3RydWN0IGZzdHJpbV9yYW5nZSBfX3VzZXIgKik7CisKKyNlbmRpZiAvKiBYRlNfRElTQ0FSRF9IICovCmRpZmYgLS1naXQgYS9mcy94ZnMvbGludXgtMi42L3hmc19maWxlLmMgYi9mcy94ZnMvbGludXgtMi42L3hmc19maWxlLmMKaW5kZXggYmE4YWQ0Mi4uYTU1YzFiNCAxMDA2NDQKLS0tIGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfZmlsZS5jCisrKyBiL2ZzL3hmcy9saW51eC0yLjYveGZzX2ZpbGUuYwpAQCAtMzcsMTAgKzM3LDQ1IEBACiAjaW5jbHVkZSAieGZzX3RyYWNlLmgiCiAKICNpbmNsdWRlIDxsaW51eC9kY2FjaGUuaD4KKyNpbmNsdWRlIDxsaW51eC9mYWxsb2MuaD4KIAogc3RhdGljIGNvbnN0IHN0cnVjdCB2bV9vcGVyYXRpb25zX3N0cnVjdCB4ZnNfZmlsZV92bV9vcHM7CiAKIC8qCisgKiBMb2NraW5nIHByaW1pdGl2ZXMgZm9yIHJlYWQgYW5kIHdyaXRlIElPIHBhdGhzIHRvIGVuc3VyZSB3ZSBjb25zaXN0ZW50bHkgdXNlCisgKiBhbmQgb3JkZXIgdGhlIGlub2RlLT5pX211dGV4LCBpcC0+aV9sb2NrIGFuZCBpcC0+aV9pb2xvY2suCisgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZAoreGZzX3J3X2lsb2NrKAorCXN0cnVjdCB4ZnNfaW5vZGUJKmlwLAorCWludAkJCXR5cGUpCit7CisJaWYgKHR5cGUgJiBYRlNfSU9MT0NLX0VYQ0wpCisJCW11dGV4X2xvY2soJlZGU19JKGlwKS0+aV9tdXRleCk7CisJeGZzX2lsb2NrKGlwLCB0eXBlKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkCit4ZnNfcndfaXVubG9jaygKKwlzdHJ1Y3QgeGZzX2lub2RlCSppcCwKKwlpbnQJCQl0eXBlKQoreworCXhmc19pdW5sb2NrKGlwLCB0eXBlKTsKKwlpZiAodHlwZSAmIFhGU19JT0xPQ0tfRVhDTCkKKwkJbXV0ZXhfdW5sb2NrKCZWRlNfSShpcCktPmlfbXV0ZXgpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK3hmc19yd19pbG9ja19kZW1vdGUoCisJc3RydWN0IHhmc19pbm9kZQkqaXAsCisJaW50CQkJdHlwZSkKK3sKKwl4ZnNfaWxvY2tfZGVtb3RlKGlwLCB0eXBlKTsKKwlpZiAodHlwZSAmIFhGU19JT0xPQ0tfRVhDTCkKKwkJbXV0ZXhfdW5sb2NrKCZWRlNfSShpcCktPmlfbXV0ZXgpOworfQorCisvKgogICoJeGZzX2lvemVybwogICoKICAqCXhmc19pb3plcm8gY2xlYXJzIHRoZSBzcGVjaWZpZWQgcmFuZ2Ugb2YgYnVmZmVyIHN1cHBsaWVkLApAQCAtMjYyLDIyICsyOTcsMjEgQEAKIAlpZiAoWEZTX0ZPUkNFRF9TSFVURE9XTihtcCkpCiAJCXJldHVybiAtRUlPOwogCi0JaWYgKHVubGlrZWx5KGlvZmxhZ3MgJiBJT19JU0RJUkVDVCkpCi0JCW11dGV4X2xvY2soJmlub2RlLT5pX211dGV4KTsKLQl4ZnNfaWxvY2soaXAsIFhGU19JT0xPQ0tfU0hBUkVEKTsKLQogCWlmICh1bmxpa2VseShpb2ZsYWdzICYgSU9fSVNESVJFQ1QpKSB7CisJCXhmc19yd19pbG9jayhpcCwgWEZTX0lPTE9DS19FWENMKTsKKwogCQlpZiAoaW5vZGUtPmlfbWFwcGluZy0+bnJwYWdlcykgewogCQkJcmV0ID0gLXhmc19mbHVzaGludmFsX3BhZ2VzKGlwLAogCQkJCQkoaW9jYi0+a2lfcG9zICYgUEFHRV9DQUNIRV9NQVNLKSwKIAkJCQkJLTEsIEZJX1JFTUFQRl9MT0NLRUQpOworCQkJaWYgKHJldCkgeworCQkJCXhmc19yd19pdW5sb2NrKGlwLCBYRlNfSU9MT0NLX0VYQ0wpOworCQkJCXJldHVybiByZXQ7CisJCQl9CiAJCX0KLQkJbXV0ZXhfdW5sb2NrKCZpbm9kZS0+aV9tdXRleCk7Ci0JCWlmIChyZXQpIHsKLQkJCXhmc19pdW5sb2NrKGlwLCBYRlNfSU9MT0NLX1NIQVJFRCk7Ci0JCQlyZXR1cm4gcmV0OwotCQl9Ci0JfQorCQl4ZnNfcndfaWxvY2tfZGVtb3RlKGlwLCBYRlNfSU9MT0NLX0VYQ0wpOworCX0gZWxzZQorCQl4ZnNfcndfaWxvY2soaXAsIFhGU19JT0xPQ0tfU0hBUkVEKTsKIAogCXRyYWNlX3hmc19maWxlX3JlYWQoaXAsIHNpemUsIGlvY2ItPmtpX3BvcywgaW9mbGFncyk7CiAKQEAgLTI4NSw3ICszMTksNyBAQAogCWlmIChyZXQgPiAwKQogCQlYRlNfU1RBVFNfQUREKHhzX3JlYWRfYnl0ZXMsIHJldCk7CiAKLQl4ZnNfaXVubG9jayhpcCwgWEZTX0lPTE9DS19TSEFSRUQpOworCXhmc19yd19pdW5sb2NrKGlwLCBYRlNfSU9MT0NLX1NIQVJFRCk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtMzA5LDcgKzM0Myw3IEBACiAJaWYgKFhGU19GT1JDRURfU0hVVERPV04oaXAtPmlfbW91bnQpKQogCQlyZXR1cm4gLUVJTzsKIAotCXhmc19pbG9jayhpcCwgWEZTX0lPTE9DS19TSEFSRUQpOworCXhmc19yd19pbG9jayhpcCwgWEZTX0lPTE9DS19TSEFSRUQpOwogCiAJdHJhY2VfeGZzX2ZpbGVfc3BsaWNlX3JlYWQoaXAsIGNvdW50LCAqcHBvcywgaW9mbGFncyk7CiAKQEAgLTMxNywxMCArMzUxLDYxIEBACiAJaWYgKHJldCA+IDApCiAJCVhGU19TVEFUU19BREQoeHNfcmVhZF9ieXRlcywgcmV0KTsKIAotCXhmc19pdW5sb2NrKGlwLCBYRlNfSU9MT0NLX1NIQVJFRCk7CisJeGZzX3J3X2l1bmxvY2soaXAsIFhGU19JT0xPQ0tfU0hBUkVEKTsKIAlyZXR1cm4gcmV0OwogfQogCitTVEFUSUMgdm9pZAoreGZzX2Fpb193cml0ZV9pc2l6ZV91cGRhdGUoCisJc3RydWN0IGlub2RlCSppbm9kZSwKKwlsb2ZmX3QJCSpwcG9zLAorCXNzaXplX3QJCWJ5dGVzX3dyaXR0ZW4pCit7CisJc3RydWN0IHhmc19pbm9kZQkqaXAgPSBYRlNfSShpbm9kZSk7CisJeGZzX2ZzaXplX3QJCWlzaXplID0gaV9zaXplX3JlYWQoaW5vZGUpOworCisJaWYgKGJ5dGVzX3dyaXR0ZW4gPiAwKQorCQlYRlNfU1RBVFNfQUREKHhzX3dyaXRlX2J5dGVzLCBieXRlc193cml0dGVuKTsKKworCWlmICh1bmxpa2VseShieXRlc193cml0dGVuIDwgMCAmJiBieXRlc193cml0dGVuICE9IC1FRkFVTFQgJiYKKwkJCQkJKnBwb3MgPiBpc2l6ZSkpCisJCSpwcG9zID0gaXNpemU7CisKKwlpZiAoKnBwb3MgPiBpcC0+aV9zaXplKSB7CisJCXhmc19yd19pbG9jayhpcCwgWEZTX0lMT0NLX0VYQ0wpOworCQlpZiAoKnBwb3MgPiBpcC0+aV9zaXplKQorCQkJaXAtPmlfc2l6ZSA9ICpwcG9zOworCQl4ZnNfcndfaXVubG9jayhpcCwgWEZTX0lMT0NLX0VYQ0wpOworCX0KK30KKworLyoKKyAqIElmIHRoaXMgd2FzIGEgZGlyZWN0IG9yIHN5bmNocm9ub3VzIEkvTyB0aGF0IGZhaWxlZCAoc3VjaCBhcyBFTk9TUEMpIHRoZW4KKyAqIHBhcnQgb2YgdGhlIEkvTyBtYXkgaGF2ZSBiZWVuIHdyaXR0ZW4gdG8gZGlzayBiZWZvcmUgdGhlIGVycm9yIG9jY3VyZWQuICBJbgorICogdGhpcyBjYXNlIHRoZSBvbi1kaXNrIGZpbGUgc2l6ZSBtYXkgaGF2ZSBiZWVuIGFkanVzdGVkIGJleW9uZCB0aGUgaW4tbWVtb3J5CisgKiBmaWxlIHNpemUgYW5kIG5vdyBuZWVkcyB0byBiZSB0cnVuY2F0ZWQgYmFjay4KKyAqLworU1RBVElDIHZvaWQKK3hmc19haW9fd3JpdGVfbmV3c2l6ZV91cGRhdGUoCisJc3RydWN0IHhmc19pbm9kZQkqaXApCit7CisJaWYgKGlwLT5pX25ld19zaXplKSB7CisJCXhmc19yd19pbG9jayhpcCwgWEZTX0lMT0NLX0VYQ0wpOworCQlpcC0+aV9uZXdfc2l6ZSA9IDA7CisJCWlmIChpcC0+aV9kLmRpX3NpemUgPiBpcC0+aV9zaXplKQorCQkJaXAtPmlfZC5kaV9zaXplID0gaXAtPmlfc2l6ZTsKKwkJeGZzX3J3X2l1bmxvY2soaXAsIFhGU19JTE9DS19FWENMKTsKKwl9Cit9CisKKy8qCisgKiB4ZnNfZmlsZV9zcGxpY2Vfd3JpdGUoKSBkb2VzIG5vdCB1c2UgeGZzX3J3X2lsb2NrKCkgYmVjYXVzZQorICogZ2VuZXJpY19maWxlX3NwbGljZV93cml0ZSgpIHRha2VzIHRoZSBpX211dGV4IGl0c2VsZi4gVGhpcywgaW4gdGhlb3J5LAorICogY291dWxkIGNhdXNlIGxvY2sgaW52ZXJzaW9ucyBiZXR3ZWVuIHRoZSBhaW9fd3JpdGUgcGF0aCBhbmQgdGhlIHNwbGljZSBwYXRoCisgKiBpZiBzb21lb25lIGlzIGRvaW5nIGNvbmN1cnJlbnQgc3BsaWNlKDIpIGJhc2VkIHdyaXRlcyBhbmQgd3JpdGUoMikgYmFzZWQKKyAqIHdyaXRlcyB0byB0aGUgc2FtZSBpbm9kZS4gVGhlIG9ubHkgcmVhbCB3YXkgdG8gZml4IHRoaXMgaXMgdG8gcmUtaW1wbGVtZW50CisgKiB0aGUgZ2VuZXJpYyBjb2RlIGhlcmUgd2l0aCBjb3JyZWN0IGxvY2tpbmcgb3JkZXJzLgorICovCiBTVEFUSUMgc3NpemVfdAogeGZzX2ZpbGVfc3BsaWNlX3dyaXRlKAogCXN0cnVjdCBwaXBlX2lub2RlX2luZm8JKnBpcGUsCkBAIC0zMzEsNyArNDE2LDcgQEAKIHsKIAlzdHJ1Y3QgaW5vZGUJCSppbm9kZSA9IG91dGZpbHAtPmZfbWFwcGluZy0+aG9zdDsKIAlzdHJ1Y3QgeGZzX2lub2RlCSppcCA9IFhGU19JKGlub2RlKTsKLQl4ZnNfZnNpemVfdAkJaXNpemUsIG5ld19zaXplOworCXhmc19mc2l6ZV90CQluZXdfc2l6ZTsKIAlpbnQJCQlpb2ZsYWdzID0gMDsKIAlzc2l6ZV90CQkJcmV0OwogCkBAIC0zNTUsMjcgKzQ0MCw5IEBACiAJdHJhY2VfeGZzX2ZpbGVfc3BsaWNlX3dyaXRlKGlwLCBjb3VudCwgKnBwb3MsIGlvZmxhZ3MpOwogCiAJcmV0ID0gZ2VuZXJpY19maWxlX3NwbGljZV93cml0ZShwaXBlLCBvdXRmaWxwLCBwcG9zLCBjb3VudCwgZmxhZ3MpOwotCWlmIChyZXQgPiAwKQotCQlYRlNfU1RBVFNfQUREKHhzX3dyaXRlX2J5dGVzLCByZXQpOwogCi0JaXNpemUgPSBpX3NpemVfcmVhZChpbm9kZSk7Ci0JaWYgKHVubGlrZWx5KHJldCA8IDAgJiYgcmV0ICE9IC1FRkFVTFQgJiYgKnBwb3MgPiBpc2l6ZSkpCi0JCSpwcG9zID0gaXNpemU7Ci0KLQlpZiAoKnBwb3MgPiBpcC0+aV9zaXplKSB7Ci0JCXhmc19pbG9jayhpcCwgWEZTX0lMT0NLX0VYQ0wpOwotCQlpZiAoKnBwb3MgPiBpcC0+aV9zaXplKQotCQkJaXAtPmlfc2l6ZSA9ICpwcG9zOwotCQl4ZnNfaXVubG9jayhpcCwgWEZTX0lMT0NLX0VYQ0wpOwotCX0KLQotCWlmIChpcC0+aV9uZXdfc2l6ZSkgewotCQl4ZnNfaWxvY2soaXAsIFhGU19JTE9DS19FWENMKTsKLQkJaXAtPmlfbmV3X3NpemUgPSAwOwotCQlpZiAoaXAtPmlfZC5kaV9zaXplID4gaXAtPmlfc2l6ZSkKLQkJCWlwLT5pX2QuZGlfc2l6ZSA9IGlwLT5pX3NpemU7Ci0JCXhmc19pdW5sb2NrKGlwLCBYRlNfSUxPQ0tfRVhDTCk7Ci0JfQorCXhmc19haW9fd3JpdGVfaXNpemVfdXBkYXRlKGlub2RlLCBwcG9zLCByZXQpOworCXhmc19haW9fd3JpdGVfbmV3c2l6ZV91cGRhdGUoaXApOwogCXhmc19pdW5sb2NrKGlwLCBYRlNfSU9MT0NLX0VYQ0wpOwogCXJldHVybiByZXQ7CiB9CkBAIC01NjIsNiArNjI5LDE5NCBAQAogCXJldHVybiBlcnJvcjsKIH0KIAorLyoKKyAqIENvbW1vbiBwcmUtd3JpdGUgbGltaXQgYW5kIHNldHVwIGNoZWNrcy4KKyAqCisgKiBSZXR1cm5zIHdpdGggaW9sb2NrIGhlbGQgYWNjb3JkaW5nIHRvIEBpb2xvY2suCisgKi8KK1NUQVRJQyBzc2l6ZV90Cit4ZnNfZmlsZV9haW9fd3JpdGVfY2hlY2tzKAorCXN0cnVjdCBmaWxlCQkqZmlsZSwKKwlsb2ZmX3QJCQkqcG9zLAorCXNpemVfdAkJCSpjb3VudCwKKwlpbnQJCQkqaW9sb2NrKQoreworCXN0cnVjdCBpbm9kZQkJKmlub2RlID0gZmlsZS0+Zl9tYXBwaW5nLT5ob3N0OworCXN0cnVjdCB4ZnNfaW5vZGUJKmlwID0gWEZTX0koaW5vZGUpOworCXhmc19mc2l6ZV90CQluZXdfc2l6ZTsKKwlpbnQJCQllcnJvciA9IDA7CisKKwllcnJvciA9IGdlbmVyaWNfd3JpdGVfY2hlY2tzKGZpbGUsIHBvcywgY291bnQsIFNfSVNCTEsoaW5vZGUtPmlfbW9kZSkpOworCWlmIChlcnJvcikgeworCQl4ZnNfcndfaXVubG9jayhpcCwgWEZTX0lMT0NLX0VYQ0wgfCAqaW9sb2NrKTsKKwkJKmlvbG9jayA9IDA7CisJCXJldHVybiBlcnJvcjsKKwl9CisKKwluZXdfc2l6ZSA9ICpwb3MgKyAqY291bnQ7CisJaWYgKG5ld19zaXplID4gaXAtPmlfc2l6ZSkKKwkJaXAtPmlfbmV3X3NpemUgPSBuZXdfc2l6ZTsKKworCWlmIChsaWtlbHkoIShmaWxlLT5mX21vZGUgJiBGTU9ERV9OT0NNVElNRSkpKQorCQlmaWxlX3VwZGF0ZV90aW1lKGZpbGUpOworCisJLyoKKwkgKiBJZiB0aGUgb2Zmc2V0IGlzIGJleW9uZCB0aGUgc2l6ZSBvZiB0aGUgZmlsZSwgd2UgbmVlZCB0byB6ZXJvIGFueQorCSAqIGJsb2NrcyB0aGF0IGZhbGwgYmV0d2VlbiB0aGUgZXhpc3RpbmcgRU9GIGFuZCB0aGUgc3RhcnQgb2YgdGhpcworCSAqIHdyaXRlLgorCSAqLworCWlmICgqcG9zID4gaXAtPmlfc2l6ZSkKKwkJZXJyb3IgPSAteGZzX3plcm9fZW9mKGlwLCAqcG9zLCBpcC0+aV9zaXplKTsKKworCXhmc19yd19pdW5sb2NrKGlwLCBYRlNfSUxPQ0tfRVhDTCk7CisJaWYgKGVycm9yKQorCQlyZXR1cm4gZXJyb3I7CisKKwkvKgorCSAqIElmIHdlJ3JlIHdyaXRpbmcgdGhlIGZpbGUgdGhlbiBtYWtlIHN1cmUgdG8gY2xlYXIgdGhlIHNldHVpZCBhbmQKKwkgKiBzZXRnaWQgYml0cyBpZiB0aGUgcHJvY2VzcyBpcyBub3QgYmVpbmcgcnVuIGJ5IHJvb3QuICBUaGlzIGtlZXBzCisJICogcGVvcGxlIGZyb20gbW9kaWZ5aW5nIHNldHVpZCBhbmQgc2V0Z2lkIGJpbmFyaWVzLgorCSAqLworCXJldHVybiBmaWxlX3JlbW92ZV9zdWlkKGZpbGUpOworCit9CisKKy8qCisgKiB4ZnNfZmlsZV9kaW9fYWlvX3dyaXRlIC0gaGFuZGxlIGRpcmVjdCBJTyB3cml0ZXMKKyAqCisgKiBMb2NrIHRoZSBpbm9kZSBhcHByb3ByaWF0ZWx5IHRvIHByZXBhcmUgZm9yIGFuZCBpc3N1ZSBhIGRpcmVjdCBJTyB3cml0ZS4KKyAqIEJ5IHNlcGFyYXRpbmcgaXQgZnJvbSB0aGUgYnVmZmVyZWQgd3JpdGUgcGF0aCB3ZSByZW1vdmUgYWxsIHRoZSB0cmlja3kgdG8KKyAqIGZvbGxvdyBsb2NraW5nIGNoYW5nZXMgYW5kIGxvb3BpbmcuCisgKgorICogSWYgdGhlcmUgYXJlIGNhY2hlZCBwYWdlcyBvciB3ZSdyZSBleHRlbmRpbmcgdGhlIGZpbGUsIHdlIG5lZWQgSU9MT0NLX0VYQ0wKKyAqIHVudGlsIHdlJ3JlIHN1cmUgdGhlIGJ5dGVzIGF0IHRoZSBuZXcgRU9GIGhhdmUgYmVlbiB6ZXJvZWQgYW5kL29yIHRoZSBjYWNoZWQKKyAqIHBhZ2VzIGFyZSBmbHVzaGVkIG91dC4KKyAqCisgKiBJbiBtb3N0IGNhc2VzIHRoZSBkaXJlY3QgSU8gd3JpdGVzIHdpbGwgYmUgZG9uZSBob2xkaW5nIElPTE9DS19TSEFSRUQKKyAqIGFsbG93aW5nIHRoZW0gdG8gYmUgZG9uZSBpbiBwYXJhbGxlbCB3aXRoIHJlYWRzIGFuZCBvdGhlciBkaXJlY3QgSU8gd3JpdGVzLgorICogSG93ZXZlciwgaWYgdGhlIElPIGlzIG5vdCBhbGlnbmVkIHRvIGZpbGVzeXN0ZW0gYmxvY2tzLCB0aGUgZGlyZWN0IElPIGxheWVyCisgKiBuZWVkcyB0byBkbyBzdWItYmxvY2sgemVyb2luZyBhbmQgdGhhdCByZXF1aXJlcyBzZXJpYWxpc2F0aW9uIGFnYWluc3Qgb3RoZXIKKyAqIGRpcmVjdCBJT3MgdG8gdGhlIHNhbWUgYmxvY2suIEluIHRoaXMgY2FzZSB3ZSBuZWVkIHRvIHNlcmlhbGlzZSB0aGUKKyAqIHN1Ym1pc3Npb24gb2YgdGhlIHVuYWxpZ25lZCBJT3Mgc28gdGhhdCB3ZSBkb24ndCBnZXQgcmFjaW5nIGJsb2NrIHplcm9pbmcgaW4KKyAqIHRoZSBkaW8gbGF5ZXIuICBUbyBhdm9pZCB0aGUgcHJvYmxlbSB3aXRoIGFpbywgd2UgYWxzbyBuZWVkIHRvIHdhaXQgZm9yCisgKiBvdXRzdGFuZGluZyBJT3MgdG8gY29tcGxldGUgc28gdGhhdCB1bndyaXR0ZW4gZXh0ZW50IGNvbnZlcnNpb24gaXMgY29tcGxldGVkCisgKiBiZWZvcmUgd2UgdHJ5IHRvIG1hcCB0aGUgb3ZlcmxhcHBpbmcgYmxvY2suIFRoaXMgaXMgY3VycmVudGx5IGltcGxlbWVudGVkIGJ5CisgKiBoaXR0aW5nIGl0IHdpdGggYSBiaWcgaGFtbWVyIChpLmUuIHhmc19pb2VuZF93YWl0KCkpLgorICoKKyAqIFJldHVybnMgd2l0aCBsb2NrcyBoZWxkIGluZGljYXRlZCBieSBAaW9sb2NrIGFuZCBlcnJvcnMgaW5kaWNhdGVkIGJ5CisgKiBuZWdhdGl2ZSByZXR1cm4gdmFsdWVzLgorICovCitTVEFUSUMgc3NpemVfdAoreGZzX2ZpbGVfZGlvX2Fpb193cml0ZSgKKwlzdHJ1Y3Qga2lvY2IJCSppb2NiLAorCWNvbnN0IHN0cnVjdCBpb3ZlYwkqaW92cCwKKwl1bnNpZ25lZCBsb25nCQlucl9zZWdzLAorCWxvZmZfdAkJCXBvcywKKwlzaXplX3QJCQlvY291bnQsCisJaW50CQkJKmlvbG9jaykKK3sKKwlzdHJ1Y3QgZmlsZQkJKmZpbGUgPSBpb2NiLT5raV9maWxwOworCXN0cnVjdCBhZGRyZXNzX3NwYWNlCSptYXBwaW5nID0gZmlsZS0+Zl9tYXBwaW5nOworCXN0cnVjdCBpbm9kZQkJKmlub2RlID0gbWFwcGluZy0+aG9zdDsKKwlzdHJ1Y3QgeGZzX2lub2RlCSppcCA9IFhGU19JKGlub2RlKTsKKwlzdHJ1Y3QgeGZzX21vdW50CSptcCA9IGlwLT5pX21vdW50OworCXNzaXplX3QJCQlyZXQgPSAwOworCXNpemVfdAkJCWNvdW50ID0gb2NvdW50OworCWludAkJCXVuYWxpZ25lZF9pbyA9IDA7CisJc3RydWN0IHhmc19idWZ0YXJnCSp0YXJnZXQgPSBYRlNfSVNfUkVBTFRJTUVfSU5PREUoaXApID8KKwkJCQkJbXAtPm1fcnRkZXZfdGFyZ3AgOiBtcC0+bV9kZGV2X3RhcmdwOworCisJKmlvbG9jayA9IDA7CisJaWYgKChwb3MgJiB0YXJnZXQtPmJ0X3NtYXNrKSB8fCAoY291bnQgJiB0YXJnZXQtPmJ0X3NtYXNrKSkKKwkJcmV0dXJuIC1YRlNfRVJST1IoRUlOVkFMKTsKKworCWlmICgocG9zICYgbXAtPm1fYmxvY2ttYXNrKSB8fCAoKHBvcyArIGNvdW50KSAmIG1wLT5tX2Jsb2NrbWFzaykpCisJCXVuYWxpZ25lZF9pbyA9IDE7CisKKwlpZiAodW5hbGlnbmVkX2lvIHx8IG1hcHBpbmctPm5ycGFnZXMgfHwgcG9zID4gaXAtPmlfc2l6ZSkKKwkJKmlvbG9jayA9IFhGU19JT0xPQ0tfRVhDTDsKKwllbHNlCisJCSppb2xvY2sgPSBYRlNfSU9MT0NLX1NIQVJFRDsKKwl4ZnNfcndfaWxvY2soaXAsIFhGU19JTE9DS19FWENMIHwgKmlvbG9jayk7CisKKwlyZXQgPSB4ZnNfZmlsZV9haW9fd3JpdGVfY2hlY2tzKGZpbGUsICZwb3MsICZjb3VudCwgaW9sb2NrKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJaWYgKG1hcHBpbmctPm5ycGFnZXMpIHsKKwkJV0FSTl9PTigqaW9sb2NrICE9IFhGU19JT0xPQ0tfRVhDTCk7CisJCXJldCA9IC14ZnNfZmx1c2hpbnZhbF9wYWdlcyhpcCwgKHBvcyAmIFBBR0VfQ0FDSEVfTUFTSyksIC0xLAorCQkJCQkJCUZJX1JFTUFQRl9MT0NLRUQpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKwl9CisKKwkvKgorCSAqIElmIHdlIGFyZSBkb2luZyB1bmFsaWduZWQgSU8sIHdhaXQgZm9yIGFsbCBvdGhlciBJTyB0byBkcmFpbiwKKwkgKiBvdGhlcndpc2UgZGVtb3RlIHRoZSBsb2NrIGlmIHdlIGhhZCB0byBmbHVzaCBjYWNoZWQgcGFnZXMKKwkgKi8KKwlpZiAodW5hbGlnbmVkX2lvKQorCQl4ZnNfaW9lbmRfd2FpdChpcCk7CisJZWxzZSBpZiAoKmlvbG9jayA9PSBYRlNfSU9MT0NLX0VYQ0wpIHsKKwkJeGZzX3J3X2lsb2NrX2RlbW90ZShpcCwgWEZTX0lPTE9DS19FWENMKTsKKwkJKmlvbG9jayA9IFhGU19JT0xPQ0tfU0hBUkVEOworCX0KKworCXRyYWNlX3hmc19maWxlX2RpcmVjdF93cml0ZShpcCwgY291bnQsIGlvY2ItPmtpX3BvcywgMCk7CisJcmV0ID0gZ2VuZXJpY19maWxlX2RpcmVjdF93cml0ZShpb2NiLCBpb3ZwLAorCQkJJm5yX3NlZ3MsIHBvcywgJmlvY2ItPmtpX3BvcywgY291bnQsIG9jb3VudCk7CisKKwkvKiBObyBmYWxsYmFjayB0byBidWZmZXJlZCBJTyBvbiBlcnJvcnMgZm9yIFhGUy4gKi8KKwlBU1NFUlQocmV0IDwgMCB8fCByZXQgPT0gY291bnQpOworCXJldHVybiByZXQ7Cit9CisKK1NUQVRJQyBzc2l6ZV90Cit4ZnNfZmlsZV9idWZmZXJlZF9haW9fd3JpdGUoCisJc3RydWN0IGtpb2NiCQkqaW9jYiwKKwljb25zdCBzdHJ1Y3QgaW92ZWMJKmlvdnAsCisJdW5zaWduZWQgbG9uZwkJbnJfc2VncywKKwlsb2ZmX3QJCQlwb3MsCisJc2l6ZV90CQkJb2NvdW50LAorCWludAkJCSppb2xvY2spCit7CisJc3RydWN0IGZpbGUJCSpmaWxlID0gaW9jYi0+a2lfZmlscDsKKwlzdHJ1Y3QgYWRkcmVzc19zcGFjZQkqbWFwcGluZyA9IGZpbGUtPmZfbWFwcGluZzsKKwlzdHJ1Y3QgaW5vZGUJCSppbm9kZSA9IG1hcHBpbmctPmhvc3Q7CisJc3RydWN0IHhmc19pbm9kZQkqaXAgPSBYRlNfSShpbm9kZSk7CisJc3NpemVfdAkJCXJldDsKKwlpbnQJCQllbm9zcGMgPSAwOworCXNpemVfdAkJCWNvdW50ID0gb2NvdW50OworCisJKmlvbG9jayA9IFhGU19JT0xPQ0tfRVhDTDsKKwl4ZnNfcndfaWxvY2soaXAsIFhGU19JTE9DS19FWENMIHwgKmlvbG9jayk7CisKKwlyZXQgPSB4ZnNfZmlsZV9haW9fd3JpdGVfY2hlY2tzKGZpbGUsICZwb3MsICZjb3VudCwgaW9sb2NrKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJLyogV2UgY2FuIHdyaXRlIGJhY2sgdGhpcyBxdWV1ZSBpbiBwYWdlIHJlY2xhaW0gKi8KKwljdXJyZW50LT5iYWNraW5nX2Rldl9pbmZvID0gbWFwcGluZy0+YmFja2luZ19kZXZfaW5mbzsKKword3JpdGVfcmV0cnk6CisJdHJhY2VfeGZzX2ZpbGVfYnVmZmVyZWRfd3JpdGUoaXAsIGNvdW50LCBpb2NiLT5raV9wb3MsIDApOworCXJldCA9IGdlbmVyaWNfZmlsZV9idWZmZXJlZF93cml0ZShpb2NiLCBpb3ZwLCBucl9zZWdzLAorCQkJcG9zLCAmaW9jYi0+a2lfcG9zLCBjb3VudCwgcmV0KTsKKwkvKgorCSAqIGlmIHdlIGp1c3QgZ290IGFuIEVOT1NQQywgZmx1c2ggdGhlIGlub2RlIG5vdyB3ZSBhcmVuJ3QgaG9sZGluZyBhbnkKKwkgKiBwYWdlIGxvY2tzIGFuZCByZXRyeSAqb25jZSoKKwkgKi8KKwlpZiAocmV0ID09IC1FTk9TUEMgJiYgIWVub3NwYykgeworCQlyZXQgPSAteGZzX2ZsdXNoX3BhZ2VzKGlwLCAwLCAtMSwgMCwgRklfTk9ORSk7CisJCWlmIChyZXQpCisJCQlyZXR1cm4gcmV0OworCQllbm9zcGMgPSAxOworCQlnb3RvIHdyaXRlX3JldHJ5OworCX0KKwljdXJyZW50LT5iYWNraW5nX2Rldl9pbmZvID0gTlVMTDsKKwlyZXR1cm4gcmV0OworfQorCiBTVEFUSUMgc3NpemVfdAogeGZzX2ZpbGVfYWlvX3dyaXRlKAogCXN0cnVjdCBraW9jYgkJKmlvY2IsCkBAIC01NzMsMjM2ICs4MjgsMTE1IEBACiAJc3RydWN0IGFkZHJlc3Nfc3BhY2UJKm1hcHBpbmcgPSBmaWxlLT5mX21hcHBpbmc7CiAJc3RydWN0IGlub2RlCQkqaW5vZGUgPSBtYXBwaW5nLT5ob3N0OwogCXN0cnVjdCB4ZnNfaW5vZGUJKmlwID0gWEZTX0koaW5vZGUpOwotCXN0cnVjdCB4ZnNfbW91bnQJKm1wID0gaXAtPmlfbW91bnQ7Ci0Jc3NpemVfdAkJCXJldCA9IDAsIGVycm9yID0gMDsKLQlpbnQJCQlpb2ZsYWdzID0gMDsKLQl4ZnNfZnNpemVfdAkJaXNpemUsIG5ld19zaXplOworCXNzaXplX3QJCQlyZXQ7CiAJaW50CQkJaW9sb2NrOwotCXNpemVfdAkJCW9jb3VudCA9IDAsIGNvdW50OwotCWludAkJCW5lZWRfaV9tdXRleDsKKwlzaXplX3QJCQlvY291bnQgPSAwOwogCiAJWEZTX1NUQVRTX0lOQyh4c193cml0ZV9jYWxscyk7CiAKIAlCVUdfT04oaW9jYi0+a2lfcG9zICE9IHBvcyk7CiAKLQlpZiAodW5saWtlbHkoZmlsZS0+Zl9mbGFncyAmIE9fRElSRUNUKSkKLQkJaW9mbGFncyB8PSBJT19JU0RJUkVDVDsKLQlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfTk9DTVRJTUUpCi0JCWlvZmxhZ3MgfD0gSU9fSU5WSVM7CisJcmV0ID0gZ2VuZXJpY19zZWdtZW50X2NoZWNrcyhpb3ZwLCAmbnJfc2VncywgJm9jb3VudCwgVkVSSUZZX1JFQUQpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CiAKLQllcnJvciA9IGdlbmVyaWNfc2VnbWVudF9jaGVja3MoaW92cCwgJm5yX3NlZ3MsICZvY291bnQsIFZFUklGWV9SRUFEKTsKLQlpZiAoZXJyb3IpCi0JCXJldHVybiBlcnJvcjsKLQotCWNvdW50ID0gb2NvdW50OwotCWlmIChjb3VudCA9PSAwKQorCWlmIChvY291bnQgPT0gMCkKIAkJcmV0dXJuIDA7CiAKLQl4ZnNfd2FpdF9mb3JfZnJlZXplKG1wLCBTQl9GUkVFWkVfV1JJVEUpOworCXhmc193YWl0X2Zvcl9mcmVlemUoaXAtPmlfbW91bnQsIFNCX0ZSRUVaRV9XUklURSk7CiAKLQlpZiAoWEZTX0ZPUkNFRF9TSFVURE9XTihtcCkpCisJaWYgKFhGU19GT1JDRURfU0hVVERPV04oaXAtPmlfbW91bnQpKQogCQlyZXR1cm4gLUVJTzsKIAotcmVsb2NrOgotCWlmIChpb2ZsYWdzICYgSU9fSVNESVJFQ1QpIHsKLQkJaW9sb2NrID0gWEZTX0lPTE9DS19TSEFSRUQ7Ci0JCW5lZWRfaV9tdXRleCA9IDA7Ci0JfSBlbHNlIHsKLQkJaW9sb2NrID0gWEZTX0lPTE9DS19FWENMOwotCQluZWVkX2lfbXV0ZXggPSAxOwotCQltdXRleF9sb2NrKCZpbm9kZS0+aV9tdXRleCk7Ci0JfQorCWlmICh1bmxpa2VseShmaWxlLT5mX2ZsYWdzICYgT19ESVJFQ1QpKQorCQlyZXQgPSB4ZnNfZmlsZV9kaW9fYWlvX3dyaXRlKGlvY2IsIGlvdnAsIG5yX3NlZ3MsIHBvcywKKwkJCQkJCW9jb3VudCwgJmlvbG9jayk7CisJZWxzZQorCQlyZXQgPSB4ZnNfZmlsZV9idWZmZXJlZF9haW9fd3JpdGUoaW9jYiwgaW92cCwgbnJfc2VncywgcG9zLAorCQkJCQkJb2NvdW50LCAmaW9sb2NrKTsKIAotCXhmc19pbG9jayhpcCwgWEZTX0lMT0NLX0VYQ0x8aW9sb2NrKTsKKwl4ZnNfYWlvX3dyaXRlX2lzaXplX3VwZGF0ZShpbm9kZSwgJmlvY2ItPmtpX3BvcywgcmV0KTsKIAotc3RhcnQ6Ci0JZXJyb3IgPSAtZ2VuZXJpY193cml0ZV9jaGVja3MoZmlsZSwgJnBvcywgJmNvdW50LAotCQkJCQlTX0lTQkxLKGlub2RlLT5pX21vZGUpKTsKLQlpZiAoZXJyb3IpIHsKLQkJeGZzX2l1bmxvY2soaXAsIFhGU19JTE9DS19FWENMfGlvbG9jayk7Ci0JCWdvdG8gb3V0X3VubG9ja19tdXRleDsKLQl9Ci0KLQlpZiAoaW9mbGFncyAmIElPX0lTRElSRUNUKSB7Ci0JCXhmc19idWZ0YXJnX3QJKnRhcmdldCA9Ci0JCQlYRlNfSVNfUkVBTFRJTUVfSU5PREUoaXApID8KLQkJCQltcC0+bV9ydGRldl90YXJncCA6IG1wLT5tX2RkZXZfdGFyZ3A7Ci0KLQkJaWYgKChwb3MgJiB0YXJnZXQtPmJ0X3NtYXNrKSB8fCAoY291bnQgJiB0YXJnZXQtPmJ0X3NtYXNrKSkgewotCQkJeGZzX2l1bmxvY2soaXAsIFhGU19JTE9DS19FWENMfGlvbG9jayk7Ci0JCQlyZXR1cm4gWEZTX0VSUk9SKC1FSU5WQUwpOwotCQl9Ci0KLQkJaWYgKCFuZWVkX2lfbXV0ZXggJiYgKG1hcHBpbmctPm5ycGFnZXMgfHwgcG9zID4gaXAtPmlfc2l6ZSkpIHsKLQkJCXhmc19pdW5sb2NrKGlwLCBYRlNfSUxPQ0tfRVhDTHxpb2xvY2spOwotCQkJaW9sb2NrID0gWEZTX0lPTE9DS19FWENMOwotCQkJbmVlZF9pX211dGV4ID0gMTsKLQkJCW11dGV4X2xvY2soJmlub2RlLT5pX211dGV4KTsKLQkJCXhmc19pbG9jayhpcCwgWEZTX0lMT0NLX0VYQ0x8aW9sb2NrKTsKLQkJCWdvdG8gc3RhcnQ7Ci0JCX0KLQl9Ci0KLQluZXdfc2l6ZSA9IHBvcyArIGNvdW50OwotCWlmIChuZXdfc2l6ZSA+IGlwLT5pX3NpemUpCi0JCWlwLT5pX25ld19zaXplID0gbmV3X3NpemU7Ci0KLQlpZiAobGlrZWx5KCEoaW9mbGFncyAmIElPX0lOVklTKSkpCi0JCWZpbGVfdXBkYXRlX3RpbWUoZmlsZSk7Ci0KLQkvKgotCSAqIElmIHRoZSBvZmZzZXQgaXMgYmV5b25kIHRoZSBzaXplIG9mIHRoZSBmaWxlLCB3ZSBoYXZlIGEgY291cGxlCi0JICogb2YgdGhpbmdzIHRvIGRvLiBGaXJzdCwgaWYgdGhlcmUgaXMgYWxyZWFkeSBzcGFjZSBhbGxvY2F0ZWQKLQkgKiB3ZSBuZWVkIHRvIGVpdGhlciBjcmVhdGUgaG9sZXMgb3IgemVybyB0aGUgZGlzayBvciAuLi4KLQkgKgotCSAqIElmIHRoZXJlIGlzIGEgcGFnZSB3aGVyZSB0aGUgcHJldmlvdXMgc2l6ZSBsYW5kcywgd2UgbmVlZAotCSAqIHRvIHplcm8gaXQgb3V0IHVwIHRvIHRoZSBuZXcgc2l6ZS4KLQkgKi8KLQotCWlmIChwb3MgPiBpcC0+aV9zaXplKSB7Ci0JCWVycm9yID0geGZzX3plcm9fZW9mKGlwLCBwb3MsIGlwLT5pX3NpemUpOwotCQlpZiAoZXJyb3IpIHsKLQkJCXhmc19pdW5sb2NrKGlwLCBYRlNfSUxPQ0tfRVhDTCk7Ci0JCQlnb3RvIG91dF91bmxvY2tfaW50ZXJuYWw7Ci0JCX0KLQl9Ci0JeGZzX2l1bmxvY2soaXAsIFhGU19JTE9DS19FWENMKTsKLQotCS8qCi0JICogSWYgd2UncmUgd3JpdGluZyB0aGUgZmlsZSB0aGVuIG1ha2Ugc3VyZSB0byBjbGVhciB0aGUKLQkgKiBzZXR1aWQgYW5kIHNldGdpZCBiaXRzIGlmIHRoZSBwcm9jZXNzIGlzIG5vdCBiZWluZyBydW4KLQkgKiBieSByb290LiAgVGhpcyBrZWVwcyBwZW9wbGUgZnJvbSBtb2RpZnlpbmcgc2V0dWlkIGFuZAotCSAqIHNldGdpZCBiaW5hcmllcy4KLQkgKi8KLQllcnJvciA9IC1maWxlX3JlbW92ZV9zdWlkKGZpbGUpOwotCWlmICh1bmxpa2VseShlcnJvcikpCi0JCWdvdG8gb3V0X3VubG9ja19pbnRlcm5hbDsKLQotCS8qIFdlIGNhbiB3cml0ZSBiYWNrIHRoaXMgcXVldWUgaW4gcGFnZSByZWNsYWltICovCi0JY3VycmVudC0+YmFja2luZ19kZXZfaW5mbyA9IG1hcHBpbmctPmJhY2tpbmdfZGV2X2luZm87Ci0KLQlpZiAoKGlvZmxhZ3MgJiBJT19JU0RJUkVDVCkpIHsKLQkJaWYgKG1hcHBpbmctPm5ycGFnZXMpIHsKLQkJCVdBUk5fT04obmVlZF9pX211dGV4ID09IDApOwotCQkJZXJyb3IgPSB4ZnNfZmx1c2hpbnZhbF9wYWdlcyhpcCwKLQkJCQkJKHBvcyAmIFBBR0VfQ0FDSEVfTUFTSyksCi0JCQkJCS0xLCBGSV9SRU1BUEZfTE9DS0VEKTsKLQkJCWlmIChlcnJvcikKLQkJCQlnb3RvIG91dF91bmxvY2tfaW50ZXJuYWw7Ci0JCX0KLQotCQlpZiAobmVlZF9pX211dGV4KSB7Ci0JCQkvKiBkZW1vdGUgdGhlIGxvY2sgbm93IHRoZSBjYWNoZWQgcGFnZXMgYXJlIGdvbmUgKi8KLQkJCXhmc19pbG9ja19kZW1vdGUoaXAsIFhGU19JT0xPQ0tfRVhDTCk7Ci0JCQltdXRleF91bmxvY2soJmlub2RlLT5pX211dGV4KTsKLQotCQkJaW9sb2NrID0gWEZTX0lPTE9DS19TSEFSRUQ7Ci0JCQluZWVkX2lfbXV0ZXggPSAwOwotCQl9Ci0KLQkJdHJhY2VfeGZzX2ZpbGVfZGlyZWN0X3dyaXRlKGlwLCBjb3VudCwgaW9jYi0+a2lfcG9zLCBpb2ZsYWdzKTsKLQkJcmV0ID0gZ2VuZXJpY19maWxlX2RpcmVjdF93cml0ZShpb2NiLCBpb3ZwLAotCQkJCSZucl9zZWdzLCBwb3MsICZpb2NiLT5raV9wb3MsIGNvdW50LCBvY291bnQpOwotCi0JCS8qCi0JCSAqIGRpcmVjdC1pbyB3cml0ZSB0byBhIGhvbGU6IGZhbGwgdGhyb3VnaCB0byBidWZmZXJlZCBJL08KLQkJICogZm9yIGNvbXBsZXRpbmcgdGhlIHJlc3Qgb2YgdGhlIHJlcXVlc3QuCi0JCSAqLwotCQlpZiAocmV0ID49IDAgJiYgcmV0ICE9IGNvdW50KSB7Ci0JCQlYRlNfU1RBVFNfQUREKHhzX3dyaXRlX2J5dGVzLCByZXQpOwotCi0JCQlwb3MgKz0gcmV0OwotCQkJY291bnQgLT0gcmV0OwotCi0JCQlpb2ZsYWdzICY9IH5JT19JU0RJUkVDVDsKLQkJCXhmc19pdW5sb2NrKGlwLCBpb2xvY2spOwotCQkJZ290byByZWxvY2s7Ci0JCX0KLQl9IGVsc2UgewotCQlpbnQgZW5vc3BjID0gMDsKLQkJc3NpemVfdCByZXQyID0gMDsKLQotd3JpdGVfcmV0cnk6Ci0JCXRyYWNlX3hmc19maWxlX2J1ZmZlcmVkX3dyaXRlKGlwLCBjb3VudCwgaW9jYi0+a2lfcG9zLCBpb2ZsYWdzKTsKLQkJcmV0MiA9IGdlbmVyaWNfZmlsZV9idWZmZXJlZF93cml0ZShpb2NiLCBpb3ZwLCBucl9zZWdzLAotCQkJCXBvcywgJmlvY2ItPmtpX3BvcywgY291bnQsIHJldCk7Ci0JCS8qCi0JCSAqIGlmIHdlIGp1c3QgZ290IGFuIEVOT1NQQywgZmx1c2ggdGhlIGlub2RlIG5vdyB3ZQotCQkgKiBhcmVuJ3QgaG9sZGluZyBhbnkgcGFnZSBsb2NrcyBhbmQgcmV0cnkgKm9uY2UqCi0JCSAqLwotCQlpZiAocmV0MiA9PSAtRU5PU1BDICYmICFlbm9zcGMpIHsKLQkJCWVycm9yID0geGZzX2ZsdXNoX3BhZ2VzKGlwLCAwLCAtMSwgMCwgRklfTk9ORSk7Ci0JCQlpZiAoZXJyb3IpCi0JCQkJZ290byBvdXRfdW5sb2NrX2ludGVybmFsOwotCQkJZW5vc3BjID0gMTsKLQkJCWdvdG8gd3JpdGVfcmV0cnk7Ci0JCX0KLQkJcmV0ID0gcmV0MjsKLQl9Ci0KLQljdXJyZW50LT5iYWNraW5nX2Rldl9pbmZvID0gTlVMTDsKLQotCWlzaXplID0gaV9zaXplX3JlYWQoaW5vZGUpOwotCWlmICh1bmxpa2VseShyZXQgPCAwICYmIHJldCAhPSAtRUZBVUxUICYmIGlvY2ItPmtpX3BvcyA+IGlzaXplKSkKLQkJaW9jYi0+a2lfcG9zID0gaXNpemU7Ci0KLQlpZiAoaW9jYi0+a2lfcG9zID4gaXAtPmlfc2l6ZSkgewotCQl4ZnNfaWxvY2soaXAsIFhGU19JTE9DS19FWENMKTsKLQkJaWYgKGlvY2ItPmtpX3BvcyA+IGlwLT5pX3NpemUpCi0JCQlpcC0+aV9zaXplID0gaW9jYi0+a2lfcG9zOwotCQl4ZnNfaXVubG9jayhpcCwgWEZTX0lMT0NLX0VYQ0wpOwotCX0KLQotCWVycm9yID0gLXJldDsKIAlpZiAocmV0IDw9IDApCi0JCWdvdG8gb3V0X3VubG9ja19pbnRlcm5hbDsKLQotCVhGU19TVEFUU19BREQoeHNfd3JpdGVfYnl0ZXMsIHJldCk7CisJCWdvdG8gb3V0X3VubG9jazsKIAogCS8qIEhhbmRsZSB2YXJpb3VzIFNZTkMtdHlwZSB3cml0ZXMgKi8KIAlpZiAoKGZpbGUtPmZfZmxhZ3MgJiBPX0RTWU5DKSB8fCBJU19TWU5DKGlub2RlKSkgewogCQlsb2ZmX3QgZW5kID0gcG9zICsgcmV0IC0gMTsKLQkJaW50IGVycm9yMjsKKwkJaW50IGVycm9yLCBlcnJvcjI7CiAKLQkJeGZzX2l1bmxvY2soaXAsIGlvbG9jayk7Ci0JCWlmIChuZWVkX2lfbXV0ZXgpCi0JCQltdXRleF91bmxvY2soJmlub2RlLT5pX211dGV4KTsKLQotCQllcnJvcjIgPSBmaWxlbWFwX3dyaXRlX2FuZF93YWl0X3JhbmdlKG1hcHBpbmcsIHBvcywgZW5kKTsKLQkJaWYgKCFlcnJvcikKLQkJCWVycm9yID0gZXJyb3IyOwotCQlpZiAobmVlZF9pX211dGV4KQotCQkJbXV0ZXhfbG9jaygmaW5vZGUtPmlfbXV0ZXgpOwotCQl4ZnNfaWxvY2soaXAsIGlvbG9jayk7CisJCXhmc19yd19pdW5sb2NrKGlwLCBpb2xvY2spOworCQllcnJvciA9IGZpbGVtYXBfd3JpdGVfYW5kX3dhaXRfcmFuZ2UobWFwcGluZywgcG9zLCBlbmQpOworCQl4ZnNfcndfaWxvY2soaXAsIGlvbG9jayk7CiAKIAkJZXJyb3IyID0gLXhmc19maWxlX2ZzeW5jKGZpbGUsCiAJCQkJCSAoZmlsZS0+Zl9mbGFncyAmIF9fT19TWU5DKSA/IDAgOiAxKTsKLQkJaWYgKCFlcnJvcikKLQkJCWVycm9yID0gZXJyb3IyOworCQlpZiAoZXJyb3IpCisJCQlyZXQgPSBlcnJvcjsKKwkJZWxzZSBpZiAoZXJyb3IyKQorCQkJcmV0ID0gZXJyb3IyOwogCX0KIAotIG91dF91bmxvY2tfaW50ZXJuYWw6Ci0JaWYgKGlwLT5pX25ld19zaXplKSB7Ci0JCXhmc19pbG9jayhpcCwgWEZTX0lMT0NLX0VYQ0wpOwotCQlpcC0+aV9uZXdfc2l6ZSA9IDA7Ci0JCS8qCi0JCSAqIElmIHRoaXMgd2FzIGEgZGlyZWN0IG9yIHN5bmNocm9ub3VzIEkvTyB0aGF0IGZhaWxlZCAoc3VjaAotCQkgKiBhcyBFTk9TUEMpIHRoZW4gcGFydCBvZiB0aGUgSS9PIG1heSBoYXZlIGJlZW4gd3JpdHRlbiB0bwotCQkgKiBkaXNrIGJlZm9yZSB0aGUgZXJyb3Igb2NjdXJlZC4gIEluIHRoaXMgY2FzZSB0aGUgb24tZGlzawotCQkgKiBmaWxlIHNpemUgbWF5IGhhdmUgYmVlbiBhZGp1c3RlZCBiZXlvbmQgdGhlIGluLW1lbW9yeSBmaWxlCi0JCSAqIHNpemUgYW5kIG5vdyBuZWVkcyB0byBiZSB0cnVuY2F0ZWQgYmFjay4KLQkJICovCi0JCWlmIChpcC0+aV9kLmRpX3NpemUgPiBpcC0+aV9zaXplKQotCQkJaXAtPmlfZC5kaV9zaXplID0gaXAtPmlfc2l6ZTsKLQkJeGZzX2l1bmxvY2soaXAsIFhGU19JTE9DS19FWENMKTsKLQl9Ci0JeGZzX2l1bmxvY2soaXAsIGlvbG9jayk7Ci0gb3V0X3VubG9ja19tdXRleDoKLQlpZiAobmVlZF9pX211dGV4KQotCQltdXRleF91bmxvY2soJmlub2RlLT5pX211dGV4KTsKLQlyZXR1cm4gLWVycm9yOworb3V0X3VubG9jazoKKwl4ZnNfYWlvX3dyaXRlX25ld3NpemVfdXBkYXRlKGlwKTsKKwl4ZnNfcndfaXVubG9jayhpcCwgaW9sb2NrKTsKKwlyZXR1cm4gcmV0OwogfQogCitTVEFUSUMgbG9uZworeGZzX2ZpbGVfZmFsbG9jYXRlKAorCXN0cnVjdCBmaWxlCSpmaWxlLAorCWludAkJbW9kZSwKKwlsb2ZmX3QJCW9mZnNldCwKKwlsb2ZmX3QJCWxlbikKK3sKKwlzdHJ1Y3QgaW5vZGUJKmlub2RlID0gZmlsZS0+Zl9wYXRoLmRlbnRyeS0+ZF9pbm9kZTsKKwlsb25nCQllcnJvcjsKKwlsb2ZmX3QJCW5ld19zaXplID0gMDsKKwl4ZnNfZmxvY2s2NF90CWJmOworCXhmc19pbm9kZV90CSppcCA9IFhGU19JKGlub2RlKTsKKwlpbnQJCWNtZCA9IFhGU19JT0NfUkVTVlNQOworCisJaWYgKG1vZGUgJiB+KEZBTExPQ19GTF9LRUVQX1NJWkUgfCBGQUxMT0NfRkxfUFVOQ0hfSE9MRSkpCisJCXJldHVybiAtRU9QTk9UU1VQUDsKKworCWJmLmxfd2hlbmNlID0gMDsKKwliZi5sX3N0YXJ0ID0gb2Zmc2V0OworCWJmLmxfbGVuID0gbGVuOworCisJeGZzX2lsb2NrKGlwLCBYRlNfSU9MT0NLX0VYQ0wpOworCisJaWYgKG1vZGUgJiBGQUxMT0NfRkxfUFVOQ0hfSE9MRSkKKwkJY21kID0gWEZTX0lPQ19VTlJFU1ZTUDsKKworCS8qIGNoZWNrIHRoZSBuZXcgaW5vZGUgc2l6ZSBpcyB2YWxpZCBiZWZvcmUgYWxsb2NhdGluZyAqLworCWlmICghKG1vZGUgJiBGQUxMT0NfRkxfS0VFUF9TSVpFKSAmJgorCSAgICBvZmZzZXQgKyBsZW4gPiBpX3NpemVfcmVhZChpbm9kZSkpIHsKKwkJbmV3X3NpemUgPSBvZmZzZXQgKyBsZW47CisJCWVycm9yID0gaW5vZGVfbmV3c2l6ZV9vayhpbm9kZSwgbmV3X3NpemUpOworCQlpZiAoZXJyb3IpCisJCQlnb3RvIG91dF91bmxvY2s7CisJfQorCisJZXJyb3IgPSAteGZzX2NoYW5nZV9maWxlX3NwYWNlKGlwLCBjbWQsICZiZiwgMCwgWEZTX0FUVFJfTk9MT0NLKTsKKwlpZiAoZXJyb3IpCisJCWdvdG8gb3V0X3VubG9jazsKKworCS8qIENoYW5nZSBmaWxlIHNpemUgaWYgbmVlZGVkICovCisJaWYgKG5ld19zaXplKSB7CisJCXN0cnVjdCBpYXR0ciBpYXR0cjsKKworCQlpYXR0ci5pYV92YWxpZCA9IEFUVFJfU0laRTsKKwkJaWF0dHIuaWFfc2l6ZSA9IG5ld19zaXplOworCQllcnJvciA9IC14ZnNfc2V0YXR0cihpcCwgJmlhdHRyLCBYRlNfQVRUUl9OT0xPQ0spOworCX0KKworb3V0X3VubG9jazoKKwl4ZnNfaXVubG9jayhpcCwgWEZTX0lPTE9DS19FWENMKTsKKwlyZXR1cm4gZXJyb3I7Cit9CisKKwogU1RBVElDIGludAogeGZzX2ZpbGVfb3BlbigKIAlzdHJ1Y3QgaW5vZGUJKmlub2RlLApAQCAtOTIxLDYgKzEwNTUsNyBAQAogCS5vcGVuCQk9IHhmc19maWxlX29wZW4sCiAJLnJlbGVhc2UJPSB4ZnNfZmlsZV9yZWxlYXNlLAogCS5mc3luYwkJPSB4ZnNfZmlsZV9mc3luYywKKwkuZmFsbG9jYXRlCT0geGZzX2ZpbGVfZmFsbG9jYXRlLAogfTsKIAogY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyB4ZnNfZGlyX2ZpbGVfb3BlcmF0aW9ucyA9IHsKZGlmZiAtLWdpdCBhL2ZzL3hmcy9saW51eC0yLjYveGZzX2lvY3RsLmMgYi9mcy94ZnMvbGludXgtMi42L3hmc19pb2N0bC5jCmluZGV4IGFkNDQyZDkuLmY1ZTJhMTkgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy9saW51eC0yLjYveGZzX2lvY3RsLmMKKysrIGIvZnMveGZzL2xpbnV4LTIuNi94ZnNfaW9jdGwuYwpAQCAtMzksNiArMzksNyBAQAogI2luY2x1ZGUgInhmc19kZnJhZy5oIgogI2luY2x1ZGUgInhmc19mc29wcy5oIgogI2luY2x1ZGUgInhmc192bm9kZW9wcy5oIgorI2luY2x1ZGUgInhmc19kaXNjYXJkLmgiCiAjaW5jbHVkZSAieGZzX3F1b3RhLmgiCiAjaW5jbHVkZSAieGZzX2lub2RlX2l0ZW0uaCIKICNpbmNsdWRlICJ4ZnNfZXhwb3J0LmgiCkBAIC05ODQsMTAgKzk4NSwyMiBAQAogCiAJCS8qCiAJCSAqIEV4dGVudCBzaXplIG11c3QgYmUgYSBtdWx0aXBsZSBvZiB0aGUgYXBwcm9wcmlhdGUgYmxvY2sKLQkJICogc2l6ZSwgaWYgc2V0IGF0IGFsbC4KKwkJICogc2l6ZSwgaWYgc2V0IGF0IGFsbC4gSXQgbXVzdCBhbHNvIGJlIHNtYWxsZXIgdGhhbiB0aGUKKwkJICogbWF4aW11bSBleHRlbnQgc2l6ZSBzdXBwb3J0ZWQgYnkgdGhlIGZpbGVzeXN0ZW0uCisJCSAqCisJCSAqIEFsc28sIGZvciBub24tcmVhbHRpbWUgZmlsZXMsIGxpbWl0IHRoZSBleHRlbnQgc2l6ZSBoaW50IHRvCisJCSAqIGhhbGYgdGhlIHNpemUgb2YgdGhlIEFHcyBpbiB0aGUgZmlsZXN5c3RlbSBzbyBhbGlnbm1lbnQKKwkJICogZG9lc24ndCByZXN1bHQgaW4gZXh0ZW50cyBsYXJnZXIgdGhhbiBhbiBBRy4KIAkJICovCiAJCWlmIChmYS0+ZnN4X2V4dHNpemUgIT0gMCkgewotCQkJeGZzX2V4dGxlbl90CXNpemU7CisJCQl4ZnNfZXh0bGVuX3QgICAgc2l6ZTsKKwkJCXhmc19mc2Jsb2NrX3QgICBleHRzaXplX2ZzYjsKKworCQkJZXh0c2l6ZV9mc2IgPSBYRlNfQl9UT19GU0IobXAsIGZhLT5mc3hfZXh0c2l6ZSk7CisJCQlpZiAoZXh0c2l6ZV9mc2IgPiBNQVhFWFRMRU4pIHsKKwkJCQljb2RlID0gWEZTX0VSUk9SKEVJTlZBTCk7CisJCQkJZ290byBlcnJvcl9yZXR1cm47CisJCQl9CiAKIAkJCWlmIChYRlNfSVNfUkVBTFRJTUVfSU5PREUoaXApIHx8CiAJCQkgICAgKChtYXNrICYgRlNYX1hGTEFHUykgJiYKQEAgLTk5Niw2ICsxMDA5LDEwIEBACiAJCQkJICAgICAgIG1wLT5tX3NiLnNiX2Jsb2NrbG9nOwogCQkJfSBlbHNlIHsKIAkJCQlzaXplID0gbXAtPm1fc2Iuc2JfYmxvY2tzaXplOworCQkJCWlmIChleHRzaXplX2ZzYiA+IG1wLT5tX3NiLnNiX2FnYmxvY2tzIC8gMikgeworCQkJCQljb2RlID0gWEZTX0VSUk9SKEVJTlZBTCk7CisJCQkJCWdvdG8gZXJyb3JfcmV0dXJuOworCQkJCX0KIAkJCX0KIAogCQkJaWYgKGZhLT5mc3hfZXh0c2l6ZSAlIHNpemUpIHsKQEAgLTEyOTQsNiArMTMxMSw4IEBACiAJdHJhY2VfeGZzX2ZpbGVfaW9jdGwoaXApOwogCiAJc3dpdGNoIChjbWQpIHsKKwljYXNlIEZJVFJJTToKKwkJcmV0dXJuIHhmc19pb2NfdHJpbShtcCwgYXJnKTsKIAljYXNlIFhGU19JT0NfQUxMT0NTUDoKIAljYXNlIFhGU19JT0NfRlJFRVNQOgogCWNhc2UgWEZTX0lPQ19SRVNWU1A6CmRpZmYgLS1naXQgYS9mcy94ZnMvbGludXgtMi42L3hmc19pb3BzLmMgYi9mcy94ZnMvbGludXgtMi42L3hmc19pb3BzLmMKaW5kZXggZGE1NDQwMy4uYmQ1NzI3OCAxMDA2NDQKLS0tIGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfaW9wcy5jCisrKyBiL2ZzL3hmcy9saW51eC0yLjYveGZzX2lvcHMuYwpAQCAtNDYsNyArNDYsNiBAQAogI2luY2x1ZGUgPGxpbnV4L25hbWVpLmg+CiAjaW5jbHVkZSA8bGludXgvcG9zaXhfYWNsLmg+CiAjaW5jbHVkZSA8bGludXgvc2VjdXJpdHkuaD4KLSNpbmNsdWRlIDxsaW51eC9mYWxsb2MuaD4KICNpbmNsdWRlIDxsaW51eC9maWVtYXAuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAKQEAgLTUwNSw2MSArNTA0LDYgQEAKIAlyZXR1cm4gLXhmc19zZXRhdHRyKFhGU19JKGRlbnRyeS0+ZF9pbm9kZSksIGlhdHRyLCAwKTsKIH0KIAotU1RBVElDIGxvbmcKLXhmc192bl9mYWxsb2NhdGUoCi0Jc3RydWN0IGlub2RlCSppbm9kZSwKLQlpbnQJCW1vZGUsCi0JbG9mZl90CQlvZmZzZXQsCi0JbG9mZl90CQlsZW4pCi17Ci0JbG9uZwkJZXJyb3I7Ci0JbG9mZl90CQluZXdfc2l6ZSA9IDA7Ci0JeGZzX2Zsb2NrNjRfdAliZjsKLQl4ZnNfaW5vZGVfdAkqaXAgPSBYRlNfSShpbm9kZSk7Ci0JaW50CQljbWQgPSBYRlNfSU9DX1JFU1ZTUDsKLQotCS8qIHByZWFsbG9jYXRpb24gb24gZGlyZWN0b3JpZXMgbm90IHlldCBzdXBwb3J0ZWQgKi8KLQllcnJvciA9IC1FTk9ERVY7Ci0JaWYgKFNfSVNESVIoaW5vZGUtPmlfbW9kZSkpCi0JCWdvdG8gb3V0X2Vycm9yOwotCi0JYmYubF93aGVuY2UgPSAwOwotCWJmLmxfc3RhcnQgPSBvZmZzZXQ7Ci0JYmYubF9sZW4gPSBsZW47Ci0KLQl4ZnNfaWxvY2soaXAsIFhGU19JT0xPQ0tfRVhDTCk7Ci0KLQlpZiAobW9kZSAmIEZBTExPQ19GTF9QVU5DSF9IT0xFKQotCQljbWQgPSBYRlNfSU9DX1VOUkVTVlNQOwotCi0JLyogY2hlY2sgdGhlIG5ldyBpbm9kZSBzaXplIGlzIHZhbGlkIGJlZm9yZSBhbGxvY2F0aW5nICovCi0JaWYgKCEobW9kZSAmIEZBTExPQ19GTF9LRUVQX1NJWkUpICYmCi0JICAgIG9mZnNldCArIGxlbiA+IGlfc2l6ZV9yZWFkKGlub2RlKSkgewotCQluZXdfc2l6ZSA9IG9mZnNldCArIGxlbjsKLQkJZXJyb3IgPSBpbm9kZV9uZXdzaXplX29rKGlub2RlLCBuZXdfc2l6ZSk7Ci0JCWlmIChlcnJvcikKLQkJCWdvdG8gb3V0X3VubG9jazsKLQl9Ci0KLQllcnJvciA9IC14ZnNfY2hhbmdlX2ZpbGVfc3BhY2UoaXAsIGNtZCwgJmJmLCAwLCBYRlNfQVRUUl9OT0xPQ0spOwotCWlmIChlcnJvcikKLQkJZ290byBvdXRfdW5sb2NrOwotCi0JLyogQ2hhbmdlIGZpbGUgc2l6ZSBpZiBuZWVkZWQgKi8KLQlpZiAobmV3X3NpemUpIHsKLQkJc3RydWN0IGlhdHRyIGlhdHRyOwotCi0JCWlhdHRyLmlhX3ZhbGlkID0gQVRUUl9TSVpFOwotCQlpYXR0ci5pYV9zaXplID0gbmV3X3NpemU7Ci0JCWVycm9yID0gLXhmc19zZXRhdHRyKGlwLCAmaWF0dHIsIFhGU19BVFRSX05PTE9DSyk7Ci0JfQotCi1vdXRfdW5sb2NrOgotCXhmc19pdW5sb2NrKGlwLCBYRlNfSU9MT0NLX0VYQ0wpOwotb3V0X2Vycm9yOgotCXJldHVybiBlcnJvcjsKLX0KLQogI2RlZmluZSBYRlNfRklFTUFQX0ZMQUdTCShGSUVNQVBfRkxBR19TWU5DfEZJRU1BUF9GTEFHX1hBVFRSKQogCiAvKgpAQCAtNjUzLDcgKzU5Nyw2IEBACiAJLmdldHhhdHRyCQk9IGdlbmVyaWNfZ2V0eGF0dHIsCiAJLnJlbW92ZXhhdHRyCQk9IGdlbmVyaWNfcmVtb3ZleGF0dHIsCiAJLmxpc3R4YXR0cgkJPSB4ZnNfdm5fbGlzdHhhdHRyLAotCS5mYWxsb2NhdGUJCT0geGZzX3ZuX2ZhbGxvY2F0ZSwKIAkuZmllbWFwCQkJPSB4ZnNfdm5fZmllbWFwLAogfTsKIApkaWZmIC0tZ2l0IGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfc3VwZXIuYyBiL2ZzL3hmcy9saW51eC0yLjYveGZzX3N1cGVyLmMKaW5kZXggYmQwN2Y3My4uOTczMTg5OCAxMDA2NDQKLS0tIGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfc3VwZXIuYworKysgYi9mcy94ZnMvbGludXgtMi42L3hmc19zdXBlci5jCkBAIC0xNDE0LDcgKzE0MTQsNyBAQAogCiAJeGZzX3NhdmVfcmVzdmJsa3MobXApOwogCXhmc19xdWllc2NlX2F0dHIobXApOwotCXJldHVybiAteGZzX2ZzX2xvZ19kdW1teShtcCwgU1lOQ19XQUlUKTsKKwlyZXR1cm4gLXhmc19mc19sb2dfZHVtbXkobXApOwogfQogCiBTVEFUSUMgaW50CmRpZmYgLS1naXQgYS9mcy94ZnMvbGludXgtMi42L3hmc19zeW5jLmMgYi9mcy94ZnMvbGludXgtMi42L3hmc19zeW5jLmMKaW5kZXggYTAyNDgwZC4uZTIyZjAwNSAxMDA2NDQKLS0tIGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfc3luYy5jCisrKyBiL2ZzL3hmcy9saW51eC0yLjYveGZzX3N5bmMuYwpAQCAtMzYyLDcgKzM2Miw3IEBACiAKIAkvKiBtYXJrIHRoZSBsb2cgYXMgY292ZXJlZCBpZiBuZWVkZWQgKi8KIAlpZiAoeGZzX2xvZ19uZWVkX2NvdmVyZWQobXApKQotCQllcnJvcjIgPSB4ZnNfZnNfbG9nX2R1bW15KG1wLCBTWU5DX1dBSVQpOworCQllcnJvcjIgPSB4ZnNfZnNfbG9nX2R1bW15KG1wKTsKIAogCS8qIGZsdXNoIGRhdGEtb25seSBkZXZpY2VzICovCiAJaWYgKG1wLT5tX3J0ZGV2X3RhcmdwKQpAQCAtNTAzLDEzICs1MDMsMTQgQEAKIAlpbnQJCWVycm9yOwogCiAJaWYgKCEobXAtPm1fZmxhZ3MgJiBYRlNfTU9VTlRfUkRPTkxZKSkgewotCQl4ZnNfbG9nX2ZvcmNlKG1wLCAwKTsKLQkJeGZzX3JlY2xhaW1faW5vZGVzKG1wLCAwKTsKIAkJLyogZGdjOiBlcnJvcnMgaWdub3JlZCBoZXJlICovCi0JCWVycm9yID0geGZzX3FtX3N5bmMobXAsIFNZTkNfVFJZTE9DSyk7CiAJCWlmIChtcC0+bV9zdXBlci0+c19mcm96ZW4gPT0gU0JfVU5GUk9aRU4gJiYKIAkJICAgIHhmc19sb2dfbmVlZF9jb3ZlcmVkKG1wKSkKLQkJCWVycm9yID0geGZzX2ZzX2xvZ19kdW1teShtcCwgMCk7CisJCQllcnJvciA9IHhmc19mc19sb2dfZHVtbXkobXApOworCQllbHNlCisJCQl4ZnNfbG9nX2ZvcmNlKG1wLCAwKTsKKwkJeGZzX3JlY2xhaW1faW5vZGVzKG1wLCAwKTsKKwkJZXJyb3IgPSB4ZnNfcW1fc3luYyhtcCwgU1lOQ19UUllMT0NLKTsKIAl9CiAJbXAtPm1fc3luY19zZXErKzsKIAl3YWtlX3VwKCZtcC0+bV93YWl0X3NpbmdsZV9zeW5jX3Rhc2spOwpkaWZmIC0tZ2l0IGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfc3lzY3RsLmMgYi9mcy94ZnMvbGludXgtMi42L3hmc19zeXNjdGwuYwppbmRleCA3YmI1MDkyLi5lZTNjZWUwIDEwMDY0NAotLS0gYS9mcy94ZnMvbGludXgtMi42L3hmc19zeXNjdGwuYworKysgYi9mcy94ZnMvbGludXgtMi42L3hmc19zeXNjdGwuYwpAQCAtMTgsNiArMTgsNyBAQAogI2luY2x1ZGUgInhmcy5oIgogI2luY2x1ZGUgPGxpbnV4L3N5c2N0bC5oPgogI2luY2x1ZGUgPGxpbnV4L3Byb2NfZnMuaD4KKyNpbmNsdWRlICJ4ZnNfZXJyb3IuaCIKIAogc3RhdGljIHN0cnVjdCBjdGxfdGFibGVfaGVhZGVyICp4ZnNfdGFibGVfaGVhZGVyOwogCkBAIC01MSw2ICs1MiwyNiBAQAogCiAJcmV0dXJuIHJldDsKIH0KKworU1RBVElDIGludAoreGZzX3BhbmljX21hc2tfcHJvY19oYW5kbGVyKAorCWN0bF90YWJsZQkqY3RsLAorCWludAkJd3JpdGUsCisJdm9pZAkJX191c2VyICpidWZmZXIsCisJc2l6ZV90CQkqbGVucCwKKwlsb2ZmX3QJCSpwcG9zKQoreworCWludAkJcmV0LCAqdmFscCA9IGN0bC0+ZGF0YTsKKworCXJldCA9IHByb2NfZG9pbnR2ZWNfbWlubWF4KGN0bCwgd3JpdGUsIGJ1ZmZlciwgbGVucCwgcHBvcyk7CisJaWYgKCFyZXQgJiYgd3JpdGUpIHsKKwkJeGZzX3BhbmljX21hc2sgPSAqdmFscDsKKyNpZmRlZiBERUJVRworCQl4ZnNfcGFuaWNfbWFzayB8PSAoWEZTX1BUQUdfU0hVVERPV05fQ09SUlVQVCB8IFhGU19QVEFHX0xPR1JFUyk7CisjZW5kaWYKKwl9CisJcmV0dXJuIHJldDsKK30KICNlbmRpZiAvKiBDT05GSUdfUFJPQ19GUyAqLwogCiBzdGF0aWMgY3RsX3RhYmxlIHhmc190YWJsZVtdID0gewpAQCAtNzcsNyArOTgsNyBAQAogCQkuZGF0YQkJPSAmeGZzX3BhcmFtcy5wYW5pY19tYXNrLnZhbCwKIAkJLm1heGxlbgkJPSBzaXplb2YoaW50KSwKIAkJLm1vZGUJCT0gMDY0NCwKLQkJLnByb2NfaGFuZGxlcgk9IHByb2NfZG9pbnR2ZWNfbWlubWF4LAorCQkucHJvY19oYW5kbGVyCT0geGZzX3BhbmljX21hc2tfcHJvY19oYW5kbGVyLAogCQkuZXh0cmExCQk9ICZ4ZnNfcGFyYW1zLnBhbmljX21hc2subWluLAogCQkuZXh0cmEyCQk9ICZ4ZnNfcGFyYW1zLnBhbmljX21hc2subWF4CiAJfSwKZGlmZiAtLWdpdCBhL2ZzL3hmcy9saW51eC0yLjYveGZzX3RyYWNlLmggYi9mcy94ZnMvbGludXgtMi42L3hmc190cmFjZS5oCmluZGV4IDY0N2FmMmEuLjJkMGJjYjQgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy9saW51eC0yLjYveGZzX3RyYWNlLmgKKysrIGIvZnMveGZzL2xpbnV4LTIuNi94ZnNfdHJhY2UuaApAQCAtMTc1OSw2ICsxNzU5LDM5IEBACiBERUZJTkVfTE9HX1JFQ09WRVJfSU5PX0lURU0oeGZzX2xvZ19yZWNvdmVyX2lub2RlX2NhbmNlbCk7CiBERUZJTkVfTE9HX1JFQ09WRVJfSU5PX0lURU0oeGZzX2xvZ19yZWNvdmVyX2lub2RlX3NraXApOwogCitERUNMQVJFX0VWRU5UX0NMQVNTKHhmc19kaXNjYXJkX2NsYXNzLAorCVRQX1BST1RPKHN0cnVjdCB4ZnNfbW91bnQgKm1wLCB4ZnNfYWdudW1iZXJfdCBhZ25vLAorCQkgeGZzX2FnYmxvY2tfdCBhZ2JubywgeGZzX2V4dGxlbl90IGxlbiksCisJVFBfQVJHUyhtcCwgYWdubywgYWdibm8sIGxlbiksCisJVFBfU1RSVUNUX19lbnRyeSgKKwkJX19maWVsZChkZXZfdCwgZGV2KQorCQlfX2ZpZWxkKHhmc19hZ251bWJlcl90LCBhZ25vKQorCQlfX2ZpZWxkKHhmc19hZ2Jsb2NrX3QsIGFnYm5vKQorCQlfX2ZpZWxkKHhmc19leHRsZW5fdCwgbGVuKQorCSksCisJVFBfZmFzdF9hc3NpZ24oCisJCV9fZW50cnktPmRldiA9IG1wLT5tX3N1cGVyLT5zX2RldjsKKwkJX19lbnRyeS0+YWdubyA9IGFnbm87CisJCV9fZW50cnktPmFnYm5vID0gYWdibm87CisJCV9fZW50cnktPmxlbiA9IGxlbjsKKwkpLAorCVRQX3ByaW50aygiZGV2ICVkOiVkIGFnbm8gJXUgYWdibm8gJXUgbGVuICV1XG4iLAorCQkgIE1BSk9SKF9fZW50cnktPmRldiksIE1JTk9SKF9fZW50cnktPmRldiksCisJCSAgX19lbnRyeS0+YWdubywKKwkJICBfX2VudHJ5LT5hZ2JubywKKwkJICBfX2VudHJ5LT5sZW4pCispCisKKyNkZWZpbmUgREVGSU5FX0RJU0NBUkRfRVZFTlQobmFtZSkgXAorREVGSU5FX0VWRU5UKHhmc19kaXNjYXJkX2NsYXNzLCBuYW1lLCBcCisJVFBfUFJPVE8oc3RydWN0IHhmc19tb3VudCAqbXAsIHhmc19hZ251bWJlcl90IGFnbm8sIFwKKwkJIHhmc19hZ2Jsb2NrX3QgYWdibm8sIHhmc19leHRsZW5fdCBsZW4pLCBcCisJVFBfQVJHUyhtcCwgYWdubywgYWdibm8sIGxlbikpCitERUZJTkVfRElTQ0FSRF9FVkVOVCh4ZnNfZGlzY2FyZF9leHRlbnQpOworREVGSU5FX0RJU0NBUkRfRVZFTlQoeGZzX2Rpc2NhcmRfdG9vc21hbGwpOworREVGSU5FX0RJU0NBUkRfRVZFTlQoeGZzX2Rpc2NhcmRfZXhjbHVkZSk7CitERUZJTkVfRElTQ0FSRF9FVkVOVCh4ZnNfZGlzY2FyZF9idXN5KTsKKwogI2VuZGlmIC8qIF9UUkFDRV9YRlNfSCAqLwogCiAjdW5kZWYgVFJBQ0VfSU5DTFVERV9QQVRICmRpZmYgLS1naXQgYS9mcy94ZnMvcXVvdGEveGZzX3FtLmMgYi9mcy94ZnMvcXVvdGEveGZzX3FtLmMKaW5kZXggZjhlODU0Yi4uMjA2YTI4MSAxMDA2NDQKLS0tIGEvZnMveGZzL3F1b3RhL3hmc19xbS5jCisrKyBiL2ZzL3hmcy9xdW90YS94ZnNfcW0uYwpAQCAtMTg2MywxMiArMTg2MywxNCBAQAogCXhmc19kcXVvdF90CSpkcXBvdXQ7CiAJeGZzX2RxdW90X3QJKmRxcDsKIAlpbnQJCXJlc3RhcnRzOworCWludAkJc3RhcnRhZ2FpbjsKIAogCXJlc3RhcnRzID0gMDsKIAlkcXBvdXQgPSBOVUxMOwogCiAJLyogbG9ja29yZGVyOiBoYXNoY2hhaW5sb2NrLCBmcmVlbGlzdGxvY2ssIG1wbGlzdGxvY2ssIGRxbG9jaywgZHFmbG9jayAqLwotc3RhcnRhZ2FpbjoKK2FnYWluOgorCXN0YXJ0YWdhaW4gPSAwOwogCW11dGV4X2xvY2soJnhmc19HcW0tPnFtX2RxZnJsaXN0X2xvY2spOwogCiAJbGlzdF9mb3JfZWFjaF9lbnRyeShkcXAsICZ4ZnNfR3FtLT5xbV9kcWZybGlzdCwgcV9mcmVlbGlzdCkgewpAQCAtMTg4NSwxMyArMTg4NywxMCBAQAogCQkJQVNTRVJUKCEgKGRxcC0+ZHFfZmxhZ3MgJiBYRlNfRFFfSU5BQ1RJVkUpKTsKIAogCQkJdHJhY2VfeGZzX2RxcmVjbGFpbV93YW50KGRxcCk7Ci0KLQkJCXhmc19kcXVubG9jayhkcXApOwotCQkJbXV0ZXhfdW5sb2NrKCZ4ZnNfR3FtLT5xbV9kcWZybGlzdF9sb2NrKTsKLQkJCWlmICgrK3Jlc3RhcnRzID49IFhGU19RTV9SRUNMQUlNX01BWF9SRVNUQVJUUykKLQkJCQlyZXR1cm4gTlVMTDsKIAkJCVhRTV9TVEFUU19JTkMoeHFtc3RhdHMueHNfcW1fZHF3YW50cyk7Ci0JCQlnb3RvIHN0YXJ0YWdhaW47CisJCQlyZXN0YXJ0cysrOworCQkJc3RhcnRhZ2FpbiA9IDE7CisJCQlnb3RvIGRxdW5sb2NrOwogCQl9CiAKIAkJLyoKQEAgLTE5MDYsMjMgKzE5MDUsMjAgQEAKIAkJCUFTU0VSVChsaXN0X2VtcHR5KCZkcXAtPnFfbXBsaXN0KSk7CiAJCQlsaXN0X2RlbF9pbml0KCZkcXAtPnFfZnJlZWxpc3QpOwogCQkJeGZzX0dxbS0+cW1fZHFmcmxpc3RfY250LS07Ci0JCQl4ZnNfZHF1bmxvY2soZHFwKTsKIAkJCWRxcG91dCA9IGRxcDsKIAkJCVhRTV9TVEFUU19JTkMoeHFtc3RhdHMueHNfcW1fZHFpbmFjdF9yZWNsYWltcyk7Ci0JCQlicmVhazsKKwkJCWdvdG8gZHF1bmxvY2s7CiAJCX0KIAogCQlBU1NFUlQoZHFwLT5xX2hhc2gpOwogCQlBU1NFUlQoIWxpc3RfZW1wdHkoJmRxcC0+cV9tcGxpc3QpKTsKIAogCQkvKgotCQkgKiBUcnkgdG8gZ3JhYiB0aGUgZmx1c2ggbG9jay4gSWYgdGhpcyBkcXVvdCBpcyBpbiB0aGUgcHJvY2VzcyBvZgotCQkgKiBnZXR0aW5nIGZsdXNoZWQgdG8gZGlzaywgd2UgZG9uJ3Qgd2FudCB0byByZWNsYWltIGl0LgorCQkgKiBUcnkgdG8gZ3JhYiB0aGUgZmx1c2ggbG9jay4gSWYgdGhpcyBkcXVvdCBpcyBpbiB0aGUgcHJvY2VzcworCQkgKiBvZiBnZXR0aW5nIGZsdXNoZWQgdG8gZGlzaywgd2UgZG9uJ3Qgd2FudCB0byByZWNsYWltIGl0LgogCQkgKi8KLQkJaWYgKCF4ZnNfZHFmbG9ja19ub3dhaXQoZHFwKSkgewotCQkJeGZzX2RxdW5sb2NrKGRxcCk7Ci0JCQljb250aW51ZTsKLQkJfQorCQlpZiAoIXhmc19kcWZsb2NrX25vd2FpdChkcXApKQorCQkJZ290byBkcXVubG9jazsKIAogCQkvKgogCQkgKiBXZSBoYXZlIHRoZSBmbHVzaCBsb2NrIHNvIHdlIGtub3cgdGhhdCB0aGlzIGlzIG5vdCBpbiB0aGUKQEAgLTE5NDQsOCArMTk0MCw3IEBACiAJCQkJeGZzX2ZzX2Ntbl9lcnIoQ0VfV0FSTiwgbXAsCiAJCQkieGZzX3FtX2RxcmVjbGFpbTogZHF1b3QgJXAgZmx1c2ggZmFpbGVkIiwgZHFwKTsKIAkJCX0KLQkJCXhmc19kcXVubG9jayhkcXApOyAvKiBkcWZsdXNoIHVubG9ja3MgZHFmbG9jayAqLwotCQkJY29udGludWU7CisJCQlnb3RvIGRxdW5sb2NrOwogCQl9CiAKIAkJLyoKQEAgLTE5NjcsMTMgKzE5NjIsOCBAQAogCQkgKi8KIAkJaWYgKCFtdXRleF90cnlsb2NrKCZtcC0+bV9xdW90YWluZm8tPnFpX2RxbGlzdF9sb2NrKSkgewogCQkJcmVzdGFydHMrKzsKLQkJCW11dGV4X3VubG9jaygmZHFwLT5xX2hhc2gtPnFoX2xvY2spOwotCQkJeGZzX2RxZnVubG9jayhkcXApOwotCQkJeGZzX2RxdW5sb2NrKGRxcCk7Ci0JCQltdXRleF91bmxvY2soJnhmc19HcW0tPnFtX2RxZnJsaXN0X2xvY2spOwotCQkJaWYgKHJlc3RhcnRzKysgPj0gWEZTX1FNX1JFQ0xBSU1fTUFYX1JFU1RBUlRTKQotCQkJCXJldHVybiBOVUxMOwotCQkJZ290byBzdGFydGFnYWluOworCQkJc3RhcnRhZ2FpbiA9IDE7CisJCQlnb3RvIHFodW5sb2NrOwogCQl9CiAKIAkJQVNTRVJUKGRxcC0+cV9ucmVmcyA9PSAwKTsKQEAgLTE5ODYsMTQgKzE5NzYsMjAgQEAKIAkJeGZzX0dxbS0+cW1fZHFmcmxpc3RfY250LS07CiAJCWRxcG91dCA9IGRxcDsKIAkJbXV0ZXhfdW5sb2NrKCZtcC0+bV9xdW90YWluZm8tPnFpX2RxbGlzdF9sb2NrKTsKK3FodW5sb2NrOgogCQltdXRleF91bmxvY2soJmRxcC0+cV9oYXNoLT5xaF9sb2NrKTsKIGRxZnVubG9jazoKIAkJeGZzX2RxZnVubG9jayhkcXApOworZHF1bmxvY2s6CiAJCXhmc19kcXVubG9jayhkcXApOwogCQlpZiAoZHFwb3V0KQogCQkJYnJlYWs7CiAJCWlmIChyZXN0YXJ0cyA+PSBYRlNfUU1fUkVDTEFJTV9NQVhfUkVTVEFSVFMpCi0JCQlyZXR1cm4gTlVMTDsKKwkJCWJyZWFrOworCQlpZiAoc3RhcnRhZ2FpbikgeworCQkJbXV0ZXhfdW5sb2NrKCZ4ZnNfR3FtLT5xbV9kcWZybGlzdF9sb2NrKTsKKwkJCWdvdG8gYWdhaW47CisJCX0KIAl9CiAJbXV0ZXhfdW5sb2NrKCZ4ZnNfR3FtLT5xbV9kcWZybGlzdF9sb2NrKTsKIAlyZXR1cm4gZHFwb3V0OwpkaWZmIC0tZ2l0IGEvZnMveGZzL3N1cHBvcnQvZGVidWcuYyBiL2ZzL3hmcy9zdXBwb3J0L2RlYnVnLmMKaW5kZXggOTc1YWExMC4uMGRmODg4OSAxMDA2NDQKLS0tIGEvZnMveGZzL3N1cHBvcnQvZGVidWcuYworKysgYi9mcy94ZnMvc3VwcG9ydC9kZWJ1Zy5jCkBAIC0yNSw4NiArMjUsNzggQEAKICNpbmNsdWRlICJ4ZnNfbW91bnQuaCIKICNpbmNsdWRlICJ4ZnNfZXJyb3IuaCIKIAotc3RhdGljIGNoYXIJCW1lc3NhZ2VbMTAyNF07CS8qIGtlZXAgaXQgb2ZmIHRoZSBzdGFjayAqLwotc3RhdGljIERFRklORV9TUElOTE9DSyh4ZnNfZXJyX2xvY2spOwotCi0vKiBUcmFuc2xhdGUgZnJvbSBDRV9GT08gdG8gS0VSTl9GT08sIGVycl9sZXZlbChDRV9GT08pID09IEtFUk5fRk9PICovCi0jZGVmaW5lIFhGU19NQVhfRVJSX0xFVkVMCTcKLSNkZWZpbmUgWEZTX0VSUl9NQVNLCQkoKDEgPDwgMykgLSAxKQotc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdAllcnJfbGV2ZWxbWEZTX01BWF9FUlJfTEVWRUwrMV0gPQotCQkJCQl7S0VSTl9FTUVSRywgS0VSTl9BTEVSVCwgS0VSTl9DUklULAotCQkJCQkgS0VSTl9FUlIsIEtFUk5fV0FSTklORywgS0VSTl9OT1RJQ0UsCi0JCQkJCSBLRVJOX0lORk8sIEtFUk5fREVCVUd9OwotCiB2b2lkCi1jbW5fZXJyKHJlZ2lzdGVyIGludCBsZXZlbCwgY2hhciAqZm10LCAuLi4pCitjbW5fZXJyKAorCWNvbnN0IGNoYXIJKmx2bCwKKwljb25zdCBjaGFyCSpmbXQsCisJLi4uKQogewotCWNoYXIJKmZwID0gZm10OwotCWludAlsZW47Ci0JdWxvbmcJZmxhZ3M7Ci0JdmFfbGlzdAlhcDsKKwlzdHJ1Y3QgdmFfZm9ybWF0IHZhZjsKKwl2YV9saXN0CQlhcmdzOwogCi0JbGV2ZWwgJj0gWEZTX0VSUl9NQVNLOwotCWlmIChsZXZlbCA+IFhGU19NQVhfRVJSX0xFVkVMKQotCQlsZXZlbCA9IFhGU19NQVhfRVJSX0xFVkVMOwotCXNwaW5fbG9ja19pcnFzYXZlKCZ4ZnNfZXJyX2xvY2ssZmxhZ3MpOwotCXZhX3N0YXJ0KGFwLCBmbXQpOwotCWlmICgqZm10ID09ICchJykgZnArKzsKLQlsZW4gPSB2c25wcmludGYobWVzc2FnZSwgc2l6ZW9mKG1lc3NhZ2UpLCBmcCwgYXApOwotCWlmIChsZW4gPj0gc2l6ZW9mKG1lc3NhZ2UpKQotCQlsZW4gPSBzaXplb2YobWVzc2FnZSkgLSAxOwotCWlmIChtZXNzYWdlW2xlbi0xXSA9PSAnXG4nKQotCQltZXNzYWdlW2xlbi0xXSA9IDA7Ci0JcHJpbnRrKCIlcyVzXG4iLCBlcnJfbGV2ZWxbbGV2ZWxdLCBtZXNzYWdlKTsKLQl2YV9lbmQoYXApOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnhmc19lcnJfbG9jayxmbGFncyk7Ci0JQlVHX09OKGxldmVsID09IENFX1BBTklDKTsKKwl2YV9zdGFydChhcmdzLCBmbXQpOworCXZhZi5mbXQgPSBmbXQ7CisJdmFmLnZhID0gJmFyZ3M7CisKKwlwcmludGsoIiVzJXBWIiwgbHZsLCAmdmFmKTsKKwl2YV9lbmQoYXJncyk7CisKKwlCVUdfT04oc3RybmNtcChsdmwsIEtFUk5fRU1FUkcsIHN0cmxlbihLRVJOX0VNRVJHKSkgPT0gMCk7CiB9CiAKIHZvaWQKLXhmc19mc192Y21uX2VycigKLQlpbnQJCQlsZXZlbCwKK3hmc19mc19jbW5fZXJyKAorCWNvbnN0IGNoYXIJCSpsdmwsCiAJc3RydWN0IHhmc19tb3VudAkqbXAsCi0JY2hhcgkJCSpmbXQsCi0JdmFfbGlzdAkJCWFwKQorCWNvbnN0IGNoYXIJCSpmbXQsCisJLi4uKQogewotCXVuc2lnbmVkIGxvbmcJCWZsYWdzOwotCWludAkJCWxlbiA9IDA7CisJc3RydWN0IHZhX2Zvcm1hdAl2YWY7CisJdmFfbGlzdAkJCWFyZ3M7CiAKLQlsZXZlbCAmPSBYRlNfRVJSX01BU0s7Ci0JaWYgKGxldmVsID4gWEZTX01BWF9FUlJfTEVWRUwpCi0JCWxldmVsID0gWEZTX01BWF9FUlJfTEVWRUw7CisJdmFfc3RhcnQoYXJncywgZm10KTsKKwl2YWYuZm10ID0gZm10OworCXZhZi52YSA9ICZhcmdzOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJnhmc19lcnJfbG9jayxmbGFncyk7CisJcHJpbnRrKCIlc0ZpbGVzeXN0ZW0gJXM6ICVwViIsIGx2bCwgbXAtPm1fZnNuYW1lLCAmdmFmKTsKKwl2YV9lbmQoYXJncyk7CiAKLQlpZiAobXApIHsKLQkJbGVuID0gc3ByaW50ZihtZXNzYWdlLCAiRmlsZXN5c3RlbSBcIiVzXCI6ICIsIG1wLT5tX2ZzbmFtZSk7CisJQlVHX09OKHN0cm5jbXAobHZsLCBLRVJOX0VNRVJHLCBzdHJsZW4oS0VSTl9FTUVSRykpID09IDApOworfQogCi0JCS8qCi0JCSAqIFNraXAgdGhlIHByaW50ayBpZiB3ZSBjYW4ndCBwcmludCBhbnl0aGluZyB1c2VmdWwKLQkJICogZHVlIHRvIGFuIG92ZXItbG9uZyBkZXZpY2UgbmFtZS4KLQkJICovCi0JCWlmIChsZW4gPj0gc2l6ZW9mKG1lc3NhZ2UpKQotCQkJZ290byBvdXQ7CisvKiBBbGwgY2FsbGVycyB0byB4ZnNfY21uX2VyciB1c2UgQ0VfQUxFUlQsIHNvIGRvbid0IGJvdGhlciB0ZXN0aW5nIGx2bCAqLwordm9pZAoreGZzX2Ntbl9lcnIoCisJaW50CQkJcGFuaWNfdGFnLAorCWNvbnN0IGNoYXIJCSpsdmwsCisJc3RydWN0IHhmc19tb3VudAkqbXAsCisJY29uc3QgY2hhcgkJKmZtdCwKKwkuLi4pCit7CisJc3RydWN0IHZhX2Zvcm1hdAl2YWY7CisJdmFfbGlzdAkJCWFyZ3M7CisJaW50CQkJZG9fcGFuaWMgPSAwOworCisJaWYgKHhmc19wYW5pY19tYXNrICYmICh4ZnNfcGFuaWNfbWFzayAmIHBhbmljX3RhZykpIHsKKwkJcHJpbnRrKEtFUk5fQUxFUlQgIlhGUzogVHJhbnNmb3JtaW5nIGFuIGFsZXJ0IGludG8gYSBCVUcuIik7CisJCWRvX3BhbmljID0gMTsKIAl9CiAKLQlsZW4gPSB2c25wcmludGYobWVzc2FnZSArIGxlbiwgc2l6ZW9mKG1lc3NhZ2UpIC0gbGVuLCBmbXQsIGFwKTsKLQlpZiAobGVuID49IHNpemVvZihtZXNzYWdlKSkKLQkJbGVuID0gc2l6ZW9mKG1lc3NhZ2UpIC0gMTsKLQlpZiAobWVzc2FnZVtsZW4tMV0gPT0gJ1xuJykKLQkJbWVzc2FnZVtsZW4tMV0gPSAwOworCXZhX3N0YXJ0KGFyZ3MsIGZtdCk7CisJdmFmLmZtdCA9IGZtdDsKKwl2YWYudmEgPSAmYXJnczsKIAotCXByaW50aygiJXMlc1xuIiwgZXJyX2xldmVsW2xldmVsXSwgbWVzc2FnZSk7Ci0gb3V0OgotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnhmc19lcnJfbG9jayxmbGFncyk7CisJcHJpbnRrKEtFUk5fQUxFUlQgIkZpbGVzeXN0ZW0gJXM6ICVwViIsIG1wLT5tX2ZzbmFtZSwgJnZhZik7CisJdmFfZW5kKGFyZ3MpOwogCi0JQlVHX09OKGxldmVsID09IENFX1BBTklDKTsKKwlCVUdfT04oZG9fcGFuaWMpOwogfQogCiB2b2lkCiBhc3NmYWlsKGNoYXIgKmV4cHIsIGNoYXIgKmZpbGUsIGludCBsaW5lKQogewotCXByaW50aygiQXNzZXJ0aW9uIGZhaWxlZDogJXMsIGZpbGU6ICVzLCBsaW5lOiAlZFxuIiwgZXhwciwgZmlsZSwgbGluZSk7CisJcHJpbnRrKEtFUk5fQ1JJVCAiQXNzZXJ0aW9uIGZhaWxlZDogJXMsIGZpbGU6ICVzLCBsaW5lOiAlZFxuIiwgZXhwciwKKwkgICAgICAgZmlsZSwgbGluZSk7CiAJQlVHKCk7CiB9CiAKZGlmZiAtLWdpdCBhL2ZzL3hmcy9zdXBwb3J0L2RlYnVnLmggYi9mcy94ZnMvc3VwcG9ydC9kZWJ1Zy5oCmluZGV4IGQyZDIwNDYuLjA1Njk5ZjYgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy9zdXBwb3J0L2RlYnVnLmgKKysrIGIvZnMveGZzL3N1cHBvcnQvZGVidWcuaApAQCAtMjAsMTUgKzIwLDIyIEBACiAKICNpbmNsdWRlIDxzdGRhcmcuaD4KIAotI2RlZmluZSBDRV9ERUJVRyAgICAgICAgNyAgICAgICAgICAgICAgIC8qIGRlYnVnICAgICAgICAqLwotI2RlZmluZSBDRV9DT05UICAgICAgICAgNiAgICAgICAgICAgICAgIC8qIGNvbnRpbnVhdGlvbiAqLwotI2RlZmluZSBDRV9OT1RFICAgICAgICAgNSAgICAgICAgICAgICAgIC8qIG5vdGljZSAgICAgICAqLwotI2RlZmluZSBDRV9XQVJOICAgICAgICAgNCAgICAgICAgICAgICAgIC8qIHdhcm5pbmcgICAgICAqLwotI2RlZmluZSBDRV9BTEVSVCAgICAgICAgMSAgICAgICAgICAgICAgIC8qIGFsZXJ0ICAgICAgICAqLwotI2RlZmluZSBDRV9QQU5JQyAgICAgICAgMCAgICAgICAgICAgICAgIC8qIHBhbmljICAgICAgICAqLworc3RydWN0IHhmc19tb3VudDsKIAotZXh0ZXJuIHZvaWQgY21uX2VycihpbnQsIGNoYXIgKiwgLi4uKQotCV9fYXR0cmlidXRlX18gKChmb3JtYXQgKHByaW50ZiwgMiwgMykpKTsKKyNkZWZpbmUgQ0VfREVCVUcgICAgICAgIEtFUk5fREVCVUcKKyNkZWZpbmUgQ0VfQ09OVCAgICAgICAgIEtFUk5fSU5GTworI2RlZmluZSBDRV9OT1RFICAgICAgICAgS0VSTl9OT1RJQ0UKKyNkZWZpbmUgQ0VfV0FSTiAgICAgICAgIEtFUk5fV0FSTklORworI2RlZmluZSBDRV9BTEVSVCAgICAgICAgS0VSTl9BTEVSVAorI2RlZmluZSBDRV9QQU5JQyAgICAgICAgS0VSTl9FTUVSRworCit2b2lkIGNtbl9lcnIoY29uc3QgY2hhciAqbHZsLCBjb25zdCBjaGFyICpmbXQsIC4uLikKKwkJX19hdHRyaWJ1dGVfXyAoKGZvcm1hdCAocHJpbnRmLCAyLCAzKSkpOwordm9pZCB4ZnNfZnNfY21uX2VyciggY29uc3QgY2hhciAqbHZsLCBzdHJ1Y3QgeGZzX21vdW50ICptcCwKKwkJY29uc3QgY2hhciAqZm10LCAuLi4pIF9fYXR0cmlidXRlX18gKChmb3JtYXQgKHByaW50ZiwgMywgNCkpKTsKK3ZvaWQgeGZzX2Ntbl9lcnIoIGludCBwYW5pY190YWcsIGNvbnN0IGNoYXIgKmx2bCwgc3RydWN0IHhmc19tb3VudCAqbXAsCisJCWNvbnN0IGNoYXIgKmZtdCwgLi4uKSBfX2F0dHJpYnV0ZV9fICgoZm9ybWF0IChwcmludGYsIDQsIDUpKSk7CisKIGV4dGVybiB2b2lkIGFzc2ZhaWwoY2hhciAqZXhwciwgY2hhciAqZiwgaW50IGwpOwogCiAjZGVmaW5lIEFTU0VSVF9BTFdBWVMoZXhwcikJXApkaWZmIC0tZ2l0IGEvZnMveGZzL3hmc19hbGxvYy5jIGIvZnMveGZzL3hmc19hbGxvYy5jCmluZGV4IGZhODcyM2YuLmYzMjI3OTggMTAwNjQ0Ci0tLSBhL2ZzL3hmcy94ZnNfYWxsb2MuYworKysgYi9mcy94ZnMveGZzX2FsbG9jLmMKQEAgLTQxLDEwICs0MSw2IEBACiAjZGVmaW5lCVhGU0FfRklYVVBfQk5PX09LCTEKICNkZWZpbmUJWEZTQV9GSVhVUF9DTlRfT0sJMgogCi1zdGF0aWMgaW50Ci14ZnNfYWxsb2NfYnVzeV9zZWFyY2goc3RydWN0IHhmc19tb3VudCAqbXAsIHhmc19hZ251bWJlcl90IGFnbm8sCi0JCSAgICB4ZnNfYWdibG9ja190IGJubywgeGZzX2V4dGxlbl90IGxlbik7Ci0KIC8qCiAgKiBQcm90b3R5cGVzIGZvciBwZXItYWcgYWxsb2NhdGlvbiByb3V0aW5lcwogICovCkBAIC05NCw3ICs5MCw3IEBACiAgKiBMb29rdXAgdGhlIGZpcnN0IHJlY29yZCBsZXNzIHRoYW4gb3IgZXF1YWwgdG8gW2JubywgbGVuXQogICogaW4gdGhlIGJ0cmVlIGdpdmVuIGJ5IGN1ci4KICAqLwotU1RBVElDIGludAkJCQkvKiBlcnJvciAqLworaW50CQkJCQkvKiBlcnJvciAqLwogeGZzX2FsbG9jX2xvb2t1cF9sZSgKIAlzdHJ1Y3QgeGZzX2J0cmVlX2N1cgkqY3VyLAkvKiBidHJlZSBjdXJzb3IgKi8KIAl4ZnNfYWdibG9ja190CQlibm8sCS8qIHN0YXJ0aW5nIGJsb2NrIG9mIGV4dGVudCAqLwpAQCAtMTI3LDcgKzEyMyw3IEBACiAvKgogICogR2V0IHRoZSBkYXRhIGZyb20gdGhlIHBvaW50ZWQtdG8gcmVjb3JkLgogICovCi1TVEFUSUMgaW50CQkJCS8qIGVycm9yICovCitpbnQJCQkJCS8qIGVycm9yICovCiB4ZnNfYWxsb2NfZ2V0X3JlYygKIAlzdHJ1Y3QgeGZzX2J0cmVlX2N1cgkqY3VyLAkvKiBidHJlZSBjdXJzb3IgKi8KIAl4ZnNfYWdibG9ja190CQkqYm5vLAkvKiBvdXRwdXQ6IHN0YXJ0aW5nIGJsb2NrIG9mIGV4dGVudCAqLwpAQCAtMjYxNSw3ICsyNjExLDcgQEAKICAqIHdpbGwgcmVxdWlyZSBhIHN5bmNocm9ub3VzIHRyYW5zYWN0aW9uLCBidXQgaXQgY2FuIHN0aWxsIGJlCiAgKiB1c2VkIHRvIGRpc3Rpbmd1aXNoIGJldHdlZW4gYSBwYXJ0aWFsIG9yIGV4YWN0IG1hdGNoLgogICovCi1zdGF0aWMgaW50CitpbnQKIHhmc19hbGxvY19idXN5X3NlYXJjaCgKIAlzdHJ1Y3QgeGZzX21vdW50CSptcCwKIAl4ZnNfYWdudW1iZXJfdAkJYWdubywKZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfYWxsb2MuaCBiL2ZzL3hmcy94ZnNfYWxsb2MuaAppbmRleCA4OTUwMDlhLi5kMGIzYmM3IDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX2FsbG9jLmgKKysrIGIvZnMveGZzL3hmc19hbGxvYy5oCkBAIC0xOSw2ICsxOSw3IEBACiAjZGVmaW5lCV9fWEZTX0FMTE9DX0hfXwogCiBzdHJ1Y3QgeGZzX2J1ZjsKK3N0cnVjdCB4ZnNfYnRyZWVfY3VyOwogc3RydWN0IHhmc19tb3VudDsKIHN0cnVjdCB4ZnNfcGVyYWc7CiBzdHJ1Y3QgeGZzX3RyYW5zOwpAQCAtNzQsNiArNzUsMjIgQEAKICNkZWZpbmUgWEZTX0FMTE9DX1NFVF9BU0lERShtcCkgICg0ICsgKChtcCktPm1fc2Iuc2JfYWdjb3VudCAqIDQpKQogCiAvKgorICogV2hlbiBkZWNpZGluZyBob3cgbXVjaCBzcGFjZSB0byBhbGxvY2F0ZSBvdXQgb2YgYW4gQUcsIHdlIGxpbWl0IHRoZQorICogYWxsb2NhdGlvbiBtYXhpbXVtIHNpemUgdG8gdGhlIHNpemUgdGhlIEFHLiBIb3dldmVyLCB3ZSBjYW5ub3QgdXNlIGFsbCB0aGUKKyAqIGJsb2NrcyBpbiB0aGUgQUcgLSBzb21lIGFyZSBwZXJtYW5lbnRseSB1c2VkIGJ5IG1ldGFkYXRhLiBUaGVzZQorICogYmxvY2tzIGFyZSBnZW5lcmFsbHk6CisgKgktIHRoZSBBRyBzdXBlcmJsb2NrLCBBR0YsIEFHSSBhbmQgQUdGTAorICoJLSB0aGUgQUdGIChibm8gYW5kIGNudCkgYW5kIEFHSSBidHJlZSByb290IGJsb2NrcworICoJLSA0IGJsb2NrcyBvbiB0aGUgQUdGTCBhY2NvcmRpbmcgdG8gWEZTX0FMTE9DX1NFVF9BU0lERSgpIGxpbWl0cworICoKKyAqIFRoZSBBRyBoZWFkZXJzIGFyZSBzZWN0b3Igc2l6ZWQsIHNvIHRoZSBhbW91bnQgb2Ygc3BhY2UgdGhleSB0YWtlIHVwIGlzCisgKiBkZXBlbmRlbnQgb24gZmlsZXN5c3RlbSBnZW9tZXRyeS4gVGhlIG90aGVycyBhcmUgYWxsIHNpbmdsZSBibG9ja3MuCisgKi8KKyNkZWZpbmUgWEZTX0FMTE9DX0FHX01BWF9VU0FCTEUobXApCVwKKwkoKG1wKS0+bV9zYi5zYl9hZ2Jsb2NrcyAtIFhGU19CQl9UT19GU0IobXAsIFhGU19GU1NfVE9fQkIobXAsIDQpKSAtIDcpCisKKworLyoKICAqIEFyZ3VtZW50IHN0cnVjdHVyZSBmb3IgeGZzX2FsbG9jIHJvdXRpbmVzLgogICogVGhpcyBpcyB0dXJuZWQgaW50byBhIHN0cnVjdHVyZSB0byBhdm9pZCBoYXZpbmcgMjAgYXJndW1lbnRzIHBhc3NlZAogICogZG93biBzZXZlcmFsIGxldmVscyBvZiB0aGUgc3RhY2suCkBAIC0xMTgsMTYgKzEzNSwxNiBAQAogCQlzdHJ1Y3QgeGZzX3BlcmFnICpwYWcpOwogCiAjaWZkZWYgX19LRVJORUxfXwotCiB2b2lkCi14ZnNfYWxsb2NfYnVzeV9pbnNlcnQoeGZzX3RyYW5zX3QgKnRwLAotCQl4ZnNfYWdudW1iZXJfdCBhZ25vLAotCQl4ZnNfYWdibG9ja190IGJubywKLQkJeGZzX2V4dGxlbl90IGxlbik7Cit4ZnNfYWxsb2NfYnVzeV9pbnNlcnQoc3RydWN0IHhmc190cmFucyAqdHAsIHhmc19hZ251bWJlcl90IGFnbm8sCisJeGZzX2FnYmxvY2tfdCBibm8sIHhmc19leHRsZW5fdCBsZW4pOwogCiB2b2lkCiB4ZnNfYWxsb2NfYnVzeV9jbGVhcihzdHJ1Y3QgeGZzX21vdW50ICptcCwgc3RydWN0IHhmc19idXN5X2V4dGVudCAqYnVzeXApOwogCitpbnQKK3hmc19hbGxvY19idXN5X3NlYXJjaChzdHJ1Y3QgeGZzX21vdW50ICptcCwgeGZzX2FnbnVtYmVyX3QgYWdubywKKwl4ZnNfYWdibG9ja190IGJubywgeGZzX2V4dGxlbl90IGxlbik7CiAjZW5kaWYJLyogX19LRVJORUxfXyAqLwogCiAvKgpAQCAtMjA1LDQgKzIyMiwxOCBAQAogCXhmc19mc2Jsb2NrX3QJYm5vLAkvKiBzdGFydGluZyBibG9jayBudW1iZXIgb2YgZXh0ZW50ICovCiAJeGZzX2V4dGxlbl90CWxlbik7CS8qIGxlbmd0aCBvZiBleHRlbnQgKi8KIAoraW50CQkJCQkvKiBlcnJvciAqLworeGZzX2FsbG9jX2xvb2t1cF9sZSgKKwlzdHJ1Y3QgeGZzX2J0cmVlX2N1cgkqY3VyLAkvKiBidHJlZSBjdXJzb3IgKi8KKwl4ZnNfYWdibG9ja190CQlibm8sCS8qIHN0YXJ0aW5nIGJsb2NrIG9mIGV4dGVudCAqLworCXhmc19leHRsZW5fdAkJbGVuLAkvKiBsZW5ndGggb2YgZXh0ZW50ICovCisJaW50CQkJKnN0YXQpOwkvKiBzdWNjZXNzL2ZhaWx1cmUgKi8KKworaW50CQkJCQkvKiBlcnJvciAqLworeGZzX2FsbG9jX2dldF9yZWMoCisJc3RydWN0IHhmc19idHJlZV9jdXIJKmN1ciwJLyogYnRyZWUgY3Vyc29yICovCisJeGZzX2FnYmxvY2tfdAkJKmJubywJLyogb3V0cHV0OiBzdGFydGluZyBibG9jayBvZiBleHRlbnQgKi8KKwl4ZnNfZXh0bGVuX3QJCSpsZW4sCS8qIG91dHB1dDogbGVuZ3RoIG9mIGV4dGVudCAqLworCWludAkJCSpzdGF0KTsJLyogb3V0cHV0OiBzdWNjZXNzL2ZhaWx1cmUgKi8KKwogI2VuZGlmCS8qIF9fWEZTX0FMTE9DX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZnMveGZzL3hmc19ibWFwLmMgYi9mcy94ZnMveGZzX2JtYXAuYwppbmRleCA0MTExY2QzLi5kYzNhZmQ3NyAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc19ibWFwLmMKKysrIGIvZnMveGZzL3hmc19ibWFwLmMKQEAgLTEwMzgsMTcgKzEwMzgsMzQgQEAKIAkJICogRmlsbGluZyBpbiB0aGUgbWlkZGxlIHBhcnQgb2YgYSBwcmV2aW91cyBkZWxheWVkIGFsbG9jYXRpb24uCiAJCSAqIENvbnRpZ3VpdHkgaXMgaW1wb3NzaWJsZSBoZXJlLgogCQkgKiBUaGlzIGNhc2UgaXMgYXZvaWRlZCBhbG1vc3QgYWxsIHRoZSB0aW1lLgorCQkgKgorCQkgKiBXZSBzdGFydCB3aXRoIGEgZGVsYXllZCBhbGxvY2F0aW9uOgorCQkgKgorCQkgKiArZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZCsKKwkJICogIFBSRVYgQCBpZHgKKwkJICoKKwkgICAgICAgICAqIGFuZCB3ZSBhcmUgYWxsb2NhdGluZzoKKwkJICogICAgICAgICAgICAgICAgICAgICArcnJycnJycnJycnJycnJycnIrCisJCSAqCQkJICAgICAgbmV3CisJCSAqCisJCSAqIGFuZCB3ZSBzZXQgaXQgdXAgZm9yIGluc2VydGlvbiBhczoKKwkJICogK2RkZGRkZGRkZGRkZGRkZGRkZGQrcnJycnJycnJycnJycnJycnIrZGRkZGRkZGRkZGRkZGRkZGQrCisJCSAqICAgICAgICAgICAgICAgICAgICAgICAgICAgIG5ldworCQkgKiAgUFJFViBAIGlkeCAgICAgICAgICBMRUZUICAgICAgICAgICAgICBSSUdIVAorCQkgKiAgICAgICAgICAgICAgICAgICAgICBpbnNlcnRlZCBhdCBpZHggKyAxCiAJCSAqLwogCQl0ZW1wID0gbmV3LT5icl9zdGFydG9mZiAtIFBSRVYuYnJfc3RhcnRvZmY7Ci0JCXRyYWNlX3hmc19ibWFwX3ByZV91cGRhdGUoaXAsIGlkeCwgMCwgX1RISVNfSVBfKTsKLQkJeGZzX2JtYnRfc2V0X2Jsb2NrY291bnQoZXAsIHRlbXApOwotCQlyWzBdID0gKm5ldzsKLQkJclsxXS5icl9zdGF0ZSA9IFBSRVYuYnJfc3RhdGU7Ci0JCXJbMV0uYnJfc3RhcnRibG9jayA9IDA7Ci0JCXJbMV0uYnJfc3RhcnRvZmYgPSBuZXdfZW5kb2ZmOwogCQl0ZW1wMiA9IFBSRVYuYnJfc3RhcnRvZmYgKyBQUkVWLmJyX2Jsb2NrY291bnQgLSBuZXdfZW5kb2ZmOwotCQlyWzFdLmJyX2Jsb2NrY291bnQgPSB0ZW1wMjsKLQkJeGZzX2lleHRfaW5zZXJ0KGlwLCBpZHggKyAxLCAyLCAmclswXSwgc3RhdGUpOworCQl0cmFjZV94ZnNfYm1hcF9wcmVfdXBkYXRlKGlwLCBpZHgsIDAsIF9USElTX0lQXyk7CisJCXhmc19ibWJ0X3NldF9ibG9ja2NvdW50KGVwLCB0ZW1wKTsJLyogdHJ1bmNhdGUgUFJFViAqLworCQlMRUZUID0gKm5ldzsKKwkJUklHSFQuYnJfc3RhdGUgPSBQUkVWLmJyX3N0YXRlOworCQlSSUdIVC5icl9zdGFydGJsb2NrID0gbnVsbHN0YXJ0YmxvY2soCisJCQkJKGludCl4ZnNfYm1hcF93b3JzdF9pbmRsZW4oaXAsIHRlbXAyKSk7CisJCVJJR0hULmJyX3N0YXJ0b2ZmID0gbmV3X2VuZG9mZjsKKwkJUklHSFQuYnJfYmxvY2tjb3VudCA9IHRlbXAyOworCQkvKiBpbnNlcnQgTEVGVCAoclswXSkgYW5kIFJJR0hUIChyWzFdKSBhdCB0aGUgc2FtZSB0aW1lICovCisJCXhmc19pZXh0X2luc2VydChpcCwgaWR4ICsgMSwgMiwgJkxFRlQsIHN0YXRlKTsKIAkJaXAtPmlfZGYuaWZfbGFzdGV4ID0gaWR4ICsgMTsKIAkJaXAtPmlfZC5kaV9uZXh0ZW50cysrOwogCQlpZiAoY3VyID09IE5VTEwpCkBAIC0yNDMwLDcgKzI0NDcsNyBAQAogCQlzdGFydGFnID0gYWcgPSAwOwogCiAJcGFnID0geGZzX3BlcmFnX2dldChtcCwgYWcpOwotCXdoaWxlICgqYmxlbiA8IGFwLT5hbGVuKSB7CisJd2hpbGUgKCpibGVuIDwgYXJncy0+bWF4bGVuKSB7CiAJCWlmICghcGFnLT5wYWdmX2luaXQpIHsKIAkJCWVycm9yID0geGZzX2FsbG9jX3BhZ2ZfaW5pdChtcCwgYXJncy0+dHAsIGFnLAogCQkJCQkJICAgIFhGU19BTExPQ19GTEFHX1RSWUxPQ0spOwpAQCAtMjQ1Miw3ICsyNDY5LDcgQEAKIAkJCW5vdGluaXQgPSAxOwogCiAJCWlmICh4ZnNfaW5vZGVfaXNfZmlsZXN0cmVhbShhcC0+aXApKSB7Ci0JCQlpZiAoKmJsZW4gPj0gYXAtPmFsZW4pCisJCQlpZiAoKmJsZW4gPj0gYXJncy0+bWF4bGVuKQogCQkJCWJyZWFrOwogCiAJCQlpZiAoYXAtPnVzZXJkYXRhKSB7CkBAIC0yNDk4LDE0ICsyNTE1LDE0IEBACiAJICogSWYgdGhlIGJlc3Qgc2VlbiBsZW5ndGggaXMgbGVzcyB0aGFuIHRoZSByZXF1ZXN0CiAJICogbGVuZ3RoLCB1c2UgdGhlIGJlc3QgYXMgdGhlIG1pbmltdW0uCiAJICovCi0JZWxzZSBpZiAoKmJsZW4gPCBhcC0+YWxlbikKKwllbHNlIGlmICgqYmxlbiA8IGFyZ3MtPm1heGxlbikKIAkJYXJncy0+bWlubGVuID0gKmJsZW47CiAJLyoKLQkgKiBPdGhlcndpc2Ugd2UndmUgc2VlbiBhbiBleHRlbnQgYXMgYmlnIGFzIGFsZW4sCisJICogT3RoZXJ3aXNlIHdlJ3ZlIHNlZW4gYW4gZXh0ZW50IGFzIGJpZyBhcyBtYXhsZW4sCiAJICogdXNlIHRoYXQgYXMgdGhlIG1pbmltdW0uCiAJICovCiAJZWxzZQotCQlhcmdzLT5taW5sZW4gPSBhcC0+YWxlbjsKKwkJYXJncy0+bWlubGVuID0gYXJncy0+bWF4bGVuOwogCiAJLyoKIAkgKiBzZXQgdGhlIGZhaWx1cmUgZmFsbGJhY2sgY2FzZSB0byBsb29rIGluIHRoZSBzZWxlY3RlZApAQCAtMjU3Myw3ICsyNTkwLDkgQEAKIAlhcmdzLnRwID0gYXAtPnRwOwogCWFyZ3MubXAgPSBtcDsKIAlhcmdzLmZzYm5vID0gYXAtPnJ2YWw7Ci0JYXJncy5tYXhsZW4gPSBNSU4oYXAtPmFsZW4sIG1wLT5tX3NiLnNiX2FnYmxvY2tzKTsKKworCS8qIFRyaW0gdGhlIGFsbG9jYXRpb24gYmFjayB0byB0aGUgbWF4aW11bSBhbiBBRyBjYW4gZml0LiAqLworCWFyZ3MubWF4bGVuID0gTUlOKGFwLT5hbGVuLCBYRlNfQUxMT0NfQUdfTUFYX1VTQUJMRShtcCkpOwogCWFyZ3MuZmlyc3RibG9jayA9IGFwLT5maXJzdGJsb2NrOwogCWJsZW4gPSAwOwogCWlmIChudWxsZmIpIHsKQEAgLTI2MjEsNyArMjY0MCw3IEBACiAJCQkvKgogCQkJICogQWRqdXN0IGZvciBhbGlnbm1lbnQKIAkJCSAqLwotCQkJaWYgKGJsZW4gPiBhcmdzLmFsaWdubWVudCAmJiBibGVuIDw9IGFwLT5hbGVuKQorCQkJaWYgKGJsZW4gPiBhcmdzLmFsaWdubWVudCAmJiBibGVuIDw9IGFyZ3MubWF4bGVuKQogCQkJCWFyZ3MubWlubGVuID0gYmxlbiAtIGFyZ3MuYWxpZ25tZW50OwogCQkJYXJncy5taW5hbGlnbnNsb3AgPSAwOwogCQl9IGVsc2UgewpAQCAtMjY0MCw3ICsyNjU5LDcgQEAKIAkJCSAqIG9mIG1pbmxlbithbGlnbm1lbnQrc2xvcCBkb2Vzbid0IGdvIHVwCiAJCQkgKiBiZXR3ZWVuIHRoZSBjYWxscy4KIAkJCSAqLwotCQkJaWYgKGJsZW4gPiBtcC0+bV9kYWxpZ24gJiYgYmxlbiA8PSBhcC0+YWxlbikKKwkJCWlmIChibGVuID4gbXAtPm1fZGFsaWduICYmIGJsZW4gPD0gYXJncy5tYXhsZW4pCiAJCQkJbmV4dG1pbmxlbiA9IGJsZW4gLSBtcC0+bV9kYWxpZ247CiAJCQllbHNlCiAJCQkJbmV4dG1pbmxlbiA9IGFyZ3MubWlubGVuOwpAQCAtNDQ4NSw2ICs0NTA0LDE2IEBACiAJCQkJLyogRmlndXJlIG91dCB0aGUgZXh0ZW50IHNpemUsIGFkanVzdCBhbGVuICovCiAJCQkJZXh0c3ogPSB4ZnNfZ2V0X2V4dHN6X2hpbnQoaXApOwogCQkJCWlmIChleHRzeikgeworCQkJCQkvKgorCQkJCQkgKiBtYWtlIHN1cmUgd2UgZG9uJ3QgZXhjZWVkIGEgc2luZ2xlCisJCQkJCSAqIGV4dGVudCBsZW5ndGggd2hlbiB3ZSBhbGlnbiB0aGUKKwkJCQkJICogZXh0ZW50IGJ5IHJlZHVjaW5nIGxlbmd0aCB3ZSBhcmUKKwkJCQkJICogZ29pbmcgdG8gYWxsb2NhdGUgYnkgdGhlIG1heGltdW0KKwkJCQkJICogYW1vdW50IGV4dGVudCBzaXplIGFsaWdtZW50IG1heQorCQkJCQkgKiByZXF1aXJlLgorCQkJCQkgKi8KKwkJCQkJYWxlbiA9IFhGU19GSUxCTEtTX01JTihsZW4sCisJCQkJCQkgICBNQVhFWFRMRU4gLSAoMiAqIGV4dHN6IC0gMSkpOwogCQkJCQllcnJvciA9IHhmc19ibWFwX2V4dHNpemVfYWxpZ24obXAsCiAJCQkJCQkJJmdvdCwgJnByZXYsIGV4dHN6LAogCQkJCQkJCXJ0LCBlb2YsCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX2J1Zl9pdGVtLmMgYi9mcy94ZnMveGZzX2J1Zl9pdGVtLmMKaW5kZXggZWQyYjY1Zi4uNmY4YzIxYyAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc19idWZfaXRlbS5jCisrKyBiL2ZzL3hmcy94ZnNfYnVmX2l0ZW0uYwpAQCAtMTQxLDcgKzE0MSw2IEBACiAjZGVmaW5lCQl4ZnNfYnVmX2l0ZW1fbG9nX2NoZWNrKHgpCiAjZW5kaWYKIAotU1RBVElDIHZvaWQJeGZzX2J1Zl9lcnJvcl9yZWxzZSh4ZnNfYnVmX3QgKmJwKTsKIFNUQVRJQyB2b2lkCXhmc19idWZfZG9fY2FsbGJhY2tzKHN0cnVjdCB4ZnNfYnVmICpicCk7CiAKIC8qCkBAIC00MjgsMTMgKzQyNywxNSBAQAogCiAJCWlmIChyZW1vdmUpIHsKIAkJCS8qCi0JCQkgKiBXZSBoYXZlIHRvIHJlbW92ZSB0aGUgbG9nIGl0ZW0gZnJvbSB0aGUgdHJhbnNhY3Rpb24KLQkJCSAqIGFzIHdlIGFyZSBhYm91dCB0byByZWxlYXNlIG91ciByZWZlcmVuY2UgdG8gdGhlCi0JCQkgKiBidWZmZXIuICBJZiB3ZSBkb24ndCwgdGhlIHVubG9jayB0aGF0IG9jY3VycyBsYXRlcgotCQkJICogaW4geGZzX3RyYW5zX3VuY29tbWl0KCkgd2lsbCByeSB0byByZWZlcmVuY2UgdGhlCisJCQkgKiBJZiB3ZSBhcmUgaW4gYSB0cmFuc2FjdGlvbiBjb250ZXh0LCB3ZSBoYXZlIHRvCisJCQkgKiByZW1vdmUgdGhlIGxvZyBpdGVtIGZyb20gdGhlIHRyYW5zYWN0aW9uIGFzIHdlIGFyZQorCQkJICogYWJvdXQgdG8gcmVsZWFzZSBvdXIgcmVmZXJlbmNlIHRvIHRoZSBidWZmZXIuICBJZiB3ZQorCQkJICogZG9uJ3QsIHRoZSB1bmxvY2sgdGhhdCBvY2N1cnMgbGF0ZXIgaW4KKwkJCSAqIHhmc190cmFuc191bmNvbW1pdCgpIHdpbGwgdHJ5IHRvIHJlZmVyZW5jZSB0aGUKIAkJCSAqIGJ1ZmZlciB3aGljaCB3ZSBubyBsb25nZXIgaGF2ZSBhIGhvbGQgb24uCiAJCQkgKi8KLQkJCXhmc190cmFuc19kZWxfaXRlbShsaXApOworCQkJaWYgKGxpcC0+bGlfZGVzYykKKwkJCQl4ZnNfdHJhbnNfZGVsX2l0ZW0obGlwKTsKIAogCQkJLyoKIAkJCSAqIFNpbmNlIHRoZSB0cmFuc2FjdGlvbiBubyBsb25nZXIgcmVmZXJzIHRvIHRoZSBidWZmZXIsCkBAIC05NTksODYgKzk2MCw3MCBAQAogICovCiB2b2lkCiB4ZnNfYnVmX2lvZG9uZV9jYWxsYmFja3MoCi0JeGZzX2J1Zl90CSpicCkKKwlzdHJ1Y3QgeGZzX2J1ZgkJKmJwKQogewotCXhmc19sb2dfaXRlbV90CSpsaXA7Ci0Jc3RhdGljIHVsb25nCWxhc3R0aW1lOwotCXN0YXRpYyB4ZnNfYnVmdGFyZ190ICpsYXN0dGFyZzsKLQl4ZnNfbW91bnRfdAkqbXA7CisJc3RydWN0IHhmc19sb2dfaXRlbQkqbGlwID0gYnAtPmJfZnNwcml2OworCXN0cnVjdCB4ZnNfbW91bnQJKm1wID0gbGlwLT5saV9tb3VudHA7CisJc3RhdGljIHVsb25nCQlsYXN0dGltZTsKKwlzdGF0aWMgeGZzX2J1ZnRhcmdfdAkqbGFzdHRhcmc7CiAKLQlBU1NFUlQoWEZTX0JVRl9GU1BSSVZBVEUoYnAsIHZvaWQgKikgIT0gTlVMTCk7Ci0JbGlwID0gWEZTX0JVRl9GU1BSSVZBVEUoYnAsIHhmc19sb2dfaXRlbV90ICopOworCWlmIChsaWtlbHkoIVhGU19CVUZfR0VURVJST1IoYnApKSkKKwkJZ290byBkb19jYWxsYmFja3M7CiAKLQlpZiAoWEZTX0JVRl9HRVRFUlJPUihicCkgIT0gMCkgewotCQkvKgotCQkgKiBJZiB3ZSd2ZSBhbHJlYWR5IGRlY2lkZWQgdG8gc2h1dGRvd24gdGhlIGZpbGVzeXN0ZW0KLQkJICogYmVjYXVzZSBvZiBJTyBlcnJvcnMsIHRoZXJlJ3Mgbm8gcG9pbnQgaW4gZ2l2aW5nIHRoaXMKLQkJICogYSByZXRyeS4KLQkJICovCi0JCW1wID0gbGlwLT5saV9tb3VudHA7Ci0JCWlmIChYRlNfRk9SQ0VEX1NIVVRET1dOKG1wKSkgewotCQkJQVNTRVJUKFhGU19CVUZfVEFSR0VUKGJwKSA9PSBtcC0+bV9kZGV2X3RhcmdwKTsKLQkJCVhGU19CVUZfU1VQRVJfU1RBTEUoYnApOwotCQkJdHJhY2VfeGZzX2J1Zl9pdGVtX2lvZG9uZShicCwgX1JFVF9JUF8pOwotCQkJeGZzX2J1Zl9kb19jYWxsYmFja3MoYnApOwotCQkJWEZTX0JVRl9TRVRfRlNQUklWQVRFKGJwLCBOVUxMKTsKLQkJCVhGU19CVUZfQ0xSX0lPRE9ORV9GVU5DKGJwKTsKLQkJCXhmc19idWZfaW9lbmQoYnAsIDApOwotCQkJcmV0dXJuOwotCQl9CisJLyoKKwkgKiBJZiB3ZSd2ZSBhbHJlYWR5IGRlY2lkZWQgdG8gc2h1dGRvd24gdGhlIGZpbGVzeXN0ZW0gYmVjYXVzZSBvZgorCSAqIEkvTyBlcnJvcnMsIHRoZXJlJ3Mgbm8gcG9pbnQgaW4gZ2l2aW5nIHRoaXMgYSByZXRyeS4KKwkgKi8KKwlpZiAoWEZTX0ZPUkNFRF9TSFVURE9XTihtcCkpIHsKKwkJWEZTX0JVRl9TVVBFUl9TVEFMRShicCk7CisJCXRyYWNlX3hmc19idWZfaXRlbV9pb2RvbmUoYnAsIF9SRVRfSVBfKTsKKwkJZ290byBkb19jYWxsYmFja3M7CisJfQogCi0JCWlmICgoWEZTX0JVRl9UQVJHRVQoYnApICE9IGxhc3R0YXJnKSB8fAotCQkgICAgKHRpbWVfYWZ0ZXIoamlmZmllcywgKGxhc3R0aW1lICsgNSpIWikpKSkgewotCQkJbGFzdHRpbWUgPSBqaWZmaWVzOwotCQkJY21uX2VycihDRV9BTEVSVCwgIkRldmljZSAlcywgWEZTIG1ldGFkYXRhIHdyaXRlIGVycm9yIgotCQkJCQkiIGJsb2NrIDB4JWxseCBpbiAlcyIsCi0JCQkJWEZTX0JVRlRBUkdfTkFNRShYRlNfQlVGX1RBUkdFVChicCkpLAotCQkJICAgICAgKF9fdWludDY0X3QpWEZTX0JVRl9BRERSKGJwKSwgbXAtPm1fZnNuYW1lKTsKLQkJfQotCQlsYXN0dGFyZyA9IFhGU19CVUZfVEFSR0VUKGJwKTsKKwlpZiAoWEZTX0JVRl9UQVJHRVQoYnApICE9IGxhc3R0YXJnIHx8CisJICAgIHRpbWVfYWZ0ZXIoamlmZmllcywgKGxhc3R0aW1lICsgNSpIWikpKSB7CisJCWxhc3R0aW1lID0gamlmZmllczsKKwkJY21uX2VycihDRV9BTEVSVCwgIkRldmljZSAlcywgWEZTIG1ldGFkYXRhIHdyaXRlIGVycm9yIgorCQkJCSIgYmxvY2sgMHglbGx4IGluICVzIiwKKwkJCVhGU19CVUZUQVJHX05BTUUoWEZTX0JVRl9UQVJHRVQoYnApKSwKKwkJICAgICAgKF9fdWludDY0X3QpWEZTX0JVRl9BRERSKGJwKSwgbXAtPm1fZnNuYW1lKTsKKwl9CisJbGFzdHRhcmcgPSBYRlNfQlVGX1RBUkdFVChicCk7CiAKLQkJaWYgKFhGU19CVUZfSVNBU1lOQyhicCkpIHsKLQkJCS8qCi0JCQkgKiBJZiB0aGUgd3JpdGUgd2FzIGFzeW5jaHJvbm91cyB0aGVuIG5vb25lIHdpbGwgYmUKLQkJCSAqIGxvb2tpbmcgZm9yIHRoZSBlcnJvci4gIENsZWFyIHRoZSBlcnJvciBzdGF0ZQotCQkJICogYW5kIHdyaXRlIHRoZSBidWZmZXIgb3V0IGFnYWluIGRlbGF5ZWQgd3JpdGUuCi0JCQkgKgotCQkJICogWFhYc3VwIFRoaXMgaXMgT0ssIHNvIGxvbmcgYXMgd2UgY2F0Y2ggdGhlc2UKLQkJCSAqIGJlZm9yZSB3ZSBzdGFydCB0aGUgdW1vdW50OyB3ZSBkb24ndCB3YW50IHRoZXNlCi0JCQkgKiBERUxXUkkgbWV0YWRhdGEgYnVmcyB0byBiZSBoYW5naW5nIGFyb3VuZC4KLQkJCSAqLwotCQkJWEZTX0JVRl9FUlJPUihicCwwKTsgLyogZXJybm8gb2YgMCB1bnNldHMgdGhlIGZsYWcgKi8KKwkvKgorCSAqIElmIHRoZSB3cml0ZSB3YXMgYXN5bmNocm9ub3VzIHRoZW4gbm9vbmUgd2lsbCBiZSBsb29raW5nIGZvciB0aGUKKwkgKiBlcnJvci4gIENsZWFyIHRoZSBlcnJvciBzdGF0ZSBhbmQgd3JpdGUgdGhlIGJ1ZmZlciBvdXQgYWdhaW4uCisJICoKKwkgKiBEdXJpbmcgc3luYyBvciB1bW91bnQgd2UnbGwgd3JpdGUgYWxsIHBlbmRpbmcgYnVmZmVycyBhZ2FpbgorCSAqIHN5bmNocm9ub3VzLCB3aGljaCB3aWxsIGNhdGNoIHRoZXNlIGVycm9ycyBpZiB0aGV5IGtlZXAgaGFuZ2luZworCSAqIGFyb3VuZC4KKwkgKi8KKwlpZiAoWEZTX0JVRl9JU0FTWU5DKGJwKSkgeworCQlYRlNfQlVGX0VSUk9SKGJwLCAwKTsgLyogZXJybm8gb2YgMCB1bnNldHMgdGhlIGZsYWcgKi8KIAotCQkJaWYgKCEoWEZTX0JVRl9JU1NUQUxFKGJwKSkpIHsKLQkJCQlYRlNfQlVGX0RFTEFZV1JJVEUoYnApOwotCQkJCVhGU19CVUZfRE9ORShicCk7Ci0JCQkJWEZTX0JVRl9TRVRfU1RBUlQoYnApOwotCQkJfQotCQkJQVNTRVJUKFhGU19CVUZfSU9ET05FX0ZVTkMoYnApKTsKLQkJCXRyYWNlX3hmc19idWZfaXRlbV9pb2RvbmVfYXN5bmMoYnAsIF9SRVRfSVBfKTsKLQkJCXhmc19idWZfcmVsc2UoYnApOwotCQl9IGVsc2UgewotCQkJLyoKLQkJCSAqIElmIHRoZSB3cml0ZSBvZiB0aGUgYnVmZmVyIHdhcyBub3QgYXN5bmNocm9ub3VzLAotCQkJICogdGhlbiB3ZSB3YW50IHRvIG1ha2Ugc3VyZSB0byByZXR1cm4gdGhlIGVycm9yCi0JCQkgKiB0byB0aGUgY2FsbGVyIG9mIGJ3cml0ZSgpLiAgQmVjYXVzZSBvZiB0aGlzIHdlCi0JCQkgKiBjYW5ub3QgY2xlYXIgdGhlIEJfRVJST1Igc3RhdGUgYXQgdGhpcyBwb2ludC4KLQkJCSAqIEluc3RlYWQgd2UgaW5zdGFsbCBhIGNhbGxiYWNrIGZ1bmN0aW9uIHRoYXQKLQkJCSAqIHdpbGwgYmUgY2FsbGVkIHdoZW4gdGhlIGJ1ZmZlciBpcyByZWxlYXNlZCwgYW5kCi0JCQkgKiB0aGF0IHJvdXRpbmUgd2lsbCBjbGVhciB0aGUgZXJyb3Igc3RhdGUgYW5kCi0JCQkgKiBzZXQgdGhlIGJ1ZmZlciB0byBiZSB3cml0dGVuIG91dCBhZ2FpbiBhZnRlcgotCQkJICogc29tZSBkZWxheS4KLQkJCSAqLwotCQkJLyogV2UgYWN0dWFsbHkgb3ZlcndyaXRlIHRoZSBleGlzdGluZyBiLXJlbHNlCi0JCQkgICBmdW5jdGlvbiBhdCB0aW1lcywgYnV0IHdlJ3JlIGdvbm5hIGJlIHNodXR0aW5nIGRvd24KLQkJCSAgIGFueXdheS4gKi8KLQkJCVhGU19CVUZfU0VUX0JSRUxTRV9GVU5DKGJwLHhmc19idWZfZXJyb3JfcmVsc2UpOworCQlpZiAoIVhGU19CVUZfSVNTVEFMRShicCkpIHsKKwkJCVhGU19CVUZfREVMQVlXUklURShicCk7CiAJCQlYRlNfQlVGX0RPTkUoYnApOwotCQkJWEZTX0JVRl9GSU5JU0hfSU9XQUlUKGJwKTsKKwkJCVhGU19CVUZfU0VUX1NUQVJUKGJwKTsKIAkJfQorCQlBU1NFUlQoWEZTX0JVRl9JT0RPTkVfRlVOQyhicCkpOworCQl0cmFjZV94ZnNfYnVmX2l0ZW1faW9kb25lX2FzeW5jKGJwLCBfUkVUX0lQXyk7CisJCXhmc19idWZfcmVsc2UoYnApOwogCQlyZXR1cm47CiAJfQogCisJLyoKKwkgKiBJZiB0aGUgd3JpdGUgb2YgdGhlIGJ1ZmZlciB3YXMgc3luY2hyb25vdXMsIHdlIHdhbnQgdG8gbWFrZQorCSAqIHN1cmUgdG8gcmV0dXJuIHRoZSBlcnJvciB0byB0aGUgY2FsbGVyIG9mIHhmc19id3JpdGUoKS4KKwkgKi8KKwlYRlNfQlVGX1NUQUxFKGJwKTsKKwlYRlNfQlVGX0RPTkUoYnApOworCVhGU19CVUZfVU5ERUxBWVdSSVRFKGJwKTsKKworCXRyYWNlX3hmc19idWZfZXJyb3JfcmVsc2UoYnAsIF9SRVRfSVBfKTsKKwl4ZnNfZm9yY2Vfc2h1dGRvd24obXAsIFNIVVRET1dOX01FVEFfSU9fRVJST1IpOworCitkb19jYWxsYmFja3M6CiAJeGZzX2J1Zl9kb19jYWxsYmFja3MoYnApOwogCVhGU19CVUZfU0VUX0ZTUFJJVkFURShicCwgTlVMTCk7CiAJWEZTX0JVRl9DTFJfSU9ET05FX0ZVTkMoYnApOwpAQCAtMTA0Niw0MiArMTAzMSw2IEBACiB9CiAKIC8qCi0gKiBUaGlzIGlzIGEgY2FsbGJhY2sgcm91dGluZSBhdHRhY2hlZCB0byBhIGJ1ZmZlciB3aGljaCBnZXRzIGFuIGVycm9yCi0gKiB3aGVuIGJlaW5nIHdyaXR0ZW4gb3V0IHN5bmNocm9ub3VzbHkuCi0gKi8KLVNUQVRJQyB2b2lkCi14ZnNfYnVmX2Vycm9yX3JlbHNlKAotCXhmc19idWZfdAkqYnApCi17Ci0JeGZzX2xvZ19pdGVtX3QJKmxpcDsKLQl4ZnNfbW91bnRfdAkqbXA7Ci0KLQlsaXAgPSBYRlNfQlVGX0ZTUFJJVkFURShicCwgeGZzX2xvZ19pdGVtX3QgKik7Ci0JbXAgPSAoeGZzX21vdW50X3QgKilsaXAtPmxpX21vdW50cDsKLQlBU1NFUlQoWEZTX0JVRl9UQVJHRVQoYnApID09IG1wLT5tX2RkZXZfdGFyZ3ApOwotCi0JWEZTX0JVRl9TVEFMRShicCk7Ci0JWEZTX0JVRl9ET05FKGJwKTsKLQlYRlNfQlVGX1VOREVMQVlXUklURShicCk7Ci0JWEZTX0JVRl9FUlJPUihicCwwKTsKLQotCXRyYWNlX3hmc19idWZfZXJyb3JfcmVsc2UoYnAsIF9SRVRfSVBfKTsKLQotCWlmICghIFhGU19GT1JDRURfU0hVVERPV04obXApKQotCQl4ZnNfZm9yY2Vfc2h1dGRvd24obXAsIFNIVVRET1dOX01FVEFfSU9fRVJST1IpOwotCS8qCi0JICogV2UgaGF2ZSB0byB1bnBpbiB0aGUgcGlubmVkIGJ1ZmZlcnMgc28gZG8gdGhlCi0JICogY2FsbGJhY2tzLgotCSAqLwotCXhmc19idWZfZG9fY2FsbGJhY2tzKGJwKTsKLQlYRlNfQlVGX1NFVF9GU1BSSVZBVEUoYnAsIE5VTEwpOwotCVhGU19CVUZfQ0xSX0lPRE9ORV9GVU5DKGJwKTsKLQlYRlNfQlVGX1NFVF9CUkVMU0VfRlVOQyhicCxOVUxMKTsKLQl4ZnNfYnVmX3JlbHNlKGJwKTsKLX0KLQotCi0vKgogICogVGhpcyBpcyB0aGUgaW9kb25lKCkgZnVuY3Rpb24gZm9yIGJ1ZmZlcnMgd2hpY2ggaGF2ZSBiZWVuCiAgKiBsb2dnZWQuICBJdCBpcyBjYWxsZWQgd2hlbiB0aGV5IGFyZSBldmVudHVhbGx5IGZsdXNoZWQgb3V0LgogICogSXQgc2hvdWxkIHJlbW92ZSB0aGUgYnVmIGl0ZW0gZnJvbSB0aGUgQUlMLCBhbmQgZnJlZSB0aGUgYnVmIGl0ZW0uCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX2Vycm9yLmMgYi9mcy94ZnMveGZzX2Vycm9yLmMKaW5kZXggYzc4Y2M2YS4uNGM3ZGI3NCAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc19lcnJvci5jCisrKyBiL2ZzL3hmcy94ZnNfZXJyb3IuYwpAQCAtMTUyLDM3ICsxNTIsNiBAQAogfQogI2VuZGlmIC8qIERFQlVHICovCiAKLQotdm9pZAoteGZzX2ZzX2Ntbl9lcnIoaW50IGxldmVsLCB4ZnNfbW91bnRfdCAqbXAsIGNoYXIgKmZtdCwgLi4uKQotewotCXZhX2xpc3QgYXA7Ci0KLQl2YV9zdGFydChhcCwgZm10KTsKLQl4ZnNfZnNfdmNtbl9lcnIobGV2ZWwsIG1wLCBmbXQsIGFwKTsKLQl2YV9lbmQoYXApOwotfQotCi12b2lkCi14ZnNfY21uX2VycihpbnQgcGFuaWNfdGFnLCBpbnQgbGV2ZWwsIHhmc19tb3VudF90ICptcCwgY2hhciAqZm10LCAuLi4pCi17Ci0JdmFfbGlzdCBhcDsKLQotI2lmZGVmIERFQlVHCi0JeGZzX3BhbmljX21hc2sgfD0gKFhGU19QVEFHX1NIVVRET1dOX0NPUlJVUFQgfCBYRlNfUFRBR19MT0dSRVMpOwotI2VuZGlmCi0KLQlpZiAoeGZzX3BhbmljX21hc2sgJiYgKHhmc19wYW5pY19tYXNrICYgcGFuaWNfdGFnKQotCSAgICAmJiAobGV2ZWwgJiBDRV9BTEVSVCkpIHsKLQkJbGV2ZWwgJj0gfkNFX0FMRVJUOwotCQlsZXZlbCB8PSBDRV9QQU5JQzsKLQkJY21uX2VycihDRV9BTEVSVCwgIlhGUzogVHJhbnNmb3JtaW5nIGFuIGFsZXJ0IGludG8gYSBCVUcuIik7Ci0JfQotCXZhX3N0YXJ0KGFwLCBmbXQpOwotCXhmc19mc192Y21uX2VycihsZXZlbCwgbXAsIGZtdCwgYXApOwotCXZhX2VuZChhcCk7Ci19Ci0KIHZvaWQKIHhmc19lcnJvcl9yZXBvcnQoCiAJY29uc3QgY2hhcgkJKnRhZywKZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfZXJyb3IuaCBiL2ZzL3hmcy94ZnNfZXJyb3IuaAppbmRleCBmMzM4ODQ3Li4xMGRjZTU0IDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX2Vycm9yLmgKKysrIGIvZnMveGZzL3hmc19lcnJvci5oCkBAIC0xMzYsOCArMTM2LDggQEAKIAkgeGZzX2Vycm9yX3Rlc3QoKHRhZyksIChtcCktPm1fZml4ZWRmc2lkLCAiZXhwciIsIF9fTElORV9fLCBfX0ZJTEVfXywgXAogCQkJKHJmKSkpKQogCi1leHRlcm4gaW50IHhmc19lcnJvcnRhZ19hZGQoaW50IGVycm9yX3RhZywgeGZzX21vdW50X3QgKm1wKTsKLWV4dGVybiBpbnQgeGZzX2Vycm9ydGFnX2NsZWFyYWxsKHhmc19tb3VudF90ICptcCwgaW50IGxvdWQpOworZXh0ZXJuIGludCB4ZnNfZXJyb3J0YWdfYWRkKGludCBlcnJvcl90YWcsIHN0cnVjdCB4ZnNfbW91bnQgKm1wKTsKK2V4dGVybiBpbnQgeGZzX2Vycm9ydGFnX2NsZWFyYWxsKHN0cnVjdCB4ZnNfbW91bnQgKm1wLCBpbnQgbG91ZCk7CiAjZWxzZQogI2RlZmluZSBYRlNfVEVTVF9FUlJPUihleHByLCBtcCwgdGFnLCByZikJKGV4cHIpCiAjZGVmaW5lIHhmc19lcnJvcnRhZ19hZGQodGFnLCBtcCkJCShFTk9TWVMpCkBAIC0xNjIsMjEgKzE2MiwxNSBAQAogCiBzdHJ1Y3QgeGZzX21vdW50OwogCi1leHRlcm4gdm9pZCB4ZnNfZnNfdmNtbl9lcnIoaW50IGxldmVsLCBzdHJ1Y3QgeGZzX21vdW50ICptcCwKLQkJY2hhciAqZm10LCB2YV9saXN0IGFwKQotCV9fYXR0cmlidXRlX18gKChmb3JtYXQgKHByaW50ZiwgMywgMCkpKTsKLWV4dGVybiB2b2lkIHhmc19jbW5fZXJyKGludCBwYW5pY190YWcsIGludCBsZXZlbCwgc3RydWN0IHhmc19tb3VudCAqbXAsCi0JCQljaGFyICpmbXQsIC4uLikKLQlfX2F0dHJpYnV0ZV9fICgoZm9ybWF0IChwcmludGYsIDQsIDUpKSk7Ci1leHRlcm4gdm9pZCB4ZnNfZnNfY21uX2VycihpbnQgbGV2ZWwsIHN0cnVjdCB4ZnNfbW91bnQgKm1wLCBjaGFyICpmbXQsIC4uLikKLQlfX2F0dHJpYnV0ZV9fICgoZm9ybWF0IChwcmludGYsIDMsIDQpKSk7Ci0KIGV4dGVybiB2b2lkIHhmc19oZXhfZHVtcCh2b2lkICpwLCBpbnQgbGVuZ3RoKTsKIAogI2RlZmluZSB4ZnNfZnNfcmVwYWlyX2Ntbl9lcnIobGV2ZWwsIG1wLCBmbXQsIGFyZ3MuLi4pIFwKIAl4ZnNfZnNfY21uX2VycihsZXZlbCwgbXAsIGZtdCAiICBVbm1vdW50IGFuZCBydW4geGZzX3JlcGFpci4iLCAjIyBhcmdzKQogCiAjZGVmaW5lIHhmc19mc19tb3VudF9jbW5fZXJyKGYsIGZtdCwgYXJncy4uLikgXAotCSgoZiAmIFhGU19NRlNJX1FVSUVUKT8gKHZvaWQpMCA6IGNtbl9lcnIoQ0VfV0FSTiwgIlhGUzogIiBmbXQsICMjIGFyZ3MpKQorCWRvIHsgXAorCQlpZiAoIShmICYgWEZTX01GU0lfUVVJRVQpKSAJXAorCQkJY21uX2VycihDRV9XQVJOLCAiWEZTOiAiIGZtdCwgIyMgYXJncyk7IFwKKwl9IHdoaWxlICgwKQogCiAjZW5kaWYJLyogX19YRlNfRVJST1JfSF9fICovCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX2V4dGZyZWVfaXRlbS5jIGIvZnMveGZzL3hmc19leHRmcmVlX2l0ZW0uYwppbmRleCA3NWYyZWY2Li5kMjJlNjI2IDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX2V4dGZyZWVfaXRlbS5jCisrKyBiL2ZzL3hmcy94ZnNfZXh0ZnJlZV9pdGVtLmMKQEAgLTEzOCw3ICsxMzgsOCBAQAogCiAJaWYgKHJlbW92ZSkgewogCQlBU1NFUlQoIShsaXAtPmxpX2ZsYWdzICYgWEZTX0xJX0lOX0FJTCkpOwotCQl4ZnNfdHJhbnNfZGVsX2l0ZW0obGlwKTsKKwkJaWYgKGxpcC0+bGlfZGVzYykKKwkJCXhmc190cmFuc19kZWxfaXRlbShsaXApOwogCQl4ZnNfZWZpX2l0ZW1fZnJlZShlZmlwKTsKIAkJcmV0dXJuOwogCX0KZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfZnNvcHMuYyBiL2ZzL3hmcy94ZnNfZnNvcHMuYwppbmRleCBmNTZkMzBlLi5jZWM4OWRkIDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX2Zzb3BzLmMKKysrIGIvZnMveGZzL3hmc19mc29wcy5jCkBAIC02MTIsMTIgKzYxMiwxMyBAQAogICoKICAqIFdlIGNhbm5vdCB1c2UgYW4gaW5vZGUgaGVyZSBmb3IgdGhpcyAtIHRoYXQgd2lsbCBwdXNoIGRpcnR5IHN0YXRlIGJhY2sgdXAKICAqIGludG8gdGhlIFZGUyBhbmQgdGhlbiBwZXJpb2RpYyBpbm9kZSBmbHVzaGluZyB3aWxsIHByZXZlbnQgbG9nIGNvdmVyaW5nIGZyb20KLSAqIG1ha2luZyBwcm9ncmVzcy4gSGVuY2Ugd2UgbG9nIGEgZmllbGQgaW4gdGhlIHN1cGVyYmxvY2sgaW5zdGVhZC4KKyAqIG1ha2luZyBwcm9ncmVzcy4gSGVuY2Ugd2UgbG9nIGEgZmllbGQgaW4gdGhlIHN1cGVyYmxvY2sgaW5zdGVhZCBhbmQgdXNlIGEKKyAqIHN5bmNocm9ub3VzIHRyYW5zYWN0aW9uIHRvIGVuc3VyZSB0aGUgc3VwZXJibG9jayBpcyBpbW1lZGlhdGVseSB1bnBpbm5lZAorICogYW5kIGNhbiBiZSB3cml0dGVuIGJhY2suCiAgKi8KIGludAogeGZzX2ZzX2xvZ19kdW1teSgKLQl4ZnNfbW91bnRfdAkqbXAsCi0JaW50CQlmbGFncykKKwl4ZnNfbW91bnRfdAkqbXApCiB7CiAJeGZzX3RyYW5zX3QJKnRwOwogCWludAkJZXJyb3I7CkBAIC02MzIsOCArNjMzLDcgQEAKIAogCS8qIGxvZyB0aGUgVVVJRCBiZWNhdXNlIGl0IGlzIGFuIHVuY2hhbmdpbmcgZmllbGQgKi8KIAl4ZnNfbW9kX3NiKHRwLCBYRlNfU0JfVVVJRCk7Ci0JaWYgKGZsYWdzICYgU1lOQ19XQUlUKQotCQl4ZnNfdHJhbnNfc2V0X3N5bmModHApOworCXhmc190cmFuc19zZXRfc3luYyh0cCk7CiAJcmV0dXJuIHhmc190cmFuc19jb21taXQodHAsIDApOwogfQogCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX2Zzb3BzLmggYi9mcy94ZnMveGZzX2Zzb3BzLmgKaW5kZXggYTc4NmM1Mi4uMWI2YTk4YiAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc19mc29wcy5oCisrKyBiL2ZzL3hmcy94ZnNfZnNvcHMuaApAQCAtMjUsNiArMjUsNiBAQAogZXh0ZXJuIGludCB4ZnNfcmVzZXJ2ZV9ibG9ja3MoeGZzX21vdW50X3QgKm1wLCBfX3VpbnQ2NF90ICppbnZhbCwKIAkJCQl4ZnNfZnNvcF9yZXNibGtzX3QgKm91dHZhbCk7CiBleHRlcm4gaW50IHhmc19mc19nb2luZ2Rvd24oeGZzX21vdW50X3QgKm1wLCBfX3VpbnQzMl90IGluZmxhZ3MpOwotZXh0ZXJuIGludCB4ZnNfZnNfbG9nX2R1bW15KHhmc19tb3VudF90ICptcCwgaW50IGZsYWdzKTsKK2V4dGVybiBpbnQgeGZzX2ZzX2xvZ19kdW1teShzdHJ1Y3QgeGZzX21vdW50ICptcCk7CiAKICNlbmRpZgkvKiBfX1hGU19GU09QU19IX18gKi8KZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfaW9tYXAuYyBiL2ZzL3hmcy94ZnNfaW9tYXAuYwppbmRleCA1NTU4MmJkLi44YTBmMDQ0IDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX2lvbWFwLmMKKysrIGIvZnMveGZzL3hmc19pb21hcC5jCkBAIC0zMzcsNyArMzM3LDEyIEBACiAJCWludCBzaGlmdCA9IDA7CiAJCWludDY0X3QgZnJlZXNwOwogCi0JCWFsbG9jX2Jsb2NrcyA9IFhGU19CX1RPX0ZTQihtcCwgaXAtPmlfc2l6ZSk7CisJCS8qCisJCSAqIHJvdW5kZG93bl9wb3dfb2ZfdHdvKCkgcmV0dXJucyBhbiB1bmRlZmluZWQgcmVzdWx0CisJCSAqIGlmIHdlIHBhc3MgaW4gYWxsb2NfYmxvY2tzID0gMC4gSGVuY2UgdGhlICIrIDEiIHRvCisJCSAqIGVuc3VyZSB3ZSBhbHdheXMgcGFzcyBpbiBhIG5vbi16ZXJvIHZhbHVlLgorCQkgKi8KKwkJYWxsb2NfYmxvY2tzID0gWEZTX0JfVE9fRlNCKG1wLCBpcC0+aV9zaXplKSArIDE7CiAJCWFsbG9jX2Jsb2NrcyA9IFhGU19GSUxFT0ZGX01JTihNQVhFWFRMRU4sCiAJCQkJCXJvdW5kZG93bl9wb3dfb2ZfdHdvKGFsbG9jX2Jsb2NrcykpOwogCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX2xvZy5jIGIvZnMveGZzL3hmc19sb2cuYwppbmRleCAwYmYyNGIxLi5hZTZmZWYxZiAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc19sb2cuYworKysgYi9mcy94ZnMveGZzX2xvZy5jCkBAIC0zNzcsNyArMzc3LDcgQEAKIAkJY21uX2VycihDRV9OT1RFLCAiWEZTIG1vdW50aW5nIGZpbGVzeXN0ZW0gJXMiLCBtcC0+bV9mc25hbWUpOwogCWVsc2UgewogCQljbW5fZXJyKENFX05PVEUsCi0JCQkiIU1vdW50aW5nIGZpbGVzeXN0ZW0gXCIlc1wiIGluIG5vLXJlY292ZXJ5IG1vZGUuICBGaWxlc3lzdGVtIHdpbGwgYmUgaW5jb25zaXN0ZW50LiIsCisJCQkiTW91bnRpbmcgZmlsZXN5c3RlbSBcIiVzXCIgaW4gbm8tcmVjb3ZlcnkgbW9kZS4gIEZpbGVzeXN0ZW0gd2lsbCBiZSBpbmNvbnNpc3RlbnQuIiwKIAkJCW1wLT5tX2ZzbmFtZSk7CiAJCUFTU0VSVChtcC0+bV9mbGFncyAmIFhGU19NT1VOVF9SRE9OTFkpOwogCX0KZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfbG9nLmggYi9mcy94ZnMveGZzX2xvZy5oCmluZGV4IDkxNmViN2QuLjNiZDMyOTEgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy94ZnNfbG9nLmgKKysrIGIvZnMveGZzL3hmc19sb2cuaApAQCAtMTkxLDcgKzE5MSw3IEBACiAKIHhsb2dfdGlkX3QgeGZzX2xvZ19nZXRfdHJhbnNfaWRlbnQoc3RydWN0IHhmc190cmFucyAqdHApOwogCi1pbnQJeGZzX2xvZ19jb21taXRfY2lsKHN0cnVjdCB4ZnNfbW91bnQgKm1wLCBzdHJ1Y3QgeGZzX3RyYW5zICp0cCwKK3ZvaWQJeGZzX2xvZ19jb21taXRfY2lsKHN0cnVjdCB4ZnNfbW91bnQgKm1wLCBzdHJ1Y3QgeGZzX3RyYW5zICp0cCwKIAkJCQlzdHJ1Y3QgeGZzX2xvZ192ZWMgKmxvZ192ZWN0b3IsCiAJCQkJeGZzX2xzbl90ICpjb21taXRfbHNuLCBpbnQgZmxhZ3MpOwogYm9vbAl4ZnNfbG9nX2l0ZW1faW5fY3VycmVudF9jaGtwdChzdHJ1Y3QgeGZzX2xvZ19pdGVtICpsaXApOwpkaWZmIC0tZ2l0IGEvZnMveGZzL3hmc19sb2dfY2lsLmMgYi9mcy94ZnMveGZzX2xvZ19jaWwuYwppbmRleCA5ZGM4MTI1Li45Y2E1OWJlIDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX2xvZ19jaWwuYworKysgYi9mcy94ZnMveGZzX2xvZ19jaWwuYwpAQCAtNTQzLDcgKzU0Myw3IEBACiAKIAllcnJvciA9IHhsb2dfd3JpdGUobG9nLCAmbHZoZHIsIHRpYywgJmN0eC0+c3RhcnRfbHNuLCBOVUxMLCAwKTsKIAlpZiAoZXJyb3IpCi0JCWdvdG8gb3V0X2Fib3J0OworCQlnb3RvIG91dF9hYm9ydF9mcmVlX3RpY2tldDsKIAogCS8qCiAJICogbm93IHRoYXQgd2UndmUgd3JpdHRlbiB0aGUgY2hlY2twb2ludCBpbnRvIHRoZSBsb2csIHN0cmljdGx5CkBAIC01NjksOCArNTY5LDkgQEAKIAl9CiAJc3Bpbl91bmxvY2soJmNpbC0+eGNfY2lsX2xvY2spOwogCisJLyogeGZzX2xvZ19kb25lIGFsd2F5cyBmcmVlcyB0aGUgdGlja2V0IG9uIGVycm9yLiAqLwogCWNvbW1pdF9sc24gPSB4ZnNfbG9nX2RvbmUobG9nLT5sX21wLCB0aWMsICZjb21taXRfaWNsb2csIDApOwotCWlmIChlcnJvciB8fCBjb21taXRfbHNuID09IC0xKQorCWlmIChjb21taXRfbHNuID09IC0xKQogCQlnb3RvIG91dF9hYm9ydDsKIAogCS8qIGF0dGFjaCBhbGwgdGhlIHRyYW5zYWN0aW9ucyB3LyBidXN5IGV4dGVudHMgdG8gaWNsb2cgKi8KQEAgLTYwMCw2ICs2MDEsOCBAQAogCWttZW1fZnJlZShuZXdfY3R4KTsKIAlyZXR1cm4gMDsKIAorb3V0X2Fib3J0X2ZyZWVfdGlja2V0OgorCXhmc19sb2dfdGlja2V0X3B1dCh0aWMpOwogb3V0X2Fib3J0OgogCXhsb2dfY2lsX2NvbW1pdHRlZChjdHgsIFhGU19MSV9BQk9SVEVEKTsKIAlyZXR1cm4gWEZTX0VSUk9SKEVJTyk7CkBAIC02MjIsNyArNjI1LDcgQEAKICAqIGJhY2tncm91bmQgY29tbWl0LCByZXR1cm5zIHdpdGhvdXQgaXQgaGVsZCBvbmNlIGJhY2tncm91bmQgY29tbWl0cyBhcmUKICAqIGFsbG93ZWQgYWdhaW4uCiAgKi8KLWludAordm9pZAogeGZzX2xvZ19jb21taXRfY2lsKAogCXN0cnVjdCB4ZnNfbW91bnQJKm1wLAogCXN0cnVjdCB4ZnNfdHJhbnMJKnRwLApAQCAtNjM3LDExICs2NDAsNiBAQAogCWlmIChmbGFncyAmIFhGU19UUkFOU19SRUxFQVNFX0xPR19SRVMpCiAJCWxvZ19mbGFncyA9IFhGU19MT0dfUkVMX1BFUk1fUkVTRVJWOwogCi0JaWYgKFhMT0dfRk9SQ0VEX1NIVVRET1dOKGxvZykpIHsKLQkJeGxvZ19jaWxfZnJlZV9sb2d2ZWMobG9nX3ZlY3Rvcik7Ci0JCXJldHVybiBYRlNfRVJST1IoRUlPKTsKLQl9Ci0KIAkvKgogCSAqIGRvIGFsbCB0aGUgaGFyZCB3b3JrIG9mIGZvcm1hdHRpbmcgaXRlbXMgKGluY2x1ZGluZyBtZW1vcnkKIAkgKiBhbGxvY2F0aW9uKSBvdXRzaWRlIHRoZSBDSUwgY29udGV4dCBsb2NrLiBUaGlzIHByZXZlbnRzIHN0YWxsaW5nIENJTApAQCAtNzAxLDcgKzY5OSw2IEBACiAJICovCiAJaWYgKHB1c2gpCiAJCXhsb2dfY2lsX3B1c2gobG9nLCAwKTsKLQlyZXR1cm4gMDsKIH0KIAogLyoKZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfbG9nX3JlY292ZXIuYyBiL2ZzL3hmcy94ZnNfbG9nX3JlY292ZXIuYwppbmRleCAyMDRkOGU1Li5hYTBlYmI3IDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX2xvZ19yZWNvdmVyLmMKKysrIGIvZnMveGZzL3hmc19sb2dfcmVjb3Zlci5jCkBAIC0zODAwLDcgKzM4MDAsNyBAQAogCQlsb2ctPmxfZmxhZ3MgJj0gflhMT0dfUkVDT1ZFUllfTkVFREVEOwogCX0gZWxzZSB7CiAJCWNtbl9lcnIoQ0VfREVCVUcsCi0JCQkiIUVuZGluZyBjbGVhbiBYRlMgbW91bnQgZm9yIGZpbGVzeXN0ZW06ICVzXG4iLAorCQkJIkVuZGluZyBjbGVhbiBYRlMgbW91bnQgZm9yIGZpbGVzeXN0ZW06ICVzXG4iLAogCQkJbG9nLT5sX21wLT5tX2ZzbmFtZSk7CiAJfQogCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvZnMveGZzL3hmc190cmFucy5jIGIvZnMveGZzL3hmc190cmFucy5jCmluZGV4IGY4MGEwNjcuLjc2OTIyNzkgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy94ZnNfdHJhbnMuYworKysgYi9mcy94ZnMveGZzX3RyYW5zLmMKQEAgLTExMzcsNyArMTEzNyw3IEBACiAJaWYgKGJsa2RlbHRhKQogCQl4ZnNfaWNzYl9tb2RpZnlfY291bnRlcnMobXAsIFhGU19TQlNfRkRCTE9DS1MsIC1ibGtkZWx0YSwgcnN2ZCk7CiBvdXQ6Ci0JQVNTRVJUKGVycm9yID0gMCk7CisJQVNTRVJUKGVycm9yID09IDApOwogCXJldHVybjsKIH0KIApAQCAtMTQ0Niw2ICsxNDQ2LDE0IEBACiAgKiBCdWxrIG9wZXJhdGlvbiB2ZXJzaW9uIG9mIHhmc190cmFuc19jb21taXR0ZWQgdGhhdCB0YWtlcyBhIGxvZyB2ZWN0b3Igb2YKICAqIGl0ZW1zIHRvIGluc2VydCBpbnRvIHRoZSBBSUwuIFRoaXMgdXNlcyBidWxrIEFJTCBpbnNlcnRpb24gdGVjaG5pcXVlcyB0bwogICogbWluaW1pc2UgbG9jayB0cmFmZmljLgorICoKKyAqIElmIHdlIGFyZSBjYWxsZWQgd2l0aCB0aGUgYWJvcnRlZCBmbGFnIHNldCwgaXQgaXMgYmVjYXVzZSBhIGxvZyB3cml0ZSBkdXJpbmcKKyAqIGEgQ0lMIGNoZWNrcG9pbnQgY29tbWl0IGhhcyBmYWlsZWQuIEluIHRoaXMgY2FzZSwgYWxsIHRoZSBpdGVtcyBpbiB0aGUKKyAqIGNoZWNrcG9pbnQgaGF2ZSBhbHJlYWR5IGdvbmUgdGhyb3VnaCBJT1BfQ09NTUlURUQgYW5kIElPUF9VTkxPQ0ssIHdoaWNoCisgKiBtZWFucyB0aGF0IGNoZWNrcG9pbnQgY29tbWl0IGFib3J0IGhhbmRsaW5nIGlzIHRyZWF0ZWQgZXhhY3RseSB0aGUgc2FtZQorICogYXMgYW4gaWNsb2cgd3JpdGUgZXJyb3IgZXZlbiB0aG91Z2ggd2UgaGF2ZW4ndCBzdGFydGVkIGFueSBJTyB5ZXQuIEhlbmNlIGluCisgKiB0aGlzIGNhc2UgYWxsIHdlIG5lZWQgdG8gZG8gaXMgSU9QX0NPTU1JVFRFRCBwcm9jZXNzaW5nLCBmb2xsb3dlZCBieSBhbgorICogSU9QX1VOUElOKGFib3J0ZWQpIGNhbGwuCiAgKi8KIHZvaWQKIHhmc190cmFuc19jb21taXR0ZWRfYnVsaygKQEAgLTE0NzIsNiArMTQ4MCwxNiBAQAogCQlpZiAoWEZTX0xTTl9DTVAoaXRlbV9sc24sICh4ZnNfbHNuX3QpLTEpID09IDApCiAJCQljb250aW51ZTsKIAorCQkvKgorCQkgKiBpZiB3ZSBhcmUgYWJvcnRpbmcgdGhlIG9wZXJhdGlvbiwgbm8gcG9pbnQgaW4gaW5zZXJ0aW5nIHRoZQorCQkgKiBvYmplY3QgaW50byB0aGUgQUlMIGFzIHdlIGFyZSBpbiBhIHNodXRkb3duIHNpdHVhdGlvbi4KKwkJICovCisJCWlmIChhYm9ydGVkKSB7CisJCQlBU1NFUlQoWEZTX0ZPUkNFRF9TSFVURE9XTihhaWxwLT54YV9tb3VudCkpOworCQkJSU9QX1VOUElOKGxpcCwgMSk7CisJCQljb250aW51ZTsKKwkJfQorCiAJCWlmIChpdGVtX2xzbiAhPSBjb21taXRfbHNuKSB7CiAKIAkJCS8qCkBAIC0xNTAzLDIwICsxNTIxLDI0IEBACiB9CiAKIC8qCi0gKiBDYWxsZWQgZnJvbSB0aGUgdHJhbnNfY29tbWl0IGNvZGUgd2hlbiB3ZSBub3RpY2UgdGhhdAotICogdGhlIGZpbGVzeXN0ZW0gaXMgaW4gdGhlIG1pZGRsZSBvZiBhIGZvcmNlZCBzaHV0ZG93bi4KKyAqIENhbGxlZCBmcm9tIHRoZSB0cmFuc19jb21taXQgY29kZSB3aGVuIHdlIG5vdGljZSB0aGF0IHRoZSBmaWxlc3lzdGVtIGlzIGluCisgKiB0aGUgbWlkZGxlIG9mIGEgZm9yY2VkIHNodXRkb3duLgorICoKKyAqIFdoZW4gd2UgYXJlIGNhbGxlZCBoZXJlLCB3ZSBoYXZlIGFscmVhZHkgcGlubmVkIGFsbCB0aGUgaXRlbXMgaW4gdGhlCisgKiB0cmFuc2FjdGlvbi4gSG93ZXZlciwgbmVpdGhlciBJT1BfQ09NTUlUVElORyBvciBJT1BfVU5MT0NLIGhhcyBiZWVuIGNhbGxlZAorICogc28gd2UgY2FuIHNpbXBseSB3YWxrIHRoZSBpdGVtcyBpbiB0aGUgdHJhbnNhY3Rpb24sIHVucGluIHRoZW0gd2l0aCBhbiBhYm9ydAorICogZmxhZyBhbmQgdGhlbiBmcmVlIHRoZSBpdGVtcy4gTm90ZSB0aGF0IHVucGlubmluZyB0aGUgaXRlbXMgY2FuIHJlc3VsdCBpbgorICogdGhlbSBiZWluZyBmcmVlZCBpbW1lZGlhdGVseSwgc28gd2UgbmVlZCB0byB1c2UgYSBzYWZlIGxpc3QgdHJhdmVyc2FsIG1ldGhvZAorICogaGVyZS4KICAqLwogU1RBVElDIHZvaWQKIHhmc190cmFuc191bmNvbW1pdCgKIAlzdHJ1Y3QgeGZzX3RyYW5zCSp0cCwKIAl1aW50CQkJZmxhZ3MpCiB7Ci0Jc3RydWN0IHhmc19sb2dfaXRlbV9kZXNjICpsaWRwOworCXN0cnVjdCB4ZnNfbG9nX2l0ZW1fZGVzYyAqbGlkcCwgKm47CiAKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGxpZHAsICZ0cC0+dF9pdGVtcywgbGlkX3RyYW5zKSB7Ci0JCS8qCi0JCSAqIFVucGluIGFsbCBidXQgdGhvc2UgdGhhdCBhcmVuJ3QgZGlydHkuCi0JCSAqLworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShsaWRwLCBuLCAmdHAtPnRfaXRlbXMsIGxpZF90cmFucykgewogCQlpZiAobGlkcC0+bGlkX2ZsYWdzICYgWEZTX0xJRF9ESVJUWSkKIAkJCUlPUF9VTlBJTihsaWRwLT5saWRfaXRlbSwgMSk7CiAJfQpAQCAtMTczMyw3ICsxNzU1LDYgQEAKIAlpbnQJCQlmbGFncykKIHsKIAlzdHJ1Y3QgeGZzX2xvZ192ZWMJKmxvZ192ZWN0b3I7Ci0JaW50CQkJZXJyb3I7CiAKIAkvKgogCSAqIEdldCBlYWNoIGxvZyBpdGVtIHRvIGFsbG9jYXRlIGEgdmVjdG9yIHN0cnVjdHVyZSBmb3IKQEAgLTE3NDQsOSArMTc2NSw3IEBACiAJaWYgKCFsb2dfdmVjdG9yKQogCQlyZXR1cm4gRU5PTUVNOwogCi0JZXJyb3IgPSB4ZnNfbG9nX2NvbW1pdF9jaWwobXAsIHRwLCBsb2dfdmVjdG9yLCBjb21taXRfbHNuLCBmbGFncyk7Ci0JaWYgKGVycm9yKQotCQlyZXR1cm4gZXJyb3I7CisJeGZzX2xvZ19jb21taXRfY2lsKG1wLCB0cCwgbG9nX3ZlY3RvciwgY29tbWl0X2xzbiwgZmxhZ3MpOwogCiAJY3VycmVudF9yZXN0b3JlX2ZsYWdzX25lc3RlZCgmdHAtPnRfcGZsYWdzLCBQRl9GU1RSQU5TKTsKIAl4ZnNfdHJhbnNfZnJlZSh0cCk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvYWNleGNlcC5oIGIvaW5jbHVkZS9hY3BpL2FjZXhjZXAuaAppbmRleCAxNzcxNGJlLi41YjZjMzkxIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvYWNleGNlcC5oCisrKyBiL2luY2x1ZGUvYWNwaS9hY2V4Y2VwLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvYWNuYW1lcy5oIGIvaW5jbHVkZS9hY3BpL2FjbmFtZXMuaAppbmRleCA5Y2Y3MzZlLi5mYzE1NzVmIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvYWNuYW1lcy5oCisrKyBiL2luY2x1ZGUvYWNwaS9hY25hbWVzLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvYWNvdXRwdXQuaCBiL2luY2x1ZGUvYWNwaS9hY291dHB1dC5oCmluZGV4IGJjNGE2ZGUuLmVmMWNlZjcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYWNwaS9hY291dHB1dC5oCisrKyBiL2luY2x1ZGUvYWNwaS9hY291dHB1dC5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hY3BpL2FjcGkuaCBiL2luY2x1ZGUvYWNwaS9hY3BpLmgKaW5kZXggYTA5MWNhYi4uZGUzOTkxNSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hY3BpL2FjcGkuaAorKysgYi9pbmNsdWRlL2FjcGkvYWNwaS5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hY3BpL2FjcGlfYnVzLmggYi9pbmNsdWRlL2FjcGkvYWNwaV9idXMuaAppbmRleCAzNTllZjExLi43OGNhNDI5IDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvYWNwaV9idXMuaAorKysgYi9pbmNsdWRlL2FjcGkvYWNwaV9idXMuaApAQCAtMTQ4LDkgKzE0OCw3IEBACiAJdTMyIHN1cHJpc2VfcmVtb3ZhbF9vazoxOwogCXUzMiBwb3dlcl9tYW5hZ2VhYmxlOjE7CiAJdTMyIHBlcmZvcm1hbmNlX21hbmFnZWFibGU6MTsKLQl1MzIgd2FrZV9jYXBhYmxlOjE7CS8qIFdha2V1cChfUFJXKSBzdXBwb3J0ZWQ/ICovCi0JdTMyIGZvcmNlX3Bvd2VyX3N0YXRlOjE7Ci0JdTMyIHJlc2VydmVkOjIyOworCXUzMiByZXNlcnZlZDoyNDsKIH07CiAKIC8qIEZpbGUgU3lzdGVtICovCkBAIC0yNDIsMjAgKzI0MCwxNCBAQAogc3RydWN0IGFjcGlfZGV2aWNlX3dha2V1cF9mbGFncyB7CiAJdTggdmFsaWQ6MTsJCS8qIENhbiBzdWNjZXNzZnVsbHkgZW5hYmxlIHdha2V1cD8gKi8KIAl1OCBydW5fd2FrZToxOwkJLyogUnVuLVdha2UgR1BFIGRldmljZXMgKi8KLQl1OCBhbHdheXNfZW5hYmxlZDoxOwkvKiBSdW4td2FrZSBkZXZpY2VzIHRoYXQgYXJlIGFsd2F5cyBlbmFibGVkICovCiAJdTggbm90aWZpZXJfcHJlc2VudDoxOyAgLyogV2FrZS11cCBub3RpZnkgaGFuZGxlciBoYXMgYmVlbiBpbnN0YWxsZWQgKi8KIH07CiAKLXN0cnVjdCBhY3BpX2RldmljZV93YWtldXBfc3RhdGUgewotCXU4IGVuYWJsZWQ6MTsKLX07Ci0KIHN0cnVjdCBhY3BpX2RldmljZV93YWtldXAgewogCWFjcGlfaGFuZGxlIGdwZV9kZXZpY2U7CiAJdTY0IGdwZV9udW1iZXI7CiAJdTY0IHNsZWVwX3N0YXRlOwogCXN0cnVjdCBhY3BpX2hhbmRsZV9saXN0IHJlc291cmNlczsKLQlzdHJ1Y3QgYWNwaV9kZXZpY2Vfd2FrZXVwX3N0YXRlIHN0YXRlOwogCXN0cnVjdCBhY3BpX2RldmljZV93YWtldXBfZmxhZ3MgZmxhZ3M7CiAJaW50IHByZXBhcmVfY291bnQ7CiAJaW50IHJ1bl93YWtlX2NvdW50OwpAQCAtMzI4LDggKzMyMCw4IEBACiBhY3BpX3N0YXR1cyBhY3BpX2J1c19nZXRfc3RhdHVzX2hhbmRsZShhY3BpX2hhbmRsZSBoYW5kbGUsCiAJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgbG9uZyAqc3RhKTsKIGludCBhY3BpX2J1c19nZXRfc3RhdHVzKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlKTsKLWludCBhY3BpX2J1c19nZXRfcG93ZXIoYWNwaV9oYW5kbGUgaGFuZGxlLCBpbnQgKnN0YXRlKTsKIGludCBhY3BpX2J1c19zZXRfcG93ZXIoYWNwaV9oYW5kbGUgaGFuZGxlLCBpbnQgc3RhdGUpOworaW50IGFjcGlfYnVzX3VwZGF0ZV9wb3dlcihhY3BpX2hhbmRsZSBoYW5kbGUsIGludCAqc3RhdGVfcCk7CiBib29sIGFjcGlfYnVzX3Bvd2VyX21hbmFnZWFibGUoYWNwaV9oYW5kbGUgaGFuZGxlKTsKIGJvb2wgYWNwaV9idXNfY2FuX3dha2V1cChhY3BpX2hhbmRsZSBoYW5kbGUpOwogI2lmZGVmIENPTkZJR19BQ1BJX1BST0NfRVZFTlQKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYWNwaS9hY3Bpb3N4Zi5oIGIvaW5jbHVkZS9hY3BpL2FjcGlvc3hmLmgKaW5kZXggNjViM2Y1OC4uYTMyNTJhNSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hY3BpL2FjcGlvc3hmLmgKKysrIGIvaW5jbHVkZS9hY3BpL2FjcGlvc3hmLmgKQEAgLTgsNyArOCw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvYWNwaXhmLmggYi9pbmNsdWRlL2FjcGkvYWNwaXhmLmgKaW5kZXggNTNiN2NmZC4uZTQ2ZWM5NSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hY3BpL2FjcGl4Zi5oCisrKyBiL2luY2x1ZGUvYWNwaS9hY3BpeGYuaApAQCAtNiw3ICs2LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKQEAgLTQ3LDcgKzQ3LDcgQEAKIAogLyogQ3VycmVudCBBQ1BJQ0Egc3Vic3lzdGVtIHZlcnNpb24gaW4gWVlZWU1NREQgZm9ybWF0ICovCiAKLSNkZWZpbmUgQUNQSV9DQV9WRVJTSU9OICAgICAgICAgICAgICAgICAweDIwMTAxMDEzCisjZGVmaW5lIEFDUElfQ0FfVkVSU0lPTiAgICAgICAgICAgICAgICAgMHgyMDExMDExMgogCiAjaW5jbHVkZSAiYWN0eXBlcy5oIgogI2luY2x1ZGUgImFjdGJsLmgiCkBAIC0yMjksNiArMjI5LDEwIEBACiBhY3BpX2luc3RhbGxfaW5pdGlhbGl6YXRpb25faGFuZGxlcihhY3BpX2luaXRfaGFuZGxlciBoYW5kbGVyLCB1MzIgZnVuY3Rpb24pOwogCiBhY3BpX3N0YXR1cworYWNwaV9pbnN0YWxsX2dsb2JhbF9ldmVudF9oYW5kbGVyKEFDUElfR0JMX0VWRU5UX0hBTkRMRVIgaGFuZGxlciwKKwkJCQkgdm9pZCAqY29udGV4dCk7CisKK2FjcGlfc3RhdHVzCiBhY3BpX2luc3RhbGxfZml4ZWRfZXZlbnRfaGFuZGxlcih1MzIgYWNwaV9ldmVudCwKIAkJCQkgYWNwaV9ldmVudF9oYW5kbGVyIGhhbmRsZXIsIHZvaWQgKmNvbnRleHQpOwogCkBAIC0yNTgsMTEgKzI2MiwxMSBAQAogYWNwaV9zdGF0dXMKIGFjcGlfaW5zdGFsbF9ncGVfaGFuZGxlcihhY3BpX2hhbmRsZSBncGVfZGV2aWNlLAogCQkJIHUzMiBncGVfbnVtYmVyLAotCQkJIHUzMiB0eXBlLCBhY3BpX2V2ZW50X2hhbmRsZXIgYWRkcmVzcywgdm9pZCAqY29udGV4dCk7CisJCQkgdTMyIHR5cGUsIGFjcGlfZ3BlX2hhbmRsZXIgYWRkcmVzcywgdm9pZCAqY29udGV4dCk7CiAKIGFjcGlfc3RhdHVzCiBhY3BpX3JlbW92ZV9ncGVfaGFuZGxlcihhY3BpX2hhbmRsZSBncGVfZGV2aWNlLAotCQkJdTMyIGdwZV9udW1iZXIsIGFjcGlfZXZlbnRfaGFuZGxlciBhZGRyZXNzKTsKKwkJCXUzMiBncGVfbnVtYmVyLCBhY3BpX2dwZV9oYW5kbGVyIGFkZHJlc3MpOwogCiAjaWZkZWYgQUNQSV9GVVRVUkVfVVNBR0UKIGFjcGlfc3RhdHVzIGFjcGlfaW5zdGFsbF9leGNlcHRpb25faGFuZGxlcihhY3BpX2V4Y2VwdGlvbl9oYW5kbGVyIGhhbmRsZXIpOwpAQCAtMjkyLDExICsyOTYsMTMgQEAKIAogYWNwaV9zdGF0dXMgYWNwaV9kaXNhYmxlX2dwZShhY3BpX2hhbmRsZSBncGVfZGV2aWNlLCB1MzIgZ3BlX251bWJlcik7CiAKLWFjcGlfc3RhdHVzIGFjcGlfZ3BlX2Nhbl93YWtlKGFjcGlfaGFuZGxlIGdwZV9kZXZpY2UsIHUzMiBncGVfbnVtYmVyKTsKLQogYWNwaV9zdGF0dXMgYWNwaV9jbGVhcl9ncGUoYWNwaV9oYW5kbGUgZ3BlX2RldmljZSwgdTMyIGdwZV9udW1iZXIpOwogCi1hY3BpX3N0YXR1cyBhY3BpX2dwZV93YWtldXAoYWNwaV9oYW5kbGUgZ3BlX2RldmljZSwgdTMyIGdwZV9udW1iZXIsIHU4IGFjdGlvbik7CithY3BpX3N0YXR1cworYWNwaV9zZXR1cF9ncGVfZm9yX3dha2UoYWNwaV9oYW5kbGUgcGFyZW50X2RldmljZSwKKwkJCWFjcGlfaGFuZGxlIGdwZV9kZXZpY2UsIHUzMiBncGVfbnVtYmVyKTsKKworYWNwaV9zdGF0dXMgYWNwaV9zZXRfZ3BlX3dha2VfbWFzayhhY3BpX2hhbmRsZSBncGVfZGV2aWNlLCB1MzIgZ3BlX251bWJlciwgdTggYWN0aW9uKTsKIAogYWNwaV9zdGF0dXMKIGFjcGlfZ2V0X2dwZV9zdGF0dXMoYWNwaV9oYW5kbGUgZ3BlX2RldmljZSwKQEAgLTMxNSw3ICszMjEsNyBAQAogCiBhY3BpX3N0YXR1cyBhY3BpX3JlbW92ZV9ncGVfYmxvY2soYWNwaV9oYW5kbGUgZ3BlX2RldmljZSk7CiAKLWFjcGlfc3RhdHVzIGFjcGlfdXBkYXRlX2dwZXModm9pZCk7CithY3BpX3N0YXR1cyBhY3BpX3VwZGF0ZV9hbGxfZ3Blcyh2b2lkKTsKIAogLyoKICAqIFJlc291cmNlIGludGVyZmFjZXMKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYWNwaS9hY3Jlc3R5cC5oIGIvaW5jbHVkZS9hY3BpL2FjcmVzdHlwLmgKaW5kZXggZTU1MjYzNS4uMGE2NmNjNCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hY3BpL2FjcmVzdHlwLmgKKysrIGIvaW5jbHVkZS9hY3BpL2FjcmVzdHlwLmgKQEAgLTUsNyArNSw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKIC8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDEwLCBJbnRlbCBDb3JwLgorICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMSwgSW50ZWwgQ29ycC4KICAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvYWN0YmwuaCBiL2luY2x1ZGUvYWNwaS9hY3RibC5oCmluZGV4IGFkMjAwMTYuLjdlNDJiZmUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYWNwaS9hY3RibC5oCisrKyBiL2luY2x1ZGUvYWNwaS9hY3RibC5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hY3BpL2FjdGJsMS5oIGIvaW5jbHVkZS9hY3BpL2FjdGJsMS5oCmluZGV4IGNkNzdhYTc1Yy4uNzUwNGJjOSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hY3BpL2FjdGJsMS5oCisrKyBiL2luY2x1ZGUvYWNwaS9hY3RibDEuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYWNwaS9hY3RibDIuaCBiL2luY2x1ZGUvYWNwaS9hY3RibDIuaAppbmRleCBkNDEzNmIyLi4wZmMxNWRmIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvYWN0YmwyLmgKKysrIGIvaW5jbHVkZS9hY3BpL2FjdGJsMi5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hY3BpL2FjdHlwZXMuaCBiL2luY2x1ZGUvYWNwaS9hY3R5cGVzLmgKaW5kZXggMmIxMzRiNi4uNjRmODM4YiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hY3BpL2FjdHlwZXMuaAorKysgYi9pbmNsdWRlL2FjcGkvYWN0eXBlcy5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtNjU2LDMzICs2NTYsMzQgQEAKICNkZWZpbmUgQUNQSV9HUEVfTUFYICAgICAgICAgICAgICAgICAgICAweEZGCiAjZGVmaW5lIEFDUElfTlVNX0dQRSAgICAgICAgICAgICAgICAgICAgMjU2CiAKLS8qIEFjdGlvbnMgZm9yIGFjcGlfZ3BlX3dha2V1cCwgYWNwaV9od19sb3dfc2V0X2dwZSAqLworLyogQWN0aW9ucyBmb3IgYWNwaV9zZXRfZ3BlX3dha2VfbWFzaywgYWNwaV9od19sb3dfc2V0X2dwZSAqLwogCiAjZGVmaW5lIEFDUElfR1BFX0VOQUJMRSAgICAgICAgICAgICAgICAgMAogI2RlZmluZSBBQ1BJX0dQRV9ESVNBQkxFICAgICAgICAgICAgICAgIDEKLSNkZWZpbmUgQUNQSV9HUEVfQ09ORF9FTkFCTEUgICAgICAgICAgICAyCisjZGVmaW5lIEFDUElfR1BFX0NPTkRJVElPTkFMX0VOQUJMRSAgICAgMgogCiAvKgogICogR1BFIGluZm8gZmxhZ3MgLSBQZXIgR1BFCi0gKiArLS0tLS0tLSstLS0rLSstKwotICogfCAgNzo0ICB8MzoyfDF8MHwKLSAqICstLS0tLS0tKy0tLSstKy0rCi0gKiAgICAgfCAgICAgfCAgfCB8Ci0gKiAgICAgfCAgICAgfCAgfCArLS0tIEludGVycnVwdCB0eXBlOiBlZGdlIG9yIGxldmVsIHRyaWdnZXJlZAotICogICAgIHwgICAgIHwgICstLS0tLSBHUEUgY2FuIHdha2UgdGhlIHN5c3RlbQotICogICAgIHwgICAgICstLS0tLS0tLSBUeXBlIG9mIGRpc3BhdGNoOnRvIG1ldGhvZCwgaGFuZGxlciwgb3Igbm9uZQotICogICAgICstLS0tLS0tLS0tLS0tLSA8UmVzZXJ2ZWQ+CisgKiArLS0tLS0tLSstKy0rLS0tKworICogfCAgNzo0ICB8M3wyfDE6MHwKKyAqICstLS0tLS0tKy0rLSstLS0rCisgKiAgICAgfCAgICB8IHwgIHwKKyAqICAgICB8ICAgIHwgfCAgKy0tIFR5cGUgb2YgZGlzcGF0Y2g6dG8gbWV0aG9kLCBoYW5kbGVyLCBub3RpZnksIG9yIG5vbmUKKyAqICAgICB8ICAgIHwgKy0tLS0tIEludGVycnVwdCB0eXBlOiBlZGdlIG9yIGxldmVsIHRyaWdnZXJlZAorICogICAgIHwgICAgKy0tLS0tLS0gSXMgYSBXYWtlIEdQRQorICogICAgICstLS0tLS0tLS0tLS0gPFJlc2VydmVkPgogICovCi0jZGVmaW5lIEFDUElfR1BFX1hSVVBUX1RZUEVfTUFTSyAgICAgICAgKHU4KSAweDAxCi0jZGVmaW5lIEFDUElfR1BFX0xFVkVMX1RSSUdHRVJFRCAgICAgICAgKHU4KSAweDAxCisjZGVmaW5lIEFDUElfR1BFX0RJU1BBVENIX05PTkUgICAgICAgICAgKHU4KSAweDAwCisjZGVmaW5lIEFDUElfR1BFX0RJU1BBVENIX01FVEhPRCAgICAgICAgKHU4KSAweDAxCisjZGVmaW5lIEFDUElfR1BFX0RJU1BBVENIX0hBTkRMRVIgICAgICAgKHU4KSAweDAyCisjZGVmaW5lIEFDUElfR1BFX0RJU1BBVENIX05PVElGWSAgICAgICAgKHU4KSAweDAzCisjZGVmaW5lIEFDUElfR1BFX0RJU1BBVENIX01BU0sgICAgICAgICAgKHU4KSAweDAzCisKKyNkZWZpbmUgQUNQSV9HUEVfTEVWRUxfVFJJR0dFUkVEICAgICAgICAodTgpIDB4MDQKICNkZWZpbmUgQUNQSV9HUEVfRURHRV9UUklHR0VSRUQgICAgICAgICAodTgpIDB4MDAKKyNkZWZpbmUgQUNQSV9HUEVfWFJVUFRfVFlQRV9NQVNLICAgICAgICAodTgpIDB4MDQKIAotI2RlZmluZSBBQ1BJX0dQRV9DQU5fV0FLRQkJKHU4KSAweDAyCi0KLSNkZWZpbmUgQUNQSV9HUEVfRElTUEFUQ0hfTUFTSyAgICAgICAgICAodTgpIDB4MEMKLSNkZWZpbmUgQUNQSV9HUEVfRElTUEFUQ0hfSEFORExFUiAgICAgICAodTgpIDB4MDQKLSNkZWZpbmUgQUNQSV9HUEVfRElTUEFUQ0hfTUVUSE9EICAgICAgICAodTgpIDB4MDgKLSNkZWZpbmUgQUNQSV9HUEVfRElTUEFUQ0hfTk9UX1VTRUQgICAgICAodTgpIDB4MDAKKyNkZWZpbmUgQUNQSV9HUEVfQ0FOX1dBS0UgICAgICAgICAgICAgICAodTgpIDB4MDgKIAogLyoKICAqIEZsYWdzIGZvciBHUEUgYW5kIExvY2sgaW50ZXJmYWNlcwpAQCAtODk0LDkgKzg5NSwyMCBAQAogLyoKICAqIFZhcmlvdXMgaGFuZGxlcnMgYW5kIGNhbGxiYWNrIHByb2NlZHVyZXMKICAqLwordHlwZWRlZgordm9pZCAoKkFDUElfR0JMX0VWRU5UX0hBTkRMRVIpICh1MzIgZXZlbnRfdHlwZSwKKwkJCSAgICAgICBhY3BpX2hhbmRsZSBkZXZpY2UsCisJCQkgICAgICAgdTMyIGV2ZW50X251bWJlciwgdm9pZCAqY29udGV4dCk7CisKKyNkZWZpbmUgQUNQSV9FVkVOVF9UWVBFX0dQRSAgICAgICAgIDAKKyNkZWZpbmUgQUNQSV9FVkVOVF9UWVBFX0ZJWEVEICAgICAgIDEKKwogdHlwZWRlZiB1MzIoKmFjcGlfZXZlbnRfaGFuZGxlcikgKHZvaWQgKmNvbnRleHQpOwogCiB0eXBlZGVmCit1MzIgKCphY3BpX2dwZV9oYW5kbGVyKSAoYWNwaV9oYW5kbGUgZ3BlX2RldmljZSwgdTMyIGdwZV9udW1iZXIsIHZvaWQgKmNvbnRleHQpOworCit0eXBlZGVmCiB2b2lkICgqYWNwaV9ub3RpZnlfaGFuZGxlcikgKGFjcGlfaGFuZGxlIGRldmljZSwgdTMyIHZhbHVlLCB2b2lkICpjb250ZXh0KTsKIAogdHlwZWRlZgpAQCAtOTUxLDYgKzk2MywxMCBAQAogI2RlZmluZSBBQ1BJX0lOVEVSUlVQVF9OT1RfSEFORExFRCAgICAgIDB4MDAKICNkZWZpbmUgQUNQSV9JTlRFUlJVUFRfSEFORExFRCAgICAgICAgICAweDAxCiAKKy8qIEdQRSBoYW5kbGVyIHJldHVybiB2YWx1ZXMgKi8KKworI2RlZmluZSBBQ1BJX1JFRU5BQkxFX0dQRSAgICAgICAgICAgICAgIDB4ODAKKwogLyogTGVuZ3RoIG9mIDMyLWJpdCBFSVNBSUQgdmFsdWVzIHdoZW4gY29udmVydGVkIGJhY2sgdG8gYSBzdHJpbmcgKi8KIAogI2RlZmluZSBBQ1BJX0VJU0FJRF9TVFJJTkdfU0laRSAgICAgICAgIDgJLyogSW5jbHVkZXMgbnVsbCB0ZXJtaW5hdG9yICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvYXBlaS5oIGIvaW5jbHVkZS9hY3BpL2FwZWkuaAppbmRleCBiMzM2NTAyLi5jNGRiYjEzIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvYXBlaS5oCisrKyBiL2luY2x1ZGUvYWNwaS9hcGVpLmgKQEAgLTE5LDYgKzE5LDEyIEBACiBleHRlcm4gaW50IGhlc3RfZGlzYWJsZTsKIGV4dGVybiBpbnQgZXJzdF9kaXNhYmxlOwogCisjaWZkZWYgQ09ORklHX0FDUElfQVBFSQordm9pZCBfX2luaXQgYWNwaV9oZXN0X2luaXQodm9pZCk7CisjZWxzZQorc3RhdGljIGlubGluZSB2b2lkIGFjcGlfaGVzdF9pbml0KHZvaWQpIHsgcmV0dXJuOyB9CisjZW5kaWYKKwogdHlwZWRlZiBpbnQgKCphcGVpX2hlc3RfZnVuY190KShzdHJ1Y3QgYWNwaV9oZXN0X2hlYWRlciAqaGVzdF9oZHIsIHZvaWQgKmRhdGEpOwogaW50IGFwZWlfaGVzdF9wYXJzZShhcGVpX2hlc3RfZnVuY190IGZ1bmMsIHZvaWQgKmRhdGEpOwogCmRpZmYgLS1naXQgYS9pbmNsdWRlL2FjcGkvcGxhdGZvcm0vYWNlbnYuaCBiL2luY2x1ZGUvYWNwaS9wbGF0Zm9ybS9hY2Vudi5oCmluZGV4IGEzZTMzNGEuLjVhZjNlZDUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYWNwaS9wbGF0Zm9ybS9hY2Vudi5oCisrKyBiL2luY2x1ZGUvYWNwaS9wbGF0Zm9ybS9hY2Vudi5oCkBAIC01LDcgKzUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAvKgotICogQ29weXJpZ2h0IChDKSAyMDAwIC0gMjAxMCwgSW50ZWwgQ29ycC4KKyAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTEsIEludGVsIENvcnAuCiAgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hY3BpL3BsYXRmb3JtL2FjZ2NjLmggYi9pbmNsdWRlL2FjcGkvcGxhdGZvcm0vYWNnY2MuaAppbmRleCA1ZGNiOTUzLi5lMjI4ODkzIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvcGxhdGZvcm0vYWNnY2MuaAorKysgYi9pbmNsdWRlL2FjcGkvcGxhdGZvcm0vYWNnY2MuaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYWNwaS9wbGF0Zm9ybS9hY2xpbnV4LmggYi9pbmNsdWRlL2FjcGkvcGxhdGZvcm0vYWNsaW51eC5oCmluZGV4IDU3MjE4OWUuLjVkMmE1ZTkgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYWNwaS9wbGF0Zm9ybS9hY2xpbnV4LmgKKysrIGIvaW5jbHVkZS9hY3BpL3BsYXRmb3JtL2FjbGludXguaApAQCAtNSw3ICs1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogLyoKLSAqIENvcHlyaWdodCAoQykgMjAwMCAtIDIwMTAsIEludGVsIENvcnAuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDAgLSAyMDExLCBJbnRlbCBDb3JwLgogICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYWNwaS9wcm9jZXNzb3IuaCBiL2luY2x1ZGUvYWNwaS9wcm9jZXNzb3IuaAppbmRleCAxYjYyMTAyLi41NTE5MmFjIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FjcGkvcHJvY2Vzc29yLmgKKysrIGIvaW5jbHVkZS9hY3BpL3Byb2Nlc3Nvci5oCkBAIC0zMjQsNiArMzI0LDEyIEBACiBpbnQgYWNwaV9wcm9jZXNzb3JfZ2V0X3Rocm90dGxpbmdfaW5mbyhzdHJ1Y3QgYWNwaV9wcm9jZXNzb3IgKnByKTsKIGV4dGVybiBpbnQgYWNwaV9wcm9jZXNzb3Jfc2V0X3Rocm90dGxpbmcoc3RydWN0IGFjcGlfcHJvY2Vzc29yICpwciwKIAkJCQkJIGludCBzdGF0ZSwgYm9vbCBmb3JjZSk7CisvKgorICogUmVldmFsdWF0ZSB3aGV0aGVyIHRoZSBULXN0YXRlIGlzIGludmFsaWQgYWZ0ZXIgb25lIGNwdSBpcworICogb25saW5lZC9vZmZsaW5lZC4gSW4gc3VjaCBjYXNlIHRoZSBmbGFncy50aHJvdHRsaW5nIHdpbGwgYmUgdXBkYXRlZC4KKyAqLworZXh0ZXJuIHZvaWQgYWNwaV9wcm9jZXNzb3JfcmVldmFsdWF0ZV90c3RhdGUoc3RydWN0IGFjcGlfcHJvY2Vzc29yICpwciwKKwkJCXVuc2lnbmVkIGxvbmcgYWN0aW9uKTsKIGV4dGVybiBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGFjcGlfcHJvY2Vzc29yX3Rocm90dGxpbmdfZm9wczsKIGV4dGVybiB2b2lkIGFjcGlfcHJvY2Vzc29yX3Rocm90dGxpbmdfaW5pdCh2b2lkKTsKIC8qIGluIHByb2Nlc3Nvcl9pZGxlLmMgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvZ3Bpby5oIGIvaW5jbHVkZS9hc20tZ2VuZXJpYy9ncGlvLmgKaW5kZXggNjA5OGNhZS4uZmY1YzY2MCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hc20tZ2VuZXJpYy9ncGlvLmgKKysrIGIvaW5jbHVkZS9hc20tZ2VuZXJpYy9ncGlvLmgKQEAgLTE0NywxMSArMTQ3LDExIEBACiAvKiBBbHdheXMgdXNlIHRoZSBsaWJyYXJ5IGNvZGUgZm9yIEdQSU8gbWFuYWdlbWVudCBjYWxscywKICAqIG9yIHdoZW4gc2xlZXBpbmcgbWF5IGJlIGludm9sdmVkLgogICovCi1leHRlcm4gaW50IF9fbXVzdF9jaGVjayBncGlvX3JlcXVlc3QodW5zaWduZWQgZ3BpbywgY29uc3QgY2hhciAqbGFiZWwpOworZXh0ZXJuIGludCBncGlvX3JlcXVlc3QodW5zaWduZWQgZ3BpbywgY29uc3QgY2hhciAqbGFiZWwpOwogZXh0ZXJuIHZvaWQgZ3Bpb19mcmVlKHVuc2lnbmVkIGdwaW8pOwogCi1leHRlcm4gaW50IF9fbXVzdF9jaGVjayBncGlvX2RpcmVjdGlvbl9pbnB1dCh1bnNpZ25lZCBncGlvKTsKLWV4dGVybiBpbnQgX19tdXN0X2NoZWNrIGdwaW9fZGlyZWN0aW9uX291dHB1dCh1bnNpZ25lZCBncGlvLCBpbnQgdmFsdWUpOworZXh0ZXJuIGludCBncGlvX2RpcmVjdGlvbl9pbnB1dCh1bnNpZ25lZCBncGlvKTsKK2V4dGVybiBpbnQgZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KHVuc2lnbmVkIGdwaW8sIGludCB2YWx1ZSk7CiAKIGV4dGVybiBpbnQgZ3Bpb19zZXRfZGVib3VuY2UodW5zaWduZWQgZ3BpbywgdW5zaWduZWQgZGVib3VuY2UpOwogCkBAIC0xOTIsOCArMTkyLDggQEAKIAljb25zdCBjaGFyCSpsYWJlbDsKIH07CiAKLWV4dGVybiBpbnQgX19tdXN0X2NoZWNrIGdwaW9fcmVxdWVzdF9vbmUodW5zaWduZWQgZ3BpbywgdW5zaWduZWQgbG9uZyBmbGFncywgY29uc3QgY2hhciAqbGFiZWwpOwotZXh0ZXJuIGludCBfX211c3RfY2hlY2sgZ3Bpb19yZXF1ZXN0X2FycmF5KHN0cnVjdCBncGlvICphcnJheSwgc2l6ZV90IG51bSk7CitleHRlcm4gaW50IGdwaW9fcmVxdWVzdF9vbmUodW5zaWduZWQgZ3BpbywgdW5zaWduZWQgbG9uZyBmbGFncywgY29uc3QgY2hhciAqbGFiZWwpOworZXh0ZXJuIGludCBncGlvX3JlcXVlc3RfYXJyYXkoc3RydWN0IGdwaW8gKmFycmF5LCBzaXplX3QgbnVtKTsKIGV4dGVybiB2b2lkIGdwaW9fZnJlZV9hcnJheShzdHJ1Y3QgZ3BpbyAqYXJyYXksIHNpemVfdCBudW0pOwogCiAjaWZkZWYgQ09ORklHX0dQSU9fU1lTRlMKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvbW1hbi1jb21tb24uaCBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvbW1hbi1jb21tb24uaAppbmRleCAzZGE5ZTI3Li43ODdhYmJiIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FzbS1nZW5lcmljL21tYW4tY29tbW9uLmgKKysrIGIvaW5jbHVkZS9hc20tZ2VuZXJpYy9tbWFuLWNvbW1vbi5oCkBAIC00NSw2ICs0NSw5IEBACiAjZGVmaW5lIE1BRFZfTUVSR0VBQkxFICAgMTIJCS8qIEtTTSBtYXkgbWVyZ2UgaWRlbnRpY2FsIHBhZ2VzICovCiAjZGVmaW5lIE1BRFZfVU5NRVJHRUFCTEUgMTMJCS8qIEtTTSBtYXkgbm90IG1lcmdlIGlkZW50aWNhbCBwYWdlcyAqLwogCisjZGVmaW5lIE1BRFZfSFVHRVBBR0UJMTQJCS8qIFdvcnRoIGJhY2tpbmcgd2l0aCBodWdlcGFnZXMgKi8KKyNkZWZpbmUgTUFEVl9OT0hVR0VQQUdFCTE1CQkvKiBOb3Qgd29ydGggYmFja2luZyB3aXRoIGh1Z2VwYWdlcyAqLworCiAvKiBjb21wYXRpYmlsaXR5IGZsYWdzICovCiAjZGVmaW5lIE1BUF9GSUxFCTAKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hc20tZ2VuZXJpYy9wZ3RhYmxlLmggYi9pbmNsdWRlL2FzbS1nZW5lcmljL3BndGFibGUuaAppbmRleCA2ZjNjNmFlLi4zMWI2MTg4IDEwMDY0NAotLS0gYS9pbmNsdWRlL2FzbS1nZW5lcmljL3BndGFibGUuaAorKysgYi9pbmNsdWRlL2FzbS1nZW5lcmljL3BndGFibGUuaApAQCAtNSw2NyArNSwxMDAgQEAKICNpZmRlZiBDT05GSUdfTU1VCiAKICNpZm5kZWYgX19IQVZFX0FSQ0hfUFRFUF9TRVRfQUNDRVNTX0ZMQUdTCi0vKgotICogTGFyZ2VseSBzYW1lIGFzIGFib3ZlLCBidXQgb25seSBzZXRzIHRoZSBhY2Nlc3MgZmxhZ3MgKGRpcnR5LAotICogYWNjZXNzZWQsIGFuZCB3cml0YWJsZSkuIEZ1cnRoZXJtb3JlLCB3ZSBrbm93IGl0IGFsd2F5cyBnZXRzIHNldAotICogdG8gYSAibW9yZSBwZXJtaXNzaXZlIiBzZXR0aW5nLCB3aGljaCBhbGxvd3MgbW9zdCBhcmNoaXRlY3R1cmVzCi0gKiB0byBvcHRpbWl6ZSB0aGlzLiBXZSByZXR1cm4gd2hldGhlciB0aGUgUFRFIGFjdHVhbGx5IGNoYW5nZWQsIHdoaWNoCi0gKiBpbiB0dXJuIGluc3RydWN0cyB0aGUgY2FsbGVyIHRvIGRvIHRoaW5ncyBsaWtlIHVwZGF0ZV9fbW11X2NhY2hlLgotICogVGhpcyB1c2VkIHRvIGJlIGRvbmUgaW4gdGhlIGNhbGxlciwgYnV0IHNwYXJjIG5lZWRzIG1pbm9yIGZhdWx0cyB0bwotICogZm9yY2UgdGhhdCBjYWxsIG9uIHN1bjRjIHNvIHdlIGNoYW5nZWQgdGhpcyBtYWNybyBzbGlnaHRseQotICovCi0jZGVmaW5lIHB0ZXBfc2V0X2FjY2Vzc19mbGFncyhfX3ZtYSwgX19hZGRyZXNzLCBfX3B0ZXAsIF9fZW50cnksIF9fZGlydHkpIFwKLSh7CQkJCQkJCQkJICBcCi0JaW50IF9fY2hhbmdlZCA9ICFwdGVfc2FtZSgqKF9fcHRlcCksIF9fZW50cnkpOwkJCSAgXAotCWlmIChfX2NoYW5nZWQpIHsJCQkJCQkgIFwKLQkJc2V0X3B0ZV9hdCgoX192bWEpLT52bV9tbSwgKF9fYWRkcmVzcyksIF9fcHRlcCwgX19lbnRyeSk7IFwKLQkJZmx1c2hfdGxiX3BhZ2UoX192bWEsIF9fYWRkcmVzcyk7CQkJICBcCi0JfQkJCQkJCQkJICBcCi0JX19jaGFuZ2VkOwkJCQkJCQkgIFwKLX0pCitleHRlcm4gaW50IHB0ZXBfc2V0X2FjY2Vzc19mbGFncyhzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCQkgdW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwdGVfdCAqcHRlcCwKKwkJCQkgcHRlX3QgZW50cnksIGludCBkaXJ0eSk7CisjZW5kaWYKKworI2lmbmRlZiBfX0hBVkVfQVJDSF9QTURQX1NFVF9BQ0NFU1NfRkxBR1MKK2V4dGVybiBpbnQgcG1kcF9zZXRfYWNjZXNzX2ZsYWdzKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJCSB1bnNpZ25lZCBsb25nIGFkZHJlc3MsIHBtZF90ICpwbWRwLAorCQkJCSBwbWRfdCBlbnRyeSwgaW50IGRpcnR5KTsKICNlbmRpZgogCiAjaWZuZGVmIF9fSEFWRV9BUkNIX1BURVBfVEVTVF9BTkRfQ0xFQVJfWU9VTkcKLSNkZWZpbmUgcHRlcF90ZXN0X2FuZF9jbGVhcl95b3VuZyhfX3ZtYSwgX19hZGRyZXNzLCBfX3B0ZXApCQlcCi0oewkJCQkJCQkJCVwKLQlwdGVfdCBfX3B0ZSA9ICooX19wdGVwKTsJCQkJCVwKLQlpbnQgciA9IDE7CQkJCQkJCVwKLQlpZiAoIXB0ZV95b3VuZyhfX3B0ZSkpCQkJCQkJXAotCQlyID0gMDsJCQkJCQkJXAotCWVsc2UJCQkJCQkJCVwKLQkJc2V0X3B0ZV9hdCgoX192bWEpLT52bV9tbSwgKF9fYWRkcmVzcyksCQkJXAotCQkJICAgKF9fcHRlcCksIHB0ZV9ta29sZChfX3B0ZSkpOwkJCVwKLQlyOwkJCQkJCQkJXAotfSkKK3N0YXRpYyBpbmxpbmUgaW50IHB0ZXBfdGVzdF9hbmRfY2xlYXJfeW91bmcoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCQkJCSAgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCisJCQkJCSAgICBwdGVfdCAqcHRlcCkKK3sKKwlwdGVfdCBwdGUgPSAqcHRlcDsKKwlpbnQgciA9IDE7CisJaWYgKCFwdGVfeW91bmcocHRlKSkKKwkJciA9IDA7CisJZWxzZQorCQlzZXRfcHRlX2F0KHZtYS0+dm1fbW0sIGFkZHJlc3MsIHB0ZXAsIHB0ZV9ta29sZChwdGUpKTsKKwlyZXR1cm4gcjsKK30KKyNlbmRpZgorCisjaWZuZGVmIF9fSEFWRV9BUkNIX1BNRFBfVEVTVF9BTkRfQ0xFQVJfWU9VTkcKKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UKK3N0YXRpYyBpbmxpbmUgaW50IHBtZHBfdGVzdF9hbmRfY2xlYXJfeW91bmcoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCQkJCSAgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCisJCQkJCSAgICBwbWRfdCAqcG1kcCkKK3sKKwlwbWRfdCBwbWQgPSAqcG1kcDsKKwlpbnQgciA9IDE7CisJaWYgKCFwbWRfeW91bmcocG1kKSkKKwkJciA9IDA7CisJZWxzZQorCQlzZXRfcG1kX2F0KHZtYS0+dm1fbW0sIGFkZHJlc3MsIHBtZHAsIHBtZF9ta29sZChwbWQpKTsKKwlyZXR1cm4gcjsKK30KKyNlbHNlIC8qIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRSAqLworc3RhdGljIGlubGluZSBpbnQgcG1kcF90ZXN0X2FuZF9jbGVhcl95b3VuZyhzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCQkJICAgIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywKKwkJCQkJICAgIHBtZF90ICpwbWRwKQoreworCUJVRygpOworCXJldHVybiAwOworfQorI2VuZGlmIC8qIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRSAqLwogI2VuZGlmCiAKICNpZm5kZWYgX19IQVZFX0FSQ0hfUFRFUF9DTEVBUl9ZT1VOR19GTFVTSAotI2RlZmluZSBwdGVwX2NsZWFyX2ZsdXNoX3lvdW5nKF9fdm1hLCBfX2FkZHJlc3MsIF9fcHRlcCkJCVwKLSh7CQkJCQkJCQkJXAotCWludCBfX3lvdW5nOwkJCQkJCQlcCi0JX195b3VuZyA9IHB0ZXBfdGVzdF9hbmRfY2xlYXJfeW91bmcoX192bWEsIF9fYWRkcmVzcywgX19wdGVwKTsJXAotCWlmIChfX3lvdW5nKQkJCQkJCQlcCi0JCWZsdXNoX3RsYl9wYWdlKF9fdm1hLCBfX2FkZHJlc3MpOwkJCVwKLQlfX3lvdW5nOwkJCQkJCQlcCi19KQoraW50IHB0ZXBfY2xlYXJfZmx1c2hfeW91bmcoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCQkgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsIHB0ZV90ICpwdGVwKTsKKyNlbmRpZgorCisjaWZuZGVmIF9fSEFWRV9BUkNIX1BNRFBfQ0xFQVJfWU9VTkdfRkxVU0gKK2ludCBwbWRwX2NsZWFyX2ZsdXNoX3lvdW5nKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJICAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwbWRfdCAqcG1kcCk7CiAjZW5kaWYKIAogI2lmbmRlZiBfX0hBVkVfQVJDSF9QVEVQX0dFVF9BTkRfQ0xFQVIKLSNkZWZpbmUgcHRlcF9nZXRfYW5kX2NsZWFyKF9fbW0sIF9fYWRkcmVzcywgX19wdGVwKQkJCVwKLSh7CQkJCQkJCQkJXAotCXB0ZV90IF9fcHRlID0gKihfX3B0ZXApOwkJCQkJXAotCXB0ZV9jbGVhcigoX19tbSksIChfX2FkZHJlc3MpLCAoX19wdGVwKSk7CQkJXAotCV9fcHRlOwkJCQkJCQkJXAorc3RhdGljIGlubGluZSBwdGVfdCBwdGVwX2dldF9hbmRfY2xlYXIoc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywKKwkJCQkgICAgICAgcHRlX3QgKnB0ZXApCit7CisJcHRlX3QgcHRlID0gKnB0ZXA7CisJcHRlX2NsZWFyKG1tLCBhZGRyZXNzLCBwdGVwKTsKKwlyZXR1cm4gcHRlOworfQorI2VuZGlmCisKKyNpZm5kZWYgX19IQVZFX0FSQ0hfUE1EUF9HRVRfQU5EX0NMRUFSCisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCitzdGF0aWMgaW5saW5lIHBtZF90IHBtZHBfZ2V0X2FuZF9jbGVhcihzdHJ1Y3QgbW1fc3RydWN0ICptbSwKKwkJCQkgICAgICAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLAorCQkJCSAgICAgICBwbWRfdCAqcG1kcCkKK3sKKwlwbWRfdCBwbWQgPSAqcG1kcDsKKwlwbWRfY2xlYXIobW0sIGFkZHJlc3MsIHBtZHApOworCXJldHVybiBwbWQ7CiB9KQorI2VuZGlmIC8qIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRSAqLwogI2VuZGlmCiAKICNpZm5kZWYgX19IQVZFX0FSQ0hfUFRFUF9HRVRfQU5EX0NMRUFSX0ZVTEwKLSNkZWZpbmUgcHRlcF9nZXRfYW5kX2NsZWFyX2Z1bGwoX19tbSwgX19hZGRyZXNzLCBfX3B0ZXAsIF9fZnVsbCkJXAotKHsJCQkJCQkJCQlcCi0JcHRlX3QgX19wdGU7CQkJCQkJCVwKLQlfX3B0ZSA9IHB0ZXBfZ2V0X2FuZF9jbGVhcigoX19tbSksIChfX2FkZHJlc3MpLCAoX19wdGVwKSk7CVwKLQlfX3B0ZTsJCQkJCQkJCVwKLX0pCitzdGF0aWMgaW5saW5lIHB0ZV90IHB0ZXBfZ2V0X2FuZF9jbGVhcl9mdWxsKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJCQkgICAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwdGVfdCAqcHRlcCwKKwkJCQkJICAgIGludCBmdWxsKQoreworCXB0ZV90IHB0ZTsKKwlwdGUgPSBwdGVwX2dldF9hbmRfY2xlYXIobW0sIGFkZHJlc3MsIHB0ZXApOworCXJldHVybiBwdGU7Cit9CiAjZW5kaWYKIAogLyoKQEAgLTc0LDIwICsxMDcsMjUgQEAKICAqIG5vdCBwcmVzZW50LCBvciBpbiB0aGUgcHJvY2VzcyBvZiBhbiBhZGRyZXNzIHNwYWNlIGRlc3RydWN0aW9uLgogICovCiAjaWZuZGVmIF9fSEFWRV9BUkNIX1BURV9DTEVBUl9OT1RfUFJFU0VOVF9GVUxMCi0jZGVmaW5lIHB0ZV9jbGVhcl9ub3RfcHJlc2VudF9mdWxsKF9fbW0sIF9fYWRkcmVzcywgX19wdGVwLCBfX2Z1bGwpCVwKLWRvIHsJCQkJCQkJCQlcCi0JcHRlX2NsZWFyKChfX21tKSwgKF9fYWRkcmVzcyksIChfX3B0ZXApKTsJCQlcCi19IHdoaWxlICgwKQorc3RhdGljIGlubGluZSB2b2lkIHB0ZV9jbGVhcl9ub3RfcHJlc2VudF9mdWxsKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJCQkgICAgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCisJCQkJCSAgICAgIHB0ZV90ICpwdGVwLAorCQkJCQkgICAgICBpbnQgZnVsbCkKK3sKKwlwdGVfY2xlYXIobW0sIGFkZHJlc3MsIHB0ZXApOworfQogI2VuZGlmCiAKICNpZm5kZWYgX19IQVZFX0FSQ0hfUFRFUF9DTEVBUl9GTFVTSAotI2RlZmluZSBwdGVwX2NsZWFyX2ZsdXNoKF9fdm1hLCBfX2FkZHJlc3MsIF9fcHRlcCkJCQlcCi0oewkJCQkJCQkJCVwKLQlwdGVfdCBfX3B0ZTsJCQkJCQkJXAotCV9fcHRlID0gcHRlcF9nZXRfYW5kX2NsZWFyKChfX3ZtYSktPnZtX21tLCBfX2FkZHJlc3MsIF9fcHRlcCk7CVwKLQlmbHVzaF90bGJfcGFnZShfX3ZtYSwgX19hZGRyZXNzKTsJCQkJXAotCV9fcHRlOwkJCQkJCQkJXAotfSkKK2V4dGVybiBwdGVfdCBwdGVwX2NsZWFyX2ZsdXNoKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJICAgICAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLAorCQkJICAgICAgcHRlX3QgKnB0ZXApOworI2VuZGlmCisKKyNpZm5kZWYgX19IQVZFX0FSQ0hfUE1EUF9DTEVBUl9GTFVTSAorZXh0ZXJuIHBtZF90IHBtZHBfY2xlYXJfZmx1c2goc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCQkgICAgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCisJCQkgICAgICBwbWRfdCAqcG1kcCk7CiAjZW5kaWYKIAogI2lmbmRlZiBfX0hBVkVfQVJDSF9QVEVQX1NFVF9XUlBST1RFQ1QKQEAgLTk5LDggKzEzNyw0OSBAQAogfQogI2VuZGlmCiAKKyNpZm5kZWYgX19IQVZFX0FSQ0hfUE1EUF9TRVRfV1JQUk9URUNUCisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCitzdGF0aWMgaW5saW5lIHZvaWQgcG1kcF9zZXRfd3Jwcm90ZWN0KHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywgcG1kX3QgKnBtZHApCit7CisJcG1kX3Qgb2xkX3BtZCA9ICpwbWRwOworCXNldF9wbWRfYXQobW0sIGFkZHJlc3MsIHBtZHAsIHBtZF93cnByb3RlY3Qob2xkX3BtZCkpOworfQorI2Vsc2UgLyogQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFICovCitzdGF0aWMgaW5saW5lIHZvaWQgcG1kcF9zZXRfd3Jwcm90ZWN0KHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywgcG1kX3QgKnBtZHApCit7CisJQlVHKCk7Cit9CisjZW5kaWYgLyogQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFICovCisjZW5kaWYKKworI2lmbmRlZiBfX0hBVkVfQVJDSF9QTURQX1NQTElUVElOR19GTFVTSAorZXh0ZXJuIHBtZF90IHBtZHBfc3BsaXR0aW5nX2ZsdXNoKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJCSAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLAorCQkJCSAgcG1kX3QgKnBtZHApOworI2VuZGlmCisKICNpZm5kZWYgX19IQVZFX0FSQ0hfUFRFX1NBTUUKLSNkZWZpbmUgcHRlX3NhbWUoQSxCKQkocHRlX3ZhbChBKSA9PSBwdGVfdmFsKEIpKQorc3RhdGljIGlubGluZSBpbnQgcHRlX3NhbWUocHRlX3QgcHRlX2EsIHB0ZV90IHB0ZV9iKQoreworCXJldHVybiBwdGVfdmFsKHB0ZV9hKSA9PSBwdGVfdmFsKHB0ZV9iKTsKK30KKyNlbmRpZgorCisjaWZuZGVmIF9fSEFWRV9BUkNIX1BNRF9TQU1FCisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCitzdGF0aWMgaW5saW5lIGludCBwbWRfc2FtZShwbWRfdCBwbWRfYSwgcG1kX3QgcG1kX2IpCit7CisJcmV0dXJuIHBtZF92YWwocG1kX2EpID09IHBtZF92YWwocG1kX2IpOworfQorI2Vsc2UgLyogQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFICovCitzdGF0aWMgaW5saW5lIGludCBwbWRfc2FtZShwbWRfdCBwbWRfYSwgcG1kX3QgcG1kX2IpCit7CisJQlVHKCk7CisJcmV0dXJuIDA7Cit9CisjZW5kaWYgLyogQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFICovCiAjZW5kaWYKIAogI2lmbmRlZiBfX0hBVkVfQVJDSF9QQUdFX1RFU1RfRElSVFkKQEAgLTM0OCw2ICs0MjcsMjQgQEAKIAkJCQl1bnNpZ25lZCBsb25nIHNpemUpOwogI2VuZGlmCiAKKyNpZm5kZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCitzdGF0aWMgaW5saW5lIGludCBwbWRfdHJhbnNfaHVnZShwbWRfdCBwbWQpCit7CisJcmV0dXJuIDA7Cit9CitzdGF0aWMgaW5saW5lIGludCBwbWRfdHJhbnNfc3BsaXR0aW5nKHBtZF90IHBtZCkKK3sKKwlyZXR1cm4gMDsKK30KKyNpZm5kZWYgX19IQVZFX0FSQ0hfUE1EX1dSSVRFCitzdGF0aWMgaW5saW5lIGludCBwbWRfd3JpdGUocG1kX3QgcG1kKQoreworCUJVRygpOworCXJldHVybiAwOworfQorI2VuZGlmIC8qIF9fSEFWRV9BUkNIX1BNRF9XUklURSAqLworI2VuZGlmCisKICNlbmRpZiAvKiAhX19BU1NFTUJMWV9fICovCiAKICNlbmRpZiAvKiBfQVNNX0dFTkVSSUNfUEdUQUJMRV9IICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmggYi9pbmNsdWRlL2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmgKaW5kZXggNjg2NDkzMy4uZmU3N2UzMyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hc20tZ2VuZXJpYy92bWxpbnV4Lmxkcy5oCisrKyBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvdm1saW51eC5sZHMuaApAQCAtMTI0LDcgKzEyNCw4IEBACiAjZW5kaWYKIAogI2lmZGVmIENPTkZJR19FVkVOVF9UUkFDSU5HCi0jZGVmaW5lIEZUUkFDRV9FVkVOVFMoKQlWTUxJTlVYX1NZTUJPTChfX3N0YXJ0X2Z0cmFjZV9ldmVudHMpID0gLjsJXAorI2RlZmluZSBGVFJBQ0VfRVZFTlRTKCkJLiA9IEFMSUdOKDgpOwkJCQkJXAorCQkJVk1MSU5VWF9TWU1CT0woX19zdGFydF9mdHJhY2VfZXZlbnRzKSA9IC47CVwKIAkJCSooX2Z0cmFjZV9ldmVudHMpCQkJCVwKIAkJCVZNTElOVVhfU1lNQk9MKF9fc3RvcF9mdHJhY2VfZXZlbnRzKSA9IC47CiAjZWxzZQpAQCAtMTQwLDcgKzE0MSw4IEBACiAjZW5kaWYKIAogI2lmZGVmIENPTkZJR19GVFJBQ0VfU1lTQ0FMTFMKLSNkZWZpbmUgVFJBQ0VfU1lTQ0FMTFMoKSBWTUxJTlVYX1NZTUJPTChfX3N0YXJ0X3N5c2NhbGxzX21ldGFkYXRhKSA9IC47CVwKKyNkZWZpbmUgVFJBQ0VfU1lTQ0FMTFMoKSAuID0gQUxJR04oOCk7CQkJCQlcCisJCQkgVk1MSU5VWF9TWU1CT0woX19zdGFydF9zeXNjYWxsc19tZXRhZGF0YSkgPSAuOwlcCiAJCQkgKihfX3N5c2NhbGxzX21ldGFkYXRhKQkJCQlcCiAJCQkgVk1MSU5VWF9TWU1CT0woX19zdG9wX3N5c2NhbGxzX21ldGFkYXRhKSA9IC47CiAjZWxzZQpAQCAtMTY1LDEwICsxNjcsOCBAQAogCUNQVV9LRUVQKGV4aXQuZGF0YSkJCQkJCQlcCiAJTUVNX0tFRVAoaW5pdC5kYXRhKQkJCQkJCVwKIAlNRU1fS0VFUChleGl0LmRhdGEpCQkJCQkJXAotCS4gPSBBTElHTigzMik7CQkJCQkJCVwKLQlWTUxJTlVYX1NZTUJPTChfX3N0YXJ0X19fdHJhY2Vwb2ludHMpID0gLjsJCQlcCisJU1RSVUNUX0FMSUdOKCk7CQkJCQkJCVwKIAkqKF9fdHJhY2Vwb2ludHMpCQkJCQkJXAotCVZNTElOVVhfU1lNQk9MKF9fc3RvcF9fX3RyYWNlcG9pbnRzKSA9IC47CQkJXAogCS8qIGltcGxlbWVudCBkeW5hbWljIHByaW50ayBkZWJ1ZyAqLwkJCQlcCiAJLiA9IEFMSUdOKDgpOwkJCQkJCQlcCiAJVk1MSU5VWF9TWU1CT0woX19zdGFydF9fX3ZlcmJvc2UpID0gLjsgICAgICAgICAgICAgICAgICAgICAgICAgIFwKQEAgLTE3NiwxMyArMTc2LDcgQEAKIAlWTUxJTlVYX1NZTUJPTChfX3N0b3BfX192ZXJib3NlKSA9IC47CQkJCVwKIAlMSUtFTFlfUFJPRklMRSgpCQkgICAgICAgCQkJCVwKIAlCUkFOQ0hfUFJPRklMRSgpCQkJCQkJXAotCVRSQUNFX1BSSU5US1MoKQkJCQkJCQlcCi0JCQkJCQkJCQlcCi0JU1RSVUNUX0FMSUdOKCk7CQkJCQkJCVwKLQlGVFJBQ0VfRVZFTlRTKCkJCQkJCQkJXAotCQkJCQkJCQkJXAotCVNUUlVDVF9BTElHTigpOwkJCQkJCQlcCi0JVFJBQ0VfU1lTQ0FMTFMoKQorCVRSQUNFX1BSSU5US1MoKQogCiAvKgogICogRGF0YSBzZWN0aW9uIGhlbHBlcnMKQEAgLTIyMCw2ICsyMTQsMTAgQEAKIAkJVk1MSU5VWF9TWU1CT0woX19zdGFydF9yb2RhdGEpID0gLjsJCQlcCiAJCSooLnJvZGF0YSkgKigucm9kYXRhLiopCQkJCQlcCiAJCSooX192ZXJtYWdpYykJCS8qIEtlcm5lbCB2ZXJzaW9uIG1hZ2ljICovCVwKKwkJLiA9IEFMSUdOKDgpOwkJCQkJCVwKKwkJVk1MSU5VWF9TWU1CT0woX19zdGFydF9fX3RyYWNlcG9pbnRzX3B0cnMpID0gLjsJCVwKKwkJKihfX3RyYWNlcG9pbnRzX3B0cnMpCS8qIFRyYWNlcG9pbnRzOiBwb2ludGVyIGFycmF5ICovXAorCQlWTUxJTlVYX1NZTUJPTChfX3N0b3BfX190cmFjZXBvaW50c19wdHJzKSA9IC47CQlcCiAJCSooX19tYXJrZXJzX3N0cmluZ3MpCS8qIE1hcmtlcnM6IHN0cmluZ3MgKi8JCVwKIAkJKihfX3RyYWNlcG9pbnRzX3N0cmluZ3MpLyogVHJhY2Vwb2ludHM6IHN0cmluZ3MgKi8JXAogCX0JCQkJCQkJCVwKQEAgLTM2NCw2ICszNjIsMTMgQEAKIAkJVk1MSU5VWF9TWU1CT0woX19zdGFydF9fX3BhcmFtKSA9IC47CQkJXAogCQkqKF9fcGFyYW0pCQkJCQkJXAogCQlWTUxJTlVYX1NZTUJPTChfX3N0b3BfX19wYXJhbSkgPSAuOwkJCVwKKwl9CQkJCQkJCQlcCisJCQkJCQkJCQlcCisJLyogQnVpbHQtaW4gbW9kdWxlIHZlcnNpb25zLiAqLwkJCQkJXAorCV9fbW9kdmVyIDogQVQoQUREUihfX21vZHZlcikgLSBMT0FEX09GRlNFVCkgewkJCVwKKwkJVk1MSU5VWF9TWU1CT0woX19zdGFydF9fX21vZHZlcikgPSAuOwkJCVwKKwkJKihfX21vZHZlcikJCQkJCQlcCisJCVZNTElOVVhfU1lNQk9MKF9fc3RvcF9fX21vZHZlcikgPSAuOwkJCVwKIAkJLiA9IEFMSUdOKChhbGlnbikpOwkJCQkJXAogCQlWTUxJTlVYX1NZTUJPTChfX2VuZF9yb2RhdGEpID0gLjsJCQlcCiAJfQkJCQkJCQkJXApAQCAtNDc1LDYgKzQ4MCw4IEBACiAJS0VSTkVMX0NUT1JTKCkJCQkJCQkJXAogCSooLmluaXQucm9kYXRhKQkJCQkJCQlcCiAJTUNPVU5UX1JFQygpCQkJCQkJCVwKKwlGVFJBQ0VfRVZFTlRTKCkJCQkJCQkJXAorCVRSQUNFX1NZU0NBTExTKCkJCQkJCQlcCiAJREVWX0RJU0NBUkQoaW5pdC5yb2RhdGEpCQkJCQlcCiAJQ1BVX0RJU0NBUkQoaW5pdC5yb2RhdGEpCQkJCQlcCiAJTUVNX0RJU0NBUkQoaW5pdC5yb2RhdGEpCQkJCQlcCmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1QLmggYi9pbmNsdWRlL2RybS9kcm1QLmgKaW5kZXggYTQ2OTRjNi4uZmUyOWFhZCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vZHJtUC5oCisrKyBiL2luY2x1ZGUvZHJtL2RybVAuaApAQCAtMTM2Nyw3ICsxMzY3LDcgQEAKIGV4dGVybiB1MzIgZHJtX3ZibGFua19jb3VudChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBpbnQgY3J0Yyk7CiBleHRlcm4gdTMyIGRybV92YmxhbmtfY291bnRfYW5kX3RpbWUoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgaW50IGNydGMsCiAJCQkJICAgICBzdHJ1Y3QgdGltZXZhbCAqdmJsYW5rdGltZSk7Ci1leHRlcm4gdm9pZCBkcm1faGFuZGxlX3ZibGFuayhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBpbnQgY3J0Yyk7CitleHRlcm4gYm9vbCBkcm1faGFuZGxlX3ZibGFuayhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBpbnQgY3J0Yyk7CiBleHRlcm4gaW50IGRybV92YmxhbmtfZ2V0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIGludCBjcnRjKTsKIGV4dGVybiB2b2lkIGRybV92YmxhbmtfcHV0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIGludCBjcnRjKTsKIGV4dGVybiB2b2lkIGRybV92Ymxhbmtfb2ZmKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIGludCBjcnRjKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9jcnRjLmggYi9pbmNsdWRlL2RybS9kcm1fY3J0Yy5oCmluZGV4IGFjZDdmYWQuLjgwMWJlNTkgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL2RybV9jcnRjLmgKKysrIGIvaW5jbHVkZS9kcm0vZHJtX2NydGMuaApAQCAtMjc1LDYgKzI3NSw3IEBACiAKIC8qKgogICogZHJtX2NydGNfZnVuY3MgLSBjb250cm9sIENSVENzIGZvciBhIGdpdmVuIGRldmljZQorICogQHJlc2V0OiByZXNldCBDUlRDIGFmdGVyIHN0YXRlIGhhcyBiZWVuIGludmFsaWRhdGUgKGUuZy4gcmVzdW1lKQogICogQGRwbXM6IGNvbnRyb2wgZGlzcGxheSBwb3dlciBsZXZlbHMKICAqIEBzYXZlOiBzYXZlIENSVEMgc3RhdGUKICAqIEByZXNvcmU6IHJlc3RvcmUgQ1JUQyBzdGF0ZQpAQCAtMzAyLDYgKzMwMyw4IEBACiAJdm9pZCAoKnNhdmUpKHN0cnVjdCBkcm1fY3J0YyAqY3J0Yyk7IC8qIHN1c3BlbmQ/ICovCiAJLyogUmVzdG9yZSBDUlRDIHN0YXRlICovCiAJdm9pZCAoKnJlc3RvcmUpKHN0cnVjdCBkcm1fY3J0YyAqY3J0Yyk7IC8qIHJlc3VtZT8gKi8KKwkvKiBSZXNldCBDUlRDIHN0YXRlICovCisJdm9pZCAoKnJlc2V0KShzdHJ1Y3QgZHJtX2NydGMgKmNydGMpOwogCiAJLyogY3Vyc29yIGNvbnRyb2xzICovCiAJaW50ICgqY3Vyc29yX3NldCkoc3RydWN0IGRybV9jcnRjICpjcnRjLCBzdHJ1Y3QgZHJtX2ZpbGUgKmZpbGVfcHJpdiwKQEAgLTM3OSw2ICszODIsNyBAQAogICogQGRwbXM6IHNldCBwb3dlciBzdGF0ZSAoc2VlIGRybV9jcnRjX2Z1bmNzIGFib3ZlKQogICogQHNhdmU6IHNhdmUgY29ubmVjdG9yIHN0YXRlCiAgKiBAcmVzdG9yZTogcmVzdG9yZSBjb25uZWN0b3Igc3RhdGUKKyAqIEByZXNldDogcmVzZXQgY29ubmVjdG9yIGFmdGVyIHN0YXRlIGhhcyBiZWVuIGludmFsaWRhdGUgKGUuZy4gcmVzdW1lKQogICogQG1vZGVfdmFsaWQ6IGlzIHRoaXMgbW9kZSB2YWxpZCBvbiB0aGUgZ2l2ZW4gY29ubmVjdG9yPwogICogQG1vZGVfZml4dXA6IHRyeSB0byBmaXh1cCBwcm9wb3NlZCBtb2RlIGZvciB0aGlzIGNvbm5lY3RvcgogICogQG1vZGVfc2V0OiBzZXQgdGhpcyBtb2RlCkBAIC0zOTYsNiArNDAwLDcgQEAKIAl2b2lkICgqZHBtcykoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwgaW50IG1vZGUpOwogCXZvaWQgKCpzYXZlKShzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKTsKIAl2b2lkICgqcmVzdG9yZSkoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3Rvcik7CisJdm9pZCAoKnJlc2V0KShzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKTsKIAogCS8qIENoZWNrIHRvIHNlZSBpZiBhbnl0aGluZyBpcyBhdHRhY2hlZCB0byB0aGUgY29ubmVjdG9yLgogCSAqIEBmb3JjZSBpcyBzZXQgdG8gZmFsc2Ugd2hpbHN0IHBvbGxpbmcsIHRydWUgd2hlbiBjaGVja2luZyB0aGUKQEAgLTQxMyw2ICs0MTgsNyBAQAogfTsKIAogc3RydWN0IGRybV9lbmNvZGVyX2Z1bmNzIHsKKwl2b2lkICgqcmVzZXQpKHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2Rlcik7CiAJdm9pZCAoKmRlc3Ryb3kpKHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2Rlcik7CiB9OwogCkBAIC02NTYsNiArNjYyLDcgQEAKIAkJCQkJCSAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlKTsKIGV4dGVybiB2b2lkIGRybV9tb2RlX2RlYnVnX3ByaW50bW9kZWxpbmUoc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm1vZGUpOwogZXh0ZXJuIHZvaWQgZHJtX21vZGVfY29uZmlnX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldik7CitleHRlcm4gdm9pZCBkcm1fbW9kZV9jb25maWdfcmVzZXQoc3RydWN0IGRybV9kZXZpY2UgKmRldik7CiBleHRlcm4gdm9pZCBkcm1fbW9kZV9jb25maWdfY2xlYW51cChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KTsKIGV4dGVybiB2b2lkIGRybV9tb2RlX3NldF9uYW1lKHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlKTsKIGV4dGVybiBib29sIGRybV9tb2RlX2VxdWFsKHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlMSwgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm1vZGUyKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9mYl9oZWxwZXIuaCBiL2luY2x1ZGUvZHJtL2RybV9mYl9oZWxwZXIuaAppbmRleCBhYWMyN2JkLi5mMjJlN2ZlIDEwMDY0NAotLS0gYS9pbmNsdWRlL2RybS9kcm1fZmJfaGVscGVyLmgKKysrIGIvaW5jbHVkZS9kcm0vZHJtX2ZiX2hlbHBlci5oCkBAIC0xMjEsNiArMTIxLDkgQEAKIHZvaWQgZHJtX2ZiX2hlbHBlcl9yZXN0b3JlKHZvaWQpOwogdm9pZCBkcm1fZmJfaGVscGVyX2ZpbGxfdmFyKHN0cnVjdCBmYl9pbmZvICppbmZvLCBzdHJ1Y3QgZHJtX2ZiX2hlbHBlciAqZmJfaGVscGVyLAogCQkJICAgIHVpbnQzMl90IGZiX3dpZHRoLCB1aW50MzJfdCBmYl9oZWlnaHQpOwordm9pZCBkcm1fZmJfaGVscGVyX2ZpbGxfZml4KHN0cnVjdCBmYl9pbmZvICppbmZvLCB1aW50MzJfdCBwaXRjaCwKKwkJCSAgICB1aW50MzJfdCBkZXB0aCk7CisKIGludCBkcm1fZmJfaGVscGVyX3NldGNtYXAoc3RydWN0IGZiX2NtYXAgKmNtYXAsIHN0cnVjdCBmYl9pbmZvICppbmZvKTsKIAogYm9vbCBkcm1fZmJfaGVscGVyX2hvdHBsdWdfZXZlbnQoc3RydWN0IGRybV9mYl9oZWxwZXIgKmZiX2hlbHBlcik7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fcGNpaWRzLmggYi9pbmNsdWRlL2RybS9kcm1fcGNpaWRzLmgKaW5kZXggZmUyOWFlMy4uNWZmMTE5NCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9kcm0vZHJtX3BjaWlkcy5oCisrKyBiL2luY2x1ZGUvZHJtL2RybV9wY2lpZHMuaApAQCAtMjgsNyArMjgsNiBAQAogCXsweDEwMDIsIDB4NDE1NiwgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwgMCwgMCwgQ0hJUF9SVjM1MH0sIFwKIAl7MHgxMDAyLCAweDQyMzcsIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsIENISVBfUlMyMDB8UkFERU9OX0lTX0lHUH0sIFwKIAl7MHgxMDAyLCAweDQyNDIsIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsIENISVBfUjIwMH0sIFwKLQl7MHgxMDAyLCAweDQyNDMsIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsIENISVBfUjIwMH0sIFwKIAl7MHgxMDAyLCAweDQzMzYsIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsIENISVBfUlMxMDB8UkFERU9OX0lTX0lHUHxSQURFT05fSVNfTU9CSUxJVFl9LCBcCiAJezB4MTAwMiwgMHg0MzM3LCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCBDSElQX1JTMjAwfFJBREVPTl9JU19JR1B8UkFERU9OX0lTX01PQklMSVRZfSwgXAogCXsweDEwMDIsIDB4NDQzNywgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwgMCwgMCwgQ0hJUF9SUzIwMHxSQURFT05fSVNfSUdQfFJBREVPTl9JU19NT0JJTElUWX0sIFwKZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL3JhZGVvbl9kcm0uaCBiL2luY2x1ZGUvZHJtL3JhZGVvbl9kcm0uaAppbmRleCBlOTVhODZiLi5lNWM2MDdhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2RybS9yYWRlb25fZHJtLmgKKysrIGIvaW5jbHVkZS9kcm0vcmFkZW9uX2RybS5oCkBAIC05MDcsNiArOTA3LDcgQEAKICNkZWZpbmUgUkFERU9OX0lORk9fVElMSU5HX0NPTkZJRwkweDA2CiAjZGVmaW5lIFJBREVPTl9JTkZPX1dBTlRfSFlQRVJaCQkweDA3CiAjZGVmaW5lIFJBREVPTl9JTkZPX1dBTlRfQ01BU0sJCTB4MDggLyogZ2V0IGFjY2VzcyB0byBDTUFTSyBvbiByMzAwICovCisjZGVmaW5lIFJBREVPTl9JTkZPX0NMT0NLX0NSWVNUQUxfRlJFUQkweDA5IC8qIGNsb2NrIGNyeXN0YWwgZnJlcXVlbmN5ICovCiAKIHN0cnVjdCBkcm1fcmFkZW9uX2luZm8gewogCXVpbnQzMl90CQlyZXF1ZXN0OwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9LYnVpbGQgYi9pbmNsdWRlL2xpbnV4L0tidWlsZAppbmRleCAyMjk2ZDhiLi5iMGFkYTZmIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L0tidWlsZAorKysgYi9pbmNsdWRlL2xpbnV4L0tidWlsZApAQCAtMSw1ICsxLDYgQEAKIGhlYWRlci15ICs9IGJ5dGVvcmRlci8KIGhlYWRlci15ICs9IGNhbi8KK2hlYWRlci15ICs9IGNhaWYvCiBoZWFkZXIteSArPSBkdmIvCiBoZWFkZXIteSArPSBoZGxjLwogaGVhZGVyLXkgKz0gaXNkbi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvYWNwaS5oIGIvaW5jbHVkZS9saW51eC9hY3BpLmgKaW5kZXggNjdjOTFiNC4uYTJlOTEwZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9hY3BpLmgKKysrIGIvaW5jbHVkZS9saW51eC9hY3BpLmgKQEAgLTMwNiw5ICszMDYsNiBAQAogCQkJCQkgICAgIHUzMiAqbWFzaywgdTMyIHJlcSk7CiBleHRlcm4gdm9pZCBhY3BpX2Vhcmx5X2luaXQodm9pZCk7CiAKLWludCBhY3BpX29zX21hcF9nZW5lcmljX2FkZHJlc3Moc3RydWN0IGFjcGlfZ2VuZXJpY19hZGRyZXNzICphZGRyKTsKLXZvaWQgYWNwaV9vc191bm1hcF9nZW5lcmljX2FkZHJlc3Moc3RydWN0IGFjcGlfZ2VuZXJpY19hZGRyZXNzICphZGRyKTsKLQogI2Vsc2UJLyogIUNPTkZJR19BQ1BJICovCiAKICNkZWZpbmUgYWNwaV9kaXNhYmxlZCAxCkBAIC0zNTIsNCArMzQ5LDE0IEBACiAJcmV0dXJuIC0xOwogfQogI2VuZGlmCS8qICFDT05GSUdfQUNQSSAqLworCisjaWZkZWYgQ09ORklHX0FDUElfU0xFRVAKK2ludCBzdXNwZW5kX252c19yZWdpc3Rlcih1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIHNpemUpOworI2Vsc2UKK3N0YXRpYyBpbmxpbmUgaW50IHN1c3BlbmRfbnZzX3JlZ2lzdGVyKHVuc2lnbmVkIGxvbmcgYSwgdW5zaWduZWQgbG9uZyBiKQoreworCXJldHVybiAwOworfQorI2VuZGlmCisKICNlbmRpZgkvKl9MSU5VWF9BQ1BJX0gqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9hY3BpX2lvLmggYi9pbmNsdWRlL2xpbnV4L2FjcGlfaW8uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43MTgwMDEzCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS9saW51eC9hY3BpX2lvLmgKQEAgLTAsMCArMSwxNiBAQAorI2lmbmRlZiBfQUNQSV9JT19IXworI2RlZmluZSBfQUNQSV9JT19IXworCisjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxhY3BpL2FjcGkuaD4KKworc3RhdGljIGlubGluZSB2b2lkIF9faW9tZW0gKmFjcGlfb3NfaW9yZW1hcChhY3BpX3BoeXNpY2FsX2FkZHJlc3MgcGh5cywKKwkJCQkJICAgIGFjcGlfc2l6ZSBzaXplKQoreworICAgICAgIHJldHVybiBpb3JlbWFwX2NhY2hlKHBoeXMsIHNpemUpOworfQorCitpbnQgYWNwaV9vc19tYXBfZ2VuZXJpY19hZGRyZXNzKHN0cnVjdCBhY3BpX2dlbmVyaWNfYWRkcmVzcyAqYWRkcik7Cit2b2lkIGFjcGlfb3NfdW5tYXBfZ2VuZXJpY19hZGRyZXNzKHN0cnVjdCBhY3BpX2dlbmVyaWNfYWRkcmVzcyAqYWRkcik7CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9hbWJhL3BsMDh4LmggYi9pbmNsdWRlL2xpbnV4L2FtYmEvcGwwOHguaAppbmRleCA1MjFhMGY4Li4zMTExMzg1IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2FtYmEvcGwwOHguaAorKysgYi9pbmNsdWRlL2xpbnV4L2FtYmEvcGwwOHguaApAQCAtMTIsNyArMTIsNiBAQAogICoKICAqIFBsZWFzZSBjcmVkaXQgQVJNLmNvbQogICogRG9jdW1lbnRhdGlvbjogQVJNIERESSAwMTk2RAotICoKICAqLwogCiAjaWZuZGVmIEFNQkFfUEwwOFhfSApAQCAtMjIsNiArMjEsMTUgQEAKICNpbmNsdWRlIDxsaW51eC9kbWFlbmdpbmUuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KIAorc3RydWN0IHBsMDh4X2xsaTsKK3N0cnVjdCBwbDA4eF9kcml2ZXJfZGF0YTsKKworLyogQml0bWFza3MgZm9yIHNlbGVjdGluZyBBSEIgcG9ydHMgZm9yIERNQSB0cmFuc2ZlcnMgKi8KK2VudW0geworCVBMMDhYX0FIQjEgPSAoMSA8PCAwKSwKKwlQTDA4WF9BSEIyID0gKDEgPDwgMSkKK307CisKIC8qKgogICogc3RydWN0IHBsMDh4X2NoYW5uZWxfZGF0YSAtIGRhdGEgc3RydWN0dXJlIHRvIHBhc3MgaW5mbyBiZXR3ZWVuCiAgKiBwbGF0Zm9ybSBhbmQgUEwwOHggZHJpdmVyIHJlZ2FyZGluZyBjaGFubmVsIGNvbmZpZ3VyYXRpb24KQEAgLTQ2LDggKzU0LDEwIEBACiAgKiBAY2lyY3VsYXJfYnVmZmVyOiB3aGV0aGVyIHRoZSBidWZmZXIgcGFzc2VkIGluIGlzIGNpcmN1bGFyIGFuZAogICogc2hhbGwgc2ltcGx5IGJlIGxvb3BlZCByb3VuZCByb3VuZCAobGlrZSBhIHJlY29yZCBiYWJ5IHJvdW5kCiAgKiByb3VuZCByb3VuZCByb3VuZCkKLSAqIEBzaW5nbGU6IHRoZSBkZXZpY2UgY29ubmVjdGVkIHRvIHRoaXMgY2hhbm5lbCB3aWxsIHJlcXVlc3Qgc2luZ2xlCi0gKiBETUEgdHJhbnNmZXJzLCBub3QgYnVyc3RzLiAoQnVyc3RzIGFyZSBkZWZhdWx0LikKKyAqIEBzaW5nbGU6IHRoZSBkZXZpY2UgY29ubmVjdGVkIHRvIHRoaXMgY2hhbm5lbCB3aWxsIHJlcXVlc3Qgc2luZ2xlIERNQQorICogdHJhbnNmZXJzLCBub3QgYnVyc3RzLiAoQnVyc3RzIGFyZSBkZWZhdWx0LikKKyAqIEBwZXJpcGhfYnVzZXM6IHRoZSBkZXZpY2UgY29ubmVjdGVkIHRvIHRoaXMgY2hhbm5lbCBpcyBhY2Nlc3NpYmxlIHZpYQorICogdGhlc2UgYnVzZXMgKHVzZSBQTDA4WF9BSEIxIHwgUEwwOFhfQUhCMikuCiAgKi8KIHN0cnVjdCBwbDA4eF9jaGFubmVsX2RhdGEgewogCWNoYXIgKmJ1c19pZDsKQEAgLTU1LDEwICs2NSwxMCBAQAogCWludCBtYXhfc2lnbmFsOwogCXUzMiBtdXh2YWw7CiAJdTMyIGNjdGw7Ci0JdTMyIGNjZmc7CiAJZG1hX2FkZHJfdCBhZGRyOwogCWJvb2wgY2lyY3VsYXJfYnVmZmVyOwogCWJvb2wgc2luZ2xlOworCXU4IHBlcmlwaF9idXNlczsKIH07CiAKIC8qKgpAQCAtNjcsMjQgKzc3LDIzIEBACiAgKiBAYWRkcjogY3VycmVudCBhZGRyZXNzCiAgKiBAbWF4d2lkdGg6IHRoZSBtYXhpbXVtIHdpZHRoIG9mIGEgdHJhbnNmZXIgb24gdGhpcyBidXMKICAqIEBidXN3aWR0aDogdGhlIHdpZHRoIG9mIHRoaXMgYnVzIGluIGJ5dGVzOiAxLCAyIG9yIDQKLSAqIEBmaWxsX2J5dGVzOiBieXRlcyByZXF1aXJlZCB0byBmaWxsIHRvIHRoZSBuZXh0IGJ1cyBtZW1vcnkKLSAqIGJvdW5kYXJ5CisgKiBAZmlsbF9ieXRlczogYnl0ZXMgcmVxdWlyZWQgdG8gZmlsbCB0byB0aGUgbmV4dCBidXMgbWVtb3J5IGJvdW5kYXJ5CiAgKi8KIHN0cnVjdCBwbDA4eF9idXNfZGF0YSB7CiAJZG1hX2FkZHJfdCBhZGRyOwogCXU4IG1heHdpZHRoOwogCXU4IGJ1c3dpZHRoOwotCXUzMiBmaWxsX2J5dGVzOworCXNpemVfdCBmaWxsX2J5dGVzOwogfTsKIAogLyoqCiAgKiBzdHJ1Y3QgcGwwOHhfcGh5X2NoYW4gLSBob2xkZXIgZm9yIHRoZSBwaHlzaWNhbCBjaGFubmVscwogICogQGlkOiBwaHlzaWNhbCBpbmRleCB0byB0aGlzIGNoYW5uZWwKICAqIEBsb2NrOiBhIGxvY2sgdG8gdXNlIHdoZW4gYWx0ZXJpbmcgYW4gaW5zdGFuY2Ugb2YgdGhpcyBzdHJ1Y3QKLSAqIEBzaWduYWw6IHRoZSBwaHlzaWNhbCBzaWduYWwgKGFrYSBjaGFubmVsKSBzZXJ2aW5nIHRoaXMKLSAqIHBoeXNpY2FsIGNoYW5uZWwgcmlnaHQgbm93Ci0gKiBAc2VydmluZzogdGhlIHZpcnR1YWwgY2hhbm5lbCBjdXJyZW50bHkgYmVpbmcgc2VydmVkIGJ5IHRoaXMKLSAqIHBoeXNpY2FsIGNoYW5uZWwKKyAqIEBzaWduYWw6IHRoZSBwaHlzaWNhbCBzaWduYWwgKGFrYSBjaGFubmVsKSBzZXJ2aW5nIHRoaXMgcGh5c2ljYWwgY2hhbm5lbAorICogcmlnaHQgbm93CisgKiBAc2VydmluZzogdGhlIHZpcnR1YWwgY2hhbm5lbCBjdXJyZW50bHkgYmVpbmcgc2VydmVkIGJ5IHRoaXMgcGh5c2ljYWwKKyAqIGNoYW5uZWwKICAqLwogc3RydWN0IHBsMDh4X3BoeV9jaGFuIHsKIAl1bnNpZ25lZCBpbnQgaWQ7CkBAIC05MiwxMSArMTAxLDYgQEAKIAlzcGlubG9ja190IGxvY2s7CiAJaW50IHNpZ25hbDsKIAlzdHJ1Y3QgcGwwOHhfZG1hX2NoYW4gKnNlcnZpbmc7Ci0JdTMyIGNzcmM7Ci0JdTMyIGNkc3Q7Ci0JdTMyIGNsbGk7Ci0JdTMyIGNjdGw7Ci0JdTMyIGNjZmc7CiB9OwogCiAvKioKQEAgLTEwOCwyNiArMTEyLDIzIEBACiAJc3RydWN0IGRtYV9hc3luY190eF9kZXNjcmlwdG9yIHR4OwogCXN0cnVjdCBsaXN0X2hlYWQgbm9kZTsKIAllbnVtIGRtYV9kYXRhX2RpcmVjdGlvbglkaXJlY3Rpb247Ci0Jc3RydWN0IHBsMDh4X2J1c19kYXRhIHNyY2J1czsKLQlzdHJ1Y3QgcGwwOHhfYnVzX2RhdGEgZHN0YnVzOwotCWludCBsZW47CisJZG1hX2FkZHJfdCBzcmNfYWRkcjsKKwlkbWFfYWRkcl90IGRzdF9hZGRyOworCXNpemVfdCBsZW47CiAJZG1hX2FkZHJfdCBsbGlzX2J1czsKLQl2b2lkICpsbGlzX3ZhOwotCXN0cnVjdCBwbDA4eF9jaGFubmVsX2RhdGEgKmNkOwotCWJvb2wgYWN0aXZlOworCXN0cnVjdCBwbDA4eF9sbGkgKmxsaXNfdmE7CisJLyogRGVmYXVsdCBjY3RsIHZhbHVlIGZvciBMTElzICovCisJdTMyIGNjdGw7CiAJLyoKIAkgKiBTZXR0aW5ncyB0byBiZSBwdXQgaW50byB0aGUgcGh5c2ljYWwgY2hhbm5lbCB3aGVuIHdlCi0JICogdHJpZ2dlciB0aGlzIHR4ZAorCSAqIHRyaWdnZXIgdGhpcyB0eGQuICBPdGhlciByZWdpc3RlcnMgYXJlIGluIGxsaXNfdmFbMF0uCiAJICovCi0JdTMyIGNzcmM7Ci0JdTMyIGNkc3Q7Ci0JdTMyIGNsbGk7Ci0JdTMyIGNjdGw7CisJdTMyIGNjZmc7CiB9OwogCiAvKioKLSAqIHN0cnVjdCBwbDA4eF9kbWFfY2hhbl9zdGF0ZSAtIGhvbGRzIHRoZSBQTDA4eCBzcGVjaWZpYyB2aXJ0dWFsCi0gKiBjaGFubmVsIHN0YXRlcworICogc3RydWN0IHBsMDh4X2RtYV9jaGFuX3N0YXRlIC0gaG9sZHMgdGhlIFBMMDh4IHNwZWNpZmljIHZpcnR1YWwgY2hhbm5lbAorICogc3RhdGVzCiAgKiBAUEwwOFhfQ0hBTl9JRExFOiB0aGUgY2hhbm5lbCBpcyBpZGxlCiAgKiBAUEwwOFhfQ0hBTl9SVU5OSU5HOiB0aGUgY2hhbm5lbCBoYXMgYWxsb2NhdGVkIGEgcGh5c2ljYWwgdHJhbnNwb3J0CiAgKiBjaGFubmVsIGFuZCBpcyBydW5uaW5nIGEgdHJhbnNmZXIgb24gaXQKQEAgLTE0Nyw2ICsxNDgsOCBAQAogICogc3RydWN0IHBsMDh4X2RtYV9jaGFuIC0gdGhpcyBzdHJ1Y3R1cmUgd3JhcHMgYSBETUEgRU5HSU5FIGNoYW5uZWwKICAqIEBjaGFuOiB3cmFwcHBlZCBhYnN0cmFjdCBjaGFubmVsCiAgKiBAcGh5Y2hhbjogdGhlIHBoeXNpY2FsIGNoYW5uZWwgdXRpbGl6ZWQgYnkgdGhpcyBjaGFubmVsLCBpZiB0aGVyZSBpcyBvbmUKKyAqIEBwaHljaGFuX2hvbGQ6IGlmIG5vbi16ZXJvLCBob2xkIG9uIHRvIHRoZSBwaHlzaWNhbCBjaGFubmVsIGV2ZW4gaWYgd2UKKyAqIGhhdmUgbm8gcGVuZGluZyBlbnRyaWVzCiAgKiBAdGFza2xldDogdGFza2xldCBzY2hlZHVsZWQgYnkgdGhlIElSUSB0byBoYW5kbGUgYWN0dWFsIHdvcmsgZXRjCiAgKiBAbmFtZTogbmFtZSBvZiBjaGFubmVsCiAgKiBAY2Q6IGNoYW5uZWwgcGxhdGZvcm0gZGF0YQpAQCAtMTU0LDUzICsxNTcsNDkgQEAKICAqIEBydW50aW1lX2RpcmVjdGlvbjogY3VycmVudCBkaXJlY3Rpb24gb2YgdGhpcyBjaGFubmVsIGFjY29yZGluZyB0bwogICogcnVudGltZSBjb25maWcKICAqIEBsYzogbGFzdCBjb21wbGV0ZWQgdHJhbnNhY3Rpb24gb24gdGhpcyBjaGFubmVsCi0gKiBAZGVzY19saXN0OiBxdWV1ZWQgdHJhbnNhY3Rpb25zIHBlbmRpbmcgb24gdGhpcyBjaGFubmVsCisgKiBAcGVuZF9saXN0OiBxdWV1ZWQgdHJhbnNhY3Rpb25zIHBlbmRpbmcgb24gdGhpcyBjaGFubmVsCiAgKiBAYXQ6IGFjdGl2ZSB0cmFuc2FjdGlvbiBvbiB0aGlzIGNoYW5uZWwKLSAqIEBsb2NrZmxhZ3M6IHNvbWV0aW1lcyB3ZSBsZXQgYSBsb2NrIGxhc3QgYmV0d2VlbiB0d28gZnVuY3Rpb24gY2FsbHMsCi0gKiBlc3BlY2lhbGx5IHByZXAvc3VibWl0LCBhbmQgdGhlbiB3ZSBuZWVkIHRvIHN0b3JlIHRoZSBJUlEgZmxhZ3MKLSAqIGluIHRoZSBjaGFubmVsIHN0YXRlLCBoZXJlCiAgKiBAbG9jazogYSBsb2NrIGZvciB0aGlzIGNoYW5uZWwgZGF0YQogICogQGhvc3Q6IGEgcG9pbnRlciB0byB0aGUgaG9zdCAoaW50ZXJuYWwgdXNlKQogICogQHN0YXRlOiB3aGV0aGVyIHRoZSBjaGFubmVsIGlzIGlkbGUsIHBhdXNlZCwgcnVubmluZyBldGMKICAqIEBzbGF2ZTogd2hldGhlciB0aGlzIGNoYW5uZWwgaXMgYSBkZXZpY2UgKHNsYXZlKSBvciBmb3IgbWVtY3B5Ci0gKiBAd2FpdGluZzogYSBUWCBkZXNjcmlwdG9yIG9uIHRoaXMgY2hhbm5lbCB3aGljaCBpcyB3YWl0aW5nIGZvcgotICogYSBwaHlzaWNhbCBjaGFubmVsIHRvIGJlY29tZSBhdmFpbGFibGUKKyAqIEB3YWl0aW5nOiBhIFRYIGRlc2NyaXB0b3Igb24gdGhpcyBjaGFubmVsIHdoaWNoIGlzIHdhaXRpbmcgZm9yIGEgcGh5c2ljYWwKKyAqIGNoYW5uZWwgdG8gYmVjb21lIGF2YWlsYWJsZQogICovCiBzdHJ1Y3QgcGwwOHhfZG1hX2NoYW4gewogCXN0cnVjdCBkbWFfY2hhbiBjaGFuOwogCXN0cnVjdCBwbDA4eF9waHlfY2hhbiAqcGh5Y2hhbjsKKwlpbnQgcGh5Y2hhbl9ob2xkOwogCXN0cnVjdCB0YXNrbGV0X3N0cnVjdCB0YXNrbGV0OwogCWNoYXIgKm5hbWU7CiAJc3RydWN0IHBsMDh4X2NoYW5uZWxfZGF0YSAqY2Q7CiAJZG1hX2FkZHJfdCBydW50aW1lX2FkZHI7CiAJZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24JcnVudGltZV9kaXJlY3Rpb247Ci0JYXRvbWljX3QgbGFzdF9pc3N1ZWQ7CiAJZG1hX2Nvb2tpZV90IGxjOwotCXN0cnVjdCBsaXN0X2hlYWQgZGVzY19saXN0OworCXN0cnVjdCBsaXN0X2hlYWQgcGVuZF9saXN0OwogCXN0cnVjdCBwbDA4eF90eGQgKmF0OwotCXVuc2lnbmVkIGxvbmcgbG9ja2ZsYWdzOwogCXNwaW5sb2NrX3QgbG9jazsKLQl2b2lkICpob3N0OworCXN0cnVjdCBwbDA4eF9kcml2ZXJfZGF0YSAqaG9zdDsKIAllbnVtIHBsMDh4X2RtYV9jaGFuX3N0YXRlIHN0YXRlOwogCWJvb2wgc2xhdmU7CiAJc3RydWN0IHBsMDh4X3R4ZCAqd2FpdGluZzsKIH07CiAKIC8qKgotICogc3RydWN0IHBsMDh4X3BsYXRmb3JtX2RhdGEgLSB0aGUgcGxhdGZvcm0gY29uZmlndXJhdGlvbiBmb3IgdGhlCi0gKiBQTDA4eCBQcmltZUNlbGxzLgorICogc3RydWN0IHBsMDh4X3BsYXRmb3JtX2RhdGEgLSB0aGUgcGxhdGZvcm0gY29uZmlndXJhdGlvbiBmb3IgdGhlIFBMMDh4CisgKiBQcmltZUNlbGxzLgogICogQHNsYXZlX2NoYW5uZWxzOiB0aGUgY2hhbm5lbHMgZGVmaW5lZCBmb3IgdGhlIGRpZmZlcmVudCBkZXZpY2VzIG9uIHRoZQogICogcGxhdGZvcm0sIGFsbCBpbmNsdXNpdmUsIGluY2x1ZGluZyBtdWx0aXBsZXhlZCBjaGFubmVscy4gVGhlIGF2YWlsYWJsZQotICogcGh5c2ljYWwgY2hhbm5lbHMgd2lsbCBiZSBtdWx0aXBsZXhlZCBhcm91bmQgdGhlc2Ugc2lnbmFscyBhcyB0aGV5Ci0gKiBhcmUgcmVxdWVzdGVkLCBqdXN0IGVudW1lcmF0ZSBhbGwgcG9zc2libGUgY2hhbm5lbHMuCi0gKiBAZ2V0X3NpZ25hbDogcmVxdWVzdCBhIHBoeXNpY2FsIHNpZ25hbCB0byBiZSB1c2VkIGZvciBhIERNQQotICogdHJhbnNmZXIgaW1tZWRpYXRlbHk6IGlmIHRoZXJlIGlzIHNvbWUgbXVsdGlwbGV4aW5nIG9yIHNpbWlsYXIgYmxvY2tpbmcKLSAqIHRoZSB1c2Ugb2YgdGhlIGNoYW5uZWwgdGhlIHRyYW5zZmVyIGNhbiBiZSBkZW5pZWQgYnkgcmV0dXJuaW5nCi0gKiBsZXNzIHRoYW4gemVybywgZWxzZSBpdCByZXR1cm5zIHRoZSBhbGxvY2F0ZWQgc2lnbmFsIG51bWJlcgorICogcGh5c2ljYWwgY2hhbm5lbHMgd2lsbCBiZSBtdWx0aXBsZXhlZCBhcm91bmQgdGhlc2Ugc2lnbmFscyBhcyB0aGV5IGFyZQorICogcmVxdWVzdGVkLCBqdXN0IGVudW1lcmF0ZSBhbGwgcG9zc2libGUgY2hhbm5lbHMuCisgKiBAZ2V0X3NpZ25hbDogcmVxdWVzdCBhIHBoeXNpY2FsIHNpZ25hbCB0byBiZSB1c2VkIGZvciBhIERNQSB0cmFuc2ZlcgorICogaW1tZWRpYXRlbHk6IGlmIHRoZXJlIGlzIHNvbWUgbXVsdGlwbGV4aW5nIG9yIHNpbWlsYXIgYmxvY2tpbmcgdGhlIHVzZQorICogb2YgdGhlIGNoYW5uZWwgdGhlIHRyYW5zZmVyIGNhbiBiZSBkZW5pZWQgYnkgcmV0dXJuaW5nIGxlc3MgdGhhbiB6ZXJvLAorICogZWxzZSBpdCByZXR1cm5zIHRoZSBhbGxvY2F0ZWQgc2lnbmFsIG51bWJlcgogICogQHB1dF9zaWduYWw6IGluZGljYXRlIHRvIHRoZSBwbGF0Zm9ybSB0aGF0IHRoaXMgcGh5c2ljYWwgc2lnbmFsIGlzIG5vdAogICogcnVubmluZyBhbnkgRE1BIHRyYW5zZmVyIGFuZCBtdWx0aXBsZXhpbmcgY2FuIGJlIHJlY3ljbGVkCi0gKiBAYnVzX2JpdF9sbGk6IEJpdFswXSBvZiB0aGUgYWRkcmVzcyBpbmRpY2F0ZWQgd2hpY2ggQUhCIGJ1cyBtYXN0ZXIgdGhlCi0gKiBMTEkgYWRkcmVzc2VzIGFyZSBvbiAwLzEgTWFzdGVyIDEvMi4KKyAqIEBsbGlfYnVzZXM6IGJ1c2VzIHdoaWNoIExMSXMgY2FuIGJlIGZldGNoZWQgZnJvbTogUEwwOFhfQUhCMSB8IFBMMDhYX0FIQjIKKyAqIEBtZW1fYnVzZXM6IGJ1c2VzIHdoaWNoIG1lbW9yeSBjYW4gYmUgYWNjZXNzZWQgZnJvbTogUEwwOFhfQUhCMSB8IFBMMDhYX0FIQjIKICAqLwogc3RydWN0IHBsMDh4X3BsYXRmb3JtX2RhdGEgewogCXN0cnVjdCBwbDA4eF9jaGFubmVsX2RhdGEgKnNsYXZlX2NoYW5uZWxzOwpAQCAtMjA4LDYgKzIwNyw4IEBACiAJc3RydWN0IHBsMDh4X2NoYW5uZWxfZGF0YSBtZW1jcHlfY2hhbm5lbDsKIAlpbnQgKCpnZXRfc2lnbmFsKShzdHJ1Y3QgcGwwOHhfZG1hX2NoYW4gKik7CiAJdm9pZCAoKnB1dF9zaWduYWwpKHN0cnVjdCBwbDA4eF9kbWFfY2hhbiAqKTsKKwl1OCBsbGlfYnVzZXM7CisJdTggbWVtX2J1c2VzOwogfTsKIAogI2lmZGVmIENPTkZJR19BTUJBX1BMMDhYCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2F1dG9fZnM0LmggYi9pbmNsdWRlL2xpbnV4L2F1dG9fZnM0LmgKaW5kZXggOGI0OWFjNC4uZTAyOTgyZiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9hdXRvX2ZzNC5oCisrKyBiL2luY2x1ZGUvbGludXgvYXV0b19mczQuaApAQCAtMjQsNyArMjQsNyBAQAogI2RlZmluZSBBVVRPRlNfTUlOX1BST1RPX1ZFUlNJT04JMwogI2RlZmluZSBBVVRPRlNfTUFYX1BST1RPX1ZFUlNJT04JNQogCi0jZGVmaW5lIEFVVE9GU19QUk9UT19TVUJWRVJTSU9OCQkxCisjZGVmaW5lIEFVVE9GU19QUk9UT19TVUJWRVJTSU9OCQkyCiAKIC8qIE1hc2sgZm9yIGV4cGlyZSBiZWhhdmlvdXIgKi8KICNkZWZpbmUgQVVUT0ZTX0VYUF9JTU1FRElBVEUJCTEKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvY2FpZi9LYnVpbGQgYi9pbmNsdWRlL2xpbnV4L2NhaWYvS2J1aWxkCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmE5Y2YyNTAKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL2xpbnV4L2NhaWYvS2J1aWxkCkBAIC0wLDAgKzEsMiBAQAoraGVhZGVyLXkgKz0gY2FpZl9zb2NrZXQuaAoraGVhZGVyLXkgKz0gaWZfY2FpZi5oCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2NvbXBhY3Rpb24uaCBiL2luY2x1ZGUvbGludXgvY29tcGFjdGlvbi5oCmluZGV4IDVhYzUxNTUuLmRmYTJlZDQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvY29tcGFjdGlvbi5oCisrKyBiL2luY2x1ZGUvbGludXgvY29tcGFjdGlvbi5oCkBAIC0xMSw2ICsxMSw5IEBACiAvKiBUaGUgZnVsbCB6b25lIHdhcyBjb21wYWN0ZWQgKi8KICNkZWZpbmUgQ09NUEFDVF9DT01QTEVURQkzCiAKKyNkZWZpbmUgQ09NUEFDVF9NT0RFX0RJUkVDVF9SRUNMQUlNCTAKKyNkZWZpbmUgQ09NUEFDVF9NT0RFX0tTV0FQRAkJMQorCiAjaWZkZWYgQ09ORklHX0NPTVBBQ1RJT04KIGV4dGVybiBpbnQgc3lzY3RsX2NvbXBhY3RfbWVtb3J5OwogZXh0ZXJuIGludCBzeXNjdGxfY29tcGFjdGlvbl9oYW5kbGVyKHN0cnVjdCBjdGxfdGFibGUgKnRhYmxlLCBpbnQgd3JpdGUsCkBAIC0yMSw3ICsyNCwxMiBAQAogCiBleHRlcm4gaW50IGZyYWdtZW50YXRpb25faW5kZXgoc3RydWN0IHpvbmUgKnpvbmUsIHVuc2lnbmVkIGludCBvcmRlcik7CiBleHRlcm4gdW5zaWduZWQgbG9uZyB0cnlfdG9fY29tcGFjdF9wYWdlcyhzdHJ1Y3Qgem9uZWxpc3QgKnpvbmVsaXN0LAotCQkJaW50IG9yZGVyLCBnZnBfdCBnZnBfbWFzaywgbm9kZW1hc2tfdCAqbWFzayk7CisJCQlpbnQgb3JkZXIsIGdmcF90IGdmcF9tYXNrLCBub2RlbWFza190ICptYXNrLAorCQkJYm9vbCBzeW5jKTsKK2V4dGVybiB1bnNpZ25lZCBsb25nIGNvbXBhY3Rpb25fc3VpdGFibGUoc3RydWN0IHpvbmUgKnpvbmUsIGludCBvcmRlcik7CitleHRlcm4gdW5zaWduZWQgbG9uZyBjb21wYWN0X3pvbmVfb3JkZXIoc3RydWN0IHpvbmUgKnpvbmUsIGludCBvcmRlciwKKwkJCQkJZ2ZwX3QgZ2ZwX21hc2ssIGJvb2wgc3luYywKKwkJCQkJaW50IGNvbXBhY3RfbW9kZSk7CiAKIC8qIERvIG5vdCBza2lwIGNvbXBhY3Rpb24gbW9yZSB0aGFuIDY0IHRpbWVzICovCiAjZGVmaW5lIENPTVBBQ1RfTUFYX0RFRkVSX1NISUZUIDYKQEAgLTU0LDcgKzYyLDIwIEBACiAKICNlbHNlCiBzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgdHJ5X3RvX2NvbXBhY3RfcGFnZXMoc3RydWN0IHpvbmVsaXN0ICp6b25lbGlzdCwKLQkJCWludCBvcmRlciwgZ2ZwX3QgZ2ZwX21hc2ssIG5vZGVtYXNrX3QgKm5vZGVtYXNrKQorCQkJaW50IG9yZGVyLCBnZnBfdCBnZnBfbWFzaywgbm9kZW1hc2tfdCAqbm9kZW1hc2ssCisJCQlib29sIHN5bmMpCit7CisJcmV0dXJuIENPTVBBQ1RfQ09OVElOVUU7Cit9CisKK3N0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyBjb21wYWN0aW9uX3N1aXRhYmxlKHN0cnVjdCB6b25lICp6b25lLCBpbnQgb3JkZXIpCit7CisJcmV0dXJuIENPTVBBQ1RfU0tJUFBFRDsKK30KKworc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIGNvbXBhY3Rfem9uZV9vcmRlcihzdHJ1Y3Qgem9uZSAqem9uZSwgaW50IG9yZGVyLAorCQkJCQkgICAgICAgZ2ZwX3QgZ2ZwX21hc2ssIGJvb2wgc3luYywKKwkJCQkJICAgICAgIGludCBjb21wYWN0X21vZGUpCiB7CiAJcmV0dXJuIENPTVBBQ1RfQ09OVElOVUU7CiB9CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2NvbnNvbGUuaCBiL2luY2x1ZGUvbGludXgvY29uc29sZS5oCmluZGV4IDk3NzRmZTYuLjc0NTNjZmQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvY29uc29sZS5oCisrKyBiL2luY2x1ZGUvbGludXgvY29uc29sZS5oCkBAIC0xMzksOSArMTM5LDkgQEAKIGV4dGVybiB2b2lkIHJlZ2lzdGVyX2NvbnNvbGUoc3RydWN0IGNvbnNvbGUgKik7CiBleHRlcm4gaW50IHVucmVnaXN0ZXJfY29uc29sZShzdHJ1Y3QgY29uc29sZSAqKTsKIGV4dGVybiBzdHJ1Y3QgY29uc29sZSAqY29uc29sZV9kcml2ZXJzOwotZXh0ZXJuIHZvaWQgYWNxdWlyZV9jb25zb2xlX3NlbSh2b2lkKTsKLWV4dGVybiBpbnQgdHJ5X2FjcXVpcmVfY29uc29sZV9zZW0odm9pZCk7Ci1leHRlcm4gdm9pZCByZWxlYXNlX2NvbnNvbGVfc2VtKHZvaWQpOworZXh0ZXJuIHZvaWQgY29uc29sZV9sb2NrKHZvaWQpOworZXh0ZXJuIGludCBjb25zb2xlX3RyeWxvY2sodm9pZCk7CitleHRlcm4gdm9pZCBjb25zb2xlX3VubG9jayh2b2lkKTsKIGV4dGVybiB2b2lkIGNvbnNvbGVfY29uZGl0aW9uYWxfc2NoZWR1bGUodm9pZCk7CiBleHRlcm4gdm9pZCBjb25zb2xlX3VuYmxhbmsodm9pZCk7CiBleHRlcm4gc3RydWN0IHR0eV9kcml2ZXIgKmNvbnNvbGVfZGV2aWNlKGludCAqKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvY3Blci5oIGIvaW5jbHVkZS9saW51eC9jcGVyLmgKaW5kZXggYmY5NzJmOC4uMzEwNGFhZiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9jcGVyLmgKKysrIGIvaW5jbHVkZS9saW51eC9jcGVyLmgKQEAgLTM5LDEwICszOSwxMiBAQAogICogU2V2ZXJpdHkgZGlmaW5pdGlvbiBmb3IgZXJyb3Jfc2V2ZXJpdHkgaW4gc3RydWN0IGNwZXJfcmVjb3JkX2hlYWRlcgogICogYW5kIHNlY3Rpb25fc2V2ZXJpdHkgaW4gc3RydWN0IGNwZXJfc2VjdGlvbl9kZXNjcmlwdG9yCiAgKi8KLSNkZWZpbmUgQ1BFUl9TRVZfUkVDT1ZFUkFCTEUJCQkweDAKLSNkZWZpbmUgQ1BFUl9TRVZfRkFUQUwJCQkJMHgxCi0jZGVmaW5lIENQRVJfU0VWX0NPUlJFQ1RFRAkJCTB4MgotI2RlZmluZSBDUEVSX1NFVl9JTkZPUk1BVElPTkFMCQkJMHgzCitlbnVtIHsKKwlDUEVSX1NFVl9SRUNPVkVSQUJMRSwKKwlDUEVSX1NFVl9GQVRBTCwKKwlDUEVSX1NFVl9DT1JSRUNURUQsCisJQ1BFUl9TRVZfSU5GT1JNQVRJT05BTCwKK307CiAKIC8qCiAgKiBWYWxpZGF0aW9uIGJpdHMgZGlmaW5pdGlvbiBmb3IgdmFsaWRhdGlvbl9iaXRzIGluIHN0cnVjdApAQCAtMjAxLDYgKzIwMyw0NyBAQAogCVVVSURfTEUoMHgwMzZGODRFMSwgMHg3RjM3LCAweDQyOGMsIDB4QTcsIDB4OUUsIDB4NTcsIDB4NUYsCVwKIAkJMHhERiwgMHhBQSwgMHg4NCwgMHhFQykKIAorI2RlZmluZSBDUEVSX1BST0NfVkFMSURfVFlQRQkJCTB4MDAwMQorI2RlZmluZSBDUEVSX1BST0NfVkFMSURfSVNBCQkJMHgwMDAyCisjZGVmaW5lIENQRVJfUFJPQ19WQUxJRF9FUlJPUl9UWVBFCQkweDAwMDQKKyNkZWZpbmUgQ1BFUl9QUk9DX1ZBTElEX09QRVJBVElPTgkJMHgwMDA4CisjZGVmaW5lIENQRVJfUFJPQ19WQUxJRF9GTEFHUwkJCTB4MDAxMAorI2RlZmluZSBDUEVSX1BST0NfVkFMSURfTEVWRUwJCQkweDAwMjAKKyNkZWZpbmUgQ1BFUl9QUk9DX1ZBTElEX1ZFUlNJT04JCQkweDAwNDAKKyNkZWZpbmUgQ1BFUl9QUk9DX1ZBTElEX0JSQU5EX0lORk8JCTB4MDA4MAorI2RlZmluZSBDUEVSX1BST0NfVkFMSURfSUQJCQkweDAxMDAKKyNkZWZpbmUgQ1BFUl9QUk9DX1ZBTElEX1RBUkdFVF9BRERSRVNTCQkweDAyMDAKKyNkZWZpbmUgQ1BFUl9QUk9DX1ZBTElEX1JFUVVFU1RPUl9JRAkJMHgwNDAwCisjZGVmaW5lIENQRVJfUFJPQ19WQUxJRF9SRVNQT05ERVJfSUQJCTB4MDgwMAorI2RlZmluZSBDUEVSX1BST0NfVkFMSURfSVAJCQkweDEwMDAKKworI2RlZmluZSBDUEVSX01FTV9WQUxJRF9FUlJPUl9TVEFUVVMJCTB4MDAwMQorI2RlZmluZSBDUEVSX01FTV9WQUxJRF9QSFlTSUNBTF9BRERSRVNTCQkweDAwMDIKKyNkZWZpbmUgQ1BFUl9NRU1fVkFMSURfUEhZU0lDQUxfQUREUkVTU19NQVNLCTB4MDAwNAorI2RlZmluZSBDUEVSX01FTV9WQUxJRF9OT0RFCQkJMHgwMDA4CisjZGVmaW5lIENQRVJfTUVNX1ZBTElEX0NBUkQJCQkweDAwMTAKKyNkZWZpbmUgQ1BFUl9NRU1fVkFMSURfTU9EVUxFCQkJMHgwMDIwCisjZGVmaW5lIENQRVJfTUVNX1ZBTElEX0JBTksJCQkweDAwNDAKKyNkZWZpbmUgQ1BFUl9NRU1fVkFMSURfREVWSUNFCQkJMHgwMDgwCisjZGVmaW5lIENQRVJfTUVNX1ZBTElEX1JPVwkJCTB4MDEwMAorI2RlZmluZSBDUEVSX01FTV9WQUxJRF9DT0xVTU4JCQkweDAyMDAKKyNkZWZpbmUgQ1BFUl9NRU1fVkFMSURfQklUX1BPU0lUSU9OCQkweDA0MDAKKyNkZWZpbmUgQ1BFUl9NRU1fVkFMSURfUkVRVUVTVE9SX0lECQkweDA4MDAKKyNkZWZpbmUgQ1BFUl9NRU1fVkFMSURfUkVTUE9OREVSX0lECQkweDEwMDAKKyNkZWZpbmUgQ1BFUl9NRU1fVkFMSURfVEFSR0VUX0lECQkweDIwMDAKKyNkZWZpbmUgQ1BFUl9NRU1fVkFMSURfRVJST1JfVFlQRQkJMHg0MDAwCisKKyNkZWZpbmUgQ1BFUl9QQ0lFX1ZBTElEX1BPUlRfVFlQRQkJMHgwMDAxCisjZGVmaW5lIENQRVJfUENJRV9WQUxJRF9WRVJTSU9OCQkJMHgwMDAyCisjZGVmaW5lIENQRVJfUENJRV9WQUxJRF9DT01NQU5EX1NUQVRVUwkJMHgwMDA0CisjZGVmaW5lIENQRVJfUENJRV9WQUxJRF9ERVZJQ0VfSUQJCTB4MDAwOAorI2RlZmluZSBDUEVSX1BDSUVfVkFMSURfU0VSSUFMX05VTUJFUgkJMHgwMDEwCisjZGVmaW5lIENQRVJfUENJRV9WQUxJRF9CUklER0VfQ09OVFJPTF9TVEFUVVMJMHgwMDIwCisjZGVmaW5lIENQRVJfUENJRV9WQUxJRF9DQVBBQklMSVRZCQkweDAwNDAKKyNkZWZpbmUgQ1BFUl9QQ0lFX1ZBTElEX0FFUl9JTkZPCQkweDAwODAKKworI2RlZmluZSBDUEVSX1BDSUVfU0xPVF9TSElGVAkJCTMKKwogLyoKICAqIEFsbCB0YWJsZXMgYW5kIHN0cnVjdHMgbXVzdCBiZSBieXRlLXBhY2tlZCB0byBtYXRjaCBDUEVSCiAgKiBzcGVjaWZpY2F0aW9uLCBzaW5jZSB0aGUgdGFibGVzIGFyZSBwcm92aWRlZCBieSB0aGUgc3lzdGVtIEJJT1MKQEAgLTMwNiw2ICszNDksNDEgQEAKIAlfX3U4CWVycm9yX3R5cGU7CiB9OwogCitzdHJ1Y3QgY3Blcl9zZWNfcGNpZSB7CisJX191NjQJCXZhbGlkYXRpb25fYml0czsKKwlfX3UzMgkJcG9ydF90eXBlOworCXN0cnVjdCB7CisJCV9fdTgJbWlub3I7CisJCV9fdTgJbWFqb3I7CisJCV9fdTgJcmVzZXJ2ZWRbMl07CisJfQkJdmVyc2lvbjsKKwlfX3UxNgkJY29tbWFuZDsKKwlfX3UxNgkJc3RhdHVzOworCV9fdTMyCQlyZXNlcnZlZDsKKwlzdHJ1Y3QgeworCQlfX3UxNgl2ZW5kb3JfaWQ7CisJCV9fdTE2CWRldmljZV9pZDsKKwkJX191OAljbGFzc19jb2RlWzNdOworCQlfX3U4CWZ1bmN0aW9uOworCQlfX3U4CWRldmljZTsKKwkJX191MTYJc2VnbWVudDsKKwkJX191OAlidXM7CisJCV9fdTgJc2Vjb25kYXJ5X2J1czsKKwkJX191MTYJc2xvdDsKKwkJX191OAlyZXNlcnZlZDsKKwl9CQlkZXZpY2VfaWQ7CisJc3RydWN0IHsKKwkJX191MzIJbG93ZXI7CisJCV9fdTMyCXVwcGVyOworCX0JCXNlcmlhbF9udW1iZXI7CisJc3RydWN0IHsKKwkJX191MTYJc2Vjb25kYXJ5X3N0YXR1czsKKwkJX191MTYJY29udHJvbDsKKwl9CQlicmlkZ2U7CisJX191OAljYXBhYmlsaXR5WzYwXTsKKwlfX3U4CWFlcl9pbmZvWzk2XTsKK307CisKIC8qIFJlc2V0IHRvIGRlZmF1bHQgcGFja2luZyAqLwogI3ByYWdtYSBwYWNrKCkKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9jcHVpZGxlLmggYi9pbmNsdWRlL2xpbnV4L2NwdWlkbGUuaAppbmRleCAxYmU0MTZiLi4zNjcxOWVhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2NwdWlkbGUuaAorKysgYi9pbmNsdWRlL2xpbnV4L2NwdWlkbGUuaApAQCAtNDcsMTMgKzQ3LDcgQEAKIAogLyogSWRsZSBTdGF0ZSBGbGFncyAqLwogI2RlZmluZSBDUFVJRExFX0ZMQUdfVElNRV9WQUxJRAkoMHgwMSkgLyogaXMgcmVzaWRlbmN5IHRpbWUgbWVhc3VyYWJsZT8gKi8KLSNkZWZpbmUgQ1BVSURMRV9GTEFHX0NIRUNLX0JNCSgweDAyKSAvKiBCTSBhY3Rpdml0eSB3aWxsIGV4aXQgc3RhdGUgKi8KLSNkZWZpbmUgQ1BVSURMRV9GTEFHX1BPTEwJKDB4MTApIC8qIG5vIGxhdGVuY3ksIG5vIHNhdmluZ3MgKi8KLSNkZWZpbmUgQ1BVSURMRV9GTEFHX1NIQUxMT1cJKDB4MjApIC8qIGxvdyBsYXRlbmN5LCBtaW5pbWFsIHNhdmluZ3MgKi8KLSNkZWZpbmUgQ1BVSURMRV9GTEFHX0JBTEFOQ0VECSgweDQwKSAvKiBtZWRpdW0gbGF0ZW5jeSwgbW9kZXJhdGUgc2F2aW5ncyAqLwotI2RlZmluZSBDUFVJRExFX0ZMQUdfREVFUAkoMHg4MCkgLyogaGlnaCBsYXRlbmN5LCBsYXJnZSBzYXZpbmdzICovCiAjZGVmaW5lIENQVUlETEVfRkxBR19JR05PUkUJKDB4MTAwKSAvKiBpZ25vcmUgZHVyaW5nIHRoaXMgaWRsZSBwZXJpb2QgKi8KLSNkZWZpbmUgQ1BVSURMRV9GTEFHX1RMQl9GTFVTSEVEICgweDIwMCkgLyogdGxiIHdpbGwgYmUgZmx1c2hlZCAqLwogCiAjZGVmaW5lIENQVUlETEVfRFJJVkVSX0ZMQUdTX01BU0sgKDB4RkZGRjAwMDApCiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZGNhY2hlLmggYi9pbmNsdWRlL2xpbnV4L2RjYWNoZS5oCmluZGV4IDU5ZmNkMjQuLmY5NThjMTkgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZGNhY2hlLmgKKysrIGIvaW5jbHVkZS9saW51eC9kY2FjaGUuaApAQCAtMTY3LDYgKzE2Nyw4IEBACiAJdm9pZCAoKmRfcmVsZWFzZSkoc3RydWN0IGRlbnRyeSAqKTsKIAl2b2lkICgqZF9pcHV0KShzdHJ1Y3QgZGVudHJ5ICosIHN0cnVjdCBpbm9kZSAqKTsKIAljaGFyICooKmRfZG5hbWUpKHN0cnVjdCBkZW50cnkgKiwgY2hhciAqLCBpbnQpOworCXN0cnVjdCB2ZnNtb3VudCAqKCpkX2F1dG9tb3VudCkoc3RydWN0IHBhdGggKik7CisJaW50ICgqZF9tYW5hZ2UpKHN0cnVjdCBkZW50cnkgKiwgYm9vbCwgYm9vbCk7CiB9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKIAogLyoKQEAgLTIwNSwxMyArMjA3LDE4IEBACiAKICNkZWZpbmUgRENBQ0hFX0NBTlRfTU9VTlQJMHgwMTAwCiAjZGVmaW5lIERDQUNIRV9HRU5PQ0lERQkJMHgwMjAwCi0jZGVmaW5lIERDQUNIRV9NT1VOVEVECQkweDA0MDAJLyogaXMgYSBtb3VudHBvaW50ICovCiAKICNkZWZpbmUgRENBQ0hFX09QX0hBU0gJCTB4MTAwMAogI2RlZmluZSBEQ0FDSEVfT1BfQ09NUEFSRQkweDIwMDAKICNkZWZpbmUgRENBQ0hFX09QX1JFVkFMSURBVEUJMHg0MDAwCiAjZGVmaW5lIERDQUNIRV9PUF9ERUxFVEUJMHg4MDAwCiAKKyNkZWZpbmUgRENBQ0hFX01PVU5URUQJCTB4MTAwMDAJLyogaXMgYSBtb3VudHBvaW50ICovCisjZGVmaW5lIERDQUNIRV9ORUVEX0FVVE9NT1VOVAkweDIwMDAwCS8qIGhhbmRsZSBhdXRvbW91bnQgb24gdGhpcyBkaXIgKi8KKyNkZWZpbmUgRENBQ0hFX01BTkFHRV9UUkFOU0lUCTB4NDAwMDAJLyogbWFuYWdlIHRyYW5zaXQgZnJvbSB0aGlzIGRpcmVudCAqLworI2RlZmluZSBEQ0FDSEVfTUFOQUdFRF9ERU5UUlkgXAorCShEQ0FDSEVfTU9VTlRFRHxEQ0FDSEVfTkVFRF9BVVRPTU9VTlR8RENBQ0hFX01BTkFHRV9UUkFOU0lUKQorCiBleHRlcm4gc2VxbG9ja190IHJlbmFtZV9sb2NrOwogCiBzdGF0aWMgaW5saW5lIGludCBkbmFtZV9leHRlcm5hbChzdHJ1Y3QgZGVudHJ5ICpkZW50cnkpCkBAIC0zOTksNyArNDA2LDEyIEBACiAKIGV4dGVybiB2b2lkIGRwdXQoc3RydWN0IGRlbnRyeSAqKTsKIAotc3RhdGljIGlubGluZSBpbnQgZF9tb3VudHBvaW50KHN0cnVjdCBkZW50cnkgKmRlbnRyeSkKK3N0YXRpYyBpbmxpbmUgYm9vbCBkX21hbmFnZWQoc3RydWN0IGRlbnRyeSAqZGVudHJ5KQoreworCXJldHVybiBkZW50cnktPmRfZmxhZ3MgJiBEQ0FDSEVfTUFOQUdFRF9ERU5UUlk7Cit9CisKK3N0YXRpYyBpbmxpbmUgYm9vbCBkX21vdW50cG9pbnQoc3RydWN0IGRlbnRyeSAqZGVudHJ5KQogewogCXJldHVybiBkZW50cnktPmRfZmxhZ3MgJiBEQ0FDSEVfTU9VTlRFRDsKIH0KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZGV2aWNlLW1hcHBlci5oIGIvaW5jbHVkZS9saW51eC9kZXZpY2UtbWFwcGVyLmgKaW5kZXggMjk3MDAyMi4uMjcyNDk2ZCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9kZXZpY2UtbWFwcGVyLmgKKysrIGIvaW5jbHVkZS9saW51eC9kZXZpY2UtbWFwcGVyLmgKQEAgLTE5Myw2ICsxOTMsMTMgQEAKIAljaGFyICplcnJvcjsKIH07CiAKKy8qIEVhY2ggdGFyZ2V0IGNhbiBsaW5rIG9uZSBvZiB0aGVzZSBpbnRvIHRoZSB0YWJsZSAqLworc3RydWN0IGRtX3RhcmdldF9jYWxsYmFja3MgeworCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKKwlpbnQgKCpjb25nZXN0ZWRfZm4pIChzdHJ1Y3QgZG1fdGFyZ2V0X2NhbGxiYWNrcyAqLCBpbnQpOworCXZvaWQgKCp1bnBsdWdfZm4pKHN0cnVjdCBkbV90YXJnZXRfY2FsbGJhY2tzICopOworfTsKKwogaW50IGRtX3JlZ2lzdGVyX3RhcmdldChzdHJ1Y3QgdGFyZ2V0X3R5cGUgKnQpOwogdm9pZCBkbV91bnJlZ2lzdGVyX3RhcmdldChzdHJ1Y3QgdGFyZ2V0X3R5cGUgKnQpOwogCkBAIC0yNjksNiArMjc2LDExIEBACiAJCQlzZWN0b3JfdCBzdGFydCwgc2VjdG9yX3QgbGVuLCBjaGFyICpwYXJhbXMpOwogCiAvKgorICogVGFyZ2V0X2N0ciBzaG91bGQgY2FsbCB0aGlzIGlmIGl0IG5lZWRzIHRvIGFkZCBhbnkgY2FsbGJhY2tzLgorICovCit2b2lkIGRtX3RhYmxlX2FkZF90YXJnZXRfY2FsbGJhY2tzKHN0cnVjdCBkbV90YWJsZSAqdCwgc3RydWN0IGRtX3RhcmdldF9jYWxsYmFja3MgKmNiKTsKKworLyoKICAqIEZpbmFsbHkgY2FsbCB0aGlzIHRvIG1ha2UgdGhlIHRhYmxlIHJlYWR5IGZvciB1c2UuCiAgKi8KIGludCBkbV90YWJsZV9jb21wbGV0ZShzdHJ1Y3QgZG1fdGFibGUgKnQpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kbS1pb2N0bC5oIGIvaW5jbHVkZS9saW51eC9kbS1pb2N0bC5oCmluZGV4IDQ5ZWFiMzYuLjc4YmJmNDcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZG0taW9jdGwuaAorKysgYi9pbmNsdWRlL2xpbnV4L2RtLWlvY3RsLmgKQEAgLTQ0LDcgKzQ0LDcgQEAKICAqIFJlbW92ZSBhIGRldmljZSwgZGVzdHJveSBhbnkgdGFibGVzLgogICoKICAqIERNX0RFVl9SRU5BTUU6Ci0gKiBSZW5hbWUgYSBkZXZpY2UuCisgKiBSZW5hbWUgYSBkZXZpY2Ugb3Igc2V0IGl0cyB1dWlkIGlmIG5vbmUgd2FzIHByZXZpb3VzbHkgc3VwcGxpZWQuCiAgKgogICogRE1fU1VTUEVORDoKICAqIFRoaXMgcGVyZm9ybXMgYm90aCBzdXNwZW5kIGFuZCByZXN1bWUsIGRlcGVuZGluZyB3aGljaCBmbGFnIGlzCkBAIC0yNjcsOSArMjY3LDkgQEAKICNkZWZpbmUgRE1fREVWX1NFVF9HRU9NRVRSWQlfSU9XUihETV9JT0NUTCwgRE1fREVWX1NFVF9HRU9NRVRSWV9DTUQsIHN0cnVjdCBkbV9pb2N0bCkKIAogI2RlZmluZSBETV9WRVJTSU9OX01BSk9SCTQKLSNkZWZpbmUgRE1fVkVSU0lPTl9NSU5PUgkxOAotI2RlZmluZSBETV9WRVJTSU9OX1BBVENITEVWRUwJMAotI2RlZmluZSBETV9WRVJTSU9OX0VYVFJBCSItaW9jdGwgKDIwMTAtMDYtMjkpIgorI2RlZmluZSBETV9WRVJTSU9OX01JTk9SCTE5CisjZGVmaW5lIERNX1ZFUlNJT05fUEFUQ0hMRVZFTAkxCisjZGVmaW5lIERNX1ZFUlNJT05fRVhUUkEJIi1pb2N0bCAoMjAxMS0wMS0wNykiCiAKIC8qIFN0YXR1cyBiaXRzICovCiAjZGVmaW5lIERNX1JFQURPTkxZX0ZMQUcJKDEgPDwgMCkgLyogSW4vT3V0ICovCkBAIC0zMjIsNCArMzIyLDEwIEBACiAgKi8KICNkZWZpbmUgRE1fVUVWRU5UX0dFTkVSQVRFRF9GTEFHCSgxIDw8IDEzKSAvKiBPdXQgKi8KIAorLyoKKyAqIElmIHNldCwgcmVuYW1lIGNoYW5nZXMgdGhlIHV1aWQgbm90IHRoZSBuYW1lLiAgT25seSBwZXJtaXR0ZWQKKyAqIGlmIG5vIHV1aWQgd2FzIHByZXZpb3VzbHkgc3VwcGxpZWQ6IGFuIGV4aXN0aW5nIHV1aWQgY2Fubm90IGJlIGNoYW5nZWQuCisgKi8KKyNkZWZpbmUgRE1fVVVJRF9GTEFHCQkJKDEgPDwgMTQpIC8qIEluICovCisKICNlbmRpZgkJCQkvKiBfTElOVVhfRE1fSU9DVExfSCAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kbS1sb2ctdXNlcnNwYWNlLmggYi9pbmNsdWRlL2xpbnV4L2RtLWxvZy11c2Vyc3BhY2UuaAppbmRleCAwYzNjM2EyLi5lZWFjZTdkIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2RtLWxvZy11c2Vyc3BhY2UuaAorKysgYi9pbmNsdWRlL2xpbnV4L2RtLWxvZy11c2Vyc3BhY2UuaApAQCAtMzcwLDYgKzM3MCwxNiBAQAogI2RlZmluZSBETV9VTE9HX1JFUVVFU1RfVFlQRShyZXF1ZXN0X3R5cGUpIFwKIAkoRE1fVUxPR19SRVFVRVNUX01BU0sgJiAocmVxdWVzdF90eXBlKSkKIAorLyoKKyAqIERNX1VMT0dfUkVRVUVTVF9WRVJTSU9OIGlzIGluY3JlbWVudGVkIHdoZW4gdGhlcmUgaXMgYQorICogY2hhbmdlIHRvIHRoZSB3YXkgaW5mb3JtYXRpb24gaXMgcGFzc2VkIGJldHdlZW4ga2VybmVsCisgKiBhbmQgdXNlcnNwYWNlLiAgVGhpcyBjb3VsZCBiZSBhIHN0cnVjdHVyZSBjaGFuZ2Ugb2YKKyAqIGRtX3Vsb2dfcmVxdWVzdCBvciBhIGNoYW5nZSBpbiB0aGUgd2F5IHJlcXVlc3RzIGFyZQorICogaXNzdWVkL2hhbmRsZWQuICBDaGFuZ2VzIGFyZSBvdXRsaW5lZCBoZXJlOgorICoJdmVyc2lvbiAxOiAgSW5pdGlhbCBpbXBsZW1lbnRhdGlvbgorICovCisjZGVmaW5lIERNX1VMT0dfUkVRVUVTVF9WRVJTSU9OIDEKKwogc3RydWN0IGRtX3Vsb2dfcmVxdWVzdCB7CiAJLyoKIAkgKiBUaGUgbG9jYWwgdW5pcXVlIGlkZW50aWZpZXIgKGx1aWQpIGFuZCB0aGUgdW5pdmVyc2FsbHkgdW5pcXVlCkBAIC0zODMsOCArMzkzLDkgQEAKIAkgKi8KIAl1aW50NjRfdCBsdWlkOwogCWNoYXIgdXVpZFtETV9VVUlEX0xFTl07Ci0JY2hhciBwYWRkaW5nWzddOyAgICAgICAgLyogUGFkZGluZyBiZWNhdXNlIERNX1VVSURfTEVOID0gMTI5ICovCisJY2hhciBwYWRkaW5nWzNdOyAgICAgICAgLyogUGFkZGluZyBiZWNhdXNlIERNX1VVSURfTEVOID0gMTI5ICovCiAKKwl1aW50MzJfdCB2ZXJzaW9uOyAgICAgICAvKiBTZWUgRE1fVUxPR19SRVFVRVNUX1ZFUlNJT04gKi8KIAlpbnQzMl90IGVycm9yOyAgICAgICAgICAvKiBVc2VkIHRvIHJlcG9ydCBiYWNrIHByb2Nlc3NpbmcgZXJyb3JzICovCiAKIAl1aW50MzJfdCBzZXE7ICAgICAgICAgICAvKiBTZXF1ZW5jZSBudW1iZXIgZm9yIHJlcXVlc3QgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZG1hZW5naW5lLmggYi9pbmNsdWRlL2xpbnV4L2RtYWVuZ2luZS5oCmluZGV4IDhjZDAwYWQuLjliZWJkN2YgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZG1hZW5naW5lLmgKKysrIGIvaW5jbHVkZS9saW51eC9kbWFlbmdpbmUuaApAQCAtNTMyLDcgKzUzMiw3IEBACiAJcmV0dXJuIGRtYWVuZ2luZV9kZXZpY2VfY29udHJvbChjaGFuLCBETUFfUkVTVU1FLCAwKTsKIH0KIAotc3RhdGljIGlubGluZSBpbnQgZG1hZW5naW5lX3N1Ym1pdChzdHJ1Y3QgZG1hX2FzeW5jX3R4X2Rlc2NyaXB0b3IgKmRlc2MpCitzdGF0aWMgaW5saW5lIGRtYV9jb29raWVfdCBkbWFlbmdpbmVfc3VibWl0KHN0cnVjdCBkbWFfYXN5bmNfdHhfZGVzY3JpcHRvciAqZGVzYykKIHsKIAlyZXR1cm4gZGVzYy0+dHhfc3VibWl0KGRlc2MpOwogfQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9ldGhlcmRldmljZS5oIGIvaW5jbHVkZS9saW51eC9ldGhlcmRldmljZS5oCmluZGV4IGJlYzhiODIuLmFiNjhmNzggMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZXRoZXJkZXZpY2UuaAorKysgYi9pbmNsdWRlL2xpbnV4L2V0aGVyZGV2aWNlLmgKQEAgLTk5LDYgKzk5LDE3IEBACiB9CiAKIC8qKgorICogaXNfdW5pY2FzdF9ldGhlcl9hZGRyIC0gRGV0ZXJtaW5lIGlmIHRoZSBFdGhlcm5ldCBhZGRyZXNzIGlzIHVuaWNhc3QKKyAqIEBhZGRyOiBQb2ludGVyIHRvIGEgc2l4LWJ5dGUgYXJyYXkgY29udGFpbmluZyB0aGUgRXRoZXJuZXQgYWRkcmVzcworICoKKyAqIFJldHVybiB0cnVlIGlmIHRoZSBhZGRyZXNzIGlzIGEgdW5pY2FzdCBhZGRyZXNzLgorICovCitzdGF0aWMgaW5saW5lIGludCBpc191bmljYXN0X2V0aGVyX2FkZHIoY29uc3QgdTggKmFkZHIpCit7CisJcmV0dXJuICFpc19tdWx0aWNhc3RfZXRoZXJfYWRkcihhZGRyKTsKK30KKworLyoqCiAgKiBpc192YWxpZF9ldGhlcl9hZGRyIC0gRGV0ZXJtaW5lIGlmIHRoZSBnaXZlbiBFdGhlcm5ldCBhZGRyZXNzIGlzIHZhbGlkCiAgKiBAYWRkcjogUG9pbnRlciB0byBhIHNpeC1ieXRlIGFycmF5IGNvbnRhaW5pbmcgdGhlIEV0aGVybmV0IGFkZHJlc3MKICAqCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2ZjbnRsLmggYi9pbmNsdWRlL2xpbnV4L2ZjbnRsLmgKaW5kZXggYWZjMDBhZi4uYTU2MmZhNSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9mY250bC5oCisrKyBiL2luY2x1ZGUvbGludXgvZmNudGwuaApAQCAtNDUsNiArNDUsNyBAQAogI2RlZmluZSBBVF9SRU1PVkVESVIJCTB4MjAwICAgLyogUmVtb3ZlIGRpcmVjdG9yeSBpbnN0ZWFkIG9mCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdW5saW5raW5nIGZpbGUuICAqLwogI2RlZmluZSBBVF9TWU1MSU5LX0ZPTExPVwkweDQwMCAgIC8qIEZvbGxvdyBzeW1ib2xpYyBsaW5rcy4gICovCisjZGVmaW5lIEFUX05PX0FVVE9NT1VOVAkJMHg4MDAJLyogU3VwcHJlc3MgdGVybWluYWwgYXV0b21vdW50IHRyYXZlcnNhbCAqLwogCiAjaWZkZWYgX19LRVJORUxfXwogCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2ZpbGUuaCBiL2luY2x1ZGUvbGludXgvZmlsZS5oCmluZGV4IGIxZTEyOTcuLmU4NWJhZWIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZmlsZS5oCisrKyBiL2luY2x1ZGUvbGludXgvZmlsZS5oCkBAIC0yMyw3ICsyMyw3IEBACiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBmcHV0X2xpZ2h0KHN0cnVjdCBmaWxlICpmaWxlLCBpbnQgZnB1dF9uZWVkZWQpCiB7Ci0JaWYgKHVubGlrZWx5KGZwdXRfbmVlZGVkKSkKKwlpZiAoZnB1dF9uZWVkZWQpCiAJCWZwdXQoZmlsZSk7CiB9CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZnMuaCBiL2luY2x1ZGUvbGludXgvZnMuaAppbmRleCAzOTg0ZjIzLi5iZDMyMTU5IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2ZzLmgKKysrIGIvaW5jbHVkZS9saW51eC9mcy5oCkBAIC0yNDIsNiArMjQyLDcgQEAKICNkZWZpbmUgU19TV0FQRklMRQkyNTYJLyogRG8gbm90IHRydW5jYXRlOiBzd2Fwb24gZ290IGl0cyBibWFwcyAqLwogI2RlZmluZSBTX1BSSVZBVEUJNTEyCS8qIElub2RlIGlzIGZzLWludGVybmFsICovCiAjZGVmaW5lIFNfSU1BCQkxMDI0CS8qIElub2RlIGhhcyBhbiBhc3NvY2lhdGVkIElNQSBzdHJ1Y3QgKi8KKyNkZWZpbmUgU19BVVRPTU9VTlQJMjA0OAkvKiBBdXRvbW91bnQvcmVmZXJyYWwgcXVhc2ktZGlyZWN0b3J5ICovCiAKIC8qCiAgKiBOb3RlIHRoYXQgbm9zdWlkIGV0YyBmbGFncyBhcmUgaW5vZGUtc3BlY2lmaWM6IHNldHRpbmcgc29tZSBmaWxlLXN5c3RlbQpAQCAtMjc3LDYgKzI3OCw3IEBACiAjZGVmaW5lIElTX1NXQVBGSUxFKGlub2RlKQkoKGlub2RlKS0+aV9mbGFncyAmIFNfU1dBUEZJTEUpCiAjZGVmaW5lIElTX1BSSVZBVEUoaW5vZGUpCSgoaW5vZGUpLT5pX2ZsYWdzICYgU19QUklWQVRFKQogI2RlZmluZSBJU19JTUEoaW5vZGUpCQkoKGlub2RlKS0+aV9mbGFncyAmIFNfSU1BKQorI2RlZmluZSBJU19BVVRPTU9VTlQoaW5vZGUpCSgoaW5vZGUpLT5pX2ZsYWdzICYgU19BVVRPTU9VTlQpCiAKIC8qIHRoZSByZWFkLW9ubHkgc3R1ZmYgZG9lc24ndCByZWFsbHkgYmVsb25nIGhlcmUsIGJ1dCBhbnkgb3RoZXIgcGxhY2UgaXMKICAgIHByb2JhYmx5IGFzIGJhZCBhbmQgSSBkb24ndCB3YW50IHRvIGNyZWF0ZSB5ZXQgYW5vdGhlciBpbmNsdWRlIGZpbGUuICovCkBAIC02NjYsNyArNjY4LDcgQEAKIAlpbnQJCQliZF9ob2xkZXJzOwogCWJvb2wJCQliZF93cml0ZV9ob2xkZXI7CiAjaWZkZWYgQ09ORklHX1NZU0ZTCi0Jc3RydWN0IGdlbmRpc2sgKgliZF9ob2xkZXJfZGlzazsJLyogZm9yIHN5c2ZzIHNsYXZlIGxpbmtuZyAqLworCXN0cnVjdCBsaXN0X2hlYWQJYmRfaG9sZGVyX2Rpc2tzOwogI2VuZGlmCiAJc3RydWN0IGJsb2NrX2RldmljZSAqCWJkX2NvbnRhaW5zOwogCXVuc2lnbmVkCQliZF9ibG9ja19zaXplOwpAQCAtMTA2Niw3ICsxMDY4LDYgQEAKIAlpbnQgKCpmbF9ncmFudCkoc3RydWN0IGZpbGVfbG9jayAqLCBzdHJ1Y3QgZmlsZV9sb2NrICosIGludCk7CiAJdm9pZCAoKmZsX3JlbGVhc2VfcHJpdmF0ZSkoc3RydWN0IGZpbGVfbG9jayAqKTsKIAl2b2lkICgqZmxfYnJlYWspKHN0cnVjdCBmaWxlX2xvY2sgKik7Ci0JaW50ICgqZmxfbXlsZWFzZSkoc3RydWN0IGZpbGVfbG9jayAqLCBzdHJ1Y3QgZmlsZV9sb2NrICopOwogCWludCAoKmZsX2NoYW5nZSkoc3RydWN0IGZpbGVfbG9jayAqKiwgaW50KTsKIH07CiAKQEAgLTE0ODIsOCArMTQ4Myw4IEBACiAJdW5zaWduZWQgaW50IGZpX2ZsYWdzOwkJLyogRmxhZ3MgYXMgcGFzc2VkIGZyb20gdXNlciAqLwogCXVuc2lnbmVkIGludCBmaV9leHRlbnRzX21hcHBlZDsJLyogTnVtYmVyIG9mIG1hcHBlZCBleHRlbnRzICovCiAJdW5zaWduZWQgaW50IGZpX2V4dGVudHNfbWF4OwkvKiBTaXplIG9mIGZpZW1hcF9leHRlbnQgYXJyYXkgKi8KLQlzdHJ1Y3QgZmllbWFwX2V4dGVudCAqZmlfZXh0ZW50c19zdGFydDsgLyogU3RhcnQgb2YgZmllbWFwX2V4dGVudAotCQkJCQkJICogYXJyYXkgKi8KKwlzdHJ1Y3QgZmllbWFwX2V4dGVudCBfX3VzZXIgKmZpX2V4dGVudHNfc3RhcnQ7IC8qIFN0YXJ0IG9mCisJCQkJCQkJZmllbWFwX2V4dGVudCBhcnJheSAqLwogfTsKIGludCBmaWVtYXBfZmlsbF9uZXh0X2V4dGVudChzdHJ1Y3QgZmllbWFwX2V4dGVudF9pbmZvICppbmZvLCB1NjQgbG9naWNhbCwKIAkJCSAgICB1NjQgcGh5cywgdTY0IGxlbiwgdTMyIGZsYWdzKTsKQEAgLTE1NTEsNiArMTU1Miw4IEBACiAJc3NpemVfdCAoKnNwbGljZV93cml0ZSkoc3RydWN0IHBpcGVfaW5vZGVfaW5mbyAqLCBzdHJ1Y3QgZmlsZSAqLCBsb2ZmX3QgKiwgc2l6ZV90LCB1bnNpZ25lZCBpbnQpOwogCXNzaXplX3QgKCpzcGxpY2VfcmVhZCkoc3RydWN0IGZpbGUgKiwgbG9mZl90ICosIHN0cnVjdCBwaXBlX2lub2RlX2luZm8gKiwgc2l6ZV90LCB1bnNpZ25lZCBpbnQpOwogCWludCAoKnNldGxlYXNlKShzdHJ1Y3QgZmlsZSAqLCBsb25nLCBzdHJ1Y3QgZmlsZV9sb2NrICoqKTsKKwlsb25nICgqZmFsbG9jYXRlKShzdHJ1Y3QgZmlsZSAqZmlsZSwgaW50IG1vZGUsIGxvZmZfdCBvZmZzZXQsCisJCQkgIGxvZmZfdCBsZW4pOwogfTsKIAogI2RlZmluZSBJUEVSTV9GTEFHX1JDVQkweDAwMDEKQEAgLTE1ODEsOCArMTU4NCw2IEBACiAJc3NpemVfdCAoKmxpc3R4YXR0cikgKHN0cnVjdCBkZW50cnkgKiwgY2hhciAqLCBzaXplX3QpOwogCWludCAoKnJlbW92ZXhhdHRyKSAoc3RydWN0IGRlbnRyeSAqLCBjb25zdCBjaGFyICopOwogCXZvaWQgKCp0cnVuY2F0ZV9yYW5nZSkoc3RydWN0IGlub2RlICosIGxvZmZfdCwgbG9mZl90KTsKLQlsb25nICgqZmFsbG9jYXRlKShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBpbnQgbW9kZSwgbG9mZl90IG9mZnNldCwKLQkJCSAgbG9mZl90IGxlbik7CiAJaW50ICgqZmllbWFwKShzdHJ1Y3QgaW5vZGUgKiwgc3RydWN0IGZpZW1hcF9leHRlbnRfaW5mbyAqLCB1NjQgc3RhcnQsCiAJCSAgICAgIHU2NCBsZW4pOwogfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CkBAIC0yMDU4LDEyICsyMDU5LDE4IEBACiBleHRlcm4gaW50IGJsa2Rldl9wdXQoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVfdCBtb2RlKTsKICNpZmRlZiBDT05GSUdfU1lTRlMKIGV4dGVybiBpbnQgYmRfbGlua19kaXNrX2hvbGRlcihzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBzdHJ1Y3QgZ2VuZGlzayAqZGlzayk7CitleHRlcm4gdm9pZCBiZF91bmxpbmtfZGlza19ob2xkZXIoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwKKwkJCQkgIHN0cnVjdCBnZW5kaXNrICpkaXNrKTsKICNlbHNlCiBzdGF0aWMgaW5saW5lIGludCBiZF9saW5rX2Rpc2tfaG9sZGVyKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsCiAJCQkJICAgICAgc3RydWN0IGdlbmRpc2sgKmRpc2spCiB7CiAJcmV0dXJuIDA7CiB9CitzdGF0aWMgaW5saW5lIHZvaWQgYmRfdW5saW5rX2Rpc2tfaG9sZGVyKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsCisJCQkJCSBzdHJ1Y3QgZ2VuZGlzayAqZGlzaykKK3sKK30KICNlbmRpZgogI2VuZGlmCiAKQEAgLTI1NDgsOSArMjU1NSwxMiBAQAogCQkgICB2b2lkIF9fdXNlciAqYnVmZmVyLCBzaXplX3QgKmxlbnAsIGxvZmZfdCAqcHBvcyk7CiBpbnQgX19pbml0IGdldF9maWxlc3lzdGVtX2xpc3QoY2hhciAqYnVmKTsKIAorI2RlZmluZSBfX0ZNT0RFX0VYRUMJCSgoX19mb3JjZSBpbnQpIEZNT0RFX0VYRUMpCisjZGVmaW5lIF9fRk1PREVfTk9OT1RJRlkJKChfX2ZvcmNlIGludCkgRk1PREVfTk9OT1RJRlkpCisKICNkZWZpbmUgQUNDX01PREUoeCkgKCJcMDA0XDAwMlwwMDZcMDA2IlsoeCkmT19BQ0NNT0RFXSkKICNkZWZpbmUgT1BFTl9GTU9ERShmbGFnKSAoKF9fZm9yY2UgZm1vZGVfdCkoKChmbGFnICsgMSkgJiBPX0FDQ01PREUpIHwgXAotCQkJCQkgICAgKGZsYWcgJiBGTU9ERV9OT05PVElGWSkpKQorCQkJCQkgICAgKGZsYWcgJiBfX0ZNT0RFX05PTk9USUZZKSkpCiAKICNlbmRpZiAvKiBfX0tFUk5FTF9fICovCiAjZW5kaWYgLyogX0xJTlVYX0ZTX0ggKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZ2ZwLmggYi9pbmNsdWRlL2xpbnV4L2dmcC5oCmluZGV4IGY1NGFkZmMuLjBiODRjNjEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZ2ZwLmgKKysrIGIvaW5jbHVkZS9saW51eC9nZnAuaApAQCAtMzQsNiArMzQsNyBAQAogI2Vsc2UKICNkZWZpbmUgX19fR0ZQX05PVFJBQ0sJCTAKICNlbmRpZgorI2RlZmluZSBfX19HRlBfTk9fS1NXQVBECTB4NDAwMDAwdQogCiAvKgogICogR0ZQIGJpdG1hc2tzLi4KQEAgLTgxLDEzICs4MiwxNSBAQAogI2RlZmluZSBfX0dGUF9SRUNMQUlNQUJMRSAoKF9fZm9yY2UgZ2ZwX3QpX19fR0ZQX1JFQ0xBSU1BQkxFKSAvKiBQYWdlIGlzIHJlY2xhaW1hYmxlICovCiAjZGVmaW5lIF9fR0ZQX05PVFJBQ0sJKChfX2ZvcmNlIGdmcF90KV9fX0dGUF9OT1RSQUNLKSAgLyogRG9uJ3QgdHJhY2sgd2l0aCBrbWVtY2hlY2sgKi8KIAorI2RlZmluZSBfX0dGUF9OT19LU1dBUEQJKChfX2ZvcmNlIGdmcF90KV9fX0dGUF9OT19LU1dBUEQpCisKIC8qCiAgKiBUaGlzIG1heSBzZWVtIHJlZHVuZGFudCwgYnV0IGl0J3MgYSB3YXkgb2YgYW5ub3RhdGluZyBmYWxzZSBwb3NpdGl2ZXMgdnMuCiAgKiBhbGxvY2F0aW9ucyB0aGF0IHNpbXBseSBjYW5ub3QgYmUgc3VwcG9ydGVkIChlLmcuIHBhZ2UgdGFibGVzKS4KICAqLwogI2RlZmluZSBfX0dGUF9OT1RSQUNLX0ZBTFNFX1BPU0lUSVZFIChfX0dGUF9OT1RSQUNLKQogCi0jZGVmaW5lIF9fR0ZQX0JJVFNfU0hJRlQgMjIJLyogUm9vbSBmb3IgMjIgX19HRlBfRk9PIGJpdHMgKi8KKyNkZWZpbmUgX19HRlBfQklUU19TSElGVCAyMwkvKiBSb29tIGZvciAyMyBfX0dGUF9GT08gYml0cyAqLwogI2RlZmluZSBfX0dGUF9CSVRTX01BU0sgKChfX2ZvcmNlIGdmcF90KSgoMSA8PCBfX0dGUF9CSVRTX1NISUZUKSAtIDEpKQogCiAvKiBUaGlzIGVxdWFscyAwLCBidXQgdXNlIGNvbnN0YW50cyBpbiBjYXNlIHRoZXkgZXZlciBjaGFuZ2UgKi8KQEAgLTEwNiw2ICsxMDksOSBAQAogCQkJCSBfX0dGUF9IQVJEV0FMTCB8IF9fR0ZQX0hJR0hNRU0gfCBcCiAJCQkJIF9fR0ZQX01PVkFCTEUpCiAjZGVmaW5lIEdGUF9JT0ZTCShfX0dGUF9JTyB8IF9fR0ZQX0ZTKQorI2RlZmluZSBHRlBfVFJBTlNIVUdFCShHRlBfSElHSFVTRVJfTU9WQUJMRSB8IF9fR0ZQX0NPTVAgfCBcCisJCQkgX19HRlBfTk9NRU1BTExPQyB8IF9fR0ZQX05PUkVUUlkgfCBfX0dGUF9OT1dBUk4gfCBcCisJCQkgX19HRlBfTk9fS1NXQVBEKQogCiAjaWZkZWYgQ09ORklHX05VTUEKICNkZWZpbmUgR0ZQX1RISVNOT0RFCShfX0dGUF9USElTTk9ERSB8IF9fR0ZQX05PV0FSTiB8IF9fR0ZQX05PUkVUUlkpCkBAIC0yNDMsNyArMjQ5LDcgQEAKIAkJCQkJICgoMSA8PCBaT05FU19TSElGVCkgLSAxKTsKIAogCWlmIChfX2J1aWx0aW5fY29uc3RhbnRfcChiaXQpKQotCQlNQVlCRV9CVUlMRF9CVUdfT04oKEdGUF9aT05FX0JBRCA+PiBiaXQpICYgMSk7CisJCUJVSUxEX0JVR19PTigoR0ZQX1pPTkVfQkFEID4+IGJpdCkgJiAxKTsKIAllbHNlIHsKICNpZmRlZiBDT05GSUdfREVCVUdfVk0KIAkJQlVHX09OKChHRlBfWk9ORV9CQUQgPj4gYml0KSAmIDEpOwpAQCAtMzI1LDE0ICszMzEsMTcgQEAKIHsKIAlyZXR1cm4gYWxsb2NfcGFnZXNfY3VycmVudChnZnBfbWFzaywgb3JkZXIpOwogfQotZXh0ZXJuIHN0cnVjdCBwYWdlICphbGxvY19wYWdlX3ZtYShnZnBfdCBnZnBfbWFzaywKK2V4dGVybiBzdHJ1Y3QgcGFnZSAqYWxsb2NfcGFnZXNfdm1hKGdmcF90IGdmcF9tYXNrLCBpbnQgb3JkZXIsCiAJCQlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgdW5zaWduZWQgbG9uZyBhZGRyKTsKICNlbHNlCiAjZGVmaW5lIGFsbG9jX3BhZ2VzKGdmcF9tYXNrLCBvcmRlcikgXAogCQlhbGxvY19wYWdlc19ub2RlKG51bWFfbm9kZV9pZCgpLCBnZnBfbWFzaywgb3JkZXIpCi0jZGVmaW5lIGFsbG9jX3BhZ2Vfdm1hKGdmcF9tYXNrLCB2bWEsIGFkZHIpIGFsbG9jX3BhZ2VzKGdmcF9tYXNrLCAwKQorI2RlZmluZSBhbGxvY19wYWdlc192bWEoZ2ZwX21hc2ssIG9yZGVyLCB2bWEsIGFkZHIpCVwKKwlhbGxvY19wYWdlcyhnZnBfbWFzaywgb3JkZXIpCiAjZW5kaWYKICNkZWZpbmUgYWxsb2NfcGFnZShnZnBfbWFzaykgYWxsb2NfcGFnZXMoZ2ZwX21hc2ssIDApCisjZGVmaW5lIGFsbG9jX3BhZ2Vfdm1hKGdmcF9tYXNrLCB2bWEsIGFkZHIpCVwKKwlhbGxvY19wYWdlc192bWEoZ2ZwX21hc2ssIDAsIHZtYSwgYWRkcikKIAogZXh0ZXJuIHVuc2lnbmVkIGxvbmcgX19nZXRfZnJlZV9wYWdlcyhnZnBfdCBnZnBfbWFzaywgdW5zaWduZWQgaW50IG9yZGVyKTsKIGV4dGVybiB1bnNpZ25lZCBsb25nIGdldF96ZXJvZWRfcGFnZShnZnBfdCBnZnBfbWFzayk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2dwaW8uaCBiL2luY2x1ZGUvbGludXgvZ3Bpby5oCmluZGV4IGY3OWQ2N2YuLjMyNzIwYmEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZ3Bpby5oCisrKyBiL2luY2x1ZGUvbGludXgvZ3Bpby5oCkBAIC0zMCwxOCArMzAsMTggQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGlubGluZSBpbnQgX19tdXN0X2NoZWNrIGdwaW9fcmVxdWVzdCh1bnNpZ25lZCBncGlvLCBjb25zdCBjaGFyICpsYWJlbCkKK3N0YXRpYyBpbmxpbmUgaW50IGdwaW9fcmVxdWVzdCh1bnNpZ25lZCBncGlvLCBjb25zdCBjaGFyICpsYWJlbCkKIHsKIAlyZXR1cm4gLUVOT1NZUzsKIH0KIAotc3RhdGljIGlubGluZSBpbnQgX19tdXN0X2NoZWNrIGdwaW9fcmVxdWVzdF9vbmUodW5zaWduZWQgZ3BpbywKK3N0YXRpYyBpbmxpbmUgaW50IGdwaW9fcmVxdWVzdF9vbmUodW5zaWduZWQgZ3BpbywKIAkJCQkJdW5zaWduZWQgbG9uZyBmbGFncywgY29uc3QgY2hhciAqbGFiZWwpCiB7CiAJcmV0dXJuIC1FTk9TWVM7CiB9CiAKLXN0YXRpYyBpbmxpbmUgaW50IF9fbXVzdF9jaGVjayBncGlvX3JlcXVlc3RfYXJyYXkoc3RydWN0IGdwaW8gKmFycmF5LCBzaXplX3QgbnVtKQorc3RhdGljIGlubGluZSBpbnQgZ3Bpb19yZXF1ZXN0X2FycmF5KHN0cnVjdCBncGlvICphcnJheSwgc2l6ZV90IG51bSkKIHsKIAlyZXR1cm4gLUVOT1NZUzsKIH0KQEAgLTYyLDEyICs2MiwxMiBAQAogCVdBUk5fT04oMSk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgaW50IF9fbXVzdF9jaGVjayBncGlvX2RpcmVjdGlvbl9pbnB1dCh1bnNpZ25lZCBncGlvKQorc3RhdGljIGlubGluZSBpbnQgZ3Bpb19kaXJlY3Rpb25faW5wdXQodW5zaWduZWQgZ3BpbykKIHsKIAlyZXR1cm4gLUVOT1NZUzsKIH0KIAotc3RhdGljIGlubGluZSBpbnQgX19tdXN0X2NoZWNrIGdwaW9fZGlyZWN0aW9uX291dHB1dCh1bnNpZ25lZCBncGlvLCBpbnQgdmFsdWUpCitzdGF0aWMgaW5saW5lIGludCBncGlvX2RpcmVjdGlvbl9vdXRwdXQodW5zaWduZWQgZ3BpbywgaW50IHZhbHVlKQogewogCXJldHVybiAtRU5PU1lTOwogfQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9odWdlX21tLmggYi9pbmNsdWRlL2xpbnV4L2h1Z2VfbW0uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44ZTZjOGM0Ci0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS9saW51eC9odWdlX21tLmgKQEAgLTAsMCArMSwxNzkgQEAKKyNpZm5kZWYgX0xJTlVYX0hVR0VfTU1fSAorI2RlZmluZSBfTElOVVhfSFVHRV9NTV9ICisKK2V4dGVybiBpbnQgZG9faHVnZV9wbWRfYW5vbnltb3VzX3BhZ2Uoc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkJICAgICAgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCQkJICAgICAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwbWRfdCAqcG1kLAorCQkJCSAgICAgIHVuc2lnbmVkIGludCBmbGFncyk7CitleHRlcm4gaW50IGNvcHlfaHVnZV9wbWQoc3RydWN0IG1tX3N0cnVjdCAqZHN0X21tLCBzdHJ1Y3QgbW1fc3RydWN0ICpzcmNfbW0sCisJCQkgcG1kX3QgKmRzdF9wbWQsIHBtZF90ICpzcmNfcG1kLCB1bnNpZ25lZCBsb25nIGFkZHIsCisJCQkgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpOworZXh0ZXJuIGludCBkb19odWdlX3BtZF93cF9wYWdlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCSAgICAgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsIHBtZF90ICpwbWQsCisJCQkgICAgICAgcG1kX3Qgb3JpZ19wbWQpOworZXh0ZXJuIHBndGFibGVfdCBnZXRfcG1kX2h1Z2VfcHRlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKK2V4dGVybiBzdHJ1Y3QgcGFnZSAqZm9sbG93X3RyYW5zX2h1Z2VfcG1kKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJCQkgIHVuc2lnbmVkIGxvbmcgYWRkciwKKwkJCQkJICBwbWRfdCAqcG1kLAorCQkJCQkgIHVuc2lnbmVkIGludCBmbGFncyk7CitleHRlcm4gaW50IHphcF9odWdlX3BtZChzdHJ1Y3QgbW11X2dhdGhlciAqdGxiLAorCQkJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCQlwbWRfdCAqcG1kKTsKK2V4dGVybiBpbnQgbWluY29yZV9odWdlX3BtZChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgcG1kX3QgKnBtZCwKKwkJCXVuc2lnbmVkIGxvbmcgYWRkciwgdW5zaWduZWQgbG9uZyBlbmQsCisJCQl1bnNpZ25lZCBjaGFyICp2ZWMpOworZXh0ZXJuIGludCBjaGFuZ2VfaHVnZV9wbWQoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHBtZF90ICpwbWQsCisJCQl1bnNpZ25lZCBsb25nIGFkZHIsIHBncHJvdF90IG5ld3Byb3QpOworCitlbnVtIHRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWcgeworCVRSQU5TUEFSRU5UX0hVR0VQQUdFX0ZMQUcsCisJVFJBTlNQQVJFTlRfSFVHRVBBR0VfUkVRX01BRFZfRkxBRywKKwlUUkFOU1BBUkVOVF9IVUdFUEFHRV9ERUZSQUdfRkxBRywKKwlUUkFOU1BBUkVOVF9IVUdFUEFHRV9ERUZSQUdfUkVRX01BRFZfRkxBRywKKwlUUkFOU1BBUkVOVF9IVUdFUEFHRV9ERUZSQUdfS0hVR0VQQUdFRF9GTEFHLAorI2lmZGVmIENPTkZJR19ERUJVR19WTQorCVRSQU5TUEFSRU5UX0hVR0VQQUdFX0RFQlVHX0NPV19GTEFHLAorI2VuZGlmCit9OworCitlbnVtIHBhZ2VfY2hlY2tfYWRkcmVzc19wbWRfZmxhZyB7CisJUEFHRV9DSEVDS19BRERSRVNTX1BNRF9GTEFHLAorCVBBR0VfQ0hFQ0tfQUREUkVTU19QTURfTk9UU1BMSVRUSU5HX0ZMQUcsCisJUEFHRV9DSEVDS19BRERSRVNTX1BNRF9TUExJVFRJTkdfRkxBRywKK307CitleHRlcm4gcG1kX3QgKnBhZ2VfY2hlY2tfYWRkcmVzc19wbWQoc3RydWN0IHBhZ2UgKnBhZ2UsCisJCQkJICAgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywKKwkJCQkgICAgIGVudW0gcGFnZV9jaGVja19hZGRyZXNzX3BtZF9mbGFnIGZsYWcpOworCisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCisjZGVmaW5lIEhQQUdFX1BNRF9TSElGVCBIUEFHRV9TSElGVAorI2RlZmluZSBIUEFHRV9QTURfTUFTSyBIUEFHRV9NQVNLCisjZGVmaW5lIEhQQUdFX1BNRF9TSVpFIEhQQUdFX1NJWkUKKworI2RlZmluZSB0cmFuc3BhcmVudF9odWdlcGFnZV9lbmFibGVkKF9fdm1hKQkJCQlcCisJKCh0cmFuc3BhcmVudF9odWdlcGFnZV9mbGFncyAmCQkJCQlcCisJICAoMTw8VFJBTlNQQVJFTlRfSFVHRVBBR0VfRkxBRykgfHwJCQkJXAorCSAgKHRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzICYJCQkJCVwKKwkgICAoMTw8VFJBTlNQQVJFTlRfSFVHRVBBR0VfUkVRX01BRFZfRkxBRykgJiYJCQlcCisJICAgKChfX3ZtYSktPnZtX2ZsYWdzICYgVk1fSFVHRVBBR0UpKSkgJiYJCQlcCisJICEoKF9fdm1hKS0+dm1fZmxhZ3MgJiBWTV9OT0hVR0VQQUdFKSkKKyNkZWZpbmUgdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZGVmcmFnKF9fdm1hKQkJCQlcCisJKCh0cmFuc3BhcmVudF9odWdlcGFnZV9mbGFncyAmCQkJCQlcCisJICAoMTw8VFJBTlNQQVJFTlRfSFVHRVBBR0VfREVGUkFHX0ZMQUcpKSB8fAkJCVwKKwkgKHRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzICYJCQkJCVwKKwkgICgxPDxUUkFOU1BBUkVOVF9IVUdFUEFHRV9ERUZSQUdfUkVRX01BRFZfRkxBRykgJiYJCVwKKwkgIChfX3ZtYSktPnZtX2ZsYWdzICYgVk1fSFVHRVBBR0UpKQorI2lmZGVmIENPTkZJR19ERUJVR19WTQorI2RlZmluZSB0cmFuc3BhcmVudF9odWdlcGFnZV9kZWJ1Z19jb3coKQkJCQlcCisJKHRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzICYJCQkJCVwKKwkgKDE8PFRSQU5TUEFSRU5UX0hVR0VQQUdFX0RFQlVHX0NPV19GTEFHKSkKKyNlbHNlIC8qIENPTkZJR19ERUJVR19WTSAqLworI2RlZmluZSB0cmFuc3BhcmVudF9odWdlcGFnZV9kZWJ1Z19jb3coKSAwCisjZW5kaWYgLyogQ09ORklHX0RFQlVHX1ZNICovCisKK2V4dGVybiB1bnNpZ25lZCBsb25nIHRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzOworZXh0ZXJuIGludCBjb3B5X3B0ZV9yYW5nZShzdHJ1Y3QgbW1fc3RydWN0ICpkc3RfbW0sIHN0cnVjdCBtbV9zdHJ1Y3QgKnNyY19tbSwKKwkJCSAgcG1kX3QgKmRzdF9wbWQsIHBtZF90ICpzcmNfcG1kLAorCQkJICBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCSAgdW5zaWduZWQgbG9uZyBhZGRyLCB1bnNpZ25lZCBsb25nIGVuZCk7CitleHRlcm4gaW50IGhhbmRsZV9wdGVfZmF1bHQoc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkgICAgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywKKwkJCSAgICBwdGVfdCAqcHRlLCBwbWRfdCAqcG1kLCB1bnNpZ25lZCBpbnQgZmxhZ3MpOworZXh0ZXJuIGludCBzcGxpdF9odWdlX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpOworZXh0ZXJuIHZvaWQgX19zcGxpdF9odWdlX3BhZ2VfcG1kKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBwbWRfdCAqcG1kKTsKKyNkZWZpbmUgc3BsaXRfaHVnZV9wYWdlX3BtZChfX21tLCBfX3BtZCkJCQkJXAorCWRvIHsJCQkJCQkJCVwKKwkJcG1kX3QgKl9fX19wbWQgPSAoX19wbWQpOwkJCQlcCisJCWlmICh1bmxpa2VseShwbWRfdHJhbnNfaHVnZSgqX19fX3BtZCkpKQkJCVwKKwkJCV9fc3BsaXRfaHVnZV9wYWdlX3BtZChfX21tLCBfX19fcG1kKTsJCVwKKwl9ICB3aGlsZSAoMCkKKyNkZWZpbmUgd2FpdF9zcGxpdF9odWdlX3BhZ2UoX19hbm9uX3ZtYSwgX19wbWQpCQkJCVwKKwlkbyB7CQkJCQkJCQlcCisJCXBtZF90ICpfX19fcG1kID0gKF9fcG1kKTsJCQkJXAorCQlzcGluX3VubG9ja193YWl0KCYoX19hbm9uX3ZtYSktPnJvb3QtPmxvY2spOwkJXAorCQkvKgkJCQkJCQlcCisJCSAqIHNwaW5fdW5sb2NrX3dhaXQoKSBpcyBqdXN0IGEgbG9vcCBpbiBDIGFuZCBzbyB0aGUJXAorCQkgKiBDUFUgY2FuIHJlb3JkZXIgYW55dGhpbmcgYXJvdW5kIGl0LgkJCVwKKwkJICovCQkJCQkJCVwKKwkJc21wX21iKCk7CQkJCQkJXAorCQlCVUdfT04ocG1kX3RyYW5zX3NwbGl0dGluZygqX19fX3BtZCkgfHwJCQlcCisJCSAgICAgICBwbWRfdHJhbnNfaHVnZSgqX19fX3BtZCkpOwkJCVwKKwl9IHdoaWxlICgwKQorI2RlZmluZSBIUEFHRV9QTURfT1JERVIgKEhQQUdFX1BNRF9TSElGVC1QQUdFX1NISUZUKQorI2RlZmluZSBIUEFHRV9QTURfTlIgKDE8PEhQQUdFX1BNRF9PUkRFUikKKyNpZiBIUEFHRV9QTURfT1JERVIgPiBNQVhfT1JERVIKKyNlcnJvciAiaHVnZXBhZ2VzIGNhbid0IGJlIGFsbG9jYXRlZCBieSB0aGUgYnVkZHkgYWxsb2NhdG9yIgorI2VuZGlmCitleHRlcm4gaW50IGh1Z2VwYWdlX21hZHZpc2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCQkgICAgdW5zaWduZWQgbG9uZyAqdm1fZmxhZ3MsIGludCBhZHZpY2UpOworZXh0ZXJuIHZvaWQgX192bWFfYWRqdXN0X3RyYW5zX2h1Z2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCQkJICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsCisJCQkJICAgIHVuc2lnbmVkIGxvbmcgZW5kLAorCQkJCSAgICBsb25nIGFkanVzdF9uZXh0KTsKK3N0YXRpYyBpbmxpbmUgdm9pZCB2bWFfYWRqdXN0X3RyYW5zX2h1Z2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCQkJCSB1bnNpZ25lZCBsb25nIHN0YXJ0LAorCQkJCQkgdW5zaWduZWQgbG9uZyBlbmQsCisJCQkJCSBsb25nIGFkanVzdF9uZXh0KQoreworCWlmICghdm1hLT5hbm9uX3ZtYSB8fCB2bWEtPnZtX29wcyB8fCB2bWEtPnZtX2ZpbGUpCisJCXJldHVybjsKKwlfX3ZtYV9hZGp1c3RfdHJhbnNfaHVnZSh2bWEsIHN0YXJ0LCBlbmQsIGFkanVzdF9uZXh0KTsKK30KK3N0YXRpYyBpbmxpbmUgaW50IGhwYWdlX25yX3BhZ2VzKHN0cnVjdCBwYWdlICpwYWdlKQoreworCWlmICh1bmxpa2VseShQYWdlVHJhbnNIdWdlKHBhZ2UpKSkKKwkJcmV0dXJuIEhQQUdFX1BNRF9OUjsKKwlyZXR1cm4gMTsKK30KK3N0YXRpYyBpbmxpbmUgc3RydWN0IHBhZ2UgKmNvbXBvdW5kX3RyYW5zX2hlYWQoc3RydWN0IHBhZ2UgKnBhZ2UpCit7CisJaWYgKFBhZ2VUYWlsKHBhZ2UpKSB7CisJCXN0cnVjdCBwYWdlICpoZWFkOworCQloZWFkID0gcGFnZS0+Zmlyc3RfcGFnZTsKKwkJc21wX3JtYigpOworCQkvKgorCQkgKiBoZWFkIG1heSBiZSBhIGRhbmdsaW5nIHBvaW50ZXIuCisJCSAqIF9fc3BsaXRfaHVnZV9wYWdlX3JlZmNvdW50IGNsZWFycyBQYWdlVGFpbCBiZWZvcmUKKwkJICogb3ZlcndyaXRpbmcgZmlyc3RfcGFnZSwgc28gaWYgUGFnZVRhaWwgaXMgc3RpbGwKKwkJICogdGhlcmUgaXQgbWVhbnMgdGhlIGhlYWQgcG9pbnRlciBpc24ndCBkYW5nbGluZy4KKwkJICovCisJCWlmIChQYWdlVGFpbChwYWdlKSkKKwkJCXJldHVybiBoZWFkOworCX0KKwlyZXR1cm4gcGFnZTsKK30KKyNlbHNlIC8qIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRSAqLworI2RlZmluZSBIUEFHRV9QTURfU0hJRlQgKHsgQlVHKCk7IDA7IH0pCisjZGVmaW5lIEhQQUdFX1BNRF9NQVNLICh7IEJVRygpOyAwOyB9KQorI2RlZmluZSBIUEFHRV9QTURfU0laRSAoeyBCVUcoKTsgMDsgfSkKKworI2RlZmluZSBocGFnZV9ucl9wYWdlcyh4KSAxCisKKyNkZWZpbmUgdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZW5hYmxlZChfX3ZtYSkgMAorCisjZGVmaW5lIHRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzIDBVTAorc3RhdGljIGlubGluZSBpbnQgc3BsaXRfaHVnZV9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKQoreworCXJldHVybiAwOworfQorI2RlZmluZSBzcGxpdF9odWdlX3BhZ2VfcG1kKF9fbW0sIF9fcG1kKQlcCisJZG8geyB9IHdoaWxlICgwKQorI2RlZmluZSB3YWl0X3NwbGl0X2h1Z2VfcGFnZShfX2Fub25fdm1hLCBfX3BtZCkJXAorCWRvIHsgfSB3aGlsZSAoMCkKKyNkZWZpbmUgY29tcG91bmRfdHJhbnNfaGVhZChwYWdlKSBjb21wb3VuZF9oZWFkKHBhZ2UpCitzdGF0aWMgaW5saW5lIGludCBodWdlcGFnZV9tYWR2aXNlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJCSAgIHVuc2lnbmVkIGxvbmcgKnZtX2ZsYWdzLCBpbnQgYWR2aWNlKQoreworCUJVRygpOworCXJldHVybiAwOworfQorc3RhdGljIGlubGluZSB2b2lkIHZtYV9hZGp1c3RfdHJhbnNfaHVnZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCQkJIHVuc2lnbmVkIGxvbmcgc3RhcnQsCisJCQkJCSB1bnNpZ25lZCBsb25nIGVuZCwKKwkJCQkJIGxvbmcgYWRqdXN0X25leHQpCit7Cit9CisjZW5kaWYgLyogQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFICovCisKKyNlbmRpZiAvKiBfTElOVVhfSFVHRV9NTV9IICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2llZWU4MDIxMS5oIGIvaW5jbHVkZS9saW51eC9pZWVlODAyMTEuaAppbmRleCA2MDQyMjI4Li4yOTQxNjllIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2llZWU4MDIxMS5oCisrKyBiL2luY2x1ZGUvbGludXgvaWVlZTgwMjExLmgKQEAgLTk1OSw3ICs5NTksNyBAQAogLyogYmxvY2stYWNrIHBhcmFtZXRlcnMgKi8KICNkZWZpbmUgSUVFRTgwMjExX0FEREJBX1BBUkFNX1BPTElDWV9NQVNLIDB4MDAwMgogI2RlZmluZSBJRUVFODAyMTFfQUREQkFfUEFSQU1fVElEX01BU0sgMHgwMDNDCi0jZGVmaW5lIElFRUU4MDIxMV9BRERCQV9QQVJBTV9CVUZfU0laRV9NQVNLIDB4RkZBMAorI2RlZmluZSBJRUVFODAyMTFfQUREQkFfUEFSQU1fQlVGX1NJWkVfTUFTSyAweEZGQzAKICNkZWZpbmUgSUVFRTgwMjExX0RFTEJBX1BBUkFNX1RJRF9NQVNLIDB4RjAwMAogI2RlZmluZSBJRUVFODAyMTFfREVMQkFfUEFSQU1fSU5JVElBVE9SX01BU0sgMHgwODAwCiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaW5wdXQvYnUyMTAxMy5oIGIvaW5jbHVkZS9saW51eC9pbnB1dC9idTIxMDEzLmgKaW5kZXggZTQ3MGQzOC4uMDVlMDMyOCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9pbnB1dC9idTIxMDEzLmgKKysrIGIvaW5jbHVkZS9saW51eC9pbnB1dC9idTIxMDEzLmgKQEAgLTEyLDggKzEyLDYgQEAKICAqIEBjc19lbjoJcG9pbnRlciB0byB0aGUgY3MgZW5hYmxlIGZ1bmN0aW9uCiAgKiBAY3NfZGlzOglwb2ludGVyIHRvIHRoZSBjcyBkaXNhYmxlIGZ1bmN0aW9uCiAgKiBAaXJxX3JlYWRfdmFsOiAgICBwb2ludGVyIHRvIHJlYWQgdGhlIHBlbiBpcnEgdmFsdWUgZnVuY3Rpb24KLSAqIEB4X21heF9yZXM6IHhtYXggcmVzb2x1dGlvbgotICogQHlfbWF4X3JlczogeW1heCByZXNvbHV0aW9uCiAgKiBAdG91Y2hfeF9tYXg6IHRvdWNoIHggbWF4CiAgKiBAdG91Y2hfeV9tYXg6IHRvdWNoIHkgbWF4CiAgKiBAY3NfcGluOiBjaGlwIHNlbGVjdCBwaW4KQEAgLTI5LDggKzI3LDYgQEAKIAlpbnQgKCpjc19lbikoaW50IHJlc2V0X3Bpbik7CiAJaW50ICgqY3NfZGlzKShpbnQgcmVzZXRfcGluKTsKIAlpbnQgKCppcnFfcmVhZF92YWwpKHZvaWQpOwotCWludCB4X21heF9yZXM7Ci0JaW50IHlfbWF4X3JlczsKIAlpbnQgdG91Y2hfeF9tYXg7CiAJaW50IHRvdWNoX3lfbWF4OwogCXVuc2lnbmVkIGludCBjc19waW47CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2lwbWkuaCBiL2luY2x1ZGUvbGludXgvaXBtaS5oCmluZGV4IDY1YWFlMzQuLjA0NWYyZjIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvaXBtaS5oCisrKyBiL2luY2x1ZGUvbGludXgvaXBtaS5oCkBAIC00NTQsNiArNDU0LDQ0IEBACiAvKiBWYWxpZGF0ZSB0aGF0IHRoZSBnaXZlbiBJUE1JIGFkZHJlc3MgaXMgdmFsaWQuICovCiBpbnQgaXBtaV92YWxpZGF0ZV9hZGRyKHN0cnVjdCBpcG1pX2FkZHIgKmFkZHIsIGludCBsZW4pOwogCisvKgorICogSG93IGRpZCB0aGUgSVBNSSBkcml2ZXIgZmluZCBvdXQgYWJvdXQgdGhlIGRldmljZT8KKyAqLworZW51bSBpcG1pX2FkZHJfc3JjIHsKKwlTSV9JTlZBTElEID0gMCwgU0lfSE9UTU9ELCBTSV9IQVJEQ09ERUQsIFNJX1NQTUksIFNJX0FDUEksIFNJX1NNQklPUywKKwlTSV9QQ0ksCVNJX0RFVklDRVRSRUUsIFNJX0RFRkFVTFQKK307CisKK3VuaW9uIGlwbWlfc21pX2luZm9fdW5pb24geworCS8qCisJICogdGhlIGFjcGlfaW5mbyBlbGVtZW50IGlzIGRlZmluZWQgZm9yIHRoZSBTSV9BQ1BJCisJICogYWRkcmVzcyB0eXBlCisJICovCisJc3RydWN0IHsKKwkJdm9pZCAqYWNwaV9oYW5kbGU7CisJfSBhY3BpX2luZm87Cit9OworCitzdHJ1Y3QgaXBtaV9zbWlfaW5mbyB7CisJZW51bSBpcG1pX2FkZHJfc3JjIGFkZHJfc3JjOworCisJLyoKKwkgKiBCYXNlIGRldmljZSBmb3IgdGhlIGludGVyZmFjZS4gIERvbid0IGZvcmdldCB0byBwdXQgdGhpcyB3aGVuCisJICogeW91IGFyZSBkb25lLgorCSAqLworCXN0cnVjdCBkZXZpY2UgKmRldjsKKworCS8qCisJICogVGhlIGFkZHJfaW5mbyBwcm92aWRlcyBtb3JlIGRldGFpbGVkIGluZm8gZm9yIHNvbWUgSVBNSQorCSAqIGRldmljZXMsIGRlcGVuZGluZyBvbiB0aGUgYWRkcl9zcmMuICBDdXJyZW50bHkgb25seSBTSV9BQ1BJCisJICogaW5mbyBpcyBwcm92aWRlZC4KKwkgKi8KKwl1bmlvbiBpcG1pX3NtaV9pbmZvX3VuaW9uIGFkZHJfaW5mbzsKK307CisKKy8qIFRoaXMgaXMgdG8gZ2V0IHRoZSBwcml2YXRlIGluZm8gb2YgaXBtaV9zbWlfdCAqLworZXh0ZXJuIGludCBpcG1pX2dldF9zbWlfaW5mbyhpbnQgaWZfbnVtLCBzdHJ1Y3QgaXBtaV9zbWlfaW5mbyAqZGF0YSk7CisKICNlbmRpZiAvKiBfX0tFUk5FTF9fICovCiAKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9pcG1pX3NtaS5oIGIvaW5jbHVkZS9saW51eC9pcG1pX3NtaS5oCmluZGV4IDRiNDgzMTguLjkwNjU5MGEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvaXBtaV9zbWkuaAorKysgYi9pbmNsdWRlL2xpbnV4L2lwbWlfc21pLmgKQEAgLTM5LDYgKzM5LDcgQEAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9pcG1pLmg+CiAKIC8qIFRoaXMgZmlsZXMgZGVzY3JpYmVzIHRoZSBpbnRlcmZhY2UgZm9yIElQTUkgc3lzdGVtIG1hbmFnZW1lbnQgaW50ZXJmYWNlCiAgICBkcml2ZXJzIHRvIGJpbmQgaW50byB0aGUgSVBNSSBtZXNzYWdlIGhhbmRsZXIuICovCkBAIC04Niw2ICs4NywxMyBAQAogCWludCAoKnN0YXJ0X3Byb2Nlc3NpbmcpKHZvaWQgICAgICAgKnNlbmRfaW5mbywKIAkJCQlpcG1pX3NtaV90IG5ld19pbnRmKTsKIAorCS8qCisJICogR2V0IHRoZSBkZXRhaWxlZCBwcml2YXRlIGluZm8gb2YgdGhlIGxvdyBsZXZlbCBpbnRlcmZhY2UgYW5kIHN0b3JlCisJICogaXQgaW50byB0aGUgc3RydWN0dXJlIG9mIGlwbWlfc21pX2RhdGEuIEZvciBleGFtcGxlOiB0aGUKKwkgKiBBQ1BJIGRldmljZSBoYW5kbGUgd2lsbCBiZSByZXR1cm5lZCBmb3IgdGhlIHBucF9hY3BpIElQTUkgZGV2aWNlLgorCSAqLworCWludCAoKmdldF9zbWlfaW5mbykodm9pZCAqc2VuZF9pbmZvLCBzdHJ1Y3QgaXBtaV9zbWlfaW5mbyAqZGF0YSk7CisKIAkvKiBDYWxsZWQgdG8gZW5xdWV1ZSBhbiBTTUkgbWVzc2FnZSB0byBiZSBzZW50LiAgVGhpcwogCSAgIG9wZXJhdGlvbiBpcyBub3QgYWxsb3dlZCB0byBmYWlsLiAgSWYgYW4gZXJyb3Igb2NjdXJzLCBpdAogCSAgIHNob3VsZCByZXBvcnQgYmFjayB0aGUgZXJyb3IgaW4gYSByZWNlaXZlZCBtZXNzYWdlLiAgSXQgbWF5CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2lycS5oIGIvaW5jbHVkZS9saW51eC9pcnEuaAppbmRleCBhYmRlMjUyLi44MGZjYjUzIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2lycS5oCisrKyBiL2luY2x1ZGUvbGludXgvaXJxLmgKQEAgLTc0LDcgKzc0LDggQEAKIAogI2RlZmluZSBJUlFGX01PRElGWV9NQVNLCVwKIAkoSVJRX1RZUEVfU0VOU0VfTUFTSyB8IElSUV9OT1BST0JFIHwgSVJRX05PUkVRVUVTVCB8IFwKLQkgSVJRX05PQVVUT0VOIHwgSVJRX01PVkVfUENOVFhUIHwgSVJRX0xFVkVMKQorCSBJUlFfTk9BVVRPRU4gfCBJUlFfTU9WRV9QQ05UWFQgfCBJUlFfTEVWRUwgfCBJUlFfTk9fQkFMQU5DSU5HIHwgXAorCSBJUlFfUEVSX0NQVSkKIAogI2lmZGVmIENPTkZJR19JUlFfUEVSX0NQVQogIyBkZWZpbmUgQ0hFQ0tfSVJRX1BFUl9DUFUodmFyKSAoKHZhcikgJiBJUlFfUEVSX0NQVSkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaXJxZGVzYy5oIGIvaW5jbHVkZS9saW51eC9pcnFkZXNjLmgKaW5kZXggOTc5YzY4Yy4uYzFhOTViNyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9pcnFkZXNjLmgKKysrIGIvaW5jbHVkZS9saW51eC9pcnFkZXNjLmgKQEAgLTU3LDcgKzU3LDcgQEAKICNlbmRpZgogCiAJc3RydWN0IHRpbWVyX3JhbmRfc3RhdGUgKnRpbWVyX3JhbmRfc3RhdGU7Ci0JdW5zaWduZWQgaW50CQkqa3N0YXRfaXJxczsKKwl1bnNpZ25lZCBpbnQgX19wZXJjcHUJKmtzdGF0X2lycXM7CiAJaXJxX2Zsb3dfaGFuZGxlcl90CWhhbmRsZV9pcnE7CiAJc3RydWN0IGlycWFjdGlvbgkqYWN0aW9uOwkvKiBJUlEgYWN0aW9uIGxpc3QgKi8KIAl1bnNpZ25lZCBpbnQJCXN0YXR1czsJCS8qIElSUSBzdGF0dXMgKi8KQEAgLTEwMSwxMyArMTAxLDYgQEAKICNkZWZpbmUgZ2V0X2lycV9kZXNjX21zaShkZXNjKQkJKChkZXNjKS0+aXJxX2RhdGEubXNpX2Rlc2MpCiAKIC8qCi0gKiBNb25vbGl0aGljIGRvX0lSUSBpbXBsZW1lbnRhdGlvbi4KLSAqLwotI2lmbmRlZiBDT05GSUdfR0VORVJJQ19IQVJESVJRU19OT19fRE9fSVJRCi1leHRlcm4gdW5zaWduZWQgaW50IF9fZG9fSVJRKHVuc2lnbmVkIGludCBpcnEpOwotI2VuZGlmCi0KLS8qCiAgKiBBcmNoaXRlY3R1cmVzIGNhbGwgdGhpcyB0byBsZXQgdGhlIGdlbmVyaWMgSVJRIGxheWVyCiAgKiBoYW5kbGUgYW4gaW50ZXJydXB0LiBJZiB0aGUgZGVzY3JpcHRvciBpcyBhdHRhY2hlZCB0byBhbgogICogaXJxY2hpcC1zdHlsZSBjb250cm9sbGVyIHRoZW4gd2UgY2FsbCB0aGUgLT5oYW5kbGVfaXJxKCkgaGFuZGxlciwKQEAgLTExNSwxNCArMTA4LDcgQEAKICAqLwogc3RhdGljIGlubGluZSB2b2lkIGdlbmVyaWNfaGFuZGxlX2lycV9kZXNjKHVuc2lnbmVkIGludCBpcnEsIHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKIHsKLSNpZmRlZiBDT05GSUdfR0VORVJJQ19IQVJESVJRU19OT19fRE9fSVJRCiAJZGVzYy0+aGFuZGxlX2lycShpcnEsIGRlc2MpOwotI2Vsc2UKLQlpZiAobGlrZWx5KGRlc2MtPmhhbmRsZV9pcnEpKQotCQlkZXNjLT5oYW5kbGVfaXJxKGlycSwgZGVzYyk7Ci0JZWxzZQotCQlfX2RvX0lSUShpcnEpOwotI2VuZGlmCiB9CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBnZW5lcmljX2hhbmRsZV9pcnEodW5zaWduZWQgaW50IGlycSkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgva2VybmVsLmggYi9pbmNsdWRlL2xpbnV4L2tlcm5lbC5oCmluZGV4IDU3ZGFjNzAuLjJmZTZlODQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgva2VybmVsLmgKKysrIGIvaW5jbHVkZS9saW51eC9rZXJuZWwuaApAQCAtMjQzLDYgKzI0Myw4IEBACiBleHRlcm4gdW5zaWduZWQgbG9uZyBnZXRfdGFpbnQodm9pZCk7CiBleHRlcm4gaW50IHJvb3RfbW91bnRmbGFnczsKIAorZXh0ZXJuIGJvb2wgZWFybHlfYm9vdF9pcnFzX2Rpc2FibGVkOworCiAvKiBWYWx1ZXMgdXNlZCBmb3Igc3lzdGVtX3N0YXRlICovCiBleHRlcm4gZW51bSBzeXN0ZW1fc3RhdGVzIHsKIAlTWVNURU1fQk9PVElORywKQEAgLTU3MywxMiArNTc1LDYgQEAKIAljaGFyIF9mWzIwLTIqc2l6ZW9mKGxvbmcpLXNpemVvZihpbnQpXTsJLyogUGFkZGluZzogbGliYzUgdXNlcyB0aGlzLi4gKi8KIH07CiAKLS8qIEZvcmNlIGEgY29tcGlsYXRpb24gZXJyb3IgaWYgY29uZGl0aW9uIGlzIHRydWUgKi8KLSNkZWZpbmUgQlVJTERfQlVHX09OKGNvbmRpdGlvbikgKCh2b2lkKUJVSUxEX0JVR19PTl9aRVJPKGNvbmRpdGlvbikpCi0KLS8qIEZvcmNlIGEgY29tcGlsYXRpb24gZXJyb3IgaWYgY29uZGl0aW9uIGlzIGNvbnN0YW50IGFuZCB0cnVlICovCi0jZGVmaW5lIE1BWUJFX0JVSUxEX0JVR19PTihjb25kKSAoKHZvaWQpc2l6ZW9mKGNoYXJbMSAtIDIgKiAhIShjb25kKV0pKQotCiAvKiBGb3JjZSBhIGNvbXBpbGF0aW9uIGVycm9yIGlmIGEgY29uc3RhbnQgZXhwcmVzc2lvbiBpcyBub3QgYSBwb3dlciBvZiAyICovCiAjZGVmaW5lIEJVSUxEX0JVR19PTl9OT1RfUE9XRVJfT0ZfMihuKQkJCVwKIAlCVUlMRF9CVUdfT04oKG4pID09IDAgfHwgKCgobikgJiAoKG4pIC0gMSkpICE9IDApKQpAQCAtNTkwLDYgKzU4NiwzMiBAQAogI2RlZmluZSBCVUlMRF9CVUdfT05fWkVSTyhlKSAoc2l6ZW9mKHN0cnVjdCB7IGludDotISEoZSk7IH0pKQogI2RlZmluZSBCVUlMRF9CVUdfT05fTlVMTChlKSAoKHZvaWQgKilzaXplb2Yoc3RydWN0IHsgaW50Oi0hIShlKTsgfSkpCiAKKy8qKgorICogQlVJTERfQlVHX09OIC0gYnJlYWsgY29tcGlsZSBpZiBhIGNvbmRpdGlvbiBpcyB0cnVlLgorICogQGNvbmRpdGlvbjogdGhlIGNvbmRpdGlvbiB3aGljaCB0aGUgY29tcGlsZXIgc2hvdWxkIGtub3cgaXMgZmFsc2UuCisgKgorICogSWYgeW91IGhhdmUgc29tZSBjb2RlIHdoaWNoIHJlbGllcyBvbiBjZXJ0YWluIGNvbnN0YW50cyBiZWluZyBlcXVhbCwgb3IKKyAqIG90aGVyIGNvbXBpbGUtdGltZS1ldmFsdWF0ZWQgY29uZGl0aW9uLCB5b3Ugc2hvdWxkIHVzZSBCVUlMRF9CVUdfT04gdG8KKyAqIGRldGVjdCBpZiBzb21lb25lIGNoYW5nZXMgaXQuCisgKgorICogVGhlIGltcGxlbWVudGF0aW9uIHVzZXMgZ2NjJ3MgcmVsdWN0YW5jZSB0byBjcmVhdGUgYSBuZWdhdGl2ZSBhcnJheSwgYnV0CisgKiBnY2MgKGFzIG9mIDQuNCkgb25seSBlbWl0cyB0aGF0IGVycm9yIGZvciBvYnZpb3VzIGNhc2VzIChlZy4gbm90IGFyZ3VtZW50cworICogdG8gaW5saW5lIGZ1bmN0aW9ucykuICBTbyBhcyBhIGZhbGxiYWNrIHdlIHVzZSB0aGUgb3B0aW1pemVyOyBpZiBpdCBjYW4ndAorICogcHJvdmUgdGhlIGNvbmRpdGlvbiBpcyBmYWxzZSwgaXQgd2lsbCBjYXVzZSBhIGxpbmsgZXJyb3Igb24gdGhlIHVuZGVmaW5lZAorICogIl9fYnVpbGRfYnVnX29uX2ZhaWxlZCIuICBUaGlzIGVycm9yIG1lc3NhZ2UgY2FuIGJlIGhhcmRlciB0byB0cmFjayBkb3duCisgKiB0aG91Z2gsIGhlbmNlIHRoZSB0d28gZGlmZmVyZW50IG1ldGhvZHMuCisgKi8KKyNpZm5kZWYgX19PUFRJTUlaRV9fCisjZGVmaW5lIEJVSUxEX0JVR19PTihjb25kaXRpb24pICgodm9pZClzaXplb2YoY2hhclsxIC0gMiohIShjb25kaXRpb24pXSkpCisjZWxzZQorZXh0ZXJuIGludCBfX2J1aWxkX2J1Z19vbl9mYWlsZWQ7CisjZGVmaW5lIEJVSUxEX0JVR19PTihjb25kaXRpb24pCQkJCQlcCisJZG8gewkJCQkJCQlcCisJCSgodm9pZClzaXplb2YoY2hhclsxIC0gMiohIShjb25kaXRpb24pXSkpOwlcCisJCWlmIChjb25kaXRpb24pIF9fYnVpbGRfYnVnX29uX2ZhaWxlZCA9IDE7CVwKKwl9IHdoaWxlKDApCisjZW5kaWYKKwogLyogVHJhcCBwYXN0ZXJzIG9mIF9fRlVOQ1RJT05fXyBhdCBjb21waWxlLXRpbWUgKi8KICNkZWZpbmUgX19GVU5DVElPTl9fIChfX2Z1bmNfXykKIApAQCAtNjAwLDYgKzYyMiwxMyBAQAogI2RlZmluZSBOVU1BX0JVSUxEIDAKICNlbmRpZgogCisvKiBUaGlzIGhlbHBzIHVzIGF2b2lkICNpZmRlZiBDT05GSUdfQ09NUEFDVElPTiAqLworI2lmZGVmIENPTkZJR19DT01QQUNUSU9OCisjZGVmaW5lIENPTVBBQ1RJT05fQlVJTEQgMQorI2Vsc2UKKyNkZWZpbmUgQ09NUEFDVElPTl9CVUlMRCAwCisjZW5kaWYKKwogLyogUmVidWlsZCBldmVyeXRoaW5nIG9uIENPTkZJR19GVFJBQ0VfTUNPVU5UX1JFQ09SRCAqLwogI2lmZGVmIENPTkZJR19GVFJBQ0VfTUNPVU5UX1JFQ09SRAogIyBkZWZpbmUgUkVCVUlMRF9EVUVfVE9fRlRSQUNFX01DT1VOVF9SRUNPUkQKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgva2VybmVsX3N0YXQuaCBiL2luY2x1ZGUvbGludXgva2VybmVsX3N0YXQuaAppbmRleCA0NGU4M2JhLi4wY2NlMmRiIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2tlcm5lbF9zdGF0LmgKKysrIGIvaW5jbHVkZS9saW51eC9rZXJuZWxfc3RhdC5oCkBAIC00NiwxNiArNDYsMTQgQEAKIGV4dGVybiB1bnNpZ25lZCBsb25nIGxvbmcgbnJfY29udGV4dF9zd2l0Y2hlcyh2b2lkKTsKIAogI2lmbmRlZiBDT05GSUdfR0VORVJJQ19IQVJESVJRUwotI2RlZmluZSBrc3RhdF9pcnFzX3RoaXNfY3B1KGlycSkgXAotCSh0aGlzX2NwdV9yZWFkKGtzdGF0LmlycXNbaXJxXSkKIAogc3RydWN0IGlycV9kZXNjOwogCiBzdGF0aWMgaW5saW5lIHZvaWQga3N0YXRfaW5jcl9pcnFzX3RoaXNfY3B1KHVuc2lnbmVkIGludCBpcnEsCiAJCQkJCSAgICBzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MpCiB7Ci0Ja3N0YXRfdGhpc19jcHUuaXJxc1tpcnFdKys7Ci0Ja3N0YXRfdGhpc19jcHUuaXJxc19zdW0rKzsKKwlfX3RoaXNfY3B1X2luYyhrc3RhdC5pcnFzW2lycV0pOworCV9fdGhpc19jcHVfaW5jKGtzdGF0LmlycXNfc3VtKTsKIH0KIAogc3RhdGljIGlubGluZSB1bnNpZ25lZCBpbnQga3N0YXRfaXJxc19jcHUodW5zaWduZWQgaW50IGlycSwgaW50IGNwdSkKQEAgLTY1LDE3ICs2MywxOCBAQAogI2Vsc2UKICNpbmNsdWRlIDxsaW51eC9pcnEuaD4KIGV4dGVybiB1bnNpZ25lZCBpbnQga3N0YXRfaXJxc19jcHUodW5zaWduZWQgaW50IGlycSwgaW50IGNwdSk7Ci0jZGVmaW5lIGtzdGF0X2lycXNfdGhpc19jcHUoREVTQykgXAotCSgoREVTQyktPmtzdGF0X2lycXNbc21wX3Byb2Nlc3Nvcl9pZCgpXSkKLSNkZWZpbmUga3N0YXRfaW5jcl9pcnFzX3RoaXNfY3B1KGlycW5vLCBERVNDKSBkbyB7XAotCSgoREVTQyktPmtzdGF0X2lycXNbc21wX3Byb2Nlc3Nvcl9pZCgpXSsrKTtcCi0Ja3N0YXRfdGhpc19jcHUuaXJxc19zdW0rKzsgfSB3aGlsZSAoMCkKKworI2RlZmluZSBrc3RhdF9pbmNyX2lycXNfdGhpc19jcHUoaXJxbm8sIERFU0MpCQlcCitkbyB7CQkJCQkJCVwKKwlfX3RoaXNfY3B1X2luYygqKERFU0MpLT5rc3RhdF9pcnFzKTsJCVwKKwlfX3RoaXNfY3B1X2luYyhrc3RhdC5pcnFzX3N1bSk7CQkJXAorfSB3aGlsZSAoMCkKIAogI2VuZGlmCiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBrc3RhdF9pbmNyX3NvZnRpcnFzX3RoaXNfY3B1KHVuc2lnbmVkIGludCBpcnEpCiB7Ci0Ja3N0YXRfdGhpc19jcHUuc29mdGlycXNbaXJxXSsrOworCV9fdGhpc19jcHVfaW5jKGtzdGF0LnNvZnRpcnFzW2lycV0pOwogfQogCiBzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGludCBrc3RhdF9zb2Z0aXJxc19jcHUodW5zaWduZWQgaW50IGlycSwgaW50IGNwdSkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgva2h1Z2VwYWdlZC5oIGIvaW5jbHVkZS9saW51eC9raHVnZXBhZ2VkLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNmIzOTRmMAotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvbGludXgva2h1Z2VwYWdlZC5oCkBAIC0wLDAgKzEsNjcgQEAKKyNpZm5kZWYgX0xJTlVYX0tIVUdFUEFHRURfSAorI2RlZmluZSBfTElOVVhfS0hVR0VQQUdFRF9ICisKKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPiAvKiBNTUZfVk1fSFVHRVBBR0UgKi8KKworI2lmZGVmIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRQorZXh0ZXJuIGludCBfX2todWdlcGFnZWRfZW50ZXIoc3RydWN0IG1tX3N0cnVjdCAqbW0pOworZXh0ZXJuIHZvaWQgX19raHVnZXBhZ2VkX2V4aXQoc3RydWN0IG1tX3N0cnVjdCAqbW0pOworZXh0ZXJuIGludCBraHVnZXBhZ2VkX2VudGVyX3ZtYV9tZXJnZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSk7CisKKyNkZWZpbmUga2h1Z2VwYWdlZF9lbmFibGVkKCkJCQkJCSAgICAgICBcCisJKHRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzICYJCQkJICAgICAgIFwKKwkgKCgxPDxUUkFOU1BBUkVOVF9IVUdFUEFHRV9GTEFHKSB8CQkgICAgICAgXAorCSAgKDE8PFRSQU5TUEFSRU5UX0hVR0VQQUdFX1JFUV9NQURWX0ZMQUcpKSkKKyNkZWZpbmUga2h1Z2VwYWdlZF9hbHdheXMoKQkJCQlcCisJKHRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzICYJCQlcCisJICgxPDxUUkFOU1BBUkVOVF9IVUdFUEFHRV9GTEFHKSkKKyNkZWZpbmUga2h1Z2VwYWdlZF9yZXFfbWFkdigpCQkJCQlcCisJKHRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzICYJCQkJXAorCSAoMTw8VFJBTlNQQVJFTlRfSFVHRVBBR0VfUkVRX01BRFZfRkxBRykpCisjZGVmaW5lIGtodWdlcGFnZWRfZGVmcmFnKCkJCQkJCVwKKwkodHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZ3MgJgkJCQlcCisJICgxPDxUUkFOU1BBUkVOVF9IVUdFUEFHRV9ERUZSQUdfS0hVR0VQQUdFRF9GTEFHKSkKKworc3RhdGljIGlubGluZSBpbnQga2h1Z2VwYWdlZF9mb3JrKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBzdHJ1Y3QgbW1fc3RydWN0ICpvbGRtbSkKK3sKKwlpZiAodGVzdF9iaXQoTU1GX1ZNX0hVR0VQQUdFLCAmb2xkbW0tPmZsYWdzKSkKKwkJcmV0dXJuIF9fa2h1Z2VwYWdlZF9lbnRlcihtbSk7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBraHVnZXBhZ2VkX2V4aXQoc3RydWN0IG1tX3N0cnVjdCAqbW0pCit7CisJaWYgKHRlc3RfYml0KE1NRl9WTV9IVUdFUEFHRSwgJm1tLT5mbGFncykpCisJCV9fa2h1Z2VwYWdlZF9leGl0KG1tKTsKK30KKworc3RhdGljIGlubGluZSBpbnQga2h1Z2VwYWdlZF9lbnRlcihzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlpZiAoIXRlc3RfYml0KE1NRl9WTV9IVUdFUEFHRSwgJnZtYS0+dm1fbW0tPmZsYWdzKSkKKwkJaWYgKChraHVnZXBhZ2VkX2Fsd2F5cygpIHx8CisJCSAgICAgKGtodWdlcGFnZWRfcmVxX21hZHYoKSAmJgorCQkgICAgICB2bWEtPnZtX2ZsYWdzICYgVk1fSFVHRVBBR0UpKSAmJgorCQkgICAgISh2bWEtPnZtX2ZsYWdzICYgVk1fTk9IVUdFUEFHRSkpCisJCQlpZiAoX19raHVnZXBhZ2VkX2VudGVyKHZtYS0+dm1fbW0pKQorCQkJCXJldHVybiAtRU5PTUVNOworCXJldHVybiAwOworfQorI2Vsc2UgLyogQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFICovCitzdGF0aWMgaW5saW5lIGludCBraHVnZXBhZ2VkX2Zvcmsoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdCBtbV9zdHJ1Y3QgKm9sZG1tKQoreworCXJldHVybiAwOworfQorc3RhdGljIGlubGluZSB2b2lkIGtodWdlcGFnZWRfZXhpdChzdHJ1Y3QgbW1fc3RydWN0ICptbSkKK3sKK30KK3N0YXRpYyBpbmxpbmUgaW50IGtodWdlcGFnZWRfZW50ZXIoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCit7CisJcmV0dXJuIDA7Cit9CitzdGF0aWMgaW5saW5lIGludCBraHVnZXBhZ2VkX2VudGVyX3ZtYV9tZXJnZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlyZXR1cm4gMDsKK30KKyNlbmRpZiAvKiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UgKi8KKworI2VuZGlmIC8qIF9MSU5VWF9LSFVHRVBBR0VEX0ggKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgva2xpc3QuaCBiL2luY2x1ZGUvbGludXgva2xpc3QuaAppbmRleCBlOTFhNGU1Li5hMzcwY2U1IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2tsaXN0LmgKKysrIGIvaW5jbHVkZS9saW51eC9rbGlzdC5oCkBAIC0yMiw3ICsyMiw3IEBACiAJc3RydWN0IGxpc3RfaGVhZAlrX2xpc3Q7CiAJdm9pZAkJCSgqZ2V0KShzdHJ1Y3Qga2xpc3Rfbm9kZSAqKTsKIAl2b2lkCQkJKCpwdXQpKHN0cnVjdCBrbGlzdF9ub2RlICopOwotfSBfX2F0dHJpYnV0ZV9fICgoYWxpZ25lZCAoNCkpKTsKK30gX19hdHRyaWJ1dGVfXyAoKGFsaWduZWQgKHNpemVvZih2b2lkICopKSkpOwogCiAjZGVmaW5lIEtMSVNUX0lOSVQoX25hbWUsIF9nZXQsIF9wdXQpCQkJCQlcCiAJeyAua19sb2NrCT0gX19TUElOX0xPQ0tfVU5MT0NLRUQoX25hbWUua19sb2NrKSwJCVwKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgva21lbWNoZWNrLmggYi9pbmNsdWRlL2xpbnV4L2ttZW1jaGVjay5oCmluZGV4IDA4ZDdkYzQuLjM5Zjg0NTMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgva21lbWNoZWNrLmgKKysrIGIvaW5jbHVkZS9saW51eC9rbWVtY2hlY2suaApAQCAtNzYsNyArNzYsNyBAQAogCQkJCQkJCQkJXAogCQlfbiA9IChsb25nKSAmKChwdHIpLT5uYW1lIyNfZW5kKQkJCVwKIAkJCS0gKGxvbmcpICYoKHB0ciktPm5hbWUjI19iZWdpbik7CQlcCi0JCU1BWUJFX0JVSUxEX0JVR19PTihfbiA8IDApOwkJCQlcCisJCUJVSUxEX0JVR19PTihfbiA8IDApOwkJCQkJXAogCQkJCQkJCQkJXAogCQlrbWVtY2hlY2tfbWFya19pbml0aWFsaXplZCgmKChwdHIpLT5uYW1lIyNfYmVnaW4pLCBfbik7CVwKIAl9IHdoaWxlICgwKQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9saXN0X2JsLmggYi9pbmNsdWRlL2xpbnV4L2xpc3RfYmwuaAppbmRleCA5ZWU5N2U3Li41YmFkMTdkMSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9saXN0X2JsLmgKKysrIGIvaW5jbHVkZS9saW51eC9saXN0X2JsLmgKQEAgLTYyLDcgKzYyLDggQEAKIAkJCQkJc3RydWN0IGhsaXN0X2JsX25vZGUgKm4pCiB7CiAJTElTVF9CTF9CVUdfT04oKHVuc2lnbmVkIGxvbmcpbiAmIExJU1RfQkxfTE9DS01BU0spOwotCUxJU1RfQkxfQlVHX09OKCEoKHVuc2lnbmVkIGxvbmcpaC0+Zmlyc3QgJiBMSVNUX0JMX0xPQ0tNQVNLKSk7CisJTElTVF9CTF9CVUdfT04oKCh1bnNpZ25lZCBsb25nKWgtPmZpcnN0ICYgTElTVF9CTF9MT0NLTUFTSykgIT0KKwkJCQkJCQlMSVNUX0JMX0xPQ0tNQVNLKTsKIAloLT5maXJzdCA9IChzdHJ1Y3QgaGxpc3RfYmxfbm9kZSAqKSgodW5zaWduZWQgbG9uZyluIHwgTElTVF9CTF9MT0NLTUFTSyk7CiB9CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbG9ja2RlcC5oIGIvaW5jbHVkZS9saW51eC9sb2NrZGVwLmgKaW5kZXggNzFjMDliMjYuLjRhZWYxZGQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbG9ja2RlcC5oCisrKyBiL2luY2x1ZGUvbGludXgvbG9ja2RlcC5oCkBAIC00MzYsMTYgKzQzNiw4IEBACiAjZW5kaWYgLyogQ09ORklHX0xPQ0tERVAgKi8KIAogI2lmZGVmIENPTkZJR19UUkFDRV9JUlFGTEFHUwotZXh0ZXJuIHZvaWQgZWFybHlfYm9vdF9pcnFzX29mZih2b2lkKTsKLWV4dGVybiB2b2lkIGVhcmx5X2Jvb3RfaXJxc19vbih2b2lkKTsKIGV4dGVybiB2b2lkIHByaW50X2lycXRyYWNlX2V2ZW50cyhzdHJ1Y3QgdGFza19zdHJ1Y3QgKmN1cnIpOwogI2Vsc2UKLXN0YXRpYyBpbmxpbmUgdm9pZCBlYXJseV9ib290X2lycXNfb2ZmKHZvaWQpCi17Ci19Ci1zdGF0aWMgaW5saW5lIHZvaWQgZWFybHlfYm9vdF9pcnFzX29uKHZvaWQpCi17Ci19CiBzdGF0aWMgaW5saW5lIHZvaWQgcHJpbnRfaXJxdHJhY2VfZXZlbnRzKHN0cnVjdCB0YXNrX3N0cnVjdCAqY3VycikKIHsKIH0KQEAgLTUyMiwxMiArNTE0LDE1IEBACiAjaWZkZWYgQ09ORklHX0RFQlVHX0xPQ0tfQUxMT0MKICMgaWZkZWYgQ09ORklHX1BST1ZFX0xPQ0tJTkcKICMgIGRlZmluZSBsb2NrX21hcF9hY3F1aXJlKGwpCQlsb2NrX2FjcXVpcmUobCwgMCwgMCwgMCwgMiwgTlVMTCwgX1RISVNfSVBfKQorIyAgZGVmaW5lIGxvY2tfbWFwX2FjcXVpcmVfcmVhZChsKQlsb2NrX2FjcXVpcmUobCwgMCwgMCwgMiwgMiwgTlVMTCwgX1RISVNfSVBfKQogIyBlbHNlCiAjICBkZWZpbmUgbG9ja19tYXBfYWNxdWlyZShsKQkJbG9ja19hY3F1aXJlKGwsIDAsIDAsIDAsIDEsIE5VTEwsIF9USElTX0lQXykKKyMgIGRlZmluZSBsb2NrX21hcF9hY3F1aXJlX3JlYWQobCkJbG9ja19hY3F1aXJlKGwsIDAsIDAsIDIsIDEsIE5VTEwsIF9USElTX0lQXykKICMgZW5kaWYKICMgZGVmaW5lIGxvY2tfbWFwX3JlbGVhc2UobCkJCQlsb2NrX3JlbGVhc2UobCwgMSwgX1RISVNfSVBfKQogI2Vsc2UKICMgZGVmaW5lIGxvY2tfbWFwX2FjcXVpcmUobCkJCQlkbyB7IH0gd2hpbGUgKDApCisjIGRlZmluZSBsb2NrX21hcF9hY3F1aXJlX3JlYWQobCkJCWRvIHsgfSB3aGlsZSAoMCkKICMgZGVmaW5lIGxvY2tfbWFwX3JlbGVhc2UobCkJCQlkbyB7IH0gd2hpbGUgKDApCiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tYWdpYy5oIGIvaW5jbHVkZS9saW51eC9tYWdpYy5oCmluZGV4IGZmNjkwZDAuLjYyNzMwZWEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbWFnaWMuaAorKysgYi9pbmNsdWRlL2xpbnV4L21hZ2ljLmgKQEAgLTE2LDYgKzE2LDcgQEAKICNkZWZpbmUgVE1QRlNfTUFHSUMJCTB4MDEwMjE5OTQKICNkZWZpbmUgSFVHRVRMQkZTX01BR0lDIAkweDk1ODQ1OGY2CS8qIHNvbWUgcmFuZG9tIG51bWJlciAqLwogI2RlZmluZSBTUVVBU0hGU19NQUdJQwkJMHg3MzcxNzM2OAorI2RlZmluZSBFQ1JZUFRGU19TVVBFUl9NQUdJQwkweGYxNWYKICNkZWZpbmUgRUZTX1NVUEVSX01BR0lDCQkweDQxNEE1MwogI2RlZmluZSBFWFQyX1NVUEVSX01BR0lDCTB4RUY1MwogI2RlZmluZSBFWFQzX1NVUEVSX01BR0lDCTB4RUY1MwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tZW1jb250cm9sLmggYi9pbmNsdWRlL2xpbnV4L21lbWNvbnRyb2wuaAppbmRleCAxNTlhMDc2Mi4uZjUxMmUxOCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tZW1jb250cm9sLmgKKysrIGIvaW5jbHVkZS9saW51eC9tZW1jb250cm9sLmgKQEAgLTI1LDYgKzI1LDExIEBACiBzdHJ1Y3QgcGFnZTsKIHN0cnVjdCBtbV9zdHJ1Y3Q7CiAKKy8qIFN0YXRzIHRoYXQgY2FuIGJlIHVwZGF0ZWQgYnkga2VybmVsLiAqLworZW51bSBtZW1fY2dyb3VwX3BhZ2Vfc3RhdF9pdGVtIHsKKwlNRU1DR19OUl9GSUxFX01BUFBFRCwgLyogIyBvZiBwYWdlcyBjaGFyZ2VkIGFzIGZpbGUgcnNzICovCit9OworCiBleHRlcm4gdW5zaWduZWQgbG9uZyBtZW1fY2dyb3VwX2lzb2xhdGVfcGFnZXModW5zaWduZWQgbG9uZyBucl90b19zY2FuLAogCQkJCQlzdHJ1Y3QgbGlzdF9oZWFkICpkc3QsCiAJCQkJCXVuc2lnbmVkIGxvbmcgKnNjYW5uZWQsIGludCBvcmRlciwKQEAgLTkzLDcgKzk4LDcgQEAKIG1lbV9jZ3JvdXBfcHJlcGFyZV9taWdyYXRpb24oc3RydWN0IHBhZ2UgKnBhZ2UsCiAJc3RydWN0IHBhZ2UgKm5ld3BhZ2UsIHN0cnVjdCBtZW1fY2dyb3VwICoqcHRyKTsKIGV4dGVybiB2b2lkIG1lbV9jZ3JvdXBfZW5kX21pZ3JhdGlvbihzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtLAotCXN0cnVjdCBwYWdlICpvbGRwYWdlLCBzdHJ1Y3QgcGFnZSAqbmV3cGFnZSk7CisJc3RydWN0IHBhZ2UgKm9sZHBhZ2UsIHN0cnVjdCBwYWdlICpuZXdwYWdlLCBib29sIG1pZ3JhdGlvbl9vayk7CiAKIC8qCiAgKiBGb3IgbWVtb3J5IHJlY2xhaW0uCkBAIC0xMjEsMTEgKzEyNiwzMCBAQAogCXJldHVybiBmYWxzZTsKIH0KIAotdm9pZCBtZW1fY2dyb3VwX3VwZGF0ZV9maWxlX21hcHBlZChzdHJ1Y3QgcGFnZSAqcGFnZSwgaW50IHZhbCk7Cit2b2lkIG1lbV9jZ3JvdXBfdXBkYXRlX3BhZ2Vfc3RhdChzdHJ1Y3QgcGFnZSAqcGFnZSwKKwkJCQkgZW51bSBtZW1fY2dyb3VwX3BhZ2Vfc3RhdF9pdGVtIGlkeCwKKwkJCQkgaW50IHZhbCk7CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBtZW1fY2dyb3VwX2luY19wYWdlX3N0YXQoc3RydWN0IHBhZ2UgKnBhZ2UsCisJCQkJCSAgICBlbnVtIG1lbV9jZ3JvdXBfcGFnZV9zdGF0X2l0ZW0gaWR4KQoreworCW1lbV9jZ3JvdXBfdXBkYXRlX3BhZ2Vfc3RhdChwYWdlLCBpZHgsIDEpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgbWVtX2Nncm91cF9kZWNfcGFnZV9zdGF0KHN0cnVjdCBwYWdlICpwYWdlLAorCQkJCQkgICAgZW51bSBtZW1fY2dyb3VwX3BhZ2Vfc3RhdF9pdGVtIGlkeCkKK3sKKwltZW1fY2dyb3VwX3VwZGF0ZV9wYWdlX3N0YXQocGFnZSwgaWR4LCAtMSk7Cit9CisKIHVuc2lnbmVkIGxvbmcgbWVtX2Nncm91cF9zb2Z0X2xpbWl0X3JlY2xhaW0oc3RydWN0IHpvbmUgKnpvbmUsIGludCBvcmRlciwKIAkJCQkJCWdmcF90IGdmcF9tYXNrKTsKIHU2NCBtZW1fY2dyb3VwX2dldF9saW1pdChzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtKTsKIAorI2lmZGVmIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRQordm9pZCBtZW1fY2dyb3VwX3NwbGl0X2h1Z2VfZml4dXAoc3RydWN0IHBhZ2UgKmhlYWQsIHN0cnVjdCBwYWdlICp0YWlsKTsKKyNlbmRpZgorCiAjZWxzZSAvKiBDT05GSUdfQ0dST1VQX01FTV9SRVNfQ1RMUiAqLwogc3RydWN0IG1lbV9jZ3JvdXA7CiAKQEAgLTIzMSw4ICsyNTUsNyBAQAogfQogCiBzdGF0aWMgaW5saW5lIHZvaWQgbWVtX2Nncm91cF9lbmRfbWlncmF0aW9uKHN0cnVjdCBtZW1fY2dyb3VwICptZW0sCi0JCQkJCXN0cnVjdCBwYWdlICpvbGRwYWdlLAotCQkJCQlzdHJ1Y3QgcGFnZSAqbmV3cGFnZSkKKwkJc3RydWN0IHBhZ2UgKm9sZHBhZ2UsIHN0cnVjdCBwYWdlICpuZXdwYWdlLCBib29sIG1pZ3JhdGlvbl9vaykKIHsKIH0KIApAQCAtMjkzLDggKzMxNiwxMyBAQAogewogfQogCi1zdGF0aWMgaW5saW5lIHZvaWQgbWVtX2Nncm91cF91cGRhdGVfZmlsZV9tYXBwZWQoc3RydWN0IHBhZ2UgKnBhZ2UsCi0JCQkJCQkJaW50IHZhbCkKK3N0YXRpYyBpbmxpbmUgdm9pZCBtZW1fY2dyb3VwX2luY19wYWdlX3N0YXQoc3RydWN0IHBhZ2UgKnBhZ2UsCisJCQkJCSAgICBlbnVtIG1lbV9jZ3JvdXBfcGFnZV9zdGF0X2l0ZW0gaWR4KQoreworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgbWVtX2Nncm91cF9kZWNfcGFnZV9zdGF0KHN0cnVjdCBwYWdlICpwYWdlLAorCQkJCQkgICAgZW51bSBtZW1fY2dyb3VwX3BhZ2Vfc3RhdF9pdGVtIGlkeCkKIHsKIH0KIApAQCAtMzExLDYgKzMzOSwxMSBAQAogCXJldHVybiAwOwogfQogCitzdGF0aWMgaW5saW5lIHZvaWQgbWVtX2Nncm91cF9zcGxpdF9odWdlX2ZpeHVwKHN0cnVjdCBwYWdlICpoZWFkLAorCQkJCQkJc3RydWN0IHBhZ2UgKnRhaWwpCit7Cit9CisKICNlbmRpZiAvKiBDT05GSUdfQ0dST1VQX01FTV9DT05UICovCiAKICNlbmRpZiAvKiBfTElOVVhfTUVNQ09OVFJPTF9IICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21lbW9yeV9ob3RwbHVnLmggYi9pbmNsdWRlL2xpbnV4L21lbW9yeV9ob3RwbHVnLmgKaW5kZXggMzFjMjM3YS4uODEyMjAxOGQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbWVtb3J5X2hvdHBsdWcuaAorKysgYi9pbmNsdWRlL2xpbnV4L21lbW9yeV9ob3RwbHVnLmgKQEAgLTEzLDEyICsxMywxNiBAQAogI2lmZGVmIENPTkZJR19NRU1PUllfSE9UUExVRwogCiAvKgotICogVHlwZXMgZm9yIGZyZWUgYm9vdG1lbS4KLSAqIFRoZSBub3JtYWwgc21hbGxlc3QgbWFwY291bnQgaXMgLTEuIEhlcmUgaXMgc21hbGxlciB2YWx1ZSB0aGFuIGl0LgorICogVHlwZXMgZm9yIGZyZWUgYm9vdG1lbSBzdG9yZWQgaW4gcGFnZS0+bHJ1Lm5leHQuIFRoZXNlIGhhdmUgdG8gYmUgaW4KKyAqIHNvbWUgcmFuZG9tIHJhbmdlIGluIHVuc2lnbmVkIGxvbmcgc3BhY2UgZm9yIGRlYnVnZ2luZyBwdXJwb3Nlcy4KICAqLwotI2RlZmluZSBTRUNUSU9OX0lORk8JCSgtMSAtIDEpCi0jZGVmaW5lIE1JWF9TRUNUSU9OX0lORk8JKC0xIC0gMikKLSNkZWZpbmUgTk9ERV9JTkZPCQkoLTEgLSAzKQorZW51bSB7CisJTUVNT1JZX0hPVFBMVUdfTUlOX0JPT1RNRU1fVFlQRSA9IDEyLAorCVNFQ1RJT05fSU5GTyA9IE1FTU9SWV9IT1RQTFVHX01JTl9CT09UTUVNX1RZUEUsCisJTUlYX1NFQ1RJT05fSU5GTywKKwlOT0RFX0lORk8sCisJTUVNT1JZX0hPVFBMVUdfTUFYX0JPT1RNRU1fVFlQRSA9IE5PREVfSU5GTywKK307CiAKIC8qCiAgKiBwZ2RhdCByZXNpemluZyBmdW5jdGlvbnMKQEAgLTE2MSw2ICsxNjUsMTIgQEAKIGV4dGVybiB2b2lkIHB1dF9wYWdlX2Jvb3RtZW0oc3RydWN0IHBhZ2UgKnBhZ2UpOwogI2VuZGlmCiAKKy8qCisgKiBMb2NrIGZvciBtZW1vcnkgaG90cGx1ZyBndWFyYW50ZWVzIDEpIGFsbCBjYWxsYmFja3MgZm9yIG1lbW9yeSBob3RwbHVnCisgKiBub3RpZmllciB3aWxsIGJlIGNhbGxlZCB1bmRlciB0aGlzLiAyKSBvZmZsaW5lL29ubGluZS9hZGQvcmVtb3ZlIG1lbW9yeQorICogd2lsbCBub3QgcnVuIHNpbXVsdGFuZW91c2x5LgorICovCisKIHZvaWQgbG9ja19tZW1vcnlfaG90cGx1Zyh2b2lkKTsKIHZvaWQgdW5sb2NrX21lbW9yeV9ob3RwbHVnKHZvaWQpOwogCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21mZC9hYjg1MDAuaCBiL2luY2x1ZGUvbGludXgvbWZkL2FiODUwMC5oCmluZGV4IDg1Y2YyYzI4Li4zN2Y1NmI3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21mZC9hYjg1MDAuaAorKysgYi9pbmNsdWRlL2xpbnV4L21mZC9hYjg1MDAuaApAQCAtNzQsMzAgKzc0LDM3IEBACiAjZGVmaW5lIEFCODUwMF9JTlRfQUNDX0RFVEVDVF8yMURCX0YJMzcKICNkZWZpbmUgQUI4NTAwX0lOVF9BQ0NfREVURUNUXzIxREJfUgkzOAogI2RlZmluZSBBQjg1MDBfSU5UX0dQX1NXX0FEQ19DT05WX0VORAkzOQotI2RlZmluZSBBQjg1MDBfSU5UX0JURU1QX0xPVwkJNzIKLSNkZWZpbmUgQUI4NTAwX0lOVF9CVEVNUF9MT1dfTUVESVVNCTczCi0jZGVmaW5lIEFCODUwMF9JTlRfQlRFTVBfTUVESVVNX0hJR0gJNzQKLSNkZWZpbmUgQUI4NTAwX0lOVF9CVEVNUF9ISUdICQk3NQotI2RlZmluZSBBQjg1MDBfSU5UX1VTQl9DSEFSR0VSX05PVF9PSwk4MQotI2RlZmluZSBBQjg1MDBfSU5UX0lEX1dBS0VVUF9SCQk4MgotI2RlZmluZSBBQjg1MDBfSU5UX0lEX0RFVF9SMVIJCTg0Ci0jZGVmaW5lIEFCODUwMF9JTlRfSURfREVUX1IyUgkJODUKLSNkZWZpbmUgQUI4NTAwX0lOVF9JRF9ERVRfUjNSCQk4NgotI2RlZmluZSBBQjg1MDBfSU5UX0lEX0RFVF9SNFIJCTg3Ci0jZGVmaW5lIEFCODUwMF9JTlRfSURfV0FLRVVQX0YJCTg4Ci0jZGVmaW5lIEFCODUwMF9JTlRfSURfREVUX1IxRgkJOTAKLSNkZWZpbmUgQUI4NTAwX0lOVF9JRF9ERVRfUjJGCQk5MQotI2RlZmluZSBBQjg1MDBfSU5UX0lEX0RFVF9SM0YJCTkyCi0jZGVmaW5lIEFCODUwMF9JTlRfSURfREVUX1I0RgkJOTMKLSNkZWZpbmUgQUI4NTAwX0lOVF9VU0JfQ0hHX0RFVF9ET05FCTk0Ci0jZGVmaW5lIEFCODUwMF9JTlRfVVNCX0NIX1RIX1BST1RfRgk5NgotI2RlZmluZSBBQjg1MDBfSU5UX1VTQl9DSF9USF9QUk9QX1IJOTcKLSNkZWZpbmUgQUI4NTAwX0lOVF9NQUlOX0NIX1RIX1BST1BfRgk5OAotI2RlZmluZSBBQjg1MDBfSU5UX01BSU5fQ0hfVEhfUFJPVF9SCTk5Ci0jZGVmaW5lIEFCODUwMF9JTlRfVVNCX0NIQVJHRVJfTk9UX09LRgkxMDMKKyNkZWZpbmUgQUI4NTAwX0lOVF9BRFBfU09VUkNFX0VSUk9SCTcyCisjZGVmaW5lIEFCODUwMF9JTlRfQURQX1NJTktfRVJST1IJNzMKKyNkZWZpbmUgQUI4NTAwX0lOVF9BRFBfUFJPQkVfUExVRwk3NAorI2RlZmluZSBBQjg1MDBfSU5UX0FEUF9QUk9CRV9VTlBMVUcJNzUKKyNkZWZpbmUgQUI4NTAwX0lOVF9BRFBfU0VOU0VfT0ZGCTc2CisjZGVmaW5lIEFCODUwMF9JTlRfVVNCX1BIWV9QT1dFUl9FUlIJNzgKKyNkZWZpbmUgQUI4NTAwX0lOVF9VU0JfTElOS19TVEFUVVMJNzkKKyNkZWZpbmUgQUI4NTAwX0lOVF9CVEVNUF9MT1cJCTgwCisjZGVmaW5lIEFCODUwMF9JTlRfQlRFTVBfTE9XX01FRElVTQk4MQorI2RlZmluZSBBQjg1MDBfSU5UX0JURU1QX01FRElVTV9ISUdICTgyCisjZGVmaW5lIEFCODUwMF9JTlRfQlRFTVBfSElHSAkJODMKKyNkZWZpbmUgQUI4NTAwX0lOVF9VU0JfQ0hBUkdFUl9OT1RfT0sJODkKKyNkZWZpbmUgQUI4NTAwX0lOVF9JRF9XQUtFVVBfUgkJOTAKKyNkZWZpbmUgQUI4NTAwX0lOVF9JRF9ERVRfUjFSCQk5MgorI2RlZmluZSBBQjg1MDBfSU5UX0lEX0RFVF9SMlIJCTkzCisjZGVmaW5lIEFCODUwMF9JTlRfSURfREVUX1IzUgkJOTQKKyNkZWZpbmUgQUI4NTAwX0lOVF9JRF9ERVRfUjRSCQk5NQorI2RlZmluZSBBQjg1MDBfSU5UX0lEX1dBS0VVUF9GCQk5NgorI2RlZmluZSBBQjg1MDBfSU5UX0lEX0RFVF9SMUYJCTk4CisjZGVmaW5lIEFCODUwMF9JTlRfSURfREVUX1IyRgkJOTkKKyNkZWZpbmUgQUI4NTAwX0lOVF9JRF9ERVRfUjNGCQkxMDAKKyNkZWZpbmUgQUI4NTAwX0lOVF9JRF9ERVRfUjRGCQkxMDEKKyNkZWZpbmUgQUI4NTAwX0lOVF9VU0JfQ0hHX0RFVF9ET05FCTEwMgorI2RlZmluZSBBQjg1MDBfSU5UX1VTQl9DSF9USF9QUk9UX0YJMTA0CisjZGVmaW5lIEFCODUwMF9JTlRfVVNCX0NIX1RIX1BST1RfUiAgICAxMDUKKyNkZWZpbmUgQUI4NTAwX0lOVF9NQUlOX0NIX1RIX1BST1RfRiAgIDEwNgorI2RlZmluZSBBQjg1MDBfSU5UX01BSU5fQ0hfVEhfUFJPVF9SCTEwNworI2RlZmluZSBBQjg1MDBfSU5UX1VTQl9DSEFSR0VSX05PVF9PS0YJMTExCiAKLSNkZWZpbmUgQUI4NTAwX05SX0lSUVMJCQkxMDQKLSNkZWZpbmUgQUI4NTAwX05VTV9JUlFfUkVHUwkJMTMKKyNkZWZpbmUgQUI4NTAwX05SX0lSUVMJCQkxMTIKKyNkZWZpbmUgQUI4NTAwX05VTV9JUlFfUkVHUwkJMTQKIAogLyoqCiAgKiBzdHJ1Y3QgYWI4NTAwIC0gYWI4NTAwIGludGVybmFsIHN0cnVjdHVyZQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tZmQvY29yZS5oIGIvaW5jbHVkZS9saW51eC9tZmQvY29yZS5oCmluZGV4IDU1ODJhYjMuLjgzNTk5NmUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbWZkL2NvcmUuaAorKysgYi9pbmNsdWRlL2xpbnV4L21mZC9jb3JlLmgKQEAgLTQ3LDYgKzQ3LDEyIEBACiAKIAkvKiBkb24ndCBjaGVjayBmb3IgcmVzb3VyY2UgY29uZmxpY3RzICovCiAJYm9vbAkJCWlnbm9yZV9yZXNvdXJjZV9jb25mbGljdHM7CisKKwkvKgorCSAqIERpc2FibGUgcnVudGltZSBQTSBjYWxsYmFja3MgZm9yIHRoaXMgc3ViZGV2aWNlIC0gc2VlCisJICogcG1fcnVudGltZV9ub19jYWxsYmFja3MoKS4KKwkgKi8KKwlib29sCQkJcG1fcnVudGltZV9ub19jYWxsYmFja3M7CiB9OwogCiBleHRlcm4gaW50IG1mZF9hZGRfZGV2aWNlcyhzdHJ1Y3QgZGV2aWNlICpwYXJlbnQsIGludCBpZCwKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbWZkL21heDg5OTgtcHJpdmF0ZS5oIGIvaW5jbHVkZS9saW51eC9tZmQvbWF4ODk5OC1wcml2YXRlLmgKaW5kZXggNzM2M2RlYS4uZWZmYTVkMyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tZmQvbWF4ODk5OC1wcml2YXRlLmgKKysrIGIvaW5jbHVkZS9saW51eC9tZmQvbWF4ODk5OC1wcml2YXRlLmgKQEAgLTE1OSwxMCArMTU5LDEyIEBACiAJdTggaXJxX21hc2tzX2N1cltNQVg4OTk4X05VTV9JUlFfUkVHU107CiAJdTggaXJxX21hc2tzX2NhY2hlW01BWDg5OThfTlVNX0lSUV9SRUdTXTsKIAlpbnQgdHlwZTsKKwlib29sIHdha2V1cDsKIH07CiAKIGludCBtYXg4OTk4X2lycV9pbml0KHN0cnVjdCBtYXg4OTk4X2RldiAqbWF4ODk5OCk7CiB2b2lkIG1heDg5OThfaXJxX2V4aXQoc3RydWN0IG1heDg5OThfZGV2ICptYXg4OTk4KTsKK2ludCBtYXg4OTk4X2lycV9yZXN1bWUoc3RydWN0IG1heDg5OThfZGV2ICptYXg4OTk4KTsKIAogZXh0ZXJuIGludCBtYXg4OTk4X3JlYWRfcmVnKHN0cnVjdCBpMmNfY2xpZW50ICppMmMsIHU4IHJlZywgdTggKmRlc3QpOwogZXh0ZXJuIGludCBtYXg4OTk4X2J1bGtfcmVhZChzdHJ1Y3QgaTJjX2NsaWVudCAqaTJjLCB1OCByZWcsIGludCBjb3VudCwKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbWZkL21heDg5OTguaCBiL2luY2x1ZGUvbGludXgvbWZkL21heDg5OTguaAppbmRleCBmOGM5Zjg4Li42MWRhYTE2IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21mZC9tYXg4OTk4LmgKKysrIGIvaW5jbHVkZS9saW51eC9tZmQvbWF4ODk5OC5oCkBAIC03MCwyNCArNzAsNDMgQEAKICAqIEBudW1fcmVndWxhdG9yczogbnVtYmVyIG9mIHJlZ3VsdG9ycyB1c2VkCiAgKiBAaXJxX2Jhc2U6IGJhc2UgSVJRIG51bWJlciBmb3IgbWF4ODk5OCwgcmVxdWlyZWQgZm9yIElSUXMKICAqIEBvbm86IHBvd2VyIG9ub2ZmIElSUSBudW1iZXIgZm9yIG1heDg5OTgKLSAqIEBidWNrMV9tYXhfdm9sdGFnZTE6IEJVQ0sxIG1heGltdW0gYWxvd2VkIHZvbHRhZ2UgcmVnaXN0ZXIgMQotICogQGJ1Y2sxX21heF92b2x0YWdlMjogQlVDSzEgbWF4aW11bSBhbG93ZWQgdm9sdGFnZSByZWdpc3RlciAyCi0gKiBAYnVjazJfbWF4X3ZvbHRhZ2U6IEJVQ0syIG1heGltdW0gYWxvd2VkIHZvbHRhZ2UKKyAqIEBidWNrX3ZvbHRhZ2VfbG9jazogRG8gTk9UIGNoYW5nZSB0aGUgdmFsdWVzIG9mIHRoZSBmb2xsb3dpbmcgc2l4CisgKiAgIHJlZ2lzdGVycyBzZXQgYnkgYnVjaz9fdm9sdGFnZT8uIFRoZSB2b2x0YWdlIG9mIEJVQ0sxLzIgY2Fubm90CisgKiAgIGJlIG90aGVyIHRoYW4gdGhlIHByZXNldCB2YWx1ZXMuCisgKiBAYnVjazFfdm9sdGFnZTE6IEJVQ0sxIERWUyBtb2RlIDEgdm9sdGFnZSByZWdpc3RlcgorICogQGJ1Y2sxX3ZvbHRhZ2UyOiBCVUNLMSBEVlMgbW9kZSAyIHZvbHRhZ2UgcmVnaXN0ZXIKKyAqIEBidWNrMV92b2x0YWdlMzogQlVDSzEgRFZTIG1vZGUgMyB2b2x0YWdlIHJlZ2lzdGVyCisgKiBAYnVjazFfdm9sdGFnZTQ6IEJVQ0sxIERWUyBtb2RlIDQgdm9sdGFnZSByZWdpc3RlcgorICogQGJ1Y2syX3ZvbHRhZ2UxOiBCVUNLMiBEVlMgbW9kZSAxIHZvbHRhZ2UgcmVnaXN0ZXIKKyAqIEBidWNrMl92b2x0YWdlMjogQlVDSzIgRFZTIG1vZGUgMiB2b2x0YWdlIHJlZ2lzdGVyCiAgKiBAYnVjazFfc2V0MTogQlVDSzEgZ3BpbyBwaW4gMSB0byBzZXQgb3V0cHV0IHZvbHRhZ2UKICAqIEBidWNrMV9zZXQyOiBCVUNLMSBncGlvIHBpbiAyIHRvIHNldCBvdXRwdXQgdm9sdGFnZQorICogQGJ1Y2sxX2RlZmF1bHRfaWR4OiBEZWZhdWx0IGZvciBCVUNLMSBncGlvIHBpbiAxLCAyCiAgKiBAYnVjazJfc2V0MzogQlVDSzIgZ3BpbyBwaW4gdG8gc2V0IG91dHB1dCB2b2x0YWdlCisgKiBAYnVjazJfZGVmYXVsdF9pZHg6IERlZmF1bHQgZm9yIEJVQ0syIGdwaW8gcGluLgorICogQHdha2V1cDogQWxsb3cgdG8gd2FrZSB1cCBmcm9tIHN1c3BlbmQKKyAqIEBydGNfZGVsYXk6IExQMzk3NCBSVEMgY2hpcCBidWcgdGhhdCByZXF1aXJlcyBkZWxheSBhZnRlciBhIHJlZ2lzdGVyCisgKiB3cml0ZSBiZWZvcmUgcmVhZGluZyBpdC4KICAqLwogc3RydWN0IG1heDg5OThfcGxhdGZvcm1fZGF0YSB7CiAJc3RydWN0IG1heDg5OThfcmVndWxhdG9yX2RhdGEJKnJlZ3VsYXRvcnM7CiAJaW50CQkJCW51bV9yZWd1bGF0b3JzOwogCWludAkJCQlpcnFfYmFzZTsKIAlpbnQJCQkJb25vOwotCWludCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnVjazFfbWF4X3ZvbHRhZ2UxOwotCWludCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnVjazFfbWF4X3ZvbHRhZ2UyOwotCWludCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnVjazJfbWF4X3ZvbHRhZ2U7CisJYm9vbAkJCQlidWNrX3ZvbHRhZ2VfbG9jazsKKwlpbnQJCQkJYnVjazFfdm9sdGFnZTE7CisJaW50CQkJCWJ1Y2sxX3ZvbHRhZ2UyOworCWludAkJCQlidWNrMV92b2x0YWdlMzsKKwlpbnQJCQkJYnVjazFfdm9sdGFnZTQ7CisJaW50CQkJCWJ1Y2syX3ZvbHRhZ2UxOworCWludAkJCQlidWNrMl92b2x0YWdlMjsKIAlpbnQJCQkJYnVjazFfc2V0MTsKIAlpbnQJCQkJYnVjazFfc2V0MjsKKwlpbnQJCQkJYnVjazFfZGVmYXVsdF9pZHg7CiAJaW50CQkJCWJ1Y2syX3NldDM7CisJaW50CQkJCWJ1Y2syX2RlZmF1bHRfaWR4OworCWJvb2wJCQkJd2FrZXVwOworCWJvb2wJCQkJcnRjX2RlbGF5OwogfTsKIAogI2VuZGlmIC8qICBfX0xJTlVYX01GRF9NQVg4OTk4X0ggKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbWZkL3dtODMxeC9jb3JlLmggYi9pbmNsdWRlL2xpbnV4L21mZC93bTgzMXgvY29yZS5oCmluZGV4IGExMjM5YzQuLjkwMzI4MGQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbWZkL3dtODMxeC9jb3JlLmgKKysrIGIvaW5jbHVkZS9saW51eC9tZmQvd204MzF4L2NvcmUuaApAQCAtMjQ1LDYgKzI0NSw3IEBACiAJV004MzIwID0gMHg4MzIwLAogCVdNODMyMSA9IDB4ODMyMSwKIAlXTTgzMjUgPSAweDgzMjUsCisJV004MzI2ID0gMHg4MzI2LAogfTsKIAogc3RydWN0IHdtODMxeCB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21pZ3JhdGUuaCBiL2luY2x1ZGUvbGludXgvbWlncmF0ZS5oCmluZGV4IDA4NTUyN2YuLmUzOWFlZWMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbWlncmF0ZS5oCisrKyBiL2luY2x1ZGUvbGludXgvbWlncmF0ZS5oCkBAIC0xMyw5ICsxMywxMSBAQAogZXh0ZXJuIGludCBtaWdyYXRlX3BhZ2Uoc3RydWN0IGFkZHJlc3Nfc3BhY2UgKiwKIAkJCXN0cnVjdCBwYWdlICosIHN0cnVjdCBwYWdlICopOwogZXh0ZXJuIGludCBtaWdyYXRlX3BhZ2VzKHN0cnVjdCBsaXN0X2hlYWQgKmwsIG5ld19wYWdlX3QgeCwKLQkJCXVuc2lnbmVkIGxvbmcgcHJpdmF0ZSwgaW50IG9mZmxpbmluZyk7CisJCQl1bnNpZ25lZCBsb25nIHByaXZhdGUsIGJvb2wgb2ZmbGluaW5nLAorCQkJYm9vbCBzeW5jKTsKIGV4dGVybiBpbnQgbWlncmF0ZV9odWdlX3BhZ2VzKHN0cnVjdCBsaXN0X2hlYWQgKmwsIG5ld19wYWdlX3QgeCwKLQkJCXVuc2lnbmVkIGxvbmcgcHJpdmF0ZSwgaW50IG9mZmxpbmluZyk7CisJCQl1bnNpZ25lZCBsb25nIHByaXZhdGUsIGJvb2wgb2ZmbGluaW5nLAorCQkJYm9vbCBzeW5jKTsKIAogZXh0ZXJuIGludCBmYWlsX21pZ3JhdGVfcGFnZShzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqLAogCQkJc3RydWN0IHBhZ2UgKiwgc3RydWN0IHBhZ2UgKik7CkBAIC0zMyw5ICszNSwxMSBAQAogCiBzdGF0aWMgaW5saW5lIHZvaWQgcHV0YmFja19scnVfcGFnZXMoc3RydWN0IGxpc3RfaGVhZCAqbCkge30KIHN0YXRpYyBpbmxpbmUgaW50IG1pZ3JhdGVfcGFnZXMoc3RydWN0IGxpc3RfaGVhZCAqbCwgbmV3X3BhZ2VfdCB4LAotCQl1bnNpZ25lZCBsb25nIHByaXZhdGUsIGludCBvZmZsaW5pbmcpIHsgcmV0dXJuIC1FTk9TWVM7IH0KKwkJdW5zaWduZWQgbG9uZyBwcml2YXRlLCBib29sIG9mZmxpbmluZywKKwkJYm9vbCBzeW5jKSB7IHJldHVybiAtRU5PU1lTOyB9CiBzdGF0aWMgaW5saW5lIGludCBtaWdyYXRlX2h1Z2VfcGFnZXMoc3RydWN0IGxpc3RfaGVhZCAqbCwgbmV3X3BhZ2VfdCB4LAotCQl1bnNpZ25lZCBsb25nIHByaXZhdGUsIGludCBvZmZsaW5pbmcpIHsgcmV0dXJuIC1FTk9TWVM7IH0KKwkJdW5zaWduZWQgbG9uZyBwcml2YXRlLCBib29sIG9mZmxpbmluZywKKwkJYm9vbCBzeW5jKSB7IHJldHVybiAtRU5PU1lTOyB9CiAKIHN0YXRpYyBpbmxpbmUgaW50IG1pZ3JhdGVfcHJlcCh2b2lkKSB7IHJldHVybiAtRU5PU1lTOyB9CiBzdGF0aWMgaW5saW5lIGludCBtaWdyYXRlX3ByZXBfbG9jYWwodm9pZCkgeyByZXR1cm4gLUVOT1NZUzsgfQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tbHg0L2RldmljZS5oIGIvaW5jbHVkZS9saW51eC9tbHg0L2RldmljZS5oCmluZGV4IGE3YjE1YmMuLjA0OTIxNDYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbWx4NC9kZXZpY2UuaAorKysgYi9pbmNsdWRlL2xpbnV4L21seDQvZGV2aWNlLmgKQEAgLTE0NCw2ICsxNDQsMTEgQEAKIAlNTFg0X1NUQVRfUkFURV9PRkZTRVQJPSA1CiB9OwogCitlbnVtIG1seDRfcHJvdG9jb2wgeworCU1MWDRfUFJPVE9DT0xfSUIsCisJTUxYNF9QUk9UT0NPTF9FTiwKK307CisKIGVudW0gewogCU1MWDRfTVRUX0ZMQUdfUFJFU0VOVAkJPSAxCiB9OwpAQCAtNTAwLDggKzUwNSw5IEBACiBpbnQgbWx4NF9DTE9TRV9QT1JUKHN0cnVjdCBtbHg0X2RldiAqZGV2LCBpbnQgcG9ydCk7CiAKIGludCBtbHg0X211bHRpY2FzdF9hdHRhY2goc3RydWN0IG1seDRfZGV2ICpkZXYsIHN0cnVjdCBtbHg0X3FwICpxcCwgdTggZ2lkWzE2XSwKLQkJCSAgaW50IGJsb2NrX21jYXN0X2xvb3BiYWNrKTsKLWludCBtbHg0X211bHRpY2FzdF9kZXRhY2goc3RydWN0IG1seDRfZGV2ICpkZXYsIHN0cnVjdCBtbHg0X3FwICpxcCwgdTggZ2lkWzE2XSk7CisJCQkgIGludCBibG9ja19tY2FzdF9sb29wYmFjaywgZW51bSBtbHg0X3Byb3RvY29sIHByb3RvY29sKTsKK2ludCBtbHg0X211bHRpY2FzdF9kZXRhY2goc3RydWN0IG1seDRfZGV2ICpkZXYsIHN0cnVjdCBtbHg0X3FwICpxcCwgdTggZ2lkWzE2XSwKKwkJCSAgZW51bSBtbHg0X3Byb3RvY29sIHByb3RvY29sKTsKIAogaW50IG1seDRfcmVnaXN0ZXJfbWFjKHN0cnVjdCBtbHg0X2RldiAqZGV2LCB1OCBwb3J0LCB1NjQgbWFjLCBpbnQgKmluZGV4KTsKIHZvaWQgbWx4NF91bnJlZ2lzdGVyX21hYyhzdHJ1Y3QgbWx4NF9kZXYgKmRldiwgdTggcG9ydCwgaW50IGluZGV4KTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbWx4NC9kcml2ZXIuaCBiL2luY2x1ZGUvbGludXgvbWx4NC9kcml2ZXIuaAppbmRleCBmNDA3Y2Q0Li5lMWVlYmY3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21seDQvZHJpdmVyLmgKKysrIGIvaW5jbHVkZS9saW51eC9tbHg0L2RyaXZlci5oCkBAIC0zNCw2ICszNCw3IEBACiAjZGVmaW5lIE1MWDRfRFJJVkVSX0gKIAogI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L21seDQvZGV2aWNlLmg+CiAKIHN0cnVjdCBtbHg0X2RldjsKIApAQCAtNDQsMTEgKzQ1LDYgQEAKIAlNTFg0X0RFVl9FVkVOVF9QT1JUX1JFSU5JVCwKIH07CiAKLWVudW0gbWx4NF9wcm90b2NvbCB7Ci0JTUxYNF9QUk9UT0NPTF9JQiwKLQlNTFg0X1BST1RPQ09MX0VOLAotfTsKLQogc3RydWN0IG1seDRfaW50ZXJmYWNlIHsKIAl2b2lkICoJCQkoKmFkZCkJIChzdHJ1Y3QgbWx4NF9kZXYgKmRldik7CiAJdm9pZAkJCSgqcmVtb3ZlKShzdHJ1Y3QgbWx4NF9kZXYgKmRldiwgdm9pZCAqY29udGV4dCk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tLmggYi9pbmNsdWRlL2xpbnV4L21tLmgKaW5kZXggNzIxZjQ1MS4uZjYzODVmYyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tbS5oCisrKyBiL2luY2x1ZGUvbGludXgvbW0uaApAQCAtMTQsNiArMTQsNyBAQAogI2luY2x1ZGUgPGxpbnV4L21tX3R5cGVzLmg+CiAjaW5jbHVkZSA8bGludXgvcmFuZ2UuaD4KICNpbmNsdWRlIDxsaW51eC9wZm4uaD4KKyNpbmNsdWRlIDxsaW51eC9iaXRfc3BpbmxvY2suaD4KIAogc3RydWN0IG1lbXBvbGljeTsKIHN0cnVjdCBhbm9uX3ZtYTsKQEAgLTgyLDYgKzgzLDcgQEAKICNkZWZpbmUgVk1fR1JPV1NVUAkweDAwMDAwMjAwCiAjZWxzZQogI2RlZmluZSBWTV9HUk9XU1VQCTB4MDAwMDAwMDAKKyNkZWZpbmUgVk1fTk9IVUdFUEFHRQkweDAwMDAwMjAwCS8qIE1BRFZfTk9IVUdFUEFHRSBtYXJrZWQgdGhpcyB2bWEgKi8KICNlbmRpZgogI2RlZmluZSBWTV9QRk5NQVAJMHgwMDAwMDQwMAkvKiBQYWdlLXJhbmdlcyBtYW5hZ2VkIHdpdGhvdXQgInN0cnVjdCBwYWdlIiwganVzdCBwdXJlIFBGTiAqLwogI2RlZmluZSBWTV9ERU5ZV1JJVEUJMHgwMDAwMDgwMAkvKiBFVFhUQlNZIG9uIHdyaXRlIGF0dGVtcHRzLi4gKi8KQEAgLTEwMSw3ICsxMDMsMTEgQEAKICNkZWZpbmUgVk1fTk9SRVNFUlZFCTB4MDAyMDAwMDAJLyogc2hvdWxkIHRoZSBWTSBzdXBwcmVzcyBhY2NvdW50aW5nICovCiAjZGVmaW5lIFZNX0hVR0VUTEIJMHgwMDQwMDAwMAkvKiBIdWdlIFRMQiBQYWdlIFZNICovCiAjZGVmaW5lIFZNX05PTkxJTkVBUgkweDAwODAwMDAwCS8qIElzIG5vbi1saW5lYXIgKHJlbWFwX2ZpbGVfcGFnZXMpICovCisjaWZuZGVmIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRQogI2RlZmluZSBWTV9NQVBQRURfQ09QWQkweDAxMDAwMDAwCS8qIFQgaWYgbWFwcGVkIGNvcHkgb2YgZGF0YSAobm9tbXUgbW1hcCkgKi8KKyNlbHNlCisjZGVmaW5lIFZNX0hVR0VQQUdFCTB4MDEwMDAwMDAJLyogTUFEVl9IVUdFUEFHRSBtYXJrZWQgdGhpcyB2bWEgKi8KKyNlbmRpZgogI2RlZmluZSBWTV9JTlNFUlRQQUdFCTB4MDIwMDAwMDAJLyogVGhlIHZtYSBoYXMgaGFkICJ2bV9pbnNlcnRfcGFnZSgpIiBkb25lIG9uIGl0ICovCiAjZGVmaW5lIFZNX0FMV0FZU0RVTVAJMHgwNDAwMDAwMAkvKiBBbHdheXMgaW5jbHVkZSBpbiBjb3JlIGR1bXBzICovCiAKQEAgLTI0Miw2ICsyNDgsNyBAQAogICogZmlsZXMgd2hpY2ggbmVlZCBpdCAoMTE5IG9mIHRoZW0pCiAgKi8KICNpbmNsdWRlIDxsaW51eC9wYWdlLWZsYWdzLmg+CisjaW5jbHVkZSA8bGludXgvaHVnZV9tbS5oPgogCiAvKgogICogTWV0aG9kcyB0byBtb2RpZnkgdGhlIHBhZ2UgdXNhZ2UgY291bnQuCkBAIC0zMDUsNiArMzEyLDM5IEBACiB9CiAjZW5kaWYKIAorc3RhdGljIGlubGluZSB2b2lkIGNvbXBvdW5kX2xvY2soc3RydWN0IHBhZ2UgKnBhZ2UpCit7CisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCisJYml0X3NwaW5fbG9jayhQR19jb21wb3VuZF9sb2NrLCAmcGFnZS0+ZmxhZ3MpOworI2VuZGlmCit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBjb21wb3VuZF91bmxvY2soc3RydWN0IHBhZ2UgKnBhZ2UpCit7CisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCisJYml0X3NwaW5fdW5sb2NrKFBHX2NvbXBvdW5kX2xvY2ssICZwYWdlLT5mbGFncyk7CisjZW5kaWYKK30KKworc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIGNvbXBvdW5kX2xvY2tfaXJxc2F2ZShzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwl1bnNpZ25lZCBsb25nIHVuaW5pdGlhbGl6ZWRfdmFyKGZsYWdzKTsKKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UKKwlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CisJY29tcG91bmRfbG9jayhwYWdlKTsKKyNlbmRpZgorCXJldHVybiBmbGFnczsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGNvbXBvdW5kX3VubG9ja19pcnFyZXN0b3JlKHN0cnVjdCBwYWdlICpwYWdlLAorCQkJCQkgICAgICB1bnNpZ25lZCBsb25nIGZsYWdzKQoreworI2lmZGVmIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRQorCWNvbXBvdW5kX3VubG9jayhwYWdlKTsKKwlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CisjZW5kaWYKK30KKwogc3RhdGljIGlubGluZSBzdHJ1Y3QgcGFnZSAqY29tcG91bmRfaGVhZChzdHJ1Y3QgcGFnZSAqcGFnZSkKIHsKIAlpZiAodW5saWtlbHkoUGFnZVRhaWwocGFnZSkpKQpAQCAtMzE5LDkgKzM1OSwyOSBAQAogCiBzdGF0aWMgaW5saW5lIHZvaWQgZ2V0X3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCiB7Ci0JcGFnZSA9IGNvbXBvdW5kX2hlYWQocGFnZSk7Ci0JVk1fQlVHX09OKGF0b21pY19yZWFkKCZwYWdlLT5fY291bnQpID09IDApOworCS8qCisJICogR2V0dGluZyBhIG5vcm1hbCBwYWdlIG9yIHRoZSBoZWFkIG9mIGEgY29tcG91bmQgcGFnZQorCSAqIHJlcXVpcmVzIHRvIGFscmVhZHkgaGF2ZSBhbiBlbGV2YXRlZCBwYWdlLT5fY291bnQuIE9ubHkgaWYKKwkgKiB3ZSdyZSBnZXR0aW5nIGEgdGFpbCBwYWdlLCB0aGUgZWxldmF0ZWQgcGFnZS0+X2NvdW50IGlzCisJICogcmVxdWlyZWQgb25seSBpbiB0aGUgaGVhZCBwYWdlLCBzbyBmb3IgdGFpbCBwYWdlcyB0aGUKKwkgKiBidWdjaGVjayBvbmx5IHZlcmlmaWVzIHRoYXQgdGhlIHBhZ2UtPl9jb3VudCBpc24ndAorCSAqIG5lZ2F0aXZlLgorCSAqLworCVZNX0JVR19PTihhdG9taWNfcmVhZCgmcGFnZS0+X2NvdW50KSA8ICFQYWdlVGFpbChwYWdlKSk7CiAJYXRvbWljX2luYygmcGFnZS0+X2NvdW50KTsKKwkvKgorCSAqIEdldHRpbmcgYSB0YWlsIHBhZ2Ugd2lsbCBlbGV2YXRlIGJvdGggdGhlIGhlYWQgYW5kIHRhaWwKKwkgKiBwYWdlLT5fY291bnQocykuCisJICovCisJaWYgKHVubGlrZWx5KFBhZ2VUYWlsKHBhZ2UpKSkgeworCQkvKgorCQkgKiBUaGlzIGlzIHNhZmUgb25seSBiZWNhdXNlCisJCSAqIF9fc3BsaXRfaHVnZV9wYWdlX3JlZmNvdW50IGNhbid0IHJ1biB1bmRlcgorCQkgKiBnZXRfcGFnZSgpLgorCQkgKi8KKwkJVk1fQlVHX09OKGF0b21pY19yZWFkKCZwYWdlLT5maXJzdF9wYWdlLT5fY291bnQpIDw9IDApOworCQlhdG9taWNfaW5jKCZwYWdlLT5maXJzdF9wYWdlLT5fY291bnQpOworCX0KIH0KIAogc3RhdGljIGlubGluZSBzdHJ1Y3QgcGFnZSAqdmlydF90b19oZWFkX3BhZ2UoY29uc3Qgdm9pZCAqeCkKQEAgLTMzOSw2ICszOTksMjcgQEAKIAlhdG9taWNfc2V0KCZwYWdlLT5fY291bnQsIDEpOwogfQogCisvKgorICogUGFnZUJ1ZGR5KCkgaW5kaWNhdGUgdGhhdCB0aGUgcGFnZSBpcyBmcmVlIGFuZCBpbiB0aGUgYnVkZHkgc3lzdGVtCisgKiAoc2VlIG1tL3BhZ2VfYWxsb2MuYykuCisgKi8KK3N0YXRpYyBpbmxpbmUgaW50IFBhZ2VCdWRkeShzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwlyZXR1cm4gYXRvbWljX3JlYWQoJnBhZ2UtPl9tYXBjb3VudCkgPT0gLTI7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBfX1NldFBhZ2VCdWRkeShzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwlWTV9CVUdfT04oYXRvbWljX3JlYWQoJnBhZ2UtPl9tYXBjb3VudCkgIT0gLTEpOworCWF0b21pY19zZXQoJnBhZ2UtPl9tYXBjb3VudCwgLTIpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgX19DbGVhclBhZ2VCdWRkeShzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwlWTV9CVUdfT04oIVBhZ2VCdWRkeShwYWdlKSk7CisJYXRvbWljX3NldCgmcGFnZS0+X21hcGNvdW50LCAtMSk7Cit9CisKIHZvaWQgcHV0X3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpOwogdm9pZCBwdXRfcGFnZXNfbGlzdChzdHJ1Y3QgbGlzdF9oZWFkICpwYWdlcyk7CiAKQEAgLTM3MCwxMSArNDUxLDQwIEBACiAJcmV0dXJuICh1bnNpZ25lZCBsb25nKXBhZ2VbMV0ubHJ1LnByZXY7CiB9CiAKK3N0YXRpYyBpbmxpbmUgaW50IGNvbXBvdW5kX3RyYW5zX29yZGVyKHN0cnVjdCBwYWdlICpwYWdlKQoreworCWludCBvcmRlcjsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJaWYgKCFQYWdlSGVhZChwYWdlKSkKKwkJcmV0dXJuIDA7CisKKwlmbGFncyA9IGNvbXBvdW5kX2xvY2tfaXJxc2F2ZShwYWdlKTsKKwlvcmRlciA9IGNvbXBvdW5kX29yZGVyKHBhZ2UpOworCWNvbXBvdW5kX3VubG9ja19pcnFyZXN0b3JlKHBhZ2UsIGZsYWdzKTsKKwlyZXR1cm4gb3JkZXI7Cit9CisKIHN0YXRpYyBpbmxpbmUgdm9pZCBzZXRfY29tcG91bmRfb3JkZXIoc3RydWN0IHBhZ2UgKnBhZ2UsIHVuc2lnbmVkIGxvbmcgb3JkZXIpCiB7CiAJcGFnZVsxXS5scnUucHJldiA9ICh2b2lkICopb3JkZXI7CiB9CiAKKyNpZmRlZiBDT05GSUdfTU1VCisvKgorICogRG8gcHRlX21rd3JpdGUsIGJ1dCBvbmx5IGlmIHRoZSB2bWEgc2F5cyBWTV9XUklURS4gIFdlIGRvIHRoaXMgd2hlbgorICogc2VydmljaW5nIGZhdWx0cyBmb3Igd3JpdGUgYWNjZXNzLiAgSW4gdGhlIG5vcm1hbCBjYXNlLCBkbyBhbHdheXMgd2FudAorICogcHRlX21rd3JpdGUuICBCdXQgZ2V0X3VzZXJfcGFnZXMgY2FuIGNhdXNlIHdyaXRlIGZhdWx0cyBmb3IgbWFwcGluZ3MKKyAqIHRoYXQgZG8gbm90IGhhdmUgd3JpdGluZyBlbmFibGVkLCB3aGVuIHVzZWQgYnkgYWNjZXNzX3Byb2Nlc3Nfdm0uCisgKi8KK3N0YXRpYyBpbmxpbmUgcHRlX3QgbWF5YmVfbWt3cml0ZShwdGVfdCBwdGUsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQoreworCWlmIChsaWtlbHkodm1hLT52bV9mbGFncyAmIFZNX1dSSVRFKSkKKwkJcHRlID0gcHRlX21rd3JpdGUocHRlKTsKKwlyZXR1cm4gcHRlOworfQorI2VuZGlmCisKIC8qCiAgKiBNdWx0aXBsZSBwcm9jZXNzZXMgbWF5ICJzZWUiIHRoZSBzYW1lIHBhZ2UuIEUuZy4gZm9yIHVudG91Y2hlZAogICogbWFwcGluZ3Mgb2YgL2Rldi9udWxsLCBhbGwgcHJvY2Vzc2VzIHNlZSB0aGUgc2FtZSBwYWdlIGZ1bGwgb2YKQEAgLTY1Nyw3ICs3NjcsNyBAQAogCVZNX0JVR19PTihQYWdlU2xhYihwYWdlKSk7CiAJaWYgKHVubGlrZWx5KFBhZ2VTd2FwQ2FjaGUocGFnZSkpKQogCQltYXBwaW5nID0gJnN3YXBwZXJfc3BhY2U7Ci0JZWxzZSBpZiAodW5saWtlbHkoKHVuc2lnbmVkIGxvbmcpbWFwcGluZyAmIFBBR0VfTUFQUElOR19BTk9OKSkKKwllbHNlIGlmICgodW5zaWduZWQgbG9uZyltYXBwaW5nICYgUEFHRV9NQVBQSU5HX0FOT04pCiAJCW1hcHBpbmcgPSBOVUxMOwogCXJldHVybiBtYXBwaW5nOwogfQpAQCAtMTA2NCw3ICsxMTc0LDggQEAKIGludCBfX3BtZF9hbGxvYyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwgcHVkX3QgKnB1ZCwgdW5zaWduZWQgbG9uZyBhZGRyZXNzKTsKICNlbmRpZgogCi1pbnQgX19wdGVfYWxsb2Moc3RydWN0IG1tX3N0cnVjdCAqbW0sIHBtZF90ICpwbWQsIHVuc2lnbmVkIGxvbmcgYWRkcmVzcyk7CitpbnQgX19wdGVfYWxsb2Moc3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQlwbWRfdCAqcG1kLCB1bnNpZ25lZCBsb25nIGFkZHJlc3MpOwogaW50IF9fcHRlX2FsbG9jX2tlcm5lbChwbWRfdCAqcG1kLCB1bnNpZ25lZCBsb25nIGFkZHJlc3MpOwogCiAvKgpAQCAtMTEzMywxNiArMTI0NCwxOCBAQAogCXB0ZV91bm1hcChwdGUpOwkJCQkJXAogfSB3aGlsZSAoMCkKIAotI2RlZmluZSBwdGVfYWxsb2NfbWFwKG1tLCBwbWQsIGFkZHJlc3MpCQkJXAotCSgodW5saWtlbHkoIXBtZF9wcmVzZW50KCoocG1kKSkpICYmIF9fcHRlX2FsbG9jKG1tLCBwbWQsIGFkZHJlc3MpKT8gXAotCQlOVUxMOiBwdGVfb2Zmc2V0X21hcChwbWQsIGFkZHJlc3MpKQorI2RlZmluZSBwdGVfYWxsb2NfbWFwKG1tLCB2bWEsIHBtZCwgYWRkcmVzcykJCQkJXAorCSgodW5saWtlbHkocG1kX25vbmUoKihwbWQpKSkgJiYgX19wdGVfYWxsb2MobW0sIHZtYSwJXAorCQkJCQkJCXBtZCwgYWRkcmVzcykpPwlcCisJIE5VTEw6IHB0ZV9vZmZzZXRfbWFwKHBtZCwgYWRkcmVzcykpCiAKICNkZWZpbmUgcHRlX2FsbG9jX21hcF9sb2NrKG1tLCBwbWQsIGFkZHJlc3MsIHB0bHApCVwKLQkoKHVubGlrZWx5KCFwbWRfcHJlc2VudCgqKHBtZCkpKSAmJiBfX3B0ZV9hbGxvYyhtbSwgcG1kLCBhZGRyZXNzKSk/IFwKKwkoKHVubGlrZWx5KHBtZF9ub25lKCoocG1kKSkpICYmIF9fcHRlX2FsbG9jKG1tLCBOVUxMLAlcCisJCQkJCQkJcG1kLCBhZGRyZXNzKSk/CVwKIAkJTlVMTDogcHRlX29mZnNldF9tYXBfbG9jayhtbSwgcG1kLCBhZGRyZXNzLCBwdGxwKSkKIAogI2RlZmluZSBwdGVfYWxsb2Nfa2VybmVsKHBtZCwgYWRkcmVzcykJCQlcCi0JKCh1bmxpa2VseSghcG1kX3ByZXNlbnQoKihwbWQpKSkgJiYgX19wdGVfYWxsb2Nfa2VybmVsKHBtZCwgYWRkcmVzcykpPyBcCisJKCh1bmxpa2VseShwbWRfbm9uZSgqKHBtZCkpKSAmJiBfX3B0ZV9hbGxvY19rZXJuZWwocG1kLCBhZGRyZXNzKSk/IFwKIAkJTlVMTDogcHRlX29mZnNldF9rZXJuZWwocG1kLCBhZGRyZXNzKSkKIAogZXh0ZXJuIHZvaWQgZnJlZV9hcmVhX2luaXQodW5zaWduZWQgbG9uZyAqIHpvbmVzX3NpemUpOwpAQCAtMTQxNSw2ICsxNTI4LDggQEAKICNkZWZpbmUgRk9MTF9HRVQJMHgwNAkvKiBkbyBnZXRfcGFnZSBvbiBwYWdlICovCiAjZGVmaW5lIEZPTExfRFVNUAkweDA4CS8qIGdpdmUgZXJyb3Igb24gaG9sZSBpZiBpdCB3b3VsZCBiZSB6ZXJvICovCiAjZGVmaW5lIEZPTExfRk9SQ0UJMHgxMAkvKiBnZXRfdXNlcl9wYWdlcyByZWFkL3dyaXRlIHcvbyBwZXJtaXNzaW9uICovCisjZGVmaW5lIEZPTExfTUxPQ0sJMHg0MAkvKiBtYXJrIHBhZ2UgYXMgbWxvY2tlZCAqLworI2RlZmluZSBGT0xMX1NQTElUCTB4ODAJLyogZG9uJ3QgcmV0dXJuIHRyYW5zaHVnZSBwYWdlcywgc3BsaXQgdGhlbSAqLwogCiB0eXBlZGVmIGludCAoKnB0ZV9mbl90KShwdGVfdCAqcHRlLCBwZ3RhYmxlX3QgdG9rZW4sIHVuc2lnbmVkIGxvbmcgYWRkciwKIAkJCXZvaWQgKmRhdGEpOwpAQCAtMTUxOCw1ICsxNjMzLDE0IEBACiAKIGV4dGVybiB2b2lkIGR1bXBfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSk7CiAKKyNpZiBkZWZpbmVkKENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRSkgfHwgZGVmaW5lZChDT05GSUdfSFVHRVRMQkZTKQorZXh0ZXJuIHZvaWQgY2xlYXJfaHVnZV9wYWdlKHN0cnVjdCBwYWdlICpwYWdlLAorCQkJICAgIHVuc2lnbmVkIGxvbmcgYWRkciwKKwkJCSAgICB1bnNpZ25lZCBpbnQgcGFnZXNfcGVyX2h1Z2VfcGFnZSk7CitleHRlcm4gdm9pZCBjb3B5X3VzZXJfaHVnZV9wYWdlKHN0cnVjdCBwYWdlICpkc3QsIHN0cnVjdCBwYWdlICpzcmMsCisJCQkJdW5zaWduZWQgbG9uZyBhZGRyLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCQl1bnNpZ25lZCBpbnQgcGFnZXNfcGVyX2h1Z2VfcGFnZSk7CisjZW5kaWYgLyogQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFIHx8IENPTkZJR19IVUdFVExCRlMgKi8KKwogI2VuZGlmIC8qIF9fS0VSTkVMX18gKi8KICNlbmRpZiAvKiBfTElOVVhfTU1fSCAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tbV9pbmxpbmUuaCBiL2luY2x1ZGUvbGludXgvbW1faW5saW5lLmgKaW5kZXggODgzNWI4Ny4uOGY3ZDI0NyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tbV9pbmxpbmUuaAorKysgYi9pbmNsdWRlL2xpbnV4L21tX2lubGluZS5oCkBAIC0xLDYgKzEsOCBAQAogI2lmbmRlZiBMSU5VWF9NTV9JTkxJTkVfSAogI2RlZmluZSBMSU5VWF9NTV9JTkxJTkVfSAogCisjaW5jbHVkZSA8bGludXgvaHVnZV9tbS5oPgorCiAvKioKICAqIHBhZ2VfaXNfZmlsZV9jYWNoZSAtIHNob3VsZCB0aGUgcGFnZSBiZSBvbiBhIGZpbGUgTFJVIG9yIGFub24gTFJVPwogICogQHBhZ2U6IHRoZSBwYWdlIHRvIHRlc3QKQEAgLTIwLDE4ICsyMiwyNSBAQAogfQogCiBzdGF0aWMgaW5saW5lIHZvaWQKK19fYWRkX3BhZ2VfdG9fbHJ1X2xpc3Qoc3RydWN0IHpvbmUgKnpvbmUsIHN0cnVjdCBwYWdlICpwYWdlLCBlbnVtIGxydV9saXN0IGwsCisJCSAgICAgICBzdHJ1Y3QgbGlzdF9oZWFkICpoZWFkKQoreworCWxpc3RfYWRkKCZwYWdlLT5scnUsIGhlYWQpOworCV9fbW9kX3pvbmVfcGFnZV9zdGF0ZSh6b25lLCBOUl9MUlVfQkFTRSArIGwsIGhwYWdlX25yX3BhZ2VzKHBhZ2UpKTsKKwltZW1fY2dyb3VwX2FkZF9scnVfbGlzdChwYWdlLCBsKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkCiBhZGRfcGFnZV90b19scnVfbGlzdChzdHJ1Y3Qgem9uZSAqem9uZSwgc3RydWN0IHBhZ2UgKnBhZ2UsIGVudW0gbHJ1X2xpc3QgbCkKIHsKLQlsaXN0X2FkZCgmcGFnZS0+bHJ1LCAmem9uZS0+bHJ1W2xdLmxpc3QpOwotCV9faW5jX3pvbmVfc3RhdGUoem9uZSwgTlJfTFJVX0JBU0UgKyBsKTsKLQltZW1fY2dyb3VwX2FkZF9scnVfbGlzdChwYWdlLCBsKTsKKwlfX2FkZF9wYWdlX3RvX2xydV9saXN0KHpvbmUsIHBhZ2UsIGwsICZ6b25lLT5scnVbbF0ubGlzdCk7CiB9CiAKIHN0YXRpYyBpbmxpbmUgdm9pZAogZGVsX3BhZ2VfZnJvbV9scnVfbGlzdChzdHJ1Y3Qgem9uZSAqem9uZSwgc3RydWN0IHBhZ2UgKnBhZ2UsIGVudW0gbHJ1X2xpc3QgbCkKIHsKIAlsaXN0X2RlbCgmcGFnZS0+bHJ1KTsKLQlfX2RlY196b25lX3N0YXRlKHpvbmUsIE5SX0xSVV9CQVNFICsgbCk7CisJX19tb2Rfem9uZV9wYWdlX3N0YXRlKHpvbmUsIE5SX0xSVV9CQVNFICsgbCwgLWhwYWdlX25yX3BhZ2VzKHBhZ2UpKTsKIAltZW1fY2dyb3VwX2RlbF9scnVfbGlzdChwYWdlLCBsKTsKIH0KIApAQCAtNjYsNyArNzUsNyBAQAogCQkJbCArPSBMUlVfQUNUSVZFOwogCQl9CiAJfQotCV9fZGVjX3pvbmVfc3RhdGUoem9uZSwgTlJfTFJVX0JBU0UgKyBsKTsKKwlfX21vZF96b25lX3BhZ2Vfc3RhdGUoem9uZSwgTlJfTFJVX0JBU0UgKyBsLCAtaHBhZ2VfbnJfcGFnZXMocGFnZSkpOwogCW1lbV9jZ3JvdXBfZGVsX2xydV9saXN0KHBhZ2UsIGwpOwogfQogCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tX3R5cGVzLmggYi9pbmNsdWRlL2xpbnV4L21tX3R5cGVzLmgKaW5kZXggYmI3Mjg4YS4uMjZiYzRlMiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tbV90eXBlcy5oCisrKyBiL2luY2x1ZGUvbGludXgvbW1fdHlwZXMuaApAQCAtMzEwLDYgKzMxMCw5IEBACiAjaWZkZWYgQ09ORklHX01NVV9OT1RJRklFUgogCXN0cnVjdCBtbXVfbm90aWZpZXJfbW0gKm1tdV9ub3RpZmllcl9tbTsKICNlbmRpZgorI2lmZGVmIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRQorCXBndGFibGVfdCBwbWRfaHVnZV9wdGU7IC8qIHByb3RlY3RlZCBieSBwYWdlX3RhYmxlX2xvY2sgKi8KKyNlbmRpZgogCS8qIEhvdyBtYW55IHRhc2tzIHNoYXJpbmcgdGhpcyBtbSBhcmUgT09NX0RJU0FCTEUgKi8KIAlhdG9taWNfdCBvb21fZGlzYWJsZV9jb3VudDsKIH07CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tYy9zaF9tbWNpZi5oIGIvaW5jbHVkZS9saW51eC9tbWMvc2hfbW1jaWYuaAppbmRleCBiZjE3MzUwLi4zOGQzOTMwIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21tYy9zaF9tbWNpZi5oCisrKyBiL2luY2x1ZGUvbGludXgvbW1jL3NoX21tY2lmLmgKQEAgLTk0LDEyICs5NCwxMiBAQAogCiBzdGF0aWMgaW5saW5lIHUzMiBzaF9tbWNpZl9yZWFkbCh2b2lkIF9faW9tZW0gKmFkZHIsIGludCByZWcpCiB7Ci0JcmV0dXJuIHJlYWRsKGFkZHIgKyByZWcpOworCXJldHVybiBfX3Jhd19yZWFkbChhZGRyICsgcmVnKTsKIH0KIAogc3RhdGljIGlubGluZSB2b2lkIHNoX21tY2lmX3dyaXRlbCh2b2lkIF9faW9tZW0gKmFkZHIsIGludCByZWcsIHUzMiB2YWwpCiB7Ci0Jd3JpdGVsKHZhbCwgYWRkciArIHJlZyk7CisJX19yYXdfd3JpdGVsKHZhbCwgYWRkciArIHJlZyk7CiB9CiAKICNkZWZpbmUgU0hfTU1DSUZfQkJTIDUxMiAvKiBib290IGJsb2NrIHNpemUgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbW11X25vdGlmaWVyLmggYi9pbmNsdWRlL2xpbnV4L21tdV9ub3RpZmllci5oCmluZGV4IDQzZGNmYmQuLmNjMmU3ZGYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbW11X25vdGlmaWVyLmgKKysrIGIvaW5jbHVkZS9saW51eC9tbXVfbm90aWZpZXIuaApAQCAtNjIsNiArNjIsMTYgQEAKIAkJCQkgdW5zaWduZWQgbG9uZyBhZGRyZXNzKTsKIAogCS8qCisJICogdGVzdF95b3VuZyBpcyBjYWxsZWQgdG8gY2hlY2sgdGhlIHlvdW5nL2FjY2Vzc2VkIGJpdGZsYWcgaW4KKwkgKiB0aGUgc2Vjb25kYXJ5IHB0ZS4gVGhpcyBpcyB1c2VkIHRvIGtub3cgaWYgdGhlIHBhZ2UgaXMKKwkgKiBmcmVxdWVudGx5IHVzZWQgd2l0aG91dCBhY3R1YWxseSBjbGVhcmluZyB0aGUgZmxhZyBvciB0ZWFyaW5nCisJICogZG93biB0aGUgc2Vjb25kYXJ5IG1hcHBpbmcgb24gdGhlIHBhZ2UuCisJICovCisJaW50ICgqdGVzdF95b3VuZykoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sCisJCQkgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJICB1bnNpZ25lZCBsb25nIGFkZHJlc3MpOworCisJLyoKIAkgKiBjaGFuZ2VfcHRlIGlzIGNhbGxlZCBpbiBjYXNlcyB0aGF0IHB0ZSBtYXBwaW5nIHRvIHBhZ2UgaXMgY2hhbmdlZDoKIAkgKiBmb3IgZXhhbXBsZSwgd2hlbiBrc20gcmVtYXBzIHB0ZSB0byBwb2ludCB0byBhIG5ldyBzaGFyZWQgcGFnZS4KIAkgKi8KQEAgLTE2Myw2ICsxNzMsOCBAQAogZXh0ZXJuIHZvaWQgX19tbXVfbm90aWZpZXJfcmVsZWFzZShzdHJ1Y3QgbW1fc3RydWN0ICptbSk7CiBleHRlcm4gaW50IF9fbW11X25vdGlmaWVyX2NsZWFyX2ZsdXNoX3lvdW5nKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAogCQkJCQkgIHVuc2lnbmVkIGxvbmcgYWRkcmVzcyk7CitleHRlcm4gaW50IF9fbW11X25vdGlmaWVyX3Rlc3RfeW91bmcoc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkJICAgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MpOwogZXh0ZXJuIHZvaWQgX19tbXVfbm90aWZpZXJfY2hhbmdlX3B0ZShzdHJ1Y3QgbW1fc3RydWN0ICptbSwKIAkJCQkgICAgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsIHB0ZV90IHB0ZSk7CiBleHRlcm4gdm9pZCBfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3BhZ2Uoc3RydWN0IG1tX3N0cnVjdCAqbW0sCkBAIC0xODYsNiArMTk4LDE0IEBACiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyBpbmxpbmUgaW50IG1tdV9ub3RpZmllcl90ZXN0X3lvdW5nKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJCQkgIHVuc2lnbmVkIGxvbmcgYWRkcmVzcykKK3sKKwlpZiAobW1faGFzX25vdGlmaWVycyhtbSkpCisJCXJldHVybiBfX21tdV9ub3RpZmllcl90ZXN0X3lvdW5nKG1tLCBhZGRyZXNzKTsKKwlyZXR1cm4gMDsKK30KKwogc3RhdGljIGlubGluZSB2b2lkIG1tdV9ub3RpZmllcl9jaGFuZ2VfcHRlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAogCQkJCQkgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsIHB0ZV90IHB0ZSkKIHsKQEAgLTI0Myw2ICsyNjMsMzIgQEAKIAlfX3B0ZTsJCQkJCQkJCVwKIH0pCiAKKyNkZWZpbmUgcG1kcF9jbGVhcl9mbHVzaF9ub3RpZnkoX192bWEsIF9fYWRkcmVzcywgX19wbWRwKQkJXAorKHsJCQkJCQkJCQlcCisJcG1kX3QgX19wbWQ7CQkJCQkJCVwKKwlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKl9fX3ZtYSA9IF9fdm1hOwkJCQlcCisJdW5zaWduZWQgbG9uZyBfX19hZGRyZXNzID0gX19hZGRyZXNzOwkJCQlcCisJVk1fQlVHX09OKF9fYWRkcmVzcyAmIH5IUEFHRV9QTURfTUFTSyk7CQkJCVwKKwltbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9zdGFydChfX192bWEtPnZtX21tLCBfX19hZGRyZXNzLAlcCisJCQkJCSAgICAoX19hZGRyZXNzKStIUEFHRV9QTURfU0laRSk7XAorCV9fcG1kID0gcG1kcF9jbGVhcl9mbHVzaChfX192bWEsIF9fX2FkZHJlc3MsIF9fcG1kcCk7CQlcCisJbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2VfZW5kKF9fX3ZtYS0+dm1fbW0sIF9fX2FkZHJlc3MsCVwKKwkJCQkJICAoX19hZGRyZXNzKStIUEFHRV9QTURfU0laRSk7CVwKKwlfX3BtZDsJCQkJCQkJCVwKK30pCisKKyNkZWZpbmUgcG1kcF9zcGxpdHRpbmdfZmx1c2hfbm90aWZ5KF9fdm1hLCBfX2FkZHJlc3MsIF9fcG1kcCkJCVwKKyh7CQkJCQkJCQkJXAorCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqX19fdm1hID0gX192bWE7CQkJCVwKKwl1bnNpZ25lZCBsb25nIF9fX2FkZHJlc3MgPSBfX2FkZHJlc3M7CQkJCVwKKwlWTV9CVUdfT04oX19hZGRyZXNzICYgfkhQQUdFX1BNRF9NQVNLKTsJCQkJXAorCW1tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KF9fX3ZtYS0+dm1fbW0sIF9fX2FkZHJlc3MsCVwKKwkJCQkJICAgIChfX2FkZHJlc3MpK0hQQUdFX1BNRF9TSVpFKTtcCisJcG1kcF9zcGxpdHRpbmdfZmx1c2goX19fdm1hLCBfX19hZGRyZXNzLCBfX3BtZHApOwkJXAorCW1tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX2VuZChfX192bWEtPnZtX21tLCBfX19hZGRyZXNzLAlcCisJCQkJCSAgKF9fYWRkcmVzcykrSFBBR0VfUE1EX1NJWkUpOwlcCit9KQorCiAjZGVmaW5lIHB0ZXBfY2xlYXJfZmx1c2hfeW91bmdfbm90aWZ5KF9fdm1hLCBfX2FkZHJlc3MsIF9fcHRlcCkJCVwKICh7CQkJCQkJCQkJXAogCWludCBfX3lvdW5nOwkJCQkJCQlcCkBAIC0yNTQsNiArMzAwLDE3IEBACiAJX195b3VuZzsJCQkJCQkJXAogfSkKIAorI2RlZmluZSBwbWRwX2NsZWFyX2ZsdXNoX3lvdW5nX25vdGlmeShfX3ZtYSwgX19hZGRyZXNzLCBfX3BtZHApCQlcCisoewkJCQkJCQkJCVwKKwlpbnQgX195b3VuZzsJCQkJCQkJXAorCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqX19fdm1hID0gX192bWE7CQkJCVwKKwl1bnNpZ25lZCBsb25nIF9fX2FkZHJlc3MgPSBfX2FkZHJlc3M7CQkJCVwKKwlfX3lvdW5nID0gcG1kcF9jbGVhcl9mbHVzaF95b3VuZyhfX192bWEsIF9fX2FkZHJlc3MsIF9fcG1kcCk7CVwKKwlfX3lvdW5nIHw9IG1tdV9ub3RpZmllcl9jbGVhcl9mbHVzaF95b3VuZyhfX192bWEtPnZtX21tLAlcCisJCQkJCQkgIF9fX2FkZHJlc3MpOwkJXAorCV9feW91bmc7CQkJCQkJCVwKK30pCisKICNkZWZpbmUgc2V0X3B0ZV9hdF9ub3RpZnkoX19tbSwgX19hZGRyZXNzLCBfX3B0ZXAsIF9fcHRlKQkJXAogKHsJCQkJCQkJCQlcCiAJc3RydWN0IG1tX3N0cnVjdCAqX19fbW0gPSBfX21tOwkJCQkJXApAQCAtMjc2LDYgKzMzMywxMiBAQAogCXJldHVybiAwOwogfQogCitzdGF0aWMgaW5saW5lIGludCBtbXVfbm90aWZpZXJfdGVzdF95b3VuZyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwKKwkJCQkJICB1bnNpZ25lZCBsb25nIGFkZHJlc3MpCit7CisJcmV0dXJuIDA7Cit9CisKIHN0YXRpYyBpbmxpbmUgdm9pZCBtbXVfbm90aWZpZXJfY2hhbmdlX3B0ZShzdHJ1Y3QgbW1fc3RydWN0ICptbSwKIAkJCQkJICAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwdGVfdCBwdGUpCiB7CkBAIC0zMDUsNyArMzY4LDEwIEBACiB9CiAKICNkZWZpbmUgcHRlcF9jbGVhcl9mbHVzaF95b3VuZ19ub3RpZnkgcHRlcF9jbGVhcl9mbHVzaF95b3VuZworI2RlZmluZSBwbWRwX2NsZWFyX2ZsdXNoX3lvdW5nX25vdGlmeSBwbWRwX2NsZWFyX2ZsdXNoX3lvdW5nCiAjZGVmaW5lIHB0ZXBfY2xlYXJfZmx1c2hfbm90aWZ5IHB0ZXBfY2xlYXJfZmx1c2gKKyNkZWZpbmUgcG1kcF9jbGVhcl9mbHVzaF9ub3RpZnkgcG1kcF9jbGVhcl9mbHVzaAorI2RlZmluZSBwbWRwX3NwbGl0dGluZ19mbHVzaF9ub3RpZnkgcG1kcF9zcGxpdHRpbmdfZmx1c2gKICNkZWZpbmUgc2V0X3B0ZV9hdF9ub3RpZnkgc2V0X3B0ZV9hdAogCiAjZW5kaWYgLyogQ09ORklHX01NVV9OT1RJRklFUiAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tbXpvbmUuaCBiL2luY2x1ZGUvbGludXgvbW16b25lLmgKaW5kZXggNTJmOTZkNy4uZTU2ZjgzNSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tbXpvbmUuaAorKysgYi9pbmNsdWRlL2xpbnV4L21tem9uZS5oCkBAIC0xMTQsNiArMTE0LDcgQEAKIAlOVU1BX0xPQ0FMLAkJLyogYWxsb2NhdGlvbiBmcm9tIGxvY2FsIG5vZGUgKi8KIAlOVU1BX09USEVSLAkJLyogYWxsb2NhdGlvbiBmcm9tIG90aGVyIG5vZGUgKi8KICNlbmRpZgorCU5SX0FOT05fVFJBTlNQQVJFTlRfSFVHRVBBR0VTLAogCU5SX1ZNX1pPTkVfU1RBVF9JVEVNUyB9OwogCiAvKgpAQCAtNDU4LDEyICs0NTksNiBAQAogCXJldHVybiB0ZXN0X2JpdChaT05FX09PTV9MT0NLRUQsICZ6b25lLT5mbGFncyk7CiB9CiAKLSNpZmRlZiBDT05GSUdfU01QCi11bnNpZ25lZCBsb25nIHpvbmVfbnJfZnJlZV9wYWdlcyhzdHJ1Y3Qgem9uZSAqem9uZSk7Ci0jZWxzZQotI2RlZmluZSB6b25lX25yX2ZyZWVfcGFnZXMoem9uZSkgem9uZV9wYWdlX3N0YXRlKHpvbmUsIE5SX0ZSRUVfUEFHRVMpCi0jZW5kaWYgLyogQ09ORklHX1NNUCAqLwotCiAvKgogICogVGhlICJwcmlvcml0eSIgb2YgVk0gc2Nhbm5pbmcgaXMgaG93IG11Y2ggb2YgdGhlIHF1ZXVlcyB3ZSB3aWxsIHNjYW4gaW4gb25lCiAgKiBnby4gQSB2YWx1ZSBvZiAxMiBmb3IgREVGX1BSSU9SSVRZIGltcGxpZXMgdGhhdCB3ZSB3aWxsIHNjYW4gMS80MDk2dGggb2YgdGhlCkBAIC02NDUsNiArNjQwLDcgQEAKIAl3YWl0X3F1ZXVlX2hlYWRfdCBrc3dhcGRfd2FpdDsKIAlzdHJ1Y3QgdGFza19zdHJ1Y3QgKmtzd2FwZDsKIAlpbnQga3N3YXBkX21heF9vcmRlcjsKKwllbnVtIHpvbmVfdHlwZSBjbGFzc3pvbmVfaWR4OwogfSBwZ19kYXRhX3Q7CiAKICNkZWZpbmUgbm9kZV9wcmVzZW50X3BhZ2VzKG5pZCkJKE5PREVfREFUQShuaWQpLT5ub2RlX3ByZXNlbnRfcGFnZXMpCkBAIC02NjAsOCArNjU2LDEwIEBACiAKIGV4dGVybiBzdHJ1Y3QgbXV0ZXggem9uZWxpc3RzX211dGV4Owogdm9pZCBidWlsZF9hbGxfem9uZWxpc3RzKHZvaWQgKmRhdGEpOwotdm9pZCB3YWtldXBfa3N3YXBkKHN0cnVjdCB6b25lICp6b25lLCBpbnQgb3JkZXIpOwotaW50IHpvbmVfd2F0ZXJtYXJrX29rKHN0cnVjdCB6b25lICp6LCBpbnQgb3JkZXIsIHVuc2lnbmVkIGxvbmcgbWFyaywKK3ZvaWQgd2FrZXVwX2tzd2FwZChzdHJ1Y3Qgem9uZSAqem9uZSwgaW50IG9yZGVyLCBlbnVtIHpvbmVfdHlwZSBjbGFzc3pvbmVfaWR4KTsKK2Jvb2wgem9uZV93YXRlcm1hcmtfb2soc3RydWN0IHpvbmUgKnosIGludCBvcmRlciwgdW5zaWduZWQgbG9uZyBtYXJrLAorCQlpbnQgY2xhc3N6b25lX2lkeCwgaW50IGFsbG9jX2ZsYWdzKTsKK2Jvb2wgem9uZV93YXRlcm1hcmtfb2tfc2FmZShzdHJ1Y3Qgem9uZSAqeiwgaW50IG9yZGVyLCB1bnNpZ25lZCBsb25nIG1hcmssCiAJCWludCBjbGFzc3pvbmVfaWR4LCBpbnQgYWxsb2NfZmxhZ3MpOwogZW51bSBtZW1tYXBfY29udGV4dCB7CiAJTUVNTUFQX0VBUkxZLApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tb2R1bGUuaCBiL2luY2x1ZGUvbGludXgvbW9kdWxlLmgKaW5kZXggOGIxN2ZkOC4uOWJkZjI3YyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tb2R1bGUuaAorKysgYi9pbmNsdWRlL2xpbnV4L21vZHVsZS5oCkBAIC01OCw2ICs1OCwxMiBAQAogCXZvaWQgKCpmcmVlKShzdHJ1Y3QgbW9kdWxlICopOwogfTsKIAorc3RydWN0IG1vZHVsZV92ZXJzaW9uX2F0dHJpYnV0ZSB7CisJc3RydWN0IG1vZHVsZV9hdHRyaWJ1dGUgbWF0dHI7CisJY29uc3QgY2hhciAqbW9kdWxlX25hbWU7CisJY29uc3QgY2hhciAqdmVyc2lvbjsKK307CisKIHN0cnVjdCBtb2R1bGVfa29iamVjdAogewogCXN0cnVjdCBrb2JqZWN0IGtvYmo7CkBAIC0xNjEsNyArMTY3LDI4IEBACiAgIFVzaW5nIHRoaXMgYXV0b21hdGljYWxseSBhZGRzIGEgY2hlY2tzdW0gb2YgdGhlIC5jIGZpbGVzIGFuZCB0aGUKICAgbG9jYWwgaGVhZGVycyBpbiAic3JjdmVyc2lvbiIuCiAqLworCisjaWYgZGVmaW5lZChNT0RVTEUpIHx8ICFkZWZpbmVkKENPTkZJR19TWVNGUykKICNkZWZpbmUgTU9EVUxFX1ZFUlNJT04oX3ZlcnNpb24pIE1PRFVMRV9JTkZPKHZlcnNpb24sIF92ZXJzaW9uKQorI2Vsc2UKKyNkZWZpbmUgTU9EVUxFX1ZFUlNJT04oX3ZlcnNpb24pCQkJCQlcCisJZXh0ZXJuIHNzaXplX3QgX19tb2R2ZXJfdmVyc2lvbl9zaG93KHN0cnVjdCBtb2R1bGVfYXR0cmlidXRlICosCVwKKwkJCQkJICAgICBzdHJ1Y3QgbW9kdWxlICosIGNoYXIgKik7CVwKKwlzdGF0aWMgc3RydWN0IG1vZHVsZV92ZXJzaW9uX2F0dHJpYnV0ZSBfX21vZHZlcl92ZXJzaW9uX2F0dHIJXAorCV9fdXNlZAkJCQkJCQkJXAorICAgIF9fYXR0cmlidXRlX18gKChfX3NlY3Rpb25fXyAoIl9fbW9kdmVyIiksYWxpZ25lZChzaXplb2Yodm9pZCAqKSkpKSBcCisJPSB7CQkJCQkJCQlcCisJCS5tYXR0cgk9IHsJCQkJCQlcCisJCQkuYXR0cgk9IHsJCQkJCVwKKwkJCQkubmFtZQk9ICJ2ZXJzaW9uIiwJCQlcCisJCQkJLm1vZGUJPSBTX0lSVUdPLAkJCVwKKwkJCX0sCQkJCQkJXAorCQkJLnNob3cJPSBfX21vZHZlcl92ZXJzaW9uX3Nob3csCQlcCisJCX0sCQkJCQkJCVwKKwkJLm1vZHVsZV9uYW1lCT0gS0JVSUxEX01PRE5BTUUsCQkJXAorCQkudmVyc2lvbgk9IF92ZXJzaW9uLAkJCQlcCisJfQorI2VuZGlmCiAKIC8qIE9wdGlvbmFsIGZpcm13YXJlIGZpbGUgKG9yIGZpbGVzKSBuZWVkZWQgYnkgdGhlIG1vZHVsZQogICogZm9ybWF0IGlzIHNpbXBseSBmaXJtd2FyZSBmaWxlIG5hbWUuICBNdWx0aXBsZSBmaXJtd2FyZQpAQCAtMzUwLDcgKzM3Nyw3IEBACiAJICAga2VlcGluZyBwb2ludGVycyB0byB0aGlzIHN0dWZmICovCiAJY2hhciAqYXJnczsKICNpZmRlZiBDT05GSUdfVFJBQ0VQT0lOVFMKLQlzdHJ1Y3QgdHJhY2Vwb2ludCAqdHJhY2Vwb2ludHM7CisJc3RydWN0IHRyYWNlcG9pbnQgKiBjb25zdCAqdHJhY2Vwb2ludHNfcHRyczsKIAl1bnNpZ25lZCBpbnQgbnVtX3RyYWNlcG9pbnRzOwogI2VuZGlmCiAjaWZkZWYgSEFWRV9KVU1QX0xBQkVMCkBAIC0zNjIsNyArMzg5LDcgQEAKIAl1bnNpZ25lZCBpbnQgbnVtX3RyYWNlX2JwcmludGtfZm10OwogI2VuZGlmCiAjaWZkZWYgQ09ORklHX0VWRU5UX1RSQUNJTkcKLQlzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgKnRyYWNlX2V2ZW50czsKKwlzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgKip0cmFjZV9ldmVudHM7CiAJdW5zaWduZWQgaW50IG51bV90cmFjZV9ldmVudHM7CiAjZW5kaWYKICNpZmRlZiBDT05GSUdfRlRSQUNFX01DT1VOVF9SRUNPUkQKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbW9kdWxlcGFyYW0uaCBiL2luY2x1ZGUvbGludXgvbW9kdWxlcGFyYW0uaAppbmRleCAxMTJhZGY4Li4wN2I0MTk1IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21vZHVsZXBhcmFtLmgKKysrIGIvaW5jbHVkZS9saW51eC9tb2R1bGVwYXJhbS5oCkBAIC0xNiwxNSArMTYsMTcgQEAKIC8qIENob3NlbiBzbyB0aGF0IHN0cnVjdHMgd2l0aCBhbiB1bnNpZ25lZCBsb25nIGxpbmUgdXAuICovCiAjZGVmaW5lIE1BWF9QQVJBTV9QUkVGSVhfTEVOICg2NCAtIHNpemVvZih1bnNpZ25lZCBsb25nKSkKIAotI2lmZGVmIE1PRFVMRQogI2RlZmluZSBfX19tb2R1bGVfY2F0KGEsYikgX19tb2RfICMjIGEgIyMgYgogI2RlZmluZSBfX21vZHVsZV9jYXQoYSxiKSBfX19tb2R1bGVfY2F0KGEsYikKKyNpZmRlZiBNT0RVTEUKICNkZWZpbmUgX19NT0RVTEVfSU5GTyh0YWcsIG5hbWUsIGluZm8pCQkJCQkgIFwKIHN0YXRpYyBjb25zdCBjaGFyIF9fbW9kdWxlX2NhdChuYW1lLF9fTElORV9fKVtdCQkJCSAgXAogICBfX3VzZWQgX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiLm1vZGluZm8iKSwgdW51c2VkLCBhbGlnbmVkKDEpKSkJICBcCiAgID0gX19zdHJpbmdpZnkodGFnKSAiPSIgaW5mbwogI2Vsc2UgIC8qICFNT0RVTEUgKi8KLSNkZWZpbmUgX19NT0RVTEVfSU5GTyh0YWcsIG5hbWUsIGluZm8pCisvKiBUaGlzIHN0cnVjdCBpcyBoZXJlIGZvciBzeW50YWN0aWMgY29oZXJlbmN5LCBpdCBpcyBub3QgdXNlZCAqLworI2RlZmluZSBfX01PRFVMRV9JTkZPKHRhZywgbmFtZSwgaW5mbykJCQkJCSAgXAorICBzdHJ1Y3QgX19tb2R1bGVfY2F0KG5hbWUsX19MSU5FX18pIHt9CiAjZW5kaWYKICNkZWZpbmUgX19NT0RVTEVfUEFSTV9UWVBFKG5hbWUsIF90eXBlKQkJCQkJICBcCiAgIF9fTU9EVUxFX0lORk8ocGFybXR5cGUsIG5hbWUjI3R5cGUsICNuYW1lICI6IiBfdHlwZSkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbW91bnQuaCBiL2luY2x1ZGUvbGludXgvbW91bnQuaAppbmRleCAxODY5ZWEyLi42MDRmMTIyIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21vdW50LmgKKysrIGIvaW5jbHVkZS9saW51eC9tb3VudC5oCkBAIC02MCw3ICs2MCw3IEBACiAJc3RydWN0IHN1cGVyX2Jsb2NrICptbnRfc2I7CS8qIHBvaW50ZXIgdG8gc3VwZXJibG9jayAqLwogI2lmZGVmIENPTkZJR19TTVAKIAlzdHJ1Y3QgbW50X3BjcCBfX3BlcmNwdSAqbW50X3BjcDsKLQlhdG9taWNfdCBtbnRfbG9uZ3JlZnM7CisJYXRvbWljX3QgbW50X2xvbmd0ZXJtOwkJLyogaG93IG1hbnkgb2YgdGhlIHJlZnMgYXJlIGxvbmd0ZXJtICovCiAjZWxzZQogCWludCBtbnRfY291bnQ7CiAJaW50IG1udF93cml0ZXJzOwpAQCAtOTYsOCArOTYsNiBAQAogZXh0ZXJuIHZvaWQgbW50X2Ryb3Bfd3JpdGUoc3RydWN0IHZmc21vdW50ICptbnQpOwogZXh0ZXJuIHZvaWQgbW50cHV0KHN0cnVjdCB2ZnNtb3VudCAqbW50KTsKIGV4dGVybiBzdHJ1Y3QgdmZzbW91bnQgKm1udGdldChzdHJ1Y3QgdmZzbW91bnQgKm1udCk7Ci1leHRlcm4gdm9pZCBtbnRwdXRfbG9uZyhzdHJ1Y3QgdmZzbW91bnQgKm1udCk7Ci1leHRlcm4gc3RydWN0IHZmc21vdW50ICptbnRnZXRfbG9uZyhzdHJ1Y3QgdmZzbW91bnQgKm1udCk7CiBleHRlcm4gdm9pZCBtbnRfcGluKHN0cnVjdCB2ZnNtb3VudCAqbW50KTsKIGV4dGVybiB2b2lkIG1udF91bnBpbihzdHJ1Y3QgdmZzbW91bnQgKm1udCk7CiBleHRlcm4gaW50IF9fbW50X2lzX3JlYWRvbmx5KHN0cnVjdCB2ZnNtb3VudCAqbW50KTsKQEAgLTExMCwxMiArMTA4LDcgQEAKIAkJCQkgICAgICBpbnQgZmxhZ3MsIGNvbnN0IGNoYXIgKm5hbWUsCiAJCQkJICAgICAgdm9pZCAqZGF0YSk7CiAKLXN0cnVjdCBuYW1laWRhdGE7Ci0KLXN0cnVjdCBwYXRoOwotZXh0ZXJuIGludCBkb19hZGRfbW91bnQoc3RydWN0IHZmc21vdW50ICpuZXdtbnQsIHN0cnVjdCBwYXRoICpwYXRoLAotCQkJaW50IG1udF9mbGFncywgc3RydWN0IGxpc3RfaGVhZCAqZnNsaXN0KTsKLQorZXh0ZXJuIHZvaWQgbW50X3NldF9leHBpcnkoc3RydWN0IHZmc21vdW50ICptbnQsIHN0cnVjdCBsaXN0X2hlYWQgKmV4cGlyeV9saXN0KTsKIGV4dGVybiB2b2lkIG1hcmtfbW91bnRzX2Zvcl9leHBpcnkoc3RydWN0IGxpc3RfaGVhZCAqbW91bnRzKTsKIAogZXh0ZXJuIGRldl90IG5hbWVfdG9fZGV2X3QoY2hhciAqbmFtZSk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21yb3V0ZS5oIGIvaW5jbHVkZS9saW51eC9tcm91dGUuaAppbmRleCAwZmE3YTNhLi5iMjFkNTY3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21yb3V0ZS5oCisrKyBiL2luY2x1ZGUvbGludXgvbXJvdXRlLmgKQEAgLTE1MCw2ICsxNTAsNyBAQAogZXh0ZXJuIGludCBpcF9tcm91dGVfc2V0c29ja29wdChzdHJ1Y3Qgc29jayAqLCBpbnQsIGNoYXIgX191c2VyICosIHVuc2lnbmVkIGludCk7CiBleHRlcm4gaW50IGlwX21yb3V0ZV9nZXRzb2Nrb3B0KHN0cnVjdCBzb2NrICosIGludCwgY2hhciBfX3VzZXIgKiwgaW50IF9fdXNlciAqKTsKIGV4dGVybiBpbnQgaXBtcl9pb2N0bChzdHJ1Y3Qgc29jayAqc2ssIGludCBjbWQsIHZvaWQgX191c2VyICphcmcpOworZXh0ZXJuIGludCBpcG1yX2NvbXBhdF9pb2N0bChzdHJ1Y3Qgc29jayAqc2ssIHVuc2lnbmVkIGludCBjbWQsIHZvaWQgX191c2VyICphcmcpOwogZXh0ZXJuIGludCBpcF9tcl9pbml0KHZvaWQpOwogI2Vsc2UKIHN0YXRpYyBpbmxpbmUKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbXJvdXRlNi5oIGIvaW5jbHVkZS9saW51eC9tcm91dGU2LmgKaW5kZXggNjA5MWFiNy4uOWQyZGViMiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tcm91dGU2LmgKKysrIGIvaW5jbHVkZS9saW51eC9tcm91dGU2LmgKQEAgLTEzNiw2ICsxMzYsNyBAQAogZXh0ZXJuIGludCBpcDZfbXJvdXRlX2dldHNvY2tvcHQoc3RydWN0IHNvY2sgKiwgaW50LCBjaGFyIF9fdXNlciAqLCBpbnQgX191c2VyICopOwogZXh0ZXJuIGludCBpcDZfbXJfaW5wdXQoc3RydWN0IHNrX2J1ZmYgKnNrYik7CiBleHRlcm4gaW50IGlwNm1yX2lvY3RsKHN0cnVjdCBzb2NrICpzaywgaW50IGNtZCwgdm9pZCBfX3VzZXIgKmFyZyk7CitleHRlcm4gaW50IGlwNm1yX2NvbXBhdF9pb2N0bChzdHJ1Y3Qgc29jayAqc2ssIHVuc2lnbmVkIGludCBjbWQsIHZvaWQgX191c2VyICphcmcpOwogZXh0ZXJuIGludCBpcDZfbXJfaW5pdCh2b2lkKTsKIGV4dGVybiB2b2lkIGlwNl9tcl9jbGVhbnVwKHZvaWQpOwogI2Vsc2UKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbXRkL2NmaS5oIGIvaW5jbHVkZS9saW51eC9tdGQvY2ZpLmgKaW5kZXggNGRkMGMyYy4uYTliYWVlNiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tdGQvY2ZpLmgKKysrIGIvaW5jbHVkZS9saW51eC9tdGQvY2ZpLmgKQEAgLTUyNyw4ICs1MjcsNyBAQAogc3RydWN0IGNmaV9maXh1cCB7CiAJdWludDE2X3QgbWZyOwogCXVpbnQxNl90IGlkOwotCXZvaWQgKCpmaXh1cCkoc3RydWN0IG10ZF9pbmZvICptdGQsIHZvaWQqIHBhcmFtKTsKLQl2b2lkKiBwYXJhbTsKKwl2b2lkICgqZml4dXApKHN0cnVjdCBtdGRfaW5mbyAqbXRkKTsKIH07CiAKICNkZWZpbmUgQ0ZJX01GUl9BTlkJCTB4RkZGRgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tdGQvZnNtYy5oIGIvaW5jbHVkZS9saW51eC9tdGQvZnNtYy5oCmluZGV4IDVkMjU1NjcuLjY5ODc5OTUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbXRkL2ZzbWMuaAorKysgYi9pbmNsdWRlL2xpbnV4L210ZC9mc21jLmgKQEAgLTE2LDYgKzE2LDcgQEAKICNpZm5kZWYgX19NVERfRlNNQ19ICiAjZGVmaW5lIF9fTVREX0ZTTUNfSAogCisjaW5jbHVkZSA8bGludXgvaW8uaD4KICNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9tdGQvcGh5c21hcC5oPgogI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CkBAIC0yNyw3ICsyOCw3IEBACiAKIC8qCiAgKiBUaGUgcGxhY2VtZW50IG9mIHRoZSBDb21tYW5kIExhdGNoIEVuYWJsZSAoQ0xFKSBhbmQKLSAqIEFkZHJlc3MgTGF0Y2ggRW5hYmxlIChBTEUpIGlzIHR3aXNlZCBhcm91bmQgaW4gdGhlCisgKiBBZGRyZXNzIExhdGNoIEVuYWJsZSAoQUxFKSBpcyB0d2lzdGVkIGFyb3VuZCBpbiB0aGUKICAqIFNQRUFSMzEwIGltcGxlbWVudGF0aW9uLgogICovCiAjaWYgZGVmaW5lZChDT05GSUdfTUFDSF9TUEVBUjMxMCkKQEAgLTYyLDcgKzYzLDcgQEAKIAogLyogY3RybF90aW0gcmVnaXN0ZXIgZGVmaW5pdGlvbnMgKi8KIAotc3RydWN0IGZzbXNfbmFuZF9iYW5rX3JlZ3Mgeworc3RydWN0IGZzbWNfbmFuZF9iYW5rX3JlZ3MgewogCXVpbnQzMl90IHBjOwogCXVpbnQzMl90IHN0czsKIAl1aW50MzJfdCBjb21tOwpAQCAtNzgsNyArNzksNyBAQAogc3RydWN0IGZzbWNfcmVncyB7CiAJc3RydWN0IGZzbWNfbm9yX2JhbmtfcmVncyBub3JfYmFua19yZWdzW0ZTTUNfTUFYX05PUl9CQU5LU107CiAJdWludDhfdCByZXNlcnZlZF8xWzB4NDAgLSAweDIwXTsKLQlzdHJ1Y3QgZnNtc19uYW5kX2JhbmtfcmVncyBiYW5rX3JlZ3NbRlNNQ19NQVhfTkFORF9CQU5LU107CisJc3RydWN0IGZzbWNfbmFuZF9iYW5rX3JlZ3MgYmFua19yZWdzW0ZTTUNfTUFYX05BTkRfQkFOS1NdOwogCXVpbnQ4X3QgcmVzZXJ2ZWRfMlsweGZlMCAtIDB4YzBdOwogCXVpbnQzMl90IHBlcmlwaWQwOwkJCS8qIDB4ZmUwICovCiAJdWludDMyX3QgcGVyaXBpZDE7CQkJLyogMHhmZTQgKi8KQEAgLTExNCwyNSArMTE1LDYgQEAKICNkZWZpbmUgRlNNQ19USE9MRF80CQkoNCA8PCAxNikKICNkZWZpbmUgRlNNQ19USElaXzEJCSgxIDw8IDI0KQogCi0vKiBwZXJpcGlkMiByZWdpc3RlciBkZWZpbml0aW9ucyAqLwotI2RlZmluZSBGU01DX1JFVklTSU9OX01TSwkoMHhmKQotI2RlZmluZSBGU01DX1JFVklTSU9OX1NIRlQJKDB4NCkKLQotI2RlZmluZSBGU01DX1ZFUjEJCTEKLSNkZWZpbmUgRlNNQ19WRVIyCQkyCi0jZGVmaW5lIEZTTUNfVkVSMwkJMwotI2RlZmluZSBGU01DX1ZFUjQJCTQKLSNkZWZpbmUgRlNNQ19WRVI1CQk1Ci0jZGVmaW5lIEZTTUNfVkVSNgkJNgotI2RlZmluZSBGU01DX1ZFUjcJCTcKLSNkZWZpbmUgRlNNQ19WRVI4CQk4Ci0KLXN0YXRpYyBpbmxpbmUgdWludDMyX3QgZ2V0X2ZzbWNfdmVyc2lvbihzdHJ1Y3QgZnNtY19yZWdzICpyZWdzKQotewotCXJldHVybiAocmVhZGwoJnJlZ3MtPnBlcmlwaWQyKSA+PiBGU01DX1JFVklTSU9OX1NIRlQpICYKLQkJCQlGU01DX1JFVklTSU9OX01TSzsKLX0KLQogLyoKICAqIFRoZXJlIGFyZSAxMyBieXRlcyBvZiBlY2MgZm9yIGV2ZXJ5IDUxMiBieXRlIGJsb2NrIGluIEZTTUMgdmVyc2lvbiA4CiAgKiBhbmQgaXQgaGFzIHRvIGJlIHJlYWQgY29uc2VjdXRpdmVseSBhbmQgaW1tZWRpYXRlbHkgYWZ0ZXIgdGhlIDUxMgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tdGQvbXRkLmggYi9pbmNsdWRlL2xpbnV4L210ZC9tdGQuaAppbmRleCBmZThkNzdlLi45ZDUzMDZiIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L210ZC9tdGQuaAorKysgYi9pbmNsdWRlL2xpbnV4L210ZC9tdGQuaApAQCAtMTQ0LDYgKzE0NCwxNyBAQAogCSAqLwogCXVpbnQzMl90IHdyaXRlc2l6ZTsKIAorCS8qCisJICogU2l6ZSBvZiB0aGUgd3JpdGUgYnVmZmVyIHVzZWQgYnkgdGhlIE1URC4gTVREIGRldmljZXMgaGF2aW5nIGEgd3JpdGUKKwkgKiBidWZmZXIgY2FuIHdyaXRlIG11bHRpcGxlIHdyaXRlc2l6ZSBjaHVua3MgYXQgYSB0aW1lLiBFLmcuIHdoaWxlCisJICogd3JpdGluZyA0ICogd3JpdGVzaXplIGJ5dGVzIHRvIGEgZGV2aWNlIHdpdGggMiAqIHdyaXRlc2l6ZSBieXRlcworCSAqIGJ1ZmZlciB0aGUgTVREIGRyaXZlciBjYW4gKGJ1dCBkb2Vzbid0IGhhdmUgdG8pIGRvIDIgd3JpdGVzaXplCisJICogb3BlcmF0aW9ucywgYnV0IG5vdCA0LiBDdXJyZW50bHksIGFsbCBOQU5EcyBoYXZlIHdyaXRlYnVmc2l6ZQorCSAqIGVxdWl2YWxlbnQgdG8gd3JpdGVzaXplIChOQU5EIHBhZ2Ugc2l6ZSkuIFNvbWUgTk9SIGZsYXNoZXMgZG8gaGF2ZQorCSAqIHdyaXRlYnVmc2l6ZSBncmVhdGVyIHRoYW4gd3JpdGVzaXplLgorCSAqLworCXVpbnQzMl90IHdyaXRlYnVmc2l6ZTsKKwogCXVpbnQzMl90IG9vYnNpemU7ICAgLy8gQW1vdW50IG9mIE9PQiBkYXRhIHBlciBibG9jayAoZS5nLiAxNikKIAl1aW50MzJfdCBvb2JhdmFpbDsgIC8vIEF2YWlsYWJsZSBPT0IgYnl0ZXMgcGVyIGJsb2NrCiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbXRkL25hbmQuaCBiL2luY2x1ZGUvbGludXgvbXRkL25hbmQuaAppbmRleCA2M2UxN2QwLi4xZjQ4OWIyIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L210ZC9uYW5kLmgKKysrIGIvaW5jbHVkZS9saW51eC9tdGQvbmFuZC5oCkBAIC00NDgsNiArNDQ4LDggQEAKICAqCQkJU2VlIHRoZSBkZWZpbmVzIGZvciBmdXJ0aGVyIGV4cGxhbmF0aW9uLgogICogQGJhZGJsb2NrcG9zOglbSU5URVJOXSBwb3NpdGlvbiBvZiB0aGUgYmFkIGJsb2NrIG1hcmtlciBpbiB0aGUgb29iCiAgKgkJCWFyZWEuCisgKiBAYmFkYmxvY2tiaXRzOglbSU5URVJOXSBudW1iZXIgb2YgYml0cyB0byBsZWZ0LXNoaWZ0IHRoZSBiYWQgYmxvY2sKKyAqCQkJbnVtYmVyCiAgKiBAY2VsbGluZm86CQlbSU5URVJOXSBNTEMvbXVsdGljaGlwIGRhdGEgZnJvbSBjaGlwIGlkZW50CiAgKiBAbnVtY2hpcHM6CQlbSU5URVJOXSBudW1iZXIgb2YgcGh5c2ljYWwgY2hpcHMKICAqIEBjaGlwc2l6ZToJCVtJTlRFUk5dIHRoZSBzaXplIG9mIG9uZSBjaGlwIGZvciBtdWx0aWNoaXAgYXJyYXlzCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L210ZC9vbmVuYW5kLmggYi9pbmNsdWRlL2xpbnV4L210ZC9vbmVuYW5kLmgKaW5kZXggMGM4ODE1Yi4uYWU0MThlNCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tdGQvb25lbmFuZC5oCisrKyBiL2luY2x1ZGUvbGludXgvbXRkL29uZW5hbmQuaApAQCAtMTE4LDYgKzExOCw4IEBACiAJaW50ICgqY2hpcF9wcm9iZSkoc3RydWN0IG10ZF9pbmZvICptdGQpOwogCWludCAoKmJsb2NrX21hcmtiYWQpKHN0cnVjdCBtdGRfaW5mbyAqbXRkLCBsb2ZmX3Qgb2ZzKTsKIAlpbnQgKCpzY2FuX2JidCkoc3RydWN0IG10ZF9pbmZvICptdGQpOworCWludCAoKmVuYWJsZSkoc3RydWN0IG10ZF9pbmZvICptdGQpOworCWludCAoKmRpc2FibGUpKHN0cnVjdCBtdGRfaW5mbyAqbXRkKTsKIAogCXN0cnVjdCBjb21wbGV0aW9uCWNvbXBsZXRlOwogCWludAkJCWlycTsKQEAgLTEzNyw2ICsxMzksMTQgQEAKIAl2b2lkCQkJKmJibTsKIAogCXZvaWQJCQkqcHJpdjsKKworCS8qCisJICogU2hvd3MgdGhhdCB0aGUgY3VycmVudCBvcGVyYXRpb24gaXMgY29tcG9zZWQKKwkgKiBvZiBzZXF1ZW5jZSBvZiBjb21tYW5kcy4gRm9yIGV4YW1wbGUsIGNhY2hlIHByb2dyYW0uCisJICogU3VjaCBjb21tYW5kIHN0YXR1cyBPbkdvIGJpdCBpcyBjaGVja2VkIGF0IHRoZSBlbmQgb2YKKwkgKiBzZXF1ZW5jZS4KKwkgKi8KKwl1bnNpZ25lZCBpbnQJCW9uZ29pbmc7CiB9OwogCiAvKgpAQCAtMTcxLDYgKzE4MSw5IEBACiAjZGVmaW5lIE9ORU5BTkRfSVNfMlBMQU5FKHRoaXMpCQkJKDApCiAjZW5kaWYKIAorI2RlZmluZSBPTkVOQU5EX0lTX0NBQ0hFX1BST0dSQU0odGhpcykJCQkJCVwKKwkodGhpcy0+b3B0aW9ucyAmIE9ORU5BTkRfSEFTX0NBQ0hFX1BST0dSQU0pCisKIC8qIENoZWNrIGJ5dGUgYWNjZXNzIGluIE9uZU5BTkQgKi8KICNkZWZpbmUgT05FTkFORF9DSEVDS19CWVRFX0FDQ0VTUyhhZGRyKQkJKGFkZHIgJiAweDEpCiAKQEAgLTE4MSw2ICsxOTQsNyBAQAogI2RlZmluZSBPTkVOQU5EX0hBU19VTkxPQ0tfQUxMCQkoMHgwMDAyKQogI2RlZmluZSBPTkVOQU5EX0hBU18yUExBTkUJCSgweDAwMDQpCiAjZGVmaW5lIE9ORU5BTkRfSEFTXzRLQl9QQUdFCQkoMHgwMDA4KQorI2RlZmluZSBPTkVOQU5EX0hBU19DQUNIRV9QUk9HUkFNCSgweDAwMTApCiAjZGVmaW5lIE9ORU5BTkRfU0tJUF9VTkxPQ0tfQ0hFQ0sJKDB4MDEwMCkKICNkZWZpbmUgT05FTkFORF9QQUdFQlVGX0FMTE9DCQkoMHgxMDAwKQogI2RlZmluZSBPTkVOQU5EX09PQkJVRl9BTExPQwkJKDB4MjAwMCkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbXRkL3BhcnRpdGlvbnMuaCBiL2luY2x1ZGUvbGludXgvbXRkL3BhcnRpdGlvbnMuaAppbmRleCAyYjU0MzE2Li40YTBhOGJhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L210ZC9wYXJ0aXRpb25zLmgKKysrIGIvaW5jbHVkZS9saW51eC9tdGQvcGFydGl0aW9ucy5oCkBAIC04OSw3ICs4OSw3IEBACiBzdGF0aWMgaW5saW5lIGludCBtdGRfaGFzX2NtZGxpbmVwYXJ0KHZvaWQpIHsgcmV0dXJuIDA7IH0KICNlbmRpZgogCi1pbnQgbXRkX2lzX21hc3RlcihzdHJ1Y3QgbXRkX2luZm8gKm10ZCk7CitpbnQgbXRkX2lzX3BhcnRpdGlvbihzdHJ1Y3QgbXRkX2luZm8gKm10ZCk7CiBpbnQgbXRkX2FkZF9wYXJ0aXRpb24oc3RydWN0IG10ZF9pbmZvICptYXN0ZXIsIGNoYXIgKm5hbWUsCiAJCSAgICAgIGxvbmcgbG9uZyBvZmZzZXQsIGxvbmcgbG9uZyBsZW5ndGgpOwogaW50IG10ZF9kZWxfcGFydGl0aW9uKHN0cnVjdCBtdGRfaW5mbyAqbWFzdGVyLCBpbnQgcGFydG5vKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbmFtZWkuaCBiL2luY2x1ZGUvbGludXgvbmFtZWkuaAppbmRleCAxOGQwNmFkLi5mMjc2ZDRmIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L25hbWVpLmgKKysrIGIvaW5jbHVkZS9saW51eC9uYW1laS5oCkBAIC00NSw2ICs0NSw3IEBACiAgKiAgLSBlbmRpbmcgc2xhc2hlcyBvayBldmVuIGZvciBub25leGlzdGVudCBmaWxlcwogICogIC0gaW50ZXJuYWwgInRoZXJlIGFyZSBtb3JlIHBhdGggY29tcG9uZW50cyIgZmxhZwogICogIC0gZGVudHJ5IGNhY2hlIGlzIHVudHJ1c3RlZDsgZm9yY2UgYSByZWFsIGxvb2t1cAorICogIC0gc3VwcHJlc3MgdGVybWluYWwgYXV0b21vdW50CiAgKi8KICNkZWZpbmUgTE9PS1VQX0ZPTExPVwkJMHgwMDAxCiAjZGVmaW5lIExPT0tVUF9ESVJFQ1RPUlkJMHgwMDAyCkBAIC01Myw2ICs1NCw3IEBACiAjZGVmaW5lIExPT0tVUF9QQVJFTlQJCTB4MDAxMAogI2RlZmluZSBMT09LVVBfUkVWQUwJCTB4MDAyMAogI2RlZmluZSBMT09LVVBfUkNVCQkweDAwNDAKKyNkZWZpbmUgTE9PS1VQX05PX0FVVE9NT1VOVAkweDAwODAKIC8qCiAgKiBJbnRlbnQgZGF0YQogICovCkBAIC03OSw3ICs4MSw4IEBACiAKIGV4dGVybiBzdHJ1Y3QgZGVudHJ5ICpsb29rdXBfb25lX2xlbihjb25zdCBjaGFyICosIHN0cnVjdCBkZW50cnkgKiwgaW50KTsKIAotZXh0ZXJuIGludCBmb2xsb3dfZG93bihzdHJ1Y3QgcGF0aCAqKTsKK2V4dGVybiBpbnQgZm9sbG93X2Rvd25fb25lKHN0cnVjdCBwYXRoICopOworZXh0ZXJuIGludCBmb2xsb3dfZG93bihzdHJ1Y3QgcGF0aCAqLCBib29sKTsKIGV4dGVybiBpbnQgZm9sbG93X3VwKHN0cnVjdCBwYXRoICopOwogCiBleHRlcm4gc3RydWN0IGRlbnRyeSAqbG9ja19yZW5hbWUoc3RydWN0IGRlbnRyeSAqLCBzdHJ1Y3QgZGVudHJ5ICopOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9uZXRkZXZpY2UuaCBiL2luY2x1ZGUvbGludXgvbmV0ZGV2aWNlLmgKaW5kZXggYmU0OTU3Yy4uZDk3MTM0NiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9uZXRkZXZpY2UuaAorKysgYi9pbmNsdWRlL2xpbnV4L25ldGRldmljZS5oCkBAIC01MjAsOSArNTIwLDYgQEAKIAkgKiBwbGVhc2UgdXNlIHRoaXMgZmllbGQgaW5zdGVhZCBvZiBkZXYtPnRyYW5zX3N0YXJ0CiAJICovCiAJdW5zaWduZWQgbG9uZwkJdHJhbnNfc3RhcnQ7Ci0JdTY0CQkJdHhfYnl0ZXM7Ci0JdTY0CQkJdHhfcGFja2V0czsKLQl1NjQJCQl0eF9kcm9wcGVkOwogfSBfX19fY2FjaGVsaW5lX2FsaWduZWRfaW5fc21wOwogCiBzdGF0aWMgaW5saW5lIGludCBuZXRkZXZfcXVldWVfbnVtYV9ub2RlX3JlYWQoY29uc3Qgc3RydWN0IG5ldGRldl9xdWV1ZSAqcSkKQEAgLTIyNjUsOCArMjI2Miw2IEBACiBleHRlcm4gdm9pZAkJZGV2X21jYXN0X2luaXQodm9pZCk7CiBleHRlcm4gc3RydWN0IHJ0bmxfbGlua19zdGF0czY0ICpkZXZfZ2V0X3N0YXRzKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCiAJCQkJCSAgICAgICBzdHJ1Y3QgcnRubF9saW5rX3N0YXRzNjQgKnN0b3JhZ2UpOwotZXh0ZXJuIHZvaWQJCWRldl90eHFfc3RhdHNfZm9sZChjb25zdCBzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LAotCQkJCQkgICBzdHJ1Y3QgcnRubF9saW5rX3N0YXRzNjQgKnN0YXRzKTsKIAogZXh0ZXJuIGludAkJbmV0ZGV2X21heF9iYWNrbG9nOwogZXh0ZXJuIGludAkJbmV0ZGV2X3RzdGFtcF9wcmVxdWV1ZTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbmZzNC5oIGIvaW5jbHVkZS9saW51eC9uZnM0LmgKaW5kZXggOWI0NjMwMC4uMTM0NzE2ZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9uZnM0LmgKKysrIGIvaW5jbHVkZS9saW51eC9uZnM0LmgKQEAgLTY1LDYgKzY1LDkgQEAKIAogI2RlZmluZSBORlM0X0NERkM0X0ZPUkUJMHgxCiAjZGVmaW5lIE5GUzRfQ0RGQzRfQkFDSyAweDIKKyNkZWZpbmUgTkZTNF9DREZDNF9CT1RIIDB4MworI2RlZmluZSBORlM0X0NERkM0X0ZPUkVfT1JfQk9USCAweDMKKyNkZWZpbmUgTkZTNF9DREZDNF9CQUNLX09SX0JPVEggMHg3CiAKICNkZWZpbmUgTkZTNF9TRVRfVE9fU0VSVkVSX1RJTUUJMAogI2RlZmluZSBORlM0X1NFVF9UT19DTElFTlRfVElNRQkxCkBAIC0xNDAsNiArMTQzLDkgQEAKICNkZWZpbmUgU0VRNF9TVEFUVVNfQ0JfUEFUSF9ET1dOX1NFU1NJT04JMHgwMDAwMDIwMAogI2RlZmluZSBTRVE0X1NUQVRVU19CQUNLQ0hBTk5FTF9GQVVMVAkJMHgwMDAwMDQwMAogCisjZGVmaW5lIE5GUzRfU0VDSU5GT19TVFlMRTRfQ1VSUkVOVF9GSAkwCisjZGVmaW5lIE5GUzRfU0VDSU5GT19TVFlMRTRfUEFSRU5UCTEKKwogI2RlZmluZSBORlM0X01BWF9VSU5UNjQJKH4odTY0KTApCiAKIC8qIEFuIE5GUzQgc2Vzc2lvbnMgc2VydmVyIG11c3Qgc3VwcG9ydCBhdCBsZWFzdCBORlM0X01BWF9PUFMgb3BlcmF0aW9ucy4KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbmZzX2ZzLmggYi9pbmNsdWRlL2xpbnV4L25mc19mcy5oCmluZGV4IDA3NzliYjguLjYwMjNlZmEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbmZzX2ZzLmgKKysrIGIvaW5jbHVkZS9saW51eC9uZnNfZnMuaApAQCAtMjE1LDcgKzIxNSw2IEBACiAjZGVmaW5lIE5GU19JTk9fQURWSVNFX1JEUExVUwkoMCkJCS8qIGFkdmlzZSByZWFkZGlycGx1cyAqLwogI2RlZmluZSBORlNfSU5PX1NUQUxFCQkoMSkJCS8qIHBvc3NpYmxlIHN0YWxlIGlub2RlICovCiAjZGVmaW5lIE5GU19JTk9fQUNMX0xSVV9TRVQJKDIpCQkvKiBJbm9kZSBpcyBvbiB0aGUgTFJVIGxpc3QgKi8KLSNkZWZpbmUgTkZTX0lOT19NT1VOVFBPSU5UCSgzKQkJLyogaW5vZGUgaXMgcmVtb3RlIG1vdW50cG9pbnQgKi8KICNkZWZpbmUgTkZTX0lOT19GTFVTSElORwkoNCkJCS8qIGlub2RlIGlzIGZsdXNoaW5nIG91dCBkYXRhICovCiAjZGVmaW5lIE5GU19JTk9fRlNDQUNIRQkJKDUpCQkvKiBpbm9kZSBjYW4gYmUgY2FjaGVkIGJ5IEZTLUNhY2hlICovCiAjZGVmaW5lIE5GU19JTk9fRlNDQUNIRV9MT0NLCSg2KQkJLyogRlMtQ2FjaGUgY29va2llIG1hbmFnZW1lbnQgbG9jayAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9uZnNhY2wuaCBiL2luY2x1ZGUvbGludXgvbmZzYWNsLmgKaW5kZXggZjMyMWI1Ny4uZmFiY2IxZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9uZnNhY2wuaAorKysgYi9pbmNsdWRlL2xpbnV4L25mc2FjbC5oCkBAIC01MSwxMCArNTEsMTAgQEAKIAlyZXR1cm4gdzsKIH0KIAotZXh0ZXJuIHVuc2lnbmVkIGludAorZXh0ZXJuIGludAogbmZzYWNsX2VuY29kZShzdHJ1Y3QgeGRyX2J1ZiAqYnVmLCB1bnNpZ25lZCBpbnQgYmFzZSwgc3RydWN0IGlub2RlICppbm9kZSwKIAkgICAgICBzdHJ1Y3QgcG9zaXhfYWNsICphY2wsIGludCBlbmNvZGVfZW50cmllcywgaW50IHR5cGVmbGFnKTsKLWV4dGVybiB1bnNpZ25lZCBpbnQKK2V4dGVybiBpbnQKIG5mc2FjbF9kZWNvZGUoc3RydWN0IHhkcl9idWYgKmJ1ZiwgdW5zaWduZWQgaW50IGJhc2UsIHVuc2lnbmVkIGludCAqYWNsY250LAogCSAgICAgIHN0cnVjdCBwb3NpeF9hY2wgKipwYWNsKTsKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9uZnNkL2V4cG9ydC5oIGIvaW5jbHVkZS9saW51eC9uZnNkL2V4cG9ydC5oCmluZGV4IDhhZTc4YTYuLmJkMzE2MTUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbmZzZC9leHBvcnQuaAorKysgYi9pbmNsdWRlL2xpbnV4L25mc2QvZXhwb3J0LmgKQEAgLTM1LDcgKzM1LDcgQEAKICNkZWZpbmUgTkZTRVhQX05PSElERQkJMHgwMjAwCiAjZGVmaW5lIE5GU0VYUF9OT1NVQlRSRUVDSEVDSwkweDA0MDAKICNkZWZpbmUJTkZTRVhQX05PQVVUSE5MTQkweDA4MDAJCS8qIERvbid0IGF1dGhlbnRpY2F0ZSBOTE0gcmVxdWVzdHMgLSBqdXN0IHRydXN0ICovCi0jZGVmaW5lIE5GU0VYUF9NU05GUwkJMHgxMDAwCS8qIGRvIHNpbGx5IHRoaW5ncyB0aGF0IE1TIGNsaWVudHMgZXhwZWN0ICovCisjZGVmaW5lIE5GU0VYUF9NU05GUwkJMHgxMDAwCS8qIGRvIHNpbGx5IHRoaW5ncyB0aGF0IE1TIGNsaWVudHMgZXhwZWN0OyBubyBsb25nZXIgc3VwcG9ydGVkICovCiAjZGVmaW5lIE5GU0VYUF9GU0lECQkweDIwMDAKICNkZWZpbmUJTkZTRVhQX0NST1NTTU9VTlQJMHg0MDAwCiAjZGVmaW5lCU5GU0VYUF9OT0FDTAkJMHg4MDAwCS8qIHJlc2VydmVkIGZvciBwb3NzaWJsZSBBQ0wgcmVsYXRlZCB1c2UgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbmw4MDIxMS5oIGIvaW5jbHVkZS9saW51eC9ubDgwMjExLmgKaW5kZXggMmI4OWI3MS4uODIxZmZiOSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9ubDgwMjExLmgKKysrIGIvaW5jbHVkZS9saW51eC9ubDgwMjExLmgKQEAgLTE0OCw2ICsxNDgsMTAgQEAKICAqIEBOTDgwMjExX0NNRF9TRVRfTVBBVEg6ICBTZXQgbWVzaCBwYXRoIGF0dHJpYnV0ZXMgZm9yIG1lc2ggcGF0aCB0bwogICogCWRlc3RpbmF0aW9uICVOTDgwMjExX0FUVFJfTUFDIG9uIHRoZSBpbnRlcmZhY2UgaWRlbnRpZmllZCBieQogICogCSVOTDgwMjExX0FUVFJfSUZJTkRFWC4KKyAqIEBOTDgwMjExX0NNRF9ORVdfTVBBVEg6IENyZWF0ZSBhIG5ldyBtZXNoIHBhdGggZm9yIHRoZSBkZXN0aW5hdGlvbiBnaXZlbiBieQorICoJJU5MODAyMTFfQVRUUl9NQUMgdmlhICVOTDgwMjExX0FUVFJfTVBBVEhfTkVYVF9IT1AuCisgKiBATkw4MDIxMV9DTURfREVMX01QQVRIOiBEZWxldGUgYSBtZXNoIHBhdGggdG8gdGhlIGRlc3RpbmF0aW9uIGdpdmVuIGJ5CisgKgklTkw4MDIxMV9BVFRSX01BQy4KICAqIEBOTDgwMjExX0NNRF9ORVdfUEFUSDogQWRkIGEgbWVzaCBwYXRoIHdpdGggZ2l2ZW4gYXR0cmlidXRlcyB0byB0aGUKICAqCXRoZSBpbnRlcmZhY2UgaWRlbnRpZmllZCBieSAlTkw4MDIxMV9BVFRSX0lGSU5ERVguCiAgKiBATkw4MDIxMV9DTURfREVMX1BBVEg6IFJlbW92ZSBhIG1lc2ggcGF0aCBpZGVudGlmaWVkIGJ5ICVOTDgwMjExX0FUVFJfTUFDCkBAIC02MTIsNyArNjE2LDcgQEAKICAqCWNvbnNpc3Rpbmcgb2YgYSBuZXN0ZWQgYXJyYXkuCiAgKgogICogQE5MODAyMTFfQVRUUl9NRVNIX0lEOiBtZXNoIGlkICgxLTMyIGJ5dGVzKS4KLSAqIEBOTDgwMjExX0FUVFJfUExJTktfQUNUSU9OOiBhY3Rpb24gdG8gcGVyZm9ybSBvbiB0aGUgbWVzaCBwZWVyIGxpbmsuCisgKiBATkw4MDIxMV9BVFRSX1NUQV9QTElOS19BQ1RJT046IGFjdGlvbiB0byBwZXJmb3JtIG9uIHRoZSBtZXNoIHBlZXIgbGluay4KICAqIEBOTDgwMjExX0FUVFJfTVBBVEhfTkVYVF9IT1A6IE1BQyBhZGRyZXNzIG9mIHRoZSBuZXh0IGhvcCBmb3IgYSBtZXNoIHBhdGguCiAgKiBATkw4MDIxMV9BVFRSX01QQVRIX0lORk86IGluZm9ybWF0aW9uIGFib3V0IGEgbWVzaF9wYXRoLCBwYXJ0IG9mIG1lc2ggcGF0aAogICogCWluZm8gZ2l2ZW4gZm9yICVOTDgwMjExX0NNRF9HRVRfTVBBVEgsIG5lc3RlZCBhdHRyaWJ1dGUgZGVzY3JpYmVkIGF0CkBAIC04NzksNyArODgzLDkgQEAKICAqCVNlZSAmZW51bSBubDgwMjExX2tleV9kZWZhdWx0X3R5cGVzLgogICoKICAqIEBOTDgwMjExX0FUVFJfTUVTSF9TRVRVUDogT3B0aW9uYWwgbWVzaCBzZXR1cCBwYXJhbWV0ZXJzLiAgVGhlc2UgY2Fubm90IGJlCi0gKiBjaGFuZ2VkIG9uY2UgdGhlIG1lc2ggaXMgYWN0aXZlLgorICoJY2hhbmdlZCBvbmNlIHRoZSBtZXNoIGlzIGFjdGl2ZS4KKyAqIEBOTDgwMjExX0FUVFJfTUVTSF9DT05GSUc6IE1lc2ggY29uZmlndXJhdGlvbiBwYXJhbWV0ZXJzLCBhIG5lc3RlZCBhdHRyaWJ1dGUKKyAqCWNvbnRhaW5pbmcgYXR0cmlidXRlcyBmcm9tICZlbnVtIG5sODAyMTFfbWVzaGNvbmZfcGFyYW1zLgogICoKICAqIEBOTDgwMjExX0FUVFJfTUFYOiBoaWdoZXN0IGF0dHJpYnV0ZSBudW1iZXIgY3VycmVudGx5IGRlZmluZWQKICAqIEBfX05MODAyMTFfQVRUUl9BRlRFUl9MQVNUOiBpbnRlcm5hbCB1c2UKQEAgLTEyMjUsOCArMTIzMSw2IEBACiAgKiBATkw4MDIxMV9TVEFfSU5GT19JTkFDVElWRV9USU1FOiB0aW1lIHNpbmNlIGxhc3QgYWN0aXZpdHkgKHUzMiwgbXNlY3MpCiAgKiBATkw4MDIxMV9TVEFfSU5GT19SWF9CWVRFUzogdG90YWwgcmVjZWl2ZWQgYnl0ZXMgKHUzMiwgZnJvbSB0aGlzIHN0YXRpb24pCiAgKiBATkw4MDIxMV9TVEFfSU5GT19UWF9CWVRFUzogdG90YWwgdHJhbnNtaXR0ZWQgYnl0ZXMgKHUzMiwgdG8gdGhpcyBzdGF0aW9uKQotICogQF9fTkw4MDIxMV9TVEFfSU5GT19BRlRFUl9MQVNUOiBpbnRlcm5hbAotICogQE5MODAyMTFfU1RBX0lORk9fTUFYOiBoaWdoZXN0IHBvc3NpYmxlIHN0YXRpb24gaW5mbyBhdHRyaWJ1dGUKICAqIEBOTDgwMjExX1NUQV9JTkZPX1NJR05BTDogc2lnbmFsIHN0cmVuZ3RoIG9mIGxhc3QgcmVjZWl2ZWQgUFBEVSAodTgsIGRCbSkKICAqIEBOTDgwMjExX1NUQV9JTkZPX1RYX0JJVFJBVEU6IGN1cnJlbnQgdW5pY2FzdCB0eCByYXRlLCBuZXN0ZWQgYXR0cmlidXRlCiAgKiAJY29udGFpbmluZyBpbmZvIGFzIHBvc3NpYmxlLCBzZWUgJmVudW0gbmw4MDIxMV9zdGFfaW5mb190eHJhdGUuCkBAIC0xMjM2LDYgKzEyNDAsMTEgQEAKICAqIEBOTDgwMjExX1NUQV9JTkZPX1RYX1JFVFJJRVM6IHRvdGFsIHJldHJpZXMgKHUzMiwgdG8gdGhpcyBzdGF0aW9uKQogICogQE5MODAyMTFfU1RBX0lORk9fVFhfRkFJTEVEOiB0b3RhbCBmYWlsZWQgcGFja2V0cyAodTMyLCB0byB0aGlzIHN0YXRpb24pCiAgKiBATkw4MDIxMV9TVEFfSU5GT19TSUdOQUxfQVZHOiBzaWduYWwgc3RyZW5ndGggYXZlcmFnZSAodTgsIGRCbSkKKyAqIEBOTDgwMjExX1NUQV9JTkZPX0xMSUQ6IHRoZSBzdGF0aW9uJ3MgbWVzaCBMTElECisgKiBATkw4MDIxMV9TVEFfSU5GT19QTElEOiB0aGUgc3RhdGlvbidzIG1lc2ggUExJRAorICogQE5MODAyMTFfU1RBX0lORk9fUExJTktfU1RBVEU6IHBlZXIgbGluayBzdGF0ZSBmb3IgdGhlIHN0YXRpb24KKyAqIEBfX05MODAyMTFfU1RBX0lORk9fQUZURVJfTEFTVDogaW50ZXJuYWwKKyAqIEBOTDgwMjExX1NUQV9JTkZPX01BWDogaGlnaGVzdCBwb3NzaWJsZSBzdGF0aW9uIGluZm8gYXR0cmlidXRlCiAgKi8KIGVudW0gbmw4MDIxMV9zdGFfaW5mbyB7CiAJX19OTDgwMjExX1NUQV9JTkZPX0lOVkFMSUQsCkBAIC0xNjI2LDcgKzE2MzUsNyBAQAogICogQE5MODAyMTFfTUVTSENPTkZfSFdNUF9ORVRfRElBTV9UUlZTX1RJTUU6IFRoZSBpbnRlcnZhbCBvZiB0aW1lIChpbiBUVXMpCiAgKiB0aGF0IGl0IHRha2VzIGZvciBhbiBIV01QIGluZm9ybWF0aW9uIGVsZW1lbnQgdG8gcHJvcGFnYXRlIGFjcm9zcyB0aGUgbWVzaAogICoKLSAqIEBOTDgwMjExX01FU0hDT05GX1JPT1RNT0RFOiB3aGV0aGVyIHJvb3QgbW9kZSBpcyBlbmFibGVkIG9yIG5vdAorICogQE5MODAyMTFfTUVTSENPTkZfSFdNUF9ST09UTU9ERTogd2hldGhlciByb290IG1vZGUgaXMgZW5hYmxlZCBvciBub3QKICAqCiAgKiBATkw4MDIxMV9NRVNIQ09ORl9FTEVNRU5UX1RUTDogc3BlY2lmaWVzIHRoZSB2YWx1ZSBvZiBUVEwgZmllbGQgc2V0IGF0IGEKICAqIHNvdXJjZSBtZXNoIHBvaW50IGZvciBwYXRoIHNlbGVjdGlvbiBlbGVtZW50cy4KQEAgLTE2NzgsNiArMTY4Nyw3IEBACiAgKiBlbGVtZW50IHRoYXQgdmVuZG9ycyB3aWxsIHVzZSB0byBpZGVudGlmeSB0aGUgcGF0aCBzZWxlY3Rpb24gbWV0aG9kcyBhbmQKICAqIG1ldHJpY3MgaW4gdXNlLgogICoKKyAqIEBOTDgwMjExX01FU0hfU0VUVVBfQVRUUl9NQVg6IGhpZ2hlc3QgcG9zc2libGUgbWVzaCBzZXR1cCBhdHRyaWJ1dGUgbnVtYmVyCiAgKiBAX19OTDgwMjExX01FU0hfU0VUVVBfQVRUUl9BRlRFUl9MQVNUOiBJbnRlcm5hbCB1c2UKICAqLwogZW51bSBubDgwMjExX21lc2hfc2V0dXBfcGFyYW1zIHsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvb2ZfZmR0LmggYi9pbmNsdWRlL2xpbnV4L29mX2ZkdC5oCmluZGV4IDBlZjIyYTEuLmM4NGQ5MDAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvb2ZfZmR0LmgKKysrIGIvaW5jbHVkZS9saW51eC9vZl9mZHQuaApAQCAtOTcsNyArOTcsNyBAQAogZXh0ZXJuIGludCBlYXJseV9pbml0X2R0X3NjYW5fbWVtb3J5KHVuc2lnbmVkIGxvbmcgbm9kZSwgY29uc3QgY2hhciAqdW5hbWUsCiAJCQkJICAgICBpbnQgZGVwdGgsIHZvaWQgKmRhdGEpOwogZXh0ZXJuIHZvaWQgZWFybHlfaW5pdF9kdF9hZGRfbWVtb3J5X2FyY2godTY0IGJhc2UsIHU2NCBzaXplKTsKLWV4dGVybiB1NjQgZWFybHlfaW5pdF9kdF9hbGxvY19tZW1vcnlfYXJjaCh1NjQgc2l6ZSwgdTY0IGFsaWduKTsKK2V4dGVybiB2b2lkICogZWFybHlfaW5pdF9kdF9hbGxvY19tZW1vcnlfYXJjaCh1NjQgc2l6ZSwgdTY0IGFsaWduKTsKIGV4dGVybiB1NjQgZHRfbWVtX25leHRfY2VsbChpbnQgcywgX19iZTMyICoqY2VsbHApOwogCiAvKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9wYWdlLWZsYWdzLmggYi9pbmNsdWRlL2xpbnV4L3BhZ2UtZmxhZ3MuaAppbmRleCA1ZjM4YzQ2Li4wZGI4MDM3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3BhZ2UtZmxhZ3MuaAorKysgYi9pbmNsdWRlL2xpbnV4L3BhZ2UtZmxhZ3MuaApAQCAtNDgsOSArNDgsNiBAQAogICogc3RydWN0IHBhZ2UgKHRoZXNlIGJpdHMgd2l0aCBpbmZvcm1hdGlvbikgYXJlIGFsd2F5cyBtYXBwZWQgaW50byBrZXJuZWwKICAqIGFkZHJlc3Mgc3BhY2UuLi4KICAqCi0gKiBQR19idWRkeSBpcyBzZXQgdG8gaW5kaWNhdGUgdGhhdCB0aGUgcGFnZSBpcyBmcmVlIGFuZCBpbiB0aGUgYnVkZHkgc3lzdGVtCi0gKiAoc2VlIG1tL3BhZ2VfYWxsb2MuYykuCi0gKgogICogUEdfaHdwb2lzb24gaW5kaWNhdGVzIHRoYXQgYSBwYWdlIGdvdCBjb3JydXB0ZWQgaW4gaGFyZHdhcmUgYW5kIGNvbnRhaW5zCiAgKiBkYXRhIHdpdGggaW5jb3JyZWN0IEVDQyBiaXRzIHRoYXQgdHJpZ2dlcmVkIGEgbWFjaGluZSBjaGVjay4gQWNjZXNzaW5nIGlzCiAgKiBub3Qgc2FmZSBzaW5jZSBpdCBtYXkgY2F1c2UgYW5vdGhlciBtYWNoaW5lIGNoZWNrLiBEb24ndCB0b3VjaCEKQEAgLTk2LDcgKzkzLDYgQEAKIAlQR19zd2FwY2FjaGUsCQkvKiBTd2FwIHBhZ2U6IHN3cF9lbnRyeV90IGluIHByaXZhdGUgKi8KIAlQR19tYXBwZWR0b2Rpc2ssCS8qIEhhcyBibG9ja3MgYWxsb2NhdGVkIG9uLWRpc2sgKi8KIAlQR19yZWNsYWltLAkJLyogVG8gYmUgcmVjbGFpbWVkIGFzYXAgKi8KLQlQR19idWRkeSwJCS8qIFBhZ2UgaXMgZnJlZSwgb24gYnVkZHkgbGlzdHMgKi8KIAlQR19zd2FwYmFja2VkLAkJLyogUGFnZSBpcyBiYWNrZWQgYnkgUkFNL3N3YXAgKi8KIAlQR191bmV2aWN0YWJsZSwJCS8qIFBhZ2UgaXMgInVuZXZpY3RhYmxlIiAgKi8KICNpZmRlZiBDT05GSUdfTU1VCkBAIC0xMDgsNiArMTA0LDkgQEAKICNpZmRlZiBDT05GSUdfTUVNT1JZX0ZBSUxVUkUKIAlQR19od3BvaXNvbiwJCS8qIGhhcmR3YXJlIHBvaXNvbmVkIHBhZ2UuIERvbid0IHRvdWNoICovCiAjZW5kaWYKKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UKKwlQR19jb21wb3VuZF9sb2NrLAorI2VuZGlmCiAJX19OUl9QQUdFRkxBR1MsCiAKIAkvKiBGaWxlc3lzdGVtcyAqLwpAQCAtMTk4LDcgKzE5Nyw3IEBACiBzdHJ1Y3QgcGFnZTsJLyogZm9yd2FyZCBkZWNsYXJhdGlvbiAqLwogCiBURVNUUEFHRUZMQUcoTG9ja2VkLCBsb2NrZWQpIFRFU1RTRVRGTEFHKExvY2tlZCwgbG9ja2VkKQotUEFHRUZMQUcoRXJyb3IsIGVycm9yKQorUEFHRUZMQUcoRXJyb3IsIGVycm9yKSBURVNUQ0xFQVJGTEFHKEVycm9yLCBlcnJvcikKIFBBR0VGTEFHKFJlZmVyZW5jZWQsIHJlZmVyZW5jZWQpIFRFU1RDTEVBUkZMQUcoUmVmZXJlbmNlZCwgcmVmZXJlbmNlZCkKIFBBR0VGTEFHKERpcnR5LCBkaXJ0eSkgVEVTVFNDRkxBRyhEaXJ0eSwgZGlydHkpIF9fQ0xFQVJQQUdFRkxBRyhEaXJ0eSwgZGlydHkpCiBQQUdFRkxBRyhMUlUsIGxydSkgX19DTEVBUlBBR0VGTEFHKExSVSwgbHJ1KQpAQCAtMjMwLDcgKzIyOSw2IEBACiAgKiByaXNreTogdGhleSBieXBhc3MgcGFnZSBhY2NvdW50aW5nLgogICovCiBURVNUUEFHRUZMQUcoV3JpdGViYWNrLCB3cml0ZWJhY2spIFRFU1RTQ0ZMQUcoV3JpdGViYWNrLCB3cml0ZWJhY2spCi1fX1BBR0VGTEFHKEJ1ZGR5LCBidWRkeSkKIFBBR0VGTEFHKE1hcHBlZFRvRGlzaywgbWFwcGVkdG9kaXNrKQogCiAvKiBQR19yZWFkYWhlYWQgaXMgb25seSB1c2VkIGZvciBmaWxlIHJlYWRzOyBQR19yZWNsYWltIGlzIG9ubHkgZm9yIHdyaXRlcyAqLwpAQCAtMzQ0LDcgKzM0Miw3IEBACiAgKiB0ZXN0cyBjYW4gYmUgdXNlZCBpbiBwZXJmb3JtYW5jZSBzZW5zaXRpdmUgcGF0aHMuIFBhZ2VDb21wb3VuZCBpcwogICogZ2VuZXJhbGx5IG5vdCB1c2VkIGluIGhvdCBjb2RlIHBhdGhzLgogICovCi1fX1BBR0VGTEFHKEhlYWQsIGhlYWQpCitfX1BBR0VGTEFHKEhlYWQsIGhlYWQpIENMRUFSUEFHRUZMQUcoSGVhZCwgaGVhZCkKIF9fUEFHRUZMQUcoVGFpbCwgdGFpbCkKIAogc3RhdGljIGlubGluZSBpbnQgUGFnZUNvbXBvdW5kKHN0cnVjdCBwYWdlICpwYWdlKQpAQCAtMzUyLDYgKzM1MCwxMyBAQAogCXJldHVybiBwYWdlLT5mbGFncyAmICgoMUwgPDwgUEdfaGVhZCkgfCAoMUwgPDwgUEdfdGFpbCkpOwogCiB9CisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCitzdGF0aWMgaW5saW5lIHZvaWQgQ2xlYXJQYWdlQ29tcG91bmQoc3RydWN0IHBhZ2UgKnBhZ2UpCit7CisJQlVHX09OKCFQYWdlSGVhZChwYWdlKSk7CisJQ2xlYXJQYWdlSGVhZChwYWdlKTsKK30KKyNlbmRpZgogI2Vsc2UKIC8qCiAgKiBSZWR1Y2UgcGFnZSBmbGFnIHVzZSBhcyBtdWNoIGFzIHBvc3NpYmxlIGJ5IG92ZXJsYXBwaW5nCkBAIC0zODksMTQgKzM5NCw2MSBAQAogCXBhZ2UtPmZsYWdzICY9IH5QR19oZWFkX3RhaWxfbWFzazsKIH0KIAorI2lmZGVmIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRQorc3RhdGljIGlubGluZSB2b2lkIENsZWFyUGFnZUNvbXBvdW5kKHN0cnVjdCBwYWdlICpwYWdlKQoreworCUJVR19PTigocGFnZS0+ZmxhZ3MgJiBQR19oZWFkX3RhaWxfbWFzaykgIT0gKDEgPDwgUEdfY29tcG91bmQpKTsKKwljbGVhcl9iaXQoUEdfY29tcG91bmQsICZwYWdlLT5mbGFncyk7Cit9CisjZW5kaWYKKwogI2VuZGlmIC8qICFQQUdFRkxBR1NfRVhURU5ERUQgKi8KIAorI2lmZGVmIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRQorLyoKKyAqIFBhZ2VIdWdlKCkgb25seSByZXR1cm5zIHRydWUgZm9yIGh1Z2V0bGJmcyBwYWdlcywgYnV0IG5vdCBmb3IKKyAqIG5vcm1hbCBvciB0cmFuc3BhcmVudCBodWdlIHBhZ2VzLgorICoKKyAqIFBhZ2VUcmFuc0h1Z2UoKSByZXR1cm5zIHRydWUgZm9yIGJvdGggdHJhbnNwYXJlbnQgaHVnZSBhbmQKKyAqIGh1Z2V0bGJmcyBwYWdlcywgYnV0IG5vdCBub3JtYWwgcGFnZXMuIFBhZ2VUcmFuc0h1Z2UoKSBjYW4gb25seSBiZQorICogY2FsbGVkIG9ubHkgaW4gdGhlIGNvcmUgVk0gcGF0aHMgd2hlcmUgaHVnZXRsYmZzIHBhZ2VzIGNhbid0IGV4aXN0LgorICovCitzdGF0aWMgaW5saW5lIGludCBQYWdlVHJhbnNIdWdlKHN0cnVjdCBwYWdlICpwYWdlKQoreworCVZNX0JVR19PTihQYWdlVGFpbChwYWdlKSk7CisJcmV0dXJuIFBhZ2VIZWFkKHBhZ2UpOworfQorCitzdGF0aWMgaW5saW5lIGludCBQYWdlVHJhbnNDb21wb3VuZChzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwlyZXR1cm4gUGFnZUNvbXBvdW5kKHBhZ2UpOworfQorCisjZWxzZQorCitzdGF0aWMgaW5saW5lIGludCBQYWdlVHJhbnNIdWdlKHN0cnVjdCBwYWdlICpwYWdlKQoreworCXJldHVybiAwOworfQorCitzdGF0aWMgaW5saW5lIGludCBQYWdlVHJhbnNDb21wb3VuZChzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwlyZXR1cm4gMDsKK30KKyNlbmRpZgorCiAjaWZkZWYgQ09ORklHX01NVQogI2RlZmluZSBfX1BHX01MT0NLRUQJCSgxIDw8IFBHX21sb2NrZWQpCiAjZWxzZQogI2RlZmluZSBfX1BHX01MT0NLRUQJCTAKICNlbmRpZgogCisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCisjZGVmaW5lIF9fUEdfQ09NUE9VTkRfTE9DSwkJKDEgPDwgUEdfY29tcG91bmRfbG9jaykKKyNlbHNlCisjZGVmaW5lIF9fUEdfQ09NUE9VTkRfTE9DSwkJMAorI2VuZGlmCisKIC8qCiAgKiBGbGFncyBjaGVja2VkIHdoZW4gYSBwYWdlIGlzIGZyZWVkLiAgUGFnZXMgYmVpbmcgZnJlZWQgc2hvdWxkIG5vdCBoYXZlCiAgKiB0aGVzZSBmbGFncyBzZXQuICBJdCB0aGV5IGFyZSwgdGhlcmUgaXMgYSBwcm9ibGVtLgpAQCAtNDA0LDkgKzQ1NiwxMCBAQAogI2RlZmluZSBQQUdFX0ZMQUdTX0NIRUNLX0FUX0ZSRUUgXAogCSgxIDw8IFBHX2xydQkgfCAxIDw8IFBHX2xvY2tlZCAgICB8IFwKIAkgMSA8PCBQR19wcml2YXRlIHwgMSA8PCBQR19wcml2YXRlXzIgfCBcCi0JIDEgPDwgUEdfYnVkZHkJIHwgMSA8PCBQR193cml0ZWJhY2sgfCAxIDw8IFBHX3Jlc2VydmVkIHwgXAorCSAxIDw8IFBHX3dyaXRlYmFjayB8IDEgPDwgUEdfcmVzZXJ2ZWQgfCBcCiAJIDEgPDwgUEdfc2xhYgkgfCAxIDw8IFBHX3N3YXBjYWNoZSB8IDEgPDwgUEdfYWN0aXZlIHwgXAotCSAxIDw8IFBHX3VuZXZpY3RhYmxlIHwgX19QR19NTE9DS0VEIHwgX19QR19IV1BPSVNPTikKKwkgMSA8PCBQR191bmV2aWN0YWJsZSB8IF9fUEdfTUxPQ0tFRCB8IF9fUEdfSFdQT0lTT04gfCBcCisJIF9fUEdfQ09NUE9VTkRfTE9DSykKIAogLyoKICAqIEZsYWdzIGNoZWNrZWQgd2hlbiBhIHBhZ2UgaXMgcHJlcHBlZCBmb3IgcmV0dXJuIGJ5IHRoZSBwYWdlIGFsbG9jYXRvci4KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGFnZV9jZ3JvdXAuaCBiL2luY2x1ZGUvbGludXgvcGFnZV9jZ3JvdXAuaAppbmRleCBiMDIxOTVkLi42ZDZjYjdhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3BhZ2VfY2dyb3VwLmgKKysrIGIvaW5jbHVkZS9saW51eC9wYWdlX2Nncm91cC5oCkBAIC0zNSwxMiArMzUsMTUgQEAKIAogZW51bSB7CiAJLyogZmxhZ3MgZm9yIG1lbV9jZ3JvdXAgKi8KLQlQQ0dfTE9DSywgIC8qIHBhZ2UgY2dyb3VwIGlzIGxvY2tlZCAqLworCVBDR19MT0NLLCAgLyogTG9jayBmb3IgcGMtPm1lbV9jZ3JvdXAgYW5kIGZvbGxvd2luZyBiaXRzLiAqLwogCVBDR19DQUNIRSwgLyogY2hhcmdlZCBhcyBjYWNoZSAqLwogCVBDR19VU0VELCAvKiB0aGlzIG9iamVjdCBpcyBpbiB1c2UuICovCi0JUENHX0FDQ1RfTFJVLCAvKiBwYWdlIGhhcyBiZWVuIGFjY291bnRlZCBmb3IgKi8KLQlQQ0dfRklMRV9NQVBQRUQsIC8qIHBhZ2UgaXMgYWNjb3VudGVkIGFzICJtYXBwZWQiICovCiAJUENHX01JR1JBVElPTiwgLyogdW5kZXIgcGFnZSBtaWdyYXRpb24gKi8KKwkvKiBmbGFncyBmb3IgbWVtX2Nncm91cCBhbmQgZmlsZSBhbmQgSS9PIHN0YXR1cyAqLworCVBDR19NT1ZFX0xPQ0ssIC8qIEZvciByYWNlIGJldHdlZW4gbW92ZV9hY2NvdW50IHYucy4gZm9sbG93aW5nIGJpdHMgKi8KKwlQQ0dfRklMRV9NQVBQRUQsIC8qIHBhZ2UgaXMgYWNjb3VudGVkIGFzICJtYXBwZWQiICovCisJLyogTm8gbG9jayBpbiBwYWdlX2Nncm91cCAqLworCVBDR19BQ0NUX0xSVSwgLyogcGFnZSBoYXMgYmVlbiBhY2NvdW50ZWQgZm9yICh1bmRlciBscnVfbG9jaykgKi8KIH07CiAKICNkZWZpbmUgVEVTVFBDR0ZMQUcodW5hbWUsIGxuYW1lKQkJCVwKQEAgLTk0LDYgKzk3LDEwIEBACiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBsb2NrX3BhZ2VfY2dyb3VwKHN0cnVjdCBwYWdlX2Nncm91cCAqcGMpCiB7CisJLyoKKwkgKiBEb24ndCB0YWtlIHRoaXMgbG9jayBpbiBJUlEgY29udGV4dC4KKwkgKiBUaGlzIGxvY2sgaXMgZm9yIHBjLT5tZW1fY2dyb3VwLCBVU0VELCBDQUNIRSwgTUlHUkFUSU9OCisJICovCiAJYml0X3NwaW5fbG9jayhQQ0dfTE9DSywgJnBjLT5mbGFncyk7CiB9CiAKQEAgLTEwNyw2ICsxMTQsMjQgQEAKIAlyZXR1cm4gYml0X3NwaW5faXNfbG9ja2VkKFBDR19MT0NLLCAmcGMtPmZsYWdzKTsKIH0KIAorc3RhdGljIGlubGluZSB2b2lkIG1vdmVfbG9ja19wYWdlX2Nncm91cChzdHJ1Y3QgcGFnZV9jZ3JvdXAgKnBjLAorCXVuc2lnbmVkIGxvbmcgKmZsYWdzKQoreworCS8qCisJICogV2Uga25vdyB1cGRhdGVzIHRvIHBjLT5mbGFncyBvZiBwYWdlIGNhY2hlJ3Mgc3RhdHMgYXJlIGZyb20gYm90aCBvZgorCSAqIHVzdWFsIGNvbnRleHQgb3IgSVJRIGNvbnRleHQuIERpc2FibGUgSVJRIHRvIGF2b2lkIGRlYWRsb2NrLgorCSAqLworCWxvY2FsX2lycV9zYXZlKCpmbGFncyk7CisJYml0X3NwaW5fbG9jayhQQ0dfTU9WRV9MT0NLLCAmcGMtPmZsYWdzKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIG1vdmVfdW5sb2NrX3BhZ2VfY2dyb3VwKHN0cnVjdCBwYWdlX2Nncm91cCAqcGMsCisJdW5zaWduZWQgbG9uZyAqZmxhZ3MpCit7CisJYml0X3NwaW5fdW5sb2NrKFBDR19NT1ZFX0xPQ0ssICZwYy0+ZmxhZ3MpOworCWxvY2FsX2lycV9yZXN0b3JlKCpmbGFncyk7Cit9CisKICNlbHNlIC8qIENPTkZJR19DR1JPVVBfTUVNX1JFU19DVExSICovCiBzdHJ1Y3QgcGFnZV9jZ3JvdXA7CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGFnZW1hcC5oIGIvaW5jbHVkZS9saW51eC9wYWdlbWFwLmgKaW5kZXggMmQxZmZlMy4uOWM2NmU5OSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9wYWdlbWFwLmgKKysrIGIvaW5jbHVkZS9saW51eC9wYWdlbWFwLmgKQEAgLTQ4LDcgKzQ4LDcgQEAKIAogc3RhdGljIGlubGluZSBpbnQgbWFwcGluZ191bmV2aWN0YWJsZShzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqbWFwcGluZykKIHsKLQlpZiAobGlrZWx5KG1hcHBpbmcpKQorCWlmIChtYXBwaW5nKQogCQlyZXR1cm4gdGVzdF9iaXQoQVNfVU5FVklDVEFCTEUsICZtYXBwaW5nLT5mbGFncyk7CiAJcmV0dXJuICEhbWFwcGluZzsKIH0KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGF0aC5oIGIvaW5jbHVkZS9saW51eC9wYXRoLmgKaW5kZXggYTU4MWU4Yy4uZWRjOThkZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9wYXRoLmgKKysrIGIvaW5jbHVkZS9saW51eC9wYXRoLmgKQEAgLTEwLDkgKzEwLDcgQEAKIH07CiAKIGV4dGVybiB2b2lkIHBhdGhfZ2V0KHN0cnVjdCBwYXRoICopOwotZXh0ZXJuIHZvaWQgcGF0aF9nZXRfbG9uZyhzdHJ1Y3QgcGF0aCAqKTsKIGV4dGVybiB2b2lkIHBhdGhfcHV0KHN0cnVjdCBwYXRoICopOwotZXh0ZXJuIHZvaWQgcGF0aF9wdXRfbG9uZyhzdHJ1Y3QgcGF0aCAqKTsKIAogc3RhdGljIGlubGluZSBpbnQgcGF0aF9lcXVhbChjb25zdCBzdHJ1Y3QgcGF0aCAqcGF0aDEsIGNvbnN0IHN0cnVjdCBwYXRoICpwYXRoMikKIHsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGNpLWFjcGkuaCBiL2luY2x1ZGUvbGludXgvcGNpLWFjcGkuaAppbmRleCBjOGI2NDczLi40NDYyMzUwIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3BjaS1hY3BpLmgKKysrIGIvaW5jbHVkZS9saW51eC9wY2ktYWNwaS5oCkBAIC0zNSw5ICszNSwxMiBAQAogCXJldHVybiBhY3BpX2dldF9wY2lfcm9vdGJyaWRnZV9oYW5kbGUocGNpX2RvbWFpbl9ucihwYnVzKSwKIAkJCQkJICAgICAgcGJ1cy0+bnVtYmVyKTsKIH0KKyNlbmRpZgorCisjaWZkZWYgQ09ORklHX0FDUElfQVBFSQorZXh0ZXJuIGJvb2wgYWVyX2FjcGlfZmlybXdhcmVfZmlyc3Qodm9pZCk7CiAjZWxzZQotc3RhdGljIGlubGluZSBhY3BpX2hhbmRsZSBhY3BpX2ZpbmRfcm9vdF9icmlkZ2VfaGFuZGxlKHN0cnVjdCBwY2lfZGV2ICpwZGV2KQoteyByZXR1cm4gTlVMTDsgfQorc3RhdGljIGlubGluZSBib29sIGFlcl9hY3BpX2Zpcm13YXJlX2ZpcnN0KHZvaWQpIHsgcmV0dXJuIGZhbHNlOyB9CiAjZW5kaWYKIAogI2VuZGlmCS8qIF9QQ0lfQUNQSV9IXyAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9wY2ktYXNwbS5oIGIvaW5jbHVkZS9saW51eC9wY2ktYXNwbS5oCmluZGV4IDkxYmEwYjMuLmNlNjgxMDUxIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3BjaS1hc3BtLmgKKysrIGIvaW5jbHVkZS9saW51eC9wY2ktYXNwbS5oCkBAIC0yNyw2ICsyNyw3IEBACiBleHRlcm4gdm9pZCBwY2llX2FzcG1fZXhpdF9saW5rX3N0YXRlKHN0cnVjdCBwY2lfZGV2ICpwZGV2KTsKIGV4dGVybiB2b2lkIHBjaWVfYXNwbV9wbV9zdGF0ZV9jaGFuZ2Uoc3RydWN0IHBjaV9kZXYgKnBkZXYpOwogZXh0ZXJuIHZvaWQgcGNpX2Rpc2FibGVfbGlua19zdGF0ZShzdHJ1Y3QgcGNpX2RldiAqcGRldiwgaW50IHN0YXRlKTsKK2V4dGVybiB2b2lkIHBjaWVfY2xlYXJfYXNwbSh2b2lkKTsKIGV4dGVybiB2b2lkIHBjaWVfbm9fYXNwbSh2b2lkKTsKICNlbHNlCiBzdGF0aWMgaW5saW5lIHZvaWQgcGNpZV9hc3BtX2luaXRfbGlua19zdGF0ZShzdHJ1Y3QgcGNpX2RldiAqcGRldikKQEAgLTQxLDcgKzQyLDkgQEAKIHN0YXRpYyBpbmxpbmUgdm9pZCBwY2lfZGlzYWJsZV9saW5rX3N0YXRlKHN0cnVjdCBwY2lfZGV2ICpwZGV2LCBpbnQgc3RhdGUpCiB7CiB9Ci0KK3N0YXRpYyBpbmxpbmUgdm9pZCBwY2llX2NsZWFyX2FzcG0odm9pZCkKK3sKK30KIHN0YXRpYyBpbmxpbmUgdm9pZCBwY2llX25vX2FzcG0odm9pZCkKIHsKIH0KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGNpLmggYi9pbmNsdWRlL2xpbnV4L3BjaS5oCmluZGV4IDc0NTQ0MDguLjU1OWQwMjggMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvcGNpLmgKKysrIGIvaW5jbHVkZS9saW51eC9wY2kuaApAQCAtODA2LDcgKzgwNiw3IEBACiAKIC8qIFBvd2VyIG1hbmFnZW1lbnQgcmVsYXRlZCByb3V0aW5lcyAqLwogaW50IHBjaV9zYXZlX3N0YXRlKHN0cnVjdCBwY2lfZGV2ICpkZXYpOwotaW50IHBjaV9yZXN0b3JlX3N0YXRlKHN0cnVjdCBwY2lfZGV2ICpkZXYpOwordm9pZCBwY2lfcmVzdG9yZV9zdGF0ZShzdHJ1Y3QgcGNpX2RldiAqZGV2KTsKIGludCBfX3BjaV9jb21wbGV0ZV9wb3dlcl90cmFuc2l0aW9uKHN0cnVjdCBwY2lfZGV2ICpkZXYsIHBjaV9wb3dlcl90IHN0YXRlKTsKIGludCBwY2lfc2V0X3Bvd2VyX3N0YXRlKHN0cnVjdCBwY2lfZGV2ICpkZXYsIHBjaV9wb3dlcl90IHN0YXRlKTsKIHBjaV9wb3dlcl90IHBjaV9jaG9vc2Vfc3RhdGUoc3RydWN0IHBjaV9kZXYgKmRldiwgcG1fbWVzc2FnZV90IHN0YXRlKTsKQEAgLTgyMCw3ICs4MjAsNiBAQAogaW50IHBjaV9iYWNrX2Zyb21fc2xlZXAoc3RydWN0IHBjaV9kZXYgKmRldik7CiBib29sIHBjaV9kZXZfcnVuX3dha2Uoc3RydWN0IHBjaV9kZXYgKmRldik7CiBib29sIHBjaV9jaGVja19wbWVfc3RhdHVzKHN0cnVjdCBwY2lfZGV2ICpkZXYpOwotdm9pZCBwY2lfd2FrZXVwX2V2ZW50KHN0cnVjdCBwY2lfZGV2ICpkZXYpOwogdm9pZCBwY2lfcG1lX3dha2V1cF9idXMoc3RydWN0IHBjaV9idXMgKmJ1cyk7CiAKIHN0YXRpYyBpbmxpbmUgaW50IHBjaV9lbmFibGVfd2FrZShzdHJ1Y3QgcGNpX2RldiAqZGV2LCBwY2lfcG93ZXJfdCBzdGF0ZSwKQEAgLTk5NCw2ICs5OTMsMTQgQEAKIGV4dGVybiBpbnQgcGNpX21zaV9lbmFibGVkKHZvaWQpOwogI2VuZGlmCiAKKyNpZmRlZiBDT05GSUdfUENJRVBPUlRCVVMKK2V4dGVybiBib29sIHBjaWVfcG9ydHNfZGlzYWJsZWQ7CitleHRlcm4gYm9vbCBwY2llX3BvcnRzX2F1dG87CisjZWxzZQorI2RlZmluZSBwY2llX3BvcnRzX2Rpc2FibGVkCXRydWUKKyNkZWZpbmUgcGNpZV9wb3J0c19hdXRvCQlmYWxzZQorI2VuZGlmCisKICNpZm5kZWYgQ09ORklHX1BDSUVBU1BNCiBzdGF0aWMgaW5saW5lIGludCBwY2llX2FzcG1fZW5hYmxlZCh2b2lkKQogewpAQCAtMTAwMyw2ICsxMDEwLDE0IEBACiBleHRlcm4gaW50IHBjaWVfYXNwbV9lbmFibGVkKHZvaWQpOwogI2VuZGlmCiAKKyNpZmRlZiBDT05GSUdfUENJRUFFUgordm9pZCBwY2lfbm9fYWVyKHZvaWQpOworYm9vbCBwY2lfYWVyX2F2YWlsYWJsZSh2b2lkKTsKKyNlbHNlCitzdGF0aWMgaW5saW5lIHZvaWQgcGNpX25vX2Flcih2b2lkKSB7IH0KK3N0YXRpYyBpbmxpbmUgYm9vbCBwY2lfYWVyX2F2YWlsYWJsZSh2b2lkKSB7IHJldHVybiBmYWxzZTsgfQorI2VuZGlmCisKICNpZm5kZWYgQ09ORklHX1BDSUVfRUNSQwogc3RhdGljIGlubGluZSB2b2lkIHBjaWVfc2V0X2VjcmNfY2hlY2tpbmcoc3RydWN0IHBjaV9kZXYgKmRldikKIHsKQEAgLTExNjgsMTAgKzExODMsOCBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW5saW5lIGludCBwY2lfcmVzdG9yZV9zdGF0ZShzdHJ1Y3QgcGNpX2RldiAqZGV2KQotewotCXJldHVybiAwOwotfQorc3RhdGljIGlubGluZSB2b2lkIHBjaV9yZXN0b3JlX3N0YXRlKHN0cnVjdCBwY2lfZGV2ICpkZXYpCit7IH0KIAogc3RhdGljIGlubGluZSBpbnQgcGNpX3NldF9wb3dlcl9zdGF0ZShzdHJ1Y3QgcGNpX2RldiAqZGV2LCBwY2lfcG93ZXJfdCBzdGF0ZSkKIHsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGNpX2lkcy5oIGIvaW5jbHVkZS9saW51eC9wY2lfaWRzLmgKaW5kZXggYWUwZGM0NS4uM2FkYjA2ZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9wY2lfaWRzLmgKKysrIGIvaW5jbHVkZS9saW51eC9wY2lfaWRzLmgKQEAgLTI0NzgsNyArMjQ3OCw4IEBACiAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfSU5URUxfQ09VR0FSUE9JTlRfTFBDX01JTgkweDFjNDEKICNkZWZpbmUgUENJX0RFVklDRV9JRF9JTlRFTF9DT1VHQVJQT0lOVF9MUENfTUFYCTB4MWM1ZgogI2RlZmluZSBQQ0lfREVWSUNFX0lEX0lOVEVMX1BBVFNCVVJHX1NNQlVTCTB4MWQyMgotI2RlZmluZSBQQ0lfREVWSUNFX0lEX0lOVEVMX1BBVFNCVVJHX0xQQwkweDFkNDAKKyNkZWZpbmUgUENJX0RFVklDRV9JRF9JTlRFTF9QQVRTQlVSR19MUENfMAkweDFkNDAKKyNkZWZpbmUgUENJX0RFVklDRV9JRF9JTlRFTF9QQVRTQlVSR19MUENfMQkweDFkNDEKICNkZWZpbmUgUENJX0RFVklDRV9JRF9JTlRFTF84MjgwMUFBXzAJMHgyNDEwCiAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfSU5URUxfODI4MDFBQV8xCTB4MjQxMQogI2RlZmluZSBQQ0lfREVWSUNFX0lEX0lOVEVMXzgyODAxQUFfMwkweDI0MTMKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGNpX3JlZ3MuaCBiL2luY2x1ZGUvbGludXgvcGNpX3JlZ3MuaAppbmRleCBhZjgzMDc2Li41YjdlNmIxIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3BjaV9yZWdzLmgKKysrIGIvaW5jbHVkZS9saW51eC9wY2lfcmVncy5oCkBAIC0zMDksNiArMzA5LDE0IEBACiAjZGVmaW5lIFBDSV9NU0lYX1BCQQkJOAogI2RlZmluZSAgUENJX01TSVhfRkxBR1NfQklSTUFTSwkoNyA8PCAwKQogCisvKiBNU0ktWCBlbnRyeSdzIGZvcm1hdCAqLworI2RlZmluZSBQQ0lfTVNJWF9FTlRSWV9TSVpFCQkxNgorI2RlZmluZSAgUENJX01TSVhfRU5UUllfTE9XRVJfQUREUgkwCisjZGVmaW5lICBQQ0lfTVNJWF9FTlRSWV9VUFBFUl9BRERSCTQKKyNkZWZpbmUgIFBDSV9NU0lYX0VOVFJZX0RBVEEJCTgKKyNkZWZpbmUgIFBDSV9NU0lYX0VOVFJZX1ZFQ1RPUl9DVFJMCTEyCisjZGVmaW5lICAgUENJX01TSVhfRU5UUllfQ1RSTF9NQVNLQklUCTEKKwogLyogQ29tcGFjdFBDSSBIb3Rzd2FwIFJlZ2lzdGVyICovCiAKICNkZWZpbmUgUENJX0NIU1dQX0NTUgkJMgkvKiBDb250cm9sIGFuZCBTdGF0dXMgUmVnaXN0ZXIgKi8KQEAgLTQ5Niw2ICs1MDQsOCBAQAogI2RlZmluZSAgUENJX0VYUF9SVENUTF9DUlNTVkUJMHgxMAkvKiBDUlMgU29mdHdhcmUgVmlzaWJpbGl0eSBFbmFibGUgKi8KICNkZWZpbmUgUENJX0VYUF9SVENBUAkJMzAJLyogUm9vdCBDYXBhYmlsaXRpZXMgKi8KICNkZWZpbmUgUENJX0VYUF9SVFNUQQkJMzIJLyogUm9vdCBTdGF0dXMgKi8KKyNkZWZpbmUgUENJX0VYUF9SVFNUQV9QTUUJMHgxMDAwMCAvKiBQTUUgc3RhdHVzICovCisjZGVmaW5lIFBDSV9FWFBfUlRTVEFfUEVORElORwkweDIwMDAwIC8qIFBNRSBwZW5kaW5nICovCiAjZGVmaW5lIFBDSV9FWFBfREVWQ0FQMgkJMzYJLyogRGV2aWNlIENhcGFiaWxpdGllcyAyICovCiAjZGVmaW5lICBQQ0lfRVhQX0RFVkNBUDJfQVJJCTB4MjAJLyogQWx0ZXJuYXRpdmUgUm91dGluZy1JRCAqLwogI2RlZmluZSBQQ0lfRVhQX0RFVkNUTDIJCTQwCS8qIERldmljZSBDb250cm9sIDIgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcG9zaXhfYWNsLmggYi9pbmNsdWRlL2xpbnV4L3Bvc2l4X2FjbC5oCmluZGV4IGQ2ODI4M2EuLjU0MjExYzEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvcG9zaXhfYWNsLmgKKysrIGIvaW5jbHVkZS9saW51eC9wb3NpeF9hY2wuaApAQCAtNzEsNiArNzEsNyBAQAogCiAvKiBwb3NpeF9hY2wuYyAqLwogCitleHRlcm4gdm9pZCBwb3NpeF9hY2xfaW5pdChzdHJ1Y3QgcG9zaXhfYWNsICosIGludCk7CiBleHRlcm4gc3RydWN0IHBvc2l4X2FjbCAqcG9zaXhfYWNsX2FsbG9jKGludCwgZ2ZwX3QpOwogZXh0ZXJuIHN0cnVjdCBwb3NpeF9hY2wgKnBvc2l4X2FjbF9jbG9uZShjb25zdCBzdHJ1Y3QgcG9zaXhfYWNsICosIGdmcF90KTsKIGV4dGVybiBpbnQgcG9zaXhfYWNsX3ZhbGlkKGNvbnN0IHN0cnVjdCBwb3NpeF9hY2wgKik7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3Bvd2VyL2dwaW8tY2hhcmdlci5oIGIvaW5jbHVkZS9saW51eC9wb3dlci9ncGlvLWNoYXJnZXIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kZTFkZmUwCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS9saW51eC9wb3dlci9ncGlvLWNoYXJnZXIuaApAQCAtMCwwICsxLDQxIEBACisvKgorICogIENvcHlyaWdodCAoQykgMjAxMCwgTGFycy1QZXRlciBDbGF1c2VuIDxsYXJzQG1ldGFmb28uZGU+CisgKgorICogIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiAgdW5kZXIgIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKKyAqICBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247ICBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91cgorICogIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFsb25nCisgKiAgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKKyAqICA2NzUgTWFzcyBBdmUsIENhbWJyaWRnZSwgTUEgMDIxMzksIFVTQS4KKyAqCisgKi8KKworI2lmbmRlZiBfX0xJTlVYX1BPV0VSX0dQSU9fQ0hBUkdFUl9IX18KKyNkZWZpbmUgX19MSU5VWF9QT1dFUl9HUElPX0NIQVJHRVJfSF9fCisKKyNpbmNsdWRlIDxsaW51eC9wb3dlcl9zdXBwbHkuaD4KKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorCisvKioKKyAqIHN0cnVjdCBncGlvX2NoYXJnZXJfcGxhdGZvcm1fZGF0YSAtIHBsYXRmb3JtX2RhdGEgZm9yIGdwaW9fY2hhcmdlciBkZXZpY2VzCisgKiBAbmFtZToJCU5hbWUgZm9yIHRoZSBjaGFyZ2VycyBwb3dlcl9zdXBwbHkgZGV2aWNlCisgKiBAdHlwZToJCVR5cGUgb2YgdGhlIGNoYXJnZXIKKyAqIEBncGlvOgkJR1BJTyB3aGljaCBpcyB1c2VkIHRvIGluZGljYXRlIHRoZSBjaGFyZ2VycyBzdGF0dXMKKyAqIEBncGlvX2FjdGl2ZV9sb3c6CVNob3VsZCBiZSBzZXQgdG8gMSBpZiB0aGUgR1BJTyBpcyBhY3RpdmUgbG93IG90aGVyd2lzZSAwCisgKiBAc3VwcGxpZWRfdG86CUFycmF5IG9mIGJhdHRlcnkgbmFtZXMgdG8gd2hpY2ggdGhpcyBjaGFyZ2VycyBzdXBwbGllcyBwb3dlcgorICogQG51bV9zdXBwbGljYW50czoJTnVtYmVyIG9mIGVudHJpZXMgaW4gdGhlIHN1cHBsaWVkX3RvIGFycmF5CisgKi8KK3N0cnVjdCBncGlvX2NoYXJnZXJfcGxhdGZvcm1fZGF0YSB7CisJY29uc3QgY2hhciAqbmFtZTsKKwllbnVtIHBvd2VyX3N1cHBseV90eXBlIHR5cGU7CisKKwlpbnQgZ3BpbzsKKwlpbnQgZ3Bpb19hY3RpdmVfbG93OworCisJY2hhciAqKnN1cHBsaWVkX3RvOworCXNpemVfdCBudW1fc3VwcGxpY2FudHM7Cit9OworCisjZW5kaWYKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcG93ZXIvbWF4MTcwNDJfYmF0dGVyeS5oIGIvaW5jbHVkZS9saW51eC9wb3dlci9tYXgxNzA0Ml9iYXR0ZXJ5LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzk5NWRlYgotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvbGludXgvcG93ZXIvbWF4MTcwNDJfYmF0dGVyeS5oCkBAIC0wLDAgKzEsMzAgQEAKKy8qCisgKiBGdWVsIGdhdWdlIGRyaXZlciBmb3IgTWF4aW0gMTcwNDIgLyA4OTY2IC8gODk5NworICogIE5vdGUgdGhhdCBNYXhpbSA4OTY2IGFuZCA4OTk3IGFyZSBtZmQgYW5kIHRoaXMgaXMgaXRzIHN1YmRldmljZS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgU2Ftc3VuZyBFbGVjdHJvbmljcworICogTXl1bmdKb28gSGFtIDxteXVuZ2pvby5oYW1Ac2Ftc3VuZy5jb20+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgIDAyMTExLTEzMDcgIFVTQQorICovCisKKyNpZm5kZWYgX19NQVgxNzA0Ml9CQVRURVJZX0hfCisjZGVmaW5lIF9fTUFYMTcwNDJfQkFUVEVSWV9IXworCitzdHJ1Y3QgbWF4MTcwNDJfcGxhdGZvcm1fZGF0YSB7CisJYm9vbCBlbmFibGVfY3VycmVudF9zZW5zZTsKK307CisKKyNlbmRpZiAvKiBfX01BWDE3MDQyX0JBVFRFUllfSF8gKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcXVvdGEuaCBiL2luY2x1ZGUvbGludXgvcXVvdGEuaAppbmRleCA5NGMxZjAzLi45YTg1NDEyIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3F1b3RhLmgKKysrIGIvaW5jbHVkZS9saW51eC9xdW90YS5oCkBAIC0zMjIsOSArMzIyLDEyIEBACiAJcXNpemVfdCAqKCpnZXRfcmVzZXJ2ZWRfc3BhY2UpIChzdHJ1Y3QgaW5vZGUgKik7CiB9OwogCitzdHJ1Y3QgcGF0aDsKKwogLyogT3BlcmF0aW9ucyBoYW5kbGluZyByZXF1ZXN0cyBmcm9tIHVzZXJzcGFjZSAqLwogc3RydWN0IHF1b3RhY3RsX29wcyB7Ci0JaW50ICgqcXVvdGFfb24pKHN0cnVjdCBzdXBlcl9ibG9jayAqLCBpbnQsIGludCwgY2hhciAqKTsKKwlpbnQgKCpxdW90YV9vbikoc3RydWN0IHN1cGVyX2Jsb2NrICosIGludCwgaW50LCBzdHJ1Y3QgcGF0aCAqKTsKKwlpbnQgKCpxdW90YV9vbl9tZXRhKShzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiwgaW50LCBpbnQpOwogCWludCAoKnF1b3RhX29mZikoc3RydWN0IHN1cGVyX2Jsb2NrICosIGludCk7CiAJaW50ICgqcXVvdGFfc3luYykoc3RydWN0IHN1cGVyX2Jsb2NrICosIGludCwgaW50KTsKIAlpbnQgKCpnZXRfaW5mbykoc3RydWN0IHN1cGVyX2Jsb2NrICosIGludCwgc3RydWN0IGlmX2RxaW5mbyAqKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcXVvdGFvcHMuaCBiL2luY2x1ZGUvbGludXgvcXVvdGFvcHMuaAppbmRleCAyMjNiMTRjLi5lYjM1NGY2IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3F1b3Rhb3BzLmgKKysrIGIvaW5jbHVkZS9saW51eC9xdW90YW9wcy5oCkBAIC03NiwxMSArNzYsOSBAQAogCiBpbnQgZHF1b3RfZmlsZV9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKTsKIAotaW50IGRxdW90X3F1b3RhX29uKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIGludCB0eXBlLCBpbnQgZm9ybWF0X2lkLAotCWNoYXIgKnBhdGgpOwogaW50IGRxdW90X2VuYWJsZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBpbnQgdHlwZSwgaW50IGZvcm1hdF9pZCwKIAl1bnNpZ25lZCBpbnQgZmxhZ3MpOwotaW50IGRxdW90X3F1b3RhX29uX3BhdGgoc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHR5cGUsIGludCBmb3JtYXRfaWQsCitpbnQgZHF1b3RfcXVvdGFfb24oc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHR5cGUsIGludCBmb3JtYXRfaWQsCiAgCXN0cnVjdCBwYXRoICpwYXRoKTsKIGludCBkcXVvdF9xdW90YV9vbl9tb3VudChzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBjaGFyICpxZl9uYW1lLAogIAlpbnQgZm9ybWF0X2lkLCBpbnQgdHlwZSk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3JhZGl4LXRyZWUuaCBiL2luY2x1ZGUvbGludXgvcmFkaXgtdHJlZS5oCmluZGV4IGFiMmJhYTUuLjIzMjQxYzIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvcmFkaXgtdHJlZS5oCisrKyBiL2luY2x1ZGUvbGludXgvcmFkaXgtdHJlZS5oCkBAIC0xNDYsNiArMTQ2LDIyIEBACiB9CiAKIC8qKgorICogcmFkaXhfdHJlZV9kZXJlZl9zbG90X3Byb3RlY3RlZAktIGRlcmVmZXJlbmNlIGEgc2xvdCB3aXRob3V0IFJDVSBsb2NrIGJ1dCB3aXRoIHRyZWUgbG9jayBoZWxkCisgKiBAcHNsb3Q6CXBvaW50ZXIgdG8gc2xvdCwgcmV0dXJuZWQgYnkgcmFkaXhfdHJlZV9sb29rdXBfc2xvdAorICogUmV0dXJuczoJaXRlbSB0aGF0IHdhcyBzdG9yZWQgaW4gdGhhdCBzbG90IHdpdGggYW55IGRpcmVjdCBwb2ludGVyIGZsYWcKKyAqCQlyZW1vdmVkLgorICoKKyAqIFNpbWlsYXIgdG8gcmFkaXhfdHJlZV9kZXJlZl9zbG90IGJ1dCBvbmx5IHVzZWQgZHVyaW5nIG1pZ3JhdGlvbiB3aGVuIGEgcGFnZXMKKyAqIG1hcHBpbmcgaXMgYmVpbmcgbW92ZWQuIFRoZSBjYWxsZXIgZG9lcyBub3QgaG9sZCB0aGUgUkNVIHJlYWQgbG9jayBidXQgaXQKKyAqIG11c3QgaG9sZCB0aGUgdHJlZSBsb2NrIHRvIHByZXZlbnQgcGFyYWxsZWwgdXBkYXRlcy4KKyAqLworc3RhdGljIGlubGluZSB2b2lkICpyYWRpeF90cmVlX2RlcmVmX3Nsb3RfcHJvdGVjdGVkKHZvaWQgKipwc2xvdCwKKwkJCQkJCQlzcGlubG9ja190ICp0cmVlbG9jaykKK3sKKwlyZXR1cm4gcmN1X2RlcmVmZXJlbmNlX3Byb3RlY3RlZCgqcHNsb3QsIGxvY2tkZXBfaXNfaGVsZCh0cmVlbG9jaykpOworfQorCisvKioKICAqIHJhZGl4X3RyZWVfZGVyZWZfcmV0cnkJLSBjaGVjayByYWRpeF90cmVlX2RlcmVmX3Nsb3QKICAqIEBhcmc6CXBvaW50ZXIgcmV0dXJuZWQgYnkgcmFkaXhfdHJlZV9kZXJlZl9zbG90CiAgKiBSZXR1cm5zOgkwIGlmIHJldHJ5IGlzIG5vdCByZXF1aXJlZCwgb3RoZXJ3aXNlIHJldHJ5IGlzIHJlcXVpcmVkCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3JjdWxpc3RfYmwuaCBiL2luY2x1ZGUvbGludXgvcmN1bGlzdF9ibC5oCmluZGV4IGI4NzJiNDkuLmNmMTI0NGYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvcmN1bGlzdF9ibC5oCisrKyBiL2luY2x1ZGUvbGludXgvcmN1bGlzdF9ibC5oCkBAIC0xMSw3ICsxMSw4IEBACiAJCQkJCXN0cnVjdCBobGlzdF9ibF9ub2RlICpuKQogewogCUxJU1RfQkxfQlVHX09OKCh1bnNpZ25lZCBsb25nKW4gJiBMSVNUX0JMX0xPQ0tNQVNLKTsKLQlMSVNUX0JMX0JVR19PTighKCh1bnNpZ25lZCBsb25nKWgtPmZpcnN0ICYgTElTVF9CTF9MT0NLTUFTSykpOworCUxJU1RfQkxfQlVHX09OKCgodW5zaWduZWQgbG9uZyloLT5maXJzdCAmIExJU1RfQkxfTE9DS01BU0spICE9CisJCQkJCQkJTElTVF9CTF9MT0NLTUFTSyk7CiAJcmN1X2Fzc2lnbl9wb2ludGVyKGgtPmZpcnN0LAogCQkoc3RydWN0IGhsaXN0X2JsX25vZGUgKikoKHVuc2lnbmVkIGxvbmcpbiB8IExJU1RfQkxfTE9DS01BU0spKTsKIH0KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcmVzX2NvdW50ZXIuaCBiL2luY2x1ZGUvbGludXgvcmVzX2NvdW50ZXIuaAppbmRleCBmY2I5ODg0Li5hNTkzMGNiIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3Jlc19jb3VudGVyLmgKKysrIGIvaW5jbHVkZS9saW51eC9yZXNfY291bnRlci5oCkBAIC0xODIsNiArMTgyLDI2IEBACiAJcmV0dXJuIHJldDsKIH0KIAorLyoqCisgKiByZXNfY291bnRlcl9jaGVja19tYXJnaW4gLSBjaGVjayBpZiB0aGUgY291bnRlciBhbGxvd3MgY2hhcmdpbmcKKyAqIEBjbnQ6IHRoZSByZXNvdXJjZSBjb3VudGVyIHRvIGNoZWNrCisgKiBAYnl0ZXM6IHRoZSBudW1iZXIgb2YgYnl0ZXMgdG8gY2hlY2sgdGhlIHJlbWFpbmluZyBzcGFjZSBhZ2FpbnN0CisgKgorICogUmV0dXJucyBhIGJvb2xlYW4gdmFsdWUgb24gd2hldGhlciB0aGUgY291bnRlciBjYW4gYmUgY2hhcmdlZAorICogQGJ5dGVzIG9yIHdoZXRoZXIgdGhpcyB3b3VsZCBleGNlZWQgdGhlIGxpbWl0LgorICovCitzdGF0aWMgaW5saW5lIGJvb2wgcmVzX2NvdW50ZXJfY2hlY2tfbWFyZ2luKHN0cnVjdCByZXNfY291bnRlciAqY250LAorCQkJCQkgICAgdW5zaWduZWQgbG9uZyBieXRlcykKK3sKKwlib29sIHJldDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmNudC0+bG9jaywgZmxhZ3MpOworCXJldCA9IGNudC0+bGltaXQgLSBjbnQtPnVzYWdlID49IGJ5dGVzOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNudC0+bG9jaywgZmxhZ3MpOworCXJldHVybiByZXQ7Cit9CisKIHN0YXRpYyBpbmxpbmUgYm9vbCByZXNfY291bnRlcl9jaGVja191bmRlcl9zb2Z0X2xpbWl0KHN0cnVjdCByZXNfY291bnRlciAqY250KQogewogCWJvb2wgcmV0OwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9ybWFwLmggYi9pbmNsdWRlL2xpbnV4L3JtYXAuaAppbmRleCBiYjgzYzBkLi5lOWZkMDRjIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3JtYXAuaAorKysgYi9pbmNsdWRlL2xpbnV4L3JtYXAuaApAQCAtMTk4LDYgKzE5OCw4IEBACiB9OwogI2RlZmluZSBUVFVfQUNUSU9OKHgpICgoeCkgJiBUVFVfQUNUSU9OX01BU0spCiAKK2Jvb2wgaXNfdm1hX3RlbXBvcmFyeV9zdGFjayhzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSk7CisKIGludCB0cnlfdG9fdW5tYXAoc3RydWN0IHBhZ2UgKiwgZW51bSB0dHVfZmxhZ3MgZmxhZ3MpOwogaW50IHRyeV90b191bm1hcF9vbmUoc3RydWN0IHBhZ2UgKiwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICosCiAJCQl1bnNpZ25lZCBsb25nIGFkZHJlc3MsIGVudW0gdHR1X2ZsYWdzIGZsYWdzKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcnRjLmggYi9pbmNsdWRlL2xpbnV4L3J0Yy5oCmluZGV4IDNjOTk1YjQuLmEwYjYzOWYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvcnRjLmgKKysrIGIvaW5jbHVkZS9saW51eC9ydGMuaApAQCAtMjM1LDggKzIzNSw2IEBACiAJCQkJc3RydWN0IHJ0Y190YXNrICp0YXNrLCBpbnQgZnJlcSk7CiBleHRlcm4gaW50IHJ0Y191cGRhdGVfaXJxX2VuYWJsZShzdHJ1Y3QgcnRjX2RldmljZSAqcnRjLCB1bnNpZ25lZCBpbnQgZW5hYmxlZCk7CiBleHRlcm4gaW50IHJ0Y19hbGFybV9pcnFfZW5hYmxlKHN0cnVjdCBydGNfZGV2aWNlICpydGMsIHVuc2lnbmVkIGludCBlbmFibGVkKTsKLWV4dGVybiBpbnQgcnRjX2Rldl91cGRhdGVfaXJxX2VuYWJsZV9lbXVsKHN0cnVjdCBydGNfZGV2aWNlICpydGMsCi0JCQkJCQl1bnNpZ25lZCBpbnQgZW5hYmxlZCk7CiAKIHZvaWQgcnRjX2FpZV91cGRhdGVfaXJxKHZvaWQgKnByaXZhdGUpOwogdm9pZCBydGNfdWllX3VwZGF0ZV9pcnEodm9pZCAqcHJpdmF0ZSk7CkBAIC0yNDYsOCArMjQ0LDYgQEAKIGludCBydGNfdW5yZWdpc3RlcihydGNfdGFza190ICp0YXNrKTsKIGludCBydGNfY29udHJvbChydGNfdGFza190ICp0LCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZyk7CiAKLXZvaWQgcnRjX3RpbWVyX2VucXVldWUoc3RydWN0IHJ0Y19kZXZpY2UgKnJ0Yywgc3RydWN0IHJ0Y190aW1lciAqdGltZXIpOwotdm9pZCBydGNfdGltZXJfcmVtb3ZlKHN0cnVjdCBydGNfZGV2aWNlICpydGMsIHN0cnVjdCBydGNfdGltZXIgKnRpbWVyKTsKIHZvaWQgcnRjX3RpbWVyX2luaXQoc3RydWN0IHJ0Y190aW1lciAqdGltZXIsIHZvaWQgKCpmKSh2b2lkKiBwKSwgdm9pZCogZGF0YSk7CiBpbnQgcnRjX3RpbWVyX3N0YXJ0KHN0cnVjdCBydGNfZGV2aWNlICpydGMsIHN0cnVjdCBydGNfdGltZXIqIHRpbWVyLAogCQkJa3RpbWVfdCBleHBpcmVzLCBrdGltZV90IHBlcmlvZCk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3MzY19hZGNfYmF0dGVyeS5oIGIvaW5jbHVkZS9saW51eC9zM2NfYWRjX2JhdHRlcnkuaAppbmRleCBkYmNlMjJmLi5mYmU1OGI3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3MzY19hZGNfYmF0dGVyeS5oCisrKyBiL2luY2x1ZGUvbGludXgvczNjX2FkY19iYXR0ZXJ5LmgKQEAgLTE0LDYgKzE0LDcgQEAKIAl2b2lkICgqZGlzYWJsZV9jaGFyZ2VyKSh2b2lkKTsKIAogCWludCBncGlvX2NoYXJnZV9maW5pc2hlZDsKKwlpbnQgZ3Bpb19pbnZlcnRlZDsKIAogCWNvbnN0IHN0cnVjdCBzM2NfYWRjX2JhdF90aHJlc2ggKmx1dF9ub2FjOwogCXVuc2lnbmVkIGludCBsdXRfbm9hY19jbnQ7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3NjaGVkLmggYi9pbmNsdWRlL2xpbnV4L3NjaGVkLmgKaW5kZXggOTZlMjMyMS4uZDc0N2Y5NCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9zY2hlZC5oCisrKyBiL2luY2x1ZGUvbGludXgvc2NoZWQuaApAQCAtMjEsNyArMjEsOCBAQAogI2RlZmluZSBDTE9ORV9ERVRBQ0hFRAkJMHgwMDQwMDAwMAkvKiBVbnVzZWQsIGlnbm9yZWQgKi8KICNkZWZpbmUgQ0xPTkVfVU5UUkFDRUQJCTB4MDA4MDAwMDAJLyogc2V0IGlmIHRoZSB0cmFjaW5nIHByb2Nlc3MgY2FuJ3QgZm9yY2UgQ0xPTkVfUFRSQUNFIG9uIHRoaXMgY2xvbmUgKi8KICNkZWZpbmUgQ0xPTkVfQ0hJTERfU0VUVElECTB4MDEwMDAwMDAJLyogc2V0IHRoZSBUSUQgaW4gdGhlIGNoaWxkICovCi0jZGVmaW5lIENMT05FX1NUT1BQRUQJCTB4MDIwMDAwMDAJLyogU3RhcnQgaW4gc3RvcHBlZCBzdGF0ZSAqLworLyogMHgwMjAwMDAwMCB3YXMgcHJldmlvdXNseSB0aGUgdW51c2VkIENMT05FX1NUT1BQRUQgKFN0YXJ0IGluIHN0b3BwZWQgc3RhdGUpCisgICBhbmQgaXMgbm93IGF2YWlsYWJsZSBmb3IgcmUtdXNlLiAqLwogI2RlZmluZSBDTE9ORV9ORVdVVFMJCTB4MDQwMDAwMDAJLyogTmV3IHV0c25hbWUgZ3JvdXA/ICovCiAjZGVmaW5lIENMT05FX05FV0lQQwkJMHgwODAwMDAwMAkvKiBOZXcgaXBjcyAqLwogI2RlZmluZSBDTE9ORV9ORVdVU0VSCQkweDEwMDAwMDAwCS8qIE5ldyB1c2VyIG5hbWVzcGFjZSAqLwpAQCAtNDMzLDYgKzQzNCw3IEBACiAjZW5kaWYKIAkJCQkJLyogbGVhdmUgcm9vbSBmb3IgbW9yZSBkdW1wIGZsYWdzICovCiAjZGVmaW5lIE1NRl9WTV9NRVJHRUFCTEUJMTYJLyogS1NNIG1heSBtZXJnZSBpZGVudGljYWwgcGFnZXMgKi8KKyNkZWZpbmUgTU1GX1ZNX0hVR0VQQUdFCQkxNwkvKiBzZXQgd2hlbiBWTV9IVUdFUEFHRSBpcyBzZXQgb24gdm1hICovCiAKICNkZWZpbmUgTU1GX0lOSVRfTUFTSwkJKE1NRl9EVU1QQUJMRV9NQVNLIHwgTU1GX0RVTVBfRklMVEVSX01BU0spCiAKQEAgLTYzMyw2ICs2MzUsOCBAQAogCiAJaW50IG9vbV9hZGo7CQkvKiBPT00ga2lsbCBzY29yZSBhZGp1c3RtZW50IChiaXQgc2hpZnQpICovCiAJaW50IG9vbV9zY29yZV9hZGo7CS8qIE9PTSBraWxsIHNjb3JlIGFkanVzdG1lbnQgKi8KKwlpbnQgb29tX3Njb3JlX2Fkal9taW47CS8qIE9PTSBraWxsIHNjb3JlIGFkanVzdG1lbnQgbWluaW11bSB2YWx1ZS4KKwkJCQkgKiBPbmx5IHNldHRhYmxlIGJ5IENBUF9TWVNfUkVTT1VSQ0UuICovCiAKIAlzdHJ1Y3QgbXV0ZXggY3JlZF9ndWFyZF9tdXRleDsJLyogZ3VhcmQgYWdhaW5zdCBmb3JlaWduIGluZmx1ZW5jZXMgb24KIAkJCQkJICogY3JlZGVudGlhbCBjYWxjdWxhdGlvbnMKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc2VjdXJpdHkuaCBiL2luY2x1ZGUvbGludXgvc2VjdXJpdHkuaAppbmRleCBjNjQyYmI4Li5iMmI3Zjk3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3NlY3VyaXR5LmgKKysrIGIvaW5jbHVkZS9saW51eC9zZWN1cml0eS5oCkBAIC0xNjYyLDcgKzE2NjIsNyBAQAogCQkgICAgY29uc3Qga2VybmVsX2NhcF90ICplZmZlY3RpdmUsCiAJCSAgICBjb25zdCBrZXJuZWxfY2FwX3QgKmluaGVyaXRhYmxlLAogCQkgICAgY29uc3Qga2VybmVsX2NhcF90ICpwZXJtaXR0ZWQpOwotaW50IHNlY3VyaXR5X2NhcGFibGUoaW50IGNhcCk7CitpbnQgc2VjdXJpdHlfY2FwYWJsZShjb25zdCBzdHJ1Y3QgY3JlZCAqY3JlZCwgaW50IGNhcCk7CiBpbnQgc2VjdXJpdHlfcmVhbF9jYXBhYmxlKHN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrLCBpbnQgY2FwKTsKIGludCBzZWN1cml0eV9yZWFsX2NhcGFibGVfbm9hdWRpdChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzaywgaW50IGNhcCk7CiBpbnQgc2VjdXJpdHlfc3lzY3RsKHN0cnVjdCBjdGxfdGFibGUgKnRhYmxlLCBpbnQgb3ApOwpAQCAtMTg1Niw5ICsxODU2LDkgQEAKIAlyZXR1cm4gY2FwX2NhcHNldChuZXcsIG9sZCwgZWZmZWN0aXZlLCBpbmhlcml0YWJsZSwgcGVybWl0dGVkKTsKIH0KIAotc3RhdGljIGlubGluZSBpbnQgc2VjdXJpdHlfY2FwYWJsZShpbnQgY2FwKQorc3RhdGljIGlubGluZSBpbnQgc2VjdXJpdHlfY2FwYWJsZShjb25zdCBzdHJ1Y3QgY3JlZCAqY3JlZCwgaW50IGNhcCkKIHsKLQlyZXR1cm4gY2FwX2NhcGFibGUoY3VycmVudCwgY3VycmVudF9jcmVkKCksIGNhcCwgU0VDVVJJVFlfQ0FQX0FVRElUKTsKKwlyZXR1cm4gY2FwX2NhcGFibGUoY3VycmVudCwgY3JlZCwgY2FwLCBTRUNVUklUWV9DQVBfQVVESVQpOwogfQogCiBzdGF0aWMgaW5saW5lIGludCBzZWN1cml0eV9yZWFsX2NhcGFibGUoc3RydWN0IHRhc2tfc3RydWN0ICp0c2ssIGludCBjYXApCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3NrYnVmZi5oIGIvaW5jbHVkZS9saW51eC9za2J1ZmYuaAppbmRleCAyMGVjMGE2NC4uYmYyMjFkNiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9za2J1ZmYuaAorKysgYi9pbmNsdWRlL2xpbnV4L3NrYnVmZi5oCkBAIC0yNTUsNiArMjU1LDExIEBACiB0eXBlZGVmIHVuc2lnbmVkIGNoYXIgKnNrX2J1ZmZfZGF0YV90OwogI2VuZGlmCiAKKyNpZiBkZWZpbmVkKENPTkZJR19ORl9ERUZSQUdfSVBWNCkgfHwgZGVmaW5lZChDT05GSUdfTkZfREVGUkFHX0lQVjRfTU9EVUxFKSB8fCBcCisgICAgZGVmaW5lZChDT05GSUdfTkZfREVGUkFHX0lQVjYpIHx8IGRlZmluZWQoQ09ORklHX05GX0RFRlJBR19JUFY2X01PRFVMRSkKKyNkZWZpbmUgTkVUX1NLQlVGRl9ORl9ERUZSQUdfTkVFREVEIDEKKyNlbmRpZgorCiAvKiogCiAgKglzdHJ1Y3Qgc2tfYnVmZiAtIHNvY2tldCBidWZmZXIKICAqCUBuZXh0OiBOZXh0IGJ1ZmZlciBpbiBsaXN0CkBAIC0zNjIsNiArMzY3LDggQEAKIAl2b2lkCQkJKCpkZXN0cnVjdG9yKShzdHJ1Y3Qgc2tfYnVmZiAqc2tiKTsKICNpZiBkZWZpbmVkKENPTkZJR19ORl9DT05OVFJBQ0spIHx8IGRlZmluZWQoQ09ORklHX05GX0NPTk5UUkFDS19NT0RVTEUpCiAJc3RydWN0IG5mX2Nvbm50cmFjawkqbmZjdDsKKyNlbmRpZgorI2lmZGVmIE5FVF9TS0JVRkZfTkZfREVGUkFHX05FRURFRAogCXN0cnVjdCBza19idWZmCQkqbmZjdF9yZWFzbTsKICNlbmRpZgogI2lmZGVmIENPTkZJR19CUklER0VfTkVURklMVEVSCkBAIC0yMDU3LDYgKzIwNjQsOCBAQAogCWlmIChuZmN0KQogCQlhdG9taWNfaW5jKCZuZmN0LT51c2UpOwogfQorI2VuZGlmCisjaWZkZWYgTkVUX1NLQlVGRl9ORl9ERUZSQUdfTkVFREVECiBzdGF0aWMgaW5saW5lIHZvaWQgbmZfY29ubnRyYWNrX2dldF9yZWFzbShzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQogewogCWlmIChza2IpCkBAIC0yMDg1LDYgKzIwOTQsOCBAQAogI2lmIGRlZmluZWQoQ09ORklHX05GX0NPTk5UUkFDSykgfHwgZGVmaW5lZChDT05GSUdfTkZfQ09OTlRSQUNLX01PRFVMRSkKIAluZl9jb25udHJhY2tfcHV0KHNrYi0+bmZjdCk7CiAJc2tiLT5uZmN0ID0gTlVMTDsKKyNlbmRpZgorI2lmZGVmIE5FVF9TS0JVRkZfTkZfREVGUkFHX05FRURFRAogCW5mX2Nvbm50cmFja19wdXRfcmVhc20oc2tiLT5uZmN0X3JlYXNtKTsKIAlza2ItPm5mY3RfcmVhc20gPSBOVUxMOwogI2VuZGlmCkBAIC0yMTAxLDYgKzIxMTIsOCBAQAogCWRzdC0+bmZjdCA9IHNyYy0+bmZjdDsKIAluZl9jb25udHJhY2tfZ2V0KHNyYy0+bmZjdCk7CiAJZHN0LT5uZmN0aW5mbyA9IHNyYy0+bmZjdGluZm87CisjZW5kaWYKKyNpZmRlZiBORVRfU0tCVUZGX05GX0RFRlJBR19ORUVERUQKIAlkc3QtPm5mY3RfcmVhc20gPSBzcmMtPm5mY3RfcmVhc207CiAJbmZfY29ubnRyYWNrX2dldF9yZWFzbShzcmMtPm5mY3RfcmVhc20pOwogI2VuZGlmCkBAIC0yMTE0LDYgKzIxMjcsOCBAQAogewogI2lmIGRlZmluZWQoQ09ORklHX05GX0NPTk5UUkFDSykgfHwgZGVmaW5lZChDT05GSUdfTkZfQ09OTlRSQUNLX01PRFVMRSkKIAluZl9jb25udHJhY2tfcHV0KGRzdC0+bmZjdCk7CisjZW5kaWYKKyNpZmRlZiBORVRfU0tCVUZGX05GX0RFRlJBR19ORUVERUQKIAluZl9jb25udHJhY2tfcHV0X3JlYXNtKGRzdC0+bmZjdF9yZWFzbSk7CiAjZW5kaWYKICNpZmRlZiBDT05GSUdfQlJJREdFX05FVEZJTFRFUgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9zdW5ycGMvYmNfeHBydC5oIGIvaW5jbHVkZS9saW51eC9zdW5ycGMvYmNfeHBydC5oCmluZGV4IGM1MGI0NTguLjA4Mjg4NDIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvc3VucnBjL2JjX3hwcnQuaAorKysgYi9pbmNsdWRlL2xpbnV4L3N1bnJwYy9iY194cHJ0LmgKQEAgLTQ3LDE0ICs0Nyw2IEBACiAJCXJldHVybiAxOwogCXJldHVybiAwOwogfQotc3RhdGljIGlubGluZSBzdHJ1Y3QgbmZzNF9zZXNzaW9uaWQgKmJjX3hwcnRfc2lkKHN0cnVjdCBzdmNfcnFzdCAqcnFzdHApCi17Ci0JaWYgKHN2Y19pc19iYWNrY2hhbm5lbChycXN0cCkpCi0JCXJldHVybiAoc3RydWN0IG5mczRfc2Vzc2lvbmlkICopCi0JCQlycXN0cC0+cnFfc2VydmVyLT5zdl9iY194cHJ0LT54cHRfYmNfc2lkOwotCXJldHVybiBOVUxMOwotfQotCiAjZWxzZSAvKiBDT05GSUdfTkZTX1Y0XzEgKi8KIHN0YXRpYyBpbmxpbmUgaW50IHhwcnRfc2V0dXBfYmFja2NoYW5uZWwoc3RydWN0IHJwY194cHJ0ICp4cHJ0LAogCQkJCQkgdW5zaWduZWQgaW50IG1pbl9yZXFzKQpAQCAtNjcsMTEgKzU5LDYgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGlubGluZSBzdHJ1Y3QgbmZzNF9zZXNzaW9uaWQgKmJjX3hwcnRfc2lkKHN0cnVjdCBzdmNfcnFzdCAqcnFzdHApCi17Ci0JcmV0dXJuIE5VTEw7Ci19Ci0KIHN0YXRpYyBpbmxpbmUgdm9pZCB4cHJ0X2ZyZWVfYmNfcmVxdWVzdChzdHJ1Y3QgcnBjX3Jxc3QgKnJlcSkKIHsKIH0KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3VucnBjL2NhY2hlLmggYi9pbmNsdWRlL2xpbnV4L3N1bnJwYy9jYWNoZS5oCmluZGV4IDc4YWExMDQuLjc4OThlYTEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvc3VucnBjL2NhY2hlLmgKKysrIGIvaW5jbHVkZS9saW51eC9zdW5ycGMvY2FjaGUuaApAQCAtMjU2LDEwICsyNTYsMTMgQEAKIAlyZXR1cm4gcnYgLSBib290LnR2X3NlYzsKIH0KIAorI2lmZGVmIENPTkZJR19ORlNEX0RFUFJFQ0FURUQKIHN0YXRpYyBpbmxpbmUgdm9pZCBzdW5ycGNfaW52YWxpZGF0ZShzdHJ1Y3QgY2FjaGVfaGVhZCAqaCwKIAkJCQkgICAgIHN0cnVjdCBjYWNoZV9kZXRhaWwgKmRldGFpbCkKIHsKIAloLT5leHBpcnlfdGltZSA9IHNlY29uZHNfc2luY2VfYm9vdCgpIC0gMTsKIAlkZXRhaWwtPm5leHRjaGVjayA9IHNlY29uZHNfc2luY2VfYm9vdCgpOwogfQorI2VuZGlmIC8qIENPTkZJR19ORlNEX0RFUFJFQ0FURUQgKi8KKwogI2VuZGlmIC8qICBfTElOVVhfU1VOUlBDX0NBQ0hFX0hfICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3N1bnJwYy9zdmMuaCBiL2luY2x1ZGUvbGludXgvc3VucnBjL3N2Yy5oCmluZGV4IGM4MWQ0ZDguLmVhMjkzMzAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvc3VucnBjL3N2Yy5oCisrKyBiL2luY2x1ZGUvbGludXgvc3VucnBjL3N2Yy5oCkBAIC0yNjksNiArMjY5LDcgQEAKIAlzdHJ1Y3QgY2FjaGVfcmVxCXJxX2NoYW5kbGU7CS8qIGhhbmRsZSBwYXNzZWQgdG8gY2FjaGVzIGZvciAKIAkJCQkJCSAqIHJlcXVlc3QgZGVsYXlpbmcgCiAJCQkJCQkgKi8KKwlib29sCQkJcnFfZHJvcG1lOwogCS8qIENhdGVyaW5nIHRvIG5mc2QgKi8KIAlzdHJ1Y3QgYXV0aF9kb21haW4gKglycV9jbGllbnQ7CS8qIFJQQyBwZWVyIGluZm8gKi8KIAlzdHJ1Y3QgYXV0aF9kb21haW4gKglycV9nc3NjbGllbnQ7CS8qICJnc3MvIi1zdHlsZSBwZWVyIGluZm8gKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3VucnBjL3N2Y194cHJ0LmggYi9pbmNsdWRlL2xpbnV4L3N1bnJwYy9zdmNfeHBydC5oCmluZGV4IDM1N2RhNWUuLjdhZDk3NTEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvc3VucnBjL3N2Y194cHJ0LmgKKysrIGIvaW5jbHVkZS9saW51eC9zdW5ycGMvc3ZjX3hwcnQuaApAQCAtNjMsNyArNjMsNiBAQAogI2RlZmluZSBYUFRfTElTVEVORVIJMTEJCS8qIGxpc3RlbmluZyBlbmRwb2ludCAqLwogI2RlZmluZSBYUFRfQ0FDSEVfQVVUSAkxMgkJLyogY2FjaGUgYXV0aCBpbmZvICovCiAKLQlzdHJ1Y3Qgc3ZjX3Bvb2wJCSp4cHRfcG9vbDsJLyogY3VycmVudCBwb29sIGlmZiBxdWV1ZWQgKi8KIAlzdHJ1Y3Qgc3ZjX3NlcnYJCSp4cHRfc2VydmVyOwkvKiBzZXJ2aWNlIGZvciB0cmFuc3BvcnQgKi8KIAlhdG9taWNfdCAgICAJICAgIAl4cHRfcmVzZXJ2ZWQ7CS8qIHNwYWNlIG9uIG91dHEgdGhhdCBpcyByc3ZkICovCiAJc3RydWN0IG11dGV4CQl4cHRfbXV0ZXg7CS8qIHRvIHNlcmlhbGl6ZSBzZW5kaW5nIGRhdGEgKi8KQEAgLTc4LDkgKzc3LDkgQEAKIAlzaXplX3QJCQl4cHRfcmVtb3RlbGVuOwkvKiBsZW5ndGggb2YgYWRkcmVzcyAqLwogCXN0cnVjdCBycGNfd2FpdF9xdWV1ZQl4cHRfYmNfcGVuZGluZzsJLyogYmFja2NoYW5uZWwgd2FpdCBxdWV1ZSAqLwogCXN0cnVjdCBsaXN0X2hlYWQJeHB0X3VzZXJzOwkvKiBjYWxsYmFja3Mgb24gZnJlZSAqLwotCXZvaWQJCQkqeHB0X2JjX3NpZDsJLyogYmFjayBjaGFubmVsIHNlc3Npb24gSUQgKi8KIAogCXN0cnVjdCBuZXQJCSp4cHRfbmV0OworCXN0cnVjdCBycGNfeHBydAkJKnhwdF9iY194cHJ0OwkvKiBORlN2NC4xIGJhY2tjaGFubmVsICovCiB9OwogCiBzdGF0aWMgaW5saW5lIHZvaWQgdW5yZWdpc3Rlcl94cHRfdXNlcihzdHJ1Y3Qgc3ZjX3hwcnQgKnhwdCwgc3RydWN0IHN2Y194cHRfdXNlciAqdSkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3VucnBjL3N2Y3NvY2suaCBiL2luY2x1ZGUvbGludXgvc3VucnBjL3N2Y3NvY2suaAppbmRleCAxYjM1M2E3Li4wNGRiYTIzIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3N1bnJwYy9zdmNzb2NrLmgKKysrIGIvaW5jbHVkZS9saW51eC9zdW5ycGMvc3Zjc29jay5oCkBAIC0yOCw3ICsyOCw2IEBACiAJLyogcHJpdmF0ZSBUQ1AgcGFydCAqLwogCXUzMgkJCXNrX3JlY2xlbjsJLyogbGVuZ3RoIG9mIHJlY29yZCAqLwogCXUzMgkJCXNrX3RjcGxlbjsJLyogY3VycmVudCByZWFkIGxlbmd0aCAqLwotCXN0cnVjdCBycGNfeHBydAkJKnNrX2JjX3hwcnQ7CS8qIE5GU3Y0LjEgYmFja2NoYW5uZWwgeHBydCAqLwogfTsKIAogLyoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3VucnBjL3hwcnQuaCBiL2luY2x1ZGUvbGludXgvc3VucnBjL3hwcnQuaAppbmRleCA4OWQxMGQyLi5iZWYwZjUzIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3N1bnJwYy94cHJ0LmgKKysrIGIvaW5jbHVkZS9saW51eC9zdW5ycGMveHBydC5oCkBAIC0zMjEsNiArMzIxLDcgQEAKICNkZWZpbmUgWFBSVF9DTE9TSU5HCQkoNikKICNkZWZpbmUgWFBSVF9DT05ORUNUSU9OX0FCT1JUCSg3KQogI2RlZmluZSBYUFJUX0NPTk5FQ1RJT05fQ0xPU0UJKDgpCisjZGVmaW5lIFhQUlRfSU5JVElBTElaRUQJKDkpCiAKIHN0YXRpYyBpbmxpbmUgdm9pZCB4cHJ0X3NldF9jb25uZWN0ZWQoc3RydWN0IHJwY194cHJ0ICp4cHJ0KQogewpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9zdXNwZW5kLmggYi9pbmNsdWRlL2xpbnV4L3N1c3BlbmQuaAppbmRleCBjMWY0OTk4Li41YTg5ZTM2IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3N1c3BlbmQuaAorKysgYi9pbmNsdWRlL2xpbnV4L3N1c3BlbmQuaApAQCAtMjU4LDIzICsyNTgsNiBAQAogc3RhdGljIGlubGluZSBib29sIHN5c3RlbV9lbnRlcmluZ19oaWJlcm5hdGlvbih2b2lkKSB7IHJldHVybiBmYWxzZTsgfQogI2VuZGlmIC8qIENPTkZJR19ISUJFUk5BVElPTiAqLwogCi0jaWZkZWYgQ09ORklHX1NVU1BFTkRfTlZTCi1leHRlcm4gaW50IHN1c3BlbmRfbnZzX3JlZ2lzdGVyKHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgc2l6ZSk7Ci1leHRlcm4gaW50IHN1c3BlbmRfbnZzX2FsbG9jKHZvaWQpOwotZXh0ZXJuIHZvaWQgc3VzcGVuZF9udnNfZnJlZSh2b2lkKTsKLWV4dGVybiB2b2lkIHN1c3BlbmRfbnZzX3NhdmUodm9pZCk7Ci1leHRlcm4gdm9pZCBzdXNwZW5kX252c19yZXN0b3JlKHZvaWQpOwotI2Vsc2UgLyogQ09ORklHX1NVU1BFTkRfTlZTICovCi1zdGF0aWMgaW5saW5lIGludCBzdXNwZW5kX252c19yZWdpc3Rlcih1bnNpZ25lZCBsb25nIGEsIHVuc2lnbmVkIGxvbmcgYikKLXsKLQlyZXR1cm4gMDsKLX0KLXN0YXRpYyBpbmxpbmUgaW50IHN1c3BlbmRfbnZzX2FsbG9jKHZvaWQpIHsgcmV0dXJuIDA7IH0KLXN0YXRpYyBpbmxpbmUgdm9pZCBzdXNwZW5kX252c19mcmVlKHZvaWQpIHt9Ci1zdGF0aWMgaW5saW5lIHZvaWQgc3VzcGVuZF9udnNfc2F2ZSh2b2lkKSB7fQotc3RhdGljIGlubGluZSB2b2lkIHN1c3BlbmRfbnZzX3Jlc3RvcmUodm9pZCkge30KLSNlbmRpZiAvKiBDT05GSUdfU1VTUEVORF9OVlMgKi8KLQogI2lmZGVmIENPTkZJR19QTV9TTEVFUAogdm9pZCBzYXZlX3Byb2Nlc3Nvcl9zdGF0ZSh2b2lkKTsKIHZvaWQgcmVzdG9yZV9wcm9jZXNzb3Jfc3RhdGUodm9pZCk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3N3YXAuaCBiL2luY2x1ZGUvbGludXgvc3dhcC5oCmluZGV4IGViYTUzZTcuLjRkNTU5MzIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvc3dhcC5oCisrKyBiL2luY2x1ZGUvbGludXgvc3dhcC5oCkBAIC0yMDgsNiArMjA4LDggQEAKIC8qIGxpbnV4L21tL3N3YXAuYyAqLwogZXh0ZXJuIHZvaWQgX19scnVfY2FjaGVfYWRkKHN0cnVjdCBwYWdlICosIGVudW0gbHJ1X2xpc3QgbHJ1KTsKIGV4dGVybiB2b2lkIGxydV9jYWNoZV9hZGRfbHJ1KHN0cnVjdCBwYWdlICosIGVudW0gbHJ1X2xpc3QgbHJ1KTsKK2V4dGVybiB2b2lkIGxydV9hZGRfcGFnZV90YWlsKHN0cnVjdCB6b25lKiB6b25lLAorCQkJICAgICAgc3RydWN0IHBhZ2UgKnBhZ2UsIHN0cnVjdCBwYWdlICpwYWdlX3RhaWwpOwogZXh0ZXJuIHZvaWQgYWN0aXZhdGVfcGFnZShzdHJ1Y3QgcGFnZSAqKTsKIGV4dGVybiB2b2lkIG1hcmtfcGFnZV9hY2Nlc3NlZChzdHJ1Y3QgcGFnZSAqKTsKIGV4dGVybiB2b2lkIGxydV9hZGRfZHJhaW4odm9pZCk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3N5c2NhbGxzLmggYi9pbmNsdWRlL2xpbnV4L3N5c2NhbGxzLmgKaW5kZXggMThjZDA2OC4uOTg2NjRkYiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9zeXNjYWxscy5oCisrKyBiL2luY2x1ZGUvbGludXgvc3lzY2FsbHMuaApAQCAtMTI1LDM5ICsxMjUsMzcgQEAKIGV4dGVybiBzdHJ1Y3QgdHJhY2VfZXZlbnRfZnVuY3Rpb25zIGV4aXRfc3lzY2FsbF9wcmludF9mdW5jczsKIAogI2RlZmluZSBTWVNDQUxMX1RSQUNFX0VOVEVSX0VWRU5UKHNuYW1lKQkJCQlcCi0Jc3RhdGljIHN0cnVjdCBzeXNjYWxsX21ldGFkYXRhCQkJCQlcCi0JX19hdHRyaWJ1dGVfXygoX19hbGlnbmVkX18oNCkpKSBfX3N5c2NhbGxfbWV0YV8jI3NuYW1lOwkJXAorCXN0YXRpYyBzdHJ1Y3Qgc3lzY2FsbF9tZXRhZGF0YSBfX3N5c2NhbGxfbWV0YV8jI3NuYW1lOwkJXAogCXN0YXRpYyBzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgX191c2VkCQkJCVwKLQkgIF9fYXR0cmlidXRlX18oKF9fYWxpZ25lZF9fKDQpKSkJCQkJXAotCSAgX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiX2Z0cmFjZV9ldmVudHMiKSkpCQkJXAogCSAgZXZlbnRfZW50ZXJfIyNzbmFtZSA9IHsJCQkJCVwKIAkJLm5hbWUgICAgICAgICAgICAgICAgICAgPSAic3lzX2VudGVyIiNzbmFtZSwJCVwKIAkJLmNsYXNzCQkJPSAmZXZlbnRfY2xhc3Nfc3lzY2FsbF9lbnRlciwJXAogCQkuZXZlbnQuZnVuY3MgICAgICAgICAgICA9ICZlbnRlcl9zeXNjYWxsX3ByaW50X2Z1bmNzLAlcCiAJCS5kYXRhCQkJPSAodm9pZCAqKSZfX3N5c2NhbGxfbWV0YV8jI3NuYW1lLFwKIAl9OwkJCQkJCQkJXAorCXN0YXRpYyBzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgX191c2VkCQkJCVwKKwkgIF9fYXR0cmlidXRlX18oKHNlY3Rpb24oIl9mdHJhY2VfZXZlbnRzIikpKQkJCVwKKwkgKl9fZXZlbnRfZW50ZXJfIyNzbmFtZSA9ICZldmVudF9lbnRlcl8jI3NuYW1lOwkJCVwKIAlfX1RSQUNFX0VWRU5UX0ZMQUdTKGVudGVyXyMjc25hbWUsIFRSQUNFX0VWRU5UX0ZMX0NBUF9BTlkpCiAKICNkZWZpbmUgU1lTQ0FMTF9UUkFDRV9FWElUX0VWRU5UKHNuYW1lKQkJCQkJXAotCXN0YXRpYyBzdHJ1Y3Qgc3lzY2FsbF9tZXRhZGF0YQkJCQkJXAotCV9fYXR0cmlidXRlX18oKF9fYWxpZ25lZF9fKDQpKSkgX19zeXNjYWxsX21ldGFfIyNzbmFtZTsJCVwKKwlzdGF0aWMgc3RydWN0IHN5c2NhbGxfbWV0YWRhdGEgX19zeXNjYWxsX21ldGFfIyNzbmFtZTsJCVwKIAlzdGF0aWMgc3RydWN0IGZ0cmFjZV9ldmVudF9jYWxsIF9fdXNlZAkJCQlcCi0JICBfX2F0dHJpYnV0ZV9fKChfX2FsaWduZWRfXyg0KSkpCQkJCVwKLQkgIF9fYXR0cmlidXRlX18oKHNlY3Rpb24oIl9mdHJhY2VfZXZlbnRzIikpKQkJCVwKIAkgIGV2ZW50X2V4aXRfIyNzbmFtZSA9IHsJCQkJCVwKIAkJLm5hbWUgICAgICAgICAgICAgICAgICAgPSAic3lzX2V4aXQiI3NuYW1lLAkJXAogCQkuY2xhc3MJCQk9ICZldmVudF9jbGFzc19zeXNjYWxsX2V4aXQsCVwKIAkJLmV2ZW50LmZ1bmNzCQk9ICZleGl0X3N5c2NhbGxfcHJpbnRfZnVuY3MsCVwKIAkJLmRhdGEJCQk9ICh2b2lkICopJl9fc3lzY2FsbF9tZXRhXyMjc25hbWUsXAogCX07CQkJCQkJCQlcCisJc3RhdGljIHN0cnVjdCBmdHJhY2VfZXZlbnRfY2FsbCBfX3VzZWQJCQkJXAorCSAgX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiX2Z0cmFjZV9ldmVudHMiKSkpCQkJXAorCSpfX2V2ZW50X2V4aXRfIyNzbmFtZSA9ICZldmVudF9leGl0XyMjc25hbWU7CQkJXAogCV9fVFJBQ0VfRVZFTlRfRkxBR1MoZXhpdF8jI3NuYW1lLCBUUkFDRV9FVkVOVF9GTF9DQVBfQU5ZKQogCiAjZGVmaW5lIFNZU0NBTExfTUVUQURBVEEoc25hbWUsIG5iKQkJCQlcCiAJU1lTQ0FMTF9UUkFDRV9FTlRFUl9FVkVOVChzbmFtZSk7CQkJXAogCVNZU0NBTExfVFJBQ0VfRVhJVF9FVkVOVChzbmFtZSk7CQkJXAogCXN0YXRpYyBzdHJ1Y3Qgc3lzY2FsbF9tZXRhZGF0YSBfX3VzZWQJCQlcCi0JICBfX2F0dHJpYnV0ZV9fKChfX2FsaWduZWRfXyg0KSkpCQkJXAotCSAgX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiX19zeXNjYWxsc19tZXRhZGF0YSIpKSkJXAogCSAgX19zeXNjYWxsX21ldGFfIyNzbmFtZSA9IHsJCQkJXAogCQkubmFtZSAJCT0gInN5cyIjc25hbWUsCQkJXAogCQkubmJfYXJncyAJPSBuYiwJCQkJXApAQCAtMTY2LDE0ICsxNjQsMTUgQEAKIAkJLmVudGVyX2V2ZW50CT0gJmV2ZW50X2VudGVyXyMjc25hbWUsCQlcCiAJCS5leGl0X2V2ZW50CT0gJmV2ZW50X2V4aXRfIyNzbmFtZSwJCVwKIAkJLmVudGVyX2ZpZWxkcwk9IExJU1RfSEVBRF9JTklUKF9fc3lzY2FsbF9tZXRhXyMjc25hbWUuZW50ZXJfZmllbGRzKSwgXAotCX07CisJfTsJCQkJCQkJXAorCXN0YXRpYyBzdHJ1Y3Qgc3lzY2FsbF9tZXRhZGF0YSBfX3VzZWQJCQlcCisJICBfX2F0dHJpYnV0ZV9fKChzZWN0aW9uKCJfX3N5c2NhbGxzX21ldGFkYXRhIikpKQlcCisJICpfX3Bfc3lzY2FsbF9tZXRhXyMjc25hbWUgPSAmX19zeXNjYWxsX21ldGFfIyNzbmFtZTsKIAogI2RlZmluZSBTWVNDQUxMX0RFRklORTAoc25hbWUpCQkJCQlcCiAJU1lTQ0FMTF9UUkFDRV9FTlRFUl9FVkVOVChfIyNzbmFtZSk7CQkJXAogCVNZU0NBTExfVFJBQ0VfRVhJVF9FVkVOVChfIyNzbmFtZSk7CQkJXAogCXN0YXRpYyBzdHJ1Y3Qgc3lzY2FsbF9tZXRhZGF0YSBfX3VzZWQJCQlcCi0JICBfX2F0dHJpYnV0ZV9fKChfX2FsaWduZWRfXyg0KSkpCQkJXAotCSAgX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiX19zeXNjYWxsc19tZXRhZGF0YSIpKSkJXAogCSAgX19zeXNjYWxsX21ldGFfXyMjc25hbWUgPSB7CQkJCVwKIAkJLm5hbWUgCQk9ICJzeXNfIiNzbmFtZSwJCQlcCiAJCS5uYl9hcmdzIAk9IDAsCQkJCVwKQEAgLTE4MSw2ICsxODAsOSBAQAogCQkuZXhpdF9ldmVudAk9ICZldmVudF9leGl0X18jI3NuYW1lLAkJXAogCQkuZW50ZXJfZmllbGRzCT0gTElTVF9IRUFEX0lOSVQoX19zeXNjYWxsX21ldGFfXyMjc25hbWUuZW50ZXJfZmllbGRzKSwgXAogCX07CQkJCQkJCVwKKwlzdGF0aWMgc3RydWN0IHN5c2NhbGxfbWV0YWRhdGEgX191c2VkCQkJXAorCSAgX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiX19zeXNjYWxsc19tZXRhZGF0YSIpKSkJXAorCSAqX19wX3N5c2NhbGxfbWV0YV8jI3NuYW1lID0gJl9fc3lzY2FsbF9tZXRhX18jI3NuYW1lOwlcCiAJYXNtbGlua2FnZSBsb25nIHN5c18jI3NuYW1lKHZvaWQpCiAjZWxzZQogI2RlZmluZSBTWVNDQUxMX0RFRklORTAobmFtZSkJICAgYXNtbGlua2FnZSBsb25nIHN5c18jI25hbWUodm9pZCkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3lzcnEuaCBiL2luY2x1ZGUvbGludXgvc3lzcnEuaAppbmRleCAzODdmYTdkLi43ZmFmOTMzIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3N5c3JxLmgKKysrIGIvaW5jbHVkZS9saW51eC9zeXNycS5oCkBAIC0xNyw2ICsxNyw5IEBACiAjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgogCisvKiBFbmFibGUvZGlzYWJsZSBTWVNSUSBzdXBwb3J0IGJ5IGRlZmF1bHQgKDA9PW5vLCAxPT15ZXMpLiAqLworI2RlZmluZSBTWVNSUV9ERUZBVUxUX0VOQUJMRQkxCisKIC8qIFBvc3NpYmxlIHZhbHVlcyBvZiBiaXRtYXNrIGZvciBlbmFibGluZyBzeXNycSBmdW5jdGlvbnMgKi8KIC8qIDB4MDAwMSBpcyByZXNlcnZlZCBmb3IgZW5hYmxlIGV2ZXJ5dGhpbmcgKi8KICNkZWZpbmUgU1lTUlFfRU5BQkxFX0xPRwkweDAwMDIKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdGhlcm1hbC5oIGIvaW5jbHVkZS9saW51eC90aGVybWFsLmgKaW5kZXggMWRlOGI5ZWIuLjg2NTE1NTYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvdGhlcm1hbC5oCisrKyBiL2luY2x1ZGUvbGludXgvdGhlcm1hbC5oCkBAIC03Nyw3ICs3Nyw3IEBACiAJY2hhciB0eXBlW1RIRVJNQUxfTkFNRV9MRU5HVEhdOwogCXN0cnVjdCBkZXZpY2UgZGV2aWNlOwogCXZvaWQgKmRldmRhdGE7Ci0Jc3RydWN0IHRoZXJtYWxfY29vbGluZ19kZXZpY2Vfb3BzICpvcHM7CisJY29uc3Qgc3RydWN0IHRoZXJtYWxfY29vbGluZ19kZXZpY2Vfb3BzICpvcHM7CiAJc3RydWN0IGxpc3RfaGVhZCBub2RlOwogfTsKIApAQCAtMTE0LDcgKzExNCw3IEBACiAJaW50IGxhc3RfdGVtcGVyYXR1cmU7CiAJYm9vbCBwYXNzaXZlOwogCXVuc2lnbmVkIGludCBmb3JjZWRfcGFzc2l2ZTsKLQlzdHJ1Y3QgdGhlcm1hbF96b25lX2RldmljZV9vcHMgKm9wczsKKwljb25zdCBzdHJ1Y3QgdGhlcm1hbF96b25lX2RldmljZV9vcHMgKm9wczsKIAlzdHJ1Y3QgbGlzdF9oZWFkIGNvb2xpbmdfZGV2aWNlczsKIAlzdHJ1Y3QgaWRyIGlkcjsKIAlzdHJ1Y3QgbXV0ZXggbG9jazsJLyogcHJvdGVjdCBjb29saW5nIGRldmljZXMgbGlzdCAqLwpAQCAtMTI3LDEzICsxMjcsNDEgQEAKIAlzdHJ1Y3QgdGhlcm1hbF9od21vbl9hdHRyIHRlbXBfY3JpdDsJLyogaHdtb24gc3lzIGF0dHIgKi8KICNlbmRpZgogfTsKKy8qIEFkZGluZyBldmVudCBub3RpZmljYXRpb24gc3VwcG9ydCBlbGVtZW50cyAqLworI2RlZmluZSBUSEVSTUFMX0dFTkxfRkFNSUxZX05BTUUgICAgICAgICAgICAgICAgInRoZXJtYWxfZXZlbnQiCisjZGVmaW5lIFRIRVJNQUxfR0VOTF9WRVJTSU9OICAgICAgICAgICAgICAgICAgICAweDAxCisjZGVmaW5lIFRIRVJNQUxfR0VOTF9NQ0FTVF9HUk9VUF9OQU1FICAgICAgICAgICAidGhlcm1hbF9tY19ncm91cCIKKworZW51bSBldmVudHMgeworCVRIRVJNQUxfQVVYMCwKKwlUSEVSTUFMX0FVWDEsCisJVEhFUk1BTF9DUklUSUNBTCwKKwlUSEVSTUFMX0RFVl9GQVVMVCwKK307CisKK3N0cnVjdCB0aGVybWFsX2dlbmxfZXZlbnQgeworCXUzMiBvcmlnOworCWVudW0gZXZlbnRzIGV2ZW50OworfTsKKy8qIGF0dHJpYnV0ZXMgb2YgdGhlcm1hbF9nZW5sX2ZhbWlseSAqLworZW51bSB7CisJVEhFUk1BTF9HRU5MX0FUVFJfVU5TUEVDLAorCVRIRVJNQUxfR0VOTF9BVFRSX0VWRU5ULAorCV9fVEhFUk1BTF9HRU5MX0FUVFJfTUFYLAorfTsKKyNkZWZpbmUgVEhFUk1BTF9HRU5MX0FUVFJfTUFYIChfX1RIRVJNQUxfR0VOTF9BVFRSX01BWCAtIDEpCisKKy8qIGNvbW1hbmRzIHN1cHBvcnRlZCBieSB0aGUgdGhlcm1hbF9nZW5sX2ZhbWlseSAqLworZW51bSB7CisJVEhFUk1BTF9HRU5MX0NNRF9VTlNQRUMsCisJVEhFUk1BTF9HRU5MX0NNRF9FVkVOVCwKKwlfX1RIRVJNQUxfR0VOTF9DTURfTUFYLAorfTsKKyNkZWZpbmUgVEhFUk1BTF9HRU5MX0NNRF9NQVggKF9fVEhFUk1BTF9HRU5MX0NNRF9NQVggLSAxKQogCiBzdHJ1Y3QgdGhlcm1hbF96b25lX2RldmljZSAqdGhlcm1hbF96b25lX2RldmljZV9yZWdpc3RlcihjaGFyICosIGludCwgdm9pZCAqLAotCQkJCQkJCSBzdHJ1Y3QKLQkJCQkJCQkgdGhlcm1hbF96b25lX2RldmljZV9vcHMKLQkJCQkJCQkgKiwgaW50IHRjMSwgaW50IHRjMiwKLQkJCQkJCQkgaW50IHBhc3NpdmVfZnJlcSwKLQkJCQkJCQkgaW50IHBvbGxpbmdfZnJlcSk7CisJCWNvbnN0IHN0cnVjdCB0aGVybWFsX3pvbmVfZGV2aWNlX29wcyAqLCBpbnQgdGMxLCBpbnQgdGMyLAorCQlpbnQgcGFzc2l2ZV9mcmVxLCBpbnQgcG9sbGluZ19mcmVxKTsKIHZvaWQgdGhlcm1hbF96b25lX2RldmljZV91bnJlZ2lzdGVyKHN0cnVjdCB0aGVybWFsX3pvbmVfZGV2aWNlICopOwogCiBpbnQgdGhlcm1hbF96b25lX2JpbmRfY29vbGluZ19kZXZpY2Uoc3RydWN0IHRoZXJtYWxfem9uZV9kZXZpY2UgKiwgaW50LApAQCAtMTQyLDkgKzE3MCw4IEBACiAJCQkJICAgICAgIHN0cnVjdCB0aGVybWFsX2Nvb2xpbmdfZGV2aWNlICopOwogdm9pZCB0aGVybWFsX3pvbmVfZGV2aWNlX3VwZGF0ZShzdHJ1Y3QgdGhlcm1hbF96b25lX2RldmljZSAqKTsKIHN0cnVjdCB0aGVybWFsX2Nvb2xpbmdfZGV2aWNlICp0aGVybWFsX2Nvb2xpbmdfZGV2aWNlX3JlZ2lzdGVyKGNoYXIgKiwgdm9pZCAqLAotCQkJCQkJCSAgICAgICBzdHJ1Y3QKLQkJCQkJCQkgICAgICAgdGhlcm1hbF9jb29saW5nX2RldmljZV9vcHMKLQkJCQkJCQkgICAgICAgKik7CisJCWNvbnN0IHN0cnVjdCB0aGVybWFsX2Nvb2xpbmdfZGV2aWNlX29wcyAqKTsKIHZvaWQgdGhlcm1hbF9jb29saW5nX2RldmljZV91bnJlZ2lzdGVyKHN0cnVjdCB0aGVybWFsX2Nvb2xpbmdfZGV2aWNlICopOworZXh0ZXJuIGludCBnZW5lcmF0ZV9uZXRsaW5rX2V2ZW50KHUzMiBvcmlnLCBlbnVtIGV2ZW50cyBldmVudCk7CiAKICNlbmRpZiAvKiBfX1RIRVJNQUxfSF9fICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3RyYWNlcG9pbnQuaCBiL2luY2x1ZGUvbGludXgvdHJhY2Vwb2ludC5oCmluZGV4IGM2ODE0NjEuLjk3Yzg0YTUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvdHJhY2Vwb2ludC5oCisrKyBiL2luY2x1ZGUvbGludXgvdHJhY2Vwb2ludC5oCkBAIC0zMywxMiArMzMsNyBAQAogCXZvaWQgKCpyZWdmdW5jKSh2b2lkKTsKIAl2b2lkICgqdW5yZWdmdW5jKSh2b2lkKTsKIAlzdHJ1Y3QgdHJhY2Vwb2ludF9mdW5jIF9fcmN1ICpmdW5jczsKLX0gX19hdHRyaWJ1dGVfXygoYWxpZ25lZCgzMikpKTsJCS8qCi0JCQkJCSAqIEFsaWduZWQgb24gMzIgYnl0ZXMgYmVjYXVzZSBpdCBpcwotCQkJCQkgKiBnbG9iYWxseSB2aXNpYmxlIGFuZCBnY2MgaGFwcGlseQotCQkJCQkgKiBhbGlnbiB0aGVzZSBvbiB0aGUgc3RydWN0dXJlIHNpemUuCi0JCQkJCSAqIEtlZXAgaW4gc3luYyB3aXRoIHZtbGludXgubGRzLmguCi0JCQkJCSAqLworfTsKIAogLyoKICAqIENvbm5lY3QgYSBwcm9iZSB0byBhIHRyYWNlcG9pbnQuCkBAIC02MSwxNSArNTYsMTUgQEAKIAogc3RydWN0IHRyYWNlcG9pbnRfaXRlciB7CiAJc3RydWN0IG1vZHVsZSAqbW9kdWxlOwotCXN0cnVjdCB0cmFjZXBvaW50ICp0cmFjZXBvaW50OworCXN0cnVjdCB0cmFjZXBvaW50ICogY29uc3QgKnRyYWNlcG9pbnQ7CiB9OwogCiBleHRlcm4gdm9pZCB0cmFjZXBvaW50X2l0ZXJfc3RhcnQoc3RydWN0IHRyYWNlcG9pbnRfaXRlciAqaXRlcik7CiBleHRlcm4gdm9pZCB0cmFjZXBvaW50X2l0ZXJfbmV4dChzdHJ1Y3QgdHJhY2Vwb2ludF9pdGVyICppdGVyKTsKIGV4dGVybiB2b2lkIHRyYWNlcG9pbnRfaXRlcl9zdG9wKHN0cnVjdCB0cmFjZXBvaW50X2l0ZXIgKml0ZXIpOwogZXh0ZXJuIHZvaWQgdHJhY2Vwb2ludF9pdGVyX3Jlc2V0KHN0cnVjdCB0cmFjZXBvaW50X2l0ZXIgKml0ZXIpOwotZXh0ZXJuIGludCB0cmFjZXBvaW50X2dldF9pdGVyX3JhbmdlKHN0cnVjdCB0cmFjZXBvaW50ICoqdHJhY2Vwb2ludCwKLQlzdHJ1Y3QgdHJhY2Vwb2ludCAqYmVnaW4sIHN0cnVjdCB0cmFjZXBvaW50ICplbmQpOworZXh0ZXJuIGludCB0cmFjZXBvaW50X2dldF9pdGVyX3JhbmdlKHN0cnVjdCB0cmFjZXBvaW50ICogY29uc3QgKip0cmFjZXBvaW50LAorCXN0cnVjdCB0cmFjZXBvaW50ICogY29uc3QgKmJlZ2luLCBzdHJ1Y3QgdHJhY2Vwb2ludCAqIGNvbnN0ICplbmQpOwogCiAvKgogICogdHJhY2Vwb2ludF9zeW5jaHJvbml6ZV91bnJlZ2lzdGVyIG11c3QgYmUgY2FsbGVkIGJldHdlZW4gdGhlIGxhc3QgdHJhY2Vwb2ludApAQCAtODQsMTEgKzc5LDEzIEBACiAjZGVmaW5lIFBBUkFNUyhhcmdzLi4uKSBhcmdzCiAKICNpZmRlZiBDT05GSUdfVFJBQ0VQT0lOVFMKLWV4dGVybiB2b2lkIHRyYWNlcG9pbnRfdXBkYXRlX3Byb2JlX3JhbmdlKHN0cnVjdCB0cmFjZXBvaW50ICpiZWdpbiwKLQlzdHJ1Y3QgdHJhY2Vwb2ludCAqZW5kKTsKK2V4dGVybgordm9pZCB0cmFjZXBvaW50X3VwZGF0ZV9wcm9iZV9yYW5nZShzdHJ1Y3QgdHJhY2Vwb2ludCAqIGNvbnN0ICpiZWdpbiwKKwlzdHJ1Y3QgdHJhY2Vwb2ludCAqIGNvbnN0ICplbmQpOwogI2Vsc2UKLXN0YXRpYyBpbmxpbmUgdm9pZCB0cmFjZXBvaW50X3VwZGF0ZV9wcm9iZV9yYW5nZShzdHJ1Y3QgdHJhY2Vwb2ludCAqYmVnaW4sCi0Jc3RydWN0IHRyYWNlcG9pbnQgKmVuZCkKK3N0YXRpYyBpbmxpbmUKK3ZvaWQgdHJhY2Vwb2ludF91cGRhdGVfcHJvYmVfcmFuZ2Uoc3RydWN0IHRyYWNlcG9pbnQgKiBjb25zdCAqYmVnaW4sCisJc3RydWN0IHRyYWNlcG9pbnQgKiBjb25zdCAqZW5kKQogeyB9CiAjZW5kaWYgLyogQ09ORklHX1RSQUNFUE9JTlRTICovCiAKQEAgLTE3NCwxMiArMTcxLDIwIEBACiAJewkJCQkJCQkJXAogCX0KIAorLyoKKyAqIFdlIGhhdmUgbm8gZ3VhcmFudGVlIHRoYXQgZ2NjIGFuZCB0aGUgbGlua2VyIHdvbid0IHVwLWFsaWduIHRoZSB0cmFjZXBvaW50CisgKiBzdHJ1Y3R1cmVzLCBzbyB3ZSBjcmVhdGUgYW4gYXJyYXkgb2YgcG9pbnRlcnMgdGhhdCB3aWxsIGJlIHVzZWQgZm9yIGl0ZXJhdGlvbgorICogb24gdGhlIHRyYWNlcG9pbnRzLgorICovCiAjZGVmaW5lIERFRklORV9UUkFDRV9GTihuYW1lLCByZWcsIHVucmVnKQkJCQlcCiAJc3RhdGljIGNvbnN0IGNoYXIgX190cHN0cnRhYl8jI25hbWVbXQkJCQlcCiAJX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiX190cmFjZXBvaW50c19zdHJpbmdzIikpKSA9ICNuYW1lOwlcCiAJc3RydWN0IHRyYWNlcG9pbnQgX190cmFjZXBvaW50XyMjbmFtZQkJCQlcCi0JX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiX190cmFjZXBvaW50cyIpLCBhbGlnbmVkKDMyKSkpID0JXAotCQl7IF9fdHBzdHJ0YWJfIyNuYW1lLCAwLCByZWcsIHVucmVnLCBOVUxMIH0KKwlfX2F0dHJpYnV0ZV9fKChzZWN0aW9uKCJfX3RyYWNlcG9pbnRzIikpKSA9CQkJXAorCQl7IF9fdHBzdHJ0YWJfIyNuYW1lLCAwLCByZWcsIHVucmVnLCBOVUxMIH07CQlcCisJc3RhdGljIHN0cnVjdCB0cmFjZXBvaW50ICogY29uc3QgX190cmFjZXBvaW50X3B0cl8jI25hbWUgX191c2VkCVwKKwlfX2F0dHJpYnV0ZV9fKChzZWN0aW9uKCJfX3RyYWNlcG9pbnRzX3B0cnMiKSkpID0JCVwKKwkJJl9fdHJhY2Vwb2ludF8jI25hbWU7CiAKICNkZWZpbmUgREVGSU5FX1RSQUNFKG5hbWUpCQkJCQkJXAogCURFRklORV9UUkFDRV9GTihuYW1lLCBOVUxMLCBOVUxMKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdXNiL2NkYy5oIGIvaW5jbHVkZS9saW51eC91c2IvY2RjLmgKaW5kZXggNWU4NmRjNy4uODFhOTI3OSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC91c2IvY2RjLmgKKysrIGIvaW5jbHVkZS9saW51eC91c2IvY2RjLmgKQEAgLTg5LDcgKzg5LDcgQEAKIAogI2RlZmluZSBVU0JfQ0RDX0NPTU1fRkVBVFVSRQkweDAxCiAjZGVmaW5lIFVTQl9DRENfQ0FQX0xJTkUJMHgwMgotI2RlZmluZSBVU0JfQ0RDX0NBUF9CUksJMHgwNAorI2RlZmluZSBVU0JfQ0RDX0NBUF9CUksJCTB4MDQKICNkZWZpbmUgVVNCX0NEQ19DQVBfTk9USUZZCTB4MDgKIAogLyogIlVuaW9uIEZ1bmN0aW9uYWwgRGVzY3JpcHRvciIgZnJvbSBDREMgc3BlYyA1LjIuMy44ICovCkBAIC0yNzEsNiArMjcxLDExIEBACiAJX19sZTE2CXdMZW5ndGg7CiB9IF9fYXR0cmlidXRlX18gKChwYWNrZWQpKTsKIAorc3RydWN0IHVzYl9jZGNfc3BlZWRfY2hhbmdlIHsKKwlfX2xlMzIJRExCaXRSUmF0ZTsJLyogY29udGFpbnMgdGhlIGRvd25saW5rIGJpdCByYXRlIChJTiBwaXBlKSAqLworCV9fbGUzMglVTEJpdFJhdGU7CS8qIGNvbnRhaW5zIHRoZSB1cGxpbmsgYml0IHJhdGUgKE9VVCBwaXBlKSAqLworfSBfX2F0dHJpYnV0ZV9fICgocGFja2VkKSk7CisKIC8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCiAKIC8qCkBAIC0yOTIsNyArMjk3LDcgQEAKIAlfX2xlMTYJd05kcE91dERpdmlzb3I7CiAJX19sZTE2CXdOZHBPdXRQYXlsb2FkUmVtYWluZGVyOwogCV9fbGUxNgl3TmRwT3V0QWxpZ25tZW50OwotCV9fbGUxNgl3UGFkZGluZzI7CisJX19sZTE2CXdOdGJPdXRNYXhEYXRhZ3JhbXM7CiB9IF9fYXR0cmlidXRlX18gKChwYWNrZWQpKTsKIAogLyoKQEAgLTMwNyw3ICszMTIsNyBAQAogCV9fbGUxNgl3SGVhZGVyTGVuZ3RoOwogCV9fbGUxNgl3U2VxdWVuY2U7CiAJX19sZTE2CXdCbG9ja0xlbmd0aDsKLQlfX2xlMTYJd0ZwSW5kZXg7CisJX19sZTE2CXdOZHBJbmRleDsKIH0gX19hdHRyaWJ1dGVfXyAoKHBhY2tlZCkpOwogCiBzdHJ1Y3QgdXNiX2NkY19uY21fbnRoMzIgewpAQCAtMzE1LDcgKzMyMCw3IEBACiAJX19sZTE2CXdIZWFkZXJMZW5ndGg7CiAJX19sZTE2CXdTZXF1ZW5jZTsKIAlfX2xlMzIJZHdCbG9ja0xlbmd0aDsKLQlfX2xlMzIJZHdGcEluZGV4OworCV9fbGUzMglkd05kcEluZGV4OwogfSBfX2F0dHJpYnV0ZV9fICgocGFja2VkKSk7CiAKIC8qCkBAIC0zMzcsNyArMzQyLDcgQEAKIHN0cnVjdCB1c2JfY2RjX25jbV9uZHAxNiB7CiAJX19sZTMyCWR3U2lnbmF0dXJlOwogCV9fbGUxNgl3TGVuZ3RoOwotCV9fbGUxNgl3TmV4dEZwSW5kZXg7CisJX19sZTE2CXdOZXh0TmRwSW5kZXg7CiAJc3RydWN0CXVzYl9jZGNfbmNtX2RwZTE2IGRwZTE2WzBdOwogfSBfX2F0dHJpYnV0ZV9fICgocGFja2VkKSk7CiAKQEAgLTM3NSw2ICszODAsNyBAQAogI2RlZmluZSBVU0JfQ0RDX05DTV9OQ0FQX0VOQ0FQX0NPTU1BTkQJCQkoMSA8PCAyKQogI2RlZmluZSBVU0JfQ0RDX05DTV9OQ0FQX01BWF9EQVRBR1JBTV9TSVpFCQkoMSA8PCAzKQogI2RlZmluZSBVU0JfQ0RDX05DTV9OQ0FQX0NSQ19NT0RFCQkJKDEgPDwgNCkKKyNkZWZpbmUJVVNCX0NEQ19OQ01fTkNBUF9OVEJfSU5QVVRfU0laRQkJCSgxIDw8IDUpCiAKIC8qIENEQyBOQ00gc3ViY2xhc3MgVGFibGUgNi0zOiBOVEIgUGFyYW1ldGVyIFN0cnVjdHVyZSAqLwogI2RlZmluZSBVU0JfQ0RDX05DTV9OVEIxNl9TVVBQT1JURUQJCQkoMSA8PCAwKQpAQCAtMzkyLDYgKzM5OCwxMyBAQAogI2RlZmluZSBVU0JfQ0RDX05DTV9OVEJfTUlOX0lOX1NJWkUJCQkyMDQ4CiAjZGVmaW5lIFVTQl9DRENfTkNNX05UQl9NSU5fT1VUX1NJWkUJCQkyMDQ4CiAKKy8qIE5UQiBJbnB1dCBTaXplIFN0cnVjdHVyZSAqLworc3RydWN0IHVzYl9jZGNfbmNtX25kcF9pbnB1dF9zaXplIHsKKwlfX2xlMzIJZHdOdGJJbk1heFNpemU7CisJX19sZTE2CXdOdGJJbk1heERhdGFncmFtczsKKwlfX2xlMTYJd1Jlc2VydmVkOworfSBfX2F0dHJpYnV0ZV9fICgocGFja2VkKSk7CisKIC8qIENEQyBOQ00gc3ViY2xhc3MgNi4yLjExIFNldENyY01vZGUgKi8KICNkZWZpbmUgVVNCX0NEQ19OQ01fQ1JDX05PVF9BUFBFTkRFRAkJCTB4MDAKICNkZWZpbmUgVVNCX0NEQ19OQ01fQ1JDX0FQUEVOREVECQkJMHgwMQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC91c2IvaGNkLmggYi9pbmNsdWRlL2xpbnV4L3VzYi9oY2QuaAppbmRleCBkZDZlZTQ5Li5hODU0ZmU4IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3VzYi9oY2QuaAorKysgYi9pbmNsdWRlL2xpbnV4L3VzYi9oY2QuaApAQCAtMTEyLDYgKzExMiw3IEBACiAJLyogRmxhZ3MgdGhhdCBnZXQgc2V0IG9ubHkgZHVyaW5nIEhDRCByZWdpc3RyYXRpb24gb3IgcmVtb3ZhbC4gKi8KIAl1bnNpZ25lZAkJcmhfcmVnaXN0ZXJlZDoxOy8qIGlzIHJvb3QgaHViIHJlZ2lzdGVyZWQ/ICovCiAJdW5zaWduZWQJCXJoX3BvbGxhYmxlOjE7CS8qIG1heSB3ZSBwb2xsIHRoZSByb290IGh1Yj8gKi8KKwl1bnNpZ25lZAkJbXNpeF9lbmFibGVkOjE7CS8qIGRyaXZlciBoYXMgTVNJLVggZW5hYmxlZD8gKi8KIAogCS8qIFRoZSBuZXh0IGZsYWcgaXMgYSBzdG9wZ2FwLCB0byBiZSByZW1vdmVkIHdoZW4gYWxsIHRoZSBIQ0RzCiAJICogc3VwcG9ydCB0aGUgbmV3IHJvb3QtaHViIHBvbGxpbmcgbWVjaGFuaXNtLiAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC91c2IvbXNtX2hzdXNiX2h3LmggYi9pbmNsdWRlL2xpbnV4L3VzYi9tc21faHN1c2JfaHcuaAppbmRleCBiOTJlMTczLi43ZDFiYWJiIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3VzYi9tc21faHN1c2JfaHcuaAorKysgYi9pbmNsdWRlL2xpbnV4L3VzYi9tc21faHN1c2JfaHcuaApAQCAtMTYsMTIgKzE2LDggQEAKICNpZm5kZWYgX19MSU5VWF9VU0JfR0FER0VUX01TTTcyS19VRENfSF9fCiAjZGVmaW5lIF9fTElOVVhfVVNCX0dBREdFVF9NU003MktfVURDX0hfXwogCi0jaWZkZWYgQ09ORklHX0FSQ0hfTVNNN1gwMEEKLSNkZWZpbmUgVVNCX1NCVVNDRkcgICAgICAgICAgKE1TTV9VU0JfQkFTRSArIDB4MDA5MCkKLSNlbHNlCiAjZGVmaW5lIFVTQl9BSEJCVVJTVCAgICAgICAgIChNU01fVVNCX0JBU0UgKyAweDAwOTApCiAjZGVmaW5lIFVTQl9BSEJNT0RFICAgICAgICAgIChNU01fVVNCX0JBU0UgKyAweDAwOTgpCi0jZW5kaWYKICNkZWZpbmUgVVNCX0NBUExFTkdUSCAgICAgICAgKE1TTV9VU0JfQkFTRSArIDB4MDEwMCkgLyogOCBiaXQgKi8KIAogI2RlZmluZSBVU0JfVVNCQ01EICAgICAgICAgICAoTVNNX1VTQl9CQVNFICsgMHgwMTQwKQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC91c2Ivc2VyaWFsLmggYi9pbmNsdWRlL2xpbnV4L3VzYi9zZXJpYWwuaAppbmRleCAxNmQ2ODJmLi5jOTA0OTEzIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3VzYi9zZXJpYWwuaAorKysgYi9pbmNsdWRlL2xpbnV4L3VzYi9zZXJpYWwuaApAQCAtMzQ3LDYgKzM0Nyw5IEBACiBleHRlcm4gaW50IHVzYl9zZXJpYWxfaGFuZGxlX3N5c3JxX2NoYXIoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCwKIAkJCQkJdW5zaWduZWQgaW50IGNoKTsKIGV4dGVybiBpbnQgdXNiX3NlcmlhbF9oYW5kbGVfYnJlYWsoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCk7CitleHRlcm4gdm9pZCB1c2Jfc2VyaWFsX2hhbmRsZV9kY2RfY2hhbmdlKHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnVzYl9wb3J0LAorCQkJCQkgc3RydWN0IHR0eV9zdHJ1Y3QgKnR0eSwKKwkJCQkJIHVuc2lnbmVkIGludCBzdGF0dXMpOwogCiAKIGV4dGVybiBpbnQgdXNiX3NlcmlhbF9idXNfcmVnaXN0ZXIoc3RydWN0IHVzYl9zZXJpYWxfZHJpdmVyICpkZXZpY2UpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC92aXJ0aW9fY29uZmlnLmggYi9pbmNsdWRlL2xpbnV4L3ZpcnRpb19jb25maWcuaAppbmRleCAwMDkzZGQ3Li44MDA2MTdiIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3ZpcnRpb19jb25maWcuaAorKysgYi9pbmNsdWRlL2xpbnV4L3ZpcnRpb19jb25maWcuaApAQCAtMTA5LDcgKzEwOSwxMCBAQAogCQkJCSAgICAgIHVuc2lnbmVkIGludCBmYml0KQogewogCS8qIERpZCB5b3UgZm9yZ2V0IHRvIGZpeCBhc3N1bXB0aW9ucyBvbiBtYXggZmVhdHVyZXM/ICovCi0JTUFZQkVfQlVJTERfQlVHX09OKGZiaXQgPj0gMzIpOworCWlmIChfX2J1aWx0aW5fY29uc3RhbnRfcChmYml0KSkKKwkJQlVJTERfQlVHX09OKGZiaXQgPj0gMzIpOworCWVsc2UKKwkJQlVHX09OKGZiaXQgPj0gMzIpOwogCiAJaWYgKGZiaXQgPCBWSVJUSU9fVFJBTlNQT1JUX0ZfU1RBUlQpCiAJCXZpcnRpb19jaGVja19kcml2ZXJfb2ZmZXJlZF9mZWF0dXJlKHZkZXYsIGZiaXQpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC92aXJ0aW9fY29uc29sZS5oIGIvaW5jbHVkZS9saW51eC92aXJ0aW9fY29uc29sZS5oCmluZGV4IGE4NTA2NGQuLmU0ZDMzMzUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvdmlydGlvX2NvbnNvbGUuaAorKysgYi9pbmNsdWRlL2xpbnV4L3ZpcnRpb19jb25zb2xlLmgKQEAgLTcsNyArNyw4IEBACiAgKiBUaGlzIGhlYWRlciwgZXhjbHVkaW5nIHRoZSAjaWZkZWYgX19LRVJORUxfXyBwYXJ0LCBpcyBCU0QgbGljZW5zZWQgc28KICAqIGFueW9uZSBjYW4gdXNlIHRoZSBkZWZpbml0aW9ucyB0byBpbXBsZW1lbnQgY29tcGF0aWJsZSBkcml2ZXJzL3NlcnZlcnMuCiAgKgotICogQ29weXJpZ2h0IChDKSBSZWQgSGF0LCBJbmMuLCAyMDA5LCAyMDEwCisgKiBDb3B5cmlnaHQgKEMpIFJlZCBIYXQsIEluYy4sIDIwMDksIDIwMTAsIDIwMTEKKyAqIENvcHlyaWdodCAoQykgQW1pdCBTaGFoIDxhbWl0LnNoYWhAcmVkaGF0LmNvbT4sIDIwMDksIDIwMTAsIDIwMTEKICAqLwogCiAvKiBGZWF0dXJlIGJpdHMgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdm1hbGxvYy5oIGIvaW5jbHVkZS9saW51eC92bWFsbG9jLmgKaW5kZXggNDRiNTRmNi4uNGVkNmZjZCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC92bWFsbG9jLmgKKysrIGIvaW5jbHVkZS9saW51eC92bWFsbG9jLmgKQEAgLTU5LDggKzU5LDkgQEAKIGV4dGVybiB2b2lkICp2bWFsbG9jXzMyKHVuc2lnbmVkIGxvbmcgc2l6ZSk7CiBleHRlcm4gdm9pZCAqdm1hbGxvY18zMl91c2VyKHVuc2lnbmVkIGxvbmcgc2l6ZSk7CiBleHRlcm4gdm9pZCAqX192bWFsbG9jKHVuc2lnbmVkIGxvbmcgc2l6ZSwgZ2ZwX3QgZ2ZwX21hc2ssIHBncHJvdF90IHByb3QpOwotZXh0ZXJuIHZvaWQgKl9fdm1hbGxvY19hcmVhKHN0cnVjdCB2bV9zdHJ1Y3QgKmFyZWEsIGdmcF90IGdmcF9tYXNrLAotCQkJCXBncHJvdF90IHByb3QpOworZXh0ZXJuIHZvaWQgKl9fdm1hbGxvY19ub2RlX3JhbmdlKHVuc2lnbmVkIGxvbmcgc2l6ZSwgdW5zaWduZWQgbG9uZyBhbGlnbiwKKwkJCXVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgZW5kLCBnZnBfdCBnZnBfbWFzaywKKwkJCXBncHJvdF90IHByb3QsIGludCBub2RlLCB2b2lkICpjYWxsZXIpOwogZXh0ZXJuIHZvaWQgdmZyZWUoY29uc3Qgdm9pZCAqYWRkcik7CiAKIGV4dGVybiB2b2lkICp2bWFwKHN0cnVjdCBwYWdlICoqcGFnZXMsIHVuc2lnbmVkIGludCBjb3VudCwKQEAgLTkwLDkgKzkxLDYgQEAKIAkJCQkJdW5zaWduZWQgbG9uZyBmbGFncywKIAkJCQkJdW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWduZWQgbG9uZyBlbmQsCiAJCQkJCXZvaWQgKmNhbGxlcik7Ci1leHRlcm4gc3RydWN0IHZtX3N0cnVjdCAqZ2V0X3ZtX2FyZWFfbm9kZSh1bnNpZ25lZCBsb25nIHNpemUsCi0JCQkJCSAgdW5zaWduZWQgbG9uZyBmbGFncywgaW50IG5vZGUsCi0JCQkJCSAgZ2ZwX3QgZ2ZwX21hc2spOwogZXh0ZXJuIHN0cnVjdCB2bV9zdHJ1Y3QgKnJlbW92ZV92bV9hcmVhKGNvbnN0IHZvaWQgKmFkZHIpOwogCiBleHRlcm4gaW50IG1hcF92bV9hcmVhKHN0cnVjdCB2bV9zdHJ1Y3QgKmFyZWEsIHBncHJvdF90IHByb3QsCkBAIC0xMjAsNyArMTE4LDcgQEAKICNpZmRlZiBDT05GSUdfU01QCiBzdHJ1Y3Qgdm1fc3RydWN0ICoqcGNwdV9nZXRfdm1fYXJlYXMoY29uc3QgdW5zaWduZWQgbG9uZyAqb2Zmc2V0cywKIAkJCQkgICAgIGNvbnN0IHNpemVfdCAqc2l6ZXMsIGludCBucl92bXMsCi0JCQkJICAgICBzaXplX3QgYWxpZ24sIGdmcF90IGdmcF9tYXNrKTsKKwkJCQkgICAgIHNpemVfdCBhbGlnbik7CiAKIHZvaWQgcGNwdV9mcmVlX3ZtX2FyZWFzKHN0cnVjdCB2bV9zdHJ1Y3QgKip2bXMsIGludCBucl92bXMpOwogI2VuZGlmCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3Ztc3RhdC5oIGIvaW5jbHVkZS9saW51eC92bXN0YXQuaAppbmRleCBlYWFlYTM3Li44MzNlNjc2IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3Ztc3RhdC5oCisrKyBiL2luY2x1ZGUvbGludXgvdm1zdGF0LmgKQEAgLTI1NCw2ICsyNTQsMTEgQEAKIGV4dGVybiB2b2lkIF9fZGVjX3pvbmVfc3RhdGUoc3RydWN0IHpvbmUgKiwgZW51bSB6b25lX3N0YXRfaXRlbSk7CiAKIHZvaWQgcmVmcmVzaF9jcHVfdm1fc3RhdHMoaW50KTsKKworaW50IGNhbGN1bGF0ZV9wcmVzc3VyZV90aHJlc2hvbGQoc3RydWN0IHpvbmUgKnpvbmUpOworaW50IGNhbGN1bGF0ZV9ub3JtYWxfdGhyZXNob2xkKHN0cnVjdCB6b25lICp6b25lKTsKK3ZvaWQgc2V0X3BnZGF0X3BlcmNwdV90aHJlc2hvbGQocGdfZGF0YV90ICpwZ2RhdCwKKwkJCQlpbnQgKCpjYWxjdWxhdGVfcHJlc3N1cmUpKHN0cnVjdCB6b25lICopKTsKICNlbHNlIC8qIENPTkZJR19TTVAgKi8KIAogLyoKQEAgLTI5OCw2ICszMDMsOCBAQAogI2RlZmluZSBkZWNfem9uZV9wYWdlX3N0YXRlIF9fZGVjX3pvbmVfcGFnZV9zdGF0ZQogI2RlZmluZSBtb2Rfem9uZV9wYWdlX3N0YXRlIF9fbW9kX3pvbmVfcGFnZV9zdGF0ZQogCisjZGVmaW5lIHNldF9wZ2RhdF9wZXJjcHVfdGhyZXNob2xkKHBnZGF0LCBjYWxsYmFjaykgeyB9CisKIHN0YXRpYyBpbmxpbmUgdm9pZCByZWZyZXNoX2NwdV92bV9zdGF0cyhpbnQgY3B1KSB7IH0KICNlbmRpZgogCmRpZmYgLS1naXQgYS9pbmNsdWRlL21lZGlhL210OXYwMTEuaCBiL2luY2x1ZGUvbWVkaWEvbXQ5djAxMS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmVhMjlmYzcKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL21lZGlhL210OXYwMTEuaApAQCAtMCwwICsxLDE3IEBACisvKiBtdDl2MDExIHNlbnNvcgorICoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBIYW5zIFZlcmt1aWwgPGh2ZXJrdWlsQHhzNGFsbC5ubD4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICovCisKKyNpZm5kZWYgX19NVDlWMDExX0hfXworI2RlZmluZSBfX01UOVYwMTFfSF9fCisKK3N0cnVjdCBtdDl2MDExX3BsYXRmb3JtX2RhdGEgeworCXVuc2lnbmVkIHh0YWw7CS8qIEh6ICovCit9OworCisjZW5kaWYKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbWVkaWEvcmMtY29yZS5oIGIvaW5jbHVkZS9tZWRpYS9yYy1jb3JlLmgKaW5kZXggYTIzYzFmYy4uMjk2MzI2MyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9tZWRpYS9yYy1jb3JlLmgKKysrIGIvaW5jbHVkZS9tZWRpYS9yYy1jb3JlLmgKQEAgLTE4Myw2ICsxODMsOSBAQAogfQogCiAjZGVmaW5lIElSX01BWF9EVVJBVElPTiAgICAgICAgIDB4RkZGRkZGRkYgICAgICAvKiBhIGJpdCBtb3JlIHRoYW4gNCBzZWNvbmRzICovCisjZGVmaW5lIFVTX1RPX05TKHVzZWMpCQkoKHVzZWMpICogMTAwMCkKKyNkZWZpbmUgTVNfVE9fVVMobXNlYykJCSgobXNlYykgKiAxMDAwKQorI2RlZmluZSBNU19UT19OUyhtc2VjKQkJKChtc2VjKSAqIDEwMDAgKiAxMDAwKQogCiB2b2lkIGlyX3Jhd19ldmVudF9oYW5kbGUoc3RydWN0IHJjX2RldiAqZGV2KTsKIGludCBpcl9yYXdfZXZlbnRfc3RvcmUoc3RydWN0IHJjX2RldiAqZGV2LCBzdHJ1Y3QgaXJfcmF3X2V2ZW50ICpldik7CmRpZmYgLS1naXQgYS9pbmNsdWRlL21lZGlhL3NhYTcxNDYuaCBiL2luY2x1ZGUvbWVkaWEvc2FhNzE0Ni5oCmluZGV4IGFjN2NlMDAuLjc5ODI3MTQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbWVkaWEvc2FhNzE0Ni5oCisrKyBiL2luY2x1ZGUvbWVkaWEvc2FhNzE0Ni5oCkBAIC0xMTUsNyArMTE1LDcgQEAKIAogCS8qIGRpZmZlcmVudCBkZXZpY2UgbG9ja3MgKi8KIAlzcGlubG9ja190CQkJc2xvY2s7Ci0Jc3RydWN0IG11dGV4CQkJbG9jazsKKwlzdHJ1Y3QgbXV0ZXgJCQl2NGwyX2xvY2s7CiAKIAl1bnNpZ25lZCBjaGFyCQkJX19pb21lbSAqbWVtOwkJLyogcG9pbnRlciB0byBtYXBwZWQgSU8gbWVtb3J5ICovCiAJdTMyCQkJCXJldmlzaW9uOwkvKiBjaGlwIHJldmlzaW9uOyBuZWVkZWQgZm9yIGJ1Zy13b3JrYXJvdW5kcyovCmRpZmYgLS1naXQgYS9pbmNsdWRlL21lZGlhL3Y0bDItY29tbW9uLmggYi9pbmNsdWRlL21lZGlhL3Y0bDItY29tbW9uLmgKaW5kZXggMmQ2NWIzNS4uYTY1OTMxOSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9tZWRpYS92NGwyLWNvbW1vbi5oCisrKyBiL2luY2x1ZGUvbWVkaWEvdjRsMi1jb21tb24uaApAQCAtMTM4LDIxICsxMzgsMTAgQEAKIAogLyogTG9hZCBhbiBpMmMgbW9kdWxlIGFuZCByZXR1cm4gYW4gaW5pdGlhbGl6ZWQgdjRsMl9zdWJkZXYgc3RydWN0LgogICAgVGhlIGNsaWVudF90eXBlIGFyZ3VtZW50IGlzIHRoZSBuYW1lIG9mIHRoZSBjaGlwIHRoYXQncyBvbiB0aGUgYWRhcHRlci4gKi8KLXN0cnVjdCB2NGwyX3N1YmRldiAqdjRsMl9pMmNfbmV3X3N1YmRldl9jZmcoc3RydWN0IHY0bDJfZGV2aWNlICp2NGwyX2RldiwKK3N0cnVjdCB2NGwyX3N1YmRldiAqdjRsMl9pMmNfbmV3X3N1YmRldihzdHJ1Y3QgdjRsMl9kZXZpY2UgKnY0bDJfZGV2LAogCQlzdHJ1Y3QgaTJjX2FkYXB0ZXIgKmFkYXB0ZXIsIGNvbnN0IGNoYXIgKmNsaWVudF90eXBlLAotCQlpbnQgaXJxLCB2b2lkICpwbGF0Zm9ybV9kYXRhLAogCQl1OCBhZGRyLCBjb25zdCB1bnNpZ25lZCBzaG9ydCAqcHJvYmVfYWRkcnMpOwogCi0vKiBMb2FkIGFuIGkyYyBtb2R1bGUgYW5kIHJldHVybiBhbiBpbml0aWFsaXplZCB2NGwyX3N1YmRldiBzdHJ1Y3QuCi0gICBUaGUgY2xpZW50X3R5cGUgYXJndW1lbnQgaXMgdGhlIG5hbWUgb2YgdGhlIGNoaXAgdGhhdCdzIG9uIHRoZSBhZGFwdGVyLiAqLwotc3RhdGljIGlubGluZSBzdHJ1Y3QgdjRsMl9zdWJkZXYgKnY0bDJfaTJjX25ld19zdWJkZXYoc3RydWN0IHY0bDJfZGV2aWNlICp2NGwyX2RldiwKLQkJc3RydWN0IGkyY19hZGFwdGVyICphZGFwdGVyLCBjb25zdCBjaGFyICpjbGllbnRfdHlwZSwKLQkJdTggYWRkciwgY29uc3QgdW5zaWduZWQgc2hvcnQgKnByb2JlX2FkZHJzKQotewotCXJldHVybiB2NGwyX2kyY19uZXdfc3ViZGV2X2NmZyh2NGwyX2RldiwgYWRhcHRlciwgY2xpZW50X3R5cGUsIDAsIE5VTEwsCi0JCQkJICAgICAgIGFkZHIsIHByb2JlX2FkZHJzKTsKLX0KLQogc3RydWN0IGkyY19ib2FyZF9pbmZvOwogCiBzdHJ1Y3QgdjRsMl9zdWJkZXYgKnY0bDJfaTJjX25ld19zdWJkZXZfYm9hcmQoc3RydWN0IHY0bDJfZGV2aWNlICp2NGwyX2RldiwKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbWVkaWEvdjRsMi1jdHJscy5oIGIvaW5jbHVkZS9tZWRpYS92NGwyLWN0cmxzLmgKaW5kZXggZDY5YWI0YS4uOTdkMDYzOCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9tZWRpYS92NGwyLWN0cmxzLmgKKysrIGIvaW5jbHVkZS9tZWRpYS92NGwyLWN0cmxzLmgKQEAgLTIzLDYgKzIzLDcgQEAKIAogI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC92aWRlb2RldjIuaD4KIAogLyogZm9yd2FyZCByZWZlcmVuY2VzICovCiBzdHJ1Y3QgdjRsMl9jdHJsX2hhbmRsZXI7CkBAIC01Myw4ICs1NCwxMCBAQAogICAqIEBoYW5kbGVyOglUaGUgaGFuZGxlciB0aGF0IG93bnMgdGhlIGNvbnRyb2wuCiAgICogQGNsdXN0ZXI6CVBvaW50IHRvIHN0YXJ0IG9mIGNsdXN0ZXIgYXJyYXkuCiAgICogQG5jb250cm9sczoJTnVtYmVyIG9mIGNvbnRyb2xzIGluIGNsdXN0ZXIgYXJyYXkuCi0gICogQGhhc19uZXc6CUludGVybmFsIGZsYWc6IHNldCB3aGVuIHRoZXJlIGlzIGEgdmFsaWQgbmV3IHZhbHVlLgogICAqIEBkb25lOglJbnRlcm5hbCBmbGFnOiBzZXQgZm9yIGVhY2ggcHJvY2Vzc2VkIGNvbnRyb2wuCisgICogQGlzX25ldzoJU2V0IHdoZW4gdGhlIHVzZXIgc3BlY2lmaWVkIGEgbmV3IHZhbHVlIGZvciB0aGlzIGNvbnRyb2wuIEl0CisgICoJCWlzIGFsc28gc2V0IHdoZW4gY2FsbGVkIGZyb20gdjRsMl9jdHJsX2hhbmRsZXJfc2V0dXAuIERyaXZlcnMKKyAgKgkJc2hvdWxkIG5ldmVyIHNldCB0aGlzIGZsYWcuCiAgICogQGlzX3ByaXZhdGU6IElmIHNldCwgdGhlbiB0aGlzIGNvbnRyb2wgaXMgcHJpdmF0ZSB0byBpdHMgaGFuZGxlciBhbmQgaXQKICAgKgkJd2lsbCBub3QgYmUgYWRkZWQgdG8gYW55IG90aGVyIGhhbmRsZXJzLiBEcml2ZXJzIGNhbiBzZXQKICAgKgkJdGhpcyBmbGFnLgpAQCAtOTcsOSArMTAwLDkgQEAKIAlzdHJ1Y3QgdjRsMl9jdHJsX2hhbmRsZXIgKmhhbmRsZXI7CiAJc3RydWN0IHY0bDJfY3RybCAqKmNsdXN0ZXI7CiAJdW5zaWduZWQgbmNvbnRyb2xzOwotCXVuc2lnbmVkIGludCBoYXNfbmV3OjE7CiAJdW5zaWduZWQgaW50IGRvbmU6MTsKIAorCXVuc2lnbmVkIGludCBpc19uZXc6MTsKIAl1bnNpZ25lZCBpbnQgaXNfcHJpdmF0ZToxOwogCXVuc2lnbmVkIGludCBpc192b2xhdGlsZToxOwogCmRpZmYgLS1naXQgYS9pbmNsdWRlL21lZGlhL3Y0bDItc3ViZGV2LmggYi9pbmNsdWRlL21lZGlhL3Y0bDItc3ViZGV2LmgKaW5kZXggYjAzMTZhNy4uZGFmMWU1NyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9tZWRpYS92NGwyLXN1YmRldi5oCisrKyBiL2luY2x1ZGUvbWVkaWEvdjRsMi1zdWJkZXYuaApAQCAtMTA2LDEwICsxMDYsNyBAQAogCXU4IHN0cmVuZ3RoOwkvKiBQaW4gZHJpdmUgc3RyZW5ndGggKi8KIH07CiAKLS8qIHNfY29uZmlnOiBpZiBzZXQsIHRoZW4gaXQgaXMgYWx3YXlzIGNhbGxlZCBieSB0aGUgdjRsMl9pMmNfbmV3X3N1YmRldioKLQlmdW5jdGlvbnMgYWZ0ZXIgdGhlIHY0bDJfc3ViZGV2IHdhcyByZWdpc3RlcmVkLiBJdCBpcyB1c2VkIHRvIHBhc3MKLQlwbGF0Zm9ybSBkYXRhIHRvIHRoZSBzdWJkZXYgd2hpY2ggY2FuIGJlIHVzZWQgZHVyaW5nIGluaXRpYWxpemF0aW9uLgotCisvKgogICAgc19pb19waW5fY29uZmlnOiBjb25maWd1cmUgb25lIG9yIG1vcmUgY2hpcCBJL08gcGlucyBmb3IgY2hpcHMgdGhhdAogCW11bHRpcGxleCBkaWZmZXJlbnQgaW50ZXJuYWwgc2lnbmFsIHBhZHMgb3V0IHRvIElPIHBpbnMuICBUaGlzIGZ1bmN0aW9uCiAJdGFrZXMgYSBwb2ludGVyIHRvIGFuIGFycmF5IG9mICduJyBwaW4gY29uZmlndXJhdGlvbiBlbnRyaWVzLCBvbmUgZm9yCkBAIC0xNDEsNyArMTM4LDYgQEAKIHN0cnVjdCB2NGwyX3N1YmRldl9jb3JlX29wcyB7CiAJaW50ICgqZ19jaGlwX2lkZW50KShzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkLCBzdHJ1Y3QgdjRsMl9kYmdfY2hpcF9pZGVudCAqY2hpcCk7CiAJaW50ICgqbG9nX3N0YXR1cykoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCk7Ci0JaW50ICgqc19jb25maWcpKHN0cnVjdCB2NGwyX3N1YmRldiAqc2QsIGludCBpcnEsIHZvaWQgKnBsYXRmb3JtX2RhdGEpOwogCWludCAoKnNfaW9fcGluX2NvbmZpZykoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCwgc2l6ZV90IG4sCiAJCQkJICAgICAgc3RydWN0IHY0bDJfc3ViZGV2X2lvX3Bpbl9jb25maWcgKnBpbmNmZyk7CiAJaW50ICgqaW5pdCkoc3RydWN0IHY0bDJfc3ViZGV2ICpzZCwgdTMyIHZhbCk7CkBAIC00MTUsNiArNDExLDIxIEBACiAJY29uc3Qgc3RydWN0IHY0bDJfc3ViZGV2X3NlbnNvcl9vcHMJKnNlbnNvcjsKIH07CiAKKy8qCisgKiBJbnRlcm5hbCBvcHMuIE5ldmVyIGNhbGwgdGhpcyBmcm9tIGRyaXZlcnMsIG9ubHkgdGhlIHY0bDIgZnJhbWV3b3JrIGNhbiBjYWxsCisgKiB0aGVzZSBvcHMuCisgKgorICogcmVnaXN0ZXJlZDogY2FsbGVkIHdoZW4gdGhpcyBzdWJkZXYgaXMgcmVnaXN0ZXJlZC4gV2hlbiBjYWxsZWQgdGhlIHY0bDJfZGV2CisgKglmaWVsZCBpcyBzZXQgdG8gdGhlIGNvcnJlY3QgdjRsMl9kZXZpY2UuCisgKgorICogdW5yZWdpc3RlcmVkOiBjYWxsZWQgd2hlbiB0aGlzIHN1YmRldiBpcyB1bnJlZ2lzdGVyZWQuIFdoZW4gY2FsbGVkIHRoZQorICoJdjRsMl9kZXYgZmllbGQgaXMgc3RpbGwgc2V0IHRvIHRoZSBjb3JyZWN0IHY0bDJfZGV2aWNlLgorICovCitzdHJ1Y3QgdjRsMl9zdWJkZXZfaW50ZXJuYWxfb3BzIHsKKwlpbnQgKCpyZWdpc3RlcmVkKShzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkKTsKKwl2b2lkICgqdW5yZWdpc3RlcmVkKShzdHJ1Y3QgdjRsMl9zdWJkZXYgKnNkKTsKK307CisKICNkZWZpbmUgVjRMMl9TVUJERVZfTkFNRV9TSVpFIDMyCiAKIC8qIFNldCB0aGlzIGZsYWcgaWYgdGhpcyBzdWJkZXYgaXMgYSBpMmMgZGV2aWNlLiAqLwpAQCAtNDMxLDYgKzQ0Miw4IEBACiAJdTMyIGZsYWdzOwogCXN0cnVjdCB2NGwyX2RldmljZSAqdjRsMl9kZXY7CiAJY29uc3Qgc3RydWN0IHY0bDJfc3ViZGV2X29wcyAqb3BzOworCS8qIE5ldmVyIGNhbGwgdGhlc2UgaW50ZXJuYWwgb3BzIGZyb20gd2l0aGluIGEgZHJpdmVyISAqLworCWNvbnN0IHN0cnVjdCB2NGwyX3N1YmRldl9pbnRlcm5hbF9vcHMgKmludGVybmFsX29wczsKIAkvKiBUaGUgY29udHJvbCBoYW5kbGVyIG9mIHRoaXMgc3ViZGV2LiBNYXkgYmUgTlVMTC4gKi8KIAlzdHJ1Y3QgdjRsMl9jdHJsX2hhbmRsZXIgKmN0cmxfaGFuZGxlcjsKIAkvKiBuYW1lIG11c3QgYmUgdW5pcXVlICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9haC5oIGIvaW5jbHVkZS9uZXQvYWguaAppbmRleCBiZTc3OThkLi5jYTk1Yjk4IDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9haC5oCisrKyBiL2luY2x1ZGUvbmV0L2FoLmgKQEAgLTQsNyArNCw3IEBACiAjaW5jbHVkZSA8bGludXgvc2tidWZmLmg+CiAKIC8qIFRoaXMgaXMgdGhlIG1heGltdW0gdHJ1bmNhdGVkIElDViBsZW5ndGggdGhhdCB3ZSBrbm93IG9mLiAqLwotI2RlZmluZSBNQVhfQUhfQVVUSF9MRU4JMTYKKyNkZWZpbmUgTUFYX0FIX0FVVEhfTEVOCTY0CiAKIHN0cnVjdCBjcnlwdG9fYWhhc2g7CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L2JsdWV0b290aC9oY2lfY29yZS5oIGIvaW5jbHVkZS9uZXQvYmx1ZXRvb3RoL2hjaV9jb3JlLmgKaW5kZXggYTI5ZmViMC4uZDJjZjg4NCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9uZXQvYmx1ZXRvb3RoL2hjaV9jb3JlLmgKKysrIGIvaW5jbHVkZS9uZXQvYmx1ZXRvb3RoL2hjaV9jb3JlLmgKQEAgLTE4NCw2ICsxODQsNyBAQAogCV9fdTMyCQkgbGlua19tb2RlOwogCV9fdTggICAgICAgICAgICAgYXV0aF90eXBlOwogCV9fdTggICAgICAgICAgICAgc2VjX2xldmVsOworCV9fdTgJCSBwZW5kaW5nX3NlY19sZXZlbDsKIAlfX3U4ICAgICAgICAgICAgIHBvd2VyX3NhdmU7CiAJX191MTYgICAgICAgICAgICBkaXNjX3RpbWVvdXQ7CiAJdW5zaWduZWQgbG9uZwkgcGVuZDsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L2NmZzgwMjExLmggYi9pbmNsdWRlL25ldC9jZmc4MDIxMS5oCmluZGV4IGJjYzlmNDQuLjEzMjI2OTUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L2NmZzgwMjExLmgKKysrIGIvaW5jbHVkZS9uZXQvY2ZnODAyMTEuaApAQCAtMTEwMyw2ICsxMTAzLDggQEAKICAqIEBjaGFuZ2VfbXBhdGg6IGNoYW5nZSBhIGdpdmVuIG1lc2ggcGF0aAogICogQGdldF9tcGF0aDogZ2V0IGEgbWVzaCBwYXRoIGZvciB0aGUgZ2l2ZW4gcGFyYW1ldGVycwogICogQGR1bXBfbXBhdGg6IGR1bXAgbWVzaCBwYXRoIGNhbGxiYWNrIC0tIHJlc3VtZSBkdW1wIGF0IGluZGV4IEBpZHgKKyAqIEBqb2luX21lc2g6IGpvaW4gdGhlIG1lc2ggbmV0d29yayB3aXRoIHRoZSBzcGVjaWZpZWQgcGFyYW1ldGVycworICogQGxlYXZlX21lc2g6IGxlYXZlIHRoZSBjdXJyZW50IG1lc2ggbmV0d29yawogICoKICAqIEBnZXRfbWVzaF9jb25maWc6IEdldCB0aGUgY3VycmVudCBtZXNoIGNvbmZpZ3VyYXRpb24KICAqCmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9nZW5ldGxpbmsuaCBiL2luY2x1ZGUvbmV0L2dlbmV0bGluay5oCmluZGV4IDhhNjRiODEuLmI0YzdjMWMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L2dlbmV0bGluay5oCisrKyBiL2luY2x1ZGUvbmV0L2dlbmV0bGluay5oCkBAIC0xOTUsNyArMTk1LDggQEAKICAqLwogc3RhdGljIGlubGluZSB2b2lkIGdlbmxtc2dfY2FuY2VsKHN0cnVjdCBza19idWZmICpza2IsIHZvaWQgKmhkcikKIHsKLQlubG1zZ19jYW5jZWwoc2tiLCBoZHIgLSBHRU5MX0hEUkxFTiAtIE5MTVNHX0hEUkxFTik7CisJaWYgKGhkcikKKwkJbmxtc2dfY2FuY2VsKHNrYiwgaGRyIC0gR0VOTF9IRFJMRU4gLSBOTE1TR19IRFJMRU4pOwogfQogCiAvKioKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L21hYzgwMjExLmggYi9pbmNsdWRlL25ldC9tYWM4MDIxMS5oCmluZGV4IDViM2ZkNWEuLjYyYzBjZTIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L21hYzgwMjExLmgKKysrIGIvaW5jbHVkZS9uZXQvbWFjODAyMTEuaApAQCAtMzM3LDYgKzMzNywxMCBAQAogICogQElFRUU4MDIxMV9UWF9DVExfTERQQzogdGVsbHMgdGhlIGRyaXZlciB0byB1c2UgTERQQyBmb3IgdGhpcyBmcmFtZQogICogQElFRUU4MDIxMV9UWF9DVExfU1RCQzogRW5hYmxlcyBTcGFjZS1UaW1lIEJsb2NrIENvZGluZyAoU1RCQykgZm9yIHRoaXMKICAqCWZyYW1lIGFuZCBzZWxlY3RzIHRoZSBtYXhpbXVtIG51bWJlciBvZiBzdHJlYW1zIHRoYXQgaXQgY2FuIHVzZS4KKyAqIEBJRUVFODAyMTFfVFhfQ1RMX1RYX09GRkNIQU46IE1hcmtzIHRoaXMgcGFja2V0IHRvIGJlIHRyYW5zbWl0dGVkIG9uCisgKgl0aGUgb2ZmLWNoYW5uZWwgY2hhbm5lbCB3aGVuIGEgcmVtYWluLW9uLWNoYW5uZWwgb2ZmbG9hZCBpcyBkb25lCisgKglpbiBoYXJkd2FyZSAtLSBub3JtYWwgcGFja2V0cyBzdGlsbCBmbG93IGFuZCBhcmUgZXhwZWN0ZWQgdG8gYmUKKyAqCWhhbmRsZWQgcHJvcGVybHkgYnkgdGhlIGRldmljZS4KICAqCiAgKiBOb3RlOiBJZiB5b3UgaGF2ZSB0byBhZGQgbmV3IGZsYWdzIHRvIHRoZSBlbnVtZXJhdGlvbiwgdGhlbiBkb24ndAogICoJIGZvcmdldCB0byB1cGRhdGUgJUlFRUU4MDIxMV9UWF9URU1QT1JBUllfRkxBR1Mgd2hlbiBuZWNlc3NhcnkuCkBAIC0xNzUzLDYgKzE3NTcsMTYgQEAKICAqCShhbHNvIHNlZSBubDgwMjExLmggQE5MODAyMTFfQVRUUl9XSVBIWV9BTlRFTk5BX1RYKS4KICAqCiAgKiBAZ2V0X2FudGVubmE6IEdldCBjdXJyZW50IGFudGVubmEgY29uZmlndXJhdGlvbiBmcm9tIGRldmljZSAodHhfYW50LCByeF9hbnQpLgorICoKKyAqIEByZW1haW5fb25fY2hhbm5lbDogU3RhcnRzIGFuIG9mZi1jaGFubmVsIHBlcmlvZCBvbiB0aGUgZ2l2ZW4gY2hhbm5lbCwgbXVzdAorICoJY2FsbCBiYWNrIHRvIGllZWU4MDIxMV9yZWFkeV9vbl9jaGFubmVsKCkgd2hlbiBvbiB0aGF0IGNoYW5uZWwuIE5vdGUKKyAqCXRoYXQgbm9ybWFsIGNoYW5uZWwgdHJhZmZpYyBpcyBub3Qgc3RvcHBlZCBhcyB0aGlzIGlzIGludGVuZGVkIGZvciBodworICoJb2ZmbG9hZC4gRnJhbWVzIHRvIHRyYW5zbWl0IG9uIHRoZSBvZmYtY2hhbm5lbCBjaGFubmVsIGFyZSB0cmFuc21pdHRlZAorICoJbm9ybWFsbHkgZXhjZXB0IGZvciB0aGUgJUlFRUU4MDIxMV9UWF9DVExfVFhfT0ZGQ0hBTiBmbGFnLiBXaGVuIHRoZQorICoJZHVyYXRpb24gKHdoaWNoIHdpbGwgYWx3YXlzIGJlIG5vbi16ZXJvKSBleHBpcmVzLCB0aGUgZHJpdmVyIG11c3QgY2FsbAorICoJaWVlZTgwMjExX3JlbWFpbl9vbl9jaGFubmVsX2V4cGlyZWQoKS4gVGhpcyBjYWxsYmFjayBtYXkgc2xlZXAuCisgKiBAY2FuY2VsX3JlbWFpbl9vbl9jaGFubmVsOiBSZXF1ZXN0cyB0aGF0IGFuIG9uZ29pbmcgb2ZmLWNoYW5uZWwgcGVyaW9kIGlzCisgKglhYm9ydGVkIGJlZm9yZSBpdCBleHBpcmVzLiBUaGlzIGNhbGxiYWNrIG1heSBzbGVlcC4KICAqLwogc3RydWN0IGllZWU4MDIxMV9vcHMgewogCWludCAoKnR4KShzdHJ1Y3QgaWVlZTgwMjExX2h3ICpodywgc3RydWN0IHNrX2J1ZmYgKnNrYik7CmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9uZXRmaWx0ZXIvaXB2Ni9uZl9jb25udHJhY2tfaXB2Ni5oIGIvaW5jbHVkZS9uZXQvbmV0ZmlsdGVyL2lwdjYvbmZfY29ubnRyYWNrX2lwdjYuaAppbmRleCAxZWU3MTdlLi5hNGM5OTM2IDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9uZXRmaWx0ZXIvaXB2Ni9uZl9jb25udHJhY2tfaXB2Ni5oCisrKyBiL2luY2x1ZGUvbmV0L25ldGZpbHRlci9pcHY2L25mX2Nvbm50cmFja19pcHY2LmgKQEAgLTcsMTYgKzcsNiBAQAogZXh0ZXJuIHN0cnVjdCBuZl9jb25udHJhY2tfbDRwcm90byBuZl9jb25udHJhY2tfbDRwcm90b191ZHA2OwogZXh0ZXJuIHN0cnVjdCBuZl9jb25udHJhY2tfbDRwcm90byBuZl9jb25udHJhY2tfbDRwcm90b19pY21wdjY7CiAKLWV4dGVybiBpbnQgbmZfY3RfZnJhZzZfaW5pdCh2b2lkKTsKLWV4dGVybiB2b2lkIG5mX2N0X2ZyYWc2X2NsZWFudXAodm9pZCk7Ci1leHRlcm4gc3RydWN0IHNrX2J1ZmYgKm5mX2N0X2ZyYWc2X2dhdGhlcihzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCB1MzIgdXNlcik7Ci1leHRlcm4gdm9pZCBuZl9jdF9mcmFnNl9vdXRwdXQodW5zaWduZWQgaW50IGhvb2tudW0sIHN0cnVjdCBza19idWZmICpza2IsCi0JCQkgICAgICAgc3RydWN0IG5ldF9kZXZpY2UgKmluLAotCQkJICAgICAgIHN0cnVjdCBuZXRfZGV2aWNlICpvdXQsCi0JCQkgICAgICAgaW50ICgqb2tmbikoc3RydWN0IHNrX2J1ZmYgKikpOwotCi1zdHJ1Y3QgaW5ldF9mcmFnc19jdGw7Ci0KICNpbmNsdWRlIDxsaW51eC9zeXNjdGwuaD4KIGV4dGVybiBzdHJ1Y3QgY3RsX3RhYmxlIG5mX2N0X2lwdjZfc3lzY3RsX3RhYmxlW107CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L25ldGZpbHRlci9pcHY2L25mX2RlZnJhZ19pcHY2LmggYi9pbmNsdWRlL25ldC9uZXRmaWx0ZXIvaXB2Ni9uZl9kZWZyYWdfaXB2Ni5oCmluZGV4IDk0ZGQ1NGQuLmZkNzljOWEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L25ldGZpbHRlci9pcHY2L25mX2RlZnJhZ19pcHY2LmgKKysrIGIvaW5jbHVkZS9uZXQvbmV0ZmlsdGVyL2lwdjYvbmZfZGVmcmFnX2lwdjYuaApAQCAtMyw0ICszLDE0IEBACiAKIGV4dGVybiB2b2lkIG5mX2RlZnJhZ19pcHY2X2VuYWJsZSh2b2lkKTsKIAorZXh0ZXJuIGludCBuZl9jdF9mcmFnNl9pbml0KHZvaWQpOworZXh0ZXJuIHZvaWQgbmZfY3RfZnJhZzZfY2xlYW51cCh2b2lkKTsKK2V4dGVybiBzdHJ1Y3Qgc2tfYnVmZiAqbmZfY3RfZnJhZzZfZ2F0aGVyKHN0cnVjdCBza19idWZmICpza2IsIHUzMiB1c2VyKTsKK2V4dGVybiB2b2lkIG5mX2N0X2ZyYWc2X291dHB1dCh1bnNpZ25lZCBpbnQgaG9va251bSwgc3RydWN0IHNrX2J1ZmYgKnNrYiwKKwkJCSAgICAgICBzdHJ1Y3QgbmV0X2RldmljZSAqaW4sCisJCQkgICAgICAgc3RydWN0IG5ldF9kZXZpY2UgKm91dCwKKwkJCSAgICAgICBpbnQgKCpva2ZuKShzdHJ1Y3Qgc2tfYnVmZiAqKSk7CisKK3N0cnVjdCBpbmV0X2ZyYWdzX2N0bDsKKwogI2VuZGlmIC8qIF9ORl9ERUZSQUdfSVBWNl9IICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX2VjYWNoZS5oIGIvaW5jbHVkZS9uZXQvbmV0ZmlsdGVyL25mX2Nvbm50cmFja19lY2FjaGUuaAppbmRleCA5NmJhNWY3Li4zNDljZWZlIDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX2VjYWNoZS5oCisrKyBiL2luY2x1ZGUvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfZWNhY2hlLmgKQEAgLTc3LDkgKzc3LDYgQEAKIAlpZiAoZSA9PSBOVUxMKQogCQlyZXR1cm47CiAKLQlpZiAoIShlLT5jdG1hc2sgJiAoMSA8PCBldmVudCkpKQotCQlyZXR1cm47Ci0KIAlzZXRfYml0KGV2ZW50LCAmZS0+Y2FjaGUpOwogfQogCmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9yZWQuaCBiL2luY2x1ZGUvbmV0L3JlZC5oCmluZGV4IDk5NTEwOGUuLjMzMTlmMTYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L3JlZC5oCisrKyBiL2luY2x1ZGUvbmV0L3JlZC5oCkBAIC05Nyw3ICs5Nyw2IEBACiAJdTMyCQlmb3JjZWRfbWFyazsJLyogRm9yY2VkIG1hcmtzLCBxYXZnID4gbWF4X3RocmVzaCAqLwogCXUzMgkJcGRyb3A7ICAgICAgICAgIC8qIERyb3BzIGR1ZSB0byBxdWV1ZSBsaW1pdHMgKi8KIAl1MzIJCW90aGVyOyAgICAgICAgICAvKiBEcm9wcyBkdWUgdG8gZHJvcCgpIGNhbGxzICovCi0JdTMyCQliYWNrbG9nOwogfTsKIAogc3RydWN0IHJlZF9wYXJtcyB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9zY2hfZ2VuZXJpYy5oIGIvaW5jbHVkZS9uZXQvc2NoX2dlbmVyaWMuaAppbmRleCBlOWVlZTk5Li4xNjBhNDA3IDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9zY2hfZ2VuZXJpYy5oCisrKyBiL2luY2x1ZGUvbmV0L3NjaF9nZW5lcmljLmgKQEAgLTQ0NSw3ICs0NDUsNiBAQAogewogCV9fc2tiX3F1ZXVlX3RhaWwobGlzdCwgc2tiKTsKIAlzY2gtPnFzdGF0cy5iYWNrbG9nICs9IHFkaXNjX3BrdF9sZW4oc2tiKTsKLQlxZGlzY19ic3RhdHNfdXBkYXRlKHNjaCwgc2tiKTsKIAogCXJldHVybiBORVRfWE1JVF9TVUNDRVNTOwogfQpAQCAtNDYwLDggKzQ1OSwxMCBAQAogewogCXN0cnVjdCBza19idWZmICpza2IgPSBfX3NrYl9kZXF1ZXVlKGxpc3QpOwogCi0JaWYgKGxpa2VseShza2IgIT0gTlVMTCkpCisJaWYgKGxpa2VseShza2IgIT0gTlVMTCkpIHsKIAkJc2NoLT5xc3RhdHMuYmFja2xvZyAtPSBxZGlzY19wa3RfbGVuKHNrYik7CisJCXFkaXNjX2JzdGF0c191cGRhdGUoc2NoLCBza2IpOworCX0KIAogCXJldHVybiBza2I7CiB9CkBAIC00NzQsMTAgKzQ3NSwxMSBAQAogc3RhdGljIGlubGluZSB1bnNpZ25lZCBpbnQgX19xZGlzY19xdWV1ZV9kcm9wX2hlYWQoc3RydWN0IFFkaXNjICpzY2gsCiAJCQkJCSAgICAgIHN0cnVjdCBza19idWZmX2hlYWQgKmxpc3QpCiB7Ci0Jc3RydWN0IHNrX2J1ZmYgKnNrYiA9IF9fcWRpc2NfZGVxdWV1ZV9oZWFkKHNjaCwgbGlzdCk7CisJc3RydWN0IHNrX2J1ZmYgKnNrYiA9IF9fc2tiX2RlcXVldWUobGlzdCk7CiAKIAlpZiAobGlrZWx5KHNrYiAhPSBOVUxMKSkgewogCQl1bnNpZ25lZCBpbnQgbGVuID0gcWRpc2NfcGt0X2xlbihza2IpOworCQlzY2gtPnFzdGF0cy5iYWNrbG9nIC09IGxlbjsKIAkJa2ZyZWVfc2tiKHNrYik7CiAJCXJldHVybiBsZW47CiAJfQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvc2N0cC91c2VyLmggYi9pbmNsdWRlL25ldC9zY3RwL3VzZXIuaAppbmRleCAyYTEyOGM4Li5lNzNlYmRhIDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9zY3RwL3VzZXIuaAorKysgYi9pbmNsdWRlL25ldC9zY3RwL3VzZXIuaApAQCAtNzgsNiArNzgsNyBAQAogI2RlZmluZSBTQ1RQX0dFVF9QRUVSX0FERFJfSU5GTwkxNQogI2RlZmluZSBTQ1RQX0RFTEFZRURfQUNLX1RJTUUJMTYKICNkZWZpbmUgU0NUUF9ERUxBWUVEX0FDSyBTQ1RQX0RFTEFZRURfQUNLX1RJTUUKKyNkZWZpbmUgU0NUUF9ERUxBWUVEX1NBQ0sgU0NUUF9ERUxBWUVEX0FDS19USU1FCiAjZGVmaW5lIFNDVFBfQ09OVEVYVAkxNwogI2RlZmluZSBTQ1RQX0ZSQUdNRU5UX0lOVEVSTEVBVkUJMTgKICNkZWZpbmUgU0NUUF9QQVJUSUFMX0RFTElWRVJZX1BPSU5UCTE5IC8qIFNldC9HZXQgcGFydGlhbCBkZWxpdmVyeSBwb2ludCAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvc29jay5oIGIvaW5jbHVkZS9uZXQvc29jay5oCmluZGV4IGQ4ODRkMjYuLmJjMWNmN2Q4IDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9zb2NrLmgKKysrIGIvaW5jbHVkZS9uZXQvc29jay5oCkBAIC03NTMsNiArNzUzLDggQEAKIAkJCQkJaW50IGxldmVsLAogCQkJCQlpbnQgb3B0bmFtZSwgY2hhciBfX3VzZXIgKm9wdHZhbCwKIAkJCQkJaW50IF9fdXNlciAqb3B0aW9uKTsKKwlpbnQJCQkoKmNvbXBhdF9pb2N0bCkoc3RydWN0IHNvY2sgKnNrLAorCQkJCQl1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZyk7CiAjZW5kaWYKIAlpbnQJCQkoKnNlbmRtc2cpKHN0cnVjdCBraW9jYiAqaW9jYiwgc3RydWN0IHNvY2sgKnNrLAogCQkJCQkgICBzdHJ1Y3QgbXNnaGRyICptc2csIHNpemVfdCBsZW4pOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9yZG1hL2liX3ZlcmJzLmggYi9pbmNsdWRlL3JkbWEvaWJfdmVyYnMuaAppbmRleCBlMDRjNDg4Li41NWNkMGEwIDEwMDY0NAotLS0gYS9pbmNsdWRlL3JkbWEvaWJfdmVyYnMuaAorKysgYi9pbmNsdWRlL3JkbWEvaWJfdmVyYnMuaApAQCAtNDcsMTAgKzQ3LDEzIEBACiAjaW5jbHVkZSA8bGludXgvbGlzdC5oPgogI2luY2x1ZGUgPGxpbnV4L3J3c2VtLmg+CiAjaW5jbHVkZSA8bGludXgvc2NhdHRlcmxpc3QuaD4KKyNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KIAogI2luY2x1ZGUgPGFzbS9hdG9taWMuaD4KICNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgogCitleHRlcm4gc3RydWN0IHdvcmtxdWV1ZV9zdHJ1Y3QgKmliX3dxOworCiB1bmlvbiBpYl9naWQgewogCXU4CXJhd1sxNl07CiAJc3RydWN0IHsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvc2NzaS9zY3NpLmggYi9pbmNsdWRlL3Njc2kvc2NzaS5oCmluZGV4IDY0OGQyMzMuLmI3NmQ0MDAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvc2NzaS9zY3NpLmgKKysrIGIvaW5jbHVkZS9zY3NpL3Njc2kuaApAQCAtOSw2ICs5LDcgQEAKICNkZWZpbmUgX1NDU0lfU0NTSV9ICiAKICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorI2luY2x1ZGUgPGxpbnV4L3NjYXR0ZXJsaXN0Lmg+CiAKIHN0cnVjdCBzY3NpX2NtbmQ7CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvc291bmQvYWM5N19jb2RlYy5oIGIvaW5jbHVkZS9zb3VuZC9hYzk3X2NvZGVjLmgKaW5kZXggNDk0MDA0NS4uYjYwMmY0NyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9zb3VuZC9hYzk3X2NvZGVjLmgKKysrIGIvaW5jbHVkZS9zb3VuZC9hYzk3X2NvZGVjLmgKQEAgLTQ3Nyw3ICs0NzcsNyBAQAogCiBzdHJ1Y3Qgc25kX2FjOTcgewogCS8qIC0tIGxvd2xldmVsIChoYXJkd2FyZSkgZHJpdmVyIHNwZWNpZmljIC0tICovCi0Jc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyAqIGJ1aWxkX29wczsKKwljb25zdCBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzICpidWlsZF9vcHM7CiAJdm9pZCAqcHJpdmF0ZV9kYXRhOwogCXZvaWQgKCpwcml2YXRlX2ZyZWUpIChzdHJ1Y3Qgc25kX2FjOTcgKmFjOTcpOwogCS8qIC0tLSAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS90YXJnZXQvY29uZmlnZnNfbWFjcm9zLmggYi9pbmNsdWRlL3RhcmdldC9jb25maWdmc19tYWNyb3MuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43ZmU3NDYwCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS90YXJnZXQvY29uZmlnZnNfbWFjcm9zLmgKQEAgLTAsMCArMSwxNDcgQEAKKy8qIC0qLSBtb2RlOiBjOyBjLWJhc2ljLW9mZnNldDogODsgLSotCisgKiB2aW06IG5vZXhwYW5kdGFiIHN3PTggdHM9OCBzdHM9MDoKKyAqCisgKiBjb25maWdmc19tYWNyb3MuaCAtIGV4dGVuZHMgbWFjcm9zIGZvciBjb25maWdmcworICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlCisgKiBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwKKyAqIEJvc3RvbiwgTUEgMDIxMTEwLTEzMDcsIFVTQS4KKyAqCisgKiBCYXNlZCBvbiBzeXNmczoKKyAqIAlzeXNmcyBpcyBDb3B5cmlnaHQgKEMpIDIwMDEsIDIwMDIsIDIwMDMgUGF0cmljayBNb2NoZWwKKyAqCisgKiBCYXNlZCBvbiBrb2JqZWN0Lmg6CisgKiAgICAgIENvcHlyaWdodCAoYykgMjAwMi0yMDAzCVBhdHJpY2sgTW9jaGVsCisgKiAgICAgIENvcHlyaWdodCAoYykgMjAwMi0yMDAzCU9wZW4gU291cmNlIERldmVsb3BtZW50IExhYnMKKyAqCisgKiBjb25maWdmcyBDb3B5cmlnaHQgKEMpIDIwMDUgT3JhY2xlLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBBZGRlZCBDT05GSUdGU19FQVRUUigpIG1hY3JvcyBmcm9tIG9yaWdpbmFsIGNvbmZpZ2ZzLmggbWFjcm9zCisgKiBDb3ByaWdodCAoQykgMjAwOC0yMDA5IE5pY2hvbGFzIEEuIEJlbGxpbmdlciA8bmFiQGxpbnV4LWlzY3NpLm9yZz4KKyAqCisgKiBQbGVhc2UgcmVhZCBEb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2NvbmZpZ2ZzLnR4dCBiZWZvcmUgdXNpbmcgdGhlCisgKiBjb25maWdmcyBpbnRlcmZhY2UsIEVTUEVDSUFMTFkgdGhlIHBhcnRzIGFib3V0IHJlZmVyZW5jZSBjb3VudHMgYW5kCisgKiBpdGVtIGRlc3RydWN0b3JzLgorICovCisKKyNpZm5kZWYgX0NPTkZJR0ZTX01BQ1JPU19IXworI2RlZmluZSBfQ09ORklHRlNfTUFDUk9TX0hfCisKKyNpbmNsdWRlIDxsaW51eC9jb25maWdmcy5oPgorCisvKgorICogVXNlcnMgb2Z0ZW4gbmVlZCB0byBjcmVhdGUgYXR0cmlidXRlIHN0cnVjdHVyZXMgZm9yIHRoZWlyIGNvbmZpZ3VyYWJsZQorICogYXR0cmlidXRlcywgY29udGFpbmluZyBhIGNvbmZpZ2ZzX2F0dHJpYnV0ZSBtZW1iZXIgYW5kIGZ1bmN0aW9uIHBvaW50ZXJzCisgKiBmb3IgdGhlIHNob3coKSBhbmQgc3RvcmUoKSBvcGVyYXRpb25zIG9uIHRoYXQgYXR0cmlidXRlLiBJZiB0aGV5IGRvbid0CisgKiBuZWVkIGFueXRoaW5nIGVsc2Ugb24gdGhlIGV4dGVuZGVkIGF0dHJpYnV0ZSBzdHJ1Y3R1cmUsIHRoZXkgY2FuIHVzZQorICogdGhpcyBtYWNybyB0byBkZWZpbmUgaXQuICBUaGUgYXJndW1lbnQgX25hbWUgaXNlbmRzIHVwIGFzCisgKiAnc3RydWN0IF9uYW1lX2F0dHJpYnV0ZSwgYXMgd2VsbCBhcyBuYW1lcyBvZiB0byBDT05GSUdGU19BVFRSX09QUygpIGJlbG93LgorICogVGhlIGFyZ3VtZW50IF9pdGVtIGlzIHRoZSBuYW1lIG9mIHRoZSBzdHJ1Y3R1cmUgY29udGFpbmluZyB0aGUKKyAqIHN0cnVjdCBjb25maWdfaXRlbSBvciBzdHJ1Y3QgY29uZmlnX2dyb3VwIHN0cnVjdHVyZSBtZW1iZXJzCisgKi8KKyNkZWZpbmUgQ09ORklHRlNfRUFUVFJfU1RSVUNUKF9uYW1lLCBfaXRlbSkJCQkJXAorc3RydWN0IF9uYW1lIyNfYXR0cmlidXRlIHsJCQkJCQlcCisJc3RydWN0IGNvbmZpZ2ZzX2F0dHJpYnV0ZSBhdHRyOwkJCQkJXAorCXNzaXplX3QgKCpzaG93KShzdHJ1Y3QgX2l0ZW0gKiwgY2hhciAqKTsJCQlcCisJc3NpemVfdCAoKnN0b3JlKShzdHJ1Y3QgX2l0ZW0gKiwgY29uc3QgY2hhciAqLCBzaXplX3QpOwkJXAorfQorCisvKgorICogV2l0aCB0aGUgZXh0ZW5kZWQgYXR0cmlidXRlIHN0cnVjdHVyZSwgdXNlcnMgY2FuIHVzZSB0aGlzIG1hY3JvCisgKiAoc2ltaWxhciB0byBzeXNmcycgX19BVFRSKSB0byBtYWtlIGRlZmluaW5nIGF0dHJpYnV0ZXMgZWFzaWVyLgorICogQW4gZXhhbXBsZToKKyAqICNkZWZpbmUgTVlJVEVNX0VBVFRSKF9uYW1lLCBfbW9kZSwgX3Nob3csIF9zdG9yZSkJXAorICogc3RydWN0IG15aXRlbV9hdHRyaWJ1dGUgY2hpbGRsZXNzX2F0dHJfIyNfbmFtZSA9CVwKKyAqICAgICAgICAgX19DT05GSUdGU19FQVRUUihfbmFtZSwgX21vZGUsIF9zaG93LCBfc3RvcmUpCisgKi8KKyNkZWZpbmUgX19DT05GSUdGU19FQVRUUihfbmFtZSwgX21vZGUsIF9zaG93LCBfc3RvcmUpCQkJXAorewkJCQkJCQkJCVwKKwkuYXR0cgk9IHsJCQkJCQkJXAorCQkJLmNhX25hbWUgPSBfX3N0cmluZ2lmeShfbmFtZSksCQkJXAorCQkJLmNhX21vZGUgPSBfbW9kZSwJCQkJXAorCQkJLmNhX293bmVyID0gVEhJU19NT0RVTEUsCQkJXAorCX0sCQkJCQkJCQlcCisJLnNob3cJPSBfc2hvdywJCQkJCQlcCisJLnN0b3JlCT0gX3N0b3JlLAkJCQkJCVwKK30KKy8qIEhlcmUgaXMgYSByZWFkb25seSB2ZXJzaW9uLCBvbmx5IHJlcXVpcmluZyBhIHNob3coKSBvcGVyYXRpb24gKi8KKyNkZWZpbmUgX19DT05GSUdGU19FQVRUUl9STyhfbmFtZSwgX3Nob3cpCQkJCVwKK3sJCQkJCQkJCQlcCisJLmF0dHIJPSB7CQkJCQkJCVwKKwkJCS5jYV9uYW1lID0gX19zdHJpbmdpZnkoX25hbWUpLAkJCVwKKwkJCS5jYV9tb2RlID0gMDQ0NCwJCQkJXAorCQkJLmNhX293bmVyID0gVEhJU19NT0RVTEUsCQkJXAorCX0sCQkJCQkJCQlcCisJLnNob3cJPSBfc2hvdywJCQkJCQlcCit9CisKKy8qCisgKiBXaXRoIHRoZXNlIGV4dGVuZGVkIGF0dHJpYnV0ZXMsIHRoZSBzaW1wbGUgc2hvd19hdHRyaWJ1dGUoKSBhbmQKKyAqIHN0b3JlX2F0dHJpYnV0ZSgpIG9wZXJhdGlvbnMgbmVlZCB0byBjYWxsIHRoZSBzaG93KCkgYW5kIHN0b3JlKCkgb2YgdGhlCisgKiBhdHRyaWJ1dGVzLiAgVGhpcyBpcyBhIGNvbW1vbiBwYXR0ZXJuLCBzbyB3ZSBwcm92aWRlIGEgbWFjcm8gdG8gZGVmaW5lCisgKiB0aGVtLiAgVGhlIGFyZ3VtZW50IF9uYW1lIGlzIHRoZSBuYW1lIG9mIHRoZSBhdHRyaWJ1dGUgZGVmaW5lZCBieQorICogQ09ORklHRlNfQVRUUl9TVFJVQ1QoKS4gVGhlIGFyZ3VtZW50IF9pdGVtIGlzIHRoZSBuYW1lIG9mIHRoZSBzdHJ1Y3R1cmUKKyAqIGNvbnRhaW5pbmcgdGhlIHN0cnVjdCBjb25maWdfaXRlbSBvciBzdHJ1Y3QgY29uZmlnX2dyb3VwIHN0cnVjdHVyZSBtZW1iZXIuCisgKiBUaGUgYXJndW1lbnQgX2l0ZW1fbWVtYmVyIGlzIHRoZSBhY3R1YWwgbmFtZSBvZiB0aGUgc3RydWN0IGNvbmZpZ18qIHN0cnVjdAorICogaW4geW91ciBfaXRlbSBzdHJ1Y3R1cmUuICBNZWFuaW5nICBteV9zdHJ1Y3R1cmUtPnNvbWVfY29uZmlnX2dyb3VwLgorICoJCSAgICAgICAgICAgICAgICAgICAgICBeXl9pdGVtXl5eXl4gIF5eX2l0ZW1fbWVtYmVyXl5eCisgKiBUaGlzIG1hY3JvIGV4cGVjdHMgdGhlIGF0dHJpYnV0ZXMgdG8gYmUgbmFtZWQgInN0cnVjdCA8bmFtZT5fYXR0cmlidXRlIi4KKyAqLworI2RlZmluZSBDT05GSUdGU19FQVRUUl9PUFNfVE9fRlVOQyhfbmFtZSwgX2l0ZW0sIF9pdGVtX21lbWJlcikJCVwKK3N0YXRpYyBzdHJ1Y3QgX2l0ZW0gKnRvXyMjX25hbWUoc3RydWN0IGNvbmZpZ19pdGVtICpjaSkJCQlcCit7CQkJCQkJCQkJXAorCXJldHVybiAoY2kpID8gY29udGFpbmVyX29mKHRvX2NvbmZpZ19ncm91cChjaSksIHN0cnVjdCBfaXRlbSwJXAorCQlfaXRlbV9tZW1iZXIpIDogTlVMTDsJCQkJCVwKK30KKworI2RlZmluZSBDT05GSUdGU19FQVRUUl9PUFNfU0hPVyhfbmFtZSwgX2l0ZW0pCQkJCVwKK3N0YXRpYyBzc2l6ZV90IF9uYW1lIyNfYXR0cl9zaG93KHN0cnVjdCBjb25maWdfaXRlbSAqaXRlbSwJCVwKKwkJCQkgc3RydWN0IGNvbmZpZ2ZzX2F0dHJpYnV0ZSAqYXR0ciwJXAorCQkJCSBjaGFyICpwYWdlKQkJCQlcCit7CQkJCQkJCQkJXAorCXN0cnVjdCBfaXRlbSAqX2l0ZW0gPSB0b18jI19uYW1lKGl0ZW0pOwkJCQlcCisJc3RydWN0IF9uYW1lIyNfYXR0cmlidXRlICogX25hbWUjI19hdHRyID0JCQlcCisJCWNvbnRhaW5lcl9vZihhdHRyLCBzdHJ1Y3QgX25hbWUjI19hdHRyaWJ1dGUsIGF0dHIpOwlcCisJc3NpemVfdCByZXQgPSAwOwkJCQkJCVwKKwkJCQkJCQkJCVwKKwlpZiAoX25hbWUjI19hdHRyLT5zaG93KQkJCQkJCVwKKwkJcmV0ID0gX25hbWUjI19hdHRyLT5zaG93KF9pdGVtLCBwYWdlKTsJCQlcCisJcmV0dXJuIHJldDsJCQkJCQkJXAorfQorCisjZGVmaW5lIENPTkZJR0ZTX0VBVFRSX09QU19TVE9SRShfbmFtZSwgX2l0ZW0pCQkJCVwKK3N0YXRpYyBzc2l6ZV90IF9uYW1lIyNfYXR0cl9zdG9yZShzdHJ1Y3QgY29uZmlnX2l0ZW0gKml0ZW0sCQlcCisJCQkJICBzdHJ1Y3QgY29uZmlnZnNfYXR0cmlidXRlICphdHRyLAlcCisJCQkJICBjb25zdCBjaGFyICpwYWdlLCBzaXplX3QgY291bnQpCVwKK3sJCQkJCQkJCQlcCisJc3RydWN0IF9pdGVtICpfaXRlbSA9IHRvXyMjX25hbWUoaXRlbSk7CQkJCVwKKwlzdHJ1Y3QgX25hbWUjI19hdHRyaWJ1dGUgKiBfbmFtZSMjX2F0dHIgPQkJCVwKKwkJY29udGFpbmVyX29mKGF0dHIsIHN0cnVjdCBfbmFtZSMjX2F0dHJpYnV0ZSwgYXR0cik7CVwKKwlzc2l6ZV90IHJldCA9IC1FSU5WQUw7CQkJCQkJXAorCQkJCQkJCQkJXAorCWlmIChfbmFtZSMjX2F0dHItPnN0b3JlKQkJCQkJXAorCQlyZXQgPSBfbmFtZSMjX2F0dHItPnN0b3JlKF9pdGVtLCBwYWdlLCBjb3VudCk7CQlcCisJcmV0dXJuIHJldDsJCQkJCQkJXAorfQorCisjZGVmaW5lIENPTkZJR0ZTX0VBVFRSX09QUyhfbmFtZSwgX2l0ZW0sIF9pdGVtX21lbWJlcikJCQlcCisJQ09ORklHRlNfRUFUVFJfT1BTX1RPX0ZVTkMoX25hbWUsIF9pdGVtLCBfaXRlbV9tZW1iZXIpOwkJXAorCUNPTkZJR0ZTX0VBVFRSX09QU19TSE9XKF9uYW1lLCBfaXRlbSk7CQkJCVwKKwlDT05GSUdGU19FQVRUUl9PUFNfU1RPUkUoX25hbWUsIF9pdGVtKTsKKworI2RlZmluZSBDT05GSUdGU19FQVRUUl9PUFNfUk8oX25hbWUsIF9pdGVtLCBfaXRlbV9tZW1iZXIpCQlcCisJQ09ORklHRlNfRUFUVFJfT1BTX1RPX0ZVTkMoX25hbWUsIF9pdGVtLCBfaXRlbV9tZW1iZXIpOwkJXAorCUNPTkZJR0ZTX0VBVFRSX09QU19TSE9XKF9uYW1lLCBfaXRlbSk7CisKKyNlbmRpZiAvKiBfQ09ORklHRlNfTUFDUk9TX0hfICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL3RhcmdldC90YXJnZXRfY29yZV9iYXNlLmggYi9pbmNsdWRlL3RhcmdldC90YXJnZXRfY29yZV9iYXNlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMDdmZGZiNgotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX2Jhc2UuaApAQCAtMCwwICsxLDkzNyBAQAorI2lmbmRlZiBUQVJHRVRfQ09SRV9CQVNFX0gKKyNkZWZpbmUgVEFSR0VUX0NPUkVfQkFTRV9ICisKKyNpbmNsdWRlIDxsaW51eC9pbi5oPgorI2luY2x1ZGUgPGxpbnV4L2NvbmZpZ2ZzLmg+CisjaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KKyNpbmNsdWRlIDxsaW51eC9ibGtkZXYuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2lfY21uZC5oPgorI2luY2x1ZGUgPG5ldC9zb2NrLmg+CisjaW5jbHVkZSA8bmV0L3RjcC5oPgorI2luY2x1ZGUgInRhcmdldF9jb3JlX21pYi5oIgorCisjZGVmaW5lIFRBUkdFVF9DT1JFX01PRF9WRVJTSU9OCQkidjQuMC4wLXJjNiIKKyNkZWZpbmUgU0hVVERPV05fU0lHUwkoc2lnbWFzayhTSUdLSUxMKXxzaWdtYXNrKFNJR0lOVCl8c2lnbWFzayhTSUdBQlJUKSkKKworLyogVXNlZCBieSB0cmFuc3BvcnRfZ2VuZXJpY19hbGxvY2F0ZV9pb3ZlY3MoKSAqLworI2RlZmluZSBUUkFOU1BPUlRfSU9WX0RBVEFfQlVGRkVSCQk1CisvKiBNYXhpbXVtIE51bWJlciBvZiBMVU5zIHBlciBUYXJnZXQgUG9ydGFsIEdyb3VwICovCisjZGVmaW5lIFRSQU5TUE9SVF9NQVhfTFVOU19QRVJfVFBHCQkyNTYKKy8qCisgKiBCeSBkZWZhdWx0IHdlIHVzZSAzMi1ieXRlIENEQnMgaW4gVENNIENvcmUgYW5kIHN1YnN5c3RlbSBwbHVnaW4gY29kZS4KKyAqCisgKiBOb3RlIHRoYXQgYm90aCBpbmNsdWRlL3Njc2kvc2NzaV9jbW5kLmg6TUFYX0NPTU1BTkRfU0laRSBhbmQKKyAqIGluY2x1ZGUvbGludXgvYmxrZGV2Lmg6QkxPQ0tfTUFYX0NEQiBhcyBvZiB2Mi42LjM2LXJjNCBzdGlsbCB1c2UKKyAqIDE2LWJ5dGUgQ0RCcyBieSBkZWZhdWx0IGFuZCByZXF1aXJlIGFuIGV4dHJhIGFsbG9jYXRpb24gZm9yCisgKiAzMi1ieXRlIENEQnMgdG8gYmVjYXN1ZSBvZiBsZWdhY3kgaXNzdWVzLgorICoKKyAqIFdpdGhpbiBUQ00gQ29yZSB0aGVyZSBhcmUgbm8gc3VjaCBsZWdhY3kgbGltaXRpYXRpb25zLCBzbyB3ZSBnbyBhaGVhZAorICogdXNlIDMyLWJ5dGUgQ0RCcyBieSBkZWZhdWx0IGFuZCB1c2UgaW5jbHVkZS9zY3NpL3Njc2kuaDpzY3NpX2NvbW1hbmRfc2l6ZSgpCisgKiB3aXRoaW4gYWxsIFRDTSBDb3JlIGFuZCBzdWJzeXN0ZW0gcGx1Z2luIGNvZGUuCisgKi8KKyNkZWZpbmUgVENNX01BWF9DT01NQU5EX1NJWkUJCQkzMgorLyoKKyAqIEZyb20gaW5jbHVkZS9zY3NpL3Njc2lfY21uZC5oOlNDU0lfU0VOU0VfQlVGRkVSU0laRSwgY3VycmVudGx5CisgKiBkZWZpbmVkIDk2LCBidXQgdGhlIHJlYWwgbGltaXQgaXMgMjUyIChvciAyNjAgaW5jbHVkaW5nIHRoZSBoZWFkZXIpCisgKi8KKyNkZWZpbmUgVFJBTlNQT1JUX1NFTlNFX0JVRkZFUgkJCVNDU0lfU0VOU0VfQlVGRkVSU0laRQorLyogVXNlZCBieSB0cmFuc3BvcnRfc2VuZF9jaGVja19jb25kaXRpb25fYW5kX3NlbnNlKCkgKi8KKyNkZWZpbmUgU1BDX1NFTlNFX0tFWV9PRkZTRVQJCQkyCisjZGVmaW5lIFNQQ19BU0NfS0VZX09GRlNFVAkJCTEyCisjZGVmaW5lIFNQQ19BU0NRX0tFWV9PRkZTRVQJCQkxMworI2RlZmluZSBUUkFOU1BPUlRfSVFOX0xFTgkJCTIyNAorLyogVXNlZCBieSB0YXJnZXRfY29yZV9zdG9yZV9hbHVhX2x1X2dwKCkgYW5kIHRhcmdldF9jb3JlX2FsdWFfbHVfZ3Bfc2hvd19hdHRyX21lbWJlcnMoKSAqLworI2RlZmluZSBMVV9HUk9VUF9OQU1FX0JVRgkJCTI1NgorLyogVXNlZCBieSBjb3JlX2FsdWFfc3RvcmVfdGdfcHRfZ3BfaW5mbygpIGFuZCB0YXJnZXRfY29yZV9hbHVhX3RnX3B0X2dwX3Nob3dfYXR0cl9tZW1iZXJzKCkgKi8KKyNkZWZpbmUgVEdfUFRfR1JPVVBfTkFNRV9CVUYJCQkyNTYKKy8qIFVzZWQgdG8gcGFyc2UgVlBEIGludG8gc3RydWN0IHQxMF92cGQgKi8KKyNkZWZpbmUgVlBEX1RNUF9CVUZfU0laRQkJCTEyOAorLyogVXNlZCBieSB0cmFuc3BvcnRfZ2VuZXJpY19jbWRfc2VxdWVuY2VyKCkgKi8KKyNkZWZpbmUgUkVBRF9CTE9DS19MRU4gICAgICAgICAgCQk2CisjZGVmaW5lIFJFQURfQ0FQX0xFTiAgICAgICAgICAgIAkJOAorI2RlZmluZSBSRUFEX1BPU0lUSU9OX0xFTiAgICAgICAJCTIwCisjZGVmaW5lIElOUVVJUllfTEVOCQkJCTM2CisvKiBVc2VkIGJ5IHRyYW5zcG9ydF9nZXRfaW5xdWlyeV92cGRfc2VyaWFsKCkgKi8KKyNkZWZpbmUgSU5RVUlSWV9WUERfU0VSSUFMX0xFTgkJCTI1NAorLyogVXNlZCBieSB0cmFuc3BvcnRfZ2V0X2lucXVpcnlfdnBkX2RldmljZV9pZGVudCgpICovCisjZGVmaW5lIElOUVVJUllfVlBEX0RFVklDRV9JREVOVElGSUVSX0xFTgkyNTQKKworLyogc3RydWN0IHNlX2hiYS0+aGJhX2ZsYWdzICovCitlbnVtIGhiYV9mbGFnc190YWJsZSB7CisJSEJBX0ZMQUdTX0lOVEVSTkFMX1VTRQk9IDB4MDEsCisJSEJBX0ZMQUdTX1BTQ1NJX01PREUJPSAweDAyLAorfTsKKworLyogc3RydWN0IHNlX2x1bi0+bHVuX3N0YXR1cyAqLworZW51bSB0cmFuc3BvcnRfbHVuX3N0YXR1c190YWJsZSB7CisJVFJBTlNQT1JUX0xVTl9TVEFUVVNfRlJFRSA9IDAsCisJVFJBTlNQT1JUX0xVTl9TVEFUVVNfQUNUSVZFID0gMSwKK307CisKKy8qIHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAtPnNlX3RwZ190eXBlICovCitlbnVtIHRyYW5zcG9ydF90cGdfdHlwZV90YWJsZSB7CisJVFJBTlNQT1JUX1RQR19UWVBFX05PUk1BTCA9IDAsCisJVFJBTlNQT1JUX1RQR19UWVBFX0RJU0NPVkVSWSA9IDEsCit9OworCisvKiBVc2VkIGZvciBnZW5lcmF0ZSB0aW1lciBmbGFncyAqLworZW51bSB0aW1lcl9mbGFnc190YWJsZSB7CisJVEZfUlVOTklORwk9IDB4MDEsCisJVEZfU1RPUAkJPSAweDAyLAorfTsKKworLyogU3BlY2lhbCB0cmFuc3BvcnQgYWdub3N0aWMgc3RydWN0IHNlX2NtZC0+dF9zdGF0ZXMgKi8KK2VudW0gdHJhbnNwb3J0X3N0YXRlX3RhYmxlIHsKKwlUUkFOU1BPUlRfTk9fU1RBVEUJPSAwLAorCVRSQU5TUE9SVF9ORVdfQ01ECT0gMSwKKwlUUkFOU1BPUlRfREVGRVJSRURfQ01ECT0gMiwKKwlUUkFOU1BPUlRfV1JJVEVfUEVORElORwk9IDMsCisJVFJBTlNQT1JUX1BST0NFU1NfV1JJVEUJPSA0LAorCVRSQU5TUE9SVF9QUk9DRVNTSU5HCT0gNSwKKwlUUkFOU1BPUlRfQ09NUExFVEVfT0sJPSA2LAorCVRSQU5TUE9SVF9DT01QTEVURV9GQUlMVVJFID0gNywKKwlUUkFOU1BPUlRfQ09NUExFVEVfVElNRU9VVCA9IDgsCisJVFJBTlNQT1JUX1BST0NFU1NfVE1SCT0gOSwKKwlUUkFOU1BPUlRfVE1SX0NPTVBMRVRFCT0gMTAsCisJVFJBTlNQT1JUX0lTVEFURV9QUk9DRVNTSU5HID0gMTEsCisJVFJBTlNQT1JUX0lTVEFURV9QUk9DRVNTRUQgPSAxMiwKKwlUUkFOU1BPUlRfS0lMTAkJPSAxMywKKwlUUkFOU1BPUlRfUkVNT1ZFCT0gMTQsCisJVFJBTlNQT1JUX0ZSRUUJCT0gMTUsCisJVFJBTlNQT1JUX05FV19DTURfTUFQCT0gMTYsCit9OworCisvKiBVc2VkIGZvciBzdHJ1Y3Qgc2VfY21kLT5zZV9jbWRfZmxhZ3MgKi8KK2VudW0gc2VfY21kX2ZsYWdzX3RhYmxlIHsKKwlTQ0ZfU1VQUE9SVEVEX1NBTV9PUENPREUJPSAweDAwMDAwMDAxLAorCVNDRl9UUkFOU1BPUlRfVEFTS19TRU5TRQk9IDB4MDAwMDAwMDIsCisJU0NGX0VNVUxBVEVEX1RBU0tfU0VOU0UJCT0gMHgwMDAwMDAwNCwKKwlTQ0ZfU0NTSV9EQVRBX1NHX0lPX0NEQgkJPSAweDAwMDAwMDA4LAorCVNDRl9TQ1NJX0NPTlRST0xfU0dfSU9fQ0RCCT0gMHgwMDAwMDAxMCwKKwlTQ0ZfU0NTSV9DT05UUk9MX05PTlNHX0lPX0NEQgk9IDB4MDAwMDAwMjAsCisJU0NGX1NDU0lfTk9OX0RBVEFfQ0RCCQk9IDB4MDAwMDAwNDAsCisJU0NGX1NDU0lfQ0RCX0VYQ0VQVElPTgkJPSAweDAwMDAwMDgwLAorCVNDRl9TQ1NJX1JFU0VSVkFUSU9OX0NPTkZMSUNUCT0gMHgwMDAwMDEwMCwKKwlTQ0ZfQ01EX1BBU1NUSFJPVUdIX05PQUxMT0MJPSAweDAwMDAwMjAwLAorCVNDRl9TRV9DTURfRkFJTEVECQk9IDB4MDAwMDA0MDAsCisJU0NGX1NFX0xVTl9DTUQJCQk9IDB4MDAwMDA4MDAsCisJU0NGX1NFX0FMTE9XX0VPTwkJPSAweDAwMDAxMDAwLAorCVNDRl9TRV9ESVNBQkxFX09OTElORV9DSEVDSwk9IDB4MDAwMDIwMDAsCisJU0NGX1NFTlRfQ0hFQ0tfQ09ORElUSU9OCT0gMHgwMDAwNDAwMCwKKwlTQ0ZfT1ZFUkZMT1dfQklUCQk9IDB4MDAwMDgwMDAsCisJU0NGX1VOREVSRkxPV19CSVQJCT0gMHgwMDAxMDAwMCwKKwlTQ0ZfU0VOVF9ERUxBWUVEX1RBUwkJPSAweDAwMDIwMDAwLAorCVNDRl9BTFVBX05PTl9PUFRJTUlaRUQJCT0gMHgwMDA0MDAwMCwKKwlTQ0ZfREVMQVlFRF9DTURfRlJPTV9TQU1fQVRUUgk9IDB4MDAwODAwMDAsCisJU0NGX1BBU1NUSFJPVUdIX1NHX1RPX01FTQk9IDB4MDAxMDAwMDAsCisJU0NGX1BBU1NUSFJPVUdIX0NPTlRJR19UT19TRwk9IDB4MDAyMDAwMDAsCisJU0NGX1BBU1NUSFJPVUdIX1NHX1RPX01FTV9OT0FMTE9DID0gMHgwMDQwMDAwMCwKKwlTQ0ZfRU1VTEFURV9TWU5DX0NBQ0hFCQk9IDB4MDA4MDAwMDAsCisJU0NGX0VNVUxBVEVfQ0RCX0FTWU5DCQk9IDB4MDEwMDAwMDAsCisJU0NGX0VNVUxBVEVfU1lOQ19VTk1BUAkJPSAweDAyMDAwMDAwCit9OworCisvKiBzdHJ1Y3Qgc2VfZGV2X2VudHJ5LT5sdW5fZmxhZ3MgYW5kIHN0cnVjdCBzZV9sdW4tPmx1bl9hY2Nlc3MgKi8KK2VudW0gdHJhbnNwb3J0X2x1bmZsYWdzX3RhYmxlIHsKKwlUUkFOU1BPUlRfTFVORkxBR1NfTk9fQUNDRVNTCQk9IDB4MDAsCisJVFJBTlNQT1JUX0xVTkZMQUdTX0lOSVRJQVRPUl9BQ0NFU1MJPSAweDAxLAorCVRSQU5TUE9SVF9MVU5GTEFHU19SRUFEX09OTFkJCT0gMHgwMiwKKwlUUkFOU1BPUlRfTFVORkxBR1NfUkVBRF9XUklURQkJPSAweDA0LAorfTsKKworLyogc3RydWN0IHNlX2RldmljZS0+ZGV2X3N0YXR1cyAqLworZW51bSB0cmFuc3BvcnRfZGV2aWNlX3N0YXR1c190YWJsZSB7CisJVFJBTlNQT1JUX0RFVklDRV9BQ1RJVkFURUQJCT0gMHgwMSwKKwlUUkFOU1BPUlRfREVWSUNFX0RFQUNUSVZBVEVECQk9IDB4MDIsCisJVFJBTlNQT1JUX0RFVklDRV9RVUVVRV9GVUxMCQk9IDB4MDQsCisJVFJBTlNQT1JUX0RFVklDRV9TSFVURE9XTgkJPSAweDA4LAorCVRSQU5TUE9SVF9ERVZJQ0VfT0ZGTElORV9BQ1RJVkFURUQJPSAweDEwLAorCVRSQU5TUE9SVF9ERVZJQ0VfT0ZGTElORV9ERUFDVElWQVRFRAk9IDB4MjAsCit9OworCisvKgorICogVXNlZCBieSB0cmFuc3BvcnRfc2VuZF9jaGVja19jb25kaXRpb25fYW5kX3NlbnNlKCkgYW5kIHNlX2NtZC0+c2NzaV9zZW5zZV9yZWFzb24KKyAqIHRvIHNpZ25hbCB3aGljaCBBU0MvQVNDUSBzZW5zZSBwYXlsb2FkIHNob3VsZCBiZSBidWlsdC4KKyAqLworZW51bSB0Y21fc2Vuc2VfcmVhc29uX3RhYmxlIHsKKwlUQ01fTk9OX0VYSVNURU5UX0xVTgkJCT0gMHgwMSwKKwlUQ01fVU5TVVBQT1JURURfU0NTSV9PUENPREUJCT0gMHgwMiwKKwlUQ01fSU5DT1JSRUNUX0FNT1VOVF9PRl9EQVRBCQk9IDB4MDMsCisJVENNX1VORVhQRUNURURfVU5TT0xJQ0lURURfREFUQQkJPSAweDA0LAorCVRDTV9TRVJWSUNFX0NSQ19FUlJPUgkJCT0gMHgwNSwKKwlUQ01fU05BQ0tfUkVKRUNURUQJCQk9IDB4MDYsCisJVENNX1NFQ1RPUl9DT1VOVF9UT09fTUFOWQkJPSAweDA3LAorCVRDTV9JTlZBTElEX0NEQl9GSUVMRAkJCT0gMHgwOCwKKwlUQ01fSU5WQUxJRF9QQVJBTUVURVJfTElTVAkJPSAweDA5LAorCVRDTV9MT0dJQ0FMX1VOSVRfQ09NTVVOSUNBVElPTl9GQUlMVVJFCT0gMHgwYSwKKwlUQ01fVU5LTk9XTl9NT0RFX1BBR0UJCQk9IDB4MGIsCisJVENNX1dSSVRFX1BST1RFQ1RFRAkJCT0gMHgwYywKKwlUQ01fQ0hFQ0tfQ09ORElUSU9OX0FCT1JUX0NNRAkJPSAweDBkLAorCVRDTV9DSEVDS19DT05ESVRJT05fVU5JVF9BVFRFTlRJT04JPSAweDBlLAorCVRDTV9DSEVDS19DT05ESVRJT05fTk9UX1JFQURZCQk9IDB4MGYsCit9OworCitzdHJ1Y3Qgc2Vfb2JqIHsKKwlhdG9taWNfdCBvYmpfYWNjZXNzX2NvdW50OworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKKy8qCisgKiBVc2VkIGJ5IFRDTSBDb3JlIGludGVybmFsbHkgdG8gc2lnbmFsIGlmIEFMVUEgZW11bGF0aW9uIGlzIGVuYWJsZWQgb3IKKyAqIGRpc2FibGVkLCBvciBydW5uaW5nIGluIHdpdGggVENNL3BTQ1NJIHBhc3N0aHJvdWdoIG1vZGUKKyAqLwordHlwZWRlZiBlbnVtIHsKKwlTUENfQUxVQV9QQVNTVEhST1VHSCwKKwlTUEMyX0FMVUFfRElTQUJMRUQsCisJU1BDM19BTFVBX0VNVUxBVEVECit9IHQxMF9hbHVhX2luZGV4X3Q7CisKKy8qCisgKiBVc2VkIGJ5IFRDTSBDb3JlIGludGVybmFsbHkgdG8gc2lnbmFsIGlmIFNBTSBUYXNrIEF0dHJpYnV0ZSBlbXVsYXRpb24KKyAqIGlzIGVuYWJsZWQgb3IgZGlzYWJsZWQsIG9yIHJ1bm5pbmcgaW4gd2l0aCBUQ00vcFNDU0kgcGFzc3Rocm91Z2ggbW9kZQorICovCit0eXBlZGVmIGVudW0geworCVNBTV9UQVNLX0FUVFJfUEFTU1RIUk9VR0gsCisJU0FNX1RBU0tfQVRUUl9VTlRBR0dFRCwKKwlTQU1fVEFTS19BVFRSX0VNVUxBVEVECit9IHQxMF90YXNrX2F0dHJfaW5kZXhfdDsKKworc3RydWN0IHNlX2NtZDsKKworc3RydWN0IHQxMF9hbHVhIHsKKwl0MTBfYWx1YV9pbmRleF90IGFsdWFfdHlwZTsKKwkvKiBBTFVBIFRhcmdldCBQb3J0IEdyb3VwIElEICovCisJdTE2CWFsdWFfdGdfcHRfZ3BzX2NvdW50ZXI7CisJdTMyCWFsdWFfdGdfcHRfZ3BzX2NvdW50OworCXNwaW5sb2NrX3QgdGdfcHRfZ3BzX2xvY2s7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnQxMF9zdWJfZGV2OworCS8qIFVzZWQgZm9yIGRlZmF1bHQgQUxVQSBUYXJnZXQgUG9ydCBHcm91cCAqLworCXN0cnVjdCB0MTBfYWx1YV90Z19wdF9ncCAqZGVmYXVsdF90Z19wdF9ncDsKKwkvKiBVc2VkIGZvciBkZWZhdWx0IEFMVUEgVGFyZ2V0IFBvcnQgR3JvdXAgQ29uZmlnRlMgZ3JvdXAgKi8KKwlzdHJ1Y3QgY29uZmlnX2dyb3VwIGFsdWFfdGdfcHRfZ3BzX2dyb3VwOworCWludCAoKmFsdWFfc3RhdGVfY2hlY2spKHN0cnVjdCBzZV9jbWQgKiwgdW5zaWduZWQgY2hhciAqLCB1OCAqKTsKKwlzdHJ1Y3QgbGlzdF9oZWFkIHRnX3B0X2dwc19saXN0OworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKK3N0cnVjdCB0MTBfYWx1YV9sdV9ncCB7CisJdTE2CWx1X2dwX2lkOworCWludAlsdV9ncF92YWxpZF9pZDsKKwl1MzIJbHVfZ3BfbWVtYmVyczsKKwlhdG9taWNfdCBsdV9ncF9zaHV0ZG93bjsKKwlhdG9taWNfdCBsdV9ncF9yZWZfY250OworCXNwaW5sb2NrX3QgbHVfZ3BfbG9jazsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwIGx1X2dwX2dyb3VwOworCXN0cnVjdCBsaXN0X2hlYWQgbHVfZ3BfbGlzdDsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGx1X2dwX21lbV9saXN0OworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKK3N0cnVjdCB0MTBfYWx1YV9sdV9ncF9tZW1iZXIgeworCWludCBsdV9ncF9hc3NvYzoxOworCWF0b21pY190IGx1X2dwX21lbV9yZWZfY250OworCXNwaW5sb2NrX3QgbHVfZ3BfbWVtX2xvY2s7CisJc3RydWN0IHQxMF9hbHVhX2x1X2dwICpsdV9ncDsKKwlzdHJ1Y3Qgc2VfZGV2aWNlICpsdV9ncF9tZW1fZGV2OworCXN0cnVjdCBsaXN0X2hlYWQgbHVfZ3BfbWVtX2xpc3Q7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwIHsKKwl1MTYJdGdfcHRfZ3BfaWQ7CisJaW50CXRnX3B0X2dwX3ZhbGlkX2lkOworCWludAl0Z19wdF9ncF9hbHVhX2FjY2Vzc19zdGF0dXM7CisJaW50CXRnX3B0X2dwX2FsdWFfYWNjZXNzX3R5cGU7CisJaW50CXRnX3B0X2dwX25vbm9wX2RlbGF5X21zZWNzOworCWludAl0Z19wdF9ncF90cmFuc19kZWxheV9tc2VjczsKKwlpbnQJdGdfcHRfZ3BfcHJlZjsKKwlpbnQJdGdfcHRfZ3Bfd3JpdGVfbWV0YWRhdGE7CisJLyogVXNlZCBieSBzdHJ1Y3QgdDEwX2FsdWFfdGdfcHRfZ3AtPnRnX3B0X2dwX21kX2J1Zl9sZW4gKi8KKyNkZWZpbmUgQUxVQV9NRF9CVUZfTEVOCQkJCTEwMjQKKwl1MzIJdGdfcHRfZ3BfbWRfYnVmX2xlbjsKKwl1MzIJdGdfcHRfZ3BfbWVtYmVyczsKKwlhdG9taWNfdCB0Z19wdF9ncF9hbHVhX2FjY2Vzc19zdGF0ZTsKKwlhdG9taWNfdCB0Z19wdF9ncF9yZWZfY250OworCXNwaW5sb2NrX3QgdGdfcHRfZ3BfbG9jazsKKwlzdHJ1Y3QgbXV0ZXggdGdfcHRfZ3BfbWRfbXV0ZXg7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKnRnX3B0X2dwX3N1X2RldjsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwIHRnX3B0X2dwX2dyb3VwOworCXN0cnVjdCBsaXN0X2hlYWQgdGdfcHRfZ3BfbGlzdDsKKwlzdHJ1Y3QgbGlzdF9oZWFkIHRnX3B0X2dwX21lbV9saXN0OworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKK3N0cnVjdCB0MTBfYWx1YV90Z19wdF9ncF9tZW1iZXIgeworCWludCB0Z19wdF9ncF9hc3NvYzoxOworCWF0b21pY190IHRnX3B0X2dwX21lbV9yZWZfY250OworCXNwaW5sb2NrX3QgdGdfcHRfZ3BfbWVtX2xvY2s7CisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwICp0Z19wdF9ncDsKKwlzdHJ1Y3Qgc2VfcG9ydCAqdGdfcHQ7CisJc3RydWN0IGxpc3RfaGVhZCB0Z19wdF9ncF9tZW1fbGlzdDsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCitzdHJ1Y3QgdDEwX3ZwZCB7CisJdW5zaWduZWQgY2hhciBkZXZpY2VfaWRlbnRpZmllcltJTlFVSVJZX1ZQRF9ERVZJQ0VfSURFTlRJRklFUl9MRU5dOworCWludCBwcm90b2NvbF9pZGVudGlmaWVyX3NldDsKKwl1MzIgcHJvdG9jb2xfaWRlbnRpZmllcjsKKwl1MzIgZGV2aWNlX2lkZW50aWZpZXJfY29kZV9zZXQ7CisJdTMyIGFzc29jaWF0aW9uOworCXUzMiBkZXZpY2VfaWRlbnRpZmllcl90eXBlOworCXN0cnVjdCBsaXN0X2hlYWQgdnBkX2xpc3Q7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworc3RydWN0IHQxMF93d24geworCXVuc2lnbmVkIGNoYXIgdmVuZG9yWzhdOworCXVuc2lnbmVkIGNoYXIgbW9kZWxbMTZdOworCXVuc2lnbmVkIGNoYXIgcmV2aXNpb25bNF07CisJdW5zaWduZWQgY2hhciB1bml0X3NlcmlhbFtJTlFVSVJZX1ZQRF9TRVJJQUxfTEVOXTsKKwlzcGlubG9ja190IHQxMF92cGRfbG9jazsKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqdDEwX3N1Yl9kZXY7CisJc3RydWN0IGNvbmZpZ19ncm91cCB0MTBfd3duX2dyb3VwOworCXN0cnVjdCBsaXN0X2hlYWQgdDEwX3ZwZF9saXN0OworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKKworLyoKKyAqIFVzZWQgYnkgVENNIENvcmUgaW50ZXJuYWxseSB0byBzaWduYWwgaWYgPj0gU1BDLTMgcGVyaXN0ZW50IHJlc2VydmF0aW9ucworICogZW11bGF0aW9uIGlzIGVuYWJsZWQgb3IgZGlzYWJsZWQsIG9yIHJ1bm5pbmcgaW4gd2l0aCBUQ00vcFNDU0kgcGFzc3Rocm91Z2gKKyAqIG1vZGUKKyAqLwordHlwZWRlZiBlbnVtIHsKKwlTUENfUEFTU1RIUk9VR0gsCisJU1BDMl9SRVNFUlZBVElPTlMsCisJU1BDM19QRVJTSVNURU5UX1JFU0VSVkFUSU9OUworfSB0MTBfcmVzZXJ2YXRpb25zX2luZGV4X3Q7CisKK3N0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uIHsKKwkvKiBVc2VkIGZvciBmYWJyaWNzIHRoYXQgY29udGFpbiBXV04rSVNJRCAqLworI2RlZmluZSBQUl9SRUdfSVNJRF9MRU4JCQkJMTYKKwkvKiBQUl9SRUdfSVNJRF9MRU4gKyAnLGksMHgnICovCisjZGVmaW5lIFBSX1JFR19JU0lEX0lEX0xFTgkJCShQUl9SRUdfSVNJRF9MRU4gKyA1KQorCWNoYXIgcHJfcmVnX2lzaWRbUFJfUkVHX0lTSURfTEVOXTsKKwkvKiBVc2VkIGR1cmluZyBBUFRQTCBtZXRhZGF0YSByZWFkaW5nICovCisjZGVmaW5lIFBSX0FQVFBMX01BWF9JUE9SVF9MRU4JCQkyNTYKKwl1bnNpZ25lZCBjaGFyIHByX2lwb3J0W1BSX0FQVFBMX01BWF9JUE9SVF9MRU5dOworCS8qIFVzZWQgZHVyaW5nIEFQVFBMIG1ldGFkYXRhIHJlYWRpbmcgKi8KKyNkZWZpbmUgUFJfQVBUUExfTUFYX1RQT1JUX0xFTgkJCTI1NgorCXVuc2lnbmVkIGNoYXIgcHJfdHBvcnRbUFJfQVBUUExfTUFYX1RQT1JUX0xFTl07CisJLyogRm9yIHdyaXRpbmcgb3V0IGxpdmUgbWV0YSBkYXRhICovCisJdW5zaWduZWQgY2hhciAqcHJfYXB0cGxfYnVmOworCXUxNiBwcl9hcHRwbF9ycHRpOworCXUxNiBwcl9yZWdfdHBndDsKKwkvKiBSZXNlcnZhdGlvbiBlZmZlY3RzIGFsbCB0YXJnZXQgcG9ydHMgKi8KKwlpbnQgcHJfcmVnX2FsbF90Z19wdDsKKwkvKiBBY3RpdmF0ZSBQZXJzaXN0ZW5jZSBhY3Jvc3MgVGFyZ2V0IFBvd2VyIExvc3MgKi8KKwlpbnQgcHJfcmVnX2FwdHBsOworCWludCBwcl9yZXNfaG9sZGVyOworCWludCBwcl9yZXNfdHlwZTsKKwlpbnQgcHJfcmVzX3Njb3BlOworCS8qIFVzZWQgZm9yIGZhYnJpYyBpbml0aWF0b3IgV1dQTnMgdXNpbmcgYSBJU0lEICovCisJaW50IGlzaWRfcHJlc2VudF9hdF9yZWc6MTsKKwl1MzIgcHJfcmVzX21hcHBlZF9sdW47CisJdTMyIHByX2FwdHBsX3RhcmdldF9sdW47CisJdTMyIHByX3Jlc19nZW5lcmF0aW9uOworCXU2NCBwcl9yZWdfYmluX2lzaWQ7CisJdTY0IHByX3Jlc19rZXk7CisJYXRvbWljX3QgcHJfcmVzX2hvbGRlcnM7CisJc3RydWN0IHNlX25vZGVfYWNsICpwcl9yZWdfbmFjbDsKKwlzdHJ1Y3Qgc2VfZGV2X2VudHJ5ICpwcl9yZWdfZGV2ZTsKKwlzdHJ1Y3Qgc2VfbHVuICpwcl9yZWdfdGdfcHRfbHVuOworCXN0cnVjdCBsaXN0X2hlYWQgcHJfcmVnX2xpc3Q7CisJc3RydWN0IGxpc3RfaGVhZCBwcl9yZWdfYWJvcnRfbGlzdDsKKwlzdHJ1Y3QgbGlzdF9oZWFkIHByX3JlZ19hcHRwbF9saXN0OworCXN0cnVjdCBsaXN0X2hlYWQgcHJfcmVnX2F0cF9saXN0OworCXN0cnVjdCBsaXN0X2hlYWQgcHJfcmVnX2F0cF9tZW1fbGlzdDsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCisvKgorICogVGhpcyBzZXQgb2YgZnVuY3Rpb24gcG9pbnRlciBvcHMgaXMgc2V0IGJhc2VkIHVwb24gU1BDM19QRVJTSVNURU5UX1JFU0VSVkFUSU9OUywKKyAqIFNQQzJfUkVTRVJWQVRJT05TIG9yIFNQQ19QQVNTVEhST1VHSCBpbiBkcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9wci5jOgorICogY29yZV9zZXR1cF9yZXNlcnZhdGlvbnMoKQorICovCitzdHJ1Y3QgdDEwX3Jlc2VydmF0aW9uX29wcyB7CisJaW50ICgqdDEwX3Jlc2VydmF0aW9uX2NoZWNrKShzdHJ1Y3Qgc2VfY21kICosIHUzMiAqKTsKKwlpbnQgKCp0MTBfc2VxX25vbl9ob2xkZXIpKHN0cnVjdCBzZV9jbWQgKiwgdW5zaWduZWQgY2hhciAqLCB1MzIpOworCWludCAoKnQxMF9wcl9yZWdpc3Rlcikoc3RydWN0IHNlX2NtZCAqKTsKKwlpbnQgKCp0MTBfcHJfY2xlYXIpKHN0cnVjdCBzZV9jbWQgKik7Cit9OworCitzdHJ1Y3QgdDEwX3Jlc2VydmF0aW9uX3RlbXBsYXRlIHsKKwkvKiBSZXNlcnZhdGlvbiBlZmZlY3RzIGFsbCB0YXJnZXQgcG9ydHMgKi8KKwlpbnQgcHJfYWxsX3RnX3B0OworCS8qIEFjdGl2YXRlIFBlcnNpc3RlbmNlIGFjcm9zcyBUYXJnZXQgUG93ZXIgTG9zcyBlbmFibGVkCisJICogZm9yIFNDU0kgZGV2aWNlICovCisJaW50IHByX2FwdHBsX2FjdGl2ZTsKKwkvKiBVc2VkIGJ5IHN0cnVjdCB0MTBfcmVzZXJ2YXRpb25fdGVtcGxhdGUtPnByX2FwdHBsX2J1Zl9sZW4gKi8KKyNkZWZpbmUgUFJfQVBUUExfQlVGX0xFTgkJCTgxOTIKKwl1MzIgcHJfYXB0cGxfYnVmX2xlbjsKKwl1MzIgcHJfZ2VuZXJhdGlvbjsKKwl0MTBfcmVzZXJ2YXRpb25zX2luZGV4X3QgcmVzX3R5cGU7CisJc3BpbmxvY2tfdCByZWdpc3RyYXRpb25fbG9jazsKKwlzcGlubG9ja190IGFwdHBsX3JlZ19sb2NrOworCS8qCisJICogVGhpcyB3aWxsIGFsd2F5cyBiZSBzZXQgYnkgb25lIGluZGl2aWR1YWwgSV9UIE5leHVzLgorCSAqIEhvd2V2ZXIgd2l0aCBhbGxfdGdfcHQ9MSwgb3RoZXIgSV9UIE5leHVzIGZyb20gdGhlCisJICogc2FtZSBpbml0aWF0b3IgY2FuIGFjY2VzcyBQUiByZWcvcmVzIGluZm8gb24gYSBkaWZmZXJlbnQKKwkgKiB0YXJnZXQgcG9ydC4KKwkgKgorCSAqIFRoZXJlIGlzIGFsc28gdGhlICdBbGwgUmVnaXN0cmFudHMnIGNhc2UsIHdoZXJlIHRoZXJlIGlzCisJICogYSBzaW5nbGUgKnByX3Jlc19ob2xkZXIgb2YgdGhlIHJlc2VydmF0aW9uLCBidXQgYWxsCisJICogcmVnaXN0cmF0aW9ucyBhcmUgY29uc2lkZXJlZCByZXNlcnZhdGlvbiBob2xkZXJzLgorCSAqLworCXN0cnVjdCBzZV9ub2RlX2FjbCAqcHJfcmVzX2hvbGRlcjsKKwlzdHJ1Y3QgbGlzdF9oZWFkIHJlZ2lzdHJhdGlvbl9saXN0OworCXN0cnVjdCBsaXN0X2hlYWQgYXB0cGxfcmVnX2xpc3Q7CisJc3RydWN0IHQxMF9yZXNlcnZhdGlvbl9vcHMgcHJfb3BzOworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKK3N0cnVjdCBzZV9xdWV1ZV9yZXEgeworCWludAkJCXN0YXRlOworCXZvaWQJCQkqY21kOworCXN0cnVjdCBsaXN0X2hlYWQJcXJfbGlzdDsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCitzdHJ1Y3Qgc2VfcXVldWVfb2JqIHsKKwlhdG9taWNfdAkJcXVldWVfY250OworCXNwaW5sb2NrX3QJCWNtZF9xdWV1ZV9sb2NrOworCXN0cnVjdCBsaXN0X2hlYWQJcW9ial9saXN0OworCXdhaXRfcXVldWVfaGVhZF90CXRocmVhZF93cTsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCisvKgorICogVXNlZCBvbmUgcGVyIHN0cnVjdCBzZV9jbWQgdG8gaG9sZCBhbGwgZXh0cmEgc3RydWN0IHNlX3Rhc2sKKyAqIG1ldGFkYXRhLiAgVGhpcyBzdHJ1Y3R1cmUgaXMgc2V0dXAgYW5kIGFsbG9jYXRlZCBpbgorICogZHJpdmVycy90YXJnZXQvdGFyZ2V0X2NvcmVfdHJhbnNwb3J0LmM6X190cmFuc3BvcnRfYWxsb2Nfc2VfY21kKCkKKyAqLworc3RydWN0IHNlX3RyYW5zcG9ydF90YXNrIHsKKwl1bnNpZ25lZCBjaGFyCQkqdF90YXNrX2NkYjsKKwl1bnNpZ25lZCBjaGFyCQlfX3RfdGFza19jZGJbVENNX01BWF9DT01NQU5EX1NJWkVdOworCXVuc2lnbmVkIGxvbmcgbG9uZwl0X3Rhc2tfbGJhOworCWludAkJCXRfdGFza3NfZmFpbGVkOworCWludAkJCXRfdGFza3NfZnVhOworCWludAkJCXRfdGFza3NfYmlkaToxOworCXUzMgkJCXRfdGFza19jZGJzOworCXUzMgkJCXRfdGFza3NfY2hlY2s7CisJdTMyCQkJdF90YXNrc19ubzsKKwl1MzIJCQl0X3Rhc2tzX3NlY3RvcnM7CisJdTMyCQkJdF90YXNrc19zZV9udW07CisJdTMyCQkJdF90YXNrc19zZV9iaWRpX251bTsKKwl1MzIJCQl0X3Rhc2tzX3NnX2NoYWluZWRfbm87CisJYXRvbWljX3QJCXRfZmVfY291bnQ7CisJYXRvbWljX3QJCXRfc2VfY291bnQ7CisJYXRvbWljX3QJCXRfdGFza19jZGJzX2xlZnQ7CisJYXRvbWljX3QJCXRfdGFza19jZGJzX2V4X2xlZnQ7CisJYXRvbWljX3QJCXRfdGFza19jZGJzX3RpbWVvdXRfbGVmdDsKKwlhdG9taWNfdAkJdF90YXNrX2NkYnNfc2VudDsKKwlhdG9taWNfdAkJdF90cmFuc3BvcnRfYWJvcnRlZDsKKwlhdG9taWNfdAkJdF90cmFuc3BvcnRfYWN0aXZlOworCWF0b21pY190CQl0X3RyYW5zcG9ydF9jb21wbGV0ZTsKKwlhdG9taWNfdAkJdF90cmFuc3BvcnRfcXVldWVfYWN0aXZlOworCWF0b21pY190CQl0X3RyYW5zcG9ydF9zZW50OworCWF0b21pY190CQl0X3RyYW5zcG9ydF9zdG9wOworCWF0b21pY190CQl0X3RyYW5zcG9ydF90aW1lb3V0OworCWF0b21pY190CQl0cmFuc3BvcnRfZGV2X2FjdGl2ZTsKKwlhdG9taWNfdAkJdHJhbnNwb3J0X2x1bl9hY3RpdmU7CisJYXRvbWljX3QJCXRyYW5zcG9ydF9sdW5fZmVfc3RvcDsKKwlhdG9taWNfdAkJdHJhbnNwb3J0X2x1bl9zdG9wOworCXNwaW5sb2NrX3QJCXRfc3RhdGVfbG9jazsKKwlzdHJ1Y3QgY29tcGxldGlvbgl0X3RyYW5zcG9ydF9zdG9wX2NvbXA7CisJc3RydWN0IGNvbXBsZXRpb24JdHJhbnNwb3J0X2x1bl9mZV9zdG9wX2NvbXA7CisJc3RydWN0IGNvbXBsZXRpb24JdHJhbnNwb3J0X2x1bl9zdG9wX2NvbXA7CisJc3RydWN0IHNjYXR0ZXJsaXN0CSp0X3Rhc2tzX3NnX2NoYWluZWQ7CisJc3RydWN0IHNjYXR0ZXJsaXN0CXRfdGFza3Nfc2dfYm91bmNlOworCXZvaWQJCQkqdF90YXNrX2J1ZjsKKwkvKgorCSAqIFVzZWQgZm9yIHByZS1yZWdpc3RlcmVkIGZhYnJpYyBTR0wgcGFzc3Rocm91Z2ggV1JJVEUgYW5kIFJFQUQKKwkgKiB3aXRoIHRoZSBzcGVjaWFsIFNDRl9QQVNTVEhST1VHSF9DT05USUdfVE9fU0cgY2FzZSBmb3IgVENNX0xvb3AKKwkgKiBhbmQgb3RoZXIgSFcgdGFyZ2V0IG1vZGUgZmFicmljIG1vZHVsZXMuCisJICovCisJc3RydWN0IHNjYXR0ZXJsaXN0CSp0X3Rhc2tfcHRfc2dsOworCXN0cnVjdCBsaXN0X2hlYWQJKnRfbWVtX2xpc3Q7CisJLyogVXNlZCBmb3IgQklESSBSRUFEICovCisJc3RydWN0IGxpc3RfaGVhZAkqdF9tZW1fYmlkaV9saXN0OworCXN0cnVjdCBsaXN0X2hlYWQJdF90YXNrX2xpc3Q7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworc3RydWN0IHNlX3Rhc2sgeworCXVuc2lnbmVkIGNoYXIJdGFza19zZW5zZTsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnRhc2tfc2c7CisJc3RydWN0IHNjYXR0ZXJsaXN0ICp0YXNrX3NnX2JpZGk7CisJdTgJCXRhc2tfc2NzaV9zdGF0dXM7CisJdTgJCXRhc2tfZmxhZ3M7CisJaW50CQl0YXNrX2Vycm9yX3N0YXR1czsKKwlpbnQJCXRhc2tfc3RhdGVfZmxhZ3M7CisJaW50CQl0YXNrX3BhZGRlZF9zZzoxOworCXVuc2lnbmVkIGxvbmcgbG9uZwl0YXNrX2xiYTsKKwl1MzIJCXRhc2tfbm87CisJdTMyCQl0YXNrX3NlY3RvcnM7CisJdTMyCQl0YXNrX3NpemU7CisJdTMyCQl0YXNrX3NnX251bTsKKwl1MzIJCXRhc2tfc2dfb2Zmc2V0OworCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uCXRhc2tfZGF0YV9kaXJlY3Rpb247CisJc3RydWN0IHNlX2NtZCAqdGFza19zZV9jbWQ7CisJc3RydWN0IHNlX2RldmljZQkqc2VfZGV2OworCXN0cnVjdCBjb21wbGV0aW9uCXRhc2tfc3RvcF9jb21wOworCWF0b21pY190CXRhc2tfYWN0aXZlOworCWF0b21pY190CXRhc2tfZXhlY3V0ZV9xdWV1ZTsKKwlhdG9taWNfdAl0YXNrX3RpbWVvdXQ7CisJYXRvbWljX3QJdGFza19zZW50OworCWF0b21pY190CXRhc2tfc3RvcDsKKwlhdG9taWNfdAl0YXNrX3N0YXRlX2FjdGl2ZTsKKwlzdHJ1Y3QgdGltZXJfbGlzdAl0YXNrX3RpbWVyOworCXN0cnVjdCBzZV9kZXZpY2UgKnNlX29ial9wdHI7CisJc3RydWN0IGxpc3RfaGVhZCB0X2xpc3Q7CisJc3RydWN0IGxpc3RfaGVhZCB0X2V4ZWN1dGVfbGlzdDsKKwlzdHJ1Y3QgbGlzdF9oZWFkIHRfc3RhdGVfbGlzdDsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCisjZGVmaW5lIFRBU0tfQ01EKHRhc2spCSgoc3RydWN0IHNlX2NtZCAqKXRhc2stPnRhc2tfc2VfY21kKQorI2RlZmluZSBUQVNLX0RFVih0YXNrKQkoKHN0cnVjdCBzZV9kZXZpY2UgKil0YXNrLT5zZV9kZXYpCisKK3N0cnVjdCBzZV9jbWQgeworCS8qIFNBTSByZXNwb25zZSBjb2RlIGJlaW5nIHNlbnQgdG8gaW5pdGlhdG9yICovCisJdTgJCQlzY3NpX3N0YXR1czsKKwl1OAkJCXNjc2lfYXNjOworCXU4CQkJc2NzaV9hc2NxOworCXU4CQkJc2NzaV9zZW5zZV9yZWFzb247CisJdTE2CQkJc2NzaV9zZW5zZV9sZW5ndGg7CisJLyogRGVsYXkgZm9yIEFMVUEgQWN0aXZlL05vbk9wdGltaXplZCBzdGF0ZSBhY2Nlc3MgaW4gbWlsbGlzZWNvbmRzICovCisJaW50CQkJYWx1YV9ub25vcF9kZWxheTsKKwkvKiBTZWUgaW5jbHVkZS9saW51eC9kbWEtbWFwcGluZy5oICovCisJZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24JZGF0YV9kaXJlY3Rpb247CisJLyogRm9yIFNBTSBUYXNrIEF0dHJpYnV0ZSAqLworCWludAkJCXNhbV90YXNrX2F0dHI7CisJLyogVHJhbnNwb3J0IHByb3RvY29sIGRlcGVuZGVudCBzdGF0ZSwgc2VlIHRyYW5zcG9ydF9zdGF0ZV90YWJsZSAqLworCWVudW0gdHJhbnNwb3J0X3N0YXRlX3RhYmxlIHRfc3RhdGU7CisJLyogVHJhbnNwb3J0IHByb3RvY29sIGRlcGVuZGVudCBzdGF0ZSBmb3Igb3V0IG9mIG9yZGVyIENtZFNOcyAqLworCWludAkJCWRlZmVycmVkX3Rfc3RhdGU7CisJLyogVHJhbnNwb3J0IHNwZWNpZmljIGVycm9yIHN0YXR1cyAqLworCWludAkJCXRyYW5zcG9ydF9lcnJvcl9zdGF0dXM7CisJLyogU2VlIHNlX2NtZF9mbGFnc190YWJsZSAqLworCXUzMgkJCXNlX2NtZF9mbGFnczsKKwl1MzIJCQlzZV9vcmRlcmVkX2lkOworCS8qIFRvdGFsIHNpemUgaW4gYnl0ZXMgYXNzb2NpYXRlZCB3aXRoIGNvbW1hbmQgKi8KKwl1MzIJCQlkYXRhX2xlbmd0aDsKKwkvKiBTQ1NJIFByZXNlbnRlZCBEYXRhIFRyYW5zZmVyIExlbmd0aCAqLworCXUzMgkJCWNtZF9zcGR0bDsKKwl1MzIJCQlyZXNpZHVhbF9jb3VudDsKKwl1MzIJCQlvcmlnX2ZlX2x1bjsKKwkvKiBQZXJzaXN0ZW50IFJlc2VydmF0aW9uIGtleSAqLworCXU2NAkJCXByX3Jlc19rZXk7CisJYXRvbWljX3QgICAgICAgICAgICAgICAgdHJhbnNwb3J0X3NlbnQ7CisJLyogVXNlZCBmb3Igc2Vuc2UgZGF0YSAqLworCXZvaWQJCQkqc2Vuc2VfYnVmZmVyOworCXN0cnVjdCBsaXN0X2hlYWQJc2VfZGVsYXllZF9saXN0OworCXN0cnVjdCBsaXN0X2hlYWQJc2Vfb3JkZXJlZF9saXN0OworCXN0cnVjdCBsaXN0X2hlYWQJc2VfbHVuX2xpc3Q7CisJc3RydWN0IHNlX2RldmljZSAgICAgICpzZV9kZXY7CisJc3RydWN0IHNlX2Rldl9lbnRyeSAgICpzZV9kZXZlOworCXN0cnVjdCBzZV9kZXZpY2UJKnNlX29ial9wdHI7CisJc3RydWN0IHNlX2RldmljZQkqc2Vfb3JpZ19vYmpfcHRyOworCXN0cnVjdCBzZV9sdW4JCSpzZV9sdW47CisJLyogT25seSB1c2VkIGZvciBpbnRlcm5hbCBwYXNzdGhyb3VnaCBhbmQgbGVnYWN5IFRDTSBmYWJyaWMgbW9kdWxlcyAqLworCXN0cnVjdCBzZV9zZXNzaW9uCSpzZV9zZXNzOworCXN0cnVjdCBzZV90bXJfcmVxCSpzZV90bXJfcmVxOworCS8qIHRfdGFzayBpcyBzZXR1cCB0byB0X3Rhc2tfYmFja3N0b3JlIGluIHRyYW5zcG9ydF9pbml0X3NlX2NtZCgpICovCisJc3RydWN0IHNlX3RyYW5zcG9ydF90YXNrICp0X3Rhc2s7CisJc3RydWN0IHNlX3RyYW5zcG9ydF90YXNrIHRfdGFza19iYWNrc3RvcmU7CisJc3RydWN0IHRhcmdldF9jb3JlX2ZhYnJpY19vcHMgKnNlX3RmbzsKKwlpbnQgKCp0cmFuc3BvcnRfZW11bGF0ZV9jZGIpKHN0cnVjdCBzZV9jbWQgKik7CisJdm9pZCAoKnRyYW5zcG9ydF9zcGxpdF9jZGIpKHVuc2lnbmVkIGxvbmcgbG9uZywgdTMyICosIHVuc2lnbmVkIGNoYXIgKik7CisJdm9pZCAoKnRyYW5zcG9ydF93YWl0X2Zvcl90YXNrcykoc3RydWN0IHNlX2NtZCAqLCBpbnQsIGludCk7CisJdm9pZCAoKnRyYW5zcG9ydF9jb21wbGV0ZV9jYWxsYmFjaykoc3RydWN0IHNlX2NtZCAqKTsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCisjZGVmaW5lIFRfVEFTSyhjbWQpICAgICAoKHN0cnVjdCBzZV90cmFuc3BvcnRfdGFzayAqKShjbWQtPnRfdGFzaykpCisjZGVmaW5lIENNRF9URk8oY21kKSAoKHN0cnVjdCB0YXJnZXRfY29yZV9mYWJyaWNfb3BzICopY21kLT5zZV90Zm8pCisKK3N0cnVjdCBzZV90bXJfcmVxIHsKKwkvKiBUYXNrIE1hbmFnZW1lbnQgZnVuY3Rpb24gdG8gYmUgcHJlZm9ybWVkICovCisJdTgJCQlmdW5jdGlvbjsKKwkvKiBUYXNrIE1hbmFnZW1lbnQgcmVzcG9uc2UgdG8gc2VuZCAqLworCXU4CQkJcmVzcG9uc2U7CisJaW50CQkJY2FsbF90cmFuc3BvcnQ7CisJLyogUmVmZXJlbmNlIHRvIElUVCB0aGF0IFRhc2sgTWdtdCBzaG91bGQgYmUgcHJlZm9ybWVkICovCisJdTMyCQkJcmVmX3Rhc2tfdGFnOworCS8qIDY0LWJpdCBlbmNvZGVkIFNBTSBMVU4gZnJvbSAkRkFCUklDX01PRCBUTVIgaGVhZGVyICovCisJdTY0CQkJcmVmX3Rhc2tfbHVuOworCXZvaWQgCQkJKmZhYnJpY190bXJfcHRyOworCXN0cnVjdCBzZV9jbWQJCSp0YXNrX2NtZDsKKwlzdHJ1Y3Qgc2VfY21kCQkqcmVmX2NtZDsKKwlzdHJ1Y3Qgc2VfZGV2aWNlCSp0bXJfZGV2OworCXN0cnVjdCBzZV9sdW4JCSp0bXJfbHVuOworCXN0cnVjdCBsaXN0X2hlYWQJdG1yX2xpc3Q7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworc3RydWN0IHNlX3VhIHsKKwl1OAkJCXVhX2FzYzsKKwl1OAkJCXVhX2FzY3E7CisJc3RydWN0IHNlX25vZGVfYWNsCSp1YV9uYWNsOworCXN0cnVjdCBsaXN0X2hlYWQJdWFfZGV2X2xpc3Q7CisJc3RydWN0IGxpc3RfaGVhZAl1YV9uYWNsX2xpc3Q7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworc3RydWN0IHNlX25vZGVfYWNsIHsKKwljaGFyCQkJaW5pdGlhdG9ybmFtZVtUUkFOU1BPUlRfSVFOX0xFTl07CisJLyogVXNlZCB0byBzaWduYWwgZGVtbyBtb2RlIGNyZWF0ZWQgQUNMLCBkaXNhYmxlZCBieSBkZWZhdWx0ICovCisJaW50CQkJZHluYW1pY19ub2RlX2FjbDoxOworCXUzMgkJCXF1ZXVlX2RlcHRoOworCXUzMgkJCWFjbF9pbmRleDsKKwl1NjQJCQludW1fY21kczsKKwl1NjQJCQlyZWFkX2J5dGVzOworCXU2NAkJCXdyaXRlX2J5dGVzOworCXNwaW5sb2NrX3QJCXN0YXRzX2xvY2s7CisJLyogVXNlZCBmb3IgUFIgU1BFQ19JX1BUPTEgYW5kIFJFR0lTVEVSX0FORF9NT1ZFICovCisJYXRvbWljX3QJCWFjbF9wcl9yZWZfY291bnQ7CisJLyogVXNlZCBmb3IgTUlCIGFjY2VzcyAqLworCWF0b21pY190CQltaWJfcmVmX2NvdW50OworCXN0cnVjdCBzZV9kZXZfZW50cnkJKmRldmljZV9saXN0OworCXN0cnVjdCBzZV9zZXNzaW9uCSpuYWNsX3Nlc3M7CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VfdHBnOworCXNwaW5sb2NrX3QJCWRldmljZV9saXN0X2xvY2s7CisJc3BpbmxvY2tfdAkJbmFjbF9zZXNzX2xvY2s7CisJc3RydWN0IGNvbmZpZ19ncm91cAlhY2xfZ3JvdXA7CisJc3RydWN0IGNvbmZpZ19ncm91cAlhY2xfYXR0cmliX2dyb3VwOworCXN0cnVjdCBjb25maWdfZ3JvdXAJYWNsX2F1dGhfZ3JvdXA7CisJc3RydWN0IGNvbmZpZ19ncm91cAlhY2xfcGFyYW1fZ3JvdXA7CisJc3RydWN0IGNvbmZpZ19ncm91cAkqYWNsX2RlZmF1bHRfZ3JvdXBzWzRdOworCXN0cnVjdCBsaXN0X2hlYWQJYWNsX2xpc3Q7CisJc3RydWN0IGxpc3RfaGVhZAlhY2xfc2Vzc19saXN0OworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKK3N0cnVjdCBzZV9zZXNzaW9uIHsKKwkvKiBVc2VkIGZvciBNSUIgYWNjZXNzICovCisJYXRvbWljX3QJCW1pYl9yZWZfY291bnQ7CisJdTY0CQkJc2Vzc19iaW5faXNpZDsKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wJKnNlX25vZGVfYWNsOworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKnNlX3RwZzsKKwl2b2lkCQkJKmZhYnJpY19zZXNzX3B0cjsKKwlzdHJ1Y3QgbGlzdF9oZWFkCXNlc3NfbGlzdDsKKwlzdHJ1Y3QgbGlzdF9oZWFkCXNlc3NfYWNsX2xpc3Q7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworI2RlZmluZSBTRV9TRVNTKGNtZCkJCSgoc3RydWN0IHNlX3Nlc3Npb24gKikoY21kKS0+c2Vfc2VzcykKKyNkZWZpbmUgU0VfTk9ERV9BQ0woc2VzcykJKChzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKikoc2VzcyktPnNlX25vZGVfYWNsKQorCitzdHJ1Y3Qgc2VfZGV2aWNlOworc3RydWN0IHNlX3RyYW5zZm9ybV9pbmZvOworc3RydWN0IHNjYXR0ZXJsaXN0OworCitzdHJ1Y3Qgc2VfbHVuX2FjbCB7CisJY2hhcgkJCWluaXRpYXRvcm5hbWVbVFJBTlNQT1JUX0lRTl9MRU5dOworCXUzMgkJCW1hcHBlZF9sdW47CisJc3RydWN0IHNlX25vZGVfYWNsCSpzZV9sdW5fbmFjbDsKKwlzdHJ1Y3Qgc2VfbHVuCQkqc2VfbHVuOworCXN0cnVjdCBsaXN0X2hlYWQJbGFjbF9saXN0OworCXN0cnVjdCBjb25maWdfZ3JvdXAJc2VfbHVuX2dyb3VwOworfSAgX19fX2NhY2hlbGluZV9hbGlnbmVkOworCitzdHJ1Y3Qgc2VfZGV2X2VudHJ5IHsKKwlpbnQJCQlkZWZfcHJfcmVnaXN0ZXJlZDoxOworCS8qIFNlZSB0cmFuc3BvcnRfbHVuZmxhZ3NfdGFibGUgKi8KKwl1MzIJCQlsdW5fZmxhZ3M7CisJdTMyCQkJZGV2ZV9jbWRzOworCXUzMgkJCW1hcHBlZF9sdW47CisJdTMyCQkJYXZlcmFnZV9ieXRlczsKKwl1MzIJCQlsYXN0X2J5dGVfY291bnQ7CisJdTMyCQkJdG90YWxfY21kczsKKwl1MzIJCQl0b3RhbF9ieXRlczsKKwl1NjQJCQlwcl9yZXNfa2V5OworCXU2NAkJCWNyZWF0aW9uX3RpbWU7CisJdTMyCQkJYXR0YWNoX2NvdW50OworCXU2NAkJCXJlYWRfYnl0ZXM7CisJdTY0CQkJd3JpdGVfYnl0ZXM7CisJYXRvbWljX3QJCXVhX2NvdW50OworCS8qIFVzZWQgZm9yIFBSIFNQRUNfSV9QVD0xIGFuZCBSRUdJU1RFUl9BTkRfTU9WRSAqLworCWF0b21pY190CQlwcl9yZWZfY291bnQ7CisJc3RydWN0IHNlX2x1bl9hY2wJKnNlX2x1bl9hY2w7CisJc3BpbmxvY2tfdAkJdWFfbG9jazsKKwlzdHJ1Y3Qgc2VfbHVuCQkqc2VfbHVuOworCXN0cnVjdCBsaXN0X2hlYWQJYWx1YV9wb3J0X2xpc3Q7CisJc3RydWN0IGxpc3RfaGVhZAl1YV9saXN0OworfSAgX19fX2NhY2hlbGluZV9hbGlnbmVkOworCitzdHJ1Y3Qgc2VfZGV2X2xpbWl0cyB7CisJLyogTWF4IHN1cHBvcnRlZCBIVyBxdWV1ZSBkZXB0aCAqLworCXUzMgkJaHdfcXVldWVfZGVwdGg7CisJLyogTWF4IHN1cHBvcnRlZCB2aXJ0dWFsIHF1ZXVlIGRlcHRoICovCisJdTMyCQlxdWV1ZV9kZXB0aDsKKwkvKiBGcm9tIGluY2x1ZGUvbGludXgvYmxrZGV2LmggZm9yIHRoZSBvdGhlciBIVy9TVyBsaW1pdHMuICovCisJc3RydWN0IHF1ZXVlX2xpbWl0cyBsaW1pdHM7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworc3RydWN0IHNlX2Rldl9hdHRyaWIgeworCWludAkJZW11bGF0ZV9kcG87CisJaW50CQllbXVsYXRlX2Z1YV93cml0ZTsKKwlpbnQJCWVtdWxhdGVfZnVhX3JlYWQ7CisJaW50CQllbXVsYXRlX3dyaXRlX2NhY2hlOworCWludAkJZW11bGF0ZV91YV9pbnRsY2tfY3RybDsKKwlpbnQJCWVtdWxhdGVfdGFzOworCWludAkJZW11bGF0ZV90cHU7CisJaW50CQllbXVsYXRlX3Rwd3M7CisJaW50CQllbXVsYXRlX3Jlc2VydmF0aW9uczsKKwlpbnQJCWVtdWxhdGVfYWx1YTsKKwlpbnQJCWVuZm9yY2VfcHJfaXNpZHM7CisJdTMyCQlod19ibG9ja19zaXplOworCXUzMgkJYmxvY2tfc2l6ZTsKKwl1MzIJCWh3X21heF9zZWN0b3JzOworCXUzMgkJbWF4X3NlY3RvcnM7CisJdTMyCQlvcHRpbWFsX3NlY3RvcnM7CisJdTMyCQlod19xdWV1ZV9kZXB0aDsKKwl1MzIJCXF1ZXVlX2RlcHRoOworCXUzMgkJdGFza190aW1lb3V0OworCXUzMgkJbWF4X3VubWFwX2xiYV9jb3VudDsKKwl1MzIJCW1heF91bm1hcF9ibG9ja19kZXNjX2NvdW50OworCXUzMgkJdW5tYXBfZ3JhbnVsYXJpdHk7CisJdTMyCQl1bm1hcF9ncmFudWxhcml0eV9hbGlnbm1lbnQ7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKmRhX3N1Yl9kZXY7CisJc3RydWN0IGNvbmZpZ19ncm91cCBkYV9ncm91cDsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCitzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiB7CisvKiBVc2VkIGZvciBzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2Rldi0tPnNlX2Rldl9hbGlhcywgbXVzdCBiZSBsZXNzIHRoYW4gUEFHRV9TSVpFICovCisjZGVmaW5lIFNFX0RFVl9BTElBU19MRU4JCTUxMgorCXVuc2lnbmVkIGNoYXIJc2VfZGV2X2FsaWFzW1NFX0RFVl9BTElBU19MRU5dOworLyogVXNlZCBmb3Igc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYtPnNlX2Rldl91ZGV2X3BhdGhbXSwgbXVzdCBiZSBsZXNzIHRoYW4gUEFHRV9TSVpFICovCisjZGVmaW5lIFNFX1VERVZfUEFUSF9MRU4JCTUxMgorCXVuc2lnbmVkIGNoYXIJc2VfZGV2X3VkZXZfcGF0aFtTRV9VREVWX1BBVEhfTEVOXTsKKwl1MzIJCXN1X2Rldl9mbGFnczsKKwlzdHJ1Y3Qgc2VfaGJhICpzZV9kZXZfaGJhOworCXN0cnVjdCBzZV9kZXZpY2UgKnNlX2Rldl9wdHI7CisJc3RydWN0IHNlX2Rldl9hdHRyaWIgc2VfZGV2X2F0dHJpYjsKKwkvKiBUMTAgQXN5bW1ldHJpYyBMb2dpY2FsIFVuaXQgQXNzaWdubWVudCBmb3IgVGFyZ2V0IFBvcnRzICovCisJc3RydWN0IHQxMF9hbHVhCXQxMF9hbHVhOworCS8qIFQxMCBJbnF1aXJ5IGFuZCBWUEQgV1dOIEluZm9ybWF0aW9uICovCisJc3RydWN0IHQxMF93d24JdDEwX3d3bjsKKwkvKiBUMTAgU1BDLTIgKyBTUEMtMyBSZXNlcnZhdGlvbnMgKi8KKwlzdHJ1Y3QgdDEwX3Jlc2VydmF0aW9uX3RlbXBsYXRlIHQxMF9yZXNlcnZhdGlvbjsKKwlzcGlubG9ja190ICAgICAgc2VfZGV2X2xvY2s7CisJdm9pZCAgICAgICAgICAgICpzZV9kZXZfc3VfcHRyOworCXN0cnVjdCBsaXN0X2hlYWQgZ19zZV9kZXZfbGlzdDsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwIHNlX2Rldl9ncm91cDsKKwkvKiBGb3IgVDEwIFJlc2VydmF0aW9ucyAqLworCXN0cnVjdCBjb25maWdfZ3JvdXAgc2VfZGV2X3ByX2dyb3VwOworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKKyNkZWZpbmUgVDEwX0FMVUEoc3VfZGV2KQkoJihzdV9kZXYpLT50MTBfYWx1YSkKKyNkZWZpbmUgVDEwX1JFUyhzdV9kZXYpCQkoJihzdV9kZXYpLT50MTBfcmVzZXJ2YXRpb24pCisjZGVmaW5lIFQxMF9QUl9PUFMoc3VfZGV2KQkoJihzdV9kZXYpLT50MTBfcmVzZXJ2YXRpb24ucHJfb3BzKQorCitzdHJ1Y3Qgc2VfZGV2aWNlIHsKKwkvKiBTZXQgdG8gMSBpZiB0aHJlYWQgaXMgTk9UIHNsZWVwaW5nIG9uIHRocmVhZF9zZW0gKi8KKwl1OAkJCXRocmVhZF9hY3RpdmU7CisJdTgJCQlkZXZfc3RhdHVzX3RpbWVyX2ZsYWdzOworCS8qIFJFTEFUSVZFIFRBUkdFVCBQT1JUIElERU5USUZFUiBDb3VudGVyICovCisJdTE2CQkJZGV2X3JwdGlfY291bnRlcjsKKwkvKiBVc2VkIGZvciBTQU0gVGFzayBBdHRyaWJ1dGUgb3JkZXJpbmcgKi8KKwl1MzIJCQlkZXZfY3VyX29yZGVyZWRfaWQ7CisJdTMyCQkJZGV2X2ZsYWdzOworCXUzMgkJCWRldl9wb3J0X2NvdW50OworCS8qIFNlZSB0cmFuc3BvcnRfZGV2aWNlX3N0YXR1c190YWJsZSAqLworCXUzMgkJCWRldl9zdGF0dXM7CisJdTMyCQkJZGV2X3RjcV93aW5kb3dfY2xvc2VkOworCS8qIFBoeXNpY2FsIGRldmljZSBxdWV1ZSBkZXB0aCAqLworCXUzMgkJCXF1ZXVlX2RlcHRoOworCS8qIFVzZWQgZm9yIFNQQy0yIHJlc2VydmF0aW9ucyBlbmZvcmNlIG9mIElTSURzICovCisJdTY0CQkJZGV2X3Jlc19iaW5faXNpZDsKKwl0MTBfdGFza19hdHRyX2luZGV4X3QJZGV2X3Rhc2tfYXR0cl90eXBlOworCS8qIFBvaW50ZXIgdG8gdHJhbnNwb3J0IHNwZWNpZmljIGRldmljZSBzdHJ1Y3R1cmUgKi8KKwl2b2lkIAkJCSpkZXZfcHRyOworCXUzMgkJCWRldl9pbmRleDsKKwl1NjQJCQljcmVhdGlvbl90aW1lOworCXUzMgkJCW51bV9yZXNldHM7CisJdTY0CQkJbnVtX2NtZHM7CisJdTY0CQkJcmVhZF9ieXRlczsKKwl1NjQJCQl3cml0ZV9ieXRlczsKKwlzcGlubG9ja190CQlzdGF0c19sb2NrOworCS8qIEFjdGl2ZSBjb21tYW5kcyBvbiB0aGlzIHZpcnR1YWwgU0UgZGV2aWNlICovCisJYXRvbWljX3QJCWFjdGl2ZV9jbWRzOworCWF0b21pY190CQlzaW1wbGVfY21kczsKKwlhdG9taWNfdAkJZGVwdGhfbGVmdDsKKwlhdG9taWNfdAkJZGV2X29yZGVyZWRfaWQ7CisJYXRvbWljX3QJCWRldl90dXJfYWN0aXZlOworCWF0b21pY190CQlleGVjdXRlX3Rhc2tzOworCWF0b21pY190CQlkZXZfc3RhdHVzX3Rocl9jb3VudDsKKwlhdG9taWNfdAkJZGV2X2hvcV9jb3VudDsKKwlhdG9taWNfdAkJZGV2X29yZGVyZWRfc3luYzsKKwlzdHJ1Y3Qgc2Vfb2JqCQlkZXZfb2JqOworCXN0cnVjdCBzZV9vYmoJCWRldl9hY2Nlc3Nfb2JqOworCXN0cnVjdCBzZV9vYmoJCWRldl9leHBvcnRfb2JqOworCXN0cnVjdCBzZV9xdWV1ZV9vYmoJKmRldl9xdWV1ZV9vYmo7CisJc3RydWN0IHNlX3F1ZXVlX29iagkqZGV2X3N0YXR1c19xdWV1ZV9vYmo7CisJc3BpbmxvY2tfdAkJZGVsYXllZF9jbWRfbG9jazsKKwlzcGlubG9ja190CQlvcmRlcmVkX2NtZF9sb2NrOworCXNwaW5sb2NrX3QJCWV4ZWN1dGVfdGFza19sb2NrOworCXNwaW5sb2NrX3QJCXN0YXRlX3Rhc2tfbG9jazsKKwlzcGlubG9ja190CQlkZXZfYWx1YV9sb2NrOworCXNwaW5sb2NrX3QJCWRldl9yZXNlcnZhdGlvbl9sb2NrOworCXNwaW5sb2NrX3QJCWRldl9zdGF0ZV9sb2NrOworCXNwaW5sb2NrX3QJCWRldl9zdGF0dXNfbG9jazsKKwlzcGlubG9ja190CQlkZXZfc3RhdHVzX3Rocl9sb2NrOworCXNwaW5sb2NrX3QJCXNlX3BvcnRfbG9jazsKKwlzcGlubG9ja190CQlzZV90bXJfbG9jazsKKwkvKiBVc2VkIGZvciBsZWdhY3kgU1BDLTIgcmVzZXJ2YXRpb25zYSAqLworCXN0cnVjdCBzZV9ub2RlX2FjbAkqZGV2X3Jlc2VydmVkX25vZGVfYWNsOworCS8qIFVzZWQgZm9yIEFMVUEgTG9naWNhbCBVbml0IEdyb3VwIG1lbWJlcnNoaXAgKi8KKwlzdHJ1Y3QgdDEwX2FsdWFfbHVfZ3BfbWVtYmVyICpkZXZfYWx1YV9sdV9ncF9tZW07CisJLyogVXNlZCBmb3IgU1BDLTMgUGVyc2lzdGVudCBSZXNlcnZhdGlvbnMgKi8KKwlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqZGV2X3ByX3Jlc19ob2xkZXI7CisJc3RydWN0IGxpc3RfaGVhZAlkZXZfc2VwX2xpc3Q7CisJc3RydWN0IGxpc3RfaGVhZAlkZXZfdG1yX2xpc3Q7CisJc3RydWN0IHRpbWVyX2xpc3QJZGV2X3N0YXR1c190aW1lcjsKKwkvKiBQb2ludGVyIHRvIGRlc2NyaXB0b3IgZm9yIHByb2Nlc3NpbmcgdGhyZWFkICovCisJc3RydWN0IHRhc2tfc3RydWN0CSpwcm9jZXNzX3RocmVhZDsKKwlwaWRfdAkJCXByb2Nlc3NfdGhyZWFkX3BpZDsKKwlzdHJ1Y3QgdGFza19zdHJ1Y3QJCSpkZXZfbWdtdF90aHJlYWQ7CisJc3RydWN0IGxpc3RfaGVhZAlkZWxheWVkX2NtZF9saXN0OworCXN0cnVjdCBsaXN0X2hlYWQJb3JkZXJlZF9jbWRfbGlzdDsKKwlzdHJ1Y3QgbGlzdF9oZWFkCWV4ZWN1dGVfdGFza19saXN0OworCXN0cnVjdCBsaXN0X2hlYWQJc3RhdGVfdGFza19saXN0OworCS8qIFBvaW50ZXIgdG8gYXNzb2NpYXRlZCBTRSBIQkEgKi8KKwlzdHJ1Y3Qgc2VfaGJhCQkqc2VfaGJhOworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICpzZV9zdWJfZGV2OworCS8qIFBvaW50ZXIgdG8gdGVtcGxhdGUgb2YgZnVuY3Rpb24gcG9pbnRlcnMgZm9yIHRyYW5zcG9ydCAqLworCXN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpICp0cmFuc3BvcnQ7CisJLyogTGlua2VkIGxpc3QgZm9yIHN0cnVjdCBzZV9oYmEgc3RydWN0IHNlX2RldmljZSBsaXN0ICovCisJc3RydWN0IGxpc3RfaGVhZAlkZXZfbGlzdDsKKwkvKiBMaW5rZWQgbGlzdCBmb3Igc3RydWN0IHNlX2dsb2JhbC0+Z19zZV9kZXZfbGlzdCAqLworCXN0cnVjdCBsaXN0X2hlYWQJZ19zZV9kZXZfbGlzdDsKK30gIF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworI2RlZmluZSBTRV9ERVYoY21kKQkJKChzdHJ1Y3Qgc2VfZGV2aWNlICopKGNtZCktPnNlX2x1bi0+bHVuX3NlX2RldikKKyNkZWZpbmUgU1VfREVWKGRldikJCSgoc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKikoZGV2KS0+c2Vfc3ViX2RldikKKyNkZWZpbmUgREVWX0FUVFJJQihkZXYpCQkoJihkZXYpLT5zZV9zdWJfZGV2LT5zZV9kZXZfYXR0cmliKQorI2RlZmluZSBERVZfVDEwX1dXTihkZXYpCSgmKGRldiktPnNlX3N1Yl9kZXYtPnQxMF93d24pCisKK3N0cnVjdCBzZV9oYmEgeworCXUxNgkJCWhiYV90cGd0OworCXUzMgkJCWhiYV9pZDsKKwkvKiBTZWUgaGJhX2ZsYWdzX3RhYmxlICovCisJdTMyCQkJaGJhX2ZsYWdzOworCS8qIFZpcnR1YWwgaVNDU0kgZGV2aWNlcyBhdHRhY2hlZC4gKi8KKwl1MzIJCQlkZXZfY291bnQ7CisJdTMyCQkJaGJhX2luZGV4OworCWF0b21pY190CQlkZXZfbWliX2FjY2Vzc19jb3VudDsKKwlhdG9taWNfdAkJbG9hZF9iYWxhbmNlX3F1ZXVlOworCWF0b21pY190CQlsZWZ0X3F1ZXVlX2RlcHRoOworCS8qIE1heGltdW0gcXVldWUgZGVwdGggdGhlIEhCQSBjYW4gaGFuZGxlLiAqLworCWF0b21pY190CQltYXhfcXVldWVfZGVwdGg7CisJLyogUG9pbnRlciB0byB0cmFuc3BvcnQgc3BlY2lmaWMgaG9zdCBzdHJ1Y3R1cmUuICovCisJdm9pZAkJCSpoYmFfcHRyOworCS8qIExpbmtlZCBsaXN0IGZvciBzdHJ1Y3Qgc2VfZGV2aWNlICovCisJc3RydWN0IGxpc3RfaGVhZAloYmFfZGV2X2xpc3Q7CisJc3RydWN0IGxpc3RfaGVhZAloYmFfbGlzdDsKKwlzcGlubG9ja190CQlkZXZpY2VfbG9jazsKKwlzcGlubG9ja190CQloYmFfcXVldWVfbG9jazsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwCWhiYV9ncm91cDsKKwlzdHJ1Y3QgbXV0ZXgJCWhiYV9hY2Nlc3NfbXV0ZXg7CisJc3RydWN0IHNlX3N1YnN5c3RlbV9hcGkgKnRyYW5zcG9ydDsKK30gIF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworI2RlZmluZSBTRV9IQkEoZCkJCSgoc3RydWN0IHNlX2hiYSAqKShkKS0+c2VfaGJhKQorCitzdHJ1Y3Qgc2VfbHVuIHsKKwkvKiBTZWUgdHJhbnNwb3J0X2x1bl9zdGF0dXNfdGFibGUgKi8KKwllbnVtIHRyYW5zcG9ydF9sdW5fc3RhdHVzX3RhYmxlIGx1bl9zdGF0dXM7CisJdTMyCQkJbHVuX2FjY2VzczsKKwl1MzIJCQlsdW5fZmxhZ3M7CisJdTMyCQkJdW5wYWNrZWRfbHVuOworCWF0b21pY190CQlsdW5fYWNsX2NvdW50OworCXNwaW5sb2NrX3QJCWx1bl9hY2xfbG9jazsKKwlzcGlubG9ja190CQlsdW5fY21kX2xvY2s7CisJc3BpbmxvY2tfdAkJbHVuX3NlcF9sb2NrOworCXN0cnVjdCBjb21wbGV0aW9uCWx1bl9zaHV0ZG93bl9jb21wOworCXN0cnVjdCBsaXN0X2hlYWQJbHVuX2NtZF9saXN0OworCXN0cnVjdCBsaXN0X2hlYWQJbHVuX2FjbF9saXN0OworCXN0cnVjdCBzZV9kZXZpY2UJKmx1bl9zZV9kZXY7CisJc3RydWN0IGNvbmZpZ19ncm91cAlsdW5fZ3JvdXA7CisJc3RydWN0IHNlX3BvcnQJKmx1bl9zZXA7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworI2RlZmluZSBTRV9MVU4oYykJCSgoc3RydWN0IHNlX2x1biAqKShjKS0+c2VfbHVuKQorCitzdHJ1Y3Qgc2VfcG9ydCB7CisJLyogUkVMQVRJVkUgVEFSR0VUIFBPUlQgSURFTlRJRkVSICovCisJdTE2CQlzZXBfcnRwaTsKKwlpbnQJCXNlcF90Z19wdF9zZWNvbmRhcnlfc3RhdDsKKwlpbnQJCXNlcF90Z19wdF9zZWNvbmRhcnlfd3JpdGVfbWQ7CisJdTMyCQlzZXBfaW5kZXg7CisJc3RydWN0IHNjc2lfcG9ydF9zdGF0cyBzZXBfc3RhdHM7CisJLyogVXNlZCBmb3IgQUxVQSBUYXJnZXQgUG9ydCBHcm91cHMgbWVtYmVyc2hpcCAqLworCWF0b21pY190CXNlcF90Z19wdF9ncF9hY3RpdmU7CisJYXRvbWljX3QJc2VwX3RnX3B0X3NlY29uZGFyeV9vZmZsaW5lOworCS8qIFVzZWQgZm9yIFBSIEFMTF9UR19QVD0xICovCisJYXRvbWljX3QJc2VwX3RnX3B0X3JlZl9jbnQ7CisJc3BpbmxvY2tfdAlzZXBfYWx1YV9sb2NrOworCXN0cnVjdCBtdXRleAlzZXBfdGdfcHRfbWRfbXV0ZXg7CisJc3RydWN0IHQxMF9hbHVhX3RnX3B0X2dwX21lbWJlciAqc2VwX2FsdWFfdGdfcHRfZ3BfbWVtOworCXN0cnVjdCBzZV9sdW4gKnNlcF9sdW47CisJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqc2VwX3RwZzsKKwlzdHJ1Y3QgbGlzdF9oZWFkIHNlcF9hbHVhX2xpc3Q7CisJc3RydWN0IGxpc3RfaGVhZCBzZXBfbGlzdDsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCitzdHJ1Y3Qgc2VfdHBnX25wIHsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwCXRwZ19ucF9ncm91cDsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCitzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwIHsKKwkvKiBUeXBlIG9mIHRhcmdldCBwb3J0YWwgZ3JvdXAsIHNlZSB0cmFuc3BvcnRfdHBnX3R5cGVfdGFibGUgKi8KKwllbnVtIHRyYW5zcG9ydF90cGdfdHlwZV90YWJsZSBzZV90cGdfdHlwZTsKKwkvKiBOdW1iZXIgb2YgQUNMZWQgSW5pdGlhdG9yIE5vZGVzIGZvciB0aGlzIFRQRyAqLworCXUzMgkJCW51bV9ub2RlX2FjbHM7CisJLyogVXNlZCBmb3IgUFIgU1BFQ19JX1BUPTEgYW5kIFJFR0lTVEVSX0FORF9NT1ZFICovCisJYXRvbWljX3QJCXRwZ19wcl9yZWZfY291bnQ7CisJLyogU3BpbmxvY2sgZm9yIGFkZGluZy9yZW1vdmluZyBBQ0xlZCBOb2RlcyAqLworCXNwaW5sb2NrX3QJCWFjbF9ub2RlX2xvY2s7CisJLyogU3BpbmxvY2sgZm9yIGFkZGluZy9yZW1vdmluZyBzZXNzaW9ucyAqLworCXNwaW5sb2NrX3QJCXNlc3Npb25fbG9jazsKKwlzcGlubG9ja190CQl0cGdfbHVuX2xvY2s7CisJLyogUG9pbnRlciB0byAkRkFCUklDX01PRCBwb3J0YWwgZ3JvdXAgKi8KKwl2b2lkCQkJKnNlX3RwZ19mYWJyaWNfcHRyOworCXN0cnVjdCBsaXN0X2hlYWQJc2VfdHBnX2xpc3Q7CisJLyogbGlua2VkIGxpc3QgZm9yIGluaXRpYXRvciBBQ0wgbGlzdCAqLworCXN0cnVjdCBsaXN0X2hlYWQJYWNsX25vZGVfbGlzdDsKKwlzdHJ1Y3Qgc2VfbHVuCQkqdHBnX2x1bl9saXN0OworCXN0cnVjdCBzZV9sdW4JCXRwZ192aXJ0X2x1bjA7CisJLyogTGlzdCBvZiBUQ00gc2Vzc2lvbnMgYXNzb2ljYXRlZCB3dGggdGhpcyBUUEcgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkCXRwZ19zZXNzX2xpc3Q7CisJLyogUG9pbnRlciB0byAkRkFCUklDX01PRCBkZXBlbmRlbnQgY29kZSAqLworCXN0cnVjdCB0YXJnZXRfY29yZV9mYWJyaWNfb3BzICpzZV90cGdfdGZvOworCXN0cnVjdCBzZV93d24JCSpzZV90cGdfd3duOworCXN0cnVjdCBjb25maWdfZ3JvdXAJdHBnX2dyb3VwOworCXN0cnVjdCBjb25maWdfZ3JvdXAJKnRwZ19kZWZhdWx0X2dyb3Vwc1s2XTsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwCXRwZ19sdW5fZ3JvdXA7CisJc3RydWN0IGNvbmZpZ19ncm91cAl0cGdfbnBfZ3JvdXA7CisJc3RydWN0IGNvbmZpZ19ncm91cAl0cGdfYWNsX2dyb3VwOworCXN0cnVjdCBjb25maWdfZ3JvdXAJdHBnX2F0dHJpYl9ncm91cDsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwCXRwZ19wYXJhbV9ncm91cDsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkOworCisjZGVmaW5lIFRQR19URk8oc2VfdHBnKQkoKHN0cnVjdCB0YXJnZXRfY29yZV9mYWJyaWNfb3BzICopKHNlX3RwZyktPnNlX3RwZ190Zm8pCisKK3N0cnVjdCBzZV93d24geworCXN0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzICp3d25fdGY7CisJc3RydWN0IGNvbmZpZ19ncm91cAl3d25fZ3JvdXA7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworc3RydWN0IHNlX2dsb2JhbCB7CisJdTE2CQkJYWx1YV9sdV9ncHNfY291bnRlcjsKKwlpbnQJCQlnX3N1Yl9hcGlfaW5pdGlhbGl6ZWQ7CisJdTMyCQkJaW5fc2h1dGRvd247CisJdTMyCQkJYWx1YV9sdV9ncHNfY291bnQ7CisJdTMyCQkJZ19oYmFfaWRfY291bnRlcjsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwCXRhcmdldF9jb3JlX2hiYWdyb3VwOworCXN0cnVjdCBjb25maWdfZ3JvdXAJYWx1YV9ncm91cDsKKwlzdHJ1Y3QgY29uZmlnX2dyb3VwCWFsdWFfbHVfZ3BzX2dyb3VwOworCXN0cnVjdCBsaXN0X2hlYWQJZ19sdV9ncHNfbGlzdDsKKwlzdHJ1Y3QgbGlzdF9oZWFkCWdfc2VfdHBnX2xpc3Q7CisJc3RydWN0IGxpc3RfaGVhZAlnX2hiYV9saXN0OworCXN0cnVjdCBsaXN0X2hlYWQJZ19zZV9kZXZfbGlzdDsKKwlzdHJ1Y3Qgc2VfaGJhCQkqZ19sdW4wX2hiYTsKKwlzdHJ1Y3Qgc2Vfc3Vic3lzdGVtX2RldiAqZ19sdW4wX3N1X2RldjsKKwlzdHJ1Y3Qgc2VfZGV2aWNlCSpnX2x1bjBfZGV2OworCXN0cnVjdCB0MTBfYWx1YV9sdV9ncAkqZGVmYXVsdF9sdV9ncDsKKwlzcGlubG9ja190CQlnX2RldmljZV9sb2NrOworCXNwaW5sb2NrX3QJCWhiYV9sb2NrOworCXNwaW5sb2NrX3QJCXNlX3RwZ19sb2NrOworCXNwaW5sb2NrX3QJCWx1X2dwc19sb2NrOworCXNwaW5sb2NrX3QJCXBsdWdpbl9jbGFzc19sb2NrOworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKKyNlbmRpZiAvKiBUQVJHRVRfQ09SRV9CQVNFX0ggKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX2NvbmZpZ2ZzLmggYi9pbmNsdWRlL3RhcmdldC90YXJnZXRfY29yZV9jb25maWdmcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQwZTZlNzQKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL3RhcmdldC90YXJnZXRfY29yZV9jb25maWdmcy5oCkBAIC0wLDAgKzEsNTIgQEAKKyNkZWZpbmUgVEFSR0VUX0NPUkVfQ09ORklHRlNfVkVSU0lPTiBUQVJHRVRfQ09SRV9NT0RfVkVSU0lPTgorCisjZGVmaW5lIFRBUkdFVF9DT1JFX0NPTkZJR19ST09UCSIvc3lzL2tlcm5lbC9jb25maWciCisKKyNkZWZpbmUgVEFSR0VUX0NPUkVfTkFNRV9NQVhfTEVOCTY0CisjZGVmaW5lIFRBUkdFVF9GQUJSSUNfTkFNRV9TSVpFCQkzMgorCitleHRlcm4gc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKnRhcmdldF9mYWJyaWNfY29uZmlnZnNfaW5pdCgKKwkJCQlzdHJ1Y3QgbW9kdWxlICosIGNvbnN0IGNoYXIgKik7CitleHRlcm4gdm9pZCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzX2ZyZWUoc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKik7CitleHRlcm4gaW50IHRhcmdldF9mYWJyaWNfY29uZmlnZnNfcmVnaXN0ZXIoc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKik7CitleHRlcm4gdm9pZCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzX2RlcmVnaXN0ZXIoc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKik7CisKK3N0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzX3RlbXBsYXRlIHsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0ZmNfZGlzY292ZXJ5X2NpdDsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZQl0ZmNfd3duX2NpdDsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0ZmNfdHBnX2NpdDsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0ZmNfdHBnX2Jhc2VfY2l0OworCXN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRmY190cGdfbHVuX2NpdDsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0ZmNfdHBnX3BvcnRfY2l0OworCXN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRmY190cGdfbnBfY2l0OworCXN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRmY190cGdfbnBfYmFzZV9jaXQ7CisJc3RydWN0IGNvbmZpZ19pdGVtX3R5cGUgdGZjX3RwZ19hdHRyaWJfY2l0OworCXN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRmY190cGdfcGFyYW1fY2l0OworCXN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRmY190cGdfbmFjbF9jaXQ7CisJc3RydWN0IGNvbmZpZ19pdGVtX3R5cGUgdGZjX3RwZ19uYWNsX2Jhc2VfY2l0OworCXN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRmY190cGdfbmFjbF9hdHRyaWJfY2l0OworCXN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRmY190cGdfbmFjbF9hdXRoX2NpdDsKKwlzdHJ1Y3QgY29uZmlnX2l0ZW1fdHlwZSB0ZmNfdHBnX25hY2xfcGFyYW1fY2l0OworCXN0cnVjdCBjb25maWdfaXRlbV90eXBlIHRmY190cGdfbWFwcGVkbHVuX2NpdDsKK307CisKK3N0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzIHsKKwljaGFyCQkJdGZfbmFtZVtUQVJHRVRfRkFCUklDX05BTUVfU0laRV07CisJYXRvbWljX3QJCXRmX2FjY2Vzc19jbnQ7CisJc3RydWN0IGxpc3RfaGVhZAl0Zl9saXN0OworCXN0cnVjdCBjb25maWdfZ3JvdXAJdGZfZ3JvdXA7CisJc3RydWN0IGNvbmZpZ19ncm91cAl0Zl9kaXNjX2dyb3VwOworCXN0cnVjdCBjb25maWdfZ3JvdXAJKnRmX2RlZmF1bHRfZ3JvdXBzWzJdOworCS8qIFBvaW50ZXIgdG8gZmFicmljJ3MgY29uZmlnX2l0ZW0gKi8KKwlzdHJ1Y3QgY29uZmlnX2l0ZW0JKnRmX2ZhYnJpYzsKKwkvKiBQYXNzZWQgZnJvbSBmYWJyaWMgbW9kdWxlcyAqLworCXN0cnVjdCBjb25maWdfaXRlbV90eXBlCSp0Zl9mYWJyaWNfY2l0OworCS8qIFBvaW50ZXIgdG8gdGFyZ2V0IGNvcmUgc3Vic3lzdGVtICovCisJc3RydWN0IGNvbmZpZ2ZzX3N1YnN5c3RlbSAqdGZfc3Vic3lzOworCS8qIFBvaW50ZXIgdG8gZmFicmljJ3Mgc3RydWN0IG1vZHVsZSAqLworCXN0cnVjdCBtb2R1bGUgKnRmX21vZHVsZTsKKwlzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcyB0Zl9vcHM7CisJc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnNfdGVtcGxhdGUgdGZfY2l0X3RtcGw7Cit9OworCisjZGVmaW5lIFRGX0NJVF9UTVBMKHRmKSAoJih0ZiktPnRmX2NpdF90bXBsKQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS90YXJnZXQvdGFyZ2V0X2NvcmVfZGV2aWNlLmggYi9pbmNsdWRlL3RhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41MmIxOGE1Ci0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS90YXJnZXQvdGFyZ2V0X2NvcmVfZGV2aWNlLmgKQEAgLTAsMCArMSw2MSBAQAorI2lmbmRlZiBUQVJHRVRfQ09SRV9ERVZJQ0VfSAorI2RlZmluZSBUQVJHRVRfQ09SRV9ERVZJQ0VfSAorCitleHRlcm4gaW50IHRyYW5zcG9ydF9nZXRfbHVuX2Zvcl9jbWQoc3RydWN0IHNlX2NtZCAqLCB1bnNpZ25lZCBjaGFyICosIHUzMik7CitleHRlcm4gaW50IHRyYW5zcG9ydF9nZXRfbHVuX2Zvcl90bXIoc3RydWN0IHNlX2NtZCAqLCB1MzIpOworZXh0ZXJuIHN0cnVjdCBzZV9kZXZfZW50cnkgKmNvcmVfZ2V0X3NlX2RldmVfZnJvbV9ydHBpKAorCQkJCQlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKiwgdTE2KTsKK2V4dGVybiBpbnQgY29yZV9mcmVlX2RldmljZV9saXN0X2Zvcl9ub2RlKHN0cnVjdCBzZV9ub2RlX2FjbCAqLAorCQkJCQlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICopOworZXh0ZXJuIHZvaWQgY29yZV9kZWNfbGFjbF9jb3VudChzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKiwgc3RydWN0IHNlX2NtZCAqKTsKK2V4dGVybiB2b2lkIGNvcmVfdXBkYXRlX2RldmljZV9saXN0X2FjY2Vzcyh1MzIsIHUzMiwgc3RydWN0IHNlX25vZGVfYWNsICopOworZXh0ZXJuIGludCBjb3JlX3VwZGF0ZV9kZXZpY2VfbGlzdF9mb3Jfbm9kZShzdHJ1Y3Qgc2VfbHVuICosIHN0cnVjdCBzZV9sdW5fYWNsICosIHUzMiwKKwkJCQkJdTMyLCBzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKiwKKwkJCQkJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLCBpbnQpOworZXh0ZXJuIHZvaWQgY29yZV9jbGVhcl9sdW5fZnJvbV90cGcoc3RydWN0IHNlX2x1biAqLCBzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICopOworZXh0ZXJuIGludCBjb3JlX2Rldl9leHBvcnQoc3RydWN0IHNlX2RldmljZSAqLCBzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICosCisJCQkJCXN0cnVjdCBzZV9sdW4gKik7CitleHRlcm4gdm9pZCBjb3JlX2Rldl91bmV4cG9ydChzdHJ1Y3Qgc2VfZGV2aWNlICosIHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKiwKKwkJCQkJc3RydWN0IHNlX2x1biAqKTsKK2V4dGVybiBpbnQgdHJhbnNwb3J0X2NvcmVfcmVwb3J0X2x1bl9yZXNwb25zZShzdHJ1Y3Qgc2VfY21kICopOworZXh0ZXJuIHZvaWQgc2VfcmVsZWFzZV9kZXZpY2VfZm9yX2hiYShzdHJ1Y3Qgc2VfZGV2aWNlICopOworZXh0ZXJuIHZvaWQgc2VfcmVsZWFzZV92cGRfZm9yX2RldihzdHJ1Y3Qgc2VfZGV2aWNlICopOworZXh0ZXJuIHZvaWQgc2VfY2xlYXJfZGV2X3BvcnRzKHN0cnVjdCBzZV9kZXZpY2UgKik7CitleHRlcm4gaW50IHNlX2ZyZWVfdmlydHVhbF9kZXZpY2Uoc3RydWN0IHNlX2RldmljZSAqLCBzdHJ1Y3Qgc2VfaGJhICopOworZXh0ZXJuIGludCBzZV9kZXZfY2hlY2tfb25saW5lKHN0cnVjdCBzZV9kZXZpY2UgKik7CitleHRlcm4gaW50IHNlX2Rldl9jaGVja19zaHV0ZG93bihzdHJ1Y3Qgc2VfZGV2aWNlICopOworZXh0ZXJuIHZvaWQgc2VfZGV2X3NldF9kZWZhdWx0X2F0dHJpYnMoc3RydWN0IHNlX2RldmljZSAqLCBzdHJ1Y3Qgc2VfZGV2X2xpbWl0cyAqKTsKK2V4dGVybiBpbnQgc2VfZGV2X3NldF90YXNrX3RpbWVvdXQoc3RydWN0IHNlX2RldmljZSAqLCB1MzIpOworZXh0ZXJuIGludCBzZV9kZXZfc2V0X21heF91bm1hcF9sYmFfY291bnQoc3RydWN0IHNlX2RldmljZSAqLCB1MzIpOworZXh0ZXJuIGludCBzZV9kZXZfc2V0X21heF91bm1hcF9ibG9ja19kZXNjX2NvdW50KHN0cnVjdCBzZV9kZXZpY2UgKiwgdTMyKTsKK2V4dGVybiBpbnQgc2VfZGV2X3NldF91bm1hcF9ncmFudWxhcml0eShzdHJ1Y3Qgc2VfZGV2aWNlICosIHUzMik7CitleHRlcm4gaW50IHNlX2Rldl9zZXRfdW5tYXBfZ3JhbnVsYXJpdHlfYWxpZ25tZW50KHN0cnVjdCBzZV9kZXZpY2UgKiwgdTMyKTsKK2V4dGVybiBpbnQgc2VfZGV2X3NldF9lbXVsYXRlX2RwbyhzdHJ1Y3Qgc2VfZGV2aWNlICosIGludCk7CitleHRlcm4gaW50IHNlX2Rldl9zZXRfZW11bGF0ZV9mdWFfd3JpdGUoc3RydWN0IHNlX2RldmljZSAqLCBpbnQpOworZXh0ZXJuIGludCBzZV9kZXZfc2V0X2VtdWxhdGVfZnVhX3JlYWQoc3RydWN0IHNlX2RldmljZSAqLCBpbnQpOworZXh0ZXJuIGludCBzZV9kZXZfc2V0X2VtdWxhdGVfd3JpdGVfY2FjaGUoc3RydWN0IHNlX2RldmljZSAqLCBpbnQpOworZXh0ZXJuIGludCBzZV9kZXZfc2V0X2VtdWxhdGVfdWFfaW50bGNrX2N0cmwoc3RydWN0IHNlX2RldmljZSAqLCBpbnQpOworZXh0ZXJuIGludCBzZV9kZXZfc2V0X2VtdWxhdGVfdGFzKHN0cnVjdCBzZV9kZXZpY2UgKiwgaW50KTsKK2V4dGVybiBpbnQgc2VfZGV2X3NldF9lbXVsYXRlX3RwdShzdHJ1Y3Qgc2VfZGV2aWNlICosIGludCk7CitleHRlcm4gaW50IHNlX2Rldl9zZXRfZW11bGF0ZV90cHdzKHN0cnVjdCBzZV9kZXZpY2UgKiwgaW50KTsKK2V4dGVybiBpbnQgc2VfZGV2X3NldF9lbmZvcmNlX3ByX2lzaWRzKHN0cnVjdCBzZV9kZXZpY2UgKiwgaW50KTsKK2V4dGVybiBpbnQgc2VfZGV2X3NldF9xdWV1ZV9kZXB0aChzdHJ1Y3Qgc2VfZGV2aWNlICosIHUzMik7CitleHRlcm4gaW50IHNlX2Rldl9zZXRfbWF4X3NlY3RvcnMoc3RydWN0IHNlX2RldmljZSAqLCB1MzIpOworZXh0ZXJuIGludCBzZV9kZXZfc2V0X29wdGltYWxfc2VjdG9ycyhzdHJ1Y3Qgc2VfZGV2aWNlICosIHUzMik7CitleHRlcm4gaW50IHNlX2Rldl9zZXRfYmxvY2tfc2l6ZShzdHJ1Y3Qgc2VfZGV2aWNlICosIHUzMik7CitleHRlcm4gc3RydWN0IHNlX2x1biAqY29yZV9kZXZfYWRkX2x1bihzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICosIHN0cnVjdCBzZV9oYmEgKiwKKwkJCQkJc3RydWN0IHNlX2RldmljZSAqLCB1MzIpOworZXh0ZXJuIGludCBjb3JlX2Rldl9kZWxfbHVuKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKiwgdTMyKTsKK2V4dGVybiBzdHJ1Y3Qgc2VfbHVuICpjb3JlX2dldF9sdW5fZnJvbV90cGcoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLCB1MzIpOworZXh0ZXJuIHN0cnVjdCBzZV9sdW5fYWNsICpjb3JlX2Rldl9pbml0X2luaXRpYXRvcl9ub2RlX2x1bl9hY2woc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLAorCQkJCQkJCXUzMiwgY2hhciAqLCBpbnQgKik7CitleHRlcm4gaW50IGNvcmVfZGV2X2FkZF9pbml0aWF0b3Jfbm9kZV9sdW5fYWNsKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKiwKKwkJCQkJCXN0cnVjdCBzZV9sdW5fYWNsICosIHUzMiwgdTMyKTsKK2V4dGVybiBpbnQgY29yZV9kZXZfZGVsX2luaXRpYXRvcl9ub2RlX2x1bl9hY2woc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLAorCQkJCQkJc3RydWN0IHNlX2x1biAqLCBzdHJ1Y3Qgc2VfbHVuX2FjbCAqKTsKK2V4dGVybiB2b2lkIGNvcmVfZGV2X2ZyZWVfaW5pdGlhdG9yX25vZGVfbHVuX2FjbChzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICosCisJCQkJCQlzdHJ1Y3Qgc2VfbHVuX2FjbCAqbGFjbCk7CitleHRlcm4gaW50IGNvcmVfZGV2X3NldHVwX3ZpcnR1YWxfbHVuMCh2b2lkKTsKK2V4dGVybiB2b2lkIGNvcmVfZGV2X3JlbGVhc2VfdmlydHVhbF9sdW4wKHZvaWQpOworCisjZW5kaWYgLyogVEFSR0VUX0NPUkVfREVWSUNFX0ggKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19jb25maWdmcy5oIGIvaW5jbHVkZS90YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX2NvbmZpZ2ZzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTI2ZmI3NQotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19jb25maWdmcy5oCkBAIC0wLDAgKzEsMTA2IEBACisvKgorICogVXNlZCBmb3IgdGZjX3d3bl9jaXQgYXR0cmlidXRlcworICovCisKKyNpbmNsdWRlIDx0YXJnZXQvY29uZmlnZnNfbWFjcm9zLmg+CisKK0NPTkZJR0ZTX0VBVFRSX1NUUlVDVCh0YXJnZXRfZmFicmljX25hY2xfYXR0cmliLCBzZV9ub2RlX2FjbCk7CisjZGVmaW5lIFRGX05BQ0xfQVRUUklCX0FUVFIoX2ZhYnJpYywgX25hbWUsIF9tb2RlKQkJCVwKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19uYWNsX2F0dHJpYl9hdHRyaWJ1dGUgX2ZhYnJpYyMjX25hY2xfYXR0cmliXyMjX25hbWUgPSBcCisJX19DT05GSUdGU19FQVRUUihfbmFtZSwgX21vZGUsCQkJCQlcCisJX2ZhYnJpYyMjX25hY2xfYXR0cmliX3Nob3dfIyNfbmFtZSwJCQkJXAorCV9mYWJyaWMjI19uYWNsX2F0dHJpYl9zdG9yZV8jI19uYW1lKTsKKworQ09ORklHRlNfRUFUVFJfU1RSVUNUKHRhcmdldF9mYWJyaWNfbmFjbF9hdXRoLCBzZV9ub2RlX2FjbCk7CisjZGVmaW5lIFRGX05BQ0xfQVVUSF9BVFRSKF9mYWJyaWMsIF9uYW1lLCBfbW9kZSkJCQlcCitzdGF0aWMgc3RydWN0IHRhcmdldF9mYWJyaWNfbmFjbF9hdXRoX2F0dHJpYnV0ZSBfZmFicmljIyNfbmFjbF9hdXRoXyMjX25hbWUgPSBcCisJX19DT05GSUdGU19FQVRUUihfbmFtZSwgX21vZGUsCQkJCQlcCisJX2ZhYnJpYyMjX25hY2xfYXV0aF9zaG93XyMjX25hbWUsCQkJCVwKKwlfZmFicmljIyNfbmFjbF9hdXRoX3N0b3JlXyMjX25hbWUpOworCisjZGVmaW5lIFRGX05BQ0xfQVVUSF9BVFRSX1JPKF9mYWJyaWMsIF9uYW1lKQkJCQlcCitzdGF0aWMgc3RydWN0IHRhcmdldF9mYWJyaWNfbmFjbF9hdXRoX2F0dHJpYnV0ZSBfZmFicmljIyNfbmFjbF9hdXRoXyMjX25hbWUgPSBcCisJX19DT05GSUdGU19FQVRUUl9STyhfbmFtZSwJCQkJCVwKKwlfZmFicmljIyNfbmFjbF9hdXRoX3Nob3dfIyNfbmFtZSk7CisKK0NPTkZJR0ZTX0VBVFRSX1NUUlVDVCh0YXJnZXRfZmFicmljX25hY2xfcGFyYW0sIHNlX25vZGVfYWNsKTsKKyNkZWZpbmUgVEZfTkFDTF9QQVJBTV9BVFRSKF9mYWJyaWMsIF9uYW1lLCBfbW9kZSkJCQlcCitzdGF0aWMgc3RydWN0IHRhcmdldF9mYWJyaWNfbmFjbF9wYXJhbV9hdHRyaWJ1dGUgX2ZhYnJpYyMjX25hY2xfcGFyYW1fIyNfbmFtZSA9IFwKKwlfX0NPTkZJR0ZTX0VBVFRSKF9uYW1lLCBfbW9kZSwJCQkJCVwKKwlfZmFicmljIyNfbmFjbF9wYXJhbV9zaG93XyMjX25hbWUsCQkJCVwKKwlfZmFicmljIyNfbmFjbF9wYXJhbV9zdG9yZV8jI19uYW1lKTsKKworI2RlZmluZSBURl9OQUNMX1BBUkFNX0FUVFJfUk8oX2ZhYnJpYywgX25hbWUpCQkJCVwKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19uYWNsX3BhcmFtX2F0dHJpYnV0ZSBfZmFicmljIyNfbmFjbF9wYXJhbV8jI19uYW1lID0gXAorCV9fQ09ORklHRlNfRUFUVFJfUk8oX25hbWUsCQkJCQlcCisJX2ZhYnJpYyMjX25hY2xfcGFyYW1fc2hvd18jI19uYW1lKTsKKworCitDT05GSUdGU19FQVRUUl9TVFJVQ1QodGFyZ2V0X2ZhYnJpY19uYWNsX2Jhc2UsIHNlX25vZGVfYWNsKTsKKyNkZWZpbmUgVEZfTkFDTF9CQVNFX0FUVFIoX2ZhYnJpYywgX25hbWUsIF9tb2RlKQkJCVwKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19uYWNsX2Jhc2VfYXR0cmlidXRlIF9mYWJyaWMjI19uYWNsXyMjX25hbWUgPSBcCisJX19DT05GSUdGU19FQVRUUihfbmFtZSwgX21vZGUsCQkJCQlcCisJX2ZhYnJpYyMjX25hY2xfc2hvd18jI19uYW1lLAkJCQkJXAorCV9mYWJyaWMjI19uYWNsX3N0b3JlXyMjX25hbWUpOworCisjZGVmaW5lIFRGX05BQ0xfQkFTRV9BVFRSX1JPKF9mYWJyaWMsIF9uYW1lKQkJCQlcCitzdGF0aWMgc3RydWN0IHRhcmdldF9mYWJyaWNfbmFjbF9iYXNlX2F0dHJpYnV0ZSBfZmFicmljIyNfbmFjbF8jI19uYW1lID0gXAorCV9fQ09ORklHRlNfRUFUVFJfUk8oX25hbWUsCQkJCQlcCisJX2ZhYnJpYyMjX25hY2xfc2hvd18jI19uYW1lKTsKKworQ09ORklHRlNfRUFUVFJfU1RSVUNUKHRhcmdldF9mYWJyaWNfbnBfYmFzZSwgc2VfdHBnX25wKTsKKyNkZWZpbmUgVEZfTlBfQkFTRV9BVFRSKF9mYWJyaWMsIF9uYW1lLCBfbW9kZSkJCQkJXAorc3RhdGljIHN0cnVjdCB0YXJnZXRfZmFicmljX25wX2Jhc2VfYXR0cmlidXRlIF9mYWJyaWMjI19ucF8jI19uYW1lID0JXAorCV9fQ09ORklHRlNfRUFUVFIoX25hbWUsIF9tb2RlLAkJCQkJXAorCV9mYWJyaWMjI19ucF9zaG93XyMjX25hbWUsCQkJCQlcCisJX2ZhYnJpYyMjX25wX3N0b3JlXyMjX25hbWUpOworCitDT05GSUdGU19FQVRUUl9TVFJVQ1QodGFyZ2V0X2ZhYnJpY190cGdfYXR0cmliLCBzZV9wb3J0YWxfZ3JvdXApOworI2RlZmluZSBURl9UUEdfQVRUUklCX0FUVFIoX2ZhYnJpYywgX25hbWUsIF9tb2RlKQkJCVwKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY190cGdfYXR0cmliX2F0dHJpYnV0ZSBfZmFicmljIyNfdHBnX2F0dHJpYl8jI19uYW1lID0gXAorCV9fQ09ORklHRlNfRUFUVFIoX25hbWUsIF9tb2RlLAkJCQkJXAorCV9mYWJyaWMjI190cGdfYXR0cmliX3Nob3dfIyNfbmFtZSwJCQkJXAorCV9mYWJyaWMjI190cGdfYXR0cmliX3N0b3JlXyMjX25hbWUpOworCisKK0NPTkZJR0ZTX0VBVFRSX1NUUlVDVCh0YXJnZXRfZmFicmljX3RwZ19wYXJhbSwgc2VfcG9ydGFsX2dyb3VwKTsKKyNkZWZpbmUgVEZfVFBHX1BBUkFNX0FUVFIoX2ZhYnJpYywgX25hbWUsIF9tb2RlKQkJCVwKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY190cGdfcGFyYW1fYXR0cmlidXRlIF9mYWJyaWMjI190cGdfcGFyYW1fIyNfbmFtZSA9IFwKKwlfX0NPTkZJR0ZTX0VBVFRSKF9uYW1lLCBfbW9kZSwJCQkJCVwKKwlfZmFicmljIyNfdHBnX3BhcmFtX3Nob3dfIyNfbmFtZSwJCQkJXAorCV9mYWJyaWMjI190cGdfcGFyYW1fc3RvcmVfIyNfbmFtZSk7CisKKworQ09ORklHRlNfRUFUVFJfU1RSVUNUKHRhcmdldF9mYWJyaWNfdHBnLCBzZV9wb3J0YWxfZ3JvdXApOworI2RlZmluZSBURl9UUEdfQkFTRV9BVFRSKF9mYWJyaWMsIF9uYW1lLCBfbW9kZSkJCQkJXAorc3RhdGljIHN0cnVjdCB0YXJnZXRfZmFicmljX3RwZ19hdHRyaWJ1dGUgX2ZhYnJpYyMjX3RwZ18jI19uYW1lID0JXAorCV9fQ09ORklHRlNfRUFUVFIoX25hbWUsIF9tb2RlLAkJCQkJXAorCV9mYWJyaWMjI190cGdfc2hvd18jI19uYW1lLAkJCQkJXAorCV9mYWJyaWMjI190cGdfc3RvcmVfIyNfbmFtZSk7CisKKworQ09ORklHRlNfRUFUVFJfU1RSVUNUKHRhcmdldF9mYWJyaWNfd3duLCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzKTsKKyNkZWZpbmUgVEZfV1dOX0FUVFIoX2ZhYnJpYywgX25hbWUsIF9tb2RlKQkJCQlcCitzdGF0aWMgc3RydWN0IHRhcmdldF9mYWJyaWNfd3duX2F0dHJpYnV0ZSBfZmFicmljIyNfd3duXyMjX25hbWUgPQlcCisJX19DT05GSUdGU19FQVRUUihfbmFtZSwgX21vZGUsCQkJCQlcCisJX2ZhYnJpYyMjX3d3bl9zaG93X2F0dHJfIyNfbmFtZSwJCQkJXAorCV9mYWJyaWMjI193d25fc3RvcmVfYXR0cl8jI19uYW1lKTsKKworI2RlZmluZSBURl9XV05fQVRUUl9STyhfZmFicmljLCBfbmFtZSkJCQkJCVwKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY193d25fYXR0cmlidXRlIF9mYWJyaWMjI193d25fIyNfbmFtZSA9CVwKKwlfX0NPTkZJR0ZTX0VBVFRSX1JPKF9uYW1lLAkJCQkJXAorCV9mYWJyaWMjI193d25fc2hvd19hdHRyXyMjX25hbWUpOworCitDT05GSUdGU19FQVRUUl9TVFJVQ1QodGFyZ2V0X2ZhYnJpY19kaXNjb3ZlcnksIHRhcmdldF9mYWJyaWNfY29uZmlnZnMpOworI2RlZmluZSBURl9ESVNDX0FUVFIoX2ZhYnJpYywgX25hbWUsIF9tb2RlKQkJCQlcCitzdGF0aWMgc3RydWN0IHRhcmdldF9mYWJyaWNfZGlzY292ZXJ5X2F0dHJpYnV0ZSBfZmFicmljIyNfZGlzY18jI19uYW1lID0gXAorCV9fQ09ORklHRlNfRUFUVFIoX25hbWUsIF9tb2RlLAkJCQkJXAorCV9mYWJyaWMjI19kaXNjX3Nob3dfIyNfbmFtZSwJCQkJCVwKKwlfZmFicmljIyNfZGlzY19zdG9yZV8jI19uYW1lKTsKKworI2RlZmluZSBURl9ESVNDX0FUVFJfUk8oX2ZhYnJpYywgX25hbWUpCQkJCQlcCitzdGF0aWMgc3RydWN0IHRhcmdldF9mYWJyaWNfZGlzY292ZXJ5X2F0dHJpYnV0ZSBfZmFicmljIyNfZGlzY18jI19uYW1lID0gXAorCV9fQ09ORklHRlNfRUFUVFJfUk8oX25hbWUsCQkJCQlcCisJX2ZhYnJpYyMjX2Rpc2Nfc2hvd18jI19uYW1lKTsKKworZXh0ZXJuIGludCB0YXJnZXRfZmFicmljX3NldHVwX2NpdHMoc3RydWN0IHRhcmdldF9mYWJyaWNfY29uZmlnZnMgKik7CmRpZmYgLS1naXQgYS9pbmNsdWRlL3RhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfbGliLmggYi9pbmNsdWRlL3RhcmdldC90YXJnZXRfY29yZV9mYWJyaWNfbGliLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzJmOGQwZQotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19saWIuaApAQCAtMCwwICsxLDI4IEBACisjaWZuZGVmIFRBUkdFVF9DT1JFX0ZBQlJJQ19MSUJfSAorI2RlZmluZSBUQVJHRVRfQ09SRV9GQUJSSUNfTElCX0gKKworZXh0ZXJuIHU4IHNhc19nZXRfZmFicmljX3Byb3RvX2lkZW50KHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKik7CitleHRlcm4gdTMyIHNhc19nZXRfcHJfdHJhbnNwb3J0X2lkKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKiwgc3RydWN0IHNlX25vZGVfYWNsICosCisJCQlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqLCBpbnQgKiwgdW5zaWduZWQgY2hhciAqKTsKK2V4dGVybiB1MzIgc2FzX2dldF9wcl90cmFuc3BvcnRfaWRfbGVuKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKiwgc3RydWN0IHNlX25vZGVfYWNsICosCisJCQlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqLCBpbnQgKik7CitleHRlcm4gY2hhciAqc2FzX3BhcnNlX3ByX291dF90cmFuc3BvcnRfaWQoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLAorCQkJY29uc3QgY2hhciAqLCB1MzIgKiwgY2hhciAqKik7CisKK2V4dGVybiB1OCBmY19nZXRfZmFicmljX3Byb3RvX2lkZW50KHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKik7CitleHRlcm4gdTMyIGZjX2dldF9wcl90cmFuc3BvcnRfaWQoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLCBzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKiwKKwkJCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICosIGludCAqLCB1bnNpZ25lZCBjaGFyICopOworZXh0ZXJuIHUzMiBmY19nZXRfcHJfdHJhbnNwb3J0X2lkX2xlbihzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICosIHN0cnVjdCBzZV9ub2RlX2FjbCAqLAorCQkJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKiwgaW50ICopOworZXh0ZXJuIGNoYXIgKmZjX3BhcnNlX3ByX291dF90cmFuc3BvcnRfaWQoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLAorCQkJY29uc3QgY2hhciAqLCB1MzIgKiwgY2hhciAqKik7CisKK2V4dGVybiB1OCBpc2NzaV9nZXRfZmFicmljX3Byb3RvX2lkZW50KHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKik7CitleHRlcm4gdTMyIGlzY3NpX2dldF9wcl90cmFuc3BvcnRfaWQoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLCBzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKiwKKwkJCXN0cnVjdCB0MTBfcHJfcmVnaXN0cmF0aW9uICosIGludCAqLCB1bnNpZ25lZCBjaGFyICopOworZXh0ZXJuIHUzMiBpc2NzaV9nZXRfcHJfdHJhbnNwb3J0X2lkX2xlbihzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICosIHN0cnVjdCBzZV9ub2RlX2FjbCAqLAorCQkJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKiwgaW50ICopOworZXh0ZXJuIGNoYXIgKmlzY3NpX3BhcnNlX3ByX291dF90cmFuc3BvcnRfaWQoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLAorCQkJY29uc3QgY2hhciAqLCB1MzIgKiwgY2hhciAqKik7CisKKyNlbmRpZiAvKiBUQVJHRVRfQ09SRV9GQUJSSUNfTElCX0ggKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19vcHMuaCBiL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX2ZhYnJpY19vcHMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mM2FjMTJiCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS90YXJnZXQvdGFyZ2V0X2NvcmVfZmFicmljX29wcy5oCkBAIC0wLDAgKzEsMTAwIEBACisvKiBEZWZpbmVkIGluIHRhcmdldF9jb3JlX2NvbmZpZ2ZzLmggKi8KK3N0cnVjdCB0YXJnZXRfZmFicmljX2NvbmZpZ2ZzOworCitzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcyB7CisJc3RydWN0IGNvbmZpZ2ZzX3N1YnN5c3RlbSAqdGZfc3Vic3lzOworCS8qCisJICogT3B0aW9uYWwgdG8gc2lnbmFsIHN0cnVjdCBzZV90YXNrLT50YXNrX3NnW10gcGFkZGluZyBlbnRyaWVzCisJICogZm9yIHNjYXR0ZXJsaXN0IGNoYWluaW5nIHVzaW5nIHRyYW5zcG9ydF9kb190YXNrX3NnX2xpbmsoKSwKKwkgKiBkaXNhYmxlZCBieSBkZWZhdWx0CisJICovCisJaW50IHRhc2tfc2dfY2hhaW5pbmc6MTsKKwljaGFyICooKmdldF9mYWJyaWNfbmFtZSkodm9pZCk7CisJdTggKCpnZXRfZmFicmljX3Byb3RvX2lkZW50KShzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICopOworCWNoYXIgKigqdHBnX2dldF93d24pKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKik7CisJdTE2ICgqdHBnX2dldF90YWcpKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKik7CisJdTMyICgqdHBnX2dldF9kZWZhdWx0X2RlcHRoKShzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICopOworCXUzMiAoKnRwZ19nZXRfcHJfdHJhbnNwb3J0X2lkKShzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICosCisJCQkJc3RydWN0IHNlX25vZGVfYWNsICosCisJCQkJc3RydWN0IHQxMF9wcl9yZWdpc3RyYXRpb24gKiwgaW50ICosCisJCQkJdW5zaWduZWQgY2hhciAqKTsKKwl1MzIgKCp0cGdfZ2V0X3ByX3RyYW5zcG9ydF9pZF9sZW4pKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKiwKKwkJCQlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKiwKKwkJCQlzdHJ1Y3QgdDEwX3ByX3JlZ2lzdHJhdGlvbiAqLCBpbnQgKik7CisJY2hhciAqKCp0cGdfcGFyc2VfcHJfb3V0X3RyYW5zcG9ydF9pZCkoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLAorCQkJCWNvbnN0IGNoYXIgKiwgdTMyICosIGNoYXIgKiopOworCWludCAoKnRwZ19jaGVja19kZW1vX21vZGUpKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKik7CisJaW50ICgqdHBnX2NoZWNrX2RlbW9fbW9kZV9jYWNoZSkoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqKTsKKwlpbnQgKCp0cGdfY2hlY2tfZGVtb19tb2RlX3dyaXRlX3Byb3RlY3QpKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKik7CisJaW50ICgqdHBnX2NoZWNrX3Byb2RfbW9kZV93cml0ZV9wcm90ZWN0KShzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICopOworCXN0cnVjdCBzZV9ub2RlX2FjbCAqKCp0cGdfYWxsb2NfZmFicmljX2FjbCkoCisJCQkJCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKik7CisJdm9pZCAoKnRwZ19yZWxlYXNlX2ZhYnJpY19hY2wpKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKiwKKwkJCQkJc3RydWN0IHNlX25vZGVfYWNsICopOworCXUzMiAoKnRwZ19nZXRfaW5zdF9pbmRleCkoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqKTsKKwkvKgorCSAqIE9wdGlvbmFsIGZ1bmN0aW9uIHBvaW50ZXIgZm9yIFRDTSB0byBwZXJmb3JtIGNvbW1hbmQgbWFwCisJICogZnJvbSBUQ00gcHJvY2Vzc2luZyB0aHJlYWQgY29udGV4dCwgZm9yIHRob3NlIHN0cnVjdCBzZV9jbWQKKwkgKiBpbml0YWxseSBhbGxvY2F0ZWQgaW4gaW50ZXJydXB0IGNvbnRleHQuCisJICovCisJaW50ICgqbmV3X2NtZF9tYXApKHN0cnVjdCBzZV9jbWQgKik7CisJLyoKKwkgKiBPcHRpb25hbCBmdW5jdGlvbiBwb2ludGVyIGZvciBUQ00gZmFicmljIG1vZHVsZXMgdGhhdCB1c2UKKwkgKiBMaW51eC9ORVQgc29ja2V0cyB0byBhbGxvY2F0ZSBzdHJ1Y3QgaW92ZWMgYXJyYXkgdG8gc3RydWN0IHNlX2NtZAorCSAqLworCWludCAoKmFsbG9jX2NtZF9pb3ZlY3MpKHN0cnVjdCBzZV9jbWQgKik7CisJLyoKKwkgKiBPcHRpb25hbCB0byByZWxlYXNlIHN0cnVjdCBzZV9jbWQgYW5kIGZhYnJpYyBkZXBlbmRlbnQgYWxsb2NhdGVkCisJICogSS9PIGRlc2NyaXB0b3IgaW4gdHJhbnNwb3J0X2NtZF9jaGVja19zdG9wKCkKKwkgKi8KKwl2b2lkICgqY2hlY2tfc3RvcF9mcmVlKShzdHJ1Y3Qgc2VfY21kICopOworCXZvaWQgKCpyZWxlYXNlX2NtZF90b19wb29sKShzdHJ1Y3Qgc2VfY21kICopOworCXZvaWQgKCpyZWxlYXNlX2NtZF9kaXJlY3QpKHN0cnVjdCBzZV9jbWQgKik7CisJLyoKKwkgKiBDYWxsZWQgd2l0aCBzcGluX2xvY2tfYmgoc3RydWN0IHNlX3BvcnRhbF9ncm91cC0+c2Vzc2lvbl9sb2NrIGhlbGQuCisJICovCisJaW50ICgqc2h1dGRvd25fc2Vzc2lvbikoc3RydWN0IHNlX3Nlc3Npb24gKik7CisJdm9pZCAoKmNsb3NlX3Nlc3Npb24pKHN0cnVjdCBzZV9zZXNzaW9uICopOworCXZvaWQgKCpzdG9wX3Nlc3Npb24pKHN0cnVjdCBzZV9zZXNzaW9uICosIGludCwgaW50KTsKKwl2b2lkICgqZmFsbF9iYWNrX3RvX2VybDApKHN0cnVjdCBzZV9zZXNzaW9uICopOworCWludCAoKnNlc3NfbG9nZ2VkX2luKShzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqKTsKKwl1MzIgKCpzZXNzX2dldF9pbmRleCkoc3RydWN0IHNlX3Nlc3Npb24gKik7CisJLyoKKwkgKiBVc2VkIG9ubHkgZm9yIFNDU0kgZmFicmljcyB0aGF0IGNvbnRhaW4gbXVsdGktdmFsdWUgVHJhbnNwb3J0SURzCisJICogKGxpa2UgaVNDU0kpLiAgQWxsIG90aGVyIFNDU0kgZmFicmljcyBzaG91bGQgc2V0IHRoaXMgdG8gTlVMTC4KKwkgKi8KKwl1MzIgKCpzZXNzX2dldF9pbml0aWF0b3Jfc2lkKShzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqLAorCQkJCSAgICAgIHVuc2lnbmVkIGNoYXIgKiwgdTMyKTsKKwlpbnQgKCp3cml0ZV9wZW5kaW5nKShzdHJ1Y3Qgc2VfY21kICopOworCWludCAoKndyaXRlX3BlbmRpbmdfc3RhdHVzKShzdHJ1Y3Qgc2VfY21kICopOworCXZvaWQgKCpzZXRfZGVmYXVsdF9ub2RlX2F0dHJpYnV0ZXMpKHN0cnVjdCBzZV9ub2RlX2FjbCAqKTsKKwl1MzIgKCpnZXRfdGFza190YWcpKHN0cnVjdCBzZV9jbWQgKik7CisJaW50ICgqZ2V0X2NtZF9zdGF0ZSkoc3RydWN0IHNlX2NtZCAqKTsKKwl2b2lkICgqbmV3X2NtZF9mYWlsdXJlKShzdHJ1Y3Qgc2VfY21kICopOworCWludCAoKnF1ZXVlX2RhdGFfaW4pKHN0cnVjdCBzZV9jbWQgKik7CisJaW50ICgqcXVldWVfc3RhdHVzKShzdHJ1Y3Qgc2VfY21kICopOworCWludCAoKnF1ZXVlX3RtX3JzcCkoc3RydWN0IHNlX2NtZCAqKTsKKwl1MTYgKCpzZXRfZmFicmljX3NlbnNlX2xlbikoc3RydWN0IHNlX2NtZCAqLCB1MzIpOworCXUxNiAoKmdldF9mYWJyaWNfc2Vuc2VfbGVuKSh2b2lkKTsKKwlpbnQgKCppc19zdGF0ZV9yZW1vdmUpKHN0cnVjdCBzZV9jbWQgKik7CisJdTY0ICgqcGFja19sdW4pKHVuc2lnbmVkIGludCk7CisJLyoKKwkgKiBmYWJyaWMgbW9kdWxlIGNhbGxzIGZvciB0YXJnZXRfY29yZV9mYWJyaWNfY29uZmlnZnMuYworCSAqLworCXN0cnVjdCBzZV93d24gKigqZmFicmljX21ha2Vfd3duKShzdHJ1Y3QgdGFyZ2V0X2ZhYnJpY19jb25maWdmcyAqLAorCQkJCXN0cnVjdCBjb25maWdfZ3JvdXAgKiwgY29uc3QgY2hhciAqKTsKKwl2b2lkICgqZmFicmljX2Ryb3Bfd3duKShzdHJ1Y3Qgc2Vfd3duICopOworCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKigqZmFicmljX21ha2VfdHBnKShzdHJ1Y3Qgc2Vfd3duICosCisJCQkJc3RydWN0IGNvbmZpZ19ncm91cCAqLCBjb25zdCBjaGFyICopOworCXZvaWQgKCpmYWJyaWNfZHJvcF90cGcpKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKik7CisJaW50ICgqZmFicmljX3Bvc3RfbGluaykoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLAorCQkJCXN0cnVjdCBzZV9sdW4gKik7CisJdm9pZCAoKmZhYnJpY19wcmVfdW5saW5rKShzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICosCisJCQkJc3RydWN0IHNlX2x1biAqKTsKKwlzdHJ1Y3Qgc2VfdHBnX25wICooKmZhYnJpY19tYWtlX25wKShzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICosCisJCQkJc3RydWN0IGNvbmZpZ19ncm91cCAqLCBjb25zdCBjaGFyICopOworCXZvaWQgKCpmYWJyaWNfZHJvcF9ucCkoc3RydWN0IHNlX3RwZ19ucCAqKTsKKwlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKigqZmFicmljX21ha2Vfbm9kZWFjbCkoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLAorCQkJCXN0cnVjdCBjb25maWdfZ3JvdXAgKiwgY29uc3QgY2hhciAqKTsKKwl2b2lkICgqZmFicmljX2Ryb3Bfbm9kZWFjbCkoc3RydWN0IHNlX25vZGVfYWNsICopOworfTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX3Rtci5oIGIvaW5jbHVkZS90YXJnZXQvdGFyZ2V0X2NvcmVfdG1yLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNmM4MjQ4YgotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX3Rtci5oCkBAIC0wLDAgKzEsNDMgQEAKKyNpZm5kZWYgVEFSR0VUX0NPUkVfVE1SX0gKKyNkZWZpbmUgVEFSR0VUX0NPUkVfVE1SX0gKKworLyogdGFzayBtYW5hZ2VtZW50IGZ1bmN0aW9uIHZhbHVlcyAqLworI2lmZGVmIEFCT1JUX1RBU0sKKyN1bmRlZiBBQk9SVF9UQVNLCisjZW5kaWYgLyogQUJPUlRfVEFTSyAqLworI2RlZmluZSBBQk9SVF9UQVNLCQkJCTEKKyNpZmRlZiBBQk9SVF9UQVNLX1NFVAorI3VuZGVmIEFCT1JUX1RBU0tfU0VUCisjZW5kaWYgLyogQUJPUlRfVEFTS19TRVQgKi8KKyNkZWZpbmUgQUJPUlRfVEFTS19TRVQJCQkJMgorI2lmZGVmIENMRUFSX0FDQQorI3VuZGVmIENMRUFSX0FDQQorI2VuZGlmIC8qIENMRUFSX0FDQSAqLworI2RlZmluZSBDTEVBUl9BQ0EJCQkJMworI2lmZGVmIENMRUFSX1RBU0tfU0VUCisjdW5kZWYgQ0xFQVJfVEFTS19TRVQKKyNlbmRpZiAvKiBDTEVBUl9UQVNLX1NFVCAqLworI2RlZmluZSBDTEVBUl9UQVNLX1NFVAkJCQk0CisjZGVmaW5lIExVTl9SRVNFVAkJCQk1CisjZGVmaW5lIFRBUkdFVF9XQVJNX1JFU0VUCQkJNgorI2RlZmluZSBUQVJHRVRfQ09MRF9SRVNFVAkJCTcKKyNkZWZpbmUgVEFTS19SRUFTU0lHTgkJCQk4CisKKy8qIHRhc2sgbWFuYWdlbWVudCByZXNwb25zZSB2YWx1ZXMgKi8KKyNkZWZpbmUgVE1SX0ZVTkNUSU9OX0NPTVBMRVRFCQkJMAorI2RlZmluZSBUTVJfVEFTS19ET0VTX05PVF9FWElTVAkJCTEKKyNkZWZpbmUgVE1SX0xVTl9ET0VTX05PVF9FWElTVAkJCTIKKyNkZWZpbmUgVE1SX1RBU0tfU1RJTExfQUxMRUdJQU5UCQkzCisjZGVmaW5lIFRNUl9UQVNLX0ZBSUxPVkVSX05PVF9TVVBQT1JURUQJCTQKKyNkZWZpbmUgVE1SX1RBU0tfTUdNVF9GVU5DVElPTl9OT1RfU1VQUE9SVEVECTUKKyNkZWZpbmUgVE1SX0ZVTkNUSU9OX0FVVEhPUklaQVRJT05fRkFJTEVECTYKKyNkZWZpbmUgVE1SX0ZVTkNUSU9OX1JFSkVDVEVECQkJMjU1CisKK2V4dGVybiBzdHJ1Y3Qga21lbV9jYWNoZSAqc2VfdG1yX3JlcV9jYWNoZTsKKworZXh0ZXJuIHN0cnVjdCBzZV90bXJfcmVxICpjb3JlX3Rtcl9hbGxvY19yZXEoc3RydWN0IHNlX2NtZCAqLCB2b2lkICosIHU4KTsKK2V4dGVybiB2b2lkIGNvcmVfdG1yX3JlbGVhc2VfcmVxKHN0cnVjdCBzZV90bXJfcmVxICopOworZXh0ZXJuIGludCBjb3JlX3Rtcl9sdW5fcmVzZXQoc3RydWN0IHNlX2RldmljZSAqLCBzdHJ1Y3Qgc2VfdG1yX3JlcSAqLAorCQkJCXN0cnVjdCBsaXN0X2hlYWQgKiwgc3RydWN0IHNlX2NtZCAqKTsKKworI2VuZGlmIC8qIFRBUkdFVF9DT1JFX1RNUl9IICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL3RhcmdldC90YXJnZXRfY29yZV90cGcuaCBiL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX3RwZy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjc3ZTE4NzIKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL3RhcmdldC90YXJnZXRfY29yZV90cGcuaApAQCAtMCwwICsxLDM1IEBACisjaWZuZGVmIFRBUkdFVF9DT1JFX1RQR19ICisjZGVmaW5lIFRBUkdFVF9DT1JFX1RQR19ICisKK2V4dGVybiBzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKl9fY29yZV90cGdfZ2V0X2luaXRpYXRvcl9ub2RlX2FjbChzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcsCisJCQkJCQljb25zdCBjaGFyICopOworZXh0ZXJuIHN0cnVjdCBzZV9ub2RlX2FjbCAqY29yZV90cGdfZ2V0X2luaXRpYXRvcl9ub2RlX2FjbChzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICp0cGcsCisJCQkJCQl1bnNpZ25lZCBjaGFyICopOworZXh0ZXJuIHZvaWQgY29yZV90cGdfYWRkX25vZGVfdG9fZGV2cyhzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKiwKKwkJCQkJCXN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKik7CitleHRlcm4gc3RydWN0IHNlX25vZGVfYWNsICpjb3JlX3RwZ19jaGVja19pbml0aWF0b3Jfbm9kZV9hY2woCisJCQkJCQlzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICosCisJCQkJCQl1bnNpZ25lZCBjaGFyICopOworZXh0ZXJuIHZvaWQgY29yZV90cGdfd2FpdF9mb3JfbmFjbF9wcl9yZWYoc3RydWN0IHNlX25vZGVfYWNsICopOworZXh0ZXJuIHZvaWQgY29yZV90cGdfd2FpdF9mb3JfbWliX3JlZihzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKik7CitleHRlcm4gdm9pZCBjb3JlX3RwZ19jbGVhcl9vYmplY3RfbHVucyhzdHJ1Y3Qgc2VfcG9ydGFsX2dyb3VwICopOworZXh0ZXJuIHN0cnVjdCBzZV9ub2RlX2FjbCAqY29yZV90cGdfYWRkX2luaXRpYXRvcl9ub2RlX2FjbCgKKwkJCQkJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLAorCQkJCQlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKiwKKwkJCQkJY29uc3QgY2hhciAqLCB1MzIpOworZXh0ZXJuIGludCBjb3JlX3RwZ19kZWxfaW5pdGlhdG9yX25vZGVfYWNsKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKiwKKwkJCQkJCXN0cnVjdCBzZV9ub2RlX2FjbCAqLCBpbnQpOworZXh0ZXJuIGludCBjb3JlX3RwZ19zZXRfaW5pdGlhdG9yX25vZGVfcXVldWVfZGVwdGgoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLAorCQkJCQkJdW5zaWduZWQgY2hhciAqLCB1MzIsIGludCk7CitleHRlcm4gaW50IGNvcmVfdHBnX3JlZ2lzdGVyKHN0cnVjdCB0YXJnZXRfY29yZV9mYWJyaWNfb3BzICosCisJCQkJCXN0cnVjdCBzZV93d24gKiwKKwkJCQkJc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLCB2b2lkICosCisJCQkJCWludCk7CitleHRlcm4gaW50IGNvcmVfdHBnX2RlcmVnaXN0ZXIoc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqKTsKK2V4dGVybiBzdHJ1Y3Qgc2VfbHVuICpjb3JlX3RwZ19wcmVfYWRkbHVuKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKiwgdTMyKTsKK2V4dGVybiBpbnQgY29yZV90cGdfcG9zdF9hZGRsdW4oc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLCBzdHJ1Y3Qgc2VfbHVuICosIHUzMiwKKwkJCQl2b2lkICopOworZXh0ZXJuIHN0cnVjdCBzZV9sdW4gKmNvcmVfdHBnX3ByZV9kZWxsdW4oc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLCB1MzIsIGludCAqKTsKK2V4dGVybiBpbnQgY29yZV90cGdfcG9zdF9kZWxsdW4oc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLCBzdHJ1Y3Qgc2VfbHVuICopOworCisjZW5kaWYgLyogVEFSR0VUX0NPUkVfVFBHX0ggKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX3RyYW5zcG9ydC5oIGIvaW5jbHVkZS90YXJnZXQvdGFyZ2V0X2NvcmVfdHJhbnNwb3J0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjZmNDRlNQotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX3RyYW5zcG9ydC5oCkBAIC0wLDAgKzEsMzUxIEBACisjaWZuZGVmIFRBUkdFVF9DT1JFX1RSQU5TUE9SVF9ICisjZGVmaW5lIFRBUkdFVF9DT1JFX1RSQU5TUE9SVF9ICisKKyNkZWZpbmUgVEFSR0VUX0NPUkVfVkVSU0lPTgkJCVRBUkdFVF9DT1JFX01PRF9WRVJTSU9OCisKKy8qIEF0dGVtcHRzIGJlZm9yZSBtb3ZpbmcgZnJvbSBTSE9SVCB0byBMT05HICovCisjZGVmaW5lIFBZWF9UUkFOU1BPUlRfV0lORE9XX0NMT1NFRF9USFJFU0hPTEQJMworI2RlZmluZSBQWVhfVFJBTlNQT1JUX1dJTkRPV19DTE9TRURfV0FJVF9TSE9SVAkzICAvKiBJbiBtaWxsaXNlY29uZHMgKi8KKyNkZWZpbmUgUFlYX1RSQU5TUE9SVF9XSU5ET1dfQ0xPU0VEX1dBSVRfTE9ORwkxMCAvKiBJbiBtaWxsaXNlY29uZHMgKi8KKworI2RlZmluZSBQWVhfVFJBTlNQT1JUX1NUQVRVU19JTlRFUlZBTAkJNSAvKiBJbiBzZWNvbmRzICovCisKKyNkZWZpbmUgUFlYX1RSQU5TUE9SVF9TRU5UX1RPX1RSQU5TUE9SVAkJMAorI2RlZmluZSBQWVhfVFJBTlNQT1JUX1dSSVRFX1BFTkRJTkcJCTEKKworI2RlZmluZSBQWVhfVFJBTlNQT1JUX1VOS05PV05fU0FNX09QQ09ERQktMQorI2RlZmluZSBQWVhfVFJBTlNQT1JUX0hCQV9RVUVVRV9GVUxMCQktMgorI2RlZmluZSBQWVhfVFJBTlNQT1JUX1JFUV9UT09fTUFOWV9TRUNUT1JTCS0zCisjZGVmaW5lIFBZWF9UUkFOU1BPUlRfT1VUX09GX01FTU9SWV9SRVNPVVJDRVMJLTQKKyNkZWZpbmUgUFlYX1RSQU5TUE9SVF9JTlZBTElEX0NEQl9GSUVMRAkJLTUKKyNkZWZpbmUgUFlYX1RSQU5TUE9SVF9JTlZBTElEX1BBUkFNRVRFUl9MSVNUCS02CisjZGVmaW5lIFBZWF9UUkFOU1BPUlRfTFVfQ09NTV9GQUlMVVJFCQktNworI2RlZmluZSBQWVhfVFJBTlNQT1JUX1VOS05PV05fTU9ERV9QQUdFCQktOAorI2RlZmluZSBQWVhfVFJBTlNQT1JUX1dSSVRFX1BST1RFQ1RFRAkJLTkKKyNkZWZpbmUgUFlYX1RSQU5TUE9SVF9UQVNLX1RJTUVPVVQJCS0xMAorI2RlZmluZSBQWVhfVFJBTlNQT1JUX1JFU0VSVkFUSU9OX0NPTkZMSUNUCS0xMQorI2RlZmluZSBQWVhfVFJBTlNQT1JUX0lMTEVHQUxfUkVRVUVTVAkJLTEyCisjZGVmaW5lIFBZWF9UUkFOU1BPUlRfVVNFX1NFTlNFX1JFQVNPTgkJLTEzCisKKyNpZm5kZWYgU0FNX1NUQVRfUkVTRVJWQVRJT05fQ09ORkxJQ1QKKyNkZWZpbmUgU0FNX1NUQVRfUkVTRVJWQVRJT05fQ09ORkxJQ1QJCTB4MTgKKyNlbmRpZgorCisjZGVmaW5lIFRSQU5TUE9SVF9QTFVHSU5fRlJFRQkJCTAKKyNkZWZpbmUgVFJBTlNQT1JUX1BMVUdJTl9SRUdJU1RFUkVECQkxCisKKyNkZWZpbmUgVFJBTlNQT1JUX1BMVUdJTl9QSEJBX1BERVYJCTEKKyNkZWZpbmUgVFJBTlNQT1JUX1BMVUdJTl9WSEJBX1BERVYJCTIKKyNkZWZpbmUgVFJBTlNQT1JUX1BMVUdJTl9WSEJBX1ZERVYJCTMKKworLyogRm9yIFNFIE9CSiBQbHVnaW5zLCBpbiBzZWNvbmRzICovCisjZGVmaW5lIFRSQU5TUE9SVF9USU1FT1VUX1RVUgkJCTEwCisjZGVmaW5lIFRSQU5TUE9SVF9USU1FT1VUX1RZUEVfRElTSwkJNjAKKyNkZWZpbmUgVFJBTlNQT1JUX1RJTUVPVVRfVFlQRV9ST00JCTEyMAorI2RlZmluZSBUUkFOU1BPUlRfVElNRU9VVF9UWVBFX1RBUEUJCTYwMAorI2RlZmluZSBUUkFOU1BPUlRfVElNRU9VVF9UWVBFX09USEVSCQkzMDAKKworLyogRm9yIHNlX3Rhc2stPnRhc2tfc3RhdGVfZmxhZ3MgKi8KKyNkZWZpbmUgVFNGX0VYQ0VQVElPTl9DTEVBUkVECQkJMHgwMQorCisvKgorICogc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYtPnN1X2Rldl9mbGFncworKi8KKyNkZWZpbmUgU0RGX0ZJUk1XQVJFX1ZQRF9VTklUX1NFUklBTAkJMHgwMDAwMDAwMQorI2RlZmluZSBTREZfRU1VTEFURURfVlBEX1VOSVRfU0VSSUFMCQkweDAwMDAwMDAyCisjZGVmaW5lIFNERl9VU0lOR19VREVWX1BBVEgJCQkweDAwMDAwMDA0CisjZGVmaW5lIFNERl9VU0lOR19BTElBUwkJCQkweDAwMDAwMDA4CisKKy8qCisgKiBzdHJ1Y3Qgc2VfZGV2aWNlLT5kZXZfZmxhZ3MKKyAqLworI2RlZmluZSBERl9SRUFEX09OTFkJCQkJMHgwMDAwMDAwMQorI2RlZmluZSBERl9TUEMyX1JFU0VSVkFUSU9OUwkJCTB4MDAwMDAwMDIKKyNkZWZpbmUgREZfU1BDMl9SRVNFUlZBVElPTlNfV0lUSF9JU0lECQkweDAwMDAwMDA0CisKKy8qIHN0cnVjdCBzZV9kZXZfYXR0cmliIHNhbml0eSB2YWx1ZXMgKi8KKy8qIDEwIE1pbnV0ZXMgKi8KKyNkZWZpbmUgREFfVEFTS19USU1FT1VUX01BWAkJCTYwMAorLyogRGVmYXVsdCBtYXhfdW5tYXBfbGJhX2NvdW50ICovCisjZGVmaW5lIERBX01BWF9VTk1BUF9MQkFfQ09VTlQJCQkwCisvKiBEZWZhdWx0IG1heF91bm1hcF9ibG9ja19kZXNjX2NvdW50ICovCisjZGVmaW5lIERBX01BWF9VTk1BUF9CTE9DS19ERVNDX0NPVU5UCQkwCisvKiBEZWZhdWx0IHVubWFwX2dyYW51bGFyaXR5ICovCisjZGVmaW5lIERBX1VOTUFQX0dSQU5VTEFSSVRZX0RFRkFVTFQJCTAKKy8qIERlZmF1bHQgdW5tYXBfZ3JhbnVsYXJpdHlfYWxpZ25tZW50ICovCisjZGVmaW5lIERBX1VOTUFQX0dSQU5VTEFSSVRZX0FMSUdOTUVOVF9ERUZBVUxUCTAKKy8qIEVtdWxhdGlvbiBmb3IgRGlyZWN0IFBhZ2UgT3V0ICovCisjZGVmaW5lIERBX0VNVUxBVEVfRFBPCQkJCTAKKy8qIEVtdWxhdGlvbiBmb3IgRm9yY2VkIFVuaXQgQWNjZXNzIFdSSVRFcyAqLworI2RlZmluZSBEQV9FTVVMQVRFX0ZVQV9XUklURQkJCTEKKy8qIEVtdWxhdGlvbiBmb3IgRm9yY2VkIFVuaXQgQWNjZXNzIFJFQURzICovCisjZGVmaW5lIERBX0VNVUxBVEVfRlVBX1JFQUQJCQkwCisvKiBFbXVsYXRpb24gZm9yIFdyaXRlQ2FjaGUgYW5kIFNZTkNIUk9OSVpFX0NBQ0hFICovCisjZGVmaW5lIERBX0VNVUxBVEVfV1JJVEVfQ0FDSEUJCQkwCisvKiBFbXVsYXRpb24gZm9yIFVOSVQgQVRURU5USU9OIEludGVybG9jayBDb250cm9sICovCisjZGVmaW5lIERBX0VNVUxBVEVfVUFfSU5UTExDS19DVFJMCQkwCisvKiBFbXVsYXRpb24gZm9yIFRBU0tfQUJPUlRFRCBzdGF0dXMgKFRBUykgYnkgZGVmYXVsdCAqLworI2RlZmluZSBEQV9FTVVMQVRFX1RBUwkJCQkxCisvKiBFbXVsYXRpb24gZm9yIFRoaW4gUHJvdmlzaW9uaW5nIFVOTUFQIHVzaW5nIGJsb2NrL2Jsay1saWIuYzpibGtkZXZfaXNzdWVfZGlzY2FyZCgpICovCisjZGVmaW5lIERBX0VNVUxBVEVfVFBVCQkJCTAKKy8qCisgKiBFbXVsYXRpb24gZm9yIFRoaW4gUHJvdmlzaW9uaW5nIFdSSVRFX1NBTUUgdy8gVU5NQVA9MSBiaXQgdXNpbmcKKyAqIGJsb2NrL2Jsay1saWIuYzpibGtkZXZfaXNzdWVfZGlzY2FyZCgpCisgKi8KKyNkZWZpbmUgREFfRU1VTEFURV9UUFdTCQkJCTAKKy8qIE5vIEVtdWxhdGlvbiBmb3IgUFNDU0kgYnkgZGVmYXVsdCAqLworI2RlZmluZSBEQV9FTVVMQVRFX1JFU0VSVkFUSU9OUwkJCTAKKy8qIE5vIEVtdWxhdGlvbiBmb3IgUFNDU0kgYnkgZGVmYXVsdCAqLworI2RlZmluZSBEQV9FTVVMQVRFX0FMVUEJCQkJMAorLyogRW5mb3JjZSBTQ1NJIEluaXRpYXRvciBQb3J0IFRyYW5zcG9ydElEIHdpdGggJ0lTSUQnIGZvciBQUiAqLworI2RlZmluZSBEQV9FTkZPUkNFX1BSX0lTSURTCQkJMQorI2RlZmluZSBEQV9TVEFUVVNfTUFYX1NFQ1RPUlNfTUlOCQkxNgorI2RlZmluZSBEQV9TVEFUVVNfTUFYX1NFQ1RPUlNfTUFYCQk4MTkyCisKKyNkZWZpbmUgU0VfTU9ERV9QQUdFX0JVRgkJCTUxMgorCisjZGVmaW5lIE1PRF9NQVhfU0VDVE9SUyhtcywgYnMpCQkJKG1zICUgKFBBR0VfU0laRSAvIGJzKSkKKworc3RydWN0IHNlX21lbTsKK3N0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpOworCitleHRlcm4gaW50IGluaXRfc2VfZ2xvYmFsKHZvaWQpOworZXh0ZXJuIHZvaWQgcmVsZWFzZV9zZV9nbG9iYWwodm9pZCk7CitleHRlcm4gdm9pZCB0cmFuc3BvcnRfaW5pdF9xdWV1ZV9vYmooc3RydWN0IHNlX3F1ZXVlX29iaiAqKTsKK2V4dGVybiBpbnQgdHJhbnNwb3J0X3N1YnN5c3RlbV9jaGVja19pbml0KHZvaWQpOworZXh0ZXJuIGludCB0cmFuc3BvcnRfc3Vic3lzdGVtX3JlZ2lzdGVyKHN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpICopOworZXh0ZXJuIHZvaWQgdHJhbnNwb3J0X3N1YnN5c3RlbV9yZWxlYXNlKHN0cnVjdCBzZV9zdWJzeXN0ZW1fYXBpICopOworZXh0ZXJuIHZvaWQgdHJhbnNwb3J0X2xvYWRfcGx1Z2lucyh2b2lkKTsKK2V4dGVybiBzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqdHJhbnNwb3J0X2luaXRfc2Vzc2lvbih2b2lkKTsKK2V4dGVybiB2b2lkIF9fdHJhbnNwb3J0X3JlZ2lzdGVyX3Nlc3Npb24oc3RydWN0IHNlX3BvcnRhbF9ncm91cCAqLAorCQkJCQlzdHJ1Y3Qgc2Vfbm9kZV9hY2wgKiwKKwkJCQkJc3RydWN0IHNlX3Nlc3Npb24gKiwgdm9pZCAqKTsKK2V4dGVybiB2b2lkIHRyYW5zcG9ydF9yZWdpc3Rlcl9zZXNzaW9uKHN0cnVjdCBzZV9wb3J0YWxfZ3JvdXAgKiwKKwkJCQkJc3RydWN0IHNlX25vZGVfYWNsICosCisJCQkJCXN0cnVjdCBzZV9zZXNzaW9uICosIHZvaWQgKik7CitleHRlcm4gdm9pZCB0cmFuc3BvcnRfZnJlZV9zZXNzaW9uKHN0cnVjdCBzZV9zZXNzaW9uICopOworZXh0ZXJuIHZvaWQgdHJhbnNwb3J0X2RlcmVnaXN0ZXJfc2Vzc2lvbl9jb25maWdmcyhzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqKTsKK2V4dGVybiB2b2lkIHRyYW5zcG9ydF9kZXJlZ2lzdGVyX3Nlc3Npb24oc3RydWN0IHNlX3Nlc3Npb24gKik7CitleHRlcm4gdm9pZCB0cmFuc3BvcnRfY21kX2ZpbmlzaF9hYm9ydChzdHJ1Y3Qgc2VfY21kICosIGludCk7CitleHRlcm4gdm9pZCB0cmFuc3BvcnRfY21kX2ZpbmlzaF9hYm9ydF90bXIoc3RydWN0IHNlX2NtZCAqKTsKK2V4dGVybiB2b2lkIHRyYW5zcG9ydF9jb21wbGV0ZV9zeW5jX2NhY2hlKHN0cnVjdCBzZV9jbWQgKiwgaW50KTsKK2V4dGVybiB2b2lkIHRyYW5zcG9ydF9jb21wbGV0ZV90YXNrKHN0cnVjdCBzZV90YXNrICosIGludCk7CitleHRlcm4gdm9pZCB0cmFuc3BvcnRfYWRkX3Rhc2tfdG9fZXhlY3V0ZV9xdWV1ZShzdHJ1Y3Qgc2VfdGFzayAqLAorCQkJCQkJc3RydWN0IHNlX3Rhc2sgKiwKKwkJCQkJCXN0cnVjdCBzZV9kZXZpY2UgKik7Cit1bnNpZ25lZCBjaGFyICp0cmFuc3BvcnRfZHVtcF9jbWRfZGlyZWN0aW9uKHN0cnVjdCBzZV9jbWQgKik7CitleHRlcm4gdm9pZCB0cmFuc3BvcnRfZHVtcF9kZXZfc3RhdGUoc3RydWN0IHNlX2RldmljZSAqLCBjaGFyICosIGludCAqKTsKK2V4dGVybiB2b2lkIHRyYW5zcG9ydF9kdW1wX2Rldl9pbmZvKHN0cnVjdCBzZV9kZXZpY2UgKiwgc3RydWN0IHNlX2x1biAqLAorCQkJCQl1bnNpZ25lZCBsb25nIGxvbmcsIGNoYXIgKiwgaW50ICopOworZXh0ZXJuIHZvaWQgdHJhbnNwb3J0X2R1bXBfdnBkX3Byb3RvX2lkKHN0cnVjdCB0MTBfdnBkICosCisJCQkJCXVuc2lnbmVkIGNoYXIgKiwgaW50KTsKK2V4dGVybiB2b2lkIHRyYW5zcG9ydF9zZXRfdnBkX3Byb3RvX2lkKHN0cnVjdCB0MTBfdnBkICosIHVuc2lnbmVkIGNoYXIgKik7CitleHRlcm4gaW50IHRyYW5zcG9ydF9kdW1wX3ZwZF9hc3NvYyhzdHJ1Y3QgdDEwX3ZwZCAqLAorCQkJCQl1bnNpZ25lZCBjaGFyICosIGludCk7CitleHRlcm4gaW50IHRyYW5zcG9ydF9zZXRfdnBkX2Fzc29jKHN0cnVjdCB0MTBfdnBkICosIHVuc2lnbmVkIGNoYXIgKik7CitleHRlcm4gaW50IHRyYW5zcG9ydF9kdW1wX3ZwZF9pZGVudF90eXBlKHN0cnVjdCB0MTBfdnBkICosCisJCQkJCXVuc2lnbmVkIGNoYXIgKiwgaW50KTsKK2V4dGVybiBpbnQgdHJhbnNwb3J0X3NldF92cGRfaWRlbnRfdHlwZShzdHJ1Y3QgdDEwX3ZwZCAqLCB1bnNpZ25lZCBjaGFyICopOworZXh0ZXJuIGludCB0cmFuc3BvcnRfZHVtcF92cGRfaWRlbnQoc3RydWN0IHQxMF92cGQgKiwKKwkJCQkJdW5zaWduZWQgY2hhciAqLCBpbnQpOworZXh0ZXJuIGludCB0cmFuc3BvcnRfc2V0X3ZwZF9pZGVudChzdHJ1Y3QgdDEwX3ZwZCAqLCB1bnNpZ25lZCBjaGFyICopOworZXh0ZXJuIHN0cnVjdCBzZV9kZXZpY2UgKnRyYW5zcG9ydF9hZGRfZGV2aWNlX3RvX2NvcmVfaGJhKHN0cnVjdCBzZV9oYmEgKiwKKwkJCQkJc3RydWN0IHNlX3N1YnN5c3RlbV9hcGkgKiwKKwkJCQkJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKiwgdTMyLAorCQkJCQl2b2lkICosIHN0cnVjdCBzZV9kZXZfbGltaXRzICosCisJCQkJCWNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqKTsKK2V4dGVybiB2b2lkIHRyYW5zcG9ydF9kZXZpY2Vfc2V0dXBfY21kKHN0cnVjdCBzZV9jbWQgKik7CitleHRlcm4gdm9pZCB0cmFuc3BvcnRfaW5pdF9zZV9jbWQoc3RydWN0IHNlX2NtZCAqLAorCQkJCQlzdHJ1Y3QgdGFyZ2V0X2NvcmVfZmFicmljX29wcyAqLAorCQkJCQlzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqLCB1MzIsIGludCwgaW50LAorCQkJCQl1bnNpZ25lZCBjaGFyICopOworZXh0ZXJuIHZvaWQgdHJhbnNwb3J0X2ZyZWVfc2VfY21kKHN0cnVjdCBzZV9jbWQgKik7CitleHRlcm4gaW50IHRyYW5zcG9ydF9nZW5lcmljX2FsbG9jYXRlX3Rhc2tzKHN0cnVjdCBzZV9jbWQgKiwgdW5zaWduZWQgY2hhciAqKTsKK2V4dGVybiBpbnQgdHJhbnNwb3J0X2dlbmVyaWNfaGFuZGxlX2NkYihzdHJ1Y3Qgc2VfY21kICopOworZXh0ZXJuIGludCB0cmFuc3BvcnRfZ2VuZXJpY19oYW5kbGVfY2RiX21hcChzdHJ1Y3Qgc2VfY21kICopOworZXh0ZXJuIGludCB0cmFuc3BvcnRfZ2VuZXJpY19oYW5kbGVfZGF0YShzdHJ1Y3Qgc2VfY21kICopOworZXh0ZXJuIHZvaWQgdHJhbnNwb3J0X25ld19jbWRfZmFpbHVyZShzdHJ1Y3Qgc2VfY21kICopOworZXh0ZXJuIGludCB0cmFuc3BvcnRfZ2VuZXJpY19oYW5kbGVfdG1yKHN0cnVjdCBzZV9jbWQgKik7CitleHRlcm4gdm9pZCBfX3RyYW5zcG9ydF9zdG9wX3Rhc2tfdGltZXIoc3RydWN0IHNlX3Rhc2sgKiwgdW5zaWduZWQgbG9uZyAqKTsKK2V4dGVybiB1bnNpZ25lZCBjaGFyIHRyYW5zcG9ydF9hc2NpaWhleF90b19iaW5hcnloZXgodW5zaWduZWQgY2hhciB2YWxbMl0pOworZXh0ZXJuIGludCB0cmFuc3BvcnRfZ2VuZXJpY19tYXBfbWVtX3RvX2NtZChzdHJ1Y3Qgc2VfY21kICpjbWQsIHN0cnVjdCBzY2F0dGVybGlzdCAqLCB1MzIsCisJCQkJc3RydWN0IHNjYXR0ZXJsaXN0ICosIHUzMik7CitleHRlcm4gaW50IHRyYW5zcG9ydF9jbGVhcl9sdW5fZnJvbV9zZXNzaW9ucyhzdHJ1Y3Qgc2VfbHVuICopOworZXh0ZXJuIGludCB0cmFuc3BvcnRfY2hlY2tfYWJvcnRlZF9zdGF0dXMoc3RydWN0IHNlX2NtZCAqLCBpbnQpOworZXh0ZXJuIGludCB0cmFuc3BvcnRfc2VuZF9jaGVja19jb25kaXRpb25fYW5kX3NlbnNlKHN0cnVjdCBzZV9jbWQgKiwgdTgsIGludCk7CitleHRlcm4gdm9pZCB0cmFuc3BvcnRfc2VuZF90YXNrX2Fib3J0KHN0cnVjdCBzZV9jbWQgKik7CitleHRlcm4gdm9pZCB0cmFuc3BvcnRfcmVsZWFzZV9jbWRfdG9fcG9vbChzdHJ1Y3Qgc2VfY21kICopOworZXh0ZXJuIHZvaWQgdHJhbnNwb3J0X2dlbmVyaWNfZnJlZV9jbWQoc3RydWN0IHNlX2NtZCAqLCBpbnQsIGludCwgaW50KTsKK2V4dGVybiB2b2lkIHRyYW5zcG9ydF9nZW5lcmljX3dhaXRfZm9yX2NtZHMoc3RydWN0IHNlX2NtZCAqLCBpbnQpOworZXh0ZXJuIHUzMiB0cmFuc3BvcnRfY2FsY19zZ19udW0oc3RydWN0IHNlX3Rhc2sgKiwgc3RydWN0IHNlX21lbSAqLCB1MzIpOworZXh0ZXJuIGludCB0cmFuc3BvcnRfbWFwX21lbV90b19zZyhzdHJ1Y3Qgc2VfdGFzayAqLCBzdHJ1Y3QgbGlzdF9oZWFkICosCisJCQkJCXZvaWQgKiwgc3RydWN0IHNlX21lbSAqLAorCQkJCQlzdHJ1Y3Qgc2VfbWVtICoqLCB1MzIgKiwgdTMyICopOworZXh0ZXJuIHZvaWQgdHJhbnNwb3J0X2RvX3Rhc2tfc2dfY2hhaW4oc3RydWN0IHNlX2NtZCAqKTsKK2V4dGVybiB2b2lkIHRyYW5zcG9ydF9nZW5lcmljX3Byb2Nlc3Nfd3JpdGUoc3RydWN0IHNlX2NtZCAqKTsKK2V4dGVybiBpbnQgdHJhbnNwb3J0X2dlbmVyaWNfZG9fdG1yKHN0cnVjdCBzZV9jbWQgKik7CisvKiBGcm9tIHRhcmdldF9jb3JlX2FsdWEuYyAqLworZXh0ZXJuIGludCBjb3JlX2FsdWFfY2hlY2tfbm9ub3BfZGVsYXkoc3RydWN0IHNlX2NtZCAqKTsKKworLyoKKyAqIEVhY2ggc2VfdHJhbnNwb3J0X3Rhc2tfdCBjYW4gaGF2ZSBOIG51bWJlciBvZiBwb3NzaWJsZSBzdHJ1Y3Qgc2VfdGFzaydzCisgKiBmb3IgdGhlIHN0b3JhZ2UgdHJhbnNwb3J0KHMpIHRvIHBvc3NpYmx5IGV4ZWN1dGUuCisgKiBVc2VkIHByaW1hcmlseSBmb3Igc3BsaXR0aW5nIHVwIENEQnMgdGhhdCBleGNlZWQgdGhlIHBoeXNpY2FsIHN0b3JhZ2UKKyAqIEhCQSdzIG1heGltdW0gc2VjdG9yIGNvdW50IHBlciB0YXNrLgorICovCitzdHJ1Y3Qgc2VfbWVtIHsKKwlzdHJ1Y3QgcGFnZQkqc2VfcGFnZTsKKwl1MzIJCXNlX2xlbjsKKwl1MzIJCXNlX29mZjsKKwlzdHJ1Y3QgbGlzdF9oZWFkIHNlX2xpc3Q7Cit9IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKworLyoKKyAqIAlFYWNoIHR5cGUgb2YgZGlzayB0cmFuc3BvcnQgc3VwcG9ydGVkIE1VU1QgaGF2ZSBhIHRlbXBsYXRlIGRlZmluZWQKKyAqCXdpdGhpbiBpdHMgLmggZmlsZS4KKyAqLworc3RydWN0IHNlX3N1YnN5c3RlbV9hcGkgeworCS8qCisJICogVGhlIE5hbWUuIDotKQorCSAqLworCWNoYXIgbmFtZVsxNl07CisJLyoKKwkgKiBUcmFuc3BvcnQgVHlwZS4KKwkgKi8KKwl1OCB0cmFuc3BvcnRfdHlwZTsKKwkvKgorCSAqIHN0cnVjdCBtb2R1bGUgZm9yIHN0cnVjdCBzZV9oYmEgcmVmZXJlbmNlcworCSAqLworCXN0cnVjdCBtb2R1bGUgKm93bmVyOworCS8qCisJICogVXNlZCBmb3IgZ2xvYmFsIHNlX3N1YnN5c3RlbV9hcGkgbGlzdF9oZWFkCisJICovCisJc3RydWN0IGxpc3RfaGVhZCBzdWJfYXBpX2xpc3Q7CisJLyoKKwkgKiBGb3IgU0NGX1NDU0lfTk9OX0RBVEFfQ0RCCisJICovCisJaW50ICgqY2RiX25vbmUpKHN0cnVjdCBzZV90YXNrICopOworCS8qCisJICogRm9yIFNDRl9TQ1NJX0NPTlRST0xfTk9OU0dfSU9fQ0RCCisJICovCisJaW50ICgqbWFwX3Rhc2tfbm9uX1NHKShzdHJ1Y3Qgc2VfdGFzayAqKTsKKwkvKgorCSAqIEZvciBTQ0ZfU0NTSV9EQVRBX1NHX0lPX0NEQiBhbmQgU0NGX1NDU0lfQ09OVFJPTF9TR19JT19DREIKKwkgKi8KKwlpbnQgKCptYXBfdGFza19TRykoc3RydWN0IHNlX3Rhc2sgKik7CisJLyoKKwkgKiBhdHRhY2hfaGJhKCk6CisJICovCisJaW50ICgqYXR0YWNoX2hiYSkoc3RydWN0IHNlX2hiYSAqLCB1MzIpOworCS8qCisJICogZGV0YWNoX2hiYSgpOgorCSAqLworCXZvaWQgKCpkZXRhY2hfaGJhKShzdHJ1Y3Qgc2VfaGJhICopOworCS8qCisJICogcG1vZGVfaGJhKCk6IFVzZWQgZm9yIFRDTS9wU0NTSSBzdWJzeXN0ZW0gcGx1Z2luIEhCQSAtPgorCSAqCQlMaW51eC9TQ1NJIHN0cnVjdCBTY3NpX0hvc3QgcGFzc3Rocm91Z2gKKwkqLworCWludCAoKnBtb2RlX2VuYWJsZV9oYmEpKHN0cnVjdCBzZV9oYmEgKiwgdW5zaWduZWQgbG9uZyk7CisJLyoKKwkgKiBhbGxvY2F0ZV92aXJ0ZGV2aWNlKCk6CisJICovCisJdm9pZCAqKCphbGxvY2F0ZV92aXJ0ZGV2aWNlKShzdHJ1Y3Qgc2VfaGJhICosIGNvbnN0IGNoYXIgKik7CisJLyoKKwkgKiBjcmVhdGVfdmlydGRldmljZSgpOiBPbmx5IGZvciBWaXJ0dWFsIEhCQXMKKwkgKi8KKwlzdHJ1Y3Qgc2VfZGV2aWNlICooKmNyZWF0ZV92aXJ0ZGV2aWNlKShzdHJ1Y3Qgc2VfaGJhICosCisJCQkJc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKiwgdm9pZCAqKTsKKwkvKgorCSAqIGZyZWVfZGV2aWNlKCk6CisJICovCisJdm9pZCAoKmZyZWVfZGV2aWNlKSh2b2lkICopOworCisJLyoKKwkgKiBkcG9fZW11bGF0ZWQoKToKKwkgKi8KKwlpbnQgKCpkcG9fZW11bGF0ZWQpKHN0cnVjdCBzZV9kZXZpY2UgKik7CisJLyoKKwkgKiBmdWFfd3JpdGVfZW11bGF0ZWQoKToKKwkgKi8KKwlpbnQgKCpmdWFfd3JpdGVfZW11bGF0ZWQpKHN0cnVjdCBzZV9kZXZpY2UgKik7CisJLyoKKwkgKiBmdWFfcmVhZF9lbXVsYXRlZCgpOgorCSAqLworCWludCAoKmZ1YV9yZWFkX2VtdWxhdGVkKShzdHJ1Y3Qgc2VfZGV2aWNlICopOworCS8qCisJICogd3JpdGVfY2FjaGVfZW11bGF0ZWQoKToKKwkgKi8KKwlpbnQgKCp3cml0ZV9jYWNoZV9lbXVsYXRlZCkoc3RydWN0IHNlX2RldmljZSAqKTsKKwkvKgorCSAqIHRyYW5zcG9ydF9jb21wbGV0ZSgpOgorCSAqCisJICogVXNlIHRyYW5zcG9ydF9nZW5lcmljX2NvbXBsZXRlKCkgZm9yIG1ham9yaXR5IG9mIERBUyB0cmFuc3BvcnQKKwkgKiBkcml2ZXJzLiAgUHJvdmlkZWQgb3V0IG9mIGNvbnZlbmllbmNlLgorCSAqLworCWludCAoKnRyYW5zcG9ydF9jb21wbGV0ZSkoc3RydWN0IHNlX3Rhc2sgKnRhc2spOworCXN0cnVjdCBzZV90YXNrICooKmFsbG9jX3Rhc2spKHN0cnVjdCBzZV9jbWQgKik7CisJLyoKKwkgKiBkb190YXNrKCk6CisJICovCisJaW50ICgqZG9fdGFzaykoc3RydWN0IHNlX3Rhc2sgKik7CisJLyoKKwkgKiBVc2VkIGJ5IHZpcnR1YWwgc3Vic3lzdGVtIHBsdWdpbnMgSUJMT0NLIGFuZCBGSUxFSU8gdG8gZW11bGF0ZQorCSAqIFVOTUFQIGFuZCBXUklURV9TQU1FXyogdy8gVU5NQVA9MSA8LT4gTGludXgvQmxvY2sgRGlzY2FyZAorCSAqLworCWludCAoKmRvX2Rpc2NhcmQpKHN0cnVjdCBzZV9kZXZpY2UgKiwgc2VjdG9yX3QsIHUzMik7CisJLyoKKwkgKiBVc2VkICBieSB2aXJ0dWFsIHN1YnN5c3RlbSBwbHVnaW5zIElCTE9DSyBhbmQgRklMRUlPIHRvIGVtdWxhdGUKKwkgKiBTWU5DSFJPTklaRV9DQUNIRV8qIDwtPiBMaW51eC9CbG9jayBibGtkZXZfaXNzdWVfZmx1c2goKQorCSAqLworCXZvaWQgKCpkb19zeW5jX2NhY2hlKShzdHJ1Y3Qgc2VfdGFzayAqKTsKKwkvKgorCSAqIGZyZWVfdGFzaygpOgorCSAqLworCXZvaWQgKCpmcmVlX3Rhc2spKHN0cnVjdCBzZV90YXNrICopOworCS8qCisJICogY2hlY2tfY29uZmlnZnNfZGV2X3BhcmFtcygpOgorCSAqLworCXNzaXplX3QgKCpjaGVja19jb25maWdmc19kZXZfcGFyYW1zKShzdHJ1Y3Qgc2VfaGJhICosIHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICopOworCS8qCisJICogc2V0X2NvbmZpZ2ZzX2Rldl9wYXJhbXMoKToKKwkgKi8KKwlzc2l6ZV90ICgqc2V0X2NvbmZpZ2ZzX2Rldl9wYXJhbXMpKHN0cnVjdCBzZV9oYmEgKiwgc3RydWN0IHNlX3N1YnN5c3RlbV9kZXYgKiwKKwkJCQkJCWNvbnN0IGNoYXIgKiwgc3NpemVfdCk7CisJLyoKKwkgKiBzaG93X2NvbmZpZ2ZzX2Rldl9wYXJhbXMoKToKKwkgKi8KKwlzc2l6ZV90ICgqc2hvd19jb25maWdmc19kZXZfcGFyYW1zKShzdHJ1Y3Qgc2VfaGJhICosIHN0cnVjdCBzZV9zdWJzeXN0ZW1fZGV2ICosCisJCQkJCQljaGFyICopOworCS8qCisJICogZ2V0X2NkYigpOgorCSAqLworCXVuc2lnbmVkIGNoYXIgKigqZ2V0X2NkYikoc3RydWN0IHNlX3Rhc2sgKik7CisJLyoKKwkgKiBnZXRfZGV2aWNlX3JldigpOgorCSAqLworCXUzMiAoKmdldF9kZXZpY2VfcmV2KShzdHJ1Y3Qgc2VfZGV2aWNlICopOworCS8qCisJICogZ2V0X2RldmljZV90eXBlKCk6CisJICovCisJdTMyICgqZ2V0X2RldmljZV90eXBlKShzdHJ1Y3Qgc2VfZGV2aWNlICopOworCS8qCisJICogR2V0IHRoZSBzZWN0b3JfdCBmcm9tIGEgc3Vic3lzdGVtIGJhY2tzdG9yZS4uCisJICovCisJc2VjdG9yX3QgKCpnZXRfYmxvY2tzKShzdHJ1Y3Qgc2VfZGV2aWNlICopOworCS8qCisJICogZG9fc2VfbWVtX21hcCgpOgorCSAqLworCWludCAoKmRvX3NlX21lbV9tYXApKHN0cnVjdCBzZV90YXNrICosIHN0cnVjdCBsaXN0X2hlYWQgKiwgdm9pZCAqLAorCQkJCXN0cnVjdCBzZV9tZW0gKiwgc3RydWN0IHNlX21lbSAqKiwgdTMyICosIHUzMiAqKTsKKwkvKgorCSAqIGdldF9zZW5zZV9idWZmZXIoKToKKwkgKi8KKwl1bnNpZ25lZCBjaGFyICooKmdldF9zZW5zZV9idWZmZXIpKHN0cnVjdCBzZV90YXNrICopOworfSBfX19fY2FjaGVsaW5lX2FsaWduZWQ7CisKKyNkZWZpbmUgVFJBTlNQT1JUKGRldikJCSgoZGV2KS0+dHJhbnNwb3J0KQorI2RlZmluZSBIQkFfVFJBTlNQT1JUKGhiYSkJKChoYmEpLT50cmFuc3BvcnQpCisKK2V4dGVybiBzdHJ1Y3Qgc2VfZ2xvYmFsICpzZV9nbG9iYWw7CisKKyNlbmRpZiAvKiBUQVJHRVRfQ09SRV9UUkFOU1BPUlRfSCAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS90cmFjZS9ldmVudHMvY29tcGFjdGlvbi5oIGIvaW5jbHVkZS90cmFjZS9ldmVudHMvY29tcGFjdGlvbi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjM4OGJjZGQKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL3RyYWNlL2V2ZW50cy9jb21wYWN0aW9uLmgKQEAgLTAsMCArMSw3NCBAQAorI3VuZGVmIFRSQUNFX1NZU1RFTQorI2RlZmluZSBUUkFDRV9TWVNURU0gY29tcGFjdGlvbgorCisjaWYgIWRlZmluZWQoX1RSQUNFX0NPTVBBQ1RJT05fSCkgfHwgZGVmaW5lZChUUkFDRV9IRUFERVJfTVVMVElfUkVBRCkKKyNkZWZpbmUgX1RSQUNFX0NPTVBBQ1RJT05fSAorCisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC90cmFjZXBvaW50Lmg+CisjaW5jbHVkZSAiZ2ZwZmxhZ3MuaCIKKworREVDTEFSRV9FVkVOVF9DTEFTUyhtbV9jb21wYWN0aW9uX2lzb2xhdGVfdGVtcGxhdGUsCisKKwlUUF9QUk9UTyh1bnNpZ25lZCBsb25nIG5yX3NjYW5uZWQsCisJCXVuc2lnbmVkIGxvbmcgbnJfdGFrZW4pLAorCisJVFBfQVJHUyhucl9zY2FubmVkLCBucl90YWtlbiksCisKKwlUUF9TVFJVQ1RfX2VudHJ5KAorCQlfX2ZpZWxkKHVuc2lnbmVkIGxvbmcsIG5yX3NjYW5uZWQpCisJCV9fZmllbGQodW5zaWduZWQgbG9uZywgbnJfdGFrZW4pCisJKSwKKworCVRQX2Zhc3RfYXNzaWduKAorCQlfX2VudHJ5LT5ucl9zY2FubmVkID0gbnJfc2Nhbm5lZDsKKwkJX19lbnRyeS0+bnJfdGFrZW4gPSBucl90YWtlbjsKKwkpLAorCisJVFBfcHJpbnRrKCJucl9zY2FubmVkPSVsdSBucl90YWtlbj0lbHUiLAorCQlfX2VudHJ5LT5ucl9zY2FubmVkLAorCQlfX2VudHJ5LT5ucl90YWtlbikKKyk7CisKK0RFRklORV9FVkVOVChtbV9jb21wYWN0aW9uX2lzb2xhdGVfdGVtcGxhdGUsIG1tX2NvbXBhY3Rpb25faXNvbGF0ZV9taWdyYXRlcGFnZXMsCisKKwlUUF9QUk9UTyh1bnNpZ25lZCBsb25nIG5yX3NjYW5uZWQsCisJCXVuc2lnbmVkIGxvbmcgbnJfdGFrZW4pLAorCisJVFBfQVJHUyhucl9zY2FubmVkLCBucl90YWtlbikKKyk7CisKK0RFRklORV9FVkVOVChtbV9jb21wYWN0aW9uX2lzb2xhdGVfdGVtcGxhdGUsIG1tX2NvbXBhY3Rpb25faXNvbGF0ZV9mcmVlcGFnZXMsCisJVFBfUFJPVE8odW5zaWduZWQgbG9uZyBucl9zY2FubmVkLAorCQl1bnNpZ25lZCBsb25nIG5yX3Rha2VuKSwKKworCVRQX0FSR1MobnJfc2Nhbm5lZCwgbnJfdGFrZW4pCispOworCitUUkFDRV9FVkVOVChtbV9jb21wYWN0aW9uX21pZ3JhdGVwYWdlcywKKworCVRQX1BST1RPKHVuc2lnbmVkIGxvbmcgbnJfbWlncmF0ZWQsCisJCXVuc2lnbmVkIGxvbmcgbnJfZmFpbGVkKSwKKworCVRQX0FSR1MobnJfbWlncmF0ZWQsIG5yX2ZhaWxlZCksCisKKwlUUF9TVFJVQ1RfX2VudHJ5KAorCQlfX2ZpZWxkKHVuc2lnbmVkIGxvbmcsIG5yX21pZ3JhdGVkKQorCQlfX2ZpZWxkKHVuc2lnbmVkIGxvbmcsIG5yX2ZhaWxlZCkKKwkpLAorCisJVFBfZmFzdF9hc3NpZ24oCisJCV9fZW50cnktPm5yX21pZ3JhdGVkID0gbnJfbWlncmF0ZWQ7CisJCV9fZW50cnktPm5yX2ZhaWxlZCA9IG5yX2ZhaWxlZDsKKwkpLAorCisJVFBfcHJpbnRrKCJucl9taWdyYXRlZD0lbHUgbnJfZmFpbGVkPSVsdSIsCisJCV9fZW50cnktPm5yX21pZ3JhdGVkLAorCQlfX2VudHJ5LT5ucl9mYWlsZWQpCispOworCisKKyNlbmRpZiAvKiBfVFJBQ0VfQ09NUEFDVElPTl9IICovCisKKy8qIFRoaXMgcGFydCBtdXN0IGJlIG91dHNpZGUgcHJvdGVjdGlvbiAqLworI2luY2x1ZGUgPHRyYWNlL2RlZmluZV90cmFjZS5oPgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS90cmFjZS9ldmVudHMvbW9kdWxlLmggYi9pbmNsdWRlL3RyYWNlL2V2ZW50cy9tb2R1bGUuaAppbmRleCBjN2JiMmYwLi5jNmJhZTM2IDEwMDY0NAotLS0gYS9pbmNsdWRlL3RyYWNlL2V2ZW50cy9tb2R1bGUuaAorKysgYi9pbmNsdWRlL3RyYWNlL2V2ZW50cy9tb2R1bGUuaApAQCAtMSw1ICsxLDE1IEBACisvKgorICogQmVjYXVzZSBsaW51eC9tb2R1bGUuaCBoYXMgdHJhY2Vwb2ludHMgaW4gdGhlIGhlYWRlciwgYW5kIGZ0cmFjZS5oCisgKiBldmVudHVhbGx5IGluY2x1ZGVzIHRoaXMgZmlsZSwgZGVmaW5lX3RyYWNlLmggaW5jbHVkZXMgbGludXgvbW9kdWxlLmgKKyAqIEJ1dCB3ZSBkbyBub3Qgd2FudCB0aGUgbW9kdWxlLmggdG8gb3ZlcnJpZGUgdGhlIFRSQUNFX1NZU1RFTSBtYWNybworICogdmFyaWFibGUgdGhhdCBkZWZpbmVfdHJhY2UuaCBpcyBwcm9jZXNzaW5nLCBzbyB3ZSBvbmx5IHNldCBpdAorICogd2hlbiBtb2R1bGUgZXZlbnRzIGFyZSBiZWluZyBwcm9jZXNzZWQsIHdoaWNoIHdvdWxkIGhhcHBlbiB3aGVuCisgKiBDUkVBVEVfVFJBQ0VfUE9JTlRTIGlzIGRlZmluZWQuCisgKi8KKyNpZmRlZiBDUkVBVEVfVFJBQ0VfUE9JTlRTCiAjdW5kZWYgVFJBQ0VfU1lTVEVNCiAjZGVmaW5lIFRSQUNFX1NZU1RFTSBtb2R1bGUKKyNlbmRpZgogCiAjaWYgIWRlZmluZWQoX1RSQUNFX01PRFVMRV9IKSB8fCBkZWZpbmVkKFRSQUNFX0hFQURFUl9NVUxUSV9SRUFEKQogI2RlZmluZSBfVFJBQ0VfTU9EVUxFX0gKZGlmZiAtLWdpdCBhL2luY2x1ZGUvdHJhY2UvZXZlbnRzL3Ztc2Nhbi5oIGIvaW5jbHVkZS90cmFjZS9ldmVudHMvdm1zY2FuLmgKaW5kZXggYzI1NWZjYy4uZWE0MjJhYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS90cmFjZS9ldmVudHMvdm1zY2FuLmgKKysrIGIvaW5jbHVkZS90cmFjZS9ldmVudHMvdm1zY2FuLmgKQEAgLTI1LDEzICsyNSwxMyBAQAogCiAjZGVmaW5lIHRyYWNlX3JlY2xhaW1fZmxhZ3MocGFnZSwgc3luYykgKCBcCiAJKHBhZ2VfaXNfZmlsZV9jYWNoZShwYWdlKSA/IFJFQ0xBSU1fV0JfRklMRSA6IFJFQ0xBSU1fV0JfQU5PTikgfCBcCi0JKHN5bmMgPT0gTFVNUFlfTU9ERV9TWU5DID8gUkVDTEFJTV9XQl9TWU5DIDogUkVDTEFJTV9XQl9BU1lOQykgICBcCisJKHN5bmMgJiBSRUNMQUlNX01PREVfU1lOQyA/IFJFQ0xBSU1fV0JfU1lOQyA6IFJFQ0xBSU1fV0JfQVNZTkMpICAgXAogCSkKIAogI2RlZmluZSB0cmFjZV9zaHJpbmtfZmxhZ3MoZmlsZSwgc3luYykgKCBcCi0JKHN5bmMgPT0gTFVNUFlfTU9ERV9TWU5DID8gUkVDTEFJTV9XQl9NSVhFRCA6IFwKKwkoc3luYyAmIFJFQ0xBSU1fTU9ERV9TWU5DID8gUkVDTEFJTV9XQl9NSVhFRCA6IFwKIAkJCShmaWxlID8gUkVDTEFJTV9XQl9GSUxFIDogUkVDTEFJTV9XQl9BTk9OKSkgfCAgXAotCShzeW5jID09IExVTVBZX01PREVfU1lOQyA/IFJFQ0xBSU1fV0JfU1lOQyA6IFJFQ0xBSU1fV0JfQVNZTkMpIFwKKwkoc3luYyAmIFJFQ0xBSU1fTU9ERV9TWU5DID8gUkVDTEFJTV9XQl9TWU5DIDogUkVDTEFJTV9XQl9BU1lOQykgXAogCSkKIAogVFJBQ0VfRVZFTlQobW1fdm1zY2FuX2tzd2FwZF9zbGVlcCwKZGlmZiAtLWdpdCBhL2luY2x1ZGUvdHJhY2UvZXZlbnRzL3dyaXRlYmFjay5oIGIvaW5jbHVkZS90cmFjZS9ldmVudHMvd3JpdGViYWNrLmgKaW5kZXggODlhMmIyZC4uNGUyNDliOSAxMDA2NDQKLS0tIGEvaW5jbHVkZS90cmFjZS9ldmVudHMvd3JpdGViYWNrLmgKKysrIGIvaW5jbHVkZS90cmFjZS9ldmVudHMvd3JpdGViYWNrLmgKQEAgLTgxLDYgKzgxLDcgQEAKIAlUUF9BUkdTKGJkaSkpCiAKIERFRklORV9XUklURUJBQ0tfRVZFTlQod3JpdGViYWNrX25vd29yayk7CitERUZJTkVfV1JJVEVCQUNLX0VWRU5UKHdyaXRlYmFja193YWtlX2JhY2tncm91bmQpOwogREVGSU5FX1dSSVRFQkFDS19FVkVOVCh3cml0ZWJhY2tfd2FrZV90aHJlYWQpOwogREVGSU5FX1dSSVRFQkFDS19FVkVOVCh3cml0ZWJhY2tfd2FrZV9mb3JrZXJfdGhyZWFkKTsKIERFRklORV9XUklURUJBQ0tfRVZFTlQod3JpdGViYWNrX2JkaV9yZWdpc3Rlcik7CmRpZmYgLS1naXQgYS9pbmNsdWRlL3RyYWNlL2Z0cmFjZS5oIGIvaW5jbHVkZS90cmFjZS9mdHJhY2UuaAppbmRleCBlMTY2MTBjLi4zZTY4MzY2IDEwMDY0NAotLS0gYS9pbmNsdWRlL3RyYWNlL2Z0cmFjZS5oCisrKyBiL2luY2x1ZGUvdHJhY2UvZnRyYWNlLmgKQEAgLTQ0NiwxNCArNDQ2LDE2IEBACiAgKgkucmVnCQkJPSBmdHJhY2VfZXZlbnRfcmVnLAogICogfTsKICAqCi0gKiBzdGF0aWMgc3RydWN0IGZ0cmFjZV9ldmVudF9jYWxsIF9fdXNlZAotICogX19hdHRyaWJ1dGVfXygoX19hbGlnbmVkX18oNCkpKQotICogX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiX2Z0cmFjZV9ldmVudHMiKSkpIGV2ZW50XzxjYWxsPiA9IHsKKyAqIHN0YXRpYyBzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgZXZlbnRfPGNhbGw+ID0gewogICoJLm5hbWUJCQk9ICI8Y2FsbD4iLAogICoJLmNsYXNzCQkJPSBldmVudF9jbGFzc188dGVtcGxhdGU+LAogICoJLmV2ZW50CQkJPSAmZnRyYWNlX2V2ZW50X3R5cGVfPGNhbGw+LAogICoJLnByaW50X2ZtdAkJPSBwcmludF9mbXRfPGNhbGw+LAogICogfTsKKyAqIC8vIGl0cyBvbmx5IHNhZmUgdG8gdXNlIHBvaW50ZXJzIHdoZW4gZG9pbmcgbGlua2VyIHRyaWNrcyB0bworICogLy8gY3JlYXRlIGFuIGFycmF5LgorICogc3RhdGljIHN0cnVjdCBmdHJhY2VfZXZlbnRfY2FsbCBfX3VzZWQKKyAqIF9fYXR0cmlidXRlX18oKHNlY3Rpb24oIl9mdHJhY2VfZXZlbnRzIikpKSAqX19ldmVudF88Y2FsbD4gPSAmZXZlbnRfPGNhbGw+OwogICoKICAqLwogCkBAIC01NzksMjggKzU4MSwyOCBAQAogI3VuZGVmIERFRklORV9FVkVOVAogI2RlZmluZSBERUZJTkVfRVZFTlQodGVtcGxhdGUsIGNhbGwsIHByb3RvLCBhcmdzKQkJCVwKIAkJCQkJCQkJCVwKLXN0YXRpYyBzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgX191c2VkCQkJCQlcCi1fX2F0dHJpYnV0ZV9fKChfX2FsaWduZWRfXyg0KSkpCQkJCQkJXAotX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiX2Z0cmFjZV9ldmVudHMiKSkpIGV2ZW50XyMjY2FsbCA9IHsJCVwKK3N0YXRpYyBzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgX191c2VkIGV2ZW50XyMjY2FsbCA9IHsJCQlcCiAJLm5hbWUJCQk9ICNjYWxsLAkJCQlcCiAJLmNsYXNzCQkJPSAmZXZlbnRfY2xhc3NfIyN0ZW1wbGF0ZSwJCVwKIAkuZXZlbnQuZnVuY3MJCT0gJmZ0cmFjZV9ldmVudF90eXBlX2Z1bmNzXyMjdGVtcGxhdGUsCVwKIAkucHJpbnRfZm10CQk9IHByaW50X2ZtdF8jI3RlbXBsYXRlLAkJCVwKLX07Cit9OwkJCQkJCQkJCVwKK3N0YXRpYyBzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgX191c2VkCQkJCQlcCitfX2F0dHJpYnV0ZV9fKChzZWN0aW9uKCJfZnRyYWNlX2V2ZW50cyIpKSkgKl9fZXZlbnRfIyNjYWxsID0gJmV2ZW50XyMjY2FsbAogCiAjdW5kZWYgREVGSU5FX0VWRU5UX1BSSU5UCiAjZGVmaW5lIERFRklORV9FVkVOVF9QUklOVCh0ZW1wbGF0ZSwgY2FsbCwgcHJvdG8sIGFyZ3MsIHByaW50KQkJXAogCQkJCQkJCQkJXAogc3RhdGljIGNvbnN0IGNoYXIgcHJpbnRfZm10XyMjY2FsbFtdID0gcHJpbnQ7CQkJCVwKIAkJCQkJCQkJCVwKLXN0YXRpYyBzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgX191c2VkCQkJCQlcCi1fX2F0dHJpYnV0ZV9fKChfX2FsaWduZWRfXyg0KSkpCQkJCQkJXAotX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiX2Z0cmFjZV9ldmVudHMiKSkpIGV2ZW50XyMjY2FsbCA9IHsJCVwKK3N0YXRpYyBzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgX191c2VkIGV2ZW50XyMjY2FsbCA9IHsJCQlcCiAJLm5hbWUJCQk9ICNjYWxsLAkJCQlcCiAJLmNsYXNzCQkJPSAmZXZlbnRfY2xhc3NfIyN0ZW1wbGF0ZSwJCVwKIAkuZXZlbnQuZnVuY3MJCT0gJmZ0cmFjZV9ldmVudF90eXBlX2Z1bmNzXyMjY2FsbCwJXAogCS5wcmludF9mbXQJCT0gcHJpbnRfZm10XyMjY2FsbCwJCQlcCi19Cit9OwkJCQkJCQkJCVwKK3N0YXRpYyBzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgX191c2VkCQkJCQlcCitfX2F0dHJpYnV0ZV9fKChzZWN0aW9uKCJfZnRyYWNlX2V2ZW50cyIpKSkgKl9fZXZlbnRfIyNjYWxsID0gJmV2ZW50XyMjY2FsbAogCiAjaW5jbHVkZSBUUkFDRV9JTkNMVURFKFRSQUNFX0lOQ0xVREVfRklMRSkKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS94ZW4vZ250ZGV2LmggYi9pbmNsdWRlL3hlbi9nbnRkZXYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lYjIzZjQxCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS94ZW4vZ250ZGV2LmgKQEAgLTAsMCArMSwxMTkgQEAKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIGdudGRldi5oCisgKiAKKyAqIEludGVyZmFjZSB0byAvZGV2L3hlbi9nbnRkZXYuCisgKiAKKyAqIENvcHlyaWdodCAoYykgMjAwNywgRCBHIE11cnJheQorICogCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIKKyAqIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBvciwgd2hlbiBkaXN0cmlidXRlZAorICogc2VwYXJhdGVseSBmcm9tIHRoZSBMaW51eCBrZXJuZWwgb3IgaW5jb3Jwb3JhdGVkIGludG8gb3RoZXIKKyAqIHNvZnR3YXJlIHBhY2thZ2VzLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgbGljZW5zZToKKyAqIAorICogUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEgY29weQorICogb2YgdGhpcyBzb3VyY2UgZmlsZSAodGhlICJTb2Z0d2FyZSIpLCB0byBkZWFsIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0CisgKiByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbiB0aGUgcmlnaHRzIHRvIHVzZSwgY29weSwgbW9kaWZ5LAorICogbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vciBzZWxsIGNvcGllcyBvZiB0aGUgU29mdHdhcmUsCisgKiBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXMgZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvCisgKiB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CisgKiAKKyAqIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluCisgKiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS4KKyAqIAorICogVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEICJBUyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1IKKyAqIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLAorICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFCisgKiBBVVRIT1JTIE9SIENPUFlSSUdIVCBIT0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSCisgKiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORworICogRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUworICogSU4gVEhFIFNPRlRXQVJFLgorICovCisKKyNpZm5kZWYgX19MSU5VWF9QVUJMSUNfR05UREVWX0hfXworI2RlZmluZSBfX0xJTlVYX1BVQkxJQ19HTlRERVZfSF9fCisKK3N0cnVjdCBpb2N0bF9nbnRkZXZfZ3JhbnRfcmVmIHsKKwkvKiBUaGUgZG9tYWluIElEIG9mIHRoZSBncmFudCB0byBiZSBtYXBwZWQuICovCisJdWludDMyX3QgZG9taWQ7CisJLyogVGhlIGdyYW50IHJlZmVyZW5jZSBvZiB0aGUgZ3JhbnQgdG8gYmUgbWFwcGVkLiAqLworCXVpbnQzMl90IHJlZjsKK307CisKKy8qCisgKiBJbnNlcnRzIHRoZSBncmFudCByZWZlcmVuY2VzIGludG8gdGhlIG1hcHBpbmcgdGFibGUgb2YgYW4gaW5zdGFuY2UKKyAqIG9mIGdudGRldi4gTi5CLiBUaGlzIGRvZXMgbm90IHBlcmZvcm0gdGhlIG1hcHBpbmcsIHdoaWNoIGlzIGRlZmVycmVkCisgKiB1bnRpbCBtbWFwKCkgaXMgY2FsbGVkIHdpdGggQGluZGV4IGFzIHRoZSBvZmZzZXQuCisgKi8KKyNkZWZpbmUgSU9DVExfR05UREVWX01BUF9HUkFOVF9SRUYgXAorX0lPQyhfSU9DX05PTkUsICdHJywgMCwgc2l6ZW9mKHN0cnVjdCBpb2N0bF9nbnRkZXZfbWFwX2dyYW50X3JlZikpCitzdHJ1Y3QgaW9jdGxfZ250ZGV2X21hcF9ncmFudF9yZWYgeworCS8qIElOIHBhcmFtZXRlcnMgKi8KKwkvKiBUaGUgbnVtYmVyIG9mIGdyYW50cyB0byBiZSBtYXBwZWQuICovCisJdWludDMyX3QgY291bnQ7CisJdWludDMyX3QgcGFkOworCS8qIE9VVCBwYXJhbWV0ZXJzICovCisJLyogVGhlIG9mZnNldCB0byBiZSB1c2VkIG9uIGEgc3Vic2VxdWVudCBjYWxsIHRvIG1tYXAoKS4gKi8KKwl1aW50NjRfdCBpbmRleDsKKwkvKiBWYXJpYWJsZSBJTiBwYXJhbWV0ZXIuICovCisJLyogQXJyYXkgb2YgZ3JhbnQgcmVmZXJlbmNlcywgb2Ygc2l6ZSBAY291bnQuICovCisJc3RydWN0IGlvY3RsX2dudGRldl9ncmFudF9yZWYgcmVmc1sxXTsKK307CisKKy8qCisgKiBSZW1vdmVzIHRoZSBncmFudCByZWZlcmVuY2VzIGZyb20gdGhlIG1hcHBpbmcgdGFibGUgb2YgYW4gaW5zdGFuY2Ugb2YKKyAqIG9mIGdudGRldi4gTi5CLiBtdW5tYXAoKSBtdXN0IGJlIGNhbGxlZCBvbiB0aGUgcmVsZXZhbnQgdmlydHVhbCBhZGRyZXNzKGVzKQorICogYmVmb3JlIHRoaXMgaW9jdGwgaXMgY2FsbGVkLCBvciBhbiBlcnJvciB3aWxsIHJlc3VsdC4KKyAqLworI2RlZmluZSBJT0NUTF9HTlRERVZfVU5NQVBfR1JBTlRfUkVGIFwKK19JT0MoX0lPQ19OT05FLCAnRycsIDEsIHNpemVvZihzdHJ1Y3QgaW9jdGxfZ250ZGV2X3VubWFwX2dyYW50X3JlZikpCitzdHJ1Y3QgaW9jdGxfZ250ZGV2X3VubWFwX2dyYW50X3JlZiB7CisJLyogSU4gcGFyYW1ldGVycyAqLworCS8qIFRoZSBvZmZzZXQgd2FzIHJldHVybmVkIGJ5IHRoZSBjb3JyZXNwb25kaW5nIG1hcCBvcGVyYXRpb24uICovCisJdWludDY0X3QgaW5kZXg7CisJLyogVGhlIG51bWJlciBvZiBwYWdlcyB0byBiZSB1bm1hcHBlZC4gKi8KKwl1aW50MzJfdCBjb3VudDsKKwl1aW50MzJfdCBwYWQ7Cit9OworCisvKgorICogUmV0dXJucyB0aGUgb2Zmc2V0IGluIHRoZSBkcml2ZXIncyBhZGRyZXNzIHNwYWNlIHRoYXQgY29ycmVzcG9uZHMKKyAqIHRvIEB2YWRkci4gVGhpcyBjYW4gYmUgdXNlZCB0byBwZXJmb3JtIGEgbXVubWFwKCksIGZvbGxvd2VkIGJ5IGFuCisgKiBVTk1BUF9HUkFOVF9SRUYgaW9jdGwsIHdoZXJlIG5vIHN0YXRlIGFib3V0IHRoZSBvZmZzZXQgaXMgcmV0YWluZWQgYnkKKyAqIHRoZSBjYWxsZXIuIFRoZSBudW1iZXIgb2YgcGFnZXMgdGhhdCB3ZXJlIGFsbG9jYXRlZCBhdCB0aGUgc2FtZSB0aW1lIGFzCisgKiBAdmFkZHIgaXMgcmV0dXJuZWQgaW4gQGNvdW50LgorICoKKyAqIE4uQi4gV2hlcmUgbW9yZSB0aGFuIG9uZSBwYWdlIGhhcyBiZWVuIG1hcHBlZCBpbnRvIGEgY29udGlndW91cyByYW5nZSwgdGhlCisgKiAgICAgIHN1cHBsaWVkIEB2YWRkciBtdXN0IGNvcnJlc3BvbmQgdG8gdGhlIHN0YXJ0IG9mIHRoZSByYW5nZTsgb3RoZXJ3aXNlCisgKiAgICAgIGFuIGVycm9yIHdpbGwgcmVzdWx0LiBJdCBpcyBvbmx5IHBvc3NpYmxlIHRvIG11bm1hcCgpIHRoZSBlbnRpcmUKKyAqICAgICAgY29udGlndW91c2x5LWFsbG9jYXRlZCByYW5nZSBhdCBvbmNlLCBhbmQgbm90IGFueSBzdWJyYW5nZSB0aGVyZW9mLgorICovCisjZGVmaW5lIElPQ1RMX0dOVERFVl9HRVRfT0ZGU0VUX0ZPUl9WQUREUiBcCitfSU9DKF9JT0NfTk9ORSwgJ0cnLCAyLCBzaXplb2Yoc3RydWN0IGlvY3RsX2dudGRldl9nZXRfb2Zmc2V0X2Zvcl92YWRkcikpCitzdHJ1Y3QgaW9jdGxfZ250ZGV2X2dldF9vZmZzZXRfZm9yX3ZhZGRyIHsKKwkvKiBJTiBwYXJhbWV0ZXJzICovCisJLyogVGhlIHZpcnR1YWwgYWRkcmVzcyBvZiB0aGUgZmlyc3QgbWFwcGVkIHBhZ2UgaW4gYSByYW5nZS4gKi8KKwl1aW50NjRfdCB2YWRkcjsKKwkvKiBPVVQgcGFyYW1ldGVycyAqLworCS8qIFRoZSBvZmZzZXQgdGhhdCB3YXMgdXNlZCBpbiB0aGUgaW5pdGlhbCBtbWFwKCkgb3BlcmF0aW9uLiAqLworCXVpbnQ2NF90IG9mZnNldDsKKwkvKiBUaGUgbnVtYmVyIG9mIHBhZ2VzIG1hcHBlZCBpbiB0aGUgVk0gYXJlYSB0aGF0IGJlZ2lucyBhdCBAdmFkZHIuICovCisJdWludDMyX3QgY291bnQ7CisJdWludDMyX3QgcGFkOworfTsKKworLyoKKyAqIFNldHMgdGhlIG1heGltdW0gbnVtYmVyIG9mIGdyYW50cyB0aGF0IG1heSBtYXBwZWQgYXQgb25jZSBieSB0aGlzIGdudGRldgorICogaW5zdGFuY2UuCisgKgorICogTi5CLiBUaGlzIG11c3QgYmUgY2FsbGVkIGJlZm9yZSBhbnkgb3RoZXIgaW9jdGwgaXMgcGVyZm9ybWVkIG9uIHRoZSBkZXZpY2UuCisgKi8KKyNkZWZpbmUgSU9DVExfR05UREVWX1NFVF9NQVhfR1JBTlRTIFwKK19JT0MoX0lPQ19OT05FLCAnRycsIDMsIHNpemVvZihzdHJ1Y3QgaW9jdGxfZ250ZGV2X3NldF9tYXhfZ3JhbnRzKSkKK3N0cnVjdCBpb2N0bF9nbnRkZXZfc2V0X21heF9ncmFudHMgeworCS8qIElOIHBhcmFtZXRlciAqLworCS8qIFRoZSBtYXhpbXVtIG51bWJlciBvZiBncmFudHMgdGhhdCBtYXkgYmUgbWFwcGVkIGF0IG9uY2UuICovCisJdWludDMyX3QgY291bnQ7Cit9OworCisjZW5kaWYgLyogX19MSU5VWF9QVUJMSUNfR05UREVWX0hfXyAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS94ZW4vZ3JhbnRfdGFibGUuaCBiL2luY2x1ZGUveGVuL2dyYW50X3RhYmxlLmgKaW5kZXggOWE3MzE3MC4uYjFmYWI2YiAxMDA2NDQKLS0tIGEvaW5jbHVkZS94ZW4vZ3JhbnRfdGFibGUuaAorKysgYi9pbmNsdWRlL3hlbi9ncmFudF90YWJsZS5oCkBAIC0zNywxMCArMzcsMTYgQEAKICNpZm5kZWYgX19BU01fR05UVEFCX0hfXwogI2RlZmluZSBfX0FTTV9HTlRUQUJfSF9fCiAKLSNpbmNsdWRlIDxhc20veGVuL2h5cGVydmlzb3IuaD4KKyNpbmNsdWRlIDxhc20vcGFnZS5oPgorCisjaW5jbHVkZSA8eGVuL2ludGVyZmFjZS94ZW4uaD4KICNpbmNsdWRlIDx4ZW4vaW50ZXJmYWNlL2dyYW50X3RhYmxlLmg+CisKKyNpbmNsdWRlIDxhc20veGVuL2h5cGVydmlzb3IuaD4KICNpbmNsdWRlIDxhc20veGVuL2dyYW50X3RhYmxlLmg+CiAKKyNpbmNsdWRlIDx4ZW4vZmVhdHVyZXMuaD4KKwogLyogTlJfR1JBTlRfRlJBTUVTIG11c3QgYmUgbGVzcyB0aGFuIG9yIGVxdWFsIHRvIHRoYXQgY29uZmlndXJlZCBpbiBYZW4gKi8KICNkZWZpbmUgTlJfR1JBTlRfRlJBTUVTIDQKIApAQCAtMTA3LDYgKzExMywzNyBAQAogdm9pZCBnbnR0YWJfZ3JhbnRfZm9yZWlnbl90cmFuc2Zlcl9yZWYoZ3JhbnRfcmVmX3QsIGRvbWlkX3QgZG9taWQsCiAJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgcGZuKTsKIAorc3RhdGljIGlubGluZSB2b2lkCitnbnR0YWJfc2V0X21hcF9vcChzdHJ1Y3QgZ250dGFiX21hcF9ncmFudF9yZWYgKm1hcCwgcGh5c19hZGRyX3QgYWRkciwKKwkJICB1aW50MzJfdCBmbGFncywgZ3JhbnRfcmVmX3QgcmVmLCBkb21pZF90IGRvbWlkKQoreworCWlmIChmbGFncyAmIEdOVE1BUF9jb250YWluc19wdGUpCisJCW1hcC0+aG9zdF9hZGRyID0gYWRkcjsKKwllbHNlIGlmICh4ZW5fZmVhdHVyZShYRU5GRUFUX2F1dG9fdHJhbnNsYXRlZF9waHlzbWFwKSkKKwkJbWFwLT5ob3N0X2FkZHIgPSBfX3BhKGFkZHIpOworCWVsc2UKKwkJbWFwLT5ob3N0X2FkZHIgPSBhZGRyOworCisJbWFwLT5mbGFncyA9IGZsYWdzOworCW1hcC0+cmVmID0gcmVmOworCW1hcC0+ZG9tID0gZG9taWQ7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAorZ250dGFiX3NldF91bm1hcF9vcChzdHJ1Y3QgZ250dGFiX3VubWFwX2dyYW50X3JlZiAqdW5tYXAsIHBoeXNfYWRkcl90IGFkZHIsCisJCSAgICB1aW50MzJfdCBmbGFncywgZ3JhbnRfaGFuZGxlX3QgaGFuZGxlKQoreworCWlmIChmbGFncyAmIEdOVE1BUF9jb250YWluc19wdGUpCisJCXVubWFwLT5ob3N0X2FkZHIgPSBhZGRyOworCWVsc2UgaWYgKHhlbl9mZWF0dXJlKFhFTkZFQVRfYXV0b190cmFuc2xhdGVkX3BoeXNtYXApKQorCQl1bm1hcC0+aG9zdF9hZGRyID0gX19wYShhZGRyKTsKKwllbHNlCisJCXVubWFwLT5ob3N0X2FkZHIgPSBhZGRyOworCisJdW5tYXAtPmhhbmRsZSA9IGhhbmRsZTsKKwl1bm1hcC0+ZGV2X2J1c19hZGRyID0gMDsKK30KKwogaW50IGFyY2hfZ250dGFiX21hcF9zaGFyZWQodW5zaWduZWQgbG9uZyAqZnJhbWVzLCB1bnNpZ25lZCBsb25nIG5yX2dmcmFtZXMsCiAJCQkgICB1bnNpZ25lZCBsb25nIG1heF9ucl9nZnJhbWVzLAogCQkJICAgc3RydWN0IGdyYW50X2VudHJ5ICoqX19zaGFyZWQpOwpAQCAtMTE4LDQgKzE1NSw5IEBACiAKICNkZWZpbmUgZ250dGFiX21hcF92YWRkcihtYXApICgodm9pZCAqKShtYXAuaG9zdF92aXJ0X2FkZHIpKQogCitpbnQgZ250dGFiX21hcF9yZWZzKHN0cnVjdCBnbnR0YWJfbWFwX2dyYW50X3JlZiAqbWFwX29wcywKKwkJICAgIHN0cnVjdCBwYWdlICoqcGFnZXMsIHVuc2lnbmVkIGludCBjb3VudCk7CitpbnQgZ250dGFiX3VubWFwX3JlZnMoc3RydWN0IGdudHRhYl91bm1hcF9ncmFudF9yZWYgKnVubWFwX29wcywKKwkJICAgICAgc3RydWN0IHBhZ2UgKipwYWdlcywgdW5zaWduZWQgaW50IGNvdW50KTsKKwogI2VuZGlmIC8qIF9fQVNNX0dOVFRBQl9IX18gKi8KZGlmZiAtLWdpdCBhL2luaXQvS2NvbmZpZyBiL2luaXQvS2NvbmZpZwppbmRleCBjYjBiMjA1Li4zZGEwOWRhIDEwMDY0NAotLS0gYS9pbml0L0tjb25maWcKKysrIGIvaW5pdC9LY29uZmlnCkBAIC01MTUsMjEgKzUxNSw2IEBACiAKIAkgIEFjY2VwdCB0aGUgZGVmYXVsdCBpZiB1bnN1cmUuCiAKLWNvbmZpZyBTUkNVX1NZTkNIUk9OSVpFX0RFTEFZCi0JaW50ICJNaWNyb3NlY29uZHMgdG8gZGVsYXkgYmVmb3JlIHdhaXRpbmcgZm9yIHJlYWRlcnMiCi0JcmFuZ2UgMCAyMAotCWRlZmF1bHQgMTAKLQloZWxwCi0JICBUaGlzIG9wdGlvbiBjb250cm9scyBob3cgbG9uZyBTUkNVIGRlbGF5cyBiZWZvcmUgZW50ZXJpbmcgaXRzCi0JICBsb29wIHdhaXRpbmcgb24gU1JDVSByZWFkZXJzLiAgVGhlIHB1cnBvc2Ugb2YgdGhpcyBsb29wIGlzCi0JICB0byBhdm9pZCB0aGUgdW5jb25kaXRpb25hbCBjb250ZXh0LXN3aXRjaCBwZW5hbHR5IHRoYXQgd291bGQKLQkgIG90aGVyd2lzZSBiZSBpbmN1cnJlZCBpZiB0aGVyZSB3YXMgYW4gYWN0aXZlIFNSQ1UgcmVhZGVyLAotCSAgaW4gYSBtYW5uZXIgc2ltaWxhciB0byBhZGFwdGl2ZSBsb2NraW5nIHNjaGVtZXMuICBUaGlzIHNob3VsZAotCSAgYmUgc2V0IHRvIGJlIGEgYml0IGxvbmdlciB0aGFuIHRoZSBjb21tb24tY2FzZSBTUkNVIHJlYWQtc2lkZQotCSAgY3JpdGljYWwtc2VjdGlvbiBvdmVyaGVhZC4KLQotCSAgQWNjZXB0IHRoZSBkZWZhdWx0IGlmIHVuc3VyZS4KLQogZW5kbWVudSAjICJSQ1UgU3Vic3lzdGVtIgogCiBjb25maWcgSUtDT05GSUcKQEAgLTc2MCw4ICs3NDUsOCBAQAogZW5kaWYgIyBDR1JPVVBTCiAKIG1lbnVjb25maWcgTkFNRVNQQUNFUwotCWJvb2wgIk5hbWVzcGFjZXMgc3VwcG9ydCIgaWYgRU1CRURERUQKLQlkZWZhdWx0ICFFTUJFRERFRAorCWJvb2wgIk5hbWVzcGFjZXMgc3VwcG9ydCIgaWYgRVhQRVJUCisJZGVmYXVsdCAhRVhQRVJUCiAJaGVscAogCSAgUHJvdmlkZXMgdGhlIHdheSB0byBtYWtlIHRhc2tzIHdvcmsgd2l0aCBkaWZmZXJlbnQgb2JqZWN0cyB1c2luZwogCSAgdGhlIHNhbWUgaWQuIEZvciBleGFtcGxlIHNhbWUgSVBDIGlkIG1heSByZWZlciB0byBkaWZmZXJlbnQgb2JqZWN0cwpAQCAtOTE0LDIzICs4OTksMzEgQEAKIGNvbmZpZyBBTk9OX0lOT0RFUwogCWJvb2wKIAotbWVudWNvbmZpZyBFTUJFRERFRAotCWJvb2wgIkNvbmZpZ3VyZSBzdGFuZGFyZCBrZXJuZWwgZmVhdHVyZXMgKGZvciBzbWFsbCBzeXN0ZW1zKSIKK21lbnVjb25maWcgRVhQRVJUCisJYm9vbCAiQ29uZmlndXJlIHN0YW5kYXJkIGtlcm5lbCBmZWF0dXJlcyAoZXhwZXJ0IHVzZXJzKSIKIAloZWxwCiAJICBUaGlzIG9wdGlvbiBhbGxvd3MgY2VydGFpbiBiYXNlIGtlcm5lbCBvcHRpb25zIGFuZCBzZXR0aW5ncwogICAgICAgICAgIHRvIGJlIGRpc2FibGVkIG9yIHR3ZWFrZWQuIFRoaXMgaXMgZm9yIHNwZWNpYWxpemVkCiAgICAgICAgICAgZW52aXJvbm1lbnRzIHdoaWNoIGNhbiB0b2xlcmF0ZSBhICJub24tc3RhbmRhcmQiIGtlcm5lbC4KICAgICAgICAgICBPbmx5IHVzZSB0aGlzIGlmIHlvdSByZWFsbHkga25vdyB3aGF0IHlvdSBhcmUgZG9pbmcuCiAKK2NvbmZpZyBFTUJFRERFRAorCWJvb2wgIkVtYmVkZGVkIHN5c3RlbSIKKwlzZWxlY3QgRVhQRVJUCisJaGVscAorCSAgVGhpcyBvcHRpb24gc2hvdWxkIGJlIGVuYWJsZWQgaWYgY29tcGlsaW5nIHRoZSBrZXJuZWwgZm9yCisJICBhbiBlbWJlZGRlZCBzeXN0ZW0gc28gY2VydGFpbiBleHBlcnQgb3B0aW9ucyBhcmUgYXZhaWxhYmxlCisJICBmb3IgY29uZmlndXJhdGlvbi4KKwogY29uZmlnIFVJRDE2Ci0JYm9vbCAiRW5hYmxlIDE2LWJpdCBVSUQgc3lzdGVtIGNhbGxzIiBpZiBFTUJFRERFRAorCWJvb2wgIkVuYWJsZSAxNi1iaXQgVUlEIHN5c3RlbSBjYWxscyIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBBUk0gfHwgQkxBQ0tGSU4gfHwgQ1JJUyB8fCBGUlYgfHwgSDgzMDAgfHwgWDg2XzMyIHx8IE02OEsgfHwgKFMzOTAgJiYgITY0QklUKSB8fCBTVVBFUkggfHwgU1BBUkMzMiB8fCAoU1BBUkM2NCAmJiBDT01QQVQpIHx8IFVNTCB8fCAoWDg2XzY0ICYmIElBMzJfRU1VTEFUSU9OKQogCWRlZmF1bHQgeQogCWhlbHAKIAkgIFRoaXMgZW5hYmxlcyB0aGUgbGVnYWN5IDE2LWJpdCBVSUQgc3lzY2FsbCB3cmFwcGVycy4KIAogY29uZmlnIFNZU0NUTF9TWVNDQUxMCi0JYm9vbCAiU3lzY3RsIHN5c2NhbGwgc3VwcG9ydCIgaWYgRU1CRURERUQKKwlib29sICJTeXNjdGwgc3lzY2FsbCBzdXBwb3J0IiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFBST0NfU1lTQ1RMCiAJZGVmYXVsdCB5CiAJc2VsZWN0IFNZU0NUTApAQCAtOTQ3LDcgKzk0MCw3IEBACiAJICBJZiB1bnN1cmUgc2F5IFkgaGVyZS4KIAogY29uZmlnIEtBTExTWU1TCi0JIGJvb2wgIkxvYWQgYWxsIHN5bWJvbHMgZm9yIGRlYnVnZ2luZy9rc3ltb29wcyIgaWYgRU1CRURERUQKKwkgYm9vbCAiTG9hZCBhbGwgc3ltYm9scyBmb3IgZGVidWdnaW5nL2tzeW1vb3BzIiBpZiBFWFBFUlQKIAkgZGVmYXVsdCB5CiAJIGhlbHAKIAkgICBTYXkgWSBoZXJlIHRvIGxldCB0aGUga2VybmVsIHByaW50IG91dCBzeW1ib2xpYyBjcmFzaCBpbmZvcm1hdGlvbiBhbmQKQEAgLTk3OCw3ICs5NzEsNyBAQAogCiAKIGNvbmZpZyBIT1RQTFVHCi0JYm9vbCAiU3VwcG9ydCBmb3IgaG90LXBsdWdnYWJsZSBkZXZpY2VzIiBpZiBFTUJFRERFRAorCWJvb2wgIlN1cHBvcnQgZm9yIGhvdC1wbHVnZ2FibGUgZGV2aWNlcyIgaWYgRVhQRVJUCiAJZGVmYXVsdCB5CiAJaGVscAogCSAgVGhpcyBvcHRpb24gaXMgcHJvdmlkZWQgZm9yIHRoZSBjYXNlIHdoZXJlIG5vIGhvdHBsdWcgb3IgdWV2ZW50CkBAIC05ODgsNyArOTgxLDcgQEAKIAogY29uZmlnIFBSSU5USwogCWRlZmF1bHQgeQotCWJvb2wgIkVuYWJsZSBzdXBwb3J0IGZvciBwcmludGsiIGlmIEVNQkVEREVECisJYm9vbCAiRW5hYmxlIHN1cHBvcnQgZm9yIHByaW50ayIgaWYgRVhQRVJUCiAJaGVscAogCSAgVGhpcyBvcHRpb24gZW5hYmxlcyBub3JtYWwgcHJpbnRrIHN1cHBvcnQuIFJlbW92aW5nIGl0CiAJICBlbGltaW5hdGVzIG1vc3Qgb2YgdGhlIG1lc3NhZ2Ugc3RyaW5ncyBmcm9tIHRoZSBrZXJuZWwgaW1hZ2UKQEAgLTk5Nyw3ICs5OTAsNyBAQAogCSAgc3Ryb25nbHkgZGlzY291cmFnZWQuCiAKIGNvbmZpZyBCVUcKLQlib29sICJCVUcoKSBzdXBwb3J0IiBpZiBFTUJFRERFRAorCWJvb2wgIkJVRygpIHN1cHBvcnQiIGlmIEVYUEVSVAogCWRlZmF1bHQgeQogCWhlbHAKICAgICAgICAgICBEaXNhYmxpbmcgdGhpcyBvcHRpb24gZWxpbWluYXRlcyBzdXBwb3J0IGZvciBCVUcgYW5kIFdBUk4sIHJlZHVjaW5nCkBAIC0xMDA4LDEyICsxMDAxLDEyIEBACiAKIGNvbmZpZyBFTEZfQ09SRQogCWRlZmF1bHQgeQotCWJvb2wgIkVuYWJsZSBFTEYgY29yZSBkdW1wcyIgaWYgRU1CRURERUQKKwlib29sICJFbmFibGUgRUxGIGNvcmUgZHVtcHMiIGlmIEVYUEVSVAogCWhlbHAKIAkgIEVuYWJsZSBzdXBwb3J0IGZvciBnZW5lcmF0aW5nIGNvcmUgZHVtcHMuIERpc2FibGluZyBzYXZlcyBhYm91dCA0ay4KIAogY29uZmlnIFBDU1BLUl9QTEFURk9STQotCWJvb2wgIkVuYWJsZSBQQy1TcGVha2VyIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiRW5hYmxlIFBDLVNwZWFrZXIgc3VwcG9ydCIgaWYgRVhQRVJUCiAJZGVwZW5kcyBvbiBBTFBIQSB8fCBYODYgfHwgTUlQUyB8fCBQUENfUFJFUCB8fCBQUENfQ0hSUCB8fCBQUENfUFNFUklFUwogCWRlZmF1bHQgeQogCWhlbHAKQEAgLTEwMjIsMTQgKzEwMTUsMTQgQEAKIAogY29uZmlnIEJBU0VfRlVMTAogCWRlZmF1bHQgeQotCWJvb2wgIkVuYWJsZSBmdWxsLXNpemVkIGRhdGEgc3RydWN0dXJlcyBmb3IgY29yZSIgaWYgRU1CRURERUQKKwlib29sICJFbmFibGUgZnVsbC1zaXplZCBkYXRhIHN0cnVjdHVyZXMgZm9yIGNvcmUiIGlmIEVYUEVSVAogCWhlbHAKIAkgIERpc2FibGluZyB0aGlzIG9wdGlvbiByZWR1Y2VzIHRoZSBzaXplIG9mIG1pc2NlbGxhbmVvdXMgY29yZQogCSAga2VybmVsIGRhdGEgc3RydWN0dXJlcy4gVGhpcyBzYXZlcyBtZW1vcnkgb24gc21hbGwgbWFjaGluZXMsCiAJICBidXQgbWF5IHJlZHVjZSBwZXJmb3JtYW5jZS4KIAogY29uZmlnIEZVVEVYCi0JYm9vbCAiRW5hYmxlIGZ1dGV4IHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiRW5hYmxlIGZ1dGV4IHN1cHBvcnQiIGlmIEVYUEVSVAogCWRlZmF1bHQgeQogCXNlbGVjdCBSVF9NVVRFWEVTCiAJaGVscApAQCAtMTAzOCw3ICsxMDMxLDcgQEAKIAkgIHJ1biBnbGliYy1iYXNlZCBhcHBsaWNhdGlvbnMgY29ycmVjdGx5LgogCiBjb25maWcgRVBPTEwKLQlib29sICJFbmFibGUgZXZlbnRwb2xsIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiRW5hYmxlIGV2ZW50cG9sbCBzdXBwb3J0IiBpZiBFWFBFUlQKIAlkZWZhdWx0IHkKIAlzZWxlY3QgQU5PTl9JTk9ERVMKIAloZWxwCkBAIC0xMDQ2LDcgKzEwMzksNyBAQAogCSAgc3VwcG9ydCBmb3IgZXBvbGwgZmFtaWx5IG9mIHN5c3RlbSBjYWxscy4KIAogY29uZmlnIFNJR05BTEZECi0JYm9vbCAiRW5hYmxlIHNpZ25hbGZkKCkgc3lzdGVtIGNhbGwiIGlmIEVNQkVEREVECisJYm9vbCAiRW5hYmxlIHNpZ25hbGZkKCkgc3lzdGVtIGNhbGwiIGlmIEVYUEVSVAogCXNlbGVjdCBBTk9OX0lOT0RFUwogCWRlZmF1bHQgeQogCWhlbHAKQEAgLTEwNTYsNyArMTA0OSw3IEBACiAJICBJZiB1bnN1cmUsIHNheSBZLgogCiBjb25maWcgVElNRVJGRAotCWJvb2wgIkVuYWJsZSB0aW1lcmZkKCkgc3lzdGVtIGNhbGwiIGlmIEVNQkVEREVECisJYm9vbCAiRW5hYmxlIHRpbWVyZmQoKSBzeXN0ZW0gY2FsbCIgaWYgRVhQRVJUCiAJc2VsZWN0IEFOT05fSU5PREVTCiAJZGVmYXVsdCB5CiAJaGVscApAQCAtMTA2Niw3ICsxMDU5LDcgQEAKIAkgIElmIHVuc3VyZSwgc2F5IFkuCiAKIGNvbmZpZyBFVkVOVEZECi0JYm9vbCAiRW5hYmxlIGV2ZW50ZmQoKSBzeXN0ZW0gY2FsbCIgaWYgRU1CRURERUQKKwlib29sICJFbmFibGUgZXZlbnRmZCgpIHN5c3RlbSBjYWxsIiBpZiBFWFBFUlQKIAlzZWxlY3QgQU5PTl9JTk9ERVMKIAlkZWZhdWx0IHkKIAloZWxwCkBAIC0xMDc2LDcgKzEwNjksNyBAQAogCSAgSWYgdW5zdXJlLCBzYXkgWS4KIAogY29uZmlnIFNITUVNCi0JYm9vbCAiVXNlIGZ1bGwgc2htZW0gZmlsZXN5c3RlbSIgaWYgRU1CRURERUQKKwlib29sICJVc2UgZnVsbCBzaG1lbSBmaWxlc3lzdGVtIiBpZiBFWFBFUlQKIAlkZWZhdWx0IHkKIAlkZXBlbmRzIG9uIE1NVQogCWhlbHAKQEAgLTEwODcsNyArMTA4MCw3IEBACiAJICB3aGljaCBtYXkgYmUgYXBwcm9wcmlhdGUgb24gc21hbGwgc3lzdGVtcyB3aXRob3V0IHN3YXAuCiAKIGNvbmZpZyBBSU8KLQlib29sICJFbmFibGUgQUlPIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiRW5hYmxlIEFJTyBzdXBwb3J0IiBpZiBFWFBFUlQKIAlkZWZhdWx0IHkKIAloZWxwCiAJICBUaGlzIG9wdGlvbiBlbmFibGVzIFBPU0lYIGFzeW5jaHJvbm91cyBJL08gd2hpY2ggbWF5IGJ5IHVzZWQKQEAgLTExNjQsMTYgKzExNTcsMTYgQEAKIAogY29uZmlnIFZNX0VWRU5UX0NPVU5URVJTCiAJZGVmYXVsdCB5Ci0JYm9vbCAiRW5hYmxlIFZNIGV2ZW50IGNvdW50ZXJzIGZvciAvcHJvYy92bXN0YXQiIGlmIEVNQkVEREVECisJYm9vbCAiRW5hYmxlIFZNIGV2ZW50IGNvdW50ZXJzIGZvciAvcHJvYy92bXN0YXQiIGlmIEVYUEVSVAogCWhlbHAKIAkgIFZNIGV2ZW50IGNvdW50ZXJzIGFyZSBuZWVkZWQgZm9yIGV2ZW50IGNvdW50cyB0byBiZSBzaG93bi4KIAkgIFRoaXMgb3B0aW9uIGFsbG93cyB0aGUgZGlzYWJsaW5nIG9mIHRoZSBWTSBldmVudCBjb3VudGVycwotCSAgb24gRU1CRURERUQgc3lzdGVtcy4gIC9wcm9jL3Ztc3RhdCB3aWxsIG9ubHkgc2hvdyBwYWdlIGNvdW50cworCSAgb24gRVhQRVJUIHN5c3RlbXMuICAvcHJvYy92bXN0YXQgd2lsbCBvbmx5IHNob3cgcGFnZSBjb3VudHMKIAkgIGlmIFZNIGV2ZW50IGNvdW50ZXJzIGFyZSBkaXNhYmxlZC4KIAogY29uZmlnIFBDSV9RVUlSS1MKIAlkZWZhdWx0IHkKLQlib29sICJFbmFibGUgUENJIHF1aXJrIHdvcmthcm91bmRzIiBpZiBFTUJFRERFRAorCWJvb2wgIkVuYWJsZSBQQ0kgcXVpcmsgd29ya2Fyb3VuZHMiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gUENJCiAJaGVscAogCSAgVGhpcyBlbmFibGVzIHdvcmthcm91bmRzIGZvciB2YXJpb3VzIFBDSSBjaGlwc2V0CkBAIC0xMTgyLDcgKzExNzUsNyBAQAogCiBjb25maWcgU0xVQl9ERUJVRwogCWRlZmF1bHQgeQotCWJvb2wgIkVuYWJsZSBTTFVCIGRlYnVnZ2luZyBzdXBwb3J0IiBpZiBFTUJFRERFRAorCWJvb2wgIkVuYWJsZSBTTFVCIGRlYnVnZ2luZyBzdXBwb3J0IiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIFNMVUIgJiYgU1lTRlMKIAloZWxwCiAJICBTTFVCIGhhcyBleHRlbnNpdmUgZGVidWcgc3VwcG9ydCBmZWF0dXJlcy4gRGlzYWJsaW5nIHRoZXNlIGNhbgpAQCAtMTIyNiw3ICsxMjE5LDcgQEAKIAkgICBhIHNsYWIgYWxsb2NhdG9yLgogCiBjb25maWcgU0xPQgotCWRlcGVuZHMgb24gRU1CRURERUQKKwlkZXBlbmRzIG9uIEVYUEVSVAogCWJvb2wgIlNMT0IgKFNpbXBsZSBBbGxvY2F0b3IpIgogCWhlbHAKIAkgICBTTE9CIHJlcGxhY2VzIHRoZSBzdG9jayBhbGxvY2F0b3Igd2l0aCBhIGRyYXN0aWNhbGx5IHNpbXBsZXIKQEAgLTEyMzcsNyArMTIzMCw3IEBACiAKIGNvbmZpZyBNTUFQX0FMTE9XX1VOSU5JVElBTElaRUQKIAlib29sICJBbGxvdyBtbWFwcGVkIGFub255bW91cyBtZW1vcnkgdG8gYmUgdW5pbml0aWFsaXplZCIKLQlkZXBlbmRzIG9uIEVNQkVEREVEICYmICFNTVUKKwlkZXBlbmRzIG9uIEVYUEVSVCAmJiAhTU1VCiAJZGVmYXVsdCBuCiAJaGVscAogCSAgTm9ybWFsbHksIGFuZCBhY2NvcmRpbmcgdG8gdGhlIExpbnV4IHNwZWMsIGFub255bW91cyBtZW1vcnkgb2J0YWluZWQKZGlmZiAtLWdpdCBhL2luaXQvY2FsaWJyYXRlLmMgYi9pbml0L2NhbGlicmF0ZS5jCmluZGV4IDZlYjQ4ZTUuLjI0ZmUwMjIgMTAwNjQ0Ci0tLSBhL2luaXQvY2FsaWJyYXRlLmMKKysrIGIvaW5pdC9jYWxpYnJhdGUuYwpAQCAtNjYsNyArNjYsNyBAQAogCQlwcmVfc3RhcnQgPSAwOwogCQlyZWFkX2N1cnJlbnRfdGltZXIoJnN0YXJ0KTsKIAkJc3RhcnRfamlmZmllcyA9IGppZmZpZXM7Ci0JCXdoaWxlIChqaWZmaWVzIDw9IChzdGFydF9qaWZmaWVzICsgMSkpIHsKKwkJd2hpbGUgKHRpbWVfYmVmb3JlX2VxKGppZmZpZXMsIHN0YXJ0X2ppZmZpZXMgKyAxKSkgewogCQkJcHJlX3N0YXJ0ID0gc3RhcnQ7CiAJCQlyZWFkX2N1cnJlbnRfdGltZXIoJnN0YXJ0KTsKIAkJfQpAQCAtNzQsOCArNzQsOCBAQAogCiAJCXByZV9lbmQgPSAwOwogCQllbmQgPSBwb3N0X3N0YXJ0OwotCQl3aGlsZSAoamlmZmllcyA8PQotCQkgICAgICAgKHN0YXJ0X2ppZmZpZXMgKyAxICsgREVMQVlfQ0FMSUJSQVRJT05fVElDS1MpKSB7CisJCXdoaWxlICh0aW1lX2JlZm9yZV9lcShqaWZmaWVzLCBzdGFydF9qaWZmaWVzICsgMSArCisJCQkJCSAgICAgICBERUxBWV9DQUxJQlJBVElPTl9USUNLUykpIHsKIAkJCXByZV9lbmQgPSBlbmQ7CiAJCQlyZWFkX2N1cnJlbnRfdGltZXIoJmVuZCk7CiAJCX0KZGlmZiAtLWdpdCBhL2luaXQvbWFpbi5jIGIvaW5pdC9tYWluLmMKaW5kZXggMDA3OTljMS4uMzNjMzdjMyAxMDA2NDQKLS0tIGEvaW5pdC9tYWluLmMKKysrIGIvaW5pdC9tYWluLmMKQEAgLTk2LDYgKzk2LDE1IEBACiBleHRlcm4gdm9pZCB0Y19pbml0KHZvaWQpOwogI2VuZGlmCiAKKy8qCisgKiBEZWJ1ZyBoZWxwZXI6IHZpYSB0aGlzIGZsYWcgd2Uga25vdyB0aGF0IHdlIGFyZSBpbiAnZWFybHkgYm9vdHVwIGNvZGUnCisgKiB3aGVyZSBvbmx5IHRoZSBib290IHByb2Nlc3NvciBpcyBydW5uaW5nIHdpdGggSVJRIGRpc2FibGVkLiAgVGhpcyBtZWFucworICogdHdvIHRoaW5ncyAtIElSUSBtdXN0IG5vdCBiZSBlbmFibGVkIGJlZm9yZSB0aGUgZmxhZyBpcyBjbGVhcmVkIGFuZCBzb21lCisgKiBvcGVyYXRpb25zIHdoaWNoIGFyZSBub3QgYWxsb3dlZCB3aXRoIElSUSBkaXNhYmxlZCBhcmUgYWxsb3dlZCB3aGlsZSB0aGUKKyAqIGZsYWcgaXMgc2V0LgorICovCitib29sIGVhcmx5X2Jvb3RfaXJxc19kaXNhYmxlZCBfX3JlYWRfbW9zdGx5OworCiBlbnVtIHN5c3RlbV9zdGF0ZXMgc3lzdGVtX3N0YXRlIF9fcmVhZF9tb3N0bHk7CiBFWFBPUlRfU1lNQk9MKHN5c3RlbV9zdGF0ZSk7CiAKQEAgLTU1NCw3ICs1NjMsNyBAQAogCWNncm91cF9pbml0X2Vhcmx5KCk7CiAKIAlsb2NhbF9pcnFfZGlzYWJsZSgpOwotCWVhcmx5X2Jvb3RfaXJxc19vZmYoKTsKKwllYXJseV9ib290X2lycXNfZGlzYWJsZWQgPSB0cnVlOwogCiAvKgogICogSW50ZXJydXB0cyBhcmUgc3RpbGwgZGlzYWJsZWQuIERvIG5lY2Vzc2FyeSBzZXR1cHMsIHRoZW4KQEAgLTYyMSw3ICs2MzAsNyBAQAogCWlmICghaXJxc19kaXNhYmxlZCgpKQogCQlwcmludGsoS0VSTl9DUklUICJzdGFydF9rZXJuZWwoKTogYnVnOiBpbnRlcnJ1cHRzIHdlcmUgIgogCQkJCSAiZW5hYmxlZCBlYXJseVxuIik7Ci0JZWFybHlfYm9vdF9pcnFzX29uKCk7CisJZWFybHlfYm9vdF9pcnFzX2Rpc2FibGVkID0gZmFsc2U7CiAJbG9jYWxfaXJxX2VuYWJsZSgpOwogCiAJLyogSW50ZXJydXB0cyBhcmUgZW5hYmxlZCBub3cgc28gYWxsIEdGUCBhbGxvY2F0aW9ucyBhcmUgc2FmZS4gKi8KZGlmZiAtLWdpdCBhL2tlcm5lbC9jYXBhYmlsaXR5LmMgYi9rZXJuZWwvY2FwYWJpbGl0eS5jCmluZGV4IDJmMDUzMDMuLjllOTM4NWYgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9jYXBhYmlsaXR5LmMKKysrIGIva2VybmVsL2NhcGFiaWxpdHkuYwpAQCAtMzA2LDcgKzMwNiw3IEBACiAJCUJVRygpOwogCX0KIAotCWlmIChzZWN1cml0eV9jYXBhYmxlKGNhcCkgPT0gMCkgeworCWlmIChzZWN1cml0eV9jYXBhYmxlKGN1cnJlbnRfY3JlZCgpLCBjYXApID09IDApIHsKIAkJY3VycmVudC0+ZmxhZ3MgfD0gUEZfU1VQRVJQUklWOwogCQlyZXR1cm4gMTsKIAl9CmRpZmYgLS1naXQgYS9rZXJuZWwvY2dyb3VwLmMgYi9rZXJuZWwvY2dyb3VwLmMKaW5kZXggNWM1ZjRjYy4uYjI0ZDcwMiAxMDA2NDQKLS0tIGEva2VybmVsL2Nncm91cC5jCisrKyBiL2tlcm5lbC9jZ3JvdXAuYwpAQCAtNzY0LDYgKzc2NCw3IEBACiAgKi8KIAogc3RhdGljIGludCBjZ3JvdXBfbWtkaXIoc3RydWN0IGlub2RlICpkaXIsIHN0cnVjdCBkZW50cnkgKmRlbnRyeSwgaW50IG1vZGUpOworc3RhdGljIHN0cnVjdCBkZW50cnkgKmNncm91cF9sb29rdXAoc3RydWN0IGlub2RlICosIHN0cnVjdCBkZW50cnkgKiwgc3RydWN0IG5hbWVpZGF0YSAqKTsKIHN0YXRpYyBpbnQgY2dyb3VwX3JtZGlyKHN0cnVjdCBpbm9kZSAqdW51c2VkX2Rpciwgc3RydWN0IGRlbnRyeSAqZGVudHJ5KTsKIHN0YXRpYyBpbnQgY2dyb3VwX3BvcHVsYXRlX2RpcihzdHJ1Y3QgY2dyb3VwICpjZ3JwKTsKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgaW5vZGVfb3BlcmF0aW9ucyBjZ3JvdXBfZGlyX2lub2RlX29wZXJhdGlvbnM7CkBAIC04NjAsNiArODYxLDExIEBACiAJaXB1dChpbm9kZSk7CiB9CiAKK3N0YXRpYyBpbnQgY2dyb3VwX2RlbGV0ZShjb25zdCBzdHJ1Y3QgZGVudHJ5ICpkKQoreworCXJldHVybiAxOworfQorCiBzdGF0aWMgdm9pZCByZW1vdmVfZGlyKHN0cnVjdCBkZW50cnkgKmQpCiB7CiAJc3RydWN0IGRlbnRyeSAqcGFyZW50ID0gZGdldChkLT5kX3BhcmVudCk7CkBAIC05MTAsNyArOTE2LDcgQEAKIAogCXBhcmVudCA9IGRlbnRyeS0+ZF9wYXJlbnQ7CiAJc3Bpbl9sb2NrKCZwYXJlbnQtPmRfbG9jayk7Ci0Jc3Bpbl9sb2NrKCZkZW50cnktPmRfbG9jayk7CisJc3Bpbl9sb2NrX25lc3RlZCgmZGVudHJ5LT5kX2xvY2ssIERFTlRSWV9EX0xPQ0tfTkVTVEVEKTsKIAlsaXN0X2RlbF9pbml0KCZkZW50cnktPmRfdS5kX2NoaWxkKTsKIAlzcGluX3VubG9jaygmZGVudHJ5LT5kX2xvY2spOwogCXNwaW5fdW5sb2NrKCZwYXJlbnQtPmRfbG9jayk7CkBAIC0xNDUxLDYgKzE0NTcsNyBAQAogewogCXN0YXRpYyBjb25zdCBzdHJ1Y3QgZGVudHJ5X29wZXJhdGlvbnMgY2dyb3VwX2RvcHMgPSB7CiAJCS5kX2lwdXQgPSBjZ3JvdXBfZGlwdXQsCisJCS5kX2RlbGV0ZSA9IGNncm91cF9kZWxldGUsCiAJfTsKIAogCXN0cnVjdCBpbm9kZSAqaW5vZGUgPQpAQCAtMjE5NSwxMiArMjIwMiwyMCBAQAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBpbm9kZV9vcGVyYXRpb25zIGNncm91cF9kaXJfaW5vZGVfb3BlcmF0aW9ucyA9IHsKLQkubG9va3VwID0gc2ltcGxlX2xvb2t1cCwKKwkubG9va3VwID0gY2dyb3VwX2xvb2t1cCwKIAkubWtkaXIgPSBjZ3JvdXBfbWtkaXIsCiAJLnJtZGlyID0gY2dyb3VwX3JtZGlyLAogCS5yZW5hbWUgPSBjZ3JvdXBfcmVuYW1lLAogfTsKIAorc3RhdGljIHN0cnVjdCBkZW50cnkgKmNncm91cF9sb29rdXAoc3RydWN0IGlub2RlICpkaXIsIHN0cnVjdCBkZW50cnkgKmRlbnRyeSwgc3RydWN0IG5hbWVpZGF0YSAqbmQpCit7CisJaWYgKGRlbnRyeS0+ZF9uYW1lLmxlbiA+IE5BTUVfTUFYKQorCQlyZXR1cm4gRVJSX1BUUigtRU5BTUVUT09MT05HKTsKKwlkX2FkZChkZW50cnksIE5VTEwpOworCXJldHVybiBOVUxMOworfQorCiAvKgogICogQ2hlY2sgaWYgYSBmaWxlIGlzIGEgY29udHJvbCBmaWxlCiAgKi8KZGlmZiAtLWdpdCBhL2tlcm5lbC9jcmVkLmMgYi9rZXJuZWwvY3JlZC5jCmluZGV4IDZhMWFhMDAuLjNhOWQ2ZGQgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9jcmVkLmMKKysrIGIva2VybmVsL2NyZWQuYwpAQCAtMjUyLDEzICsyNTIsMTMgQEAKICNlbmRpZgogCiAJYXRvbWljX3NldCgmbmV3LT51c2FnZSwgMSk7CisjaWZkZWYgQ09ORklHX0RFQlVHX0NSRURFTlRJQUxTCisJbmV3LT5tYWdpYyA9IENSRURfTUFHSUM7CisjZW5kaWYKIAogCWlmIChzZWN1cml0eV9jcmVkX2FsbG9jX2JsYW5rKG5ldywgR0ZQX0tFUk5FTCkgPCAwKQogCQlnb3RvIGVycm9yOwogCi0jaWZkZWYgQ09ORklHX0RFQlVHX0NSRURFTlRJQUxTCi0JbmV3LT5tYWdpYyA9IENSRURfTUFHSUM7Ci0jZW5kaWYKIAlyZXR1cm4gbmV3OwogCiBlcnJvcjoKQEAgLTY1Nyw2ICs2NTcsOCBAQAogCXZhbGlkYXRlX2NyZWRzKG9sZCk7CiAKIAkqbmV3ID0gKm9sZDsKKwlhdG9taWNfc2V0KCZuZXctPnVzYWdlLCAxKTsKKwlzZXRfY3JlZF9zdWJzY3JpYmVycyhuZXcsIDApOwogCWdldF91aWQobmV3LT51c2VyKTsKIAlnZXRfZ3JvdXBfaW5mbyhuZXctPmdyb3VwX2luZm8pOwogCkBAIC02NzQsOCArNjc2LDYgQEAKIAlpZiAoc2VjdXJpdHlfcHJlcGFyZV9jcmVkcyhuZXcsIG9sZCwgR0ZQX0tFUk5FTCkgPCAwKQogCQlnb3RvIGVycm9yOwogCi0JYXRvbWljX3NldCgmbmV3LT51c2FnZSwgMSk7Ci0Jc2V0X2NyZWRfc3Vic2NyaWJlcnMobmV3LCAwKTsKIAlwdXRfY3JlZChvbGQpOwogCXZhbGlkYXRlX2NyZWRzKG5ldyk7CiAJcmV0dXJuIG5ldzsKQEAgLTc0OCw3ICs3NDgsMTEgQEAKIAlpZiAoY3JlZC0+bWFnaWMgIT0gQ1JFRF9NQUdJQykKIAkJcmV0dXJuIHRydWU7CiAjaWZkZWYgQ09ORklHX1NFQ1VSSVRZX1NFTElOVVgKLQlpZiAoc2VsaW51eF9pc19lbmFibGVkKCkpIHsKKwkvKgorCSAqIGNyZWQtPnNlY3VyaXR5ID09IE5VTEwgaWYgc2VjdXJpdHlfY3JlZF9hbGxvY19ibGFuaygpIG9yCisJICogc2VjdXJpdHlfcHJlcGFyZV9jcmVkcygpIHJldHVybmVkIGFuIGVycm9yLgorCSAqLworCWlmIChzZWxpbnV4X2lzX2VuYWJsZWQoKSAmJiBjcmVkLT5zZWN1cml0eSkgewogCQlpZiAoKHVuc2lnbmVkIGxvbmcpIGNyZWQtPnNlY3VyaXR5IDwgUEFHRV9TSVpFKQogCQkJcmV0dXJuIHRydWU7CiAJCWlmICgoKih1MzIgKiljcmVkLT5zZWN1cml0eSAmIDB4ZmZmZmZmMDApID09CmRpZmYgLS1naXQgYS9rZXJuZWwvZm9yay5jIGIva2VybmVsL2ZvcmsuYwppbmRleCBkOWI0NGYyLi4yNWU0MjkxIDEwMDY0NAotLS0gYS9rZXJuZWwvZm9yay5jCisrKyBiL2tlcm5lbC9mb3JrLmMKQEAgLTY2LDYgKzY2LDcgQEAKICNpbmNsdWRlIDxsaW51eC9wb3NpeC10aW1lcnMuaD4KICNpbmNsdWRlIDxsaW51eC91c2VyLXJldHVybi1ub3RpZmllci5oPgogI2luY2x1ZGUgPGxpbnV4L29vbS5oPgorI2luY2x1ZGUgPGxpbnV4L2todWdlcGFnZWQuaD4KIAogI2luY2x1ZGUgPGFzbS9wZ3RhYmxlLmg+CiAjaW5jbHVkZSA8YXNtL3BnYWxsb2MuaD4KQEAgLTMzMCw2ICszMzEsOSBAQAogCXJldHZhbCA9IGtzbV9mb3JrKG1tLCBvbGRtbSk7CiAJaWYgKHJldHZhbCkKIAkJZ290byBvdXQ7CisJcmV0dmFsID0ga2h1Z2VwYWdlZF9mb3JrKG1tLCBvbGRtbSk7CisJaWYgKHJldHZhbCkKKwkJZ290byBvdXQ7CiAKIAlwcmV2ID0gTlVMTDsKIAlmb3IgKG1wbnQgPSBvbGRtbS0+bW1hcDsgbXBudDsgbXBudCA9IG1wbnQtPnZtX25leHQpIHsKQEAgLTUyOSw2ICs1MzMsOSBAQAogCW1tX2ZyZWVfcGdkKG1tKTsKIAlkZXN0cm95X2NvbnRleHQobW0pOwogCW1tdV9ub3RpZmllcl9tbV9kZXN0cm95KG1tKTsKKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UKKwlWTV9CVUdfT04obW0tPnBtZF9odWdlX3B0ZSk7CisjZW5kaWYKIAlmcmVlX21tKG1tKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKF9fbW1kcm9wKTsKQEAgLTU0Myw2ICs1NTAsNyBAQAogCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZtbS0+bW1fdXNlcnMpKSB7CiAJCWV4aXRfYWlvKG1tKTsKIAkJa3NtX2V4aXQobW0pOworCQlraHVnZXBhZ2VkX2V4aXQobW0pOyAvKiBtdXN0IHJ1biBiZWZvcmUgZXhpdF9tbWFwICovCiAJCWV4aXRfbW1hcChtbSk7CiAJCXNldF9tbV9leGVfZmlsZShtbSwgTlVMTCk7CiAJCWlmICghbGlzdF9lbXB0eSgmbW0tPm1tbGlzdCkpIHsKQEAgLTY2OSw2ICs2NzcsMTAgQEAKIAltbS0+dG9rZW5fcHJpb3JpdHkgPSAwOwogCW1tLT5sYXN0X2ludGVydmFsID0gMDsKIAorI2lmZGVmIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRQorCW1tLT5wbWRfaHVnZV9wdGUgPSBOVUxMOworI2VuZGlmCisKIAlpZiAoIW1tX2luaXQobW0sIHRzaykpCiAJCWdvdG8gZmFpbF9ub21lbTsKIApAQCAtOTEwLDYgKzkyMiw3IEBACiAKIAlzaWctPm9vbV9hZGogPSBjdXJyZW50LT5zaWduYWwtPm9vbV9hZGo7CiAJc2lnLT5vb21fc2NvcmVfYWRqID0gY3VycmVudC0+c2lnbmFsLT5vb21fc2NvcmVfYWRqOworCXNpZy0+b29tX3Njb3JlX2Fkal9taW4gPSBjdXJyZW50LT5zaWduYWwtPm9vbV9zY29yZV9hZGpfbWluOwogCiAJbXV0ZXhfaW5pdCgmc2lnLT5jcmVkX2d1YXJkX211dGV4KTsKIApAQCAtMTQxMCwyMyArMTQyMyw2IEBACiAJfQogCiAJLyoKLQkgKiBXZSBob3BlIHRvIHJlY3ljbGUgdGhlc2UgZmxhZ3MgYWZ0ZXIgMi42LjI2Ci0JICovCi0JaWYgKHVubGlrZWx5KGNsb25lX2ZsYWdzICYgQ0xPTkVfU1RPUFBFRCkpIHsKLQkJc3RhdGljIGludCBfX3JlYWRfbW9zdGx5IGNvdW50ID0gMTAwOwotCi0JCWlmIChjb3VudCA+IDAgJiYgcHJpbnRrX3JhdGVsaW1pdCgpKSB7Ci0JCQljaGFyIGNvbW1bVEFTS19DT01NX0xFTl07Ci0KLQkJCWNvdW50LS07Ci0JCQlwcmludGsoS0VSTl9JTkZPICJmb3JrKCk6IHByb2Nlc3MgYCVzJyB1c2VkIGRlcHJlY2F0ZWQgIgotCQkJCQkiY2xvbmUgZmxhZ3MgMHglbHhcbiIsCi0JCQkJZ2V0X3Rhc2tfY29tbShjb21tLCBjdXJyZW50KSwKLQkJCQljbG9uZV9mbGFncyAmIENMT05FX1NUT1BQRUQpOwotCQl9Ci0JfQotCi0JLyoKIAkgKiBXaGVuIGNhbGxlZCBmcm9tIGtlcm5lbF90aHJlYWQsIGRvbid0IGRvIHVzZXIgdHJhY2luZyBzdHVmZi4KIAkgKi8KIAlpZiAobGlrZWx5KHVzZXJfbW9kZShyZWdzKSkpCkBAIC0xNDY0LDE2ICsxNDYwLDcgQEAKIAkJICovCiAJCXAtPmZsYWdzICY9IH5QRl9TVEFSVElORzsKIAotCQlpZiAodW5saWtlbHkoY2xvbmVfZmxhZ3MgJiBDTE9ORV9TVE9QUEVEKSkgewotCQkJLyoKLQkJCSAqIFdlJ2xsIHN0YXJ0IHVwIHdpdGggYW4gaW1tZWRpYXRlIFNJR1NUT1AuCi0JCQkgKi8KLQkJCXNpZ2FkZHNldCgmcC0+cGVuZGluZy5zaWduYWwsIFNJR1NUT1ApOwotCQkJc2V0X3Rza190aHJlYWRfZmxhZyhwLCBUSUZfU0lHUEVORElORyk7Ci0JCQlfX3NldF90YXNrX3N0YXRlKHAsIFRBU0tfU1RPUFBFRCk7Ci0JCX0gZWxzZSB7Ci0JCQl3YWtlX3VwX25ld190YXNrKHAsIGNsb25lX2ZsYWdzKTsKLQkJfQorCQl3YWtlX3VwX25ld190YXNrKHAsIGNsb25lX2ZsYWdzKTsKIAogCQl0cmFjZWhvb2tfcmVwb3J0X2Nsb25lX2NvbXBsZXRlKHRyYWNlLCByZWdzLAogCQkJCQkJY2xvbmVfZmxhZ3MsIG5yLCBwKTsKZGlmZiAtLWdpdCBhL2tlcm5lbC9mdXRleC5jIGIva2VybmVsL2Z1dGV4LmMKaW5kZXggMzAxOWI5Mi4uYjc2NmQyOCAxMDA2NDQKLS0tIGEva2VybmVsL2Z1dGV4LmMKKysrIGIva2VybmVsL2Z1dGV4LmMKQEAgLTIzMyw3ICsyMzMsNyBAQAogewogCXVuc2lnbmVkIGxvbmcgYWRkcmVzcyA9ICh1bnNpZ25lZCBsb25nKXVhZGRyOwogCXN0cnVjdCBtbV9zdHJ1Y3QgKm1tID0gY3VycmVudC0+bW07Ci0Jc3RydWN0IHBhZ2UgKnBhZ2U7CisJc3RydWN0IHBhZ2UgKnBhZ2UsICpwYWdlX2hlYWQ7CiAJaW50IGVycjsKIAogCS8qCkBAIC0yNjUsMTEgKzI2NSw0NiBAQAogCWlmIChlcnIgPCAwKQogCQlyZXR1cm4gZXJyOwogCi0JcGFnZSA9IGNvbXBvdW5kX2hlYWQocGFnZSk7Ci0JbG9ja19wYWdlKHBhZ2UpOwotCWlmICghcGFnZS0+bWFwcGluZykgewotCQl1bmxvY2tfcGFnZShwYWdlKTsKKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UKKwlwYWdlX2hlYWQgPSBwYWdlOworCWlmICh1bmxpa2VseShQYWdlVGFpbChwYWdlKSkpIHsKIAkJcHV0X3BhZ2UocGFnZSk7CisJCS8qIHNlcmlhbGl6ZSBhZ2FpbnN0IF9fc3BsaXRfaHVnZV9wYWdlX3NwbGl0dGluZygpICovCisJCWxvY2FsX2lycV9kaXNhYmxlKCk7CisJCWlmIChsaWtlbHkoX19nZXRfdXNlcl9wYWdlc19mYXN0KGFkZHJlc3MsIDEsIDEsICZwYWdlKSA9PSAxKSkgeworCQkJcGFnZV9oZWFkID0gY29tcG91bmRfaGVhZChwYWdlKTsKKwkJCS8qCisJCQkgKiBwYWdlX2hlYWQgaXMgdmFsaWQgcG9pbnRlciBidXQgd2UgbXVzdCBwaW4KKwkJCSAqIGl0IGJlZm9yZSB0YWtpbmcgdGhlIFBHX2xvY2sgYW5kL29yCisJCQkgKiBQR19jb21wb3VuZF9sb2NrLiBUaGUgbW9tZW50IHdlIHJlLWVuYWJsZQorCQkJICogaXJxcyBfX3NwbGl0X2h1Z2VfcGFnZV9zcGxpdHRpbmcoKSBjYW4KKwkJCSAqIHJldHVybiBhbmQgdGhlIGhlYWQgcGFnZSBjYW4gYmUgZnJlZWQgZnJvbQorCQkJICogdW5kZXIgdXMuIFdlIGNhbid0IHRha2UgdGhlIFBHX2xvY2sgYW5kL29yCisJCQkgKiBQR19jb21wb3VuZF9sb2NrIG9uIGEgcGFnZSB0aGF0IGNvdWxkIGJlCisJCQkgKiBmcmVlZCBmcm9tIHVuZGVyIHVzLgorCQkJICovCisJCQlpZiAocGFnZSAhPSBwYWdlX2hlYWQpIHsKKwkJCQlnZXRfcGFnZShwYWdlX2hlYWQpOworCQkJCXB1dF9wYWdlKHBhZ2UpOworCQkJfQorCQkJbG9jYWxfaXJxX2VuYWJsZSgpOworCQl9IGVsc2UgeworCQkJbG9jYWxfaXJxX2VuYWJsZSgpOworCQkJZ290byBhZ2FpbjsKKwkJfQorCX0KKyNlbHNlCisJcGFnZV9oZWFkID0gY29tcG91bmRfaGVhZChwYWdlKTsKKwlpZiAocGFnZSAhPSBwYWdlX2hlYWQpIHsKKwkJZ2V0X3BhZ2UocGFnZV9oZWFkKTsKKwkJcHV0X3BhZ2UocGFnZSk7CisJfQorI2VuZGlmCisKKwlsb2NrX3BhZ2UocGFnZV9oZWFkKTsKKwlpZiAoIXBhZ2VfaGVhZC0+bWFwcGluZykgeworCQl1bmxvY2tfcGFnZShwYWdlX2hlYWQpOworCQlwdXRfcGFnZShwYWdlX2hlYWQpOwogCQlnb3RvIGFnYWluOwogCX0KIApAQCAtMjgwLDIwICszMTUsMjAgQEAKIAkgKiBpdCdzIGEgcmVhZC1vbmx5IGhhbmRsZSwgaXQncyBleHBlY3RlZCB0aGF0IGZ1dGV4ZXMgYXR0YWNoIHRvCiAJICogdGhlIG9iamVjdCBub3QgdGhlIHBhcnRpY3VsYXIgcHJvY2Vzcy4KIAkgKi8KLQlpZiAoUGFnZUFub24ocGFnZSkpIHsKKwlpZiAoUGFnZUFub24ocGFnZV9oZWFkKSkgewogCQlrZXktPmJvdGgub2Zmc2V0IHw9IEZVVF9PRkZfTU1TSEFSRUQ7IC8qIHJlZiB0YWtlbiBvbiBtbSAqLwogCQlrZXktPnByaXZhdGUubW0gPSBtbTsKIAkJa2V5LT5wcml2YXRlLmFkZHJlc3MgPSBhZGRyZXNzOwogCX0gZWxzZSB7CiAJCWtleS0+Ym90aC5vZmZzZXQgfD0gRlVUX09GRl9JTk9ERTsgLyogaW5vZGUtYmFzZWQga2V5ICovCi0JCWtleS0+c2hhcmVkLmlub2RlID0gcGFnZS0+bWFwcGluZy0+aG9zdDsKLQkJa2V5LT5zaGFyZWQucGdvZmYgPSBwYWdlLT5pbmRleDsKKwkJa2V5LT5zaGFyZWQuaW5vZGUgPSBwYWdlX2hlYWQtPm1hcHBpbmctPmhvc3Q7CisJCWtleS0+c2hhcmVkLnBnb2ZmID0gcGFnZV9oZWFkLT5pbmRleDsKIAl9CiAKIAlnZXRfZnV0ZXhfa2V5X3JlZnMoa2V5KTsKIAotCXVubG9ja19wYWdlKHBhZ2UpOwotCXB1dF9wYWdlKHBhZ2UpOworCXVubG9ja19wYWdlKHBhZ2VfaGVhZCk7CisJcHV0X3BhZ2UocGFnZV9oZWFkKTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtNzkxLDEwICs4MjYsOSBAQAogCW5ld19vd25lciA9IHJ0X211dGV4X25leHRfb3duZXIoJnBpX3N0YXRlLT5waV9tdXRleCk7CiAKIAkvKgotCSAqIFRoaXMgaGFwcGVucyB3aGVuIHdlIGhhdmUgc3RvbGVuIHRoZSBsb2NrIGFuZCB0aGUgb3JpZ2luYWwKLQkgKiBwZW5kaW5nIG93bmVyIGRpZCBub3QgZW5xdWV1ZSBpdHNlbGYgYmFjayBvbiB0aGUgcnRfbXV0ZXguCi0JICogVGhhdHMgbm90IGEgdHJhZ2VkeS4gV2Uga25vdyB0aGF0IHdheSwgdGhhdCBhIGxvY2sgd2FpdGVyCi0JICogaXMgb24gdGhlIGZseS4gV2UgbWFrZSB0aGUgZnV0ZXhfcSB3YWl0ZXIgdGhlIHBlbmRpbmcgb3duZXIuCisJICogSXQgaXMgcG9zc2libGUgdGhhdCB0aGUgbmV4dCB3YWl0ZXIgKHRoZSBvbmUgdGhhdCBicm91Z2h0CisJICogdGhpcyBvd25lciB0byB0aGUga2VybmVsKSB0aW1lZCBvdXQgYW5kIGlzIG5vIGxvbmdlcgorCSAqIHdhaXRpbmcgb24gdGhlIGxvY2suCiAJICovCiAJaWYgKCFuZXdfb3duZXIpCiAJCW5ld19vd25lciA9IHRoaXMtPnRhc2s7CmRpZmYgLS1naXQgYS9rZXJuZWwvaXJxL0tjb25maWcgYi9rZXJuZWwvaXJxL0tjb25maWcKaW5kZXggMzFkNzY2Yi4uOGU0MmZlYyAxMDA2NDQKLS0tIGEva2VybmVsL2lycS9LY29uZmlnCisrKyBiL2tlcm5lbC9pcnEvS2NvbmZpZwpAQCAtOSw5ICs5LDYgQEAKIGNvbmZpZyBHRU5FUklDX0hBUkRJUlFTCiAgICAgICAgZGVmX2Jvb2wgeQogCi1jb25maWcgR0VORVJJQ19IQVJESVJRU19OT19fRE9fSVJRCi0gICAgICAgZGVmX2Jvb2wgeQotCiAjIFNlbGVjdCB0aGlzIHRvIGRpc2FibGUgdGhlIGRlcHJlY2F0ZWQgc3R1ZmYKIGNvbmZpZyBHRU5FUklDX0hBUkRJUlFTX05PX0RFUFJFQ0FURUQKICAgICAgICBkZWZfYm9vbCBuCmRpZmYgLS1naXQgYS9rZXJuZWwvaXJxL2hhbmRsZS5jIGIva2VybmVsL2lycS9oYW5kbGUuYwppbmRleCBlMjM0N2ViLi4zNTQwYTcxIDEwMDY0NAotLS0gYS9rZXJuZWwvaXJxL2hhbmRsZS5jCisrKyBiL2tlcm5lbC9pcnEvaGFuZGxlLmMKQEAgLTExOCwxMTQgKzExOCwzIEBACiAKIAlyZXR1cm4gcmV0dmFsOwogfQotCi0jaWZuZGVmIENPTkZJR19HRU5FUklDX0hBUkRJUlFTX05PX19ET19JUlEKLQotI2lmZGVmIENPTkZJR19FTkFCTEVfV0FSTl9ERVBSRUNBVEVECi0jIHdhcm5pbmcgX19kb19JUlEgaXMgZGVwcmVjYXRlZC4gUGxlYXNlIGNvbnZlcnQgdG8gcHJvcGVyIGZsb3cgaGFuZGxlcnMKLSNlbmRpZgotCi0vKioKLSAqIF9fZG9fSVJRIC0gb3JpZ2luYWwgYWxsIGluIG9uZSBoaWdobGV2ZWwgSVJRIGhhbmRsZXIKLSAqIEBpcnE6CXRoZSBpbnRlcnJ1cHQgbnVtYmVyCi0gKgotICogX19kb19JUlEgaGFuZGxlcyBhbGwgbm9ybWFsIGRldmljZSBJUlEncyAodGhlIHNwZWNpYWwKLSAqIFNNUCBjcm9zcy1DUFUgaW50ZXJydXB0cyBoYXZlIHRoZWlyIG93biBzcGVjaWZpYwotICogaGFuZGxlcnMpLgotICoKLSAqIFRoaXMgaXMgdGhlIG9yaWdpbmFsIHg4NiBpbXBsZW1lbnRhdGlvbiB3aGljaCBpcyB1c2VkIGZvciBldmVyeQotICogaW50ZXJydXB0IHR5cGUuCi0gKi8KLXVuc2lnbmVkIGludCBfX2RvX0lSUSh1bnNpZ25lZCBpbnQgaXJxKQotewotCXN0cnVjdCBpcnFfZGVzYyAqZGVzYyA9IGlycV90b19kZXNjKGlycSk7Ci0Jc3RydWN0IGlycWFjdGlvbiAqYWN0aW9uOwotCXVuc2lnbmVkIGludCBzdGF0dXM7Ci0KLQlrc3RhdF9pbmNyX2lycXNfdGhpc19jcHUoaXJxLCBkZXNjKTsKLQotCWlmIChDSEVDS19JUlFfUEVSX0NQVShkZXNjLT5zdGF0dXMpKSB7Ci0JCWlycXJldHVybl90IGFjdGlvbl9yZXQ7Ci0KLQkJLyoKLQkJICogTm8gbG9ja2luZyByZXF1aXJlZCBmb3IgQ1BVLWxvY2FsIGludGVycnVwdHM6Ci0JCSAqLwotCQlpZiAoZGVzYy0+aXJxX2RhdGEuY2hpcC0+YWNrKQotCQkJZGVzYy0+aXJxX2RhdGEuY2hpcC0+YWNrKGlycSk7Ci0JCWlmIChsaWtlbHkoIShkZXNjLT5zdGF0dXMgJiBJUlFfRElTQUJMRUQpKSkgewotCQkJYWN0aW9uX3JldCA9IGhhbmRsZV9JUlFfZXZlbnQoaXJxLCBkZXNjLT5hY3Rpb24pOwotCQkJaWYgKCFub2lycWRlYnVnKQotCQkJCW5vdGVfaW50ZXJydXB0KGlycSwgZGVzYywgYWN0aW9uX3JldCk7Ci0JCX0KLQkJZGVzYy0+aXJxX2RhdGEuY2hpcC0+ZW5kKGlycSk7Ci0JCXJldHVybiAxOwotCX0KLQotCXJhd19zcGluX2xvY2soJmRlc2MtPmxvY2spOwotCWlmIChkZXNjLT5pcnFfZGF0YS5jaGlwLT5hY2spCi0JCWRlc2MtPmlycV9kYXRhLmNoaXAtPmFjayhpcnEpOwotCS8qCi0JICogUkVQTEFZIGlzIHdoZW4gTGludXggcmVzZW5kcyBhbiBJUlEgdGhhdCB3YXMgZHJvcHBlZCBlYXJsaWVyCi0JICogV0FJVElORyBpcyB1c2VkIGJ5IHByb2JlIHRvIG1hcmsgaXJxcyB0aGF0IGFyZSBiZWluZyB0ZXN0ZWQKLQkgKi8KLQlzdGF0dXMgPSBkZXNjLT5zdGF0dXMgJiB+KElSUV9SRVBMQVkgfCBJUlFfV0FJVElORyk7Ci0Jc3RhdHVzIHw9IElSUV9QRU5ESU5HOyAvKiB3ZSBfd2FudF8gdG8gaGFuZGxlIGl0ICovCi0KLQkvKgotCSAqIElmIHRoZSBJUlEgaXMgZGlzYWJsZWQgZm9yIHdoYXRldmVyIHJlYXNvbiwgd2UgY2Fubm90Ci0JICogdXNlIHRoZSBhY3Rpb24gd2UgaGF2ZS4KLQkgKi8KLQlhY3Rpb24gPSBOVUxMOwotCWlmIChsaWtlbHkoIShzdGF0dXMgJiAoSVJRX0RJU0FCTEVEIHwgSVJRX0lOUFJPR1JFU1MpKSkpIHsKLQkJYWN0aW9uID0gZGVzYy0+YWN0aW9uOwotCQlzdGF0dXMgJj0gfklSUV9QRU5ESU5HOyAvKiB3ZSBjb21taXQgdG8gaGFuZGxpbmcgKi8KLQkJc3RhdHVzIHw9IElSUV9JTlBST0dSRVNTOyAvKiB3ZSBhcmUgaGFuZGxpbmcgaXQgKi8KLQl9Ci0JZGVzYy0+c3RhdHVzID0gc3RhdHVzOwotCi0JLyoKLQkgKiBJZiB0aGVyZSBpcyBubyBJUlEgaGFuZGxlciBvciBpdCB3YXMgZGlzYWJsZWQsIGV4aXQgZWFybHkuCi0JICogU2luY2Ugd2Ugc2V0IFBFTkRJTkcsIGlmIGFub3RoZXIgcHJvY2Vzc29yIGlzIGhhbmRsaW5nCi0JICogYSBkaWZmZXJlbnQgaW5zdGFuY2Ugb2YgdGhpcyBzYW1lIGlycSwgdGhlIG90aGVyIHByb2Nlc3NvcgotCSAqIHdpbGwgdGFrZSBjYXJlIG9mIGl0LgotCSAqLwotCWlmICh1bmxpa2VseSghYWN0aW9uKSkKLQkJZ290byBvdXQ7Ci0KLQkvKgotCSAqIEVkZ2UgdHJpZ2dlcmVkIGludGVycnVwdHMgbmVlZCB0byByZW1lbWJlcgotCSAqIHBlbmRpbmcgZXZlbnRzLgotCSAqIFRoaXMgYXBwbGllcyB0byBhbnkgaHcgaW50ZXJydXB0cyB0aGF0IGFsbG93IGEgc2Vjb25kCi0JICogaW5zdGFuY2Ugb2YgdGhlIHNhbWUgaXJxIHRvIGFycml2ZSB3aGlsZSB3ZSBhcmUgaW4gZG9fSVJRCi0JICogb3IgaW4gdGhlIGhhbmRsZXIuIEJ1dCB0aGUgY29kZSBoZXJlIG9ubHkgaGFuZGxlcyB0aGUgX3NlY29uZF8KLQkgKiBpbnN0YW5jZSBvZiB0aGUgaXJxLCBub3QgdGhlIHRoaXJkIG9yIGZvdXJ0aC4gU28gaXQgaXMgbW9zdGx5Ci0JICogdXNlZnVsIGZvciBpcnEgaGFyZHdhcmUgdGhhdCBkb2VzIG5vdCBtYXNrIGNsZWFubHkgaW4gYW4KLQkgKiBTTVAgZW52aXJvbm1lbnQuCi0JICovCi0JZm9yICg7OykgewotCQlpcnFyZXR1cm5fdCBhY3Rpb25fcmV0OwotCi0JCXJhd19zcGluX3VubG9jaygmZGVzYy0+bG9jayk7Ci0KLQkJYWN0aW9uX3JldCA9IGhhbmRsZV9JUlFfZXZlbnQoaXJxLCBhY3Rpb24pOwotCQlpZiAoIW5vaXJxZGVidWcpCi0JCQlub3RlX2ludGVycnVwdChpcnEsIGRlc2MsIGFjdGlvbl9yZXQpOwotCi0JCXJhd19zcGluX2xvY2soJmRlc2MtPmxvY2spOwotCQlpZiAobGlrZWx5KCEoZGVzYy0+c3RhdHVzICYgSVJRX1BFTkRJTkcpKSkKLQkJCWJyZWFrOwotCQlkZXNjLT5zdGF0dXMgJj0gfklSUV9QRU5ESU5HOwotCX0KLQlkZXNjLT5zdGF0dXMgJj0gfklSUV9JTlBST0dSRVNTOwotCi1vdXQ6Ci0JLyoKLQkgKiBUaGUgLT5lbmQoKSBoYW5kbGVyIGhhcyB0byBkZWFsIHdpdGggaW50ZXJydXB0cyB3aGljaCBnb3QKLQkgKiBkaXNhYmxlZCB3aGlsZSB0aGUgaGFuZGxlciB3YXMgcnVubmluZy4KLQkgKi8KLQlkZXNjLT5pcnFfZGF0YS5jaGlwLT5lbmQoaXJxKTsKLQlyYXdfc3Bpbl91bmxvY2soJmRlc2MtPmxvY2spOwotCi0JcmV0dXJuIDE7Ci19Ci0jZW5kaWYKZGlmZiAtLWdpdCBhL2tlcm5lbC9pcnEvaXJxZGVzYy5jIGIva2VybmVsL2lycS9pcnFkZXNjLmMKaW5kZXggOTk4OGQwMy4uMjgyZjIwMiAxMDA2NDQKLS0tIGEva2VybmVsL2lycS9pcnFkZXNjLmMKKysrIGIva2VybmVsL2lycS9pcnFkZXNjLmMKQEAgLTcyLDYgKzcyLDggQEAKIAogc3RhdGljIHZvaWQgZGVzY19zZXRfZGVmYXVsdHModW5zaWduZWQgaW50IGlycSwgc3RydWN0IGlycV9kZXNjICpkZXNjLCBpbnQgbm9kZSkKIHsKKwlpbnQgY3B1OworCiAJZGVzYy0+aXJxX2RhdGEuaXJxID0gaXJxOwogCWRlc2MtPmlycV9kYXRhLmNoaXAgPSAmbm9faXJxX2NoaXA7CiAJZGVzYy0+aXJxX2RhdGEuY2hpcF9kYXRhID0gTlVMTDsKQEAgLTgzLDcgKzg1LDggQEAKIAlkZXNjLT5pcnFfY291bnQgPSAwOwogCWRlc2MtPmlycXNfdW5oYW5kbGVkID0gMDsKIAlkZXNjLT5uYW1lID0gTlVMTDsKLQltZW1zZXQoZGVzYy0+a3N0YXRfaXJxcywgMCwgbnJfY3B1X2lkcyAqIHNpemVvZigqKGRlc2MtPmtzdGF0X2lycXMpKSk7CisJZm9yX2VhY2hfcG9zc2libGVfY3B1KGNwdSkKKwkJKnBlcl9jcHVfcHRyKGRlc2MtPmtzdGF0X2lycXMsIGNwdSkgPSAwOwogCWRlc2Nfc21wX2luaXQoZGVzYywgbm9kZSk7CiB9CiAKQEAgLTEzMyw4ICsxMzYsNyBAQAogCWlmICghZGVzYykKIAkJcmV0dXJuIE5VTEw7CiAJLyogYWxsb2NhdGUgYmFzZWQgb24gbnJfY3B1X2lkcyAqLwotCWRlc2MtPmtzdGF0X2lycXMgPSBremFsbG9jX25vZGUobnJfY3B1X2lkcyAqIHNpemVvZigqZGVzYy0+a3N0YXRfaXJxcyksCi0JCQkJCSBnZnAsIG5vZGUpOworCWRlc2MtPmtzdGF0X2lycXMgPSBhbGxvY19wZXJjcHUodW5zaWduZWQgaW50KTsKIAlpZiAoIWRlc2MtPmtzdGF0X2lycXMpCiAJCWdvdG8gZXJyX2Rlc2M7CiAKQEAgLTE0OSw3ICsxNTEsNyBAQAogCXJldHVybiBkZXNjOwogCiBlcnJfa3N0YXQ6Ci0Ja2ZyZWUoZGVzYy0+a3N0YXRfaXJxcyk7CisJZnJlZV9wZXJjcHUoZGVzYy0+a3N0YXRfaXJxcyk7CiBlcnJfZGVzYzoKIAlrZnJlZShkZXNjKTsKIAlyZXR1cm4gTlVMTDsKQEAgLTE2Niw3ICsxNjgsNyBAQAogCW11dGV4X3VubG9jaygmc3BhcnNlX2lycV9sb2NrKTsKIAogCWZyZWVfbWFza3MoZGVzYyk7Ci0Ja2ZyZWUoZGVzYy0+a3N0YXRfaXJxcyk7CisJZnJlZV9wZXJjcHUoZGVzYy0+a3N0YXRfaXJxcyk7CiAJa2ZyZWUoZGVzYyk7CiB9CiAKQEAgLTIzNCw3ICsyMzYsNiBAQAogCX0KIH07CiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQga3N0YXRfaXJxc19hbGxbTlJfSVJRU11bTlJfQ1BVU107CiBpbnQgX19pbml0IGVhcmx5X2lycV9pbml0KHZvaWQpCiB7CiAJaW50IGNvdW50LCBpLCBub2RlID0gZmlyc3Rfb25saW5lX25vZGU7CkBAIC0yNTAsNyArMjUxLDggQEAKIAlmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykgewogCQlkZXNjW2ldLmlycV9kYXRhLmlycSA9IGk7CiAJCWRlc2NbaV0uaXJxX2RhdGEuY2hpcCA9ICZub19pcnFfY2hpcDsKLQkJZGVzY1tpXS5rc3RhdF9pcnFzID0ga3N0YXRfaXJxc19hbGxbaV07CisJCS8qIFRPRE8gOiBkbyB0aGlzIGFsbG9jYXRpb24gb24tZGVtYW5kIC4uLiAqLworCQlkZXNjW2ldLmtzdGF0X2lycXMgPSBhbGxvY19wZXJjcHUodW5zaWduZWQgaW50KTsKIAkJYWxsb2NfbWFza3MoZGVzYyArIGksIEdGUF9LRVJORUwsIG5vZGUpOwogCQlkZXNjX3NtcF9pbml0KGRlc2MgKyBpLCBub2RlKTsKIAkJbG9ja2RlcF9zZXRfY2xhc3MoJmRlc2NbaV0ubG9jaywgJmlycV9kZXNjX2xvY2tfY2xhc3MpOwpAQCAtMjc1LDYgKzI3NywyMiBAQAogCiBzdGF0aWMgaW5saW5lIGludCBhbGxvY19kZXNjcyh1bnNpZ25lZCBpbnQgc3RhcnQsIHVuc2lnbmVkIGludCBjbnQsIGludCBub2RlKQogeworI2lmIGRlZmluZWQoQ09ORklHX0tTVEFUX0lSUVNfT05ERU1BTkQpCisJc3RydWN0IGlycV9kZXNjICpkZXNjOworCXVuc2lnbmVkIGludCBpOworCisJZm9yIChpID0gMDsgaSA8IGNudDsgaSsrKSB7CisJCWRlc2MgPSBpcnFfdG9fZGVzYyhzdGFydCArIGkpOworCQlpZiAoZGVzYyAmJiAhZGVzYy0+a3N0YXRfaXJxcykgeworCQkJdW5zaWduZWQgaW50IF9fcGVyY3B1ICpzdGF0cyA9IGFsbG9jX3BlcmNwdSh1bnNpZ25lZCBpbnQpOworCisJCQlpZiAoIXN0YXRzKQorCQkJCXJldHVybiAtMTsKKwkJCWlmIChjbXB4Y2hnKCZkZXNjLT5rc3RhdF9pcnFzLCBOVUxMLCBzdGF0cykgIT0gTlVMTCkKKwkJCQlmcmVlX3BlcmNwdShzdGF0cyk7CisJCX0KKwl9CisjZW5kaWYKIAlyZXR1cm4gc3RhcnQ7CiB9CiAjZW5kaWYgLyogIUNPTkZJR19TUEFSU0VfSVJRICovCkBAIC0zOTEsNyArNDA5LDkgQEAKIHVuc2lnbmVkIGludCBrc3RhdF9pcnFzX2NwdSh1bnNpZ25lZCBpbnQgaXJxLCBpbnQgY3B1KQogewogCXN0cnVjdCBpcnFfZGVzYyAqZGVzYyA9IGlycV90b19kZXNjKGlycSk7Ci0JcmV0dXJuIGRlc2MgPyBkZXNjLT5rc3RhdF9pcnFzW2NwdV0gOiAwOworCisJcmV0dXJuIGRlc2MgJiYgZGVzYy0+a3N0YXRfaXJxcyA/CisJCQkqcGVyX2NwdV9wdHIoZGVzYy0+a3N0YXRfaXJxcywgY3B1KSA6IDA7CiB9CiAKICNpZmRlZiBDT05GSUdfR0VORVJJQ19IQVJESVJRUwpAQCAtNDAxLDEwICs0MjEsMTAgQEAKIAlpbnQgY3B1OwogCWludCBzdW0gPSAwOwogCi0JaWYgKCFkZXNjKQorCWlmICghZGVzYyB8fCAhZGVzYy0+a3N0YXRfaXJxcykKIAkJcmV0dXJuIDA7CiAJZm9yX2VhY2hfcG9zc2libGVfY3B1KGNwdSkKLQkJc3VtICs9IGRlc2MtPmtzdGF0X2lycXNbY3B1XTsKKwkJc3VtICs9ICpwZXJfY3B1X3B0cihkZXNjLT5rc3RhdF9pcnFzLCBjcHUpOwogCXJldHVybiBzdW07CiB9CiAjZW5kaWYgLyogQ09ORklHX0dFTkVSSUNfSEFSRElSUVMgKi8KZGlmZiAtLWdpdCBhL2tlcm5lbC9pcnEvbWlncmF0aW9uLmMgYi9rZXJuZWwvaXJxL21pZ3JhdGlvbi5jCmluZGV4IDFkMjU0MTkuLjQ0MWZkNjIgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9pcnEvbWlncmF0aW9uLmMKKysrIGIva2VybmVsL2lycS9taWdyYXRpb24uYwpAQCAtNTYsNiArNTYsNyBAQAogdm9pZCBtb3ZlX25hdGl2ZV9pcnEoaW50IGlycSkKIHsKIAlzdHJ1Y3QgaXJxX2Rlc2MgKmRlc2MgPSBpcnFfdG9fZGVzYyhpcnEpOworCWJvb2wgbWFza2VkOwogCiAJaWYgKGxpa2VseSghKGRlc2MtPnN0YXR1cyAmIElSUV9NT1ZFX1BFTkRJTkcpKSkKIAkJcmV0dXJuOwpAQCAtNjMsOCArNjQsMTUgQEAKIAlpZiAodW5saWtlbHkoZGVzYy0+c3RhdHVzICYgSVJRX0RJU0FCTEVEKSkKIAkJcmV0dXJuOwogCi0JZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX21hc2soJmRlc2MtPmlycV9kYXRhKTsKKwkvKgorCSAqIEJlIGNhcmVmdWwgdnMuIGFscmVhZHkgbWFza2VkIGludGVycnVwdHMuIElmIHRoaXMgaXMgYQorCSAqIHRocmVhZGVkIGludGVycnVwdCB3aXRoIE9ORVNIT1Qgc2V0LCB3ZSBjYW4gZW5kIHVwIHdpdGggYW4KKwkgKiBpbnRlcnJ1cHQgc3Rvcm0uCisJICovCisJbWFza2VkID0gZGVzYy0+c3RhdHVzICYgSVJRX01BU0tFRDsKKwlpZiAoIW1hc2tlZCkKKwkJZGVzYy0+aXJxX2RhdGEuY2hpcC0+aXJxX21hc2soJmRlc2MtPmlycV9kYXRhKTsKIAltb3ZlX21hc2tlZF9pcnEoaXJxKTsKLQlkZXNjLT5pcnFfZGF0YS5jaGlwLT5pcnFfdW5tYXNrKCZkZXNjLT5pcnFfZGF0YSk7CisJaWYgKCFtYXNrZWQpCisJCWRlc2MtPmlycV9kYXRhLmNoaXAtPmlycV91bm1hc2soJmRlc2MtPmlycV9kYXRhKTsKIH0KLQpkaWZmIC0tZ2l0IGEva2VybmVsL2xvY2tkZXAuYyBiL2tlcm5lbC9sb2NrZGVwLmMKaW5kZXggNDJiYTY1ZC4uMGQyMDU4ZCAxMDA2NDQKLS0tIGEva2VybmVsL2xvY2tkZXAuYworKysgYi9rZXJuZWwvbG9ja2RlcC5jCkBAIC0yMjkyLDIyICsyMjkyLDYgQEAKIH0KIAogLyoKLSAqIERlYnVnZ2luZyBoZWxwZXI6IHZpYSB0aGlzIGZsYWcgd2Uga25vdyB0aGF0IHdlIGFyZSBpbgotICogJ2Vhcmx5IGJvb3R1cCBjb2RlJywgYW5kIHdpbGwgd2FybiBhYm91dCBhbnkgaW52YWxpZCBpcnFzLW9uIGV2ZW50OgotICovCi1zdGF0aWMgaW50IGVhcmx5X2Jvb3RfaXJxc19lbmFibGVkOwotCi12b2lkIGVhcmx5X2Jvb3RfaXJxc19vZmYodm9pZCkKLXsKLQllYXJseV9ib290X2lycXNfZW5hYmxlZCA9IDA7Ci19Ci0KLXZvaWQgZWFybHlfYm9vdF9pcnFzX29uKHZvaWQpCi17Ci0JZWFybHlfYm9vdF9pcnFzX2VuYWJsZWQgPSAxOwotfQotCi0vKgogICogSGFyZGlycXMgd2lsbCBiZSBlbmFibGVkOgogICovCiB2b2lkIHRyYWNlX2hhcmRpcnFzX29uX2NhbGxlcih1bnNpZ25lZCBsb25nIGlwKQpAQCAtMjMxOSw3ICsyMzAzLDcgQEAKIAlpZiAodW5saWtlbHkoIWRlYnVnX2xvY2tzIHx8IGN1cnJlbnQtPmxvY2tkZXBfcmVjdXJzaW9uKSkKIAkJcmV0dXJuOwogCi0JaWYgKERFQlVHX0xPQ0tTX1dBUk5fT04odW5saWtlbHkoIWVhcmx5X2Jvb3RfaXJxc19lbmFibGVkKSkpCisJaWYgKERFQlVHX0xPQ0tTX1dBUk5fT04odW5saWtlbHkoZWFybHlfYm9vdF9pcnFzX2Rpc2FibGVkKSkpCiAJCXJldHVybjsKIAogCWlmICh1bmxpa2VseShjdXJyLT5oYXJkaXJxc19lbmFibGVkKSkgewpkaWZmIC0tZ2l0IGEva2VybmVsL21vZHVsZS5jIGIva2VybmVsL21vZHVsZS5jCmluZGV4IDM0ZTAwYjcuLmVmYTI5MGUgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9tb2R1bGUuYworKysgYi9rZXJuZWwvbW9kdWxlLmMKQEAgLTI0NjAsOSArMjQ2MCw5IEBACiAjZW5kaWYKIAogI2lmZGVmIENPTkZJR19UUkFDRVBPSU5UUwotCW1vZC0+dHJhY2Vwb2ludHMgPSBzZWN0aW9uX29ianMoaW5mbywgIl9fdHJhY2Vwb2ludHMiLAotCQkJCQlzaXplb2YoKm1vZC0+dHJhY2Vwb2ludHMpLAotCQkJCQkmbW9kLT5udW1fdHJhY2Vwb2ludHMpOworCW1vZC0+dHJhY2Vwb2ludHNfcHRycyA9IHNlY3Rpb25fb2JqcyhpbmZvLCAiX190cmFjZXBvaW50c19wdHJzIiwKKwkJCQkJICAgICBzaXplb2YoKm1vZC0+dHJhY2Vwb2ludHNfcHRycyksCisJCQkJCSAgICAgJm1vZC0+bnVtX3RyYWNlcG9pbnRzKTsKICNlbmRpZgogI2lmZGVmIEhBVkVfSlVNUF9MQUJFTAogCW1vZC0+anVtcF9lbnRyaWVzID0gc2VjdGlvbl9vYmpzKGluZm8sICJfX2p1bXBfdGFibGUiLApAQCAtMzM5Myw3ICszMzkzLDcgQEAKIAkJICAgc3RydWN0IG1vZHZlcnNpb25faW5mbyAqdmVyLAogCQkgICBzdHJ1Y3Qga2VybmVsX3BhcmFtICprcCwKIAkJICAgc3RydWN0IGtlcm5lbF9zeW1ib2wgKmtzLAotCQkgICBzdHJ1Y3QgdHJhY2Vwb2ludCAqdHApCisJCSAgIHN0cnVjdCB0cmFjZXBvaW50ICogY29uc3QgKnRwKQogewogfQogRVhQT1JUX1NZTUJPTChtb2R1bGVfbGF5b3V0KTsKQEAgLTM0MDcsOCArMzQwNyw4IEBACiAJbXV0ZXhfbG9jaygmbW9kdWxlX211dGV4KTsKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KG1vZCwgJm1vZHVsZXMsIGxpc3QpCiAJCWlmICghbW9kLT50YWludHMpCi0JCQl0cmFjZXBvaW50X3VwZGF0ZV9wcm9iZV9yYW5nZShtb2QtPnRyYWNlcG9pbnRzLAotCQkJCW1vZC0+dHJhY2Vwb2ludHMgKyBtb2QtPm51bV90cmFjZXBvaW50cyk7CisJCQl0cmFjZXBvaW50X3VwZGF0ZV9wcm9iZV9yYW5nZShtb2QtPnRyYWNlcG9pbnRzX3B0cnMsCisJCQkJbW9kLT50cmFjZXBvaW50c19wdHJzICsgbW9kLT5udW1fdHJhY2Vwb2ludHMpOwogCW11dGV4X3VubG9jaygmbW9kdWxlX211dGV4KTsKIH0KIApAQCAtMzQzMiw4ICszNDMyLDggQEAKIAkJCWVsc2UgaWYgKGl0ZXJfbW9kID4gaXRlci0+bW9kdWxlKQogCQkJCWl0ZXItPnRyYWNlcG9pbnQgPSBOVUxMOwogCQkJZm91bmQgPSB0cmFjZXBvaW50X2dldF9pdGVyX3JhbmdlKCZpdGVyLT50cmFjZXBvaW50LAotCQkJCWl0ZXJfbW9kLT50cmFjZXBvaW50cywKLQkJCQlpdGVyX21vZC0+dHJhY2Vwb2ludHMKKwkJCQlpdGVyX21vZC0+dHJhY2Vwb2ludHNfcHRycywKKwkJCQlpdGVyX21vZC0+dHJhY2Vwb2ludHNfcHRycwogCQkJCQkrIGl0ZXJfbW9kLT5udW1fdHJhY2Vwb2ludHMpOwogCQkJaWYgKGZvdW5kKSB7CiAJCQkJaXRlci0+bW9kdWxlID0gaXRlcl9tb2Q7CmRpZmYgLS1naXQgYS9rZXJuZWwvcGFuaWMuYyBiL2tlcm5lbC9wYW5pYy5jCmluZGV4IDRjMTNiMWEuLjk5MWJiODcgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9wYW5pYy5jCisrKyBiL2tlcm5lbC9wYW5pYy5jCkBAIC0zNCw2ICszNCw3IEBACiBzdGF0aWMgREVGSU5FX1NQSU5MT0NLKHBhdXNlX29uX29vcHNfbG9jayk7CiAKIGludCBwYW5pY190aW1lb3V0OworRVhQT1JUX1NZTUJPTF9HUEwocGFuaWNfdGltZW91dCk7CiAKIEFUT01JQ19OT1RJRklFUl9IRUFEKHBhbmljX25vdGlmaWVyX2xpc3QpOwogCmRpZmYgLS1naXQgYS9rZXJuZWwvcGFyYW1zLmMgYi9rZXJuZWwvcGFyYW1zLmMKaW5kZXggMDgxMDdkMS4uMGRhMTQxMSAxMDA2NDQKLS0tIGEva2VybmVsL3BhcmFtcy5jCisrKyBiL2tlcm5lbC9wYXJhbXMuYwpAQCAtNzE5LDkgKzcxOSw3IEBACiAJCQlwYXJhbXNbaV0ub3BzLT5mcmVlKHBhcmFtc1tpXS5hcmcpOwogfQogCi1zdGF0aWMgdm9pZCBfX2luaXQga2VybmVsX2FkZF9zeXNmc19wYXJhbShjb25zdCBjaGFyICpuYW1lLAotCQkJCQkgIHN0cnVjdCBrZXJuZWxfcGFyYW0gKmtwYXJhbSwKLQkJCQkJICB1bnNpZ25lZCBpbnQgbmFtZV9za2lwKQorc3RhdGljIHN0cnVjdCBtb2R1bGVfa29iamVjdCAqIF9faW5pdCBsb2NhdGVfbW9kdWxlX2tvYmplY3QoY29uc3QgY2hhciAqbmFtZSkKIHsKIAlzdHJ1Y3QgbW9kdWxlX2tvYmplY3QgKm1rOwogCXN0cnVjdCBrb2JqZWN0ICprb2JqOwpAQCAtNzI5LDEwICs3MjcsNyBAQAogCiAJa29iaiA9IGtzZXRfZmluZF9vYmoobW9kdWxlX2tzZXQsIG5hbWUpOwogCWlmIChrb2JqKSB7Ci0JCS8qIFdlIGFscmVhZHkgaGF2ZSBvbmUuICBSZW1vdmUgcGFyYW1zIHNvIHdlIGNhbiBhZGQgbW9yZS4gKi8KIAkJbWsgPSB0b19tb2R1bGVfa29iamVjdChrb2JqKTsKLQkJLyogV2UgbmVlZCB0byByZW1vdmUgaXQgYmVmb3JlIGFkZGluZyBwYXJhbWV0ZXJzLiAqLwotCQlzeXNmc19yZW1vdmVfZ3JvdXAoJm1rLT5rb2JqLCAmbWstPm1wLT5ncnApOwogCX0gZWxzZSB7CiAJCW1rID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IG1vZHVsZV9rb2JqZWN0KSwgR0ZQX0tFUk5FTCk7CiAJCUJVR19PTighbWspOwpAQCAtNzQzLDE1ICs3MzgsMzYgQEAKIAkJCQkJICAgIiVzIiwgbmFtZSk7CiAJCWlmIChlcnIpIHsKIAkJCWtvYmplY3RfcHV0KCZtay0+a29iaik7Ci0JCQlwcmludGsoS0VSTl9FUlIgIk1vZHVsZSAnJXMnIGZhaWxlZCBhZGQgdG8gc3lzZnMsICIKLQkJCSAgICAgICAiZXJyb3IgbnVtYmVyICVkXG4iLCBuYW1lLCBlcnIpOwotCQkJcHJpbnRrKEtFUk5fRVJSCSJUaGUgc3lzdGVtIHdpbGwgYmUgdW5zdGFibGUgbm93LlxuIik7Ci0JCQlyZXR1cm47CisJCQlwcmludGsoS0VSTl9FUlIKKwkJCQkiTW9kdWxlICclcycgZmFpbGVkIGFkZCB0byBzeXNmcywgZXJyb3IgbnVtYmVyICVkXG4iLAorCQkJCW5hbWUsIGVycik7CisJCQlwcmludGsoS0VSTl9FUlIKKwkJCQkiVGhlIHN5c3RlbSB3aWxsIGJlIHVuc3RhYmxlIG5vdy5cbiIpOworCQkJcmV0dXJuIE5VTEw7CiAJCX0KLQkJLyogU28gdGhhdCBleGl0IHBhdGggaXMgZXZlbi4gKi8KKworCQkvKiBTbyB0aGF0IHdlIGhvbGQgcmVmZXJlbmNlIGluIGJvdGggY2FzZXMuICovCiAJCWtvYmplY3RfZ2V0KCZtay0+a29iaik7CiAJfQogCisJcmV0dXJuIG1rOworfQorCitzdGF0aWMgdm9pZCBfX2luaXQga2VybmVsX2FkZF9zeXNmc19wYXJhbShjb25zdCBjaGFyICpuYW1lLAorCQkJCQkgIHN0cnVjdCBrZXJuZWxfcGFyYW0gKmtwYXJhbSwKKwkJCQkJICB1bnNpZ25lZCBpbnQgbmFtZV9za2lwKQoreworCXN0cnVjdCBtb2R1bGVfa29iamVjdCAqbWs7CisJaW50IGVycjsKKworCW1rID0gbG9jYXRlX21vZHVsZV9rb2JqZWN0KG5hbWUpOworCWlmICghbWspCisJCXJldHVybjsKKworCS8qIFdlIG5lZWQgdG8gcmVtb3ZlIG9sZCBwYXJhbWV0ZXJzIGJlZm9yZSBhZGRpbmcgbW9yZS4gKi8KKwlpZiAobWstPm1wKQorCQlzeXNmc19yZW1vdmVfZ3JvdXAoJm1rLT5rb2JqLCAmbWstPm1wLT5ncnApOworCiAJLyogVGhlc2Ugc2hvdWxkIG5vdCBmYWlsIGF0IGJvb3QuICovCiAJZXJyID0gYWRkX3N5c2ZzX3BhcmFtKG1rLCBrcGFyYW0sIGtwYXJhbS0+bmFtZSArIG5hbWVfc2tpcCk7CiAJQlVHX09OKGVycik7CkBAIC03OTYsNiArODEyLDMyIEBACiAJfQogfQogCitzc2l6ZV90IF9fbW9kdmVyX3ZlcnNpb25fc2hvdyhzdHJ1Y3QgbW9kdWxlX2F0dHJpYnV0ZSAqbWF0dHIsCisJCQkgICAgICBzdHJ1Y3QgbW9kdWxlICptb2QsIGNoYXIgKmJ1ZikKK3sKKwlzdHJ1Y3QgbW9kdWxlX3ZlcnNpb25fYXR0cmlidXRlICp2YXR0ciA9CisJCWNvbnRhaW5lcl9vZihtYXR0ciwgc3RydWN0IG1vZHVsZV92ZXJzaW9uX2F0dHJpYnV0ZSwgbWF0dHIpOworCisJcmV0dXJuIHNwcmludGYoYnVmLCAiJXNcbiIsIHZhdHRyLT52ZXJzaW9uKTsKK30KKworZXh0ZXJuIHN0cnVjdCBtb2R1bGVfdmVyc2lvbl9hdHRyaWJ1dGUgX19zdGFydF9fX21vZHZlcltdLCBfX3N0b3BfX19tb2R2ZXJbXTsKKworc3RhdGljIHZvaWQgX19pbml0IHZlcnNpb25fc3lzZnNfYnVpbHRpbih2b2lkKQoreworCWNvbnN0IHN0cnVjdCBtb2R1bGVfdmVyc2lvbl9hdHRyaWJ1dGUgKnZhdHRyOworCXN0cnVjdCBtb2R1bGVfa29iamVjdCAqbWs7CisJaW50IGVycjsKKworCWZvciAodmF0dHIgPSBfX3N0YXJ0X19fbW9kdmVyOyB2YXR0ciA8IF9fc3RvcF9fX21vZHZlcjsgdmF0dHIrKykgeworCQltayA9IGxvY2F0ZV9tb2R1bGVfa29iamVjdCh2YXR0ci0+bW9kdWxlX25hbWUpOworCQlpZiAobWspIHsKKwkJCWVyciA9IHN5c2ZzX2NyZWF0ZV9maWxlKCZtay0+a29iaiwgJnZhdHRyLT5tYXR0ci5hdHRyKTsKKwkJCWtvYmplY3RfdWV2ZW50KCZtay0+a29iaiwgS09CSl9BREQpOworCQkJa29iamVjdF9wdXQoJm1rLT5rb2JqKTsKKwkJfQorCX0KK30KIAogLyogbW9kdWxlLXJlbGF0ZWQgc3lzZnMgc3R1ZmYgKi8KIApAQCAtODc1LDYgKzkxNyw3IEBACiAJfQogCW1vZHVsZV9zeXNmc19pbml0aWFsaXplZCA9IDE7CiAKKwl2ZXJzaW9uX3N5c2ZzX2J1aWx0aW4oKTsKIAlwYXJhbV9zeXNmc19idWlsdGluKCk7CiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2tlcm5lbC9wZXJmX2V2ZW50LmMgYi9rZXJuZWwvcGVyZl9ldmVudC5jCmluZGV4IDA1ZWJlODQuLjk5OTgzNWIgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9wZXJmX2V2ZW50LmMKKysrIGIva2VybmVsL3BlcmZfZXZlbnQuYwpAQCAtMTkwMSwxMSArMTkwMSwxMiBAQAogCQlyZXR1cm47CiAKIAlyYXdfc3Bpbl9sb2NrKCZjdHgtPmxvY2spOwotCXVwZGF0ZV9jb250ZXh0X3RpbWUoY3R4KTsKKwlpZiAoY3R4LT5pc19hY3RpdmUpCisJCXVwZGF0ZV9jb250ZXh0X3RpbWUoY3R4KTsKIAl1cGRhdGVfZXZlbnRfdGltZXMoZXZlbnQpOworCWlmIChldmVudC0+c3RhdGUgPT0gUEVSRl9FVkVOVF9TVEFURV9BQ1RJVkUpCisJCWV2ZW50LT5wbXUtPnJlYWQoZXZlbnQpOwogCXJhd19zcGluX3VubG9jaygmY3R4LT5sb2NrKTsKLQotCWV2ZW50LT5wbXUtPnJlYWQoZXZlbnQpOwogfQogCiBzdGF0aWMgaW5saW5lIHU2NCBwZXJmX2V2ZW50X2NvdW50KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKQEAgLTE5OTksOCArMjAwMCw3IEBACiAJICogYWNjZXNzZWQgZnJvbSBOTUkuIFVzZSBhIHRlbXBvcmFyeSBtYW51YWwgcGVyIGNwdSBhbGxvY2F0aW9uCiAJICogdW50aWwgdGhhdCBnZXRzIHNvcnRlZCBvdXQuCiAJICovCi0Jc2l6ZSA9IHNpemVvZigqZW50cmllcykgKyBzaXplb2Yoc3RydWN0IHBlcmZfY2FsbGNoYWluX2VudHJ5ICopICoKLQkJbnVtX3Bvc3NpYmxlX2NwdXMoKTsKKwlzaXplID0gb2Zmc2V0b2Yoc3RydWN0IGNhbGxjaGFpbl9jcHVzX2VudHJpZXMsIGNwdV9lbnRyaWVzW25yX2NwdV9pZHNdKTsKIAogCWVudHJpZXMgPSBremFsbG9jKHNpemUsIEdGUF9LRVJORUwpOwogCWlmICghZW50cmllcykKQEAgLTIyMDEsMTMgKzIyMDEsNiBAQAogCWlmICghdGFzaykKIAkJcmV0dXJuIEVSUl9QVFIoLUVTUkNIKTsKIAotCS8qCi0JICogQ2FuJ3QgYXR0YWNoIGV2ZW50cyB0byBhIGR5aW5nIHRhc2suCi0JICovCi0JZXJyID0gLUVTUkNIOwotCWlmICh0YXNrLT5mbGFncyAmIFBGX0VYSVRJTkcpCi0JCWdvdG8gZXJyb3V0OwotCiAJLyogUmV1c2UgcHRyYWNlIHBlcm1pc3Npb24gY2hlY2tzIGZvciBub3cuICovCiAJZXJyID0gLUVBQ0NFUzsKIAlpZiAoIXB0cmFjZV9tYXlfYWNjZXNzKHRhc2ssIFBUUkFDRV9NT0RFX1JFQUQpKQpAQCAtMjIyOCwxNCArMjIyMSwxMSBAQAogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJaW50IGN0eG4sIGVycjsKIAotCWlmICghdGFzayAmJiBjcHUgIT0gLTEpIHsKKwlpZiAoIXRhc2spIHsKIAkJLyogTXVzdCBiZSByb290IHRvIG9wZXJhdGUgb24gYSBDUFUgZXZlbnQ6ICovCiAJCWlmIChwZXJmX3BhcmFub2lkX2NwdSgpICYmICFjYXBhYmxlKENBUF9TWVNfQURNSU4pKQogCQkJcmV0dXJuIEVSUl9QVFIoLUVBQ0NFUyk7CiAKLQkJaWYgKGNwdSA8IDAgfHwgY3B1ID49IG5yX2NwdW1hc2tfYml0cykKLQkJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOwotCiAJCS8qCiAJCSAqIFdlIGNvdWxkIGJlIGNsZXZlciBhbmQgYWxsb3cgdG8gYXR0YWNoIGEgZXZlbnQgdG8gYW4KIAkJICogb2ZmbGluZSBDUFUgYW5kIGFjdGl2YXRlIGl0IHdoZW4gdGhlIENQVSBjb21lcyB1cCwgYnV0CkBAIC0yMjcxLDE0ICsyMjYxLDI3IEBACiAKIAkJZ2V0X2N0eChjdHgpOwogCi0JCWlmIChjbXB4Y2hnKCZ0YXNrLT5wZXJmX2V2ZW50X2N0eHBbY3R4bl0sIE5VTEwsIGN0eCkpIHsKLQkJCS8qCi0JCQkgKiBXZSByYWNlZCB3aXRoIHNvbWUgb3RoZXIgdGFzazsgdXNlCi0JCQkgKiB0aGUgY29udGV4dCB0aGV5IHNldC4KLQkJCSAqLworCQllcnIgPSAwOworCQltdXRleF9sb2NrKCZ0YXNrLT5wZXJmX2V2ZW50X211dGV4KTsKKwkJLyoKKwkJICogSWYgaXQgaGFzIGFscmVhZHkgcGFzc2VkIHBlcmZfZXZlbnRfZXhpdF90YXNrKCkuCisJCSAqIHdlIG11c3Qgc2VlIFBGX0VYSVRJTkcsIGl0IHRha2VzIHRoaXMgbXV0ZXggdG9vLgorCQkgKi8KKwkJaWYgKHRhc2stPmZsYWdzICYgUEZfRVhJVElORykKKwkJCWVyciA9IC1FU1JDSDsKKwkJZWxzZSBpZiAodGFzay0+cGVyZl9ldmVudF9jdHhwW2N0eG5dKQorCQkJZXJyID0gLUVBR0FJTjsKKwkJZWxzZQorCQkJcmN1X2Fzc2lnbl9wb2ludGVyKHRhc2stPnBlcmZfZXZlbnRfY3R4cFtjdHhuXSwgY3R4KTsKKwkJbXV0ZXhfdW5sb2NrKCZ0YXNrLT5wZXJmX2V2ZW50X211dGV4KTsKKworCQlpZiAodW5saWtlbHkoZXJyKSkgewogCQkJcHV0X3Rhc2tfc3RydWN0KHRhc2spOwogCQkJa2ZyZWUoY3R4KTsKLQkJCWdvdG8gcmV0cnk7CisKKwkJCWlmIChlcnIgPT0gLUVBR0FJTikKKwkJCQlnb3RvIHJldHJ5OworCQkJZ290byBlcnJvdXQ7CiAJCX0KIAl9CiAKQEAgLTUzNzcsNiArNTM4MCw4IEBACiAJZ290byBvdXQ7CiB9CiAKK3N0YXRpYyBzdHJ1Y3QgbG9ja19jbGFzc19rZXkgY3B1Y3R4X211dGV4OworCiBpbnQgcGVyZl9wbXVfcmVnaXN0ZXIoc3RydWN0IHBtdSAqcG11LCBjaGFyICpuYW1lLCBpbnQgdHlwZSkKIHsKIAlpbnQgY3B1LCByZXQ7CkBAIC01NDI1LDYgKzU0MzAsNyBAQAogCiAJCWNwdWN0eCA9IHBlcl9jcHVfcHRyKHBtdS0+cG11X2NwdV9jb250ZXh0LCBjcHUpOwogCQlfX3BlcmZfZXZlbnRfaW5pdF9jb250ZXh0KCZjcHVjdHgtPmN0eCk7CisJCWxvY2tkZXBfc2V0X2NsYXNzKCZjcHVjdHgtPmN0eC5tdXRleCwgJmNwdWN0eF9tdXRleCk7CiAJCWNwdWN0eC0+Y3R4LnR5cGUgPSBjcHVfY29udGV4dDsKIAkJY3B1Y3R4LT5jdHgucG11ID0gcG11OwogCQljcHVjdHgtPmppZmZpZXNfaW50ZXJ2YWwgPSAxOwpAQCAtNTU0MSw2ICs1NTQ3LDExIEBACiAJc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YzsKIAlsb25nIGVycjsKIAorCWlmICgodW5zaWduZWQpY3B1ID49IG5yX2NwdV9pZHMpIHsKKwkJaWYgKCF0YXNrIHx8IGNwdSAhPSAtMSkKKwkJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCX0KKwogCWV2ZW50ID0ga3phbGxvYyhzaXplb2YoKmV2ZW50KSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFldmVudCkKIAkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CkBAIC01NTg5LDcgKzU2MDAsNyBAQAogCiAJaWYgKCFvdmVyZmxvd19oYW5kbGVyICYmIHBhcmVudF9ldmVudCkKIAkJb3ZlcmZsb3dfaGFuZGxlciA9IHBhcmVudF9ldmVudC0+b3ZlcmZsb3dfaGFuZGxlcjsKLQkKKwogCWV2ZW50LT5vdmVyZmxvd19oYW5kbGVyCT0gb3ZlcmZsb3dfaGFuZGxlcjsKIAogCWlmIChhdHRyLT5kaXNhYmxlZCkKQEAgLTYxMjUsNyArNjEzNiw3IEBACiAJICogc2NoZWR1bGVkLCBzbyB3ZSBhcmUgbm93IHNhZmUgZnJvbSByZXNjaGVkdWxpbmcgY2hhbmdpbmcKIAkgKiBvdXIgY29udGV4dC4KIAkgKi8KLQljaGlsZF9jdHggPSBjaGlsZC0+cGVyZl9ldmVudF9jdHhwW2N0eG5dOworCWNoaWxkX2N0eCA9IHJjdV9kZXJlZmVyZW5jZV9yYXcoY2hpbGQtPnBlcmZfZXZlbnRfY3R4cFtjdHhuXSk7CiAJdGFza19jdHhfc2NoZWRfb3V0KGNoaWxkX2N0eCwgRVZFTlRfQUxMKTsKIAogCS8qCkBAIC02NDM4LDExICs2NDQ5LDYgQEAKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCByZXQgPSAwOwogCi0JY2hpbGQtPnBlcmZfZXZlbnRfY3R4cFtjdHhuXSA9IE5VTEw7Ci0KLQltdXRleF9pbml0KCZjaGlsZC0+cGVyZl9ldmVudF9tdXRleCk7Ci0JSU5JVF9MSVNUX0hFQUQoJmNoaWxkLT5wZXJmX2V2ZW50X2xpc3QpOwotCiAJaWYgKGxpa2VseSghcGFyZW50LT5wZXJmX2V2ZW50X2N0eHBbY3R4bl0pKQogCQlyZXR1cm4gMDsKIApAQCAtNjQ5NCw3ICs2NTAwLDYgQEAKIAogCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmcGFyZW50X2N0eC0+bG9jaywgZmxhZ3MpOwogCXBhcmVudF9jdHgtPnJvdGF0ZV9kaXNhYmxlID0gMDsKLQlyYXdfc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcGFyZW50X2N0eC0+bG9jaywgZmxhZ3MpOwogCiAJY2hpbGRfY3R4ID0gY2hpbGQtPnBlcmZfZXZlbnRfY3R4cFtjdHhuXTsKIApAQCAtNjUwMiwxMiArNjUwNywxMSBAQAogCQkvKgogCQkgKiBNYXJrIHRoZSBjaGlsZCBjb250ZXh0IGFzIGEgY2xvbmUgb2YgdGhlIHBhcmVudAogCQkgKiBjb250ZXh0LCBvciBvZiB3aGF0ZXZlciB0aGUgcGFyZW50IGlzIGEgY2xvbmUgb2YuCi0JCSAqIE5vdGUgdGhhdCBpZiB0aGUgcGFyZW50IGlzIGEgY2xvbmUsIGl0IGNvdWxkIGdldAotCQkgKiB1bmNsb25lZCBhdCBhbnkgcG9pbnQsIGJ1dCB0aGF0IGRvZXNuJ3QgbWF0dGVyCi0JCSAqIGJlY2F1c2UgdGhlIGxpc3Qgb2YgZXZlbnRzIGFuZCB0aGUgZ2VuZXJhdGlvbgotCQkgKiBjb3VudCBjYW4ndCBoYXZlIGNoYW5nZWQgc2luY2Ugd2UgdG9vayB0aGUgbXV0ZXguCisJCSAqCisJCSAqIE5vdGUgdGhhdCBpZiB0aGUgcGFyZW50IGlzIGEgY2xvbmUsIHRoZSBob2xkaW5nIG9mCisJCSAqIHBhcmVudF9jdHgtPmxvY2sgYXZvaWRzIGl0IGZyb20gYmVpbmcgdW5jbG9uZWQuCiAJCSAqLwotCQljbG9uZWRfY3R4ID0gcmN1X2RlcmVmZXJlbmNlKHBhcmVudF9jdHgtPnBhcmVudF9jdHgpOworCQljbG9uZWRfY3R4ID0gcGFyZW50X2N0eC0+cGFyZW50X2N0eDsKIAkJaWYgKGNsb25lZF9jdHgpIHsKIAkJCWNoaWxkX2N0eC0+cGFyZW50X2N0eCA9IGNsb25lZF9jdHg7CiAJCQljaGlsZF9jdHgtPnBhcmVudF9nZW4gPSBwYXJlbnRfY3R4LT5wYXJlbnRfZ2VuOwpAQCAtNjUxOCw2ICs2NTIyLDcgQEAKIAkJZ2V0X2N0eChjaGlsZF9jdHgtPnBhcmVudF9jdHgpOwogCX0KIAorCXJhd19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZwYXJlbnRfY3R4LT5sb2NrLCBmbGFncyk7CiAJbXV0ZXhfdW5sb2NrKCZwYXJlbnRfY3R4LT5tdXRleCk7CiAKIAlwZXJmX3VucGluX2NvbnRleHQocGFyZW50X2N0eCk7CkBAIC02NTMyLDYgKzY1MzcsMTAgQEAKIHsKIAlpbnQgY3R4biwgcmV0OwogCisJbWVtc2V0KGNoaWxkLT5wZXJmX2V2ZW50X2N0eHAsIDAsIHNpemVvZihjaGlsZC0+cGVyZl9ldmVudF9jdHhwKSk7CisJbXV0ZXhfaW5pdCgmY2hpbGQtPnBlcmZfZXZlbnRfbXV0ZXgpOworCUlOSVRfTElTVF9IRUFEKCZjaGlsZC0+cGVyZl9ldmVudF9saXN0KTsKKwogCWZvcl9lYWNoX3Rhc2tfY29udGV4dF9ucihjdHhuKSB7CiAJCXJldCA9IHBlcmZfZXZlbnRfaW5pdF9jb250ZXh0KGNoaWxkLCBjdHhuKTsKIAkJaWYgKHJldCkKZGlmZiAtLWdpdCBhL2tlcm5lbC9wb3dlci9LY29uZmlnIGIva2VybmVsL3Bvd2VyL0tjb25maWcKaW5kZXggYTVhZmYzZS4uMjY1NzI5OSAxMDA2NDQKLS0tIGEva2VybmVsL3Bvd2VyL0tjb25maWcKKysrIGIva2VybmVsL3Bvd2VyL0tjb25maWcKQEAgLTEwMCwxMyArMTAwLDkgQEAKIAlkZXBlbmRzIG9uIFBNX0FEVkFOQ0VEX0RFQlVHCiAJZGVmYXVsdCBuCiAKLWNvbmZpZyBTVVNQRU5EX05WUwotICAgICAgIGJvb2wKLQogY29uZmlnIFNVU1BFTkQKIAlib29sICJTdXNwZW5kIHRvIFJBTSBhbmQgc3RhbmRieSIKIAlkZXBlbmRzIG9uIFBNICYmIEFSQ0hfU1VTUEVORF9QT1NTSUJMRQotCXNlbGVjdCBTVVNQRU5EX05WUyBpZiBIQVNfSU9NRU0KIAlkZWZhdWx0IHkKIAktLS1oZWxwLS0tCiAJICBBbGxvdyB0aGUgc3lzdGVtIHRvIGVudGVyIHNsZWVwIHN0YXRlcyBpbiB3aGljaCBtYWluIG1lbW9yeSBpcwpAQCAtMTQwLDcgKzEzNiw2IEBACiAJZGVwZW5kcyBvbiBQTSAmJiBTV0FQICYmIEFSQ0hfSElCRVJOQVRJT05fUE9TU0lCTEUKIAlzZWxlY3QgTFpPX0NPTVBSRVNTCiAJc2VsZWN0IExaT19ERUNPTVBSRVNTCi0Jc2VsZWN0IFNVU1BFTkRfTlZTIGlmIEhBU19JT01FTQogCS0tLWhlbHAtLS0KIAkgIEVuYWJsZSB0aGUgc3VzcGVuZCB0byBkaXNrIChTVEQpIGZ1bmN0aW9uYWxpdHksIHdoaWNoIGlzIHVzdWFsbHkKIAkgIGNhbGxlZCAiaGliZXJuYXRpb24iIGluIHVzZXIgaW50ZXJmYWNlcy4gIFNURCBjaGVja3BvaW50cyB0aGUKZGlmZiAtLWdpdCBhL2tlcm5lbC9wb3dlci9NYWtlZmlsZSBiL2tlcm5lbC9wb3dlci9NYWtlZmlsZQppbmRleCBiNzU1OTcyLi5jMzUwZTE4IDEwMDY0NAotLS0gYS9rZXJuZWwvcG93ZXIvTWFrZWZpbGUKKysrIGIva2VybmVsL3Bvd2VyL01ha2VmaWxlCkBAIC03LDYgKzcsNSBAQAogb2JqLSQoQ09ORklHX1BNX1RFU1RfU1VTUEVORCkJKz0gc3VzcGVuZF90ZXN0Lm8KIG9iai0kKENPTkZJR19ISUJFUk5BVElPTikJKz0gaGliZXJuYXRlLm8gc25hcHNob3QubyBzd2FwLm8gdXNlci5vIFwKIAkJCQkgICBibG9ja19pby5vCi1vYmotJChDT05GSUdfU1VTUEVORF9OVlMpCSs9IG52cy5vCiAKIG9iai0kKENPTkZJR19NQUdJQ19TWVNSUSkJKz0gcG93ZXJvZmYubwpkaWZmIC0tZ2l0IGEva2VybmVsL3ByaW50ay5jIGIva2VybmVsL3ByaW50ay5jCmluZGV4IDUzZDlhOWUuLjM2MjMxNTIgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9wcmludGsuYworKysgYi9rZXJuZWwvcHJpbnRrLmMKQEAgLTk3LDcgKzk3LDcgQEAKIC8qCiAgKiBsb2didWZfbG9jayBwcm90ZWN0cyBsb2dfYnVmLCBsb2dfc3RhcnQsIGxvZ19lbmQsIGNvbl9zdGFydCBhbmQgbG9nZ2VkX2NoYXJzCiAgKiBJdCBpcyBhbHNvIHVzZWQgaW4gaW50ZXJlc3Rpbmcgd2F5cyB0byBwcm92aWRlIGludGVybG9ja2luZyBpbgotICogcmVsZWFzZV9jb25zb2xlX3NlbSgpLgorICogY29uc29sZV91bmxvY2soKTsuCiAgKi8KIHN0YXRpYyBERUZJTkVfU1BJTkxPQ0sobG9nYnVmX2xvY2spOwogCkBAIC0yNjIsMjUgKzI2Miw0NyBAQAogaW50IGRtZXNnX3Jlc3RyaWN0OwogI2VuZGlmCiAKK3N0YXRpYyBpbnQgc3lzbG9nX2FjdGlvbl9yZXN0cmljdGVkKGludCB0eXBlKQoreworCWlmIChkbWVzZ19yZXN0cmljdCkKKwkJcmV0dXJuIDE7CisJLyogVW5sZXNzIHJlc3RyaWN0ZWQsIHdlIGFsbG93ICJyZWFkIGFsbCIgYW5kICJnZXQgYnVmZmVyIHNpemUiIGZvciBldmVyeWJvZHkgKi8KKwlyZXR1cm4gdHlwZSAhPSBTWVNMT0dfQUNUSU9OX1JFQURfQUxMICYmIHR5cGUgIT0gU1lTTE9HX0FDVElPTl9TSVpFX0JVRkZFUjsKK30KKworc3RhdGljIGludCBjaGVja19zeXNsb2dfcGVybWlzc2lvbnMoaW50IHR5cGUsIGJvb2wgZnJvbV9maWxlKQoreworCS8qCisJICogSWYgdGhpcyBpcyBmcm9tIC9wcm9jL2ttc2cgYW5kIHdlJ3ZlIGFscmVhZHkgb3BlbmVkIGl0LCB0aGVuIHdlJ3ZlCisJICogYWxyZWFkeSBkb25lIHRoZSBjYXBhYmlsaXRpZXMgY2hlY2tzIGF0IG9wZW4gdGltZS4KKwkgKi8KKwlpZiAoZnJvbV9maWxlICYmIHR5cGUgIT0gU1lTTE9HX0FDVElPTl9PUEVOKQorCQlyZXR1cm4gMDsKKworCWlmIChzeXNsb2dfYWN0aW9uX3Jlc3RyaWN0ZWQodHlwZSkpIHsKKwkJaWYgKGNhcGFibGUoQ0FQX1NZU0xPRykpCisJCQlyZXR1cm4gMDsKKwkJLyogRm9yIGhpc3RvcmljYWwgcmVhc29ucywgYWNjZXB0IENBUF9TWVNfQURNSU4gdG9vLCB3aXRoIGEgd2FybmluZyAqLworCQlpZiAoY2FwYWJsZShDQVBfU1lTX0FETUlOKSkgeworCQkJV0FSTl9PTkNFKDEsICJBdHRlbXB0IHRvIGFjY2VzcyBzeXNsb2cgd2l0aCBDQVBfU1lTX0FETUlOICIKKwkJCQkgImJ1dCBubyBDQVBfU1lTTE9HIChkZXByZWNhdGVkKS5cbiIpOworCQkJcmV0dXJuIDA7CisJCX0KKwkJcmV0dXJuIC1FUEVSTTsKKwl9CisJcmV0dXJuIDA7Cit9CisKIGludCBkb19zeXNsb2coaW50IHR5cGUsIGNoYXIgX191c2VyICpidWYsIGludCBsZW4sIGJvb2wgZnJvbV9maWxlKQogewogCXVuc2lnbmVkIGksIGosIGxpbWl0LCBjb3VudDsKIAlpbnQgZG9fY2xlYXIgPSAwOwogCWNoYXIgYzsKLQlpbnQgZXJyb3IgPSAwOworCWludCBlcnJvcjsKIAotCS8qCi0JICogSWYgdGhpcyBpcyBmcm9tIC9wcm9jL2ttc2cgd2Ugb25seSBkbyB0aGUgY2FwYWJpbGl0aWVzIGNoZWNrcwotCSAqIGF0IG9wZW4gdGltZS4KLQkgKi8KLQlpZiAodHlwZSA9PSBTWVNMT0dfQUNUSU9OX09QRU4gfHwgIWZyb21fZmlsZSkgewotCQlpZiAoZG1lc2dfcmVzdHJpY3QgJiYgIWNhcGFibGUoQ0FQX1NZU0xPRykpCi0JCQlnb3RvIHdhcm47IC8qIHN3aXRjaCB0byByZXR1cm4gLUVQRVJNIGFmdGVyIDIuNi4zOSAqLwotCQlpZiAoKHR5cGUgIT0gU1lTTE9HX0FDVElPTl9SRUFEX0FMTCAmJgotCQkgICAgIHR5cGUgIT0gU1lTTE9HX0FDVElPTl9TSVpFX0JVRkZFUikgJiYKLQkJICAgICFjYXBhYmxlKENBUF9TWVNMT0cpKQotCQkJZ290byB3YXJuOyAvKiBzd2l0Y2ggdG8gcmV0dXJuIC1FUEVSTSBhZnRlciAyLjYuMzkgKi8KLQl9CisJZXJyb3IgPSBjaGVja19zeXNsb2dfcGVybWlzc2lvbnModHlwZSwgZnJvbV9maWxlKTsKKwlpZiAoZXJyb3IpCisJCWdvdG8gb3V0OwogCiAJZXJyb3IgPSBzZWN1cml0eV9zeXNsb2codHlwZSk7CiAJaWYgKGVycm9yKQpAQCAtNDIzLDEyICs0NDUsNiBAQAogCX0KIG91dDoKIAlyZXR1cm4gZXJyb3I7Ci13YXJuOgotCS8qIHJlbW92ZSBhZnRlciAyLjYuMzkgKi8KLQlpZiAoY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKLQkJV0FSTl9PTkNFKDEsICJBdHRlbXB0IHRvIGFjY2VzcyBzeXNsb2cgd2l0aCBDQVBfU1lTX0FETUlOICIKLQkJICAiYnV0IG5vIENBUF9TWVNMT0cgKGRlcHJlY2F0ZWQgYW5kIGRlbmllZCkuXG4iKTsKLQlyZXR1cm4gLUVQRVJNOwogfQogCiBTWVNDQUxMX0RFRklORTMoc3lzbG9nLCBpbnQsIHR5cGUsIGNoYXIgX191c2VyICosIGJ1ZiwgaW50LCBsZW4pCkBAIC01MDEsNyArNTE3LDcgQEAKIC8qCiAgKiBDYWxsIHRoZSBjb25zb2xlIGRyaXZlcnMsIGFza2luZyB0aGVtIHRvIHdyaXRlIG91dAogICogbG9nX2J1ZltzdGFydF0gdG8gbG9nX2J1ZltlbmQgLSAxXS4KLSAqIFRoZSBjb25zb2xlX3NlbSBtdXN0IGJlIGhlbGQuCisgKiBUaGUgY29uc29sZV9sb2NrIG11c3QgYmUgaGVsZC4KICAqLwogc3RhdGljIHZvaWQgY2FsbF9jb25zb2xlX2RyaXZlcnModW5zaWduZWQgc3RhcnQsIHVuc2lnbmVkIGVuZCkKIHsKQEAgLTYwNCwxMSArNjIwLDExIEBACiAgKgogICogVGhpcyBpcyBwcmludGsoKS4gIEl0IGNhbiBiZSBjYWxsZWQgZnJvbSBhbnkgY29udGV4dC4gIFdlIHdhbnQgaXQgdG8gd29yay4KICAqCi0gKiBXZSB0cnkgdG8gZ3JhYiB0aGUgY29uc29sZV9zZW0uICBJZiB3ZSBzdWNjZWVkLCBpdCdzIGVhc3kgLSB3ZSBsb2cgdGhlIG91dHB1dCBhbmQKKyAqIFdlIHRyeSB0byBncmFiIHRoZSBjb25zb2xlX2xvY2suICBJZiB3ZSBzdWNjZWVkLCBpdCdzIGVhc3kgLSB3ZSBsb2cgdGhlIG91dHB1dCBhbmQKICAqIGNhbGwgdGhlIGNvbnNvbGUgZHJpdmVycy4gIElmIHdlIGZhaWwgdG8gZ2V0IHRoZSBzZW1hcGhvcmUgd2UgcGxhY2UgdGhlIG91dHB1dAogICogaW50byB0aGUgbG9nIGJ1ZmZlciBhbmQgcmV0dXJuLiAgVGhlIGN1cnJlbnQgaG9sZGVyIG9mIHRoZSBjb25zb2xlX3NlbSB3aWxsCi0gKiBub3RpY2UgdGhlIG5ldyBvdXRwdXQgaW4gcmVsZWFzZV9jb25zb2xlX3NlbSgpIGFuZCB3aWxsIHNlbmQgaXQgdG8gdGhlCi0gKiBjb25zb2xlcyBiZWZvcmUgcmVsZWFzaW5nIHRoZSBzZW1hcGhvcmUuCisgKiBub3RpY2UgdGhlIG5ldyBvdXRwdXQgaW4gY29uc29sZV91bmxvY2soKTsgYW5kIHdpbGwgc2VuZCBpdCB0byB0aGUKKyAqIGNvbnNvbGVzIGJlZm9yZSByZWxlYXNpbmcgdGhlIGxvY2suCiAgKgogICogT25lIGVmZmVjdCBvZiB0aGlzIGRlZmVycmVkIHByaW50aW5nIGlzIHRoYXQgY29kZSB3aGljaCBjYWxscyBwcmludGsoKSBhbmQKICAqIHRoZW4gY2hhbmdlcyBjb25zb2xlX2xvZ2xldmVsIG1heSBicmVhay4gVGhpcyBpcyBiZWNhdXNlIGNvbnNvbGVfbG9nbGV2ZWwKQEAgLTY1OSwxOSArNjc1LDE5IEBACiAvKgogICogVHJ5IHRvIGdldCBjb25zb2xlIG93bmVyc2hpcCB0byBhY3R1YWxseSBzaG93IHRoZSBrZXJuZWwKICAqIG1lc3NhZ2VzIGZyb20gYSAncHJpbnRrJy4gUmV0dXJuIHRydWUgKGFuZCB3aXRoIHRoZQotICogY29uc29sZV9zZW1hcGhvcmUgaGVsZCwgYW5kICdjb25zb2xlX2xvY2tlZCcgc2V0KSBpZiBpdAorICogY29uc29sZV9sb2NrIGhlbGQsIGFuZCAnY29uc29sZV9sb2NrZWQnIHNldCkgaWYgaXQKICAqIGlzIHN1Y2Nlc3NmdWwsIGZhbHNlIG90aGVyd2lzZS4KICAqCiAgKiBUaGlzIGdldHMgY2FsbGVkIHdpdGggdGhlICdsb2didWZfbG9jaycgc3BpbmxvY2sgaGVsZCBhbmQKICAqIGludGVycnVwdHMgZGlzYWJsZWQuIEl0IHNob3VsZCByZXR1cm4gd2l0aCAnbG9ja2J1Zl9sb2NrJwogICogcmVsZWFzZWQgYnV0IGludGVycnVwdHMgc3RpbGwgZGlzYWJsZWQuCiAgKi8KLXN0YXRpYyBpbnQgYWNxdWlyZV9jb25zb2xlX3NlbWFwaG9yZV9mb3JfcHJpbnRrKHVuc2lnbmVkIGludCBjcHUpCitzdGF0aWMgaW50IGNvbnNvbGVfdHJ5bG9ja19mb3JfcHJpbnRrKHVuc2lnbmVkIGludCBjcHUpCiAJX19yZWxlYXNlcygmbG9nYnVmX2xvY2spCiB7CiAJaW50IHJldHZhbCA9IDA7CiAKLQlpZiAoIXRyeV9hY3F1aXJlX2NvbnNvbGVfc2VtKCkpIHsKKwlpZiAoY29uc29sZV90cnlsb2NrKCkpIHsKIAkJcmV0dmFsID0gMTsKIAogCQkvKgpAQCAtODI3LDEyICs4NDMsMTIgQEAKIAkgKiBhY3R1YWwgbWFnaWMgKHByaW50IG91dCBidWZmZXJzLCB3YWtlIHVwIGtsb2dkLAogCSAqIGV0YykuIAogCSAqCi0JICogVGhlIGFjcXVpcmVfY29uc29sZV9zZW1hcGhvcmVfZm9yX3ByaW50aygpIGZ1bmN0aW9uCisJICogVGhlIGNvbnNvbGVfdHJ5bG9ja19mb3JfcHJpbnRrKCkgZnVuY3Rpb24KIAkgKiB3aWxsIHJlbGVhc2UgJ2xvZ2J1Zl9sb2NrJyByZWdhcmRsZXNzIG9mIHdoZXRoZXIgaXQKIAkgKiBhY3R1YWxseSBnZXRzIHRoZSBzZW1hcGhvcmUgb3Igbm90LgogCSAqLwotCWlmIChhY3F1aXJlX2NvbnNvbGVfc2VtYXBob3JlX2Zvcl9wcmludGsodGhpc19jcHUpKQotCQlyZWxlYXNlX2NvbnNvbGVfc2VtKCk7CisJaWYgKGNvbnNvbGVfdHJ5bG9ja19mb3JfcHJpbnRrKHRoaXNfY3B1KSkKKwkJY29uc29sZV91bmxvY2soKTsKIAogCWxvY2tkZXBfb24oKTsKIG91dF9yZXN0b3JlX2lycXM6CkBAIC05OTMsNyArMTAwOSw3IEBACiAJaWYgKCFjb25zb2xlX3N1c3BlbmRfZW5hYmxlZCkKIAkJcmV0dXJuOwogCXByaW50aygiU3VzcGVuZGluZyBjb25zb2xlKHMpICh1c2Ugbm9fY29uc29sZV9zdXNwZW5kIHRvIGRlYnVnKVxuIik7Ci0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWNvbnNvbGVfc3VzcGVuZGVkID0gMTsKIAl1cCgmY29uc29sZV9zZW0pOwogfQpAQCAtMTAwNCw3ICsxMDIwLDcgQEAKIAkJcmV0dXJuOwogCWRvd24oJmNvbnNvbGVfc2VtKTsKIAljb25zb2xlX3N1c3BlbmRlZCA9IDA7Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiB9CiAKIC8qKgpAQCAtMTAyNywyMSArMTA0MywyMSBAQAogCWNhc2UgQ1BVX0RZSU5HOgogCWNhc2UgQ1BVX0RPV05fRkFJTEVEOgogCWNhc2UgQ1BVX1VQX0NBTkNFTEVEOgotCQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7Ci0JCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV9sb2NrKCk7CisJCWNvbnNvbGVfdW5sb2NrKCk7CiAJfQogCXJldHVybiBOT1RJRllfT0s7CiB9CiAKIC8qKgotICogYWNxdWlyZV9jb25zb2xlX3NlbSAtIGxvY2sgdGhlIGNvbnNvbGUgc3lzdGVtIGZvciBleGNsdXNpdmUgdXNlLgorICogY29uc29sZV9sb2NrIC0gbG9jayB0aGUgY29uc29sZSBzeXN0ZW0gZm9yIGV4Y2x1c2l2ZSB1c2UuCiAgKgotICogQWNxdWlyZXMgYSBzZW1hcGhvcmUgd2hpY2ggZ3VhcmFudGVlcyB0aGF0IHRoZSBjYWxsZXIgaGFzCisgKiBBY3F1aXJlcyBhIGxvY2sgd2hpY2ggZ3VhcmFudGVlcyB0aGF0IHRoZSBjYWxsZXIgaGFzCiAgKiBleGNsdXNpdmUgYWNjZXNzIHRvIHRoZSBjb25zb2xlIHN5c3RlbSBhbmQgdGhlIGNvbnNvbGVfZHJpdmVycyBsaXN0LgogICoKICAqIENhbiBzbGVlcCwgcmV0dXJucyBub3RoaW5nLgogICovCi12b2lkIGFjcXVpcmVfY29uc29sZV9zZW0odm9pZCkKK3ZvaWQgY29uc29sZV9sb2NrKHZvaWQpCiB7CiAJQlVHX09OKGluX2ludGVycnVwdCgpKTsKIAlkb3duKCZjb25zb2xlX3NlbSk7CkBAIC0xMDUwLDIxICsxMDY2LDI5IEBACiAJY29uc29sZV9sb2NrZWQgPSAxOwogCWNvbnNvbGVfbWF5X3NjaGVkdWxlID0gMTsKIH0KLUVYUE9SVF9TWU1CT0woYWNxdWlyZV9jb25zb2xlX3NlbSk7CitFWFBPUlRfU1lNQk9MKGNvbnNvbGVfbG9jayk7CiAKLWludCB0cnlfYWNxdWlyZV9jb25zb2xlX3NlbSh2b2lkKQorLyoqCisgKiBjb25zb2xlX3RyeWxvY2sgLSB0cnkgdG8gbG9jayB0aGUgY29uc29sZSBzeXN0ZW0gZm9yIGV4Y2x1c2l2ZSB1c2UuCisgKgorICogVHJpZWQgdG8gYWNxdWlyZSBhIGxvY2sgd2hpY2ggZ3VhcmFudGVlcyB0aGF0IHRoZSBjYWxsZXIgaGFzCisgKiBleGNsdXNpdmUgYWNjZXNzIHRvIHRoZSBjb25zb2xlIHN5c3RlbSBhbmQgdGhlIGNvbnNvbGVfZHJpdmVycyBsaXN0LgorICoKKyAqIHJldHVybnMgMSBvbiBzdWNjZXNzLCBhbmQgMCBvbiBmYWlsdXJlIHRvIGFjcXVpcmUgdGhlIGxvY2suCisgKi8KK2ludCBjb25zb2xlX3RyeWxvY2sodm9pZCkKIHsKIAlpZiAoZG93bl90cnlsb2NrKCZjb25zb2xlX3NlbSkpCi0JCXJldHVybiAtMTsKKwkJcmV0dXJuIDA7CiAJaWYgKGNvbnNvbGVfc3VzcGVuZGVkKSB7CiAJCXVwKCZjb25zb2xlX3NlbSk7Ci0JCXJldHVybiAtMTsKKwkJcmV0dXJuIDA7CiAJfQogCWNvbnNvbGVfbG9ja2VkID0gMTsKIAljb25zb2xlX21heV9zY2hlZHVsZSA9IDA7Ci0JcmV0dXJuIDA7CisJcmV0dXJuIDE7CiB9Ci1FWFBPUlRfU1lNQk9MKHRyeV9hY3F1aXJlX2NvbnNvbGVfc2VtKTsKK0VYUE9SVF9TWU1CT0woY29uc29sZV90cnlsb2NrKTsKIAogaW50IGlzX2NvbnNvbGVfbG9ja2VkKHZvaWQpCiB7CkBAIC0xMDk1LDIwICsxMTE5LDIwIEBACiB9CiAKIC8qKgotICogcmVsZWFzZV9jb25zb2xlX3NlbSAtIHVubG9jayB0aGUgY29uc29sZSBzeXN0ZW0KKyAqIGNvbnNvbGVfdW5sb2NrIC0gdW5sb2NrIHRoZSBjb25zb2xlIHN5c3RlbQogICoKLSAqIFJlbGVhc2VzIHRoZSBzZW1hcGhvcmUgd2hpY2ggdGhlIGNhbGxlciBob2xkcyBvbiB0aGUgY29uc29sZSBzeXN0ZW0KKyAqIFJlbGVhc2VzIHRoZSBjb25zb2xlX2xvY2sgd2hpY2ggdGhlIGNhbGxlciBob2xkcyBvbiB0aGUgY29uc29sZSBzeXN0ZW0KICAqIGFuZCB0aGUgY29uc29sZSBkcml2ZXIgbGlzdC4KICAqCi0gKiBXaGlsZSB0aGUgc2VtYXBob3JlIHdhcyBoZWxkLCBjb25zb2xlIG91dHB1dCBtYXkgaGF2ZSBiZWVuIGJ1ZmZlcmVkCi0gKiBieSBwcmludGsoKS4gIElmIHRoaXMgaXMgdGhlIGNhc2UsIHJlbGVhc2VfY29uc29sZV9zZW0oKSBlbWl0cwotICogdGhlIG91dHB1dCBwcmlvciB0byByZWxlYXNpbmcgdGhlIHNlbWFwaG9yZS4KKyAqIFdoaWxlIHRoZSBjb25zb2xlX2xvY2sgd2FzIGhlbGQsIGNvbnNvbGUgb3V0cHV0IG1heSBoYXZlIGJlZW4gYnVmZmVyZWQKKyAqIGJ5IHByaW50aygpLiAgSWYgdGhpcyBpcyB0aGUgY2FzZSwgY29uc29sZV91bmxvY2soKTsgZW1pdHMKKyAqIHRoZSBvdXRwdXQgcHJpb3IgdG8gcmVsZWFzaW5nIHRoZSBsb2NrLgogICoKICAqIElmIHRoZXJlIGlzIG91dHB1dCB3YWl0aW5nIGZvciBrbG9nZCwgd2Ugd2FrZSBpdCB1cC4KICAqCi0gKiByZWxlYXNlX2NvbnNvbGVfc2VtKCkgbWF5IGJlIGNhbGxlZCBmcm9tIGFueSBjb250ZXh0LgorICogY29uc29sZV91bmxvY2soKTsgbWF5IGJlIGNhbGxlZCBmcm9tIGFueSBjb250ZXh0LgogICovCi12b2lkIHJlbGVhc2VfY29uc29sZV9zZW0odm9pZCkKK3ZvaWQgY29uc29sZV91bmxvY2sodm9pZCkKIHsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCXVuc2lnbmVkIF9jb25fc3RhcnQsIF9sb2dfZW5kOwpAQCAtMTE0MSw3ICsxMTY1LDcgQEAKIAlpZiAod2FrZV9rbG9nZCkKIAkJd2FrZV91cF9rbG9nZCgpOwogfQotRVhQT1JUX1NZTUJPTChyZWxlYXNlX2NvbnNvbGVfc2VtKTsKK0VYUE9SVF9TWU1CT0woY29uc29sZV91bmxvY2spOwogCiAvKioKICAqIGNvbnNvbGVfY29uZGl0aW9uYWxfc2NoZWR1bGUgLSB5aWVsZCB0aGUgQ1BVIGlmIHJlcXVpcmVkCkBAIC0xMTUwLDcgKzExNzQsNyBAQAogICogaWYgdGhpcyBDUFUgc2hvdWxkIHlpZWxkIHRoZSBDUFUgdG8gYW5vdGhlciB0YXNrLCBkbwogICogc28gaGVyZS4KICAqCi0gKiBNdXN0IGJlIGNhbGxlZCB3aXRoaW4gYWNxdWlyZV9jb25zb2xlX3NlbSgpLgorICogTXVzdCBiZSBjYWxsZWQgd2l0aGluIGNvbnNvbGVfbG9jaygpOy4KICAqLwogdm9pZCBfX3NjaGVkIGNvbnNvbGVfY29uZGl0aW9uYWxfc2NoZWR1bGUodm9pZCkKIHsKQEAgLTExNzEsMTQgKzExOTUsMTQgQEAKIAkJaWYgKGRvd25fdHJ5bG9jaygmY29uc29sZV9zZW0pICE9IDApCiAJCQlyZXR1cm47CiAJfSBlbHNlCi0JCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwkJY29uc29sZV9sb2NrKCk7CiAKIAljb25zb2xlX2xvY2tlZCA9IDE7CiAJY29uc29sZV9tYXlfc2NoZWR1bGUgPSAwOwogCWZvcl9lYWNoX2NvbnNvbGUoYykKIAkJaWYgKChjLT5mbGFncyAmIENPTl9FTkFCTEVEKSAmJiBjLT51bmJsYW5rKQogCQkJYy0+dW5ibGFuaygpOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogfQogCiAvKgpAQCAtMTE4OSw3ICsxMjEzLDcgQEAKIAlzdHJ1Y3QgY29uc29sZSAqYzsKIAlzdHJ1Y3QgdHR5X2RyaXZlciAqZHJpdmVyID0gTlVMTDsKIAotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlmb3JfZWFjaF9jb25zb2xlKGMpIHsKIAkJaWYgKCFjLT5kZXZpY2UpCiAJCQljb250aW51ZTsKQEAgLTExOTcsNyArMTIyMSw3IEBACiAJCWlmIChkcml2ZXIpCiAJCQlicmVhazsKIAl9Ci0JcmVsZWFzZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfdW5sb2NrKCk7CiAJcmV0dXJuIGRyaXZlcjsKIH0KIApAQCAtMTIwOCwxNyArMTIzMiwxNyBAQAogICovCiB2b2lkIGNvbnNvbGVfc3RvcChzdHJ1Y3QgY29uc29sZSAqY29uc29sZSkKIHsKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJY29uc29sZS0+ZmxhZ3MgJj0gfkNPTl9FTkFCTEVEOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogfQogRVhQT1JUX1NZTUJPTChjb25zb2xlX3N0b3ApOwogCiB2b2lkIGNvbnNvbGVfc3RhcnQoc3RydWN0IGNvbnNvbGUgKmNvbnNvbGUpCiB7Ci0JYWNxdWlyZV9jb25zb2xlX3NlbSgpOworCWNvbnNvbGVfbG9jaygpOwogCWNvbnNvbGUtPmZsYWdzIHw9IENPTl9FTkFCTEVEOwotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogfQogRVhQT1JUX1NZTUJPTChjb25zb2xlX3N0YXJ0KTsKIApAQCAtMTM0MCw3ICsxMzY0LDcgQEAKIAkgKglQdXQgdGhpcyBjb25zb2xlIGluIHRoZSBsaXN0IC0ga2VlcCB0aGUKIAkgKglwcmVmZXJyZWQgZHJpdmVyIGF0IHRoZSBoZWFkIG9mIHRoZSBsaXN0LgogCSAqLwotCWFjcXVpcmVfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX2xvY2soKTsKIAlpZiAoKG5ld2Nvbi0+ZmxhZ3MgJiBDT05fQ09OU0RFVikgfHwgY29uc29sZV9kcml2ZXJzID09IE5VTEwpIHsKIAkJbmV3Y29uLT5uZXh0ID0gY29uc29sZV9kcml2ZXJzOwogCQljb25zb2xlX2RyaXZlcnMgPSBuZXdjb247CkBAIC0xMzUyLDE0ICsxMzc2LDE0IEBACiAJfQogCWlmIChuZXdjb24tPmZsYWdzICYgQ09OX1BSSU5UQlVGRkVSKSB7CiAJCS8qCi0JCSAqIHJlbGVhc2VfY29uc29sZV9zZW0oKSB3aWxsIHByaW50IG91dCB0aGUgYnVmZmVyZWQgbWVzc2FnZXMKKwkJICogY29uc29sZV91bmxvY2soKTsgd2lsbCBwcmludCBvdXQgdGhlIGJ1ZmZlcmVkIG1lc3NhZ2VzCiAJCSAqIGZvciB1cy4KIAkJICovCiAJCXNwaW5fbG9ja19pcnFzYXZlKCZsb2didWZfbG9jaywgZmxhZ3MpOwogCQljb25fc3RhcnQgPSBsb2dfc3RhcnQ7CiAJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmxvZ2J1Zl9sb2NrLCBmbGFncyk7CiAJfQotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCWNvbnNvbGVfc3lzZnNfbm90aWZ5KCk7CiAKIAkvKgpAQCAtMTM5Niw3ICsxNDIwLDcgQEAKIAkJcmV0dXJuIGJyYWlsbGVfdW5yZWdpc3Rlcl9jb25zb2xlKGNvbnNvbGUpOwogI2VuZGlmCiAKLQlhY3F1aXJlX2NvbnNvbGVfc2VtKCk7CisJY29uc29sZV9sb2NrKCk7CiAJaWYgKGNvbnNvbGVfZHJpdmVycyA9PSBjb25zb2xlKSB7CiAJCWNvbnNvbGVfZHJpdmVycz1jb25zb2xlLT5uZXh0OwogCQlyZXMgPSAwOwpAQCAtMTQxOCw3ICsxNDQyLDcgQEAKIAlpZiAoY29uc29sZV9kcml2ZXJzICE9IE5VTEwgJiYgY29uc29sZS0+ZmxhZ3MgJiBDT05fQ09OU0RFVikKIAkJY29uc29sZV9kcml2ZXJzLT5mbGFncyB8PSBDT05fQ09OU0RFVjsKIAotCXJlbGVhc2VfY29uc29sZV9zZW0oKTsKKwljb25zb2xlX3VubG9jaygpOwogCWNvbnNvbGVfc3lzZnNfbm90aWZ5KCk7CiAJcmV0dXJuIHJlczsKIH0KZGlmZiAtLWdpdCBhL2tlcm5lbC9wdHJhY2UuYyBiL2tlcm5lbC9wdHJhY2UuYwppbmRleCA5OWJiYWEzLi4xNzA4YjFlIDEwMDY0NAotLS0gYS9rZXJuZWwvcHRyYWNlLmMKKysrIGIva2VybmVsL3B0cmFjZS5jCkBAIC0zMTMsNyArMzEzLDcgQEAKIAkJY2hpbGQtPmV4aXRfY29kZSA9IGRhdGE7CiAJCWRlYWQgPSBfX3B0cmFjZV9kZXRhY2goY3VycmVudCwgY2hpbGQpOwogCQlpZiAoIWNoaWxkLT5leGl0X3N0YXRlKQotCQkJd2FrZV91cF9wcm9jZXNzKGNoaWxkKTsKKwkJCXdha2VfdXBfc3RhdGUoY2hpbGQsIFRBU0tfVFJBQ0VEIHwgVEFTS19TVE9QUEVEKTsKIAl9CiAJd3JpdGVfdW5sb2NrX2lycSgmdGFza2xpc3RfbG9jayk7CiAKZGlmZiAtLWdpdCBhL2tlcm5lbC9yY3V0aW55LmMgYi9rZXJuZWwvcmN1dGlueS5jCmluZGV4IDAzNDQ5MzcuLjBjMzQzYjkgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9yY3V0aW55LmMKKysrIGIva2VybmVsL3JjdXRpbnkuYwpAQCAtMTg5LDcgKzE4OSw4IEBACiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCWZvciAoOzspIHsKLQkJd2FpdF9ldmVudChyY3Vfa3RocmVhZF93cSwgaGF2ZV9yY3Vfa3RocmVhZF93b3JrICE9IDApOworCQl3YWl0X2V2ZW50X2ludGVycnVwdGlibGUocmN1X2t0aHJlYWRfd3EsCisJCQkJCSBoYXZlX3JjdV9rdGhyZWFkX3dvcmsgIT0gMCk7CiAJCW1vcmV3b3JrID0gcmN1X2Jvb3N0KCk7CiAJCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKIAkJd29yayA9IGhhdmVfcmN1X2t0aHJlYWRfd29yazsKZGlmZiAtLWdpdCBhL2tlcm5lbC9zY2hlZC5jIGIva2VybmVsL3NjaGVkLmMKaW5kZXggZWEzZTVlZi4uMThkMzhlNCAxMDA2NDQKLS0tIGEva2VybmVsL3NjaGVkLmMKKysrIGIva2VybmVsL3NjaGVkLmMKQEAgLTU1Myw5ICs1NTMsNiBAQAogCS8qIHRyeV90b193YWtlX3VwKCkgc3RhdHMgKi8KIAl1bnNpZ25lZCBpbnQgdHR3dV9jb3VudDsKIAl1bnNpZ25lZCBpbnQgdHR3dV9sb2NhbDsKLQotCS8qIEJLTCBzdGF0cyAqLwotCXVuc2lnbmVkIGludCBia2xfY291bnQ7CiAjZW5kaWYKIH07CiAKQEAgLTYwOSw2ICs2MDYsOSBAQAogCXN0cnVjdCB0YXNrX2dyb3VwICp0ZzsKIAlzdHJ1Y3QgY2dyb3VwX3N1YnN5c19zdGF0ZSAqY3NzOwogCisJaWYgKHAtPmZsYWdzICYgUEZfRVhJVElORykKKwkJcmV0dXJuICZyb290X3Rhc2tfZ3JvdXA7CisKIAljc3MgPSB0YXNrX3N1YnN5c19zdGF0ZV9jaGVjayhwLCBjcHVfY2dyb3VwX3N1YnN5c19pZCwKIAkJCWxvY2tkZXBfaXNfaGVsZCgmdGFza19ycShwKS0+bG9jaykpOwogCXRnID0gY29udGFpbmVyX29mKGNzcywgc3RydWN0IHRhc2tfZ3JvdXAsIGNzcyk7CkBAIC0zODg3LDcgKzM4ODcsNyBAQAogCXNjaGVkc3RhdF9pbmModGhpc19ycSgpLCBzY2hlZF9jb3VudCk7CiAjaWZkZWYgQ09ORklHX1NDSEVEU1RBVFMKIAlpZiAodW5saWtlbHkocHJldi0+bG9ja19kZXB0aCA+PSAwKSkgewotCQlzY2hlZHN0YXRfaW5jKHRoaXNfcnEoKSwgYmtsX2NvdW50KTsKKwkJc2NoZWRzdGF0X2luYyh0aGlzX3JxKCksIHJxX3NjaGVkX2luZm8uYmtsX2NvdW50KTsKIAkJc2NoZWRzdGF0X2luYyhwcmV2LCBzY2hlZF9pbmZvLmJrbF9jb3VudCk7CiAJfQogI2VuZGlmCkBAIC00ODcxLDcgKzQ4NzEsOCBAQAogCQkgKiBhc3NpZ25lZC4KIAkJICovCiAJCWlmIChydF9iYW5kd2lkdGhfZW5hYmxlZCgpICYmIHJ0X3BvbGljeShwb2xpY3kpICYmCi0JCQkJdGFza19ncm91cChwKS0+cnRfYmFuZHdpZHRoLnJ0X3J1bnRpbWUgPT0gMCkgeworCQkJCXRhc2tfZ3JvdXAocCktPnJ0X2JhbmR3aWR0aC5ydF9ydW50aW1lID09IDAgJiYKKwkJCQkhdGFza19ncm91cF9pc19hdXRvZ3JvdXAodGFza19ncm91cChwKSkpIHsKIAkJCV9fdGFza19ycV91bmxvY2socnEpOwogCQkJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnAtPnBpX2xvY2ssIGZsYWdzKTsKIAkJCXJldHVybiAtRVBFUk07CkBAIC04ODgyLDYgKzg4ODMsMjAgQEAKIAl9CiB9CiAKK3N0YXRpYyB2b2lkCitjcHVfY2dyb3VwX2V4aXQoc3RydWN0IGNncm91cF9zdWJzeXMgKnNzLCBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spCit7CisJLyoKKwkgKiBjZ3JvdXBfZXhpdCgpIGlzIGNhbGxlZCBpbiB0aGUgY29weV9wcm9jZXNzKCkgZmFpbHVyZSBwYXRoLgorCSAqIElnbm9yZSB0aGlzIGNhc2Ugc2luY2UgdGhlIHRhc2sgaGFzbid0IHJhbiB5ZXQsIHRoaXMgYXZvaWRzCisJICogdHJ5aW5nIHRvIHBva2UgYSBoYWxmIGZyZWVkIHRhc2sgc3RhdGUgZnJvbSBnZW5lcmljIGNvZGUuCisJICovCisJaWYgKCEodGFzay0+ZmxhZ3MgJiBQRl9FWElUSU5HKSkKKwkJcmV0dXJuOworCisJc2NoZWRfbW92ZV90YXNrKHRhc2spOworfQorCiAjaWZkZWYgQ09ORklHX0ZBSVJfR1JPVVBfU0NIRUQKIHN0YXRpYyBpbnQgY3B1X3NoYXJlc193cml0ZV91NjQoc3RydWN0IGNncm91cCAqY2dycCwgc3RydWN0IGNmdHlwZSAqY2Z0eXBlLAogCQkJCXU2NCBzaGFyZXZhbCkKQEAgLTg5NTQsNiArODk2OSw3IEBACiAJLmRlc3Ryb3kJPSBjcHVfY2dyb3VwX2Rlc3Ryb3ksCiAJLmNhbl9hdHRhY2gJPSBjcHVfY2dyb3VwX2Nhbl9hdHRhY2gsCiAJLmF0dGFjaAkJPSBjcHVfY2dyb3VwX2F0dGFjaCwKKwkuZXhpdAkJPSBjcHVfY2dyb3VwX2V4aXQsCiAJLnBvcHVsYXRlCT0gY3B1X2Nncm91cF9wb3B1bGF0ZSwKIAkuc3Vic3lzX2lkCT0gY3B1X2Nncm91cF9zdWJzeXNfaWQsCiAJLmVhcmx5X2luaXQJPSAxLApkaWZmIC0tZ2l0IGEva2VybmVsL3NjaGVkX2F1dG9ncm91cC5jIGIva2VybmVsL3NjaGVkX2F1dG9ncm91cC5jCmluZGV4IDMyYTcyM2IuLjlmYjY1NjIgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9zY2hlZF9hdXRvZ3JvdXAuYworKysgYi9rZXJuZWwvc2NoZWRfYXV0b2dyb3VwLmMKQEAgLTI3LDYgKzI3LDExIEBACiB7CiAJc3RydWN0IGF1dG9ncm91cCAqYWcgPSBjb250YWluZXJfb2Yoa3JlZiwgc3RydWN0IGF1dG9ncm91cCwga3JlZik7CiAKKyNpZmRlZiBDT05GSUdfUlRfR1JPVVBfU0NIRUQKKwkvKiBXZSd2ZSByZWRpcmVjdGVkIFJUIHRhc2tzIHRvIHRoZSByb290IHRhc2sgZ3JvdXAuLi4gKi8KKwlhZy0+dGctPnJ0X3NlID0gTlVMTDsKKwlhZy0+dGctPnJ0X3JxID0gTlVMTDsKKyNlbmRpZgogCXNjaGVkX2Rlc3Ryb3lfZ3JvdXAoYWctPnRnKTsKIH0KIApAQCAtNTUsNiArNjAsMTAgQEAKIAlyZXR1cm4gYWc7CiB9CiAKKyNpZmRlZiBDT05GSUdfUlRfR1JPVVBfU0NIRUQKK3N0YXRpYyB2b2lkIGZyZWVfcnRfc2NoZWRfZ3JvdXAoc3RydWN0IHRhc2tfZ3JvdXAgKnRnKTsKKyNlbmRpZgorCiBzdGF0aWMgaW5saW5lIHN0cnVjdCBhdXRvZ3JvdXAgKmF1dG9ncm91cF9jcmVhdGUodm9pZCkKIHsKIAlzdHJ1Y3QgYXV0b2dyb3VwICphZyA9IGt6YWxsb2Moc2l6ZW9mKCphZyksIEdGUF9LRVJORUwpOwpAQCAtNzIsNiArODEsMTkgQEAKIAlpbml0X3J3c2VtKCZhZy0+bG9jayk7CiAJYWctPmlkID0gYXRvbWljX2luY19yZXR1cm4oJmF1dG9ncm91cF9zZXFfbnIpOwogCWFnLT50ZyA9IHRnOworI2lmZGVmIENPTkZJR19SVF9HUk9VUF9TQ0hFRAorCS8qCisJICogQXV0b2dyb3VwIFJUIHRhc2tzIGFyZSByZWRpcmVjdGVkIHRvIHRoZSByb290IHRhc2sgZ3JvdXAKKwkgKiBzbyB3ZSBkb24ndCBoYXZlIHRvIG1vdmUgdGFza3MgYXJvdW5kIHVwb24gcG9saWN5IGNoYW5nZSwKKwkgKiBvciBmbGFpbCBhcm91bmQgdHJ5aW5nIHRvIGFsbG9jYXRlIGJhbmR3aWR0aCBvbiB0aGUgZmx5LgorCSAqIEEgYmFuZHdpZHRoIGV4Y2VwdGlvbiBpbiBfX3NjaGVkX3NldHNjaGVkdWxlcigpIGFsbG93cworCSAqIHRoZSBwb2xpY3kgY2hhbmdlIHRvIHByb2NlZWQuICBUaGVyZWFmdGVyLCB0YXNrX2dyb3VwKCkKKwkgKiByZXR1cm5zICZyb290X3Rhc2tfZ3JvdXAsIHNvIHplcm8gYmFuZHdpZHRoIGlzIHJlcXVpcmVkLgorCSAqLworCWZyZWVfcnRfc2NoZWRfZ3JvdXAodGcpOworCXRnLT5ydF9zZSA9IHJvb3RfdGFza19ncm91cC5ydF9zZTsKKwl0Zy0+cnRfcnEgPSByb290X3Rhc2tfZ3JvdXAucnRfcnE7CisjZW5kaWYKIAl0Zy0+YXV0b2dyb3VwID0gYWc7CiAKIAlyZXR1cm4gYWc7CkBAIC0xMDYsNiArMTI4LDExIEBACiAJcmV0dXJuIHRydWU7CiB9CiAKK3N0YXRpYyBpbmxpbmUgYm9vbCB0YXNrX2dyb3VwX2lzX2F1dG9ncm91cChzdHJ1Y3QgdGFza19ncm91cCAqdGcpCit7CisJcmV0dXJuIHRnICE9ICZyb290X3Rhc2tfZ3JvdXAgJiYgdGctPmF1dG9ncm91cDsKK30KKwogc3RhdGljIGlubGluZSBzdHJ1Y3QgdGFza19ncm91cCAqCiBhdXRvZ3JvdXBfdGFza19ncm91cChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAsIHN0cnVjdCB0YXNrX2dyb3VwICp0ZykKIHsKQEAgLTIzMSw2ICsyNTgsMTEgQEAKICNpZmRlZiBDT05GSUdfU0NIRURfREVCVUcKIHN0YXRpYyBpbmxpbmUgaW50IGF1dG9ncm91cF9wYXRoKHN0cnVjdCB0YXNrX2dyb3VwICp0ZywgY2hhciAqYnVmLCBpbnQgYnVmbGVuKQogeworCWludCBlbmFibGVkID0gQUNDRVNTX09OQ0Uoc3lzY3RsX3NjaGVkX2F1dG9ncm91cF9lbmFibGVkKTsKKworCWlmICghZW5hYmxlZCB8fCAhdGctPmF1dG9ncm91cCkKKwkJcmV0dXJuIDA7CisKIAlyZXR1cm4gc25wcmludGYoYnVmLCBidWZsZW4sICIlcy0lbGQiLCAiL2F1dG9ncm91cCIsIHRnLT5hdXRvZ3JvdXAtPmlkKTsKIH0KICNlbmRpZiAvKiBDT05GSUdfU0NIRURfREVCVUcgKi8KZGlmZiAtLWdpdCBhL2tlcm5lbC9zY2hlZF9hdXRvZ3JvdXAuaCBiL2tlcm5lbC9zY2hlZF9hdXRvZ3JvdXAuaAppbmRleCA1MzU4ZTI0Li43Yjg1OWZmIDEwMDY0NAotLS0gYS9rZXJuZWwvc2NoZWRfYXV0b2dyb3VwLmgKKysrIGIva2VybmVsL3NjaGVkX2F1dG9ncm91cC5oCkBAIC0xNSw2ICsxNSwxMCBAQAogCiBzdGF0aWMgaW5saW5lIHZvaWQgYXV0b2dyb3VwX2luaXQoc3RydWN0IHRhc2tfc3RydWN0ICppbml0X3Rhc2spIHsgIH0KIHN0YXRpYyBpbmxpbmUgdm9pZCBhdXRvZ3JvdXBfZnJlZShzdHJ1Y3QgdGFza19ncm91cCAqdGcpIHsgfQorc3RhdGljIGlubGluZSBib29sIHRhc2tfZ3JvdXBfaXNfYXV0b2dyb3VwKHN0cnVjdCB0YXNrX2dyb3VwICp0ZykKK3sKKwlyZXR1cm4gMDsKK30KIAogc3RhdGljIGlubGluZSBzdHJ1Y3QgdGFza19ncm91cCAqCiBhdXRvZ3JvdXBfdGFza19ncm91cChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAsIHN0cnVjdCB0YXNrX2dyb3VwICp0ZykKZGlmZiAtLWdpdCBhL2tlcm5lbC9zY2hlZF9kZWJ1Zy5jIGIva2VybmVsL3NjaGVkX2RlYnVnLmMKaW5kZXggMWRmYWUzZC4uZWI2Y2I4ZSAxMDA2NDQKLS0tIGEva2VybmVsL3NjaGVkX2RlYnVnLmMKKysrIGIva2VybmVsL3NjaGVkX2RlYnVnLmMKQEAgLTE2LDYgKzE2LDggQEAKICNpbmNsdWRlIDxsaW51eC9rYWxsc3ltcy5oPgogI2luY2x1ZGUgPGxpbnV4L3V0c25hbWUuaD4KIAorc3RhdGljIERFRklORV9TUElOTE9DSyhzY2hlZF9kZWJ1Z19sb2NrKTsKKwogLyoKICAqIFRoaXMgYWxsb3dzIHByaW50aW5nIGJvdGggdG8gL3Byb2Mvc2NoZWRfZGVidWcgYW5kCiAgKiB0byB0aGUgY29uc29sZQpAQCAtODYsNiArODgsMjYgQEAKIH0KICNlbmRpZgogCisjaWZkZWYgQ09ORklHX0NHUk9VUF9TQ0hFRAorc3RhdGljIGNoYXIgZ3JvdXBfcGF0aFtQQVRIX01BWF07CisKK3N0YXRpYyBjaGFyICp0YXNrX2dyb3VwX3BhdGgoc3RydWN0IHRhc2tfZ3JvdXAgKnRnKQoreworCWlmIChhdXRvZ3JvdXBfcGF0aCh0ZywgZ3JvdXBfcGF0aCwgUEFUSF9NQVgpKQorCQlyZXR1cm4gZ3JvdXBfcGF0aDsKKworCS8qCisJICogTWF5IGJlIE5VTEwgaWYgdGhlIHVuZGVybHlpbmcgY2dyb3VwIGlzbid0IGZ1bGx5LWNyZWF0ZWQgeWV0CisJICovCisJaWYgKCF0Zy0+Y3NzLmNncm91cCkgeworCQlncm91cF9wYXRoWzBdID0gJ1wwJzsKKwkJcmV0dXJuIGdyb3VwX3BhdGg7CisJfQorCWNncm91cF9wYXRoKHRnLT5jc3MuY2dyb3VwLCBncm91cF9wYXRoLCBQQVRIX01BWCk7CisJcmV0dXJuIGdyb3VwX3BhdGg7Cit9CisjZW5kaWYKKwogc3RhdGljIHZvaWQKIHByaW50X3Rhc2soc3RydWN0IHNlcV9maWxlICptLCBzdHJ1Y3QgcnEgKnJxLCBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnApCiB7CkBAIC0xMDgsNiArMTMwLDkgQEAKIAlTRVFfcHJpbnRmKG0sICIlMTVMZCAlMTVMZCAlMTVMZC4lMDZsZCAlMTVMZC4lMDZsZCAlMTVMZC4lMDZsZCIsCiAJCTBMTCwgMExMLCAwTEwsIDBMLCAwTEwsIDBMLCAwTEwsIDBMKTsKICNlbmRpZgorI2lmZGVmIENPTkZJR19DR1JPVVBfU0NIRUQKKwlTRVFfcHJpbnRmKG0sICIgJXMiLCB0YXNrX2dyb3VwX3BhdGgodGFza19ncm91cChwKSkpOworI2VuZGlmCiAKIAlTRVFfcHJpbnRmKG0sICJcbiIpOwogfQpAQCAtMTQ0LDcgKzE2OSwxMSBAQAogCXN0cnVjdCBzY2hlZF9lbnRpdHkgKmxhc3Q7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAorI2lmZGVmIENPTkZJR19GQUlSX0dST1VQX1NDSEVECisJU0VRX3ByaW50ZihtLCAiXG5jZnNfcnFbJWRdOiVzXG4iLCBjcHUsIHRhc2tfZ3JvdXBfcGF0aChjZnNfcnEtPnRnKSk7CisjZWxzZQogCVNFUV9wcmludGYobSwgIlxuY2ZzX3JxWyVkXTpcbiIsIGNwdSk7CisjZW5kaWYKIAlTRVFfcHJpbnRmKG0sICIgIC4lLTMwczogJUxkLiUwNmxkXG4iLCAiZXhlY19jbG9jayIsCiAJCQlTUExJVF9OUyhjZnNfcnEtPmV4ZWNfY2xvY2spKTsKIApAQCAtMTkxLDcgKzIyMCwxMSBAQAogCiB2b2lkIHByaW50X3J0X3JxKHN0cnVjdCBzZXFfZmlsZSAqbSwgaW50IGNwdSwgc3RydWN0IHJ0X3JxICpydF9ycSkKIHsKKyNpZmRlZiBDT05GSUdfUlRfR1JPVVBfU0NIRUQKKwlTRVFfcHJpbnRmKG0sICJcbnJ0X3JxWyVkXTolc1xuIiwgY3B1LCB0YXNrX2dyb3VwX3BhdGgocnRfcnEtPnRnKSk7CisjZWxzZQogCVNFUV9wcmludGYobSwgIlxucnRfcnFbJWRdOlxuIiwgY3B1KTsKKyNlbmRpZgogCiAjZGVmaW5lIFAoeCkgXAogCVNFUV9wcmludGYobSwgIiAgLiUtMzBzOiAlTGRcbiIsICN4LCAobG9uZyBsb25nKShydF9ycS0+eCkpCkBAIC0yMTIsNiArMjQ1LDcgQEAKIHN0YXRpYyB2b2lkIHByaW50X2NwdShzdHJ1Y3Qgc2VxX2ZpbGUgKm0sIGludCBjcHUpCiB7CiAJc3RydWN0IHJxICpycSA9IGNwdV9ycShjcHUpOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKICNpZmRlZiBDT05GSUdfWDg2CiAJewpAQCAtMjYyLDE0ICsyOTYsMjAgQEAKIAlQKHR0d3VfY291bnQpOwogCVAodHR3dV9sb2NhbCk7CiAKLQlQKGJrbF9jb3VudCk7CisJU0VRX3ByaW50ZihtLCAiICAuJS0zMHM6ICVkXG4iLCAiYmtsX2NvdW50IiwKKwkJCQlycS0+cnFfc2NoZWRfaW5mby5ia2xfY291bnQpOwogCiAjdW5kZWYgUAorI3VuZGVmIFA2NAogI2VuZGlmCisJc3Bpbl9sb2NrX2lycXNhdmUoJnNjaGVkX2RlYnVnX2xvY2ssIGZsYWdzKTsKIAlwcmludF9jZnNfc3RhdHMobSwgY3B1KTsKIAlwcmludF9ydF9zdGF0cyhtLCBjcHUpOwogCisJcmN1X3JlYWRfbG9jaygpOwogCXByaW50X3JxKG0sIHJxLCBjcHUpOworCXJjdV9yZWFkX3VubG9jaygpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNjaGVkX2RlYnVnX2xvY2ssIGZsYWdzKTsKIH0KIAogc3RhdGljIGNvbnN0IGNoYXIgKnNjaGVkX3R1bmFibGVfc2NhbGluZ19uYW1lc1tdID0gewpkaWZmIC0tZ2l0IGEva2VybmVsL3NjaGVkX2ZhaXIuYyBiL2tlcm5lbC9zY2hlZF9mYWlyLmMKaW5kZXggYzYyZWJhZS4uMGMyNmUyZCAxMDA2NDQKLS0tIGEva2VybmVsL3NjaGVkX2ZhaXIuYworKysgYi9rZXJuZWwvc2NoZWRfZmFpci5jCkBAIC02OTksNyArNjk5LDggQEAKIAljZnNfcnEtPm5yX3J1bm5pbmctLTsKIH0KIAotI2lmIGRlZmluZWQgQ09ORklHX1NNUCAmJiBkZWZpbmVkIENPTkZJR19GQUlSX0dST1VQX1NDSEVECisjaWZkZWYgQ09ORklHX0ZBSVJfR1JPVVBfU0NIRUQKKyMgaWZkZWYgQ09ORklHX1NNUAogc3RhdGljIHZvaWQgdXBkYXRlX2Nmc19ycV9sb2FkX2NvbnRyaWJ1dGlvbihzdHJ1Y3QgY2ZzX3JxICpjZnNfcnEsCiAJCQkJCSAgICBpbnQgZ2xvYmFsX3VwZGF0ZSkKIHsKQEAgLTcyMSwxMCArNzIyLDEwIEBACiAJdTY0IG5vdywgZGVsdGE7CiAJdW5zaWduZWQgbG9uZyBsb2FkID0gY2ZzX3JxLT5sb2FkLndlaWdodDsKIAotCWlmICghY2ZzX3JxKQorCWlmIChjZnNfcnEtPnRnID09ICZyb290X3Rhc2tfZ3JvdXApCiAJCXJldHVybjsKIAotCW5vdyA9IHJxX29mKGNmc19ycSktPmNsb2NrOworCW5vdyA9IHJxX29mKGNmc19ycSktPmNsb2NrX3Rhc2s7CiAJZGVsdGEgPSBub3cgLSBjZnNfcnEtPmxvYWRfc3RhbXA7CiAKIAkvKiB0cnVuY2F0ZSBsb2FkIGhpc3RvcnkgYXQgNCBpZGxlIHBlcmlvZHMgKi8KQEAgLTc2Miw2ICs3NjMsNTEgQEAKIAkJbGlzdF9kZWxfbGVhZl9jZnNfcnEoY2ZzX3JxKTsKIH0KIAorc3RhdGljIGxvbmcgY2FsY19jZnNfc2hhcmVzKHN0cnVjdCBjZnNfcnEgKmNmc19ycSwgc3RydWN0IHRhc2tfZ3JvdXAgKnRnLAorCQkJCWxvbmcgd2VpZ2h0X2RlbHRhKQoreworCWxvbmcgbG9hZF93ZWlnaHQsIGxvYWQsIHNoYXJlczsKKworCWxvYWQgPSBjZnNfcnEtPmxvYWQud2VpZ2h0ICsgd2VpZ2h0X2RlbHRhOworCisJbG9hZF93ZWlnaHQgPSBhdG9taWNfcmVhZCgmdGctPmxvYWRfd2VpZ2h0KTsKKwlsb2FkX3dlaWdodCAtPSBjZnNfcnEtPmxvYWRfY29udHJpYnV0aW9uOworCWxvYWRfd2VpZ2h0ICs9IGxvYWQ7CisKKwlzaGFyZXMgPSAodGctPnNoYXJlcyAqIGxvYWQpOworCWlmIChsb2FkX3dlaWdodCkKKwkJc2hhcmVzIC89IGxvYWRfd2VpZ2h0OworCisJaWYgKHNoYXJlcyA8IE1JTl9TSEFSRVMpCisJCXNoYXJlcyA9IE1JTl9TSEFSRVM7CisJaWYgKHNoYXJlcyA+IHRnLT5zaGFyZXMpCisJCXNoYXJlcyA9IHRnLT5zaGFyZXM7CisKKwlyZXR1cm4gc2hhcmVzOworfQorCitzdGF0aWMgdm9pZCB1cGRhdGVfZW50aXR5X3NoYXJlc190aWNrKHN0cnVjdCBjZnNfcnEgKmNmc19ycSkKK3sKKwlpZiAoY2ZzX3JxLT5sb2FkX3VuYWNjX2V4ZWNfdGltZSA+IHN5c2N0bF9zY2hlZF9zaGFyZXNfd2luZG93KSB7CisJCXVwZGF0ZV9jZnNfbG9hZChjZnNfcnEsIDApOworCQl1cGRhdGVfY2ZzX3NoYXJlcyhjZnNfcnEsIDApOworCX0KK30KKyMgZWxzZSAvKiBDT05GSUdfU01QICovCitzdGF0aWMgdm9pZCB1cGRhdGVfY2ZzX2xvYWQoc3RydWN0IGNmc19ycSAqY2ZzX3JxLCBpbnQgZ2xvYmFsX3VwZGF0ZSkKK3sKK30KKworc3RhdGljIGlubGluZSBsb25nIGNhbGNfY2ZzX3NoYXJlcyhzdHJ1Y3QgY2ZzX3JxICpjZnNfcnEsIHN0cnVjdCB0YXNrX2dyb3VwICp0ZywKKwkJCQlsb25nIHdlaWdodF9kZWx0YSkKK3sKKwlyZXR1cm4gdGctPnNoYXJlczsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHVwZGF0ZV9lbnRpdHlfc2hhcmVzX3RpY2soc3RydWN0IGNmc19ycSAqY2ZzX3JxKQoreworfQorIyBlbmRpZiAvKiBDT05GSUdfU01QICovCiBzdGF0aWMgdm9pZCByZXdlaWdodF9lbnRpdHkoc3RydWN0IGNmc19ycSAqY2ZzX3JxLCBzdHJ1Y3Qgc2NoZWRfZW50aXR5ICpzZSwKIAkJCSAgICB1bnNpZ25lZCBsb25nIHdlaWdodCkKIHsKQEAgLTc4Miw0MSArODI4LDIwIEBACiB7CiAJc3RydWN0IHRhc2tfZ3JvdXAgKnRnOwogCXN0cnVjdCBzY2hlZF9lbnRpdHkgKnNlOwotCWxvbmcgbG9hZF93ZWlnaHQsIGxvYWQsIHNoYXJlczsKLQotCWlmICghY2ZzX3JxKQotCQlyZXR1cm47CisJbG9uZyBzaGFyZXM7CiAKIAl0ZyA9IGNmc19ycS0+dGc7CiAJc2UgPSB0Zy0+c2VbY3B1X29mKHJxX29mKGNmc19ycSkpXTsKIAlpZiAoIXNlKQogCQlyZXR1cm47Ci0KLQlsb2FkID0gY2ZzX3JxLT5sb2FkLndlaWdodCArIHdlaWdodF9kZWx0YTsKLQotCWxvYWRfd2VpZ2h0ID0gYXRvbWljX3JlYWQoJnRnLT5sb2FkX3dlaWdodCk7Ci0JbG9hZF93ZWlnaHQgLT0gY2ZzX3JxLT5sb2FkX2NvbnRyaWJ1dGlvbjsKLQlsb2FkX3dlaWdodCArPSBsb2FkOwotCi0Jc2hhcmVzID0gKHRnLT5zaGFyZXMgKiBsb2FkKTsKLQlpZiAobG9hZF93ZWlnaHQpCi0JCXNoYXJlcyAvPSBsb2FkX3dlaWdodDsKLQotCWlmIChzaGFyZXMgPCBNSU5fU0hBUkVTKQotCQlzaGFyZXMgPSBNSU5fU0hBUkVTOwotCWlmIChzaGFyZXMgPiB0Zy0+c2hhcmVzKQotCQlzaGFyZXMgPSB0Zy0+c2hhcmVzOworI2lmbmRlZiBDT05GSUdfU01QCisJaWYgKGxpa2VseShzZS0+bG9hZC53ZWlnaHQgPT0gdGctPnNoYXJlcykpCisJCXJldHVybjsKKyNlbmRpZgorCXNoYXJlcyA9IGNhbGNfY2ZzX3NoYXJlcyhjZnNfcnEsIHRnLCB3ZWlnaHRfZGVsdGEpOwogCiAJcmV3ZWlnaHRfZW50aXR5KGNmc19ycV9vZihzZSksIHNlLCBzaGFyZXMpOwogfQotCi1zdGF0aWMgdm9pZCB1cGRhdGVfZW50aXR5X3NoYXJlc190aWNrKHN0cnVjdCBjZnNfcnEgKmNmc19ycSkKLXsKLQlpZiAoY2ZzX3JxLT5sb2FkX3VuYWNjX2V4ZWNfdGltZSA+IHN5c2N0bF9zY2hlZF9zaGFyZXNfd2luZG93KSB7Ci0JCXVwZGF0ZV9jZnNfbG9hZChjZnNfcnEsIDApOwotCQl1cGRhdGVfY2ZzX3NoYXJlcyhjZnNfcnEsIDApOwotCX0KLX0KICNlbHNlIC8qIENPTkZJR19GQUlSX0dST1VQX1NDSEVEICovCiBzdGF0aWMgdm9pZCB1cGRhdGVfY2ZzX2xvYWQoc3RydWN0IGNmc19ycSAqY2ZzX3JxLCBpbnQgZ2xvYmFsX3VwZGF0ZSkKIHsKQEAgLTEwNjIsNiArMTA4Nyw5IEBACiAJCXN0cnVjdCBzY2hlZF9lbnRpdHkgKnNlID0gX19waWNrX25leHRfZW50aXR5KGNmc19ycSk7CiAJCXM2NCBkZWx0YSA9IGN1cnItPnZydW50aW1lIC0gc2UtPnZydW50aW1lOwogCisJCWlmIChkZWx0YSA8IDApCisJCQlyZXR1cm47CisKIAkJaWYgKGRlbHRhID4gaWRlYWxfcnVudGltZSkKIAkJCXJlc2NoZWRfdGFzayhycV9vZihjZnNfcnEpLT5jdXJyKTsKIAl9CkBAIC0xMzYyLDI3ICsxMzkwLDI3IEBACiAJCXJldHVybiB3bDsKIAogCWZvcl9lYWNoX3NjaGVkX2VudGl0eShzZSkgewotCQlsb25nIFMsIHJ3LCBzLCBhLCBiOworCQlsb25nIGx3LCB3OwogCi0JCVMgPSBzZS0+bXlfcS0+dGctPnNoYXJlczsKLQkJcyA9IHNlLT5sb2FkLndlaWdodDsKLQkJcncgPSBzZS0+bXlfcS0+bG9hZC53ZWlnaHQ7CisJCXRnID0gc2UtPm15X3EtPnRnOworCQl3ID0gc2UtPm15X3EtPmxvYWQud2VpZ2h0OwogCi0JCWEgPSBTKihydyArIHdsKTsKLQkJYiA9IFMqcncgKyBzKndnOworCQkvKiB1c2UgdGhpcyBjcHUncyBpbnN0YW50YW5lb3VzIGNvbnRyaWJ1dGlvbiAqLworCQlsdyA9IGF0b21pY19yZWFkKCZ0Zy0+bG9hZF93ZWlnaHQpOworCQlsdyAtPSBzZS0+bXlfcS0+bG9hZF9jb250cmlidXRpb247CisJCWx3ICs9IHcgKyB3ZzsKIAotCQl3bCA9IHMqKGEtYik7CisJCXdsICs9IHc7CiAKLQkJaWYgKGxpa2VseShiKSkKLQkJCXdsIC89IGI7CisJCWlmIChsdyA+IDAgJiYgd2wgPCBsdykKKwkJCXdsID0gKHdsICogdGctPnNoYXJlcykgLyBsdzsKKwkJZWxzZQorCQkJd2wgPSB0Zy0+c2hhcmVzOwogCi0JCS8qCi0JCSAqIEFzc3VtZSB0aGUgZ3JvdXAgaXMgYWxyZWFkeSBydW5uaW5nIGFuZCB3aWxsCi0JCSAqIHRodXMgYWxyZWFkeSBiZSBhY2NvdW50ZWQgZm9yIGluIHRoZSB3ZWlnaHQuCi0JCSAqCi0JCSAqIFRoYXQgaXMsIG1vdmluZyBzaGFyZXMgYmV0d2VlbiBDUFVzLCBkb2VzIG5vdAotCQkgKiBhbHRlciB0aGUgZ3JvdXAgd2VpZ2h0LgotCQkgKi8KKwkJLyogemVybyBwb2ludCBpcyBNSU5fU0hBUkVTICovCisJCWlmICh3bCA8IE1JTl9TSEFSRVMpCisJCQl3bCA9IE1JTl9TSEFSRVM7CisJCXdsIC09IHNlLT5sb2FkLndlaWdodDsKIAkJd2cgPSAwOwogCX0KIApAQCAtMTQwMSw3ICsxNDI5LDcgQEAKIAogc3RhdGljIGludCB3YWtlX2FmZmluZShzdHJ1Y3Qgc2NoZWRfZG9tYWluICpzZCwgc3RydWN0IHRhc2tfc3RydWN0ICpwLCBpbnQgc3luYykKIHsKLQl1bnNpZ25lZCBsb25nIHRoaXNfbG9hZCwgbG9hZDsKKwlzNjQgdGhpc19sb2FkLCBsb2FkOwogCWludCBpZHgsIHRoaXNfY3B1LCBwcmV2X2NwdTsKIAl1bnNpZ25lZCBsb25nIHRsX3Blcl90YXNrOwogCXN0cnVjdCB0YXNrX2dyb3VwICp0ZzsKQEAgLTE0NDAsOCArMTQ2OCw4IEBACiAJICogT3RoZXJ3aXNlIGNoZWNrIGlmIGVpdGhlciBjcHVzIGFyZSBuZWFyIGVub3VnaCBpbiBsb2FkIHRvIGFsbG93IHRoaXMKIAkgKiB0YXNrIHRvIGJlIHdva2VuIG9uIHRoaXNfY3B1LgogCSAqLwotCWlmICh0aGlzX2xvYWQpIHsKLQkJdW5zaWduZWQgbG9uZyB0aGlzX2VmZl9sb2FkLCBwcmV2X2VmZl9sb2FkOworCWlmICh0aGlzX2xvYWQgPiAwKSB7CisJCXM2NCB0aGlzX2VmZl9sb2FkLCBwcmV2X2VmZl9sb2FkOwogCiAJCXRoaXNfZWZmX2xvYWQgPSAxMDA7CiAJCXRoaXNfZWZmX2xvYWQgKj0gcG93ZXJfb2YocHJldl9jcHUpOwpkaWZmIC0tZ2l0IGEva2VybmVsL3NjaGVkX3J0LmMgYi9rZXJuZWwvc2NoZWRfcnQuYwppbmRleCBjOTE0ZWM3Li5hZDYyNjc3IDEwMDY0NAotLS0gYS9rZXJuZWwvc2NoZWRfcnQuYworKysgYi9rZXJuZWwvc2NoZWRfcnQuYwpAQCAtNjI1LDcgKzYyNSw3IEBACiAJc3RydWN0IHJ0X3JxICpydF9ycSA9IHJ0X3JxX29mX3NlKHJ0X3NlKTsKIAl1NjQgZGVsdGFfZXhlYzsKIAotCWlmICghdGFza19oYXNfcnRfcG9saWN5KGN1cnIpKQorCWlmIChjdXJyLT5zY2hlZF9jbGFzcyAhPSAmcnRfc2NoZWRfY2xhc3MpCiAJCXJldHVybjsKIAogCWRlbHRhX2V4ZWMgPSBycS0+Y2xvY2tfdGFzayAtIGN1cnItPnNlLmV4ZWNfc3RhcnQ7CmRpZmYgLS1naXQgYS9rZXJuZWwvc21wLmMgYi9rZXJuZWwvc21wLmMKaW5kZXggNGVjMzBlMC4uOTkxMDc0NCAxMDA2NDQKLS0tIGEva2VybmVsL3NtcC5jCisrKyBiL2tlcm5lbC9zbXAuYwpAQCAtMTk0LDIzICsxOTQsNTIgQEAKIAkgKi8KIAlsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShkYXRhLCAmY2FsbF9mdW5jdGlvbi5xdWV1ZSwgY3NkLmxpc3QpIHsKIAkJaW50IHJlZnM7CisJCXZvaWQgKCpmdW5jKSAodm9pZCAqaW5mbyk7CiAKLQkJaWYgKCFjcHVtYXNrX3Rlc3RfYW5kX2NsZWFyX2NwdShjcHUsIGRhdGEtPmNwdW1hc2spKQorCQkvKgorCQkgKiBTaW5jZSB3ZSB3YWxrIHRoZSBsaXN0IHdpdGhvdXQgYW55IGxvY2tzLCB3ZSBtaWdodAorCQkgKiBzZWUgYW4gZW50cnkgdGhhdCB3YXMgY29tcGxldGVkLCByZW1vdmVkIGZyb20gdGhlCisJCSAqIGxpc3QgYW5kIGlzIGluIHRoZSBwcm9jZXNzIG9mIGJlaW5nIHJldXNlZC4KKwkJICoKKwkJICogV2UgbXVzdCBjaGVjayB0aGF0IHRoZSBjcHUgaXMgaW4gdGhlIGNwdW1hc2sgYmVmb3JlCisJCSAqIGNoZWNraW5nIHRoZSByZWZzLCBhbmQgYm90aCBtdXN0IGJlIHNldCBiZWZvcmUKKwkJICogZXhlY3V0aW5nIHRoZSBjYWxsYmFjayBvbiB0aGlzIGNwdS4KKwkJICovCisKKwkJaWYgKCFjcHVtYXNrX3Rlc3RfY3B1KGNwdSwgZGF0YS0+Y3B1bWFzaykpCiAJCQljb250aW51ZTsKIAorCQlzbXBfcm1iKCk7CisKKwkJaWYgKGF0b21pY19yZWFkKCZkYXRhLT5yZWZzKSA9PSAwKQorCQkJY29udGludWU7CisKKwkJZnVuYyA9IGRhdGEtPmNzZC5mdW5jOwkJCS8qIGZvciBsYXRlciB3YXJuICovCiAJCWRhdGEtPmNzZC5mdW5jKGRhdGEtPmNzZC5pbmZvKTsKIAorCQkvKgorCQkgKiBJZiB0aGUgY3B1IG1hc2sgaXMgbm90IHN0aWxsIHNldCB0aGVuIGl0IGVuYWJsZWQgaW50ZXJydXB0cywKKwkJICogd2UgdG9vayBhbm90aGVyIHNtcCBpbnRlcnJ1cHQsIGFuZCBleGVjdXRlZCB0aGUgZnVuY3Rpb24KKwkJICogdHdpY2Ugb24gdGhpcyBjcHUuICBJbiB0aGVvcnkgdGhhdCBjb3B5IGRlY3JlbWVudGVkIHJlZnMuCisJCSAqLworCQlpZiAoIWNwdW1hc2tfdGVzdF9hbmRfY2xlYXJfY3B1KGNwdSwgZGF0YS0+Y3B1bWFzaykpIHsKKwkJCVdBUk4oMSwgIiVwUyBlbmFibGVkIGludGVycnVwdHMgYW5kIGRvdWJsZSBleGVjdXRlZFxuIiwKKwkJCSAgICAgZnVuYyk7CisJCQljb250aW51ZTsKKwkJfQorCiAJCXJlZnMgPSBhdG9taWNfZGVjX3JldHVybigmZGF0YS0+cmVmcyk7CiAJCVdBUk5fT04ocmVmcyA8IDApOwotCQlpZiAoIXJlZnMpIHsKLQkJCXJhd19zcGluX2xvY2soJmNhbGxfZnVuY3Rpb24ubG9jayk7Ci0JCQlsaXN0X2RlbF9yY3UoJmRhdGEtPmNzZC5saXN0KTsKLQkJCXJhd19zcGluX3VubG9jaygmY2FsbF9mdW5jdGlvbi5sb2NrKTsKLQkJfQogCiAJCWlmIChyZWZzKQogCQkJY29udGludWU7CiAKKwkJV0FSTl9PTighY3B1bWFza19lbXB0eShkYXRhLT5jcHVtYXNrKSk7CisKKwkJcmF3X3NwaW5fbG9jaygmY2FsbF9mdW5jdGlvbi5sb2NrKTsKKwkJbGlzdF9kZWxfcmN1KCZkYXRhLT5jc2QubGlzdCk7CisJCXJhd19zcGluX3VubG9jaygmY2FsbF9mdW5jdGlvbi5sb2NrKTsKKwogCQljc2RfdW5sb2NrKCZkYXRhLT5jc2QpOwogCX0KIApAQCAtNDMwLDcgKzQ1OSw3IEBACiAJICogY2FuJ3QgaGFwcGVuLgogCSAqLwogCVdBUk5fT05fT05DRShjcHVfb25saW5lKHRoaXNfY3B1KSAmJiBpcnFzX2Rpc2FibGVkKCkKLQkJICAgICAmJiAhb29wc19pbl9wcm9ncmVzcyk7CisJCSAgICAgJiYgIW9vcHNfaW5fcHJvZ3Jlc3MgJiYgIWVhcmx5X2Jvb3RfaXJxc19kaXNhYmxlZCk7CiAKIAkvKiBTbywgd2hhdCdzIGEgQ1BVIHRoZXkgd2FudD8gSWdub3JpbmcgdGhpcyBvbmUuICovCiAJY3B1ID0gY3B1bWFza19maXJzdF9hbmQobWFzaywgY3B1X29ubGluZV9tYXNrKTsKQEAgLTQ1NCwxMSArNDgzLDIxIEBACiAKIAlkYXRhID0gJl9fZ2V0X2NwdV92YXIoY2ZkX2RhdGEpOwogCWNzZF9sb2NrKCZkYXRhLT5jc2QpOworCUJVR19PTihhdG9taWNfcmVhZCgmZGF0YS0+cmVmcykgfHwgIWNwdW1hc2tfZW1wdHkoZGF0YS0+Y3B1bWFzaykpOwogCiAJZGF0YS0+Y3NkLmZ1bmMgPSBmdW5jOwogCWRhdGEtPmNzZC5pbmZvID0gaW5mbzsKIAljcHVtYXNrX2FuZChkYXRhLT5jcHVtYXNrLCBtYXNrLCBjcHVfb25saW5lX21hc2spOwogCWNwdW1hc2tfY2xlYXJfY3B1KHRoaXNfY3B1LCBkYXRhLT5jcHVtYXNrKTsKKworCS8qCisJICogVG8gZW5zdXJlIHRoZSBpbnRlcnJ1cHQgaGFuZGxlciBnZXRzIGFuIGNvbXBsZXRlIHZpZXcKKwkgKiB3ZSBvcmRlciB0aGUgY3B1bWFzayBhbmQgcmVmcyB3cml0ZXMgYW5kIG9yZGVyIHRoZSByZWFkCisJICogb2YgdGhlbSBpbiB0aGUgaW50ZXJydXB0IGhhbmRsZXIuICBJbiBhZGRpdGlvbiB3ZSBtYXkKKwkgKiBvbmx5IGNsZWFyIG91ciBvd24gY3B1IGJpdCBmcm9tIHRoZSBtYXNrLgorCSAqLworCXNtcF93bWIoKTsKKwogCWF0b21pY19zZXQoJmRhdGEtPnJlZnMsIGNwdW1hc2tfd2VpZ2h0KGRhdGEtPmNwdW1hc2spKTsKIAogCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmY2FsbF9mdW5jdGlvbi5sb2NrLCBmbGFncyk7CkBAIC01MzMsMTcgKzU3MiwyMCBAQAogI2VuZGlmIC8qIFVTRV9HRU5FUklDX1NNUF9IRUxQRVJTICovCiAKIC8qCi0gKiBDYWxsIGEgZnVuY3Rpb24gb24gYWxsIHByb2Nlc3NvcnMKKyAqIENhbGwgYSBmdW5jdGlvbiBvbiBhbGwgcHJvY2Vzc29ycy4gIE1heSBiZSB1c2VkIGR1cmluZyBlYXJseSBib290IHdoaWxlCisgKiBlYXJseV9ib290X2lycXNfZGlzYWJsZWQgaXMgc2V0LiAgVXNlIGxvY2FsX2lycV9zYXZlL3Jlc3RvcmUoKSBpbnN0ZWFkCisgKiBvZiBsb2NhbF9pcnFfZGlzYWJsZS9lbmFibGUoKS4KICAqLwogaW50IG9uX2VhY2hfY3B1KHZvaWQgKCpmdW5jKSAodm9pZCAqaW5mbyksIHZvaWQgKmluZm8sIGludCB3YWl0KQogeworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJaW50IHJldCA9IDA7CiAKIAlwcmVlbXB0X2Rpc2FibGUoKTsKIAlyZXQgPSBzbXBfY2FsbF9mdW5jdGlvbihmdW5jLCBpbmZvLCB3YWl0KTsKLQlsb2NhbF9pcnFfZGlzYWJsZSgpOworCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKIAlmdW5jKGluZm8pOwotCWxvY2FsX2lycV9lbmFibGUoKTsKKwlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CiAJcHJlZW1wdF9lbmFibGUoKTsKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0tZ2l0IGEva2VybmVsL3NyY3UuYyBiL2tlcm5lbC9zcmN1LmMKaW5kZXggOThkOGMxZS4uNzNjZTIzZiAxMDA2NDQKLS0tIGEva2VybmVsL3NyY3UuYworKysgYi9rZXJuZWwvc3JjdS5jCkBAIC0xNTYsNiArMTU2LDE2IEBACiBFWFBPUlRfU1lNQk9MX0dQTChfX3NyY3VfcmVhZF91bmxvY2spOwogCiAvKgorICogV2UgdXNlIGFuIGFkYXB0aXZlIHN0cmF0ZWd5IGZvciBzeW5jaHJvbml6ZV9zcmN1KCkgYW5kIGVzcGVjaWFsbHkgZm9yCisgKiBzeW5jaHJvbml6ZV9zcmN1X2V4cGVkaXRlZCgpLiAgV2Ugc3BpbiBmb3IgYSBmaXhlZCB0aW1lIHBlcmlvZAorICogKGRlZmluZWQgYmVsb3cpIHRvIGFsbG93IFNSQ1UgcmVhZGVycyB0byBleGl0IHRoZWlyIHJlYWQtc2lkZSBjcml0aWNhbAorICogc2VjdGlvbnMuICBJZiB0aGVyZSBhcmUgc3RpbGwgc29tZSByZWFkZXJzIGFmdGVyIDEwIG1pY3Jvc2Vjb25kcywKKyAqIHdlIHJlcGVhdGVkbHkgYmxvY2sgZm9yIDEtbWlsbGlzZWNvbmQgdGltZSBwZXJpb2RzLiAgVGhpcyBhcHByb2FjaAorICogaGFzIGRvbmUgd2VsbCBpbiB0ZXN0aW5nLCBzbyB0aGVyZSBpcyBubyBuZWVkIGZvciBhIGNvbmZpZyBwYXJhbWV0ZXIuCisgKi8KKyNkZWZpbmUgU1lOQ0hST05JWkVfU1JDVV9SRUFERVJfREVMQVkgMTAKKworLyoKICAqIEhlbHBlciBmdW5jdGlvbiBmb3Igc3luY2hyb25pemVfc3JjdSgpIGFuZCBzeW5jaHJvbml6ZV9zcmN1X2V4cGVkaXRlZCgpLgogICovCiBzdGF0aWMgdm9pZCBfX3N5bmNocm9uaXplX3NyY3Uoc3RydWN0IHNyY3Vfc3RydWN0ICpzcCwgdm9pZCAoKnN5bmNfZnVuYykodm9pZCkpCkBAIC0yMDcsMTEgKzIxNywxMiBAQAogCSAqIHdpbGwgaGF2ZSBmaW5pc2hlZCBleGVjdXRpbmcuICBXZSBpbml0aWFsbHkgZ2l2ZSByZWFkZXJzCiAJICogYW4gYXJiaXRyYXJpbHkgY2hvc2VuIDEwIG1pY3Jvc2Vjb25kcyB0byBnZXQgb3V0IG9mIHRoZWlyCiAJICogU1JDVSByZWFkLXNpZGUgY3JpdGljYWwgc2VjdGlvbnMsIHRoZW4gbG9vcCB3YWl0aW5nIDEvSFoKLQkgKiBzZWNvbmRzIHBlciBpdGVyYXRpb24uCisJICogc2Vjb25kcyBwZXIgaXRlcmF0aW9uLiAgVGhlIDEwLW1pY3Jvc2Vjb25kIHZhbHVlIGhhcyBkb25lCisJICogdmVyeSB3ZWxsIGluIHRlc3RpbmcuCiAJICovCiAKIAlpZiAoc3JjdV9yZWFkZXJzX2FjdGl2ZV9pZHgoc3AsIGlkeCkpCi0JCXVkZWxheShDT05GSUdfU1JDVV9TWU5DSFJPTklaRV9ERUxBWSk7CisJCXVkZWxheShTWU5DSFJPTklaRV9TUkNVX1JFQURFUl9ERUxBWSk7CiAJd2hpbGUgKHNyY3VfcmVhZGVyc19hY3RpdmVfaWR4KHNwLCBpZHgpKQogCQlzY2hlZHVsZV90aW1lb3V0X2ludGVycnVwdGlibGUoMSk7CiAKZGlmZiAtLWdpdCBhL2tlcm5lbC9zeXMuYyBiL2tlcm5lbC9zeXMuYwppbmRleCAzMWI3MWEyLi4xOGRhNzAyIDEwMDY0NAotLS0gYS9rZXJuZWwvc3lzLmMKKysrIGIva2VybmVsL3N5cy5jCkBAIC0xMzg1LDcgKzEzODUsOCBAQAogCWNvbnN0IHN0cnVjdCBjcmVkICpjcmVkID0gY3VycmVudF9jcmVkKCksICp0Y3JlZDsKIAogCXRjcmVkID0gX190YXNrX2NyZWQodGFzayk7Ci0JaWYgKChjcmVkLT51aWQgIT0gdGNyZWQtPmV1aWQgfHwKKwlpZiAoY3VycmVudCAhPSB0YXNrICYmCisJICAgIChjcmVkLT51aWQgIT0gdGNyZWQtPmV1aWQgfHwKIAkgICAgIGNyZWQtPnVpZCAhPSB0Y3JlZC0+c3VpZCB8fAogCSAgICAgY3JlZC0+dWlkICE9IHRjcmVkLT51aWQgIHx8CiAJICAgICBjcmVkLT5naWQgIT0gdGNyZWQtPmVnaWQgfHwKZGlmZiAtLWdpdCBhL2tlcm5lbC9zeXNjdGwuYyBiL2tlcm5lbC9zeXNjdGwuYwppbmRleCBiYzg2YmIzLi4wZjFiZDgzIDEwMDY0NAotLS0gYS9rZXJuZWwvc3lzY3RsLmMKKysrIGIva2VybmVsL3N5c2N0bC5jCkBAIC0xNzAsNyArMTcwLDggQEAKICNlbmRpZgogCiAjaWZkZWYgQ09ORklHX01BR0lDX1NZU1JRCi1zdGF0aWMgaW50IF9fc3lzcnFfZW5hYmxlZDsgLyogTm90ZTogc3lzcnEgY29kZSBpc2VzIGl0J3Mgb3duIHByaXZhdGUgY29weSAqLworLyogTm90ZTogc3lzcnEgY29kZSB1c2VzIGl0J3Mgb3duIHByaXZhdGUgY29weSAqLworc3RhdGljIGludCBfX3N5c3JxX2VuYWJsZWQgPSBTWVNSUV9ERUZBVUxUX0VOQUJMRTsKIAogc3RhdGljIGludCBzeXNycV9zeXNjdGxfaGFuZGxlcihjdGxfdGFibGUgKnRhYmxlLCBpbnQgd3JpdGUsCiAJCQkJdm9pZCBfX3VzZXIgKmJ1ZmZlciwgc2l6ZV90ICpsZW5wLApkaWZmIC0tZ2l0IGEva2VybmVsL3RpbWUvY2xvY2tzb3VyY2UuYyBiL2tlcm5lbC90aW1lL2Nsb2Nrc291cmNlLmMKaW5kZXggYzUwYTAzNC4uNjUxOWNmNjIgMTAwNjQ0Ci0tLSBhL2tlcm5lbC90aW1lL2Nsb2Nrc291cmNlLmMKKysrIGIva2VybmVsL3RpbWUvY2xvY2tzb3VyY2UuYwpAQCAtMTEzLDcgKzExMyw3IEBACiAgKiBAc2hpZnQ6CXBvaW50ZXIgdG8gc2hpZnQgdmFyaWFibGUKICAqIEBmcm9tOglmcmVxdWVuY3kgdG8gY29udmVydCBmcm9tCiAgKiBAdG86CQlmcmVxdWVuY3kgdG8gY29udmVydCB0bwotICogQG1pbnNlYzoJZ3VhcmFudGVlZCBydW50aW1lIGNvbnZlcnNpb24gcmFuZ2UgaW4gc2Vjb25kcworICogQG1heHNlYzoJZ3VhcmFudGVlZCBydW50aW1lIGNvbnZlcnNpb24gcmFuZ2UgaW4gc2Vjb25kcwogICoKICAqIFRoZSBmdW5jdGlvbiBldmFsdWF0ZXMgdGhlIHNoaWZ0L211bHQgcGFpciBmb3IgdGhlIHNjYWxlZCBtYXRoCiAgKiBvcGVyYXRpb25zIG9mIGNsb2Nrc291cmNlcyBhbmQgY2xvY2tldmVudHMuCkBAIC0xMjIsNyArMTIyLDcgQEAKICAqIE5TRUNfUEVSX1NFQyA9PSAxR0h6IGFuZCBAZnJvbSBpcyB0aGUgY291bnRlciBmcmVxdWVuY3kuIEZvciBjbG9jawogICogZXZlbnQgQHRvIGlzIHRoZSBjb3VudGVyIGZyZXF1ZW5jeSBhbmQgQGZyb20gaXMgTlNFQ19QRVJfU0VDLgogICoKLSAqIFRoZSBAbWluc2VjIGNvbnZlcnNpb24gcmFuZ2UgYXJndW1lbnQgY29udHJvbHMgdGhlIHRpbWUgZnJhbWUgaW4KKyAqIFRoZSBAbWF4c2VjIGNvbnZlcnNpb24gcmFuZ2UgYXJndW1lbnQgY29udHJvbHMgdGhlIHRpbWUgZnJhbWUgaW4KICAqIHNlY29uZHMgd2hpY2ggbXVzdCBiZSBjb3ZlcmVkIGJ5IHRoZSBydW50aW1lIGNvbnZlcnNpb24gd2l0aCB0aGUKICAqIGNhbGN1bGF0ZWQgbXVsdCBhbmQgc2hpZnQgZmFjdG9ycy4gVGhpcyBndWFyYW50ZWVzIHRoYXQgbm8gNjRiaXQKICAqIG92ZXJmbG93IGhhcHBlbnMgd2hlbiB0aGUgaW5wdXQgdmFsdWUgb2YgdGhlIGNvbnZlcnNpb24gaXMKQEAgLTEzMSw3ICsxMzEsNyBAQAogICogZmFjdG9ycy4KICAqLwogdm9pZAotY2xvY2tzX2NhbGNfbXVsdF9zaGlmdCh1MzIgKm11bHQsIHUzMiAqc2hpZnQsIHUzMiBmcm9tLCB1MzIgdG8sIHUzMiBtaW5zZWMpCitjbG9ja3NfY2FsY19tdWx0X3NoaWZ0KHUzMiAqbXVsdCwgdTMyICpzaGlmdCwgdTMyIGZyb20sIHUzMiB0bywgdTMyIG1heHNlYykKIHsKIAl1NjQgdG1wOwogCXUzMiBzZnQsIHNmdGFjYz0gMzI7CkBAIC0xNDAsNyArMTQwLDcgQEAKIAkgKiBDYWxjdWxhdGUgdGhlIHNoaWZ0IGZhY3RvciB3aGljaCBpcyBsaW1pdGluZyB0aGUgY29udmVyc2lvbgogCSAqIHJhbmdlOgogCSAqLwotCXRtcCA9ICgodTY0KW1pbnNlYyAqIGZyb20pID4+IDMyOworCXRtcCA9ICgodTY0KW1heHNlYyAqIGZyb20pID4+IDMyOwogCXdoaWxlICh0bXApIHsKIAkJdG1wID4+PTE7CiAJCXNmdGFjYy0tOwpkaWZmIC0tZ2l0IGEva2VybmVsL3RpbWUvdGljay1zY2hlZC5jIGIva2VybmVsL3RpbWUvdGljay1zY2hlZC5jCmluZGV4IDNlMjE2ZTAuLmM1NWVhMjQgMTAwNjQ0Ci0tLSBhL2tlcm5lbC90aW1lL3RpY2stc2NoZWQuYworKysgYi9rZXJuZWwvdGltZS90aWNrLXNjaGVkLmMKQEAgLTY0Miw4ICs2NDIsNyBAQAogCX0KIAlsb2NhbF9pcnFfZW5hYmxlKCk7CiAKLQlwcmludGsoS0VSTl9JTkZPICJTd2l0Y2hlZCB0byBOT0h6IG1vZGUgb24gQ1BVICMlZFxuIiwKLQkgICAgICAgc21wX3Byb2Nlc3Nvcl9pZCgpKTsKKwlwcmludGsoS0VSTl9JTkZPICJTd2l0Y2hlZCB0byBOT0h6IG1vZGUgb24gQ1BVICMlZFxuIiwgc21wX3Byb2Nlc3Nvcl9pZCgpKTsKIH0KIAogLyoKQEAgLTc5NSw4ICs3OTQsMTAgQEAKIAl9CiAKICNpZmRlZiBDT05GSUdfTk9fSFoKLQlpZiAodGlja19ub2h6X2VuYWJsZWQpCisJaWYgKHRpY2tfbm9oel9lbmFibGVkKSB7CiAJCXRzLT5ub2h6X21vZGUgPSBOT0haX01PREVfSElHSFJFUzsKKwkJcHJpbnRrKEtFUk5fSU5GTyAiU3dpdGNoZWQgdG8gTk9IeiBtb2RlIG9uIENQVSAjJWRcbiIsIHNtcF9wcm9jZXNzb3JfaWQoKSk7CisJfQogI2VuZGlmCiB9CiAjZW5kaWYgLyogSElHSF9SRVNfVElNRVJTICovCmRpZmYgLS1naXQgYS9rZXJuZWwvdGltZS90aW1la2VlcGluZy5jIGIva2VybmVsL3RpbWUvdGltZWtlZXBpbmcuYwppbmRleCA1NTM2YWFmLi5kMjdjNzU2IDEwMDY0NAotLS0gYS9rZXJuZWwvdGltZS90aW1la2VlcGluZy5jCisrKyBiL2tlcm5lbC90aW1lL3RpbWVrZWVwaW5nLmMKQEAgLTQ5LDcgKzQ5LDcgQEAKIAl1MzIJbXVsdDsKIH07CiAKLXN0cnVjdCB0aW1la2VlcGVyIHRpbWVrZWVwZXI7CitzdGF0aWMgc3RydWN0IHRpbWVrZWVwZXIgdGltZWtlZXBlcjsKIAogLyoqCiAgKiB0aW1la2VlcGVyX3NldHVwX2ludGVybmFscyAtIFNldCB1cCBpbnRlcm5hbHMgdG8gdXNlIGNsb2Nrc291cmNlIGNsb2NrLgpAQCAtMTY0LDcgKzE2NCw3IEBACiAvKgogICogVGhlIHJhdyBtb25vdG9uaWMgdGltZSBmb3IgdGhlIENMT0NLX01PTk9UT05JQ19SQVcgcG9zaXggY2xvY2suCiAgKi8KLXN0cnVjdCB0aW1lc3BlYyByYXdfdGltZTsKK3N0YXRpYyBzdHJ1Y3QgdGltZXNwZWMgcmF3X3RpbWU7CiAKIC8qIGZsYWcgZm9yIGlmIHRpbWVrZWVwaW5nIGlzIHN1c3BlbmRlZCAqLwogaW50IF9fcmVhZF9tb3N0bHkgdGltZWtlZXBpbmdfc3VzcGVuZGVkOwpkaWZmIC0tZ2l0IGEva2VybmVsL3RpbWVyLmMgYi9rZXJuZWwvdGltZXIuYwppbmRleCA0M2NhOTkzLi5kNTNjZTY2IDEwMDY0NAotLS0gYS9rZXJuZWwvdGltZXIuYworKysgYi9rZXJuZWwvdGltZXIuYwpAQCAtOTY5LDEwICs5NjksMTQgQEAKIGludCBkZWxfdGltZXJfc3luYyhzdHJ1Y3QgdGltZXJfbGlzdCAqdGltZXIpCiB7CiAjaWZkZWYgQ09ORklHX0xPQ0tERVAKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJcmF3X2xvY2FsX2lycV9zYXZlKGZsYWdzKTsKIAlsb2NhbF9iaF9kaXNhYmxlKCk7CiAJbG9ja19tYXBfYWNxdWlyZSgmdGltZXItPmxvY2tkZXBfbWFwKTsKIAlsb2NrX21hcF9yZWxlYXNlKCZ0aW1lci0+bG9ja2RlcF9tYXApOwotCWxvY2FsX2JoX2VuYWJsZSgpOworCV9sb2NhbF9iaF9lbmFibGUoKTsKKwlyYXdfbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogI2VuZGlmCiAJLyoKIAkgKiBkb24ndCB1c2UgaXQgaW4gaGFyZGlycSBjb250ZXh0LCBiZWNhdXNlIGl0CmRpZmYgLS1naXQgYS9rZXJuZWwvdHJhY2UvYmxrdHJhY2UuYyBiL2tlcm5lbC90cmFjZS9ibGt0cmFjZS5jCmluZGV4IDE1MzU2MmQuLmQ5NTcyMWYgMTAwNjQ0Ci0tLSBhL2tlcm5lbC90cmFjZS9ibGt0cmFjZS5jCisrKyBiL2tlcm5lbC90cmFjZS9ibGt0cmFjZS5jCkBAIC0xMzgsNiArMTM4LDEzIEBACiAJCSAgICAgIWJsa190cmFjZXJfZW5hYmxlZCkpCiAJCXJldHVybjsKIAorCS8qCisJICogSWYgdGhlIEJMS19UQ19OT1RJRlkgYWN0aW9uIG1hc2sgaXNuJ3Qgc2V0LCBkb24ndCBzZW5kIGFueSBub3RlCisJICogbWVzc2FnZSB0byB0aGUgdHJhY2UuCisJICovCisJaWYgKCEoYnQtPmFjdF9tYXNrICYgQkxLX1RDX05PVElGWSkpCisJCXJldHVybjsKKwogCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKIAlidWYgPSBwZXJfY3B1X3B0cihidC0+bXNnX2RhdGEsIHNtcF9wcm9jZXNzb3JfaWQoKSk7CiAJdmFfc3RhcnQoYXJncywgZm10KTsKZGlmZiAtLWdpdCBhL2tlcm5lbC90cmFjZS90cmFjZV9ldmVudHMuYyBiL2tlcm5lbC90cmFjZS90cmFjZV9ldmVudHMuYwppbmRleCAzNWZkZTA5Li41ZjQ5OWUwNCAxMDA2NDQKLS0tIGEva2VybmVsL3RyYWNlL3RyYWNlX2V2ZW50cy5jCisrKyBiL2tlcm5lbC90cmFjZS90cmFjZV9ldmVudHMuYwpAQCAtMTI4NCw3ICsxMjg0LDcgQEAKIHN0YXRpYyB2b2lkIHRyYWNlX21vZHVsZV9hZGRfZXZlbnRzKHN0cnVjdCBtb2R1bGUgKm1vZCkKIHsKIAlzdHJ1Y3QgZnRyYWNlX21vZHVsZV9maWxlX29wcyAqZmlsZV9vcHMgPSBOVUxMOwotCXN0cnVjdCBmdHJhY2VfZXZlbnRfY2FsbCAqY2FsbCwgKnN0YXJ0LCAqZW5kOworCXN0cnVjdCBmdHJhY2VfZXZlbnRfY2FsbCAqKmNhbGwsICoqc3RhcnQsICoqZW5kOwogCiAJc3RhcnQgPSBtb2QtPnRyYWNlX2V2ZW50czsKIAllbmQgPSBtb2QtPnRyYWNlX2V2ZW50cyArIG1vZC0+bnVtX3RyYWNlX2V2ZW50czsKQEAgLTEyOTcsNyArMTI5Nyw3IEBACiAJCXJldHVybjsKIAogCWZvcl9lYWNoX2V2ZW50KGNhbGwsIHN0YXJ0LCBlbmQpIHsKLQkJX190cmFjZV9hZGRfZXZlbnRfY2FsbChjYWxsLCBtb2QsCisJCV9fdHJhY2VfYWRkX2V2ZW50X2NhbGwoKmNhbGwsIG1vZCwKIAkJCQkgICAgICAgJmZpbGVfb3BzLT5pZCwgJmZpbGVfb3BzLT5lbmFibGUsCiAJCQkJICAgICAgICZmaWxlX29wcy0+ZmlsdGVyLCAmZmlsZV9vcHMtPmZvcm1hdCk7CiAJfQpAQCAtMTM2Nyw4ICsxMzY3LDggQEAKIAkucHJpb3JpdHkgPSAwLAogfTsKIAotZXh0ZXJuIHN0cnVjdCBmdHJhY2VfZXZlbnRfY2FsbCBfX3N0YXJ0X2Z0cmFjZV9ldmVudHNbXTsKLWV4dGVybiBzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgX19zdG9wX2Z0cmFjZV9ldmVudHNbXTsKK2V4dGVybiBzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgKl9fc3RhcnRfZnRyYWNlX2V2ZW50c1tdOworZXh0ZXJuIHN0cnVjdCBmdHJhY2VfZXZlbnRfY2FsbCAqX19zdG9wX2Z0cmFjZV9ldmVudHNbXTsKIAogc3RhdGljIGNoYXIgYm9vdHVwX2V2ZW50X2J1ZltDT01NQU5EX0xJTkVfU0laRV0gX19pbml0ZGF0YTsKIApAQCAtMTM4NCw3ICsxMzg0LDcgQEAKIAogc3RhdGljIF9faW5pdCBpbnQgZXZlbnRfdHJhY2VfaW5pdCh2b2lkKQogewotCXN0cnVjdCBmdHJhY2VfZXZlbnRfY2FsbCAqY2FsbDsKKwlzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgKipjYWxsOwogCXN0cnVjdCBkZW50cnkgKmRfdHJhY2VyOwogCXN0cnVjdCBkZW50cnkgKmVudHJ5OwogCXN0cnVjdCBkZW50cnkgKmRfZXZlbnRzOwpAQCAtMTQzMCw3ICsxNDMwLDcgQEAKIAkJcHJfd2FybmluZygidHJhY2luZzogRmFpbGVkIHRvIGFsbG9jYXRlIGNvbW1vbiBmaWVsZHMiKTsKIAogCWZvcl9lYWNoX2V2ZW50KGNhbGwsIF9fc3RhcnRfZnRyYWNlX2V2ZW50cywgX19zdG9wX2Z0cmFjZV9ldmVudHMpIHsKLQkJX190cmFjZV9hZGRfZXZlbnRfY2FsbChjYWxsLCBOVUxMLCAmZnRyYWNlX2V2ZW50X2lkX2ZvcHMsCisJCV9fdHJhY2VfYWRkX2V2ZW50X2NhbGwoKmNhbGwsIE5VTEwsICZmdHJhY2VfZXZlbnRfaWRfZm9wcywKIAkJCQkgICAgICAgJmZ0cmFjZV9lbmFibGVfZm9wcywKIAkJCQkgICAgICAgJmZ0cmFjZV9ldmVudF9maWx0ZXJfZm9wcywKIAkJCQkgICAgICAgJmZ0cmFjZV9ldmVudF9mb3JtYXRfZm9wcyk7CmRpZmYgLS1naXQgYS9rZXJuZWwvdHJhY2UvdHJhY2VfZXhwb3J0LmMgYi9rZXJuZWwvdHJhY2UvdHJhY2VfZXhwb3J0LmMKaW5kZXggNGI3NGQ3MS4uYmJlZWMzMSAxMDA2NDQKLS0tIGEva2VybmVsL3RyYWNlL3RyYWNlX2V4cG9ydC5jCisrKyBiL2tlcm5lbC90cmFjZS90cmFjZV9leHBvcnQuYwpAQCAtMTYxLDEzICsxNjEsMTMgQEAKIAkuZmllbGRzCQkJPSBMSVNUX0hFQURfSU5JVChldmVudF9jbGFzc19mdHJhY2VfIyNjYWxsLmZpZWxkcyksXAogfTsJCQkJCQkJCQlcCiAJCQkJCQkJCQlcCi1zdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgX191c2VkCQkJCQkJXAotX19hdHRyaWJ1dGVfXygoX19hbGlnbmVkX18oNCkpKQkJCQkJCVwKLV9fYXR0cmlidXRlX18oKHNlY3Rpb24oIl9mdHJhY2VfZXZlbnRzIikpKSBldmVudF8jI2NhbGwgPSB7CQlcCitzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgX191c2VkIGV2ZW50XyMjY2FsbCA9IHsJCQlcCiAJLm5hbWUJCQk9ICNjYWxsLAkJCQlcCiAJLmV2ZW50LnR5cGUJCT0gZXR5cGUsCQkJCVwKIAkuY2xhc3MJCQk9ICZldmVudF9jbGFzc19mdHJhY2VfIyNjYWxsLAkJXAogCS5wcmludF9mbXQJCT0gcHJpbnQsCQkJCVwKIH07CQkJCQkJCQkJXAorc3RydWN0IGZ0cmFjZV9ldmVudF9jYWxsIF9fdXNlZAkJCQkJCVwKK19fYXR0cmlidXRlX18oKHNlY3Rpb24oIl9mdHJhY2VfZXZlbnRzIikpKSAqX19ldmVudF8jI2NhbGwgPSAmZXZlbnRfIyNjYWxsOwogCiAjaW5jbHVkZSAidHJhY2VfZW50cmllcy5oIgpkaWZmIC0tZ2l0IGEva2VybmVsL3RyYWNlL3RyYWNlX2lycXNvZmYuYyBiL2tlcm5lbC90cmFjZS90cmFjZV9pcnFzb2ZmLmMKaW5kZXggNWNmOGM2MC4uOTJiNmUxZSAxMDA2NDQKLS0tIGEva2VybmVsL3RyYWNlL3RyYWNlX2lycXNvZmYuYworKysgYi9rZXJuZWwvdHJhY2UvdHJhY2VfaXJxc29mZi5jCkBAIC00NTMsMTQgKzQ1Myw2IEBACiAgKiBTdHViczoKICAqLwogCi12b2lkIGVhcmx5X2Jvb3RfaXJxc19vZmYodm9pZCkKLXsKLX0KLQotdm9pZCBlYXJseV9ib290X2lycXNfb24odm9pZCkKLXsKLX0KLQogdm9pZCB0cmFjZV9zb2Z0aXJxc19vbih1bnNpZ25lZCBsb25nIGlwKQogewogfQpkaWZmIC0tZ2l0IGEva2VybmVsL3RyYWNlL3RyYWNlX3N5c2NhbGxzLmMgYi9rZXJuZWwvdHJhY2UvdHJhY2Vfc3lzY2FsbHMuYwppbmRleCBiYWM3NTJmLi41YzlmZTA4IDEwMDY0NAotLS0gYS9rZXJuZWwvdHJhY2UvdHJhY2Vfc3lzY2FsbHMuYworKysgYi9rZXJuZWwvdHJhY2UvdHJhY2Vfc3lzY2FsbHMuYwpAQCAtMjMsOSArMjMsNiBAQAogc3RhdGljIGludCBzeXNjYWxsX2VudGVyX2RlZmluZV9maWVsZHMoc3RydWN0IGZ0cmFjZV9ldmVudF9jYWxsICpjYWxsKTsKIHN0YXRpYyBpbnQgc3lzY2FsbF9leGl0X2RlZmluZV9maWVsZHMoc3RydWN0IGZ0cmFjZV9ldmVudF9jYWxsICpjYWxsKTsKIAotLyogQWxsIHN5c2NhbGwgZXhpdCBldmVudHMgaGF2ZSB0aGUgc2FtZSBmaWVsZHMgKi8KLXN0YXRpYyBMSVNUX0hFQUQoc3lzY2FsbF9leGl0X2ZpZWxkcyk7Ci0KIHN0YXRpYyBzdHJ1Y3QgbGlzdF9oZWFkICoKIHN5c2NhbGxfZ2V0X2VudGVyX2ZpZWxkcyhzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NhbGwgKmNhbGwpCiB7CkBAIC0zNCw1MCArMzEsNDUgQEAKIAlyZXR1cm4gJmVudHJ5LT5lbnRlcl9maWVsZHM7CiB9CiAKLXN0YXRpYyBzdHJ1Y3QgbGlzdF9oZWFkICoKLXN5c2NhbGxfZ2V0X2V4aXRfZmllbGRzKHN0cnVjdCBmdHJhY2VfZXZlbnRfY2FsbCAqY2FsbCkKLXsKLQlyZXR1cm4gJnN5c2NhbGxfZXhpdF9maWVsZHM7Ci19Ci0KIHN0cnVjdCB0cmFjZV9ldmVudF9mdW5jdGlvbnMgZW50ZXJfc3lzY2FsbF9wcmludF9mdW5jcyA9IHsKLQkudHJhY2UgICAgICAgICAgICAgICAgICA9IHByaW50X3N5c2NhbGxfZW50ZXIsCisJLnRyYWNlCQk9IHByaW50X3N5c2NhbGxfZW50ZXIsCiB9OwogCiBzdHJ1Y3QgdHJhY2VfZXZlbnRfZnVuY3Rpb25zIGV4aXRfc3lzY2FsbF9wcmludF9mdW5jcyA9IHsKLQkudHJhY2UgICAgICAgICAgICAgICAgICA9IHByaW50X3N5c2NhbGxfZXhpdCwKKwkudHJhY2UJCT0gcHJpbnRfc3lzY2FsbF9leGl0LAogfTsKIAogc3RydWN0IGZ0cmFjZV9ldmVudF9jbGFzcyBldmVudF9jbGFzc19zeXNjYWxsX2VudGVyID0gewotCS5zeXN0ZW0JCQk9ICJzeXNjYWxscyIsCi0JLnJlZwkJCT0gc3lzY2FsbF9lbnRlcl9yZWdpc3RlciwKLQkuZGVmaW5lX2ZpZWxkcwkJPSBzeXNjYWxsX2VudGVyX2RlZmluZV9maWVsZHMsCi0JLmdldF9maWVsZHMJCT0gc3lzY2FsbF9nZXRfZW50ZXJfZmllbGRzLAotCS5yYXdfaW5pdAkJPSBpbml0X3N5c2NhbGxfdHJhY2UsCisJLnN5c3RlbQkJPSAic3lzY2FsbHMiLAorCS5yZWcJCT0gc3lzY2FsbF9lbnRlcl9yZWdpc3RlciwKKwkuZGVmaW5lX2ZpZWxkcwk9IHN5c2NhbGxfZW50ZXJfZGVmaW5lX2ZpZWxkcywKKwkuZ2V0X2ZpZWxkcwk9IHN5c2NhbGxfZ2V0X2VudGVyX2ZpZWxkcywKKwkucmF3X2luaXQJPSBpbml0X3N5c2NhbGxfdHJhY2UsCiB9OwogCiBzdHJ1Y3QgZnRyYWNlX2V2ZW50X2NsYXNzIGV2ZW50X2NsYXNzX3N5c2NhbGxfZXhpdCA9IHsKLQkuc3lzdGVtCQkJPSAic3lzY2FsbHMiLAotCS5yZWcJCQk9IHN5c2NhbGxfZXhpdF9yZWdpc3RlciwKLQkuZGVmaW5lX2ZpZWxkcwkJPSBzeXNjYWxsX2V4aXRfZGVmaW5lX2ZpZWxkcywKLQkuZ2V0X2ZpZWxkcwkJPSBzeXNjYWxsX2dldF9leGl0X2ZpZWxkcywKLQkucmF3X2luaXQJCT0gaW5pdF9zeXNjYWxsX3RyYWNlLAorCS5zeXN0ZW0JCT0gInN5c2NhbGxzIiwKKwkucmVnCQk9IHN5c2NhbGxfZXhpdF9yZWdpc3RlciwKKwkuZGVmaW5lX2ZpZWxkcwk9IHN5c2NhbGxfZXhpdF9kZWZpbmVfZmllbGRzLAorCS5maWVsZHMJCT0gTElTVF9IRUFEX0lOSVQoZXZlbnRfY2xhc3Nfc3lzY2FsbF9leGl0LmZpZWxkcyksCisJLnJhd19pbml0CT0gaW5pdF9zeXNjYWxsX3RyYWNlLAogfTsKIAotZXh0ZXJuIHVuc2lnbmVkIGxvbmcgX19zdGFydF9zeXNjYWxsc19tZXRhZGF0YVtdOwotZXh0ZXJuIHVuc2lnbmVkIGxvbmcgX19zdG9wX3N5c2NhbGxzX21ldGFkYXRhW107CitleHRlcm4gc3RydWN0IHN5c2NhbGxfbWV0YWRhdGEgKl9fc3RhcnRfc3lzY2FsbHNfbWV0YWRhdGFbXTsKK2V4dGVybiBzdHJ1Y3Qgc3lzY2FsbF9tZXRhZGF0YSAqX19zdG9wX3N5c2NhbGxzX21ldGFkYXRhW107CiAKIHN0YXRpYyBzdHJ1Y3Qgc3lzY2FsbF9tZXRhZGF0YSAqKnN5c2NhbGxzX21ldGFkYXRhOwogCi1zdGF0aWMgc3RydWN0IHN5c2NhbGxfbWV0YWRhdGEgKmZpbmRfc3lzY2FsbF9tZXRhKHVuc2lnbmVkIGxvbmcgc3lzY2FsbCkKK3N0YXRpYyBfX2luaXQgc3RydWN0IHN5c2NhbGxfbWV0YWRhdGEgKgorZmluZF9zeXNjYWxsX21ldGEodW5zaWduZWQgbG9uZyBzeXNjYWxsKQogewotCXN0cnVjdCBzeXNjYWxsX21ldGFkYXRhICpzdGFydDsKLQlzdHJ1Y3Qgc3lzY2FsbF9tZXRhZGF0YSAqc3RvcDsKKwlzdHJ1Y3Qgc3lzY2FsbF9tZXRhZGF0YSAqKnN0YXJ0OworCXN0cnVjdCBzeXNjYWxsX21ldGFkYXRhICoqc3RvcDsKIAljaGFyIHN0cltLU1lNX1NZTUJPTF9MRU5dOwogCiAKLQlzdGFydCA9IChzdHJ1Y3Qgc3lzY2FsbF9tZXRhZGF0YSAqKV9fc3RhcnRfc3lzY2FsbHNfbWV0YWRhdGE7Ci0Jc3RvcCA9IChzdHJ1Y3Qgc3lzY2FsbF9tZXRhZGF0YSAqKV9fc3RvcF9zeXNjYWxsc19tZXRhZGF0YTsKKwlzdGFydCA9IF9fc3RhcnRfc3lzY2FsbHNfbWV0YWRhdGE7CisJc3RvcCA9IF9fc3RvcF9zeXNjYWxsc19tZXRhZGF0YTsKIAlrYWxsc3ltc19sb29rdXAoc3lzY2FsbCwgTlVMTCwgTlVMTCwgTlVMTCwgc3RyKTsKIAogCWZvciAoIDsgc3RhcnQgPCBzdG9wOyBzdGFydCsrKSB7CkBAIC04Nyw4ICs3OSw4IEBACiAJCSAqIHdpdGggIlN5UyIgaW5zdGVhZCBvZiAic3lzIiwgbGVhZGluZyB0byBhbiB1bndhbnRlZAogCQkgKiBtaXNtYXRjaC4KIAkJICovCi0JCWlmIChzdGFydC0+bmFtZSAmJiAhc3RyY21wKHN0YXJ0LT5uYW1lICsgMywgc3RyICsgMykpCi0JCQlyZXR1cm4gc3RhcnQ7CisJCWlmICgoKnN0YXJ0KS0+bmFtZSAmJiAhc3RyY21wKCgqc3RhcnQpLT5uYW1lICsgMywgc3RyICsgMykpCisJCQlyZXR1cm4gKnN0YXJ0OwogCX0KIAlyZXR1cm4gTlVMTDsKIH0KZGlmZiAtLWdpdCBhL2tlcm5lbC90cmFjZXBvaW50LmMgYi9rZXJuZWwvdHJhY2Vwb2ludC5jCmluZGV4IGU5NWVlN2YuLjY4MTg3YWYgMTAwNjQ0Ci0tLSBhL2tlcm5lbC90cmFjZXBvaW50LmMKKysrIGIva2VybmVsL3RyYWNlcG9pbnQuYwpAQCAtMjcsOCArMjcsOCBAQAogI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvanVtcF9sYWJlbC5oPgogCi1leHRlcm4gc3RydWN0IHRyYWNlcG9pbnQgX19zdGFydF9fX3RyYWNlcG9pbnRzW107Ci1leHRlcm4gc3RydWN0IHRyYWNlcG9pbnQgX19zdG9wX19fdHJhY2Vwb2ludHNbXTsKK2V4dGVybiBzdHJ1Y3QgdHJhY2Vwb2ludCAqIGNvbnN0IF9fc3RhcnRfX190cmFjZXBvaW50c19wdHJzW107CitleHRlcm4gc3RydWN0IHRyYWNlcG9pbnQgKiBjb25zdCBfX3N0b3BfX190cmFjZXBvaW50c19wdHJzW107CiAKIC8qIFNldCB0byAxIHRvIGVuYWJsZSB0cmFjZXBvaW50IGRlYnVnIG91dHB1dCAqLwogc3RhdGljIGNvbnN0IGludCB0cmFjZXBvaW50X2RlYnVnOwpAQCAtMjk4LDEwICsyOTgsMTAgQEAKICAqCiAgKiBVcGRhdGVzIHRoZSBwcm9iZSBjYWxsYmFjayBjb3JyZXNwb25kaW5nIHRvIGEgcmFuZ2Ugb2YgdHJhY2Vwb2ludHMuCiAgKi8KLXZvaWQKLXRyYWNlcG9pbnRfdXBkYXRlX3Byb2JlX3JhbmdlKHN0cnVjdCB0cmFjZXBvaW50ICpiZWdpbiwgc3RydWN0IHRyYWNlcG9pbnQgKmVuZCkKK3ZvaWQgdHJhY2Vwb2ludF91cGRhdGVfcHJvYmVfcmFuZ2Uoc3RydWN0IHRyYWNlcG9pbnQgKiBjb25zdCAqYmVnaW4sCisJCQkJICAgc3RydWN0IHRyYWNlcG9pbnQgKiBjb25zdCAqZW5kKQogewotCXN0cnVjdCB0cmFjZXBvaW50ICppdGVyOworCXN0cnVjdCB0cmFjZXBvaW50ICogY29uc3QgKml0ZXI7CiAJc3RydWN0IHRyYWNlcG9pbnRfZW50cnkgKm1hcmtfZW50cnk7CiAKIAlpZiAoIWJlZ2luKQpAQCAtMzA5LDEyICszMDksMTIgQEAKIAogCW11dGV4X2xvY2soJnRyYWNlcG9pbnRzX211dGV4KTsKIAlmb3IgKGl0ZXIgPSBiZWdpbjsgaXRlciA8IGVuZDsgaXRlcisrKSB7Ci0JCW1hcmtfZW50cnkgPSBnZXRfdHJhY2Vwb2ludChpdGVyLT5uYW1lKTsKKwkJbWFya19lbnRyeSA9IGdldF90cmFjZXBvaW50KCgqaXRlciktPm5hbWUpOwogCQlpZiAobWFya19lbnRyeSkgewotCQkJc2V0X3RyYWNlcG9pbnQoJm1hcmtfZW50cnksIGl0ZXIsCisJCQlzZXRfdHJhY2Vwb2ludCgmbWFya19lbnRyeSwgKml0ZXIsCiAJCQkJCSEhbWFya19lbnRyeS0+cmVmY291bnQpOwogCQl9IGVsc2UgewotCQkJZGlzYWJsZV90cmFjZXBvaW50KGl0ZXIpOworCQkJZGlzYWJsZV90cmFjZXBvaW50KCppdGVyKTsKIAkJfQogCX0KIAltdXRleF91bmxvY2soJnRyYWNlcG9pbnRzX211dGV4KTsKQEAgLTMyNiw4ICszMjYsOCBAQAogc3RhdGljIHZvaWQgdHJhY2Vwb2ludF91cGRhdGVfcHJvYmVzKHZvaWQpCiB7CiAJLyogQ29yZSBrZXJuZWwgdHJhY2Vwb2ludHMgKi8KLQl0cmFjZXBvaW50X3VwZGF0ZV9wcm9iZV9yYW5nZShfX3N0YXJ0X19fdHJhY2Vwb2ludHMsCi0JCV9fc3RvcF9fX3RyYWNlcG9pbnRzKTsKKwl0cmFjZXBvaW50X3VwZGF0ZV9wcm9iZV9yYW5nZShfX3N0YXJ0X19fdHJhY2Vwb2ludHNfcHRycywKKwkJX19zdG9wX19fdHJhY2Vwb2ludHNfcHRycyk7CiAJLyogdHJhY2Vwb2ludHMgaW4gbW9kdWxlcy4gKi8KIAltb2R1bGVfdXBkYXRlX3RyYWNlcG9pbnRzKCk7CiB9CkBAIC01MTQsOCArNTE0LDggQEAKICAqIFdpbGwgcmV0dXJuIHRoZSBmaXJzdCB0cmFjZXBvaW50IGluIHRoZSByYW5nZSBpZiB0aGUgaW5wdXQgdHJhY2Vwb2ludCBpcwogICogTlVMTC4KICAqLwotaW50IHRyYWNlcG9pbnRfZ2V0X2l0ZXJfcmFuZ2Uoc3RydWN0IHRyYWNlcG9pbnQgKip0cmFjZXBvaW50LAotCXN0cnVjdCB0cmFjZXBvaW50ICpiZWdpbiwgc3RydWN0IHRyYWNlcG9pbnQgKmVuZCkKK2ludCB0cmFjZXBvaW50X2dldF9pdGVyX3JhbmdlKHN0cnVjdCB0cmFjZXBvaW50ICogY29uc3QgKip0cmFjZXBvaW50LAorCXN0cnVjdCB0cmFjZXBvaW50ICogY29uc3QgKmJlZ2luLCBzdHJ1Y3QgdHJhY2Vwb2ludCAqIGNvbnN0ICplbmQpCiB7CiAJaWYgKCEqdHJhY2Vwb2ludCAmJiBiZWdpbiAhPSBlbmQpIHsKIAkJKnRyYWNlcG9pbnQgPSBiZWdpbjsKQEAgLTUzNCw3ICs1MzQsOCBAQAogCS8qIENvcmUga2VybmVsIHRyYWNlcG9pbnRzICovCiAJaWYgKCFpdGVyLT5tb2R1bGUpIHsKIAkJZm91bmQgPSB0cmFjZXBvaW50X2dldF9pdGVyX3JhbmdlKCZpdGVyLT50cmFjZXBvaW50LAotCQkJCV9fc3RhcnRfX190cmFjZXBvaW50cywgX19zdG9wX19fdHJhY2Vwb2ludHMpOworCQkJCV9fc3RhcnRfX190cmFjZXBvaW50c19wdHJzLAorCQkJCV9fc3RvcF9fX3RyYWNlcG9pbnRzX3B0cnMpOwogCQlpZiAoZm91bmQpCiAJCQlnb3RvIGVuZDsKIAl9CkBAIC01ODUsOCArNTg2LDggQEAKIAlzd2l0Y2ggKHZhbCkgewogCWNhc2UgTU9EVUxFX1NUQVRFX0NPTUlORzoKIAljYXNlIE1PRFVMRV9TVEFURV9HT0lORzoKLQkJdHJhY2Vwb2ludF91cGRhdGVfcHJvYmVfcmFuZ2UobW9kLT50cmFjZXBvaW50cywKLQkJCW1vZC0+dHJhY2Vwb2ludHMgKyBtb2QtPm51bV90cmFjZXBvaW50cyk7CisJCXRyYWNlcG9pbnRfdXBkYXRlX3Byb2JlX3JhbmdlKG1vZC0+dHJhY2Vwb2ludHNfcHRycywKKwkJCW1vZC0+dHJhY2Vwb2ludHNfcHRycyArIG1vZC0+bnVtX3RyYWNlcG9pbnRzKTsKIAkJYnJlYWs7CiAJfQogCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEva2VybmVsL3dhdGNoZG9nLmMgYi9rZXJuZWwvd2F0Y2hkb2cuYwppbmRleCBkN2ViZGY0Li5mMzdmOTc0IDEwMDY0NAotLS0gYS9rZXJuZWwvd2F0Y2hkb2cuYworKysgYi9rZXJuZWwvd2F0Y2hkb2cuYwpAQCAtMjcsNyArMjcsNyBAQAogI2luY2x1ZGUgPGFzbS9pcnFfcmVncy5oPgogI2luY2x1ZGUgPGxpbnV4L3BlcmZfZXZlbnQuaD4KIAotaW50IHdhdGNoZG9nX2VuYWJsZWQ7CitpbnQgd2F0Y2hkb2dfZW5hYmxlZCA9IDE7CiBpbnQgX19yZWFkX21vc3RseSBzb2Z0bG9ja3VwX3RocmVzaCA9IDYwOwogCiBzdGF0aWMgREVGSU5FX1BFUl9DUFUodW5zaWduZWQgbG9uZywgd2F0Y2hkb2dfdG91Y2hfdHMpOwpAQCAtNDMsOSArNDMsNiBAQAogc3RhdGljIERFRklORV9QRVJfQ1BVKHN0cnVjdCBwZXJmX2V2ZW50ICosIHdhdGNoZG9nX2V2KTsKICNlbmRpZgogCi1zdGF0aWMgaW50IG5vX3dhdGNoZG9nOwotCi0KIC8qIGJvb3QgY29tbWFuZHMgKi8KIC8qCiAgKiBTaG91bGQgd2UgcGFuaWMgd2hlbiBhIHNvZnQtbG9ja3VwIG9yIGhhcmQtbG9ja3VwIG9jY3VyczoKQEAgLTU4LDcgKzU1LDcgQEAKIAlpZiAoIXN0cm5jbXAoc3RyLCAicGFuaWMiLCA1KSkKIAkJaGFyZGxvY2t1cF9wYW5pYyA9IDE7CiAJZWxzZSBpZiAoIXN0cm5jbXAoc3RyLCAiMCIsIDEpKQotCQlub193YXRjaGRvZyA9IDE7CisJCXdhdGNoZG9nX2VuYWJsZWQgPSAwOwogCXJldHVybiAxOwogfQogX19zZXR1cCgibm1pX3dhdGNoZG9nPSIsIGhhcmRsb2NrdXBfcGFuaWNfc2V0dXApOwpAQCAtNzcsNyArNzQsNyBAQAogCiBzdGF0aWMgaW50IF9faW5pdCBub3dhdGNoZG9nX3NldHVwKGNoYXIgKnN0cikKIHsKLQlub193YXRjaGRvZyA9IDE7CisJd2F0Y2hkb2dfZW5hYmxlZCA9IDA7CiAJcmV0dXJuIDE7CiB9CiBfX3NldHVwKCJub3dhdGNoZG9nIiwgbm93YXRjaGRvZ19zZXR1cCk7CkBAIC04NSw3ICs4Miw3IEBACiAvKiBkZXByZWNhdGVkICovCiBzdGF0aWMgaW50IF9faW5pdCBub3NvZnRsb2NrdXBfc2V0dXAoY2hhciAqc3RyKQogewotCW5vX3dhdGNoZG9nID0gMTsKKwl3YXRjaGRvZ19lbmFibGVkID0gMDsKIAlyZXR1cm4gMTsKIH0KIF9fc2V0dXAoIm5vc29mdGxvY2t1cCIsIG5vc29mdGxvY2t1cF9zZXR1cCk7CkBAIC00MzIsOSArNDI5LDYgQEAKIAkJd2FrZV91cF9wcm9jZXNzKHApOwogCX0KIAotCS8qIGlmIGFueSBjcHUgc3VjY2VlZHMsIHdhdGNoZG9nIGlzIGNvbnNpZGVyZWQgZW5hYmxlZCBmb3IgdGhlIHN5c3RlbSAqLwotCXdhdGNoZG9nX2VuYWJsZWQgPSAxOwotCiAJcmV0dXJuIDA7CiB9CiAKQEAgLTQ2MiwxMiArNDU2LDE2IEBACiBzdGF0aWMgdm9pZCB3YXRjaGRvZ19lbmFibGVfYWxsX2NwdXModm9pZCkKIHsKIAlpbnQgY3B1OwotCWludCByZXN1bHQgPSAwOworCisJd2F0Y2hkb2dfZW5hYmxlZCA9IDA7CiAKIAlmb3JfZWFjaF9vbmxpbmVfY3B1KGNwdSkKLQkJcmVzdWx0ICs9IHdhdGNoZG9nX2VuYWJsZShjcHUpOworCQlpZiAoIXdhdGNoZG9nX2VuYWJsZShjcHUpKQorCQkJLyogaWYgYW55IGNwdSBzdWNjZWVkcywgd2F0Y2hkb2cgaXMgY29uc2lkZXJlZAorCQkJICAgZW5hYmxlZCBmb3IgdGhlIHN5c3RlbSAqLworCQkJd2F0Y2hkb2dfZW5hYmxlZCA9IDE7CiAKLQlpZiAocmVzdWx0KQorCWlmICghd2F0Y2hkb2dfZW5hYmxlZCkKIAkJcHJpbnRrKEtFUk5fRVJSICJ3YXRjaGRvZzogZmFpbGVkIHRvIGJlIGVuYWJsZWQgb24gc29tZSBjcHVzXG4iKTsKIAogfQpAQCAtNDc2LDkgKzQ3NCw2IEBACiB7CiAJaW50IGNwdTsKIAotCWlmIChub193YXRjaGRvZykKLQkJcmV0dXJuOwotCiAJZm9yX2VhY2hfb25saW5lX2NwdShjcHUpCiAJCXdhdGNoZG9nX2Rpc2FibGUoY3B1KTsKIApAQCAtNDk4LDEwICs0OTMsMTIgQEAKIHsKIAlwcm9jX2RvaW50dmVjKHRhYmxlLCB3cml0ZSwgYnVmZmVyLCBsZW5ndGgsIHBwb3MpOwogCi0JaWYgKHdhdGNoZG9nX2VuYWJsZWQpCi0JCXdhdGNoZG9nX2VuYWJsZV9hbGxfY3B1cygpOwotCWVsc2UKLQkJd2F0Y2hkb2dfZGlzYWJsZV9hbGxfY3B1cygpOworCWlmICh3cml0ZSkgeworCQlpZiAod2F0Y2hkb2dfZW5hYmxlZCkKKwkJCXdhdGNoZG9nX2VuYWJsZV9hbGxfY3B1cygpOworCQllbHNlCisJCQl3YXRjaGRvZ19kaXNhYmxlX2FsbF9jcHVzKCk7CisJfQogCXJldHVybiAwOwogfQogCkBAIC01MzAsNyArNTI3LDggQEAKIAkJYnJlYWs7CiAJY2FzZSBDUFVfT05MSU5FOgogCWNhc2UgQ1BVX09OTElORV9GUk9aRU46Ci0JCWVyciA9IHdhdGNoZG9nX2VuYWJsZShob3RjcHUpOworCQlpZiAod2F0Y2hkb2dfZW5hYmxlZCkKKwkJCWVyciA9IHdhdGNoZG9nX2VuYWJsZShob3RjcHUpOwogCQlicmVhazsKICNpZmRlZiBDT05GSUdfSE9UUExVR19DUFUKIAljYXNlIENQVV9VUF9DQU5DRUxFRDoKQEAgLTU1NSw5ICs1NTMsNiBAQAogCXZvaWQgKmNwdSA9ICh2b2lkICopKGxvbmcpc21wX3Byb2Nlc3Nvcl9pZCgpOwogCWludCBlcnI7CiAKLQlpZiAobm9fd2F0Y2hkb2cpCi0JCXJldHVybjsKLQogCWVyciA9IGNwdV9jYWxsYmFjaygmY3B1X25mYiwgQ1BVX1VQX1BSRVBBUkUsIGNwdSk7CiAJV0FSTl9PTihub3RpZmllcl90b19lcnJubyhlcnIpKTsKIApkaWZmIC0tZ2l0IGEva2VybmVsL3dvcmtxdWV1ZS5jIGIva2VybmVsL3dvcmtxdWV1ZS5jCmluZGV4IDhlZTZlYzguLjExODY5ZmEgMTAwNjQ0Ci0tLSBhL2tlcm5lbC93b3JrcXVldWUuYworKysgYi9rZXJuZWwvd29ya3F1ZXVlLmMKQEAgLTc2OCw3ICs3NjgsMTEgQEAKIAogCXdvcmtlci0+ZmxhZ3MgJj0gfmZsYWdzOwogCi0JLyogaWYgdHJhbnNpdGlvbmluZyBvdXQgb2YgTk9UX1JVTk5JTkcsIGluY3JlbWVudCBucl9ydW5uaW5nICovCisJLyoKKwkgKiBJZiB0cmFuc2l0aW9uaW5nIG91dCBvZiBOT1RfUlVOTklORywgaW5jcmVtZW50IG5yX3J1bm5pbmcuICBOb3RlCisJICogdGhhdCB0aGUgbmVzdGVkIE5PVF9SVU5OSU5HIGlzIG5vdCBhIG5vb3AuICBOT1RfUlVOTklORyBpcyBtYXNrCisJICogb2YgbXVsdGlwbGUgZmxhZ3MsIG5vdCBhIHNpbmdsZSBmbGFnLgorCSAqLwogCWlmICgoZmxhZ3MgJiBXT1JLRVJfTk9UX1JVTk5JTkcpICYmIChvZmxhZ3MgJiBXT1JLRVJfTk9UX1JVTk5JTkcpKQogCQlpZiAoISh3b3JrZXItPmZsYWdzICYgV09SS0VSX05PVF9SVU5OSU5HKSkKIAkJCWF0b21pY19pbmMoZ2V0X2djd3FfbnJfcnVubmluZyhnY3dxLT5jcHUpKTsKQEAgLTE4NDAsNyArMTg0NCw3IEBACiAJc3Bpbl91bmxvY2tfaXJxKCZnY3dxLT5sb2NrKTsKIAogCXdvcmtfY2xlYXJfcGVuZGluZyh3b3JrKTsKLQlsb2NrX21hcF9hY3F1aXJlKCZjd3EtPndxLT5sb2NrZGVwX21hcCk7CisJbG9ja19tYXBfYWNxdWlyZV9yZWFkKCZjd3EtPndxLT5sb2NrZGVwX21hcCk7CiAJbG9ja19tYXBfYWNxdWlyZSgmbG9ja2RlcF9tYXApOwogCXRyYWNlX3dvcmtxdWV1ZV9leGVjdXRlX3N0YXJ0KHdvcmspOwogCWYod29yayk7CkBAIC0yMzg0LDggKzIzODgsMTggQEAKIAlpbnNlcnRfd3FfYmFycmllcihjd3EsIGJhcnIsIHdvcmssIHdvcmtlcik7CiAJc3Bpbl91bmxvY2tfaXJxKCZnY3dxLT5sb2NrKTsKIAotCWxvY2tfbWFwX2FjcXVpcmUoJmN3cS0+d3EtPmxvY2tkZXBfbWFwKTsKKwkvKgorCSAqIElmIEBtYXhfYWN0aXZlIGlzIDEgb3IgcmVzY3VlciBpcyBpbiB1c2UsIGZsdXNoaW5nIGFub3RoZXIgd29yaworCSAqIGl0ZW0gb24gdGhlIHNhbWUgd29ya3F1ZXVlIG1heSBsZWFkIHRvIGRlYWRsb2NrLiAgTWFrZSBzdXJlIHRoZQorCSAqIGZsdXNoZXIgaXMgbm90IHJ1bm5pbmcgb24gdGhlIHNhbWUgd29ya3F1ZXVlIGJ5IHZlcmlmeWluZyB3cml0ZQorCSAqIGFjY2Vzcy4KKwkgKi8KKwlpZiAoY3dxLT53cS0+c2F2ZWRfbWF4X2FjdGl2ZSA9PSAxIHx8IGN3cS0+d3EtPmZsYWdzICYgV1FfUkVTQ1VFUikKKwkJbG9ja19tYXBfYWNxdWlyZSgmY3dxLT53cS0+bG9ja2RlcF9tYXApOworCWVsc2UKKwkJbG9ja19tYXBfYWNxdWlyZV9yZWFkKCZjd3EtPndxLT5sb2NrZGVwX21hcCk7CiAJbG9ja19tYXBfcmVsZWFzZSgmY3dxLT53cS0+bG9ja2RlcF9tYXApOworCiAJcmV0dXJuIHRydWU7CiBhbHJlYWR5X2dvbmU6CiAJc3Bpbl91bmxvY2tfaXJxKCZnY3dxLT5sb2NrKTsKZGlmZiAtLWdpdCBhL2xpYi9LY29uZmlnLmRlYnVnIGIvbGliL0tjb25maWcuZGVidWcKaW5kZXggMmQwNWFkYi4uMzk2N2MyMzUgMTAwNjQ0Ci0tLSBhL2xpYi9LY29uZmlnLmRlYnVnCisrKyBiL2xpYi9LY29uZmlnLmRlYnVnCkBAIC02NTcsNyArNjU3LDcgQEAKIAkgIERpc2FibGUgZm9yIHByb2R1Y3Rpb24gc3lzdGVtcy4KIAogY29uZmlnIERFQlVHX0JVR1ZFUkJPU0UKLQlib29sICJWZXJib3NlIEJVRygpIHJlcG9ydGluZyAoYWRkcyA3MEspIiBpZiBERUJVR19LRVJORUwgJiYgRU1CRURERUQKKwlib29sICJWZXJib3NlIEJVRygpIHJlcG9ydGluZyAoYWRkcyA3MEspIiBpZiBERUJVR19LRVJORUwgJiYgRVhQRVJUCiAJZGVwZW5kcyBvbiBCVUcKIAlkZXBlbmRzIG9uIEFSTSB8fCBBVlIzMiB8fCBNMzJSIHx8IE02OEsgfHwgU1BBUkMzMiB8fCBTUEFSQzY0IHx8IFwKIAkJICAgRlJWIHx8IFNVUEVSSCB8fCBHRU5FUklDX0JVRyB8fCBCTEFDS0ZJTiB8fCBNTjEwMzAwCkBAIC03MjksOCArNzI5LDggQEAKIAkgIElmIHVuc3VyZSwgc2F5IE4uCiAKIGNvbmZpZyBERUJVR19NRU1PUllfSU5JVAotCWJvb2wgIkRlYnVnIG1lbW9yeSBpbml0aWFsaXNhdGlvbiIgaWYgRU1CRURERUQKLQlkZWZhdWx0ICFFTUJFRERFRAorCWJvb2wgIkRlYnVnIG1lbW9yeSBpbml0aWFsaXNhdGlvbiIgaWYgRVhQRVJUCisJZGVmYXVsdCAhRVhQRVJUCiAJaGVscAogCSAgRW5hYmxlIHRoaXMgZm9yIGFkZGl0aW9uYWwgY2hlY2tzIGR1cmluZyBtZW1vcnkgaW5pdGlhbGlzYXRpb24uCiAJICBUaGUgc2FuaXR5IGNoZWNrcyB2ZXJpZnkgYXNwZWN0cyBvZiB0aGUgVk0gc3VjaCBhcyB0aGUgbWVtb3J5IG1vZGVsCmRpZmYgLS1naXQgYS9saWIvaW9yZW1hcC5jIGIvbGliL2lvcmVtYXAuYwppbmRleCA1NzMwZWNkLi5kYTRlMmFkIDEwMDY0NAotLS0gYS9saWIvaW9yZW1hcC5jCisrKyBiL2xpYi9pb3JlbWFwLmMKQEAgLTksNiArOSw3IEBACiAjaW5jbHVkZSA8bGludXgvbW0uaD4KICNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L2lvLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8YXNtL2NhY2hlZmx1c2guaD4KICNpbmNsdWRlIDxhc20vcGd0YWJsZS5oPgogCkBAIC05MCwzICs5MSw0IEBACiAKIAlyZXR1cm4gZXJyOwogfQorRVhQT1JUX1NZTUJPTF9HUEwoaW9yZW1hcF9wYWdlX3JhbmdlKTsKZGlmZiAtLWdpdCBhL2xpYi9yYWRpeC10cmVlLmMgYi9saWIvcmFkaXgtdHJlZS5jCmluZGV4IDUwODZiYjkuLjdlYTJlMDMgMTAwNjQ0Ci0tLSBhL2xpYi9yYWRpeC10cmVlLmMKKysrIGIvbGliL3JhZGl4LXRyZWUuYwpAQCAtNzM2LDEwICs3MzYsMTEgQEAKIAkJfQogCX0KIAkvKgotCSAqIFRoZSBpZnRhZyBtdXN0IGhhdmUgYmVlbiBzZXQgc29tZXdoZXJlIGJlY2F1c2Ugb3RoZXJ3aXNlCi0JICogd2Ugd291bGQgcmV0dXJuIGltbWVkaWF0ZWQgYXQgdGhlIGJlZ2lubmluZyBvZiB0aGUgZnVuY3Rpb24KKwkgKiBXZSBuZWVkIG5vdCB0byB0YWcgdGhlIHJvb3QgdGFnIGlmIHRoZXJlIGlzIG5vIHRhZyB3aGljaCBpcyBzZXQgd2l0aAorCSAqIHNldHRhZyB3aXRoaW4gdGhlIHJhbmdlIGZyb20gKmZpcnN0X2luZGV4cCB0byBsYXN0X2luZGV4LgogCSAqLwotCXJvb3RfdGFnX3NldChyb290LCBzZXR0YWcpOworCWlmICh0YWdnZWQgPiAwKQorCQlyb290X3RhZ19zZXQocm9vdCwgc2V0dGFnKTsKIAkqZmlyc3RfaW5kZXhwID0gaW5kZXg7CiAKIAlyZXR1cm4gdGFnZ2VkOwpkaWZmIC0tZ2l0IGEvbGliL3JidHJlZS5jIGIvbGliL3JidHJlZS5jCmluZGV4IDQ2OTNmNzkuLmExNmJlMTkgMTAwNjQ0Ci0tLSBhL2xpYi9yYnRyZWUuYworKysgYi9saWIvcmJ0cmVlLmMKQEAgLTMxNSw2ICszMTUsNyBAQAogCiAJcmJfYXVnbWVudF9wYXRoKG5vZGUsIGZ1bmMsIGRhdGEpOwogfQorRVhQT1JUX1NZTUJPTChyYl9hdWdtZW50X2luc2VydCk7CiAKIC8qCiAgKiBiZWZvcmUgcmVtb3ZpbmcgdGhlIG5vZGUsIGZpbmQgdGhlIGRlZXBlc3Qgbm9kZSBvbiB0aGUgcmViYWxhbmNlIHBhdGgKQEAgLTM0MCw2ICszNDEsNyBAQAogCiAJcmV0dXJuIGRlZXBlc3Q7CiB9CitFWFBPUlRfU1lNQk9MKHJiX2F1Z21lbnRfZXJhc2VfYmVnaW4pOwogCiAvKgogICogYWZ0ZXIgcmVtb3ZhbCwgdXBkYXRlIHRoZSB0cmVlIHRvIGFjY291bnQgZm9yIHRoZSByZW1vdmVkIGVudHJ5CkBAIC0zNTAsNiArMzUyLDcgQEAKIAlpZiAobm9kZSkKIAkJcmJfYXVnbWVudF9wYXRoKG5vZGUsIGZ1bmMsIGRhdGEpOwogfQorRVhQT1JUX1NZTUJPTChyYl9hdWdtZW50X2VyYXNlX2VuZCk7CiAKIC8qCiAgKiBUaGlzIGZ1bmN0aW9uIHJldHVybnMgdGhlIGZpcnN0IG5vZGUgKGluIHNvcnQgb3JkZXIpIG9mIHRoZSB0cmVlLgpkaWZmIC0tZ2l0IGEvbGliL3RleHRzZWFyY2guYyBiL2xpYi90ZXh0c2VhcmNoLmMKaW5kZXggZDYwODMzMS4uZTBjYzAxNCAxMDA2NDQKLS0tIGEvbGliL3RleHRzZWFyY2guYworKysgYi9saWIvdGV4dHNlYXJjaC5jCkBAIC0xMyw3ICsxMyw3IEBACiAgKgogICogSU5UUk9EVUNUSU9OCiAgKgotICogICBUaGUgdGV4dHNlYXJjaCBpbmZyYXN0cnVjdHVyZSBwcm92aWRlcyB0ZXh0IHNlYXJjaGluZyBmYWNpdGlsaWVzIGZvcgorICogICBUaGUgdGV4dHNlYXJjaCBpbmZyYXN0cnVjdHVyZSBwcm92aWRlcyB0ZXh0IHNlYXJjaGluZyBmYWNpbGl0aWVzIGZvcgogICogICBib3RoIGxpbmVhciBhbmQgbm9uLWxpbmVhciBkYXRhLiBJbmRpdmlkdWFsIHNlYXJjaCBhbGdvcml0aG1zIGFyZQogICogICBpbXBsZW1lbnRlZCBpbiBtb2R1bGVzIGFuZCBjaG9zZW4gYnkgdGhlIHVzZXIuCiAgKgpAQCAtNDMsNyArNDMsNyBAQAogICogICAgICAgdG8gdGhlIGFsZ29yaXRobSB0byBzdG9yZSBwZXJzaXN0ZW50IHZhcmlhYmxlcy4KICAqICAgKDQpIENvcmUgZXZlbnR1YWxseSByZXNldHMgdGhlIHNlYXJjaCBvZmZzZXQgYW5kIGZvcndhcmRzIHRoZSBmaW5kKCkKICAqICAgICAgIHJlcXVlc3QgdG8gdGhlIGFsZ29yaXRobS4KLSAqICAgKDUpIEFsZ29yaXRobSBjYWxscyBnZXRfbmV4dF9ibG9jaygpIHByb3ZpZGVkIGJ5IHRoZSB1c2VyIGNvbnRpbm91c2x5CisgKiAgICg1KSBBbGdvcml0aG0gY2FsbHMgZ2V0X25leHRfYmxvY2soKSBwcm92aWRlZCBieSB0aGUgdXNlciBjb250aW51b3VzbHkKICAqICAgICAgIHRvIGZldGNoIHRoZSBkYXRhIHRvIGJlIHNlYXJjaGVkIGluIGJsb2NrIGJ5IGJsb2NrLgogICogICAoNikgQWxnb3JpdGhtIGludm9rZXMgZmluaXNoKCkgYWZ0ZXIgdGhlIGxhc3QgY2FsbCB0byBnZXRfbmV4dF9ibG9jawogICogICAgICAgdG8gY2xlYW4gdXAgYW55IGxlZnRvdmVycyBmcm9tIGdldF9uZXh0X2Jsb2NrLiAoT3B0aW9uYWwpCkBAIC01OCwxNSArNTgsMTUgQEAKICAqICAgdGhlIHBhdHRlcm4gdG8gbG9vayBmb3IgYW5kIGZsYWdzLiBBcyBhIGZsYWcsIHlvdSBjYW4gc2V0IFRTX0lHTk9SRUNBU0UKICAqICAgdG8gcGVyZm9ybSBjYXNlIGluc2Vuc2l0aXZlIG1hdGNoaW5nLiBCdXQgaXQgbWlnaHQgc2xvdyBkb3duCiAgKiAgIHBlcmZvcm1hbmNlIG9mIGFsZ29yaXRobSwgc28geW91IHNob3VsZCB1c2UgaXQgYXQgb3duIHlvdXIgcmlzay4KLSAqICAgVGhlIHJldHVybmVkIGNvbmZpZ3VyYXRpb24gbWF5IHRoZW4gYmUgdXNlZCBmb3IgYW4gYXJiaXRhcnkKKyAqICAgVGhlIHJldHVybmVkIGNvbmZpZ3VyYXRpb24gbWF5IHRoZW4gYmUgdXNlZCBmb3IgYW4gYXJiaXRyYXJ5CiAgKiAgIGFtb3VudCBvZiB0aW1lcyBhbmQgZXZlbiBpbiBwYXJhbGxlbCBhcyBsb25nIGFzIGEgc2VwYXJhdGUgc3RydWN0CiAgKiAgIHRzX3N0YXRlIHZhcmlhYmxlIGlzIHByb3ZpZGVkIHRvIGV2ZXJ5IGluc3RhbmNlLgogICoKICAqICAgVGhlIGFjdHVhbCBzZWFyY2ggaXMgcGVyZm9ybWVkIGJ5IGVpdGhlciBjYWxsaW5nIHRleHRzZWFyY2hfZmluZF8tCiAgKiAgIGNvbnRpbnVvdXMoKSBmb3IgbGluZWFyIGRhdGEgb3IgYnkgcHJvdmlkaW5nIGFuIG93biBnZXRfbmV4dF9ibG9jaygpCiAgKiAgIGltcGxlbWVudGF0aW9uIGFuZCBjYWxsaW5nIHRleHRzZWFyY2hfZmluZCgpLiBCb3RoIGZ1bmN0aW9ucyByZXR1cm4KLSAqICAgdGhlIHBvc2l0aW9uIG9mIHRoZSBmaXJzdCBvY2N1cnJlbmNlIG9mIHRoZSBwYXRlcm4gb3IgVUlOVF9NQVggaWYKLSAqICAgbm8gbWF0Y2ggd2FzIGZvdW5kLiBTdWJzZXF1ZW50IG9jY3VyZW5jZXMgY2FuIGJlIGZvdW5kIGJ5IGNhbGxpbmcKKyAqICAgdGhlIHBvc2l0aW9uIG9mIHRoZSBmaXJzdCBvY2N1cnJlbmNlIG9mIHRoZSBwYXR0ZXJuIG9yIFVJTlRfTUFYIGlmCisgKiAgIG5vIG1hdGNoIHdhcyBmb3VuZC4gU3Vic2VxdWVudCBvY2N1cnJlbmNlcyBjYW4gYmUgZm91bmQgYnkgY2FsbGluZwogICogICB0ZXh0c2VhcmNoX25leHQoKSByZWdhcmRsZXNzIG9mIHRoZSBsaW5lYXJpdHkgb2YgdGhlIGRhdGEuCiAgKgogICogICBPbmNlIHlvdSdyZSBkb25lIHVzaW5nIGEgY29uZmlndXJhdGlvbiBpdCBtdXN0IGJlIGdpdmVuIGJhY2sgdmlhCmRpZmYgLS1naXQgYS9saWIveHovS2NvbmZpZyBiL2xpYi94ei9LY29uZmlnCmluZGV4IGUzYjZlMTguLjYwYTYwODggMTAwNjQ0Ci0tLSBhL2xpYi94ei9LY29uZmlnCisrKyBiL2xpYi94ei9LY29uZmlnCkBAIC03LDM3ICs3LDM3IEBACiAJICBDUkMzMiBpcyBzdXBwb3J0ZWQuIFNlZSBEb2N1bWVudGF0aW9uL3h6LnR4dCBmb3IgbW9yZSBpbmZvcm1hdGlvbi4KIAogY29uZmlnIFhaX0RFQ19YODYKLQlib29sICJ4ODYgQkNKIGZpbHRlciBkZWNvZGVyIiBpZiBFTUJFRERFRAorCWJvb2wgIng4NiBCQ0ogZmlsdGVyIGRlY29kZXIiIGlmIEVYUEVSVAogCWRlZmF1bHQgeQogCWRlcGVuZHMgb24gWFpfREVDCiAJc2VsZWN0IFhaX0RFQ19CQ0oKIAogY29uZmlnIFhaX0RFQ19QT1dFUlBDCi0JYm9vbCAiUG93ZXJQQyBCQ0ogZmlsdGVyIGRlY29kZXIiIGlmIEVNQkVEREVECisJYm9vbCAiUG93ZXJQQyBCQ0ogZmlsdGVyIGRlY29kZXIiIGlmIEVYUEVSVAogCWRlZmF1bHQgeQogCWRlcGVuZHMgb24gWFpfREVDCiAJc2VsZWN0IFhaX0RFQ19CQ0oKIAogY29uZmlnIFhaX0RFQ19JQTY0Ci0JYm9vbCAiSUEtNjQgQkNKIGZpbHRlciBkZWNvZGVyIiBpZiBFTUJFRERFRAorCWJvb2wgIklBLTY0IEJDSiBmaWx0ZXIgZGVjb2RlciIgaWYgRVhQRVJUCiAJZGVmYXVsdCB5CiAJZGVwZW5kcyBvbiBYWl9ERUMKIAlzZWxlY3QgWFpfREVDX0JDSgogCiBjb25maWcgWFpfREVDX0FSTQotCWJvb2wgIkFSTSBCQ0ogZmlsdGVyIGRlY29kZXIiIGlmIEVNQkVEREVECisJYm9vbCAiQVJNIEJDSiBmaWx0ZXIgZGVjb2RlciIgaWYgRVhQRVJUCiAJZGVmYXVsdCB5CiAJZGVwZW5kcyBvbiBYWl9ERUMKIAlzZWxlY3QgWFpfREVDX0JDSgogCiBjb25maWcgWFpfREVDX0FSTVRIVU1CCi0JYm9vbCAiQVJNLVRodW1iIEJDSiBmaWx0ZXIgZGVjb2RlciIgaWYgRU1CRURERUQKKwlib29sICJBUk0tVGh1bWIgQkNKIGZpbHRlciBkZWNvZGVyIiBpZiBFWFBFUlQKIAlkZWZhdWx0IHkKIAlkZXBlbmRzIG9uIFhaX0RFQwogCXNlbGVjdCBYWl9ERUNfQkNKCiAKIGNvbmZpZyBYWl9ERUNfU1BBUkMKLQlib29sICJTUEFSQyBCQ0ogZmlsdGVyIGRlY29kZXIiIGlmIEVNQkVEREVECisJYm9vbCAiU1BBUkMgQkNKIGZpbHRlciBkZWNvZGVyIiBpZiBFWFBFUlQKIAlkZWZhdWx0IHkKIAlkZXBlbmRzIG9uIFhaX0RFQwogCXNlbGVjdCBYWl9ERUNfQkNKCmRpZmYgLS1naXQgYS9tbS9LY29uZmlnIGIvbW0vS2NvbmZpZwppbmRleCBjMmM4YTRhLi5lOWMwYzYxIDEwMDY0NAotLS0gYS9tbS9LY29uZmlnCisrKyBiL21tL0tjb25maWcKQEAgLTE3OSw3ICsxNzksNyBAQAogY29uZmlnIENPTVBBQ1RJT04KIAlib29sICJBbGxvdyBmb3IgbWVtb3J5IGNvbXBhY3Rpb24iCiAJc2VsZWN0IE1JR1JBVElPTgotCWRlcGVuZHMgb24gRVhQRVJJTUVOVEFMICYmIEhVR0VUTEJfUEFHRSAmJiBNTVUKKwlkZXBlbmRzIG9uIE1NVQogCWhlbHAKIAkgIEFsbG93cyB0aGUgY29tcGFjdGlvbiBvZiBtZW1vcnkgZm9yIHRoZSBhbGxvY2F0aW9uIG9mIGh1Z2UgcGFnZXMuCiAKQEAgLTMwMiw2ICszMDIsNDQgQEAKIAogCSAgU2VlIERvY3VtZW50YXRpb24vbm9tbXUtbW1hcC50eHQgZm9yIG1vcmUgaW5mb3JtYXRpb24uCiAKK2NvbmZpZyBUUkFOU1BBUkVOVF9IVUdFUEFHRQorCWJvb2wgIlRyYW5zcGFyZW50IEh1Z2VwYWdlIFN1cHBvcnQiCisJZGVwZW5kcyBvbiBYODYgJiYgTU1VCisJc2VsZWN0IENPTVBBQ1RJT04KKwloZWxwCisJICBUcmFuc3BhcmVudCBIdWdlcGFnZXMgYWxsb3dzIHRoZSBrZXJuZWwgdG8gdXNlIGh1Z2UgcGFnZXMgYW5kCisJICBodWdlIHRsYiB0cmFuc3BhcmVudGx5IHRvIHRoZSBhcHBsaWNhdGlvbnMgd2hlbmV2ZXIgcG9zc2libGUuCisJICBUaGlzIGZlYXR1cmUgY2FuIGltcHJvdmUgY29tcHV0aW5nIHBlcmZvcm1hbmNlIHRvIGNlcnRhaW4KKwkgIGFwcGxpY2F0aW9ucyBieSBzcGVlZGluZyB1cCBwYWdlIGZhdWx0cyBkdXJpbmcgbWVtb3J5CisJICBhbGxvY2F0aW9uLCBieSByZWR1Y2luZyB0aGUgbnVtYmVyIG9mIHRsYiBtaXNzZXMgYW5kIGJ5IHNwZWVkaW5nCisJICB1cCB0aGUgcGFnZXRhYmxlIHdhbGtpbmcuCisKKwkgIElmIG1lbW9yeSBjb25zdHJhaW5lZCBvbiBlbWJlZGRlZCwgeW91IG1heSB3YW50IHRvIHNheSBOLgorCitjaG9pY2UKKwlwcm9tcHQgIlRyYW5zcGFyZW50IEh1Z2VwYWdlIFN1cHBvcnQgc3lzZnMgZGVmYXVsdHMiCisJZGVwZW5kcyBvbiBUUkFOU1BBUkVOVF9IVUdFUEFHRQorCWRlZmF1bHQgVFJBTlNQQVJFTlRfSFVHRVBBR0VfQUxXQVlTCisJaGVscAorCSAgU2VsZWN0cyB0aGUgc3lzZnMgZGVmYXVsdHMgZm9yIFRyYW5zcGFyZW50IEh1Z2VwYWdlIFN1cHBvcnQuCisKKwljb25maWcgVFJBTlNQQVJFTlRfSFVHRVBBR0VfQUxXQVlTCisJCWJvb2wgImFsd2F5cyIKKwloZWxwCisJICBFbmFibGluZyBUcmFuc3BhcmVudCBIdWdlcGFnZSBhbHdheXMsIGNhbiBpbmNyZWFzZSB0aGUKKwkgIG1lbW9yeSBmb290cHJpbnQgb2YgYXBwbGljYXRpb25zIHdpdGhvdXQgYSBndWFyYW50ZWVkCisJICBiZW5lZml0IGJ1dCBpdCB3aWxsIHdvcmsgYXV0b21hdGljYWxseSBmb3IgYWxsIGFwcGxpY2F0aW9ucy4KKworCWNvbmZpZyBUUkFOU1BBUkVOVF9IVUdFUEFHRV9NQURWSVNFCisJCWJvb2wgIm1hZHZpc2UiCisJaGVscAorCSAgRW5hYmxpbmcgVHJhbnNwYXJlbnQgSHVnZXBhZ2UgbWFkdmlzZSwgd2lsbCBvbmx5IHByb3ZpZGUgYQorCSAgcGVyZm9ybWFuY2UgaW1wcm92ZW1lbnQgYmVuZWZpdCB0byB0aGUgYXBwbGljYXRpb25zIHVzaW5nCisJICBtYWR2aXNlKE1BRFZfSFVHRVBBR0UpIGJ1dCBpdCB3b24ndCByaXNrIHRvIGluY3JlYXNlIHRoZQorCSAgbWVtb3J5IGZvb3RwcmludCBvZiBhcHBsaWNhdGlvbnMgd2l0aG91dCBhIGd1YXJhbnRlZWQKKwkgIGJlbmVmaXQuCitlbmRjaG9pY2UKKwogIwogIyBVUCBhbmQgbm9tbXUgYXJjaHMgdXNlIGttIGJhc2VkIHBlcmNwdSBhbGxvY2F0b3IKICMKZGlmZiAtLWdpdCBhL21tL01ha2VmaWxlIGIvbW0vTWFrZWZpbGUKaW5kZXggZjczZjc1YS4uMmIxYjU3NSAxMDA2NDQKLS0tIGEvbW0vTWFrZWZpbGUKKysrIGIvbW0vTWFrZWZpbGUKQEAgLTUsNyArNSw3IEBACiBtbXUteQkJCTo9IG5vbW11Lm8KIG1tdS0kKENPTkZJR19NTVUpCTo9IGZyZW1hcC5vIGhpZ2htZW0ubyBtYWR2aXNlLm8gbWVtb3J5Lm8gbWluY29yZS5vIFwKIAkJCSAgIG1sb2NrLm8gbW1hcC5vIG1wcm90ZWN0Lm8gbXJlbWFwLm8gbXN5bmMubyBybWFwLm8gXAotCQkJICAgdm1hbGxvYy5vIHBhZ2V3YWxrLm8KKwkJCSAgIHZtYWxsb2MubyBwYWdld2Fsay5vIHBndGFibGUtZ2VuZXJpYy5vCiAKIG9iai15CQkJOj0gYm9vdG1lbS5vIGZpbGVtYXAubyBtZW1wb29sLm8gb29tX2tpbGwubyBmYWR2aXNlLm8gXAogCQkJICAgbWFjY2Vzcy5vIHBhZ2VfYWxsb2MubyBwYWdlLXdyaXRlYmFjay5vIFwKQEAgLTM3LDYgKzM3LDcgQEAKIG9iai0kKENPTkZJR19GU19YSVApICs9IGZpbGVtYXBfeGlwLm8KIG9iai0kKENPTkZJR19NSUdSQVRJT04pICs9IG1pZ3JhdGUubwogb2JqLSQoQ09ORklHX1FVSUNLTElTVCkgKz0gcXVpY2tsaXN0Lm8KK29iai0kKENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRSkgKz0gaHVnZV9tZW1vcnkubwogb2JqLSQoQ09ORklHX0NHUk9VUF9NRU1fUkVTX0NUTFIpICs9IG1lbWNvbnRyb2wubyBwYWdlX2Nncm91cC5vCiBvYmotJChDT05GSUdfTUVNT1JZX0ZBSUxVUkUpICs9IG1lbW9yeS1mYWlsdXJlLm8KIG9iai0kKENPTkZJR19IV1BPSVNPTl9JTkpFQ1QpICs9IGh3cG9pc29uLWluamVjdC5vCmRpZmYgLS1naXQgYS9tbS9jb21wYWN0aW9uLmMgYi9tbS9jb21wYWN0aW9uLmMKaW5kZXggMWE4ODk0ZS4uOGJlNDMwYiAxMDA2NDQKLS0tIGEvbW0vY29tcGFjdGlvbi5jCisrKyBiL21tL2NvbXBhY3Rpb24uYwpAQCAtMTYsNiArMTYsOSBAQAogI2luY2x1ZGUgPGxpbnV4L3N5c2ZzLmg+CiAjaW5jbHVkZSAiaW50ZXJuYWwuaCIKIAorI2RlZmluZSBDUkVBVEVfVFJBQ0VfUE9JTlRTCisjaW5jbHVkZSA8dHJhY2UvZXZlbnRzL2NvbXBhY3Rpb24uaD4KKwogLyoKICAqIGNvbXBhY3RfY29udHJvbCBpcyB1c2VkIHRvIHRyYWNrIHBhZ2VzIGJlaW5nIG1pZ3JhdGVkIGFuZCB0aGUgZnJlZSBwYWdlcwogICogdGhleSBhcmUgYmVpbmcgbWlncmF0ZWQgdG8gZHVyaW5nIG1lbW9yeSBjb21wYWN0aW9uLiBUaGUgZnJlZV9wZm4gc3RhcnRzCkBAIC0zMCw2ICszMyw3IEBACiAJdW5zaWduZWQgbG9uZyBucl9taWdyYXRlcGFnZXM7CS8qIE51bWJlciBvZiBwYWdlcyB0byBtaWdyYXRlICovCiAJdW5zaWduZWQgbG9uZyBmcmVlX3BmbjsJCS8qIGlzb2xhdGVfZnJlZXBhZ2VzIHNlYXJjaCBiYXNlICovCiAJdW5zaWduZWQgbG9uZyBtaWdyYXRlX3BmbjsJLyogaXNvbGF0ZV9taWdyYXRlcGFnZXMgc2VhcmNoIGJhc2UgKi8KKwlib29sIHN5bmM7CQkJLyogU3luY2hyb25vdXMgbWlncmF0aW9uICovCiAKIAkvKiBBY2NvdW50IGZvciBpc29sYXRlZCBhbm9uIGFuZCBmaWxlIHBhZ2VzICovCiAJdW5zaWduZWQgbG9uZyBucl9hbm9uOwpAQCAtMzgsNiArNDIsOCBAQAogCXVuc2lnbmVkIGludCBvcmRlcjsJCS8qIG9yZGVyIGEgZGlyZWN0IGNvbXBhY3RvciBuZWVkcyAqLwogCWludCBtaWdyYXRldHlwZTsJCS8qIE1PVkFCTEUsIFJFQ0xBSU1BQkxFIGV0YyAqLwogCXN0cnVjdCB6b25lICp6b25lOworCisJaW50IGNvbXBhY3RfbW9kZTsKIH07CiAKIHN0YXRpYyB1bnNpZ25lZCBsb25nIHJlbGVhc2VfZnJlZXBhZ2VzKHN0cnVjdCBsaXN0X2hlYWQgKmZyZWVsaXN0KQpAQCAtNjAsNyArNjYsNyBAQAogCQkJCXN0cnVjdCBsaXN0X2hlYWQgKmZyZWVsaXN0KQogewogCXVuc2lnbmVkIGxvbmcgem9uZV9lbmRfcGZuLCBlbmRfcGZuOwotCWludCB0b3RhbF9pc29sYXRlZCA9IDA7CisJaW50IG5yX3NjYW5uZWQgPSAwLCB0b3RhbF9pc29sYXRlZCA9IDA7CiAJc3RydWN0IHBhZ2UgKmN1cnNvcjsKIAogCS8qIEdldCB0aGUgbGFzdCBQRk4gd2Ugc2hvdWxkIHNjYW4gZm9yIGZyZWUgcGFnZXMgYXQgKi8KQEAgLTgxLDYgKzg3LDcgQEAKIAogCQlpZiAoIXBmbl92YWxpZF93aXRoaW4oYmxvY2twZm4pKQogCQkJY29udGludWU7CisJCW5yX3NjYW5uZWQrKzsKIAogCQlpZiAoIVBhZ2VCdWRkeShwYWdlKSkKIAkJCWNvbnRpbnVlOwpAQCAtMTAwLDYgKzEwNyw3IEBACiAJCX0KIAl9CiAKKwl0cmFjZV9tbV9jb21wYWN0aW9uX2lzb2xhdGVfZnJlZXBhZ2VzKG5yX3NjYW5uZWQsIHRvdGFsX2lzb2xhdGVkKTsKIAlyZXR1cm4gdG90YWxfaXNvbGF0ZWQ7CiB9CiAKQEAgLTIzNCw2ICsyNDIsOCBAQAogCQkJCQlzdHJ1Y3QgY29tcGFjdF9jb250cm9sICpjYykKIHsKIAl1bnNpZ25lZCBsb25nIGxvd19wZm4sIGVuZF9wZm47CisJdW5zaWduZWQgbG9uZyBsYXN0X3BhZ2VibG9ja19uciA9IDAsIHBhZ2VibG9ja19ucjsKKwl1bnNpZ25lZCBsb25nIG5yX3NjYW5uZWQgPSAwLCBucl9pc29sYXRlZCA9IDA7CiAJc3RydWN0IGxpc3RfaGVhZCAqbWlncmF0ZWxpc3QgPSAmY2MtPm1pZ3JhdGVwYWdlczsKIAogCS8qIERvIG5vdCBzY2FuIG91dHNpZGUgem9uZSBib3VuZGFyaWVzICovCkBAIC0yNjYsMjAgKzI3Niw1MSBAQAogCQlzdHJ1Y3QgcGFnZSAqcGFnZTsKIAkJaWYgKCFwZm5fdmFsaWRfd2l0aGluKGxvd19wZm4pKQogCQkJY29udGludWU7CisJCW5yX3NjYW5uZWQrKzsKIAogCQkvKiBHZXQgdGhlIHBhZ2UgYW5kIHNraXAgaWYgZnJlZSAqLwogCQlwYWdlID0gcGZuX3RvX3BhZ2UobG93X3Bmbik7CiAJCWlmIChQYWdlQnVkZHkocGFnZSkpCiAJCQljb250aW51ZTsKIAorCQkvKgorCQkgKiBGb3IgYXN5bmMgbWlncmF0aW9uLCBhbHNvIG9ubHkgc2NhbiBpbiBNT1ZBQkxFIGJsb2Nrcy4gQXN5bmMKKwkJICogbWlncmF0aW9uIGlzIG9wdGltaXN0aWMgdG8gc2VlIGlmIHRoZSBtaW5pbXVtIGFtb3VudCBvZiB3b3JrCisJCSAqIHNhdGlzZmllcyB0aGUgYWxsb2NhdGlvbgorCQkgKi8KKwkJcGFnZWJsb2NrX25yID0gbG93X3BmbiA+PiBwYWdlYmxvY2tfb3JkZXI7CisJCWlmICghY2MtPnN5bmMgJiYgbGFzdF9wYWdlYmxvY2tfbnIgIT0gcGFnZWJsb2NrX25yICYmCisJCQkJZ2V0X3BhZ2VibG9ja19taWdyYXRldHlwZShwYWdlKSAhPSBNSUdSQVRFX01PVkFCTEUpIHsKKwkJCWxvd19wZm4gKz0gcGFnZWJsb2NrX25yX3BhZ2VzOworCQkJbG93X3BmbiA9IEFMSUdOKGxvd19wZm4sIHBhZ2VibG9ja19ucl9wYWdlcykgLSAxOworCQkJbGFzdF9wYWdlYmxvY2tfbnIgPSBwYWdlYmxvY2tfbnI7CisJCQljb250aW51ZTsKKwkJfQorCisJCWlmICghUGFnZUxSVShwYWdlKSkKKwkJCWNvbnRpbnVlOworCisJCS8qCisJCSAqIFBhZ2VMUlUgaXMgc2V0LCBhbmQgbHJ1X2xvY2sgZXhjbHVkZXMgaXNvbGF0aW9uLAorCQkgKiBzcGxpdHRpbmcgYW5kIGNvbGxhcHNpbmcgKGNvbGxhcHNpbmcgaGFzIGFscmVhZHkKKwkJICogaGFwcGVuZWQgaWYgUGFnZUxSVSBpcyBzZXQpLgorCQkgKi8KKwkJaWYgKFBhZ2VUcmFuc0h1Z2UocGFnZSkpIHsKKwkJCWxvd19wZm4gKz0gKDEgPDwgY29tcG91bmRfb3JkZXIocGFnZSkpIC0gMTsKKwkJCWNvbnRpbnVlOworCQl9CisKIAkJLyogVHJ5IGlzb2xhdGUgdGhlIHBhZ2UgKi8KIAkJaWYgKF9faXNvbGF0ZV9scnVfcGFnZShwYWdlLCBJU09MQVRFX0JPVEgsIDApICE9IDApCiAJCQljb250aW51ZTsKIAorCQlWTV9CVUdfT04oUGFnZVRyYW5zQ29tcG91bmQocGFnZSkpOworCiAJCS8qIFN1Y2Nlc3NmdWxseSBpc29sYXRlZCAqLwogCQlkZWxfcGFnZV9mcm9tX2xydV9saXN0KHpvbmUsIHBhZ2UsIHBhZ2VfbHJ1KHBhZ2UpKTsKIAkJbGlzdF9hZGQoJnBhZ2UtPmxydSwgbWlncmF0ZWxpc3QpOwogCQljYy0+bnJfbWlncmF0ZXBhZ2VzKys7CisJCW5yX2lzb2xhdGVkKys7CiAKIAkJLyogQXZvaWQgaXNvbGF0aW5nIHRvbyBtdWNoICovCiAJCWlmIChjYy0+bnJfbWlncmF0ZXBhZ2VzID09IENPTVBBQ1RfQ0xVU1RFUl9NQVgpCkBAIC0yOTEsNiArMzMyLDggQEAKIAlzcGluX3VubG9ja19pcnEoJnpvbmUtPmxydV9sb2NrKTsKIAljYy0+bWlncmF0ZV9wZm4gPSBsb3dfcGZuOwogCisJdHJhY2VfbW1fY29tcGFjdGlvbl9pc29sYXRlX21pZ3JhdGVwYWdlcyhucl9zY2FubmVkLCBucl9pc29sYXRlZCk7CisKIAlyZXR1cm4gY2MtPm5yX21pZ3JhdGVwYWdlczsKIH0KIApAQCAtMzQxLDEwICszODQsMTAgQEAKIH0KIAogc3RhdGljIGludCBjb21wYWN0X2ZpbmlzaGVkKHN0cnVjdCB6b25lICp6b25lLAotCQkJCQkJc3RydWN0IGNvbXBhY3RfY29udHJvbCAqY2MpCisJCQkgICAgc3RydWN0IGNvbXBhY3RfY29udHJvbCAqY2MpCiB7CiAJdW5zaWduZWQgaW50IG9yZGVyOwotCXVuc2lnbmVkIGxvbmcgd2F0ZXJtYXJrID0gbG93X3dtYXJrX3BhZ2VzKHpvbmUpICsgKDEgPDwgY2MtPm9yZGVyKTsKKwl1bnNpZ25lZCBsb25nIHdhdGVybWFyazsKIAogCWlmIChmYXRhbF9zaWduYWxfcGVuZGluZyhjdXJyZW50KSkKIAkJcmV0dXJuIENPTVBBQ1RfUEFSVElBTDsKQEAgLTM1NCwxMiArMzk3LDMxIEBACiAJCXJldHVybiBDT01QQUNUX0NPTVBMRVRFOwogCiAJLyogQ29tcGFjdGlvbiBydW4gaXMgbm90IGZpbmlzaGVkIGlmIHRoZSB3YXRlcm1hcmsgaXMgbm90IG1ldCAqLworCWlmIChjYy0+Y29tcGFjdF9tb2RlICE9IENPTVBBQ1RfTU9ERV9LU1dBUEQpCisJCXdhdGVybWFyayA9IGxvd193bWFya19wYWdlcyh6b25lKTsKKwllbHNlCisJCXdhdGVybWFyayA9IGhpZ2hfd21hcmtfcGFnZXMoem9uZSk7CisJd2F0ZXJtYXJrICs9ICgxIDw8IGNjLT5vcmRlcik7CisKIAlpZiAoIXpvbmVfd2F0ZXJtYXJrX29rKHpvbmUsIGNjLT5vcmRlciwgd2F0ZXJtYXJrLCAwLCAwKSkKIAkJcmV0dXJuIENPTVBBQ1RfQ09OVElOVUU7CiAKKwkvKgorCSAqIG9yZGVyID09IC0xIGlzIGV4cGVjdGVkIHdoZW4gY29tcGFjdGluZyB2aWEKKwkgKiAvcHJvYy9zeXMvdm0vY29tcGFjdF9tZW1vcnkKKwkgKi8KIAlpZiAoY2MtPm9yZGVyID09IC0xKQogCQlyZXR1cm4gQ09NUEFDVF9DT05USU5VRTsKIAorCS8qCisJICogR2VuZXJhdGluZyBvbmx5IG9uZSBwYWdlIG9mIHRoZSByaWdodCBvcmRlciBpcyBub3QgZW5vdWdoCisJICogZm9yIGtzd2FwZCwgd2UgbXVzdCBjb250aW51ZSB1bnRpbCB3ZSdyZSBhYm92ZSB0aGUgaGlnaAorCSAqIHdhdGVybWFyayBhcyBhIHBvb2wgZm9yIGhpZ2ggb3JkZXIgR0ZQX0FUT01JQyBhbGxvY2F0aW9ucworCSAqIHRvby4KKwkgKi8KKwlpZiAoY2MtPmNvbXBhY3RfbW9kZSA9PSBDT01QQUNUX01PREVfS1NXQVBEKQorCQlyZXR1cm4gQ09NUEFDVF9DT05USU5VRTsKKwogCS8qIERpcmVjdCBjb21wYWN0b3I6IElzIGEgc3VpdGFibGUgcGFnZSBmcmVlPyAqLwogCWZvciAob3JkZXIgPSBjYy0+b3JkZXI7IG9yZGVyIDwgTUFYX09SREVSOyBvcmRlcisrKSB7CiAJCS8qIEpvYiBkb25lIGlmIHBhZ2UgaXMgZnJlZSBvZiB0aGUgcmlnaHQgbWlncmF0ZXR5cGUgKi8KQEAgLTM3NCwxMCArNDM2LDY5IEBACiAJcmV0dXJuIENPTVBBQ1RfQ09OVElOVUU7CiB9CiAKKy8qCisgKiBjb21wYWN0aW9uX3N1aXRhYmxlOiBJcyB0aGlzIHN1aXRhYmxlIHRvIHJ1biBjb21wYWN0aW9uIG9uIHRoaXMgem9uZSBub3c/CisgKiBSZXR1cm5zCisgKiAgIENPTVBBQ1RfU0tJUFBFRCAgLSBJZiB0aGVyZSBhcmUgdG9vIGZldyBmcmVlIHBhZ2VzIGZvciBjb21wYWN0aW9uCisgKiAgIENPTVBBQ1RfUEFSVElBTCAgLSBJZiB0aGUgYWxsb2NhdGlvbiB3b3VsZCBzdWNjZWVkIHdpdGhvdXQgY29tcGFjdGlvbgorICogICBDT01QQUNUX0NPTlRJTlVFIC0gSWYgY29tcGFjdGlvbiBzaG91bGQgcnVuIG5vdworICovCit1bnNpZ25lZCBsb25nIGNvbXBhY3Rpb25fc3VpdGFibGUoc3RydWN0IHpvbmUgKnpvbmUsIGludCBvcmRlcikKK3sKKwlpbnQgZnJhZ2luZGV4OworCXVuc2lnbmVkIGxvbmcgd2F0ZXJtYXJrOworCisJLyoKKwkgKiBXYXRlcm1hcmtzIGZvciBvcmRlci0wIG11c3QgYmUgbWV0IGZvciBjb21wYWN0aW9uLiBOb3RlIHRoZSAyVUwuCisJICogVGhpcyBpcyBiZWNhdXNlIGR1cmluZyBtaWdyYXRpb24sIGNvcGllcyBvZiBwYWdlcyBuZWVkIHRvIGJlCisJICogYWxsb2NhdGVkIGFuZCBmb3IgYSBzaG9ydCB0aW1lLCB0aGUgZm9vdHByaW50IGlzIGhpZ2hlcgorCSAqLworCXdhdGVybWFyayA9IGxvd193bWFya19wYWdlcyh6b25lKSArICgyVUwgPDwgb3JkZXIpOworCWlmICghem9uZV93YXRlcm1hcmtfb2soem9uZSwgMCwgd2F0ZXJtYXJrLCAwLCAwKSkKKwkJcmV0dXJuIENPTVBBQ1RfU0tJUFBFRDsKKworCS8qCisJICogb3JkZXIgPT0gLTEgaXMgZXhwZWN0ZWQgd2hlbiBjb21wYWN0aW5nIHZpYQorCSAqIC9wcm9jL3N5cy92bS9jb21wYWN0X21lbW9yeQorCSAqLworCWlmIChvcmRlciA9PSAtMSkKKwkJcmV0dXJuIENPTVBBQ1RfQ09OVElOVUU7CisKKwkvKgorCSAqIGZyYWdtZW50YXRpb24gaW5kZXggZGV0ZXJtaW5lcyBpZiBhbGxvY2F0aW9uIGZhaWx1cmVzIGFyZSBkdWUgdG8KKwkgKiBsb3cgbWVtb3J5IG9yIGV4dGVybmFsIGZyYWdtZW50YXRpb24KKwkgKgorCSAqIGluZGV4IG9mIC0xIGltcGxpZXMgYWxsb2NhdGlvbnMgbWlnaHQgc3VjY2VlZCBkZXBlbmRpbmdvbiB3YXRlcm1hcmtzCisJICogaW5kZXggdG93YXJkcyAwIGltcGxpZXMgZmFpbHVyZSBpcyBkdWUgdG8gbGFjayBvZiBtZW1vcnkKKwkgKiBpbmRleCB0b3dhcmRzIDEwMDAgaW1wbGllcyBmYWlsdXJlIGlzIGR1ZSB0byBmcmFnbWVudGF0aW9uCisJICoKKwkgKiBPbmx5IGNvbXBhY3QgaWYgYSBmYWlsdXJlIHdvdWxkIGJlIGR1ZSB0byBmcmFnbWVudGF0aW9uLgorCSAqLworCWZyYWdpbmRleCA9IGZyYWdtZW50YXRpb25faW5kZXgoem9uZSwgb3JkZXIpOworCWlmIChmcmFnaW5kZXggPj0gMCAmJiBmcmFnaW5kZXggPD0gc3lzY3RsX2V4dGZyYWdfdGhyZXNob2xkKQorCQlyZXR1cm4gQ09NUEFDVF9TS0lQUEVEOworCisJaWYgKGZyYWdpbmRleCA9PSAtMSAmJiB6b25lX3dhdGVybWFya19vayh6b25lLCBvcmRlciwgd2F0ZXJtYXJrLCAwLCAwKSkKKwkJcmV0dXJuIENPTVBBQ1RfUEFSVElBTDsKKworCXJldHVybiBDT01QQUNUX0NPTlRJTlVFOworfQorCiBzdGF0aWMgaW50IGNvbXBhY3Rfem9uZShzdHJ1Y3Qgem9uZSAqem9uZSwgc3RydWN0IGNvbXBhY3RfY29udHJvbCAqY2MpCiB7CiAJaW50IHJldDsKIAorCXJldCA9IGNvbXBhY3Rpb25fc3VpdGFibGUoem9uZSwgY2MtPm9yZGVyKTsKKwlzd2l0Y2ggKHJldCkgeworCWNhc2UgQ09NUEFDVF9QQVJUSUFMOgorCWNhc2UgQ09NUEFDVF9TS0lQUEVEOgorCQkvKiBDb21wYWN0aW9uIGlzIGxpa2VseSB0byBmYWlsICovCisJCXJldHVybiByZXQ7CisJY2FzZSBDT01QQUNUX0NPTlRJTlVFOgorCQkvKiBGYWxsIHRocm91Z2ggdG8gY29tcGFjdGlvbiAqLworCQk7CisJfQorCiAJLyogU2V0dXAgdG8gbW92ZSBhbGwgbW92YWJsZSBwYWdlcyB0byB0aGUgZW5kIG9mIHRoZSB6b25lICovCiAJY2MtPm1pZ3JhdGVfcGZuID0gem9uZS0+em9uZV9zdGFydF9wZm47CiAJY2MtPmZyZWVfcGZuID0gY2MtPm1pZ3JhdGVfcGZuICsgem9uZS0+c3Bhbm5lZF9wYWdlczsKQEAgLTM5Myw3ICs1MTQsOCBAQAogCiAJCW5yX21pZ3JhdGUgPSBjYy0+bnJfbWlncmF0ZXBhZ2VzOwogCQltaWdyYXRlX3BhZ2VzKCZjYy0+bWlncmF0ZXBhZ2VzLCBjb21wYWN0aW9uX2FsbG9jLAotCQkJCQkJKHVuc2lnbmVkIGxvbmcpY2MsIDApOworCQkJCSh1bnNpZ25lZCBsb25nKWNjLCBmYWxzZSwKKwkJCQljYy0+c3luYyk7CiAJCXVwZGF0ZV9ucl9saXN0cGFnZXMoY2MpOwogCQlucl9yZW1haW5pbmcgPSBjYy0+bnJfbWlncmF0ZXBhZ2VzOwogCkBAIC00MDEsNiArNTIzLDggQEAKIAkJY291bnRfdm1fZXZlbnRzKENPTVBBQ1RQQUdFUywgbnJfbWlncmF0ZSAtIG5yX3JlbWFpbmluZyk7CiAJCWlmIChucl9yZW1haW5pbmcpCiAJCQljb3VudF92bV9ldmVudHMoQ09NUEFDVFBBR0VGQUlMRUQsIG5yX3JlbWFpbmluZyk7CisJCXRyYWNlX21tX2NvbXBhY3Rpb25fbWlncmF0ZXBhZ2VzKG5yX21pZ3JhdGUgLSBucl9yZW1haW5pbmcsCisJCQkJCQlucl9yZW1haW5pbmcpOwogCiAJCS8qIFJlbGVhc2UgTFJVIHBhZ2VzIG5vdCBtaWdyYXRlZCAqLwogCQlpZiAoIWxpc3RfZW1wdHkoJmNjLT5taWdyYXRlcGFnZXMpKSB7CkBAIC00MTcsOCArNTQxLDEwIEBACiAJcmV0dXJuIHJldDsKIH0KIAotc3RhdGljIHVuc2lnbmVkIGxvbmcgY29tcGFjdF96b25lX29yZGVyKHN0cnVjdCB6b25lICp6b25lLAotCQkJCQkJaW50IG9yZGVyLCBnZnBfdCBnZnBfbWFzaykKK3Vuc2lnbmVkIGxvbmcgY29tcGFjdF96b25lX29yZGVyKHN0cnVjdCB6b25lICp6b25lLAorCQkJCSBpbnQgb3JkZXIsIGdmcF90IGdmcF9tYXNrLAorCQkJCSBib29sIHN5bmMsCisJCQkJIGludCBjb21wYWN0X21vZGUpCiB7CiAJc3RydWN0IGNvbXBhY3RfY29udHJvbCBjYyA9IHsKIAkJLm5yX2ZyZWVwYWdlcyA9IDAsCkBAIC00MjYsNiArNTUyLDggQEAKIAkJLm9yZGVyID0gb3JkZXIsCiAJCS5taWdyYXRldHlwZSA9IGFsbG9jZmxhZ3NfdG9fbWlncmF0ZXR5cGUoZ2ZwX21hc2spLAogCQkuem9uZSA9IHpvbmUsCisJCS5zeW5jID0gc3luYywKKwkJLmNvbXBhY3RfbW9kZSA9IGNvbXBhY3RfbW9kZSwKIAl9OwogCUlOSVRfTElTVF9IRUFEKCZjYy5mcmVlcGFnZXMpOwogCUlOSVRfTElTVF9IRUFEKCZjYy5taWdyYXRlcGFnZXMpOwpAQCAtNDQxLDE2ICs1NjksMTcgQEAKICAqIEBvcmRlcjogVGhlIG9yZGVyIG9mIHRoZSBjdXJyZW50IGFsbG9jYXRpb24KICAqIEBnZnBfbWFzazogVGhlIEdGUCBtYXNrIG9mIHRoZSBjdXJyZW50IGFsbG9jYXRpb24KICAqIEBub2RlbWFzazogVGhlIGFsbG93ZWQgbm9kZXMgdG8gYWxsb2NhdGUgZnJvbQorICogQHN5bmM6IFdoZXRoZXIgbWlncmF0aW9uIGlzIHN5bmNocm9ub3VzIG9yIG5vdAogICoKICAqIFRoaXMgaXMgdGhlIG1haW4gZW50cnkgcG9pbnQgZm9yIGRpcmVjdCBwYWdlIGNvbXBhY3Rpb24uCiAgKi8KIHVuc2lnbmVkIGxvbmcgdHJ5X3RvX2NvbXBhY3RfcGFnZXMoc3RydWN0IHpvbmVsaXN0ICp6b25lbGlzdCwKLQkJCWludCBvcmRlciwgZ2ZwX3QgZ2ZwX21hc2ssIG5vZGVtYXNrX3QgKm5vZGVtYXNrKQorCQkJaW50IG9yZGVyLCBnZnBfdCBnZnBfbWFzaywgbm9kZW1hc2tfdCAqbm9kZW1hc2ssCisJCQlib29sIHN5bmMpCiB7CiAJZW51bSB6b25lX3R5cGUgaGlnaF96b25laWR4ID0gZ2ZwX3pvbmUoZ2ZwX21hc2spOwogCWludCBtYXlfZW50ZXJfZnMgPSBnZnBfbWFzayAmIF9fR0ZQX0ZTOwogCWludCBtYXlfcGVyZm9ybV9pbyA9IGdmcF9tYXNrICYgX19HRlBfSU87Ci0JdW5zaWduZWQgbG9uZyB3YXRlcm1hcms7CiAJc3RydWN0IHpvbmVyZWYgKno7CiAJc3RydWN0IHpvbmUgKnpvbmU7CiAJaW50IHJjID0gQ09NUEFDVF9TS0lQUEVEOwpAQCAtNDYwLDcgKzU4OSw3IEBACiAJICogbWFkZSBiZWNhdXNlIGFuIGFzc3VtcHRpb24gaXMgbWFkZSB0aGF0IHRoZSBwYWdlIGFsbG9jYXRvciBjYW4gc2F0aXNmeQogCSAqIHRoZSAiY2hlYXBlciIgb3JkZXJzIHdpdGhvdXQgdGFraW5nIHNwZWNpYWwgc3RlcHMKIAkgKi8KLQlpZiAob3JkZXIgPD0gUEFHRV9BTExPQ19DT1NUTFlfT1JERVIgfHwgIW1heV9lbnRlcl9mcyB8fCAhbWF5X3BlcmZvcm1faW8pCisJaWYgKCFvcmRlciB8fCAhbWF5X2VudGVyX2ZzIHx8ICFtYXlfcGVyZm9ybV9pbykKIAkJcmV0dXJuIHJjOwogCiAJY291bnRfdm1fZXZlbnQoQ09NUEFDVFNUQUxMKTsKQEAgLTQ2OCw0MyArNTk3LDE0IEBACiAJLyogQ29tcGFjdCBlYWNoIHpvbmUgaW4gdGhlIGxpc3QgKi8KIAlmb3JfZWFjaF96b25lX3pvbmVsaXN0X25vZGVtYXNrKHpvbmUsIHosIHpvbmVsaXN0LCBoaWdoX3pvbmVpZHgsCiAJCQkJCQkJCW5vZGVtYXNrKSB7Ci0JCWludCBmcmFnaW5kZXg7CiAJCWludCBzdGF0dXM7CiAKLQkJLyoKLQkJICogV2F0ZXJtYXJrcyBmb3Igb3JkZXItMCBtdXN0IGJlIG1ldCBmb3IgY29tcGFjdGlvbi4gTm90ZQotCQkgKiB0aGUgMlVMLiBUaGlzIGlzIGJlY2F1c2UgZHVyaW5nIG1pZ3JhdGlvbiwgY29waWVzIG9mCi0JCSAqIHBhZ2VzIG5lZWQgdG8gYmUgYWxsb2NhdGVkIGFuZCBmb3IgYSBzaG9ydCB0aW1lLCB0aGUKLQkJICogZm9vdHByaW50IGlzIGhpZ2hlcgotCQkgKi8KLQkJd2F0ZXJtYXJrID0gbG93X3dtYXJrX3BhZ2VzKHpvbmUpICsgKDJVTCA8PCBvcmRlcik7Ci0JCWlmICghem9uZV93YXRlcm1hcmtfb2soem9uZSwgMCwgd2F0ZXJtYXJrLCAwLCAwKSkKLQkJCWNvbnRpbnVlOwotCi0JCS8qCi0JCSAqIGZyYWdtZW50YXRpb24gaW5kZXggZGV0ZXJtaW5lcyBpZiBhbGxvY2F0aW9uIGZhaWx1cmVzIGFyZQotCQkgKiBkdWUgdG8gbG93IG1lbW9yeSBvciBleHRlcm5hbCBmcmFnbWVudGF0aW9uCi0JCSAqCi0JCSAqIGluZGV4IG9mIC0xIGltcGxpZXMgYWxsb2NhdGlvbnMgbWlnaHQgc3VjY2VlZCBkZXBlbmRpbmcKLQkJICogCW9uIHdhdGVybWFya3MKLQkJICogaW5kZXggdG93YXJkcyAwIGltcGxpZXMgZmFpbHVyZSBpcyBkdWUgdG8gbGFjayBvZiBtZW1vcnkKLQkJICogaW5kZXggdG93YXJkcyAxMDAwIGltcGxpZXMgZmFpbHVyZSBpcyBkdWUgdG8gZnJhZ21lbnRhdGlvbgotCQkgKgotCQkgKiBPbmx5IGNvbXBhY3QgaWYgYSBmYWlsdXJlIHdvdWxkIGJlIGR1ZSB0byBmcmFnbWVudGF0aW9uLgotCQkgKi8KLQkJZnJhZ2luZGV4ID0gZnJhZ21lbnRhdGlvbl9pbmRleCh6b25lLCBvcmRlcik7Ci0JCWlmIChmcmFnaW5kZXggPj0gMCAmJiBmcmFnaW5kZXggPD0gc3lzY3RsX2V4dGZyYWdfdGhyZXNob2xkKQotCQkJY29udGludWU7Ci0KLQkJaWYgKGZyYWdpbmRleCA9PSAtMSAmJiB6b25lX3dhdGVybWFya19vayh6b25lLCBvcmRlciwgd2F0ZXJtYXJrLCAwLCAwKSkgewotCQkJcmMgPSBDT01QQUNUX1BBUlRJQUw7Ci0JCQlicmVhazsKLQkJfQotCi0JCXN0YXR1cyA9IGNvbXBhY3Rfem9uZV9vcmRlcih6b25lLCBvcmRlciwgZ2ZwX21hc2spOworCQlzdGF0dXMgPSBjb21wYWN0X3pvbmVfb3JkZXIoem9uZSwgb3JkZXIsIGdmcF9tYXNrLCBzeW5jLAorCQkJCQkgICAgQ09NUEFDVF9NT0RFX0RJUkVDVF9SRUNMQUlNKTsKIAkJcmMgPSBtYXgoc3RhdHVzLCByYyk7CiAKLQkJaWYgKHpvbmVfd2F0ZXJtYXJrX29rKHpvbmUsIG9yZGVyLCB3YXRlcm1hcmssIDAsIDApKQorCQkvKiBJZiBhIG5vcm1hbCBhbGxvY2F0aW9uIHdvdWxkIHN1Y2NlZWQsIHN0b3AgY29tcGFjdGluZyAqLworCQlpZiAoem9uZV93YXRlcm1hcmtfb2soem9uZSwgb3JkZXIsIGxvd193bWFya19wYWdlcyh6b25lKSwgMCwgMCkpCiAJCQlicmVhazsKIAl9CiAKQEAgLTUzMSw2ICs2MzEsNyBAQAogCQkJLm5yX2ZyZWVwYWdlcyA9IDAsCiAJCQkubnJfbWlncmF0ZXBhZ2VzID0gMCwKIAkJCS5vcmRlciA9IC0xLAorCQkJLmNvbXBhY3RfbW9kZSA9IENPTVBBQ1RfTU9ERV9ESVJFQ1RfUkVDTEFJTSwKIAkJfTsKIAogCQl6b25lID0gJnBnZGF0LT5ub2RlX3pvbmVzW3pvbmVpZF07CmRpZmYgLS1naXQgYS9tbS9kbWFwb29sLmMgYi9tbS9kbWFwb29sLmMKaW5kZXggNGRmMmRlNy4uMDNiZjNiYiAxMDA2NDQKLS0tIGEvbW0vZG1hcG9vbC5jCisrKyBiL21tL2RtYXBvb2wuYwpAQCAtMzI0LDcgKzMyNCw3IEBACiAJCWlmIChtZW1fZmxhZ3MgJiBfX0dGUF9XQUlUKSB7CiAJCQlERUNMQVJFX1dBSVRRVUVVRSh3YWl0LCBjdXJyZW50KTsKIAotCQkJX19zZXRfY3VycmVudF9zdGF0ZShUQVNLX0lOVEVSUlVQVElCTEUpOworCQkJX19zZXRfY3VycmVudF9zdGF0ZShUQVNLX1VOSU5URVJSVVBUSUJMRSk7CiAJCQlfX2FkZF93YWl0X3F1ZXVlKCZwb29sLT53YWl0cSwgJndhaXQpOwogCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcG9vbC0+bG9jaywgZmxhZ3MpOwogCkBAIC0zNTUsMjAgKzM1NSwxNSBAQAogCiBzdGF0aWMgc3RydWN0IGRtYV9wYWdlICpwb29sX2ZpbmRfcGFnZShzdHJ1Y3QgZG1hX3Bvb2wgKnBvb2wsIGRtYV9hZGRyX3QgZG1hKQogewotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJc3RydWN0IGRtYV9wYWdlICpwYWdlOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJnBvb2wtPmxvY2ssIGZsYWdzKTsKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KHBhZ2UsICZwb29sLT5wYWdlX2xpc3QsIHBhZ2VfbGlzdCkgewogCQlpZiAoZG1hIDwgcGFnZS0+ZG1hKQogCQkJY29udGludWU7CiAJCWlmIChkbWEgPCAocGFnZS0+ZG1hICsgcG9vbC0+YWxsb2NhdGlvbikpCi0JCQlnb3RvIGRvbmU7CisJCQlyZXR1cm4gcGFnZTsKIAl9Ci0JcGFnZSA9IE5VTEw7Ci0gZG9uZToKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwb29sLT5sb2NrLCBmbGFncyk7Ci0JcmV0dXJuIHBhZ2U7CisJcmV0dXJuIE5VTEw7CiB9CiAKIC8qKgpAQCAtMzg2LDggKzM4MSwxMCBAQAogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJdW5zaWduZWQgaW50IG9mZnNldDsKIAorCXNwaW5fbG9ja19pcnFzYXZlKCZwb29sLT5sb2NrLCBmbGFncyk7CiAJcGFnZSA9IHBvb2xfZmluZF9wYWdlKHBvb2wsIGRtYSk7CiAJaWYgKCFwYWdlKSB7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBvb2wtPmxvY2ssIGZsYWdzKTsKIAkJaWYgKHBvb2wtPmRldikKIAkJCWRldl9lcnIocG9vbC0+ZGV2LAogCQkJCSJkbWFfcG9vbF9mcmVlICVzLCAlcC8lbHggKGJhZCBkbWEpXG4iLApAQCAtNDAxLDYgKzM5OCw3IEBACiAJb2Zmc2V0ID0gdmFkZHIgLSBwYWdlLT52YWRkcjsKICNpZmRlZglETUFQT09MX0RFQlVHCiAJaWYgKChkbWEgLSBwYWdlLT5kbWEpICE9IG9mZnNldCkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwb29sLT5sb2NrLCBmbGFncyk7CiAJCWlmIChwb29sLT5kZXYpCiAJCQlkZXZfZXJyKHBvb2wtPmRldiwKIAkJCQkiZG1hX3Bvb2xfZnJlZSAlcywgJXAgKGJhZCB2YWRkcikvJUx4XG4iLApAQCAtNDE4LDYgKzQxNiw3IEBACiAJCQkJY2hhaW4gPSAqKGludCAqKShwYWdlLT52YWRkciArIGNoYWluKTsKIAkJCQljb250aW51ZTsKIAkJCX0KKwkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBvb2wtPmxvY2ssIGZsYWdzKTsKIAkJCWlmIChwb29sLT5kZXYpCiAJCQkJZGV2X2Vycihwb29sLT5kZXYsICJkbWFfcG9vbF9mcmVlICVzLCBkbWEgJUx4ICIKIAkJCQkJImFscmVhZHkgZnJlZVxuIiwgcG9vbC0+bmFtZSwKQEAgLTQzMiw3ICs0MzEsNiBAQAogCW1lbXNldCh2YWRkciwgUE9PTF9QT0lTT05fRlJFRUQsIHBvb2wtPnNpemUpOwogI2VuZGlmCiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmcG9vbC0+bG9jaywgZmxhZ3MpOwogCXBhZ2UtPmluX3VzZS0tOwogCSooaW50ICopdmFkZHIgPSBwYWdlLT5vZmZzZXQ7CiAJcGFnZS0+b2Zmc2V0ID0gb2Zmc2V0OwpkaWZmIC0tZ2l0IGEvbW0vZmlsZW1hcC5jIGIvbW0vZmlsZW1hcC5jCmluZGV4IGNhMzg5MzkuLjgzYTQ1ZDMgMTAwNjQ0Ci0tLSBhL21tL2ZpbGVtYXAuYworKysgYi9tbS9maWxlbWFwLmMKQEAgLTI5OCw3ICsyOTgsNyBAQAogCQkJCWNvbnRpbnVlOwogCiAJCQl3YWl0X29uX3BhZ2Vfd3JpdGViYWNrKHBhZ2UpOwotCQkJaWYgKFBhZ2VFcnJvcihwYWdlKSkKKwkJCWlmIChUZXN0Q2xlYXJQYWdlRXJyb3IocGFnZSkpCiAJCQkJcmV0ID0gLUVJTzsKIAkJfQogCQlwYWdldmVjX3JlbGVhc2UoJnB2ZWMpOwpAQCAtODM3LDkgKzgzNyw2IEBACiAJCWlmIChyYWRpeF90cmVlX2RlcmVmX3JldHJ5KHBhZ2UpKQogCQkJZ290byByZXN0YXJ0OwogCi0JCWlmIChwYWdlLT5tYXBwaW5nID09IE5VTEwgfHwgcGFnZS0+aW5kZXggIT0gaW5kZXgpCi0JCQlicmVhazsKLQogCQlpZiAoIXBhZ2VfY2FjaGVfZ2V0X3NwZWN1bGF0aXZlKHBhZ2UpKQogCQkJZ290byByZXBlYXQ7CiAKQEAgLTg0OSw2ICs4NDYsMTYgQEAKIAkJCWdvdG8gcmVwZWF0OwogCQl9CiAKKwkJLyoKKwkJICogbXVzdCBjaGVjayBtYXBwaW5nIGFuZCBpbmRleCBhZnRlciB0YWtpbmcgdGhlIHJlZi4KKwkJICogb3RoZXJ3aXNlIHdlIGNhbiBnZXQgYm90aCBmYWxzZSBwb3NpdGl2ZXMgYW5kIGZhbHNlCisJCSAqIG5lZ2F0aXZlcywgd2hpY2ggaXMganVzdCBjb25mdXNpbmcgdG8gdGhlIGNhbGxlci4KKwkJICovCisJCWlmIChwYWdlLT5tYXBwaW5nID09IE5VTEwgfHwgcGFnZS0+aW5kZXggIT0gaW5kZXgpIHsKKwkJCXBhZ2VfY2FjaGVfcmVsZWFzZShwYWdlKTsKKwkJCWJyZWFrOworCQl9CisKIAkJcGFnZXNbcmV0XSA9IHBhZ2U7CiAJCXJldCsrOwogCQlpbmRleCsrOwpAQCAtMjIyMCw3ICsyMjI3LDcgQEAKIAkJZ2ZwX25vdG1hc2sgPSBfX0dGUF9GUzsKIHJlcGVhdDoKIAlwYWdlID0gZmluZF9sb2NrX3BhZ2UobWFwcGluZywgaW5kZXgpOwotCWlmIChsaWtlbHkocGFnZSkpCisJaWYgKHBhZ2UpCiAJCXJldHVybiBwYWdlOwogCiAJcGFnZSA9IF9fcGFnZV9jYWNoZV9hbGxvYyhtYXBwaW5nX2dmcF9tYXNrKG1hcHBpbmcpICYgfmdmcF9ub3RtYXNrKTsKZGlmZiAtLWdpdCBhL21tL2h1Z2VfbWVtb3J5LmMgYi9tbS9odWdlX21lbW9yeS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmU2MmRkYjgKLS0tIC9kZXYvbnVsbAorKysgYi9tbS9odWdlX21lbW9yeS5jCkBAIC0wLDAgKzEsMjM1NCBAQAorLyoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMDkgIFJlZCBIYXQsIEluYy4KKyAqCisgKiAgVGhpcyB3b3JrIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdQTCwgdmVyc2lvbiAyLiBTZWUKKyAqICB0aGUgQ09QWUlORyBmaWxlIGluIHRoZSB0b3AtbGV2ZWwgZGlyZWN0b3J5LgorICovCisKKyNpbmNsdWRlIDxsaW51eC9tbS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CisjaW5jbHVkZSA8bGludXgvaGlnaG1lbS5oPgorI2luY2x1ZGUgPGxpbnV4L2h1Z2V0bGIuaD4KKyNpbmNsdWRlIDxsaW51eC9tbXVfbm90aWZpZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9ybWFwLmg+CisjaW5jbHVkZSA8bGludXgvc3dhcC5oPgorI2luY2x1ZGUgPGxpbnV4L21tX2lubGluZS5oPgorI2luY2x1ZGUgPGxpbnV4L2t0aHJlYWQuaD4KKyNpbmNsdWRlIDxsaW51eC9raHVnZXBhZ2VkLmg+CisjaW5jbHVkZSA8bGludXgvZnJlZXplci5oPgorI2luY2x1ZGUgPGxpbnV4L21tYW4uaD4KKyNpbmNsdWRlIDxhc20vdGxiLmg+CisjaW5jbHVkZSA8YXNtL3BnYWxsb2MuaD4KKyNpbmNsdWRlICJpbnRlcm5hbC5oIgorCisvKgorICogQnkgZGVmYXVsdCB0cmFuc3BhcmVudCBodWdlcGFnZSBzdXBwb3J0IGlzIGVuYWJsZWQgZm9yIGFsbCBtYXBwaW5ncworICogYW5kIGtodWdlcGFnZWQgc2NhbnMgYWxsIG1hcHBpbmdzLiBEZWZyYWcgaXMgb25seSBpbnZva2VkIGJ5CisgKiBraHVnZXBhZ2VkIGh1Z2VwYWdlIGFsbG9jYXRpb25zIGFuZCBieSBwYWdlIGZhdWx0cyBpbnNpZGUKKyAqIE1BRFZfSFVHRVBBR0UgcmVnaW9ucyB0byBhdm9pZCB0aGUgcmlzayBvZiBzbG93aW5nIGRvd24gc2hvcnQgbGl2ZWQKKyAqIGFsbG9jYXRpb25zLgorICovCit1bnNpZ25lZCBsb25nIHRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzIF9fcmVhZF9tb3N0bHkgPQorI2lmZGVmIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRV9BTFdBWVMKKwkoMTw8VFJBTlNQQVJFTlRfSFVHRVBBR0VfRkxBRyl8CisjZW5kaWYKKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0VfTUFEVklTRQorCSgxPDxUUkFOU1BBUkVOVF9IVUdFUEFHRV9SRVFfTUFEVl9GTEFHKXwKKyNlbmRpZgorCSgxPDxUUkFOU1BBUkVOVF9IVUdFUEFHRV9ERUZSQUdfRkxBRyl8CisJKDE8PFRSQU5TUEFSRU5UX0hVR0VQQUdFX0RFRlJBR19LSFVHRVBBR0VEX0ZMQUcpOworCisvKiBkZWZhdWx0IHNjYW4gOCo1MTIgcHRlIChvciB2bWFzKSBldmVyeSAzMCBzZWNvbmQgKi8KK3N0YXRpYyB1bnNpZ25lZCBpbnQga2h1Z2VwYWdlZF9wYWdlc190b19zY2FuIF9fcmVhZF9tb3N0bHkgPSBIUEFHRV9QTURfTlIqODsKK3N0YXRpYyB1bnNpZ25lZCBpbnQga2h1Z2VwYWdlZF9wYWdlc19jb2xsYXBzZWQ7CitzdGF0aWMgdW5zaWduZWQgaW50IGtodWdlcGFnZWRfZnVsbF9zY2FuczsKK3N0YXRpYyB1bnNpZ25lZCBpbnQga2h1Z2VwYWdlZF9zY2FuX3NsZWVwX21pbGxpc2VjcyBfX3JlYWRfbW9zdGx5ID0gMTAwMDA7CisvKiBkdXJpbmcgZnJhZ21lbnRhdGlvbiBwb2xsIHRoZSBodWdlcGFnZSBhbGxvY2F0b3Igb25jZSBldmVyeSBtaW51dGUgKi8KK3N0YXRpYyB1bnNpZ25lZCBpbnQga2h1Z2VwYWdlZF9hbGxvY19zbGVlcF9taWxsaXNlY3MgX19yZWFkX21vc3RseSA9IDYwMDAwOworc3RhdGljIHN0cnVjdCB0YXNrX3N0cnVjdCAqa2h1Z2VwYWdlZF90aHJlYWQgX19yZWFkX21vc3RseTsKK3N0YXRpYyBERUZJTkVfTVVURVgoa2h1Z2VwYWdlZF9tdXRleCk7CitzdGF0aWMgREVGSU5FX1NQSU5MT0NLKGtodWdlcGFnZWRfbW1fbG9jayk7CitzdGF0aWMgREVDTEFSRV9XQUlUX1FVRVVFX0hFQUQoa2h1Z2VwYWdlZF93YWl0KTsKKy8qCisgKiBkZWZhdWx0IGNvbGxhcHNlIGh1Z2VwYWdlcyBpZiB0aGVyZSBpcyBhdCBsZWFzdCBvbmUgcHRlIG1hcHBlZCBsaWtlCisgKiBpdCB3b3VsZCBoYXZlIGhhcHBlbmVkIGlmIHRoZSB2bWEgd2FzIGxhcmdlIGVub3VnaCBkdXJpbmcgcGFnZQorICogZmF1bHQuCisgKi8KK3N0YXRpYyB1bnNpZ25lZCBpbnQga2h1Z2VwYWdlZF9tYXhfcHRlc19ub25lIF9fcmVhZF9tb3N0bHkgPSBIUEFHRV9QTURfTlItMTsKKworc3RhdGljIGludCBraHVnZXBhZ2VkKHZvaWQgKm5vbmUpOworc3RhdGljIGludCBtbV9zbG90c19oYXNoX2luaXQodm9pZCk7CitzdGF0aWMgaW50IGtodWdlcGFnZWRfc2xhYl9pbml0KHZvaWQpOworc3RhdGljIHZvaWQga2h1Z2VwYWdlZF9zbGFiX2ZyZWUodm9pZCk7CisKKyNkZWZpbmUgTU1fU0xPVFNfSEFTSF9IRUFEUyAxMDI0CitzdGF0aWMgc3RydWN0IGhsaXN0X2hlYWQgKm1tX3Nsb3RzX2hhc2ggX19yZWFkX21vc3RseTsKK3N0YXRpYyBzdHJ1Y3Qga21lbV9jYWNoZSAqbW1fc2xvdF9jYWNoZSBfX3JlYWRfbW9zdGx5OworCisvKioKKyAqIHN0cnVjdCBtbV9zbG90IC0gaGFzaCBsb29rdXAgZnJvbSBtbSB0byBtbV9zbG90CisgKiBAaGFzaDogaGFzaCBjb2xsaXNpb24gbGlzdAorICogQG1tX25vZGU6IGtodWdlcGFnZWQgc2NhbiBsaXN0IGhlYWRlZCBpbiBraHVnZXBhZ2VkX3NjYW4ubW1faGVhZAorICogQG1tOiB0aGUgbW0gdGhhdCB0aGlzIGluZm9ybWF0aW9uIGlzIHZhbGlkIGZvcgorICovCitzdHJ1Y3QgbW1fc2xvdCB7CisJc3RydWN0IGhsaXN0X25vZGUgaGFzaDsKKwlzdHJ1Y3QgbGlzdF9oZWFkIG1tX25vZGU7CisJc3RydWN0IG1tX3N0cnVjdCAqbW07Cit9OworCisvKioKKyAqIHN0cnVjdCBraHVnZXBhZ2VkX3NjYW4gLSBjdXJzb3IgZm9yIHNjYW5uaW5nCisgKiBAbW1faGVhZDogdGhlIGhlYWQgb2YgdGhlIG1tIGxpc3QgdG8gc2NhbgorICogQG1tX3Nsb3Q6IHRoZSBjdXJyZW50IG1tX3Nsb3Qgd2UgYXJlIHNjYW5uaW5nCisgKiBAYWRkcmVzczogdGhlIG5leHQgYWRkcmVzcyBpbnNpZGUgdGhhdCB0byBiZSBzY2FubmVkCisgKgorICogVGhlcmUgaXMgb25seSB0aGUgb25lIGtodWdlcGFnZWRfc2NhbiBpbnN0YW5jZSBvZiB0aGlzIGN1cnNvciBzdHJ1Y3R1cmUuCisgKi8KK3N0cnVjdCBraHVnZXBhZ2VkX3NjYW4geworCXN0cnVjdCBsaXN0X2hlYWQgbW1faGVhZDsKKwlzdHJ1Y3QgbW1fc2xvdCAqbW1fc2xvdDsKKwl1bnNpZ25lZCBsb25nIGFkZHJlc3M7Cit9IGtodWdlcGFnZWRfc2NhbiA9IHsKKwkubW1faGVhZCA9IExJU1RfSEVBRF9JTklUKGtodWdlcGFnZWRfc2Nhbi5tbV9oZWFkKSwKK307CisKKworc3RhdGljIGludCBzZXRfcmVjb21tZW5kZWRfbWluX2ZyZWVfa2J5dGVzKHZvaWQpCit7CisJc3RydWN0IHpvbmUgKnpvbmU7CisJaW50IG5yX3pvbmVzID0gMDsKKwl1bnNpZ25lZCBsb25nIHJlY29tbWVuZGVkX21pbjsKKwlleHRlcm4gaW50IG1pbl9mcmVlX2tieXRlczsKKworCWlmICghdGVzdF9iaXQoVFJBTlNQQVJFTlRfSFVHRVBBR0VfRkxBRywKKwkJICAgICAgJnRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzKSAmJgorCSAgICAhdGVzdF9iaXQoVFJBTlNQQVJFTlRfSFVHRVBBR0VfUkVRX01BRFZfRkxBRywKKwkJICAgICAgJnRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzKSkKKwkJcmV0dXJuIDA7CisKKwlmb3JfZWFjaF9wb3B1bGF0ZWRfem9uZSh6b25lKQorCQlucl96b25lcysrOworCisJLyogTWFrZSBzdXJlIGF0IGxlYXN0IDIgaHVnZXBhZ2VzIGFyZSBmcmVlIGZvciBNSUdSQVRFX1JFU0VSVkUgKi8KKwlyZWNvbW1lbmRlZF9taW4gPSBwYWdlYmxvY2tfbnJfcGFnZXMgKiBucl96b25lcyAqIDI7CisKKwkvKgorCSAqIE1ha2Ugc3VyZSB0aGF0IG9uIGF2ZXJhZ2UgYXQgbGVhc3QgdHdvIHBhZ2VibG9ja3MgYXJlIGFsbW9zdCBmcmVlCisJICogb2YgYW5vdGhlciB0eXBlLCBvbmUgZm9yIGEgbWlncmF0ZXR5cGUgdG8gZmFsbCBiYWNrIHRvIGFuZCBhCisJICogc2Vjb25kIHRvIGF2b2lkIHN1YnNlcXVlbnQgZmFsbGJhY2tzIG9mIG90aGVyIHR5cGVzIFRoZXJlIGFyZSAzCisJICogTUlHUkFURV9UWVBFUyB3ZSBjYXJlIGFib3V0LgorCSAqLworCXJlY29tbWVuZGVkX21pbiArPSBwYWdlYmxvY2tfbnJfcGFnZXMgKiBucl96b25lcyAqCisJCQkgICBNSUdSQVRFX1BDUFRZUEVTICogTUlHUkFURV9QQ1BUWVBFUzsKKworCS8qIGRvbid0IGV2ZXIgYWxsb3cgdG8gcmVzZXJ2ZSBtb3JlIHRoYW4gNSUgb2YgdGhlIGxvd21lbSAqLworCXJlY29tbWVuZGVkX21pbiA9IG1pbihyZWNvbW1lbmRlZF9taW4sCisJCQkgICAgICAodW5zaWduZWQgbG9uZykgbnJfZnJlZV9idWZmZXJfcGFnZXMoKSAvIDIwKTsKKwlyZWNvbW1lbmRlZF9taW4gPDw9IChQQUdFX1NISUZULTEwKTsKKworCWlmIChyZWNvbW1lbmRlZF9taW4gPiBtaW5fZnJlZV9rYnl0ZXMpCisJCW1pbl9mcmVlX2tieXRlcyA9IHJlY29tbWVuZGVkX21pbjsKKwlzZXR1cF9wZXJfem9uZV93bWFya3MoKTsKKwlyZXR1cm4gMDsKK30KK2xhdGVfaW5pdGNhbGwoc2V0X3JlY29tbWVuZGVkX21pbl9mcmVlX2tieXRlcyk7CisKK3N0YXRpYyBpbnQgc3RhcnRfa2h1Z2VwYWdlZCh2b2lkKQoreworCWludCBlcnIgPSAwOworCWlmIChraHVnZXBhZ2VkX2VuYWJsZWQoKSkgeworCQlpbnQgd2FrZXVwOworCQlpZiAodW5saWtlbHkoIW1tX3Nsb3RfY2FjaGUgfHwgIW1tX3Nsb3RzX2hhc2gpKSB7CisJCQllcnIgPSAtRU5PTUVNOworCQkJZ290byBvdXQ7CisJCX0KKwkJbXV0ZXhfbG9jaygma2h1Z2VwYWdlZF9tdXRleCk7CisJCWlmICgha2h1Z2VwYWdlZF90aHJlYWQpCisJCQlraHVnZXBhZ2VkX3RocmVhZCA9IGt0aHJlYWRfcnVuKGtodWdlcGFnZWQsIE5VTEwsCisJCQkJCQkJImtodWdlcGFnZWQiKTsKKwkJaWYgKHVubGlrZWx5KElTX0VSUihraHVnZXBhZ2VkX3RocmVhZCkpKSB7CisJCQlwcmludGsoS0VSTl9FUlIKKwkJCSAgICAgICAia2h1Z2VwYWdlZDoga3RocmVhZF9ydW4oa2h1Z2VwYWdlZCkgZmFpbGVkXG4iKTsKKwkJCWVyciA9IFBUUl9FUlIoa2h1Z2VwYWdlZF90aHJlYWQpOworCQkJa2h1Z2VwYWdlZF90aHJlYWQgPSBOVUxMOworCQl9CisJCXdha2V1cCA9ICFsaXN0X2VtcHR5KCZraHVnZXBhZ2VkX3NjYW4ubW1faGVhZCk7CisJCW11dGV4X3VubG9jaygma2h1Z2VwYWdlZF9tdXRleCk7CisJCWlmICh3YWtldXApCisJCQl3YWtlX3VwX2ludGVycnVwdGlibGUoJmtodWdlcGFnZWRfd2FpdCk7CisKKwkJc2V0X3JlY29tbWVuZGVkX21pbl9mcmVlX2tieXRlcygpOworCX0gZWxzZQorCQkvKiB3YWtldXAgdG8gZXhpdCAqLworCQl3YWtlX3VwX2ludGVycnVwdGlibGUoJmtodWdlcGFnZWRfd2FpdCk7CitvdXQ6CisJcmV0dXJuIGVycjsKK30KKworI2lmZGVmIENPTkZJR19TWVNGUworCitzdGF0aWMgc3NpemVfdCBkb3VibGVfZmxhZ19zaG93KHN0cnVjdCBrb2JqZWN0ICprb2JqLAorCQkJCXN0cnVjdCBrb2JqX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmLAorCQkJCWVudW0gdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZyBlbmFibGVkLAorCQkJCWVudW0gdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZyByZXFfbWFkdikKK3sKKwlpZiAodGVzdF9iaXQoZW5hYmxlZCwgJnRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzKSkgeworCQlWTV9CVUdfT04odGVzdF9iaXQocmVxX21hZHYsICZ0cmFuc3BhcmVudF9odWdlcGFnZV9mbGFncykpOworCQlyZXR1cm4gc3ByaW50ZihidWYsICJbYWx3YXlzXSBtYWR2aXNlIG5ldmVyXG4iKTsKKwl9IGVsc2UgaWYgKHRlc3RfYml0KHJlcV9tYWR2LCAmdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZ3MpKQorCQlyZXR1cm4gc3ByaW50ZihidWYsICJhbHdheXMgW21hZHZpc2VdIG5ldmVyXG4iKTsKKwllbHNlCisJCXJldHVybiBzcHJpbnRmKGJ1ZiwgImFsd2F5cyBtYWR2aXNlIFtuZXZlcl1cbiIpOworfQorc3RhdGljIHNzaXplX3QgZG91YmxlX2ZsYWdfc3RvcmUoc3RydWN0IGtvYmplY3QgKmtvYmosCisJCQkJIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCQkgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQsCisJCQkJIGVudW0gdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZyBlbmFibGVkLAorCQkJCSBlbnVtIHRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWcgcmVxX21hZHYpCit7CisJaWYgKCFtZW1jbXAoImFsd2F5cyIsIGJ1ZiwKKwkJICAgIG1pbihzaXplb2YoImFsd2F5cyIpLTEsIGNvdW50KSkpIHsKKwkJc2V0X2JpdChlbmFibGVkLCAmdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZ3MpOworCQljbGVhcl9iaXQocmVxX21hZHYsICZ0cmFuc3BhcmVudF9odWdlcGFnZV9mbGFncyk7CisJfSBlbHNlIGlmICghbWVtY21wKCJtYWR2aXNlIiwgYnVmLAorCQkJICAgbWluKHNpemVvZigibWFkdmlzZSIpLTEsIGNvdW50KSkpIHsKKwkJY2xlYXJfYml0KGVuYWJsZWQsICZ0cmFuc3BhcmVudF9odWdlcGFnZV9mbGFncyk7CisJCXNldF9iaXQocmVxX21hZHYsICZ0cmFuc3BhcmVudF9odWdlcGFnZV9mbGFncyk7CisJfSBlbHNlIGlmICghbWVtY21wKCJuZXZlciIsIGJ1ZiwKKwkJCSAgIG1pbihzaXplb2YoIm5ldmVyIiktMSwgY291bnQpKSkgeworCQljbGVhcl9iaXQoZW5hYmxlZCwgJnRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzKTsKKwkJY2xlYXJfYml0KHJlcV9tYWR2LCAmdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZ3MpOworCX0gZWxzZQorCQlyZXR1cm4gLUVJTlZBTDsKKworCXJldHVybiBjb3VudDsKK30KKworc3RhdGljIHNzaXplX3QgZW5hYmxlZF9zaG93KHN0cnVjdCBrb2JqZWN0ICprb2JqLAorCQkJICAgIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQoreworCXJldHVybiBkb3VibGVfZmxhZ19zaG93KGtvYmosIGF0dHIsIGJ1ZiwKKwkJCQlUUkFOU1BBUkVOVF9IVUdFUEFHRV9GTEFHLAorCQkJCVRSQU5TUEFSRU5UX0hVR0VQQUdFX1JFUV9NQURWX0ZMQUcpOworfQorc3RhdGljIHNzaXplX3QgZW5hYmxlZF9zdG9yZShzdHJ1Y3Qga29iamVjdCAqa29iaiwKKwkJCSAgICAgc3RydWN0IGtvYmpfYXR0cmlidXRlICphdHRyLAorCQkJICAgICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKK3sKKwlzc2l6ZV90IHJldDsKKworCXJldCA9IGRvdWJsZV9mbGFnX3N0b3JlKGtvYmosIGF0dHIsIGJ1ZiwgY291bnQsCisJCQkJVFJBTlNQQVJFTlRfSFVHRVBBR0VfRkxBRywKKwkJCQlUUkFOU1BBUkVOVF9IVUdFUEFHRV9SRVFfTUFEVl9GTEFHKTsKKworCWlmIChyZXQgPiAwKSB7CisJCWludCBlcnIgPSBzdGFydF9raHVnZXBhZ2VkKCk7CisJCWlmIChlcnIpCisJCQlyZXQgPSBlcnI7CisJfQorCisJaWYgKHJldCA+IDAgJiYKKwkgICAgKHRlc3RfYml0KFRSQU5TUEFSRU5UX0hVR0VQQUdFX0ZMQUcsCisJCSAgICAgICZ0cmFuc3BhcmVudF9odWdlcGFnZV9mbGFncykgfHwKKwkgICAgIHRlc3RfYml0KFRSQU5TUEFSRU5UX0hVR0VQQUdFX1JFUV9NQURWX0ZMQUcsCisJCSAgICAgICZ0cmFuc3BhcmVudF9odWdlcGFnZV9mbGFncykpKQorCQlzZXRfcmVjb21tZW5kZWRfbWluX2ZyZWVfa2J5dGVzKCk7CisKKwlyZXR1cm4gcmV0OworfQorc3RhdGljIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSBlbmFibGVkX2F0dHIgPQorCV9fQVRUUihlbmFibGVkLCAwNjQ0LCBlbmFibGVkX3Nob3csIGVuYWJsZWRfc3RvcmUpOworCitzdGF0aWMgc3NpemVfdCBzaW5nbGVfZmxhZ19zaG93KHN0cnVjdCBrb2JqZWN0ICprb2JqLAorCQkJCXN0cnVjdCBrb2JqX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmLAorCQkJCWVudW0gdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZyBmbGFnKQoreworCWlmICh0ZXN0X2JpdChmbGFnLCAmdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZ3MpKQorCQlyZXR1cm4gc3ByaW50ZihidWYsICJbeWVzXSBub1xuIik7CisJZWxzZQorCQlyZXR1cm4gc3ByaW50ZihidWYsICJ5ZXMgW25vXVxuIik7Cit9CitzdGF0aWMgc3NpemVfdCBzaW5nbGVfZmxhZ19zdG9yZShzdHJ1Y3Qga29iamVjdCAqa29iaiwKKwkJCQkgc3RydWN0IGtvYmpfYXR0cmlidXRlICphdHRyLAorCQkJCSBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCwKKwkJCQkgZW51bSB0cmFuc3BhcmVudF9odWdlcGFnZV9mbGFnIGZsYWcpCit7CisJaWYgKCFtZW1jbXAoInllcyIsIGJ1ZiwKKwkJICAgIG1pbihzaXplb2YoInllcyIpLTEsIGNvdW50KSkpIHsKKwkJc2V0X2JpdChmbGFnLCAmdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZ3MpOworCX0gZWxzZSBpZiAoIW1lbWNtcCgibm8iLCBidWYsCisJCQkgICBtaW4oc2l6ZW9mKCJubyIpLTEsIGNvdW50KSkpIHsKKwkJY2xlYXJfYml0KGZsYWcsICZ0cmFuc3BhcmVudF9odWdlcGFnZV9mbGFncyk7CisJfSBlbHNlCisJCXJldHVybiAtRUlOVkFMOworCisJcmV0dXJuIGNvdW50OworfQorCisvKgorICogQ3VycmVudGx5IGRlZnJhZyBvbmx5IGRpc2FibGVzIF9fR0ZQX05PV0FJVCBmb3IgYWxsb2NhdGlvbi4gQSBibGluZAorICogX19HRlBfUkVQRUFUIGlzIHRvbyBhZ2dyZXNzaXZlLCBpdCdzIG5ldmVyIHdvcnRoIHN3YXBwaW5nIHRvbnMgb2YKKyAqIG1lbW9yeSBqdXN0IHRvIGFsbG9jYXRlIG9uZSBtb3JlIGh1Z2VwYWdlLgorICovCitzdGF0aWMgc3NpemVfdCBkZWZyYWdfc2hvdyhzdHJ1Y3Qga29iamVjdCAqa29iaiwKKwkJCSAgIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQoreworCXJldHVybiBkb3VibGVfZmxhZ19zaG93KGtvYmosIGF0dHIsIGJ1ZiwKKwkJCQlUUkFOU1BBUkVOVF9IVUdFUEFHRV9ERUZSQUdfRkxBRywKKwkJCQlUUkFOU1BBUkVOVF9IVUdFUEFHRV9ERUZSQUdfUkVRX01BRFZfRkxBRyk7Cit9CitzdGF0aWMgc3NpemVfdCBkZWZyYWdfc3RvcmUoc3RydWN0IGtvYmplY3QgKmtvYmosCisJCQkgICAgc3RydWN0IGtvYmpfYXR0cmlidXRlICphdHRyLAorCQkJICAgIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQoreworCXJldHVybiBkb3VibGVfZmxhZ19zdG9yZShrb2JqLCBhdHRyLCBidWYsIGNvdW50LAorCQkJCSBUUkFOU1BBUkVOVF9IVUdFUEFHRV9ERUZSQUdfRkxBRywKKwkJCQkgVFJBTlNQQVJFTlRfSFVHRVBBR0VfREVGUkFHX1JFUV9NQURWX0ZMQUcpOworfQorc3RhdGljIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSBkZWZyYWdfYXR0ciA9CisJX19BVFRSKGRlZnJhZywgMDY0NCwgZGVmcmFnX3Nob3csIGRlZnJhZ19zdG9yZSk7CisKKyNpZmRlZiBDT05GSUdfREVCVUdfVk0KK3N0YXRpYyBzc2l6ZV90IGRlYnVnX2Nvd19zaG93KHN0cnVjdCBrb2JqZWN0ICprb2JqLAorCQkJCXN0cnVjdCBrb2JqX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQoreworCXJldHVybiBzaW5nbGVfZmxhZ19zaG93KGtvYmosIGF0dHIsIGJ1ZiwKKwkJCQlUUkFOU1BBUkVOVF9IVUdFUEFHRV9ERUJVR19DT1dfRkxBRyk7Cit9CitzdGF0aWMgc3NpemVfdCBkZWJ1Z19jb3dfc3RvcmUoc3RydWN0IGtvYmplY3QgKmtvYmosCisJCQkgICAgICAgc3RydWN0IGtvYmpfYXR0cmlidXRlICphdHRyLAorCQkJICAgICAgIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQoreworCXJldHVybiBzaW5nbGVfZmxhZ19zdG9yZShrb2JqLCBhdHRyLCBidWYsIGNvdW50LAorCQkJCSBUUkFOU1BBUkVOVF9IVUdFUEFHRV9ERUJVR19DT1dfRkxBRyk7Cit9CitzdGF0aWMgc3RydWN0IGtvYmpfYXR0cmlidXRlIGRlYnVnX2Nvd19hdHRyID0KKwlfX0FUVFIoZGVidWdfY293LCAwNjQ0LCBkZWJ1Z19jb3dfc2hvdywgZGVidWdfY293X3N0b3JlKTsKKyNlbmRpZiAvKiBDT05GSUdfREVCVUdfVk0gKi8KKworc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKmh1Z2VwYWdlX2F0dHJbXSA9IHsKKwkmZW5hYmxlZF9hdHRyLmF0dHIsCisJJmRlZnJhZ19hdHRyLmF0dHIsCisjaWZkZWYgQ09ORklHX0RFQlVHX1ZNCisJJmRlYnVnX2Nvd19hdHRyLmF0dHIsCisjZW5kaWYKKwlOVUxMLAorfTsKKworc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgaHVnZXBhZ2VfYXR0cl9ncm91cCA9IHsKKwkuYXR0cnMgPSBodWdlcGFnZV9hdHRyLAorfTsKKworc3RhdGljIHNzaXplX3Qgc2Nhbl9zbGVlcF9taWxsaXNlY3Nfc2hvdyhzdHJ1Y3Qga29iamVjdCAqa29iaiwKKwkJCQkJIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCQkJIGNoYXIgKmJ1ZikKK3sKKwlyZXR1cm4gc3ByaW50ZihidWYsICIldVxuIiwga2h1Z2VwYWdlZF9zY2FuX3NsZWVwX21pbGxpc2Vjcyk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IHNjYW5fc2xlZXBfbWlsbGlzZWNzX3N0b3JlKHN0cnVjdCBrb2JqZWN0ICprb2JqLAorCQkJCQkgIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCQkJICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKK3sKKwl1bnNpZ25lZCBsb25nIG1zZWNzOworCWludCBlcnI7CisKKwllcnIgPSBzdHJpY3Rfc3RydG91bChidWYsIDEwLCAmbXNlY3MpOworCWlmIChlcnIgfHwgbXNlY3MgPiBVSU5UX01BWCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlraHVnZXBhZ2VkX3NjYW5fc2xlZXBfbWlsbGlzZWNzID0gbXNlY3M7CisJd2FrZV91cF9pbnRlcnJ1cHRpYmxlKCZraHVnZXBhZ2VkX3dhaXQpOworCisJcmV0dXJuIGNvdW50OworfQorc3RhdGljIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSBzY2FuX3NsZWVwX21pbGxpc2Vjc19hdHRyID0KKwlfX0FUVFIoc2Nhbl9zbGVlcF9taWxsaXNlY3MsIDA2NDQsIHNjYW5fc2xlZXBfbWlsbGlzZWNzX3Nob3csCisJICAgICAgIHNjYW5fc2xlZXBfbWlsbGlzZWNzX3N0b3JlKTsKKworc3RhdGljIHNzaXplX3QgYWxsb2Nfc2xlZXBfbWlsbGlzZWNzX3Nob3coc3RydWN0IGtvYmplY3QgKmtvYmosCisJCQkJCSAgc3RydWN0IGtvYmpfYXR0cmlidXRlICphdHRyLAorCQkJCQkgIGNoYXIgKmJ1ZikKK3sKKwlyZXR1cm4gc3ByaW50ZihidWYsICIldVxuIiwga2h1Z2VwYWdlZF9hbGxvY19zbGVlcF9taWxsaXNlY3MpOworfQorCitzdGF0aWMgc3NpemVfdCBhbGxvY19zbGVlcF9taWxsaXNlY3Nfc3RvcmUoc3RydWN0IGtvYmplY3QgKmtvYmosCisJCQkJCSAgIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCQkJICAgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7CisJdW5zaWduZWQgbG9uZyBtc2VjczsKKwlpbnQgZXJyOworCisJZXJyID0gc3RyaWN0X3N0cnRvdWwoYnVmLCAxMCwgJm1zZWNzKTsKKwlpZiAoZXJyIHx8IG1zZWNzID4gVUlOVF9NQVgpCisJCXJldHVybiAtRUlOVkFMOworCisJa2h1Z2VwYWdlZF9hbGxvY19zbGVlcF9taWxsaXNlY3MgPSBtc2VjczsKKwl3YWtlX3VwX2ludGVycnVwdGlibGUoJmtodWdlcGFnZWRfd2FpdCk7CisKKwlyZXR1cm4gY291bnQ7Cit9CitzdGF0aWMgc3RydWN0IGtvYmpfYXR0cmlidXRlIGFsbG9jX3NsZWVwX21pbGxpc2Vjc19hdHRyID0KKwlfX0FUVFIoYWxsb2Nfc2xlZXBfbWlsbGlzZWNzLCAwNjQ0LCBhbGxvY19zbGVlcF9taWxsaXNlY3Nfc2hvdywKKwkgICAgICAgYWxsb2Nfc2xlZXBfbWlsbGlzZWNzX3N0b3JlKTsKKworc3RhdGljIHNzaXplX3QgcGFnZXNfdG9fc2Nhbl9zaG93KHN0cnVjdCBrb2JqZWN0ICprb2JqLAorCQkJCSAgc3RydWN0IGtvYmpfYXR0cmlidXRlICphdHRyLAorCQkJCSAgY2hhciAqYnVmKQoreworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiV1XG4iLCBraHVnZXBhZ2VkX3BhZ2VzX3RvX3NjYW4pOworfQorc3RhdGljIHNzaXplX3QgcGFnZXNfdG9fc2Nhbl9zdG9yZShzdHJ1Y3Qga29iamVjdCAqa29iaiwKKwkJCQkgICBzdHJ1Y3Qga29ial9hdHRyaWJ1dGUgKmF0dHIsCisJCQkJICAgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7CisJaW50IGVycjsKKwl1bnNpZ25lZCBsb25nIHBhZ2VzOworCisJZXJyID0gc3RyaWN0X3N0cnRvdWwoYnVmLCAxMCwgJnBhZ2VzKTsKKwlpZiAoZXJyIHx8ICFwYWdlcyB8fCBwYWdlcyA+IFVJTlRfTUFYKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWtodWdlcGFnZWRfcGFnZXNfdG9fc2NhbiA9IHBhZ2VzOworCisJcmV0dXJuIGNvdW50OworfQorc3RhdGljIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSBwYWdlc190b19zY2FuX2F0dHIgPQorCV9fQVRUUihwYWdlc190b19zY2FuLCAwNjQ0LCBwYWdlc190b19zY2FuX3Nob3csCisJICAgICAgIHBhZ2VzX3RvX3NjYW5fc3RvcmUpOworCitzdGF0aWMgc3NpemVfdCBwYWdlc19jb2xsYXBzZWRfc2hvdyhzdHJ1Y3Qga29iamVjdCAqa29iaiwKKwkJCQkgICAgc3RydWN0IGtvYmpfYXR0cmlidXRlICphdHRyLAorCQkJCSAgICBjaGFyICpidWYpCit7CisJcmV0dXJuIHNwcmludGYoYnVmLCAiJXVcbiIsIGtodWdlcGFnZWRfcGFnZXNfY29sbGFwc2VkKTsKK30KK3N0YXRpYyBzdHJ1Y3Qga29ial9hdHRyaWJ1dGUgcGFnZXNfY29sbGFwc2VkX2F0dHIgPQorCV9fQVRUUl9STyhwYWdlc19jb2xsYXBzZWQpOworCitzdGF0aWMgc3NpemVfdCBmdWxsX3NjYW5zX3Nob3coc3RydWN0IGtvYmplY3QgKmtvYmosCisJCQkgICAgICAgc3RydWN0IGtvYmpfYXR0cmlidXRlICphdHRyLAorCQkJICAgICAgIGNoYXIgKmJ1ZikKK3sKKwlyZXR1cm4gc3ByaW50ZihidWYsICIldVxuIiwga2h1Z2VwYWdlZF9mdWxsX3NjYW5zKTsKK30KK3N0YXRpYyBzdHJ1Y3Qga29ial9hdHRyaWJ1dGUgZnVsbF9zY2Fuc19hdHRyID0KKwlfX0FUVFJfUk8oZnVsbF9zY2Fucyk7CisKK3N0YXRpYyBzc2l6ZV90IGtodWdlcGFnZWRfZGVmcmFnX3Nob3coc3RydWN0IGtvYmplY3QgKmtvYmosCisJCQkJICAgICAgc3RydWN0IGtvYmpfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCit7CisJcmV0dXJuIHNpbmdsZV9mbGFnX3Nob3coa29iaiwgYXR0ciwgYnVmLAorCQkJCVRSQU5TUEFSRU5UX0hVR0VQQUdFX0RFRlJBR19LSFVHRVBBR0VEX0ZMQUcpOworfQorc3RhdGljIHNzaXplX3Qga2h1Z2VwYWdlZF9kZWZyYWdfc3RvcmUoc3RydWN0IGtvYmplY3QgKmtvYmosCisJCQkJICAgICAgIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCQkgICAgICAgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7CisJcmV0dXJuIHNpbmdsZV9mbGFnX3N0b3JlKGtvYmosIGF0dHIsIGJ1ZiwgY291bnQsCisJCQkJIFRSQU5TUEFSRU5UX0hVR0VQQUdFX0RFRlJBR19LSFVHRVBBR0VEX0ZMQUcpOworfQorc3RhdGljIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSBraHVnZXBhZ2VkX2RlZnJhZ19hdHRyID0KKwlfX0FUVFIoZGVmcmFnLCAwNjQ0LCBraHVnZXBhZ2VkX2RlZnJhZ19zaG93LAorCSAgICAgICBraHVnZXBhZ2VkX2RlZnJhZ19zdG9yZSk7CisKKy8qCisgKiBtYXhfcHRlc19ub25lIGNvbnRyb2xzIGlmIGtodWdlcGFnZWQgc2hvdWxkIGNvbGxhcHNlIGh1Z2VwYWdlcyBvdmVyCisgKiBhbnkgdW5tYXBwZWQgcHRlcyBpbiB0dXJuIHBvdGVudGlhbGx5IGluY3JlYXNpbmcgdGhlIG1lbW9yeQorICogZm9vdHByaW50IG9mIHRoZSB2bWFzLiBXaGVuIG1heF9wdGVzX25vbmUgaXMgMCBraHVnZXBhZ2VkIHdpbGwgbm90CisgKiByZWR1Y2UgdGhlIGF2YWlsYWJsZSBmcmVlIG1lbW9yeSBpbiB0aGUgc3lzdGVtIGFzIGl0CisgKiBydW5zLiBJbmNyZWFzaW5nIG1heF9wdGVzX25vbmUgd2lsbCBpbnN0ZWFkIHBvdGVudGlhbGx5IHJlZHVjZSB0aGUKKyAqIGZyZWUgbWVtb3J5IGluIHRoZSBzeXN0ZW0gZHVyaW5nIHRoZSBraHVnZXBhZ2VkIHNjYW4uCisgKi8KK3N0YXRpYyBzc2l6ZV90IGtodWdlcGFnZWRfbWF4X3B0ZXNfbm9uZV9zaG93KHN0cnVjdCBrb2JqZWN0ICprb2JqLAorCQkJCQkgICAgIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCQkJICAgICBjaGFyICpidWYpCit7CisJcmV0dXJuIHNwcmludGYoYnVmLCAiJXVcbiIsIGtodWdlcGFnZWRfbWF4X3B0ZXNfbm9uZSk7Cit9CitzdGF0aWMgc3NpemVfdCBraHVnZXBhZ2VkX21heF9wdGVzX25vbmVfc3RvcmUoc3RydWN0IGtvYmplY3QgKmtvYmosCisJCQkJCSAgICAgIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCQkJICAgICAgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7CisJaW50IGVycjsKKwl1bnNpZ25lZCBsb25nIG1heF9wdGVzX25vbmU7CisKKwllcnIgPSBzdHJpY3Rfc3RydG91bChidWYsIDEwLCAmbWF4X3B0ZXNfbm9uZSk7CisJaWYgKGVyciB8fCBtYXhfcHRlc19ub25lID4gSFBBR0VfUE1EX05SLTEpCisJCXJldHVybiAtRUlOVkFMOworCisJa2h1Z2VwYWdlZF9tYXhfcHRlc19ub25lID0gbWF4X3B0ZXNfbm9uZTsKKworCXJldHVybiBjb3VudDsKK30KK3N0YXRpYyBzdHJ1Y3Qga29ial9hdHRyaWJ1dGUga2h1Z2VwYWdlZF9tYXhfcHRlc19ub25lX2F0dHIgPQorCV9fQVRUUihtYXhfcHRlc19ub25lLCAwNjQ0LCBraHVnZXBhZ2VkX21heF9wdGVzX25vbmVfc2hvdywKKwkgICAgICAga2h1Z2VwYWdlZF9tYXhfcHRlc19ub25lX3N0b3JlKTsKKworc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKmtodWdlcGFnZWRfYXR0cltdID0geworCSZraHVnZXBhZ2VkX2RlZnJhZ19hdHRyLmF0dHIsCisJJmtodWdlcGFnZWRfbWF4X3B0ZXNfbm9uZV9hdHRyLmF0dHIsCisJJnBhZ2VzX3RvX3NjYW5fYXR0ci5hdHRyLAorCSZwYWdlc19jb2xsYXBzZWRfYXR0ci5hdHRyLAorCSZmdWxsX3NjYW5zX2F0dHIuYXR0ciwKKwkmc2Nhbl9zbGVlcF9taWxsaXNlY3NfYXR0ci5hdHRyLAorCSZhbGxvY19zbGVlcF9taWxsaXNlY3NfYXR0ci5hdHRyLAorCU5VTEwsCit9OworCitzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBraHVnZXBhZ2VkX2F0dHJfZ3JvdXAgPSB7CisJLmF0dHJzID0ga2h1Z2VwYWdlZF9hdHRyLAorCS5uYW1lID0gImtodWdlcGFnZWQiLAorfTsKKyNlbmRpZiAvKiBDT05GSUdfU1lTRlMgKi8KKworc3RhdGljIGludCBfX2luaXQgaHVnZXBhZ2VfaW5pdCh2b2lkKQoreworCWludCBlcnI7CisjaWZkZWYgQ09ORklHX1NZU0ZTCisJc3RhdGljIHN0cnVjdCBrb2JqZWN0ICpodWdlcGFnZV9rb2JqOworI2VuZGlmCisKKwllcnIgPSAtRUlOVkFMOworCWlmICghaGFzX3RyYW5zcGFyZW50X2h1Z2VwYWdlKCkpIHsKKwkJdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZ3MgPSAwOworCQlnb3RvIG91dDsKKwl9CisKKyNpZmRlZiBDT05GSUdfU1lTRlMKKwllcnIgPSAtRU5PTUVNOworCWh1Z2VwYWdlX2tvYmogPSBrb2JqZWN0X2NyZWF0ZV9hbmRfYWRkKCJ0cmFuc3BhcmVudF9odWdlcGFnZSIsIG1tX2tvYmopOworCWlmICh1bmxpa2VseSghaHVnZXBhZ2Vfa29iaikpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJodWdlcGFnZTogZmFpbGVkIGtvYmplY3QgY3JlYXRlXG4iKTsKKwkJZ290byBvdXQ7CisJfQorCisJZXJyID0gc3lzZnNfY3JlYXRlX2dyb3VwKGh1Z2VwYWdlX2tvYmosICZodWdlcGFnZV9hdHRyX2dyb3VwKTsKKwlpZiAoZXJyKSB7CisJCXByaW50ayhLRVJOX0VSUiAiaHVnZXBhZ2U6IGZhaWxlZCByZWdpc3RlciBodWdlYWdlIGdyb3VwXG4iKTsKKwkJZ290byBvdXQ7CisJfQorCisJZXJyID0gc3lzZnNfY3JlYXRlX2dyb3VwKGh1Z2VwYWdlX2tvYmosICZraHVnZXBhZ2VkX2F0dHJfZ3JvdXApOworCWlmIChlcnIpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJodWdlcGFnZTogZmFpbGVkIHJlZ2lzdGVyIGh1Z2VhZ2UgZ3JvdXBcbiIpOworCQlnb3RvIG91dDsKKwl9CisjZW5kaWYKKworCWVyciA9IGtodWdlcGFnZWRfc2xhYl9pbml0KCk7CisJaWYgKGVycikKKwkJZ290byBvdXQ7CisKKwllcnIgPSBtbV9zbG90c19oYXNoX2luaXQoKTsKKwlpZiAoZXJyKSB7CisJCWtodWdlcGFnZWRfc2xhYl9mcmVlKCk7CisJCWdvdG8gb3V0OworCX0KKworCS8qCisJICogQnkgZGVmYXVsdCBkaXNhYmxlIHRyYW5zcGFyZW50IGh1Z2VwYWdlcyBvbiBzbWFsbGVyIHN5c3RlbXMsCisJICogd2hlcmUgdGhlIGV4dHJhIG1lbW9yeSB1c2VkIGNvdWxkIGh1cnQgbW9yZSB0aGFuIFRMQiBvdmVyaGVhZAorCSAqIGlzIGxpa2VseSB0byBzYXZlLiAgVGhlIGFkbWluIGNhbiBzdGlsbCBlbmFibGUgaXQgdGhyb3VnaCAvc3lzLgorCSAqLworCWlmICh0b3RhbHJhbV9wYWdlcyA8ICg1MTIgPDwgKDIwIC0gUEFHRV9TSElGVCkpKQorCQl0cmFuc3BhcmVudF9odWdlcGFnZV9mbGFncyA9IDA7CisKKwlzdGFydF9raHVnZXBhZ2VkKCk7CisKKwlzZXRfcmVjb21tZW5kZWRfbWluX2ZyZWVfa2J5dGVzKCk7CisKK291dDoKKwlyZXR1cm4gZXJyOworfQorbW9kdWxlX2luaXQoaHVnZXBhZ2VfaW5pdCkKKworc3RhdGljIGludCBfX2luaXQgc2V0dXBfdHJhbnNwYXJlbnRfaHVnZXBhZ2UoY2hhciAqc3RyKQoreworCWludCByZXQgPSAwOworCWlmICghc3RyKQorCQlnb3RvIG91dDsKKwlpZiAoIXN0cmNtcChzdHIsICJhbHdheXMiKSkgeworCQlzZXRfYml0KFRSQU5TUEFSRU5UX0hVR0VQQUdFX0ZMQUcsCisJCQkmdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZ3MpOworCQljbGVhcl9iaXQoVFJBTlNQQVJFTlRfSFVHRVBBR0VfUkVRX01BRFZfRkxBRywKKwkJCSAgJnRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzKTsKKwkJcmV0ID0gMTsKKwl9IGVsc2UgaWYgKCFzdHJjbXAoc3RyLCAibWFkdmlzZSIpKSB7CisJCWNsZWFyX2JpdChUUkFOU1BBUkVOVF9IVUdFUEFHRV9GTEFHLAorCQkJICAmdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZ3MpOworCQlzZXRfYml0KFRSQU5TUEFSRU5UX0hVR0VQQUdFX1JFUV9NQURWX0ZMQUcsCisJCQkmdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZ3MpOworCQlyZXQgPSAxOworCX0gZWxzZSBpZiAoIXN0cmNtcChzdHIsICJuZXZlciIpKSB7CisJCWNsZWFyX2JpdChUUkFOU1BBUkVOVF9IVUdFUEFHRV9GTEFHLAorCQkJICAmdHJhbnNwYXJlbnRfaHVnZXBhZ2VfZmxhZ3MpOworCQljbGVhcl9iaXQoVFJBTlNQQVJFTlRfSFVHRVBBR0VfUkVRX01BRFZfRkxBRywKKwkJCSAgJnRyYW5zcGFyZW50X2h1Z2VwYWdlX2ZsYWdzKTsKKwkJcmV0ID0gMTsKKwl9CitvdXQ6CisJaWYgKCFyZXQpCisJCXByaW50ayhLRVJOX1dBUk5JTkcKKwkJICAgICAgICJ0cmFuc3BhcmVudF9odWdlcGFnZT0gY2Fubm90IHBhcnNlLCBpZ25vcmVkXG4iKTsKKwlyZXR1cm4gcmV0OworfQorX19zZXR1cCgidHJhbnNwYXJlbnRfaHVnZXBhZ2U9Iiwgc2V0dXBfdHJhbnNwYXJlbnRfaHVnZXBhZ2UpOworCitzdGF0aWMgdm9pZCBwcmVwYXJlX3BtZF9odWdlX3B0ZShwZ3RhYmxlX3QgcGd0YWJsZSwKKwkJCQkgc3RydWN0IG1tX3N0cnVjdCAqbW0pCit7CisJYXNzZXJ0X3NwaW5fbG9ja2VkKCZtbS0+cGFnZV90YWJsZV9sb2NrKTsKKworCS8qIEZJRk8gKi8KKwlpZiAoIW1tLT5wbWRfaHVnZV9wdGUpCisJCUlOSVRfTElTVF9IRUFEKCZwZ3RhYmxlLT5scnUpOworCWVsc2UKKwkJbGlzdF9hZGQoJnBndGFibGUtPmxydSwgJm1tLT5wbWRfaHVnZV9wdGUtPmxydSk7CisJbW0tPnBtZF9odWdlX3B0ZSA9IHBndGFibGU7Cit9CisKK3N0YXRpYyBpbmxpbmUgcG1kX3QgbWF5YmVfcG1kX21rd3JpdGUocG1kX3QgcG1kLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlpZiAobGlrZWx5KHZtYS0+dm1fZmxhZ3MgJiBWTV9XUklURSkpCisJCXBtZCA9IHBtZF9ta3dyaXRlKHBtZCk7CisJcmV0dXJuIHBtZDsKK30KKworc3RhdGljIGludCBfX2RvX2h1Z2VfcG1kX2Fub255bW91c19wYWdlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJCQlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCQkJdW5zaWduZWQgbG9uZyBoYWRkciwgcG1kX3QgKnBtZCwKKwkJCQkJc3RydWN0IHBhZ2UgKnBhZ2UpCit7CisJaW50IHJldCA9IDA7CisJcGd0YWJsZV90IHBndGFibGU7CisKKwlWTV9CVUdfT04oIVBhZ2VDb21wb3VuZChwYWdlKSk7CisJcGd0YWJsZSA9IHB0ZV9hbGxvY19vbmUobW0sIGhhZGRyKTsKKwlpZiAodW5saWtlbHkoIXBndGFibGUpKSB7CisJCW1lbV9jZ3JvdXBfdW5jaGFyZ2VfcGFnZShwYWdlKTsKKwkJcHV0X3BhZ2UocGFnZSk7CisJCXJldHVybiBWTV9GQVVMVF9PT007CisJfQorCisJY2xlYXJfaHVnZV9wYWdlKHBhZ2UsIGhhZGRyLCBIUEFHRV9QTURfTlIpOworCV9fU2V0UGFnZVVwdG9kYXRlKHBhZ2UpOworCisJc3Bpbl9sb2NrKCZtbS0+cGFnZV90YWJsZV9sb2NrKTsKKwlpZiAodW5saWtlbHkoIXBtZF9ub25lKCpwbWQpKSkgeworCQlzcGluX3VubG9jaygmbW0tPnBhZ2VfdGFibGVfbG9jayk7CisJCW1lbV9jZ3JvdXBfdW5jaGFyZ2VfcGFnZShwYWdlKTsKKwkJcHV0X3BhZ2UocGFnZSk7CisJCXB0ZV9mcmVlKG1tLCBwZ3RhYmxlKTsKKwl9IGVsc2UgeworCQlwbWRfdCBlbnRyeTsKKwkJZW50cnkgPSBta19wbWQocGFnZSwgdm1hLT52bV9wYWdlX3Byb3QpOworCQllbnRyeSA9IG1heWJlX3BtZF9ta3dyaXRlKHBtZF9ta2RpcnR5KGVudHJ5KSwgdm1hKTsKKwkJZW50cnkgPSBwbWRfbWtodWdlKGVudHJ5KTsKKwkJLyoKKwkJICogVGhlIHNwaW5sb2NraW5nIHRvIHRha2UgdGhlIGxydV9sb2NrIGluc2lkZQorCQkgKiBwYWdlX2FkZF9uZXdfYW5vbl9ybWFwKCkgYWN0cyBhcyBhIGZ1bGwgbWVtb3J5CisJCSAqIGJhcnJpZXIgdG8gYmUgc3VyZSBjbGVhcl9odWdlX3BhZ2Ugd3JpdGVzIGJlY29tZQorCQkgKiB2aXNpYmxlIGFmdGVyIHRoZSBzZXRfcG1kX2F0KCkgd3JpdGUuCisJCSAqLworCQlwYWdlX2FkZF9uZXdfYW5vbl9ybWFwKHBhZ2UsIHZtYSwgaGFkZHIpOworCQlzZXRfcG1kX2F0KG1tLCBoYWRkciwgcG1kLCBlbnRyeSk7CisJCXByZXBhcmVfcG1kX2h1Z2VfcHRlKHBndGFibGUsIG1tKTsKKwkJYWRkX21tX2NvdW50ZXIobW0sIE1NX0FOT05QQUdFUywgSFBBR0VfUE1EX05SKTsKKwkJc3Bpbl91bmxvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCX0KKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbmxpbmUgZ2ZwX3QgYWxsb2NfaHVnZXBhZ2VfZ2ZwbWFzayhpbnQgZGVmcmFnKQoreworCXJldHVybiBHRlBfVFJBTlNIVUdFICYgfihkZWZyYWcgPyAwIDogX19HRlBfV0FJVCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IHBhZ2UgKmFsbG9jX2h1Z2VwYWdlX3ZtYShpbnQgZGVmcmFnLAorCQkJCQkgICAgICBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCQkJICAgICAgdW5zaWduZWQgbG9uZyBoYWRkcikKK3sKKwlyZXR1cm4gYWxsb2NfcGFnZXNfdm1hKGFsbG9jX2h1Z2VwYWdlX2dmcG1hc2soZGVmcmFnKSwKKwkJCSAgICAgICBIUEFHRV9QTURfT1JERVIsIHZtYSwgaGFkZHIpOworfQorCisjaWZuZGVmIENPTkZJR19OVU1BCitzdGF0aWMgaW5saW5lIHN0cnVjdCBwYWdlICphbGxvY19odWdlcGFnZShpbnQgZGVmcmFnKQoreworCXJldHVybiBhbGxvY19wYWdlcyhhbGxvY19odWdlcGFnZV9nZnBtYXNrKGRlZnJhZyksCisJCQkgICBIUEFHRV9QTURfT1JERVIpOworfQorI2VuZGlmCisKK2ludCBkb19odWdlX3BtZF9hbm9ueW1vdXNfcGFnZShzdHJ1Y3QgbW1fc3RydWN0ICptbSwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCQkgICAgICAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwbWRfdCAqcG1kLAorCQkJICAgICAgIHVuc2lnbmVkIGludCBmbGFncykKK3sKKwlzdHJ1Y3QgcGFnZSAqcGFnZTsKKwl1bnNpZ25lZCBsb25nIGhhZGRyID0gYWRkcmVzcyAmIEhQQUdFX1BNRF9NQVNLOworCXB0ZV90ICpwdGU7CisKKwlpZiAoaGFkZHIgPj0gdm1hLT52bV9zdGFydCAmJiBoYWRkciArIEhQQUdFX1BNRF9TSVpFIDw9IHZtYS0+dm1fZW5kKSB7CisJCWlmICh1bmxpa2VseShhbm9uX3ZtYV9wcmVwYXJlKHZtYSkpKQorCQkJcmV0dXJuIFZNX0ZBVUxUX09PTTsKKwkJaWYgKHVubGlrZWx5KGtodWdlcGFnZWRfZW50ZXIodm1hKSkpCisJCQlyZXR1cm4gVk1fRkFVTFRfT09NOworCQlwYWdlID0gYWxsb2NfaHVnZXBhZ2Vfdm1hKHRyYW5zcGFyZW50X2h1Z2VwYWdlX2RlZnJhZyh2bWEpLAorCQkJCQkgIHZtYSwgaGFkZHIpOworCQlpZiAodW5saWtlbHkoIXBhZ2UpKQorCQkJZ290byBvdXQ7CisJCWlmICh1bmxpa2VseShtZW1fY2dyb3VwX25ld3BhZ2VfY2hhcmdlKHBhZ2UsIG1tLCBHRlBfS0VSTkVMKSkpIHsKKwkJCXB1dF9wYWdlKHBhZ2UpOworCQkJZ290byBvdXQ7CisJCX0KKworCQlyZXR1cm4gX19kb19odWdlX3BtZF9hbm9ueW1vdXNfcGFnZShtbSwgdm1hLCBoYWRkciwgcG1kLCBwYWdlKTsKKwl9CitvdXQ6CisJLyoKKwkgKiBVc2UgX19wdGVfYWxsb2MgaW5zdGVhZCBvZiBwdGVfYWxsb2NfbWFwLCBiZWNhdXNlIHdlIGNhbid0CisJICogcnVuIHB0ZV9vZmZzZXRfbWFwIG9uIHRoZSBwbWQsIGlmIGFuIGh1Z2UgcG1kIGNvdWxkCisJICogbWF0ZXJpYWxpemUgZnJvbSB1bmRlciB1cyBmcm9tIGEgZGlmZmVyZW50IHRocmVhZC4KKwkgKi8KKwlpZiAodW5saWtlbHkoX19wdGVfYWxsb2MobW0sIHZtYSwgcG1kLCBhZGRyZXNzKSkpCisJCXJldHVybiBWTV9GQVVMVF9PT007CisJLyogaWYgYW4gaHVnZSBwbWQgbWF0ZXJpYWxpemVkIGZyb20gdW5kZXIgdXMganVzdCByZXRyeSBsYXRlciAqLworCWlmICh1bmxpa2VseShwbWRfdHJhbnNfaHVnZSgqcG1kKSkpCisJCXJldHVybiAwOworCS8qCisJICogQSByZWd1bGFyIHBtZCBpcyBlc3RhYmxpc2hlZCBhbmQgaXQgY2FuJ3QgbW9ycGggaW50byBhIGh1Z2UgcG1kCisJICogZnJvbSB1bmRlciB1cyBhbnltb3JlIGF0IHRoaXMgcG9pbnQgYmVjYXVzZSB3ZSBob2xkIHRoZSBtbWFwX3NlbQorCSAqIHJlYWQgbW9kZSBhbmQga2h1Z2VwYWdlZCB0YWtlcyBpdCBpbiB3cml0ZSBtb2RlLiBTbyBub3cgaXQncworCSAqIHNhZmUgdG8gcnVuIHB0ZV9vZmZzZXRfbWFwKCkuCisJICovCisJcHRlID0gcHRlX29mZnNldF9tYXAocG1kLCBhZGRyZXNzKTsKKwlyZXR1cm4gaGFuZGxlX3B0ZV9mYXVsdChtbSwgdm1hLCBhZGRyZXNzLCBwdGUsIHBtZCwgZmxhZ3MpOworfQorCitpbnQgY29weV9odWdlX3BtZChzdHJ1Y3QgbW1fc3RydWN0ICpkc3RfbW0sIHN0cnVjdCBtbV9zdHJ1Y3QgKnNyY19tbSwKKwkJICBwbWRfdCAqZHN0X3BtZCwgcG1kX3QgKnNyY19wbWQsIHVuc2lnbmVkIGxvbmcgYWRkciwKKwkJICBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlzdHJ1Y3QgcGFnZSAqc3JjX3BhZ2U7CisJcG1kX3QgcG1kOworCXBndGFibGVfdCBwZ3RhYmxlOworCWludCByZXQ7CisKKwlyZXQgPSAtRU5PTUVNOworCXBndGFibGUgPSBwdGVfYWxsb2Nfb25lKGRzdF9tbSwgYWRkcik7CisJaWYgKHVubGlrZWx5KCFwZ3RhYmxlKSkKKwkJZ290byBvdXQ7CisKKwlzcGluX2xvY2soJmRzdF9tbS0+cGFnZV90YWJsZV9sb2NrKTsKKwlzcGluX2xvY2tfbmVzdGVkKCZzcmNfbW0tPnBhZ2VfdGFibGVfbG9jaywgU0lOR0xFX0RFUFRIX05FU1RJTkcpOworCisJcmV0ID0gLUVBR0FJTjsKKwlwbWQgPSAqc3JjX3BtZDsKKwlpZiAodW5saWtlbHkoIXBtZF90cmFuc19odWdlKHBtZCkpKSB7CisJCXB0ZV9mcmVlKGRzdF9tbSwgcGd0YWJsZSk7CisJCWdvdG8gb3V0X3VubG9jazsKKwl9CisJaWYgKHVubGlrZWx5KHBtZF90cmFuc19zcGxpdHRpbmcocG1kKSkpIHsKKwkJLyogc3BsaXQgaHVnZSBwYWdlIHJ1bm5pbmcgZnJvbSB1bmRlciB1cyAqLworCQlzcGluX3VubG9jaygmc3JjX21tLT5wYWdlX3RhYmxlX2xvY2spOworCQlzcGluX3VubG9jaygmZHN0X21tLT5wYWdlX3RhYmxlX2xvY2spOworCQlwdGVfZnJlZShkc3RfbW0sIHBndGFibGUpOworCisJCXdhaXRfc3BsaXRfaHVnZV9wYWdlKHZtYS0+YW5vbl92bWEsIHNyY19wbWQpOyAvKiBzcmNfdm1hICovCisJCWdvdG8gb3V0OworCX0KKwlzcmNfcGFnZSA9IHBtZF9wYWdlKHBtZCk7CisJVk1fQlVHX09OKCFQYWdlSGVhZChzcmNfcGFnZSkpOworCWdldF9wYWdlKHNyY19wYWdlKTsKKwlwYWdlX2R1cF9ybWFwKHNyY19wYWdlKTsKKwlhZGRfbW1fY291bnRlcihkc3RfbW0sIE1NX0FOT05QQUdFUywgSFBBR0VfUE1EX05SKTsKKworCXBtZHBfc2V0X3dycHJvdGVjdChzcmNfbW0sIGFkZHIsIHNyY19wbWQpOworCXBtZCA9IHBtZF9ta29sZChwbWRfd3Jwcm90ZWN0KHBtZCkpOworCXNldF9wbWRfYXQoZHN0X21tLCBhZGRyLCBkc3RfcG1kLCBwbWQpOworCXByZXBhcmVfcG1kX2h1Z2VfcHRlKHBndGFibGUsIGRzdF9tbSk7CisKKwlyZXQgPSAwOworb3V0X3VubG9jazoKKwlzcGluX3VubG9jaygmc3JjX21tLT5wYWdlX3RhYmxlX2xvY2spOworCXNwaW5fdW5sb2NrKCZkc3RfbW0tPnBhZ2VfdGFibGVfbG9jayk7CitvdXQ6CisJcmV0dXJuIHJldDsKK30KKworLyogbm8gImFkZHJlc3MiIGFyZ3VtZW50IHNvIGRlc3Ryb3lzIHBhZ2UgY29sb3Jpbmcgb2Ygc29tZSBhcmNoICovCitwZ3RhYmxlX3QgZ2V0X3BtZF9odWdlX3B0ZShzdHJ1Y3QgbW1fc3RydWN0ICptbSkKK3sKKwlwZ3RhYmxlX3QgcGd0YWJsZTsKKworCWFzc2VydF9zcGluX2xvY2tlZCgmbW0tPnBhZ2VfdGFibGVfbG9jayk7CisKKwkvKiBGSUZPICovCisJcGd0YWJsZSA9IG1tLT5wbWRfaHVnZV9wdGU7CisJaWYgKGxpc3RfZW1wdHkoJnBndGFibGUtPmxydSkpCisJCW1tLT5wbWRfaHVnZV9wdGUgPSBOVUxMOworCWVsc2UgeworCQltbS0+cG1kX2h1Z2VfcHRlID0gbGlzdF9lbnRyeShwZ3RhYmxlLT5scnUubmV4dCwKKwkJCQkJICAgICAgc3RydWN0IHBhZ2UsIGxydSk7CisJCWxpc3RfZGVsKCZwZ3RhYmxlLT5scnUpOworCX0KKwlyZXR1cm4gcGd0YWJsZTsKK30KKworc3RhdGljIGludCBkb19odWdlX3BtZF93cF9wYWdlX2ZhbGxiYWNrKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJCQlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCQkJdW5zaWduZWQgbG9uZyBhZGRyZXNzLAorCQkJCQlwbWRfdCAqcG1kLCBwbWRfdCBvcmlnX3BtZCwKKwkJCQkJc3RydWN0IHBhZ2UgKnBhZ2UsCisJCQkJCXVuc2lnbmVkIGxvbmcgaGFkZHIpCit7CisJcGd0YWJsZV90IHBndGFibGU7CisJcG1kX3QgX3BtZDsKKwlpbnQgcmV0ID0gMCwgaTsKKwlzdHJ1Y3QgcGFnZSAqKnBhZ2VzOworCisJcGFnZXMgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3QgcGFnZSAqKSAqIEhQQUdFX1BNRF9OUiwKKwkJCUdGUF9LRVJORUwpOworCWlmICh1bmxpa2VseSghcGFnZXMpKSB7CisJCXJldCB8PSBWTV9GQVVMVF9PT007CisJCWdvdG8gb3V0OworCX0KKworCWZvciAoaSA9IDA7IGkgPCBIUEFHRV9QTURfTlI7IGkrKykgeworCQlwYWdlc1tpXSA9IGFsbG9jX3BhZ2Vfdm1hKEdGUF9ISUdIVVNFUl9NT1ZBQkxFLAorCQkJCQkgIHZtYSwgYWRkcmVzcyk7CisJCWlmICh1bmxpa2VseSghcGFnZXNbaV0gfHwKKwkJCSAgICAgbWVtX2Nncm91cF9uZXdwYWdlX2NoYXJnZShwYWdlc1tpXSwgbW0sCisJCQkJCQkgICAgICAgR0ZQX0tFUk5FTCkpKSB7CisJCQlpZiAocGFnZXNbaV0pCisJCQkJcHV0X3BhZ2UocGFnZXNbaV0pOworCQkJbWVtX2Nncm91cF91bmNoYXJnZV9zdGFydCgpOworCQkJd2hpbGUgKC0taSA+PSAwKSB7CisJCQkJbWVtX2Nncm91cF91bmNoYXJnZV9wYWdlKHBhZ2VzW2ldKTsKKwkJCQlwdXRfcGFnZShwYWdlc1tpXSk7CisJCQl9CisJCQltZW1fY2dyb3VwX3VuY2hhcmdlX2VuZCgpOworCQkJa2ZyZWUocGFnZXMpOworCQkJcmV0IHw9IFZNX0ZBVUxUX09PTTsKKwkJCWdvdG8gb3V0OworCQl9CisJfQorCisJZm9yIChpID0gMDsgaSA8IEhQQUdFX1BNRF9OUjsgaSsrKSB7CisJCWNvcHlfdXNlcl9oaWdocGFnZShwYWdlc1tpXSwgcGFnZSArIGksCisJCQkJICAgaGFkZHIgKyBQQUdFX1NISUZUKmksIHZtYSk7CisJCV9fU2V0UGFnZVVwdG9kYXRlKHBhZ2VzW2ldKTsKKwkJY29uZF9yZXNjaGVkKCk7CisJfQorCisJc3Bpbl9sb2NrKCZtbS0+cGFnZV90YWJsZV9sb2NrKTsKKwlpZiAodW5saWtlbHkoIXBtZF9zYW1lKCpwbWQsIG9yaWdfcG1kKSkpCisJCWdvdG8gb3V0X2ZyZWVfcGFnZXM7CisJVk1fQlVHX09OKCFQYWdlSGVhZChwYWdlKSk7CisKKwlwbWRwX2NsZWFyX2ZsdXNoX25vdGlmeSh2bWEsIGhhZGRyLCBwbWQpOworCS8qIGxlYXZlIHBtZCBlbXB0eSB1bnRpbCBwdGUgaXMgZmlsbGVkICovCisKKwlwZ3RhYmxlID0gZ2V0X3BtZF9odWdlX3B0ZShtbSk7CisJcG1kX3BvcHVsYXRlKG1tLCAmX3BtZCwgcGd0YWJsZSk7CisKKwlmb3IgKGkgPSAwOyBpIDwgSFBBR0VfUE1EX05SOyBpKyssIGhhZGRyICs9IFBBR0VfU0laRSkgeworCQlwdGVfdCAqcHRlLCBlbnRyeTsKKwkJZW50cnkgPSBta19wdGUocGFnZXNbaV0sIHZtYS0+dm1fcGFnZV9wcm90KTsKKwkJZW50cnkgPSBtYXliZV9ta3dyaXRlKHB0ZV9ta2RpcnR5KGVudHJ5KSwgdm1hKTsKKwkJcGFnZV9hZGRfbmV3X2Fub25fcm1hcChwYWdlc1tpXSwgdm1hLCBoYWRkcik7CisJCXB0ZSA9IHB0ZV9vZmZzZXRfbWFwKCZfcG1kLCBoYWRkcik7CisJCVZNX0JVR19PTighcHRlX25vbmUoKnB0ZSkpOworCQlzZXRfcHRlX2F0KG1tLCBoYWRkciwgcHRlLCBlbnRyeSk7CisJCXB0ZV91bm1hcChwdGUpOworCX0KKwlrZnJlZShwYWdlcyk7CisKKwltbS0+bnJfcHRlcysrOworCXNtcF93bWIoKTsgLyogbWFrZSBwdGUgdmlzaWJsZSBiZWZvcmUgcG1kICovCisJcG1kX3BvcHVsYXRlKG1tLCBwbWQsIHBndGFibGUpOworCXBhZ2VfcmVtb3ZlX3JtYXAocGFnZSk7CisJc3Bpbl91bmxvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCisJcmV0IHw9IFZNX0ZBVUxUX1dSSVRFOworCXB1dF9wYWdlKHBhZ2UpOworCitvdXQ6CisJcmV0dXJuIHJldDsKKworb3V0X2ZyZWVfcGFnZXM6CisJc3Bpbl91bmxvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCW1lbV9jZ3JvdXBfdW5jaGFyZ2Vfc3RhcnQoKTsKKwlmb3IgKGkgPSAwOyBpIDwgSFBBR0VfUE1EX05SOyBpKyspIHsKKwkJbWVtX2Nncm91cF91bmNoYXJnZV9wYWdlKHBhZ2VzW2ldKTsKKwkJcHV0X3BhZ2UocGFnZXNbaV0pOworCX0KKwltZW1fY2dyb3VwX3VuY2hhcmdlX2VuZCgpOworCWtmcmVlKHBhZ2VzKTsKKwlnb3RvIG91dDsKK30KKworaW50IGRvX2h1Z2VfcG1kX3dwX3BhZ2Uoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJdW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwbWRfdCAqcG1kLCBwbWRfdCBvcmlnX3BtZCkKK3sKKwlpbnQgcmV0ID0gMDsKKwlzdHJ1Y3QgcGFnZSAqcGFnZSwgKm5ld19wYWdlOworCXVuc2lnbmVkIGxvbmcgaGFkZHI7CisKKwlWTV9CVUdfT04oIXZtYS0+YW5vbl92bWEpOworCXNwaW5fbG9jaygmbW0tPnBhZ2VfdGFibGVfbG9jayk7CisJaWYgKHVubGlrZWx5KCFwbWRfc2FtZSgqcG1kLCBvcmlnX3BtZCkpKQorCQlnb3RvIG91dF91bmxvY2s7CisKKwlwYWdlID0gcG1kX3BhZ2Uob3JpZ19wbWQpOworCVZNX0JVR19PTighUGFnZUNvbXBvdW5kKHBhZ2UpIHx8ICFQYWdlSGVhZChwYWdlKSk7CisJaGFkZHIgPSBhZGRyZXNzICYgSFBBR0VfUE1EX01BU0s7CisJaWYgKHBhZ2VfbWFwY291bnQocGFnZSkgPT0gMSkgeworCQlwbWRfdCBlbnRyeTsKKwkJZW50cnkgPSBwbWRfbWt5b3VuZyhvcmlnX3BtZCk7CisJCWVudHJ5ID0gbWF5YmVfcG1kX21rd3JpdGUocG1kX21rZGlydHkoZW50cnkpLCB2bWEpOworCQlpZiAocG1kcF9zZXRfYWNjZXNzX2ZsYWdzKHZtYSwgaGFkZHIsIHBtZCwgZW50cnksICAxKSkKKwkJCXVwZGF0ZV9tbXVfY2FjaGUodm1hLCBhZGRyZXNzLCBlbnRyeSk7CisJCXJldCB8PSBWTV9GQVVMVF9XUklURTsKKwkJZ290byBvdXRfdW5sb2NrOworCX0KKwlnZXRfcGFnZShwYWdlKTsKKwlzcGluX3VubG9jaygmbW0tPnBhZ2VfdGFibGVfbG9jayk7CisKKwlpZiAodHJhbnNwYXJlbnRfaHVnZXBhZ2VfZW5hYmxlZCh2bWEpICYmCisJICAgICF0cmFuc3BhcmVudF9odWdlcGFnZV9kZWJ1Z19jb3coKSkKKwkJbmV3X3BhZ2UgPSBhbGxvY19odWdlcGFnZV92bWEodHJhbnNwYXJlbnRfaHVnZXBhZ2VfZGVmcmFnKHZtYSksCisJCQkJCSAgICAgIHZtYSwgaGFkZHIpOworCWVsc2UKKwkJbmV3X3BhZ2UgPSBOVUxMOworCisJaWYgKHVubGlrZWx5KCFuZXdfcGFnZSkpIHsKKwkJcmV0ID0gZG9faHVnZV9wbWRfd3BfcGFnZV9mYWxsYmFjayhtbSwgdm1hLCBhZGRyZXNzLAorCQkJCQkJICAgcG1kLCBvcmlnX3BtZCwgcGFnZSwgaGFkZHIpOworCQlwdXRfcGFnZShwYWdlKTsKKwkJZ290byBvdXQ7CisJfQorCisJaWYgKHVubGlrZWx5KG1lbV9jZ3JvdXBfbmV3cGFnZV9jaGFyZ2UobmV3X3BhZ2UsIG1tLCBHRlBfS0VSTkVMKSkpIHsKKwkJcHV0X3BhZ2UobmV3X3BhZ2UpOworCQlwdXRfcGFnZShwYWdlKTsKKwkJcmV0IHw9IFZNX0ZBVUxUX09PTTsKKwkJZ290byBvdXQ7CisJfQorCisJY29weV91c2VyX2h1Z2VfcGFnZShuZXdfcGFnZSwgcGFnZSwgaGFkZHIsIHZtYSwgSFBBR0VfUE1EX05SKTsKKwlfX1NldFBhZ2VVcHRvZGF0ZShuZXdfcGFnZSk7CisKKwlzcGluX2xvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCXB1dF9wYWdlKHBhZ2UpOworCWlmICh1bmxpa2VseSghcG1kX3NhbWUoKnBtZCwgb3JpZ19wbWQpKSkgeworCQltZW1fY2dyb3VwX3VuY2hhcmdlX3BhZ2UobmV3X3BhZ2UpOworCQlwdXRfcGFnZShuZXdfcGFnZSk7CisJfSBlbHNlIHsKKwkJcG1kX3QgZW50cnk7CisJCVZNX0JVR19PTighUGFnZUhlYWQocGFnZSkpOworCQllbnRyeSA9IG1rX3BtZChuZXdfcGFnZSwgdm1hLT52bV9wYWdlX3Byb3QpOworCQllbnRyeSA9IG1heWJlX3BtZF9ta3dyaXRlKHBtZF9ta2RpcnR5KGVudHJ5KSwgdm1hKTsKKwkJZW50cnkgPSBwbWRfbWtodWdlKGVudHJ5KTsKKwkJcG1kcF9jbGVhcl9mbHVzaF9ub3RpZnkodm1hLCBoYWRkciwgcG1kKTsKKwkJcGFnZV9hZGRfbmV3X2Fub25fcm1hcChuZXdfcGFnZSwgdm1hLCBoYWRkcik7CisJCXNldF9wbWRfYXQobW0sIGhhZGRyLCBwbWQsIGVudHJ5KTsKKwkJdXBkYXRlX21tdV9jYWNoZSh2bWEsIGFkZHJlc3MsIGVudHJ5KTsKKwkJcGFnZV9yZW1vdmVfcm1hcChwYWdlKTsKKwkJcHV0X3BhZ2UocGFnZSk7CisJCXJldCB8PSBWTV9GQVVMVF9XUklURTsKKwl9CitvdXRfdW5sb2NrOgorCXNwaW5fdW5sb2NrKCZtbS0+cGFnZV90YWJsZV9sb2NrKTsKK291dDoKKwlyZXR1cm4gcmV0OworfQorCitzdHJ1Y3QgcGFnZSAqZm9sbG93X3RyYW5zX2h1Z2VfcG1kKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJCSAgIHVuc2lnbmVkIGxvbmcgYWRkciwKKwkJCQkgICBwbWRfdCAqcG1kLAorCQkJCSAgIHVuc2lnbmVkIGludCBmbGFncykKK3sKKwlzdHJ1Y3QgcGFnZSAqcGFnZSA9IE5VTEw7CisKKwlhc3NlcnRfc3Bpbl9sb2NrZWQoJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCisJaWYgKGZsYWdzICYgRk9MTF9XUklURSAmJiAhcG1kX3dyaXRlKCpwbWQpKQorCQlnb3RvIG91dDsKKworCXBhZ2UgPSBwbWRfcGFnZSgqcG1kKTsKKwlWTV9CVUdfT04oIVBhZ2VIZWFkKHBhZ2UpKTsKKwlpZiAoZmxhZ3MgJiBGT0xMX1RPVUNIKSB7CisJCXBtZF90IF9wbWQ7CisJCS8qCisJCSAqIFdlIHNob3VsZCBzZXQgdGhlIGRpcnR5IGJpdCBvbmx5IGZvciBGT0xMX1dSSVRFIGJ1dAorCQkgKiBmb3Igbm93IHRoZSBkaXJ0eSBiaXQgaW4gdGhlIHBtZCBpcyBtZWFuaW5nbGVzcy4KKwkJICogQW5kIGlmIHRoZSBkaXJ0eSBiaXQgd2lsbCBiZWNvbWUgbWVhbmluZ2Z1bCBhbmQKKwkJICogd2UnbGwgb25seSBzZXQgaXQgd2l0aCBGT0xMX1dSSVRFLCBhbiBhdG9taWMKKwkJICogc2V0X2JpdCB3aWxsIGJlIHJlcXVpcmVkIG9uIHRoZSBwbWQgdG8gc2V0IHRoZQorCQkgKiB5b3VuZyBiaXQsIGluc3RlYWQgb2YgdGhlIGN1cnJlbnQgc2V0X3BtZF9hdC4KKwkJICovCisJCV9wbWQgPSBwbWRfbWt5b3VuZyhwbWRfbWtkaXJ0eSgqcG1kKSk7CisJCXNldF9wbWRfYXQobW0sIGFkZHIgJiBIUEFHRV9QTURfTUFTSywgcG1kLCBfcG1kKTsKKwl9CisJcGFnZSArPSAoYWRkciAmIH5IUEFHRV9QTURfTUFTSykgPj4gUEFHRV9TSElGVDsKKwlWTV9CVUdfT04oIVBhZ2VDb21wb3VuZChwYWdlKSk7CisJaWYgKGZsYWdzICYgRk9MTF9HRVQpCisJCWdldF9wYWdlKHBhZ2UpOworCitvdXQ6CisJcmV0dXJuIHBhZ2U7Cit9CisKK2ludCB6YXBfaHVnZV9wbWQoc3RydWN0IG1tdV9nYXRoZXIgKnRsYiwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCSBwbWRfdCAqcG1kKQoreworCWludCByZXQgPSAwOworCisJc3Bpbl9sb2NrKCZ0bGItPm1tLT5wYWdlX3RhYmxlX2xvY2spOworCWlmIChsaWtlbHkocG1kX3RyYW5zX2h1Z2UoKnBtZCkpKSB7CisJCWlmICh1bmxpa2VseShwbWRfdHJhbnNfc3BsaXR0aW5nKCpwbWQpKSkgeworCQkJc3Bpbl91bmxvY2soJnRsYi0+bW0tPnBhZ2VfdGFibGVfbG9jayk7CisJCQl3YWl0X3NwbGl0X2h1Z2VfcGFnZSh2bWEtPmFub25fdm1hLAorCQkJCQkgICAgIHBtZCk7CisJCX0gZWxzZSB7CisJCQlzdHJ1Y3QgcGFnZSAqcGFnZTsKKwkJCXBndGFibGVfdCBwZ3RhYmxlOworCQkJcGd0YWJsZSA9IGdldF9wbWRfaHVnZV9wdGUodGxiLT5tbSk7CisJCQlwYWdlID0gcG1kX3BhZ2UoKnBtZCk7CisJCQlwbWRfY2xlYXIocG1kKTsKKwkJCXBhZ2VfcmVtb3ZlX3JtYXAocGFnZSk7CisJCQlWTV9CVUdfT04ocGFnZV9tYXBjb3VudChwYWdlKSA8IDApOworCQkJYWRkX21tX2NvdW50ZXIodGxiLT5tbSwgTU1fQU5PTlBBR0VTLCAtSFBBR0VfUE1EX05SKTsKKwkJCVZNX0JVR19PTighUGFnZUhlYWQocGFnZSkpOworCQkJc3Bpbl91bmxvY2soJnRsYi0+bW0tPnBhZ2VfdGFibGVfbG9jayk7CisJCQl0bGJfcmVtb3ZlX3BhZ2UodGxiLCBwYWdlKTsKKwkJCXB0ZV9mcmVlKHRsYi0+bW0sIHBndGFibGUpOworCQkJcmV0ID0gMTsKKwkJfQorCX0gZWxzZQorCQlzcGluX3VubG9jaygmdGxiLT5tbS0+cGFnZV90YWJsZV9sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CisKK2ludCBtaW5jb3JlX2h1Z2VfcG1kKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLCBwbWRfdCAqcG1kLAorCQl1bnNpZ25lZCBsb25nIGFkZHIsIHVuc2lnbmVkIGxvbmcgZW5kLAorCQl1bnNpZ25lZCBjaGFyICp2ZWMpCit7CisJaW50IHJldCA9IDA7CisKKwlzcGluX2xvY2soJnZtYS0+dm1fbW0tPnBhZ2VfdGFibGVfbG9jayk7CisJaWYgKGxpa2VseShwbWRfdHJhbnNfaHVnZSgqcG1kKSkpIHsKKwkJcmV0ID0gIXBtZF90cmFuc19zcGxpdHRpbmcoKnBtZCk7CisJCXNwaW5fdW5sb2NrKCZ2bWEtPnZtX21tLT5wYWdlX3RhYmxlX2xvY2spOworCQlpZiAodW5saWtlbHkoIXJldCkpCisJCQl3YWl0X3NwbGl0X2h1Z2VfcGFnZSh2bWEtPmFub25fdm1hLCBwbWQpOworCQllbHNlIHsKKwkJCS8qCisJCQkgKiBBbGwgbG9naWNhbCBwYWdlcyBpbiB0aGUgcmFuZ2UgYXJlIHByZXNlbnQKKwkJCSAqIGlmIGJhY2tlZCBieSBhIGh1Z2UgcGFnZS4KKwkJCSAqLworCQkJbWVtc2V0KHZlYywgMSwgKGVuZCAtIGFkZHIpID4+IFBBR0VfU0hJRlQpOworCQl9CisJfSBlbHNlCisJCXNwaW5fdW5sb2NrKCZ2bWEtPnZtX21tLT5wYWdlX3RhYmxlX2xvY2spOworCisJcmV0dXJuIHJldDsKK30KKworaW50IGNoYW5nZV9odWdlX3BtZChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgcG1kX3QgKnBtZCwKKwkJdW5zaWduZWQgbG9uZyBhZGRyLCBwZ3Byb3RfdCBuZXdwcm90KQoreworCXN0cnVjdCBtbV9zdHJ1Y3QgKm1tID0gdm1hLT52bV9tbTsKKwlpbnQgcmV0ID0gMDsKKworCXNwaW5fbG9jaygmbW0tPnBhZ2VfdGFibGVfbG9jayk7CisJaWYgKGxpa2VseShwbWRfdHJhbnNfaHVnZSgqcG1kKSkpIHsKKwkJaWYgKHVubGlrZWx5KHBtZF90cmFuc19zcGxpdHRpbmcoKnBtZCkpKSB7CisJCQlzcGluX3VubG9jaygmbW0tPnBhZ2VfdGFibGVfbG9jayk7CisJCQl3YWl0X3NwbGl0X2h1Z2VfcGFnZSh2bWEtPmFub25fdm1hLCBwbWQpOworCQl9IGVsc2UgeworCQkJcG1kX3QgZW50cnk7CisKKwkJCWVudHJ5ID0gcG1kcF9nZXRfYW5kX2NsZWFyKG1tLCBhZGRyLCBwbWQpOworCQkJZW50cnkgPSBwbWRfbW9kaWZ5KGVudHJ5LCBuZXdwcm90KTsKKwkJCXNldF9wbWRfYXQobW0sIGFkZHIsIHBtZCwgZW50cnkpOworCQkJc3Bpbl91bmxvY2soJnZtYS0+dm1fbW0tPnBhZ2VfdGFibGVfbG9jayk7CisJCQlmbHVzaF90bGJfcmFuZ2Uodm1hLCBhZGRyLCBhZGRyICsgSFBBR0VfUE1EX1NJWkUpOworCQkJcmV0ID0gMTsKKwkJfQorCX0gZWxzZQorCQlzcGluX3VubG9jaygmdm1hLT52bV9tbS0+cGFnZV90YWJsZV9sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CisKK3BtZF90ICpwYWdlX2NoZWNrX2FkZHJlc3NfcG1kKHN0cnVjdCBwYWdlICpwYWdlLAorCQkJICAgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkgICAgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCisJCQkgICAgICBlbnVtIHBhZ2VfY2hlY2tfYWRkcmVzc19wbWRfZmxhZyBmbGFnKQoreworCXBnZF90ICpwZ2Q7CisJcHVkX3QgKnB1ZDsKKwlwbWRfdCAqcG1kLCAqcmV0ID0gTlVMTDsKKworCWlmIChhZGRyZXNzICYgfkhQQUdFX1BNRF9NQVNLKQorCQlnb3RvIG91dDsKKworCXBnZCA9IHBnZF9vZmZzZXQobW0sIGFkZHJlc3MpOworCWlmICghcGdkX3ByZXNlbnQoKnBnZCkpCisJCWdvdG8gb3V0OworCisJcHVkID0gcHVkX29mZnNldChwZ2QsIGFkZHJlc3MpOworCWlmICghcHVkX3ByZXNlbnQoKnB1ZCkpCisJCWdvdG8gb3V0OworCisJcG1kID0gcG1kX29mZnNldChwdWQsIGFkZHJlc3MpOworCWlmIChwbWRfbm9uZSgqcG1kKSkKKwkJZ290byBvdXQ7CisJaWYgKHBtZF9wYWdlKCpwbWQpICE9IHBhZ2UpCisJCWdvdG8gb3V0OworCS8qCisJICogc3BsaXRfdm1hKCkgbWF5IGNyZWF0ZSB0ZW1wb3JhcnkgYWxpYXNlZCBtYXBwaW5ncy4gVGhlcmUgaXMKKwkgKiBubyByaXNrIGFzIGxvbmcgYXMgYWxsIGh1Z2UgcG1kIGFyZSBmb3VuZCBhbmQgaGF2ZSB0aGVpcgorCSAqIHNwbGl0dGluZyBiaXQgc2V0IGJlZm9yZSBfX3NwbGl0X2h1Z2VfcGFnZV9yZWZjb3VudAorCSAqIHJ1bnMuIEZpbmRpbmcgdGhlIHNhbWUgaHVnZSBwbWQgbW9yZSB0aGFuIG9uY2UgZHVyaW5nIHRoZQorCSAqIHNhbWUgcm1hcCB3YWxrIGlzIG5vdCBhIHByb2JsZW0uCisJICovCisJaWYgKGZsYWcgPT0gUEFHRV9DSEVDS19BRERSRVNTX1BNRF9OT1RTUExJVFRJTkdfRkxBRyAmJgorCSAgICBwbWRfdHJhbnNfc3BsaXR0aW5nKCpwbWQpKQorCQlnb3RvIG91dDsKKwlpZiAocG1kX3RyYW5zX2h1Z2UoKnBtZCkpIHsKKwkJVk1fQlVHX09OKGZsYWcgPT0gUEFHRV9DSEVDS19BRERSRVNTX1BNRF9TUExJVFRJTkdfRkxBRyAmJgorCQkJICAhcG1kX3RyYW5zX3NwbGl0dGluZygqcG1kKSk7CisJCXJldCA9IHBtZDsKKwl9CitvdXQ6CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBfX3NwbGl0X2h1Z2VfcGFnZV9zcGxpdHRpbmcoc3RydWN0IHBhZ2UgKnBhZ2UsCisJCQkJICAgICAgIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJCSAgICAgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MpCit7CisJc3RydWN0IG1tX3N0cnVjdCAqbW0gPSB2bWEtPnZtX21tOworCXBtZF90ICpwbWQ7CisJaW50IHJldCA9IDA7CisKKwlzcGluX2xvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCXBtZCA9IHBhZ2VfY2hlY2tfYWRkcmVzc19wbWQocGFnZSwgbW0sIGFkZHJlc3MsCisJCQkJICAgICBQQUdFX0NIRUNLX0FERFJFU1NfUE1EX05PVFNQTElUVElOR19GTEFHKTsKKwlpZiAocG1kKSB7CisJCS8qCisJCSAqIFdlIGNhbid0IHRlbXBvcmFyaWx5IHNldCB0aGUgcG1kIHRvIG51bGwgaW4gb3JkZXIKKwkJICogdG8gc3BsaXQgaXQsIHRoZSBwbWQgbXVzdCByZW1haW4gbWFya2VkIGh1Z2UgYXQgYWxsCisJCSAqIHRpbWVzIG9yIHRoZSBWTSB3b24ndCB0YWtlIHRoZSBwbWRfdHJhbnNfaHVnZSBwYXRocworCQkgKiBhbmQgaXQgd29uJ3Qgd2FpdCBvbiB0aGUgYW5vbl92bWEtPnJvb3QtPmxvY2sgdG8KKwkJICogc2VyaWFsaXplIGFnYWluc3Qgc3BsaXRfaHVnZV9wYWdlKi4KKwkJICovCisJCXBtZHBfc3BsaXR0aW5nX2ZsdXNoX25vdGlmeSh2bWEsIGFkZHJlc3MsIHBtZCk7CisJCXJldCA9IDE7CisJfQorCXNwaW5fdW5sb2NrKCZtbS0+cGFnZV90YWJsZV9sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIF9fc3BsaXRfaHVnZV9wYWdlX3JlZmNvdW50KHN0cnVjdCBwYWdlICpwYWdlKQoreworCWludCBpOworCXVuc2lnbmVkIGxvbmcgaGVhZF9pbmRleCA9IHBhZ2UtPmluZGV4OworCXN0cnVjdCB6b25lICp6b25lID0gcGFnZV96b25lKHBhZ2UpOworCWludCB6b25lc3RhdDsKKworCS8qIHByZXZlbnQgUGFnZUxSVSB0byBnbyBhd2F5IGZyb20gdW5kZXIgdXMsIGFuZCBmcmVlemUgbHJ1IHN0YXRzICovCisJc3Bpbl9sb2NrX2lycSgmem9uZS0+bHJ1X2xvY2spOworCWNvbXBvdW5kX2xvY2socGFnZSk7CisKKwlmb3IgKGkgPSAxOyBpIDwgSFBBR0VfUE1EX05SOyBpKyspIHsKKwkJc3RydWN0IHBhZ2UgKnBhZ2VfdGFpbCA9IHBhZ2UgKyBpOworCisJCS8qIHRhaWxfcGFnZS0+X2NvdW50IGNhbm5vdCBjaGFuZ2UgKi8KKwkJYXRvbWljX3N1YihhdG9taWNfcmVhZCgmcGFnZV90YWlsLT5fY291bnQpLCAmcGFnZS0+X2NvdW50KTsKKwkJQlVHX09OKHBhZ2VfY291bnQocGFnZSkgPD0gMCk7CisJCWF0b21pY19hZGQocGFnZV9tYXBjb3VudChwYWdlKSArIDEsICZwYWdlX3RhaWwtPl9jb3VudCk7CisJCUJVR19PTihhdG9taWNfcmVhZCgmcGFnZV90YWlsLT5fY291bnQpIDw9IDApOworCisJCS8qIGFmdGVyIGNsZWFyaW5nIFBhZ2VUYWlsIHRoZSBndXAgcmVmY291bnQgY2FuIGJlIHJlbGVhc2VkICovCisJCXNtcF9tYigpOworCisJCS8qCisJCSAqIHJldGFpbiBod3BvaXNvbiBmbGFnIG9mIHRoZSBwb2lzb25lZCB0YWlsIHBhZ2U6CisJCSAqICAgZml4IGZvciB0aGUgdW5zdWl0YWJsZSBwcm9jZXNzIGtpbGxlZCBvbiBHdWVzdCBNYWNoaW5lKEtWTSkKKwkJICogICBieSB0aGUgbWVtb3J5LWZhaWx1cmUuCisJCSAqLworCQlwYWdlX3RhaWwtPmZsYWdzICY9IH5QQUdFX0ZMQUdTX0NIRUNLX0FUX1BSRVAgfCBfX1BHX0hXUE9JU09OOworCQlwYWdlX3RhaWwtPmZsYWdzIHw9IChwYWdlLT5mbGFncyAmCisJCQkJICAgICAoKDFMIDw8IFBHX3JlZmVyZW5jZWQpIHwKKwkJCQkgICAgICAoMUwgPDwgUEdfc3dhcGJhY2tlZCkgfAorCQkJCSAgICAgICgxTCA8PCBQR19tbG9ja2VkKSB8CisJCQkJICAgICAgKDFMIDw8IFBHX3VwdG9kYXRlKSkpOworCQlwYWdlX3RhaWwtPmZsYWdzIHw9ICgxTCA8PCBQR19kaXJ0eSk7CisKKwkJLyoKKwkJICogMSkgY2xlYXIgUGFnZVRhaWwgYmVmb3JlIG92ZXJ3cml0aW5nIGZpcnN0X3BhZ2UKKwkJICogMikgY2xlYXIgUGFnZVRhaWwgYmVmb3JlIGNsZWFyaW5nIFBhZ2VIZWFkIGZvciBWTV9CVUdfT04KKwkJICovCisJCXNtcF93bWIoKTsKKworCQkvKgorCQkgKiBfX3NwbGl0X2h1Z2VfcGFnZV9zcGxpdHRpbmcoKSBhbHJlYWR5IHNldCB0aGUKKwkJICogc3BsaXR0aW5nIGJpdCBpbiBhbGwgcG1kIHRoYXQgY291bGQgbWFwIHRoaXMKKwkJICogaHVnZXBhZ2UsIHRoYXQgd2lsbCBlbnN1cmUgbm8gQ1BVIGNhbiBhbHRlciB0aGUKKwkJICogbWFwY291bnQgb24gdGhlIGhlYWQgcGFnZS4gVGhlIG1hcGNvdW50IGlzIG9ubHkKKwkJICogYWNjb3VudGVkIGluIHRoZSBoZWFkIHBhZ2UgYW5kIGl0IGhhcyB0byBiZQorCQkgKiB0cmFuc2ZlcnJlZCB0byBhbGwgdGFpbCBwYWdlcyBpbiB0aGUgYmVsb3cgY29kZS4gU28KKwkJICogZm9yIHRoaXMgY29kZSB0byBiZSBzYWZlLCB0aGUgc3BsaXQgdGhlIG1hcGNvdW50CisJCSAqIGNhbid0IGNoYW5nZS4gQnV0IHRoYXQgZG9lc24ndCBtZWFuIHVzZXJsYW5kIGNhbid0CisJCSAqIGtlZXAgY2hhbmdpbmcgYW5kIHJlYWRpbmcgdGhlIHBhZ2UgY29udGVudHMgd2hpbGUKKwkJICogd2UgdHJhbnNmZXIgdGhlIG1hcGNvdW50LCBzbyB0aGUgcG1kIHNwbGl0dGluZworCQkgKiBzdGF0dXMgaXMgYWNoaWV2ZWQgc2V0dGluZyBhIHJlc2VydmVkIGJpdCBpbiB0aGUKKwkJICogcG1kLCBub3QgYnkgY2xlYXJpbmcgdGhlIHByZXNlbnQgYml0LgorCQkqLworCQlCVUdfT04ocGFnZV9tYXBjb3VudChwYWdlX3RhaWwpKTsKKwkJcGFnZV90YWlsLT5fbWFwY291bnQgPSBwYWdlLT5fbWFwY291bnQ7CisKKwkJQlVHX09OKHBhZ2VfdGFpbC0+bWFwcGluZyk7CisJCXBhZ2VfdGFpbC0+bWFwcGluZyA9IHBhZ2UtPm1hcHBpbmc7CisKKwkJcGFnZV90YWlsLT5pbmRleCA9ICsraGVhZF9pbmRleDsKKworCQlCVUdfT04oIVBhZ2VBbm9uKHBhZ2VfdGFpbCkpOworCQlCVUdfT04oIVBhZ2VVcHRvZGF0ZShwYWdlX3RhaWwpKTsKKwkJQlVHX09OKCFQYWdlRGlydHkocGFnZV90YWlsKSk7CisJCUJVR19PTighUGFnZVN3YXBCYWNrZWQocGFnZV90YWlsKSk7CisKKwkJbWVtX2Nncm91cF9zcGxpdF9odWdlX2ZpeHVwKHBhZ2UsIHBhZ2VfdGFpbCk7CisKKwkJbHJ1X2FkZF9wYWdlX3RhaWwoem9uZSwgcGFnZSwgcGFnZV90YWlsKTsKKwl9CisKKwlfX2RlY196b25lX3BhZ2Vfc3RhdGUocGFnZSwgTlJfQU5PTl9UUkFOU1BBUkVOVF9IVUdFUEFHRVMpOworCV9fbW9kX3pvbmVfcGFnZV9zdGF0ZSh6b25lLCBOUl9BTk9OX1BBR0VTLCBIUEFHRV9QTURfTlIpOworCisJLyoKKwkgKiBBIGh1Z2VwYWdlIGNvdW50cyBmb3IgSFBBR0VfUE1EX05SIHBhZ2VzIG9uIHRoZSBMUlUgc3RhdGlzdGljcywKKwkgKiBzbyBhZGp1c3QgdGhvc2UgYXBwcm9wcmlhdGVseSBpZiB0aGlzIHBhZ2UgaXMgb24gdGhlIExSVS4KKwkgKi8KKwlpZiAoUGFnZUxSVShwYWdlKSkgeworCQl6b25lc3RhdCA9IE5SX0xSVV9CQVNFICsgcGFnZV9scnUocGFnZSk7CisJCV9fbW9kX3pvbmVfcGFnZV9zdGF0ZSh6b25lLCB6b25lc3RhdCwgLShIUEFHRV9QTURfTlItMSkpOworCX0KKworCUNsZWFyUGFnZUNvbXBvdW5kKHBhZ2UpOworCWNvbXBvdW5kX3VubG9jayhwYWdlKTsKKwlzcGluX3VubG9ja19pcnEoJnpvbmUtPmxydV9sb2NrKTsKKworCWZvciAoaSA9IDE7IGkgPCBIUEFHRV9QTURfTlI7IGkrKykgeworCQlzdHJ1Y3QgcGFnZSAqcGFnZV90YWlsID0gcGFnZSArIGk7CisJCUJVR19PTihwYWdlX2NvdW50KHBhZ2VfdGFpbCkgPD0gMCk7CisJCS8qCisJCSAqIFRhaWwgcGFnZXMgbWF5IGJlIGZyZWVkIGlmIHRoZXJlIHdhc24ndCBhbnkgbWFwcGluZworCQkgKiBsaWtlIGlmIGFkZF90b19zd2FwKCkgaXMgcnVubmluZyBvbiBhIGxydSBwYWdlIHRoYXQKKwkJICogaGFkIGl0cyBtYXBwaW5nIHphcHBlZC4gQW5kIGZyZWVpbmcgdGhlc2UgcGFnZXMKKwkJICogcmVxdWlyZXMgdGFraW5nIHRoZSBscnVfbG9jayBzbyB3ZSBkbyB0aGUgcHV0X3BhZ2UKKwkJICogb2YgdGhlIHRhaWwgcGFnZXMgYWZ0ZXIgdGhlIHNwbGl0IGlzIGNvbXBsZXRlLgorCQkgKi8KKwkJcHV0X3BhZ2UocGFnZV90YWlsKTsKKwl9CisKKwkvKgorCSAqIE9ubHkgdGhlIGhlYWQgcGFnZSAobm93IGJlY29tZSBhIHJlZ3VsYXIgcGFnZSkgaXMgcmVxdWlyZWQKKwkgKiB0byBiZSBwaW5uZWQgYnkgdGhlIGNhbGxlci4KKwkgKi8KKwlCVUdfT04ocGFnZV9jb3VudChwYWdlKSA8PSAwKTsKK30KKworc3RhdGljIGludCBfX3NwbGl0X2h1Z2VfcGFnZV9tYXAoc3RydWN0IHBhZ2UgKnBhZ2UsCisJCQkJIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJCSB1bnNpZ25lZCBsb25nIGFkZHJlc3MpCit7CisJc3RydWN0IG1tX3N0cnVjdCAqbW0gPSB2bWEtPnZtX21tOworCXBtZF90ICpwbWQsIF9wbWQ7CisJaW50IHJldCA9IDAsIGk7CisJcGd0YWJsZV90IHBndGFibGU7CisJdW5zaWduZWQgbG9uZyBoYWRkcjsKKworCXNwaW5fbG9jaygmbW0tPnBhZ2VfdGFibGVfbG9jayk7CisJcG1kID0gcGFnZV9jaGVja19hZGRyZXNzX3BtZChwYWdlLCBtbSwgYWRkcmVzcywKKwkJCQkgICAgIFBBR0VfQ0hFQ0tfQUREUkVTU19QTURfU1BMSVRUSU5HX0ZMQUcpOworCWlmIChwbWQpIHsKKwkJcGd0YWJsZSA9IGdldF9wbWRfaHVnZV9wdGUobW0pOworCQlwbWRfcG9wdWxhdGUobW0sICZfcG1kLCBwZ3RhYmxlKTsKKworCQlmb3IgKGkgPSAwLCBoYWRkciA9IGFkZHJlc3M7IGkgPCBIUEFHRV9QTURfTlI7CisJCSAgICAgaSsrLCBoYWRkciArPSBQQUdFX1NJWkUpIHsKKwkJCXB0ZV90ICpwdGUsIGVudHJ5OworCQkJQlVHX09OKFBhZ2VDb21wb3VuZChwYWdlK2kpKTsKKwkJCWVudHJ5ID0gbWtfcHRlKHBhZ2UgKyBpLCB2bWEtPnZtX3BhZ2VfcHJvdCk7CisJCQllbnRyeSA9IG1heWJlX21rd3JpdGUocHRlX21rZGlydHkoZW50cnkpLCB2bWEpOworCQkJaWYgKCFwbWRfd3JpdGUoKnBtZCkpCisJCQkJZW50cnkgPSBwdGVfd3Jwcm90ZWN0KGVudHJ5KTsKKwkJCWVsc2UKKwkJCQlCVUdfT04ocGFnZV9tYXBjb3VudChwYWdlKSAhPSAxKTsKKwkJCWlmICghcG1kX3lvdW5nKCpwbWQpKQorCQkJCWVudHJ5ID0gcHRlX21rb2xkKGVudHJ5KTsKKwkJCXB0ZSA9IHB0ZV9vZmZzZXRfbWFwKCZfcG1kLCBoYWRkcik7CisJCQlCVUdfT04oIXB0ZV9ub25lKCpwdGUpKTsKKwkJCXNldF9wdGVfYXQobW0sIGhhZGRyLCBwdGUsIGVudHJ5KTsKKwkJCXB0ZV91bm1hcChwdGUpOworCQl9CisKKwkJbW0tPm5yX3B0ZXMrKzsKKwkJc21wX3dtYigpOyAvKiBtYWtlIHB0ZSB2aXNpYmxlIGJlZm9yZSBwbWQgKi8KKwkJLyoKKwkJICogVXAgdG8gdGhpcyBwb2ludCB0aGUgcG1kIGlzIHByZXNlbnQgYW5kIGh1Z2UgYW5kCisJCSAqIHVzZXJsYW5kIGhhcyB0aGUgd2hvbGUgYWNjZXNzIHRvIHRoZSBodWdlcGFnZQorCQkgKiBkdXJpbmcgdGhlIHNwbGl0ICh3aGljaCBoYXBwZW5zIGluIHBsYWNlKS4gSWYgd2UKKwkJICogb3ZlcndyaXRlIHRoZSBwbWQgd2l0aCB0aGUgbm90LWh1Z2UgdmVyc2lvbgorCQkgKiBwb2ludGluZyB0byB0aGUgcHRlIGhlcmUgKHdoaWNoIG9mIGNvdXJzZSB3ZSBjb3VsZAorCQkgKiBpZiBhbGwgQ1BVcyB3ZXJlIGJ1ZyBmcmVlKSwgdXNlcmxhbmQgY291bGQgdHJpZ2dlcgorCQkgKiBhIHNtYWxsIHBhZ2Ugc2l6ZSBUTEIgbWlzcyBvbiB0aGUgc21hbGwgc2l6ZWQgVExCCisJCSAqIHdoaWxlIHRoZSBodWdlcGFnZSBUTEIgZW50cnkgaXMgc3RpbGwgZXN0YWJsaXNoZWQKKwkJICogaW4gdGhlIGh1Z2UgVExCLiBTb21lIENQVSBkb2Vzbid0IGxpa2UgdGhhdC4gU2VlCisJCSAqIGh0dHA6Ly9zdXBwb3J0LmFtZC5jb20vdXMvUHJvY2Vzc29yX1RlY2hEb2NzLzQxMzIyLnBkZiwKKwkJICogRXJyYXR1bSAzODMgb24gcGFnZSA5My4gSW50ZWwgc2hvdWxkIGJlIHNhZmUgYnV0IGlzCisJCSAqIGFsc28gd2FybnMgdGhhdCBpdCdzIG9ubHkgc2FmZSBpZiB0aGUgcGVybWlzc2lvbgorCQkgKiBhbmQgY2FjaGUgYXR0cmlidXRlcyBvZiB0aGUgdHdvIGVudHJpZXMgbG9hZGVkIGluCisJCSAqIHRoZSB0d28gVExCIGlzIGlkZW50aWNhbCAod2hpY2ggc2hvdWxkIGJlIHRoZSBjYXNlCisJCSAqIGhlcmUpLiBCdXQgaXQgaXMgZ2VuZXJhbGx5IHNhZmVyIHRvIG5ldmVyIGFsbG93CisJCSAqIHNtYWxsIGFuZCBodWdlIFRMQiBlbnRyaWVzIGZvciB0aGUgc2FtZSB2aXJ0dWFsCisJCSAqIGFkZHJlc3MgdG8gYmUgbG9hZGVkIHNpbXVsdGFuZW91c2x5LiBTbyBpbnN0ZWFkIG9mCisJCSAqIGRvaW5nICJwbWRfcG9wdWxhdGUoKTsgZmx1c2hfdGxiX3JhbmdlKCk7IiB3ZSBmaXJzdAorCQkgKiBtYXJrIHRoZSBjdXJyZW50IHBtZCBub3RwcmVzZW50IChhdG9taWNhbGx5IGJlY2F1c2UKKwkJICogaGVyZSB0aGUgcG1kX3RyYW5zX2h1Z2UgYW5kIHBtZF90cmFuc19zcGxpdHRpbmcKKwkJICogbXVzdCByZW1haW4gc2V0IGF0IGFsbCB0aW1lcyBvbiB0aGUgcG1kIHVudGlsIHRoZQorCQkgKiBzcGxpdCBpcyBjb21wbGV0ZSBmb3IgdGhpcyBwbWQpLCB0aGVuIHdlIGZsdXNoIHRoZQorCQkgKiBTTVAgVExCIGFuZCBmaW5hbGx5IHdlIHdyaXRlIHRoZSBub24taHVnZSB2ZXJzaW9uCisJCSAqIG9mIHRoZSBwbWQgZW50cnkgd2l0aCBwbWRfcG9wdWxhdGUuCisJCSAqLworCQlzZXRfcG1kX2F0KG1tLCBhZGRyZXNzLCBwbWQsIHBtZF9ta25vdHByZXNlbnQoKnBtZCkpOworCQlmbHVzaF90bGJfcmFuZ2Uodm1hLCBhZGRyZXNzLCBhZGRyZXNzICsgSFBBR0VfUE1EX1NJWkUpOworCQlwbWRfcG9wdWxhdGUobW0sIHBtZCwgcGd0YWJsZSk7CisJCXJldCA9IDE7CisJfQorCXNwaW5fdW5sb2NrKCZtbS0+cGFnZV90YWJsZV9sb2NrKTsKKworCXJldHVybiByZXQ7Cit9CisKKy8qIG11c3QgYmUgY2FsbGVkIHdpdGggYW5vbl92bWEtPnJvb3QtPmxvY2sgaG9sZCAqLworc3RhdGljIHZvaWQgX19zcGxpdF9odWdlX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UsCisJCQkgICAgICBzdHJ1Y3QgYW5vbl92bWEgKmFub25fdm1hKQoreworCWludCBtYXBjb3VudCwgbWFwY291bnQyOworCXN0cnVjdCBhbm9uX3ZtYV9jaGFpbiAqYXZjOworCisJQlVHX09OKCFQYWdlSGVhZChwYWdlKSk7CisJQlVHX09OKFBhZ2VUYWlsKHBhZ2UpKTsKKworCW1hcGNvdW50ID0gMDsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGF2YywgJmFub25fdm1hLT5oZWFkLCBzYW1lX2Fub25fdm1hKSB7CisJCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hID0gYXZjLT52bWE7CisJCXVuc2lnbmVkIGxvbmcgYWRkciA9IHZtYV9hZGRyZXNzKHBhZ2UsIHZtYSk7CisJCUJVR19PTihpc192bWFfdGVtcG9yYXJ5X3N0YWNrKHZtYSkpOworCQlpZiAoYWRkciA9PSAtRUZBVUxUKQorCQkJY29udGludWU7CisJCW1hcGNvdW50ICs9IF9fc3BsaXRfaHVnZV9wYWdlX3NwbGl0dGluZyhwYWdlLCB2bWEsIGFkZHIpOworCX0KKwkvKgorCSAqIEl0IGlzIGNyaXRpY2FsIHRoYXQgbmV3IHZtYXMgYXJlIGFkZGVkIHRvIHRoZSB0YWlsIG9mIHRoZQorCSAqIGFub25fdm1hIGxpc3QuIFRoaXMgZ3VhcmFudGVzIHRoYXQgaWYgY29weV9odWdlX3BtZCgpIHJ1bnMKKwkgKiBhbmQgZXN0YWJsaXNoZXMgYSBjaGlsZCBwbWQgYmVmb3JlCisJICogX19zcGxpdF9odWdlX3BhZ2Vfc3BsaXR0aW5nKCkgZnJlZXplcyB0aGUgcGFyZW50IHBtZCAoc28gaWYKKwkgKiB3ZSBmYWlsIHRvIHByZXZlbnQgY29weV9odWdlX3BtZCgpIGZyb20gcnVubmluZyB1bnRpbCB0aGUKKwkgKiB3aG9sZSBfX3NwbGl0X2h1Z2VfcGFnZSgpIGlzIGNvbXBsZXRlKSwgd2Ugd2lsbCBzdGlsbCBzZWUKKwkgKiB0aGUgbmV3bHkgZXN0YWJsaXNoZWQgcG1kIG9mIHRoZSBjaGlsZCBsYXRlciBkdXJpbmcgdGhlCisJICogd2FsaywgdG8gYmUgYWJsZSB0byBzZXQgaXQgYXMgcG1kX3RyYW5zX3NwbGl0dGluZyB0b28uCisJICovCisJaWYgKG1hcGNvdW50ICE9IHBhZ2VfbWFwY291bnQocGFnZSkpCisJCXByaW50ayhLRVJOX0VSUiAibWFwY291bnQgJWQgcGFnZV9tYXBjb3VudCAlZFxuIiwKKwkJICAgICAgIG1hcGNvdW50LCBwYWdlX21hcGNvdW50KHBhZ2UpKTsKKwlCVUdfT04obWFwY291bnQgIT0gcGFnZV9tYXBjb3VudChwYWdlKSk7CisKKwlfX3NwbGl0X2h1Z2VfcGFnZV9yZWZjb3VudChwYWdlKTsKKworCW1hcGNvdW50MiA9IDA7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShhdmMsICZhbm9uX3ZtYS0+aGVhZCwgc2FtZV9hbm9uX3ZtYSkgeworCQlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSA9IGF2Yy0+dm1hOworCQl1bnNpZ25lZCBsb25nIGFkZHIgPSB2bWFfYWRkcmVzcyhwYWdlLCB2bWEpOworCQlCVUdfT04oaXNfdm1hX3RlbXBvcmFyeV9zdGFjayh2bWEpKTsKKwkJaWYgKGFkZHIgPT0gLUVGQVVMVCkKKwkJCWNvbnRpbnVlOworCQltYXBjb3VudDIgKz0gX19zcGxpdF9odWdlX3BhZ2VfbWFwKHBhZ2UsIHZtYSwgYWRkcik7CisJfQorCWlmIChtYXBjb3VudCAhPSBtYXBjb3VudDIpCisJCXByaW50ayhLRVJOX0VSUiAibWFwY291bnQgJWQgbWFwY291bnQyICVkIHBhZ2VfbWFwY291bnQgJWRcbiIsCisJCSAgICAgICBtYXBjb3VudCwgbWFwY291bnQyLCBwYWdlX21hcGNvdW50KHBhZ2UpKTsKKwlCVUdfT04obWFwY291bnQgIT0gbWFwY291bnQyKTsKK30KKworaW50IHNwbGl0X2h1Z2VfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwlzdHJ1Y3QgYW5vbl92bWEgKmFub25fdm1hOworCWludCByZXQgPSAxOworCisJQlVHX09OKCFQYWdlQW5vbihwYWdlKSk7CisJYW5vbl92bWEgPSBwYWdlX2xvY2tfYW5vbl92bWEocGFnZSk7CisJaWYgKCFhbm9uX3ZtYSkKKwkJZ290byBvdXQ7CisJcmV0ID0gMDsKKwlpZiAoIVBhZ2VDb21wb3VuZChwYWdlKSkKKwkJZ290byBvdXRfdW5sb2NrOworCisJQlVHX09OKCFQYWdlU3dhcEJhY2tlZChwYWdlKSk7CisJX19zcGxpdF9odWdlX3BhZ2UocGFnZSwgYW5vbl92bWEpOworCisJQlVHX09OKFBhZ2VDb21wb3VuZChwYWdlKSk7CitvdXRfdW5sb2NrOgorCXBhZ2VfdW5sb2NrX2Fub25fdm1hKGFub25fdm1hKTsKK291dDoKKwlyZXR1cm4gcmV0OworfQorCitpbnQgaHVnZXBhZ2VfbWFkdmlzZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJICAgICB1bnNpZ25lZCBsb25nICp2bV9mbGFncywgaW50IGFkdmljZSkKK3sKKwlzd2l0Y2ggKGFkdmljZSkgeworCWNhc2UgTUFEVl9IVUdFUEFHRToKKwkJLyoKKwkJICogQmUgc29tZXdoYXQgb3Zlci1wcm90ZWN0aXZlIGxpa2UgS1NNIGZvciBub3chCisJCSAqLworCQlpZiAoKnZtX2ZsYWdzICYgKFZNX0hVR0VQQUdFIHwKKwkJCQkgVk1fU0hBUkVEICAgfCBWTV9NQVlTSEFSRSAgIHwKKwkJCQkgVk1fUEZOTUFQICAgfCBWTV9JTyAgICAgIHwgVk1fRE9OVEVYUEFORCB8CisJCQkJIFZNX1JFU0VSVkVEIHwgVk1fSFVHRVRMQiB8IFZNX0lOU0VSVFBBR0UgfAorCQkJCSBWTV9NSVhFRE1BUCB8IFZNX1NBTykpCisJCQlyZXR1cm4gLUVJTlZBTDsKKwkJKnZtX2ZsYWdzICY9IH5WTV9OT0hVR0VQQUdFOworCQkqdm1fZmxhZ3MgfD0gVk1fSFVHRVBBR0U7CisJCS8qCisJCSAqIElmIHRoZSB2bWEgYmVjb21lIGdvb2QgZm9yIGtodWdlcGFnZWQgdG8gc2NhbiwKKwkJICogcmVnaXN0ZXIgaXQgaGVyZSB3aXRob3V0IHdhaXRpbmcgYSBwYWdlIGZhdWx0IHRoYXQKKwkJICogbWF5IG5vdCBoYXBwZW4gYW55IHRpbWUgc29vbi4KKwkJICovCisJCWlmICh1bmxpa2VseShraHVnZXBhZ2VkX2VudGVyX3ZtYV9tZXJnZSh2bWEpKSkKKwkJCXJldHVybiAtRU5PTUVNOworCQlicmVhazsKKwljYXNlIE1BRFZfTk9IVUdFUEFHRToKKwkJLyoKKwkJICogQmUgc29tZXdoYXQgb3Zlci1wcm90ZWN0aXZlIGxpa2UgS1NNIGZvciBub3chCisJCSAqLworCQlpZiAoKnZtX2ZsYWdzICYgKFZNX05PSFVHRVBBR0UgfAorCQkJCSBWTV9TSEFSRUQgICB8IFZNX01BWVNIQVJFICAgfAorCQkJCSBWTV9QRk5NQVAgICB8IFZNX0lPICAgICAgfCBWTV9ET05URVhQQU5EIHwKKwkJCQkgVk1fUkVTRVJWRUQgfCBWTV9IVUdFVExCIHwgVk1fSU5TRVJUUEFHRSB8CisJCQkJIFZNX01JWEVETUFQIHwgVk1fU0FPKSkKKwkJCXJldHVybiAtRUlOVkFMOworCQkqdm1fZmxhZ3MgJj0gflZNX0hVR0VQQUdFOworCQkqdm1fZmxhZ3MgfD0gVk1fTk9IVUdFUEFHRTsKKwkJLyoKKwkJICogU2V0dGluZyBWTV9OT0hVR0VQQUdFIHdpbGwgcHJldmVudCBraHVnZXBhZ2VkIGZyb20gc2Nhbm5pbmcKKwkJICogdGhpcyB2bWEgZXZlbiBpZiB3ZSBsZWF2ZSB0aGUgbW0gcmVnaXN0ZXJlZCBpbiBraHVnZXBhZ2VkIGlmCisJCSAqIGl0IGdvdCByZWdpc3RlcmVkIGJlZm9yZSBWTV9OT0hVR0VQQUdFIHdhcyBzZXQuCisJCSAqLworCQlicmVhazsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBfX2luaXQga2h1Z2VwYWdlZF9zbGFiX2luaXQodm9pZCkKK3sKKwltbV9zbG90X2NhY2hlID0ga21lbV9jYWNoZV9jcmVhdGUoImtodWdlcGFnZWRfbW1fc2xvdCIsCisJCQkJCSAgc2l6ZW9mKHN0cnVjdCBtbV9zbG90KSwKKwkJCQkJICBfX2FsaWdub2ZfXyhzdHJ1Y3QgbW1fc2xvdCksIDAsIE5VTEwpOworCWlmICghbW1fc2xvdF9jYWNoZSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgX19pbml0IGtodWdlcGFnZWRfc2xhYl9mcmVlKHZvaWQpCit7CisJa21lbV9jYWNoZV9kZXN0cm95KG1tX3Nsb3RfY2FjaGUpOworCW1tX3Nsb3RfY2FjaGUgPSBOVUxMOworfQorCitzdGF0aWMgaW5saW5lIHN0cnVjdCBtbV9zbG90ICphbGxvY19tbV9zbG90KHZvaWQpCit7CisJaWYgKCFtbV9zbG90X2NhY2hlKQkvKiBpbml0aWFsaXphdGlvbiBmYWlsZWQgKi8KKwkJcmV0dXJuIE5VTEw7CisJcmV0dXJuIGttZW1fY2FjaGVfemFsbG9jKG1tX3Nsb3RfY2FjaGUsIEdGUF9LRVJORUwpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgZnJlZV9tbV9zbG90KHN0cnVjdCBtbV9zbG90ICptbV9zbG90KQoreworCWttZW1fY2FjaGVfZnJlZShtbV9zbG90X2NhY2hlLCBtbV9zbG90KTsKK30KKworc3RhdGljIGludCBfX2luaXQgbW1fc2xvdHNfaGFzaF9pbml0KHZvaWQpCit7CisJbW1fc2xvdHNfaGFzaCA9IGt6YWxsb2MoTU1fU0xPVFNfSEFTSF9IRUFEUyAqIHNpemVvZihzdHJ1Y3QgaGxpc3RfaGVhZCksCisJCQkJR0ZQX0tFUk5FTCk7CisJaWYgKCFtbV9zbG90c19oYXNoKQorCQlyZXR1cm4gLUVOT01FTTsKKwlyZXR1cm4gMDsKK30KKworI2lmIDAKK3N0YXRpYyB2b2lkIF9faW5pdCBtbV9zbG90c19oYXNoX2ZyZWUodm9pZCkKK3sKKwlrZnJlZShtbV9zbG90c19oYXNoKTsKKwltbV9zbG90c19oYXNoID0gTlVMTDsKK30KKyNlbmRpZgorCitzdGF0aWMgc3RydWN0IG1tX3Nsb3QgKmdldF9tbV9zbG90KHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQoreworCXN0cnVjdCBtbV9zbG90ICptbV9zbG90OworCXN0cnVjdCBobGlzdF9oZWFkICpidWNrZXQ7CisJc3RydWN0IGhsaXN0X25vZGUgKm5vZGU7CisKKwlidWNrZXQgPSAmbW1fc2xvdHNfaGFzaFsoKHVuc2lnbmVkIGxvbmcpbW0gLyBzaXplb2Yoc3RydWN0IG1tX3N0cnVjdCkpCisJCQkJJSBNTV9TTE9UU19IQVNIX0hFQURTXTsKKwlobGlzdF9mb3JfZWFjaF9lbnRyeShtbV9zbG90LCBub2RlLCBidWNrZXQsIGhhc2gpIHsKKwkJaWYgKG1tID09IG1tX3Nsb3QtPm1tKQorCQkJcmV0dXJuIG1tX3Nsb3Q7CisJfQorCXJldHVybiBOVUxMOworfQorCitzdGF0aWMgdm9pZCBpbnNlcnRfdG9fbW1fc2xvdHNfaGFzaChzdHJ1Y3QgbW1fc3RydWN0ICptbSwKKwkJCQkgICAgc3RydWN0IG1tX3Nsb3QgKm1tX3Nsb3QpCit7CisJc3RydWN0IGhsaXN0X2hlYWQgKmJ1Y2tldDsKKworCWJ1Y2tldCA9ICZtbV9zbG90c19oYXNoWygodW5zaWduZWQgbG9uZyltbSAvIHNpemVvZihzdHJ1Y3QgbW1fc3RydWN0KSkKKwkJCQklIE1NX1NMT1RTX0hBU0hfSEVBRFNdOworCW1tX3Nsb3QtPm1tID0gbW07CisJaGxpc3RfYWRkX2hlYWQoJm1tX3Nsb3QtPmhhc2gsIGJ1Y2tldCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IGtodWdlcGFnZWRfdGVzdF9leGl0KHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQoreworCXJldHVybiBhdG9taWNfcmVhZCgmbW0tPm1tX3VzZXJzKSA9PSAwOworfQorCitpbnQgX19raHVnZXBhZ2VkX2VudGVyKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQoreworCXN0cnVjdCBtbV9zbG90ICptbV9zbG90OworCWludCB3YWtldXA7CisKKwltbV9zbG90ID0gYWxsb2NfbW1fc2xvdCgpOworCWlmICghbW1fc2xvdCkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwkvKiBfX2todWdlcGFnZWRfZXhpdCgpIG11c3Qgbm90IHJ1biBmcm9tIHVuZGVyIHVzICovCisJVk1fQlVHX09OKGtodWdlcGFnZWRfdGVzdF9leGl0KG1tKSk7CisJaWYgKHVubGlrZWx5KHRlc3RfYW5kX3NldF9iaXQoTU1GX1ZNX0hVR0VQQUdFLCAmbW0tPmZsYWdzKSkpIHsKKwkJZnJlZV9tbV9zbG90KG1tX3Nsb3QpOworCQlyZXR1cm4gMDsKKwl9CisKKwlzcGluX2xvY2soJmtodWdlcGFnZWRfbW1fbG9jayk7CisJaW5zZXJ0X3RvX21tX3Nsb3RzX2hhc2gobW0sIG1tX3Nsb3QpOworCS8qCisJICogSW5zZXJ0IGp1c3QgYmVoaW5kIHRoZSBzY2FubmluZyBjdXJzb3IsIHRvIGxldCB0aGUgYXJlYSBzZXR0bGUKKwkgKiBkb3duIGEgbGl0dGxlLgorCSAqLworCXdha2V1cCA9IGxpc3RfZW1wdHkoJmtodWdlcGFnZWRfc2Nhbi5tbV9oZWFkKTsKKwlsaXN0X2FkZF90YWlsKCZtbV9zbG90LT5tbV9ub2RlLCAma2h1Z2VwYWdlZF9zY2FuLm1tX2hlYWQpOworCXNwaW5fdW5sb2NrKCZraHVnZXBhZ2VkX21tX2xvY2spOworCisJYXRvbWljX2luYygmbW0tPm1tX2NvdW50KTsKKwlpZiAod2FrZXVwKQorCQl3YWtlX3VwX2ludGVycnVwdGlibGUoJmtodWdlcGFnZWRfd2FpdCk7CisKKwlyZXR1cm4gMDsKK30KKworaW50IGtodWdlcGFnZWRfZW50ZXJfdm1hX21lcmdlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQoreworCXVuc2lnbmVkIGxvbmcgaHN0YXJ0LCBoZW5kOworCWlmICghdm1hLT5hbm9uX3ZtYSkKKwkJLyoKKwkJICogTm90IHlldCBmYXVsdGVkIGluIHNvIHdlIHdpbGwgcmVnaXN0ZXIgbGF0ZXIgaW4gdGhlCisJCSAqIHBhZ2UgZmF1bHQgaWYgbmVlZGVkLgorCQkgKi8KKwkJcmV0dXJuIDA7CisJaWYgKHZtYS0+dm1fZmlsZSB8fCB2bWEtPnZtX29wcykKKwkJLyoga2h1Z2VwYWdlZCBub3QgeWV0IHdvcmtpbmcgb24gZmlsZSBvciBzcGVjaWFsIG1hcHBpbmdzICovCisJCXJldHVybiAwOworCVZNX0JVR19PTihpc19saW5lYXJfcGZuX21hcHBpbmcodm1hKSB8fCBpc19wZm5fbWFwcGluZyh2bWEpKTsKKwloc3RhcnQgPSAodm1hLT52bV9zdGFydCArIH5IUEFHRV9QTURfTUFTSykgJiBIUEFHRV9QTURfTUFTSzsKKwloZW5kID0gdm1hLT52bV9lbmQgJiBIUEFHRV9QTURfTUFTSzsKKwlpZiAoaHN0YXJ0IDwgaGVuZCkKKwkJcmV0dXJuIGtodWdlcGFnZWRfZW50ZXIodm1hKTsKKwlyZXR1cm4gMDsKK30KKwordm9pZCBfX2todWdlcGFnZWRfZXhpdChzdHJ1Y3QgbW1fc3RydWN0ICptbSkKK3sKKwlzdHJ1Y3QgbW1fc2xvdCAqbW1fc2xvdDsKKwlpbnQgZnJlZSA9IDA7CisKKwlzcGluX2xvY2soJmtodWdlcGFnZWRfbW1fbG9jayk7CisJbW1fc2xvdCA9IGdldF9tbV9zbG90KG1tKTsKKwlpZiAobW1fc2xvdCAmJiBraHVnZXBhZ2VkX3NjYW4ubW1fc2xvdCAhPSBtbV9zbG90KSB7CisJCWhsaXN0X2RlbCgmbW1fc2xvdC0+aGFzaCk7CisJCWxpc3RfZGVsKCZtbV9zbG90LT5tbV9ub2RlKTsKKwkJZnJlZSA9IDE7CisJfQorCisJaWYgKGZyZWUpIHsKKwkJc3Bpbl91bmxvY2soJmtodWdlcGFnZWRfbW1fbG9jayk7CisJCWNsZWFyX2JpdChNTUZfVk1fSFVHRVBBR0UsICZtbS0+ZmxhZ3MpOworCQlmcmVlX21tX3Nsb3QobW1fc2xvdCk7CisJCW1tZHJvcChtbSk7CisJfSBlbHNlIGlmIChtbV9zbG90KSB7CisJCXNwaW5fdW5sb2NrKCZraHVnZXBhZ2VkX21tX2xvY2spOworCQkvKgorCQkgKiBUaGlzIGlzIHJlcXVpcmVkIHRvIHNlcmlhbGl6ZSBhZ2FpbnN0CisJCSAqIGtodWdlcGFnZWRfdGVzdF9leGl0KCkgKHdoaWNoIGlzIGd1YXJhbnRlZWQgdG8gcnVuCisJCSAqIHVuZGVyIG1tYXAgc2VtIHJlYWQgbW9kZSkuIFN0b3AgaGVyZSAoYWZ0ZXIgd2UKKwkJICogcmV0dXJuIGFsbCBwYWdldGFibGVzIHdpbGwgYmUgZGVzdHJveWVkKSB1bnRpbAorCQkgKiBraHVnZXBhZ2VkIGhhcyBmaW5pc2hlZCB3b3JraW5nIG9uIHRoZSBwYWdldGFibGVzCisJCSAqIHVuZGVyIHRoZSBtbWFwX3NlbS4KKwkJICovCisJCWRvd25fd3JpdGUoJm1tLT5tbWFwX3NlbSk7CisJCXVwX3dyaXRlKCZtbS0+bW1hcF9zZW0pOworCX0gZWxzZQorCQlzcGluX3VubG9jaygma2h1Z2VwYWdlZF9tbV9sb2NrKTsKK30KKworc3RhdGljIHZvaWQgcmVsZWFzZV9wdGVfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwkvKiAwIHN0YW5kcyBmb3IgcGFnZV9pc19maWxlX2NhY2hlKHBhZ2UpID09IGZhbHNlICovCisJZGVjX3pvbmVfcGFnZV9zdGF0ZShwYWdlLCBOUl9JU09MQVRFRF9BTk9OICsgMCk7CisJdW5sb2NrX3BhZ2UocGFnZSk7CisJcHV0YmFja19scnVfcGFnZShwYWdlKTsKK30KKworc3RhdGljIHZvaWQgcmVsZWFzZV9wdGVfcGFnZXMocHRlX3QgKnB0ZSwgcHRlX3QgKl9wdGUpCit7CisJd2hpbGUgKC0tX3B0ZSA+PSBwdGUpIHsKKwkJcHRlX3QgcHRldmFsID0gKl9wdGU7CisJCWlmICghcHRlX25vbmUocHRldmFsKSkKKwkJCXJlbGVhc2VfcHRlX3BhZ2UocHRlX3BhZ2UocHRldmFsKSk7CisJfQorfQorCitzdGF0aWMgdm9pZCByZWxlYXNlX2FsbF9wdGVfcGFnZXMocHRlX3QgKnB0ZSkKK3sKKwlyZWxlYXNlX3B0ZV9wYWdlcyhwdGUsIHB0ZSArIEhQQUdFX1BNRF9OUik7Cit9CisKK3N0YXRpYyBpbnQgX19jb2xsYXBzZV9odWdlX3BhZ2VfaXNvbGF0ZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCQkJdW5zaWduZWQgbG9uZyBhZGRyZXNzLAorCQkJCQlwdGVfdCAqcHRlKQoreworCXN0cnVjdCBwYWdlICpwYWdlOworCXB0ZV90ICpfcHRlOworCWludCByZWZlcmVuY2VkID0gMCwgaXNvbGF0ZWQgPSAwLCBub25lID0gMDsKKwlmb3IgKF9wdGUgPSBwdGU7IF9wdGUgPCBwdGUrSFBBR0VfUE1EX05SOworCSAgICAgX3B0ZSsrLCBhZGRyZXNzICs9IFBBR0VfU0laRSkgeworCQlwdGVfdCBwdGV2YWwgPSAqX3B0ZTsKKwkJaWYgKHB0ZV9ub25lKHB0ZXZhbCkpIHsKKwkJCWlmICgrK25vbmUgPD0ga2h1Z2VwYWdlZF9tYXhfcHRlc19ub25lKQorCQkJCWNvbnRpbnVlOworCQkJZWxzZSB7CisJCQkJcmVsZWFzZV9wdGVfcGFnZXMocHRlLCBfcHRlKTsKKwkJCQlnb3RvIG91dDsKKwkJCX0KKwkJfQorCQlpZiAoIXB0ZV9wcmVzZW50KHB0ZXZhbCkgfHwgIXB0ZV93cml0ZShwdGV2YWwpKSB7CisJCQlyZWxlYXNlX3B0ZV9wYWdlcyhwdGUsIF9wdGUpOworCQkJZ290byBvdXQ7CisJCX0KKwkJcGFnZSA9IHZtX25vcm1hbF9wYWdlKHZtYSwgYWRkcmVzcywgcHRldmFsKTsKKwkJaWYgKHVubGlrZWx5KCFwYWdlKSkgeworCQkJcmVsZWFzZV9wdGVfcGFnZXMocHRlLCBfcHRlKTsKKwkJCWdvdG8gb3V0OworCQl9CisJCVZNX0JVR19PTihQYWdlQ29tcG91bmQocGFnZSkpOworCQlCVUdfT04oIVBhZ2VBbm9uKHBhZ2UpKTsKKwkJVk1fQlVHX09OKCFQYWdlU3dhcEJhY2tlZChwYWdlKSk7CisKKwkJLyogY2Fubm90IHVzZSBtYXBjb3VudDogY2FuJ3QgY29sbGFwc2UgaWYgdGhlcmUncyBhIGd1cCBwaW4gKi8KKwkJaWYgKHBhZ2VfY291bnQocGFnZSkgIT0gMSkgeworCQkJcmVsZWFzZV9wdGVfcGFnZXMocHRlLCBfcHRlKTsKKwkJCWdvdG8gb3V0OworCQl9CisJCS8qCisJCSAqIFdlIGNhbiBkbyBpdCBiZWZvcmUgaXNvbGF0ZV9scnVfcGFnZSBiZWNhdXNlIHRoZQorCQkgKiBwYWdlIGNhbid0IGJlIGZyZWVkIGZyb20gdW5kZXIgdXMuIE5PVEU6IFBHX2xvY2sKKwkJICogaXMgbmVlZGVkIHRvIHNlcmlhbGl6ZSBhZ2FpbnN0IHNwbGl0X2h1Z2VfcGFnZQorCQkgKiB3aGVuIGludm9rZWQgZnJvbSB0aGUgVk0uCisJCSAqLworCQlpZiAoIXRyeWxvY2tfcGFnZShwYWdlKSkgeworCQkJcmVsZWFzZV9wdGVfcGFnZXMocHRlLCBfcHRlKTsKKwkJCWdvdG8gb3V0OworCQl9CisJCS8qCisJCSAqIElzb2xhdGUgdGhlIHBhZ2UgdG8gYXZvaWQgY29sbGFwc2luZyBhbiBodWdlcGFnZQorCQkgKiBjdXJyZW50bHkgaW4gdXNlIGJ5IHRoZSBWTS4KKwkJICovCisJCWlmIChpc29sYXRlX2xydV9wYWdlKHBhZ2UpKSB7CisJCQl1bmxvY2tfcGFnZShwYWdlKTsKKwkJCXJlbGVhc2VfcHRlX3BhZ2VzKHB0ZSwgX3B0ZSk7CisJCQlnb3RvIG91dDsKKwkJfQorCQkvKiAwIHN0YW5kcyBmb3IgcGFnZV9pc19maWxlX2NhY2hlKHBhZ2UpID09IGZhbHNlICovCisJCWluY196b25lX3BhZ2Vfc3RhdGUocGFnZSwgTlJfSVNPTEFURURfQU5PTiArIDApOworCQlWTV9CVUdfT04oIVBhZ2VMb2NrZWQocGFnZSkpOworCQlWTV9CVUdfT04oUGFnZUxSVShwYWdlKSk7CisKKwkJLyogSWYgdGhlcmUgaXMgbm8gbWFwcGVkIHB0ZSB5b3VuZyBkb24ndCBjb2xsYXBzZSB0aGUgcGFnZSAqLworCQlpZiAocHRlX3lvdW5nKHB0ZXZhbCkgfHwgUGFnZVJlZmVyZW5jZWQocGFnZSkgfHwKKwkJICAgIG1tdV9ub3RpZmllcl90ZXN0X3lvdW5nKHZtYS0+dm1fbW0sIGFkZHJlc3MpKQorCQkJcmVmZXJlbmNlZCA9IDE7CisJfQorCWlmICh1bmxpa2VseSghcmVmZXJlbmNlZCkpCisJCXJlbGVhc2VfYWxsX3B0ZV9wYWdlcyhwdGUpOworCWVsc2UKKwkJaXNvbGF0ZWQgPSAxOworb3V0OgorCXJldHVybiBpc29sYXRlZDsKK30KKworc3RhdGljIHZvaWQgX19jb2xsYXBzZV9odWdlX3BhZ2VfY29weShwdGVfdCAqcHRlLCBzdHJ1Y3QgcGFnZSAqcGFnZSwKKwkJCQkgICAgICBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCQkgICAgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCisJCQkJICAgICAgc3BpbmxvY2tfdCAqcHRsKQoreworCXB0ZV90ICpfcHRlOworCWZvciAoX3B0ZSA9IHB0ZTsgX3B0ZSA8IHB0ZStIUEFHRV9QTURfTlI7IF9wdGUrKykgeworCQlwdGVfdCBwdGV2YWwgPSAqX3B0ZTsKKwkJc3RydWN0IHBhZ2UgKnNyY19wYWdlOworCisJCWlmIChwdGVfbm9uZShwdGV2YWwpKSB7CisJCQljbGVhcl91c2VyX2hpZ2hwYWdlKHBhZ2UsIGFkZHJlc3MpOworCQkJYWRkX21tX2NvdW50ZXIodm1hLT52bV9tbSwgTU1fQU5PTlBBR0VTLCAxKTsKKwkJfSBlbHNlIHsKKwkJCXNyY19wYWdlID0gcHRlX3BhZ2UocHRldmFsKTsKKwkJCWNvcHlfdXNlcl9oaWdocGFnZShwYWdlLCBzcmNfcGFnZSwgYWRkcmVzcywgdm1hKTsKKwkJCVZNX0JVR19PTihwYWdlX21hcGNvdW50KHNyY19wYWdlKSAhPSAxKTsKKwkJCVZNX0JVR19PTihwYWdlX2NvdW50KHNyY19wYWdlKSAhPSAyKTsKKwkJCXJlbGVhc2VfcHRlX3BhZ2Uoc3JjX3BhZ2UpOworCQkJLyoKKwkJCSAqIHB0bCBtb3N0bHkgdW5uZWNlc3NhcnksIGJ1dCBwcmVlbXB0IGhhcyB0bworCQkJICogYmUgZGlzYWJsZWQgdG8gdXBkYXRlIHRoZSBwZXItY3B1IHN0YXRzCisJCQkgKiBpbnNpZGUgcGFnZV9yZW1vdmVfcm1hcCgpLgorCQkJICovCisJCQlzcGluX2xvY2socHRsKTsKKwkJCS8qCisJCQkgKiBwYXJhdmlydCBjYWxscyBpbnNpZGUgcHRlX2NsZWFyIGhlcmUgYXJlCisJCQkgKiBzdXBlcmZsdW91cy4KKwkJCSAqLworCQkJcHRlX2NsZWFyKHZtYS0+dm1fbW0sIGFkZHJlc3MsIF9wdGUpOworCQkJcGFnZV9yZW1vdmVfcm1hcChzcmNfcGFnZSk7CisJCQlzcGluX3VubG9jayhwdGwpOworCQkJZnJlZV9wYWdlX2FuZF9zd2FwX2NhY2hlKHNyY19wYWdlKTsKKwkJfQorCisJCWFkZHJlc3MgKz0gUEFHRV9TSVpFOworCQlwYWdlKys7CisJfQorfQorCitzdGF0aWMgdm9pZCBjb2xsYXBzZV9odWdlX3BhZ2Uoc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkgICAgICAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLAorCQkJICAgICAgIHN0cnVjdCBwYWdlICoqaHBhZ2UsCisJCQkgICAgICAgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCit7CisJcGdkX3QgKnBnZDsKKwlwdWRfdCAqcHVkOworCXBtZF90ICpwbWQsIF9wbWQ7CisJcHRlX3QgKnB0ZTsKKwlwZ3RhYmxlX3QgcGd0YWJsZTsKKwlzdHJ1Y3QgcGFnZSAqbmV3X3BhZ2U7CisJc3BpbmxvY2tfdCAqcHRsOworCWludCBpc29sYXRlZDsKKwl1bnNpZ25lZCBsb25nIGhzdGFydCwgaGVuZDsKKworCVZNX0JVR19PTihhZGRyZXNzICYgfkhQQUdFX1BNRF9NQVNLKTsKKyNpZm5kZWYgQ09ORklHX05VTUEKKwlWTV9CVUdfT04oISpocGFnZSk7CisJbmV3X3BhZ2UgPSAqaHBhZ2U7CisjZWxzZQorCVZNX0JVR19PTigqaHBhZ2UpOworCS8qCisJICogQWxsb2NhdGUgdGhlIHBhZ2Ugd2hpbGUgdGhlIHZtYSBpcyBzdGlsbCB2YWxpZCBhbmQgdW5kZXIKKwkgKiB0aGUgbW1hcF9zZW0gcmVhZCBtb2RlIHNvIHRoZXJlIGlzIG5vIG1lbW9yeSBhbGxvY2F0aW9uCisJICogbGF0ZXIgd2hlbiB3ZSB0YWtlIHRoZSBtbWFwX3NlbSBpbiB3cml0ZSBtb2RlLiBUaGlzIGlzIG1vcmUKKwkgKiBmcmllbmRseSBiZWhhdmlvciAoT1RPSCBpdCBtYXkgYWN0dWFsbHkgaGlkZSBidWdzKSB0bworCSAqIGZpbGVzeXN0ZW1zIGluIHVzZXJsYW5kIHdpdGggZGFlbW9ucyBhbGxvY2F0aW5nIG1lbW9yeSBpbgorCSAqIHRoZSB1c2VybGFuZCBJL08gcGF0aHMuICBBbGxvY2F0aW5nIG1lbW9yeSB3aXRoIHRoZQorCSAqIG1tYXBfc2VtIGluIHJlYWQgbW9kZSBpcyBnb29kIGlkZWEgYWxzbyB0byBhbGxvdyBncmVhdGVyCisJICogc2NhbGFiaWxpdHkuCisJICovCisJbmV3X3BhZ2UgPSBhbGxvY19odWdlcGFnZV92bWEoa2h1Z2VwYWdlZF9kZWZyYWcoKSwgdm1hLCBhZGRyZXNzKTsKKwlpZiAodW5saWtlbHkoIW5ld19wYWdlKSkgeworCQl1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOworCQkqaHBhZ2UgPSBFUlJfUFRSKC1FTk9NRU0pOworCQlyZXR1cm47CisJfQorI2VuZGlmCisJaWYgKHVubGlrZWx5KG1lbV9jZ3JvdXBfbmV3cGFnZV9jaGFyZ2UobmV3X3BhZ2UsIG1tLCBHRlBfS0VSTkVMKSkpIHsKKwkJdXBfcmVhZCgmbW0tPm1tYXBfc2VtKTsKKwkJcHV0X3BhZ2UobmV3X3BhZ2UpOworCQlyZXR1cm47CisJfQorCisJLyogYWZ0ZXIgYWxsb2NhdGluZyB0aGUgaHVnZXBhZ2UgdXBncmFkZSB0byBtbWFwX3NlbSB3cml0ZSBtb2RlICovCisJdXBfcmVhZCgmbW0tPm1tYXBfc2VtKTsKKworCS8qCisJICogUHJldmVudCBhbGwgYWNjZXNzIHRvIHBhZ2V0YWJsZXMgd2l0aCB0aGUgZXhjZXB0aW9uIG9mCisJICogZ3VwX2Zhc3QgbGF0ZXIgaGFubGRlZCBieSB0aGUgcHRlcF9jbGVhcl9mbHVzaCBhbmQgdGhlIFZNCisJICogaGFuZGxlZCBieSB0aGUgYW5vbl92bWEgbG9jayArIFBHX2xvY2suCisJICovCisJZG93bl93cml0ZSgmbW0tPm1tYXBfc2VtKTsKKwlpZiAodW5saWtlbHkoa2h1Z2VwYWdlZF90ZXN0X2V4aXQobW0pKSkKKwkJZ290byBvdXQ7CisKKwl2bWEgPSBmaW5kX3ZtYShtbSwgYWRkcmVzcyk7CisJaHN0YXJ0ID0gKHZtYS0+dm1fc3RhcnQgKyB+SFBBR0VfUE1EX01BU0spICYgSFBBR0VfUE1EX01BU0s7CisJaGVuZCA9IHZtYS0+dm1fZW5kICYgSFBBR0VfUE1EX01BU0s7CisJaWYgKGFkZHJlc3MgPCBoc3RhcnQgfHwgYWRkcmVzcyArIEhQQUdFX1BNRF9TSVpFID4gaGVuZCkKKwkJZ290byBvdXQ7CisKKwlpZiAoKCEodm1hLT52bV9mbGFncyAmIFZNX0hVR0VQQUdFKSAmJiAha2h1Z2VwYWdlZF9hbHdheXMoKSkgfHwKKwkgICAgKHZtYS0+dm1fZmxhZ3MgJiBWTV9OT0hVR0VQQUdFKSkKKwkJZ290byBvdXQ7CisKKwkvKiBWTV9QRk5NQVAgdm1hcyBtYXkgaGF2ZSB2bV9vcHMgbnVsbCBidXQgdm1fZmlsZSBzZXQgKi8KKwlpZiAoIXZtYS0+YW5vbl92bWEgfHwgdm1hLT52bV9vcHMgfHwgdm1hLT52bV9maWxlKQorCQlnb3RvIG91dDsKKwlWTV9CVUdfT04oaXNfbGluZWFyX3Bmbl9tYXBwaW5nKHZtYSkgfHwgaXNfcGZuX21hcHBpbmcodm1hKSk7CisKKwlwZ2QgPSBwZ2Rfb2Zmc2V0KG1tLCBhZGRyZXNzKTsKKwlpZiAoIXBnZF9wcmVzZW50KCpwZ2QpKQorCQlnb3RvIG91dDsKKworCXB1ZCA9IHB1ZF9vZmZzZXQocGdkLCBhZGRyZXNzKTsKKwlpZiAoIXB1ZF9wcmVzZW50KCpwdWQpKQorCQlnb3RvIG91dDsKKworCXBtZCA9IHBtZF9vZmZzZXQocHVkLCBhZGRyZXNzKTsKKwkvKiBwbWQgY2FuJ3QgZ28gYXdheSBvciBiZWNvbWUgaHVnZSB1bmRlciB1cyAqLworCWlmICghcG1kX3ByZXNlbnQoKnBtZCkgfHwgcG1kX3RyYW5zX2h1Z2UoKnBtZCkpCisJCWdvdG8gb3V0OworCisJYW5vbl92bWFfbG9jayh2bWEtPmFub25fdm1hKTsKKworCXB0ZSA9IHB0ZV9vZmZzZXRfbWFwKHBtZCwgYWRkcmVzcyk7CisJcHRsID0gcHRlX2xvY2twdHIobW0sIHBtZCk7CisKKwlzcGluX2xvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOyAvKiBwcm9iYWJseSB1bm5lY2Vzc2FyeSAqLworCS8qCisJICogQWZ0ZXIgdGhpcyBndXBfZmFzdCBjYW4ndCBydW4gYW55bW9yZS4gVGhpcyBhbHNvIHJlbW92ZXMKKwkgKiBhbnkgaHVnZSBUTEIgZW50cnkgZnJvbSB0aGUgQ1BVIHNvIHdlIHdvbid0IGFsbG93CisJICogaHVnZSBhbmQgc21hbGwgVExCIGVudHJpZXMgZm9yIHRoZSBzYW1lIHZpcnR1YWwgYWRkcmVzcworCSAqIHRvIGF2b2lkIHRoZSByaXNrIG9mIENQVSBidWdzIGluIHRoYXQgYXJlYS4KKwkgKi8KKwlfcG1kID0gcG1kcF9jbGVhcl9mbHVzaF9ub3RpZnkodm1hLCBhZGRyZXNzLCBwbWQpOworCXNwaW5fdW5sb2NrKCZtbS0+cGFnZV90YWJsZV9sb2NrKTsKKworCXNwaW5fbG9jayhwdGwpOworCWlzb2xhdGVkID0gX19jb2xsYXBzZV9odWdlX3BhZ2VfaXNvbGF0ZSh2bWEsIGFkZHJlc3MsIHB0ZSk7CisJc3Bpbl91bmxvY2socHRsKTsKKworCWlmICh1bmxpa2VseSghaXNvbGF0ZWQpKSB7CisJCXB0ZV91bm1hcChwdGUpOworCQlzcGluX2xvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCQlCVUdfT04oIXBtZF9ub25lKCpwbWQpKTsKKwkJc2V0X3BtZF9hdChtbSwgYWRkcmVzcywgcG1kLCBfcG1kKTsKKwkJc3Bpbl91bmxvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCQlhbm9uX3ZtYV91bmxvY2sodm1hLT5hbm9uX3ZtYSk7CisJCWdvdG8gb3V0OworCX0KKworCS8qCisJICogQWxsIHBhZ2VzIGFyZSBpc29sYXRlZCBhbmQgbG9ja2VkIHNvIGFub25fdm1hIHJtYXAKKwkgKiBjYW4ndCBydW4gYW55bW9yZS4KKwkgKi8KKwlhbm9uX3ZtYV91bmxvY2sodm1hLT5hbm9uX3ZtYSk7CisKKwlfX2NvbGxhcHNlX2h1Z2VfcGFnZV9jb3B5KHB0ZSwgbmV3X3BhZ2UsIHZtYSwgYWRkcmVzcywgcHRsKTsKKwlwdGVfdW5tYXAocHRlKTsKKwlfX1NldFBhZ2VVcHRvZGF0ZShuZXdfcGFnZSk7CisJcGd0YWJsZSA9IHBtZF9wZ3RhYmxlKF9wbWQpOworCVZNX0JVR19PTihwYWdlX2NvdW50KHBndGFibGUpICE9IDEpOworCVZNX0JVR19PTihwYWdlX21hcGNvdW50KHBndGFibGUpICE9IDApOworCisJX3BtZCA9IG1rX3BtZChuZXdfcGFnZSwgdm1hLT52bV9wYWdlX3Byb3QpOworCV9wbWQgPSBtYXliZV9wbWRfbWt3cml0ZShwbWRfbWtkaXJ0eShfcG1kKSwgdm1hKTsKKwlfcG1kID0gcG1kX21raHVnZShfcG1kKTsKKworCS8qCisJICogc3Bpbl9sb2NrKCkgYmVsb3cgaXMgbm90IHRoZSBlcXVpdmFsZW50IG9mIHNtcF93bWIoKSwgc28KKwkgKiB0aGlzIGlzIG5lZWRlZCB0byBhdm9pZCB0aGUgY29weV9odWdlX3BhZ2Ugd3JpdGVzIHRvIGJlY29tZQorCSAqIHZpc2libGUgYWZ0ZXIgdGhlIHNldF9wbWRfYXQoKSB3cml0ZS4KKwkgKi8KKwlzbXBfd21iKCk7CisKKwlzcGluX2xvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCUJVR19PTighcG1kX25vbmUoKnBtZCkpOworCXBhZ2VfYWRkX25ld19hbm9uX3JtYXAobmV3X3BhZ2UsIHZtYSwgYWRkcmVzcyk7CisJc2V0X3BtZF9hdChtbSwgYWRkcmVzcywgcG1kLCBfcG1kKTsKKwl1cGRhdGVfbW11X2NhY2hlKHZtYSwgYWRkcmVzcywgZW50cnkpOworCXByZXBhcmVfcG1kX2h1Z2VfcHRlKHBndGFibGUsIG1tKTsKKwltbS0+bnJfcHRlcy0tOworCXNwaW5fdW5sb2NrKCZtbS0+cGFnZV90YWJsZV9sb2NrKTsKKworI2lmbmRlZiBDT05GSUdfTlVNQQorCSpocGFnZSA9IE5VTEw7CisjZW5kaWYKKwlraHVnZXBhZ2VkX3BhZ2VzX2NvbGxhcHNlZCsrOworb3V0X3VwX3dyaXRlOgorCXVwX3dyaXRlKCZtbS0+bW1hcF9zZW0pOworCXJldHVybjsKKworb3V0OgorCW1lbV9jZ3JvdXBfdW5jaGFyZ2VfcGFnZShuZXdfcGFnZSk7CisjaWZkZWYgQ09ORklHX05VTUEKKwlwdXRfcGFnZShuZXdfcGFnZSk7CisjZW5kaWYKKwlnb3RvIG91dF91cF93cml0ZTsKK30KKworc3RhdGljIGludCBraHVnZXBhZ2VkX3NjYW5fcG1kKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJICAgICAgIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywKKwkJCSAgICAgICBzdHJ1Y3QgcGFnZSAqKmhwYWdlKQoreworCXBnZF90ICpwZ2Q7CisJcHVkX3QgKnB1ZDsKKwlwbWRfdCAqcG1kOworCXB0ZV90ICpwdGUsICpfcHRlOworCWludCByZXQgPSAwLCByZWZlcmVuY2VkID0gMCwgbm9uZSA9IDA7CisJc3RydWN0IHBhZ2UgKnBhZ2U7CisJdW5zaWduZWQgbG9uZyBfYWRkcmVzczsKKwlzcGlubG9ja190ICpwdGw7CisKKwlWTV9CVUdfT04oYWRkcmVzcyAmIH5IUEFHRV9QTURfTUFTSyk7CisKKwlwZ2QgPSBwZ2Rfb2Zmc2V0KG1tLCBhZGRyZXNzKTsKKwlpZiAoIXBnZF9wcmVzZW50KCpwZ2QpKQorCQlnb3RvIG91dDsKKworCXB1ZCA9IHB1ZF9vZmZzZXQocGdkLCBhZGRyZXNzKTsKKwlpZiAoIXB1ZF9wcmVzZW50KCpwdWQpKQorCQlnb3RvIG91dDsKKworCXBtZCA9IHBtZF9vZmZzZXQocHVkLCBhZGRyZXNzKTsKKwlpZiAoIXBtZF9wcmVzZW50KCpwbWQpIHx8IHBtZF90cmFuc19odWdlKCpwbWQpKQorCQlnb3RvIG91dDsKKworCXB0ZSA9IHB0ZV9vZmZzZXRfbWFwX2xvY2sobW0sIHBtZCwgYWRkcmVzcywgJnB0bCk7CisJZm9yIChfYWRkcmVzcyA9IGFkZHJlc3MsIF9wdGUgPSBwdGU7IF9wdGUgPCBwdGUrSFBBR0VfUE1EX05SOworCSAgICAgX3B0ZSsrLCBfYWRkcmVzcyArPSBQQUdFX1NJWkUpIHsKKwkJcHRlX3QgcHRldmFsID0gKl9wdGU7CisJCWlmIChwdGVfbm9uZShwdGV2YWwpKSB7CisJCQlpZiAoKytub25lIDw9IGtodWdlcGFnZWRfbWF4X3B0ZXNfbm9uZSkKKwkJCQljb250aW51ZTsKKwkJCWVsc2UKKwkJCQlnb3RvIG91dF91bm1hcDsKKwkJfQorCQlpZiAoIXB0ZV9wcmVzZW50KHB0ZXZhbCkgfHwgIXB0ZV93cml0ZShwdGV2YWwpKQorCQkJZ290byBvdXRfdW5tYXA7CisJCXBhZ2UgPSB2bV9ub3JtYWxfcGFnZSh2bWEsIF9hZGRyZXNzLCBwdGV2YWwpOworCQlpZiAodW5saWtlbHkoIXBhZ2UpKQorCQkJZ290byBvdXRfdW5tYXA7CisJCVZNX0JVR19PTihQYWdlQ29tcG91bmQocGFnZSkpOworCQlpZiAoIVBhZ2VMUlUocGFnZSkgfHwgUGFnZUxvY2tlZChwYWdlKSB8fCAhUGFnZUFub24ocGFnZSkpCisJCQlnb3RvIG91dF91bm1hcDsKKwkJLyogY2Fubm90IHVzZSBtYXBjb3VudDogY2FuJ3QgY29sbGFwc2UgaWYgdGhlcmUncyBhIGd1cCBwaW4gKi8KKwkJaWYgKHBhZ2VfY291bnQocGFnZSkgIT0gMSkKKwkJCWdvdG8gb3V0X3VubWFwOworCQlpZiAocHRlX3lvdW5nKHB0ZXZhbCkgfHwgUGFnZVJlZmVyZW5jZWQocGFnZSkgfHwKKwkJICAgIG1tdV9ub3RpZmllcl90ZXN0X3lvdW5nKHZtYS0+dm1fbW0sIGFkZHJlc3MpKQorCQkJcmVmZXJlbmNlZCA9IDE7CisJfQorCWlmIChyZWZlcmVuY2VkKQorCQlyZXQgPSAxOworb3V0X3VubWFwOgorCXB0ZV91bm1hcF91bmxvY2socHRlLCBwdGwpOworCWlmIChyZXQpCisJCS8qIGNvbGxhcHNlX2h1Z2VfcGFnZSB3aWxsIHJldHVybiB3aXRoIHRoZSBtbWFwX3NlbSByZWxlYXNlZCAqLworCQljb2xsYXBzZV9odWdlX3BhZ2UobW0sIGFkZHJlc3MsIGhwYWdlLCB2bWEpOworb3V0OgorCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIGNvbGxlY3RfbW1fc2xvdChzdHJ1Y3QgbW1fc2xvdCAqbW1fc2xvdCkKK3sKKwlzdHJ1Y3QgbW1fc3RydWN0ICptbSA9IG1tX3Nsb3QtPm1tOworCisJVk1fQlVHX09OKCFzcGluX2lzX2xvY2tlZCgma2h1Z2VwYWdlZF9tbV9sb2NrKSk7CisKKwlpZiAoa2h1Z2VwYWdlZF90ZXN0X2V4aXQobW0pKSB7CisJCS8qIGZyZWUgbW1fc2xvdCAqLworCQlobGlzdF9kZWwoJm1tX3Nsb3QtPmhhc2gpOworCQlsaXN0X2RlbCgmbW1fc2xvdC0+bW1fbm9kZSk7CisKKwkJLyoKKwkJICogTm90IHN0cmljdGx5IG5lZWRlZCBiZWNhdXNlIHRoZSBtbSBleGl0ZWQgYWxyZWFkeS4KKwkJICoKKwkJICogY2xlYXJfYml0KE1NRl9WTV9IVUdFUEFHRSwgJm1tLT5mbGFncyk7CisJCSAqLworCisJCS8qIGtodWdlcGFnZWRfbW1fbG9jayBhY3R1YWxseSBub3QgbmVjZXNzYXJ5IGZvciB0aGUgYmVsb3cgKi8KKwkJZnJlZV9tbV9zbG90KG1tX3Nsb3QpOworCQltbWRyb3AobW0pOworCX0KK30KKworc3RhdGljIHVuc2lnbmVkIGludCBraHVnZXBhZ2VkX3NjYW5fbW1fc2xvdCh1bnNpZ25lZCBpbnQgcGFnZXMsCisJCQkJCSAgICBzdHJ1Y3QgcGFnZSAqKmhwYWdlKQoreworCXN0cnVjdCBtbV9zbG90ICptbV9zbG90OworCXN0cnVjdCBtbV9zdHJ1Y3QgKm1tOworCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hOworCWludCBwcm9ncmVzcyA9IDA7CisKKwlWTV9CVUdfT04oIXBhZ2VzKTsKKwlWTV9CVUdfT04oIXNwaW5faXNfbG9ja2VkKCZraHVnZXBhZ2VkX21tX2xvY2spKTsKKworCWlmIChraHVnZXBhZ2VkX3NjYW4ubW1fc2xvdCkKKwkJbW1fc2xvdCA9IGtodWdlcGFnZWRfc2Nhbi5tbV9zbG90OworCWVsc2UgeworCQltbV9zbG90ID0gbGlzdF9lbnRyeShraHVnZXBhZ2VkX3NjYW4ubW1faGVhZC5uZXh0LAorCQkJCSAgICAgc3RydWN0IG1tX3Nsb3QsIG1tX25vZGUpOworCQlraHVnZXBhZ2VkX3NjYW4uYWRkcmVzcyA9IDA7CisJCWtodWdlcGFnZWRfc2Nhbi5tbV9zbG90ID0gbW1fc2xvdDsKKwl9CisJc3Bpbl91bmxvY2soJmtodWdlcGFnZWRfbW1fbG9jayk7CisKKwltbSA9IG1tX3Nsb3QtPm1tOworCWRvd25fcmVhZCgmbW0tPm1tYXBfc2VtKTsKKwlpZiAodW5saWtlbHkoa2h1Z2VwYWdlZF90ZXN0X2V4aXQobW0pKSkKKwkJdm1hID0gTlVMTDsKKwllbHNlCisJCXZtYSA9IGZpbmRfdm1hKG1tLCBraHVnZXBhZ2VkX3NjYW4uYWRkcmVzcyk7CisKKwlwcm9ncmVzcysrOworCWZvciAoOyB2bWE7IHZtYSA9IHZtYS0+dm1fbmV4dCkgeworCQl1bnNpZ25lZCBsb25nIGhzdGFydCwgaGVuZDsKKworCQljb25kX3Jlc2NoZWQoKTsKKwkJaWYgKHVubGlrZWx5KGtodWdlcGFnZWRfdGVzdF9leGl0KG1tKSkpIHsKKwkJCXByb2dyZXNzKys7CisJCQlicmVhazsKKwkJfQorCisJCWlmICgoISh2bWEtPnZtX2ZsYWdzICYgVk1fSFVHRVBBR0UpICYmCisJCSAgICAgIWtodWdlcGFnZWRfYWx3YXlzKCkpIHx8CisJCSAgICAodm1hLT52bV9mbGFncyAmIFZNX05PSFVHRVBBR0UpKSB7CisJCQlwcm9ncmVzcysrOworCQkJY29udGludWU7CisJCX0KKworCQkvKiBWTV9QRk5NQVAgdm1hcyBtYXkgaGF2ZSB2bV9vcHMgbnVsbCBidXQgdm1fZmlsZSBzZXQgKi8KKwkJaWYgKCF2bWEtPmFub25fdm1hIHx8IHZtYS0+dm1fb3BzIHx8IHZtYS0+dm1fZmlsZSkgeworCQkJa2h1Z2VwYWdlZF9zY2FuLmFkZHJlc3MgPSB2bWEtPnZtX2VuZDsKKwkJCXByb2dyZXNzKys7CisJCQljb250aW51ZTsKKwkJfQorCQlWTV9CVUdfT04oaXNfbGluZWFyX3Bmbl9tYXBwaW5nKHZtYSkgfHwgaXNfcGZuX21hcHBpbmcodm1hKSk7CisKKwkJaHN0YXJ0ID0gKHZtYS0+dm1fc3RhcnQgKyB+SFBBR0VfUE1EX01BU0spICYgSFBBR0VfUE1EX01BU0s7CisJCWhlbmQgPSB2bWEtPnZtX2VuZCAmIEhQQUdFX1BNRF9NQVNLOworCQlpZiAoaHN0YXJ0ID49IGhlbmQpIHsKKwkJCXByb2dyZXNzKys7CisJCQljb250aW51ZTsKKwkJfQorCQlpZiAoa2h1Z2VwYWdlZF9zY2FuLmFkZHJlc3MgPCBoc3RhcnQpCisJCQlraHVnZXBhZ2VkX3NjYW4uYWRkcmVzcyA9IGhzdGFydDsKKwkJaWYgKGtodWdlcGFnZWRfc2Nhbi5hZGRyZXNzID4gaGVuZCkgeworCQkJa2h1Z2VwYWdlZF9zY2FuLmFkZHJlc3MgPSBoZW5kICsgSFBBR0VfUE1EX1NJWkU7CisJCQlwcm9ncmVzcysrOworCQkJY29udGludWU7CisJCX0KKwkJQlVHX09OKGtodWdlcGFnZWRfc2Nhbi5hZGRyZXNzICYgfkhQQUdFX1BNRF9NQVNLKTsKKworCQl3aGlsZSAoa2h1Z2VwYWdlZF9zY2FuLmFkZHJlc3MgPCBoZW5kKSB7CisJCQlpbnQgcmV0OworCQkJY29uZF9yZXNjaGVkKCk7CisJCQlpZiAodW5saWtlbHkoa2h1Z2VwYWdlZF90ZXN0X2V4aXQobW0pKSkKKwkJCQlnb3RvIGJyZWFrb3V0ZXJsb29wOworCisJCQlWTV9CVUdfT04oa2h1Z2VwYWdlZF9zY2FuLmFkZHJlc3MgPCBoc3RhcnQgfHwKKwkJCQkgIGtodWdlcGFnZWRfc2Nhbi5hZGRyZXNzICsgSFBBR0VfUE1EX1NJWkUgPgorCQkJCSAgaGVuZCk7CisJCQlyZXQgPSBraHVnZXBhZ2VkX3NjYW5fcG1kKG1tLCB2bWEsCisJCQkJCQkgIGtodWdlcGFnZWRfc2Nhbi5hZGRyZXNzLAorCQkJCQkJICBocGFnZSk7CisJCQkvKiBtb3ZlIHRvIG5leHQgYWRkcmVzcyAqLworCQkJa2h1Z2VwYWdlZF9zY2FuLmFkZHJlc3MgKz0gSFBBR0VfUE1EX1NJWkU7CisJCQlwcm9ncmVzcyArPSBIUEFHRV9QTURfTlI7CisJCQlpZiAocmV0KQorCQkJCS8qIHdlIHJlbGVhc2VkIG1tYXBfc2VtIHNvIGJyZWFrIGxvb3AgKi8KKwkJCQlnb3RvIGJyZWFrb3V0ZXJsb29wX21tYXBfc2VtOworCQkJaWYgKHByb2dyZXNzID49IHBhZ2VzKQorCQkJCWdvdG8gYnJlYWtvdXRlcmxvb3A7CisJCX0KKwl9CiticmVha291dGVybG9vcDoKKwl1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOyAvKiBleGl0X21tYXAgd2lsbCBkZXN0cm95IHB0ZXMgYWZ0ZXIgdGhpcyAqLworYnJlYWtvdXRlcmxvb3BfbW1hcF9zZW06CisKKwlzcGluX2xvY2soJmtodWdlcGFnZWRfbW1fbG9jayk7CisJQlVHX09OKGtodWdlcGFnZWRfc2Nhbi5tbV9zbG90ICE9IG1tX3Nsb3QpOworCS8qCisJICogUmVsZWFzZSB0aGUgY3VycmVudCBtbV9zbG90IGlmIHRoaXMgbW0gaXMgYWJvdXQgdG8gZGllLCBvcgorCSAqIGlmIHdlIHNjYW5uZWQgYWxsIHZtYXMgb2YgdGhpcyBtbS4KKwkgKi8KKwlpZiAoa2h1Z2VwYWdlZF90ZXN0X2V4aXQobW0pIHx8ICF2bWEpIHsKKwkJLyoKKwkJICogTWFrZSBzdXJlIHRoYXQgaWYgbW1fdXNlcnMgaXMgcmVhY2hpbmcgemVybyB3aGlsZQorCQkgKiBraHVnZXBhZ2VkIHJ1bnMgaGVyZSwga2h1Z2VwYWdlZF9leGl0IHdpbGwgZmluZAorCQkgKiBtbV9zbG90IG5vdCBwb2ludGluZyB0byB0aGUgZXhpdGluZyBtbS4KKwkJICovCisJCWlmIChtbV9zbG90LT5tbV9ub2RlLm5leHQgIT0gJmtodWdlcGFnZWRfc2Nhbi5tbV9oZWFkKSB7CisJCQlraHVnZXBhZ2VkX3NjYW4ubW1fc2xvdCA9IGxpc3RfZW50cnkoCisJCQkJbW1fc2xvdC0+bW1fbm9kZS5uZXh0LAorCQkJCXN0cnVjdCBtbV9zbG90LCBtbV9ub2RlKTsKKwkJCWtodWdlcGFnZWRfc2Nhbi5hZGRyZXNzID0gMDsKKwkJfSBlbHNlIHsKKwkJCWtodWdlcGFnZWRfc2Nhbi5tbV9zbG90ID0gTlVMTDsKKwkJCWtodWdlcGFnZWRfZnVsbF9zY2FucysrOworCQl9CisKKwkJY29sbGVjdF9tbV9zbG90KG1tX3Nsb3QpOworCX0KKworCXJldHVybiBwcm9ncmVzczsKK30KKworc3RhdGljIGludCBraHVnZXBhZ2VkX2hhc193b3JrKHZvaWQpCit7CisJcmV0dXJuICFsaXN0X2VtcHR5KCZraHVnZXBhZ2VkX3NjYW4ubW1faGVhZCkgJiYKKwkJa2h1Z2VwYWdlZF9lbmFibGVkKCk7Cit9CisKK3N0YXRpYyBpbnQga2h1Z2VwYWdlZF93YWl0X2V2ZW50KHZvaWQpCit7CisJcmV0dXJuICFsaXN0X2VtcHR5KCZraHVnZXBhZ2VkX3NjYW4ubW1faGVhZCkgfHwKKwkJIWtodWdlcGFnZWRfZW5hYmxlZCgpOworfQorCitzdGF0aWMgdm9pZCBraHVnZXBhZ2VkX2RvX3NjYW4oc3RydWN0IHBhZ2UgKipocGFnZSkKK3sKKwl1bnNpZ25lZCBpbnQgcHJvZ3Jlc3MgPSAwLCBwYXNzX3Rocm91Z2hfaGVhZCA9IDA7CisJdW5zaWduZWQgaW50IHBhZ2VzID0ga2h1Z2VwYWdlZF9wYWdlc190b19zY2FuOworCisJYmFycmllcigpOyAvKiB3cml0ZSBraHVnZXBhZ2VkX3BhZ2VzX3RvX3NjYW4gdG8gbG9jYWwgc3RhY2sgKi8KKworCXdoaWxlIChwcm9ncmVzcyA8IHBhZ2VzKSB7CisJCWNvbmRfcmVzY2hlZCgpOworCisjaWZuZGVmIENPTkZJR19OVU1BCisJCWlmICghKmhwYWdlKSB7CisJCQkqaHBhZ2UgPSBhbGxvY19odWdlcGFnZShraHVnZXBhZ2VkX2RlZnJhZygpKTsKKwkJCWlmICh1bmxpa2VseSghKmhwYWdlKSkKKwkJCQlicmVhazsKKwkJfQorI2Vsc2UKKwkJaWYgKElTX0VSUigqaHBhZ2UpKQorCQkJYnJlYWs7CisjZW5kaWYKKworCQlpZiAodW5saWtlbHkoa3RocmVhZF9zaG91bGRfc3RvcCgpIHx8IGZyZWV6aW5nKGN1cnJlbnQpKSkKKwkJCWJyZWFrOworCisJCXNwaW5fbG9jaygma2h1Z2VwYWdlZF9tbV9sb2NrKTsKKwkJaWYgKCFraHVnZXBhZ2VkX3NjYW4ubW1fc2xvdCkKKwkJCXBhc3NfdGhyb3VnaF9oZWFkKys7CisJCWlmIChraHVnZXBhZ2VkX2hhc193b3JrKCkgJiYKKwkJICAgIHBhc3NfdGhyb3VnaF9oZWFkIDwgMikKKwkJCXByb2dyZXNzICs9IGtodWdlcGFnZWRfc2Nhbl9tbV9zbG90KHBhZ2VzIC0gcHJvZ3Jlc3MsCisJCQkJCQkJICAgIGhwYWdlKTsKKwkJZWxzZQorCQkJcHJvZ3Jlc3MgPSBwYWdlczsKKwkJc3Bpbl91bmxvY2soJmtodWdlcGFnZWRfbW1fbG9jayk7CisJfQorfQorCitzdGF0aWMgdm9pZCBraHVnZXBhZ2VkX2FsbG9jX3NsZWVwKHZvaWQpCit7CisJREVGSU5FX1dBSVQod2FpdCk7CisJYWRkX3dhaXRfcXVldWUoJmtodWdlcGFnZWRfd2FpdCwgJndhaXQpOworCXNjaGVkdWxlX3RpbWVvdXRfaW50ZXJydXB0aWJsZSgKKwkJbXNlY3NfdG9famlmZmllcygKKwkJCWtodWdlcGFnZWRfYWxsb2Nfc2xlZXBfbWlsbGlzZWNzKSk7CisJcmVtb3ZlX3dhaXRfcXVldWUoJmtodWdlcGFnZWRfd2FpdCwgJndhaXQpOworfQorCisjaWZuZGVmIENPTkZJR19OVU1BCitzdGF0aWMgc3RydWN0IHBhZ2UgKmtodWdlcGFnZWRfYWxsb2NfaHVnZXBhZ2Uodm9pZCkKK3sKKwlzdHJ1Y3QgcGFnZSAqaHBhZ2U7CisKKwlkbyB7CisJCWhwYWdlID0gYWxsb2NfaHVnZXBhZ2Uoa2h1Z2VwYWdlZF9kZWZyYWcoKSk7CisJCWlmICghaHBhZ2UpCisJCQlraHVnZXBhZ2VkX2FsbG9jX3NsZWVwKCk7CisJfSB3aGlsZSAodW5saWtlbHkoIWhwYWdlKSAmJgorCQkgbGlrZWx5KGtodWdlcGFnZWRfZW5hYmxlZCgpKSk7CisJcmV0dXJuIGhwYWdlOworfQorI2VuZGlmCisKK3N0YXRpYyB2b2lkIGtodWdlcGFnZWRfbG9vcCh2b2lkKQoreworCXN0cnVjdCBwYWdlICpocGFnZTsKKworI2lmZGVmIENPTkZJR19OVU1BCisJaHBhZ2UgPSBOVUxMOworI2VuZGlmCisJd2hpbGUgKGxpa2VseShraHVnZXBhZ2VkX2VuYWJsZWQoKSkpIHsKKyNpZm5kZWYgQ09ORklHX05VTUEKKwkJaHBhZ2UgPSBraHVnZXBhZ2VkX2FsbG9jX2h1Z2VwYWdlKCk7CisJCWlmICh1bmxpa2VseSghaHBhZ2UpKQorCQkJYnJlYWs7CisjZWxzZQorCQlpZiAoSVNfRVJSKGhwYWdlKSkgeworCQkJa2h1Z2VwYWdlZF9hbGxvY19zbGVlcCgpOworCQkJaHBhZ2UgPSBOVUxMOworCQl9CisjZW5kaWYKKworCQlraHVnZXBhZ2VkX2RvX3NjYW4oJmhwYWdlKTsKKyNpZm5kZWYgQ09ORklHX05VTUEKKwkJaWYgKGhwYWdlKQorCQkJcHV0X3BhZ2UoaHBhZ2UpOworI2VuZGlmCisJCXRyeV90b19mcmVlemUoKTsKKwkJaWYgKHVubGlrZWx5KGt0aHJlYWRfc2hvdWxkX3N0b3AoKSkpCisJCQlicmVhazsKKwkJaWYgKGtodWdlcGFnZWRfaGFzX3dvcmsoKSkgeworCQkJREVGSU5FX1dBSVQod2FpdCk7CisJCQlpZiAoIWtodWdlcGFnZWRfc2Nhbl9zbGVlcF9taWxsaXNlY3MpCisJCQkJY29udGludWU7CisJCQlhZGRfd2FpdF9xdWV1ZSgma2h1Z2VwYWdlZF93YWl0LCAmd2FpdCk7CisJCQlzY2hlZHVsZV90aW1lb3V0X2ludGVycnVwdGlibGUoCisJCQkJbXNlY3NfdG9famlmZmllcygKKwkJCQkJa2h1Z2VwYWdlZF9zY2FuX3NsZWVwX21pbGxpc2VjcykpOworCQkJcmVtb3ZlX3dhaXRfcXVldWUoJmtodWdlcGFnZWRfd2FpdCwgJndhaXQpOworCQl9IGVsc2UgaWYgKGtodWdlcGFnZWRfZW5hYmxlZCgpKQorCQkJd2FpdF9ldmVudF9mcmVlemFibGUoa2h1Z2VwYWdlZF93YWl0LAorCQkJCQkgICAgIGtodWdlcGFnZWRfd2FpdF9ldmVudCgpKTsKKwl9Cit9CisKK3N0YXRpYyBpbnQga2h1Z2VwYWdlZCh2b2lkICpub25lKQoreworCXN0cnVjdCBtbV9zbG90ICptbV9zbG90OworCisJc2V0X2ZyZWV6YWJsZSgpOworCXNldF91c2VyX25pY2UoY3VycmVudCwgMTkpOworCisJLyogc2VyaWFsaXplIHdpdGggc3RhcnRfa2h1Z2VwYWdlZCgpICovCisJbXV0ZXhfbG9jaygma2h1Z2VwYWdlZF9tdXRleCk7CisKKwlmb3IgKDs7KSB7CisJCW11dGV4X3VubG9jaygma2h1Z2VwYWdlZF9tdXRleCk7CisJCUJVR19PTihraHVnZXBhZ2VkX3RocmVhZCAhPSBjdXJyZW50KTsKKwkJa2h1Z2VwYWdlZF9sb29wKCk7CisJCUJVR19PTihraHVnZXBhZ2VkX3RocmVhZCAhPSBjdXJyZW50KTsKKworCQltdXRleF9sb2NrKCZraHVnZXBhZ2VkX211dGV4KTsKKwkJaWYgKCFraHVnZXBhZ2VkX2VuYWJsZWQoKSkKKwkJCWJyZWFrOworCQlpZiAodW5saWtlbHkoa3RocmVhZF9zaG91bGRfc3RvcCgpKSkKKwkJCWJyZWFrOworCX0KKworCXNwaW5fbG9jaygma2h1Z2VwYWdlZF9tbV9sb2NrKTsKKwltbV9zbG90ID0ga2h1Z2VwYWdlZF9zY2FuLm1tX3Nsb3Q7CisJa2h1Z2VwYWdlZF9zY2FuLm1tX3Nsb3QgPSBOVUxMOworCWlmIChtbV9zbG90KQorCQljb2xsZWN0X21tX3Nsb3QobW1fc2xvdCk7CisJc3Bpbl91bmxvY2soJmtodWdlcGFnZWRfbW1fbG9jayk7CisKKwlraHVnZXBhZ2VkX3RocmVhZCA9IE5VTEw7CisJbXV0ZXhfdW5sb2NrKCZraHVnZXBhZ2VkX211dGV4KTsKKworCXJldHVybiAwOworfQorCit2b2lkIF9fc3BsaXRfaHVnZV9wYWdlX3BtZChzdHJ1Y3QgbW1fc3RydWN0ICptbSwgcG1kX3QgKnBtZCkKK3sKKwlzdHJ1Y3QgcGFnZSAqcGFnZTsKKworCXNwaW5fbG9jaygmbW0tPnBhZ2VfdGFibGVfbG9jayk7CisJaWYgKHVubGlrZWx5KCFwbWRfdHJhbnNfaHVnZSgqcG1kKSkpIHsKKwkJc3Bpbl91bmxvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCQlyZXR1cm47CisJfQorCXBhZ2UgPSBwbWRfcGFnZSgqcG1kKTsKKwlWTV9CVUdfT04oIXBhZ2VfY291bnQocGFnZSkpOworCWdldF9wYWdlKHBhZ2UpOworCXNwaW5fdW5sb2NrKCZtbS0+cGFnZV90YWJsZV9sb2NrKTsKKworCXNwbGl0X2h1Z2VfcGFnZShwYWdlKTsKKworCXB1dF9wYWdlKHBhZ2UpOworCUJVR19PTihwbWRfdHJhbnNfaHVnZSgqcG1kKSk7Cit9CisKK3N0YXRpYyB2b2lkIHNwbGl0X2h1Z2VfcGFnZV9hZGRyZXNzKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJCSAgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MpCit7CisJcGdkX3QgKnBnZDsKKwlwdWRfdCAqcHVkOworCXBtZF90ICpwbWQ7CisKKwlWTV9CVUdfT04oIShhZGRyZXNzICYgfkhQQUdFX1BNRF9NQVNLKSk7CisKKwlwZ2QgPSBwZ2Rfb2Zmc2V0KG1tLCBhZGRyZXNzKTsKKwlpZiAoIXBnZF9wcmVzZW50KCpwZ2QpKQorCQlyZXR1cm47CisKKwlwdWQgPSBwdWRfb2Zmc2V0KHBnZCwgYWRkcmVzcyk7CisJaWYgKCFwdWRfcHJlc2VudCgqcHVkKSkKKwkJcmV0dXJuOworCisJcG1kID0gcG1kX29mZnNldChwdWQsIGFkZHJlc3MpOworCWlmICghcG1kX3ByZXNlbnQoKnBtZCkpCisJCXJldHVybjsKKwkvKgorCSAqIENhbGxlciBob2xkcyB0aGUgbW1hcF9zZW0gd3JpdGUgbW9kZSwgc28gYSBodWdlIHBtZCBjYW5ub3QKKwkgKiBtYXRlcmlhbGl6ZSBmcm9tIHVuZGVyIHVzLgorCSAqLworCXNwbGl0X2h1Z2VfcGFnZV9wbWQobW0sIHBtZCk7Cit9CisKK3ZvaWQgX192bWFfYWRqdXN0X3RyYW5zX2h1Z2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCQkgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsCisJCQkgICAgIHVuc2lnbmVkIGxvbmcgZW5kLAorCQkJICAgICBsb25nIGFkanVzdF9uZXh0KQoreworCS8qCisJICogSWYgdGhlIG5ldyBzdGFydCBhZGRyZXNzIGlzbid0IGhwYWdlIGFsaWduZWQgYW5kIGl0IGNvdWxkCisJICogcHJldmlvdXNseSBjb250YWluIGFuIGh1Z2VwYWdlOiBjaGVjayBpZiB3ZSBuZWVkIHRvIHNwbGl0CisJICogYW4gaHVnZSBwbWQuCisJICovCisJaWYgKHN0YXJ0ICYgfkhQQUdFX1BNRF9NQVNLICYmCisJICAgIChzdGFydCAmIEhQQUdFX1BNRF9NQVNLKSA+PSB2bWEtPnZtX3N0YXJ0ICYmCisJICAgIChzdGFydCAmIEhQQUdFX1BNRF9NQVNLKSArIEhQQUdFX1BNRF9TSVpFIDw9IHZtYS0+dm1fZW5kKQorCQlzcGxpdF9odWdlX3BhZ2VfYWRkcmVzcyh2bWEtPnZtX21tLCBzdGFydCk7CisKKwkvKgorCSAqIElmIHRoZSBuZXcgZW5kIGFkZHJlc3MgaXNuJ3QgaHBhZ2UgYWxpZ25lZCBhbmQgaXQgY291bGQKKwkgKiBwcmV2aW91c2x5IGNvbnRhaW4gYW4gaHVnZXBhZ2U6IGNoZWNrIGlmIHdlIG5lZWQgdG8gc3BsaXQKKwkgKiBhbiBodWdlIHBtZC4KKwkgKi8KKwlpZiAoZW5kICYgfkhQQUdFX1BNRF9NQVNLICYmCisJICAgIChlbmQgJiBIUEFHRV9QTURfTUFTSykgPj0gdm1hLT52bV9zdGFydCAmJgorCSAgICAoZW5kICYgSFBBR0VfUE1EX01BU0spICsgSFBBR0VfUE1EX1NJWkUgPD0gdm1hLT52bV9lbmQpCisJCXNwbGl0X2h1Z2VfcGFnZV9hZGRyZXNzKHZtYS0+dm1fbW0sIGVuZCk7CisKKwkvKgorCSAqIElmIHdlJ3JlIGFsc28gdXBkYXRpbmcgdGhlIHZtYS0+dm1fbmV4dC0+dm1fc3RhcnQsIGlmIHRoZSBuZXcKKwkgKiB2bV9uZXh0LT52bV9zdGFydCBpc24ndCBwYWdlIGFsaWduZWQgYW5kIGl0IGNvdWxkIHByZXZpb3VzbHkKKwkgKiBjb250YWluIGFuIGh1Z2VwYWdlOiBjaGVjayBpZiB3ZSBuZWVkIHRvIHNwbGl0IGFuIGh1Z2UgcG1kLgorCSAqLworCWlmIChhZGp1c3RfbmV4dCA+IDApIHsKKwkJc3RydWN0IHZtX2FyZWFfc3RydWN0ICpuZXh0ID0gdm1hLT52bV9uZXh0OworCQl1bnNpZ25lZCBsb25nIG5zdGFydCA9IG5leHQtPnZtX3N0YXJ0OworCQluc3RhcnQgKz0gYWRqdXN0X25leHQgPDwgUEFHRV9TSElGVDsKKwkJaWYgKG5zdGFydCAmIH5IUEFHRV9QTURfTUFTSyAmJgorCQkgICAgKG5zdGFydCAmIEhQQUdFX1BNRF9NQVNLKSA+PSBuZXh0LT52bV9zdGFydCAmJgorCQkgICAgKG5zdGFydCAmIEhQQUdFX1BNRF9NQVNLKSArIEhQQUdFX1BNRF9TSVpFIDw9IG5leHQtPnZtX2VuZCkKKwkJCXNwbGl0X2h1Z2VfcGFnZV9hZGRyZXNzKG5leHQtPnZtX21tLCBuc3RhcnQpOworCX0KK30KZGlmZiAtLWdpdCBhL21tL2h1Z2V0bGIuYyBiL21tL2h1Z2V0bGIuYwppbmRleCA4NTg1NTI0Li5iYjBiN2MxIDEwMDY0NAotLS0gYS9tbS9odWdldGxiLmMKKysrIGIvbW0vaHVnZXRsYi5jCkBAIC0zOTQsNzEgKzM5NCw2IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyB2b2lkIGNsZWFyX2dpZ2FudGljX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UsCi0JCQl1bnNpZ25lZCBsb25nIGFkZHIsIHVuc2lnbmVkIGxvbmcgc3opCi17Ci0JaW50IGk7Ci0Jc3RydWN0IHBhZ2UgKnAgPSBwYWdlOwotCi0JbWlnaHRfc2xlZXAoKTsKLQlmb3IgKGkgPSAwOyBpIDwgc3ovUEFHRV9TSVpFOyBpKyssIHAgPSBtZW1fbWFwX25leHQocCwgcGFnZSwgaSkpIHsKLQkJY29uZF9yZXNjaGVkKCk7Ci0JCWNsZWFyX3VzZXJfaGlnaHBhZ2UocCwgYWRkciArIGkgKiBQQUdFX1NJWkUpOwotCX0KLX0KLXN0YXRpYyB2b2lkIGNsZWFyX2h1Z2VfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSwKLQkJCXVuc2lnbmVkIGxvbmcgYWRkciwgdW5zaWduZWQgbG9uZyBzeikKLXsKLQlpbnQgaTsKLQotCWlmICh1bmxpa2VseShzei9QQUdFX1NJWkUgPiBNQVhfT1JERVJfTlJfUEFHRVMpKSB7Ci0JCWNsZWFyX2dpZ2FudGljX3BhZ2UocGFnZSwgYWRkciwgc3opOwotCQlyZXR1cm47Ci0JfQotCi0JbWlnaHRfc2xlZXAoKTsKLQlmb3IgKGkgPSAwOyBpIDwgc3ovUEFHRV9TSVpFOyBpKyspIHsKLQkJY29uZF9yZXNjaGVkKCk7Ci0JCWNsZWFyX3VzZXJfaGlnaHBhZ2UocGFnZSArIGksIGFkZHIgKyBpICogUEFHRV9TSVpFKTsKLQl9Ci19Ci0KLXN0YXRpYyB2b2lkIGNvcHlfdXNlcl9naWdhbnRpY19wYWdlKHN0cnVjdCBwYWdlICpkc3QsIHN0cnVjdCBwYWdlICpzcmMsCi0JCQkgICB1bnNpZ25lZCBsb25nIGFkZHIsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQotewotCWludCBpOwotCXN0cnVjdCBoc3RhdGUgKmggPSBoc3RhdGVfdm1hKHZtYSk7Ci0Jc3RydWN0IHBhZ2UgKmRzdF9iYXNlID0gZHN0OwotCXN0cnVjdCBwYWdlICpzcmNfYmFzZSA9IHNyYzsKLQotCWZvciAoaSA9IDA7IGkgPCBwYWdlc19wZXJfaHVnZV9wYWdlKGgpOyApIHsKLQkJY29uZF9yZXNjaGVkKCk7Ci0JCWNvcHlfdXNlcl9oaWdocGFnZShkc3QsIHNyYywgYWRkciArIGkqUEFHRV9TSVpFLCB2bWEpOwotCi0JCWkrKzsKLQkJZHN0ID0gbWVtX21hcF9uZXh0KGRzdCwgZHN0X2Jhc2UsIGkpOwotCQlzcmMgPSBtZW1fbWFwX25leHQoc3JjLCBzcmNfYmFzZSwgaSk7Ci0JfQotfQotCi1zdGF0aWMgdm9pZCBjb3B5X3VzZXJfaHVnZV9wYWdlKHN0cnVjdCBwYWdlICpkc3QsIHN0cnVjdCBwYWdlICpzcmMsCi0JCQkgICB1bnNpZ25lZCBsb25nIGFkZHIsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQotewotCWludCBpOwotCXN0cnVjdCBoc3RhdGUgKmggPSBoc3RhdGVfdm1hKHZtYSk7Ci0KLQlpZiAodW5saWtlbHkocGFnZXNfcGVyX2h1Z2VfcGFnZShoKSA+IE1BWF9PUkRFUl9OUl9QQUdFUykpIHsKLQkJY29weV91c2VyX2dpZ2FudGljX3BhZ2UoZHN0LCBzcmMsIGFkZHIsIHZtYSk7Ci0JCXJldHVybjsKLQl9Ci0KLQltaWdodF9zbGVlcCgpOwotCWZvciAoaSA9IDA7IGkgPCBwYWdlc19wZXJfaHVnZV9wYWdlKGgpOyBpKyspIHsKLQkJY29uZF9yZXNjaGVkKCk7Ci0JCWNvcHlfdXNlcl9oaWdocGFnZShkc3QgKyBpLCBzcmMgKyBpLCBhZGRyICsgaSpQQUdFX1NJWkUsIHZtYSk7Ci0JfQotfQotCiBzdGF0aWMgdm9pZCBjb3B5X2dpZ2FudGljX3BhZ2Uoc3RydWN0IHBhZ2UgKmRzdCwgc3RydWN0IHBhZ2UgKnNyYykKIHsKIAlpbnQgaTsKQEAgLTE0MjgsNiArMTM2Myw3IEBACiAKIAlyZXR1cm4gc3ByaW50ZihidWYsICIlbHVcbiIsIG5yX2h1Z2VfcGFnZXMpOwogfQorCiBzdGF0aWMgc3NpemVfdCBucl9odWdlcGFnZXNfc3RvcmVfY29tbW9uKGJvb2wgb2JleV9tZW1wb2xpY3ksCiAJCQlzdHJ1Y3Qga29iamVjdCAqa29iaiwgc3RydWN0IGtvYmpfYXR0cmlidXRlICphdHRyLAogCQkJY29uc3QgY2hhciAqYnVmLCBzaXplX3QgbGVuKQpAQCAtMTQ0MCw5ICsxMzc2LDE0IEBACiAKIAllcnIgPSBzdHJpY3Rfc3RydG91bChidWYsIDEwLCAmY291bnQpOwogCWlmIChlcnIpCi0JCXJldHVybiAwOworCQlnb3RvIG91dDsKIAogCWggPSBrb2JqX3RvX2hzdGF0ZShrb2JqLCAmbmlkKTsKKwlpZiAoaC0+b3JkZXIgPj0gTUFYX09SREVSKSB7CisJCWVyciA9IC1FSU5WQUw7CisJCWdvdG8gb3V0OworCX0KKwogCWlmIChuaWQgPT0gTlVNQV9OT19OT0RFKSB7CiAJCS8qCiAJCSAqIGdsb2JhbCBoc3RhdGUgYXR0cmlidXRlCkBAIC0xNDY4LDYgKzE0MDksOSBAQAogCQlOT0RFTUFTS19GUkVFKG5vZGVzX2FsbG93ZWQpOwogCiAJcmV0dXJuIGxlbjsKK291dDoKKwlOT0RFTUFTS19GUkVFKG5vZGVzX2FsbG93ZWQpOworCXJldHVybiBlcnI7CiB9CiAKIHN0YXRpYyBzc2l6ZV90IG5yX2h1Z2VwYWdlc19zaG93KHN0cnVjdCBrb2JqZWN0ICprb2JqLApAQCAtMTUxMCw2ICsxNDU0LDcgQEAKIAlzdHJ1Y3QgaHN0YXRlICpoID0ga29ial90b19oc3RhdGUoa29iaiwgTlVMTCk7CiAJcmV0dXJuIHNwcmludGYoYnVmLCAiJWx1XG4iLCBoLT5ucl9vdmVyY29tbWl0X2h1Z2VfcGFnZXMpOwogfQorCiBzdGF0aWMgc3NpemVfdCBucl9vdmVyY29tbWl0X2h1Z2VwYWdlc19zdG9yZShzdHJ1Y3Qga29iamVjdCAqa29iaiwKIAkJc3RydWN0IGtvYmpfYXR0cmlidXRlICphdHRyLCBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKIHsKQEAgLTE1MTcsOSArMTQ2MiwxMiBAQAogCXVuc2lnbmVkIGxvbmcgaW5wdXQ7CiAJc3RydWN0IGhzdGF0ZSAqaCA9IGtvYmpfdG9faHN0YXRlKGtvYmosIE5VTEwpOwogCisJaWYgKGgtPm9yZGVyID49IE1BWF9PUkRFUikKKwkJcmV0dXJuIC1FSU5WQUw7CisKIAllcnIgPSBzdHJpY3Rfc3RydG91bChidWYsIDEwLCAmaW5wdXQpOwogCWlmIChlcnIpCi0JCXJldHVybiAwOworCQlyZXR1cm4gZXJyOwogCiAJc3Bpbl9sb2NrKCZodWdldGxiX2xvY2spOwogCWgtPm5yX292ZXJjb21taXRfaHVnZV9wYWdlcyA9IGlucHV0OwpAQCAtMTkyMiwxMyArMTg3MCwxOSBAQAogewogCXN0cnVjdCBoc3RhdGUgKmggPSAmZGVmYXVsdF9oc3RhdGU7CiAJdW5zaWduZWQgbG9uZyB0bXA7CisJaW50IHJldDsKIAogCWlmICghd3JpdGUpCiAJCXRtcCA9IGgtPm1heF9odWdlX3BhZ2VzOwogCisJaWYgKHdyaXRlICYmIGgtPm9yZGVyID49IE1BWF9PUkRFUikKKwkJcmV0dXJuIC1FSU5WQUw7CisKIAl0YWJsZS0+ZGF0YSA9ICZ0bXA7CiAJdGFibGUtPm1heGxlbiA9IHNpemVvZih1bnNpZ25lZCBsb25nKTsKLQlwcm9jX2RvdWxvbmd2ZWNfbWlubWF4KHRhYmxlLCB3cml0ZSwgYnVmZmVyLCBsZW5ndGgsIHBwb3MpOworCXJldCA9IHByb2NfZG91bG9uZ3ZlY19taW5tYXgodGFibGUsIHdyaXRlLCBidWZmZXIsIGxlbmd0aCwgcHBvcyk7CisJaWYgKHJldCkKKwkJZ290byBvdXQ7CiAKIAlpZiAod3JpdGUpIHsKIAkJTk9ERU1BU0tfQUxMT0Mobm9kZW1hc2tfdCwgbm9kZXNfYWxsb3dlZCwKQEAgLTE5NDMsOCArMTg5Nyw4IEBACiAJCWlmIChub2Rlc19hbGxvd2VkICE9ICZub2RlX3N0YXRlc1tOX0hJR0hfTUVNT1JZXSkKIAkJCU5PREVNQVNLX0ZSRUUobm9kZXNfYWxsb3dlZCk7CiAJfQotCi0JcmV0dXJuIDA7CitvdXQ6CisJcmV0dXJuIHJldDsKIH0KIAogaW50IGh1Z2V0bGJfc3lzY3RsX2hhbmRsZXIoc3RydWN0IGN0bF90YWJsZSAqdGFibGUsIGludCB3cml0ZSwKQEAgLTE5ODIsMjEgKzE5MzYsMjcgQEAKIHsKIAlzdHJ1Y3QgaHN0YXRlICpoID0gJmRlZmF1bHRfaHN0YXRlOwogCXVuc2lnbmVkIGxvbmcgdG1wOworCWludCByZXQ7CiAKIAlpZiAoIXdyaXRlKQogCQl0bXAgPSBoLT5ucl9vdmVyY29tbWl0X2h1Z2VfcGFnZXM7CiAKKwlpZiAod3JpdGUgJiYgaC0+b3JkZXIgPj0gTUFYX09SREVSKQorCQlyZXR1cm4gLUVJTlZBTDsKKwogCXRhYmxlLT5kYXRhID0gJnRtcDsKIAl0YWJsZS0+bWF4bGVuID0gc2l6ZW9mKHVuc2lnbmVkIGxvbmcpOwotCXByb2NfZG91bG9uZ3ZlY19taW5tYXgodGFibGUsIHdyaXRlLCBidWZmZXIsIGxlbmd0aCwgcHBvcyk7CisJcmV0ID0gcHJvY19kb3Vsb25ndmVjX21pbm1heCh0YWJsZSwgd3JpdGUsIGJ1ZmZlciwgbGVuZ3RoLCBwcG9zKTsKKwlpZiAocmV0KQorCQlnb3RvIG91dDsKIAogCWlmICh3cml0ZSkgewogCQlzcGluX2xvY2soJmh1Z2V0bGJfbG9jayk7CiAJCWgtPm5yX292ZXJjb21taXRfaHVnZV9wYWdlcyA9IHRtcDsKIAkJc3Bpbl91bmxvY2soJmh1Z2V0bGJfbG9jayk7CiAJfQotCi0JcmV0dXJuIDA7CitvdXQ6CisJcmV0dXJuIHJldDsKIH0KIAogI2VuZGlmIC8qIENPTkZJR19TWVNDVEwgKi8KQEAgLTI0NTQsNyArMjQxNCw4IEBACiAJCXJldHVybiBWTV9GQVVMVF9PT007CiAJfQogCi0JY29weV91c2VyX2h1Z2VfcGFnZShuZXdfcGFnZSwgb2xkX3BhZ2UsIGFkZHJlc3MsIHZtYSk7CisJY29weV91c2VyX2h1Z2VfcGFnZShuZXdfcGFnZSwgb2xkX3BhZ2UsIGFkZHJlc3MsIHZtYSwKKwkJCSAgICBwYWdlc19wZXJfaHVnZV9wYWdlKGgpKTsKIAlfX1NldFBhZ2VVcHRvZGF0ZShuZXdfcGFnZSk7CiAKIAkvKgpAQCAtMjU1OCw3ICsyNTE5LDcgQEAKIAkJCXJldCA9IC1QVFJfRVJSKHBhZ2UpOwogCQkJZ290byBvdXQ7CiAJCX0KLQkJY2xlYXJfaHVnZV9wYWdlKHBhZ2UsIGFkZHJlc3MsIGh1Z2VfcGFnZV9zaXplKGgpKTsKKwkJY2xlYXJfaHVnZV9wYWdlKHBhZ2UsIGFkZHJlc3MsIHBhZ2VzX3Blcl9odWdlX3BhZ2UoaCkpOwogCQlfX1NldFBhZ2VVcHRvZGF0ZShwYWdlKTsKIAogCQlpZiAodm1hLT52bV9mbGFncyAmIFZNX01BWVNIQVJFKSB7CmRpZmYgLS1naXQgYS9tbS9pbnRlcm5hbC5oIGIvbW0vaW50ZXJuYWwuaAppbmRleCBkZWRiMGFmLi42OTQ4ODIwIDEwMDY0NAotLS0gYS9tbS9pbnRlcm5hbC5oCisrKyBiL21tL2ludGVybmFsLmgKQEAgLTEzNCw2ICsxMzQsMTAgQEAKIAl9CiB9CiAKKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UKK2V4dGVybiB1bnNpZ25lZCBsb25nIHZtYV9hZGRyZXNzKHN0cnVjdCBwYWdlICpwYWdlLAorCQkJCSBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSk7CisjZW5kaWYKICNlbHNlIC8qICFDT05GSUdfTU1VICovCiBzdGF0aWMgaW5saW5lIGludCBpc19tbG9ja2VkX3ZtYShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnYsIHN0cnVjdCBwYWdlICpwKQogewpAQCAtMjQzLDcgKzI0Nyw4IEBACiAKIGludCBfX2dldF91c2VyX3BhZ2VzKHN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrLCBzdHJ1Y3QgbW1fc3RydWN0ICptbSwKIAkJICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0LCBpbnQgbGVuLCB1bnNpZ25lZCBpbnQgZm9sbF9mbGFncywKLQkJICAgICBzdHJ1Y3QgcGFnZSAqKnBhZ2VzLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKip2bWFzKTsKKwkJICAgICBzdHJ1Y3QgcGFnZSAqKnBhZ2VzLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKip2bWFzLAorCQkgICAgIGludCAqbm9uYmxvY2tpbmcpOwogCiAjZGVmaW5lIFpPTkVfUkVDTEFJTV9OT1NDQU4JLTIKICNkZWZpbmUgWk9ORV9SRUNMQUlNX0ZVTEwJLTEKZGlmZiAtLWdpdCBhL21tL2ttZW1sZWFrLXRlc3QuYyBiL21tL2ttZW1sZWFrLXRlc3QuYwppbmRleCAxNzdhNTE2Li5mZjBkOTc3IDEwMDY0NAotLS0gYS9tbS9rbWVtbGVhay10ZXN0LmMKKysrIGIvbW0va21lbWxlYWstdGVzdC5jCkBAIC03NSwxMyArNzUsMTEgQEAKIAkgKiBhZnRlciB0aGUgbW9kdWxlIGlzIHJlbW92ZWQuCiAJICovCiAJZm9yIChpID0gMDsgaSA8IDEwOyBpKyspIHsKLQkJZWxlbSA9IGttYWxsb2Moc2l6ZW9mKCplbGVtKSwgR0ZQX0tFUk5FTCk7Ci0JCXByX2luZm8oImttZW1sZWFrOiBrbWFsbG9jKHNpemVvZigqZWxlbSkpID0gJXBcbiIsIGVsZW0pOworCQllbGVtID0ga3phbGxvYyhzaXplb2YoKmVsZW0pLCBHRlBfS0VSTkVMKTsKKwkJcHJfaW5mbygia21lbWxlYWs6IGt6YWxsb2Moc2l6ZW9mKCplbGVtKSkgPSAlcFxuIiwgZWxlbSk7CiAJCWlmICghZWxlbSkKIAkJCXJldHVybiAtRU5PTUVNOwotCQltZW1zZXQoZWxlbSwgMCwgc2l6ZW9mKCplbGVtKSk7CiAJCUlOSVRfTElTVF9IRUFEKCZlbGVtLT5saXN0KTsKLQogCQlsaXN0X2FkZF90YWlsKCZlbGVtLT5saXN0LCAmdGVzdF9saXN0KTsKIAl9CiAKZGlmZiAtLWdpdCBhL21tL2ttZW1sZWFrLmMgYi9tbS9rbWVtbGVhay5jCmluZGV4IGJkOWJjMjEuLjg0MjI1ZjMgMTAwNjQ0Ci0tLSBhL21tL2ttZW1sZWFrLmMKKysrIGIvbW0va21lbWxlYWsuYwpAQCAtMTEzLDcgKzExMyw5IEBACiAjZGVmaW5lIEJZVEVTX1BFUl9QT0lOVEVSCXNpemVvZih2b2lkICopCiAKIC8qIEdGUCBiaXRtYXNrIGZvciBrbWVtbGVhayBpbnRlcm5hbCBhbGxvY2F0aW9ucyAqLwotI2RlZmluZSBHRlBfS01FTUxFQUtfTUFTSwkoR0ZQX0tFUk5FTCB8IEdGUF9BVE9NSUMpCisjZGVmaW5lIGdmcF9rbWVtbGVha19tYXNrKGdmcCkJKCgoZ2ZwKSAmIChHRlBfS0VSTkVMIHwgR0ZQX0FUT01JQykpIHwgXAorCQkJCSBfX0dGUF9OT1JFVFJZIHwgX19HRlBfTk9NRU1BTExPQyB8IFwKKwkJCQkgX19HRlBfTk9XQVJOKQogCiAvKiBzY2FubmluZyBhcmVhIGluc2lkZSBhIG1lbW9yeSBibG9jayAqLwogc3RydWN0IGttZW1sZWFrX3NjYW5fYXJlYSB7CkBAIC01MTEsOSArNTEzLDEwIEBACiAJc3RydWN0IGttZW1sZWFrX29iamVjdCAqb2JqZWN0OwogCXN0cnVjdCBwcmlvX3RyZWVfbm9kZSAqbm9kZTsKIAotCW9iamVjdCA9IGttZW1fY2FjaGVfYWxsb2Mob2JqZWN0X2NhY2hlLCBnZnAgJiBHRlBfS01FTUxFQUtfTUFTSyk7CisJb2JqZWN0ID0ga21lbV9jYWNoZV9hbGxvYyhvYmplY3RfY2FjaGUsIGdmcF9rbWVtbGVha19tYXNrKGdmcCkpOwogCWlmICghb2JqZWN0KSB7Ci0JCWttZW1sZWFrX3N0b3AoIkNhbm5vdCBhbGxvY2F0ZSBhIGttZW1sZWFrX29iamVjdCBzdHJ1Y3R1cmVcbiIpOworCQlwcl93YXJuaW5nKCJDYW5ub3QgYWxsb2NhdGUgYSBrbWVtbGVha19vYmplY3Qgc3RydWN0dXJlXG4iKTsKKwkJa21lbWxlYWtfZGlzYWJsZSgpOwogCQlyZXR1cm4gTlVMTDsKIAl9CiAKQEAgLTczNCw5ICs3MzcsOSBAQAogCQlyZXR1cm47CiAJfQogCi0JYXJlYSA9IGttZW1fY2FjaGVfYWxsb2Moc2Nhbl9hcmVhX2NhY2hlLCBnZnAgJiBHRlBfS01FTUxFQUtfTUFTSyk7CisJYXJlYSA9IGttZW1fY2FjaGVfYWxsb2Moc2Nhbl9hcmVhX2NhY2hlLCBnZnBfa21lbWxlYWtfbWFzayhnZnApKTsKIAlpZiAoIWFyZWEpIHsKLQkJa21lbWxlYWtfd2FybigiQ2Fubm90IGFsbG9jYXRlIGEgc2NhbiBhcmVhXG4iKTsKKwkJcHJfd2FybmluZygiQ2Fubm90IGFsbG9jYXRlIGEgc2NhbiBhcmVhXG4iKTsKIAkJZ290byBvdXQ7CiAJfQogCmRpZmYgLS1naXQgYS9tbS9rc20uYyBiL21tL2tzbS5jCmluZGV4IDQzYmM4OTMuLmMyYjJhOTQgMTAwNjQ0Ci0tLSBhL21tL2tzbS5jCisrKyBiL21tL2tzbS5jCkBAIC0zNCw2ICszNCw3IEBACiAjaW5jbHVkZSA8bGludXgvc3dhcC5oPgogI2luY2x1ZGUgPGxpbnV4L2tzbS5oPgogI2luY2x1ZGUgPGxpbnV4L2hhc2guaD4KKyNpbmNsdWRlIDxsaW51eC9mcmVlemVyLmg+CiAKICNpbmNsdWRlIDxhc20vdGxiZmx1c2guaD4KICNpbmNsdWRlICJpbnRlcm5hbC5oIgpAQCAtNDExLDYgKzQxMiwyMCBAQAogCXVwX3JlYWQoJm1tLT5tbWFwX3NlbSk7CiB9CiAKK3N0YXRpYyBzdHJ1Y3QgcGFnZSAqcGFnZV90cmFuc19jb21wb3VuZF9hbm9uKHN0cnVjdCBwYWdlICpwYWdlKQoreworCWlmIChQYWdlVHJhbnNDb21wb3VuZChwYWdlKSkgeworCQlzdHJ1Y3QgcGFnZSAqaGVhZCA9IGNvbXBvdW5kX3RyYW5zX2hlYWQocGFnZSk7CisJCS8qCisJCSAqIGhlYWQgbWF5IGFjdHVhbGx5IGJlIHNwbGl0dGVkIGFuZCBmcmVlZCBmcm9tIHVuZGVyCisJCSAqIHVzIGJ1dCBpdCdzIG9rIGhlcmUuCisJCSAqLworCQlpZiAoUGFnZUFub24oaGVhZCkpCisJCQlyZXR1cm4gaGVhZDsKKwl9CisJcmV0dXJuIE5VTEw7Cit9CisKIHN0YXRpYyBzdHJ1Y3QgcGFnZSAqZ2V0X21lcmdlYWJsZV9wYWdlKHN0cnVjdCBybWFwX2l0ZW0gKnJtYXBfaXRlbSkKIHsKIAlzdHJ1Y3QgbW1fc3RydWN0ICptbSA9IHJtYXBfaXRlbS0+bW07CkBAIC00MzAsNyArNDQ1LDcgQEAKIAlwYWdlID0gZm9sbG93X3BhZ2Uodm1hLCBhZGRyLCBGT0xMX0dFVCk7CiAJaWYgKElTX0VSUl9PUl9OVUxMKHBhZ2UpKQogCQlnb3RvIG91dDsKLQlpZiAoUGFnZUFub24ocGFnZSkpIHsKKwlpZiAoUGFnZUFub24ocGFnZSkgfHwgcGFnZV90cmFuc19jb21wb3VuZF9hbm9uKHBhZ2UpKSB7CiAJCWZsdXNoX2Fub25fcGFnZSh2bWEsIHBhZ2UsIGFkZHIpOwogCQlmbHVzaF9kY2FjaGVfcGFnZShwYWdlKTsKIAl9IGVsc2UgewpAQCAtNzA4LDYgKzcyMyw3IEBACiAJaWYgKGFkZHIgPT0gLUVGQVVMVCkKIAkJZ290byBvdXQ7CiAKKwlCVUdfT04oUGFnZVRyYW5zQ29tcG91bmQocGFnZSkpOwogCXB0ZXAgPSBwYWdlX2NoZWNrX2FkZHJlc3MocGFnZSwgbW0sIGFkZHIsICZwdGwsIDApOwogCWlmICghcHRlcCkKIAkJZ290byBvdXQ7CkBAIC03ODMsNiArNzk5LDcgQEAKIAkJZ290byBvdXQ7CiAKIAlwbWQgPSBwbWRfb2Zmc2V0KHB1ZCwgYWRkcik7CisJQlVHX09OKHBtZF90cmFuc19odWdlKCpwbWQpKTsKIAlpZiAoIXBtZF9wcmVzZW50KCpwbWQpKQogCQlnb3RvIG91dDsKIApAQCAtODAwLDYgKzgxNyw4IEBACiAJc2V0X3B0ZV9hdF9ub3RpZnkobW0sIGFkZHIsIHB0ZXAsIG1rX3B0ZShrcGFnZSwgdm1hLT52bV9wYWdlX3Byb3QpKTsKIAogCXBhZ2VfcmVtb3ZlX3JtYXAocGFnZSk7CisJaWYgKCFwYWdlX21hcHBlZChwYWdlKSkKKwkJdHJ5X3RvX2ZyZWVfc3dhcChwYWdlKTsKIAlwdXRfcGFnZShwYWdlKTsKIAogCXB0ZV91bm1hcF91bmxvY2socHRlcCwgcHRsKTsKQEAgLTgwOCw2ICs4MjcsMzMgQEAKIAlyZXR1cm4gZXJyOwogfQogCitzdGF0aWMgaW50IHBhZ2VfdHJhbnNfY29tcG91bmRfYW5vbl9zcGxpdChzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwlpbnQgcmV0ID0gMDsKKwlzdHJ1Y3QgcGFnZSAqdHJhbnNodWdlX2hlYWQgPSBwYWdlX3RyYW5zX2NvbXBvdW5kX2Fub24ocGFnZSk7CisJaWYgKHRyYW5zaHVnZV9oZWFkKSB7CisJCS8qIEdldCB0aGUgcmVmZXJlbmNlIG9uIHRoZSBoZWFkIHRvIHNwbGl0IGl0LiAqLworCQlpZiAoZ2V0X3BhZ2VfdW5sZXNzX3plcm8odHJhbnNodWdlX2hlYWQpKSB7CisJCQkvKgorCQkJICogUmVjaGVjayB3ZSBnb3QgdGhlIHJlZmVyZW5jZSB3aGlsZSB0aGUgaGVhZAorCQkJICogd2FzIHN0aWxsIGFub255bW91cy4KKwkJCSAqLworCQkJaWYgKFBhZ2VBbm9uKHRyYW5zaHVnZV9oZWFkKSkKKwkJCQlyZXQgPSBzcGxpdF9odWdlX3BhZ2UodHJhbnNodWdlX2hlYWQpOworCQkJZWxzZQorCQkJCS8qCisJCQkJICogUmV0cnkgbGF0ZXIgaWYgc3BsaXRfaHVnZV9wYWdlIHJ1bgorCQkJCSAqIGZyb20gdW5kZXIgdXMuCisJCQkJICovCisJCQkJcmV0ID0gMTsKKwkJCXB1dF9wYWdlKHRyYW5zaHVnZV9oZWFkKTsKKwkJfSBlbHNlCisJCQkvKiBSZXRyeSBsYXRlciBpZiBzcGxpdF9odWdlX3BhZ2UgcnVuIGZyb20gdW5kZXIgdXMuICovCisJCQlyZXQgPSAxOworCX0KKwlyZXR1cm4gcmV0OworfQorCiAvKgogICogdHJ5X3RvX21lcmdlX29uZV9wYWdlIC0gdGFrZSB0d28gcGFnZXMgYW5kIG1lcmdlIHRoZW0gaW50byBvbmUKICAqIEB2bWE6IHRoZSB2bWEgdGhhdCBob2xkcyB0aGUgcHRlIHBvaW50aW5nIHRvIHBhZ2UKQEAgLTgyOCw2ICs4NzQsOSBAQAogCiAJaWYgKCEodm1hLT52bV9mbGFncyAmIFZNX01FUkdFQUJMRSkpCiAJCWdvdG8gb3V0OworCWlmIChQYWdlVHJhbnNDb21wb3VuZChwYWdlKSAmJiBwYWdlX3RyYW5zX2NvbXBvdW5kX2Fub25fc3BsaXQocGFnZSkpCisJCWdvdG8gb3V0OworCUJVR19PTihQYWdlVHJhbnNDb21wb3VuZChwYWdlKSk7CiAJaWYgKCFQYWdlQW5vbihwYWdlKSkKIAkJZ290byBvdXQ7CiAKQEAgLTEyNDcsNiArMTI5NiwxOCBAQAogCiAJc2xvdCA9IGtzbV9zY2FuLm1tX3Nsb3Q7CiAJaWYgKHNsb3QgPT0gJmtzbV9tbV9oZWFkKSB7CisJCS8qCisJCSAqIEEgbnVtYmVyIG9mIHBhZ2VzIGNhbiBoYW5nIGFyb3VuZCBpbmRlZmluaXRlbHkgb24gcGVyLWNwdQorCQkgKiBwYWdldmVjcywgcmFpc2VkIHBhZ2UgY291bnQgcHJldmVudGluZyB3cml0ZV9wcm90ZWN0X3BhZ2UKKwkJICogZnJvbSBtZXJnaW5nIHRoZW0uICBUaG91Z2ggaXQgZG9lc24ndCByZWFsbHkgbWF0dGVyIG11Y2gsCisJCSAqIGl0IGlzIHB1enpsaW5nIHRvIHNlZSBzb21lIHN0dWNrIGluIHBhZ2VzX3ZvbGF0aWxlIHVudGlsCisJCSAqIG90aGVyIGFjdGl2aXR5IGpvc3RsZXMgdGhlbSBvdXQsIGFuZCB0aGV5IGFsc28gcHJldmVudGVkCisJCSAqIExUUCdzIEtTTSB0ZXN0IGZyb20gc3VjY2VlZGluZyBkZXRlcm1pbmlzdGljYWxseTsgc28gZHJhaW4KKwkJICogdGhlbSBoZXJlIChoZXJlIHJhdGhlciB0aGFuIG9uIGVudHJ5IHRvIGtzbV9kb19zY2FuKCksCisJCSAqIHNvIHdlIGRvbid0IElQSSB0b28gb2Z0ZW4gd2hlbiBwYWdlc190b19zY2FuIGlzIHNldCBsb3cpLgorCQkgKi8KKwkJbHJ1X2FkZF9kcmFpbl9hbGwoKTsKKwogCQlyb290X3Vuc3RhYmxlX3RyZWUgPSBSQl9ST09UOwogCiAJCXNwaW5fbG9jaygma3NtX21tbGlzdF9sb2NrKTsKQEAgLTEyNzcsNyArMTMzOCwxMyBAQAogCQkJaWYgKGtzbV90ZXN0X2V4aXQobW0pKQogCQkJCWJyZWFrOwogCQkJKnBhZ2UgPSBmb2xsb3dfcGFnZSh2bWEsIGtzbV9zY2FuLmFkZHJlc3MsIEZPTExfR0VUKTsKLQkJCWlmICghSVNfRVJSX09SX05VTEwoKnBhZ2UpICYmIFBhZ2VBbm9uKCpwYWdlKSkgeworCQkJaWYgKElTX0VSUl9PUl9OVUxMKCpwYWdlKSkgeworCQkJCWtzbV9zY2FuLmFkZHJlc3MgKz0gUEFHRV9TSVpFOworCQkJCWNvbmRfcmVzY2hlZCgpOworCQkJCWNvbnRpbnVlOworCQkJfQorCQkJaWYgKFBhZ2VBbm9uKCpwYWdlKSB8fAorCQkJICAgIHBhZ2VfdHJhbnNfY29tcG91bmRfYW5vbigqcGFnZSkpIHsKIAkJCQlmbHVzaF9hbm9uX3BhZ2Uodm1hLCAqcGFnZSwga3NtX3NjYW4uYWRkcmVzcyk7CiAJCQkJZmx1c2hfZGNhY2hlX3BhZ2UoKnBhZ2UpOwogCQkJCXJtYXBfaXRlbSA9IGdldF9uZXh0X3JtYXBfaXRlbShzbG90LApAQCAtMTI5MSw4ICsxMzU4LDcgQEAKIAkJCQl1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOwogCQkJCXJldHVybiBybWFwX2l0ZW07CiAJCQl9Ci0JCQlpZiAoIUlTX0VSUl9PUl9OVUxMKCpwYWdlKSkKLQkJCQlwdXRfcGFnZSgqcGFnZSk7CisJCQlwdXRfcGFnZSgqcGFnZSk7CiAJCQlrc21fc2Nhbi5hZGRyZXNzICs9IFBBR0VfU0laRTsKIAkJCWNvbmRfcmVzY2hlZCgpOwogCQl9CkBAIC0xMzUyLDcgKzE0MTgsNyBAQAogCXN0cnVjdCBybWFwX2l0ZW0gKnJtYXBfaXRlbTsKIAlzdHJ1Y3QgcGFnZSAqdW5pbml0aWFsaXplZF92YXIocGFnZSk7CiAKLQl3aGlsZSAoc2Nhbl9ucGFnZXMtLSkgeworCXdoaWxlIChzY2FuX25wYWdlcy0tICYmIGxpa2VseSghZnJlZXppbmcoY3VycmVudCkpKSB7CiAJCWNvbmRfcmVzY2hlZCgpOwogCQlybWFwX2l0ZW0gPSBzY2FuX2dldF9uZXh0X3JtYXBfaXRlbSgmcGFnZSk7CiAJCWlmICghcm1hcF9pdGVtKQpAQCAtMTM3MCw2ICsxNDM2LDcgQEAKIAogc3RhdGljIGludCBrc21fc2Nhbl90aHJlYWQodm9pZCAqbm90aGluZykKIHsKKwlzZXRfZnJlZXphYmxlKCk7CiAJc2V0X3VzZXJfbmljZShjdXJyZW50LCA1KTsKIAogCXdoaWxlICgha3RocmVhZF9zaG91bGRfc3RvcCgpKSB7CkBAIC0xMzc4LDExICsxNDQ1LDEzIEBACiAJCQlrc21fZG9fc2Nhbihrc21fdGhyZWFkX3BhZ2VzX3RvX3NjYW4pOwogCQltdXRleF91bmxvY2soJmtzbV90aHJlYWRfbXV0ZXgpOwogCisJCXRyeV90b19mcmVlemUoKTsKKwogCQlpZiAoa3NtZF9zaG91bGRfcnVuKCkpIHsKIAkJCXNjaGVkdWxlX3RpbWVvdXRfaW50ZXJydXB0aWJsZSgKIAkJCQltc2Vjc190b19qaWZmaWVzKGtzbV90aHJlYWRfc2xlZXBfbWlsbGlzZWNzKSk7CiAJCX0gZWxzZSB7Ci0JCQl3YWl0X2V2ZW50X2ludGVycnVwdGlibGUoa3NtX3RocmVhZF93YWl0LAorCQkJd2FpdF9ldmVudF9mcmVlemFibGUoa3NtX3RocmVhZF93YWl0LAogCQkJCWtzbWRfc2hvdWxkX3J1bigpIHx8IGt0aHJlYWRfc2hvdWxkX3N0b3AoKSk7CiAJCX0KIAl9CmRpZmYgLS1naXQgYS9tbS9tYWR2aXNlLmMgYi9tbS9tYWR2aXNlLmMKaW5kZXggMzE5NTI4Yi4uMjIyMTQ5MSAxMDA2NDQKLS0tIGEvbW0vbWFkdmlzZS5jCisrKyBiL21tL21hZHZpc2UuYwpAQCAtNzEsNiArNzEsMTIgQEAKIAkJaWYgKGVycm9yKQogCQkJZ290byBvdXQ7CiAJCWJyZWFrOworCWNhc2UgTUFEVl9IVUdFUEFHRToKKwljYXNlIE1BRFZfTk9IVUdFUEFHRToKKwkJZXJyb3IgPSBodWdlcGFnZV9tYWR2aXNlKHZtYSwgJm5ld19mbGFncywgYmVoYXZpb3IpOworCQlpZiAoZXJyb3IpCisJCQlnb3RvIG91dDsKKwkJYnJlYWs7CiAJfQogCiAJaWYgKG5ld19mbGFncyA9PSB2bWEtPnZtX2ZsYWdzKSB7CkBAIC0yODMsNiArMjg5LDEwIEBACiAJY2FzZSBNQURWX01FUkdFQUJMRToKIAljYXNlIE1BRFZfVU5NRVJHRUFCTEU6CiAjZW5kaWYKKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UKKwljYXNlIE1BRFZfSFVHRVBBR0U6CisJY2FzZSBNQURWX05PSFVHRVBBR0U6CisjZW5kaWYKIAkJcmV0dXJuIDE7CiAKIAlkZWZhdWx0OgpkaWZmIC0tZ2l0IGEvbW0vbWVtYmxvY2suYyBiL21tL21lbWJsb2NrLmMKaW5kZXggNDAwZGM2Mi4uNDYxOGZkYSAxMDA2NDQKLS0tIGEvbW0vbWVtYmxvY2suYworKysgYi9tbS9tZW1ibG9jay5jCkBAIC0xMzcsOCArMTM3LDYgQEAKIAogCUJVR19PTigwID09IHNpemUpOwogCi0Jc2l6ZSA9IG1lbWJsb2NrX2FsaWduX3VwKHNpemUsIGFsaWduKTsKLQogCS8qIFB1bXAgdXAgbWF4X2FkZHIgKi8KIAlpZiAoZW5kID09IE1FTUJMT0NLX0FMTE9DX0FDQ0VTU0lCTEUpCiAJCWVuZCA9IG1lbWJsb2NrLmN1cnJlbnRfbGltaXQ7CkBAIC02ODMsMTMgKzY4MSwxMyBAQAogCiBpbnQgX19pbml0X21lbWJsb2NrIG1lbWJsb2NrX2lzX3JlZ2lvbl9tZW1vcnkocGh5c19hZGRyX3QgYmFzZSwgcGh5c19hZGRyX3Qgc2l6ZSkKIHsKLQlpbnQgaWR4ID0gbWVtYmxvY2tfc2VhcmNoKCZtZW1ibG9jay5yZXNlcnZlZCwgYmFzZSk7CisJaW50IGlkeCA9IG1lbWJsb2NrX3NlYXJjaCgmbWVtYmxvY2subWVtb3J5LCBiYXNlKTsKIAogCWlmIChpZHggPT0gLTEpCiAJCXJldHVybiAwOwotCXJldHVybiBtZW1ibG9jay5yZXNlcnZlZC5yZWdpb25zW2lkeF0uYmFzZSA8PSBiYXNlICYmCi0JCShtZW1ibG9jay5yZXNlcnZlZC5yZWdpb25zW2lkeF0uYmFzZSArCi0JCSBtZW1ibG9jay5yZXNlcnZlZC5yZWdpb25zW2lkeF0uc2l6ZSkgPj0gKGJhc2UgKyBzaXplKTsKKwlyZXR1cm4gbWVtYmxvY2subWVtb3J5LnJlZ2lvbnNbaWR4XS5iYXNlIDw9IGJhc2UgJiYKKwkJKG1lbWJsb2NrLm1lbW9yeS5yZWdpb25zW2lkeF0uYmFzZSArCisJCSBtZW1ibG9jay5tZW1vcnkucmVnaW9uc1tpZHhdLnNpemUpID49IChiYXNlICsgc2l6ZSk7CiB9CiAKIGludCBfX2luaXRfbWVtYmxvY2sgbWVtYmxvY2tfaXNfcmVnaW9uX3Jlc2VydmVkKHBoeXNfYWRkcl90IGJhc2UsIHBoeXNfYWRkcl90IHNpemUpCmRpZmYgLS1naXQgYS9tbS9tZW1jb250cm9sLmMgYi9tbS9tZW1jb250cm9sLmMKaW5kZXggMDBiYjhhNi4uZGE1M2EyNSAxMDA2NDQKLS0tIGEvbW0vbWVtY29udHJvbC5jCisrKyBiL21tL21lbWNvbnRyb2wuYwpAQCAtMjkyLDcgKzI5Miw2IEBACiAJdW5zaWduZWQgbG9uZyBtb3ZlZF9jaGFyZ2U7CiAJdW5zaWduZWQgbG9uZyBtb3ZlZF9zd2FwOwogCXN0cnVjdCB0YXNrX3N0cnVjdCAqbW92aW5nX3Rhc2s7CS8qIGEgdGFzayBtb3ZpbmcgY2hhcmdlcyAqLwotCXN0cnVjdCBtbV9zdHJ1Y3QgKm1tOwogCXdhaXRfcXVldWVfaGVhZF90IHdhaXRxOwkJLyogYSB3YWl0cSBmb3Igb3RoZXIgY29udGV4dCAqLwogfSBtYyA9IHsKIAkubG9jayA9IF9fU1BJTl9MT0NLX1VOTE9DS0VEKG1jLmxvY2spLApAQCAtNjAxLDIzICs2MDAsMjQgQEAKIH0KIAogc3RhdGljIHZvaWQgbWVtX2Nncm91cF9jaGFyZ2Vfc3RhdGlzdGljcyhzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtLAotCQkJCQkgc3RydWN0IHBhZ2VfY2dyb3VwICpwYywKLQkJCQkJIGJvb2wgY2hhcmdlKQorCQkJCQkgYm9vbCBmaWxlLCBpbnQgbnJfcGFnZXMpCiB7Ci0JaW50IHZhbCA9IChjaGFyZ2UpID8gMSA6IC0xOwotCiAJcHJlZW1wdF9kaXNhYmxlKCk7CiAKLQlpZiAoUGFnZUNncm91cENhY2hlKHBjKSkKLQkJX190aGlzX2NwdV9hZGQobWVtLT5zdGF0LT5jb3VudFtNRU1fQ0dST1VQX1NUQVRfQ0FDSEVdLCB2YWwpOworCWlmIChmaWxlKQorCQlfX3RoaXNfY3B1X2FkZChtZW0tPnN0YXQtPmNvdW50W01FTV9DR1JPVVBfU1RBVF9DQUNIRV0sIG5yX3BhZ2VzKTsKIAllbHNlCi0JCV9fdGhpc19jcHVfYWRkKG1lbS0+c3RhdC0+Y291bnRbTUVNX0NHUk9VUF9TVEFUX1JTU10sIHZhbCk7CisJCV9fdGhpc19jcHVfYWRkKG1lbS0+c3RhdC0+Y291bnRbTUVNX0NHUk9VUF9TVEFUX1JTU10sIG5yX3BhZ2VzKTsKIAotCWlmIChjaGFyZ2UpCisJLyogcGFnZWluIG9mIGEgYmlnIHBhZ2UgaXMgYW4gZXZlbnQuIFNvLCBpZ25vcmUgcGFnZSBzaXplICovCisJaWYgKG5yX3BhZ2VzID4gMCkKIAkJX190aGlzX2NwdV9pbmMobWVtLT5zdGF0LT5jb3VudFtNRU1fQ0dST1VQX1NUQVRfUEdQR0lOX0NPVU5UXSk7Ci0JZWxzZQorCWVsc2UgewogCQlfX3RoaXNfY3B1X2luYyhtZW0tPnN0YXQtPmNvdW50W01FTV9DR1JPVVBfU1RBVF9QR1BHT1VUX0NPVU5UXSk7Ci0JX190aGlzX2NwdV9pbmMobWVtLT5zdGF0LT5jb3VudFtNRU1fQ0dST1VQX0VWRU5UU10pOworCQlucl9wYWdlcyA9IC1ucl9wYWdlczsgLyogZm9yIGV2ZW50ICovCisJfQorCisJX190aGlzX2NwdV9hZGQobWVtLT5zdGF0LT5jb3VudFtNRU1fQ0dST1VQX0VWRU5UU10sIG5yX3BhZ2VzKTsKIAogCXByZWVtcHRfZW5hYmxlKCk7CiB9CkBAIC04MTYsMTIgKzgxNiwxMiBAQAogCSAqIHJlbW92ZWQgZnJvbSBnbG9iYWwgTFJVLgogCSAqLwogCW16ID0gcGFnZV9jZ3JvdXBfem9uZWluZm8ocGMpOwotCU1FTV9DR1JPVVBfWlNUQVQobXosIGxydSkgLT0gMTsKKwkvKiBodWdlIHBhZ2Ugc3BsaXQgaXMgZG9uZSB1bmRlciBscnVfbG9jay4gc28sIHdlIGhhdmUgbm8gcmFjZXMuICovCisJTUVNX0NHUk9VUF9aU1RBVChteiwgbHJ1KSAtPSAxIDw8IGNvbXBvdW5kX29yZGVyKHBhZ2UpOwogCWlmIChtZW1fY2dyb3VwX2lzX3Jvb3QocGMtPm1lbV9jZ3JvdXApKQogCQlyZXR1cm47CiAJVk1fQlVHX09OKGxpc3RfZW1wdHkoJnBjLT5scnUpKTsKIAlsaXN0X2RlbF9pbml0KCZwYy0+bHJ1KTsKLQlyZXR1cm47CiB9CiAKIHZvaWQgbWVtX2Nncm91cF9kZWxfbHJ1KHN0cnVjdCBwYWdlICpwYWdlKQpAQCAtODM4LDEzICs4MzgsMTIgQEAKIAkJcmV0dXJuOwogCiAJcGMgPSBsb29rdXBfcGFnZV9jZ3JvdXAocGFnZSk7Ci0JLyoKLQkgKiBVc2VkIGJpdCBpcyBzZXQgd2l0aG91dCBhdG9taWMgb3BzIGJ1dCBhZnRlciBzbXBfd21iKCkuCi0JICogRm9yIG1ha2luZyBwYy0+bWVtX2Nncm91cCB2aXNpYmxlLCBpbnNlcnQgc21wX3JtYigpIGhlcmUuCi0JICovCi0Jc21wX3JtYigpOwogCS8qIHVudXNlZCBvciByb290IHBhZ2UgaXMgbm90IHJvdGF0ZWQuICovCi0JaWYgKCFQYWdlQ2dyb3VwVXNlZChwYykgfHwgbWVtX2Nncm91cF9pc19yb290KHBjLT5tZW1fY2dyb3VwKSkKKwlpZiAoIVBhZ2VDZ3JvdXBVc2VkKHBjKSkKKwkJcmV0dXJuOworCS8qIEVuc3VyZSBwYy0+bWVtX2Nncm91cCBpcyB2aXNpYmxlIGFmdGVyIHJlYWRpbmcgUENHX1VTRUQuICovCisJc21wX3JtYigpOworCWlmIChtZW1fY2dyb3VwX2lzX3Jvb3QocGMtPm1lbV9jZ3JvdXApKQogCQlyZXR1cm47CiAJbXogPSBwYWdlX2Nncm91cF96b25laW5mbyhwYyk7CiAJbGlzdF9tb3ZlKCZwYy0+bHJ1LCAmbXotPmxpc3RzW2xydV0pOwpAQCAtODU5LDE2ICs4NTgsMTMgQEAKIAkJcmV0dXJuOwogCXBjID0gbG9va3VwX3BhZ2VfY2dyb3VwKHBhZ2UpOwogCVZNX0JVR19PTihQYWdlQ2dyb3VwQWNjdExSVShwYykpOwotCS8qCi0JICogVXNlZCBiaXQgaXMgc2V0IHdpdGhvdXQgYXRvbWljIG9wcyBidXQgYWZ0ZXIgc21wX3dtYigpLgotCSAqIEZvciBtYWtpbmcgcGMtPm1lbV9jZ3JvdXAgdmlzaWJsZSwgaW5zZXJ0IHNtcF9ybWIoKSBoZXJlLgotCSAqLwotCXNtcF9ybWIoKTsKIAlpZiAoIVBhZ2VDZ3JvdXBVc2VkKHBjKSkKIAkJcmV0dXJuOwotCisJLyogRW5zdXJlIHBjLT5tZW1fY2dyb3VwIGlzIHZpc2libGUgYWZ0ZXIgcmVhZGluZyBQQ0dfVVNFRC4gKi8KKwlzbXBfcm1iKCk7CiAJbXogPSBwYWdlX2Nncm91cF96b25laW5mbyhwYyk7Ci0JTUVNX0NHUk9VUF9aU1RBVChteiwgbHJ1KSArPSAxOworCS8qIGh1Z2UgcGFnZSBzcGxpdCBpcyBkb25lIHVuZGVyIGxydV9sb2NrLiBzbywgd2UgaGF2ZSBubyByYWNlcy4gKi8KKwlNRU1fQ0dST1VQX1pTVEFUKG16LCBscnUpICs9IDEgPDwgY29tcG91bmRfb3JkZXIocGFnZSk7CiAJU2V0UGFnZUNncm91cEFjY3RMUlUocGMpOwogCWlmIChtZW1fY2dyb3VwX2lzX3Jvb3QocGMtPm1lbV9jZ3JvdXApKQogCQlyZXR1cm47CkBAIC0xMDMyLDE0ICsxMDI4LDEwIEBACiAJCXJldHVybiBOVUxMOwogCiAJcGMgPSBsb29rdXBfcGFnZV9jZ3JvdXAocGFnZSk7Ci0JLyoKLQkgKiBVc2VkIGJpdCBpcyBzZXQgd2l0aG91dCBhdG9taWMgb3BzIGJ1dCBhZnRlciBzbXBfd21iKCkuCi0JICogRm9yIG1ha2luZyBwYy0+bWVtX2Nncm91cCB2aXNpYmxlLCBpbnNlcnQgc21wX3JtYigpIGhlcmUuCi0JICovCi0Jc21wX3JtYigpOwogCWlmICghUGFnZUNncm91cFVzZWQocGMpKQogCQlyZXR1cm4gTlVMTDsKLQorCS8qIEVuc3VyZSBwYy0+bWVtX2Nncm91cCBpcyB2aXNpYmxlIGFmdGVyIHJlYWRpbmcgUENHX1VTRUQuICovCisJc21wX3JtYigpOwogCW16ID0gcGFnZV9jZ3JvdXBfem9uZWluZm8ocGMpOwogCWlmICghbXopCiAJCXJldHVybiBOVUxMOwpAQCAtMTA4Nyw3ICsxMDc5LDcgQEAKIAkJY2FzZSAwOgogCQkJbGlzdF9tb3ZlKCZwYWdlLT5scnUsIGRzdCk7CiAJCQltZW1fY2dyb3VwX2RlbF9scnUocGFnZSk7Ci0JCQlucl90YWtlbisrOworCQkJbnJfdGFrZW4gKz0gaHBhZ2VfbnJfcGFnZXMocGFnZSk7CiAJCQlicmVhazsKIAkJY2FzZSAtRUJVU1k6CiAJCQkvKiB3ZSBkb24ndCBhZmZlY3QgZ2xvYmFsIExSVSBidXQgcm90YXRlIGluIG91ciBMUlUgKi8KQEAgLTExMjEsNiArMTExMywyMyBAQAogCXJldHVybiBmYWxzZTsKIH0KIAorLyoqCisgKiBtZW1fY2dyb3VwX2NoZWNrX21hcmdpbiAtIGNoZWNrIGlmIHRoZSBtZW1vcnkgY2dyb3VwIGFsbG93cyBjaGFyZ2luZworICogQG1lbTogbWVtb3J5IGNncm91cCB0byBjaGVjaworICogQGJ5dGVzOiB0aGUgbnVtYmVyIG9mIGJ5dGVzIHRoZSBjYWxsZXIgaW50ZW5kcyB0byBjaGFyZ2UKKyAqCisgKiBSZXR1cm5zIGEgYm9vbGVhbiB2YWx1ZSBvbiB3aGV0aGVyIEBtZW0gY2FuIGJlIGNoYXJnZWQgQGJ5dGVzIG9yCisgKiB3aGV0aGVyIHRoaXMgd291bGQgZXhjZWVkIHRoZSBsaW1pdC4KKyAqLworc3RhdGljIGJvb2wgbWVtX2Nncm91cF9jaGVja19tYXJnaW4oc3RydWN0IG1lbV9jZ3JvdXAgKm1lbSwgdW5zaWduZWQgbG9uZyBieXRlcykKK3sKKwlpZiAoIXJlc19jb3VudGVyX2NoZWNrX21hcmdpbigmbWVtLT5yZXMsIGJ5dGVzKSkKKwkJcmV0dXJuIGZhbHNlOworCWlmIChkb19zd2FwX2FjY291bnQgJiYgIXJlc19jb3VudGVyX2NoZWNrX21hcmdpbigmbWVtLT5tZW1zdywgYnl0ZXMpKQorCQlyZXR1cm4gZmFsc2U7CisJcmV0dXJuIHRydWU7Cit9CisKIHN0YXRpYyB1bnNpZ25lZCBpbnQgZ2V0X3N3YXBwaW5lc3Moc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnKQogewogCXN0cnVjdCBjZ3JvdXAgKmNncnAgPSBtZW1jZy0+Y3NzLmNncm91cDsKQEAgLTEzMTIsOCArMTMyMSw5IEBACiAJdTY0IGxpbWl0OwogCXU2NCBtZW1zdzsKIAotCWxpbWl0ID0gcmVzX2NvdW50ZXJfcmVhZF91NjQoJm1lbWNnLT5yZXMsIFJFU19MSU1JVCkgKwotCQkJdG90YWxfc3dhcF9wYWdlczsKKwlsaW1pdCA9IHJlc19jb3VudGVyX3JlYWRfdTY0KCZtZW1jZy0+cmVzLCBSRVNfTElNSVQpOworCWxpbWl0ICs9IHRvdGFsX3N3YXBfcGFnZXMgPDwgUEFHRV9TSElGVDsKKwogCW1lbXN3ID0gcmVzX2NvdW50ZXJfcmVhZF91NjQoJm1lbWNnLT5tZW1zdywgUkVTX0xJTUlUKTsKIAkvKgogCSAqIElmIG1lbXN3IGlzIGZpbml0ZSBhbmQgbGltaXRzIHRoZSBhbW91bnQgb2Ygc3dhcCBzcGFjZSBhdmFpbGFibGUKQEAgLTE2MDAsMTEgKzE2MTAsMTMgQEAKICAqIHBvc3NpYmlsaXR5IG9mIHJhY2UgY29uZGl0aW9uLiBJZiB0aGVyZSBpcywgd2UgdGFrZSBhIGxvY2suCiAgKi8KIAotc3RhdGljIHZvaWQgbWVtX2Nncm91cF91cGRhdGVfZmlsZV9zdGF0KHN0cnVjdCBwYWdlICpwYWdlLCBpbnQgaWR4LCBpbnQgdmFsKQordm9pZCBtZW1fY2dyb3VwX3VwZGF0ZV9wYWdlX3N0YXQoc3RydWN0IHBhZ2UgKnBhZ2UsCisJCQkJIGVudW0gbWVtX2Nncm91cF9wYWdlX3N0YXRfaXRlbSBpZHgsIGludCB2YWwpCiB7CiAJc3RydWN0IG1lbV9jZ3JvdXAgKm1lbTsKIAlzdHJ1Y3QgcGFnZV9jZ3JvdXAgKnBjID0gbG9va3VwX3BhZ2VfY2dyb3VwKHBhZ2UpOwogCWJvb2wgbmVlZF91bmxvY2sgPSBmYWxzZTsKKwl1bnNpZ25lZCBsb25nIHVuaW5pdGlhbGl6ZWRfdmFyKGZsYWdzKTsKIAogCWlmICh1bmxpa2VseSghcGMpKQogCQlyZXR1cm47CkBAIC0xNjE0LDM5ICsxNjI2LDM2IEBACiAJaWYgKHVubGlrZWx5KCFtZW0gfHwgIVBhZ2VDZ3JvdXBVc2VkKHBjKSkpCiAJCWdvdG8gb3V0OwogCS8qIHBjLT5tZW1fY2dyb3VwIGlzIHVuc3RhYmxlID8gKi8KLQlpZiAodW5saWtlbHkobWVtX2Nncm91cF9zdGVhbGVkKG1lbSkpKSB7CisJaWYgKHVubGlrZWx5KG1lbV9jZ3JvdXBfc3RlYWxlZChtZW0pKSB8fCBQYWdlVHJhbnNIdWdlKHBhZ2UpKSB7CiAJCS8qIHRha2UgYSBsb2NrIGFnYWluc3QgdG8gYWNjZXNzIHBjLT5tZW1fY2dyb3VwICovCi0JCWxvY2tfcGFnZV9jZ3JvdXAocGMpOworCQltb3ZlX2xvY2tfcGFnZV9jZ3JvdXAocGMsICZmbGFncyk7CiAJCW5lZWRfdW5sb2NrID0gdHJ1ZTsKIAkJbWVtID0gcGMtPm1lbV9jZ3JvdXA7CiAJCWlmICghbWVtIHx8ICFQYWdlQ2dyb3VwVXNlZChwYykpCiAJCQlnb3RvIG91dDsKIAl9CiAKLQl0aGlzX2NwdV9hZGQobWVtLT5zdGF0LT5jb3VudFtpZHhdLCB2YWwpOwotCiAJc3dpdGNoIChpZHgpIHsKLQljYXNlIE1FTV9DR1JPVVBfU1RBVF9GSUxFX01BUFBFRDoKKwljYXNlIE1FTUNHX05SX0ZJTEVfTUFQUEVEOgogCQlpZiAodmFsID4gMCkKIAkJCVNldFBhZ2VDZ3JvdXBGaWxlTWFwcGVkKHBjKTsKIAkJZWxzZSBpZiAoIXBhZ2VfbWFwcGVkKHBhZ2UpKQogCQkJQ2xlYXJQYWdlQ2dyb3VwRmlsZU1hcHBlZChwYyk7CisJCWlkeCA9IE1FTV9DR1JPVVBfU1RBVF9GSUxFX01BUFBFRDsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJQlVHKCk7CiAJfQogCisJdGhpc19jcHVfYWRkKG1lbS0+c3RhdC0+Y291bnRbaWR4XSwgdmFsKTsKKwogb3V0OgogCWlmICh1bmxpa2VseShuZWVkX3VubG9jaykpCi0JCXVubG9ja19wYWdlX2Nncm91cChwYyk7CisJCW1vdmVfdW5sb2NrX3BhZ2VfY2dyb3VwKHBjLCAmZmxhZ3MpOwogCXJjdV9yZWFkX3VubG9jaygpOwogCXJldHVybjsKIH0KLQotdm9pZCBtZW1fY2dyb3VwX3VwZGF0ZV9maWxlX21hcHBlZChzdHJ1Y3QgcGFnZSAqcGFnZSwgaW50IHZhbCkKLXsKLQltZW1fY2dyb3VwX3VwZGF0ZV9maWxlX3N0YXQocGFnZSwgTUVNX0NHUk9VUF9TVEFUX0ZJTEVfTUFQUEVELCB2YWwpOwotfQorRVhQT1JUX1NZTUJPTChtZW1fY2dyb3VwX3VwZGF0ZV9wYWdlX3N0YXQpOwogCiAvKgogICogc2l6ZSBvZiBmaXJzdCBjaGFyZ2UgdHJpYWwuICIzMiIgY29tZXMgZnJvbSB2bXNjYW4uYydzIG1hZ2ljIHZhbHVlLgpAQCAtMTg0MiwyNyArMTg1MSwzOSBAQAogCQlpZiAobGlrZWx5KCFyZXQpKQogCQkJcmV0dXJuIENIQVJHRV9PSzsKIAorCQlyZXNfY291bnRlcl91bmNoYXJnZSgmbWVtLT5yZXMsIGNzaXplKTsKIAkJbWVtX292ZXJfbGltaXQgPSBtZW1fY2dyb3VwX2Zyb21fcmVzX2NvdW50ZXIoZmFpbF9yZXMsIG1lbXN3KTsKIAkJZmxhZ3MgfD0gTUVNX0NHUk9VUF9SRUNMQUlNX05PU1dBUDsKIAl9IGVsc2UKIAkJbWVtX292ZXJfbGltaXQgPSBtZW1fY2dyb3VwX2Zyb21fcmVzX2NvdW50ZXIoZmFpbF9yZXMsIHJlcyk7Ci0KLQlpZiAoY3NpemUgPiBQQUdFX1NJWkUpIC8qIGNoYW5nZSBjc2l6ZSBhbmQgcmV0cnkgKi8KKwkvKgorCSAqIGNzaXplIGNhbiBiZSBlaXRoZXIgYSBodWdlIHBhZ2UgKEhQQUdFX1NJWkUpLCBhIGJhdGNoIG9mCisJICogcmVndWxhciBwYWdlcyAoQ0hBUkdFX1NJWkUpLCBvciBhIHNpbmdsZSByZWd1bGFyIHBhZ2UKKwkgKiAoUEFHRV9TSVpFKS4KKwkgKgorCSAqIE5ldmVyIHJlY2xhaW0gb24gYmVoYWxmIG9mIG9wdGlvbmFsIGJhdGNoaW5nLCByZXRyeSB3aXRoIGEKKwkgKiBzaW5nbGUgcGFnZSBpbnN0ZWFkLgorCSAqLworCWlmIChjc2l6ZSA9PSBDSEFSR0VfU0laRSkKIAkJcmV0dXJuIENIQVJHRV9SRVRSWTsKIAogCWlmICghKGdmcF9tYXNrICYgX19HRlBfV0FJVCkpCiAJCXJldHVybiBDSEFSR0VfV09VTERCTE9DSzsKIAogCXJldCA9IG1lbV9jZ3JvdXBfaGllcmFyY2hpY2FsX3JlY2xhaW0obWVtX292ZXJfbGltaXQsIE5VTEwsCi0JCQkJCWdmcF9tYXNrLCBmbGFncyk7CisJCQkJCSAgICAgIGdmcF9tYXNrLCBmbGFncyk7CisJaWYgKG1lbV9jZ3JvdXBfY2hlY2tfbWFyZ2luKG1lbV9vdmVyX2xpbWl0LCBjc2l6ZSkpCisJCXJldHVybiBDSEFSR0VfUkVUUlk7CiAJLyoKLQkgKiB0cnlfdG9fZnJlZV9tZW1fY2dyb3VwX3BhZ2VzKCkgbWlnaHQgbm90IGdpdmUgdXMgYSBmdWxsCi0JICogcGljdHVyZSBvZiByZWNsYWltLiBTb21lIHBhZ2VzIGFyZSByZWNsYWltZWQgYW5kIG1pZ2h0IGJlCi0JICogbW92ZWQgdG8gc3dhcCBjYWNoZSBvciBqdXN0IHVubWFwcGVkIGZyb20gdGhlIGNncm91cC4KLQkgKiBDaGVjayB0aGUgbGltaXQgYWdhaW4gdG8gc2VlIGlmIHRoZSByZWNsYWltIHJlZHVjZWQgdGhlCi0JICogY3VycmVudCB1c2FnZSBvZiB0aGUgY2dyb3VwIGJlZm9yZSBnaXZpbmcgdXAKKwkgKiBFdmVuIHRob3VnaCB0aGUgbGltaXQgaXMgZXhjZWVkZWQgYXQgdGhpcyBwb2ludCwgcmVjbGFpbQorCSAqIG1heSBoYXZlIGJlZW4gYWJsZSB0byBmcmVlIHNvbWUgcGFnZXMuICBSZXRyeSB0aGUgY2hhcmdlCisJICogYmVmb3JlIGtpbGxpbmcgdGhlIHRhc2suCisJICoKKwkgKiBPbmx5IGZvciByZWd1bGFyIHBhZ2VzLCB0aG91Z2g6IGh1Z2UgcGFnZXMgYXJlIHJhdGhlcgorCSAqIHVubGlrZWx5IHRvIHN1Y2NlZWQgc28gY2xvc2UgdG8gdGhlIGxpbWl0LCBhbmQgd2UgZmFsbCBiYWNrCisJICogdG8gcmVndWxhciBwYWdlcyBhbnl3YXkgaW4gY2FzZSBvZiBmYWlsdXJlLgogCSAqLwotCWlmIChyZXQgfHwgbWVtX2Nncm91cF9jaGVja191bmRlcl9saW1pdChtZW1fb3Zlcl9saW1pdCkpCisJaWYgKGNzaXplID09IFBBR0VfU0laRSAmJiByZXQpCiAJCXJldHVybiBDSEFSR0VfUkVUUlk7CiAKIAkvKgpAQCAtMTg4NywxMiArMTkwOCwxNCBAQAogICogb29tLWtpbGxlciBjYW4gYmUgaW52b2tlZC4KICAqLwogc3RhdGljIGludCBfX21lbV9jZ3JvdXBfdHJ5X2NoYXJnZShzdHJ1Y3QgbW1fc3RydWN0ICptbSwKLQkJZ2ZwX3QgZ2ZwX21hc2ssIHN0cnVjdCBtZW1fY2dyb3VwICoqbWVtY2csIGJvb2wgb29tKQorCQkJCSAgIGdmcF90IGdmcF9tYXNrLAorCQkJCSAgIHN0cnVjdCBtZW1fY2dyb3VwICoqbWVtY2csIGJvb2wgb29tLAorCQkJCSAgIGludCBwYWdlX3NpemUpCiB7CiAJaW50IG5yX29vbV9yZXRyaWVzID0gTUVNX0NHUk9VUF9SRUNMQUlNX1JFVFJJRVM7CiAJc3RydWN0IG1lbV9jZ3JvdXAgKm1lbSA9IE5VTEw7CiAJaW50IHJldDsKLQlpbnQgY3NpemUgPSBDSEFSR0VfU0laRTsKKwlpbnQgY3NpemUgPSBtYXgoQ0hBUkdFX1NJWkUsICh1bnNpZ25lZCBsb25nKSBwYWdlX3NpemUpOwogCiAJLyoKIAkgKiBVbmxpa2UgZ2xvdmFsLXZtJ3MgT09NLWtpbGwsIHdlJ3JlIG5vdCBpbiBtZW1vcnkgc2hvcnRhZ2UKQEAgLTE5MTcsNyArMTk0MCw3IEBACiAJCVZNX0JVR19PTihjc3NfaXNfcmVtb3ZlZCgmbWVtLT5jc3MpKTsKIAkJaWYgKG1lbV9jZ3JvdXBfaXNfcm9vdChtZW0pKQogCQkJZ290byBkb25lOwotCQlpZiAoY29uc3VtZV9zdG9jayhtZW0pKQorCQlpZiAocGFnZV9zaXplID09IFBBR0VfU0laRSAmJiBjb25zdW1lX3N0b2NrKG1lbSkpCiAJCQlnb3RvIGRvbmU7CiAJCWNzc19nZXQoJm1lbS0+Y3NzKTsKIAl9IGVsc2UgewpAQCAtMTk0MCw3ICsxOTYzLDcgQEAKIAkJCXJjdV9yZWFkX3VubG9jaygpOwogCQkJZ290byBkb25lOwogCQl9Ci0JCWlmIChjb25zdW1lX3N0b2NrKG1lbSkpIHsKKwkJaWYgKHBhZ2Vfc2l6ZSA9PSBQQUdFX1NJWkUgJiYgY29uc3VtZV9zdG9jayhtZW0pKSB7CiAJCQkvKgogCQkJICogSXQgc2VlbXMgZGFnZXJvdXMgdG8gYWNjZXNzIG1lbWNnIHdpdGhvdXQgY3NzX2dldCgpLgogCQkJICogQnV0IGNvbnNpZGVyaW5nIGhvdyBjb25zdW1lX3N0b2sgd29ya3MsIGl0J3Mgbm90CkBAIC0xOTgxLDcgKzIwMDQsNyBAQAogCQljYXNlIENIQVJHRV9PSzoKIAkJCWJyZWFrOwogCQljYXNlIENIQVJHRV9SRVRSWTogLyogbm90IGluIE9PTSBzaXR1YXRpb24gYnV0IHJldHJ5ICovCi0JCQljc2l6ZSA9IFBBR0VfU0laRTsKKwkJCWNzaXplID0gcGFnZV9zaXplOwogCQkJY3NzX3B1dCgmbWVtLT5jc3MpOwogCQkJbWVtID0gTlVMTDsKIAkJCWdvdG8gYWdhaW47CkBAIC0yMDAyLDggKzIwMjUsOCBAQAogCQl9CiAJfSB3aGlsZSAocmV0ICE9IENIQVJHRV9PSyk7CiAKLQlpZiAoY3NpemUgPiBQQUdFX1NJWkUpCi0JCXJlZmlsbF9zdG9jayhtZW0sIGNzaXplIC0gUEFHRV9TSVpFKTsKKwlpZiAoY3NpemUgPiBwYWdlX3NpemUpCisJCXJlZmlsbF9zdG9jayhtZW0sIGNzaXplIC0gcGFnZV9zaXplKTsKIAljc3NfcHV0KCZtZW0tPmNzcyk7CiBkb25lOgogCSptZW1jZyA9IG1lbTsKQEAgLTIwMzEsOSArMjA1NCwxMCBAQAogCX0KIH0KIAotc3RhdGljIHZvaWQgbWVtX2Nncm91cF9jYW5jZWxfY2hhcmdlKHN0cnVjdCBtZW1fY2dyb3VwICptZW0pCitzdGF0aWMgdm9pZCBtZW1fY2dyb3VwX2NhbmNlbF9jaGFyZ2Uoc3RydWN0IG1lbV9jZ3JvdXAgKm1lbSwKKwkJCQkgICAgIGludCBwYWdlX3NpemUpCiB7Ci0JX19tZW1fY2dyb3VwX2NhbmNlbF9jaGFyZ2UobWVtLCAxKTsKKwlfX21lbV9jZ3JvdXBfY2FuY2VsX2NoYXJnZShtZW0sIHBhZ2Vfc2l6ZSA+PiBQQUdFX1NISUZUKTsKIH0KIAogLyoKQEAgLTIwODMsMTUgKzIxMDcsMTMgQEAKIAlyZXR1cm4gbWVtOwogfQogCi0vKgotICogY29tbWl0IGEgY2hhcmdlIGdvdCBieSBfX21lbV9jZ3JvdXBfdHJ5X2NoYXJnZSgpIGFuZCBtYWtlcyBwYWdlX2Nncm91cCB0byBiZQotICogVVNFRCBzdGF0ZS4gSWYgYWxyZWFkeSBVU0VELCB1bmNoYXJnZSBhbmQgcmV0dXJuLgotICovCi0KIHN0YXRpYyB2b2lkIF9fbWVtX2Nncm91cF9jb21taXRfY2hhcmdlKHN0cnVjdCBtZW1fY2dyb3VwICptZW0sCi0JCQkJICAgICBzdHJ1Y3QgcGFnZV9jZ3JvdXAgKnBjLAotCQkJCSAgICAgZW51bSBjaGFyZ2VfdHlwZSBjdHlwZSkKKwkJCQkgICAgICAgc3RydWN0IHBhZ2VfY2dyb3VwICpwYywKKwkJCQkgICAgICAgZW51bSBjaGFyZ2VfdHlwZSBjdHlwZSwKKwkJCQkgICAgICAgaW50IHBhZ2Vfc2l6ZSkKIHsKKwlpbnQgbnJfcGFnZXMgPSBwYWdlX3NpemUgPj4gUEFHRV9TSElGVDsKKwogCS8qIHRyeV9jaGFyZ2UoKSBjYW4gcmV0dXJuIE5VTEwgdG8gKm1lbWNnLCB0YWtpbmcgY2FyZSBvZiBpdC4gKi8KIAlpZiAoIW1lbSkKIAkJcmV0dXJuOwpAQCAtMjA5OSwxMCArMjEyMSwxMyBAQAogCWxvY2tfcGFnZV9jZ3JvdXAocGMpOwogCWlmICh1bmxpa2VseShQYWdlQ2dyb3VwVXNlZChwYykpKSB7CiAJCXVubG9ja19wYWdlX2Nncm91cChwYyk7Ci0JCW1lbV9jZ3JvdXBfY2FuY2VsX2NoYXJnZShtZW0pOworCQltZW1fY2dyb3VwX2NhbmNlbF9jaGFyZ2UobWVtLCBwYWdlX3NpemUpOwogCQlyZXR1cm47CiAJfQotCisJLyoKKwkgKiB3ZSBkb24ndCBuZWVkIHBhZ2VfY2dyb3VwX2xvY2sgYWJvdXQgdGFpbCBwYWdlcywgYmVjYXNlIHRoZXkgYXJlIG5vdAorCSAqIGFjY2Vzc2VkIGJ5IGFueSBvdGhlciBjb250ZXh0IGF0IHRoaXMgcG9pbnQuCisJICovCiAJcGMtPm1lbV9jZ3JvdXAgPSBtZW07CiAJLyoKIAkgKiBXZSBhY2Nlc3MgYSBwYWdlX2Nncm91cCBhc3luY2hyb25vdXNseSB3aXRob3V0IGxvY2tfcGFnZV9jZ3JvdXAoKS4KQEAgLTIxMjYsOCArMjE1MSw3IEBACiAJCWJyZWFrOwogCX0KIAotCW1lbV9jZ3JvdXBfY2hhcmdlX3N0YXRpc3RpY3MobWVtLCBwYywgdHJ1ZSk7Ci0KKwltZW1fY2dyb3VwX2NoYXJnZV9zdGF0aXN0aWNzKG1lbSwgUGFnZUNncm91cENhY2hlKHBjKSwgbnJfcGFnZXMpOwogCXVubG9ja19wYWdlX2Nncm91cChwYyk7CiAJLyoKIAkgKiAiY2hhcmdlX3N0YXRpc3RpY3MiIHVwZGF0ZWQgZXZlbnQgY291bnRlci4gVGhlbiwgY2hlY2sgaXQuCkBAIC0yMTM3LDYgKzIxNjEsNDggQEAKIAltZW1jZ19jaGVja19ldmVudHMobWVtLCBwYy0+cGFnZSk7CiB9CiAKKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UKKworI2RlZmluZSBQQ0dGX05PQ09QWV9BVF9TUExJVCAoKDEgPDwgUENHX0xPQ0spIHwgKDEgPDwgUENHX01PVkVfTE9DSykgfFwKKwkJCSgxIDw8IFBDR19BQ0NUX0xSVSkgfCAoMSA8PCBQQ0dfTUlHUkFUSU9OKSkKKy8qCisgKiBCZWNhdXNlIHRhaWwgcGFnZXMgYXJlIG5vdCBtYXJrZWQgYXMgInVzZWQiLCBzZXQgaXQuIFdlJ3JlIHVuZGVyCisgKiB6b25lLT5scnVfbG9jaywgJ3NwbGl0dGluZyBvbiBwbWQnIGFuZCBjb21wdW5kX2xvY2suCisgKi8KK3ZvaWQgbWVtX2Nncm91cF9zcGxpdF9odWdlX2ZpeHVwKHN0cnVjdCBwYWdlICpoZWFkLCBzdHJ1Y3QgcGFnZSAqdGFpbCkKK3sKKwlzdHJ1Y3QgcGFnZV9jZ3JvdXAgKmhlYWRfcGMgPSBsb29rdXBfcGFnZV9jZ3JvdXAoaGVhZCk7CisJc3RydWN0IHBhZ2VfY2dyb3VwICp0YWlsX3BjID0gbG9va3VwX3BhZ2VfY2dyb3VwKHRhaWwpOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlpZiAobWVtX2Nncm91cF9kaXNhYmxlZCgpKQorCQlyZXR1cm47CisJLyoKKwkgKiBXZSBoYXZlIG5vIHJhY2VzIHdpdGggY2hhcmdlL3VuY2hhcmdlIGJ1dCB3aWxsIGhhdmUgcmFjZXMgd2l0aAorCSAqIHBhZ2Ugc3RhdGUgYWNjb3VudGluZy4KKwkgKi8KKwltb3ZlX2xvY2tfcGFnZV9jZ3JvdXAoaGVhZF9wYywgJmZsYWdzKTsKKworCXRhaWxfcGMtPm1lbV9jZ3JvdXAgPSBoZWFkX3BjLT5tZW1fY2dyb3VwOworCXNtcF93bWIoKTsgLyogc2VlIF9fY29tbWl0X2NoYXJnZSgpICovCisJaWYgKFBhZ2VDZ3JvdXBBY2N0TFJVKGhlYWRfcGMpKSB7CisJCWVudW0gbHJ1X2xpc3QgbHJ1OworCQlzdHJ1Y3QgbWVtX2Nncm91cF9wZXJfem9uZSAqbXo7CisKKwkJLyoKKwkJICogTFJVIGZsYWdzIGNhbm5vdCBiZSBjb3BpZWQgYmVjYXVzZSB3ZSBuZWVkIHRvIGFkZCB0YWlsCisJCSAqLnBhZ2UgdG8gTFJVIGJ5IGdlbmVyaWMgY2FsbCBhbmQgb3VyIGhvb2sgd2lsbCBiZSBjYWxsZWQuCisJCSAqIFdlIGhvbGQgbHJ1X2xvY2ssIHRoZW4sIHJlZHVjZSBjb3VudGVyIGRpcmVjdGx5LgorCQkgKi8KKwkJbHJ1ID0gcGFnZV9scnUoaGVhZCk7CisJCW16ID0gcGFnZV9jZ3JvdXBfem9uZWluZm8oaGVhZF9wYyk7CisJCU1FTV9DR1JPVVBfWlNUQVQobXosIGxydSkgLT0gMTsKKwl9CisJdGFpbF9wYy0+ZmxhZ3MgPSBoZWFkX3BjLT5mbGFncyAmIH5QQ0dGX05PQ09QWV9BVF9TUExJVDsKKwltb3ZlX3VubG9ja19wYWdlX2Nncm91cChoZWFkX3BjLCAmZmxhZ3MpOworfQorI2VuZGlmCisKIC8qKgogICogX19tZW1fY2dyb3VwX21vdmVfYWNjb3VudCAtIG1vdmUgYWNjb3VudCBvZiB0aGUgcGFnZQogICogQHBjOglwYWdlX2Nncm91cCBvZiB0aGUgcGFnZS4KQEAgLTIxNTUsOCArMjIyMSwxMSBAQAogICovCiAKIHN0YXRpYyB2b2lkIF9fbWVtX2Nncm91cF9tb3ZlX2FjY291bnQoc3RydWN0IHBhZ2VfY2dyb3VwICpwYywKLQlzdHJ1Y3QgbWVtX2Nncm91cCAqZnJvbSwgc3RydWN0IG1lbV9jZ3JvdXAgKnRvLCBib29sIHVuY2hhcmdlKQorCXN0cnVjdCBtZW1fY2dyb3VwICpmcm9tLCBzdHJ1Y3QgbWVtX2Nncm91cCAqdG8sIGJvb2wgdW5jaGFyZ2UsCisJaW50IGNoYXJnZV9zaXplKQogeworCWludCBucl9wYWdlcyA9IGNoYXJnZV9zaXplID4+IFBBR0VfU0hJRlQ7CisKIAlWTV9CVUdfT04oZnJvbSA9PSB0byk7CiAJVk1fQlVHX09OKFBhZ2VMUlUocGMtPnBhZ2UpKTsKIAlWTV9CVUdfT04oIXBhZ2VfaXNfY2dyb3VwX2xvY2tlZChwYykpOwpAQCAtMjE3MCwxNCArMjIzOSwxNCBAQAogCQlfX3RoaXNfY3B1X2luYyh0by0+c3RhdC0+Y291bnRbTUVNX0NHUk9VUF9TVEFUX0ZJTEVfTUFQUEVEXSk7CiAJCXByZWVtcHRfZW5hYmxlKCk7CiAJfQotCW1lbV9jZ3JvdXBfY2hhcmdlX3N0YXRpc3RpY3MoZnJvbSwgcGMsIGZhbHNlKTsKKwltZW1fY2dyb3VwX2NoYXJnZV9zdGF0aXN0aWNzKGZyb20sIFBhZ2VDZ3JvdXBDYWNoZShwYyksIC1ucl9wYWdlcyk7CiAJaWYgKHVuY2hhcmdlKQogCQkvKiBUaGlzIGlzIG5vdCAiY2FuY2VsIiwgYnV0IGNhbmNlbF9jaGFyZ2UgZG9lcyBhbGwgd2UgbmVlZC4gKi8KLQkJbWVtX2Nncm91cF9jYW5jZWxfY2hhcmdlKGZyb20pOworCQltZW1fY2dyb3VwX2NhbmNlbF9jaGFyZ2UoZnJvbSwgY2hhcmdlX3NpemUpOwogCiAJLyogY2FsbGVyIHNob3VsZCBoYXZlIGRvbmUgY3NzX2dldCAqLwogCXBjLT5tZW1fY2dyb3VwID0gdG87Ci0JbWVtX2Nncm91cF9jaGFyZ2Vfc3RhdGlzdGljcyh0bywgcGMsIHRydWUpOworCW1lbV9jZ3JvdXBfY2hhcmdlX3N0YXRpc3RpY3ModG8sIFBhZ2VDZ3JvdXBDYWNoZShwYyksIG5yX3BhZ2VzKTsKIAkvKgogCSAqIFdlIGNoYXJnZXMgYWdhaW5zdCAidG8iIHdoaWNoIG1heSBub3QgaGF2ZSBhbnkgdGFza3MuIFRoZW4sICJ0byIKIAkgKiBjYW4gYmUgdW5kZXIgcm1kaXIoKS4gQnV0IGluIGN1cnJlbnQgaW1wbGVtZW50YXRpb24sIGNhbGxlciBvZgpAQCAtMjE5MiwxMiArMjI2MSwyNSBAQAogICogX19tZW1fY2dyb3VwX21vdmVfYWNjb3VudCgpCiAgKi8KIHN0YXRpYyBpbnQgbWVtX2Nncm91cF9tb3ZlX2FjY291bnQoc3RydWN0IHBhZ2VfY2dyb3VwICpwYywKLQkJc3RydWN0IG1lbV9jZ3JvdXAgKmZyb20sIHN0cnVjdCBtZW1fY2dyb3VwICp0bywgYm9vbCB1bmNoYXJnZSkKKwkJc3RydWN0IG1lbV9jZ3JvdXAgKmZyb20sIHN0cnVjdCBtZW1fY2dyb3VwICp0bywKKwkJYm9vbCB1bmNoYXJnZSwgaW50IGNoYXJnZV9zaXplKQogewogCWludCByZXQgPSAtRUlOVkFMOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJLyoKKwkgKiBUaGUgcGFnZSBpcyBpc29sYXRlZCBmcm9tIExSVS4gU28sIGNvbGxhcHNlIGZ1bmN0aW9uCisJICogd2lsbCBub3QgaGFuZGxlIHRoaXMgcGFnZS4gQnV0IHBhZ2Ugc3BsaXR0aW5nIGNhbiBoYXBwZW4uCisJICogRG8gdGhpcyBjaGVjayB1bmRlciBjb21wb3VuZF9wYWdlX2xvY2soKS4gVGhlIGNhbGxlciBzaG91bGQKKwkgKiBob2xkIGl0LgorCSAqLworCWlmICgoY2hhcmdlX3NpemUgPiBQQUdFX1NJWkUpICYmICFQYWdlVHJhbnNIdWdlKHBjLT5wYWdlKSkKKwkJcmV0dXJuIC1FQlVTWTsKKwogCWxvY2tfcGFnZV9jZ3JvdXAocGMpOwogCWlmIChQYWdlQ2dyb3VwVXNlZChwYykgJiYgcGMtPm1lbV9jZ3JvdXAgPT0gZnJvbSkgewotCQlfX21lbV9jZ3JvdXBfbW92ZV9hY2NvdW50KHBjLCBmcm9tLCB0bywgdW5jaGFyZ2UpOworCQltb3ZlX2xvY2tfcGFnZV9jZ3JvdXAocGMsICZmbGFncyk7CisJCV9fbWVtX2Nncm91cF9tb3ZlX2FjY291bnQocGMsIGZyb20sIHRvLCB1bmNoYXJnZSwgY2hhcmdlX3NpemUpOworCQltb3ZlX3VubG9ja19wYWdlX2Nncm91cChwYywgJmZsYWdzKTsKIAkJcmV0ID0gMDsKIAl9CiAJdW5sb2NrX3BhZ2VfY2dyb3VwKHBjKTsKQEAgLTIyMjEsNiArMjMwMyw4IEBACiAJc3RydWN0IGNncm91cCAqY2cgPSBjaGlsZC0+Y3NzLmNncm91cDsKIAlzdHJ1Y3QgY2dyb3VwICpwY2cgPSBjZy0+cGFyZW50OwogCXN0cnVjdCBtZW1fY2dyb3VwICpwYXJlbnQ7CisJaW50IHBhZ2Vfc2l6ZSA9IFBBR0VfU0laRTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCByZXQ7CiAKIAkvKiBJcyBST09UID8gKi8KQEAgLTIyMzMsMTQgKzIzMTcsMjQgQEAKIAlpZiAoaXNvbGF0ZV9scnVfcGFnZShwYWdlKSkKIAkJZ290byBwdXQ7CiAKKwlpZiAoUGFnZVRyYW5zSHVnZShwYWdlKSkKKwkJcGFnZV9zaXplID0gSFBBR0VfU0laRTsKKwogCXBhcmVudCA9IG1lbV9jZ3JvdXBfZnJvbV9jb250KHBjZyk7Ci0JcmV0ID0gX19tZW1fY2dyb3VwX3RyeV9jaGFyZ2UoTlVMTCwgZ2ZwX21hc2ssICZwYXJlbnQsIGZhbHNlKTsKKwlyZXQgPSBfX21lbV9jZ3JvdXBfdHJ5X2NoYXJnZShOVUxMLCBnZnBfbWFzaywKKwkJCQkmcGFyZW50LCBmYWxzZSwgcGFnZV9zaXplKTsKIAlpZiAocmV0IHx8ICFwYXJlbnQpCiAJCWdvdG8gcHV0X2JhY2s7CiAKLQlyZXQgPSBtZW1fY2dyb3VwX21vdmVfYWNjb3VudChwYywgY2hpbGQsIHBhcmVudCwgdHJ1ZSk7CisJaWYgKHBhZ2Vfc2l6ZSA+IFBBR0VfU0laRSkKKwkJZmxhZ3MgPSBjb21wb3VuZF9sb2NrX2lycXNhdmUocGFnZSk7CisKKwlyZXQgPSBtZW1fY2dyb3VwX21vdmVfYWNjb3VudChwYywgY2hpbGQsIHBhcmVudCwgdHJ1ZSwgcGFnZV9zaXplKTsKIAlpZiAocmV0KQotCQltZW1fY2dyb3VwX2NhbmNlbF9jaGFyZ2UocGFyZW50KTsKKwkJbWVtX2Nncm91cF9jYW5jZWxfY2hhcmdlKHBhcmVudCwgcGFnZV9zaXplKTsKKworCWlmIChwYWdlX3NpemUgPiBQQUdFX1NJWkUpCisJCWNvbXBvdW5kX3VubG9ja19pcnFyZXN0b3JlKHBhZ2UsIGZsYWdzKTsKIHB1dF9iYWNrOgogCXB1dGJhY2tfbHJ1X3BhZ2UocGFnZSk7CiBwdXQ6CkBAIC0yMjU5LDIwICsyMzUzLDMyIEBACiAJCQkJZ2ZwX3QgZ2ZwX21hc2ssIGVudW0gY2hhcmdlX3R5cGUgY3R5cGUpCiB7CiAJc3RydWN0IG1lbV9jZ3JvdXAgKm1lbSA9IE5VTEw7CisJaW50IHBhZ2Vfc2l6ZSA9IFBBR0VfU0laRTsKIAlzdHJ1Y3QgcGFnZV9jZ3JvdXAgKnBjOworCWJvb2wgb29tID0gdHJ1ZTsKIAlpbnQgcmV0OwogCisJaWYgKFBhZ2VUcmFuc0h1Z2UocGFnZSkpIHsKKwkJcGFnZV9zaXplIDw8PSBjb21wb3VuZF9vcmRlcihwYWdlKTsKKwkJVk1fQlVHX09OKCFQYWdlVHJhbnNIdWdlKHBhZ2UpKTsKKwkJLyoKKwkJICogTmV2ZXIgT09NLWtpbGwgYSBwcm9jZXNzIGZvciBhIGh1Z2UgcGFnZS4gIFRoZQorCQkgKiBmYXVsdCBoYW5kbGVyIHdpbGwgZmFsbCBiYWNrIHRvIHJlZ3VsYXIgcGFnZXMuCisJCSAqLworCQlvb20gPSBmYWxzZTsKKwl9CisKIAlwYyA9IGxvb2t1cF9wYWdlX2Nncm91cChwYWdlKTsKIAkvKiBjYW4gaGFwcGVuIGF0IGJvb3QgKi8KIAlpZiAodW5saWtlbHkoIXBjKSkKIAkJcmV0dXJuIDA7CiAJcHJlZmV0Y2h3KHBjKTsKIAotCXJldCA9IF9fbWVtX2Nncm91cF90cnlfY2hhcmdlKG1tLCBnZnBfbWFzaywgJm1lbSwgdHJ1ZSk7CisJcmV0ID0gX19tZW1fY2dyb3VwX3RyeV9jaGFyZ2UobW0sIGdmcF9tYXNrLCAmbWVtLCBvb20sIHBhZ2Vfc2l6ZSk7CiAJaWYgKHJldCB8fCAhbWVtKQogCQlyZXR1cm4gcmV0OwogCi0JX19tZW1fY2dyb3VwX2NvbW1pdF9jaGFyZ2UobWVtLCBwYywgY3R5cGUpOworCV9fbWVtX2Nncm91cF9jb21taXRfY2hhcmdlKG1lbSwgcGMsIGN0eXBlLCBwYWdlX3NpemUpOwogCXJldHVybiAwOwogfQogCkBAIC0yMjgxLDggKzIzODcsNiBAQAogewogCWlmIChtZW1fY2dyb3VwX2Rpc2FibGVkKCkpCiAJCXJldHVybiAwOwotCWlmIChQYWdlQ29tcG91bmQocGFnZSkpCi0JCXJldHVybiAwOwogCS8qCiAJICogSWYgYWxyZWFkeSBtYXBwZWQsIHdlIGRvbid0IGhhdmUgdG8gYWNjb3VudC4KIAkgKiBJZiBwYWdlIGNhY2hlLCBwYWdlLT5tYXBwaW5nIGhhcyBhZGRyZXNzX3NwYWNlLgpAQCAtMjM4OCwxMyArMjQ5MiwxMyBAQAogCWlmICghbWVtKQogCQlnb3RvIGNoYXJnZV9jdXJfbW07CiAJKnB0ciA9IG1lbTsKLQlyZXQgPSBfX21lbV9jZ3JvdXBfdHJ5X2NoYXJnZShOVUxMLCBtYXNrLCBwdHIsIHRydWUpOworCXJldCA9IF9fbWVtX2Nncm91cF90cnlfY2hhcmdlKE5VTEwsIG1hc2ssIHB0ciwgdHJ1ZSwgUEFHRV9TSVpFKTsKIAljc3NfcHV0KCZtZW0tPmNzcyk7CiAJcmV0dXJuIHJldDsKIGNoYXJnZV9jdXJfbW06CiAJaWYgKHVubGlrZWx5KCFtbSkpCiAJCW1tID0gJmluaXRfbW07Ci0JcmV0dXJuIF9fbWVtX2Nncm91cF90cnlfY2hhcmdlKG1tLCBtYXNrLCBwdHIsIHRydWUpOworCXJldHVybiBfX21lbV9jZ3JvdXBfdHJ5X2NoYXJnZShtbSwgbWFzaywgcHRyLCB0cnVlLCBQQUdFX1NJWkUpOwogfQogCiBzdGF0aWMgdm9pZApAQCAtMjQxMCw3ICsyNTE0LDcgQEAKIAljZ3JvdXBfZXhjbHVkZV9ybWRpcigmcHRyLT5jc3MpOwogCXBjID0gbG9va3VwX3BhZ2VfY2dyb3VwKHBhZ2UpOwogCW1lbV9jZ3JvdXBfbHJ1X2RlbF9iZWZvcmVfY29tbWl0X3N3YXBjYWNoZShwYWdlKTsKLQlfX21lbV9jZ3JvdXBfY29tbWl0X2NoYXJnZShwdHIsIHBjLCBjdHlwZSk7CisJX19tZW1fY2dyb3VwX2NvbW1pdF9jaGFyZ2UocHRyLCBwYywgY3R5cGUsIFBBR0VfU0laRSk7CiAJbWVtX2Nncm91cF9scnVfYWRkX2FmdGVyX2NvbW1pdF9zd2FwY2FjaGUocGFnZSk7CiAJLyoKIAkgKiBOb3cgc3dhcCBpcyBvbi1tZW1vcnkuIFRoaXMgbWVhbnMgdGhpcyBwYWdlIG1heSBiZQpAQCAtMjQ1OSwxMSArMjU2MywxMiBAQAogCQlyZXR1cm47CiAJaWYgKCFtZW0pCiAJCXJldHVybjsKLQltZW1fY2dyb3VwX2NhbmNlbF9jaGFyZ2UobWVtKTsKKwltZW1fY2dyb3VwX2NhbmNlbF9jaGFyZ2UobWVtLCBQQUdFX1NJWkUpOwogfQogCiBzdGF0aWMgdm9pZAotX19kb191bmNoYXJnZShzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtLCBjb25zdCBlbnVtIGNoYXJnZV90eXBlIGN0eXBlKQorX19kb191bmNoYXJnZShzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtLCBjb25zdCBlbnVtIGNoYXJnZV90eXBlIGN0eXBlLAorCSAgICAgIGludCBwYWdlX3NpemUpCiB7CiAJc3RydWN0IG1lbWNnX2JhdGNoX2luZm8gKmJhdGNoID0gTlVMTDsKIAlib29sIHVuY2hhcmdlX21lbXN3ID0gdHJ1ZTsKQEAgLTI0OTAsNiArMjU5NSw5IEBACiAJaWYgKCFiYXRjaC0+ZG9fYmF0Y2ggfHwgdGVzdF90aHJlYWRfZmxhZyhUSUZfTUVNRElFKSkKIAkJZ290byBkaXJlY3RfdW5jaGFyZ2U7CiAKKwlpZiAocGFnZV9zaXplICE9IFBBR0VfU0laRSkKKwkJZ290byBkaXJlY3RfdW5jaGFyZ2U7CisKIAkvKgogCSAqIEluIHR5cGljYWwgY2FzZSwgYmF0Y2gtPm1lbWNnID09IG1lbS4gVGhpcyBtZWFucyB3ZSBjYW4KIAkgKiBtZXJnZSBhIHNlcmllcyBvZiB1bmNoYXJnZXMgdG8gYW4gdW5jaGFyZ2Ugb2YgcmVzX2NvdW50ZXIuCkBAIC0yNTAzLDkgKzI2MTEsOSBAQAogCQliYXRjaC0+bWVtc3dfYnl0ZXMgKz0gUEFHRV9TSVpFOwogCXJldHVybjsKIGRpcmVjdF91bmNoYXJnZToKLQlyZXNfY291bnRlcl91bmNoYXJnZSgmbWVtLT5yZXMsIFBBR0VfU0laRSk7CisJcmVzX2NvdW50ZXJfdW5jaGFyZ2UoJm1lbS0+cmVzLCBwYWdlX3NpemUpOwogCWlmICh1bmNoYXJnZV9tZW1zdykKLQkJcmVzX2NvdW50ZXJfdW5jaGFyZ2UoJm1lbS0+bWVtc3csIFBBR0VfU0laRSk7CisJCXJlc19jb3VudGVyX3VuY2hhcmdlKCZtZW0tPm1lbXN3LCBwYWdlX3NpemUpOwogCWlmICh1bmxpa2VseShiYXRjaC0+bWVtY2cgIT0gbWVtKSkKIAkJbWVtY2dfb29tX3JlY292ZXIobWVtKTsKIAlyZXR1cm47CkBAIC0yNTE3LDggKzI2MjUsMTAgQEAKIHN0YXRpYyBzdHJ1Y3QgbWVtX2Nncm91cCAqCiBfX21lbV9jZ3JvdXBfdW5jaGFyZ2VfY29tbW9uKHN0cnVjdCBwYWdlICpwYWdlLCBlbnVtIGNoYXJnZV90eXBlIGN0eXBlKQogeworCWludCBjb3VudDsKIAlzdHJ1Y3QgcGFnZV9jZ3JvdXAgKnBjOwogCXN0cnVjdCBtZW1fY2dyb3VwICptZW0gPSBOVUxMOworCWludCBwYWdlX3NpemUgPSBQQUdFX1NJWkU7CiAKIAlpZiAobWVtX2Nncm91cF9kaXNhYmxlZCgpKQogCQlyZXR1cm4gTlVMTDsKQEAgLTI1MjYsNiArMjYzNiwxMiBAQAogCWlmIChQYWdlU3dhcENhY2hlKHBhZ2UpKQogCQlyZXR1cm4gTlVMTDsKIAorCWlmIChQYWdlVHJhbnNIdWdlKHBhZ2UpKSB7CisJCXBhZ2Vfc2l6ZSA8PD0gY29tcG91bmRfb3JkZXIocGFnZSk7CisJCVZNX0JVR19PTighUGFnZVRyYW5zSHVnZShwYWdlKSk7CisJfQorCisJY291bnQgPSBwYWdlX3NpemUgPj4gUEFHRV9TSElGVDsKIAkvKgogCSAqIENoZWNrIGlmIG91ciBwYWdlX2Nncm91cCBpcyB2YWxpZAogCSAqLwpAQCAtMjU1OCw3ICsyNjc0LDcgQEAKIAkJYnJlYWs7CiAJfQogCi0JbWVtX2Nncm91cF9jaGFyZ2Vfc3RhdGlzdGljcyhtZW0sIHBjLCBmYWxzZSk7CisJbWVtX2Nncm91cF9jaGFyZ2Vfc3RhdGlzdGljcyhtZW0sIFBhZ2VDZ3JvdXBDYWNoZShwYyksIC1jb3VudCk7CiAKIAlDbGVhclBhZ2VDZ3JvdXBVc2VkKHBjKTsKIAkvKgpAQCAtMjU3OSw3ICsyNjk1LDcgQEAKIAkJbWVtX2Nncm91cF9nZXQobWVtKTsKIAl9CiAJaWYgKCFtZW1fY2dyb3VwX2lzX3Jvb3QobWVtKSkKLQkJX19kb191bmNoYXJnZShtZW0sIGN0eXBlKTsKKwkJX19kb191bmNoYXJnZShtZW0sIGN0eXBlLCBwYWdlX3NpemUpOwogCiAJcmV0dXJuIG1lbTsKIApAQCAtMjc3NCw2ICsyODkwLDcgQEAKIAllbnVtIGNoYXJnZV90eXBlIGN0eXBlOwogCWludCByZXQgPSAwOwogCisJVk1fQlVHX09OKFBhZ2VUcmFuc0h1Z2UocGFnZSkpOwogCWlmIChtZW1fY2dyb3VwX2Rpc2FibGVkKCkpCiAJCXJldHVybiAwOwogCkBAIC0yODIzLDcgKzI5NDAsNyBAQAogCQlyZXR1cm4gMDsKIAogCSpwdHIgPSBtZW07Ci0JcmV0ID0gX19tZW1fY2dyb3VwX3RyeV9jaGFyZ2UoTlVMTCwgR0ZQX0tFUk5FTCwgcHRyLCBmYWxzZSk7CisJcmV0ID0gX19tZW1fY2dyb3VwX3RyeV9jaGFyZ2UoTlVMTCwgR0ZQX0tFUk5FTCwgcHRyLCBmYWxzZSwgUEFHRV9TSVpFKTsKIAljc3NfcHV0KCZtZW0tPmNzcyk7LyogZHJvcCBleHRyYSByZWZjbnQgKi8KIAlpZiAocmV0IHx8ICpwdHIgPT0gTlVMTCkgewogCQlpZiAoUGFnZUFub24ocGFnZSkpIHsKQEAgLTI4NTAsMTMgKzI5NjcsMTMgQEAKIAkJY3R5cGUgPSBNRU1fQ0dST1VQX0NIQVJHRV9UWVBFX0NBQ0hFOwogCWVsc2UKIAkJY3R5cGUgPSBNRU1fQ0dST1VQX0NIQVJHRV9UWVBFX1NITUVNOwotCV9fbWVtX2Nncm91cF9jb21taXRfY2hhcmdlKG1lbSwgcGMsIGN0eXBlKTsKKwlfX21lbV9jZ3JvdXBfY29tbWl0X2NoYXJnZShtZW0sIHBjLCBjdHlwZSwgUEFHRV9TSVpFKTsKIAlyZXR1cm4gcmV0OwogfQogCiAvKiByZW1vdmUgcmVkdW5kYW50IGNoYXJnZSBpZiBtaWdyYXRpb24gZmFpbGVkKi8KIHZvaWQgbWVtX2Nncm91cF9lbmRfbWlncmF0aW9uKHN0cnVjdCBtZW1fY2dyb3VwICptZW0sCi0Jc3RydWN0IHBhZ2UgKm9sZHBhZ2UsIHN0cnVjdCBwYWdlICpuZXdwYWdlKQorCXN0cnVjdCBwYWdlICpvbGRwYWdlLCBzdHJ1Y3QgcGFnZSAqbmV3cGFnZSwgYm9vbCBtaWdyYXRpb25fb2spCiB7CiAJc3RydWN0IHBhZ2UgKnVzZWQsICp1bnVzZWQ7CiAJc3RydWN0IHBhZ2VfY2dyb3VwICpwYzsKQEAgLTI4NjUsOCArMjk4Miw3IEBACiAJCXJldHVybjsKIAkvKiBibG9ja3Mgcm1kaXIoKSAqLwogCWNncm91cF9leGNsdWRlX3JtZGlyKCZtZW0tPmNzcyk7Ci0JLyogYXQgbWlncmF0aW9uIHN1Y2Nlc3MsIG9sZHBhZ2UtPm1hcHBpbmcgaXMgTlVMTC4gKi8KLQlpZiAob2xkcGFnZS0+bWFwcGluZykgeworCWlmICghbWlncmF0aW9uX29rKSB7CiAJCXVzZWQgPSBvbGRwYWdlOwogCQl1bnVzZWQgPSBuZXdwYWdlOwogCX0gZWxzZSB7CkBAIC00MTc2LDEzICs0MjkyLDExIEBACiAJICovCiAJaWYgKCFub2RlX3N0YXRlKG5vZGUsIE5fTk9STUFMX01FTU9SWSkpCiAJCXRtcCA9IC0xOwotCXBuID0ga21hbGxvY19ub2RlKHNpemVvZigqcG4pLCBHRlBfS0VSTkVMLCB0bXApOworCXBuID0ga3phbGxvY19ub2RlKHNpemVvZigqcG4pLCBHRlBfS0VSTkVMLCB0bXApOwogCWlmICghcG4pCiAJCXJldHVybiAxOwogCiAJbWVtLT5pbmZvLm5vZGVpbmZvW25vZGVdID0gcG47Ci0JbWVtc2V0KHBuLCAwLCBzaXplb2YoKnBuKSk7Ci0KIAlmb3IgKHpvbmUgPSAwOyB6b25lIDwgTUFYX05SX1pPTkVTOyB6b25lKyspIHsKIAkJbXogPSAmcG4tPnpvbmVpbmZvW3pvbmVdOwogCQlmb3JfZWFjaF9scnUobCkKQEAgLTQyMDYsMTQgKzQzMjAsMTMgQEAKIAogCS8qIENhbiBiZSB2ZXJ5IGJpZyBpZiBNQVhfTlVNTk9ERVMgaXMgdmVyeSBiaWcgKi8KIAlpZiAoc2l6ZSA8IFBBR0VfU0laRSkKLQkJbWVtID0ga21hbGxvYyhzaXplLCBHRlBfS0VSTkVMKTsKKwkJbWVtID0ga3phbGxvYyhzaXplLCBHRlBfS0VSTkVMKTsKIAllbHNlCi0JCW1lbSA9IHZtYWxsb2Moc2l6ZSk7CisJCW1lbSA9IHZ6YWxsb2Moc2l6ZSk7CiAKIAlpZiAoIW1lbSkKIAkJcmV0dXJuIE5VTEw7CiAKLQltZW1zZXQobWVtLCAwLCBzaXplKTsKIAltZW0tPnN0YXQgPSBhbGxvY19wZXJjcHUoc3RydWN0IG1lbV9jZ3JvdXBfc3RhdF9jcHUpOwogCWlmICghbWVtLT5zdGF0KQogCQlnb3RvIG91dF9mcmVlOwpAQCAtNDQ2MSw3ICs0NTc0LDggQEAKIAkJCWJhdGNoX2NvdW50ID0gUFJFQ0hBUkdFX0NPVU5UX0FUX09OQ0U7CiAJCQljb25kX3Jlc2NoZWQoKTsKIAkJfQotCQlyZXQgPSBfX21lbV9jZ3JvdXBfdHJ5X2NoYXJnZShOVUxMLCBHRlBfS0VSTkVMLCAmbWVtLCBmYWxzZSk7CisJCXJldCA9IF9fbWVtX2Nncm91cF90cnlfY2hhcmdlKE5VTEwsIEdGUF9LRVJORUwsICZtZW0sIGZhbHNlLAorCQkJCQkgICAgICBQQUdFX1NJWkUpOwogCQlpZiAocmV0IHx8ICFtZW0pCiAJCQkvKiBtZW1fY2dyb3VwX2NsZWFyX21jKCkgd2lsbCBkbyB1bmNoYXJnZSBsYXRlciAqLwogCQkJcmV0dXJuIC1FTk9NRU07CkBAIC00NjIzLDYgKzQ3MzcsNyBAQAogCXB0ZV90ICpwdGU7CiAJc3BpbmxvY2tfdCAqcHRsOwogCisJVk1fQlVHX09OKHBtZF90cmFuc19odWdlKCpwbWQpKTsKIAlwdGUgPSBwdGVfb2Zmc2V0X21hcF9sb2NrKHZtYS0+dm1fbW0sIHBtZCwgYWRkciwgJnB0bCk7CiAJZm9yICg7IGFkZHIgIT0gZW5kOyBwdGUrKywgYWRkciArPSBQQUdFX1NJWkUpCiAJCWlmIChpc190YXJnZXRfcHRlX2Zvcl9tYyh2bWEsIGFkZHIsICpwdGUsIE5VTEwpKQpAQCAtNDYzOCw3ICs0NzUzLDcgQEAKIAl1bnNpZ25lZCBsb25nIHByZWNoYXJnZTsKIAlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYTsKIAotCS8qIFdlJ3ZlIGFscmVhZHkgaGVsZCB0aGUgbW1hcF9zZW0gKi8KKwlkb3duX3JlYWQoJm1tLT5tbWFwX3NlbSk7CiAJZm9yICh2bWEgPSBtbS0+bW1hcDsgdm1hOyB2bWEgPSB2bWEtPnZtX25leHQpIHsKIAkJc3RydWN0IG1tX3dhbGsgbWVtX2Nncm91cF9jb3VudF9wcmVjaGFyZ2Vfd2FsayA9IHsKIAkJCS5wbWRfZW50cnkgPSBtZW1fY2dyb3VwX2NvdW50X3ByZWNoYXJnZV9wdGVfcmFuZ2UsCkBAIC00NjUwLDYgKzQ3NjUsNyBAQAogCQl3YWxrX3BhZ2VfcmFuZ2Uodm1hLT52bV9zdGFydCwgdm1hLT52bV9lbmQsCiAJCQkJCSZtZW1fY2dyb3VwX2NvdW50X3ByZWNoYXJnZV93YWxrKTsKIAl9CisJdXBfcmVhZCgmbW0tPm1tYXBfc2VtKTsKIAogCXByZWNoYXJnZSA9IG1jLnByZWNoYXJnZTsKIAltYy5wcmVjaGFyZ2UgPSAwOwpAQCAtNDY1OSwxMCArNDc3NSwxNSBAQAogCiBzdGF0aWMgaW50IG1lbV9jZ3JvdXBfcHJlY2hhcmdlX21jKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQogewotCXJldHVybiBtZW1fY2dyb3VwX2RvX3ByZWNoYXJnZShtZW1fY2dyb3VwX2NvdW50X3ByZWNoYXJnZShtbSkpOworCXVuc2lnbmVkIGxvbmcgcHJlY2hhcmdlID0gbWVtX2Nncm91cF9jb3VudF9wcmVjaGFyZ2UobW0pOworCisJVk1fQlVHX09OKG1jLm1vdmluZ190YXNrKTsKKwltYy5tb3ZpbmdfdGFzayA9IGN1cnJlbnQ7CisJcmV0dXJuIG1lbV9jZ3JvdXBfZG9fcHJlY2hhcmdlKHByZWNoYXJnZSk7CiB9CiAKLXN0YXRpYyB2b2lkIG1lbV9jZ3JvdXBfY2xlYXJfbWModm9pZCkKKy8qIGNhbmNlbHMgYWxsIGV4dHJhIGNoYXJnZXMgb24gbWMuZnJvbSBhbmQgbWMudG8sIGFuZCB3YWtlcyB1cCBhbGwgd2FpdGVycy4gKi8KK3N0YXRpYyB2b2lkIF9fbWVtX2Nncm91cF9jbGVhcl9tYyh2b2lkKQogewogCXN0cnVjdCBtZW1fY2dyb3VwICpmcm9tID0gbWMuZnJvbTsKIAlzdHJ1Y3QgbWVtX2Nncm91cCAqdG8gPSBtYy50bzsKQEAgLTQ2OTcsMjMgKzQ4MTgsMjggQEAKIAkJCQkJCVBBR0VfU0laRSAqIG1jLm1vdmVkX3N3YXApOwogCQl9CiAJCS8qIHdlJ3ZlIGFscmVhZHkgZG9uZSBtZW1fY2dyb3VwX2dldChtYy50bykgKi8KLQogCQltYy5tb3ZlZF9zd2FwID0gMDsKIAl9Ci0JaWYgKG1jLm1tKSB7Ci0JCXVwX3JlYWQoJm1jLm1tLT5tbWFwX3NlbSk7Ci0JCW1tcHV0KG1jLm1tKTsKLQl9CisJbWVtY2dfb29tX3JlY292ZXIoZnJvbSk7CisJbWVtY2dfb29tX3JlY292ZXIodG8pOworCXdha2VfdXBfYWxsKCZtYy53YWl0cSk7Cit9CisKK3N0YXRpYyB2b2lkIG1lbV9jZ3JvdXBfY2xlYXJfbWModm9pZCkKK3sKKwlzdHJ1Y3QgbWVtX2Nncm91cCAqZnJvbSA9IG1jLmZyb207CisKKwkvKgorCSAqIHdlIG11c3QgY2xlYXIgbW92aW5nX3Rhc2sgYmVmb3JlIHdha2luZyB1cCB3YWl0ZXJzIGF0IHRoZSBlbmQgb2YKKwkgKiB0YXNrIG1pZ3JhdGlvbi4KKwkgKi8KKwltYy5tb3ZpbmdfdGFzayA9IE5VTEw7CisJX19tZW1fY2dyb3VwX2NsZWFyX21jKCk7CiAJc3Bpbl9sb2NrKCZtYy5sb2NrKTsKIAltYy5mcm9tID0gTlVMTDsKIAltYy50byA9IE5VTEw7CiAJc3Bpbl91bmxvY2soJm1jLmxvY2spOwotCW1jLm1vdmluZ190YXNrID0gTlVMTDsKLQltYy5tbSA9IE5VTEw7CiAJbWVtX2Nncm91cF9lbmRfbW92ZShmcm9tKTsKLQltZW1jZ19vb21fcmVjb3Zlcihmcm9tKTsKLQltZW1jZ19vb21fcmVjb3Zlcih0byk7Ci0Jd2FrZV91cF9hbGwoJm1jLndhaXRxKTsKIH0KIAogc3RhdGljIGludCBtZW1fY2dyb3VwX2Nhbl9hdHRhY2goc3RydWN0IGNncm91cF9zdWJzeXMgKnNzLApAQCAtNDczNSwzOCArNDg2MSwyMyBAQAogCQkJcmV0dXJuIDA7CiAJCS8qIFdlIG1vdmUgY2hhcmdlcyBvbmx5IHdoZW4gd2UgbW92ZSBhIG93bmVyIG9mIHRoZSBtbSAqLwogCQlpZiAobW0tPm93bmVyID09IHApIHsKLQkJCS8qCi0JCQkgKiBXZSBkbyBhbGwgdGhlIG1vdmUgY2hhcmdlIHdvcmtzIHVuZGVyIG9uZSBtbWFwX3NlbSB0bwotCQkJICogYXZvaWQgZGVhZGxvY2sgd2l0aCBkb3duX3dyaXRlKCZtbWFwX3NlbSkKLQkJCSAqIC0+IHRyeV9jaGFyZ2UoKSAtPiBpZiAobWMubW92aW5nX3Rhc2spIC0+IHNsZWVwLgotCQkJICovCi0JCQlkb3duX3JlYWQoJm1tLT5tbWFwX3NlbSk7Ci0KIAkJCVZNX0JVR19PTihtYy5mcm9tKTsKIAkJCVZNX0JVR19PTihtYy50byk7CiAJCQlWTV9CVUdfT04obWMucHJlY2hhcmdlKTsKIAkJCVZNX0JVR19PTihtYy5tb3ZlZF9jaGFyZ2UpOwogCQkJVk1fQlVHX09OKG1jLm1vdmVkX3N3YXApOwotCQkJVk1fQlVHX09OKG1jLm1vdmluZ190YXNrKTsKLQkJCVZNX0JVR19PTihtYy5tbSk7Ci0KIAkJCW1lbV9jZ3JvdXBfc3RhcnRfbW92ZShmcm9tKTsKIAkJCXNwaW5fbG9jaygmbWMubG9jayk7CiAJCQltYy5mcm9tID0gZnJvbTsKIAkJCW1jLnRvID0gbWVtOwotCQkJbWMucHJlY2hhcmdlID0gMDsKLQkJCW1jLm1vdmVkX2NoYXJnZSA9IDA7Ci0JCQltYy5tb3ZlZF9zd2FwID0gMDsKIAkJCXNwaW5fdW5sb2NrKCZtYy5sb2NrKTsKLQkJCW1jLm1vdmluZ190YXNrID0gY3VycmVudDsKLQkJCW1jLm1tID0gbW07CisJCQkvKiBXZSBzZXQgbWMubW92aW5nX3Rhc2sgbGF0ZXIgKi8KIAogCQkJcmV0ID0gbWVtX2Nncm91cF9wcmVjaGFyZ2VfbWMobW0pOwogCQkJaWYgKHJldCkKIAkJCQltZW1fY2dyb3VwX2NsZWFyX21jKCk7Ci0JCQkvKiBXZSBjYWxsIHVwX3JlYWQoKSBhbmQgbW1wdXQoKSBpbiBjbGVhcl9tYygpLiAqLwotCQl9IGVsc2UKLQkJCW1tcHV0KG1tKTsKKwkJfQorCQltbXB1dChtbSk7CiAJfQogCXJldHVybiByZXQ7CiB9CkBAIC00Nzg5LDYgKzQ5MDAsNyBAQAogCXNwaW5sb2NrX3QgKnB0bDsKIAogcmV0cnk6CisJVk1fQlVHX09OKHBtZF90cmFuc19odWdlKCpwbWQpKTsKIAlwdGUgPSBwdGVfb2Zmc2V0X21hcF9sb2NrKHZtYS0+dm1fbW0sIHBtZCwgYWRkciwgJnB0bCk7CiAJZm9yICg7IGFkZHIgIT0gZW5kOyBhZGRyICs9IFBBR0VfU0laRSkgewogCQlwdGVfdCBwdGVudCA9ICoocHRlKyspOwpAQCAtNDgwOSw3ICs0OTIxLDcgQEAKIAkJCQlnb3RvIHB1dDsKIAkJCXBjID0gbG9va3VwX3BhZ2VfY2dyb3VwKHBhZ2UpOwogCQkJaWYgKCFtZW1fY2dyb3VwX21vdmVfYWNjb3VudChwYywKLQkJCQkJCW1jLmZyb20sIG1jLnRvLCBmYWxzZSkpIHsKKwkJCQkJbWMuZnJvbSwgbWMudG8sIGZhbHNlLCBQQUdFX1NJWkUpKSB7CiAJCQkJbWMucHJlY2hhcmdlLS07CiAJCQkJLyogd2UgdW5jaGFyZ2UgZnJvbSBtYy5mcm9tIGxhdGVyLiAqLwogCQkJCW1jLm1vdmVkX2NoYXJnZSsrOwpAQCAtNDg1NCw3ICs0OTY2LDE5IEBACiAJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWE7CiAKIAlscnVfYWRkX2RyYWluX2FsbCgpOwotCS8qIFdlJ3ZlIGFscmVhZHkgaGVsZCB0aGUgbW1hcF9zZW0gKi8KK3JldHJ5OgorCWlmICh1bmxpa2VseSghZG93bl9yZWFkX3RyeWxvY2soJm1tLT5tbWFwX3NlbSkpKSB7CisJCS8qCisJCSAqIFNvbWVvbmUgd2hvIGFyZSBob2xkaW5nIHRoZSBtbWFwX3NlbSBtaWdodCBiZSB3YWl0aW5nIGluCisJCSAqIHdhaXRxLiBTbyB3ZSBjYW5jZWwgYWxsIGV4dHJhIGNoYXJnZXMsIHdha2UgdXAgYWxsIHdhaXRlcnMsCisJCSAqIGFuZCByZXRyeS4gQmVjYXVzZSB3ZSBjYW5jZWwgcHJlY2hhcmdlcywgd2UgbWlnaHQgbm90IGJlIGFibGUKKwkJICogdG8gbW92ZSBlbm91Z2ggY2hhcmdlcywgYnV0IG1vdmluZyBjaGFyZ2UgaXMgYSBiZXN0LWVmZm9ydAorCQkgKiBmZWF0dXJlIGFueXdheSwgc28gaXQgd291bGRuJ3QgYmUgYSBiaWcgcHJvYmxlbS4KKwkJICovCisJCV9fbWVtX2Nncm91cF9jbGVhcl9tYygpOworCQljb25kX3Jlc2NoZWQoKTsKKwkJZ290byByZXRyeTsKKwl9CiAJZm9yICh2bWEgPSBtbS0+bW1hcDsgdm1hOyB2bWEgPSB2bWEtPnZtX25leHQpIHsKIAkJaW50IHJldDsKIAkJc3RydWN0IG1tX3dhbGsgbWVtX2Nncm91cF9tb3ZlX2NoYXJnZV93YWxrID0gewpAQCAtNDg3Myw2ICs0OTk3LDcgQEAKIAkJCSAqLwogCQkJYnJlYWs7CiAJfQorCXVwX3JlYWQoJm1tLT5tbWFwX3NlbSk7CiB9CiAKIHN0YXRpYyB2b2lkIG1lbV9jZ3JvdXBfbW92ZV90YXNrKHN0cnVjdCBjZ3JvdXBfc3Vic3lzICpzcywKQEAgLTQ4ODEsMTEgKzUwMDYsMTcgQEAKIAkJCQlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAsCiAJCQkJYm9vbCB0aHJlYWRncm91cCkKIHsKLQlpZiAoIW1jLm1tKQorCXN0cnVjdCBtbV9zdHJ1Y3QgKm1tOworCisJaWYgKCFtYy50bykKIAkJLyogbm8gbmVlZCB0byBtb3ZlIGNoYXJnZSAqLwogCQlyZXR1cm47CiAKLQltZW1fY2dyb3VwX21vdmVfY2hhcmdlKG1jLm1tKTsKKwltbSA9IGdldF90YXNrX21tKHApOworCWlmIChtbSkgeworCQltZW1fY2dyb3VwX21vdmVfY2hhcmdlKG1tKTsKKwkJbW1wdXQobW0pOworCX0KIAltZW1fY2dyb3VwX2NsZWFyX21jKCk7CiB9CiAjZWxzZQkvKiAhQ09ORklHX01NVSAqLwpAQCAtNDkyOSw5ICs1MDYwLDkgQEAKIHN0YXRpYyBpbnQgX19pbml0IGVuYWJsZV9zd2FwX2FjY291bnQoY2hhciAqcykKIHsKIAkvKiBjb25zaWRlciBlbmFibGVkIGlmIG5vIHBhcmFtZXRlciBvciAxIGlzIGdpdmVuICovCi0JaWYgKCFzIHx8ICFzdHJjbXAocywgIjEiKSkKKwlpZiAoISgqcykgfHwgIXN0cmNtcChzLCAiPTEiKSkKIAkJcmVhbGx5X2RvX3N3YXBfYWNjb3VudCA9IDE7Ci0JZWxzZSBpZiAoIXN0cmNtcChzLCAiMCIpKQorCWVsc2UgaWYgKCFzdHJjbXAocywgIj0wIikpCiAJCXJlYWxseV9kb19zd2FwX2FjY291bnQgPSAwOwogCXJldHVybiAxOwogfQpAQCAtNDkzOSw3ICs1MDcwLDggQEAKIAogc3RhdGljIGludCBfX2luaXQgZGlzYWJsZV9zd2FwX2FjY291bnQoY2hhciAqcykKIHsKLQllbmFibGVfc3dhcF9hY2NvdW50KCIwIik7CisJcHJpbnRrX29uY2UoIm5vc3dhcGFjY291bnQgaXMgZGVwcmVjYXRlZCBhbmQgd2lsbCBiZSByZW1vdmVkIGluIDIuNi40MC4gVXNlIHN3YXBhY2NvdW50PTAgaW5zdGVhZFxuIik7CisJZW5hYmxlX3N3YXBfYWNjb3VudCgiPTAiKTsKIAlyZXR1cm4gMTsKIH0KIF9fc2V0dXAoIm5vc3dhcGFjY291bnQiLCBkaXNhYmxlX3N3YXBfYWNjb3VudCk7CmRpZmYgLS1naXQgYS9tbS9tZW1vcnktZmFpbHVyZS5jIGIvbW0vbWVtb3J5LWZhaWx1cmUuYwppbmRleCA0NmFiMmMwLi4wMjA3YzJmIDEwMDY0NAotLS0gYS9tbS9tZW1vcnktZmFpbHVyZS5jCisrKyBiL21tL21lbW9yeS1mYWlsdXJlLmMKQEAgLTIwMyw3ICsyMDMsNyBAQAogI2lmZGVmIF9fQVJDSF9TSV9UUkFQTk8KIAlzaS5zaV90cmFwbm8gPSB0cmFwbm87CiAjZW5kaWYKLQlzaS5zaV9hZGRyX2xzYiA9IGNvbXBvdW5kX29yZGVyKGNvbXBvdW5kX2hlYWQocGFnZSkpICsgUEFHRV9TSElGVDsKKwlzaS5zaV9hZGRyX2xzYiA9IGNvbXBvdW5kX3RyYW5zX29yZGVyKGNvbXBvdW5kX2hlYWQocGFnZSkpICsgUEFHRV9TSElGVDsKIAkvKgogCSAqIERvbid0IHVzZSBmb3JjZSBoZXJlLCBpdCdzIGNvbnZlbmllbnQgaWYgdGhlIHNpZ25hbAogCSAqIGNhbiBiZSB0ZW1wb3JhcmlseSBibG9ja2VkLgpAQCAtMjMzLDggKzIzMyw4IEBACiAJfQogCiAJLyoKLQkgKiBPbmx5IGFsbCBzaHJpbmtfc2xhYiBoZXJlICh3aGljaCB3b3VsZCBhbHNvCi0JICogc2hyaW5rIG90aGVyIGNhY2hlcykgaWYgYWNjZXNzIGlzIG5vdCBwb3RlbnRpYWxseSBmYXRhbC4KKwkgKiBPbmx5IGNhbGwgc2hyaW5rX3NsYWIgaGVyZSAod2hpY2ggd291bGQgYWxzbyBzaHJpbmsgb3RoZXIgY2FjaGVzKSBpZgorCSAqIGFjY2VzcyBpcyBub3QgcG90ZW50aWFsbHkgZmF0YWwuCiAJICovCiAJaWYgKGFjY2VzcykgewogCQlpbnQgbnI7CkBAIC04NTQsNiArODU0LDcgQEAKIAlpbnQgcmV0OwogCWludCBraWxsID0gMTsKIAlzdHJ1Y3QgcGFnZSAqaHBhZ2UgPSBjb21wb3VuZF9oZWFkKHApOworCXN0cnVjdCBwYWdlICpwcGFnZTsKIAogCWlmIChQYWdlUmVzZXJ2ZWQocCkgfHwgUGFnZVNsYWIocCkpCiAJCXJldHVybiBTV0FQX1NVQ0NFU1M7CkBAIC04OTUsNiArODk2LDQ0IEBACiAJfQogCiAJLyoKKwkgKiBwcGFnZTogcG9pc29uZWQgcGFnZQorCSAqICAgaWYgcCBpcyByZWd1bGFyIHBhZ2UoNGsgcGFnZSkKKwkgKiAgICAgICAgcHBhZ2UgPT0gcmVhbCBwb2lzb25lZCBwYWdlOworCSAqICAgZWxzZSBwIGlzIGh1Z2V0bGIgb3IgVEhQLCBwcGFnZSA9PSBoZWFkIHBhZ2UuCisJICovCisJcHBhZ2UgPSBocGFnZTsKKworCWlmIChQYWdlVHJhbnNIdWdlKGhwYWdlKSkgeworCQkvKgorCQkgKiBWZXJpZnkgdGhhdCB0aGlzIGlzbid0IGEgaHVnZXRsYmZzIGhlYWQgcGFnZSwgdGhlIGNoZWNrIGZvcgorCQkgKiBQYWdlQW5vbiBpcyBqdXN0IGZvciBhdm9pZCB0cmlwcGluZyBhIHNwbGl0X2h1Z2VfcGFnZQorCQkgKiBpbnRlcm5hbCBkZWJ1ZyBjaGVjaywgYXMgc3BsaXRfaHVnZV9wYWdlIHJlZnVzZXMgdG8gZGVhbCB3aXRoCisJCSAqIGFueXRoaW5nIHRoYXQgaXNuJ3QgYW4gYW5vbiBwYWdlLiBQYWdlQW5vbiBjYW4ndCBnbyBhd2F5IGZybworCQkgKiB1bmRlciB1cyBiZWNhdXNlIHdlIGhvbGQgYSByZWZjb3VudCBvbiB0aGUgaHBhZ2UsIHdpdGhvdXQgYQorCQkgKiByZWZjb3VudCBvbiB0aGUgaHBhZ2UuIHNwbGl0X2h1Z2VfcGFnZSBjYW4ndCBiZSBzYWZlbHkgY2FsbGVkCisJCSAqIGluIHRoZSBmaXJzdCBwbGFjZSwgaGF2aW5nIGEgcmVmY291bnQgb24gdGhlIHRhaWwgaXNuJ3QKKwkJICogZW5vdWdoICogdG8gYmUgc2FmZS4KKwkJICovCisJCWlmICghUGFnZUh1Z2UoaHBhZ2UpICYmIFBhZ2VBbm9uKGhwYWdlKSkgeworCQkJaWYgKHVubGlrZWx5KHNwbGl0X2h1Z2VfcGFnZShocGFnZSkpKSB7CisJCQkJLyoKKwkJCQkgKiBGSVhNRTogaWYgc3BsaXR0aW5nIFRIUCBpcyBmYWlsZWQsIGl0IGlzCisJCQkJICogYmV0dGVyIHRvIHN0b3AgdGhlIGZvbGxvd2luZyBvcGVyYXRpb24gcmF0aGVyCisJCQkJICogdGhhbiBjYXVzaW5nIHBhbmljIGJ5IHVubWFwcGluZy4gU3lzdGVtIG1pZ2h0CisJCQkJICogc3Vydml2ZSBpZiB0aGUgcGFnZSBpcyBmcmVlZCBsYXRlci4KKwkJCQkgKi8KKwkJCQlwcmludGsoS0VSTl9JTkZPCisJCQkJCSJNQ0UgJSNseDogZmFpbGVkIHRvIHNwbGl0IFRIUFxuIiwgcGZuKTsKKworCQkJCUJVR19PTighUGFnZUhXUG9pc29uKHApKTsKKwkJCQlyZXR1cm4gU1dBUF9GQUlMOworCQkJfQorCQkJLyogVEhQIGlzIHNwbGl0LCBzbyBwcGFnZSBzaG91bGQgYmUgdGhlIHJlYWwgcG9pc29uZWQgcGFnZS4gKi8KKwkJCXBwYWdlID0gcDsKKwkJfQorCX0KKworCS8qCiAJICogRmlyc3QgY29sbGVjdCBhbGwgdGhlIHByb2Nlc3NlcyB0aGF0IGhhdmUgdGhlIHBhZ2UKIAkgKiBtYXBwZWQgaW4gZGlydHkgZm9ybS4gIFRoaXMgaGFzIHRvIGJlIGRvbmUgYmVmb3JlIHRyeV90b191bm1hcCwKIAkgKiBiZWNhdXNlIHR0dSB0YWtlcyB0aGUgcm1hcCBkYXRhIHN0cnVjdHVyZXMgZG93bi4KQEAgLTkwMywxMiArOTQyLDE4IEBACiAJICogdGhlcmUncyBub3RoaW5nIHRoYXQgY2FuIGJlIGRvbmUuCiAJICovCiAJaWYgKGtpbGwpCi0JCWNvbGxlY3RfcHJvY3MoaHBhZ2UsICZ0b2tpbGwpOworCQljb2xsZWN0X3Byb2NzKHBwYWdlLCAmdG9raWxsKTsKIAotCXJldCA9IHRyeV90b191bm1hcChocGFnZSwgdHR1KTsKKwlpZiAoaHBhZ2UgIT0gcHBhZ2UpCisJCWxvY2tfcGFnZV9ub3N5bmMocHBhZ2UpOworCisJcmV0ID0gdHJ5X3RvX3VubWFwKHBwYWdlLCB0dHUpOwogCWlmIChyZXQgIT0gU1dBUF9TVUNDRVNTKQogCQlwcmludGsoS0VSTl9FUlIgIk1DRSAlI2x4OiBmYWlsZWQgdG8gdW5tYXAgcGFnZSAobWFwY291bnQ9JWQpXG4iLAotCQkJCXBmbiwgcGFnZV9tYXBjb3VudChocGFnZSkpOworCQkJCXBmbiwgcGFnZV9tYXBjb3VudChwcGFnZSkpOworCisJaWYgKGhwYWdlICE9IHBwYWdlKQorCQl1bmxvY2tfcGFnZShwcGFnZSk7CiAKIAkvKgogCSAqIE5vdyB0aGF0IHRoZSBkaXJ0eSBiaXQgaGFzIGJlZW4gcHJvcGFnYXRlZCB0byB0aGUKQEAgLTkxOSw3ICs5NjQsNyBAQAogCSAqIHVzZSBhIG1vcmUgZm9yY2UtZnVsbCB1bmNhdGNoYWJsZSBraWxsIHRvIHByZXZlbnQKIAkgKiBhbnkgYWNjZXNzZXMgdG8gdGhlIHBvaXNvbmVkIG1lbW9yeS4KIAkgKi8KLQlraWxsX3Byb2NzX2FvKCZ0b2tpbGwsICEhUGFnZURpcnR5KGhwYWdlKSwgdHJhcG5vLAorCWtpbGxfcHJvY3NfYW8oJnRva2lsbCwgISFQYWdlRGlydHkocHBhZ2UpLCB0cmFwbm8sCiAJCSAgICAgIHJldCAhPSBTV0FQX1NVQ0NFU1MsIHAsIHBmbik7CiAKIAlyZXR1cm4gcmV0OwpAQCAtOTI4LDcgKzk3Myw3IEBACiBzdGF0aWMgdm9pZCBzZXRfcGFnZV9od3BvaXNvbl9odWdlX3BhZ2Uoc3RydWN0IHBhZ2UgKmhwYWdlKQogewogCWludCBpOwotCWludCBucl9wYWdlcyA9IDEgPDwgY29tcG91bmRfb3JkZXIoaHBhZ2UpOworCWludCBucl9wYWdlcyA9IDEgPDwgY29tcG91bmRfdHJhbnNfb3JkZXIoaHBhZ2UpOwogCWZvciAoaSA9IDA7IGkgPCBucl9wYWdlczsgaSsrKQogCQlTZXRQYWdlSFdQb2lzb24oaHBhZ2UgKyBpKTsKIH0KQEAgLTkzNiw3ICs5ODEsNyBAQAogc3RhdGljIHZvaWQgY2xlYXJfcGFnZV9od3BvaXNvbl9odWdlX3BhZ2Uoc3RydWN0IHBhZ2UgKmhwYWdlKQogewogCWludCBpOwotCWludCBucl9wYWdlcyA9IDEgPDwgY29tcG91bmRfb3JkZXIoaHBhZ2UpOworCWludCBucl9wYWdlcyA9IDEgPDwgY29tcG91bmRfdHJhbnNfb3JkZXIoaHBhZ2UpOwogCWZvciAoaSA9IDA7IGkgPCBucl9wYWdlczsgaSsrKQogCQlDbGVhclBhZ2VIV1BvaXNvbihocGFnZSArIGkpOwogfQpAQCAtOTY2LDcgKzEwMTEsNyBAQAogCQlyZXR1cm4gMDsKIAl9CiAKLQlucl9wYWdlcyA9IDEgPDwgY29tcG91bmRfb3JkZXIoaHBhZ2UpOworCW5yX3BhZ2VzID0gMSA8PCBjb21wb3VuZF90cmFuc19vcmRlcihocGFnZSk7CiAJYXRvbWljX2xvbmdfYWRkKG5yX3BhZ2VzLCAmbWNlX2JhZF9wYWdlcyk7CiAKIAkvKgpAQCAtMTAyMCwxOSArMTA2NSwyMiBAQAogCSAqIFRoZSBjaGVjayAodW5uZWNlc3NhcmlseSkgaWdub3JlcyBMUlUgcGFnZXMgYmVpbmcgaXNvbGF0ZWQgYW5kCiAJICogd2Fsa2VkIGJ5IHRoZSBwYWdlIHJlY2xhaW0gY29kZSwgaG93ZXZlciB0aGF0J3Mgbm90IGEgYmlnIGxvc3MuCiAJICovCi0JaWYgKCFQYWdlTFJVKHApICYmICFQYWdlSHVnZShwKSkKLQkJc2hha2VfcGFnZShwLCAwKTsKLQlpZiAoIVBhZ2VMUlUocCkgJiYgIVBhZ2VIdWdlKHApKSB7Ci0JCS8qCi0JCSAqIHNoYWtlX3BhZ2UgY291bGQgaGF2ZSB0dXJuZWQgaXQgZnJlZS4KLQkJICovCi0JCWlmIChpc19mcmVlX2J1ZGR5X3BhZ2UocCkpIHsKLQkJCWFjdGlvbl9yZXN1bHQocGZuLCAiZnJlZSBidWRkeSwgMm5kIHRyeSIsIERFTEFZRUQpOwotCQkJcmV0dXJuIDA7CisJaWYgKCFQYWdlSHVnZShwKSAmJiAhUGFnZVRyYW5zQ29tcG91bmQocCkpIHsKKwkJaWYgKCFQYWdlTFJVKHApKQorCQkJc2hha2VfcGFnZShwLCAwKTsKKwkJaWYgKCFQYWdlTFJVKHApKSB7CisJCQkvKgorCQkJICogc2hha2VfcGFnZSBjb3VsZCBoYXZlIHR1cm5lZCBpdCBmcmVlLgorCQkJICovCisJCQlpZiAoaXNfZnJlZV9idWRkeV9wYWdlKHApKSB7CisJCQkJYWN0aW9uX3Jlc3VsdChwZm4sICJmcmVlIGJ1ZGR5LCAybmQgdHJ5IiwKKwkJCQkJCURFTEFZRUQpOworCQkJCXJldHVybiAwOworCQkJfQorCQkJYWN0aW9uX3Jlc3VsdChwZm4sICJub24gTFJVIiwgSUdOT1JFRCk7CisJCQlwdXRfcGFnZShwKTsKKwkJCXJldHVybiAtRUJVU1k7CiAJCX0KLQkJYWN0aW9uX3Jlc3VsdChwZm4sICJub24gTFJVIiwgSUdOT1JFRCk7Ci0JCXB1dF9wYWdlKHApOwotCQlyZXR1cm4gLUVCVVNZOwogCX0KIAogCS8qCkBAIC0xMDYyLDcgKzExMTAsNyBAQAogCSAqIEZvciBlcnJvciBvbiB0aGUgdGFpbCBwYWdlLCB3ZSBzaG91bGQgc2V0IFBHX2h3cG9pc29uCiAJICogb24gdGhlIGhlYWQgcGFnZSB0byBzaG93IHRoYXQgdGhlIGh1Z2VwYWdlIGlzIGh3cG9pc29uZWQKIAkgKi8KLQlpZiAoUGFnZVRhaWwocCkgJiYgVGVzdFNldFBhZ2VIV1BvaXNvbihocGFnZSkpIHsKKwlpZiAoUGFnZUh1Z2UocCkgJiYgUGFnZVRhaWwocCkgJiYgVGVzdFNldFBhZ2VIV1BvaXNvbihocGFnZSkpIHsKIAkJYWN0aW9uX3Jlc3VsdChwZm4sICJodWdlcGFnZSBhbHJlYWR5IGhhcmR3YXJlIHBvaXNvbmVkIiwKIAkJCQlJR05PUkVEKTsKIAkJdW5sb2NrX3BhZ2UoaHBhZ2UpOwpAQCAtMTE2NCw3ICsxMjEyLDcgQEAKIAkJcmV0dXJuIDA7CiAJfQogCi0JbnJfcGFnZXMgPSAxIDw8IGNvbXBvdW5kX29yZGVyKHBhZ2UpOworCW5yX3BhZ2VzID0gMSA8PCBjb21wb3VuZF90cmFuc19vcmRlcihwYWdlKTsKIAogCWlmICghZ2V0X3BhZ2VfdW5sZXNzX3plcm8ocGFnZSkpIHsKIAkJLyoKQEAgLTEyOTAsOSArMTMzOCwxMyBAQAogCS8qIEtlZXAgcGFnZSBjb3VudCB0byBpbmRpY2F0ZSBhIGdpdmVuIGh1Z2VwYWdlIGlzIGlzb2xhdGVkLiAqLwogCiAJbGlzdF9hZGQoJmhwYWdlLT5scnUsICZwYWdlbGlzdCk7Ci0JcmV0ID0gbWlncmF0ZV9odWdlX3BhZ2VzKCZwYWdlbGlzdCwgbmV3X3BhZ2UsIE1QT0xfTUZfTU9WRV9BTEwsIDApOworCXJldCA9IG1pZ3JhdGVfaHVnZV9wYWdlcygmcGFnZWxpc3QsIG5ld19wYWdlLCBNUE9MX01GX01PVkVfQUxMLCAwLAorCQkJCXRydWUpOwogCWlmIChyZXQpIHsKLQkJCXB1dGJhY2tfbHJ1X3BhZ2VzKCZwYWdlbGlzdCk7CisJCXN0cnVjdCBwYWdlICpwYWdlMSwgKnBhZ2UyOworCQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocGFnZTEsIHBhZ2UyLCAmcGFnZWxpc3QsIGxydSkKKwkJCXB1dF9wYWdlKHBhZ2UxKTsKKwogCQlwcl9kZWJ1Zygic29mdCBvZmZsaW5lOiAlI2x4OiBtaWdyYXRpb24gZmFpbGVkICVkLCB0eXBlICVseFxuIiwKIAkJCSBwZm4sIHJldCwgcGFnZS0+ZmxhZ3MpOwogCQlpZiAocmV0ID4gMCkKQEAgLTEzMDEsNyArMTM1Myw3IEBACiAJfQogZG9uZToKIAlpZiAoIVBhZ2VIV1BvaXNvbihocGFnZSkpCi0JCWF0b21pY19sb25nX2FkZCgxIDw8IGNvbXBvdW5kX29yZGVyKGhwYWdlKSwgJm1jZV9iYWRfcGFnZXMpOworCQlhdG9taWNfbG9uZ19hZGQoMSA8PCBjb21wb3VuZF90cmFuc19vcmRlcihocGFnZSksICZtY2VfYmFkX3BhZ2VzKTsKIAlzZXRfcGFnZV9od3BvaXNvbl9odWdlX3BhZ2UoaHBhZ2UpOwogCWRlcXVldWVfaHdwb2lzb25lZF9odWdlX3BhZ2UoaHBhZ2UpOwogCS8qIGtlZXAgZWxldmF0ZWQgcGFnZSBjb3VudCBmb3IgYmFkIHBhZ2UgKi8KQEAgLTE0MTMsOCArMTQ2NSwxMCBAQAogCQlMSVNUX0hFQUQocGFnZWxpc3QpOwogCiAJCWxpc3RfYWRkKCZwYWdlLT5scnUsICZwYWdlbGlzdCk7Ci0JCXJldCA9IG1pZ3JhdGVfcGFnZXMoJnBhZ2VsaXN0LCBuZXdfcGFnZSwgTVBPTF9NRl9NT1ZFX0FMTCwgMCk7CisJCXJldCA9IG1pZ3JhdGVfcGFnZXMoJnBhZ2VsaXN0LCBuZXdfcGFnZSwgTVBPTF9NRl9NT1ZFX0FMTCwKKwkJCQkJCQkJMCwgdHJ1ZSk7CiAJCWlmIChyZXQpIHsKKwkJCXB1dGJhY2tfbHJ1X3BhZ2VzKCZwYWdlbGlzdCk7CiAJCQlwcl9pbmZvKCJzb2Z0IG9mZmxpbmU6ICUjbHg6IG1pZ3JhdGlvbiBmYWlsZWQgJWQsIHR5cGUgJWx4XG4iLAogCQkJCXBmbiwgcmV0LCBwYWdlLT5mbGFncyk7CiAJCQlpZiAocmV0ID4gMCkKZGlmZiAtLWdpdCBhL21tL21lbW9yeS5jIGIvbW0vbWVtb3J5LmMKaW5kZXggMDJlNDhhYS4uOGU4YzE4MzIgMTAwNjQ0Ci0tLSBhL21tL21lbW9yeS5jCisrKyBiL21tL21lbW9yeS5jCkBAIC0zOTQsOSArMzk0LDExIEBACiAJfQogfQogCi1pbnQgX19wdGVfYWxsb2Moc3RydWN0IG1tX3N0cnVjdCAqbW0sIHBtZF90ICpwbWQsIHVuc2lnbmVkIGxvbmcgYWRkcmVzcykKK2ludCBfX3B0ZV9hbGxvYyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCXBtZF90ICpwbWQsIHVuc2lnbmVkIGxvbmcgYWRkcmVzcykKIHsKIAlwZ3RhYmxlX3QgbmV3ID0gcHRlX2FsbG9jX29uZShtbSwgYWRkcmVzcyk7CisJaW50IHdhaXRfc3BsaXRfaHVnZV9wYWdlOwogCWlmICghbmV3KQogCQlyZXR1cm4gLUVOT01FTTsKIApAQCAtNDE2LDE0ICs0MTgsMTggQEAKIAlzbXBfd21iKCk7IC8qIENvdWxkIGJlIHNtcF93bWJfX3h4eChiZWZvcmV8YWZ0ZXIpX3NwaW5fbG9jayAqLwogCiAJc3Bpbl9sb2NrKCZtbS0+cGFnZV90YWJsZV9sb2NrKTsKLQlpZiAoIXBtZF9wcmVzZW50KCpwbWQpKSB7CS8qIEhhcyBhbm90aGVyIHBvcHVsYXRlZCBpdCA/ICovCisJd2FpdF9zcGxpdF9odWdlX3BhZ2UgPSAwOworCWlmIChsaWtlbHkocG1kX25vbmUoKnBtZCkpKSB7CS8qIEhhcyBhbm90aGVyIHBvcHVsYXRlZCBpdCA/ICovCiAJCW1tLT5ucl9wdGVzKys7CiAJCXBtZF9wb3B1bGF0ZShtbSwgcG1kLCBuZXcpOwogCQluZXcgPSBOVUxMOwotCX0KKwl9IGVsc2UgaWYgKHVubGlrZWx5KHBtZF90cmFuc19zcGxpdHRpbmcoKnBtZCkpKQorCQl3YWl0X3NwbGl0X2h1Z2VfcGFnZSA9IDE7CiAJc3Bpbl91bmxvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOwogCWlmIChuZXcpCiAJCXB0ZV9mcmVlKG1tLCBuZXcpOworCWlmICh3YWl0X3NwbGl0X2h1Z2VfcGFnZSkKKwkJd2FpdF9zcGxpdF9odWdlX3BhZ2Uodm1hLT5hbm9uX3ZtYSwgcG1kKTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtNDM2LDEwICs0NDIsMTEgQEAKIAlzbXBfd21iKCk7IC8qIFNlZSBjb21tZW50IGluIF9fcHRlX2FsbG9jICovCiAKIAlzcGluX2xvY2soJmluaXRfbW0ucGFnZV90YWJsZV9sb2NrKTsKLQlpZiAoIXBtZF9wcmVzZW50KCpwbWQpKSB7CS8qIEhhcyBhbm90aGVyIHBvcHVsYXRlZCBpdCA/ICovCisJaWYgKGxpa2VseShwbWRfbm9uZSgqcG1kKSkpIHsJLyogSGFzIGFub3RoZXIgcG9wdWxhdGVkIGl0ID8gKi8KIAkJcG1kX3BvcHVsYXRlX2tlcm5lbCgmaW5pdF9tbSwgcG1kLCBuZXcpOwogCQluZXcgPSBOVUxMOwotCX0KKwl9IGVsc2UKKwkJVk1fQlVHX09OKHBtZF90cmFuc19zcGxpdHRpbmcoKnBtZCkpOwogCXNwaW5fdW5sb2NrKCZpbml0X21tLnBhZ2VfdGFibGVfbG9jayk7CiAJaWYgKG5ldykKIAkJcHRlX2ZyZWVfa2VybmVsKCZpbml0X21tLCBuZXcpOwpAQCAtNzE5LDkgKzcyNiw5IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgY29weV9wdGVfcmFuZ2Uoc3RydWN0IG1tX3N0cnVjdCAqZHN0X21tLCBzdHJ1Y3QgbW1fc3RydWN0ICpzcmNfbW0sCi0JCXBtZF90ICpkc3RfcG1kLCBwbWRfdCAqc3JjX3BtZCwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCi0JCXVuc2lnbmVkIGxvbmcgYWRkciwgdW5zaWduZWQgbG9uZyBlbmQpCitpbnQgY29weV9wdGVfcmFuZ2Uoc3RydWN0IG1tX3N0cnVjdCAqZHN0X21tLCBzdHJ1Y3QgbW1fc3RydWN0ICpzcmNfbW0sCisJCSAgIHBtZF90ICpkc3RfcG1kLCBwbWRfdCAqc3JjX3BtZCwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCSAgIHVuc2lnbmVkIGxvbmcgYWRkciwgdW5zaWduZWQgbG9uZyBlbmQpCiB7CiAJcHRlX3QgKm9yaWdfc3JjX3B0ZSwgKm9yaWdfZHN0X3B0ZTsKIAlwdGVfdCAqc3JjX3B0ZSwgKmRzdF9wdGU7CkBAIC03OTUsNiArODAyLDE3IEBACiAJc3JjX3BtZCA9IHBtZF9vZmZzZXQoc3JjX3B1ZCwgYWRkcik7CiAJZG8gewogCQluZXh0ID0gcG1kX2FkZHJfZW5kKGFkZHIsIGVuZCk7CisJCWlmIChwbWRfdHJhbnNfaHVnZSgqc3JjX3BtZCkpIHsKKwkJCWludCBlcnI7CisJCQlWTV9CVUdfT04obmV4dC1hZGRyICE9IEhQQUdFX1BNRF9TSVpFKTsKKwkJCWVyciA9IGNvcHlfaHVnZV9wbWQoZHN0X21tLCBzcmNfbW0sCisJCQkJCSAgICBkc3RfcG1kLCBzcmNfcG1kLCBhZGRyLCB2bWEpOworCQkJaWYgKGVyciA9PSAtRU5PTUVNKQorCQkJCXJldHVybiAtRU5PTUVNOworCQkJaWYgKCFlcnIpCisJCQkJY29udGludWU7CisJCQkvKiBmYWxsIHRocm91Z2ggKi8KKwkJfQogCQlpZiAocG1kX25vbmVfb3JfY2xlYXJfYmFkKHNyY19wbWQpKQogCQkJY29udGludWU7CiAJCWlmIChjb3B5X3B0ZV9yYW5nZShkc3RfbW0sIHNyY19tbSwgZHN0X3BtZCwgc3JjX3BtZCwKQEAgLTk5Nyw2ICsxMDE1LDE2IEBACiAJcG1kID0gcG1kX29mZnNldChwdWQsIGFkZHIpOwogCWRvIHsKIAkJbmV4dCA9IHBtZF9hZGRyX2VuZChhZGRyLCBlbmQpOworCQlpZiAocG1kX3RyYW5zX2h1Z2UoKnBtZCkpIHsKKwkJCWlmIChuZXh0LWFkZHIgIT0gSFBBR0VfUE1EX1NJWkUpIHsKKwkJCQlWTV9CVUdfT04oIXJ3c2VtX2lzX2xvY2tlZCgmdGxiLT5tbS0+bW1hcF9zZW0pKTsKKwkJCQlzcGxpdF9odWdlX3BhZ2VfcG1kKHZtYS0+dm1fbW0sIHBtZCk7CisJCQl9IGVsc2UgaWYgKHphcF9odWdlX3BtZCh0bGIsIHZtYSwgcG1kKSkgeworCQkJCSgqemFwX3dvcmspLS07CisJCQkJY29udGludWU7CisJCQl9CisJCQkvKiBmYWxsIHRocm91Z2ggKi8KKwkJfQogCQlpZiAocG1kX25vbmVfb3JfY2xlYXJfYmFkKHBtZCkpIHsKIAkJCSgqemFwX3dvcmspLS07CiAJCQljb250aW51ZTsKQEAgLTEyNjIsNyArMTI5MCw3IEBACiAJcHVkID0gcHVkX29mZnNldChwZ2QsIGFkZHJlc3MpOwogCWlmIChwdWRfbm9uZSgqcHVkKSkKIAkJZ290byBub19wYWdlX3RhYmxlOwotCWlmIChwdWRfaHVnZSgqcHVkKSkgeworCWlmIChwdWRfaHVnZSgqcHVkKSAmJiB2bWEtPnZtX2ZsYWdzICYgVk1fSFVHRVRMQikgewogCQlCVUdfT04oZmxhZ3MgJiBGT0xMX0dFVCk7CiAJCXBhZ2UgPSBmb2xsb3dfaHVnZV9wdWQobW0sIGFkZHJlc3MsIHB1ZCwgZmxhZ3MgJiBGT0xMX1dSSVRFKTsKIAkJZ290byBvdXQ7CkBAIC0xMjczLDExICsxMzAxLDMyIEBACiAJcG1kID0gcG1kX29mZnNldChwdWQsIGFkZHJlc3MpOwogCWlmIChwbWRfbm9uZSgqcG1kKSkKIAkJZ290byBub19wYWdlX3RhYmxlOwotCWlmIChwbWRfaHVnZSgqcG1kKSkgeworCWlmIChwbWRfaHVnZSgqcG1kKSAmJiB2bWEtPnZtX2ZsYWdzICYgVk1fSFVHRVRMQikgewogCQlCVUdfT04oZmxhZ3MgJiBGT0xMX0dFVCk7CiAJCXBhZ2UgPSBmb2xsb3dfaHVnZV9wbWQobW0sIGFkZHJlc3MsIHBtZCwgZmxhZ3MgJiBGT0xMX1dSSVRFKTsKIAkJZ290byBvdXQ7CiAJfQorCWlmIChwbWRfdHJhbnNfaHVnZSgqcG1kKSkgeworCQlpZiAoZmxhZ3MgJiBGT0xMX1NQTElUKSB7CisJCQlzcGxpdF9odWdlX3BhZ2VfcG1kKG1tLCBwbWQpOworCQkJZ290byBzcGxpdF9mYWxsdGhyb3VnaDsKKwkJfQorCQlzcGluX2xvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCQlpZiAobGlrZWx5KHBtZF90cmFuc19odWdlKCpwbWQpKSkgeworCQkJaWYgKHVubGlrZWx5KHBtZF90cmFuc19zcGxpdHRpbmcoKnBtZCkpKSB7CisJCQkJc3Bpbl91bmxvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCQkJCXdhaXRfc3BsaXRfaHVnZV9wYWdlKHZtYS0+YW5vbl92bWEsIHBtZCk7CisJCQl9IGVsc2UgeworCQkJCXBhZ2UgPSBmb2xsb3dfdHJhbnNfaHVnZV9wbWQobW0sIGFkZHJlc3MsCisJCQkJCQkJICAgICBwbWQsIGZsYWdzKTsKKwkJCQlzcGluX3VubG9jaygmbW0tPnBhZ2VfdGFibGVfbG9jayk7CisJCQkJZ290byBvdXQ7CisJCQl9CisJCX0gZWxzZQorCQkJc3Bpbl91bmxvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCQkvKiBmYWxsIHRocm91Z2ggKi8KKwl9CitzcGxpdF9mYWxsdGhyb3VnaDoKIAlpZiAodW5saWtlbHkocG1kX2JhZCgqcG1kKSkpCiAJCWdvdG8gbm9fcGFnZV90YWJsZTsKIApAQCAtMTMxMCw2ICsxMzU5LDI4IEBACiAJCSAqLwogCQltYXJrX3BhZ2VfYWNjZXNzZWQocGFnZSk7CiAJfQorCWlmIChmbGFncyAmIEZPTExfTUxPQ0spIHsKKwkJLyoKKwkJICogVGhlIHByZWxpbWluYXJ5IG1hcHBpbmcgY2hlY2sgaXMgbWFpbmx5IHRvIGF2b2lkIHRoZQorCQkgKiBwb2ludGxlc3Mgb3ZlcmhlYWQgb2YgbG9ja19wYWdlIG9uIHRoZSBaRVJPX1BBR0UKKwkJICogd2hpY2ggbWlnaHQgYm91bmNlIHZlcnkgYmFkbHkgaWYgdGhlcmUgaXMgY29udGVudGlvbi4KKwkJICoKKwkJICogSWYgdGhlIHBhZ2UgaXMgYWxyZWFkeSBsb2NrZWQsIHdlIGRvbid0IG5lZWQgdG8KKwkJICogaGFuZGxlIGl0IG5vdyAtIHZtc2NhbiB3aWxsIGhhbmRsZSBpdCBsYXRlciBpZiBhbmQKKwkJICogd2hlbiBpdCBhdHRlbXB0cyB0byByZWNsYWltIHRoZSBwYWdlLgorCQkgKi8KKwkJaWYgKHBhZ2UtPm1hcHBpbmcgJiYgdHJ5bG9ja19wYWdlKHBhZ2UpKSB7CisJCQlscnVfYWRkX2RyYWluKCk7ICAvKiBwdXNoIGNhY2hlZCBwYWdlcyB0byBMUlUgKi8KKwkJCS8qCisJCQkgKiBCZWNhdXNlIHdlIGxvY2sgcGFnZSBoZXJlIGFuZCBtaWdyYXRpb24gaXMKKwkJCSAqIGJsb2NrZWQgYnkgdGhlIHB0ZSdzIHBhZ2UgcmVmZXJlbmNlLCB3ZSBuZWVkCisJCQkgKiBvbmx5IGNoZWNrIGZvciBmaWxlLWNhY2hlIHBhZ2UgdHJ1bmNhdGlvbi4KKwkJCSAqLworCQkJaWYgKHBhZ2UtPm1hcHBpbmcpCisJCQkJbWxvY2tfdm1hX3BhZ2UocGFnZSk7CisJCQl1bmxvY2tfcGFnZShwYWdlKTsKKwkJfQorCX0KIHVubG9jazoKIAlwdGVfdW5tYXBfdW5sb2NrKHB0ZXAsIHB0bCk7CiBvdXQ6CkBAIC0xMzQxLDcgKzE0MTIsOCBAQAogCiBpbnQgX19nZXRfdXNlcl9wYWdlcyhzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzaywgc3RydWN0IG1tX3N0cnVjdCAqbW0sCiAJCSAgICAgdW5zaWduZWQgbG9uZyBzdGFydCwgaW50IG5yX3BhZ2VzLCB1bnNpZ25lZCBpbnQgZ3VwX2ZsYWdzLAotCQkgICAgIHN0cnVjdCBwYWdlICoqcGFnZXMsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqKnZtYXMpCisJCSAgICAgc3RydWN0IHBhZ2UgKipwYWdlcywgc3RydWN0IHZtX2FyZWFfc3RydWN0ICoqdm1hcywKKwkJICAgICBpbnQgKm5vbmJsb2NraW5nKQogewogCWludCBpOwogCXVuc2lnbmVkIGxvbmcgdm1fZmxhZ3M7CkBAIC0xMzg2LDYgKzE0NTgsNyBAQAogCQkJcG1kID0gcG1kX29mZnNldChwdWQsIHBnKTsKIAkJCWlmIChwbWRfbm9uZSgqcG1kKSkKIAkJCQlyZXR1cm4gaSA/IDogLUVGQVVMVDsKKwkJCVZNX0JVR19PTihwbWRfdHJhbnNfaHVnZSgqcG1kKSk7CiAJCQlwdGUgPSBwdGVfb2Zmc2V0X21hcChwbWQsIHBnKTsKIAkJCWlmIChwdGVfbm9uZSgqcHRlKSkgewogCQkJCXB0ZV91bm1hcChwdGUpOwpAQCAtMTQ0MSwxMCArMTUxNCwxNSBAQAogCQkJY29uZF9yZXNjaGVkKCk7CiAJCQl3aGlsZSAoIShwYWdlID0gZm9sbG93X3BhZ2Uodm1hLCBzdGFydCwgZm9sbF9mbGFncykpKSB7CiAJCQkJaW50IHJldDsKKwkJCQl1bnNpZ25lZCBpbnQgZmF1bHRfZmxhZ3MgPSAwOworCisJCQkJaWYgKGZvbGxfZmxhZ3MgJiBGT0xMX1dSSVRFKQorCQkJCQlmYXVsdF9mbGFncyB8PSBGQVVMVF9GTEFHX1dSSVRFOworCQkJCWlmIChub25ibG9ja2luZykKKwkJCQkJZmF1bHRfZmxhZ3MgfD0gRkFVTFRfRkxBR19BTExPV19SRVRSWTsKIAogCQkJCXJldCA9IGhhbmRsZV9tbV9mYXVsdChtbSwgdm1hLCBzdGFydCwKLQkJCQkJKGZvbGxfZmxhZ3MgJiBGT0xMX1dSSVRFKSA/Ci0JCQkJCUZBVUxUX0ZMQUdfV1JJVEUgOiAwKTsKKwkJCQkJCQlmYXVsdF9mbGFncyk7CiAKIAkJCQlpZiAocmV0ICYgVk1fRkFVTFRfRVJST1IpIHsKIAkJCQkJaWYgKHJldCAmIFZNX0ZBVUxUX09PTSkKQEAgLTE0NjAsNiArMTUzOCwxMSBAQAogCQkJCWVsc2UKIAkJCQkJdHNrLT5taW5fZmx0Kys7CiAKKwkJCQlpZiAocmV0ICYgVk1fRkFVTFRfUkVUUlkpIHsKKwkJCQkJKm5vbmJsb2NraW5nID0gMDsKKwkJCQkJcmV0dXJuIGk7CisJCQkJfQorCiAJCQkJLyoKIAkJCQkgKiBUaGUgVk1fRkFVTFRfV1JJVEUgYml0IHRlbGxzIHVzIHRoYXQKIAkJCQkgKiBkb193cF9wYWdlIGhhcyBicm9rZW4gQ09XIHdoZW4gbmVjZXNzYXJ5LApAQCAtMTU1OSw3ICsxNjQyLDggQEAKIAlpZiAoZm9yY2UpCiAJCWZsYWdzIHw9IEZPTExfRk9SQ0U7CiAKLQlyZXR1cm4gX19nZXRfdXNlcl9wYWdlcyh0c2ssIG1tLCBzdGFydCwgbnJfcGFnZXMsIGZsYWdzLCBwYWdlcywgdm1hcyk7CisJcmV0dXJuIF9fZ2V0X3VzZXJfcGFnZXModHNrLCBtbSwgc3RhcnQsIG5yX3BhZ2VzLCBmbGFncywgcGFnZXMsIHZtYXMsCisJCQkJTlVMTCk7CiB9CiBFWFBPUlRfU1lNQk9MKGdldF91c2VyX3BhZ2VzKTsKIApAQCAtMTU4NCw3ICsxNjY4LDggQEAKIAlzdHJ1Y3QgcGFnZSAqcGFnZTsKIAogCWlmIChfX2dldF91c2VyX3BhZ2VzKGN1cnJlbnQsIGN1cnJlbnQtPm1tLCBhZGRyLCAxLAotCQkJRk9MTF9GT1JDRSB8IEZPTExfRFVNUCB8IEZPTExfR0VULCAmcGFnZSwgJnZtYSkgPCAxKQorCQkJICAgICBGT0xMX0ZPUkNFIHwgRk9MTF9EVU1QIHwgRk9MTF9HRVQsICZwYWdlLCAmdm1hLAorCQkJICAgICBOVUxMKSA8IDEpCiAJCXJldHVybiBOVUxMOwogCWZsdXNoX2NhY2hlX3BhZ2Uodm1hLCBhZGRyLCBwYWdlX3RvX3BmbihwYWdlKSk7CiAJcmV0dXJuIHBhZ2U7CkBAIC0xNTk4LDggKzE2ODMsMTAgQEAKIAlwdWRfdCAqIHB1ZCA9IHB1ZF9hbGxvYyhtbSwgcGdkLCBhZGRyKTsKIAlpZiAocHVkKSB7CiAJCXBtZF90ICogcG1kID0gcG1kX2FsbG9jKG1tLCBwdWQsIGFkZHIpOwotCQlpZiAocG1kKQorCQlpZiAocG1kKSB7CisJCQlWTV9CVUdfT04ocG1kX3RyYW5zX2h1Z2UoKnBtZCkpOwogCQkJcmV0dXJuIHB0ZV9hbGxvY19tYXBfbG9jayhtbSwgcG1kLCBhZGRyLCBwdGwpOworCQl9CiAJfQogCXJldHVybiBOVUxMOwogfQpAQCAtMTgxOCw2ICsxOTA1LDcgQEAKIAlwbWQgPSBwbWRfYWxsb2MobW0sIHB1ZCwgYWRkcik7CiAJaWYgKCFwbWQpCiAJCXJldHVybiAtRU5PTUVNOworCVZNX0JVR19PTihwbWRfdHJhbnNfaHVnZSgqcG1kKSk7CiAJZG8gewogCQluZXh0ID0gcG1kX2FkZHJfZW5kKGFkZHIsIGVuZCk7CiAJCWlmIChyZW1hcF9wdGVfcmFuZ2UobW0sIHBtZCwgYWRkciwgbmV4dCwKQEAgLTIwNDgsMTkgKzIxMzYsNiBAQAogCXJldHVybiBzYW1lOwogfQogCi0vKgotICogRG8gcHRlX21rd3JpdGUsIGJ1dCBvbmx5IGlmIHRoZSB2bWEgc2F5cyBWTV9XUklURS4gIFdlIGRvIHRoaXMgd2hlbgotICogc2VydmljaW5nIGZhdWx0cyBmb3Igd3JpdGUgYWNjZXNzLiAgSW4gdGhlIG5vcm1hbCBjYXNlLCBkbyBhbHdheXMgd2FudAotICogcHRlX21rd3JpdGUuICBCdXQgZ2V0X3VzZXJfcGFnZXMgY2FuIGNhdXNlIHdyaXRlIGZhdWx0cyBmb3IgbWFwcGluZ3MKLSAqIHRoYXQgZG8gbm90IGhhdmUgd3JpdGluZyBlbmFibGVkLCB3aGVuIHVzZWQgYnkgYWNjZXNzX3Byb2Nlc3Nfdm0uCi0gKi8KLXN0YXRpYyBpbmxpbmUgcHRlX3QgbWF5YmVfbWt3cml0ZShwdGVfdCBwdGUsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQotewotCWlmIChsaWtlbHkodm1hLT52bV9mbGFncyAmIFZNX1dSSVRFKSkKLQkJcHRlID0gcHRlX21rd3JpdGUocHRlKTsKLQlyZXR1cm4gcHRlOwotfQotCiBzdGF0aWMgaW5saW5lIHZvaWQgY293X3VzZXJfcGFnZShzdHJ1Y3QgcGFnZSAqZHN0LCBzdHJ1Y3QgcGFnZSAqc3JjLCB1bnNpZ25lZCBsb25nIHZhLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKIHsKIAkvKgpAQCAtMjExMiw3ICsyMTg3LDcgQEAKIHsKIAlzdHJ1Y3QgcGFnZSAqb2xkX3BhZ2UsICpuZXdfcGFnZTsKIAlwdGVfdCBlbnRyeTsKLQlpbnQgcmV1c2UgPSAwLCByZXQgPSAwOworCWludCByZXQgPSAwOwogCWludCBwYWdlX21rd3JpdGUgPSAwOwogCXN0cnVjdCBwYWdlICpkaXJ0eV9wYWdlID0gTlVMTDsKIApAQCAtMjE0NCwxOSArMjIxOSwyMCBAQAogCQkJCQkJCSAmcHRsKTsKIAkJCWlmICghcHRlX3NhbWUoKnBhZ2VfdGFibGUsIG9yaWdfcHRlKSkgewogCQkJCXVubG9ja19wYWdlKG9sZF9wYWdlKTsKLQkJCQlwYWdlX2NhY2hlX3JlbGVhc2Uob2xkX3BhZ2UpOwogCQkJCWdvdG8gdW5sb2NrOwogCQkJfQogCQkJcGFnZV9jYWNoZV9yZWxlYXNlKG9sZF9wYWdlKTsKIAkJfQotCQlyZXVzZSA9IHJldXNlX3N3YXBfcGFnZShvbGRfcGFnZSk7Ci0JCWlmIChyZXVzZSkKKwkJaWYgKHJldXNlX3N3YXBfcGFnZShvbGRfcGFnZSkpIHsKIAkJCS8qCiAJCQkgKiBUaGUgcGFnZSBpcyBhbGwgb3Vycy4gIE1vdmUgaXQgdG8gb3VyIGFub25fdm1hIHNvCiAJCQkgKiB0aGUgcm1hcCBjb2RlIHdpbGwgbm90IHNlYXJjaCBvdXIgcGFyZW50IG9yIHNpYmxpbmdzLgogCQkJICogUHJvdGVjdGVkIGFnYWluc3QgdGhlIHJtYXAgY29kZSBieSB0aGUgcGFnZSBsb2NrLgogCQkJICovCiAJCQlwYWdlX21vdmVfYW5vbl9ybWFwKG9sZF9wYWdlLCB2bWEsIGFkZHJlc3MpOworCQkJdW5sb2NrX3BhZ2Uob2xkX3BhZ2UpOworCQkJZ290byByZXVzZTsKKwkJfQogCQl1bmxvY2tfcGFnZShvbGRfcGFnZSk7CiAJfSBlbHNlIGlmICh1bmxpa2VseSgodm1hLT52bV9mbGFncyAmIChWTV9XUklURXxWTV9TSEFSRUQpKSA9PQogCQkJCQkoVk1fV1JJVEV8Vk1fU0hBUkVEKSkpIHsKQEAgLTIyMTIsNyArMjI4OCw2IEBACiAJCQkJCQkJICZwdGwpOwogCQkJaWYgKCFwdGVfc2FtZSgqcGFnZV90YWJsZSwgb3JpZ19wdGUpKSB7CiAJCQkJdW5sb2NrX3BhZ2Uob2xkX3BhZ2UpOwotCQkJCXBhZ2VfY2FjaGVfcmVsZWFzZShvbGRfcGFnZSk7CiAJCQkJZ290byB1bmxvY2s7CiAJCQl9CiAKQEAgLTIyMjAsMTggKzIyOTUsNTIgQEAKIAkJfQogCQlkaXJ0eV9wYWdlID0gb2xkX3BhZ2U7CiAJCWdldF9wYWdlKGRpcnR5X3BhZ2UpOwotCQlyZXVzZSA9IDE7Ci0JfQogCi0JaWYgKHJldXNlKSB7CiByZXVzZToKIAkJZmx1c2hfY2FjaGVfcGFnZSh2bWEsIGFkZHJlc3MsIHB0ZV9wZm4ob3JpZ19wdGUpKTsKIAkJZW50cnkgPSBwdGVfbWt5b3VuZyhvcmlnX3B0ZSk7CiAJCWVudHJ5ID0gbWF5YmVfbWt3cml0ZShwdGVfbWtkaXJ0eShlbnRyeSksIHZtYSk7CiAJCWlmIChwdGVwX3NldF9hY2Nlc3NfZmxhZ3Modm1hLCBhZGRyZXNzLCBwYWdlX3RhYmxlLCBlbnRyeSwxKSkKIAkJCXVwZGF0ZV9tbXVfY2FjaGUodm1hLCBhZGRyZXNzLCBwYWdlX3RhYmxlKTsKKwkJcHRlX3VubWFwX3VubG9jayhwYWdlX3RhYmxlLCBwdGwpOwogCQlyZXQgfD0gVk1fRkFVTFRfV1JJVEU7Ci0JCWdvdG8gdW5sb2NrOworCisJCWlmICghZGlydHlfcGFnZSkKKwkJCXJldHVybiByZXQ7CisKKwkJLyoKKwkJICogWWVzLCBWaXJnaW5pYSwgdGhpcyBpcyBhY3R1YWxseSByZXF1aXJlZCB0byBwcmV2ZW50IGEgcmFjZQorCQkgKiB3aXRoIGNsZWFyX3BhZ2VfZGlydHlfZm9yX2lvKCkgZnJvbSBjbGVhcmluZyB0aGUgcGFnZSBkaXJ0eQorCQkgKiBiaXQgYWZ0ZXIgaXQgY2xlYXIgYWxsIGRpcnR5IHB0ZXMsIGJ1dCBiZWZvcmUgYSByYWNpbmcKKwkJICogZG9fd3BfcGFnZSBpbnN0YWxscyBhIGRpcnR5IHB0ZS4KKwkJICoKKwkJICogZG9fbm9fcGFnZSBpcyBwcm90ZWN0ZWQgc2ltaWxhcmx5LgorCQkgKi8KKwkJaWYgKCFwYWdlX21rd3JpdGUpIHsKKwkJCXdhaXRfb25fcGFnZV9sb2NrZWQoZGlydHlfcGFnZSk7CisJCQlzZXRfcGFnZV9kaXJ0eV9iYWxhbmNlKGRpcnR5X3BhZ2UsIHBhZ2VfbWt3cml0ZSk7CisJCX0KKwkJcHV0X3BhZ2UoZGlydHlfcGFnZSk7CisJCWlmIChwYWdlX21rd3JpdGUpIHsKKwkJCXN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nID0gZGlydHlfcGFnZS0+bWFwcGluZzsKKworCQkJc2V0X3BhZ2VfZGlydHkoZGlydHlfcGFnZSk7CisJCQl1bmxvY2tfcGFnZShkaXJ0eV9wYWdlKTsKKwkJCXBhZ2VfY2FjaGVfcmVsZWFzZShkaXJ0eV9wYWdlKTsKKwkJCWlmIChtYXBwaW5nKQl7CisJCQkJLyoKKwkJCQkgKiBTb21lIGRldmljZSBkcml2ZXJzIGRvIG5vdCBzZXQgcGFnZS5tYXBwaW5nCisJCQkJICogYnV0IHN0aWxsIGRpcnR5IHRoZWlyIHBhZ2VzCisJCQkJICovCisJCQkJYmFsYW5jZV9kaXJ0eV9wYWdlc19yYXRlbGltaXRlZChtYXBwaW5nKTsKKwkJCX0KKwkJfQorCisJCS8qIGZpbGVfdXBkYXRlX3RpbWUgb3V0c2lkZSBwYWdlX2xvY2sgKi8KKwkJaWYgKHZtYS0+dm1fZmlsZSkKKwkJCWZpbGVfdXBkYXRlX3RpbWUodm1hLT52bV9maWxlKTsKKworCQlyZXR1cm4gcmV0OwogCX0KIAogCS8qCkBAIC0yMjU2LDE2ICsyMzY1LDYgQEAKIAl9CiAJX19TZXRQYWdlVXB0b2RhdGUobmV3X3BhZ2UpOwogCi0JLyoKLQkgKiBEb24ndCBsZXQgYW5vdGhlciB0YXNrLCB3aXRoIHBvc3NpYmx5IHVubG9ja2VkIHZtYSwKLQkgKiBrZWVwIHRoZSBtbG9ja2VkIHBhZ2UuCi0JICovCi0JaWYgKCh2bWEtPnZtX2ZsYWdzICYgVk1fTE9DS0VEKSAmJiBvbGRfcGFnZSkgewotCQlsb2NrX3BhZ2Uob2xkX3BhZ2UpOwkvKiBmb3IgTFJVIG1hbmlwdWxhdGlvbiAqLwotCQljbGVhcl9wYWdlX21sb2NrKG9sZF9wYWdlKTsKLQkJdW5sb2NrX3BhZ2Uob2xkX3BhZ2UpOwotCX0KLQogCWlmIChtZW1fY2dyb3VwX25ld3BhZ2VfY2hhcmdlKG5ld19wYWdlLCBtbSwgR0ZQX0tFUk5FTCkpCiAJCWdvdG8gb29tX2ZyZWVfbmV3OwogCkBAIC0yMzMzLDQyICsyNDMyLDE5IEBACiAKIAlpZiAobmV3X3BhZ2UpCiAJCXBhZ2VfY2FjaGVfcmVsZWFzZShuZXdfcGFnZSk7Ci0JaWYgKG9sZF9wYWdlKQotCQlwYWdlX2NhY2hlX3JlbGVhc2Uob2xkX3BhZ2UpOwogdW5sb2NrOgogCXB0ZV91bm1hcF91bmxvY2socGFnZV90YWJsZSwgcHRsKTsKLQlpZiAoZGlydHlfcGFnZSkgeworCWlmIChvbGRfcGFnZSkgewogCQkvKgotCQkgKiBZZXMsIFZpcmdpbmlhLCB0aGlzIGlzIGFjdHVhbGx5IHJlcXVpcmVkIHRvIHByZXZlbnQgYSByYWNlCi0JCSAqIHdpdGggY2xlYXJfcGFnZV9kaXJ0eV9mb3JfaW8oKSBmcm9tIGNsZWFyaW5nIHRoZSBwYWdlIGRpcnR5Ci0JCSAqIGJpdCBhZnRlciBpdCBjbGVhciBhbGwgZGlydHkgcHRlcywgYnV0IGJlZm9yZSBhIHJhY2luZwotCQkgKiBkb193cF9wYWdlIGluc3RhbGxzIGEgZGlydHkgcHRlLgotCQkgKgotCQkgKiBkb19ub19wYWdlIGlzIHByb3RlY3RlZCBzaW1pbGFybHkuCisJCSAqIERvbid0IGxldCBhbm90aGVyIHRhc2ssIHdpdGggcG9zc2libHkgdW5sb2NrZWQgdm1hLAorCQkgKiBrZWVwIHRoZSBtbG9ja2VkIHBhZ2UuCiAJCSAqLwotCQlpZiAoIXBhZ2VfbWt3cml0ZSkgewotCQkJd2FpdF9vbl9wYWdlX2xvY2tlZChkaXJ0eV9wYWdlKTsKLQkJCXNldF9wYWdlX2RpcnR5X2JhbGFuY2UoZGlydHlfcGFnZSwgcGFnZV9ta3dyaXRlKTsKKwkJaWYgKChyZXQgJiBWTV9GQVVMVF9XUklURSkgJiYgKHZtYS0+dm1fZmxhZ3MgJiBWTV9MT0NLRUQpKSB7CisJCQlsb2NrX3BhZ2Uob2xkX3BhZ2UpOwkvKiBMUlUgbWFuaXB1bGF0aW9uICovCisJCQltdW5sb2NrX3ZtYV9wYWdlKG9sZF9wYWdlKTsKKwkJCXVubG9ja19wYWdlKG9sZF9wYWdlKTsKIAkJfQotCQlwdXRfcGFnZShkaXJ0eV9wYWdlKTsKLQkJaWYgKHBhZ2VfbWt3cml0ZSkgewotCQkJc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmcgPSBkaXJ0eV9wYWdlLT5tYXBwaW5nOwotCi0JCQlzZXRfcGFnZV9kaXJ0eShkaXJ0eV9wYWdlKTsKLQkJCXVubG9ja19wYWdlKGRpcnR5X3BhZ2UpOwotCQkJcGFnZV9jYWNoZV9yZWxlYXNlKGRpcnR5X3BhZ2UpOwotCQkJaWYgKG1hcHBpbmcpCXsKLQkJCQkvKgotCQkJCSAqIFNvbWUgZGV2aWNlIGRyaXZlcnMgZG8gbm90IHNldCBwYWdlLm1hcHBpbmcKLQkJCQkgKiBidXQgc3RpbGwgZGlydHkgdGhlaXIgcGFnZXMKLQkJCQkgKi8KLQkJCQliYWxhbmNlX2RpcnR5X3BhZ2VzX3JhdGVsaW1pdGVkKG1hcHBpbmcpOwotCQkJfQotCQl9Ci0KLQkJLyogZmlsZV91cGRhdGVfdGltZSBvdXRzaWRlIHBhZ2VfbG9jayAqLwotCQlpZiAodm1hLT52bV9maWxlKQotCQkJZmlsZV91cGRhdGVfdGltZSh2bWEtPnZtX2ZpbGUpOworCQlwYWdlX2NhY2hlX3JlbGVhc2Uob2xkX3BhZ2UpOwogCX0KIAlyZXR1cm4gcmV0Owogb29tX2ZyZWVfbmV3OgpAQCAtMjk3NSwxMiArMzA1MSw2IEBACiAJCQkJZ290byBvdXQ7CiAJCQl9CiAJCQljaGFyZ2VkID0gMTsKLQkJCS8qCi0JCQkgKiBEb24ndCBsZXQgYW5vdGhlciB0YXNrLCB3aXRoIHBvc3NpYmx5IHVubG9ja2VkIHZtYSwKLQkJCSAqIGtlZXAgdGhlIG1sb2NrZWQgcGFnZS4KLQkJCSAqLwotCQkJaWYgKHZtYS0+dm1fZmxhZ3MgJiBWTV9MT0NLRUQpCi0JCQkJY2xlYXJfcGFnZV9tbG9jayh2bWYucGFnZSk7CiAJCQljb3B5X3VzZXJfaGlnaHBhZ2UocGFnZSwgdm1mLnBhZ2UsIGFkZHJlc3MsIHZtYSk7CiAJCQlfX1NldFBhZ2VVcHRvZGF0ZShwYWdlKTsKIAkJfSBlbHNlIHsKQEAgLTMxNDcsOSArMzIxNyw5IEBACiAgKiBidXQgYWxsb3cgY29uY3VycmVudCBmYXVsdHMpLCBhbmQgcHRlIG1hcHBlZCBidXQgbm90IHlldCBsb2NrZWQuCiAgKiBXZSByZXR1cm4gd2l0aCBtbWFwX3NlbSBzdGlsbCBoZWxkLCBidXQgcHRlIHVubWFwcGVkIGFuZCB1bmxvY2tlZC4KICAqLwotc3RhdGljIGlubGluZSBpbnQgaGFuZGxlX3B0ZV9mYXVsdChzdHJ1Y3QgbW1fc3RydWN0ICptbSwKLQkJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywKLQkJcHRlX3QgKnB0ZSwgcG1kX3QgKnBtZCwgdW5zaWduZWQgaW50IGZsYWdzKQoraW50IGhhbmRsZV9wdGVfZmF1bHQoc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCSAgICAgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywKKwkJICAgICBwdGVfdCAqcHRlLCBwbWRfdCAqcG1kLCB1bnNpZ25lZCBpbnQgZmxhZ3MpCiB7CiAJcHRlX3QgZW50cnk7CiAJc3BpbmxvY2tfdCAqcHRsOwpAQCAtMzIyOCw5ICszMjk4LDQwIEBACiAJcG1kID0gcG1kX2FsbG9jKG1tLCBwdWQsIGFkZHJlc3MpOwogCWlmICghcG1kKQogCQlyZXR1cm4gVk1fRkFVTFRfT09NOwotCXB0ZSA9IHB0ZV9hbGxvY19tYXAobW0sIHBtZCwgYWRkcmVzcyk7Ci0JaWYgKCFwdGUpCisJaWYgKHBtZF9ub25lKCpwbWQpICYmIHRyYW5zcGFyZW50X2h1Z2VwYWdlX2VuYWJsZWQodm1hKSkgeworCQlpZiAoIXZtYS0+dm1fb3BzKQorCQkJcmV0dXJuIGRvX2h1Z2VfcG1kX2Fub255bW91c19wYWdlKG1tLCB2bWEsIGFkZHJlc3MsCisJCQkJCQkJICBwbWQsIGZsYWdzKTsKKwl9IGVsc2UgeworCQlwbWRfdCBvcmlnX3BtZCA9ICpwbWQ7CisJCWJhcnJpZXIoKTsKKwkJaWYgKHBtZF90cmFuc19odWdlKG9yaWdfcG1kKSkgeworCQkJaWYgKGZsYWdzICYgRkFVTFRfRkxBR19XUklURSAmJgorCQkJICAgICFwbWRfd3JpdGUob3JpZ19wbWQpICYmCisJCQkgICAgIXBtZF90cmFuc19zcGxpdHRpbmcob3JpZ19wbWQpKQorCQkJCXJldHVybiBkb19odWdlX3BtZF93cF9wYWdlKG1tLCB2bWEsIGFkZHJlc3MsCisJCQkJCQkJICAgcG1kLCBvcmlnX3BtZCk7CisJCQlyZXR1cm4gMDsKKwkJfQorCX0KKworCS8qCisJICogVXNlIF9fcHRlX2FsbG9jIGluc3RlYWQgb2YgcHRlX2FsbG9jX21hcCwgYmVjYXVzZSB3ZSBjYW4ndAorCSAqIHJ1biBwdGVfb2Zmc2V0X21hcCBvbiB0aGUgcG1kLCBpZiBhbiBodWdlIHBtZCBjb3VsZAorCSAqIG1hdGVyaWFsaXplIGZyb20gdW5kZXIgdXMgZnJvbSBhIGRpZmZlcmVudCB0aHJlYWQuCisJICovCisJaWYgKHVubGlrZWx5KF9fcHRlX2FsbG9jKG1tLCB2bWEsIHBtZCwgYWRkcmVzcykpKQogCQlyZXR1cm4gVk1fRkFVTFRfT09NOworCS8qIGlmIGFuIGh1Z2UgcG1kIG1hdGVyaWFsaXplZCBmcm9tIHVuZGVyIHVzIGp1c3QgcmV0cnkgbGF0ZXIgKi8KKwlpZiAodW5saWtlbHkocG1kX3RyYW5zX2h1Z2UoKnBtZCkpKQorCQlyZXR1cm4gMDsKKwkvKgorCSAqIEEgcmVndWxhciBwbWQgaXMgZXN0YWJsaXNoZWQgYW5kIGl0IGNhbid0IG1vcnBoIGludG8gYSBodWdlIHBtZAorCSAqIGZyb20gdW5kZXIgdXMgYW55bW9yZSBhdCB0aGlzIHBvaW50IGJlY2F1c2Ugd2UgaG9sZCB0aGUgbW1hcF9zZW0KKwkgKiByZWFkIG1vZGUgYW5kIGtodWdlcGFnZWQgdGFrZXMgaXQgaW4gd3JpdGUgbW9kZS4gU28gbm93IGl0J3MKKwkgKiBzYWZlIHRvIHJ1biBwdGVfb2Zmc2V0X21hcCgpLgorCSAqLworCXB0ZSA9IHB0ZV9vZmZzZXRfbWFwKHBtZCwgYWRkcmVzcyk7CiAKIAlyZXR1cm4gaGFuZGxlX3B0ZV9mYXVsdChtbSwgdm1hLCBhZGRyZXNzLCBwdGUsIHBtZCwgZmxhZ3MpOwogfQpAQCAtMzI5Niw3ICszMzk3LDEyIEBACiAJdm1hID0gZmluZF92bWEoY3VycmVudC0+bW0sIGFkZHIpOwogCWlmICghdm1hKQogCQlyZXR1cm4gLUVOT01FTTsKLQl3cml0ZSA9ICh2bWEtPnZtX2ZsYWdzICYgVk1fV1JJVEUpICE9IDA7CisJLyoKKwkgKiBXZSB3YW50IHRvIHRvdWNoIHdyaXRhYmxlIG1hcHBpbmdzIHdpdGggYSB3cml0ZSBmYXVsdCBpbiBvcmRlcgorCSAqIHRvIGJyZWFrIENPVywgZXhjZXB0IGZvciBzaGFyZWQgbWFwcGluZ3MgYmVjYXVzZSB0aGVzZSBkb24ndCBDT1cKKwkgKiBhbmQgd2Ugd291bGQgbm90IHdhbnQgdG8gZGlydHkgdGhlbSBmb3Igbm90aGluZy4KKwkgKi8KKwl3cml0ZSA9ICh2bWEtPnZtX2ZsYWdzICYgKFZNX1dSSVRFIHwgVk1fU0hBUkVEKSkgPT0gVk1fV1JJVEU7CiAJQlVHX09OKGFkZHIgPj0gZW5kKTsKIAlCVUdfT04oZW5kID4gdm1hLT52bV9lbmQpOwogCWxlbiA9IERJVl9ST1VORF9VUChlbmQsIFBBR0VfU0laRSkgLSBhZGRyL1BBR0VfU0laRTsKQEAgLTMzNjgsNiArMzQ3NCw3IEBACiAJCWdvdG8gb3V0OwogCiAJcG1kID0gcG1kX29mZnNldChwdWQsIGFkZHJlc3MpOworCVZNX0JVR19PTihwbWRfdHJhbnNfaHVnZSgqcG1kKSk7CiAJaWYgKHBtZF9ub25lKCpwbWQpIHx8IHVubGlrZWx5KHBtZF9iYWQoKnBtZCkpKQogCQlnb3RvIG91dDsKIApAQCAtMzYwOCwzICszNzE1LDc0IEBACiB9CiBFWFBPUlRfU1lNQk9MKG1pZ2h0X2ZhdWx0KTsKICNlbmRpZgorCisjaWYgZGVmaW5lZChDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UpIHx8IGRlZmluZWQoQ09ORklHX0hVR0VUTEJGUykKK3N0YXRpYyB2b2lkIGNsZWFyX2dpZ2FudGljX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UsCisJCQkJdW5zaWduZWQgbG9uZyBhZGRyLAorCQkJCXVuc2lnbmVkIGludCBwYWdlc19wZXJfaHVnZV9wYWdlKQoreworCWludCBpOworCXN0cnVjdCBwYWdlICpwID0gcGFnZTsKKworCW1pZ2h0X3NsZWVwKCk7CisJZm9yIChpID0gMDsgaSA8IHBhZ2VzX3Blcl9odWdlX3BhZ2U7CisJICAgICBpKyssIHAgPSBtZW1fbWFwX25leHQocCwgcGFnZSwgaSkpIHsKKwkJY29uZF9yZXNjaGVkKCk7CisJCWNsZWFyX3VzZXJfaGlnaHBhZ2UocCwgYWRkciArIGkgKiBQQUdFX1NJWkUpOworCX0KK30KK3ZvaWQgY2xlYXJfaHVnZV9wYWdlKHN0cnVjdCBwYWdlICpwYWdlLAorCQkgICAgIHVuc2lnbmVkIGxvbmcgYWRkciwgdW5zaWduZWQgaW50IHBhZ2VzX3Blcl9odWdlX3BhZ2UpCit7CisJaW50IGk7CisKKwlpZiAodW5saWtlbHkocGFnZXNfcGVyX2h1Z2VfcGFnZSA+IE1BWF9PUkRFUl9OUl9QQUdFUykpIHsKKwkJY2xlYXJfZ2lnYW50aWNfcGFnZShwYWdlLCBhZGRyLCBwYWdlc19wZXJfaHVnZV9wYWdlKTsKKwkJcmV0dXJuOworCX0KKworCW1pZ2h0X3NsZWVwKCk7CisJZm9yIChpID0gMDsgaSA8IHBhZ2VzX3Blcl9odWdlX3BhZ2U7IGkrKykgeworCQljb25kX3Jlc2NoZWQoKTsKKwkJY2xlYXJfdXNlcl9oaWdocGFnZShwYWdlICsgaSwgYWRkciArIGkgKiBQQUdFX1NJWkUpOworCX0KK30KKworc3RhdGljIHZvaWQgY29weV91c2VyX2dpZ2FudGljX3BhZ2Uoc3RydWN0IHBhZ2UgKmRzdCwgc3RydWN0IHBhZ2UgKnNyYywKKwkJCQkgICAgdW5zaWduZWQgbG9uZyBhZGRyLAorCQkJCSAgICBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCQkgICAgdW5zaWduZWQgaW50IHBhZ2VzX3Blcl9odWdlX3BhZ2UpCit7CisJaW50IGk7CisJc3RydWN0IHBhZ2UgKmRzdF9iYXNlID0gZHN0OworCXN0cnVjdCBwYWdlICpzcmNfYmFzZSA9IHNyYzsKKworCWZvciAoaSA9IDA7IGkgPCBwYWdlc19wZXJfaHVnZV9wYWdlOyApIHsKKwkJY29uZF9yZXNjaGVkKCk7CisJCWNvcHlfdXNlcl9oaWdocGFnZShkc3QsIHNyYywgYWRkciArIGkqUEFHRV9TSVpFLCB2bWEpOworCisJCWkrKzsKKwkJZHN0ID0gbWVtX21hcF9uZXh0KGRzdCwgZHN0X2Jhc2UsIGkpOworCQlzcmMgPSBtZW1fbWFwX25leHQoc3JjLCBzcmNfYmFzZSwgaSk7CisJfQorfQorCit2b2lkIGNvcHlfdXNlcl9odWdlX3BhZ2Uoc3RydWN0IHBhZ2UgKmRzdCwgc3RydWN0IHBhZ2UgKnNyYywKKwkJCSB1bnNpZ25lZCBsb25nIGFkZHIsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJIHVuc2lnbmVkIGludCBwYWdlc19wZXJfaHVnZV9wYWdlKQoreworCWludCBpOworCisJaWYgKHVubGlrZWx5KHBhZ2VzX3Blcl9odWdlX3BhZ2UgPiBNQVhfT1JERVJfTlJfUEFHRVMpKSB7CisJCWNvcHlfdXNlcl9naWdhbnRpY19wYWdlKGRzdCwgc3JjLCBhZGRyLCB2bWEsCisJCQkJCXBhZ2VzX3Blcl9odWdlX3BhZ2UpOworCQlyZXR1cm47CisJfQorCisJbWlnaHRfc2xlZXAoKTsKKwlmb3IgKGkgPSAwOyBpIDwgcGFnZXNfcGVyX2h1Z2VfcGFnZTsgaSsrKSB7CisJCWNvbmRfcmVzY2hlZCgpOworCQljb3B5X3VzZXJfaGlnaHBhZ2UoZHN0ICsgaSwgc3JjICsgaSwgYWRkciArIGkqUEFHRV9TSVpFLCB2bWEpOworCX0KK30KKyNlbmRpZiAvKiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UgfHwgQ09ORklHX0hVR0VUTEJGUyAqLwpkaWZmIC0tZ2l0IGEvbW0vbWVtb3J5X2hvdHBsdWcuYyBiL21tL21lbW9yeV9ob3RwbHVnLmMKaW5kZXggMmM2NTIzYS4uMzIxZmM3NCAxMDA2NDQKLS0tIGEvbW0vbWVtb3J5X2hvdHBsdWcuYworKysgYi9tbS9tZW1vcnlfaG90cGx1Zy5jCkBAIC04Miw5ICs4MiwxMCBAQAogCiAjaWZkZWYgQ09ORklHX01FTU9SWV9IT1RQTFVHX1NQQVJTRQogI2lmbmRlZiBDT05GSUdfU1BBUlNFTUVNX1ZNRU1NQVAKLXN0YXRpYyB2b2lkIGdldF9wYWdlX2Jvb3RtZW0odW5zaWduZWQgbG9uZyBpbmZvLCAgc3RydWN0IHBhZ2UgKnBhZ2UsIGludCB0eXBlKQorc3RhdGljIHZvaWQgZ2V0X3BhZ2VfYm9vdG1lbSh1bnNpZ25lZCBsb25nIGluZm8sICBzdHJ1Y3QgcGFnZSAqcGFnZSwKKwkJCSAgICAgdW5zaWduZWQgbG9uZyB0eXBlKQogewotCWF0b21pY19zZXQoJnBhZ2UtPl9tYXBjb3VudCwgdHlwZSk7CisJcGFnZS0+bHJ1Lm5leHQgPSAoc3RydWN0IGxpc3RfaGVhZCAqKSB0eXBlOwogCVNldFBhZ2VQcml2YXRlKHBhZ2UpOwogCXNldF9wYWdlX3ByaXZhdGUocGFnZSwgaW5mbyk7CiAJYXRvbWljX2luYygmcGFnZS0+X2NvdW50KTsKQEAgLTk0LDE1ICs5NSwxNiBAQAogICogc28gdXNlIF9fcmVmIHRvIHRlbGwgbW9kcG9zdCBub3QgdG8gZ2VuZXJhdGUgYSB3YXJuaW5nICovCiB2b2lkIF9fcmVmIHB1dF9wYWdlX2Jvb3RtZW0oc3RydWN0IHBhZ2UgKnBhZ2UpCiB7Ci0JaW50IHR5cGU7CisJdW5zaWduZWQgbG9uZyB0eXBlOwogCi0JdHlwZSA9IGF0b21pY19yZWFkKCZwYWdlLT5fbWFwY291bnQpOwotCUJVR19PTih0eXBlID49IC0xKTsKKwl0eXBlID0gKHVuc2lnbmVkIGxvbmcpIHBhZ2UtPmxydS5uZXh0OworCUJVR19PTih0eXBlIDwgTUVNT1JZX0hPVFBMVUdfTUlOX0JPT1RNRU1fVFlQRSB8fAorCSAgICAgICB0eXBlID4gTUVNT1JZX0hPVFBMVUdfTUFYX0JPT1RNRU1fVFlQRSk7CiAKIAlpZiAoYXRvbWljX2RlY19yZXR1cm4oJnBhZ2UtPl9jb3VudCkgPT0gMSkgewogCQlDbGVhclBhZ2VQcml2YXRlKHBhZ2UpOwogCQlzZXRfcGFnZV9wcml2YXRlKHBhZ2UsIDApOwotCQlyZXNldF9wYWdlX21hcGNvdW50KHBhZ2UpOworCQlJTklUX0xJU1RfSEVBRCgmcGFnZS0+bHJ1KTsKIAkJX19mcmVlX3BhZ2VzX2Jvb3RtZW0ocGFnZSwgMCk7CiAJfQogCkBAIC00MDcsNiArNDA5LDcgQEAKIAlpbnQgcmV0OwogCXN0cnVjdCBtZW1vcnlfbm90aWZ5IGFyZzsKIAorCWxvY2tfbWVtb3J5X2hvdHBsdWcoKTsKIAlhcmcuc3RhcnRfcGZuID0gcGZuOwogCWFyZy5ucl9wYWdlcyA9IG5yX3BhZ2VzOwogCWFyZy5zdGF0dXNfY2hhbmdlX25pZCA9IC0xOwpAQCAtNDE5LDYgKzQyMiw3IEBACiAJcmV0ID0gbm90aWZpZXJfdG9fZXJybm8ocmV0KTsKIAlpZiAocmV0KSB7CiAJCW1lbW9yeV9ub3RpZnkoTUVNX0NBTkNFTF9PTkxJTkUsICZhcmcpOworCQl1bmxvY2tfbWVtb3J5X2hvdHBsdWcoKTsKIAkJcmV0dXJuIHJldDsKIAl9CiAJLyoKQEAgLTQ0Myw2ICs0NDcsNyBAQAogCQlwcmludGsoS0VSTl9ERUJVRyAib25saW5lX3BhZ2VzICVseCBhdCAlbHggZmFpbGVkXG4iLAogCQkJbnJfcGFnZXMsIHBmbik7CiAJCW1lbW9yeV9ub3RpZnkoTUVNX0NBTkNFTF9PTkxJTkUsICZhcmcpOworCQl1bmxvY2tfbWVtb3J5X2hvdHBsdWcoKTsKIAkJcmV0dXJuIHJldDsKIAl9CiAKQEAgLTQ2Nyw2ICs0NzIsNyBAQAogCiAJaWYgKG9ubGluZWRfcGFnZXMpCiAJCW1lbW9yeV9ub3RpZnkoTUVNX09OTElORSwgJmFyZyk7CisJdW5sb2NrX21lbW9yeV9ob3RwbHVnKCk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTczMyw3ICs3MzksOCBAQAogCQkJZ290byBvdXQ7CiAJCX0KIAkJLyogdGhpcyBmdW5jdGlvbiByZXR1cm5zICMgb2YgZmFpbGVkIHBhZ2VzICovCi0JCXJldCA9IG1pZ3JhdGVfcGFnZXMoJnNvdXJjZSwgaG90cmVtb3ZlX21pZ3JhdGVfYWxsb2MsIDAsIDEpOworCQlyZXQgPSBtaWdyYXRlX3BhZ2VzKCZzb3VyY2UsIGhvdHJlbW92ZV9taWdyYXRlX2FsbG9jLCAwLAorCQkJCQkJCQl0cnVlLCB0cnVlKTsKIAkJaWYgKHJldCkKIAkJCXB1dGJhY2tfbHJ1X3BhZ2VzKCZzb3VyY2UpOwogCX0KZGlmZiAtLWdpdCBhL21tL21lbXBvbGljeS5jIGIvbW0vbWVtcG9saWN5LmMKaW5kZXggMTFmZjI2MC4uMzY4ZmM5ZCAxMDA2NDQKLS0tIGEvbW0vbWVtcG9saWN5LmMKKysrIGIvbW0vbWVtcG9saWN5LmMKQEAgLTUxNCw2ICs1MTQsNyBAQAogCXBtZCA9IHBtZF9vZmZzZXQocHVkLCBhZGRyKTsKIAlkbyB7CiAJCW5leHQgPSBwbWRfYWRkcl9lbmQoYWRkciwgZW5kKTsKKwkJc3BsaXRfaHVnZV9wYWdlX3BtZCh2bWEtPnZtX21tLCBwbWQpOwogCQlpZiAocG1kX25vbmVfb3JfY2xlYXJfYmFkKHBtZCkpCiAJCQljb250aW51ZTsKIAkJaWYgKGNoZWNrX3B0ZV9yYW5nZSh2bWEsIHBtZCwgYWRkciwgbmV4dCwgbm9kZXMsCkBAIC05MzUsNyArOTM2LDggQEAKIAkJcmV0dXJuIFBUUl9FUlIodm1hKTsKIAogCWlmICghbGlzdF9lbXB0eSgmcGFnZWxpc3QpKSB7Ci0JCWVyciA9IG1pZ3JhdGVfcGFnZXMoJnBhZ2VsaXN0LCBuZXdfbm9kZV9wYWdlLCBkZXN0LCAwKTsKKwkJZXJyID0gbWlncmF0ZV9wYWdlcygmcGFnZWxpc3QsIG5ld19ub2RlX3BhZ2UsIGRlc3QsCisJCQkJCQkJCWZhbHNlLCB0cnVlKTsKIAkJaWYgKGVycikKIAkJCXB1dGJhY2tfbHJ1X3BhZ2VzKCZwYWdlbGlzdCk7CiAJfQpAQCAtMTE1NSw3ICsxMTU3LDggQEAKIAogCQlpZiAoIWxpc3RfZW1wdHkoJnBhZ2VsaXN0KSkgewogCQkJbnJfZmFpbGVkID0gbWlncmF0ZV9wYWdlcygmcGFnZWxpc3QsIG5ld192bWFfcGFnZSwKLQkJCQkJCSh1bnNpZ25lZCBsb25nKXZtYSwgMCk7CisJCQkJCQkodW5zaWduZWQgbG9uZyl2bWEsCisJCQkJCQlmYWxzZSwgdHJ1ZSk7CiAJCQlpZiAobnJfZmFpbGVkKQogCQkJCXB1dGJhY2tfbHJ1X3BhZ2VzKCZwYWdlbGlzdCk7CiAJCX0KQEAgLTEzMDgsMTYgKzEzMTEsMTMgQEAKIAogCS8qIEZpbmQgdGhlIG1tX3N0cnVjdCAqLwogCXJjdV9yZWFkX2xvY2soKTsKLQlyZWFkX2xvY2soJnRhc2tsaXN0X2xvY2spOwogCXRhc2sgPSBwaWQgPyBmaW5kX3Rhc2tfYnlfdnBpZChwaWQpIDogY3VycmVudDsKIAlpZiAoIXRhc2spIHsKLQkJcmVhZF91bmxvY2soJnRhc2tsaXN0X2xvY2spOwogCQlyY3VfcmVhZF91bmxvY2soKTsKIAkJZXJyID0gLUVTUkNIOwogCQlnb3RvIG91dDsKIAl9CiAJbW0gPSBnZXRfdGFza19tbSh0YXNrKTsKLQlyZWFkX3VubG9jaygmdGFza2xpc3RfbG9jayk7CiAJcmN1X3JlYWRfdW5sb2NrKCk7CiAKIAllcnIgPSAtRUlOVkFMOwpAQCAtMTc5Niw3ICsxNzk2LDcgQEAKIH0KIAogLyoqCi0gKiAJYWxsb2NfcGFnZV92bWEJLSBBbGxvY2F0ZSBhIHBhZ2UgZm9yIGEgVk1BLgorICogCWFsbG9jX3BhZ2VzX3ZtYQktIEFsbG9jYXRlIGEgcGFnZSBmb3IgYSBWTUEuCiAgKgogICogCUBnZnA6CiAgKiAgICAgICVHRlBfVVNFUiAgICB1c2VyIGFsbG9jYXRpb24uCkBAIC0xODA1LDYgKzE4MDUsNyBAQAogICogICAgICAlR0ZQX0ZTICAgICAgYWxsb2NhdGlvbiBzaG91bGQgbm90IGNhbGwgYmFjayBpbnRvIGEgZmlsZSBzeXN0ZW0uCiAgKiAgICAgICVHRlBfQVRPTUlDICBkb24ndCBzbGVlcC4KICAqCisgKglAb3JkZXI6T3JkZXIgb2YgdGhlIEdGUCBhbGxvY2F0aW9uLgogICogCUB2bWE6ICBQb2ludGVyIHRvIFZNQSBvciBOVUxMIGlmIG5vdCBhdmFpbGFibGUuCiAgKglAYWRkcjogVmlydHVhbCBBZGRyZXNzIG9mIHRoZSBhbGxvY2F0aW9uLiBNdXN0IGJlIGluc2lkZSB0aGUgVk1BLgogICoKQEAgLTE4MTgsNyArMTgxOSw4IEBACiAgKglTaG91bGQgYmUgY2FsbGVkIHdpdGggdGhlIG1tX3NlbSBvZiB0aGUgdm1hIGhvbGQuCiAgKi8KIHN0cnVjdCBwYWdlICoKLWFsbG9jX3BhZ2Vfdm1hKGdmcF90IGdmcCwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHVuc2lnbmVkIGxvbmcgYWRkcikKK2FsbG9jX3BhZ2VzX3ZtYShnZnBfdCBnZnAsIGludCBvcmRlciwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCisJCXVuc2lnbmVkIGxvbmcgYWRkcikKIHsKIAlzdHJ1Y3QgbWVtcG9saWN5ICpwb2wgPSBnZXRfdm1hX3BvbGljeShjdXJyZW50LCB2bWEsIGFkZHIpOwogCXN0cnVjdCB6b25lbGlzdCAqemw7CkBAIC0xODMwLDcgKzE4MzIsNyBAQAogCiAJCW5pZCA9IGludGVybGVhdmVfbmlkKHBvbCwgdm1hLCBhZGRyLCBQQUdFX1NISUZUKTsKIAkJbXBvbF9jb25kX3B1dChwb2wpOwotCQlwYWdlID0gYWxsb2NfcGFnZV9pbnRlcmxlYXZlKGdmcCwgMCwgbmlkKTsKKwkJcGFnZSA9IGFsbG9jX3BhZ2VfaW50ZXJsZWF2ZShnZnAsIG9yZGVyLCBuaWQpOwogCQlwdXRfbWVtc19hbGxvd2VkKCk7CiAJCXJldHVybiBwYWdlOwogCX0KQEAgLTE4MzksNyArMTg0MSw3IEBACiAJCS8qCiAJCSAqIHNsb3cgcGF0aDogcmVmIGNvdW50ZWQgc2hhcmVkIHBvbGljeQogCQkgKi8KLQkJc3RydWN0IHBhZ2UgKnBhZ2UgPSAgX19hbGxvY19wYWdlc19ub2RlbWFzayhnZnAsIDAsCisJCXN0cnVjdCBwYWdlICpwYWdlID0gIF9fYWxsb2NfcGFnZXNfbm9kZW1hc2soZ2ZwLCBvcmRlciwKIAkJCQkJCXpsLCBwb2xpY3lfbm9kZW1hc2soZ2ZwLCBwb2wpKTsKIAkJX19tcG9sX3B1dChwb2wpOwogCQlwdXRfbWVtc19hbGxvd2VkKCk7CkBAIC0xODQ4LDcgKzE4NTAsOCBAQAogCS8qCiAJICogZmFzdCBwYXRoOiAgZGVmYXVsdCBvciB0YXNrIHBvbGljeQogCSAqLwotCXBhZ2UgPSBfX2FsbG9jX3BhZ2VzX25vZGVtYXNrKGdmcCwgMCwgemwsIHBvbGljeV9ub2RlbWFzayhnZnAsIHBvbCkpOworCXBhZ2UgPSBfX2FsbG9jX3BhZ2VzX25vZGVtYXNrKGdmcCwgb3JkZXIsIHpsLAorCQkJCSAgICAgIHBvbGljeV9ub2RlbWFzayhnZnAsIHBvbCkpOwogCXB1dF9tZW1zX2FsbG93ZWQoKTsKIAlyZXR1cm4gcGFnZTsKIH0KZGlmZiAtLWdpdCBhL21tL21pZ3JhdGUuYyBiL21tL21pZ3JhdGUuYwppbmRleCA2YWU4YTY2Li43NjYxMTUyIDEwMDY0NAotLS0gYS9tbS9taWdyYXRlLmMKKysrIGIvbW0vbWlncmF0ZS5jCkBAIC0xMTMsNiArMTEzLDggQEAKIAkJCWdvdG8gb3V0OwogCiAJCXBtZCA9IHBtZF9vZmZzZXQocHVkLCBhZGRyKTsKKwkJaWYgKHBtZF90cmFuc19odWdlKCpwbWQpKQorCQkJZ290byBvdXQ7CiAJCWlmICghcG1kX3ByZXNlbnQoKnBtZCkpCiAJCQlnb3RvIG91dDsKIApAQCAtMjQ2LDcgKzI0OCw3IEBACiAKIAlleHBlY3RlZF9jb3VudCA9IDIgKyBwYWdlX2hhc19wcml2YXRlKHBhZ2UpOwogCWlmIChwYWdlX2NvdW50KHBhZ2UpICE9IGV4cGVjdGVkX2NvdW50IHx8Ci0JCQkoc3RydWN0IHBhZ2UgKilyYWRpeF90cmVlX2RlcmVmX3Nsb3QocHNsb3QpICE9IHBhZ2UpIHsKKwkJcmFkaXhfdHJlZV9kZXJlZl9zbG90X3Byb3RlY3RlZChwc2xvdCwgJm1hcHBpbmctPnRyZWVfbG9jaykgIT0gcGFnZSkgewogCQlzcGluX3VubG9ja19pcnEoJm1hcHBpbmctPnRyZWVfbG9jayk7CiAJCXJldHVybiAtRUFHQUlOOwogCX0KQEAgLTMxOCw3ICszMjAsNyBAQAogCiAJZXhwZWN0ZWRfY291bnQgPSAyICsgcGFnZV9oYXNfcHJpdmF0ZShwYWdlKTsKIAlpZiAocGFnZV9jb3VudChwYWdlKSAhPSBleHBlY3RlZF9jb3VudCB8fAotCSAgICAoc3RydWN0IHBhZ2UgKilyYWRpeF90cmVlX2RlcmVmX3Nsb3QocHNsb3QpICE9IHBhZ2UpIHsKKwkJcmFkaXhfdHJlZV9kZXJlZl9zbG90X3Byb3RlY3RlZChwc2xvdCwgJm1hcHBpbmctPnRyZWVfbG9jaykgIT0gcGFnZSkgewogCQlzcGluX3VubG9ja19pcnEoJm1hcHBpbmctPnRyZWVfbG9jayk7CiAJCXJldHVybiAtRUFHQUlOOwogCX0KQEAgLTYxNCwxMyArNjE2LDEyIEBACiAgKiB0byB0aGUgbmV3bHkgYWxsb2NhdGVkIHBhZ2UgaW4gbmV3cGFnZS4KICAqLwogc3RhdGljIGludCB1bm1hcF9hbmRfbW92ZShuZXdfcGFnZV90IGdldF9uZXdfcGFnZSwgdW5zaWduZWQgbG9uZyBwcml2YXRlLAotCQkJc3RydWN0IHBhZ2UgKnBhZ2UsIGludCBmb3JjZSwgaW50IG9mZmxpbmluZykKKwkJCXN0cnVjdCBwYWdlICpwYWdlLCBpbnQgZm9yY2UsIGJvb2wgb2ZmbGluaW5nLCBib29sIHN5bmMpCiB7CiAJaW50IHJjID0gMDsKIAlpbnQgKnJlc3VsdCA9IE5VTEw7CiAJc3RydWN0IHBhZ2UgKm5ld3BhZ2UgPSBnZXRfbmV3X3BhZ2UocGFnZSwgcHJpdmF0ZSwgJnJlc3VsdCk7CiAJaW50IHJlbWFwX3N3YXBjYWNoZSA9IDE7Ci0JaW50IHJjdV9sb2NrZWQgPSAwOwogCWludCBjaGFyZ2UgPSAwOwogCXN0cnVjdCBtZW1fY2dyb3VwICptZW0gPSBOVUxMOwogCXN0cnVjdCBhbm9uX3ZtYSAqYW5vbl92bWEgPSBOVUxMOwpAQCAtNjMyLDYgKzYzMyw5IEBACiAJCS8qIHBhZ2Ugd2FzIGZyZWVkIGZyb20gdW5kZXIgdXMuIFNvIHdlIGFyZSBkb25lLiAqLwogCQlnb3RvIG1vdmVfbmV3cGFnZTsKIAl9CisJaWYgKHVubGlrZWx5KFBhZ2VUcmFuc0h1Z2UocGFnZSkpKQorCQlpZiAodW5saWtlbHkoc3BsaXRfaHVnZV9wYWdlKHBhZ2UpKSkKKwkJCWdvdG8gbW92ZV9uZXdwYWdlOwogCiAJLyogcHJlcGFyZSBjZ3JvdXAganVzdCByZXR1cm5zIDAgb3IgLUVOT01FTSAqLwogCXJjID0gLUVBR0FJTjsKQEAgLTYzOSw2ICs2NDMsMjMgQEAKIAlpZiAoIXRyeWxvY2tfcGFnZShwYWdlKSkgewogCQlpZiAoIWZvcmNlKQogCQkJZ290byBtb3ZlX25ld3BhZ2U7CisKKwkJLyoKKwkJICogSXQncyBub3Qgc2FmZSBmb3IgZGlyZWN0IGNvbXBhY3Rpb24gdG8gY2FsbCBsb2NrX3BhZ2UuCisJCSAqIEZvciBleGFtcGxlLCBkdXJpbmcgcGFnZSByZWFkYWhlYWQgcGFnZXMgYXJlIGFkZGVkIGxvY2tlZAorCQkgKiB0byB0aGUgTFJVLiBMYXRlciwgd2hlbiB0aGUgSU8gY29tcGxldGVzIHRoZSBwYWdlcyBhcmUKKwkJICogbWFya2VkIHVwdG9kYXRlIGFuZCB1bmxvY2tlZC4gSG93ZXZlciwgdGhlIHF1ZXVlaW5nCisJCSAqIGNvdWxkIGJlIG1lcmdpbmcgbXVsdGlwbGUgcGFnZXMgZm9yIG9uZSBiaW8gKGUuZy4KKwkJICogbXBhZ2VfcmVhZHBhZ2VzKS4gSWYgYW4gYWxsb2NhdGlvbiBoYXBwZW5zIGZvciB0aGUKKwkJICogc2Vjb25kIG9yIHRoaXJkIHBhZ2UsIHRoZSBwcm9jZXNzIGNhbiBlbmQgdXAgbG9ja2luZworCQkgKiB0aGUgc2FtZSBwYWdlIHR3aWNlIGFuZCBkZWFkbG9ja2luZy4gUmF0aGVyIHRoYW4KKwkJICogdHJ5aW5nIHRvIGJlIGNsZXZlciBhYm91dCB3aGF0IHBhZ2VzIGNhbiBiZSBsb2NrZWQsCisJCSAqIGF2b2lkIHRoZSB1c2Ugb2YgbG9ja19wYWdlIGZvciBkaXJlY3QgY29tcGFjdGlvbgorCQkgKiBhbHRvZ2V0aGVyLgorCQkgKi8KKwkJaWYgKGN1cnJlbnQtPmZsYWdzICYgUEZfTUVNQUxMT0MpCisJCQlnb3RvIG1vdmVfbmV3cGFnZTsKKwogCQlsb2NrX3BhZ2UocGFnZSk7CiAJfQogCkBAIC02NjUsMjcgKzY4NiwzMyBAQAogCUJVR19PTihjaGFyZ2UpOwogCiAJaWYgKFBhZ2VXcml0ZWJhY2socGFnZSkpIHsKLQkJaWYgKCFmb3JjZSkKKwkJaWYgKCFmb3JjZSB8fCAhc3luYykKIAkJCWdvdG8gdW5jaGFyZ2U7CiAJCXdhaXRfb25fcGFnZV93cml0ZWJhY2socGFnZSk7CiAJfQogCS8qCiAJICogQnkgdHJ5X3RvX3VubWFwKCksIHBhZ2UtPm1hcGNvdW50IGdvZXMgZG93biB0byAwIGhlcmUuIEluIHRoaXMgY2FzZSwKIAkgKiB3ZSBjYW5ub3Qgbm90aWNlIHRoYXQgYW5vbl92bWEgaXMgZnJlZWQgd2hpbGUgd2UgbWlncmF0ZXMgYSBwYWdlLgotCSAqIFRoaXMgcmN1X3JlYWRfbG9jaygpIGRlbGF5cyBmcmVlaW5nIGFub25fdm1hIHBvaW50ZXIgdW50aWwgdGhlIGVuZAorCSAqIFRoaXMgZ2V0X2Fub25fdm1hKCkgZGVsYXlzIGZyZWVpbmcgYW5vbl92bWEgcG9pbnRlciB1bnRpbCB0aGUgZW5kCiAJICogb2YgbWlncmF0aW9uLiBGaWxlIGNhY2hlIHBhZ2VzIGFyZSBubyBwcm9ibGVtIGJlY2F1c2Ugb2YgcGFnZV9sb2NrKCkKIAkgKiBGaWxlIENhY2hlcyBtYXkgdXNlIHdyaXRlX3BhZ2UoKSBvciBsb2NrX3BhZ2UoKSBpbiBtaWdyYXRpb24sIHRoZW4sCiAJICoganVzdCBjYXJlIEFub24gcGFnZSBoZXJlLgogCSAqLwogCWlmIChQYWdlQW5vbihwYWdlKSkgewotCQlyY3VfcmVhZF9sb2NrKCk7Ci0JCXJjdV9sb2NrZWQgPSAxOwotCi0JCS8qIERldGVybWluZSBob3cgdG8gc2FmZWx5IHVzZSBhbm9uX3ZtYSAqLwotCQlpZiAoIXBhZ2VfbWFwcGVkKHBhZ2UpKSB7Ci0JCQlpZiAoIVBhZ2VTd2FwQ2FjaGUocGFnZSkpCi0JCQkJZ290byByY3VfdW5sb2NrOwotCisJCS8qCisJCSAqIE9ubHkgcGFnZV9sb2NrX2Fub25fdm1hKCkgdW5kZXJzdGFuZHMgdGhlIHN1YnRsZXRpZXMgb2YKKwkJICogZ2V0dGluZyBhIGhvbGQgb24gYW4gYW5vbl92bWEgZnJvbSBvdXRzaWRlIG9uZSBvZiBpdHMgbW1zLgorCQkgKi8KKwkJYW5vbl92bWEgPSBwYWdlX2xvY2tfYW5vbl92bWEocGFnZSk7CisJCWlmIChhbm9uX3ZtYSkgeworCQkJLyoKKwkJCSAqIFRha2UgYSByZWZlcmVuY2UgY291bnQgb24gdGhlIGFub25fdm1hIGlmIHRoZQorCQkJICogcGFnZSBpcyBtYXBwZWQgc28gdGhhdCBpdCBpcyBndWFyYW50ZWVkIHRvCisJCQkgKiBleGlzdCB3aGVuIHRoZSBwYWdlIGlzIHJlbWFwcGVkIGxhdGVyCisJCQkgKi8KKwkJCWdldF9hbm9uX3ZtYShhbm9uX3ZtYSk7CisJCQlwYWdlX3VubG9ja19hbm9uX3ZtYShhbm9uX3ZtYSk7CisJCX0gZWxzZSBpZiAoUGFnZVN3YXBDYWNoZShwYWdlKSkgewogCQkJLyoKIAkJCSAqIFdlIGNhbm5vdCBiZSBzdXJlIHRoYXQgdGhlIGFub25fdm1hIG9mIGFuIHVubWFwcGVkCiAJCQkgKiBzd2FwY2FjaGUgcGFnZSBpcyBzYWZlIHRvIHVzZSBiZWNhdXNlIHdlIGRvbid0CkBAIC03MDAsMTMgKzcyNyw3IEBACiAJCQkgKi8KIAkJCXJlbWFwX3N3YXBjYWNoZSA9IDA7CiAJCX0gZWxzZSB7Ci0JCQkvKgotCQkJICogVGFrZSBhIHJlZmVyZW5jZSBjb3VudCBvbiB0aGUgYW5vbl92bWEgaWYgdGhlCi0JCQkgKiBwYWdlIGlzIG1hcHBlZCBzbyB0aGF0IGl0IGlzIGd1YXJhbnRlZWQgdG8KLQkJCSAqIGV4aXN0IHdoZW4gdGhlIHBhZ2UgaXMgcmVtYXBwZWQgbGF0ZXIKLQkJCSAqLwotCQkJYW5vbl92bWEgPSBwYWdlX2Fub25fdm1hKHBhZ2UpOwotCQkJZ2V0X2Fub25fdm1hKGFub25fdm1hKTsKKwkJCWdvdG8gdW5jaGFyZ2U7CiAJCX0KIAl9CiAKQEAgLTcyMywxNiArNzQ0LDEwIEBACiAJICogZnJlZSB0aGUgbWV0YWRhdGEsIHNvIHRoZSBwYWdlIGNhbiBiZSBmcmVlZC4KIAkgKi8KIAlpZiAoIXBhZ2UtPm1hcHBpbmcpIHsKLQkJaWYgKCFQYWdlQW5vbihwYWdlKSAmJiBwYWdlX2hhc19wcml2YXRlKHBhZ2UpKSB7Ci0JCQkvKgotCQkJICogR28gZGlyZWN0IHRvIHRyeV90b19mcmVlX2J1ZmZlcnMoKSBoZXJlIGJlY2F1c2UKLQkJCSAqIGEpIHRoYXQncyB3aGF0IHRyeV90b19yZWxlYXNlX3BhZ2UoKSB3b3VsZCBkbyBhbnl3YXkKLQkJCSAqIGIpIHdlIG1heSBiZSB1bmRlciByY3VfcmVhZF9sb2NrKCkgaGVyZSwgc28gd2UgY2FuJ3QKLQkJCSAqICAgIHVzZSBHRlBfS0VSTkVMIHdoaWNoIGlzIHdoYXQgdHJ5X3RvX3JlbGVhc2VfcGFnZSgpCi0JCQkgKiAgICBuZWVkcyB0byBiZSBlZmZlY3RpdmUuCi0JCQkgKi8KKwkJVk1fQlVHX09OKFBhZ2VBbm9uKHBhZ2UpKTsKKwkJaWYgKHBhZ2VfaGFzX3ByaXZhdGUocGFnZSkpIHsKIAkJCXRyeV90b19mcmVlX2J1ZmZlcnMocGFnZSk7Ci0JCQlnb3RvIHJjdV91bmxvY2s7CisJCQlnb3RvIHVuY2hhcmdlOwogCQl9CiAJCWdvdG8gc2tpcF91bm1hcDsKIAl9CkBAIC03NDYsMjAgKzc2MSwxOCBAQAogCiAJaWYgKHJjICYmIHJlbWFwX3N3YXBjYWNoZSkKIAkJcmVtb3ZlX21pZ3JhdGlvbl9wdGVzKHBhZ2UsIHBhZ2UpOwotcmN1X3VubG9jazoKIAogCS8qIERyb3AgYW4gYW5vbl92bWEgcmVmZXJlbmNlIGlmIHdlIHRvb2sgb25lICovCiAJaWYgKGFub25fdm1hKQogCQlkcm9wX2Fub25fdm1hKGFub25fdm1hKTsKIAotCWlmIChyY3VfbG9ja2VkKQotCQlyY3VfcmVhZF91bmxvY2soKTsKIHVuY2hhcmdlOgogCWlmICghY2hhcmdlKQotCQltZW1fY2dyb3VwX2VuZF9taWdyYXRpb24obWVtLCBwYWdlLCBuZXdwYWdlKTsKKwkJbWVtX2Nncm91cF9lbmRfbWlncmF0aW9uKG1lbSwgcGFnZSwgbmV3cGFnZSwgcmMgPT0gMCk7CiB1bmxvY2s6CiAJdW5sb2NrX3BhZ2UocGFnZSk7CiAKK21vdmVfbmV3cGFnZToKIAlpZiAocmMgIT0gLUVBR0FJTikgewogIAkJLyoKICAJCSAqIEEgcGFnZSB0aGF0IGhhcyBiZWVuIG1pZ3JhdGVkIGhhcyBhbGwgcmVmZXJlbmNlcwpAQCAtNzczLDggKzc4Niw2IEBACiAJCXB1dGJhY2tfbHJ1X3BhZ2UocGFnZSk7CiAJfQogCi1tb3ZlX25ld3BhZ2U6Ci0KIAkvKgogCSAqIE1vdmUgdGhlIG5ldyBwYWdlIHRvIHRoZSBMUlUuIElmIG1pZ3JhdGlvbiB3YXMgbm90IHN1Y2Nlc3NmdWwKIAkgKiB0aGVuIHRoaXMgd2lsbCBmcmVlIHRoZSBwYWdlLgpAQCAtODEwLDEyICs4MjEsMTEgQEAKICAqLwogc3RhdGljIGludCB1bm1hcF9hbmRfbW92ZV9odWdlX3BhZ2UobmV3X3BhZ2VfdCBnZXRfbmV3X3BhZ2UsCiAJCQkJdW5zaWduZWQgbG9uZyBwcml2YXRlLCBzdHJ1Y3QgcGFnZSAqaHBhZ2UsCi0JCQkJaW50IGZvcmNlLCBpbnQgb2ZmbGluaW5nKQorCQkJCWludCBmb3JjZSwgYm9vbCBvZmZsaW5pbmcsIGJvb2wgc3luYykKIHsKIAlpbnQgcmMgPSAwOwogCWludCAqcmVzdWx0ID0gTlVMTDsKIAlzdHJ1Y3QgcGFnZSAqbmV3X2hwYWdlID0gZ2V0X25ld19wYWdlKGhwYWdlLCBwcml2YXRlLCAmcmVzdWx0KTsKLQlpbnQgcmN1X2xvY2tlZCA9IDA7CiAJc3RydWN0IGFub25fdm1hICphbm9uX3ZtYSA9IE5VTEw7CiAKIAlpZiAoIW5ld19ocGFnZSkKQEAgLTgyNCwxOCArODM0LDE2IEBACiAJcmMgPSAtRUFHQUlOOwogCiAJaWYgKCF0cnlsb2NrX3BhZ2UoaHBhZ2UpKSB7Ci0JCWlmICghZm9yY2UpCisJCWlmICghZm9yY2UgfHwgIXN5bmMpCiAJCQlnb3RvIG91dDsKIAkJbG9ja19wYWdlKGhwYWdlKTsKIAl9CiAKIAlpZiAoUGFnZUFub24oaHBhZ2UpKSB7Ci0JCXJjdV9yZWFkX2xvY2soKTsKLQkJcmN1X2xvY2tlZCA9IDE7Ci0KLQkJaWYgKHBhZ2VfbWFwcGVkKGhwYWdlKSkgewotCQkJYW5vbl92bWEgPSBwYWdlX2Fub25fdm1hKGhwYWdlKTsKLQkJCWF0b21pY19pbmMoJmFub25fdm1hLT5leHRlcm5hbF9yZWZjb3VudCk7CisJCWFub25fdm1hID0gcGFnZV9sb2NrX2Fub25fdm1hKGhwYWdlKTsKKwkJaWYgKGFub25fdm1hKSB7CisJCQlnZXRfYW5vbl92bWEoYW5vbl92bWEpOworCQkJcGFnZV91bmxvY2tfYW5vbl92bWEoYW5vbl92bWEpOwogCQl9CiAJfQogCkBAIC04NDcsMTYgKzg1NSw4IEBACiAJaWYgKHJjKQogCQlyZW1vdmVfbWlncmF0aW9uX3B0ZXMoaHBhZ2UsIGhwYWdlKTsKIAotCWlmIChhbm9uX3ZtYSAmJiBhdG9taWNfZGVjX2FuZF9sb2NrKCZhbm9uX3ZtYS0+ZXh0ZXJuYWxfcmVmY291bnQsCi0JCQkJCSAgICAmYW5vbl92bWEtPmxvY2spKSB7Ci0JCWludCBlbXB0eSA9IGxpc3RfZW1wdHkoJmFub25fdm1hLT5oZWFkKTsKLQkJc3Bpbl91bmxvY2soJmFub25fdm1hLT5sb2NrKTsKLQkJaWYgKGVtcHR5KQotCQkJYW5vbl92bWFfZnJlZShhbm9uX3ZtYSk7Ci0JfQotCi0JaWYgKHJjdV9sb2NrZWQpCi0JCXJjdV9yZWFkX3VubG9jaygpOworCWlmIChhbm9uX3ZtYSkKKwkJZHJvcF9hbm9uX3ZtYShhbm9uX3ZtYSk7CiBvdXQ6CiAJdW5sb2NrX3BhZ2UoaHBhZ2UpOwogCkBAIC04ODcsMTIgKzg4NywxMyBAQAogICogYXJlIG1vdmFibGUgYW55bW9yZSBiZWNhdXNlIHRvIGhhcyBiZWNvbWUgZW1wdHkKICAqIG9yIG5vIHJldHJ5YWJsZSBwYWdlcyBleGlzdCBhbnltb3JlLgogICogQ2FsbGVyIHNob3VsZCBjYWxsIHB1dGJhY2tfbHJ1X3BhZ2VzIHRvIHJldHVybiBwYWdlcyB0byB0aGUgTFJVCi0gKiBvciBmcmVlIGxpc3QuCisgKiBvciBmcmVlIGxpc3Qgb25seSBpZiByZXQgIT0gMC4KICAqCiAgKiBSZXR1cm46IE51bWJlciBvZiBwYWdlcyBub3QgbWlncmF0ZWQgb3IgZXJyb3IgY29kZS4KICAqLwogaW50IG1pZ3JhdGVfcGFnZXMoc3RydWN0IGxpc3RfaGVhZCAqZnJvbSwKLQkJbmV3X3BhZ2VfdCBnZXRfbmV3X3BhZ2UsIHVuc2lnbmVkIGxvbmcgcHJpdmF0ZSwgaW50IG9mZmxpbmluZykKKwkJbmV3X3BhZ2VfdCBnZXRfbmV3X3BhZ2UsIHVuc2lnbmVkIGxvbmcgcHJpdmF0ZSwgYm9vbCBvZmZsaW5pbmcsCisJCWJvb2wgc3luYykKIHsKIAlpbnQgcmV0cnkgPSAxOwogCWludCBucl9mYWlsZWQgPSAwOwpAQCAtOTEyLDcgKzkxMyw4IEBACiAJCQljb25kX3Jlc2NoZWQoKTsKIAogCQkJcmMgPSB1bm1hcF9hbmRfbW92ZShnZXRfbmV3X3BhZ2UsIHByaXZhdGUsCi0JCQkJCQlwYWdlLCBwYXNzID4gMiwgb2ZmbGluaW5nKTsKKwkJCQkJCXBhZ2UsIHBhc3MgPiAyLCBvZmZsaW5pbmcsCisJCQkJCQlzeW5jKTsKIAogCQkJc3dpdGNoKHJjKSB7CiAJCQljYXNlIC1FTk9NRU06CkBAIC05NDEsNyArOTQzLDggQEAKIH0KIAogaW50IG1pZ3JhdGVfaHVnZV9wYWdlcyhzdHJ1Y3QgbGlzdF9oZWFkICpmcm9tLAotCQluZXdfcGFnZV90IGdldF9uZXdfcGFnZSwgdW5zaWduZWQgbG9uZyBwcml2YXRlLCBpbnQgb2ZmbGluaW5nKQorCQluZXdfcGFnZV90IGdldF9uZXdfcGFnZSwgdW5zaWduZWQgbG9uZyBwcml2YXRlLCBib29sIG9mZmxpbmluZywKKwkJYm9vbCBzeW5jKQogewogCWludCByZXRyeSA9IDE7CiAJaW50IG5yX2ZhaWxlZCA9IDA7CkBAIC05NTcsNyArOTYwLDggQEAKIAkJCWNvbmRfcmVzY2hlZCgpOwogCiAJCQlyYyA9IHVubWFwX2FuZF9tb3ZlX2h1Z2VfcGFnZShnZXRfbmV3X3BhZ2UsCi0JCQkJCXByaXZhdGUsIHBhZ2UsIHBhc3MgPiAyLCBvZmZsaW5pbmcpOworCQkJCQlwcml2YXRlLCBwYWdlLCBwYXNzID4gMiwgb2ZmbGluaW5nLAorCQkJCQlzeW5jKTsKIAogCQkJc3dpdGNoKHJjKSB7CiAJCQljYXNlIC1FTk9NRU06CkBAIC05NzYsMTAgKzk4MCw2IEBACiAJfQogCXJjID0gMDsKIG91dDoKLQotCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShwYWdlLCBwYWdlMiwgZnJvbSwgbHJ1KQotCQlwdXRfcGFnZShwYWdlKTsKLQogCWlmIChyYykKIAkJcmV0dXJuIHJjOwogCkBAIC0xMDQyLDcgKzEwNDIsNyBAQAogCQlpZiAoIXZtYSB8fCBwcC0+YWRkciA8IHZtYS0+dm1fc3RhcnQgfHwgIXZtYV9taWdyYXRhYmxlKHZtYSkpCiAJCQlnb3RvIHNldF9zdGF0dXM7CiAKLQkJcGFnZSA9IGZvbGxvd19wYWdlKHZtYSwgcHAtPmFkZHIsIEZPTExfR0VUKTsKKwkJcGFnZSA9IGZvbGxvd19wYWdlKHZtYSwgcHAtPmFkZHIsIEZPTExfR0VUfEZPTExfU1BMSVQpOwogCiAJCWVyciA9IFBUUl9FUlIocGFnZSk7CiAJCWlmIChJU19FUlIocGFnZSkpCkBAIC0xMDkwLDcgKzEwOTAsNyBAQAogCWVyciA9IDA7CiAJaWYgKCFsaXN0X2VtcHR5KCZwYWdlbGlzdCkpIHsKIAkJZXJyID0gbWlncmF0ZV9wYWdlcygmcGFnZWxpc3QsIG5ld19wYWdlX25vZGUsCi0JCQkJKHVuc2lnbmVkIGxvbmcpcG0sIDApOworCQkJCSh1bnNpZ25lZCBsb25nKXBtLCAwLCB0cnVlKTsKIAkJaWYgKGVycikKIAkJCXB1dGJhY2tfbHJ1X3BhZ2VzKCZwYWdlbGlzdCk7CiAJfQpkaWZmIC0tZ2l0IGEvbW0vbWluY29yZS5jIGIvbW0vbWluY29yZS5jCmluZGV4IDlhYzQyZGMuLmE0ZTZiOWQgMTAwNjQ0Ci0tLSBhL21tL21pbmNvcmUuYworKysgYi9tbS9taW5jb3JlLmMKQEAgLTE1NCw2ICsxNTQsMTMgQEAKIAlwbWQgPSBwbWRfb2Zmc2V0KHB1ZCwgYWRkcik7CiAJZG8gewogCQluZXh0ID0gcG1kX2FkZHJfZW5kKGFkZHIsIGVuZCk7CisJCWlmIChwbWRfdHJhbnNfaHVnZSgqcG1kKSkgeworCQkJaWYgKG1pbmNvcmVfaHVnZV9wbWQodm1hLCBwbWQsIGFkZHIsIG5leHQsIHZlYykpIHsKKwkJCQl2ZWMgKz0gKG5leHQgLSBhZGRyKSA+PiBQQUdFX1NISUZUOworCQkJCWNvbnRpbnVlOworCQkJfQorCQkJLyogZmFsbCB0aHJvdWdoICovCisJCX0KIAkJaWYgKHBtZF9ub25lX29yX2NsZWFyX2JhZChwbWQpKQogCQkJbWluY29yZV91bm1hcHBlZF9yYW5nZSh2bWEsIGFkZHIsIG5leHQsIHZlYyk7CiAJCWVsc2UKZGlmZiAtLWdpdCBhL21tL21sb2NrLmMgYi9tbS9tbG9jay5jCmluZGV4IGI3MDkxOWMuLmMzOTI0YzdmIDEwMDY0NAotLS0gYS9tbS9tbG9jay5jCisrKyBiL21tL21sb2NrLmMKQEAgLTE1NSwxMyArMTU1LDEyIEBACiAgKiB2bWEtPnZtX21tLT5tbWFwX3NlbSBtdXN0IGJlIGhlbGQgZm9yIGF0IGxlYXN0IHJlYWQuCiAgKi8KIHN0YXRpYyBsb25nIF9fbWxvY2tfdm1hX3BhZ2VzX3JhbmdlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAotCQkJCSAgICB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIGVuZCkKKwkJCQkgICAgdW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWduZWQgbG9uZyBlbmQsCisJCQkJICAgIGludCAqbm9uYmxvY2tpbmcpCiB7CiAJc3RydWN0IG1tX3N0cnVjdCAqbW0gPSB2bWEtPnZtX21tOwogCXVuc2lnbmVkIGxvbmcgYWRkciA9IHN0YXJ0OwotCXN0cnVjdCBwYWdlICpwYWdlc1sxNl07IC8qIDE2IGdpdmVzIGEgcmVhc29uYWJsZSBiYXRjaCAqLwogCWludCBucl9wYWdlcyA9IChlbmQgLSBzdGFydCkgLyBQQUdFX1NJWkU7Ci0JaW50IHJldCA9IDA7CiAJaW50IGd1cF9mbGFnczsKIAogCVZNX0JVR19PTihzdGFydCAmIH5QQUdFX01BU0spOwpAQCAtMTcwLDczICsxNjksMzMgQEAKIAlWTV9CVUdfT04oZW5kICAgPiB2bWEtPnZtX2VuZCk7CiAJVk1fQlVHX09OKCFyd3NlbV9pc19sb2NrZWQoJm1tLT5tbWFwX3NlbSkpOwogCi0JZ3VwX2ZsYWdzID0gRk9MTF9UT1VDSCB8IEZPTExfR0VUOwotCWlmICh2bWEtPnZtX2ZsYWdzICYgVk1fV1JJVEUpCisJZ3VwX2ZsYWdzID0gRk9MTF9UT1VDSDsKKwkvKgorCSAqIFdlIHdhbnQgdG8gdG91Y2ggd3JpdGFibGUgbWFwcGluZ3Mgd2l0aCBhIHdyaXRlIGZhdWx0IGluIG9yZGVyCisJICogdG8gYnJlYWsgQ09XLCBleGNlcHQgZm9yIHNoYXJlZCBtYXBwaW5ncyBiZWNhdXNlIHRoZXNlIGRvbid0IENPVworCSAqIGFuZCB3ZSB3b3VsZCBub3Qgd2FudCB0byBkaXJ0eSB0aGVtIGZvciBub3RoaW5nLgorCSAqLworCWlmICgodm1hLT52bV9mbGFncyAmIChWTV9XUklURSB8IFZNX1NIQVJFRCkpID09IFZNX1dSSVRFKQogCQlndXBfZmxhZ3MgfD0gRk9MTF9XUklURTsKIAorCS8qCisJICogV2Ugd2FudCBtbG9jayB0byBzdWNjZWVkIGZvciByZWdpb25zIHRoYXQgaGF2ZSBhbnkgcGVybWlzc2lvbnMKKwkgKiBvdGhlciB0aGFuIFBST1RfTk9ORS4KKwkgKi8KKwlpZiAodm1hLT52bV9mbGFncyAmIChWTV9SRUFEIHwgVk1fV1JJVEUgfCBWTV9FWEVDKSkKKwkJZ3VwX2ZsYWdzIHw9IEZPTExfRk9SQ0U7CisKKwlpZiAodm1hLT52bV9mbGFncyAmIFZNX0xPQ0tFRCkKKwkJZ3VwX2ZsYWdzIHw9IEZPTExfTUxPQ0s7CisKIAkvKiBXZSBkb24ndCB0cnkgdG8gYWNjZXNzIHRoZSBndWFyZCBwYWdlIG9mIGEgc3RhY2sgdm1hICovCiAJaWYgKHN0YWNrX2d1YXJkX3BhZ2Uodm1hLCBzdGFydCkpIHsKIAkJYWRkciArPSBQQUdFX1NJWkU7CiAJCW5yX3BhZ2VzLS07CiAJfQogCi0Jd2hpbGUgKG5yX3BhZ2VzID4gMCkgewotCQlpbnQgaTsKLQotCQljb25kX3Jlc2NoZWQoKTsKLQotCQkvKgotCQkgKiBnZXRfdXNlcl9wYWdlcyBtYWtlcyBwYWdlcyBwcmVzZW50IGlmIHdlIGFyZQotCQkgKiBzZXR0aW5nIG1sb2NrLiBhbmQgdGhpcyBleHRyYSByZWZlcmVuY2UgY291bnQgd2lsbAotCQkgKiBkaXNhYmxlIG1pZ3JhdGlvbiBvZiB0aGlzIHBhZ2UuICBIb3dldmVyLCBwYWdlIG1heQotCQkgKiBzdGlsbCBiZSB0cnVuY2F0ZWQgb3V0IGZyb20gdW5kZXIgdXMuCi0JCSAqLwotCQlyZXQgPSBfX2dldF91c2VyX3BhZ2VzKGN1cnJlbnQsIG1tLCBhZGRyLAotCQkJCW1pbl90KGludCwgbnJfcGFnZXMsIEFSUkFZX1NJWkUocGFnZXMpKSwKLQkJCQlndXBfZmxhZ3MsIHBhZ2VzLCBOVUxMKTsKLQkJLyoKLQkJICogVGhpcyBjYW4gaGFwcGVuIGZvciwgZS5nLiwgVk1fTk9OTElORUFSIHJlZ2lvbnMgYmVmb3JlCi0JCSAqIGEgcGFnZSBoYXMgYmVlbiBhbGxvY2F0ZWQgYW5kIG1hcHBlZCBhdCBhIGdpdmVuIG9mZnNldCwKLQkJICogb3IgZm9yIGFkZHJlc3NlcyB0aGF0IG1hcCBiZXlvbmQgZW5kIG9mIGEgZmlsZS4KLQkJICogV2UnbGwgbWxvY2sgdGhlIHBhZ2VzIGlmL3doZW4gdGhleSBnZXQgZmF1bHRlZCBpbi4KLQkJICovCi0JCWlmIChyZXQgPCAwKQotCQkJYnJlYWs7Ci0KLQkJbHJ1X2FkZF9kcmFpbigpOwkvKiBwdXNoIGNhY2hlZCBwYWdlcyB0byBMUlUgKi8KLQotCQlmb3IgKGkgPSAwOyBpIDwgcmV0OyBpKyspIHsKLQkJCXN0cnVjdCBwYWdlICpwYWdlID0gcGFnZXNbaV07Ci0KLQkJCWlmIChwYWdlLT5tYXBwaW5nKSB7Ci0JCQkJLyoKLQkJCQkgKiBUaGF0IHByZWxpbWluYXJ5IGNoZWNrIGlzIG1haW5seSB0byBhdm9pZAotCQkJCSAqIHRoZSBwb2ludGxlc3Mgb3ZlcmhlYWQgb2YgbG9ja19wYWdlIG9uIHRoZQotCQkJCSAqIFpFUk9fUEFHRTogd2hpY2ggbWlnaHQgYm91bmNlIHZlcnkgYmFkbHkgaWYKLQkJCQkgKiB0aGVyZSBpcyBjb250ZW50aW9uLiAgSG93ZXZlciwgd2UncmUgc3RpbGwKLQkJCQkgKiBkaXJ0eWluZyBpdHMgY2FjaGVsaW5lIHdpdGggZ2V0L3B1dF9wYWdlOgotCQkJCSAqIHdlJ2xsIGFkZCBhbm90aGVyIF9fZ2V0X3VzZXJfcGFnZXMgZmxhZyB0bwotCQkJCSAqIGF2b2lkIGl0IGlmIHRoYXQgY2FzZSB0dXJucyBvdXQgdG8gbWF0dGVyLgotCQkJCSAqLwotCQkJCWxvY2tfcGFnZShwYWdlKTsKLQkJCQkvKgotCQkJCSAqIEJlY2F1c2Ugd2UgbG9jayBwYWdlIGhlcmUgYW5kIG1pZ3JhdGlvbiBpcwotCQkJCSAqIGJsb2NrZWQgYnkgdGhlIGVsZXZhdGVkIHJlZmVyZW5jZSwgd2UgbmVlZAotCQkJCSAqIG9ubHkgY2hlY2sgZm9yIGZpbGUtY2FjaGUgcGFnZSB0cnVuY2F0aW9uLgotCQkJCSAqLwotCQkJCWlmIChwYWdlLT5tYXBwaW5nKQotCQkJCQltbG9ja192bWFfcGFnZShwYWdlKTsKLQkJCQl1bmxvY2tfcGFnZShwYWdlKTsKLQkJCX0KLQkJCXB1dF9wYWdlKHBhZ2UpOwkvKiByZWYgZnJvbSBnZXRfdXNlcl9wYWdlcygpICovCi0JCX0KLQotCQlhZGRyICs9IHJldCAqIFBBR0VfU0laRTsKLQkJbnJfcGFnZXMgLT0gcmV0OwotCQlyZXQgPSAwOwotCX0KLQotCXJldHVybiByZXQ7CS8qIDAgb3IgbmVnYXRpdmUgZXJyb3IgY29kZSAqLworCXJldHVybiBfX2dldF91c2VyX3BhZ2VzKGN1cnJlbnQsIG1tLCBhZGRyLCBucl9wYWdlcywgZ3VwX2ZsYWdzLAorCQkJCU5VTEwsIE5VTEwsIG5vbmJsb2NraW5nKTsKIH0KIAogLyoKQEAgLTI4MCw3ICsyMzksNyBAQAogCQkJaXNfdm1faHVnZXRsYl9wYWdlKHZtYSkgfHwKIAkJCXZtYSA9PSBnZXRfZ2F0ZV92bWEoY3VycmVudCkpKSB7CiAKLQkJX19tbG9ja192bWFfcGFnZXNfcmFuZ2Uodm1hLCBzdGFydCwgZW5kKTsKKwkJX19tbG9ja192bWFfcGFnZXNfcmFuZ2Uodm1hLCBzdGFydCwgZW5kLCBOVUxMKTsKIAogCQkvKiBIaWRlIGVycm9ycyBmcm9tIG1tYXAoKSBhbmQgb3RoZXIgY2FsbGVycyAqLwogCQlyZXR1cm4gMDsKQEAgLTM3MiwxOCArMzMxLDEwIEBACiAJaW50IHJldCA9IDA7CiAJaW50IGxvY2sgPSBuZXdmbGFncyAmIFZNX0xPQ0tFRDsKIAotCWlmIChuZXdmbGFncyA9PSB2bWEtPnZtX2ZsYWdzIHx8Ci0JCQkodm1hLT52bV9mbGFncyAmIChWTV9JTyB8IFZNX1BGTk1BUCkpKQorCWlmIChuZXdmbGFncyA9PSB2bWEtPnZtX2ZsYWdzIHx8ICh2bWEtPnZtX2ZsYWdzICYgVk1fU1BFQ0lBTCkgfHwKKwkgICAgaXNfdm1faHVnZXRsYl9wYWdlKHZtYSkgfHwgdm1hID09IGdldF9nYXRlX3ZtYShjdXJyZW50KSkKIAkJZ290byBvdXQ7CS8qIGRvbid0IHNldCBWTV9MT0NLRUQsICBkb24ndCBjb3VudCAqLwogCi0JaWYgKCh2bWEtPnZtX2ZsYWdzICYgKFZNX0RPTlRFWFBBTkQgfCBWTV9SRVNFUlZFRCkpIHx8Ci0JCQlpc192bV9odWdldGxiX3BhZ2Uodm1hKSB8fAotCQkJdm1hID09IGdldF9nYXRlX3ZtYShjdXJyZW50KSkgewotCQlpZiAobG9jaykKLQkJCW1ha2VfcGFnZXNfcHJlc2VudChzdGFydCwgZW5kKTsKLQkJZ290byBvdXQ7CS8qIGRvbid0IHNldCBWTV9MT0NLRUQsICBkb24ndCBjb3VudCAqLwotCX0KLQogCXBnb2ZmID0gdm1hLT52bV9wZ29mZiArICgoc3RhcnQgLSB2bWEtPnZtX3N0YXJ0KSA+PiBQQUdFX1NISUZUKTsKIAkqcHJldiA9IHZtYV9tZXJnZShtbSwgKnByZXYsIHN0YXJ0LCBlbmQsIG5ld2ZsYWdzLCB2bWEtPmFub25fdm1hLAogCQkJICB2bWEtPnZtX2ZpbGUsIHBnb2ZmLCB2bWFfcG9saWN5KHZtYSkpOwpAQCAtNDE5LDE0ICszNzAsMTAgQEAKIAkgKiBzZXQgVk1fTE9DS0VELCBfX21sb2NrX3ZtYV9wYWdlc19yYW5nZSB3aWxsIGJyaW5nIGl0IGJhY2suCiAJICovCiAKLQlpZiAobG9jaykgeworCWlmIChsb2NrKQogCQl2bWEtPnZtX2ZsYWdzID0gbmV3ZmxhZ3M7Ci0JCXJldCA9IF9fbWxvY2tfdm1hX3BhZ2VzX3JhbmdlKHZtYSwgc3RhcnQsIGVuZCk7Ci0JCWlmIChyZXQgPCAwKQotCQkJcmV0ID0gX19tbG9ja19wb3NpeF9lcnJvcl9yZXR1cm4ocmV0KTsKLQl9IGVsc2UgeworCWVsc2UKIAkJbXVubG9ja192bWFfcGFnZXNfcmFuZ2Uodm1hLCBzdGFydCwgZW5kKTsKLQl9CiAKIG91dDoKIAkqcHJldiA9IHZtYTsKQEAgLTQzOSw3ICszODYsOCBAQAogCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqIHZtYSwgKiBwcmV2OwogCWludCBlcnJvcjsKIAotCWxlbiA9IFBBR0VfQUxJR04obGVuKTsKKwlWTV9CVUdfT04oc3RhcnQgJiB+UEFHRV9NQVNLKTsKKwlWTV9CVUdfT04obGVuICE9IFBBR0VfQUxJR04obGVuKSk7CiAJZW5kID0gc3RhcnQgKyBsZW47CiAJaWYgKGVuZCA8IHN0YXJ0KQogCQlyZXR1cm4gLUVJTlZBTDsKQEAgLTQ4Miw2ICs0MzAsNjIgQEAKIAlyZXR1cm4gZXJyb3I7CiB9CiAKK3N0YXRpYyBpbnQgZG9fbWxvY2tfcGFnZXModW5zaWduZWQgbG9uZyBzdGFydCwgc2l6ZV90IGxlbiwgaW50IGlnbm9yZV9lcnJvcnMpCit7CisJc3RydWN0IG1tX3N0cnVjdCAqbW0gPSBjdXJyZW50LT5tbTsKKwl1bnNpZ25lZCBsb25nIGVuZCwgbnN0YXJ0LCBuZW5kOworCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hID0gTlVMTDsKKwlpbnQgbG9ja2VkID0gMDsKKwlpbnQgcmV0ID0gMDsKKworCVZNX0JVR19PTihzdGFydCAmIH5QQUdFX01BU0spOworCVZNX0JVR19PTihsZW4gIT0gUEFHRV9BTElHTihsZW4pKTsKKwllbmQgPSBzdGFydCArIGxlbjsKKworCWZvciAobnN0YXJ0ID0gc3RhcnQ7IG5zdGFydCA8IGVuZDsgbnN0YXJ0ID0gbmVuZCkgeworCQkvKgorCQkgKiBXZSB3YW50IHRvIGZhdWx0IGluIHBhZ2VzIGZvciBbbnN0YXJ0OyBlbmQpIGFkZHJlc3MgcmFuZ2UuCisJCSAqIEZpbmQgZmlyc3QgY29ycmVzcG9uZGluZyBWTUEuCisJCSAqLworCQlpZiAoIWxvY2tlZCkgeworCQkJbG9ja2VkID0gMTsKKwkJCWRvd25fcmVhZCgmbW0tPm1tYXBfc2VtKTsKKwkJCXZtYSA9IGZpbmRfdm1hKG1tLCBuc3RhcnQpOworCQl9IGVsc2UgaWYgKG5zdGFydCA+PSB2bWEtPnZtX2VuZCkKKwkJCXZtYSA9IHZtYS0+dm1fbmV4dDsKKwkJaWYgKCF2bWEgfHwgdm1hLT52bV9zdGFydCA+PSBlbmQpCisJCQlicmVhazsKKwkJLyoKKwkJICogU2V0IFtuc3RhcnQ7IG5lbmQpIHRvIGludGVyc2VjdGlvbiBvZiBkZXNpcmVkIGFkZHJlc3MKKwkJICogcmFuZ2Ugd2l0aCB0aGUgZmlyc3QgVk1BLiBBbHNvLCBza2lwIHVuZGVzaXJhYmxlIFZNQSB0eXBlcy4KKwkJICovCisJCW5lbmQgPSBtaW4oZW5kLCB2bWEtPnZtX2VuZCk7CisJCWlmICh2bWEtPnZtX2ZsYWdzICYgKFZNX0lPIHwgVk1fUEZOTUFQKSkKKwkJCWNvbnRpbnVlOworCQlpZiAobnN0YXJ0IDwgdm1hLT52bV9zdGFydCkKKwkJCW5zdGFydCA9IHZtYS0+dm1fc3RhcnQ7CisJCS8qCisJCSAqIE5vdyBmYXVsdCBpbiBhIHJhbmdlIG9mIHBhZ2VzLiBfX21sb2NrX3ZtYV9wYWdlc19yYW5nZSgpCisJCSAqIGRvdWJsZSBjaGVja3MgdGhlIHZtYSBmbGFncywgc28gdGhhdCBpdCB3b24ndCBtbG9jayBwYWdlcworCQkgKiBpZiB0aGUgdm1hIHdhcyBhbHJlYWR5IG11bmxvY2tlZC4KKwkJICovCisJCXJldCA9IF9fbWxvY2tfdm1hX3BhZ2VzX3JhbmdlKHZtYSwgbnN0YXJ0LCBuZW5kLCAmbG9ja2VkKTsKKwkJaWYgKHJldCA8IDApIHsKKwkJCWlmIChpZ25vcmVfZXJyb3JzKSB7CisJCQkJcmV0ID0gMDsKKwkJCQljb250aW51ZTsJLyogY29udGludWUgYXQgbmV4dCBWTUEgKi8KKwkJCX0KKwkJCXJldCA9IF9fbWxvY2tfcG9zaXhfZXJyb3JfcmV0dXJuKHJldCk7CisJCQlicmVhazsKKwkJfQorCQluZW5kID0gbnN0YXJ0ICsgcmV0ICogUEFHRV9TSVpFOworCQlyZXQgPSAwOworCX0KKwlpZiAobG9ja2VkKQorCQl1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOworCXJldHVybiByZXQ7CS8qIDAgb3IgbmVnYXRpdmUgZXJyb3IgY29kZSAqLworfQorCiBTWVNDQUxMX0RFRklORTIobWxvY2ssIHVuc2lnbmVkIGxvbmcsIHN0YXJ0LCBzaXplX3QsIGxlbikKIHsKIAl1bnNpZ25lZCBsb25nIGxvY2tlZDsKQEAgLTUwNyw2ICs1MTEsOCBAQAogCWlmICgobG9ja2VkIDw9IGxvY2tfbGltaXQpIHx8IGNhcGFibGUoQ0FQX0lQQ19MT0NLKSkKIAkJZXJyb3IgPSBkb19tbG9jayhzdGFydCwgbGVuLCAxKTsKIAl1cF93cml0ZSgmY3VycmVudC0+bW0tPm1tYXBfc2VtKTsKKwlpZiAoIWVycm9yKQorCQllcnJvciA9IGRvX21sb2NrX3BhZ2VzKHN0YXJ0LCBsZW4sIDApOwogCXJldHVybiBlcnJvcjsKIH0KIApAQCAtNTcxLDYgKzU3NywxMCBAQAogCSAgICBjYXBhYmxlKENBUF9JUENfTE9DSykpCiAJCXJldCA9IGRvX21sb2NrYWxsKGZsYWdzKTsKIAl1cF93cml0ZSgmY3VycmVudC0+bW0tPm1tYXBfc2VtKTsKKwlpZiAoIXJldCAmJiAoZmxhZ3MgJiBNQ0xfQ1VSUkVOVCkpIHsKKwkJLyogSWdub3JlIGVycm9ycyAqLworCQlkb19tbG9ja19wYWdlcygwLCBUQVNLX1NJWkUsIDEpOworCX0KIG91dDoKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0tZ2l0IGEvbW0vbW1hcC5jIGIvbW0vbW1hcC5jCmluZGV4IDUwYTRhYTAuLjJlYzhlYjUgMTAwNjQ0Ci0tLSBhL21tL21tYXAuYworKysgYi9tbS9tbWFwLmMKQEAgLTI5LDYgKzI5LDcgQEAKICNpbmNsdWRlIDxsaW51eC9tbXVfbm90aWZpZXIuaD4KICNpbmNsdWRlIDxsaW51eC9wZXJmX2V2ZW50Lmg+CiAjaW5jbHVkZSA8bGludXgvYXVkaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9raHVnZXBhZ2VkLmg+CiAKICNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgogI2luY2x1ZGUgPGFzbS9jYWNoZWZsdXNoLmg+CkBAIC0yNTMsNyArMjU0LDE1IEBACiAJZG93bl93cml0ZSgmbW0tPm1tYXBfc2VtKTsKIAogI2lmZGVmIENPTkZJR19DT01QQVRfQlJLCi0JbWluX2JyayA9IG1tLT5lbmRfY29kZTsKKwkvKgorCSAqIENPTkZJR19DT01QQVRfQlJLIGNhbiBzdGlsbCBiZSBvdmVycmlkZGVuIGJ5IHNldHRpbmcKKwkgKiByYW5kb21pemVfdmFfc3BhY2UgdG8gMiwgd2hpY2ggd2lsbCBzdGlsbCBjYXVzZSBtbS0+c3RhcnRfYnJrCisJICogdG8gYmUgYXJiaXRyYXJpbHkgc2hpZnRlZAorCSAqLworCWlmIChtbS0+c3RhcnRfYnJrID4gUEFHRV9BTElHTihtbS0+ZW5kX2RhdGEpKQorCQltaW5fYnJrID0gbW0tPnN0YXJ0X2JyazsKKwllbHNlCisJCW1pbl9icmsgPSBtbS0+ZW5kX2RhdGE7CiAjZWxzZQogCW1pbl9icmsgPSBtbS0+c3RhcnRfYnJrOwogI2VuZGlmCkBAIC01ODgsNiArNTk3LDggQEAKIAkJfQogCX0KIAorCXZtYV9hZGp1c3RfdHJhbnNfaHVnZSh2bWEsIHN0YXJ0LCBlbmQsIGFkanVzdF9uZXh0KTsKKwogCS8qCiAJICogV2hlbiBjaGFuZ2luZyBvbmx5IHZtYS0+dm1fZW5kLCB3ZSBkb24ndCByZWFsbHkgbmVlZCBhbm9uX3ZtYQogCSAqIGxvY2suIFRoaXMgaXMgYSBmYWlybHkgcmFyZSBjYXNlIGJ5IGl0c2VsZiwgYnV0IHRoZSBhbm9uX3ZtYQpAQCAtODE1LDYgKzgyNiw3IEBACiAJCQkJZW5kLCBwcmV2LT52bV9wZ29mZiwgTlVMTCk7CiAJCWlmIChlcnIpCiAJCQlyZXR1cm4gTlVMTDsKKwkJa2h1Z2VwYWdlZF9lbnRlcl92bWFfbWVyZ2UocHJldik7CiAJCXJldHVybiBwcmV2OwogCX0KIApAQCAtODMzLDYgKzg0NSw3IEBACiAJCQkJbmV4dC0+dm1fcGdvZmYgLSBwZ2xlbiwgTlVMTCk7CiAJCWlmIChlcnIpCiAJCQlyZXR1cm4gTlVMTDsKKwkJa2h1Z2VwYWdlZF9lbnRlcl92bWFfbWVyZ2UoYXJlYSk7CiAJCXJldHVybiBhcmVhOwogCX0KIApAQCAtMTc2MSw2ICsxNzc0LDcgQEAKIAkJfQogCX0KIAl2bWFfdW5sb2NrX2Fub25fdm1hKHZtYSk7CisJa2h1Z2VwYWdlZF9lbnRlcl92bWFfbWVyZ2Uodm1hKTsKIAlyZXR1cm4gZXJyb3I7CiB9CiAjZW5kaWYgLyogQ09ORklHX1NUQUNLX0dST1dTVVAgfHwgQ09ORklHX0lBNjQgKi8KQEAgLTE4MDgsNiArMTgyMiw3IEBACiAJCX0KIAl9CiAJdm1hX3VubG9ja19hbm9uX3ZtYSh2bWEpOworCWtodWdlcGFnZWRfZW50ZXJfdm1hX21lcmdlKHZtYSk7CiAJcmV0dXJuIGVycm9yOwogfQogCmRpZmYgLS1naXQgYS9tbS9tbXVfbm90aWZpZXIuYyBiL21tL21tdV9ub3RpZmllci5jCmluZGV4IDQzODk1MWQuLjhkMDMyZGUgMTAwNjQ0Ci0tLSBhL21tL21tdV9ub3RpZmllci5jCisrKyBiL21tL21tdV9ub3RpZmllci5jCkBAIC0xMDAsNiArMTAwLDI2IEBACiAJcmV0dXJuIHlvdW5nOwogfQogCitpbnQgX19tbXVfbm90aWZpZXJfdGVzdF95b3VuZyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgYWRkcmVzcykKK3sKKwlzdHJ1Y3QgbW11X25vdGlmaWVyICptbjsKKwlzdHJ1Y3QgaGxpc3Rfbm9kZSAqbjsKKwlpbnQgeW91bmcgPSAwOworCisJcmN1X3JlYWRfbG9jaygpOworCWhsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShtbiwgbiwgJm1tLT5tbXVfbm90aWZpZXJfbW0tPmxpc3QsIGhsaXN0KSB7CisJCWlmIChtbi0+b3BzLT50ZXN0X3lvdW5nKSB7CisJCQl5b3VuZyA9IG1uLT5vcHMtPnRlc3RfeW91bmcobW4sIG1tLCBhZGRyZXNzKTsKKwkJCWlmICh5b3VuZykKKwkJCQlicmVhazsKKwkJfQorCX0KKwlyY3VfcmVhZF91bmxvY2soKTsKKworCXJldHVybiB5b3VuZzsKK30KKwogdm9pZCBfX21tdV9ub3RpZmllcl9jaGFuZ2VfcHRlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCiAJCQkgICAgICAgcHRlX3QgcHRlKQogewpkaWZmIC0tZ2l0IGEvbW0vbW16b25lLmMgYi9tbS9tbXpvbmUuYwppbmRleCBlMzViZmI4Li5mNWI3ZDE3IDEwMDY0NAotLS0gYS9tbS9tbXpvbmUuYworKysgYi9tbS9tbXpvbmUuYwpAQCAtODcsMjQgKzg3LDMgQEAKIAlyZXR1cm4gMTsKIH0KICNlbmRpZiAvKiBDT05GSUdfQVJDSF9IQVNfSE9MRVNfTUVNT1JZTU9ERUwgKi8KLQotI2lmZGVmIENPTkZJR19TTVAKLS8qIENhbGxlZCB3aGVuIGEgbW9yZSBhY2N1cmF0ZSB2aWV3IG9mIE5SX0ZSRUVfUEFHRVMgaXMgbmVlZGVkICovCi11bnNpZ25lZCBsb25nIHpvbmVfbnJfZnJlZV9wYWdlcyhzdHJ1Y3Qgem9uZSAqem9uZSkKLXsKLQl1bnNpZ25lZCBsb25nIG5yX2ZyZWVfcGFnZXMgPSB6b25lX3BhZ2Vfc3RhdGUoem9uZSwgTlJfRlJFRV9QQUdFUyk7Ci0KLQkvKgotCSAqIFdoaWxlIGtzd2FwZCBpcyBhd2FrZSwgaXQgaXMgY29uc2lkZXJlZCB0aGUgem9uZSBpcyB1bmRlciBzb21lCi0JICogbWVtb3J5IHByZXNzdXJlLiBVbmRlciBwcmVzc3VyZSwgdGhlcmUgaXMgYSByaXNrIHRoYXQKLQkgKiBwZXItY3B1LWNvdW50ZXItZHJpZnQgd2lsbCBhbGxvdyB0aGUgbWluIHdhdGVybWFyayB0byBiZSBicmVhY2hlZAotCSAqIHBvdGVudGlhbGx5IGNhdXNpbmcgYSBsaXZlLWxvY2suIFdoaWxlIGtzd2FwZCBpcyBhd2FrZSBhbmQKLQkgKiBmcmVlIHBhZ2VzIGFyZSBsb3csIGdldCBhIGJldHRlciBlc3RpbWF0ZSBmb3IgZnJlZSBwYWdlcwotCSAqLwotCWlmIChucl9mcmVlX3BhZ2VzIDwgem9uZS0+cGVyY3B1X2RyaWZ0X21hcmsgJiYKLQkJCSF3YWl0cXVldWVfYWN0aXZlKCZ6b25lLT56b25lX3BnZGF0LT5rc3dhcGRfd2FpdCkpCi0JCXJldHVybiB6b25lX3BhZ2Vfc3RhdGVfc25hcHNob3Qoem9uZSwgTlJfRlJFRV9QQUdFUyk7Ci0KLQlyZXR1cm4gbnJfZnJlZV9wYWdlczsKLX0KLSNlbmRpZiAvKiBDT05GSUdfU01QICovCmRpZmYgLS1naXQgYS9tbS9tcHJvdGVjdC5jIGIvbW0vbXByb3RlY3QuYwppbmRleCA0YzUxMzM4Li41YTY4OGEyIDEwMDY0NAotLS0gYS9tbS9tcHJvdGVjdC5jCisrKyBiL21tL21wcm90ZWN0LmMKQEAgLTc4LDcgKzc4LDcgQEAKIAlwdGVfdW5tYXBfdW5sb2NrKHB0ZSAtIDEsIHB0bCk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgdm9pZCBjaGFuZ2VfcG1kX3JhbmdlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBwdWRfdCAqcHVkLAorc3RhdGljIGlubGluZSB2b2lkIGNoYW5nZV9wbWRfcmFuZ2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHB1ZF90ICpwdWQsCiAJCXVuc2lnbmVkIGxvbmcgYWRkciwgdW5zaWduZWQgbG9uZyBlbmQsIHBncHJvdF90IG5ld3Byb3QsCiAJCWludCBkaXJ0eV9hY2NvdW50YWJsZSkKIHsKQEAgLTg4LDEzICs4OCwyMSBAQAogCXBtZCA9IHBtZF9vZmZzZXQocHVkLCBhZGRyKTsKIAlkbyB7CiAJCW5leHQgPSBwbWRfYWRkcl9lbmQoYWRkciwgZW5kKTsKKwkJaWYgKHBtZF90cmFuc19odWdlKCpwbWQpKSB7CisJCQlpZiAobmV4dCAtIGFkZHIgIT0gSFBBR0VfUE1EX1NJWkUpCisJCQkJc3BsaXRfaHVnZV9wYWdlX3BtZCh2bWEtPnZtX21tLCBwbWQpOworCQkJZWxzZSBpZiAoY2hhbmdlX2h1Z2VfcG1kKHZtYSwgcG1kLCBhZGRyLCBuZXdwcm90KSkKKwkJCQljb250aW51ZTsKKwkJCS8qIGZhbGwgdGhyb3VnaCAqLworCQl9CiAJCWlmIChwbWRfbm9uZV9vcl9jbGVhcl9iYWQocG1kKSkKIAkJCWNvbnRpbnVlOwotCQljaGFuZ2VfcHRlX3JhbmdlKG1tLCBwbWQsIGFkZHIsIG5leHQsIG5ld3Byb3QsIGRpcnR5X2FjY291bnRhYmxlKTsKKwkJY2hhbmdlX3B0ZV9yYW5nZSh2bWEtPnZtX21tLCBwbWQsIGFkZHIsIG5leHQsIG5ld3Byb3QsCisJCQkJIGRpcnR5X2FjY291bnRhYmxlKTsKIAl9IHdoaWxlIChwbWQrKywgYWRkciA9IG5leHQsIGFkZHIgIT0gZW5kKTsKIH0KIAotc3RhdGljIGlubGluZSB2b2lkIGNoYW5nZV9wdWRfcmFuZ2Uoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHBnZF90ICpwZ2QsCitzdGF0aWMgaW5saW5lIHZvaWQgY2hhbmdlX3B1ZF9yYW5nZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgcGdkX3QgKnBnZCwKIAkJdW5zaWduZWQgbG9uZyBhZGRyLCB1bnNpZ25lZCBsb25nIGVuZCwgcGdwcm90X3QgbmV3cHJvdCwKIAkJaW50IGRpcnR5X2FjY291bnRhYmxlKQogewpAQCAtMTA2LDcgKzExNCw4IEBACiAJCW5leHQgPSBwdWRfYWRkcl9lbmQoYWRkciwgZW5kKTsKIAkJaWYgKHB1ZF9ub25lX29yX2NsZWFyX2JhZChwdWQpKQogCQkJY29udGludWU7Ci0JCWNoYW5nZV9wbWRfcmFuZ2UobW0sIHB1ZCwgYWRkciwgbmV4dCwgbmV3cHJvdCwgZGlydHlfYWNjb3VudGFibGUpOworCQljaGFuZ2VfcG1kX3JhbmdlKHZtYSwgcHVkLCBhZGRyLCBuZXh0LCBuZXdwcm90LAorCQkJCSBkaXJ0eV9hY2NvdW50YWJsZSk7CiAJfSB3aGlsZSAocHVkKyssIGFkZHIgPSBuZXh0LCBhZGRyICE9IGVuZCk7CiB9CiAKQEAgLTEyNiw3ICsxMzUsOCBAQAogCQluZXh0ID0gcGdkX2FkZHJfZW5kKGFkZHIsIGVuZCk7CiAJCWlmIChwZ2Rfbm9uZV9vcl9jbGVhcl9iYWQocGdkKSkKIAkJCWNvbnRpbnVlOwotCQljaGFuZ2VfcHVkX3JhbmdlKG1tLCBwZ2QsIGFkZHIsIG5leHQsIG5ld3Byb3QsIGRpcnR5X2FjY291bnRhYmxlKTsKKwkJY2hhbmdlX3B1ZF9yYW5nZSh2bWEsIHBnZCwgYWRkciwgbmV4dCwgbmV3cHJvdCwKKwkJCQkgZGlydHlfYWNjb3VudGFibGUpOwogCX0gd2hpbGUgKHBnZCsrLCBhZGRyID0gbmV4dCwgYWRkciAhPSBlbmQpOwogCWZsdXNoX3RsYl9yYW5nZSh2bWEsIHN0YXJ0LCBlbmQpOwogfQpkaWZmIC0tZ2l0IGEvbW0vbXJlbWFwLmMgYi9tbS9tcmVtYXAuYwppbmRleCA1NjNmYmRkLi45OTI1YjYzIDEwMDY0NAotLS0gYS9tbS9tcmVtYXAuYworKysgYi9tbS9tcmVtYXAuYwpAQCAtNDEsMTMgKzQxLDE1IEBACiAJCXJldHVybiBOVUxMOwogCiAJcG1kID0gcG1kX29mZnNldChwdWQsIGFkZHIpOworCXNwbGl0X2h1Z2VfcGFnZV9wbWQobW0sIHBtZCk7CiAJaWYgKHBtZF9ub25lX29yX2NsZWFyX2JhZChwbWQpKQogCQlyZXR1cm4gTlVMTDsKIAogCXJldHVybiBwbWQ7CiB9CiAKLXN0YXRpYyBwbWRfdCAqYWxsb2NfbmV3X3BtZChzdHJ1Y3QgbW1fc3RydWN0ICptbSwgdW5zaWduZWQgbG9uZyBhZGRyKQorc3RhdGljIHBtZF90ICphbGxvY19uZXdfcG1kKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCSAgICB1bnNpZ25lZCBsb25nIGFkZHIpCiB7CiAJcGdkX3QgKnBnZDsKIAlwdWRfdCAqcHVkOwpAQCAtNjIsNyArNjQsOCBAQAogCWlmICghcG1kKQogCQlyZXR1cm4gTlVMTDsKIAotCWlmICghcG1kX3ByZXNlbnQoKnBtZCkgJiYgX19wdGVfYWxsb2MobW0sIHBtZCwgYWRkcikpCisJVk1fQlVHX09OKHBtZF90cmFuc19odWdlKCpwbWQpKTsKKwlpZiAocG1kX25vbmUoKnBtZCkgJiYgX19wdGVfYWxsb2MobW0sIHZtYSwgcG1kLCBhZGRyKSkKIAkJcmV0dXJuIE5VTEw7CiAKIAlyZXR1cm4gcG1kOwpAQCAtMTQ3LDcgKzE1MCw3IEBACiAJCW9sZF9wbWQgPSBnZXRfb2xkX3BtZCh2bWEtPnZtX21tLCBvbGRfYWRkcik7CiAJCWlmICghb2xkX3BtZCkKIAkJCWNvbnRpbnVlOwotCQluZXdfcG1kID0gYWxsb2NfbmV3X3BtZCh2bWEtPnZtX21tLCBuZXdfYWRkcik7CisJCW5ld19wbWQgPSBhbGxvY19uZXdfcG1kKHZtYS0+dm1fbW0sIHZtYSwgbmV3X2FkZHIpOwogCQlpZiAoIW5ld19wbWQpCiAJCQlicmVhazsKIAkJbmV4dCA9IChuZXdfYWRkciArIFBNRF9TSVpFKSAmIFBNRF9NQVNLOwpkaWZmIC0tZ2l0IGEvbW0vbm9tbXUuYyBiL21tL25vbW11LmMKaW5kZXggZWY0MDQ1ZC4uZjU5ZTE0MiAxMDA2NDQKLS0tIGEvbW0vbm9tbXUuYworKysgYi9tbS9ub21tdS5jCkBAIC0xMjcsNyArMTI3LDggQEAKIAogaW50IF9fZ2V0X3VzZXJfcGFnZXMoc3RydWN0IHRhc2tfc3RydWN0ICp0c2ssIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAogCQkgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsIGludCBucl9wYWdlcywgdW5zaWduZWQgaW50IGZvbGxfZmxhZ3MsCi0JCSAgICAgc3RydWN0IHBhZ2UgKipwYWdlcywgc3RydWN0IHZtX2FyZWFfc3RydWN0ICoqdm1hcykKKwkJICAgICBzdHJ1Y3QgcGFnZSAqKnBhZ2VzLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKip2bWFzLAorCQkgICAgIGludCAqcmV0cnkpCiB7CiAJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWE7CiAJdW5zaWduZWQgbG9uZyB2bV9mbGFnczsKQEAgLTE4NSw3ICsxODYsOCBAQAogCWlmIChmb3JjZSkKIAkJZmxhZ3MgfD0gRk9MTF9GT1JDRTsKIAotCXJldHVybiBfX2dldF91c2VyX3BhZ2VzKHRzaywgbW0sIHN0YXJ0LCBucl9wYWdlcywgZmxhZ3MsIHBhZ2VzLCB2bWFzKTsKKwlyZXR1cm4gX19nZXRfdXNlcl9wYWdlcyh0c2ssIG1tLCBzdGFydCwgbnJfcGFnZXMsIGZsYWdzLCBwYWdlcywgdm1hcywKKwkJCQlOVUxMKTsKIH0KIEVYUE9SVF9TWU1CT0woZ2V0X3VzZXJfcGFnZXMpOwogCmRpZmYgLS1naXQgYS9tbS9wYWdlLXdyaXRlYmFjay5jIGIvbW0vcGFnZS13cml0ZWJhY2suYwppbmRleCBiNWQ4YTFmLi4yY2IwMWY2IDEwMDY0NAotLS0gYS9tbS9wYWdlLXdyaXRlYmFjay5jCisrKyBiL21tL3BhZ2Utd3JpdGViYWNrLmMKQEAgLTQxMCw5ICs0MTAsMTIgQEAKIHsKIAl1bnNpZ25lZCBsb25nIGJhY2tncm91bmQ7CiAJdW5zaWduZWQgbG9uZyBkaXJ0eTsKLQl1bnNpZ25lZCBsb25nIGF2YWlsYWJsZV9tZW1vcnkgPSBkZXRlcm1pbmVfZGlydHlhYmxlX21lbW9yeSgpOworCXVuc2lnbmVkIGxvbmcgdW5pbml0aWFsaXplZF92YXIoYXZhaWxhYmxlX21lbW9yeSk7CiAJc3RydWN0IHRhc2tfc3RydWN0ICp0c2s7CiAKKwlpZiAoIXZtX2RpcnR5X2J5dGVzIHx8ICFkaXJ0eV9iYWNrZ3JvdW5kX2J5dGVzKQorCQlhdmFpbGFibGVfbWVtb3J5ID0gZGV0ZXJtaW5lX2RpcnR5YWJsZV9tZW1vcnkoKTsKKwogCWlmICh2bV9kaXJ0eV9ieXRlcykKIAkJZGlydHkgPSBESVZfUk9VTkRfVVAodm1fZGlydHlfYnl0ZXMsIFBBR0VfU0laRSk7CiAJZWxzZQpAQCAtMTEwMyw3ICsxMTA2LDcgQEAKIGludCBfX3NldF9wYWdlX2RpcnR5X25vX3dyaXRlYmFjayhzdHJ1Y3QgcGFnZSAqcGFnZSkKIHsKIAlpZiAoIVBhZ2VEaXJ0eShwYWdlKSkKLQkJU2V0UGFnZURpcnR5KHBhZ2UpOworCQlyZXR1cm4gIVRlc3RTZXRQYWdlRGlydHkocGFnZSk7CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL21tL3BhZ2VfYWxsb2MuYyBiL21tL3BhZ2VfYWxsb2MuYwppbmRleCA4MjZiYTY5Li5hODczZTYxIDEwMDY0NAotLS0gYS9tbS9wYWdlX2FsbG9jLmMKKysrIGIvbW0vcGFnZV9hbGxvYy5jCkBAIC0zNTcsNiArMzU3LDcgQEAKIAl9CiB9CiAKKy8qIHVwZGF0ZSBfX3NwbGl0X2h1Z2VfcGFnZV9yZWZjb3VudCBpZiB5b3UgY2hhbmdlIHRoaXMgZnVuY3Rpb24gKi8KIHN0YXRpYyBpbnQgZGVzdHJveV9jb21wb3VuZF9wYWdlKHN0cnVjdCBwYWdlICpwYWdlLCB1bnNpZ25lZCBsb25nIG9yZGVyKQogewogCWludCBpOwpAQCAtNDI2LDE4ICs0MjcsMTAgQEAKICAqCiAgKiBBc3N1bXB0aW9uOiAqX21lbV9tYXAgaXMgY29udGlndW91cyBhdCBsZWFzdCB1cCB0byBNQVhfT1JERVIKICAqLwotc3RhdGljIGlubGluZSBzdHJ1Y3QgcGFnZSAqCi1fX3BhZ2VfZmluZF9idWRkeShzdHJ1Y3QgcGFnZSAqcGFnZSwgdW5zaWduZWQgbG9uZyBwYWdlX2lkeCwgdW5zaWduZWQgaW50IG9yZGVyKQotewotCXVuc2lnbmVkIGxvbmcgYnVkZHlfaWR4ID0gcGFnZV9pZHggXiAoMSA8PCBvcmRlcik7Ci0KLQlyZXR1cm4gcGFnZSArIChidWRkeV9pZHggLSBwYWdlX2lkeCk7Ci19Ci0KIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZwotX19maW5kX2NvbWJpbmVkX2luZGV4KHVuc2lnbmVkIGxvbmcgcGFnZV9pZHgsIHVuc2lnbmVkIGludCBvcmRlcikKK19fZmluZF9idWRkeV9pbmRleCh1bnNpZ25lZCBsb25nIHBhZ2VfaWR4LCB1bnNpZ25lZCBpbnQgb3JkZXIpCiB7Ci0JcmV0dXJuIChwYWdlX2lkeCAmIH4oMSA8PCBvcmRlcikpOworCXJldHVybiBwYWdlX2lkeCBeICgxIDw8IG9yZGVyKTsKIH0KIAogLyoKQEAgLTQ0OCw4ICs0NDEsOCBAQAogICogKGMpIGEgcGFnZSBhbmQgaXRzIGJ1ZGR5IGhhdmUgdGhlIHNhbWUgb3JkZXIgJiYKICAqIChkKSBhIHBhZ2UgYW5kIGl0cyBidWRkeSBhcmUgaW4gdGhlIHNhbWUgem9uZS4KICAqCi0gKiBGb3IgcmVjb3JkaW5nIHdoZXRoZXIgYSBwYWdlIGlzIGluIHRoZSBidWRkeSBzeXN0ZW0sIHdlIHVzZSBQR19idWRkeS4KLSAqIFNldHRpbmcsIGNsZWFyaW5nLCBhbmQgdGVzdGluZyBQR19idWRkeSBpcyBzZXJpYWxpemVkIGJ5IHpvbmUtPmxvY2suCisgKiBGb3IgcmVjb3JkaW5nIHdoZXRoZXIgYSBwYWdlIGlzIGluIHRoZSBidWRkeSBzeXN0ZW0sIHdlIHNldCAtPl9tYXBjb3VudCAtMi4KKyAqIFNldHRpbmcsIGNsZWFyaW5nLCBhbmQgdGVzdGluZyBfbWFwY291bnQgLTIgaXMgc2VyaWFsaXplZCBieSB6b25lLT5sb2NrLgogICoKICAqIEZvciByZWNvcmRpbmcgcGFnZSdzIG9yZGVyLCB3ZSB1c2UgcGFnZV9wcml2YXRlKHBhZ2UpLgogICovCkBAIC00ODIsNyArNDc1LDcgQEAKICAqIGFzIG5lY2Vzc2FyeSwgcGx1cyBzb21lIGFjY291bnRpbmcgbmVlZGVkIHRvIHBsYXkgbmljZWx5IHdpdGggb3RoZXIKICAqIHBhcnRzIG9mIHRoZSBWTSBzeXN0ZW0uCiAgKiBBdCBlYWNoIGxldmVsLCB3ZSBrZWVwIGEgbGlzdCBvZiBwYWdlcywgd2hpY2ggYXJlIGhlYWRzIG9mIGNvbnRpbnVvdXMKLSAqIGZyZWUgcGFnZXMgb2YgbGVuZ3RoIG9mICgxIDw8IG9yZGVyKSBhbmQgbWFya2VkIHdpdGggUEdfYnVkZHkuIFBhZ2UncworICogZnJlZSBwYWdlcyBvZiBsZW5ndGggb2YgKDEgPDwgb3JkZXIpIGFuZCBtYXJrZWQgd2l0aCBfbWFwY291bnQgLTIuIFBhZ2UncwogICogb3JkZXIgaXMgcmVjb3JkZWQgaW4gcGFnZV9wcml2YXRlKHBhZ2UpIGZpZWxkLgogICogU28gd2hlbiB3ZSBhcmUgYWxsb2NhdGluZyBvciBmcmVlaW5nIG9uZSwgd2UgY2FuIGRlcml2ZSB0aGUgc3RhdGUgb2YgdGhlCiAgKiBvdGhlci4gIFRoYXQgaXMsIGlmIHdlIGFsbG9jYXRlIGEgc21hbGwgYmxvY2ssIGFuZCBib3RoIHdlcmUgICAKQEAgLTQ5OSw2ICs0OTIsNyBAQAogewogCXVuc2lnbmVkIGxvbmcgcGFnZV9pZHg7CiAJdW5zaWduZWQgbG9uZyBjb21iaW5lZF9pZHg7CisJdW5zaWduZWQgbG9uZyB1bmluaXRpYWxpemVkX3ZhcihidWRkeV9pZHgpOwogCXN0cnVjdCBwYWdlICpidWRkeTsKIAogCWlmICh1bmxpa2VseShQYWdlQ29tcG91bmQocGFnZSkpKQpAQCAtNTEzLDcgKzUwNyw4IEBACiAJVk1fQlVHX09OKGJhZF9yYW5nZSh6b25lLCBwYWdlKSk7CiAKIAl3aGlsZSAob3JkZXIgPCBNQVhfT1JERVItMSkgewotCQlidWRkeSA9IF9fcGFnZV9maW5kX2J1ZGR5KHBhZ2UsIHBhZ2VfaWR4LCBvcmRlcik7CisJCWJ1ZGR5X2lkeCA9IF9fZmluZF9idWRkeV9pbmRleChwYWdlX2lkeCwgb3JkZXIpOworCQlidWRkeSA9IHBhZ2UgKyAoYnVkZHlfaWR4IC0gcGFnZV9pZHgpOwogCQlpZiAoIXBhZ2VfaXNfYnVkZHkocGFnZSwgYnVkZHksIG9yZGVyKSkKIAkJCWJyZWFrOwogCkBAIC01MjEsNyArNTE2LDcgQEAKIAkJbGlzdF9kZWwoJmJ1ZGR5LT5scnUpOwogCQl6b25lLT5mcmVlX2FyZWFbb3JkZXJdLm5yX2ZyZWUtLTsKIAkJcm12X3BhZ2Vfb3JkZXIoYnVkZHkpOwotCQljb21iaW5lZF9pZHggPSBfX2ZpbmRfY29tYmluZWRfaW5kZXgocGFnZV9pZHgsIG9yZGVyKTsKKwkJY29tYmluZWRfaWR4ID0gYnVkZHlfaWR4ICYgcGFnZV9pZHg7CiAJCXBhZ2UgPSBwYWdlICsgKGNvbWJpbmVkX2lkeCAtIHBhZ2VfaWR4KTsKIAkJcGFnZV9pZHggPSBjb21iaW5lZF9pZHg7CiAJCW9yZGVyKys7CkBAIC01MzgsOSArNTMzLDEwIEBACiAJICovCiAJaWYgKChvcmRlciA8IE1BWF9PUkRFUi0yKSAmJiBwZm5fdmFsaWRfd2l0aGluKHBhZ2VfdG9fcGZuKGJ1ZGR5KSkpIHsKIAkJc3RydWN0IHBhZ2UgKmhpZ2hlcl9wYWdlLCAqaGlnaGVyX2J1ZGR5OwotCQljb21iaW5lZF9pZHggPSBfX2ZpbmRfY29tYmluZWRfaW5kZXgocGFnZV9pZHgsIG9yZGVyKTsKLQkJaGlnaGVyX3BhZ2UgPSBwYWdlICsgY29tYmluZWRfaWR4IC0gcGFnZV9pZHg7Ci0JCWhpZ2hlcl9idWRkeSA9IF9fcGFnZV9maW5kX2J1ZGR5KGhpZ2hlcl9wYWdlLCBjb21iaW5lZF9pZHgsIG9yZGVyICsgMSk7CisJCWNvbWJpbmVkX2lkeCA9IGJ1ZGR5X2lkeCAmIHBhZ2VfaWR4OworCQloaWdoZXJfcGFnZSA9IHBhZ2UgKyAoY29tYmluZWRfaWR4IC0gcGFnZV9pZHgpOworCQlidWRkeV9pZHggPSBfX2ZpbmRfYnVkZHlfaW5kZXgoY29tYmluZWRfaWR4LCBvcmRlciArIDEpOworCQloaWdoZXJfYnVkZHkgPSBwYWdlICsgKGJ1ZGR5X2lkeCAtIGNvbWJpbmVkX2lkeCk7CiAJCWlmIChwYWdlX2lzX2J1ZGR5KGhpZ2hlcl9wYWdlLCBoaWdoZXJfYnVkZHksIG9yZGVyICsgMSkpIHsKIAkJCWxpc3RfYWRkX3RhaWwoJnBhZ2UtPmxydSwKIAkJCQkmem9uZS0+ZnJlZV9hcmVhW29yZGVyXS5mcmVlX2xpc3RbbWlncmF0ZXR5cGVdKTsKQEAgLTY1MSwxMyArNjQ3LDEwIEBACiAJdHJhY2VfbW1fcGFnZV9mcmVlX2RpcmVjdChwYWdlLCBvcmRlcik7CiAJa21lbWNoZWNrX2ZyZWVfc2hhZG93KHBhZ2UsIG9yZGVyKTsKIAotCWZvciAoaSA9IDA7IGkgPCAoMSA8PCBvcmRlcik7IGkrKykgewotCQlzdHJ1Y3QgcGFnZSAqcGcgPSBwYWdlICsgaTsKLQotCQlpZiAoUGFnZUFub24ocGcpKQotCQkJcGctPm1hcHBpbmcgPSBOVUxMOwotCQliYWQgKz0gZnJlZV9wYWdlc19jaGVjayhwZyk7Ci0JfQorCWlmIChQYWdlQW5vbihwYWdlKSkKKwkJcGFnZS0+bWFwcGluZyA9IE5VTEw7CisJZm9yIChpID0gMDsgaSA8ICgxIDw8IG9yZGVyKTsgaSsrKQorCQliYWQgKz0gZnJlZV9wYWdlc19jaGVjayhwYWdlICsgaSk7CiAJaWYgKGJhZCkKIAkJcmV0dXJuIGZhbHNlOwogCkBAIC0xMDk1LDggKzEwODgsMTAgQEAKIAkJcHNldCA9IHBlcl9jcHVfcHRyKHpvbmUtPnBhZ2VzZXQsIGNwdSk7CiAKIAkJcGNwID0gJnBzZXQtPnBjcDsKLQkJZnJlZV9wY3BwYWdlc19idWxrKHpvbmUsIHBjcC0+Y291bnQsIHBjcCk7Ci0JCXBjcC0+Y291bnQgPSAwOworCQlpZiAocGNwLT5jb3VudCkgeworCQkJZnJlZV9wY3BwYWdlc19idWxrKHpvbmUsIHBjcC0+Y291bnQsIHBjcCk7CisJCQlwY3AtPmNvdW50ID0gMDsKKwkJfQogCQlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CiAJfQogfQpAQCAtMTQ2MCwyNCArMTQ1NSwyNCBAQAogI2VuZGlmIC8qIENPTkZJR19GQUlMX1BBR0VfQUxMT0MgKi8KIAogLyoKLSAqIFJldHVybiAxIGlmIGZyZWUgcGFnZXMgYXJlIGFib3ZlICdtYXJrJy4gVGhpcyB0YWtlcyBpbnRvIGFjY291bnQgdGhlIG9yZGVyCisgKiBSZXR1cm4gdHJ1ZSBpZiBmcmVlIHBhZ2VzIGFyZSBhYm92ZSAnbWFyaycuIFRoaXMgdGFrZXMgaW50byBhY2NvdW50IHRoZSBvcmRlcgogICogb2YgdGhlIGFsbG9jYXRpb24uCiAgKi8KLWludCB6b25lX3dhdGVybWFya19vayhzdHJ1Y3Qgem9uZSAqeiwgaW50IG9yZGVyLCB1bnNpZ25lZCBsb25nIG1hcmssCi0JCSAgICAgIGludCBjbGFzc3pvbmVfaWR4LCBpbnQgYWxsb2NfZmxhZ3MpCitzdGF0aWMgYm9vbCBfX3pvbmVfd2F0ZXJtYXJrX29rKHN0cnVjdCB6b25lICp6LCBpbnQgb3JkZXIsIHVuc2lnbmVkIGxvbmcgbWFyaywKKwkJICAgICAgaW50IGNsYXNzem9uZV9pZHgsIGludCBhbGxvY19mbGFncywgbG9uZyBmcmVlX3BhZ2VzKQogewogCS8qIGZyZWVfcGFnZXMgbXkgZ28gbmVnYXRpdmUgLSB0aGF0J3MgT0sgKi8KIAlsb25nIG1pbiA9IG1hcms7Ci0JbG9uZyBmcmVlX3BhZ2VzID0gem9uZV9ucl9mcmVlX3BhZ2VzKHopIC0gKDEgPDwgb3JkZXIpICsgMTsKIAlpbnQgbzsKIAorCWZyZWVfcGFnZXMgLT0gKDEgPDwgb3JkZXIpICsgMTsKIAlpZiAoYWxsb2NfZmxhZ3MgJiBBTExPQ19ISUdIKQogCQltaW4gLT0gbWluIC8gMjsKIAlpZiAoYWxsb2NfZmxhZ3MgJiBBTExPQ19IQVJERVIpCiAJCW1pbiAtPSBtaW4gLyA0OwogCiAJaWYgKGZyZWVfcGFnZXMgPD0gbWluICsgei0+bG93bWVtX3Jlc2VydmVbY2xhc3N6b25lX2lkeF0pCi0JCXJldHVybiAwOworCQlyZXR1cm4gZmFsc2U7CiAJZm9yIChvID0gMDsgbyA8IG9yZGVyOyBvKyspIHsKIAkJLyogQXQgdGhlIG5leHQgb3JkZXIsIHRoaXMgb3JkZXIncyBwYWdlcyBiZWNvbWUgdW5hdmFpbGFibGUgKi8KIAkJZnJlZV9wYWdlcyAtPSB6LT5mcmVlX2FyZWFbb10ubnJfZnJlZSA8PCBvOwpAQCAtMTQ4Niw5ICsxNDgxLDI4IEBACiAJCW1pbiA+Pj0gMTsKIAogCQlpZiAoZnJlZV9wYWdlcyA8PSBtaW4pCi0JCQlyZXR1cm4gMDsKKwkJCXJldHVybiBmYWxzZTsKIAl9Ci0JcmV0dXJuIDE7CisJcmV0dXJuIHRydWU7Cit9CisKK2Jvb2wgem9uZV93YXRlcm1hcmtfb2soc3RydWN0IHpvbmUgKnosIGludCBvcmRlciwgdW5zaWduZWQgbG9uZyBtYXJrLAorCQkgICAgICBpbnQgY2xhc3N6b25lX2lkeCwgaW50IGFsbG9jX2ZsYWdzKQoreworCXJldHVybiBfX3pvbmVfd2F0ZXJtYXJrX29rKHosIG9yZGVyLCBtYXJrLCBjbGFzc3pvbmVfaWR4LCBhbGxvY19mbGFncywKKwkJCQkJem9uZV9wYWdlX3N0YXRlKHosIE5SX0ZSRUVfUEFHRVMpKTsKK30KKworYm9vbCB6b25lX3dhdGVybWFya19va19zYWZlKHN0cnVjdCB6b25lICp6LCBpbnQgb3JkZXIsIHVuc2lnbmVkIGxvbmcgbWFyaywKKwkJICAgICAgaW50IGNsYXNzem9uZV9pZHgsIGludCBhbGxvY19mbGFncykKK3sKKwlsb25nIGZyZWVfcGFnZXMgPSB6b25lX3BhZ2Vfc3RhdGUoeiwgTlJfRlJFRV9QQUdFUyk7CisKKwlpZiAoei0+cGVyY3B1X2RyaWZ0X21hcmsgJiYgZnJlZV9wYWdlcyA8IHotPnBlcmNwdV9kcmlmdF9tYXJrKQorCQlmcmVlX3BhZ2VzID0gem9uZV9wYWdlX3N0YXRlX3NuYXBzaG90KHosIE5SX0ZSRUVfUEFHRVMpOworCisJcmV0dXJuIF9fem9uZV93YXRlcm1hcmtfb2soeiwgb3JkZXIsIG1hcmssIGNsYXNzem9uZV9pZHgsIGFsbG9jX2ZsYWdzLAorCQkJCQkJCQlmcmVlX3BhZ2VzKTsKIH0KIAogI2lmZGVmIENPTkZJR19OVU1BCkBAIC0xNzkzLDE1ICsxODA3LDE4IEBACiBfX2FsbG9jX3BhZ2VzX2RpcmVjdF9jb21wYWN0KGdmcF90IGdmcF9tYXNrLCB1bnNpZ25lZCBpbnQgb3JkZXIsCiAJc3RydWN0IHpvbmVsaXN0ICp6b25lbGlzdCwgZW51bSB6b25lX3R5cGUgaGlnaF96b25laWR4LAogCW5vZGVtYXNrX3QgKm5vZGVtYXNrLCBpbnQgYWxsb2NfZmxhZ3MsIHN0cnVjdCB6b25lICpwcmVmZXJyZWRfem9uZSwKLQlpbnQgbWlncmF0ZXR5cGUsIHVuc2lnbmVkIGxvbmcgKmRpZF9zb21lX3Byb2dyZXNzKQorCWludCBtaWdyYXRldHlwZSwgdW5zaWduZWQgbG9uZyAqZGlkX3NvbWVfcHJvZ3Jlc3MsCisJYm9vbCBzeW5jX21pZ3JhdGlvbikKIHsKIAlzdHJ1Y3QgcGFnZSAqcGFnZTsKIAogCWlmICghb3JkZXIgfHwgY29tcGFjdGlvbl9kZWZlcnJlZChwcmVmZXJyZWRfem9uZSkpCiAJCXJldHVybiBOVUxMOwogCisJY3VycmVudC0+ZmxhZ3MgfD0gUEZfTUVNQUxMT0M7CiAJKmRpZF9zb21lX3Byb2dyZXNzID0gdHJ5X3RvX2NvbXBhY3RfcGFnZXMoem9uZWxpc3QsIG9yZGVyLCBnZnBfbWFzaywKLQkJCQkJCQkJbm9kZW1hc2spOworCQkJCQkJbm9kZW1hc2ssIHN5bmNfbWlncmF0aW9uKTsKKwljdXJyZW50LT5mbGFncyAmPSB+UEZfTUVNQUxMT0M7CiAJaWYgKCpkaWRfc29tZV9wcm9ncmVzcyAhPSBDT01QQUNUX1NLSVBQRUQpIHsKIAogCQkvKiBQYWdlIG1pZ3JhdGlvbiBmcmVlcyB0byB0aGUgUENQIGxpc3RzIGJ1dCB3ZSB3YW50IG1lcmdpbmcgKi8KQEAgLTE4MzcsNyArMTg1NCw4IEBACiBfX2FsbG9jX3BhZ2VzX2RpcmVjdF9jb21wYWN0KGdmcF90IGdmcF9tYXNrLCB1bnNpZ25lZCBpbnQgb3JkZXIsCiAJc3RydWN0IHpvbmVsaXN0ICp6b25lbGlzdCwgZW51bSB6b25lX3R5cGUgaGlnaF96b25laWR4LAogCW5vZGVtYXNrX3QgKm5vZGVtYXNrLCBpbnQgYWxsb2NfZmxhZ3MsIHN0cnVjdCB6b25lICpwcmVmZXJyZWRfem9uZSwKLQlpbnQgbWlncmF0ZXR5cGUsIHVuc2lnbmVkIGxvbmcgKmRpZF9zb21lX3Byb2dyZXNzKQorCWludCBtaWdyYXRldHlwZSwgdW5zaWduZWQgbG9uZyAqZGlkX3NvbWVfcHJvZ3Jlc3MsCisJYm9vbCBzeW5jX21pZ3JhdGlvbikKIHsKIAlyZXR1cm4gTlVMTDsKIH0KQEAgLTE4NTIsMjMgKzE4NzAsMjIgQEAKIHsKIAlzdHJ1Y3QgcGFnZSAqcGFnZSA9IE5VTEw7CiAJc3RydWN0IHJlY2xhaW1fc3RhdGUgcmVjbGFpbV9zdGF0ZTsKLQlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAgPSBjdXJyZW50OwogCWJvb2wgZHJhaW5lZCA9IGZhbHNlOwogCiAJY29uZF9yZXNjaGVkKCk7CiAKIAkvKiBXZSBub3cgZ28gaW50byBzeW5jaHJvbm91cyByZWNsYWltICovCiAJY3B1c2V0X21lbW9yeV9wcmVzc3VyZV9idW1wKCk7Ci0JcC0+ZmxhZ3MgfD0gUEZfTUVNQUxMT0M7CisJY3VycmVudC0+ZmxhZ3MgfD0gUEZfTUVNQUxMT0M7CiAJbG9ja2RlcF9zZXRfY3VycmVudF9yZWNsYWltX3N0YXRlKGdmcF9tYXNrKTsKIAlyZWNsYWltX3N0YXRlLnJlY2xhaW1lZF9zbGFiID0gMDsKLQlwLT5yZWNsYWltX3N0YXRlID0gJnJlY2xhaW1fc3RhdGU7CisJY3VycmVudC0+cmVjbGFpbV9zdGF0ZSA9ICZyZWNsYWltX3N0YXRlOwogCiAJKmRpZF9zb21lX3Byb2dyZXNzID0gdHJ5X3RvX2ZyZWVfcGFnZXMoem9uZWxpc3QsIG9yZGVyLCBnZnBfbWFzaywgbm9kZW1hc2spOwogCi0JcC0+cmVjbGFpbV9zdGF0ZSA9IE5VTEw7CisJY3VycmVudC0+cmVjbGFpbV9zdGF0ZSA9IE5VTEw7CiAJbG9ja2RlcF9jbGVhcl9jdXJyZW50X3JlY2xhaW1fc3RhdGUoKTsKLQlwLT5mbGFncyAmPSB+UEZfTUVNQUxMT0M7CisJY3VycmVudC0+ZmxhZ3MgJj0gflBGX01FTUFMTE9DOwogCiAJY29uZF9yZXNjaGVkKCk7CiAKQEAgLTE5MjAsMTkgKzE5MzcsMTkgQEAKIAogc3RhdGljIGlubGluZQogdm9pZCB3YWtlX2FsbF9rc3dhcGQodW5zaWduZWQgaW50IG9yZGVyLCBzdHJ1Y3Qgem9uZWxpc3QgKnpvbmVsaXN0LAotCQkJCQkJZW51bSB6b25lX3R5cGUgaGlnaF96b25laWR4KQorCQkJCQkJZW51bSB6b25lX3R5cGUgaGlnaF96b25laWR4LAorCQkJCQkJZW51bSB6b25lX3R5cGUgY2xhc3N6b25lX2lkeCkKIHsKIAlzdHJ1Y3Qgem9uZXJlZiAqejsKIAlzdHJ1Y3Qgem9uZSAqem9uZTsKIAogCWZvcl9lYWNoX3pvbmVfem9uZWxpc3Qoem9uZSwgeiwgem9uZWxpc3QsIGhpZ2hfem9uZWlkeCkKLQkJd2FrZXVwX2tzd2FwZCh6b25lLCBvcmRlcik7CisJCXdha2V1cF9rc3dhcGQoem9uZSwgb3JkZXIsIGNsYXNzem9uZV9pZHgpOwogfQogCiBzdGF0aWMgaW5saW5lIGludAogZ2ZwX3RvX2FsbG9jX2ZsYWdzKGdmcF90IGdmcF9tYXNrKQogewotCXN0cnVjdCB0YXNrX3N0cnVjdCAqcCA9IGN1cnJlbnQ7CiAJaW50IGFsbG9jX2ZsYWdzID0gQUxMT0NfV01BUktfTUlOIHwgQUxMT0NfQ1BVU0VUOwogCWNvbnN0IGdmcF90IHdhaXQgPSBnZnBfbWFzayAmIF9fR0ZQX1dBSVQ7CiAKQEAgLTE5NDgsMTggKzE5NjUsMjMgQEAKIAlhbGxvY19mbGFncyB8PSAoX19mb3JjZSBpbnQpIChnZnBfbWFzayAmIF9fR0ZQX0hJR0gpOwogCiAJaWYgKCF3YWl0KSB7Ci0JCWFsbG9jX2ZsYWdzIHw9IEFMTE9DX0hBUkRFUjsKKwkJLyoKKwkJICogTm90IHdvcnRoIHRyeWluZyB0byBhbGxvY2F0ZSBoYXJkZXIgZm9yCisJCSAqIF9fR0ZQX05PTUVNQUxMT0MgZXZlbiBpZiBpdCBjYW4ndCBzY2hlZHVsZS4KKwkJICovCisJCWlmICAoIShnZnBfbWFzayAmIF9fR0ZQX05PTUVNQUxMT0MpKQorCQkJYWxsb2NfZmxhZ3MgfD0gQUxMT0NfSEFSREVSOwogCQkvKgogCQkgKiBJZ25vcmUgY3B1c2V0IGlmIEdGUF9BVE9NSUMgKCF3YWl0KSByYXRoZXIgdGhhbiBmYWlsIGFsbG9jLgogCQkgKiBTZWUgYWxzbyBjcHVzZXRfem9uZV9hbGxvd2VkKCkgY29tbWVudCBpbiBrZXJuZWwvY3B1c2V0LmMuCiAJCSAqLwogCQlhbGxvY19mbGFncyAmPSB+QUxMT0NfQ1BVU0VUOwotCX0gZWxzZSBpZiAodW5saWtlbHkocnRfdGFzayhwKSkgJiYgIWluX2ludGVycnVwdCgpKQorCX0gZWxzZSBpZiAodW5saWtlbHkocnRfdGFzayhjdXJyZW50KSkgJiYgIWluX2ludGVycnVwdCgpKQogCQlhbGxvY19mbGFncyB8PSBBTExPQ19IQVJERVI7CiAKIAlpZiAobGlrZWx5KCEoZ2ZwX21hc2sgJiBfX0dGUF9OT01FTUFMTE9DKSkpIHsKIAkJaWYgKCFpbl9pbnRlcnJ1cHQoKSAmJgotCQkgICAgKChwLT5mbGFncyAmIFBGX01FTUFMTE9DKSB8fAorCQkgICAgKChjdXJyZW50LT5mbGFncyAmIFBGX01FTUFMTE9DKSB8fAogCQkgICAgIHVubGlrZWx5KHRlc3RfdGhyZWFkX2ZsYWcoVElGX01FTURJRSkpKSkKIAkJCWFsbG9jX2ZsYWdzIHw9IEFMTE9DX05PX1dBVEVSTUFSS1M7CiAJfQpAQCAtMTk3OCw3ICsyMDAwLDcgQEAKIAlpbnQgYWxsb2NfZmxhZ3M7CiAJdW5zaWduZWQgbG9uZyBwYWdlc19yZWNsYWltZWQgPSAwOwogCXVuc2lnbmVkIGxvbmcgZGlkX3NvbWVfcHJvZ3Jlc3M7Ci0Jc3RydWN0IHRhc2tfc3RydWN0ICpwID0gY3VycmVudDsKKwlib29sIHN5bmNfbWlncmF0aW9uID0gZmFsc2U7CiAKIAkvKgogCSAqIEluIHRoZSBzbG93cGF0aCwgd2Ugc2FuaXR5IGNoZWNrIG9yZGVyIHRvIGF2b2lkIGV2ZXIgdHJ5aW5nIHRvCkBAIC0yMDAzLDcgKzIwMjUsOSBAQAogCQlnb3RvIG5vcGFnZTsKIAogcmVzdGFydDoKLQl3YWtlX2FsbF9rc3dhcGQob3JkZXIsIHpvbmVsaXN0LCBoaWdoX3pvbmVpZHgpOworCWlmICghKGdmcF9tYXNrICYgX19HRlBfTk9fS1NXQVBEKSkKKwkJd2FrZV9hbGxfa3N3YXBkKG9yZGVyLCB6b25lbGlzdCwgaGlnaF96b25laWR4LAorCQkJCQkJem9uZV9pZHgocHJlZmVycmVkX3pvbmUpKTsKIAogCS8qCiAJICogT0ssIHdlJ3JlIGJlbG93IHRoZSBrc3dhcGQgd2F0ZXJtYXJrIGFuZCBoYXZlIGtpY2tlZCBiYWNrZ3JvdW5kCkBAIC0yMDEyLDYgKzIwMzYsMTQgQEAKIAkgKi8KIAlhbGxvY19mbGFncyA9IGdmcF90b19hbGxvY19mbGFncyhnZnBfbWFzayk7CiAKKwkvKgorCSAqIEZpbmQgdGhlIHRydWUgcHJlZmVycmVkIHpvbmUgaWYgdGhlIGFsbG9jYXRpb24gaXMgdW5jb25zdHJhaW5lZCBieQorCSAqIGNwdXNldHMuCisJICovCisJaWYgKCEoYWxsb2NfZmxhZ3MgJiBBTExPQ19DUFVTRVQpICYmICFub2RlbWFzaykKKwkJZmlyc3Rfem9uZXNfem9uZWxpc3Qoem9uZWxpc3QsIGhpZ2hfem9uZWlkeCwgTlVMTCwKKwkJCQkJJnByZWZlcnJlZF96b25lKTsKKwogCS8qIFRoaXMgaXMgdGhlIGxhc3QgY2hhbmNlLCBpbiBnZW5lcmFsLCBiZWZvcmUgdGhlIGdvdG8gbm9wYWdlLiAqLwogCXBhZ2UgPSBnZXRfcGFnZV9mcm9tX2ZyZWVsaXN0KGdmcF9tYXNrLCBub2RlbWFzaywgb3JkZXIsIHpvbmVsaXN0LAogCQkJaGlnaF96b25laWR4LCBhbGxvY19mbGFncyAmIH5BTExPQ19OT19XQVRFUk1BUktTLApAQCAtMjAzNCwyMSArMjA2NiwyNiBAQAogCQlnb3RvIG5vcGFnZTsKIAogCS8qIEF2b2lkIHJlY3Vyc2lvbiBvZiBkaXJlY3QgcmVjbGFpbSAqLwotCWlmIChwLT5mbGFncyAmIFBGX01FTUFMTE9DKQorCWlmIChjdXJyZW50LT5mbGFncyAmIFBGX01FTUFMTE9DKQogCQlnb3RvIG5vcGFnZTsKIAogCS8qIEF2b2lkIGFsbG9jYXRpb25zIHdpdGggbm8gd2F0ZXJtYXJrcyBmcm9tIGxvb3BpbmcgZW5kbGVzc2x5ICovCiAJaWYgKHRlc3RfdGhyZWFkX2ZsYWcoVElGX01FTURJRSkgJiYgIShnZnBfbWFzayAmIF9fR0ZQX05PRkFJTCkpCiAJCWdvdG8gbm9wYWdlOwogCi0JLyogVHJ5IGRpcmVjdCBjb21wYWN0aW9uICovCisJLyoKKwkgKiBUcnkgZGlyZWN0IGNvbXBhY3Rpb24uIFRoZSBmaXJzdCBwYXNzIGlzIGFzeW5jaHJvbm91cy4gU3Vic2VxdWVudAorCSAqIGF0dGVtcHRzIGFmdGVyIGRpcmVjdCByZWNsYWltIGFyZSBzeW5jaHJvbm91cworCSAqLwogCXBhZ2UgPSBfX2FsbG9jX3BhZ2VzX2RpcmVjdF9jb21wYWN0KGdmcF9tYXNrLCBvcmRlciwKIAkJCQkJem9uZWxpc3QsIGhpZ2hfem9uZWlkeCwKIAkJCQkJbm9kZW1hc2ssCiAJCQkJCWFsbG9jX2ZsYWdzLCBwcmVmZXJyZWRfem9uZSwKLQkJCQkJbWlncmF0ZXR5cGUsICZkaWRfc29tZV9wcm9ncmVzcyk7CisJCQkJCW1pZ3JhdGV0eXBlLCAmZGlkX3NvbWVfcHJvZ3Jlc3MsCisJCQkJCXN5bmNfbWlncmF0aW9uKTsKIAlpZiAocGFnZSkKIAkJZ290byBnb3RfcGc7CisJc3luY19taWdyYXRpb24gPSB0cnVlOwogCiAJLyogVHJ5IGRpcmVjdCByZWNsYWltIGFuZCB0aGVuIGFsbG9jYXRpbmcgKi8KIAlwYWdlID0gX19hbGxvY19wYWdlc19kaXJlY3RfcmVjbGFpbShnZnBfbWFzaywgb3JkZXIsCkBAIC0yMTAyLDEzICsyMTM5LDI3IEBACiAJCS8qIFdhaXQgZm9yIHNvbWUgd3JpdGUgcmVxdWVzdHMgdG8gY29tcGxldGUgdGhlbiByZXRyeSAqLwogCQl3YWl0X2lmZl9jb25nZXN0ZWQocHJlZmVycmVkX3pvbmUsIEJMS19SV19BU1lOQywgSFovNTApOwogCQlnb3RvIHJlYmFsYW5jZTsKKwl9IGVsc2UgeworCQkvKgorCQkgKiBIaWdoLW9yZGVyIGFsbG9jYXRpb25zIGRvIG5vdCBuZWNlc3NhcmlseSBsb29wIGFmdGVyCisJCSAqIGRpcmVjdCByZWNsYWltIGFuZCByZWNsYWltL2NvbXBhY3Rpb24gZGVwZW5kcyBvbiBjb21wYWN0aW9uCisJCSAqIGJlaW5nIGNhbGxlZCBhZnRlciByZWNsYWltIHNvIGNhbGwgZGlyZWN0bHkgaWYgbmVjZXNzYXJ5CisJCSAqLworCQlwYWdlID0gX19hbGxvY19wYWdlc19kaXJlY3RfY29tcGFjdChnZnBfbWFzaywgb3JkZXIsCisJCQkJCXpvbmVsaXN0LCBoaWdoX3pvbmVpZHgsCisJCQkJCW5vZGVtYXNrLAorCQkJCQlhbGxvY19mbGFncywgcHJlZmVycmVkX3pvbmUsCisJCQkJCW1pZ3JhdGV0eXBlLCAmZGlkX3NvbWVfcHJvZ3Jlc3MsCisJCQkJCXN5bmNfbWlncmF0aW9uKTsKKwkJaWYgKHBhZ2UpCisJCQlnb3RvIGdvdF9wZzsKIAl9CiAKIG5vcGFnZToKIAlpZiAoIShnZnBfbWFzayAmIF9fR0ZQX05PV0FSTikgJiYgcHJpbnRrX3JhdGVsaW1pdCgpKSB7CiAJCXByaW50ayhLRVJOX1dBUk5JTkcgIiVzOiBwYWdlIGFsbG9jYXRpb24gZmFpbHVyZS4iCiAJCQkiIG9yZGVyOiVkLCBtb2RlOjB4JXhcbiIsCi0JCQlwLT5jb21tLCBvcmRlciwgZ2ZwX21hc2spOworCQkJY3VycmVudC0+Y29tbSwgb3JkZXIsIGdmcF9tYXNrKTsKIAkJZHVtcF9zdGFjaygpOwogCQlzaG93X21lbSgpOwogCX0KQEAgLTIxNTEsNyArMjIwMiw5IEBACiAKIAlnZXRfbWVtc19hbGxvd2VkKCk7CiAJLyogVGhlIHByZWZlcnJlZCB6b25lIGlzIHVzZWQgZm9yIHN0YXRpc3RpY3MgbGF0ZXIgKi8KLQlmaXJzdF96b25lc196b25lbGlzdCh6b25lbGlzdCwgaGlnaF96b25laWR4LCBub2RlbWFzaywgJnByZWZlcnJlZF96b25lKTsKKwlmaXJzdF96b25lc196b25lbGlzdCh6b25lbGlzdCwgaGlnaF96b25laWR4LAorCQkJCW5vZGVtYXNrID8gOiAmY3B1c2V0X2N1cnJlbnRfbWVtc19hbGxvd2VkLAorCQkJCSZwcmVmZXJyZWRfem9uZSk7CiAJaWYgKCFwcmVmZXJyZWRfem9uZSkgewogCQlwdXRfbWVtc19hbGxvd2VkKCk7CiAJCXJldHVybiBOVUxMOwpAQCAtMjQ0Miw3ICsyNDk1LDcgQEAKIAkJCSIgYWxsX3VucmVjbGFpbWFibGU/ICVzIgogCQkJIlxuIiwKIAkJCXpvbmUtPm5hbWUsCi0JCQlLKHpvbmVfbnJfZnJlZV9wYWdlcyh6b25lKSksCisJCQlLKHpvbmVfcGFnZV9zdGF0ZSh6b25lLCBOUl9GUkVFX1BBR0VTKSksCiAJCQlLKG1pbl93bWFya19wYWdlcyh6b25lKSksCiAJCQlLKGxvd193bWFya19wYWdlcyh6b25lKSksCiAJCQlLKGhpZ2hfd21hcmtfcGFnZXMoem9uZSkpLApAQCAtMjU4NSw5ICsyNjM4LDE2IEBACiAKIHN0YXRpYyBfX2luaXQgaW50IHNldHVwX251bWFfem9uZWxpc3Rfb3JkZXIoY2hhciAqcykKIHsKLQlpZiAocykKLQkJcmV0dXJuIF9fcGFyc2VfbnVtYV96b25lbGlzdF9vcmRlcihzKTsKLQlyZXR1cm4gMDsKKwlpbnQgcmV0OworCisJaWYgKCFzKQorCQlyZXR1cm4gMDsKKworCXJldCA9IF9fcGFyc2VfbnVtYV96b25lbGlzdF9vcmRlcihzKTsKKwlpZiAocmV0ID09IDApCisJCXN0cmxjcHkobnVtYV96b25lbGlzdF9vcmRlciwgcywgTlVNQV9aT05FTElTVF9PUkRFUl9MRU4pOworCisJcmV0dXJuIHJldDsKIH0KIGVhcmx5X3BhcmFtKCJudW1hX3pvbmVsaXN0X29yZGVyIiwgc2V0dXBfbnVtYV96b25lbGlzdF9vcmRlcik7CiAKQEAgLTU1MTcsNyArNTU3Nyw2IEBACiAJezFVTCA8PCBQR19zd2FwY2FjaGUsCQkic3dhcGNhY2hlIgl9LAogCXsxVUwgPDwgUEdfbWFwcGVkdG9kaXNrLAkibWFwcGVkdG9kaXNrIgl9LAogCXsxVUwgPDwgUEdfcmVjbGFpbSwJCSJyZWNsYWltIgl9LAotCXsxVUwgPDwgUEdfYnVkZHksCQkiYnVkZHkiCQl9LAogCXsxVUwgPDwgUEdfc3dhcGJhY2tlZCwJCSJzd2FwYmFja2VkIgl9LAogCXsxVUwgPDwgUEdfdW5ldmljdGFibGUsCQkidW5ldmljdGFibGUiCX0sCiAjaWZkZWYgQ09ORklHX01NVQpAQCAtNTU2NSw3ICs1NjI0LDcgQEAKIHsKIAlwcmludGsoS0VSTl9BTEVSVAogCSAgICAgICAicGFnZTolcCBjb3VudDolZCBtYXBjb3VudDolZCBtYXBwaW5nOiVwIGluZGV4OiUjbHhcbiIsCi0JCXBhZ2UsIHBhZ2VfY291bnQocGFnZSksIHBhZ2VfbWFwY291bnQocGFnZSksCisJCXBhZ2UsIGF0b21pY19yZWFkKCZwYWdlLT5fY291bnQpLCBwYWdlX21hcGNvdW50KHBhZ2UpLAogCQlwYWdlLT5tYXBwaW5nLCBwYWdlLT5pbmRleCk7CiAJZHVtcF9wYWdlX2ZsYWdzKHBhZ2UtPmZsYWdzKTsKIH0KZGlmZiAtLWdpdCBhL21tL3BhZ2V3YWxrLmMgYi9tbS9wYWdld2Fsay5jCmluZGV4IDM4Y2M1OGIuLjdjZmE2YWUgMTAwNjQ0Ci0tLSBhL21tL3BhZ2V3YWxrLmMKKysrIGIvbW0vcGFnZXdhbGsuYwpAQCAtMzQsNiArMzQsNyBAQAogCXBtZCA9IHBtZF9vZmZzZXQocHVkLCBhZGRyKTsKIAlkbyB7CiAJCW5leHQgPSBwbWRfYWRkcl9lbmQoYWRkciwgZW5kKTsKKwkJc3BsaXRfaHVnZV9wYWdlX3BtZCh3YWxrLT5tbSwgcG1kKTsKIAkJaWYgKHBtZF9ub25lX29yX2NsZWFyX2JhZChwbWQpKSB7CiAJCQlpZiAod2Fsay0+cHRlX2hvbGUpCiAJCQkJZXJyID0gd2Fsay0+cHRlX2hvbGUoYWRkciwgbmV4dCwgd2Fsayk7CmRpZmYgLS1naXQgYS9tbS9wZXJjcHUtdm0uYyBiL21tL3BlcmNwdS12bS5jCmluZGV4IDdkOWMxZDAuLmVhNTM0OTYgMTAwNjQ0Ci0tLSBhL21tL3BlcmNwdS12bS5jCisrKyBiL21tL3BlcmNwdS12bS5jCkBAIC00MjEsNyArNDIxLDcgQEAKIAkJcmV0dXJuIE5VTEw7CiAKIAl2bXMgPSBwY3B1X2dldF92bV9hcmVhcyhwY3B1X2dyb3VwX29mZnNldHMsIHBjcHVfZ3JvdXBfc2l6ZXMsCi0JCQkJcGNwdV9ucl9ncm91cHMsIHBjcHVfYXRvbV9zaXplLCBHRlBfS0VSTkVMKTsKKwkJCQlwY3B1X25yX2dyb3VwcywgcGNwdV9hdG9tX3NpemUpOwogCWlmICghdm1zKSB7CiAJCXBjcHVfZnJlZV9jaHVuayhjaHVuayk7CiAJCXJldHVybiBOVUxMOwpkaWZmIC0tZ2l0IGEvbW0vcGd0YWJsZS1nZW5lcmljLmMgYi9tbS9wZ3RhYmxlLWdlbmVyaWMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lYjY2M2ZiCi0tLSAvZGV2L251bGwKKysrIGIvbW0vcGd0YWJsZS1nZW5lcmljLmMKQEAgLTAsMCArMSwxMjEgQEAKKy8qCisgKiAgbW0vcGd0YWJsZS1nZW5lcmljLmMKKyAqCisgKiAgR2VuZXJpYyBwZ3RhYmxlIG1ldGhvZHMgZGVjbGFyZWQgaW4gYXNtLWdlbmVyaWMvcGd0YWJsZS5oCisgKgorICogIENvcHlyaWdodCAoQykgMjAxMCAgTGludXMgVG9ydmFsZHMKKyAqLworCisjaW5jbHVkZSA8bGludXgvcGFnZW1hcC5oPgorI2luY2x1ZGUgPGFzbS90bGIuaD4KKyNpbmNsdWRlIDxhc20tZ2VuZXJpYy9wZ3RhYmxlLmg+CisKKyNpZm5kZWYgX19IQVZFX0FSQ0hfUFRFUF9TRVRfQUNDRVNTX0ZMQUdTCisvKgorICogT25seSBzZXRzIHRoZSBhY2Nlc3MgZmxhZ3MgKGRpcnR5LCBhY2Nlc3NlZCwgYW5kCisgKiB3cml0YWJsZSkuIEZ1cnRoZXJtb3JlLCB3ZSBrbm93IGl0IGFsd2F5cyBnZXRzIHNldCB0byBhICJtb3JlCisgKiBwZXJtaXNzaXZlIiBzZXR0aW5nLCB3aGljaCBhbGxvd3MgbW9zdCBhcmNoaXRlY3R1cmVzIHRvIG9wdGltaXplCisgKiB0aGlzLiBXZSByZXR1cm4gd2hldGhlciB0aGUgUFRFIGFjdHVhbGx5IGNoYW5nZWQsIHdoaWNoIGluIHR1cm4KKyAqIGluc3RydWN0cyB0aGUgY2FsbGVyIHRvIGRvIHRoaW5ncyBsaWtlIHVwZGF0ZV9fbW11X2NhY2hlLiAgVGhpcworICogdXNlZCB0byBiZSBkb25lIGluIHRoZSBjYWxsZXIsIGJ1dCBzcGFyYyBuZWVkcyBtaW5vciBmYXVsdHMgdG8KKyAqIGZvcmNlIHRoYXQgY2FsbCBvbiBzdW40YyBzbyB3ZSBjaGFuZ2VkIHRoaXMgbWFjcm8gc2xpZ2h0bHkKKyAqLworaW50IHB0ZXBfc2V0X2FjY2Vzc19mbGFncyhzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCSAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwdGVfdCAqcHRlcCwKKwkJCSAgcHRlX3QgZW50cnksIGludCBkaXJ0eSkKK3sKKwlpbnQgY2hhbmdlZCA9ICFwdGVfc2FtZSgqcHRlcCwgZW50cnkpOworCWlmIChjaGFuZ2VkKSB7CisJCXNldF9wdGVfYXQodm1hLT52bV9tbSwgYWRkcmVzcywgcHRlcCwgZW50cnkpOworCQlmbHVzaF90bGJfcGFnZSh2bWEsIGFkZHJlc3MpOworCX0KKwlyZXR1cm4gY2hhbmdlZDsKK30KKyNlbmRpZgorCisjaWZuZGVmIF9fSEFWRV9BUkNIX1BNRFBfU0VUX0FDQ0VTU19GTEFHUworaW50IHBtZHBfc2V0X2FjY2Vzc19mbGFncyhzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKKwkJCSAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwbWRfdCAqcG1kcCwKKwkJCSAgcG1kX3QgZW50cnksIGludCBkaXJ0eSkKK3sKKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UKKwlpbnQgY2hhbmdlZCA9ICFwbWRfc2FtZSgqcG1kcCwgZW50cnkpOworCVZNX0JVR19PTihhZGRyZXNzICYgfkhQQUdFX1BNRF9NQVNLKTsKKwlpZiAoY2hhbmdlZCkgeworCQlzZXRfcG1kX2F0KHZtYS0+dm1fbW0sIGFkZHJlc3MsIHBtZHAsIGVudHJ5KTsKKwkJZmx1c2hfdGxiX3JhbmdlKHZtYSwgYWRkcmVzcywgYWRkcmVzcyArIEhQQUdFX1BNRF9TSVpFKTsKKwl9CisJcmV0dXJuIGNoYW5nZWQ7CisjZWxzZSAvKiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UgKi8KKwlCVUcoKTsKKwlyZXR1cm4gMDsKKyNlbmRpZiAvKiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UgKi8KK30KKyNlbmRpZgorCisjaWZuZGVmIF9fSEFWRV9BUkNIX1BURVBfQ0xFQVJfWU9VTkdfRkxVU0gKK2ludCBwdGVwX2NsZWFyX2ZsdXNoX3lvdW5nKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJICAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwdGVfdCAqcHRlcCkKK3sKKwlpbnQgeW91bmc7CisJeW91bmcgPSBwdGVwX3Rlc3RfYW5kX2NsZWFyX3lvdW5nKHZtYSwgYWRkcmVzcywgcHRlcCk7CisJaWYgKHlvdW5nKQorCQlmbHVzaF90bGJfcGFnZSh2bWEsIGFkZHJlc3MpOworCXJldHVybiB5b3VuZzsKK30KKyNlbmRpZgorCisjaWZuZGVmIF9fSEFWRV9BUkNIX1BNRFBfQ0xFQVJfWU9VTkdfRkxVU0gKK2ludCBwbWRwX2NsZWFyX2ZsdXNoX3lvdW5nKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAorCQkJICAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwbWRfdCAqcG1kcCkKK3sKKwlpbnQgeW91bmc7CisjaWZuZGVmIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRQorCUJVRygpOworI2VuZGlmIC8qIENPTkZJR19UUkFOU1BBUkVOVF9IVUdFUEFHRSAqLworCVZNX0JVR19PTihhZGRyZXNzICYgfkhQQUdFX1BNRF9NQVNLKTsKKwl5b3VuZyA9IHBtZHBfdGVzdF9hbmRfY2xlYXJfeW91bmcodm1hLCBhZGRyZXNzLCBwbWRwKTsKKwlpZiAoeW91bmcpCisJCWZsdXNoX3RsYl9yYW5nZSh2bWEsIGFkZHJlc3MsIGFkZHJlc3MgKyBIUEFHRV9QTURfU0laRSk7CisJcmV0dXJuIHlvdW5nOworfQorI2VuZGlmCisKKyNpZm5kZWYgX19IQVZFX0FSQ0hfUFRFUF9DTEVBUl9GTFVTSAorcHRlX3QgcHRlcF9jbGVhcl9mbHVzaChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgdW5zaWduZWQgbG9uZyBhZGRyZXNzLAorCQkgICAgICAgcHRlX3QgKnB0ZXApCit7CisJcHRlX3QgcHRlOworCXB0ZSA9IHB0ZXBfZ2V0X2FuZF9jbGVhcigodm1hKS0+dm1fbW0sIGFkZHJlc3MsIHB0ZXApOworCWZsdXNoX3RsYl9wYWdlKHZtYSwgYWRkcmVzcyk7CisJcmV0dXJuIHB0ZTsKK30KKyNlbmRpZgorCisjaWZuZGVmIF9fSEFWRV9BUkNIX1BNRFBfQ0xFQVJfRkxVU0gKKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UKK3BtZF90IHBtZHBfY2xlYXJfZmx1c2goc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywKKwkJICAgICAgIHBtZF90ICpwbWRwKQoreworCXBtZF90IHBtZDsKKwlWTV9CVUdfT04oYWRkcmVzcyAmIH5IUEFHRV9QTURfTUFTSyk7CisJcG1kID0gcG1kcF9nZXRfYW5kX2NsZWFyKHZtYS0+dm1fbW0sIGFkZHJlc3MsIHBtZHApOworCWZsdXNoX3RsYl9yYW5nZSh2bWEsIGFkZHJlc3MsIGFkZHJlc3MgKyBIUEFHRV9QTURfU0laRSk7CisJcmV0dXJuIHBtZDsKK30KKyNlbmRpZiAvKiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UgKi8KKyNlbmRpZgorCisjaWZuZGVmIF9fSEFWRV9BUkNIX1BNRFBfU1BMSVRUSU5HX0ZMVVNICisjaWZkZWYgQ09ORklHX1RSQU5TUEFSRU5UX0hVR0VQQUdFCitwbWRfdCBwbWRwX3NwbGl0dGluZ19mbHVzaChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgdW5zaWduZWQgbG9uZyBhZGRyZXNzLAorCQkJICAgcG1kX3QgKnBtZHApCit7CisJcG1kX3QgcG1kID0gcG1kX21rc3BsaXR0aW5nKCpwbWRwKTsKKwlWTV9CVUdfT04oYWRkcmVzcyAmIH5IUEFHRV9QTURfTUFTSyk7CisJc2V0X3BtZF9hdCh2bWEtPnZtX21tLCBhZGRyZXNzLCBwbWRwLCBwbWQpOworCS8qIHRsYiBmbHVzaCBvbmx5IHRvIHNlcmlhbGl6ZSBhZ2FpbnN0IGd1cC1mYXN0ICovCisJZmx1c2hfdGxiX3JhbmdlKHZtYSwgYWRkcmVzcywgYWRkcmVzcyArIEhQQUdFX1BNRF9TSVpFKTsKK30KKyNlbmRpZiAvKiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UgKi8KKyNlbmRpZgpkaWZmIC0tZ2l0IGEvbW0vcm1hcC5jIGIvbW0vcm1hcC5jCmluZGV4IGM5NWQyYmEuLmYyMWY0YTEgMTAwNjQ0Ci0tLSBhL21tL3JtYXAuYworKysgYi9tbS9ybWFwLmMKQEAgLTE3Nyw2ICsxNzcsMTAgQEAKIAlsaXN0X2FkZCgmYXZjLT5zYW1lX3ZtYSwgJnZtYS0+YW5vbl92bWFfY2hhaW4pOwogCiAJYW5vbl92bWFfbG9jayhhbm9uX3ZtYSk7CisJLyoKKwkgKiBJdCdzIGNyaXRpY2FsIHRvIGFkZCBuZXcgdm1hcyB0byB0aGUgdGFpbCBvZiB0aGUgYW5vbl92bWEsCisJICogc2VlIGNvbW1lbnQgaW4gaHVnZV9tZW1vcnkuYzpfX3NwbGl0X2h1Z2VfcGFnZSgpLgorCSAqLwogCWxpc3RfYWRkX3RhaWwoJmF2Yy0+c2FtZV9hbm9uX3ZtYSwgJmFub25fdm1hLT5oZWFkKTsKIAlhbm9uX3ZtYV91bmxvY2soYW5vbl92bWEpOwogfQpAQCAtMzYwLDcgKzM2NCw3IEBACiAgKiBSZXR1cm5zIHZpcnR1YWwgYWRkcmVzcyBvciAtRUZBVUxUIGlmIHBhZ2UncyBpbmRleC9vZmZzZXQgaXMgbm90CiAgKiB3aXRoaW4gdGhlIHJhbmdlIG1hcHBlZCB0aGUgQHZtYS4KICAqLwotc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nCitpbmxpbmUgdW5zaWduZWQgbG9uZwogdm1hX2FkZHJlc3Moc3RydWN0IHBhZ2UgKnBhZ2UsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQogewogCXBnb2ZmX3QgcGdvZmYgPSBwYWdlLT5pbmRleCA8PCAoUEFHRV9DQUNIRV9TSElGVCAtIFBBR0VfU0hJRlQpOwpAQCAtNDM1LDYgKzQzOSw4IEBACiAJcG1kID0gcG1kX29mZnNldChwdWQsIGFkZHJlc3MpOwogCWlmICghcG1kX3ByZXNlbnQoKnBtZCkpCiAJCXJldHVybiBOVUxMOworCWlmIChwbWRfdHJhbnNfaHVnZSgqcG1kKSkKKwkJcmV0dXJuIE5VTEw7CiAKIAlwdGUgPSBwdGVfb2Zmc2V0X21hcChwbWQsIGFkZHJlc3MpOwogCS8qIE1ha2UgYSBxdWljayBjaGVjayBiZWZvcmUgZ2V0dGluZyB0aGUgbG9jayAqLwpAQCAtNDg5LDM1ICs0OTUsMTcgQEAKIAkJCXVuc2lnbmVkIGxvbmcgKnZtX2ZsYWdzKQogewogCXN0cnVjdCBtbV9zdHJ1Y3QgKm1tID0gdm1hLT52bV9tbTsKLQlwdGVfdCAqcHRlOwotCXNwaW5sb2NrX3QgKnB0bDsKIAlpbnQgcmVmZXJlbmNlZCA9IDA7CiAKLQlwdGUgPSBwYWdlX2NoZWNrX2FkZHJlc3MocGFnZSwgbW0sIGFkZHJlc3MsICZwdGwsIDApOwotCWlmICghcHRlKQotCQlnb3RvIG91dDsKLQogCS8qCiAJICogRG9uJ3Qgd2FudCB0byBlbGV2YXRlIHJlZmVyZW5jZWQgZm9yIG1sb2NrZWQgcGFnZSB0aGF0IGdldHMgdGhpcyBmYXIsCiAJICogaW4gb3JkZXIgdGhhdCBpdCBwcm9ncmVzc2VzIHRvIHRyeV90b191bm1hcCBhbmQgaXMgbW92ZWQgdG8gdGhlCiAJICogdW5ldmljdGFibGUgbGlzdC4KIAkgKi8KIAlpZiAodm1hLT52bV9mbGFncyAmIFZNX0xPQ0tFRCkgewotCQkqbWFwY291bnQgPSAxOwkvKiBicmVhayBlYXJseSBmcm9tIGxvb3AgKi8KKwkJKm1hcGNvdW50ID0gMDsJLyogYnJlYWsgZWFybHkgZnJvbSBsb29wICovCiAJCSp2bV9mbGFncyB8PSBWTV9MT0NLRUQ7Ci0JCWdvdG8gb3V0X3VubWFwOwotCX0KLQotCWlmIChwdGVwX2NsZWFyX2ZsdXNoX3lvdW5nX25vdGlmeSh2bWEsIGFkZHJlc3MsIHB0ZSkpIHsKLQkJLyoKLQkJICogRG9uJ3QgdHJlYXQgYSByZWZlcmVuY2UgdGhyb3VnaCBhIHNlcXVlbnRpYWxseSByZWFkCi0JCSAqIG1hcHBpbmcgYXMgc3VjaC4gIElmIHRoZSBwYWdlIGhhcyBiZWVuIHVzZWQgaW4KLQkJICogYW5vdGhlciBtYXBwaW5nLCB3ZSB3aWxsIGNhdGNoIGl0OyBpZiB0aGlzIG90aGVyCi0JCSAqIG1hcHBpbmcgaXMgYWxyZWFkeSBnb25lLCB0aGUgdW5tYXAgcGF0aCB3aWxsIGhhdmUKLQkJICogc2V0IFBHX3JlZmVyZW5jZWQgb3IgYWN0aXZhdGVkIHRoZSBwYWdlLgotCQkgKi8KLQkJaWYgKGxpa2VseSghVk1fU2VxdWVudGlhbFJlYWRIaW50KHZtYSkpKQotCQkJcmVmZXJlbmNlZCsrOworCQlnb3RvIG91dDsKIAl9CiAKIAkvKiBQcmV0ZW5kIHRoZSBwYWdlIGlzIHJlZmVyZW5jZWQgaWYgdGhlIHRhc2sgaGFzIHRoZQpAQCAtNTI2LDkgKzUxNCwzOSBAQAogCQkJcndzZW1faXNfbG9ja2VkKCZtbS0+bW1hcF9zZW0pKQogCQlyZWZlcmVuY2VkKys7CiAKLW91dF91bm1hcDoKKwlpZiAodW5saWtlbHkoUGFnZVRyYW5zSHVnZShwYWdlKSkpIHsKKwkJcG1kX3QgKnBtZDsKKworCQlzcGluX2xvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCQlwbWQgPSBwYWdlX2NoZWNrX2FkZHJlc3NfcG1kKHBhZ2UsIG1tLCBhZGRyZXNzLAorCQkJCQkgICAgIFBBR0VfQ0hFQ0tfQUREUkVTU19QTURfRkxBRyk7CisJCWlmIChwbWQgJiYgIXBtZF90cmFuc19zcGxpdHRpbmcoKnBtZCkgJiYKKwkJICAgIHBtZHBfY2xlYXJfZmx1c2hfeW91bmdfbm90aWZ5KHZtYSwgYWRkcmVzcywgcG1kKSkKKwkJCXJlZmVyZW5jZWQrKzsKKwkJc3Bpbl91bmxvY2soJm1tLT5wYWdlX3RhYmxlX2xvY2spOworCX0gZWxzZSB7CisJCXB0ZV90ICpwdGU7CisJCXNwaW5sb2NrX3QgKnB0bDsKKworCQlwdGUgPSBwYWdlX2NoZWNrX2FkZHJlc3MocGFnZSwgbW0sIGFkZHJlc3MsICZwdGwsIDApOworCQlpZiAoIXB0ZSkKKwkJCWdvdG8gb3V0OworCisJCWlmIChwdGVwX2NsZWFyX2ZsdXNoX3lvdW5nX25vdGlmeSh2bWEsIGFkZHJlc3MsIHB0ZSkpIHsKKwkJCS8qCisJCQkgKiBEb24ndCB0cmVhdCBhIHJlZmVyZW5jZSB0aHJvdWdoIGEgc2VxdWVudGlhbGx5IHJlYWQKKwkJCSAqIG1hcHBpbmcgYXMgc3VjaC4gIElmIHRoZSBwYWdlIGhhcyBiZWVuIHVzZWQgaW4KKwkJCSAqIGFub3RoZXIgbWFwcGluZywgd2Ugd2lsbCBjYXRjaCBpdDsgaWYgdGhpcyBvdGhlcgorCQkJICogbWFwcGluZyBpcyBhbHJlYWR5IGdvbmUsIHRoZSB1bm1hcCBwYXRoIHdpbGwgaGF2ZQorCQkJICogc2V0IFBHX3JlZmVyZW5jZWQgb3IgYWN0aXZhdGVkIHRoZSBwYWdlLgorCQkJICovCisJCQlpZiAobGlrZWx5KCFWTV9TZXF1ZW50aWFsUmVhZEhpbnQodm1hKSkpCisJCQkJcmVmZXJlbmNlZCsrOworCQl9CisJCXB0ZV91bm1hcF91bmxvY2socHRlLCBwdGwpOworCX0KKwogCSgqbWFwY291bnQpLS07Ci0JcHRlX3VubWFwX3VubG9jayhwdGUsIHB0bCk7CiAKIAlpZiAocmVmZXJlbmNlZCkKIAkJKnZtX2ZsYWdzIHw9IHZtYS0+dm1fZmxhZ3M7CkBAIC04NjQsOCArODgyLDEzIEBACiAJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywgaW50IGV4Y2x1c2l2ZSkKIHsKIAlpbnQgZmlyc3QgPSBhdG9taWNfaW5jX2FuZF90ZXN0KCZwYWdlLT5fbWFwY291bnQpOwotCWlmIChmaXJzdCkKLQkJX19pbmNfem9uZV9wYWdlX3N0YXRlKHBhZ2UsIE5SX0FOT05fUEFHRVMpOworCWlmIChmaXJzdCkgeworCQlpZiAoIVBhZ2VUcmFuc0h1Z2UocGFnZSkpCisJCQlfX2luY196b25lX3BhZ2Vfc3RhdGUocGFnZSwgTlJfQU5PTl9QQUdFUyk7CisJCWVsc2UKKwkJCV9faW5jX3pvbmVfcGFnZV9zdGF0ZShwYWdlLAorCQkJCQkgICAgICBOUl9BTk9OX1RSQU5TUEFSRU5UX0hVR0VQQUdFUyk7CisJfQogCWlmICh1bmxpa2VseShQYWdlS3NtKHBhZ2UpKSkKIAkJcmV0dXJuOwogCkBAIC04OTMsNyArOTE2LDEwIEBACiAJVk1fQlVHX09OKGFkZHJlc3MgPCB2bWEtPnZtX3N0YXJ0IHx8IGFkZHJlc3MgPj0gdm1hLT52bV9lbmQpOwogCVNldFBhZ2VTd2FwQmFja2VkKHBhZ2UpOwogCWF0b21pY19zZXQoJnBhZ2UtPl9tYXBjb3VudCwgMCk7IC8qIGluY3JlbWVudCBjb3VudCAoc3RhcnRzIGF0IC0xKSAqLwotCV9faW5jX3pvbmVfcGFnZV9zdGF0ZShwYWdlLCBOUl9BTk9OX1BBR0VTKTsKKwlpZiAoIVBhZ2VUcmFuc0h1Z2UocGFnZSkpCisJCV9faW5jX3pvbmVfcGFnZV9zdGF0ZShwYWdlLCBOUl9BTk9OX1BBR0VTKTsKKwllbHNlCisJCV9faW5jX3pvbmVfcGFnZV9zdGF0ZShwYWdlLCBOUl9BTk9OX1RSQU5TUEFSRU5UX0hVR0VQQUdFUyk7CiAJX19wYWdlX3NldF9hbm9uX3JtYXAocGFnZSwgdm1hLCBhZGRyZXNzLCAxKTsKIAlpZiAocGFnZV9ldmljdGFibGUocGFnZSwgdm1hKSkKIAkJbHJ1X2NhY2hlX2FkZF9scnUocGFnZSwgTFJVX0FDVElWRV9BTk9OKTsKQEAgLTkxMSw3ICs5MzcsNyBAQAogewogCWlmIChhdG9taWNfaW5jX2FuZF90ZXN0KCZwYWdlLT5fbWFwY291bnQpKSB7CiAJCV9faW5jX3pvbmVfcGFnZV9zdGF0ZShwYWdlLCBOUl9GSUxFX01BUFBFRCk7Ci0JCW1lbV9jZ3JvdXBfdXBkYXRlX2ZpbGVfbWFwcGVkKHBhZ2UsIDEpOworCQltZW1fY2dyb3VwX2luY19wYWdlX3N0YXQocGFnZSwgTUVNQ0dfTlJfRklMRV9NQVBQRUQpOwogCX0KIH0KIApAQCAtOTQ2LDEwICs5NzIsMTQgQEAKIAkJcmV0dXJuOwogCWlmIChQYWdlQW5vbihwYWdlKSkgewogCQltZW1fY2dyb3VwX3VuY2hhcmdlX3BhZ2UocGFnZSk7Ci0JCV9fZGVjX3pvbmVfcGFnZV9zdGF0ZShwYWdlLCBOUl9BTk9OX1BBR0VTKTsKKwkJaWYgKCFQYWdlVHJhbnNIdWdlKHBhZ2UpKQorCQkJX19kZWNfem9uZV9wYWdlX3N0YXRlKHBhZ2UsIE5SX0FOT05fUEFHRVMpOworCQllbHNlCisJCQlfX2RlY196b25lX3BhZ2Vfc3RhdGUocGFnZSwKKwkJCQkJICAgICAgTlJfQU5PTl9UUkFOU1BBUkVOVF9IVUdFUEFHRVMpOwogCX0gZWxzZSB7CiAJCV9fZGVjX3pvbmVfcGFnZV9zdGF0ZShwYWdlLCBOUl9GSUxFX01BUFBFRCk7Ci0JCW1lbV9jZ3JvdXBfdXBkYXRlX2ZpbGVfbWFwcGVkKHBhZ2UsIC0xKTsKKwkJbWVtX2Nncm91cF9kZWNfcGFnZV9zdGF0KHBhZ2UsIE1FTUNHX05SX0ZJTEVfTUFQUEVEKTsKIAl9CiAJLyoKIAkgKiBJdCB3b3VsZCBiZSB0aWR5IHRvIHJlc2V0IHRoZSBQYWdlQW5vbiBtYXBwaW5nIGhlcmUsCkBAIC0xMjAyLDcgKzEyMzIsNyBAQAogCXJldHVybiByZXQ7CiB9CiAKLXN0YXRpYyBib29sIGlzX3ZtYV90ZW1wb3Jhcnlfc3RhY2soc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCitib29sIGlzX3ZtYV90ZW1wb3Jhcnlfc3RhY2soc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCiB7CiAJaW50IG1heWJlX3N0YWNrID0gdm1hLT52bV9mbGFncyAmIChWTV9HUk9XU0RPV04gfCBWTV9HUk9XU1VQKTsKIApAQCAtMTQwMCw2ICsxNDMwLDcgQEAKIAlpbnQgcmV0OwogCiAJQlVHX09OKCFQYWdlTG9ja2VkKHBhZ2UpKTsKKwlWTV9CVUdfT04oIVBhZ2VIdWdlKHBhZ2UpICYmIFBhZ2VUcmFuc0h1Z2UocGFnZSkpOwogCiAJaWYgKHVubGlrZWx5KFBhZ2VLc20ocGFnZSkpKQogCQlyZXQgPSB0cnlfdG9fdW5tYXBfa3NtKHBhZ2UsIGZsYWdzKTsKZGlmZiAtLWdpdCBhL21tL3NsYWIuYyBiL21tL3NsYWIuYwppbmRleCAyNjQwMzc0Li4zNzk2MWQxIDEwMDY0NAotLS0gYS9tbS9zbGFiLmMKKysrIGIvbW0vc2xhYi5jCkBAIC0yODQsNyArMjg0LDcgQEAKICAqIE5lZWQgdGhpcyBmb3IgYm9vdHN0cmFwcGluZyBhIHBlciBub2RlIGFsbG9jYXRvci4KICAqLwogI2RlZmluZSBOVU1fSU5JVF9MSVNUUyAoMyAqIE1BWF9OVU1OT0RFUykKLXN0cnVjdCBrbWVtX2xpc3QzIF9faW5pdGRhdGEgaW5pdGttZW1fbGlzdDNbTlVNX0lOSVRfTElTVFNdOworc3RhdGljIHN0cnVjdCBrbWVtX2xpc3QzIF9faW5pdGRhdGEgaW5pdGttZW1fbGlzdDNbTlVNX0lOSVRfTElTVFNdOwogI2RlZmluZQlDQUNIRV9DQUNIRSAwCiAjZGVmaW5lCVNJWkVfQUMgTUFYX05VTU5PREVTCiAjZGVmaW5lCVNJWkVfTDMgKDIgKiBNQVhfTlVNTk9ERVMpCkBAIC00MDUzLDcgKzQwNTMsNyBAQAogICogbmVjZXNzYXJ5LiBOb3RlIHRoYXQgdGhlIGwzIGxpc3Rsb2NrIGFsc28gcHJvdGVjdHMgdGhlIGFycmF5X2NhY2hlCiAgKiBpZiBkcmFpbl9hcnJheSgpIGlzIHVzZWQgb24gdGhlIHNoYXJlZCBhcnJheS4KICAqLwotdm9pZCBkcmFpbl9hcnJheShzdHJ1Y3Qga21lbV9jYWNoZSAqY2FjaGVwLCBzdHJ1Y3Qga21lbV9saXN0MyAqbDMsCitzdGF0aWMgdm9pZCBkcmFpbl9hcnJheShzdHJ1Y3Qga21lbV9jYWNoZSAqY2FjaGVwLCBzdHJ1Y3Qga21lbV9saXN0MyAqbDMsCiAJCQkgc3RydWN0IGFycmF5X2NhY2hlICphYywgaW50IGZvcmNlLCBpbnQgbm9kZSkKIHsKIAlpbnQgdG9mcmVlOwpAQCAtNDMxNyw3ICs0MzE3LDcgQEAKICAqIEBjb3VudDogZGF0YSBsZW5ndGgKICAqIEBwcG9zOiB1bnVzZWQKICAqLwotc3NpemVfdCBzbGFiaW5mb193cml0ZShzdHJ1Y3QgZmlsZSAqZmlsZSwgY29uc3QgY2hhciBfX3VzZXIgKiBidWZmZXIsCitzdGF0aWMgc3NpemVfdCBzbGFiaW5mb193cml0ZShzdHJ1Y3QgZmlsZSAqZmlsZSwgY29uc3QgY2hhciBfX3VzZXIgKmJ1ZmZlciwKIAkJICAgICAgIHNpemVfdCBjb3VudCwgbG9mZl90ICpwcG9zKQogewogCWNoYXIga2J1ZltNQVhfU0xBQklORk9fV1JJVEUgKyAxXSwgKnRtcDsKZGlmZiAtLWdpdCBhL21tL3NsdWIuYyBiL21tL3NsdWIuYwppbmRleCAwMDhjZDc0Li5lMTVhYTdmIDEwMDY0NAotLS0gYS9tbS9zbHViLmMKKysrIGIvbW0vc2x1Yi5jCkBAIC0zNjM2LDcgKzM2MzYsNyBAQAogCQlsZW4gKz0gc3ByaW50ZihidWYgKyBsZW4sICIlN2xkICIsIGwtPmNvdW50KTsKIAogCQlpZiAobC0+YWRkcikKLQkJCWxlbiArPSBzcHJpbnRfc3ltYm9sKGJ1ZiArIGxlbiwgKHVuc2lnbmVkIGxvbmcpbC0+YWRkcik7CisJCQlsZW4gKz0gc3ByaW50ZihidWYgKyBsZW4sICIlcFMiLCAodm9pZCAqKWwtPmFkZHIpOwogCQllbHNlCiAJCQlsZW4gKz0gc3ByaW50ZihidWYgKyBsZW4sICI8bm90LWF2YWlsYWJsZT4iKTsKIApAQCAtMzc5Nyw3ICszNzk3LDcgQEAKIAkJfQogCX0KIAotCWRvd25fcmVhZCgmc2x1Yl9sb2NrKTsKKwlsb2NrX21lbW9yeV9ob3RwbHVnKCk7CiAjaWZkZWYgQ09ORklHX1NMVUJfREVCVUcKIAlpZiAoZmxhZ3MgJiBTT19BTEwpIHsKIAkJZm9yX2VhY2hfbm9kZV9zdGF0ZShub2RlLCBOX05PUk1BTF9NRU1PUlkpIHsKQEAgLTM4MzgsNyArMzgzOCw3IEBACiAJCQl4ICs9IHNwcmludGYoYnVmICsgeCwgIiBOJWQ9JWx1IiwKIAkJCQkJbm9kZSwgbm9kZXNbbm9kZV0pOwogI2VuZGlmCi0JdXBfcmVhZCgmc2x1Yl9sb2NrKTsKKwl1bmxvY2tfbWVtb3J5X2hvdHBsdWcoKTsKIAlrZnJlZShub2Rlcyk7CiAJcmV0dXJuIHggKyBzcHJpbnRmKGJ1ZiArIHgsICJcbiIpOwogfQpAQCAtMzk0NiwxMiArMzk0Niw5IEBACiAKIHN0YXRpYyBzc2l6ZV90IGN0b3Jfc2hvdyhzdHJ1Y3Qga21lbV9jYWNoZSAqcywgY2hhciAqYnVmKQogewotCWlmIChzLT5jdG9yKSB7Ci0JCWludCBuID0gc3ByaW50X3N5bWJvbChidWYsICh1bnNpZ25lZCBsb25nKXMtPmN0b3IpOwotCi0JCXJldHVybiBuICsgc3ByaW50ZihidWYgKyBuLCAiXG4iKTsKLQl9Ci0JcmV0dXJuIDA7CisJaWYgKCFzLT5jdG9yKQorCQlyZXR1cm4gMDsKKwlyZXR1cm4gc3ByaW50ZihidWYsICIlcFNcbiIsIHMtPmN0b3IpOwogfQogU0xBQl9BVFRSX1JPKGN0b3IpOwogCmRpZmYgLS1naXQgYS9tbS9zcGFyc2UuYyBiL21tL3NwYXJzZS5jCmluZGV4IDk1YWMyMTkuLjkzMjUwMjAgMTAwNjQ0Ci0tLSBhL21tL3NwYXJzZS5jCisrKyBiL21tL3NwYXJzZS5jCkBAIC02NzEsMTAgKzY3MSwxMCBAQAogc3RhdGljIHZvaWQgZnJlZV9tYXBfYm9vdG1lbShzdHJ1Y3QgcGFnZSAqcGFnZSwgdW5zaWduZWQgbG9uZyBucl9wYWdlcykKIHsKIAl1bnNpZ25lZCBsb25nIG1hcHNfc2VjdGlvbl9uciwgcmVtb3Zpbmdfc2VjdGlvbl9uciwgaTsKLQlpbnQgbWFnaWM7CisJdW5zaWduZWQgbG9uZyBtYWdpYzsKIAogCWZvciAoaSA9IDA7IGkgPCBucl9wYWdlczsgaSsrLCBwYWdlKyspIHsKLQkJbWFnaWMgPSBhdG9taWNfcmVhZCgmcGFnZS0+X21hcGNvdW50KTsKKwkJbWFnaWMgPSAodW5zaWduZWQgbG9uZykgcGFnZS0+bHJ1Lm5leHQ7CiAKIAkJQlVHX09OKG1hZ2ljID09IE5PREVfSU5GTyk7CiAKZGlmZiAtLWdpdCBhL21tL3N3YXAuYyBiL21tL3N3YXAuYwppbmRleCAzZjQ4NTQyLi5jMDJmOTM2IDEwMDY0NAotLS0gYS9tbS9zd2FwLmMKKysrIGIvbW0vc3dhcC5jCkBAIC01NiwxNyArNTYsOTcgQEAKIAkJZGVsX3BhZ2VfZnJvbV9scnUoem9uZSwgcGFnZSk7CiAJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnpvbmUtPmxydV9sb2NrLCBmbGFncyk7CiAJfQorfQorCitzdGF0aWMgdm9pZCBfX3B1dF9zaW5nbGVfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwlfX3BhZ2VfY2FjaGVfcmVsZWFzZShwYWdlKTsKIAlmcmVlX2hvdF9jb2xkX3BhZ2UocGFnZSwgMCk7CiB9CiAKK3N0YXRpYyB2b2lkIF9fcHV0X2NvbXBvdW5kX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCit7CisJY29tcG91bmRfcGFnZV9kdG9yICpkdG9yOworCisJX19wYWdlX2NhY2hlX3JlbGVhc2UocGFnZSk7CisJZHRvciA9IGdldF9jb21wb3VuZF9wYWdlX2R0b3IocGFnZSk7CisJKCpkdG9yKShwYWdlKTsKK30KKwogc3RhdGljIHZvaWQgcHV0X2NvbXBvdW5kX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCiB7Ci0JcGFnZSA9IGNvbXBvdW5kX2hlYWQocGFnZSk7Ci0JaWYgKHB1dF9wYWdlX3Rlc3R6ZXJvKHBhZ2UpKSB7Ci0JCWNvbXBvdW5kX3BhZ2VfZHRvciAqZHRvcjsKLQotCQlkdG9yID0gZ2V0X2NvbXBvdW5kX3BhZ2VfZHRvcihwYWdlKTsKLQkJKCpkdG9yKShwYWdlKTsKKwlpZiAodW5saWtlbHkoUGFnZVRhaWwocGFnZSkpKSB7CisJCS8qIF9fc3BsaXRfaHVnZV9wYWdlX3JlZmNvdW50IGNhbiBydW4gdW5kZXIgdXMgKi8KKwkJc3RydWN0IHBhZ2UgKnBhZ2VfaGVhZCA9IHBhZ2UtPmZpcnN0X3BhZ2U7CisJCXNtcF9ybWIoKTsKKwkJLyoKKwkJICogSWYgUGFnZVRhaWwgaXMgc3RpbGwgc2V0IGFmdGVyIHNtcF9ybWIoKSB3ZSBjYW4gYmUgc3VyZQorCQkgKiB0aGF0IHRoZSBwYWdlLT5maXJzdF9wYWdlIHdlIHJlYWQgd2Fzbid0IGEgZGFuZ2xpbmcgcG9pbnRlci4KKwkJICogU2VlIF9fc3BsaXRfaHVnZV9wYWdlX3JlZmNvdW50KCkgc21wX3dtYigpLgorCQkgKi8KKwkJaWYgKGxpa2VseShQYWdlVGFpbChwYWdlKSAmJiBnZXRfcGFnZV91bmxlc3NfemVybyhwYWdlX2hlYWQpKSkgeworCQkJdW5zaWduZWQgbG9uZyBmbGFnczsKKwkJCS8qCisJCQkgKiBWZXJpZnkgdGhhdCBvdXIgcGFnZV9oZWFkIHdhc24ndCBjb252ZXJ0ZWQKKwkJCSAqIHRvIGEgYSByZWd1bGFyIHBhZ2UgYmVmb3JlIHdlIGdvdCBhCisJCQkgKiByZWZlcmVuY2Ugb24gaXQuCisJCQkgKi8KKwkJCWlmICh1bmxpa2VseSghUGFnZUhlYWQocGFnZV9oZWFkKSkpIHsKKwkJCQkvKiBQYWdlSGVhZCBpcyBjbGVhcmVkIGFmdGVyIFBhZ2VUYWlsICovCisJCQkJc21wX3JtYigpOworCQkJCVZNX0JVR19PTihQYWdlVGFpbChwYWdlKSk7CisJCQkJZ290byBvdXRfcHV0X2hlYWQ7CisJCQl9CisJCQkvKgorCQkJICogT25seSBydW4gY29tcG91bmRfbG9jayBvbiBhIHZhbGlkIFBhZ2VIZWFkLAorCQkJICogYWZ0ZXIgaGF2aW5nIGl0IHBpbm5lZCB3aXRoCisJCQkgKiBnZXRfcGFnZV91bmxlc3NfemVybygpIGFib3ZlLgorCQkJICovCisJCQlzbXBfbWIoKTsKKwkJCS8qIHBhZ2VfaGVhZCB3YXNuJ3QgYSBkYW5nbGluZyBwb2ludGVyICovCisJCQlmbGFncyA9IGNvbXBvdW5kX2xvY2tfaXJxc2F2ZShwYWdlX2hlYWQpOworCQkJaWYgKHVubGlrZWx5KCFQYWdlVGFpbChwYWdlKSkpIHsKKwkJCQkvKiBfX3NwbGl0X2h1Z2VfcGFnZV9yZWZjb3VudCBydW4gYmVmb3JlIHVzICovCisJCQkJY29tcG91bmRfdW5sb2NrX2lycXJlc3RvcmUocGFnZV9oZWFkLCBmbGFncyk7CisJCQkJVk1fQlVHX09OKFBhZ2VIZWFkKHBhZ2VfaGVhZCkpOworCQkJb3V0X3B1dF9oZWFkOgorCQkJCWlmIChwdXRfcGFnZV90ZXN0emVybyhwYWdlX2hlYWQpKQorCQkJCQlfX3B1dF9zaW5nbGVfcGFnZShwYWdlX2hlYWQpOworCQkJb3V0X3B1dF9zaW5nbGU6CisJCQkJaWYgKHB1dF9wYWdlX3Rlc3R6ZXJvKHBhZ2UpKQorCQkJCQlfX3B1dF9zaW5nbGVfcGFnZShwYWdlKTsKKwkJCQlyZXR1cm47CisJCQl9CisJCQlWTV9CVUdfT04ocGFnZV9oZWFkICE9IHBhZ2UtPmZpcnN0X3BhZ2UpOworCQkJLyoKKwkJCSAqIFdlIGNhbiByZWxlYXNlIHRoZSByZWZjb3VudCB0YWtlbiBieQorCQkJICogZ2V0X3BhZ2VfdW5sZXNzX3plcm8gbm93IHRoYXQKKwkJCSAqIHNwbGl0X2h1Z2VfcGFnZV9yZWZjb3VudCBpcyBibG9ja2VkIG9uIHRoZQorCQkJICogY29tcG91bmRfbG9jay4KKwkJCSAqLworCQkJaWYgKHB1dF9wYWdlX3Rlc3R6ZXJvKHBhZ2VfaGVhZCkpCisJCQkJVk1fQlVHX09OKDEpOworCQkJLyogX19zcGxpdF9odWdlX3BhZ2VfcmVmY291bnQgd2lsbCB3YWl0IG5vdyAqLworCQkJVk1fQlVHX09OKGF0b21pY19yZWFkKCZwYWdlLT5fY291bnQpIDw9IDApOworCQkJYXRvbWljX2RlYygmcGFnZS0+X2NvdW50KTsKKwkJCVZNX0JVR19PTihhdG9taWNfcmVhZCgmcGFnZV9oZWFkLT5fY291bnQpIDw9IDApOworCQkJY29tcG91bmRfdW5sb2NrX2lycXJlc3RvcmUocGFnZV9oZWFkLCBmbGFncyk7CisJCQlpZiAocHV0X3BhZ2VfdGVzdHplcm8ocGFnZV9oZWFkKSkgeworCQkJCWlmIChQYWdlSGVhZChwYWdlX2hlYWQpKQorCQkJCQlfX3B1dF9jb21wb3VuZF9wYWdlKHBhZ2VfaGVhZCk7CisJCQkJZWxzZQorCQkJCQlfX3B1dF9zaW5nbGVfcGFnZShwYWdlX2hlYWQpOworCQkJfQorCQl9IGVsc2UgeworCQkJLyogcGFnZV9oZWFkIGlzIGEgZGFuZ2xpbmcgcG9pbnRlciAqLworCQkJVk1fQlVHX09OKFBhZ2VUYWlsKHBhZ2UpKTsKKwkJCWdvdG8gb3V0X3B1dF9zaW5nbGU7CisJCX0KKwl9IGVsc2UgaWYgKHB1dF9wYWdlX3Rlc3R6ZXJvKHBhZ2UpKSB7CisJCWlmIChQYWdlSGVhZChwYWdlKSkKKwkJCV9fcHV0X2NvbXBvdW5kX3BhZ2UocGFnZSk7CisJCWVsc2UKKwkJCV9fcHV0X3NpbmdsZV9wYWdlKHBhZ2UpOwogCX0KIH0KIApAQCAtNzUsNyArMTU1LDcgQEAKIAlpZiAodW5saWtlbHkoUGFnZUNvbXBvdW5kKHBhZ2UpKSkKIAkJcHV0X2NvbXBvdW5kX3BhZ2UocGFnZSk7CiAJZWxzZSBpZiAocHV0X3BhZ2VfdGVzdHplcm8ocGFnZSkpCi0JCV9fcGFnZV9jYWNoZV9yZWxlYXNlKHBhZ2UpOworCQlfX3B1dF9zaW5nbGVfcGFnZShwYWdlKTsKIH0KIEVYUE9SVF9TWU1CT0wocHV0X3BhZ2UpOwogCkBAIC0zOTksNiArNDc5LDQzIEBACiAKIEVYUE9SVF9TWU1CT0woX19wYWdldmVjX3JlbGVhc2UpOwogCisvKiB1c2VkIGJ5IF9fc3BsaXRfaHVnZV9wYWdlX3JlZmNvdW50KCkgKi8KK3ZvaWQgbHJ1X2FkZF9wYWdlX3RhaWwoc3RydWN0IHpvbmUqIHpvbmUsCisJCSAgICAgICBzdHJ1Y3QgcGFnZSAqcGFnZSwgc3RydWN0IHBhZ2UgKnBhZ2VfdGFpbCkKK3sKKwlpbnQgYWN0aXZlOworCWVudW0gbHJ1X2xpc3QgbHJ1OworCWNvbnN0IGludCBmaWxlID0gMDsKKwlzdHJ1Y3QgbGlzdF9oZWFkICpoZWFkOworCisJVk1fQlVHX09OKCFQYWdlSGVhZChwYWdlKSk7CisJVk1fQlVHX09OKFBhZ2VDb21wb3VuZChwYWdlX3RhaWwpKTsKKwlWTV9CVUdfT04oUGFnZUxSVShwYWdlX3RhaWwpKTsKKwlWTV9CVUdfT04oIXNwaW5faXNfbG9ja2VkKCZ6b25lLT5scnVfbG9jaykpOworCisJU2V0UGFnZUxSVShwYWdlX3RhaWwpOworCisJaWYgKHBhZ2VfZXZpY3RhYmxlKHBhZ2VfdGFpbCwgTlVMTCkpIHsKKwkJaWYgKFBhZ2VBY3RpdmUocGFnZSkpIHsKKwkJCVNldFBhZ2VBY3RpdmUocGFnZV90YWlsKTsKKwkJCWFjdGl2ZSA9IDE7CisJCQlscnUgPSBMUlVfQUNUSVZFX0FOT047CisJCX0gZWxzZSB7CisJCQlhY3RpdmUgPSAwOworCQkJbHJ1ID0gTFJVX0lOQUNUSVZFX0FOT047CisJCX0KKwkJdXBkYXRlX3BhZ2VfcmVjbGFpbV9zdGF0KHpvbmUsIHBhZ2VfdGFpbCwgZmlsZSwgYWN0aXZlKTsKKwkJaWYgKGxpa2VseShQYWdlTFJVKHBhZ2UpKSkKKwkJCWhlYWQgPSBwYWdlLT5scnUucHJldjsKKwkJZWxzZQorCQkJaGVhZCA9ICZ6b25lLT5scnVbbHJ1XS5saXN0OworCQlfX2FkZF9wYWdlX3RvX2xydV9saXN0KHpvbmUsIHBhZ2VfdGFpbCwgbHJ1LCBoZWFkKTsKKwl9IGVsc2UgeworCQlTZXRQYWdlVW5ldmljdGFibGUocGFnZV90YWlsKTsKKwkJYWRkX3BhZ2VfdG9fbHJ1X2xpc3Qoem9uZSwgcGFnZV90YWlsLCBMUlVfVU5FVklDVEFCTEUpOworCX0KK30KKwogLyoKICAqIEFkZCB0aGUgcGFzc2VkIHBhZ2VzIHRvIHRoZSBMUlUsIHRoZW4gZHJvcCB0aGUgY2FsbGVyJ3MgcmVmY291bnQKICAqIG9uIHRoZW0uICBSZWluaXRpYWxpc2VzIHRoZSBjYWxsZXIncyBwYWdldmVjLgpkaWZmIC0tZ2l0IGEvbW0vc3dhcF9zdGF0ZS5jIGIvbW0vc3dhcF9zdGF0ZS5jCmluZGV4IGUxMGY1ODMuLjVjOGNmYWIgMTAwNjQ0Ci0tLSBhL21tL3N3YXBfc3RhdGUuYworKysgYi9tbS9zd2FwX3N0YXRlLmMKQEAgLTE1Nyw2ICsxNTcsMTIgQEAKIAlpZiAoIWVudHJ5LnZhbCkKIAkJcmV0dXJuIDA7CiAKKwlpZiAodW5saWtlbHkoUGFnZVRyYW5zSHVnZShwYWdlKSkpCisJCWlmICh1bmxpa2VseShzcGxpdF9odWdlX3BhZ2UocGFnZSkpKSB7CisJCQlzd2FwY2FjaGVfZnJlZShlbnRyeSwgTlVMTCk7CisJCQlyZXR1cm4gMDsKKwkJfQorCiAJLyoKIAkgKiBSYWRpeC10cmVlIG5vZGUgYWxsb2NhdGlvbnMgZnJvbSBQRl9NRU1BTExPQyBjb250ZXh0cyBjb3VsZAogCSAqIGNvbXBsZXRlbHkgZXhoYXVzdCB0aGUgcGFnZSBhbGxvY2F0b3IuIF9fR0ZQX05PTUVNQUxMT0MKZGlmZiAtLWdpdCBhL21tL3N3YXBmaWxlLmMgYi9tbS9zd2FwZmlsZS5jCmluZGV4IGI2YWRjZmIuLjA3YTQ1OGQgMTAwNjQ0Ci0tLSBhL21tL3N3YXBmaWxlLmMKKysrIGIvbW0vc3dhcGZpbGUuYwpAQCAtOTY0LDYgKzk2NCw4IEBACiAJcG1kID0gcG1kX29mZnNldChwdWQsIGFkZHIpOwogCWRvIHsKIAkJbmV4dCA9IHBtZF9hZGRyX2VuZChhZGRyLCBlbmQpOworCQlpZiAodW5saWtlbHkocG1kX3RyYW5zX2h1Z2UoKnBtZCkpKQorCQkJY29udGludWU7CiAJCWlmIChwbWRfbm9uZV9vcl9jbGVhcl9iYWQocG1kKSkKIAkJCWNvbnRpbnVlOwogCQlyZXQgPSB1bnVzZV9wdGVfcmFuZ2Uodm1hLCBwbWQsIGFkZHIsIG5leHQsIGVudHJ5LCBwYWdlKTsKZGlmZiAtLWdpdCBhL21tL3RydW5jYXRlLmMgYi9tbS90cnVuY2F0ZS5jCmluZGV4IDNjMmQ1ZGQuLjQ5ZmViNDYgMTAwNjQ0Ci0tLSBhL21tL3RydW5jYXRlLmMKKysrIGIvbW0vdHJ1bmNhdGUuYwpAQCAtNTQ5LDEzICs1NDksMTIgQEAKICAqIEBpbm9kZTogaW5vZGUKICAqIEBuZXdzaXplOiBuZXcgZmlsZSBzaXplCiAgKgotICogdHJ1bmNhdGVfc2V0c2l6ZSB1cGRhc3RlcyBpX3NpemUgdXBkYXRlIGFuZCBwZXJmb3JtcyBwYWdlY2FjaGUKLSAqIHRydW5jYXRpb24gKGlmIG5lY2Vzc2FyeSkgZm9yIGEgZmlsZSBzaXplIHVwZGF0ZXMuIEl0IHdpbGwgYmUKLSAqIHR5cGljYWxseSBiZSBjYWxsZWQgZnJvbSB0aGUgZmlsZXN5c3RlbSdzIHNldGF0dHIgZnVuY3Rpb24gd2hlbgotICogQVRUUl9TSVpFIGlzIHBhc3NlZCBpbi4KKyAqIHRydW5jYXRlX3NldHNpemUgdXBkYXRlcyBpX3NpemUgYW5kIHBlcmZvcm1zIHBhZ2VjYWNoZSB0cnVuY2F0aW9uIChpZgorICogbmVjZXNzYXJ5KSB0byBAbmV3c2l6ZS4gSXQgd2lsbCBiZSB0eXBpY2FsbHkgYmUgY2FsbGVkIGZyb20gdGhlIGZpbGVzeXN0ZW0ncworICogc2V0YXR0ciBmdW5jdGlvbiB3aGVuIEFUVFJfU0laRSBpcyBwYXNzZWQgaW4uCiAgKgotICogTXVzdCBiZSBjYWxsZWQgd2l0aCBpbm9kZV9tdXRleCBoZWxkIGFuZCBhZnRlciBhbGwgZmlsZXN5c3RlbQotICogc3BlY2lmaWMgYmxvY2sgdHJ1bmNhdGlvbiBoYXMgYmVlbiBwZXJmb3JtZWQuCisgKiBNdXN0IGJlIGNhbGxlZCB3aXRoIGlub2RlX211dGV4IGhlbGQgYW5kIGJlZm9yZSBhbGwgZmlsZXN5c3RlbSBzcGVjaWZpYworICogYmxvY2sgdHJ1bmNhdGlvbiBoYXMgYmVlbiBwZXJmb3JtZWQuCiAgKi8KIHZvaWQgdHJ1bmNhdGVfc2V0c2l6ZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBsb2ZmX3QgbmV3c2l6ZSkKIHsKZGlmZiAtLWdpdCBhL21tL3ZtYWxsb2MuYyBiL21tL3ZtYWxsb2MuYwppbmRleCBlYjVjYzdkLi5mOWIxNjY3IDEwMDY0NAotLS0gYS9tbS92bWFsbG9jLmMKKysrIGIvbW0vdm1hbGxvYy5jCkBAIC03NDgsNyArNzQ4LDcgQEAKIAl2YSA9IGFsbG9jX3ZtYXBfYXJlYShWTUFQX0JMT0NLX1NJWkUsIFZNQVBfQkxPQ0tfU0laRSwKIAkJCQkJVk1BTExPQ19TVEFSVCwgVk1BTExPQ19FTkQsCiAJCQkJCW5vZGUsIGdmcF9tYXNrKTsKLQlpZiAodW5saWtlbHkoSVNfRVJSKHZhKSkpIHsKKwlpZiAoSVNfRVJSKHZhKSkgewogCQlrZnJlZSh2Yik7CiAJCXJldHVybiBFUlJfQ0FTVCh2YSk7CiAJfQpAQCAtMTE3NSw2ICsxMTc1LDcgQEAKIHsKIAl2dW5tYXBfcGFnZV9yYW5nZShhZGRyLCBhZGRyICsgc2l6ZSk7CiB9CitFWFBPUlRfU1lNQk9MX0dQTCh1bm1hcF9rZXJuZWxfcmFuZ2Vfbm9mbHVzaCk7CiAKIC8qKgogICogdW5tYXBfa2VybmVsX3JhbmdlIC0gdW5tYXAga2VybmVsIFZNIGFyZWEgYW5kIGZsdXNoIGNhY2hlIGFuZCBUTEIKQEAgLTEzMTUsMTMgKzEzMTYsNiBAQAogCQkJCQkJLTEsIEdGUF9LRVJORUwsIGNhbGxlcik7CiB9CiAKLXN0cnVjdCB2bV9zdHJ1Y3QgKmdldF92bV9hcmVhX25vZGUodW5zaWduZWQgbG9uZyBzaXplLCB1bnNpZ25lZCBsb25nIGZsYWdzLAotCQkJCSAgIGludCBub2RlLCBnZnBfdCBnZnBfbWFzaykKLXsKLQlyZXR1cm4gX19nZXRfdm1fYXJlYV9ub2RlKHNpemUsIDEsIGZsYWdzLCBWTUFMTE9DX1NUQVJULCBWTUFMTE9DX0VORCwKLQkJCQkgIG5vZGUsIGdmcF9tYXNrLCBfX2J1aWx0aW5fcmV0dXJuX2FkZHJlc3MoMCkpOwotfQotCiBzdGF0aWMgc3RydWN0IHZtX3N0cnVjdCAqZmluZF92bV9hcmVhKGNvbnN0IHZvaWQgKmFkZHIpCiB7CiAJc3RydWN0IHZtYXBfYXJlYSAqdmE7CkBAIC0xNTM3LDE3ICsxNTMxLDQ3IEBACiAJcmV0dXJuIE5VTEw7CiB9CiAKLXZvaWQgKl9fdm1hbGxvY19hcmVhKHN0cnVjdCB2bV9zdHJ1Y3QgKmFyZWEsIGdmcF90IGdmcF9tYXNrLCBwZ3Byb3RfdCBwcm90KQorLyoqCisgKglfX3ZtYWxsb2Nfbm9kZV9yYW5nZSAgLSAgYWxsb2NhdGUgdmlydHVhbGx5IGNvbnRpZ3VvdXMgbWVtb3J5CisgKglAc2l6ZToJCWFsbG9jYXRpb24gc2l6ZQorICoJQGFsaWduOgkJZGVzaXJlZCBhbGlnbm1lbnQKKyAqCUBzdGFydDoJCXZtIGFyZWEgcmFuZ2Ugc3RhcnQKKyAqCUBlbmQ6CQl2bSBhcmVhIHJhbmdlIGVuZAorICoJQGdmcF9tYXNrOglmbGFncyBmb3IgdGhlIHBhZ2UgbGV2ZWwgYWxsb2NhdG9yCisgKglAcHJvdDoJCXByb3RlY3Rpb24gbWFzayBmb3IgdGhlIGFsbG9jYXRlZCBwYWdlcworICoJQG5vZGU6CQlub2RlIHRvIHVzZSBmb3IgYWxsb2NhdGlvbiBvciAtMQorICoJQGNhbGxlcjoJY2FsbGVyJ3MgcmV0dXJuIGFkZHJlc3MKKyAqCisgKglBbGxvY2F0ZSBlbm91Z2ggcGFnZXMgdG8gY292ZXIgQHNpemUgZnJvbSB0aGUgcGFnZSBsZXZlbAorICoJYWxsb2NhdG9yIHdpdGggQGdmcF9tYXNrIGZsYWdzLiAgTWFwIHRoZW0gaW50byBjb250aWd1b3VzCisgKglrZXJuZWwgdmlydHVhbCBzcGFjZSwgdXNpbmcgYSBwYWdldGFibGUgcHJvdGVjdGlvbiBvZiBAcHJvdC4KKyAqLwordm9pZCAqX192bWFsbG9jX25vZGVfcmFuZ2UodW5zaWduZWQgbG9uZyBzaXplLCB1bnNpZ25lZCBsb25nIGFsaWduLAorCQkJdW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWduZWQgbG9uZyBlbmQsIGdmcF90IGdmcF9tYXNrLAorCQkJcGdwcm90X3QgcHJvdCwgaW50IG5vZGUsIHZvaWQgKmNhbGxlcikKIHsKLQl2b2lkICphZGRyID0gX192bWFsbG9jX2FyZWFfbm9kZShhcmVhLCBnZnBfbWFzaywgcHJvdCwgLTEsCi0JCQkJCSBfX2J1aWx0aW5fcmV0dXJuX2FkZHJlc3MoMCkpOworCXN0cnVjdCB2bV9zdHJ1Y3QgKmFyZWE7CisJdm9pZCAqYWRkcjsKKwl1bnNpZ25lZCBsb25nIHJlYWxfc2l6ZSA9IHNpemU7CisKKwlzaXplID0gUEFHRV9BTElHTihzaXplKTsKKwlpZiAoIXNpemUgfHwgKHNpemUgPj4gUEFHRV9TSElGVCkgPiB0b3RhbHJhbV9wYWdlcykKKwkJcmV0dXJuIE5VTEw7CisKKwlhcmVhID0gX19nZXRfdm1fYXJlYV9ub2RlKHNpemUsIGFsaWduLCBWTV9BTExPQywgc3RhcnQsIGVuZCwgbm9kZSwKKwkJCQkgIGdmcF9tYXNrLCBjYWxsZXIpOworCisJaWYgKCFhcmVhKQorCQlyZXR1cm4gTlVMTDsKKworCWFkZHIgPSBfX3ZtYWxsb2NfYXJlYV9ub2RlKGFyZWEsIGdmcF9tYXNrLCBwcm90LCBub2RlLCBjYWxsZXIpOwogCiAJLyoKIAkgKiBBIHJlZl9jb3VudCA9IDMgaXMgbmVlZGVkIGJlY2F1c2UgdGhlIHZtX3N0cnVjdCBhbmQgdm1hcF9hcmVhCiAJICogc3RydWN0dXJlcyBhbGxvY2F0ZWQgaW4gdGhlIF9fZ2V0X3ZtX2FyZWFfbm9kZSgpIGZ1bmN0aW9uIGNvbnRhaW4KIAkgKiByZWZlcmVuY2VzIHRvIHRoZSB2aXJ0dWFsIGFkZHJlc3Mgb2YgdGhlIHZtYWxsb2MnZWQgYmxvY2suCiAJICovCi0Ja21lbWxlYWtfYWxsb2MoYWRkciwgYXJlYS0+c2l6ZSAtIFBBR0VfU0laRSwgMywgZ2ZwX21hc2spOworCWttZW1sZWFrX2FsbG9jKGFkZHIsIHJlYWxfc2l6ZSwgMywgZ2ZwX21hc2spOwogCiAJcmV0dXJuIGFkZHI7CiB9CkBAIC0xNTY5LDMwICsxNTkzLDggQEAKIAkJCSAgICBnZnBfdCBnZnBfbWFzaywgcGdwcm90X3QgcHJvdCwKIAkJCSAgICBpbnQgbm9kZSwgdm9pZCAqY2FsbGVyKQogewotCXN0cnVjdCB2bV9zdHJ1Y3QgKmFyZWE7Ci0Jdm9pZCAqYWRkcjsKLQl1bnNpZ25lZCBsb25nIHJlYWxfc2l6ZSA9IHNpemU7Ci0KLQlzaXplID0gUEFHRV9BTElHTihzaXplKTsKLQlpZiAoIXNpemUgfHwgKHNpemUgPj4gUEFHRV9TSElGVCkgPiB0b3RhbHJhbV9wYWdlcykKLQkJcmV0dXJuIE5VTEw7Ci0KLQlhcmVhID0gX19nZXRfdm1fYXJlYV9ub2RlKHNpemUsIGFsaWduLCBWTV9BTExPQywgVk1BTExPQ19TVEFSVCwKLQkJCQkgIFZNQUxMT0NfRU5ELCBub2RlLCBnZnBfbWFzaywgY2FsbGVyKTsKLQotCWlmICghYXJlYSkKLQkJcmV0dXJuIE5VTEw7Ci0KLQlhZGRyID0gX192bWFsbG9jX2FyZWFfbm9kZShhcmVhLCBnZnBfbWFzaywgcHJvdCwgbm9kZSwgY2FsbGVyKTsKLQotCS8qCi0JICogQSByZWZfY291bnQgPSAzIGlzIG5lZWRlZCBiZWNhdXNlIHRoZSB2bV9zdHJ1Y3QgYW5kIHZtYXBfYXJlYQotCSAqIHN0cnVjdHVyZXMgYWxsb2NhdGVkIGluIHRoZSBfX2dldF92bV9hcmVhX25vZGUoKSBmdW5jdGlvbiBjb250YWluCi0JICogcmVmZXJlbmNlcyB0byB0aGUgdmlydHVhbCBhZGRyZXNzIG9mIHRoZSB2bWFsbG9jJ2VkIGJsb2NrLgotCSAqLwotCWttZW1sZWFrX2FsbG9jKGFkZHIsIHJlYWxfc2l6ZSwgMywgZ2ZwX21hc2spOwotCi0JcmV0dXJuIGFkZHI7CisJcmV0dXJuIF9fdm1hbGxvY19ub2RlX3JhbmdlKHNpemUsIGFsaWduLCBWTUFMTE9DX1NUQVJULCBWTUFMTE9DX0VORCwKKwkJCQlnZnBfbWFzaywgcHJvdCwgbm9kZSwgY2FsbGVyKTsKIH0KIAogdm9pZCAqX192bWFsbG9jKHVuc2lnbmVkIGxvbmcgc2l6ZSwgZ2ZwX3QgZ2ZwX21hc2ssIHBncHJvdF90IHByb3QpCkBAIC0yMjAzLDE3ICsyMjA1LDE2IEBACiAgKiBAc2l6ZXM6IGFycmF5IGNvbnRhaW5pbmcgc2l6ZSBvZiBlYWNoIGFyZWEKICAqIEBucl92bXM6IHRoZSBudW1iZXIgb2YgYXJlYXMgdG8gYWxsb2NhdGUKICAqIEBhbGlnbjogYWxpZ25tZW50LCBhbGwgZW50cmllcyBpbiBAb2Zmc2V0cyBhbmQgQHNpemVzIG11c3QgYmUgYWxpZ25lZCB0byB0aGlzCi0gKiBAZ2ZwX21hc2s6IGFsbG9jYXRpb24gbWFzawogICoKICAqIFJldHVybnM6IGttYWxsb2MnZCB2bV9zdHJ1Y3QgcG9pbnRlciBhcnJheSBwb2ludGluZyB0byBhbGxvY2F0ZWQKICAqCSAgICB2bV9zdHJ1Y3RzIG9uIHN1Y2Nlc3MsICVOVUxMIG9uIGZhaWx1cmUKICAqCiAgKiBQZXJjcHUgYWxsb2NhdG9yIHdhbnRzIHRvIHVzZSBjb25ncnVlbnQgdm0gYXJlYXMgc28gdGhhdCBpdCBjYW4KICAqIG1haW50YWluIHRoZSBvZmZzZXRzIGFtb25nIHBlcmNwdSBhcmVhcy4gIFRoaXMgZnVuY3Rpb24gYWxsb2NhdGVzCi0gKiBjb25ncnVlbnQgdm1hbGxvYyBhcmVhcyBmb3IgaXQuICBUaGVzZSBhcmVhcyB0ZW5kIHRvIGJlIHNjYXR0ZXJlZAotICogcHJldHR5IGZhciwgZGlzdGFuY2UgYmV0d2VlbiB0d28gYXJlYXMgZWFzaWx5IGdvaW5nIHVwIHRvCi0gKiBnaWdhYnl0ZXMuICBUbyBhdm9pZCBpbnRlcmFjdGluZyB3aXRoIHJlZ3VsYXIgdm1hbGxvY3MsIHRoZXNlIGFyZWFzCi0gKiBhcmUgYWxsb2NhdGVkIGZyb20gdG9wLgorICogY29uZ3J1ZW50IHZtYWxsb2MgYXJlYXMgZm9yIGl0IHdpdGggR0ZQX0tFUk5FTC4gIFRoZXNlIGFyZWFzIHRlbmQgdG8KKyAqIGJlIHNjYXR0ZXJlZCBwcmV0dHkgZmFyLCBkaXN0YW5jZSBiZXR3ZWVuIHR3byBhcmVhcyBlYXNpbHkgZ29pbmcgdXAKKyAqIHRvIGdpZ2FieXRlcy4gIFRvIGF2b2lkIGludGVyYWN0aW5nIHdpdGggcmVndWxhciB2bWFsbG9jcywgdGhlc2UKKyAqIGFyZWFzIGFyZSBhbGxvY2F0ZWQgZnJvbSB0b3AuCiAgKgogICogRGVzcGl0ZSBpdHMgY29tcGxpY2F0ZWQgbG9vaywgdGhpcyBhbGxvY2F0b3IgaXMgcmF0aGVyIHNpbXBsZS4gIEl0CiAgKiBkb2VzIGV2ZXJ5dGhpbmcgdG9wLWRvd24gYW5kIHNjYW5zIGFyZWFzIGZyb20gdGhlIGVuZCBsb29raW5nIGZvcgpAQCAtMjIyNCw3ICsyMjI1LDcgQEAKICAqLwogc3RydWN0IHZtX3N0cnVjdCAqKnBjcHVfZ2V0X3ZtX2FyZWFzKGNvbnN0IHVuc2lnbmVkIGxvbmcgKm9mZnNldHMsCiAJCQkJICAgICBjb25zdCBzaXplX3QgKnNpemVzLCBpbnQgbnJfdm1zLAotCQkJCSAgICAgc2l6ZV90IGFsaWduLCBnZnBfdCBnZnBfbWFzaykKKwkJCQkgICAgIHNpemVfdCBhbGlnbikKIHsKIAljb25zdCB1bnNpZ25lZCBsb25nIHZtYWxsb2Nfc3RhcnQgPSBBTElHTihWTUFMTE9DX1NUQVJULCBhbGlnbik7CiAJY29uc3QgdW5zaWduZWQgbG9uZyB2bWFsbG9jX2VuZCA9IFZNQUxMT0NfRU5EICYgfihhbGlnbiAtIDEpOwpAQCAtMjIzNCw4ICsyMjM1LDYgQEAKIAl1bnNpZ25lZCBsb25nIGJhc2UsIHN0YXJ0LCBlbmQsIGxhc3RfZW5kOwogCWJvb2wgcHVyZ2VkID0gZmFsc2U7CiAKLQlnZnBfbWFzayAmPSBHRlBfUkVDTEFJTV9NQVNLOwotCiAJLyogdmVyaWZ5IHBhcmFtZXRlcnMgYW5kIGFsbG9jYXRlIGRhdGEgc3RydWN0dXJlcyAqLwogCUJVR19PTihhbGlnbiAmIH5QQUdFX01BU0sgfHwgIWlzX3Bvd2VyX29mXzIoYWxpZ24pKTsKIAlmb3IgKGxhc3RfYXJlYSA9IDAsIGFyZWEgPSAwOyBhcmVhIDwgbnJfdm1zOyBhcmVhKyspIHsKQEAgLTIyNjgsMTQgKzIyNjcsMTQgQEAKIAkJcmV0dXJuIE5VTEw7CiAJfQogCi0Jdm1zID0ga3phbGxvYyhzaXplb2Yodm1zWzBdKSAqIG5yX3ZtcywgZ2ZwX21hc2spOwotCXZhcyA9IGt6YWxsb2Moc2l6ZW9mKHZhc1swXSkgKiBucl92bXMsIGdmcF9tYXNrKTsKKwl2bXMgPSBremFsbG9jKHNpemVvZih2bXNbMF0pICogbnJfdm1zLCBHRlBfS0VSTkVMKTsKKwl2YXMgPSBremFsbG9jKHNpemVvZih2YXNbMF0pICogbnJfdm1zLCBHRlBfS0VSTkVMKTsKIAlpZiAoIXZhcyB8fCAhdm1zKQogCQlnb3RvIGVycl9mcmVlOwogCiAJZm9yIChhcmVhID0gMDsgYXJlYSA8IG5yX3ZtczsgYXJlYSsrKSB7Ci0JCXZhc1thcmVhXSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCB2bWFwX2FyZWEpLCBnZnBfbWFzayk7Ci0JCXZtc1thcmVhXSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCB2bV9zdHJ1Y3QpLCBnZnBfbWFzayk7CisJCXZhc1thcmVhXSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCB2bWFwX2FyZWEpLCBHRlBfS0VSTkVMKTsKKwkJdm1zW2FyZWFdID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHZtX3N0cnVjdCksIEdGUF9LRVJORUwpOwogCQlpZiAoIXZhc1thcmVhXSB8fCAhdm1zW2FyZWFdKQogCQkJZ290byBlcnJfZnJlZTsKIAl9CkBAIC0yNDU2LDEzICsyNDU1LDggQEAKIAlzZXFfcHJpbnRmKG0sICIweCVwLTB4JXAgJTdsZCIsCiAJCXYtPmFkZHIsIHYtPmFkZHIgKyB2LT5zaXplLCB2LT5zaXplKTsKIAotCWlmICh2LT5jYWxsZXIpIHsKLQkJY2hhciBidWZmW0tTWU1fU1lNQk9MX0xFTl07Ci0KLQkJc2VxX3B1dGMobSwgJyAnKTsKLQkJc3ByaW50X3N5bWJvbChidWZmLCAodW5zaWduZWQgbG9uZyl2LT5jYWxsZXIpOwotCQlzZXFfcHV0cyhtLCBidWZmKTsKLQl9CisJaWYgKHYtPmNhbGxlcikKKwkJc2VxX3ByaW50ZihtLCAiICVwUyIsIHYtPmNhbGxlcik7CiAKIAlpZiAodi0+bnJfcGFnZXMpCiAJCXNlcV9wcmludGYobSwgIiBwYWdlcz0lZCIsIHYtPm5yX3BhZ2VzKTsKZGlmZiAtLWdpdCBhL21tL3Ztc2Nhbi5jIGIvbW0vdm1zY2FuLmMKaW5kZXggOWNhNTg3Yy4uMTc0OTdkMCAxMDA2NDQKLS0tIGEvbW0vdm1zY2FuLmMKKysrIGIvbW0vdm1zY2FuLmMKQEAgLTMyLDYgKzMyLDcgQEAKICNpbmNsdWRlIDxsaW51eC90b3BvbG9neS5oPgogI2luY2x1ZGUgPGxpbnV4L2NwdS5oPgogI2luY2x1ZGUgPGxpbnV4L2NwdXNldC5oPgorI2luY2x1ZGUgPGxpbnV4L2NvbXBhY3Rpb24uaD4KICNpbmNsdWRlIDxsaW51eC9ub3RpZmllci5oPgogI2luY2x1ZGUgPGxpbnV4L3J3c2VtLmg+CiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KQEAgLTUxLDExICs1MiwyMyBAQAogI2RlZmluZSBDUkVBVEVfVFJBQ0VfUE9JTlRTCiAjaW5jbHVkZSA8dHJhY2UvZXZlbnRzL3Ztc2Nhbi5oPgogCi1lbnVtIGx1bXB5X21vZGUgewotCUxVTVBZX01PREVfTk9ORSwKLQlMVU1QWV9NT0RFX0FTWU5DLAotCUxVTVBZX01PREVfU1lOQywKLX07CisvKgorICogcmVjbGFpbV9tb2RlIGRldGVybWluZXMgaG93IHRoZSBpbmFjdGl2ZSBsaXN0IGlzIHNocnVuaworICogUkVDTEFJTV9NT0RFX1NJTkdMRTogUmVjbGFpbSBvbmx5IG9yZGVyLTAgcGFnZXMKKyAqIFJFQ0xBSU1fTU9ERV9BU1lOQzogIERvIG5vdCBibG9jaworICogUkVDTEFJTV9NT0RFX1NZTkM6ICAgQWxsb3cgYmxvY2tpbmcgZS5nLiBjYWxsIHdhaXRfb25fcGFnZV93cml0ZWJhY2sKKyAqIFJFQ0xBSU1fTU9ERV9MVU1QWVJFQ0xBSU06IEZvciBoaWdoLW9yZGVyIGFsbG9jYXRpb25zLCB0YWtlIGEgcmVmZXJlbmNlCisgKgkJCXBhZ2UgZnJvbSB0aGUgTFJVIGFuZCByZWNsYWltIGFsbCBwYWdlcyB3aXRoaW4gYQorICoJCQluYXR1cmFsbHkgYWxpZ25lZCByYW5nZQorICogUkVDTEFJTV9NT0RFX0NPTVBBQ1RJT046IEZvciBoaWdoLW9yZGVyIGFsbG9jYXRpb25zLCByZWNsYWltIGEgbnVtYmVyIG9mCisgKgkJCW9yZGVyLTAgcGFnZXMgYW5kIHRoZW4gY29tcGFjdCB0aGUgem9uZQorICovCit0eXBlZGVmIHVuc2lnbmVkIF9fYml0d2lzZV9fIHJlY2xhaW1fbW9kZV90OworI2RlZmluZSBSRUNMQUlNX01PREVfU0lOR0xFCQkoKF9fZm9yY2UgcmVjbGFpbV9tb2RlX3QpMHgwMXUpCisjZGVmaW5lIFJFQ0xBSU1fTU9ERV9BU1lOQwkJKChfX2ZvcmNlIHJlY2xhaW1fbW9kZV90KTB4MDJ1KQorI2RlZmluZSBSRUNMQUlNX01PREVfU1lOQwkJKChfX2ZvcmNlIHJlY2xhaW1fbW9kZV90KTB4MDR1KQorI2RlZmluZSBSRUNMQUlNX01PREVfTFVNUFlSRUNMQUlNCSgoX19mb3JjZSByZWNsYWltX21vZGVfdCkweDA4dSkKKyNkZWZpbmUgUkVDTEFJTV9NT0RFX0NPTVBBQ1RJT04JCSgoX19mb3JjZSByZWNsYWltX21vZGVfdCkweDEwdSkKIAogc3RydWN0IHNjYW5fY29udHJvbCB7CiAJLyogSW5jcmVtZW50ZWQgYnkgdGhlIG51bWJlciBvZiBpbmFjdGl2ZSBwYWdlcyB0aGF0IHdlcmUgc2Nhbm5lZCAqLwpAQCAtODgsNyArMTAxLDcgQEAKIAkgKiBJbnRlbmQgdG8gcmVjbGFpbSBlbm91Z2ggY29udGludW91cyBtZW1vcnkgcmF0aGVyIHRoYW4gcmVjbGFpbQogCSAqIGVub3VnaCBhbW91bnQgb2YgbWVtb3J5LiBpLmUsIG1vZGUgZm9yIGhpZ2ggb3JkZXIgYWxsb2NhdGlvbi4KIAkgKi8KLQllbnVtIGx1bXB5X21vZGUgbHVtcHlfcmVjbGFpbV9tb2RlOworCXJlY2xhaW1fbW9kZV90IHJlY2xhaW1fbW9kZTsKIAogCS8qIFdoaWNoIGNncm91cCBkbyB3ZSByZWNsYWltIGZyb20gKi8KIAlzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtX2Nncm91cDsKQEAgLTI3MSwzNCArMjg0LDM3IEBACiAJcmV0dXJuIHJldDsKIH0KIAotc3RhdGljIHZvaWQgc2V0X2x1bXB5X3JlY2xhaW1fbW9kZShpbnQgcHJpb3JpdHksIHN0cnVjdCBzY2FuX2NvbnRyb2wgKnNjLAorc3RhdGljIHZvaWQgc2V0X3JlY2xhaW1fbW9kZShpbnQgcHJpb3JpdHksIHN0cnVjdCBzY2FuX2NvbnRyb2wgKnNjLAogCQkJCSAgIGJvb2wgc3luYykKIHsKLQllbnVtIGx1bXB5X21vZGUgbW9kZSA9IHN5bmMgPyBMVU1QWV9NT0RFX1NZTkMgOiBMVU1QWV9NT0RFX0FTWU5DOworCXJlY2xhaW1fbW9kZV90IHN5bmNtb2RlID0gc3luYyA/IFJFQ0xBSU1fTU9ERV9TWU5DIDogUkVDTEFJTV9NT0RFX0FTWU5DOwogCiAJLyoKLQkgKiBTb21lIHJlY2xhaW0gaGF2ZSBhbHJlZHkgYmVlbiBmYWlsZWQuIE5vIHdvcnRoIHRvIHRyeSBzeW5jaHJvbm91cwotCSAqIGx1bXB5IHJlY2xhaW0uCisJICogSW5pdGlhbGx5IGFzc3VtZSB3ZSBhcmUgZW50ZXJpbmcgZWl0aGVyIGx1bXB5IHJlY2xhaW0gb3IKKwkgKiByZWNsYWltL2NvbXBhY3Rpb24uRGVwZW5kaW5nIG9uIHRoZSBvcmRlciwgd2Ugd2lsbCBlaXRoZXIgc2V0IHRoZQorCSAqIHN5bmMgbW9kZSBvciBqdXN0IHJlY2xhaW0gb3JkZXItMCBwYWdlcyBsYXRlci4KIAkgKi8KLQlpZiAoc3luYyAmJiBzYy0+bHVtcHlfcmVjbGFpbV9tb2RlID09IExVTVBZX01PREVfTk9ORSkKLQkJcmV0dXJuOworCWlmIChDT01QQUNUSU9OX0JVSUxEKQorCQlzYy0+cmVjbGFpbV9tb2RlID0gUkVDTEFJTV9NT0RFX0NPTVBBQ1RJT047CisJZWxzZQorCQlzYy0+cmVjbGFpbV9tb2RlID0gUkVDTEFJTV9NT0RFX0xVTVBZUkVDTEFJTTsKIAogCS8qCi0JICogSWYgd2UgbmVlZCBhIGxhcmdlIGNvbnRpZ3VvdXMgY2h1bmsgb2YgbWVtb3J5LCBvciBoYXZlCi0JICogdHJvdWJsZSBnZXR0aW5nIGEgc21hbGwgc2V0IG9mIGNvbnRpZ3VvdXMgcGFnZXMsIHdlCi0JICogd2lsbCByZWNsYWltIGJvdGggYWN0aXZlIGFuZCBpbmFjdGl2ZSBwYWdlcy4KKwkgKiBBdm9pZCB1c2luZyBsdW1weSByZWNsYWltIG9yIHJlY2xhaW0vY29tcGFjdGlvbiBpZiBwb3NzaWJsZSBieQorCSAqIHJlc3RyaWN0aW5nIHdoZW4gaXRzIHNldCB0byBlaXRoZXIgY29zdGx5IGFsbG9jYXRpb25zIG9yIHdoZW4KKwkgKiB1bmRlciBtZW1vcnkgcHJlc3N1cmUKIAkgKi8KIAlpZiAoc2MtPm9yZGVyID4gUEFHRV9BTExPQ19DT1NUTFlfT1JERVIpCi0JCXNjLT5sdW1weV9yZWNsYWltX21vZGUgPSBtb2RlOworCQlzYy0+cmVjbGFpbV9tb2RlIHw9IHN5bmNtb2RlOwogCWVsc2UgaWYgKHNjLT5vcmRlciAmJiBwcmlvcml0eSA8IERFRl9QUklPUklUWSAtIDIpCi0JCXNjLT5sdW1weV9yZWNsYWltX21vZGUgPSBtb2RlOworCQlzYy0+cmVjbGFpbV9tb2RlIHw9IHN5bmNtb2RlOwogCWVsc2UKLQkJc2MtPmx1bXB5X3JlY2xhaW1fbW9kZSA9IExVTVBZX01PREVfTk9ORTsKKwkJc2MtPnJlY2xhaW1fbW9kZSA9IFJFQ0xBSU1fTU9ERV9TSU5HTEUgfCBSRUNMQUlNX01PREVfQVNZTkM7CiB9CiAKLXN0YXRpYyB2b2lkIGRpc2FibGVfbHVtcHlfcmVjbGFpbV9tb2RlKHN0cnVjdCBzY2FuX2NvbnRyb2wgKnNjKQorc3RhdGljIHZvaWQgcmVzZXRfcmVjbGFpbV9tb2RlKHN0cnVjdCBzY2FuX2NvbnRyb2wgKnNjKQogewotCXNjLT5sdW1weV9yZWNsYWltX21vZGUgPSBMVU1QWV9NT0RFX05PTkU7CisJc2MtPnJlY2xhaW1fbW9kZSA9IFJFQ0xBSU1fTU9ERV9TSU5HTEUgfCBSRUNMQUlNX01PREVfQVNZTkM7CiB9CiAKIHN0YXRpYyBpbmxpbmUgaW50IGlzX3BhZ2VfY2FjaGVfZnJlZWFibGUoc3RydWN0IHBhZ2UgKnBhZ2UpCkBAIC00MjksNyArNDQ1LDcgQEAKIAkJICogZmlyc3QgYXR0ZW1wdCB0byBmcmVlIGEgcmFuZ2Ugb2YgcGFnZXMgZmFpbHMuCiAJCSAqLwogCQlpZiAoUGFnZVdyaXRlYmFjayhwYWdlKSAmJgotCQkgICAgc2MtPmx1bXB5X3JlY2xhaW1fbW9kZSA9PSBMVU1QWV9NT0RFX1NZTkMpCisJCSAgICAoc2MtPnJlY2xhaW1fbW9kZSAmIFJFQ0xBSU1fTU9ERV9TWU5DKSkKIAkJCXdhaXRfb25fcGFnZV93cml0ZWJhY2socGFnZSk7CiAKIAkJaWYgKCFQYWdlV3JpdGViYWNrKHBhZ2UpKSB7CkBAIC00MzcsNyArNDUzLDcgQEAKIAkJCUNsZWFyUGFnZVJlY2xhaW0ocGFnZSk7CiAJCX0KIAkJdHJhY2VfbW1fdm1zY2FuX3dyaXRlcGFnZShwYWdlLAotCQkJdHJhY2VfcmVjbGFpbV9mbGFncyhwYWdlLCBzYy0+bHVtcHlfcmVjbGFpbV9tb2RlKSk7CisJCQl0cmFjZV9yZWNsYWltX2ZsYWdzKHBhZ2UsIHNjLT5yZWNsYWltX21vZGUpKTsKIAkJaW5jX3pvbmVfcGFnZV9zdGF0ZShwYWdlLCBOUl9WTVNDQU5fV1JJVEUpOwogCQlyZXR1cm4gUEFHRV9TVUNDRVNTOwogCX0KQEAgLTYyMiw3ICs2MzgsNyBAQAogCXJlZmVyZW5jZWRfcGFnZSA9IFRlc3RDbGVhclBhZ2VSZWZlcmVuY2VkKHBhZ2UpOwogCiAJLyogTHVtcHkgcmVjbGFpbSAtIGlnbm9yZSByZWZlcmVuY2VzICovCi0JaWYgKHNjLT5sdW1weV9yZWNsYWltX21vZGUgIT0gTFVNUFlfTU9ERV9OT05FKQorCWlmIChzYy0+cmVjbGFpbV9tb2RlICYgUkVDTEFJTV9NT0RFX0xVTVBZUkVDTEFJTSkKIAkJcmV0dXJuIFBBR0VSRUZfUkVDTEFJTTsKIAogCS8qCkBAIC03MzksNyArNzU1LDcgQEAKIAkJCSAqIGZvciBhbnkgcGFnZSBmb3Igd2hpY2ggd3JpdGViYWNrIGhhcyBhbHJlYWR5CiAJCQkgKiBzdGFydGVkLgogCQkJICovCi0JCQlpZiAoc2MtPmx1bXB5X3JlY2xhaW1fbW9kZSA9PSBMVU1QWV9NT0RFX1NZTkMgJiYKKwkJCWlmICgoc2MtPnJlY2xhaW1fbW9kZSAmIFJFQ0xBSU1fTU9ERV9TWU5DKSAmJgogCQkJICAgIG1heV9lbnRlcl9mcykKIAkJCQl3YWl0X29uX3BhZ2Vfd3JpdGViYWNrKHBhZ2UpOwogCQkJZWxzZSB7CkBAIC04OTUsNyArOTExLDcgQEAKIAkJCXRyeV90b19mcmVlX3N3YXAocGFnZSk7CiAJCXVubG9ja19wYWdlKHBhZ2UpOwogCQlwdXRiYWNrX2xydV9wYWdlKHBhZ2UpOwotCQlkaXNhYmxlX2x1bXB5X3JlY2xhaW1fbW9kZShzYyk7CisJCXJlc2V0X3JlY2xhaW1fbW9kZShzYyk7CiAJCWNvbnRpbnVlOwogCiBhY3RpdmF0ZV9sb2NrZWQ6CkBAIC05MDgsNyArOTI0LDcgQEAKIGtlZXBfbG9ja2VkOgogCQl1bmxvY2tfcGFnZShwYWdlKTsKIGtlZXA6Ci0JCWRpc2FibGVfbHVtcHlfcmVjbGFpbV9tb2RlKHNjKTsKKwkJcmVzZXRfcmVjbGFpbV9tb2RlKHNjKTsKIGtlZXBfbHVtcHk6CiAJCWxpc3RfYWRkKCZwYWdlLT5scnUsICZyZXRfcGFnZXMpOwogCQlWTV9CVUdfT04oUGFnZUxSVShwYWdlKSB8fCBQYWdlVW5ldmljdGFibGUocGFnZSkpOwpAQCAtMTAyOCw3ICsxMDQ0LDcgQEAKIAkJY2FzZSAwOgogCQkJbGlzdF9tb3ZlKCZwYWdlLT5scnUsIGRzdCk7CiAJCQltZW1fY2dyb3VwX2RlbF9scnUocGFnZSk7Ci0JCQlucl90YWtlbisrOworCQkJbnJfdGFrZW4gKz0gaHBhZ2VfbnJfcGFnZXMocGFnZSk7CiAJCQlicmVhazsKIAogCQljYXNlIC1FQlVTWToKQEAgLTEwODYsNyArMTEwMiw3IEBACiAJCQlpZiAoX19pc29sYXRlX2xydV9wYWdlKGN1cnNvcl9wYWdlLCBtb2RlLCBmaWxlKSA9PSAwKSB7CiAJCQkJbGlzdF9tb3ZlKCZjdXJzb3JfcGFnZS0+bHJ1LCBkc3QpOwogCQkJCW1lbV9jZ3JvdXBfZGVsX2xydShjdXJzb3JfcGFnZSk7Ci0JCQkJbnJfdGFrZW4rKzsKKwkJCQlucl90YWtlbiArPSBocGFnZV9ucl9wYWdlcyhwYWdlKTsKIAkJCQlucl9sdW1weV90YWtlbisrOwogCQkJCWlmIChQYWdlRGlydHkoY3Vyc29yX3BhZ2UpKQogCQkJCQlucl9sdW1weV9kaXJ0eSsrOwpAQCAtMTE0MSwxNCArMTE1NywxNSBAQAogCXN0cnVjdCBwYWdlICpwYWdlOwogCiAJbGlzdF9mb3JfZWFjaF9lbnRyeShwYWdlLCBwYWdlX2xpc3QsIGxydSkgeworCQlpbnQgbnVtcGFnZXMgPSBocGFnZV9ucl9wYWdlcyhwYWdlKTsKIAkJbHJ1ID0gcGFnZV9scnVfYmFzZV90eXBlKHBhZ2UpOwogCQlpZiAoUGFnZUFjdGl2ZShwYWdlKSkgewogCQkJbHJ1ICs9IExSVV9BQ1RJVkU7CiAJCQlDbGVhclBhZ2VBY3RpdmUocGFnZSk7Ci0JCQlucl9hY3RpdmUrKzsKKwkJCW5yX2FjdGl2ZSArPSBudW1wYWdlczsKIAkJfQogCQlpZiAoY291bnQpCi0JCQljb3VudFtscnVdKys7CisJCQljb3VudFtscnVdICs9IG51bXBhZ2VzOwogCX0KIAogCXJldHVybiBucl9hY3RpdmU7CkBAIC0xMjU4LDcgKzEyNzUsOCBAQAogCQlhZGRfcGFnZV90b19scnVfbGlzdCh6b25lLCBwYWdlLCBscnUpOwogCQlpZiAoaXNfYWN0aXZlX2xydShscnUpKSB7CiAJCQlpbnQgZmlsZSA9IGlzX2ZpbGVfbHJ1KGxydSk7Ci0JCQlyZWNsYWltX3N0YXQtPnJlY2VudF9yb3RhdGVkW2ZpbGVdKys7CisJCQlpbnQgbnVtcGFnZXMgPSBocGFnZV9ucl9wYWdlcyhwYWdlKTsKKwkJCXJlY2xhaW1fc3RhdC0+cmVjZW50X3JvdGF0ZWRbZmlsZV0gKz0gbnVtcGFnZXM7CiAJCX0KIAkJaWYgKCFwYWdldmVjX2FkZCgmcHZlYywgcGFnZSkpIHsKIAkJCXNwaW5fdW5sb2NrX2lycSgmem9uZS0+bHJ1X2xvY2spOwpAQCAtMTMyNCw3ICsxMzQyLDcgQEAKIAkJcmV0dXJuIGZhbHNlOwogCiAJLyogT25seSBzdGFsbCBvbiBsdW1weSByZWNsYWltICovCi0JaWYgKHNjLT5sdW1weV9yZWNsYWltX21vZGUgPT0gTFVNUFlfTU9ERV9OT05FKQorCWlmIChzYy0+cmVjbGFpbV9tb2RlICYgUkVDTEFJTV9NT0RFX1NJTkdMRSkKIAkJcmV0dXJuIGZhbHNlOwogCiAJLyogSWYgd2UgaGF2ZSByZWxhaW1lZCBldmVyeXRoaW5nIG9uIHRoZSBpc29sYXRlZCBsaXN0LCBubyBzdGFsbCAqLwpAQCAtMTM2OCwxNSArMTM4NiwxNSBAQAogCQkJcmV0dXJuIFNXQVBfQ0xVU1RFUl9NQVg7CiAJfQogCi0Jc2V0X2x1bXB5X3JlY2xhaW1fbW9kZShwcmlvcml0eSwgc2MsIGZhbHNlKTsKKwlzZXRfcmVjbGFpbV9tb2RlKHByaW9yaXR5LCBzYywgZmFsc2UpOwogCWxydV9hZGRfZHJhaW4oKTsKIAlzcGluX2xvY2tfaXJxKCZ6b25lLT5scnVfbG9jayk7CiAKIAlpZiAoc2Nhbm5pbmdfZ2xvYmFsX2xydShzYykpIHsKIAkJbnJfdGFrZW4gPSBpc29sYXRlX3BhZ2VzX2dsb2JhbChucl90b19zY2FuLAogCQkJJnBhZ2VfbGlzdCwgJm5yX3NjYW5uZWQsIHNjLT5vcmRlciwKLQkJCXNjLT5sdW1weV9yZWNsYWltX21vZGUgPT0gTFVNUFlfTU9ERV9OT05FID8KLQkJCQkJSVNPTEFURV9JTkFDVElWRSA6IElTT0xBVEVfQk9USCwKKwkJCXNjLT5yZWNsYWltX21vZGUgJiBSRUNMQUlNX01PREVfTFVNUFlSRUNMQUlNID8KKwkJCQkJSVNPTEFURV9CT1RIIDogSVNPTEFURV9JTkFDVElWRSwKIAkJCXpvbmUsIDAsIGZpbGUpOwogCQl6b25lLT5wYWdlc19zY2FubmVkICs9IG5yX3NjYW5uZWQ7CiAJCWlmIChjdXJyZW50X2lzX2tzd2FwZCgpKQpAQCAtMTM4OCw4ICsxNDA2LDggQEAKIAl9IGVsc2UgewogCQlucl90YWtlbiA9IG1lbV9jZ3JvdXBfaXNvbGF0ZV9wYWdlcyhucl90b19zY2FuLAogCQkJJnBhZ2VfbGlzdCwgJm5yX3NjYW5uZWQsIHNjLT5vcmRlciwKLQkJCXNjLT5sdW1weV9yZWNsYWltX21vZGUgPT0gTFVNUFlfTU9ERV9OT05FID8KLQkJCQkJSVNPTEFURV9JTkFDVElWRSA6IElTT0xBVEVfQk9USCwKKwkJCXNjLT5yZWNsYWltX21vZGUgJiBSRUNMQUlNX01PREVfTFVNUFlSRUNMQUlNID8KKwkJCQkJSVNPTEFURV9CT1RIIDogSVNPTEFURV9JTkFDVElWRSwKIAkJCXpvbmUsIHNjLT5tZW1fY2dyb3VwLAogCQkJMCwgZmlsZSk7CiAJCS8qCkBAIC0xNDExLDcgKzE0MjksNyBAQAogCiAJLyogQ2hlY2sgaWYgd2Ugc2hvdWxkIHN5bmNyb25vdXNseSB3YWl0IGZvciB3cml0ZWJhY2sgKi8KIAlpZiAoc2hvdWxkX3JlY2xhaW1fc3RhbGwobnJfdGFrZW4sIG5yX3JlY2xhaW1lZCwgcHJpb3JpdHksIHNjKSkgewotCQlzZXRfbHVtcHlfcmVjbGFpbV9tb2RlKHByaW9yaXR5LCBzYywgdHJ1ZSk7CisJCXNldF9yZWNsYWltX21vZGUocHJpb3JpdHksIHNjLCB0cnVlKTsKIAkJbnJfcmVjbGFpbWVkICs9IHNocmlua19wYWdlX2xpc3QoJnBhZ2VfbGlzdCwgem9uZSwgc2MpOwogCX0KIApAQCAtMTQyNiw3ICsxNDQ0LDcgQEAKIAkJem9uZV9pZHgoem9uZSksCiAJCW5yX3NjYW5uZWQsIG5yX3JlY2xhaW1lZCwKIAkJcHJpb3JpdHksCi0JCXRyYWNlX3Nocmlua19mbGFncyhmaWxlLCBzYy0+bHVtcHlfcmVjbGFpbV9tb2RlKSk7CisJCXRyYWNlX3Nocmlua19mbGFncyhmaWxlLCBzYy0+cmVjbGFpbV9tb2RlKSk7CiAJcmV0dXJuIG5yX3JlY2xhaW1lZDsKIH0KIApAQCAtMTQ2Niw3ICsxNDg0LDcgQEAKIAogCQlsaXN0X21vdmUoJnBhZ2UtPmxydSwgJnpvbmUtPmxydVtscnVdLmxpc3QpOwogCQltZW1fY2dyb3VwX2FkZF9scnVfbGlzdChwYWdlLCBscnUpOwotCQlwZ21vdmVkKys7CisJCXBnbW92ZWQgKz0gaHBhZ2VfbnJfcGFnZXMocGFnZSk7CiAKIAkJaWYgKCFwYWdldmVjX2FkZCgmcHZlYywgcGFnZSkgfHwgbGlzdF9lbXB0eShsaXN0KSkgewogCQkJc3Bpbl91bmxvY2tfaXJxKCZ6b25lLT5scnVfbG9jayk7CkBAIC0xNTM0LDcgKzE1NTIsNyBAQAogCQl9CiAKIAkJaWYgKHBhZ2VfcmVmZXJlbmNlZChwYWdlLCAwLCBzYy0+bWVtX2Nncm91cCwgJnZtX2ZsYWdzKSkgewotCQkJbnJfcm90YXRlZCsrOworCQkJbnJfcm90YXRlZCArPSBocGFnZV9ucl9wYWdlcyhwYWdlKTsKIAkJCS8qCiAJCQkgKiBJZGVudGlmeSByZWZlcmVuY2VkLCBmaWxlLWJhY2tlZCBhY3RpdmUgcGFnZXMgYW5kCiAJCQkgKiBnaXZlIHRoZW0gb25lIG1vcmUgdHJpcCBhcm91bmQgdGhlIGFjdGl2ZSBsaXN0LiBTbwpAQCAtMTgwNSw2ICsxODIzLDU3IEBACiB9CiAKIC8qCisgKiBSZWNsYWltL2NvbXBhY3Rpb24gZGVwZW5kcyBvbiBhIG51bWJlciBvZiBwYWdlcyBiZWluZyBmcmVlZC4gVG8gYXZvaWQKKyAqIGRpc3J1cHRpb24gdG8gdGhlIHN5c3RlbSwgYSBzbWFsbCBudW1iZXIgb2Ygb3JkZXItMCBwYWdlcyBjb250aW51ZSB0byBiZQorICogcm90YXRlZCBhbmQgcmVjbGFpbWVkIGluIHRoZSBub3JtYWwgZmFzaGlvbi4gSG93ZXZlciwgYnkgdGhlIHRpbWUgd2UgZ2V0CisgKiBiYWNrIHRvIHRoZSBhbGxvY2F0b3IgYW5kIGNhbGwgdHJ5X3RvX2NvbXBhY3Rfem9uZSgpLCB3ZSBlbnN1cmUgdGhhdAorICogdGhlcmUgYXJlIGVub3VnaCBmcmVlIHBhZ2VzIGZvciBpdCB0byBiZSBsaWtlbHkgc3VjY2Vzc2Z1bAorICovCitzdGF0aWMgaW5saW5lIGJvb2wgc2hvdWxkX2NvbnRpbnVlX3JlY2xhaW0oc3RydWN0IHpvbmUgKnpvbmUsCisJCQkJCXVuc2lnbmVkIGxvbmcgbnJfcmVjbGFpbWVkLAorCQkJCQl1bnNpZ25lZCBsb25nIG5yX3NjYW5uZWQsCisJCQkJCXN0cnVjdCBzY2FuX2NvbnRyb2wgKnNjKQoreworCXVuc2lnbmVkIGxvbmcgcGFnZXNfZm9yX2NvbXBhY3Rpb247CisJdW5zaWduZWQgbG9uZyBpbmFjdGl2ZV9scnVfcGFnZXM7CisKKwkvKiBJZiBub3QgaW4gcmVjbGFpbS9jb21wYWN0aW9uIG1vZGUsIHN0b3AgKi8KKwlpZiAoIShzYy0+cmVjbGFpbV9tb2RlICYgUkVDTEFJTV9NT0RFX0NPTVBBQ1RJT04pKQorCQlyZXR1cm4gZmFsc2U7CisKKwkvKgorCSAqIElmIHdlIGZhaWxlZCB0byByZWNsYWltIGFuZCBoYXZlIHNjYW5uZWQgdGhlIGZ1bGwgbGlzdCwgc3RvcC4KKwkgKiBOT1RFOiBDaGVja2luZyBqdXN0IG5yX3JlY2xhaW1lZCB3b3VsZCBleGl0IHJlY2xhaW0vY29tcGFjdGlvbiBmYXIKKwkgKiAgICAgICBmYXN0ZXIgYnV0IG9idmlvdXNseSB3b3VsZCBiZSBsZXNzIGxpa2VseSB0byBzdWNjZWVkCisJICogICAgICAgYWxsb2NhdGlvbi4gSWYgdGhpcyBpcyBkZXNpcmFibGUsIHVzZSBHRlBfUkVQRUFUIHRvIGRlY2lkZQorCSAqICAgICAgIGlmIGJvdGggcmVjbGFpbWVkIGFuZCBzY2FubmVkIHNob3VsZCBiZSBjaGVja2VkIG9yIGp1c3QKKwkgKiAgICAgICByZWNsYWltZWQKKwkgKi8KKwlpZiAoIW5yX3JlY2xhaW1lZCAmJiAhbnJfc2Nhbm5lZCkKKwkJcmV0dXJuIGZhbHNlOworCisJLyoKKwkgKiBJZiB3ZSBoYXZlIG5vdCByZWNsYWltZWQgZW5vdWdoIHBhZ2VzIGZvciBjb21wYWN0aW9uIGFuZCB0aGUKKwkgKiBpbmFjdGl2ZSBsaXN0cyBhcmUgbGFyZ2UgZW5vdWdoLCBjb250aW51ZSByZWNsYWltaW5nCisJICovCisJcGFnZXNfZm9yX2NvbXBhY3Rpb24gPSAoMlVMIDw8IHNjLT5vcmRlcik7CisJaW5hY3RpdmVfbHJ1X3BhZ2VzID0gem9uZV9ucl9scnVfcGFnZXMoem9uZSwgc2MsIExSVV9JTkFDVElWRV9BTk9OKSArCisJCQkJem9uZV9ucl9scnVfcGFnZXMoem9uZSwgc2MsIExSVV9JTkFDVElWRV9GSUxFKTsKKwlpZiAoc2MtPm5yX3JlY2xhaW1lZCA8IHBhZ2VzX2Zvcl9jb21wYWN0aW9uICYmCisJCQlpbmFjdGl2ZV9scnVfcGFnZXMgPiBwYWdlc19mb3JfY29tcGFjdGlvbikKKwkJcmV0dXJuIHRydWU7CisKKwkvKiBJZiBjb21wYWN0aW9uIHdvdWxkIGdvIGFoZWFkIG9yIHRoZSBhbGxvY2F0aW9uIHdvdWxkIHN1Y2NlZWQsIHN0b3AgKi8KKwlzd2l0Y2ggKGNvbXBhY3Rpb25fc3VpdGFibGUoem9uZSwgc2MtPm9yZGVyKSkgeworCWNhc2UgQ09NUEFDVF9QQVJUSUFMOgorCWNhc2UgQ09NUEFDVF9DT05USU5VRToKKwkJcmV0dXJuIGZhbHNlOworCWRlZmF1bHQ6CisJCXJldHVybiB0cnVlOworCX0KK30KKworLyoKICAqIFRoaXMgaXMgYSBiYXNpYyBwZXItem9uZSBwYWdlIGZyZWVyLiAgVXNlZCBieSBib3RoIGtzd2FwZCBhbmQgZGlyZWN0IHJlY2xhaW0uCiAgKi8KIHN0YXRpYyB2b2lkIHNocmlua196b25lKGludCBwcmlvcml0eSwgc3RydWN0IHpvbmUgKnpvbmUsCkBAIC0xODEzLDkgKzE4ODIsMTIgQEAKIAl1bnNpZ25lZCBsb25nIG5yW05SX0xSVV9MSVNUU107CiAJdW5zaWduZWQgbG9uZyBucl90b19zY2FuOwogCWVudW0gbHJ1X2xpc3QgbDsKLQl1bnNpZ25lZCBsb25nIG5yX3JlY2xhaW1lZCA9IHNjLT5ucl9yZWNsYWltZWQ7CisJdW5zaWduZWQgbG9uZyBucl9yZWNsYWltZWQsIG5yX3NjYW5uZWQ7CiAJdW5zaWduZWQgbG9uZyBucl90b19yZWNsYWltID0gc2MtPm5yX3RvX3JlY2xhaW07CiAKK3Jlc3RhcnQ6CisJbnJfcmVjbGFpbWVkID0gMDsKKwlucl9zY2FubmVkID0gc2MtPm5yX3NjYW5uZWQ7CiAJZ2V0X3NjYW5fY291bnQoem9uZSwgc2MsIG5yLCBwcmlvcml0eSk7CiAKIAl3aGlsZSAobnJbTFJVX0lOQUNUSVZFX0FOT05dIHx8IG5yW0xSVV9BQ1RJVkVfRklMRV0gfHwKQEAgLTE4NDEsOCArMTkxMyw3IEBACiAJCWlmIChucl9yZWNsYWltZWQgPj0gbnJfdG9fcmVjbGFpbSAmJiBwcmlvcml0eSA8IERFRl9QUklPUklUWSkKIAkJCWJyZWFrOwogCX0KLQotCXNjLT5ucl9yZWNsYWltZWQgPSBucl9yZWNsYWltZWQ7CisJc2MtPm5yX3JlY2xhaW1lZCArPSBucl9yZWNsYWltZWQ7CiAKIAkvKgogCSAqIEV2ZW4gaWYgd2UgZGlkIG5vdCB0cnkgdG8gZXZpY3QgYW5vbiBwYWdlcyBhdCBhbGwsIHdlIHdhbnQgdG8KQEAgLTE4NTEsNiArMTkyMiwxMSBAQAogCWlmIChpbmFjdGl2ZV9hbm9uX2lzX2xvdyh6b25lLCBzYykpCiAJCXNocmlua19hY3RpdmVfbGlzdChTV0FQX0NMVVNURVJfTUFYLCB6b25lLCBzYywgcHJpb3JpdHksIDApOwogCisJLyogcmVjbGFpbS9jb21wYWN0aW9uIG1pZ2h0IG5lZWQgcmVjbGFpbSB0byBjb250aW51ZSAqLworCWlmIChzaG91bGRfY29udGludWVfcmVjbGFpbSh6b25lLCBucl9yZWNsYWltZWQsCisJCQkJCXNjLT5ucl9zY2FubmVkIC0gbnJfc2Nhbm5lZCwgc2MpKQorCQlnb3RvIHJlc3RhcnQ7CisKIAl0aHJvdHRsZV92bV93cml0ZW91dChzYy0+Z2ZwX21hc2spOwogfQogCkBAIC0yMDA3LDcgKzIwODMsOCBAQAogCQkJc3RydWN0IHpvbmUgKnByZWZlcnJlZF96b25lOwogCiAJCQlmaXJzdF96b25lc196b25lbGlzdCh6b25lbGlzdCwgZ2ZwX3pvbmUoc2MtPmdmcF9tYXNrKSwKLQkJCQkJCQlOVUxMLCAmcHJlZmVycmVkX3pvbmUpOworCQkJCQkJJmNwdXNldF9jdXJyZW50X21lbXNfYWxsb3dlZCwKKwkJCQkJCSZwcmVmZXJyZWRfem9uZSk7CiAJCQl3YWl0X2lmZl9jb25nZXN0ZWQocHJlZmVycmVkX3pvbmUsIEJMS19SV19BU1lOQywgSFovMTApOwogCQl9CiAJfQpAQCAtMjEyNCwzOCArMjIwMSw4NyBAQAogfQogI2VuZGlmCiAKKy8qCisgKiBwZ2RhdF9iYWxhbmNlZCBpcyB1c2VkIHdoZW4gY2hlY2tpbmcgaWYgYSBub2RlIGlzIGJhbGFuY2VkIGZvciBoaWdoLW9yZGVyCisgKiBhbGxvY2F0aW9ucy4gT25seSB6b25lcyB0aGF0IG1lZXQgd2F0ZXJtYXJrcyBhbmQgYXJlIGluIGEgem9uZSBhbGxvd2VkCisgKiBieSB0aGUgY2FsbGVycyBjbGFzc3pvbmVfaWR4IGFyZSBhZGRlZCB0byBiYWxhbmNlZF9wYWdlcy4gVGhlIHRvdGFsIG9mCisgKiBiYWxhbmNlZCBwYWdlcyBtdXN0IGJlIGF0IGxlYXN0IDI1JSBvZiB0aGUgem9uZXMgYWxsb3dlZCBieSBjbGFzc3pvbmVfaWR4CisgKiBmb3IgdGhlIG5vZGUgdG8gYmUgY29uc2lkZXJlZCBiYWxhbmNlZC4gRm9yY2luZyBhbGwgem9uZXMgdG8gYmUgYmFsYW5jZWQKKyAqIGZvciBoaWdoIG9yZGVycyBjYW4gY2F1c2UgZXhjZXNzaXZlIHJlY2xhaW0gd2hlbiB0aGVyZSBhcmUgaW1iYWxhbmNlZCB6b25lcy4KKyAqIFRoZSBjaG9pY2Ugb2YgMjUlIGlzIGR1ZSB0bworICogICBvIGEgMTZNIERNQSB6b25lIHRoYXQgaXMgYmFsYW5jZWQgd2lsbCBub3QgYmFsYW5jZSBhIHpvbmUgb24gYW55CisgKiAgICAgcmVhc29uYWJsZSBzaXplZCBtYWNoaW5lCisgKiAgIG8gT24gYWxsIG90aGVyIG1hY2hpbmVzLCB0aGUgdG9wIHpvbmUgbXVzdCBiZSBhdCBsZWFzdCBhIHJlYXNvbmFibGUKKyAqICAgICBwcmVjZW50YWdlIG9mIHRoZSBtaWRkbGUgem9uZXMuIEZvciBleGFtcGxlLCBvbiAzMi1iaXQgeDg2LCBoaWdobWVtCisgKiAgICAgd291bGQgbmVlZCB0byBiZSBhdCBsZWFzdCAyNTZNIGZvciBpdCB0byBiZSBiYWxhbmNlIGEgd2hvbGUgbm9kZS4KKyAqICAgICBTaW1pbGFybHksIG9uIHg4Ni02NCB0aGUgTm9ybWFsIHpvbmUgd291bGQgbmVlZCB0byBiZSBhdCBsZWFzdCAxRworICogICAgIHRvIGJhbGFuY2UgYSBub2RlIG9uIGl0cyBvd24uIFRoZXNlIHNlZW1lZCBsaWtlIHJlYXNvbmFibGUgcmF0aW9zLgorICovCitzdGF0aWMgYm9vbCBwZ2RhdF9iYWxhbmNlZChwZ19kYXRhX3QgKnBnZGF0LCB1bnNpZ25lZCBsb25nIGJhbGFuY2VkX3BhZ2VzLAorCQkJCQkJaW50IGNsYXNzem9uZV9pZHgpCit7CisJdW5zaWduZWQgbG9uZyBwcmVzZW50X3BhZ2VzID0gMDsKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPD0gY2xhc3N6b25lX2lkeDsgaSsrKQorCQlwcmVzZW50X3BhZ2VzICs9IHBnZGF0LT5ub2RlX3pvbmVzW2ldLnByZXNlbnRfcGFnZXM7CisKKwlyZXR1cm4gYmFsYW5jZWRfcGFnZXMgPiAocHJlc2VudF9wYWdlcyA+PiAyKTsKK30KKwogLyogaXMga3N3YXBkIHNsZWVwaW5nIHByZW1hdHVyZWx5PyAqLwotc3RhdGljIGludCBzbGVlcGluZ19wcmVtYXR1cmVseShwZ19kYXRhX3QgKnBnZGF0LCBpbnQgb3JkZXIsIGxvbmcgcmVtYWluaW5nKQorc3RhdGljIGJvb2wgc2xlZXBpbmdfcHJlbWF0dXJlbHkocGdfZGF0YV90ICpwZ2RhdCwgaW50IG9yZGVyLCBsb25nIHJlbWFpbmluZywKKwkJCQkJaW50IGNsYXNzem9uZV9pZHgpCiB7CiAJaW50IGk7CisJdW5zaWduZWQgbG9uZyBiYWxhbmNlZCA9IDA7CisJYm9vbCBhbGxfem9uZXNfb2sgPSB0cnVlOwogCiAJLyogSWYgYSBkaXJlY3QgcmVjbGFpbWVyIHdva2Uga3N3YXBkIHdpdGhpbiBIWi8xMCwgaXQncyBwcmVtYXR1cmUgKi8KIAlpZiAocmVtYWluaW5nKQotCQlyZXR1cm4gMTsKKwkJcmV0dXJuIHRydWU7CiAKLQkvKiBJZiBhZnRlciBIWi8xMCwgYSB6b25lIGlzIGJlbG93IHRoZSBoaWdoIG1hcmssIGl0J3MgcHJlbWF0dXJlICovCisJLyogQ2hlY2sgdGhlIHdhdGVybWFyayBsZXZlbHMgKi8KIAlmb3IgKGkgPSAwOyBpIDwgcGdkYXQtPm5yX3pvbmVzOyBpKyspIHsKIAkJc3RydWN0IHpvbmUgKnpvbmUgPSBwZ2RhdC0+bm9kZV96b25lcyArIGk7CiAKIAkJaWYgKCFwb3B1bGF0ZWRfem9uZSh6b25lKSkKIAkJCWNvbnRpbnVlOwogCi0JCWlmICh6b25lLT5hbGxfdW5yZWNsYWltYWJsZSkKKwkJLyoKKwkJICogYmFsYW5jZV9wZ2RhdCgpIHNraXBzIG92ZXIgYWxsX3VucmVjbGFpbWFibGUgYWZ0ZXIKKwkJICogREVGX1BSSU9SSVRZLiBFZmZlY3RpdmVseSwgaXQgY29uc2lkZXJzIHRoZW0gYmFsYW5jZWQgc28KKwkJICogdGhleSBtdXN0IGJlIGNvbnNpZGVyZWQgYmFsYW5jZWQgaGVyZSBhcyB3ZWxsIGlmIGtzd2FwZAorCQkgKiBpcyB0byBzbGVlcAorCQkgKi8KKwkJaWYgKHpvbmUtPmFsbF91bnJlY2xhaW1hYmxlKSB7CisJCQliYWxhbmNlZCArPSB6b25lLT5wcmVzZW50X3BhZ2VzOwogCQkJY29udGludWU7CisJCX0KIAotCQlpZiAoIXpvbmVfd2F0ZXJtYXJrX29rKHpvbmUsIG9yZGVyLCBoaWdoX3dtYXJrX3BhZ2VzKHpvbmUpLAotCQkJCQkJCQkwLCAwKSkKLQkJCXJldHVybiAxOworCQlpZiAoIXpvbmVfd2F0ZXJtYXJrX29rX3NhZmUoem9uZSwgb3JkZXIsIGhpZ2hfd21hcmtfcGFnZXMoem9uZSksCisJCQkJCQkJY2xhc3N6b25lX2lkeCwgMCkpCisJCQlhbGxfem9uZXNfb2sgPSBmYWxzZTsKKwkJZWxzZQorCQkJYmFsYW5jZWQgKz0gem9uZS0+cHJlc2VudF9wYWdlczsKIAl9CiAKLQlyZXR1cm4gMDsKKwkvKgorCSAqIEZvciBoaWdoLW9yZGVyIHJlcXVlc3RzLCB0aGUgYmFsYW5jZWQgem9uZXMgbXVzdCBjb250YWluIGF0IGxlYXN0CisJICogMjUlIG9mIHRoZSBub2RlcyBwYWdlcyBmb3Iga3N3YXBkIHRvIHNsZWVwLiBGb3Igb3JkZXItMCwgYWxsIHpvbmVzCisJICogbXVzdCBiZSBiYWxhbmNlZAorCSAqLworCWlmIChvcmRlcikKKwkJcmV0dXJuIHBnZGF0X2JhbGFuY2VkKHBnZGF0LCBiYWxhbmNlZCwgY2xhc3N6b25lX2lkeCk7CisJZWxzZQorCQlyZXR1cm4gIWFsbF96b25lc19vazsKIH0KIAogLyoKICAqIEZvciBrc3dhcGQsIGJhbGFuY2VfcGdkYXQoKSB3aWxsIHdvcmsgYWNyb3NzIGFsbCB0aGlzIG5vZGUncyB6b25lcyB1bnRpbAogICogdGhleSBhcmUgYWxsIGF0IGhpZ2hfd21hcmtfcGFnZXMoem9uZSkuCiAgKgotICogUmV0dXJucyB0aGUgbnVtYmVyIG9mIHBhZ2VzIHdoaWNoIHdlcmUgYWN0dWFsbHkgZnJlZWQuCisgKiBSZXR1cm5zIHRoZSBmaW5hbCBvcmRlciBrc3dhcGQgd2FzIHJlY2xhaW1pbmcgYXQKICAqCiAgKiBUaGVyZSBpcyBzcGVjaWFsIGhhbmRsaW5nIGhlcmUgZm9yIHpvbmVzIHdoaWNoIGFyZSBmdWxsIG9mIHBpbm5lZCBwYWdlcy4KICAqIFRoaXMgY2FuIGhhcHBlbiBpZiB0aGUgcGFnZXMgYXJlIGFsbCBtbG9ja2VkLCBvciBpZiB0aGV5IGFyZSBhbGwgdXNlZCBieQpAQCAtMjE3MiwxMSArMjI5OCwxNCBAQAogICogaW50ZXJvcGVyYXRlcyB3aXRoIHRoZSBwYWdlIGFsbG9jYXRvciBmYWxsYmFjayBzY2hlbWUgdG8gZW5zdXJlIHRoYXQgYWdpbmcKICAqIG9mIHBhZ2VzIGlzIGJhbGFuY2VkIGFjcm9zcyB0aGUgem9uZXMuCiAgKi8KLXN0YXRpYyB1bnNpZ25lZCBsb25nIGJhbGFuY2VfcGdkYXQocGdfZGF0YV90ICpwZ2RhdCwgaW50IG9yZGVyKQorc3RhdGljIHVuc2lnbmVkIGxvbmcgYmFsYW5jZV9wZ2RhdChwZ19kYXRhX3QgKnBnZGF0LCBpbnQgb3JkZXIsCisJCQkJCQkJaW50ICpjbGFzc3pvbmVfaWR4KQogewogCWludCBhbGxfem9uZXNfb2s7CisJdW5zaWduZWQgbG9uZyBiYWxhbmNlZDsKIAlpbnQgcHJpb3JpdHk7CiAJaW50IGk7CisJaW50IGVuZF96b25lID0gMDsJLyogSW5jbHVzaXZlLiAgMCA9IFpPTkVfRE1BICovCiAJdW5zaWduZWQgbG9uZyB0b3RhbF9zY2FubmVkOwogCXN0cnVjdCByZWNsYWltX3N0YXRlICpyZWNsYWltX3N0YXRlID0gY3VycmVudC0+cmVjbGFpbV9zdGF0ZTsKIAlzdHJ1Y3Qgc2Nhbl9jb250cm9sIHNjID0gewpAQCAtMjE5OSw3ICsyMzI4LDYgQEAKIAljb3VudF92bV9ldmVudChQQUdFT1VUUlVOKTsKIAogCWZvciAocHJpb3JpdHkgPSBERUZfUFJJT1JJVFk7IHByaW9yaXR5ID49IDA7IHByaW9yaXR5LS0pIHsKLQkJaW50IGVuZF96b25lID0gMDsJLyogSW5jbHVzaXZlLiAgMCA9IFpPTkVfRE1BICovCiAJCXVuc2lnbmVkIGxvbmcgbHJ1X3BhZ2VzID0gMDsKIAkJaW50IGhhc191bmRlcl9taW5fd2F0ZXJtYXJrX3pvbmUgPSAwOwogCkBAIC0yMjA4LDYgKzIzMzYsNyBAQAogCQkJZGlzYWJsZV9zd2FwX3Rva2VuKCk7CiAKIAkJYWxsX3pvbmVzX29rID0gMTsKKwkJYmFsYW5jZWQgPSAwOwogCiAJCS8qCiAJCSAqIFNjYW4gaW4gdGhlIGhpZ2htZW0tPmRtYSBkaXJlY3Rpb24gZm9yIHRoZSBoaWdoZXN0CkBAIC0yMjMwLDkgKzIzNTksMTAgQEAKIAkJCQlzaHJpbmtfYWN0aXZlX2xpc3QoU1dBUF9DTFVTVEVSX01BWCwgem9uZSwKIAkJCQkJCQkmc2MsIHByaW9yaXR5LCAwKTsKIAotCQkJaWYgKCF6b25lX3dhdGVybWFya19vayh6b25lLCBvcmRlciwKKwkJCWlmICghem9uZV93YXRlcm1hcmtfb2tfc2FmZSh6b25lLCBvcmRlciwKIAkJCQkJaGlnaF93bWFya19wYWdlcyh6b25lKSwgMCwgMCkpIHsKIAkJCQllbmRfem9uZSA9IGk7CisJCQkJKmNsYXNzem9uZV9pZHggPSBpOwogCQkJCWJyZWFrOwogCQkJfQogCQl9CkBAIC0yMjU1LDYgKzIzODUsNyBAQAogCQkgKiBjYXVzZSB0b28gbXVjaCBzY2FubmluZyBvZiB0aGUgbG93ZXIgem9uZXMuCiAJCSAqLwogCQlmb3IgKGkgPSAwOyBpIDw9IGVuZF96b25lOyBpKyspIHsKKwkJCWludCBjb21wYWN0aW9uOwogCQkJc3RydWN0IHpvbmUgKnpvbmUgPSBwZ2RhdC0+bm9kZV96b25lcyArIGk7CiAJCQlpbnQgbnJfc2xhYjsKIApAQCAtMjI3Niw3ICsyNDA3LDcgQEAKIAkJCSAqIFdlIHB1dCBlcXVhbCBwcmVzc3VyZSBvbiBldmVyeSB6b25lLCB1bmxlc3Mgb25lCiAJCQkgKiB6b25lIGhhcyB3YXkgdG9vIG1hbnkgcGFnZXMgZnJlZSBhbHJlYWR5LgogCQkJICovCi0JCQlpZiAoIXpvbmVfd2F0ZXJtYXJrX29rKHpvbmUsIG9yZGVyLAorCQkJaWYgKCF6b25lX3dhdGVybWFya19va19zYWZlKHpvbmUsIG9yZGVyLAogCQkJCQk4KmhpZ2hfd21hcmtfcGFnZXMoem9uZSksIGVuZF96b25lLCAwKSkKIAkJCQlzaHJpbmtfem9uZShwcmlvcml0eSwgem9uZSwgJnNjKTsKIAkJCXJlY2xhaW1fc3RhdGUtPnJlY2xhaW1lZF9zbGFiID0gMDsKQEAgLTIyODQsOSArMjQxNSwyNiBAQAogCQkJCQkJbHJ1X3BhZ2VzKTsKIAkJCXNjLm5yX3JlY2xhaW1lZCArPSByZWNsYWltX3N0YXRlLT5yZWNsYWltZWRfc2xhYjsKIAkJCXRvdGFsX3NjYW5uZWQgKz0gc2MubnJfc2Nhbm5lZDsKKworCQkJY29tcGFjdGlvbiA9IDA7CisJCQlpZiAob3JkZXIgJiYKKwkJCSAgICB6b25lX3dhdGVybWFya19vayh6b25lLCAwLAorCQkJCQkgICAgICAgaGlnaF93bWFya19wYWdlcyh6b25lKSwKKwkJCQkJICAgICAgZW5kX3pvbmUsIDApICYmCisJCQkgICAgIXpvbmVfd2F0ZXJtYXJrX29rKHpvbmUsIG9yZGVyLAorCQkJCQkgICAgICAgaGlnaF93bWFya19wYWdlcyh6b25lKSwKKwkJCQkJICAgICAgIGVuZF96b25lLCAwKSkgeworCQkJCWNvbXBhY3Rfem9uZV9vcmRlcih6b25lLAorCQkJCQkJICAgb3JkZXIsCisJCQkJCQkgICBzYy5nZnBfbWFzaywgZmFsc2UsCisJCQkJCQkgICBDT01QQUNUX01PREVfS1NXQVBEKTsKKwkJCQljb21wYWN0aW9uID0gMTsKKwkJCX0KKwogCQkJaWYgKHpvbmUtPmFsbF91bnJlY2xhaW1hYmxlKQogCQkJCWNvbnRpbnVlOwotCQkJaWYgKG5yX3NsYWIgPT0gMCAmJiAhem9uZV9yZWNsYWltYWJsZSh6b25lKSkKKwkJCWlmICghY29tcGFjdGlvbiAmJiBucl9zbGFiID09IDAgJiYKKwkJCSAgICAhem9uZV9yZWNsYWltYWJsZSh6b25lKSkKIAkJCQl6b25lLT5hbGxfdW5yZWNsYWltYWJsZSA9IDE7CiAJCQkvKgogCQkJICogSWYgd2UndmUgZG9uZSBhIGRlY2VudCBhbW91bnQgb2Ygc2Nhbm5pbmcgYW5kCkBAIC0yMjk3LDcgKzI0NDUsNyBAQAogCQkJICAgIHRvdGFsX3NjYW5uZWQgPiBzYy5ucl9yZWNsYWltZWQgKyBzYy5ucl9yZWNsYWltZWQgLyAyKQogCQkJCXNjLm1heV93cml0ZXBhZ2UgPSAxOwogCi0JCQlpZiAoIXpvbmVfd2F0ZXJtYXJrX29rKHpvbmUsIG9yZGVyLAorCQkJaWYgKCF6b25lX3dhdGVybWFya19va19zYWZlKHpvbmUsIG9yZGVyLAogCQkJCQloaWdoX3dtYXJrX3BhZ2VzKHpvbmUpLCBlbmRfem9uZSwgMCkpIHsKIAkJCQlhbGxfem9uZXNfb2sgPSAwOwogCQkJCS8qCkBAIC0yMzA1LDcgKzI0NTMsNyBAQAogCQkJCSAqIG1lYW5zIHRoYXQgd2UgaGF2ZSBhIEdGUF9BVE9NSUMgYWxsb2NhdGlvbgogCQkJCSAqIGZhaWx1cmUgcmlzay4gSHVycnkgdXAhCiAJCQkJICovCi0JCQkJaWYgKCF6b25lX3dhdGVybWFya19vayh6b25lLCBvcmRlciwKKwkJCQlpZiAoIXpvbmVfd2F0ZXJtYXJrX29rX3NhZmUoem9uZSwgb3JkZXIsCiAJCQkJCSAgICBtaW5fd21hcmtfcGFnZXMoem9uZSksIGVuZF96b25lLCAwKSkKIAkJCQkJaGFzX3VuZGVyX21pbl93YXRlcm1hcmtfem9uZSA9IDE7CiAJCQl9IGVsc2UgewpAQCAtMjMxNywxMCArMjQ2NSwxMiBAQAogCQkJCSAqIHNwZWN0dWxhdGl2ZWx5IGF2b2lkIGNvbmdlc3Rpb24gd2FpdHMKIAkJCQkgKi8KIAkJCQl6b25lX2NsZWFyX2ZsYWcoem9uZSwgWk9ORV9DT05HRVNURUQpOworCQkJCWlmIChpIDw9ICpjbGFzc3pvbmVfaWR4KQorCQkJCQliYWxhbmNlZCArPSB6b25lLT5wcmVzZW50X3BhZ2VzOwogCQkJfQogCiAJCX0KLQkJaWYgKGFsbF96b25lc19vaykKKwkJaWYgKGFsbF96b25lc19vayB8fCAob3JkZXIgJiYgcGdkYXRfYmFsYW5jZWQocGdkYXQsIGJhbGFuY2VkLCAqY2xhc3N6b25lX2lkeCkpKQogCQkJYnJlYWs7CQkvKiBrc3dhcGQ6IGFsbCBkb25lICovCiAJCS8qCiAJCSAqIE9LLCBrc3dhcGQgaXMgZ2V0dGluZyBpbnRvIHRyb3VibGUuICBUYWtlIGEgbmFwLCB0aGVuIHRha2UKQEAgLTIzNDMsNyArMjQ5MywxMyBAQAogCQkJYnJlYWs7CiAJfQogb3V0OgotCWlmICghYWxsX3pvbmVzX29rKSB7CisKKwkvKgorCSAqIG9yZGVyLTA6IEFsbCB6b25lcyBtdXN0IG1lZXQgaGlnaCB3YXRlcm1hcmsgZm9yIGEgYmFsYW5jZWQgbm9kZQorCSAqIGhpZ2gtb3JkZXI6IEJhbGFuY2VkIHpvbmVzIG11c3QgbWFrZSB1cCBhdCBsZWFzdCAyNSUgb2YgdGhlIG5vZGUKKwkgKiAgICAgICAgICAgICBmb3IgdGhlIG5vZGUgdG8gYmUgYmFsYW5jZWQKKwkgKi8KKwlpZiAoIShhbGxfem9uZXNfb2sgfHwgKG9yZGVyICYmIHBnZGF0X2JhbGFuY2VkKHBnZGF0LCBiYWxhbmNlZCwgKmNsYXNzem9uZV9pZHgpKSkpIHsKIAkJY29uZF9yZXNjaGVkKCk7CiAKIAkJdHJ5X3RvX2ZyZWV6ZSgpOwpAQCAtMjM2OCw3ICsyNTI0LDg4IEBACiAJCWdvdG8gbG9vcF9hZ2FpbjsKIAl9CiAKLQlyZXR1cm4gc2MubnJfcmVjbGFpbWVkOworCS8qCisJICogSWYga3N3YXBkIHdhcyByZWNsYWltaW5nIGF0IGEgaGlnaGVyIG9yZGVyLCBpdCBoYXMgdGhlIG9wdGlvbiBvZgorCSAqIHNsZWVwaW5nIHdpdGhvdXQgYWxsIHpvbmVzIGJlaW5nIGJhbGFuY2VkLiBCZWZvcmUgaXQgZG9lcywgaXQgbXVzdAorCSAqIGVuc3VyZSB0aGF0IHRoZSB3YXRlcm1hcmtzIGZvciBvcmRlci0wIG9uICphbGwqIHpvbmVzIGFyZSBtZXQgYW5kCisJICogdGhhdCB0aGUgY29uZ2VzdGlvbiBmbGFncyBhcmUgY2xlYXJlZC4gVGhlIGNvbmdlc3Rpb24gZmxhZyBtdXN0CisJICogYmUgY2xlYXJlZCBhcyBrc3dhcGQgaXMgdGhlIG9ubHkgbWVjaGFuaXNtIHRoYXQgY2xlYXJzIHRoZSBmbGFnCisJICogYW5kIGl0IGlzIHBvdGVudGlhbGx5IGdvaW5nIHRvIHNsZWVwIGhlcmUuCisJICovCisJaWYgKG9yZGVyKSB7CisJCWZvciAoaSA9IDA7IGkgPD0gZW5kX3pvbmU7IGkrKykgeworCQkJc3RydWN0IHpvbmUgKnpvbmUgPSBwZ2RhdC0+bm9kZV96b25lcyArIGk7CisKKwkJCWlmICghcG9wdWxhdGVkX3pvbmUoem9uZSkpCisJCQkJY29udGludWU7CisKKwkJCWlmICh6b25lLT5hbGxfdW5yZWNsYWltYWJsZSAmJiBwcmlvcml0eSAhPSBERUZfUFJJT1JJVFkpCisJCQkJY29udGludWU7CisKKwkJCS8qIENvbmZpcm0gdGhlIHpvbmUgaXMgYmFsYW5jZWQgZm9yIG9yZGVyLTAgKi8KKwkJCWlmICghem9uZV93YXRlcm1hcmtfb2soem9uZSwgMCwKKwkJCQkJaGlnaF93bWFya19wYWdlcyh6b25lKSwgMCwgMCkpIHsKKwkJCQlvcmRlciA9IHNjLm9yZGVyID0gMDsKKwkJCQlnb3RvIGxvb3BfYWdhaW47CisJCQl9CisKKwkJCS8qIElmIGJhbGFuY2VkLCBjbGVhciB0aGUgY29uZ2VzdGVkIGZsYWcgKi8KKwkJCXpvbmVfY2xlYXJfZmxhZyh6b25lLCBaT05FX0NPTkdFU1RFRCk7CisJCX0KKwl9CisKKwkvKgorCSAqIFJldHVybiB0aGUgb3JkZXIgd2Ugd2VyZSByZWNsYWltaW5nIGF0IHNvIHNsZWVwaW5nX3ByZW1hdHVyZWx5KCkKKwkgKiBtYWtlcyBhIGRlY2lzaW9uIG9uIHRoZSBvcmRlciB3ZSB3ZXJlIGxhc3QgcmVjbGFpbWluZyBhdC4gSG93ZXZlciwKKwkgKiBpZiBhbm90aGVyIGNhbGxlciBlbnRlcmVkIHRoZSBhbGxvY2F0b3Igc2xvdyBwYXRoIHdoaWxlIGtzd2FwZAorCSAqIHdhcyBhd2FrZSwgb3JkZXIgd2lsbCByZW1haW4gYXQgdGhlIGhpZ2hlciBsZXZlbAorCSAqLworCSpjbGFzc3pvbmVfaWR4ID0gZW5kX3pvbmU7CisJcmV0dXJuIG9yZGVyOworfQorCitzdGF0aWMgdm9pZCBrc3dhcGRfdHJ5X3RvX3NsZWVwKHBnX2RhdGFfdCAqcGdkYXQsIGludCBvcmRlciwgaW50IGNsYXNzem9uZV9pZHgpCit7CisJbG9uZyByZW1haW5pbmcgPSAwOworCURFRklORV9XQUlUKHdhaXQpOworCisJaWYgKGZyZWV6aW5nKGN1cnJlbnQpIHx8IGt0aHJlYWRfc2hvdWxkX3N0b3AoKSkKKwkJcmV0dXJuOworCisJcHJlcGFyZV90b193YWl0KCZwZ2RhdC0+a3N3YXBkX3dhaXQsICZ3YWl0LCBUQVNLX0lOVEVSUlVQVElCTEUpOworCisJLyogVHJ5IHRvIHNsZWVwIGZvciBhIHNob3J0IGludGVydmFsICovCisJaWYgKCFzbGVlcGluZ19wcmVtYXR1cmVseShwZ2RhdCwgb3JkZXIsIHJlbWFpbmluZywgY2xhc3N6b25lX2lkeCkpIHsKKwkJcmVtYWluaW5nID0gc2NoZWR1bGVfdGltZW91dChIWi8xMCk7CisJCWZpbmlzaF93YWl0KCZwZ2RhdC0+a3N3YXBkX3dhaXQsICZ3YWl0KTsKKwkJcHJlcGFyZV90b193YWl0KCZwZ2RhdC0+a3N3YXBkX3dhaXQsICZ3YWl0LCBUQVNLX0lOVEVSUlVQVElCTEUpOworCX0KKworCS8qCisJICogQWZ0ZXIgYSBzaG9ydCBzbGVlcCwgY2hlY2sgaWYgaXQgd2FzIGEgcHJlbWF0dXJlIHNsZWVwLiBJZiBub3QsIHRoZW4KKwkgKiBnbyBmdWxseSB0byBzbGVlcCB1bnRpbCBleHBsaWNpdGx5IHdva2VuIHVwLgorCSAqLworCWlmICghc2xlZXBpbmdfcHJlbWF0dXJlbHkocGdkYXQsIG9yZGVyLCByZW1haW5pbmcsIGNsYXNzem9uZV9pZHgpKSB7CisJCXRyYWNlX21tX3Ztc2Nhbl9rc3dhcGRfc2xlZXAocGdkYXQtPm5vZGVfaWQpOworCisJCS8qCisJCSAqIHZtc3RhdCBjb3VudGVycyBhcmUgbm90IHBlcmZlY3RseSBhY2N1cmF0ZSBhbmQgdGhlIGVzdGltYXRlZAorCQkgKiB2YWx1ZSBmb3IgY291bnRlcnMgc3VjaCBhcyBOUl9GUkVFX1BBR0VTIGNhbiBkZXZpYXRlIGZyb20gdGhlCisJCSAqIHRydWUgdmFsdWUgYnkgbnJfb25saW5lX2NwdXMgKiB0aHJlc2hvbGQuIFRvIGF2b2lkIHRoZSB6b25lCisJCSAqIHdhdGVybWFya3MgYmVpbmcgYnJlYWNoZWQgd2hpbGUgdW5kZXIgcHJlc3N1cmUsIHdlIHJlZHVjZSB0aGUKKwkJICogcGVyLWNwdSB2bXN0YXQgdGhyZXNob2xkIHdoaWxlIGtzd2FwZCBpcyBhd2FrZSBhbmQgcmVzdG9yZQorCQkgKiB0aGVtIGJlZm9yZSBnb2luZyBiYWNrIHRvIHNsZWVwLgorCQkgKi8KKwkJc2V0X3BnZGF0X3BlcmNwdV90aHJlc2hvbGQocGdkYXQsIGNhbGN1bGF0ZV9ub3JtYWxfdGhyZXNob2xkKTsKKwkJc2NoZWR1bGUoKTsKKwkJc2V0X3BnZGF0X3BlcmNwdV90aHJlc2hvbGQocGdkYXQsIGNhbGN1bGF0ZV9wcmVzc3VyZV90aHJlc2hvbGQpOworCX0gZWxzZSB7CisJCWlmIChyZW1haW5pbmcpCisJCQljb3VudF92bV9ldmVudChLU1dBUERfTE9XX1dNQVJLX0hJVF9RVUlDS0xZKTsKKwkJZWxzZQorCQkJY291bnRfdm1fZXZlbnQoS1NXQVBEX0hJR0hfV01BUktfSElUX1FVSUNLTFkpOworCX0KKwlmaW5pc2hfd2FpdCgmcGdkYXQtPmtzd2FwZF93YWl0LCAmd2FpdCk7CiB9CiAKIC8qCkBAIC0yMzg3LDkgKzI2MjQsMTAgQEAKIHN0YXRpYyBpbnQga3N3YXBkKHZvaWQgKnApCiB7CiAJdW5zaWduZWQgbG9uZyBvcmRlcjsKKwlpbnQgY2xhc3N6b25lX2lkeDsKIAlwZ19kYXRhX3QgKnBnZGF0ID0gKHBnX2RhdGFfdCopcDsKIAlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzayA9IGN1cnJlbnQ7Ci0JREVGSU5FX1dBSVQod2FpdCk7CisKIAlzdHJ1Y3QgcmVjbGFpbV9zdGF0ZSByZWNsYWltX3N0YXRlID0gewogCQkucmVjbGFpbWVkX3NsYWIgPSAwLAogCX07CkBAIC0yNDE3LDQ5ICsyNjU1LDMwIEBACiAJc2V0X2ZyZWV6YWJsZSgpOwogCiAJb3JkZXIgPSAwOworCWNsYXNzem9uZV9pZHggPSBNQVhfTlJfWk9ORVMgLSAxOwogCWZvciAoIDsgOyApIHsKIAkJdW5zaWduZWQgbG9uZyBuZXdfb3JkZXI7CisJCWludCBuZXdfY2xhc3N6b25lX2lkeDsKIAkJaW50IHJldDsKIAotCQlwcmVwYXJlX3RvX3dhaXQoJnBnZGF0LT5rc3dhcGRfd2FpdCwgJndhaXQsIFRBU0tfSU5URVJSVVBUSUJMRSk7CiAJCW5ld19vcmRlciA9IHBnZGF0LT5rc3dhcGRfbWF4X29yZGVyOworCQluZXdfY2xhc3N6b25lX2lkeCA9IHBnZGF0LT5jbGFzc3pvbmVfaWR4OwogCQlwZ2RhdC0+a3N3YXBkX21heF9vcmRlciA9IDA7Ci0JCWlmIChvcmRlciA8IG5ld19vcmRlcikgeworCQlwZ2RhdC0+Y2xhc3N6b25lX2lkeCA9IE1BWF9OUl9aT05FUyAtIDE7CisJCWlmIChvcmRlciA8IG5ld19vcmRlciB8fCBjbGFzc3pvbmVfaWR4ID4gbmV3X2NsYXNzem9uZV9pZHgpIHsKIAkJCS8qCiAJCQkgKiBEb24ndCBzbGVlcCBpZiBzb21lb25lIHdhbnRzIGEgbGFyZ2VyICdvcmRlcicKLQkJCSAqIGFsbG9jYXRpb24KKwkJCSAqIGFsbG9jYXRpb24gb3IgaGFzIHRpZ2hlciB6b25lIGNvbnN0cmFpbnRzCiAJCQkgKi8KIAkJCW9yZGVyID0gbmV3X29yZGVyOworCQkJY2xhc3N6b25lX2lkeCA9IG5ld19jbGFzc3pvbmVfaWR4OwogCQl9IGVsc2UgewotCQkJaWYgKCFmcmVlemluZyhjdXJyZW50KSAmJiAha3RocmVhZF9zaG91bGRfc3RvcCgpKSB7Ci0JCQkJbG9uZyByZW1haW5pbmcgPSAwOwotCi0JCQkJLyogVHJ5IHRvIHNsZWVwIGZvciBhIHNob3J0IGludGVydmFsICovCi0JCQkJaWYgKCFzbGVlcGluZ19wcmVtYXR1cmVseShwZ2RhdCwgb3JkZXIsIHJlbWFpbmluZykpIHsKLQkJCQkJcmVtYWluaW5nID0gc2NoZWR1bGVfdGltZW91dChIWi8xMCk7Ci0JCQkJCWZpbmlzaF93YWl0KCZwZ2RhdC0+a3N3YXBkX3dhaXQsICZ3YWl0KTsKLQkJCQkJcHJlcGFyZV90b193YWl0KCZwZ2RhdC0+a3N3YXBkX3dhaXQsICZ3YWl0LCBUQVNLX0lOVEVSUlVQVElCTEUpOwotCQkJCX0KLQotCQkJCS8qCi0JCQkJICogQWZ0ZXIgYSBzaG9ydCBzbGVlcCwgY2hlY2sgaWYgaXQgd2FzIGEKLQkJCQkgKiBwcmVtYXR1cmUgc2xlZXAuIElmIG5vdCwgdGhlbiBnbyBmdWxseQotCQkJCSAqIHRvIHNsZWVwIHVudGlsIGV4cGxpY2l0bHkgd29rZW4gdXAKLQkJCQkgKi8KLQkJCQlpZiAoIXNsZWVwaW5nX3ByZW1hdHVyZWx5KHBnZGF0LCBvcmRlciwgcmVtYWluaW5nKSkgewotCQkJCQl0cmFjZV9tbV92bXNjYW5fa3N3YXBkX3NsZWVwKHBnZGF0LT5ub2RlX2lkKTsKLQkJCQkJc2NoZWR1bGUoKTsKLQkJCQl9IGVsc2UgewotCQkJCQlpZiAocmVtYWluaW5nKQotCQkJCQkJY291bnRfdm1fZXZlbnQoS1NXQVBEX0xPV19XTUFSS19ISVRfUVVJQ0tMWSk7Ci0JCQkJCWVsc2UKLQkJCQkJCWNvdW50X3ZtX2V2ZW50KEtTV0FQRF9ISUdIX1dNQVJLX0hJVF9RVUlDS0xZKTsKLQkJCQl9Ci0JCQl9Ci0KKwkJCWtzd2FwZF90cnlfdG9fc2xlZXAocGdkYXQsIG9yZGVyLCBjbGFzc3pvbmVfaWR4KTsKIAkJCW9yZGVyID0gcGdkYXQtPmtzd2FwZF9tYXhfb3JkZXI7CisJCQljbGFzc3pvbmVfaWR4ID0gcGdkYXQtPmNsYXNzem9uZV9pZHg7CisJCQlwZ2RhdC0+a3N3YXBkX21heF9vcmRlciA9IDA7CisJCQlwZ2RhdC0+Y2xhc3N6b25lX2lkeCA9IE1BWF9OUl9aT05FUyAtIDE7CiAJCX0KLQkJZmluaXNoX3dhaXQoJnBnZGF0LT5rc3dhcGRfd2FpdCwgJndhaXQpOwogCiAJCXJldCA9IHRyeV90b19mcmVlemUoKTsKIAkJaWYgKGt0aHJlYWRfc2hvdWxkX3N0b3AoKSkKQEAgLTI0NzEsNyArMjY5MCw3IEBACiAJCSAqLwogCQlpZiAoIXJldCkgewogCQkJdHJhY2VfbW1fdm1zY2FuX2tzd2FwZF93YWtlKHBnZGF0LT5ub2RlX2lkLCBvcmRlcik7Ci0JCQliYWxhbmNlX3BnZGF0KHBnZGF0LCBvcmRlcik7CisJCQlvcmRlciA9IGJhbGFuY2VfcGdkYXQocGdkYXQsIG9yZGVyLCAmY2xhc3N6b25lX2lkeCk7CiAJCX0KIAl9CiAJcmV0dXJuIDA7CkBAIC0yNDgwLDIzICsyNjk5LDI2IEBACiAvKgogICogQSB6b25lIGlzIGxvdyBvbiBmcmVlIG1lbW9yeSwgc28gd2FrZSBpdHMga3N3YXBkIHRhc2sgdG8gc2VydmljZSBpdC4KICAqLwotdm9pZCB3YWtldXBfa3N3YXBkKHN0cnVjdCB6b25lICp6b25lLCBpbnQgb3JkZXIpCit2b2lkIHdha2V1cF9rc3dhcGQoc3RydWN0IHpvbmUgKnpvbmUsIGludCBvcmRlciwgZW51bSB6b25lX3R5cGUgY2xhc3N6b25lX2lkeCkKIHsKIAlwZ19kYXRhX3QgKnBnZGF0OwogCiAJaWYgKCFwb3B1bGF0ZWRfem9uZSh6b25lKSkKIAkJcmV0dXJuOwogCi0JcGdkYXQgPSB6b25lLT56b25lX3BnZGF0OwotCWlmICh6b25lX3dhdGVybWFya19vayh6b25lLCBvcmRlciwgbG93X3dtYXJrX3BhZ2VzKHpvbmUpLCAwLCAwKSkKLQkJcmV0dXJuOwotCWlmIChwZ2RhdC0+a3N3YXBkX21heF9vcmRlciA8IG9yZGVyKQotCQlwZ2RhdC0+a3N3YXBkX21heF9vcmRlciA9IG9yZGVyOwotCXRyYWNlX21tX3Ztc2Nhbl93YWtldXBfa3N3YXBkKHBnZGF0LT5ub2RlX2lkLCB6b25lX2lkeCh6b25lKSwgb3JkZXIpOwogCWlmICghY3B1c2V0X3pvbmVfYWxsb3dlZF9oYXJkd2FsbCh6b25lLCBHRlBfS0VSTkVMKSkKIAkJcmV0dXJuOworCXBnZGF0ID0gem9uZS0+em9uZV9wZ2RhdDsKKwlpZiAocGdkYXQtPmtzd2FwZF9tYXhfb3JkZXIgPCBvcmRlcikgeworCQlwZ2RhdC0+a3N3YXBkX21heF9vcmRlciA9IG9yZGVyOworCQlwZ2RhdC0+Y2xhc3N6b25lX2lkeCA9IG1pbihwZ2RhdC0+Y2xhc3N6b25lX2lkeCwgY2xhc3N6b25lX2lkeCk7CisJfQogCWlmICghd2FpdHF1ZXVlX2FjdGl2ZSgmcGdkYXQtPmtzd2FwZF93YWl0KSkKIAkJcmV0dXJuOworCWlmICh6b25lX3dhdGVybWFya19va19zYWZlKHpvbmUsIG9yZGVyLCBsb3dfd21hcmtfcGFnZXMoem9uZSksIDAsIDApKQorCQlyZXR1cm47CisKKwl0cmFjZV9tbV92bXNjYW5fd2FrZXVwX2tzd2FwZChwZ2RhdC0+bm9kZV9pZCwgem9uZV9pZHgoem9uZSksIG9yZGVyKTsKIAl3YWtlX3VwX2ludGVycnVwdGlibGUoJnBnZGF0LT5rc3dhcGRfd2FpdCk7CiB9CiAKZGlmZiAtLWdpdCBhL21tL3Ztc3RhdC5jIGIvbW0vdm1zdGF0LmMKaW5kZXggMzEyZDcyOC4uMGMzYjUwNCAxMDA2NDQKLS0tIGEvbW0vdm1zdGF0LmMKKysrIGIvbW0vdm1zdGF0LmMKQEAgLTgzLDcgKzgzLDMxIEBACiAKICNpZmRlZiBDT05GSUdfU01QCiAKLXN0YXRpYyBpbnQgY2FsY3VsYXRlX3RocmVzaG9sZChzdHJ1Y3Qgem9uZSAqem9uZSkKK2ludCBjYWxjdWxhdGVfcHJlc3N1cmVfdGhyZXNob2xkKHN0cnVjdCB6b25lICp6b25lKQoreworCWludCB0aHJlc2hvbGQ7CisJaW50IHdhdGVybWFya19kaXN0YW5jZTsKKworCS8qCisJICogQXMgdm1zdGF0cyBhcmUgbm90IHVwIHRvIGRhdGUsIHRoZXJlIGlzIGRyaWZ0IGJldHdlZW4gdGhlIGVzdGltYXRlZAorCSAqIGFuZCByZWFsIHZhbHVlcy4gRm9yIGhpZ2ggdGhyZXNob2xkcyBhbmQgYSBoaWdoIG51bWJlciBvZiBDUFVzLCBpdAorCSAqIGlzIHBvc3NpYmxlIGZvciB0aGUgbWluIHdhdGVybWFyayB0byBiZSBicmVhY2hlZCB3aGlsZSB0aGUgZXN0aW1hdGVkCisJICogdmFsdWUgbG9va3MgZmluZS4gVGhlIHByZXNzdXJlIHRocmVzaG9sZCBpcyBhIHJlZHVjZWQgdmFsdWUgc3VjaAorCSAqIHRoYXQgZXZlbiB0aGUgbWF4aW11bSBhbW91bnQgb2YgZHJpZnQgd2lsbCBub3QgYWNjaWRlbnRhbGx5IGJyZWFjaAorCSAqIHRoZSBtaW4gd2F0ZXJtYXJrCisJICovCisJd2F0ZXJtYXJrX2Rpc3RhbmNlID0gbG93X3dtYXJrX3BhZ2VzKHpvbmUpIC0gbWluX3dtYXJrX3BhZ2VzKHpvbmUpOworCXRocmVzaG9sZCA9IG1heCgxLCAoaW50KSh3YXRlcm1hcmtfZGlzdGFuY2UgLyBudW1fb25saW5lX2NwdXMoKSkpOworCisJLyoKKwkgKiBNYXhpbXVtIHRocmVzaG9sZCBpcyAxMjUKKwkgKi8KKwl0aHJlc2hvbGQgPSBtaW4oMTI1LCB0aHJlc2hvbGQpOworCisJcmV0dXJuIHRocmVzaG9sZDsKK30KKworaW50IGNhbGN1bGF0ZV9ub3JtYWxfdGhyZXNob2xkKHN0cnVjdCB6b25lICp6b25lKQogewogCWludCB0aHJlc2hvbGQ7CiAJaW50IG1lbTsJLyogbWVtb3J5IGluIDEyOCBNQiB1bml0cyAqLwpAQCAtMTQyLDcgKzE2Niw3IEBACiAJZm9yX2VhY2hfcG9wdWxhdGVkX3pvbmUoem9uZSkgewogCQl1bnNpZ25lZCBsb25nIG1heF9kcmlmdCwgdG9sZXJhdGVfZHJpZnQ7CiAKLQkJdGhyZXNob2xkID0gY2FsY3VsYXRlX3RocmVzaG9sZCh6b25lKTsKKwkJdGhyZXNob2xkID0gY2FsY3VsYXRlX25vcm1hbF90aHJlc2hvbGQoem9uZSk7CiAKIAkJZm9yX2VhY2hfb25saW5lX2NwdShjcHUpCiAJCQlwZXJfY3B1X3B0cih6b25lLT5wYWdlc2V0LCBjcHUpLT5zdGF0X3RocmVzaG9sZApAQCAtMTYxLDYgKzE4NSwyNiBAQAogCX0KIH0KIAordm9pZCBzZXRfcGdkYXRfcGVyY3B1X3RocmVzaG9sZChwZ19kYXRhX3QgKnBnZGF0LAorCQkJCWludCAoKmNhbGN1bGF0ZV9wcmVzc3VyZSkoc3RydWN0IHpvbmUgKikpCit7CisJc3RydWN0IHpvbmUgKnpvbmU7CisJaW50IGNwdTsKKwlpbnQgdGhyZXNob2xkOworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IHBnZGF0LT5ucl96b25lczsgaSsrKSB7CisJCXpvbmUgPSAmcGdkYXQtPm5vZGVfem9uZXNbaV07CisJCWlmICghem9uZS0+cGVyY3B1X2RyaWZ0X21hcmspCisJCQljb250aW51ZTsKKworCQl0aHJlc2hvbGQgPSAoKmNhbGN1bGF0ZV9wcmVzc3VyZSkoem9uZSk7CisJCWZvcl9lYWNoX3Bvc3NpYmxlX2NwdShjcHUpCisJCQlwZXJfY3B1X3B0cih6b25lLT5wYWdlc2V0LCBjcHUpLT5zdGF0X3RocmVzaG9sZAorCQkJCQkJCT0gdGhyZXNob2xkOworCX0KK30KKwogLyoKICAqIEZvciB1c2Ugd2hlbiB3ZSBrbm93IHRoYXQgaW50ZXJydXB0cyBhcmUgZGlzYWJsZWQuCiAgKi8KQEAgLTgzNiw2ICs4ODAsNyBAQAogCSJudW1hX2xvY2FsIiwKIAkibnVtYV9vdGhlciIsCiAjZW5kaWYKKwkibnJfYW5vbl90cmFuc3BhcmVudF9odWdlcGFnZXMiLAogCSJucl9kaXJ0eV90aHJlc2hvbGQiLAogCSJucl9kaXJ0eV9iYWNrZ3JvdW5kX3RocmVzaG9sZCIsCiAKQEAgLTkxMSw3ICs5NTYsNyBAQAogCQkgICAiXG4gICAgICAgIHNjYW5uZWQgICVsdSIKIAkJICAgIlxuICAgICAgICBzcGFubmVkICAlbHUiCiAJCSAgICJcbiAgICAgICAgcHJlc2VudCAgJWx1IiwKLQkJICAgem9uZV9ucl9mcmVlX3BhZ2VzKHpvbmUpLAorCQkgICB6b25lX3BhZ2Vfc3RhdGUoem9uZSwgTlJfRlJFRV9QQUdFUyksCiAJCSAgIG1pbl93bWFya19wYWdlcyh6b25lKSwKIAkJICAgbG93X3dtYXJrX3BhZ2VzKHpvbmUpLAogCQkgICBoaWdoX3dtYXJrX3BhZ2VzKHpvbmUpLApkaWZmIC0tZ2l0IGEvbmV0L2F4MjUvYWZfYXgyNS5jIGIvbmV0L2F4MjUvYWZfYXgyNS5jCmluZGV4IGJiODZkMjkuLjZkYTVkYWUgMTAwNjQ0Ci0tLSBhL25ldC9heDI1L2FmX2F4MjUuYworKysgYi9uZXQvYXgyNS9hZl9heDI1LmMKQEAgLTEzOTIsNyArMTM5Miw3IEBACiAJYXgyNV9jYiAqYXgyNTsKIAlpbnQgZXJyID0gMDsKIAotCW1lbXNldChmc2EsIDAsIHNpemVvZihmc2EpKTsKKwltZW1zZXQoZnNhLCAwLCBzaXplb2YoKmZzYSkpOwogCWxvY2tfc29jayhzayk7CiAJYXgyNSA9IGF4MjVfc2soc2spOwogCmRpZmYgLS1naXQgYS9uZXQvYmF0bWFuLWFkdi9tYWluLmggYi9uZXQvYmF0bWFuLWFkdi9tYWluLmgKaW5kZXggZDRkOTkyNi4uNjUxMDZmYiAxMDA2NDQKLS0tIGEvbmV0L2JhdG1hbi1hZHYvbWFpbi5oCisrKyBiL25ldC9iYXRtYW4tYWR2L21haW4uaApAQCAtMTUxLDkgKzE1MSw5IEBACiAJfQkJCQkJCQlcCiAJd2hpbGUgKDApCiAjZWxzZSAvKiAhQ09ORklHX0JBVE1BTl9BRFZfREVCVUcgKi8KLXN0YXRpYyBpbmxpbmUgdm9pZCBiYXRfZGJnKGNoYXIgdHlwZSBfX2F0dHJpYnV0ZV9fKCh1bnVzZWQpKSwKLQkJCSAgIHN0cnVjdCBiYXRfcHJpdiAqYmF0X3ByaXYgX19hdHRyaWJ1dGVfXygodW51c2VkKSksCi0JCQkgICBjaGFyICpmbXQgX19hdHRyaWJ1dGVfXygodW51c2VkKSksIC4uLikKK3N0YXRpYyBpbmxpbmUgdm9pZCBiYXRfZGJnKGNoYXIgdHlwZSBfX2Fsd2F5c191bnVzZWQsCisJCQkgICBzdHJ1Y3QgYmF0X3ByaXYgKmJhdF9wcml2IF9fYWx3YXlzX3VudXNlZCwKKwkJCSAgIGNoYXIgKmZtdCBfX2Fsd2F5c191bnVzZWQsIC4uLikKIHsKIH0KICNlbmRpZgpkaWZmIC0tZ2l0IGEvbmV0L2JhdG1hbi1hZHYvcGFja2V0LmggYi9uZXQvYmF0bWFuLWFkdi9wYWNrZXQuaAppbmRleCBiNDlmZGY3Li4yMjg0ZTgxIDEwMDY0NAotLS0gYS9uZXQvYmF0bWFuLWFkdi9wYWNrZXQuaAorKysgYi9uZXQvYmF0bWFuLWFkdi9wYWNrZXQuaApAQCAtNjMsNyArNjMsNyBAQAogCXVpbnQ4X3QgIG51bV9obmE7CiAJdWludDhfdCAgZ3dfZmxhZ3M7ICAvKiBmbGFncyByZWxhdGVkIHRvIGdhdGV3YXkgY2xhc3MgKi8KIAl1aW50OF90ICBhbGlnbjsKLX0gX19hdHRyaWJ1dGVfXygocGFja2VkKSk7Cit9IF9fcGFja2VkOwogCiAjZGVmaW5lIEJBVF9QQUNLRVRfTEVOIHNpemVvZihzdHJ1Y3QgYmF0bWFuX3BhY2tldCkKIApAQCAtNzYsNyArNzYsNyBAQAogCXVpbnQ4X3QgIG9yaWdbNl07CiAJdWludDE2X3Qgc2Vxbm87CiAJdWludDhfdCAgdWlkOwotfSBfX2F0dHJpYnV0ZV9fKChwYWNrZWQpKTsKK30gX19wYWNrZWQ7CiAKICNkZWZpbmUgQkFUX1JSX0xFTiAxNgogCkBAIC05MywxNCArOTMsMTQgQEAKIAl1aW50OF90ICB1aWQ7CiAJdWludDhfdCAgcnJfY3VyOwogCXVpbnQ4X3QgIHJyW0JBVF9SUl9MRU5dW0VUSF9BTEVOXTsKLX0gX19hdHRyaWJ1dGVfXygocGFja2VkKSk7Cit9IF9fcGFja2VkOwogCiBzdHJ1Y3QgdW5pY2FzdF9wYWNrZXQgewogCXVpbnQ4X3QgIHBhY2tldF90eXBlOwogCXVpbnQ4X3QgIHZlcnNpb247ICAvKiBiYXRtYW4gdmVyc2lvbiBmaWVsZCAqLwogCXVpbnQ4X3QgIGRlc3RbNl07CiAJdWludDhfdCAgdHRsOwotfSBfX2F0dHJpYnV0ZV9fKChwYWNrZWQpKTsKK30gX19wYWNrZWQ7CiAKIHN0cnVjdCB1bmljYXN0X2ZyYWdfcGFja2V0IHsKIAl1aW50OF90ICBwYWNrZXRfdHlwZTsKQEAgLTExMCw3ICsxMTAsNyBAQAogCXVpbnQ4X3QgIGZsYWdzOwogCXVpbnQ4X3QgIG9yaWdbNl07CiAJdWludDE2X3Qgc2Vxbm87Ci19IF9fYXR0cmlidXRlX18oKHBhY2tlZCkpOworfSBfX3BhY2tlZDsKIAogc3RydWN0IGJjYXN0X3BhY2tldCB7CiAJdWludDhfdCAgcGFja2V0X3R5cGU7CkBAIC0xMTgsNyArMTE4LDcgQEAKIAl1aW50OF90ICBvcmlnWzZdOwogCXVpbnQ4X3QgIHR0bDsKIAl1aW50MzJfdCBzZXFubzsKLX0gX19hdHRyaWJ1dGVfXygocGFja2VkKSk7Cit9IF9fcGFja2VkOwogCiBzdHJ1Y3QgdmlzX3BhY2tldCB7CiAJdWludDhfdCAgcGFja2V0X3R5cGU7CkBAIC0xMzEsNiArMTMxLDYgQEAKIAkJCQkgICogbmVpZ2hib3JzICovCiAJdWludDhfdCAgdGFyZ2V0X29yaWdbNl07IC8qIHdobyBzaG91bGQgcmVjZWl2ZSB0aGlzIHBhY2tldCAqLwogCXVpbnQ4X3QgIHNlbmRlcl9vcmlnWzZdOyAvKiB3aG8gc2VudCBvciByZWJyb2FkY2FzdGVkIHRoaXMgcGFja2V0ICovCi19IF9fYXR0cmlidXRlX18oKHBhY2tlZCkpOworfSBfX3BhY2tlZDsKIAogI2VuZGlmIC8qIF9ORVRfQkFUTUFOX0FEVl9QQUNLRVRfSF8gKi8KZGlmZiAtLWdpdCBhL25ldC9iYXRtYW4tYWR2L3R5cGVzLmggYi9uZXQvYmF0bWFuLWFkdi90eXBlcy5oCmluZGV4IDk3Y2IyM2QuLmJmM2Y2ZjUgMTAwNjQ0Ci0tLSBhL25ldC9iYXRtYW4tYWR2L3R5cGVzLmgKKysrIGIvbmV0L2JhdG1hbi1hZHYvdHlwZXMuaApAQCAtMjQ2LDEzICsyNDYsMTMgQEAKIAkvKiB0aGlzIHBhY2tldCBtaWdodCBiZSBwYXJ0IG9mIHRoZSB2aXMgc2VuZCBxdWV1ZS4gKi8KIAlzdHJ1Y3Qgc2tfYnVmZiAqc2tiX3BhY2tldDsKIAkvKiB2aXNfaW5mbyBtYXkgZm9sbG93IGhlcmUqLwotfSBfX2F0dHJpYnV0ZV9fKChwYWNrZWQpKTsKK30gX19wYWNrZWQ7CiAKIHN0cnVjdCB2aXNfaW5mb19lbnRyeSB7CiAJdWludDhfdCAgc3JjW0VUSF9BTEVOXTsKIAl1aW50OF90ICBkZXN0W0VUSF9BTEVOXTsKIAl1aW50OF90ICBxdWFsaXR5OwkvKiBxdWFsaXR5ID0gMCBtZWFucyBITkEgKi8KLX0gX19hdHRyaWJ1dGVfXygocGFja2VkKSk7Cit9IF9fcGFja2VkOwogCiBzdHJ1Y3QgcmVjdmxpc3Rfbm9kZSB7CiAJc3RydWN0IGxpc3RfaGVhZCBsaXN0OwpkaWZmIC0tZ2l0IGEvbmV0L2JhdG1hbi1hZHYvdW5pY2FzdC5jIGIvbmV0L2JhdG1hbi1hZHYvdW5pY2FzdC5jCmluZGV4IGRjMmUyOGIuLmQxYTYxMTMgMTAwNjQ0Ci0tLSBhL25ldC9iYXRtYW4tYWR2L3VuaWNhc3QuYworKysgYi9uZXQvYmF0bWFuLWFkdi91bmljYXN0LmMKQEAgLTUwLDEyICs1MCwxMiBAQAogCQlza2IgPSB0ZnAtPnNrYjsKIAl9CiAKKwlpZiAoc2tiX2xpbmVhcml6ZShza2IpIDwgMCB8fCBza2JfbGluZWFyaXplKHRtcF9za2IpIDwgMCkKKwkJZ290byBlcnI7CisKIAlza2JfcHVsbCh0bXBfc2tiLCBzaXplb2Yoc3RydWN0IHVuaWNhc3RfZnJhZ19wYWNrZXQpKTsKLQlpZiAocHNrYl9leHBhbmRfaGVhZChza2IsIDAsIHRtcF9za2ItPmxlbiwgR0ZQX0FUT01JQykgPCAwKSB7Ci0JCS8qIGZyZWUgYnVmZmVyZWQgc2tiLCBza2Igd2lsbCBiZSBmcmVlZCBsYXRlciAqLwotCQlrZnJlZV9za2IodGZwLT5za2IpOwotCQlyZXR1cm4gTlVMTDsKLQl9CisJaWYgKHBza2JfZXhwYW5kX2hlYWQoc2tiLCAwLCB0bXBfc2tiLT5sZW4sIEdGUF9BVE9NSUMpIDwgMCkKKwkJZ290byBlcnI7CiAKIAkvKiBtb3ZlIGZyZWUgZW50cnkgdG8gZW5kICovCiAJdGZwLT5za2IgPSBOVUxMOwpAQCAtNzAsNiArNzAsMTEgQEAKIAl1bmljYXN0X3BhY2tldC0+cGFja2V0X3R5cGUgPSBCQVRfVU5JQ0FTVDsKIAogCXJldHVybiBza2I7CisKK2VycjoKKwkvKiBmcmVlIGJ1ZmZlcmVkIHNrYiwgc2tiIHdpbGwgYmUgZnJlZWQgbGF0ZXIgKi8KKwlrZnJlZV9za2IodGZwLT5za2IpOworCXJldHVybiBOVUxMOwogfQogCiBzdGF0aWMgdm9pZCBmcmFnX2NyZWF0ZV9lbnRyeShzdHJ1Y3QgbGlzdF9oZWFkICpoZWFkLCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQpAQCAtMjI5LDEwICsyMzQsMTIgQEAKIAlpZiAoIWJhdF9wcml2LT5wcmltYXJ5X2lmKQogCQlnb3RvIGRyb3BwZWQ7CiAKLQl1bmljYXN0X3BhY2tldCA9IChzdHJ1Y3QgdW5pY2FzdF9wYWNrZXQgKikgc2tiLT5kYXRhOwotCi0JbWVtY3B5KCZ0bXBfdWMsIHVuaWNhc3RfcGFja2V0LCB1Y19oZHJfbGVuKTsKIAlmcmFnX3NrYiA9IGRldl9hbGxvY19za2IoZGF0YV9sZW4gLSAoZGF0YV9sZW4gLyAyKSArIHVjZl9oZHJfbGVuKTsKKwlpZiAoIWZyYWdfc2tiKQorCQlnb3RvIGRyb3BwZWQ7CisKKwl1bmljYXN0X3BhY2tldCA9IChzdHJ1Y3QgdW5pY2FzdF9wYWNrZXQgKikgc2tiLT5kYXRhOworCW1lbWNweSgmdG1wX3VjLCB1bmljYXN0X3BhY2tldCwgdWNfaGRyX2xlbik7CiAJc2tiX3NwbGl0KHNrYiwgZnJhZ19za2IsIGRhdGFfbGVuIC8gMik7CiAKIAlpZiAobXlfc2tiX2hlYWRfcHVzaChza2IsIHVjZl9oZHJfbGVuIC0gdWNfaGRyX2xlbikgPCAwIHx8CmRpZmYgLS1naXQgYS9uZXQvYmF0bWFuLWFkdi92aXMuYyBiL25ldC9iYXRtYW4tYWR2L3Zpcy5jCmluZGV4IGNkNGM0MjMuLmRlMTAyMmMgMTAwNjQ0Ci0tLSBhL25ldC9iYXRtYW4tYWR2L3Zpcy5jCisrKyBiL25ldC9iYXRtYW4tYWR2L3Zpcy5jCkBAIC02NCw2ICs2NCw3IEBACiAKIAlzcGluX3VubG9ja19iaCgmYmF0X3ByaXYtPnZpc19saXN0X2xvY2spOwogCWtmcmVlX3NrYihpbmZvLT5za2JfcGFja2V0KTsKKwlrZnJlZShpbmZvKTsKIH0KIAogLyogQ29tcGFyZSB0d28gdmlzIHBhY2tldHMsIHVzZWQgYnkgdGhlIGhhc2hpbmcgYWxnb3JpdGhtICovCkBAIC0yNjgsMTAgKzI2OSwxMCBAQAogCQkJCWJ1ZmZfcG9zICs9IHNwcmludGYoYnVmZiArIGJ1ZmZfcG9zLCAiJXBNLCIsCiAJCQkJCQllbnRyeS0+YWRkcik7CiAKLQkJCQlmb3IgKGkgPSAwOyBpIDwgcGFja2V0LT5lbnRyaWVzOyBpKyspCisJCQkJZm9yIChqID0gMDsgaiA8IHBhY2tldC0+ZW50cmllczsgaisrKQogCQkJCQlidWZmX3BvcyArPSB2aXNfZGF0YV9yZWFkX2VudHJ5KAogCQkJCQkJCWJ1ZmYgKyBidWZmX3BvcywKLQkJCQkJCQkmZW50cmllc1tpXSwKKwkJCQkJCQkmZW50cmllc1tqXSwKIAkJCQkJCQllbnRyeS0+YWRkciwKIAkJCQkJCQllbnRyeS0+cHJpbWFyeSk7CiAKQEAgLTQ0NCw3ICs0NDUsNyBAQAogCQkJICAgICAgaW5mbyk7CiAJaWYgKGhhc2hfYWRkZWQgPCAwKSB7CiAJCS8qIGRpZCBub3Qgd29yayAoZm9yIHNvbWUgcmVhc29uKSAqLwotCQlrcmVmX3B1dCgmb2xkX2luZm8tPnJlZmNvdW50LCBmcmVlX2luZm8pOworCQlrcmVmX3B1dCgmaW5mby0+cmVmY291bnQsIGZyZWVfaW5mbyk7CiAJCWluZm8gPSBOVUxMOwogCX0KIApAQCAtODE1LDcgKzgxNiw3IEBACiAJCWNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3QgZGVsYXllZF93b3JrLCB3b3JrKTsKIAlzdHJ1Y3QgYmF0X3ByaXYgKmJhdF9wcml2ID0KIAkJY29udGFpbmVyX29mKGRlbGF5ZWRfd29yaywgc3RydWN0IGJhdF9wcml2LCB2aXNfd29yayk7Ci0Jc3RydWN0IHZpc19pbmZvICppbmZvLCAqdGVtcDsKKwlzdHJ1Y3QgdmlzX2luZm8gKmluZm87CiAKIAlzcGluX2xvY2tfYmgoJmJhdF9wcml2LT52aXNfaGFzaF9sb2NrKTsKIAlwdXJnZV92aXNfcGFja2V0cyhiYXRfcHJpdik7CkBAIC04MjUsOCArODI2LDkgQEAKIAkJc2VuZF9saXN0X2FkZChiYXRfcHJpdiwgYmF0X3ByaXYtPm15X3Zpc19pbmZvKTsKIAl9CiAKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoaW5mbywgdGVtcCwgJmJhdF9wcml2LT52aXNfc2VuZF9saXN0LAotCQkJCSBzZW5kX2xpc3QpIHsKKwl3aGlsZSAoIWxpc3RfZW1wdHkoJmJhdF9wcml2LT52aXNfc2VuZF9saXN0KSkgeworCQlpbmZvID0gbGlzdF9maXJzdF9lbnRyeSgmYmF0X3ByaXYtPnZpc19zZW5kX2xpc3QsCisJCQkJCXR5cGVvZigqaW5mbyksIHNlbmRfbGlzdCk7CiAKIAkJa3JlZl9nZXQoJmluZm8tPnJlZmNvdW50KTsKIAkJc3Bpbl91bmxvY2tfYmgoJmJhdF9wcml2LT52aXNfaGFzaF9sb2NrKTsKZGlmZiAtLWdpdCBhL25ldC9ibHVldG9vdGgvaGNpX2Nvbm4uYyBiL25ldC9ibHVldG9vdGgvaGNpX2Nvbm4uYwppbmRleCA2YjkwYTQxLi45OWNkOGQ5IDEwMDY0NAotLS0gYS9uZXQvYmx1ZXRvb3RoL2hjaV9jb25uLmMKKysrIGIvbmV0L2JsdWV0b290aC9oY2lfY29ubi5jCkBAIC0zNzksMTQgKzM3OSwxMCBAQAogCWhjaV9jb25uX2hvbGQoYWNsKTsKIAogCWlmIChhY2wtPnN0YXRlID09IEJUX09QRU4gfHwgYWNsLT5zdGF0ZSA9PSBCVF9DTE9TRUQpIHsKLQkJYWNsLT5zZWNfbGV2ZWwgPSBzZWNfbGV2ZWw7CisJCWFjbC0+c2VjX2xldmVsID0gQlRfU0VDVVJJVFlfTE9XOworCQlhY2wtPnBlbmRpbmdfc2VjX2xldmVsID0gc2VjX2xldmVsOwogCQlhY2wtPmF1dGhfdHlwZSA9IGF1dGhfdHlwZTsKIAkJaGNpX2FjbF9jb25uZWN0KGFjbCk7Ci0JfSBlbHNlIHsKLQkJaWYgKGFjbC0+c2VjX2xldmVsIDwgc2VjX2xldmVsKQotCQkJYWNsLT5zZWNfbGV2ZWwgPSBzZWNfbGV2ZWw7Ci0JCWlmIChhY2wtPmF1dGhfdHlwZSA8IGF1dGhfdHlwZSkKLQkJCWFjbC0+YXV0aF90eXBlID0gYXV0aF90eXBlOwogCX0KIAogCWlmICh0eXBlID09IEFDTF9MSU5LKQpAQCAtNDQyLDExICs0MzgsMTcgQEAKIHsKIAlCVF9EQkcoImNvbm4gJXAiLCBjb25uKTsKIAorCWlmIChjb25uLT5wZW5kaW5nX3NlY19sZXZlbCA+IHNlY19sZXZlbCkKKwkJc2VjX2xldmVsID0gY29ubi0+cGVuZGluZ19zZWNfbGV2ZWw7CisKIAlpZiAoc2VjX2xldmVsID4gY29ubi0+c2VjX2xldmVsKQotCQljb25uLT5zZWNfbGV2ZWwgPSBzZWNfbGV2ZWw7CisJCWNvbm4tPnBlbmRpbmdfc2VjX2xldmVsID0gc2VjX2xldmVsOwogCWVsc2UgaWYgKGNvbm4tPmxpbmtfbW9kZSAmIEhDSV9MTV9BVVRIKQogCQlyZXR1cm4gMTsKIAorCS8qIE1ha2Ugc3VyZSB3ZSBwcmVzZXJ2ZSBhbiBleGlzdGluZyBNSVRNIHJlcXVpcmVtZW50Ki8KKwlhdXRoX3R5cGUgfD0gKGNvbm4tPmF1dGhfdHlwZSAmIDB4MDEpOworCiAJY29ubi0+YXV0aF90eXBlID0gYXV0aF90eXBlOwogCiAJaWYgKCF0ZXN0X2FuZF9zZXRfYml0KEhDSV9DT05OX0FVVEhfUEVORCwgJmNvbm4tPnBlbmQpKSB7CmRpZmYgLS1naXQgYS9uZXQvYmx1ZXRvb3RoL2hjaV9jb3JlLmMgYi9uZXQvYmx1ZXRvb3RoL2hjaV9jb3JlLmMKaW5kZXggOGI2MDJkOC4uOWM0NTQxYiAxMDA2NDQKLS0tIGEvbmV0L2JsdWV0b290aC9oY2lfY29yZS5jCisrKyBiL25ldC9ibHVldG9vdGgvaGNpX2NvcmUuYwpAQCAtMTAxMSw2ICsxMDExLDEwIEBACiAKIAlkZXN0cm95X3dvcmtxdWV1ZShoZGV2LT53b3JrcXVldWUpOwogCisJaGNpX2Rldl9sb2NrX2JoKGhkZXYpOworCWhjaV9ibGFja2xpc3RfY2xlYXIoaGRldik7CisJaGNpX2Rldl91bmxvY2tfYmgoaGRldik7CisKIAlfX2hjaV9kZXZfcHV0KGhkZXYpOwogCiAJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9uZXQvYmx1ZXRvb3RoL2hjaV9ldmVudC5jIGIvbmV0L2JsdWV0b290aC9oY2lfZXZlbnQuYwppbmRleCAzODEwMDE3Li5hMjkwODU0IDEwMDY0NAotLS0gYS9uZXQvYmx1ZXRvb3RoL2hjaV9ldmVudC5jCisrKyBiL25ldC9ibHVldG9vdGgvaGNpX2V2ZW50LmMKQEAgLTY5MiwxMyArNjkyLDEzIEBACiAJaWYgKGNvbm4tPnN0YXRlICE9IEJUX0NPTkZJRyB8fCAhY29ubi0+b3V0KQogCQlyZXR1cm4gMDsKIAotCWlmIChjb25uLT5zZWNfbGV2ZWwgPT0gQlRfU0VDVVJJVFlfU0RQKQorCWlmIChjb25uLT5wZW5kaW5nX3NlY19sZXZlbCA9PSBCVF9TRUNVUklUWV9TRFApCiAJCXJldHVybiAwOwogCiAJLyogT25seSByZXF1ZXN0IGF1dGhlbnRpY2F0aW9uIGZvciBTU1AgY29ubmVjdGlvbnMgb3Igbm9uLVNTUAogCSAqIGRldmljZXMgd2l0aCBzZWNfbGV2ZWwgSElHSCAqLwogCWlmICghKGhkZXYtPnNzcF9tb2RlID4gMCAmJiBjb25uLT5zc3BfbW9kZSA+IDApICYmCi0JCQkJCWNvbm4tPnNlY19sZXZlbCAhPSBCVF9TRUNVUklUWV9ISUdIKQorCQkJCWNvbm4tPnBlbmRpbmdfc2VjX2xldmVsICE9IEJUX1NFQ1VSSVRZX0hJR0gpCiAJCXJldHVybiAwOwogCiAJcmV0dXJuIDE7CkBAIC0xMDk1LDkgKzEwOTUsMTAgQEAKIAogCWNvbm4gPSBoY2lfY29ubl9oYXNoX2xvb2t1cF9oYW5kbGUoaGRldiwgX19sZTE2X3RvX2NwdShldi0+aGFuZGxlKSk7CiAJaWYgKGNvbm4pIHsKLQkJaWYgKCFldi0+c3RhdHVzKQorCQlpZiAoIWV2LT5zdGF0dXMpIHsKIAkJCWNvbm4tPmxpbmtfbW9kZSB8PSBIQ0lfTE1fQVVUSDsKLQkJZWxzZQorCQkJY29ubi0+c2VjX2xldmVsID0gY29ubi0+cGVuZGluZ19zZWNfbGV2ZWw7CisJCX0gZWxzZQogCQkJY29ubi0+c2VjX2xldmVsID0gQlRfU0VDVVJJVFlfTE9XOwogCiAJCWNsZWFyX2JpdChIQ0lfQ09OTl9BVVRIX1BFTkQsICZjb25uLT5wZW5kKTsKZGlmZiAtLWdpdCBhL25ldC9ibHVldG9vdGgvbDJjYXAuYyBiL25ldC9ibHVldG9vdGgvbDJjYXAuYwppbmRleCBjNzkxZmNkLi43NTUwYWJiIDEwMDY0NAotLS0gYS9uZXQvYmx1ZXRvb3RoL2wyY2FwLmMKKysrIGIvbmV0L2JsdWV0b290aC9sMmNhcC5jCkBAIC0zMDUsMzMgKzMwNSw0NCBAQAogCX0KIH0KIAorc3RhdGljIGlubGluZSB1OCBsMmNhcF9nZXRfYXV0aF90eXBlKHN0cnVjdCBzb2NrICpzaykKK3sKKwlpZiAoc2stPnNrX3R5cGUgPT0gU09DS19SQVcpIHsKKwkJc3dpdGNoIChsMmNhcF9waShzayktPnNlY19sZXZlbCkgeworCQljYXNlIEJUX1NFQ1VSSVRZX0hJR0g6CisJCQlyZXR1cm4gSENJX0FUX0RFRElDQVRFRF9CT05ESU5HX01JVE07CisJCWNhc2UgQlRfU0VDVVJJVFlfTUVESVVNOgorCQkJcmV0dXJuIEhDSV9BVF9ERURJQ0FURURfQk9ORElORzsKKwkJZGVmYXVsdDoKKwkJCXJldHVybiBIQ0lfQVRfTk9fQk9ORElORzsKKwkJfQorCX0gZWxzZSBpZiAobDJjYXBfcGkoc2spLT5wc20gPT0gY3B1X3RvX2xlMTYoMHgwMDAxKSkgeworCQlpZiAobDJjYXBfcGkoc2spLT5zZWNfbGV2ZWwgPT0gQlRfU0VDVVJJVFlfTE9XKQorCQkJbDJjYXBfcGkoc2spLT5zZWNfbGV2ZWwgPSBCVF9TRUNVUklUWV9TRFA7CisKKwkJaWYgKGwyY2FwX3BpKHNrKS0+c2VjX2xldmVsID09IEJUX1NFQ1VSSVRZX0hJR0gpCisJCQlyZXR1cm4gSENJX0FUX05PX0JPTkRJTkdfTUlUTTsKKwkJZWxzZQorCQkJcmV0dXJuIEhDSV9BVF9OT19CT05ESU5HOworCX0gZWxzZSB7CisJCXN3aXRjaCAobDJjYXBfcGkoc2spLT5zZWNfbGV2ZWwpIHsKKwkJY2FzZSBCVF9TRUNVUklUWV9ISUdIOgorCQkJcmV0dXJuIEhDSV9BVF9HRU5FUkFMX0JPTkRJTkdfTUlUTTsKKwkJY2FzZSBCVF9TRUNVUklUWV9NRURJVU06CisJCQlyZXR1cm4gSENJX0FUX0dFTkVSQUxfQk9ORElORzsKKwkJZGVmYXVsdDoKKwkJCXJldHVybiBIQ0lfQVRfTk9fQk9ORElORzsKKwkJfQorCX0KK30KKwogLyogU2VydmljZSBsZXZlbCBzZWN1cml0eSAqLwogc3RhdGljIGlubGluZSBpbnQgbDJjYXBfY2hlY2tfc2VjdXJpdHkoc3RydWN0IHNvY2sgKnNrKQogewogCXN0cnVjdCBsMmNhcF9jb25uICpjb25uID0gbDJjYXBfcGkoc2spLT5jb25uOwogCV9fdTggYXV0aF90eXBlOwogCi0JaWYgKGwyY2FwX3BpKHNrKS0+cHNtID09IGNwdV90b19sZTE2KDB4MDAwMSkpIHsKLQkJaWYgKGwyY2FwX3BpKHNrKS0+c2VjX2xldmVsID09IEJUX1NFQ1VSSVRZX0hJR0gpCi0JCQlhdXRoX3R5cGUgPSBIQ0lfQVRfTk9fQk9ORElOR19NSVRNOwotCQllbHNlCi0JCQlhdXRoX3R5cGUgPSBIQ0lfQVRfTk9fQk9ORElORzsKLQotCQlpZiAobDJjYXBfcGkoc2spLT5zZWNfbGV2ZWwgPT0gQlRfU0VDVVJJVFlfTE9XKQotCQkJbDJjYXBfcGkoc2spLT5zZWNfbGV2ZWwgPSBCVF9TRUNVUklUWV9TRFA7Ci0JfSBlbHNlIHsKLQkJc3dpdGNoIChsMmNhcF9waShzayktPnNlY19sZXZlbCkgewotCQljYXNlIEJUX1NFQ1VSSVRZX0hJR0g6Ci0JCQlhdXRoX3R5cGUgPSBIQ0lfQVRfR0VORVJBTF9CT05ESU5HX01JVE07Ci0JCQlicmVhazsKLQkJY2FzZSBCVF9TRUNVUklUWV9NRURJVU06Ci0JCQlhdXRoX3R5cGUgPSBIQ0lfQVRfR0VORVJBTF9CT05ESU5HOwotCQkJYnJlYWs7Ci0JCWRlZmF1bHQ6Ci0JCQlhdXRoX3R5cGUgPSBIQ0lfQVRfTk9fQk9ORElORzsKLQkJCWJyZWFrOwotCQl9Ci0JfQorCWF1dGhfdHlwZSA9IGwyY2FwX2dldF9hdXRoX3R5cGUoc2spOwogCiAJcmV0dXJuIGhjaV9jb25uX3NlY3VyaXR5KGNvbm4tPmhjb24sIGwyY2FwX3BpKHNrKS0+c2VjX2xldmVsLAogCQkJCQkJCQlhdXRoX3R5cGUpOwpAQCAtMTA2OCwzOSArMTA3OSw3IEBACiAKIAllcnIgPSAtRU5PTUVNOwogCi0JaWYgKHNrLT5za190eXBlID09IFNPQ0tfUkFXKSB7Ci0JCXN3aXRjaCAobDJjYXBfcGkoc2spLT5zZWNfbGV2ZWwpIHsKLQkJY2FzZSBCVF9TRUNVUklUWV9ISUdIOgotCQkJYXV0aF90eXBlID0gSENJX0FUX0RFRElDQVRFRF9CT05ESU5HX01JVE07Ci0JCQlicmVhazsKLQkJY2FzZSBCVF9TRUNVUklUWV9NRURJVU06Ci0JCQlhdXRoX3R5cGUgPSBIQ0lfQVRfREVESUNBVEVEX0JPTkRJTkc7Ci0JCQlicmVhazsKLQkJZGVmYXVsdDoKLQkJCWF1dGhfdHlwZSA9IEhDSV9BVF9OT19CT05ESU5HOwotCQkJYnJlYWs7Ci0JCX0KLQl9IGVsc2UgaWYgKGwyY2FwX3BpKHNrKS0+cHNtID09IGNwdV90b19sZTE2KDB4MDAwMSkpIHsKLQkJaWYgKGwyY2FwX3BpKHNrKS0+c2VjX2xldmVsID09IEJUX1NFQ1VSSVRZX0hJR0gpCi0JCQlhdXRoX3R5cGUgPSBIQ0lfQVRfTk9fQk9ORElOR19NSVRNOwotCQllbHNlCi0JCQlhdXRoX3R5cGUgPSBIQ0lfQVRfTk9fQk9ORElORzsKLQotCQlpZiAobDJjYXBfcGkoc2spLT5zZWNfbGV2ZWwgPT0gQlRfU0VDVVJJVFlfTE9XKQotCQkJbDJjYXBfcGkoc2spLT5zZWNfbGV2ZWwgPSBCVF9TRUNVUklUWV9TRFA7Ci0JfSBlbHNlIHsKLQkJc3dpdGNoIChsMmNhcF9waShzayktPnNlY19sZXZlbCkgewotCQljYXNlIEJUX1NFQ1VSSVRZX0hJR0g6Ci0JCQlhdXRoX3R5cGUgPSBIQ0lfQVRfR0VORVJBTF9CT05ESU5HX01JVE07Ci0JCQlicmVhazsKLQkJY2FzZSBCVF9TRUNVUklUWV9NRURJVU06Ci0JCQlhdXRoX3R5cGUgPSBIQ0lfQVRfR0VORVJBTF9CT05ESU5HOwotCQkJYnJlYWs7Ci0JCWRlZmF1bHQ6Ci0JCQlhdXRoX3R5cGUgPSBIQ0lfQVRfTk9fQk9ORElORzsKLQkJCWJyZWFrOwotCQl9Ci0JfQorCWF1dGhfdHlwZSA9IGwyY2FwX2dldF9hdXRoX3R5cGUoc2spOwogCiAJaGNvbiA9IGhjaV9jb25uZWN0KGhkZXYsIEFDTF9MSU5LLCBkc3QsCiAJCQkJCWwyY2FwX3BpKHNrKS0+c2VjX2xldmVsLCBhdXRoX3R5cGUpOwpAQCAtMTEyNyw3ICsxMTA2LDggQEAKIAkJaWYgKHNrLT5za190eXBlICE9IFNPQ0tfU0VRUEFDS0VUICYmCiAJCQkJc2stPnNrX3R5cGUgIT0gU09DS19TVFJFQU0pIHsKIAkJCWwyY2FwX3NvY2tfY2xlYXJfdGltZXIoc2spOwotCQkJc2stPnNrX3N0YXRlID0gQlRfQ09OTkVDVEVEOworCQkJaWYgKGwyY2FwX2NoZWNrX3NlY3VyaXR5KHNrKSkKKwkJCQlzay0+c2tfc3RhdGUgPSBCVF9DT05ORUNURUQ7CiAJCX0gZWxzZQogCQkJbDJjYXBfZG9fc3RhcnQoc2spOwogCX0KQEAgLTE4OTMsOCArMTg3Myw4IEBACiAJCWlmIChwaS0+bW9kZSA9PSBMMkNBUF9NT0RFX1NUUkVBTUlORykgewogCQkJbDJjYXBfc3RyZWFtaW5nX3NlbmQoc2spOwogCQl9IGVsc2UgewotCQkJaWYgKHBpLT5jb25uX3N0YXRlICYgTDJDQVBfQ09OTl9SRU1PVEVfQlVTWSAmJgotCQkJCQlwaS0+Y29ubl9zdGF0ZSAmJiBMMkNBUF9DT05OX1dBSVRfRikgeworCQkJaWYgKChwaS0+Y29ubl9zdGF0ZSAmIEwyQ0FQX0NPTk5fUkVNT1RFX0JVU1kpICYmCisJCQkJCShwaS0+Y29ubl9zdGF0ZSAmIEwyQ0FQX0NPTk5fV0FJVF9GKSkgewogCQkJCWVyciA9IGxlbjsKIAkJCQlicmVhazsKIAkJCX0KZGlmZiAtLWdpdCBhL25ldC9ibHVldG9vdGgvcmZjb21tL2NvcmUuYyBiL25ldC9ibHVldG9vdGgvcmZjb21tL2NvcmUuYwppbmRleCBmZjhhYWE3Li42YjgzNzc2IDEwMDY0NAotLS0gYS9uZXQvYmx1ZXRvb3RoL3JmY29tbS9jb3JlLmMKKysrIGIvbmV0L2JsdWV0b290aC9yZmNvbW0vY29yZS5jCkBAIC0xMTY0LDcgKzExNjQsOCBAQAogCQkJICogaW5pdGlhdG9yIHJmY29tbV9wcm9jZXNzX3J4IGFscmVhZHkgY2FsbHMKIAkJCSAqIHJmY29tbV9zZXNzaW9uX3B1dCgpICovCiAJCQlpZiAocy0+c29jay0+c2stPnNrX3N0YXRlICE9IEJUX0NMT1NFRCkKLQkJCQlyZmNvbW1fc2Vzc2lvbl9wdXQocyk7CisJCQkJaWYgKGxpc3RfZW1wdHkoJnMtPmRsY3MpKQorCQkJCQlyZmNvbW1fc2Vzc2lvbl9wdXQocyk7CiAJCQlicmVhazsKIAkJfQogCX0KZGlmZiAtLWdpdCBhL25ldC9icmlkZ2UvYnJfZmRiLmMgYi9uZXQvYnJpZGdlL2JyX2ZkYi5jCmluZGV4IDI4NzIzOTMuLjg4NDg1Y2MgMTAwNjQ0Ci0tLSBhL25ldC9icmlkZ2UvYnJfZmRiLmMKKysrIGIvbmV0L2JyaWRnZS9icl9mZGIuYwpAQCAtMzI4LDEyICszMjgsMTIgQEAKIAlmZGIgPSBrbWVtX2NhY2hlX2FsbG9jKGJyX2ZkYl9jYWNoZSwgR0ZQX0FUT01JQyk7CiAJaWYgKGZkYikgewogCQltZW1jcHkoZmRiLT5hZGRyLmFkZHIsIGFkZHIsIEVUSF9BTEVOKTsKLQkJaGxpc3RfYWRkX2hlYWRfcmN1KCZmZGItPmhsaXN0LCBoZWFkKTsKLQogCQlmZGItPmRzdCA9IHNvdXJjZTsKIAkJZmRiLT5pc19sb2NhbCA9IGlzX2xvY2FsOwogCQlmZGItPmlzX3N0YXRpYyA9IGlzX2xvY2FsOwogCQlmZGItPmFnZWluZ190aW1lciA9IGppZmZpZXM7CisKKwkJaGxpc3RfYWRkX2hlYWRfcmN1KCZmZGItPmhsaXN0LCBoZWFkKTsKIAl9CiAJcmV0dXJuIGZkYjsKIH0KZGlmZiAtLWdpdCBhL25ldC9jYWlmL2NmY25mZy5jIGIvbmV0L2NhaWYvY2ZjbmZnLmMKaW5kZXggMjFlZGUxNC4uYzY2NWRlNyAxMDA2NDQKLS0tIGEvbmV0L2NhaWYvY2ZjbmZnLmMKKysrIGIvbmV0L2NhaWYvY2ZjbmZnLmMKQEAgLTE5MSw2ICsxOTEsNyBAQAogCXN0cnVjdCBjZmxheWVyICpzZXJ2bCA9IE5VTEw7CiAJc3RydWN0IGNmY25mZ19waHlpbmZvICpwaHlpbmZvID0gTlVMTDsKIAl1OCBwaHlpZCA9IDA7CisKIAljYWlmX2Fzc2VydChhZGFwX2xheWVyICE9IE5VTEwpOwogCWNoYW5uZWxfaWQgPSBhZGFwX2xheWVyLT5pZDsKIAlpZiAoYWRhcF9sYXllci0+ZG4gPT0gTlVMTCB8fCBjaGFubmVsX2lkID09IDApIHsKQEAgLTE5OSwxNiArMjAwLDE2IEBACiAJCWdvdG8gZW5kOwogCX0KIAlzZXJ2bCA9IGNmbXV4bF9yZW1vdmVfdXBsYXllcihjbmZnLT5tdXgsIGNoYW5uZWxfaWQpOwotCWlmIChzZXJ2bCA9PSBOVUxMKQotCQlnb3RvIGVuZDsKLQlsYXllcl9zZXRfdXAoc2VydmwsIE5VTEwpOwotCXJldCA9IGNmY3RybF9saW5rZG93bl9yZXEoY25mZy0+Y3RybCwgY2hhbm5lbF9pZCwgYWRhcF9sYXllcik7CiAJaWYgKHNlcnZsID09IE5VTEwpIHsKIAkJcHJfZXJyKCJQUk9UT0NPTCBFUlJPUiAtIEVycm9yIHJlbW92aW5nIHNlcnZpY2VfbGF5ZXIgQ2hhbm5lbF9JZCglZCkiLAogCQkgICAgICAgY2hhbm5lbF9pZCk7CiAJCXJldCA9IC1FSU5WQUw7CiAJCWdvdG8gZW5kOwogCX0KKwlsYXllcl9zZXRfdXAoc2VydmwsIE5VTEwpOworCXJldCA9IGNmY3RybF9saW5rZG93bl9yZXEoY25mZy0+Y3RybCwgY2hhbm5lbF9pZCwgYWRhcF9sYXllcik7CisJaWYgKHJldCkKKwkJZ290byBlbmQ7CiAJY2FpZl9hc3NlcnQoY2hhbm5lbF9pZCA9PSBzZXJ2bC0+aWQpOwogCWlmIChhZGFwX2xheWVyLT5kbiAhPSBOVUxMKSB7CiAJCXBoeWlkID0gY2ZzcnZsX2dldHBoeWlkKGFkYXBfbGF5ZXItPmRuKTsKZGlmZiAtLWdpdCBhL25ldC9jYWlmL2NobmxfbmV0LmMgYi9uZXQvY2FpZi9jaG5sX25ldC5jCmluZGV4IGZhOWRhYjMuLjYwMDhkNmQgMTAwNjQ0Ci0tLSBhL25ldC9jYWlmL2NobmxfbmV0LmMKKysrIGIvbmV0L2NhaWYvY2hubF9uZXQuYwpAQCAtMzk0LDkgKzM5NCw3IEBACiAJcHJpdi0+Y29ubl9yZXEuc29ja2FkZHIudS5kZ20uY29ubmVjdGlvbl9pZCA9IC0xOwogCXByaXYtPmZsb3dlbmFibGVkID0gZmFsc2U7CiAKLQlBU1NFUlRfUlROTCgpOwogCWluaXRfd2FpdHF1ZXVlX2hlYWQoJnByaXYtPm5ldG1nbXRfd3EpOwotCWxpc3RfYWRkKCZwcml2LT5saXN0X2ZpZWxkLCAmY2hubF9uZXRfbGlzdCk7CiB9CiAKIApAQCAtNDUzLDYgKzQ1MSw4IEBACiAJcmV0ID0gcmVnaXN0ZXJfbmV0ZGV2aWNlKGRldik7CiAJaWYgKHJldCkKIAkJcHJfd2FybigiZGV2aWNlIHJ0bWwgcmVnaXN0cmF0aW9uIGZhaWxlZFxuIik7CisJZWxzZQorCQlsaXN0X2FkZCgmY2FpZmRldi0+bGlzdF9maWVsZCwgJmNobmxfbmV0X2xpc3QpOwogCXJldHVybiByZXQ7CiB9CiAKZGlmZiAtLWdpdCBhL25ldC9jYW4vYmNtLmMgYi9uZXQvY2FuL2JjbS5jCmluZGV4IDlkNWU4YWMuLjA5MmRjODggMTAwNjQ0Ci0tLSBhL25ldC9jYW4vYmNtLmMKKysrIGIvbmV0L2Nhbi9iY20uYwpAQCAtMTI1Niw2ICsxMjU2LDkgQEAKIAkJc3RydWN0IHNvY2thZGRyX2NhbiAqYWRkciA9CiAJCQkoc3RydWN0IHNvY2thZGRyX2NhbiAqKW1zZy0+bXNnX25hbWU7CiAKKwkJaWYgKG1zZy0+bXNnX25hbWVsZW4gPCBzaXplb2YoKmFkZHIpKQorCQkJcmV0dXJuIC1FSU5WQUw7CisKIAkJaWYgKGFkZHItPmNhbl9mYW1pbHkgIT0gQUZfQ0FOKQogCQkJcmV0dXJuIC1FSU5WQUw7CiAKZGlmZiAtLWdpdCBhL25ldC9jYW4vcmF3LmMgYi9uZXQvY2FuL3Jhdy5jCmluZGV4IGU4OGY2MTAuLjg4M2U5ZDcgMTAwNjQ0Ci0tLSBhL25ldC9jYW4vcmF3LmMKKysrIGIvbmV0L2Nhbi9yYXcuYwpAQCAtNjQ5LDYgKzY0OSw5IEBACiAJCXN0cnVjdCBzb2NrYWRkcl9jYW4gKmFkZHIgPQogCQkJKHN0cnVjdCBzb2NrYWRkcl9jYW4gKiltc2ctPm1zZ19uYW1lOwogCisJCWlmIChtc2ctPm1zZ19uYW1lbGVuIDwgc2l6ZW9mKCphZGRyKSkKKwkJCXJldHVybiAtRUlOVkFMOworCiAJCWlmIChhZGRyLT5jYW5fZmFtaWx5ICE9IEFGX0NBTikKIAkJCXJldHVybiAtRUlOVkFMOwogCmRpZmYgLS1naXQgYS9uZXQvY29yZS9kZXYuYyBiL25ldC9jb3JlL2Rldi5jCmluZGV4IDA2ZDBlN2IuLjhlNzI2Y2IgMTAwNjQ0Ci0tLSBhL25ldC9jb3JlL2Rldi5jCisrKyBiL25ldC9jb3JlL2Rldi5jCkBAIC03NDksNyArNzQ5LDggQEAKICAqCUBoYTogaGFyZHdhcmUgYWRkcmVzcwogICoKICAqCVNlYXJjaCBmb3IgYW4gaW50ZXJmYWNlIGJ5IE1BQyBhZGRyZXNzLiBSZXR1cm5zIE5VTEwgaWYgdGhlIGRldmljZQotICoJaXMgbm90IGZvdW5kIG9yIGEgcG9pbnRlciB0byB0aGUgZGV2aWNlLiBUaGUgY2FsbGVyIG11c3QgaG9sZCBSQ1UKKyAqCWlzIG5vdCBmb3VuZCBvciBhIHBvaW50ZXIgdG8gdGhlIGRldmljZS4KKyAqCVRoZSBjYWxsZXIgbXVzdCBob2xkIFJDVSBvciBSVE5MLgogICoJVGhlIHJldHVybmVkIGRldmljZSBoYXMgbm90IGhhZCBpdHMgcmVmIGNvdW50IGluY3JlYXNlZAogICoJYW5kIHRoZSBjYWxsZXIgbXVzdCB0aGVyZWZvcmUgYmUgY2FyZWZ1bCBhYm91dCBsb2NraW5nCiAgKgpAQCAtMjAwMSw3ICsyMDAyLDcgQEAKIAogc3RhdGljIGludCBoYXJtb25pemVfZmVhdHVyZXMoc3RydWN0IHNrX2J1ZmYgKnNrYiwgX19iZTE2IHByb3RvY29sLCBpbnQgZmVhdHVyZXMpCiB7Ci0JaWYgKCFjYW5fY2hlY2tzdW1fcHJvdG9jb2wocHJvdG9jb2wsIGZlYXR1cmVzKSkgeworCWlmICghY2FuX2NoZWNrc3VtX3Byb3RvY29sKGZlYXR1cmVzLCBwcm90b2NvbCkpIHsKIAkJZmVhdHVyZXMgJj0gfk5FVElGX0ZfQUxMX0NTVU07CiAJCWZlYXR1cmVzICY9IH5ORVRJRl9GX1NHOwogCX0gZWxzZSBpZiAoaWxsZWdhbF9oaWdoZG1hKHNrYi0+ZGV2LCBza2IpKSB7CkBAIC0yMDIzLDEzICsyMDI0LDEzIEBACiAJCXJldHVybiBoYXJtb25pemVfZmVhdHVyZXMoc2tiLCBwcm90b2NvbCwgZmVhdHVyZXMpOwogCX0KIAotCWZlYXR1cmVzICY9IHNrYi0+ZGV2LT52bGFuX2ZlYXR1cmVzOworCWZlYXR1cmVzICY9IChza2ItPmRldi0+dmxhbl9mZWF0dXJlcyB8IE5FVElGX0ZfSFdfVkxBTl9UWCk7CiAKIAlpZiAocHJvdG9jb2wgIT0gaHRvbnMoRVRIX1BfODAyMVEpKSB7CiAJCXJldHVybiBoYXJtb25pemVfZmVhdHVyZXMoc2tiLCBwcm90b2NvbCwgZmVhdHVyZXMpOwogCX0gZWxzZSB7CiAJCWZlYXR1cmVzICY9IE5FVElGX0ZfU0cgfCBORVRJRl9GX0hJR0hETUEgfCBORVRJRl9GX0ZSQUdMSVNUIHwKLQkJCQlORVRJRl9GX0dFTl9DU1VNOworCQkJCU5FVElGX0ZfR0VOX0NTVU0gfCBORVRJRl9GX0hXX1ZMQU5fVFg7CiAJCXJldHVybiBoYXJtb25pemVfZmVhdHVyZXMoc2tiLCBwcm90b2NvbCwgZmVhdHVyZXMpOwogCX0KIH0KQEAgLTI1NjIsNyArMjU2Myw4IEBACiAKIAltYXAgPSByY3VfZGVyZWZlcmVuY2UocnhxdWV1ZS0+cnBzX21hcCk7CiAJaWYgKG1hcCkgewotCQlpZiAobWFwLT5sZW4gPT0gMSkgeworCQlpZiAobWFwLT5sZW4gPT0gMSAmJgorCQkgICAgIXJjdV9kZXJlZmVyZW5jZV9yYXcocnhxdWV1ZS0+cnBzX2Zsb3dfdGFibGUpKSB7CiAJCQl0Y3B1ID0gbWFwLT5jcHVzWzBdOwogCQkJaWYgKGNwdV9vbmxpbmUodGNwdSkpCiAJCQkJY3B1ID0gdGNwdTsKQEAgLTM0MjMsNiArMzQyNSw4IEBACiAJX19za2JfcHVsbChza2IsIHNrYl9oZWFkbGVuKHNrYikpOwogCXNrYl9yZXNlcnZlKHNrYiwgTkVUX0lQX0FMSUdOIC0gc2tiX2hlYWRyb29tKHNrYikpOwogCXNrYi0+dmxhbl90Y2kgPSAwOworCXNrYi0+ZGV2ID0gbmFwaS0+ZGV2OworCXNrYi0+c2tiX2lpZiA9IDA7CiAKIAluYXBpLT5za2IgPSBza2I7CiB9CkBAIC01NTIzLDM0ICs1NTI3LDYgQEAKIAl9CiB9CiAKLS8qKgotICoJZGV2X3R4cV9zdGF0c19mb2xkIC0gZm9sZCB0eF9xdWV1ZXMgc3RhdHMKLSAqCUBkZXY6IGRldmljZSB0byBnZXQgc3RhdGlzdGljcyBmcm9tCi0gKglAc3RhdHM6IHN0cnVjdCBydG5sX2xpbmtfc3RhdHM2NCB0byBob2xkIHJlc3VsdHMKLSAqLwotdm9pZCBkZXZfdHhxX3N0YXRzX2ZvbGQoY29uc3Qgc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKLQkJCXN0cnVjdCBydG5sX2xpbmtfc3RhdHM2NCAqc3RhdHMpCi17Ci0JdTY0IHR4X2J5dGVzID0gMCwgdHhfcGFja2V0cyA9IDAsIHR4X2Ryb3BwZWQgPSAwOwotCXVuc2lnbmVkIGludCBpOwotCXN0cnVjdCBuZXRkZXZfcXVldWUgKnR4cTsKLQotCWZvciAoaSA9IDA7IGkgPCBkZXYtPm51bV90eF9xdWV1ZXM7IGkrKykgewotCQl0eHEgPSBuZXRkZXZfZ2V0X3R4X3F1ZXVlKGRldiwgaSk7Ci0JCXNwaW5fbG9ja19iaCgmdHhxLT5feG1pdF9sb2NrKTsKLQkJdHhfYnl0ZXMgICArPSB0eHEtPnR4X2J5dGVzOwotCQl0eF9wYWNrZXRzICs9IHR4cS0+dHhfcGFja2V0czsKLQkJdHhfZHJvcHBlZCArPSB0eHEtPnR4X2Ryb3BwZWQ7Ci0JCXNwaW5fdW5sb2NrX2JoKCZ0eHEtPl94bWl0X2xvY2spOwotCX0KLQlpZiAodHhfYnl0ZXMgfHwgdHhfcGFja2V0cyB8fCB0eF9kcm9wcGVkKSB7Ci0JCXN0YXRzLT50eF9ieXRlcyAgID0gdHhfYnl0ZXM7Ci0JCXN0YXRzLT50eF9wYWNrZXRzID0gdHhfcGFja2V0czsKLQkJc3RhdHMtPnR4X2Ryb3BwZWQgPSB0eF9kcm9wcGVkOwotCX0KLX0KLUVYUE9SVF9TWU1CT0woZGV2X3R4cV9zdGF0c19mb2xkKTsKLQogLyogQ29udmVydCBuZXRfZGV2aWNlX3N0YXRzIHRvIHJ0bmxfbGlua19zdGF0czY0LiAgVGhleSBoYXZlIHRoZSBzYW1lCiAgKiBmaWVsZHMgaW4gdGhlIHNhbWUgb3JkZXIsIHdpdGggb25seSB0aGUgdHlwZSBkaWZmZXJpbmcuCiAgKi8KQEAgLTU1OTQsNyArNTU3MCw2IEBACiAJCW5ldGRldl9zdGF0c190b19zdGF0czY0KHN0b3JhZ2UsIG9wcy0+bmRvX2dldF9zdGF0cyhkZXYpKTsKIAl9IGVsc2UgewogCQluZXRkZXZfc3RhdHNfdG9fc3RhdHM2NChzdG9yYWdlLCAmZGV2LT5zdGF0cyk7Ci0JCWRldl90eHFfc3RhdHNfZm9sZChkZXYsIHN0b3JhZ2UpOwogCX0KIAlzdG9yYWdlLT5yeF9kcm9wcGVkICs9IGF0b21pY19sb25nX3JlYWQoJmRldi0+cnhfZHJvcHBlZCk7CiAJcmV0dXJuIHN0b3JhZ2U7CkBAIC01Njg1LDE4ICs1NjYwLDYgQEAKIAogCWRldl9uZXRfc2V0KGRldiwgJmluaXRfbmV0KTsKIAotCWRldi0+bnVtX3R4X3F1ZXVlcyA9IHR4cXM7Ci0JZGV2LT5yZWFsX251bV90eF9xdWV1ZXMgPSB0eHFzOwotCWlmIChuZXRpZl9hbGxvY19uZXRkZXZfcXVldWVzKGRldikpCi0JCWdvdG8gZnJlZV9wY3B1OwotCi0jaWZkZWYgQ09ORklHX1JQUwotCWRldi0+bnVtX3J4X3F1ZXVlcyA9IHJ4cXM7Ci0JZGV2LT5yZWFsX251bV9yeF9xdWV1ZXMgPSByeHFzOwotCWlmIChuZXRpZl9hbGxvY19yeF9xdWV1ZXMoZGV2KSkKLQkJZ290byBmcmVlX3BjcHU7Ci0jZW5kaWYKLQogCWRldi0+Z3NvX21heF9zaXplID0gR1NPX01BWF9TSVpFOwogCiAJSU5JVF9MSVNUX0hFQUQoJmRldi0+ZXRodG9vbF9udHVwbGVfbGlzdC5saXN0KTsKQEAgLTU3MDYsOSArNTY2OSwyNiBAQAogCUlOSVRfTElTVF9IRUFEKCZkZXYtPmxpbmtfd2F0Y2hfbGlzdCk7CiAJZGV2LT5wcml2X2ZsYWdzID0gSUZGX1hNSVRfRFNUX1JFTEVBU0U7CiAJc2V0dXAoZGV2KTsKKworCWRldi0+bnVtX3R4X3F1ZXVlcyA9IHR4cXM7CisJZGV2LT5yZWFsX251bV90eF9xdWV1ZXMgPSB0eHFzOworCWlmIChuZXRpZl9hbGxvY19uZXRkZXZfcXVldWVzKGRldikpCisJCWdvdG8gZnJlZV9hbGw7CisKKyNpZmRlZiBDT05GSUdfUlBTCisJZGV2LT5udW1fcnhfcXVldWVzID0gcnhxczsKKwlkZXYtPnJlYWxfbnVtX3J4X3F1ZXVlcyA9IHJ4cXM7CisJaWYgKG5ldGlmX2FsbG9jX3J4X3F1ZXVlcyhkZXYpKQorCQlnb3RvIGZyZWVfYWxsOworI2VuZGlmCisKIAlzdHJjcHkoZGV2LT5uYW1lLCBuYW1lKTsKIAlyZXR1cm4gZGV2OwogCitmcmVlX2FsbDoKKwlmcmVlX25ldGRldihkZXYpOworCXJldHVybiBOVUxMOworCiBmcmVlX3BjcHU6CiAJZnJlZV9wZXJjcHUoZGV2LT5wY3B1X3JlZmNudCk7CiAJa2ZyZWUoZGV2LT5fdHgpOwpkaWZmIC0tZ2l0IGEvbmV0L2NvcmUvZXRodG9vbC5jIGIvbmV0L2NvcmUvZXRodG9vbC5jCmluZGV4IDE3NzQxNzguLmZmMjMwMjkgMTAwNjQ0Ci0tLSBhL25ldC9jb3JlL2V0aHRvb2wuYworKysgYi9uZXQvY29yZS9ldGh0b29sLmMKQEAgLTgxNyw3ICs4MTcsNyBAQAogCWlmIChyZWdzLmxlbiA+IHJlZ2xlbikKIAkJcmVncy5sZW4gPSByZWdsZW47CiAKLQlyZWdidWYgPSB2bWFsbG9jKHJlZ2xlbik7CisJcmVnYnVmID0gdnphbGxvYyhyZWdsZW4pOwogCWlmICghcmVnYnVmKQogCQlyZXR1cm4gLUVOT01FTTsKIApkaWZmIC0tZ2l0IGEvbmV0L2NvcmUvcnRuZXRsaW5rLmMgYi9uZXQvY29yZS9ydG5ldGxpbmsuYwppbmRleCBhNWY3NTM1Li4yZDY1YzZiIDEwMDY0NAotLS0gYS9uZXQvY29yZS9ydG5ldGxpbmsuYworKysgYi9uZXQvY29yZS9ydG5ldGxpbmsuYwpAQCAtMTEyMSw4ICsxMTIxLDcgQEAKIAkJCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAKIAkJCWlmIChhZl9vcHMtPnZhbGlkYXRlX2xpbmtfYWYpIHsKLQkJCQllcnIgPSBhZl9vcHMtPnZhbGlkYXRlX2xpbmtfYWYoZGV2LAotCQkJCQkJCXRiW0lGTEFfQUZfU1BFQ10pOworCQkJCWVyciA9IGFmX29wcy0+dmFsaWRhdGVfbGlua19hZihkZXYsIGFmKTsKIAkJCQlpZiAoZXJyIDwgMCkKIAkJCQkJcmV0dXJuIGVycjsKIAkJCX0KQEAgLTE2NzIsNiArMTY3MSw5IEBACiAJCQlzbnByaW50ZihpZm5hbWUsIElGTkFNU0laLCAiJXMlJWQiLCBvcHMtPmtpbmQpOwogCiAJCWRlc3RfbmV0ID0gcnRubF9saW5rX2dldF9uZXQobmV0LCB0Yik7CisJCWlmIChJU19FUlIoZGVzdF9uZXQpKQorCQkJcmV0dXJuIFBUUl9FUlIoZGVzdF9uZXQpOworCiAJCWRldiA9IHJ0bmxfY3JlYXRlX2xpbmsobmV0LCBkZXN0X25ldCwgaWZuYW1lLCBvcHMsIHRiKTsKIAogCQlpZiAoSVNfRVJSKGRldikpCkBAIC0xODIwLDcgKzE4MjIsNyBAQAogCWlmIChraW5kICE9IDIgJiYgc2VjdXJpdHlfbmV0bGlua19yZWN2KHNrYiwgQ0FQX05FVF9BRE1JTikpCiAJCXJldHVybiAtRVBFUk07CiAKLQlpZiAoa2luZCA9PSAyICYmIChubGgtPm5sbXNnX2ZsYWdzICYgTkxNX0ZfRFVNUCkgPT0gTkxNX0ZfRFVNUCkgeworCWlmIChraW5kID09IDIgJiYgbmxoLT5ubG1zZ19mbGFncyZOTE1fRl9EVU1QKSB7CiAJCXN0cnVjdCBzb2NrICpydG5sOwogCQlydG5sX2R1bXBpdF9mdW5jIGR1bXBpdDsKIApkaWZmIC0tZ2l0IGEvbmV0L2NvcmUvc2tidWZmLmMgYi9uZXQvY29yZS9za2J1ZmYuYwppbmRleCAxOWQ2YzIxLi5kODgzZGNjIDEwMDY0NAotLS0gYS9uZXQvY29yZS9za2J1ZmYuYworKysgYi9uZXQvY29yZS9za2J1ZmYuYwpAQCAtMjEwLDYgKzIxMCw3IEBACiAJc2hpbmZvID0gc2tiX3NoaW5mbyhza2IpOwogCW1lbXNldChzaGluZm8sIDAsIG9mZnNldG9mKHN0cnVjdCBza2Jfc2hhcmVkX2luZm8sIGRhdGFyZWYpKTsKIAlhdG9taWNfc2V0KCZzaGluZm8tPmRhdGFyZWYsIDEpOworCWttZW1jaGVja19hbm5vdGF0ZV92YXJpYWJsZShzaGluZm8tPmRlc3RydWN0b3JfYXJnKTsKIAogCWlmIChmY2xvbmUpIHsKIAkJc3RydWN0IHNrX2J1ZmYgKmNoaWxkID0gc2tiICsgMTsKQEAgLTM4MCw2ICszODEsOCBAQAogCX0KICNpZiBkZWZpbmVkKENPTkZJR19ORl9DT05OVFJBQ0spIHx8IGRlZmluZWQoQ09ORklHX05GX0NPTk5UUkFDS19NT0RVTEUpCiAJbmZfY29ubnRyYWNrX3B1dChza2ItPm5mY3QpOworI2VuZGlmCisjaWZkZWYgTkVUX1NLQlVGRl9ORl9ERUZSQUdfTkVFREVECiAJbmZfY29ubnRyYWNrX3B1dF9yZWFzbShza2ItPm5mY3RfcmVhc20pOwogI2VuZGlmCiAjaWZkZWYgQ09ORklHX0JSSURHRV9ORVRGSUxURVIKQEAgLTI3NDIsOCArMjc0NSwxMiBAQAogCiBtZXJnZToKIAlpZiAob2Zmc2V0ID4gaGVhZGxlbikgewotCQlza2JpbmZvLT5mcmFnc1swXS5wYWdlX29mZnNldCArPSBvZmZzZXQgLSBoZWFkbGVuOwotCQlza2JpbmZvLT5mcmFnc1swXS5zaXplIC09IG9mZnNldCAtIGhlYWRsZW47CisJCXVuc2lnbmVkIGludCBlYXQgPSBvZmZzZXQgLSBoZWFkbGVuOworCisJCXNrYmluZm8tPmZyYWdzWzBdLnBhZ2Vfb2Zmc2V0ICs9IGVhdDsKKwkJc2tiaW5mby0+ZnJhZ3NbMF0uc2l6ZSAtPSBlYXQ7CisJCXNrYi0+ZGF0YV9sZW4gLT0gZWF0OworCQlza2ItPmxlbiAtPSBlYXQ7CiAJCW9mZnNldCA9IGhlYWRsZW47CiAJfQogCmRpZmYgLS1naXQgYS9uZXQvZGNiL2RjYm5sLmMgYi9uZXQvZGNiL2RjYm5sLmMKaW5kZXggZDkwMGFiOS4uNmIwM2Y1NiAxMDA2NDQKLS0tIGEvbmV0L2RjYi9kY2JubC5jCisrKyBiL25ldC9kY2IvZGNibmwuYwpAQCAtNTgzLDcgKzU4Myw3IEBACiAJdTggdXAsIGlkdHlwZTsKIAlpbnQgcmV0ID0gLUVJTlZBTDsKIAotCWlmICghdGJbRENCX0FUVFJfQVBQXSB8fCAhbmV0ZGV2LT5kY2JubF9vcHMtPmdldGFwcCkKKwlpZiAoIXRiW0RDQl9BVFRSX0FQUF0pCiAJCWdvdG8gb3V0OwogCiAJcmV0ID0gbmxhX3BhcnNlX25lc3RlZChhcHBfdGIsIERDQl9BUFBfQVRUUl9NQVgsIHRiW0RDQl9BVFRSX0FQUF0sCkBAIC02MDQsNyArNjA0LDE2IEBACiAJCWdvdG8gb3V0OwogCiAJaWQgPSBubGFfZ2V0X3UxNihhcHBfdGJbRENCX0FQUF9BVFRSX0lEXSk7Ci0JdXAgPSBuZXRkZXYtPmRjYm5sX29wcy0+Z2V0YXBwKG5ldGRldiwgaWR0eXBlLCBpZCk7CisKKwlpZiAobmV0ZGV2LT5kY2JubF9vcHMtPmdldGFwcCkgeworCQl1cCA9IG5ldGRldi0+ZGNibmxfb3BzLT5nZXRhcHAobmV0ZGV2LCBpZHR5cGUsIGlkKTsKKwl9IGVsc2UgeworCQlzdHJ1Y3QgZGNiX2FwcCBhcHAgPSB7CisJCQkJCS5zZWxlY3RvciA9IGlkdHlwZSwKKwkJCQkJLnByb3RvY29sID0gaWQsCisJCQkJICAgICB9OworCQl1cCA9IGRjYl9nZXRhcHAobmV0ZGV2LCAmYXBwKTsKKwl9CiAKIAkvKiBzZW5kIHRoaXMgYmFjayAqLwogCWRjYm5sX3NrYiA9IG5sbXNnX25ldyhOTE1TR19ERUZBVUxUX1NJWkUsIEdGUF9LRVJORUwpOwpkaWZmIC0tZ2l0IGEvbmV0L2RzYS9kc2EuYyBiL25ldC9kc2EvZHNhLmMKaW5kZXggMGM4NzdhNy4uM2ZiMTRiNyAxMDA2NDQKLS0tIGEvbmV0L2RzYS9kc2EuYworKysgYi9uZXQvZHNhL2RzYS5jCkBAIC00MjgsNyArNDI4LDcgQEAKIH0KIG1vZHVsZV9leGl0KGRzYV9jbGVhbnVwX21vZHVsZSk7CiAKLU1PRFVMRV9BVVRIT1IoIkxlbm5lcnQgQnV5dGVuaGVrIDxidXl0ZW5oQHdhbnRzdG9mbHkub3JnPiIpCitNT0RVTEVfQVVUSE9SKCJMZW5uZXJ0IEJ1eXRlbmhlayA8YnV5dGVuaEB3YW50c3RvZmx5Lm9yZz4iKTsKIE1PRFVMRV9ERVNDUklQVElPTigiRHJpdmVyIGZvciBEaXN0cmlidXRlZCBTd2l0Y2ggQXJjaGl0ZWN0dXJlIHN3aXRjaCBjaGlwcyIpOwogTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwogTU9EVUxFX0FMSUFTKCJwbGF0Zm9ybTpkc2EiKTsKZGlmZiAtLWdpdCBhL25ldC9lY29uZXQvYWZfZWNvbmV0LmMgYi9uZXQvZWNvbmV0L2FmX2Vjb25ldC5jCmluZGV4IDE1ZGNjMWEuLjBjMjgyNjMgMTAwNjQ0Ci0tLSBhL25ldC9lY29uZXQvYWZfZWNvbmV0LmMKKysrIGIvbmV0L2Vjb25ldC9hZl9lY29uZXQuYwpAQCAtMjY1LDEzICsyNjUsMTMgQEAKIHN0YXRpYyBpbnQgZWNvbmV0X3NlbmRtc2coc3RydWN0IGtpb2NiICppb2NiLCBzdHJ1Y3Qgc29ja2V0ICpzb2NrLAogCQkJICBzdHJ1Y3QgbXNnaGRyICptc2csIHNpemVfdCBsZW4pCiB7Ci0Jc3RydWN0IHNvY2sgKnNrID0gc29jay0+c2s7CiAJc3RydWN0IHNvY2thZGRyX2VjICpzYWRkcj0oc3RydWN0IHNvY2thZGRyX2VjICopbXNnLT5tc2dfbmFtZTsKIAlzdHJ1Y3QgbmV0X2RldmljZSAqZGV2OwogCXN0cnVjdCBlY19hZGRyIGFkZHI7CiAJaW50IGVycjsKIAl1bnNpZ25lZCBjaGFyIHBvcnQsIGNiOwogI2lmIGRlZmluZWQoQ09ORklHX0VDT05FVF9BVU5VRFApIHx8IGRlZmluZWQoQ09ORklHX0VDT05FVF9OQVRJVkUpCisJc3RydWN0IHNvY2sgKnNrID0gc29jay0+c2s7CiAJc3RydWN0IHNrX2J1ZmYgKnNrYjsKIAlzdHJ1Y3QgZWNfY2IgKmViOwogI2VuZGlmCkBAIC00ODgsMTAgKzQ4OCwxMCBAQAogCiBlcnJvcl9mcmVlX2J1ZjoKIAl2ZnJlZSh1c2VyYnVmKTsKK2Vycm9yOgogI2Vsc2UKIAllcnIgPSAtRVBST1RPVFlQRTsKICNlbmRpZgotCWVycm9yOgogCW11dGV4X3VubG9jaygmZWNvbmV0X211dGV4KTsKIAogCXJldHVybiBlcnI7CmRpZmYgLS1naXQgYS9uZXQvZXRoZXJuZXQvZXRoLmMgYi9uZXQvZXRoZXJuZXQvZXRoLmMKaW5kZXggZjlkN2FjOS4uNDRkMmI0MiAxMDA2NDQKLS0tIGEvbmV0L2V0aGVybmV0L2V0aC5jCisrKyBiL25ldC9ldGhlcm5ldC9ldGguYwpAQCAtMzUxLDcgKzM1MSw3IEBACiAgKiBAc2l6ZW9mX3ByaXY6IFNpemUgb2YgYWRkaXRpb25hbCBkcml2ZXItcHJpdmF0ZSBzdHJ1Y3R1cmUgdG8gYmUgYWxsb2NhdGVkCiAgKglmb3IgdGhpcyBFdGhlcm5ldCBkZXZpY2UKICAqIEB0eHFzOiBUaGUgbnVtYmVyIG9mIFRYIHF1ZXVlcyB0aGlzIGRldmljZSBoYXMuCi0gKiBAdHhxczogVGhlIG51bWJlciBvZiBSWCBxdWV1ZXMgdGhpcyBkZXZpY2UgaGFzLgorICogQHJ4cXM6IFRoZSBudW1iZXIgb2YgUlggcXVldWVzIHRoaXMgZGV2aWNlIGhhcy4KICAqCiAgKiBGaWxsIGluIHRoZSBmaWVsZHMgb2YgdGhlIGRldmljZSBzdHJ1Y3R1cmUgd2l0aCBFdGhlcm5ldC1nZW5lcmljCiAgKiB2YWx1ZXMuIEJhc2ljYWxseSBkb2VzIGV2ZXJ5dGhpbmcgZXhjZXB0IHJlZ2lzdGVyaW5nIHRoZSBkZXZpY2UuCmRpZmYgLS1naXQgYS9uZXQvaXB2NC9hZl9pbmV0LmMgYi9uZXQvaXB2NC9hZl9pbmV0LmMKaW5kZXggZjJiNjExMC4uNDViODlkNyAxMDA2NDQKLS0tIGEvbmV0L2lwdjQvYWZfaW5ldC5jCisrKyBiL25ldC9pcHY0L2FmX2luZXQuYwpAQCAtODgwLDYgKzg4MCwxOSBAQAogfQogRVhQT1JUX1NZTUJPTChpbmV0X2lvY3RsKTsKIAorI2lmZGVmIENPTkZJR19DT01QQVQKK2ludCBpbmV0X2NvbXBhdF9pb2N0bChzdHJ1Y3Qgc29ja2V0ICpzb2NrLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKK3sKKwlzdHJ1Y3Qgc29jayAqc2sgPSBzb2NrLT5zazsKKwlpbnQgZXJyID0gLUVOT0lPQ1RMQ01EOworCisJaWYgKHNrLT5za19wcm90LT5jb21wYXRfaW9jdGwpCisJCWVyciA9IHNrLT5za19wcm90LT5jb21wYXRfaW9jdGwoc2ssIGNtZCwgYXJnKTsKKworCXJldHVybiBlcnI7Cit9CisjZW5kaWYKKwogY29uc3Qgc3RydWN0IHByb3RvX29wcyBpbmV0X3N0cmVhbV9vcHMgPSB7CiAJLmZhbWlseQkJICAgPSBQRl9JTkVULAogCS5vd25lcgkJICAgPSBUSElTX01PRFVMRSwKQEAgLTkwMyw2ICs5MTYsNyBAQAogI2lmZGVmIENPTkZJR19DT01QQVQKIAkuY29tcGF0X3NldHNvY2tvcHQgPSBjb21wYXRfc29ja19jb21tb25fc2V0c29ja29wdCwKIAkuY29tcGF0X2dldHNvY2tvcHQgPSBjb21wYXRfc29ja19jb21tb25fZ2V0c29ja29wdCwKKwkuY29tcGF0X2lvY3RsCSAgID0gaW5ldF9jb21wYXRfaW9jdGwsCiAjZW5kaWYKIH07CiBFWFBPUlRfU1lNQk9MKGluZXRfc3RyZWFtX29wcyk7CkBAIC05MjksNiArOTQzLDcgQEAKICNpZmRlZiBDT05GSUdfQ09NUEFUCiAJLmNvbXBhdF9zZXRzb2Nrb3B0ID0gY29tcGF0X3NvY2tfY29tbW9uX3NldHNvY2tvcHQsCiAJLmNvbXBhdF9nZXRzb2Nrb3B0ID0gY29tcGF0X3NvY2tfY29tbW9uX2dldHNvY2tvcHQsCisJLmNvbXBhdF9pb2N0bAkgICA9IGluZXRfY29tcGF0X2lvY3RsLAogI2VuZGlmCiB9OwogRVhQT1JUX1NZTUJPTChpbmV0X2RncmFtX29wcyk7CkBAIC05NTksNiArOTc0LDcgQEAKICNpZmRlZiBDT05GSUdfQ09NUEFUCiAJLmNvbXBhdF9zZXRzb2Nrb3B0ID0gY29tcGF0X3NvY2tfY29tbW9uX3NldHNvY2tvcHQsCiAJLmNvbXBhdF9nZXRzb2Nrb3B0ID0gY29tcGF0X3NvY2tfY29tbW9uX2dldHNvY2tvcHQsCisJLmNvbXBhdF9pb2N0bAkgICA9IGluZXRfY29tcGF0X2lvY3RsLAogI2VuZGlmCiB9OwogCmRpZmYgLS1naXQgYS9uZXQvaXB2NC9hcnAuYyBiL25ldC9pcHY0L2FycC5jCmluZGV4IDA0YzhiNjkuLjc5Mjc1ODkgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L2FycC5jCisrKyBiL25ldC9pcHY0L2FycC5jCkBAIC0xMDE3LDE0ICsxMDE3LDEzIEBACiAJCUlQVjRfREVWQ09ORl9BTEwobmV0LCBQUk9YWV9BUlApID0gb247CiAJCXJldHVybiAwOwogCX0KLQlpZiAoX19pbl9kZXZfZ2V0X3JjdShkZXYpKSB7Ci0JCUlOX0RFVl9DT05GX1NFVChfX2luX2Rldl9nZXRfcmN1KGRldiksIFBST1hZX0FSUCwgb24pOworCWlmIChfX2luX2Rldl9nZXRfcnRubChkZXYpKSB7CisJCUlOX0RFVl9DT05GX1NFVChfX2luX2Rldl9nZXRfcnRubChkZXYpLCBQUk9YWV9BUlAsIG9uKTsKIAkJcmV0dXJuIDA7CiAJfQogCXJldHVybiAtRU5YSU87CiB9CiAKLS8qIG11c3QgYmUgY2FsbGVkIHdpdGggcmN1X3JlYWRfbG9jaygpICovCiBzdGF0aWMgaW50IGFycF9yZXFfc2V0X3B1YmxpYyhzdHJ1Y3QgbmV0ICpuZXQsIHN0cnVjdCBhcnByZXEgKnIsCiAJCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCiB7CkBAIC0xMjMzLDEwICsxMjMyLDEwIEBACiAJaWYgKCEoci5hcnBfZmxhZ3MgJiBBVEZfTkVUTUFTSykpCiAJCSgoc3RydWN0IHNvY2thZGRyX2luICopJnIuYXJwX25ldG1hc2spLT5zaW5fYWRkci5zX2FkZHIgPQogCQkJCQkJCSAgIGh0b25sKDB4RkZGRkZGRkZVTCk7Ci0JcmN1X3JlYWRfbG9jaygpOworCXJ0bmxfbG9jaygpOwogCWlmIChyLmFycF9kZXZbMF0pIHsKIAkJZXJyID0gLUVOT0RFVjsKLQkJZGV2ID0gZGV2X2dldF9ieV9uYW1lX3JjdShuZXQsIHIuYXJwX2Rldik7CisJCWRldiA9IF9fZGV2X2dldF9ieV9uYW1lKG5ldCwgci5hcnBfZGV2KTsKIAkJaWYgKGRldiA9PSBOVUxMKQogCQkJZ290byBvdXQ7CiAKQEAgLTEyNjMsNyArMTI2Miw3IEBACiAJCWJyZWFrOwogCX0KIG91dDoKLQlyY3VfcmVhZF91bmxvY2soKTsKKwlydG5sX3VubG9jaygpOwogCWlmIChjbWQgPT0gU0lPQ0dBUlAgJiYgIWVyciAmJiBjb3B5X3RvX3VzZXIoYXJnLCAmciwgc2l6ZW9mKHIpKSkKIAkJZXJyID0gLUVGQVVMVDsKIAlyZXR1cm4gZXJyOwpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvaW5ldF9kaWFnLmMgYi9uZXQvaXB2NC9pbmV0X2RpYWcuYwppbmRleCAyNzQ2YzFmLi4yYWRhMTcxIDEwMDY0NAotLS0gYS9uZXQvaXB2NC9pbmV0X2RpYWcuYworKysgYi9uZXQvaXB2NC9pbmV0X2RpYWcuYwpAQCAtODU4LDcgKzg1OCw3IEBACiAJICAgIG5sbXNnX2xlbihubGgpIDwgaGRybGVuKQogCQlyZXR1cm4gLUVJTlZBTDsKIAotCWlmICgobmxoLT5ubG1zZ19mbGFncyAmIE5MTV9GX0RVTVApID09IE5MTV9GX0RVTVApIHsKKwlpZiAobmxoLT5ubG1zZ19mbGFncyAmIE5MTV9GX0RVTVApIHsKIAkJaWYgKG5sbXNnX2F0dHJsZW4obmxoLCBoZHJsZW4pKSB7CiAJCQlzdHJ1Y3QgbmxhdHRyICphdHRyOwogCmRpZmYgLS1naXQgYS9uZXQvaXB2NC9pbmV0cGVlci5jIGIvbmV0L2lwdjQvaW5ldHBlZXIuYwppbmRleCBkOWJjODU3Li5hOTZlNjU2IDEwMDY0NAotLS0gYS9uZXQvaXB2NC9pbmV0cGVlci5jCisrKyBiL25ldC9pcHY0L2luZXRwZWVyLmMKQEAgLTQ3NSw3ICs0NzUsNyBAQAogc3RydWN0IGluZXRfcGVlciAqaW5ldF9nZXRwZWVyKHN0cnVjdCBpbmV0cGVlcl9hZGRyICpkYWRkciwgaW50IGNyZWF0ZSkKIHsKIAlzdHJ1Y3QgaW5ldF9wZWVyIF9fcmN1ICoqc3RhY2tbUEVFUl9NQVhERVBUSF0sICoqKnN0YWNrcHRyOwotCXN0cnVjdCBpbmV0X3BlZXJfYmFzZSAqYmFzZSA9IGZhbWlseV90b19iYXNlKEFGX0lORVQpOworCXN0cnVjdCBpbmV0X3BlZXJfYmFzZSAqYmFzZSA9IGZhbWlseV90b19iYXNlKGRhZGRyLT5mYW1pbHkpOwogCXN0cnVjdCBpbmV0X3BlZXIgKnA7CiAKIAkvKiBMb29rIHVwIGZvciB0aGUgYWRkcmVzcyBxdWlja2x5LCBsb2NrbGVzcy4KZGlmZiAtLWdpdCBhL25ldC9pcHY0L2lwbXIuYyBiL25ldC9pcHY0L2lwbXIuYwppbmRleCAzZjNhOWFmLi44YjY1YTEyIDEwMDY0NAotLS0gYS9uZXQvaXB2NC9pcG1yLmMKKysrIGIvbmV0L2lwdjQvaXBtci5jCkBAIC02MCw2ICs2MCw3IEBACiAjaW5jbHVkZSA8bGludXgvbm90aWZpZXIuaD4KICNpbmNsdWRlIDxsaW51eC9pZl9hcnAuaD4KICNpbmNsdWRlIDxsaW51eC9uZXRmaWx0ZXJfaXB2NC5oPgorI2luY2x1ZGUgPGxpbnV4L2NvbXBhdC5oPgogI2luY2x1ZGUgPG5ldC9pcGlwLmg+CiAjaW5jbHVkZSA8bmV0L2NoZWNrc3VtLmg+CiAjaW5jbHVkZSA8bmV0L25ldGxpbmsuaD4KQEAgLTE0MzQsNiArMTQzNSw4MSBAQAogCX0KIH0KIAorI2lmZGVmIENPTkZJR19DT01QQVQKK3N0cnVjdCBjb21wYXRfc2lvY19zZ19yZXEgeworCXN0cnVjdCBpbl9hZGRyIHNyYzsKKwlzdHJ1Y3QgaW5fYWRkciBncnA7CisJY29tcGF0X3Vsb25nX3QgcGt0Y250OworCWNvbXBhdF91bG9uZ190IGJ5dGVjbnQ7CisJY29tcGF0X3Vsb25nX3Qgd3JvbmdfaWY7Cit9OworCitzdHJ1Y3QgY29tcGF0X3Npb2NfdmlmX3JlcSB7CisJdmlmaV90CXZpZmk7CQkvKiBXaGljaCBpZmFjZSAqLworCWNvbXBhdF91bG9uZ190IGljb3VudDsKKwljb21wYXRfdWxvbmdfdCBvY291bnQ7CisJY29tcGF0X3Vsb25nX3QgaWJ5dGVzOworCWNvbXBhdF91bG9uZ190IG9ieXRlczsKK307CisKK2ludCBpcG1yX2NvbXBhdF9pb2N0bChzdHJ1Y3Qgc29jayAqc2ssIHVuc2lnbmVkIGludCBjbWQsIHZvaWQgX191c2VyICphcmcpCit7CisJc3RydWN0IGNvbXBhdF9zaW9jX3NnX3JlcSBzcjsKKwlzdHJ1Y3QgY29tcGF0X3Npb2NfdmlmX3JlcSB2cjsKKwlzdHJ1Y3QgdmlmX2RldmljZSAqdmlmOworCXN0cnVjdCBtZmNfY2FjaGUgKmM7CisJc3RydWN0IG5ldCAqbmV0ID0gc29ja19uZXQoc2spOworCXN0cnVjdCBtcl90YWJsZSAqbXJ0OworCisJbXJ0ID0gaXBtcl9nZXRfdGFibGUobmV0LCByYXdfc2soc2spLT5pcG1yX3RhYmxlID8gOiBSVF9UQUJMRV9ERUZBVUxUKTsKKwlpZiAobXJ0ID09IE5VTEwpCisJCXJldHVybiAtRU5PRU5UOworCisJc3dpdGNoIChjbWQpIHsKKwljYXNlIFNJT0NHRVRWSUZDTlQ6CisJCWlmIChjb3B5X2Zyb21fdXNlcigmdnIsIGFyZywgc2l6ZW9mKHZyKSkpCisJCQlyZXR1cm4gLUVGQVVMVDsKKwkJaWYgKHZyLnZpZmkgPj0gbXJ0LT5tYXh2aWYpCisJCQlyZXR1cm4gLUVJTlZBTDsKKwkJcmVhZF9sb2NrKCZtcnRfbG9jayk7CisJCXZpZiA9ICZtcnQtPnZpZl90YWJsZVt2ci52aWZpXTsKKwkJaWYgKFZJRl9FWElTVFMobXJ0LCB2ci52aWZpKSkgeworCQkJdnIuaWNvdW50ID0gdmlmLT5wa3RfaW47CisJCQl2ci5vY291bnQgPSB2aWYtPnBrdF9vdXQ7CisJCQl2ci5pYnl0ZXMgPSB2aWYtPmJ5dGVzX2luOworCQkJdnIub2J5dGVzID0gdmlmLT5ieXRlc19vdXQ7CisJCQlyZWFkX3VubG9jaygmbXJ0X2xvY2spOworCisJCQlpZiAoY29weV90b191c2VyKGFyZywgJnZyLCBzaXplb2YodnIpKSkKKwkJCQlyZXR1cm4gLUVGQVVMVDsKKwkJCXJldHVybiAwOworCQl9CisJCXJlYWRfdW5sb2NrKCZtcnRfbG9jayk7CisJCXJldHVybiAtRUFERFJOT1RBVkFJTDsKKwljYXNlIFNJT0NHRVRTR0NOVDoKKwkJaWYgKGNvcHlfZnJvbV91c2VyKCZzciwgYXJnLCBzaXplb2Yoc3IpKSkKKwkJCXJldHVybiAtRUZBVUxUOworCisJCXJjdV9yZWFkX2xvY2soKTsKKwkJYyA9IGlwbXJfY2FjaGVfZmluZChtcnQsIHNyLnNyYy5zX2FkZHIsIHNyLmdycC5zX2FkZHIpOworCQlpZiAoYykgeworCQkJc3IucGt0Y250ID0gYy0+bWZjX3VuLnJlcy5wa3Q7CisJCQlzci5ieXRlY250ID0gYy0+bWZjX3VuLnJlcy5ieXRlczsKKwkJCXNyLndyb25nX2lmID0gYy0+bWZjX3VuLnJlcy53cm9uZ19pZjsKKwkJCXJjdV9yZWFkX3VubG9jaygpOworCisJCQlpZiAoY29weV90b191c2VyKGFyZywgJnNyLCBzaXplb2Yoc3IpKSkKKwkJCQlyZXR1cm4gLUVGQVVMVDsKKwkJCXJldHVybiAwOworCQl9CisJCXJjdV9yZWFkX3VubG9jaygpOworCQlyZXR1cm4gLUVBRERSTk9UQVZBSUw7CisJZGVmYXVsdDoKKwkJcmV0dXJuIC1FTk9JT0NUTENNRDsKKwl9Cit9CisjZW5kaWYKKwogCiBzdGF0aWMgaW50IGlwbXJfZGV2aWNlX2V2ZW50KHN0cnVjdCBub3RpZmllcl9ibG9jayAqdGhpcywgdW5zaWduZWQgbG9uZyBldmVudCwgdm9pZCAqcHRyKQogewpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvbmV0ZmlsdGVyL2FycHRfbWFuZ2xlLmMgYi9uZXQvaXB2NC9uZXRmaWx0ZXIvYXJwdF9tYW5nbGUuYwppbmRleCBiOGRkY2M0Li5hNWU1MmE5IDEwMDY0NAotLS0gYS9uZXQvaXB2NC9uZXRmaWx0ZXIvYXJwdF9tYW5nbGUuYworKysgYi9uZXQvaXB2NC9uZXRmaWx0ZXIvYXJwdF9tYW5nbGUuYwpAQCAtNjAsMTIgKzYwLDEyIEBACiAKIAlpZiAobWFuZ2xlLT5mbGFncyAmIH5BUlBUX01BTkdMRV9NQVNLIHx8CiAJICAgICEobWFuZ2xlLT5mbGFncyAmIEFSUFRfTUFOR0xFX01BU0spKQotCQlyZXR1cm4gZmFsc2U7CisJCXJldHVybiAtRUlOVkFMOwogCiAJaWYgKG1hbmdsZS0+dGFyZ2V0ICE9IE5GX0RST1AgJiYgbWFuZ2xlLT50YXJnZXQgIT0gTkZfQUNDRVBUICYmCiAJICAgbWFuZ2xlLT50YXJnZXQgIT0gWFRfQ09OVElOVUUpCi0JCXJldHVybiBmYWxzZTsKLQlyZXR1cm4gdHJ1ZTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJcmV0dXJuIDA7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgeHRfdGFyZ2V0IGFycHRfbWFuZ2xlX3JlZyBfX3JlYWRfbW9zdGx5ID0gewpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvcmF3LmMgYi9uZXQvaXB2NC9yYXcuYwppbmRleCBhM2Q1YWI3Li42MzkwYmEyIDEwMDY0NAotLS0gYS9uZXQvaXB2NC9yYXcuYworKysgYi9uZXQvaXB2NC9yYXcuYwpAQCAtNzYsNiArNzYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3NlcV9maWxlLmg+CiAjaW5jbHVkZSA8bGludXgvbmV0ZmlsdGVyLmg+CiAjaW5jbHVkZSA8bGludXgvbmV0ZmlsdGVyX2lwdjQuaD4KKyNpbmNsdWRlIDxsaW51eC9jb21wYXQuaD4KIAogc3RhdGljIHN0cnVjdCByYXdfaGFzaGluZm8gcmF3X3Y0X2hhc2hpbmZvID0gewogCS5sb2NrID0gX19SV19MT0NLX1VOTE9DS0VEKHJhd192NF9oYXNoaW5mby5sb2NrKSwKQEAgLTgzOCw2ICs4MzksMjMgQEAKIAl9CiB9CiAKKyNpZmRlZiBDT05GSUdfQ09NUEFUCitzdGF0aWMgaW50IGNvbXBhdF9yYXdfaW9jdGwoc3RydWN0IHNvY2sgKnNrLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKK3sKKwlzd2l0Y2ggKGNtZCkgeworCWNhc2UgU0lPQ09VVFE6CisJY2FzZSBTSU9DSU5ROgorCQlyZXR1cm4gLUVOT0lPQ1RMQ01EOworCWRlZmF1bHQ6CisjaWZkZWYgQ09ORklHX0lQX01ST1VURQorCQlyZXR1cm4gaXBtcl9jb21wYXRfaW9jdGwoc2ssIGNtZCwgY29tcGF0X3B0cihhcmcpKTsKKyNlbHNlCisJCXJldHVybiAtRU5PSU9DVExDTUQ7CisjZW5kaWYKKwl9Cit9CisjZW5kaWYKKwogc3RydWN0IHByb3RvIHJhd19wcm90ID0gewogCS5uYW1lCQkgICA9ICJSQVciLAogCS5vd25lcgkJICAgPSBUSElTX01PRFVMRSwKQEAgLTg2MCw2ICs4NzgsNyBAQAogI2lmZGVmIENPTkZJR19DT01QQVQKIAkuY29tcGF0X3NldHNvY2tvcHQgPSBjb21wYXRfcmF3X3NldHNvY2tvcHQsCiAJLmNvbXBhdF9nZXRzb2Nrb3B0ID0gY29tcGF0X3Jhd19nZXRzb2Nrb3B0LAorCS5jb21wYXRfaW9jdGwJICAgPSBjb21wYXRfcmF3X2lvY3RsLAogI2VuZGlmCiB9OwogCmRpZmYgLS1naXQgYS9uZXQvaXB2NC9yb3V0ZS5jIGIvbmV0L2lwdjQvcm91dGUuYwppbmRleCAzNTFkYzRlLi43ODhhM2U3IDEwMDY0NAotLS0gYS9uZXQvaXB2NC9yb3V0ZS5jCisrKyBiL25ldC9pcHY0L3JvdXRlLmMKQEAgLTI3MDcsNiArMjcwNywxMSBAQAogCXJldHVybiBOVUxMOwogfQogCitzdGF0aWMgdW5zaWduZWQgaW50IGlwdjRfYmxhY2tob2xlX2RlZmF1bHRfbXR1KGNvbnN0IHN0cnVjdCBkc3RfZW50cnkgKmRzdCkKK3sKKwlyZXR1cm4gMDsKK30KKwogc3RhdGljIHZvaWQgaXB2NF9ydF9ibGFja2hvbGVfdXBkYXRlX3BtdHUoc3RydWN0IGRzdF9lbnRyeSAqZHN0LCB1MzIgbXR1KQogewogfQpAQCAtMjcxNiw2ICsyNzIxLDcgQEAKIAkucHJvdG9jb2wJCT0JY3B1X3RvX2JlMTYoRVRIX1BfSVApLAogCS5kZXN0cm95CQk9CWlwdjRfZHN0X2Rlc3Ryb3ksCiAJLmNoZWNrCQkJPQlpcHY0X2JsYWNraG9sZV9kc3RfY2hlY2ssCisJLmRlZmF1bHRfbXR1CQk9CWlwdjRfYmxhY2tob2xlX2RlZmF1bHRfbXR1LAogCS51cGRhdGVfcG10dQkJPQlpcHY0X3J0X2JsYWNraG9sZV91cGRhdGVfcG10dSwKIH07CiAKZGlmZiAtLWdpdCBhL25ldC9pcHY0L3RjcF9pbnB1dC5jIGIvbmV0L2lwdjQvdGNwX2lucHV0LmMKaW5kZXggMjU0OWIyOS4uZWI3ZjgyZSAxMDA2NDQKLS0tIGEvbmV0L2lwdjQvdGNwX2lucHV0LmMKKysrIGIvbmV0L2lwdjQvdGNwX2lucHV0LmMKQEAgLTQzOTksNyArNDM5OSw3IEBACiAJCQlpZiAoIXNrYl9jb3B5X2RhdGFncmFtX2lvdmVjKHNrYiwgMCwgdHAtPnVjb3B5LmlvdiwgY2h1bmspKSB7CiAJCQkJdHAtPnVjb3B5LmxlbiAtPSBjaHVuazsKIAkJCQl0cC0+Y29waWVkX3NlcSArPSBjaHVuazsKLQkJCQllYXRlbiA9IChjaHVuayA9PSBza2ItPmxlbiAmJiAhdGgtPmZpbik7CisJCQkJZWF0ZW4gPSAoY2h1bmsgPT0gc2tiLT5sZW4pOwogCQkJCXRjcF9yY3Zfc3BhY2VfYWRqdXN0KHNrKTsKIAkJCX0KIAkJCWxvY2FsX2JoX2Rpc2FibGUoKTsKZGlmZiAtLWdpdCBhL25ldC9pcHY0L3RjcF9pcHY0LmMgYi9uZXQvaXB2NC90Y3BfaXB2NC5jCmluZGV4IDg1NmY2ODQuLjAyZjU4M2IgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L3RjcF9pcHY0LmMKKysrIGIvbmV0L2lwdjQvdGNwX2lwdjQuYwpAQCAtMTk5NCw3ICsxOTk0LDYgQEAKIAkJCQl9CiAJCQkJcmVxID0gcmVxLT5kbF9uZXh0OwogCQkJfQotCQkJc3QtPm9mZnNldCA9IDA7CiAJCQlpZiAoKytzdC0+c2J1Y2tldCA+PSBpY3NrLT5pY3NrX2FjY2VwdF9xdWV1ZS5saXN0ZW5fb3B0LT5ucl90YWJsZV9lbnRyaWVzKQogCQkJCWJyZWFrOwogZ2V0X3JlcToKZGlmZiAtLWdpdCBhL25ldC9pcHY2L2FkZHJjb25mLmMgYi9uZXQvaXB2Ni9hZGRyY29uZi5jCmluZGV4IDViMTg5YzkuLmZkNjc4MmUgMTAwNjQ0Ci0tLSBhL25ldC9pcHY2L2FkZHJjb25mLmMKKysrIGIvbmV0L2lwdjYvYWRkcmNvbmYuYwpAQCAtNDIwLDkgKzQyMCw2IEBACiAJICAgIGRldi0+dHlwZSA9PSBBUlBIUkRfVFVOTkVMNiB8fAogCSAgICBkZXYtPnR5cGUgPT0gQVJQSFJEX1NJVCB8fAogCSAgICBkZXYtPnR5cGUgPT0gQVJQSFJEX05PTkUpIHsKLQkJcHJpbnRrKEtFUk5fSU5GTwotCQkgICAgICAgIiVzOiBEaXNhYmxlZCBQcml2YWN5IEV4dGVuc2lvbnNcbiIsCi0JCSAgICAgICBkZXYtPm5hbWUpOwogCQluZGV2LT5jbmYudXNlX3RlbXBhZGRyID0gLTE7CiAJfSBlbHNlIHsKIAkJaW42X2Rldl9ob2xkKG5kZXYpOwpAQCAtMjY2NCwxNCArMjY2MSwxMiBAQAogCXN0cnVjdCBuZXQgKm5ldCA9IGRldl9uZXQoZGV2KTsKIAlzdHJ1Y3QgaW5ldDZfZGV2ICppZGV2OwogCXN0cnVjdCBpbmV0Nl9pZmFkZHIgKmlmYTsKLQlMSVNUX0hFQUQoa2VlcF9saXN0KTsKLQlpbnQgc3RhdGU7CisJaW50IHN0YXRlLCBpOwogCiAJQVNTRVJUX1JUTkwoKTsKIAotCS8qIEZsdXNoIHJvdXRlcyBpZiBkZXZpY2UgaXMgYmVpbmcgcmVtb3ZlZCBvciBpdCBpcyBub3QgbG9vcGJhY2sgKi8KLQlpZiAoaG93IHx8ICEoZGV2LT5mbGFncyAmIElGRl9MT09QQkFDSykpCi0JCXJ0Nl9pZmRvd24obmV0LCBkZXYpOworCXJ0Nl9pZmRvd24obmV0LCBkZXYpOworCW5laWdoX2lmZG93bigmbmRfdGJsLCBkZXYpOwogCiAJaWRldiA9IF9faW42X2Rldl9nZXQoZGV2KTsKIAlpZiAoaWRldiA9PSBOVUxMKQpAQCAtMjY5Miw2ICsyNjg3LDIzIEBACiAKIAl9CiAKKwkvKiBTdGVwIDI6IGNsZWFyIGhhc2ggdGFibGUgKi8KKwlmb3IgKGkgPSAwOyBpIDwgSU42X0FERFJfSFNJWkU7IGkrKykgeworCQlzdHJ1Y3QgaGxpc3RfaGVhZCAqaCA9ICZpbmV0Nl9hZGRyX2xzdFtpXTsKKwkJc3RydWN0IGhsaXN0X25vZGUgKm47CisKKwkJc3Bpbl9sb2NrX2JoKCZhZGRyY29uZl9oYXNoX2xvY2spOworCXJlc3RhcnQ6CisJCWhsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShpZmEsIG4sIGgsIGFkZHJfbHN0KSB7CisJCQlpZiAoaWZhLT5pZGV2ID09IGlkZXYpIHsKKwkJCQlobGlzdF9kZWxfaW5pdF9yY3UoJmlmYS0+YWRkcl9sc3QpOworCQkJCWFkZHJjb25mX2RlbF90aW1lcihpZmEpOworCQkJCWdvdG8gcmVzdGFydDsKKwkJCX0KKwkJfQorCQlzcGluX3VubG9ja19iaCgmYWRkcmNvbmZfaGFzaF9sb2NrKTsKKwl9CisKIAl3cml0ZV9sb2NrX2JoKCZpZGV2LT5sb2NrKTsKIAogCS8qIFN0ZXAgMjogY2xlYXIgZmxhZ3MgZm9yIHN0YXRlbGVzcyBhZGRyY29uZiAqLwpAQCAtMjcyNSw1MiArMjczNywyMyBAQAogCQkJCSAgICAgICBzdHJ1Y3QgaW5ldDZfaWZhZGRyLCBpZl9saXN0KTsKIAkJYWRkcmNvbmZfZGVsX3RpbWVyKGlmYSk7CiAKLQkJLyogSWYganVzdCBkb2luZyBsaW5rIGRvd24sIGFuZCBhZGRyZXNzIGlzIHBlcm1hbmVudAotCQkgICBhbmQgbm90IGxpbmstbG9jYWwsIHRoZW4gcmV0YWluIGl0LiAqLwotCQlpZiAoIWhvdyAmJgotCQkgICAgKGlmYS0+ZmxhZ3MmSUZBX0ZfUEVSTUFORU5UKSAmJgotCQkgICAgIShpcHY2X2FkZHJfdHlwZSgmaWZhLT5hZGRyKSAmIElQVjZfQUREUl9MSU5LTE9DQUwpKSB7Ci0JCQlsaXN0X21vdmVfdGFpbCgmaWZhLT5pZl9saXN0LCAma2VlcF9saXN0KTsKKwkJbGlzdF9kZWwoJmlmYS0+aWZfbGlzdCk7CiAKLQkJCS8qIElmIG5vdCBkb2luZyBEQUQgb24gdGhpcyBhZGRyZXNzLCBqdXN0IGtlZXAgaXQuICovCi0JCQlpZiAoKGRldi0+ZmxhZ3MmKElGRl9OT0FSUHxJRkZfTE9PUEJBQ0spKSB8fAotCQkJICAgIGlkZXYtPmNuZi5hY2NlcHRfZGFkIDw9IDAgfHwKLQkJCSAgICAoaWZhLT5mbGFncyAmIElGQV9GX05PREFEKSkKLQkJCQljb250aW51ZTsKKwkJd3JpdGVfdW5sb2NrX2JoKCZpZGV2LT5sb2NrKTsKIAotCQkJLyogSWYgaXQgd2FzIHRlbnRhdGl2ZSBhbHJlYWR5LCBubyBuZWVkIHRvIG5vdGlmeSAqLwotCQkJaWYgKGlmYS0+ZmxhZ3MgJiBJRkFfRl9URU5UQVRJVkUpCi0JCQkJY29udGludWU7CisJCXNwaW5fbG9ja19iaCgmaWZhLT5zdGF0ZV9sb2NrKTsKKwkJc3RhdGUgPSBpZmEtPnN0YXRlOworCQlpZmEtPnN0YXRlID0gSU5FVDZfSUZBRERSX1NUQVRFX0RFQUQ7CisJCXNwaW5fdW5sb2NrX2JoKCZpZmEtPnN0YXRlX2xvY2spOwogCi0JCQkvKiBGbGFnIGl0IGZvciBsYXRlciByZXN0b3JhdGlvbiB3aGVuIGxpbmsgY29tZXMgdXAgKi8KLQkJCWlmYS0+ZmxhZ3MgfD0gSUZBX0ZfVEVOVEFUSVZFOwotCQkJaWZhLT5zdGF0ZSA9IElORVQ2X0lGQUREUl9TVEFURV9EQUQ7Ci0JCX0gZWxzZSB7Ci0JCQlsaXN0X2RlbCgmaWZhLT5pZl9saXN0KTsKLQotCQkJLyogY2xlYXIgaGFzaCB0YWJsZSAqLwotCQkJc3Bpbl9sb2NrX2JoKCZhZGRyY29uZl9oYXNoX2xvY2spOwotCQkJaGxpc3RfZGVsX2luaXRfcmN1KCZpZmEtPmFkZHJfbHN0KTsKLQkJCXNwaW5fdW5sb2NrX2JoKCZhZGRyY29uZl9oYXNoX2xvY2spOwotCi0JCQl3cml0ZV91bmxvY2tfYmgoJmlkZXYtPmxvY2spOwotCQkJc3Bpbl9sb2NrX2JoKCZpZmEtPnN0YXRlX2xvY2spOwotCQkJc3RhdGUgPSBpZmEtPnN0YXRlOwotCQkJaWZhLT5zdGF0ZSA9IElORVQ2X0lGQUREUl9TVEFURV9ERUFEOwotCQkJc3Bpbl91bmxvY2tfYmgoJmlmYS0+c3RhdGVfbG9jayk7Ci0KLQkJCWlmIChzdGF0ZSAhPSBJTkVUNl9JRkFERFJfU1RBVEVfREVBRCkgewotCQkJCV9faXB2Nl9pZmFfbm90aWZ5KFJUTV9ERUxBRERSLCBpZmEpOwotCQkJCWF0b21pY19ub3RpZmllcl9jYWxsX2NoYWluKCZpbmV0NmFkZHJfY2hhaW4sCi0JCQkJCQkJICAgTkVUREVWX0RPV04sIGlmYSk7Ci0JCQl9Ci0KLQkJCWluNl9pZmFfcHV0KGlmYSk7Ci0JCQl3cml0ZV9sb2NrX2JoKCZpZGV2LT5sb2NrKTsKKwkJaWYgKHN0YXRlICE9IElORVQ2X0lGQUREUl9TVEFURV9ERUFEKSB7CisJCQlfX2lwdjZfaWZhX25vdGlmeShSVE1fREVMQUREUiwgaWZhKTsKKwkJCWF0b21pY19ub3RpZmllcl9jYWxsX2NoYWluKCZpbmV0NmFkZHJfY2hhaW4sIE5FVERFVl9ET1dOLCBpZmEpOwogCQl9Ci0JfQorCQlpbjZfaWZhX3B1dChpZmEpOwogCi0JbGlzdF9zcGxpY2UoJmtlZXBfbGlzdCwgJmlkZXYtPmFkZHJfbGlzdCk7CisJCXdyaXRlX2xvY2tfYmgoJmlkZXYtPmxvY2spOworCX0KIAogCXdyaXRlX3VubG9ja19iaCgmaWRldi0+bG9jayk7CiAKQEAgLTQxNTksOCArNDE0Miw3IEBACiAJCWFkZHJjb25mX2xlYXZlX3NvbGljdChpZnAtPmlkZXYsICZpZnAtPmFkZHIpOwogCQlkc3RfaG9sZCgmaWZwLT5ydC0+ZHN0KTsKIAotCQlpZiAoaWZwLT5zdGF0ZSA9PSBJTkVUNl9JRkFERFJfU1RBVEVfREVBRCAmJgotCQkgICAgaXA2X2RlbF9ydChpZnAtPnJ0KSkKKwkJaWYgKGlwNl9kZWxfcnQoaWZwLT5ydCkpCiAJCQlkc3RfZnJlZSgmaWZwLT5ydC0+ZHN0KTsKIAkJYnJlYWs7CiAJfQpkaWZmIC0tZ2l0IGEvbmV0L2lwdjYvaXA2X291dHB1dC5jIGIvbmV0L2lwdjYvaXA2X291dHB1dC5jCmluZGV4IDk0YjViZjEuLjVmOGQyNDIgMTAwNjQ0Ci0tLSBhL25ldC9pcHY2L2lwNl9vdXRwdXQuYworKysgYi9uZXQvaXB2Ni9pcDZfb3V0cHV0LmMKQEAgLTQwMSw2ICs0MDEsOSBAQAogCQlnb3RvIGRyb3A7CiAJfQogCisJaWYgKHNrYi0+cGt0X3R5cGUgIT0gUEFDS0VUX0hPU1QpCisJCWdvdG8gZHJvcDsKKwogCXNrYl9mb3J3YXJkX2NzdW0oc2tiKTsKIAogCS8qCmRpZmYgLS1naXQgYS9uZXQvaXB2Ni9pcDZtci5jIGIvbmV0L2lwdjYvaXA2bXIuYwppbmRleCA5ZmFiMjc0Li4wZTFkNTNiIDEwMDY0NAotLS0gYS9uZXQvaXB2Ni9pcDZtci5jCisrKyBiL25ldC9pcHY2L2lwNm1yLmMKQEAgLTM0LDYgKzM0LDcgQEAKICNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvY29tcGF0Lmg+CiAjaW5jbHVkZSA8bmV0L3Byb3RvY29sLmg+CiAjaW5jbHVkZSA8bGludXgvc2tidWZmLmg+CiAjaW5jbHVkZSA8bmV0L3NvY2suaD4KQEAgLTE4MDQsNiArMTgwNSw4MCBAQAogCX0KIH0KIAorI2lmZGVmIENPTkZJR19DT01QQVQKK3N0cnVjdCBjb21wYXRfc2lvY19zZ19yZXE2IHsKKwlzdHJ1Y3Qgc29ja2FkZHJfaW42IHNyYzsKKwlzdHJ1Y3Qgc29ja2FkZHJfaW42IGdycDsKKwljb21wYXRfdWxvbmdfdCBwa3RjbnQ7CisJY29tcGF0X3Vsb25nX3QgYnl0ZWNudDsKKwljb21wYXRfdWxvbmdfdCB3cm9uZ19pZjsKK307CisKK3N0cnVjdCBjb21wYXRfc2lvY19taWZfcmVxNiB7CisJbWlmaV90CW1pZmk7CisJY29tcGF0X3Vsb25nX3QgaWNvdW50OworCWNvbXBhdF91bG9uZ190IG9jb3VudDsKKwljb21wYXRfdWxvbmdfdCBpYnl0ZXM7CisJY29tcGF0X3Vsb25nX3Qgb2J5dGVzOworfTsKKworaW50IGlwNm1yX2NvbXBhdF9pb2N0bChzdHJ1Y3Qgc29jayAqc2ssIHVuc2lnbmVkIGludCBjbWQsIHZvaWQgX191c2VyICphcmcpCit7CisJc3RydWN0IGNvbXBhdF9zaW9jX3NnX3JlcTYgc3I7CisJc3RydWN0IGNvbXBhdF9zaW9jX21pZl9yZXE2IHZyOworCXN0cnVjdCBtaWZfZGV2aWNlICp2aWY7CisJc3RydWN0IG1mYzZfY2FjaGUgKmM7CisJc3RydWN0IG5ldCAqbmV0ID0gc29ja19uZXQoc2spOworCXN0cnVjdCBtcjZfdGFibGUgKm1ydDsKKworCW1ydCA9IGlwNm1yX2dldF90YWJsZShuZXQsIHJhdzZfc2soc2spLT5pcDZtcl90YWJsZSA/IDogUlQ2X1RBQkxFX0RGTFQpOworCWlmIChtcnQgPT0gTlVMTCkKKwkJcmV0dXJuIC1FTk9FTlQ7CisKKwlzd2l0Y2ggKGNtZCkgeworCWNhc2UgU0lPQ0dFVE1JRkNOVF9JTjY6CisJCWlmIChjb3B5X2Zyb21fdXNlcigmdnIsIGFyZywgc2l6ZW9mKHZyKSkpCisJCQlyZXR1cm4gLUVGQVVMVDsKKwkJaWYgKHZyLm1pZmkgPj0gbXJ0LT5tYXh2aWYpCisJCQlyZXR1cm4gLUVJTlZBTDsKKwkJcmVhZF9sb2NrKCZtcnRfbG9jayk7CisJCXZpZiA9ICZtcnQtPnZpZjZfdGFibGVbdnIubWlmaV07CisJCWlmIChNSUZfRVhJU1RTKG1ydCwgdnIubWlmaSkpIHsKKwkJCXZyLmljb3VudCA9IHZpZi0+cGt0X2luOworCQkJdnIub2NvdW50ID0gdmlmLT5wa3Rfb3V0OworCQkJdnIuaWJ5dGVzID0gdmlmLT5ieXRlc19pbjsKKwkJCXZyLm9ieXRlcyA9IHZpZi0+Ynl0ZXNfb3V0OworCQkJcmVhZF91bmxvY2soJm1ydF9sb2NrKTsKKworCQkJaWYgKGNvcHlfdG9fdXNlcihhcmcsICZ2ciwgc2l6ZW9mKHZyKSkpCisJCQkJcmV0dXJuIC1FRkFVTFQ7CisJCQlyZXR1cm4gMDsKKwkJfQorCQlyZWFkX3VubG9jaygmbXJ0X2xvY2spOworCQlyZXR1cm4gLUVBRERSTk9UQVZBSUw7CisJY2FzZSBTSU9DR0VUU0dDTlRfSU42OgorCQlpZiAoY29weV9mcm9tX3VzZXIoJnNyLCBhcmcsIHNpemVvZihzcikpKQorCQkJcmV0dXJuIC1FRkFVTFQ7CisKKwkJcmVhZF9sb2NrKCZtcnRfbG9jayk7CisJCWMgPSBpcDZtcl9jYWNoZV9maW5kKG1ydCwgJnNyLnNyYy5zaW42X2FkZHIsICZzci5ncnAuc2luNl9hZGRyKTsKKwkJaWYgKGMpIHsKKwkJCXNyLnBrdGNudCA9IGMtPm1mY191bi5yZXMucGt0OworCQkJc3IuYnl0ZWNudCA9IGMtPm1mY191bi5yZXMuYnl0ZXM7CisJCQlzci53cm9uZ19pZiA9IGMtPm1mY191bi5yZXMud3JvbmdfaWY7CisJCQlyZWFkX3VubG9jaygmbXJ0X2xvY2spOworCisJCQlpZiAoY29weV90b191c2VyKGFyZywgJnNyLCBzaXplb2Yoc3IpKSkKKwkJCQlyZXR1cm4gLUVGQVVMVDsKKwkJCXJldHVybiAwOworCQl9CisJCXJlYWRfdW5sb2NrKCZtcnRfbG9jayk7CisJCXJldHVybiAtRUFERFJOT1RBVkFJTDsKKwlkZWZhdWx0OgorCQlyZXR1cm4gLUVOT0lPQ1RMQ01EOworCX0KK30KKyNlbmRpZgogCiBzdGF0aWMgaW5saW5lIGludCBpcDZtcl9mb3J3YXJkMl9maW5pc2goc3RydWN0IHNrX2J1ZmYgKnNrYikKIHsKZGlmZiAtLWdpdCBhL25ldC9pcHY2L25ldGZpbHRlci9uZl9kZWZyYWdfaXB2Nl9ob29rcy5jIGIvbmV0L2lwdjYvbmV0ZmlsdGVyL25mX2RlZnJhZ19pcHY2X2hvb2tzLmMKaW5kZXggOTlhYmZiNS4uOTdjNWIyMSAxMDA2NDQKLS0tIGEvbmV0L2lwdjYvbmV0ZmlsdGVyL25mX2RlZnJhZ19pcHY2X2hvb2tzLmMKKysrIGIvbmV0L2lwdjYvbmV0ZmlsdGVyL25mX2RlZnJhZ19pcHY2X2hvb2tzLmMKQEAgLTE5LDEzICsxOSwxNSBAQAogCiAjaW5jbHVkZSA8bGludXgvbmV0ZmlsdGVyX2lwdjYuaD4KICNpbmNsdWRlIDxsaW51eC9uZXRmaWx0ZXJfYnJpZGdlLmg+CisjaWYgZGVmaW5lZChDT05GSUdfTkZfQ09OTlRSQUNLKSB8fCBkZWZpbmVkKENPTkZJR19ORl9DT05OVFJBQ0tfTU9EVUxFKQogI2luY2x1ZGUgPG5ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrLmg+CiAjaW5jbHVkZSA8bmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfaGVscGVyLmg+CiAjaW5jbHVkZSA8bmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfbDRwcm90by5oPgogI2luY2x1ZGUgPG5ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX2wzcHJvdG8uaD4KICNpbmNsdWRlIDxuZXQvbmV0ZmlsdGVyL25mX2Nvbm50cmFja19jb3JlLmg+Ci0jaW5jbHVkZSA8bmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfem9uZXMuaD4KICNpbmNsdWRlIDxuZXQvbmV0ZmlsdGVyL2lwdjYvbmZfY29ubnRyYWNrX2lwdjYuaD4KKyNlbmRpZgorI2luY2x1ZGUgPG5ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX3pvbmVzLmg+CiAjaW5jbHVkZSA8bmV0L25ldGZpbHRlci9pcHY2L25mX2RlZnJhZ19pcHY2Lmg+CiAKIHN0YXRpYyBlbnVtIGlwNl9kZWZyYWdfdXNlcnMgbmZfY3Q2X2RlZnJhZ191c2VyKHVuc2lnbmVkIGludCBob29rbnVtLApAQCAtMzMsOCArMzUsMTAgQEAKIHsKIAl1MTYgem9uZSA9IE5GX0NUX0RFRkFVTFRfWk9ORTsKIAorI2lmIGRlZmluZWQoQ09ORklHX05GX0NPTk5UUkFDSykgfHwgZGVmaW5lZChDT05GSUdfTkZfQ09OTlRSQUNLX01PRFVMRSkKIAlpZiAoc2tiLT5uZmN0KQogCQl6b25lID0gbmZfY3Rfem9uZSgoc3RydWN0IG5mX2Nvbm4gKilza2ItPm5mY3QpOworI2VuZGlmCiAKICNpZmRlZiBDT05GSUdfQlJJREdFX05FVEZJTFRFUgogCWlmIChza2ItPm5mX2JyaWRnZSAmJgpAQCAtNTYsOSArNjAsMTEgQEAKIHsKIAlzdHJ1Y3Qgc2tfYnVmZiAqcmVhc207CiAKKyNpZiBkZWZpbmVkKENPTkZJR19ORl9DT05OVFJBQ0spIHx8IGRlZmluZWQoQ09ORklHX05GX0NPTk5UUkFDS19NT0RVTEUpCiAJLyogUHJldmlvdXNseSBzZWVuIChsb29wYmFjayk/CSovCiAJaWYgKHNrYi0+bmZjdCAmJiAhbmZfY3RfaXNfdGVtcGxhdGUoKHN0cnVjdCBuZl9jb25uICopc2tiLT5uZmN0KSkKIAkJcmV0dXJuIE5GX0FDQ0VQVDsKKyNlbmRpZgogCiAJcmVhc20gPSBuZl9jdF9mcmFnNl9nYXRoZXIoc2tiLCBuZl9jdDZfZGVmcmFnX3VzZXIoaG9va251bSwgc2tiKSk7CiAJLyogcXVldWVkICovCmRpZmYgLS1naXQgYS9uZXQvaXB2Ni9yYXcuYyBiL25ldC9pcHY2L3Jhdy5jCmluZGV4IDg2YzM5NTIuLmM1YjA5MTUgMTAwNjQ0Ci0tLSBhL25ldC9pcHY2L3Jhdy5jCisrKyBiL25ldC9pcHY2L3Jhdy5jCkBAIC0zMSw2ICszMSw3IEBACiAjaW5jbHVkZSA8bGludXgvbmV0ZmlsdGVyLmg+CiAjaW5jbHVkZSA8bGludXgvbmV0ZmlsdGVyX2lwdjYuaD4KICNpbmNsdWRlIDxsaW51eC9za2J1ZmYuaD4KKyNpbmNsdWRlIDxsaW51eC9jb21wYXQuaD4KICNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgogI2luY2x1ZGUgPGFzbS9pb2N0bHMuaD4KIApAQCAtMTE1Nyw2ICsxMTU4LDIzIEBACiAJfQogfQogCisjaWZkZWYgQ09ORklHX0NPTVBBVAorc3RhdGljIGludCBjb21wYXRfcmF3djZfaW9jdGwoc3RydWN0IHNvY2sgKnNrLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKK3sKKwlzd2l0Y2ggKGNtZCkgeworCWNhc2UgU0lPQ09VVFE6CisJY2FzZSBTSU9DSU5ROgorCQlyZXR1cm4gLUVOT0lPQ1RMQ01EOworCWRlZmF1bHQ6CisjaWZkZWYgQ09ORklHX0lQVjZfTVJPVVRFCisJCXJldHVybiBpcDZtcl9jb21wYXRfaW9jdGwoc2ssIGNtZCwgY29tcGF0X3B0cihhcmcpKTsKKyNlbHNlCisJCXJldHVybiAtRU5PSU9DVExDTUQ7CisjZW5kaWYKKwl9Cit9CisjZW5kaWYKKwogc3RhdGljIHZvaWQgcmF3djZfY2xvc2Uoc3RydWN0IHNvY2sgKnNrLCBsb25nIHRpbWVvdXQpCiB7CiAJaWYgKGluZXRfc2soc2spLT5pbmV0X251bSA9PSBJUFBST1RPX1JBVykKQEAgLTEyMTUsNiArMTIzMyw3IEBACiAjaWZkZWYgQ09ORklHX0NPTVBBVAogCS5jb21wYXRfc2V0c29ja29wdCA9IGNvbXBhdF9yYXd2Nl9zZXRzb2Nrb3B0LAogCS5jb21wYXRfZ2V0c29ja29wdCA9IGNvbXBhdF9yYXd2Nl9nZXRzb2Nrb3B0LAorCS5jb21wYXRfaW9jdGwJICAgPSBjb21wYXRfcmF3djZfaW9jdGwsCiAjZW5kaWYKIH07CiAKZGlmZiAtLWdpdCBhL25ldC9pcHY2L3JvdXRlLmMgYi9uZXQvaXB2Ni9yb3V0ZS5jCmluZGV4IDM3M2JkMDQuLjFjMjlmOTUgMTAwNjQ0Ci0tLSBhL25ldC9pcHY2L3JvdXRlLmMKKysrIGIvbmV0L2lwdjYvcm91dGUuYwpAQCAtNzIsOCArNzIsNiBAQAogI2RlZmluZSBSVDZfVFJBQ0UoeC4uLikgZG8geyA7IH0gd2hpbGUgKDApCiAjZW5kaWYKIAotI2RlZmluZSBDTE9ORV9PRkZMSU5LX1JPVVRFIDAKLQogc3RhdGljIHN0cnVjdCBydDZfaW5mbyAqIGlwNl9ydF9jb3B5KHN0cnVjdCBydDZfaW5mbyAqb3J0KTsKIHN0YXRpYyBzdHJ1Y3QgZHN0X2VudHJ5CSppcDZfZHN0X2NoZWNrKHN0cnVjdCBkc3RfZW50cnkgKmRzdCwgdTMyIGNvb2tpZSk7CiBzdGF0aWMgdW5zaWduZWQgaW50CSBpcDZfZGVmYXVsdF9hZHZtc3MoY29uc3Qgc3RydWN0IGRzdF9lbnRyeSAqZHN0KTsKQEAgLTExNSw2ICsxMTMsMTEgQEAKIAkubG9jYWxfb3V0CQk9CV9faXA2X2xvY2FsX291dCwKIH07CiAKK3N0YXRpYyB1bnNpZ25lZCBpbnQgaXA2X2JsYWNraG9sZV9kZWZhdWx0X210dShjb25zdCBzdHJ1Y3QgZHN0X2VudHJ5ICpkc3QpCit7CisJcmV0dXJuIDA7Cit9CisKIHN0YXRpYyB2b2lkIGlwNl9ydF9ibGFja2hvbGVfdXBkYXRlX3BtdHUoc3RydWN0IGRzdF9lbnRyeSAqZHN0LCB1MzIgbXR1KQogewogfQpAQCAtMTI0LDYgKzEyNyw3IEBACiAJLnByb3RvY29sCQk9CWNwdV90b19iZTE2KEVUSF9QX0lQVjYpLAogCS5kZXN0cm95CQk9CWlwNl9kc3RfZGVzdHJveSwKIAkuY2hlY2sJCQk9CWlwNl9kc3RfY2hlY2ssCisJLmRlZmF1bHRfbXR1CQk9CWlwNl9ibGFja2hvbGVfZGVmYXVsdF9tdHUsCiAJLnVwZGF0ZV9wbXR1CQk9CWlwNl9ydF9ibGFja2hvbGVfdXBkYXRlX3BtdHUsCiB9OwogCkBAIC0xOTYsNyArMjAwLDYgQEAKIAkJaW42X2Rldl9wdXQoaWRldik7CiAJfQogCWlmIChwZWVyKSB7Ci0JCUJVR19PTighKHJ0LT5ydDZpX2ZsYWdzICYgUlRGX0NBQ0hFKSk7CiAJCXJ0LT5ydDZpX3BlZXIgPSBOVUxMOwogCQlpbmV0X3B1dHBlZXIocGVlcik7CiAJfQpAQCAtMjA2LDkgKzIwOSw2IEBACiB7CiAJc3RydWN0IGluZXRfcGVlciAqcGVlcjsKIAotCWlmIChXQVJOX09OKCEocnQtPnJ0NmlfZmxhZ3MgJiBSVEZfQ0FDSEUpKSkKLQkJcmV0dXJuOwotCiAJcGVlciA9IGluZXRfZ2V0cGVlcl92NigmcnQtPnJ0NmlfZHN0LmFkZHIsIGNyZWF0ZSk7CiAJaWYgKHBlZXIgJiYgY21weGNoZygmcnQtPnJ0NmlfcGVlciwgTlVMTCwgcGVlcikgIT0gTlVMTCkKIAkJaW5ldF9wdXRwZWVyKHBlZXIpOwpAQCAtNzM4LDEzICs3MzgsOCBAQAogCiAJaWYgKCFydC0+cnQ2aV9uZXh0aG9wICYmICEocnQtPnJ0NmlfZmxhZ3MgJiBSVEZfTk9ORVhUSE9QKSkKIAkJbnJ0ID0gcnQ2X2FsbG9jX2NvdyhydCwgJmZsLT5mbDZfZHN0LCAmZmwtPmZsNl9zcmMpOwotCWVsc2UgewotI2lmIENMT05FX09GRkxJTktfUk9VVEUKKwllbHNlCiAJCW5ydCA9IHJ0Nl9hbGxvY19jbG9uZShydCwgJmZsLT5mbDZfZHN0KTsKLSNlbHNlCi0JCWdvdG8gb3V0MjsKLSNlbmRpZgotCX0KIAogCWRzdF9yZWxlYXNlKCZydC0+ZHN0KTsKIAlydCA9IG5ydCA/IDogbmV0LT5pcHY2LmlwNl9udWxsX2VudHJ5OwpkaWZmIC0tZ2l0IGEvbmV0L2lwdjYvc3lzY3RsX25ldF9pcHY2LmMgYi9uZXQvaXB2Ni9zeXNjdGxfbmV0X2lwdjYuYwppbmRleCBmYTFkOGY0Li43Y2I2NWVmIDEwMDY0NAotLS0gYS9uZXQvaXB2Ni9zeXNjdGxfbmV0X2lwdjYuYworKysgYi9uZXQvaXB2Ni9zeXNjdGxfbmV0X2lwdjYuYwpAQCAtMTUsNiArMTUsOCBAQAogI2luY2x1ZGUgPG5ldC9hZGRyY29uZi5oPgogI2luY2x1ZGUgPG5ldC9pbmV0X2ZyYWcuaD4KIAorc3RhdGljIHN0cnVjdCBjdGxfdGFibGUgZW1wdHlbMV07CisKIHN0YXRpYyBjdGxfdGFibGUgaXB2Nl90YWJsZV90ZW1wbGF0ZVtdID0gewogCXsKIAkJLnByb2NuYW1lCT0gInJvdXRlIiwKQEAgLTM1LDYgKzM3LDEyIEBACiAJCS5tb2RlCQk9IDA2NDQsCiAJCS5wcm9jX2hhbmRsZXIJPSBwcm9jX2RvaW50dmVjCiAJfSwKKwl7CisJCS5wcm9jbmFtZQk9ICJuZWlnaCIsCisJCS5tYXhsZW4JCT0gMCwKKwkJLm1vZGUJCT0gMDU1NSwKKwkJLmNoaWxkCQk9IGVtcHR5LAorCX0sCiAJeyB9CiB9OwogCkBAIC0xNTIsNyArMTYwLDYgQEAKIAogaW50IGlwdjZfc3RhdGljX3N5c2N0bF9yZWdpc3Rlcih2b2lkKQogewotCXN0YXRpYyBzdHJ1Y3QgY3RsX3RhYmxlIGVtcHR5WzFdOwogCWlwNl9iYXNlID0gcmVnaXN0ZXJfc3lzY3RsX3BhdGhzKG5ldF9pcHY2X2N0bF9wYXRoLCBlbXB0eSk7CiAJaWYgKGlwNl9iYXNlID09IE5VTEwpCiAJCXJldHVybiAtRU5PTUVNOwpkaWZmIC0tZ2l0IGEvbmV0L2lwdjYveGZybTZfcG9saWN5LmMgYi9uZXQvaXB2Ni94ZnJtNl9wb2xpY3kuYwppbmRleCA3ZTc0MDIzLi5kYTg3NDI4IDEwMDY0NAotLS0gYS9uZXQvaXB2Ni94ZnJtNl9wb2xpY3kuYworKysgYi9uZXQvaXB2Ni94ZnJtNl9wb2xpY3kuYwpAQCAtOTgsNiArOTgsMTAgQEAKIAlpZiAoIXhkc3QtPnUucnQ2LnJ0NmlfaWRldikKIAkJcmV0dXJuIC1FTk9ERVY7CiAKKwl4ZHN0LT51LnJ0Ni5ydDZpX3BlZXIgPSBydC0+cnQ2aV9wZWVyOworCWlmIChydC0+cnQ2aV9wZWVyKQorCQlhdG9taWNfaW5jKCZydC0+cnQ2aV9wZWVyLT5yZWZjbnQpOworCiAJLyogU2hlaXQuLi4gSSByZW1lbWJlciBJIGRpZCB0aGlzIHJpZ2h0LiBBcHBhcmVudGx5LAogCSAqIGl0IHdhcyBtYWdpY2FsbHkgbG9zdCwgc28gdGhpcyBjb2RlIG5lZWRzIGF1ZGl0ICovCiAJeGRzdC0+dS5ydDYucnQ2aV9mbGFncyA9IHJ0LT5ydDZpX2ZsYWdzICYgKFJURl9BTllDQVNUIHwKQEAgLTIxNiw2ICsyMjAsOCBAQAogCiAJaWYgKGxpa2VseSh4ZHN0LT51LnJ0Ni5ydDZpX2lkZXYpKQogCQlpbjZfZGV2X3B1dCh4ZHN0LT51LnJ0Ni5ydDZpX2lkZXYpOworCWlmIChsaWtlbHkoeGRzdC0+dS5ydDYucnQ2aV9wZWVyKSkKKwkJaW5ldF9wdXRwZWVyKHhkc3QtPnUucnQ2LnJ0NmlfcGVlcik7CiAJeGZybV9kc3RfZGVzdHJveSh4ZHN0KTsKIH0KIApkaWZmIC0tZ2l0IGEvbmV0L21hYzgwMjExL0tjb25maWcgYi9uZXQvbWFjODAyMTEvS2NvbmZpZwppbmRleCA5MTA5MjYyLi5jNzY2MDU2IDEwMDY0NAotLS0gYS9uZXQvbWFjODAyMTEvS2NvbmZpZworKysgYi9uZXQvbWFjODAyMTEvS2NvbmZpZwpAQCAtMjAsNyArMjAsNyBAQAogCWRlZl9ib29sIG4KIAogY29uZmlnIE1BQzgwMjExX1JDX1BJRAotCWJvb2wgIlBJRCBjb250cm9sbGVyIGJhc2VkIHJhdGUgY29udHJvbCBhbGdvcml0aG0iIGlmIEVNQkVEREVECisJYm9vbCAiUElEIGNvbnRyb2xsZXIgYmFzZWQgcmF0ZSBjb250cm9sIGFsZ29yaXRobSIgaWYgRVhQRVJUCiAJc2VsZWN0IE1BQzgwMjExX0hBU19SQwogCS0tLWhlbHAtLS0KIAkgIFRoaXMgb3B0aW9uIGVuYWJsZXMgYSBUWCByYXRlIGNvbnRyb2wgYWxnb3JpdGhtIGZvcgpAQCAtMjgsMTQgKzI4LDE0IEBACiAJICByYXRlLgogCiBjb25maWcgTUFDODAyMTFfUkNfTUlOU1RSRUwKLQlib29sICJNaW5zdHJlbCIgaWYgRU1CRURERUQKKwlib29sICJNaW5zdHJlbCIgaWYgRVhQRVJUCiAJc2VsZWN0IE1BQzgwMjExX0hBU19SQwogCWRlZmF1bHQgeQogCS0tLWhlbHAtLS0KIAkgIFRoaXMgb3B0aW9uIGVuYWJsZXMgdGhlICdtaW5zdHJlbCcgVFggcmF0ZSBjb250cm9sIGFsZ29yaXRobQogCiBjb25maWcgTUFDODAyMTFfUkNfTUlOU1RSRUxfSFQKLQlib29sICJNaW5zdHJlbCA4MDIuMTFuIHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiTWluc3RyZWwgODAyLjExbiBzdXBwb3J0IiBpZiBFWFBFUlQKIAlkZXBlbmRzIG9uIE1BQzgwMjExX1JDX01JTlNUUkVMCiAJZGVmYXVsdCB5CiAJLS0taGVscC0tLQpkaWZmIC0tZ2l0IGEvbmV0L21hYzgwMjExL2FnZy1yeC5jIGIvbmV0L21hYzgwMjExL2FnZy1yeC5jCmluZGV4IGYxMzhiMTkuLjIyN2NhODIgMTAwNjQ0Ci0tLSBhL25ldC9tYWM4MDIxMS9hZ2ctcnguYworKysgYi9uZXQvbWFjODAyMTEvYWdnLXJ4LmMKQEAgLTE4NSw4ICsxODUsNiBAQAogCQkJCSAgICAgc3RydWN0IGllZWU4MDIxMV9tZ210ICptZ210LAogCQkJCSAgICAgc2l6ZV90IGxlbikKIHsKLQlzdHJ1Y3QgaWVlZTgwMjExX2h3ICpodyA9ICZsb2NhbC0+aHc7Ci0Jc3RydWN0IGllZWU4MDIxMV9jb25mICpjb25mID0gJmh3LT5jb25mOwogCXN0cnVjdCB0aWRfYW1wZHVfcnggKnRpZF9hZ2dfcng7CiAJdTE2IGNhcGFiLCB0aWQsIHRpbWVvdXQsIGJhX3BvbGljeSwgYnVmX3NpemUsIHN0YXJ0X3NlcV9udW0sIHN0YXR1czsKIAl1OCBkaWFsb2dfdG9rZW47CkBAIC0yMzEsMTMgKzIyOSw4IEBACiAJCWdvdG8gZW5kX25vX2xvY2s7CiAJfQogCS8qIGRldGVybWluZSBkZWZhdWx0IGJ1ZmZlciBzaXplICovCi0JaWYgKGJ1Zl9zaXplID09IDApIHsKLQkJc3RydWN0IGllZWU4MDIxMV9zdXBwb3J0ZWRfYmFuZCAqc2JhbmQ7Ci0KLQkJc2JhbmQgPSBsb2NhbC0+aHcud2lwaHktPmJhbmRzW2NvbmYtPmNoYW5uZWwtPmJhbmRdOwotCQlidWZfc2l6ZSA9IElFRUU4MDIxMV9NSU5fQU1QRFVfQlVGOwotCQlidWZfc2l6ZSA9IGJ1Zl9zaXplIDw8IHNiYW5kLT5odF9jYXAuYW1wZHVfZmFjdG9yOwotCX0KKwlpZiAoYnVmX3NpemUgPT0gMCkKKwkJYnVmX3NpemUgPSBJRUVFODAyMTFfTUFYX0FNUERVX0JVRjsKIAogCiAJLyogZXhhbWluZSBzdGF0ZSBtYWNoaW5lICovCmRpZmYgLS1naXQgYS9uZXQvbWFjODAyMTEvY2ZnLmMgYi9uZXQvbWFjODAyMTEvY2ZnLmMKaW5kZXggNGJjOGE5Mi4uOWNkNzNiMSAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjExL2NmZy5jCisrKyBiL25ldC9tYWM4MDIxMS9jZmcuYwpAQCAtMTgyMiw2ICsxODIyLDcgQEAKIAkJKmNvb2tpZSBePSAyOwogCQlJRUVFODAyMTFfU0tCX0NCKHNrYiktPmZsYWdzIHw9IElFRUU4MDIxMV9UWF9DVExfVFhfT0ZGQ0hBTjsKIAkJbG9jYWwtPmh3X3JvY19za2IgPSBza2I7CisJCWxvY2FsLT5od19yb2Nfc2tiX2Zvcl9zdGF0dXMgPSBza2I7CiAJCW11dGV4X3VubG9jaygmbG9jYWwtPm10eCk7CiAKIAkJcmV0dXJuIDA7CkBAIC0xODc1LDYgKzE4NzYsNyBAQAogCQlpZiAocmV0ID09IDApIHsKIAkJCWtmcmVlX3NrYihsb2NhbC0+aHdfcm9jX3NrYik7CiAJCQlsb2NhbC0+aHdfcm9jX3NrYiA9IE5VTEw7CisJCQlsb2NhbC0+aHdfcm9jX3NrYl9mb3Jfc3RhdHVzID0gTlVMTDsKIAkJfQogCiAJCW11dGV4X3VubG9jaygmbG9jYWwtPm10eCk7CmRpZmYgLS1naXQgYS9uZXQvbWFjODAyMTEvaWVlZTgwMjExX2kuaCBiL25ldC9tYWM4MDIxMS9pZWVlODAyMTFfaS5oCmluZGV4IGM0N2Q3YzAuLjUzM2ZkMzIgMTAwNjQ0Ci0tLSBhL25ldC9tYWM4MDIxMS9pZWVlODAyMTFfaS5oCisrKyBiL25ldC9tYWM4MDIxMS9pZWVlODAyMTFfaS5oCkBAIC05NTMsNyArOTUzLDcgQEAKIAogCXN0cnVjdCBpZWVlODAyMTFfY2hhbm5lbCAqaHdfcm9jX2NoYW5uZWw7CiAJc3RydWN0IG5ldF9kZXZpY2UgKmh3X3JvY19kZXY7Ci0Jc3RydWN0IHNrX2J1ZmYgKmh3X3JvY19za2I7CisJc3RydWN0IHNrX2J1ZmYgKmh3X3JvY19za2IsICpod19yb2Nfc2tiX2Zvcl9zdGF0dXM7CiAJc3RydWN0IHdvcmtfc3RydWN0IGh3X3JvY19zdGFydCwgaHdfcm9jX2RvbmU7CiAJZW51bSBubDgwMjExX2NoYW5uZWxfdHlwZSBod19yb2NfY2hhbm5lbF90eXBlOwogCXVuc2lnbmVkIGludCBod19yb2NfZHVyYXRpb247CmRpZmYgLS1naXQgYS9uZXQvbWFjODAyMTEvbWFpbi5jIGIvbmV0L21hYzgwMjExL21haW4uYwppbmRleCA0ODVkMzZiLi5hNDZmZjA2IDEwMDY0NAotLS0gYS9uZXQvbWFjODAyMTEvbWFpbi5jCisrKyBiL25ldC9tYWM4MDIxMS9tYWluLmMKQEAgLTM5LDYgKzM5LDggQEAKIE1PRFVMRV9QQVJNX0RFU0MoaWVlZTgwMjExX2Rpc2FibGVfNDBtaHpfMjRnaHosCiAJCSAiRGlzYWJsZSA0ME1IeiBzdXBwb3J0IGluIHRoZSAyLjRHSHogYmFuZCIpOwogCitzdGF0aWMgc3RydWN0IGxvY2tfY2xhc3Nfa2V5IGllZWU4MDIxMV9yeF9za2JfcXVldWVfY2xhc3M7CisKIHZvaWQgaWVlZTgwMjExX2NvbmZpZ3VyZV9maWx0ZXIoc3RydWN0IGllZWU4MDIxMV9sb2NhbCAqbG9jYWwpCiB7CiAJdTY0IG1jOwpAQCAtNTY5LDcgKzU3MSwxNSBAQAogCXNwaW5fbG9ja19pbml0KCZsb2NhbC0+ZmlsdGVyX2xvY2spOwogCXNwaW5fbG9ja19pbml0KCZsb2NhbC0+cXVldWVfc3RvcF9yZWFzb25fbG9jayk7CiAKLQlza2JfcXVldWVfaGVhZF9pbml0KCZsb2NhbC0+cnhfc2tiX3F1ZXVlKTsKKwkvKgorCSAqIFRoZSByeF9za2JfcXVldWUgaXMgb25seSBhY2Nlc3NlZCBmcm9tIHRhc2tsZXRzLAorCSAqIGJ1dCBvdGhlciBTS0IgcXVldWVzIGFyZSB1c2VkIGZyb20gd2l0aGluIElSUQorCSAqIGNvbnRleHQuIFRoZXJlZm9yZSwgdGhpcyBvbmUgbmVlZHMgYSBkaWZmZXJlbnQKKwkgKiBsb2NraW5nIGNsYXNzIHNvIG91ciBkaXJlY3QsIG5vbi1pcnEtc2FmZSB1c2Ugb2YKKwkgKiB0aGUgcXVldWUncyBsb2NrIGRvZXNuJ3QgdGhyb3cgbG9ja2RlcCB3YXJuaW5ncy4KKwkgKi8KKwlza2JfcXVldWVfaGVhZF9pbml0X2NsYXNzKCZsb2NhbC0+cnhfc2tiX3F1ZXVlLAorCQkJCSAgJmllZWU4MDIxMV9yeF9za2JfcXVldWVfY2xhc3MpOwogCiAJSU5JVF9ERUxBWUVEX1dPUksoJmxvY2FsLT5zY2FuX3dvcmssIGllZWU4MDIxMV9zY2FuX3dvcmspOwogCmRpZmYgLS1naXQgYS9uZXQvbWFjODAyMTEvc3RhdHVzLmMgYi9uZXQvbWFjODAyMTEvc3RhdHVzLmMKaW5kZXggMzhhNzk3Mi4uMDcxYWM5NSAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjExL3N0YXR1cy5jCisrKyBiL25ldC9tYWM4MDIxMS9zdGF0dXMuYwpAQCAtMzIzLDYgKzMyMyw3IEBACiAKIAlpZiAoaW5mby0+ZmxhZ3MgJiBJRUVFODAyMTFfVFhfSU5URkxfTkw4MDIxMV9GUkFNRV9UWCkgewogCQlzdHJ1Y3QgaWVlZTgwMjExX3dvcmsgKndrOworCQl1NjQgY29va2llID0gKHVuc2lnbmVkIGxvbmcpc2tiOwogCiAJCXJjdV9yZWFkX2xvY2soKTsKIAkJbGlzdF9mb3JfZWFjaF9lbnRyeV9yY3Uod2ssICZsb2NhbC0+d29ya19saXN0LCBsaXN0KSB7CkBAIC0zMzQsOCArMzM1LDEyIEBACiAJCQlicmVhazsKIAkJfQogCQlyY3VfcmVhZF91bmxvY2soKTsKKwkJaWYgKGxvY2FsLT5od19yb2Nfc2tiX2Zvcl9zdGF0dXMgPT0gc2tiKSB7CisJCQljb29raWUgPSBsb2NhbC0+aHdfcm9jX2Nvb2tpZSBeIDI7CisJCQlsb2NhbC0+aHdfcm9jX3NrYl9mb3Jfc3RhdHVzID0gTlVMTDsKKwkJfQogCQljZmc4MDIxMV9tZ210X3R4X3N0YXR1cygKLQkJCXNrYi0+ZGV2LCAodW5zaWduZWQgbG9uZykgc2tiLCBza2ItPmRhdGEsIHNrYi0+bGVuLAorCQkJc2tiLT5kZXYsIGNvb2tpZSwgc2tiLT5kYXRhLCBza2ItPmxlbiwKIAkJCSEhKGluZm8tPmZsYWdzICYgSUVFRTgwMjExX1RYX1NUQVRfQUNLKSwgR0ZQX0FUT01JQyk7CiAJfQogCmRpZmYgLS1naXQgYS9uZXQvbWFjODAyMTEvdHguYyBiL25ldC9tYWM4MDIxMS90eC5jCmluZGV4IGE0NDlkZDUuLjMwNjUzM2IgMTAwNjQ0Ci0tLSBhL25ldC9tYWM4MDIxMS90eC5jCisrKyBiL25ldC9tYWM4MDIxMS90eC5jCkBAIC0xNTQ3LDcgKzE1NDcsNyBAQAogCQlza2Jfb3JwaGFuKHNrYik7CiAJfQogCi0JaWYgKHNrYl9oZWFkZXJfY2xvbmVkKHNrYikpCisJaWYgKHNrYl9jbG9uZWQoc2tiKSkKIAkJSTgwMl9ERUJVR19JTkMobG9jYWwtPnR4X2V4cGFuZF9za2JfaGVhZF9jbG9uZWQpOwogCWVsc2UgaWYgKGhlYWRfbmVlZCB8fCB0YWlsX25lZWQpCiAJCUk4MDJfREVCVUdfSU5DKGxvY2FsLT50eF9leHBhbmRfc2tiX2hlYWQpOwpAQCAtMjIzMCw2ICsyMjMwLDkgQEAKIAogCXNkYXRhID0gdmlmX3RvX3NkYXRhKHZpZik7CiAKKwlpZiAoIWllZWU4MDIxMV9zZGF0YV9ydW5uaW5nKHNkYXRhKSkKKwkJZ290byBvdXQ7CisKIAlpZiAodGltX29mZnNldCkKIAkJKnRpbV9vZmZzZXQgPSAwOwogCWlmICh0aW1fbGVuZ3RoKQpkaWZmIC0tZ2l0IGEvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfY29yZS5jIGIvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfY29yZS5jCmluZGV4IGU2MTUxMTkuLjg0ZjRmY2MgMTAwNjQ0Ci0tLSBhL25ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX2NvcmUuYworKysgYi9uZXQvbmV0ZmlsdGVyL25mX2Nvbm50cmFja19jb3JlLmMKQEAgLTk0Miw4ICs5NDIsMTUgQEAKIAlpZiAoc2V0X3JlcGx5ICYmICF0ZXN0X2FuZF9zZXRfYml0KElQU19TRUVOX1JFUExZX0JJVCwgJmN0LT5zdGF0dXMpKQogCQluZl9jb25udHJhY2tfZXZlbnRfY2FjaGUoSVBDVF9SRVBMWSwgY3QpOwogb3V0OgotCWlmICh0bXBsKQotCQluZl9jdF9wdXQodG1wbCk7CisJaWYgKHRtcGwpIHsKKwkJLyogU3BlY2lhbCBjYXNlOiB3ZSBoYXZlIHRvIHJlcGVhdCB0aGlzIGhvb2ssIGFzc2lnbiB0aGUKKwkJICogdGVtcGxhdGUgYWdhaW4gdG8gdGhpcyBwYWNrZXQuIFdlIGFzc3VtZSB0aGF0IHRoaXMgcGFja2V0CisJCSAqIGhhcyBubyBjb25udHJhY2sgYXNzaWduZWQuIFRoaXMgaXMgdXNlZCBieSBuZl9jdF90Y3AuICovCisJCWlmIChyZXQgPT0gTkZfUkVQRUFUKQorCQkJc2tiLT5uZmN0ID0gKHN0cnVjdCBuZl9jb25udHJhY2sgKil0bXBsOworCQllbHNlCisJCQluZl9jdF9wdXQodG1wbCk7CisJfQogCiAJcmV0dXJuIHJldDsKIH0KZGlmZiAtLWdpdCBhL25ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX2VjYWNoZS5jIGIvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfZWNhY2hlLmMKaW5kZXggNTcwMmRlMy4uNjNhMWI5MSAxMDA2NDQKLS0tIGEvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfZWNhY2hlLmMKKysrIGIvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfZWNhY2hlLmMKQEAgLTYzLDYgKzYzLDkgQEAKIAkJICogdGhpcyBkb2VzIG5vdCBoYXJtIGFuZCBpdCBoYXBwZW5zIHZlcnkgcmFyZWx5LiAqLwogCQl1bnNpZ25lZCBsb25nIG1pc3NlZCA9IGUtPm1pc3NlZDsKIAorCQlpZiAoISgoZXZlbnRzIHwgbWlzc2VkKSAmIGUtPmN0bWFzaykpCisJCQlnb3RvIG91dF91bmxvY2s7CisKIAkJcmV0ID0gbm90aWZ5LT5mY24oZXZlbnRzIHwgbWlzc2VkLCAmaXRlbSk7CiAJCWlmICh1bmxpa2VseShyZXQgPCAwIHx8IG1pc3NlZCkpIHsKIAkJCXNwaW5fbG9ja19iaCgmY3QtPmxvY2spOwpkaWZmIC0tZ2l0IGEvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfbmV0bGluay5jIGIvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfbmV0bGluay5jCmluZGV4IDVjYjhkMzAuLmVlYWQ5ZGIgMTAwNjQ0Ci0tLSBhL25ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX25ldGxpbmsuYworKysgYi9uZXQvbmV0ZmlsdGVyL25mX2Nvbm50cmFja19uZXRsaW5rLmMKQEAgLTY2Nyw2ICs2NjcsNyBAQAogCQkJaWYgKGN0bmV0bGlua19maWxsX2luZm8oc2tiLCBORVRMSU5LX0NCKGNiLT5za2IpLnBpZCwKIAkJCQkJCWNiLT5ubGgtPm5sbXNnX3NlcSwKIAkJCQkJCUlQQ1ROTF9NU0dfQ1RfTkVXLCBjdCkgPCAwKSB7CisJCQkJbmZfY29ubnRyYWNrX2dldCgmY3QtPmN0X2dlbmVyYWwpOwogCQkJCWNiLT5hcmdzWzFdID0gKHVuc2lnbmVkIGxvbmcpY3Q7CiAJCQkJZ290byBvdXQ7CiAJCQl9CkBAIC05MjQsNyArOTI1LDcgQEAKIAl1MTYgem9uZTsKIAlpbnQgZXJyOwogCi0JaWYgKChubGgtPm5sbXNnX2ZsYWdzICYgTkxNX0ZfRFVNUCkgPT0gTkxNX0ZfRFVNUCkKKwlpZiAobmxoLT5ubG1zZ19mbGFncyAmIE5MTV9GX0RVTVApCiAJCXJldHVybiBuZXRsaW5rX2R1bXBfc3RhcnQoY3RubCwgc2tiLCBubGgsIGN0bmV0bGlua19kdW1wX3RhYmxlLAogCQkJCQkgIGN0bmV0bGlua19kb25lKTsKIApAQCAtOTcyLDcgKzk3Myw4IEBACiBmcmVlOgogCWtmcmVlX3NrYihza2IyKTsKIG91dDoKLQlyZXR1cm4gZXJyOworCS8qIHRoaXMgYXZvaWRzIGEgbG9vcCBpbiBuZm5ldGxpbmsuICovCisJcmV0dXJuIGVyciA9PSAtRUFHQUlOID8gLUVOT0JVRlMgOiBlcnI7CiB9CiAKICNpZmRlZiBDT05GSUdfTkZfTkFUX05FRURFRApAQCAtMTc4Niw3ICsxNzg4LDcgQEAKIAl1MTYgem9uZTsKIAlpbnQgZXJyOwogCi0JaWYgKChubGgtPm5sbXNnX2ZsYWdzICYgTkxNX0ZfRFVNUCkgPT0gTkxNX0ZfRFVNUCkgeworCWlmIChubGgtPm5sbXNnX2ZsYWdzICYgTkxNX0ZfRFVNUCkgewogCQlyZXR1cm4gbmV0bGlua19kdW1wX3N0YXJ0KGN0bmwsIHNrYiwgbmxoLAogCQkJCQkgIGN0bmV0bGlua19leHBfZHVtcF90YWJsZSwKIAkJCQkJICBjdG5ldGxpbmtfZXhwX2RvbmUpOwpkaWZmIC0tZ2l0IGEvbmV0L25ldGZpbHRlci94dF9pcHJhbmdlLmMgYi9uZXQvbmV0ZmlsdGVyL3h0X2lwcmFuZ2UuYwppbmRleCA4OGY3YzM1Li43M2MzM2E0IDEwMDY0NAotLS0gYS9uZXQvbmV0ZmlsdGVyL3h0X2lwcmFuZ2UuYworKysgYi9uZXQvbmV0ZmlsdGVyL3h0X2lwcmFuZ2UuYwpAQCAtNTMsMTUgKzUzLDEzIEBACiB9CiAKIHN0YXRpYyBpbmxpbmUgaW50Ci1pcHJhbmdlX2lwdjZfc3ViKGNvbnN0IHN0cnVjdCBpbjZfYWRkciAqYSwgY29uc3Qgc3RydWN0IGluNl9hZGRyICpiKQoraXByYW5nZV9pcHY2X2x0KGNvbnN0IHN0cnVjdCBpbjZfYWRkciAqYSwgY29uc3Qgc3RydWN0IGluNl9hZGRyICpiKQogewogCXVuc2lnbmVkIGludCBpOwotCWludCByOwogCiAJZm9yIChpID0gMDsgaSA8IDQ7ICsraSkgewotCQlyID0gbnRvaGwoYS0+czZfYWRkcjMyW2ldKSAtIG50b2hsKGItPnM2X2FkZHIzMltpXSk7Ci0JCWlmIChyICE9IDApCi0JCQlyZXR1cm4gcjsKKwkJaWYgKGEtPnM2X2FkZHIzMltpXSAhPSBiLT5zNl9hZGRyMzJbaV0pCisJCQlyZXR1cm4gbnRvaGwoYS0+czZfYWRkcjMyW2ldKSA8IG50b2hsKGItPnM2X2FkZHIzMltpXSk7CiAJfQogCiAJcmV0dXJuIDA7CkBAIC03NSwxNSArNzMsMTUgQEAKIAlib29sIG07CiAKIAlpZiAoaW5mby0+ZmxhZ3MgJiBJUFJBTkdFX1NSQykgewotCQltICA9IGlwcmFuZ2VfaXB2Nl9zdWIoJmlwaC0+c2FkZHIsICZpbmZvLT5zcmNfbWluLmluNikgPCAwOwotCQltIHw9IGlwcmFuZ2VfaXB2Nl9zdWIoJmlwaC0+c2FkZHIsICZpbmZvLT5zcmNfbWF4LmluNikgPiAwOworCQltICA9IGlwcmFuZ2VfaXB2Nl9sdCgmaXBoLT5zYWRkciwgJmluZm8tPnNyY19taW4uaW42KTsKKwkJbSB8PSBpcHJhbmdlX2lwdjZfbHQoJmluZm8tPnNyY19tYXguaW42LCAmaXBoLT5zYWRkcik7CiAJCW0gXj0gISEoaW5mby0+ZmxhZ3MgJiBJUFJBTkdFX1NSQ19JTlYpOwogCQlpZiAobSkKIAkJCXJldHVybiBmYWxzZTsKIAl9CiAJaWYgKGluZm8tPmZsYWdzICYgSVBSQU5HRV9EU1QpIHsKLQkJbSAgPSBpcHJhbmdlX2lwdjZfc3ViKCZpcGgtPmRhZGRyLCAmaW5mby0+ZHN0X21pbi5pbjYpIDwgMDsKLQkJbSB8PSBpcHJhbmdlX2lwdjZfc3ViKCZpcGgtPmRhZGRyLCAmaW5mby0+ZHN0X21heC5pbjYpID4gMDsKKwkJbSAgPSBpcHJhbmdlX2lwdjZfbHQoJmlwaC0+ZGFkZHIsICZpbmZvLT5kc3RfbWluLmluNik7CisJCW0gfD0gaXByYW5nZV9pcHY2X2x0KCZpbmZvLT5kc3RfbWF4LmluNiwgJmlwaC0+ZGFkZHIpOwogCQltIF49ICEhKGluZm8tPmZsYWdzICYgSVBSQU5HRV9EU1RfSU5WKTsKIAkJaWYgKG0pCiAJCQlyZXR1cm4gZmFsc2U7CmRpZmYgLS1naXQgYS9uZXQvbmV0bGluay9nZW5ldGxpbmsuYyBiL25ldC9uZXRsaW5rL2dlbmV0bGluay5jCmluZGV4IGY4M2NiMzcuLjE3ODFkOTkgMTAwNjQ0Ci0tLSBhL25ldC9uZXRsaW5rL2dlbmV0bGluay5jCisrKyBiL25ldC9uZXRsaW5rL2dlbmV0bGluay5jCkBAIC01MTksNyArNTE5LDcgQEAKIAkgICAgc2VjdXJpdHlfbmV0bGlua19yZWN2KHNrYiwgQ0FQX05FVF9BRE1JTikpCiAJCXJldHVybiAtRVBFUk07CiAKLQlpZiAoKG5saC0+bmxtc2dfZmxhZ3MgJiBOTE1fRl9EVU1QKSA9PSBOTE1fRl9EVU1QKSB7CisJaWYgKG5saC0+bmxtc2dfZmxhZ3MgJiBOTE1fRl9EVU1QKSB7CiAJCWlmIChvcHMtPmR1bXBpdCA9PSBOVUxMKQogCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCmRpZmYgLS1naXQgYS9uZXQvcmZraWxsL0tjb25maWcgYi9uZXQvcmZraWxsL0tjb25maWcKaW5kZXggZWFmNzY1OC4uN2ZjZTZkZiAxMDA2NDQKLS0tIGEvbmV0L3Jma2lsbC9LY29uZmlnCisrKyBiL25ldC9yZmtpbGwvS2NvbmZpZwpAQCAtMTgsNyArMTgsNyBAQAogCWRlZmF1bHQgeQogCiBjb25maWcgUkZLSUxMX0lOUFVUCi0JYm9vbCAiUkYgc3dpdGNoIGlucHV0IHN1cHBvcnQiIGlmIEVNQkVEREVECisJYm9vbCAiUkYgc3dpdGNoIGlucHV0IHN1cHBvcnQiIGlmIEVYUEVSVAogCWRlcGVuZHMgb24gUkZLSUxMCiAJZGVwZW5kcyBvbiBJTlBVVCA9IHkgfHwgUkZLSUxMID0gSU5QVVQKLQlkZWZhdWx0IHkgaWYgIUVNQkVEREVECisJZGVmYXVsdCB5IGlmICFFWFBFUlQKZGlmZiAtLWdpdCBhL25ldC9yeHJwYy9hZl9yeHJwYy5jIGIvbmV0L3J4cnBjL2FmX3J4cnBjLmMKaW5kZXggMGI5YmIyMC4uNzRjMDY0YyAxMDA2NDQKLS0tIGEvbmV0L3J4cnBjL2FmX3J4cnBjLmMKKysrIGIvbmV0L3J4cnBjL2FmX3J4cnBjLmMKQEAgLTgwOCw3ICs4MDgsNyBAQAogCQlnb3RvIGVycm9yX2NhbGxfamFyOwogCX0KIAotCXJ4cnBjX3dvcmtxdWV1ZSA9IGNyZWF0ZV93b3JrcXVldWUoImtyeHJwY2QiKTsKKwlyeHJwY193b3JrcXVldWUgPSBhbGxvY193b3JrcXVldWUoImtyeHJwY2QiLCAwLCAxKTsKIAlpZiAoIXJ4cnBjX3dvcmtxdWV1ZSkgewogCQlwcmludGsoS0VSTl9OT1RJQ0UgIlJ4UlBDOiBGYWlsZWQgdG8gYWxsb2NhdGUgd29yayBxdWV1ZVxuIik7CiAJCWdvdG8gZXJyb3Jfd29ya19xdWV1ZTsKZGlmZiAtLWdpdCBhL25ldC9zY2hlZC9zY2hfY2JxLmMgYi9uZXQvc2NoZWQvc2NoX2NicS5jCmluZGV4IGM4MGQxYzIuLjVmNjNlYzUgMTAwNjQ0Ci0tLSBhL25ldC9zY2hlZC9zY2hfY2JxLmMKKysrIGIvbmV0L3NjaGVkL3NjaF9jYnEuYwpAQCAtMzkwLDcgKzM5MCw2IEBACiAJcmV0ID0gcWRpc2NfZW5xdWV1ZShza2IsIGNsLT5xKTsKIAlpZiAocmV0ID09IE5FVF9YTUlUX1NVQ0NFU1MpIHsKIAkJc2NoLT5xLnFsZW4rKzsKLQkJcWRpc2NfYnN0YXRzX3VwZGF0ZShzY2gsIHNrYik7CiAJCWNicV9tYXJrX3RvcGxldmVsKHEsIGNsKTsKIAkJaWYgKCFjbC0+bmV4dF9hbGl2ZSkKIAkJCWNicV9hY3RpdmF0ZV9jbGFzcyhjbCk7CkBAIC02NDksNyArNjQ4LDYgQEAKIAkJcmV0ID0gcWRpc2NfZW5xdWV1ZShza2IsIGNsLT5xKTsKIAkJaWYgKHJldCA9PSBORVRfWE1JVF9TVUNDRVNTKSB7CiAJCQlzY2gtPnEucWxlbisrOwotCQkJcWRpc2NfYnN0YXRzX3VwZGF0ZShzY2gsIHNrYik7CiAJCQlpZiAoIWNsLT5uZXh0X2FsaXZlKQogCQkJCWNicV9hY3RpdmF0ZV9jbGFzcyhjbCk7CiAJCQlyZXR1cm4gMDsKQEAgLTk3MSw2ICs5NjksNyBAQAogCiAJCXNrYiA9IGNicV9kZXF1ZXVlXzEoc2NoKTsKIAkJaWYgKHNrYikgeworCQkJcWRpc2NfYnN0YXRzX3VwZGF0ZShzY2gsIHNrYik7CiAJCQlzY2gtPnEucWxlbi0tOwogCQkJc2NoLT5mbGFncyAmPSB+VENRX0ZfVEhST1RUTEVEOwogCQkJcmV0dXJuIHNrYjsKZGlmZiAtLWdpdCBhL25ldC9zY2hlZC9zY2hfZHJyLmMgYi9uZXQvc2NoZWQvc2NoX2Ryci5jCmluZGV4IGRlNTVlNjQuLjZiN2ZlNGEgMTAwNjQ0Ci0tLSBhL25ldC9zY2hlZC9zY2hfZHJyLmMKKysrIGIvbmV0L3NjaGVkL3NjaF9kcnIuYwpAQCAtMzc2LDcgKzM3Niw2IEBACiAJfQogCiAJYnN0YXRzX3VwZGF0ZSgmY2wtPmJzdGF0cywgc2tiKTsKLQlxZGlzY19ic3RhdHNfdXBkYXRlKHNjaCwgc2tiKTsKIAogCXNjaC0+cS5xbGVuKys7CiAJcmV0dXJuIGVycjsKQEAgLTQwMyw2ICs0MDIsNyBAQAogCQkJc2tiID0gcWRpc2NfZGVxdWV1ZV9wZWVrZWQoY2wtPnFkaXNjKTsKIAkJCWlmIChjbC0+cWRpc2MtPnEucWxlbiA9PSAwKQogCQkJCWxpc3RfZGVsKCZjbC0+YWxpc3QpOworCQkJcWRpc2NfYnN0YXRzX3VwZGF0ZShzY2gsIHNrYik7CiAJCQlzY2gtPnEucWxlbi0tOwogCQkJcmV0dXJuIHNrYjsKIAkJfQpkaWZmIC0tZ2l0IGEvbmV0L3NjaGVkL3NjaF9kc21hcmsuYyBiL25ldC9zY2hlZC9zY2hfZHNtYXJrLmMKaW5kZXggNjBmNGJkZC4uMGY3YmYzZiAxMDA2NDQKLS0tIGEvbmV0L3NjaGVkL3NjaF9kc21hcmsuYworKysgYi9uZXQvc2NoZWQvc2NoX2RzbWFyay5jCkBAIC0yNjAsNyArMjYwLDYgQEAKIAkJcmV0dXJuIGVycjsKIAl9CiAKLQlxZGlzY19ic3RhdHNfdXBkYXRlKHNjaCwgc2tiKTsKIAlzY2gtPnEucWxlbisrOwogCiAJcmV0dXJuIE5FVF9YTUlUX1NVQ0NFU1M7CkBAIC0yODMsNiArMjgyLDcgQEAKIAlpZiAoc2tiID09IE5VTEwpCiAJCXJldHVybiBOVUxMOwogCisJcWRpc2NfYnN0YXRzX3VwZGF0ZShzY2gsIHNrYik7CiAJc2NoLT5xLnFsZW4tLTsKIAogCWluZGV4ID0gc2tiLT50Y19pbmRleCAmIChwLT5pbmRpY2VzIC0gMSk7CmRpZmYgLS1naXQgYS9uZXQvc2NoZWQvc2NoX2ZpZm8uYyBiL25ldC9zY2hlZC9zY2hfZmlmby5jCmluZGV4IGFhNGQ2MzMuLmQ0NjhiNDcgMTAwNjQ0Ci0tLSBhL25ldC9zY2hlZC9zY2hfZmlmby5jCisrKyBiL25ldC9zY2hlZC9zY2hfZmlmby5jCkBAIC00NiwxNyArNDYsMTQgQEAKIAogc3RhdGljIGludCBwZmlmb190YWlsX2VucXVldWUoc3RydWN0IHNrX2J1ZmYgKnNrYiwgc3RydWN0IFFkaXNjKiBzY2gpCiB7Ci0Jc3RydWN0IHNrX2J1ZmYgKnNrYl9oZWFkOwogCXN0cnVjdCBmaWZvX3NjaGVkX2RhdGEgKnEgPSBxZGlzY19wcml2KHNjaCk7CiAKIAlpZiAobGlrZWx5KHNrYl9xdWV1ZV9sZW4oJnNjaC0+cSkgPCBxLT5saW1pdCkpCiAJCXJldHVybiBxZGlzY19lbnF1ZXVlX3RhaWwoc2tiLCBzY2gpOwogCiAJLyogcXVldWUgZnVsbCwgcmVtb3ZlIG9uZSBza2IgdG8gZnVsZmlsbCB0aGUgbGltaXQgKi8KLQlza2JfaGVhZCA9IHFkaXNjX2RlcXVldWVfaGVhZChzY2gpOworCV9fcWRpc2NfcXVldWVfZHJvcF9oZWFkKHNjaCwgJnNjaC0+cSk7CiAJc2NoLT5xc3RhdHMuZHJvcHMrKzsKLQlrZnJlZV9za2Ioc2tiX2hlYWQpOwotCiAJcWRpc2NfZW5xdWV1ZV90YWlsKHNrYiwgc2NoKTsKIAogCXJldHVybiBORVRfWE1JVF9DTjsKZGlmZiAtLWdpdCBhL25ldC9zY2hlZC9zY2hfaGZzYy5jIGIvbmV0L3NjaGVkL3NjaF9oZnNjLmMKaW5kZXggMmU0NTc5MS4uMTRhNzk5ZGUgMTAwNjQ0Ci0tLSBhL25ldC9zY2hlZC9zY2hfaGZzYy5jCisrKyBiL25ldC9zY2hlZC9zY2hfaGZzYy5jCkBAIC0xNjAwLDcgKzE2MDAsNiBAQAogCQlzZXRfYWN0aXZlKGNsLCBxZGlzY19wa3RfbGVuKHNrYikpOwogCiAJYnN0YXRzX3VwZGF0ZSgmY2wtPmJzdGF0cywgc2tiKTsKLQlxZGlzY19ic3RhdHNfdXBkYXRlKHNjaCwgc2tiKTsKIAlzY2gtPnEucWxlbisrOwogCiAJcmV0dXJuIE5FVF9YTUlUX1NVQ0NFU1M7CkBAIC0xNjY2LDYgKzE2NjUsNyBAQAogCX0KIAogCXNjaC0+ZmxhZ3MgJj0gflRDUV9GX1RIUk9UVExFRDsKKwlxZGlzY19ic3RhdHNfdXBkYXRlKHNjaCwgc2tiKTsKIAlzY2gtPnEucWxlbi0tOwogCiAJcmV0dXJuIHNrYjsKZGlmZiAtLWdpdCBhL25ldC9zY2hlZC9zY2hfaHRiLmMgYi9uZXQvc2NoZWQvc2NoX2h0Yi5jCmluZGV4IDk4NGMxYjAuLmZjMTJmZTYgMTAwNjQ0Ci0tLSBhL25ldC9zY2hlZC9zY2hfaHRiLmMKKysrIGIvbmV0L3NjaGVkL3NjaF9odGIuYwpAQCAtNTc0LDcgKzU3NCw2IEBACiAJfQogCiAJc2NoLT5xLnFsZW4rKzsKLQlxZGlzY19ic3RhdHNfdXBkYXRlKHNjaCwgc2tiKTsKIAlyZXR1cm4gTkVUX1hNSVRfU1VDQ0VTUzsKIH0KIApAQCAtODQyLDcgKzg0MSw3IEBACiAKIHN0YXRpYyBzdHJ1Y3Qgc2tfYnVmZiAqaHRiX2RlcXVldWUoc3RydWN0IFFkaXNjICpzY2gpCiB7Ci0Jc3RydWN0IHNrX2J1ZmYgKnNrYiA9IE5VTEw7CisJc3RydWN0IHNrX2J1ZmYgKnNrYjsKIAlzdHJ1Y3QgaHRiX3NjaGVkICpxID0gcWRpc2NfcHJpdihzY2gpOwogCWludCBsZXZlbDsKIAlwc2NoZWRfdGltZV90IG5leHRfZXZlbnQ7CkBAIC04NTEsNiArODUwLDggQEAKIAkvKiB0cnkgdG8gZGVxdWV1ZSBkaXJlY3QgcGFja2V0cyBhcyBoaWdoIHByaW8gKCEpIHRvIG1pbmltaXplIGNwdSB3b3JrICovCiAJc2tiID0gX19za2JfZGVxdWV1ZSgmcS0+ZGlyZWN0X3F1ZXVlKTsKIAlpZiAoc2tiICE9IE5VTEwpIHsKK29rOgorCQlxZGlzY19ic3RhdHNfdXBkYXRlKHNjaCwgc2tiKTsKIAkJc2NoLT5mbGFncyAmPSB+VENRX0ZfVEhST1RUTEVEOwogCQlzY2gtPnEucWxlbi0tOwogCQlyZXR1cm4gc2tiOwpAQCAtODg0LDExICs4ODUsOCBAQAogCQkJaW50IHByaW8gPSBmZnoobSk7CiAJCQltIHw9IDEgPDwgcHJpbzsKIAkJCXNrYiA9IGh0Yl9kZXF1ZXVlX3RyZWUocSwgcHJpbywgbGV2ZWwpOwotCQkJaWYgKGxpa2VseShza2IgIT0gTlVMTCkpIHsKLQkJCQlzY2gtPnEucWxlbi0tOwotCQkJCXNjaC0+ZmxhZ3MgJj0gflRDUV9GX1RIUk9UVExFRDsKLQkJCQlnb3RvIGZpbjsKLQkJCX0KKwkJCWlmIChsaWtlbHkoc2tiICE9IE5VTEwpKQorCQkJCWdvdG8gb2s7CiAJCX0KIAl9CiAJc2NoLT5xc3RhdHMub3ZlcmxpbWl0cysrOwpkaWZmIC0tZ2l0IGEvbmV0L3NjaGVkL3NjaF9tdWx0aXEuYyBiL25ldC9zY2hlZC9zY2hfbXVsdGlxLmMKaW5kZXggMjFmMTNkYS4uNDM2YTJlNyAxMDA2NDQKLS0tIGEvbmV0L3NjaGVkL3NjaF9tdWx0aXEuYworKysgYi9uZXQvc2NoZWQvc2NoX211bHRpcS5jCkBAIC04Myw3ICs4Myw2IEBACiAKIAlyZXQgPSBxZGlzY19lbnF1ZXVlKHNrYiwgcWRpc2MpOwogCWlmIChyZXQgPT0gTkVUX1hNSVRfU1VDQ0VTUykgewotCQlxZGlzY19ic3RhdHNfdXBkYXRlKHNjaCwgc2tiKTsKIAkJc2NoLT5xLnFsZW4rKzsKIAkJcmV0dXJuIE5FVF9YTUlUX1NVQ0NFU1M7CiAJfQpAQCAtMTEyLDYgKzExMSw3IEBACiAJCQlxZGlzYyA9IHEtPnF1ZXVlc1txLT5jdXJiYW5kXTsKIAkJCXNrYiA9IHFkaXNjLT5kZXF1ZXVlKHFkaXNjKTsKIAkJCWlmIChza2IpIHsKKwkJCQlxZGlzY19ic3RhdHNfdXBkYXRlKHNjaCwgc2tiKTsKIAkJCQlzY2gtPnEucWxlbi0tOwogCQkJCXJldHVybiBza2I7CiAJCQl9CmRpZmYgLS1naXQgYS9uZXQvc2NoZWQvc2NoX25ldGVtLmMgYi9uZXQvc2NoZWQvc2NoX25ldGVtLmMKaW5kZXggMWM0YmNlOC4uNmEzMDA2YiAxMDA2NDQKLS0tIGEvbmV0L3NjaGVkL3NjaF9uZXRlbS5jCisrKyBiL25ldC9zY2hlZC9zY2hfbmV0ZW0uYwpAQCAtMjQwLDcgKzI0MCw2IEBACiAKIAlpZiAobGlrZWx5KHJldCA9PSBORVRfWE1JVF9TVUNDRVNTKSkgewogCQlzY2gtPnEucWxlbisrOwotCQlxZGlzY19ic3RhdHNfdXBkYXRlKHNjaCwgc2tiKTsKIAl9IGVsc2UgaWYgKG5ldF94bWl0X2Ryb3BfY291bnQocmV0KSkgewogCQlzY2gtPnFzdGF0cy5kcm9wcysrOwogCX0KQEAgLTI4OSw2ICsyODgsNyBAQAogCQkJCXNrYi0+dHN0YW1wLnR2NjQgPSAwOwogI2VuZGlmCiAJCQlwcl9kZWJ1ZygibmV0ZW1fZGVxdWV1ZTogcmV0dXJuIHNrYj0lcFxuIiwgc2tiKTsKKwkJCXFkaXNjX2JzdGF0c191cGRhdGUoc2NoLCBza2IpOwogCQkJc2NoLT5xLnFsZW4tLTsKIAkJCXJldHVybiBza2I7CiAJCX0KQEAgLTQ3Niw3ICs0NzYsNiBAQAogCQlfX3NrYl9xdWV1ZV9hZnRlcihsaXN0LCBza2IsIG5za2IpOwogCiAJCXNjaC0+cXN0YXRzLmJhY2tsb2cgKz0gcWRpc2NfcGt0X2xlbihuc2tiKTsKLQkJcWRpc2NfYnN0YXRzX3VwZGF0ZShzY2gsIG5za2IpOwogCiAJCXJldHVybiBORVRfWE1JVF9TVUNDRVNTOwogCX0KZGlmZiAtLWdpdCBhL25ldC9zY2hlZC9zY2hfcHJpby5jIGIvbmV0L3NjaGVkL3NjaF9wcmlvLmMKaW5kZXggOTY2MTU4ZC4uZmJkNzEwZCAxMDA2NDQKLS0tIGEvbmV0L3NjaGVkL3NjaF9wcmlvLmMKKysrIGIvbmV0L3NjaGVkL3NjaF9wcmlvLmMKQEAgLTg0LDcgKzg0LDYgQEAKIAogCXJldCA9IHFkaXNjX2VucXVldWUoc2tiLCBxZGlzYyk7CiAJaWYgKHJldCA9PSBORVRfWE1JVF9TVUNDRVNTKSB7Ci0JCXFkaXNjX2JzdGF0c191cGRhdGUoc2NoLCBza2IpOwogCQlzY2gtPnEucWxlbisrOwogCQlyZXR1cm4gTkVUX1hNSVRfU1VDQ0VTUzsKIAl9CkBAIC0xMTYsNiArMTE1LDcgQEAKIAkJc3RydWN0IFFkaXNjICpxZGlzYyA9IHEtPnF1ZXVlc1twcmlvXTsKIAkJc3RydWN0IHNrX2J1ZmYgKnNrYiA9IHFkaXNjLT5kZXF1ZXVlKHFkaXNjKTsKIAkJaWYgKHNrYikgeworCQkJcWRpc2NfYnN0YXRzX3VwZGF0ZShzY2gsIHNrYik7CiAJCQlzY2gtPnEucWxlbi0tOwogCQkJcmV0dXJuIHNrYjsKIAkJfQpkaWZmIC0tZ2l0IGEvbmV0L3NjaGVkL3NjaF9yZWQuYyBiL25ldC9zY2hlZC9zY2hfcmVkLmMKaW5kZXggYTYwMDljNS4uOWY5OGRiZCAxMDA2NDQKLS0tIGEvbmV0L3NjaGVkL3NjaF9yZWQuYworKysgYi9uZXQvc2NoZWQvc2NoX3JlZC5jCkBAIC05NCw3ICs5NCw2IEBACiAKIAlyZXQgPSBxZGlzY19lbnF1ZXVlKHNrYiwgY2hpbGQpOwogCWlmIChsaWtlbHkocmV0ID09IE5FVF9YTUlUX1NVQ0NFU1MpKSB7Ci0JCXFkaXNjX2JzdGF0c191cGRhdGUoc2NoLCBza2IpOwogCQlzY2gtPnEucWxlbisrOwogCX0gZWxzZSBpZiAobmV0X3htaXRfZHJvcF9jb3VudChyZXQpKSB7CiAJCXEtPnN0YXRzLnBkcm9wKys7CkBAIC0xMTQsMTEgKzExMywxMyBAQAogCXN0cnVjdCBRZGlzYyAqY2hpbGQgPSBxLT5xZGlzYzsKIAogCXNrYiA9IGNoaWxkLT5kZXF1ZXVlKGNoaWxkKTsKLQlpZiAoc2tiKQorCWlmIChza2IpIHsKKwkJcWRpc2NfYnN0YXRzX3VwZGF0ZShzY2gsIHNrYik7CiAJCXNjaC0+cS5xbGVuLS07Ci0JZWxzZSBpZiAoIXJlZF9pc19pZGxpbmcoJnEtPnBhcm1zKSkKLQkJcmVkX3N0YXJ0X29mX2lkbGVfcGVyaW9kKCZxLT5wYXJtcyk7Ci0KKwl9IGVsc2UgeworCQlpZiAoIXJlZF9pc19pZGxpbmcoJnEtPnBhcm1zKSkKKwkJCXJlZF9zdGFydF9vZl9pZGxlX3BlcmlvZCgmcS0+cGFybXMpOworCX0KIAlyZXR1cm4gc2tiOwogfQogCmRpZmYgLS1naXQgYS9uZXQvc2NoZWQvc2NoX3NmcS5jIGIvbmV0L3NjaGVkL3NjaF9zZnEuYwppbmRleCAyMzllYzUzLi5lZGVhOGNlIDEwMDY0NAotLS0gYS9uZXQvc2NoZWQvc2NoX3NmcS5jCisrKyBiL25ldC9zY2hlZC9zY2hfc2ZxLmMKQEAgLTQwMiwxMCArNDAyLDggQEAKIAkJcS0+dGFpbCA9IHNsb3Q7CiAJCXNsb3QtPmFsbG90ID0gcS0+c2NhbGVkX3F1YW50dW07CiAJfQotCWlmICgrK3NjaC0+cS5xbGVuIDw9IHEtPmxpbWl0KSB7Ci0JCXFkaXNjX2JzdGF0c191cGRhdGUoc2NoLCBza2IpOworCWlmICgrK3NjaC0+cS5xbGVuIDw9IHEtPmxpbWl0KQogCQlyZXR1cm4gTkVUX1hNSVRfU1VDQ0VTUzsKLQl9CiAKIAlzZnFfZHJvcChzY2gpOwogCXJldHVybiBORVRfWE1JVF9DTjsKQEAgLTQ0NSw2ICs0NDMsNyBAQAogCX0KIAlza2IgPSBzbG90X2RlcXVldWVfaGVhZChzbG90KTsKIAlzZnFfZGVjKHEsIGEpOworCXFkaXNjX2JzdGF0c191cGRhdGUoc2NoLCBza2IpOwogCXNjaC0+cS5xbGVuLS07CiAJc2NoLT5xc3RhdHMuYmFja2xvZyAtPSBxZGlzY19wa3RfbGVuKHNrYik7CiAKZGlmZiAtLWdpdCBhL25ldC9zY2hlZC9zY2hfdGJmLmMgYi9uZXQvc2NoZWQvc2NoX3RiZi5jCmluZGV4IDc3NTY1ZTcuLmU5MzE2NTggMTAwNjQ0Ci0tLSBhL25ldC9zY2hlZC9zY2hfdGJmLmMKKysrIGIvbmV0L3NjaGVkL3NjaF90YmYuYwpAQCAtMTM0LDcgKzEzNCw2IEBACiAJfQogCiAJc2NoLT5xLnFsZW4rKzsKLQlxZGlzY19ic3RhdHNfdXBkYXRlKHNjaCwgc2tiKTsKIAlyZXR1cm4gTkVUX1hNSVRfU1VDQ0VTUzsKIH0KIApAQCAtMTg3LDYgKzE4Niw3IEBACiAJCQlxLT5wdG9rZW5zID0gcHRva3M7CiAJCQlzY2gtPnEucWxlbi0tOwogCQkJc2NoLT5mbGFncyAmPSB+VENRX0ZfVEhST1RUTEVEOworCQkJcWRpc2NfYnN0YXRzX3VwZGF0ZShzY2gsIHNrYik7CiAJCQlyZXR1cm4gc2tiOwogCQl9CiAKZGlmZiAtLWdpdCBhL25ldC9zY2hlZC9zY2hfdGVxbC5jIGIvbmV0L3NjaGVkL3NjaF90ZXFsLmMKaW5kZXggYWY5MzYwZC4uZDg0ZTczMiAxMDA2NDQKLS0tIGEvbmV0L3NjaGVkL3NjaF90ZXFsLmMKKysrIGIvbmV0L3NjaGVkL3NjaF90ZXFsLmMKQEAgLTU5LDYgKzU5LDEwIEBACiAJc3RydWN0IG5ldF9kZXZpY2UgKmRldjsKIAlzdHJ1Y3QgUWRpc2MgKnNsYXZlczsKIAlzdHJ1Y3QgbGlzdF9oZWFkIG1hc3Rlcl9saXN0OworCXVuc2lnbmVkIGxvbmcJdHhfYnl0ZXM7CisJdW5zaWduZWQgbG9uZwl0eF9wYWNrZXRzOworCXVuc2lnbmVkIGxvbmcJdHhfZXJyb3JzOworCXVuc2lnbmVkIGxvbmcJdHhfZHJvcHBlZDsKIH07CiAKIHN0cnVjdCB0ZXFsX3NjaGVkX2RhdGEKQEAgLTgzLDcgKzg3LDYgQEAKIAogCWlmIChxLT5xLnFsZW4gPCBkZXYtPnR4X3F1ZXVlX2xlbikgewogCQlfX3NrYl9xdWV1ZV90YWlsKCZxLT5xLCBza2IpOwotCQlxZGlzY19ic3RhdHNfdXBkYXRlKHNjaCwgc2tiKTsKIAkJcmV0dXJuIE5FVF9YTUlUX1NVQ0NFU1M7CiAJfQogCkBAIC0xMDcsNiArMTEwLDggQEAKIAkJCWRhdC0+bS0+c2xhdmVzID0gc2NoOwogCQkJbmV0aWZfd2FrZV9xdWV1ZShtKTsKIAkJfQorCX0gZWxzZSB7CisJCXFkaXNjX2JzdGF0c191cGRhdGUoc2NoLCBza2IpOwogCX0KIAlzY2gtPnEucWxlbiA9IGRhdC0+cS5xbGVuICsgZGF0X3F1ZXVlLT5xZGlzYy0+cS5xbGVuOwogCXJldHVybiBza2I7CkBAIC0yNzQsNyArMjc5LDYgQEAKIHN0YXRpYyBuZXRkZXZfdHhfdCB0ZXFsX21hc3Rlcl94bWl0KHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0IHRlcWxfbWFzdGVyICptYXN0ZXIgPSBuZXRkZXZfcHJpdihkZXYpOwotCXN0cnVjdCBuZXRkZXZfcXVldWUgKnR4cSA9IG5ldGRldl9nZXRfdHhfcXVldWUoZGV2LCAwKTsKIAlzdHJ1Y3QgUWRpc2MgKnN0YXJ0LCAqcTsKIAlpbnQgYnVzeTsKIAlpbnQgbm9yZXM7CkBAIC0zMTQsOCArMzE4LDggQEAKIAkJCQkJX19uZXRpZl90eF91bmxvY2soc2xhdmVfdHhxKTsKIAkJCQkJbWFzdGVyLT5zbGF2ZXMgPSBORVhUX1NMQVZFKHEpOwogCQkJCQluZXRpZl93YWtlX3F1ZXVlKGRldik7Ci0JCQkJCXR4cS0+dHhfcGFja2V0cysrOwotCQkJCQl0eHEtPnR4X2J5dGVzICs9IGxlbmd0aDsKKwkJCQkJbWFzdGVyLT50eF9wYWNrZXRzKys7CisJCQkJCW1hc3Rlci0+dHhfYnl0ZXMgKz0gbGVuZ3RoOwogCQkJCQlyZXR1cm4gTkVUREVWX1RYX09LOwogCQkJCX0KIAkJCQlfX25ldGlmX3R4X3VubG9jayhzbGF2ZV90eHEpOwpAQCAtMzQyLDEwICszNDYsMTAgQEAKIAkJbmV0aWZfc3RvcF9xdWV1ZShkZXYpOwogCQlyZXR1cm4gTkVUREVWX1RYX0JVU1k7CiAJfQotCWRldi0+c3RhdHMudHhfZXJyb3JzKys7CisJbWFzdGVyLT50eF9lcnJvcnMrKzsKIAogZHJvcDoKLQl0eHEtPnR4X2Ryb3BwZWQrKzsKKwltYXN0ZXItPnR4X2Ryb3BwZWQrKzsKIAlkZXZfa2ZyZWVfc2tiKHNrYik7CiAJcmV0dXJuIE5FVERFVl9UWF9PSzsKIH0KQEAgLTM5OCw2ICs0MDIsMTggQEAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIHN0cnVjdCBydG5sX2xpbmtfc3RhdHM2NCAqdGVxbF9tYXN0ZXJfc3RhdHM2NChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LAorCQkJCQkJICAgICBzdHJ1Y3QgcnRubF9saW5rX3N0YXRzNjQgKnN0YXRzKQoreworCXN0cnVjdCB0ZXFsX21hc3RlciAqbSA9IG5ldGRldl9wcml2KGRldik7CisKKwlzdGF0cy0+dHhfcGFja2V0cwk9IG0tPnR4X3BhY2tldHM7CisJc3RhdHMtPnR4X2J5dGVzCQk9IG0tPnR4X2J5dGVzOworCXN0YXRzLT50eF9lcnJvcnMJPSBtLT50eF9lcnJvcnM7CisJc3RhdHMtPnR4X2Ryb3BwZWQJPSBtLT50eF9kcm9wcGVkOworCXJldHVybiBzdGF0czsKK30KKwogc3RhdGljIGludCB0ZXFsX21hc3Rlcl9tdHUoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgaW50IG5ld19tdHUpCiB7CiAJc3RydWN0IHRlcWxfbWFzdGVyICptID0gbmV0ZGV2X3ByaXYoZGV2KTsKQEAgLTQyMiw2ICs0MzgsNyBAQAogCS5uZG9fb3Blbgk9IHRlcWxfbWFzdGVyX29wZW4sCiAJLm5kb19zdG9wCT0gdGVxbF9tYXN0ZXJfY2xvc2UsCiAJLm5kb19zdGFydF94bWl0CT0gdGVxbF9tYXN0ZXJfeG1pdCwKKwkubmRvX2dldF9zdGF0czY0ID0gdGVxbF9tYXN0ZXJfc3RhdHM2NCwKIAkubmRvX2NoYW5nZV9tdHUJPSB0ZXFsX21hc3Rlcl9tdHUsCiB9OwogCmRpZmYgLS1naXQgYS9uZXQvc2N0cC9zb2NrZXQuYyBiL25ldC9zY3RwL3NvY2tldC5jCmluZGV4IGEwOWIwZGQuLjhlMDI1NTAgMTAwNjQ0Ci0tLSBhL25ldC9zY3RwL3NvY2tldC5jCisrKyBiL25ldC9zY3RwL3NvY2tldC5jCkBAIC0zNDI4LDcgKzM0MjgsNyBAQAogCQlyZXR2YWwgPSBzY3RwX3NldHNvY2tvcHRfcGVlcl9hZGRyX3BhcmFtcyhzaywgb3B0dmFsLCBvcHRsZW4pOwogCQlicmVhazsKIAotCWNhc2UgU0NUUF9ERUxBWUVEX0FDSzoKKwljYXNlIFNDVFBfREVMQVlFRF9TQUNLOgogCQlyZXR2YWwgPSBzY3RwX3NldHNvY2tvcHRfZGVsYXllZF9hY2soc2ssIG9wdHZhbCwgb3B0bGVuKTsKIAkJYnJlYWs7CiAJY2FzZSBTQ1RQX1BBUlRJQUxfREVMSVZFUllfUE9JTlQ6CkBAIC01MzMzLDcgKzUzMzMsNyBAQAogCQlyZXR2YWwgPSBzY3RwX2dldHNvY2tvcHRfcGVlcl9hZGRyX3BhcmFtcyhzaywgbGVuLCBvcHR2YWwsCiAJCQkJCQkJICBvcHRsZW4pOwogCQlicmVhazsKLQljYXNlIFNDVFBfREVMQVlFRF9BQ0s6CisJY2FzZSBTQ1RQX0RFTEFZRURfU0FDSzoKIAkJcmV0dmFsID0gc2N0cF9nZXRzb2Nrb3B0X2RlbGF5ZWRfYWNrKHNrLCBsZW4sIG9wdHZhbCwKIAkJCQkJCQkgIG9wdGxlbik7CiAJCWJyZWFrOwpkaWZmIC0tZ2l0IGEvbmV0L3N1bnJwYy9hdXRoX2dzcy9nc3Nfa3JiNV9jcnlwdG8uYyBiL25ldC9zdW5ycGMvYXV0aF9nc3MvZ3NzX2tyYjVfY3J5cHRvLmMKaW5kZXggNzVlZTk5My4uOTU3NmYzNSAxMDA2NDQKLS0tIGEvbmV0L3N1bnJwYy9hdXRoX2dzcy9nc3Nfa3JiNV9jcnlwdG8uYworKysgYi9uZXQvc3VucnBjL2F1dGhfZ3NzL2dzc19rcmI1X2NyeXB0by5jCkBAIC0xMzcsNyArMTM3LDcgQEAKIAkJbXNfdXNhZ2UgPSAxMzsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKLQkJcmV0dXJuIEVJTlZBTDs7CisJCXJldHVybiAtRUlOVkFMOwogCX0KIAlzYWx0WzBdID0gKG1zX3VzYWdlID4+IDApICYgMHhmZjsKIAlzYWx0WzFdID0gKG1zX3VzYWdlID4+IDgpICYgMHhmZjsKZGlmZiAtLWdpdCBhL25ldC9zdW5ycGMvYXV0aF9nc3Mvc3ZjYXV0aF9nc3MuYyBiL25ldC9zdW5ycGMvYXV0aF9nc3Mvc3ZjYXV0aF9nc3MuYwppbmRleCBkZWMyYTZmLi5iY2RhZTc4IDEwMDY0NAotLS0gYS9uZXQvc3VucnBjL2F1dGhfZ3NzL3N2Y2F1dGhfZ3NzLmMKKysrIGIvbmV0L3N1bnJwYy9hdXRoX2dzcy9zdmNhdXRoX2dzcy5jCkBAIC02Nyw3ICs2Nyw2IEBACiAKICNkZWZpbmUJUlNJX0hBU0hCSVRTCTYKICNkZWZpbmUJUlNJX0hBU0hNQVgJKDE8PFJTSV9IQVNIQklUUykKLSNkZWZpbmUJUlNJX0hBU0hNQVNLCShSU0lfSEFTSE1BWC0xKQogCiBzdHJ1Y3QgcnNpIHsKIAlzdHJ1Y3QgY2FjaGVfaGVhZAloOwpAQCAtMzE5LDcgKzMxOCw2IEBACiAKICNkZWZpbmUJUlNDX0hBU0hCSVRTCTEwCiAjZGVmaW5lCVJTQ19IQVNITUFYCSgxPDxSU0NfSEFTSEJJVFMpCi0jZGVmaW5lCVJTQ19IQVNITUFTSwkoUlNDX0hBU0hNQVgtMSkKIAogI2RlZmluZSBHU1NfU0VRX1dJTgkxMjgKIApkaWZmIC0tZ2l0IGEvbmV0L3N1bnJwYy9jYWNoZS5jIGIvbmV0L3N1bnJwYy9jYWNoZS5jCmluZGV4IGU0MzNlNzUuLjcyYWQ4MzYgMTAwNjQ0Ci0tLSBhL25ldC9zdW5ycGMvY2FjaGUuYworKysgYi9uZXQvc3VucnBjL2NhY2hlLmMKQEAgLTM3LDcgKzM3LDcgQEAKIAogI2RlZmluZQkgUlBDREJHX0ZBQ0lMSVRZIFJQQ0RCR19DQUNIRQogCi1zdGF0aWMgdm9pZCBjYWNoZV9kZWZlcl9yZXEoc3RydWN0IGNhY2hlX3JlcSAqcmVxLCBzdHJ1Y3QgY2FjaGVfaGVhZCAqaXRlbSk7CitzdGF0aWMgYm9vbCBjYWNoZV9kZWZlcl9yZXEoc3RydWN0IGNhY2hlX3JlcSAqcmVxLCBzdHJ1Y3QgY2FjaGVfaGVhZCAqaXRlbSk7CiBzdGF0aWMgdm9pZCBjYWNoZV9yZXZpc2l0X3JlcXVlc3Qoc3RydWN0IGNhY2hlX2hlYWQgKml0ZW0pOwogCiBzdGF0aWMgdm9pZCBjYWNoZV9pbml0KHN0cnVjdCBjYWNoZV9oZWFkICpoKQpAQCAtMTI4LDYgKzEyOCw3IEBACiB7CiAJaGVhZC0+ZXhwaXJ5X3RpbWUgPSBleHBpcnk7CiAJaGVhZC0+bGFzdF9yZWZyZXNoID0gc2Vjb25kc19zaW5jZV9ib290KCk7CisJc21wX3dtYigpOyAvKiBwYWlyZWQgd2l0aCBzbXBfcm1iKCkgaW4gY2FjaGVfaXNfdmFsaWQoKSAqLwogCXNldF9iaXQoQ0FDSEVfVkFMSUQsICZoZWFkLT5mbGFncyk7CiB9CiAKQEAgLTIwOCwxMSArMjA5LDM2IEBACiAJCS8qIGVudHJ5IGlzIHZhbGlkICovCiAJCWlmICh0ZXN0X2JpdChDQUNIRV9ORUdBVElWRSwgJmgtPmZsYWdzKSkKIAkJCXJldHVybiAtRU5PRU5UOwotCQllbHNlCisJCWVsc2UgeworCQkJLyoKKwkJCSAqIEluIGNvbWJpbmF0aW9uIHdpdGggd3JpdGUgYmFycmllciBpbgorCQkJICogc3VucnBjX2NhY2hlX3VwZGF0ZSwgZW5zdXJlcyB0aGF0IGFueW9uZQorCQkJICogdXNpbmcgdGhlIGNhY2hlIGVudHJ5IGFmdGVyIHRoaXMgc2VlcyB0aGUKKwkJCSAqIHVwZGF0ZWQgY29udGVudHM6CisJCQkgKi8KKwkJCXNtcF9ybWIoKTsKIAkJCXJldHVybiAwOworCQl9CiAJfQogfQogCitzdGF0aWMgaW50IHRyeV90b19uZWdhdGVfZW50cnkoc3RydWN0IGNhY2hlX2RldGFpbCAqZGV0YWlsLCBzdHJ1Y3QgY2FjaGVfaGVhZCAqaCkKK3sKKwlpbnQgcnY7CisKKwl3cml0ZV9sb2NrKCZkZXRhaWwtPmhhc2hfbG9jayk7CisJcnYgPSBjYWNoZV9pc192YWxpZChkZXRhaWwsIGgpOworCWlmIChydiAhPSAtRUFHQUlOKSB7CisJCXdyaXRlX3VubG9jaygmZGV0YWlsLT5oYXNoX2xvY2spOworCQlyZXR1cm4gcnY7CisJfQorCXNldF9iaXQoQ0FDSEVfTkVHQVRJVkUsICZoLT5mbGFncyk7CisJY2FjaGVfZnJlc2hfbG9ja2VkKGgsIHNlY29uZHNfc2luY2VfYm9vdCgpK0NBQ0hFX05FV19FWFBJUlkpOworCXdyaXRlX3VubG9jaygmZGV0YWlsLT5oYXNoX2xvY2spOworCWNhY2hlX2ZyZXNoX3VubG9ja2VkKGgsIGRldGFpbCk7CisJcmV0dXJuIC1FTk9FTlQ7Cit9CisKIC8qCiAgKiBUaGlzIGlzIHRoZSBnZW5lcmljIGNhY2hlIG1hbmFnZW1lbnQgcm91dGluZSBmb3IgYWxsCiAgKiB0aGUgYXV0aGVudGljYXRpb24gY2FjaGVzLgpAQCAtMjUxLDE0ICsyNzcsOCBAQAogCQkJY2FzZSAtRUlOVkFMOgogCQkJCWNsZWFyX2JpdChDQUNIRV9QRU5ESU5HLCAmaC0+ZmxhZ3MpOwogCQkJCWNhY2hlX3JldmlzaXRfcmVxdWVzdChoKTsKLQkJCQlpZiAocnYgPT0gLUVBR0FJTikgewotCQkJCQlzZXRfYml0KENBQ0hFX05FR0FUSVZFLCAmaC0+ZmxhZ3MpOwotCQkJCQljYWNoZV9mcmVzaF9sb2NrZWQoaCwgc2Vjb25kc19zaW5jZV9ib290KCkrQ0FDSEVfTkVXX0VYUElSWSk7Ci0JCQkJCWNhY2hlX2ZyZXNoX3VubG9ja2VkKGgsIGRldGFpbCk7Ci0JCQkJCXJ2ID0gLUVOT0VOVDsKLQkJCQl9CisJCQkJcnYgPSB0cnlfdG9fbmVnYXRlX2VudHJ5KGRldGFpbCwgaCk7CiAJCQkJYnJlYWs7Ci0KIAkJCWNhc2UgLUVBR0FJTjoKIAkJCQljbGVhcl9iaXQoQ0FDSEVfUEVORElORywgJmgtPmZsYWdzKTsKIAkJCQljYWNoZV9yZXZpc2l0X3JlcXVlc3QoaCk7CkBAIC0yNjgsOSArMjg4LDExIEBACiAJfQogCiAJaWYgKHJ2ID09IC1FQUdBSU4pIHsKLQkJY2FjaGVfZGVmZXJfcmVxKHJxc3RwLCBoKTsKLQkJaWYgKCF0ZXN0X2JpdChDQUNIRV9QRU5ESU5HLCAmaC0+ZmxhZ3MpKSB7Ci0JCQkvKiBSZXF1ZXN0IGlzIG5vdCBkZWZlcnJlZCAqLworCQlpZiAoIWNhY2hlX2RlZmVyX3JlcShycXN0cCwgaCkpIHsKKwkJCS8qCisJCQkgKiBSZXF1ZXN0IHdhcyBub3QgZGVmZXJyZWQ7IGhhbmRsZSBpdCBhcyBiZXN0CisJCQkgKiB3ZSBjYW4gb3Vyc2VsdmVzOgorCQkJICovCiAJCQlydiA9IGNhY2hlX2lzX3ZhbGlkKGRldGFpbCwgaCk7CiAJCQlpZiAocnYgPT0gLUVBR0FJTikKIAkJCQlydiA9IC1FVElNRURPVVQ7CkBAIC02MTgsMTggKzY0MCwxOSBAQAogCQlkaXNjYXJkLT5yZXZpc2l0KGRpc2NhcmQsIDEpOwogfQogCi1zdGF0aWMgdm9pZCBjYWNoZV9kZWZlcl9yZXEoc3RydWN0IGNhY2hlX3JlcSAqcmVxLCBzdHJ1Y3QgY2FjaGVfaGVhZCAqaXRlbSkKKy8qIFJldHVybiB0cnVlIGlmIGFuZCBvbmx5IGlmIGEgZGVmZXJyZWQgcmVxdWVzdCBpcyBxdWV1ZWQuICovCitzdGF0aWMgYm9vbCBjYWNoZV9kZWZlcl9yZXEoc3RydWN0IGNhY2hlX3JlcSAqcmVxLCBzdHJ1Y3QgY2FjaGVfaGVhZCAqaXRlbSkKIHsKIAlzdHJ1Y3QgY2FjaGVfZGVmZXJyZWRfcmVxICpkcmVxOwogCiAJaWYgKHJlcS0+dGhyZWFkX3dhaXQpIHsKIAkJY2FjaGVfd2FpdF9yZXEocmVxLCBpdGVtKTsKIAkJaWYgKCF0ZXN0X2JpdChDQUNIRV9QRU5ESU5HLCAmaXRlbS0+ZmxhZ3MpKQotCQkJcmV0dXJuOworCQkJcmV0dXJuIGZhbHNlOwogCX0KIAlkcmVxID0gcmVxLT5kZWZlcihyZXEpOwogCWlmIChkcmVxID09IE5VTEwpCi0JCXJldHVybjsKKwkJcmV0dXJuIGZhbHNlOwogCXNldHVwX2RlZmVycmFsKGRyZXEsIGl0ZW0sIDEpOwogCWlmICghdGVzdF9iaXQoQ0FDSEVfUEVORElORywgJml0ZW0tPmZsYWdzKSkKIAkJLyogQml0IGNvdWxkIGhhdmUgYmVlbiBjbGVhcmVkIGJlZm9yZSB3ZSBtYW5hZ2VkIHRvCkBAIC02MzgsNiArNjYxLDcgQEAKIAkJY2FjaGVfcmV2aXNpdF9yZXF1ZXN0KGl0ZW0pOwogCiAJY2FjaGVfbGltaXRfZGVmZXJzKCk7CisJcmV0dXJuIHRydWU7CiB9CiAKIHN0YXRpYyB2b2lkIGNhY2hlX3JldmlzaXRfcmVxdWVzdChzdHJ1Y3QgY2FjaGVfaGVhZCAqaXRlbSkKZGlmZiAtLWdpdCBhL25ldC9zdW5ycGMvc3ZjLmMgYi9uZXQvc3VucnBjL3N2Yy5jCmluZGV4IDBlNjU5YzYuLjA4ZTA1YTggMTAwNjQ0Ci0tLSBhL25ldC9zdW5ycGMvc3ZjLmMKKysrIGIvbmV0L3N1bnJwYy9zdmMuYwpAQCAtMTAwMSw2ICsxMDAxLDcgQEAKIAlycXN0cC0+cnFfc3BsaWNlX29rID0gMTsKIAkvKiBXaWxsIGJlIHR1cm5lZCBvZmYgb25seSB3aGVuIE5GU3Y0IFNlc3Npb25zIGFyZSB1c2VkICovCiAJcnFzdHAtPnJxX3VzZWRlZmVycmFsID0gMTsKKwlycXN0cC0+cnFfZHJvcG1lID0gZmFsc2U7CiAKIAkvKiBTZXR1cCByZXBseSBoZWFkZXIgKi8KIAlycXN0cC0+cnFfeHBydC0+eHB0X29wcy0+eHBvX3ByZXBfcmVwbHlfaGRyKHJxc3RwKTsKQEAgLTExMDIsNyArMTEwMyw3IEBACiAJCSpzdGF0cCA9IHByb2NwLT5wY19mdW5jKHJxc3RwLCBycXN0cC0+cnFfYXJncCwgcnFzdHAtPnJxX3Jlc3ApOwogCiAJCS8qIEVuY29kZSByZXBseSAqLwotCQlpZiAoKnN0YXRwID09IHJwY19kcm9wX3JlcGx5KSB7CisJCWlmIChycXN0cC0+cnFfZHJvcG1lKSB7CiAJCQlpZiAocHJvY3AtPnBjX3JlbGVhc2UpCiAJCQkJcHJvY3AtPnBjX3JlbGVhc2UocnFzdHAsIE5VTEwsIHJxc3RwLT5ycV9yZXNwKTsKIAkJCWdvdG8gZHJvcGl0OwpkaWZmIC0tZ2l0IGEvbmV0L3N1bnJwYy9zdmNfeHBydC5jIGIvbmV0L3N1bnJwYy9zdmNfeHBydC5jCmluZGV4IDNmMmM1NTUuLmFiODZiNzkgMTAwNjQ0Ci0tLSBhL25ldC9zdW5ycGMvc3ZjX3hwcnQuYworKysgYi9uZXQvc3VucnBjL3N2Y194cHJ0LmMKQEAgLTEzLDYgKzEzLDcgQEAKICNpbmNsdWRlIDxsaW51eC9zdW5ycGMvc3RhdHMuaD4KICNpbmNsdWRlIDxsaW51eC9zdW5ycGMvc3ZjX3hwcnQuaD4KICNpbmNsdWRlIDxsaW51eC9zdW5ycGMvc3Zjc29jay5oPgorI2luY2x1ZGUgPGxpbnV4L3N1bnJwYy94cHJ0Lmg+CiAKICNkZWZpbmUgUlBDREJHX0ZBQ0lMSVRZCVJQQ0RCR19TVkNYUFJUCiAKQEAgLTEyOCw2ICsxMjksOSBAQAogCWlmICh0ZXN0X2JpdChYUFRfQ0FDSEVfQVVUSCwgJnhwcnQtPnhwdF9mbGFncykpCiAJCXN2Y2F1dGhfdW5peF9pbmZvX3JlbGVhc2UoeHBydCk7CiAJcHV0X25ldCh4cHJ0LT54cHRfbmV0KTsKKwkvKiBTZWUgY29tbWVudCBvbiBjb3JyZXNwb25kaW5nIGdldCBpbiB4c19zZXR1cF9iY190Y3AoKTogKi8KKwlpZiAoeHBydC0+eHB0X2JjX3hwcnQpCisJCXhwcnRfcHV0KHhwcnQtPnhwdF9iY194cHJ0KTsKIAl4cHJ0LT54cHRfb3BzLT54cG9fZnJlZSh4cHJ0KTsKIAltb2R1bGVfcHV0KG93bmVyKTsKIH0KQEAgLTMwMyw2ICszMDcsMTUgQEAKIAlsaXN0X2RlbCgmcnFzdHAtPnJxX2xpc3QpOwogfQogCitzdGF0aWMgYm9vbCBzdmNfeHBydF9oYXNfc29tZXRoaW5nX3RvX2RvKHN0cnVjdCBzdmNfeHBydCAqeHBydCkKK3sKKwlpZiAoeHBydC0+eHB0X2ZsYWdzICYgKCgxPDxYUFRfQ09OTil8KDE8PFhQVF9DTE9TRSkpKQorCQlyZXR1cm4gdHJ1ZTsKKwlpZiAoeHBydC0+eHB0X2ZsYWdzICYgKCgxPDxYUFRfREFUQSl8KDE8PFhQVF9ERUZFUlJFRCkpKQorCQlyZXR1cm4geHBydC0+eHB0X29wcy0+eHBvX2hhc193c3BhY2UoeHBydCk7CisJcmV0dXJuIGZhbHNlOworfQorCiAvKgogICogUXVldWUgdXAgYSB0cmFuc3BvcnQgd2l0aCBkYXRhIHBlbmRpbmcuIElmIHRoZXJlIGFyZSBpZGxlIG5mc2QKICAqIHByb2Nlc3Nlcywgd2FrZSAnZW0gdXAuCkBAIC0zMTUsOCArMzI4LDcgQEAKIAlzdHJ1Y3Qgc3ZjX3Jxc3QJKnJxc3RwOwogCWludCBjcHU7CiAKLQlpZiAoISh4cHJ0LT54cHRfZmxhZ3MgJgotCSAgICAgICgoMTw8WFBUX0NPTk4pfCgxPDxYUFRfREFUQSl8KDE8PFhQVF9DTE9TRSl8KDE8PFhQVF9ERUZFUlJFRCkpKSkKKwlpZiAoIXN2Y194cHJ0X2hhc19zb21ldGhpbmdfdG9fZG8oeHBydCkpCiAJCXJldHVybjsKIAogCWNwdSA9IGdldF9jcHUoKTsKQEAgLTM0MywyOCArMzU1LDcgQEAKIAkJZHByaW50aygic3ZjOiB0cmFuc3BvcnQgJXAgYnVzeSwgbm90IGVucXVldWVkXG4iLCB4cHJ0KTsKIAkJZ290byBvdXRfdW5sb2NrOwogCX0KLQlCVUdfT04oeHBydC0+eHB0X3Bvb2wgIT0gTlVMTCk7Ci0JeHBydC0+eHB0X3Bvb2wgPSBwb29sOwogCi0JLyogSGFuZGxlIHBlbmRpbmcgY29ubmVjdGlvbiAqLwotCWlmICh0ZXN0X2JpdChYUFRfQ09OTiwgJnhwcnQtPnhwdF9mbGFncykpCi0JCWdvdG8gcHJvY2VzczsKLQotCS8qIEhhbmRsZSBjbG9zZSBpbi1wcm9ncmVzcyAqLwotCWlmICh0ZXN0X2JpdChYUFRfQ0xPU0UsICZ4cHJ0LT54cHRfZmxhZ3MpKQotCQlnb3RvIHByb2Nlc3M7Ci0KLQkvKiBDaGVjayBpZiB3ZSBoYXZlIHNwYWNlIHRvIHJlcGx5IHRvIGEgcmVxdWVzdCAqLwotCWlmICgheHBydC0+eHB0X29wcy0+eHBvX2hhc193c3BhY2UoeHBydCkpIHsKLQkJLyogRG9uJ3QgZW5xdWV1ZSB3aGlsZSBub3QgZW5vdWdoIHNwYWNlIGZvciByZXBseSAqLwotCQlkcHJpbnRrKCJzdmM6IG5vIHdyaXRlIHNwYWNlLCB0cmFuc3BvcnQgJXAgIG5vdCBlbnF1ZXVlZFxuIiwKLQkJCXhwcnQpOwotCQl4cHJ0LT54cHRfcG9vbCA9IE5VTEw7Ci0JCWNsZWFyX2JpdChYUFRfQlVTWSwgJnhwcnQtPnhwdF9mbGFncyk7Ci0JCWdvdG8gb3V0X3VubG9jazsKLQl9Ci0KLSBwcm9jZXNzOgogCWlmICghbGlzdF9lbXB0eSgmcG9vbC0+c3BfdGhyZWFkcykpIHsKIAkJcnFzdHAgPSBsaXN0X2VudHJ5KHBvb2wtPnNwX3RocmVhZHMubmV4dCwKIAkJCQkgICBzdHJ1Y3Qgc3ZjX3Jxc3QsCkBAIC0zODEsMTMgKzM3MiwxMSBAQAogCQlycXN0cC0+cnFfcmVzZXJ2ZWQgPSBzZXJ2LT5zdl9tYXhfbWVzZzsKIAkJYXRvbWljX2FkZChycXN0cC0+cnFfcmVzZXJ2ZWQsICZ4cHJ0LT54cHRfcmVzZXJ2ZWQpOwogCQlwb29sLT5zcF9zdGF0cy50aHJlYWRzX3dva2VuKys7Ci0JCUJVR19PTih4cHJ0LT54cHRfcG9vbCAhPSBwb29sKTsKIAkJd2FrZV91cCgmcnFzdHAtPnJxX3dhaXQpOwogCX0gZWxzZSB7CiAJCWRwcmludGsoInN2YzogdHJhbnNwb3J0ICVwIHB1dCBpbnRvIHF1ZXVlXG4iLCB4cHJ0KTsKIAkJbGlzdF9hZGRfdGFpbCgmeHBydC0+eHB0X3JlYWR5LCAmcG9vbC0+c3Bfc29ja2V0cyk7CiAJCXBvb2wtPnNwX3N0YXRzLnNvY2tldHNfcXVldWVkKys7Ci0JCUJVR19PTih4cHJ0LT54cHRfcG9vbCAhPSBwb29sKTsKIAl9CiAKIG91dF91bmxvY2s6CkBAIC00MjYsNyArNDE1LDYgQEAKIHZvaWQgc3ZjX3hwcnRfcmVjZWl2ZWQoc3RydWN0IHN2Y194cHJ0ICp4cHJ0KQogewogCUJVR19PTighdGVzdF9iaXQoWFBUX0JVU1ksICZ4cHJ0LT54cHRfZmxhZ3MpKTsKLQl4cHJ0LT54cHRfcG9vbCA9IE5VTEw7CiAJLyogQXMgc29vbiBhcyB3ZSBjbGVhciBidXN5LCB0aGUgeHBydCBjb3VsZCBiZSBjbG9zZWQgYW5kCiAJICogJ3B1dCcsIHNvIHdlIG5lZWQgYSByZWZlcmVuY2UgdG8gY2FsbCBzdmNfeHBydF9lbnF1ZXVlIHdpdGg6CiAJICovCkBAIC03MjIsNyArNzEwLDEwIEBACiAJaWYgKHRlc3RfYml0KFhQVF9DTE9TRSwgJnhwcnQtPnhwdF9mbGFncykpIHsKIAkJZHByaW50aygic3ZjX3JlY3Y6IGZvdW5kIFhQVF9DTE9TRVxuIik7CiAJCXN2Y19kZWxldGVfeHBydCh4cHJ0KTsKLQl9IGVsc2UgaWYgKHRlc3RfYml0KFhQVF9MSVNURU5FUiwgJnhwcnQtPnhwdF9mbGFncykpIHsKKwkJLyogTGVhdmUgWFBUX0JVU1kgc2V0IG9uIHRoZSBkZWFkIHhwcnQ6ICovCisJCWdvdG8gb3V0OworCX0KKwlpZiAodGVzdF9iaXQoWFBUX0xJU1RFTkVSLCAmeHBydC0+eHB0X2ZsYWdzKSkgewogCQlzdHJ1Y3Qgc3ZjX3hwcnQgKm5ld3hwdDsKIAkJbmV3eHB0ID0geHBydC0+eHB0X29wcy0+eHBvX2FjY2VwdCh4cHJ0KTsKIAkJaWYgKG5ld3hwdCkgewpAQCAtNzQ3LDI4ICs3MzgsMjMgQEAKIAkJCXNwaW5fdW5sb2NrX2JoKCZzZXJ2LT5zdl9sb2NrKTsKIAkJCXN2Y194cHJ0X3JlY2VpdmVkKG5ld3hwdCk7CiAJCX0KLQkJc3ZjX3hwcnRfcmVjZWl2ZWQoeHBydCk7Ci0JfSBlbHNlIHsKKwl9IGVsc2UgaWYgKHhwcnQtPnhwdF9vcHMtPnhwb19oYXNfd3NwYWNlKHhwcnQpKSB7CiAJCWRwcmludGsoInN2Yzogc2VydmVyICVwLCBwb29sICV1LCB0cmFuc3BvcnQgJXAsIGludXNlPSVkXG4iLAogCQkJcnFzdHAsIHBvb2wtPnNwX2lkLCB4cHJ0LAogCQkJYXRvbWljX3JlYWQoJnhwcnQtPnhwdF9yZWYucmVmY291bnQpKTsKIAkJcnFzdHAtPnJxX2RlZmVycmVkID0gc3ZjX2RlZmVycmVkX2RlcXVldWUoeHBydCk7Ci0JCWlmIChycXN0cC0+cnFfZGVmZXJyZWQpIHsKLQkJCXN2Y194cHJ0X3JlY2VpdmVkKHhwcnQpOworCQlpZiAocnFzdHAtPnJxX2RlZmVycmVkKQogCQkJbGVuID0gc3ZjX2RlZmVycmVkX3JlY3YocnFzdHApOwotCQl9IGVsc2UgeworCQllbHNlCiAJCQlsZW4gPSB4cHJ0LT54cHRfb3BzLT54cG9fcmVjdmZyb20ocnFzdHApOwotCQkJc3ZjX3hwcnRfcmVjZWl2ZWQoeHBydCk7Ci0JCX0KIAkJZHByaW50aygic3ZjOiBnb3QgbGVuPSVkXG4iLCBsZW4pOwogCX0KKwlzdmNfeHBydF9yZWNlaXZlZCh4cHJ0KTsKIAogCS8qIE5vIGRhdGEsIGluY29tcGxldGUgKFRDUCkgcmVhZCwgb3IgYWNjZXB0KCkgKi8KLQlpZiAobGVuID09IDAgfHwgbGVuID09IC1FQUdBSU4pIHsKLQkJcnFzdHAtPnJxX3Jlcy5sZW4gPSAwOwotCQlzdmNfeHBydF9yZWxlYXNlKHJxc3RwKTsKLQkJcmV0dXJuIC1FQUdBSU47Ci0JfQorCWlmIChsZW4gPT0gMCB8fCBsZW4gPT0gLUVBR0FJTikKKwkJZ290byBvdXQ7CisKIAljbGVhcl9iaXQoWFBUX09MRCwgJnhwcnQtPnhwdF9mbGFncyk7CiAKIAlycXN0cC0+cnFfc2VjdXJlID0gc3ZjX3BvcnRfaXNfcHJpdmlsZWdlZChzdmNfYWRkcihycXN0cCkpOwpAQCAtNzc3LDYgKzc2MywxMCBAQAogCWlmIChzZXJ2LT5zdl9zdGF0cykKIAkJc2Vydi0+c3Zfc3RhdHMtPm5ldGNudCsrOwogCXJldHVybiBsZW47CitvdXQ6CisJcnFzdHAtPnJxX3Jlcy5sZW4gPSAwOworCXN2Y194cHJ0X3JlbGVhc2UocnFzdHApOworCXJldHVybiAtRUFHQUlOOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoc3ZjX3JlY3YpOwogCkBAIC05MzUsNyArOTI1LDEyIEBACiAJaWYgKHRlc3RfYW5kX3NldF9iaXQoWFBUX0JVU1ksICZ4cHJ0LT54cHRfZmxhZ3MpKQogCQkvKiBzb21lb25lIGVsc2Ugd2lsbCBoYXZlIHRvIGVmZmVjdCB0aGUgY2xvc2UgKi8KIAkJcmV0dXJuOwotCisJLyoKKwkgKiBXZSBleHBlY3Qgc3ZjX2Nsb3NlX3hwcnQoKSB0byB3b3JrIGV2ZW4gd2hlbiBubyB0aHJlYWRzIGFyZQorCSAqIHJ1bm5pbmcgKGUuZy4sIHdoaWxlIGNvbmZpZ3VyaW5nIHRoZSBzZXJ2ZXIgYmVmb3JlIHN0YXJ0aW5nCisJICogYW55IHRocmVhZHMpLCBzbyBpZiB0aGUgdHJhbnNwb3J0IGlzbid0IGJ1c3ksIHdlIGRlbGV0ZQorCSAqIGl0IG91cnNlbGY6CisJICovCiAJc3ZjX2RlbGV0ZV94cHJ0KHhwcnQpOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoc3ZjX2Nsb3NlX3hwcnQpOwpAQCAtOTQ1LDE2ICs5NDAsMTYgQEAKIAlzdHJ1Y3Qgc3ZjX3hwcnQgKnhwcnQ7CiAJc3RydWN0IHN2Y194cHJ0ICp0bXA7CiAKKwkvKgorCSAqIFRoZSBzZXJ2ZXIgaXMgc2h1dHRpbmcgZG93biwgYW5kIG5vIG1vcmUgdGhyZWFkcyBhcmUgcnVubmluZy4KKwkgKiBzdmNfeHBydF9lbnF1ZXVlKCkgbWlnaHQgc3RpbGwgYmUgcnVubmluZywgYnV0IGF0IHdvcnN0IGl0CisJICogd2lsbCByZS1hZGQgdGhlIHhwcnQgdG8gc3Bfc29ja2V0cywgd2hpY2ggd2lsbCBzb29uIGdldAorCSAqIGZyZWVkLiAgU28gd2UgZG9uJ3QgYm90aGVyIHdpdGggYW55IG1vcmUgbG9ja2luZywgYW5kIGRvbid0CisJICogbGVhdmUgdGhlIGNsb3NlIHRvIHRoZSAobm9uZXhpc3RlbnQpIHNlcnZlciB0aHJlYWRzOgorCSAqLwogCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSh4cHJ0LCB0bXAsIHhwcnRfbGlzdCwgeHB0X2xpc3QpIHsKIAkJc2V0X2JpdChYUFRfQ0xPU0UsICZ4cHJ0LT54cHRfZmxhZ3MpOwotCQlpZiAodGVzdF9iaXQoWFBUX0JVU1ksICZ4cHJ0LT54cHRfZmxhZ3MpKSB7Ci0JCQkvKiBXYWl0aW5nIHRvIGJlIHByb2Nlc3NlZCwgYnV0IG5vIHRocmVhZHMgbGVmdCwKLQkJCSAqIFNvIGp1c3QgcmVtb3ZlIGl0IGZyb20gdGhlIHdhaXRpbmcgbGlzdAotCQkJICovCi0JCQlsaXN0X2RlbF9pbml0KCZ4cHJ0LT54cHRfcmVhZHkpOwotCQkJY2xlYXJfYml0KFhQVF9CVVNZLCAmeHBydC0+eHB0X2ZsYWdzKTsKLQkJfQotCQlzdmNfY2xvc2VfeHBydCh4cHJ0KTsKKwkJc3ZjX2RlbGV0ZV94cHJ0KHhwcnQpOwogCX0KIH0KIApAQCAtMTAyOCw2ICsxMDIzLDcgQEAKIAl9CiAJc3ZjX3hwcnRfZ2V0KHJxc3RwLT5ycV94cHJ0KTsKIAlkci0+eHBydCA9IHJxc3RwLT5ycV94cHJ0OworCXJxc3RwLT5ycV9kcm9wbWUgPSB0cnVlOwogCiAJZHItPmhhbmRsZS5yZXZpc2l0ID0gc3ZjX3JldmlzaXQ7CiAJcmV0dXJuICZkci0+aGFuZGxlOwpAQCAtMTA2NSwxNCArMTA2MSwxMyBAQAogCWlmICghdGVzdF9iaXQoWFBUX0RFRkVSUkVELCAmeHBydC0+eHB0X2ZsYWdzKSkKIAkJcmV0dXJuIE5VTEw7CiAJc3Bpbl9sb2NrKCZ4cHJ0LT54cHRfbG9jayk7Ci0JY2xlYXJfYml0KFhQVF9ERUZFUlJFRCwgJnhwcnQtPnhwdF9mbGFncyk7CiAJaWYgKCFsaXN0X2VtcHR5KCZ4cHJ0LT54cHRfZGVmZXJyZWQpKSB7CiAJCWRyID0gbGlzdF9lbnRyeSh4cHJ0LT54cHRfZGVmZXJyZWQubmV4dCwKIAkJCQlzdHJ1Y3Qgc3ZjX2RlZmVycmVkX3JlcSwKIAkJCQloYW5kbGUucmVjZW50KTsKIAkJbGlzdF9kZWxfaW5pdCgmZHItPmhhbmRsZS5yZWNlbnQpOwotCQlzZXRfYml0KFhQVF9ERUZFUlJFRCwgJnhwcnQtPnhwdF9mbGFncyk7Ci0JfQorCX0gZWxzZQorCQljbGVhcl9iaXQoWFBUX0RFRkVSUkVELCAmeHBydC0+eHB0X2ZsYWdzKTsKIAlzcGluX3VubG9jaygmeHBydC0+eHB0X2xvY2spOwogCXJldHVybiBkcjsKIH0KZGlmZiAtLWdpdCBhL25ldC9zdW5ycGMvc3ZjYXV0aC5jIGIvbmV0L3N1bnJwYy9zdmNhdXRoLmMKaW5kZXggNGU5MzkzYy4uNzk2MzU2OSAxMDA2NDQKLS0tIGEvbmV0L3N1bnJwYy9zdmNhdXRoLmMKKysrIGIvbmV0L3N1bnJwYy9zdmNhdXRoLmMKQEAgLTExOCw3ICsxMTgsNiBAQAogCiAjZGVmaW5lCUROX0hBU0hCSVRTCTYKICNkZWZpbmUJRE5fSEFTSE1BWAkoMTw8RE5fSEFTSEJJVFMpCi0jZGVmaW5lCUROX0hBU0hNQVNLCShETl9IQVNITUFYLTEpCiAKIHN0YXRpYyBzdHJ1Y3QgaGxpc3RfaGVhZAlhdXRoX2RvbWFpbl90YWJsZVtETl9IQVNITUFYXTsKIHN0YXRpYyBzcGlubG9ja190CWF1dGhfZG9tYWluX2xvY2sgPQpkaWZmIC0tZ2l0IGEvbmV0L3N1bnJwYy9zdmNhdXRoX3VuaXguYyBiL25ldC9zdW5ycGMvc3ZjYXV0aF91bml4LmMKaW5kZXggNTYwNjc3ZC4uMzA5MTZiMCAxMDA2NDQKLS0tIGEvbmV0L3N1bnJwYy9zdmNhdXRoX3VuaXguYworKysgYi9uZXQvc3VucnBjL3N2Y2F1dGhfdW5peC5jCkBAIC0zMCw3ICszMCw5IEBACiAKIHN0cnVjdCB1bml4X2RvbWFpbiB7CiAJc3RydWN0IGF1dGhfZG9tYWluCWg7CisjaWZkZWYgQ09ORklHX05GU0RfREVQUkVDQVRFRAogCWludAlhZGRyX2NoYW5nZXM7CisjZW5kaWYgLyogQ09ORklHX05GU0RfREVQUkVDQVRFRCAqLwogCS8qIG90aGVyIHN0dWZmIGxhdGVyICovCiB9OwogCkBAIC02NCw3ICs2Niw5IEBACiAJCQlyZXR1cm4gTlVMTDsKIAkJfQogCQluZXctPmguZmxhdm91ciA9ICZzdmNhdXRoX3VuaXg7CisjaWZkZWYgQ09ORklHX05GU0RfREVQUkVDQVRFRAogCQluZXctPmFkZHJfY2hhbmdlcyA9IDA7CisjZW5kaWYgLyogQ09ORklHX05GU0RfREVQUkVDQVRFRCAqLwogCQlydiA9IGF1dGhfZG9tYWluX2xvb2t1cChuYW1lLCAmbmV3LT5oKTsKIAl9CiB9CkBAIC04NSwxNCArODksMTUgQEAKICAqLwogI2RlZmluZQlJUF9IQVNIQklUUwk4CiAjZGVmaW5lCUlQX0hBU0hNQVgJKDE8PElQX0hBU0hCSVRTKQotI2RlZmluZQlJUF9IQVNITUFTSwkoSVBfSEFTSE1BWC0xKQogCiBzdHJ1Y3QgaXBfbWFwIHsKIAlzdHJ1Y3QgY2FjaGVfaGVhZAloOwogCWNoYXIJCQltX2NsYXNzWzhdOyAvKiBlLmcuICJuZnNkIiAqLwogCXN0cnVjdCBpbjZfYWRkcgkJbV9hZGRyOwogCXN0cnVjdCB1bml4X2RvbWFpbgkqbV9jbGllbnQ7CisjaWZkZWYgQ09ORklHX05GU0RfREVQUkVDQVRFRAogCWludAkJCW1fYWRkX2NoYW5nZTsKKyNlbmRpZiAvKiBDT05GSUdfTkZTRF9ERVBSRUNBVEVEICovCiB9OwogCiBzdGF0aWMgdm9pZCBpcF9tYXBfcHV0KHN0cnVjdCBrcmVmICprcmVmKQpAQCAtMTQ2LDcgKzE1MSw5IEBACiAKIAlrcmVmX2dldCgmaXRlbS0+bV9jbGllbnQtPmgucmVmKTsKIAluZXctPm1fY2xpZW50ID0gaXRlbS0+bV9jbGllbnQ7CisjaWZkZWYgQ09ORklHX05GU0RfREVQUkVDQVRFRAogCW5ldy0+bV9hZGRfY2hhbmdlID0gaXRlbS0+bV9hZGRfY2hhbmdlOworI2VuZGlmIC8qIENPTkZJR19ORlNEX0RFUFJFQ0FURUQgKi8KIH0KIHN0YXRpYyBzdHJ1Y3QgY2FjaGVfaGVhZCAqaXBfbWFwX2FsbG9jKHZvaWQpCiB7CkBAIC0zMzEsNiArMzM4LDcgQEAKIAlpcC5oLmZsYWdzID0gMDsKIAlpZiAoIXVkb20pCiAJCXNldF9iaXQoQ0FDSEVfTkVHQVRJVkUsICZpcC5oLmZsYWdzKTsKKyNpZmRlZiBDT05GSUdfTkZTRF9ERVBSRUNBVEVECiAJZWxzZSB7CiAJCWlwLm1fYWRkX2NoYW5nZSA9IHVkb20tPmFkZHJfY2hhbmdlczsKIAkJLyogaWYgdGhpcyBpcyBmcm9tIHRoZSBsZWdhY3kgc2V0X2NsaWVudCBzeXN0ZW0gY2FsbCwKQEAgLTMzOSw2ICszNDcsNyBAQAogCQlpZiAoZXhwaXJ5ID09IE5FVkVSKQogCQkJaXAubV9hZGRfY2hhbmdlKys7CiAJfQorI2VuZGlmIC8qIENPTkZJR19ORlNEX0RFUFJFQ0FURUQgKi8KIAlpcC5oLmV4cGlyeV90aW1lID0gZXhwaXJ5OwogCWNoID0gc3VucnBjX2NhY2hlX3VwZGF0ZShjZCwgJmlwLmgsICZpcG0tPmgsCiAJCQkJIGhhc2hfc3RyKGlwbS0+bV9jbGFzcywgSVBfSEFTSEJJVFMpIF4KQEAgLTM1OCw2ICszNjcsNyBAQAogCXJldHVybiBfX2lwX21hcF91cGRhdGUoc24tPmlwX21hcF9jYWNoZSwgaXBtLCB1ZG9tLCBleHBpcnkpOwogfQogCisjaWZkZWYgQ09ORklHX05GU0RfREVQUkVDQVRFRAogaW50IGF1dGhfdW5peF9hZGRfYWRkcihzdHJ1Y3QgbmV0ICpuZXQsIHN0cnVjdCBpbjZfYWRkciAqYWRkciwgc3RydWN0IGF1dGhfZG9tYWluICpkb20pCiB7CiAJc3RydWN0IHVuaXhfZG9tYWluICp1ZG9tOwpAQCAtNDAyLDggKzQxMiw3IEBACiAJCXJldHVybiBOVUxMOwogCiAJaWYgKChpcG0tPm1fY2xpZW50LT5hZGRyX2NoYW5nZXMgLSBpcG0tPm1fYWRkX2NoYW5nZSkgPjApIHsKLQkJaWYgKHRlc3RfYW5kX3NldF9iaXQoQ0FDSEVfTkVHQVRJVkUsICZpcG0tPmguZmxhZ3MpID09IDApCi0JCQlhdXRoX2RvbWFpbl9wdXQoJmlwbS0+bV9jbGllbnQtPmgpOworCQlzdW5ycGNfaW52YWxpZGF0ZSgmaXBtLT5oLCBzbi0+aXBfbWFwX2NhY2hlKTsKIAkJcnYgPSBOVUxMOwogCX0gZWxzZSB7CiAJCXJ2ID0gJmlwbS0+bV9jbGllbnQtPmg7CkBAIC00MTMsNiArNDIyLDcgQEAKIAlyZXR1cm4gcnY7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChhdXRoX3VuaXhfbG9va3VwKTsKKyNlbmRpZiAvKiBDT05GSUdfTkZTRF9ERVBSRUNBVEVEICovCiAKIHZvaWQgc3ZjYXV0aF91bml4X3B1cmdlKHZvaWQpCiB7CkBAIC00OTcsNyArNTA3LDYgQEAKICAqLwogI2RlZmluZQlHSURfSEFTSEJJVFMJOAogI2RlZmluZQlHSURfSEFTSE1BWAkoMTw8R0lEX0hBU0hCSVRTKQotI2RlZmluZQlHSURfSEFTSE1BU0sJKEdJRF9IQVNITUFYIC0gMSkKIAogc3RydWN0IHVuaXhfZ2lkIHsKIAlzdHJ1Y3QgY2FjaGVfaGVhZAloOwpkaWZmIC0tZ2l0IGEvbmV0L3N1bnJwYy9zdmNzb2NrLmMgYi9uZXQvc3VucnBjL3N2Y3NvY2suYwppbmRleCBkMjY1YWE3Li5kODAyZTk0IDEwMDY0NAotLS0gYS9uZXQvc3VucnBjL3N2Y3NvY2suYworKysgYi9uZXQvc3VucnBjL3N2Y3NvY2suYwpAQCAtMzMxLDE5ICszMzEsMjEgQEAKIAkJCWxlbiA9IG9uZWxlbjsKIAkJCWJyZWFrOwogCQl9Ci0JCWlmICh0b2Nsb3NlICYmIHN0cmNtcCh0b2Nsb3NlLCBidWYgKyBsZW4pID09IDApCisJCWlmICh0b2Nsb3NlICYmIHN0cmNtcCh0b2Nsb3NlLCBidWYgKyBsZW4pID09IDApIHsKIAkJCWNsb3Nlc2sgPSBzdnNrOwotCQllbHNlCisJCQlzdmNfeHBydF9nZXQoJmNsb3Nlc2stPnNrX3hwcnQpOworCQl9IGVsc2UKIAkJCWxlbiArPSBvbmVsZW47CiAJfQogCXNwaW5fdW5sb2NrX2JoKCZzZXJ2LT5zdl9sb2NrKTsKIAotCWlmIChjbG9zZXNrKQorCWlmIChjbG9zZXNrKSB7CiAJCS8qIFNob3VsZCB1bnJlZ2lzdGVyIHdpdGggcG9ydG1hcCwgYnV0IHlvdSBjYW5ub3QKIAkJICogdW5yZWdpc3RlciBqdXN0IG9uZSBwcm90b2NvbC4uLgogCQkgKi8KIAkJc3ZjX2Nsb3NlX3hwcnQoJmNsb3Nlc2stPnNrX3hwcnQpOwotCWVsc2UgaWYgKHRvY2xvc2UpCisJCXN2Y194cHJ0X3B1dCgmY2xvc2Vzay0+c2tfeHBydCk7CisJfSBlbHNlIGlmICh0b2Nsb3NlKQogCQlyZXR1cm4gLUVOT0VOVDsKIAlyZXR1cm4gbGVuOwogfQpAQCAtOTkyLDE1ICs5OTQsMTcgQEAKIAkJdmVjWzBdID0gcnFzdHAtPnJxX2FyZy5oZWFkWzBdOwogCX0gZWxzZSB7CiAJCS8qIFJFUExZICovCi0JCWlmIChzdnNrLT5za19iY194cHJ0KQotCQkJcmVxID0geHBydF9sb29rdXBfcnFzdChzdnNrLT5za19iY194cHJ0LCB4aWQpOworCQlzdHJ1Y3QgcnBjX3hwcnQgKmJjX3hwcnQgPSBzdnNrLT5za194cHJ0LnhwdF9iY194cHJ0OworCisJCWlmIChiY194cHJ0KQorCQkJcmVxID0geHBydF9sb29rdXBfcnFzdChiY194cHJ0LCB4aWQpOwogCiAJCWlmICghcmVxKSB7CiAJCQlwcmludGsoS0VSTl9OT1RJQ0UKIAkJCQkiJXM6IEdvdCB1bnJlY29nbml6ZWQgcmVwbHk6ICIKLQkJCQkiY2FsbGRpciAweCV4IHNrX2JjX3hwcnQgJXAgeGlkICUwOHhcbiIsCisJCQkJImNhbGxkaXIgMHgleCB4cHRfYmNfeHBydCAlcCB4aWQgJTA4eFxuIiwKIAkJCQlfX2Z1bmNfXywgbnRvaGwoY2FsbGRpciksCi0JCQkJc3Zzay0+c2tfYmNfeHBydCwgeGlkKTsKKwkJCQliY194cHJ0LCB4aWQpOwogCQkJdmVjWzBdID0gcnFzdHAtPnJxX2FyZy5oZWFkWzBdOwogCQkJZ290byBvdXQ7CiAJCX0KQEAgLTE2MDUsOSArMTYwOSw3IEBACiAgKi8KIHN0YXRpYyB2b2lkIHN2Y19iY19zb2NrX2ZyZWUoc3RydWN0IHN2Y194cHJ0ICp4cHJ0KQogewotCWlmICh4cHJ0KSB7Ci0JCWtmcmVlKHhwcnQtPnhwdF9iY19zaWQpOworCWlmICh4cHJ0KQogCQlrZnJlZShjb250YWluZXJfb2YoeHBydCwgc3RydWN0IHN2Y19zb2NrLCBza194cHJ0KSk7Ci0JfQogfQogI2VuZGlmIC8qIENPTkZJR19ORlNfVjRfMSAqLwpkaWZmIC0tZ2l0IGEvbmV0L3N1bnJwYy94cHJ0LmMgYi9uZXQvc3VucnBjL3hwcnQuYwppbmRleCA0YzhmMThhLi44NTYyNzRkIDEwMDY0NAotLS0gYS9uZXQvc3VucnBjL3hwcnQuYworKysgYi9uZXQvc3VucnBjL3hwcnQuYwpAQCAtOTY1LDYgKzk2NSw3IEBACiAJeHBydCA9IGt6YWxsb2Moc2l6ZSwgR0ZQX0tFUk5FTCk7CiAJaWYgKHhwcnQgPT0gTlVMTCkKIAkJZ290byBvdXQ7CisJa3JlZl9pbml0KCZ4cHJ0LT5rcmVmKTsKIAogCXhwcnQtPm1heF9yZXFzID0gbWF4X3JlcTsKIAl4cHJ0LT5zbG90ID0ga2NhbGxvYyhtYXhfcmVxLCBzaXplb2Yoc3RydWN0IHJwY19ycXN0KSwgR0ZQX0tFUk5FTCk7CkBAIC0xMTAxLDggKzExMDIsMTAgQEAKIAkJCQktUFRSX0VSUih4cHJ0KSk7CiAJCXJldHVybiB4cHJ0OwogCX0KKwlpZiAodGVzdF9hbmRfc2V0X2JpdChYUFJUX0lOSVRJQUxJWkVELCAmeHBydC0+c3RhdGUpKQorCQkvKiAtPnNldHVwIHJldHVybmVkIGEgcHJlLWluaXRpYWxpemVkIHhwcnQ6ICovCisJCXJldHVybiB4cHJ0OwogCi0Ja3JlZl9pbml0KCZ4cHJ0LT5rcmVmKTsKIAlzcGluX2xvY2tfaW5pdCgmeHBydC0+dHJhbnNwb3J0X2xvY2spOwogCXNwaW5fbG9ja19pbml0KCZ4cHJ0LT5yZXNlcnZlX2xvY2spOwogCmRpZmYgLS1naXQgYS9uZXQvc3VucnBjL3hwcnRzb2NrLmMgYi9uZXQvc3VucnBjL3hwcnRzb2NrLmMKaW5kZXggOTY1NDlkZi4uYzQzMWY1YSAxMDA2NDQKLS0tIGEvbmV0L3N1bnJwYy94cHJ0c29jay5jCisrKyBiL25ldC9zdW5ycGMveHBydHNvY2suYwpAQCAtMjM1OSw2ICsyMzU5LDE1IEBACiAJc3RydWN0IHN2Y19zb2NrICpiY19zb2NrOwogCXN0cnVjdCBycGNfeHBydCAqcmV0OwogCisJaWYgKGFyZ3MtPmJjX3hwcnQtPnhwdF9iY194cHJ0KSB7CisJCS8qCisJCSAqIFRoaXMgc2VydmVyIGNvbm5lY3Rpb24gYWxyZWFkeSBoYXMgYSBiYWNrY2hhbm5lbAorCQkgKiBleHBvcnQ7IHdlIGNhbid0IGNyZWF0ZSBhIG5ldyBvbmUsIGFzIHdlIHdvdWxkbid0IGJlCisJCSAqIGFibGUgdG8gbWF0Y2ggcmVwbGllcyBiYXNlZCBvbiB4aWQgYW55IG1vcmUuICBTbywKKwkJICogcmV1c2UgdGhlIGFscmVhZHktZXhpc3Rpbmcgb25lOgorCQkgKi8KKwkJIHJldHVybiBhcmdzLT5iY194cHJ0LT54cHRfYmNfeHBydDsKKwl9CiAJeHBydCA9IHhzX3NldHVwX3hwcnQoYXJncywgeHBydF90Y3Bfc2xvdF90YWJsZV9lbnRyaWVzKTsKIAlpZiAoSVNfRVJSKHhwcnQpKQogCQlyZXR1cm4geHBydDsKQEAgLTIzNzUsMTYgKzIzODQsNiBAQAogCXhwcnQtPnJlZXN0YWJsaXNoX3RpbWVvdXQgPSAwOwogCXhwcnQtPmlkbGVfdGltZW91dCA9IDA7CiAKLQkvKgotCSAqIFRoZSBiYWNrY2hhbm5lbCB1c2VzIHRoZSBzYW1lIHNvY2tldCBjb25uZWN0aW9uIGFzIHRoZQotCSAqIGZvcmVjaGFubmVsCi0JICovCi0JeHBydC0+YmNfeHBydCA9IGFyZ3MtPmJjX3hwcnQ7Ci0JYmNfc29jayA9IGNvbnRhaW5lcl9vZihhcmdzLT5iY194cHJ0LCBzdHJ1Y3Qgc3ZjX3NvY2ssIHNrX3hwcnQpOwotCWJjX3NvY2stPnNrX2JjX3hwcnQgPSB4cHJ0OwotCXRyYW5zcG9ydC0+c29jayA9IGJjX3NvY2stPnNrX3NvY2s7Ci0JdHJhbnNwb3J0LT5pbmV0ID0gYmNfc29jay0+c2tfc2s7Ci0KIAl4cHJ0LT5vcHMgPSAmYmNfdGNwX29wczsKIAogCXN3aXRjaCAoYWRkci0+c2FfZmFtaWx5KSB7CkBAIC0yNDA3LDYgKzI0MDYsMjAgQEAKIAkJCXhwcnQtPmFkZHJlc3Nfc3RyaW5nc1tSUENfRElTUExBWV9QUk9UT10pOwogCiAJLyoKKwkgKiBPbmNlIHdlJ3ZlIGFzc29jaWF0ZWQgYSBiYWNrY2hhbm5lbCB4cHJ0IHdpdGggYSBjb25uZWN0aW9uLAorCSAqIHdlIHdhbnQgdG8ga2VlcCBpdCBhcm91bmQgYXMgbG9uZyBhcyBsb25nIGFzIHRoZSBjb25uZWN0aW9uCisJICogbGFzdHMsIGluIGNhc2Ugd2UgbmVlZCB0byBzdGFydCB1c2luZyBpdCBmb3IgYSBiYWNrY2hhbm5lbAorCSAqIGFnYWluOyB0aGlzIHJlZmVyZW5jZSB3b24ndCBiZSBkcm9wcGVkIHVudGlsIGJjX3hwcnQgaXMKKwkgKiBkZXN0cm95ZWQuCisJICovCisJeHBydF9nZXQoeHBydCk7CisJYXJncy0+YmNfeHBydC0+eHB0X2JjX3hwcnQgPSB4cHJ0OworCXhwcnQtPmJjX3hwcnQgPSBhcmdzLT5iY194cHJ0OworCWJjX3NvY2sgPSBjb250YWluZXJfb2YoYXJncy0+YmNfeHBydCwgc3RydWN0IHN2Y19zb2NrLCBza194cHJ0KTsKKwl0cmFuc3BvcnQtPnNvY2sgPSBiY19zb2NrLT5za19zb2NrOworCXRyYW5zcG9ydC0+aW5ldCA9IGJjX3NvY2stPnNrX3NrOworCisJLyoKIAkgKiBTaW5jZSB3ZSBkb24ndCB3YW50IGNvbm5lY3Rpb25zIGZvciB0aGUgYmFja2NoYW5uZWwsIHdlIHNldAogCSAqIHRoZSB4cHJ0IHN0YXR1cyB0byBjb25uZWN0ZWQKIAkgKi8KQEAgLTI0MTUsNiArMjQyOCw3IEBACiAKIAlpZiAodHJ5X21vZHVsZV9nZXQoVEhJU19NT0RVTEUpKQogCQlyZXR1cm4geHBydDsKKwl4cHJ0X3B1dCh4cHJ0KTsKIAlyZXQgPSBFUlJfUFRSKC1FSU5WQUwpOwogb3V0X2VycjoKIAl4cHJ0X2ZyZWUoeHBydCk7CmRpZmYgLS1naXQgYS9uZXQvd2lyZWxlc3MvS2NvbmZpZyBiL25ldC93aXJlbGVzcy9LY29uZmlnCmluZGV4IGQwZWUyOTAuLjFmMWVmNzAgMTAwNjQ0Ci0tLSBhL25ldC93aXJlbGVzcy9LY29uZmlnCisrKyBiL25ldC93aXJlbGVzcy9LY29uZmlnCkBAIC05NSw3ICs5NSw3IEBACiAJICBJZiB1bnN1cmUsIHNheSBOLgogCiBjb25maWcgQ0ZHODAyMTFfSU5URVJOQUxfUkVHREIKLQlib29sICJ1c2Ugc3RhdGljYWxseSBjb21waWxlZCByZWd1bGF0b3J5IHJ1bGVzIGRhdGFiYXNlIiBpZiBFTUJFRERFRAorCWJvb2wgInVzZSBzdGF0aWNhbGx5IGNvbXBpbGVkIHJlZ3VsYXRvcnkgcnVsZXMgZGF0YWJhc2UiIGlmIEVYUEVSVAogCWRlZmF1bHQgbgogCWRlcGVuZHMgb24gQ0ZHODAyMTEKIAktLS1oZWxwLS0tCmRpZmYgLS1naXQgYS9uZXQveDI1L3gyNV9mYWNpbGl0aWVzLmMgYi9uZXQveDI1L3gyNV9mYWNpbGl0aWVzLmMKaW5kZXggNTUxODdjOC4uNDA2MjA3NSAxMDA2NDQKLS0tIGEvbmV0L3gyNS94MjVfZmFjaWxpdGllcy5jCisrKyBiL25ldC94MjUveDI1X2ZhY2lsaXRpZXMuYwpAQCAtMjcsOSArMjcsMTkgQEAKICNpbmNsdWRlIDxuZXQvc29jay5oPgogI2luY2x1ZGUgPG5ldC94MjUuaD4KIAotLyoKLSAqIFBhcnNlIGEgc2V0IG9mIGZhY2lsaXRpZXMgaW50byB0aGUgZmFjaWxpdGllcyBzdHJ1Y3R1cmVzLiBVbnJlY29nbmlzZWQKLSAqCWZhY2lsaXRpZXMgYXJlIHdyaXR0ZW4gdG8gdGhlIGRlYnVnIGxvZyBmaWxlLgorLyoqCisgKiB4MjVfcGFyc2VfZmFjaWxpdGllcyAtIFBhcnNlIGZhY2lsaXRpZXMgZnJvbSBza2IgaW50byB0aGUgZmFjaWxpdGllcyBzdHJ1Y3RzCisgKgorICogQHNrYjogc2tfYnVmZiB0byBwYXJzZQorICogQGZhY2lsaXRpZXM6IFJlZ3VsYXIgZmFjaWxpdGVzLCB1cGRhdGVkIGFzIGZhY2lsaXRpZXMgYXJlIGZvdW5kCisgKiBAZHRlX2ZhY3M6IElUVSBEVEUgZmFjaWxpdGllcywgdXBkYXRlZCBhcyBEVEUgZmFjaWxpdGllcyBhcmUgZm91bmQKKyAqIEB2Y19mYWNfbWFzazogbWFzayBpcyB1cGRhdGVkIHdpdGggYWxsIGZhY2lsaXRpZXMgZm91bmQKKyAqCisgKiBSZXR1cm4gY29kZXM6CisgKiAgLTEgLSBQYXJzaW5nIGVycm9yLCBjYWxsZXIgc2hvdWxkIGRyb3AgY2FsbCBhbmQgY2xlYW4gdXAKKyAqICAgMCAtIFBhcnNlIE9LLCB0aGlzIHNrYiBoYXMgbm8gZmFjaWxpdGllcworICogID4wIC0gUGFyc2UgT0ssIHJldHVybnMgdGhlIGxlbmd0aCBvZiB0aGUgZmFjaWxpdGllcyBoZWFkZXIKKyAqCiAgKi8KIGludCB4MjVfcGFyc2VfZmFjaWxpdGllcyhzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBzdHJ1Y3QgeDI1X2ZhY2lsaXRpZXMgKmZhY2lsaXRpZXMsCiAJCXN0cnVjdCB4MjVfZHRlX2ZhY2lsaXRpZXMgKmR0ZV9mYWNzLCB1bnNpZ25lZCBsb25nICp2Y19mYWNfbWFzaykKQEAgLTYyLDcgKzcyLDcgQEAKIAkJc3dpdGNoICgqcCAmIFgyNV9GQUNfQ0xBU1NfTUFTSykgewogCQljYXNlIFgyNV9GQUNfQ0xBU1NfQToKIAkJCWlmIChsZW4gPCAyKQotCQkJCXJldHVybiAwOworCQkJCXJldHVybiAtMTsKIAkJCXN3aXRjaCAoKnApIHsKIAkJCWNhc2UgWDI1X0ZBQ19SRVZFUlNFOgogCQkJCWlmKChwWzFdICYgMHg4MSkgPT0gMHg4MSkgewpAQCAtMTA3LDcgKzExNyw3IEBACiAJCQlicmVhazsKIAkJY2FzZSBYMjVfRkFDX0NMQVNTX0I6CiAJCQlpZiAobGVuIDwgMykKLQkJCQlyZXR1cm4gMDsKKwkJCQlyZXR1cm4gLTE7CiAJCQlzd2l0Y2ggKCpwKSB7CiAJCQljYXNlIFgyNV9GQUNfUEFDS0VUX1NJWkU6CiAJCQkJZmFjaWxpdGllcy0+cGFjc2l6ZV9pbiAgPSBwWzFdOwpAQCAtMTMwLDcgKzE0MCw3IEBACiAJCQlicmVhazsKIAkJY2FzZSBYMjVfRkFDX0NMQVNTX0M6CiAJCQlpZiAobGVuIDwgNCkKLQkJCQlyZXR1cm4gMDsKKwkJCQlyZXR1cm4gLTE7CiAJCQlwcmludGsoS0VSTl9ERUJVRyAiWC4yNTogdW5rbm93biBmYWNpbGl0eSAlMDJYLCAiCiAJCQkgICAgICAgInZhbHVlcyAlMDJYLCAlMDJYLCAlMDJYXG4iLAogCQkJICAgICAgIHBbMF0sIHBbMV0sIHBbMl0sIHBbM10pOwpAQCAtMTM5LDE4ICsxNDksMTggQEAKIAkJCWJyZWFrOwogCQljYXNlIFgyNV9GQUNfQ0xBU1NfRDoKIAkJCWlmIChsZW4gPCBwWzFdICsgMikKLQkJCQlyZXR1cm4gMDsKKwkJCQlyZXR1cm4gLTE7CiAJCQlzd2l0Y2ggKCpwKSB7CiAJCQljYXNlIFgyNV9GQUNfQ0FMTElOR19BRToKIAkJCQlpZiAocFsxXSA+IFgyNV9NQVhfRFRFX0ZBQ0lMX0xFTiB8fCBwWzFdIDw9IDEpCi0JCQkJCXJldHVybiAwOworCQkJCQlyZXR1cm4gLTE7CiAJCQkJZHRlX2ZhY3MtPmNhbGxpbmdfbGVuID0gcFsyXTsKIAkJCQltZW1jcHkoZHRlX2ZhY3MtPmNhbGxpbmdfYWUsICZwWzNdLCBwWzFdIC0gMSk7CiAJCQkJKnZjX2ZhY19tYXNrIHw9IFgyNV9NQVNLX0NBTExJTkdfQUU7CiAJCQkJYnJlYWs7CiAJCQljYXNlIFgyNV9GQUNfQ0FMTEVEX0FFOgogCQkJCWlmIChwWzFdID4gWDI1X01BWF9EVEVfRkFDSUxfTEVOIHx8IHBbMV0gPD0gMSkKLQkJCQkJcmV0dXJuIDA7CisJCQkJCXJldHVybiAtMTsKIAkJCQlkdGVfZmFjcy0+Y2FsbGVkX2xlbiA9IHBbMl07CiAJCQkJbWVtY3B5KGR0ZV9mYWNzLT5jYWxsZWRfYWUsICZwWzNdLCBwWzFdIC0gMSk7CiAJCQkJKnZjX2ZhY19tYXNrIHw9IFgyNV9NQVNLX0NBTExFRF9BRTsKZGlmZiAtLWdpdCBhL25ldC94MjUveDI1X2luLmMgYi9uZXQveDI1L3gyNV9pbi5jCmluZGV4IGY3MjlmMDIuLjE1ZGU2NWYgMTAwNjQ0Ci0tLSBhL25ldC94MjUveDI1X2luLmMKKysrIGIvbmV0L3gyNS94MjVfaW4uYwpAQCAtOTEsMTAgKzkxLDEwIEBACiB7CiAJc3RydWN0IHgyNV9hZGRyZXNzIHNvdXJjZV9hZGRyLCBkZXN0X2FkZHI7CiAJaW50IGxlbjsKKwlzdHJ1Y3QgeDI1X3NvY2sgKngyNSA9IHgyNV9zayhzayk7CiAKIAlzd2l0Y2ggKGZyYW1ldHlwZSkgewogCQljYXNlIFgyNV9DQUxMX0FDQ0VQVEVEOiB7Ci0JCQlzdHJ1Y3QgeDI1X3NvY2sgKngyNSA9IHgyNV9zayhzayk7CiAKIAkJCXgyNV9zdG9wX3RpbWVyKHNrKTsKIAkJCXgyNS0+Y29uZGl0aW9uID0gMHgwMDsKQEAgLTExMywxNCArMTEzLDE2IEBACiAJCQkJCQkmZGVzdF9hZGRyKTsKIAkJCWlmIChsZW4gPiAwKQogCQkJCXNrYl9wdWxsKHNrYiwgbGVuKTsKKwkJCWVsc2UgaWYgKGxlbiA8IDApCisJCQkJZ290byBvdXRfY2xlYXI7CiAKIAkJCWxlbiA9IHgyNV9wYXJzZV9mYWNpbGl0aWVzKHNrYiwgJngyNS0+ZmFjaWxpdGllcywKIAkJCQkJCSZ4MjUtPmR0ZV9mYWNpbGl0aWVzLAogCQkJCQkJJngyNS0+dmNfZmFjaWxfbWFzayk7CiAJCQlpZiAobGVuID4gMCkKIAkJCQlza2JfcHVsbChza2IsIGxlbik7Ci0JCQllbHNlCi0JCQkJcmV0dXJuIC0xOworCQkJZWxzZSBpZiAobGVuIDwgMCkKKwkJCQlnb3RvIG91dF9jbGVhcjsKIAkJCS8qCiAJCQkgKglDb3B5IGFueSBDYWxsIFVzZXIgRGF0YS4KIAkJCSAqLwpAQCAtMTQ0LDYgKzE0NiwxMiBAQAogCX0KIAogCXJldHVybiAwOworCitvdXRfY2xlYXI6CisJeDI1X3dyaXRlX2ludGVybmFsKHNrLCBYMjVfQ0xFQVJfUkVRVUVTVCk7CisJeDI1LT5zdGF0ZSA9IFgyNV9TVEFURV8yOworCXgyNV9zdGFydF90MjN0aW1lcihzayk7CisJcmV0dXJuIDA7CiB9CiAKIC8qCmRpZmYgLS1naXQgYS9uZXQveDI1L3gyNV9saW5rLmMgYi9uZXQveDI1L3gyNV9saW5rLmMKaW5kZXggNGNiYzk0Mi4uMjEzMDY5MiAxMDA2NDQKLS0tIGEvbmV0L3gyNS94MjVfbGluay5jCisrKyBiL25ldC94MjUveDI1X2xpbmsuYwpAQCAtMzk2LDkgKzM5NiwxMiBAQAogCXdyaXRlX2xvY2tfYmgoJngyNV9uZWlnaF9saXN0X2xvY2spOwogCiAJbGlzdF9mb3JfZWFjaF9zYWZlKGVudHJ5LCB0bXAsICZ4MjVfbmVpZ2hfbGlzdCkgeworCQlzdHJ1Y3QgbmV0X2RldmljZSAqZGV2OworCiAJCW5iID0gbGlzdF9lbnRyeShlbnRyeSwgc3RydWN0IHgyNV9uZWlnaCwgbm9kZSk7CisJCWRldiA9IG5iLT5kZXY7CiAJCV9feDI1X3JlbW92ZV9uZWlnaChuYik7Ci0JCWRldl9wdXQobmItPmRldik7CisJCWRldl9wdXQoZGV2KTsKIAl9CiAJd3JpdGVfdW5sb2NrX2JoKCZ4MjVfbmVpZ2hfbGlzdF9sb2NrKTsKIH0KZGlmZiAtLWdpdCBhL25ldC94ZnJtL3hmcm1fdXNlci5jIGIvbmV0L3hmcm0veGZybV91c2VyLmMKaW5kZXggZDVlMWUwYi4uNjEyOTE5NiAxMDA2NDQKLS0tIGEvbmV0L3hmcm0veGZybV91c2VyLmMKKysrIGIvbmV0L3hmcm0veGZybV91c2VyLmMKQEAgLTIxODksNyArMjE4OSw3IEBACiAKIAlpZiAoKHR5cGUgPT0gKFhGUk1fTVNHX0dFVFNBIC0gWEZSTV9NU0dfQkFTRSkgfHwKIAkgICAgIHR5cGUgPT0gKFhGUk1fTVNHX0dFVFBPTElDWSAtIFhGUk1fTVNHX0JBU0UpKSAmJgotCSAgICAobmxoLT5ubG1zZ19mbGFncyAmIE5MTV9GX0RVTVApID09IE5MTV9GX0RVTVApIHsKKwkgICAgKG5saC0+bmxtc2dfZmxhZ3MgJiBOTE1fRl9EVU1QKSkgewogCQlpZiAobGluay0+ZHVtcCA9PSBOVUxMKQogCQkJcmV0dXJuIC1FSU5WQUw7CiAKZGlmZiAtLWdpdCBhL3NjcmlwdHMvcGFja2FnZS9idWlsZGRlYiBiL3NjcmlwdHMvcGFja2FnZS9idWlsZGRlYgppbmRleCBiMGIyMzU3Li5mNmNiYzNkIDEwMDY0NAotLS0gYS9zY3JpcHRzL3BhY2thZ2UvYnVpbGRkZWIKKysrIGIvc2NyaXB0cy9wYWNrYWdlL2J1aWxkZGViCkBAIC0yMzgsMTIgKzIzOCwxMiBAQAogZmkKIAogIyBCdWlsZCBoZWFkZXIgcGFja2FnZQotZmluZCAuIC1uYW1lIE1ha2VmaWxlIC1vIC1uYW1lIEtjb25maWdcKiAtbyAtbmFtZSBcKi5wbCA+IC90bXAvZmlsZXMkJAotZmluZCBhcmNoL3g4Ni9pbmNsdWRlIGluY2x1ZGUgc2NyaXB0cyAtdHlwZSBmID4+IC90bXAvZmlsZXMkJAorKGNkICRzcmN0cmVlOyBmaW5kIC4gLW5hbWUgTWFrZWZpbGUgLW8gLW5hbWUgS2NvbmZpZ1wqIC1vIC1uYW1lIFwqLnBsID4gL3RtcC9maWxlcyQkKQorKGNkICRzcmN0cmVlOyBmaW5kIGFyY2gvJFNSQ0FSQ0gvaW5jbHVkZSBpbmNsdWRlIHNjcmlwdHMgLXR5cGUgZiA+PiAvdG1wL2ZpbGVzJCQpCiAoY2QgJG9ianRyZWU7IGZpbmQgLmNvbmZpZyBNb2R1bGUuc3ltdmVycyBpbmNsdWRlIHNjcmlwdHMgLXR5cGUgZiA+PiAvdG1wL29iamZpbGVzJCQpCiBkZXN0ZGlyPSRrZXJuZWxfaGVhZGVyc19kaXIvdXNyL3NyYy9saW51eC1oZWFkZXJzLSR2ZXJzaW9uCiBta2RpciAtcCAiJGRlc3RkaXIiCi10YXIgLWMgLWYgLSAtVCAvdG1wL2ZpbGVzJCQgfCAoY2QgJGRlc3RkaXI7IHRhciAteGYgLSkKKyhjZCAkc3JjdHJlZTsgdGFyIC1jIC1mIC0gLVQgL3RtcC9maWxlcyQkKSB8IChjZCAkZGVzdGRpcjsgdGFyIC14ZiAtKQogKGNkICRvYmp0cmVlOyB0YXIgLWMgLWYgLSAtVCAvdG1wL29iamZpbGVzJCQpIHwgKGNkICRkZXN0ZGlyOyB0YXIgLXhmIC0pCiBybSAtZiAvdG1wL2ZpbGVzJCQgL3RtcC9vYmpmaWxlcyQkCiBhcmNoPSQoZHBrZyAtLXByaW50LWFyY2hpdGVjdHVyZSkKZGlmZiAtLWdpdCBhL3NlY3VyaXR5L2tleXMvTWFrZWZpbGUgYi9zZWN1cml0eS9rZXlzL01ha2VmaWxlCmluZGV4IDZjOTQxMDUuLjFiZjA5MGEgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L2tleXMvTWFrZWZpbGUKKysrIGIvc2VjdXJpdHkva2V5cy9NYWtlZmlsZQpAQCAtMTMsOCArMTMsOCBAQAogCXJlcXVlc3Rfa2V5X2F1dGgubyBcCiAJdXNlcl9kZWZpbmVkLm8KIAotb2JqLSQoQ09ORklHX1RSVVNURURfS0VZUykgKz0gdHJ1c3RlZF9kZWZpbmVkLm8KLW9iai0kKENPTkZJR19FTkNSWVBURURfS0VZUykgKz0gZW5jcnlwdGVkX2RlZmluZWQubworb2JqLSQoQ09ORklHX1RSVVNURURfS0VZUykgKz0gdHJ1c3RlZC5vCitvYmotJChDT05GSUdfRU5DUllQVEVEX0tFWVMpICs9IGVuY3J5cHRlZC5vCiBvYmotJChDT05GSUdfS0VZU19DT01QQVQpICs9IGNvbXBhdC5vCiBvYmotJChDT05GSUdfUFJPQ19GUykgKz0gcHJvYy5vCiBvYmotJChDT05GSUdfU1lTQ1RMKSArPSBzeXNjdGwubwpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkva2V5cy9jb21wYXQuYyBiL3NlY3VyaXR5L2tleXMvY29tcGF0LmMKaW5kZXggNzkyYzBhNi4uMDdhNWYzNSAxMDA2NDQKLS0tIGEvc2VjdXJpdHkva2V5cy9jb21wYXQuYworKysgYi9zZWN1cml0eS9rZXlzL2NvbXBhdC5jCkBAIC0xLDQgKzEsNCBAQAotLyogY29tcGF0LmM6IDMyLWJpdCBjb21wYXRpYmlsaXR5IHN5c2NhbGwgZm9yIDY0LWJpdCBzeXN0ZW1zCisvKiAzMi1iaXQgY29tcGF0aWJpbGl0eSBzeXNjYWxsIGZvciA2NC1iaXQgc3lzdGVtcwogICoKICAqIENvcHlyaWdodCAoQykgMjAwNC01IFJlZCBIYXQsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KICAqIFdyaXR0ZW4gYnkgRGF2aWQgSG93ZWxscyAoZGhvd2VsbHNAcmVkaGF0LmNvbSkKQEAgLTE0LDEzICsxNCwxMyBAQAogI2luY2x1ZGUgPGxpbnV4L2NvbXBhdC5oPgogI2luY2x1ZGUgImludGVybmFsLmgiCiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiB0aGUga2V5IGNvbnRyb2wgc3lzdGVtIGNhbGwsIDMyLWJpdCBjb21wYXRpYmlsaXR5IHZlcnNpb24gZm9yIDY0LWJpdCBhcmNocwotICogLSB0aGlzIHNob3VsZCBvbmx5IGJlIGNhbGxlZCBpZiB0aGUgNjQtYml0IGFyY2ggdXNlcyB3ZWlyZCBwb2ludGVycyBpbgotICogICAzMi1iaXQgbW9kZSBvciBkb2Vzbid0IGd1YXJhbnRlZSB0aGF0IHRoZSB0b3AgMzItYml0cyBvZiB0aGUgYXJndW1lbnQKLSAqICAgcmVnaXN0ZXJzIG9uIHRha2luZyBhIDMyLWJpdCBzeXNjYWxsIGFyZSB6ZXJvCi0gKiAtIGlmIHlvdSBjYW4sIHlvdSBzaG91bGQgY2FsbCBzeXNfa2V5Y3RsIGRpcmVjdGx5CisgKiBUaGUga2V5IGNvbnRyb2wgc3lzdGVtIGNhbGwsIDMyLWJpdCBjb21wYXRpYmlsaXR5IHZlcnNpb24gZm9yIDY0LWJpdCBhcmNocworICoKKyAqIFRoaXMgc2hvdWxkIG9ubHkgYmUgY2FsbGVkIGlmIHRoZSA2NC1iaXQgYXJjaCB1c2VzIHdlaXJkIHBvaW50ZXJzIGluIDMyLWJpdAorICogbW9kZSBvciBkb2Vzbid0IGd1YXJhbnRlZSB0aGF0IHRoZSB0b3AgMzItYml0cyBvZiB0aGUgYXJndW1lbnQgcmVnaXN0ZXJzIG9uCisgKiB0YWtpbmcgYSAzMi1iaXQgc3lzY2FsbCBhcmUgemVyby4gIElmIHlvdSBjYW4sIHlvdSBzaG91bGQgY2FsbCBzeXNfa2V5Y3RsKCkKKyAqIGRpcmVjdGx5LgogICovCiBhc21saW5rYWdlIGxvbmcgY29tcGF0X3N5c19rZXljdGwodTMyIG9wdGlvbiwKIAkJCQkgIHUzMiBhcmcyLCB1MzIgYXJnMywgdTMyIGFyZzQsIHUzMiBhcmc1KQpAQCAtODgsNSArODgsNCBAQAogCWRlZmF1bHQ6CiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAl9Ci0KLX0gLyogZW5kIGNvbXBhdF9zeXNfa2V5Y3RsKCkgKi8KK30KZGlmZiAtLWdpdCBhL3NlY3VyaXR5L2tleXMvZW5jcnlwdGVkX2RlZmluZWQuYyBiL3NlY3VyaXR5L2tleXMvZW5jcnlwdGVkLmMKc2ltaWxhcml0eSBpbmRleCA5OSUKcmVuYW1lIGZyb20gc2VjdXJpdHkva2V5cy9lbmNyeXB0ZWRfZGVmaW5lZC5jCnJlbmFtZSB0byBzZWN1cml0eS9rZXlzL2VuY3J5cHRlZC5jCmluZGV4IDMyZDI3YzguLjllN2U0Y2UgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L2tleXMvZW5jcnlwdGVkX2RlZmluZWQuYworKysgYi9zZWN1cml0eS9rZXlzL2VuY3J5cHRlZC5jCkBAIC0zMCw3ICszMCw3IEBACiAjaW5jbHVkZSA8Y3J5cHRvL3NoYS5oPgogI2luY2x1ZGUgPGNyeXB0by9hZXMuaD4KIAotI2luY2x1ZGUgImVuY3J5cHRlZF9kZWZpbmVkLmgiCisjaW5jbHVkZSAiZW5jcnlwdGVkLmgiCiAKIHN0YXRpYyBjb25zdCBjaGFyIEtFWV9UUlVTVEVEX1BSRUZJWFtdID0gInRydXN0ZWQ6IjsKIHN0YXRpYyBjb25zdCBjaGFyIEtFWV9VU0VSX1BSRUZJWFtdID0gInVzZXI6IjsKZGlmZiAtLWdpdCBhL3NlY3VyaXR5L2tleXMvZW5jcnlwdGVkX2RlZmluZWQuaCBiL3NlY3VyaXR5L2tleXMvZW5jcnlwdGVkLmgKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIHNlY3VyaXR5L2tleXMvZW5jcnlwdGVkX2RlZmluZWQuaApyZW5hbWUgdG8gc2VjdXJpdHkva2V5cy9lbmNyeXB0ZWQuaApkaWZmIC0tZ2l0IGEvc2VjdXJpdHkva2V5cy9nYy5jIGIvc2VjdXJpdHkva2V5cy9nYy5jCmluZGV4IGE0NmU4MjUuLjg5ZGY2YjUgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L2tleXMvZ2MuYworKysgYi9zZWN1cml0eS9rZXlzL2djLmMKQEAgLTMyLDggKzMyLDggQEAKIHN0YXRpYyB0aW1lX3Qga2V5X2djX25ld190aW1lcjsKIAogLyoKLSAqIFNjaGVkdWxlIGEgZ2FyYmFnZSBjb2xsZWN0aW9uIHJ1bgotICogLSBwcmVjaXNpb24gaXNuJ3QgcGFydGljdWxhcmx5IGltcG9ydGFudAorICogU2NoZWR1bGUgYSBnYXJiYWdlIGNvbGxlY3Rpb24gcnVuLgorICogLSB0aW1lIHByZWNpc2lvbiBpc24ndCBwYXJ0aWN1bGFybHkgaW1wb3J0YW50CiAgKi8KIHZvaWQga2V5X3NjaGVkdWxlX2djKHRpbWVfdCBnY19hdCkKIHsKQEAgLTYxLDggKzYxLDkgQEAKIH0KIAogLyoKLSAqIEdhcmJhZ2UgY29sbGVjdCBwb2ludGVycyBmcm9tIGEga2V5cmluZwotICogLSByZXR1cm4gdHJ1ZSBpZiB3ZSBhbHRlcmVkIHRoZSBrZXlyaW5nCisgKiBHYXJiYWdlIGNvbGxlY3QgcG9pbnRlcnMgZnJvbSBhIGtleXJpbmcuCisgKgorICogUmV0dXJuIHRydWUgaWYgd2UgYWx0ZXJlZCB0aGUga2V5cmluZy4KICAqLwogc3RhdGljIGJvb2wga2V5X2djX2tleXJpbmcoc3RydWN0IGtleSAqa2V5cmluZywgdGltZV90IGxpbWl0KQogCV9fcmVsZWFzZXMoa2V5X3NlcmlhbF9sb2NrKQpAQCAtMTA3LDkgKzEwOCw4IEBACiB9CiAKIC8qCi0gKiBHYXJiYWdlIGNvbGxlY3RvciBmb3Iga2V5cwotICogLSB0aGlzIGludm9sdmVzIHNjYW5uaW5nIHRoZSBrZXlyaW5ncyBmb3IgZGVhZCwgZXhwaXJlZCBhbmQgcmV2b2tlZCBrZXlzCi0gKiAgIHRoYXQgaGF2ZSBvdmVyc3RheWVkIHRoZWlyIHdlbGNvbWUKKyAqIEdhcmJhZ2UgY29sbGVjdG9yIGZvciBrZXlzLiAgVGhpcyBpbnZvbHZlcyBzY2FubmluZyB0aGUga2V5cmluZ3MgZm9yIGRlYWQsCisgKiBleHBpcmVkIGFuZCByZXZva2VkIGtleXMgdGhhdCBoYXZlIG92ZXJzdGF5ZWQgdGhlaXIgd2VsY29tZQogICovCiBzdGF0aWMgdm9pZCBrZXlfZ2FyYmFnZV9jb2xsZWN0b3Ioc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogewpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkva2V5cy9pbnRlcm5hbC5oIGIvc2VjdXJpdHkva2V5cy9pbnRlcm5hbC5oCmluZGV4IDU2YTEzM2QuLmE1MmFhN2MgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L2tleXMvaW50ZXJuYWwuaAorKysgYi9zZWN1cml0eS9rZXlzL2ludGVybmFsLmgKQEAgLTEsNCArMSw0IEBACi0vKiBpbnRlcm5hbC5oOiBhdXRoZW50aWNhdGlvbiB0b2tlbiBhbmQgYWNjZXNzIGtleSBtYW5hZ2VtZW50IGludGVybmFsIGRlZnMKKy8qIEF1dGhlbnRpY2F0aW9uIHRva2VuIGFuZCBhY2Nlc3Mga2V5IG1hbmFnZW1lbnQgaW50ZXJuYWwgZGVmcwogICoKICAqIENvcHlyaWdodCAoQykgMjAwMy01LCAyMDA3IFJlZCBIYXQsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KICAqIFdyaXR0ZW4gYnkgRGF2aWQgSG93ZWxscyAoZGhvd2VsbHNAcmVkaGF0LmNvbSkKQEAgLTM1LDEwICszNSwxMiBAQAogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICoga2VlcCB0cmFjayBvZiBrZXlzIGZvciBhIHVzZXIKLSAqIC0gdGhpcyBuZWVkcyB0byBiZSBzZXBhcmF0ZSB0byB1c2VyX3N0cnVjdCB0byBhdm9pZCBhIHJlZmNvdW50LWxvb3AKLSAqICAgKHVzZXJfc3RydWN0IHBpbnMgc29tZSBrZXlyaW5ncyB3aGljaCBwaW4gdGhpcyBzdHJ1Y3QpCi0gKiAtIHRoaXMgYWxzbyBrZWVwcyB0cmFjayBvZiBrZXlzIHVuZGVyIHJlcXVlc3QgZnJvbSB1c2Vyc3BhY2UgZm9yIHRoaXMgVUlECisgKiBLZWVwIHRyYWNrIG9mIGtleXMgZm9yIGEgdXNlci4KKyAqCisgKiBUaGlzIG5lZWRzIHRvIGJlIHNlcGFyYXRlIHRvIHVzZXJfc3RydWN0IHRvIGF2b2lkIGEgcmVmY291bnQtbG9vcAorICogKHVzZXJfc3RydWN0IHBpbnMgc29tZSBrZXlyaW5ncyB3aGljaCBwaW4gdGhpcyBzdHJ1Y3QpLgorICoKKyAqIFdlIGFsc28ga2VlcCB0cmFjayBvZiBrZXlzIHVuZGVyIHJlcXVlc3QgZnJvbSB1c2Vyc3BhY2UgZm9yIHRoaXMgVUlEIGhlcmUuCiAgKi8KIHN0cnVjdCBrZXlfdXNlciB7CiAJc3RydWN0IHJiX25vZGUJCW5vZGU7CkBAIC02Miw3ICs2NCw3IEBACiBleHRlcm4gdm9pZCBrZXlfdXNlcl9wdXQoc3RydWN0IGtleV91c2VyICp1c2VyKTsKIAogLyoKLSAqIGtleSBxdW90YSBsaW1pdHMKKyAqIEtleSBxdW90YSBsaW1pdHMuCiAgKiAtIHJvb3QgaGFzIGl0cyBvd24gc2VwYXJhdGUgbGltaXRzIHRvIGV2ZXJ5b25lIGVsc2UKICAqLwogZXh0ZXJuIHVuc2lnbmVkIGtleV9xdW90YV9yb290X21heGtleXM7CkBAIC04NSwxMyArODcsMTMgQEAKIGV4dGVybiBpbnQgX19rZXlfbGlua19iZWdpbihzdHJ1Y3Qga2V5ICprZXlyaW5nLAogCQkJICAgIGNvbnN0IHN0cnVjdCBrZXlfdHlwZSAqdHlwZSwKIAkJCSAgICBjb25zdCBjaGFyICpkZXNjcmlwdGlvbiwKLQkJCSAgICBzdHJ1Y3Qga2V5cmluZ19saXN0ICoqX3ByZWFsbG9jKTsKKwkJCSAgICB1bnNpZ25lZCBsb25nICpfcHJlYWxsb2MpOwogZXh0ZXJuIGludCBfX2tleV9saW5rX2NoZWNrX2xpdmVfa2V5KHN0cnVjdCBrZXkgKmtleXJpbmcsIHN0cnVjdCBrZXkgKmtleSk7CiBleHRlcm4gdm9pZCBfX2tleV9saW5rKHN0cnVjdCBrZXkgKmtleXJpbmcsIHN0cnVjdCBrZXkgKmtleSwKLQkJICAgICAgIHN0cnVjdCBrZXlyaW5nX2xpc3QgKipfcHJlYWxsb2MpOworCQkgICAgICAgdW5zaWduZWQgbG9uZyAqX3ByZWFsbG9jKTsKIGV4dGVybiB2b2lkIF9fa2V5X2xpbmtfZW5kKHN0cnVjdCBrZXkgKmtleXJpbmcsCiAJCQkgICBzdHJ1Y3Qga2V5X3R5cGUgKnR5cGUsCi0JCQkgICBzdHJ1Y3Qga2V5cmluZ19saXN0ICpwcmVhbGxvYyk7CisJCQkgICB1bnNpZ25lZCBsb25nIHByZWFsbG9jKTsKIAogZXh0ZXJuIGtleV9yZWZfdCBfX2tleXJpbmdfc2VhcmNoX29uZShrZXlfcmVmX3Qga2V5cmluZ19yZWYsCiAJCQkJICAgICAgY29uc3Qgc3RydWN0IGtleV90eXBlICp0eXBlLApAQCAtMTQ2LDEzICsxNDgsMTMgQEAKIGV4dGVybiB2b2lkIGtleXJpbmdfZ2Moc3RydWN0IGtleSAqa2V5cmluZywgdGltZV90IGxpbWl0KTsKIGV4dGVybiB2b2lkIGtleV9zY2hlZHVsZV9nYyh0aW1lX3QgZXhwaXJ5X2F0KTsKIAotLyoKLSAqIGNoZWNrIHRvIHNlZSB3aGV0aGVyIHBlcm1pc3Npb24gaXMgZ3JhbnRlZCB0byB1c2UgYSBrZXkgaW4gdGhlIGRlc2lyZWQgd2F5Ci0gKi8KIGV4dGVybiBpbnQga2V5X3Rhc2tfcGVybWlzc2lvbihjb25zdCBrZXlfcmVmX3Qga2V5X3JlZiwKIAkJCSAgICAgICBjb25zdCBzdHJ1Y3QgY3JlZCAqY3JlZCwKIAkJCSAgICAgICBrZXlfcGVybV90IHBlcm0pOwogCisvKgorICogQ2hlY2sgdG8gc2VlIHdoZXRoZXIgcGVybWlzc2lvbiBpcyBncmFudGVkIHRvIHVzZSBhIGtleSBpbiB0aGUgZGVzaXJlZCB3YXkuCisgKi8KIHN0YXRpYyBpbmxpbmUgaW50IGtleV9wZXJtaXNzaW9uKGNvbnN0IGtleV9yZWZfdCBrZXlfcmVmLCBrZXlfcGVybV90IHBlcm0pCiB7CiAJcmV0dXJuIGtleV90YXNrX3Blcm1pc3Npb24oa2V5X3JlZiwgY3VycmVudF9jcmVkKCksIHBlcm0pOwpAQCAtMTY4LDcgKzE3MCw3IEBACiAjZGVmaW5lCUtFWV9BTEwJCTB4M2YJLyogYWxsIHRoZSBhYm92ZSBwZXJtaXNzaW9ucyAqLwogCiAvKgotICogcmVxdWVzdF9rZXkgYXV0aG9yaXNhdGlvbgorICogQXV0aG9yaXNhdGlvbiByZWNvcmQgZm9yIHJlcXVlc3Rfa2V5KCkuCiAgKi8KIHN0cnVjdCByZXF1ZXN0X2tleV9hdXRoIHsKIAlzdHJ1Y3Qga2V5CQkqdGFyZ2V0X2tleTsKQEAgLTE4OCw3ICsxOTAsNyBAQAogZXh0ZXJuIHN0cnVjdCBrZXkgKmtleV9nZXRfaW5zdGFudGlhdGlvbl9hdXRoa2V5KGtleV9zZXJpYWxfdCB0YXJnZXRfaWQpOwogCiAvKgotICoga2V5Y3RsIGZ1bmN0aW9ucworICoga2V5Y3RsKCkgZnVuY3Rpb25zCiAgKi8KIGV4dGVybiBsb25nIGtleWN0bF9nZXRfa2V5cmluZ19JRChrZXlfc2VyaWFsX3QsIGludCk7CiBleHRlcm4gbG9uZyBrZXljdGxfam9pbl9zZXNzaW9uX2tleXJpbmcoY29uc3QgY2hhciBfX3VzZXIgKik7CkBAIC0yMTQsNyArMjE2LDcgQEAKIGV4dGVybiBsb25nIGtleWN0bF9zZXNzaW9uX3RvX3BhcmVudCh2b2lkKTsKIAogLyoKLSAqIGRlYnVnZ2luZyBrZXkgdmFsaWRhdGlvbgorICogRGVidWdnaW5nIGtleSB2YWxpZGF0aW9uCiAgKi8KICNpZmRlZiBLRVlfREVCVUdHSU5HCiBleHRlcm4gdm9pZCBfX2tleV9jaGVjayhjb25zdCBzdHJ1Y3Qga2V5ICopOwpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkva2V5cy9rZXkuYyBiL3NlY3VyaXR5L2tleXMva2V5LmMKaW5kZXggYzFlYWM4MC4uMWMyZDQzZCAxMDA2NDQKLS0tIGEvc2VjdXJpdHkva2V5cy9rZXkuYworKysgYi9zZWN1cml0eS9rZXlzL2tleS5jCkBAIC0zOSwxMCArMzksMTAgQEAKIHN0YXRpYyB2b2lkIGtleV9jbGVhbnVwKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yayk7CiBzdGF0aWMgREVDTEFSRV9XT1JLKGtleV9jbGVhbnVwX3Rhc2ssIGtleV9jbGVhbnVwKTsKIAotLyogd2Ugc2VyaWFsaXNlIGtleSBpbnN0YW50aWF0aW9uIGFuZCBsaW5rICovCisvKiBXZSBzZXJpYWxpc2Uga2V5IGluc3RhbnRpYXRpb24gYW5kIGxpbmsgKi8KIERFRklORV9NVVRFWChrZXlfY29uc3RydWN0aW9uX211dGV4KTsKIAotLyogYW55IGtleSB3aG8ncyB0eXBlIGdldHMgdW5lZ2lzdGVyZWQgd2lsbCBiZSByZS10eXBlZCB0byB0aGlzICovCisvKiBBbnkga2V5IHdobydzIHR5cGUgZ2V0cyB1bmVnaXN0ZXJlZCB3aWxsIGJlIHJlLXR5cGVkIHRvIHRoaXMgKi8KIHN0YXRpYyBzdHJ1Y3Qga2V5X3R5cGUga2V5X3R5cGVfZGVhZCA9IHsKIAkubmFtZQkJPSAiZGVhZCIsCiB9OwpAQCAtNTYsMTAgKzU2LDkgQEAKIH0KICNlbmRpZgogCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogZ2V0IHRoZSBrZXkgcXVvdGEgcmVjb3JkIGZvciBhIHVzZXIsIGFsbG9jYXRpbmcgYSBuZXcgcmVjb3JkIGlmIG9uZSBkb2Vzbid0Ci0gKiBhbHJlYWR5IGV4aXN0CisgKiBHZXQgdGhlIGtleSBxdW90YSByZWNvcmQgZm9yIGEgdXNlciwgYWxsb2NhdGluZyBhIG5ldyByZWNvcmQgaWYgb25lIGRvZXNuJ3QKKyAqIGFscmVhZHkgZXhpc3QuCiAgKi8KIHN0cnVjdCBrZXlfdXNlciAqa2V5X3VzZXJfbG9va3VwKHVpZF90IHVpZCwgc3RydWN0IHVzZXJfbmFtZXNwYWNlICp1c2VyX25zKQogewpAQCAtNjcsNyArNjYsNyBAQAogCXN0cnVjdCByYl9ub2RlICpwYXJlbnQgPSBOVUxMOwogCXN0cnVjdCByYl9ub2RlICoqcDsKIAotIHRyeV9hZ2FpbjoKK3RyeV9hZ2FpbjoKIAlwID0gJmtleV91c2VyX3RyZWUucmJfbm9kZTsKIAlzcGluX2xvY2soJmtleV91c2VyX2xvY2spOwogCkBAIC0xMjQsMTggKzEyMywxNiBAQAogCWdvdG8gb3V0OwogCiAJLyogb2theSAtIHdlIGZvdW5kIGEgdXNlciByZWNvcmQgZm9yIHRoaXMgVUlEICovCi0gZm91bmQ6Citmb3VuZDoKIAlhdG9taWNfaW5jKCZ1c2VyLT51c2FnZSk7CiAJc3Bpbl91bmxvY2soJmtleV91c2VyX2xvY2spOwogCWtmcmVlKGNhbmRpZGF0ZSk7Ci0gb3V0Ogorb3V0OgogCXJldHVybiB1c2VyOworfQogCi19IC8qIGVuZCBrZXlfdXNlcl9sb29rdXAoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogZGlzcG9zZSBvZiBhIHVzZXIgc3RydWN0dXJlCisgKiBEaXNwb3NlIG9mIGEgdXNlciBzdHJ1Y3R1cmUKICAqLwogdm9pZCBrZXlfdXNlcl9wdXQoc3RydWN0IGtleV91c2VyICp1c2VyKQogewpAQCAtMTQ2LDE0ICsxNDMsMTEgQEAKIAogCQlrZnJlZSh1c2VyKTsKIAl9Cit9CiAKLX0gLyogZW5kIGtleV91c2VyX3B1dCgpICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBhc3NpZ24gYSBrZXkgdGhlIG5leHQgdW5pcXVlIHNlcmlhbCBudW1iZXIKLSAqIC0gdGhlc2UgYXJlIGFzc2lnbmVkIHJhbmRvbWx5IHRvIGF2b2lkIHNlY3VyaXR5IGlzc3VlcyB0aHJvdWdoIGNvdmVydAotICogICBjaGFubmVsIHByb2JsZW1zCisgKiBBbGxvY2F0ZSBhIHNlcmlhbCBudW1iZXIgZm9yIGEga2V5LiAgVGhlc2UgYXJlIGFzc2lnbmVkIHJhbmRvbWx5IHRvIGF2b2lkCisgKiBzZWN1cml0eSBpc3N1ZXMgdGhyb3VnaCBjb3ZlcnQgY2hhbm5lbCBwcm9ibGVtcy4KICAqLwogc3RhdGljIGlubGluZSB2b2lkIGtleV9hbGxvY19zZXJpYWwoc3RydWN0IGtleSAqa2V5KQogewpAQCAtMjExLDE4ICsyMDUsMzYgQEAKIAkJaWYgKGtleS0+c2VyaWFsIDwgeGtleS0+c2VyaWFsKQogCQkJZ290byBhdHRlbXB0X2luc2VydGlvbjsKIAl9Cit9CiAKLX0gLyogZW5kIGtleV9hbGxvY19zZXJpYWwoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi0vKgotICogYWxsb2NhdGUgYSBrZXkgb2YgdGhlIHNwZWNpZmllZCB0eXBlCi0gKiAtIHVwZGF0ZSB0aGUgdXNlcidzIHF1b3RhIHRvIHJlZmxlY3QgdGhlIGV4aXN0ZW5jZSBvZiB0aGUga2V5Ci0gKiAtIGNhbGxlZCBmcm9tIGEga2V5LXR5cGUgb3BlcmF0aW9uIHdpdGgga2V5X3R5cGVzX3NlbSByZWFkLWxvY2tlZCBieQotICogICBrZXlfY3JlYXRlX29yX3VwZGF0ZSgpCi0gKiAgIC0gdGhpcyBwcmV2ZW50cyB1bnJlZ2lzdHJhdGlvbiBvZiB0aGUga2V5IHR5cGUKLSAqIC0gdXBvbiByZXR1cm4gdGhlIGtleSBpcyBhcyB5ZXQgdW5pbnN0YW50aWF0ZWQ7IHRoZSBjYWxsZXIgbmVlZHMgdG8gZWl0aGVyCi0gKiAgIGluc3RhbnRpYXRlIHRoZSBrZXkgb3IgZGlzY2FyZCBpdCBiZWZvcmUgcmV0dXJuaW5nCisvKioKKyAqIGtleV9hbGxvYyAtIEFsbG9jYXRlIGEga2V5IG9mIHRoZSBzcGVjaWZpZWQgdHlwZS4KKyAqIEB0eXBlOiBUaGUgdHlwZSBvZiBrZXkgdG8gYWxsb2NhdGUuCisgKiBAZGVzYzogVGhlIGtleSBkZXNjcmlwdGlvbiB0byBhbGxvdyB0aGUga2V5IHRvIGJlIHNlYXJjaGVkIG91dC4KKyAqIEB1aWQ6IFRoZSBvd25lciBvZiB0aGUgbmV3IGtleS4KKyAqIEBnaWQ6IFRoZSBncm91cCBJRCBmb3IgdGhlIG5ldyBrZXkncyBncm91cCBwZXJtaXNzaW9ucy4KKyAqIEBjcmVkOiBUaGUgY3JlZGVudGlhbHMgc3BlY2lmeWluZyBVSUQgbmFtZXNwYWNlLgorICogQHBlcm06IFRoZSBwZXJtaXNzaW9ucyBtYXNrIG9mIHRoZSBuZXcga2V5LgorICogQGZsYWdzOiBGbGFncyBzcGVjaWZ5aW5nIHF1b3RhIHByb3BlcnRpZXMuCisgKgorICogQWxsb2NhdGUgYSBrZXkgb2YgdGhlIHNwZWNpZmllZCB0eXBlIHdpdGggdGhlIGF0dHJpYnV0ZXMgZ2l2ZW4uICBUaGUga2V5IGlzCisgKiByZXR1cm5lZCBpbiBhbiB1bmluc3RhbnRpYXRlZCBzdGF0ZSBhbmQgdGhlIGNhbGxlciBuZWVkcyB0byBpbnN0YW50aWF0ZSB0aGUKKyAqIGtleSBiZWZvcmUgcmV0dXJuaW5nLgorICoKKyAqIFRoZSB1c2VyJ3Mga2V5IGNvdW50IHF1b3RhIGlzIHVwZGF0ZWQgdG8gcmVmbGVjdCB0aGUgY3JlYXRpb24gb2YgdGhlIGtleSBhbmQKKyAqIHRoZSB1c2VyJ3Mga2V5IGRhdGEgcXVvdGEgaGFzIHRoZSBkZWZhdWx0IGZvciB0aGUga2V5IHR5cGUgcmVzZXJ2ZWQuICBUaGUKKyAqIGluc3RhbnRpYXRpb24gZnVuY3Rpb24gc2hvdWxkIGFtZW5kIHRoaXMgYXMgbmVjZXNzYXJ5LiAgSWYgaW5zdWZmaWNpZW50CisgKiBxdW90YSBpcyBhdmFpbGFibGUsIC1FRFFVT1Qgd2lsbCBiZSByZXR1cm5lZC4KKyAqCisgKiBUaGUgTFNNIHNlY3VyaXR5IG1vZHVsZXMgY2FuIHByZXZlbnQgYSBrZXkgYmVpbmcgY3JlYXRlZCwgaW4gd2hpY2ggY2FzZQorICogLUVBQ0NFUyB3aWxsIGJlIHJldHVybmVkLgorICoKKyAqIFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBuZXcga2V5IGlmIHN1Y2Nlc3NmdWwgYW5kIGFuIGVycm9yIGNvZGUgb3RoZXJ3aXNlLgorICoKKyAqIE5vdGUgdGhhdCB0aGUgY2FsbGVyIG5lZWRzIHRvIGVuc3VyZSB0aGUga2V5IHR5cGUgaXNuJ3QgdW5pbnN0YW50aWF0ZWQuCisgKiBJbnRlcm5hbGx5IHRoaXMgY2FuIGJlIGRvbmUgYnkgbG9ja2luZyBrZXlfdHlwZXNfc2VtLiAgRXh0ZXJuYWxseSwgdGhpcyBjYW4KKyAqIGJlIGRvbmUgYnkgZWl0aGVyIG5ldmVyIHVucmVnaXN0ZXJpbmcgdGhlIGtleSB0eXBlLCBvciBtYWtpbmcgc3VyZQorICoga2V5X2FsbG9jKCkgY2FsbHMgZG9uJ3QgcmFjZSB3aXRoIG1vZHVsZSB1bmxvYWRpbmcuCiAgKi8KIHN0cnVjdCBrZXkgKmtleV9hbGxvYyhzdHJ1Y3Qga2V5X3R5cGUgKnR5cGUsIGNvbnN0IGNoYXIgKmRlc2MsCiAJCSAgICAgIHVpZF90IHVpZCwgZ2lkX3QgZ2lkLCBjb25zdCBzdHJ1Y3QgY3JlZCAqY3JlZCwKQEAgLTM0NCwxNCArMzU2LDE5IEBACiAJa2V5X3VzZXJfcHV0KHVzZXIpOwogCWtleSA9IEVSUl9QVFIoLUVEUVVPVCk7CiAJZ290byBlcnJvcjsKLQotfSAvKiBlbmQga2V5X2FsbG9jKCkgKi8KLQorfQogRVhQT1JUX1NZTUJPTChrZXlfYWxsb2MpOwogCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi0vKgotICogcmVzZXJ2ZSBhbiBhbW91bnQgb2YgcXVvdGEgZm9yIHRoZSBrZXkncyBwYXlsb2FkCisvKioKKyAqIGtleV9wYXlsb2FkX3Jlc2VydmUgLSBBZGp1c3QgZGF0YSBxdW90YSByZXNlcnZhdGlvbiBmb3IgdGhlIGtleSdzIHBheWxvYWQKKyAqIEBrZXk6IFRoZSBrZXkgdG8gbWFrZSB0aGUgcmVzZXJ2YXRpb24gZm9yLgorICogQGRhdGFsZW46IFRoZSBhbW91bnQgb2YgZGF0YSBwYXlsb2FkIHRoZSBjYWxsZXIgbm93IHdhbnRzLgorICoKKyAqIEFkanVzdCB0aGUgYW1vdW50IG9mIHRoZSBvd25pbmcgdXNlcidzIGtleSBkYXRhIHF1b3RhIHRoYXQgYSBrZXkgcmVzZXJ2ZXMuCisgKiBJZiB0aGUgYW1vdW50IGlzIGluY3JlYXNlZCwgdGhlbiAtRURRVU9UIG1heSBiZSByZXR1cm5lZCBpZiB0aGVyZSBpc24ndAorICogZW5vdWdoIGZyZWUgcXVvdGEgYXZhaWxhYmxlLgorICoKKyAqIElmIHN1Y2Nlc3NmdWwsIDAgaXMgcmV0dXJuZWQuCiAgKi8KIGludCBrZXlfcGF5bG9hZF9yZXNlcnZlKHN0cnVjdCBrZXkgKmtleSwgc2l6ZV90IGRhdGFsZW4pCiB7CkBAIC0zODQsMjIgKzQwMSwyMSBAQAogCQlrZXktPmRhdGFsZW4gPSBkYXRhbGVuOwogCiAJcmV0dXJuIHJldDsKLQotfSAvKiBlbmQga2V5X3BheWxvYWRfcmVzZXJ2ZSgpICovCi0KK30KIEVYUE9SVF9TWU1CT0woa2V5X3BheWxvYWRfcmVzZXJ2ZSk7CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBpbnN0YW50aWF0ZSBhIGtleSBhbmQgbGluayBpdCBpbnRvIHRoZSB0YXJnZXQga2V5cmluZyBhdG9taWNhbGx5Ci0gKiAtIGNhbGxlZCB3aXRoIHRoZSB0YXJnZXQga2V5cmluZydzIHNlbWFwaG9yZSB3cml0ZWxvY2tlZAorICogSW5zdGFudGlhdGUgYSBrZXkgYW5kIGxpbmsgaXQgaW50byB0aGUgdGFyZ2V0IGtleXJpbmcgYXRvbWljYWxseS4gIE11c3QgYmUKKyAqIGNhbGxlZCB3aXRoIHRoZSB0YXJnZXQga2V5cmluZydzIHNlbWFwaG9yZSB3cml0ZWxvY2tlZC4gIFRoZSB0YXJnZXQga2V5J3MKKyAqIHNlbWFwaG9yZSBuZWVkIG5vdCBiZSBsb2NrZWQgYXMgaW5zdGFudGlhdGlvbiBpcyBzZXJpYWxpc2VkIGJ5CisgKiBrZXlfY29uc3RydWN0aW9uX211dGV4LgogICovCiBzdGF0aWMgaW50IF9fa2V5X2luc3RhbnRpYXRlX2FuZF9saW5rKHN0cnVjdCBrZXkgKmtleSwKIAkJCQkgICAgICBjb25zdCB2b2lkICpkYXRhLAogCQkJCSAgICAgIHNpemVfdCBkYXRhbGVuLAogCQkJCSAgICAgIHN0cnVjdCBrZXkgKmtleXJpbmcsCiAJCQkJICAgICAgc3RydWN0IGtleSAqYXV0aGtleSwKLQkJCQkgICAgICBzdHJ1Y3Qga2V5cmluZ19saXN0ICoqX3ByZWFsbG9jKQorCQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgKl9wcmVhbGxvYykKIHsKIAlpbnQgcmV0LCBhd2FrZW47CiAKQEAgLTQ0MSwxMiArNDU3LDIzIEBACiAJCXdha2VfdXBfYml0KCZrZXktPmZsYWdzLCBLRVlfRkxBR19VU0VSX0NPTlNUUlVDVCk7CiAKIAlyZXR1cm4gcmV0OworfQogCi19IC8qIGVuZCBfX2tleV9pbnN0YW50aWF0ZV9hbmRfbGluaygpICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLS8qCi0gKiBpbnN0YW50aWF0ZSBhIGtleSBhbmQgbGluayBpdCBpbnRvIHRoZSB0YXJnZXQga2V5cmluZyBhdG9taWNhbGx5CisvKioKKyAqIGtleV9pbnN0YW50aWF0ZV9hbmRfbGluayAtIEluc3RhbnRpYXRlIGEga2V5IGFuZCBsaW5rIGl0IGludG8gdGhlIGtleXJpbmcuCisgKiBAa2V5OiBUaGUga2V5IHRvIGluc3RhbnRpYXRlLgorICogQGRhdGE6IFRoZSBkYXRhIHRvIHVzZSB0byBpbnN0YW50aWF0ZSB0aGUga2V5cmluZy4KKyAqIEBkYXRhbGVuOiBUaGUgbGVuZ3RoIG9mIEBkYXRhLgorICogQGtleXJpbmc6IEtleXJpbmcgdG8gY3JlYXRlIGEgbGluayBpbiBvbiBzdWNjZXNzIChvciBOVUxMKS4KKyAqIEBhdXRoa2V5OiBUaGUgYXV0aG9yaXNhdGlvbiB0b2tlbiBwZXJtaXR0aW5nIGluc3RhbnRpYXRpb24uCisgKgorICogSW5zdGFudGlhdGUgYSBrZXkgdGhhdCdzIGluIHRoZSB1bmluc3RhbnRpYXRlZCBzdGF0ZSB1c2luZyB0aGUgcHJvdmlkZWQgZGF0YQorICogYW5kLCBpZiBzdWNjZXNzZnVsLCBsaW5rIGl0IGluIHRvIHRoZSBkZXN0aW5hdGlvbiBrZXlyaW5nIGlmIG9uZSBpcworICogc3VwcGxpZWQuCisgKgorICogSWYgc3VjY2Vzc2Z1bCwgMCBpcyByZXR1cm5lZCwgdGhlIGF1dGhvcmlzYXRpb24gdG9rZW4gaXMgcmV2b2tlZCBhbmQgYW55b25lCisgKiB3YWl0aW5nIGZvciB0aGUga2V5IGlzIHdva2VuIHVwLiAgSWYgdGhlIGtleSB3YXMgYWxyZWFkeSBpbnN0YW50aWF0ZWQsCisgKiAtRUJVU1kgd2lsbCBiZSByZXR1cm5lZC4KICAqLwogaW50IGtleV9pbnN0YW50aWF0ZV9hbmRfbGluayhzdHJ1Y3Qga2V5ICprZXksCiAJCQkgICAgIGNvbnN0IHZvaWQgKmRhdGEsCkBAIC00NTQsNyArNDgxLDcgQEAKIAkJCSAgICAgc3RydWN0IGtleSAqa2V5cmluZywKIAkJCSAgICAgc3RydWN0IGtleSAqYXV0aGtleSkKIHsKLQlzdHJ1Y3Qga2V5cmluZ19saXN0ICpwcmVhbGxvYzsKKwl1bnNpZ25lZCBsb25nIHByZWFsbG9jOwogCWludCByZXQ7CiAKIAlpZiAoa2V5cmluZykgewpAQCAtNDcxLDIxICs0OTgsMzUgQEAKIAkJX19rZXlfbGlua19lbmQoa2V5cmluZywga2V5LT50eXBlLCBwcmVhbGxvYyk7CiAKIAlyZXR1cm4gcmV0OwotCi19IC8qIGVuZCBrZXlfaW5zdGFudGlhdGVfYW5kX2xpbmsoKSAqLworfQogCiBFWFBPUlRfU1lNQk9MKGtleV9pbnN0YW50aWF0ZV9hbmRfbGluayk7CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLS8qCi0gKiBuZWdhdGl2ZWx5IGluc3RhbnRpYXRlIGEga2V5IGFuZCBsaW5rIGl0IGludG8gdGhlIHRhcmdldCBrZXlyaW5nIGF0b21pY2FsbHkKKy8qKgorICoga2V5X25lZ2F0ZV9hbmRfbGluayAtIE5lZ2F0aXZlbHkgaW5zdGFudGlhdGUgYSBrZXkgYW5kIGxpbmsgaXQgaW50byB0aGUga2V5cmluZy4KKyAqIEBrZXk6IFRoZSBrZXkgdG8gaW5zdGFudGlhdGUuCisgKiBAdGltZW91dDogVGhlIHRpbWVvdXQgb24gdGhlIG5lZ2F0aXZlIGtleS4KKyAqIEBrZXlyaW5nOiBLZXlyaW5nIHRvIGNyZWF0ZSBhIGxpbmsgaW4gb24gc3VjY2VzcyAob3IgTlVMTCkuCisgKiBAYXV0aGtleTogVGhlIGF1dGhvcmlzYXRpb24gdG9rZW4gcGVybWl0dGluZyBpbnN0YW50aWF0aW9uLgorICoKKyAqIE5lZ2F0aXZlbHkgaW5zdGFudGlhdGUgYSBrZXkgdGhhdCdzIGluIHRoZSB1bmluc3RhbnRpYXRlZCBzdGF0ZSBhbmQsIGlmCisgKiBzdWNjZXNzZnVsLCBzZXQgaXRzIHRpbWVvdXQgYW5kIGxpbmsgaXQgaW4gdG8gdGhlIGRlc3RpbmF0aW9uIGtleXJpbmcgaWYgb25lCisgKiBpcyBzdXBwbGllZC4gIFRoZSBrZXkgYW5kIGFueSBsaW5rcyB0byB0aGUga2V5IHdpbGwgYmUgYXV0b21hdGljYWxseSBnYXJiYWdlCisgKiBjb2xsZWN0ZWQgYWZ0ZXIgdGhlIHRpbWVvdXQgZXhwaXJlcy4KKyAqCisgKiBOZWdhdGl2ZSBrZXlzIGFyZSB1c2VkIHRvIHJhdGUgbGltaXQgcmVwZWF0ZWQgcmVxdWVzdF9rZXkoKSBjYWxscyBieSBjYXVzaW5nCisgKiB0aGVtIHRvIHJldHVybiAtRU5PS0VZIHVudGlsIHRoZSBuZWdhdGl2ZSBrZXkgZXhwaXJlcy4KKyAqCisgKiBJZiBzdWNjZXNzZnVsLCAwIGlzIHJldHVybmVkLCB0aGUgYXV0aG9yaXNhdGlvbiB0b2tlbiBpcyByZXZva2VkIGFuZCBhbnlvbmUKKyAqIHdhaXRpbmcgZm9yIHRoZSBrZXkgaXMgd29rZW4gdXAuICBJZiB0aGUga2V5IHdhcyBhbHJlYWR5IGluc3RhbnRpYXRlZCwKKyAqIC1FQlVTWSB3aWxsIGJlIHJldHVybmVkLgogICovCiBpbnQga2V5X25lZ2F0ZV9hbmRfbGluayhzdHJ1Y3Qga2V5ICprZXksCiAJCQl1bnNpZ25lZCB0aW1lb3V0LAogCQkJc3RydWN0IGtleSAqa2V5cmluZywKIAkJCXN0cnVjdCBrZXkgKmF1dGhrZXkpCiB7Ci0Jc3RydWN0IGtleXJpbmdfbGlzdCAqcHJlYWxsb2M7CisJdW5zaWduZWQgbG9uZyBwcmVhbGxvYzsKIAlzdHJ1Y3QgdGltZXNwZWMgbm93OwogCWludCByZXQsIGF3YWtlbiwgbGlua19yZXQgPSAwOwogCkBAIC01MzUsMjIgKzU3NiwyMyBAQAogCQl3YWtlX3VwX2JpdCgma2V5LT5mbGFncywgS0VZX0ZMQUdfVVNFUl9DT05TVFJVQ1QpOwogCiAJcmV0dXJuIHJldCA9PSAwID8gbGlua19yZXQgOiByZXQ7Ci0KLX0gLyogZW5kIGtleV9uZWdhdGVfYW5kX2xpbmsoKSAqLworfQogCiBFWFBPUlRfU1lNQk9MKGtleV9uZWdhdGVfYW5kX2xpbmspOwogCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogZG8gY2xlYW5pbmcgdXAgaW4gcHJvY2VzcyBjb250ZXh0IHNvIHRoYXQgd2UgZG9uJ3QgaGF2ZSB0byBkaXNhYmxlCi0gKiBpbnRlcnJ1cHRzIGFsbCBvdmVyIHRoZSBwbGFjZQorICogR2FyYmFnZSBjb2xsZWN0IGtleXMgaW4gcHJvY2VzcyBjb250ZXh0IHNvIHRoYXQgd2UgZG9uJ3QgaGF2ZSB0byBkaXNhYmxlCisgKiBpbnRlcnJ1cHRzIGFsbCBvdmVyIHRoZSBwbGFjZS4KKyAqCisgKiBrZXlfcHV0KCkgc2NoZWR1bGVzIHRoaXMgcmF0aGVyIHRoYW4gdHJ5aW5nIHRvIGRvIHRoZSBjbGVhbnVwIGl0c2VsZiwgd2hpY2gKKyAqIG1lYW5zIGtleV9wdXQoKSBkb2Vzbid0IGhhdmUgdG8gc2xlZXAuCiAgKi8KIHN0YXRpYyB2b2lkIGtleV9jbGVhbnVwKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKIHsKIAlzdHJ1Y3QgcmJfbm9kZSAqX247CiAJc3RydWN0IGtleSAqa2V5OwogCi0gZ29fYWdhaW46Citnb19hZ2FpbjoKIAkvKiBsb29rIGZvciBhIGRlYWQga2V5IGluIHRoZSB0cmVlICovCiAJc3Bpbl9sb2NrKCZrZXlfc2VyaWFsX2xvY2spOwogCkBAIC01NjQsNyArNjA2LDcgQEAKIAlzcGluX3VubG9jaygma2V5X3NlcmlhbF9sb2NrKTsKIAlyZXR1cm47CiAKLSBmb3VuZF9kZWFkX2tleToKK2ZvdW5kX2RlYWRfa2V5OgogCS8qIHdlIGZvdW5kIGEgZGVhZCBrZXkgLSBvbmNlIHdlJ3ZlIHJlbW92ZWQgaXQgZnJvbSB0aGUgdHJlZSwgd2UgY2FuCiAJICogZHJvcCB0aGUgbG9jayAqLwogCXJiX2VyYXNlKCZrZXktPnNlcmlhbF9ub2RlLCAma2V5X3NlcmlhbF90cmVlKTsKQEAgLTYwMSwxNCArNjQzLDE1IEBACiAKIAkvKiB0aGVyZSBtYXksIG9mIGNvdXJzZSwgYmUgbW9yZSB0aGFuIG9uZSBrZXkgdG8gZGVzdHJveSAqLwogCWdvdG8gZ29fYWdhaW47Cit9CiAKLX0gLyogZW5kIGtleV9jbGVhbnVwKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotLyoKLSAqIGRpc3Bvc2Ugb2YgYSByZWZlcmVuY2UgdG8gYSBrZXkKLSAqIC0gd2hlbiBhbGwgdGhlIHJlZmVyZW5jZXMgYXJlIGdvbmUsIHdlIHNjaGVkdWxlIHRoZSBjbGVhbnVwIHRhc2sgdG8gY29tZSBhbmQKLSAqICAgcHVsbCBpdCBvdXQgb2YgdGhlIHRyZWUgaW4gZGVmaW5pdGUgcHJvY2VzcyBjb250ZXh0CisvKioKKyAqIGtleV9wdXQgLSBEaXNjYXJkIGEgcmVmZXJlbmNlIHRvIGEga2V5LgorICogQGtleTogVGhlIGtleSB0byBkaXNjYXJkIGEgcmVmZXJlbmNlIGZyb20uCisgKgorICogRGlzY2FyZCBhIHJlZmVyZW5jZSB0byBhIGtleSwgYW5kIHdoZW4gYWxsIHRoZSByZWZlcmVuY2VzIGFyZSBnb25lLCB3ZQorICogc2NoZWR1bGUgdGhlIGNsZWFudXAgdGFzayB0byBjb21lIGFuZCBwdWxsIGl0IG91dCBvZiB0aGUgdHJlZSBpbiBwcm9jZXNzCisgKiBjb250ZXh0IGF0IHNvbWUgbGF0ZXIgdGltZS4KICAqLwogdm9pZCBrZXlfcHV0KHN0cnVjdCBrZXkgKmtleSkKIHsKQEAgLTYxOCwxNCArNjYxLDExIEBACiAJCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZrZXktPnVzYWdlKSkKIAkJCXNjaGVkdWxlX3dvcmsoJmtleV9jbGVhbnVwX3Rhc2spOwogCX0KLQotfSAvKiBlbmQga2V5X3B1dCgpICovCi0KK30KIEVYUE9SVF9TWU1CT0woa2V5X3B1dCk7CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBmaW5kIGEga2V5IGJ5IGl0cyBzZXJpYWwgbnVtYmVyCisgKiBGaW5kIGEga2V5IGJ5IGl0cyBzZXJpYWwgbnVtYmVyLgogICovCiBzdHJ1Y3Qga2V5ICprZXlfbG9va3VwKGtleV9zZXJpYWxfdCBpZCkKIHsKQEAgLTY0NywxMSArNjg3LDExIEBACiAJCQlnb3RvIGZvdW5kOwogCX0KIAotIG5vdF9mb3VuZDoKK25vdF9mb3VuZDoKIAlrZXkgPSBFUlJfUFRSKC1FTk9LRVkpOwogCWdvdG8gZXJyb3I7CiAKLSBmb3VuZDoKK2ZvdW5kOgogCS8qIHByZXRlbmQgaXQgZG9lc24ndCBleGlzdCBpZiBpdCBpcyBhd2FpdGluZyBkZWxldGlvbiAqLwogCWlmIChhdG9taWNfcmVhZCgma2V5LT51c2FnZSkgPT0gMCkKIAkJZ290byBub3RfZm91bmQ7CkBAIC02NjEsMTYgKzcwMSwxNiBAQAogCSAqLwogCWF0b21pY19pbmMoJmtleS0+dXNhZ2UpOwogCi0gZXJyb3I6CitlcnJvcjoKIAlzcGluX3VubG9jaygma2V5X3NlcmlhbF9sb2NrKTsKIAlyZXR1cm4ga2V5OworfQogCi19IC8qIGVuZCBrZXlfbG9va3VwKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIGZpbmQgYW5kIGxvY2sgdGhlIHNwZWNpZmllZCBrZXkgdHlwZSBhZ2FpbnN0IHJlbW92YWwKLSAqIC0gd2UgcmV0dXJuIHdpdGggdGhlIHNlbSByZWFkbG9ja2VkCisgKiBGaW5kIGFuZCBsb2NrIHRoZSBzcGVjaWZpZWQga2V5IHR5cGUgYWdhaW5zdCByZW1vdmFsLgorICoKKyAqIFdlIHJldHVybiB3aXRoIHRoZSBzZW0gcmVhZC1sb2NrZWQgaWYgc3VjY2Vzc2Z1bC4gIElmIHRoZSB0eXBlIHdhc24ndAorICogYXZhaWxhYmxlIC1FTk9LRVkgaXMgcmV0dXJuZWQgaW5zdGVhZC4KICAqLwogc3RydWN0IGtleV90eXBlICprZXlfdHlwZV9sb29rdXAoY29uc3QgY2hhciAqdHlwZSkKIHsKQEAgLTY4OCwyNiArNzI4LDIzIEBACiAJdXBfcmVhZCgma2V5X3R5cGVzX3NlbSk7CiAJa3R5cGUgPSBFUlJfUFRSKC1FTk9LRVkpOwogCi0gZm91bmRfa2VybmVsX3R5cGU6Citmb3VuZF9rZXJuZWxfdHlwZToKIAlyZXR1cm4ga3R5cGU7Cit9CiAKLX0gLyogZW5kIGtleV90eXBlX2xvb2t1cCgpICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiB1bmxvY2sgYSBrZXkgdHlwZQorICogVW5sb2NrIGEga2V5IHR5cGUgbG9ja2VkIGJ5IGtleV90eXBlX2xvb2t1cCgpLgogICovCiB2b2lkIGtleV90eXBlX3B1dChzdHJ1Y3Qga2V5X3R5cGUgKmt0eXBlKQogewogCXVwX3JlYWQoJmtleV90eXBlc19zZW0pOworfQogCi19IC8qIGVuZCBrZXlfdHlwZV9wdXQoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogYXR0ZW1wdCB0byB1cGRhdGUgYW4gZXhpc3Rpbmcga2V5Ci0gKiAtIHRoZSBrZXkgaGFzIGFuIGluY3JlbWVudGVkIHJlZmNvdW50Ci0gKiAtIHdlIG5lZWQgdG8gcHV0IHRoZSBrZXkgaWYgd2UgZ2V0IGFuIGVycm9yCisgKiBBdHRlbXB0IHRvIHVwZGF0ZSBhbiBleGlzdGluZyBrZXkuCisgKgorICogVGhlIGtleSBpcyBnaXZlbiB0byB1cyB3aXRoIGFuIGluY3JlbWVudGVkIHJlZmNvdW50IHRoYXQgd2UgbmVlZCB0byBkaXNjYXJkCisgKiBpZiB3ZSBnZXQgYW4gZXJyb3IuCiAgKi8KIHN0YXRpYyBpbmxpbmUga2V5X3JlZl90IF9fa2V5X3VwZGF0ZShrZXlfcmVmX3Qga2V5X3JlZiwKIAkJCQkgICAgIGNvbnN0IHZvaWQgKnBheWxvYWQsIHNpemVfdCBwbGVuKQpAQCAtNzQyLDEzICs3NzksMzIgQEAKIAlrZXlfcHV0KGtleSk7CiAJa2V5X3JlZiA9IEVSUl9QVFIocmV0KTsKIAlnb3RvIG91dDsKK30KIAotfSAvKiBlbmQgX19rZXlfdXBkYXRlKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotLyoKLSAqIHNlYXJjaCB0aGUgc3BlY2lmaWVkIGtleXJpbmcgZm9yIGEga2V5IG9mIHRoZSBzYW1lIGRlc2NyaXB0aW9uOyBpZiBvbmUgaXMKLSAqIGZvdW5kLCB1cGRhdGUgaXQsIG90aGVyd2lzZSBhZGQgYSBuZXcgb25lCisvKioKKyAqIGtleV9jcmVhdGVfb3JfdXBkYXRlIC0gVXBkYXRlIG9yIGNyZWF0ZSBhbmQgaW5zdGFudGlhdGUgYSBrZXkuCisgKiBAa2V5cmluZ19yZWY6IEEgcG9pbnRlciB0byB0aGUgZGVzdGluYXRpb24ga2V5cmluZyB3aXRoIHBvc3Nlc3Npb24gZmxhZy4KKyAqIEB0eXBlOiBUaGUgdHlwZSBvZiBrZXkuCisgKiBAZGVzY3JpcHRpb246IFRoZSBzZWFyY2hhYmxlIGRlc2NyaXB0aW9uIGZvciB0aGUga2V5LgorICogQHBheWxvYWQ6IFRoZSBkYXRhIHRvIHVzZSB0byBpbnN0YW50aWF0ZSBvciB1cGRhdGUgdGhlIGtleS4KKyAqIEBwbGVuOiBUaGUgbGVuZ3RoIG9mIEBwYXlsb2FkLgorICogQHBlcm06IFRoZSBwZXJtaXNzaW9ucyBtYXNrIGZvciBhIG5ldyBrZXkuCisgKiBAZmxhZ3M6IFRoZSBxdW90YSBmbGFncyBmb3IgYSBuZXcga2V5LgorICoKKyAqIFNlYXJjaCB0aGUgZGVzdGluYXRpb24ga2V5cmluZyBmb3IgYSBrZXkgb2YgdGhlIHNhbWUgZGVzY3JpcHRpb24gYW5kIGlmIG9uZQorICogaXMgZm91bmQsIHVwZGF0ZSBpdCwgb3RoZXJ3aXNlIGNyZWF0ZSBhbmQgaW5zdGFudGlhdGUgYSBuZXcgb25lIGFuZCBjcmVhdGUgYQorICogbGluayB0byBpdCBmcm9tIHRoYXQga2V5cmluZy4KKyAqCisgKiBJZiBwZXJtIGlzIEtFWV9QRVJNX1VOREVGIHRoZW4gYW4gYXBwcm9wcmlhdGUga2V5IHBlcm1pc3Npb25zIG1hc2sgd2lsbCBiZQorICogY29uY29jdGVkLgorICoKKyAqIFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBuZXcga2V5IGlmIHN1Y2Nlc3NmdWwsIC1FTk9ERVYgaWYgdGhlIGtleSB0eXBlCisgKiB3YXNuJ3QgYXZhaWxhYmxlLCAtRU5PVERJUiBpZiB0aGUga2V5cmluZyB3YXNuJ3QgYSBrZXlyaW5nLCAtRUFDQ0VTIGlmIHRoZQorICogY2FsbGVyIGlzbid0IHBlcm1pdHRlZCB0byBtb2RpZnkgdGhlIGtleXJpbmcgb3IgdGhlIExTTSBkaWQgbm90IHBlcm1pdAorICogY3JlYXRpb24gb2YgdGhlIGtleS4KKyAqCisgKiBPbiBzdWNjZXNzLCB0aGUgcG9zc2Vzc2lvbiBmbGFnIGZyb20gdGhlIGtleXJpbmcgcmVmIHdpbGwgYmUgdGFja2VkIG9uIHRvCisgKiB0aGUga2V5IHJlZiBiZWZvcmUgaXQgaXMgcmV0dXJuZWQuCiAgKi8KIGtleV9yZWZfdCBrZXlfY3JlYXRlX29yX3VwZGF0ZShrZXlfcmVmX3Qga2V5cmluZ19yZWYsCiAJCQkgICAgICAgY29uc3QgY2hhciAqdHlwZSwKQEAgLTc1OCw3ICs4MTQsNyBAQAogCQkJICAgICAgIGtleV9wZXJtX3QgcGVybSwKIAkJCSAgICAgICB1bnNpZ25lZCBsb25nIGZsYWdzKQogewotCXN0cnVjdCBrZXlyaW5nX2xpc3QgKnByZWFsbG9jOworCXVuc2lnbmVkIGxvbmcgcHJlYWxsb2M7CiAJY29uc3Qgc3RydWN0IGNyZWQgKmNyZWQgPSBjdXJyZW50X2NyZWQoKTsKIAlzdHJ1Y3Qga2V5X3R5cGUgKmt0eXBlOwogCXN0cnVjdCBrZXkgKmtleXJpbmcsICprZXkgPSBOVUxMOwpAQCAtODU1LDE0ICs5MTEsMjEgQEAKIAogCWtleV9yZWYgPSBfX2tleV91cGRhdGUoa2V5X3JlZiwgcGF5bG9hZCwgcGxlbik7CiAJZ290byBlcnJvcjsKLQotfSAvKiBlbmQga2V5X2NyZWF0ZV9vcl91cGRhdGUoKSAqLwotCit9CiBFWFBPUlRfU1lNQk9MKGtleV9jcmVhdGVfb3JfdXBkYXRlKTsKIAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotLyoKLSAqIHVwZGF0ZSBhIGtleQorLyoqCisgKiBrZXlfdXBkYXRlIC0gVXBkYXRlIGEga2V5J3MgY29udGVudHMuCisgKiBAa2V5X3JlZjogVGhlIHBvaW50ZXIgKHBsdXMgcG9zc2Vzc2lvbiBmbGFnKSB0byB0aGUga2V5LgorICogQHBheWxvYWQ6IFRoZSBkYXRhIHRvIGJlIHVzZWQgdG8gdXBkYXRlIHRoZSBrZXkuCisgKiBAcGxlbjogVGhlIGxlbmd0aCBvZiBAcGF5bG9hZC4KKyAqCisgKiBBdHRlbXB0IHRvIHVwZGF0ZSB0aGUgY29udGVudHMgb2YgYSBrZXkgd2l0aCB0aGUgZ2l2ZW4gcGF5bG9hZCBkYXRhLiAgVGhlCisgKiBjYWxsZXIgbXVzdCBiZSBncmFudGVkIFdyaXRlIHBlcm1pc3Npb24gb24gdGhlIGtleS4gIE5lZ2F0aXZlIGtleXMgY2FuIGJlCisgKiBpbnN0YW50aWF0ZWQgYnkgdGhpcyBtZXRob2QuCisgKgorICogUmV0dXJucyAwIG9uIHN1Y2Nlc3MsIC1FQUNDRVMgaWYgbm90IHBlcm1pdHRlZCBhbmQgLUVPUE5PVFNVUFAgaWYgdGhlIGtleQorICogdHlwZSBkb2VzIG5vdCBzdXBwb3J0IHVwZGF0aW5nLiAgVGhlIGtleSB0eXBlIG1heSByZXR1cm4gb3RoZXIgZXJyb3JzLgogICovCiBpbnQga2V5X3VwZGF0ZShrZXlfcmVmX3Qga2V5X3JlZiwgY29uc3Qgdm9pZCAqcGF5bG9hZCwgc2l6ZV90IHBsZW4pCiB7CkBAIC04OTEsMTQgKzk1NCwxNyBAQAogCiAgZXJyb3I6CiAJcmV0dXJuIHJldDsKLQotfSAvKiBlbmQga2V5X3VwZGF0ZSgpICovCi0KK30KIEVYUE9SVF9TWU1CT0woa2V5X3VwZGF0ZSk7CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLS8qCi0gKiByZXZva2UgYSBrZXkKKy8qKgorICoga2V5X3Jldm9rZSAtIFJldm9rZSBhIGtleS4KKyAqIEBrZXk6IFRoZSBrZXkgdG8gYmUgcmV2b2tlZC4KKyAqCisgKiBNYXJrIGEga2V5IGFzIGJlaW5nIHJldm9rZWQgYW5kIGFzayB0aGUgdHlwZSB0byBmcmVlIHVwIGl0cyByZXNvdXJjZXMuICBUaGUKKyAqIHJldm9jYXRpb24gdGltZW91dCBpcyBzZXQgYW5kIHRoZSBrZXkgYW5kIGFsbCBpdHMgbGlua3Mgd2lsbCBiZQorICogYXV0b21hdGljYWxseSBnYXJiYWdlIGNvbGxlY3RlZCBhZnRlciBrZXlfZ2NfZGVsYXkgYW1vdW50IG9mIHRpbWUgaWYgdGhleQorICogYXJlIG5vdCBtYW51YWxseSBkZWFsdCB3aXRoIGZpcnN0LgogICovCiB2b2lkIGtleV9yZXZva2Uoc3RydWN0IGtleSAqa2V5KQogewpAQCAtOTI2LDE0ICs5OTIsMTYgQEAKIAl9CiAKIAl1cF93cml0ZSgma2V5LT5zZW0pOwotCi19IC8qIGVuZCBrZXlfcmV2b2tlKCkgKi8KLQorfQogRVhQT1JUX1NZTUJPTChrZXlfcmV2b2tlKTsKIAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotLyoKLSAqIHJlZ2lzdGVyIGEgdHlwZSBvZiBrZXkKKy8qKgorICogcmVnaXN0ZXJfa2V5X3R5cGUgLSBSZWdpc3RlciBhIHR5cGUgb2Yga2V5LgorICogQGt0eXBlOiBUaGUgbmV3IGtleSB0eXBlLgorICoKKyAqIFJlZ2lzdGVyIGEgbmV3IGtleSB0eXBlLgorICoKKyAqIFJldHVybnMgMCBvbiBzdWNjZXNzIG9yIC1FRVhJU1QgaWYgYSB0eXBlIG9mIHRoaXMgbmFtZSBhbHJlYWR5IGV4aXN0cy4KICAqLwogaW50IHJlZ2lzdGVyX2tleV90eXBlKHN0cnVjdCBrZXlfdHlwZSAqa3R5cGUpCiB7CkBAIC05NTMsMTcgKzEwMjEsMTkgQEAKIAlsaXN0X2FkZCgma3R5cGUtPmxpbmssICZrZXlfdHlwZXNfbGlzdCk7CiAJcmV0ID0gMDsKIAotIG91dDoKK291dDoKIAl1cF93cml0ZSgma2V5X3R5cGVzX3NlbSk7CiAJcmV0dXJuIHJldDsKLQotfSAvKiBlbmQgcmVnaXN0ZXJfa2V5X3R5cGUoKSAqLwotCit9CiBFWFBPUlRfU1lNQk9MKHJlZ2lzdGVyX2tleV90eXBlKTsKIAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotLyoKLSAqIHVucmVnaXN0ZXIgYSB0eXBlIG9mIGtleQorLyoqCisgKiB1bnJlZ2lzdGVyX2tleV90eXBlIC0gVW5yZWdpc3RlciBhIHR5cGUgb2Yga2V5LgorICogQGt0eXBlOiBUaGUga2V5IHR5cGUuCisgKgorICogVW5yZWdpc3RlciBhIGtleSB0eXBlIGFuZCBtYXJrIGFsbCB0aGUgZXh0YW50IGtleXMgb2YgdGhpcyB0eXBlIGFzIGRlYWQuCisgKiBUaG9zZSBrZXlzIG9mIHRoaXMgdHlwZSBhcmUgdGhlbiBkZXN0cm95ZWQgdG8gZ2V0IHJpZCBvZiB0aGVpciBwYXlsb2FkcyBhbmQKKyAqIHRoZXkgYW5kIHRoZWlyIGxpbmtzIHdpbGwgYmUgZ2FyYmFnZSBjb2xsZWN0ZWQgYXMgc29vbiBhcyBwb3NzaWJsZS4KICAqLwogdm9pZCB1bnJlZ2lzdGVyX2tleV90eXBlKHN0cnVjdCBrZXlfdHlwZSAqa3R5cGUpCiB7CkBAIC0xMDEwLDE0ICsxMDgwLDExIEBACiAJdXBfd3JpdGUoJmtleV90eXBlc19zZW0pOwogCiAJa2V5X3NjaGVkdWxlX2djKDApOwotCi19IC8qIGVuZCB1bnJlZ2lzdGVyX2tleV90eXBlKCkgKi8KLQorfQogRVhQT1JUX1NZTUJPTCh1bnJlZ2lzdGVyX2tleV90eXBlKTsKIAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIGluaXRpYWxpc2UgdGhlIGtleSBtYW5hZ2VtZW50IHN0dWZmCisgKiBJbml0aWFsaXNlIHRoZSBrZXkgbWFuYWdlbWVudCBzdGF0ZS4KICAqLwogdm9pZCBfX2luaXQga2V5X2luaXQodm9pZCkKIHsKQEAgLTEwMzcsNSArMTEwNCw0IEBACiAKIAlyYl9pbnNlcnRfY29sb3IoJnJvb3Rfa2V5X3VzZXIubm9kZSwKIAkJCSZrZXlfdXNlcl90cmVlKTsKLQotfSAvKiBlbmQga2V5X2luaXQoKSAqLworfQpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkva2V5cy9rZXljdGwuYyBiL3NlY3VyaXR5L2tleXMva2V5Y3RsLmMKaW5kZXggNjA5MjRmNi4uMzFhMGZkOCAxMDA2NDQKLS0tIGEvc2VjdXJpdHkva2V5cy9rZXljdGwuYworKysgYi9zZWN1cml0eS9rZXlzL2tleWN0bC5jCkBAIC0xLDQgKzEsNCBAQAotLyoga2V5Y3RsLmM6IHVzZXJzcGFjZSBrZXljdGwgb3BlcmF0aW9ucworLyogVXNlcnNwYWNlIGtleSBjb250cm9sIG9wZXJhdGlvbnMKICAqCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDQtNSBSZWQgSGF0LCBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAgKiBXcml0dGVuIGJ5IERhdmlkIEhvd2VsbHMgKGRob3dlbGxzQHJlZGhhdC5jb20pCkBAIC0zMSwyOCArMzEsMjQgQEAKIAlpbnQgcmV0OwogCiAJcmV0ID0gc3RybmNweV9mcm9tX3VzZXIodHlwZSwgX3R5cGUsIGxlbik7Ci0KIAlpZiAocmV0IDwgMCkKIAkJcmV0dXJuIHJldDsKLQogCWlmIChyZXQgPT0gMCB8fCByZXQgPj0gbGVuKQogCQlyZXR1cm4gLUVJTlZBTDsKLQogCWlmICh0eXBlWzBdID09ICcuJykKIAkJcmV0dXJuIC1FUEVSTTsKLQogCXR5cGVbbGVuIC0gMV0gPSAnXDAnOwotCiAJcmV0dXJuIDA7CiB9CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBleHRyYWN0IHRoZSBkZXNjcmlwdGlvbiBvZiBhIG5ldyBrZXkgZnJvbSB1c2Vyc3BhY2UgYW5kIGVpdGhlciBhZGQgaXQgYXMgYQotICogbmV3IGtleSB0byB0aGUgc3BlY2lmaWVkIGtleXJpbmcgb3IgdXBkYXRlIGEgbWF0Y2hpbmcga2V5IGluIHRoYXQga2V5cmluZwotICogLSB0aGUga2V5cmluZyBtdXN0IGJlIHdyaXRhYmxlCi0gKiAtIHJldHVybnMgdGhlIG5ldyBrZXkncyBzZXJpYWwgbnVtYmVyCi0gKiAtIGltcGxlbWVudHMgYWRkX2tleSgpCisgKiBFeHRyYWN0IHRoZSBkZXNjcmlwdGlvbiBvZiBhIG5ldyBrZXkgZnJvbSB1c2Vyc3BhY2UgYW5kIGVpdGhlciBhZGQgaXQgYXMgYQorICogbmV3IGtleSB0byB0aGUgc3BlY2lmaWVkIGtleXJpbmcgb3IgdXBkYXRlIGEgbWF0Y2hpbmcga2V5IGluIHRoYXQga2V5cmluZy4KKyAqCisgKiBUaGUga2V5cmluZyBtdXN0IGJlIHdyaXRhYmxlIHNvIHRoYXQgd2UgY2FuIGF0dGFjaCB0aGUga2V5IHRvIGl0LgorICoKKyAqIElmIHN1Y2Nlc3NmdWwsIHRoZSBuZXcga2V5J3Mgc2VyaWFsIG51bWJlciBpcyByZXR1cm5lZCwgb3RoZXJ3aXNlIGFuIGVycm9yCisgKiBjb2RlIGlzIHJldHVybmVkLgogICovCiBTWVNDQUxMX0RFRklORTUoYWRkX2tleSwgY29uc3QgY2hhciBfX3VzZXIgKiwgX3R5cGUsCiAJCWNvbnN0IGNoYXIgX191c2VyICosIF9kZXNjcmlwdGlvbiwKQEAgLTEzMiwxOSArMTI4LDIwIEBACiAJa2ZyZWUoZGVzY3JpcHRpb24pOwogIGVycm9yOgogCXJldHVybiByZXQ7Cit9CiAKLX0gLyogZW5kIHN5c19hZGRfa2V5KCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIHNlYXJjaCB0aGUgcHJvY2VzcyBrZXlyaW5ncyBmb3IgYSBtYXRjaGluZyBrZXkKLSAqIC0gbmVzdGVkIGtleXJpbmdzIG1heSBhbHNvIGJlIHNlYXJjaGVkIGlmIHRoZXkgaGF2ZSBTZWFyY2ggcGVybWlzc2lvbgotICogLSBpZiBhIGtleSBpcyBmb3VuZCwgaXQgd2lsbCBiZSBhdHRhY2hlZCB0byB0aGUgZGVzdGluYXRpb24ga2V5cmluZyBpZgotICogICB0aGVyZSdzIG9uZSBzcGVjaWZpZWQKLSAqIC0gL3NiaW4vcmVxdWVzdC1rZXkgd2lsbCBiZSBpbnZva2VkIGlmIF9jYWxsb3V0X2luZm8gaXMgbm9uLU5VTEwKLSAqICAgLSB0aGUgX2NhbGxvdXRfaW5mbyBzdHJpbmcgd2lsbCBiZSBwYXNzZWQgdG8gL3NiaW4vcmVxdWVzdC1rZXkKLSAqICAgLSBpZiB0aGUgX2NhbGxvdXRfaW5mbyBzdHJpbmcgaXMgZW1wdHksIGl0IHdpbGwgYmUgcmVuZGVyZWQgYXMgIi0iCi0gKiAtIGltcGxlbWVudHMgcmVxdWVzdF9rZXkoKQorICogU2VhcmNoIHRoZSBwcm9jZXNzIGtleXJpbmdzIGFuZCBrZXlyaW5nIHRyZWVzIGxpbmtlZCBmcm9tIHRob3NlIGZvciBhCisgKiBtYXRjaGluZyBrZXkuICBLZXlyaW5ncyBtdXN0IGhhdmUgYXBwcm9wcmlhdGUgU2VhcmNoIHBlcm1pc3Npb24gdG8gYmUKKyAqIHNlYXJjaGVkLgorICoKKyAqIElmIGEga2V5IGlzIGZvdW5kLCBpdCB3aWxsIGJlIGF0dGFjaGVkIHRvIHRoZSBkZXN0aW5hdGlvbiBrZXlyaW5nIGlmIHRoZXJlJ3MKKyAqIG9uZSBzcGVjaWZpZWQgYW5kIHRoZSBzZXJpYWwgbnVtYmVyIG9mIHRoZSBrZXkgd2lsbCBiZSByZXR1cm5lZC4KKyAqCisgKiBJZiBubyBrZXkgaXMgZm91bmQsIC9zYmluL3JlcXVlc3Qta2V5IHdpbGwgYmUgaW52b2tlZCBpZiBfY2FsbG91dF9pbmZvIGlzCisgKiBub24tTlVMTCBpbiBhbiBhdHRlbXB0IHRvIGNyZWF0ZSBhIGtleS4gIFRoZSBfY2FsbG91dF9pbmZvIHN0cmluZyB3aWxsIGJlCisgKiBwYXNzZWQgdG8gL3NiaW4vcmVxdWVzdC1rZXkgdG8gYWlkIHdpdGggY29tcGxldGluZyB0aGUgcmVxdWVzdC4gIElmIHRoZQorICogX2NhbGxvdXRfaW5mbyBzdHJpbmcgaXMgIiIgdGhlbiBpdCB3aWxsIGJlIGNoYW5nZWQgdG8gIi0iLgogICovCiBTWVNDQUxMX0RFRklORTQocmVxdWVzdF9rZXksIGNvbnN0IGNoYXIgX191c2VyICosIF90eXBlLAogCQljb25zdCBjaGFyIF9fdXNlciAqLCBfZGVzY3JpcHRpb24sCkBAIC0yMjIsMTQgKzIxOSwxNCBAQAogCWtmcmVlKGRlc2NyaXB0aW9uKTsKIGVycm9yOgogCXJldHVybiByZXQ7Cit9CiAKLX0gLyogZW5kIHN5c19yZXF1ZXN0X2tleSgpICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBnZXQgdGhlIElEIG9mIHRoZSBzcGVjaWZpZWQgcHJvY2VzcyBrZXlyaW5nCi0gKiAtIHRoZSBrZXlyaW5nIG11c3QgaGF2ZSBzZWFyY2ggcGVybWlzc2lvbiB0byBiZSBmb3VuZAotICogLSBpbXBsZW1lbnRzIGtleWN0bChLRVlDVExfR0VUX0tFWVJJTkdfSUQpCisgKiBHZXQgdGhlIElEIG9mIHRoZSBzcGVjaWZpZWQgcHJvY2VzcyBrZXlyaW5nLgorICoKKyAqIFRoZSByZXF1ZXN0ZWQga2V5cmluZyBtdXN0IGhhdmUgc2VhcmNoIHBlcm1pc3Npb24gdG8gYmUgZm91bmQuCisgKgorICogSWYgc3VjY2Vzc2Z1bCwgdGhlIElEIG9mIHRoZSByZXF1ZXN0ZWQga2V5cmluZyB3aWxsIGJlIHJldHVybmVkLgogICovCiBsb25nIGtleWN0bF9nZXRfa2V5cmluZ19JRChrZXlfc2VyaWFsX3QgaWQsIGludCBjcmVhdGUpCiB7CkBAIC0yNDgsMTMgKzI0NSwxNyBAQAogCWtleV9yZWZfcHV0KGtleV9yZWYpOwogZXJyb3I6CiAJcmV0dXJuIHJldDsKK30KIAotfSAvKiBlbmQga2V5Y3RsX2dldF9rZXlyaW5nX0lEKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIGpvaW4gdGhlIHNlc3Npb24ga2V5cmluZwotICogLSBpbXBsZW1lbnRzIGtleWN0bChLRVlDVExfSk9JTl9TRVNTSU9OX0tFWVJJTkcpCisgKiBKb2luIGEgKG5hbWVkKSBzZXNzaW9uIGtleXJpbmcuCisgKgorICogQ3JlYXRlIGFuZCBqb2luIGFuIGFub255bW91cyBzZXNzaW9uIGtleXJpbmcgb3Igam9pbiBhIG5hbWVkIHNlc3Npb24KKyAqIGtleXJpbmcsIGNyZWF0aW5nIGl0IGlmIG5lY2Vzc2FyeS4gIEEgbmFtZWQgc2Vzc2lvbiBrZXlyaW5nIG11c3QgaGF2ZSBTZWFyY2gKKyAqIHBlcm1pc3Npb24gZm9yIGl0IHRvIGJlIGpvaW5lZC4gIFNlc3Npb24ga2V5cmluZ3Mgd2l0aG91dCB0aGlzIHBlcm1pdCB3aWxsCisgKiBiZSBza2lwcGVkIG92ZXIuCisgKgorICogSWYgc3VjY2Vzc2Z1bCwgdGhlIElEIG9mIHRoZSBqb2luZWQgc2Vzc2lvbiBrZXlyaW5nIHdpbGwgYmUgcmV0dXJuZWQuCiAgKi8KIGxvbmcga2V5Y3RsX2pvaW5fc2Vzc2lvbl9rZXlyaW5nKGNvbnN0IGNoYXIgX191c2VyICpfbmFtZSkKIHsKQEAgLTI3NywxNCArMjc4LDE3IEBACiAKIGVycm9yOgogCXJldHVybiByZXQ7Cit9CiAKLX0gLyogZW5kIGtleWN0bF9qb2luX3Nlc3Npb25fa2V5cmluZygpICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiB1cGRhdGUgYSBrZXkncyBkYXRhIHBheWxvYWQKLSAqIC0gdGhlIGtleSBtdXN0IGJlIHdyaXRhYmxlCi0gKiAtIGltcGxlbWVudHMga2V5Y3RsKEtFWUNUTF9VUERBVEUpCisgKiBVcGRhdGUgYSBrZXkncyBkYXRhIHBheWxvYWQgZnJvbSB0aGUgZ2l2ZW4gZGF0YS4KKyAqCisgKiBUaGUga2V5IG11c3QgZ3JhbnQgdGhlIGNhbGxlciBXcml0ZSBwZXJtaXNzaW9uIGFuZCB0aGUga2V5IHR5cGUgbXVzdCBzdXBwb3J0CisgKiB1cGRhdGluZyBmb3IgdGhpcyB0byB3b3JrLiAgQSBuZWdhdGl2ZSBrZXkgY2FuIGJlIHBvc2l0aXZlbHkgaW5zdGFudGlhdGVkCisgKiB3aXRoIHRoaXMgY2FsbC4KKyAqCisgKiBJZiBzdWNjZXNzZnVsLCAwIHdpbGwgYmUgcmV0dXJuZWQuICBJZiB0aGUga2V5IHR5cGUgZG9lcyBub3Qgc3VwcG9ydAorICogdXBkYXRpbmcsIHRoZW4gLUVPUE5PVFNVUFAgd2lsbCBiZSByZXR1cm5lZC4KICAqLwogbG9uZyBrZXljdGxfdXBkYXRlX2tleShrZXlfc2VyaWFsX3QgaWQsCiAJCSAgICAgICBjb25zdCB2b2lkIF9fdXNlciAqX3BheWxvYWQsCkBAIC0zMjYsMTQgKzMzMCwxNyBAQAogCWtmcmVlKHBheWxvYWQpOwogZXJyb3I6CiAJcmV0dXJuIHJldDsKK30KIAotfSAvKiBlbmQga2V5Y3RsX3VwZGF0ZV9rZXkoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogcmV2b2tlIGEga2V5Ci0gKiAtIHRoZSBrZXkgbXVzdCBiZSB3cml0YWJsZQotICogLSBpbXBsZW1lbnRzIGtleWN0bChLRVlDVExfUkVWT0tFKQorICogUmV2b2tlIGEga2V5LgorICoKKyAqIFRoZSBrZXkgbXVzdCBiZSBncmFudCB0aGUgY2FsbGVyIFdyaXRlIG9yIFNldGF0dHIgcGVybWlzc2lvbiBmb3IgdGhpcyB0bworICogd29yay4gIFRoZSBrZXkgdHlwZSBzaG91bGQgZ2l2ZSB1cCBpdHMgcXVvdGEgY2xhaW0gd2hlbiByZXZva2VkLiAgVGhlIGtleQorICogYW5kIGFueSBsaW5rcyB0byB0aGUga2V5IHdpbGwgYmUgYXV0b21hdGljYWxseSBnYXJiYWdlIGNvbGxlY3RlZCBhZnRlciBhCisgKiBjZXJ0YWluIGFtb3VudCBvZiB0aW1lICgvcHJvYy9zeXMva2VybmVsL2tleXMvZ2NfZGVsYXkpLgorICoKKyAqIElmIHN1Y2Nlc3NmdWwsIDAgaXMgcmV0dXJuZWQuCiAgKi8KIGxvbmcga2V5Y3RsX3Jldm9rZV9rZXkoa2V5X3NlcmlhbF90IGlkKQogewpAQCAtMzU4LDE0ICszNjUsMTQgQEAKIAlrZXlfcmVmX3B1dChrZXlfcmVmKTsKIGVycm9yOgogCXJldHVybiByZXQ7Cit9CiAKLX0gLyogZW5kIGtleWN0bF9yZXZva2Vfa2V5KCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIGNsZWFyIHRoZSBzcGVjaWZpZWQgcHJvY2VzcyBrZXlyaW5nCi0gKiAtIHRoZSBrZXlyaW5nIG11c3QgYmUgd3JpdGFibGUKLSAqIC0gaW1wbGVtZW50cyBrZXljdGwoS0VZQ1RMX0NMRUFSKQorICogQ2xlYXIgdGhlIHNwZWNpZmllZCBrZXlyaW5nLCBjcmVhdGluZyBhbiBlbXB0eSBwcm9jZXNzIGtleXJpbmcgaWYgb25lIG9mIHRoZQorICogc3BlY2lhbCBrZXlyaW5nIElEcyBpcyB1c2VkLgorICoKKyAqIFRoZSBrZXlyaW5nIG11c3QgZ3JhbnQgdGhlIGNhbGxlciBXcml0ZSBwZXJtaXNzaW9uIGZvciB0aGlzIHRvIHdvcmsuICBJZgorICogc3VjY2Vzc2Z1bCwgMCB3aWxsIGJlIHJldHVybmVkLgogICovCiBsb25nIGtleWN0bF9rZXlyaW5nX2NsZWFyKGtleV9zZXJpYWxfdCByaW5naWQpCiB7CkBAIC0zODMsMTUgKzM5MCwxOCBAQAogCWtleV9yZWZfcHV0KGtleXJpbmdfcmVmKTsKIGVycm9yOgogCXJldHVybiByZXQ7Cit9CiAKLX0gLyogZW5kIGtleWN0bF9rZXlyaW5nX2NsZWFyKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIGxpbmsgYSBrZXkgaW50byBhIGtleXJpbmcKLSAqIC0gdGhlIGtleXJpbmcgbXVzdCBiZSB3cml0YWJsZQotICogLSB0aGUga2V5IG11c3QgYmUgbGlua2FibGUKLSAqIC0gaW1wbGVtZW50cyBrZXljdGwoS0VZQ1RMX0xJTkspCisgKiBDcmVhdGUgYSBsaW5rIGZyb20gYSBrZXlyaW5nIHRvIGEga2V5IGlmIHRoZXJlJ3Mgbm8gbWF0Y2hpbmcga2V5IGluIHRoZQorICoga2V5cmluZywgb3RoZXJ3aXNlIHJlcGxhY2UgdGhlIGxpbmsgdG8gdGhlIG1hdGNoaW5nIGtleSB3aXRoIGEgbGluayB0byB0aGUKKyAqIG5ldyBrZXkuCisgKgorICogVGhlIGtleSBtdXN0IGdyYW50IHRoZSBjYWxsZXIgTGluayBwZXJtaXNzaW9uIGFuZCB0aGUgdGhlIGtleXJpbmcgbXVzdCBncmFudAorICogdGhlIGNhbGxlciBXcml0ZSBwZXJtaXNzaW9uLiAgRnVydGhlcm1vcmUsIGlmIGFuIGFkZGl0aW9uYWwgbGluayBpcyBjcmVhdGVkLAorICogdGhlIGtleXJpbmcncyBxdW90YSB3aWxsIGJlIGV4dGVuZGVkLgorICoKKyAqIElmIHN1Y2Nlc3NmdWwsIDAgd2lsbCBiZSByZXR1cm5lZC4KICAqLwogbG9uZyBrZXljdGxfa2V5cmluZ19saW5rKGtleV9zZXJpYWxfdCBpZCwga2V5X3NlcmlhbF90IHJpbmdpZCkKIHsKQEAgLTQxNywxNSArNDI3LDE2IEBACiAJa2V5X3JlZl9wdXQoa2V5cmluZ19yZWYpOwogZXJyb3I6CiAJcmV0dXJuIHJldDsKK30KIAotfSAvKiBlbmQga2V5Y3RsX2tleXJpbmdfbGluaygpICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiB1bmxpbmsgdGhlIGZpcnN0IGF0dGFjaG1lbnQgb2YgYSBrZXkgZnJvbSBhIGtleXJpbmcKLSAqIC0gdGhlIGtleXJpbmcgbXVzdCBiZSB3cml0YWJsZQotICogLSB3ZSBkb24ndCBuZWVkIGFueSBwZXJtaXNzaW9ucyBvbiB0aGUga2V5Ci0gKiAtIGltcGxlbWVudHMga2V5Y3RsKEtFWUNUTF9VTkxJTkspCisgKiBVbmxpbmsgYSBrZXkgZnJvbSBhIGtleXJpbmcuCisgKgorICogVGhlIGtleXJpbmcgbXVzdCBncmFudCB0aGUgY2FsbGVyIFdyaXRlIHBlcm1pc3Npb24gZm9yIHRoaXMgdG8gd29yazsgdGhlIGtleQorICogaXRzZWxmIG5lZWQgbm90IGdyYW50IHRoZSBjYWxsZXIgYW55dGhpbmcuICBJZiB0aGUgbGFzdCBsaW5rIHRvIGEga2V5IGlzCisgKiByZW1vdmVkIHRoZW4gdGhhdCBrZXkgd2lsbCBiZSBzY2hlZHVsZWQgZm9yIGRlc3RydWN0aW9uLgorICoKKyAqIElmIHN1Y2Nlc3NmdWwsIDAgd2lsbCBiZSByZXR1cm5lZC4KICAqLwogbG9uZyBrZXljdGxfa2V5cmluZ191bmxpbmsoa2V5X3NlcmlhbF90IGlkLCBrZXlfc2VyaWFsX3QgcmluZ2lkKQogewpAQCAtNDUxLDE5ICs0NjIsMjAgQEAKIAlrZXlfcmVmX3B1dChrZXlyaW5nX3JlZik7CiBlcnJvcjoKIAlyZXR1cm4gcmV0OworfQogCi19IC8qIGVuZCBrZXljdGxfa2V5cmluZ191bmxpbmsoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogZGVzY3JpYmUgYSB1c2VyIGtleQotICogLSB0aGUga2V5IG11c3QgaGF2ZSB2aWV3IHBlcm1pc3Npb24KLSAqIC0gaWYgdGhlcmUncyBhIGJ1ZmZlciwgd2UgcGxhY2UgdXAgdG8gYnVmbGVuIGJ5dGVzIG9mIGRhdGEgaW50byBpdAotICogLSB1bmxlc3MgdGhlcmUncyBhbiBlcnJvciwgd2UgcmV0dXJuIHRoZSBhbW91bnQgb2YgZGVzY3JpcHRpb24gYXZhaWxhYmxlLAotICogICBpcnJlc3BlY3RpdmUgb2YgaG93IG11Y2ggd2UgbWF5IGhhdmUgY29waWVkCi0gKiAtIHRoZSBkZXNjcmlwdGlvbiBpcyBmb3JtYXR0ZWQgdGh1czoKKyAqIFJldHVybiBhIGRlc2NyaXB0aW9uIG9mIGEga2V5IHRvIHVzZXJzcGFjZS4KKyAqCisgKiBUaGUga2V5IG11c3QgZ3JhbnQgdGhlIGNhbGxlciBWaWV3IHBlcm1pc3Npb24gZm9yIHRoaXMgdG8gd29yay4KKyAqCisgKiBJZiB0aGVyZSdzIGEgYnVmZmVyLCB3ZSBwbGFjZSB1cCB0byBidWZsZW4gYnl0ZXMgb2YgZGF0YSBpbnRvIGl0IGZvcm1hdHRlZAorICogaW4gdGhlIGZvbGxvd2luZyB3YXk6CisgKgogICoJdHlwZTt1aWQ7Z2lkO3Blcm07ZGVzY3JpcHRpb248TlVMPgotICogLSBpbXBsZW1lbnRzIGtleWN0bChLRVlDVExfREVTQ1JJQkUpCisgKgorICogSWYgc3VjY2Vzc2Z1bCwgd2UgcmV0dXJuIHRoZSBhbW91bnQgb2YgZGVzY3JpcHRpb24gYXZhaWxhYmxlLCBpcnJlc3BlY3RpdmUKKyAqIG9mIGhvdyBtdWNoIHdlIG1heSBoYXZlIGNvcGllZCBpbnRvIHRoZSBidWZmZXIuCiAgKi8KIGxvbmcga2V5Y3RsX2Rlc2NyaWJlX2tleShrZXlfc2VyaWFsX3Qga2V5aWQsCiAJCQkgY2hhciBfX3VzZXIgKmJ1ZmZlciwKQEAgLTUzMSwxOCArNTQzLDE3IEBACiAJa2V5X3JlZl9wdXQoa2V5X3JlZik7CiBlcnJvcjoKIAlyZXR1cm4gcmV0OworfQogCi19IC8qIGVuZCBrZXljdGxfZGVzY3JpYmVfa2V5KCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIHNlYXJjaCB0aGUgc3BlY2lmaWVkIGtleXJpbmcgZm9yIGEgbWF0Y2hpbmcga2V5Ci0gKiAtIHRoZSBzdGFydCBrZXlyaW5nIG11c3QgYmUgc2VhcmNoYWJsZQotICogLSBuZXN0ZWQga2V5cmluZ3MgbWF5IGFsc28gYmUgc2VhcmNoZWQgaWYgdGhleSBhcmUgc2VhcmNoYWJsZQotICogLSBvbmx5IGtleXMgd2l0aCBzZWFyY2ggcGVybWlzc2lvbiBtYXkgYmUgZm91bmQKLSAqIC0gaWYgYSBrZXkgaXMgZm91bmQsIGl0IHdpbGwgYmUgYXR0YWNoZWQgdG8gdGhlIGRlc3RpbmF0aW9uIGtleXJpbmcgaWYKLSAqICAgdGhlcmUncyBvbmUgc3BlY2lmaWVkCi0gKiAtIGltcGxlbWVudHMga2V5Y3RsKEtFWUNUTF9TRUFSQ0gpCisgKiBTZWFyY2ggdGhlIHNwZWNpZmllZCBrZXlyaW5nIGFuZCBhbnkga2V5cmluZ3MgaXQgbGlua3MgdG8gZm9yIGEgbWF0Y2hpbmcKKyAqIGtleS4gIE9ubHkga2V5cmluZ3MgdGhhdCBncmFudCB0aGUgY2FsbGVyIFNlYXJjaCBwZXJtaXNzaW9uIHdpbGwgYmUgc2VhcmNoZWQKKyAqICh0aGlzIGluY2x1ZGVzIHRoZSBzdGFydGluZyBrZXlyaW5nKS4gIE9ubHkga2V5cyB3aXRoIFNlYXJjaCBwZXJtaXNzaW9uIGNhbgorICogYmUgZm91bmQuCisgKgorICogSWYgc3VjY2Vzc2Z1bCwgdGhlIGZvdW5kIGtleSB3aWxsIGJlIGxpbmtlZCB0byB0aGUgZGVzdGluYXRpb24ga2V5cmluZyBpZgorICogc3VwcGxpZWQgYW5kIHRoZSBrZXkgaGFzIExpbmsgcGVybWlzc2lvbiwgYW5kIHRoZSBmb3VuZCBrZXkgSUQgd2lsbCBiZQorICogcmV0dXJuZWQuCiAgKi8KIGxvbmcga2V5Y3RsX2tleXJpbmdfc2VhcmNoKGtleV9zZXJpYWxfdCByaW5naWQsCiAJCQkgICBjb25zdCBjaGFyIF9fdXNlciAqX3R5cGUsCkBAIC02MjYsMTggKzYzNywxNyBAQAogCWtmcmVlKGRlc2NyaXB0aW9uKTsKIGVycm9yOgogCXJldHVybiByZXQ7Cit9CiAKLX0gLyogZW5kIGtleWN0bF9rZXlyaW5nX3NlYXJjaCgpICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiByZWFkIGEgdXNlciBrZXkncyBwYXlsb2FkCi0gKiAtIHRoZSBrZXlyaW5nIG11c3QgYmUgcmVhZGFibGUgb3IgdGhlIGtleSBtdXN0IGJlIHNlYXJjaGFibGUgZnJvbSB0aGUKLSAqICAgcHJvY2VzcydzIGtleXJpbmdzCi0gKiAtIGlmIHRoZXJlJ3MgYSBidWZmZXIsIHdlIHBsYWNlIHVwIHRvIGJ1ZmxlbiBieXRlcyBvZiBkYXRhIGludG8gaXQKLSAqIC0gdW5sZXNzIHRoZXJlJ3MgYW4gZXJyb3IsIHdlIHJldHVybiB0aGUgYW1vdW50IG9mIGRhdGEgaW4gdGhlIGtleSwKLSAqICAgaXJyZXNwZWN0aXZlIG9mIGhvdyBtdWNoIHdlIG1heSBoYXZlIGNvcGllZAotICogLSBpbXBsZW1lbnRzIGtleWN0bChLRVlDVExfUkVBRCkKKyAqIFJlYWQgYSBrZXkncyBwYXlsb2FkLgorICoKKyAqIFRoZSBrZXkgbXVzdCBlaXRoZXIgZ3JhbnQgdGhlIGNhbGxlciBSZWFkIHBlcm1pc3Npb24sIG9yIGl0IG11c3QgZ3JhbnQgdGhlCisgKiBjYWxsZXIgU2VhcmNoIHBlcm1pc3Npb24gd2hlbiBzZWFyY2hlZCBmb3IgZnJvbSB0aGUgcHJvY2VzcyBrZXlyaW5ncy4KKyAqCisgKiBJZiBzdWNjZXNzZnVsLCB3ZSBwbGFjZSB1cCB0byBidWZsZW4gYnl0ZXMgb2YgZGF0YSBpbnRvIHRoZSBidWZmZXIsIGlmIG9uZQorICogaXMgcHJvdmlkZWQsIGFuZCByZXR1cm4gdGhlIGFtb3VudCBvZiBkYXRhIHRoYXQgaXMgYXZhaWxhYmxlIGluIHRoZSBrZXksCisgKiBpcnJlc3BlY3RpdmUgb2YgaG93IG11Y2ggd2UgY29waWVkIGludG8gdGhlIGJ1ZmZlci4KICAqLwogbG9uZyBrZXljdGxfcmVhZF9rZXkoa2V5X3NlcmlhbF90IGtleWlkLCBjaGFyIF9fdXNlciAqYnVmZmVyLCBzaXplX3QgYnVmbGVuKQogewpAQCAtNjg4LDE1ICs2OTgsMjIgQEAKIAlrZXlfcHV0KGtleSk7CiBlcnJvcjoKIAlyZXR1cm4gcmV0OworfQogCi19IC8qIGVuZCBrZXljdGxfcmVhZF9rZXkoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogY2hhbmdlIHRoZSBvd25lcnNoaXAgb2YgYSBrZXkKLSAqIC0gdGhlIGtleXJpbmcgb3duZWQgYnkgdGhlIGNoYW5nZXIKLSAqIC0gaWYgdGhlIHVpZCBvciBnaWQgaXMgLTEsIHRoZW4gdGhhdCBwYXJhbWV0ZXIgaXMgbm90IGNoYW5nZWQKLSAqIC0gaW1wbGVtZW50cyBrZXljdGwoS0VZQ1RMX0NIT1dOKQorICogQ2hhbmdlIHRoZSBvd25lcnNoaXAgb2YgYSBrZXkKKyAqCisgKiBUaGUga2V5IG11c3QgZ3JhbnQgdGhlIGNhbGxlciBTZXRhdHRyIHBlcm1pc3Npb24gZm9yIHRoaXMgdG8gd29yaywgdGhvdWdoCisgKiB0aGUga2V5IG5lZWQgbm90IGJlIGZ1bGx5IGluc3RhbnRpYXRlZCB5ZXQuICBGb3IgdGhlIFVJRCB0byBiZSBjaGFuZ2VkLCBvcgorICogZm9yIHRoZSBHSUQgdG8gYmUgY2hhbmdlZCB0byBhIGdyb3VwIHRoZSBjYWxsZXIgaXMgbm90IGEgbWVtYmVyIG9mLCB0aGUKKyAqIGNhbGxlciBtdXN0IGhhdmUgc3lzYWRtaW4gY2FwYWJpbGl0eS4gIElmIGVpdGhlciB1aWQgb3IgZ2lkIGlzIC0xIHRoZW4gdGhhdAorICogYXR0cmlidXRlIGlzIG5vdCBjaGFuZ2VkLgorICoKKyAqIElmIHRoZSBVSUQgaXMgdG8gYmUgY2hhbmdlZCwgdGhlIG5ldyB1c2VyIG11c3QgaGF2ZSBzdWZmaWNpZW50IHF1b3RhIHRvCisgKiBhY2NlcHQgdGhlIGtleS4gIFRoZSBxdW90YSBkZWR1Y3Rpb24gd2lsbCBiZSByZW1vdmVkIGZyb20gdGhlIG9sZCB1c2VyIHRvCisgKiB0aGUgbmV3IHVzZXIgc2hvdWxkIHRoZSBhdHRyaWJ1dGUgYmUgY2hhbmdlZC4KKyAqCisgKiBJZiBzdWNjZXNzZnVsLCAwIHdpbGwgYmUgcmV0dXJuZWQuCiAgKi8KIGxvbmcga2V5Y3RsX2Nob3duX2tleShrZXlfc2VyaWFsX3QgaWQsIHVpZF90IHVpZCwgZ2lkX3QgZ2lkKQogewpAQCAtNzk2LDE0ICs4MTMsMTQgQEAKIAl6YXBvd25lciA9IG5ld293bmVyOwogCXJldCA9IC1FRFFVT1Q7CiAJZ290byBlcnJvcl9wdXQ7Cit9CiAKLX0gLyogZW5kIGtleWN0bF9jaG93bl9rZXkoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogY2hhbmdlIHRoZSBwZXJtaXNzaW9uIG1hc2sgb24gYSBrZXkKLSAqIC0gdGhlIGtleXJpbmcgb3duZWQgYnkgdGhlIGNoYW5nZXIKLSAqIC0gaW1wbGVtZW50cyBrZXljdGwoS0VZQ1RMX1NFVFBFUk0pCisgKiBDaGFuZ2UgdGhlIHBlcm1pc3Npb24gbWFzayBvbiBhIGtleS4KKyAqCisgKiBUaGUga2V5IG11c3QgZ3JhbnQgdGhlIGNhbGxlciBTZXRhdHRyIHBlcm1pc3Npb24gZm9yIHRoaXMgdG8gd29yaywgdGhvdWdoCisgKiB0aGUga2V5IG5lZWQgbm90IGJlIGZ1bGx5IGluc3RhbnRpYXRlZCB5ZXQuICBJZiB0aGUgY2FsbGVyIGRvZXMgbm90IGhhdmUKKyAqIHN5c2FkbWluIGNhcGFiaWxpdHksIGl0IG1heSBvbmx5IGNoYW5nZSB0aGUgcGVybWlzc2lvbiBvbiBrZXlzIHRoYXQgaXQgb3ducy4KICAqLwogbG9uZyBrZXljdGxfc2V0cGVybV9rZXkoa2V5X3NlcmlhbF90IGlkLCBrZXlfcGVybV90IHBlcm0pCiB7CkBAIC04MzgsMTEgKzg1NSwxMSBAQAogCWtleV9wdXQoa2V5KTsKIGVycm9yOgogCXJldHVybiByZXQ7Ci0KLX0gLyogZW5kIGtleWN0bF9zZXRwZXJtX2tleSgpICovCit9CiAKIC8qCi0gKiBnZXQgdGhlIGRlc3RpbmF0aW9uIGtleXJpbmcgZm9yIGluc3RhbnRpYXRpb24KKyAqIEdldCB0aGUgZGVzdGluYXRpb24ga2V5cmluZyBmb3IgaW5zdGFudGlhdGlvbiBhbmQgY2hlY2sgdGhhdCB0aGUgY2FsbGVyIGhhcworICogV3JpdGUgcGVybWlzc2lvbiBvbiBpdC4KICAqLwogc3RhdGljIGxvbmcgZ2V0X2luc3RhbnRpYXRpb25fa2V5cmluZyhrZXlfc2VyaWFsX3QgcmluZ2lkLAogCQkJCSAgICAgIHN0cnVjdCByZXF1ZXN0X2tleV9hdXRoICpya2EsCkBAIC04NzksNyArODk2LDcgQEAKIH0KIAogLyoKLSAqIGNoYW5nZSB0aGUgcmVxdWVzdF9rZXkgYXV0aG9yaXNhdGlvbiBrZXkgb24gdGhlIGN1cnJlbnQgcHJvY2VzcworICogQ2hhbmdlIHRoZSByZXF1ZXN0X2tleSBhdXRob3Jpc2F0aW9uIGtleSBvbiB0aGUgY3VycmVudCBwcm9jZXNzLgogICovCiBzdGF0aWMgaW50IGtleWN0bF9jaGFuZ2VfcmVxa2V5X2F1dGgoc3RydWN0IGtleSAqa2V5KQogewpAQCAtODk1LDEwICs5MTIsMTQgQEAKIAlyZXR1cm4gY29tbWl0X2NyZWRzKG5ldyk7CiB9CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBpbnN0YW50aWF0ZSB0aGUga2V5IHdpdGggdGhlIHNwZWNpZmllZCBwYXlsb2FkLCBhbmQsIGlmIG9uZSBpcyBnaXZlbiwgbGluawotICogdGhlIGtleSBpbnRvIHRoZSBrZXlyaW5nCisgKiBJbnN0YW50aWF0ZSBhIGtleSB3aXRoIHRoZSBzcGVjaWZpZWQgcGF5bG9hZCBhbmQgbGluayB0aGUga2V5IGludG8gdGhlCisgKiBkZXN0aW5hdGlvbiBrZXlyaW5nIGlmIG9uZSBpcyBnaXZlbi4KKyAqCisgKiBUaGUgY2FsbGVyIG11c3QgaGF2ZSB0aGUgYXBwcm9wcmlhdGUgaW5zdGFudGlhdGlvbiBwZXJtaXQgc2V0IGZvciB0aGlzIHRvCisgKiB3b3JrIChzZWUga2V5Y3RsX2Fzc3VtZV9hdXRob3JpdHkpLiAgTm8gb3RoZXIgcGVybWlzc2lvbnMgYXJlIHJlcXVpcmVkLgorICoKKyAqIElmIHN1Y2Nlc3NmdWwsIDAgd2lsbCBiZSByZXR1cm5lZC4KICAqLwogbG9uZyBrZXljdGxfaW5zdGFudGlhdGVfa2V5KGtleV9zZXJpYWxfdCBpZCwKIAkJCSAgICBjb25zdCB2b2lkIF9fdXNlciAqX3BheWxvYWQsCkBAIC05NzMsMTMgKzk5NCwyMiBAQAogCQl2ZnJlZShwYXlsb2FkKTsKIGVycm9yOgogCXJldHVybiByZXQ7Cit9CiAKLX0gLyogZW5kIGtleWN0bF9pbnN0YW50aWF0ZV9rZXkoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogbmVnYXRpdmVseSBpbnN0YW50aWF0ZSB0aGUga2V5IHdpdGggdGhlIGdpdmVuIHRpbWVvdXQgKGluIHNlY29uZHMpLCBhbmQsIGlmCi0gKiBvbmUgaXMgZ2l2ZW4sIGxpbmsgdGhlIGtleSBpbnRvIHRoZSBrZXlyaW5nCisgKiBOZWdhdGl2ZWx5IGluc3RhbnRpYXRlIHRoZSBrZXkgd2l0aCB0aGUgZ2l2ZW4gdGltZW91dCAoaW4gc2Vjb25kcykgYW5kIGxpbmsKKyAqIHRoZSBrZXkgaW50byB0aGUgZGVzdGluYXRpb24ga2V5cmluZyBpZiBvbmUgaXMgZ2l2ZW4uCisgKgorICogVGhlIGNhbGxlciBtdXN0IGhhdmUgdGhlIGFwcHJvcHJpYXRlIGluc3RhbnRpYXRpb24gcGVybWl0IHNldCBmb3IgdGhpcyB0bworICogd29yayAoc2VlIGtleWN0bF9hc3N1bWVfYXV0aG9yaXR5KS4gIE5vIG90aGVyIHBlcm1pc3Npb25zIGFyZSByZXF1aXJlZC4KKyAqCisgKiBUaGUga2V5IGFuZCBhbnkgbGlua3MgdG8gdGhlIGtleSB3aWxsIGJlIGF1dG9tYXRpY2FsbHkgZ2FyYmFnZSBjb2xsZWN0ZWQKKyAqIGFmdGVyIHRoZSB0aW1lb3V0IGV4cGlyZXMuCisgKgorICogTmVnYXRpdmUga2V5cyBhcmUgdXNlZCB0byByYXRlIGxpbWl0IHJlcGVhdGVkIHJlcXVlc3Rfa2V5KCkgY2FsbHMgYnkgY2F1c2luZworICogdGhlbSB0byByZXR1cm4gLUVOT0tFWSB1bnRpbCB0aGUgbmVnYXRpdmUga2V5IGV4cGlyZXMuCisgKgorICogSWYgc3VjY2Vzc2Z1bCwgMCB3aWxsIGJlIHJldHVybmVkLgogICovCiBsb25nIGtleWN0bF9uZWdhdGVfa2V5KGtleV9zZXJpYWxfdCBpZCwgdW5zaWduZWQgdGltZW91dCwga2V5X3NlcmlhbF90IHJpbmdpZCkKIHsKQEAgLTEwMjAsMTMgKzEwNTAsMTQgQEAKIAogZXJyb3I6CiAJcmV0dXJuIHJldDsKK30KIAotfSAvKiBlbmQga2V5Y3RsX25lZ2F0ZV9rZXkoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogc2V0IHRoZSBkZWZhdWx0IGtleXJpbmcgaW4gd2hpY2ggcmVxdWVzdF9rZXkoKSB3aWxsIGNhY2hlIGtleXMKLSAqIC0gcmV0dXJuIHRoZSBvbGQgc2V0dGluZworICogUmVhZCBvciBzZXQgdGhlIGRlZmF1bHQga2V5cmluZyBpbiB3aGljaCByZXF1ZXN0X2tleSgpIHdpbGwgY2FjaGUga2V5cyBhbmQKKyAqIHJldHVybiB0aGUgb2xkIHNldHRpbmcuCisgKgorICogSWYgYSBwcm9jZXNzIGtleXJpbmcgaXMgc3BlY2lmaWVkIHRoZW4gdGhpcyB3aWxsIGJlIGNyZWF0ZWQgaWYgaXQgZG9lc24ndAorICogeWV0IGV4aXN0LiAgVGhlIG9sZCBzZXR0aW5nIHdpbGwgYmUgcmV0dXJuZWQgaWYgc3VjY2Vzc2Z1bC4KICAqLwogbG9uZyBrZXljdGxfc2V0X3JlcWtleV9rZXlyaW5nKGludCByZXFrZXlfZGVmbCkKIHsKQEAgLTEwNzksMTIgKzExMTAsMTkgQEAKIGVycm9yOgogCWFib3J0X2NyZWRzKG5ldyk7CiAJcmV0dXJuIHJldDsKK30KIAotfSAvKiBlbmQga2V5Y3RsX3NldF9yZXFrZXlfa2V5cmluZygpICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBzZXQgb3IgY2xlYXIgdGhlIHRpbWVvdXQgZm9yIGEga2V5CisgKiBTZXQgb3IgY2xlYXIgdGhlIHRpbWVvdXQgb24gYSBrZXkuCisgKgorICogRWl0aGVyIHRoZSBrZXkgbXVzdCBncmFudCB0aGUgY2FsbGVyIFNldGF0dHIgcGVybWlzc2lvbiBvciBlbHNlIHRoZSBjYWxsZXIKKyAqIG11c3QgaG9sZCBhbiBpbnN0YW50aWF0aW9uIGF1dGhvcmlzYXRpb24gdG9rZW4gZm9yIHRoZSBrZXkuCisgKgorICogVGhlIHRpbWVvdXQgaXMgZWl0aGVyIDAgdG8gY2xlYXIgdGhlIHRpbWVvdXQsIG9yIGEgbnVtYmVyIG9mIHNlY29uZHMgZnJvbQorICogdGhlIGN1cnJlbnQgdGltZS4gIFRoZSBrZXkgYW5kIGFueSBsaW5rcyB0byB0aGUga2V5IHdpbGwgYmUgYXV0b21hdGljYWxseQorICogZ2FyYmFnZSBjb2xsZWN0ZWQgYWZ0ZXIgdGhlIHRpbWVvdXQgZXhwaXJlcy4KKyAqCisgKiBJZiBzdWNjZXNzZnVsLCAwIGlzIHJldHVybmVkLgogICovCiBsb25nIGtleWN0bF9zZXRfdGltZW91dChrZXlfc2VyaWFsX3QgaWQsIHVuc2lnbmVkIHRpbWVvdXQpCiB7CkBAIC0xMTM2LDEyICsxMTc0LDI0IEBACiAJcmV0ID0gMDsKIGVycm9yOgogCXJldHVybiByZXQ7Cit9CiAKLX0gLyogZW5kIGtleWN0bF9zZXRfdGltZW91dCgpICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBhc3N1bWUgdGhlIGF1dGhvcml0eSB0byBpbnN0YW50aWF0ZSB0aGUgc3BlY2lmaWVkIGtleQorICogQXNzdW1lIChvciBjbGVhcikgdGhlIGF1dGhvcml0eSB0byBpbnN0YW50aWF0ZSB0aGUgc3BlY2lmaWVkIGtleS4KKyAqCisgKiBUaGlzIHNldHMgdGhlIGF1dGhvcml0YXRpdmUgdG9rZW4gY3VycmVudGx5IGluIGZvcmNlIGZvciBrZXkgaW5zdGFudGlhdGlvbi4KKyAqIFRoaXMgbXVzdCBiZSBkb25lIGZvciBhIGtleSB0byBiZSBpbnN0YW50aWF0ZWQuICBJdCBoYXMgdGhlIGVmZmVjdCBvZiBtYWtpbmcKKyAqIGF2YWlsYWJsZSBhbGwgdGhlIGtleXMgZnJvbSB0aGUgY2FsbGVyIG9mIHRoZSByZXF1ZXN0X2tleSgpIHRoYXQgY3JlYXRlZCBhCisgKiBrZXkgdG8gcmVxdWVzdF9rZXkoKSBjYWxscyBtYWRlIGJ5IHRoZSBjYWxsZXIgb2YgdGhpcyBmdW5jdGlvbi4KKyAqCisgKiBUaGUgY2FsbGVyIG11c3QgaGF2ZSB0aGUgaW5zdGFudGlhdGlvbiBrZXkgaW4gdGhlaXIgcHJvY2VzcyBrZXlyaW5ncyB3aXRoIGEKKyAqIFNlYXJjaCBwZXJtaXNzaW9uIGdyYW50IGF2YWlsYWJsZSB0byB0aGUgY2FsbGVyLgorICoKKyAqIElmIHRoZSBJRCBnaXZlbiBpcyAwLCB0aGVuIHRoZSBzZXR0aW5nIHdpbGwgYmUgY2xlYXJlZCBhbmQgMCByZXR1cm5lZC4KKyAqCisgKiBJZiB0aGUgSUQgZ2l2ZW4gaGFzIGEgbWF0Y2hpbmcgYW4gYXV0aG9yaXNhdGlvbiBrZXksIHRoZW4gdGhhdCBrZXkgd2lsbCBiZQorICogc2V0IGFuZCBpdHMgSUQgd2lsbCBiZSByZXR1cm5lZC4gIFRoZSBhdXRob3Jpc2F0aW9uIGtleSBjYW4gYmUgcmVhZCB0byBnZXQKKyAqIHRoZSBjYWxsb3V0IGluZm9ybWF0aW9uIHBhc3NlZCB0byByZXF1ZXN0X2tleSgpLgogICovCiBsb25nIGtleWN0bF9hc3N1bWVfYXV0aG9yaXR5KGtleV9zZXJpYWxfdCBpZCkKIHsKQEAgLTExNzgsMTYgKzEyMjgsMTcgQEAKIAlyZXQgPSBhdXRoa2V5LT5zZXJpYWw7CiBlcnJvcjoKIAlyZXR1cm4gcmV0OwotCi19IC8qIGVuZCBrZXljdGxfYXNzdW1lX2F1dGhvcml0eSgpICovCit9CiAKIC8qCi0gKiBnZXQgdGhlIHNlY3VyaXR5IGxhYmVsIG9mIGEga2V5Ci0gKiAtIHRoZSBrZXkgbXVzdCBncmFudCB1cyB2aWV3IHBlcm1pc3Npb24KLSAqIC0gaWYgdGhlcmUncyBhIGJ1ZmZlciwgd2UgcGxhY2UgdXAgdG8gYnVmbGVuIGJ5dGVzIG9mIGRhdGEgaW50byBpdAotICogLSB1bmxlc3MgdGhlcmUncyBhbiBlcnJvciwgd2UgcmV0dXJuIHRoZSBhbW91bnQgb2YgaW5mb3JtYXRpb24gYXZhaWxhYmxlLAotICogICBpcnJlc3BlY3RpdmUgb2YgaG93IG11Y2ggd2UgbWF5IGhhdmUgY29waWVkIChpbmNsdWRpbmcgdGhlIHRlcm1pbmFsIE5VTCkKLSAqIC0gaW1wbGVtZW50cyBrZXljdGwoS0VZQ1RMX0dFVF9TRUNVUklUWSkKKyAqIEdldCBhIGtleSdzIHRoZSBMU00gc2VjdXJpdHkgbGFiZWwuCisgKgorICogVGhlIGtleSBtdXN0IGdyYW50IHRoZSBjYWxsZXIgVmlldyBwZXJtaXNzaW9uIGZvciB0aGlzIHRvIHdvcmsuCisgKgorICogSWYgdGhlcmUncyBhIGJ1ZmZlciwgdGhlbiB1cCB0byBidWZsZW4gYnl0ZXMgb2YgZGF0YSB3aWxsIGJlIHBsYWNlZCBpbnRvIGl0LgorICoKKyAqIElmIHN1Y2Nlc3NmdWwsIHRoZSBhbW91bnQgb2YgaW5mb3JtYXRpb24gYXZhaWxhYmxlIHdpbGwgYmUgcmV0dXJuZWQsCisgKiBpcnJlc3BlY3RpdmUgb2YgaG93IG11Y2ggd2FzIGNvcGllZCAoaW5jbHVkaW5nIHRoZSB0ZXJtaW5hbCBOVUwpLgogICovCiBsb25nIGtleWN0bF9nZXRfc2VjdXJpdHkoa2V5X3NlcmlhbF90IGtleWlkLAogCQkJIGNoYXIgX191c2VyICpidWZmZXIsCkBAIC0xMjQyLDEwICsxMjkzLDE2IEBACiB9CiAKIC8qCi0gKiBhdHRlbXB0IHRvIGluc3RhbGwgdGhlIGNhbGxpbmcgcHJvY2VzcydzIHNlc3Npb24ga2V5cmluZyBvbiB0aGUgcHJvY2VzcydzCi0gKiBwYXJlbnQgcHJvY2VzcwotICogLSB0aGUga2V5cmluZyBtdXN0IGV4aXN0IGFuZCBtdXN0IGdyYW50IHVzIExJTksgcGVybWlzc2lvbgotICogLSBpbXBsZW1lbnRzIGtleWN0bChLRVlDVExfU0VTU0lPTl9UT19QQVJFTlQpCisgKiBBdHRlbXB0IHRvIGluc3RhbGwgdGhlIGNhbGxpbmcgcHJvY2VzcydzIHNlc3Npb24ga2V5cmluZyBvbiB0aGUgcHJvY2VzcydzCisgKiBwYXJlbnQgcHJvY2Vzcy4KKyAqCisgKiBUaGUga2V5cmluZyBtdXN0IGV4aXN0IGFuZCBtdXN0IGdyYW50IHRoZSBjYWxsZXIgTElOSyBwZXJtaXNzaW9uLCBhbmQgdGhlCisgKiBwYXJlbnQgcHJvY2VzcyBtdXN0IGJlIHNpbmdsZS10aHJlYWRlZCBhbmQgbXVzdCBoYXZlIHRoZSBzYW1lIGVmZmVjdGl2ZQorICogb3duZXJzaGlwIGFzIHRoaXMgcHJvY2VzcyBhbmQgbXVzdG4ndCBiZSBTVUlEL1NHSUQuCisgKgorICogVGhlIGtleXJpbmcgd2lsbCBiZSBlbXBsYWNlZCBvbiB0aGUgcGFyZW50IHdoZW4gaXQgbmV4dCByZXN1bWVzIHVzZXJzcGFjZS4KKyAqCisgKiBJZiBzdWNjZXNzZnVsLCAwIHdpbGwgYmUgcmV0dXJuZWQuCiAgKi8KIGxvbmcga2V5Y3RsX3Nlc3Npb25fdG9fcGFyZW50KHZvaWQpCiB7CkBAIC0xMzQ4LDkgKzE0MDUsOCBAQAogI2VuZGlmIC8qICFUSUZfTk9USUZZX1JFU1VNRSAqLwogfQogCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogdGhlIGtleSBjb250cm9sIHN5c3RlbSBjYWxsCisgKiBUaGUga2V5IGNvbnRyb2wgc3lzdGVtIGNhbGwKICAqLwogU1lTQ0FMTF9ERUZJTkU1KGtleWN0bCwgaW50LCBvcHRpb24sIHVuc2lnbmVkIGxvbmcsIGFyZzIsIHVuc2lnbmVkIGxvbmcsIGFyZzMsCiAJCXVuc2lnbmVkIGxvbmcsIGFyZzQsIHVuc2lnbmVkIGxvbmcsIGFyZzUpCkBAIC0xNDM5LDUgKzE0OTUsNCBAQAogCWRlZmF1bHQ6CiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAl9Ci0KLX0gLyogZW5kIHN5c19rZXljdGwoKSAqLworfQpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkva2V5cy9rZXlyaW5nLmMgYi9zZWN1cml0eS9rZXlzL2tleXJpbmcuYwppbmRleCBkMzdmNzEzLi41NjIwZjA4IDEwMDY0NAotLS0gYS9zZWN1cml0eS9rZXlzL2tleXJpbmcuYworKysgYi9zZWN1cml0eS9rZXlzL2tleXJpbmcuYwpAQCAtMjUsMTQgKzI1LDE2IEBACiAJCShrZXlyaW5nKS0+cGF5bG9hZC5zdWJzY3JpcHRpb25zLAkJCVwKIAkJcndzZW1faXNfbG9ja2VkKChzdHJ1Y3Qgcndfc2VtYXBob3JlICopJihrZXlyaW5nKS0+c2VtKSkpCiAKKyNkZWZpbmUgS0VZX0xJTktfRklYUVVPVEEgMVVMCisKIC8qCi0gKiB3aGVuIHBsdW1iaW5nIHRoZSBkZXB0aHMgb2YgdGhlIGtleSB0cmVlLCB0aGlzIHNldHMgYSBoYXJkIGxpbWl0IHNldCBvbiBob3cKLSAqIGRlZXAgd2UncmUgd2lsbGluZyB0byBnbworICogV2hlbiBwbHVtYmluZyB0aGUgZGVwdGhzIG9mIHRoZSBrZXkgdHJlZSwgdGhpcyBzZXRzIGEgaGFyZCBsaW1pdAorICogc2V0IG9uIGhvdyBkZWVwIHdlJ3JlIHdpbGxpbmcgdG8gZ28uCiAgKi8KICNkZWZpbmUgS0VZUklOR19TRUFSQ0hfTUFYX0RFUFRIIDYKIAogLyoKLSAqIHdlIGtlZXAgYWxsIG5hbWVkIGtleXJpbmdzIGluIGEgaGFzaCB0byBzcGVlZCBsb29raW5nIHRoZW0gdXAKKyAqIFdlIGtlZXAgYWxsIG5hbWVkIGtleXJpbmdzIGluIGEgaGFzaCB0byBzcGVlZCBsb29raW5nIHRoZW0gdXAuCiAgKi8KICNkZWZpbmUgS0VZUklOR19OQU1FX0hBU0hfU0laRQkoMSA8PCA1KQogCkBAIC01MCw3ICs1Miw5IEBACiB9CiAKIC8qCi0gKiB0aGUga2V5cmluZyB0eXBlIGRlZmluaXRpb24KKyAqIFRoZSBrZXlyaW5nIGtleSB0eXBlIGRlZmluaXRpb24uICBLZXlyaW5ncyBhcmUgc2ltcGx5IGtleXMgb2YgdGhpcyB0eXBlIGFuZAorICogY2FuIGJlIHRyZWF0ZWQgYXMgb3JkaW5hcnkga2V5cyBpbiBhZGRpdGlvbiB0byBoYXZpbmcgdGhlaXIgb3duIHNwZWNpYWwKKyAqIG9wZXJhdGlvbnMuCiAgKi8KIHN0YXRpYyBpbnQga2V5cmluZ19pbnN0YW50aWF0ZShzdHJ1Y3Qga2V5ICprZXlyaW5nLAogCQkJICAgICAgIGNvbnN0IHZvaWQgKmRhdGEsIHNpemVfdCBkYXRhbGVuKTsKQEAgLTcxLDE5ICs3NSwxNyBAQAogCS5kZXNjcmliZQk9IGtleXJpbmdfZGVzY3JpYmUsCiAJLnJlYWQJCT0ga2V5cmluZ19yZWFkLAogfTsKLQogRVhQT1JUX1NZTUJPTChrZXlfdHlwZV9rZXlyaW5nKTsKIAogLyoKLSAqIHNlbWFwaG9yZSB0byBzZXJpYWxpc2UgbGluay9saW5rIGNhbGxzIHRvIHByZXZlbnQgdHdvIGxpbmsgY2FsbHMgaW4gcGFyYWxsZWwKLSAqIGludHJvZHVjaW5nIGEgY3ljbGUKKyAqIFNlbWFwaG9yZSB0byBzZXJpYWxpc2UgbGluay9saW5rIGNhbGxzIHRvIHByZXZlbnQgdHdvIGxpbmsgY2FsbHMgaW4gcGFyYWxsZWwKKyAqIGludHJvZHVjaW5nIGEgY3ljbGUuCiAgKi8KIHN0YXRpYyBERUNMQVJFX1JXU0VNKGtleXJpbmdfc2VyaWFsaXNlX2xpbmtfc2VtKTsKIAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIHB1Ymxpc2ggdGhlIG5hbWUgb2YgYSBrZXlyaW5nIHNvIHRoYXQgaXQgY2FuIGJlIGZvdW5kIGJ5IG5hbWUgKGlmIGl0IGhhcwotICogb25lKQorICogUHVibGlzaCB0aGUgbmFtZSBvZiBhIGtleXJpbmcgc28gdGhhdCBpdCBjYW4gYmUgZm91bmQgYnkgbmFtZSAoaWYgaXQgaGFzCisgKiBvbmUpLgogICovCiBzdGF0aWMgdm9pZCBrZXlyaW5nX3B1Ymxpc2hfbmFtZShzdHJ1Y3Qga2V5ICprZXlyaW5nKQogewpAQCAtMTAyLDEzICsxMDQsMTIgQEAKIAogCQl3cml0ZV91bmxvY2soJmtleXJpbmdfbmFtZV9sb2NrKTsKIAl9Cit9CiAKLX0gLyogZW5kIGtleXJpbmdfcHVibGlzaF9uYW1lKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIGluaXRpYWxpc2UgYSBrZXlyaW5nCi0gKiAtIHdlIG9iamVjdCBpZiB3ZSB3ZXJlIGdpdmVuIGFueSBkYXRhCisgKiBJbml0aWFsaXNlIGEga2V5cmluZy4KKyAqCisgKiBSZXR1cm5zIDAgb24gc3VjY2VzcywgLUVJTlZBTCBpZiBnaXZlbiBhbnkgZGF0YS4KICAqLwogc3RhdGljIGludCBrZXlyaW5nX2luc3RhbnRpYXRlKHN0cnVjdCBrZXkgKmtleXJpbmcsCiAJCQkgICAgICAgY29uc3Qgdm9pZCAqZGF0YSwgc2l6ZV90IGRhdGFsZW4pCkBAIC0xMjMsMjMgKzEyNCwyMCBAQAogCX0KIAogCXJldHVybiByZXQ7Cit9CiAKLX0gLyogZW5kIGtleXJpbmdfaW5zdGFudGlhdGUoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogbWF0Y2gga2V5cmluZ3Mgb24gdGhlaXIgbmFtZQorICogTWF0Y2gga2V5cmluZ3Mgb24gdGhlaXIgbmFtZQogICovCiBzdGF0aWMgaW50IGtleXJpbmdfbWF0Y2goY29uc3Qgc3RydWN0IGtleSAqa2V5cmluZywgY29uc3Qgdm9pZCAqZGVzY3JpcHRpb24pCiB7CiAJcmV0dXJuIGtleXJpbmctPmRlc2NyaXB0aW9uICYmCiAJCXN0cmNtcChrZXlyaW5nLT5kZXNjcmlwdGlvbiwgZGVzY3JpcHRpb24pID09IDA7Cit9CiAKLX0gLyogZW5kIGtleXJpbmdfbWF0Y2goKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogZGlzcG9zZSBvZiB0aGUgZGF0YSBkYW5nbGluZyBmcm9tIHRoZSBjb3Jwc2Ugb2YgYSBrZXlyaW5nCisgKiBDbGVhbiB1cCBhIGtleXJpbmcgd2hlbiBpdCBpcyBkZXN0cm95ZWQuICBVbnB1Ymxpc2ggaXRzIG5hbWUgaWYgaXQgaGFkIG9uZQorICogYW5kIGRpc3Bvc2Ugb2YgaXRzIGRhdGEuCiAgKi8KIHN0YXRpYyB2b2lkIGtleXJpbmdfZGVzdHJveShzdHJ1Y3Qga2V5ICprZXlyaW5nKQogewpAQCAtMTY0LDEyICsxNjIsMTAgQEAKIAkJCWtleV9wdXQoa2xpc3QtPmtleXNbbG9vcF0pOwogCQlrZnJlZShrbGlzdCk7CiAJfQorfQogCi19IC8qIGVuZCBrZXlyaW5nX2Rlc3Ryb3koKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogZGVzY3JpYmUgdGhlIGtleXJpbmcKKyAqIERlc2NyaWJlIGEga2V5cmluZyBmb3IgL3Byb2MuCiAgKi8KIHN0YXRpYyB2b2lkIGtleXJpbmdfZGVzY3JpYmUoY29uc3Qgc3RydWN0IGtleSAqa2V5cmluZywgc3RydWN0IHNlcV9maWxlICptKQogewpAQCAtMTg3LDEzICsxODMsMTIgQEAKIAllbHNlCiAJCXNlcV9wdXRzKG0sICI6IGVtcHR5Iik7CiAJcmN1X3JlYWRfdW5sb2NrKCk7Cit9CiAKLX0gLyogZW5kIGtleXJpbmdfZGVzY3JpYmUoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogcmVhZCBhIGxpc3Qgb2Yga2V5IElEcyBmcm9tIHRoZSBrZXlyaW5nJ3MgY29udGVudHMKLSAqIC0gdGhlIGtleXJpbmcncyBzZW1hcGhvcmUgaXMgcmVhZC1sb2NrZWQKKyAqIFJlYWQgYSBsaXN0IG9mIGtleSBJRHMgZnJvbSB0aGUga2V5cmluZydzIGNvbnRlbnRzIGluIGJpbmFyeSBmb3JtCisgKgorICogVGhlIGtleXJpbmcncyBzZW1hcGhvcmUgaXMgcmVhZC1sb2NrZWQgYnkgdGhlIGNhbGxlci4KICAqLwogc3RhdGljIGxvbmcga2V5cmluZ19yZWFkKGNvbnN0IHN0cnVjdCBrZXkgKmtleXJpbmcsCiAJCQkgY2hhciBfX3VzZXIgKmJ1ZmZlciwgc2l6ZV90IGJ1ZmxlbikKQEAgLTI0MSwxMiArMjM2LDEwIEBACiAKIGVycm9yOgogCXJldHVybiByZXQ7Cit9CiAKLX0gLyogZW5kIGtleXJpbmdfcmVhZCgpICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBhbGxvY2F0ZSBhIGtleXJpbmcgYW5kIGxpbmsgaW50byB0aGUgZGVzdGluYXRpb24ga2V5cmluZworICogQWxsb2NhdGUgYSBrZXlyaW5nIGFuZCBsaW5rIGludG8gdGhlIGRlc3RpbmF0aW9uIGtleXJpbmcuCiAgKi8KIHN0cnVjdCBrZXkgKmtleXJpbmdfYWxsb2MoY29uc3QgY2hhciAqZGVzY3JpcHRpb24sIHVpZF90IHVpZCwgZ2lkX3QgZ2lkLAogCQkJICBjb25zdCBzdHJ1Y3QgY3JlZCAqY3JlZCwgdW5zaWduZWQgbG9uZyBmbGFncywKQEAgLTI2OSwyMCArMjYyLDQyIEBACiAJfQogCiAJcmV0dXJuIGtleXJpbmc7Cit9CiAKLX0gLyogZW5kIGtleXJpbmdfYWxsb2MoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi0vKgotICogc2VhcmNoIHRoZSBzdXBwbGllZCBrZXlyaW5nIHRyZWUgZm9yIGEga2V5IHRoYXQgbWF0Y2hlcyB0aGUgY3JpdGVyaW9uCi0gKiAtIHBlcmZvcm0gYSBicmVhZHRoLXRoZW4tZGVwdGggc2VhcmNoIHVwIHRvIHRoZSBwcmVzY3JpYmVkIGxpbWl0Ci0gKiAtIHdlIG9ubHkgZmluZCBrZXlzIG9uIHdoaWNoIHdlIGhhdmUgc2VhcmNoIHBlcm1pc3Npb24KLSAqIC0gd2UgdXNlIHRoZSBzdXBwbGllZCBtYXRjaCBmdW5jdGlvbiB0byBzZWUgaWYgdGhlIGRlc2NyaXB0aW9uIChvciBvdGhlcgotICogICBmZWF0dXJlIG9mIGludGVyZXN0KSBtYXRjaGVzCi0gKiAtIHdlIHJlbHkgb24gUkNVIHRvIHByZXZlbnQgdGhlIGtleXJpbmcgbGlzdHMgZnJvbSBkaXNhcHBlYXJpbmcgb24gdXMKLSAqIC0gd2UgcmV0dXJuIC1FQUdBSU4gaWYgd2UgZGlkbid0IGZpbmQgYW55IG1hdGNoaW5nIGtleQotICogLSB3ZSByZXR1cm4gLUVOT0tFWSBpZiB3ZSBvbmx5IGZvdW5kIG5lZ2F0aXZlIG1hdGNoaW5nIGtleXMKLSAqIC0gd2UgcHJvcGFnYXRlIHRoZSBwb3NzZXNzaW9uIGF0dHJpYnV0ZSBmcm9tIHRoZSBrZXlyaW5nIHJlZiB0byB0aGUga2V5IHJlZgorLyoqCisgKiBrZXlyaW5nX3NlYXJjaF9hdXggLSBTZWFyY2ggYSBrZXlyaW5nIHRyZWUgZm9yIGEga2V5IG1hdGNoaW5nIHNvbWUgY3JpdGVyaWEKKyAqIEBrZXlyaW5nX3JlZjogQSBwb2ludGVyIHRvIHRoZSBrZXlyaW5nIHdpdGggcG9zc2Vzc2lvbiBpbmRpY2F0b3IuCisgKiBAY3JlZDogVGhlIGNyZWRlbnRpYWxzIHRvIHVzZSBmb3IgcGVybWlzc2lvbnMgY2hlY2tzLgorICogQHR5cGU6IFRoZSB0eXBlIG9mIGtleSB0byBzZWFyY2ggZm9yLgorICogQGRlc2NyaXB0aW9uOiBQYXJhbWV0ZXIgZm9yIEBtYXRjaC4KKyAqIEBtYXRjaDogRnVuY3Rpb24gdG8gcnVsZSBvbiB3aGV0aGVyIG9yIG5vdCBhIGtleSBpcyB0aGUgb25lIHJlcXVpcmVkLgorICoKKyAqIFNlYXJjaCB0aGUgc3VwcGxpZWQga2V5cmluZyB0cmVlIGZvciBhIGtleSB0aGF0IG1hdGNoZXMgdGhlIGNyaXRlcmlhIGdpdmVuLgorICogVGhlIHJvb3Qga2V5cmluZyBhbmQgYW55IGxpbmtlZCBrZXlyaW5ncyBtdXN0IGdyYW50IFNlYXJjaCBwZXJtaXNzaW9uIHRvIHRoZQorICogY2FsbGVyIHRvIGJlIHNlYXJjaGFibGUgYW5kIGtleXMgY2FuIG9ubHkgYmUgZm91bmQgaWYgdGhleSB0b28gZ3JhbnQgU2VhcmNoCisgKiB0byB0aGUgY2FsbGVyLiBUaGUgcG9zc2Vzc2lvbiBmbGFnIG9uIHRoZSByb290IGtleXJpbmcgcG9pbnRlciBjb250cm9scyB1c2UKKyAqIG9mIHRoZSBwb3NzZXNzb3IgYml0cyBpbiBwZXJtaXNzaW9ucyBjaGVja2luZyBvZiB0aGUgZW50aXJlIHRyZWUuICBJbgorICogYWRkaXRpb24sIHRoZSBMU00gZ2V0cyB0byBmb3JiaWQga2V5cmluZyBzZWFyY2hlcyBhbmQga2V5IG1hdGNoZXMuCisgKgorICogVGhlIHNlYXJjaCBpcyBwZXJmb3JtZWQgYXMgYSBicmVhZHRoLXRoZW4tZGVwdGggc2VhcmNoIHVwIHRvIHRoZSBwcmVzY3JpYmVkCisgKiBsaW1pdCAoS0VZUklOR19TRUFSQ0hfTUFYX0RFUFRIKS4KKyAqCisgKiBLZXlzIGFyZSBtYXRjaGVkIHRvIHRoZSB0eXBlIHByb3ZpZGVkIGFuZCBhcmUgdGhlbiBmaWx0ZXJlZCBieSB0aGUgbWF0Y2gKKyAqIGZ1bmN0aW9uLCB3aGljaCBpcyBnaXZlbiB0aGUgZGVzY3JpcHRpb24gdG8gdXNlIGluIGFueSB3YXkgaXQgc2VlcyBmaXQuICBUaGUKKyAqIG1hdGNoIGZ1bmN0aW9uIG1heSB1c2UgYW55IGF0dHJpYnV0ZXMgb2YgYSBrZXkgdGhhdCBpdCB3aXNoZXMgdG8gdG8KKyAqIGRldGVybWluZSB0aGUgbWF0Y2guICBOb3JtYWxseSB0aGUgbWF0Y2ggZnVuY3Rpb24gZnJvbSB0aGUga2V5IHR5cGUgd291bGQgYmUKKyAqIHVzZWQuCisgKgorICogUkNVIGlzIHVzZWQgdG8gcHJldmVudCB0aGUga2V5cmluZyBrZXkgbGlzdHMgZnJvbSBkaXNhcHBlYXJpbmcgd2l0aG91dCB0aGUKKyAqIG5lZWQgdG8gdGFrZSBsb3RzIG9mIGxvY2tzLgorICoKKyAqIFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBmb3VuZCBrZXkgYW5kIGluY3JlbWVudHMgdGhlIGtleSB1c2FnZSBjb3VudCBpZgorICogc3VjY2Vzc2Z1bDsgLUVBR0FJTiBpZiBubyBtYXRjaGluZyBrZXlzIHdlcmUgZm91bmQsIG9yIGlmIGV4cGlyZWQgb3IgcmV2b2tlZAorICoga2V5cyB3ZXJlIGZvdW5kOyAtRU5PS0VZIGlmIG9ubHkgbmVnYXRpdmUga2V5cyB3ZXJlIGZvdW5kOyAtRU5PVERJUiBpZiB0aGUKKyAqIHNwZWNpZmllZCBrZXlyaW5nIHdhc24ndCBhIGtleXJpbmcuCisgKgorICogSW4gdGhlIGNhc2Ugb2YgYSBzdWNjZXNzZnVsIHJldHVybiwgdGhlIHBvc3Nlc3Npb24gYXR0cmlidXRlIGZyb20KKyAqIEBrZXlyaW5nX3JlZiBpcyBwcm9wYWdhdGVkIHRvIHRoZSByZXR1cm5lZCBrZXkgcmVmZXJlbmNlLgogICovCiBrZXlfcmVmX3Qga2V5cmluZ19zZWFyY2hfYXV4KGtleV9yZWZfdCBrZXlyaW5nX3JlZiwKIAkJCSAgICAgY29uc3Qgc3RydWN0IGNyZWQgKmNyZWQsCkBAIC00NDQsMTcgKzQ1OSwxNiBAQAogCXJjdV9yZWFkX3VubG9jaygpOwogZXJyb3I6CiAJcmV0dXJuIGtleV9yZWY7Cit9CiAKLX0gLyogZW5kIGtleXJpbmdfc2VhcmNoX2F1eCgpICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLS8qCi0gKiBzZWFyY2ggdGhlIHN1cHBsaWVkIGtleXJpbmcgdHJlZSBmb3IgYSBrZXkgdGhhdCBtYXRjaGVzIHRoZSBjcml0ZXJpb24KLSAqIC0gcGVyZm9ybSBhIGJyZWFkdGgtdGhlbi1kZXB0aCBzZWFyY2ggdXAgdG8gdGhlIHByZXNjcmliZWQgbGltaXQKLSAqIC0gd2Ugb25seSBmaW5kIGtleXMgb24gd2hpY2ggd2UgaGF2ZSBzZWFyY2ggcGVybWlzc2lvbgotICogLSB3ZSByZWFkbG9jayB0aGUga2V5cmluZ3MgYXMgd2Ugc2VhcmNoIGRvd24gdGhlIHRyZWUKLSAqIC0gd2UgcmV0dXJuIC1FQUdBSU4gaWYgd2UgZGlkbid0IGZpbmQgYW55IG1hdGNoaW5nIGtleQotICogLSB3ZSByZXR1cm4gLUVOT0tFWSBpZiB3ZSBvbmx5IGZvdW5kIG5lZ2F0aXZlIG1hdGNoaW5nIGtleXMKKy8qKgorICoga2V5cmluZ19zZWFyY2ggLSBTZWFyY2ggdGhlIHN1cHBsaWVkIGtleXJpbmcgdHJlZSBmb3IgYSBtYXRjaGluZyBrZXkKKyAqIEBrZXlyaW5nOiBUaGUgcm9vdCBvZiB0aGUga2V5cmluZyB0cmVlIHRvIGJlIHNlYXJjaGVkLgorICogQHR5cGU6IFRoZSB0eXBlIG9mIGtleXJpbmcgd2Ugd2FudCB0byBmaW5kLgorICogQGRlc2NyaXB0aW9uOiBUaGUgbmFtZSBvZiB0aGUga2V5cmluZyB3ZSB3YW50IHRvIGZpbmQuCisgKgorICogQXMga2V5cmluZ19zZWFyY2hfYXV4KCkgYWJvdmUsIGJ1dCB1c2luZyB0aGUgY3VycmVudCB0YXNrJ3MgY3JlZGVudGlhbHMgYW5kCisgKiB0eXBlJ3MgZGVmYXVsdCBtYXRjaGluZyBmdW5jdGlvbi4KICAqLwoga2V5X3JlZl90IGtleXJpbmdfc2VhcmNoKGtleV9yZWZfdCBrZXlyaW5nLAogCQkJIHN0cnVjdCBrZXlfdHlwZSAqdHlwZSwKQEAgLTQ2NSwxNiArNDc5LDIzIEBACiAKIAlyZXR1cm4ga2V5cmluZ19zZWFyY2hfYXV4KGtleXJpbmcsIGN1cnJlbnQtPmNyZWQsCiAJCQkJICB0eXBlLCBkZXNjcmlwdGlvbiwgdHlwZS0+bWF0Y2gpOwotCi19IC8qIGVuZCBrZXlyaW5nX3NlYXJjaCgpICovCi0KK30KIEVYUE9SVF9TWU1CT0woa2V5cmluZ19zZWFyY2gpOwogCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogc2VhcmNoIHRoZSBnaXZlbiBrZXlyaW5nIG9ubHkgKG5vIHJlY3Vyc2lvbikKLSAqIC0ga2V5cmluZyBtdXN0IGJlIGxvY2tlZCBieSBjYWxsZXIKLSAqIC0gY2FsbGVyIG11c3QgZ3VhcmFudGVlIHRoYXQgdGhlIGtleXJpbmcgaXMgYSBrZXlyaW5nCisgKiBTZWFyY2ggdGhlIGdpdmVuIGtleXJpbmcgb25seSAobm8gcmVjdXJzaW9uKS4KKyAqCisgKiBUaGUgY2FsbGVyIG11c3QgZ3VhcmFudGVlIHRoYXQgdGhlIGtleXJpbmcgaXMgYSBrZXlyaW5nIGFuZCB0aGF0IHRoZQorICogcGVybWlzc2lvbiBpcyBncmFudGVkIHRvIHNlYXJjaCB0aGUga2V5cmluZyBhcyBubyBjaGVjayBpcyBtYWRlIGhlcmUuCisgKgorICogUkNVIGlzIHVzZWQgdG8gbWFrZSBpdCB1bm5lY2Vzc2FyeSB0byBsb2NrIHRoZSBrZXlyaW5nIGtleSBsaXN0IGhlcmUuCisgKgorICogUmV0dXJucyBhIHBvaW50ZXIgdG8gdGhlIGZvdW5kIGtleSB3aXRoIHVzYWdlIGNvdW50IGluY3JlbWVudGVkIGlmCisgKiBzdWNjZXNzZnVsIGFuZCByZXR1cm5zIC1FTk9LRVkgaWYgbm90IGZvdW5kLiAgUmV2b2tlZCBrZXlzIGFuZCBrZXlzIG5vdAorICogcHJvdmlkaW5nIHRoZSByZXF1ZXN0ZWQgcGVybWlzc2lvbiBhcmUgc2tpcHBlZCBvdmVyLgorICoKKyAqIElmIHN1Y2Nlc3NmdWwsIHRoZSBwb3NzZXNzaW9uIGluZGljYXRvciBpcyBwcm9wYWdhdGVkIGZyb20gdGhlIGtleXJpbmcgcmVmCisgKiB0byB0aGUgcmV0dXJuZWQga2V5IHJlZmVyZW5jZS4KICAqLwoga2V5X3JlZl90IF9fa2V5cmluZ19zZWFyY2hfb25lKGtleV9yZWZfdCBrZXlyaW5nX3JlZiwKIAkJCSAgICAgICBjb25zdCBzdHJ1Y3Qga2V5X3R5cGUgKmt0eXBlLApAQCAtNTE0LDE0ICs1MzUsMTggQEAKIAlhdG9taWNfaW5jKCZrZXktPnVzYWdlKTsKIAlyY3VfcmVhZF91bmxvY2soKTsKIAlyZXR1cm4gbWFrZV9rZXlfcmVmKGtleSwgcG9zc2Vzc2VkKTsKK30KIAotfSAvKiBlbmQgX19rZXlyaW5nX3NlYXJjaF9vbmUoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogZmluZCBhIGtleXJpbmcgd2l0aCB0aGUgc3BlY2lmaWVkIG5hbWUKLSAqIC0gYWxsIG5hbWVkIGtleXJpbmdzIGFyZSBzZWFyY2hlZAotICogLSBub3JtYWxseSBvbmx5IGZpbmRzIGtleXJpbmdzIHdpdGggc2VhcmNoIHBlcm1pc3Npb24gZm9yIHRoZSBjdXJyZW50IHByb2Nlc3MKKyAqIEZpbmQgYSBrZXlyaW5nIHdpdGggdGhlIHNwZWNpZmllZCBuYW1lLgorICoKKyAqIEFsbCBuYW1lZCBrZXlyaW5ncyBpbiB0aGUgY3VycmVudCB1c2VyIG5hbWVzcGFjZSBhcmUgc2VhcmNoZWQsIHByb3ZpZGVkIHRoZXkKKyAqIGdyYW50IFNlYXJjaCBwZXJtaXNzaW9uIGRpcmVjdGx5IHRvIHRoZSBjYWxsZXIgKHVubGVzcyB0aGlzIGNoZWNrIGlzCisgKiBza2lwcGVkKS4gIEtleXJpbmdzIHdob3NlIHVzYWdlIHBvaW50cyBoYXZlIHJlYWNoZWQgemVybyBvciB3aG8gaGF2ZSBiZWVuCisgKiByZXZva2VkIGFyZSBza2lwcGVkLgorICoKKyAqIFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBrZXlyaW5nIHdpdGggdGhlIGtleXJpbmcncyByZWZjb3VudCBoYXZpbmcgYmVpbmcKKyAqIGluY3JlbWVudGVkIG9uIHN1Y2Nlc3MuICAtRU5PS0VZIGlzIHJldHVybmVkIGlmIGEga2V5IGNvdWxkIG5vdCBiZSBmb3VuZC4KICAqLwogc3RydWN0IGtleSAqZmluZF9rZXlyaW5nX2J5X25hbWUoY29uc3QgY2hhciAqbmFtZSwgYm9vbCBza2lwX3Blcm1fY2hlY2spCiB7CkBAIC01NjksMTUgKzU5NCwxNCBAQAogb3V0OgogCXJlYWRfdW5sb2NrKCZrZXlyaW5nX25hbWVfbG9jayk7CiAJcmV0dXJuIGtleXJpbmc7Cit9CiAKLX0gLyogZW5kIGZpbmRfa2V5cmluZ19ieV9uYW1lKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIHNlZSBpZiBhIGN5Y2xlIHdpbGwgd2lsbCBiZSBjcmVhdGVkIGJ5IGluc2VydGluZyBhY3ljbGljIHRyZWUgQiBpbiBhY3ljbGljCi0gKiB0cmVlIEEgYXQgdGhlIHRvcG1vc3QgbGV2ZWwgKGllOiBhcyBhIGRpcmVjdCBjaGlsZCBvZiBBKQotICogLSBzaW5jZSB3ZSBhcmUgYWRkaW5nIEIgdG8gQSBhdCB0aGUgdG9wIGxldmVsLCBjaGVja2luZyBmb3IgY3ljbGVzIHNob3VsZAotICogICBqdXN0IGJlIGEgbWF0dGVyIG9mIHNlZWluZyBpZiBub2RlIEEgaXMgc29tZXdoZXJlIGluIHRyZWUgQgorICogU2VlIGlmIGEgY3ljbGUgd2lsbCB3aWxsIGJlIGNyZWF0ZWQgYnkgaW5zZXJ0aW5nIGFjeWNsaWMgdHJlZSBCIGluIGFjeWNsaWMKKyAqIHRyZWUgQSBhdCB0aGUgdG9wbW9zdCBsZXZlbCAoaWU6IGFzIGEgZGlyZWN0IGNoaWxkIG9mIEEpLgorICoKKyAqIFNpbmNlIHdlIGFyZSBhZGRpbmcgQiB0byBBIGF0IHRoZSB0b3AgbGV2ZWwsIGNoZWNraW5nIGZvciBjeWNsZXMgc2hvdWxkIGp1c3QKKyAqIGJlIGEgbWF0dGVyIG9mIHNlZWluZyBpZiBub2RlIEEgaXMgc29tZXdoZXJlIGluIHRyZWUgQi4KICAqLwogc3RhdGljIGludCBrZXlyaW5nX2RldGVjdF9jeWNsZShzdHJ1Y3Qga2V5ICpBLCBzdHJ1Y3Qga2V5ICpCKQogewpAQCAtNjU3LDExICs2ODEsMTAgQEAKIGN5Y2xlX2RldGVjdGVkOgogCXJldCA9IC1FREVBRExLOwogCWdvdG8gZXJyb3I7Ci0KLX0gLyogZW5kIGtleXJpbmdfZGV0ZWN0X2N5Y2xlKCkgKi8KK30KIAogLyoKLSAqIGRpc3Bvc2Ugb2YgYSBrZXlyaW5nIGxpc3QgYWZ0ZXIgdGhlIFJDVSBncmFjZSBwZXJpb2QsIGZyZWVpbmcgdGhlIHVubGlua2VkCisgKiBEaXNwb3NlIG9mIGEga2V5cmluZyBsaXN0IGFmdGVyIHRoZSBSQ1UgZ3JhY2UgcGVyaW9kLCBmcmVlaW5nIHRoZSB1bmxpbmtlZAogICoga2V5CiAgKi8KIHN0YXRpYyB2b2lkIGtleXJpbmdfdW5saW5rX3JjdV9kaXNwb3NhbChzdHJ1Y3QgcmN1X2hlYWQgKnJjdSkKQEAgLTY3NSwxNCArNjk4LDE0IEBACiB9CiAKIC8qCi0gKiBwcmVhbGxvY2F0ZSBtZW1vcnkgc28gdGhhdCBhIGtleSBjYW4gYmUgbGlua2VkIGludG8gdG8gYSBrZXlyaW5nCisgKiBQcmVhbGxvY2F0ZSBtZW1vcnkgc28gdGhhdCBhIGtleSBjYW4gYmUgbGlua2VkIGludG8gdG8gYSBrZXlyaW5nLgogICovCiBpbnQgX19rZXlfbGlua19iZWdpbihzdHJ1Y3Qga2V5ICprZXlyaW5nLCBjb25zdCBzdHJ1Y3Qga2V5X3R5cGUgKnR5cGUsCi0JCSAgICAgY29uc3QgY2hhciAqZGVzY3JpcHRpb24sCi0JCSAgICAgc3RydWN0IGtleXJpbmdfbGlzdCAqKl9wcmVhbGxvYykKKwkJICAgICBjb25zdCBjaGFyICpkZXNjcmlwdGlvbiwgdW5zaWduZWQgbG9uZyAqX3ByZWFsbG9jKQogCV9fYWNxdWlyZXMoJmtleXJpbmctPnNlbSkKIHsKIAlzdHJ1Y3Qga2V5cmluZ19saXN0ICprbGlzdCwgKm5rbGlzdDsKKwl1bnNpZ25lZCBsb25nIHByZWFsbG9jOwogCXVuc2lnbmVkIG1heDsKIAlzaXplX3Qgc2l6ZTsKIAlpbnQgbG9vcCwgcmV0OwpAQCAtNzI1LDYgKzc0OCw3IEBACiAKIAkJCQkvKiBub3RlIHJlcGxhY2VtZW50IHNsb3QgKi8KIAkJCQlrbGlzdC0+ZGVsa2V5ID0gbmtsaXN0LT5kZWxrZXkgPSBsb29wOworCQkJCXByZWFsbG9jID0gKHVuc2lnbmVkIGxvbmcpbmtsaXN0OwogCQkJCWdvdG8gZG9uZTsKIAkJCX0KIAkJfQpAQCAtNzM5LDYgKzc2Myw3IEBACiAJaWYgKGtsaXN0ICYmIGtsaXN0LT5ua2V5cyA8IGtsaXN0LT5tYXhrZXlzKSB7CiAJCS8qIHRoZXJlJ3Mgc3VmZmljaWVudCBzbGFjayBzcGFjZSB0byBhcHBlbmQgZGlyZWN0bHkgKi8KIAkJbmtsaXN0ID0gTlVMTDsKKwkJcHJlYWxsb2MgPSBLRVlfTElOS19GSVhRVU9UQTsKIAl9IGVsc2UgewogCQkvKiBncm93IHRoZSBrZXkgbGlzdCAqLwogCQltYXggPSA0OwpAQCAtNzczLDggKzc5OCw5IEBACiAJCW5rbGlzdC0+a2V5c1tua2xpc3QtPmRlbGtleV0gPSBOVUxMOwogCX0KIAorCXByZWFsbG9jID0gKHVuc2lnbmVkIGxvbmcpbmtsaXN0IHwgS0VZX0xJTktfRklYUVVPVEE7CiBkb25lOgotCSpfcHJlYWxsb2MgPSBua2xpc3Q7CisJKl9wcmVhbGxvYyA9IHByZWFsbG9jOwogCWtsZWF2ZSgiID0gMCIpOwogCXJldHVybiAwOwogCkBAIC03OTIsMTAgKzgxOCwxMCBAQAogfQogCiAvKgotICogY2hlY2sgYWxyZWFkeSBpbnN0YW50aWF0ZWQga2V5cyBhcmVuJ3QgZ29pbmcgdG8gYmUgYSBwcm9ibGVtCi0gKiAtIHRoZSBjYWxsZXIgbXVzdCBoYXZlIGNhbGxlZCBfX2tleV9saW5rX2JlZ2luKCkKLSAqIC0gZG9uJ3QgbmVlZCB0byBjYWxsIHRoaXMgZm9yIGtleXMgdGhhdCB3ZXJlIGNyZWF0ZWQgc2luY2UgX19rZXlfbGlua19iZWdpbigpCi0gKiAgIHdhcyBjYWxsZWQKKyAqIENoZWNrIGFscmVhZHkgaW5zdGFudGlhdGVkIGtleXMgYXJlbid0IGdvaW5nIHRvIGJlIGEgcHJvYmxlbS4KKyAqCisgKiBUaGUgY2FsbGVyIG11c3QgaGF2ZSBjYWxsZWQgX19rZXlfbGlua19iZWdpbigpLiBEb24ndCBuZWVkIHRvIGNhbGwgdGhpcyBmb3IKKyAqIGtleXMgdGhhdCB3ZXJlIGNyZWF0ZWQgc2luY2UgX19rZXlfbGlua19iZWdpbigpIHdhcyBjYWxsZWQuCiAgKi8KIGludCBfX2tleV9saW5rX2NoZWNrX2xpdmVfa2V5KHN0cnVjdCBrZXkgKmtleXJpbmcsIHN0cnVjdCBrZXkgKmtleSkKIHsKQEAgLTgwNywxNyArODMzLDIwIEBACiB9CiAKIC8qCi0gKiBsaW5rIGEga2V5IGludG8gdG8gYSBrZXlyaW5nCi0gKiAtIG11c3QgYmUgY2FsbGVkIHdpdGggX19rZXlfbGlua19iZWdpbigpIGhhdmluZyBiZWluZyBjYWxsZWQKLSAqIC0gZGlzY2FyZCBhbHJlYWR5IGV4dGFudCBsaW5rIHRvIG1hdGNoaW5nIGtleSBpZiB0aGVyZSBpcyBvbmUKKyAqIExpbmsgYSBrZXkgaW50byB0byBhIGtleXJpbmcuCisgKgorICogTXVzdCBiZSBjYWxsZWQgd2l0aCBfX2tleV9saW5rX2JlZ2luKCkgaGF2aW5nIGJlaW5nIGNhbGxlZC4gIERpc2NhcmRzIGFueQorICogYWxyZWFkeSBleHRhbnQgbGluayB0byBtYXRjaGluZyBrZXkgaWYgdGhlcmUgaXMgb25lLCBzbyB0aGF0IGVhY2gga2V5cmluZworICogaG9sZHMgYXQgbW9zdCBvbmUgbGluayB0byBhbnkgZ2l2ZW4ga2V5IG9mIGEgcGFydGljdWxhciB0eXBlK2Rlc2NyaXB0aW9uCisgKiBjb21iaW5hdGlvbi4KICAqLwogdm9pZCBfX2tleV9saW5rKHN0cnVjdCBrZXkgKmtleXJpbmcsIHN0cnVjdCBrZXkgKmtleSwKLQkJc3RydWN0IGtleXJpbmdfbGlzdCAqKl9wcmVhbGxvYykKKwkJdW5zaWduZWQgbG9uZyAqX3ByZWFsbG9jKQogewogCXN0cnVjdCBrZXlyaW5nX2xpc3QgKmtsaXN0LCAqbmtsaXN0OwogCi0JbmtsaXN0ID0gKl9wcmVhbGxvYzsKLQkqX3ByZWFsbG9jID0gTlVMTDsKKwlua2xpc3QgPSAoc3RydWN0IGtleXJpbmdfbGlzdCAqKSgqX3ByZWFsbG9jICYgfktFWV9MSU5LX0ZJWFFVT1RBKTsKKwkqX3ByZWFsbG9jID0gMDsKIAogCWtlbnRlcigiJWQsJWQsJXAiLCBrZXlyaW5nLT5zZXJpYWwsIGtleS0+c2VyaWFsLCBua2xpc3QpOwogCkBAIC04NTIsMzQgKzg4MSw1NCBAQAogfQogCiAvKgotICogZmluaXNoIGxpbmtpbmcgYSBrZXkgaW50byB0byBhIGtleXJpbmcKLSAqIC0gbXVzdCBiZSBjYWxsZWQgd2l0aCBfX2tleV9saW5rX2JlZ2luKCkgaGF2aW5nIGJlaW5nIGNhbGxlZAorICogRmluaXNoIGxpbmtpbmcgYSBrZXkgaW50byB0byBhIGtleXJpbmcuCisgKgorICogTXVzdCBiZSBjYWxsZWQgd2l0aCBfX2tleV9saW5rX2JlZ2luKCkgaGF2aW5nIGJlaW5nIGNhbGxlZC4KICAqLwogdm9pZCBfX2tleV9saW5rX2VuZChzdHJ1Y3Qga2V5ICprZXlyaW5nLCBzdHJ1Y3Qga2V5X3R5cGUgKnR5cGUsCi0JCSAgICBzdHJ1Y3Qga2V5cmluZ19saXN0ICpwcmVhbGxvYykKKwkJICAgIHVuc2lnbmVkIGxvbmcgcHJlYWxsb2MpCiAJX19yZWxlYXNlcygma2V5cmluZy0+c2VtKQogewogCUJVR19PTih0eXBlID09IE5VTEwpOwogCUJVR19PTih0eXBlLT5uYW1lID09IE5VTEwpOwotCWtlbnRlcigiJWQsJXMsJXAiLCBrZXlyaW5nLT5zZXJpYWwsIHR5cGUtPm5hbWUsIHByZWFsbG9jKTsKKwlrZW50ZXIoIiVkLCVzLCVseCIsIGtleXJpbmctPnNlcmlhbCwgdHlwZS0+bmFtZSwgcHJlYWxsb2MpOwogCiAJaWYgKHR5cGUgPT0gJmtleV90eXBlX2tleXJpbmcpCiAJCXVwX3dyaXRlKCZrZXlyaW5nX3NlcmlhbGlzZV9saW5rX3NlbSk7CiAKIAlpZiAocHJlYWxsb2MpIHsKLQkJa2ZyZWUocHJlYWxsb2MpOwotCQlrZXlfcGF5bG9hZF9yZXNlcnZlKGtleXJpbmcsCi0JCQkJICAgIGtleXJpbmctPmRhdGFsZW4gLSBLRVlRVU9UQV9MSU5LX0JZVEVTKTsKKwkJaWYgKHByZWFsbG9jICYgS0VZX0xJTktfRklYUVVPVEEpCisJCQlrZXlfcGF5bG9hZF9yZXNlcnZlKGtleXJpbmcsCisJCQkJCSAgICBrZXlyaW5nLT5kYXRhbGVuIC0KKwkJCQkJICAgIEtFWVFVT1RBX0xJTktfQllURVMpOworCQlrZnJlZSgoc3RydWN0IGtleXJpbmdfbGlzdCAqKShwcmVhbGxvYyAmIH5LRVlfTElOS19GSVhRVU9UQSkpOwogCX0KIAl1cF93cml0ZSgma2V5cmluZy0+c2VtKTsKIH0KIAotLyoKLSAqIGxpbmsgYSBrZXkgdG8gYSBrZXlyaW5nCisvKioKKyAqIGtleV9saW5rIC0gTGluayBhIGtleSB0byBhIGtleXJpbmcKKyAqIEBrZXlyaW5nOiBUaGUga2V5cmluZyB0byBtYWtlIHRoZSBsaW5rIGluLgorICogQGtleTogVGhlIGtleSB0byBsaW5rIHRvLgorICoKKyAqIE1ha2UgYSBsaW5rIGluIGEga2V5cmluZyB0byBhIGtleSwgc3VjaCB0aGF0IHRoZSBrZXlyaW5nIGhvbGRzIGEgcmVmZXJlbmNlCisgKiBvbiB0aGF0IGtleSBhbmQgdGhlIGtleSBjYW4gcG90ZW50aWFsbHkgYmUgZm91bmQgYnkgc2VhcmNoaW5nIHRoYXQga2V5cmluZy4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIHdpbGwgd3JpdGUtbG9jayB0aGUga2V5cmluZydzIHNlbWFwaG9yZSBhbmQgd2lsbCBjb25zdW1lIHNvbWUKKyAqIG9mIHRoZSB1c2VyJ3Mga2V5IGRhdGEgcXVvdGEgdG8gaG9sZCB0aGUgbGluay4KKyAqCisgKiBSZXR1cm5zIDAgaWYgc3VjY2Vzc2Z1bCwgLUVOT1RESVIgaWYgdGhlIGtleXJpbmcgaXNuJ3QgYSBrZXlyaW5nLAorICogLUVLRVlSRVZPS0VEIGlmIHRoZSBrZXlyaW5nIGhhcyBiZWVuIHJldm9rZWQsIC1FTkZJTEUgaWYgdGhlIGtleXJpbmcgaXMKKyAqIGZ1bGwsIC1FRFFVT1QgaWYgdGhlcmUgaXMgaW5zdWZmaWNpZW50IGtleSBkYXRhIHF1b3RhIHJlbWFpbmluZyB0byBhZGQKKyAqIGFub3RoZXIgbGluayBvciAtRU5PTUVNIGlmIHRoZXJlJ3MgaW5zdWZmaWNpZW50IG1lbW9yeS4KKyAqCisgKiBJdCBpcyBhc3N1bWVkIHRoYXQgdGhlIGNhbGxlciBoYXMgY2hlY2tlZCB0aGF0IGl0IGlzIHBlcm1pdHRlZCBmb3IgYSBsaW5rIHRvCisgKiBiZSBtYWRlICh0aGUga2V5cmluZyBzaG91bGQgaGF2ZSBXcml0ZSBwZXJtaXNzaW9uIGFuZCB0aGUga2V5IExpbmsKKyAqIHBlcm1pc3Npb24pLgogICovCiBpbnQga2V5X2xpbmsoc3RydWN0IGtleSAqa2V5cmluZywgc3RydWN0IGtleSAqa2V5KQogewotCXN0cnVjdCBrZXlyaW5nX2xpc3QgKnByZWFsbG9jOworCXVuc2lnbmVkIGxvbmcgcHJlYWxsb2M7CiAJaW50IHJldDsKIAogCWtleV9jaGVjayhrZXlyaW5nKTsKQEAgLTg5NSwxMiArOTQ0LDI0IEBACiAKIAlyZXR1cm4gcmV0OwogfQotCiBFWFBPUlRfU1lNQk9MKGtleV9saW5rKTsKIAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotLyoKLSAqIHVubGluayB0aGUgZmlyc3QgbGluayB0byBhIGtleSBmcm9tIGEga2V5cmluZworLyoqCisgKiBrZXlfdW5saW5rIC0gVW5saW5rIHRoZSBmaXJzdCBsaW5rIHRvIGEga2V5IGZyb20gYSBrZXlyaW5nLgorICogQGtleXJpbmc6IFRoZSBrZXlyaW5nIHRvIHJlbW92ZSB0aGUgbGluayBmcm9tLgorICogQGtleTogVGhlIGtleSB0aGUgbGluayBpcyB0by4KKyAqCisgKiBSZW1vdmUgYSBsaW5rIGZyb20gYSBrZXlyaW5nIHRvIGEga2V5LgorICoKKyAqIFRoaXMgZnVuY3Rpb24gd2lsbCB3cml0ZS1sb2NrIHRoZSBrZXlyaW5nJ3Mgc2VtYXBob3JlLgorICoKKyAqIFJldHVybnMgMCBpZiBzdWNjZXNzZnVsLCAtRU5PVERJUiBpZiB0aGUga2V5cmluZyBpc24ndCBhIGtleXJpbmcsIC1FTk9FTlQgaWYKKyAqIHRoZSBrZXkgaXNuJ3QgbGlua2VkIHRvIGJ5IHRoZSBrZXlyaW5nIG9yIC1FTk9NRU0gaWYgdGhlcmUncyBpbnN1ZmZpY2llbnQKKyAqIG1lbW9yeS4KKyAqCisgKiBJdCBpcyBhc3N1bWVkIHRoYXQgdGhlIGNhbGxlciBoYXMgY2hlY2tlZCB0aGF0IGl0IGlzIHBlcm1pdHRlZCBmb3IgYSBsaW5rIHRvCisgKiBiZSByZW1vdmVkICh0aGUga2V5cmluZyBzaG91bGQgaGF2ZSBXcml0ZSBwZXJtaXNzaW9uOyBubyBwZXJtaXNzaW9ucyBhcmUKKyAqIHJlcXVpcmVkIG9uIHRoZSBrZXkpLgogICovCiBpbnQga2V5X3VubGluayhzdHJ1Y3Qga2V5ICprZXlyaW5nLCBzdHJ1Y3Qga2V5ICprZXkpCiB7CkBAIC05NjgsMTUgKzEwMjksMTIgQEAKIAlyZXQgPSAtRU5PTUVNOwogCXVwX3dyaXRlKCZrZXlyaW5nLT5zZW0pOwogCWdvdG8gZXJyb3I7Ci0KLX0gLyogZW5kIGtleV91bmxpbmsoKSAqLwotCit9CiBFWFBPUlRfU1lNQk9MKGtleV91bmxpbmspOwogCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogZGlzcG9zZSBvZiBhIGtleXJpbmcgbGlzdCBhZnRlciB0aGUgUkNVIGdyYWNlIHBlcmlvZCwgcmVsZWFzaW5nIHRoZSBrZXlzIGl0Ci0gKiBsaW5rcyB0bworICogRGlzcG9zZSBvZiBhIGtleXJpbmcgbGlzdCBhZnRlciB0aGUgUkNVIGdyYWNlIHBlcmlvZCwgcmVsZWFzaW5nIHRoZSBrZXlzIGl0CisgKiBsaW5rcyB0by4KICAqLwogc3RhdGljIHZvaWQga2V5cmluZ19jbGVhcl9yY3VfZGlzcG9zYWwoc3RydWN0IHJjdV9oZWFkICpyY3UpCiB7CkBAIC05ODksMTMgKzEwNDcsMTUgQEAKIAkJa2V5X3B1dChrbGlzdC0+a2V5c1tsb29wXSk7CiAKIAlrZnJlZShrbGlzdCk7Cit9CiAKLX0gLyogZW5kIGtleXJpbmdfY2xlYXJfcmN1X2Rpc3Bvc2FsKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotLyoKLSAqIGNsZWFyIHRoZSBzcGVjaWZpZWQgcHJvY2VzcyBrZXlyaW5nCi0gKiAtIGltcGxlbWVudHMga2V5Y3RsKEtFWUNUTF9DTEVBUikKKy8qKgorICoga2V5cmluZ19jbGVhciAtIENsZWFyIGEga2V5cmluZworICogQGtleXJpbmc6IFRoZSBrZXlyaW5nIHRvIGNsZWFyLgorICoKKyAqIENsZWFyIHRoZSBjb250ZW50cyBvZiB0aGUgc3BlY2lmaWVkIGtleXJpbmcuCisgKgorICogUmV0dXJucyAwIGlmIHN1Y2Nlc3NmdWwgb3IgLUVOT1RESVIgaWYgdGhlIGtleXJpbmcgaXNuJ3QgYSBrZXlyaW5nLgogICovCiBpbnQga2V5cmluZ19jbGVhcihzdHJ1Y3Qga2V5ICprZXlyaW5nKQogewpAQCAtMTAyNywxNSArMTA4NywxMyBAQAogCX0KIAogCXJldHVybiByZXQ7Ci0KLX0gLyogZW5kIGtleXJpbmdfY2xlYXIoKSAqLwotCit9CiBFWFBPUlRfU1lNQk9MKGtleXJpbmdfY2xlYXIpOwogCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogZGlzcG9zZSBvZiB0aGUgbGlua3MgZnJvbSBhIHJldm9rZWQga2V5cmluZwotICogLSBjYWxsZWQgd2l0aCB0aGUga2V5IHNlbSB3cml0ZS1sb2NrZWQKKyAqIERpc3Bvc2Ugb2YgdGhlIGxpbmtzIGZyb20gYSByZXZva2VkIGtleXJpbmcuCisgKgorICogVGhpcyBpcyBjYWxsZWQgd2l0aCB0aGUga2V5IHNlbSB3cml0ZS1sb2NrZWQuCiAgKi8KIHN0YXRpYyB2b2lkIGtleXJpbmdfcmV2b2tlKHN0cnVjdCBrZXkgKmtleXJpbmcpCiB7CkBAIC0xMDUwLDExICsxMTA4LDEwIEBACiAJCXJjdV9hc3NpZ25fcG9pbnRlcihrZXlyaW5nLT5wYXlsb2FkLnN1YnNjcmlwdGlvbnMsIE5VTEwpOwogCQljYWxsX3JjdSgma2xpc3QtPnJjdSwga2V5cmluZ19jbGVhcl9yY3VfZGlzcG9zYWwpOwogCX0KLQotfSAvKiBlbmQga2V5cmluZ19yZXZva2UoKSAqLworfQogCiAvKgotICogRGV0ZXJtaW5lIHdoZXRoZXIgYSBrZXkgaXMgZGVhZAorICogRGV0ZXJtaW5lIHdoZXRoZXIgYSBrZXkgaXMgZGVhZC4KICAqLwogc3RhdGljIGJvb2wga2V5X2lzX2RlYWQoc3RydWN0IGtleSAqa2V5LCB0aW1lX3QgbGltaXQpCiB7CkBAIC0xMDYzLDcgKzExMjAsMTIgQEAKIH0KIAogLyoKLSAqIENvbGxlY3QgZ2FyYmFnZSBmcm9tIHRoZSBjb250ZW50cyBvZiBhIGtleXJpbmcKKyAqIENvbGxlY3QgZ2FyYmFnZSBmcm9tIHRoZSBjb250ZW50cyBvZiBhIGtleXJpbmcsIHJlcGxhY2luZyB0aGUgb2xkIGxpc3Qgd2l0aAorICogYSBuZXcgb25lIHdpdGggdGhlIHBvaW50ZXJzIGFsbCBzaHVmZmxlZCBkb3duLgorICoKKyAqIERlYWQga2V5cyBhcmUgY2xhc3NlZCBhcyBvbmVkIHRoYXQgYXJlIGZsYWdnZWQgYXMgYmVpbmcgZGVhZCBvciBhcmUgcmV2b2tlZCwKKyAqIGV4cGlyZWQgb3IgbmVnYXRpdmUga2V5cyB0aGF0IHdlcmUgcmV2b2tlZCBvciBleHBpcmVkIGJlZm9yZSB0aGUgc3BlY2lmaWVkCisgKiBsaW1pdC4KICAqLwogdm9pZCBrZXlyaW5nX2djKHN0cnVjdCBrZXkgKmtleXJpbmcsIHRpbWVfdCBsaW1pdCkKIHsKZGlmZiAtLWdpdCBhL3NlY3VyaXR5L2tleXMvcGVybWlzc2lvbi5jIGIvc2VjdXJpdHkva2V5cy9wZXJtaXNzaW9uLmMKaW5kZXggMjg2NDU1MC4uYzM1YjUyMiAxMDA2NDQKLS0tIGEvc2VjdXJpdHkva2V5cy9wZXJtaXNzaW9uLmMKKysrIGIvc2VjdXJpdHkva2V5cy9wZXJtaXNzaW9uLmMKQEAgLTEsNCArMSw0IEBACi0vKiBwZXJtaXNzaW9uLmM6IGtleSBwZXJtaXNzaW9uIGRldGVybWluYXRpb24KKy8qIEtleSBwZXJtaXNzaW9uIGNoZWNraW5nCiAgKgogICogQ29weXJpZ2h0IChDKSAyMDA1IFJlZCBIYXQsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KICAqIFdyaXR0ZW4gYnkgRGF2aWQgSG93ZWxscyAoZGhvd2VsbHNAcmVkaGF0LmNvbSkKQEAgLTEzLDE4ICsxMywxOSBAQAogI2luY2x1ZGUgPGxpbnV4L3NlY3VyaXR5Lmg+CiAjaW5jbHVkZSAiaW50ZXJuYWwuaCIKIAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoqCiAgKiBrZXlfdGFza19wZXJtaXNzaW9uIC0gQ2hlY2sgYSBrZXkgY2FuIGJlIHVzZWQKLSAqIEBrZXlfcmVmOiBUaGUga2V5IHRvIGNoZWNrCi0gKiBAY3JlZDogVGhlIGNyZWRlbnRpYWxzIHRvIHVzZQotICogQHBlcm06IFRoZSBwZXJtaXNzaW9ucyB0byBjaGVjayBmb3IKKyAqIEBrZXlfcmVmOiBUaGUga2V5IHRvIGNoZWNrLgorICogQGNyZWQ6IFRoZSBjcmVkZW50aWFscyB0byB1c2UuCisgKiBAcGVybTogVGhlIHBlcm1pc3Npb25zIHRvIGNoZWNrIGZvci4KICAqCiAgKiBDaGVjayB0byBzZWUgd2hldGhlciBwZXJtaXNzaW9uIGlzIGdyYW50ZWQgdG8gdXNlIGEga2V5IGluIHRoZSBkZXNpcmVkIHdheSwKICAqIGJ1dCBwZXJtaXQgdGhlIHNlY3VyaXR5IG1vZHVsZXMgdG8gb3ZlcnJpZGUuCiAgKgotICogVGhlIGNhbGxlciBtdXN0IGhvbGQgZWl0aGVyIGEgcmVmIG9uIGNyZWQgb3IgbXVzdCBob2xkIHRoZSBSQ1UgcmVhZGxvY2sgb3IgYQotICogc3BpbmxvY2suCisgKiBUaGUgY2FsbGVyIG11c3QgaG9sZCBlaXRoZXIgYSByZWYgb24gY3JlZCBvciBtdXN0IGhvbGQgdGhlIFJDVSByZWFkbG9jay4KKyAqCisgKiBSZXR1cm5zIDAgaWYgc3VjY2Vzc2Z1bCwgLUVBQ0NFUyBpZiBhY2Nlc3MgaXMgZGVuaWVkIGJhc2VkIG9uIHRoZQorICogcGVybWlzc2lvbnMgYml0cyBvciB0aGUgTFNNIGNoZWNrLgogICovCiBpbnQga2V5X3Rhc2tfcGVybWlzc2lvbihjb25zdCBrZXlfcmVmX3Qga2V5X3JlZiwgY29uc3Qgc3RydWN0IGNyZWQgKmNyZWQsCiAJCQlrZXlfcGVybV90IHBlcm0pCkBAIC03OSwxNCArODAsMTYgQEAKIAogCS8qIGxldCBMU00gYmUgdGhlIGZpbmFsIGFyYml0ZXIgKi8KIAlyZXR1cm4gc2VjdXJpdHlfa2V5X3Blcm1pc3Npb24oa2V5X3JlZiwgY3JlZCwgcGVybSk7Ci0KLX0gLyogZW5kIGtleV90YXNrX3Blcm1pc3Npb24oKSAqLwotCit9CiBFWFBPUlRfU1lNQk9MKGtleV90YXNrX3Blcm1pc3Npb24pOwogCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi0vKgotICogdmFsaWRhdGUgYSBrZXkKKy8qKgorICoga2V5X3ZhbGlkYXRlIC0gVmFsaWRhdGUgYSBrZXkuCisgKiBAa2V5OiBUaGUga2V5IHRvIGJlIHZhbGlkYXRlZC4KKyAqCisgKiBDaGVjayB0aGF0IGEga2V5IGlzIHZhbGlkLCByZXR1cm5pbmcgMCBpZiB0aGUga2V5IGlzIG9rYXksIC1FS0VZUkVWT0tFRCBpZgorICogdGhlIGtleSdzIHR5cGUgaGFzIGJlZW4gcmVtb3ZlZCBvciBpZiB0aGUga2V5IGhhcyBiZWVuIHJldm9rZWQgb3IKKyAqIC1FS0VZRVhQSVJFRCBpZiB0aGUga2V5IGhhcyBleHBpcmVkLgogICovCiBpbnQga2V5X3ZhbGlkYXRlKHN0cnVjdCBrZXkgKmtleSkKIHsKQEAgLTExMSw3ICsxMTQsNSBAQAogCiBlcnJvcjoKIAlyZXR1cm4gcmV0OwotCi19IC8qIGVuZCBrZXlfdmFsaWRhdGUoKSAqLwotCit9CiBFWFBPUlRfU1lNQk9MKGtleV92YWxpZGF0ZSk7CmRpZmYgLS1naXQgYS9zZWN1cml0eS9rZXlzL3Byb2MuYyBiL3NlY3VyaXR5L2tleXMvcHJvYy5jCmluZGV4IDcwMzczOTY2Li41MjVjZjhhIDEwMDY0NAotLS0gYS9zZWN1cml0eS9rZXlzL3Byb2MuYworKysgYi9zZWN1cml0eS9rZXlzL3Byb2MuYwpAQCAtMSw0ICsxLDQgQEAKLS8qIHByb2MuYzogcHJvYyBmaWxlcyBmb3Iga2V5IGRhdGFiYXNlIGVudW1lcmF0aW9uCisvKiBwcm9jZnMgZmlsZXMgZm9yIGtleSBkYXRhYmFzZSBlbnVtZXJhdGlvbgogICoKICAqIENvcHlyaWdodCAoQykgMjAwNCBSZWQgSGF0LCBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAgKiBXcml0dGVuIGJ5IERhdmlkIEhvd2VsbHMgKGRob3dlbGxzQHJlZGhhdC5jb20pCkBAIC02MCw5ICs2MCw4IEBACiAJLnJlbGVhc2UJPSBzZXFfcmVsZWFzZSwKIH07CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBkZWNsYXJlIHRoZSAvcHJvYyBmaWxlcworICogRGVjbGFyZSB0aGUgL3Byb2MgZmlsZXMuCiAgKi8KIHN0YXRpYyBpbnQgX19pbml0IGtleV9wcm9jX2luaXQodm9pZCkKIHsKQEAgLTc5LDE0ICs3OCwxMyBAQAogCQlwYW5pYygiQ2Fubm90IGNyZWF0ZSAvcHJvYy9rZXktdXNlcnNcbiIpOwogCiAJcmV0dXJuIDA7Ci0KLX0gLyogZW5kIGtleV9wcm9jX2luaXQoKSAqLworfQogCiBfX2luaXRjYWxsKGtleV9wcm9jX2luaXQpOwogCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogaW1wbGVtZW50ICIvcHJvYy9rZXlzIiB0byBwcm92aWRlcyBhIGxpc3Qgb2YgdGhlIGtleXMgb24gdGhlIHN5c3RlbQorICogSW1wbGVtZW50ICIvcHJvYy9rZXlzIiB0byBwcm92aWRlIGEgbGlzdCBvZiB0aGUga2V5cyBvbiB0aGUgc3lzdGVtIHRoYXQKKyAqIGdyYW50IFZpZXcgcGVybWlzc2lvbiB0byB0aGUgY2FsbGVyLgogICovCiAjaWZkZWYgQ09ORklHX0tFWVNfREVCVUdfUFJPQ19LRVlTCiAKQEAgLTI5Myw5ICsyOTEsOSBAQAogCXJldHVybiBfX2tleV91c2VyX25leHQobik7CiB9CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBpbXBsZW1lbnQgIi9wcm9jL2tleS11c2VycyIgdG8gcHJvdmlkZXMgYSBsaXN0IG9mIHRoZSBrZXkgdXNlcnMKKyAqIEltcGxlbWVudCAiL3Byb2Mva2V5LXVzZXJzIiB0byBwcm92aWRlcyBhIGxpc3Qgb2YgdGhlIGtleSB1c2VycyBhbmQgdGhlaXIKKyAqIHF1b3Rhcy4KICAqLwogc3RhdGljIGludCBwcm9jX2tleV91c2Vyc19vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQogewpAQCAtMzUxLDUgKzM0OSw0IEBACiAJCSAgIG1heGJ5dGVzKTsKIAogCXJldHVybiAwOwotCiB9CmRpZmYgLS1naXQgYS9zZWN1cml0eS9rZXlzL3Byb2Nlc3Nfa2V5cy5jIGIvc2VjdXJpdHkva2V5cy9wcm9jZXNzX2tleXMuYwppbmRleCA1MDRiZGQyLi45MzA2MzRlIDEwMDY0NAotLS0gYS9zZWN1cml0eS9rZXlzL3Byb2Nlc3Nfa2V5cy5jCisrKyBiL3NlY3VyaXR5L2tleXMvcHJvY2Vzc19rZXlzLmMKQEAgLTEsNCArMSw0IEBACi0vKiBNYW5hZ2VtZW50IG9mIGEgcHJvY2VzcydzIGtleXJpbmdzCisvKiBNYW5hZ2UgYSBwcm9jZXNzJ3Mga2V5cmluZ3MKICAqCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDQtMjAwNSwgMjAwOCBSZWQgSGF0LCBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAgKiBXcml0dGVuIGJ5IERhdmlkIEhvd2VsbHMgKGRob3dlbGxzQHJlZGhhdC5jb20pCkBAIC0yMSwxMyArMjEsMTMgQEAKICNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgogI2luY2x1ZGUgImludGVybmFsLmgiCiAKLS8qIHNlc3Npb24ga2V5cmluZyBjcmVhdGUgdnMgam9pbiBzZW1hcGhvcmUgKi8KKy8qIFNlc3Npb24ga2V5cmluZyBjcmVhdGUgdnMgam9pbiBzZW1hcGhvcmUgKi8KIHN0YXRpYyBERUZJTkVfTVVURVgoa2V5X3Nlc3Npb25fbXV0ZXgpOwogCi0vKiB1c2VyIGtleXJpbmcgY3JlYXRpb24gc2VtYXBob3JlICovCisvKiBVc2VyIGtleXJpbmcgY3JlYXRpb24gc2VtYXBob3JlICovCiBzdGF0aWMgREVGSU5FX01VVEVYKGtleV91c2VyX2tleXJpbmdfbXV0ZXgpOwogCi0vKiB0aGUgcm9vdCB1c2VyJ3MgdHJhY2tpbmcgc3RydWN0ICovCisvKiBUaGUgcm9vdCB1c2VyJ3MgdHJhY2tpbmcgc3RydWN0ICovCiBzdHJ1Y3Qga2V5X3VzZXIgcm9vdF9rZXlfdXNlciA9IHsKIAkudXNhZ2UJCT0gQVRPTUlDX0lOSVQoMyksCiAJLmNvbnNfbG9jawk9IF9fTVVURVhfSU5JVElBTElaRVIocm9vdF9rZXlfdXNlci5jb25zX2xvY2spLApAQCAtMzgsOSArMzgsOCBAQAogCS51c2VyX25zCT0gJmluaXRfdXNlcl9ucywKIH07CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBpbnN0YWxsIHVzZXIgYW5kIHVzZXIgc2Vzc2lvbiBrZXlyaW5ncyBmb3IgYSBwYXJ0aWN1bGFyIFVJRAorICogSW5zdGFsbCB0aGUgdXNlciBhbmQgdXNlciBzZXNzaW9uIGtleXJpbmdzIGZvciB0aGUgY3VycmVudCBwcm9jZXNzJ3MgVUlELgogICovCiBpbnQgaW5zdGFsbF91c2VyX2tleXJpbmdzKHZvaWQpCiB7CkBAIC0xMjIsNyArMTIxLDggQEAKIH0KIAogLyoKLSAqIGluc3RhbGwgYSBmcmVzaCB0aHJlYWQga2V5cmluZyBkaXJlY3RseSB0byBuZXcgY3JlZGVudGlhbHMKKyAqIEluc3RhbGwgYSBmcmVzaCB0aHJlYWQga2V5cmluZyBkaXJlY3RseSB0byBuZXcgY3JlZGVudGlhbHMuICBUaGlzIGtleXJpbmcgaXMKKyAqIGFsbG93ZWQgdG8gb3ZlcnJ1biB0aGUgcXVvdGEuCiAgKi8KIGludCBpbnN0YWxsX3RocmVhZF9rZXlyaW5nX3RvX2NyZWQoc3RydWN0IGNyZWQgKm5ldykKIHsKQEAgLTEzOCw3ICsxMzgsNyBAQAogfQogCiAvKgotICogaW5zdGFsbCBhIGZyZXNoIHRocmVhZCBrZXlyaW5nLCBkaXNjYXJkaW5nIHRoZSBvbGQgb25lCisgKiBJbnN0YWxsIGEgZnJlc2ggdGhyZWFkIGtleXJpbmcsIGRpc2NhcmRpbmcgdGhlIG9sZCBvbmUuCiAgKi8KIHN0YXRpYyBpbnQgaW5zdGFsbF90aHJlYWRfa2V5cmluZyh2b2lkKQogewpAQCAtMTYxLDkgKzE2MSwxMCBAQAogfQogCiAvKgotICogaW5zdGFsbCBhIHByb2Nlc3Mga2V5cmluZyBkaXJlY3RseSB0byBhIGNyZWRlbnRpYWxzIHN0cnVjdAotICogLSByZXR1cm5zIC1FRVhJU1QgaWYgdGhlcmUgd2FzIGFscmVhZHkgYSBwcm9jZXNzIGtleXJpbmcsIDAgaWYgb25lIGluc3RhbGxlZCwKLSAqICAgYW5kIG90aGVyIC12ZSBvbiBhbnkgb3RoZXIgZXJyb3IKKyAqIEluc3RhbGwgYSBwcm9jZXNzIGtleXJpbmcgZGlyZWN0bHkgdG8gYSBjcmVkZW50aWFscyBzdHJ1Y3QuCisgKgorICogUmV0dXJucyAtRUVYSVNUIGlmIHRoZXJlIHdhcyBhbHJlYWR5IGEgcHJvY2VzcyBrZXlyaW5nLCAwIGlmIG9uZSBpbnN0YWxsZWQsCisgKiBhbmQgb3RoZXIgdmFsdWUgb24gYW55IG90aGVyIGVycm9yCiAgKi8KIGludCBpbnN0YWxsX3Byb2Nlc3Nfa2V5cmluZ190b19jcmVkKHN0cnVjdCBjcmVkICpuZXcpCiB7CkBAIC0xOTIsOCArMTkzLDExIEBACiB9CiAKIC8qCi0gKiBtYWtlIHN1cmUgYSBwcm9jZXNzIGtleXJpbmcgaXMgaW5zdGFsbGVkCi0gKiAtIHdlCisgKiBNYWtlIHN1cmUgYSBwcm9jZXNzIGtleXJpbmcgaXMgaW5zdGFsbGVkIGZvciB0aGUgY3VycmVudCBwcm9jZXNzLiAgVGhlCisgKiBleGlzdGluZyBwcm9jZXNzIGtleXJpbmcgaXMgbm90IHJlcGxhY2VkLgorICoKKyAqIFJldHVybnMgMCBpZiB0aGVyZSBpcyBhIHByb2Nlc3Mga2V5cmluZyBieSB0aGUgZW5kIG9mIHRoaXMgZnVuY3Rpb24sIHNvbWUKKyAqIGVycm9yIG90aGVyd2lzZS4KICAqLwogc3RhdGljIGludCBpbnN0YWxsX3Byb2Nlc3Nfa2V5cmluZyh2b2lkKQogewpAQCAtMjE0LDcgKzIxOCw3IEBACiB9CiAKIC8qCi0gKiBpbnN0YWxsIGEgc2Vzc2lvbiBrZXlyaW5nIGRpcmVjdGx5IHRvIGEgY3JlZGVudGlhbHMgc3RydWN0CisgKiBJbnN0YWxsIGEgc2Vzc2lvbiBrZXlyaW5nIGRpcmVjdGx5IHRvIGEgY3JlZGVudGlhbHMgc3RydWN0LgogICovCiBpbnQgaW5zdGFsbF9zZXNzaW9uX2tleXJpbmdfdG9fY3JlZChzdHJ1Y3QgY3JlZCAqY3JlZCwgc3RydWN0IGtleSAqa2V5cmluZykKIHsKQEAgLTI1NCw4ICsyNTgsOCBAQAogfQogCiAvKgotICogaW5zdGFsbCBhIHNlc3Npb24ga2V5cmluZywgZGlzY2FyZGluZyB0aGUgb2xkIG9uZQotICogLSBpZiBhIGtleXJpbmcgaXMgbm90IHN1cHBsaWVkLCBhbiBlbXB0eSBvbmUgaXMgaW52ZW50ZWQKKyAqIEluc3RhbGwgYSBzZXNzaW9uIGtleXJpbmcsIGRpc2NhcmRpbmcgdGhlIG9sZCBvbmUuICBJZiBhIGtleXJpbmcgaXMgbm90CisgKiBzdXBwbGllZCwgYW4gZW1wdHkgb25lIGlzIGludmVudGVkLgogICovCiBzdGF0aWMgaW50IGluc3RhbGxfc2Vzc2lvbl9rZXlyaW5nKHN0cnVjdCBrZXkgKmtleXJpbmcpCiB7CkBAIC0yNzUsOSArMjc5LDggQEAKIAlyZXR1cm4gY29tbWl0X2NyZWRzKG5ldyk7CiB9CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiB0aGUgZmlsZXN5c3RlbSB1c2VyIElEIGNoYW5nZWQKKyAqIEhhbmRsZSB0aGUgZnN1aWQgY2hhbmdpbmcuCiAgKi8KIHZvaWQga2V5X2ZzdWlkX2NoYW5nZWQoc3RydWN0IHRhc2tfc3RydWN0ICp0c2spCiB7CkBAIC0yODgsMTIgKzI5MSwxMCBAQAogCQl0c2stPmNyZWQtPnRocmVhZF9rZXlyaW5nLT51aWQgPSB0c2stPmNyZWQtPmZzdWlkOwogCQl1cF93cml0ZSgmdHNrLT5jcmVkLT50aHJlYWRfa2V5cmluZy0+c2VtKTsKIAl9Cit9CiAKLX0gLyogZW5kIGtleV9mc3VpZF9jaGFuZ2VkKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIHRoZSBmaWxlc3lzdGVtIGdyb3VwIElEIGNoYW5nZWQKKyAqIEhhbmRsZSB0aGUgZnNnaWQgY2hhbmdpbmcuCiAgKi8KIHZvaWQga2V5X2ZzZ2lkX2NoYW5nZWQoc3RydWN0IHRhc2tfc3RydWN0ICp0c2spCiB7CkBAIC0zMDQsMTYgKzMwNSwyOCBAQAogCQl0c2stPmNyZWQtPnRocmVhZF9rZXlyaW5nLT5naWQgPSB0c2stPmNyZWQtPmZzZ2lkOwogCQl1cF93cml0ZSgmdHNrLT5jcmVkLT50aHJlYWRfa2V5cmluZy0+c2VtKTsKIAl9Cit9CiAKLX0gLyogZW5kIGtleV9mc2dpZF9jaGFuZ2VkKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIHNlYXJjaCBvbmx5IG15IHByb2Nlc3Mga2V5cmluZ3MgZm9yIHRoZSBmaXJzdCBtYXRjaGluZyBrZXkKLSAqIC0gd2UgdXNlIHRoZSBzdXBwbGllZCBtYXRjaCBmdW5jdGlvbiB0byBzZWUgaWYgdGhlIGRlc2NyaXB0aW9uIChvciBvdGhlcgotICogICBmZWF0dXJlIG9mIGludGVyZXN0KSBtYXRjaGVzCi0gKiAtIHdlIHJldHVybiAtRUFHQUlOIGlmIHdlIGRpZG4ndCBmaW5kIGFueSBtYXRjaGluZyBrZXkKLSAqIC0gd2UgcmV0dXJuIC1FTk9LRVkgaWYgd2UgZm91bmQgb25seSBuZWdhdGl2ZSBtYXRjaGluZyBrZXlzCisgKiBTZWFyY2ggdGhlIHByb2Nlc3Mga2V5cmluZ3MgYXR0YWNoZWQgdG8gdGhlIHN1cHBsaWVkIGNyZWQgZm9yIHRoZSBmaXJzdAorICogbWF0Y2hpbmcga2V5LgorICoKKyAqIFRoZSBzZWFyY2ggY3JpdGVyaWEgYXJlIHRoZSB0eXBlIGFuZCB0aGUgbWF0Y2ggZnVuY3Rpb24uICBUaGUgZGVzY3JpcHRpb24gaXMKKyAqIGdpdmVuIHRvIHRoZSBtYXRjaCBmdW5jdGlvbiBhcyBhIHBhcmFtZXRlciwgYnV0IGRvZXNuJ3Qgb3RoZXJ3aXNlIGluZmx1ZW5jZQorICogdGhlIHNlYXJjaC4gIFR5cGljYWxseSB0aGUgbWF0Y2ggZnVuY3Rpb24gd2lsbCBjb21wYXJlIHRoZSBkZXNjcmlwdGlvbgorICogcGFyYW1ldGVyIHRvIHRoZSBrZXkncyBkZXNjcmlwdGlvbi4KKyAqCisgKiBUaGlzIGNhbiBvbmx5IHNlYXJjaCBrZXlyaW5ncyB0aGF0IGdyYW50IFNlYXJjaCBwZXJtaXNzaW9uIHRvIHRoZSBzdXBwbGllZAorICogY3JlZGVudGlhbHMuICBLZXlyaW5ncyBsaW5rZWQgdG8gc2VhcmNoZWQga2V5cmluZ3Mgd2lsbCBhbHNvIGJlIHNlYXJjaGVkIGlmCisgKiB0aGV5IGdyYW50IFNlYXJjaCBwZXJtaXNzaW9uIHRvby4gIEtleXMgY2FuIG9ubHkgYmUgZm91bmQgaWYgdGhleSBncmFudAorICogU2VhcmNoIHBlcm1pc3Npb24gdG8gdGhlIGNyZWRlbnRpYWxzLgorICoKKyAqIFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBrZXkgd2l0aCB0aGUga2V5IHVzYWdlIGNvdW50IGluY3JlbWVudGVkIGlmCisgKiBzdWNjZXNzZnVsLCAtRUFHQUlOIGlmIHdlIGRpZG4ndCBmaW5kIGFueSBtYXRjaGluZyBrZXkgb3IgLUVOT0tFWSBpZiB3ZSBvbmx5CisgKiBtYXRjaGVkIG5lZ2F0aXZlIGtleXMuCisgKgorICogSW4gdGhlIGNhc2Ugb2YgYSBzdWNjZXNzZnVsIHJldHVybiwgdGhlIHBvc3Nlc3Npb24gYXR0cmlidXRlIGlzIHNldCBvbiB0aGUKKyAqIHJldHVybmVkIGtleSByZWZlcmVuY2UuCiAgKi8KIGtleV9yZWZfdCBzZWFyY2hfbXlfcHJvY2Vzc19rZXlyaW5ncyhzdHJ1Y3Qga2V5X3R5cGUgKnR5cGUsCiAJCQkJICAgICBjb25zdCB2b2lkICpkZXNjcmlwdGlvbiwKQEAgLTQyOCwxMyArNDQxLDEzIEBACiAJcmV0dXJuIGtleV9yZWY7CiB9CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBzZWFyY2ggdGhlIHByb2Nlc3Mga2V5cmluZ3MgZm9yIHRoZSBmaXJzdCBtYXRjaGluZyBrZXkKLSAqIC0gd2UgdXNlIHRoZSBzdXBwbGllZCBtYXRjaCBmdW5jdGlvbiB0byBzZWUgaWYgdGhlIGRlc2NyaXB0aW9uIChvciBvdGhlcgotICogICBmZWF0dXJlIG9mIGludGVyZXN0KSBtYXRjaGVzCi0gKiAtIHdlIHJldHVybiAtRUFHQUlOIGlmIHdlIGRpZG4ndCBmaW5kIGFueSBtYXRjaGluZyBrZXkKLSAqIC0gd2UgcmV0dXJuIC1FTk9LRVkgaWYgd2UgZm91bmQgb25seSBuZWdhdGl2ZSBtYXRjaGluZyBrZXlzCisgKiBTZWFyY2ggdGhlIHByb2Nlc3Mga2V5cmluZ3MgYXR0YWNoZWQgdG8gdGhlIHN1cHBsaWVkIGNyZWQgZm9yIHRoZSBmaXJzdAorICogbWF0Y2hpbmcga2V5IGluIHRoZSBtYW5uZXIgb2Ygc2VhcmNoX215X3Byb2Nlc3Nfa2V5cmluZ3MoKSwgYnV0IGFsc28gc2VhcmNoCisgKiB0aGUga2V5cyBhdHRhY2hlZCB0byB0aGUgYXNzdW1lZCBhdXRob3Jpc2F0aW9uIGtleSB1c2luZyBpdHMgY3JlZGVudGlhbHMgaWYKKyAqIG9uZSBpcyBhdmFpbGFibGUuCisgKgorICogUmV0dXJuIHNhbWUgYXMgc2VhcmNoX215X3Byb2Nlc3Nfa2V5cmluZ3MoKS4KICAqLwoga2V5X3JlZl90IHNlYXJjaF9wcm9jZXNzX2tleXJpbmdzKHN0cnVjdCBrZXlfdHlwZSAqdHlwZSwKIAkJCQkgIGNvbnN0IHZvaWQgKmRlc2NyaXB0aW9uLApAQCAtNDg5LDI0ICs1MDIsMzMgQEAKIAogZm91bmQ6CiAJcmV0dXJuIGtleV9yZWY7Cit9CiAKLX0gLyogZW5kIHNlYXJjaF9wcm9jZXNzX2tleXJpbmdzKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIHNlZSBpZiB0aGUga2V5IHdlJ3JlIGxvb2tpbmcgYXQgaXMgdGhlIHRhcmdldCBrZXkKKyAqIFNlZSBpZiB0aGUga2V5IHdlJ3JlIGxvb2tpbmcgYXQgaXMgdGhlIHRhcmdldCBrZXkuCiAgKi8KIGludCBsb29rdXBfdXNlcl9rZXlfcG9zc2Vzc2VkKGNvbnN0IHN0cnVjdCBrZXkgKmtleSwgY29uc3Qgdm9pZCAqdGFyZ2V0KQogewogCXJldHVybiBrZXkgPT0gdGFyZ2V0OworfQogCi19IC8qIGVuZCBsb29rdXBfdXNlcl9rZXlfcG9zc2Vzc2VkKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIGxvb2t1cCBhIGtleSBnaXZlbiBhIGtleSBJRCBmcm9tIHVzZXJzcGFjZSB3aXRoIGEgZ2l2ZW4gcGVybWlzc2lvbnMgbWFzawotICogLSBkb24ndCBjcmVhdGUgc3BlY2lhbCBrZXlyaW5ncyB1bmxlc3Mgc28gcmVxdWVzdGVkCi0gKiAtIHBhcnRpYWxseSBjb25zdHJ1Y3RlZCBrZXlzIGFyZW4ndCBmb3VuZCB1bmxlc3MgcmVxdWVzdGVkCisgKiBMb29rIHVwIGEga2V5IElEIGdpdmVuIHVzIGJ5IHVzZXJzcGFjZSB3aXRoIGEgZ2l2ZW4gcGVybWlzc2lvbnMgbWFzayB0byBnZXQKKyAqIHRoZSBrZXkgaXQgcmVmZXJzIHRvLgorICoKKyAqIEZsYWdzIGNhbiBiZSBwYXNzZWQgdG8gcmVxdWVzdCB0aGF0IHNwZWNpYWwga2V5cmluZ3MgYmUgY3JlYXRlZCBpZiByZWZlcnJlZAorICogdG8gZGlyZWN0bHksIHRvIHBlcm1pdCBwYXJ0aWFsbHkgY29uc3RydWN0ZWQga2V5cyB0byBiZSBmb3VuZCBhbmQgdG8gc2tpcAorICogdmFsaWRpdHkgYW5kIHBlcm1pc3Npb24gY2hlY2tzIG9uIHRoZSBmb3VuZCBrZXkuCisgKgorICogUmV0dXJucyBhIHBvaW50ZXIgdG8gdGhlIGtleSB3aXRoIGFuIGluY3JlbWVudGVkIHVzYWdlIGNvdW50IGlmIHN1Y2Nlc3NmdWw7CisgKiAtRUlOVkFMIGlmIHRoZSBrZXkgSUQgaXMgaW52YWxpZDsgLUVOT0tFWSBpZiB0aGUga2V5IElEIGRvZXMgbm90IGNvcnJlc3BvbmQKKyAqIHRvIGEga2V5IG9yIHRoZSBiZXN0IGZvdW5kIGtleSB3YXMgYSBuZWdhdGl2ZSBrZXk7IC1FS0VZUkVWT0tFRCBvcgorICogLUVLRVlFWFBJUkVEIGlmIHRoZSBiZXN0IGZvdW5kIGtleSB3YXMgcmV2b2tlZCBvciBleHBpcmVkOyAtRUFDQ0VTIGlmIHRoZQorICogZm91bmQga2V5IGRvZXNuJ3QgZ3JhbnQgdGhlIHJlcXVlc3RlZCBwZXJtaXQgb3IgdGhlIExTTSBkZW5pZWQgYWNjZXNzIHRvIGl0OworICogb3IgLUVOT01FTSBpZiBhIHNwZWNpYWwga2V5cmluZyBjb3VsZG4ndCBiZSBjcmVhdGVkLgorICoKKyAqIEluIHRoZSBjYXNlIG9mIGEgc3VjY2Vzc2Z1bCByZXR1cm4sIHRoZSBwb3NzZXNzaW9uIGF0dHJpYnV0ZSBpcyBzZXQgb24gdGhlCisgKiByZXR1cm5lZCBrZXkgcmVmZXJlbmNlLgogICovCiBrZXlfcmVmX3QgbG9va3VwX3VzZXJfa2V5KGtleV9zZXJpYWxfdCBpZCwgdW5zaWduZWQgbG9uZyBsZmxhZ3MsCiAJCQkgIGtleV9wZXJtX3QgcGVybSkKQEAgLTcxMSwxNSArNzMzLDE4IEBACiByZWdldF9jcmVkczoKIAlwdXRfY3JlZChjcmVkKTsKIAlnb3RvIHRyeV9hZ2FpbjsKK30KIAotfSAvKiBlbmQgbG9va3VwX3VzZXJfa2V5KCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIGpvaW4gdGhlIG5hbWVkIGtleXJpbmcgYXMgdGhlIHNlc3Npb24ga2V5cmluZyBpZiBwb3NzaWJsZSwgb3IgYXR0ZW1wdCB0bwotICogY3JlYXRlIGEgbmV3IG9uZSBvZiB0aGF0IG5hbWUgaWYgbm90Ci0gKiAtIGlmIHRoZSBuYW1lIGlzIE5VTEwsIGFuIGVtcHR5IGFub255bW91cyBrZXlyaW5nIGlzIGluc3RhbGxlZCBpbnN0ZWFkCi0gKiAtIG5hbWVkIHNlc3Npb24ga2V5cmluZyBqb2luaW5nIGlzIGRvbmUgd2l0aCBhIHNlbWFwaG9yZSBoZWxkCisgKiBKb2luIHRoZSBuYW1lZCBrZXlyaW5nIGFzIHRoZSBzZXNzaW9uIGtleXJpbmcgaWYgcG9zc2libGUgZWxzZSBhdHRlbXB0IHRvCisgKiBjcmVhdGUgYSBuZXcgb25lIG9mIHRoYXQgbmFtZSBhbmQgam9pbiB0aGF0LgorICoKKyAqIElmIHRoZSBuYW1lIGlzIE5VTEwsIGFuIGVtcHR5IGFub255bW91cyBrZXlyaW5nIHdpbGwgYmUgaW5zdGFsbGVkIGFzIHRoZQorICogc2Vzc2lvbiBrZXlyaW5nLgorICoKKyAqIE5hbWVkIHNlc3Npb24ga2V5cmluZ3MgYXJlIGpvaW5lZCB3aXRoIGEgc2VtYXBob3JlIGhlbGQgdG8gcHJldmVudCB0aGUKKyAqIGtleXJpbmdzIGZyb20gZ29pbmcgYXdheSB3aGlsc3QgdGhlIGF0dGVtcHQgaXMgbWFkZSB0byBnb2luZyB0aGVtIGFuZCBhbHNvCisgKiB0byBwcmV2ZW50IGEgcmFjZSBpbiBjcmVhdGluZyBjb21wYXRpYmxlIHNlc3Npb24ga2V5cmluZ3MuCiAgKi8KIGxvbmcgam9pbl9zZXNzaW9uX2tleXJpbmcoY29uc3QgY2hhciAqbmFtZSkKIHsKQEAgLTc5MSw4ICs4MTYsOCBAQAogfQogCiAvKgotICogUmVwbGFjZSBhIHByb2Nlc3MncyBzZXNzaW9uIGtleXJpbmcgd2hlbiB0aGF0IHByb2Nlc3MgcmVzdW1lcyB1c2Vyc3BhY2Ugb24KLSAqIGJlaGFsZiBvZiBvbmUgb2YgaXRzIGNoaWxkcmVuCisgKiBSZXBsYWNlIGEgcHJvY2VzcydzIHNlc3Npb24ga2V5cmluZyBvbiBiZWhhbGYgb2Ygb25lIG9mIGl0cyBjaGlsZHJlbiB3aGVuCisgKiB0aGUgdGFyZ2V0ICBwcm9jZXNzIGlzIGFib3V0IHRvIHJlc3VtZSB1c2Vyc3BhY2UgZXhlY3V0aW9uLgogICovCiB2b2lkIGtleV9yZXBsYWNlX3Nlc3Npb25fa2V5cmluZyh2b2lkKQogewpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkva2V5cy9yZXF1ZXN0X2tleS5jIGIvc2VjdXJpdHkva2V5cy9yZXF1ZXN0X2tleS5jCmluZGV4IDBlYTUyZDIuLmEzZGMwZDQgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L2tleXMvcmVxdWVzdF9rZXkuYworKysgYi9zZWN1cml0eS9rZXlzL3JlcXVlc3Rfa2V5LmMKQEAgLTM5LDggKzM5LDE0IEBACiAJcmV0dXJuIHNpZ25hbF9wZW5kaW5nKGN1cnJlbnQpID8gLUVSRVNUQVJUU1lTIDogMDsKIH0KIAotLyoKLSAqIGNhbGwgdG8gY29tcGxldGUgdGhlIGNvbnN0cnVjdGlvbiBvZiBhIGtleQorLyoqCisgKiBjb21wbGV0ZV9yZXF1ZXN0X2tleSAtIENvbXBsZXRlIHRoZSBjb25zdHJ1Y3Rpb24gb2YgYSBrZXkuCisgKiBAY29uczogVGhlIGtleSBjb25zdHJ1Y3Rpb24gcmVjb3JkLgorICogQGVycm9yOiBUaGUgc3VjY2VzcyBvciBmYWlsdXRlIG9mIHRoZSBjb25zdHJ1Y3Rpb24uCisgKgorICogQ29tcGxldGUgdGhlIGF0dGVtcHQgdG8gY29uc3RydWN0IGEga2V5LiAgVGhlIGtleSB3aWxsIGJlIG5lZ2F0ZWQKKyAqIGlmIGFuIGVycm9yIGlzIGluZGljYXRlZC4gIFRoZSBhdXRob3Jpc2F0aW9uIGtleSB3aWxsIGJlIHJldm9rZWQKKyAqIHVuY29uZGl0aW9uYWxseS4KICAqLwogdm9pZCBjb21wbGV0ZV9yZXF1ZXN0X2tleShzdHJ1Y3Qga2V5X2NvbnN0cnVjdGlvbiAqY29ucywgaW50IGVycm9yKQogewpAQCAtNTgsMjMgKzY0LDMzIEBACiB9CiBFWFBPUlRfU1lNQk9MKGNvbXBsZXRlX3JlcXVlc3Rfa2V5KTsKIAorLyoKKyAqIEluaXRpYWxpc2UgYSB1c2VybW9kZSBoZWxwZXIgdGhhdCBpcyBnb2luZyB0byBoYXZlIGEgc3BlY2lmaWMgc2Vzc2lvbgorICoga2V5cmluZy4KKyAqCisgKiBUaGlzIGlzIGNhbGxlZCBpbiBjb250ZXh0IG9mIGZyZXNobHkgZm9ya2VkIGt0aHJlYWQgYmVmb3JlIGtlcm5lbF9leGVjdmUoKSwKKyAqIHNvIHdlIGNhbiBzaW1wbHkgaW5zdGFsbCB0aGUgZGVzaXJlZCBzZXNzaW9uX2tleXJpbmcgYXQgdGhpcyBwb2ludC4KKyAqLwogc3RhdGljIGludCB1bWhfa2V5c19pbml0KHN0cnVjdCBzdWJwcm9jZXNzX2luZm8gKmluZm8pCiB7CiAJc3RydWN0IGNyZWQgKmNyZWQgPSAoc3RydWN0IGNyZWQqKWN1cnJlbnRfY3JlZCgpOwogCXN0cnVjdCBrZXkgKmtleXJpbmcgPSBpbmZvLT5kYXRhOwotCS8qCi0JICogVGhpcyBpcyBjYWxsZWQgaW4gY29udGV4dCBvZiBmcmVzaGx5IGZvcmtlZCBrdGhyZWFkIGJlZm9yZQotCSAqIGtlcm5lbF9leGVjdmUoKSwgd2UgY2FuIGp1c3QgY2hhbmdlIG91ciAtPnNlc3Npb25fa2V5cmluZy4KLQkgKi8KKwogCXJldHVybiBpbnN0YWxsX3Nlc3Npb25fa2V5cmluZ190b19jcmVkKGNyZWQsIGtleXJpbmcpOwogfQogCisvKgorICogQ2xlYW4gdXAgYSB1c2VybW9kZSBoZWxwZXIgd2l0aCBzZXNzaW9uIGtleXJpbmcuCisgKi8KIHN0YXRpYyB2b2lkIHVtaF9rZXlzX2NsZWFudXAoc3RydWN0IHN1YnByb2Nlc3NfaW5mbyAqaW5mbykKIHsKIAlzdHJ1Y3Qga2V5ICprZXlyaW5nID0gaW5mby0+ZGF0YTsKIAlrZXlfcHV0KGtleXJpbmcpOwogfQogCisvKgorICogQ2FsbCBhIHVzZXJtb2RlIGhlbHBlciB3aXRoIGEgc3BlY2lmaWMgc2Vzc2lvbiBrZXlyaW5nLgorICovCiBzdGF0aWMgaW50IGNhbGxfdXNlcm1vZGVoZWxwZXJfa2V5cyhjaGFyICpwYXRoLCBjaGFyICoqYXJndiwgY2hhciAqKmVudnAsCiAJCQkgc3RydWN0IGtleSAqc2Vzc2lvbl9rZXlyaW5nLCBlbnVtIHVtaF93YWl0IHdhaXQpCiB7CkBAIC05MSw3ICsxMDcsNyBAQAogfQogCiAvKgotICogcmVxdWVzdCB1c2Vyc3BhY2UgZmluaXNoIHRoZSBjb25zdHJ1Y3Rpb24gb2YgYSBrZXkKKyAqIFJlcXVlc3QgdXNlcnNwYWNlIGZpbmlzaCB0aGUgY29uc3RydWN0aW9uIG9mIGEga2V5CiAgKiAtIGV4ZWN1dGUgIi9zYmluL3JlcXVlc3Qta2V5IDxvcD4gPGtleT4gPHVpZD4gPGdpZD4gPGtleXJpbmc+IDxrZXlyaW5nPiA8a2V5cmluZz4iCiAgKi8KIHN0YXRpYyBpbnQgY2FsbF9zYmluX3JlcXVlc3Rfa2V5KHN0cnVjdCBrZXlfY29uc3RydWN0aW9uICpjb25zLApAQCAtMTk4LDggKzIxNCw5IEBACiB9CiAKIC8qCi0gKiBjYWxsIG91dCB0byB1c2Vyc3BhY2UgZm9yIGtleSBjb25zdHJ1Y3Rpb24KLSAqIC0gd2UgaWdub3JlIHByb2dyYW0gZmFpbHVyZSBhbmQgZ28gb24ga2V5IHN0YXR1cyBpbnN0ZWFkCisgKiBDYWxsIG91dCB0byB1c2Vyc3BhY2UgZm9yIGtleSBjb25zdHJ1Y3Rpb24uCisgKgorICogUHJvZ3JhbSBmYWlsdXJlIGlzIGlnbm9yZWQgaW4gZmF2b3VyIG9mIGtleSBzdGF0dXMuCiAgKi8KIHN0YXRpYyBpbnQgY29uc3RydWN0X2tleShzdHJ1Y3Qga2V5ICprZXksIGNvbnN0IHZvaWQgKmNhbGxvdXRfaW5mbywKIAkJCSBzaXplX3QgY2FsbG91dF9sZW4sIHZvaWQgKmF1eCwKQEAgLTI0Niw5ICsyNjMsMTAgQEAKIH0KIAogLyoKLSAqIGdldCB0aGUgYXBwcm9wcmlhdGUgZGVzdGluYXRpb24ga2V5cmluZyBmb3IgdGhlIHJlcXVlc3QKLSAqIC0gd2UgcmV0dXJuIHdoYXRldmVyIGtleXJpbmcgd2Ugc2VsZWN0IHdpdGggYW4gZXh0cmEgcmVmZXJlbmNlIHVwb24gaXQgd2hpY2gKLSAqICAgdGhlIGNhbGxlciBtdXN0IHJlbGVhc2UKKyAqIEdldCB0aGUgYXBwcm9wcmlhdGUgZGVzdGluYXRpb24ga2V5cmluZyBmb3IgdGhlIHJlcXVlc3QuCisgKgorICogVGhlIGtleXJpbmcgc2VsZWN0ZWQgaXMgcmV0dXJuZWQgd2l0aCBhbiBleHRyYSByZWZlcmVuY2UgdXBvbiBpdCB3aGljaCB0aGUKKyAqIGNhbGxlciBtdXN0IHJlbGVhc2UuCiAgKi8KIHN0YXRpYyB2b2lkIGNvbnN0cnVjdF9nZXRfZGVzdF9rZXlyaW5nKHN0cnVjdCBrZXkgKipfZGVzdF9rZXlyaW5nKQogewpAQCAtMzIxLDkgKzMzOSwxMSBAQAogfQogCiAvKgotICogYWxsb2NhdGUgYSBuZXcga2V5IGluIHVuZGVyLWNvbnN0cnVjdGlvbiBzdGF0ZSBhbmQgYXR0ZW1wdCB0byBsaW5rIGl0IGluIHRvCi0gKiB0aGUgcmVxdWVzdGVkIHBsYWNlCi0gKiAtIG1heSByZXR1cm4gYSBrZXkgdGhhdCdzIGFscmVhZHkgdW5kZXIgY29uc3RydWN0aW9uIGluc3RlYWQKKyAqIEFsbG9jYXRlIGEgbmV3IGtleSBpbiB1bmRlci1jb25zdHJ1Y3Rpb24gc3RhdGUgYW5kIGF0dGVtcHQgdG8gbGluayBpdCBpbiB0bworICogdGhlIHJlcXVlc3RlZCBrZXlyaW5nLgorICoKKyAqIE1heSByZXR1cm4gYSBrZXkgdGhhdCdzIGFscmVhZHkgdW5kZXIgY29uc3RydWN0aW9uIGluc3RlYWQgaWYgdGhlcmUgd2FzIGEKKyAqIHJhY2UgYmV0d2VlbiB0d28gdGhyZWFkIGNhbGxpbmcgcmVxdWVzdF9rZXkoKS4KICAqLwogc3RhdGljIGludCBjb25zdHJ1Y3RfYWxsb2Nfa2V5KHN0cnVjdCBrZXlfdHlwZSAqdHlwZSwKIAkJCSAgICAgICBjb25zdCBjaGFyICpkZXNjcmlwdGlvbiwKQEAgLTMzMiw4ICszNTIsOCBAQAogCQkJICAgICAgIHN0cnVjdCBrZXlfdXNlciAqdXNlciwKIAkJCSAgICAgICBzdHJ1Y3Qga2V5ICoqX2tleSkKIHsKLQlzdHJ1Y3Qga2V5cmluZ19saXN0ICpwcmVhbGxvYzsKIAljb25zdCBzdHJ1Y3QgY3JlZCAqY3JlZCA9IGN1cnJlbnRfY3JlZCgpOworCXVuc2lnbmVkIGxvbmcgcHJlYWxsb2M7CiAJc3RydWN0IGtleSAqa2V5OwogCWtleV9yZWZfdCBrZXlfcmVmOwogCWludCByZXQ7CkBAIC00MTQsNyArNDM0LDcgQEAKIH0KIAogLyoKLSAqIGNvbW1lbmNlIGtleSBjb25zdHJ1Y3Rpb24KKyAqIENvbW1lbmNlIGtleSBjb25zdHJ1Y3Rpb24uCiAgKi8KIHN0YXRpYyBzdHJ1Y3Qga2V5ICpjb25zdHJ1Y3Rfa2V5X2FuZF9saW5rKHN0cnVjdCBrZXlfdHlwZSAqdHlwZSwKIAkJCQkJICBjb25zdCBjaGFyICpkZXNjcmlwdGlvbiwKQEAgLTQ2NSwxMiArNDg1LDMyIEBACiAJcmV0dXJuIEVSUl9QVFIocmV0KTsKIH0KIAotLyoKLSAqIHJlcXVlc3QgYSBrZXkKLSAqIC0gc2VhcmNoIHRoZSBwcm9jZXNzJ3Mga2V5cmluZ3MKLSAqIC0gY2hlY2sgdGhlIGxpc3Qgb2Yga2V5cyBiZWluZyBjcmVhdGVkIG9yIHVwZGF0ZWQKLSAqIC0gY2FsbCBvdXQgdG8gdXNlcnNwYWNlIGZvciBhIGtleSBpZiBzdXBwbGVtZW50YXJ5IGluZm8gd2FzIHByb3ZpZGVkCi0gKiAtIGNhY2hlIHRoZSBrZXkgaW4gYW4gYXBwcm9wcmlhdGUga2V5cmluZworLyoqCisgKiByZXF1ZXN0X2tleV9hbmRfbGluayAtIFJlcXVlc3QgYSBrZXkgYW5kIGNhY2hlIGl0IGluIGEga2V5cmluZy4KKyAqIEB0eXBlOiBUaGUgdHlwZSBvZiBrZXkgd2Ugd2FudC4KKyAqIEBkZXNjcmlwdGlvbjogVGhlIHNlYXJjaGFibGUgZGVzY3JpcHRpb24gb2YgdGhlIGtleS4KKyAqIEBjYWxsb3V0X2luZm86IFRoZSBkYXRhIHRvIHBhc3MgdG8gdGhlIGluc3RhbnRpYXRpb24gdXBjYWxsIChvciBOVUxMKS4KKyAqIEBjYWxsb3V0X2xlbjogVGhlIGxlbmd0aCBvZiBjYWxsb3V0X2luZm8uCisgKiBAYXV4OiBBdXhpbGlhcnkgZGF0YSBmb3IgdGhlIHVwY2FsbC4KKyAqIEBkZXN0X2tleXJpbmc6IFdoZXJlIHRvIGNhY2hlIHRoZSBrZXkuCisgKiBAZmxhZ3M6IEZsYWdzIHRvIGtleV9hbGxvYygpLgorICoKKyAqIEEga2V5IG1hdGNoaW5nIHRoZSBzcGVjaWZpZWQgY3JpdGVyaWEgaXMgc2VhcmNoZWQgZm9yIGluIHRoZSBwcm9jZXNzJ3MKKyAqIGtleXJpbmdzIGFuZCByZXR1cm5lZCB3aXRoIGl0cyB1c2FnZSBjb3VudCBpbmNyZW1lbnRlZCBpZiBmb3VuZC4gIE90aGVyd2lzZSwKKyAqIGlmIGNhbGxvdXRfaW5mbyBpcyBub3QgTlVMTCwgYSBrZXkgd2lsbCBiZSBhbGxvY2F0ZWQgYW5kIHNvbWUgc2VydmljZQorICogKHByb2JhYmx5IGluIHVzZXJzcGFjZSkgd2lsbCBiZSBhc2tlZCB0byBpbnN0YW50aWF0ZSBpdC4KKyAqCisgKiBJZiBzdWNjZXNzZnVsbHkgZm91bmQgb3IgY3JlYXRlZCwgdGhlIGtleSB3aWxsIGJlIGxpbmtlZCB0byB0aGUgZGVzdGluYXRpb24KKyAqIGtleXJpbmcgaWYgb25lIGlzIHByb3ZpZGVkLgorICoKKyAqIFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBrZXkgaWYgc3VjY2Vzc2Z1bDsgLUVBQ0NFUywgLUVOT0tFWSwgLUVLRVlSRVZPS0VECisgKiBvciAtRUtFWUVYUElSRUQgaWYgYW4gaW5hY2Nlc3NpYmxlLCBuZWdhdGl2ZSwgcmV2b2tlZCBvciBleHBpcmVkIGtleSB3YXMKKyAqIGZvdW5kOyAtRU5PS0VZIGlmIG5vIGtleSB3YXMgZm91bmQgYW5kIG5vIEBjYWxsb3V0X2luZm8gd2FzIGdpdmVuOyAtRURRVU9UCisgKiBpZiBpbnN1ZmZpY2llbnQga2V5IHF1b3RhIHdhcyBhdmFpbGFibGUgdG8gY3JlYXRlIGEgbmV3IGtleTsgb3IgLUVOT01FTSBpZgorICogaW5zdWZmaWNpZW50IG1lbW9yeSB3YXMgYXZhaWxhYmxlLgorICoKKyAqIElmIHRoZSByZXR1cm5lZCBrZXkgd2FzIGNyZWF0ZWQsIHRoZW4gaXQgbWF5IHN0aWxsIGJlIHVuZGVyIGNvbnN0cnVjdGlvbiwKKyAqIGFuZCB3YWl0X2Zvcl9rZXlfY29uc3RydWN0aW9uKCkgc2hvdWxkIGJlIHVzZWQgdG8gd2FpdCBmb3IgdGhhdCB0byBjb21wbGV0ZS4KICAqLwogc3RydWN0IGtleSAqcmVxdWVzdF9rZXlfYW5kX2xpbmsoc3RydWN0IGtleV90eXBlICp0eXBlLAogCQkJCSBjb25zdCBjaGFyICpkZXNjcmlwdGlvbiwKQEAgLTUyNCw4ICs1NjQsMTYgQEAKIAlyZXR1cm4ga2V5OwogfQogCi0vKgotICogd2FpdCBmb3IgY29uc3RydWN0aW9uIG9mIGEga2V5IHRvIGNvbXBsZXRlCisvKioKKyAqIHdhaXRfZm9yX2tleV9jb25zdHJ1Y3Rpb24gLSBXYWl0IGZvciBjb25zdHJ1Y3Rpb24gb2YgYSBrZXkgdG8gY29tcGxldGUKKyAqIEBrZXk6IFRoZSBrZXkgYmVpbmcgd2FpdGVkIGZvci4KKyAqIEBpbnRyOiBXaGV0aGVyIHRvIHdhaXQgaW50ZXJydXB0aWJseS4KKyAqCisgKiBXYWl0IGZvciBhIGtleSB0byBmaW5pc2ggYmVpbmcgY29uc3RydWN0ZWQuCisgKgorICogUmV0dXJucyAwIGlmIHN1Y2Nlc3NmdWw7IC1FUkVTVEFSVFNZUyBpZiB0aGUgd2FpdCB3YXMgaW50ZXJydXB0ZWQ7IC1FTk9LRVkKKyAqIGlmIHRoZSBrZXkgd2FzIG5lZ2F0ZWQ7IG9yIC1FS0VZUkVWT0tFRCBvciAtRUtFWUVYUElSRUQgaWYgdGhlIGtleSB3YXMKKyAqIHJldm9rZWQgb3IgZXhwaXJlZC4KICAqLwogaW50IHdhaXRfZm9yX2tleV9jb25zdHJ1Y3Rpb24oc3RydWN0IGtleSAqa2V5LCBib29sIGludHIpCiB7CkBAIC01NDIsMTIgKzU5MCwxOSBAQAogfQogRVhQT1JUX1NZTUJPTCh3YWl0X2Zvcl9rZXlfY29uc3RydWN0aW9uKTsKIAotLyoKLSAqIHJlcXVlc3QgYSBrZXkKLSAqIC0gc2VhcmNoIHRoZSBwcm9jZXNzJ3Mga2V5cmluZ3MKLSAqIC0gY2hlY2sgdGhlIGxpc3Qgb2Yga2V5cyBiZWluZyBjcmVhdGVkIG9yIHVwZGF0ZWQKLSAqIC0gY2FsbCBvdXQgdG8gdXNlcnNwYWNlIGZvciBhIGtleSBpZiBzdXBwbGVtZW50YXJ5IGluZm8gd2FzIHByb3ZpZGVkCi0gKiAtIHdhaXRzIHVuaW50ZXJydXB0aWJsZSBmb3IgY3JlYXRpb24gdG8gY29tcGxldGUKKy8qKgorICogcmVxdWVzdF9rZXkgLSBSZXF1ZXN0IGEga2V5IGFuZCB3YWl0IGZvciBjb25zdHJ1Y3Rpb24KKyAqIEB0eXBlOiBUeXBlIG9mIGtleS4KKyAqIEBkZXNjcmlwdGlvbjogVGhlIHNlYXJjaGFibGUgZGVzY3JpcHRpb24gb2YgdGhlIGtleS4KKyAqIEBjYWxsb3V0X2luZm86IFRoZSBkYXRhIHRvIHBhc3MgdG8gdGhlIGluc3RhbnRpYXRpb24gdXBjYWxsIChvciBOVUxMKS4KKyAqCisgKiBBcyBmb3IgcmVxdWVzdF9rZXlfYW5kX2xpbmsoKSBleGNlcHQgdGhhdCBpdCBkb2VzIG5vdCBhZGQgdGhlIHJldHVybmVkIGtleQorICogdG8gYSBrZXlyaW5nIGlmIGZvdW5kLCBuZXcga2V5cyBhcmUgYWx3YXlzIGFsbG9jYXRlZCBpbiB0aGUgdXNlcidzIHF1b3RhLAorICogdGhlIGNhbGxvdXRfaW5mbyBtdXN0IGJlIGEgTlVMLXRlcm1pbmF0ZWQgc3RyaW5nIGFuZCBubyBhdXhpbGlhcnkgZGF0YSBjYW4KKyAqIGJlIHBhc3NlZC4KKyAqCisgKiBGdXJ0aGVybW9yZSwgaXQgdGhlbiB3b3JrcyBhcyB3YWl0X2Zvcl9rZXlfY29uc3RydWN0aW9uKCkgdG8gd2FpdCBmb3IgdGhlCisgKiBjb21wbGV0aW9uIG9mIGtleXMgdW5kZXJnb2luZyBjb25zdHJ1Y3Rpb24gd2l0aCBhIG5vbi1pbnRlcnJ1cHRpYmxlIHdhaXQuCiAgKi8KIHN0cnVjdCBrZXkgKnJlcXVlc3Rfa2V5KHN0cnVjdCBrZXlfdHlwZSAqdHlwZSwKIAkJCWNvbnN0IGNoYXIgKmRlc2NyaXB0aW9uLApAQCAtNTcyLDEyICs2MjcsMTkgQEAKIH0KIEVYUE9SVF9TWU1CT0wocmVxdWVzdF9rZXkpOwogCi0vKgotICogcmVxdWVzdCBhIGtleSB3aXRoIGF1eGlsaWFyeSBkYXRhIGZvciB0aGUgdXBjYWxsZXIKLSAqIC0gc2VhcmNoIHRoZSBwcm9jZXNzJ3Mga2V5cmluZ3MKLSAqIC0gY2hlY2sgdGhlIGxpc3Qgb2Yga2V5cyBiZWluZyBjcmVhdGVkIG9yIHVwZGF0ZWQKLSAqIC0gY2FsbCBvdXQgdG8gdXNlcnNwYWNlIGZvciBhIGtleSBpZiBzdXBwbGVtZW50YXJ5IGluZm8gd2FzIHByb3ZpZGVkCi0gKiAtIHdhaXRzIHVuaW50ZXJydXB0aWJsZSBmb3IgY3JlYXRpb24gdG8gY29tcGxldGUKKy8qKgorICogcmVxdWVzdF9rZXlfd2l0aF9hdXhkYXRhIC0gUmVxdWVzdCBhIGtleSB3aXRoIGF1eGlsaWFyeSBkYXRhIGZvciB0aGUgdXBjYWxsZXIKKyAqIEB0eXBlOiBUaGUgdHlwZSBvZiBrZXkgd2Ugd2FudC4KKyAqIEBkZXNjcmlwdGlvbjogVGhlIHNlYXJjaGFibGUgZGVzY3JpcHRpb24gb2YgdGhlIGtleS4KKyAqIEBjYWxsb3V0X2luZm86IFRoZSBkYXRhIHRvIHBhc3MgdG8gdGhlIGluc3RhbnRpYXRpb24gdXBjYWxsIChvciBOVUxMKS4KKyAqIEBjYWxsb3V0X2xlbjogVGhlIGxlbmd0aCBvZiBjYWxsb3V0X2luZm8uCisgKiBAYXV4OiBBdXhpbGlhcnkgZGF0YSBmb3IgdGhlIHVwY2FsbC4KKyAqCisgKiBBcyBmb3IgcmVxdWVzdF9rZXlfYW5kX2xpbmsoKSBleGNlcHQgdGhhdCBpdCBkb2VzIG5vdCBhZGQgdGhlIHJldHVybmVkIGtleQorICogdG8gYSBrZXlyaW5nIGlmIGZvdW5kIGFuZCBuZXcga2V5cyBhcmUgYWx3YXlzIGFsbG9jYXRlZCBpbiB0aGUgdXNlcidzIHF1b3RhLgorICoKKyAqIEZ1cnRoZXJtb3JlLCBpdCB0aGVuIHdvcmtzIGFzIHdhaXRfZm9yX2tleV9jb25zdHJ1Y3Rpb24oKSB0byB3YWl0IGZvciB0aGUKKyAqIGNvbXBsZXRpb24gb2Yga2V5cyB1bmRlcmdvaW5nIGNvbnN0cnVjdGlvbiB3aXRoIGEgbm9uLWludGVycnVwdGlibGUgd2FpdC4KICAqLwogc3RydWN0IGtleSAqcmVxdWVzdF9rZXlfd2l0aF9hdXhkYXRhKHN0cnVjdCBrZXlfdHlwZSAqdHlwZSwKIAkJCQkgICAgIGNvbnN0IGNoYXIgKmRlc2NyaXB0aW9uLApAQCAtNjAyLDEwICs2NjQsMTggQEAKIEVYUE9SVF9TWU1CT0wocmVxdWVzdF9rZXlfd2l0aF9hdXhkYXRhKTsKIAogLyoKLSAqIHJlcXVlc3QgYSBrZXkgKGFsbG93IGFzeW5jIGNvbnN0cnVjdGlvbikKLSAqIC0gc2VhcmNoIHRoZSBwcm9jZXNzJ3Mga2V5cmluZ3MKLSAqIC0gY2hlY2sgdGhlIGxpc3Qgb2Yga2V5cyBiZWluZyBjcmVhdGVkIG9yIHVwZGF0ZWQKLSAqIC0gY2FsbCBvdXQgdG8gdXNlcnNwYWNlIGZvciBhIGtleSBpZiBzdXBwbGVtZW50YXJ5IGluZm8gd2FzIHByb3ZpZGVkCisgKiByZXF1ZXN0X2tleV9hc3luYyAtIFJlcXVlc3QgYSBrZXkgKGFsbG93IGFzeW5jIGNvbnN0cnVjdGlvbikKKyAqIEB0eXBlOiBUeXBlIG9mIGtleS4KKyAqIEBkZXNjcmlwdGlvbjogVGhlIHNlYXJjaGFibGUgZGVzY3JpcHRpb24gb2YgdGhlIGtleS4KKyAqIEBjYWxsb3V0X2luZm86IFRoZSBkYXRhIHRvIHBhc3MgdG8gdGhlIGluc3RhbnRpYXRpb24gdXBjYWxsIChvciBOVUxMKS4KKyAqIEBjYWxsb3V0X2xlbjogVGhlIGxlbmd0aCBvZiBjYWxsb3V0X2luZm8uCisgKgorICogQXMgZm9yIHJlcXVlc3Rfa2V5X2FuZF9saW5rKCkgZXhjZXB0IHRoYXQgaXQgZG9lcyBub3QgYWRkIHRoZSByZXR1cm5lZCBrZXkKKyAqIHRvIGEga2V5cmluZyBpZiBmb3VuZCwgbmV3IGtleXMgYXJlIGFsd2F5cyBhbGxvY2F0ZWQgaW4gdGhlIHVzZXIncyBxdW90YSBhbmQKKyAqIG5vIGF1eGlsaWFyeSBkYXRhIGNhbiBiZSBwYXNzZWQuCisgKgorICogVGhlIGNhbGxlciBzaG91bGQgY2FsbCB3YWl0X2Zvcl9rZXlfY29uc3RydWN0aW9uKCkgdG8gd2FpdCBmb3IgdGhlCisgKiBjb21wbGV0aW9uIG9mIHRoZSByZXR1cm5lZCBrZXkgaWYgaXQgaXMgc3RpbGwgdW5kZXJnb2luZyBjb25zdHJ1Y3Rpb24uCiAgKi8KIHN0cnVjdCBrZXkgKnJlcXVlc3Rfa2V5X2FzeW5jKHN0cnVjdCBrZXlfdHlwZSAqdHlwZSwKIAkJCSAgICAgIGNvbnN0IGNoYXIgKmRlc2NyaXB0aW9uLApAQCAtNjIwLDkgKzY5MCwxNyBAQAogCiAvKgogICogcmVxdWVzdCBhIGtleSB3aXRoIGF1eGlsaWFyeSBkYXRhIGZvciB0aGUgdXBjYWxsZXIgKGFsbG93IGFzeW5jIGNvbnN0cnVjdGlvbikKLSAqIC0gc2VhcmNoIHRoZSBwcm9jZXNzJ3Mga2V5cmluZ3MKLSAqIC0gY2hlY2sgdGhlIGxpc3Qgb2Yga2V5cyBiZWluZyBjcmVhdGVkIG9yIHVwZGF0ZWQKLSAqIC0gY2FsbCBvdXQgdG8gdXNlcnNwYWNlIGZvciBhIGtleSBpZiBzdXBwbGVtZW50YXJ5IGluZm8gd2FzIHByb3ZpZGVkCisgKiBAdHlwZTogVHlwZSBvZiBrZXkuCisgKiBAZGVzY3JpcHRpb246IFRoZSBzZWFyY2hhYmxlIGRlc2NyaXB0aW9uIG9mIHRoZSBrZXkuCisgKiBAY2FsbG91dF9pbmZvOiBUaGUgZGF0YSB0byBwYXNzIHRvIHRoZSBpbnN0YW50aWF0aW9uIHVwY2FsbCAob3IgTlVMTCkuCisgKiBAY2FsbG91dF9sZW46IFRoZSBsZW5ndGggb2YgY2FsbG91dF9pbmZvLgorICogQGF1eDogQXV4aWxpYXJ5IGRhdGEgZm9yIHRoZSB1cGNhbGwuCisgKgorICogQXMgZm9yIHJlcXVlc3Rfa2V5X2FuZF9saW5rKCkgZXhjZXB0IHRoYXQgaXQgZG9lcyBub3QgYWRkIHRoZSByZXR1cm5lZCBrZXkKKyAqIHRvIGEga2V5cmluZyBpZiBmb3VuZCBhbmQgbmV3IGtleXMgYXJlIGFsd2F5cyBhbGxvY2F0ZWQgaW4gdGhlIHVzZXIncyBxdW90YS4KKyAqCisgKiBUaGUgY2FsbGVyIHNob3VsZCBjYWxsIHdhaXRfZm9yX2tleV9jb25zdHJ1Y3Rpb24oKSB0byB3YWl0IGZvciB0aGUKKyAqIGNvbXBsZXRpb24gb2YgdGhlIHJldHVybmVkIGtleSBpZiBpdCBpcyBzdGlsbCB1bmRlcmdvaW5nIGNvbnN0cnVjdGlvbi4KICAqLwogc3RydWN0IGtleSAqcmVxdWVzdF9rZXlfYXN5bmNfd2l0aF9hdXhkYXRhKHN0cnVjdCBrZXlfdHlwZSAqdHlwZSwKIAkJCQkJICAgY29uc3QgY2hhciAqZGVzY3JpcHRpb24sCmRpZmYgLS1naXQgYS9zZWN1cml0eS9rZXlzL3JlcXVlc3Rfa2V5X2F1dGguYyBiL3NlY3VyaXR5L2tleXMvcmVxdWVzdF9rZXlfYXV0aC5jCmluZGV4IDg2NzQ3MTUuLjY4MTY0MDMgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L2tleXMvcmVxdWVzdF9rZXlfYXV0aC5jCisrKyBiL3NlY3VyaXR5L2tleXMvcmVxdWVzdF9rZXlfYXV0aC5jCkBAIC0xLDQgKzEsNCBAQAotLyogcmVxdWVzdF9rZXlfYXV0aC5jOiByZXF1ZXN0IGtleSBhdXRob3Jpc2F0aW9uIGNvbnRyb2xsaW5nIGtleSBkZWYKKy8qIFJlcXVlc3Qga2V5IGF1dGhvcmlzYXRpb24gdG9rZW4ga2V5IGRlZmluaXRpb24uCiAgKgogICogQ29weXJpZ2h0IChDKSAyMDA1IFJlZCBIYXQsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KICAqIFdyaXR0ZW4gYnkgRGF2aWQgSG93ZWxscyAoZGhvd2VsbHNAcmVkaGF0LmNvbSkKQEAgLTI2LDcgKzI2LDcgQEAKIHN0YXRpYyBsb25nIHJlcXVlc3Rfa2V5X2F1dGhfcmVhZChjb25zdCBzdHJ1Y3Qga2V5ICosIGNoYXIgX191c2VyICosIHNpemVfdCk7CiAKIC8qCi0gKiB0aGUgcmVxdWVzdC1rZXkgYXV0aG9yaXNhdGlvbiBrZXkgdHlwZSBkZWZpbml0aW9uCisgKiBUaGUgcmVxdWVzdC1rZXkgYXV0aG9yaXNhdGlvbiBrZXkgdHlwZSBkZWZpbml0aW9uLgogICovCiBzdHJ1Y3Qga2V5X3R5cGUga2V5X3R5cGVfcmVxdWVzdF9rZXlfYXV0aCA9IHsKIAkubmFtZQkJPSAiLnJlcXVlc3Rfa2V5X2F1dGgiLApAQCAtMzgsOSArMzgsOCBAQAogCS5yZWFkCQk9IHJlcXVlc3Rfa2V5X2F1dGhfcmVhZCwKIH07CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBpbnN0YW50aWF0ZSBhIHJlcXVlc3Qta2V5IGF1dGhvcmlzYXRpb24ga2V5CisgKiBJbnN0YW50aWF0ZSBhIHJlcXVlc3Qta2V5IGF1dGhvcmlzYXRpb24ga2V5LgogICovCiBzdGF0aWMgaW50IHJlcXVlc3Rfa2V5X2F1dGhfaW5zdGFudGlhdGUoc3RydWN0IGtleSAqa2V5LAogCQkJCQljb25zdCB2b2lkICpkYXRhLApAQCAtNDgsMTIgKzQ3LDEwIEBACiB7CiAJa2V5LT5wYXlsb2FkLmRhdGEgPSAoc3RydWN0IHJlcXVlc3Rfa2V5X2F1dGggKikgZGF0YTsKIAlyZXR1cm4gMDsKK30KIAotfSAvKiBlbmQgcmVxdWVzdF9rZXlfYXV0aF9pbnN0YW50aWF0ZSgpICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiByZWFkaW5nIGEgcmVxdWVzdC1rZXkgYXV0aG9yaXNhdGlvbiBrZXkgcmV0cmlldmVzIHRoZSBjYWxsb3V0IGluZm9ybWF0aW9uCisgKiBEZXNjcmliZSBhbiBhdXRob3Jpc2F0aW9uIHRva2VuLgogICovCiBzdGF0aWMgdm9pZCByZXF1ZXN0X2tleV9hdXRoX2Rlc2NyaWJlKGNvbnN0IHN0cnVjdCBrZXkgKmtleSwKIAkJCQkgICAgICBzdHJ1Y3Qgc2VxX2ZpbGUgKm0pCkBAIC02MywxMiArNjAsMTAgQEAKIAlzZXFfcHV0cyhtLCAia2V5OiIpOwogCXNlcV9wdXRzKG0sIGtleS0+ZGVzY3JpcHRpb24pOwogCXNlcV9wcmludGYobSwgIiBwaWQ6JWQgY2k6JXp1IiwgcmthLT5waWQsIHJrYS0+Y2FsbG91dF9sZW4pOworfQogCi19IC8qIGVuZCByZXF1ZXN0X2tleV9hdXRoX2Rlc2NyaWJlKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIHJlYWQgdGhlIGNhbGxvdXRfaW5mbyBkYXRhCisgKiBSZWFkIHRoZSBjYWxsb3V0X2luZm8gZGF0YSAocmV0cmlldmVzIHRoZSBjYWxsb3V0IGluZm9ybWF0aW9uKS4KICAqIC0gdGhlIGtleSdzIHNlbWFwaG9yZSBpcyByZWFkLWxvY2tlZAogICovCiBzdGF0aWMgbG9uZyByZXF1ZXN0X2tleV9hdXRoX3JlYWQoY29uc3Qgc3RydWN0IGtleSAqa2V5LApAQCAtOTEsMTMgKzg2LDEyIEBACiAJfQogCiAJcmV0dXJuIHJldDsKK30KIAotfSAvKiBlbmQgcmVxdWVzdF9rZXlfYXV0aF9yZWFkKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIGhhbmRsZSByZXZvY2F0aW9uIG9mIGFuIGF1dGhvcmlzYXRpb24gdG9rZW4ga2V5Ci0gKiAtIGNhbGxlZCB3aXRoIHRoZSBrZXkgc2VtIHdyaXRlLWxvY2tlZAorICogSGFuZGxlIHJldm9jYXRpb24gb2YgYW4gYXV0aG9yaXNhdGlvbiB0b2tlbiBrZXkuCisgKgorICogQ2FsbGVkIHdpdGggdGhlIGtleSBzZW0gd3JpdGUtbG9ja2VkLgogICovCiBzdGF0aWMgdm9pZCByZXF1ZXN0X2tleV9hdXRoX3Jldm9rZShzdHJ1Y3Qga2V5ICprZXkpCiB7CkBAIC0xMDksMTIgKzEwMywxMCBAQAogCQlwdXRfY3JlZChya2EtPmNyZWQpOwogCQlya2EtPmNyZWQgPSBOVUxMOwogCX0KK30KIAotfSAvKiBlbmQgcmVxdWVzdF9rZXlfYXV0aF9yZXZva2UoKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogZGVzdHJveSBhbiBpbnN0YW50aWF0aW9uIGF1dGhvcmlzYXRpb24gdG9rZW4ga2V5CisgKiBEZXN0cm95IGFuIGluc3RhbnRpYXRpb24gYXV0aG9yaXNhdGlvbiB0b2tlbiBrZXkuCiAgKi8KIHN0YXRpYyB2b2lkIHJlcXVlc3Rfa2V5X2F1dGhfZGVzdHJveShzdHJ1Y3Qga2V5ICprZXkpCiB7CkBAIC0xMzEsMTMgKzEyMywxMSBAQAogCWtleV9wdXQocmthLT5kZXN0X2tleXJpbmcpOwogCWtmcmVlKHJrYS0+Y2FsbG91dF9pbmZvKTsKIAlrZnJlZShya2EpOworfQogCi19IC8qIGVuZCByZXF1ZXN0X2tleV9hdXRoX2Rlc3Ryb3koKSAqLwotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgotICogY3JlYXRlIGFuIGF1dGhvcmlzYXRpb24gdG9rZW4gZm9yIC9zYmluL3JlcXVlc3Qta2V5IG9yIHdob2V2ZXIgdG8gZ2FpbgotICogYWNjZXNzIHRvIHRoZSBjYWxsZXIncyBzZWN1cml0eSBkYXRhCisgKiBDcmVhdGUgYW4gYXV0aG9yaXNhdGlvbiB0b2tlbiBmb3IgL3NiaW4vcmVxdWVzdC1rZXkgb3Igd2hvZXZlciB0byBnYWluCisgKiBhY2Nlc3MgdG8gdGhlIGNhbGxlcidzIHNlY3VyaXR5IGRhdGEuCiAgKi8KIHN0cnVjdCBrZXkgKnJlcXVlc3Rfa2V5X2F1dGhfbmV3KHN0cnVjdCBrZXkgKnRhcmdldCwgY29uc3Qgdm9pZCAqY2FsbG91dF9pbmZvLAogCQkJCSBzaXplX3QgY2FsbG91dF9sZW4sIHN0cnVjdCBrZXkgKmRlc3Rfa2V5cmluZykKQEAgLTIyOCwxMiArMjE4LDEwIEBACiAJa2ZyZWUocmthKTsKIAlrbGVhdmUoIj0gJWQiLCByZXQpOwogCXJldHVybiBFUlJfUFRSKHJldCk7Cit9CiAKLX0gLyogZW5kIHJlcXVlc3Rfa2V5X2F1dGhfbmV3KCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIHNlZSBpZiBhbiBhdXRob3Jpc2F0aW9uIGtleSBpcyBhc3NvY2lhdGVkIHdpdGggYSBwYXJ0aWN1bGFyIGtleQorICogU2VlIGlmIGFuIGF1dGhvcmlzYXRpb24ga2V5IGlzIGFzc29jaWF0ZWQgd2l0aCBhIHBhcnRpY3VsYXIga2V5LgogICovCiBzdGF0aWMgaW50IGtleV9nZXRfaW5zdGFudGlhdGlvbl9hdXRoa2V5X21hdGNoKGNvbnN0IHN0cnVjdCBrZXkgKmtleSwKIAkJCQkJICAgICAgIGNvbnN0IHZvaWQgKl9pZCkKQEAgLTI0MiwxNiArMjMwLDExIEBACiAJa2V5X3NlcmlhbF90IGlkID0gKGtleV9zZXJpYWxfdCkodW5zaWduZWQgbG9uZykgX2lkOwogCiAJcmV0dXJuIHJrYS0+dGFyZ2V0X2tleS0+c2VyaWFsID09IGlkOworfQogCi19IC8qIGVuZCBrZXlfZ2V0X2luc3RhbnRpYXRpb25fYXV0aGtleV9tYXRjaCgpICovCi0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBnZXQgdGhlIGF1dGhvcmlzYXRpb24ga2V5IGZvciBpbnN0YW50aWF0aW9uIG9mIGEgc3BlY2lmaWMga2V5IGlmIGF0dGFjaGVkIHRvCi0gKiB0aGUgY3VycmVudCBwcm9jZXNzJ3Mga2V5cmluZ3MKLSAqIC0gdGhpcyBrZXkgaXMgaW5zZXJ0ZWQgaW50byBhIGtleXJpbmcgYW5kIHRoYXQgaXMgc2V0IGFzIC9zYmluL3JlcXVlc3Qta2V5J3MKLSAqICAgc2Vzc2lvbiBrZXlyaW5nCi0gKiAtIGEgdGFyZ2V0X2lkIG9mIHplcm8gc3BlY2lmaWVzIGFueSB2YWxpZCB0b2tlbgorICogU2VhcmNoIHRoZSBjdXJyZW50IHByb2Nlc3MncyBrZXlyaW5ncyBmb3IgdGhlIGF1dGhvcmlzYXRpb24ga2V5IGZvcgorICogaW5zdGFudGlhdGlvbiBvZiBhIGtleS4KICAqLwogc3RydWN0IGtleSAqa2V5X2dldF9pbnN0YW50aWF0aW9uX2F1dGhrZXkoa2V5X3NlcmlhbF90IHRhcmdldF9pZCkKIHsKQEAgLTI3OCw1ICsyNjEsNCBAQAogCiBlcnJvcjoKIAlyZXR1cm4gYXV0aGtleTsKLQotfSAvKiBlbmQga2V5X2dldF9pbnN0YW50aWF0aW9uX2F1dGhrZXkoKSAqLworfQpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkva2V5cy90cnVzdGVkX2RlZmluZWQuYyBiL3NlY3VyaXR5L2tleXMvdHJ1c3RlZC5jCnNpbWlsYXJpdHkgaW5kZXggOTclCnJlbmFtZSBmcm9tIHNlY3VyaXR5L2tleXMvdHJ1c3RlZF9kZWZpbmVkLmMKcmVuYW1lIHRvIHNlY3VyaXR5L2tleXMvdHJ1c3RlZC5jCmluZGV4IDk3NWU5ZjIuLjgzZmM5MmUgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L2tleXMvdHJ1c3RlZF9kZWZpbmVkLmMKKysrIGIvc2VjdXJpdHkva2V5cy90cnVzdGVkLmMKQEAgLTI5LDcgKzI5LDcgQEAKICNpbmNsdWRlIDxsaW51eC90cG0uaD4KICNpbmNsdWRlIDxsaW51eC90cG1fY29tbWFuZC5oPgogCi0jaW5jbHVkZSAidHJ1c3RlZF9kZWZpbmVkLmgiCisjaW5jbHVkZSAidHJ1c3RlZC5oIgogCiBzdGF0aWMgY29uc3QgY2hhciBobWFjX2FsZ1tdID0gImhtYWMoc2hhMSkiOwogc3RhdGljIGNvbnN0IGNoYXIgaGFzaF9hbGdbXSA9ICJzaGExIjsKQEAgLTEwMSwxMSArMTAxLDEzIEBACiAJCWlmIChkbGVuID09IDApCiAJCQlicmVhazsKIAkJZGF0YSA9IHZhX2FyZyhhcmdwLCB1bnNpZ25lZCBjaGFyICopOwotCQlpZiAoZGF0YSA9PSBOVUxMKQotCQkJcmV0dXJuIC1FSU5WQUw7CisJCWlmIChkYXRhID09IE5VTEwpIHsKKwkJCXJldCA9IC1FSU5WQUw7CisJCQlicmVhazsKKwkJfQogCQlyZXQgPSBjcnlwdG9fc2hhc2hfdXBkYXRlKCZzZGVzYy0+c2hhc2gsIGRhdGEsIGRsZW4pOwogCQlpZiAocmV0IDwgMCkKLQkJCWdvdG8gb3V0OworCQkJYnJlYWs7CiAJfQogCXZhX2VuZChhcmdwKTsKIAlpZiAoIXJldCkKQEAgLTE0NiwxNCArMTQ4LDE3IEBACiAJCWlmIChkbGVuID09IDApCiAJCQlicmVhazsKIAkJZGF0YSA9IHZhX2FyZyhhcmdwLCB1bnNpZ25lZCBjaGFyICopOwotCQlyZXQgPSBjcnlwdG9fc2hhc2hfdXBkYXRlKCZzZGVzYy0+c2hhc2gsIGRhdGEsIGRsZW4pOwotCQlpZiAocmV0IDwgMCkgewotCQkJdmFfZW5kKGFyZ3ApOwotCQkJZ290byBvdXQ7CisJCWlmICghZGF0YSkgeworCQkJcmV0ID0gLUVJTlZBTDsKKwkJCWJyZWFrOwogCQl9CisJCXJldCA9IGNyeXB0b19zaGFzaF91cGRhdGUoJnNkZXNjLT5zaGFzaCwgZGF0YSwgZGxlbik7CisJCWlmIChyZXQgPCAwKQorCQkJYnJlYWs7CiAJfQogCXZhX2VuZChhcmdwKTsKLQlyZXQgPSBjcnlwdG9fc2hhc2hfZmluYWwoJnNkZXNjLT5zaGFzaCwgcGFyYW1kaWdlc3QpOworCWlmICghcmV0KQorCQlyZXQgPSBjcnlwdG9fc2hhc2hfZmluYWwoJnNkZXNjLT5zaGFzaCwgcGFyYW1kaWdlc3QpOwogCWlmICghcmV0KQogCQlyZXQgPSBUU1NfcmF3aG1hYyhkaWdlc3QsIGtleSwga2V5bGVuLCBTSEExX0RJR0VTVF9TSVpFLAogCQkJCSAgcGFyYW1kaWdlc3QsIFRQTV9OT05DRV9TSVpFLCBoMSwKQEAgLTIyMiwxMyArMjI3LDEyIEBACiAJCQlicmVhazsKIAkJZHBvcyA9IHZhX2FyZyhhcmdwLCB1bnNpZ25lZCBpbnQpOwogCQlyZXQgPSBjcnlwdG9fc2hhc2hfdXBkYXRlKCZzZGVzYy0+c2hhc2gsIGJ1ZmZlciArIGRwb3MsIGRsZW4pOwotCQlpZiAocmV0IDwgMCkgewotCQkJdmFfZW5kKGFyZ3ApOwotCQkJZ290byBvdXQ7Ci0JCX0KKwkJaWYgKHJldCA8IDApCisJCQlicmVhazsKIAl9CiAJdmFfZW5kKGFyZ3ApOwotCXJldCA9IGNyeXB0b19zaGFzaF9maW5hbCgmc2Rlc2MtPnNoYXNoLCBwYXJhbWRpZ2VzdCk7CisJaWYgKCFyZXQpCisJCXJldCA9IGNyeXB0b19zaGFzaF9maW5hbCgmc2Rlc2MtPnNoYXNoLCBwYXJhbWRpZ2VzdCk7CiAJaWYgKHJldCA8IDApCiAJCWdvdG8gb3V0OwogCkBAIC0zMTYsMTMgKzMyMCwxMiBAQAogCQkJYnJlYWs7CiAJCWRwb3MgPSB2YV9hcmcoYXJncCwgdW5zaWduZWQgaW50KTsKIAkJcmV0ID0gY3J5cHRvX3NoYXNoX3VwZGF0ZSgmc2Rlc2MtPnNoYXNoLCBidWZmZXIgKyBkcG9zLCBkbGVuKTsKLQkJaWYgKHJldCA8IDApIHsKLQkJCXZhX2VuZChhcmdwKTsKLQkJCWdvdG8gb3V0OwotCQl9CisJCWlmIChyZXQgPCAwKQorCQkJYnJlYWs7CiAJfQogCXZhX2VuZChhcmdwKTsKLQlyZXQgPSBjcnlwdG9fc2hhc2hfZmluYWwoJnNkZXNjLT5zaGFzaCwgcGFyYW1kaWdlc3QpOworCWlmICghcmV0KQorCQlyZXQgPSBjcnlwdG9fc2hhc2hfZmluYWwoJnNkZXNjLT5zaGFzaCwgcGFyYW1kaWdlc3QpOwogCWlmIChyZXQgPCAwKQogCQlnb3RvIG91dDsKIApAQCAtNTExLDcgKzUxNCw3IEBACiAJLyogZ2V0IHNlc3Npb24gZm9yIHNlYWxpbmcga2V5ICovCiAJcmV0ID0gb3NhcCh0YiwgJnNlc3MsIGtleWF1dGgsIGtleXR5cGUsIGtleWhhbmRsZSk7CiAJaWYgKHJldCA8IDApCi0JCXJldHVybiByZXQ7CisJCWdvdG8gb3V0OwogCWR1bXBfc2Vzcygmc2Vzcyk7CiAKIAkvKiBjYWxjdWxhdGUgZW5jcnlwdGVkIGF1dGhvcml6YXRpb24gdmFsdWUgKi8KQEAgLTUxOSwxMSArNTIyLDExIEBACiAJbWVtY3B5KHRkLT54b3J3b3JrICsgU0hBMV9ESUdFU1RfU0laRSwgc2Vzcy5lbm9uY2UsIFNIQTFfRElHRVNUX1NJWkUpOwogCXJldCA9IFRTU19zaGExKHRkLT54b3J3b3JrLCBTSEExX0RJR0VTVF9TSVpFICogMiwgdGQtPnhvcmhhc2gpOwogCWlmIChyZXQgPCAwKQotCQlyZXR1cm4gcmV0OworCQlnb3RvIG91dDsKIAogCXJldCA9IHRwbV9nZXRfcmFuZG9tKHRiLCB0ZC0+bm9uY2VvZGQsIFRQTV9OT05DRV9TSVpFKTsKIAlpZiAocmV0IDwgMCkKLQkJcmV0dXJuIHJldDsKKwkJZ290byBvdXQ7CiAJb3JkaW5hbCA9IGh0b25sKFRQTV9PUkRfU0VBTCk7CiAJZGF0c2l6ZSA9IGh0b25sKGRhdGFsZW4pOwogCXBjcnNpemUgPSBodG9ubChwY3JpbmZvc2l6ZSk7CkBAIC01NTIsNyArNTU1LDcgQEAKIAkJCQkgICAmZGF0c2l6ZSwgZGF0YWxlbiwgZGF0YSwgMCwgMCk7CiAJfQogCWlmIChyZXQgPCAwKQotCQlyZXR1cm4gcmV0OworCQlnb3RvIG91dDsKIAogCS8qIGJ1aWxkIGFuZCBzZW5kIHRoZSBUUE0gcmVxdWVzdCBwYWNrZXQgKi8KIAlJTklUX0JVRih0Yik7CkBAIC01NzIsNyArNTc1LDcgQEAKIAogCXJldCA9IHRydXN0ZWRfdHBtX3NlbmQoVFBNX0FOWV9OVU0sIHRiLT5kYXRhLCBNQVhfQlVGX1NJWkUpOwogCWlmIChyZXQgPCAwKQotCQlyZXR1cm4gcmV0OworCQlnb3RvIG91dDsKIAogCS8qIGNhbGN1bGF0ZSB0aGUgc2l6ZSBvZiB0aGUgcmV0dXJuZWQgQmxvYiAqLwogCXNlYWxpbmZvc2l6ZSA9IExPQUQzMih0Yi0+ZGF0YSwgVFBNX0RBVEFfT0ZGU0VUICsgc2l6ZW9mKHVpbnQzMl90KSk7CkBAIC01OTEsNiArNTk0LDggQEAKIAkJbWVtY3B5KGJsb2IsIHRiLT5kYXRhICsgVFBNX0RBVEFfT0ZGU0VULCBzdG9yZWRzaXplKTsKIAkJKmJsb2JsZW4gPSBzdG9yZWRzaXplOwogCX0KK291dDoKKwlrZnJlZSh0ZCk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtMTAyNyw2ICsxMDMyLDcgQEAKIAlyZXQgPSBkYXRhYmxvYl9wYXJzZShkYXRhYmxvYiwgbmV3X3AsIG5ld19vKTsKIAlpZiAocmV0ICE9IE9wdF91cGRhdGUpIHsKIAkJcmV0ID0gLUVJTlZBTDsKKwkJa2ZyZWUobmV3X3ApOwogCQlnb3RvIG91dDsKIAl9CiAJLyogY29weSBvbGQga2V5IHZhbHVlcywgYW5kIHJlc2VhbCB3aXRoIG5ldyBwY3JzICovCmRpZmYgLS1naXQgYS9zZWN1cml0eS9rZXlzL3RydXN0ZWRfZGVmaW5lZC5oIGIvc2VjdXJpdHkva2V5cy90cnVzdGVkLmgKc2ltaWxhcml0eSBpbmRleCAxMDAlCnJlbmFtZSBmcm9tIHNlY3VyaXR5L2tleXMvdHJ1c3RlZF9kZWZpbmVkLmgKcmVuYW1lIHRvIHNlY3VyaXR5L2tleXMvdHJ1c3RlZC5oCmRpZmYgLS1naXQgYS9zZWN1cml0eS9rZXlzL3VzZXJfZGVmaW5lZC5jIGIvc2VjdXJpdHkva2V5cy91c2VyX2RlZmluZWQuYwppbmRleCBlOWFhMDc5Li4wMjgwN2ZiIDEwMDY0NAotLS0gYS9zZWN1cml0eS9rZXlzL3VzZXJfZGVmaW5lZC5jCisrKyBiL3NlY3VyaXR5L2tleXMvdXNlcl9kZWZpbmVkLmMKQEAgLTM1LDcgKzM1LDYgQEAKIAogRVhQT1JUX1NZTUJPTF9HUEwoa2V5X3R5cGVfdXNlcik7CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCiAgKiBpbnN0YW50aWF0ZSBhIHVzZXIgZGVmaW5lZCBrZXkKICAqLwpAQCAtNjUsMTIgKzY0LDEwIEBACiAKIGVycm9yOgogCXJldHVybiByZXQ7Ci0KLX0gLyogZW5kIHVzZXJfaW5zdGFudGlhdGUoKSAqLworfQogCiBFWFBPUlRfU1lNQk9MX0dQTCh1c2VyX2luc3RhbnRpYXRlKTsKIAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKICAqIGRpc3Bvc2Ugb2YgdGhlIG9sZCBkYXRhIGZyb20gYW4gdXBkYXRlZCB1c2VyIGRlZmluZWQga2V5CiAgKi8KQEAgLTgxLDEwICs3OCw4IEBACiAJdXBheWxvYWQgPSBjb250YWluZXJfb2YocmN1LCBzdHJ1Y3QgdXNlcl9rZXlfcGF5bG9hZCwgcmN1KTsKIAogCWtmcmVlKHVwYXlsb2FkKTsKK30KIAotfSAvKiBlbmQgdXNlcl91cGRhdGVfcmN1X2Rpc3Bvc2FsKCkgKi8KLQotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKICAqIHVwZGF0ZSBhIHVzZXIgZGVmaW5lZCBrZXkKICAqIC0gdGhlIGtleSdzIHNlbWFwaG9yZSBpcyB3cml0ZS1sb2NrZWQKQEAgLTEyMywyNCArMTE4LDIwIEBACiAKIGVycm9yOgogCXJldHVybiByZXQ7Ci0KLX0gLyogZW5kIHVzZXJfdXBkYXRlKCkgKi8KK30KIAogRVhQT1JUX1NZTUJPTF9HUEwodXNlcl91cGRhdGUpOwogCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAvKgogICogbWF0Y2ggdXNlcnMgb24gdGhlaXIgbmFtZQogICovCiBpbnQgdXNlcl9tYXRjaChjb25zdCBzdHJ1Y3Qga2V5ICprZXksIGNvbnN0IHZvaWQgKmRlc2NyaXB0aW9uKQogewogCXJldHVybiBzdHJjbXAoa2V5LT5kZXNjcmlwdGlvbiwgZGVzY3JpcHRpb24pID09IDA7Ci0KLX0gLyogZW5kIHVzZXJfbWF0Y2goKSAqLworfQogCiBFWFBPUlRfU1lNQk9MX0dQTCh1c2VyX21hdGNoKTsKIAotLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKICAqIGRpc3Bvc2Ugb2YgdGhlIGxpbmtzIGZyb20gYSByZXZva2VkIGtleXJpbmcKICAqIC0gY2FsbGVkIHdpdGggdGhlIGtleSBzZW0gd3JpdGUtbG9ja2VkCkBAIC0xNTYsMTIgKzE0NywxMCBAQAogCQlyY3VfYXNzaWduX3BvaW50ZXIoa2V5LT5wYXlsb2FkLmRhdGEsIE5VTEwpOwogCQljYWxsX3JjdSgmdXBheWxvYWQtPnJjdSwgdXNlcl91cGRhdGVfcmN1X2Rpc3Bvc2FsKTsKIAl9Ci0KLX0gLyogZW5kIHVzZXJfcmV2b2tlKCkgKi8KK30KIAogRVhQT1JUX1NZTUJPTCh1c2VyX3Jldm9rZSk7CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCiAgKiBkaXNwb3NlIG9mIHRoZSBkYXRhIGRhbmdsaW5nIGZyb20gdGhlIGNvcnBzZSBvZiBhIHVzZXIga2V5CiAgKi8KQEAgLTE3MCwxMiArMTU5LDEwIEBACiAJc3RydWN0IHVzZXJfa2V5X3BheWxvYWQgKnVwYXlsb2FkID0ga2V5LT5wYXlsb2FkLmRhdGE7CiAKIAlrZnJlZSh1cGF5bG9hZCk7Ci0KLX0gLyogZW5kIHVzZXJfZGVzdHJveSgpICovCit9CiAKIEVYUE9SVF9TWU1CT0xfR1BMKHVzZXJfZGVzdHJveSk7CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCiAgKiBkZXNjcmliZSB0aGUgdXNlciBrZXkKICAqLwpAQCAtMTg0LDEyICsxNzEsMTAgQEAKIAlzZXFfcHV0cyhtLCBrZXktPmRlc2NyaXB0aW9uKTsKIAogCXNlcV9wcmludGYobSwgIjogJXUiLCBrZXktPmRhdGFsZW4pOwotCi19IC8qIGVuZCB1c2VyX2Rlc2NyaWJlKCkgKi8KK30KIAogRVhQT1JUX1NZTUJPTF9HUEwodXNlcl9kZXNjcmliZSk7CiAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCiAgKiByZWFkIHRoZSBrZXkgZGF0YQogICogLSB0aGUga2V5J3Mgc2VtYXBob3JlIGlzIHJlYWQtbG9ja2VkCkBAIC0yMTMsNyArMTk4LDYgQEAKIAl9CiAKIAlyZXR1cm4gcmV0OwotCi19IC8qIGVuZCB1c2VyX3JlYWQoKSAqLworfQogCiBFWFBPUlRfU1lNQk9MX0dQTCh1c2VyX3JlYWQpOwpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkvc2VjdXJpdHkuYyBiL3NlY3VyaXR5L3NlY3VyaXR5LmMKaW5kZXggNzM5ZTQwMy4uN2I3MzA4YSAxMDA2NDQKLS0tIGEvc2VjdXJpdHkvc2VjdXJpdHkuYworKysgYi9zZWN1cml0eS9zZWN1cml0eS5jCkBAIC0xNTQsMTAgKzE1NCw5IEBACiAJCQkJICAgIGVmZmVjdGl2ZSwgaW5oZXJpdGFibGUsIHBlcm1pdHRlZCk7CiB9CiAKLWludCBzZWN1cml0eV9jYXBhYmxlKGludCBjYXApCitpbnQgc2VjdXJpdHlfY2FwYWJsZShjb25zdCBzdHJ1Y3QgY3JlZCAqY3JlZCwgaW50IGNhcCkKIHsKLQlyZXR1cm4gc2VjdXJpdHlfb3BzLT5jYXBhYmxlKGN1cnJlbnQsIGN1cnJlbnRfY3JlZCgpLCBjYXAsCi0JCQkJICAgICBTRUNVUklUWV9DQVBfQVVESVQpOworCXJldHVybiBzZWN1cml0eV9vcHMtPmNhcGFibGUoY3VycmVudCwgY3JlZCwgY2FwLCBTRUNVUklUWV9DQVBfQVVESVQpOwogfQogCiBpbnQgc2VjdXJpdHlfcmVhbF9jYXBhYmxlKHN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrLCBpbnQgY2FwKQpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkvc2VsaW51eC9ob29rcy5jIGIvc2VjdXJpdHkvc2VsaW51eC9ob29rcy5jCmluZGV4IGUyNzZlYjQuLmM4ZDY5OTIgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L3NlbGludXgvaG9va3MuYworKysgYi9zZWN1cml0eS9zZWxpbnV4L2hvb2tzLmMKQEAgLTMxOTgsNyArMzE5OCwxMSBAQAogewogCXN0cnVjdCB0YXNrX3NlY3VyaXR5X3N0cnVjdCAqdHNlYyA9IGNyZWQtPnNlY3VyaXR5OwogCi0JQlVHX09OKCh1bnNpZ25lZCBsb25nKSBjcmVkLT5zZWN1cml0eSA8IFBBR0VfU0laRSk7CisJLyoKKwkgKiBjcmVkLT5zZWN1cml0eSA9PSBOVUxMIGlmIHNlY3VyaXR5X2NyZWRfYWxsb2NfYmxhbmsoKSBvcgorCSAqIHNlY3VyaXR5X3ByZXBhcmVfY3JlZHMoKSByZXR1cm5lZCBhbiBlcnJvci4KKwkgKi8KKwlCVUdfT04oY3JlZC0+c2VjdXJpdHkgJiYgKHVuc2lnbmVkIGxvbmcpIGNyZWQtPnNlY3VyaXR5IDwgUEFHRV9TSVpFKTsKIAljcmVkLT5zZWN1cml0eSA9ICh2b2lkICopIDB4N1VMOwogCWtmcmVlKHRzZWMpOwogfQpkaWZmIC0tZ2l0IGEvc2VjdXJpdHkvc2VsaW51eC9zcy9jb25kaXRpb25hbC5jIGIvc2VjdXJpdHkvc2VsaW51eC9zcy9jb25kaXRpb25hbC5jCmluZGV4IGMzZjg0NWMuLmE1MzM3MzIgMTAwNjQ0Ci0tLSBhL3NlY3VyaXR5L3NlbGludXgvc3MvY29uZGl0aW9uYWwuYworKysgYi9zZWN1cml0eS9zZWxpbnV4L3NzL2NvbmRpdGlvbmFsLmMKQEAgLTE3OCw3ICsxNzgsNyBAQAogCXAtPmJvb2xfdmFsX3RvX3N0cnVjdCA9IChzdHJ1Y3QgY29uZF9ib29sX2RhdHVtICoqKQogCQlrbWFsbG9jKHAtPnBfYm9vbHMubnByaW0gKiBzaXplb2Yoc3RydWN0IGNvbmRfYm9vbF9kYXR1bSAqKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFwLT5ib29sX3ZhbF90b19zdHJ1Y3QpCi0JCXJldHVybiAtMTsKKwkJcmV0dXJuIC1FTk9NRU07CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL3NlY3VyaXR5L3NlbGludXgvc3MvcG9saWN5ZGIuYyBiL3NlY3VyaXR5L3NlbGludXgvc3MvcG9saWN5ZGIuYwppbmRleCBiZTlkZTM4Li41NzM2MzU2IDEwMDY0NAotLS0gYS9zZWN1cml0eS9zZWxpbnV4L3NzL3BvbGljeWRiLmMKKysrIGIvc2VjdXJpdHkvc2VsaW51eC9zcy9wb2xpY3lkYi5jCkBAIC01MDEsOCArNTAxLDggQEAKIAlpZiAocmMpCiAJCWdvdG8gb3V0OwogCi0JcmMgPSAtRU5PTUVNOwotCWlmIChjb25kX2luaXRfYm9vbF9pbmRleGVzKHApKQorCXJjID0gY29uZF9pbml0X2Jvb2xfaW5kZXhlcyhwKTsKKwlpZiAocmMpCiAJCWdvdG8gb3V0OwogCiAJZm9yIChpID0gMDsgaSA8IFNZTV9OVU07IGkrKykgewpkaWZmIC0tZ2l0IGEvc291bmQvYXJtL2FhY2kuYyBiL3NvdW5kL2FybS9hYWNpLmMKaW5kZXggOTFhY2M5YS4uN2MxZmM2NCAxMDA2NDQKLS0tIGEvc291bmQvYXJtL2FhY2kuYworKysgYi9zb3VuZC9hcm0vYWFjaS5jCkBAIC0zMCw2ICszMCw4IEBACiAKICNkZWZpbmUgRFJJVkVSX05BTUUJImFhY2ktcGwwNDEiCiAKKyNkZWZpbmUgRlJBTUVfUEVSSU9EX1VTCTIxCisKIC8qCiAgKiBQTSBzdXBwb3J0IGlzIG5vdCBjb21wbGV0ZS4gIFR1cm4gaXQgb2ZmLgogICovCkBAIC00OCw3ICs1MCwxMSBAQAogCWlmICh2ICYgU0xGUl8xUlhWKQogCQlyZWFkbChhYWNpLT5iYXNlICsgQUFDSV9TTDFSWCk7CiAKLQl3cml0ZWwobWFpbmNyLCBhYWNpLT5iYXNlICsgQUFDSV9NQUlOQ1IpOworCWlmIChtYWluY3IgIT0gcmVhZGwoYWFjaS0+YmFzZSArIEFBQ0lfTUFJTkNSKSkgeworCQl3cml0ZWwobWFpbmNyLCBhYWNpLT5iYXNlICsgQUFDSV9NQUlOQ1IpOworCQlyZWFkbChhYWNpLT5iYXNlICsgQUFDSV9NQUlOQ1IpOworCQl1ZGVsYXkoMSk7CisJfQogfQogCiAvKgpAQCAtNjQsOCArNzAsOCBAQAogCQkJICAgIHVuc2lnbmVkIHNob3J0IHZhbCkKIHsKIAlzdHJ1Y3QgYWFjaSAqYWFjaSA9IGFjOTctPnByaXZhdGVfZGF0YTsKKwlpbnQgdGltZW91dDsKIAl1MzIgdjsKLQlpbnQgdGltZW91dCA9IDUwMDA7CiAKIAlpZiAoYWM5Ny0+bnVtID49IDQpCiAJCXJldHVybjsKQEAgLTgxLDE0ICs4NywxNyBAQAogCXdyaXRlbCh2YWwgPDwgNCwgYWFjaS0+YmFzZSArIEFBQ0lfU0wyVFgpOwogCXdyaXRlbChyZWcgPDwgMTIsIGFhY2ktPmJhc2UgKyBBQUNJX1NMMVRYKTsKIAotCS8qCi0JICogV2FpdCBmb3IgdGhlIHRyYW5zbWlzc2lvbiBvZiBib3RoIHNsb3RzIHRvIGNvbXBsZXRlLgotCSAqLworCS8qIEluaXRpYWxseSwgd2FpdCBvbmUgZnJhbWUgcGVyaW9kICovCisJdWRlbGF5KEZSQU1FX1BFUklPRF9VUyk7CisKKwkvKiBBbmQgdGhlbiB3YWl0IGFuIGFkZGl0aW9uYWwgZWlnaHQgZnJhbWUgcGVyaW9kcyBmb3IgaXQgdG8gYmUgc2VudCAqLworCXRpbWVvdXQgPSBGUkFNRV9QRVJJT0RfVVMgKiA4OwogCWRvIHsKKwkJdWRlbGF5KDEpOwogCQl2ID0gcmVhZGwoYWFjaS0+YmFzZSArIEFBQ0lfU0xGUik7CiAJfSB3aGlsZSAoKHYgJiAoU0xGUl8xVFhCfFNMRlJfMlRYQikpICYmIC0tdGltZW91dCk7CiAKLQlpZiAoIXRpbWVvdXQpCisJaWYgKHYgJiAoU0xGUl8xVFhCfFNMRlJfMlRYQikpCiAJCWRldl9lcnIoJmFhY2ktPmRldi0+ZGV2LAogCQkJInRpbWVvdXQgd2FpdGluZyBmb3Igd3JpdGUgdG8gY29tcGxldGVcbiIpOwogCkBAIC0xMDEsOSArMTEwLDggQEAKIHN0YXRpYyB1bnNpZ25lZCBzaG9ydCBhYWNpX2FjOTdfcmVhZChzdHJ1Y3Qgc25kX2FjOTcgKmFjOTcsIHVuc2lnbmVkIHNob3J0IHJlZykKIHsKIAlzdHJ1Y3QgYWFjaSAqYWFjaSA9IGFjOTctPnByaXZhdGVfZGF0YTsKKwlpbnQgdGltZW91dCwgcmV0cmllcyA9IDEwOwogCXUzMiB2OwotCWludCB0aW1lb3V0ID0gNTAwMDsKLQlpbnQgcmV0cmllcyA9IDEwOwogCiAJaWYgKGFjOTctPm51bSA+PSA0KQogCQlyZXR1cm4gfjA7CkBAIC0xMTcsMzUgKzEyNSwzNCBAQAogCSAqLwogCXdyaXRlbCgocmVnIDw8IDEyKSB8ICgxIDw8IDE5KSwgYWFjaS0+YmFzZSArIEFBQ0lfU0wxVFgpOwogCi0JLyoKLQkgKiBXYWl0IGZvciB0aGUgdHJhbnNtaXNzaW9uIHRvIGNvbXBsZXRlLgotCSAqLworCS8qIEluaXRpYWxseSwgd2FpdCBvbmUgZnJhbWUgcGVyaW9kICovCisJdWRlbGF5KEZSQU1FX1BFUklPRF9VUyk7CisKKwkvKiBBbmQgdGhlbiB3YWl0IGFuIGFkZGl0aW9uYWwgZWlnaHQgZnJhbWUgcGVyaW9kcyBmb3IgaXQgdG8gYmUgc2VudCAqLworCXRpbWVvdXQgPSBGUkFNRV9QRVJJT0RfVVMgKiA4OwogCWRvIHsKKwkJdWRlbGF5KDEpOwogCQl2ID0gcmVhZGwoYWFjaS0+YmFzZSArIEFBQ0lfU0xGUik7CiAJfSB3aGlsZSAoKHYgJiBTTEZSXzFUWEIpICYmIC0tdGltZW91dCk7CiAKLQlpZiAoIXRpbWVvdXQpIHsKKwlpZiAodiAmIFNMRlJfMVRYQikgewogCQlkZXZfZXJyKCZhYWNpLT5kZXYtPmRldiwgInRpbWVvdXQgb24gc2xvdCAxIFRYIGJ1c3lcbiIpOwogCQl2ID0gfjA7CiAJCWdvdG8gb3V0OwogCX0KIAotCS8qCi0JICogR2l2ZSB0aGUgQUMnOTcgY29kZWMgbW9yZSB0aGFuIGVub3VnaCB0aW1lCi0JICogdG8gcmVzcG9uZC4gKDQydXMgPSB+MiBmcmFtZXMgYXQgNDhrSHouKQotCSAqLwotCXVkZWxheSg0Mik7CisJLyogTm93IHdhaXQgZm9yIHRoZSByZXNwb25zZSBmcmFtZSAqLworCXVkZWxheShGUkFNRV9QRVJJT0RfVVMpOwogCi0JLyoKLQkgKiBXYWl0IGZvciBzbG90IDIgdG8gaW5kaWNhdGUgZGF0YS4KLQkgKi8KLQl0aW1lb3V0ID0gNTAwMDsKKwkvKiBBbmQgdGhlbiB3YWl0IGFuIGFkZGl0aW9uYWwgZWlnaHQgZnJhbWUgcGVyaW9kcyBmb3IgZGF0YSAqLworCXRpbWVvdXQgPSBGUkFNRV9QRVJJT0RfVVMgKiA4OwogCWRvIHsKKwkJdWRlbGF5KDEpOwogCQljb25kX3Jlc2NoZWQoKTsKIAkJdiA9IHJlYWRsKGFhY2ktPmJhc2UgKyBBQUNJX1NMRlIpICYgKFNMRlJfMVJYVnxTTEZSXzJSWFYpOwogCX0gd2hpbGUgKCh2ICE9IChTTEZSXzFSWFZ8U0xGUl8yUlhWKSkgJiYgLS10aW1lb3V0KTsKIAotCWlmICghdGltZW91dCkgeworCWlmICh2ICE9IChTTEZSXzFSWFZ8U0xGUl8yUlhWKSkgewogCQlkZXZfZXJyKCZhYWNpLT5kZXYtPmRldiwgInRpbWVvdXQgb24gUlggdmFsaWRcbiIpOwogCQl2ID0gfjA7CiAJCWdvdG8gb3V0OwpAQCAtMTc5LDYgKzE4Niw3IEBACiAJaW50IHRpbWVvdXQgPSA1MDAwOwogCiAJZG8geworCQl1ZGVsYXkoMSk7CiAJCXZhbCA9IHJlYWRsKGFhY2lydW4tPmJhc2UgKyBBQUNJX1NSKTsKIAl9IHdoaWxlICh2YWwgJiBtYXNrICYmIHRpbWVvdXQtLSk7CiB9CkBAIC04NzQsNyArODgyLDcgQEAKIAkgKiBHaXZlIHRoZSBBQyc5NyBjb2RlYyBtb3JlIHRoYW4gZW5vdWdoIHRpbWUKIAkgKiB0byB3YWtlIHVwLiAoNDJ1cyA9IH4yIGZyYW1lcyBhdCA0OGtIei4pCiAJICovCi0JdWRlbGF5KDQyKTsKKwl1ZGVsYXkoRlJBTUVfUEVSSU9EX1VTICogMik7CiAKIAlyZXQgPSBzbmRfYWM5N19idXMoYWFjaS0+Y2FyZCwgMCwgJmFhY2lfYnVzX29wcywgYWFjaSwgJmFjOTdfYnVzKTsKIAlpZiAocmV0KQpAQCAtOTg5LDYgKzk5Nyw4IEBACiAJICogZGlzYWJsaW5nIHRoZSBjaGFubmVsIGRvZXNuJ3QgY2xlYXIgdGhlIEZJRk8uCiAJICovCiAJd3JpdGVsKGFhY2ktPm1haW5jciAmIH5NQUlOQ1JfSUUsIGFhY2ktPmJhc2UgKyBBQUNJX01BSU5DUik7CisJcmVhZGwoYWFjaS0+YmFzZSArIEFBQ0lfTUFJTkNSKTsKKwl1ZGVsYXkoMSk7CiAJd3JpdGVsKGFhY2ktPm1haW5jciwgYWFjaS0+YmFzZSArIEFBQ0lfTUFJTkNSKTsKIAogCS8qCmRpZmYgLS1naXQgYS9zb3VuZC9hdG1lbC9hYzk3Yy5jIGIvc291bmQvYXRtZWwvYWM5N2MuYwppbmRleCAxMGMzYTg3Li5iMzEwNzAyIDEwMDY0NAotLS0gYS9zb3VuZC9hdG1lbC9hYzk3Yy5jCisrKyBiL3NvdW5kL2F0bWVsL2FjOTdjLmMKQEAgLTMzLDkgKzMzLDEyIEBACiAjaW5jbHVkZSA8bGludXgvZHdfZG1hYy5oPgogCiAjaW5jbHVkZSA8bWFjaC9jcHUuaD4KLSNpbmNsdWRlIDxtYWNoL2hhcmR3YXJlLmg+CiAjaW5jbHVkZSA8bWFjaC9ncGlvLmg+CiAKKyNpZmRlZiBDT05GSUdfQVJDSF9BVDkxCisjaW5jbHVkZSA8bWFjaC9oYXJkd2FyZS5oPgorI2VuZGlmCisKICNpbmNsdWRlICJhYzk3Yy5oIgogCiBlbnVtIHsKZGlmZiAtLWdpdCBhL3NvdW5kL2NvcmUvaHJ0aW1lci5jIGIvc291bmQvY29yZS9ocnRpbWVyLmMKaW5kZXggNzczMDU3NS4uYjhiMzFjNCAxMDA2NDQKLS0tIGEvc291bmQvY29yZS9ocnRpbWVyLmMKKysrIGIvc291bmQvY29yZS9ocnRpbWVyLmMKQEAgLTQ1LDEyICs0NSwxMyBAQAogewogCXN0cnVjdCBzbmRfaHJ0aW1lciAqc3RpbWUgPSBjb250YWluZXJfb2YoaHJ0LCBzdHJ1Y3Qgc25kX2hydGltZXIsIGhydCk7CiAJc3RydWN0IHNuZF90aW1lciAqdCA9IHN0aW1lLT50aW1lcjsKKwl1bnNpZ25lZCBsb25nIG9ydW5zOwogCiAJaWYgKCFhdG9taWNfcmVhZCgmc3RpbWUtPnJ1bm5pbmcpKQogCQlyZXR1cm4gSFJUSU1FUl9OT1JFU1RBUlQ7CiAKLQlocnRpbWVyX2ZvcndhcmRfbm93KGhydCwgbnNfdG9fa3RpbWUodC0+c3RpY2tzICogcmVzb2x1dGlvbikpOwotCXNuZF90aW1lcl9pbnRlcnJ1cHQoc3RpbWUtPnRpbWVyLCB0LT5zdGlja3MpOworCW9ydW5zID0gaHJ0aW1lcl9mb3J3YXJkX25vdyhocnQsIG5zX3RvX2t0aW1lKHQtPnN0aWNrcyAqIHJlc29sdXRpb24pKTsKKwlzbmRfdGltZXJfaW50ZXJydXB0KHN0aW1lLT50aW1lciwgdC0+c3RpY2tzICogb3J1bnMpOwogCiAJaWYgKCFhdG9taWNfcmVhZCgmc3RpbWUtPnJ1bm5pbmcpKQogCQlyZXR1cm4gSFJUSU1FUl9OT1JFU1RBUlQ7CkBAIC0xMDQsNyArMTA1LDcgQEAKIH0KIAogc3RhdGljIHN0cnVjdCBzbmRfdGltZXJfaGFyZHdhcmUgaHJ0aW1lcl9odyA9IHsKLQkuZmxhZ3MgPQlTTkRSVl9USU1FUl9IV19BVVRPLAorCS5mbGFncyA9CVNORFJWX1RJTUVSX0hXX0FVVE8gfCBTTkRSVl9USU1FUl9IV19UQVNLTEVULAogCS5vcGVuID0JCXNuZF9ocnRpbWVyX29wZW4sCiAJLmNsb3NlID0Jc25kX2hydGltZXJfY2xvc2UsCiAJLnN0YXJ0ID0Jc25kX2hydGltZXJfc3RhcnQsCmRpZmYgLS1naXQgYS9zb3VuZC9kcml2ZXJzL210cGF2LmMgYi9zb3VuZC9kcml2ZXJzL210cGF2LmMKaW5kZXggZGEwMzU5Ny4uNWM0MjZkZiAxMDA2NDQKLS0tIGEvc291bmQvZHJpdmVycy9tdHBhdi5jCisrKyBiL3NvdW5kL2RyaXZlcnMvbXRwYXYuYwpAQCAtNTUsMTQgKzU1LDEzIEBACiAjaW5jbHVkZSA8bGludXgvZXJyLmg+CiAjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvaW9wb3J0Lmg+CisjaW5jbHVkZSA8bGludXgvaW8uaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGVwYXJhbS5oPgogI2luY2x1ZGUgPHNvdW5kL2NvcmUuaD4KICNpbmNsdWRlIDxzb3VuZC9pbml0dmFsLmg+CiAjaW5jbHVkZSA8c291bmQvcmF3bWlkaS5oPgogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiAKLSNpbmNsdWRlIDxhc20vaW8uaD4KLQogLyoKICAqICAgICAgZ2xvYmFscwogICovCmRpZmYgLS1naXQgYS9zb3VuZC9vc3MvTWFrZWZpbGUgYi9zb3VuZC9vc3MvTWFrZWZpbGUKaW5kZXggOTZmMTRkYy4uOTBmZmI5OSAxMDA2NDQKLS0tIGEvc291bmQvb3NzL01ha2VmaWxlCisrKyBiL3NvdW5kL29zcy9NYWtlZmlsZQpAQCAtODcsNyArODcsNyBAQAogCSQob2JqKS9iaW4yaGV4IHBzc19zeW50aCA8ICQ8ID4gJEAKIGVsc2UKICAgICAkKG9iaikvcHNzX2Jvb3QuaDoKLQkoCQkJCQkJCVwKKwkkKFEpKAkJCQkJCQlcCiAJICAgIGVjaG8gJ3N0YXRpYyB1bnNpZ25lZCBjaGFyICogcHNzX3N5bnRoID0gTlVMTDsnOwlcCiAJICAgIGVjaG8gJ3N0YXRpYyBpbnQgcHNzX3N5bnRoTGVuID0gMDsnOwkJXAogCSkgPiAkQApAQCAtMTAyLDcgKzEwMiw3IEBACiAJJChvYmopL2hleDJoZXggLWkgdHJpeF9ib290IDwgJDwgPiAkQAogZWxzZQogICAgICQob2JqKS90cml4X2Jvb3QuaDoKLQkoCQkJCQkJCVwKKwkkKFEpKAkJCQkJCQlcCiAJICAgIGVjaG8gJ3N0YXRpYyB1bnNpZ25lZCBjaGFyICogdHJpeF9ib290ID0gTlVMTDsnOwlcCiAJICAgIGVjaG8gJ3N0YXRpYyBpbnQgdHJpeF9ib290X2xlbiA9IDA7JzsJCVwKIAkpID4gJEAKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9hYzk3L2FjOTdfY29kZWMuYyBiL3NvdW5kL3BjaS9hYzk3L2FjOTdfY29kZWMuYwppbmRleCAwZmM2MTRjLi5jYjYyZDE3IDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvYWM5Ny9hYzk3X2NvZGVjLmMKKysrIGIvc291bmQvcGNpL2FjOTcvYWM5N19jb2RlYy5jCkBAIC0xOTYxLDcgKzE5NjEsNyBAQAogfQogCiAvKiBidWlsZF9vcHMgdG8gZG8gbm90aGluZyAqLwotc3RhdGljIHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgbnVsbF9idWlsZF9vcHM7CitzdGF0aWMgY29uc3Qgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBudWxsX2J1aWxkX29wczsKIAogI2lmZGVmIENPTkZJR19TTkRfQUM5N19QT1dFUl9TQVZFCiBzdGF0aWMgdm9pZCBkb191cGRhdGVfcG93ZXIoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2FjOTcvYWM5N19wYXRjaC5jIGIvc291bmQvcGNpL2FjOTcvYWM5N19wYXRjaC5jCmluZGV4IGU2OGM5OGUuLmJmNDc1NzQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9hYzk3L2FjOTdfcGF0Y2guYworKysgYi9zb3VuZC9wY2kvYWM5Ny9hYzk3X3BhdGNoLmMKQEAgLTM3MSw3ICszNzEsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF95YW1haGFfeW1mNzQzX29wcyA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX3lhbWFoYV95bWY3NDNfb3BzID0gewogCS5idWlsZF9zcGRpZgk9IHBhdGNoX3lhbWFoYV95bWY3NDNfYnVpbGRfc3BkaWYsCiAJLmJ1aWxkXzNkCT0gcGF0Y2hfeWFtYWhhX3ltZjd4M18zZCwKIH07CkBAIC00NTUsNyArNDU1LDcgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfeWFtYWhhX3ltZjc1M19vcHMgPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF95YW1haGFfeW1mNzUzX29wcyA9IHsKIAkuYnVpbGRfM2QJPSBwYXRjaF95YW1haGFfeW1mN3gzXzNkLAogCS5idWlsZF9wb3N0X3NwZGlmID0gcGF0Y2hfeWFtYWhhX3ltZjc1M19wb3N0X3NwZGlmCiB9OwpAQCAtNTAyLDcgKzUwMiw3IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX3dvbGZzb25fd205NzAzX29wcyA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX3dvbGZzb25fd205NzAzX29wcyA9IHsKIAkuYnVpbGRfc3BlY2lmaWMgPSBwYXRjaF93b2xmc29uX3dtOTcwM19zcGVjaWZpYywKIH07CiAKQEAgLTUzMyw3ICs1MzMsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF93b2xmc29uX3dtOTcwNF9vcHMgPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF93b2xmc29uX3dtOTcwNF9vcHMgPSB7CiAJLmJ1aWxkX3NwZWNpZmljID0gcGF0Y2hfd29sZnNvbl93bTk3MDRfc3BlY2lmaWMsCiB9OwogCkBAIC02NzcsNyArNjc3LDcgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfd29sZnNvbl93bTk3MTFfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfd29sZnNvbl93bTk3MTFfb3BzID0gewogCS5idWlsZF9zcGVjaWZpYyA9IHBhdGNoX3dvbGZzb25fd205NzExX3NwZWNpZmljLAogfTsKIApAQCAtODcxLDcgKzg3MSw3IEBACiB9CiAjZW5kaWYKIAotc3RhdGljIHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfd29sZnNvbl93bTk3MTNfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfd29sZnNvbl93bTk3MTNfb3BzID0gewogCS5idWlsZF9zcGVjaWZpYyA9IHBhdGNoX3dvbGZzb25fd205NzEzX3NwZWNpZmljLAogCS5idWlsZF8zZCA9IHBhdGNoX3dvbGZzb25fd205NzEzXzNkLAogI2lmZGVmIENPTkZJR19QTQkKQEAgLTk3Niw3ICs5NzYsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9zaWdtYXRlbF9zdGFjOTcwMF9vcHMgPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9zaWdtYXRlbF9zdGFjOTcwMF9vcHMgPSB7CiAJLmJ1aWxkXzNkCT0gcGF0Y2hfc2lnbWF0ZWxfc3RhYzk3MDBfM2QsCiAJLmJ1aWxkX3NwZWNpZmljCT0gcGF0Y2hfc2lnbWF0ZWxfc3RhYzk3eHhfc3BlY2lmaWMKIH07CkBAIC0xMDIzLDcgKzEwMjMsNyBAQAogCXJldHVybiBwYXRjaF9zaWdtYXRlbF9zdGFjOTd4eF9zcGVjaWZpYyhhYzk3KTsKIH0KIAotc3RhdGljIHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfc2lnbWF0ZWxfc3RhYzk3MDhfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfc2lnbWF0ZWxfc3RhYzk3MDhfb3BzID0gewogCS5idWlsZF8zZAk9IHBhdGNoX3NpZ21hdGVsX3N0YWM5NzA4XzNkLAogCS5idWlsZF9zcGVjaWZpYwk9IHBhdGNoX3NpZ21hdGVsX3N0YWM5NzA4X3NwZWNpZmljCiB9OwpAQCAtMTI1Miw3ICsxMjUyLDcgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfc2lnbWF0ZWxfc3RhYzk3NThfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfc2lnbWF0ZWxfc3RhYzk3NThfb3BzID0gewogCS5idWlsZF8zZAk9IHBhdGNoX3NpZ21hdGVsX3N0YWM5NzAwXzNkLAogCS5idWlsZF9zcGVjaWZpYwk9IHBhdGNoX3NpZ21hdGVsX3N0YWM5NzU4X3NwZWNpZmljCiB9OwpAQCAtMTMyNyw3ICsxMzI3LDcgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfY2lycnVzX29wcyA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX2NpcnJ1c19vcHMgPSB7CiAJLmJ1aWxkX3NwZGlmID0gcGF0Y2hfY2lycnVzX2J1aWxkX3NwZGlmCiB9OwogCkBAIC0xMzg0LDcgKzEzODQsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9jb25leGFudF9vcHMgPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9jb25leGFudF9vcHMgPSB7CiAJLmJ1aWxkX3NwZGlmID0gcGF0Y2hfY29uZXhhbnRfYnVpbGRfc3BkaWYKIH07CiAKQEAgLTE1NjAsNyArMTU2MCw3IEBACiAJfQogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9hZDE4ODFfYnVpbGRfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfYWQxODgxX2J1aWxkX29wcyA9IHsKICNpZmRlZiBDT05GSUdfUE0KIAkucmVzdW1lID0gYWQxOHh4X3Jlc3VtZQogI2VuZGlmCkBAIC0xNjQ3LDcgKzE2NDcsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9hZDE4ODVfYnVpbGRfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfYWQxODg1X2J1aWxkX29wcyA9IHsKIAkuYnVpbGRfc3BlY2lmaWMgPSAmcGF0Y2hfYWQxODg1X3NwZWNpZmljLAogI2lmZGVmIENPTkZJR19QTQogCS5yZXN1bWUgPSBhZDE4eHhfcmVzdW1lCkBAIC0xNjc0LDcgKzE2NzQsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9hZDE4ODZfYnVpbGRfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfYWQxODg2X2J1aWxkX29wcyA9IHsKIAkuYnVpbGRfc3BlY2lmaWMgPSAmcGF0Y2hfYWQxODg2X3NwZWNpZmljLAogI2lmZGVmIENPTkZJR19QTQogCS5yZXN1bWUgPSBhZDE4eHhfcmVzdW1lCkBAIC0xODgxLDcgKzE4ODEsNyBAQAogCQkJCSAgICBBUlJBWV9TSVpFKHNuZF9hYzk3X2FkMTk4MXhfamFja19zZW5zZSkpOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9hZDE5ODFhX2J1aWxkX29wcyA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX2FkMTk4MWFfYnVpbGRfb3BzID0gewogCS5idWlsZF9wb3N0X3NwZGlmID0gcGF0Y2hfYWQxOTh4X3Bvc3Rfc3BkaWYsCiAJLmJ1aWxkX3NwZWNpZmljID0gcGF0Y2hfYWQxOTgxYV9zcGVjaWZpYywKICNpZmRlZiBDT05GSUdfUE0KQEAgLTE5MzYsNyArMTkzNiw3IEBACiAJCQkJICAgIEFSUkFZX1NJWkUoc25kX2FjOTdfYWQxOTgxeF9qYWNrX3NlbnNlKSk7CiB9CiAKLXN0YXRpYyBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX2FkMTk4MWJfYnVpbGRfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfYWQxOTgxYl9idWlsZF9vcHMgPSB7CiAJLmJ1aWxkX3Bvc3Rfc3BkaWYgPSBwYXRjaF9hZDE5OHhfcG9zdF9zcGRpZiwKIAkuYnVpbGRfc3BlY2lmaWMgPSBwYXRjaF9hZDE5ODFiX3NwZWNpZmljLAogI2lmZGVmIENPTkZJR19QTQpAQCAtMjA3NSw3ICsyMDc1LDcgQEAKIAlyZXR1cm4gcGF0Y2hfYnVpbGRfY29udHJvbHMoYWM5Nywgc25kX2FjOTdfYWQxODg4X2NvbnRyb2xzLCBBUlJBWV9TSVpFKHNuZF9hYzk3X2FkMTg4OF9jb250cm9scykpOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9hZDE4ODhfYnVpbGRfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfYWQxODg4X2J1aWxkX29wcyA9IHsKIAkuYnVpbGRfcG9zdF9zcGRpZiA9IHBhdGNoX2FkMTk4eF9wb3N0X3NwZGlmLAogCS5idWlsZF9zcGVjaWZpYyA9IHBhdGNoX2FkMTg4OF9zcGVjaWZpYywKICNpZmRlZiBDT05GSUdfUE0KQEAgLTIxMjQsNyArMjEyNCw3IEBACiAJcmV0dXJuIHBhdGNoX2J1aWxkX2NvbnRyb2xzKGFjOTcsICZzbmRfYWM5N19hZDE5OHhfMmNtaWMsIDEpOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9hZDE5ODBfYnVpbGRfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfYWQxOTgwX2J1aWxkX29wcyA9IHsKIAkuYnVpbGRfcG9zdF9zcGRpZiA9IHBhdGNoX2FkMTk4eF9wb3N0X3NwZGlmLAogCS5idWlsZF9zcGVjaWZpYyA9IHBhdGNoX2FkMTk4MF9zcGVjaWZpYywKICNpZmRlZiBDT05GSUdfUE0KQEAgLTIyMzksNyArMjIzOSw3IEBACiAJCQkJICAgIEFSUkFZX1NJWkUoc25kX2FjOTdfYWQxOTg1X2NvbnRyb2xzKSk7CiB9CiAKLXN0YXRpYyBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX2FkMTk4NV9idWlsZF9vcHMgPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9hZDE5ODVfYnVpbGRfb3BzID0gewogCS5idWlsZF9wb3N0X3NwZGlmID0gcGF0Y2hfYWQxOTh4X3Bvc3Rfc3BkaWYsCiAJLmJ1aWxkX3NwZWNpZmljID0gcGF0Y2hfYWQxOTg1X3NwZWNpZmljLAogI2lmZGVmIENPTkZJR19QTQpAQCAtMjUzMSw3ICsyNTMxLDcgQEAKIAkJCQkgICAgQVJSQVlfU0laRShzbmRfYWM5N19hZDE5ODVfY29udHJvbHMpKTsKIH0KIAotc3RhdGljIHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfYWQxOTg2X2J1aWxkX29wcyA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX2FkMTk4Nl9idWlsZF9vcHMgPSB7CiAJLmJ1aWxkX3Bvc3Rfc3BkaWYgPSBwYXRjaF9hZDE5OHhfcG9zdF9zcGRpZiwKIAkuYnVpbGRfc3BlY2lmaWMgPSBwYXRjaF9hZDE5ODZfc3BlY2lmaWMsCiAjaWZkZWYgQ09ORklHX1BNCkBAIC0yNjM2LDcgKzI2MzYsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9hbGM2NTBfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfYWxjNjUwX29wcyA9IHsKIAkuYnVpbGRfc3BlY2lmaWMJPSBwYXRjaF9hbGM2NTBfc3BlY2lmaWMsCiAJLnVwZGF0ZV9qYWNrcyA9IGFsYzY1MF91cGRhdGVfamFja3MKIH07CkBAIC0yNzg4LDcgKzI3ODgsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9hbGM2NTVfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfYWxjNjU1X29wcyA9IHsKIAkuYnVpbGRfc3BlY2lmaWMJPSBwYXRjaF9hbGM2NTVfc3BlY2lmaWMsCiAJLnVwZGF0ZV9qYWNrcyA9IGFsYzY1NV91cGRhdGVfamFja3MKIH07CkBAIC0yOTAwLDcgKzI5MDAsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9hbGM4NTBfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfYWxjODUwX29wcyA9IHsKIAkuYnVpbGRfc3BlY2lmaWMJPSBwYXRjaF9hbGM4NTBfc3BlY2lmaWMsCiAJLnVwZGF0ZV9qYWNrcyA9IGFsYzg1MF91cGRhdGVfamFja3MKIH07CkBAIC0yOTYyLDcgKzI5NjIsNyBAQAogCXJldHVybiBwYXRjaF9idWlsZF9jb250cm9scyhhYzk3LCBzbmRfYWM5N19jbTk3MzhfY29udHJvbHMsIEFSUkFZX1NJWkUoc25kX2FjOTdfY205NzM4X2NvbnRyb2xzKSk7CiB9CiAKLXN0YXRpYyBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX2NtOTczOF9vcHMgPSB7CitzdGF0aWMgY29uc3Qgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9jbTk3Mzhfb3BzID0gewogCS5idWlsZF9zcGVjaWZpYwk9IHBhdGNoX2NtOTczOF9zcGVjaWZpYywKIAkudXBkYXRlX2phY2tzID0gY205NzM4X3VwZGF0ZV9qYWNrcwogfTsKQEAgLTMwNTMsNyArMzA1Myw3IEBACiAJcmV0dXJuIHBhdGNoX2J1aWxkX2NvbnRyb2xzKGFjOTcsIHNuZF9hYzk3X2NtOTczOV9jb250cm9sc19zcGRpZiwgQVJSQVlfU0laRShzbmRfYWM5N19jbTk3MzlfY29udHJvbHNfc3BkaWYpKTsKIH0KIAotc3RhdGljIHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfY205NzM5X29wcyA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX2NtOTczOV9vcHMgPSB7CiAJLmJ1aWxkX3NwZWNpZmljCT0gcGF0Y2hfY205NzM5X3NwZWNpZmljLAogCS5idWlsZF9wb3N0X3NwZGlmID0gcGF0Y2hfY205NzM5X3Bvc3Rfc3BkaWYsCiAJLnVwZGF0ZV9qYWNrcyA9IGNtOTczOV91cGRhdGVfamFja3MKQEAgLTMyMjcsNyArMzIyNyw3IEBACiAJcmV0dXJuIHBhdGNoX2J1aWxkX2NvbnRyb2xzKGFjOTcsIHNuZF9hYzk3X2NtOTc2MV9jb250cm9scywgQVJSQVlfU0laRShzbmRfYWM5N19jbTk3NjFfY29udHJvbHMpKTsKIH0KIAotc3RhdGljIHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfY205NzYxX29wcyA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX2NtOTc2MV9vcHMgPSB7CiAJLmJ1aWxkX3NwZWNpZmljCT0gcGF0Y2hfY205NzYxX3NwZWNpZmljLAogCS5idWlsZF9wb3N0X3NwZGlmID0gcGF0Y2hfY205NzYxX3Bvc3Rfc3BkaWYsCiAJLnVwZGF0ZV9qYWNrcyA9IGNtOTc2MV91cGRhdGVfamFja3MKQEAgLTMzMjMsNyArMzMyMyw3IEBACiAJcmV0dXJuIHBhdGNoX2J1aWxkX2NvbnRyb2xzKGFjOTcsIGNtOTc4MF9jb250cm9scywgQVJSQVlfU0laRShjbTk3ODBfY29udHJvbHMpKTsKIH0KIAotc3RhdGljIHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfY205NzgwX29wcyA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX2NtOTc4MF9vcHMgPSB7CiAJLmJ1aWxkX3NwZWNpZmljCT0gcGF0Y2hfY205NzgwX3NwZWNpZmljLAogCS5idWlsZF9wb3N0X3NwZGlmID0gcGF0Y2hfY205NzYxX3Bvc3Rfc3BkaWYJLyogaWRlbnRpY2FsIHdpdGggQ005NzYxICovCiB9OwpAQCAtMzQ0Myw3ICszNDQzLDcgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfdnQxNjE2X29wcyA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX3Z0MTYxNl9vcHMgPSB7CiAJLmJ1aWxkX3NwZWNpZmljCT0gcGF0Y2hfdnQxNjE2X3NwZWNpZmljCiB9OwogCkBAIC0zNzk3LDcgKzM3OTcsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9pdDI2NDZfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfaXQyNjQ2X29wcyA9IHsKIAkuYnVpbGRfc3BlY2lmaWMJPSBwYXRjaF9pdDI2NDZfc3BlY2lmaWMsCiAJLnVwZGF0ZV9qYWNrcyA9IGl0MjY0Nl91cGRhdGVfamFja3MKIH07CkBAIC0zODMxLDcgKzM4MzEsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF9zaTMwMzZfb3BzID0geworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfYWM5N19idWlsZF9vcHMgcGF0Y2hfc2kzMDM2X29wcyA9IHsKIAkuYnVpbGRfc3BlY2lmaWMJPSBwYXRjaF9zaTMwMzZfc3BlY2lmaWMsCiB9OwogCkBAIC0zODk4LDcgKzM4OTgsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IHNuZF9hYzk3X2J1aWxkX29wcyBwYXRjaF91Y2IxNDAwX29wcyA9IHsKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX2FjOTdfYnVpbGRfb3BzIHBhdGNoX3VjYjE0MDBfb3BzID0gewogCS5idWlsZF9zcGVjaWZpYwk9IHBhdGNoX3VjYjE0MDBfc3BlY2lmaWMsCiB9OwogCmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvYXU4OHgwL2F1ODh4MF9wY20uYyBiL3NvdW5kL3BjaS9hdTg4eDAvYXU4OHgwX3BjbS5jCmluZGV4IGI5ZDJmMjAuLjU0MzlkNjYgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9hdTg4eDAvYXU4OHgwX3BjbS5jCisrKyBiL3NvdW5kL3BjaS9hdTg4eDAvYXU4OHgwX3BjbS5jCkBAIC00MiwxMSArNDIsNyBAQAogCS5yYXRlX21pbiA9IDUwMDAsCiAJLnJhdGVfbWF4ID0gNDgwMDAsCiAJLmNoYW5uZWxzX21pbiA9IDEsCi0jaWZkZWYgQ0hJUF9BVTg4MzAKLQkuY2hhbm5lbHNfbWF4ID0gNCwKLSNlbHNlCiAJLmNoYW5uZWxzX21heCA9IDIsCi0jZW5kaWYKIAkuYnVmZmVyX2J5dGVzX21heCA9IDB4MTAwMDAsCiAJLnBlcmlvZF9ieXRlc19taW4gPSAweDEsCiAJLnBlcmlvZF9ieXRlc19tYXggPSAweDEwMDAsCkBAIC0xMTUsNiArMTExLDE3IEBACiAJLnBlcmlvZHNfbWF4ID0gNjQsCiB9OwogI2VuZGlmCisjaWZkZWYgQ0hJUF9BVTg4MzAKK3N0YXRpYyB1bnNpZ25lZCBpbnQgYXU4ODMwX2NoYW5uZWxzWzNdID0geworCTEsIDIsIDQsCit9OworCitzdGF0aWMgc3RydWN0IHNuZF9wY21faHdfY29uc3RyYWludF9saXN0IGh3X2NvbnN0cmFpbnRzX2F1ODgzMF9jaGFubmVscyA9IHsKKwkuY291bnQgPSBBUlJBWV9TSVpFKGF1ODgzMF9jaGFubmVscyksCisJLmxpc3QgPSBhdTg4MzBfY2hhbm5lbHMsCisJLm1hc2sgPSAwLAorfTsKKyNlbmRpZgogLyogb3BlbiBjYWxsYmFjayAqLwogc3RhdGljIGludCBzbmRfdm9ydGV4X3BjbV9vcGVuKHN0cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAqc3Vic3RyZWFtKQogewpAQCAtMTU2LDYgKzE2MywxNSBAQAogCQlpZiAoVk9SVEVYX1BDTV9UWVBFKHN1YnN0cmVhbS0+cGNtKSA9PSBWT1JURVhfUENNX0FEQgogCQkgICAgfHwgVk9SVEVYX1BDTV9UWVBFKHN1YnN0cmVhbS0+cGNtKSA9PSBWT1JURVhfUENNX0kyUykKIAkJCXJ1bnRpbWUtPmh3ID0gc25kX3ZvcnRleF9wbGF5YmFja19od19hZGI7CisjaWZkZWYgQ0hJUF9BVTg4MzAKKwkJaWYgKHN1YnN0cmVhbS0+c3RyZWFtID09IFNORFJWX1BDTV9TVFJFQU1fUExBWUJBQ0sgJiYKKwkJCVZPUlRFWF9QQ01fVFlQRShzdWJzdHJlYW0tPnBjbSkgPT0gVk9SVEVYX1BDTV9BREIpIHsKKwkJCXJ1bnRpbWUtPmh3LmNoYW5uZWxzX21heCA9IDQ7CisJCQlzbmRfcGNtX2h3X2NvbnN0cmFpbnRfbGlzdChydW50aW1lLCAwLAorCQkJCVNORFJWX1BDTV9IV19QQVJBTV9DSEFOTkVMUywKKwkJCQkmaHdfY29uc3RyYWludHNfYXU4ODMwX2NoYW5uZWxzKTsKKwkJfQorI2VuZGlmCiAJCXN1YnN0cmVhbS0+cnVudGltZS0+cHJpdmF0ZV9kYXRhID0gTlVMTDsKIAl9CiAjaWZuZGVmIENISVBfQVU4ODEwCmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvYXp0MzMyOC5jIGIvc291bmQvcGNpL2F6dDMzMjguYwppbmRleCA2MTE3NTk1Li41NzM1OTRiIDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvYXp0MzMyOC5jCisrKyBiL3NvdW5kL3BjaS9henQzMzI4LmMKQEAgLTk3OSwzMSArOTc5LDI1IEBACiAKIAlzbmRfYXpmMzMyOF9kYmdjYWxsZW50ZXIoKTsKIAlzd2l0Y2ggKGJpdHJhdGUpIHsKLSNkZWZpbmUgQVpGX0ZNVF9YTEFURShpbl9mcmVxLCBvdXRfYml0cykgXAotCWRvIHsgXAotCQljYXNlIEFaRl9GUkVRXyAjIyBpbl9mcmVxOiBcCi0JCQlmcmVxID0gU09VTkRGT1JNQVRfRlJFUV8gIyMgb3V0X2JpdHM7IFwKLQkJCWJyZWFrOyBcCi0JfSB3aGlsZSAoMCk7Ci0JQVpGX0ZNVF9YTEFURSg0MDAwLCBTVVNQRUNURURfNDAwMCkKLQlBWkZfRk1UX1hMQVRFKDQ4MDAsIFNVU1BFQ1RFRF80ODAwKQotCS8qIHRoZSBBWkYzMzI4IG5hbWVzIGl0ICI1NTEwIiBmb3Igc29tZSBzdHJhbmdlIHJlYXNvbjogKi8KLQlBWkZfRk1UX1hMQVRFKDU1MTIsIDU1MTApCi0JQVpGX0ZNVF9YTEFURSg2NjIwLCA2NjIwKQotCUFaRl9GTVRfWExBVEUoODAwMCwgODAwMCkKLQlBWkZfRk1UX1hMQVRFKDk2MDAsIDk2MDApCi0JQVpGX0ZNVF9YTEFURSgxMTAyNSwgMTEwMjUpCi0JQVpGX0ZNVF9YTEFURSgxMzI0MCwgU1VTUEVDVEVEXzEzMjQwKQotCUFaRl9GTVRfWExBVEUoMTYwMDAsIDE2MDAwKQotCUFaRl9GTVRfWExBVEUoMjIwNTAsIDIyMDUwKQotCUFaRl9GTVRfWExBVEUoMzIwMDAsIDMyMDAwKQorCWNhc2UgQVpGX0ZSRVFfNDAwMDogIGZyZXEgPSBTT1VOREZPUk1BVF9GUkVRX1NVU1BFQ1RFRF80MDAwOyBicmVhazsKKwljYXNlIEFaRl9GUkVRXzQ4MDA6ICBmcmVxID0gU09VTkRGT1JNQVRfRlJFUV9TVVNQRUNURURfNDgwMDsgYnJlYWs7CisJY2FzZSBBWkZfRlJFUV81NTEyOgorCQkvKiB0aGUgQVpGMzMyOCBuYW1lcyBpdCAiNTUxMCIgZm9yIHNvbWUgc3RyYW5nZSByZWFzb24gKi8KKwkJCSAgICAgZnJlcSA9IFNPVU5ERk9STUFUX0ZSRVFfNTUxMDsgYnJlYWs7CisJY2FzZSBBWkZfRlJFUV82NjIwOiAgZnJlcSA9IFNPVU5ERk9STUFUX0ZSRVFfNjYyMDsgYnJlYWs7CisJY2FzZSBBWkZfRlJFUV84MDAwOiAgZnJlcSA9IFNPVU5ERk9STUFUX0ZSRVFfODAwMDsgYnJlYWs7CisJY2FzZSBBWkZfRlJFUV85NjAwOiAgZnJlcSA9IFNPVU5ERk9STUFUX0ZSRVFfOTYwMDsgYnJlYWs7CisJY2FzZSBBWkZfRlJFUV8xMTAyNTogZnJlcSA9IFNPVU5ERk9STUFUX0ZSRVFfMTEwMjU7IGJyZWFrOworCWNhc2UgQVpGX0ZSRVFfMTMyNDA6IGZyZXEgPSBTT1VOREZPUk1BVF9GUkVRX1NVU1BFQ1RFRF8xMzI0MDsgYnJlYWs7CisJY2FzZSBBWkZfRlJFUV8xNjAwMDogZnJlcSA9IFNPVU5ERk9STUFUX0ZSRVFfMTYwMDA7IGJyZWFrOworCWNhc2UgQVpGX0ZSRVFfMjIwNTA6IGZyZXEgPSBTT1VOREZPUk1BVF9GUkVRXzIyMDUwOyBicmVhazsKKwljYXNlIEFaRl9GUkVRXzMyMDAwOiBmcmVxID0gU09VTkRGT1JNQVRfRlJFUV8zMjAwMDsgYnJlYWs7CiAJZGVmYXVsdDoKIAkJc25kX3ByaW50ayhLRVJOX1dBUk5JTkcgInVua25vd24gYml0cmF0ZSAlZCwgYXNzdW1pbmcgNDQuMWtIeiFcbiIsIGJpdHJhdGUpOwogCQkvKiBmYWxsLXRocm91Z2ggKi8KLQlBWkZfRk1UX1hMQVRFKDQ0MTAwLCA0NDEwMCkKLQlBWkZfRk1UX1hMQVRFKDQ4MDAwLCA0ODAwMCkKLQlBWkZfRk1UX1hMQVRFKDY2MjAwLCBTVVNQRUNURURfNjYyMDApCi0jdW5kZWYgQVpGX0ZNVF9YTEFURQorCWNhc2UgQVpGX0ZSRVFfNDQxMDA6IGZyZXEgPSBTT1VOREZPUk1BVF9GUkVRXzQ0MTAwOyBicmVhazsKKwljYXNlIEFaRl9GUkVRXzQ4MDAwOiBmcmVxID0gU09VTkRGT1JNQVRfRlJFUV80ODAwMDsgYnJlYWs7CisJY2FzZSBBWkZfRlJFUV82NjIwMDogZnJlcSA9IFNPVU5ERk9STUFUX0ZSRVFfU1VTUEVDVEVEXzY2MjAwOyBicmVhazsKIAl9CiAJLyogdmFsID0gMHhmZjA3OyAzbTI3Ljk5M3MgKDY1MzAxSHo7IC0+IDY0MDAwSHo/Pz8pIGhtbSwgNjYxMjAsIDY1OTY3LCA2NjEyMyAqLwogCS8qIHZhbCA9IDB4ZmYwOTsgMTdtMTUuMDk4cyAoMTMxMjMsNDc4SHo7IC0+IDEyMDAwSHo/Pz8pIGhtbSwgMTMyMzcuMkh6PyAqLwpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2NzNTUzNWF1ZGlvL2NzNTUzNWF1ZGlvX3BtLmMgYi9zb3VuZC9wY2kvY3M1NTM1YXVkaW8vY3M1NTM1YXVkaW9fcG0uYwppbmRleCBhMzMwMWNjLi4xODViMDAwIDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvY3M1NTM1YXVkaW8vY3M1NTM1YXVkaW9fcG0uYworKysgYi9zb3VuZC9wY2kvY3M1NTM1YXVkaW8vY3M1NTM1YXVkaW9fcG0uYwpAQCAtOTAsMTIgKzkwLDcgQEAKIAlpbnQgaTsKIAogCXBjaV9zZXRfcG93ZXJfc3RhdGUocGNpLCBQQ0lfRDApOwotCWlmIChwY2lfcmVzdG9yZV9zdGF0ZShwY2kpIDwgMCkgewotCQlwcmludGsoS0VSTl9FUlIgImNzNTUzNWF1ZGlvOiBwY2lfcmVzdG9yZV9zdGF0ZSBmYWlsZWQsICIKLQkJICAgICAgICJkaXNhYmxpbmcgZGV2aWNlXG4iKTsKLQkJc25kX2NhcmRfZGlzY29ubmVjdChjYXJkKTsKLQkJcmV0dXJuIC1FSU87Ci0JfQorCXBjaV9yZXN0b3JlX3N0YXRlKHBjaSk7CiAJaWYgKHBjaV9lbmFibGVfZGV2aWNlKHBjaSkgPCAwKSB7CiAJCXByaW50ayhLRVJOX0VSUiAiY3M1NTM1YXVkaW86IHBjaV9lbmFibGVfZGV2aWNlIGZhaWxlZCwgIgogCQkgICAgICAgImRpc2FibGluZyBkZXZpY2VcbiIpOwpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2hkYS9oZGFfY29kZWMuYyBiL3NvdW5kL3BjaS9oZGEvaGRhX2NvZGVjLmMKaW5kZXggMDVlNWVjOC4uYWU1YzVkNWUgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9oZGEvaGRhX2NvZGVjLmMKKysrIGIvc291bmQvcGNpL2hkYS9oZGFfY29kZWMuYwpAQCAtMjEzNCwxMCArMjEzNCwxMCBAQAogICogVGhpcyBmdW5jdGlvbiByZXR1cm5zIHplcm8gaWYgc3VjY2Vzc2Z1bCBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUuCiAgKi8KIGludCBzbmRfaGRhX2FkZF92bWFzdGVyKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLCBjaGFyICpuYW1lLAotCQkJdW5zaWduZWQgaW50ICp0bHYsIGNvbnN0IGNoYXIgKipzbGF2ZXMpCisJCQl1bnNpZ25lZCBpbnQgKnRsdiwgY29uc3QgY2hhciAqIGNvbnN0ICpzbGF2ZXMpCiB7CiAJc3RydWN0IHNuZF9rY29udHJvbCAqa2N0bDsKLQljb25zdCBjaGFyICoqczsKKwljb25zdCBjaGFyICogY29uc3QgKnM7CiAJaW50IGVycjsKIAogCWZvciAocyA9IHNsYXZlczsgKnMgJiYgIXNuZF9oZGFfZmluZF9taXhlcl9jdGwoY29kZWMsICpzKTsgcysrKQpAQCAtMzY4OSw3ICszNjg5LDcgQEAKICAqIElmIG5vIGVudHJpZXMgYXJlIG1hdGNoaW5nLCB0aGUgZnVuY3Rpb24gcmV0dXJucyBhIG5lZ2F0aXZlIHZhbHVlLgogICovCiBpbnQgc25kX2hkYV9jaGVja19ib2FyZF9jb25maWcoc3RydWN0IGhkYV9jb2RlYyAqY29kZWMsCi0JCQkgICAgICAgaW50IG51bV9jb25maWdzLCBjb25zdCBjaGFyICoqbW9kZWxzLAorCQkJICAgICAgIGludCBudW1fY29uZmlncywgY29uc3QgY2hhciAqIGNvbnN0ICptb2RlbHMsCiAJCQkgICAgICAgY29uc3Qgc3RydWN0IHNuZF9wY2lfcXVpcmsgKnRibCkKIHsKIAlpZiAoY29kZWMtPm1vZGVsbmFtZSAmJiBtb2RlbHMpIHsKQEAgLTM3NTMsNyArMzc1Myw3IEBACiAgKiBJZiBubyBlbnRyaWVzIGFyZSBtYXRjaGluZywgdGhlIGZ1bmN0aW9uIHJldHVybnMgYSBuZWdhdGl2ZSB2YWx1ZS4KICAqLwogaW50IHNuZF9oZGFfY2hlY2tfYm9hcmRfY29kZWNfc2lkX2NvbmZpZyhzdHJ1Y3QgaGRhX2NvZGVjICpjb2RlYywKLQkJCSAgICAgICBpbnQgbnVtX2NvbmZpZ3MsIGNvbnN0IGNoYXIgKiptb2RlbHMsCisJCQkgICAgICAgaW50IG51bV9jb25maWdzLCBjb25zdCBjaGFyICogY29uc3QgKm1vZGVscywKIAkJCSAgICAgICBjb25zdCBzdHJ1Y3Qgc25kX3BjaV9xdWlyayAqdGJsKQogewogCWNvbnN0IHN0cnVjdCBzbmRfcGNpX3F1aXJrICpxOwpAQCAtNDY5MCw3ICs0NjkwLDcgQEAKIAkJCQkJaW50IGNoZWNrX2xvY2F0aW9uKQogewogCXVuc2lnbmVkIGludCBkZWZfY29uZjsKLQlzdGF0aWMgY29uc3QgY2hhciAqbWljX25hbWVzW10gPSB7CisJc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBtaWNfbmFtZXNbXSA9IHsKIAkJIkludGVybmFsIE1pYyIsICJEb2NrIE1pYyIsICJNaWMiLCAiRnJvbnQgTWljIiwgIlJlYXIgTWljIiwKIAl9OwogCWludCBhdHRyOwpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2hkYS9oZGFfZWxkLmMgYi9zb3VuZC9wY2kvaGRhL2hkYV9lbGQuYwppbmRleCA0YTY2MzQ3Li43NGIwNTYwIDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvaGRhL2hkYV9lbGQuYworKysgYi9zb3VuZC9wY2kvaGRhL2hkYV9lbGQuYwpAQCAtMzgxLDcgKzM4MSw3IEBACiAJc25kX3ByaW50X3BjbV9yYXRlcyhhLT5yYXRlcywgYnVmLCBzaXplb2YoYnVmKSk7CiAKIAlpZiAoYS0+Zm9ybWF0ID09IEFVRElPX0NPRElOR19UWVBFX0xQQ00pCi0JCXNuZF9wcmludF9wY21fYml0cyhhLT5zYW1wbGVfYml0cywgYnVmMiArIDgsIHNpemVvZihidWYyIC0gOCkpOworCQlzbmRfcHJpbnRfcGNtX2JpdHMoYS0+c2FtcGxlX2JpdHMsIGJ1ZjIgKyA4LCBzaXplb2YoYnVmMikgLSA4KTsKIAllbHNlIGlmIChhLT5tYXhfYml0cmF0ZSkKIAkJc25wcmludGYoYnVmMiwgc2l6ZW9mKGJ1ZjIpLAogCQkJCSIsIG1heCBiaXRyYXRlID0gJWQiLCBhLT5tYXhfYml0cmF0ZSk7CmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvaGRhL2hkYV9nZW5lcmljLmMgYi9zb3VuZC9wY2kvaGRhL2hkYV9nZW5lcmljLmMKaW5kZXggZmIwNTgyZjguLmE2M2M1NGQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9oZGEvaGRhX2dlbmVyaWMuYworKysgYi9zb3VuZC9wY2kvaGRhL2hkYV9nZW5lcmljLmMKQEAgLTc2Miw3ICs3NjIsOCBAQAogLyoKICAqIGJ1aWxkIG91dHB1dCBtaXhlciBjb250cm9scwogICovCi1zdGF0aWMgaW50IGNyZWF0ZV9vdXRwdXRfbWl4ZXJzKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLCBjb25zdCBjaGFyICoqbmFtZXMpCitzdGF0aWMgaW50IGNyZWF0ZV9vdXRwdXRfbWl4ZXJzKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLAorCQkJCWNvbnN0IGNoYXIgKiBjb25zdCAqbmFtZXMpCiB7CiAJc3RydWN0IGhkYV9nc3BlYyAqc3BlYyA9IGNvZGVjLT5zcGVjOwogCWludCBpLCBlcnI7CkBAIC03ODAsOCArNzgxLDggQEAKIHN0YXRpYyBpbnQgYnVpbGRfb3V0cHV0X2NvbnRyb2xzKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjKQogewogCXN0cnVjdCBoZGFfZ3NwZWMgKnNwZWMgPSBjb2RlYy0+c3BlYzsKLQlzdGF0aWMgY29uc3QgY2hhciAqdHlwZXNfc3BlYWtlcltdID0geyAiU3BlYWtlciIsICJIZWFkcGhvbmUiIH07Ci0Jc3RhdGljIGNvbnN0IGNoYXIgKnR5cGVzX2xpbmVbXSA9IHsgIkZyb250IiwgIkhlYWRwaG9uZSIgfTsKKwlzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHR5cGVzX3NwZWFrZXJbXSA9IHsgIlNwZWFrZXIiLCAiSGVhZHBob25lIiB9OworCXN0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdHlwZXNfbGluZVtdID0geyAiRnJvbnQiLCAiSGVhZHBob25lIiB9OwogCiAJc3dpdGNoIChzcGVjLT5wY21fdm9sX25vZGVzKSB7CiAJY2FzZSAxOgpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2hkYS9oZGFfaW50ZWwuYyBiL3NvdW5kL3BjaS9oZGEvaGRhX2ludGVsLmMKaW5kZXggZDNkMThiZS4uMGJhZmZjZCAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2hkYS9oZGFfaW50ZWwuYworKysgYi9zb3VuZC9wY2kvaGRhL2hkYV9pbnRlbC5jCkBAIC0yNzAzLDcgKzI3MDMsNyBAQAogCWlmIChlcnIgPCAwKQogCQlnb3RvIG91dF9mcmVlOwogI2lmZGVmIENPTkZJR19TTkRfSERBX1BBVENIX0xPQURFUgotCWlmIChwYXRjaFtkZXZdKSB7CisJaWYgKHBhdGNoW2Rldl0gJiYgKnBhdGNoW2Rldl0pIHsKIAkJc25kX3ByaW50ayhLRVJOX0VSUiBTRlggIkFwcGx5aW5nIHBhdGNoIGZpcm13YXJlICclcydcbiIsCiAJCQkgICBwYXRjaFtkZXZdKTsKIAkJZXJyID0gc25kX2hkYV9sb2FkX3BhdGNoKGNoaXAtPmJ1cywgcGF0Y2hbZGV2XSk7CkBAIC0yODA5LDYgKzI4MDksOCBAQAogI2VuZGlmCiAJLyogVm9ydGV4ODZNWCAqLwogCXsgUENJX0RFVklDRSgweDE3ZjMsIDB4MzAxMCksIC5kcml2ZXJfZGF0YSA9IEFaWF9EUklWRVJfR0VORVJJQyB9LAorCS8qIFZNd2FyZSBIREF1ZGlvICovCisJeyBQQ0lfREVWSUNFKDB4MTVhZCwgMHgxOTc3KSwgLmRyaXZlcl9kYXRhID0gQVpYX0RSSVZFUl9HRU5FUklDIH0sCiAJLyogQU1EL0FUSSBHZW5lcmljLCBQQ0kgY2xhc3MgY29kZSBhbmQgVmVuZG9yIElEIGZvciBIRCBBdWRpbyAqLwogCXsgUENJX0RFVklDRShQQ0lfVkVORE9SX0lEX0FUSSwgUENJX0FOWV9JRCksCiAJICAuY2xhc3MgPSBQQ0lfQ0xBU1NfTVVMVElNRURJQV9IRF9BVURJTyA8PCA4LApkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2hkYS9oZGFfbG9jYWwuaCBiL3NvdW5kL3BjaS9oZGEvaGRhX2xvY2FsLmgKaW5kZXggNDZiYmVmZS4uM2FiNWU3YSAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2hkYS9oZGFfbG9jYWwuaAorKysgYi9zb3VuZC9wY2kvaGRhL2hkYV9sb2NhbC5oCkBAIC0xNDAsNyArMTQwLDcgQEAKIHN0cnVjdCBzbmRfa2NvbnRyb2wgKnNuZF9oZGFfZmluZF9taXhlcl9jdGwoc3RydWN0IGhkYV9jb2RlYyAqY29kZWMsCiAJCQkJCSAgICBjb25zdCBjaGFyICpuYW1lKTsKIGludCBzbmRfaGRhX2FkZF92bWFzdGVyKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLCBjaGFyICpuYW1lLAotCQkJdW5zaWduZWQgaW50ICp0bHYsIGNvbnN0IGNoYXIgKipzbGF2ZXMpOworCQkJdW5zaWduZWQgaW50ICp0bHYsIGNvbnN0IGNoYXIgKiBjb25zdCAqc2xhdmVzKTsKIGludCBzbmRfaGRhX2NvZGVjX3Jlc2V0KHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjKTsKIAogLyogYW1wIHZhbHVlIGJpdHMgKi8KQEAgLTM0MSwxMCArMzQxLDEwIEBACiAgKiBNaXNjCiAgKi8KIGludCBzbmRfaGRhX2NoZWNrX2JvYXJkX2NvbmZpZyhzdHJ1Y3QgaGRhX2NvZGVjICpjb2RlYywgaW50IG51bV9jb25maWdzLAotCQkJICAgICAgIGNvbnN0IGNoYXIgKiptb2RlbG5hbWVzLAorCQkJICAgICAgIGNvbnN0IGNoYXIgKiBjb25zdCAqbW9kZWxuYW1lcywKIAkJCSAgICAgICBjb25zdCBzdHJ1Y3Qgc25kX3BjaV9xdWlyayAqcGNpX2xpc3QpOwogaW50IHNuZF9oZGFfY2hlY2tfYm9hcmRfY29kZWNfc2lkX2NvbmZpZyhzdHJ1Y3QgaGRhX2NvZGVjICpjb2RlYywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnQgbnVtX2NvbmZpZ3MsIGNvbnN0IGNoYXIgKiptb2RlbHMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW50IG51bV9jb25maWdzLCBjb25zdCBjaGFyICogY29uc3QgKm1vZGVscywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBzdHJ1Y3Qgc25kX3BjaV9xdWlyayAqdGJsKTsKIGludCBzbmRfaGRhX2FkZF9uZXdfY3RscyhzdHJ1Y3QgaGRhX2NvZGVjICpjb2RlYywKIAkJCSBzdHJ1Y3Qgc25kX2tjb250cm9sX25ldyAqa25ldyk7CmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvaGRhL2hkYV9wcm9jLmMgYi9zb3VuZC9wY2kvaGRhL2hkYV9wcm9jLmMKaW5kZXggZjAyNTIwMC4uYmZlNzRjMiAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2hkYS9oZGFfcHJvYy5jCisrKyBiL3NvdW5kL3BjaS9oZGEvaGRhX3Byb2MuYwpAQCAtNDE4LDcgKzQxOCw3IEBACiAKIHN0YXRpYyBjb25zdCBjaGFyICpnZXRfcHdyX3N0YXRlKHUzMiBzdGF0ZSkKIHsKLQlzdGF0aWMgY29uc3QgY2hhciAqYnVmWzRdID0geworCXN0YXRpYyBjb25zdCBjaGFyICogY29uc3QgYnVmWzRdID0gewogCQkiRDAiLCAiRDEiLCAiRDIiLCAiRDMiCiAJfTsKIAlpZiAoc3RhdGUgPCA0KQpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2hkYS9wYXRjaF9hbmFsb2cuYyBiL3NvdW5kL3BjaS9oZGEvcGF0Y2hfYW5hbG9nLmMKaW5kZXggNDY3ODA2Ny4uOGRhYmFiNyAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2hkYS9wYXRjaF9hbmFsb2cuYworKysgYi9zb3VuZC9wY2kvaGRhL3BhdGNoX2FuYWxvZy5jCkBAIC00Niw2ICs0Niw5IEBACiAJdW5zaWduZWQgaW50IGN1cl9lYXBkOwogCXVuc2lnbmVkIGludCBuZWVkX2RhY19maXg7CiAKKwloZGFfbmlkX3QgKmFsdF9kYWNfbmlkOworCXN0cnVjdCBoZGFfcGNtX3N0cmVhbSAqc3RyZWFtX2FuYWxvZ19hbHRfcGxheWJhY2s7CisKIAkvKiBjYXB0dXJlICovCiAJdW5zaWduZWQgaW50IG51bV9hZGNfbmlkczsKIAloZGFfbmlkX3QgKmFkY19uaWRzOwpAQCAtODEsOCArODQsOCBAQAogI2VuZGlmCiAJLyogZm9yIHZpcnR1YWwgbWFzdGVyICovCiAJaGRhX25pZF90IHZtYXN0ZXJfbmlkOwotCWNvbnN0IGNoYXIgKipzbGF2ZV92b2xzOwotCWNvbnN0IGNoYXIgKipzbGF2ZV9zd3M7CisJY29uc3QgY2hhciAqIGNvbnN0ICpzbGF2ZV92b2xzOworCWNvbnN0IGNoYXIgKiBjb25zdCAqc2xhdmVfc3dzOwogfTsKIAogLyoKQEAgLTEzMCw3ICsxMzMsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgY29uc3QgY2hhciAqYWRfc2xhdmVfdm9sc1tdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhZF9zbGF2ZV92b2xzW10gPSB7CiAJIkZyb250IFBsYXliYWNrIFZvbHVtZSIsCiAJIlN1cnJvdW5kIFBsYXliYWNrIFZvbHVtZSIsCiAJIkNlbnRlciBQbGF5YmFjayBWb2x1bWUiLApAQCAtMTQzLDcgKzE0Niw3IEBACiAJTlVMTAogfTsKIAotc3RhdGljIGNvbnN0IGNoYXIgKmFkX3NsYXZlX3N3c1tdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhZF9zbGF2ZV9zd3NbXSA9IHsKIAkiRnJvbnQgUGxheWJhY2sgU3dpdGNoIiwKIAkiU3Vycm91bmQgUGxheWJhY2sgU3dpdGNoIiwKIAkiQ2VudGVyIFBsYXliYWNrIFN3aXRjaCIsCkBAIC0xNTYsNiArMTU5LDI1IEBACiAJTlVMTAogfTsKIAorc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhZDE5ODhfNnN0YWNrX2ZwX3NsYXZlX3ZvbHNbXSA9IHsKKwkiRnJvbnQgUGxheWJhY2sgVm9sdW1lIiwKKwkiU3Vycm91bmQgUGxheWJhY2sgVm9sdW1lIiwKKwkiQ2VudGVyIFBsYXliYWNrIFZvbHVtZSIsCisJIkxGRSBQbGF5YmFjayBWb2x1bWUiLAorCSJTaWRlIFBsYXliYWNrIFZvbHVtZSIsCisJIklFQzk1OCBQbGF5YmFjayBWb2x1bWUiLAorCU5VTEwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgYWQxOTg4XzZzdGFja19mcF9zbGF2ZV9zd3NbXSA9IHsKKwkiRnJvbnQgUGxheWJhY2sgU3dpdGNoIiwKKwkiU3Vycm91bmQgUGxheWJhY2sgU3dpdGNoIiwKKwkiQ2VudGVyIFBsYXliYWNrIFN3aXRjaCIsCisJIkxGRSBQbGF5YmFjayBTd2l0Y2giLAorCSJTaWRlIFBsYXliYWNrIFN3aXRjaCIsCisJIklFQzk1OCBQbGF5YmFjayBTd2l0Y2giLAorCU5VTEwKK307CiBzdGF0aWMgdm9pZCBhZDE5OHhfZnJlZV9rY3RscyhzdHJ1Y3QgaGRhX2NvZGVjICpjb2RlYyk7CiAKICNpZmRlZiBDT05GSUdfU05EX0hEQV9JTlBVVF9CRUVQCkBAIC0zMDksNiArMzMxLDM4IEBACiAJcmV0dXJuIHNuZF9oZGFfbXVsdGlfb3V0X2FuYWxvZ19jbGVhbnVwKGNvZGVjLCAmc3BlYy0+bXVsdGlvdXQpOwogfQogCitzdGF0aWMgaW50IGFkMTk4eF9hbHRfcGxheWJhY2tfcGNtX3ByZXBhcmUoc3RydWN0IGhkYV9wY21fc3RyZWFtICpoaW5mbywKKwkJCQlzdHJ1Y3QgaGRhX2NvZGVjICpjb2RlYywKKwkJCQl1bnNpZ25lZCBpbnQgc3RyZWFtX3RhZywKKwkJCQl1bnNpZ25lZCBpbnQgZm9ybWF0LAorCQkJCXN0cnVjdCBzbmRfcGNtX3N1YnN0cmVhbSAqc3Vic3RyZWFtKQoreworCXN0cnVjdCBhZDE5OHhfc3BlYyAqc3BlYyA9IGNvZGVjLT5zcGVjOworCXNuZF9oZGFfY29kZWNfc2V0dXBfc3RyZWFtKGNvZGVjLCBzcGVjLT5hbHRfZGFjX25pZFswXSwgc3RyZWFtX3RhZywKKwkJCQkJMCwgZm9ybWF0KTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBhZDE5OHhfYWx0X3BsYXliYWNrX3BjbV9jbGVhbnVwKHN0cnVjdCBoZGFfcGNtX3N0cmVhbSAqaGluZm8sCisJCQkJc3RydWN0IGhkYV9jb2RlYyAqY29kZWMsCisJCQkJc3RydWN0IHNuZF9wY21fc3Vic3RyZWFtICpzdWJzdHJlYW0pCit7CisJc3RydWN0IGFkMTk4eF9zcGVjICpzcGVjID0gY29kZWMtPnNwZWM7CisJc25kX2hkYV9jb2RlY19jbGVhbnVwX3N0cmVhbShjb2RlYywgc3BlYy0+YWx0X2RhY19uaWRbMF0pOworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IGhkYV9wY21fc3RyZWFtIGFkMTk4eF9wY21fYW5hbG9nX2FsdF9wbGF5YmFjayA9IHsKKwkuc3Vic3RyZWFtcyA9IDEsCisJLmNoYW5uZWxzX21pbiA9IDIsCisJLmNoYW5uZWxzX21heCA9IDIsCisJLyogTklEIGlzIHNldCBpbiBhZDE5OHhfYnVpbGRfcGNtcyAqLworCS5vcHMgPSB7CisJCS5wcmVwYXJlID0gYWQxOTh4X2FsdF9wbGF5YmFja19wY21fcHJlcGFyZSwKKwkJLmNsZWFudXAgPSBhZDE5OHhfYWx0X3BsYXliYWNrX3BjbV9jbGVhbnVwCisJfSwKK307CisKIC8qCiAgKiBEaWdpdGFsIG91dAogICovCkBAIC00NDYsNiArNTAwLDE3IEBACiAJCX0KIAl9CiAKKwlpZiAoc3BlYy0+YWx0X2RhY19uaWQgJiYgc3BlYy0+c3RyZWFtX2FuYWxvZ19hbHRfcGxheWJhY2spIHsKKwkJY29kZWMtPm51bV9wY21zKys7CisJCWluZm8gPSBzcGVjLT5wY21fcmVjICsgMjsKKwkJaW5mby0+bmFtZSA9ICJBRDE5OHggSGVhZHBob25lIjsKKwkJaW5mby0+cGNtX3R5cGUgPSBIREFfUENNX1RZUEVfQVVESU87CisJCWluZm8tPnN0cmVhbVtTTkRSVl9QQ01fU1RSRUFNX1BMQVlCQUNLXSA9CisJCQkqc3BlYy0+c3RyZWFtX2FuYWxvZ19hbHRfcGxheWJhY2s7CisJCWluZm8tPnN0cmVhbVtTTkRSVl9QQ01fU1RSRUFNX1BMQVlCQUNLXS5uaWQgPQorCQkJc3BlYy0+YWx0X2RhY19uaWRbMF07CisJfQorCiAJcmV0dXJuIDA7CiB9CiAKQEAgLTEwNjksNyArMTEzNCw3IEBACiAJQUQxOTg2QV9NT0RFTFMKIH07CiAKLXN0YXRpYyBjb25zdCBjaGFyICphZDE5ODZhX21vZGVsc1tBRDE5ODZBX01PREVMU10gPSB7CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFkMTk4NmFfbW9kZWxzW0FEMTk4NkFfTU9ERUxTXSA9IHsKIAlbQUQxOTg2QV82U1RBQ0tdCT0gIjZzdGFjayIsCiAJW0FEMTk4NkFfM1NUQUNLXQk9ICIzc3RhY2siLAogCVtBRDE5ODZBX0xBUFRPUF0JPSAibGFwdG9wIiwKQEAgLTE4MTMsNyArMTg3OCw3IEBACiAJQUQxOTgxX01PREVMUwogfTsKIAotc3RhdGljIGNvbnN0IGNoYXIgKmFkMTk4MV9tb2RlbHNbQUQxOTgxX01PREVMU10gPSB7CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFkMTk4MV9tb2RlbHNbQUQxOTgxX01PREVMU10gPSB7CiAJW0FEMTk4MV9IUF0JCT0gImhwIiwKIAlbQUQxOTgxX1RISU5LUEFEXQk9ICJ0aGlua3BhZCIsCiAJW0FEMTk4MV9CQVNJQ10JCT0gImJhc2ljIiwKQEAgLTIwMTUsNiArMjA4MCw3IEBACiBlbnVtIHsKIAlBRDE5ODhfNlNUQUNLLAogCUFEMTk4OF82U1RBQ0tfRElHLAorCUFEMTk4OF82U1RBQ0tfRElHX0ZQLAogCUFEMTk4OF8zU1RBQ0ssCiAJQUQxOTg4XzNTVEFDS19ESUcsCiAJQUQxOTg4X0xBUFRPUCwKQEAgLTIwNDcsNiArMjExMywxMCBAQAogCTB4MDQsIDB4MDUsIDB4MGEsIDB4MDYKIH07CiAKK3N0YXRpYyBoZGFfbmlkX3QgYWQxOTg4X2FsdF9kYWNfbmlkWzFdID0geworCTB4MDMKK307CisKIHN0YXRpYyBoZGFfbmlkX3QgYWQxOTg4XzNzdGFja19kYWNfbmlkc19yZXYyWzNdID0gewogCTB4MDQsIDB4MGEsIDB4MDYKIH07CkBAIC0yMTY2LDYgKzIyMzYsMzUgQEAKIAl7IH0gLyogZW5kICovCiB9OwogCitzdGF0aWMgc3RydWN0IHNuZF9rY29udHJvbF9uZXcgYWQxOTg4XzZzdGFja19mcF9taXhlcnNbXSA9IHsKKwlIREFfQ09ERUNfVk9MVU1FKCJIZWFkcGhvbmUgUGxheWJhY2sgVm9sdW1lIiwgMHgwMywgMHgwLCBIREFfT1VUUFVUKSwKKworCUhEQV9CSU5EX01VVEUoIkZyb250IFBsYXliYWNrIFN3aXRjaCIsIDB4MjksIDIsIEhEQV9JTlBVVCksCisJSERBX0JJTkRfTVVURSgiU3Vycm91bmQgUGxheWJhY2sgU3dpdGNoIiwgMHgyYSwgMiwgSERBX0lOUFVUKSwKKwlIREFfQklORF9NVVRFX01PTk8oIkNlbnRlciBQbGF5YmFjayBTd2l0Y2giLCAweDI3LCAxLCAyLCBIREFfSU5QVVQpLAorCUhEQV9CSU5EX01VVEVfTU9OTygiTEZFIFBsYXliYWNrIFN3aXRjaCIsIDB4MjcsIDIsIDIsIEhEQV9JTlBVVCksCisJSERBX0JJTkRfTVVURSgiU2lkZSBQbGF5YmFjayBTd2l0Y2giLCAweDI4LCAyLCBIREFfSU5QVVQpLAorCUhEQV9CSU5EX01VVEUoIkhlYWRwaG9uZSBQbGF5YmFjayBTd2l0Y2giLCAweDIyLCAyLCBIREFfSU5QVVQpLAorCUhEQV9CSU5EX01VVEUoIk1vbm8gUGxheWJhY2sgU3dpdGNoIiwgMHgxZSwgMiwgSERBX0lOUFVUKSwKKworCUhEQV9DT0RFQ19WT0xVTUUoIkNEIFBsYXliYWNrIFZvbHVtZSIsIDB4MjAsIDB4NiwgSERBX0lOUFVUKSwKKwlIREFfQ09ERUNfTVVURSgiQ0QgUGxheWJhY2sgU3dpdGNoIiwgMHgyMCwgMHg2LCBIREFfSU5QVVQpLAorCUhEQV9DT0RFQ19WT0xVTUUoIkZyb250IE1pYyBQbGF5YmFjayBWb2x1bWUiLCAweDIwLCAweDAsIEhEQV9JTlBVVCksCisJSERBX0NPREVDX01VVEUoIkZyb250IE1pYyBQbGF5YmFjayBTd2l0Y2giLCAweDIwLCAweDAsIEhEQV9JTlBVVCksCisJSERBX0NPREVDX1ZPTFVNRSgiTGluZSBQbGF5YmFjayBWb2x1bWUiLCAweDIwLCAweDEsIEhEQV9JTlBVVCksCisJSERBX0NPREVDX01VVEUoIkxpbmUgUGxheWJhY2sgU3dpdGNoIiwgMHgyMCwgMHgxLCBIREFfSU5QVVQpLAorCUhEQV9DT0RFQ19WT0xVTUUoIk1pYyBQbGF5YmFjayBWb2x1bWUiLCAweDIwLCAweDQsIEhEQV9JTlBVVCksCisJSERBX0NPREVDX01VVEUoIk1pYyBQbGF5YmFjayBTd2l0Y2giLCAweDIwLCAweDQsIEhEQV9JTlBVVCksCisKKwlIREFfQ09ERUNfVk9MVU1FKCJBbmFsb2cgTWl4IFBsYXliYWNrIFZvbHVtZSIsIDB4MjEsIDB4MCwgSERBX09VVFBVVCksCisJSERBX0NPREVDX01VVEUoIkFuYWxvZyBNaXggUGxheWJhY2sgU3dpdGNoIiwgMHgyMSwgMHgwLCBIREFfT1VUUFVUKSwKKworCUhEQV9DT0RFQ19WT0xVTUUoIkZyb250IE1pYyBCb29zdCBWb2x1bWUiLCAweDM5LCAweDAsIEhEQV9PVVRQVVQpLAorCUhEQV9DT0RFQ19WT0xVTUUoIk1pYyBCb29zdCBWb2x1bWUiLCAweDNjLCAweDAsIEhEQV9PVVRQVVQpLAorCisJeyB9IC8qIGVuZCAqLworfTsKKwogLyogMy1zdGFjayBtb2RlICovCiBzdGF0aWMgc3RydWN0IHNuZF9rY29udHJvbF9uZXcgYWQxOTg4XzNzdGFja19taXhlcnMxW10gPSB7CiAJSERBX0NPREVDX1ZPTFVNRSgiRnJvbnQgUGxheWJhY2sgVm9sdW1lIiwgMHgwNCwgMHgwLCBIREFfT1VUUFVUKSwKQEAgLTI0NDUsNiArMjU0NCw2OCBAQAogCXsgfQogfTsKIAorc3RhdGljIHN0cnVjdCBoZGFfdmVyYiBhZDE5ODhfNnN0YWNrX2ZwX2luaXRfdmVyYnNbXSA9IHsKKwkvKiBGcm9udCwgU3Vycm91bmQsIENMRkUsIHNpZGUgREFDOyB1bm11dGUgYXMgZGVmYXVsdCAqLworCXsweDA0LCBBQ19WRVJCX1NFVF9BTVBfR0FJTl9NVVRFLCBBTVBfT1VUX1VOTVVURX0sCisJezB4MDYsIEFDX1ZFUkJfU0VUX0FNUF9HQUlOX01VVEUsIEFNUF9PVVRfVU5NVVRFfSwKKwl7MHgwNSwgQUNfVkVSQl9TRVRfQU1QX0dBSU5fTVVURSwgQU1QX09VVF9VTk1VVEV9LAorCXsweDBhLCBBQ19WRVJCX1NFVF9BTVBfR0FJTl9NVVRFLCBBTVBfT1VUX1VOTVVURX0sCisJLyogSGVhZHBob25lOyB1bm11dGUgYXMgZGVmYXVsdCAqLworCXsweDAzLCBBQ19WRVJCX1NFVF9BTVBfR0FJTl9NVVRFLCBBTVBfT1VUX1VOTVVURX0sCisJLyogUG9ydC1BIGZyb250IGhlYWRwaG9uIHBhdGggKi8KKwl7MHgzNywgQUNfVkVSQl9TRVRfQ09OTkVDVF9TRUwsIDB4MDB9LCAvKiBEQUMwOjAzaCAqLworCXsweDIyLCBBQ19WRVJCX1NFVF9BTVBfR0FJTl9NVVRFLCBBTVBfSU5fTVVURSgwKX0sCisJezB4MjIsIEFDX1ZFUkJfU0VUX0FNUF9HQUlOX01VVEUsIEFNUF9JTl9NVVRFKDEpfSwKKwl7MHgxMSwgQUNfVkVSQl9TRVRfQU1QX0dBSU5fTVVURSwgQU1QX09VVF9VTk1VVEV9LAorCXsweDExLCBBQ19WRVJCX1NFVF9QSU5fV0lER0VUX0NPTlRST0wsIFBJTl9IUH0sCisJLyogUG9ydC1EIGxpbmUtb3V0IHBhdGggKi8KKwl7MHgyOSwgQUNfVkVSQl9TRVRfQU1QX0dBSU5fTVVURSwgQU1QX0lOX01VVEUoMCl9LAorCXsweDI5LCBBQ19WRVJCX1NFVF9BTVBfR0FJTl9NVVRFLCBBTVBfSU5fTVVURSgxKX0sCisJezB4MTIsIEFDX1ZFUkJfU0VUX0FNUF9HQUlOX01VVEUsIEFNUF9PVVRfVU5NVVRFfSwKKwl7MHgxMiwgQUNfVkVSQl9TRVRfUElOX1dJREdFVF9DT05UUk9MLCBQSU5fT1VUfSwKKwkvKiBQb3J0LUYgc3Vycm91bmQgcGF0aCAqLworCXsweDJhLCBBQ19WRVJCX1NFVF9BTVBfR0FJTl9NVVRFLCBBTVBfSU5fTVVURSgwKX0sCisJezB4MmEsIEFDX1ZFUkJfU0VUX0FNUF9HQUlOX01VVEUsIEFNUF9JTl9NVVRFKDEpfSwKKwl7MHgxNiwgQUNfVkVSQl9TRVRfQU1QX0dBSU5fTVVURSwgQU1QX09VVF9VTk1VVEV9LAorCXsweDE2LCBBQ19WRVJCX1NFVF9QSU5fV0lER0VUX0NPTlRST0wsIFBJTl9PVVR9LAorCS8qIFBvcnQtRyBDTEZFIHBhdGggKi8KKwl7MHgyNywgQUNfVkVSQl9TRVRfQU1QX0dBSU5fTVVURSwgQU1QX0lOX01VVEUoMCl9LAorCXsweDI3LCBBQ19WRVJCX1NFVF9BTVBfR0FJTl9NVVRFLCBBTVBfSU5fTVVURSgxKX0sCisJezB4MjQsIEFDX1ZFUkJfU0VUX0FNUF9HQUlOX01VVEUsIEFNUF9PVVRfVU5NVVRFfSwKKwl7MHgyNCwgQUNfVkVSQl9TRVRfUElOX1dJREdFVF9DT05UUk9MLCBQSU5fT1VUfSwKKwkvKiBQb3J0LUggc2lkZSBwYXRoICovCisJezB4MjgsIEFDX1ZFUkJfU0VUX0FNUF9HQUlOX01VVEUsIEFNUF9JTl9NVVRFKDApfSwKKwl7MHgyOCwgQUNfVkVSQl9TRVRfQU1QX0dBSU5fTVVURSwgQU1QX0lOX01VVEUoMSl9LAorCXsweDI1LCBBQ19WRVJCX1NFVF9BTVBfR0FJTl9NVVRFLCBBTVBfT1VUX1VOTVVURX0sCisJezB4MjUsIEFDX1ZFUkJfU0VUX1BJTl9XSURHRVRfQ09OVFJPTCwgUElOX09VVH0sCisJLyogTW9ubyBvdXQgcGF0aCAqLworCXsweDM2LCBBQ19WRVJCX1NFVF9DT05ORUNUX1NFTCwgMHgxfSwgLyogREFDMTowNGggKi8KKwl7MHgxZSwgQUNfVkVSQl9TRVRfQU1QX0dBSU5fTVVURSwgQU1QX0lOX01VVEUoMCl9LAorCXsweDFlLCBBQ19WRVJCX1NFVF9BTVBfR0FJTl9NVVRFLCBBTVBfSU5fTVVURSgxKX0sCisJezB4MTMsIEFDX1ZFUkJfU0VUX1BJTl9XSURHRVRfQ09OVFJPTCwgUElOX09VVH0sCisJezB4MTMsIEFDX1ZFUkJfU0VUX0FNUF9HQUlOX01VVEUsIDB4YjAxZn0sIC8qIHVubXV0ZSwgMGRCICovCisJLyogUG9ydC1CIGZyb250IG1pYy1pbiBwYXRoICovCisJezB4MTQsIEFDX1ZFUkJfU0VUX0FNUF9HQUlOX01VVEUsIEFNUF9PVVRfTVVURX0sCisJezB4MTQsIEFDX1ZFUkJfU0VUX1BJTl9XSURHRVRfQ09OVFJPTCwgUElOX1ZSRUY4MH0sCisJezB4MzksIEFDX1ZFUkJfU0VUX0FNUF9HQUlOX01VVEUsIEFNUF9PVVRfWkVST30sCisJLyogUG9ydC1DIGxpbmUtaW4gcGF0aCAqLworCXsweDE1LCBBQ19WRVJCX1NFVF9BTVBfR0FJTl9NVVRFLCBBTVBfT1VUX01VVEV9LAorCXsweDE1LCBBQ19WRVJCX1NFVF9QSU5fV0lER0VUX0NPTlRST0wsIFBJTl9JTn0sCisJezB4M2EsIEFDX1ZFUkJfU0VUX0FNUF9HQUlOX01VVEUsIEFNUF9PVVRfWkVST30sCisJezB4MzMsIEFDX1ZFUkJfU0VUX0NPTk5FQ1RfU0VMLCAweDB9LAorCS8qIFBvcnQtRSBtaWMtaW4gcGF0aCAqLworCXsweDE3LCBBQ19WRVJCX1NFVF9BTVBfR0FJTl9NVVRFLCBBTVBfT1VUX01VVEV9LAorCXsweDE3LCBBQ19WRVJCX1NFVF9QSU5fV0lER0VUX0NPTlRST0wsIFBJTl9WUkVGODB9LAorCXsweDNjLCBBQ19WRVJCX1NFVF9BTVBfR0FJTl9NVVRFLCBBTVBfT1VUX1pFUk99LAorCXsweDM0LCBBQ19WRVJCX1NFVF9DT05ORUNUX1NFTCwgMHgwfSwKKwkvKiBBbmFsb2cgQ0QgSW5wdXQgKi8KKwl7MHgxOCwgQUNfVkVSQl9TRVRfUElOX1dJREdFVF9DT05UUk9MLCBQSU5fSU59LAorCS8qIEFuYWxvZyBNaXggb3V0cHV0IGFtcCAqLworCXsweDIxLCBBQ19WRVJCX1NFVF9BTVBfR0FJTl9NVVRFLCBBTVBfT1VUX1VOTVVURSB8IDB4MWZ9LCAvKiAwZEIgKi8KKworCXsgfQorfTsKKwogc3RhdGljIHN0cnVjdCBoZGFfdmVyYiBhZDE5ODhfY2FwdHVyZV9pbml0X3ZlcmJzW10gPSB7CiAJLyogbXV0ZSBhbmFsb2cgbWl4ICovCiAJezB4MjAsIEFDX1ZFUkJfU0VUX0FNUF9HQUlOX01VVEUsIEFNUF9JTl9NVVRFKDApfSwKQEAgLTI3OTIsNyArMjk1Myw5IEBACiAJCQkJCSAgICAgY29uc3Qgc3RydWN0IGF1dG9fcGluX2NmZyAqY2ZnKQogewogCWNoYXIgbmFtZVszMl07Ci0Jc3RhdGljIGNvbnN0IGNoYXIgKmNobmFtZVs0XSA9IHsgIkZyb250IiwgIlN1cnJvdW5kIiwgTlVMTCAvKkNMRkUqLywgIlNpZGUiIH07CisJc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBjaG5hbWVbNF0gPSB7CisJCSJGcm9udCIsICJTdXJyb3VuZCIsIE5VTEwgLypDTEZFKi8sICJTaWRlIgorCX07CiAJaGRhX25pZF90IG5pZDsKIAlpbnQgaSwgZXJyOwogCkBAIC0zMDc0LDEzICszMjM3LDEzIEBACiAJcmV0dXJuIDA7CiB9CiAKLQogLyoKICAqLwogCi1zdGF0aWMgY29uc3QgY2hhciAqYWQxOTg4X21vZGVsc1tBRDE5ODhfTU9ERUxfTEFTVF0gPSB7CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFkMTk4OF9tb2RlbHNbQUQxOTg4X01PREVMX0xBU1RdID0gewogCVtBRDE5ODhfNlNUQUNLXQkJPSAiNnN0YWNrIiwKIAlbQUQxOTg4XzZTVEFDS19ESUddCT0gIjZzdGFjay1kaWciLAorCVtBRDE5ODhfNlNUQUNLX0RJR19GUF0JPSAiNnN0YWNrLWRpZy1mcCIsCiAJW0FEMTk4OF8zU1RBQ0tdCQk9ICIzc3RhY2siLAogCVtBRDE5ODhfM1NUQUNLX0RJR10JPSAiM3N0YWNrLWRpZyIsCiAJW0FEMTk4OF9MQVBUT1BdCQk9ICJsYXB0b3AiLApAQCAtMzE0MCw2ICszMzAzLDcgQEAKIAlzd2l0Y2ggKGJvYXJkX2NvbmZpZykgewogCWNhc2UgQUQxOTg4XzZTVEFDSzoKIAljYXNlIEFEMTk4OF82U1RBQ0tfRElHOgorCWNhc2UgQUQxOTg4XzZTVEFDS19ESUdfRlA6CiAJCXNwZWMtPm11bHRpb3V0Lm1heF9jaGFubmVscyA9IDg7CiAJCXNwZWMtPm11bHRpb3V0Lm51bV9kYWNzID0gNDsKIAkJaWYgKGlzX3JldjIoY29kZWMpKQpAQCAtMzE1MiwxMCArMzMxNiwyMiBAQAogCQkJc3BlYy0+bWl4ZXJzWzBdID0gYWQxOTg4XzZzdGFja19taXhlcnMxX3JldjI7CiAJCWVsc2UKIAkJCXNwZWMtPm1peGVyc1swXSA9IGFkMTk4OF82c3RhY2tfbWl4ZXJzMTsKLQkJc3BlYy0+bWl4ZXJzWzFdID0gYWQxOTg4XzZzdGFja19taXhlcnMyOworCQlpZiAoYm9hcmRfY29uZmlnID09IEFEMTk4OF82U1RBQ0tfRElHX0ZQKSB7CisJCQlzcGVjLT5taXhlcnNbMV0gPSBhZDE5ODhfNnN0YWNrX2ZwX21peGVyczsKKwkJCXNwZWMtPnNsYXZlX3ZvbHMgPSBhZDE5ODhfNnN0YWNrX2ZwX3NsYXZlX3ZvbHM7CisJCQlzcGVjLT5zbGF2ZV9zd3MgPSBhZDE5ODhfNnN0YWNrX2ZwX3NsYXZlX3N3czsKKwkJCXNwZWMtPmFsdF9kYWNfbmlkID0gYWQxOTg4X2FsdF9kYWNfbmlkOworCQkJc3BlYy0+c3RyZWFtX2FuYWxvZ19hbHRfcGxheWJhY2sgPQorCQkJCSZhZDE5OHhfcGNtX2FuYWxvZ19hbHRfcGxheWJhY2s7CisJCX0gZWxzZQorCQkJc3BlYy0+bWl4ZXJzWzFdID0gYWQxOTg4XzZzdGFja19taXhlcnMyOwogCQlzcGVjLT5udW1faW5pdF92ZXJicyA9IDE7Ci0JCXNwZWMtPmluaXRfdmVyYnNbMF0gPSBhZDE5ODhfNnN0YWNrX2luaXRfdmVyYnM7Ci0JCWlmIChib2FyZF9jb25maWcgPT0gQUQxOTg4XzZTVEFDS19ESUcpIHsKKwkJaWYgKGJvYXJkX2NvbmZpZyA9PSBBRDE5ODhfNlNUQUNLX0RJR19GUCkKKwkJCXNwZWMtPmluaXRfdmVyYnNbMF0gPSBhZDE5ODhfNnN0YWNrX2ZwX2luaXRfdmVyYnM7CisJCWVsc2UKKwkJCXNwZWMtPmluaXRfdmVyYnNbMF0gPSBhZDE5ODhfNnN0YWNrX2luaXRfdmVyYnM7CisJCWlmICgoYm9hcmRfY29uZmlnID09IEFEMTk4OF82U1RBQ0tfRElHKSB8fAorCQkJKGJvYXJkX2NvbmZpZyA9PSBBRDE5ODhfNlNUQUNLX0RJR19GUCkpIHsKIAkJCXNwZWMtPm11bHRpb3V0LmRpZ19vdXRfbmlkID0gQUQxOTg4X1NQRElGX09VVDsKIAkJCXNwZWMtPmRpZ19pbl9uaWQgPSBBRDE5ODhfU1BESUZfSU47CiAJCX0KQEAgLTMzOTksNyArMzU3NSw3IEBACiB9OwogI2VuZGlmCiAKLXN0YXRpYyBjb25zdCBjaGFyICphZDE4ODRfc2xhdmVfdm9sc1tdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhZDE4ODRfc2xhdmVfdm9sc1tdID0gewogCSJQQ00gUGxheWJhY2sgVm9sdW1lIiwKIAkiTWljIFBsYXliYWNrIFZvbHVtZSIsCiAJIk1vbm8gUGxheWJhY2sgVm9sdW1lIiwKQEAgLTM2MzcsNyArMzgxMyw3IEBACiAJQUQxOTg0X01PREVMUwogfTsKIAotc3RhdGljIGNvbnN0IGNoYXIgKmFkMTk4NF9tb2RlbHNbQUQxOTg0X01PREVMU10gPSB7CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFkMTk4NF9tb2RlbHNbQUQxOTg0X01PREVMU10gPSB7CiAJW0FEMTk4NF9CQVNJQ10JCT0gImJhc2ljIiwKIAlbQUQxOTg0X1RISU5LUEFEXQk9ICJ0aGlua3BhZCIsCiAJW0FEMTk4NF9ERUxMX0RFU0tUT1BdCT0gImRlbGxfZGVza3RvcCIsCkBAIC00MzA4LDcgKzQ0ODQsNyBAQAogCUFEMTg4NEFfTU9ERUxTCiB9OwogCi1zdGF0aWMgY29uc3QgY2hhciAqYWQxODg0YV9tb2RlbHNbQUQxODg0QV9NT0RFTFNdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhZDE4ODRhX21vZGVsc1tBRDE4ODRBX01PREVMU10gPSB7CiAJW0FEMTg4NEFfREVTS1RPUF0JPSAiZGVza3RvcCIsCiAJW0FEMTg4NEFfTEFQVE9QXQk9ICJsYXB0b3AiLAogCVtBRDE4ODRBX01PQklMRV0JPSAibW9iaWxlIiwKQEAgLTQ2OTYsNyArNDg3Miw3IEBACiAJQUQxODgyX01PREVMUwogfTsKIAotc3RhdGljIGNvbnN0IGNoYXIgKmFkMTg4Ml9tb2RlbHNbQUQxOTg2QV9NT0RFTFNdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhZDE4ODJfbW9kZWxzW0FEMTk4NkFfTU9ERUxTXSA9IHsKIAlbQUQxODgyXzNTVEFDS10JCT0gIjNzdGFjayIsCiAJW0FEMTg4Ml82U1RBQ0tdCQk9ICI2c3RhY2siLAogfTsKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9oZGEvcGF0Y2hfY2lycnVzLmMgYi9zb3VuZC9wY2kvaGRhL3BhdGNoX2NpcnJ1cy5jCmluZGV4IDE4YWYzOGUuLmEwN2IwMzEgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9oZGEvcGF0Y2hfY2lycnVzLmMKKysrIGIvc291bmQvcGNpL2hkYS9wYXRjaF9jaXJydXMuYwpAQCAtNDkwLDcgKzQ5MCw3IEBACiAgKiBjcmVhdGUgbWl4ZXIgY29udHJvbHMKICAqLwogCi1zdGF0aWMgY29uc3QgY2hhciAqZGlyX3NmeFsyXSA9IHsgIlBsYXliYWNrIiwgIkNhcHR1cmUiIH07CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGRpcl9zZnhbMl0gPSB7ICJQbGF5YmFjayIsICJDYXB0dXJlIiB9OwogCiBzdGF0aWMgaW50IGFkZF9tdXRlKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLCBjb25zdCBjaGFyICpuYW1lLCBpbnQgaW5kZXgsCiAJCSAgICB1bnNpZ25lZCBpbnQgcHZhbCwgaW50IGRpciwgc3RydWN0IHNuZF9rY29udHJvbCAqKmtjdGxwKQpAQCAtMTE1Niw3ICsxMTU2LDcgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGNvbnN0IGNoYXIgKmNzNDIweF9tb2RlbHNbQ1M0MjBYX01PREVMU10gPSB7CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGNzNDIweF9tb2RlbHNbQ1M0MjBYX01PREVMU10gPSB7CiAJW0NTNDIwWF9NQlA1M10gPSAibWJwNTMiLAogCVtDUzQyMFhfTUJQNTVdID0gIm1icDU1IiwKIAlbQ1M0MjBYX0lNQUMyN10gPSAiaW1hYzI3IiwKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9oZGEvcGF0Y2hfY21lZGlhLmMgYi9zb3VuZC9wY2kvaGRhL3BhdGNoX2NtZWRpYS5jCmluZGV4IGZmNjA5MDguLjFmOGJiY2QgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9oZGEvcGF0Y2hfY21lZGlhLmMKKysrIGIvc291bmQvcGNpL2hkYS9wYXRjaF9jbWVkaWEuYwpAQCAtNjA4LDcgKzYwOCw3IEBACiAvKgogICovCiAKLXN0YXRpYyBjb25zdCBjaGFyICpjbWk5ODgwX21vZGVsc1tDTUlfTU9ERUxTXSA9IHsKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgY21pOTg4MF9tb2RlbHNbQ01JX01PREVMU10gPSB7CiAJW0NNSV9NSU5JTUFMXQk9ICJtaW5pbWFsIiwKIAlbQ01JX01JTl9GUF0JPSAibWluX2ZwIiwKIAlbQ01JX0ZVTExdCT0gImZ1bGwiLApkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2hkYS9wYXRjaF9jb25leGFudC5jIGIvc291bmQvcGNpL2hkYS9wYXRjaF9jb25leGFudC5jCmluZGV4IGU5NjU4MWYuLmZiZTk3ZDMgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9oZGEvcGF0Y2hfY29uZXhhbnQuYworKysgYi9zb3VuZC9wY2kvaGRhL3BhdGNoX2NvbmV4YW50LmMKQEAgLTg1LDYgKzg1LDcgQEAKIAl1bnNpZ25lZCBpbnQgYXV0b19taWM7CiAJaW50IGF1dG9fbWljX2V4dDsJCS8qIGF1dG9jZmcuaW5wdXRzW10gaW5kZXggZm9yIGV4dCBtaWMgKi8KIAl1bnNpZ25lZCBpbnQgbmVlZF9kYWNfZml4OworCWhkYV9uaWRfdCBzbGF2ZV9kaWdfb3V0c1syXTsKIAogCS8qIGNhcHR1cmUgKi8KIAl1bnNpZ25lZCBpbnQgbnVtX2FkY19uaWRzOwpAQCAtMTI3LDYgKzEyOCw3IEBACiAJdW5zaWduZWQgaW50IGlkZWFwYWQ6MTsKIAl1bnNpZ25lZCBpbnQgdGhpbmtwYWQ6MTsKIAl1bnNpZ25lZCBpbnQgaHBfbGFwdG9wOjE7CisJdW5zaWduZWQgaW50IGFzdXM6MTsKIAogCXVuc2lnbmVkIGludCBleHRfbWljX3ByZXNlbnQ7CiAJdW5zaWduZWQgaW50IHJlY29yZGluZzsKQEAgLTM1Miw2ICszNTQsOCBAQAogCQkJaW5mby0+c3RyZWFtW1NORFJWX1BDTV9TVFJFQU1fQ0FQVFVSRV0ubmlkID0KIAkJCQlzcGVjLT5kaWdfaW5fbmlkOwogCQl9CisJCWlmIChzcGVjLT5zbGF2ZV9kaWdfb3V0c1swXSkKKwkJCWNvZGVjLT5zbGF2ZV9kaWdfb3V0cyA9IHNwZWMtPnNsYXZlX2RpZ19vdXRzOwogCX0KIAogCXJldHVybiAwOwpAQCAtNDAzLDEwICs0MDcsMTYgQEAKIAlzdHJ1Y3QgY29uZXhhbnRfc3BlYyAqc3BlYzsKIAlzdHJ1Y3QgY29uZXhhbnRfamFjayAqamFjazsKIAljb25zdCBjaGFyICpuYW1lOwotCWludCBlcnI7CisJaW50IGksIGVycjsKIAogCXNwZWMgPSBjb2RlYy0+c3BlYzsKIAlzbmRfYXJyYXlfaW5pdCgmc3BlYy0+amFja3MsIHNpemVvZigqamFjayksIDMyKTsKKworCWphY2sgPSBzcGVjLT5qYWNrcy5saXN0OworCWZvciAoaSA9IDA7IGkgPCBzcGVjLT5qYWNrcy51c2VkOyBpKyssIGphY2srKykKKwkJaWYgKGphY2stPm5pZCA9PSBuaWQpCisJCQlyZXR1cm4gMCA7IC8qIGFscmVhZHkgcHJlc2VudCAqLworCiAJamFjayA9IHNuZF9hcnJheV9uZXcoJnNwZWMtPmphY2tzKTsKIAluYW1lID0gKHR5cGUgPT0gU05EX0pBQ0tfSEVBRFBIT05FKSA/ICJIZWFkcGhvbmUiIDogIk1pYyIgOwogCkBAIC01MzcsMTMgKzU0NywxMyBAQAogfTsKICNlbmRpZgogCi1zdGF0aWMgY29uc3QgY2hhciAqc2xhdmVfdm9sc1tdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzbGF2ZV92b2xzW10gPSB7CiAJIkhlYWRwaG9uZSBQbGF5YmFjayBWb2x1bWUiLAogCSJTcGVha2VyIFBsYXliYWNrIFZvbHVtZSIsCiAJTlVMTAogfTsKIAotc3RhdGljIGNvbnN0IGNoYXIgKnNsYXZlX3N3c1tdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzbGF2ZV9zd3NbXSA9IHsKIAkiSGVhZHBob25lIFBsYXliYWNrIFN3aXRjaCIsCiAJIlNwZWFrZXIgUGxheWJhY2sgU3dpdGNoIiwKIAlOVUxMCkBAIC0xMTM0LDcgKzExNDQsNyBAQAogCUNYVDUwNDVfTU9ERUxTCiB9OwogCi1zdGF0aWMgY29uc3QgY2hhciAqY3h0NTA0NV9tb2RlbHNbQ1hUNTA0NV9NT0RFTFNdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBjeHQ1MDQ1X21vZGVsc1tDWFQ1MDQ1X01PREVMU10gPSB7CiAJW0NYVDUwNDVfTEFQVE9QX0hQU0VOU0VdCT0gImxhcHRvcC1ocHNlbnNlIiwKIAlbQ1hUNTA0NV9MQVBUT1BfTUlDU0VOU0VdCT0gImxhcHRvcC1taWNzZW5zZSIsCiAJW0NYVDUwNDVfTEFQVE9QX0hQTUlDU0VOU0VdCT0gImxhcHRvcC1ocG1pY3NlbnNlIiwKQEAgLTE1NzksNyArMTU4OSw3IEBACiAJQ1hUNTA0N19NT0RFTFMKIH07CiAKLXN0YXRpYyBjb25zdCBjaGFyICpjeHQ1MDQ3X21vZGVsc1tDWFQ1MDQ3X01PREVMU10gPSB7CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGN4dDUwNDdfbW9kZWxzW0NYVDUwNDdfTU9ERUxTXSA9IHsKIAlbQ1hUNTA0N19MQVBUT1BdCT0gImxhcHRvcCIsCiAJW0NYVDUwNDdfTEFQVE9QX0hQXQk9ICJsYXB0b3AtaHAiLAogCVtDWFQ1MDQ3X0xBUFRPUF9FQVBEXQk9ICJsYXB0b3AtZWFwZCIsCkBAIC0xOTk1LDcgKzIwMDUsNyBAQAogCUNYVDUwNTFfTU9ERUxTCiB9OwogCi1zdGF0aWMgY29uc3QgY2hhciAqY3h0NTA1MV9tb2RlbHNbQ1hUNTA1MV9NT0RFTFNdID0geworc3RhdGljIGNvbnN0IGNoYXIgKmNvbnN0IGN4dDUwNTFfbW9kZWxzW0NYVDUwNTFfTU9ERUxTXSA9IHsKIAlbQ1hUNTA1MV9MQVBUT1BdCT0gImxhcHRvcCIsCiAJW0NYVDUwNTFfSFBdCQk9ICJocCIsCiAJW0NYVDUwNTFfSFBfRFY2NzM2XQk9ICJocC1kdjY3MzYiLApAQCAtMjEwMCw3ICsyMTEwLDcgQEAKIHN0YXRpYyBoZGFfbmlkX3QgY3h0NTA2Nl9kYWNfbmlkc1sxXSA9IHsgMHgxMCB9Owogc3RhdGljIGhkYV9uaWRfdCBjeHQ1MDY2X2FkY19uaWRzWzNdID0geyAweDE0LCAweDE1LCAweDE2IH07CiBzdGF0aWMgaGRhX25pZF90IGN4dDUwNjZfY2Fwc3JjX25pZHNbMV0gPSB7IDB4MTcgfTsKLSNkZWZpbmUgQ1hUNTA2Nl9TUERJRl9PVVQJMHgyMQorc3RhdGljIGhkYV9uaWRfdCBjeHQ1MDY2X2RpZ291dF9waW5fbmlkc1syXSA9IHsgMHgyMCwgMHgyMiB9OwogCiAvKiBPTFBDJ3MgbWljcm9waG9uZSBwb3J0IGlzIERDIGNvdXBsZWQgZm9yIHVzZSB3aXRoIGV4dGVybmFsIHNlbnNvcnMsCiAgKiB0aGVyZWZvcmUgd2UgdXNlIGEgNTAlIG1pYyBiaWFzIGluIG9yZGVyIHRvIGNlbnRlciB0aGUgaW5wdXQgc2lnbmFsIHdpdGgKQEAgLTIzMTIsNiArMjMyMiwxOSBAQAogCX0KIH0KIAorCisvKiB0b2dnbGUgaW5wdXQgb2YgYnVpbHQtaW4gZGlnaXRhbCBtaWMgYW5kIG1pYyBqYWNrIGFwcHJvcHJpYXRlbHkgKi8KK3N0YXRpYyB2b2lkIGN4dDUwNjZfYXN1c19hdXRvbWljKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjKQoreworCXVuc2lnbmVkIGludCBwcmVzZW50OworCisJcHJlc2VudCA9IHNuZF9oZGFfamFja19kZXRlY3QoY29kZWMsIDB4MWIpOworCXNuZF9wcmludGRkKCJDWFQ1MDY2OiBleHRlcm5hbCBtaWNyb3Bob25lIHByZXNlbnQ9JWRcbiIsIHByZXNlbnQpOworCXNuZF9oZGFfY29kZWNfd3JpdGUoY29kZWMsIDB4MTcsIDAsIEFDX1ZFUkJfU0VUX0NPTk5FQ1RfU0VMLAorCQkJICAgIHByZXNlbnQgPyAxIDogMCk7Cit9CisKKwogLyogdG9nZ2xlIGlucHV0IG9mIGJ1aWx0LWluIGRpZ2l0YWwgbWljIGFuZCBtaWMgamFjayBhcHByb3ByaWF0ZWx5ICovCiBzdGF0aWMgdm9pZCBjeHQ1MDY2X2hwX2xhcHRvcF9hdXRvbWljKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjKQogewpAQCAtMjM4Nyw2ICsyNDEwLDIzIEBACiAJY3h0NTA2Nl91cGRhdGVfc3BlYWtlcihjb2RlYyk7CiB9CiAKKy8qIERpc3BhdGNoIHRoZSByaWdodCBtaWMgYXV0b3N3aXRjaCBmdW5jdGlvbiAqLworc3RhdGljIHZvaWQgY3h0NTA2Nl9hdXRvbWljKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjKQoreworCXN0cnVjdCBjb25leGFudF9zcGVjICpzcGVjID0gY29kZWMtPnNwZWM7CisKKwlpZiAoc3BlYy0+ZGVsbF92b3N0cm8pCisJCWN4dDUwNjZfdm9zdHJvX2F1dG9taWMoY29kZWMpOworCWVsc2UgaWYgKHNwZWMtPmlkZWFwYWQpCisJCWN4dDUwNjZfaWRlYXBhZF9hdXRvbWljKGNvZGVjKTsKKwllbHNlIGlmIChzcGVjLT50aGlua3BhZCkKKwkJY3h0NTA2Nl90aGlua3BhZF9hdXRvbWljKGNvZGVjKTsKKwllbHNlIGlmIChzcGVjLT5ocF9sYXB0b3ApCisJCWN4dDUwNjZfaHBfbGFwdG9wX2F1dG9taWMoY29kZWMpOworCWVsc2UgaWYgKHNwZWMtPmFzdXMpCisJCWN4dDUwNjZfYXN1c19hdXRvbWljKGNvZGVjKTsKK30KKwogLyogdW5zb2xpY2l0ZWQgZXZlbnQgZm9yIGphY2sgc2Vuc2luZyAqLwogc3RhdGljIHZvaWQgY3h0NTA2Nl9vbHBjX3Vuc29sX2V2ZW50KHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLCB1bnNpZ25lZCBpbnQgcmVzKQogewpAQCAtMjQwNSw2MCArMjQ0NSwxOSBAQAogfQogCiAvKiB1bnNvbGljaXRlZCBldmVudCBmb3IgamFjayBzZW5zaW5nICovCi1zdGF0aWMgdm9pZCBjeHQ1MDY2X3Zvc3Ryb19ldmVudChzdHJ1Y3QgaGRhX2NvZGVjICpjb2RlYywgdW5zaWduZWQgaW50IHJlcykKK3N0YXRpYyB2b2lkIGN4dDUwNjZfdW5zb2xfZXZlbnQoc3RydWN0IGhkYV9jb2RlYyAqY29kZWMsIHVuc2lnbmVkIGludCByZXMpCiB7Ci0Jc25kX3ByaW50ZGQoIkNYVDUwNjZfdm9zdHJvOiB1bnNvbCBldmVudCAleCAoJXgpXG4iLCByZXMsIHJlcyA+PiAyNik7CisJc25kX3ByaW50ZGQoIkNYVDUwNjY6IHVuc29sIGV2ZW50ICV4ICgleClcbiIsIHJlcywgcmVzID4+IDI2KTsKIAlzd2l0Y2ggKHJlcyA+PiAyNikgewogCWNhc2UgQ09ORVhBTlRfSFBfRVZFTlQ6CiAJCWN4dDUwNjZfaHBfYXV0b211dGUoY29kZWMpOwogCQlicmVhazsKIAljYXNlIENPTkVYQU5UX01JQ19FVkVOVDoKLQkJY3h0NTA2Nl92b3N0cm9fYXV0b21pYyhjb2RlYyk7CisJCWN4dDUwNjZfYXV0b21pYyhjb2RlYyk7CiAJCWJyZWFrOwogCX0KIH0KIAotLyogdW5zb2xpY2l0ZWQgZXZlbnQgZm9yIGphY2sgc2Vuc2luZyAqLwotc3RhdGljIHZvaWQgY3h0NTA2Nl9pZGVhcGFkX2V2ZW50KHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLCB1bnNpZ25lZCBpbnQgcmVzKQotewotCXNuZF9wcmludGRkKCJDWFQ1MDY2X2lkZWFwYWQ6IHVuc29sIGV2ZW50ICV4ICgleClcbiIsIHJlcywgcmVzID4+IDI2KTsKLQlzd2l0Y2ggKHJlcyA+PiAyNikgewotCWNhc2UgQ09ORVhBTlRfSFBfRVZFTlQ6Ci0JCWN4dDUwNjZfaHBfYXV0b211dGUoY29kZWMpOwotCQlicmVhazsKLQljYXNlIENPTkVYQU5UX01JQ19FVkVOVDoKLQkJY3h0NTA2Nl9pZGVhcGFkX2F1dG9taWMoY29kZWMpOwotCQlicmVhazsKLQl9Ci19Ci0KLS8qIHVuc29saWNpdGVkIGV2ZW50IGZvciBqYWNrIHNlbnNpbmcgKi8KLXN0YXRpYyB2b2lkIGN4dDUwNjZfaHBfbGFwdG9wX2V2ZW50KHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLCB1bnNpZ25lZCBpbnQgcmVzKQotewotCXNuZF9wcmludGRkKCJDWFQ1MDY2X2hwX2xhcHRvcDogdW5zb2wgZXZlbnQgJXggKCV4KVxuIiwgcmVzLCByZXMgPj4gMjYpOwotCXN3aXRjaCAocmVzID4+IDI2KSB7Ci0JY2FzZSBDT05FWEFOVF9IUF9FVkVOVDoKLQkJY3h0NTA2Nl9ocF9hdXRvbXV0ZShjb2RlYyk7Ci0JCWJyZWFrOwotCWNhc2UgQ09ORVhBTlRfTUlDX0VWRU5UOgotCQljeHQ1MDY2X2hwX2xhcHRvcF9hdXRvbWljKGNvZGVjKTsKLQkJYnJlYWs7Ci0JfQotfQotCi0vKiB1bnNvbGljaXRlZCBldmVudCBmb3IgamFjayBzZW5zaW5nICovCi1zdGF0aWMgdm9pZCBjeHQ1MDY2X3RoaW5rcGFkX2V2ZW50KHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLCB1bnNpZ25lZCBpbnQgcmVzKQotewotCXNuZF9wcmludGRkKCJDWFQ1MDY2X3RoaW5rcGFkOiB1bnNvbCBldmVudCAleCAoJXgpXG4iLCByZXMsIHJlcyA+PiAyNik7Ci0Jc3dpdGNoIChyZXMgPj4gMjYpIHsKLQljYXNlIENPTkVYQU5UX0hQX0VWRU5UOgotCQljeHQ1MDY2X2hwX2F1dG9tdXRlKGNvZGVjKTsKLQkJYnJlYWs7Ci0JY2FzZSBDT05FWEFOVF9NSUNfRVZFTlQ6Ci0JCWN4dDUwNjZfdGhpbmtwYWRfYXV0b21pYyhjb2RlYyk7Ci0JCWJyZWFrOwotCX0KLX0KIAogc3RhdGljIGNvbnN0IHN0cnVjdCBoZGFfaW5wdXRfbXV4IGN4dDUwNjZfYW5hbG9nX21pY19ib29zdCA9IHsKIAkubnVtX2l0ZW1zID0gNSwKQEAgLTI2MzMsNiArMjYzMiwyNyBAQAogCXNwZWMtPnJlY29yZGluZyA9IDA7CiB9CiAKK3N0YXRpYyB2b2lkIGNvbmV4YW50X2NoZWNrX2RpZ19vdXRzKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLAorCQkJCSAgICBoZGFfbmlkX3QgKmRpZ19waW5zLAorCQkJCSAgICBpbnQgbnVtX3BpbnMpCit7CisJc3RydWN0IGNvbmV4YW50X3NwZWMgKnNwZWMgPSBjb2RlYy0+c3BlYzsKKwloZGFfbmlkX3QgKm5pZF9sb2MgPSAmc3BlYy0+bXVsdGlvdXQuZGlnX291dF9uaWQ7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgbnVtX3BpbnM7IGkrKywgZGlnX3BpbnMrKykgeworCQl1bnNpZ25lZCBpbnQgY2ZnID0gc25kX2hkYV9jb2RlY19nZXRfcGluY2ZnKGNvZGVjLCAqZGlnX3BpbnMpOworCQlpZiAoZ2V0X2RlZmNmZ19jb25uZWN0KGNmZykgPT0gQUNfSkFDS19QT1JUX05PTkUpCisJCQljb250aW51ZTsKKwkJaWYgKHNuZF9oZGFfZ2V0X2Nvbm5lY3Rpb25zKGNvZGVjLCAqZGlnX3BpbnMsIG5pZF9sb2MsIDEpICE9IDEpCisJCQljb250aW51ZTsKKwkJaWYgKHNwZWMtPnNsYXZlX2RpZ19vdXRzWzBdKQorCQkJbmlkX2xvYysrOworCQllbHNlCisJCQluaWRfbG9jID0gc3BlYy0+c2xhdmVfZGlnX291dHM7CisJfQorfQorCiBzdGF0aWMgc3RydWN0IGhkYV9pbnB1dF9tdXggY3h0NTA2Nl9jYXB0dXJlX3NvdXJjZSA9IHsKIAkubnVtX2l0ZW1zID0gNCwKIAkuaXRlbXMgPSB7CkBAIC0zMDM5LDIwICszMDU5LDExIEBACiAvKiBpbml0aWFsaXplIGphY2stc2Vuc2luZywgdG9vICovCiBzdGF0aWMgaW50IGN4dDUwNjZfaW5pdChzdHJ1Y3QgaGRhX2NvZGVjICpjb2RlYykKIHsKLQlzdHJ1Y3QgY29uZXhhbnRfc3BlYyAqc3BlYyA9IGNvZGVjLT5zcGVjOwotCiAJc25kX3ByaW50ZGQoIkNYVDUwNjY6IGluaXRcbiIpOwogCWNvbmV4YW50X2luaXQoY29kZWMpOwogCWlmIChjb2RlYy0+cGF0Y2hfb3BzLnVuc29sX2V2ZW50KSB7CiAJCWN4dDUwNjZfaHBfYXV0b211dGUoY29kZWMpOwotCQlpZiAoc3BlYy0+ZGVsbF92b3N0cm8pCi0JCQljeHQ1MDY2X3Zvc3Ryb19hdXRvbWljKGNvZGVjKTsKLQkJZWxzZSBpZiAoc3BlYy0+aWRlYXBhZCkKLQkJCWN4dDUwNjZfaWRlYXBhZF9hdXRvbWljKGNvZGVjKTsKLQkJZWxzZSBpZiAoc3BlYy0+dGhpbmtwYWQpCi0JCQljeHQ1MDY2X3RoaW5rcGFkX2F1dG9taWMoY29kZWMpOwotCQllbHNlIGlmIChzcGVjLT5ocF9sYXB0b3ApCi0JCQljeHQ1MDY2X2hwX2xhcHRvcF9hdXRvbWljKGNvZGVjKTsKKwkJY3h0NTA2Nl9hdXRvbWljKGNvZGVjKTsKIAl9CiAJY3h0NTA2Nl9zZXRfbWljX2Jvb3N0KGNvZGVjKTsKIAlyZXR1cm4gMDsKQEAgLTMwODAsMTcgKzMwOTEsMTkgQEAKIAlDWFQ1MDY2X0RFTExfVk9TVFJPLAkvKiBEZWxsIFZvc3RybyAxMDE1aSAqLwogCUNYVDUwNjZfSURFQVBBRCwJLyogTGVub3ZvIElkZWFQYWQgVTE1MCAqLwogCUNYVDUwNjZfVEhJTktQQUQsCS8qIExlbm92byBUaGlua1BhZCBUNDEwcywgb3RoZXJzPyAqLworCUNYVDUwNjZfQVNVUywJCS8qIEFzdXMgSzUySlUsIExlbm92byBHNTYwIC0gSW50IG1pYyBhdCAweDFhIGFuZCBFeHQgbWljIGF0IDB4MWIgKi8KIAlDWFQ1MDY2X0hQX0xBUFRPUCwgICAgICAvKiBIUCBMYXB0b3AgKi8KIAlDWFQ1MDY2X01PREVMUwogfTsKIAotc3RhdGljIGNvbnN0IGNoYXIgKmN4dDUwNjZfbW9kZWxzW0NYVDUwNjZfTU9ERUxTXSA9IHsKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgY3h0NTA2Nl9tb2RlbHNbQ1hUNTA2Nl9NT0RFTFNdID0gewogCVtDWFQ1MDY2X0xBUFRPUF0JPSAibGFwdG9wIiwKIAlbQ1hUNTA2Nl9ERUxMX0xBUFRPUF0JPSAiZGVsbC1sYXB0b3AiLAogCVtDWFQ1MDY2X09MUENfWE9fMV81XQk9ICJvbHBjLXhvLTFfNSIsCiAJW0NYVDUwNjZfREVMTF9WT1NUUk9dCT0gImRlbGwtdm9zdHJvIiwKIAlbQ1hUNTA2Nl9JREVBUEFEXQk9ICJpZGVhcGFkIiwKIAlbQ1hUNTA2Nl9USElOS1BBRF0JPSAidGhpbmtwYWQiLAorCVtDWFQ1MDY2X0FTVVNdCQk9ICJhc3VzIiwKIAlbQ1hUNTA2Nl9IUF9MQVBUT1BdCT0gImhwLWxhcHRvcCIsCiB9OwogCkBAIC0zMTAyLDcgKzMxMTUsOSBAQAogCVNORF9QQ0lfUVVJUksoMHgxMDI4LCAweDA0MDIsICJEZWxsIFZvc3RybyIsIENYVDUwNjZfREVMTF9WT1NUUk8pLAogCVNORF9QQ0lfUVVJUksoMHgxMDI4LCAweDA0MDgsICJEZWxsIEluc3Bpcm9uIE9uZSAxOVQiLCBDWFQ1MDY2X0lERUFQQUQpLAogCVNORF9QQ0lfUVVJUksoMHgxMDNjLCAweDM2MGIsICJIUCBHNjAiLCBDWFQ1MDY2X0hQX0xBUFRPUCksCi0JU05EX1BDSV9RVUlSSygweDEwNDMsIDB4MTNmMywgIkFzdXMgQTUySiIsIENYVDUwNjZfSFBfTEFQVE9QKSwKKwlTTkRfUENJX1FVSVJLKDB4MTA0MywgMHgxM2YzLCAiQXN1cyBBNTJKIiwgQ1hUNTA2Nl9BU1VTKSwKKwlTTkRfUENJX1FVSVJLKDB4MTA0MywgMHgxNjQzLCAiQXN1cyBLNTJKVSIsIENYVDUwNjZfQVNVUyksCisJU05EX1BDSV9RVUlSSygweDEwNDMsIDB4MTk5MywgIkFzdXMgVTUwRiIsIENYVDUwNjZfQVNVUyksCiAJU05EX1BDSV9RVUlSSygweDExNzksIDB4ZmYxZSwgIlRvc2hpYmEgU2F0ZWxsaXRlIEM2NTBEIiwgQ1hUNTA2Nl9JREVBUEFEKSwKIAlTTkRfUENJX1FVSVJLKDB4MTE3OSwgMHhmZjUwLCAiVG9zaGliYSBTYXRlbGxpdGUgUDUwMC1QU1BHU0MtMDE4MDBUIiwgQ1hUNTA2Nl9PTFBDX1hPXzFfNSksCiAJU05EX1BDSV9RVUlSSygweDExNzksIDB4ZmZlMCwgIlRvc2hpYmEgU2F0ZWxsaXRlIFBybyBUMTMwLTE1RiIsIENYVDUwNjZfT0xQQ19YT18xXzUpLApAQCAtMzExMSw3ICszMTI2LDkgQEAKIAlTTkRfUENJX1FVSVJLKDB4MTUyZCwgMHgwODMzLCAiT0xQQyBYTy0xLjUiLCBDWFQ1MDY2X09MUENfWE9fMV81KSwKIAlTTkRfUENJX1FVSVJLKDB4MTdhYSwgMHgyMGYyLCAiTGVub3ZvIFQ0MDBzIiwgQ1hUNTA2Nl9USElOS1BBRCksCiAJU05EX1BDSV9RVUlSSygweDE3YWEsIDB4MjFjNSwgIlRoaW5rcGFkIEVkZ2UgMTMiLCBDWFQ1MDY2X1RISU5LUEFEKSwKKwlTTkRfUENJX1FVSVJLKDB4MTdhYSwgMHgyMWM2LCAiVGhpbmtwYWQgRWRnZSAxMyIsIENYVDUwNjZfQVNVUyksCiAgCVNORF9QQ0lfUVVJUksoMHgxN2FhLCAweDIxNWUsICJMZW5vdm8gVGhpbmtwYWQiLCBDWFQ1MDY2X1RISU5LUEFEKSwKKwlTTkRfUENJX1FVSVJLKDB4MTdhYSwgMHgzOGFmLCAiTGVub3ZvIEc1NjAiLCBDWFQ1MDY2X0FTVVMpLAogCVNORF9QQ0lfUVVJUktfVkVORE9SKDB4MTdhYSwgIkxlbm92byIsIENYVDUwNjZfSURFQVBBRCksIC8qIEZhbGxiYWNrIGZvciBMZW5vdm9zIHdpdGhvdXQgZG9jayBtaWMgKi8KIAl7fQogfTsKQEAgLTMxMzMsNyArMzE1MCw4IEBACiAJc3BlYy0+bXVsdGlvdXQubWF4X2NoYW5uZWxzID0gMjsKIAlzcGVjLT5tdWx0aW91dC5udW1fZGFjcyA9IEFSUkFZX1NJWkUoY3h0NTA2Nl9kYWNfbmlkcyk7CiAJc3BlYy0+bXVsdGlvdXQuZGFjX25pZHMgPSBjeHQ1MDY2X2RhY19uaWRzOwotCXNwZWMtPm11bHRpb3V0LmRpZ19vdXRfbmlkID0gQ1hUNTA2Nl9TUERJRl9PVVQ7CisJY29uZXhhbnRfY2hlY2tfZGlnX291dHMoY29kZWMsIGN4dDUwNjZfZGlnb3V0X3Bpbl9uaWRzLAorCSAgICBBUlJBWV9TSVpFKGN4dDUwNjZfZGlnb3V0X3Bpbl9uaWRzKSk7CiAJc3BlYy0+bnVtX2FkY19uaWRzID0gMTsKIAlzcGVjLT5hZGNfbmlkcyA9IGN4dDUwNjZfYWRjX25pZHM7CiAJc3BlYy0+Y2Fwc3JjX25pZHMgPSBjeHQ1MDY2X2NhcHNyY19uaWRzOwpAQCAtMzE2NywxNyArMzE4NSwyMCBAQAogCQlzcGVjLT5udW1faW5pdF92ZXJicysrOwogCQlzcGVjLT5kZWxsX2F1dG9tdXRlID0gMTsKIAkJYnJlYWs7CisJY2FzZSBDWFQ1MDY2X0FTVVM6CiAJY2FzZSBDWFQ1MDY2X0hQX0xBUFRPUDoKIAkJY29kZWMtPnBhdGNoX29wcy5pbml0ID0gY3h0NTA2Nl9pbml0OwotCQljb2RlYy0+cGF0Y2hfb3BzLnVuc29sX2V2ZW50ID0gY3h0NTA2Nl9ocF9sYXB0b3BfZXZlbnQ7CisJCWNvZGVjLT5wYXRjaF9vcHMudW5zb2xfZXZlbnQgPSBjeHQ1MDY2X3Vuc29sX2V2ZW50OwogCQlzcGVjLT5pbml0X3ZlcmJzW3NwZWMtPm51bV9pbml0X3ZlcmJzXSA9CiAJCQljeHQ1MDY2X2luaXRfdmVyYnNfaHBfbGFwdG9wOwogCQlzcGVjLT5udW1faW5pdF92ZXJicysrOwotCQlzcGVjLT5ocF9sYXB0b3AgPSAxOworCQlzcGVjLT5ocF9sYXB0b3AgPSBib2FyZF9jb25maWcgPT0gQ1hUNTA2Nl9IUF9MQVBUT1A7CisJCXNwZWMtPmFzdXMgPSBib2FyZF9jb25maWcgPT0gQ1hUNTA2Nl9BU1VTOwogCQlzcGVjLT5taXhlcnNbc3BlYy0+bnVtX21peGVycysrXSA9IGN4dDUwNjZfbWl4ZXJfbWFzdGVyOwogCQlzcGVjLT5taXhlcnNbc3BlYy0+bnVtX21peGVycysrXSA9IGN4dDUwNjZfbWl4ZXJzOwogCQkvKiBubyBTL1BESUYgb3V0ICovCi0JCXNwZWMtPm11bHRpb3V0LmRpZ19vdXRfbmlkID0gMDsKKwkJaWYgKGJvYXJkX2NvbmZpZyA9PSBDWFQ1MDY2X0hQX0xBUFRPUCkKKwkJCXNwZWMtPm11bHRpb3V0LmRpZ19vdXRfbmlkID0gMDsKIAkJLyogaW5wdXQgc291cmNlIGF1dG9tYXRpY2FsbHkgc2VsZWN0ZWQgKi8KIAkJc3BlYy0+aW5wdXRfbXV4ID0gTlVMTDsKIAkJc3BlYy0+cG9ydF9kX21vZGUgPSAwOwpAQCAtMzIwNyw3ICszMjI4LDcgQEAKIAkJYnJlYWs7CiAJY2FzZSBDWFQ1MDY2X0RFTExfVk9TVFJPOgogCQljb2RlYy0+cGF0Y2hfb3BzLmluaXQgPSBjeHQ1MDY2X2luaXQ7Ci0JCWNvZGVjLT5wYXRjaF9vcHMudW5zb2xfZXZlbnQgPSBjeHQ1MDY2X3Zvc3Ryb19ldmVudDsKKwkJY29kZWMtPnBhdGNoX29wcy51bnNvbF9ldmVudCA9IGN4dDUwNjZfdW5zb2xfZXZlbnQ7CiAJCXNwZWMtPmluaXRfdmVyYnNbMF0gPSBjeHQ1MDY2X2luaXRfdmVyYnNfdm9zdHJvOwogCQlzcGVjLT5taXhlcnNbc3BlYy0+bnVtX21peGVycysrXSA9IGN4dDUwNjZfbWl4ZXJfbWFzdGVyX29scGM7CiAJCXNwZWMtPm1peGVyc1tzcGVjLT5udW1fbWl4ZXJzKytdID0gY3h0NTA2Nl9taXhlcnM7CkBAIC0zMjI0LDcgKzMyNDUsNyBAQAogCQlicmVhazsKIAljYXNlIENYVDUwNjZfSURFQVBBRDoKIAkJY29kZWMtPnBhdGNoX29wcy5pbml0ID0gY3h0NTA2Nl9pbml0OwotCQljb2RlYy0+cGF0Y2hfb3BzLnVuc29sX2V2ZW50ID0gY3h0NTA2Nl9pZGVhcGFkX2V2ZW50OworCQljb2RlYy0+cGF0Y2hfb3BzLnVuc29sX2V2ZW50ID0gY3h0NTA2Nl91bnNvbF9ldmVudDsKIAkJc3BlYy0+bWl4ZXJzW3NwZWMtPm51bV9taXhlcnMrK10gPSBjeHQ1MDY2X21peGVyX21hc3RlcjsKIAkJc3BlYy0+bWl4ZXJzW3NwZWMtPm51bV9taXhlcnMrK10gPSBjeHQ1MDY2X21peGVyczsKIAkJc3BlYy0+aW5pdF92ZXJic1swXSA9IGN4dDUwNjZfaW5pdF92ZXJic19pZGVhcGFkOwpAQCAtMzI0MCw3ICszMjYxLDcgQEAKIAkJYnJlYWs7CiAJY2FzZSBDWFQ1MDY2X1RISU5LUEFEOgogCQljb2RlYy0+cGF0Y2hfb3BzLmluaXQgPSBjeHQ1MDY2X2luaXQ7Ci0JCWNvZGVjLT5wYXRjaF9vcHMudW5zb2xfZXZlbnQgPSBjeHQ1MDY2X3RoaW5rcGFkX2V2ZW50OworCQljb2RlYy0+cGF0Y2hfb3BzLnVuc29sX2V2ZW50ID0gY3h0NTA2Nl91bnNvbF9ldmVudDsKIAkJc3BlYy0+bWl4ZXJzW3NwZWMtPm51bV9taXhlcnMrK10gPSBjeHQ1MDY2X21peGVyX21hc3RlcjsKIAkJc3BlYy0+bWl4ZXJzW3NwZWMtPm51bV9taXhlcnMrK10gPSBjeHQ1MDY2X21peGVyczsKIAkJc3BlYy0+aW5pdF92ZXJic1swXSA9IGN4dDUwNjZfaW5pdF92ZXJic190aGlua3BhZDsKQEAgLTM3NDYsNyArMzc2Nyw3IEBACiAJc3RydWN0IGNvbmV4YW50X3NwZWMgKnNwZWMgPSBjb2RlYy0+c3BlYzsKIAlpbnQgaSwgZXJyOwogCWludCBudW1fbGluZSA9IDAsIG51bV9ocCA9IDAsIG51bV9zcGsgPSAwOwotCXN0YXRpYyBjb25zdCBjaGFyICp0ZXh0c1szXSA9IHsgIkZyb250IiwgIlN1cnJvdW5kIiwgIkNMRkUiIH07CisJc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB0ZXh0c1szXSA9IHsgIkZyb250IiwgIlN1cnJvdW5kIiwgIkNMRkUiIH07CiAKIAlpZiAoc3BlYy0+ZGFjX2luZm9fZmlsbGVkID09IDEpCiAJCXJldHVybiBjeF9hdXRvX2FkZF9wYl92b2x1bWUoY29kZWMsIHNwZWMtPmRhY19pbmZvWzBdLmRhYywKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9oZGEvcGF0Y2hfaGRtaS5jIGIvc291bmQvcGNpL2hkYS9wYXRjaF9oZG1pLmMKaW5kZXggZjI5Yjk3Yi4uYTU4NzY3NyAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2hkYS9wYXRjaF9oZG1pLmMKKysrIGIvc291bmQvcGNpL2hkYS9wYXRjaF9oZG1pLmMKQEAgLTY0Miw2ICs2NDIsNyBAQAogCQkJaGRtaV9haS0+dmVyCQk9IDB4MDE7CiAJCQloZG1pX2FpLT5sZW4JCT0gMHgwYTsKIAkJCWhkbWlfYWktPkNDMDJfQ1Q0Nwk9IGNoYW5uZWxzIC0gMTsKKwkJCWhkbWlfYWktPkNBCQk9IGNhOwogCQkJaGRtaV9jaGVja3N1bV9hdWRpb19pbmZvZnJhbWUoaGRtaV9haSk7CiAJCX0gZWxzZSBpZiAoc3BlYy0+c2lua19lbGRbaV0uY29ubl90eXBlID09IDEpIHsgLyogRGlzcGxheVBvcnQgKi8KIAkJCXN0cnVjdCBkcF9hdWRpb19pbmZvZnJhbWUgKmRwX2FpOwpAQCAtNjUxLDYgKzY1Miw3IEBACiAJCQlkcF9haS0+bGVuCQk9IDB4MWI7CiAJCQlkcF9haS0+dmVyCQk9IDB4MTEgPDwgMjsKIAkJCWRwX2FpLT5DQzAyX0NUNDcJPSBjaGFubmVscyAtIDE7CisJCQlkcF9haS0+Q0EJCT0gY2E7CiAJCX0gZWxzZSB7CiAJCQlzbmRfcHJpbnRkKCJIRE1JOiB1bmtub3duIGNvbm5lY3Rpb24gdHlwZSBhdCBwaW4gJWRcbiIsCiAJCQkJICAgcGluX25pZCk7CkBAIC04MTcsNiArODE5LDcgQEAKIAlzdHJ1Y3QgaGRtaV9zcGVjICpzcGVjID0gY29kZWMtPnNwZWM7CiAJc3RydWN0IGhkbWlfZWxkICplbGQ7CiAJc3RydWN0IGhkYV9wY21fc3RyZWFtICpjb2RlY19wYXJzOworCXN0cnVjdCBzbmRfcGNtX3J1bnRpbWUgKnJ1bnRpbWUgPSBzdWJzdHJlYW0tPnJ1bnRpbWU7CiAJdW5zaWduZWQgaW50IGlkeDsKIAogCWZvciAoaWR4ID0gMDsgaWR4IDwgc3BlYy0+bnVtX2N2dHM7IGlkeCsrKQpAQCAtODQ0LDYgKzg0NywxNCBAQAogCQloaW5mby0+Zm9ybWF0cyA9IGNvZGVjX3BhcnMtPmZvcm1hdHM7CiAJCWhpbmZvLT5tYXhicHMgPSBjb2RlY19wYXJzLT5tYXhicHM7CiAJfQorCS8qIHN0b3JlIHRoZSB1cGRhdGVkIHBhcmFtZXRlcnMgKi8KKwlydW50aW1lLT5ody5jaGFubmVsc19taW4gPSBoaW5mby0+Y2hhbm5lbHNfbWluOworCXJ1bnRpbWUtPmh3LmNoYW5uZWxzX21heCA9IGhpbmZvLT5jaGFubmVsc19tYXg7CisJcnVudGltZS0+aHcuZm9ybWF0cyA9IGhpbmZvLT5mb3JtYXRzOworCXJ1bnRpbWUtPmh3LnJhdGVzID0gaGluZm8tPnJhdGVzOworCisJc25kX3BjbV9od19jb25zdHJhaW50X3N0ZXAoc3Vic3RyZWFtLT5ydW50aW1lLCAwLAorCQkJCSAgIFNORFJWX1BDTV9IV19QQVJBTV9DSEFOTkVMUywgMik7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTEyMzgsNiArMTI0OSw5IEBACiAJCXNuZF9wY21faHdfY29uc3RyYWludF9saXN0KHN1YnN0cmVhbS0+cnVudGltZSwgMCwKIAkJCQlTTkRSVl9QQ01fSFdfUEFSQU1fQ0hBTk5FTFMsCiAJCQkJaHdfY29uc3RyYWludHNfY2hhbm5lbHMpOworCX0gZWxzZSB7CisJCXNuZF9wY21faHdfY29uc3RyYWludF9zdGVwKHN1YnN0cmVhbS0+cnVudGltZSwgMCwKKwkJCQkJICAgU05EUlZfUENNX0hXX1BBUkFNX0NIQU5ORUxTLCAyKTsKIAl9CiAKIAlyZXR1cm4gc25kX2hkYV9tdWx0aV9vdXRfZGlnX29wZW4oY29kZWMsICZzcGVjLT5tdWx0aW91dCk7CmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvaGRhL3BhdGNoX3JlYWx0ZWsuYyBiL3NvdW5kL3BjaS9oZGEvcGF0Y2hfcmVhbHRlay5jCmluZGV4IDUxYzA4ZWQuLjMzMjhhMjUgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9oZGEvcGF0Y2hfcmVhbHRlay5jCisrKyBiL3NvdW5kL3BjaS9oZGEvcGF0Y2hfcmVhbHRlay5jCkBAIC0zMDMsNiArMzAzLDggQEAKIAl1bnNpZ25lZCBpbnQgIGZpeHVwOjE7IC8qIE1lYW5zIHRoYXQgdGhpcyBza3UgaXMgc2V0IGJ5IGRyaXZlciwgbm90IHJlYWQgZnJvbSBodyAqLwogfTsKIAorc3RydWN0IGFsY19maXh1cDsKKwogc3RydWN0IGFsY19zcGVjIHsKIAkvKiBjb2RlYyBwYXJhbWV0ZXJpemF0aW9uICovCiAJc3RydWN0IHNuZF9rY29udHJvbF9uZXcgKm1peGVyc1s1XTsJLyogbWl4ZXIgYXJyYXlzICovCkBAIC00MDQsNiArNDA2LDExIEBACiAJLyogZm9yIFBMTCBmaXggKi8KIAloZGFfbmlkX3QgcGxsX25pZDsKIAl1bnNpZ25lZCBpbnQgcGxsX2NvZWZfaWR4LCBwbGxfY29lZl9iaXQ7CisKKwkvKiBmaXgtdXAgbGlzdCAqLworCWludCBmaXh1cF9pZDsKKwljb25zdCBzdHJ1Y3QgYWxjX2ZpeHVwICpmaXh1cF9saXN0OworCWNvbnN0IGNoYXIgKmZpeHVwX25hbWU7CiB9OwogCiAvKgpAQCAtMTY4Myw4OCArMTY5MCwxMzMgQEAKIH07CiAKIHN0cnVjdCBhbGNfZml4dXAgewotCXVuc2lnbmVkIGludCBza3U7Ci0JY29uc3Qgc3RydWN0IGFsY19waW5jZmcgKnBpbnM7Ci0JY29uc3Qgc3RydWN0IGhkYV92ZXJiICp2ZXJiczsKLQl2b2lkICgqZnVuYykoc3RydWN0IGhkYV9jb2RlYyAqY29kZWMsIGNvbnN0IHN0cnVjdCBhbGNfZml4dXAgKmZpeCwKLQkJICAgICBpbnQgcHJlX2luaXQpOworCWludCB0eXBlOworCWJvb2wgY2hhaW5lZDsKKwlpbnQgY2hhaW5faWQ7CisJdW5pb24geworCQl1bnNpZ25lZCBpbnQgc2t1OworCQljb25zdCBzdHJ1Y3QgYWxjX3BpbmNmZyAqcGluczsKKwkJY29uc3Qgc3RydWN0IGhkYV92ZXJiICp2ZXJiczsKKwkJdm9pZCAoKmZ1bmMpKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLAorCQkJICAgICBjb25zdCBzdHJ1Y3QgYWxjX2ZpeHVwICpmaXgsCisJCQkgICAgIGludCBhY3Rpb24pOworCX0gdjsKIH07CiAKLXN0YXRpYyB2b2lkIF9fYWxjX3BpY2tfZml4dXAoc3RydWN0IGhkYV9jb2RlYyAqY29kZWMsCi0JCQkgICAgIGNvbnN0IHN0cnVjdCBhbGNfZml4dXAgKmZpeCwKLQkJCSAgICAgY29uc3QgY2hhciAqbW9kZWxuYW1lLAotCQkJICAgICBpbnQgcHJlX2luaXQpCi17Ci0JY29uc3Qgc3RydWN0IGFsY19waW5jZmcgKmNmZzsKLQlzdHJ1Y3QgYWxjX3NwZWMgKnNwZWM7CitlbnVtIHsKKwlBTENfRklYVVBfSU5WQUxJRCwKKwlBTENfRklYVVBfU0tVLAorCUFMQ19GSVhVUF9QSU5TLAorCUFMQ19GSVhVUF9WRVJCUywKKwlBTENfRklYVVBfRlVOQywKK307CiAKLQljZmcgPSBmaXgtPnBpbnM7Ci0JaWYgKHByZV9pbml0ICYmIGZpeC0+c2t1KSB7CitlbnVtIHsKKwlBTENfRklYVVBfQUNUX1BSRV9QUk9CRSwKKwlBTENfRklYVVBfQUNUX1BST0JFLAorCUFMQ19GSVhVUF9BQ1RfSU5JVCwKK307CisKK3N0YXRpYyB2b2lkIGFsY19hcHBseV9maXh1cChzdHJ1Y3QgaGRhX2NvZGVjICpjb2RlYywgaW50IGFjdGlvbikKK3sKKwlzdHJ1Y3QgYWxjX3NwZWMgKnNwZWMgPSBjb2RlYy0+c3BlYzsKKwlpbnQgaWQgPSBzcGVjLT5maXh1cF9pZDsKICNpZmRlZiBDT05GSUdfU05EX0RFQlVHX1ZFUkJPU0UKLQkJc25kX3ByaW50ZGQoS0VSTl9JTkZPICJoZGFfY29kZWM6ICVzOiBBcHBseSBza3Ugb3ZlcnJpZGUgZm9yICVzXG4iLAotCQkJICAgIGNvZGVjLT5jaGlwX25hbWUsIG1vZGVsbmFtZSk7CisJY29uc3QgY2hhciAqbW9kZWxuYW1lID0gc3BlYy0+Zml4dXBfbmFtZTsKICNlbmRpZgotCQlzcGVjID0gY29kZWMtPnNwZWM7Ci0JCXNwZWMtPmNkZWZpbmUuc2t1X2NmZyA9IGZpeC0+c2t1OwotCQlzcGVjLT5jZGVmaW5lLmZpeHVwID0gMTsKLQl9Ci0JaWYgKHByZV9pbml0ICYmIGNmZykgewotI2lmZGVmIENPTkZJR19TTkRfREVCVUdfVkVSQk9TRQotCQlzbmRfcHJpbnRkZChLRVJOX0lORk8gImhkYV9jb2RlYzogJXM6IEFwcGx5IHBpbmNmZyBmb3IgJXNcbiIsCi0JCQkgICAgY29kZWMtPmNoaXBfbmFtZSwgbW9kZWxuYW1lKTsKLSNlbmRpZgotCQlmb3IgKDsgY2ZnLT5uaWQ7IGNmZysrKQotCQkJc25kX2hkYV9jb2RlY19zZXRfcGluY2ZnKGNvZGVjLCBjZmctPm5pZCwgY2ZnLT52YWwpOwotCX0KLQlpZiAoIXByZV9pbml0ICYmIGZpeC0+dmVyYnMpIHsKLSNpZmRlZiBDT05GSUdfU05EX0RFQlVHX1ZFUkJPU0UKLQkJc25kX3ByaW50ZGQoS0VSTl9JTkZPICJoZGFfY29kZWM6ICVzOiBBcHBseSBmaXgtdmVyYnMgZm9yICVzXG4iLAotCQkJICAgIGNvZGVjLT5jaGlwX25hbWUsIG1vZGVsbmFtZSk7Ci0jZW5kaWYKLQkJYWRkX3ZlcmIoY29kZWMtPnNwZWMsIGZpeC0+dmVyYnMpOwotCX0KLQlpZiAoZml4LT5mdW5jKSB7Ci0jaWZkZWYgQ09ORklHX1NORF9ERUJVR19WRVJCT1NFCi0JCXNuZF9wcmludGRkKEtFUk5fSU5GTyAiaGRhX2NvZGVjOiAlczogQXBwbHkgZml4LWZ1bmMgZm9yICVzXG4iLAotCQkJICAgIGNvZGVjLT5jaGlwX25hbWUsIG1vZGVsbmFtZSk7Ci0jZW5kaWYKLQkJZml4LT5mdW5jKGNvZGVjLCBmaXgsIHByZV9pbml0KTsKKwlpbnQgZGVwdGggPSAwOworCisJaWYgKCFzcGVjLT5maXh1cF9saXN0KQorCQlyZXR1cm47CisKKwl3aGlsZSAoaWQgPj0gMCkgeworCQljb25zdCBzdHJ1Y3QgYWxjX2ZpeHVwICpmaXggPSBzcGVjLT5maXh1cF9saXN0ICsgaWQ7CisJCWNvbnN0IHN0cnVjdCBhbGNfcGluY2ZnICpjZmc7CisKKwkJc3dpdGNoIChmaXgtPnR5cGUpIHsKKwkJY2FzZSBBTENfRklYVVBfU0tVOgorCQkJaWYgKGFjdGlvbiAhPSBBTENfRklYVVBfQUNUX1BSRV9QUk9CRSB8fCAhZml4LT52LnNrdSkKKwkJCQlicmVhazs7CisJCQlzbmRfcHJpbnRkZChLRVJOX0lORk8gImhkYV9jb2RlYzogJXM6ICIKKwkJCQkgICAgIkFwcGx5IHNrdSBvdmVycmlkZSBmb3IgJXNcbiIsCisJCQkJICAgIGNvZGVjLT5jaGlwX25hbWUsIG1vZGVsbmFtZSk7CisJCQlzcGVjLT5jZGVmaW5lLnNrdV9jZmcgPSBmaXgtPnYuc2t1OworCQkJc3BlYy0+Y2RlZmluZS5maXh1cCA9IDE7CisJCQlicmVhazsKKwkJY2FzZSBBTENfRklYVVBfUElOUzoKKwkJCWNmZyA9IGZpeC0+di5waW5zOworCQkJaWYgKGFjdGlvbiAhPSBBTENfRklYVVBfQUNUX1BSRV9QUk9CRSB8fCAhY2ZnKQorCQkJCWJyZWFrOworCQkJc25kX3ByaW50ZGQoS0VSTl9JTkZPICJoZGFfY29kZWM6ICVzOiAiCisJCQkJICAgICJBcHBseSBwaW5jZmcgZm9yICVzXG4iLAorCQkJCSAgICBjb2RlYy0+Y2hpcF9uYW1lLCBtb2RlbG5hbWUpOworCQkJZm9yICg7IGNmZy0+bmlkOyBjZmcrKykKKwkJCQlzbmRfaGRhX2NvZGVjX3NldF9waW5jZmcoY29kZWMsIGNmZy0+bmlkLAorCQkJCQkJCSBjZmctPnZhbCk7CisJCQlicmVhazsKKwkJY2FzZSBBTENfRklYVVBfVkVSQlM6CisJCQlpZiAoYWN0aW9uICE9IEFMQ19GSVhVUF9BQ1RfUFJPQkUgfHwgIWZpeC0+di52ZXJicykKKwkJCQlicmVhazsKKwkJCXNuZF9wcmludGRkKEtFUk5fSU5GTyAiaGRhX2NvZGVjOiAlczogIgorCQkJCSAgICAiQXBwbHkgZml4LXZlcmJzIGZvciAlc1xuIiwKKwkJCQkgICAgY29kZWMtPmNoaXBfbmFtZSwgbW9kZWxuYW1lKTsKKwkJCWFkZF92ZXJiKGNvZGVjLT5zcGVjLCBmaXgtPnYudmVyYnMpOworCQkJYnJlYWs7CisJCWNhc2UgQUxDX0ZJWFVQX0ZVTkM6CisJCQlpZiAoIWZpeC0+di5mdW5jKQorCQkJCWJyZWFrOworCQkJc25kX3ByaW50ZGQoS0VSTl9JTkZPICJoZGFfY29kZWM6ICVzOiAiCisJCQkJICAgICJBcHBseSBmaXgtZnVuYyBmb3IgJXNcbiIsCisJCQkJICAgIGNvZGVjLT5jaGlwX25hbWUsIG1vZGVsbmFtZSk7CisJCQlmaXgtPnYuZnVuYyhjb2RlYywgZml4LCBhY3Rpb24pOworCQkJYnJlYWs7CisJCWRlZmF1bHQ6CisJCQlzbmRfcHJpbnRrKEtFUk5fRVJSICJoZGFfY29kZWM6ICVzOiAiCisJCQkJICAgIkludmFsaWQgZml4dXAgdHlwZSAlZFxuIiwKKwkJCQkgICBjb2RlYy0+Y2hpcF9uYW1lLCBmaXgtPnR5cGUpOworCQkJYnJlYWs7CisJCX0KKwkJaWYgKCFmaXhbaWRdLmNoYWluZWQpCisJCQlicmVhazsKKwkJaWYgKCsrZGVwdGggPiAxMCkKKwkJCWJyZWFrOworCQlpZCA9IGZpeFtpZF0uY2hhaW5faWQ7CiAJfQogfQogCiBzdGF0aWMgdm9pZCBhbGNfcGlja19maXh1cChzdHJ1Y3QgaGRhX2NvZGVjICpjb2RlYywKLQkJCQkgY29uc3Qgc3RydWN0IHNuZF9wY2lfcXVpcmsgKnF1aXJrLAotCQkJCSBjb25zdCBzdHJ1Y3QgYWxjX2ZpeHVwICpmaXgsCi0JCQkJIGludCBwcmVfaW5pdCkKKwkJCSAgIGNvbnN0IHN0cnVjdCBhbGNfbW9kZWxfZml4dXAgKm1vZGVscywKKwkJCSAgIGNvbnN0IHN0cnVjdCBzbmRfcGNpX3F1aXJrICpxdWlyaywKKwkJCSAgIGNvbnN0IHN0cnVjdCBhbGNfZml4dXAgKmZpeGxpc3QpCiB7Ci0JcXVpcmsgPSBzbmRfcGNpX3F1aXJrX2xvb2t1cChjb2RlYy0+YnVzLT5wY2ksIHF1aXJrKTsKLQlpZiAocXVpcmspIHsKLQkJZml4ICs9IHF1aXJrLT52YWx1ZTsKLSNpZmRlZiBDT05GSUdfU05EX0RFQlVHX1ZFUkJPU0UKLQkJX19hbGNfcGlja19maXh1cChjb2RlYywgZml4LCBxdWlyay0+bmFtZSwgcHJlX2luaXQpOwotI2Vsc2UKLQkJX19hbGNfcGlja19maXh1cChjb2RlYywgZml4LCBOVUxMLCBwcmVfaW5pdCk7Ci0jZW5kaWYKLQl9Ci19CisJc3RydWN0IGFsY19zcGVjICpzcGVjID0gY29kZWMtPnNwZWM7CisJaW50IGlkID0gLTE7CisJY29uc3QgY2hhciAqbmFtZSA9IE5VTEw7CiAKLXN0YXRpYyB2b2lkIGFsY19waWNrX2ZpeHVwX21vZGVsKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLAotCQkJCSBjb25zdCBzdHJ1Y3QgYWxjX21vZGVsX2ZpeHVwICptb2RlbHMsCi0JCQkJIGNvbnN0IHN0cnVjdCBzbmRfcGNpX3F1aXJrICpxdWlyaywKLQkJCQkgY29uc3Qgc3RydWN0IGFsY19maXh1cCAqZml4LAotCQkJCSBpbnQgcHJlX2luaXQpCi17CiAJaWYgKGNvZGVjLT5tb2RlbG5hbWUgJiYgbW9kZWxzKSB7CiAJCXdoaWxlIChtb2RlbHMtPm5hbWUpIHsKIAkJCWlmICghc3RyY21wKGNvZGVjLT5tb2RlbG5hbWUsIG1vZGVscy0+bmFtZSkpIHsKLQkJCQlmaXggKz0gbW9kZWxzLT5pZDsKKwkJCQlpZCA9IG1vZGVscy0+aWQ7CisJCQkJbmFtZSA9IG1vZGVscy0+bmFtZTsKIAkJCQlicmVhazsKIAkJCX0KIAkJCW1vZGVscysrOwogCQl9Ci0JCV9fYWxjX3BpY2tfZml4dXAoY29kZWMsIGZpeCwgY29kZWMtPm1vZGVsbmFtZSwgcHJlX2luaXQpOwotCX0gZWxzZSB7Ci0JCWFsY19waWNrX2ZpeHVwKGNvZGVjLCBxdWlyaywgZml4LCBwcmVfaW5pdCk7CisJfQorCWlmIChpZCA8IDApIHsKKwkJcXVpcmsgPSBzbmRfcGNpX3F1aXJrX2xvb2t1cChjb2RlYy0+YnVzLT5wY2ksIHF1aXJrKTsKKwkJaWYgKHF1aXJrKSB7CisJCQlpZCA9IHF1aXJrLT52YWx1ZTsKKyNpZmRlZiBDT05GSUdfU05EX0RFQlVHX1ZFUkJPU0UKKwkJCW5hbWUgPSBxdWlyay0+bmFtZTsKKyNlbmRpZgorCQl9CisJfQorCisJc3BlYy0+Zml4dXBfaWQgPSBpZDsKKwlpZiAoaWQgPj0gMCkgeworCQlzcGVjLT5maXh1cF9saXN0ID0gZml4bGlzdDsKKwkJc3BlYy0+Zml4dXBfbmFtZSA9IG5hbWU7CiAJfQogfQogCkBAIC0yMjM4LDYgKzIyOTAsMjkgQEAKIAl7IH0gLyogZW5kICovCiB9OwogCitzdGF0aWMgc3RydWN0IHNuZF9rY29udHJvbF9uZXcgYWxjODg4X2FjZXJfYXNwaXJlXzQ5MzBnX21peGVyW10gPSB7CisJSERBX0NPREVDX1ZPTFVNRSgiRnJvbnQgUGxheWJhY2sgVm9sdW1lIiwgMHgwYywgMHgwLCBIREFfT1VUUFVUKSwKKwlIREFfQklORF9NVVRFKCJGcm9udCBQbGF5YmFjayBTd2l0Y2giLCAweDBjLCAyLCBIREFfSU5QVVQpLAorCUhEQV9DT0RFQ19WT0xVTUUoIlN1cnJvdW5kIFBsYXliYWNrIFZvbHVtZSIsIDB4MGQsIDB4MCwgSERBX09VVFBVVCksCisJSERBX0JJTkRfTVVURSgiU3Vycm91bmQgUGxheWJhY2sgU3dpdGNoIiwgMHgwZCwgMiwgSERBX0lOUFVUKSwKKwlIREFfQ09ERUNfVk9MVU1FX01PTk8oIkNlbnRlciBQbGF5YmFjayBWb2x1bWUiLCAweDBmLCAyLCAweDAsCisJCUhEQV9PVVRQVVQpLAorCUhEQV9CSU5EX01VVEVfTU9OTygiQ2VudGVyIFBsYXliYWNrIFN3aXRjaCIsIDB4MGYsIDIsIDIsIEhEQV9JTlBVVCksCisJSERBX0NPREVDX1ZPTFVNRV9NT05PKCJMRkUgUGxheWJhY2sgVm9sdW1lIiwgMHgwZiwgMSwgMHgwLCBIREFfT1VUUFVUKSwKKwlIREFfQklORF9NVVRFX01PTk8oIkxGRSBQbGF5YmFjayBTd2l0Y2giLCAweDBmLCAxLCAyLCBIREFfSU5QVVQpLAorCUhEQV9DT0RFQ19WT0xVTUUoIlNpZGUgUGxheWJhY2sgVm9sdW1lIiwgMHgwZSwgMHgwLCBIREFfT1VUUFVUKSwKKwlIREFfQklORF9NVVRFKCJTaWRlIFBsYXliYWNrIFN3aXRjaCIsIDB4MGUsIDIsIEhEQV9JTlBVVCksCisJSERBX0NPREVDX1ZPTFVNRSgiQ0QgUGxheWJhY2sgVm9sdW1lIiwgMHgwYiwgMHgwNCwgSERBX0lOUFVUKSwKKwlIREFfQ09ERUNfTVVURSgiQ0QgUGxheWJhY2sgU3dpdGNoIiwgMHgwYiwgMHgwNCwgSERBX0lOUFVUKSwKKwlIREFfQ09ERUNfVk9MVU1FKCJMaW5lIFBsYXliYWNrIFZvbHVtZSIsIDB4MGIsIDB4MDIsIEhEQV9JTlBVVCksCisJSERBX0NPREVDX01VVEUoIkxpbmUgUGxheWJhY2sgU3dpdGNoIiwgMHgwYiwgMHgwMiwgSERBX0lOUFVUKSwKKwlIREFfQ09ERUNfVk9MVU1FKCJNaWMgUGxheWJhY2sgVm9sdW1lIiwgMHgwYiwgMHgwLCBIREFfSU5QVVQpLAorCUhEQV9DT0RFQ19WT0xVTUUoIk1pYyBCb29zdCBWb2x1bWUiLCAweDE4LCAwLCBIREFfSU5QVVQpLAorCUhEQV9DT0RFQ19NVVRFKCJNaWMgUGxheWJhY2sgU3dpdGNoIiwgMHgwYiwgMHgwLCBIREFfSU5QVVQpLAorCXsgfSAvKiBlbmQgKi8KK307CisKKwogc3RhdGljIHN0cnVjdCBzbmRfa2NvbnRyb2xfbmV3IGFsYzg4OV9hY2VyX2FzcGlyZV84OTMwZ19taXhlcltdID0gewogCUhEQV9DT0RFQ19WT0xVTUUoIkZyb250IFBsYXliYWNrIFZvbHVtZSIsIDB4MGMsIDB4MCwgSERBX09VVFBVVCksCiAJSERBX0JJTkRfTVVURSgiRnJvbnQgUGxheWJhY2sgU3dpdGNoIiwgMHgwYywgMiwgSERBX0lOUFVUKSwKQEAgLTI4NjYsNyArMjk0MSw3IEBACiAvKgogICogc2xhdmUgY29udHJvbHMgZm9yIHZpcnR1YWwgbWFzdGVyCiAgKi8KLXN0YXRpYyBjb25zdCBjaGFyICphbGNfc2xhdmVfdm9sc1tdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhbGNfc2xhdmVfdm9sc1tdID0gewogCSJGcm9udCBQbGF5YmFjayBWb2x1bWUiLAogCSJTdXJyb3VuZCBQbGF5YmFjayBWb2x1bWUiLAogCSJDZW50ZXIgUGxheWJhY2sgVm9sdW1lIiwKQEAgLTI4ODAsNyArMjk1NSw3IEBACiAJTlVMTCwKIH07CiAKLXN0YXRpYyBjb25zdCBjaGFyICphbGNfc2xhdmVfc3dzW10gPSB7CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFsY19zbGF2ZV9zd3NbXSA9IHsKIAkiRnJvbnQgUGxheWJhY2sgU3dpdGNoIiwKIAkiU3Vycm91bmQgUGxheWJhY2sgU3dpdGNoIiwKIAkiQ2VudGVyIFBsYXliYWNrIFN3aXRjaCIsCkBAIC0zODYxLDYgKzM5MzYsOCBAQAogCWlmIChzcGVjLT5pbml0X2hvb2spCiAJCXNwZWMtPmluaXRfaG9vayhjb2RlYyk7CiAKKwlhbGNfYXBwbHlfZml4dXAoY29kZWMsIEFMQ19GSVhVUF9BQ1RfSU5JVCk7CisKIAloZGFfY2FsbF9jaGVja19wb3dlcl9zdGF0dXMoY29kZWMsIDB4MDEpOwogCXJldHVybiAwOwogfQpAQCAtNDU1OSw3ICs0NjM2LDcgQEAKIC8qCiAgKi8KIAotc3RhdGljIGNvbnN0IGNoYXIgKmFsYzg4MF9tb2RlbHNbQUxDODgwX01PREVMX0xBU1RdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhbGM4ODBfbW9kZWxzW0FMQzg4MF9NT0RFTF9MQVNUXSA9IHsKIAlbQUxDODgwXzNTVF0JCT0gIjNzdGFjayIsCiAJW0FMQzg4MF9UQ0xfUzcwMF0JPSAidGNsIiwKIAlbQUxDODgwXzNTVF9ESUddCT0gIjNzdGFjay1kaWdvdXQiLApAQCAtNTA5Miw3ICs1MTY5LDcgQEAKIHN0YXRpYyBpbnQgYWxjODgwX2F1dG9fY3JlYXRlX211bHRpX291dF9jdGxzKHN0cnVjdCBhbGNfc3BlYyAqc3BlYywKIAkJCQkJICAgICBjb25zdCBzdHJ1Y3QgYXV0b19waW5fY2ZnICpjZmcpCiB7Ci0Jc3RhdGljIGNvbnN0IGNoYXIgKmNobmFtZVs0XSA9IHsKKwlzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGNobmFtZVs0XSA9IHsKIAkJIkZyb250IiwgIlN1cnJvdW5kIiwgTlVMTCAvKkNMRkUqLywgIlNpZGUiCiAJfTsKIAljb25zdCBjaGFyICpwZnggPSBhbGNfZ2V0X2xpbmVfb3V0X3BmeChjZmcsIGZhbHNlKTsKQEAgLTcwOTAsNyArNzE2Nyw4IEBACiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgYWxjX2ZpeHVwIGFsYzI2MF9maXh1cHNbXSA9IHsKIAlbUElORklYX0hQX0RDNTc1MF0gPSB7Ci0JCS5waW5zID0gKGNvbnN0IHN0cnVjdCBhbGNfcGluY2ZnW10pIHsKKwkJLnR5cGUgPSBBTENfRklYVVBfUElOUywKKwkJLnYucGlucyA9IChjb25zdCBzdHJ1Y3QgYWxjX3BpbmNmZ1tdKSB7CiAJCQl7IDB4MTEsIDB4OTAxMzAxMTAgfSwgLyogc3BlYWtlciAqLwogCQkJeyB9CiAJCX0KQEAgLTcxMDUsNyArNzE4Myw3IEBACiAvKgogICogQUxDMjYwIGNvbmZpZ3VyYXRpb25zCiAgKi8KLXN0YXRpYyBjb25zdCBjaGFyICphbGMyNjBfbW9kZWxzW0FMQzI2MF9NT0RFTF9MQVNUXSA9IHsKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgYWxjMjYwX21vZGVsc1tBTEMyNjBfTU9ERUxfTEFTVF0gPSB7CiAJW0FMQzI2MF9CQVNJQ10JCT0gImJhc2ljIiwKIAlbQUxDMjYwX0hQXQkJPSAiaHAiLAogCVtBTEMyNjBfSFBfMzAxM10JPSAiaHAtMzAxMyIsCkBAIC03MzAxLDggKzczNzksMTAgQEAKIAkJYm9hcmRfY29uZmlnID0gQUxDMjYwX0FVVE87CiAJfQogCi0JaWYgKGJvYXJkX2NvbmZpZyA9PSBBTEMyNjBfQVVUTykKLQkJYWxjX3BpY2tfZml4dXAoY29kZWMsIGFsYzI2MF9maXh1cF90YmwsIGFsYzI2MF9maXh1cHMsIDEpOworCWlmIChib2FyZF9jb25maWcgPT0gQUxDMjYwX0FVVE8pIHsKKwkJYWxjX3BpY2tfZml4dXAoY29kZWMsIE5VTEwsIGFsYzI2MF9maXh1cF90YmwsIGFsYzI2MF9maXh1cHMpOworCQlhbGNfYXBwbHlfZml4dXAoY29kZWMsIEFMQ19GSVhVUF9BQ1RfUFJFX1BST0JFKTsKKwl9CiAKIAlpZiAoYm9hcmRfY29uZmlnID09IEFMQzI2MF9BVVRPKSB7CiAJCS8qIGF1dG9tYXRpYyBwYXJzZSBmcm9tIHRoZSBCSU9TIGNvbmZpZyAqLwpAQCAtNzM1MCw4ICs3NDMwLDcgQEAKIAlzZXRfY2FwdHVyZV9taXhlcihjb2RlYyk7CiAJc2V0X2JlZXBfYW1wKHNwZWMsIDB4MDcsIDB4MDUsIEhEQV9JTlBVVCk7CiAKLQlpZiAoYm9hcmRfY29uZmlnID09IEFMQzI2MF9BVVRPKQotCQlhbGNfcGlja19maXh1cChjb2RlYywgYWxjMjYwX2ZpeHVwX3RibCwgYWxjMjYwX2ZpeHVwcywgMCk7CisJYWxjX2FwcGx5X2ZpeHVwKGNvZGVjLCBBTENfRklYVVBfQUNUX1BST0JFKTsKIAogCXNwZWMtPnZtYXN0ZXJfbmlkID0gMHgwODsKIApAQCAtOTcyNyw3ICs5ODA2LDcgQEAKIC8qCiAgKiBjb25maWd1cmF0aW9uIGFuZCBwcmVzZXQKICAqLwotc3RhdGljIGNvbnN0IGNoYXIgKmFsYzg4Ml9tb2RlbHNbQUxDODgyX01PREVMX0xBU1RdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhbGM4ODJfbW9kZWxzW0FMQzg4Ml9NT0RFTF9MQVNUXSA9IHsKIAlbQUxDODgyXzNTVF9ESUddCT0gIjNzdGFjay1kaWciLAogCVtBTEM4ODJfNlNUX0RJR10JPSAiNnN0YWNrLWRpZyIsCiAJW0FMQzg4Ml9BUklNQV0JCT0gImFyaW1hIiwKQEAgLTEwMzAzLDcgKzEwMzgyLDcgQEAKIAkJLmluaXRfaG9vayA9IGFsY19hdXRvbXV0ZV9hbXAsCiAJfSwKIAlbQUxDODg4X0FDRVJfQVNQSVJFXzQ5MzBHXSA9IHsKLQkJLm1peGVycyA9IHsgYWxjODg4X2Jhc2VfbWl4ZXIsCisJCS5taXhlcnMgPSB7IGFsYzg4OF9hY2VyX2FzcGlyZV80OTMwZ19taXhlciwKIAkJCQlhbGM4ODNfY2htb2RlX21peGVyIH0sCiAJCS5pbml0X3ZlcmJzID0geyBhbGM4ODNfaW5pdF92ZXJicywgYWxjODgwX2dwaW8xX2luaXRfdmVyYnMsCiAJCQkJYWxjODg4X2FjZXJfYXNwaXJlXzQ5MzBnX3ZlcmJzIH0sCkBAIC0xMDY3OCw3ICsxMDc1Nyw4IEBACiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgYWxjX2ZpeHVwIGFsYzg4Ml9maXh1cHNbXSA9IHsKIAlbUElORklYX0FCSVRfQVc5RF9NQVhdID0gewotCQkucGlucyA9IChjb25zdCBzdHJ1Y3QgYWxjX3BpbmNmZ1tdKSB7CisJCS50eXBlID0gQUxDX0ZJWFVQX1BJTlMsCisJCS52LnBpbnMgPSAoY29uc3Qgc3RydWN0IGFsY19waW5jZmdbXSkgewogCQkJeyAweDE1LCAweDAxMDgwMTA0IH0sIC8qIHNpZGUgKi8KIAkJCXsgMHgxNiwgMHgwMTAxMTAxMiB9LCAvKiByZWFyICovCiAJCQl7IDB4MTcsIDB4MDEwMTYwMTEgfSwgLyogY2xmZSAqLwpAQCAtMTA2ODYsMTMgKzEwNzY2LDE1IEBACiAJCX0KIAl9LAogCVtQSU5GSVhfUEJfTTUyMTBdID0gewotCQkudmVyYnMgPSAoY29uc3Qgc3RydWN0IGhkYV92ZXJiW10pIHsKKwkJLnR5cGUgPSBBTENfRklYVVBfVkVSQlMsCisJCS52LnZlcmJzID0gKGNvbnN0IHN0cnVjdCBoZGFfdmVyYltdKSB7CiAJCQl7IDB4MTksIEFDX1ZFUkJfU0VUX1BJTl9XSURHRVRfQ09OVFJPTCwgUElOX1ZSRUY1MCB9LAogCQkJe30KIAkJfQogCX0sCiAJW1BJTkZJWF9BQ0VSX0FTUElSRV83NzM2XSA9IHsKLQkJLnNrdSA9IEFMQ19GSVhVUF9TS1VfSUdOT1JFLAorCQkudHlwZSA9IEFMQ19GSVhVUF9TS1UsCisJCS52LnNrdSA9IEFMQ19GSVhVUF9TS1VfSUdOT1JFLAogCX0sCiB9OwogCkBAIC0xMDg3Myw5ICsxMDk1NSw2IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgYWxjODYxdmRfYXV0b19jcmVhdGVfbXVsdGlfb3V0X2N0bHMoc3RydWN0IGFsY19zcGVjICpzcGVjLAotCQkJCQkgICAgIGNvbnN0IHN0cnVjdCBhdXRvX3Bpbl9jZmcgKmNmZyk7Ci0KIC8qIGFsbW9zdCBpZGVudGljYWwgd2l0aCBBTEM4ODAgcGFyc2VyLi4uICovCiBzdGF0aWMgaW50IGFsYzg4Ml9wYXJzZV9hdXRvX2NvbmZpZyhzdHJ1Y3QgaGRhX2NvZGVjICpjb2RlYykKIHsKQEAgLTEwODkzLDEwICsxMDk3Miw3IEBACiAJZXJyID0gYWxjODgwX2F1dG9fZmlsbF9kYWNfbmlkcyhzcGVjLCAmc3BlYy0+YXV0b2NmZyk7CiAJaWYgKGVyciA8IDApCiAJCXJldHVybiBlcnI7Ci0JaWYgKGNvZGVjLT52ZW5kb3JfaWQgPT0gMHgxMGVjMDg4NykKLQkJZXJyID0gYWxjODYxdmRfYXV0b19jcmVhdGVfbXVsdGlfb3V0X2N0bHMoc3BlYywgJnNwZWMtPmF1dG9jZmcpOwotCWVsc2UKLQkJZXJyID0gYWxjODgwX2F1dG9fY3JlYXRlX211bHRpX291dF9jdGxzKHNwZWMsICZzcGVjLT5hdXRvY2ZnKTsKKwllcnIgPSBhbGM4ODBfYXV0b19jcmVhdGVfbXVsdGlfb3V0X2N0bHMoc3BlYywgJnNwZWMtPmF1dG9jZmcpOwogCWlmIChlcnIgPCAwKQogCQlyZXR1cm4gZXJyOwogCWVyciA9IGFsYzg4MF9hdXRvX2NyZWF0ZV9leHRyYV9vdXQoc3BlYywgc3BlYy0+YXV0b2NmZy5ocF9waW5zWzBdLApAQCAtMTA5ODQsOCArMTEwNjAsMTAgQEAKIAkJYm9hcmRfY29uZmlnID0gQUxDODgyX0FVVE87CiAJfQogCi0JaWYgKGJvYXJkX2NvbmZpZyA9PSBBTEM4ODJfQVVUTykKLQkJYWxjX3BpY2tfZml4dXAoY29kZWMsIGFsYzg4Ml9maXh1cF90YmwsIGFsYzg4Ml9maXh1cHMsIDEpOworCWlmIChib2FyZF9jb25maWcgPT0gQUxDODgyX0FVVE8pIHsKKwkJYWxjX3BpY2tfZml4dXAoY29kZWMsIE5VTEwsIGFsYzg4Ml9maXh1cF90YmwsIGFsYzg4Ml9maXh1cHMpOworCQlhbGNfYXBwbHlfZml4dXAoY29kZWMsIEFMQ19GSVhVUF9BQ1RfUFJFX1BST0JFKTsKKwl9CiAKIAlhbGNfYXV0b19wYXJzZV9jdXN0b21pemVfZGVmaW5lKGNvZGVjKTsKIApAQCAtMTEwNjEsOCArMTExMzksNyBAQAogCWlmIChoYXNfY2RlZmluZV9iZWVwKGNvZGVjKSkKIAkJc2V0X2JlZXBfYW1wKHNwZWMsIDB4MGIsIDB4MDUsIEhEQV9JTlBVVCk7CiAKLQlpZiAoYm9hcmRfY29uZmlnID09IEFMQzg4Ml9BVVRPKQotCQlhbGNfcGlja19maXh1cChjb2RlYywgYWxjODgyX2ZpeHVwX3RibCwgYWxjODgyX2ZpeHVwcywgMCk7CisJYWxjX2FwcGx5X2ZpeHVwKGNvZGVjLCBBTENfRklYVVBfQUNUX1BST0JFKTsKIAogCXNwZWMtPnZtYXN0ZXJfbmlkID0gMHgwYzsKIApAQCAtMTI0NTIsMTkgKzEyNTI5LDE0IEBACiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgYWxjX2ZpeHVwIGFsYzI2Ml9maXh1cHNbXSA9IHsKIAlbUElORklYX0ZTQ19IMjcwXSA9IHsKLQkJLnBpbnMgPSAoY29uc3Qgc3RydWN0IGFsY19waW5jZmdbXSkgeworCQkudHlwZSA9IEFMQ19GSVhVUF9QSU5TLAorCQkudi5waW5zID0gKGNvbnN0IHN0cnVjdCBhbGNfcGluY2ZnW10pIHsKIAkJCXsgMHgxNCwgMHg5OTEzMDExMCB9LCAvKiBzcGVha2VyICovCiAJCQl7IDB4MTUsIDB4MDIyMTE0MmYgfSwgLyogZnJvbnQgSFAgKi8KIAkJCXsgMHgxYiwgMHgwMTIxMTQxZiB9LCAvKiByZWFyIEhQICovCiAJCQl7IH0KIAkJfQogCX0sCi0JW1BJTkZJWF9QQl9NNTIxMF0gPSB7Ci0JCS52ZXJicyA9IChjb25zdCBzdHJ1Y3QgaGRhX3ZlcmJbXSkgewotCQkJeyAweDE5LCBBQ19WRVJCX1NFVF9QSU5fV0lER0VUX0NPTlRST0wsIFBJTl9WUkVGNTAgfSwKLQkJCXt9Ci0JCX0KLQl9LAogfTsKIAogc3RhdGljIHN0cnVjdCBzbmRfcGNpX3F1aXJrIGFsYzI2Ml9maXh1cF90YmxbXSA9IHsKQEAgLTEyNTU0LDcgKzEyNjI2LDcgQEAKIC8qCiAgKiBjb25maWd1cmF0aW9uIGFuZCBwcmVzZXQKICAqLwotc3RhdGljIGNvbnN0IGNoYXIgKmFsYzI2Ml9tb2RlbHNbQUxDMjYyX01PREVMX0xBU1RdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhbGMyNjJfbW9kZWxzW0FMQzI2Ml9NT0RFTF9MQVNUXSA9IHsKIAlbQUxDMjYyX0JBU0lDXQkJPSAiYmFzaWMiLAogCVtBTEMyNjJfSElQUE9dCQk9ICJoaXBwbyIsCiAJW0FMQzI2Ml9ISVBQT18xXQk9ICJoaXBwb18xIiwKQEAgLTEyNTgyLDYgKzEyNjU0LDggQEAKIAkJCSAgIEFMQzI2Ml9IUF9CUEMpLAogCVNORF9QQ0lfUVVJUktfTUFTSygweDEwM2MsIDB4ZmYwMCwgMHgxMzAwLCAiSFAgeHcgc2VyaWVzIiwKIAkJCSAgIEFMQzI2Ml9IUF9CUEMpLAorCVNORF9QQ0lfUVVJUktfTUFTSygweDEwM2MsIDB4ZmYwMCwgMHgxNTAwLCAiSFAgeiBzZXJpZXMiLAorCQkJICAgQUxDMjYyX0hQX0JQQyksCiAJU05EX1BDSV9RVUlSS19NQVNLKDB4MTAzYywgMHhmZjAwLCAweDE3MDAsICJIUCB4dyBzZXJpZXMiLAogCQkJICAgQUxDMjYyX0hQX0JQQyksCiAJU05EX1BDSV9RVUlSSygweDEwM2MsIDB4MjgwMCwgIkhQIEQ3MDAwIiwgQUxDMjYyX0hQX0JQQ19ENzAwMF9XTCksCkBAIC0xMjg5NSw4ICsxMjk2OSwxMCBAQAogCQlib2FyZF9jb25maWcgPSBBTEMyNjJfQVVUTzsKIAl9CiAKLQlpZiAoYm9hcmRfY29uZmlnID09IEFMQzI2Ml9BVVRPKQotCQlhbGNfcGlja19maXh1cChjb2RlYywgYWxjMjYyX2ZpeHVwX3RibCwgYWxjMjYyX2ZpeHVwcywgMSk7CisJaWYgKGJvYXJkX2NvbmZpZyA9PSBBTEMyNjJfQVVUTykgeworCQlhbGNfcGlja19maXh1cChjb2RlYywgTlVMTCwgYWxjMjYyX2ZpeHVwX3RibCwgYWxjMjYyX2ZpeHVwcyk7CisJCWFsY19hcHBseV9maXh1cChjb2RlYywgQUxDX0ZJWFVQX0FDVF9QUkVfUFJPQkUpOworCX0KIAogCWlmIChib2FyZF9jb25maWcgPT0gQUxDMjYyX0FVVE8pIHsKIAkJLyogYXV0b21hdGljIHBhcnNlIGZyb20gdGhlIEJJT1MgY29uZmlnICovCkBAIC0xMjk2Niw4ICsxMzA0Miw3IEBACiAJaWYgKCFzcGVjLT5ub19hbmFsb2cgJiYgaGFzX2NkZWZpbmVfYmVlcChjb2RlYykpCiAJCXNldF9iZWVwX2FtcChzcGVjLCAweDBiLCAweDA1LCBIREFfSU5QVVQpOwogCi0JaWYgKGJvYXJkX2NvbmZpZyA9PSBBTEMyNjJfQVVUTykKLQkJYWxjX3BpY2tfZml4dXAoY29kZWMsIGFsYzI2Ml9maXh1cF90YmwsIGFsYzI2Ml9maXh1cHMsIDApOworCWFsY19hcHBseV9maXh1cChjb2RlYywgQUxDX0ZJWFVQX0FDVF9QUk9CRSk7CiAKIAlzcGVjLT52bWFzdGVyX25pZCA9IDB4MGM7CiAKQEAgLTEzNzQxLDcgKzEzODE2LDcgQEAKIC8qCiAgKiBjb25maWd1cmF0aW9uIGFuZCBwcmVzZXQKICAqLwotc3RhdGljIGNvbnN0IGNoYXIgKmFsYzI2OF9tb2RlbHNbQUxDMjY4X01PREVMX0xBU1RdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhbGMyNjhfbW9kZWxzW0FMQzI2OF9NT0RFTF9MQVNUXSA9IHsKIAlbQUxDMjY3X1FVQU5UQV9JTDFdCT0gInF1YW50YS1pbDEiLAogCVtBTEMyNjhfM1NUXQkJPSAiM3N0YWNrIiwKIAlbQUxDMjY4X1RPU0hJQkFdCT0gInRvc2hpYmEiLApAQCAtMTQ4MjIsMTcgKzE0ODk3LDE5IEBACiAjZW5kaWYgLyogU05EX0hEQV9ORUVEU19SRVNVTUUgKi8KIAogc3RhdGljIHZvaWQgYWxjMjY5X2ZpeHVwX2h3ZXEoc3RydWN0IGhkYV9jb2RlYyAqY29kZWMsCi0JCQkgICAgICAgY29uc3Qgc3RydWN0IGFsY19maXh1cCAqZml4LCBpbnQgcHJlX2luaXQpCisJCQkgICAgICAgY29uc3Qgc3RydWN0IGFsY19maXh1cCAqZml4LCBpbnQgYWN0aW9uKQogewogCWludCBjb2VmOwogCisJaWYgKGFjdGlvbiAhPSBBTENfRklYVVBfQUNUX0lOSVQpCisJCXJldHVybjsKIAljb2VmID0gYWxjX3JlYWRfY29lZl9pZHgoY29kZWMsIDB4MWUpOwogCWFsY193cml0ZV9jb2VmX2lkeChjb2RlYywgMHgxZSwgY29lZiB8IDB4ODApOwogfQogCiBlbnVtIHsKIAlBTEMyNjlfRklYVVBfU09OWV9WQUlPLAotCUFMQzI3NV9GSVhfU09OWV9WQUlPX0dQSU8yLAorCUFMQzI3NV9GSVhVUF9TT05ZX1ZBSU9fR1BJTzIsCiAJQUxDMjY5X0ZJWFVQX0RFTExfTTEwMVosCiAJQUxDMjY5X0ZJWFVQX1NLVV9JR05PUkUsCiAJQUxDMjY5X0ZJWFVQX0FTVVNfRzczSlcsCkBAIC0xNDg0MiwyMiArMTQ5MTksMjYgQEAKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBhbGNfZml4dXAgYWxjMjY5X2ZpeHVwc1tdID0gewogCVtBTEMyNjlfRklYVVBfU09OWV9WQUlPXSA9IHsKLQkJLnZlcmJzID0gKGNvbnN0IHN0cnVjdCBoZGFfdmVyYltdKSB7CisJCS50eXBlID0gQUxDX0ZJWFVQX1ZFUkJTLAorCQkudi52ZXJicyA9IChjb25zdCBzdHJ1Y3QgaGRhX3ZlcmJbXSkgewogCQkJezB4MTksIEFDX1ZFUkJfU0VUX1BJTl9XSURHRVRfQ09OVFJPTCwgUElOX1ZSRUZHUkR9LAogCQkJe30KIAkJfQogCX0sCi0JW0FMQzI3NV9GSVhfU09OWV9WQUlPX0dQSU8yXSA9IHsKLQkJLnZlcmJzID0gKGNvbnN0IHN0cnVjdCBoZGFfdmVyYltdKSB7CisJW0FMQzI3NV9GSVhVUF9TT05ZX1ZBSU9fR1BJTzJdID0geworCQkudHlwZSA9IEFMQ19GSVhVUF9WRVJCUywKKwkJLnYudmVyYnMgPSAoY29uc3Qgc3RydWN0IGhkYV92ZXJiW10pIHsKIAkJCXsweDAxLCBBQ19WRVJCX1NFVF9HUElPX01BU0ssIDB4MDR9LAogCQkJezB4MDEsIEFDX1ZFUkJfU0VUX0dQSU9fRElSRUNUSU9OLCAweDA0fSwKIAkJCXsweDAxLCBBQ19WRVJCX1NFVF9HUElPX0RBVEEsIDB4MDB9LAotCQkJezB4MTksIEFDX1ZFUkJfU0VUX1BJTl9XSURHRVRfQ09OVFJPTCwgUElOX1ZSRUZHUkR9LAogCQkJeyB9Ci0JCX0KKwkJfSwKKwkJLmNoYWluZWQgPSB0cnVlLAorCQkuY2hhaW5faWQgPSBBTEMyNjlfRklYVVBfU09OWV9WQUlPCiAJfSwKIAlbQUxDMjY5X0ZJWFVQX0RFTExfTTEwMVpdID0gewotCQkudmVyYnMgPSAoY29uc3Qgc3RydWN0IGhkYV92ZXJiW10pIHsKKwkJLnR5cGUgPSBBTENfRklYVVBfVkVSQlMsCisJCS52LnZlcmJzID0gKGNvbnN0IHN0cnVjdCBoZGFfdmVyYltdKSB7CiAJCQkvKiBFbmFibGVzIGludGVybmFsIHNwZWFrZXIgKi8KIAkJCXsweDIwLCBBQ19WRVJCX1NFVF9DT0VGX0lOREVYLCAxM30sCiAJCQl7MHgyMCwgQUNfVkVSQl9TRVRfUFJPQ19DT0VGLCAweDQwNDB9LApAQCAtMTQ4NjUsNDAgKzE0OTQ2LDQyIEBACiAJCX0KIAl9LAogCVtBTEMyNjlfRklYVVBfU0tVX0lHTk9SRV0gPSB7Ci0JCS5za3UgPSBBTENfRklYVVBfU0tVX0lHTk9SRSwKKwkJLnR5cGUgPSBBTENfRklYVVBfU0tVLAorCQkudi5za3UgPSBBTENfRklYVVBfU0tVX0lHTk9SRSwKIAl9LAogCVtBTEMyNjlfRklYVVBfQVNVU19HNzNKV10gPSB7Ci0JCS5waW5zID0gKGNvbnN0IHN0cnVjdCBhbGNfcGluY2ZnW10pIHsKKwkJLnR5cGUgPSBBTENfRklYVVBfUElOUywKKwkJLnYucGlucyA9IChjb25zdCBzdHJ1Y3QgYWxjX3BpbmNmZ1tdKSB7CiAJCQl7IDB4MTcsIDB4OTkxMzAxMTEgfSwgLyogc3Vid29vZmVyICovCiAJCQl7IH0KIAkJfQogCX0sCiAJW0FMQzI2OV9GSVhVUF9MRU5PVk9fRUFQRF0gPSB7Ci0JCS52ZXJicyA9IChjb25zdCBzdHJ1Y3QgaGRhX3ZlcmJbXSkgeworCQkudHlwZSA9IEFMQ19GSVhVUF9WRVJCUywKKwkJLnYudmVyYnMgPSAoY29uc3Qgc3RydWN0IGhkYV92ZXJiW10pIHsKIAkJCXsweDE0LCBBQ19WRVJCX1NFVF9FQVBEX0JUTEVOQUJMRSwgMH0sCiAJCQl7fQogCQl9CiAJfSwKIAlbQUxDMjc1X0ZJWFVQX1NPTllfSFdFUV0gPSB7Ci0JCS5mdW5jID0gYWxjMjY5X2ZpeHVwX2h3ZXEsCi0JCS52ZXJicyA9IChjb25zdCBzdHJ1Y3QgaGRhX3ZlcmJbXSkgewotCQkJezB4MDEsIEFDX1ZFUkJfU0VUX0dQSU9fTUFTSywgMHgwNH0sCi0JCQl7MHgwMSwgQUNfVkVSQl9TRVRfR1BJT19ESVJFQ1RJT04sIDB4MDR9LAotCQkJezB4MDEsIEFDX1ZFUkJfU0VUX0dQSU9fREFUQSwgMHgwMH0sCi0JCQl7MHgxOSwgQUNfVkVSQl9TRVRfUElOX1dJREdFVF9DT05UUk9MLCBQSU5fVlJFRkdSRH0sCi0JCQl7IH0KLQkJfQorCQkudHlwZSA9IEFMQ19GSVhVUF9GVU5DLAorCQkudi5mdW5jID0gYWxjMjY5X2ZpeHVwX2h3ZXEsCisJCS5jaGFpbmVkID0gdHJ1ZSwKKwkJLmNoYWluX2lkID0gQUxDMjc1X0ZJWFVQX1NPTllfVkFJT19HUElPMgogCX0KIH07CiAKIHN0YXRpYyBzdHJ1Y3Qgc25kX3BjaV9xdWlyayBhbGMyNjlfZml4dXBfdGJsW10gPSB7Ci0JU05EX1BDSV9RVUlSSygweDEwNGQsIDB4OTA3MywgIlNvbnkgVkFJTyIsIEFMQzI3NV9GSVhfU09OWV9WQUlPX0dQSU8yKSwKKwlTTkRfUENJX1FVSVJLKDB4MTA0ZCwgMHg5MDczLCAiU29ueSBWQUlPIiwgQUxDMjc1X0ZJWFVQX1NPTllfVkFJT19HUElPMiksCiAJU05EX1BDSV9RVUlSSygweDEwNGQsIDB4OTA3YiwgIlNvbnkgVkFJTyIsIEFMQzI3NV9GSVhVUF9TT05ZX0hXRVEpLAogCVNORF9QQ0lfUVVJUksoMHgxMDRkLCAweDkwODQsICJTb255IFZBSU8iLCBBTEMyNzVfRklYVVBfU09OWV9IV0VRKSwKIAlTTkRfUENJX1FVSVJLX1ZFTkRPUigweDEwNGQsICJTb255IFZBSU8iLCBBTEMyNjlfRklYVVBfU09OWV9WQUlPKSwKIAlTTkRfUENJX1FVSVJLKDB4MTAyOCwgMHgwNDcwLCAiRGVsbCBNMTAxeiIsIEFMQzI2OV9GSVhVUF9ERUxMX00xMDFaKSwKLQlTTkRfUENJX1FVSVJLKDB4MTdhYSwgMHgyMWI4LCAiVGhpbmtwYWQgRWRnZSAxNCIsIEFMQzI2OV9GSVhVUF9TS1VfSUdOT1JFKSwKIAlTTkRfUENJX1FVSVJLKDB4MTdhYSwgMHgyMGYyLCAiVGhpbmtwYWQgU0w0MTAvNTEwIiwgQUxDMjY5X0ZJWFVQX1NLVV9JR05PUkUpLAorCVNORF9QQ0lfUVVJUksoMHgxN2FhLCAweDIxNWUsICJUaGlua3BhZCBMNTEyIiwgQUxDMjY5X0ZJWFVQX1NLVV9JR05PUkUpLAorCVNORF9QQ0lfUVVJUksoMHgxN2FhLCAweDIxYjgsICJUaGlua3BhZCBFZGdlIDE0IiwgQUxDMjY5X0ZJWFVQX1NLVV9JR05PUkUpLAorCVNORF9QQ0lfUVVJUksoMHgxN2FhLCAweDIxY2EsICJUaGlua3BhZCBMNDEyIiwgQUxDMjY5X0ZJWFVQX1NLVV9JR05PUkUpLAorCVNORF9QQ0lfUVVJUksoMHgxN2FhLCAweDIxZTksICJUaGlua3BhZCBFZGdlIDE1IiwgQUxDMjY5X0ZJWFVQX1NLVV9JR05PUkUpLAogCVNORF9QQ0lfUVVJUksoMHgxMDQzLCAweDFhMTMsICJBc3VzIEc3M0p3IiwgQUxDMjY5X0ZJWFVQX0FTVVNfRzczSlcpLAogCVNORF9QQ0lfUVVJUksoMHgxN2FhLCAweDllNTQsICJMRU5PVk8gTkIiLCBBTEMyNjlfRklYVVBfTEVOT1ZPX0VBUEQpLAogCXt9CkBAIC0xNDkwOCw3ICsxNDk5MSw3IEBACiAvKgogICogY29uZmlndXJhdGlvbiBhbmQgcHJlc2V0CiAgKi8KLXN0YXRpYyBjb25zdCBjaGFyICphbGMyNjlfbW9kZWxzW0FMQzI2OV9NT0RFTF9MQVNUXSA9IHsKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgYWxjMjY5X21vZGVsc1tBTEMyNjlfTU9ERUxfTEFTVF0gPSB7CiAJW0FMQzI2OV9CQVNJQ10JCQk9ICJiYXNpYyIsCiAJW0FMQzI2OV9RVUFOVEFfRkwxXQkJPSAicXVhbnRhIiwKIAlbQUxDMjY5X0FNSUNdCQkJPSAibGFwdG9wLWFtaWMiLApAQCAtMTUxODQsOCArMTUyNjcsMTAgQEAKIAkJYm9hcmRfY29uZmlnID0gQUxDMjY5X0FVVE87CiAJfQogCi0JaWYgKGJvYXJkX2NvbmZpZyA9PSBBTEMyNjlfQVVUTykKLQkJYWxjX3BpY2tfZml4dXAoY29kZWMsIGFsYzI2OV9maXh1cF90YmwsIGFsYzI2OV9maXh1cHMsIDEpOworCWlmIChib2FyZF9jb25maWcgPT0gQUxDMjY5X0FVVE8pIHsKKwkJYWxjX3BpY2tfZml4dXAoY29kZWMsIE5VTEwsIGFsYzI2OV9maXh1cF90YmwsIGFsYzI2OV9maXh1cHMpOworCQlhbGNfYXBwbHlfZml4dXAoY29kZWMsIEFMQ19GSVhVUF9BQ1RfUFJFX1BST0JFKTsKKwl9CiAKIAlpZiAoYm9hcmRfY29uZmlnID09IEFMQzI2OV9BVVRPKSB7CiAJCS8qIGF1dG9tYXRpYyBwYXJzZSBmcm9tIHRoZSBCSU9TIGNvbmZpZyAqLwpAQCAtMTUyNDYsOCArMTUzMzEsNyBAQAogCWlmIChoYXNfY2RlZmluZV9iZWVwKGNvZGVjKSkKIAkJc2V0X2JlZXBfYW1wKHNwZWMsIDB4MGIsIDB4MDQsIEhEQV9JTlBVVCk7CiAKLQlpZiAoYm9hcmRfY29uZmlnID09IEFMQzI2OV9BVVRPKQotCQlhbGNfcGlja19maXh1cChjb2RlYywgYWxjMjY5X2ZpeHVwX3RibCwgYWxjMjY5X2ZpeHVwcywgMCk7CisJYWxjX2FwcGx5X2ZpeHVwKGNvZGVjLCBBTENfRklYVVBfQUNUX1BST0JFKTsKIAogCXNwZWMtPnZtYXN0ZXJfbmlkID0gMHgwMjsKIApAQCAtMTU5NTAsNyArMTYwMzQsNyBAQAogCQkJCQkgICAgIGNvbnN0IHN0cnVjdCBhdXRvX3Bpbl9jZmcgKmNmZykKIHsKIAlzdHJ1Y3QgYWxjX3NwZWMgKnNwZWMgPSBjb2RlYy0+c3BlYzsKLQlzdGF0aWMgY29uc3QgY2hhciAqY2huYW1lWzRdID0geworCXN0YXRpYyBjb25zdCBjaGFyICogY29uc3QgY2huYW1lWzRdID0gewogCQkiRnJvbnQiLCAiU3Vycm91bmQiLCBOVUxMIC8qQ0xGRSovLCAiU2lkZSIKIAl9OwogCWNvbnN0IGNoYXIgKnBmeCA9IGFsY19nZXRfbGluZV9vdXRfcGZ4KGNmZywgdHJ1ZSk7CkBAIC0xNjE1Niw3ICsxNjI0MCw3IEBACiAvKgogICogY29uZmlndXJhdGlvbiBhbmQgcHJlc2V0CiAgKi8KLXN0YXRpYyBjb25zdCBjaGFyICphbGM4NjFfbW9kZWxzW0FMQzg2MV9NT0RFTF9MQVNUXSA9IHsKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgYWxjODYxX21vZGVsc1tBTEM4NjFfTU9ERUxfTEFTVF0gPSB7CiAJW0FMQzg2MV8zU1RdCQk9ICIzc3RhY2siLAogCVtBTEM2NjBfM1NUXQkJPSAiM3N0YWNrLTY2MCIsCiAJW0FMQzg2MV8zU1RfRElHXQk9ICIzc3RhY2stZGlnIiwKQEAgLTE2MzA2LDcgKzE2MzkwLDggQEAKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBhbGNfZml4dXAgYWxjODYxX2ZpeHVwc1tdID0gewogCVtQSU5GSVhfRlNDX0FNSUxPX1BJMTUwNV0gPSB7Ci0JCS5waW5zID0gKGNvbnN0IHN0cnVjdCBhbGNfcGluY2ZnW10pIHsKKwkJLnR5cGUgPSBBTENfRklYVVBfUElOUywKKwkJLnYucGlucyA9IChjb25zdCBzdHJ1Y3QgYWxjX3BpbmNmZ1tdKSB7CiAJCQl7IDB4MGIsIDB4MDIyMTEwMWYgfSwgLyogSFAgKi8KIAkJCXsgMHgwZiwgMHg5MDE3MDMxMCB9LCAvKiBzcGVha2VyICovCiAJCQl7IH0KQEAgLTE2MzQxLDggKzE2NDI2LDEwIEBACiAJCWJvYXJkX2NvbmZpZyA9IEFMQzg2MV9BVVRPOwogCX0KIAotCWlmIChib2FyZF9jb25maWcgPT0gQUxDODYxX0FVVE8pCi0JCWFsY19waWNrX2ZpeHVwKGNvZGVjLCBhbGM4NjFfZml4dXBfdGJsLCBhbGM4NjFfZml4dXBzLCAxKTsKKwlpZiAoYm9hcmRfY29uZmlnID09IEFMQzg2MV9BVVRPKSB7CisJCWFsY19waWNrX2ZpeHVwKGNvZGVjLCBOVUxMLCBhbGM4NjFfZml4dXBfdGJsLCBhbGM4NjFfZml4dXBzKTsKKwkJYWxjX2FwcGx5X2ZpeHVwKGNvZGVjLCBBTENfRklYVVBfQUNUX1BSRV9QUk9CRSk7CisJfQogCiAJaWYgKGJvYXJkX2NvbmZpZyA9PSBBTEM4NjFfQVVUTykgewogCQkvKiBhdXRvbWF0aWMgcGFyc2UgZnJvbSB0aGUgQklPUyBjb25maWcgKi8KQEAgLTE2Mzc5LDggKzE2NDY2LDcgQEAKIAogCXNwZWMtPnZtYXN0ZXJfbmlkID0gMHgwMzsKIAotCWlmIChib2FyZF9jb25maWcgPT0gQUxDODYxX0FVVE8pCi0JCWFsY19waWNrX2ZpeHVwKGNvZGVjLCBhbGM4NjFfZml4dXBfdGJsLCBhbGM4NjFfZml4dXBzLCAwKTsKKwlhbGNfYXBwbHlfZml4dXAoY29kZWMsIEFMQ19GSVhVUF9BQ1RfUFJPQkUpOwogCiAJY29kZWMtPnBhdGNoX29wcyA9IGFsY19wYXRjaF9vcHM7CiAJaWYgKGJvYXJkX2NvbmZpZyA9PSBBTEM4NjFfQVVUTykgewpAQCAtMTY4NTcsNyArMTY5NDMsNyBAQAogLyoKICAqIGNvbmZpZ3VyYXRpb24gYW5kIHByZXNldAogICovCi1zdGF0aWMgY29uc3QgY2hhciAqYWxjODYxdmRfbW9kZWxzW0FMQzg2MVZEX01PREVMX0xBU1RdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhbGM4NjF2ZF9tb2RlbHNbQUxDODYxVkRfTU9ERUxfTEFTVF0gPSB7CiAJW0FMQzY2MFZEXzNTVF0JCT0gIjNzdGFjay02NjAiLAogCVtBTEM2NjBWRF8zU1RfRElHXQk9ICIzc3RhY2stNjYwLWRpZ291dCIsCiAJW0FMQzY2MFZEX0FTVVNfVjFTXQk9ICJhc3VzLXYxcyIsCkBAIC0xNzA3MiwxMiArMTcxNTgsMTQgQEAKICNkZWZpbmUgYWxjODYxdmRfaWR4X3RvX21peGVyX3N3aXRjaChuaWQpCSgobmlkKSArIDB4MGMpCiAKIC8qIGFkZCBwbGF5YmFjayBjb250cm9scyBmcm9tIHRoZSBwYXJzZWQgREFDIHRhYmxlICovCi0vKiBCYXNlZCBvbiBBTEM4ODAgdmVyc2lvbi4gQnV0IEFMQzg2MVZEIGFuZCBBTEM4ODcgaGF2ZSBzZXBhcmF0ZSwKKy8qIEJhc2VkIG9uIEFMQzg4MCB2ZXJzaW9uLiBCdXQgQUxDODYxVkQgaGFzIHNlcGFyYXRlLAogICogZGlmZmVyZW50IE5JRHMgZm9yIG11dGUvdW5tdXRlIHN3aXRjaCBhbmQgdm9sdW1lIGNvbnRyb2wgKi8KIHN0YXRpYyBpbnQgYWxjODYxdmRfYXV0b19jcmVhdGVfbXVsdGlfb3V0X2N0bHMoc3RydWN0IGFsY19zcGVjICpzcGVjLAogCQkJCQkgICAgIGNvbnN0IHN0cnVjdCBhdXRvX3Bpbl9jZmcgKmNmZykKIHsKLQlzdGF0aWMgY29uc3QgY2hhciAqY2huYW1lWzRdID0geyJGcm9udCIsICJTdXJyb3VuZCIsICJDTEZFIiwgIlNpZGUifTsKKwlzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGNobmFtZVs0XSA9IHsKKwkJIkZyb250IiwgIlN1cnJvdW5kIiwgIkNMRkUiLCAiU2lkZSIKKwl9OwogCWNvbnN0IGNoYXIgKnBmeCA9IGFsY19nZXRfbGluZV9vdXRfcGZ4KGNmZywgdHJ1ZSk7CiAJaGRhX25pZF90IG5pZF92LCBuaWRfczsKIAlpbnQgaSwgZXJyOwpAQCAtMTcyNjIsNyArMTczNTAsOCBAQAogLyogcmVzZXQgR1BJTzEgKi8KIHN0YXRpYyBjb25zdCBzdHJ1Y3QgYWxjX2ZpeHVwIGFsYzg2MXZkX2ZpeHVwc1tdID0gewogCVtBTEM2NjBWRF9GSVhfQVNVU19HUElPMV0gPSB7Ci0JCS52ZXJicyA9IChjb25zdCBzdHJ1Y3QgaGRhX3ZlcmJbXSkgeworCQkudHlwZSA9IEFMQ19GSVhVUF9WRVJCUywKKwkJLnYudmVyYnMgPSAoY29uc3Qgc3RydWN0IGhkYV92ZXJiW10pIHsKIAkJCXsweDAxLCBBQ19WRVJCX1NFVF9HUElPX01BU0ssIDB4MDN9LAogCQkJezB4MDEsIEFDX1ZFUkJfU0VUX0dQSU9fRElSRUNUSU9OLCAweDAxfSwKIAkJCXsweDAxLCBBQ19WRVJCX1NFVF9HUElPX0RBVEEsIDB4MDF9LApAQCAtMTcyOTcsOCArMTczODYsMTAgQEAKIAkJYm9hcmRfY29uZmlnID0gQUxDODYxVkRfQVVUTzsKIAl9CiAKLQlpZiAoYm9hcmRfY29uZmlnID09IEFMQzg2MVZEX0FVVE8pCi0JCWFsY19waWNrX2ZpeHVwKGNvZGVjLCBhbGM4NjF2ZF9maXh1cF90YmwsIGFsYzg2MXZkX2ZpeHVwcywgMSk7CisJaWYgKGJvYXJkX2NvbmZpZyA9PSBBTEM4NjFWRF9BVVRPKSB7CisJCWFsY19waWNrX2ZpeHVwKGNvZGVjLCBOVUxMLCBhbGM4NjF2ZF9maXh1cF90YmwsIGFsYzg2MXZkX2ZpeHVwcyk7CisJCWFsY19hcHBseV9maXh1cChjb2RlYywgQUxDX0ZJWFVQX0FDVF9QUkVfUFJPQkUpOworCX0KIAogCWlmIChib2FyZF9jb25maWcgPT0gQUxDODYxVkRfQVVUTykgewogCQkvKiBhdXRvbWF0aWMgcGFyc2UgZnJvbSB0aGUgQklPUyBjb25maWcgKi8KQEAgLTE3MzQ2LDggKzE3NDM3LDcgQEAKIAogCXNwZWMtPnZtYXN0ZXJfbmlkID0gMHgwMjsKIAotCWlmIChib2FyZF9jb25maWcgPT0gQUxDODYxVkRfQVVUTykKLQkJYWxjX3BpY2tfZml4dXAoY29kZWMsIGFsYzg2MXZkX2ZpeHVwX3RibCwgYWxjODYxdmRfZml4dXBzLCAwKTsKKwlhbGNfYXBwbHlfZml4dXAoY29kZWMsIEFMQ19GSVhVUF9BQ1RfUFJPQkUpOwogCiAJY29kZWMtPnBhdGNoX29wcyA9IGFsY19wYXRjaF9vcHM7CiAKQEAgLTE4NjMwLDcgKzE4NzIwLDcgQEAKIC8qCiAgKiBjb25maWd1cmF0aW9uIGFuZCBwcmVzZXQKICAqLwotc3RhdGljIGNvbnN0IGNoYXIgKmFsYzY2Ml9tb2RlbHNbQUxDNjYyX01PREVMX0xBU1RdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhbGM2NjJfbW9kZWxzW0FMQzY2Ml9NT0RFTF9MQVNUXSA9IHsKIAlbQUxDNjYyXzNTVF8yY2hfRElHXQk9ICIzc3RhY2stZGlnIiwKIAlbQUxDNjYyXzNTVF82Y2hfRElHXQk9ICIzc3RhY2stNmNoLWRpZyIsCiAJW0FMQzY2Ml8zU1RfNmNoXQk9ICIzc3RhY2stNmNoIiwKQEAgLTE4NzM1LDYgKzE4ODI1LDcgQEAKIAkJCQkJQUxDNjYyXzNTVF82Y2hfRElHKSwKIAlTTkRfUENJX1FVSVJLX01BU0soMHgxODU0LCAweGYwMDAsIDB4MjAwMCwgIkFTVVMgSDEzLTIwMHgiLAogCQkJICAgQUxDNjYzX0FTVVNfSDEzKSwKKwlTTkRfUENJX1FVSVJLKDB4MTk5MSwgMHg1NjI4LCAiT3JkaXNzaW1vIEVWRSIsIEFMQzY2Ml9MRU5PVk9fMTAxRSksCiAJe30KIH07CiAKQEAgLTE5MTQ1LDcgKzE5MjM2LDcgQEAKIAkJCQkJICAgICBjb25zdCBzdHJ1Y3QgYXV0b19waW5fY2ZnICpjZmcpCiB7CiAJc3RydWN0IGFsY19zcGVjICpzcGVjID0gY29kZWMtPnNwZWM7Ci0Jc3RhdGljIGNvbnN0IGNoYXIgKmNobmFtZVs0XSA9IHsKKwlzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGNobmFtZVs0XSA9IHsKIAkJIkZyb250IiwgIlN1cnJvdW5kIiwgTlVMTCAvKkNMRkUqLywgIlNpZGUiCiAJfTsKIAljb25zdCBjaGFyICpwZnggPSBhbGNfZ2V0X2xpbmVfb3V0X3BmeChjZmcsIHRydWUpOwpAQCAtMTkzNzgsNyArMTk0NjksMTAgQEAKIH0KIAogc3RhdGljIHZvaWQgYWxjMjcyX2ZpeHVwX21hcmlvKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLAotCQkJICAgICAgIGNvbnN0IHN0cnVjdCBhbGNfZml4dXAgKmZpeCwgaW50IHByZV9pbml0KSB7CisJCQkgICAgICAgY29uc3Qgc3RydWN0IGFsY19maXh1cCAqZml4LCBpbnQgYWN0aW9uKQoreworCWlmIChhY3Rpb24gIT0gQUxDX0ZJWFVQX0FDVF9QUk9CRSkKKwkJcmV0dXJuOwogCWlmIChzbmRfaGRhX292ZXJyaWRlX2FtcF9jYXBzKGNvZGVjLCAweDIsIEhEQV9PVVRQVVQsCiAJCQkJICAgICAgKDB4M2IgPDwgQUNfQU1QQ0FQX09GRlNFVF9TSElGVCkgfAogCQkJCSAgICAgICgweDNiIDw8IEFDX0FNUENBUF9OVU1fU1RFUFNfU0hJRlQpIHwKQEAgLTE5MzkyLDMxICsxOTQ4Niw0NCBAQAogCUFMQzY2Ml9GSVhVUF9BU1BJUkUsCiAJQUxDNjYyX0ZJWFVQX0lERUFQQUQsCiAJQUxDMjcyX0ZJWFVQX01BUklPLAorCUFMQzY2Ml9GSVhVUF9DWkNfUDEwVCwKIH07CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgYWxjX2ZpeHVwIGFsYzY2Ml9maXh1cHNbXSA9IHsKIAlbQUxDNjYyX0ZJWFVQX0FTUElSRV0gPSB7Ci0JCS5waW5zID0gKGNvbnN0IHN0cnVjdCBhbGNfcGluY2ZnW10pIHsKKwkJLnR5cGUgPSBBTENfRklYVVBfUElOUywKKwkJLnYucGlucyA9IChjb25zdCBzdHJ1Y3QgYWxjX3BpbmNmZ1tdKSB7CiAJCQl7IDB4MTUsIDB4OTkxMzAxMTIgfSwgLyogc3Vid29vZmVyICovCiAJCQl7IH0KIAkJfQogCX0sCiAJW0FMQzY2Ml9GSVhVUF9JREVBUEFEXSA9IHsKLQkJLnBpbnMgPSAoY29uc3Qgc3RydWN0IGFsY19waW5jZmdbXSkgeworCQkudHlwZSA9IEFMQ19GSVhVUF9QSU5TLAorCQkudi5waW5zID0gKGNvbnN0IHN0cnVjdCBhbGNfcGluY2ZnW10pIHsKIAkJCXsgMHgxNywgMHg5OTEzMDExMiB9LCAvKiBzdWJ3b29mZXIgKi8KIAkJCXsgfQogCQl9CiAJfSwKIAlbQUxDMjcyX0ZJWFVQX01BUklPXSA9IHsKLQkJLmZ1bmMgPSBhbGMyNzJfZml4dXBfbWFyaW8sCi0JfQorCQkudHlwZSA9IEFMQ19GSVhVUF9GVU5DLAorCQkudi5mdW5jID0gYWxjMjcyX2ZpeHVwX21hcmlvLAorCX0sCisJW0FMQzY2Ml9GSVhVUF9DWkNfUDEwVF0gPSB7CisJCS50eXBlID0gQUxDX0ZJWFVQX1ZFUkJTLAorCQkudi52ZXJicyA9IChjb25zdCBzdHJ1Y3QgaGRhX3ZlcmJbXSkgeworCQkJezB4MTQsIEFDX1ZFUkJfU0VUX0VBUERfQlRMRU5BQkxFLCAwfSwKKwkJCXt9CisJCX0KKwl9LAogfTsKIAogc3RhdGljIHN0cnVjdCBzbmRfcGNpX3F1aXJrIGFsYzY2Ml9maXh1cF90YmxbXSA9IHsKKwlTTkRfUENJX1FVSVJLKDB4MTAyNSwgMHgwMzA4LCAiQWNlciBBc3BpcmUgODk0MkciLCBBTEM2NjJfRklYVVBfQVNQSVJFKSwKIAlTTkRfUENJX1FVSVJLKDB4MTAyNSwgMHgwMzhiLCAiQWNlciBBc3BpcmUgODk0M0ciLCBBTEM2NjJfRklYVVBfQVNQSVJFKSwKIAlTTkRfUENJX1FVSVJLKDB4MTQ0ZCwgMHhjMDUxLCAiU2Ftc3VuZyBSNzIwIiwgQUxDNjYyX0ZJWFVQX0lERUFQQUQpLAogCVNORF9QQ0lfUVVJUksoMHgxN2FhLCAweDM4YWYsICJMZW5vdm8gSWRlYXBhZCBZNTUwUCIsIEFMQzY2Ml9GSVhVUF9JREVBUEFEKSwKIAlTTkRfUENJX1FVSVJLKDB4MTdhYSwgMHgzYTBkLCAiTGVub3ZvIElkZWFwYWQgWTU1MCIsIEFMQzY2Ml9GSVhVUF9JREVBUEFEKSwKKwlTTkRfUENJX1FVSVJLKDB4MWIzNSwgMHgyMjA2LCAiQ1pDIFAxMFQiLCBBTEM2NjJfRklYVVBfQ1pDX1AxMFQpLAogCXt9CiB9OwogCkBAIC0xOTQ2Miw3ICsxOTU2OSw5IEBACiAJfQogCiAJaWYgKGJvYXJkX2NvbmZpZyA9PSBBTEM2NjJfQVVUTykgewotCQlhbGNfcGlja19maXh1cChjb2RlYywgYWxjNjYyX2ZpeHVwX3RibCwgYWxjNjYyX2ZpeHVwcywgMSk7CisJCWFsY19waWNrX2ZpeHVwKGNvZGVjLCBhbGM2NjJfZml4dXBfbW9kZWxzLAorCQkJICAgICAgIGFsYzY2Ml9maXh1cF90YmwsIGFsYzY2Ml9maXh1cHMpOworCQlhbGNfYXBwbHlfZml4dXAoY29kZWMsIEFMQ19GSVhVUF9BQ1RfUFJFX1BST0JFKTsKIAkJLyogYXV0b21hdGljIHBhcnNlIGZyb20gdGhlIEJJT1MgY29uZmlnICovCiAJCWVyciA9IGFsYzY2Ml9wYXJzZV9hdXRvX2NvbmZpZyhjb2RlYyk7CiAJCWlmIChlcnIgPCAwKSB7CkBAIC0xOTUyMCwxMiArMTk2MjksMTEgQEAKIAl9CiAJc3BlYy0+dm1hc3Rlcl9uaWQgPSAweDAyOwogCisJYWxjX2FwcGx5X2ZpeHVwKGNvZGVjLCBBTENfRklYVVBfQUNUX1BST0JFKTsKKwogCWNvZGVjLT5wYXRjaF9vcHMgPSBhbGNfcGF0Y2hfb3BzOwotCWlmIChib2FyZF9jb25maWcgPT0gQUxDNjYyX0FVVE8pIHsKKwlpZiAoYm9hcmRfY29uZmlnID09IEFMQzY2Ml9BVVRPKQogCQlzcGVjLT5pbml0X2hvb2sgPSBhbGM2NjJfYXV0b19pbml0OwotCQlhbGNfcGlja19maXh1cF9tb2RlbChjb2RlYywgYWxjNjYyX2ZpeHVwX21vZGVscywKLQkJCQkgICAgIGFsYzY2Ml9maXh1cF90YmwsIGFsYzY2Ml9maXh1cHMsIDApOwotCX0KIAogCWFsY19pbml0X2phY2tzKGNvZGVjKTsKIApAQCAtMTk5MTMsNyArMjAwMjEsNyBAQAogLyoKICAqIGNvbmZpZ3VyYXRpb24gYW5kIHByZXNldAogICovCi1zdGF0aWMgY29uc3QgY2hhciAqYWxjNjgwX21vZGVsc1tBTEM2ODBfTU9ERUxfTEFTVF0gPSB7CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFsYzY4MF9tb2RlbHNbQUxDNjgwX01PREVMX0xBU1RdID0gewogCVtBTEM2ODBfQkFTRV0JCT0gImJhc2UiLAogCVtBTEM2ODBfQVVUT10JCT0gImF1dG8iLAogfTsKZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9oZGEvcGF0Y2hfc2lnbWF0ZWwuYyBiL3NvdW5kL3BjaS9oZGEvcGF0Y2hfc2lnbWF0ZWwuYwppbmRleCA0YWIwMTlkLi45ZWE0OGI0IDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvaGRhL3BhdGNoX3NpZ21hdGVsLmMKKysrIGIvc291bmQvcGNpL2hkYS9wYXRjaF9zaWdtYXRlbC5jCkBAIC0yNjYsNyArMjY2LDcgQEAKIAlzdHJ1Y3Qgc2lnbWF0ZWxfbWljX3JvdXRlIGludF9taWM7CiAJc3RydWN0IHNpZ21hdGVsX21pY19yb3V0ZSBkb2NrX21pYzsKIAotCWNvbnN0IGNoYXIgKipzcGRpZl9sYWJlbHM7CisJY29uc3QgY2hhciAqIGNvbnN0ICpzcGRpZl9sYWJlbHM7CiAKIAloZGFfbmlkX3QgZGlnX2luX25pZDsKIAloZGFfbmlkX3QgbW9ub19uaWQ7CkBAIC01MjQsNyArNTI0LDcgQEAKIAlIREFfQ09NUE9TRV9BTVBfVkFMKDB4MWQsIDMsIDAsIEhEQV9PVVRQVVQpLAogfTsKIAotc3RhdGljIGNvbnN0IGNoYXIgKnN0YWM5Mjd4X3NwZGlmX2xhYmVsc1s1XSA9IHsKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc3RhYzkyN3hfc3BkaWZfbGFiZWxzWzVdID0gewogCSJEaWdpdGFsIFBsYXliYWNrIiwgIkFEQVQiLCAiQW5hbG9nIE11eCAxIiwKIAkiQW5hbG9nIE11eCAyIiwgIkFuYWxvZyBNdXggMyIKIH07CkBAIC0xMDYyLDcgKzEwNjIsNyBAQAogCS5wdXQgPSBzdGFjOTJ4eF9zbXV4X2VudW1fcHV0LAogfTsKIAotc3RhdGljIGNvbnN0IGNoYXIgKnNsYXZlX3ZvbHNbXSA9IHsKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc2xhdmVfdm9sc1tdID0gewogCSJGcm9udCBQbGF5YmFjayBWb2x1bWUiLAogCSJTdXJyb3VuZCBQbGF5YmFjayBWb2x1bWUiLAogCSJDZW50ZXIgUGxheWJhY2sgVm9sdW1lIiwKQEAgLTEwNzMsNyArMTA3Myw3IEBACiAJTlVMTAogfTsKIAotc3RhdGljIGNvbnN0IGNoYXIgKnNsYXZlX3N3c1tdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzbGF2ZV9zd3NbXSA9IHsKIAkiRnJvbnQgUGxheWJhY2sgU3dpdGNoIiwKIAkiU3Vycm91bmQgUGxheWJhY2sgU3dpdGNoIiwKIAkiQ2VudGVyIFBsYXliYWNrIFN3aXRjaCIsCkBAIC0xMzU0LDcgKzEzNTQsNyBAQAogCVtTVEFDXzkyMDBfUEFOQVNPTklDXSA9IHJlZjkyMDBfcGluX2NvbmZpZ3MsCiB9OwogCi1zdGF0aWMgY29uc3QgY2hhciAqc3RhYzkyMDBfbW9kZWxzW1NUQUNfOTIwMF9NT0RFTFNdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzdGFjOTIwMF9tb2RlbHNbU1RBQ185MjAwX01PREVMU10gPSB7CiAJW1NUQUNfQVVUT10gPSAiYXV0byIsCiAJW1NUQUNfUkVGXSA9ICJyZWYiLAogCVtTVEFDXzkyMDBfT1FPXSA9ICJvcW8iLApAQCAtMTUwMCw3ICsxNTAwLDcgQEAKIAlbU1RBQ19NNl0gPSBzdGFjOTI1eE02X3Bpbl9jb25maWdzLAogfTsKIAotc3RhdGljIGNvbnN0IGNoYXIgKnN0YWM5MjV4X21vZGVsc1tTVEFDXzkyNXhfTU9ERUxTXSA9IHsKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc3RhYzkyNXhfbW9kZWxzW1NUQUNfOTI1eF9NT0RFTFNdID0gewogCVtTVEFDXzkyNXhfQVVUT10gPSAiYXV0byIsCiAJW1NUQUNfUkVGXSA9ICJyZWYiLAogCVtTVEFDX00xXSA9ICJtMSIsCkBAIC0xNTc0LDcgKzE1NzQsNyBAQAogCVtTVEFDXzkySEQ3M1hYX0lOVEVMXQk9IGludGVsX2RnNDVpZF9waW5fY29uZmlncywKIH07CiAKLXN0YXRpYyBjb25zdCBjaGFyICpzdGFjOTJoZDczeHhfbW9kZWxzW1NUQUNfOTJIRDczWFhfTU9ERUxTXSA9IHsKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc3RhYzkyaGQ3M3h4X21vZGVsc1tTVEFDXzkySEQ3M1hYX01PREVMU10gPSB7CiAJW1NUQUNfOTJIRDczWFhfQVVUT10gPSAiYXV0byIsCiAJW1NUQUNfOTJIRDczWFhfTk9fSkRdID0gIm5vLWpkIiwKIAlbU1RBQ185MkhENzNYWF9SRUZdID0gInJlZiIsCkBAIC0xNjYwLDcgKzE2NjAsNyBAQAogCVtTVEFDX0hQX0RWN180MDAwXSA9IGhwX2R2N180MDAwX3Bpbl9jb25maWdzLAogfTsKIAotc3RhdGljIGNvbnN0IGNoYXIgKnN0YWM5MmhkODN4eHhfbW9kZWxzW1NUQUNfOTJIRDgzWFhYX01PREVMU10gPSB7CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHN0YWM5MmhkODN4eHhfbW9kZWxzW1NUQUNfOTJIRDgzWFhYX01PREVMU10gPSB7CiAJW1NUQUNfOTJIRDgzWFhYX0FVVE9dID0gImF1dG8iLAogCVtTVEFDXzkySEQ4M1hYWF9SRUZdID0gInJlZiIsCiAJW1NUQUNfOTJIRDgzWFhYX1BXUl9SRUZdID0gIm1pYy1yZWYiLApAQCAtMTcyMiw3ICsxNzIyLDcgQEAKIAlbU1RBQ19IUF9EVjRfMTIyMk5SXQk9IE5VTEwsCiB9OwogCi1zdGF0aWMgY29uc3QgY2hhciAqc3RhYzkyaGQ3MWJ4eF9tb2RlbHNbU1RBQ185MkhENzFCWFhfTU9ERUxTXSA9IHsKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc3RhYzkyaGQ3MWJ4eF9tb2RlbHNbU1RBQ185MkhENzFCWFhfTU9ERUxTXSA9IHsKIAlbU1RBQ185MkhENzFCWFhfQVVUT10gPSAiYXV0byIsCiAJW1NUQUNfOTJIRDcxQlhYX1JFRl0gPSAicmVmIiwKIAlbU1RBQ19ERUxMX000XzFdID0gImRlbGwtbTQtMSIsCkBAIC0xOTE1LDcgKzE5MTUsNyBAQAogCVtTVEFDXzkyMlhfREVMTF9NODJdID0gZGVsbF85MjJ4X204Ml9waW5fY29uZmlncywJCiB9OwogCi1zdGF0aWMgY29uc3QgY2hhciAqc3RhYzkyMnhfbW9kZWxzW1NUQUNfOTIyWF9NT0RFTFNdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzdGFjOTIyeF9tb2RlbHNbU1RBQ185MjJYX01PREVMU10gPSB7CiAJW1NUQUNfOTIyWF9BVVRPXSA9ICJhdXRvIiwKIAlbU1RBQ19EOTQ1X1JFRl0JPSAicmVmIiwKIAlbU1RBQ19EOTQ1R1RQNV0JPSAiNXN0YWNrIiwKQEAgLTIwNzcsNyArMjA3Nyw3IEBACiAJW1NUQUNfOTI3WF9WT0xLTk9CXSA9IE5VTEwsCiB9OwogCi1zdGF0aWMgY29uc3QgY2hhciAqc3RhYzkyN3hfbW9kZWxzW1NUQUNfOTI3WF9NT0RFTFNdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzdGFjOTI3eF9tb2RlbHNbU1RBQ185MjdYX01PREVMU10gPSB7CiAJW1NUQUNfOTI3WF9BVVRPXQk9ICJhdXRvIiwKIAlbU1RBQ19EOTY1X1JFRl9OT19KRF0JPSAicmVmLW5vLWpkIiwKIAlbU1RBQ19EOTY1X1JFRl0JCT0gInJlZiIsCkBAIC0yMTgwLDcgKzIxODAsNyBAQAogCVtTVEFDXzkyMDVfRUFQRF0gPSBOVUxMLAogfTsKIAotc3RhdGljIGNvbnN0IGNoYXIgKnN0YWM5MjA1X21vZGVsc1tTVEFDXzkyMDVfTU9ERUxTXSA9IHsKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc3RhYzkyMDVfbW9kZWxzW1NUQUNfOTIwNV9NT0RFTFNdID0gewogCVtTVEFDXzkyMDVfQVVUT10gPSAiYXV0byIsCiAJW1NUQUNfOTIwNV9SRUZdID0gInJlZiIsCiAJW1NUQUNfOTIwNV9ERUxMX000Ml0gPSAiZGVsbC1tNDIiLApAQCAtMzEyMyw3ICszMTIzLDcgQEAKIAkJCQkgaW50IHR5cGUpCiB7CiAJc3RydWN0IHNpZ21hdGVsX3NwZWMgKnNwZWMgPSBjb2RlYy0+c3BlYzsKLQlzdGF0aWMgY29uc3QgY2hhciAqY2huYW1lWzRdID0geworCXN0YXRpYyBjb25zdCBjaGFyICogY29uc3QgY2huYW1lWzRdID0gewogCQkiRnJvbnQiLCAiU3Vycm91bmQiLCBOVUxMIC8qQ0xGRSovLCAiU2lkZSIKIAl9OwogCWhkYV9uaWRfdCBuaWQ7CkBAIC0zMjU2LDcgKzMyNTYsNyBAQAogfQogCiAvKiBsYWJlbHMgZm9yIG1vbm8gbXV4IG91dHB1dHMgKi8KLXN0YXRpYyBjb25zdCBjaGFyICpzdGFjOTJ4eF9tb25vX2xhYmVsc1s0XSA9IHsKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc3RhYzkyeHhfbW9ub19sYWJlbHNbNF0gPSB7CiAJIkRBQzAiLCAiREFDMSIsICJNaXhlciIsICJEQUMyIgogfTsKIApAQCAtMzM4MCw3ICszMzgwLDcgQEAKIAlyZXR1cm4gMDsKIH07CiAKLXN0YXRpYyBjb25zdCBjaGFyICpzdGFjOTJ4eF9zcGRpZl9sYWJlbHNbM10gPSB7CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHN0YWM5Mnh4X3NwZGlmX2xhYmVsc1szXSA9IHsKIAkiRGlnaXRhbCBQbGF5YmFjayIsICJBbmFsb2cgTXV4IDEiLCAiQW5hbG9nIE11eCAyIiwKIH07CiAKQEAgLTMzODgsNyArMzM4OCw3IEBACiB7CiAJc3RydWN0IHNpZ21hdGVsX3NwZWMgKnNwZWMgPSBjb2RlYy0+c3BlYzsKIAlzdHJ1Y3QgaGRhX2lucHV0X211eCAqc3BkaWZfbXV4ID0gJnNwZWMtPnByaXZhdGVfc211eDsKLQljb25zdCBjaGFyICoqbGFiZWxzID0gc3BlYy0+c3BkaWZfbGFiZWxzOworCWNvbnN0IGNoYXIgKiBjb25zdCAqbGFiZWxzID0gc3BlYy0+c3BkaWZfbGFiZWxzOwogCWludCBpLCBudW1fY29uczsKIAloZGFfbmlkX3QgY29uX2xzdFtIREFfTUFYX05VTV9JTlBVVFNdOwogCkBAIC0zNDA5LDcgKzM0MDksNyBAQAogfQogCiAvKiBsYWJlbHMgZm9yIGRtaWMgbXV4IGlucHV0cyAqLwotc3RhdGljIGNvbnN0IGNoYXIgKnN0YWM5Mnh4X2RtaWNfbGFiZWxzWzVdID0geworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzdGFjOTJ4eF9kbWljX2xhYmVsc1s1XSA9IHsKIAkiQW5hbG9nIElucHV0cyIsICJEaWdpdGFsIE1pYyAxIiwgIkRpZ2l0YWwgTWljIDIiLAogCSJEaWdpdGFsIE1pYyAzIiwgIkRpZ2l0YWwgTWljIDQiCiB9OwpAQCAtNTMzMyw3ICs1MzMzLDcgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCBzdGFjOTJoZDgzeHh4X3NldF9zeXN0ZW1fYnRsX2FtcChzdHJ1Y3QgaGRhX2NvZGVjICpjb2RlYykKK3N0YXRpYyBpbnQgaHBfYm5iMjAxMV93aXRoX2RvY2soc3RydWN0IGhkYV9jb2RlYyAqY29kZWMpCiB7CiAJaWYgKGNvZGVjLT52ZW5kb3JfaWQgIT0gMHgxMTFkNzYwNSAmJgogCSAgICBjb2RlYy0+dmVuZG9yX2lkICE9IDB4MTExZDc2ZDEpCkBAIC01MzQ4LDEwICs1MzQ4LDYgQEAKIAljYXNlIDB4MTAzYzE2MWQ6CiAJY2FzZSAweDEwM2MxNjFlOgogCWNhc2UgMHgxMDNjMTYxZjoKLQljYXNlIDB4MTAzYzE2MjA6Ci0JY2FzZSAweDEwM2MxNjIxOgotCWNhc2UgMHgxMDNjMTYyMjoKLQljYXNlIDB4MTAzYzE2MjM6CiAKIAljYXNlIDB4MTAzYzE2MmE6CiAJY2FzZSAweDEwM2MxNjJiOgpAQCAtNTM2MCw0MSArNTM1Niw5IEBACiAJY2FzZSAweDEwM2MxNjMxOgogCiAJY2FzZSAweDEwM2MxNjMzOgotCisJY2FzZSAweDEwM2MxNjM0OgogCWNhc2UgMHgxMDNjMTYzNToKIAotCWNhc2UgMHgxMDNjMTY0ZjoKLQotCWNhc2UgMHgxMDNjMTY3NjoKLQljYXNlIDB4MTAzYzE2Nzc6Ci0JY2FzZSAweDEwM2MxNjc4OgotCWNhc2UgMHgxMDNjMTY3OToKLQljYXNlIDB4MTAzYzE2N2E6Ci0JY2FzZSAweDEwM2MxNjdiOgotCWNhc2UgMHgxMDNjMTY3YzoKLQljYXNlIDB4MTAzYzE2N2Q6Ci0JY2FzZSAweDEwM2MxNjdlOgotCWNhc2UgMHgxMDNjMTY3ZjoKLQljYXNlIDB4MTAzYzE2ODA6Ci0JY2FzZSAweDEwM2MxNjgxOgotCWNhc2UgMHgxMDNjMTY4MjoKLQljYXNlIDB4MTAzYzE2ODM6Ci0JY2FzZSAweDEwM2MxNjg0OgotCWNhc2UgMHgxMDNjMTY4NToKLQljYXNlIDB4MTAzYzE2ODY6Ci0JY2FzZSAweDEwM2MxNjg3OgotCWNhc2UgMHgxMDNjMTY4ODoKLQljYXNlIDB4MTAzYzE2ODk6Ci0JY2FzZSAweDEwM2MxNjhhOgotCWNhc2UgMHgxMDNjMTY4YjoKLQljYXNlIDB4MTAzYzE2OGM6Ci0JY2FzZSAweDEwM2MxNjhkOgotCWNhc2UgMHgxMDNjMTY4ZToKLQljYXNlIDB4MTAzYzE2OGY6Ci0JY2FzZSAweDEwM2MxNjkwOgotCWNhc2UgMHgxMDNjMTY5MToKLQljYXNlIDB4MTAzYzE2OTI6Ci0KIAljYXNlIDB4MTAzYzM1ODc6CiAJY2FzZSAweDEwM2MzNTg4OgogCWNhc2UgMHgxMDNjMzU4OToKQEAgLTU0MDIsOSArNTM2Niw5IEBACiAKIAljYXNlIDB4MTAzYzM2Njc6CiAJY2FzZSAweDEwM2MzNjY4OgotCQkvKiBzZXQgQlRMIGFtcCBsZXZlbCB0byAxMy40M2RCIGZvciBsb3VkZXIgc3BlYWtlciBvdXRwdXQgKi8KLQkJcmV0dXJuIHNuZF9oZGFfY29kZWNfd3JpdGVfY2FjaGUoY29kZWMsIGNvZGVjLT5hZmcsIDAsCi0JCQkJCQkgMHg3RjQsIDB4MTQpOworCWNhc2UgMHgxMDNjMzY2OToKKworCQlyZXR1cm4gMTsKIAl9CiAJcmV0dXJuIDA7CiB9CkBAIC01NDIwLDYgKzUzODQsMTEgQEAKIAlpZiAoc3BlYyA9PSBOVUxMKQogCQlyZXR1cm4gLUVOT01FTTsKIAorCWlmIChocF9ibmIyMDExX3dpdGhfZG9jayhjb2RlYykpIHsKKwkJc25kX2hkYV9jb2RlY19zZXRfcGluY2ZnKGNvZGVjLCAweGEsIDB4MjEwMTIwMWYpOworCQlzbmRfaGRhX2NvZGVjX3NldF9waW5jZmcoY29kZWMsIDB4ZiwgMHgyMTgxMjA1ZSk7CisJfQorCiAJLyogcmVzZXQgcGluIHBvd2VyLWRvd247IFdpbmRvd3MgbWF5IGxlYXZlIHRoZXNlIGJpdHMgYWZ0ZXIgcmVib290ICovCiAJc25kX2hkYV9jb2RlY193cml0ZV9jYWNoZShjb2RlYywgY29kZWMtPmFmZywgMCwgMHg3RUMsIDApOwogCXNuZF9oZGFfY29kZWNfd3JpdGVfY2FjaGUoY29kZWMsIGNvZGVjLT5hZmcsIDAsIDB4N0VELCAwKTsKQEAgLTU1NDYsOCArNTUxNSw2IEBACiAJCQlBQ19WRVJCX1NFVF9DT05ORUNUX1NFTCwgbnVtX2RhY3MpOwogCX0KIAotCXN0YWM5MmhkODN4eHhfc2V0X3N5c3RlbV9idGxfYW1wKGNvZGVjKTsKLQogCWNvZGVjLT5wcm9jX3dpZGdldF9ob29rID0gc3RhYzkyaGRfcHJvY19ob29rOwogCiAJcmV0dXJuIDA7CkBAIC02MjcwLDcgKzYyMzcsNyBAQAogCTB4OTBhNzAxM2UKIH07CiAKLXN0YXRpYyBjb25zdCBjaGFyICpzdGFjOTg3Ml9tb2RlbHNbU1RBQ185ODcyX01PREVMU10gPSB7CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHN0YWM5ODcyX21vZGVsc1tTVEFDXzk4NzJfTU9ERUxTXSA9IHsKIAlbU1RBQ185ODcyX0FVVE9dID0gImF1dG8iLAogCVtTVEFDXzk4NzJfVkFJT10gPSAidmFpbyIsCiB9OwpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2hkYS9wYXRjaF92aWEuYyBiL3NvdW5kL3BjaS9oZGEvcGF0Y2hfdmlhLmMKaW5kZXggN2Y0ODUyYS4uYTc2YzMyNiAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2hkYS9wYXRjaF92aWEuYworKysgYi9zb3VuZC9wY2kvaGRhL3BhdGNoX3ZpYS5jCkBAIC0yMjgxLDcgKzIyODEsOSBAQAogCQkJCQkgICAgIGNvbnN0IHN0cnVjdCBhdXRvX3Bpbl9jZmcgKmNmZykKIHsKIAljaGFyIG5hbWVbMzJdOwotCXN0YXRpYyBjb25zdCBjaGFyICpjaG5hbWVbNF0gPSB7ICJGcm9udCIsICJTdXJyb3VuZCIsICJDL0xGRSIsICJTaWRlIiB9OworCXN0YXRpYyBjb25zdCBjaGFyICogY29uc3QgY2huYW1lWzRdID0geworCQkiRnJvbnQiLCAiU3Vycm91bmQiLCAiQy9MRkUiLCAiU2lkZSIKKwl9OwogCWhkYV9uaWRfdCBuaWQsIG5pZF92b2wsIG5pZF92b2xzW10gPSB7MHgxNywgMHgxOSwgMHgxYSwgMHgxYn07CiAJaW50IGksIGVycjsKIApAQCAtMjM3MCw3ICsyMzcyLDcgQEAKIHsKIAlpbnQgaTsKIAlzdHJ1Y3QgaGRhX2lucHV0X211eCAqaW11eCA9ICZzcGVjLT5wcml2YXRlX2ltdXhbMV07Ci0Jc3RhdGljIGNvbnN0IGNoYXIgKnRleHRzW10gPSB7ICJPRkYiLCAiT04iLCBOVUxMfTsKKwlzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHRleHRzW10gPSB7ICJPRkYiLCAiT04iLCBOVUxMfTsKIAogCS8qIGZvciBocCBtb2RlIHNlbGVjdCAqLwogCWZvciAoaSA9IDA7IHRleHRzW2ldOyBpKyspCkBAIC0yODkwLDcgKzI4OTIsOSBAQAogCQkJCQkgICAgIGNvbnN0IHN0cnVjdCBhdXRvX3Bpbl9jZmcgKmNmZykKIHsKIAljaGFyIG5hbWVbMzJdOwotCXN0YXRpYyBjb25zdCBjaGFyICpjaG5hbWVbNF0gPSB7ICJGcm9udCIsICJTdXJyb3VuZCIsICJDL0xGRSIsICJTaWRlIiB9OworCXN0YXRpYyBjb25zdCBjaGFyICogY29uc3QgY2huYW1lWzRdID0geworCQkiRnJvbnQiLCAiU3Vycm91bmQiLCAiQy9MRkUiLCAiU2lkZSIKKwl9OwogCWhkYV9uaWRfdCBuaWQsIG5pZF92b2wsIG5pZF92b2xzW10gPSB7MHgxOCwgMHgxYSwgMHgxYiwgMHgyOX07CiAJaW50IGksIGVycjsKIApAQCAtMzQzMyw3ICszNDM3LDkgQEAKIAkJCQkJICAgICBjb25zdCBzdHJ1Y3QgYXV0b19waW5fY2ZnICpjZmcpCiB7CiAJY2hhciBuYW1lWzMyXTsKLQlzdGF0aWMgY29uc3QgY2hhciAqY2huYW1lWzRdID0geyAiRnJvbnQiLCAiU3Vycm91bmQiLCAiQy9MRkUiLCAiU2lkZSIgfTsKKwlzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGNobmFtZVs0XSA9IHsKKwkJIkZyb250IiwgIlN1cnJvdW5kIiwgIkMvTEZFIiwgIlNpZGUiCisJfTsKIAloZGFfbmlkX3QgbmlkX3ZvbHNbXSA9IHsweDE2LCAweDE4LCAweDI2LCAweDI3fTsKIAloZGFfbmlkX3QgbmlkLCBuaWRfdm9sID0gMDsKIAlpbnQgaSwgZXJyOwpAQCAtMzg2MSw3ICszODY3LDkgQEAKIAkJCQkJICAgICBjb25zdCBzdHJ1Y3QgYXV0b19waW5fY2ZnICpjZmcpCiB7CiAJY2hhciBuYW1lWzMyXTsKLQlzdGF0aWMgY29uc3QgY2hhciAqY2huYW1lWzRdID0geyAiRnJvbnQiLCAiU3Vycm91bmQiLCAiQy9MRkUiLCAiU2lkZSIgfTsKKwlzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGNobmFtZVs0XSA9IHsKKwkJIkZyb250IiwgIlN1cnJvdW5kIiwgIkMvTEZFIiwgIlNpZGUiCisJfTsKIAloZGFfbmlkX3QgbmlkX3ZvbHNbXSA9IHsweDEwLCAweDExLCAweDI0LCAweDI1fTsKIAloZGFfbmlkX3QgbmlkX211dGVzW10gPSB7MHgxQywgMHgxOCwgMHgyNiwgMHgyN307CiAJaGRhX25pZF90IG5pZCwgbmlkX3ZvbCwgbmlkX211dGU7CkBAIC00MzA0LDcgKzQzMTIsNyBAQAogewogCWludCBlcnIsIGk7CiAJc3RydWN0IGhkYV9pbnB1dF9tdXggKmltdXg7Ci0Jc3RhdGljIGNvbnN0IGNoYXIgKnRleHRzW10gPSB7ICJPTiIsICJPRkYiLCBOVUxMfTsKKwlzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHRleHRzW10gPSB7ICJPTiIsICJPRkYiLCBOVUxMfTsKIAlpZiAoIXBpbikKIAkJcmV0dXJuIDA7CiAJc3BlYy0+bXVsdGlvdXQuaHBfbmlkID0gMHgxRDsKQEAgLTQ2MTUsNyArNDYyMyw5IEBACiAJCQkJCSAgICAgY29uc3Qgc3RydWN0IGF1dG9fcGluX2NmZyAqY2ZnKQogewogCWNoYXIgbmFtZVszMl07Ci0Jc3RhdGljIGNvbnN0IGNoYXIgKmNobmFtZVs0XSA9IHsgIkZyb250IiwgIlN1cnJvdW5kIiwgIkMvTEZFIiwgIlNpZGUiIH07CisJc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBjaG5hbWVbNF0gPSB7CisJCSJGcm9udCIsICJTdXJyb3VuZCIsICJDL0xGRSIsICJTaWRlIgorCX07CiAJaGRhX25pZF90IG5pZF92b2xzW10gPSB7MHg4LCAweDksIDB4YSwgMHhifTsKIAloZGFfbmlkX3QgbmlkX211dGVzW10gPSB7MHgyNCwgMHgyNSwgMHgyNiwgMHgyN307CiAJaGRhX25pZF90IG5pZCwgbmlkX3ZvbCwgbmlkX211dGUgPSAwOwpAQCAtNTA2NCw3ICs1MDc0LDkgQEAKIAkJCQkJICAgICAgY29uc3Qgc3RydWN0IGF1dG9fcGluX2NmZyAqY2ZnKQogewogCWNoYXIgbmFtZVszMl07Ci0Jc3RhdGljIGNvbnN0IGNoYXIgKmNobmFtZVszXSA9IHsgIkZyb250IiwgIlN1cnJvdW5kIiwgIkMvTEZFIiB9OworCXN0YXRpYyBjb25zdCBjaGFyICogY29uc3QgY2huYW1lWzNdID0geworCQkiRnJvbnQiLCAiU3Vycm91bmQiLCAiQy9MRkUiCisJfTsKIAloZGFfbmlkX3QgbmlkX3ZvbHNbXSA9IHsweDEwLCAweDExLCAweDI1fTsKIAloZGFfbmlkX3QgbmlkX211dGVzW10gPSB7MHgxQywgMHgxOCwgMHgyN307CiAJaGRhX25pZF90IG5pZCwgbmlkX3ZvbCwgbmlkX211dGU7CmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvaWNlMTcxMi9kZWx0YS5jIGIvc291bmQvcGNpL2ljZTE3MTIvZGVsdGEuYwppbmRleCA3YjYyZGUwLi4yMGM2YjA3IDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvaWNlMTcxMi9kZWx0YS5jCisrKyBiL3NvdW5kL3BjaS9pY2UxNzEyL2RlbHRhLmMKQEAgLTU4MCw2ICs1ODAsNyBAQAogewogCWludCBlcnI7CiAJc3RydWN0IHNuZF9ha200eHh4ICphazsKKwl1bnNpZ25lZCBjaGFyIHRtcDsKIAogCWlmIChpY2UtPmVlcHJvbS5zdWJ2ZW5kb3IgPT0gSUNFMTcxMl9TVUJERVZJQ0VfREVMVEExMDEwICYmCiAJICAgIGljZS0+ZWVwcm9tLmdwaW9kaXIgPT0gMHg3YikKQEAgLTYyMiw2ICs2MjMsMTIgQEAKIAkJYnJlYWs7CiAJfQogCisJLyogaW5pdGlhbGl6ZSB0aGUgU1BJIGNsb2NrIHRvIGhpZ2ggKi8KKwl0bXAgPSBzbmRfaWNlMTcxMl9yZWFkKGljZSwgSUNFMTcxMl9JUkVHX0dQSU9fREFUQSk7CisJdG1wIHw9IElDRTE3MTJfREVMVEFfQVBfQ0NMSzsKKwlzbmRfaWNlMTcxMl93cml0ZShpY2UsIElDRTE3MTJfSVJFR19HUElPX0RBVEEsIHRtcCk7CisJdWRlbGF5KDUpOworCiAJLyogaW5pdGlhbGl6ZSBzcGRpZiAqLwogCXN3aXRjaCAoaWNlLT5lZXByb20uc3VidmVuZG9yKSB7CiAJY2FzZSBJQ0UxNzEyX1NVQkRFVklDRV9BVURJT1BISUxFOgpkaWZmIC0tZ2l0IGEvc291bmQvcGNpL294eWdlbi9veHlnZW4uaCBiL3NvdW5kL3BjaS9veHlnZW4vb3h5Z2VuLmgKaW5kZXggYzJhZTYzZC4uZjUzODk3YSAxMDA2NDQKLS0tIGEvc291bmQvcGNpL294eWdlbi9veHlnZW4uaAorKysgYi9zb3VuZC9wY2kvb3h5Z2VuL294eWdlbi5oCkBAIC05Miw2ICs5Miw4IEBACiAJdm9pZCAoKnVwZGF0ZV9kYWNfdm9sdW1lKShzdHJ1Y3Qgb3h5Z2VuICpjaGlwKTsKIAl2b2lkICgqdXBkYXRlX2RhY19tdXRlKShzdHJ1Y3Qgb3h5Z2VuICpjaGlwKTsKIAl2b2lkICgqdXBkYXRlX2NlbnRlcl9sZmVfbWl4KShzdHJ1Y3Qgb3h5Z2VuICpjaGlwLCBib29sIG1peGVkKTsKKwl1bnNpZ25lZCBpbnQgKCphZGp1c3RfZGFjX3JvdXRpbmcpKHN0cnVjdCBveHlnZW4gKmNoaXAsCisJCQkJCSAgIHVuc2lnbmVkIGludCBwbGF5X3JvdXRpbmcpOwogCXZvaWQgKCpncGlvX2NoYW5nZWQpKHN0cnVjdCBveHlnZW4gKmNoaXApOwogCXZvaWQgKCp1YXJ0X2lucHV0KShzdHJ1Y3Qgb3h5Z2VuICpjaGlwKTsKIAl2b2lkICgqYWM5N19zd2l0Y2gpKHN0cnVjdCBveHlnZW4gKmNoaXAsCmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvb3h5Z2VuL294eWdlbl9taXhlci5jIGIvc291bmQvcGNpL294eWdlbi9veHlnZW5fbWl4ZXIuYwppbmRleCA5YmZmMTRkLi4yNmM3ZThiIDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvb3h5Z2VuL294eWdlbl9taXhlci5jCisrKyBiL3NvdW5kL3BjaS9veHlnZW4vb3h5Z2VuX21peGVyLmMKQEAgLTE4MCw2ICsxODAsOCBAQAogCQkJICAgICgxIDw8IE9YWUdFTl9QTEFZX0RBQzFfU09VUkNFX1NISUZUKSB8CiAJCQkgICAgKDIgPDwgT1hZR0VOX1BMQVlfREFDMl9TT1VSQ0VfU0hJRlQpIHwKIAkJCSAgICAoMyA8PCBPWFlHRU5fUExBWV9EQUMzX1NPVVJDRV9TSElGVCk7CisJaWYgKGNoaXAtPm1vZGVsLmFkanVzdF9kYWNfcm91dGluZykKKwkJcmVnX3ZhbHVlID0gY2hpcC0+bW9kZWwuYWRqdXN0X2RhY19yb3V0aW5nKGNoaXAsIHJlZ192YWx1ZSk7CiAJb3h5Z2VuX3dyaXRlMTZfbWFza2VkKGNoaXAsIE9YWUdFTl9QTEFZX1JPVVRJTkcsIHJlZ192YWx1ZSwKIAkJCSAgICAgIE9YWUdFTl9QTEFZX0RBQzBfU09VUkNFX01BU0sgfAogCQkJICAgICAgT1hZR0VOX1BMQVlfREFDMV9TT1VSQ0VfTUFTSyB8CmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvb3h5Z2VuL3hvbmFyX2NzNDN4eC5jIGIvc291bmQvcGNpL294eWdlbi94b25hcl9jczQzeHguYwppbmRleCA5ZjcyZDQyLi4yNTI3MTkxIDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvb3h5Z2VuL3hvbmFyX2NzNDN4eC5jCisrKyBiL3NvdW5kL3BjaS9veHlnZW4veG9uYXJfY3M0M3h4LmMKQEAgLTM5Miw3ICszOTIsNyBAQAogCXVuc2lnbmVkIGludCBpOwogCiAJc25kX2lwcmludGYoYnVmZmVyLCAiXG5DUzQzOTg6IDc/Iik7Ci0JZm9yIChpID0gMjsgaSA8PSA4OyArK2kpCisJZm9yIChpID0gMjsgaSA8IDg7ICsraSkKIAkJc25kX2lwcmludGYoYnVmZmVyLCAiICUwMngiLCBkYXRhLT5jczQzOThfcmVnc1tpXSk7CiAJc25kX2lwcmludGYoYnVmZmVyLCAiXG4iKTsKIAlkdW1wX2NzNDM2MmFfcmVnaXN0ZXJzKGRhdGEsIGJ1ZmZlcik7CmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvb3h5Z2VuL3hvbmFyX2RnLmMgYi9zb3VuZC9wY2kvb3h5Z2VuL3hvbmFyX2RnLmMKaW5kZXggZTRkZTBiOC4uYmM2ZWI1OCAxMDA2NDQKLS0tIGEvc291bmQvcGNpL294eWdlbi94b25hcl9kZy5jCisrKyBiL3NvdW5kL3BjaS9veHlnZW4veG9uYXJfZGcuYwpAQCAtMjQsNiArMjQsMTEgQEAKICAqCiAgKiAgIFNQSSAwIC0+IENTNDI0NQogICoKKyAqICAgScKyUyAxIC0+IENTNDI0NQorICogICBJwrJTIDIgLT4gQ1M0MzYxIChjZW50ZXIvTEZFKQorICogICBJwrJTIDMgLT4gQ1M0MzYxIChzdXJyb3VuZCkKKyAqICAgScKyUyA0IC0+IENTNDM2MSAoZnJvbnQpCisgKgogICogICBHUElPIDMgPC0gPwogICogICBHUElPIDQgPC0gaGVhZHBob25lIGRldGVjdAogICogICBHUElPIDUgLT4gcm91dGUgaW5wdXQgamFjayB0byBsaW5lLWluICgwKSBvciBtaWMtaW4gKDEpCkBAIC0zNiw2ICs0MSw3IEBACiAgKiAgIGlucHV0IDEgPC0gYXV4CiAgKiAgIGlucHV0IDIgPC0gZnJvbnQgbWljCiAgKiAgIGlucHV0IDQgPC0gbGluZS9taWMKKyAqICAgREFDIG91dCAtPiBoZWFkcGhvbmVzCiAgKiAgIGF1eCBvdXQgLT4gZnJvbnQgcGFuZWwgaGVhZHBob25lcwogICovCiAKQEAgLTc1LDcgKzgxLDcgQEAKIAkJCSBPWFlHRU5fU1BJX0NFTl9MQVRDSF9DTE9DS19ISSwKIAkJCSBDUzQyNDVfU1BJX0FERFJFU1MgfAogCQkJIENTNDI0NV9TUElfV1JJVEUgfAotCQkJICh2YWx1ZSA8PCA4KSB8IHJlZyk7CisJCQkgKHJlZyA8PCA4KSB8IHZhbHVlKTsKIAlkYXRhLT5jczQyNDVfcmVnc1tyZWddID0gdmFsdWU7CiB9CiAKQEAgLTIwNyw2ICsyMTMsMzUgQEAKIAljczQyNDVfd3JpdGVfY2FjaGVkKGNoaXAsIENTNDI0NV9BRENfQ1RSTCwgdmFsdWUpOwogfQogCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGludCBzaGlmdF9iaXRzKHVuc2lnbmVkIGludCB2YWx1ZSwKKwkJCQkgICAgICB1bnNpZ25lZCBpbnQgc2hpZnRfZnJvbSwKKwkJCQkgICAgICB1bnNpZ25lZCBpbnQgc2hpZnRfdG8sCisJCQkJICAgICAgdW5zaWduZWQgaW50IG1hc2spCit7CisJaWYgKHNoaWZ0X2Zyb20gPCBzaGlmdF90bykKKwkJcmV0dXJuICh2YWx1ZSA8PCAoc2hpZnRfdG8gLSBzaGlmdF9mcm9tKSkgJiBtYXNrOworCWVsc2UKKwkJcmV0dXJuICh2YWx1ZSA+PiAoc2hpZnRfZnJvbSAtIHNoaWZ0X3RvKSkgJiBtYXNrOworfQorCitzdGF0aWMgdW5zaWduZWQgaW50IGFkanVzdF9kZ19kYWNfcm91dGluZyhzdHJ1Y3Qgb3h5Z2VuICpjaGlwLAorCQkJCQkgIHVuc2lnbmVkIGludCBwbGF5X3JvdXRpbmcpCit7CisJcmV0dXJuIChwbGF5X3JvdXRpbmcgJiBPWFlHRU5fUExBWV9EQUMwX1NPVVJDRV9NQVNLKSB8CisJICAgICAgIHNoaWZ0X2JpdHMocGxheV9yb3V0aW5nLAorCQkJICBPWFlHRU5fUExBWV9EQUMyX1NPVVJDRV9TSElGVCwKKwkJCSAgT1hZR0VOX1BMQVlfREFDMV9TT1VSQ0VfU0hJRlQsCisJCQkgIE9YWUdFTl9QTEFZX0RBQzFfU09VUkNFX01BU0spIHwKKwkgICAgICAgc2hpZnRfYml0cyhwbGF5X3JvdXRpbmcsCisJCQkgIE9YWUdFTl9QTEFZX0RBQzFfU09VUkNFX1NISUZULAorCQkJICBPWFlHRU5fUExBWV9EQUMyX1NPVVJDRV9TSElGVCwKKwkJCSAgT1hZR0VOX1BMQVlfREFDMl9TT1VSQ0VfTUFTSykgfAorCSAgICAgICBzaGlmdF9iaXRzKHBsYXlfcm91dGluZywKKwkJCSAgT1hZR0VOX1BMQVlfREFDMF9TT1VSQ0VfU0hJRlQsCisJCQkgIE9YWUdFTl9QTEFZX0RBQzNfU09VUkNFX1NISUZULAorCQkJICBPWFlHRU5fUExBWV9EQUMzX1NPVVJDRV9NQVNLKTsKK30KKwogc3RhdGljIGludCBvdXRwdXRfc3dpdGNoX2luZm8oc3RydWN0IHNuZF9rY29udHJvbCAqY3RsLAogCQkJICAgICAgc3RydWN0IHNuZF9jdGxfZWxlbV9pbmZvICppbmZvKQogewpAQCAtNTU3LDYgKzU5Miw3IEBACiAJLnJlc3VtZSA9IGRnX3Jlc3VtZSwKIAkuc2V0X2RhY19wYXJhbXMgPSBzZXRfY3M0MjQ1X2RhY19wYXJhbXMsCiAJLnNldF9hZGNfcGFyYW1zID0gc2V0X2NzNDI0NV9hZGNfcGFyYW1zLAorCS5hZGp1c3RfZGFjX3JvdXRpbmcgPSBhZGp1c3RfZGdfZGFjX3JvdXRpbmcsCiAJLmR1bXBfcmVnaXN0ZXJzID0gZHVtcF9jczQyNDVfcmVnaXN0ZXJzLAogCS5tb2RlbF9kYXRhX3NpemUgPSBzaXplb2Yoc3RydWN0IGRnKSwKIAkuZGV2aWNlX2NvbmZpZyA9IFBMQVlCQUNLXzBfVE9fSTJTIHwKZGlmZiAtLWdpdCBhL3NvdW5kL3BjbWNpYS9wZGF1ZGlvY2YvcGRhdWRpb2NmLmggYi9zb3VuZC9wY21jaWEvcGRhdWRpb2NmL3BkYXVkaW9jZi5oCmluZGV4IGJkMjZlMDkuLjZjZTlhZDcgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjbWNpYS9wZGF1ZGlvY2YvcGRhdWRpb2NmLmgKKysrIGIvc291bmQvcGNtY2lhL3BkYXVkaW9jZi9wZGF1ZGlvY2YuaApAQCAtMjIsNyArMjIsNyBAQAogI2RlZmluZSBfX1BEQVVESU9DRl9ICiAKICNpbmNsdWRlIDxzb3VuZC9wY20uaD4KLSNpbmNsdWRlIDxhc20vaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9pby5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPHBjbWNpYS9jaXN0cGwuaD4KICNpbmNsdWRlIDxwY21jaWEvZHMuaD4KZGlmZiAtLWdpdCBhL3NvdW5kL3BjbWNpYS92eC92eHBfb3BzLmMgYi9zb3VuZC9wY21jaWEvdngvdnhwX29wcy5jCmluZGV4IDk4OWUwNGEuLmZlMzNlMTIgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjbWNpYS92eC92eHBfb3BzLmMKKysrIGIvc291bmQvcGNtY2lhL3Z4L3Z4cF9vcHMuYwpAQCAtMjMsOCArMjMsOCBAQAogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvZmlybXdhcmUuaD4KKyNpbmNsdWRlIDxsaW51eC9pby5oPgogI2luY2x1ZGUgPHNvdW5kL2NvcmUuaD4KLSNpbmNsdWRlIDxhc20vaW8uaD4KICNpbmNsdWRlICJ2eHBvY2tldC5oIgogCiAKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9hdG1lbC9zbmQtc29jLWFmZWI5MjYwLmMgYi9zb3VuZC9zb2MvYXRtZWwvc25kLXNvYy1hZmViOTI2MC5jCmluZGV4IGRhMjIwOGUuLjVlNGQ0OTkgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9hdG1lbC9zbmQtc29jLWFmZWI5MjYwLmMKKysrIGIvc291bmQvc29jL2F0bWVsL3NuZC1zb2MtYWZlYjkyNjAuYwpAQCAtMTI5LDcgKzEyOSw3IEBACiAJLmNwdV9kYWlfbmFtZSA9ICJhdG1lbC1zc2MtZGFpLjAiLAogCS5jb2RlY19kYWlfbmFtZSA9ICJ0bHYzMjBhaWMyMy1oaWZpIiwKIAkucGxhdGZvcm1fbmFtZSA9ICJhdG1lbF9wY20tYXVkaW8iLAotCS5jb2RlY19uYW1lID0gInRsdjMyMGFpYzIzLWNvZGVjLjAtMHgxYSIsCisJLmNvZGVjX25hbWUgPSAidGx2MzIwYWljMjMtY29kZWMuMC0wMDFhIiwKIAkuaW5pdCA9IGFmZWI5MjYwX3RsdjMyMGFpYzIzX2luaXQsCiAJLm9wcyA9ICZhZmViOTI2MF9vcHMsCiB9OwpkaWZmIC0tZ2l0IGEvc291bmQvc29jL2JsYWNrZmluL0tjb25maWcgYi9zb3VuZC9zb2MvYmxhY2tmaW4vS2NvbmZpZwppbmRleCAzYWJlZWRkLi5hZTQwMzU5IDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvYmxhY2tmaW4vS2NvbmZpZworKysgYi9zb3VuZC9zb2MvYmxhY2tmaW4vS2NvbmZpZwpAQCAtMSw2ICsxLDcgQEAKIGNvbmZpZyBTTkRfQkY1WFhfSTJTCiAJdHJpc3RhdGUgIlNvQyBJMlMgQXVkaW8gZm9yIHRoZSBBREkgQkY1eHggY2hpcCIKIAlkZXBlbmRzIG9uIEJMQUNLRklOCisJc2VsZWN0IFNORF9CRjVYWF9TT0NfU1BPUlQKIAloZWxwCiAJICBTYXkgWSBvciBNIGlmIHlvdSB3YW50IHRvIGFkZCBzdXBwb3J0IGZvciBjb2RlY3MgYXR0YWNoZWQgdG8KIAkgIHRoZSBCbGFja2ZpbiBTUE9SVCAoc3luY2hyb25vdXMgc2VyaWFsIHBvcnRzKSBpbnRlcmZhY2UgaW4gSTJTCkBAIC0zNSw2ICszNiw3IEBACiBjb25maWcgU05EX0JGNVhYX1RETQogCXRyaXN0YXRlICJTb0MgSTJTKFRETSBtb2RlKSBBdWRpbyBmb3IgdGhlIEFESSBCRjV4eCBjaGlwIgogCWRlcGVuZHMgb24gKEJMQUNLRklOICYmIFNORF9TT0MpCisJc2VsZWN0IFNORF9CRjVYWF9TT0NfU1BPUlQKIAloZWxwCiAJICBTYXkgWSBvciBNIGlmIHlvdSB3YW50IHRvIGFkZCBzdXBwb3J0IGZvciBjb2RlY3MgYXR0YWNoZWQgdG8KIAkgIHRoZSBCbGFja2ZpbiBTUE9SVCAoc3luY2hyb25vdXMgc2VyaWFsIHBvcnRzKSBpbnRlcmZhY2UgaW4gVERNCkBAIC02MSw2ICs2MywxMCBAQAogY29uZmlnIFNORF9CRjVYWF9BQzk3CiAJdHJpc3RhdGUgIlNvQyBBQzk3IEF1ZGlvIGZvciB0aGUgQURJIEJGNXh4IGNoaXAiCiAJZGVwZW5kcyBvbiBCTEFDS0ZJTgorCXNlbGVjdCBBQzk3X0JVUworCXNlbGVjdCBTTkRfU09DX0FDOTdfQlVTCisJc2VsZWN0IFNORF9CRjVYWF9TT0NfU1BPUlQKKwlzZWxlY3QgU05EX0JGNVhYX1NPQ19BQzk3CiAJaGVscAogCSAgU2F5IFkgb3IgTSBpZiB5b3Ugd2FudCB0byBhZGQgc3VwcG9ydCBmb3IgY29kZWNzIGF0dGFjaGVkIHRvCiAJICB0aGUgQmxhY2tmaW4gU1BPUlQgKHN5bmNocm9ub3VzIHNlcmlhbCBwb3J0cykgaW50ZXJmYWNlIGluIHNsb3QgMTYKQEAgLTEyMiwxNyArMTI4LDEyIEBACiAKIGNvbmZpZyBTTkRfQkY1WFhfU09DX0kyUwogCXRyaXN0YXRlCi0Jc2VsZWN0IFNORF9CRjVYWF9TT0NfU1BPUlQKIAogY29uZmlnIFNORF9CRjVYWF9TT0NfVERNCiAJdHJpc3RhdGUKLQlzZWxlY3QgU05EX0JGNVhYX1NPQ19TUE9SVAogCiBjb25maWcgU05EX0JGNVhYX1NPQ19BQzk3CiAJdHJpc3RhdGUKLQlzZWxlY3QgQUM5N19CVVMKLQlzZWxlY3QgU05EX1NPQ19BQzk3X0JVUwotCXNlbGVjdCBTTkRfQkY1WFhfU09DX1NQT1JUCiAKIGNvbmZpZyBTTkRfQkY1WFhfU1BPUlRfTlVNCiAJaW50ICJTZXQgYSBTUE9SVCBmb3IgU291bmQgY2hpcCIKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9ibGFja2Zpbi9iZjV4eC1hYzk3LmMgYi9zb3VuZC9zb2MvYmxhY2tmaW4vYmY1eHgtYWM5Ny5jCmluZGV4IGM1Zjg1NmVjLi5mZmJhYzI2IDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvYmxhY2tmaW4vYmY1eHgtYWM5Ny5jCisrKyBiL3NvdW5kL3NvYy9ibGFja2Zpbi9iZjV4eC1hYzk3LmMKQEAgLTI2MCw5ICsyNjAsOSBAQAogCXByX2RlYnVnKCIlcyA6IHNwb3J0ICVkXG4iLCBfX2Z1bmNfXywgZGFpLT5pZCk7CiAJaWYgKCFkYWktPmFjdGl2ZSkKIAkJcmV0dXJuIDA7Ci0JaWYgKGRhaS0+Y2FwdHVyZS5hY3RpdmUpCisJaWYgKGRhaS0+Y2FwdHVyZV9hY3RpdmUpCiAJCXNwb3J0X3J4X3N0b3Aoc3BvcnQpOwotCWlmIChkYWktPnBsYXliYWNrLmFjdGl2ZSkKKwlpZiAoZGFpLT5wbGF5YmFja19hY3RpdmUpCiAJCXNwb3J0X3R4X3N0b3Aoc3BvcnQpOwogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvc291bmQvc29jL2JsYWNrZmluL2JmNXh4LXNzbTI2MDIuYyBiL3NvdW5kL3NvYy9ibGFja2Zpbi9iZjV4eC1zc20yNjAyLmMKaW5kZXggZTkwMmIyNC4uYWQyODY2MyAxMDA2NDQKLS0tIGEvc291bmQvc29jL2JsYWNrZmluL2JmNXh4LXNzbTI2MDIuYworKysgYi9zb3VuZC9zb2MvYmxhY2tmaW4vYmY1eHgtc3NtMjYwMi5jCkBAIC0xMTksNyArMTE5LDcgQEAKIAkuY3B1X2RhaV9uYW1lID0gImJmNXh4LWkycyIsCiAJLmNvZGVjX2RhaV9uYW1lID0gInNzbTI2MDItaGlmaSIsCiAJLnBsYXRmb3JtX25hbWUgPSAiYmY1eHgtcGNtLWF1ZGlvIiwKLQkuY29kZWNfbmFtZSA9ICJzc20yNjAyLWNvZGVjLjAtMHgxYiIsCisJLmNvZGVjX25hbWUgPSAic3NtMjYwMi1jb2RlYy4wLTAwMWIiLAogCS5vcHMgPSAmYmY1eHhfc3NtMjYwMl9vcHMsCiB9OwogCmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvYmxhY2tmaW4vYmY1eHgtdGRtLmMgYi9zb3VuZC9zb2MvYmxhY2tmaW4vYmY1eHgtdGRtLmMKaW5kZXggMTI1MTIzOS4uNTUxNWFjOSAxMDA2NDQKLS0tIGEvc291bmQvc29jL2JsYWNrZmluL2JmNXh4LXRkbS5jCisrKyBiL3NvdW5kL3NvYy9ibGFja2Zpbi9iZjV4eC10ZG0uYwpAQCAtMjEwLDcgKzIxMCw3IEBACiAjaWZkZWYgQ09ORklHX1BNCiBzdGF0aWMgaW50IGJmNXh4X3RkbV9zdXNwZW5kKHN0cnVjdCBzbmRfc29jX2RhaSAqZGFpKQogewotCXN0cnVjdCBzcG9ydF9kZXZpY2UgKnNwb3J0ID0gZGFpLT5wcml2YXRlX2RhdGE7CisJc3RydWN0IHNwb3J0X2RldmljZSAqc3BvcnQgPSBzbmRfc29jX2RhaV9nZXRfZHJ2ZGF0YShkYWkpOwogCiAJaWYgKCFkYWktPmFjdGl2ZSkKIAkJcmV0dXJuIDA7CkBAIC0yMzUsMTMgKzIzNSwxMyBAQAogCQlyZXQgPSAtRUJVU1k7CiAJfQogCi0JcmV0ID0gc3BvcnRfY29uZmlnX3J4KHNwb3J0LCBJUkZTLCAweDFGLCAwLCAwKTsKKwlyZXQgPSBzcG9ydF9jb25maWdfcngoc3BvcnQsIDAsIDB4MUYsIDAsIDApOwogCWlmIChyZXQpIHsKIAkJcHJfZXJyKCJTUE9SVCBpcyBidXN5IVxuIik7CiAJCXJldCA9IC1FQlVTWTsKIAl9CiAKLQlyZXQgPSBzcG9ydF9jb25maWdfdHgoc3BvcnQsIElURlMsIDB4MUYsIDAsIDApOworCXJldCA9IHNwb3J0X2NvbmZpZ190eChzcG9ydCwgMCwgMHgxRiwgMCwgMCk7CiAJaWYgKHJldCkgewogCQlwcl9lcnIoIlNQT1JUIGlzIGJ1c3khXG4iKTsKIAkJcmV0ID0gLUVCVVNZOwpAQCAtMzAzLDE0ICszMDMsMTQgQEAKIAkJZ290byBzcG9ydF9jb25maWdfZXJyOwogCX0KIAotCXJldCA9IHNwb3J0X2NvbmZpZ19yeChzcG9ydF9oYW5kbGUsIElSRlMsIDB4MUYsIDAsIDApOworCXJldCA9IHNwb3J0X2NvbmZpZ19yeChzcG9ydF9oYW5kbGUsIDAsIDB4MUYsIDAsIDApOwogCWlmIChyZXQpIHsKIAkJcHJfZXJyKCJTUE9SVCBpcyBidXN5IVxuIik7CiAJCXJldCA9IC1FQlVTWTsKIAkJZ290byBzcG9ydF9jb25maWdfZXJyOwogCX0KIAotCXJldCA9IHNwb3J0X2NvbmZpZ190eChzcG9ydF9oYW5kbGUsIElURlMsIDB4MUYsIDAsIDApOworCXJldCA9IHNwb3J0X2NvbmZpZ190eChzcG9ydF9oYW5kbGUsIDAsIDB4MUYsIDAsIDApOwogCWlmIChyZXQpIHsKIAkJcHJfZXJyKCJTUE9SVCBpcyBidXN5IVxuIik7CiAJCXJldCA9IC1FQlVTWTsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3MvS2NvbmZpZyBiL3NvdW5kL3NvYy9jb2RlY3MvS2NvbmZpZwppbmRleCA4ODNhMzEyLi5jNDhiMjNjIDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvY29kZWNzL0tjb25maWcKKysrIGIvc291bmQvc29jL2NvZGVjcy9LY29uZmlnCkBAIC00NCw3ICs0NCw3IEBACiAJc2VsZWN0IFNORF9TT0NfVFdMNjA0MCBpZiBUV0w0MDMwX0NPUkUKIAlzZWxlY3QgU05EX1NPQ19VREExMzRYCiAJc2VsZWN0IFNORF9TT0NfVURBMTM4MCBpZiBJMkMKLQlzZWxlY3QgU05EX1NPQ19XTDEyNzMgaWYgV0wxMjczX0NPUkUKKwlzZWxlY3QgU05EX1NPQ19XTDEyNzMgaWYgUkFESU9fV0wxMjczCiAJc2VsZWN0IFNORF9TT0NfV00yMDAwIGlmIEkyQwogCXNlbGVjdCBTTkRfU09DX1dNODM1MCBpZiBNRkRfV004MzUwCiAJc2VsZWN0IFNORF9TT0NfV004NDAwIGlmIE1GRF9XTTg0MDAKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3MvY3E5M3ZjLmMgYi9zb3VuZC9zb2MvY29kZWNzL2NxOTN2Yy5jCmluZGV4IDQ2ZGJmZDAuLjM0N2E1NjcgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3MvY3E5M3ZjLmMKKysrIGIvc291bmQvc29jL2NvZGVjcy9jcTkzdmMuYwpAQCAtMTUzLDcgKzE1Myw3IEBACiAKIHN0YXRpYyBpbnQgY3E5M3ZjX3Byb2JlKHN0cnVjdCBzbmRfc29jX2NvZGVjICpjb2RlYykKIHsKLQlzdHJ1Y3QgZGF2aW5jaV92YyAqZGF2aW5jaV92YyA9IGNvZGVjLT5kZXYtPnBsYXRmb3JtX2RhdGE7CisJc3RydWN0IGRhdmluY2lfdmMgKmRhdmluY2lfdmMgPSBzbmRfc29jX2NvZGVjX2dldF9kcnZkYXRhKGNvZGVjKTsKIAogCWRhdmluY2lfdmMtPmNxOTN2Yy5jb2RlYyA9IGNvZGVjOwogCWNvZGVjLT5jb250cm9sX2RhdGEgPSBkYXZpbmNpX3ZjOwpkaWZmIC0tZ2l0IGEvc291bmQvc29jL2NvZGVjcy9jeDIwNDQyLmMgYi9zb3VuZC9zb2MvY29kZWNzL2N4MjA0NDIuYwppbmRleCAwM2QxZTg2Li5iYjRiZjY1IDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvY29kZWNzL2N4MjA0NDIuYworKysgYi9zb3VuZC9zb2MvY29kZWNzL2N4MjA0NDIuYwpAQCAtMzY3LDkgKzM2NywxMiBAQAogCXJldHVybiAwOwogfQogCitzdGF0aWMgY29uc3QgdTggY3gyMDQ0Ml9yZWcgPSBDWDIwNDQyX1RFTE9VVCB8IENYMjA0NDJfTUlDOworCiBzdGF0aWMgc3RydWN0IHNuZF9zb2NfY29kZWNfZHJpdmVyIGN4MjA0NDJfY29kZWNfZGV2ID0gewogCS5wcm9iZSA9IAljeDIwNDQyX2NvZGVjX3Byb2JlLAogCS5yZW1vdmUgPSAJY3gyMDQ0Ml9jb2RlY19yZW1vdmUsCisJLnJlZ19jYWNoZV9kZWZhdWx0ID0gJmN4MjA0NDJfcmVnLAogCS5yZWdfY2FjaGVfc2l6ZSA9IDEsCiAJLnJlZ193b3JkX3NpemUgPSBzaXplb2YodTgpLAogCS5yZWFkID0gY3gyMDQ0Ml9yZWFkX3JlZ19jYWNoZSwKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9jb2RlY3Mvd2wxMjczLmMgYi9zb3VuZC9zb2MvY29kZWNzL3dsMTI3My5jCmluZGV4IGQzZmZhMmYuLjg2MWIyOGYgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3Mvd2wxMjczLmMKKysrIGIvc291bmQvc29jL2NvZGVjcy93bDEyNzMuYwpAQCAtNDIsNyArNDIsNyBAQAogc3RhdGljIGludCBzbmRfd2wxMjczX2ZtX3NldF9pMnNfbW9kZShzdHJ1Y3Qgd2wxMjczX2NvcmUgKmNvcmUsCiAJCQkJICAgICAgaW50IHJhdGUsIGludCB3aWR0aCkKIHsKLQlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmY29yZS0+aTJjX2Rldi0+ZGV2OworCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZjb3JlLT5jbGllbnQtPmRldjsKIAlpbnQgciA9IDA7CiAJdTE2IG1vZGU7CiAKQEAgLTEyMywxMyArMTIzLDEzIEBACiAJZGV2X2RiZyhkZXYsICJtb2RlOiAweCUwNHhcbiIsIG1vZGUpOwogCiAJaWYgKGNvcmUtPmkyc19tb2RlICE9IG1vZGUpIHsKLQkJciA9IHdsMTI3M19mbV93cml0ZV9jbWQoY29yZSwgV0wxMjczX0kyU19NT0RFX0NPTkZJR19TRVQsIG1vZGUpOworCQlyID0gY29yZS0+d3JpdGUoY29yZSwgV0wxMjczX0kyU19NT0RFX0NPTkZJR19TRVQsIG1vZGUpOwogCQlpZiAocikKIAkJCWdvdG8gb3V0OwogCiAJCWNvcmUtPmkyc19tb2RlID0gbW9kZTsKLQkJciA9IHdsMTI3M19mbV93cml0ZV9jbWQoY29yZSwgV0wxMjczX0FVRElPX0VOQUJMRSwKLQkJCQkJV0wxMjczX0FVRElPX0VOQUJMRV9JMlMpOworCQlyID0gY29yZS0+d3JpdGUoY29yZSwgV0wxMjczX0FVRElPX0VOQUJMRSwKKwkJCQlXTDEyNzNfQVVESU9fRU5BQkxFX0kyUyk7CiAJCWlmIChyKQogCQkJZ290byBvdXQ7CiAJfQpAQCAtMTQyLDggKzE0Miw3IEBACiBzdGF0aWMgaW50IHNuZF93bDEyNzNfZm1fc2V0X2NoYW5uZWxfbnVtYmVyKHN0cnVjdCB3bDEyNzNfY29yZSAqY29yZSwKIAkJCQkJICAgIGludCBjaGFubmVsX251bWJlcikKIHsKLQlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50ID0gY29yZS0+aTJjX2RldjsKLQlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmY2xpZW50LT5kZXY7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJmNvcmUtPmNsaWVudC0+ZGV2OwogCWludCByID0gMDsKIAogCWRldl9kYmcoZGV2LCAiJXNcbiIsIF9fZnVuY19fKTsKQEAgLTE1NCwxNyArMTUzLDEzIEBACiAJCWdvdG8gb3V0OwogCiAJaWYgKGNoYW5uZWxfbnVtYmVyID09IDEgJiYgY29yZS0+bW9kZSA9PSBXTDEyNzNfTU9ERV9SWCkKLQkJciA9IHdsMTI3M19mbV93cml0ZV9jbWQoY29yZSwgV0wxMjczX01PU1RfTU9ERV9TRVQsCi0JCQkJCVdMMTI3M19SWF9NT05PKTsKKwkJciA9IGNvcmUtPndyaXRlKGNvcmUsIFdMMTI3M19NT1NUX01PREVfU0VULCBXTDEyNzNfUlhfTU9OTyk7CiAJZWxzZSBpZiAoY2hhbm5lbF9udW1iZXIgPT0gMSAmJiBjb3JlLT5tb2RlID09IFdMMTI3M19NT0RFX1RYKQotCQlyID0gd2wxMjczX2ZtX3dyaXRlX2NtZChjb3JlLCBXTDEyNzNfTU9OT19TRVQsCi0JCQkJCVdMMTI3M19UWF9NT05PKTsKKwkJciA9IGNvcmUtPndyaXRlKGNvcmUsIFdMMTI3M19NT05PX1NFVCwgV0wxMjczX1RYX01PTk8pOwogCWVsc2UgaWYgKGNoYW5uZWxfbnVtYmVyID09IDIgJiYgY29yZS0+bW9kZSA9PSBXTDEyNzNfTU9ERV9SWCkKLQkJciA9IHdsMTI3M19mbV93cml0ZV9jbWQoY29yZSwgV0wxMjczX01PU1RfTU9ERV9TRVQsCi0JCQkJCVdMMTI3M19SWF9TVEVSRU8pOworCQlyID0gY29yZS0+d3JpdGUoY29yZSwgV0wxMjczX01PU1RfTU9ERV9TRVQsIFdMMTI3M19SWF9TVEVSRU8pOwogCWVsc2UgaWYgKGNoYW5uZWxfbnVtYmVyID09IDIgJiYgY29yZS0+bW9kZSA9PSBXTDEyNzNfTU9ERV9UWCkKLQkJciA9IHdsMTI3M19mbV93cml0ZV9jbWQoY29yZSwgV0wxMjczX01PTk9fU0VULAotCQkJCQlXTDEyNzNfVFhfU1RFUkVPKTsKKwkJciA9IGNvcmUtPndyaXRlKGNvcmUsIFdMMTI3M19NT05PX1NFVCwgV0wxMjczX1RYX1NURVJFTyk7CiAJZWxzZQogCQlyID0gLUVJTlZBTDsKIG91dDoKQEAgLTIzNyw3ICsyMzIsNyBAQAogCWlmICh3bDEyNzMtPmNvcmUtPmF1ZGlvX21vZGUgPT0gdmFsKQogCQlyZXR1cm4gMDsKIAotCXIgPSB3bDEyNzNfZm1fc2V0X2F1ZGlvKHdsMTI3My0+Y29yZSwgdmFsKTsKKwlyID0gd2wxMjczLT5jb3JlLT5zZXRfYXVkaW8od2wxMjczLT5jb3JlLCB2YWwpOwogCWlmIChyIDwgMCkKIAkJcmV0dXJuIHI7CiAKQEAgLTI3Miw4ICsyNjcsOCBAQAogCiAJZGV2X2RiZyhjb2RlYy0+ZGV2LCAiJXM6IGVudGVyLlxuIiwgX19mdW5jX18pOwogCi0JciA9IHdsMTI3M19mbV9zZXRfdm9sdW1lKHdsMTI3My0+Y29yZSwKLQkJCQkgdWNvbnRyb2wtPnZhbHVlLmludGVnZXIudmFsdWVbMF0pOworCXIgPSB3bDEyNzMtPmNvcmUtPnNldF92b2x1bWUod2wxMjczLT5jb3JlLAorCQkJCSAgICAgdWNvbnRyb2wtPnZhbHVlLmludGVnZXIudmFsdWVbMF0pOwogCWlmIChyKQogCQlyZXR1cm4gcjsKIApkaWZmIC0tZ2l0IGEvc291bmQvc29jL2NvZGVjcy93bDEyNzMuaCBiL3NvdW5kL3NvYy9jb2RlY3Mvd2wxMjczLmgKaW5kZXggMTRlZDAyNy4uNDNlYzdlNiAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy93bDEyNzMuaAorKysgYi9zb3VuZC9zb2MvY29kZWNzL3dsMTI3My5oCkBAIC0yNSw3NyArMjUsNiBAQAogI2lmbmRlZiBfX1dMMTI3M19DT0RFQ19IX18KICNkZWZpbmUgX19XTDEyNzNfQ09ERUNfSF9fCiAKLS8qIEkyUyBwcm90b2NvbCwgbGVmdCBjaGFubmVsIGZpcnN0LCBkYXRhIHdpZHRoIDE2IGJpdHMgKi8KLSNkZWZpbmUgV0wxMjczX1BDTV9ERUZfTU9ERQkJMHgwMAotCi0vKiBSeCAqLwotI2RlZmluZSBXTDEyNzNfQVVESU9fRU5BQkxFX0kyUwkJKDEgPDwgMCkKLSNkZWZpbmUgV0wxMjczX0FVRElPX0VOQUJMRV9BTkFMT0cJKDEgPDwgMSkKLQotLyogVHggKi8KLSNkZWZpbmUgV0wxMjczX0FVRElPX0lPX1NFVF9BTkFMT0cJMAotI2RlZmluZSBXTDEyNzNfQVVESU9fSU9fU0VUX0kyUwkJMQotCi0jZGVmaW5lIFdMMTI3M19QT1dFUl9TRVRfT0ZGCQkwCi0jZGVmaW5lIFdMMTI3M19QT1dFUl9TRVRfRk0JCSgxIDw8IDApCi0jZGVmaW5lIFdMMTI3M19QT1dFUl9TRVRfUkRTCQkoMSA8PCAxKQotI2RlZmluZSBXTDEyNzNfUE9XRVJfU0VUX1JFVEVOVElPTgkoMSA8PCA0KQotCi0jZGVmaW5lIFdMMTI3M19QVVBEX1NFVF9PRkYJCTB4MDAKLSNkZWZpbmUgV0wxMjczX1BVUERfU0VUX09OCQkweDAxCi0jZGVmaW5lIFdMMTI3M19QVVBEX1NFVF9SRVRFTlRJT04JMHgxMAotCi0vKiBJMlMgbW9kZSAqLwotI2RlZmluZSBXTDEyNzNfSVMyX1dJRFRIXzMyCTB4MAotI2RlZmluZSBXTDEyNzNfSVMyX1dJRFRIXzQwCTB4MQotI2RlZmluZSBXTDEyNzNfSVMyX1dJRFRIXzIyXzIzCTB4MgotI2RlZmluZSBXTDEyNzNfSVMyX1dJRFRIXzIzXzIyCTB4MwotI2RlZmluZSBXTDEyNzNfSVMyX1dJRFRIXzQ4CTB4NAotI2RlZmluZSBXTDEyNzNfSVMyX1dJRFRIXzUwCTB4NQotI2RlZmluZSBXTDEyNzNfSVMyX1dJRFRIXzYwCTB4NgotI2RlZmluZSBXTDEyNzNfSVMyX1dJRFRIXzY0CTB4NwotI2RlZmluZSBXTDEyNzNfSVMyX1dJRFRIXzgwCTB4OAotI2RlZmluZSBXTDEyNzNfSVMyX1dJRFRIXzk2CTB4OQotI2RlZmluZSBXTDEyNzNfSVMyX1dJRFRIXzEyOAkweGEKLSNkZWZpbmUgV0wxMjczX0lTMl9XSURUSAkweGYKLQotI2RlZmluZSBXTDEyNzNfSVMyX0ZPUk1BVF9TVEQJKDB4MCA8PCA0KQotI2RlZmluZSBXTDEyNzNfSVMyX0ZPUk1BVF9MRUZUCSgweDEgPDwgNCkKLSNkZWZpbmUgV0wxMjczX0lTMl9GT1JNQVRfUklHSFQJKDB4MiA8PCA0KQotI2RlZmluZSBXTDEyNzNfSVMyX0ZPUk1BVF9VU0VSCSgweDMgPDwgNCkKLQotI2RlZmluZSBXTDEyNzNfSVMyX01BU1RFUgkoMHgwIDw8IDYpCi0jZGVmaW5lIFdMMTI3M19JUzJfU0xBVkVXCSgweDEgPDwgNikKLQotI2RlZmluZSBXTDEyNzNfSVMyX1RSSV9BRlRFUl9TRU5ESU5HCSgweDAgPDwgNykKLSNkZWZpbmUgV0wxMjczX0lTMl9UUklfQUxXQVlTX0FDVElWRQkoMHgxIDw8IDcpCi0KLSNkZWZpbmUgV0wxMjczX0lTMl9TRE9XU19SUgkoMHgwIDw8IDgpCi0jZGVmaW5lIFdMMTI3M19JUzJfU0RPV1NfUkYJKDB4MSA8PCA4KQotI2RlZmluZSBXTDEyNzNfSVMyX1NET1dTX0ZSCSgweDIgPDwgOCkKLSNkZWZpbmUgV0wxMjczX0lTMl9TRE9XU19GRgkoMHgzIDw8IDgpCi0KLSNkZWZpbmUgV0wxMjczX0lTMl9UUklfT1BUCSgweDAgPDwgMTApCi0jZGVmaW5lIFdMMTI3M19JUzJfVFJJX0FMV0FZUwkoMHgxIDw8IDEwKQotCi0jZGVmaW5lIFdMMTI3M19JUzJfUkFURV80OEsJKDB4MCA8PCAxMikKLSNkZWZpbmUgV0wxMjczX0lTMl9SQVRFXzQ0XzFLCSgweDEgPDwgMTIpCi0jZGVmaW5lIFdMMTI3M19JUzJfUkFURV8zMksJKDB4MiA8PCAxMikKLSNkZWZpbmUgV0wxMjczX0lTMl9SQVRFXzIyXzA1SwkoMHg0IDw8IDEyKQotI2RlZmluZSBXTDEyNzNfSVMyX1JBVEVfMTZLCSgweDUgPDwgMTIpCi0jZGVmaW5lIFdMMTI3M19JUzJfUkFURV8xMksJKDB4OCA8PCAxMikKLSNkZWZpbmUgV0wxMjczX0lTMl9SQVRFXzExXzAyNQkoMHg5IDw8IDEyKQotI2RlZmluZSBXTDEyNzNfSVMyX1JBVEVfOEsJKDB4YSA8PCAxMikKLSNkZWZpbmUgV0wxMjczX0lTMl9SQVRFCQkoMHhmIDw8IDEyKQotCi0jZGVmaW5lIFdMMTI3M19JMlNfREVGX01PREUJKFdMMTI3M19JUzJfV0lEVEhfMzIgfCBcCi0JCQkJIFdMMTI3M19JUzJfRk9STUFUX1NURCB8IFwKLQkJCQkgV0wxMjczX0lTMl9NQVNURVIgfCBcCi0JCQkJIFdMMTI3M19JUzJfVFJJX0FGVEVSX1NFTkRJTkcgfCBcCi0JCQkJIFdMMTI3M19JUzJfU0RPV1NfUlIgfCBcCi0JCQkJIFdMMTI3M19JUzJfVFJJX09QVCB8IFwKLQkJCQkgV0wxMjczX0lTMl9SQVRFXzQ4SykKLQogaW50IHdsMTI3M19nZXRfZm9ybWF0KHN0cnVjdCBzbmRfc29jX2NvZGVjICpjb2RlYywgdW5zaWduZWQgaW50ICpmbXQpOwogCiAjZW5kaWYJLyogRW5kIG9mIF9fV0wxMjczX0NPREVDX0hfXyAqLwpkaWZmIC0tZ2l0IGEvc291bmQvc29jL2NvZGVjcy93bTg5OTAuYyBiL3NvdW5kL3NvYy9jb2RlY3Mvd204OTkwLmMKaW5kZXggNWM4N2E2My4uMTAwYWVlZSAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy93bTg5OTAuYworKysgYi9zb3VuZC9zb2MvY29kZWNzL3dtODk5MC5jCkBAIC0xMTgzLDcgKzExODMsNyBAQAogCQkJCSAgICAgV004OTkwX1ZNSURUT0cpOwogCiAJCQkvKiBEZWxheSB0byBhbGxvdyBvdXRwdXQgY2FwcyB0byBkaXNjaGFyZ2UgKi8KLQkJCW1zbGVlcChtc2Vjc190b19qaWZmaWVzKDMwMCkpOworCQkJbXNsZWVwKDMwMCk7CiAKIAkJCS8qIERpc2FibGUgVk1JRFRPRyAqLwogCQkJc25kX3NvY193cml0ZShjb2RlYywgV004OTkwX0FOVElQT1AyLCBXTTg5OTBfU09GVFNUIHwKQEAgLTExOTUsMTcgKzExOTUsMTcgQEAKIAkJCS8qIEVuYWJsZSBvdXRwdXRzICovCiAJCQlzbmRfc29jX3dyaXRlKGNvZGVjLCBXTTg5OTBfUE9XRVJfTUFOQUdFTUVOVF8xLCAweDFiMDApOwogCi0JCQltc2xlZXAobXNlY3NfdG9famlmZmllcyg1MCkpOworCQkJbXNsZWVwKDUwKTsKIAogCQkJLyogRW5hYmxlIFZNSUQgYXQgMng1MGsgKi8KIAkJCXNuZF9zb2Nfd3JpdGUoY29kZWMsIFdNODk5MF9QT1dFUl9NQU5BR0VNRU5UXzEsIDB4MWYwMik7CiAKLQkJCW1zbGVlcChtc2Vjc190b19qaWZmaWVzKDEwMCkpOworCQkJbXNsZWVwKDEwMCk7CiAKIAkJCS8qIEVuYWJsZSBWUkVGICovCiAJCQlzbmRfc29jX3dyaXRlKGNvZGVjLCBXTTg5OTBfUE9XRVJfTUFOQUdFTUVOVF8xLCAweDFmMDMpOwogCi0JCQltc2xlZXAobXNlY3NfdG9famlmZmllcyg2MDApKTsKKwkJCW1zbGVlcCg2MDApOwogCiAJCQkvKiBFbmFibGUgQlVGSU9FTiAqLwogCQkJc25kX3NvY193cml0ZShjb2RlYywgV004OTkwX0FOVElQT1AyLCBXTTg5OTBfU09GVFNUIHwKQEAgLTEyNTAsNyArMTI1MCw3IEBACiAJCS8qIERpc2FibGUgVk1JRCAqLwogCQlzbmRfc29jX3dyaXRlKGNvZGVjLCBXTTg5OTBfUE9XRVJfTUFOQUdFTUVOVF8xLCAweDFmMDEpOwogCi0JCW1zbGVlcChtc2Vjc190b19qaWZmaWVzKDMwMCkpOworCQltc2xlZXAoMzAwKTsKIAogCQkvKiBFbmFibGUgYWxsIG91dHB1dCBkaXNjaGFyZ2UgYml0cyAqLwogCQlzbmRfc29jX3dyaXRlKGNvZGVjLCBXTTg5OTBfQU5USVBPUDEsIFdNODk5MF9ESVNfTExJTkUgfApkaWZmIC0tZ2l0IGEvc291bmQvc29jL2NvZGVjcy93bTg5OTQuYyBiL3NvdW5kL3NvYy9jb2RlY3Mvd204OTk0LmMKaW5kZXggMjQ3YTZhOS4uMzdiOGFhOCAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy93bTg5OTQuYworKysgYi9zb3VuZC9zb2MvY29kZWNzL3dtODk5NC5jCkBAIC0xMjg3LDkgKzEyODcsOSBAQAogU05EX1NPQ19EQVBNX1NVUFBMWSgiQUlGMUNMSyIsIFdNODk5NF9BSUYxX0NMT0NLSU5HXzEsIDAsIDAsIE5VTEwsIDApLAogU05EX1NPQ19EQVBNX1NVUFBMWSgiQUlGMkNMSyIsIFdNODk5NF9BSUYyX0NMT0NLSU5HXzEsIDAsIDAsIE5VTEwsIDApLAogCi1TTkRfU09DX0RBUE1fQUlGX09VVCgiQUlGMUFEQzFMIiwgIkFJRjEgQ2FwdHVyZSIsCitTTkRfU09DX0RBUE1fQUlGX09VVCgiQUlGMUFEQzFMIiwgTlVMTCwKIAkJICAgICAwLCBXTTg5OTRfUE9XRVJfTUFOQUdFTUVOVF80LCA5LCAwKSwKLVNORF9TT0NfREFQTV9BSUZfT1VUKCJBSUYxQURDMVIiLCAiQUlGMSBDYXB0dXJlIiwKK1NORF9TT0NfREFQTV9BSUZfT1VUKCJBSUYxQURDMVIiLCBOVUxMLAogCQkgICAgIDAsIFdNODk5NF9QT1dFUl9NQU5BR0VNRU5UXzQsIDgsIDApLAogU05EX1NPQ19EQVBNX0FJRl9JTl9FKCJBSUYxREFDMUwiLCBOVUxMLCAwLAogCQkgICAgICBXTTg5OTRfUE9XRVJfTUFOQUdFTUVOVF81LCA5LCAwLCB3bTg5NThfYWlmX2V2LApAQCAtMTI5OCw5ICsxMjk4LDkgQEAKIAkJICAgICAgV004OTk0X1BPV0VSX01BTkFHRU1FTlRfNSwgOCwgMCwgd204OTU4X2FpZl9ldiwKIAkJICAgICAgU05EX1NPQ19EQVBNX1BPU1RfUE1VIHwgU05EX1NPQ19EQVBNX1BPU1RfUE1EKSwKIAotU05EX1NPQ19EQVBNX0FJRl9PVVQoIkFJRjFBREMyTCIsICJBSUYxIENhcHR1cmUiLAorU05EX1NPQ19EQVBNX0FJRl9PVVQoIkFJRjFBREMyTCIsIE5VTEwsCiAJCSAgICAgMCwgV004OTk0X1BPV0VSX01BTkFHRU1FTlRfNCwgMTEsIDApLAotU05EX1NPQ19EQVBNX0FJRl9PVVQoIkFJRjFBREMyUiIsICJBSUYxIENhcHR1cmUiLAorU05EX1NPQ19EQVBNX0FJRl9PVVQoIkFJRjFBREMyUiIsIE5VTEwsCiAJCSAgICAgMCwgV004OTk0X1BPV0VSX01BTkFHRU1FTlRfNCwgMTAsIDApLAogU05EX1NPQ19EQVBNX0FJRl9JTl9FKCJBSUYxREFDMkwiLCBOVUxMLCAwLAogCQkgICAgICBXTTg5OTRfUE9XRVJfTUFOQUdFTUVOVF81LCAxMSwgMCwgd204OTU4X2FpZl9ldiwKQEAgLTEzNDUsNiArMTM0NSw3IEBACiAKIFNORF9TT0NfREFQTV9BSUZfSU4oIkFJRjFEQUNEQVQiLCAiQUlGMSBQbGF5YmFjayIsIDAsIFNORF9TT0NfTk9QTSwgMCwgMCksCiBTTkRfU09DX0RBUE1fQUlGX0lOKCJBSUYyREFDREFUIiwgIkFJRjIgUGxheWJhY2siLCAwLCBTTkRfU09DX05PUE0sIDAsIDApLAorU05EX1NPQ19EQVBNX0FJRl9PVVQoIkFJRjFBRENEQVQiLCAiQUlGMSBDYXB0dXJlIiwgMCwgU05EX1NPQ19OT1BNLCAwLCAwKSwKIFNORF9TT0NfREFQTV9BSUZfT1VUKCJBSUYyQURDREFUIiwgIkFJRjIgQ2FwdHVyZSIsIDAsIFNORF9TT0NfTk9QTSwgMCwgMCksCiAKIFNORF9TT0NfREFQTV9NVVgoIkFJRjFEQUMgTXV4IiwgU05EX1NPQ19OT1BNLCAwLCAwLCAmYWlmMWRhY19tdXgpLApAQCAtMTU0Niw2ICsxNTQ3LDExIEBACiAJeyAiQUlGMkRBQzJSIE1peGVyIiwgIkxlZnQgU2lkZXRvbmUgU3dpdGNoIiwgIkxlZnQgU2lkZXRvbmUiIH0sCiAJeyAiQUlGMkRBQzJSIE1peGVyIiwgIlJpZ2h0IFNpZGV0b25lIFN3aXRjaCIsICJSaWdodCBTaWRldG9uZSIgfSwKIAorCXsgIkFJRjFBRENEQVQiLCBOVUxMLCAiQUlGMUFEQzFMIiB9LAorCXsgIkFJRjFBRENEQVQiLCBOVUxMLCAiQUlGMUFEQzFSIiB9LAorCXsgIkFJRjFBRENEQVQiLCBOVUxMLCAiQUlGMUFEQzJMIiB9LAorCXsgIkFJRjFBRENEQVQiLCBOVUxMLCAiQUlGMUFEQzJSIiB9LAorCiAJeyAiQUlGMkFEQ0RBVCIsIE5VTEwsICJBSUYyQURDIE11eCIgfSwKIAogCS8qIEFJRjMgb3V0cHV0ICovCkBAIC0xNTc4LDYgKzE1ODQsMTMgQEAKIAl7ICJSaWdodCBIZWFkcGhvbmUgTXV4IiwgIkRBQyIsICJEQUMxUiIgfSwKIH07CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc25kX3NvY19kYXBtX3JvdXRlIHdtODk5NF9yZXZkX2ludGVyY29uW10gPSB7CisJeyAiQUlGMURBQ0RBVCIsIE5VTEwsICJBSUYyREFDREFUIiB9LAorCXsgIkFJRjJEQUNEQVQiLCBOVUxMLCAiQUlGMURBQ0RBVCIgfSwKKwl7ICJBSUYxQURDREFUIiwgTlVMTCwgIkFJRjJBRENEQVQiIH0sCisJeyAiQUlGMkFEQ0RBVCIsIE5VTEwsICJBSUYxQURDREFUIiB9LAorfTsKKwogc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfc29jX2RhcG1fcm91dGUgd204OTk0X2ludGVyY29uW10gPSB7CiAJeyAiQUlGMkRBQ0wiLCBOVUxMLCAiQUlGMkRBQyBNdXgiIH0sCiAJeyAiQUlGMkRBQ1IiLCBOVUxMLCAiQUlGMkRBQyBNdXgiIH0sCkBAIC0yMzg2LDcgKzIzOTksNyBAQAogCWVsc2UKIAkJdmFsID0gMDsKIAotCXJldHVybiBzbmRfc29jX3VwZGF0ZV9iaXRzKGNvZGVjLCByZWcsIG1hc2ssIHJlZyk7CisJcmV0dXJuIHNuZF9zb2NfdXBkYXRlX2JpdHMoY29kZWMsIHJlZywgbWFzaywgdmFsKTsKIH0KIAogI2RlZmluZSBXTTg5OTRfUkFURVMgU05EUlZfUENNX1JBVEVfODAwMF85NjAwMApAQCAtMzEyOSw2ICszMTQyLDExIEBACiAJY2FzZSBXTTg5OTQ6CiAJCXNuZF9zb2NfZGFwbV9hZGRfcm91dGVzKGRhcG0sIHdtODk5NF9pbnRlcmNvbiwKIAkJCQkJQVJSQVlfU0laRSh3bTg5OTRfaW50ZXJjb24pKTsKKworCQlpZiAod204OTk0LT5yZXZpc2lvbiA8IDQpCisJCQlzbmRfc29jX2RhcG1fYWRkX3JvdXRlcyhkYXBtLCB3bTg5OTRfcmV2ZF9pbnRlcmNvbiwKKwkJCQkJCUFSUkFZX1NJWkUod204OTk0X3JldmRfaW50ZXJjb24pKTsKKwkJCQogCQlicmVhazsKIAljYXNlIFdNODk1ODoKIAkJc25kX3NvY19kYXBtX2FkZF9yb3V0ZXMoZGFwbSwgd204OTU4X2ludGVyY29uLApkaWZmIC0tZ2l0IGEvc291bmQvc29jL2NvZGVjcy93bTg5OTUuYyBiL3NvdW5kL3NvYy9jb2RlY3Mvd204OTk1LmMKaW5kZXggNjA0NWNiZC4uNjA4Yzg0YyAxMDA2NDQKLS0tIGEvc291bmQvc29jL2NvZGVjcy93bTg5OTUuYworKysgYi9zb3VuZC9zb2MvY29kZWNzL3dtODk5NS5jCkBAIC0xMjIzLDcgKzEyMjMsNyBAQAogCWVsc2UKIAkJdmFsID0gMDsKIAotCXJldHVybiBzbmRfc29jX3VwZGF0ZV9iaXRzKGNvZGVjLCByZWcsIG1hc2ssIHJlZyk7CisJcmV0dXJuIHNuZF9zb2NfdXBkYXRlX2JpdHMoY29kZWMsIHJlZywgbWFzaywgdmFsKTsKIH0KIAogLyogVGhlIHNpemUgaW4gYml0cyBvZiB0aGUgRkxMIGRpdmlkZSBtdWx0aXBsaWVkIGJ5IDEwCmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvY29kZWNzL3dtX2h1YnMuYyBiL3NvdW5kL3NvYy9jb2RlY3Mvd21faHVicy5jCmluZGV4IGM0NjY5ODIuLjYxM2RmNWQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9jb2RlY3Mvd21faHVicy5jCisrKyBiL3NvdW5kL3NvYy9jb2RlY3Mvd21faHVicy5jCkBAIC05MSw2ICs5MSw3IEBACiBzdGF0aWMgdm9pZCBjYWxpYnJhdGVfZGNfc2Vydm8oc3RydWN0IHNuZF9zb2NfY29kZWMgKmNvZGVjKQogewogCXN0cnVjdCB3bV9odWJzX2RhdGEgKmh1YnMgPSBzbmRfc29jX2NvZGVjX2dldF9kcnZkYXRhKGNvZGVjKTsKKwlzOCBvZmZzZXQ7CiAJdTE2IHJlZywgcmVnX2wsIHJlZ19yLCBkY3NfY2ZnOwogCiAJLyogSWYgd2UncmUgdXNpbmcgYSBkaWdpdGFsIG9ubHkgcGF0aCBhbmQgaGF2ZSBhIHByZXZpb3VzbHkKQEAgLTE0OSwxNiArMTUwLDE0IEBACiAJCQlodWJzLT5kY3NfY29kZXMpOwogCiAJCS8qIEhQT1VUMUwgKi8KLQkJaWYgKHJlZ19sICsgaHVicy0+ZGNzX2NvZGVzID4gMCAmJgotCQkgICAgcmVnX2wgKyBodWJzLT5kY3NfY29kZXMgPCAweGZmKQotCQkJcmVnX2wgKz0gaHVicy0+ZGNzX2NvZGVzOwotCQlkY3NfY2ZnID0gcmVnX2wgPDwgV004OTkzX0RDU19EQUNfV1JfVkFMXzFfU0hJRlQ7CisJCW9mZnNldCA9IHJlZ19sOworCQlvZmZzZXQgKz0gaHVicy0+ZGNzX2NvZGVzOworCQlkY3NfY2ZnID0gKHU4KW9mZnNldCA8PCBXTTg5OTNfRENTX0RBQ19XUl9WQUxfMV9TSElGVDsKIAogCQkvKiBIUE9VVDFSICovCi0JCWlmIChyZWdfciArIGh1YnMtPmRjc19jb2RlcyA+IDAgJiYKLQkJICAgIHJlZ19yICsgaHVicy0+ZGNzX2NvZGVzIDwgMHhmZikKLQkJCXJlZ19yICs9IGh1YnMtPmRjc19jb2RlczsKLQkJZGNzX2NmZyB8PSByZWdfcjsKKwkJb2Zmc2V0ID0gcmVnX3I7CisJCW9mZnNldCArPSBodWJzLT5kY3NfY29kZXM7CisJCWRjc19jZmcgfD0gKHU4KW9mZnNldDsKIAogCQlkZXZfZGJnKGNvZGVjLT5kZXYsICJEQ1MgcmVzdWx0OiAleFxuIiwgZGNzX2NmZyk7CiAKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9kYXZpbmNpL2RhdmluY2ktZXZtLmMgYi9zb3VuZC9zb2MvZGF2aW5jaS9kYXZpbmNpLWV2bS5jCmluZGV4IDBjMmQ2YmEuLmZlNzk4NDIgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9kYXZpbmNpL2RhdmluY2ktZXZtLmMKKysrIGIvc291bmQvc29jL2RhdmluY2kvZGF2aW5jaS1ldm0uYwpAQCAtMjE4LDEyICsyMTgsMjQgQEAKIAkJLm9wcyA9ICZldm1fc3BkaWZfb3BzLAogCX0sCiB9Owotc3RhdGljIHN0cnVjdCBzbmRfc29jX2RhaV9saW5rIGRhOHh4X2V2bV9kYWkgPSB7CisKK3N0YXRpYyBzdHJ1Y3Qgc25kX3NvY19kYWlfbGluayBkYTgzMF9ldm1fZGFpID0geworCS5uYW1lID0gIlRMVjMyMEFJQzNYIiwKKwkuc3RyZWFtX25hbWUgPSAiQUlDM1giLAorCS5jcHVfZGFpX25hbWUgPSAiZGF2aW5jaS1tY2FzcC4xIiwKKwkuY29kZWNfZGFpX25hbWUgPSAidGx2MzIwYWljM3gtaGlmaSIsCisJLmNvZGVjX25hbWUgPSAidGx2MzIwYWljM3gtY29kZWMuMS0wMDE4IiwKKwkucGxhdGZvcm1fbmFtZSA9ICJkYXZpbmNpLXBjbS1hdWRpbyIsCisJLmluaXQgPSBldm1fYWljM3hfaW5pdCwKKwkub3BzID0gJmV2bV9vcHMsCit9OworCitzdGF0aWMgc3RydWN0IHNuZF9zb2NfZGFpX2xpbmsgZGE4NTBfZXZtX2RhaSA9IHsKIAkubmFtZSA9ICJUTFYzMjBBSUMzWCIsCiAJLnN0cmVhbV9uYW1lID0gIkFJQzNYIiwKIAkuY3B1X2RhaV9uYW1lPSAiZGF2aW5jaS1tY2FzcC4wIiwKIAkuY29kZWNfZGFpX25hbWUgPSAidGx2MzIwYWljM3gtaGlmaSIsCi0JLmNvZGVjX25hbWUgPSAidGx2MzIwYWljM3gtY29kZWMuMC0wMDFhIiwKKwkuY29kZWNfbmFtZSA9ICJ0bHYzMjBhaWMzeC1jb2RlYy4xLTAwMTgiLAogCS5wbGF0Zm9ybV9uYW1lID0gImRhdmluY2ktcGNtLWF1ZGlvIiwKIAkuaW5pdCA9IGV2bV9haWMzeF9pbml0LAogCS5vcHMgPSAmZXZtX29wcywKQEAgLTI1OSwxMyArMjcxLDEzIEBACiAKIHN0YXRpYyBzdHJ1Y3Qgc25kX3NvY19jYXJkIGRhODMwX3NuZF9zb2NfY2FyZCA9IHsKIAkubmFtZSA9ICJEQTgzMC9PTUFQLUwxMzcgRVZNIiwKLQkuZGFpX2xpbmsgPSAmZGE4eHhfZXZtX2RhaSwKKwkuZGFpX2xpbmsgPSAmZGE4MzBfZXZtX2RhaSwKIAkubnVtX2xpbmtzID0gMSwKIH07CiAKIHN0YXRpYyBzdHJ1Y3Qgc25kX3NvY19jYXJkIGRhODUwX3NuZF9zb2NfY2FyZCA9IHsKIAkubmFtZSA9ICJEQTg1MC9PTUFQLUwxMzggRVZNIiwKLQkuZGFpX2xpbmsgPSAmZGE4eHhfZXZtX2RhaSwKKwkuZGFpX2xpbmsgPSAmZGE4NTBfZXZtX2RhaSwKIAkubnVtX2xpbmtzID0gMSwKIH07CiAKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9lcDkzeHgvZXA5M3h4LWkycy5jIGIvc291bmQvc29jL2VwOTN4eC9lcDkzeHgtaTJzLmMKaW5kZXggOWFjOTNmNi4uZmZmNTc5YSAxMDA2NDQKLS0tIGEvc291bmQvc29jL2VwOTN4eC9lcDkzeHgtaTJzLmMKKysrIGIvc291bmQvc29jL2VwOTN4eC9lcDkzeHgtaTJzLmMKQEAgLTI2NywxNCArMjY3LDE2IEBACiAJCWVwOTN4eF9pMnNfd3JpdGVfcmVnKGluZm8sIEVQOTNYWF9JMlNfUlhXUkRMRU4sIHdvcmRfbGVuKTsKIAogCS8qCi0JICogQ2FsY3VsYXRlIHRoZSBzZGl2IChiaXQgY2xvY2spIGFuZCBscmRpdiAobGVmdC9yaWdodCBjbG9jaykgdmFsdWVzLgotCSAqIElmIHRoZSBscmNsayBpcyBwdWxzZSBsZW5ndGggaXMgbGFyZ2VyIHRoYW4gdGhlIHdvcmQgc2l6ZSwgdGhlbiB0aGUKLQkgKiBiaXQgY2xvY2sgd2lsbCBiZSBnYXRlZCBmb3IgdGhlIHVudXNlZCBiaXRzLgorCSAqIEVQOTN4eCBJMlMgbW9kdWxlIGNhbiBiZSBzZXR1cCBzbyBTQ0xLIC8gTFJDTEsgdmFsdWUgY2FuIGJlCisJICogMzIsIDY0LCAxMjguIE1DTEsgLyBTQ0xLIHZhbHVlIGNhbiBiZSAyIGFuZCA0LgorCSAqIFdlIHNldCBMUkNMSyBlcXVhbCB0byBgcmF0ZScgYW5kIG1pbmltdW0gU0NMSyAvIExSQ0xLIAorCSAqIHZhbHVlIGlzIDY0LCBiZWNhdXNlIG91ciBzYW1wbGUgc2l6ZSBpcyAzMiBiaXQgKiAyIGNoYW5uZWxzLgorCSAqIEkyUyBzdGFuZGFyZCBwZXJtaXRzIHVzIHRvIHRyYW5zbWl0IG1vcmUgYml0cyB0aGFuCisJICogdGhlIGNvZGVjIHVzZXMuCiAJICovCi0JZGl2ID0gKGNsa19nZXRfcmF0ZShpbmZvLT5tY2xrKSAvIHBhcmFtc19yYXRlKHBhcmFtcykpICoKLQkJcGFyYW1zX2NoYW5uZWxzKHBhcmFtcyk7CisJZGl2ID0gY2xrX2dldF9yYXRlKGluZm8tPm1jbGspIC8gcGFyYW1zX3JhdGUocGFyYW1zKTsKIAlmb3IgKHNkaXYgPSAyOyBzZGl2IDw9IDQ7IHNkaXYgKz0gMikKLQkJZm9yIChscmRpdiA9IDMyOyBscmRpdiA8PSAxMjg7IGxyZGl2IDw8PSAxKQorCQlmb3IgKGxyZGl2ID0gNjQ7IGxyZGl2IDw9IDEyODsgbHJkaXYgPDw9IDEpCiAJCQlpZiAoc2RpdiAqIGxyZGl2ID09IGRpdikgewogCQkJCWZvdW5kID0gMTsKIAkJCQlnb3RvIG91dDsKQEAgLTM0MSw5ICszNDMsNyBAQAogCS5zZXRfZm10CT0gZXA5M3h4X2kyc19zZXRfZGFpX2ZtdCwKIH07CiAKLSNkZWZpbmUgRVA5M1hYX0kyU19GT1JNQVRTIChTTkRSVl9QQ01fRk1UQklUX1MxNl9MRSB8IFwKLQkJCSAgICBTTkRSVl9QQ01fRk1UQklUX1MyNF9MRSB8IFwKLQkJCSAgICBTTkRSVl9QQ01fRk1UQklUX1MzMl9MRSkKKyNkZWZpbmUgRVA5M1hYX0kyU19GT1JNQVRTIChTTkRSVl9QQ01fRk1UQklUX1MzMl9MRSkKIAogc3RhdGljIHN0cnVjdCBzbmRfc29jX2RhaV9kcml2ZXIgZXA5M3h4X2kyc19kYWkgPSB7CiAJLnN5bW1ldHJpY19yYXRlcz0gMSwKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9vbWFwL2Ftcy1kZWx0YS5jIGIvc291bmQvc29jL29tYXAvYW1zLWRlbHRhLmMKaW5kZXggMjEwMWJkYy4uMzE2N2JlNiAxMDA2NDQKLS0tIGEvc291bmQvc29jL29tYXAvYW1zLWRlbHRhLmMKKysrIGIvc291bmQvc29jL29tYXAvYW1zLWRlbHRhLmMKQEAgLTUwNyw4ICs1MDcsNiBAQAogCS8qIFNldCB1cCBkaWdpdGFsIG11dGUgaWYgbm90IHByb3ZpZGVkIGJ5IHRoZSBjb2RlYyAqLwogCWlmICghY29kZWNfZGFpLT5kcml2ZXItPm9wcykgewogCQljb2RlY19kYWktPmRyaXZlci0+b3BzID0gJmFtc19kZWx0YV9kYWlfb3BzOwotCX0gZWxzZSBpZiAoIWNvZGVjX2RhaS0+ZHJpdmVyLT5vcHMtPmRpZ2l0YWxfbXV0ZSkgewotCQljb2RlY19kYWktPmRyaXZlci0+b3BzLT5kaWdpdGFsX211dGUgPSBhbXNfZGVsdGFfZGlnaXRhbF9tdXRlOwogCX0gZWxzZSB7CiAJCWFtc19kZWx0YV9vcHMuc3RhcnR1cCA9IGFtc19kZWx0YV9zdGFydHVwOwogCQlhbXNfZGVsdGFfb3BzLnNodXRkb3duID0gYW1zX2RlbHRhX3NodXRkb3duOwpkaWZmIC0tZ2l0IGEvc291bmQvc29jL3B4YS9jb3JnaS5jIGIvc291bmQvc29jL3B4YS9jb3JnaS5jCmluZGV4IGZjNTkyZjAuLjc4NGNmZjUgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9weGEvY29yZ2kuYworKysgYi9zb3VuZC9zb2MvcHhhL2NvcmdpLmMKQEAgLTMwNywxMCArMzA3LDEwIEBACiBzdGF0aWMgc3RydWN0IHNuZF9zb2NfZGFpX2xpbmsgY29yZ2lfZGFpID0gewogCS5uYW1lID0gIldNODczMSIsCiAJLnN0cmVhbV9uYW1lID0gIldNODczMSIsCi0JLmNwdV9kYWlfbmFtZSA9ICJweGEtaXMyLWRhaSIsCisJLmNwdV9kYWlfbmFtZSA9ICJweGEyeHgtaTJzIiwKIAkuY29kZWNfZGFpX25hbWUgPSAid204NzMxLWhpZmkiLAogCS5wbGF0Zm9ybV9uYW1lID0gInB4YS1wY20tYXVkaW8iLAotCS5jb2RlY19uYW1lID0gIndtODczMS1jb2RlYy0wLjAwMWEiLAorCS5jb2RlY19uYW1lID0gIndtODczMS1jb2RlYy0wLjAwMWIiLAogCS5pbml0ID0gY29yZ2lfd204NzMxX2luaXQsCiAJLm9wcyA9ICZjb3JnaV9vcHMsCiB9OwpkaWZmIC0tZ2l0IGEvc291bmQvc29jL3B4YS9wb29kbGUuYyBiL3NvdW5kL3NvYy9weGEvcG9vZGxlLmMKaW5kZXggNjI5OGVlMS4uYTdkNDk5OSAxMDA2NDQKLS0tIGEvc291bmQvc29jL3B4YS9wb29kbGUuYworKysgYi9zb3VuZC9zb2MvcHhhL3Bvb2RsZS5jCkBAIC0yNzYsNyArMjc2LDcgQEAKIAkuY3B1X2RhaV9uYW1lID0gInB4YTJ4eC1pMnMiLAogCS5jb2RlY19kYWlfbmFtZSA9ICJ3bTg3MzEtaGlmaSIsCiAJLnBsYXRmb3JtX25hbWUgPSAicHhhLXBjbS1hdWRpbyIsCi0JLmNvZGVjX25hbWUgPSAid204NzMxLWNvZGVjLjAtMDAxYSIsCisJLmNvZGVjX25hbWUgPSAid204NzMxLWNvZGVjLjAtMDAxYiIsCiAJLmluaXQgPSBwb29kbGVfd204NzMxX2luaXQsCiAJLm9wcyA9ICZwb29kbGVfb3BzLAogfTsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9weGEvc3BpdHouYyBiL3NvdW5kL3NvYy9weGEvc3BpdHouYwppbmRleCBjMmFjYjY5Li44ZTE1NzEzIDEwMDY0NAotLS0gYS9zb3VuZC9zb2MvcHhhL3NwaXR6LmMKKysrIGIvc291bmQvc29jL3B4YS9zcGl0ei5jCkBAIC0zMTUsMTAgKzMxNSwxMCBAQAogc3RhdGljIHN0cnVjdCBzbmRfc29jX2RhaV9saW5rIHNwaXR6X2RhaSA9IHsKIAkubmFtZSA9ICJ3bTg3NTAiLAogCS5zdHJlYW1fbmFtZSA9ICJXTTg3NTAiLAotCS5jcHVfZGFpX25hbWUgPSAicHhhLWlzMiIsCisJLmNwdV9kYWlfbmFtZSA9ICJweGEyeHgtaTJzIiwKIAkuY29kZWNfZGFpX25hbWUgPSAid204NzUwLWhpZmkiLAogCS5wbGF0Zm9ybV9uYW1lID0gInB4YS1wY20tYXVkaW8iLAotCS5jb2RlY19uYW1lID0gIndtODc1MC1jb2RlYy4wLTAwMWEiLAorCS5jb2RlY19uYW1lID0gIndtODc1MC1jb2RlYy4wLTAwMWIiLAogCS5pbml0ID0gc3BpdHpfd204NzUwX2luaXQsCiAJLm9wcyA9ICZzcGl0el9vcHMsCiB9OwpkaWZmIC0tZ2l0IGEvc291bmQvc29jL3B4YS96Mi5jIGIvc291bmQvc29jL3B4YS96Mi5jCmluZGV4IDJkNGY4OTYuLjNjZWFlZjYgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9weGEvejIuYworKysgYi9zb3VuZC9zb2MvcHhhL3oyLmMKQEAgLTEwNCw2ICsxMDQsNyBAQAogCQkubmFtZQkJPSAiaHNkZXQtZ3BpbyIsCiAJCS5yZXBvcnQJCT0gU05EX0pBQ0tfSEVBRFNFVCwKIAkJLmRlYm91bmNlX3RpbWUJPSAyMDAsCisJCS5pbnZlcnQJCT0gMSwKIAl9LAogfTsKIApAQCAtMTkyLDcgKzE5Myw3IEBACiAJLmNwdV9kYWlfbmFtZQk9ICJweGEyeHgtaTJzIiwKIAkuY29kZWNfZGFpX25hbWUJPSAid204NzUwLWhpZmkiLAogCS5wbGF0Zm9ybV9uYW1lID0gInB4YS1wY20tYXVkaW8iLAotCS5jb2RlY19uYW1lCT0gIndtODc1MC1jb2RlYy4wLTAwMWEiLAorCS5jb2RlY19uYW1lCT0gIndtODc1MC1jb2RlYy4wLTAwMWIiLAogCS5pbml0CQk9IHoyX3dtODc1MF9pbml0LAogCS5vcHMJCT0gJnoyX29wcywKIH07CmRpZmYgLS1naXQgYS9zb3VuZC9zb2Mvc2Ftc3VuZy9uZW8xOTczX2d0YTAyX3dtODc1My5jIGIvc291bmQvc29jL3NhbXN1bmcvbmVvMTk3M19ndGEwMl93bTg3NTMuYwppbmRleCAzZWVjNjEwLi4wZDBhZTJiIDEwMDY0NAotLS0gYS9zb3VuZC9zb2Mvc2Ftc3VuZy9uZW8xOTczX2d0YTAyX3dtODc1My5jCisrKyBiL3NvdW5kL3NvYy9zYW1zdW5nL25lbzE5NzNfZ3RhMDJfd204NzUzLmMKQEAgLTM5NywxMSArMzk3LDExIEBACiB7IC8qIEhpZmkgUGxheWJhY2sgLSBmb3Igc2ltaWxhdGlvdXMgdXNlIHdpdGggdm9pY2UgYmVsb3cgKi8KIAkubmFtZSA9ICJXTTg3NTMiLAogCS5zdHJlYW1fbmFtZSA9ICJXTTg3NTMgSGlGaSIsCi0JLmNwdV9kYWlfbmFtZSA9ICJzM2MyNHh4LWkycyIsCisJLmNwdV9kYWlfbmFtZSA9ICJzM2MyNHh4LWlpcyIsCiAJLmNvZGVjX2RhaV9uYW1lID0gIndtODc1My1oaWZpIiwKIAkuaW5pdCA9IG5lbzE5NzNfZ3RhMDJfd204NzUzX2luaXQsCiAJLnBsYXRmb3JtX25hbWUgPSAic2Ftc3VuZy1hdWRpbyIsCi0JLmNvZGVjX25hbWUgPSAid204NzUzLWNvZGVjLjAtMHgxYSIsCisJLmNvZGVjX25hbWUgPSAid204NzUzLWNvZGVjLjAtMDAxYSIsCiAJLm9wcyA9ICZuZW8xOTczX2d0YTAyX2hpZmlfb3BzLAogfSwKIHsgLyogVm9pY2UgdmlhIEJUICovCkBAIC00MTAsNyArNDEwLDcgQEAKIAkuY3B1X2RhaV9uYW1lID0gImJsdWV0b290aC1kYWkiLAogCS5jb2RlY19kYWlfbmFtZSA9ICJ3bTg3NTMtdm9pY2UiLAogCS5vcHMgPSAmbmVvMTk3M19ndGEwMl92b2ljZV9vcHMsCi0JLmNvZGVjX25hbWUgPSAid204NzUzLWNvZGVjLjAtMHgxYSIsCisJLmNvZGVjX25hbWUgPSAid204NzUzLWNvZGVjLjAtMDAxYSIsCiAJLnBsYXRmb3JtX25hbWUgPSAic2Ftc3VuZy1hdWRpbyIsCiB9LAogfTsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9zYW1zdW5nL25lbzE5NzNfd204NzUzLmMgYi9zb3VuZC9zb2Mvc2Ftc3VuZy9uZW8xOTczX3dtODc1My5jCmluZGV4IGM3YTI0NTEuLmQyMDgxNWQgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9zYW1zdW5nL25lbzE5NzNfd204NzUzLmMKKysrIGIvc291bmQvc29jL3NhbXN1bmcvbmVvMTk3M193bTg3NTMuYwpAQCAtNTU5LDkgKzU1OSw5IEBACiAJLm5hbWUgPSAiV004NzUzIiwKIAkuc3RyZWFtX25hbWUgPSAiV004NzUzIEhpRmkiLAogCS5wbGF0Zm9ybV9uYW1lID0gInNhbXN1bmctYXVkaW8iLAotCS5jcHVfZGFpX25hbWUgPSAiczNjMjR4eC1pMnMiLAorCS5jcHVfZGFpX25hbWUgPSAiczNjMjR4eC1paXMiLAogCS5jb2RlY19kYWlfbmFtZSA9ICJ3bTg3NTMtaGlmaSIsCi0JLmNvZGVjX25hbWUgPSAid204NzUzLWNvZGVjLjAtMHgxYSIsCisJLmNvZGVjX25hbWUgPSAid204NzUzLWNvZGVjLjAtMDAxYSIsCiAJLmluaXQgPSBuZW8xOTczX3dtODc1M19pbml0LAogCS5vcHMgPSAmbmVvMTk3M19oaWZpX29wcywKIH0sCkBAIC01NzEsNyArNTcxLDcgQEAKIAkucGxhdGZvcm1fbmFtZSA9ICJzYW1zdW5nLWF1ZGlvIiwKIAkuY3B1X2RhaV9uYW1lID0gImJsdWV0b290aC1kYWkiLAogCS5jb2RlY19kYWlfbmFtZSA9ICJ3bTg3NTMtdm9pY2UiLAotCS5jb2RlY19uYW1lID0gIndtODc1My1jb2RlYy4wLTB4MWEiLAorCS5jb2RlY19uYW1lID0gIndtODc1My1jb2RlYy4wLTAwMWEiLAogCS5vcHMgPSAmbmVvMTk3M192b2ljZV9vcHMsCiB9LAogfTsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9zYW1zdW5nL3MzYzI0eHhfc2ltdGVjX2hlcm1lcy5jIGIvc291bmQvc29jL3NhbXN1bmcvczNjMjR4eF9zaW10ZWNfaGVybWVzLmMKaW5kZXggYmI0MjkyZS4uMDhmY2FhYSAxMDA2NDQKLS0tIGEvc291bmQvc29jL3NhbXN1bmcvczNjMjR4eF9zaW10ZWNfaGVybWVzLmMKKysrIGIvc291bmQvc29jL3NhbXN1bmcvczNjMjR4eF9zaW10ZWNfaGVybWVzLmMKQEAgLTk0LDggKzk0LDggQEAKIHN0YXRpYyBzdHJ1Y3Qgc25kX3NvY19kYWlfbGluayBzaW10ZWNfZGFpX2FpYzMzID0gewogCS5uYW1lCQk9ICJ0bHYzMjBhaWMzMyIsCiAJLnN0cmVhbV9uYW1lCT0gIlRMVjMyMEFJQzMzIiwKLQkuY29kZWNfbmFtZQk9ICJ0bHYzMjBhaWMzeC1jb2RlYy4wLTB4MWEiLAotCS5jcHVfZGFpX25hbWUJPSAiczNjMjR4eC1pMnMiLAorCS5jb2RlY19uYW1lCT0gInRsdjMyMGFpYzN4LWNvZGVjLjAtMDAxYSIsCisJLmNwdV9kYWlfbmFtZQk9ICJzM2MyNHh4LWlpcyIsCiAJLmNvZGVjX2RhaV9uYW1lID0gInRsdjMyMGFpYzN4LWhpZmkiLAogCS5wbGF0Zm9ybV9uYW1lCT0gInNhbXN1bmctYXVkaW8iLAogCS5pbml0CQk9IHNpbXRlY19oZXJtZXNfaW5pdCwKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9zYW1zdW5nL3MzYzI0eHhfc2ltdGVjX3RsdjMyMGFpYzIzLmMgYi9zb3VuZC9zb2Mvc2Ftc3VuZy9zM2MyNHh4X3NpbXRlY190bHYzMjBhaWMyMy5jCmluZGV4IGZiYmE0ZTMuLjExNmUzZTYgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9zYW1zdW5nL3MzYzI0eHhfc2ltdGVjX3RsdjMyMGFpYzIzLmMKKysrIGIvc291bmQvc29jL3NhbXN1bmcvczNjMjR4eF9zaW10ZWNfdGx2MzIwYWljMjMuYwpAQCAtODUsOCArODUsOCBAQAogc3RhdGljIHN0cnVjdCBzbmRfc29jX2RhaV9saW5rIHNpbXRlY19kYWlfYWljMjMgPSB7CiAJLm5hbWUJCT0gInRsdjMyMGFpYzIzIiwKIAkuc3RyZWFtX25hbWUJPSAiVExWMzIwQUlDMjMiLAotCS5jb2RlY19uYW1lCT0gInRsdjMyMGFpYzN4LWNvZGVjLjAtMHgxYSIsCi0JLmNwdV9kYWlfbmFtZQk9ICJzM2MyNHh4LWkycyIsCisJLmNvZGVjX25hbWUJPSAidGx2MzIwYWljM3gtY29kZWMuMC0wMDFhIiwKKwkuY3B1X2RhaV9uYW1lCT0gInMzYzI0eHgtaWlzIiwKIAkuY29kZWNfZGFpX25hbWUgPSAidGx2MzIwYWljM3gtaGlmaSIsCiAJLnBsYXRmb3JtX25hbWUJPSAic2Ftc3VuZy1hdWRpbyIsCiAJLmluaXQJCT0gc2ltdGVjX3RsdjMyMGFpYzIzX2luaXQsCmRpZmYgLS1naXQgYS9zb3VuZC9zb2Mvc2Ftc3VuZy9zM2MyNHh4X3VkYTEzNHguYyBiL3NvdW5kL3NvYy9zYW1zdW5nL3MzYzI0eHhfdWRhMTM0eC5jCmluZGV4IGNkYzhlY2IuLjJjMDllOTMgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9zYW1zdW5nL3MzYzI0eHhfdWRhMTM0eC5jCisrKyBiL3NvdW5kL3NvYy9zYW1zdW5nL3MzYzI0eHhfdWRhMTM0eC5jCkBAIC0yMjgsNyArMjI4LDcgQEAKIAkuc3RyZWFtX25hbWUgPSAiVURBMTM0WCIsCiAJLmNvZGVjX25hbWUgPSAidWRhMTM0eC1oaWZpIiwKIAkuY29kZWNfZGFpX25hbWUgPSAidWRhMTM0eC1oaWZpIiwKLQkuY3B1X2RhaV9uYW1lID0gInMzYzI0eHgtaTJzIiwKKwkuY3B1X2RhaV9uYW1lID0gInMzYzI0eHgtaWlzIiwKIAkub3BzID0gJnMzYzI0eHhfdWRhMTM0eF9vcHMsCiAJLnBsYXRmb3JtX25hbWUJPSAic2Ftc3VuZy1hdWRpbyIsCiB9OwpkaWZmIC0tZ2l0IGEvc291bmQvc29jL3NvYy1jb3JlLmMgYi9zb3VuZC9zb2Mvc29jLWNvcmUuYwppbmRleCBiYWM3MjkxLi5jM2Y2ZjFlNyAxMDA2NDQKLS0tIGEvc291bmQvc29jL3NvYy1jb3JlLmMKKysrIGIvc291bmQvc29jL3NvYy1jb3JlLmMKQEAgLTE0NDksNiArMTQ0OSw3IEBACiAJCXJ0ZCA9ICZjYXJkLT5ydGRfYXV4W251bV07CiAJCW5hbWUgPSBhdXhfZGV2LT5uYW1lOwogCX0KKwlydGQtPmNhcmQgPSBjYXJkOwogCiAJLyogbWFjaGluZSBjb250cm9scywgcm91dGVzIGFuZCB3aWRnZXRzIGFyZSBub3QgcHJlZml4ZWQgKi8KIAl0ZW1wID0gY29kZWMtPm5hbWVfcHJlZml4OwpAQCAtMTQ3MSw3ICsxNDcyLDYgQEAKIAogCS8qIHJlZ2lzdGVyIHRoZSBydGQgZGV2aWNlICovCiAJcnRkLT5jb2RlYyA9IGNvZGVjOwotCXJ0ZC0+Y2FyZCA9IGNhcmQ7CiAJcnRkLT5kZXYucGFyZW50ID0gY2FyZC0+ZGV2OwogCXJ0ZC0+ZGV2LnJlbGVhc2UgPSBydGRfcmVsZWFzZTsKIAlydGQtPmRldi5pbml0X25hbWUgPSBuYW1lOwpAQCAtMTY2NCw5ICsxNjY0LDYgQEAKIAlnb3RvIG91dDsKIAogZm91bmQ6Ci0JaWYgKCF0cnlfbW9kdWxlX2dldChjb2RlYy0+ZGV2LT5kcml2ZXItPm93bmVyKSkKLQkJcmV0dXJuIC1FTk9ERVY7Ci0KIAlyZXQgPSBzb2NfcHJvYmVfY29kZWMoY2FyZCwgY29kZWMpOwogCWlmIChyZXQgPCAwKQogCQlyZXR1cm4gcmV0OwpkaWZmIC0tZ2l0IGEvc291bmQvc29jL3NvYy1kYXBtLmMgYi9zb3VuZC9zb2Mvc29jLWRhcG0uYwppbmRleCA0OTk3MzBhLi44MTk0ZjE1IDEwMDY0NAotLS0gYS9zb3VuZC9zb2Mvc29jLWRhcG0uYworKysgYi9zb3VuZC9zb2Mvc29jLWRhcG0uYwpAQCAtMTc0Miw3ICsxNzQyLDcgQEAKIAlpbnQgbWF4ID0gbWMtPm1heDsKIAl1bnNpZ25lZCBpbnQgbWFzayA9ICgxIDw8IGZscyhtYXgpKSAtIDE7CiAJdW5zaWduZWQgaW50IGludmVydCA9IG1jLT5pbnZlcnQ7Ci0JdW5zaWduZWQgaW50IHZhbCwgdmFsX21hc2s7CisJdW5zaWduZWQgaW50IHZhbDsKIAlpbnQgY29ubmVjdCwgY2hhbmdlOwogCXN0cnVjdCBzbmRfc29jX2RhcG1fdXBkYXRlIHVwZGF0ZTsKIApAQCAtMTc1MCwxMyArMTc1MCwxMyBAQAogCiAJaWYgKGludmVydCkKIAkJdmFsID0gbWF4IC0gdmFsOwotCXZhbF9tYXNrID0gbWFzayA8PCBzaGlmdDsKKwltYXNrID0gbWFzayA8PCBzaGlmdDsKIAl2YWwgPSB2YWwgPDwgc2hpZnQ7CiAKIAltdXRleF9sb2NrKCZ3aWRnZXQtPmNvZGVjLT5tdXRleCk7CiAJd2lkZ2V0LT52YWx1ZSA9IHZhbDsKIAotCWNoYW5nZSA9IHNuZF9zb2NfdGVzdF9iaXRzKHdpZGdldC0+Y29kZWMsIHJlZywgdmFsX21hc2ssIHZhbCk7CisJY2hhbmdlID0gc25kX3NvY190ZXN0X2JpdHMod2lkZ2V0LT5jb2RlYywgcmVnLCBtYXNrLCB2YWwpOwogCWlmIChjaGFuZ2UpIHsKIAkJaWYgKHZhbCkKIAkJCS8qIG5ldyBjb25uZWN0aW9uICovCmRpZmYgLS1naXQgYS9zb3VuZC91c2IvbWl4ZXIuYyBiL3NvdW5kL3VzYi9taXhlci5jCmluZGV4IDdkZjg5YjMuLjg1YWY2MDUgMTAwNjQ0Ci0tLSBhL3NvdW5kL3VzYi9taXhlci5jCisrKyBiL3NvdW5kL3VzYi9taXhlci5jCkBAIC05NSw3ICs5NSw3IEBACiB9OwogCiAKLS8qRS1tdSAwMjAyKDA0MDQpIGVYdGVuc2lvbiBVbml0KFhVKSBjb250cm9sKi8KKy8qRS1tdSAwMjAyLzA0MDQvMDIwNCBlWHRlbnNpb24gVW5pdChYVSkgY29udHJvbCovCiBlbnVtIHsKIAlVU0JfWFVfQ0xPQ0tfUkFURSAJCT0gMHhlMzAxLAogCVVTQl9YVV9DTE9DS19TT1VSQ0UJCT0gMHhlMzAyLApAQCAtMTU2Niw3ICsxNTY2LDcgQEAKIAkJCWN2YWwtPmluaXRpYWxpemVkID0gMTsKIAkJfSBlbHNlIHsKIAkJCWlmICh0eXBlID09IFVTQl9YVV9DTE9DS19SQVRFKSB7Ci0JCQkJLyogRS1NdSBVU0IgMDQwNC8wMjAyL1RyYWNrZXJQcmUKKwkJCQkvKiBFLU11IFVTQiAwNDA0LzAyMDIvVHJhY2tlclByZS8wMjA0CiAJCQkJICogc2FtcGxlcmF0ZSBjb250cm9sIHF1aXJrCiAJCQkJICovCiAJCQkJY3ZhbC0+bWluID0gMDsKZGlmZiAtLWdpdCBhL3NvdW5kL3VzYi9xdWlya3MtdGFibGUuaCBiL3NvdW5kL3VzYi9xdWlya3MtdGFibGUuaAppbmRleCAzNTk5OTg3Li45MjFhODZmIDEwMDY0NAotLS0gYS9zb3VuZC91c2IvcXVpcmtzLXRhYmxlLmgKKysrIGIvc291bmQvdXNiL3F1aXJrcy10YWJsZS5oCkBAIC03OSw2ICs3OSwxMyBAQAogCS5pZFByb2R1Y3QgPSAweDNmMGEsCiAJLmJJbnRlcmZhY2VDbGFzcyA9IFVTQl9DTEFTU19BVURJTywKIH0sCit7CisJLyogRS1NdSAwMjA0IFVTQiAqLworCS5tYXRjaF9mbGFncyA9IFVTQl9ERVZJQ0VfSURfTUFUQ0hfREVWSUNFLAorCS5pZFZlbmRvciA9IDB4MDQxZSwKKwkuaWRQcm9kdWN0ID0gMHgzZjE5LAorCS5iSW50ZXJmYWNlQ2xhc3MgPSBVU0JfQ0xBU1NfQVVESU8sCit9LAogCiAvKgogICogTG9naXRlY2ggUXVpY2tDYW06IGJEZXZpY2VDbGFzcyBpcyB2ZW5kb3Itc3BlY2lmaWMsIHNvIGdlbmVyaWMgaW50ZXJmYWNlCmRpZmYgLS1naXQgYS9zb3VuZC91c2IvcXVpcmtzLmMgYi9zb3VuZC91c2IvcXVpcmtzLmMKaW5kZXggY2Y4YmYwOC4uZTMxNGNkYiAxMDA2NDQKLS0tIGEvc291bmQvdXNiL3F1aXJrcy5jCisrKyBiL3NvdW5kL3VzYi9xdWlya3MuYwpAQCAtNTMyLDcgKzUzMiw3IEBACiB9CiAKIC8qCi0gKiBGb3IgRS1NdSAwNDA0VVNCLzAyMDJVU0IvVHJhY2tlclByZSBzYW1wbGUgcmF0ZSBzaG91bGQgYmUgc2V0IGZvciBkZXZpY2UsCisgKiBGb3IgRS1NdSAwNDA0VVNCLzAyMDJVU0IvVHJhY2tlclByZS8wMjA0IHNhbXBsZSByYXRlIHNob3VsZCBiZSBzZXQgZm9yIGRldmljZSwKICAqIG5vdCBmb3IgaW50ZXJmYWNlLgogICovCiAKQEAgLTU4OSw2ICs1ODksNyBAQAogCWNhc2UgVVNCX0lEKDB4MDQxZSwgMHgzZjAyKTogLyogRS1NdSAwMjAyIFVTQiAqLwogCWNhc2UgVVNCX0lEKDB4MDQxZSwgMHgzZjA0KTogLyogRS1NdSAwNDA0IFVTQiAqLwogCWNhc2UgVVNCX0lEKDB4MDQxZSwgMHgzZjBhKTogLyogRS1NdSBUcmFja2VyIFByZSAqLworCWNhc2UgVVNCX0lEKDB4MDQxZSwgMHgzZjE5KTogLyogRS1NdSAwMjA0IFVTQiAqLwogCQlzZXRfZm9ybWF0X2VtdV9xdWlyayhzdWJzLCBmbXQpOwogCQlicmVhazsKIAl9CmRpZmYgLS1naXQgYS90b29scy9wZXJmL0RvY3VtZW50YXRpb24vcGVyZi1yZWNvcmQudHh0IGIvdG9vbHMvcGVyZi9Eb2N1bWVudGF0aW9uL3BlcmYtcmVjb3JkLnR4dAppbmRleCA1MjQ2MmFlLi5lMDMyNzE2IDEwMDY0NAotLS0gYS90b29scy9wZXJmL0RvY3VtZW50YXRpb24vcGVyZi1yZWNvcmQudHh0CisrKyBiL3Rvb2xzL3BlcmYvRG9jdW1lbnRhdGlvbi9wZXJmLXJlY29yZC50eHQKQEAgLTYxLDYgKzYxLDkgQEAKIC1yOjoKIC0tcmVhbHRpbWU9OjoKIAlDb2xsZWN0IGRhdGEgd2l0aCB0aGlzIFJUIFNDSEVEX0ZJRk8gcHJpb3JpdHkuCistRDo6CistLW5vLWRlbGF5OjoKKwlDb2xsZWN0IGRhdGEgd2l0aG91dCBidWZmZXJpbmcuCiAtQTo6CiAtLWFwcGVuZDo6CiAJQXBwZW5kIHRvIHRoZSBvdXRwdXQgZmlsZSB0byBkbyBpbmNyZW1lbnRhbCBwcm9maWxpbmcuCmRpZmYgLS1naXQgYS90b29scy9wZXJmL01ha2VmaWxlIGIvdG9vbHMvcGVyZi9NYWtlZmlsZQppbmRleCAyYjUzODdkLi43MTQxYzQyIDEwMDY0NAotLS0gYS90b29scy9wZXJmL01ha2VmaWxlCisrKyBiL3Rvb2xzL3BlcmYvTWFrZWZpbGUKQEAgLTIwNCwxMyArMjA0LDExIEBACiBFWFRSQV9XQVJOSU5HUyA6PSAkKEVYVFJBX1dBUk5JTkdTKSAtV2luaXQtc2VsZgogRVhUUkFfV0FSTklOR1MgOj0gJChFWFRSQV9XQVJOSU5HUykgLVdwYWNrZWQKIEVYVFJBX1dBUk5JTkdTIDo9ICQoRVhUUkFfV0FSTklOR1MpIC1XcmVkdW5kYW50LWRlY2xzCi1FWFRSQV9XQVJOSU5HUyA6PSAkKEVYVFJBX1dBUk5JTkdTKSAtV3N0YWNrLXByb3RlY3RvcgogRVhUUkFfV0FSTklOR1MgOj0gJChFWFRSQV9XQVJOSU5HUykgLVdzdHJpY3QtYWxpYXNpbmc9MwogRVhUUkFfV0FSTklOR1MgOj0gJChFWFRSQV9XQVJOSU5HUykgLVdzd2l0Y2gtZGVmYXVsdAogRVhUUkFfV0FSTklOR1MgOj0gJChFWFRSQV9XQVJOSU5HUykgLVdzd2l0Y2gtZW51bQogRVhUUkFfV0FSTklOR1MgOj0gJChFWFRSQV9XQVJOSU5HUykgLVduby1zeXN0ZW0taGVhZGVycwogRVhUUkFfV0FSTklOR1MgOj0gJChFWFRSQV9XQVJOSU5HUykgLVd1bmRlZgotRVhUUkFfV0FSTklOR1MgOj0gJChFWFRSQV9XQVJOSU5HUykgLVd2b2xhdGlsZS1yZWdpc3Rlci12YXIKIEVYVFJBX1dBUk5JTkdTIDo9ICQoRVhUUkFfV0FSTklOR1MpIC1Xd3JpdGUtc3RyaW5ncwogRVhUUkFfV0FSTklOR1MgOj0gJChFWFRSQV9XQVJOSU5HUykgLVdiYWQtZnVuY3Rpb24tY2FzdAogRVhUUkFfV0FSTklOR1MgOj0gJChFWFRSQV9XQVJOSU5HUykgLVdtaXNzaW5nLWRlY2xhcmF0aW9ucwpAQCAtMjk0LDYgKzI5MiwxMyBAQAogCUNGTEFHUyA6PSAkKENGTEFHUykgLWZzdGFjay1wcm90ZWN0b3ItYWxsCiBlbmRpZgogCitpZmVxICgkKGNhbGwgdHJ5LWNjLCQoU09VUkNFX0hFTExPKSwtV2Vycm9yIC1Xc3RhY2stcHJvdGVjdG9yKSx5KQorICAgICAgIENGTEFHUyA6PSAkKENGTEFHUykgLVdzdGFjay1wcm90ZWN0b3IKK2VuZGlmCisKK2lmZXEgKCQoY2FsbCB0cnktY2MsJChTT1VSQ0VfSEVMTE8pLC1XZXJyb3IgLVd2b2xhdGlsZS1yZWdpc3Rlci12YXIpLHkpCisgICAgICAgQ0ZMQUdTIDo9ICQoQ0ZMQUdTKSAtV3ZvbGF0aWxlLXJlZ2lzdGVyLXZhcgorZW5kaWYKIAogIyMjIC0tLSBFTkQgQ09ORklHVVJBVElPTiBTRUNUSU9OIC0tLQogCmRpZmYgLS1naXQgYS90b29scy9wZXJmL2J1aWx0aW4tYW5ub3RhdGUuYyBiL3Rvb2xzL3BlcmYvYnVpbHRpbi1hbm5vdGF0ZS5jCmluZGV4IGMwNTZjZGMuLjg4Nzk0NjMgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvYnVpbHRpbi1hbm5vdGF0ZS5jCisrKyBiL3Rvb2xzL3BlcmYvYnVpbHRpbi1hbm5vdGF0ZS5jCkBAIC0yMTIsNyArMjEyLDcgQEAKIAkJCWNvbnRpbnVlOwogCiAJCW9mZnNldCA9IHN0YXJ0ICsgaTsKLQkJc3ByaW50ZihjbWQsICJhZGRyMmxpbmUgLWUgJXMgJTAxNmxseCIsIGZpbGVuYW1lLCBvZmZzZXQpOworCQlzcHJpbnRmKGNtZCwgImFkZHIybGluZSAtZSAlcyAlMDE2IiBQUkl4NjQsIGZpbGVuYW1lLCBvZmZzZXQpOwogCQlmcCA9IHBvcGVuKGNtZCwgInIiKTsKIAkJaWYgKCFmcCkKIAkJCWNvbnRpbnVlOwpAQCAtMjcwLDkgKzI3MCw5IEBACiAKIAlmb3IgKG9mZnNldCA9IDA7IG9mZnNldCA8IGxlbjsgKytvZmZzZXQpCiAJCWlmIChoLT5pcFtvZmZzZXRdICE9IDApCi0JCQlwcmludGYoIiUqTHg6ICVMdVxuIiwgQklUU19QRVJfTE9ORyAvIDIsCisJCQlwcmludGYoIiUqIiBQUkl4NjQgIjogJSIgUFJJdTY0ICJcbiIsIEJJVFNfUEVSX0xPTkcgLyAyLAogCQkJICAgICAgIHN5bS0+c3RhcnQgKyBvZmZzZXQsIGgtPmlwW29mZnNldF0pOwotCXByaW50ZigiJSpzOiAlTHVcbiIsIEJJVFNfUEVSX0xPTkcgLyAyLCAiaC0+c3VtIiwgaC0+c3VtKTsKKwlwcmludGYoIiUqczogJSIgUFJJdTY0ICJcbiIsIEJJVFNfUEVSX0xPTkcgLyAyLCAiaC0+c3VtIiwgaC0+c3VtKTsKIH0KIAogc3RhdGljIGludCBoaXN0X2VudHJ5X190dHlfYW5ub3RhdGUoc3RydWN0IGhpc3RfZW50cnkgKmhlKQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9idWlsdGluLWttZW0uYyBiL3Rvb2xzL3BlcmYvYnVpbHRpbi1rbWVtLmMKaW5kZXggZGVmN2RkYy4uZDk3MjU2ZCAxMDA2NDQKLS0tIGEvdG9vbHMvcGVyZi9idWlsdGluLWttZW0uYworKysgYi90b29scy9wZXJmL2J1aWx0aW4ta21lbS5jCkBAIC0zNzEsMTAgKzM3MSwxMCBAQAogCQkJYWRkciA9IGRhdGEtPnB0cjsKIAogCQlpZiAoc3ltICE9IE5VTEwpCi0JCQlzbnByaW50ZihidWYsIHNpemVvZihidWYpLCAiJXMrJUx4Iiwgc3ltLT5uYW1lLAorCQkJc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIiVzKyUiIFBSSXg2NCAiIiwgc3ltLT5uYW1lLAogCQkJCSBhZGRyIC0gbWFwLT51bm1hcF9pcChtYXAsIHN5bS0+c3RhcnQpKTsKIAkJZWxzZQotCQkJc25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIiUjTHgiLCBhZGRyKTsKKwkJCXNucHJpbnRmKGJ1Ziwgc2l6ZW9mKGJ1ZiksICIlIyIgUFJJeDY0ICIiLCBhZGRyKTsKIAkJcHJpbnRmKCIgJS0zNHMgfCIsIGJ1Zik7CiAKIAkJcHJpbnRmKCIgJTlsbHUvJS01bHUgfCAlOWxsdS8lLTVsdSB8ICU4bHUgfCAlOGx1IHwgJTYuM2YlJVxuIiwKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvYnVpbHRpbi1sb2NrLmMgYi90b29scy9wZXJmL2J1aWx0aW4tbG9jay5jCmluZGV4IGI5YzZlNTQuLjJiMzZkZWYgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvYnVpbHRpbi1sb2NrLmMKKysrIGIvdG9vbHMvcGVyZi9idWlsdGluLWxvY2suYwpAQCAtNzgyLDkgKzc4Miw5IEBACiAJCXByX2luZm8oIiUxMHUgIiwgc3QtPm5yX2FjcXVpcmVkKTsKIAkJcHJfaW5mbygiJTEwdSAiLCBzdC0+bnJfY29udGVuZGVkKTsKIAotCQlwcl9pbmZvKCIlMTVsbHUgIiwgc3QtPndhaXRfdGltZV90b3RhbCk7Ci0JCXByX2luZm8oIiUxNWxsdSAiLCBzdC0+d2FpdF90aW1lX21heCk7Ci0JCXByX2luZm8oIiUxNWxsdSAiLCBzdC0+d2FpdF90aW1lX21pbiA9PSBVTExPTkdfTUFYID8KKwkJcHJfaW5mbygiJTE1IiBQUkl1NjQgIiAiLCBzdC0+d2FpdF90aW1lX3RvdGFsKTsKKwkJcHJfaW5mbygiJTE1IiBQUkl1NjQgIiAiLCBzdC0+d2FpdF90aW1lX21heCk7CisJCXByX2luZm8oIiUxNSIgUFJJdTY0ICIgIiwgc3QtPndhaXRfdGltZV9taW4gPT0gVUxMT05HX01BWCA/CiAJCSAgICAgICAwIDogc3QtPndhaXRfdGltZV9taW4pOwogCQlwcl9pbmZvKCJcbiIpOwogCX0KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvYnVpbHRpbi1yZWNvcmQuYyBiL3Rvb2xzL3BlcmYvYnVpbHRpbi1yZWNvcmQuYwppbmRleCA3MDY5YmQzLi5iMmY3MjlmIDEwMDY0NAotLS0gYS90b29scy9wZXJmL2J1aWx0aW4tcmVjb3JkLmMKKysrIGIvdG9vbHMvcGVyZi9idWlsdGluLXJlY29yZC5jCkBAIC00OSw2ICs0OSw3IEBACiBzdGF0aWMgY29uc3QgY2hhcgkJKm91dHB1dF9uYW1lCQkJPSAicGVyZi5kYXRhIjsKIHN0YXRpYyBpbnQJCQlncm91cAkJCQk9ICAgICAgMDsKIHN0YXRpYyBpbnQJCQlyZWFsdGltZV9wcmlvCQkJPSAgICAgIDA7CitzdGF0aWMgYm9vbAkJCW5vZGVsYXkJCQkJPSAgZmFsc2U7CiBzdGF0aWMgYm9vbAkJCXJhd19zYW1wbGVzCQkJPSAgZmFsc2U7CiBzdGF0aWMgYm9vbAkJCXNhbXBsZV9pZF9hbGxfYXZhaWwJCT0gICB0cnVlOwogc3RhdGljIGJvb2wJCQlzeXN0ZW1fd2lkZQkJCT0gIGZhbHNlOwpAQCAtMzA3LDYgKzMwOCwxMSBAQAogCQlhdHRyLT5zYW1wbGVfdHlwZQl8PSBQRVJGX1NBTVBMRV9DUFU7CiAJfQogCisJaWYgKG5vZGVsYXkpIHsKKwkJYXR0ci0+d2F0ZXJtYXJrID0gMDsKKwkJYXR0ci0+d2FrZXVwX2V2ZW50cyA9IDE7CisJfQorCiAJYXR0ci0+bW1hcAkJPSB0cmFjazsKIAlhdHRyLT5jb21tCQk9IHRyYWNrOwogCWF0dHItPmluaGVyaXQJCT0gIW5vX2luaGVyaXQ7CkBAIC0zMzEsOSArMzM3LDYgQEAKIAkJCWVsc2UgaWYgKGVyciA9PSAgRU5PREVWICYmIGNwdV9saXN0KSB7CiAJCQkJZGllKCJObyBzdWNoIGRldmljZSAtIGRpZCB5b3Ugc3BlY2lmeSIKIAkJCQkJIiBhbiBvdXQtb2YtcmFuZ2UgcHJvZmlsZSBDUFU/XG4iKTsKLQkJCX0gZWxzZSBpZiAoZXJyID09IEVOT0VOVCkgewotCQkJCWRpZSgiJXMgZXZlbnQgaXMgbm90IHN1cHBvcnRlZC4gIiwKLQkJCQkgICAgIGV2ZW50X25hbWUoZXZzZWwpKTsKIAkJCX0gZWxzZSBpZiAoZXJyID09IEVJTlZBTCAmJiBzYW1wbGVfaWRfYWxsX2F2YWlsKSB7CiAJCQkJLyoKIAkJCQkgKiBPbGQga2VybmVsLCBubyBhdHRyLT5zYW1wbGVfaWRfdHlwZV9hbGwgZmllbGQKQEAgLTQ4MCw2ICs0ODMsNyBAQAogCQkJcHJvY2Vzc19idWlsZGlkcygpOwogCQlwZXJmX2hlYWRlcl9fd3JpdGUoJnNlc3Npb24tPmhlYWRlciwgb3V0cHV0LCB0cnVlKTsKIAkJcGVyZl9zZXNzaW9uX19kZWxldGUoc2Vzc2lvbik7CisJCXBlcmZfZXZzZWxfbGlzdF9fZGVsZXRlKCk7CiAJCXN5bWJvbF9fZXhpdCgpOwogCX0KIH0KQEAgLTgxMyw3ICs4MTcsNyBAQAogCSAqIEFwcHJveGltYXRlIFJJUCBldmVudCBzaXplOiAyNCBieXRlcy4KIAkgKi8KIAlmcHJpbnRmKHN0ZGVyciwKLQkJIlsgcGVyZiByZWNvcmQ6IENhcHR1cmVkIGFuZCB3cm90ZSAlLjNmIE1CICVzICh+JWxsZCBzYW1wbGVzKSBdXG4iLAorCQkiWyBwZXJmIHJlY29yZDogQ2FwdHVyZWQgYW5kIHdyb3RlICUuM2YgTUIgJXMgKH4lIiBQUkl1NjQgIiBzYW1wbGVzKSBdXG4iLAogCQkoZG91YmxlKWJ5dGVzX3dyaXR0ZW4gLyAxMDI0LjAgLyAxMDI0LjAsCiAJCW91dHB1dF9uYW1lLAogCQlieXRlc193cml0dGVuIC8gMjQpOwpAQCAtODQ1LDYgKzg0OSw4IEBACiAJCSAgICAicmVjb3JkIGV2ZW50cyBvbiBleGlzdGluZyB0aHJlYWQgaWQiKSwKIAlPUFRfSU5URUdFUigncicsICJyZWFsdGltZSIsICZyZWFsdGltZV9wcmlvLAogCQkgICAgImNvbGxlY3QgZGF0YSB3aXRoIHRoaXMgUlQgU0NIRURfRklGTyBwcmlvcml0eSIpLAorCU9QVF9CT09MRUFOKCdEJywgIm5vLWRlbGF5IiwgJm5vZGVsYXksCisJCSAgICAiY29sbGVjdCBkYXRhIHdpdGhvdXQgYnVmZmVyaW5nIiksCiAJT1BUX0JPT0xFQU4oJ1InLCAicmF3LXNhbXBsZXMiLCAmcmF3X3NhbXBsZXMsCiAJCSAgICAiY29sbGVjdCByYXcgc2FtcGxlIHJlY29yZHMgZnJvbSBhbGwgb3BlbmVkIGNvdW50ZXJzIiksCiAJT1BUX0JPT0xFQU4oJ2EnLCAiYWxsLWNwdXMiLCAmc3lzdGVtX3dpZGUsCkBAIC05MzAsNiArOTM2LDggQEAKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KHBvcywgJmV2c2VsX2xpc3QsIG5vZGUpIHsKIAkJaWYgKHBlcmZfZXZzZWxfX2FsbG9jX2ZkKHBvcywgY3B1cy0+bnIsIHRocmVhZHMtPm5yKSA8IDApCiAJCQlnb3RvIG91dF9mcmVlX2ZkOworCQlpZiAocGVyZl9oZWFkZXJfX3B1c2hfZXZlbnQocG9zLT5hdHRyLmNvbmZpZywgZXZlbnRfbmFtZShwb3MpKSkKKwkJCWdvdG8gb3V0X2ZyZWVfZmQ7CiAJfQogCWV2ZW50X2FycmF5ID0gbWFsbG9jKChzaXplb2Yoc3RydWN0IHBvbGxmZCkgKiBNQVhfTlJfQ1BVUyAqCiAJCQkgICAgICBNQVhfQ09VTlRFUlMgKiB0aHJlYWRzLT5ucikpOwpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9idWlsdGluLXJlcG9ydC5jIGIvdG9vbHMvcGVyZi9idWlsdGluLXJlcG9ydC5jCmluZGV4IDc1MTgzYTQuLmMyN2UzMWYgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvYnVpbHRpbi1yZXBvcnQuYworKysgYi90b29scy9wZXJmL2J1aWx0aW4tcmVwb3J0LmMKQEAgLTE5Nyw3ICsxOTcsNyBAQAogCQkJCQkgICBldmVudC0+cmVhZC52YWx1ZSk7CiAJfQogCi0JZHVtcF9wcmludGYoIjogJWQgJWQgJXMgJUx1XG4iLCBldmVudC0+cmVhZC5waWQsIGV2ZW50LT5yZWFkLnRpZCwKKwlkdW1wX3ByaW50ZigiOiAlZCAlZCAlcyAlIiBQUkl1NjQgIlxuIiwgZXZlbnQtPnJlYWQucGlkLCBldmVudC0+cmVhZC50aWQsCiAJCSAgICBhdHRyID8gX19ldmVudF9uYW1lKGF0dHItPnR5cGUsIGF0dHItPmNvbmZpZykgOiAiRkFJTCIsCiAJCSAgICBldmVudC0+cmVhZC52YWx1ZSk7CiAKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvYnVpbHRpbi1zY2hlZC5jIGIvdG9vbHMvcGVyZi9idWlsdGluLXNjaGVkLmMKaW5kZXggYWJkNGI4NC4uMjlhY2I4OTQgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvYnVpbHRpbi1zY2hlZC5jCisrKyBiL3Rvb2xzL3BlcmYvYnVpbHRpbi1zY2hlZC5jCkBAIC0xOTMsNyArMTkzLDcgQEAKIAl9CiAJcnVuX21lYXN1cmVtZW50X292ZXJoZWFkID0gbWluX2RlbHRhOwogCi0JcHJpbnRmKCJydW4gbWVhc3VyZW1lbnQgb3ZlcmhlYWQ6ICVMZCBuc2Vjc1xuIiwgbWluX2RlbHRhKTsKKwlwcmludGYoInJ1biBtZWFzdXJlbWVudCBvdmVyaGVhZDogJSIgUFJJdTY0ICIgbnNlY3NcbiIsIG1pbl9kZWx0YSk7CiB9CiAKIHN0YXRpYyB2b2lkIGNhbGlicmF0ZV9zbGVlcF9tZWFzdXJlbWVudF9vdmVyaGVhZCh2b2lkKQpAQCAtMjExLDcgKzIxMSw3IEBACiAJbWluX2RlbHRhIC09IDEwMDAwOwogCXNsZWVwX21lYXN1cmVtZW50X292ZXJoZWFkID0gbWluX2RlbHRhOwogCi0JcHJpbnRmKCJzbGVlcCBtZWFzdXJlbWVudCBvdmVyaGVhZDogJUxkIG5zZWNzXG4iLCBtaW5fZGVsdGEpOworCXByaW50Zigic2xlZXAgbWVhc3VyZW1lbnQgb3ZlcmhlYWQ6ICUiIFBSSXU2NCAiIG5zZWNzXG4iLCBtaW5fZGVsdGEpOwogfQogCiBzdGF0aWMgc3RydWN0IHNjaGVkX2F0b20gKgpAQCAtNjE3LDEzICs2MTcsMTMgQEAKIAlidXJuX25zZWNzKDFlNik7CiAJVDEgPSBnZXRfbnNlY3MoKTsKIAotCXByaW50ZigidGhlIHJ1biB0ZXN0IHRvb2sgJUxkIG5zZWNzXG4iLCBUMS1UMCk7CisJcHJpbnRmKCJ0aGUgcnVuIHRlc3QgdG9vayAlIiBQUkl1NjQgIiBuc2Vjc1xuIiwgVDEgLSBUMCk7CiAKIAlUMCA9IGdldF9uc2VjcygpOwogCXNsZWVwX25zZWNzKDFlNik7CiAJVDEgPSBnZXRfbnNlY3MoKTsKIAotCXByaW50ZigidGhlIHNsZWVwIHRlc3QgdG9vayAlTGQgbnNlY3NcbiIsIFQxLVQwKTsKKwlwcmludGYoInRoZSBzbGVlcCB0ZXN0IHRvb2sgJSIgUFJJdTY0ICIgbnNlY3NcbiIsIFQxIC0gVDApOwogfQogCiAjZGVmaW5lIEZJTExfRklFTEQocHRyLCBmaWVsZCwgZXZlbnQsIGRhdGEpCVwKQEAgLTgxNiwxMCArODE2LDEwIEBACiAJCWRlbHRhID0gMDsKIAogCWlmIChkZWx0YSA8IDApCi0JCWRpZSgiaG0sIGRlbHRhOiAlTGQgPCAwID9cbiIsIGRlbHRhKTsKKwkJZGllKCJobSwgZGVsdGE6ICUiIFBSSXU2NCAiIDwgMCA/XG4iLCBkZWx0YSk7CiAKIAlpZiAodmVyYm9zZSkgewotCQlwcmludGYoIiAuLi4gc3dpdGNoIGZyb20gJXMvJWQgdG8gJXMvJWQgW3JhbiAlTGQgbnNlY3NdXG4iLAorCQlwcmludGYoIiAuLi4gc3dpdGNoIGZyb20gJXMvJWQgdG8gJXMvJWQgW3JhbiAlIiBQUkl1NjQgIiBuc2Vjc11cbiIsCiAJCQlzd2l0Y2hfZXZlbnQtPnByZXZfY29tbSwgc3dpdGNoX2V2ZW50LT5wcmV2X3BpZCwKIAkJCXN3aXRjaF9ldmVudC0+bmV4dF9jb21tLCBzd2l0Y2hfZXZlbnQtPm5leHRfcGlkLAogCQkJZGVsdGEpOwpAQCAtMTA0OCw3ICsxMDQ4LDcgQEAKIAkJZGVsdGEgPSAwOwogCiAJaWYgKGRlbHRhIDwgMCkKLQkJZGllKCJobSwgZGVsdGE6ICVMZCA8IDAgP1xuIiwgZGVsdGEpOworCQlkaWUoImhtLCBkZWx0YTogJSIgUFJJdTY0ICIgPCAwID9cbiIsIGRlbHRhKTsKIAogCiAJc2NoZWRfb3V0ID0gcGVyZl9zZXNzaW9uX19maW5kbmV3KHNlc3Npb24sIHN3aXRjaF9ldmVudC0+cHJldl9waWQpOwpAQCAtMTIyMSw3ICsxMjIxLDcgQEAKIAogCWF2ZyA9IHdvcmtfbGlzdC0+dG90YWxfbGF0IC8gd29ya19saXN0LT5uYl9hdG9tczsKIAotCXByaW50ZigifCUxMS4zZiBtcyB8JTlsbHUgfCBhdmc6JTkuM2YgbXMgfCBtYXg6JTkuM2YgbXMgfCBtYXggYXQ6ICU5LjZmIHNcbiIsCisJcHJpbnRmKCJ8JTExLjNmIG1zIHwlOSIgUFJJdTY0ICIgfCBhdmc6JTkuM2YgbXMgfCBtYXg6JTkuM2YgbXMgfCBtYXggYXQ6ICU5LjZmIHNcbiIsCiAJICAgICAgKGRvdWJsZSl3b3JrX2xpc3QtPnRvdGFsX3J1bnRpbWUgLyAxZTYsCiAJCSB3b3JrX2xpc3QtPm5iX2F0b21zLCAoZG91YmxlKWF2ZyAvIDFlNiwKIAkJIChkb3VibGUpd29ya19saXN0LT5tYXhfbGF0IC8gMWU2LApAQCAtMTQyMyw3ICsxNDIzLDcgQEAKIAkJZGVsdGEgPSAwOwogCiAJaWYgKGRlbHRhIDwgMCkKLQkJZGllKCJobSwgZGVsdGE6ICVMZCA8IDAgP1xuIiwgZGVsdGEpOworCQlkaWUoImhtLCBkZWx0YTogJSIgUFJJdTY0ICIgPCAwID9cbiIsIGRlbHRhKTsKIAogCiAJc2NoZWRfb3V0ID0gcGVyZl9zZXNzaW9uX19maW5kbmV3KHNlc3Npb24sIHN3aXRjaF9ldmVudC0+cHJldl9waWQpOwpAQCAtMTcxMyw3ICsxNzEzLDcgQEAKIAl9CiAKIAlwcmludGYoIiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLVxuIik7Ci0JcHJpbnRmKCIgIFRPVEFMOiAgICAgICAgICAgICAgICB8JTExLjNmIG1zIHwlOUxkIHxcbiIsCisJcHJpbnRmKCIgIFRPVEFMOiAgICAgICAgICAgICAgICB8JTExLjNmIG1zIHwlOSIgUFJJdTY0ICIgfFxuIiwKIAkJKGRvdWJsZSlhbGxfcnVudGltZS8xZTYsIGFsbF9jb3VudCk7CiAKIAlwcmludGYoIiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS1cbiIpOwpAQCAtMTg0MywxNSArMTg0MywxNSBAQAogCSItZiIsCiAJIi1tIiwgIjEwMjQiLAogCSItYyIsICIxIiwKLQkiLWUiLCAic2NoZWQ6c2NoZWRfc3dpdGNoOnIiLAotCSItZSIsICJzY2hlZDpzY2hlZF9zdGF0X3dhaXQ6ciIsCi0JIi1lIiwgInNjaGVkOnNjaGVkX3N0YXRfc2xlZXA6ciIsCi0JIi1lIiwgInNjaGVkOnNjaGVkX3N0YXRfaW93YWl0OnIiLAotCSItZSIsICJzY2hlZDpzY2hlZF9zdGF0X3J1bnRpbWU6ciIsCi0JIi1lIiwgInNjaGVkOnNjaGVkX3Byb2Nlc3NfZXhpdDpyIiwKLQkiLWUiLCAic2NoZWQ6c2NoZWRfcHJvY2Vzc19mb3JrOnIiLAotCSItZSIsICJzY2hlZDpzY2hlZF93YWtldXA6ciIsCi0JIi1lIiwgInNjaGVkOnNjaGVkX21pZ3JhdGVfdGFzazpyIiwKKwkiLWUiLCAic2NoZWQ6c2NoZWRfc3dpdGNoIiwKKwkiLWUiLCAic2NoZWQ6c2NoZWRfc3RhdF93YWl0IiwKKwkiLWUiLCAic2NoZWQ6c2NoZWRfc3RhdF9zbGVlcCIsCisJIi1lIiwgInNjaGVkOnNjaGVkX3N0YXRfaW93YWl0IiwKKwkiLWUiLCAic2NoZWQ6c2NoZWRfc3RhdF9ydW50aW1lIiwKKwkiLWUiLCAic2NoZWQ6c2NoZWRfcHJvY2Vzc19leGl0IiwKKwkiLWUiLCAic2NoZWQ6c2NoZWRfcHJvY2Vzc19mb3JrIiwKKwkiLWUiLCAic2NoZWQ6c2NoZWRfd2FrZXVwIiwKKwkiLWUiLCAic2NoZWQ6c2NoZWRfbWlncmF0ZV90YXNrIiwKIH07CiAKIHN0YXRpYyBpbnQgX19jbWRfcmVjb3JkKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndikKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvYnVpbHRpbi1zY3JpcHQuYyBiL3Rvb2xzL3BlcmYvYnVpbHRpbi1zY3JpcHQuYwppbmRleCAxNTBhNjA2Li5iNzY2YzJhIDEwMDY0NAotLS0gYS90b29scy9wZXJmL2J1aWx0aW4tc2NyaXB0LmMKKysrIGIvdG9vbHMvcGVyZi9idWlsdGluLXNjcmlwdC5jCkBAIC03Nyw4ICs3Nyw4IEBACiAJaWYgKHNlc3Npb24tPnNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfUkFXKSB7CiAJCWlmIChkZWJ1Z19tb2RlKSB7CiAJCQlpZiAoc2FtcGxlLT50aW1lIDwgbGFzdF90aW1lc3RhbXApIHsKLQkJCQlwcl9lcnIoIlNhbXBsZXMgbWlzb3JkZXJlZCwgcHJldmlvdXM6ICVsbHUgIgotCQkJCQkidGhpczogJWxsdVxuIiwgbGFzdF90aW1lc3RhbXAsCisJCQkJcHJfZXJyKCJTYW1wbGVzIG1pc29yZGVyZWQsIHByZXZpb3VzOiAlIiBQUkl1NjQKKwkJCQkJIiB0aGlzOiAlIiBQUkl1NjQgIlxuIiwgbGFzdF90aW1lc3RhbXAsCiAJCQkJCXNhbXBsZS0+dGltZSk7CiAJCQkJbnJfdW5vcmRlcmVkKys7CiAJCQl9CkBAIC0xMjYsNyArMTI2LDcgQEAKIAlyZXQgPSBwZXJmX3Nlc3Npb25fX3Byb2Nlc3NfZXZlbnRzKHNlc3Npb24sICZldmVudF9vcHMpOwogCiAJaWYgKGRlYnVnX21vZGUpCi0JCXByX2VycigiTWlzb3JkZXJlZCB0aW1lc3RhbXBzOiAlbGx1XG4iLCBucl91bm9yZGVyZWQpOworCQlwcl9lcnIoIk1pc29yZGVyZWQgdGltZXN0YW1wczogJSIgUFJJdTY0ICJcbiIsIG5yX3Vub3JkZXJlZCk7CiAKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9idWlsdGluLXN0YXQuYyBiL3Rvb2xzL3BlcmYvYnVpbHRpbi1zdGF0LmMKaW5kZXggYzM4NWE2My4uYTQ4MmExOSAxMDA2NDQKLS0tIGEvdG9vbHMvcGVyZi9idWlsdGluLXN0YXQuYworKysgYi90b29scy9wZXJmL2J1aWx0aW4tc3RhdC5jCkBAIC0yMDYsOCArMjA2LDggQEAKIAkJdXBkYXRlX3N0YXRzKCZwcy0+cmVzX3N0YXRzW2ldLCBjb3VudFtpXSk7CiAKIAlpZiAodmVyYm9zZSkgewotCQlmcHJpbnRmKHN0ZGVyciwgIiVzOiAlTGQgJUxkICVMZFxuIiwgZXZlbnRfbmFtZShjb3VudGVyKSwKLQkJCQljb3VudFswXSwgY291bnRbMV0sIGNvdW50WzJdKTsKKwkJZnByaW50ZihzdGRlcnIsICIlczogJSIgUFJJdTY0ICIgJSIgUFJJdTY0ICIgJSIgUFJJdTY0ICJcbiIsCisJCQlldmVudF9uYW1lKGNvdW50ZXIpLCBjb3VudFswXSwgY291bnRbMV0sIGNvdW50WzJdKTsKIAl9CiAKIAkvKgpAQCAtNzQzLDYgKzc0Myw3IEBACiBvdXRfZnJlZV9mZDoKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KHBvcywgJmV2c2VsX2xpc3QsIG5vZGUpCiAJCXBlcmZfZXZzZWxfX2ZyZWVfc3RhdF9wcml2KHBvcyk7CisJcGVyZl9ldnNlbF9saXN0X19kZWxldGUoKTsKIG91dDoKIAl0aHJlYWRfbWFwX19kZWxldGUodGhyZWFkcyk7CiAJdGhyZWFkcyA9IE5VTEw7CmRpZmYgLS1naXQgYS90b29scy9wZXJmL2J1aWx0aW4tdGVzdC5jIGIvdG9vbHMvcGVyZi9idWlsdGluLXRlc3QuYwppbmRleCBlZDU2OTYxLi41ZGNkYmE2IDEwMDY0NAotLS0gYS90b29scy9wZXJmL2J1aWx0aW4tdGVzdC5jCisrKyBiL3Rvb2xzL3BlcmYvYnVpbHRpbi10ZXN0LmMKQEAgLTE0Niw3ICsxNDYsNyBAQAogCQkJCWlmIChsbGFicyhza2V3KSA8IHBhZ2Vfc2l6ZSkKIAkJCQkJY29udGludWU7CiAKLQkJCQlwcl9kZWJ1ZygiJSNMeDogZGlmZiBlbmQgYWRkciBmb3IgJXMgdjogJSNMeCBrOiAlI0x4XG4iLAorCQkJCXByX2RlYnVnKCIlIyIgUFJJeDY0ICI6IGRpZmYgZW5kIGFkZHIgZm9yICVzIHY6ICUjIiBQUkl4NjQgIiBrOiAlIyIgUFJJeDY0ICJcbiIsCiAJCQkJCSBzeW0tPnN0YXJ0LCBzeW0tPm5hbWUsIHN5bS0+ZW5kLCBwYWlyLT5lbmQpOwogCQkJfSBlbHNlIHsKIAkJCQlzdHJ1Y3QgcmJfbm9kZSAqbm5kOwpAQCAtMTY4LDExICsxNjgsMTEgQEAKIAkJCQkJZ290byBkZXRvdXI7CiAJCQkJfQogCi0JCQkJcHJfZGVidWcoIiUjTHg6IGRpZmYgbmFtZSB2OiAlcyBrOiAlc1xuIiwKKwkJCQlwcl9kZWJ1ZygiJSMiIFBSSXg2NCAiOiBkaWZmIG5hbWUgdjogJXMgazogJXNcbiIsCiAJCQkJCSBzeW0tPnN0YXJ0LCBzeW0tPm5hbWUsIHBhaXItPm5hbWUpOwogCQkJfQogCQl9IGVsc2UKLQkJCXByX2RlYnVnKCIlI0x4OiAlcyBub3Qgb24ga2FsbHN5bXNcbiIsIHN5bS0+c3RhcnQsIHN5bS0+bmFtZSk7CisJCQlwcl9kZWJ1ZygiJSMiIFBSSXg2NCAiOiAlcyBub3Qgb24ga2FsbHN5bXNcbiIsIHN5bS0+c3RhcnQsIHN5bS0+bmFtZSk7CiAKIAkJZXJyID0gLTE7CiAJfQpAQCAtMjExLDEwICsyMTEsMTAgQEAKIAogCQlpZiAocGFpci0+c3RhcnQgPT0gcG9zLT5zdGFydCkgewogCQkJcGFpci0+cHJpdiA9IDE7Ci0JCQlwcl9pbmZvKCIgJUx4LSVMeCAlTHggJXMgaW4ga2FsbHN5bXMgYXMiLAorCQkJcHJfaW5mbygiICUiIFBSSXg2NCAiLSUiIFBSSXg2NCAiICUiIFBSSXg2NCAiICVzIGluIGthbGxzeW1zIGFzIiwKIAkJCQlwb3MtPnN0YXJ0LCBwb3MtPmVuZCwgcG9zLT5wZ29mZiwgcG9zLT5kc28tPm5hbWUpOwogCQkJaWYgKHBvcy0+cGdvZmYgIT0gcGFpci0+cGdvZmYgfHwgcG9zLT5lbmQgIT0gcGFpci0+ZW5kKQotCQkJCXByX2luZm8oIjogXG4qJUx4LSVMeCAlTHgiLAorCQkJCXByX2luZm8oIjogXG4qJSIgUFJJeDY0ICItJSIgUFJJeDY0ICIgJSIgUFJJeDY0ICIiLAogCQkJCQlwYWlyLT5zdGFydCwgcGFpci0+ZW5kLCBwYWlyLT5wZ29mZik7CiAJCQlwcl9pbmZvKCIgJXNcbiIsIHBhaXItPmRzby0+bmFtZSk7CiAJCQlwYWlyLT5wcml2ID0gMTsKQEAgLTMwNyw3ICszMDcsNyBAQAogCX0KIAogCWlmIChldnNlbC0+Y291bnRzLT5jcHVbMF0udmFsICE9IG5yX29wZW5fY2FsbHMpIHsKLQkJcHJfZGVidWcoInBlcmZfZXZzZWxfX3JlYWRfb25fY3B1OiBleHBlY3RlZCB0byBpbnRlcmNlcHQgJWQgY2FsbHMsIGdvdCAlTGRcbiIsCisJCXByX2RlYnVnKCJwZXJmX2V2c2VsX19yZWFkX29uX2NwdTogZXhwZWN0ZWQgdG8gaW50ZXJjZXB0ICVkIGNhbGxzLCBnb3QgJSIgUFJJdTY0ICJcbiIsCiAJCQkgbnJfb3Blbl9jYWxscywgZXZzZWwtPmNvdW50cy0+Y3B1WzBdLnZhbCk7CiAJCWdvdG8gb3V0X2Nsb3NlX2ZkOwogCX0KQEAgLTMzMiw4ICszMzIsNyBAQAogCXN0cnVjdCBwZXJmX2V2c2VsICpldnNlbDsKIAlzdHJ1Y3QgcGVyZl9ldmVudF9hdHRyIGF0dHI7CiAJdW5zaWduZWQgaW50IG5yX29wZW5fY2FsbHMgPSAxMTEsIGk7Ci0JY3B1X3NldF90ICpjcHVfc2V0OwotCXNpemVfdCBjcHVfc2V0X3NpemU7CisJY3B1X3NldF90IGNwdV9zZXQ7CiAJaW50IGlkID0gdHJhY2VfZXZlbnRfX2lkKCJzeXNfZW50ZXJfb3BlbiIpOwogCiAJaWYgKGlkIDwgMCkgewpAQCAtMzUzLDEzICszNTIsOCBAQAogCQlyZXR1cm4gLTE7CiAJfQogCi0JY3B1X3NldCA9IENQVV9BTExPQyhjcHVzLT5ucik7CiAKLQlpZiAoY3B1X3NldCA9PSBOVUxMKQotCQlnb3RvIG91dF90aHJlYWRfbWFwX2RlbGV0ZTsKLQotCWNwdV9zZXRfc2l6ZSA9IENQVV9BTExPQ19TSVpFKGNwdXMtPm5yKTsKLQlDUFVfWkVST19TKGNwdV9zZXRfc2l6ZSwgY3B1X3NldCk7CisJQ1BVX1pFUk8oJmNwdV9zZXQpOwogCiAJbWVtc2V0KCZhdHRyLCAwLCBzaXplb2YoYXR0cikpOwogCWF0dHIudHlwZSA9IFBFUkZfVFlQRV9UUkFDRVBPSU5UOwpAQCAtMzY3LDcgKzM2MSw3IEBACiAJZXZzZWwgPSBwZXJmX2V2c2VsX19uZXcoJmF0dHIsIDApOwogCWlmIChldnNlbCA9PSBOVUxMKSB7CiAJCXByX2RlYnVnKCJwZXJmX2V2c2VsX19uZXdcbiIpOwotCQlnb3RvIG91dF9jcHVfZnJlZTsKKwkJZ290byBvdXRfdGhyZWFkX21hcF9kZWxldGU7CiAJfQogCiAJaWYgKHBlcmZfZXZzZWxfX29wZW4oZXZzZWwsIGNwdXMsIHRocmVhZHMpIDwgMCkgewpAQCAtMzc5LDE0ICszNzMsMjkgQEAKIAogCWZvciAoY3B1ID0gMDsgY3B1IDwgY3B1cy0+bnI7ICsrY3B1KSB7CiAJCXVuc2lnbmVkIGludCBuY2FsbHMgPSBucl9vcGVuX2NhbGxzICsgY3B1OworCQkvKgorCQkgKiBYWFggZXZlbnR1YWxseSBsaWZ0IHRoaXMgcmVzdHJpY3Rpb24gaW4gYSB3YXkgdGhhdAorCQkgKiBrZWVwcyBwZXJmIGJ1aWxkaW5nIG9uIG9sZGVyIGdsaWJjIGluc3RhbGxhdGlvbnMKKwkJICogd2l0aG91dCBDUFVfQUxMT0MuIDEwMjQgY3B1cyBpbiAyMDEwIHN0aWxsIHNlZW1zCisJCSAqIGEgcmVhc29uYWJsZSB1cHBlciBsaW1pdCB0aG8gOi0pCisJCSAqLworCQlpZiAoY3B1cy0+bWFwW2NwdV0gPj0gQ1BVX1NFVFNJWkUpIHsKKwkJCXByX2RlYnVnKCJJZ25vcmluZyBDUFUgJWRcbiIsIGNwdXMtPm1hcFtjcHVdKTsKKwkJCWNvbnRpbnVlOworCQl9CiAKLQkJQ1BVX1NFVChjcHUsIGNwdV9zZXQpOwotCQlzY2hlZF9zZXRhZmZpbml0eSgwLCBjcHVfc2V0X3NpemUsIGNwdV9zZXQpOworCQlDUFVfU0VUKGNwdXMtPm1hcFtjcHVdLCAmY3B1X3NldCk7CisJCWlmIChzY2hlZF9zZXRhZmZpbml0eSgwLCBzaXplb2YoY3B1X3NldCksICZjcHVfc2V0KSA8IDApIHsKKwkJCXByX2RlYnVnKCJzY2hlZF9zZXRhZmZpbml0eSgpIGZhaWxlZCBvbiBDUFUgJWQ6ICVzICIsCisJCQkJIGNwdXMtPm1hcFtjcHVdLAorCQkJCSBzdHJlcnJvcihlcnJubykpOworCQkJZ290byBvdXRfY2xvc2VfZmQ7CisJCX0KIAkJZm9yIChpID0gMDsgaSA8IG5jYWxsczsgKytpKSB7CiAJCQlmZCA9IG9wZW4oIi9ldGMvcGFzc3dkIiwgT19SRE9OTFkpOwogCQkJY2xvc2UoZmQpOwogCQl9Ci0JCUNQVV9DTFIoY3B1LCBjcHVfc2V0KTsKKwkJQ1BVX0NMUihjcHVzLT5tYXBbY3B1XSwgJmNwdV9zZXQpOwogCX0KIAogCS8qCkBAIC00MDIsNiArNDExLDkgQEAKIAlmb3IgKGNwdSA9IDA7IGNwdSA8IGNwdXMtPm5yOyArK2NwdSkgewogCQl1bnNpZ25lZCBpbnQgZXhwZWN0ZWQ7CiAKKwkJaWYgKGNwdXMtPm1hcFtjcHVdID49IENQVV9TRVRTSVpFKQorCQkJY29udGludWU7CisKIAkJaWYgKHBlcmZfZXZzZWxfX3JlYWRfb25fY3B1KGV2c2VsLCBjcHUsIDApIDwgMCkgewogCQkJcHJfZGVidWcoInBlcmZfZXZzZWxfX29wZW5fcmVhZF9vbl9jcHVcbiIpOwogCQkJZ290byBvdXRfY2xvc2VfZmQ7CkBAIC00MDksOCArNDIxLDggQEAKIAogCQlleHBlY3RlZCA9IG5yX29wZW5fY2FsbHMgKyBjcHU7CiAJCWlmIChldnNlbC0+Y291bnRzLT5jcHVbY3B1XS52YWwgIT0gZXhwZWN0ZWQpIHsKLQkJCXByX2RlYnVnKCJwZXJmX2V2c2VsX19yZWFkX29uX2NwdTogZXhwZWN0ZWQgdG8gaW50ZXJjZXB0ICVkIGNhbGxzIG9uIGNwdSAlZCwgZ290ICVMZFxuIiwKLQkJCQkgZXhwZWN0ZWQsIGNwdSwgZXZzZWwtPmNvdW50cy0+Y3B1W2NwdV0udmFsKTsKKwkJCXByX2RlYnVnKCJwZXJmX2V2c2VsX19yZWFkX29uX2NwdTogZXhwZWN0ZWQgdG8gaW50ZXJjZXB0ICVkIGNhbGxzIG9uIGNwdSAlZCwgZ290ICUiIFBSSXU2NCAiXG4iLAorCQkJCSBleHBlY3RlZCwgY3B1cy0+bWFwW2NwdV0sIGV2c2VsLT5jb3VudHMtPmNwdVtjcHVdLnZhbCk7CiAJCQlnb3RvIG91dF9jbG9zZV9mZDsKIAkJfQogCX0KQEAgLTQyMCw4ICs0MzIsNiBAQAogCXBlcmZfZXZzZWxfX2Nsb3NlX2ZkKGV2c2VsLCAxLCB0aHJlYWRzLT5ucik7CiBvdXRfZXZzZWxfZGVsZXRlOgogCXBlcmZfZXZzZWxfX2RlbGV0ZShldnNlbCk7Ci1vdXRfY3B1X2ZyZWU6Ci0JQ1BVX0ZSRUUoY3B1X3NldCk7CiBvdXRfdGhyZWFkX21hcF9kZWxldGU6CiAJdGhyZWFkX21hcF9fZGVsZXRlKHRocmVhZHMpOwogCXJldHVybiBlcnI7CmRpZmYgLS1naXQgYS90b29scy9wZXJmL2J1aWx0aW4tdG9wLmMgYi90b29scy9wZXJmL2J1aWx0aW4tdG9wLmMKaW5kZXggNmNlNDA0Mi4uYjY5OThlMCAxMDA2NDQKLS0tIGEvdG9vbHMvcGVyZi9idWlsdGluLXRvcC5jCisrKyBiL3Rvb2xzL3BlcmYvYnVpbHRpbi10b3AuYwpAQCAtNDAsNiArNDAsNyBAQAogI2luY2x1ZGUgPHN0ZGlvLmg+CiAjaW5jbHVkZSA8dGVybWlvcy5oPgogI2luY2x1ZGUgPHVuaXN0ZC5oPgorI2luY2x1ZGUgPGludHR5cGVzLmg+CiAKICNpbmNsdWRlIDxlcnJuby5oPgogI2luY2x1ZGUgPHRpbWUuaD4KQEAgLTIxNCw3ICsyMTUsNyBAQAogCWxlbiA9IHN5bS0+ZW5kIC0gc3ltLT5zdGFydDsKIAogCXNwcmludGYoY29tbWFuZCwKLQkJIm9iamR1bXAgLS1zdGFydC1hZGRyZXNzPSUjMCpMeCAtLXN0b3AtYWRkcmVzcz0lIzAqTHggLWRTICVzIiwKKwkJIm9iamR1bXAgLS1zdGFydC1hZGRyZXNzPSUjMCoiIFBSSXg2NCAiIC0tc3RvcC1hZGRyZXNzPSUjMCoiIFBSSXg2NCAiIC1kUyAlcyIsCiAJCUJJVFNfUEVSX0xPTkcgLyA0LCBtYXBfX3JpcF8yb2JqZHVtcChtYXAsIHN5bS0+c3RhcnQpLAogCQlCSVRTX1BFUl9MT05HIC8gNCwgbWFwX19yaXBfMm9iamR1bXAobWFwLCBzeW0tPmVuZCksIHBhdGgpOwogCkBAIC0zMDgsNyArMzA5LDcgQEAKIAlzdHJ1Y3Qgc291cmNlX2xpbmUgKmxpbmU7CiAJY2hhciBwYXR0ZXJuW1BBVFRFUk5fTEVOICsgMV07CiAKLQlzcHJpbnRmKHBhdHRlcm4sICIlMCpMeCA8IiwgQklUU19QRVJfTE9ORyAvIDQsCisJc3ByaW50ZihwYXR0ZXJuLCAiJTAqIiBQUkl4NjQgIiA8IiwgQklUU19QRVJfTE9ORyAvIDQsCiAJCW1hcF9fcmlwXzJvYmpkdW1wKHN5bWUtPm1hcCwgc3ltYm9sLT5zdGFydCkpOwogCiAJcHRocmVhZF9tdXRleF9sb2NrKCZzeW1lLT5zcmMtPmxvY2spOwpAQCAtNTM3LDcgKzUzOCw3IEBACiAJaWYgKG5yX2NvdW50ZXJzID09IDEgfHwgIWRpc3BsYXlfd2VpZ2h0ZWQpIHsKIAkJc3RydWN0IHBlcmZfZXZzZWwgKmZpcnN0OwogCQlmaXJzdCA9IGxpc3RfZW50cnkoZXZzZWxfbGlzdC5uZXh0LCBzdHJ1Y3QgcGVyZl9ldnNlbCwgbm9kZSk7Ci0JCXByaW50ZigiJUxkIiwgZmlyc3QtPmF0dHIuc2FtcGxlX3BlcmlvZCk7CisJCXByaW50ZigiJSIgUFJJdTY0LCAodWludDY0X3QpZmlyc3QtPmF0dHIuc2FtcGxlX3BlcmlvZCk7CiAJCWlmIChmcmVxKQogCQkJcHJpbnRmKCJIeiAiKTsKIAkJZWxzZQpAQCAtNjQwLDcgKzY0MSw3IEBACiAKIAkJcGVyY2VudF9jb2xvcl9mcHJpbnRmKHN0ZG91dCwgIiU0LjFmJSUiLCBwY250KTsKIAkJaWYgKHZlcmJvc2UpCi0JCQlwcmludGYoIiAlMDE2bGx4Iiwgc3ltLT5zdGFydCk7CisJCQlwcmludGYoIiAlMDE2IiBQUkl4NjQsIHN5bS0+c3RhcnQpOwogCQlwcmludGYoIiAlLSouKnMiLCBzeW1fd2lkdGgsIHN5bV93aWR0aCwgc3ltLT5uYW1lKTsKIAkJcHJpbnRmKCIgJS0qLipzXG4iLCBkc29fd2lkdGgsIGRzb193aWR0aCwKIAkJICAgICAgIGRzb193aWR0aCA+PSBzeW1lLT5tYXAtPmRzby0+bG9uZ19uYW1lX2xlbiA/CkBAIC0xMjQ3LDggKzEyNDgsNiBAQAogCQkJCWRpZSgiUGVybWlzc2lvbiBlcnJvciAtIGFyZSB5b3Ugcm9vdD9cbiIKIAkJCQkJIlx0IENvbnNpZGVyIHR3ZWFraW5nIgogCQkJCQkiIC9wcm9jL3N5cy9rZXJuZWwvcGVyZl9ldmVudF9wYXJhbm9pZC5cbiIpOwotCQkJaWYgKGVyciA9PSBFTk9FTlQpCi0JCQkJZGllKCIlcyBldmVudCBpcyBub3Qgc3VwcG9ydGVkLiAiLCBldmVudF9uYW1lKGV2c2VsKSk7CiAJCQkvKgogCQkJICogSWYgaXQncyBjeWNsZXMgdGhlbiBmYWxsIGJhY2sgdG8gaHJ0aW1lcgogCQkJICogYmFzZWQgY3B1LWNsb2NrLXRpY2sgc3cgY291bnRlciwgd2hpY2gKQEAgLTE0NzMsNiArMTQ3Miw4IEBACiAJCXBvcy0+YXR0ci5zYW1wbGVfcGVyaW9kID0gZGVmYXVsdF9pbnRlcnZhbDsKIAl9CiAKKwlzeW1fZXZzZWwgPSBsaXN0X2VudHJ5KGV2c2VsX2xpc3QubmV4dCwgc3RydWN0IHBlcmZfZXZzZWwsIG5vZGUpOworCiAJc3ltYm9sX2NvbmYucHJpdl9zaXplID0gKHNpemVvZihzdHJ1Y3Qgc3ltX2VudHJ5KSArCiAJCQkJIChucl9jb3VudGVycyArIDEpICogc2l6ZW9mKHVuc2lnbmVkIGxvbmcpKTsKIApAQCAtMTQ5MCw2ICsxNDkxLDcgQEAKIG91dF9mcmVlX2ZkOgogCWxpc3RfZm9yX2VhY2hfZW50cnkocG9zLCAmZXZzZWxfbGlzdCwgbm9kZSkKIAkJcGVyZl9ldnNlbF9fZnJlZV9tbWFwKHBvcyk7CisJcGVyZl9ldnNlbF9saXN0X19kZWxldGUoKTsKIAogCXJldHVybiBzdGF0dXM7CiB9CmRpZmYgLS1naXQgYS90b29scy9wZXJmL3BlcmYuYyBiL3Rvb2xzL3BlcmYvcGVyZi5jCmluZGV4IDViMWVjZDYuLjU5NWQwZjQgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvcGVyZi5jCisrKyBiL3Rvb2xzL3BlcmYvcGVyZi5jCkBAIC0yODYsOCArMjg2LDYgQEAKIAlzdGF0dXMgPSBwLT5mbihhcmdjLCBhcmd2LCBwcmVmaXgpOwogCWV4aXRfYnJvd3NlcihzdGF0dXMpOwogCi0JcGVyZl9ldnNlbF9saXN0X19kZWxldGUoKTsKLQogCWlmIChzdGF0dXMpCiAJCXJldHVybiBzdGF0dXMgJiAweGZmOwogCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvZXZlbnQuYyBiL3Rvb2xzL3BlcmYvdXRpbC9ldmVudC5jCmluZGV4IDIzMDJlYzAuLjE0NzhhYjQgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvdXRpbC9ldmVudC5jCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9ldmVudC5jCkBAIC00NTksNyArNDU5LDggQEAKIGludCBldmVudF9fcHJvY2Vzc19sb3N0KGV2ZW50X3QgKnNlbGYsIHN0cnVjdCBzYW1wbGVfZGF0YSAqc2FtcGxlIF9fdXNlZCwKIAkJCXN0cnVjdCBwZXJmX3Nlc3Npb24gKnNlc3Npb24pCiB7Ci0JZHVtcF9wcmludGYoIjogaWQ6JUxkOiBsb3N0OiVMZFxuIiwgc2VsZi0+bG9zdC5pZCwgc2VsZi0+bG9zdC5sb3N0KTsKKwlkdW1wX3ByaW50ZigiOiBpZDolIiBQUkl1NjQgIjogbG9zdDolIiBQUkl1NjQgIlxuIiwKKwkJICAgIHNlbGYtPmxvc3QuaWQsIHNlbGYtPmxvc3QubG9zdCk7CiAJc2Vzc2lvbi0+aGlzdHMuc3RhdHMudG90YWxfbG9zdCArPSBzZWxmLT5sb3N0Lmxvc3Q7CiAJcmV0dXJuIDA7CiB9CkBAIC01NzUsNyArNTc2LDcgQEAKIAl1OCBjcHVtb2RlID0gc2VsZi0+aGVhZGVyLm1pc2MgJiBQRVJGX1JFQ09SRF9NSVNDX0NQVU1PREVfTUFTSzsKIAlpbnQgcmV0ID0gMDsKIAotCWR1bXBfcHJpbnRmKCIgJWQvJWQ6IFslI0x4KCUjTHgpIEAgJSNMeF06ICVzXG4iLAorCWR1bXBfcHJpbnRmKCIgJWQvJWQ6IFslIyIgUFJJeDY0ICIoJSMiIFBSSXg2NCAiKSBAICUjIiBQUkl4NjQgIl06ICVzXG4iLAogCQkJc2VsZi0+bW1hcC5waWQsIHNlbGYtPm1tYXAudGlkLCBzZWxmLT5tbWFwLnN0YXJ0LAogCQkJc2VsZi0+bW1hcC5sZW4sIHNlbGYtPm1tYXAucGdvZmYsIHNlbGYtPm1tYXAuZmlsZW5hbWUpOwogCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvZXZzZWwuYyBiL3Rvb2xzL3BlcmYvdXRpbC9ldnNlbC5jCmluZGV4IGY1Y2ZlZDYuLmQ4NTc1ZDMgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvdXRpbC9ldnNlbC5jCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9ldnNlbC5jCkBAIC05MCw3ICs5MCw3IEBACiAJaW50IGNwdSwgdGhyZWFkOwogCXN0cnVjdCBwZXJmX2NvdW50c192YWx1ZXMgKmFnZ3IgPSAmZXZzZWwtPmNvdW50cy0+YWdnciwgY291bnQ7CiAKLQlhZ2dyLT52YWwgPSAwOworCWFnZ3ItPnZhbCA9IGFnZ3ItPmVuYSA9IGFnZ3ItPnJ1biA9IDA7CiAKIAlmb3IgKGNwdSA9IDA7IGNwdSA8IG5jcHVzOyBjcHUrKykgewogCQlmb3IgKHRocmVhZCA9IDA7IHRocmVhZCA8IG50aHJlYWRzOyB0aHJlYWQrKykgewpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL2hlYWRlci5jIGIvdG9vbHMvcGVyZi91dGlsL2hlYWRlci5jCmluZGV4IDk4OWZhMmQuLmY2YTkyOWUgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvdXRpbC9oZWFkZXIuYworKysgYi90b29scy9wZXJmL3V0aWwvaGVhZGVyLmMKQEAgLTc5OCw4ICs3OTgsOCBAQAogCQkJCSAgICAgIGludCBmZWF0LCBpbnQgZmQpCiB7CiAJaWYgKGxzZWVrKGZkLCBzZWxmLT5vZmZzZXQsIFNFRUtfU0VUKSA9PSAob2ZmX3QpLTEpIHsKLQkJcHJfZGVidWcoIkZhaWxlZCB0byBsc2VlayB0byAlTGQgb2Zmc2V0IGZvciBmZWF0dXJlICVkLCAiCi0JCQkgImNvbnRpbnVpbmcuLi5cbiIsIHNlbGYtPm9mZnNldCwgZmVhdCk7CisJCXByX2RlYnVnKCJGYWlsZWQgdG8gbHNlZWsgdG8gJSIgUFJJdTY0ICIgb2Zmc2V0IGZvciBmZWF0dXJlICIKKwkJCSAgIiVkLCBjb250aW51aW5nLi4uXG4iLCBzZWxmLT5vZmZzZXQsIGZlYXQpOwogCQlyZXR1cm4gMDsKIAl9CiAKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9oaXN0LmMgYi90b29scy9wZXJmL3V0aWwvaGlzdC5jCmluZGV4IGM3NDliYTYuLjMyZjRmMWYgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvdXRpbC9oaXN0LmMKKysrIGIvdG9vbHMvcGVyZi91dGlsL2hpc3QuYwpAQCAtNjM2LDEzICs2MzYsMTMgQEAKIAkJCX0KIAkJfQogCX0gZWxzZQotCQlyZXQgPSBzbnByaW50ZihzLCBzaXplLCBzZXAgPyAiJWxsZCIgOiAiJTEybGxkICIsIHBlcmlvZCk7CisJCXJldCA9IHNucHJpbnRmKHMsIHNpemUsIHNlcCA/ICIlIiBQUkl1NjQgOiAiJTEyIiBQUkl1NjQgIiAiLCBwZXJpb2QpOwogCiAJaWYgKHN5bWJvbF9jb25mLnNob3dfbnJfc2FtcGxlcykgewogCQlpZiAoc2VwKQotCQkJcmV0ICs9IHNucHJpbnRmKHMgKyByZXQsIHNpemUgLSByZXQsICIlYyVsbGQiLCAqc2VwLCBwZXJpb2QpOworCQkJcmV0ICs9IHNucHJpbnRmKHMgKyByZXQsIHNpemUgLSByZXQsICIlYyUiIFBSSXU2NCwgKnNlcCwgcGVyaW9kKTsKIAkJZWxzZQotCQkJcmV0ICs9IHNucHJpbnRmKHMgKyByZXQsIHNpemUgLSByZXQsICIlMTFsbGQiLCBwZXJpb2QpOworCQkJcmV0ICs9IHNucHJpbnRmKHMgKyByZXQsIHNpemUgLSByZXQsICIlMTEiIFBSSXU2NCwgcGVyaW9kKTsKIAl9CiAKIAlpZiAocGFpcl9oaXN0cykgewpAQCAtOTcxLDcgKzk3MSw3IEBACiAJc3ltX3NpemUgPSBzeW0tPmVuZCAtIHN5bS0+c3RhcnQ7CiAJb2Zmc2V0ID0gaXAgLSBzeW0tPnN0YXJ0OwogCi0JcHJfZGVidWczKCIlczogaXA9JSNMeFxuIiwgX19mdW5jX18sIHNlbGYtPm1zLm1hcC0+dW5tYXBfaXAoc2VsZi0+bXMubWFwLCBpcCkpOworCXByX2RlYnVnMygiJXM6IGlwPSUjIiBQUkl4NjQgIlxuIiwgX19mdW5jX18sIHNlbGYtPm1zLm1hcC0+dW5tYXBfaXAoc2VsZi0+bXMubWFwLCBpcCkpOwogCiAJaWYgKG9mZnNldCA+PSBzeW1fc2l6ZSkKIAkJcmV0dXJuIDA7CkBAIC05ODAsOCArOTgwLDkgQEAKIAloLT5zdW0rKzsKIAloLT5pcFtvZmZzZXRdKys7CiAKLQlwcl9kZWJ1ZzMoIiUjTHggJXM6IHBlcmlvZCsrIFtpcDogJSNMeCwgJSNMeF0gPT4gJUxkXG4iLCBzZWxmLT5tcy5zeW0tPnN0YXJ0LAotCQkgIHNlbGYtPm1zLnN5bS0+bmFtZSwgaXAsIGlwIC0gc2VsZi0+bXMuc3ltLT5zdGFydCwgaC0+aXBbb2Zmc2V0XSk7CisJcHJfZGVidWczKCIlIyIgUFJJeDY0ICIgJXM6IHBlcmlvZCsrIFtpcDogJSMiIFBSSXg2NCAiLCAlIyIgUFJJeDY0CisJCSAgIl0gPT4gJSIgUFJJdTY0ICJcbiIsIHNlbGYtPm1zLnN5bS0+c3RhcnQsIHNlbGYtPm1zLnN5bS0+bmFtZSwKKwkJICBpcCwgaXAgLSBzZWxmLT5tcy5zeW0tPnN0YXJ0LCBoLT5pcFtvZmZzZXRdKTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtMTEzMiw3ICsxMTMzLDcgQEAKIAkJZ290byBvdXRfZnJlZV9maWxlbmFtZTsKIAl9CiAKLQlwcl9kZWJ1ZygiJXM6IGZpbGVuYW1lPSVzLCBzeW09JXMsIHN0YXJ0PSUjTHgsIGVuZD0lI0x4XG4iLCBfX2Z1bmNfXywKKwlwcl9kZWJ1ZygiJXM6IGZpbGVuYW1lPSVzLCBzeW09JXMsIHN0YXJ0PSUjIiBQUkl4NjQgIiwgZW5kPSUjIiBQUkl4NjQgIlxuIiwgX19mdW5jX18sCiAJCSBmaWxlbmFtZSwgc3ltLT5uYW1lLCBtYXAtPnVubWFwX2lwKG1hcCwgc3ltLT5zdGFydCksCiAJCSBtYXAtPnVubWFwX2lwKG1hcCwgc3ltLT5lbmQpKTsKIApAQCAtMTE0Miw3ICsxMTQzLDcgQEAKIAkJIGRzbywgZHNvLT5sb25nX25hbWUsIHN5bSwgc3ltLT5uYW1lKTsKIAogCXNucHJpbnRmKGNvbW1hbmQsIHNpemVvZihjb21tYW5kKSwKLQkJICJvYmpkdW1wIC0tc3RhcnQtYWRkcmVzcz0weCUwMTZMeCAtLXN0b3AtYWRkcmVzcz0weCUwMTZMeCAtZFMgLUMgJXN8Z3JlcCAtdiAlc3xleHBhbmQiLAorCQkgIm9iamR1bXAgLS1zdGFydC1hZGRyZXNzPTB4JTAxNiIgUFJJeDY0ICIgLS1zdG9wLWFkZHJlc3M9MHglMDE2IiBQUkl4NjQgIiAtZFMgLUMgJXN8Z3JlcCAtdiAlc3xleHBhbmQiLAogCQkgbWFwX19yaXBfMm9iamR1bXAobWFwLCBzeW0tPnN0YXJ0KSwKIAkJIG1hcF9fcmlwXzJvYmpkdW1wKG1hcCwgc3ltLT5lbmQpLAogCQkgc3ltZnNfZmlsZW5hbWUsIGZpbGVuYW1lKTsKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9pbmNsdWRlL2xpbnV4L2JpdG9wcy5oIGIvdG9vbHMvcGVyZi91dGlsL2luY2x1ZGUvbGludXgvYml0b3BzLmgKaW5kZXggOGJlMGI5Ni4uMzA1Yzg0OCAxMDA2NDQKLS0tIGEvdG9vbHMvcGVyZi91dGlsL2luY2x1ZGUvbGludXgvYml0b3BzLmgKKysrIGIvdG9vbHMvcGVyZi91dGlsL2luY2x1ZGUvbGludXgvYml0b3BzLmgKQEAgLTIsNiArMiw3IEBACiAjZGVmaW5lIF9QRVJGX0xJTlVYX0JJVE9QU19IXwogCiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvY29tcGlsZXIuaD4KICNpbmNsdWRlIDxhc20vaHdlaWdodC5oPgogCiAjZGVmaW5lIEJJVFNfUEVSX0xPTkcgX19XT1JEU0laRQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL21hcC5jIGIvdG9vbHMvcGVyZi91dGlsL21hcC5jCmluZGV4IDNhN2ViNmUuLmExNmVjYWIgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvdXRpbC9tYXAuYworKysgYi90b29scy9wZXJmL3V0aWwvbWFwLmMKQEAgLTEsNSArMSw2IEBACiAjaW5jbHVkZSAic3ltYm9sLmgiCiAjaW5jbHVkZSA8ZXJybm8uaD4KKyNpbmNsdWRlIDxpbnR0eXBlcy5oPgogI2luY2x1ZGUgPGxpbWl0cy5oPgogI2luY2x1ZGUgPHN0ZGxpYi5oPgogI2luY2x1ZGUgPHN0cmluZy5oPgpAQCAtMTk1LDcgKzE5Niw3IEBACiAKIHNpemVfdCBtYXBfX2ZwcmludGYoc3RydWN0IG1hcCAqc2VsZiwgRklMRSAqZnApCiB7Ci0JcmV0dXJuIGZwcmludGYoZnAsICIgJUx4LSVMeCAlTHggJXNcbiIsCisJcmV0dXJuIGZwcmludGYoZnAsICIgJSIgUFJJeDY0ICItJSIgUFJJeDY0ICIgJSIgUFJJeDY0ICIgJXNcbiIsCiAJCSAgICAgICBzZWxmLT5zdGFydCwgc2VsZi0+ZW5kLCBzZWxmLT5wZ29mZiwgc2VsZi0+ZHNvLT5uYW1lKTsKIH0KIApkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL3BhcnNlLWV2ZW50cy5jIGIvdG9vbHMvcGVyZi91dGlsL3BhcnNlLWV2ZW50cy5jCmluZGV4IDVjYjZmNGIuLjEzNWY2OWIgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvdXRpbC9wYXJzZS1ldmVudHMuYworKysgYi90b29scy9wZXJmL3V0aWwvcGFyc2UtZXZlbnRzLmMKQEAgLTI3OSw3ICsyNzksNyBAQAogCXN0YXRpYyBjaGFyIGJ1ZlszMl07CiAKIAlpZiAodHlwZSA9PSBQRVJGX1RZUEVfUkFXKSB7Ci0JCXNwcmludGYoYnVmLCAicmF3IDB4JWxseCIsIGNvbmZpZyk7CisJCXNwcmludGYoYnVmLCAicmF3IDB4JSIgUFJJeDY0LCBjb25maWcpOwogCQlyZXR1cm4gYnVmOwogCX0KIApAQCAtNDkwLDMyICs0OTAsNiBAQAogCXJldHVybiBFVlRfSEFORExFRF9BTEw7CiB9CiAKLXN0YXRpYyBpbnQgc3RvcmVfZXZlbnRfdHlwZShjb25zdCBjaGFyICpvcmduYW1lKQotewotCWNoYXIgZmlsZW5hbWVbUEFUSF9NQVhdLCAqYzsKLQlGSUxFICpmaWxlOwotCWludCBpZCwgbjsKLQotCXNwcmludGYoZmlsZW5hbWUsICIlcy8iLCBkZWJ1Z2ZzX3BhdGgpOwotCXN0cm5jYXQoZmlsZW5hbWUsIG9yZ25hbWUsIHN0cmxlbihvcmduYW1lKSk7Ci0Jc3RyY2F0KGZpbGVuYW1lLCAiL2lkIik7Ci0KLQljID0gc3RyY2hyKGZpbGVuYW1lLCAnOicpOwotCWlmIChjKQotCQkqYyA9ICcvJzsKLQotCWZpbGUgPSBmb3BlbihmaWxlbmFtZSwgInIiKTsKLQlpZiAoIWZpbGUpCi0JCXJldHVybiAwOwotCW4gPSBmc2NhbmYoZmlsZSwgIiVpIiwgJmlkKTsKLQlmY2xvc2UoZmlsZSk7Ci0JaWYgKG4gPCAxKSB7Ci0JCXByX2VycigiY2Fubm90IHN0b3JlIGV2ZW50IElEXG4iKTsKLQkJcmV0dXJuIC1FSU5WQUw7Ci0JfQotCXJldHVybiBwZXJmX2hlYWRlcl9fcHVzaF9ldmVudChpZCwgb3JnbmFtZSk7Ci19Ci0KIHN0YXRpYyBlbnVtIGV2ZW50X3Jlc3VsdCBwYXJzZV90cmFjZXBvaW50X2V2ZW50KGNvbnN0IGNoYXIgKipzdHJwLAogCQkJCSAgICBzdHJ1Y3QgcGVyZl9ldmVudF9hdHRyICphdHRyKQogewpAQCAtNTU1LDEzICs1MjksMTAgQEAKIAlpZiAoZXZ0X2xlbmd0aCA+PSBNQVhfRVZFTlRfTEVOR1RIKQogCQlyZXR1cm4gRVZUX0ZBSUxFRDsKIAlpZiAoc3RycGJyayhldnRfbmFtZSwgIio/IikpIHsKLQkJKnN0cnAgKz0gc3RybGVuKHN5c19uYW1lKSArIGV2dF9sZW5ndGg7CisJCSpzdHJwICs9IHN0cmxlbihzeXNfbmFtZSkgKyBldnRfbGVuZ3RoICsgMTsgLyogMSA9PSB0aGUgJzonICovCiAJCXJldHVybiBwYXJzZV9tdWx0aXBsZV90cmFjZXBvaW50X2V2ZW50KHN5c19uYW1lLCBldnRfbmFtZSwKIAkJCQkJCSAgICAgICBmbGFncyk7CiAJfSBlbHNlIHsKLQkJaWYgKHN0b3JlX2V2ZW50X3R5cGUoZXZ0X25hbWUpIDwgMCkKLQkJCXJldHVybiBFVlRfRkFJTEVEOwotCiAJCXJldHVybiBwYXJzZV9zaW5nbGVfdHJhY2Vwb2ludF9ldmVudChzeXNfbmFtZSwgZXZ0X25hbWUsCiAJCQkJCQkgICAgIGV2dF9sZW5ndGgsIGF0dHIsIHN0cnApOwogCX0KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9wYXJzZS1ldmVudHMuaCBiL3Rvb2xzL3BlcmYvdXRpbC9wYXJzZS1ldmVudHMuaAppbmRleCBiODJjYWZiLi40NThlM2VjIDEwMDY0NAotLS0gYS90b29scy9wZXJmL3V0aWwvcGFyc2UtZXZlbnRzLmgKKysrIGIvdG9vbHMvcGVyZi91dGlsL3BhcnNlLWV2ZW50cy5oCkBAIC0yMyw3ICsyMyw3IEBACiB9OwogCiBleHRlcm4gc3RydWN0IHRyYWNlcG9pbnRfcGF0aCAqdHJhY2Vwb2ludF9pZF90b19wYXRoKHU2NCBjb25maWcpOwotZXh0ZXJuIGJvb2wgaGF2ZV90cmFjZXBvaW50cyhzdHJ1Y3QgbGlzdF9oZWFkICpldnNlbF9saXN0KTsKK2V4dGVybiBib29sIGhhdmVfdHJhY2Vwb2ludHMoc3RydWN0IGxpc3RfaGVhZCAqZXZsaXN0KTsKIAogZXh0ZXJuIGludAkJCW5yX2NvdW50ZXJzOwogCmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcHJvYmUtZXZlbnQuYyBiL3Rvb2xzL3BlcmYvdXRpbC9wcm9iZS1ldmVudC5jCmluZGV4IDEyOGFhYWIuLjZlMjlkOWMgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvdXRpbC9wcm9iZS1ldmVudC5jCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9wcm9iZS1ldmVudC5jCkBAIC0xNzIsNyArMTcyLDcgQEAKIAlzeW0gPSBfX2ZpbmRfa2VybmVsX2Z1bmN0aW9uX2J5X25hbWUodHAtPnN5bWJvbCwgJm1hcCk7CiAJaWYgKHN5bSkgewogCQlhZGRyID0gbWFwLT51bm1hcF9pcChtYXAsIHN5bS0+c3RhcnQgKyB0cC0+b2Zmc2V0KTsKLQkJcHJfZGVidWcoInRyeSB0byBmaW5kICVzKyVsZEAlbGx4XG4iLCB0cC0+c3ltYm9sLAorCQlwcl9kZWJ1ZygidHJ5IHRvIGZpbmQgJXMrJWxkQCUiIFBSSXg2NCAiXG4iLCB0cC0+c3ltYm9sLAogCQkJIHRwLT5vZmZzZXQsIGFkZHIpOwogCQlyZXQgPSBmaW5kX3BlcmZfcHJvYmVfcG9pbnQoKHVuc2lnbmVkIGxvbmcpYWRkciwgcHApOwogCX0KZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC9zZXNzaW9uLmMgYi90b29scy9wZXJmL3V0aWwvc2Vzc2lvbi5jCmluZGV4IDMxM2RhYzIuLjEwNWYwMGIgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvdXRpbC9zZXNzaW9uLmMKKysrIGIvdG9vbHMvcGVyZi91dGlsL3Nlc3Npb24uYwpAQCAtNjUyLDEwICs2NTIsMTEgQEAKIHsKIAl1bnNpZ25lZCBpbnQgaTsKIAotCXByaW50ZigiLi4uIGNoYWluOiBucjolTHVcbiIsIHNhbXBsZS0+Y2FsbGNoYWluLT5ucik7CisJcHJpbnRmKCIuLi4gY2hhaW46IG5yOiUiIFBSSXU2NCAiXG4iLCBzYW1wbGUtPmNhbGxjaGFpbi0+bnIpOwogCiAJZm9yIChpID0gMDsgaSA8IHNhbXBsZS0+Y2FsbGNoYWluLT5ucjsgaSsrKQotCQlwcmludGYoIi4uLi4uICUyZDogJTAxNkx4XG4iLCBpLCBzYW1wbGUtPmNhbGxjaGFpbi0+aXBzW2ldKTsKKwkJcHJpbnRmKCIuLi4uLiAlMmQ6ICUwMTYiIFBSSXg2NCAiXG4iLAorCQkgICAgICAgaSwgc2FtcGxlLT5jYWxsY2hhaW4tPmlwc1tpXSk7CiB9CiAKIHN0YXRpYyB2b2lkIHBlcmZfc2Vzc2lvbl9fcHJpbnRfdHN0YW1wKHN0cnVjdCBwZXJmX3Nlc3Npb24gKnNlc3Npb24sCkBAIC02NzIsNyArNjczLDcgQEAKIAkJcHJpbnRmKCIldSAiLCBzYW1wbGUtPmNwdSk7CiAKIAlpZiAoc2Vzc2lvbi0+c2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9USU1FKQotCQlwcmludGYoIiVMdSAiLCBzYW1wbGUtPnRpbWUpOworCQlwcmludGYoIiUiIFBSSXU2NCAiICIsIHNhbXBsZS0+dGltZSk7CiB9CiAKIHN0YXRpYyB2b2lkIGR1bXBfZXZlbnQoc3RydWN0IHBlcmZfc2Vzc2lvbiAqc2Vzc2lvbiwgZXZlbnRfdCAqZXZlbnQsCkBAIC02ODEsMTYgKzY4MiwxNiBAQAogCWlmICghZHVtcF90cmFjZSkKIAkJcmV0dXJuOwogCi0JcHJpbnRmKCJcbiUjTHggWyUjeF06IGV2ZW50OiAlZFxuIiwgZmlsZV9vZmZzZXQsIGV2ZW50LT5oZWFkZXIuc2l6ZSwKLQkgICAgICAgZXZlbnQtPmhlYWRlci50eXBlKTsKKwlwcmludGYoIlxuJSMiIFBSSXg2NCAiIFslI3hdOiBldmVudDogJWRcbiIsCisJICAgICAgIGZpbGVfb2Zmc2V0LCBldmVudC0+aGVhZGVyLnNpemUsIGV2ZW50LT5oZWFkZXIudHlwZSk7CiAKIAl0cmFjZV9ldmVudChldmVudCk7CiAKIAlpZiAoc2FtcGxlKQogCQlwZXJmX3Nlc3Npb25fX3ByaW50X3RzdGFtcChzZXNzaW9uLCBldmVudCwgc2FtcGxlKTsKIAotCXByaW50ZigiJSNMeCBbJSN4XTogUEVSRl9SRUNPUkRfJXMiLCBmaWxlX29mZnNldCwgZXZlbnQtPmhlYWRlci5zaXplLAotCSAgICAgICBldmVudF9fZ2V0X2V2ZW50X25hbWUoZXZlbnQtPmhlYWRlci50eXBlKSk7CisJcHJpbnRmKCIlIyIgUFJJeDY0ICIgWyUjeF06IFBFUkZfUkVDT1JEXyVzIiwgZmlsZV9vZmZzZXQsCisJICAgICAgIGV2ZW50LT5oZWFkZXIuc2l6ZSwgZXZlbnRfX2dldF9ldmVudF9uYW1lKGV2ZW50LT5oZWFkZXIudHlwZSkpOwogfQogCiBzdGF0aWMgdm9pZCBkdW1wX3NhbXBsZShzdHJ1Y3QgcGVyZl9zZXNzaW9uICpzZXNzaW9uLCBldmVudF90ICpldmVudCwKQEAgLTY5OSw4ICs3MDAsOSBAQAogCWlmICghZHVtcF90cmFjZSkKIAkJcmV0dXJuOwogCi0JcHJpbnRmKCIoSVAsICVkKTogJWQvJWQ6ICUjTHggcGVyaW9kOiAlTGRcbiIsIGV2ZW50LT5oZWFkZXIubWlzYywKLQkgICAgICAgc2FtcGxlLT5waWQsIHNhbXBsZS0+dGlkLCBzYW1wbGUtPmlwLCBzYW1wbGUtPnBlcmlvZCk7CisJcHJpbnRmKCIoSVAsICVkKTogJWQvJWQ6ICUjIiBQUkl4NjQgIiBwZXJpb2Q6ICUiIFBSSXU2NCAiXG4iLAorCSAgICAgICBldmVudC0+aGVhZGVyLm1pc2MsIHNhbXBsZS0+cGlkLCBzYW1wbGUtPnRpZCwgc2FtcGxlLT5pcCwKKwkgICAgICAgc2FtcGxlLT5wZXJpb2QpOwogCiAJaWYgKHNlc3Npb24tPnNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfQ0FMTENIQUlOKQogCQljYWxsY2hhaW5fX3ByaW50ZihzYW1wbGUpOwpAQCAtODQzLDggKzg0NSw4IEBACiB7CiAJaWYgKG9wcy0+bG9zdCA9PSBldmVudF9fcHJvY2Vzc19sb3N0ICYmCiAJICAgIHNlc3Npb24tPmhpc3RzLnN0YXRzLnRvdGFsX2xvc3QgIT0gMCkgewotCQl1aV9fd2FybmluZygiUHJvY2Vzc2VkICVMdSBldmVudHMgYW5kIExPU1QgJUx1IVxuXG4iCi0JCQkgICAgIkNoZWNrIElPL0NQVSBvdmVybG9hZCFcblxuIiwKKwkJdWlfX3dhcm5pbmcoIlByb2Nlc3NlZCAlIiBQUkl1NjQgIiBldmVudHMgYW5kIExPU1QgJSIgUFJJdTY0CisJCQkgICAgIiFcblxuQ2hlY2sgSU8vQ1BVIG92ZXJsb2FkIVxuXG4iLAogCQkJICAgIHNlc3Npb24tPmhpc3RzLnN0YXRzLnRvdGFsX3BlcmlvZCwKIAkJCSAgICBzZXNzaW9uLT5oaXN0cy5zdGF0cy50b3RhbF9sb3N0KTsKIAl9CkBAIC05MTgsNyArOTIwLDcgQEAKIAogCWlmIChzaXplID09IDAgfHwKIAkgICAgKHNraXAgPSBwZXJmX3Nlc3Npb25fX3Byb2Nlc3NfZXZlbnQoc2VsZiwgJmV2ZW50LCBvcHMsIGhlYWQpKSA8IDApIHsKLQkJZHVtcF9wcmludGYoIiUjTHggWyUjeF06IHNraXBwaW5nIHVua25vd24gaGVhZGVyIHR5cGU6ICVkXG4iLAorCQlkdW1wX3ByaW50ZigiJSMiIFBSSXg2NCAiIFslI3hdOiBza2lwcGluZyB1bmtub3duIGhlYWRlciB0eXBlOiAlZFxuIiwKIAkJCSAgICBoZWFkLCBldmVudC5oZWFkZXIuc2l6ZSwgZXZlbnQuaGVhZGVyLnR5cGUpOwogCQkvKgogCQkgKiBhc3N1bWUgd2UgbG9zdCB0cmFjayBvZiB0aGUgc3RyZWFtLCBjaGVjayBhbGlnbm1lbnQsIGFuZApAQCAtMTAyMyw3ICsxMDI1LDcgQEAKIAogCWlmIChzaXplID09IDAgfHwKIAkgICAgcGVyZl9zZXNzaW9uX19wcm9jZXNzX2V2ZW50KHNlc3Npb24sIGV2ZW50LCBvcHMsIGZpbGVfcG9zKSA8IDApIHsKLQkJZHVtcF9wcmludGYoIiUjTHggWyUjeF06IHNraXBwaW5nIHVua25vd24gaGVhZGVyIHR5cGU6ICVkXG4iLAorCQlkdW1wX3ByaW50ZigiJSMiIFBSSXg2NCAiIFslI3hdOiBza2lwcGluZyB1bmtub3duIGhlYWRlciB0eXBlOiAlZFxuIiwKIAkJCSAgICBmaWxlX29mZnNldCArIGhlYWQsIGV2ZW50LT5oZWFkZXIuc2l6ZSwKIAkJCSAgICBldmVudC0+aGVhZGVyLnR5cGUpOwogCQkvKgpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL3N2Z2hlbHBlci5jIGIvdG9vbHMvcGVyZi91dGlsL3N2Z2hlbHBlci5jCmluZGV4IGIzNjM3ZGIuLmZiNzM3ZmUgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvdXRpbC9zdmdoZWxwZXIuYworKysgYi90b29scy9wZXJmL3V0aWwvc3ZnaGVscGVyLmMKQEAgLTEyLDYgKzEyLDcgQEAKICAqIG9mIHRoZSBMaWNlbnNlLgogICovCiAKKyNpbmNsdWRlIDxpbnR0eXBlcy5oPgogI2luY2x1ZGUgPHN0ZGlvLmg+CiAjaW5jbHVkZSA8c3RkbGliLmg+CiAjaW5jbHVkZSA8dW5pc3RkLmg+CkBAIC00MywxMSArNDQsMTEgQEAKIAlyZXR1cm4gY3B1MnNsb3QoY3B1KSAqIFNMT1RfTVVMVDsKIH0KIAotc3RhdGljIGRvdWJsZSB0aW1lMnBpeGVscyh1NjQgdGltZSkKK3N0YXRpYyBkb3VibGUgdGltZTJwaXhlbHModTY0IF9fdGltZSkKIHsKIAlkb3VibGUgWDsKIAotCVggPSAxLjAgKiBzdmdfcGFnZV93aWR0aCAqICh0aW1lIC0gZmlyc3RfdGltZSkgLyAobGFzdF90aW1lIC0gZmlyc3RfdGltZSk7CisJWCA9IDEuMCAqIHN2Z19wYWdlX3dpZHRoICogKF9fdGltZSAtIGZpcnN0X3RpbWUpIC8gKGxhc3RfdGltZSAtIGZpcnN0X3RpbWUpOwogCXJldHVybiBYOwogfQogCkBAIC05NCw3ICs5NSw3IEBACiAKIAl0b3RhbF9oZWlnaHQgPSAoMSArIHJvd3MgKyBjcHUyc2xvdChjcHVzKSkgKiBTTE9UX01VTFQ7CiAJZnByaW50ZihzdmdmaWxlLCAiPD94bWwgdmVyc2lvbj1cIjEuMFwiIHN0YW5kYWxvbmU9XCJub1wiPz4gXG4iKTsKLQlmcHJpbnRmKHN2Z2ZpbGUsICI8c3ZnIHdpZHRoPVwiJWlcIiBoZWlnaHQ9XCIlbGx1XCIgdmVyc2lvbj1cIjEuMVwiIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIj5cbiIsIHN2Z19wYWdlX3dpZHRoLCB0b3RhbF9oZWlnaHQpOworCWZwcmludGYoc3ZnZmlsZSwgIjxzdmcgd2lkdGg9XCIlaVwiIGhlaWdodD1cIiUiIFBSSXU2NCAiXCIgdmVyc2lvbj1cIjEuMVwiIHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmdcIj5cbiIsIHN2Z19wYWdlX3dpZHRoLCB0b3RhbF9oZWlnaHQpOwogCiAJZnByaW50ZihzdmdmaWxlLCAiPGRlZnM+XG4gIDxzdHlsZSB0eXBlPVwidGV4dC9jc3NcIj5cbiAgICA8IVtDREFUQVtcbiIpOwogCkBAIC00ODMsNyArNDg0LDcgQEAKIAkJCWNvbG9yID0gMTI4OwogCQl9CiAKLQkJZnByaW50ZihzdmdmaWxlLCAiPGxpbmUgeDE9XCIlNC44ZlwiIHkxPVwiJTQuMmZcIiB4Mj1cIiU0LjhmXCIgeTI9XCIlbGx1XCIgc3R5bGU9XCJzdHJva2U6cmdiKCVpLCVpLCVpKTtzdHJva2Utd2lkdGg6JTEuM2ZcIi8+XG4iLAorCQlmcHJpbnRmKHN2Z2ZpbGUsICI8bGluZSB4MT1cIiU0LjhmXCIgeTE9XCIlNC4yZlwiIHgyPVwiJTQuOGZcIiB5Mj1cIiUiIFBSSXU2NCAiXCIgc3R5bGU9XCJzdHJva2U6cmdiKCVpLCVpLCVpKTtzdHJva2Utd2lkdGg6JTEuM2ZcIi8+XG4iLAogCQkJdGltZTJwaXhlbHMoaSksIFNMT1RfTVVMVC8yLCB0aW1lMnBpeGVscyhpKSwgdG90YWxfaGVpZ2h0LCBjb2xvciwgY29sb3IsIGNvbG9yLCB0aGlja25lc3MpOwogCiAJCWkgKz0gMTAwMDAwMDA7CmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvc3ltYm9sLmMgYi90b29scy9wZXJmL3V0aWwvc3ltYm9sLmMKaW5kZXggMTVjY2ZiYS4uNzgyMWQwZSAxMDA2NDQKLS0tIGEvdG9vbHMvcGVyZi91dGlsL3N5bWJvbC5jCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9zeW1ib2wuYwpAQCAtMTEsNiArMTEsNyBAQAogI2luY2x1ZGUgPHN5cy9wYXJhbS5oPgogI2luY2x1ZGUgPGZjbnRsLmg+CiAjaW5jbHVkZSA8dW5pc3RkLmg+CisjaW5jbHVkZSA8aW50dHlwZXMuaD4KICNpbmNsdWRlICJidWlsZC1pZC5oIgogI2luY2x1ZGUgImRlYnVnLmgiCiAjaW5jbHVkZSAic3ltYm9sLmgiCkBAIC0xNTMsNyArMTU0LDcgQEAKIAlzZWxmLT5iaW5kaW5nID0gYmluZGluZzsKIAlzZWxmLT5uYW1lbGVuID0gbmFtZWxlbiAtIDE7CiAKLQlwcl9kZWJ1ZzQoIiVzOiAlcyAlI0x4LSUjTHhcbiIsIF9fZnVuY19fLCBuYW1lLCBzdGFydCwgc2VsZi0+ZW5kKTsKKwlwcl9kZWJ1ZzQoIiVzOiAlcyAlIyIgUFJJeDY0ICItJSMiIFBSSXg2NCAiXG4iLCBfX2Z1bmNfXywgbmFtZSwgc3RhcnQsIHNlbGYtPmVuZCk7CiAKIAltZW1jcHkoc2VsZi0+bmFtZSwgbmFtZSwgbmFtZWxlbik7CiAKQEAgLTE2Nyw3ICsxNjgsNyBAQAogCiBzdGF0aWMgc2l6ZV90IHN5bWJvbF9fZnByaW50ZihzdHJ1Y3Qgc3ltYm9sICpzZWxmLCBGSUxFICpmcCkKIHsKLQlyZXR1cm4gZnByaW50ZihmcCwgIiAlbGx4LSVsbHggJWMgJXNcbiIsCisJcmV0dXJuIGZwcmludGYoZnAsICIgJSIgUFJJeDY0ICItJSIgUFJJeDY0ICIgJWMgJXNcbiIsCiAJCSAgICAgICBzZWxmLT5zdGFydCwgc2VsZi0+ZW5kLAogCQkgICAgICAgc2VsZi0+YmluZGluZyA9PSBTVEJfR0xPQkFMID8gJ2cnIDoKIAkJICAgICAgIHNlbGYtPmJpbmRpbmcgPT0gU1RCX0xPQ0FMICA/ICdsJyA6ICd3JywKQEAgLTExNjEsNiArMTE2MiwxMyBAQAogCiAJCXNlY3Rpb25fbmFtZSA9IGVsZl9zZWNfX25hbWUoJnNoZHIsIHNlY3N0cnMpOwogCisJCS8qIE9uIEFSTSwgc3ltYm9scyBmb3IgdGh1bWIgZnVuY3Rpb25zIGhhdmUgMSBhZGRlZCB0bworCQkgKiB0aGUgc3ltYm9sIGFkZHJlc3MgYXMgYSBmbGFnIC0gcmVtb3ZlIGl0ICovCisJCWlmICgoZWhkci5lX21hY2hpbmUgPT0gRU1fQVJNKSAmJgorCQkgICAgKG1hcC0+dHlwZSA9PSBNQVBfX0ZVTkNUSU9OKSAmJgorCQkgICAgKHN5bS5zdF92YWx1ZSAmIDEpKQorCQkJLS1zeW0uc3RfdmFsdWU7CisKIAkJaWYgKHNlbGYtPmtlcm5lbCAhPSBEU09fVFlQRV9VU0VSIHx8IGttb2R1bGUpIHsKIAkJCWNoYXIgZHNvX25hbWVbUEFUSF9NQVhdOwogCkBAIC0xMjA4LDggKzEyMTYsOCBAQAogCQl9CiAKIAkJaWYgKGN1cnJfZHNvLT5hZGp1c3Rfc3ltYm9scykgewotCQkJcHJfZGVidWc0KCIlczogYWRqdXN0aW5nIHN5bWJvbDogc3RfdmFsdWU6ICUjTHggIgotCQkJCSAgInNoX2FkZHI6ICUjTHggc2hfb2Zmc2V0OiAlI0x4XG4iLCBfX2Z1bmNfXywKKwkJCXByX2RlYnVnNCgiJXM6IGFkanVzdGluZyBzeW1ib2w6IHN0X3ZhbHVlOiAlIyIgUFJJeDY0ICIgIgorCQkJCSAgInNoX2FkZHI6ICUjIiBQUkl4NjQgIiBzaF9vZmZzZXQ6ICUjIiBQUkl4NjQgIlxuIiwgX19mdW5jX18sCiAJCQkJICAodTY0KXN5bS5zdF92YWx1ZSwgKHU2NClzaGRyLnNoX2FkZHIsCiAJCQkJICAodTY0KXNoZHIuc2hfb2Zmc2V0KTsKIAkJCXN5bS5zdF92YWx1ZSAtPSBzaGRyLnNoX2FkZHIgLSBzaGRyLnNoX29mZnNldDsKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC90eXBlcy5oIGIvdG9vbHMvcGVyZi91dGlsL3R5cGVzLmgKaW5kZXggN2Q2YjgzMy4uNWYzNjg5YSAxMDA2NDQKLS0tIGEvdG9vbHMvcGVyZi91dGlsL3R5cGVzLmgKKysrIGIvdG9vbHMvcGVyZi91dGlsL3R5cGVzLmgKQEAgLTEsMTIgKzEsMTQgQEAKICNpZm5kZWYgX19QRVJGX1RZUEVTX0gKICNkZWZpbmUgX19QRVJGX1RZUEVTX0gKIAorI2luY2x1ZGUgPHN0ZGludC5oPgorCiAvKgotICogV2UgZGVmaW5lIHU2NCBhcyB1bnNpZ25lZCBsb25nIGxvbmcgZm9yIGV2ZXJ5IGFyY2hpdGVjdHVyZQotICogc28gdGhhdCB3ZSBjYW4gcHJpbnQgaXQgd2l0aCAlTHggd2l0aG91dCBnZXR0aW5nIHdhcm5pbmdzLgorICogV2UgZGVmaW5lIHU2NCBhcyB1aW50NjRfdCBmb3IgZXZlcnkgYXJjaGl0ZWN0dXJlCisgKiBzbyB0aGF0IHdlIGNhbiBwcmludCBpdCB3aXRoICIlIlBSSXg2NCB3aXRob3V0IGdldHRpbmcgd2FybmluZ3MuCiAgKi8KLXR5cGVkZWYgdW5zaWduZWQgbG9uZyBsb25nIHU2NDsKLXR5cGVkZWYgc2lnbmVkIGxvbmcgbG9uZyAgIHM2NDsKK3R5cGVkZWYgdWludDY0X3QJICAgdTY0OwordHlwZWRlZiBpbnQ2NF90CQkgICBzNjQ7CiB0eXBlZGVmIHVuc2lnbmVkIGludAkgICB1MzI7CiB0eXBlZGVmIHNpZ25lZCBpbnQJICAgczMyOwogdHlwZWRlZiB1bnNpZ25lZCBzaG9ydAkgICB1MTY7CmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvdWkvYnJvd3NlcnMvaGlzdHMuYyBiL3Rvb2xzL3BlcmYvdXRpbC91aS9icm93c2Vycy9oaXN0cy5jCmluZGV4IGViZGE4YzMuLjYwYzQ2M2MgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3BlcmYvdXRpbC91aS9icm93c2Vycy9oaXN0cy5jCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC91aS9icm93c2Vycy9oaXN0cy5jCkBAIC0zNTAsNyArMzUwLDcgQEAKIAlpZiAoc2VsZi0+bXMuc3ltKQogCQlyZXR1cm4gc2VsZi0+bXMuc3ltLT5uYW1lOwogCi0Jc25wcmludGYoYmYsIGJmc2l6ZSwgIiUjTHgiLCBzZWxmLT5pcCk7CisJc25wcmludGYoYmYsIGJmc2l6ZSwgIiUjIiBQUkl4NjQsIHNlbGYtPmlwKTsKIAlyZXR1cm4gYmY7CiB9CiAKZGlmZiAtLWdpdCBhL3Rvb2xzL3BlcmYvdXRpbC91aS9icm93c2Vycy9tYXAuYyBiL3Rvb2xzL3BlcmYvdXRpbC91aS9icm93c2Vycy9tYXAuYwppbmRleCBlMzU0MzdkLi5lNTE1ODM2IDEwMDY0NAotLS0gYS90b29scy9wZXJmL3V0aWwvdWkvYnJvd3NlcnMvbWFwLmMKKysrIGIvdG9vbHMvcGVyZi91dGlsL3VpL2Jyb3dzZXJzL21hcC5jCkBAIC0xLDUgKzEsNiBAQAogI2luY2x1ZGUgIi4uL2xpYnNsYW5nLmgiCiAjaW5jbHVkZSA8ZWxmLmg+CisjaW5jbHVkZSA8aW50dHlwZXMuaD4KICNpbmNsdWRlIDxzeXMvdHR5ZGVmYXVsdHMuaD4KICNpbmNsdWRlIDxjdHlwZS5oPgogI2luY2x1ZGUgPHN0cmluZy5oPgpAQCAtNTcsNyArNTgsNyBAQAogCWludCB3aWR0aDsKIAogCXVpX2Jyb3dzZXJfX3NldF9wZXJjZW50X2NvbG9yKHNlbGYsIDAsIGN1cnJlbnRfZW50cnkpOwotCXNsc21nX3ByaW50ZigiJSpsbHggJSpsbHggJWMgIiwKKwlzbHNtZ19wcmludGYoIiUqIiBQUkl4NjQgIiAlKiIgUFJJeDY0ICIgJWMgIiwKIAkJICAgICBtYi0+YWRkcmxlbiwgc3ltLT5zdGFydCwgbWItPmFkZHJsZW4sIHN5bS0+ZW5kLAogCQkgICAgIHN5bS0+YmluZGluZyA9PSBTVEJfR0xPQkFMID8gJ2cnIDoKIAkJICAgICBzeW0tPmJpbmRpbmcgPT0gU1RCX0xPQ0FMICA/ICdsJyA6ICd3Jyk7CkBAIC0xNTAsNiArMTUxLDYgQEAKIAkJKyttYi5iLm5yX2VudHJpZXM7CiAJfQogCi0JbWIuYWRkcmxlbiA9IHNucHJpbnRmKHRtcCwgc2l6ZW9mKHRtcCksICIlbGx4IiwgbWF4YWRkcik7CisJbWIuYWRkcmxlbiA9IHNucHJpbnRmKHRtcCwgc2l6ZW9mKHRtcCksICIlIiBQUkl4NjQsIG1heGFkZHIpOwogCXJldHVybiBtYXBfYnJvd3Nlcl9fcnVuKCZtYik7CiB9CmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvdmFsdWVzLmMgYi90b29scy9wZXJmL3V0aWwvdmFsdWVzLmMKaW5kZXggY2ZhNTVkNi4uYmRkMzM0NyAxMDA2NDQKLS0tIGEvdG9vbHMvcGVyZi91dGlsL3ZhbHVlcy5jCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC92YWx1ZXMuYwpAQCAtMTUwLDcgKzE1MCw3IEBACiAJCWlmICh3aWR0aCA+IHRpZHdpZHRoKQogCQkJdGlkd2lkdGggPSB3aWR0aDsKIAkJZm9yIChqID0gMDsgaiA8IHZhbHVlcy0+Y291bnRlcnM7IGorKykgewotCQkJd2lkdGggPSBzbnByaW50ZihOVUxMLCAwLCAiJUx1IiwgdmFsdWVzLT52YWx1ZVtpXVtqXSk7CisJCQl3aWR0aCA9IHNucHJpbnRmKE5VTEwsIDAsICIlIiBQUkl1NjQsIHZhbHVlcy0+dmFsdWVbaV1bal0pOwogCQkJaWYgKHdpZHRoID4gY291bnRlcndpZHRoW2pdKQogCQkJCWNvdW50ZXJ3aWR0aFtqXSA9IHdpZHRoOwogCQl9CkBAIC0xNjUsNyArMTY1LDcgQEAKIAkJZnByaW50ZihmcCwgIiAgJSpkICAlKmQiLCBwaWR3aWR0aCwgdmFsdWVzLT5waWRbaV0sCiAJCQl0aWR3aWR0aCwgdmFsdWVzLT50aWRbaV0pOwogCQlmb3IgKGogPSAwOyBqIDwgdmFsdWVzLT5jb3VudGVyczsgaisrKQotCQkJZnByaW50ZihmcCwgIiAgJSpMdSIsCisJCQlmcHJpbnRmKGZwLCAiICAlKiIgUFJJdTY0LAogCQkJCWNvdW50ZXJ3aWR0aFtqXSwgdmFsdWVzLT52YWx1ZVtpXVtqXSk7CiAJCWZwcmludGYoZnAsICJcbiIpOwogCX0KQEAgLTE5NiwxMyArMTk2LDEzIEBACiAJCXdpZHRoID0gc3RybGVuKHZhbHVlcy0+Y291bnRlcm5hbWVbal0pOwogCQlpZiAod2lkdGggPiBuYW1ld2lkdGgpCiAJCQluYW1ld2lkdGggPSB3aWR0aDsKLQkJd2lkdGggPSBzbnByaW50ZihOVUxMLCAwLCAiJWxseCIsIHZhbHVlcy0+Y291bnRlcnJhd2lkW2pdKTsKKwkJd2lkdGggPSBzbnByaW50ZihOVUxMLCAwLCAiJSIgUFJJeDY0LCB2YWx1ZXMtPmNvdW50ZXJyYXdpZFtqXSk7CiAJCWlmICh3aWR0aCA+IHJhd3dpZHRoKQogCQkJcmF3d2lkdGggPSB3aWR0aDsKIAl9CiAJZm9yIChpID0gMDsgaSA8IHZhbHVlcy0+dGhyZWFkczsgaSsrKSB7CiAJCWZvciAoaiA9IDA7IGogPCB2YWx1ZXMtPmNvdW50ZXJzOyBqKyspIHsKLQkJCXdpZHRoID0gc25wcmludGYoTlVMTCwgMCwgIiVMdSIsIHZhbHVlcy0+dmFsdWVbaV1bal0pOworCQkJd2lkdGggPSBzbnByaW50ZihOVUxMLCAwLCAiJSIgUFJJdTY0LCB2YWx1ZXMtPnZhbHVlW2ldW2pdKTsKIAkJCWlmICh3aWR0aCA+IGNvdW50d2lkdGgpCiAJCQkJY291bnR3aWR0aCA9IHdpZHRoOwogCQl9CkBAIC0yMTQsNyArMjE0LDcgQEAKIAkJY291bnR3aWR0aCwgIkNvdW50Iik7CiAJZm9yIChpID0gMDsgaSA8IHZhbHVlcy0+dGhyZWFkczsgaSsrKQogCQlmb3IgKGogPSAwOyBqIDwgdmFsdWVzLT5jb3VudGVyczsgaisrKQotCQkJZnByaW50ZihmcCwgIiAgJSpkICAlKmQgICUqcyAgJSpsbHggICUqTHVcbiIsCisJCQlmcHJpbnRmKGZwLCAiICAlKmQgICUqZCAgJSpzICAlKiIgUFJJeDY0ICIgICUqIiBQUkl1NjQsCiAJCQkJcGlkd2lkdGgsIHZhbHVlcy0+cGlkW2ldLAogCQkJCXRpZHdpZHRoLCB2YWx1ZXMtPnRpZFtpXSwKIAkJCQluYW1ld2lkdGgsIHZhbHVlcy0+Y291bnRlcm5hbWVbal0sCmRpZmYgLS1naXQgYS91c3IvS2NvbmZpZyBiL3Vzci9LY29uZmlnCmluZGV4IDQ3ODBkZWEuLjY1Yjg0NWJkIDEwMDY0NAotLS0gYS91c3IvS2NvbmZpZworKysgYi91c3IvS2NvbmZpZwpAQCAtNDYsNyArNDYsNyBAQAogCSAgSWYgeW91IGFyZSBub3Qgc3VyZSwgbGVhdmUgaXQgc2V0IHRvICIwIi4KIAogY29uZmlnIFJEX0daSVAKLQlib29sICJTdXBwb3J0IGluaXRpYWwgcmFtZGlza3MgY29tcHJlc3NlZCB1c2luZyBnemlwIiBpZiBFTUJFRERFRAorCWJvb2wgIlN1cHBvcnQgaW5pdGlhbCByYW1kaXNrcyBjb21wcmVzc2VkIHVzaW5nIGd6aXAiIGlmIEVYUEVSVAogCWRlZmF1bHQgeQogCWRlcGVuZHMgb24gQkxLX0RFVl9JTklUUkQKIAlzZWxlY3QgREVDT01QUkVTU19HWklQCkBAIC01NSw4ICs1NSw4IEBACiAJICBJZiB1bnN1cmUsIHNheSBZLgogCiBjb25maWcgUkRfQlpJUDIKLQlib29sICJTdXBwb3J0IGluaXRpYWwgcmFtZGlza3MgY29tcHJlc3NlZCB1c2luZyBiemlwMiIgaWYgRU1CRURERUQKLQlkZWZhdWx0ICFFTUJFRERFRAorCWJvb2wgIlN1cHBvcnQgaW5pdGlhbCByYW1kaXNrcyBjb21wcmVzc2VkIHVzaW5nIGJ6aXAyIiBpZiBFWFBFUlQKKwlkZWZhdWx0ICFFWFBFUlQKIAlkZXBlbmRzIG9uIEJMS19ERVZfSU5JVFJECiAJc2VsZWN0IERFQ09NUFJFU1NfQlpJUDIKIAloZWxwCkBAIC02NCw4ICs2NCw4IEBACiAJICBJZiB1bnN1cmUsIHNheSBOLgogCiBjb25maWcgUkRfTFpNQQotCWJvb2wgIlN1cHBvcnQgaW5pdGlhbCByYW1kaXNrcyBjb21wcmVzc2VkIHVzaW5nIExaTUEiIGlmIEVNQkVEREVECi0JZGVmYXVsdCAhRU1CRURERUQKKwlib29sICJTdXBwb3J0IGluaXRpYWwgcmFtZGlza3MgY29tcHJlc3NlZCB1c2luZyBMWk1BIiBpZiBFWFBFUlQKKwlkZWZhdWx0ICFFWFBFUlQKIAlkZXBlbmRzIG9uIEJMS19ERVZfSU5JVFJECiAJc2VsZWN0IERFQ09NUFJFU1NfTFpNQQogCWhlbHAKQEAgLTczLDggKzczLDggQEAKIAkgIElmIHVuc3VyZSwgc2F5IE4uCiAKIGNvbmZpZyBSRF9YWgotCWJvb2wgIlN1cHBvcnQgaW5pdGlhbCByYW1kaXNrcyBjb21wcmVzc2VkIHVzaW5nIFhaIiBpZiBFTUJFRERFRAotCWRlZmF1bHQgIUVNQkVEREVECisJYm9vbCAiU3VwcG9ydCBpbml0aWFsIHJhbWRpc2tzIGNvbXByZXNzZWQgdXNpbmcgWFoiIGlmIEVYUEVSVAorCWRlZmF1bHQgIUVYUEVSVAogCWRlcGVuZHMgb24gQkxLX0RFVl9JTklUUkQKIAlzZWxlY3QgREVDT01QUkVTU19YWgogCWhlbHAKQEAgLTgyLDggKzgyLDggQEAKIAkgIElmIHVuc3VyZSwgc2F5IE4uCiAKIGNvbmZpZyBSRF9MWk8KLQlib29sICJTdXBwb3J0IGluaXRpYWwgcmFtZGlza3MgY29tcHJlc3NlZCB1c2luZyBMWk8iIGlmIEVNQkVEREVECi0JZGVmYXVsdCAhRU1CRURERUQKKwlib29sICJTdXBwb3J0IGluaXRpYWwgcmFtZGlza3MgY29tcHJlc3NlZCB1c2luZyBMWk8iIGlmIEVYUEVSVAorCWRlZmF1bHQgIUVYUEVSVAogCWRlcGVuZHMgb24gQkxLX0RFVl9JTklUUkQKIAlzZWxlY3QgREVDT01QUkVTU19MWk8KIAloZWxwCmRpZmYgLS1naXQgYS92aXJ0L2t2bS9rdm1fbWFpbi5jIGIvdmlydC9rdm0va3ZtX21haW4uYwppbmRleCA3ZjY4NjI1Li5mMjlhYmViIDEwMDY0NAotLS0gYS92aXJ0L2t2bS9rdm1fbWFpbi5jCisrKyBiL3ZpcnQva3ZtL2t2bV9tYWluLmMKQEAgLTEwNCw4ICsxMDQsMjYgQEAKIGlubGluZSBpbnQga3ZtX2lzX21taW9fcGZuKHBmbl90IHBmbikKIHsKIAlpZiAocGZuX3ZhbGlkKHBmbikpIHsKLQkJc3RydWN0IHBhZ2UgKnBhZ2UgPSBjb21wb3VuZF9oZWFkKHBmbl90b19wYWdlKHBmbikpOwotCQlyZXR1cm4gUGFnZVJlc2VydmVkKHBhZ2UpOworCQlpbnQgcmVzZXJ2ZWQ7CisJCXN0cnVjdCBwYWdlICp0YWlsID0gcGZuX3RvX3BhZ2UocGZuKTsKKwkJc3RydWN0IHBhZ2UgKmhlYWQgPSBjb21wb3VuZF90cmFuc19oZWFkKHRhaWwpOworCQlyZXNlcnZlZCA9IFBhZ2VSZXNlcnZlZChoZWFkKTsKKwkJaWYgKGhlYWQgIT0gdGFpbCkgeworCQkJLyoKKwkJCSAqICJoZWFkIiBpcyBub3QgYSBkYW5nbGluZyBwb2ludGVyCisJCQkgKiAoY29tcG91bmRfdHJhbnNfaGVhZCB0YWtlcyBjYXJlIG9mIHRoYXQpCisJCQkgKiBidXQgdGhlIGh1Z2VwYWdlIG1heSBoYXZlIGJlZW4gc3BsaXR0ZWQKKwkJCSAqIGZyb20gdW5kZXIgdXMgKGFuZCB3ZSBtYXkgbm90IGhvbGQgYQorCQkJICogcmVmZXJlbmNlIGNvdW50IG9uIHRoZSBoZWFkIHBhZ2Ugc28gaXQgY2FuCisJCQkgKiBiZSByZXVzZWQgYmVmb3JlIHdlIHJ1biBQYWdlUmVmZXJlbmNlZCksIHNvCisJCQkgKiB3ZSd2ZSB0byBjaGVjayBQYWdlVGFpbCBiZWZvcmUgcmV0dXJuaW5nCisJCQkgKiB3aGF0IHdlIGp1c3QgcmVhZC4KKwkJCSAqLworCQkJc21wX3JtYigpOworCQkJaWYgKFBhZ2VUYWlsKHRhaWwpKQorCQkJCXJldHVybiByZXNlcnZlZDsKKwkJfQorCQlyZXR1cm4gUGFnZVJlc2VydmVkKHRhaWwpOwogCX0KIAogCXJldHVybiB0cnVlOwpAQCAtMzUyLDYgKzM3MCwyMiBAQAogCXJldHVybiB5b3VuZzsKIH0KIAorc3RhdGljIGludCBrdm1fbW11X25vdGlmaWVyX3Rlc3RfeW91bmcoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sCisJCQkJICAgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAorCQkJCSAgICAgICB1bnNpZ25lZCBsb25nIGFkZHJlc3MpCit7CisJc3RydWN0IGt2bSAqa3ZtID0gbW11X25vdGlmaWVyX3RvX2t2bShtbik7CisJaW50IHlvdW5nLCBpZHg7CisKKwlpZHggPSBzcmN1X3JlYWRfbG9jaygma3ZtLT5zcmN1KTsKKwlzcGluX2xvY2soJmt2bS0+bW11X2xvY2spOworCXlvdW5nID0ga3ZtX3Rlc3RfYWdlX2h2YShrdm0sIGFkZHJlc3MpOworCXNwaW5fdW5sb2NrKCZrdm0tPm1tdV9sb2NrKTsKKwlzcmN1X3JlYWRfdW5sb2NrKCZrdm0tPnNyY3UsIGlkeCk7CisKKwlyZXR1cm4geW91bmc7Cit9CisKIHN0YXRpYyB2b2lkIGt2bV9tbXVfbm90aWZpZXJfcmVsZWFzZShzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKIAkJCQkgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQogewpAQCAtMzY4LDYgKzQwMiw3IEBACiAJLmludmFsaWRhdGVfcmFuZ2Vfc3RhcnQJPSBrdm1fbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQsCiAJLmludmFsaWRhdGVfcmFuZ2VfZW5kCT0ga3ZtX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX2VuZCwKIAkuY2xlYXJfZmx1c2hfeW91bmcJPSBrdm1fbW11X25vdGlmaWVyX2NsZWFyX2ZsdXNoX3lvdW5nLAorCS50ZXN0X3lvdW5nCQk9IGt2bV9tbXVfbm90aWZpZXJfdGVzdF95b3VuZywKIAkuY2hhbmdlX3B0ZQkJPSBrdm1fbW11X25vdGlmaWVyX2NoYW5nZV9wdGUsCiAJLnJlbGVhc2UJCT0ga3ZtX21tdV9ub3RpZmllcl9yZWxlYXNlLAogfTsK