LyoKICogIHdpbmJvbmQtY2lyLmMgLSBEcml2ZXIgZm9yIHRoZSBDb25zdW1lciBJUiBmdW5jdGlvbmFsaXR5IG9mIFdpbmJvbmQKICogICAgICAgICAgICAgICAgICBTdXBlckkvTyBjaGlwcy4KICoKICogIEN1cnJlbnRseSBzdXBwb3J0cyB0aGUgV2luYm9uZCBXUENEMzc2aSBjaGlwIChQTlAgaWQgV0VDMTAyMiksIGJ1dAogKiAgY291bGQgcHJvYmFibHkgc3VwcG9ydCBvdGhlcnMgKFdpbmJvbmQgV0VDMTAyWCwgTmF0U2VtaSwgZXRjKQogKiAgd2l0aCBtaW5vciBtb2RpZmljYXRpb25zLgogKgogKiAgT3JpZ2luYWwgQXV0aG9yOiBEYXZpZCBI5HJkZW1hbiA8ZGF2aWRAaGFyZGVtYW4ubnU+CiAqICAgICBDb3B5cmlnaHQgKEMpIDIwMDkgRGF2aWQgSORyZGVtYW4gPGRhdmlkQGhhcmRlbWFuLm51PgogKgogKiAgRGVkaWNhdGVkIHRvIE1hdGlsZGEsIG15IG5ld2Jvcm4gZGF1Z2h0ZXIsIHdpdGhvdXQgd2hvc2UgbG92aW5nIGF0dGVudGlvbgogKiAgdGhpcyBkcml2ZXIgd291bGQgaGF2ZSBiZWVuIGZpbmlzaGVkIGluIGhhbGYgdGhlIHRpbWUgYW5kIHdpdGggYSBmcmFjdGlvbgogKiAgb2YgdGhlIGJ1Z3MuCiAqCiAqICBXcml0dGVuIHVzaW5nOgogKiAgICBvIFdpbmJvbmQgV1BDRDM3NkkgZGF0YXNoZWV0IGhlbHBmdWxseSBwcm92aWRlZCBieSBKZXNzZSBCYXJuZXMgYXQgSW50ZWwKICogICAgbyBOYXRTZW1pIFBDODczMzgvUEM5NzMzOCBkYXRhc2hlZXQgKGZvciB0aGUgc2VyaWFsIHBvcnQgc3R1ZmYpCiAqICAgIG8gRFNEVCBkdW1wcwogKgogKiAgU3VwcG9ydGVkIGZlYXR1cmVzOgogKiAgICBvIFJDNgogKiAgICBvIFdha2UtT24tQ0lSIGZ1bmN0aW9uYWxpdHkKICoKICogIFRvIGRvOgogKiAgICBvIFRlc3QgTkVDIGFuZCBSQzUKICoKICogIExlZnQgYXMgYW4gZXhlcmNpc2UgZm9yIHRoZSByZWFkZXI6CiAqICAgIG8gTGVhcm5pbmcgKEkgaGF2ZSBuZWl0aGVyIHRoZSBoYXJkd2FyZSwgbm9yIHRoZSBuZWVkKQogKiAgICBvIElSIFRyYW5zbWl0IChpYmlkKQogKgogKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICogIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CiAqICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgogKiAgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KICoKICogIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAogKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKICogIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCiAqCiAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQogKiAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogIEZvdW5kYXRpb24sIEluYy4sIDY3NSBNYXNzIEF2ZSwgQ2FtYnJpZGdlLCBNQSAwMjEzOSwgVVNBLgogKi8KCiNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KI2luY2x1ZGUgPGxpbnV4L3BucC5oPgojaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiNpbmNsdWRlIDxsaW51eC90aW1lci5oPgojaW5jbHVkZSA8bGludXgvaW5wdXQuaD4KI2luY2x1ZGUgPGxpbnV4L2xlZHMuaD4KI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiNpbmNsdWRlIDxsaW51eC9wY2lfaWRzLmg+CiNpbmNsdWRlIDxsaW51eC9pby5oPgojaW5jbHVkZSA8bGludXgvYml0cmV2Lmg+CiNpbmNsdWRlIDxsaW51eC9iaXRvcHMuaD4KI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KCiNkZWZpbmUgRFJWTkFNRSAid2luYm9uZC1jaXIiCgovKiBDRUlSIFdha2UtVXAgUmVnaXN0ZXJzLCByZWxhdGl2ZSB0byBkYXRhLT53YmFzZSAgICAgICAgICAgICAgICAgICAgICAqLwojZGVmaW5lIFdCQ0lSX1JFR19XQ0VJUl9DVEwJMHgwMyAvKiBDRUlSIFJlY2VpdmVyIENvbnRyb2wJCSovCiNkZWZpbmUgV0JDSVJfUkVHX1dDRUlSX1NUUwkweDA0IC8qIENFSVIgUmVjZWl2ZXIgU3RhdHVzCQkqLwojZGVmaW5lIFdCQ0lSX1JFR19XQ0VJUl9FVl9FTgkweDA1IC8qIENFSVIgUmVjZWl2ZXIgRXZlbnQgRW5hYmxlCSovCiNkZWZpbmUgV0JDSVJfUkVHX1dDRUlSX0NOVEwJMHgwNiAvKiBDRUlSIFJlY2VpdmVyIENvdW50ZXIgTG93CSovCiNkZWZpbmUgV0JDSVJfUkVHX1dDRUlSX0NOVEgJMHgwNyAvKiBDRUlSIFJlY2VpdmVyIENvdW50ZXIgSGlnaAkqLwojZGVmaW5lIFdCQ0lSX1JFR19XQ0VJUl9JTkRFWAkweDA4IC8qIENFSVIgUmVjZWl2ZXIgSW5kZXgJCSovCiNkZWZpbmUgV0JDSVJfUkVHX1dDRUlSX0RBVEEJMHgwOSAvKiBDRUlSIFJlY2VpdmVyIERhdGEJCSovCiNkZWZpbmUgV0JDSVJfUkVHX1dDRUlSX0NTTAkweDBBIC8qIENFSVIgUmUuIENvbXBhcmUgU3RybGVuCQkqLwojZGVmaW5lIFdCQ0lSX1JFR19XQ0VJUl9DRkcxCTB4MEIgLyogQ0VJUiBSZS4gQ29uZmlndXJhdGlvbiAxCSovCiNkZWZpbmUgV0JDSVJfUkVHX1dDRUlSX0NGRzIJMHgwQyAvKiBDRUlSIFJlLiBDb25maWd1cmF0aW9uIDIJKi8KCi8qIENFSVIgRW5oYW5jZWQgRnVuY3Rpb25hbGl0eSBSZWdpc3RlcnMsIHJlbGF0aXZlIHRvIGRhdGEtPmViYXNlICAgICAgICovCiNkZWZpbmUgV0JDSVJfUkVHX0VDRUlSX0NUUwkweDAwIC8qIEVuaGFuY2VkIElSIENvbnRyb2wgU3RhdHVzCSovCiNkZWZpbmUgV0JDSVJfUkVHX0VDRUlSX0NDVEwJMHgwMSAvKiBJbmZyYXJlZCBDb3VudGVyIENvbnRyb2wJKi8KI2RlZmluZSBXQkNJUl9SRUdfRUNFSVJfQ05UX0xPCTB4MDIgLyogSW5mcmFyZWQgQ291bnRlciBMU0IJCSovCiNkZWZpbmUgV0JDSVJfUkVHX0VDRUlSX0NOVF9ISQkweDAzIC8qIEluZnJhcmVkIENvdW50ZXIgTVNCCQkqLwojZGVmaW5lIFdCQ0lSX1JFR19FQ0VJUl9JUkVNCTB4MDQgLyogSW5mcmFyZWQgRW1pdHRlciBTdGF0dXMJCSovCgovKiBTUDMgQmFua2VkIFJlZ2lzdGVycywgcmVsYXRpdmUgdG8gZGF0YS0+c2Jhc2UgICAgICAgICAgICAgICAgICAgICAgICAqLwojZGVmaW5lIFdCQ0lSX1JFR19TUDNfQlNSCTB4MDMgLyogQmFuayBTZWxlY3QsIGFsbCBiYW5rcwkJKi8KCQkJCSAgICAgIC8qIEJhbmsgMAkJCQkqLwojZGVmaW5lIFdCQ0lSX1JFR19TUDNfUlhEQVRBCTB4MDAgLyogRklGTyBSWCBkYXRhIChyKQkJKi8KI2RlZmluZSBXQkNJUl9SRUdfU1AzX1RYREFUQQkweDAwIC8qIEZJRk8gVFggZGF0YSAodykJCSovCiNkZWZpbmUgV0JDSVJfUkVHX1NQM19JRVIJMHgwMSAvKiBJbnRlcnJ1cHQgRW5hYmxlCQkqLwojZGVmaW5lIFdCQ0lSX1JFR19TUDNfRUlSCTB4MDIgLyogRXZlbnQgSWRlbnRpZmljYXRpb24gKHIpCSovCiNkZWZpbmUgV0JDSVJfUkVHX1NQM19GQ1IJMHgwMiAvKiBGSUZPIENvbnRyb2wgKHcpCQkqLwojZGVmaW5lIFdCQ0lSX1JFR19TUDNfTUNSCTB4MDQgLyogTW9kZSBDb250cm9sCQkJKi8KI2RlZmluZSBXQkNJUl9SRUdfU1AzX0xTUgkweDA1IC8qIExpbmsgU3RhdHVzCQkJKi8KI2RlZmluZSBXQkNJUl9SRUdfU1AzX01TUgkweDA2IC8qIE1vZGVtIFN0YXR1cwkJCSovCiNkZWZpbmUgV0JDSVJfUkVHX1NQM19BU0NSCTB4MDcgLyogQXV4IFN0YXR1cyBhbmQgQ29udHJvbAkJKi8KCQkJCSAgICAgIC8qIEJhbmsgMgkJCQkqLwojZGVmaW5lIFdCQ0lSX1JFR19TUDNfQkdETAkweDAwIC8qIEJhdWQgRGl2aXNvciBMU0IJCSovCiNkZWZpbmUgV0JDSVJfUkVHX1NQM19CR0RICTB4MDEgLyogQmF1ZCBEaXZpc29yIE1TQgkJKi8KI2RlZmluZSBXQkNJUl9SRUdfU1AzX0VYQ1IxCTB4MDIgLyogRXh0ZW5kZWQgQ29udHJvbCAxCQkqLwojZGVmaW5lIFdCQ0lSX1JFR19TUDNfRVhDUjIJMHgwNCAvKiBFeHRlbmRlZCBDb250cm9sIDIJCSovCiNkZWZpbmUgV0JDSVJfUkVHX1NQM19UWEZMVgkweDA2IC8qIFRYIEZJRk8gTGV2ZWwJCQkqLwojZGVmaW5lIFdCQ0lSX1JFR19TUDNfUlhGTFYJMHgwNyAvKiBSWCBGSUZPIExldmVsCQkJKi8KCQkJCSAgICAgIC8qIEJhbmsgMwkJCQkqLwojZGVmaW5lIFdCQ0lSX1JFR19TUDNfTVJJRAkweDAwIC8qIE1vZHVsZSBJZGVudGlmaWNhdGlvbgkJKi8KI2RlZmluZSBXQkNJUl9SRUdfU1AzX1NIX0xDUgkweDAxIC8qIExDUiBTaGFkb3cJCQkqLwojZGVmaW5lIFdCQ0lSX1JFR19TUDNfU0hfRkNSCTB4MDIgLyogRkNSIFNoYWRvdwkJCSovCgkJCQkgICAgICAvKiBCYW5rIDQJCQkJKi8KI2RlZmluZSBXQkNJUl9SRUdfU1AzX0lSQ1IxCTB4MDIgLyogSW5mcmFyZWQgQ29udHJvbCAxCQkqLwoJCQkJICAgICAgLyogQmFuayA1CQkJCSovCiNkZWZpbmUgV0JDSVJfUkVHX1NQM19JUkNSMgkweDA0IC8qIEluZnJhcmVkIENvbnRyb2wgMgkJKi8KCQkJCSAgICAgIC8qIEJhbmsgNgkJCQkqLwojZGVmaW5lIFdCQ0lSX1JFR19TUDNfSVJDUjMJMHgwMCAvKiBJbmZyYXJlZCBDb250cm9sIDMJCSovCiNkZWZpbmUgV0JDSVJfUkVHX1NQM19TSVJfUFcJMHgwMiAvKiBTSVIgUHVsc2UgV2lkdGgJCSovCgkJCQkgICAgICAvKiBCYW5rIDcJCQkJKi8KI2RlZmluZSBXQkNJUl9SRUdfU1AzX0lSUlhEQwkweDAwIC8qIElSIFJYIERlbW9kIENvbnRyb2wJCSovCiNkZWZpbmUgV0JDSVJfUkVHX1NQM19JUlRYTUMJMHgwMSAvKiBJUiBUWCBNb2QgQ29udHJvbAkJKi8KI2RlZmluZSBXQkNJUl9SRUdfU1AzX1JDQ0ZHCTB4MDIgLyogQ0VJUiBDb25maWcJCQkqLwojZGVmaW5lIFdCQ0lSX1JFR19TUDNfSVJDRkcxCTB4MDQgLyogSW5mcmFyZWQgQ29uZmlnIDEJCSovCiNkZWZpbmUgV0JDSVJfUkVHX1NQM19JUkNGRzQJMHgwNyAvKiBJbmZyYXJlZCBDb25maWcgNAkJKi8KCi8qCiAqIE1hZ2ljIHZhbHVlcyBmb2xsb3cKICovCgovKiBObyBpbnRlcnJ1cHRzIGZvciBXQkNJUl9SRUdfU1AzX0lFUiBhbmQgV0JDSVJfUkVHX1NQM19FSVIgKi8KI2RlZmluZSBXQkNJUl9JUlFfTk9ORQkJMHgwMAovKiBSWCBkYXRhIGJpdCBmb3IgV0JDSVJfUkVHX1NQM19JRVIgYW5kIFdCQ0lSX1JFR19TUDNfRUlSICovCiNkZWZpbmUgV0JDSVJfSVJRX1JYCQkweDAxCi8qIE92ZXIvVW5kZXItZmxvdyBiaXQgZm9yIFdCQ0lSX1JFR19TUDNfSUVSIGFuZCBXQkNJUl9SRUdfU1AzX0VJUiAqLwojZGVmaW5lIFdCQ0lSX0lSUV9FUlIJCTB4MDQKLyogTGVkIGVuYWJsZS9kaXNhYmxlIGJpdCBmb3IgV0JDSVJfUkVHX0VDRUlSX0NUUyAqLwojZGVmaW5lIFdCQ0lSX0xFRF9FTkFCTEUJMHg4MAovKiBSWCBkYXRhIGF2YWlsYWJsZSBiaXQgZm9yIFdCQ0lSX1JFR19TUDNfTFNSICovCiNkZWZpbmUgV0JDSVJfUlhfQVZBSUwJCTB4MDEKLyogUlggZGlzYWJsZSBiaXQgZm9yIFdCQ0lSX1JFR19TUDNfQVNDUiAqLwojZGVmaW5lIFdCQ0lSX1JYX0RJU0FCTEUJMHgyMAovKiBFeHRlbmRlZCBtb2RlIGVuYWJsZSBiaXQgZm9yIFdCQ0lSX1JFR19TUDNfRVhDUjEgKi8KI2RlZmluZSBXQkNJUl9FWFRfRU5BQkxFCTB4MDEKLyogU2VsZWN0IGNvbXBhcmUgcmVnaXN0ZXIgaW4gV0JDSVJfUkVHX1dDRUlSX0lOREVYIChiaXRzIDUgJiA2KSAqLwojZGVmaW5lIFdCQ0lSX1JFR1NFTF9DT01QQVJFCTB4MTAKLyogU2VsZWN0IG1hc2sgcmVnaXN0ZXIgaW4gV0JDSVJfUkVHX1dDRUlSX0lOREVYIChiaXRzIDUgJiA2KSAqLwojZGVmaW5lIFdCQ0lSX1JFR1NFTF9NQVNLCTB4MjAKLyogU3RhcnRpbmcgYWRkcmVzcyBvZiBzZWxlY3RlZCByZWdpc3RlciBpbiBXQkNJUl9SRUdfV0NFSVJfSU5ERVggKi8KI2RlZmluZSBXQkNJUl9SRUdfQUREUjAJCTB4MDAKCi8qIFZhbGlkIGJhbmtzIGZvciB0aGUgU1AzIFVBUlQgKi8KZW51bSB3YmNpcl9iYW5rIHsKCVdCQ0lSX0JBTktfMCAgICAgICAgICA9IDB4MDAsCglXQkNJUl9CQU5LXzEgICAgICAgICAgPSAweDgwLAoJV0JDSVJfQkFOS18yICAgICAgICAgID0gMHhFMCwKCVdCQ0lSX0JBTktfMyAgICAgICAgICA9IDB4RTQsCglXQkNJUl9CQU5LXzQgICAgICAgICAgPSAweEU4LAoJV0JDSVJfQkFOS181ICAgICAgICAgID0gMHhFQywKCVdCQ0lSX0JBTktfNiAgICAgICAgICA9IDB4RjAsCglXQkNJUl9CQU5LXzcgICAgICAgICAgPSAweEY0LAp9OwoKLyogU3VwcG9ydGVkIElSIFByb3RvY29scyAqLwplbnVtIHdiY2lyX3Byb3RvY29sIHsKCUlSX1BST1RPQ09MX1JDNSAgICAgICAgICA9IDB4MCwKCUlSX1BST1RPQ09MX05FQyAgICAgICAgICA9IDB4MSwKCUlSX1BST1RPQ09MX1JDNiAgICAgICAgICA9IDB4MiwKfTsKCi8qIE1pc2MgKi8KI2RlZmluZSBXQkNJUl9OQU1FCSJXaW5ib25kIENJUiIKI2RlZmluZSBXQkNJUl9JRF9GQU1JTFkgICAgICAgICAgMHhGMSAvKiBGYW1pbHkgSUQgZm9yIHRoZSBXUENEMzc2SQkqLwojZGVmaW5lCVdCQ0lSX0lEX0NISVAgICAgICAgICAgICAweDA0IC8qIENoaXAgSUQgZm9yIHRoZSBXUENEMzc2SQkqLwojZGVmaW5lIElSX0tFWVBSRVNTX1RJTUVPVVQgICAgICAgMjUwIC8qIEZJWE1FOiBzaG91bGQgYmUgcGVyLXByb3RvY29sPyAqLwojZGVmaW5lIElOVkFMSURfU0NBTkNPREUgICAweDdGRkZGRkZGIC8qIEludmFsaWQgd2l0aCBhbGwgcHJvdG9zCSovCiNkZWZpbmUgV0FLRVVQX0lPTUVNX0xFTiAgICAgICAgIDB4MTAgLyogV2FrZS1VcCBJL08gUmVnIExlbgkJKi8KI2RlZmluZSBFSEZVTkNfSU9NRU1fTEVOICAgICAgICAgMHgxMCAvKiBFbmhhbmNlZCBGdW5jIEkvTyBSZWcgTGVuCSovCiNkZWZpbmUgU1BfSU9NRU1fTEVOICAgICAgICAgICAgIDB4MDggLyogU2VyaWFsIFBvcnQgMyAoSVIpIFJlZyBMZW4JKi8KI2RlZmluZSBXQkNJUl9NQVhfSURMRV9CWVRFUyAgICAgICAxMAoKc3RhdGljIERFRklORV9TUElOTE9DSyh3YmNpcl9sb2NrKTsKc3RhdGljIERFRklORV9SV0xPQ0soa2V5dGFibGVfbG9jayk7CgpzdHJ1Y3Qgd2JjaXJfa2V5IHsKCXUzMiBzY2FuY29kZTsKCXVuc2lnbmVkIGludCBrZXljb2RlOwp9OwoKc3RydWN0IHdiY2lyX2tleWVudHJ5IHsKCXN0cnVjdCB3YmNpcl9rZXkga2V5OwoJc3RydWN0IGxpc3RfaGVhZCBsaXN0Owp9OwoKc3RhdGljIHN0cnVjdCB3YmNpcl9rZXkgcmM2X2RlZl9rZXltYXBbXSA9IHsKCXsgMHg4MDBGMDQwMCwgS0VZX05VTUVSSUNfMAkJfSwKCXsgMHg4MDBGMDQwMSwgS0VZX05VTUVSSUNfMQkJfSwKCXsgMHg4MDBGMDQwMiwgS0VZX05VTUVSSUNfMgkJfSwKCXsgMHg4MDBGMDQwMywgS0VZX05VTUVSSUNfMwkJfSwKCXsgMHg4MDBGMDQwNCwgS0VZX05VTUVSSUNfNAkJfSwKCXsgMHg4MDBGMDQwNSwgS0VZX05VTUVSSUNfNQkJfSwKCXsgMHg4MDBGMDQwNiwgS0VZX05VTUVSSUNfNgkJfSwKCXsgMHg4MDBGMDQwNywgS0VZX05VTUVSSUNfNwkJfSwKCXsgMHg4MDBGMDQwOCwgS0VZX05VTUVSSUNfOAkJfSwKCXsgMHg4MDBGMDQwOSwgS0VZX05VTUVSSUNfOQkJfSwKCXsgMHg4MDBGMDQxRCwgS0VZX05VTUVSSUNfU1RBUgkJfSwKCXsgMHg4MDBGMDQxQywgS0VZX05VTUVSSUNfUE9VTkQJCX0sCgl7IDB4ODAwRjA0MTAsIEtFWV9WT0xVTUVVUAkJfSwKCXsgMHg4MDBGMDQxMSwgS0VZX1ZPTFVNRURPV04JCX0sCgl7IDB4ODAwRjA0MTIsIEtFWV9DSEFOTkVMVVAJCX0sCgl7IDB4ODAwRjA0MTMsIEtFWV9DSEFOTkVMRE9XTgkJfSwKCXsgMHg4MDBGMDQwRSwgS0VZX01VVEUJCQl9LAoJeyAweDgwMEYwNDBELCBLRVlfVkVORE9SCQl9LCAvKiBWaXN0YSBMb2dvIEtleSAqLwoJeyAweDgwMEYwNDFFLCBLRVlfVVAJCQl9LAoJeyAweDgwMEYwNDFGLCBLRVlfRE9XTgkJCX0sCgl7IDB4ODAwRjA0MjAsIEtFWV9MRUZUCQkJfSwKCXsgMHg4MDBGMDQyMSwgS0VZX1JJR0hUCQkJfSwKCXsgMHg4MDBGMDQyMiwgS0VZX09LCQkJfSwKCXsgMHg4MDBGMDQyMywgS0VZX0VTQwkJCX0sCgl7IDB4ODAwRjA0MEYsIEtFWV9JTkZPCQkJfSwKCXsgMHg4MDBGMDQwQSwgS0VZX0NMRUFSCQkJfSwKCXsgMHg4MDBGMDQwQiwgS0VZX0VOVEVSCQkJfSwKCXsgMHg4MDBGMDQ1QiwgS0VZX1JFRAkJCX0sCgl7IDB4ODAwRjA0NUMsIEtFWV9HUkVFTgkJCX0sCgl7IDB4ODAwRjA0NUQsIEtFWV9ZRUxMT1cJCX0sCgl7IDB4ODAwRjA0NUUsIEtFWV9CTFVFCQkJfSwKCXsgMHg4MDBGMDQ1QSwgS0VZX1RFWFQJCQl9LAoJeyAweDgwMEYwNDI3LCBLRVlfU1dJVENIVklERU9NT0RFCX0sCgl7IDB4ODAwRjA0MEMsIEtFWV9QT1dFUgkJCX0sCgl7IDB4ODAwRjA0NTAsIEtFWV9SQURJTwkJCX0sCgl7IDB4ODAwRjA0NDgsIEtFWV9QVlIJCQl9LAoJeyAweDgwMEYwNDQ3LCBLRVlfQVVESU8JCQl9LAoJeyAweDgwMEYwNDI2LCBLRVlfRVBHCQkJfSwKCXsgMHg4MDBGMDQ0OSwgS0VZX0NBTUVSQQkJfSwKCXsgMHg4MDBGMDQyNSwgS0VZX1RWCQkJfSwKCXsgMHg4MDBGMDQ0QSwgS0VZX1ZJREVPCQkJfSwKCXsgMHg4MDBGMDQyNCwgS0VZX0RWRAkJCX0sCgl7IDB4ODAwRjA0MTYsIEtFWV9QTEFZCQkJfSwKCXsgMHg4MDBGMDQxOCwgS0VZX1BBVVNFCQkJfSwKCXsgMHg4MDBGMDQxOSwgS0VZX1NUT1AJCQl9LAoJeyAweDgwMEYwNDE0LCBLRVlfRkFTVEZPUldBUkQJCX0sCgl7IDB4ODAwRjA0MUEsIEtFWV9ORVhUCQkJfSwKCXsgMHg4MDBGMDQxQiwgS0VZX1BSRVZJT1VTCQl9LAoJeyAweDgwMEYwNDE1LCBLRVlfUkVXSU5ECQl9LAoJeyAweDgwMEYwNDE3LCBLRVlfUkVDT1JECQl9LAp9OwoKLyogUmVnaXN0ZXJzIGFuZCBvdGhlciBzdGF0ZSBpcyBwcm90ZWN0ZWQgYnkgd2JjaXJfbG9jayAqLwpzdHJ1Y3Qgd2JjaXJfZGF0YSB7Cgl1bnNpZ25lZCBsb25nIHdiYXNlOyAgICAgICAgLyogV2FrZS1VcCBCYXNlYWRkcgkJKi8KCXVuc2lnbmVkIGxvbmcgZWJhc2U7ICAgICAgICAvKiBFbmhhbmNlZCBGdW5jLiBCYXNlYWRkcgkqLwoJdW5zaWduZWQgbG9uZyBzYmFzZTsgICAgICAgIC8qIFNlcmlhbCBQb3J0IEJhc2VhZGRyCSovCgl1bnNpZ25lZCBpbnQgIGlycTsgICAgICAgICAgLyogU2VyaWFsIFBvcnQgSVJRCQkqLwoKCXN0cnVjdCBpbnB1dF9kZXYgKmlucHV0X2RldjsKCXN0cnVjdCB0aW1lcl9saXN0IHRpbWVyX2tleXVwOwoJc3RydWN0IGxlZF90cmlnZ2VyICpyeHRyaWdnZXI7CglzdHJ1Y3QgbGVkX3RyaWdnZXIgKnR4dHJpZ2dlcjsKCXN0cnVjdCBsZWRfY2xhc3NkZXYgbGVkOwoKCXUzMiBsYXN0X3NjYW5jb2RlOwoJdW5zaWduZWQgaW50IGxhc3Rfa2V5Y29kZTsKCXU4IGxhc3RfdG9nZ2xlOwoJdTgga2V5cHJlc3NlZDsKCXVuc2lnbmVkIGxvbmcga2V5dXBfamlmZmllczsKCXVuc2lnbmVkIGludCBpZGxlX2NvdW50OwoKCS8qIFJYIGlyZGF0YSBhbmQgcGFyc2luZyBzdGF0ZSAqLwoJdW5zaWduZWQgbG9uZyBpcmRhdGFbMzBdOwoJdW5zaWduZWQgaW50IGlyZGF0YV9jb3VudDsKCXVuc2lnbmVkIGludCBpcmRhdGFfaWRsZTsKCXVuc2lnbmVkIGludCBpcmRhdGFfb2ZmOwoJdW5zaWduZWQgaW50IGlyZGF0YV9lcnJvcjsKCgkvKiBQcm90ZWN0ZWQgYnkga2V5dGFibGVfbG9jayAqLwoJc3RydWN0IGxpc3RfaGVhZCBrZXl0YWJsZTsKfTsKCnN0YXRpYyBlbnVtIHdiY2lyX3Byb3RvY29sIHByb3RvY29sID0gSVJfUFJPVE9DT0xfUkM2Owptb2R1bGVfcGFyYW0ocHJvdG9jb2wsIHVpbnQsIDA0NDQpOwpNT0RVTEVfUEFSTV9ERVNDKHByb3RvY29sLCAiSVIgcHJvdG9jb2wgdG8gdXNlICIKCQkgIigwID0gUkM1LCAxID0gTkVDLCAyID0gUkM2QSwgZGVmYXVsdCkiKTsKCnN0YXRpYyBpbnQgaW52ZXJ0OyAvKiBkZWZhdWx0ID0gMCAqLwptb2R1bGVfcGFyYW0oaW52ZXJ0LCBib29sLCAwNDQ0KTsKTU9EVUxFX1BBUk1fREVTQyhpbnZlcnQsICJJbnZlcnQgdGhlIHNpZ25hbCBmcm9tIHRoZSBJUiByZWNlaXZlciIpOwoKc3RhdGljIHVuc2lnbmVkIGludCB3YWtlX3NjID0gMHg4MDBGMDQwQzsKbW9kdWxlX3BhcmFtKHdha2Vfc2MsIHVpbnQsIDA2NDQpOwpNT0RVTEVfUEFSTV9ERVNDKHdha2Vfc2MsICJTY2FuY29kZSBvZiB0aGUgcG93ZXItb24gSVIgY29tbWFuZCIpOwoKc3RhdGljIHVuc2lnbmVkIGludCB3YWtlX3JjNm1vZGUgPSA2Owptb2R1bGVfcGFyYW0od2FrZV9yYzZtb2RlLCB1aW50LCAwNjQ0KTsKTU9EVUxFX1BBUk1fREVTQyh3YWtlX3JjNm1vZGUsICJSQzYgbW9kZSBmb3IgdGhlIHBvd2VyLW9uIGNvbW1hbmQgIgoJCSAiKDAgPSAwLCA2ID0gNkEsIGRlZmF1bHQpIik7CgoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgogKiBVVElMSVRZIEZVTkNUSU9OUwogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgovKiBDYWxsZXIgbmVlZHMgdG8gaG9sZCB3YmNpcl9sb2NrICovCnN0YXRpYyB2b2lkCndiY2lyX3NldF9iaXRzKHVuc2lnbmVkIGxvbmcgYWRkciwgdTggYml0cywgdTggbWFzaykKewoJdTggdmFsOwoKCXZhbCA9IGluYihhZGRyKTsKCXZhbCA9ICgodmFsICYgfm1hc2spIHwgKGJpdHMgJiBtYXNrKSk7CglvdXRiKHZhbCwgYWRkcik7Cn0KCi8qIFNlbGVjdHMgdGhlIHJlZ2lzdGVyIGJhbmsgZm9yIHRoZSBzZXJpYWwgcG9ydCAqLwpzdGF0aWMgaW5saW5lIHZvaWQKd2JjaXJfc2VsZWN0X2Jhbmsoc3RydWN0IHdiY2lyX2RhdGEgKmRhdGEsIGVudW0gd2JjaXJfYmFuayBiYW5rKQp7CglvdXRiKGJhbmssIGRhdGEtPnNiYXNlICsgV0JDSVJfUkVHX1NQM19CU1IpOwp9CgpzdGF0aWMgZW51bSBsZWRfYnJpZ2h0bmVzcwp3YmNpcl9sZWRfYnJpZ2h0bmVzc19nZXQoc3RydWN0IGxlZF9jbGFzc2RldiAqbGVkX2NkZXYpCnsKCXN0cnVjdCB3YmNpcl9kYXRhICpkYXRhID0gY29udGFpbmVyX29mKGxlZF9jZGV2LAoJCQkJCSAgICAgICBzdHJ1Y3Qgd2JjaXJfZGF0YSwKCQkJCQkgICAgICAgbGVkKTsKCglpZiAoaW5iKGRhdGEtPmViYXNlICsgV0JDSVJfUkVHX0VDRUlSX0NUUykgJiBXQkNJUl9MRURfRU5BQkxFKQoJCXJldHVybiBMRURfRlVMTDsKCWVsc2UKCQlyZXR1cm4gTEVEX09GRjsKfQoKc3RhdGljIHZvaWQKd2JjaXJfbGVkX2JyaWdodG5lc3Nfc2V0KHN0cnVjdCBsZWRfY2xhc3NkZXYgKmxlZF9jZGV2LAoJCQkgICAgZW51bSBsZWRfYnJpZ2h0bmVzcyBicmlnaHRuZXNzKQp7CglzdHJ1Y3Qgd2JjaXJfZGF0YSAqZGF0YSA9IGNvbnRhaW5lcl9vZihsZWRfY2RldiwKCQkJCQkgICAgICAgc3RydWN0IHdiY2lyX2RhdGEsCgkJCQkJICAgICAgIGxlZCk7CgoJd2JjaXJfc2V0X2JpdHMoZGF0YS0+ZWJhc2UgKyBXQkNJUl9SRUdfRUNFSVJfQ1RTLAoJCSAgICAgICBicmlnaHRuZXNzID09IExFRF9PRkYgPyAweDAwIDogV0JDSVJfTEVEX0VOQUJMRSwKCQkgICAgICAgV0JDSVJfTEVEX0VOQUJMRSk7Cn0KCi8qIE1hbmNoZXN0ZXIgZW5jb2RlcyBiaXRzIHRvIFJDNiBtZXNzYWdlIGNlbGxzIChzZWUgd2JjaXJfcGFyc2VfcmM2KSAqLwpzdGF0aWMgdTgKd2JjaXJfdG9fcmM2Y2VsbHModTggdmFsKQp7Cgl1OCBjb2RlZCA9IDB4MDA7CglpbnQgaTsKCgl2YWwgJj0gMHgwRjsKCWZvciAoaSA9IDA7IGkgPCA0OyBpKyspIHsKCQlpZiAodmFsICYgMHgwMSkKCQkJY29kZWQgfD0gMHgwMiA8PCAoaSAqIDIpOwoJCWVsc2UKCQkJY29kZWQgfD0gMHgwMSA8PCAoaSAqIDIpOwoJCXZhbCA+Pj0gMTsKCX0KCglyZXR1cm4gY29kZWQ7Cn0KCgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCiAqIElOUFVUIEZVTkNUSU9OUwogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgpzdGF0aWMgdW5zaWduZWQgaW50CndiY2lyX2RvX2dldGtleWNvZGUoc3RydWN0IHdiY2lyX2RhdGEgKmRhdGEsIHUzMiBzY2FuY29kZSkKewoJc3RydWN0IHdiY2lyX2tleWVudHJ5ICprZXllbnRyeTsKCXVuc2lnbmVkIGludCBrZXljb2RlID0gS0VZX1JFU0VSVkVEOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCglyZWFkX2xvY2tfaXJxc2F2ZSgma2V5dGFibGVfbG9jaywgZmxhZ3MpOwoKCWxpc3RfZm9yX2VhY2hfZW50cnkoa2V5ZW50cnksICZkYXRhLT5rZXl0YWJsZSwgbGlzdCkgewoJCWlmIChrZXllbnRyeS0+a2V5LnNjYW5jb2RlID09IHNjYW5jb2RlKSB7CgkJCWtleWNvZGUgPSBrZXllbnRyeS0+a2V5LmtleWNvZGU7CgkJCWJyZWFrOwoJCX0KCX0KCglyZWFkX3VubG9ja19pcnFyZXN0b3JlKCZrZXl0YWJsZV9sb2NrLCBmbGFncyk7CglyZXR1cm4ga2V5Y29kZTsKfQoKc3RhdGljIGludAp3YmNpcl9nZXRrZXljb2RlKHN0cnVjdCBpbnB1dF9kZXYgKmRldiwKCQkgdW5zaWduZWQgaW50IHNjYW5jb2RlLCB1bnNpZ25lZCBpbnQgKmtleWNvZGUpCnsKCXN0cnVjdCB3YmNpcl9kYXRhICpkYXRhID0gaW5wdXRfZ2V0X2RydmRhdGEoZGV2KTsKCgkqa2V5Y29kZSA9IHdiY2lyX2RvX2dldGtleWNvZGUoZGF0YSwgc2NhbmNvZGUpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQKd2JjaXJfc2V0a2V5Y29kZShzdHJ1Y3QgaW5wdXRfZGV2ICpkZXYsCgkJIHVuc2lnbmVkIGludCBzY2FuY29kZSwgdW5zaWduZWQgaW50IGtleWNvZGUpCnsKCXN0cnVjdCB3YmNpcl9kYXRhICpkYXRhID0gaW5wdXRfZ2V0X2RydmRhdGEoZGV2KTsKCXN0cnVjdCB3YmNpcl9rZXllbnRyeSAqa2V5ZW50cnk7CglzdHJ1Y3Qgd2JjaXJfa2V5ZW50cnkgKm5ld19rZXllbnRyeTsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1bnNpZ25lZCBpbnQgb2xkX2tleWNvZGUgPSBLRVlfUkVTRVJWRUQ7CgoJbmV3X2tleWVudHJ5ID0ga21hbGxvYyhzaXplb2YoKm5ld19rZXllbnRyeSksIEdGUF9LRVJORUwpOwoJaWYgKCFuZXdfa2V5ZW50cnkpCgkJcmV0dXJuIC1FTk9NRU07CgoJd3JpdGVfbG9ja19pcnFzYXZlKCZrZXl0YWJsZV9sb2NrLCBmbGFncyk7CgoJbGlzdF9mb3JfZWFjaF9lbnRyeShrZXllbnRyeSwgJmRhdGEtPmtleXRhYmxlLCBsaXN0KSB7CgkJaWYgKGtleWVudHJ5LT5rZXkuc2NhbmNvZGUgIT0gc2NhbmNvZGUpCgkJCWNvbnRpbnVlOwoKCQlvbGRfa2V5Y29kZSA9IGtleWVudHJ5LT5rZXkua2V5Y29kZTsKCQlrZXllbnRyeS0+a2V5LmtleWNvZGUgPSBrZXljb2RlOwoKCQlpZiAoa2V5ZW50cnktPmtleS5rZXljb2RlID09IEtFWV9SRVNFUlZFRCkgewoJCQlsaXN0X2RlbCgma2V5ZW50cnktPmxpc3QpOwoJCQlrZnJlZShrZXllbnRyeSk7CgkJfQoKCQlicmVhazsKCX0KCglzZXRfYml0KGtleWNvZGUsIGRldi0+a2V5Yml0KTsKCglpZiAob2xkX2tleWNvZGUgPT0gS0VZX1JFU0VSVkVEKSB7CgkJbmV3X2tleWVudHJ5LT5rZXkuc2NhbmNvZGUgPSBzY2FuY29kZTsKCQluZXdfa2V5ZW50cnktPmtleS5rZXljb2RlID0ga2V5Y29kZTsKCQlsaXN0X2FkZCgmbmV3X2tleWVudHJ5LT5saXN0LCAmZGF0YS0+a2V5dGFibGUpOwoJfSBlbHNlIHsKCQlrZnJlZShuZXdfa2V5ZW50cnkpOwoJCWNsZWFyX2JpdChvbGRfa2V5Y29kZSwgZGV2LT5rZXliaXQpOwoJCWxpc3RfZm9yX2VhY2hfZW50cnkoa2V5ZW50cnksICZkYXRhLT5rZXl0YWJsZSwgbGlzdCkgewoJCQlpZiAoa2V5ZW50cnktPmtleS5rZXljb2RlID09IG9sZF9rZXljb2RlKSB7CgkJCQlzZXRfYml0KG9sZF9rZXljb2RlLCBkZXYtPmtleWJpdCk7CgkJCQlicmVhazsKCQkJfQoJCX0KCX0KCgl3cml0ZV91bmxvY2tfaXJxcmVzdG9yZSgma2V5dGFibGVfbG9jaywgZmxhZ3MpOwoJcmV0dXJuIDA7Cn0KCi8qCiAqIFRpbWVyIGZ1bmN0aW9uIHRvIHJlcG9ydCBrZXl1cCBldmVudCBzb21lIHRpbWUgYWZ0ZXIga2V5ZG93biBpcwogKiByZXBvcnRlZCBieSB0aGUgSVNSLgogKi8Kc3RhdGljIHZvaWQKd2JjaXJfa2V5dXAodW5zaWduZWQgbG9uZyBjb29raWUpCnsKCXN0cnVjdCB3YmNpcl9kYXRhICpkYXRhID0gKHN0cnVjdCB3YmNpcl9kYXRhICopY29va2llOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCgkvKgoJICogZGF0YS0+a2V5dXBfamlmZmllcyBpcyB1c2VkIHRvIHByZXZlbnQgYSByYWNlIGNvbmRpdGlvbiBpZiBhCgkgKiBoYXJkd2FyZSBpbnRlcnJ1cHQgb2NjdXJzIGF0IHRoaXMgcG9pbnQgYW5kIHRoZSBrZXl1cCB0aW1lcgoJICogZXZlbnQgaXMgbW92ZWQgZnVydGhlciBpbnRvIHRoZSBmdXR1cmUgYXMgYSByZXN1bHQuCgkgKgoJICogVGhlIHRpbWVyIHdpbGwgdGhlbiBiZSByZWFjdGl2YXRlZCBhbmQgdGhpcyBmdW5jdGlvbiBjYWxsZWQKCSAqIGFnYWluIGluIHRoZSBmdXR1cmUuIFdlIG5lZWQgdG8gZXhpdCBncmFjZWZ1bGx5IGluIHRoYXQgY2FzZQoJICogdG8gYWxsb3cgdGhlIGlucHV0IHN1YnN5c3RlbSB0byBkbyBpdHMgYXV0by1yZXBlYXQgbWFnaWMgb3IKCSAqIGEga2V5dXAgZXZlbnQgbWlnaHQgZm9sbG93IGltbWVkaWF0ZWx5IGFmdGVyIHRoZSBrZXlkb3duLgoJICovCgoJc3Bpbl9sb2NrX2lycXNhdmUoJndiY2lyX2xvY2ssIGZsYWdzKTsKCglpZiAodGltZV9pc19hZnRlcl9lcV9qaWZmaWVzKGRhdGEtPmtleXVwX2ppZmZpZXMpICYmIGRhdGEtPmtleXByZXNzZWQpIHsKCQlkYXRhLT5rZXlwcmVzc2VkID0gMDsKCQlsZWRfdHJpZ2dlcl9ldmVudChkYXRhLT5yeHRyaWdnZXIsIExFRF9PRkYpOwoJCWlucHV0X3JlcG9ydF9rZXkoZGF0YS0+aW5wdXRfZGV2LCBkYXRhLT5sYXN0X2tleWNvZGUsIDApOwoJCWlucHV0X3N5bmMoZGF0YS0+aW5wdXRfZGV2KTsKCX0KCglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ3YmNpcl9sb2NrLCBmbGFncyk7Cn0KCnN0YXRpYyB2b2lkCndiY2lyX2tleWRvd24oc3RydWN0IHdiY2lyX2RhdGEgKmRhdGEsIHUzMiBzY2FuY29kZSwgdTggdG9nZ2xlKQp7Cgl1bnNpZ25lZCBpbnQga2V5Y29kZTsKCgkvKiBSZXBlYXQ/ICovCglpZiAoZGF0YS0+bGFzdF9zY2FuY29kZSA9PSBzY2FuY29kZSAmJgoJICAgIGRhdGEtPmxhc3RfdG9nZ2xlID09IHRvZ2dsZSAmJgoJICAgIGRhdGEtPmtleXByZXNzZWQpCgkJZ290byBzZXRfdGltZXI7CglkYXRhLT5sYXN0X3NjYW5jb2RlID0gc2NhbmNvZGU7CgoJLyogRG8gd2UgbmVlZCB0byByZWxlYXNlIGFuIG9sZCBrZXlwcmVzcz8gKi8KCWlmIChkYXRhLT5rZXlwcmVzc2VkKSB7CgkJaW5wdXRfcmVwb3J0X2tleShkYXRhLT5pbnB1dF9kZXYsIGRhdGEtPmxhc3Rfa2V5Y29kZSwgMCk7CgkJaW5wdXRfc3luYyhkYXRhLT5pbnB1dF9kZXYpOwoJCWRhdGEtPmtleXByZXNzZWQgPSAwOwoJfQoKCS8qIFJlcG9ydCBzY2FuY29kZSAqLwoJaW5wdXRfZXZlbnQoZGF0YS0+aW5wdXRfZGV2LCBFVl9NU0MsIE1TQ19TQ0FOLCAoaW50KXNjYW5jb2RlKTsKCgkvKiBEbyB3ZSBrbm93IHRoaXMgc2NhbmNvZGU/ICovCglrZXljb2RlID0gd2JjaXJfZG9fZ2V0a2V5Y29kZShkYXRhLCBzY2FuY29kZSk7CglpZiAoa2V5Y29kZSA9PSBLRVlfUkVTRVJWRUQpCgkJZ290byBzZXRfdGltZXI7CgoJLyogUmVnaXN0ZXIgYSBrZXlwcmVzcyAqLwoJaW5wdXRfcmVwb3J0X2tleShkYXRhLT5pbnB1dF9kZXYsIGtleWNvZGUsIDEpOwoJZGF0YS0+a2V5cHJlc3NlZCA9IDE7CglkYXRhLT5sYXN0X2tleWNvZGUgPSBrZXljb2RlOwoJZGF0YS0+bGFzdF90b2dnbGUgPSB0b2dnbGU7CgpzZXRfdGltZXI6CglpbnB1dF9zeW5jKGRhdGEtPmlucHV0X2Rldik7CglsZWRfdHJpZ2dlcl9ldmVudChkYXRhLT5yeHRyaWdnZXIsCgkJCSAgZGF0YS0+a2V5cHJlc3NlZCA/IExFRF9GVUxMIDogTEVEX09GRik7CglkYXRhLT5rZXl1cF9qaWZmaWVzID0gamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoSVJfS0VZUFJFU1NfVElNRU9VVCk7Cgltb2RfdGltZXIoJmRhdGEtPnRpbWVyX2tleXVwLCBkYXRhLT5rZXl1cF9qaWZmaWVzKTsKfQoKCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoKICogSVIgUEFSU0lORyBGVU5DVElPTlMKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKLyogUmVzZXRzIGFsbCBpcmRhdGEgKi8Kc3RhdGljIHZvaWQKd2JjaXJfcmVzZXRfaXJkYXRhKHN0cnVjdCB3YmNpcl9kYXRhICpkYXRhKQp7CgltZW1zZXQoZGF0YS0+aXJkYXRhLCAwLCBzaXplb2YoZGF0YS0+aXJkYXRhKSk7CglkYXRhLT5pcmRhdGFfY291bnQgPSAwOwoJZGF0YS0+aXJkYXRhX29mZiA9IDA7CglkYXRhLT5pcmRhdGFfZXJyb3IgPSAwOwoJZGF0YS0+aWRsZV9jb3VudCA9IDA7Cn0KCi8qIEFkZHMgb25lIGJpdCBvZiBpcmRhdGEgKi8Kc3RhdGljIHZvaWQKYWRkX2lyZGF0YV9iaXQoc3RydWN0IHdiY2lyX2RhdGEgKmRhdGEsIGludCBzZXQpCnsKCWlmIChkYXRhLT5pcmRhdGFfY291bnQgPj0gc2l6ZW9mKGRhdGEtPmlyZGF0YSkgKiA4KSB7CgkJZGF0YS0+aXJkYXRhX2Vycm9yID0gMTsKCQlyZXR1cm47Cgl9CgoJaWYgKHNldCkKCQlfX3NldF9iaXQoZGF0YS0+aXJkYXRhX2NvdW50LCBkYXRhLT5pcmRhdGEpOwoJZGF0YS0+aXJkYXRhX2NvdW50Kys7Cn0KCi8qIEdldHMgY291bnQgYml0cyBvZiBpcmRhdGEgKi8Kc3RhdGljIHUxNgpnZXRfYml0cyhzdHJ1Y3Qgd2JjaXJfZGF0YSAqZGF0YSwgaW50IGNvdW50KQp7Cgl1MTYgdmFsID0gMHgwOwoKCWlmIChkYXRhLT5pcmRhdGFfY291bnQgLSBkYXRhLT5pcmRhdGFfb2ZmIDwgY291bnQpIHsKCQlkYXRhLT5pcmRhdGFfZXJyb3IgPSAxOwoJCXJldHVybiAweDA7Cgl9CgoJd2hpbGUgKGNvdW50ID4gMCkgewoJCXZhbCA8PD0gMTsKCQlpZiAodGVzdF9iaXQoZGF0YS0+aXJkYXRhX29mZiwgZGF0YS0+aXJkYXRhKSkKCQkJdmFsIHw9IDB4MTsKCQljb3VudC0tOwoJCWRhdGEtPmlyZGF0YV9vZmYrKzsKCX0KCglyZXR1cm4gdmFsOwp9CgovKiBSZWFkcyAxNiBjZWxscyBhbmQgY29udmVydHMgdGhlbSB0byBhIGJ5dGUgKi8Kc3RhdGljIHU4CndiY2lyX3JjNmNlbGxzX3RvX2J5dGUoc3RydWN0IHdiY2lyX2RhdGEgKmRhdGEpCnsKCXUxNiByYXcgPSBnZXRfYml0cyhkYXRhLCAxNik7Cgl1OCB2YWwgPSAweDAwOwoJaW50IGJpdDsKCglmb3IgKGJpdCA9IDA7IGJpdCA8IDg7IGJpdCsrKSB7CgkJc3dpdGNoIChyYXcgJiAweDAzKSB7CgkJY2FzZSAweDAxOgoJCQlicmVhazsKCQljYXNlIDB4MDI6CgkJCXZhbCB8PSAoMHgwMSA8PCBiaXQpOwoJCQlicmVhazsKCQlkZWZhdWx0OgoJCQlkYXRhLT5pcmRhdGFfZXJyb3IgPSAxOwoJCQlicmVhazsKCQl9CgkJcmF3ID4+PSAyOwoJfQoKCXJldHVybiB2YWw7Cn0KCi8qIERlY29kZXMgYSBudW1iZXIgb2YgYml0cyBmcm9tIHJhdyBSQzUgZGF0YSAqLwpzdGF0aWMgdTgKd2JjaXJfZ2V0X3JjNWJpdHMoc3RydWN0IHdiY2lyX2RhdGEgKmRhdGEsIHVuc2lnbmVkIGludCBjb3VudCkKewoJdTE2IHJhdyA9IGdldF9iaXRzKGRhdGEsIGNvdW50ICogMik7Cgl1OCB2YWwgPSAweDAwOwoJaW50IGJpdDsKCglmb3IgKGJpdCA9IDA7IGJpdCA8IGNvdW50OyBiaXQrKykgewoJCXN3aXRjaCAocmF3ICYgMHgwMykgewoJCWNhc2UgMHgwMToKCQkJdmFsIHw9ICgweDAxIDw8IGJpdCk7CgkJCWJyZWFrOwoJCWNhc2UgMHgwMjoKCQkJYnJlYWs7CgkJZGVmYXVsdDoKCQkJZGF0YS0+aXJkYXRhX2Vycm9yID0gMTsKCQkJYnJlYWs7CgkJfQoJCXJhdyA+Pj0gMjsKCX0KCglyZXR1cm4gdmFsOwp9CgpzdGF0aWMgdm9pZAp3YmNpcl9wYXJzZV9yYzYoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgd2JjaXJfZGF0YSAqZGF0YSkKewoJLyoKCSAqIE5vcm1hbCBiaXRzIGFyZSBtYW5jaGVzdGVyIGNvZGVkIGFzIGZvbGxvd3M6CgkgKiBjZWxsMCArIGNlbGwxID0gbG9naWMgIjAiCgkgKiBjZWxsMSArIGNlbGwwID0gbG9naWMgIjEiCgkgKgoJICogVGhlIElSIHB1bHNlIGhhcyB0aGUgZm9sbG93aW5nIGNvbXBvbmVudHM6CgkgKgoJICogTGVhZGVyCQktIDYgKiBjZWxsMSAtIGRpc2NhcmRlZAoJICogR2FwICAgIAkJLSAyICogY2VsbDAgLSBkaXNjYXJkZWQKCSAqIFN0YXJ0IGJpdAkJLSBOb3JtYWwgQ29kaW5nIC0gYWx3YXlzICIxIgoJICogTW9kZSBCaXQgMiAtIDAJLSBOb3JtYWwgQ29kaW5nCgkgKiBUb2dnbGUgYml0CQktIE5vcm1hbCBDb2Rpbmcgd2l0aCBkb3VibGUgYml0IHRpbWUsCgkgKgkJCSAgZS5nLiBjZWxsMCArIGNlbGwwICsgY2VsbDEgKyBjZWxsMQoJICoJCQkgIG1lYW5zIGxvZ2ljICIwIi4KCSAqCgkgKiBUaGUgcmVzdCBkZXBlbmRzIG9uIHRoZSBtb2RlLCB0aGUgZm9sbG93aW5nIG1vZGVzIGFyZSBrbm93bjoKCSAqCgkgKiBNT0RFIDA6CgkgKiAgQWRkcmVzcyBCaXQgNyAtIDAJLSBOb3JtYWwgQ29kaW5nCgkgKiAgQ29tbWFuZCBCaXQgNyAtIDAJLSBOb3JtYWwgQ29kaW5nCgkgKgoJICogTU9ERSA2OgoJICogIFRoZSBhYm92ZSBUb2dnbGUgQml0IGlzIHVzZWQgYXMgYSBzdWJtb2RlIGJpdCwgMCA9IEEsIDEgPSBCLgoJICogIFN1Ym1vZGUgQiBpcyBmb3IgcG9pbnRpbmcgZGV2aWNlcywgb25seSByZW1vdGVzIHVzaW5nIHN1Ym1vZGUgQQoJICogIGFyZSBzdXBwb3J0ZWQuCgkgKgoJICogIEN1c3RvbWVyIHJhbmdlIGJpdAktIDAgPT4gQ3VzdG9tZXIgPSA3IGJpdHMsIDAuLi4xMjcKCSAqICAgICAgICAgICAgICAgICAgICAgICAgMSA9PiBDdXN0b21lciA9IDE1IGJpdHMsIDMyNzY4Li4uNjU1MzUKCSAqICBDdXN0b21lciBCaXRzCS0gTm9ybWFsIENvZGluZwoJICoKCSAqICBDdXN0b21lciBjb2RlcyBhcmUgYWxsb2NhdGVkIGJ5IFBoaWxpcHMuIFRoZSByZXN0IG9mIHRoZSBiaXRzCgkgKiAgYXJlIGN1c3RvbWVyIGRlcGVuZGVudC4gVGhlIGZvbGxvd2luZyBpcyBjb21tb25seSB1c2VkIChhbmQgdGhlCgkgKiAgb25seSBzdXBwb3J0ZWQgY29uZmlnKToKCSAqCgkgKiAgVG9nZ2xlIEJpdAkJLSBOb3JtYWwgQ29kaW5nCgkgKiAgQWRkcmVzcyBCaXQgNiAtIDAJLSBOb3JtYWwgQ29kaW5nCgkgKiAgQ29tbWFuZCBCaXQgNyAtIDAJLSBOb3JtYWwgQ29kaW5nCgkgKgoJICogQWxsIG1vZGVzIGFyZSBmb2xsb3dlZCBieSBhdCBsZWFzdCA2ICogY2VsbDAuCgkgKgoJICogTU9ERSAwIG1zZ2xlbjoKCSAqICAxICogMiAoc3RhcnQgYml0KSArIDMgKiAyIChtb2RlKSArIDIgKiAyICh0b2dnbGUpICsKCSAqICA4ICogMiAoYWRkcmVzcykgKyA4ICogMiAoY29tbWFuZCkgPQoJICogIDQ0IGNlbGxzCgkgKgoJICogTU9ERSA2QSBtc2dsZW46CgkgKiAgMSAqIDIgKHN0YXJ0IGJpdCkgKyAzICogMiAobW9kZSkgKyAyICogMiAoc3VibW9kZSkgKwoJICogIDEgKiAyIChjdXN0b21lciByYW5nZSBiaXQpICsgNy8xNSAqIDIgKGN1c3RvbWVyIGJpdHMpICsKCSAqICAxICogMiAodG9nZ2xlIGJpdCkgKyA3ICogMiAoYWRkcmVzcykgKyA4ICogMiAoY29tbWFuZCkgPQoJICogIDYwIC0gNzYgY2VsbHMKCSAqLwoJdTggbW9kZTsKCXU4IHRvZ2dsZTsKCXUxNiBjdXN0b21lciA9IDB4MDsKCXU4IGFkZHJlc3M7Cgl1OCBjb21tYW5kOwoJdTMyIHNjYW5jb2RlOwoKCS8qIExlYWRlciBtYXJrICovCgl3aGlsZSAoZ2V0X2JpdHMoZGF0YSwgMSkgJiYgIWRhdGEtPmlyZGF0YV9lcnJvcikKCQkvKiBEbyBub3RoaW5nICovOwoKCS8qIExlYWRlciBzcGFjZSAqLwoJaWYgKGdldF9iaXRzKGRhdGEsIDEpKSB7CgkJZGV2X2RiZyhkZXYsICJSQzYgLSBJbnZhbGlkIGxlYWRlciBzcGFjZVxuIik7CgkJcmV0dXJuOwoJfQoKCS8qIFN0YXJ0IGJpdCAqLwoJaWYgKGdldF9iaXRzKGRhdGEsIDIpICE9IDB4MDIpIHsKCQlkZXZfZGJnKGRldiwgIlJDNiAtIEludmFsaWQgc3RhcnQgYml0XG4iKTsKCQlyZXR1cm47Cgl9CgoJLyogTW9kZSAqLwoJbW9kZSA9IGdldF9iaXRzKGRhdGEsIDYpOwoJc3dpdGNoIChtb2RlKSB7CgljYXNlIDB4MTU6IC8qIDAxMDEwMSA9IGIwMDAgKi8KCQltb2RlID0gMDsKCQlicmVhazsKCWNhc2UgMHgyOTogLyogMTAxMDAxID0gYjExMCAqLwoJCW1vZGUgPSA2OwoJCWJyZWFrOwoJZGVmYXVsdDoKCQlkZXZfZGJnKGRldiwgIlJDNiAtIEludmFsaWQgbW9kZVxuIik7CgkJcmV0dXJuOwoJfQoKCS8qIFRvZ2dsZSBiaXQgLyBTdWJtb2RlIGJpdCAqLwoJdG9nZ2xlID0gZ2V0X2JpdHMoZGF0YSwgNCk7Cglzd2l0Y2ggKHRvZ2dsZSkgewoJY2FzZSAweDAzOgoJCXRvZ2dsZSA9IDA7CgkJYnJlYWs7CgljYXNlIDB4MEM6CgkJdG9nZ2xlID0gMTsKCQlicmVhazsKCWRlZmF1bHQ6CgkJZGV2X2RiZyhkZXYsICJSQzYgLSBUb2dnbGUgYml0IGVycm9yXG4iKTsKCQlicmVhazsKCX0KCgkvKiBDdXN0b21lciAqLwoJaWYgKG1vZGUgPT0gNikgewoJCWlmICh0b2dnbGUgIT0gMCkgewoJCQlkZXZfZGJnKGRldiwgIlJDNkIgLSBOb3QgU3VwcG9ydGVkXG4iKTsKCQkJcmV0dXJuOwoJCX0KCgkJY3VzdG9tZXIgPSB3YmNpcl9yYzZjZWxsc190b19ieXRlKGRhdGEpOwoKCQlpZiAoY3VzdG9tZXIgJiAweDgwKSB7CgkJCS8qIDE1IGJpdCBjdXN0b21lciB2YWx1ZSAqLwoJCQljdXN0b21lciA8PD0gODsKCQkJY3VzdG9tZXIgfD0gd2JjaXJfcmM2Y2VsbHNfdG9fYnl0ZShkYXRhKTsKCQl9Cgl9CgoJLyogQWRkcmVzcyAqLwoJYWRkcmVzcyA9IHdiY2lyX3JjNmNlbGxzX3RvX2J5dGUoZGF0YSk7CglpZiAobW9kZSA9PSA2KSB7CgkJdG9nZ2xlID0gYWRkcmVzcyA+PiA3OwoJCWFkZHJlc3MgJj0gMHg3RjsKCX0KCgkvKiBDb21tYW5kICovCgljb21tYW5kID0gd2JjaXJfcmM2Y2VsbHNfdG9fYnl0ZShkYXRhKTsKCgkvKiBDcmVhdGUgc2NhbmNvZGUgKi8KCXNjYW5jb2RlID0gIGNvbW1hbmQ7CglzY2FuY29kZSB8PSBhZGRyZXNzIDw8IDg7CglzY2FuY29kZSB8PSBjdXN0b21lciA8PCAxNjsKCgkvKiBMYXN0IHNhbml0eSBjaGVjayAqLwoJaWYgKGRhdGEtPmlyZGF0YV9lcnJvcikgewoJCWRldl9kYmcoZGV2LCAiUkM2IC0gQ2VsbCBlcnJvcihzKVxuIik7CgkJcmV0dXJuOwoJfQoKCWRldl9kYmcoZGV2LCAiSVItUkM2IGFkIDB4JTAyWCBjbSAweCUwMlggY3UgMHglMDRYICIKCQkidG9nZ2xlICV1IG1vZGUgJXUgc2NhbiAweCUwOFhcbiIsCgkJYWRkcmVzcywKCQljb21tYW5kLAoJCWN1c3RvbWVyLAoJCSh1bnNpZ25lZCBpbnQpdG9nZ2xlLAoJCSh1bnNpZ25lZCBpbnQpbW9kZSwKCQlzY2FuY29kZSk7CgoJd2JjaXJfa2V5ZG93bihkYXRhLCBzY2FuY29kZSwgdG9nZ2xlKTsKfQoKc3RhdGljIHZvaWQKd2JjaXJfcGFyc2VfcmM1KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHdiY2lyX2RhdGEgKmRhdGEpCnsKCS8qCgkgKiBCaXRzIGFyZSBtYW5jaGVzdGVyIGNvZGVkIGFzIGZvbGxvd3M6CgkgKiBjZWxsMSArIGNlbGwwID0gbG9naWMgIjAiCgkgKiBjZWxsMCArIGNlbGwxID0gbG9naWMgIjEiCgkgKiAoaS5lLiB0aGUgcmV2ZXJzZSBvZiBSQzYpCgkgKgoJICogU3RhcnQgYml0IDEJCS0gIjEiIC0gZGlzY2FyZGVkCgkgKiBTdGFydCBiaXQgMgkJLSBNdXN0IGJlIGludmVydGVkIHRvIGdldCBjb21tYW5kIGJpdCA2CgkgKiBUb2dnbGUgYml0CgkgKiBBZGRyZXNzIEJpdCA0IC0gMAoJICogQ29tbWFuZCBCaXQgNSAtIDAKCSAqLwoJdTggdG9nZ2xlOwoJdTggYWRkcmVzczsKCXU4IGNvbW1hbmQ7Cgl1MzIgc2NhbmNvZGU7CgoJLyogU3RhcnQgYml0IDEgKi8KCWlmICghZ2V0X2JpdHMoZGF0YSwgMSkpIHsKCQlkZXZfZGJnKGRldiwgIlJDNSAtIEludmFsaWQgc3RhcnQgYml0XG4iKTsKCQlyZXR1cm47Cgl9CgoJLyogU3RhcnQgYml0IDIgKi8KCWlmICghd2JjaXJfZ2V0X3JjNWJpdHMoZGF0YSwgMSkpCgkJY29tbWFuZCA9IDB4NDA7CgllbHNlCgkJY29tbWFuZCA9IDB4MDA7CgoJdG9nZ2xlICAgPSB3YmNpcl9nZXRfcmM1Yml0cyhkYXRhLCAxKTsKCWFkZHJlc3MgID0gd2JjaXJfZ2V0X3JjNWJpdHMoZGF0YSwgNSk7Cgljb21tYW5kIHw9IHdiY2lyX2dldF9yYzViaXRzKGRhdGEsIDYpOwoJc2NhbmNvZGUgPSBhZGRyZXNzIDw8IDcgfCBjb21tYW5kOwoKCS8qIExhc3Qgc2FuaXR5IGNoZWNrICovCglpZiAoZGF0YS0+aXJkYXRhX2Vycm9yKSB7CgkJZGV2X2RiZyhkZXYsICJSQzUgLSBJbnZhbGlkIG1lc3NhZ2VcbiIpOwoJCXJldHVybjsKCX0KCglkZXZfZGJnKGRldiwgIklSLVJDNSBhZCAldSBjbSAldSB0ICV1IHMgJXVcbiIsCgkJKHVuc2lnbmVkIGludClhZGRyZXNzLAoJCSh1bnNpZ25lZCBpbnQpY29tbWFuZCwKCQkodW5zaWduZWQgaW50KXRvZ2dsZSwKCQkodW5zaWduZWQgaW50KXNjYW5jb2RlKTsKCgl3YmNpcl9rZXlkb3duKGRhdGEsIHNjYW5jb2RlLCB0b2dnbGUpOwp9CgpzdGF0aWMgdm9pZAp3YmNpcl9wYXJzZV9uZWMoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgd2JjaXJfZGF0YSAqZGF0YSkKewoJLyoKCSAqIEVhY2ggYml0IHJlcHJlc2VudHMgNTYwIHVzLgoJICoKCSAqIExlYWRlcgkJLSA5IG1zIGJ1cnN0CgkgKiBHYXAJCQktIDQuNSBtcyBzaWxlbmNlCgkgKiBBZGRyZXNzMSBiaXQgMCAtIDcJLSBBZGRyZXNzIDEKCSAqIEFkZHJlc3MyIGJpdCAwIC0gNwktIEFkZHJlc3MgMgoJICogQ29tbWFuZDEgYml0IDAgLSA3CS0gQ29tbWFuZCAxCgkgKiBDb21tYW5kMiBiaXQgMCAtIDcJLSBDb21tYW5kIDIKCSAqCgkgKiBOb3RlIHRoZSBiaXQgb3JkZXIhCgkgKgoJICogV2l0aCB0aGUgb2xkIE5FQyBwcm90b2NvbCwgQWRkcmVzczIgd2FzIHRoZSBpbnZlcnNlIG9mIEFkZHJlc3MxCgkgKiBhbmQgQ29tbWFuZDIgd2FzIHRoZSBpbnZlcnNlIG9mIENvbW1hbmQxIGFuZCB3ZXJlIHVzZWQgYXMKCSAqIGFuIGVycm9yIGNoZWNrLgoJICoKCSAqIFdpdGggTkVDIGV4dGVuZGVkLCBBZGRyZXNzMSBpcyB0aGUgTFNCIG9mIHRoZSBBZGRyZXNzIGFuZAoJICogQWRkcmVzczIgaXMgdGhlIE1TQiwgQ29tbWFuZCBwYXJzaW5nIHJlbWFpbnMgdW5jaGFuZ2VkLgoJICoKCSAqIEEgcmVwZWF0IG1lc3NhZ2UgaXMgY29kZWQgYXM6CgkgKiBMZWFkZXIJCS0gOSBtcyBidXJzdAoJICogR2FwCQkJLSAyLjI1IG1zIHNpbGVuY2UKCSAqIFJlcGVhdAkJLSA1NjAgdXMgYWN0aXZlCgkgKi8KCXU4IGFkZHJlc3MxOwoJdTggYWRkcmVzczI7Cgl1OCBjb21tYW5kMTsKCXU4IGNvbW1hbmQyOwoJdTE2IGFkZHJlc3M7Cgl1MzIgc2NhbmNvZGU7CgoJLyogTGVhZGVyIG1hcmsgKi8KCXdoaWxlIChnZXRfYml0cyhkYXRhLCAxKSAmJiAhZGF0YS0+aXJkYXRhX2Vycm9yKQoJCS8qIERvIG5vdGhpbmcgKi87CgoJLyogTGVhZGVyIHNwYWNlICovCglpZiAoZ2V0X2JpdHMoZGF0YSwgNCkpIHsKCQlkZXZfZGJnKGRldiwgIk5FQyAtIEludmFsaWQgbGVhZGVyIHNwYWNlXG4iKTsKCQlyZXR1cm47Cgl9CgoJLyogUmVwZWF0PyAqLwoJaWYgKGdldF9iaXRzKGRhdGEsIDEpKSB7CgkJaWYgKCFkYXRhLT5rZXlwcmVzc2VkKSB7CgkJCWRldl9kYmcoZGV2LCAiTkVDIC0gU3RyYXkgcmVwZWF0IG1lc3NhZ2VcbiIpOwoJCQlyZXR1cm47CgkJfQoKCQlkZXZfZGJnKGRldiwgIklSLU5FQyByZXBlYXQgcyAldVxuIiwKCQkJKHVuc2lnbmVkIGludClkYXRhLT5sYXN0X3NjYW5jb2RlKTsKCgkJd2JjaXJfa2V5ZG93bihkYXRhLCBkYXRhLT5sYXN0X3NjYW5jb2RlLCBkYXRhLT5sYXN0X3RvZ2dsZSk7CgkJcmV0dXJuOwoJfQoKCS8qIFJlbWFpbmluZyBsZWFkZXIgc3BhY2UgKi8KCWlmIChnZXRfYml0cyhkYXRhLCAzKSkgewoJCWRldl9kYmcoZGV2LCAiTkVDIC0gSW52YWxpZCBsZWFkZXIgc3BhY2VcbiIpOwoJCXJldHVybjsKCX0KCglhZGRyZXNzMSAgPSBiaXRyZXY4KGdldF9iaXRzKGRhdGEsIDgpKTsKCWFkZHJlc3MyICA9IGJpdHJldjgoZ2V0X2JpdHMoZGF0YSwgOCkpOwoJY29tbWFuZDEgID0gYml0cmV2OChnZXRfYml0cyhkYXRhLCA4KSk7Cgljb21tYW5kMiAgPSBiaXRyZXY4KGdldF9iaXRzKGRhdGEsIDgpKTsKCgkvKiBTYW5pdHkgY2hlY2sgKi8KCWlmIChkYXRhLT5pcmRhdGFfZXJyb3IpIHsKCQlkZXZfZGJnKGRldiwgIk5FQyAtIEludmFsaWQgbWVzc2FnZVxuIik7CgkJcmV0dXJuOwoJfQoKCS8qIENoZWNrIGNvbW1hbmQgdmFsaWRpdHkgKi8KCWlmIChjb21tYW5kMSAhPSB+Y29tbWFuZDIpIHsKCQlkZXZfZGJnKGRldiwgIk5FQyAtIENvbW1hbmQgYnl0ZXMgbWlzbWF0Y2hcbiIpOwoJCXJldHVybjsKCX0KCgkvKiBDaGVjayBmb3IgZXh0ZW5kZWQgTkVDIHByb3RvY29sICovCglhZGRyZXNzID0gYWRkcmVzczE7CglpZiAoYWRkcmVzczEgIT0gfmFkZHJlc3MyKQoJCWFkZHJlc3MgfD0gYWRkcmVzczIgPDwgODsKCglzY2FuY29kZSA9IGFkZHJlc3MgPDwgOCB8IGNvbW1hbmQxOwoKCWRldl9kYmcoZGV2LCAiSVItTkVDIGFkICV1IGNtICV1IHMgJXVcbiIsCgkJKHVuc2lnbmVkIGludClhZGRyZXNzLAoJCSh1bnNpZ25lZCBpbnQpY29tbWFuZDEsCgkJKHVuc2lnbmVkIGludClzY2FuY29kZSk7CgoJd2JjaXJfa2V5ZG93bihkYXRhLCBzY2FuY29kZSwgIWRhdGEtPmxhc3RfdG9nZ2xlKTsKfQoKCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoKICogSU5URVJSVVBUIEZVTkNUSU9OUwogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgpzdGF0aWMgaXJxcmV0dXJuX3QKd2JjaXJfaXJxX2hhbmRsZXIoaW50IGlycW5vLCB2b2lkICpjb29raWUpCnsKCXN0cnVjdCBwbnBfZGV2ICpkZXZpY2UgPSBjb29raWU7CglzdHJ1Y3Qgd2JjaXJfZGF0YSAqZGF0YSA9IHBucF9nZXRfZHJ2ZGF0YShkZXZpY2UpOwoJc3RydWN0IGRldmljZSAqZGV2ID0gJmRldmljZS0+ZGV2OwoJdTggc3RhdHVzOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCXU4IGlyZGF0YVs4XTsKCWludCBpOwoJdW5zaWduZWQgaW50IGh3OwoKCXNwaW5fbG9ja19pcnFzYXZlKCZ3YmNpcl9sb2NrLCBmbGFncyk7CgoJd2JjaXJfc2VsZWN0X2JhbmsoZGF0YSwgV0JDSVJfQkFOS18wKTsKCglzdGF0dXMgPSBpbmIoZGF0YS0+c2Jhc2UgKyBXQkNJUl9SRUdfU1AzX0VJUik7CgoJaWYgKCEoc3RhdHVzICYgKFdCQ0lSX0lSUV9SWCB8IFdCQ0lSX0lSUV9FUlIpKSkgewoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJndiY2lyX2xvY2ssIGZsYWdzKTsKCQlyZXR1cm4gSVJRX05PTkU7Cgl9CgoJaWYgKHN0YXR1cyAmIFdCQ0lSX0lSUV9FUlIpCgkJZGF0YS0+aXJkYXRhX2Vycm9yID0gMTsKCglpZiAoIShzdGF0dXMgJiBXQkNJUl9JUlFfUlgpKQoJCWdvdG8gb3V0OwoKCS8qIFNpbmNlIFJYSERMRVYgaXMgc2V0LCBhdCBsZWFzdCA4IGJ5dGVzIGFyZSBpbiB0aGUgRklGTyAqLwoJaW5zYihkYXRhLT5zYmFzZSArIFdCQ0lSX1JFR19TUDNfUlhEQVRBLCAmaXJkYXRhWzBdLCA4KTsKCglmb3IgKGkgPSAwOyBpIDwgc2l6ZW9mKGlyZGF0YSk7IGkrKykgewoJCWh3ID0gaHdlaWdodDgoaXJkYXRhW2ldKTsKCQlpZiAoaHcgPiA0KQoJCQlhZGRfaXJkYXRhX2JpdChkYXRhLCAwKTsKCQllbHNlCgkJCWFkZF9pcmRhdGFfYml0KGRhdGEsIDEpOwoKCQlpZiAoaHcgPT0gOCkKCQkJZGF0YS0+aWRsZV9jb3VudCsrOwoJCWVsc2UKCQkJZGF0YS0+aWRsZV9jb3VudCA9IDA7Cgl9CgoJaWYgKGRhdGEtPmlkbGVfY291bnQgPiBXQkNJUl9NQVhfSURMRV9CWVRFUykgewoJCS8qIFNldCBSWElOQUNUSVZFLi4uICovCgkJb3V0YihXQkNJUl9SWF9ESVNBQkxFLCBkYXRhLT5zYmFzZSArIFdCQ0lSX1JFR19TUDNfQVNDUik7CgoJCS8qIC4uLmFuZCBkcmFpbiB0aGUgRklGTyAqLwoJCXdoaWxlIChpbmIoZGF0YS0+c2Jhc2UgKyBXQkNJUl9SRUdfU1AzX0xTUikgJiBXQkNJUl9SWF9BVkFJTCkKCQkJaW5iKGRhdGEtPnNiYXNlICsgV0JDSVJfUkVHX1NQM19SWERBVEEpOwoKCQlkZXZfZGJnKGRldiwgIklSREFUQTpcbiIpOwoJCWZvciAoaSA9IDA7IGkgPCBkYXRhLT5pcmRhdGFfY291bnQ7IGkgKz0gQklUU19QRVJfTE9ORykKCQkJZGV2X2RiZyhkZXYsICIweCUwOGxYXG4iLCBkYXRhLT5pcmRhdGFbaS9CSVRTX1BFUl9MT05HXSk7CgoJCXN3aXRjaCAocHJvdG9jb2wpIHsKCQljYXNlIElSX1BST1RPQ09MX1JDNToKCQkJd2JjaXJfcGFyc2VfcmM1KGRldiwgZGF0YSk7CgkJCWJyZWFrOwoJCWNhc2UgSVJfUFJPVE9DT0xfUkM2OgoJCQl3YmNpcl9wYXJzZV9yYzYoZGV2LCBkYXRhKTsKCQkJYnJlYWs7CgkJY2FzZSBJUl9QUk9UT0NPTF9ORUM6CgkJCXdiY2lyX3BhcnNlX25lYyhkZXYsIGRhdGEpOwoJCQlicmVhazsKCQl9CgoJCXdiY2lyX3Jlc2V0X2lyZGF0YShkYXRhKTsKCX0KCm91dDoKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJndiY2lyX2xvY2ssIGZsYWdzKTsKCXJldHVybiBJUlFfSEFORExFRDsKfQoKCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoKICogU0VUVVAvSU5JVC9TVVNQRU5EL1JFU1VNRSBGVU5DVElPTlMKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKc3RhdGljIHZvaWQKd2JjaXJfc2h1dGRvd24oc3RydWN0IHBucF9kZXYgKmRldmljZSkKewoJc3RydWN0IGRldmljZSAqZGV2ID0gJmRldmljZS0+ZGV2OwoJc3RydWN0IHdiY2lyX2RhdGEgKmRhdGEgPSBwbnBfZ2V0X2RydmRhdGEoZGV2aWNlKTsKCWludCBkb193YWtlID0gMTsKCXU4IG1hdGNoWzExXTsKCXU4IG1hc2tbMTFdOwoJdTggcmM2X2NzbCA9IDA7CglpbnQgaTsKCgltZW1zZXQobWF0Y2gsIDAsIHNpemVvZihtYXRjaCkpOwoJbWVtc2V0KG1hc2ssIDAsIHNpemVvZihtYXNrKSk7CgoJaWYgKHdha2Vfc2MgPT0gSU5WQUxJRF9TQ0FOQ09ERSB8fCAhZGV2aWNlX21heV93YWtldXAoZGV2KSkgewoJCWRvX3dha2UgPSAwOwoJCWdvdG8gZmluaXNoOwoJfQoKCXN3aXRjaCAocHJvdG9jb2wpIHsKCWNhc2UgSVJfUFJPVE9DT0xfUkM1OgoJCWlmICh3YWtlX3NjID4gMHhGRkYpIHsKCQkJZG9fd2FrZSA9IDA7CgkJCWRldl9lcnIoZGV2LCAiUkM1IC0gSW52YWxpZCB3YWtlIHNjYW5jb2RlXG4iKTsKCQkJYnJlYWs7CgkJfQoKCQkvKiBNYXNrID0gMTMgYml0cywgZXggdG9nZ2xlICovCgkJbWFza1swXSA9IDB4RkY7CgkJbWFza1sxXSA9IDB4MTc7CgoJCW1hdGNoWzBdICA9ICh3YWtlX3NjICYgMHgwMDNGKTsgICAgICAvKiA2IGNvbW1hbmQgYml0cyAqLwoJCW1hdGNoWzBdIHw9ICh3YWtlX3NjICYgMHgwMTgwKSA+PiAxOyAvKiAyIGFkZHJlc3MgYml0cyAqLwoJCW1hdGNoWzFdICA9ICh3YWtlX3NjICYgMHgwRTAwKSA+PiA5OyAvKiAzIGFkZHJlc3MgYml0cyAqLwoJCWlmICghKHdha2Vfc2MgJiAweDAwNDApKSAgICAgICAgICAgICAvKiAybmQgc3RhcnQgYml0ICAqLwoJCQltYXRjaFsxXSB8PSAweDEwOwoKCQlicmVhazsKCgljYXNlIElSX1BST1RPQ09MX05FQzoKCQlpZiAod2FrZV9zYyA+IDB4RkZGRkZGKSB7CgkJCWRvX3dha2UgPSAwOwoJCQlkZXZfZXJyKGRldiwgIk5FQyAtIEludmFsaWQgd2FrZSBzY2FuY29kZVxuIik7CgkJCWJyZWFrOwoJCX0KCgkJbWFza1swXSA9IG1hc2tbMV0gPSBtYXNrWzJdID0gbWFza1szXSA9IDB4RkY7CgoJCW1hdGNoWzFdID0gYml0cmV2OCgod2FrZV9zYyAmIDB4RkYpKTsKCQltYXRjaFswXSA9IH5tYXRjaFsxXTsKCgkJbWF0Y2hbM10gPSBiaXRyZXY4KCh3YWtlX3NjICYgMHhGRjAwKSA+PiA4KTsKCQlpZiAod2FrZV9zYyA+IDB4RkZGRikKCQkJbWF0Y2hbMl0gPSBiaXRyZXY4KCh3YWtlX3NjICYgMHhGRjAwMDApID4+IDE2KTsKCQllbHNlCgkJCW1hdGNoWzJdID0gfm1hdGNoWzNdOwoKCQlicmVhazsKCgljYXNlIElSX1BST1RPQ09MX1JDNjoKCgkJaWYgKHdha2VfcmM2bW9kZSA9PSAwKSB7CgkJCWlmICh3YWtlX3NjID4gMHhGRkZGKSB7CgkJCQlkb193YWtlID0gMDsKCQkJCWRldl9lcnIoZGV2LCAiUkM2IC0gSW52YWxpZCB3YWtlIHNjYW5jb2RlXG4iKTsKCQkJCWJyZWFrOwoJCQl9CgoJCQkvKiBDb21tYW5kICovCgkJCW1hdGNoWzBdID0gd2JjaXJfdG9fcmM2Y2VsbHMod2FrZV9zYyA+PiAgMCk7CgkJCW1hc2tbMF0gID0gMHhGRjsKCQkJbWF0Y2hbMV0gPSB3YmNpcl90b19yYzZjZWxscyh3YWtlX3NjID4+ICA0KTsKCQkJbWFza1sxXSAgPSAweEZGOwoKCQkJLyogQWRkcmVzcyAqLwoJCQltYXRjaFsyXSA9IHdiY2lyX3RvX3JjNmNlbGxzKHdha2Vfc2MgPj4gIDgpOwoJCQltYXNrWzJdICA9IDB4RkY7CgkJCW1hdGNoWzNdID0gd2JjaXJfdG9fcmM2Y2VsbHMod2FrZV9zYyA+PiAxMik7CgkJCW1hc2tbM10gID0gMHhGRjsKCgkJCS8qIEhlYWRlciAqLwoJCQltYXRjaFs0XSA9IDB4NTA7IC8qIG1vZGUxID0gbW9kZTAgPSAwLCBpZ25vcmUgdG9nZ2xlICovCgkJCW1hc2tbNF0gID0gMHhGMDsKCQkJbWF0Y2hbNV0gPSAweDA5OyAvKiBzdGFydCBiaXQgPSAxLCBtb2RlMiA9IDAgKi8KCQkJbWFza1s1XSAgPSAweDBGOwoKCQkJcmM2X2NzbCA9IDQ0OwoKCQl9IGVsc2UgaWYgKHdha2VfcmM2bW9kZSA9PSA2KSB7CgkJCWkgPSAwOwoKCQkJLyogQ29tbWFuZCAqLwoJCQltYXRjaFtpXSAgPSB3YmNpcl90b19yYzZjZWxscyh3YWtlX3NjID4+ICAwKTsKCQkJbWFza1tpKytdID0gMHhGRjsKCQkJbWF0Y2hbaV0gID0gd2JjaXJfdG9fcmM2Y2VsbHMod2FrZV9zYyA+PiAgNCk7CgkJCW1hc2tbaSsrXSA9IDB4RkY7CgoJCQkvKiBBZGRyZXNzICsgVG9nZ2xlICovCgkJCW1hdGNoW2ldICA9IHdiY2lyX3RvX3JjNmNlbGxzKHdha2Vfc2MgPj4gIDgpOwoJCQltYXNrW2krK10gPSAweEZGOwoJCQltYXRjaFtpXSAgPSB3YmNpcl90b19yYzZjZWxscyh3YWtlX3NjID4+IDEyKTsKCQkJbWFza1tpKytdID0gMHgzRjsKCgkJCS8qIEN1c3RvbWVyIGJpdHMgNyAtIDAgKi8KCQkJbWF0Y2hbaV0gID0gd2JjaXJfdG9fcmM2Y2VsbHMod2FrZV9zYyA+PiAxNik7CgkJCW1hc2tbaSsrXSA9IDB4RkY7CgkJCW1hdGNoW2ldICA9IHdiY2lyX3RvX3JjNmNlbGxzKHdha2Vfc2MgPj4gMjApOwoJCQltYXNrW2krK10gPSAweEZGOwoKCQkJaWYgKHdha2Vfc2MgJiAweDgwMDAwMDAwKSB7CgkJCQkvKiBDdXN0b21lciByYW5nZSBiaXQgYW5kIGJpdHMgMTUgLSA4ICovCgkJCQltYXRjaFtpXSAgPSB3YmNpcl90b19yYzZjZWxscyh3YWtlX3NjID4+IDI0KTsKCQkJCW1hc2tbaSsrXSA9IDB4RkY7CgkJCQltYXRjaFtpXSAgPSB3YmNpcl90b19yYzZjZWxscyh3YWtlX3NjID4+IDI4KTsKCQkJCW1hc2tbaSsrXSA9IDB4RkY7CgkJCQlyYzZfY3NsID0gNzY7CgkJCX0gZWxzZSBpZiAod2FrZV9zYyA8PSAweDAwN0ZGRkZGKSB7CgkJCQlyYzZfY3NsID0gNjA7CgkJCX0gZWxzZSB7CgkJCQlkb193YWtlID0gMDsKCQkJCWRldl9lcnIoZGV2LCAiUkM2IC0gSW52YWxpZCB3YWtlIHNjYW5jb2RlXG4iKTsKCQkJCWJyZWFrOwoJCQl9CgoJCQkvKiBIZWFkZXIgKi8KCQkJbWF0Y2hbaV0gID0gMHg5MzsgLyogbW9kZTEgPSBtb2RlMCA9IDEsIHN1Ym1vZGUgPSAwICovCgkJCW1hc2tbaSsrXSA9IDB4RkY7CgkJCW1hdGNoW2ldICA9IDB4MEE7IC8qIHN0YXJ0IGJpdCA9IDEsIG1vZGUyID0gMSAqLwoJCQltYXNrW2krK10gPSAweDBGOwoKCQl9IGVsc2UgewoJCQlkb193YWtlID0gMDsKCQkJZGV2X2VycihkZXYsICJSQzYgLSBJbnZhbGlkIHdha2UgbW9kZVxuIik7CgkJfQoKCQlicmVhazsKCglkZWZhdWx0OgoJCWRvX3dha2UgPSAwOwoJCWJyZWFrOwoJfQoKZmluaXNoOgoJaWYgKGRvX3dha2UpIHsKCQkvKiBTZXQgY29tcGFyZSBhbmQgY29tcGFyZSBtYXNrICovCgkJd2JjaXJfc2V0X2JpdHMoZGF0YS0+d2Jhc2UgKyBXQkNJUl9SRUdfV0NFSVJfSU5ERVgsCgkJCSAgICAgICBXQkNJUl9SRUdTRUxfQ09NUEFSRSB8IFdCQ0lSX1JFR19BRERSMCwKCQkJICAgICAgIDB4M0YpOwoJCW91dHNiKGRhdGEtPndiYXNlICsgV0JDSVJfUkVHX1dDRUlSX0RBVEEsIG1hdGNoLCAxMSk7CgkJd2JjaXJfc2V0X2JpdHMoZGF0YS0+d2Jhc2UgKyBXQkNJUl9SRUdfV0NFSVJfSU5ERVgsCgkJCSAgICAgICBXQkNJUl9SRUdTRUxfTUFTSyB8IFdCQ0lSX1JFR19BRERSMCwKCQkJICAgICAgIDB4M0YpOwoJCW91dHNiKGRhdGEtPndiYXNlICsgV0JDSVJfUkVHX1dDRUlSX0RBVEEsIG1hc2ssIDExKTsKCgkJLyogUkM2IENvbXBhcmUgU3RyaW5nIExlbiAqLwoJCW91dGIocmM2X2NzbCwgZGF0YS0+d2Jhc2UgKyBXQkNJUl9SRUdfV0NFSVJfQ1NMKTsKCgkJLyogQ2xlYXIgc3RhdHVzIGJpdHMgTkVDX1JFUCwgQlVGRiwgTVNHX0VORCwgTUFUQ0ggKi8KCQl3YmNpcl9zZXRfYml0cyhkYXRhLT53YmFzZSArIFdCQ0lSX1JFR19XQ0VJUl9TVFMsIDB4MTcsIDB4MTcpOwoKCQkvKiBDbGVhciBCVUZGX0VOLCBDbGVhciBFTkRfRU4sIFNldCBNQVRDSF9FTiAqLwoJCXdiY2lyX3NldF9iaXRzKGRhdGEtPndiYXNlICsgV0JDSVJfUkVHX1dDRUlSX0VWX0VOLCAweDAxLCAweDA3KTsKCgkJLyogU2V0IENFSVJfRU4gKi8KCQl3YmNpcl9zZXRfYml0cyhkYXRhLT53YmFzZSArIFdCQ0lSX1JFR19XQ0VJUl9DVEwsIDB4MDEsIDB4MDEpOwoKCX0gZWxzZSB7CgkJLyogQ2xlYXIgQlVGRl9FTiwgQ2xlYXIgRU5EX0VOLCBDbGVhciBNQVRDSF9FTiAqLwoJCXdiY2lyX3NldF9iaXRzKGRhdGEtPndiYXNlICsgV0JDSVJfUkVHX1dDRUlSX0VWX0VOLCAweDAwLCAweDA3KTsKCgkJLyogQ2xlYXIgQ0VJUl9FTiAqLwoJCXdiY2lyX3NldF9iaXRzKGRhdGEtPndiYXNlICsgV0JDSVJfUkVHX1dDRUlSX0NUTCwgMHgwMCwgMHgwMSk7Cgl9CgoJLyogRGlzYWJsZSBpbnRlcnJ1cHRzICovCgl3YmNpcl9zZWxlY3RfYmFuayhkYXRhLCBXQkNJUl9CQU5LXzApOwoJb3V0YihXQkNJUl9JUlFfTk9ORSwgZGF0YS0+c2Jhc2UgKyBXQkNJUl9SRUdfU1AzX0lFUik7CgoJLyoKCSAqIEFDUEkgd2lsbCBzZXQgdGhlIEhXIGRpc2FibGUgYml0IGZvciBTUDMgd2hpY2ggbWVhbnMgdGhhdCB0aGUKCSAqIG91dHB1dCBzaWduYWxzIGFyZSBsZWZ0IGluIGFuIHVuZGVmaW5lZCBzdGF0ZSB3aGljaCBtYXkgY2F1c2UKCSAqIHNwdXJpb3VzIGludGVycnVwdHMgd2hpY2ggd2UgbmVlZCB0byBpZ25vcmUgdW50aWwgdGhlIGhhcmR3YXJlCgkgKiBpcyByZWluaXRpYWxpemVkLgoJICovCglkaXNhYmxlX2lycShkYXRhLT5pcnEpOwp9CgpzdGF0aWMgaW50CndiY2lyX3N1c3BlbmQoc3RydWN0IHBucF9kZXYgKmRldmljZSwgcG1fbWVzc2FnZV90IHN0YXRlKQp7Cgl3YmNpcl9zaHV0ZG93bihkZXZpY2UpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyB2b2lkCndiY2lyX2luaXRfaHcoc3RydWN0IHdiY2lyX2RhdGEgKmRhdGEpCnsKCXU4IHRtcDsKCgkvKiBEaXNhYmxlIGludGVycnVwdHMgKi8KCXdiY2lyX3NlbGVjdF9iYW5rKGRhdGEsIFdCQ0lSX0JBTktfMCk7CglvdXRiKFdCQ0lSX0lSUV9OT05FLCBkYXRhLT5zYmFzZSArIFdCQ0lSX1JFR19TUDNfSUVSKTsKCgkvKiBTZXQgUFJPVF9TRUwsIFJYX0lOViwgQ2xlYXIgQ0VJUl9FTiAobmVlZGVkIGZvciB0aGUgbGVkKSAqLwoJdG1wID0gcHJvdG9jb2wgPDwgNDsKCWlmIChpbnZlcnQpCgkJdG1wIHw9IDB4MDg7CglvdXRiKHRtcCwgZGF0YS0+d2Jhc2UgKyBXQkNJUl9SRUdfV0NFSVJfQ1RMKTsKCgkvKiBDbGVhciBzdGF0dXMgYml0cyBORUNfUkVQLCBCVUZGLCBNU0dfRU5ELCBNQVRDSCAqLwoJd2JjaXJfc2V0X2JpdHMoZGF0YS0+d2Jhc2UgKyBXQkNJUl9SRUdfV0NFSVJfU1RTLCAweDE3LCAweDE3KTsKCgkvKiBDbGVhciBCVUZGX0VOLCBDbGVhciBFTkRfRU4sIENsZWFyIE1BVENIX0VOICovCgl3YmNpcl9zZXRfYml0cyhkYXRhLT53YmFzZSArIFdCQ0lSX1JFR19XQ0VJUl9FVl9FTiwgMHgwMCwgMHgwNyk7CgoJLyogU2V0IFJDNSBjZWxsIHRpbWUgdG8gY29ycmVzcG9uZCB0byAzNiBrSHogKi8KCXdiY2lyX3NldF9iaXRzKGRhdGEtPndiYXNlICsgV0JDSVJfUkVHX1dDRUlSX0NGRzEsIDB4NEEsIDB4N0YpOwoKCS8qIFNldCBJUlRYX0lOViAqLwoJaWYgKGludmVydCkKCQlvdXRiKDB4MDQsIGRhdGEtPmViYXNlICsgV0JDSVJfUkVHX0VDRUlSX0NDVEwpOwoJZWxzZQoJCW91dGIoMHgwMCwgZGF0YS0+ZWJhc2UgKyBXQkNJUl9SRUdfRUNFSVJfQ0NUTCk7CgoJLyoKCSAqIENsZWFyIElSIExFRCwgc2V0IFNQMyBjbG9jayB0byAyNE1oegoJICogc2V0IFNQM19JUlJYX1NXIHRvIGJpbmFyeSAwMSwgaGVscGZ1bGx5IG5vdCBkb2N1bWVudGVkCgkgKi8KCW91dGIoMHgxMCwgZGF0YS0+ZWJhc2UgKyBXQkNJUl9SRUdfRUNFSVJfQ1RTKTsKCgkvKiBFbmFibGUgZXh0ZW5kZWQgbW9kZSAqLwoJd2JjaXJfc2VsZWN0X2JhbmsoZGF0YSwgV0JDSVJfQkFOS18yKTsKCW91dGIoV0JDSVJfRVhUX0VOQUJMRSwgZGF0YS0+c2Jhc2UgKyBXQkNJUl9SRUdfU1AzX0VYQ1IxKTsKCgkvKgoJICogQ29uZmlndXJlIGJhdWQgZ2VuZXJhdG9yLCBJUiBkYXRhIHdpbGwgYmUgc2FtcGxlZCBhdAoJICogYSBiaXRyYXRlIG9mOiAoMjRNaHogKiBwcmVzY2FsZXIpIC8gKGRpdmlzb3IgKiAxNikuCgkgKgoJICogVGhlIEVDSVIgcmVnaXN0ZXJzIGluY2x1ZGUgYSBmbGFnIHRvIGNoYW5nZSB0aGUKCSAqIDI0TWh6IGNsb2NrIGZyZXEgdG8gNDhNaHouCgkgKgoJICogSXQncyBub3QgZG9jdW1lbnRlZCBpbiB0aGUgc3BlY3MsIGJ1dCBmaWZvIGxldmVscwoJICogb3RoZXIgdGhhbiAxNiBzZWVtcyB0byBiZSB1bnN1cHBvcnRlZC4KCSAqLwoKCS8qIHByZXNjYWxlciAxLjAsIHR4L3J4IGZpZm8gbHZsIDE2ICovCglvdXRiKDB4MzAsIGRhdGEtPnNiYXNlICsgV0JDSVJfUkVHX1NQM19FWENSMik7CgoJLyogU2V0IGJhdWQgZGl2aXNvciB0byBnZW5lcmF0ZSBvbmUgYnl0ZSBwZXIgYml0L2NlbGwgKi8KCXN3aXRjaCAocHJvdG9jb2wpIHsKCWNhc2UgSVJfUFJPVE9DT0xfUkM1OgoJCW91dGIoMHhBNywgZGF0YS0+c2Jhc2UgKyBXQkNJUl9SRUdfU1AzX0JHREwpOwoJCWJyZWFrOwoJY2FzZSBJUl9QUk9UT0NPTF9SQzY6CgkJb3V0YigweDUzLCBkYXRhLT5zYmFzZSArIFdCQ0lSX1JFR19TUDNfQkdETCk7CgkJYnJlYWs7CgljYXNlIElSX1BST1RPQ09MX05FQzoKCQlvdXRiKDB4NjksIGRhdGEtPnNiYXNlICsgV0JDSVJfUkVHX1NQM19CR0RMKTsKCQlicmVhazsKCX0KCW91dGIoMHgwMCwgZGF0YS0+c2Jhc2UgKyBXQkNJUl9SRUdfU1AzX0JHREgpOwoKCS8qIFNldCBDRUlSIG1vZGUgKi8KCXdiY2lyX3NlbGVjdF9iYW5rKGRhdGEsIFdCQ0lSX0JBTktfMCk7CglvdXRiKDB4QzAsIGRhdGEtPnNiYXNlICsgV0JDSVJfUkVHX1NQM19NQ1IpOwoJaW5iKGRhdGEtPnNiYXNlICsgV0JDSVJfUkVHX1NQM19MU1IpOyAvKiBDbGVhciBMU1IgKi8KCWluYihkYXRhLT5zYmFzZSArIFdCQ0lSX1JFR19TUDNfTVNSKTsgLyogQ2xlYXIgTVNSICovCgoJLyogRGlzYWJsZSBSWCBkZW1vZCwgcnVuLWxlbmd0aCBlbmNvZGluZy9kZWNvZGluZywgc2V0IGZyZXEgc3BhbiAqLwoJd2JjaXJfc2VsZWN0X2JhbmsoZGF0YSwgV0JDSVJfQkFOS183KTsKCW91dGIoMHgxMCwgZGF0YS0+c2Jhc2UgKyBXQkNJUl9SRUdfU1AzX1JDQ0ZHKTsKCgkvKiBEaXNhYmxlIHRpbWVyICovCgl3YmNpcl9zZWxlY3RfYmFuayhkYXRhLCBXQkNJUl9CQU5LXzQpOwoJb3V0YigweDAwLCBkYXRhLT5zYmFzZSArIFdCQ0lSX1JFR19TUDNfSVJDUjEpOwoKCS8qIEVuYWJsZSBNU1IgaW50ZXJydXB0LCBDbGVhciBBVVhfSVJYICovCgl3YmNpcl9zZWxlY3RfYmFuayhkYXRhLCBXQkNJUl9CQU5LXzUpOwoJb3V0YigweDAwLCBkYXRhLT5zYmFzZSArIFdCQ0lSX1JFR19TUDNfSVJDUjIpOwoKCS8qIERpc2FibGUgQ1JDICovCgl3YmNpcl9zZWxlY3RfYmFuayhkYXRhLCBXQkNJUl9CQU5LXzYpOwoJb3V0YigweDIwLCBkYXRhLT5zYmFzZSArIFdCQ0lSX1JFR19TUDNfSVJDUjMpOwoKCS8qIFNldCBSWC9UWCAoZGUpbW9kdWxhdGlvbiBmcmVxLCBub3QgcmVhbGx5IHVzZWQgKi8KCXdiY2lyX3NlbGVjdF9iYW5rKGRhdGEsIFdCQ0lSX0JBTktfNyk7CglvdXRiKDB4RjIsIGRhdGEtPnNiYXNlICsgV0JDSVJfUkVHX1NQM19JUlJYREMpOwoJb3V0YigweDY5LCBkYXRhLT5zYmFzZSArIFdCQ0lSX1JFR19TUDNfSVJUWE1DKTsKCgkvKiBTZXQgaW52ZXJ0IGFuZCBwaW4gZGlyZWN0aW9uICovCglpZiAoaW52ZXJ0KQoJCW91dGIoMHgxMCwgZGF0YS0+c2Jhc2UgKyBXQkNJUl9SRUdfU1AzX0lSQ0ZHNCk7CgllbHNlCgkJb3V0YigweDAwLCBkYXRhLT5zYmFzZSArIFdCQ0lSX1JFR19TUDNfSVJDRkc0KTsKCgkvKiBTZXQgRklGTyB0aHJlc2hvbGRzIChSWCA9IDgsIFRYID0gMyksIHJlc2V0IFJYL1RYICovCgl3YmNpcl9zZWxlY3RfYmFuayhkYXRhLCBXQkNJUl9CQU5LXzApOwoJb3V0YigweDk3LCBkYXRhLT5zYmFzZSArIFdCQ0lSX1JFR19TUDNfRkNSKTsKCgkvKiBDbGVhciBBVVggc3RhdHVzIGJpdHMgKi8KCW91dGIoMHhFMCwgZGF0YS0+c2Jhc2UgKyBXQkNJUl9SRUdfU1AzX0FTQ1IpOwoKCS8qIEVuYWJsZSBpbnRlcnJ1cHRzICovCgl3YmNpcl9yZXNldF9pcmRhdGEoZGF0YSk7CglvdXRiKFdCQ0lSX0lSUV9SWCB8IFdCQ0lSX0lSUV9FUlIsIGRhdGEtPnNiYXNlICsgV0JDSVJfUkVHX1NQM19JRVIpOwp9CgpzdGF0aWMgaW50CndiY2lyX3Jlc3VtZShzdHJ1Y3QgcG5wX2RldiAqZGV2aWNlKQp7CglzdHJ1Y3Qgd2JjaXJfZGF0YSAqZGF0YSA9IHBucF9nZXRfZHJ2ZGF0YShkZXZpY2UpOwoKCXdiY2lyX2luaXRfaHcoZGF0YSk7CgllbmFibGVfaXJxKGRhdGEtPmlycSk7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgX19kZXZpbml0CndiY2lyX3Byb2JlKHN0cnVjdCBwbnBfZGV2ICpkZXZpY2UsIGNvbnN0IHN0cnVjdCBwbnBfZGV2aWNlX2lkICpkZXZfaWQpCnsKCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZkZXZpY2UtPmRldjsKCXN0cnVjdCB3YmNpcl9kYXRhICpkYXRhOwoJaW50IGVycjsKCglpZiAoIShwbnBfcG9ydF9sZW4oZGV2aWNlLCAwKSA9PSBFSEZVTkNfSU9NRU1fTEVOICYmCgkgICAgICBwbnBfcG9ydF9sZW4oZGV2aWNlLCAxKSA9PSBXQUtFVVBfSU9NRU1fTEVOICYmCgkgICAgICBwbnBfcG9ydF9sZW4oZGV2aWNlLCAyKSA9PSBTUF9JT01FTV9MRU4pKSB7CgkJZGV2X2VycihkZXYsICJJbnZhbGlkIHJlc291cmNlc1xuIik7CgkJcmV0dXJuIC1FTk9ERVY7Cgl9CgoJZGF0YSA9IGt6YWxsb2Moc2l6ZW9mKCpkYXRhKSwgR0ZQX0tFUk5FTCk7CglpZiAoIWRhdGEpIHsKCQllcnIgPSAtRU5PTUVNOwoJCWdvdG8gZXhpdDsKCX0KCglwbnBfc2V0X2RydmRhdGEoZGV2aWNlLCBkYXRhKTsKCglkYXRhLT5lYmFzZSA9IHBucF9wb3J0X3N0YXJ0KGRldmljZSwgMCk7CglkYXRhLT53YmFzZSA9IHBucF9wb3J0X3N0YXJ0KGRldmljZSwgMSk7CglkYXRhLT5zYmFzZSA9IHBucF9wb3J0X3N0YXJ0KGRldmljZSwgMik7CglkYXRhLT5pcnEgPSBwbnBfaXJxKGRldmljZSwgMCk7CgoJaWYgKGRhdGEtPndiYXNlID09IDAgfHwgZGF0YS0+ZWJhc2UgPT0gMCB8fAoJICAgIGRhdGEtPnNiYXNlID09IDAgfHwgZGF0YS0+aXJxID09IDApIHsKCQllcnIgPSAtRU5PREVWOwoJCWRldl9lcnIoZGV2LCAiSW52YWxpZCByZXNvdXJjZXNcbiIpOwoJCWdvdG8gZXhpdF9mcmVlX2RhdGE7Cgl9CgoJZGV2X2RiZygmZGV2aWNlLT5kZXYsICJGb3VuZCBkZXZpY2UgIgoJCSIodzogMHglbFgsIGU6IDB4JWxYLCBzOiAweCVsWCwgaTogJXUpXG4iLAoJCWRhdGEtPndiYXNlLCBkYXRhLT5lYmFzZSwgZGF0YS0+c2Jhc2UsIGRhdGEtPmlycSk7CgoJaWYgKCFyZXF1ZXN0X3JlZ2lvbihkYXRhLT53YmFzZSwgV0FLRVVQX0lPTUVNX0xFTiwgRFJWTkFNRSkpIHsKCQlkZXZfZXJyKGRldiwgIlJlZ2lvbiAweCVseC0weCVseCBhbHJlYWR5IGluIHVzZSFcbiIsCgkJCWRhdGEtPndiYXNlLCBkYXRhLT53YmFzZSArIFdBS0VVUF9JT01FTV9MRU4gLSAxKTsKCQllcnIgPSAtRUJVU1k7CgkJZ290byBleGl0X2ZyZWVfZGF0YTsKCX0KCglpZiAoIXJlcXVlc3RfcmVnaW9uKGRhdGEtPmViYXNlLCBFSEZVTkNfSU9NRU1fTEVOLCBEUlZOQU1FKSkgewoJCWRldl9lcnIoZGV2LCAiUmVnaW9uIDB4JWx4LTB4JWx4IGFscmVhZHkgaW4gdXNlIVxuIiwKCQkJZGF0YS0+ZWJhc2UsIGRhdGEtPmViYXNlICsgRUhGVU5DX0lPTUVNX0xFTiAtIDEpOwoJCWVyciA9IC1FQlVTWTsKCQlnb3RvIGV4aXRfcmVsZWFzZV93YmFzZTsKCX0KCglpZiAoIXJlcXVlc3RfcmVnaW9uKGRhdGEtPnNiYXNlLCBTUF9JT01FTV9MRU4sIERSVk5BTUUpKSB7CgkJZGV2X2VycihkZXYsICJSZWdpb24gMHglbHgtMHglbHggYWxyZWFkeSBpbiB1c2UhXG4iLAoJCQlkYXRhLT5zYmFzZSwgZGF0YS0+c2Jhc2UgKyBTUF9JT01FTV9MRU4gLSAxKTsKCQllcnIgPSAtRUJVU1k7CgkJZ290byBleGl0X3JlbGVhc2VfZWJhc2U7Cgl9CgoJZXJyID0gcmVxdWVzdF9pcnEoZGF0YS0+aXJxLCB3YmNpcl9pcnFfaGFuZGxlciwKCQkJICBJUlFGX0RJU0FCTEVELCBEUlZOQU1FLCBkZXZpY2UpOwoJaWYgKGVycikgewoJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvIGNsYWltIElSUSAldVxuIiwgZGF0YS0+aXJxKTsKCQllcnIgPSAtRUJVU1k7CgkJZ290byBleGl0X3JlbGVhc2Vfc2Jhc2U7Cgl9CgoJbGVkX3RyaWdnZXJfcmVnaXN0ZXJfc2ltcGxlKCJjaXItdHgiLCAmZGF0YS0+dHh0cmlnZ2VyKTsKCWlmICghZGF0YS0+dHh0cmlnZ2VyKSB7CgkJZXJyID0gLUVOT01FTTsKCQlnb3RvIGV4aXRfZnJlZV9pcnE7Cgl9CgoJbGVkX3RyaWdnZXJfcmVnaXN0ZXJfc2ltcGxlKCJjaXItcngiLCAmZGF0YS0+cnh0cmlnZ2VyKTsKCWlmICghZGF0YS0+cnh0cmlnZ2VyKSB7CgkJZXJyID0gLUVOT01FTTsKCQlnb3RvIGV4aXRfdW5yZWdpc3Rlcl90eHRyaWdnZXI7Cgl9CgoJZGF0YS0+bGVkLm5hbWUgPSAiY2lyOjphY3Rpdml0eSI7CglkYXRhLT5sZWQuZGVmYXVsdF90cmlnZ2VyID0gImNpci1yeCI7CglkYXRhLT5sZWQuYnJpZ2h0bmVzc19zZXQgPSB3YmNpcl9sZWRfYnJpZ2h0bmVzc19zZXQ7CglkYXRhLT5sZWQuYnJpZ2h0bmVzc19nZXQgPSB3YmNpcl9sZWRfYnJpZ2h0bmVzc19nZXQ7CgllcnIgPSBsZWRfY2xhc3NkZXZfcmVnaXN0ZXIoJmRldmljZS0+ZGV2LCAmZGF0YS0+bGVkKTsKCWlmIChlcnIpCgkJZ290byBleGl0X3VucmVnaXN0ZXJfcnh0cmlnZ2VyOwoKCWRhdGEtPmlucHV0X2RldiA9IGlucHV0X2FsbG9jYXRlX2RldmljZSgpOwoJaWYgKCFkYXRhLT5pbnB1dF9kZXYpIHsKCQllcnIgPSAtRU5PTUVNOwoJCWdvdG8gZXhpdF91bnJlZ2lzdGVyX2xlZDsKCX0KCglkYXRhLT5pbnB1dF9kZXYtPmV2Yml0WzBdID0gQklUKEVWX0tFWSk7CglkYXRhLT5pbnB1dF9kZXYtPm5hbWUgPSBXQkNJUl9OQU1FOwoJZGF0YS0+aW5wdXRfZGV2LT5waHlzID0gIndiY2lyL2NpcjAiOwoJZGF0YS0+aW5wdXRfZGV2LT5pZC5idXN0eXBlID0gQlVTX0hPU1Q7CglkYXRhLT5pbnB1dF9kZXYtPmlkLnZlbmRvciAgPSBQQ0lfVkVORE9SX0lEX1dJTkJPTkQ7CglkYXRhLT5pbnB1dF9kZXYtPmlkLnByb2R1Y3QgPSBXQkNJUl9JRF9GQU1JTFk7CglkYXRhLT5pbnB1dF9kZXYtPmlkLnZlcnNpb24gPSBXQkNJUl9JRF9DSElQOwoJZGF0YS0+aW5wdXRfZGV2LT5nZXRrZXljb2RlID0gd2JjaXJfZ2V0a2V5Y29kZTsKCWRhdGEtPmlucHV0X2Rldi0+c2V0a2V5Y29kZSA9IHdiY2lyX3NldGtleWNvZGU7CglpbnB1dF9zZXRfY2FwYWJpbGl0eShkYXRhLT5pbnB1dF9kZXYsIEVWX01TQywgTVNDX1NDQU4pOwoJaW5wdXRfc2V0X2RydmRhdGEoZGF0YS0+aW5wdXRfZGV2LCBkYXRhKTsKCgllcnIgPSBpbnB1dF9yZWdpc3Rlcl9kZXZpY2UoZGF0YS0+aW5wdXRfZGV2KTsKCWlmIChlcnIpCgkJZ290byBleGl0X2ZyZWVfaW5wdXQ7CgoJZGF0YS0+bGFzdF9zY2FuY29kZSA9IElOVkFMSURfU0NBTkNPREU7CglJTklUX0xJU1RfSEVBRCgmZGF0YS0+a2V5dGFibGUpOwoJc2V0dXBfdGltZXIoJmRhdGEtPnRpbWVyX2tleXVwLCB3YmNpcl9rZXl1cCwgKHVuc2lnbmVkIGxvbmcpZGF0YSk7CgoJLyogTG9hZCBkZWZhdWx0IGtleW1hcHMgKi8KCWlmIChwcm90b2NvbCA9PSBJUl9QUk9UT0NPTF9SQzYpIHsKCQlpbnQgaTsKCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShyYzZfZGVmX2tleW1hcCk7IGkrKykgewoJCQllcnIgPSB3YmNpcl9zZXRrZXljb2RlKGRhdGEtPmlucHV0X2RldiwKCQkJCQkgICAgICAgKGludClyYzZfZGVmX2tleW1hcFtpXS5zY2FuY29kZSwKCQkJCQkgICAgICAgKGludClyYzZfZGVmX2tleW1hcFtpXS5rZXljb2RlKTsKCQkJaWYgKGVycikKCQkJCWdvdG8gZXhpdF91bnJlZ2lzdGVyX2tleXM7CgkJfQoJfQoKCWRldmljZV9pbml0X3dha2V1cCgmZGV2aWNlLT5kZXYsIDEpOwoKCXdiY2lyX2luaXRfaHcoZGF0YSk7CgoJcmV0dXJuIDA7CgpleGl0X3VucmVnaXN0ZXJfa2V5czoKCWlmICghbGlzdF9lbXB0eSgmZGF0YS0+a2V5dGFibGUpKSB7CgkJc3RydWN0IHdiY2lyX2tleWVudHJ5ICprZXk7CgkJc3RydWN0IHdiY2lyX2tleWVudHJ5ICprZXl0bXA7CgoJCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShrZXksIGtleXRtcCwgJmRhdGEtPmtleXRhYmxlLCBsaXN0KSB7CgkJCWxpc3RfZGVsKCZrZXktPmxpc3QpOwoJCQlrZnJlZShrZXkpOwoJCX0KCX0KCWlucHV0X3VucmVnaXN0ZXJfZGV2aWNlKGRhdGEtPmlucHV0X2Rldik7CgkvKiBDYW4ndCBjYWxsIGlucHV0X2ZyZWVfZGV2aWNlIG9uIGFuIHVucmVnaXN0ZXJlZCBkZXZpY2UgKi8KCWRhdGEtPmlucHV0X2RldiA9IE5VTEw7CmV4aXRfZnJlZV9pbnB1dDoKCWlucHV0X2ZyZWVfZGV2aWNlKGRhdGEtPmlucHV0X2Rldik7CmV4aXRfdW5yZWdpc3Rlcl9sZWQ6CglsZWRfY2xhc3NkZXZfdW5yZWdpc3RlcigmZGF0YS0+bGVkKTsKZXhpdF91bnJlZ2lzdGVyX3J4dHJpZ2dlcjoKCWxlZF90cmlnZ2VyX3VucmVnaXN0ZXJfc2ltcGxlKGRhdGEtPnJ4dHJpZ2dlcik7CmV4aXRfdW5yZWdpc3Rlcl90eHRyaWdnZXI6CglsZWRfdHJpZ2dlcl91bnJlZ2lzdGVyX3NpbXBsZShkYXRhLT50eHRyaWdnZXIpOwpleGl0X2ZyZWVfaXJxOgoJZnJlZV9pcnEoZGF0YS0+aXJxLCBkZXZpY2UpOwpleGl0X3JlbGVhc2Vfc2Jhc2U6CglyZWxlYXNlX3JlZ2lvbihkYXRhLT5zYmFzZSwgU1BfSU9NRU1fTEVOKTsKZXhpdF9yZWxlYXNlX2ViYXNlOgoJcmVsZWFzZV9yZWdpb24oZGF0YS0+ZWJhc2UsIEVIRlVOQ19JT01FTV9MRU4pOwpleGl0X3JlbGVhc2Vfd2Jhc2U6CglyZWxlYXNlX3JlZ2lvbihkYXRhLT53YmFzZSwgV0FLRVVQX0lPTUVNX0xFTik7CmV4aXRfZnJlZV9kYXRhOgoJa2ZyZWUoZGF0YSk7CglwbnBfc2V0X2RydmRhdGEoZGV2aWNlLCBOVUxMKTsKZXhpdDoKCXJldHVybiBlcnI7Cn0KCnN0YXRpYyB2b2lkIF9fZGV2ZXhpdAp3YmNpcl9yZW1vdmUoc3RydWN0IHBucF9kZXYgKmRldmljZSkKewoJc3RydWN0IHdiY2lyX2RhdGEgKmRhdGEgPSBwbnBfZ2V0X2RydmRhdGEoZGV2aWNlKTsKCXN0cnVjdCB3YmNpcl9rZXllbnRyeSAqa2V5OwoJc3RydWN0IHdiY2lyX2tleWVudHJ5ICprZXl0bXA7CgoJLyogRGlzYWJsZSBpbnRlcnJ1cHRzICovCgl3YmNpcl9zZWxlY3RfYmFuayhkYXRhLCBXQkNJUl9CQU5LXzApOwoJb3V0YihXQkNJUl9JUlFfTk9ORSwgZGF0YS0+c2Jhc2UgKyBXQkNJUl9SRUdfU1AzX0lFUik7CgoJZGVsX3RpbWVyX3N5bmMoJmRhdGEtPnRpbWVyX2tleXVwKTsKCglmcmVlX2lycShkYXRhLT5pcnEsIGRldmljZSk7CgoJLyogQ2xlYXIgc3RhdHVzIGJpdHMgTkVDX1JFUCwgQlVGRiwgTVNHX0VORCwgTUFUQ0ggKi8KCXdiY2lyX3NldF9iaXRzKGRhdGEtPndiYXNlICsgV0JDSVJfUkVHX1dDRUlSX1NUUywgMHgxNywgMHgxNyk7CgoJLyogQ2xlYXIgQ0VJUl9FTiAqLwoJd2JjaXJfc2V0X2JpdHMoZGF0YS0+d2Jhc2UgKyBXQkNJUl9SRUdfV0NFSVJfQ1RMLCAweDAwLCAweDAxKTsKCgkvKiBDbGVhciBCVUZGX0VOLCBFTkRfRU4sIE1BVENIX0VOICovCgl3YmNpcl9zZXRfYml0cyhkYXRhLT53YmFzZSArIFdCQ0lSX1JFR19XQ0VJUl9FVl9FTiwgMHgwMCwgMHgwNyk7CgoJLyogVGhpcyB3aWxsIGdlbmVyYXRlIGEga2V5dXAgZXZlbnQgaWYgbmVjZXNzYXJ5ICovCglpbnB1dF91bnJlZ2lzdGVyX2RldmljZShkYXRhLT5pbnB1dF9kZXYpOwoKCWxlZF90cmlnZ2VyX3VucmVnaXN0ZXJfc2ltcGxlKGRhdGEtPnJ4dHJpZ2dlcik7CglsZWRfdHJpZ2dlcl91bnJlZ2lzdGVyX3NpbXBsZShkYXRhLT50eHRyaWdnZXIpOwoJbGVkX2NsYXNzZGV2X3VucmVnaXN0ZXIoJmRhdGEtPmxlZCk7CgoJLyogVGhpcyBpcyBvayBzaW5jZSAmZGF0YS0+bGVkIGlzbid0IGFjdHVhbGx5IHVzZWQgKi8KCXdiY2lyX2xlZF9icmlnaHRuZXNzX3NldCgmZGF0YS0+bGVkLCBMRURfT0ZGKTsKCglyZWxlYXNlX3JlZ2lvbihkYXRhLT53YmFzZSwgV0FLRVVQX0lPTUVNX0xFTik7CglyZWxlYXNlX3JlZ2lvbihkYXRhLT5lYmFzZSwgRUhGVU5DX0lPTUVNX0xFTik7CglyZWxlYXNlX3JlZ2lvbihkYXRhLT5zYmFzZSwgU1BfSU9NRU1fTEVOKTsKCglsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoa2V5LCBrZXl0bXAsICZkYXRhLT5rZXl0YWJsZSwgbGlzdCkgewoJCWxpc3RfZGVsKCZrZXktPmxpc3QpOwoJCWtmcmVlKGtleSk7Cgl9CgoJa2ZyZWUoZGF0YSk7CgoJcG5wX3NldF9kcnZkYXRhKGRldmljZSwgTlVMTCk7Cn0KCnN0YXRpYyBjb25zdCBzdHJ1Y3QgcG5wX2RldmljZV9pZCB3YmNpcl9pZHNbXSA9IHsKCXsgIldFQzEwMjIiLCAwIH0sCgl7ICIiLCAwIH0KfTsKTU9EVUxFX0RFVklDRV9UQUJMRShwbnAsIHdiY2lyX2lkcyk7CgpzdGF0aWMgc3RydWN0IHBucF9kcml2ZXIgd2JjaXJfZHJpdmVyID0gewoJLm5hbWUgICAgID0gV0JDSVJfTkFNRSwKCS5pZF90YWJsZSA9IHdiY2lyX2lkcywKCS5wcm9iZSAgICA9IHdiY2lyX3Byb2JlLAoJLnJlbW92ZSAgID0gX19kZXZleGl0X3Aod2JjaXJfcmVtb3ZlKSwKCS5zdXNwZW5kICA9IHdiY2lyX3N1c3BlbmQsCgkucmVzdW1lICAgPSB3YmNpcl9yZXN1bWUsCgkuc2h1dGRvd24gPSB3YmNpcl9zaHV0ZG93bgp9OwoKc3RhdGljIGludCBfX2luaXQKd2JjaXJfaW5pdCh2b2lkKQp7CglpbnQgcmV0OwoKCXN3aXRjaCAocHJvdG9jb2wpIHsKCWNhc2UgSVJfUFJPVE9DT0xfUkM1OgoJY2FzZSBJUl9QUk9UT0NPTF9ORUM6CgljYXNlIElSX1BST1RPQ09MX1JDNjoKCQlicmVhazsKCWRlZmF1bHQ6CgkJcHJpbnRrKEtFUk5fRVJSIERSVk5BTUUgIjogSW52YWxpZCBwcm90b2NvbCBhcmd1bWVudFxuIik7CgkJcmV0dXJuIC1FSU5WQUw7Cgl9CgoJcmV0ID0gcG5wX3JlZ2lzdGVyX2RyaXZlcigmd2JjaXJfZHJpdmVyKTsKCWlmIChyZXQpCgkJcHJpbnRrKEtFUk5fRVJSIERSVk5BTUUgIjogVW5hYmxlIHRvIHJlZ2lzdGVyIGRyaXZlclxuIik7CgoJcmV0dXJuIHJldDsKfQoKc3RhdGljIHZvaWQgX19leGl0CndiY2lyX2V4aXQodm9pZCkKewoJcG5wX3VucmVnaXN0ZXJfZHJpdmVyKCZ3YmNpcl9kcml2ZXIpOwp9CgpNT0RVTEVfQVVUSE9SKCJEYXZpZCBI5HJkZW1hbiA8ZGF2aWRAaGFyZGVtYW4ubnU+Iik7Ck1PRFVMRV9ERVNDUklQVElPTigiV2luYm9uZCBTdXBlckkvTyBDb25zdW1lciBJUiBEcml2ZXIiKTsKTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwoKbW9kdWxlX2luaXQod2JjaXJfaW5pdCk7Cm1vZHVsZV9leGl0KHdiY2lyX2V4aXQpOwoKCg==