LyogcmFkZW9uX3N0YXRlLmMgLS0gU3RhdGUgc3VwcG9ydCBmb3IgUmFkZW9uIC0qLSBsaW51eC1jIC0qLQogKgogKiBDb3B5cmlnaHQgMjAwMCBWQSBMaW51eCBTeXN0ZW1zLCBJbmMuLCBGcmVtb250LCBDYWxpZm9ybmlhLgogKiBBbGwgUmlnaHRzIFJlc2VydmVkLgogKgogKiBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYQogKiBjb3B5IG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhlICJTb2Z0d2FyZSIpLAogKiB0byBkZWFsIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uCiAqIHRoZSByaWdodHMgdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLAogKiBhbmQvb3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUKICogU29mdHdhcmUgaXMgZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKICoKICogVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2UgKGluY2x1ZGluZyB0aGUgbmV4dAogKiBwYXJhZ3JhcGgpIHNoYWxsIGJlIGluY2x1ZGVkIGluIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlCiAqIFNvZnR3YXJlLgogKgogKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgogKiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSwKICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gIElOIE5PIEVWRU5UIFNIQUxMCiAqIFBSRUNJU0lPTiBJTlNJR0hUIEFORC9PUiBJVFMgU1VQUExJRVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SCiAqIE9USEVSIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLAogKiBBUklTSU5HIEZST00sIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIKICogREVBTElOR1MgSU4gVEhFIFNPRlRXQVJFLgogKgogKiBBdXRob3JzOgogKiAgICBHYXJldGggSHVnaGVzIDxnYXJldGhAdmFsaW51eC5jb20+CiAqICAgIEtldmluIEUuIE1hcnRpbiA8bWFydGluQHZhbGludXguY29tPgogKi8KCiNpbmNsdWRlICJkcm1QLmgiCiNpbmNsdWRlICJkcm0uaCIKI2luY2x1ZGUgImRybV9zYXJlYS5oIgojaW5jbHVkZSAicmFkZW9uX2RybS5oIgojaW5jbHVkZSAicmFkZW9uX2Rydi5oIgoKLyogPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogKiBIZWxwZXIgZnVuY3Rpb25zIGZvciBjbGllbnQgc3RhdGUgY2hlY2tpbmcgYW5kIGZpeHVwCiAqLwoKc3RhdGljIF9faW5saW5lX18gaW50IHJhZGVvbl9jaGVja19hbmRfZml4dXBfb2Zmc2V0KCBkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYsCgkJCQkJCSAgICAgZHJtX2ZpbGVfdCAqZmlscF9wcml2LAoJCQkJCQkgICAgIHUzMiAqb2Zmc2V0ICkgewoJdTMyIG9mZiA9ICpvZmZzZXQ7CglzdHJ1Y3QgZHJtX3JhZGVvbl9kcml2ZXJfZmlsZV9maWVsZHMgKnJhZGVvbl9wcml2OwoKCWlmICggb2ZmID49IGRldl9wcml2LT5mYl9sb2NhdGlvbiAmJgoJICAgICBvZmYgPCAoIGRldl9wcml2LT5nYXJ0X3ZtX3N0YXJ0ICsgZGV2X3ByaXYtPmdhcnRfc2l6ZSApICkKCQlyZXR1cm4gMDsKCglyYWRlb25fcHJpdiA9IGZpbHBfcHJpdi0+ZHJpdmVyX3ByaXY7CglvZmYgKz0gcmFkZW9uX3ByaXYtPnJhZGVvbl9mYl9kZWx0YTsKCglEUk1fREVCVUcoICJvZmZzZXQgZml4ZWQgdXAgdG8gMHgleFxuIiwgb2ZmICk7CgoJaWYgKCBvZmYgPCBkZXZfcHJpdi0+ZmJfbG9jYXRpb24gfHwKCSAgICAgb2ZmID49ICggZGV2X3ByaXYtPmdhcnRfdm1fc3RhcnQgKyBkZXZfcHJpdi0+Z2FydF9zaXplICkgKQoJCXJldHVybiBEUk1fRVJSKCBFSU5WQUwgKTsKCgkqb2Zmc2V0ID0gb2ZmOwoKCXJldHVybiAwOwp9CgpzdGF0aWMgX19pbmxpbmVfXyBpbnQgcmFkZW9uX2NoZWNrX2FuZF9maXh1cF9wYWNrZXRzKCBkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYsCgkJCQkJCSAgICAgIGRybV9maWxlX3QgKmZpbHBfcHJpdiwKCQkJCQkJICAgICAgaW50IGlkLAoJCQkJCQkgICAgICB1MzIgX191c2VyICpkYXRhICkgewoJc3dpdGNoICggaWQgKSB7CgoJY2FzZSBSQURFT05fRU1JVF9QUF9NSVNDOgoJCWlmICggcmFkZW9uX2NoZWNrX2FuZF9maXh1cF9vZmZzZXQoIGRldl9wcml2LCBmaWxwX3ByaXYsCgkJCQkJCSAgICAmZGF0YVsoIFJBREVPTl9SQjNEX0RFUFRIT0ZGU0VUCgkJCQkJCQkgICAgLSBSQURFT05fUFBfTUlTQyApIC8gNF0gKSApIHsKCQkJRFJNX0VSUk9SKCAiSW52YWxpZCBkZXB0aCBidWZmZXIgb2Zmc2V0XG4iICk7CgkJCXJldHVybiBEUk1fRVJSKCBFSU5WQUwgKTsKCQl9CgkJYnJlYWs7CgoJY2FzZSBSQURFT05fRU1JVF9QUF9DTlRMOgoJCWlmICggcmFkZW9uX2NoZWNrX2FuZF9maXh1cF9vZmZzZXQoIGRldl9wcml2LCBmaWxwX3ByaXYsCgkJCQkJCSAgICAmZGF0YVsoIFJBREVPTl9SQjNEX0NPTE9ST0ZGU0VUCgkJCQkJCQkgICAgLSBSQURFT05fUFBfQ05UTCApIC8gNF0gKSApIHsKCQkJRFJNX0VSUk9SKCAiSW52YWxpZCBjb2xvdXIgYnVmZmVyIG9mZnNldFxuIiApOwoJCQlyZXR1cm4gRFJNX0VSUiggRUlOVkFMICk7CgkJfQoJCWJyZWFrOwoKCWNhc2UgUjIwMF9FTUlUX1BQX1RYT0ZGU0VUXzA6CgljYXNlIFIyMDBfRU1JVF9QUF9UWE9GRlNFVF8xOgoJY2FzZSBSMjAwX0VNSVRfUFBfVFhPRkZTRVRfMjoKCWNhc2UgUjIwMF9FTUlUX1BQX1RYT0ZGU0VUXzM6CgljYXNlIFIyMDBfRU1JVF9QUF9UWE9GRlNFVF80OgoJY2FzZSBSMjAwX0VNSVRfUFBfVFhPRkZTRVRfNToKCQlpZiAoIHJhZGVvbl9jaGVja19hbmRfZml4dXBfb2Zmc2V0KCBkZXZfcHJpdiwgZmlscF9wcml2LAoJCQkJCQkgICAgJmRhdGFbMF0gKSApIHsKCQkJRFJNX0VSUk9SKCAiSW52YWxpZCBSMjAwIHRleHR1cmUgb2Zmc2V0XG4iICk7CgkJCXJldHVybiBEUk1fRVJSKCBFSU5WQUwgKTsKCQl9CgkJYnJlYWs7CgoJY2FzZSBSQURFT05fRU1JVF9QUF9UWEZJTFRFUl8wOgoJY2FzZSBSQURFT05fRU1JVF9QUF9UWEZJTFRFUl8xOgoJY2FzZSBSQURFT05fRU1JVF9QUF9UWEZJTFRFUl8yOgoJCWlmICggcmFkZW9uX2NoZWNrX2FuZF9maXh1cF9vZmZzZXQoIGRldl9wcml2LCBmaWxwX3ByaXYsCgkJCQkJCSAgICAmZGF0YVsoIFJBREVPTl9QUF9UWE9GRlNFVF8wCgkJCQkJCQkgICAgLSBSQURFT05fUFBfVFhGSUxURVJfMCApIC8gNF0gKSApIHsKCQkJRFJNX0VSUk9SKCAiSW52YWxpZCBSMTAwIHRleHR1cmUgb2Zmc2V0XG4iICk7CgkJCXJldHVybiBEUk1fRVJSKCBFSU5WQUwgKTsKCQl9CgkJYnJlYWs7CgoJY2FzZSBSMjAwX0VNSVRfUFBfQ1VCSUNfT0ZGU0VUU18wOgoJY2FzZSBSMjAwX0VNSVRfUFBfQ1VCSUNfT0ZGU0VUU18xOgoJY2FzZSBSMjAwX0VNSVRfUFBfQ1VCSUNfT0ZGU0VUU18yOgoJY2FzZSBSMjAwX0VNSVRfUFBfQ1VCSUNfT0ZGU0VUU18zOgoJY2FzZSBSMjAwX0VNSVRfUFBfQ1VCSUNfT0ZGU0VUU180OgoJY2FzZSBSMjAwX0VNSVRfUFBfQ1VCSUNfT0ZGU0VUU181OiB7CgkJaW50IGk7CgkJZm9yICggaSA9IDA7IGkgPCA1OyBpKysgKSB7CgkJCWlmICggcmFkZW9uX2NoZWNrX2FuZF9maXh1cF9vZmZzZXQoIGRldl9wcml2LCBmaWxwX3ByaXYsCgkJCQkJCQkgICAgJmRhdGFbaV0gKSApIHsKCQkJCURSTV9FUlJPUiggIkludmFsaWQgUjIwMCBjdWJpYyB0ZXh0dXJlIG9mZnNldFxuIiApOwoJCQkJcmV0dXJuIERSTV9FUlIoIEVJTlZBTCApOwoJCQl9CgkJfQoJCWJyZWFrOwoJfQoKCWNhc2UgUkFERU9OX0VNSVRfUFBfQ1VCSUNfT0ZGU0VUU19UMDoKCWNhc2UgUkFERU9OX0VNSVRfUFBfQ1VCSUNfT0ZGU0VUU19UMToKCWNhc2UgUkFERU9OX0VNSVRfUFBfQ1VCSUNfT0ZGU0VUU19UMjp7CgkJCWludCBpOwoJCQlmb3IgKGkgPSAwOyBpIDwgNTsgaSsrKSB7CgkJCQlpZiAocmFkZW9uX2NoZWNrX2FuZF9maXh1cF9vZmZzZXQoZGV2X3ByaXYsCgkJCQkJCQkJICBmaWxwX3ByaXYsCgkJCQkJCQkJICAmZGF0YVtpXSkpIHsKCQkJCQlEUk1fRVJST1IKCQkJCQkgICAgKCJJbnZhbGlkIFIxMDAgY3ViaWMgdGV4dHVyZSBvZmZzZXRcbiIpOwoJCQkJCXJldHVybiBEUk1fRVJSKEVJTlZBTCk7CgkJCQl9CgkJCX0KCQl9CgkJYnJlYWs7CgoJY2FzZSBSQURFT05fRU1JVF9SQjNEX0NPTE9SUElUQ0g6CgljYXNlIFJBREVPTl9FTUlUX1JFX0xJTkVfUEFUVEVSTjoKCWNhc2UgUkFERU9OX0VNSVRfU0VfTElORV9XSURUSDoKCWNhc2UgUkFERU9OX0VNSVRfUFBfTFVNX01BVFJJWDoKCWNhc2UgUkFERU9OX0VNSVRfUFBfUk9UX01BVFJJWF8wOgoJY2FzZSBSQURFT05fRU1JVF9SQjNEX1NURU5DSUxSRUZNQVNLOgoJY2FzZSBSQURFT05fRU1JVF9TRV9WUE9SVF9YU0NBTEU6CgljYXNlIFJBREVPTl9FTUlUX1NFX0NOVEw6CgljYXNlIFJBREVPTl9FTUlUX1NFX0NOVExfU1RBVFVTOgoJY2FzZSBSQURFT05fRU1JVF9SRV9NSVNDOgoJY2FzZSBSQURFT05fRU1JVF9QUF9CT1JERVJfQ09MT1JfMDoKCWNhc2UgUkFERU9OX0VNSVRfUFBfQk9SREVSX0NPTE9SXzE6CgljYXNlIFJBREVPTl9FTUlUX1BQX0JPUkRFUl9DT0xPUl8yOgoJY2FzZSBSQURFT05fRU1JVF9TRV9aQklBU19GQUNUT1I6CgljYXNlIFJBREVPTl9FTUlUX1NFX1RDTF9PVVRQVVRfVlRYX0ZNVDoKCWNhc2UgUkFERU9OX0VNSVRfU0VfVENMX01BVEVSSUFMX0VNTUlTU0lWRV9SRUQ6CgljYXNlIFIyMDBfRU1JVF9QUF9UWENCTEVORF8wOgoJY2FzZSBSMjAwX0VNSVRfUFBfVFhDQkxFTkRfMToKCWNhc2UgUjIwMF9FTUlUX1BQX1RYQ0JMRU5EXzI6CgljYXNlIFIyMDBfRU1JVF9QUF9UWENCTEVORF8zOgoJY2FzZSBSMjAwX0VNSVRfUFBfVFhDQkxFTkRfNDoKCWNhc2UgUjIwMF9FTUlUX1BQX1RYQ0JMRU5EXzU6CgljYXNlIFIyMDBfRU1JVF9QUF9UWENCTEVORF82OgoJY2FzZSBSMjAwX0VNSVRfUFBfVFhDQkxFTkRfNzoKCWNhc2UgUjIwMF9FTUlUX1RDTF9MSUdIVF9NT0RFTF9DVExfMDoKCWNhc2UgUjIwMF9FTUlUX1RGQUNUT1JfMDoKCWNhc2UgUjIwMF9FTUlUX1ZUWF9GTVRfMDoKCWNhc2UgUjIwMF9FTUlUX1ZBUF9DVEw6CgljYXNlIFIyMDBfRU1JVF9NQVRSSVhfU0VMRUNUXzA6CgljYXNlIFIyMDBfRU1JVF9URVhfUFJPQ19DVExfMjoKCWNhc2UgUjIwMF9FTUlUX1RDTF9VQ1BfVkVSVF9CTEVORF9DVEw6CgljYXNlIFIyMDBfRU1JVF9QUF9UWEZJTFRFUl8wOgoJY2FzZSBSMjAwX0VNSVRfUFBfVFhGSUxURVJfMToKCWNhc2UgUjIwMF9FTUlUX1BQX1RYRklMVEVSXzI6CgljYXNlIFIyMDBfRU1JVF9QUF9UWEZJTFRFUl8zOgoJY2FzZSBSMjAwX0VNSVRfUFBfVFhGSUxURVJfNDoKCWNhc2UgUjIwMF9FTUlUX1BQX1RYRklMVEVSXzU6CgljYXNlIFIyMDBfRU1JVF9WVEVfQ05UTDoKCWNhc2UgUjIwMF9FTUlUX09VVFBVVF9WVFhfQ09NUF9TRUw6CgljYXNlIFIyMDBfRU1JVF9QUF9UQU1fREVCVUczOgoJY2FzZSBSMjAwX0VNSVRfUFBfQ05UTF9YOgoJY2FzZSBSMjAwX0VNSVRfUkIzRF9ERVBUSFhZX09GRlNFVDoKCWNhc2UgUjIwMF9FTUlUX1JFX0FVWF9TQ0lTU09SX0NOVEw6CgljYXNlIFIyMDBfRU1JVF9SRV9TQ0lTU09SX1RMXzA6CgljYXNlIFIyMDBfRU1JVF9SRV9TQ0lTU09SX1RMXzE6CgljYXNlIFIyMDBfRU1JVF9SRV9TQ0lTU09SX1RMXzI6CgljYXNlIFIyMDBfRU1JVF9TRV9WQVBfQ05UTF9TVEFUVVM6CgljYXNlIFIyMDBfRU1JVF9TRV9WVFhfU1RBVEVfQ05UTDoKCWNhc2UgUjIwMF9FTUlUX1JFX1BPSU5UU0laRToKCWNhc2UgUjIwMF9FTUlUX1RDTF9JTlBVVF9WVFhfVkVDVE9SX0FERFJfMDoKCWNhc2UgUjIwMF9FTUlUX1BQX0NVQklDX0ZBQ0VTXzA6CgljYXNlIFIyMDBfRU1JVF9QUF9DVUJJQ19GQUNFU18xOgoJY2FzZSBSMjAwX0VNSVRfUFBfQ1VCSUNfRkFDRVNfMjoKCWNhc2UgUjIwMF9FTUlUX1BQX0NVQklDX0ZBQ0VTXzM6CgljYXNlIFIyMDBfRU1JVF9QUF9DVUJJQ19GQUNFU180OgoJY2FzZSBSMjAwX0VNSVRfUFBfQ1VCSUNfRkFDRVNfNToKCWNhc2UgUkFERU9OX0VNSVRfUFBfVEVYX1NJWkVfMDoKCWNhc2UgUkFERU9OX0VNSVRfUFBfVEVYX1NJWkVfMToKCWNhc2UgUkFERU9OX0VNSVRfUFBfVEVYX1NJWkVfMjoKCWNhc2UgUjIwMF9FTUlUX1JCM0RfQkxFTkRDT0xPUjoKCWNhc2UgUjIwMF9FTUlUX1RDTF9QT0lOVF9TUFJJVEVfQ05UTDoKCWNhc2UgUkFERU9OX0VNSVRfUFBfQ1VCSUNfRkFDRVNfMDoKCWNhc2UgUkFERU9OX0VNSVRfUFBfQ1VCSUNfRkFDRVNfMToKCWNhc2UgUkFERU9OX0VNSVRfUFBfQ1VCSUNfRkFDRVNfMjoKCWNhc2UgUjIwMF9FTUlUX1BQX1RSSV9QRVJGX0NOVEw6CgkJLyogVGhlc2UgcGFja2V0cyBkb24ndCBjb250YWluIG1lbW9yeSBvZmZzZXRzICovCgkJYnJlYWs7CgoJZGVmYXVsdDoKCQlEUk1fRVJST1IoICJVbmtub3duIHN0YXRlIHBhY2tldCBJRCAlZFxuIiwgaWQgKTsKCQlyZXR1cm4gRFJNX0VSUiggRUlOVkFMICk7Cgl9CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBfX2lubGluZV9fIGludCByYWRlb25fY2hlY2tfYW5kX2ZpeHVwX3BhY2tldDMoIGRybV9yYWRlb25fcHJpdmF0ZV90ICpkZXZfcHJpdiwKCQkJCQkJICAgICAgZHJtX2ZpbGVfdCAqZmlscF9wcml2LAoJCQkJCQkgICAgICBkcm1fcmFkZW9uX2NtZF9idWZmZXJfdCAqY21kYnVmLAoJCQkJCQkgICAgICB1bnNpZ25lZCBpbnQgKmNtZHN6ICkgewoJdTMyICpjbWQgPSAodTMyICopIGNtZGJ1Zi0+YnVmOwoKCSpjbWRzeiA9IDIgKyAoICggY21kWzBdICYgUkFERU9OX0NQX1BBQ0tFVF9DT1VOVF9NQVNLICkgPj4gMTYgKTsKCglpZiAoICggY21kWzBdICYgMHhjMDAwMDAwMCApICE9IFJBREVPTl9DUF9QQUNLRVQzICkgewoJCURSTV9FUlJPUiggIk5vdCBhIHR5cGUgMyBwYWNrZXRcbiIgKTsKCQlyZXR1cm4gRFJNX0VSUiggRUlOVkFMICk7Cgl9CgoJaWYgKCA0ICogKmNtZHN6ID4gY21kYnVmLT5idWZzeiApIHsKCQlEUk1fRVJST1IoICJQYWNrZXQgc2l6ZSBsYXJnZXIgdGhhbiBzaXplIG9mIGRhdGEgcHJvdmlkZWRcbiIgKTsKCQlyZXR1cm4gRFJNX0VSUiggRUlOVkFMICk7Cgl9CgoJLyogQ2hlY2sgY2xpZW50IHN0YXRlIGFuZCBmaXggaXQgdXAgaWYgbmVjZXNzYXJ5ICovCglpZiAoIGNtZFswXSAmIDB4ODAwMCApIHsgLyogTVNCIG9mIG9wY29kZTogbmV4dCBEV09SRCBHVUlfQ05UTCAqLwoJCXUzMiBvZmZzZXQ7CgoJCWlmICggY21kWzFdICYgKCBSQURFT05fR01DX1NSQ19QSVRDSF9PRkZTRVRfQ05UTAoJCQkgICAgICB8IFJBREVPTl9HTUNfRFNUX1BJVENIX09GRlNFVF9DTlRMICkgKSB7CgkJCW9mZnNldCA9IGNtZFsyXSA8PCAxMDsKCQkJaWYgKCByYWRlb25fY2hlY2tfYW5kX2ZpeHVwX29mZnNldCggZGV2X3ByaXYsIGZpbHBfcHJpdiwgJm9mZnNldCApICkgewoJCQkJRFJNX0VSUk9SKCAiSW52YWxpZCBmaXJzdCBwYWNrZXQgb2Zmc2V0XG4iICk7CgkJCQlyZXR1cm4gRFJNX0VSUiggRUlOVkFMICk7CgkJCX0KCQkJY21kWzJdID0gKCBjbWRbMl0gJiAweGZmYzAwMDAwICkgfCBvZmZzZXQgPj4gMTA7CgkJfQoKCQlpZiAoICggY21kWzFdICYgUkFERU9OX0dNQ19TUkNfUElUQ0hfT0ZGU0VUX0NOVEwgKSAmJgoJCSAgICAgKCBjbWRbMV0gJiBSQURFT05fR01DX0RTVF9QSVRDSF9PRkZTRVRfQ05UTCApICkgewoJCQlvZmZzZXQgPSBjbWRbM10gPDwgMTA7CgkJCWlmICggcmFkZW9uX2NoZWNrX2FuZF9maXh1cF9vZmZzZXQoIGRldl9wcml2LCBmaWxwX3ByaXYsICZvZmZzZXQgKSApIHsKCQkJCURSTV9FUlJPUiggIkludmFsaWQgc2Vjb25kIHBhY2tldCBvZmZzZXRcbiIgKTsKCQkJCXJldHVybiBEUk1fRVJSKCBFSU5WQUwgKTsKCQkJfQoJCQljbWRbM10gPSAoIGNtZFszXSAmIDB4ZmZjMDAwMDAgKSB8IG9mZnNldCA+PiAxMDsKCQl9Cgl9CgoJcmV0dXJuIDA7Cn0KCgovKiA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAqIENQIGhhcmR3YXJlIHN0YXRlIHByb2dyYW1taW5nIGZ1bmN0aW9ucwogKi8KCnN0YXRpYyBfX2lubGluZV9fIHZvaWQgcmFkZW9uX2VtaXRfY2xpcF9yZWN0KCBkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYsCgkJCQkJICBkcm1fY2xpcF9yZWN0X3QgKmJveCApCnsKCVJJTkdfTE9DQUxTOwoKCURSTV9ERUJVRyggIiAgIGJveDogIHgxPSVkIHkxPSVkICB4Mj0lZCB5Mj0lZFxuIiwKCQkgICBib3gtPngxLCBib3gtPnkxLCBib3gtPngyLCBib3gtPnkyICk7CgoJQkVHSU5fUklORyggNCApOwoJT1VUX1JJTkcoIENQX1BBQ0tFVDAoIFJBREVPTl9SRV9UT1BfTEVGVCwgMCApICk7CglPVVRfUklORyggKGJveC0+eTEgPDwgMTYpIHwgYm94LT54MSApOwoJT1VUX1JJTkcoIENQX1BBQ0tFVDAoIFJBREVPTl9SRV9XSURUSF9IRUlHSFQsIDAgKSApOwoJT1VUX1JJTkcoICgoYm94LT55MiAtIDEpIDw8IDE2KSB8IChib3gtPngyIC0gMSkgKTsKCUFEVkFOQ0VfUklORygpOwp9CgovKiBFbWl0IDEuMSBzdGF0ZQogKi8Kc3RhdGljIGludCByYWRlb25fZW1pdF9zdGF0ZSggZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2LAoJCQkgICAgICBkcm1fZmlsZV90ICpmaWxwX3ByaXYsCgkJCSAgICAgIGRybV9yYWRlb25fY29udGV4dF9yZWdzX3QgKmN0eCwKCQkJICAgICAgZHJtX3JhZGVvbl90ZXh0dXJlX3JlZ3NfdCAqdGV4LAoJCQkgICAgICB1bnNpZ25lZCBpbnQgZGlydHkgKQp7CglSSU5HX0xPQ0FMUzsKCURSTV9ERUJVRyggImRpcnR5PTB4JTA4eFxuIiwgZGlydHkgKTsKCglpZiAoIGRpcnR5ICYgUkFERU9OX1VQTE9BRF9DT05URVhUICkgewoJCWlmICggcmFkZW9uX2NoZWNrX2FuZF9maXh1cF9vZmZzZXQoIGRldl9wcml2LCBmaWxwX3ByaXYsCgkJCQkJCSAgICAmY3R4LT5yYjNkX2RlcHRob2Zmc2V0ICkgKSB7CgkJCURSTV9FUlJPUiggIkludmFsaWQgZGVwdGggYnVmZmVyIG9mZnNldFxuIiApOwoJCQlyZXR1cm4gRFJNX0VSUiggRUlOVkFMICk7CgkJfQoKCQlpZiAoIHJhZGVvbl9jaGVja19hbmRfZml4dXBfb2Zmc2V0KCBkZXZfcHJpdiwgZmlscF9wcml2LAoJCQkJCQkgICAgJmN0eC0+cmIzZF9jb2xvcm9mZnNldCApICkgewoJCQlEUk1fRVJST1IoICJJbnZhbGlkIGRlcHRoIGJ1ZmZlciBvZmZzZXRcbiIgKTsKCQkJcmV0dXJuIERSTV9FUlIoIEVJTlZBTCApOwoJCX0KCgkJQkVHSU5fUklORyggMTQgKTsKCQlPVVRfUklORyggQ1BfUEFDS0VUMCggUkFERU9OX1BQX01JU0MsIDYgKSApOwoJCU9VVF9SSU5HKCBjdHgtPnBwX21pc2MgKTsKCQlPVVRfUklORyggY3R4LT5wcF9mb2dfY29sb3IgKTsKCQlPVVRfUklORyggY3R4LT5yZV9zb2xpZF9jb2xvciApOwoJCU9VVF9SSU5HKCBjdHgtPnJiM2RfYmxlbmRjbnRsICk7CgkJT1VUX1JJTkcoIGN0eC0+cmIzZF9kZXB0aG9mZnNldCApOwoJCU9VVF9SSU5HKCBjdHgtPnJiM2RfZGVwdGhwaXRjaCApOwoJCU9VVF9SSU5HKCBjdHgtPnJiM2RfenN0ZW5jaWxjbnRsICk7CgkJT1VUX1JJTkcoIENQX1BBQ0tFVDAoIFJBREVPTl9QUF9DTlRMLCAyICkgKTsKCQlPVVRfUklORyggY3R4LT5wcF9jbnRsICk7CgkJT1VUX1JJTkcoIGN0eC0+cmIzZF9jbnRsICk7CgkJT1VUX1JJTkcoIGN0eC0+cmIzZF9jb2xvcm9mZnNldCApOwoJCU9VVF9SSU5HKCBDUF9QQUNLRVQwKCBSQURFT05fUkIzRF9DT0xPUlBJVENILCAwICkgKTsKCQlPVVRfUklORyggY3R4LT5yYjNkX2NvbG9ycGl0Y2ggKTsKCQlBRFZBTkNFX1JJTkcoKTsKCX0KCglpZiAoIGRpcnR5ICYgUkFERU9OX1VQTE9BRF9WRVJURk1UICkgewoJCUJFR0lOX1JJTkcoIDIgKTsKCQlPVVRfUklORyggQ1BfUEFDS0VUMCggUkFERU9OX1NFX0NPT1JEX0ZNVCwgMCApICk7CgkJT1VUX1JJTkcoIGN0eC0+c2VfY29vcmRfZm10ICk7CgkJQURWQU5DRV9SSU5HKCk7Cgl9CgoJaWYgKCBkaXJ0eSAmIFJBREVPTl9VUExPQURfTElORSApIHsKCQlCRUdJTl9SSU5HKCA1ICk7CgkJT1VUX1JJTkcoIENQX1BBQ0tFVDAoIFJBREVPTl9SRV9MSU5FX1BBVFRFUk4sIDEgKSApOwoJCU9VVF9SSU5HKCBjdHgtPnJlX2xpbmVfcGF0dGVybiApOwoJCU9VVF9SSU5HKCBjdHgtPnJlX2xpbmVfc3RhdGUgKTsKCQlPVVRfUklORyggQ1BfUEFDS0VUMCggUkFERU9OX1NFX0xJTkVfV0lEVEgsIDAgKSApOwoJCU9VVF9SSU5HKCBjdHgtPnNlX2xpbmVfd2lkdGggKTsKCQlBRFZBTkNFX1JJTkcoKTsKCX0KCglpZiAoIGRpcnR5ICYgUkFERU9OX1VQTE9BRF9CVU1QTUFQICkgewoJCUJFR0lOX1JJTkcoIDUgKTsKCQlPVVRfUklORyggQ1BfUEFDS0VUMCggUkFERU9OX1BQX0xVTV9NQVRSSVgsIDAgKSApOwoJCU9VVF9SSU5HKCBjdHgtPnBwX2x1bV9tYXRyaXggKTsKCQlPVVRfUklORyggQ1BfUEFDS0VUMCggUkFERU9OX1BQX1JPVF9NQVRSSVhfMCwgMSApICk7CgkJT1VUX1JJTkcoIGN0eC0+cHBfcm90X21hdHJpeF8wICk7CgkJT1VUX1JJTkcoIGN0eC0+cHBfcm90X21hdHJpeF8xICk7CgkJQURWQU5DRV9SSU5HKCk7Cgl9CgoJaWYgKCBkaXJ0eSAmIFJBREVPTl9VUExPQURfTUFTS1MgKSB7CgkJQkVHSU5fUklORyggNCApOwoJCU9VVF9SSU5HKCBDUF9QQUNLRVQwKCBSQURFT05fUkIzRF9TVEVOQ0lMUkVGTUFTSywgMiApICk7CgkJT1VUX1JJTkcoIGN0eC0+cmIzZF9zdGVuY2lscmVmbWFzayApOwoJCU9VVF9SSU5HKCBjdHgtPnJiM2Rfcm9wY250bCApOwoJCU9VVF9SSU5HKCBjdHgtPnJiM2RfcGxhbmVtYXNrICk7CgkJQURWQU5DRV9SSU5HKCk7Cgl9CgoJaWYgKCBkaXJ0eSAmIFJBREVPTl9VUExPQURfVklFV1BPUlQgKSB7CgkJQkVHSU5fUklORyggNyApOwoJCU9VVF9SSU5HKCBDUF9QQUNLRVQwKCBSQURFT05fU0VfVlBPUlRfWFNDQUxFLCA1ICkgKTsKCQlPVVRfUklORyggY3R4LT5zZV92cG9ydF94c2NhbGUgKTsKCQlPVVRfUklORyggY3R4LT5zZV92cG9ydF94b2Zmc2V0ICk7CgkJT1VUX1JJTkcoIGN0eC0+c2VfdnBvcnRfeXNjYWxlICk7CgkJT1VUX1JJTkcoIGN0eC0+c2VfdnBvcnRfeW9mZnNldCApOwoJCU9VVF9SSU5HKCBjdHgtPnNlX3Zwb3J0X3pzY2FsZSApOwoJCU9VVF9SSU5HKCBjdHgtPnNlX3Zwb3J0X3pvZmZzZXQgKTsKCQlBRFZBTkNFX1JJTkcoKTsKCX0KCglpZiAoIGRpcnR5ICYgUkFERU9OX1VQTE9BRF9TRVRVUCApIHsKCQlCRUdJTl9SSU5HKCA0ICk7CgkJT1VUX1JJTkcoIENQX1BBQ0tFVDAoIFJBREVPTl9TRV9DTlRMLCAwICkgKTsKCQlPVVRfUklORyggY3R4LT5zZV9jbnRsICk7CgkJT1VUX1JJTkcoIENQX1BBQ0tFVDAoIFJBREVPTl9TRV9DTlRMX1NUQVRVUywgMCApICk7CgkJT1VUX1JJTkcoIGN0eC0+c2VfY250bF9zdGF0dXMgKTsKCQlBRFZBTkNFX1JJTkcoKTsKCX0KCglpZiAoIGRpcnR5ICYgUkFERU9OX1VQTE9BRF9NSVNDICkgewoJCUJFR0lOX1JJTkcoIDIgKTsKCQlPVVRfUklORyggQ1BfUEFDS0VUMCggUkFERU9OX1JFX01JU0MsIDAgKSApOwoJCU9VVF9SSU5HKCBjdHgtPnJlX21pc2MgKTsKCQlBRFZBTkNFX1JJTkcoKTsKCX0KCglpZiAoIGRpcnR5ICYgUkFERU9OX1VQTE9BRF9URVgwICkgewoJCWlmICggcmFkZW9uX2NoZWNrX2FuZF9maXh1cF9vZmZzZXQoIGRldl9wcml2LCBmaWxwX3ByaXYsCgkJCQkJCSAgICAmdGV4WzBdLnBwX3R4b2Zmc2V0ICkgKSB7CgkJCURSTV9FUlJPUiggIkludmFsaWQgdGV4dHVyZSBvZmZzZXQgZm9yIHVuaXQgMFxuIiApOwoJCQlyZXR1cm4gRFJNX0VSUiggRUlOVkFMICk7CgkJfQoKCQlCRUdJTl9SSU5HKCA5ICk7CgkJT1VUX1JJTkcoIENQX1BBQ0tFVDAoIFJBREVPTl9QUF9UWEZJTFRFUl8wLCA1ICkgKTsKCQlPVVRfUklORyggdGV4WzBdLnBwX3R4ZmlsdGVyICk7CgkJT1VUX1JJTkcoIHRleFswXS5wcF90eGZvcm1hdCApOwoJCU9VVF9SSU5HKCB0ZXhbMF0ucHBfdHhvZmZzZXQgKTsKCQlPVVRfUklORyggdGV4WzBdLnBwX3R4Y2JsZW5kICk7CgkJT1VUX1JJTkcoIHRleFswXS5wcF90eGFibGVuZCApOwoJCU9VVF9SSU5HKCB0ZXhbMF0ucHBfdGZhY3RvciApOwoJCU9VVF9SSU5HKCBDUF9QQUNLRVQwKCBSQURFT05fUFBfQk9SREVSX0NPTE9SXzAsIDAgKSApOwoJCU9VVF9SSU5HKCB0ZXhbMF0ucHBfYm9yZGVyX2NvbG9yICk7CgkJQURWQU5DRV9SSU5HKCk7Cgl9CgoJaWYgKCBkaXJ0eSAmIFJBREVPTl9VUExPQURfVEVYMSApIHsKCQlpZiAoIHJhZGVvbl9jaGVja19hbmRfZml4dXBfb2Zmc2V0KCBkZXZfcHJpdiwgZmlscF9wcml2LAoJCQkJCQkgICAgJnRleFsxXS5wcF90eG9mZnNldCApICkgewoJCQlEUk1fRVJST1IoICJJbnZhbGlkIHRleHR1cmUgb2Zmc2V0IGZvciB1bml0IDFcbiIgKTsKCQkJcmV0dXJuIERSTV9FUlIoIEVJTlZBTCApOwoJCX0KCgkJQkVHSU5fUklORyggOSApOwoJCU9VVF9SSU5HKCBDUF9QQUNLRVQwKCBSQURFT05fUFBfVFhGSUxURVJfMSwgNSApICk7CgkJT1VUX1JJTkcoIHRleFsxXS5wcF90eGZpbHRlciApOwoJCU9VVF9SSU5HKCB0ZXhbMV0ucHBfdHhmb3JtYXQgKTsKCQlPVVRfUklORyggdGV4WzFdLnBwX3R4b2Zmc2V0ICk7CgkJT1VUX1JJTkcoIHRleFsxXS5wcF90eGNibGVuZCApOwoJCU9VVF9SSU5HKCB0ZXhbMV0ucHBfdHhhYmxlbmQgKTsKCQlPVVRfUklORyggdGV4WzFdLnBwX3RmYWN0b3IgKTsKCQlPVVRfUklORyggQ1BfUEFDS0VUMCggUkFERU9OX1BQX0JPUkRFUl9DT0xPUl8xLCAwICkgKTsKCQlPVVRfUklORyggdGV4WzFdLnBwX2JvcmRlcl9jb2xvciApOwoJCUFEVkFOQ0VfUklORygpOwoJfQoKCWlmICggZGlydHkgJiBSQURFT05fVVBMT0FEX1RFWDIgKSB7CgkJaWYgKCByYWRlb25fY2hlY2tfYW5kX2ZpeHVwX29mZnNldCggZGV2X3ByaXYsIGZpbHBfcHJpdiwKCQkJCQkJICAgICZ0ZXhbMl0ucHBfdHhvZmZzZXQgKSApIHsKCQkJRFJNX0VSUk9SKCAiSW52YWxpZCB0ZXh0dXJlIG9mZnNldCBmb3IgdW5pdCAyXG4iICk7CgkJCXJldHVybiBEUk1fRVJSKCBFSU5WQUwgKTsKCQl9CgoJCUJFR0lOX1JJTkcoIDkgKTsKCQlPVVRfUklORyggQ1BfUEFDS0VUMCggUkFERU9OX1BQX1RYRklMVEVSXzIsIDUgKSApOwoJCU9VVF9SSU5HKCB0ZXhbMl0ucHBfdHhmaWx0ZXIgKTsKCQlPVVRfUklORyggdGV4WzJdLnBwX3R4Zm9ybWF0ICk7CgkJT1VUX1JJTkcoIHRleFsyXS5wcF90eG9mZnNldCApOwoJCU9VVF9SSU5HKCB0ZXhbMl0ucHBfdHhjYmxlbmQgKTsKCQlPVVRfUklORyggdGV4WzJdLnBwX3R4YWJsZW5kICk7CgkJT1VUX1JJTkcoIHRleFsyXS5wcF90ZmFjdG9yICk7CgkJT1VUX1JJTkcoIENQX1BBQ0tFVDAoIFJBREVPTl9QUF9CT1JERVJfQ09MT1JfMiwgMCApICk7CgkJT1VUX1JJTkcoIHRleFsyXS5wcF9ib3JkZXJfY29sb3IgKTsKCQlBRFZBTkNFX1JJTkcoKTsKCX0KCglyZXR1cm4gMDsKfQoKLyogRW1pdCAxLjIgc3RhdGUKICovCnN0YXRpYyBpbnQgcmFkZW9uX2VtaXRfc3RhdGUyKCBkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYsCgkJCSAgICAgICBkcm1fZmlsZV90ICpmaWxwX3ByaXYsCgkJCSAgICAgICBkcm1fcmFkZW9uX3N0YXRlX3QgKnN0YXRlICkKewoJUklOR19MT0NBTFM7CgoJaWYgKHN0YXRlLT5kaXJ0eSAmIFJBREVPTl9VUExPQURfWkJJQVMpIHsKCQlCRUdJTl9SSU5HKCAzICk7CgkJT1VUX1JJTkcoIENQX1BBQ0tFVDAoIFJBREVPTl9TRV9aQklBU19GQUNUT1IsIDEgKSApOwoJCU9VVF9SSU5HKCBzdGF0ZS0+Y29udGV4dDIuc2VfemJpYXNfZmFjdG9yICk7IAoJCU9VVF9SSU5HKCBzdGF0ZS0+Y29udGV4dDIuc2VfemJpYXNfY29uc3RhbnQgKTsgCgkJQURWQU5DRV9SSU5HKCk7Cgl9CgoJcmV0dXJuIHJhZGVvbl9lbWl0X3N0YXRlKCBkZXZfcHJpdiwgZmlscF9wcml2LCAmc3RhdGUtPmNvbnRleHQsCgkJCSAgIHN0YXRlLT50ZXgsIHN0YXRlLT5kaXJ0eSApOwp9CgovKiBOZXcgKDEuMykgc3RhdGUgbWVjaGFuaXNtLiAgMyBjb21tYW5kcyAocGFja2V0LCBzY2FsYXIsIHZlY3RvcikgaW4KICogMS4zIGNtZGJ1ZmZlcnMgYWxsb3cgYWxsIHByZXZpb3VzIHN0YXRlIHRvIGJlIHVwZGF0ZWQgYXMgd2VsbCBhcwogKiB0aGUgdGNsIHNjYWxhciBhbmQgdmVjdG9yIGFyZWFzLiAgCiAqLwpzdGF0aWMgc3RydWN0IHsgCglpbnQgc3RhcnQ7IAoJaW50IGxlbjsgCgljb25zdCBjaGFyICpuYW1lOwp9IHBhY2tldFtSQURFT05fTUFYX1NUQVRFX1BBQ0tFVFNdID0gewoJeyBSQURFT05fUFBfTUlTQyw3LCJSQURFT05fUFBfTUlTQyIgfSwKCXsgUkFERU9OX1BQX0NOVEwsMywiUkFERU9OX1BQX0NOVEwiIH0sCgl7IFJBREVPTl9SQjNEX0NPTE9SUElUQ0gsMSwiUkFERU9OX1JCM0RfQ09MT1JQSVRDSCIgfSwKCXsgUkFERU9OX1JFX0xJTkVfUEFUVEVSTiwyLCJSQURFT05fUkVfTElORV9QQVRURVJOIiB9LAoJeyBSQURFT05fU0VfTElORV9XSURUSCwxLCJSQURFT05fU0VfTElORV9XSURUSCIgfSwKCXsgUkFERU9OX1BQX0xVTV9NQVRSSVgsMSwiUkFERU9OX1BQX0xVTV9NQVRSSVgiIH0sCgl7IFJBREVPTl9QUF9ST1RfTUFUUklYXzAsMiwiUkFERU9OX1BQX1JPVF9NQVRSSVhfMCIgfSwKCXsgUkFERU9OX1JCM0RfU1RFTkNJTFJFRk1BU0ssMywiUkFERU9OX1JCM0RfU1RFTkNJTFJFRk1BU0siIH0sCgl7IFJBREVPTl9TRV9WUE9SVF9YU0NBTEUsNiwiUkFERU9OX1NFX1ZQT1JUX1hTQ0FMRSIgfSwKCXsgUkFERU9OX1NFX0NOVEwsMiwiUkFERU9OX1NFX0NOVEwiIH0sCgl7IFJBREVPTl9TRV9DTlRMX1NUQVRVUywxLCJSQURFT05fU0VfQ05UTF9TVEFUVVMiIH0sCgl7IFJBREVPTl9SRV9NSVNDLDEsIlJBREVPTl9SRV9NSVNDIiB9LAoJeyBSQURFT05fUFBfVFhGSUxURVJfMCw2LCJSQURFT05fUFBfVFhGSUxURVJfMCIgfSwKCXsgUkFERU9OX1BQX0JPUkRFUl9DT0xPUl8wLDEsIlJBREVPTl9QUF9CT1JERVJfQ09MT1JfMCIgfSwKCXsgUkFERU9OX1BQX1RYRklMVEVSXzEsNiwiUkFERU9OX1BQX1RYRklMVEVSXzEiIH0sCgl7IFJBREVPTl9QUF9CT1JERVJfQ09MT1JfMSwxLCJSQURFT05fUFBfQk9SREVSX0NPTE9SXzEiIH0sCgl7IFJBREVPTl9QUF9UWEZJTFRFUl8yLDYsIlJBREVPTl9QUF9UWEZJTFRFUl8yIiB9LAoJeyBSQURFT05fUFBfQk9SREVSX0NPTE9SXzIsMSwiUkFERU9OX1BQX0JPUkRFUl9DT0xPUl8yIiB9LAoJeyBSQURFT05fU0VfWkJJQVNfRkFDVE9SLDIsIlJBREVPTl9TRV9aQklBU19GQUNUT1IiIH0sCgl7IFJBREVPTl9TRV9UQ0xfT1VUUFVUX1ZUWF9GTVQsMTEsIlJBREVPTl9TRV9UQ0xfT1VUUFVUX1ZUWF9GTVQiIH0sCgl7IFJBREVPTl9TRV9UQ0xfTUFURVJJQUxfRU1NSVNTSVZFX1JFRCwxNywiUkFERU9OX1NFX1RDTF9NQVRFUklBTF9FTU1JU1NJVkVfUkVEIiB9LAoJeyBSMjAwX1BQX1RYQ0JMRU5EXzAsIDQsICJSMjAwX1BQX1RYQ0JMRU5EXzAiIH0sCgl7IFIyMDBfUFBfVFhDQkxFTkRfMSwgNCwgIlIyMDBfUFBfVFhDQkxFTkRfMSIgfSwKCXsgUjIwMF9QUF9UWENCTEVORF8yLCA0LCAiUjIwMF9QUF9UWENCTEVORF8yIiB9LAoJeyBSMjAwX1BQX1RYQ0JMRU5EXzMsIDQsICJSMjAwX1BQX1RYQ0JMRU5EXzMiIH0sCgl7IFIyMDBfUFBfVFhDQkxFTkRfNCwgNCwgIlIyMDBfUFBfVFhDQkxFTkRfNCIgfSwKCXsgUjIwMF9QUF9UWENCTEVORF81LCA0LCAiUjIwMF9QUF9UWENCTEVORF81IiB9LAoJeyBSMjAwX1BQX1RYQ0JMRU5EXzYsIDQsICJSMjAwX1BQX1RYQ0JMRU5EXzYiIH0sCgl7IFIyMDBfUFBfVFhDQkxFTkRfNywgNCwgIlIyMDBfUFBfVFhDQkxFTkRfNyIgfSwKCXsgUjIwMF9TRV9UQ0xfTElHSFRfTU9ERUxfQ1RMXzAsIDYsICJSMjAwX1NFX1RDTF9MSUdIVF9NT0RFTF9DVExfMCIgfSwKCXsgUjIwMF9QUF9URkFDVE9SXzAsIDYsICJSMjAwX1BQX1RGQUNUT1JfMCIgfSwKCXsgUjIwMF9TRV9WVFhfRk1UXzAsIDQsICJSMjAwX1NFX1ZUWF9GTVRfMCIgfSwKCXsgUjIwMF9TRV9WQVBfQ05UTCwgMSwgIlIyMDBfU0VfVkFQX0NOVEwiIH0sCgl7IFIyMDBfU0VfVENMX01BVFJJWF9TRUxfMCwgNSwgIlIyMDBfU0VfVENMX01BVFJJWF9TRUxfMCIgfSwKCXsgUjIwMF9TRV9UQ0xfVEVYX1BST0NfQ1RMXzIsIDUsICJSMjAwX1NFX1RDTF9URVhfUFJPQ19DVExfMiIgfSwKCXsgUjIwMF9TRV9UQ0xfVUNQX1ZFUlRfQkxFTkRfQ1RMLCAxLCAiUjIwMF9TRV9UQ0xfVUNQX1ZFUlRfQkxFTkRfQ1RMIiB9LAoJeyBSMjAwX1BQX1RYRklMVEVSXzAsIDYsICJSMjAwX1BQX1RYRklMVEVSXzAiIH0sCgl7IFIyMDBfUFBfVFhGSUxURVJfMSwgNiwgIlIyMDBfUFBfVFhGSUxURVJfMSIgfSwKCXsgUjIwMF9QUF9UWEZJTFRFUl8yLCA2LCAiUjIwMF9QUF9UWEZJTFRFUl8yIiB9LAoJeyBSMjAwX1BQX1RYRklMVEVSXzMsIDYsICJSMjAwX1BQX1RYRklMVEVSXzMiIH0sCgl7IFIyMDBfUFBfVFhGSUxURVJfNCwgNiwgIlIyMDBfUFBfVFhGSUxURVJfNCIgfSwKCXsgUjIwMF9QUF9UWEZJTFRFUl81LCA2LCAiUjIwMF9QUF9UWEZJTFRFUl81IiB9LAoJeyBSMjAwX1BQX1RYT0ZGU0VUXzAsIDEsICJSMjAwX1BQX1RYT0ZGU0VUXzAiIH0sCgl7IFIyMDBfUFBfVFhPRkZTRVRfMSwgMSwgIlIyMDBfUFBfVFhPRkZTRVRfMSIgfSwKCXsgUjIwMF9QUF9UWE9GRlNFVF8yLCAxLCAiUjIwMF9QUF9UWE9GRlNFVF8yIiB9LAoJeyBSMjAwX1BQX1RYT0ZGU0VUXzMsIDEsICJSMjAwX1BQX1RYT0ZGU0VUXzMiIH0sCgl7IFIyMDBfUFBfVFhPRkZTRVRfNCwgMSwgIlIyMDBfUFBfVFhPRkZTRVRfNCIgfSwKCXsgUjIwMF9QUF9UWE9GRlNFVF81LCAxLCAiUjIwMF9QUF9UWE9GRlNFVF81IiB9LAoJeyBSMjAwX1NFX1ZURV9DTlRMLCAxLCAiUjIwMF9TRV9WVEVfQ05UTCIgfSwKCXsgUjIwMF9TRV9UQ0xfT1VUUFVUX1ZUWF9DT01QX1NFTCwgMSwgIlIyMDBfU0VfVENMX09VVFBVVF9WVFhfQ09NUF9TRUwiIH0sCgl7IFIyMDBfUFBfVEFNX0RFQlVHMywgMSwgIlIyMDBfUFBfVEFNX0RFQlVHMyIgfSwKCXsgUjIwMF9QUF9DTlRMX1gsIDEsICJSMjAwX1BQX0NOVExfWCIgfSwgCgl7IFIyMDBfUkIzRF9ERVBUSFhZX09GRlNFVCwgMSwgIlIyMDBfUkIzRF9ERVBUSFhZX09GRlNFVCIgfSwgCgl7IFIyMDBfUkVfQVVYX1NDSVNTT1JfQ05UTCwgMSwgIlIyMDBfUkVfQVVYX1NDSVNTT1JfQ05UTCIgfSwgCgl7IFIyMDBfUkVfU0NJU1NPUl9UTF8wLCAyLCAiUjIwMF9SRV9TQ0lTU09SX1RMXzAiIH0sIAoJeyBSMjAwX1JFX1NDSVNTT1JfVExfMSwgMiwgIlIyMDBfUkVfU0NJU1NPUl9UTF8xIiB9LCAKCXsgUjIwMF9SRV9TQ0lTU09SX1RMXzIsIDIsICJSMjAwX1JFX1NDSVNTT1JfVExfMiIgfSwgCgl7IFIyMDBfU0VfVkFQX0NOVExfU1RBVFVTLCAxLCAiUjIwMF9TRV9WQVBfQ05UTF9TVEFUVVMiIH0sIAoJeyBSMjAwX1NFX1ZUWF9TVEFURV9DTlRMLCAxLCAiUjIwMF9TRV9WVFhfU1RBVEVfQ05UTCIgfSwgCgl7IFIyMDBfUkVfUE9JTlRTSVpFLCAxLCAiUjIwMF9SRV9QT0lOVFNJWkUiIH0sIAoJeyBSMjAwX1NFX1RDTF9JTlBVVF9WVFhfVkVDVE9SX0FERFJfMCwgNCwgIlIyMDBfU0VfVENMX0lOUFVUX1ZUWF9WRUNUT1JfQUREUl8wIiB9LAoJeyBSMjAwX1BQX0NVQklDX0ZBQ0VTXzAsIDEsICJSMjAwX1BQX0NVQklDX0ZBQ0VTXzAiIH0sIC8qIDYxICovCgl7IFIyMDBfUFBfQ1VCSUNfT0ZGU0VUX0YxXzAsIDUsICJSMjAwX1BQX0NVQklDX09GRlNFVF9GMV8wIiB9LCAvKiA2MiAqLwoJeyBSMjAwX1BQX0NVQklDX0ZBQ0VTXzEsIDEsICJSMjAwX1BQX0NVQklDX0ZBQ0VTXzEiIH0sCgl7IFIyMDBfUFBfQ1VCSUNfT0ZGU0VUX0YxXzEsIDUsICJSMjAwX1BQX0NVQklDX09GRlNFVF9GMV8xIiB9LAoJeyBSMjAwX1BQX0NVQklDX0ZBQ0VTXzIsIDEsICJSMjAwX1BQX0NVQklDX0ZBQ0VTXzIiIH0sCgl7IFIyMDBfUFBfQ1VCSUNfT0ZGU0VUX0YxXzIsIDUsICJSMjAwX1BQX0NVQklDX09GRlNFVF9GMV8yIiB9LAoJeyBSMjAwX1BQX0NVQklDX0ZBQ0VTXzMsIDEsICJSMjAwX1BQX0NVQklDX0ZBQ0VTXzMiIH0sCgl7IFIyMDBfUFBfQ1VCSUNfT0ZGU0VUX0YxXzMsIDUsICJSMjAwX1BQX0NVQklDX09GRlNFVF9GMV8zIiB9LAoJeyBSMjAwX1BQX0NVQklDX0ZBQ0VTXzQsIDEsICJSMjAwX1BQX0NVQklDX0ZBQ0VTXzQiIH0sCgl7IFIyMDBfUFBfQ1VCSUNfT0ZGU0VUX0YxXzQsIDUsICJSMjAwX1BQX0NVQklDX09GRlNFVF9GMV80IiB9LAoJeyBSMjAwX1BQX0NVQklDX0ZBQ0VTXzUsIDEsICJSMjAwX1BQX0NVQklDX0ZBQ0VTXzUiIH0sCgl7IFIyMDBfUFBfQ1VCSUNfT0ZGU0VUX0YxXzUsIDUsICJSMjAwX1BQX0NVQklDX09GRlNFVF9GMV81IiB9LAoJeyBSQURFT05fUFBfVEVYX1NJWkVfMCwgMiwgIlJBREVPTl9QUF9URVhfU0laRV8wIiB9LAoJeyBSQURFT05fUFBfVEVYX1NJWkVfMSwgMiwgIlJBREVPTl9QUF9URVhfU0laRV8xIiB9LAoJeyBSQURFT05fUFBfVEVYX1NJWkVfMiwgMiwgIlJBREVPTl9QUF9URVhfU0laRV8yIiB9LAoJeyBSMjAwX1JCM0RfQkxFTkRDT0xPUiwgMywgIlIyMDBfUkIzRF9CTEVORENPTE9SIiB9LAoJeyBSMjAwX1NFX1RDTF9QT0lOVF9TUFJJVEVfQ05UTCwgMSwgIlIyMDBfU0VfVENMX1BPSU5UX1NQUklURV9DTlRMIiB9LAoJeyBSQURFT05fUFBfQ1VCSUNfRkFDRVNfMCwgMSwgIlJBREVPTl9QUF9DVUJJQ19GQUNFU18wIn0sCgl7IFJBREVPTl9QUF9DVUJJQ19PRkZTRVRfVDBfMCwgNSwgIlJBREVPTl9QUF9DVUJJQ19PRkZTRVRfVDBfMCJ9LAoJeyBSQURFT05fUFBfQ1VCSUNfRkFDRVNfMSwgMSwgIlJBREVPTl9QUF9DVUJJQ19GQUNFU18xIn0sCgl7IFJBREVPTl9QUF9DVUJJQ19PRkZTRVRfVDFfMCwgNSwgIlJBREVPTl9QUF9DVUJJQ19PRkZTRVRfVDFfMCJ9LAoJeyBSQURFT05fUFBfQ1VCSUNfRkFDRVNfMiwgMSwgIlJBREVPTl9QUF9DVUJJQ19GQUNFU18yIn0sCgl7IFJBREVPTl9QUF9DVUJJQ19PRkZTRVRfVDJfMCwgNSwgIlJBREVPTl9QUF9DVUJJQ19PRkZTRVRfVDJfMCJ9LAoJeyBSMjAwX1BQX1RSSV9QRVJGLCAyLCAiUjIwMF9QUF9UUklfUEVSRiJ9LAp9OwoKCgovKiA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAqIFBlcmZvcm1hbmNlIG1vbml0b3JpbmcgZnVuY3Rpb25zCiAqLwoKc3RhdGljIHZvaWQgcmFkZW9uX2NsZWFyX2JveCggZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2LAoJCQkgICAgICBpbnQgeCwgaW50IHksIGludCB3LCBpbnQgaCwKCQkJICAgICAgaW50IHIsIGludCBnLCBpbnQgYiApCnsKCXUzMiBjb2xvcjsKCVJJTkdfTE9DQUxTOwoKCXggKz0gZGV2X3ByaXYtPnNhcmVhX3ByaXYtPmJveGVzWzBdLngxOwoJeSArPSBkZXZfcHJpdi0+c2FyZWFfcHJpdi0+Ym94ZXNbMF0ueTE7CgoJc3dpdGNoICggZGV2X3ByaXYtPmNvbG9yX2ZtdCApIHsKCWNhc2UgUkFERU9OX0NPTE9SX0ZPUk1BVF9SR0I1NjU6CgkJY29sb3IgPSAoKChyICYgMHhmOCkgPDwgOCkgfAoJCQkgKChnICYgMHhmYykgPDwgMykgfAoJCQkgKChiICYgMHhmOCkgPj4gMykpOwoJCWJyZWFrOwoJY2FzZSBSQURFT05fQ09MT1JfRk9STUFUX0FSR0I4ODg4OgoJZGVmYXVsdDoKCQljb2xvciA9ICgoKDB4ZmYpIDw8IDI0KSB8IChyIDw8IDE2KSB8IChnIDw8ICA4KSB8IGIpOwoJCWJyZWFrOwoJfQoKCUJFR0lOX1JJTkcoIDQgKTsKCVJBREVPTl9XQUlUX1VOVElMXzNEX0lETEUoKTsJCQoJT1VUX1JJTkcoIENQX1BBQ0tFVDAoIFJBREVPTl9EUF9XUklURV9NQVNLLCAwICkgKTsKCU9VVF9SSU5HKCAweGZmZmZmZmZmICk7CglBRFZBTkNFX1JJTkcoKTsKCglCRUdJTl9SSU5HKCA2ICk7CgoJT1VUX1JJTkcoIENQX1BBQ0tFVDMoIFJBREVPTl9DTlRMX1BBSU5UX01VTFRJLCA0ICkgKTsKCU9VVF9SSU5HKCBSQURFT05fR01DX0RTVF9QSVRDSF9PRkZTRVRfQ05UTCB8CgkJICBSQURFT05fR01DX0JSVVNIX1NPTElEX0NPTE9SIHwKCQkgIChkZXZfcHJpdi0+Y29sb3JfZm10IDw8IDgpIHwKCQkgIFJBREVPTl9HTUNfU1JDX0RBVEFUWVBFX0NPTE9SIHwKCQkgIFJBREVPTl9ST1AzX1AgfAoJCSAgUkFERU9OX0dNQ19DTFJfQ01QX0NOVExfRElTICk7CgogCWlmICggZGV2X3ByaXYtPnBhZ2VfZmxpcHBpbmcgJiYgZGV2X3ByaXYtPmN1cnJlbnRfcGFnZSA9PSAxICkgeyAKCQlPVVRfUklORyggZGV2X3ByaXYtPmZyb250X3BpdGNoX29mZnNldCApOwogCX0gZWxzZSB7CSAKCQlPVVRfUklORyggZGV2X3ByaXYtPmJhY2tfcGl0Y2hfb2Zmc2V0ICk7CiAJfSAKCglPVVRfUklORyggY29sb3IgKTsKCglPVVRfUklORyggKHggPDwgMTYpIHwgeSApOwoJT1VUX1JJTkcoICh3IDw8IDE2KSB8IGggKTsKCglBRFZBTkNFX1JJTkcoKTsKfQoKc3RhdGljIHZvaWQgcmFkZW9uX2NwX3BlcmZvcm1hbmNlX2JveGVzKCBkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgKQp7CgkvKiBDb2xsYXBzZSB2YXJpb3VzIHRoaW5ncyBpbnRvIGEgd2FpdCBmbGFnIC0tIHRyeWluZyB0bwoJICogZ3Vlc3MgaWYgdXNlcnNwYXNlIHNsZXB0IC0tIGJldHRlciBqdXN0IHRvIGhhdmUgdGhlbSB0ZWxsIHVzLgoJICovCglpZiAoZGV2X3ByaXYtPnN0YXRzLmxhc3RfZnJhbWVfcmVhZHMgPiAxIHx8CgkgICAgZGV2X3ByaXYtPnN0YXRzLmxhc3RfY2xlYXJfcmVhZHMgPiBkZXZfcHJpdi0+c3RhdHMuY2xlYXJzKSB7CgkJZGV2X3ByaXYtPnN0YXRzLmJveGVzIHw9IFJBREVPTl9CT1hfV0FJVF9JRExFOwoJfQoKCWlmIChkZXZfcHJpdi0+c3RhdHMuZnJlZWxpc3RfbG9vcHMpIHsKCQlkZXZfcHJpdi0+c3RhdHMuYm94ZXMgfD0gUkFERU9OX0JPWF9XQUlUX0lETEU7Cgl9CgoJLyogUHVycGxlIGJveCBmb3IgcGFnZSBmbGlwcGluZwoJICovCglpZiAoIGRldl9wcml2LT5zdGF0cy5ib3hlcyAmIFJBREVPTl9CT1hfRkxJUCApIAoJCXJhZGVvbl9jbGVhcl9ib3goIGRldl9wcml2LCA0LCA0LCA4LCA4LCAyNTUsIDAsIDI1NSApOwoKCS8qIFJlZCBib3ggaWYgd2UgaGF2ZSB0byB3YWl0IGZvciBpZGxlIGF0IGFueSBwb2ludAoJICovCglpZiAoIGRldl9wcml2LT5zdGF0cy5ib3hlcyAmIFJBREVPTl9CT1hfV0FJVF9JRExFICkgCgkJcmFkZW9uX2NsZWFyX2JveCggZGV2X3ByaXYsIDE2LCA0LCA4LCA4LCAyNTUsIDAsIDAgKTsKCgkvKiBCbHVlIGJveDogbG9zdCBjb250ZXh0PwoJICovCgoJLyogWWVsbG93IGJveCBmb3IgdGV4dHVyZSBzd2FwcwoJICovCglpZiAoIGRldl9wcml2LT5zdGF0cy5ib3hlcyAmIFJBREVPTl9CT1hfVEVYVFVSRV9MT0FEICkgCgkJcmFkZW9uX2NsZWFyX2JveCggZGV2X3ByaXYsIDQwLCA0LCA4LCA4LCAyNTUsIDI1NSwgMCApOwoKCS8qIEdyZWVuIGJveCBpZiBoYXJkd2FyZSBuZXZlciBpZGxlcyAoYXMgZmFyIGFzIHdlIGNhbiB0ZWxsKQoJICovCglpZiAoICEoZGV2X3ByaXYtPnN0YXRzLmJveGVzICYgUkFERU9OX0JPWF9ETUFfSURMRSkgKSAKCQlyYWRlb25fY2xlYXJfYm94KCBkZXZfcHJpdiwgNjQsIDQsIDgsIDgsIDAsIDI1NSwgMCApOwoKCgkvKiBEcmF3IGJhcnMgaW5kaWNhdGluZyBudW1iZXIgb2YgYnVmZmVycyBhbGxvY2F0ZWQgCgkgKiAobm90IGEgZ3JlYXQgbWVhc3VyZSwgZWFzaWx5IGNvbmZ1c2VkKQoJICovCglpZiAoZGV2X3ByaXYtPnN0YXRzLnJlcXVlc3RlZF9idWZzKSB7CgkJaWYgKGRldl9wcml2LT5zdGF0cy5yZXF1ZXN0ZWRfYnVmcyA+IDEwMCkKCQkJZGV2X3ByaXYtPnN0YXRzLnJlcXVlc3RlZF9idWZzID0gMTAwOwoKCQlyYWRlb25fY2xlYXJfYm94KCBkZXZfcHJpdiwgNCwgMTYsICAKCQkJCSAgZGV2X3ByaXYtPnN0YXRzLnJlcXVlc3RlZF9idWZzLCA0LAoJCQkJICAxOTYsIDEyOCwgMTI4ICk7Cgl9CgoJbWVtc2V0KCAmZGV2X3ByaXYtPnN0YXRzLCAwLCBzaXplb2YoZGV2X3ByaXYtPnN0YXRzKSApOwoKfQovKiA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAqIENQIGNvbW1hbmQgZGlzcGF0Y2ggZnVuY3Rpb25zCiAqLwoKc3RhdGljIHZvaWQgcmFkZW9uX2NwX2Rpc3BhdGNoX2NsZWFyKCBkcm1fZGV2aWNlX3QgKmRldiwKCQkJCSAgICAgIGRybV9yYWRlb25fY2xlYXJfdCAqY2xlYXIsCgkJCQkgICAgICBkcm1fcmFkZW9uX2NsZWFyX3JlY3RfdCAqZGVwdGhfYm94ZXMgKQp7Cglkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoJZHJtX3JhZGVvbl9zYXJlYV90ICpzYXJlYV9wcml2ID0gZGV2X3ByaXYtPnNhcmVhX3ByaXY7Cglkcm1fcmFkZW9uX2RlcHRoX2NsZWFyX3QgKmRlcHRoX2NsZWFyID0gJmRldl9wcml2LT5kZXB0aF9jbGVhcjsKCWludCBuYm94ID0gc2FyZWFfcHJpdi0+bmJveDsKCWRybV9jbGlwX3JlY3RfdCAqcGJveCA9IHNhcmVhX3ByaXYtPmJveGVzOwoJdW5zaWduZWQgaW50IGZsYWdzID0gY2xlYXItPmZsYWdzOwoJdTMyIHJiM2RfY250bCA9IDAsIHJiM2Rfc3RlbmNpbHJlZm1hc2s9IDA7CglpbnQgaTsKCVJJTkdfTE9DQUxTOwoJRFJNX0RFQlVHKCAiZmxhZ3MgPSAweCV4XG4iLCBmbGFncyApOwoKCWRldl9wcml2LT5zdGF0cy5jbGVhcnMrKzsKCglpZiAoIGRldl9wcml2LT5wYWdlX2ZsaXBwaW5nICYmIGRldl9wcml2LT5jdXJyZW50X3BhZ2UgPT0gMSApIHsKCQl1bnNpZ25lZCBpbnQgdG1wID0gZmxhZ3M7CgoJCWZsYWdzICY9IH4oUkFERU9OX0ZST05UIHwgUkFERU9OX0JBQ0spOwoJCWlmICggdG1wICYgUkFERU9OX0ZST05UICkgZmxhZ3MgfD0gUkFERU9OX0JBQ0s7CgkJaWYgKCB0bXAgJiBSQURFT05fQkFDSyApICBmbGFncyB8PSBSQURFT05fRlJPTlQ7Cgl9CgoJaWYgKCBmbGFncyAmIChSQURFT05fRlJPTlQgfCBSQURFT05fQkFDSykgKSB7CgoJCUJFR0lOX1JJTkcoIDQgKTsKCgkJLyogRW5zdXJlIHRoZSAzRCBzdHJlYW0gaXMgaWRsZSBiZWZvcmUgZG9pbmcgYQoJCSAqIDJEIGZpbGwgdG8gY2xlYXIgdGhlIGZyb250IG9yIGJhY2sgYnVmZmVyLgoJCSAqLwoJCVJBREVPTl9XQUlUX1VOVElMXzNEX0lETEUoKTsKCQkKCQlPVVRfUklORyggQ1BfUEFDS0VUMCggUkFERU9OX0RQX1dSSVRFX01BU0ssIDAgKSApOwoJCU9VVF9SSU5HKCBjbGVhci0+Y29sb3JfbWFzayApOwoKCQlBRFZBTkNFX1JJTkcoKTsKCgkJLyogTWFrZSBzdXJlIHdlIHJlc3RvcmUgdGhlIDNEIHN0YXRlIG5leHQgdGltZS4KCQkgKi8KCQlkZXZfcHJpdi0+c2FyZWFfcHJpdi0+Y3R4X293bmVyID0gMDsKCgkJZm9yICggaSA9IDAgOyBpIDwgbmJveCA7IGkrKyApIHsKCQkJaW50IHggPSBwYm94W2ldLngxOwoJCQlpbnQgeSA9IHBib3hbaV0ueTE7CgkJCWludCB3ID0gcGJveFtpXS54MiAtIHg7CgkJCWludCBoID0gcGJveFtpXS55MiAtIHk7CgoJCQlEUk1fREVCVUcoICJkaXNwYXRjaCBjbGVhciAlZCwlZC0lZCwlZCBmbGFncyAweCV4XG4iLAoJCQkJICAgeCwgeSwgdywgaCwgZmxhZ3MgKTsKCgkJCWlmICggZmxhZ3MgJiBSQURFT05fRlJPTlQgKSB7CgkJCQlCRUdJTl9SSU5HKCA2ICk7CgkJCQkKCQkJCU9VVF9SSU5HKCBDUF9QQUNLRVQzKCBSQURFT05fQ05UTF9QQUlOVF9NVUxUSSwgNCApICk7CgkJCQlPVVRfUklORyggUkFERU9OX0dNQ19EU1RfUElUQ0hfT0ZGU0VUX0NOVEwgfAoJCQkJCSAgUkFERU9OX0dNQ19CUlVTSF9TT0xJRF9DT0xPUiB8CgkJCQkJICAoZGV2X3ByaXYtPmNvbG9yX2ZtdCA8PCA4KSB8CgkJCQkJICBSQURFT05fR01DX1NSQ19EQVRBVFlQRV9DT0xPUiB8CgkJCQkJICBSQURFT05fUk9QM19QIHwKCQkJCQkgIFJBREVPTl9HTUNfQ0xSX0NNUF9DTlRMX0RJUyApOwoKCQkJCU9VVF9SSU5HKCBkZXZfcHJpdi0+ZnJvbnRfcGl0Y2hfb2Zmc2V0ICk7CgkJCQlPVVRfUklORyggY2xlYXItPmNsZWFyX2NvbG9yICk7CgkJCQkKCQkJCU9VVF9SSU5HKCAoeCA8PCAxNikgfCB5ICk7CgkJCQlPVVRfUklORyggKHcgPDwgMTYpIHwgaCApOwoJCQkJCgkJCQlBRFZBTkNFX1JJTkcoKTsKCQkJfQoJCQkKCQkJaWYgKCBmbGFncyAmIFJBREVPTl9CQUNLICkgewoJCQkJQkVHSU5fUklORyggNiApOwoJCQkJCgkJCQlPVVRfUklORyggQ1BfUEFDS0VUMyggUkFERU9OX0NOVExfUEFJTlRfTVVMVEksIDQgKSApOwoJCQkJT1VUX1JJTkcoIFJBREVPTl9HTUNfRFNUX1BJVENIX09GRlNFVF9DTlRMIHwKCQkJCQkgIFJBREVPTl9HTUNfQlJVU0hfU09MSURfQ09MT1IgfAoJCQkJCSAgKGRldl9wcml2LT5jb2xvcl9mbXQgPDwgOCkgfAoJCQkJCSAgUkFERU9OX0dNQ19TUkNfREFUQVRZUEVfQ09MT1IgfAoJCQkJCSAgUkFERU9OX1JPUDNfUCB8CgkJCQkJICBSQURFT05fR01DX0NMUl9DTVBfQ05UTF9ESVMgKTsKCQkJCQoJCQkJT1VUX1JJTkcoIGRldl9wcml2LT5iYWNrX3BpdGNoX29mZnNldCApOwoJCQkJT1VUX1JJTkcoIGNsZWFyLT5jbGVhcl9jb2xvciApOwoKCQkJCU9VVF9SSU5HKCAoeCA8PCAxNikgfCB5ICk7CgkJCQlPVVRfUklORyggKHcgPDwgMTYpIHwgaCApOwoKCQkJCUFEVkFOQ0VfUklORygpOwoJCQl9CgkJfQoJfQoJCgkvKiBoeXBlciB6IGNsZWFyICovCgkvKiBubyBkb2NzIGF2YWlsYWJsZSwgYmFzZWQgb24gcmV2ZXJzZSBlbmdlbmVlcmluZyBieSBTdGVwaGFuZSBNYXJjaGVzaW4gKi8KCWlmICgoZmxhZ3MgJiAoUkFERU9OX0RFUFRIIHwgUkFERU9OX1NURU5DSUwpKSAmJiAoZmxhZ3MgJiBSQURFT05fQ0xFQVJfRkFTVFopKSB7CgoJCWludCBpOwoJCWludCBkZXB0aHBpeHBlcmxpbmUgPSBkZXZfcHJpdi0+ZGVwdGhfZm10PT1SQURFT05fREVQVEhfRk9STUFUXzE2QklUX0lOVF9aPyAKCQkJKGRldl9wcml2LT5kZXB0aF9waXRjaCAvIDIpOiAoZGV2X3ByaXYtPmRlcHRoX3BpdGNoIC8gNCk7CgkJCgkJdTMyIGNsZWFybWFzazsKCgkJdTMyIHRlbXBSQjNEX0RFUFRIQ0xFQVJWQUxVRSA9IGNsZWFyLT5jbGVhcl9kZXB0aCB8CgkJCSgoY2xlYXItPmRlcHRoX21hc2sgJiAweGZmKSA8PCAyNCk7CgkKCQkKCQkvKiBNYWtlIHN1cmUgd2UgcmVzdG9yZSB0aGUgM0Qgc3RhdGUgbmV4dCB0aW1lLgoJCSAqIHdlIGhhdmVuJ3QgdG91Y2hlZCBhbnkgIm5vcm1hbCIgc3RhdGUgLSBzdGlsbCBuZWVkIHRoaXM/CgkJICovCgkJZGV2X3ByaXYtPnNhcmVhX3ByaXYtPmN0eF9vd25lciA9IDA7CgoJCWlmICgoZGV2X3ByaXYtPmZsYWdzICYgQ0hJUF9IQVNfSElFUlopICYmIChmbGFncyAmIFJBREVPTl9VU0VfSElFUlopKSB7CgkJLyogRklYTUUgOiByZXZlcnNlIGVuZ2luZWVyIHRoYXQgZm9yIFJ4MDAgY2FyZHMgKi8KCQkvKiBGSVhNRSA6IHRoZSBtYXNrIHN1cHBvc2VkbHkgY29udGFpbnMgbG93LXJlcyB6IHZhbHVlcy4gU28gY2FuJ3Qgc2V0CgkJICAganVzdCB0byB0aGUgbWF4ICgweGZmPyBvciBhY3R1YWxseSAweDNmZmY/KSwgbmVlZCB0byB0YWtlIHogY2xlYXIKCQkgICB2YWx1ZSBpbnRvIGFjY291bnQ/ICovCgkJLyogcGF0dGVybiBzZWVtcyB0byB3b3JrIGZvciByMTAwLCB0aG91Z2ggZ2V0IHNsaWdodAoJCSAgIHJlbmRlcmluZyBlcnJvcnMgd2l0aCBnbHhnZWFycy4gSWYgaGllcnogaXMgbm90IGVuYWJsZWQgZm9yIHIxMDAsCgkJICAgb25seSA0IGJpdHMgd2hpY2ggaW5kaWNhdGUgY2xlYXIgKDE1LDE2LDMxLDMyLCBhbGwgemVybykgbWF0dGVyLCB0aGUKCQkgICBvdGhlciBvbmVzIGFyZSBpZ25vcmVkLCBhbmQgdGhlIHNhbWUgY2xlYXIgbWFzayBjYW4gYmUgdXNlZC4gVGhhdCdzCgkJICAgdmVyeSBkaWZmZXJlbnQgYmVoYXZpb3VyIHRoYW4gUjIwMCB3aGljaCBuZWVkcyBkaWZmZXJlbnQgY2xlYXIgbWFzawoJCSAgIGFuZCBkaWZmZXJlbnQgbnVtYmVyIG9mIHRpbGVzIHRvIGNsZWFyIGlmIGhpZXJ6IGlzIGVuYWJsZWQgb3Igbm90ICE/IQoJCSovCgkJCWNsZWFybWFzayA9ICgweGZmPDwyMil8KDB4ZmY8PDYpfCAweDAwM2YwMDNmOwoJCX0KCQllbHNlIHsKCQkvKiBjbGVhciBtYXNrIDogY2hvb3NlcyB0aGUgY2xlYXJpbmcgcGF0dGVybi4KCQkgICBydjI1MDogY291bGQgYmUgdXNlZCB0byBjbGVhciBvbmx5IHBhcnRzIG9mIG1hY3JvdGlsZXMKCQkgICAoYnV0IHRoYXQgd291bGQgZ2V0IHJlYWxseSBjb21wbGljYXRlZC4uLik/CgkJICAgYml0IDAgYW5kIDEgKGVpdGhlciBvciBib3RoIG9mIHRoZW0gPyE/ISkgYXJlIHVzZWQgdG8KCQkgICBub3QgY2xlYXIgdGlsZSAob3IgbWF5YmUgb25lIG9mIHRoZSBiaXRzIGluZGljYXRlcyBpZiB0aGUgdGlsZSBpcwoJCSAgIGNvbXByZXNzZWQgb3Igbm90KSwgYml0IDIgYW5kIDMgdG8gbm90IGNsZWFyIHRpbGUgMSwuLi4sLgoJCSAgIFBhdHRlcm4gaXMgYXMgZm9sbG93czoKCQkgICAgICAgIHwgMCwxIHwgNCw1IHwgOCw5IHwxMiwxM3wxNiwxN3wyMCwyMXwyNCwyNXwyOCwyOXwKCQkgICBiaXRzIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCQkgICAgICAgIHwgMiwzIHwgNiw3IHwxMCwxMXwxNCwxNXwxOCwxOXwyMiwyM3wyNiwyN3wzMCwzMXwKCQkgICBydjEwMDogY2xlYXJtYXNrIGNvdmVycyAyeDggNHgxIHRpbGVzLCBidXQgb25lIGNsZWFyIHN0aWxsCgkJICAgY292ZXJzIDI1NiBwaXhlbHMgPyE/CgkJKi8KCQkJY2xlYXJtYXNrID0gMHgwOwoJCX0KCgkJQkVHSU5fUklORyggOCApOwoJCVJBREVPTl9XQUlUX1VOVElMXzJEX0lETEUoKTsKCQlPVVRfUklOR19SRUcoIFJBREVPTl9SQjNEX0RFUFRIQ0xFQVJWQUxVRSwKCQkJdGVtcFJCM0RfREVQVEhDTEVBUlZBTFVFKTsKCQkvKiB3aGF0IG9mZnNldCBpcyB0aGlzIGV4YWN0bHkgPyAqLwoJCU9VVF9SSU5HX1JFRyggUkFERU9OX1JCM0RfWk1BU0tPRkZTRVQsIDAgKTsKCQkvKiBuZWVkIGN0bHN0YXQsIG90aGVyd2lzZSBnZXQgc29tZSBzdHJhbmdlIGJsYWNrIGZsaWNrZXJpbmcgKi8KCQlPVVRfUklOR19SRUcoIFJBREVPTl9SQjNEX1pDQUNIRV9DVExTVEFULCBSQURFT05fUkIzRF9aQ19GTFVTSF9BTEwgKTsKCQlBRFZBTkNFX1JJTkcoKTsKCgkJZm9yIChpID0gMDsgaSA8IG5ib3g7IGkrKykgewoJCQlpbnQgdGlsZW9mZnNldCwgbnJ0aWxlc3gsIG5ydGlsZXN5LCBqOwoJCQkvKiBpdCBsb29rcyBsaWtlIHIyMDAgbmVlZHMgcnYtc3R5bGUgY2xlYXJzLCBhdCBsZWFzdCBpZiBoaWVyeiBpcyBub3QgZW5hYmxlZD8gKi8KCQkJaWYgKChkZXZfcHJpdi0+ZmxhZ3MmQ0hJUF9IQVNfSElFUlopICYmICEoZGV2X3ByaXYtPm1pY3JvY29kZV92ZXJzaW9uPT1VQ09ERV9SMjAwKSkgewoJCQkJLyogRklYTUUgOiBmaWd1cmUgdGhpcyBvdXQgZm9yIHIyMDAgKHdoZW4gaGllcnogaXMgZW5hYmxlZCkuIE9yCgkJCQkgICBtYXliZSByMjAwIGFjdHVhbGx5IGRvZXNuJ3QgbmVlZCB0byBwdXQgdGhlIGxvdy1yZXMgeiB2YWx1ZSBpbnRvCgkJCQkgICB0aGUgdGlsZSBjYWNoZSBsaWtlIHIxMDAsIGJ1dCBqdXN0IG5lZWRzIHRvIGNsZWFyIHRoZSBoaS1sZXZlbCB6LWJ1ZmZlcj8KCQkJCSAgIFdvcmtzIGZvciBSMTAwLCBib3RoIHdpdGggaGllcnogYW5kIHdpdGhvdXQuCgkJCQkgICBSMTAwIHNlZW1zIHRvIG9wZXJhdGUgb24gMngxIDh4OCB0aWxlcywgYnV0Li4uCgkJCQkgICBvZGQ6IG9mZnNldC9ucnRpbGVzIG5lZWQgdG8gYmUgNjQgcGl4ICg0IGJsb2NrKSBhbGlnbmVkPyBQb3RlbnRpYWxseQoJCQkJICAgcHJvYmxlbWF0aWMgd2l0aCByZXNvbHV0aW9ucyB3aGljaCBhcmUgbm90IDY0IHBpeCBhbGlnbmVkPyAqLwoJCQkJdGlsZW9mZnNldCA9ICgocGJveFtpXS55MSA+PiAzKSAqIGRlcHRocGl4cGVybGluZSArIHBib3hbaV0ueDEpID4+IDY7CgkJCQlucnRpbGVzeCA9ICgocGJveFtpXS54MiAmIH42MykgLSAocGJveFtpXS54MSAmIH42MykpID4+IDQ7CgkJCQlucnRpbGVzeSA9IChwYm94W2ldLnkyID4+IDMpIC0gKHBib3hbaV0ueTEgPj4gMyk7CgkJCQlmb3IgKGogPSAwOyBqIDw9IG5ydGlsZXN5OyBqKyspIHsKCQkJCQlCRUdJTl9SSU5HKCA0ICk7CgkJCQkJT1VUX1JJTkcoIENQX1BBQ0tFVDMoIFJBREVPTl8zRF9DTEVBUl9aTUFTSywgMiApICk7CgkJCQkJLyogZmlyc3QgdGlsZSAqLwoJCQkJCU9VVF9SSU5HKCB0aWxlb2Zmc2V0ICogOCApOwoJCQkJCS8qIHRoZSBudW1iZXIgb2YgdGlsZXMgdG8gY2xlYXIgKi8KCQkJCQlPVVRfUklORyggbnJ0aWxlc3ggKyA0ICk7CgkJCQkJLyogY2xlYXIgbWFzayA6IGNob29zZXMgdGhlIGNsZWFyaW5nIHBhdHRlcm4uICovCgkJCQkJT1VUX1JJTkcoIGNsZWFybWFzayApOwoJCQkJCUFEVkFOQ0VfUklORygpOwoJCQkJCXRpbGVvZmZzZXQgKz0gZGVwdGhwaXhwZXJsaW5lID4+IDY7CgkJCQl9CgkJCX0KCQkJZWxzZSBpZiAoZGV2X3ByaXYtPm1pY3JvY29kZV92ZXJzaW9uPT1VQ09ERV9SMjAwKSB7CgkJCQkvKiB3b3JrcyBmb3IgcnYyNTAuICovCgkJCQkvKiBmaW5kIGZpcnN0IG1hY3JvIHRpbGUgKDh4MiA0eDQgei1waXhlbHMgb24gcnYyNTApICovCgkJCQl0aWxlb2Zmc2V0ID0gKChwYm94W2ldLnkxID4+IDMpICogZGVwdGhwaXhwZXJsaW5lICsgcGJveFtpXS54MSkgPj4gNTsKCQkJCW5ydGlsZXN4ID0gKHBib3hbaV0ueDIgPj4gNSkgLSAocGJveFtpXS54MSA+PiA1KTsKCQkJCW5ydGlsZXN5ID0gKHBib3hbaV0ueTIgPj4gMykgLSAocGJveFtpXS55MSA+PiAzKTsKCQkJCWZvciAoaiA9IDA7IGogPD0gbnJ0aWxlc3k7IGorKykgewoJCQkJCUJFR0lOX1JJTkcoIDQgKTsKCQkJCQlPVVRfUklORyggQ1BfUEFDS0VUMyggUkFERU9OXzNEX0NMRUFSX1pNQVNLLCAyICkgKTsKCQkJCQkvKiBmaXJzdCB0aWxlICovCgkJCQkJLyoganVkZ2luZyBieSB0aGUgZmlyc3QgdGlsZSBvZmZzZXQgbmVlZGVkLCBjb3VsZCBwb3NzaWJseQoJCQkJCSAgIGRpcmVjdGx5IGFkZHJlc3MvY2xlYXIgNHg0IHRpbGVzIGluc3RlYWQgb2YgOHgyICogNHg0CgkJCQkJICAgbWFjcm8gdGlsZXMsIHRob3VnaCB3b3VsZCBzdGlsbCBuZWVkIGNsZWFyIG1hc2sgZm9yCgkJCQkJICAgcmlnaHQvYm90dG9tIGlmIHRydWVseSA0eDQgZ3JhbnVsYXJpdHkgaXMgZGVzaXJlZCA/ICovCgkJCQkJT1VUX1JJTkcoIHRpbGVvZmZzZXQgKiAxNiApOwoJCQkJCS8qIHRoZSBudW1iZXIgb2YgdGlsZXMgdG8gY2xlYXIgKi8KCQkJCQlPVVRfUklORyggbnJ0aWxlc3ggKyAxICk7CgkJCQkJLyogY2xlYXIgbWFzayA6IGNob29zZXMgdGhlIGNsZWFyaW5nIHBhdHRlcm4uICovCgkJCQkJT1VUX1JJTkcoIGNsZWFybWFzayApOwoJCQkJCUFEVkFOQ0VfUklORygpOwoJCQkJCXRpbGVvZmZzZXQgKz0gZGVwdGhwaXhwZXJsaW5lID4+IDU7CgkJCQl9CgkJCX0KCQkJZWxzZSB7IC8qIHJ2IDEwMCAqLwoJCQkJLyogcnYxMDAgbWlnaHQgbm90IG5lZWQgNjQgcGl4IGFsaWdubWVudCwgd2hvIGtub3dzICovCgkJCQkvKiBvZmZzZXRzIGFyZSwgaG1tLCB3ZWlyZCAqLwoJCQkJdGlsZW9mZnNldCA9ICgocGJveFtpXS55MSA+PiA0KSAqIGRlcHRocGl4cGVybGluZSArIHBib3hbaV0ueDEpID4+IDY7CgkJCQlucnRpbGVzeCA9ICgocGJveFtpXS54MiAmIH42MykgLSAocGJveFtpXS54MSAmIH42MykpID4+IDQ7CgkJCQlucnRpbGVzeSA9IChwYm94W2ldLnkyID4+IDQpIC0gKHBib3hbaV0ueTEgPj4gNCk7CgkJCQlmb3IgKGogPSAwOyBqIDw9IG5ydGlsZXN5OyBqKyspIHsKCQkJCQlCRUdJTl9SSU5HKCA0ICk7CgkJCQkJT1VUX1JJTkcoIENQX1BBQ0tFVDMoIFJBREVPTl8zRF9DTEVBUl9aTUFTSywgMiApICk7CgkJCQkJT1VUX1JJTkcoIHRpbGVvZmZzZXQgKiAxMjggKTsKCQkJCQkvKiB0aGUgbnVtYmVyIG9mIHRpbGVzIHRvIGNsZWFyICovCgkJCQkJT1VUX1JJTkcoIG5ydGlsZXN4ICsgNCApOwoJCQkJCS8qIGNsZWFyIG1hc2sgOiBjaG9vc2VzIHRoZSBjbGVhcmluZyBwYXR0ZXJuLiAqLwoJCQkJCU9VVF9SSU5HKCBjbGVhcm1hc2sgKTsKCQkJCQlBRFZBTkNFX1JJTkcoKTsKCQkJCQl0aWxlb2Zmc2V0ICs9IGRlcHRocGl4cGVybGluZSA+PiA2OwoJCQkJfQoJCQl9CgkJfQoKCQkvKiBUT0RPIGRvbid0IGFsd2F5cyBjbGVhciBhbGwgaGktbGV2ZWwgeiB0aWxlcyAqLwoJCWlmICgoZGV2X3ByaXYtPmZsYWdzICYgQ0hJUF9IQVNfSElFUlopICYmIChkZXZfcHJpdi0+bWljcm9jb2RlX3ZlcnNpb249PVVDT0RFX1IyMDApCgkJCSYmIChmbGFncyAmIFJBREVPTl9VU0VfSElFUlopKQoJCS8qIHIxMDAgYW5kIGNhcmRzIHdpdGhvdXQgaGllcmFyY2hpY2FsIHotYnVmZmVyIGhhdmUgbm8gaGlnaC1sZXZlbCB6LWJ1ZmZlciAqLwoJCS8qIEZJWE1FIDogdGhlIG1hc2sgc3VwcG9zZWRseSBjb250YWlucyBsb3ctcmVzIHogdmFsdWVzLiBTbyBjYW4ndCBzZXQKCQkgICBqdXN0IHRvIHRoZSBtYXggKDB4ZmY/IG9yIGFjdHVhbGx5IDB4M2ZmZj8pLCBuZWVkIHRvIHRha2UgeiBjbGVhcgoJCSAgIHZhbHVlIGludG8gYWNjb3VudD8gKi8KCQl7CgkJCUJFR0lOX1JJTkcoIDQgKTsKCQkJT1VUX1JJTkcoIENQX1BBQ0tFVDMoIFJBREVPTl8zRF9DTEVBUl9ISVosIDIgKSApOwoJCQlPVVRfUklORyggMHgwICk7IC8qIEZpcnN0IHRpbGUgKi8KCQkJT1VUX1JJTkcoIDB4M2NjMCApOwoJCQlPVVRfUklORyggKDB4ZmY8PDIyKXwoMHhmZjw8Nil8IDB4MDAzZjAwM2YpOwoJCQlBRFZBTkNFX1JJTkcoKTsKCQl9Cgl9CgoJLyogV2UgaGF2ZSB0byBjbGVhciB0aGUgZGVwdGggYW5kL29yIHN0ZW5jaWwgYnVmZmVycyBieQoJICogcmVuZGVyaW5nIGEgcXVhZCBpbnRvIGp1c3QgdGhvc2UgYnVmZmVycy4gIFRodXMsIHdlIGhhdmUgdG8KCSAqIG1ha2Ugc3VyZSB0aGUgM0QgZW5naW5lIGlzIGNvbmZpZ3VyZWQgY29ycmVjdGx5LgoJICovCglpZiAoKGRldl9wcml2LT5taWNyb2NvZGVfdmVyc2lvbiA9PSBVQ09ERV9SMjAwKSAmJgoJICAgIChmbGFncyAmIChSQURFT05fREVQVEggfCBSQURFT05fU1RFTkNJTCkpKSB7CgoJCWludCB0ZW1wUFBfQ05UTDsKCQlpbnQgdGVtcFJFX0NOVEw7CgkJaW50IHRlbXBSQjNEX0NOVEw7CgkJaW50IHRlbXBSQjNEX1pTVEVOQ0lMQ05UTDsKCQlpbnQgdGVtcFJCM0RfU1RFTkNJTFJFRk1BU0s7CgkJaW50IHRlbXBSQjNEX1BMQU5FTUFTSzsKCQlpbnQgdGVtcFNFX0NOVEw7CgkJaW50IHRlbXBTRV9WVEVfQ05UTDsKCQlpbnQgdGVtcFNFX1ZUWF9GTVRfMDsKCQlpbnQgdGVtcFNFX1ZUWF9GTVRfMTsKCQlpbnQgdGVtcFNFX1ZBUF9DTlRMOwoJCWludCB0ZW1wUkVfQVVYX1NDSVNTT1JfQ05UTDsKCgkJdGVtcFBQX0NOVEwgPSAwOwoJCXRlbXBSRV9DTlRMID0gMDsKCgkJdGVtcFJCM0RfQ05UTCA9IGRlcHRoX2NsZWFyLT5yYjNkX2NudGw7CgoJCXRlbXBSQjNEX1pTVEVOQ0lMQ05UTCA9IGRlcHRoX2NsZWFyLT5yYjNkX3pzdGVuY2lsY250bDsKCQl0ZW1wUkIzRF9TVEVOQ0lMUkVGTUFTSyA9IDB4MDsKCgkJdGVtcFNFX0NOVEwgPSBkZXB0aF9jbGVhci0+c2VfY250bDsKCgoKCQkvKiBEaXNhYmxlIFRDTCAqLwoKCQl0ZW1wU0VfVkFQX0NOVEwgPSAoLyogU0VfVkFQX0NOVExfX0ZPUkNFX1dfVE9fT05FX01BU0sgfCAgKi8KCQkJCSAgICgweDkgPDwgU0VfVkFQX0NOVExfX1ZGX01BWF9WVFhfTlVNX19TSElGVCkpOwoKCQl0ZW1wUkIzRF9QTEFORU1BU0sgPSAweDA7CgoJCXRlbXBSRV9BVVhfU0NJU1NPUl9DTlRMID0gMHgwOwoKCQl0ZW1wU0VfVlRFX0NOVEwgPQoJCQlTRV9WVEVfQ05UTF9fVlRYX1hZX0ZNVF9NQVNLIHwKCQkJU0VfVlRFX0NOVExfX1ZUWF9aX0ZNVF9NQVNLOwoKCQkvKiBWZXJ0ZXggZm9ybWF0IChYLCBZLCBaLCBXKSovCgkJdGVtcFNFX1ZUWF9GTVRfMCA9CgkJCVNFX1ZUWF9GTVRfMF9fVlRYX1owX1BSRVNFTlRfTUFTSyB8CgkJCVNFX1ZUWF9GTVRfMF9fVlRYX1cwX1BSRVNFTlRfTUFTSzsKCQl0ZW1wU0VfVlRYX0ZNVF8xID0gMHgwOwoKCgkJLyogCgkJICogRGVwdGggYnVmZmVyIHNwZWNpZmljIGVuYWJsZXMgCgkJICovCgkJaWYgKGZsYWdzICYgUkFERU9OX0RFUFRIKSB7CgkJCS8qIEVuYWJsZSBkZXB0aCBidWZmZXIgKi8KCQkJdGVtcFJCM0RfQ05UTCB8PSBSQURFT05fWl9FTkFCTEU7CgkJfSBlbHNlIHsKCQkJLyogRGlzYWJsZSBkZXB0aCBidWZmZXIgKi8KCQkJdGVtcFJCM0RfQ05UTCAmPSB+UkFERU9OX1pfRU5BQkxFOwoJCX0KCgkJLyogCgkJICogU3RlbmNpbCBidWZmZXIgc3BlY2lmaWMgZW5hYmxlcwoJCSAqLwoJCWlmICggZmxhZ3MgJiBSQURFT05fU1RFTkNJTCApIHsKCQkJdGVtcFJCM0RfQ05UTCB8PSAgUkFERU9OX1NURU5DSUxfRU5BQkxFOwoJCQl0ZW1wUkIzRF9TVEVOQ0lMUkVGTUFTSyA9IGNsZWFyLT5kZXB0aF9tYXNrOyAKCQl9IGVsc2UgewoJCQl0ZW1wUkIzRF9DTlRMICY9IH5SQURFT05fU1RFTkNJTF9FTkFCTEU7CgkJCXRlbXBSQjNEX1NURU5DSUxSRUZNQVNLID0gMHgwMDAwMDAwMDsKCQl9CgoJCWlmIChmbGFncyAmIFJBREVPTl9VU0VfQ09NUF9aQlVGKSB7CgkJCXRlbXBSQjNEX1pTVEVOQ0lMQ05UTCB8PSBSQURFT05fWl9DT01QUkVTU0lPTl9FTkFCTEUgfAoJCQkJUkFERU9OX1pfREVDT01QUkVTU0lPTl9FTkFCTEU7CgkJfQoJCWlmIChmbGFncyAmIFJBREVPTl9VU0VfSElFUlopIHsKCQkJdGVtcFJCM0RfWlNURU5DSUxDTlRMIHw9IFJBREVPTl9aX0hJRVJBUkNIWV9FTkFCTEU7CgkJfQoKCQlCRUdJTl9SSU5HKCAyNiApOwoJCVJBREVPTl9XQUlUX1VOVElMXzJEX0lETEUoKTsKCgkJT1VUX1JJTkdfUkVHKCBSQURFT05fUFBfQ05UTCwgdGVtcFBQX0NOVEwgKTsKCQlPVVRfUklOR19SRUcoIFIyMDBfUkVfQ05UTCwgdGVtcFJFX0NOVEwgKTsKCQlPVVRfUklOR19SRUcoIFJBREVPTl9SQjNEX0NOVEwsIHRlbXBSQjNEX0NOVEwgKTsKCQlPVVRfUklOR19SRUcoIFJBREVPTl9SQjNEX1pTVEVOQ0lMQ05UTCwKCQkJICAgICAgdGVtcFJCM0RfWlNURU5DSUxDTlRMICk7CgkJT1VUX1JJTkdfUkVHKCBSQURFT05fUkIzRF9TVEVOQ0lMUkVGTUFTSywgCgkJCSAgICAgIHRlbXBSQjNEX1NURU5DSUxSRUZNQVNLICk7CgkJT1VUX1JJTkdfUkVHKCBSQURFT05fUkIzRF9QTEFORU1BU0ssIHRlbXBSQjNEX1BMQU5FTUFTSyApOwoJCU9VVF9SSU5HX1JFRyggUkFERU9OX1NFX0NOVEwsIHRlbXBTRV9DTlRMICk7CgkJT1VUX1JJTkdfUkVHKCBSMjAwX1NFX1ZURV9DTlRMLCB0ZW1wU0VfVlRFX0NOVEwgKTsKCQlPVVRfUklOR19SRUcoIFIyMDBfU0VfVlRYX0ZNVF8wLCB0ZW1wU0VfVlRYX0ZNVF8wICk7CgkJT1VUX1JJTkdfUkVHKCBSMjAwX1NFX1ZUWF9GTVRfMSwgdGVtcFNFX1ZUWF9GTVRfMSApOwoJCU9VVF9SSU5HX1JFRyggUjIwMF9TRV9WQVBfQ05UTCwgdGVtcFNFX1ZBUF9DTlRMICk7CgkJT1VUX1JJTkdfUkVHKCBSMjAwX1JFX0FVWF9TQ0lTU09SX0NOVEwsIAoJCQkgICAgICB0ZW1wUkVfQVVYX1NDSVNTT1JfQ05UTCApOwoJCUFEVkFOQ0VfUklORygpOwoKCQkvKiBNYWtlIHN1cmUgd2UgcmVzdG9yZSB0aGUgM0Qgc3RhdGUgbmV4dCB0aW1lLgoJCSAqLwoJCWRldl9wcml2LT5zYXJlYV9wcml2LT5jdHhfb3duZXIgPSAwOwoKCQlmb3IgKCBpID0gMCA7IGkgPCBuYm94IDsgaSsrICkgewoJCQkKCQkJLyogRnVubnkgdGhhdCB0aGlzIHNob3VsZCBiZSByZXF1aXJlZCAtLSAKCQkJICogIHNldHMgdG9wLWxlZnQ/CgkJCSAqLwoJCQlyYWRlb25fZW1pdF9jbGlwX3JlY3QoIGRldl9wcml2LAoJCQkJCSAgICAgICAmc2FyZWFfcHJpdi0+Ym94ZXNbaV0gKTsKCgkJCUJFR0lOX1JJTkcoIDE0ICk7CgkJCU9VVF9SSU5HKCBDUF9QQUNLRVQzKCBSMjAwXzNEX0RSQVdfSU1NRF8yLCAxMiApICk7CgkJCU9VVF9SSU5HKCAoUkFERU9OX1BSSU1fVFlQRV9SRUNUX0xJU1QgfAoJCQkJICAgUkFERU9OX1BSSU1fV0FMS19SSU5HIHwKCQkJCSAgICgzIDw8IFJBREVPTl9OVU1fVkVSVElDRVNfU0hJRlQpKSApOwoJCQlPVVRfUklORyggZGVwdGhfYm94ZXNbaV0udWlbQ0xFQVJfWDFdICk7CgkJCU9VVF9SSU5HKCBkZXB0aF9ib3hlc1tpXS51aVtDTEVBUl9ZMV0gKTsKCQkJT1VUX1JJTkcoIGRlcHRoX2JveGVzW2ldLnVpW0NMRUFSX0RFUFRIXSApOwoJCQlPVVRfUklORyggMHgzZjgwMDAwMCApOwoJCQlPVVRfUklORyggZGVwdGhfYm94ZXNbaV0udWlbQ0xFQVJfWDFdICk7CgkJCU9VVF9SSU5HKCBkZXB0aF9ib3hlc1tpXS51aVtDTEVBUl9ZMl0gKTsKCQkJT1VUX1JJTkcoIGRlcHRoX2JveGVzW2ldLnVpW0NMRUFSX0RFUFRIXSApOwoJCQlPVVRfUklORyggMHgzZjgwMDAwMCApOwoJCQlPVVRfUklORyggZGVwdGhfYm94ZXNbaV0udWlbQ0xFQVJfWDJdICk7CgkJCU9VVF9SSU5HKCBkZXB0aF9ib3hlc1tpXS51aVtDTEVBUl9ZMl0gKTsKCQkJT1VUX1JJTkcoIGRlcHRoX2JveGVzW2ldLnVpW0NMRUFSX0RFUFRIXSApOwoJCQlPVVRfUklORyggMHgzZjgwMDAwMCApOwoJCQlBRFZBTkNFX1JJTkcoKTsKCQl9Cgl9IAoJZWxzZSBpZiAoIChmbGFncyAmIChSQURFT05fREVQVEggfCBSQURFT05fU1RFTkNJTCkpICkgewoKCQlpbnQgdGVtcFJCM0RfWlNURU5DSUxDTlRMID0gZGVwdGhfY2xlYXItPnJiM2RfenN0ZW5jaWxjbnRsOwoKCQlyYjNkX2NudGwgPSBkZXB0aF9jbGVhci0+cmIzZF9jbnRsOwoKCQlpZiAoIGZsYWdzICYgUkFERU9OX0RFUFRIICkgewoJCQlyYjNkX2NudGwgfD0gIFJBREVPTl9aX0VOQUJMRTsKCQl9IGVsc2UgewoJCQlyYjNkX2NudGwgJj0gflJBREVPTl9aX0VOQUJMRTsKCQl9CgoJCWlmICggZmxhZ3MgJiBSQURFT05fU1RFTkNJTCApIHsKCQkJcmIzZF9jbnRsIHw9ICBSQURFT05fU1RFTkNJTF9FTkFCTEU7CgkJCXJiM2Rfc3RlbmNpbHJlZm1hc2sgPSBjbGVhci0+ZGVwdGhfbWFzazsgLyogbWlzbmFtZWQgZmllbGQgKi8KCQl9IGVsc2UgewoJCQlyYjNkX2NudGwgJj0gflJBREVPTl9TVEVOQ0lMX0VOQUJMRTsKCQkJcmIzZF9zdGVuY2lscmVmbWFzayA9IDB4MDAwMDAwMDA7CgkJfQoKCQlpZiAoZmxhZ3MgJiBSQURFT05fVVNFX0NPTVBfWkJVRikgewoJCQl0ZW1wUkIzRF9aU1RFTkNJTENOVEwgfD0gUkFERU9OX1pfQ09NUFJFU1NJT05fRU5BQkxFIHwKCQkJCVJBREVPTl9aX0RFQ09NUFJFU1NJT05fRU5BQkxFOwoJCX0KCQlpZiAoZmxhZ3MgJiBSQURFT05fVVNFX0hJRVJaKSB7CgkJCXRlbXBSQjNEX1pTVEVOQ0lMQ05UTCB8PSBSQURFT05fWl9ISUVSQVJDSFlfRU5BQkxFOwoJCX0KCgkJQkVHSU5fUklORyggMTMgKTsKCQlSQURFT05fV0FJVF9VTlRJTF8yRF9JRExFKCk7CgoJCU9VVF9SSU5HKCBDUF9QQUNLRVQwKCBSQURFT05fUFBfQ05UTCwgMSApICk7CgkJT1VUX1JJTkcoIDB4MDAwMDAwMDAgKTsKCQlPVVRfUklORyggcmIzZF9jbnRsICk7CgkJCgkJT1VUX1JJTkdfUkVHKCBSQURFT05fUkIzRF9aU1RFTkNJTENOVEwsIHRlbXBSQjNEX1pTVEVOQ0lMQ05UTCApOwoJCU9VVF9SSU5HX1JFRyggUkFERU9OX1JCM0RfU1RFTkNJTFJFRk1BU0ssCgkJCSAgICAgIHJiM2Rfc3RlbmNpbHJlZm1hc2sgKTsKCQlPVVRfUklOR19SRUcoIFJBREVPTl9SQjNEX1BMQU5FTUFTSywKCQkJICAgICAgMHgwMDAwMDAwMCApOwoJCU9VVF9SSU5HX1JFRyggUkFERU9OX1NFX0NOVEwsCgkJCSAgICAgIGRlcHRoX2NsZWFyLT5zZV9jbnRsICk7CgkJQURWQU5DRV9SSU5HKCk7CgoJCS8qIE1ha2Ugc3VyZSB3ZSByZXN0b3JlIHRoZSAzRCBzdGF0ZSBuZXh0IHRpbWUuCgkJICovCgkJZGV2X3ByaXYtPnNhcmVhX3ByaXYtPmN0eF9vd25lciA9IDA7CgoJCWZvciAoIGkgPSAwIDsgaSA8IG5ib3ggOyBpKysgKSB7CgkJCQoJCQkvKiBGdW5ueSB0aGF0IHRoaXMgc2hvdWxkIGJlIHJlcXVpcmVkIC0tIAoJCQkgKiAgc2V0cyB0b3AtbGVmdD8KCQkJICovCgkJCXJhZGVvbl9lbWl0X2NsaXBfcmVjdCggZGV2X3ByaXYsCgkJCQkJICAgICAgICZzYXJlYV9wcml2LT5ib3hlc1tpXSApOwoKCQkJQkVHSU5fUklORyggMTUgKTsKCgkJCU9VVF9SSU5HKCBDUF9QQUNLRVQzKCBSQURFT05fM0RfRFJBV19JTU1ELCAxMyApICk7CgkJCU9VVF9SSU5HKCBSQURFT05fVlRYX1pfUFJFU0VOVCB8CgkJCQkgIFJBREVPTl9WVFhfUEtDT0xPUl9QUkVTRU5UKTsKCQkJT1VUX1JJTkcoIChSQURFT05fUFJJTV9UWVBFX1JFQ1RfTElTVCB8CgkJCQkgICBSQURFT05fUFJJTV9XQUxLX1JJTkcgfAoJCQkJICAgUkFERU9OX01BT1NfRU5BQkxFIHwKCQkJCSAgIFJBREVPTl9WVFhfRk1UX1JBREVPTl9NT0RFIHwKCQkJCSAgICgzIDw8IFJBREVPTl9OVU1fVkVSVElDRVNfU0hJRlQpKSApOwoKCgkJCU9VVF9SSU5HKCBkZXB0aF9ib3hlc1tpXS51aVtDTEVBUl9YMV0gKTsKCQkJT1VUX1JJTkcoIGRlcHRoX2JveGVzW2ldLnVpW0NMRUFSX1kxXSApOwoJCQlPVVRfUklORyggZGVwdGhfYm94ZXNbaV0udWlbQ0xFQVJfREVQVEhdICk7CgkJCU9VVF9SSU5HKCAweDAgKTsKCgkJCU9VVF9SSU5HKCBkZXB0aF9ib3hlc1tpXS51aVtDTEVBUl9YMV0gKTsKCQkJT1VUX1JJTkcoIGRlcHRoX2JveGVzW2ldLnVpW0NMRUFSX1kyXSApOwoJCQlPVVRfUklORyggZGVwdGhfYm94ZXNbaV0udWlbQ0xFQVJfREVQVEhdICk7CgkJCU9VVF9SSU5HKCAweDAgKTsKCgkJCU9VVF9SSU5HKCBkZXB0aF9ib3hlc1tpXS51aVtDTEVBUl9YMl0gKTsKCQkJT1VUX1JJTkcoIGRlcHRoX2JveGVzW2ldLnVpW0NMRUFSX1kyXSApOwoJCQlPVVRfUklORyggZGVwdGhfYm94ZXNbaV0udWlbQ0xFQVJfREVQVEhdICk7CgkJCU9VVF9SSU5HKCAweDAgKTsKCgkJCUFEVkFOQ0VfUklORygpOwoJCX0KCX0KCgkvKiBJbmNyZW1lbnQgdGhlIGNsZWFyIGNvdW50ZXIuICBUaGUgY2xpZW50LXNpZGUgM0QgZHJpdmVyIG11c3QKCSAqIHdhaXQgb24gdGhpcyB2YWx1ZSBiZWZvcmUgcGVyZm9ybWluZyB0aGUgY2xlYXIgaW9jdGwuICBXZQoJICogbmVlZCB0aGlzIGJlY2F1c2UgdGhlIGNhcmQncyBzbyBkYW1uZWQgZmFzdC4uLgoJICovCglkZXZfcHJpdi0+c2FyZWFfcHJpdi0+bGFzdF9jbGVhcisrOwoKCUJFR0lOX1JJTkcoIDQgKTsKCglSQURFT05fQ0xFQVJfQUdFKCBkZXZfcHJpdi0+c2FyZWFfcHJpdi0+bGFzdF9jbGVhciApOwoJUkFERU9OX1dBSVRfVU5USUxfSURMRSgpOwoKCUFEVkFOQ0VfUklORygpOwp9CgpzdGF0aWMgdm9pZCByYWRlb25fY3BfZGlzcGF0Y2hfc3dhcCggZHJtX2RldmljZV90ICpkZXYgKQp7Cglkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoJZHJtX3JhZGVvbl9zYXJlYV90ICpzYXJlYV9wcml2ID0gZGV2X3ByaXYtPnNhcmVhX3ByaXY7CglpbnQgbmJveCA9IHNhcmVhX3ByaXYtPm5ib3g7Cglkcm1fY2xpcF9yZWN0X3QgKnBib3ggPSBzYXJlYV9wcml2LT5ib3hlczsKCWludCBpOwoJUklOR19MT0NBTFM7CglEUk1fREVCVUcoICJcbiIgKTsKCgkvKiBEbyBzb21lIHRyaXZpYWwgcGVyZm9ybWFuY2UgbW9uaXRvcmluZy4uLgoJICovCglpZiAoZGV2X3ByaXYtPmRvX2JveGVzKQoJCXJhZGVvbl9jcF9wZXJmb3JtYW5jZV9ib3hlcyggZGV2X3ByaXYgKTsKCgoJLyogV2FpdCBmb3IgdGhlIDNEIHN0cmVhbSB0byBpZGxlIGJlZm9yZSBkaXNwYXRjaGluZyB0aGUgYml0Ymx0LgoJICogVGhpcyB3aWxsIHByZXZlbnQgZGF0YSBjb3JydXB0aW9uIGJldHdlZW4gdGhlIHR3byBzdHJlYW1zLgoJICovCglCRUdJTl9SSU5HKCAyICk7CgoJUkFERU9OX1dBSVRfVU5USUxfM0RfSURMRSgpOwoKCUFEVkFOQ0VfUklORygpOwoKCWZvciAoIGkgPSAwIDsgaSA8IG5ib3ggOyBpKysgKSB7CgkJaW50IHggPSBwYm94W2ldLngxOwoJCWludCB5ID0gcGJveFtpXS55MTsKCQlpbnQgdyA9IHBib3hbaV0ueDIgLSB4OwoJCWludCBoID0gcGJveFtpXS55MiAtIHk7CgoJCURSTV9ERUJVRyggImRpc3BhdGNoIHN3YXAgJWQsJWQtJWQsJWRcbiIsCgkJCSAgIHgsIHksIHcsIGggKTsKCgkJQkVHSU5fUklORyggNyApOwoKCQlPVVRfUklORyggQ1BfUEFDS0VUMyggUkFERU9OX0NOVExfQklUQkxUX01VTFRJLCA1ICkgKTsKCQlPVVRfUklORyggUkFERU9OX0dNQ19TUkNfUElUQ0hfT0ZGU0VUX0NOVEwgfAoJCQkgIFJBREVPTl9HTUNfRFNUX1BJVENIX09GRlNFVF9DTlRMIHwKCQkJICBSQURFT05fR01DX0JSVVNIX05PTkUgfAoJCQkgIChkZXZfcHJpdi0+Y29sb3JfZm10IDw8IDgpIHwKCQkJICBSQURFT05fR01DX1NSQ19EQVRBVFlQRV9DT0xPUiB8CgkJCSAgUkFERU9OX1JPUDNfUyB8CgkJCSAgUkFERU9OX0RQX1NSQ19TT1VSQ0VfTUVNT1JZIHwKCQkJICBSQURFT05fR01DX0NMUl9DTVBfQ05UTF9ESVMgfAoJCQkgIFJBREVPTl9HTUNfV1JfTVNLX0RJUyApOwoJCQoJCS8qIE1ha2UgdGhpcyB3b3JrIGV2ZW4gaWYgZnJvbnQgJiBiYWNrIGFyZSBmbGlwcGVkOgoJCSAqLwoJCWlmIChkZXZfcHJpdi0+Y3VycmVudF9wYWdlID09IDApIHsKCQkJT1VUX1JJTkcoIGRldl9wcml2LT5iYWNrX3BpdGNoX29mZnNldCApOwoJCQlPVVRfUklORyggZGV2X3ByaXYtPmZyb250X3BpdGNoX29mZnNldCApOwoJCX0gCgkJZWxzZSB7CgkJCU9VVF9SSU5HKCBkZXZfcHJpdi0+ZnJvbnRfcGl0Y2hfb2Zmc2V0ICk7CgkJCU9VVF9SSU5HKCBkZXZfcHJpdi0+YmFja19waXRjaF9vZmZzZXQgKTsKCQl9CgoJCU9VVF9SSU5HKCAoeCA8PCAxNikgfCB5ICk7CgkJT1VUX1JJTkcoICh4IDw8IDE2KSB8IHkgKTsKCQlPVVRfUklORyggKHcgPDwgMTYpIHwgaCApOwoKCQlBRFZBTkNFX1JJTkcoKTsKCX0KCgkvKiBJbmNyZW1lbnQgdGhlIGZyYW1lIGNvdW50ZXIuICBUaGUgY2xpZW50LXNpZGUgM0QgZHJpdmVyIG11c3QKCSAqIHRocm90dGxlIHRoZSBmcmFtZXJhdGUgYnkgd2FpdGluZyBmb3IgdGhpcyB2YWx1ZSBiZWZvcmUKCSAqIHBlcmZvcm1pbmcgdGhlIHN3YXBidWZmZXIgaW9jdGwuCgkgKi8KCWRldl9wcml2LT5zYXJlYV9wcml2LT5sYXN0X2ZyYW1lKys7CgoJQkVHSU5fUklORyggNCApOwoKCVJBREVPTl9GUkFNRV9BR0UoIGRldl9wcml2LT5zYXJlYV9wcml2LT5sYXN0X2ZyYW1lICk7CglSQURFT05fV0FJVF9VTlRJTF8yRF9JRExFKCk7CgoJQURWQU5DRV9SSU5HKCk7Cn0KCnN0YXRpYyB2b2lkIHJhZGVvbl9jcF9kaXNwYXRjaF9mbGlwKCBkcm1fZGV2aWNlX3QgKmRldiApCnsKCWRybV9yYWRlb25fcHJpdmF0ZV90ICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7Cglkcm1fc2FyZWFfdCAqc2FyZWEgPSAoZHJtX3NhcmVhX3QgKilkZXZfcHJpdi0+c2FyZWEtPmhhbmRsZTsKCWludCBvZmZzZXQgPSAoZGV2X3ByaXYtPmN1cnJlbnRfcGFnZSA9PSAxKQoJCSAgID8gZGV2X3ByaXYtPmZyb250X29mZnNldCA6IGRldl9wcml2LT5iYWNrX29mZnNldDsKCVJJTkdfTE9DQUxTOwoJRFJNX0RFQlVHKCAiJXM6IHBhZ2U9JWQgcGZDdXJyZW50UGFnZT0lZFxuIiwgCgkJX19GVU5DVElPTl9fLCAKCQlkZXZfcHJpdi0+Y3VycmVudF9wYWdlLAoJCWRldl9wcml2LT5zYXJlYV9wcml2LT5wZkN1cnJlbnRQYWdlKTsKCgkvKiBEbyBzb21lIHRyaXZpYWwgcGVyZm9ybWFuY2UgbW9uaXRvcmluZy4uLgoJICovCglpZiAoZGV2X3ByaXYtPmRvX2JveGVzKSB7CgkJZGV2X3ByaXYtPnN0YXRzLmJveGVzIHw9IFJBREVPTl9CT1hfRkxJUDsKCQlyYWRlb25fY3BfcGVyZm9ybWFuY2VfYm94ZXMoIGRldl9wcml2ICk7Cgl9CgoJLyogVXBkYXRlIHRoZSBmcmFtZSBvZmZzZXRzIGZvciBib3RoIENSVENzCgkgKi8KCUJFR0lOX1JJTkcoIDYgKTsKCglSQURFT05fV0FJVF9VTlRJTF8zRF9JRExFKCk7CglPVVRfUklOR19SRUcoIFJBREVPTl9DUlRDX09GRlNFVCwgKCAoIHNhcmVhLT5mcmFtZS55ICogZGV2X3ByaXYtPmZyb250X3BpdGNoCgkJCQkJICAgICAgKyBzYXJlYS0+ZnJhbWUueCAKCQkJCQkgICAgICAqICggZGV2X3ByaXYtPmNvbG9yX2ZtdCAtIDIgKSApICYgfjcgKQoJCQkJCSAgKyBvZmZzZXQgKTsKCU9VVF9SSU5HX1JFRyggUkFERU9OX0NSVEMyX09GRlNFVCwgZGV2X3ByaXYtPnNhcmVhX3ByaXYtPmNydGMyX2Jhc2UKCQkJCQkgICArIG9mZnNldCApOwoKCUFEVkFOQ0VfUklORygpOwoKCS8qIEluY3JlbWVudCB0aGUgZnJhbWUgY291bnRlci4gIFRoZSBjbGllbnQtc2lkZSAzRCBkcml2ZXIgbXVzdAoJICogdGhyb3R0bGUgdGhlIGZyYW1lcmF0ZSBieSB3YWl0aW5nIGZvciB0aGlzIHZhbHVlIGJlZm9yZQoJICogcGVyZm9ybWluZyB0aGUgc3dhcGJ1ZmZlciBpb2N0bC4KCSAqLwoJZGV2X3ByaXYtPnNhcmVhX3ByaXYtPmxhc3RfZnJhbWUrKzsKCWRldl9wcml2LT5zYXJlYV9wcml2LT5wZkN1cnJlbnRQYWdlID0gZGV2X3ByaXYtPmN1cnJlbnRfcGFnZSA9CgkJCQkJICAgICAgMSAtIGRldl9wcml2LT5jdXJyZW50X3BhZ2U7CgoJQkVHSU5fUklORyggMiApOwoKCVJBREVPTl9GUkFNRV9BR0UoIGRldl9wcml2LT5zYXJlYV9wcml2LT5sYXN0X2ZyYW1lICk7CgoJQURWQU5DRV9SSU5HKCk7Cn0KCnN0YXRpYyBpbnQgYmFkX3ByaW1fdmVydGV4X25yKCBpbnQgcHJpbWl0aXZlLCBpbnQgbnIgKQp7Cglzd2l0Y2ggKHByaW1pdGl2ZSAmIFJBREVPTl9QUklNX1RZUEVfTUFTSykgewoJY2FzZSBSQURFT05fUFJJTV9UWVBFX05PTkU6CgljYXNlIFJBREVPTl9QUklNX1RZUEVfUE9JTlQ6CgkJcmV0dXJuIG5yIDwgMTsKCWNhc2UgUkFERU9OX1BSSU1fVFlQRV9MSU5FOgoJCXJldHVybiAobnIgJiAxKSB8fCBuciA9PSAwOwoJY2FzZSBSQURFT05fUFJJTV9UWVBFX0xJTkVfU1RSSVA6CgkJcmV0dXJuIG5yIDwgMjsKCWNhc2UgUkFERU9OX1BSSU1fVFlQRV9UUklfTElTVDoKCWNhc2UgUkFERU9OX1BSSU1fVFlQRV8zVlJUX1BPSU5UX0xJU1Q6CgljYXNlIFJBREVPTl9QUklNX1RZUEVfM1ZSVF9MSU5FX0xJU1Q6CgljYXNlIFJBREVPTl9QUklNX1RZUEVfUkVDVF9MSVNUOgoJCXJldHVybiBuciAlIDMgfHwgbnIgPT0gMDsKCWNhc2UgUkFERU9OX1BSSU1fVFlQRV9UUklfRkFOOgoJY2FzZSBSQURFT05fUFJJTV9UWVBFX1RSSV9TVFJJUDoKCQlyZXR1cm4gbnIgPCAzOwoJZGVmYXVsdDoKCQlyZXR1cm4gMTsKCX0JCn0KCgoKdHlwZWRlZiBzdHJ1Y3QgewoJdW5zaWduZWQgaW50IHN0YXJ0OwoJdW5zaWduZWQgaW50IGZpbmlzaDsKCXVuc2lnbmVkIGludCBwcmltOwoJdW5zaWduZWQgaW50IG51bXZlcnRzOwoJdW5zaWduZWQgaW50IG9mZnNldDsgICAKICAgICAgICB1bnNpZ25lZCBpbnQgdmNfZm9ybWF0Owp9IGRybV9yYWRlb25fdGNsX3ByaW1fdDsKCnN0YXRpYyB2b2lkIHJhZGVvbl9jcF9kaXNwYXRjaF92ZXJ0ZXgoIGRybV9kZXZpY2VfdCAqZGV2LAoJCQkJICAgICAgIGRybV9idWZfdCAqYnVmLAoJCQkJICAgICAgIGRybV9yYWRlb25fdGNsX3ByaW1fdCAqcHJpbSApCgp7Cglkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoJZHJtX3JhZGVvbl9zYXJlYV90ICpzYXJlYV9wcml2ID0gZGV2X3ByaXYtPnNhcmVhX3ByaXY7CglpbnQgb2Zmc2V0ID0gZGV2X3ByaXYtPmdhcnRfYnVmZmVyc19vZmZzZXQgKyBidWYtPm9mZnNldCArIHByaW0tPnN0YXJ0OwoJaW50IG51bXZlcnRzID0gKGludClwcmltLT5udW12ZXJ0czsKCWludCBuYm94ID0gc2FyZWFfcHJpdi0+bmJveDsKCWludCBpID0gMDsKCVJJTkdfTE9DQUxTOwoKCURSTV9ERUJVRygiaHdwcmltIDB4JXggdmZtdCAweCV4ICVkLi4lZCAlZCB2ZXJ0c1xuIiwKCQkgIHByaW0tPnByaW0sCgkJICBwcmltLT52Y19mb3JtYXQsCgkJICBwcmltLT5zdGFydCwKCQkgIHByaW0tPmZpbmlzaCwKCQkgIHByaW0tPm51bXZlcnRzKTsKCglpZiAoYmFkX3ByaW1fdmVydGV4X25yKCBwcmltLT5wcmltLCBwcmltLT5udW12ZXJ0cyApKSB7CgkJRFJNX0VSUk9SKCAiYmFkIHByaW0gJXggbnVtdmVydHMgJWRcbiIsIAoJCQkgICBwcmltLT5wcmltLCBwcmltLT5udW12ZXJ0cyApOwoJCXJldHVybjsKCX0KCglkbyB7CgkJLyogRW1pdCB0aGUgbmV4dCBjbGlwcmVjdCAqLwoJCWlmICggaSA8IG5ib3ggKSB7CgkJCXJhZGVvbl9lbWl0X2NsaXBfcmVjdCggZGV2X3ByaXYsIAoJCQkJCSAgICAgICAmc2FyZWFfcHJpdi0+Ym94ZXNbaV0gKTsKCQl9CgoJCS8qIEVtaXQgdGhlIHZlcnRleCBidWZmZXIgcmVuZGVyaW5nIGNvbW1hbmRzICovCgkJQkVHSU5fUklORyggNSApOwoKCQlPVVRfUklORyggQ1BfUEFDS0VUMyggUkFERU9OXzNEX1JORFJfR0VOX0lORFhfUFJJTSwgMyApICk7CgkJT1VUX1JJTkcoIG9mZnNldCApOwoJCU9VVF9SSU5HKCBudW12ZXJ0cyApOwoJCU9VVF9SSU5HKCBwcmltLT52Y19mb3JtYXQgKTsKCQlPVVRfUklORyggcHJpbS0+cHJpbSB8IFJBREVPTl9QUklNX1dBTEtfTElTVCB8CgkJCSAgUkFERU9OX0NPTE9SX09SREVSX1JHQkEgfAoJCQkgIFJBREVPTl9WVFhfRk1UX1JBREVPTl9NT0RFIHwKCQkJICAobnVtdmVydHMgPDwgUkFERU9OX05VTV9WRVJUSUNFU19TSElGVCkgKTsKCgkJQURWQU5DRV9SSU5HKCk7CgoJCWkrKzsKCX0gd2hpbGUgKCBpIDwgbmJveCApOwp9CgoKCnN0YXRpYyB2b2lkIHJhZGVvbl9jcF9kaXNjYXJkX2J1ZmZlciggZHJtX2RldmljZV90ICpkZXYsIGRybV9idWZfdCAqYnVmICkKewoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCWRybV9yYWRlb25fYnVmX3ByaXZfdCAqYnVmX3ByaXYgPSBidWYtPmRldl9wcml2YXRlOwoJUklOR19MT0NBTFM7CgoJYnVmX3ByaXYtPmFnZSA9ICsrZGV2X3ByaXYtPnNhcmVhX3ByaXYtPmxhc3RfZGlzcGF0Y2g7CgoJLyogRW1pdCB0aGUgdmVydGV4IGJ1ZmZlciBhZ2UgKi8KCUJFR0lOX1JJTkcoIDIgKTsKCVJBREVPTl9ESVNQQVRDSF9BR0UoIGJ1Zl9wcml2LT5hZ2UgKTsKCUFEVkFOQ0VfUklORygpOwoKCWJ1Zi0+cGVuZGluZyA9IDE7CglidWYtPnVzZWQgPSAwOwp9CgpzdGF0aWMgdm9pZCByYWRlb25fY3BfZGlzcGF0Y2hfaW5kaXJlY3QoIGRybV9kZXZpY2VfdCAqZGV2LAoJCQkJCSBkcm1fYnVmX3QgKmJ1ZiwKCQkJCQkgaW50IHN0YXJ0LCBpbnQgZW5kICkKewoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCVJJTkdfTE9DQUxTOwoJRFJNX0RFQlVHKCAiaW5kaXJlY3Q6IGJ1Zj0lZCBzPTB4JXggZT0weCV4XG4iLAoJCSAgIGJ1Zi0+aWR4LCBzdGFydCwgZW5kICk7CgoJaWYgKCBzdGFydCAhPSBlbmQgKSB7CgkJaW50IG9mZnNldCA9IChkZXZfcHJpdi0+Z2FydF9idWZmZXJzX29mZnNldAoJCQkgICAgICArIGJ1Zi0+b2Zmc2V0ICsgc3RhcnQpOwoJCWludCBkd29yZHMgPSAoZW5kIC0gc3RhcnQgKyAzKSAvIHNpemVvZih1MzIpOwoKCQkvKiBJbmRpcmVjdCBidWZmZXIgZGF0YSBtdXN0IGJlIGFuIGV2ZW4gbnVtYmVyIG9mCgkJICogZHdvcmRzLCBzbyBpZiB3ZSd2ZSBiZWVuIGdpdmVuIGFuIG9kZCBudW1iZXIgd2UgbXVzdAoJCSAqIHBhZCB0aGUgZGF0YSB3aXRoIGEgVHlwZS0yIENQIHBhY2tldC4KCQkgKi8KCQlpZiAoIGR3b3JkcyAmIDEgKSB7CgkJCXUzMiAqZGF0YSA9ICh1MzIgKikKCQkJCSgoY2hhciAqKWRldi0+YWdwX2J1ZmZlcl9tYXAtPmhhbmRsZQoJCQkJICsgYnVmLT5vZmZzZXQgKyBzdGFydCk7CgkJCWRhdGFbZHdvcmRzKytdID0gUkFERU9OX0NQX1BBQ0tFVDI7CgkJfQoKCQkvKiBGaXJlIG9mZiB0aGUgaW5kaXJlY3QgYnVmZmVyICovCgkJQkVHSU5fUklORyggMyApOwoKCQlPVVRfUklORyggQ1BfUEFDS0VUMCggUkFERU9OX0NQX0lCX0JBU0UsIDEgKSApOwoJCU9VVF9SSU5HKCBvZmZzZXQgKTsKCQlPVVRfUklORyggZHdvcmRzICk7CgoJCUFEVkFOQ0VfUklORygpOwoJfQp9CgoKc3RhdGljIHZvaWQgcmFkZW9uX2NwX2Rpc3BhdGNoX2luZGljZXMoIGRybV9kZXZpY2VfdCAqZGV2LAoJCQkJCWRybV9idWZfdCAqZWx0X2J1ZiwKCQkJCQlkcm1fcmFkZW9uX3RjbF9wcmltX3QgKnByaW0gKQp7Cglkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoJZHJtX3JhZGVvbl9zYXJlYV90ICpzYXJlYV9wcml2ID0gZGV2X3ByaXYtPnNhcmVhX3ByaXY7CglpbnQgb2Zmc2V0ID0gZGV2X3ByaXYtPmdhcnRfYnVmZmVyc19vZmZzZXQgKyBwcmltLT5vZmZzZXQ7Cgl1MzIgKmRhdGE7CglpbnQgZHdvcmRzOwoJaW50IGkgPSAwOwoJaW50IHN0YXJ0ID0gcHJpbS0+c3RhcnQgKyBSQURFT05fSU5ERVhfUFJJTV9PRkZTRVQ7CglpbnQgY291bnQgPSAocHJpbS0+ZmluaXNoIC0gc3RhcnQpIC8gc2l6ZW9mKHUxNik7CglpbnQgbmJveCA9IHNhcmVhX3ByaXYtPm5ib3g7CgoJRFJNX0RFQlVHKCJod3ByaW0gMHgleCB2Zm10IDB4JXggJWQuLiVkIG9mZnNldDogJXggbnIgJWRcbiIsCgkJICBwcmltLT5wcmltLAoJCSAgcHJpbS0+dmNfZm9ybWF0LAoJCSAgcHJpbS0+c3RhcnQsCgkJICBwcmltLT5maW5pc2gsCgkJICBwcmltLT5vZmZzZXQsCgkJICBwcmltLT5udW12ZXJ0cyk7CgoJaWYgKGJhZF9wcmltX3ZlcnRleF9uciggcHJpbS0+cHJpbSwgY291bnQgKSkgewoJCURSTV9FUlJPUiggImJhZCBwcmltICV4IGNvdW50ICVkXG4iLCAKCQkJICAgcHJpbS0+cHJpbSwgY291bnQgKTsKCQlyZXR1cm47Cgl9CgoKCWlmICggc3RhcnQgPj0gcHJpbS0+ZmluaXNoIHx8CgkgICAgIChwcmltLT5zdGFydCAmIDB4NykgKSB7CgkJRFJNX0VSUk9SKCAiYnVmZmVyIHByaW0gJWRcbiIsIHByaW0tPnByaW0gKTsKCQlyZXR1cm47Cgl9CgoJZHdvcmRzID0gKHByaW0tPmZpbmlzaCAtIHByaW0tPnN0YXJ0ICsgMykgLyBzaXplb2YodTMyKTsKCglkYXRhID0gKHUzMiAqKSgoY2hhciAqKWRldi0+YWdwX2J1ZmZlcl9tYXAtPmhhbmRsZSArCgkJICAgICAgIGVsdF9idWYtPm9mZnNldCArIHByaW0tPnN0YXJ0KTsKCglkYXRhWzBdID0gQ1BfUEFDS0VUMyggUkFERU9OXzNEX1JORFJfR0VOX0lORFhfUFJJTSwgZHdvcmRzLTIgKTsKCWRhdGFbMV0gPSBvZmZzZXQ7CglkYXRhWzJdID0gcHJpbS0+bnVtdmVydHM7CglkYXRhWzNdID0gcHJpbS0+dmNfZm9ybWF0OwoJZGF0YVs0XSA9IChwcmltLT5wcmltIHwKCQkgICBSQURFT05fUFJJTV9XQUxLX0lORCB8CgkJICAgUkFERU9OX0NPTE9SX09SREVSX1JHQkEgfAoJCSAgIFJBREVPTl9WVFhfRk1UX1JBREVPTl9NT0RFIHwKCQkgICAoY291bnQgPDwgUkFERU9OX05VTV9WRVJUSUNFU19TSElGVCkgKTsKCglkbyB7CgkJaWYgKCBpIDwgbmJveCApIAoJCQlyYWRlb25fZW1pdF9jbGlwX3JlY3QoIGRldl9wcml2LCAKCQkJCQkgICAgICAgJnNhcmVhX3ByaXYtPmJveGVzW2ldICk7CgoJCXJhZGVvbl9jcF9kaXNwYXRjaF9pbmRpcmVjdCggZGV2LCBlbHRfYnVmLAoJCQkJCSAgICAgcHJpbS0+c3RhcnQsCgkJCQkJICAgICBwcmltLT5maW5pc2ggKTsKCgkJaSsrOwoJfSB3aGlsZSAoIGkgPCBuYm94ICk7Cgp9CgojZGVmaW5lIFJBREVPTl9NQVhfVEVYVFVSRV9TSVpFIFJBREVPTl9CVUZGRVJfU0laRQoKc3RhdGljIGludCByYWRlb25fY3BfZGlzcGF0Y2hfdGV4dHVyZSggRFJNRklMRSBmaWxwLAoJCQkJICAgICAgIGRybV9kZXZpY2VfdCAqZGV2LAoJCQkJICAgICAgIGRybV9yYWRlb25fdGV4dHVyZV90ICp0ZXgsCgkJCQkgICAgICAgZHJtX3JhZGVvbl90ZXhfaW1hZ2VfdCAqaW1hZ2UgKQp7Cglkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoJZHJtX2ZpbGVfdCAqZmlscF9wcml2OwoJZHJtX2J1Zl90ICpidWY7Cgl1MzIgZm9ybWF0OwoJdTMyICpidWZmZXI7Cgljb25zdCB1OCBfX3VzZXIgKmRhdGE7CglpbnQgc2l6ZSwgZHdvcmRzLCB0ZXhfd2lkdGgsIGJsaXRfd2lkdGgsIHNwaXRjaDsKCXUzMiBoZWlnaHQ7CglpbnQgaTsKCXUzMiB0ZXhwaXRjaCwgbWljcm90aWxlOwoJdTMyIG9mZnNldDsKCVJJTkdfTE9DQUxTOwoKCURSTV9HRVRfUFJJVl9XSVRIX1JFVFVSTiggZmlscF9wcml2LCBmaWxwICk7CgoJaWYgKCByYWRlb25fY2hlY2tfYW5kX2ZpeHVwX29mZnNldCggZGV2X3ByaXYsIGZpbHBfcHJpdiwgJnRleC0+b2Zmc2V0ICkgKSB7CgkJRFJNX0VSUk9SKCAiSW52YWxpZCBkZXN0aW5hdGlvbiBvZmZzZXRcbiIgKTsKCQlyZXR1cm4gRFJNX0VSUiggRUlOVkFMICk7Cgl9CgoJZGV2X3ByaXYtPnN0YXRzLmJveGVzIHw9IFJBREVPTl9CT1hfVEVYVFVSRV9MT0FEOwoKCS8qIEZsdXNoIHRoZSBwaXhlbCBjYWNoZS4gIFRoaXMgZW5zdXJlcyBubyBwaXhlbCBkYXRhIGdldHMgbWl4ZWQKCSAqIHVwIHdpdGggdGhlIHRleHR1cmUgZGF0YSBmcm9tIHRoZSBob3N0IGRhdGEgYmxpdCwgb3RoZXJ3aXNlCgkgKiBwYXJ0IG9mIHRoZSB0ZXh0dXJlIGltYWdlIG1heSBiZSBjb3JydXB0ZWQuCgkgKi8KCUJFR0lOX1JJTkcoIDQgKTsKCVJBREVPTl9GTFVTSF9DQUNIRSgpOwoJUkFERU9OX1dBSVRfVU5USUxfSURMRSgpOwoJQURWQU5DRV9SSU5HKCk7CgoJLyogVGhlIGNvbXBpbGVyIHdvbid0IG9wdGltaXplIGF3YXkgYSBkaXZpc2lvbiBieSBhIHZhcmlhYmxlLAoJICogZXZlbiBpZiB0aGUgb25seSBsZWdhbCB2YWx1ZXMgYXJlIHBvd2VycyBvZiB0d28uICBUaHVzLCB3ZSdsbAoJICogdXNlIGEgc2hpZnQgaW5zdGVhZC4KCSAqLwoJc3dpdGNoICggdGV4LT5mb3JtYXQgKSB7CgljYXNlIFJBREVPTl9UWEZPUk1BVF9BUkdCODg4ODoKCWNhc2UgUkFERU9OX1RYRk9STUFUX1JHQkE4ODg4OgoJCWZvcm1hdCA9IFJBREVPTl9DT0xPUl9GT1JNQVRfQVJHQjg4ODg7CgkJdGV4X3dpZHRoID0gdGV4LT53aWR0aCAqIDQ7CgkJYmxpdF93aWR0aCA9IGltYWdlLT53aWR0aCAqIDQ7CgkJYnJlYWs7CgljYXNlIFJBREVPTl9UWEZPUk1BVF9BSTg4OgoJY2FzZSBSQURFT05fVFhGT1JNQVRfQVJHQjE1NTU6CgljYXNlIFJBREVPTl9UWEZPUk1BVF9SR0I1NjU6CgljYXNlIFJBREVPTl9UWEZPUk1BVF9BUkdCNDQ0NDoKCWNhc2UgUkFERU9OX1RYRk9STUFUX1ZZVVk0MjI6CgljYXNlIFJBREVPTl9UWEZPUk1BVF9ZVllVNDIyOgoJCWZvcm1hdCA9IFJBREVPTl9DT0xPUl9GT1JNQVRfUkdCNTY1OwoJCXRleF93aWR0aCA9IHRleC0+d2lkdGggKiAyOwoJCWJsaXRfd2lkdGggPSBpbWFnZS0+d2lkdGggKiAyOwoJCWJyZWFrOwoJY2FzZSBSQURFT05fVFhGT1JNQVRfSTg6CgljYXNlIFJBREVPTl9UWEZPUk1BVF9SR0IzMzI6CgkJZm9ybWF0ID0gUkFERU9OX0NPTE9SX0ZPUk1BVF9DSTg7CgkJdGV4X3dpZHRoID0gdGV4LT53aWR0aCAqIDE7CgkJYmxpdF93aWR0aCA9IGltYWdlLT53aWR0aCAqIDE7CgkJYnJlYWs7CglkZWZhdWx0OgoJCURSTV9FUlJPUiggImludmFsaWQgdGV4dHVyZSBmb3JtYXQgJWRcbiIsIHRleC0+Zm9ybWF0ICk7CgkJcmV0dXJuIERSTV9FUlIoRUlOVkFMKTsKCX0KCXNwaXRjaCA9IGJsaXRfd2lkdGggPj4gNjsKCWlmIChzcGl0Y2ggPT0gMCAmJiBpbWFnZS0+aGVpZ2h0ID4gMSkKCQlyZXR1cm4gRFJNX0VSUihFSU5WQUwpOwoKCXRleHBpdGNoID0gdGV4LT5waXRjaDsKCWlmICgodGV4cGl0Y2ggPDwgMjIpICYgUkFERU9OX0RTVF9USUxFX01JQ1JPKSB7CgkJbWljcm90aWxlID0gMTsKCQlpZiAodGV4X3dpZHRoIDwgNjQpIHsKCQkJdGV4cGl0Y2ggJj0gfihSQURFT05fRFNUX1RJTEVfTUlDUk8gPj4gMjIpOwoJCQkvKiB3ZSBnb3QgdGlsZWQgY29vcmRpbmF0ZXMsIHVudGlsZSB0aGVtICovCgkJCWltYWdlLT54ICo9IDI7CgkJfQoJfQoJZWxzZSBtaWNyb3RpbGUgPSAwOwoKCURSTV9ERUJVRygidGV4PSVkeCVkIGJsaXQ9JWRcbiIsIHRleF93aWR0aCwgdGV4LT5oZWlnaHQsIGJsaXRfd2lkdGggKTsKCglkbyB7CgkJRFJNX0RFQlVHKCAidGV4OiBvZnM9MHgleCBwPSVkIGY9JWQgeD0laGQgeT0laGQgdz0laGQgaD0laGRcbiIsCgkJCSAgIHRleC0+b2Zmc2V0ID4+IDEwLCB0ZXgtPnBpdGNoLCB0ZXgtPmZvcm1hdCwKCQkJICAgaW1hZ2UtPngsIGltYWdlLT55LCBpbWFnZS0+d2lkdGgsIGltYWdlLT5oZWlnaHQgKTsKCgkJLyogTWFrZSBhIGNvcHkgb2Ygc29tZSBwYXJhbWV0ZXJzIGluIGNhc2Ugd2UgaGF2ZSB0bwoJCSAqIHVwZGF0ZSB0aGVtIGZvciBhIG11bHRpLXBhc3MgdGV4dHVyZSBibGl0LgoJCSAqLwoJCWhlaWdodCA9IGltYWdlLT5oZWlnaHQ7CgkJZGF0YSA9IChjb25zdCB1OCBfX3VzZXIgKilpbWFnZS0+ZGF0YTsKCQkKCQlzaXplID0gaGVpZ2h0ICogYmxpdF93aWR0aDsKCgkJaWYgKCBzaXplID4gUkFERU9OX01BWF9URVhUVVJFX1NJWkUgKSB7CgkJCWhlaWdodCA9IFJBREVPTl9NQVhfVEVYVFVSRV9TSVpFIC8gYmxpdF93aWR0aDsKCQkJc2l6ZSA9IGhlaWdodCAqIGJsaXRfd2lkdGg7CgkJfSBlbHNlIGlmICggc2l6ZSA8IDQgJiYgc2l6ZSA+IDAgKSB7CgkJCXNpemUgPSA0OwoJCX0gZWxzZSBpZiAoIHNpemUgPT0gMCApIHsKCQkJcmV0dXJuIDA7CgkJfQoKCQlidWYgPSByYWRlb25fZnJlZWxpc3RfZ2V0KCBkZXYgKTsKCQlpZiAoIDAgJiYgIWJ1ZiApIHsKCQkJcmFkZW9uX2RvX2NwX2lkbGUoIGRldl9wcml2ICk7CgkJCWJ1ZiA9IHJhZGVvbl9mcmVlbGlzdF9nZXQoIGRldiApOwoJCX0KCQlpZiAoICFidWYgKSB7CgkJCURSTV9ERUJVRygicmFkZW9uX2NwX2Rpc3BhdGNoX3RleHR1cmU6IEVBR0FJTlxuIik7CgkJCWlmIChEUk1fQ09QWV9UT19VU0VSKCB0ZXgtPmltYWdlLCBpbWFnZSwgc2l6ZW9mKCppbWFnZSkgKSkKCQkJCXJldHVybiBEUk1fRVJSKEVGQVVMVCk7CgkJCXJldHVybiBEUk1fRVJSKEVBR0FJTik7CgkJfQoKCgkJLyogRGlzcGF0Y2ggdGhlIGluZGlyZWN0IGJ1ZmZlci4KCQkgKi8KCQlidWZmZXIgPSAodTMyKikoKGNoYXIqKWRldi0+YWdwX2J1ZmZlcl9tYXAtPmhhbmRsZSArIGJ1Zi0+b2Zmc2V0KTsKCQlkd29yZHMgPSBzaXplIC8gNDsKCgkJaWYgKG1pY3JvdGlsZSkgewoJCQkvKiB0ZXh0dXJlIG1pY3JvIHRpbGluZyBpbiB1c2UsIG1pbmltdW0gdGV4dHVyZSB3aWR0aCBpcyB0aHVzIDE2IGJ5dGVzLgoJCQkgICBob3dldmVyLCB3ZSBjYW5ub3QgdXNlIGJsaXR0ZXIgZGlyZWN0bHkgZm9yIHRleHR1cmUgd2lkdGggPCA2NCBieXRlcywKCQkJICAgc2luY2UgbWluaW11bSB0ZXggcGl0Y2ggaXMgNjQgYnl0ZXMgYW5kIHdlIG5lZWQgdGhpcyB0byBtYXRjaAoJCQkgICB0aGUgdGV4dHVyZSB3aWR0aCwgb3RoZXJ3aXNlIHRoZSBibGl0dGVyIHdpbGwgdGlsZSBpdCB3cm9uZy4KCQkJICAgVGh1cywgdGlsaW5nIG1hbnVhbGx5IGluIHRoaXMgY2FzZS4gQWRkaXRpb25hbGx5LCBuZWVkIHRvIHNwZWNpYWwKCQkJICAgY2FzZSB0ZXggaGVpZ2h0ID0gMSwgc2luY2Ugb3VyIGFjdHVhbCBpbWFnZSB3aWxsIGhhdmUgaGVpZ2h0IDIKCQkJICAgYW5kIHdlIG5lZWQgdG8gZW5zdXJlIHdlIGRvbid0IHJlYWQgYmV5b25kIHRoZSB0ZXh0dXJlIHNpemUKCQkJICAgZnJvbSB1c2VyIHNwYWNlLiAqLwoJCQlpZiAodGV4LT5oZWlnaHQgPT0gMSkgewoJCQkJaWYgKHRleF93aWR0aCA+PSA2NCB8fCB0ZXhfd2lkdGggPD0gMTYpIHsKCQkJCQlpZiAoRFJNX0NPUFlfRlJPTV9VU0VSKGJ1ZmZlciwgZGF0YSwKCQkJCQkJCSAgICAgICB0ZXhfd2lkdGggKiBzaXplb2YodTMyKSkpIHsKCQkJCQkJRFJNX0VSUk9SKCJFRkFVTFQgb24gcGFkLCAlZCBieXRlc1xuIiwKCQkJCQkJCSAgdGV4X3dpZHRoKTsKCQkJCQkJcmV0dXJuIERSTV9FUlIoRUZBVUxUKTsKCQkJCQl9CgkJCQl9IGVsc2UgaWYgKHRleF93aWR0aCA9PSAzMikgewoJCQkJCWlmIChEUk1fQ09QWV9GUk9NX1VTRVIoYnVmZmVyLCBkYXRhLCAxNikpIHsKCQkJCQkJRFJNX0VSUk9SKCJFRkFVTFQgb24gcGFkLCAlZCBieXRlc1xuIiwKCQkJCQkJCSAgdGV4X3dpZHRoKTsKCQkJCQkJcmV0dXJuIERSTV9FUlIoRUZBVUxUKTsKCQkJCQl9CgkJCQkJaWYgKERSTV9DT1BZX0ZST01fVVNFUihidWZmZXIgKyA4LCBkYXRhICsgMTYsIDE2KSkgewoJCQkJCQlEUk1fRVJST1IoIkVGQVVMVCBvbiBwYWQsICVkIGJ5dGVzXG4iLAoJCQkJCQkJICB0ZXhfd2lkdGgpOwoJCQkJCQlyZXR1cm4gRFJNX0VSUihFRkFVTFQpOwoJCQkJCX0KCQkJCX0KCQkJfSBlbHNlIGlmICh0ZXhfd2lkdGggPj0gNjQgfHwgdGV4X3dpZHRoID09IDE2KSB7CgkJCQlpZiAoRFJNX0NPUFlfRlJPTV9VU0VSKGJ1ZmZlciwgZGF0YSwKCQkJCQkJICAgICAgIGR3b3JkcyAqIHNpemVvZih1MzIpKSkgewoJCQkJCURSTV9FUlJPUigiRUZBVUxUIG9uIGRhdGEsICVkIGR3b3Jkc1xuIiwKCQkJCQkJICBkd29yZHMpOwoJCQkJCXJldHVybiBEUk1fRVJSKEVGQVVMVCk7CgkJCQl9CgkJCX0gZWxzZSBpZiAodGV4X3dpZHRoIDwgMTYpIHsKCQkJCWZvciAoaSA9IDA7IGkgPCB0ZXgtPmhlaWdodDsgaSsrKSB7CgkJCQkJaWYgKERSTV9DT1BZX0ZST01fVVNFUihidWZmZXIsIGRhdGEsIHRleF93aWR0aCkpIHsKCQkJCQkJRFJNX0VSUk9SKCJFRkFVTFQgb24gcGFkLCAlZCBieXRlc1xuIiwKCQkJCQkJCSAgdGV4X3dpZHRoKTsKCQkJCQkJcmV0dXJuIERSTV9FUlIoRUZBVUxUKTsKCQkJCQl9CgkJCQkJYnVmZmVyICs9IDQ7CgkJCQkJZGF0YSArPSB0ZXhfd2lkdGg7CgkJCQl9CgkJCX0gZWxzZSBpZiAodGV4X3dpZHRoID09IDMyKSB7CgkJCQkvKiBUT0RPOiBtYWtlIHN1cmUgdGhpcyB3b3JrcyB3aGVuIG5vdCBmaXR0aW5nIGluIG9uZSBidWZmZXIKCQkJCSAgIChpLmUuIDMyYnl0ZXMgeCAyMDQ4Li4uKSAqLwoJCQkJZm9yIChpID0gMDsgaSA8IHRleC0+aGVpZ2h0OyBpICs9IDIpIHsKCQkJCQlpZiAoRFJNX0NPUFlfRlJPTV9VU0VSKGJ1ZmZlciwgZGF0YSwgMTYpKSB7CgkJCQkJCURSTV9FUlJPUigiRUZBVUxUIG9uIHBhZCwgJWQgYnl0ZXNcbiIsCgkJCQkJCQkgIHRleF93aWR0aCk7CgkJCQkJCXJldHVybiBEUk1fRVJSKEVGQVVMVCk7CgkJCQkJfQoJCQkJCWRhdGEgKz0gMTY7CgkJCQkJaWYgKERSTV9DT1BZX0ZST01fVVNFUihidWZmZXIgKyA4LCBkYXRhLCAxNikpIHsKCQkJCQkJRFJNX0VSUk9SKCJFRkFVTFQgb24gcGFkLCAlZCBieXRlc1xuIiwKCQkJCQkJCSAgdGV4X3dpZHRoKTsKCQkJCQkJcmV0dXJuIERSTV9FUlIoRUZBVUxUKTsKCQkJCQl9CgkJCQkJZGF0YSArPSAxNjsKCQkJCQlpZiAoRFJNX0NPUFlfRlJPTV9VU0VSKGJ1ZmZlciArIDQsIGRhdGEsIDE2KSkgewoJCQkJCQlEUk1fRVJST1IoIkVGQVVMVCBvbiBwYWQsICVkIGJ5dGVzXG4iLAoJCQkJCQkJICB0ZXhfd2lkdGgpOwoJCQkJCQlyZXR1cm4gRFJNX0VSUihFRkFVTFQpOwoJCQkJCX0KCQkJCQlkYXRhICs9IDE2OwoJCQkJCWlmIChEUk1fQ09QWV9GUk9NX1VTRVIoYnVmZmVyICsgMTIsIGRhdGEsIDE2KSkgewoJCQkJCQlEUk1fRVJST1IoIkVGQVVMVCBvbiBwYWQsICVkIGJ5dGVzXG4iLAoJCQkJCQkJICB0ZXhfd2lkdGgpOwoJCQkJCQlyZXR1cm4gRFJNX0VSUihFRkFVTFQpOwoJCQkJCX0KCQkJCQlkYXRhICs9IDE2OwoJCQkJCWJ1ZmZlciArPSAxNjsKCQkJCX0KCQkJfQoJCX0KCQllbHNlIHsKCQkJaWYgKHRleF93aWR0aCA+PSAzMikgewoJCQkJLyogVGV4dHVyZSBpbWFnZSB3aWR0aCBpcyBsYXJnZXIgdGhhbiB0aGUgbWluaW11bSwgc28gd2UKCQkJCSAqIGNhbiB1cGxvYWQgaXQgZGlyZWN0bHkuCgkJCQkgKi8KCQkJCWlmIChEUk1fQ09QWV9GUk9NX1VTRVIoYnVmZmVyLCBkYXRhLAoJCQkJCQkgICAgICAgZHdvcmRzICogc2l6ZW9mKHUzMikpKSB7CgkJCQkJRFJNX0VSUk9SKCJFRkFVTFQgb24gZGF0YSwgJWQgZHdvcmRzXG4iLAoJCQkJCQkgIGR3b3Jkcyk7CgkJCQkJcmV0dXJuIERSTV9FUlIoRUZBVUxUKTsKCQkJCX0KCQkJfSBlbHNlIHsKCQkJCS8qIFRleHR1cmUgaW1hZ2Ugd2lkdGggaXMgbGVzcyB0aGFuIHRoZSBtaW5pbXVtLCBzbyB3ZQoJCQkJICogbmVlZCB0byBwYWQgb3V0IGVhY2ggaW1hZ2Ugc2NhbmxpbmUgdG8gdGhlIG1pbmltdW0KCQkJCSAqIHdpZHRoLgoJCQkJICovCgkJCQlmb3IgKGkgPSAwIDsgaSA8IHRleC0+aGVpZ2h0IDsgaSsrKSB7CgkJCQkJaWYgKERSTV9DT1BZX0ZST01fVVNFUihidWZmZXIsIGRhdGEsIHRleF93aWR0aCApKSB7CgkJCQkJCURSTV9FUlJPUigiRUZBVUxUIG9uIHBhZCwgJWQgYnl0ZXNcbiIsIHRleF93aWR0aCk7CgkJCQkJCXJldHVybiBEUk1fRVJSKEVGQVVMVCk7CgkJCQkJfQoJCQkJCWJ1ZmZlciArPSA4OwoJCQkJCWRhdGEgKz0gdGV4X3dpZHRoOwoJCQkJfQoJCQl9CgkJfQoKCQlidWYtPmZpbHAgPSBmaWxwOwoJCWJ1Zi0+dXNlZCA9IHNpemU7CgkJb2Zmc2V0ID0gZGV2X3ByaXYtPmdhcnRfYnVmZmVyc19vZmZzZXQgKyBidWYtPm9mZnNldDsKCQlCRUdJTl9SSU5HKDkpOwoJCU9VVF9SSU5HKENQX1BBQ0tFVDMoUkFERU9OX0NOVExfQklUQkxUX01VTFRJLCA1KSk7CgkJT1VUX1JJTkcoUkFERU9OX0dNQ19TUkNfUElUQ0hfT0ZGU0VUX0NOVEwgfAoJCQkgUkFERU9OX0dNQ19EU1RfUElUQ0hfT0ZGU0VUX0NOVEwgfAoJCQkgUkFERU9OX0dNQ19CUlVTSF9OT05FIHwKCQkJIChmb3JtYXQgPDwgOCkgfAoJCQkgUkFERU9OX0dNQ19TUkNfREFUQVRZUEVfQ09MT1IgfAoJCQkgUkFERU9OX1JPUDNfUyB8CgkJCSBSQURFT05fRFBfU1JDX1NPVVJDRV9NRU1PUlkgfAoJCQkgUkFERU9OX0dNQ19DTFJfQ01QX0NOVExfRElTIHwKCQkJIFJBREVPTl9HTUNfV1JfTVNLX0RJUyApOwoJCU9VVF9SSU5HKChzcGl0Y2ggPDwgMjIpIHwgKG9mZnNldCA+PiAxMCkpOwoJCU9VVF9SSU5HKCh0ZXhwaXRjaCA8PCAyMikgfCAodGV4LT5vZmZzZXQgPj4gMTApKTsKCQlPVVRfUklORygwKTsKCQlPVVRfUklORygoaW1hZ2UtPnggPDwgMTYpIHwgaW1hZ2UtPnkpOwoJCU9VVF9SSU5HKChpbWFnZS0+d2lkdGggPDwgMTYpIHwgaGVpZ2h0KTsKCQlSQURFT05fV0FJVF9VTlRJTF8yRF9JRExFKCk7CgkJQURWQU5DRV9SSU5HKCk7CgoJCXJhZGVvbl9jcF9kaXNjYXJkX2J1ZmZlcihkZXYsIGJ1Zik7CgoJCS8qIFVwZGF0ZSB0aGUgaW5wdXQgcGFyYW1ldGVycyBmb3IgbmV4dCB0aW1lICovCgkJaW1hZ2UtPnkgKz0gaGVpZ2h0OwoJCWltYWdlLT5oZWlnaHQgLT0gaGVpZ2h0OwoJCWltYWdlLT5kYXRhID0gKGNvbnN0IHU4IF9fdXNlciAqKWltYWdlLT5kYXRhICsgc2l6ZTsKCX0gd2hpbGUgKGltYWdlLT5oZWlnaHQgPiAwKTsKCgkvKiBGbHVzaCB0aGUgcGl4ZWwgY2FjaGUgYWZ0ZXIgdGhlIGJsaXQgY29tcGxldGVzLiAgVGhpcyBlbnN1cmVzCgkgKiB0aGUgdGV4dHVyZSBkYXRhIGlzIHdyaXR0ZW4gb3V0IHRvIG1lbW9yeSBiZWZvcmUgcmVuZGVyaW5nCgkgKiBjb250aW51ZXMuCgkgKi8KCUJFR0lOX1JJTkcoIDQgKTsKCVJBREVPTl9GTFVTSF9DQUNIRSgpOwoJUkFERU9OX1dBSVRfVU5USUxfMkRfSURMRSgpOwoJQURWQU5DRV9SSU5HKCk7CglyZXR1cm4gMDsKfQoKCnN0YXRpYyB2b2lkIHJhZGVvbl9jcF9kaXNwYXRjaF9zdGlwcGxlKCBkcm1fZGV2aWNlX3QgKmRldiwgdTMyICpzdGlwcGxlICkKewoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCWludCBpOwoJUklOR19MT0NBTFM7CglEUk1fREVCVUcoICJcbiIgKTsKCglCRUdJTl9SSU5HKCAzNSApOwoKCU9VVF9SSU5HKCBDUF9QQUNLRVQwKCBSQURFT05fUkVfU1RJUFBMRV9BRERSLCAwICkgKTsKCU9VVF9SSU5HKCAweDAwMDAwMDAwICk7CgoJT1VUX1JJTkcoIENQX1BBQ0tFVDBfVEFCTEUoIFJBREVPTl9SRV9TVElQUExFX0RBVEEsIDMxICkgKTsKCWZvciAoIGkgPSAwIDsgaSA8IDMyIDsgaSsrICkgewoJCU9VVF9SSU5HKCBzdGlwcGxlW2ldICk7Cgl9CgoJQURWQU5DRV9SSU5HKCk7Cn0KCnN0YXRpYyB2b2lkIHJhZGVvbl9hcHBseV9zdXJmYWNlX3JlZ3MoaW50IHN1cmZfaW5kZXgsIGRybV9yYWRlb25fcHJpdmF0ZV90ICpkZXZfcHJpdikKewoJaWYgKCFkZXZfcHJpdi0+bW1pbykKCQlyZXR1cm47CgoJcmFkZW9uX2RvX2NwX2lkbGUoZGV2X3ByaXYpOwoKCVJBREVPTl9XUklURShSQURFT05fU1VSRkFDRTBfSU5GTyArIDE2KnN1cmZfaW5kZXgsCgkJZGV2X3ByaXYtPnN1cmZhY2VzW3N1cmZfaW5kZXhdLmZsYWdzKTsKCVJBREVPTl9XUklURShSQURFT05fU1VSRkFDRTBfTE9XRVJfQk9VTkQgKyAxNipzdXJmX2luZGV4LAoJCWRldl9wcml2LT5zdXJmYWNlc1tzdXJmX2luZGV4XS5sb3dlcik7CglSQURFT05fV1JJVEUoUkFERU9OX1NVUkZBQ0UwX1VQUEVSX0JPVU5EICsgMTYqc3VyZl9pbmRleCwKCQlkZXZfcHJpdi0+c3VyZmFjZXNbc3VyZl9pbmRleF0udXBwZXIpOwp9CgoKLyogQWxsb2NhdGVzIGEgdmlydHVhbCBzdXJmYWNlCiAqIGRvZXNuJ3QgYWx3YXlzIGFsbG9jYXRlIGEgcmVhbCBzdXJmYWNlLCB3aWxsIHN0cmV0Y2ggYW4gZXhpc3RpbmcgCiAqIHN1cmZhY2Ugd2hlbiBwb3NzaWJsZS4KICoKICogTm90ZSB0aGF0IHJlZmNvdW50IGNhbiBiZSBhdCBtb3N0IDIsIHNpbmNlIGR1cmluZyBhIGZyZWUgcmVmY291bnQ9MwogKiBtaWdodCBtZWFuIHdlIGhhdmUgdG8gYWxsb2NhdGUgYSBuZXcgc3VyZmFjZSB3aGljaCBtaWdodCBub3QgYWx3YXlzCiAqIGJlIGF2YWlsYWJsZS4KICogRm9yIGV4YW1wbGUgOiB3ZSBhbGxvY2F0ZSB0aHJlZSBjb250aWdvdXMgc3VyZmFjZXMgQUJDLiBJZiBCIGlzIAogKiBmcmVlZCwgd2Ugc3VkZGVubHkgbmVlZCB0d28gc3VyZmFjZXMgdG8gc3RvcmUgQSBhbmQgQywgd2hpY2ggbWlnaHQKICogbm90IGFsd2F5cyBiZSBhdmFpbGFibGUuCiAqLwpzdGF0aWMgaW50IGFsbG9jX3N1cmZhY2UoZHJtX3JhZGVvbl9zdXJmYWNlX2FsbG9jX3QqIG5ldywgZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2LCBEUk1GSUxFIGZpbHApCnsKCXN0cnVjdCByYWRlb25fdmlydF9zdXJmYWNlICpzOwoJaW50IGk7CglpbnQgdmlydF9zdXJmYWNlX2luZGV4OwoJdWludDMyX3QgbmV3X3VwcGVyLCBuZXdfbG93ZXI7CgoJbmV3X2xvd2VyID0gbmV3LT5hZGRyZXNzOwoJbmV3X3VwcGVyID0gbmV3X2xvd2VyICsgbmV3LT5zaXplIC0gMTsKCgkvKiBzYW5pdHkgY2hlY2sgKi8KCWlmICgobmV3X2xvd2VyID49IG5ld191cHBlcikgfHwgKG5ldy0+ZmxhZ3MgPT0gMCkgfHwgKG5ldy0+c2l6ZSA9PSAwKSB8fAoJCSgobmV3X3VwcGVyICYgUkFERU9OX1NVUkZfQUREUkVTU19GSVhFRF9NQVNLKSAhPSBSQURFT05fU1VSRl9BRERSRVNTX0ZJWEVEX01BU0spIHx8CgkJKChuZXdfbG93ZXIgJiBSQURFT05fU1VSRl9BRERSRVNTX0ZJWEVEX01BU0spICE9IDApKQoJCXJldHVybiAtMTsKCgkvKiBtYWtlIHN1cmUgdGhlcmUgaXMgbm8gb3ZlcmxhcCB3aXRoIGV4aXN0aW5nIHN1cmZhY2VzICovCglmb3IgKGkgPSAwOyBpIDwgUkFERU9OX01BWF9TVVJGQUNFUzsgaSsrKSB7CgkJaWYgKChkZXZfcHJpdi0+c3VyZmFjZXNbaV0ucmVmY291bnQgIT0gMCkgJiYKCQkoKCAobmV3X2xvd2VyID49IGRldl9wcml2LT5zdXJmYWNlc1tpXS5sb3dlcikgJiYKCQkJKG5ld19sb3dlciA8IGRldl9wcml2LT5zdXJmYWNlc1tpXS51cHBlcikgKSB8fAoJCSAoIChuZXdfbG93ZXIgPCBkZXZfcHJpdi0+c3VyZmFjZXNbaV0ubG93ZXIpICYmCgkJCShuZXdfdXBwZXIgPiBkZXZfcHJpdi0+c3VyZmFjZXNbaV0ubG93ZXIpICkpICl7CgkJcmV0dXJuIC0xO30KCX0KCgkvKiBmaW5kIGEgdmlydHVhbCBzdXJmYWNlICovCglmb3IgKGkgPSAwOyBpIDwgMipSQURFT05fTUFYX1NVUkZBQ0VTOyBpKyspCgkJaWYgKGRldl9wcml2LT52aXJ0X3N1cmZhY2VzW2ldLmZpbHAgPT0gMCkKCQkJYnJlYWs7CglpZiAoaSA9PSAyKlJBREVPTl9NQVhfU1VSRkFDRVMpIHsKCQlyZXR1cm4gLTE7fQoJdmlydF9zdXJmYWNlX2luZGV4ID0gaTsKCgkvKiB0cnkgdG8gcmV1c2UgYW4gZXhpc3Rpbmcgc3VyZmFjZSAqLwoJZm9yIChpID0gMDsgaSA8IFJBREVPTl9NQVhfU1VSRkFDRVM7IGkrKykgewoJCS8qIGV4dGVuZCBiZWZvcmUgKi8KCQlpZiAoKGRldl9wcml2LT5zdXJmYWNlc1tpXS5yZWZjb3VudCA9PSAxKSAmJgoJCSAgKG5ldy0+ZmxhZ3MgPT0gZGV2X3ByaXYtPnN1cmZhY2VzW2ldLmZsYWdzKSAmJgoJCSAgKG5ld191cHBlciArIDEgPT0gZGV2X3ByaXYtPnN1cmZhY2VzW2ldLmxvd2VyKSkgewoJCQlzID0gJihkZXZfcHJpdi0+dmlydF9zdXJmYWNlc1t2aXJ0X3N1cmZhY2VfaW5kZXhdKTsKCQkJcy0+c3VyZmFjZV9pbmRleCA9IGk7CgkJCXMtPmxvd2VyID0gbmV3X2xvd2VyOwoJCQlzLT51cHBlciA9IG5ld191cHBlcjsKCQkJcy0+ZmxhZ3MgPSBuZXctPmZsYWdzOwoJCQlzLT5maWxwID0gZmlscDsKCQkJZGV2X3ByaXYtPnN1cmZhY2VzW2ldLnJlZmNvdW50Kys7CgkJCWRldl9wcml2LT5zdXJmYWNlc1tpXS5sb3dlciA9IHMtPmxvd2VyOwoJCQlyYWRlb25fYXBwbHlfc3VyZmFjZV9yZWdzKHMtPnN1cmZhY2VfaW5kZXgsIGRldl9wcml2KTsKCQkJcmV0dXJuIHZpcnRfc3VyZmFjZV9pbmRleDsKCQl9CgoJCS8qIGV4dGVuZCBhZnRlciAqLwoJCWlmICgoZGV2X3ByaXYtPnN1cmZhY2VzW2ldLnJlZmNvdW50ID09IDEpICYmCgkJICAobmV3LT5mbGFncyA9PSBkZXZfcHJpdi0+c3VyZmFjZXNbaV0uZmxhZ3MpICYmCgkJICAobmV3X2xvd2VyID09IGRldl9wcml2LT5zdXJmYWNlc1tpXS51cHBlciArIDEpKSB7CgkJCXMgPSAmKGRldl9wcml2LT52aXJ0X3N1cmZhY2VzW3ZpcnRfc3VyZmFjZV9pbmRleF0pOwoJCQlzLT5zdXJmYWNlX2luZGV4ID0gaTsKCQkJcy0+bG93ZXIgPSBuZXdfbG93ZXI7CgkJCXMtPnVwcGVyID0gbmV3X3VwcGVyOwoJCQlzLT5mbGFncyA9IG5ldy0+ZmxhZ3M7CgkJCXMtPmZpbHAgPSBmaWxwOwoJCQlkZXZfcHJpdi0+c3VyZmFjZXNbaV0ucmVmY291bnQrKzsKCQkJZGV2X3ByaXYtPnN1cmZhY2VzW2ldLnVwcGVyID0gcy0+dXBwZXI7CgkJCXJhZGVvbl9hcHBseV9zdXJmYWNlX3JlZ3Mocy0+c3VyZmFjZV9pbmRleCwgZGV2X3ByaXYpOwoJCQlyZXR1cm4gdmlydF9zdXJmYWNlX2luZGV4OwoJCX0KCX0KCgkvKiBva2F5LCB3ZSBuZWVkIGEgbmV3IG9uZSAqLwoJZm9yIChpID0gMDsgaSA8IFJBREVPTl9NQVhfU1VSRkFDRVM7IGkrKykgewoJCWlmIChkZXZfcHJpdi0+c3VyZmFjZXNbaV0ucmVmY291bnQgPT0gMCkgewoJCQlzID0gJihkZXZfcHJpdi0+dmlydF9zdXJmYWNlc1t2aXJ0X3N1cmZhY2VfaW5kZXhdKTsKCQkJcy0+c3VyZmFjZV9pbmRleCA9IGk7CgkJCXMtPmxvd2VyID0gbmV3X2xvd2VyOwoJCQlzLT51cHBlciA9IG5ld191cHBlcjsKCQkJcy0+ZmxhZ3MgPSBuZXctPmZsYWdzOwoJCQlzLT5maWxwID0gZmlscDsKCQkJZGV2X3ByaXYtPnN1cmZhY2VzW2ldLnJlZmNvdW50ID0gMTsKCQkJZGV2X3ByaXYtPnN1cmZhY2VzW2ldLmxvd2VyID0gcy0+bG93ZXI7CgkJCWRldl9wcml2LT5zdXJmYWNlc1tpXS51cHBlciA9IHMtPnVwcGVyOwoJCQlkZXZfcHJpdi0+c3VyZmFjZXNbaV0uZmxhZ3MgPSBzLT5mbGFnczsKCQkJcmFkZW9uX2FwcGx5X3N1cmZhY2VfcmVncyhzLT5zdXJmYWNlX2luZGV4LCBkZXZfcHJpdik7CgkJCXJldHVybiB2aXJ0X3N1cmZhY2VfaW5kZXg7CgkJfQoJfQoKCS8qIHdlIGRpZG4ndCBmaW5kIGFueXRoaW5nICovCglyZXR1cm4gLTE7Cn0KCnN0YXRpYyBpbnQgZnJlZV9zdXJmYWNlKERSTUZJTEUgZmlscCwgZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2LCBpbnQgbG93ZXIpCnsKCXN0cnVjdCByYWRlb25fdmlydF9zdXJmYWNlICpzOwoJaW50IGk7CgkvKiBmaW5kIHRoZSB2aXJ0dWFsIHN1cmZhY2UgKi8KCWZvcihpID0gMDsgaSA8IDIqUkFERU9OX01BWF9TVVJGQUNFUzsgaSsrKSB7CgkJcyA9ICYoZGV2X3ByaXYtPnZpcnRfc3VyZmFjZXNbaV0pOwoJCWlmIChzLT5maWxwKSB7CgkJCWlmICgobG93ZXIgPT0gcy0+bG93ZXIpICYmIChmaWxwID09IHMtPmZpbHApKSB7CgkJCQlpZiAoZGV2X3ByaXYtPnN1cmZhY2VzW3MtPnN1cmZhY2VfaW5kZXhdLmxvd2VyID09IHMtPmxvd2VyKQoJCQkJCWRldl9wcml2LT5zdXJmYWNlc1tzLT5zdXJmYWNlX2luZGV4XS5sb3dlciA9IHMtPnVwcGVyOwoKCQkJCWlmIChkZXZfcHJpdi0+c3VyZmFjZXNbcy0+c3VyZmFjZV9pbmRleF0udXBwZXIgPT0gcy0+dXBwZXIpCgkJCQkJZGV2X3ByaXYtPnN1cmZhY2VzW3MtPnN1cmZhY2VfaW5kZXhdLnVwcGVyID0gcy0+bG93ZXI7CgoJCQkJZGV2X3ByaXYtPnN1cmZhY2VzW3MtPnN1cmZhY2VfaW5kZXhdLnJlZmNvdW50LS07CgkJCQlpZiAoZGV2X3ByaXYtPnN1cmZhY2VzW3MtPnN1cmZhY2VfaW5kZXhdLnJlZmNvdW50ID09IDApCgkJCQkJZGV2X3ByaXYtPnN1cmZhY2VzW3MtPnN1cmZhY2VfaW5kZXhdLmZsYWdzID0gMDsKCQkJCXMtPmZpbHAgPSBOVUxMOwoJCQkJcmFkZW9uX2FwcGx5X3N1cmZhY2VfcmVncyhzLT5zdXJmYWNlX2luZGV4LCBkZXZfcHJpdik7CgkJCQlyZXR1cm4gMDsKCQkJfQoJCX0KCX0KCXJldHVybiAxOwp9CgpzdGF0aWMgdm9pZCByYWRlb25fc3VyZmFjZXNfcmVsZWFzZShEUk1GSUxFIGZpbHAsIGRybV9yYWRlb25fcHJpdmF0ZV90ICpkZXZfcHJpdikKewoJaW50IGk7Cglmb3IoIGkgPSAwOyBpIDwgMipSQURFT05fTUFYX1NVUkZBQ0VTOyBpKyspCgl7CgkJaWYgKGRldl9wcml2LT52aXJ0X3N1cmZhY2VzW2ldLmZpbHAgPT0gZmlscCkKCQkJZnJlZV9zdXJmYWNlKGZpbHAsIGRldl9wcml2LCBkZXZfcHJpdi0+dmlydF9zdXJmYWNlc1tpXS5sb3dlcik7Cgl9Cn0KCi8qID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KICogSU9DVEwgZnVuY3Rpb25zCiAqLwpzdGF0aWMgaW50IHJhZGVvbl9zdXJmYWNlX2FsbG9jKERSTV9JT0NUTF9BUkdTKQp7CglEUk1fREVWSUNFOwoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCWRybV9yYWRlb25fc3VyZmFjZV9hbGxvY190IGFsbG9jOwoKCWlmICghZGV2X3ByaXYpIHsKCQlEUk1fRVJST1IoICIlcyBjYWxsZWQgd2l0aCBubyBpbml0aWFsaXphdGlvblxuIiwgX19GVU5DVElPTl9fICk7CgkJcmV0dXJuIERSTV9FUlIoRUlOVkFMKTsKCX0KCglEUk1fQ09QWV9GUk9NX1VTRVJfSU9DVEwoYWxsb2MsIChkcm1fcmFkZW9uX3N1cmZhY2VfYWxsb2NfdCBfX3VzZXIgKilkYXRhLAoJCQkJICBzaXplb2YoYWxsb2MpKTsKCglpZiAoYWxsb2Nfc3VyZmFjZSgmYWxsb2MsIGRldl9wcml2LCBmaWxwKSA9PSAtMSkKCQlyZXR1cm4gRFJNX0VSUihFSU5WQUwpOwoJZWxzZQoJCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IHJhZGVvbl9zdXJmYWNlX2ZyZWUoRFJNX0lPQ1RMX0FSR1MpCnsKCURSTV9ERVZJQ0U7Cglkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoJZHJtX3JhZGVvbl9zdXJmYWNlX2ZyZWVfdCBtZW1mcmVlOwoKCWlmICghZGV2X3ByaXYpIHsKCQlEUk1fRVJST1IoICIlcyBjYWxsZWQgd2l0aCBubyBpbml0aWFsaXphdGlvblxuIiwgX19GVU5DVElPTl9fICk7CgkJcmV0dXJuIERSTV9FUlIoRUlOVkFMKTsKCX0KCglEUk1fQ09QWV9GUk9NX1VTRVJfSU9DVEwobWVtZnJlZSwgKGRybV9yYWRlb25fbWVtX2ZyZWVfdCBfX3VzZXIgKilkYXRhLAoJCQkJICBzaXplb2YobWVtZnJlZSkgKTsKCglpZiAoZnJlZV9zdXJmYWNlKGZpbHAsIGRldl9wcml2LCBtZW1mcmVlLmFkZHJlc3MpKQoJCXJldHVybiBEUk1fRVJSKEVJTlZBTCk7CgllbHNlCgkJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgcmFkZW9uX2NwX2NsZWFyKCBEUk1fSU9DVExfQVJHUyApCnsKCURSTV9ERVZJQ0U7Cglkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoJZHJtX3JhZGVvbl9zYXJlYV90ICpzYXJlYV9wcml2ID0gZGV2X3ByaXYtPnNhcmVhX3ByaXY7Cglkcm1fcmFkZW9uX2NsZWFyX3QgY2xlYXI7Cglkcm1fcmFkZW9uX2NsZWFyX3JlY3RfdCBkZXB0aF9ib3hlc1tSQURFT05fTlJfU0FSRUFfQ0xJUFJFQ1RTXTsKCURSTV9ERUJVRyggIlxuIiApOwoKCUxPQ0tfVEVTVF9XSVRIX1JFVFVSTiggZGV2LCBmaWxwICk7CgoJRFJNX0NPUFlfRlJPTV9VU0VSX0lPQ1RMKCBjbGVhciwgKGRybV9yYWRlb25fY2xlYXJfdCBfX3VzZXIgKilkYXRhLAoJCQkgICAgIHNpemVvZihjbGVhcikgKTsKCglSSU5HX1NQQUNFX1RFU1RfV0lUSF9SRVRVUk4oIGRldl9wcml2ICk7CgoJaWYgKCBzYXJlYV9wcml2LT5uYm94ID4gUkFERU9OX05SX1NBUkVBX0NMSVBSRUNUUyApCgkJc2FyZWFfcHJpdi0+bmJveCA9IFJBREVPTl9OUl9TQVJFQV9DTElQUkVDVFM7CgoJaWYgKCBEUk1fQ09QWV9GUk9NX1VTRVIoICZkZXB0aF9ib3hlcywgY2xlYXIuZGVwdGhfYm94ZXMsCgkJCSAgICAgc2FyZWFfcHJpdi0+bmJveCAqIHNpemVvZihkZXB0aF9ib3hlc1swXSkgKSApCgkJcmV0dXJuIERSTV9FUlIoRUZBVUxUKTsKCglyYWRlb25fY3BfZGlzcGF0Y2hfY2xlYXIoIGRldiwgJmNsZWFyLCBkZXB0aF9ib3hlcyApOwoKCUNPTU1JVF9SSU5HKCk7CglyZXR1cm4gMDsKfQoKCi8qIE5vdCBzdXJlIHdoeSB0aGlzIGlzbid0IHNldCBhbGwgdGhlIHRpbWU6CiAqLyAKc3RhdGljIGludCByYWRlb25fZG9faW5pdF9wYWdlZmxpcCggZHJtX2RldmljZV90ICpkZXYgKQp7Cglkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoJUklOR19MT0NBTFM7CgoJRFJNX0RFQlVHKCAiXG4iICk7CgoJQkVHSU5fUklORyggNiApOwoJUkFERU9OX1dBSVRfVU5USUxfM0RfSURMRSgpOwoJT1VUX1JJTkcoIENQX1BBQ0tFVDAoIFJBREVPTl9DUlRDX09GRlNFVF9DTlRMLCAwICkgKTsKCU9VVF9SSU5HKCBSQURFT05fUkVBRCggUkFERU9OX0NSVENfT0ZGU0VUX0NOVEwgKSB8IFJBREVPTl9DUlRDX09GRlNFVF9GTElQX0NOVEwgKTsKCU9VVF9SSU5HKCBDUF9QQUNLRVQwKCBSQURFT05fQ1JUQzJfT0ZGU0VUX0NOVEwsIDAgKSApOwoJT1VUX1JJTkcoIFJBREVPTl9SRUFEKCBSQURFT05fQ1JUQzJfT0ZGU0VUX0NOVEwgKSB8IFJBREVPTl9DUlRDX09GRlNFVF9GTElQX0NOVEwgKTsKCUFEVkFOQ0VfUklORygpOwoKCWRldl9wcml2LT5wYWdlX2ZsaXBwaW5nID0gMTsKCWRldl9wcml2LT5jdXJyZW50X3BhZ2UgPSAwOwoJZGV2X3ByaXYtPnNhcmVhX3ByaXYtPnBmQ3VycmVudFBhZ2UgPSBkZXZfcHJpdi0+Y3VycmVudF9wYWdlOwoKCXJldHVybiAwOwp9CgovKiBDYWxsZWQgd2hlbmV2ZXIgYSBjbGllbnQgZGllcywgZnJvbSBkcm1fcmVsZWFzZS4KICogTk9URTogIExvY2sgaXNuJ3QgbmVjZXNzYXJpbHkgaGVsZCB3aGVuIHRoaXMgaXMgY2FsbGVkIQogKi8Kc3RhdGljIGludCByYWRlb25fZG9fY2xlYW51cF9wYWdlZmxpcCggZHJtX2RldmljZV90ICpkZXYgKQp7Cglkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoJRFJNX0RFQlVHKCAiXG4iICk7CgoJaWYgKGRldl9wcml2LT5jdXJyZW50X3BhZ2UgIT0gMCkKCQlyYWRlb25fY3BfZGlzcGF0Y2hfZmxpcCggZGV2ICk7CgoJZGV2X3ByaXYtPnBhZ2VfZmxpcHBpbmcgPSAwOwoJcmV0dXJuIDA7Cn0KCi8qIFN3YXBwaW5nIGFuZCBmbGlwcGluZyBhcmUgZGlmZmVyZW50IG9wZXJhdGlvbnMsIG5lZWQgZGlmZmVyZW50IGlvY3Rscy4KICogVGhleSBjYW4gJiBzaG91bGQgYmUgaW50ZXJtaXhlZCB0byBzdXBwb3J0IG11bHRpcGxlIDNkIHdpbmRvd3MuICAKICovCnN0YXRpYyBpbnQgcmFkZW9uX2NwX2ZsaXAoIERSTV9JT0NUTF9BUkdTICkKewoJRFJNX0RFVklDRTsKCWRybV9yYWRlb25fcHJpdmF0ZV90ICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7CglEUk1fREVCVUcoICJcbiIgKTsKCglMT0NLX1RFU1RfV0lUSF9SRVRVUk4oIGRldiwgZmlscCApOwoKCVJJTkdfU1BBQ0VfVEVTVF9XSVRIX1JFVFVSTiggZGV2X3ByaXYgKTsKCglpZiAoIWRldl9wcml2LT5wYWdlX2ZsaXBwaW5nKSAKCQlyYWRlb25fZG9faW5pdF9wYWdlZmxpcCggZGV2ICk7CgkJCglyYWRlb25fY3BfZGlzcGF0Y2hfZmxpcCggZGV2ICk7CgoJQ09NTUlUX1JJTkcoKTsKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IHJhZGVvbl9jcF9zd2FwKCBEUk1fSU9DVExfQVJHUyApCnsKCURSTV9ERVZJQ0U7Cglkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoJZHJtX3JhZGVvbl9zYXJlYV90ICpzYXJlYV9wcml2ID0gZGV2X3ByaXYtPnNhcmVhX3ByaXY7CglEUk1fREVCVUcoICJcbiIgKTsKCglMT0NLX1RFU1RfV0lUSF9SRVRVUk4oIGRldiwgZmlscCApOwoKCVJJTkdfU1BBQ0VfVEVTVF9XSVRIX1JFVFVSTiggZGV2X3ByaXYgKTsKCglpZiAoIHNhcmVhX3ByaXYtPm5ib3ggPiBSQURFT05fTlJfU0FSRUFfQ0xJUFJFQ1RTICkKCQlzYXJlYV9wcml2LT5uYm94ID0gUkFERU9OX05SX1NBUkVBX0NMSVBSRUNUUzsKCglyYWRlb25fY3BfZGlzcGF0Y2hfc3dhcCggZGV2ICk7CglkZXZfcHJpdi0+c2FyZWFfcHJpdi0+Y3R4X293bmVyID0gMDsKCglDT01NSVRfUklORygpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgcmFkZW9uX2NwX3ZlcnRleCggRFJNX0lPQ1RMX0FSR1MgKQp7CglEUk1fREVWSUNFOwoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCWRybV9maWxlX3QgKmZpbHBfcHJpdjsKCWRybV9yYWRlb25fc2FyZWFfdCAqc2FyZWFfcHJpdiA9IGRldl9wcml2LT5zYXJlYV9wcml2OwoJZHJtX2RldmljZV9kbWFfdCAqZG1hID0gZGV2LT5kbWE7Cglkcm1fYnVmX3QgKmJ1ZjsKCWRybV9yYWRlb25fdmVydGV4X3QgdmVydGV4OwoJZHJtX3JhZGVvbl90Y2xfcHJpbV90IHByaW07CgoJTE9DS19URVNUX1dJVEhfUkVUVVJOKCBkZXYsIGZpbHAgKTsKCglEUk1fR0VUX1BSSVZfV0lUSF9SRVRVUk4oIGZpbHBfcHJpdiwgZmlscCApOwoKCURSTV9DT1BZX0ZST01fVVNFUl9JT0NUTCggdmVydGV4LCAoZHJtX3JhZGVvbl92ZXJ0ZXhfdCBfX3VzZXIgKilkYXRhLAoJCQkgICAgIHNpemVvZih2ZXJ0ZXgpICk7CgoJRFJNX0RFQlVHKCAicGlkPSVkIGluZGV4PSVkIGNvdW50PSVkIGRpc2NhcmQ9JWRcbiIsCgkJICAgRFJNX0NVUlJFTlRQSUQsCgkJICAgdmVydGV4LmlkeCwgdmVydGV4LmNvdW50LCB2ZXJ0ZXguZGlzY2FyZCApOwoKCWlmICggdmVydGV4LmlkeCA8IDAgfHwgdmVydGV4LmlkeCA+PSBkbWEtPmJ1Zl9jb3VudCApIHsKCQlEUk1fRVJST1IoICJidWZmZXIgaW5kZXggJWQgKG9mICVkIG1heClcbiIsCgkJCSAgIHZlcnRleC5pZHgsIGRtYS0+YnVmX2NvdW50IC0gMSApOwoJCXJldHVybiBEUk1fRVJSKEVJTlZBTCk7Cgl9CglpZiAoIHZlcnRleC5wcmltIDwgMCB8fAoJICAgICB2ZXJ0ZXgucHJpbSA+IFJBREVPTl9QUklNX1RZUEVfM1ZSVF9MSU5FX0xJU1QgKSB7CgkJRFJNX0VSUk9SKCAiYnVmZmVyIHByaW0gJWRcbiIsIHZlcnRleC5wcmltICk7CgkJcmV0dXJuIERSTV9FUlIoRUlOVkFMKTsKCX0KCglSSU5HX1NQQUNFX1RFU1RfV0lUSF9SRVRVUk4oIGRldl9wcml2ICk7CglWQl9BR0VfVEVTVF9XSVRIX1JFVFVSTiggZGV2X3ByaXYgKTsKCglidWYgPSBkbWEtPmJ1Zmxpc3RbdmVydGV4LmlkeF07CgoJaWYgKCBidWYtPmZpbHAgIT0gZmlscCApIHsKCQlEUk1fRVJST1IoICJwcm9jZXNzICVkIHVzaW5nIGJ1ZmZlciBvd25lZCBieSAlcFxuIiwKCQkJICAgRFJNX0NVUlJFTlRQSUQsIGJ1Zi0+ZmlscCApOwoJCXJldHVybiBEUk1fRVJSKEVJTlZBTCk7Cgl9CglpZiAoIGJ1Zi0+cGVuZGluZyApIHsKCQlEUk1fRVJST1IoICJzZW5kaW5nIHBlbmRpbmcgYnVmZmVyICVkXG4iLCB2ZXJ0ZXguaWR4ICk7CgkJcmV0dXJuIERSTV9FUlIoRUlOVkFMKTsKCX0KCgkvKiBCdWlsZCB1cCBhIHByaW1fdCByZWNvcmQ6CgkgKi8KCWlmICh2ZXJ0ZXguY291bnQpIHsKCQlidWYtPnVzZWQgPSB2ZXJ0ZXguY291bnQ7IC8qIG5vdCB1c2VkPyAqLwoKCQlpZiAoIHNhcmVhX3ByaXYtPmRpcnR5ICYgflJBREVPTl9VUExPQURfQ0xJUFJFQ1RTICkgewoJCQlpZiAoIHJhZGVvbl9lbWl0X3N0YXRlKCBkZXZfcHJpdiwgZmlscF9wcml2LAoJCQkJCQkmc2FyZWFfcHJpdi0+Y29udGV4dF9zdGF0ZSwKCQkJCQkJc2FyZWFfcHJpdi0+dGV4X3N0YXRlLAoJCQkJCQlzYXJlYV9wcml2LT5kaXJ0eSApICkgewoJCQkJRFJNX0VSUk9SKCAicmFkZW9uX2VtaXRfc3RhdGUgZmFpbGVkXG4iICk7CgkJCQlyZXR1cm4gRFJNX0VSUiggRUlOVkFMICk7CgkJCX0KCgkJCXNhcmVhX3ByaXYtPmRpcnR5ICY9IH4oUkFERU9OX1VQTE9BRF9URVgwSU1BR0VTIHwKCQkJCQkgICAgICAgUkFERU9OX1VQTE9BRF9URVgxSU1BR0VTIHwKCQkJCQkgICAgICAgUkFERU9OX1VQTE9BRF9URVgySU1BR0VTIHwKCQkJCQkgICAgICAgUkFERU9OX1JFUVVJUkVfUVVJRVNDRU5DRSk7CgkJfQoKCQlwcmltLnN0YXJ0ID0gMDsKCQlwcmltLmZpbmlzaCA9IHZlcnRleC5jb3VudDsgLyogdW51c2VkICovCgkJcHJpbS5wcmltID0gdmVydGV4LnByaW07CgkJcHJpbS5udW12ZXJ0cyA9IHZlcnRleC5jb3VudDsKCQlwcmltLnZjX2Zvcm1hdCA9IGRldl9wcml2LT5zYXJlYV9wcml2LT52Y19mb3JtYXQ7CgkJCgkJcmFkZW9uX2NwX2Rpc3BhdGNoX3ZlcnRleCggZGV2LCBidWYsICZwcmltICk7Cgl9CgoJaWYgKHZlcnRleC5kaXNjYXJkKSB7CgkJcmFkZW9uX2NwX2Rpc2NhcmRfYnVmZmVyKCBkZXYsIGJ1ZiApOwoJfQoKCUNPTU1JVF9SSU5HKCk7CglyZXR1cm4gMDsKfQoKc3RhdGljIGludCByYWRlb25fY3BfaW5kaWNlcyggRFJNX0lPQ1RMX0FSR1MgKQp7CglEUk1fREVWSUNFOwoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCWRybV9maWxlX3QgKmZpbHBfcHJpdjsKCWRybV9yYWRlb25fc2FyZWFfdCAqc2FyZWFfcHJpdiA9IGRldl9wcml2LT5zYXJlYV9wcml2OwoJZHJtX2RldmljZV9kbWFfdCAqZG1hID0gZGV2LT5kbWE7Cglkcm1fYnVmX3QgKmJ1ZjsKCWRybV9yYWRlb25faW5kaWNlc190IGVsdHM7Cglkcm1fcmFkZW9uX3RjbF9wcmltX3QgcHJpbTsKCWludCBjb3VudDsKCglMT0NLX1RFU1RfV0lUSF9SRVRVUk4oIGRldiwgZmlscCApOwoKCWlmICggIWRldl9wcml2ICkgewoJCURSTV9FUlJPUiggIiVzIGNhbGxlZCB3aXRoIG5vIGluaXRpYWxpemF0aW9uXG4iLCBfX0ZVTkNUSU9OX18gKTsKCQlyZXR1cm4gRFJNX0VSUihFSU5WQUwpOwoJfQoKCURSTV9HRVRfUFJJVl9XSVRIX1JFVFVSTiggZmlscF9wcml2LCBmaWxwICk7CgoJRFJNX0NPUFlfRlJPTV9VU0VSX0lPQ1RMKCBlbHRzLCAoZHJtX3JhZGVvbl9pbmRpY2VzX3QgX191c2VyICopZGF0YSwKCQkJICAgICBzaXplb2YoZWx0cykgKTsKCglEUk1fREVCVUcoICJwaWQ9JWQgaW5kZXg9JWQgc3RhcnQ9JWQgZW5kPSVkIGRpc2NhcmQ9JWRcbiIsCgkJICAgRFJNX0NVUlJFTlRQSUQsCgkJICAgZWx0cy5pZHgsIGVsdHMuc3RhcnQsIGVsdHMuZW5kLCBlbHRzLmRpc2NhcmQgKTsKCglpZiAoIGVsdHMuaWR4IDwgMCB8fCBlbHRzLmlkeCA+PSBkbWEtPmJ1Zl9jb3VudCApIHsKCQlEUk1fRVJST1IoICJidWZmZXIgaW5kZXggJWQgKG9mICVkIG1heClcbiIsCgkJCSAgIGVsdHMuaWR4LCBkbWEtPmJ1Zl9jb3VudCAtIDEgKTsKCQlyZXR1cm4gRFJNX0VSUihFSU5WQUwpOwoJfQoJaWYgKCBlbHRzLnByaW0gPCAwIHx8CgkgICAgIGVsdHMucHJpbSA+IFJBREVPTl9QUklNX1RZUEVfM1ZSVF9MSU5FX0xJU1QgKSB7CgkJRFJNX0VSUk9SKCAiYnVmZmVyIHByaW0gJWRcbiIsIGVsdHMucHJpbSApOwoJCXJldHVybiBEUk1fRVJSKEVJTlZBTCk7Cgl9CgoJUklOR19TUEFDRV9URVNUX1dJVEhfUkVUVVJOKCBkZXZfcHJpdiApOwoJVkJfQUdFX1RFU1RfV0lUSF9SRVRVUk4oIGRldl9wcml2ICk7CgoJYnVmID0gZG1hLT5idWZsaXN0W2VsdHMuaWR4XTsKCglpZiAoIGJ1Zi0+ZmlscCAhPSBmaWxwICkgewoJCURSTV9FUlJPUiggInByb2Nlc3MgJWQgdXNpbmcgYnVmZmVyIG93bmVkIGJ5ICVwXG4iLAoJCQkgICBEUk1fQ1VSUkVOVFBJRCwgYnVmLT5maWxwICk7CgkJcmV0dXJuIERSTV9FUlIoRUlOVkFMKTsKCX0KCWlmICggYnVmLT5wZW5kaW5nICkgewoJCURSTV9FUlJPUiggInNlbmRpbmcgcGVuZGluZyBidWZmZXIgJWRcbiIsIGVsdHMuaWR4ICk7CgkJcmV0dXJuIERSTV9FUlIoRUlOVkFMKTsKCX0KCgljb3VudCA9IChlbHRzLmVuZCAtIGVsdHMuc3RhcnQpIC8gc2l6ZW9mKHUxNik7CgllbHRzLnN0YXJ0IC09IFJBREVPTl9JTkRFWF9QUklNX09GRlNFVDsKCglpZiAoIGVsdHMuc3RhcnQgJiAweDcgKSB7CgkJRFJNX0VSUk9SKCAibWlzYWxpZ25lZCBidWZmZXIgMHgleFxuIiwgZWx0cy5zdGFydCApOwoJCXJldHVybiBEUk1fRVJSKEVJTlZBTCk7Cgl9CglpZiAoIGVsdHMuc3RhcnQgPCBidWYtPnVzZWQgKSB7CgkJRFJNX0VSUk9SKCAibm8gaGVhZGVyIDB4JXggLSAweCV4XG4iLCBlbHRzLnN0YXJ0LCBidWYtPnVzZWQgKTsKCQlyZXR1cm4gRFJNX0VSUihFSU5WQUwpOwoJfQoKCWJ1Zi0+dXNlZCA9IGVsdHMuZW5kOwoKCWlmICggc2FyZWFfcHJpdi0+ZGlydHkgJiB+UkFERU9OX1VQTE9BRF9DTElQUkVDVFMgKSB7CgkJaWYgKCByYWRlb25fZW1pdF9zdGF0ZSggZGV2X3ByaXYsIGZpbHBfcHJpdiwKCQkJCQkmc2FyZWFfcHJpdi0+Y29udGV4dF9zdGF0ZSwKCQkJCQlzYXJlYV9wcml2LT50ZXhfc3RhdGUsCgkJCQkJc2FyZWFfcHJpdi0+ZGlydHkgKSApIHsKCQkJRFJNX0VSUk9SKCAicmFkZW9uX2VtaXRfc3RhdGUgZmFpbGVkXG4iICk7CgkJCXJldHVybiBEUk1fRVJSKCBFSU5WQUwgKTsKCQl9CgoJCXNhcmVhX3ByaXYtPmRpcnR5ICY9IH4oUkFERU9OX1VQTE9BRF9URVgwSU1BR0VTIHwKCQkJCSAgICAgICBSQURFT05fVVBMT0FEX1RFWDFJTUFHRVMgfAoJCQkJICAgICAgIFJBREVPTl9VUExPQURfVEVYMklNQUdFUyB8CgkJCQkgICAgICAgUkFERU9OX1JFUVVJUkVfUVVJRVNDRU5DRSk7Cgl9CgoKCS8qIEJ1aWxkIHVwIGEgcHJpbV90IHJlY29yZDoKCSAqLwoJcHJpbS5zdGFydCA9IGVsdHMuc3RhcnQ7CglwcmltLmZpbmlzaCA9IGVsdHMuZW5kOyAKCXByaW0ucHJpbSA9IGVsdHMucHJpbTsKCXByaW0ub2Zmc2V0ID0gMDsJLyogb2Zmc2V0IGZyb20gc3RhcnQgb2YgZG1hIGJ1ZmZlcnMgKi8KCXByaW0ubnVtdmVydHMgPSBSQURFT05fTUFYX1ZCX1ZFUlRTOyAvKiBkdWggKi8KCXByaW0udmNfZm9ybWF0ID0gZGV2X3ByaXYtPnNhcmVhX3ByaXYtPnZjX2Zvcm1hdDsKCQoJcmFkZW9uX2NwX2Rpc3BhdGNoX2luZGljZXMoIGRldiwgYnVmLCAmcHJpbSApOwoJaWYgKGVsdHMuZGlzY2FyZCkgewoJCXJhZGVvbl9jcF9kaXNjYXJkX2J1ZmZlciggZGV2LCBidWYgKTsKCX0KCglDT01NSVRfUklORygpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgcmFkZW9uX2NwX3RleHR1cmUoIERSTV9JT0NUTF9BUkdTICkKewoJRFJNX0RFVklDRTsKCWRybV9yYWRlb25fcHJpdmF0ZV90ICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7Cglkcm1fcmFkZW9uX3RleHR1cmVfdCB0ZXg7Cglkcm1fcmFkZW9uX3RleF9pbWFnZV90IGltYWdlOwoJaW50IHJldDsKCglMT0NLX1RFU1RfV0lUSF9SRVRVUk4oIGRldiwgZmlscCApOwoKCURSTV9DT1BZX0ZST01fVVNFUl9JT0NUTCggdGV4LCAoZHJtX3JhZGVvbl90ZXh0dXJlX3QgX191c2VyICopZGF0YSwgc2l6ZW9mKHRleCkgKTsKCglpZiAoIHRleC5pbWFnZSA9PSBOVUxMICkgewoJCURSTV9FUlJPUiggIm51bGwgdGV4dHVyZSBpbWFnZSFcbiIgKTsKCQlyZXR1cm4gRFJNX0VSUihFSU5WQUwpOwoJfQoKCWlmICggRFJNX0NPUFlfRlJPTV9VU0VSKCAmaW1hZ2UsCgkJCSAgICAgKGRybV9yYWRlb25fdGV4X2ltYWdlX3QgX191c2VyICopdGV4LmltYWdlLAoJCQkgICAgIHNpemVvZihpbWFnZSkgKSApCgkJcmV0dXJuIERSTV9FUlIoRUZBVUxUKTsKCglSSU5HX1NQQUNFX1RFU1RfV0lUSF9SRVRVUk4oIGRldl9wcml2ICk7CglWQl9BR0VfVEVTVF9XSVRIX1JFVFVSTiggZGV2X3ByaXYgKTsKCglyZXQgPSByYWRlb25fY3BfZGlzcGF0Y2hfdGV4dHVyZSggZmlscCwgZGV2LCAmdGV4LCAmaW1hZ2UgKTsKCglDT01NSVRfUklORygpOwoJcmV0dXJuIHJldDsKfQoKc3RhdGljIGludCByYWRlb25fY3Bfc3RpcHBsZSggRFJNX0lPQ1RMX0FSR1MgKQp7CglEUk1fREVWSUNFOwoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCWRybV9yYWRlb25fc3RpcHBsZV90IHN0aXBwbGU7Cgl1MzIgbWFza1szMl07CgoJTE9DS19URVNUX1dJVEhfUkVUVVJOKCBkZXYsIGZpbHAgKTsKCglEUk1fQ09QWV9GUk9NX1VTRVJfSU9DVEwoIHN0aXBwbGUsIChkcm1fcmFkZW9uX3N0aXBwbGVfdCBfX3VzZXIgKilkYXRhLAoJCQkgICAgIHNpemVvZihzdGlwcGxlKSApOwoKCWlmICggRFJNX0NPUFlfRlJPTV9VU0VSKCAmbWFzaywgc3RpcHBsZS5tYXNrLCAzMiAqIHNpemVvZih1MzIpICkgKQoJCXJldHVybiBEUk1fRVJSKEVGQVVMVCk7CgoJUklOR19TUEFDRV9URVNUX1dJVEhfUkVUVVJOKCBkZXZfcHJpdiApOwoKCXJhZGVvbl9jcF9kaXNwYXRjaF9zdGlwcGxlKCBkZXYsIG1hc2sgKTsKCglDT01NSVRfUklORygpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgcmFkZW9uX2NwX2luZGlyZWN0KCBEUk1fSU9DVExfQVJHUyApCnsKCURSTV9ERVZJQ0U7Cglkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoJZHJtX2RldmljZV9kbWFfdCAqZG1hID0gZGV2LT5kbWE7Cglkcm1fYnVmX3QgKmJ1ZjsKCWRybV9yYWRlb25faW5kaXJlY3RfdCBpbmRpcmVjdDsKCVJJTkdfTE9DQUxTOwoKCUxPQ0tfVEVTVF9XSVRIX1JFVFVSTiggZGV2LCBmaWxwICk7CgoJaWYgKCAhZGV2X3ByaXYgKSB7CgkJRFJNX0VSUk9SKCAiJXMgY2FsbGVkIHdpdGggbm8gaW5pdGlhbGl6YXRpb25cbiIsIF9fRlVOQ1RJT05fXyApOwoJCXJldHVybiBEUk1fRVJSKEVJTlZBTCk7Cgl9CgoJRFJNX0NPUFlfRlJPTV9VU0VSX0lPQ1RMKCBpbmRpcmVjdCwgKGRybV9yYWRlb25faW5kaXJlY3RfdCBfX3VzZXIgKilkYXRhLAoJCQkgICAgIHNpemVvZihpbmRpcmVjdCkgKTsKCglEUk1fREVCVUcoICJpbmRpcmVjdDogaWR4PSVkIHM9JWQgZT0lZCBkPSVkXG4iLAoJCSAgIGluZGlyZWN0LmlkeCwgaW5kaXJlY3Quc3RhcnQsCgkJICAgaW5kaXJlY3QuZW5kLCBpbmRpcmVjdC5kaXNjYXJkICk7CgoJaWYgKCBpbmRpcmVjdC5pZHggPCAwIHx8IGluZGlyZWN0LmlkeCA+PSBkbWEtPmJ1Zl9jb3VudCApIHsKCQlEUk1fRVJST1IoICJidWZmZXIgaW5kZXggJWQgKG9mICVkIG1heClcbiIsCgkJCSAgIGluZGlyZWN0LmlkeCwgZG1hLT5idWZfY291bnQgLSAxICk7CgkJcmV0dXJuIERSTV9FUlIoRUlOVkFMKTsKCX0KCglidWYgPSBkbWEtPmJ1Zmxpc3RbaW5kaXJlY3QuaWR4XTsKCglpZiAoIGJ1Zi0+ZmlscCAhPSBmaWxwICkgewoJCURSTV9FUlJPUiggInByb2Nlc3MgJWQgdXNpbmcgYnVmZmVyIG93bmVkIGJ5ICVwXG4iLAoJCQkgICBEUk1fQ1VSUkVOVFBJRCwgYnVmLT5maWxwICk7CgkJcmV0dXJuIERSTV9FUlIoRUlOVkFMKTsKCX0KCWlmICggYnVmLT5wZW5kaW5nICkgewoJCURSTV9FUlJPUiggInNlbmRpbmcgcGVuZGluZyBidWZmZXIgJWRcbiIsIGluZGlyZWN0LmlkeCApOwoJCXJldHVybiBEUk1fRVJSKEVJTlZBTCk7Cgl9CgoJaWYgKCBpbmRpcmVjdC5zdGFydCA8IGJ1Zi0+dXNlZCApIHsKCQlEUk1fRVJST1IoICJyZXVzaW5nIGluZGlyZWN0OiBzdGFydD0weCV4IGFjdHVhbD0weCV4XG4iLAoJCQkgICBpbmRpcmVjdC5zdGFydCwgYnVmLT51c2VkICk7CgkJcmV0dXJuIERSTV9FUlIoRUlOVkFMKTsKCX0KCglSSU5HX1NQQUNFX1RFU1RfV0lUSF9SRVRVUk4oIGRldl9wcml2ICk7CglWQl9BR0VfVEVTVF9XSVRIX1JFVFVSTiggZGV2X3ByaXYgKTsKCglidWYtPnVzZWQgPSBpbmRpcmVjdC5lbmQ7CgoJLyogV2FpdCBmb3IgdGhlIDNEIHN0cmVhbSB0byBpZGxlIGJlZm9yZSB0aGUgaW5kaXJlY3QgYnVmZmVyCgkgKiBjb250YWluaW5nIDJEIGFjY2VsZXJhdGlvbiBjb21tYW5kcyBpcyBwcm9jZXNzZWQuCgkgKi8KCUJFR0lOX1JJTkcoIDIgKTsKCglSQURFT05fV0FJVF9VTlRJTF8zRF9JRExFKCk7CgoJQURWQU5DRV9SSU5HKCk7CgoJLyogRGlzcGF0Y2ggdGhlIGluZGlyZWN0IGJ1ZmZlciBmdWxsIG9mIGNvbW1hbmRzIGZyb20gdGhlCgkgKiBYIHNlcnZlci4gIFRoaXMgaXMgaW5zZWN1cmUgYW5kIGlzIHRodXMgb25seSBhdmFpbGFibGUgdG8KCSAqIHByaXZpbGVnZWQgY2xpZW50cy4KCSAqLwoJcmFkZW9uX2NwX2Rpc3BhdGNoX2luZGlyZWN0KCBkZXYsIGJ1ZiwgaW5kaXJlY3Quc3RhcnQsIGluZGlyZWN0LmVuZCApOwoJaWYgKGluZGlyZWN0LmRpc2NhcmQpIHsKCQlyYWRlb25fY3BfZGlzY2FyZF9idWZmZXIoIGRldiwgYnVmICk7Cgl9CgoKCUNPTU1JVF9SSU5HKCk7CglyZXR1cm4gMDsKfQoKc3RhdGljIGludCByYWRlb25fY3BfdmVydGV4MiggRFJNX0lPQ1RMX0FSR1MgKQp7CglEUk1fREVWSUNFOwoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCWRybV9maWxlX3QgKmZpbHBfcHJpdjsKCWRybV9yYWRlb25fc2FyZWFfdCAqc2FyZWFfcHJpdiA9IGRldl9wcml2LT5zYXJlYV9wcml2OwoJZHJtX2RldmljZV9kbWFfdCAqZG1hID0gZGV2LT5kbWE7Cglkcm1fYnVmX3QgKmJ1ZjsKCWRybV9yYWRlb25fdmVydGV4Ml90IHZlcnRleDsKCWludCBpOwoJdW5zaWduZWQgY2hhciBsYXN0c3RhdGU7CgoJTE9DS19URVNUX1dJVEhfUkVUVVJOKCBkZXYsIGZpbHAgKTsKCglpZiAoICFkZXZfcHJpdiApIHsKCQlEUk1fRVJST1IoICIlcyBjYWxsZWQgd2l0aCBubyBpbml0aWFsaXphdGlvblxuIiwgX19GVU5DVElPTl9fICk7CgkJcmV0dXJuIERSTV9FUlIoRUlOVkFMKTsKCX0KCglEUk1fR0VUX1BSSVZfV0lUSF9SRVRVUk4oIGZpbHBfcHJpdiwgZmlscCApOwoKCURSTV9DT1BZX0ZST01fVVNFUl9JT0NUTCggdmVydGV4LCAoZHJtX3JhZGVvbl92ZXJ0ZXgyX3QgX191c2VyICopZGF0YSwKCQkJICAgICBzaXplb2YodmVydGV4KSApOwoKCURSTV9ERUJVRyggInBpZD0lZCBpbmRleD0lZCBkaXNjYXJkPSVkXG4iLAoJCSAgIERSTV9DVVJSRU5UUElELAoJCSAgIHZlcnRleC5pZHgsIHZlcnRleC5kaXNjYXJkICk7CgoJaWYgKCB2ZXJ0ZXguaWR4IDwgMCB8fCB2ZXJ0ZXguaWR4ID49IGRtYS0+YnVmX2NvdW50ICkgewoJCURSTV9FUlJPUiggImJ1ZmZlciBpbmRleCAlZCAob2YgJWQgbWF4KVxuIiwKCQkJICAgdmVydGV4LmlkeCwgZG1hLT5idWZfY291bnQgLSAxICk7CgkJcmV0dXJuIERSTV9FUlIoRUlOVkFMKTsKCX0KCglSSU5HX1NQQUNFX1RFU1RfV0lUSF9SRVRVUk4oIGRldl9wcml2ICk7CglWQl9BR0VfVEVTVF9XSVRIX1JFVFVSTiggZGV2X3ByaXYgKTsKCglidWYgPSBkbWEtPmJ1Zmxpc3RbdmVydGV4LmlkeF07CgoJaWYgKCBidWYtPmZpbHAgIT0gZmlscCApIHsKCQlEUk1fRVJST1IoICJwcm9jZXNzICVkIHVzaW5nIGJ1ZmZlciBvd25lZCBieSAlcFxuIiwKCQkJICAgRFJNX0NVUlJFTlRQSUQsIGJ1Zi0+ZmlscCApOwoJCXJldHVybiBEUk1fRVJSKEVJTlZBTCk7Cgl9CgoJaWYgKCBidWYtPnBlbmRpbmcgKSB7CgkJRFJNX0VSUk9SKCAic2VuZGluZyBwZW5kaW5nIGJ1ZmZlciAlZFxuIiwgdmVydGV4LmlkeCApOwoJCXJldHVybiBEUk1fRVJSKEVJTlZBTCk7Cgl9CgkKCWlmIChzYXJlYV9wcml2LT5uYm94ID4gUkFERU9OX05SX1NBUkVBX0NMSVBSRUNUUykKCQlyZXR1cm4gRFJNX0VSUihFSU5WQUwpOwoKCWZvciAobGFzdHN0YXRlID0gMHhmZiwgaSA9IDAgOyBpIDwgdmVydGV4Lm5yX3ByaW1zIDsgaSsrKSB7CgkJZHJtX3JhZGVvbl9wcmltX3QgcHJpbTsKCQlkcm1fcmFkZW9uX3RjbF9wcmltX3QgdGNscHJpbTsKCQkKCQlpZiAoIERSTV9DT1BZX0ZST01fVVNFUiggJnByaW0sICZ2ZXJ0ZXgucHJpbVtpXSwgc2l6ZW9mKHByaW0pICkgKQoJCQlyZXR1cm4gRFJNX0VSUihFRkFVTFQpOwoJCQoJCWlmICggcHJpbS5zdGF0ZWlkeCAhPSBsYXN0c3RhdGUgKSB7CgkJCWRybV9yYWRlb25fc3RhdGVfdCBzdGF0ZTsJCQkgICAgICAgCgkJCQkKCQkJaWYgKCBEUk1fQ09QWV9GUk9NX1VTRVIoICZzdGF0ZSwgCgkJCQkJICAgICAmdmVydGV4LnN0YXRlW3ByaW0uc3RhdGVpZHhdLCAKCQkJCQkgICAgIHNpemVvZihzdGF0ZSkgKSApCgkJCQlyZXR1cm4gRFJNX0VSUihFRkFVTFQpOwoKCQkJaWYgKCByYWRlb25fZW1pdF9zdGF0ZTIoIGRldl9wcml2LCBmaWxwX3ByaXYsICZzdGF0ZSApICkgewoJCQkJRFJNX0VSUk9SKCAicmFkZW9uX2VtaXRfc3RhdGUyIGZhaWxlZFxuIiApOwoJCQkJcmV0dXJuIERSTV9FUlIoIEVJTlZBTCApOwoJCQl9CgoJCQlsYXN0c3RhdGUgPSBwcmltLnN0YXRlaWR4OwoJCX0KCgkJdGNscHJpbS5zdGFydCA9IHByaW0uc3RhcnQ7CgkJdGNscHJpbS5maW5pc2ggPSBwcmltLmZpbmlzaDsKCQl0Y2xwcmltLnByaW0gPSBwcmltLnByaW07CgkJdGNscHJpbS52Y19mb3JtYXQgPSBwcmltLnZjX2Zvcm1hdDsKCgkJaWYgKCBwcmltLnByaW0gJiBSQURFT05fUFJJTV9XQUxLX0lORCApIHsKCQkJdGNscHJpbS5vZmZzZXQgPSBwcmltLm51bXZlcnRzICogNjQ7CgkJCXRjbHByaW0ubnVtdmVydHMgPSBSQURFT05fTUFYX1ZCX1ZFUlRTOyAvKiBkdWggKi8KCgkJCXJhZGVvbl9jcF9kaXNwYXRjaF9pbmRpY2VzKCBkZXYsIGJ1ZiwgJnRjbHByaW0gKTsKCQl9IGVsc2UgewoJCQl0Y2xwcmltLm51bXZlcnRzID0gcHJpbS5udW12ZXJ0czsKCQkJdGNscHJpbS5vZmZzZXQgPSAwOyAvKiBub3QgdXNlZCAqLwoKCQkJcmFkZW9uX2NwX2Rpc3BhdGNoX3ZlcnRleCggZGV2LCBidWYsICZ0Y2xwcmltICk7CgkJfQoJCQoJCWlmIChzYXJlYV9wcml2LT5uYm94ID09IDEpCgkJCXNhcmVhX3ByaXYtPm5ib3ggPSAwOwoJfQoKCWlmICggdmVydGV4LmRpc2NhcmQgKSB7CgkJcmFkZW9uX2NwX2Rpc2NhcmRfYnVmZmVyKCBkZXYsIGJ1ZiApOwoJfQoKCUNPTU1JVF9SSU5HKCk7CglyZXR1cm4gMDsKfQoKCnN0YXRpYyBpbnQgcmFkZW9uX2VtaXRfcGFja2V0cyggCglkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYsCglkcm1fZmlsZV90ICpmaWxwX3ByaXYsCglkcm1fcmFkZW9uX2NtZF9oZWFkZXJfdCBoZWFkZXIsCglkcm1fcmFkZW9uX2NtZF9idWZmZXJfdCAqY21kYnVmICkKewoJaW50IGlkID0gKGludCloZWFkZXIucGFja2V0LnBhY2tldF9pZDsKCWludCBzeiwgcmVnOwoJaW50ICpkYXRhID0gKGludCAqKWNtZGJ1Zi0+YnVmOwoJUklOR19MT0NBTFM7CiAgIAoJaWYgKGlkID49IFJBREVPTl9NQVhfU1RBVEVfUEFDS0VUUykKCQlyZXR1cm4gRFJNX0VSUihFSU5WQUwpOwoKCXN6ID0gcGFja2V0W2lkXS5sZW47CglyZWcgPSBwYWNrZXRbaWRdLnN0YXJ0OwoKCWlmIChzeiAqIHNpemVvZihpbnQpID4gY21kYnVmLT5idWZzeikgewoJCURSTV9FUlJPUiggIlBhY2tldCBzaXplIHByb3ZpZGVkIGxhcmdlciB0aGFuIGRhdGEgcHJvdmlkZWRcbiIgKTsKCQlyZXR1cm4gRFJNX0VSUihFSU5WQUwpOwoJfQoKCWlmICggcmFkZW9uX2NoZWNrX2FuZF9maXh1cF9wYWNrZXRzKCBkZXZfcHJpdiwgZmlscF9wcml2LCBpZCwgZGF0YSApICkgewoJCURSTV9FUlJPUiggIlBhY2tldCB2ZXJpZmljYXRpb24gZmFpbGVkXG4iICk7CgkJcmV0dXJuIERSTV9FUlIoIEVJTlZBTCApOwoJfQoKCUJFR0lOX1JJTkcoc3orMSk7CglPVVRfUklORyggQ1BfUEFDS0VUMCggcmVnLCAoc3otMSkgKSApOwoJT1VUX1JJTkdfVEFCTEUoIGRhdGEsIHN6ICk7CglBRFZBTkNFX1JJTkcoKTsKCgljbWRidWYtPmJ1ZiArPSBzeiAqIHNpemVvZihpbnQpOwoJY21kYnVmLT5idWZzeiAtPSBzeiAqIHNpemVvZihpbnQpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBfX2lubGluZV9fIGludCByYWRlb25fZW1pdF9zY2FsYXJzKCAKCWRybV9yYWRlb25fcHJpdmF0ZV90ICpkZXZfcHJpdiwKCWRybV9yYWRlb25fY21kX2hlYWRlcl90IGhlYWRlciwKCWRybV9yYWRlb25fY21kX2J1ZmZlcl90ICpjbWRidWYgKQp7CglpbnQgc3ogPSBoZWFkZXIuc2NhbGFycy5jb3VudDsKCWludCBzdGFydCA9IGhlYWRlci5zY2FsYXJzLm9mZnNldDsKCWludCBzdHJpZGUgPSBoZWFkZXIuc2NhbGFycy5zdHJpZGU7CglSSU5HX0xPQ0FMUzsKCglCRUdJTl9SSU5HKCAzK3N6ICk7CglPVVRfUklORyggQ1BfUEFDS0VUMCggUkFERU9OX1NFX1RDTF9TQ0FMQVJfSU5EWF9SRUcsIDAgKSApOwoJT1VUX1JJTkcoIHN0YXJ0IHwgKHN0cmlkZSA8PCBSQURFT05fU0NBTF9JTkRYX0RXT1JEX1NUUklERV9TSElGVCkpOwoJT1VUX1JJTkcoIENQX1BBQ0tFVDBfVEFCTEUoIFJBREVPTl9TRV9UQ0xfU0NBTEFSX0RBVEFfUkVHLCBzei0xICkgKTsKCU9VVF9SSU5HX1RBQkxFKCBjbWRidWYtPmJ1Ziwgc3ogKTsKCUFEVkFOQ0VfUklORygpOwoJY21kYnVmLT5idWYgKz0gc3ogKiBzaXplb2YoaW50KTsKCWNtZGJ1Zi0+YnVmc3ogLT0gc3ogKiBzaXplb2YoaW50KTsKCXJldHVybiAwOwp9CgovKiBHb2QgdGhpcyBpcyB1Z2x5CiAqLwpzdGF0aWMgX19pbmxpbmVfXyBpbnQgcmFkZW9uX2VtaXRfc2NhbGFyczIoIAoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2LAoJZHJtX3JhZGVvbl9jbWRfaGVhZGVyX3QgaGVhZGVyLAoJZHJtX3JhZGVvbl9jbWRfYnVmZmVyX3QgKmNtZGJ1ZiApCnsKCWludCBzeiA9IGhlYWRlci5zY2FsYXJzLmNvdW50OwoJaW50IHN0YXJ0ID0gKCh1bnNpZ25lZCBpbnQpaGVhZGVyLnNjYWxhcnMub2Zmc2V0KSArIDB4MTAwOwoJaW50IHN0cmlkZSA9IGhlYWRlci5zY2FsYXJzLnN0cmlkZTsKCVJJTkdfTE9DQUxTOwoKCUJFR0lOX1JJTkcoIDMrc3ogKTsKCU9VVF9SSU5HKCBDUF9QQUNLRVQwKCBSQURFT05fU0VfVENMX1NDQUxBUl9JTkRYX1JFRywgMCApICk7CglPVVRfUklORyggc3RhcnQgfCAoc3RyaWRlIDw8IFJBREVPTl9TQ0FMX0lORFhfRFdPUkRfU1RSSURFX1NISUZUKSk7CglPVVRfUklORyggQ1BfUEFDS0VUMF9UQUJMRSggUkFERU9OX1NFX1RDTF9TQ0FMQVJfREFUQV9SRUcsIHN6LTEgKSApOwoJT1VUX1JJTkdfVEFCTEUoIGNtZGJ1Zi0+YnVmLCBzeiApOwoJQURWQU5DRV9SSU5HKCk7CgljbWRidWYtPmJ1ZiArPSBzeiAqIHNpemVvZihpbnQpOwoJY21kYnVmLT5idWZzeiAtPSBzeiAqIHNpemVvZihpbnQpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBfX2lubGluZV9fIGludCByYWRlb25fZW1pdF92ZWN0b3JzKCAKCWRybV9yYWRlb25fcHJpdmF0ZV90ICpkZXZfcHJpdiwKCWRybV9yYWRlb25fY21kX2hlYWRlcl90IGhlYWRlciwKCWRybV9yYWRlb25fY21kX2J1ZmZlcl90ICpjbWRidWYgKQp7CglpbnQgc3ogPSBoZWFkZXIudmVjdG9ycy5jb3VudDsKCWludCBzdGFydCA9IGhlYWRlci52ZWN0b3JzLm9mZnNldDsKCWludCBzdHJpZGUgPSBoZWFkZXIudmVjdG9ycy5zdHJpZGU7CglSSU5HX0xPQ0FMUzsKCglCRUdJTl9SSU5HKCAzK3N6ICk7CglPVVRfUklORyggQ1BfUEFDS0VUMCggUkFERU9OX1NFX1RDTF9WRUNUT1JfSU5EWF9SRUcsIDAgKSApOwoJT1VUX1JJTkcoIHN0YXJ0IHwgKHN0cmlkZSA8PCBSQURFT05fVkVDX0lORFhfT0NUV09SRF9TVFJJREVfU0hJRlQpKTsKCU9VVF9SSU5HKCBDUF9QQUNLRVQwX1RBQkxFKCBSQURFT05fU0VfVENMX1ZFQ1RPUl9EQVRBX1JFRywgKHN6LTEpICkgKTsKCU9VVF9SSU5HX1RBQkxFKCBjbWRidWYtPmJ1Ziwgc3ogKTsKCUFEVkFOQ0VfUklORygpOwoKCWNtZGJ1Zi0+YnVmICs9IHN6ICogc2l6ZW9mKGludCk7CgljbWRidWYtPmJ1ZnN6IC09IHN6ICogc2l6ZW9mKGludCk7CglyZXR1cm4gMDsKfQoKCnN0YXRpYyBpbnQgcmFkZW9uX2VtaXRfcGFja2V0MyggZHJtX2RldmljZV90ICpkZXYsCgkJCQlkcm1fZmlsZV90ICpmaWxwX3ByaXYsCgkJCQlkcm1fcmFkZW9uX2NtZF9idWZmZXJfdCAqY21kYnVmICkKewoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCXVuc2lnbmVkIGludCBjbWRzejsKCWludCByZXQ7CglSSU5HX0xPQ0FMUzsKCglEUk1fREVCVUcoIlxuIik7CgoJaWYgKCAoIHJldCA9IHJhZGVvbl9jaGVja19hbmRfZml4dXBfcGFja2V0MyggZGV2X3ByaXYsIGZpbHBfcHJpdiwKCQkJCQkJICAgICBjbWRidWYsICZjbWRzeiApICkgKSB7CgkJRFJNX0VSUk9SKCAiUGFja2V0IHZlcmlmaWNhdGlvbiBmYWlsZWRcbiIgKTsKCQlyZXR1cm4gcmV0OwoJfQoKCUJFR0lOX1JJTkcoIGNtZHN6ICk7CglPVVRfUklOR19UQUJMRSggY21kYnVmLT5idWYsIGNtZHN6ICk7CglBRFZBTkNFX1JJTkcoKTsKCgljbWRidWYtPmJ1ZiArPSBjbWRzeiAqIDQ7CgljbWRidWYtPmJ1ZnN6IC09IGNtZHN6ICogNDsKCXJldHVybiAwOwp9CgoKc3RhdGljIGludCByYWRlb25fZW1pdF9wYWNrZXQzX2NsaXByZWN0KCBkcm1fZGV2aWNlX3QgKmRldiwKCQkJCQkgZHJtX2ZpbGVfdCAqZmlscF9wcml2LAoJCQkJCSBkcm1fcmFkZW9uX2NtZF9idWZmZXJfdCAqY21kYnVmLAoJCQkJCSBpbnQgb3JpZ19uYm94ICkKewoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCWRybV9jbGlwX3JlY3RfdCBib3g7Cgl1bnNpZ25lZCBpbnQgY21kc3o7CglpbnQgcmV0OwoJZHJtX2NsaXBfcmVjdF90IF9fdXNlciAqYm94ZXMgPSBjbWRidWYtPmJveGVzOwoJaW50IGkgPSAwOwoJUklOR19MT0NBTFM7CgoJRFJNX0RFQlVHKCJcbiIpOwoKCWlmICggKCByZXQgPSByYWRlb25fY2hlY2tfYW5kX2ZpeHVwX3BhY2tldDMoIGRldl9wcml2LCBmaWxwX3ByaXYsCgkJCQkJCSAgICAgY21kYnVmLCAmY21kc3ogKSApICkgewoJCURSTV9FUlJPUiggIlBhY2tldCB2ZXJpZmljYXRpb24gZmFpbGVkXG4iICk7CgkJcmV0dXJuIHJldDsKCX0KCglpZiAoIW9yaWdfbmJveCkKCQlnb3RvIG91dDsKCglkbyB7CgkJaWYgKCBpIDwgY21kYnVmLT5uYm94ICkgewoJCQlpZiAoRFJNX0NPUFlfRlJPTV9VU0VSKCAmYm94LCAmYm94ZXNbaV0sIHNpemVvZihib3gpICkpCgkJCQlyZXR1cm4gRFJNX0VSUihFRkFVTFQpOwoJCQkvKiBGSVhNRSBUaGUgc2Vjb25kIGFuZCBzdWJzZXF1ZW50IHRpbWVzIHJvdW5kCgkJCSAqIHRoaXMgbG9vcCwgc2VuZCBhIFdBSVRfVU5USUxfM0RfSURMRSBiZWZvcmUKCQkJICogY2FsbGluZyBlbWl0X2NsaXBfcmVjdCgpLiBUaGlzIGZpeGVzIGEKCQkJICogbG9ja3VwIG9uIGZhc3QgbWFjaGluZXMgd2hlbiBzZW5kaW5nCgkJCSAqIHNldmVyYWwgY2xpcHJlY3RzIHdpdGggYSBjbWRidWYsIGFzIHdoZW4KCQkJICogd2F2aW5nIGEgMkQgd2luZG93IG92ZXIgYSAzRAoJCQkgKiB3aW5kb3cuIFNvbWV0aGluZyBpbiB0aGUgY29tbWFuZHMgZnJvbSB1c2VyCgkJCSAqIHNwYWNlIHNlZW1zIHRvIGhhbmcgdGhlIGNhcmQgd2hlbiB0aGV5J3JlCgkJCSAqIHNlbnQgc2V2ZXJhbCB0aW1lcyBpbiBhIHJvdy4gVGhhdCB3b3VsZCBiZQoJCQkgKiB0aGUgY29ycmVjdCBwbGFjZSB0byBmaXggaXQgYnV0IHRoaXMgd29ya3MKCQkJICogYXJvdW5kIGl0IHVudGlsIEkgY2FuIGZpZ3VyZSB0aGF0IG91dCAtIFRpbQoJCQkgKiBTbWl0aCAqLwoJCQlpZiAoIGkgKSB7CgkJCQlCRUdJTl9SSU5HKCAyICk7CgkJCQlSQURFT05fV0FJVF9VTlRJTF8zRF9JRExFKCk7CgkJCQlBRFZBTkNFX1JJTkcoKTsKCQkJfQoJCQlyYWRlb25fZW1pdF9jbGlwX3JlY3QoIGRldl9wcml2LCAmYm94ICk7CgkJfQoJCQoJCUJFR0lOX1JJTkcoIGNtZHN6ICk7CgkJT1VUX1JJTkdfVEFCTEUoIGNtZGJ1Zi0+YnVmLCBjbWRzeiApOwoJCUFEVkFOQ0VfUklORygpOwoKCX0gd2hpbGUgKCArK2kgPCBjbWRidWYtPm5ib3ggKTsKIAlpZiAoY21kYnVmLT5uYm94ID09IDEpCgkJY21kYnVmLT5uYm94ID0gMDsKCiBvdXQ6CgljbWRidWYtPmJ1ZiArPSBjbWRzeiAqIDQ7CgljbWRidWYtPmJ1ZnN6IC09IGNtZHN6ICogNDsKCXJldHVybiAwOwp9CgoKc3RhdGljIGludCByYWRlb25fZW1pdF93YWl0KCBkcm1fZGV2aWNlX3QgKmRldiwgaW50IGZsYWdzICkKewoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCVJJTkdfTE9DQUxTOwoKCURSTV9ERUJVRygiJXM6ICV4XG4iLCBfX0ZVTkNUSU9OX18sIGZsYWdzKTsKCXN3aXRjaCAoZmxhZ3MpIHsKCWNhc2UgUkFERU9OX1dBSVRfMkQ6CgkJQkVHSU5fUklORyggMiApOwoJCVJBREVPTl9XQUlUX1VOVElMXzJEX0lETEUoKTsgCgkJQURWQU5DRV9SSU5HKCk7CgkJYnJlYWs7CgljYXNlIFJBREVPTl9XQUlUXzNEOgoJCUJFR0lOX1JJTkcoIDIgKTsKCQlSQURFT05fV0FJVF9VTlRJTF8zRF9JRExFKCk7IAoJCUFEVkFOQ0VfUklORygpOwoJCWJyZWFrOwoJY2FzZSBSQURFT05fV0FJVF8yRHxSQURFT05fV0FJVF8zRDoKCQlCRUdJTl9SSU5HKCAyICk7CgkJUkFERU9OX1dBSVRfVU5USUxfSURMRSgpOyAKCQlBRFZBTkNFX1JJTkcoKTsKCQlicmVhazsKCWRlZmF1bHQ6CgkJcmV0dXJuIERSTV9FUlIoRUlOVkFMKTsKCX0KCglyZXR1cm4gMDsKfQoKc3RhdGljIGludCByYWRlb25fY3BfY21kYnVmKCBEUk1fSU9DVExfQVJHUyApCnsKCURSTV9ERVZJQ0U7Cglkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOwoJZHJtX2ZpbGVfdCAqZmlscF9wcml2OwoJZHJtX2RldmljZV9kbWFfdCAqZG1hID0gZGV2LT5kbWE7Cglkcm1fYnVmX3QgKmJ1ZiA9IE5VTEw7CglpbnQgaWR4OwoJZHJtX3JhZGVvbl9jbWRfYnVmZmVyX3QgY21kYnVmOwoJZHJtX3JhZGVvbl9jbWRfaGVhZGVyX3QgaGVhZGVyOwoJaW50IG9yaWdfbmJveCwgb3JpZ19idWZzejsKCWNoYXIgKmtidWY9TlVMTDsKCglMT0NLX1RFU1RfV0lUSF9SRVRVUk4oIGRldiwgZmlscCApOwoKCWlmICggIWRldl9wcml2ICkgewoJCURSTV9FUlJPUiggIiVzIGNhbGxlZCB3aXRoIG5vIGluaXRpYWxpemF0aW9uXG4iLCBfX0ZVTkNUSU9OX18gKTsKCQlyZXR1cm4gRFJNX0VSUihFSU5WQUwpOwoJfQoKCURSTV9HRVRfUFJJVl9XSVRIX1JFVFVSTiggZmlscF9wcml2LCBmaWxwICk7CgoJRFJNX0NPUFlfRlJPTV9VU0VSX0lPQ1RMKCBjbWRidWYsIChkcm1fcmFkZW9uX2NtZF9idWZmZXJfdCBfX3VzZXIgKilkYXRhLAoJCQkgICAgIHNpemVvZihjbWRidWYpICk7CgoJUklOR19TUEFDRV9URVNUX1dJVEhfUkVUVVJOKCBkZXZfcHJpdiApOwoJVkJfQUdFX1RFU1RfV0lUSF9SRVRVUk4oIGRldl9wcml2ICk7CgoJaWYgKGNtZGJ1Zi5idWZzeiA+IDY0KjEwMjQgfHwgY21kYnVmLmJ1ZnN6PDApIHsKCQlyZXR1cm4gRFJNX0VSUihFSU5WQUwpOwoJfQoKCS8qIEFsbG9jYXRlIGFuIGluLWtlcm5lbCBhcmVhIGFuZCBjb3B5IGluIHRoZSBjbWRidWYuICBEbyB0aGlzIHRvIGF2b2lkCgkgKiByYWNlcyBiZXR3ZWVuIGNoZWNraW5nIHZhbHVlcyBhbmQgdXNpbmcgdGhvc2UgdmFsdWVzIGluIG90aGVyIGNvZGUsCgkgKiBhbmQgc2ltcGx5IHRvIGF2b2lkIGEgbG90IG9mIGZ1bmN0aW9uIGNhbGxzIHRvIGNvcHkgaW4gZGF0YS4KCSAqLwoJb3JpZ19idWZzeiA9IGNtZGJ1Zi5idWZzejsKCWlmIChvcmlnX2J1ZnN6ICE9IDApIHsKCQlrYnVmID0gZHJtX2FsbG9jKGNtZGJ1Zi5idWZzeiwgRFJNX01FTV9EUklWRVIpOwoJCWlmIChrYnVmID09IE5VTEwpCgkJCXJldHVybiBEUk1fRVJSKEVOT01FTSk7CgkJaWYgKERSTV9DT1BZX0ZST01fVVNFUihrYnVmLCBjbWRidWYuYnVmLCBjbWRidWYuYnVmc3opKSB7CgkJCWRybV9mcmVlKGtidWYsIG9yaWdfYnVmc3osIERSTV9NRU1fRFJJVkVSKTsKCQkJcmV0dXJuIERSTV9FUlIoRUZBVUxUKTsKCQl9CgkJY21kYnVmLmJ1ZiA9IGtidWY7Cgl9CgoJb3JpZ19uYm94ID0gY21kYnVmLm5ib3g7CgoJaWYoZGV2X3ByaXYtPm1pY3JvY29kZV92ZXJzaW9uID09IFVDT0RFX1IzMDApIHsKCQlpbnQgdGVtcDsKCQl0ZW1wPXIzMDBfZG9fY3BfY21kYnVmKGRldiwgZmlscCwgZmlscF9wcml2LCAmY21kYnVmKTsKCQoJCWlmIChvcmlnX2J1ZnN6ICE9IDApCgkJCWRybV9mcmVlKGtidWYsIG9yaWdfYnVmc3osIERSTV9NRU1fRFJJVkVSKTsKCQoJCXJldHVybiB0ZW1wOwoJfQoKCS8qIG1pY3JvY29kZV92ZXJzaW9uICE9IHIzMDAgKi8KCXdoaWxlICggY21kYnVmLmJ1ZnN6ID49IHNpemVvZihoZWFkZXIpICkgewoKCQloZWFkZXIuaSA9ICooaW50ICopY21kYnVmLmJ1ZjsKCQljbWRidWYuYnVmICs9IHNpemVvZihoZWFkZXIpOwoJCWNtZGJ1Zi5idWZzeiAtPSBzaXplb2YoaGVhZGVyKTsKCgkJc3dpdGNoIChoZWFkZXIuaGVhZGVyLmNtZF90eXBlKSB7CgkJY2FzZSBSQURFT05fQ01EX1BBQ0tFVDogCgkJCURSTV9ERUJVRygiUkFERU9OX0NNRF9QQUNLRVRcbiIpOwoJCQlpZiAocmFkZW9uX2VtaXRfcGFja2V0cyggZGV2X3ByaXYsIGZpbHBfcHJpdiwgaGVhZGVyLCAmY21kYnVmICkpIHsKCQkJCURSTV9FUlJPUigicmFkZW9uX2VtaXRfcGFja2V0cyBmYWlsZWRcbiIpOwoJCQkJZ290byBlcnI7CgkJCX0KCQkJYnJlYWs7CgoJCWNhc2UgUkFERU9OX0NNRF9TQ0FMQVJTOgoJCQlEUk1fREVCVUcoIlJBREVPTl9DTURfU0NBTEFSU1xuIik7CgkJCWlmIChyYWRlb25fZW1pdF9zY2FsYXJzKCBkZXZfcHJpdiwgaGVhZGVyLCAmY21kYnVmICkpIHsKCQkJCURSTV9FUlJPUigicmFkZW9uX2VtaXRfc2NhbGFycyBmYWlsZWRcbiIpOwoJCQkJZ290byBlcnI7CgkJCX0KCQkJYnJlYWs7CgoJCWNhc2UgUkFERU9OX0NNRF9WRUNUT1JTOgoJCQlEUk1fREVCVUcoIlJBREVPTl9DTURfVkVDVE9SU1xuIik7CgkJCWlmIChyYWRlb25fZW1pdF92ZWN0b3JzKCBkZXZfcHJpdiwgaGVhZGVyLCAmY21kYnVmICkpIHsKCQkJCURSTV9FUlJPUigicmFkZW9uX2VtaXRfdmVjdG9ycyBmYWlsZWRcbiIpOwoJCQkJZ290byBlcnI7CgkJCX0KCQkJYnJlYWs7CgoJCWNhc2UgUkFERU9OX0NNRF9ETUFfRElTQ0FSRDoKCQkJRFJNX0RFQlVHKCJSQURFT05fQ01EX0RNQV9ESVNDQVJEXG4iKTsKCQkJaWR4ID0gaGVhZGVyLmRtYS5idWZfaWR4OwoJCQlpZiAoIGlkeCA8IDAgfHwgaWR4ID49IGRtYS0+YnVmX2NvdW50ICkgewoJCQkJRFJNX0VSUk9SKCAiYnVmZmVyIGluZGV4ICVkIChvZiAlZCBtYXgpXG4iLAoJCQkJCSAgIGlkeCwgZG1hLT5idWZfY291bnQgLSAxICk7CgkJCQlnb3RvIGVycjsKCQkJfQoKCQkJYnVmID0gZG1hLT5idWZsaXN0W2lkeF07CgkJCWlmICggYnVmLT5maWxwICE9IGZpbHAgfHwgYnVmLT5wZW5kaW5nICkgewoJCQkJRFJNX0VSUk9SKCAiYmFkIGJ1ZmZlciAlcCAlcCAlZFxuIiwKCQkJCQkgICBidWYtPmZpbHAsIGZpbHAsIGJ1Zi0+cGVuZGluZyk7CgkJCQlnb3RvIGVycjsKCQkJfQoKCQkJcmFkZW9uX2NwX2Rpc2NhcmRfYnVmZmVyKCBkZXYsIGJ1ZiApOwoJCQlicmVhazsKCgkJY2FzZSBSQURFT05fQ01EX1BBQ0tFVDM6CgkJCURSTV9ERUJVRygiUkFERU9OX0NNRF9QQUNLRVQzXG4iKTsKCQkJaWYgKHJhZGVvbl9lbWl0X3BhY2tldDMoIGRldiwgZmlscF9wcml2LCAmY21kYnVmICkpIHsKCQkJCURSTV9FUlJPUigicmFkZW9uX2VtaXRfcGFja2V0MyBmYWlsZWRcbiIpOwoJCQkJZ290byBlcnI7CgkJCX0KCQkJYnJlYWs7CgoJCWNhc2UgUkFERU9OX0NNRF9QQUNLRVQzX0NMSVA6CgkJCURSTV9ERUJVRygiUkFERU9OX0NNRF9QQUNLRVQzX0NMSVBcbiIpOwoJCQlpZiAocmFkZW9uX2VtaXRfcGFja2V0M19jbGlwcmVjdCggZGV2LCBmaWxwX3ByaXYsICZjbWRidWYsIG9yaWdfbmJveCApKSB7CgkJCQlEUk1fRVJST1IoInJhZGVvbl9lbWl0X3BhY2tldDNfY2xpcCBmYWlsZWRcbiIpOwoJCQkJZ290byBlcnI7CgkJCX0KCQkJYnJlYWs7CgoJCWNhc2UgUkFERU9OX0NNRF9TQ0FMQVJTMjoKCQkJRFJNX0RFQlVHKCJSQURFT05fQ01EX1NDQUxBUlMyXG4iKTsKCQkJaWYgKHJhZGVvbl9lbWl0X3NjYWxhcnMyKCBkZXZfcHJpdiwgaGVhZGVyLCAmY21kYnVmICkpIHsKCQkJCURSTV9FUlJPUigicmFkZW9uX2VtaXRfc2NhbGFyczIgZmFpbGVkXG4iKTsKCQkJCWdvdG8gZXJyOwoJCQl9CgkJCWJyZWFrOwoKCQljYXNlIFJBREVPTl9DTURfV0FJVDoKCQkJRFJNX0RFQlVHKCJSQURFT05fQ01EX1dBSVRcbiIpOwoJCQlpZiAocmFkZW9uX2VtaXRfd2FpdCggZGV2LCBoZWFkZXIud2FpdC5mbGFncyApKSB7CgkJCQlEUk1fRVJST1IoInJhZGVvbl9lbWl0X3dhaXQgZmFpbGVkXG4iKTsKCQkJCWdvdG8gZXJyOwoJCQl9CgkJCWJyZWFrOwoJCWRlZmF1bHQ6CgkJCURSTV9FUlJPUigiYmFkIGNtZF90eXBlICVkIGF0ICVwXG4iLCAKCQkJCSAgaGVhZGVyLmhlYWRlci5jbWRfdHlwZSwKCQkJCSAgY21kYnVmLmJ1ZiAtIHNpemVvZihoZWFkZXIpKTsKCQkJZ290byBlcnI7CgkJfQoJfQoKCWlmIChvcmlnX2J1ZnN6ICE9IDApCgkJZHJtX2ZyZWUoa2J1Ziwgb3JpZ19idWZzeiwgRFJNX01FTV9EUklWRVIpOwoKCURSTV9ERUJVRygiRE9ORVxuIik7CglDT01NSVRfUklORygpOwoJcmV0dXJuIDA7CgplcnI6CglpZiAob3JpZ19idWZzeiAhPSAwKQoJCWRybV9mcmVlKGtidWYsIG9yaWdfYnVmc3osIERSTV9NRU1fRFJJVkVSKTsKCXJldHVybiBEUk1fRVJSKEVJTlZBTCk7Cn0KCgoKc3RhdGljIGludCByYWRlb25fY3BfZ2V0cGFyYW0oIERSTV9JT0NUTF9BUkdTICkKewoJRFJNX0RFVklDRTsKCWRybV9yYWRlb25fcHJpdmF0ZV90ICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7Cglkcm1fcmFkZW9uX2dldHBhcmFtX3QgcGFyYW07CglpbnQgdmFsdWU7CgoJaWYgKCAhZGV2X3ByaXYgKSB7CgkJRFJNX0VSUk9SKCAiJXMgY2FsbGVkIHdpdGggbm8gaW5pdGlhbGl6YXRpb25cbiIsIF9fRlVOQ1RJT05fXyApOwoJCXJldHVybiBEUk1fRVJSKEVJTlZBTCk7Cgl9CgoJRFJNX0NPUFlfRlJPTV9VU0VSX0lPQ1RMKCBwYXJhbSwgKGRybV9yYWRlb25fZ2V0cGFyYW1fdCBfX3VzZXIgKilkYXRhLAoJCQkgICAgIHNpemVvZihwYXJhbSkgKTsKCglEUk1fREVCVUcoICJwaWQ9JWRcbiIsIERSTV9DVVJSRU5UUElEICk7CgoJc3dpdGNoKCBwYXJhbS5wYXJhbSApIHsKCWNhc2UgUkFERU9OX1BBUkFNX0dBUlRfQlVGRkVSX09GRlNFVDoKCQl2YWx1ZSA9IGRldl9wcml2LT5nYXJ0X2J1ZmZlcnNfb2Zmc2V0OwoJCWJyZWFrOwoJY2FzZSBSQURFT05fUEFSQU1fTEFTVF9GUkFNRToKCQlkZXZfcHJpdi0+c3RhdHMubGFzdF9mcmFtZV9yZWFkcysrOwoJCXZhbHVlID0gR0VUX1NDUkFUQ0goIDAgKTsKCQlicmVhazsKCWNhc2UgUkFERU9OX1BBUkFNX0xBU1RfRElTUEFUQ0g6CgkJdmFsdWUgPSBHRVRfU0NSQVRDSCggMSApOwoJCWJyZWFrOwoJY2FzZSBSQURFT05fUEFSQU1fTEFTVF9DTEVBUjoKCQlkZXZfcHJpdi0+c3RhdHMubGFzdF9jbGVhcl9yZWFkcysrOwoJCXZhbHVlID0gR0VUX1NDUkFUQ0goIDIgKTsKCQlicmVhazsKCWNhc2UgUkFERU9OX1BBUkFNX0lSUV9OUjoKCQl2YWx1ZSA9IGRldi0+aXJxOwoJCWJyZWFrOwoJY2FzZSBSQURFT05fUEFSQU1fR0FSVF9CQVNFOgoJCXZhbHVlID0gZGV2X3ByaXYtPmdhcnRfdm1fc3RhcnQ7CgkJYnJlYWs7CgljYXNlIFJBREVPTl9QQVJBTV9SRUdJU1RFUl9IQU5ETEU6CgkJdmFsdWUgPSBkZXZfcHJpdi0+bW1pb19vZmZzZXQ7CgkJYnJlYWs7CgljYXNlIFJBREVPTl9QQVJBTV9TVEFUVVNfSEFORExFOgoJCXZhbHVlID0gZGV2X3ByaXYtPnJpbmdfcnB0cl9vZmZzZXQ7CgkJYnJlYWs7CiNpZiBCSVRTX1BFUl9MT05HID09IDMyCgkvKgoJICogVGhpcyBpb2N0bCgpIGRvZXNuJ3Qgd29yayBvbiA2NC1iaXQgcGxhdGZvcm1zIGJlY2F1c2UgaHdfbG9jayBpcyBhCgkgKiBwb2ludGVyIHdoaWNoIGNhbid0IGZpdCBpbnRvIGFuIGludC1zaXplZCB2YXJpYWJsZS4gIEFjY29yZGluZyB0bwoJICogTWljaGVsIETkbnplciwgdGhlIGlvY3RsKCkgaXMgb25seSB1c2VkIG9uIGVtYmVkZGVkIHBsYXRmb3Jtcywgc28KCSAqIG5vdCBzdXBwb3J0aW5nIGl0IHNob3VsZG4ndCBiZSBhIHByb2JsZW0uICBJZiB0aGUgc2FtZSBmdW5jdGlvbmFsaXR5CgkgKiBpcyBuZWVkZWQgb24gNjQtYml0IHBsYXRmb3JtcywgYSBuZXcgaW9jdGwoKSB3b3VsZCBoYXZlIHRvIGJlIGFkZGVkLAoJICogc28gYmFja3dhcmRzLWNvbXBhdGliaWxpdHkgZm9yIHRoZSBlbWJlZGRlZCBwbGF0Zm9ybXMgY2FuIGJlCgkgKiBtYWludGFpbmVkLiAgLS1kYXZpZG0gNC1GZWItMjAwNC4KCSAqLwoJY2FzZSBSQURFT05fUEFSQU1fU0FSRUFfSEFORExFOgoJCS8qIFRoZSBsb2NrIGlzIHRoZSBmaXJzdCBkd29yZCBpbiB0aGUgc2FyZWEuICovCgkJdmFsdWUgPSAobG9uZylkZXYtPmxvY2suaHdfbG9jazsKCQlicmVhazsKI2VuZGlmCgljYXNlIFJBREVPTl9QQVJBTV9HQVJUX1RFWF9IQU5ETEU6CgkJdmFsdWUgPSBkZXZfcHJpdi0+Z2FydF90ZXh0dXJlc19vZmZzZXQ7CgkJYnJlYWs7CglkZWZhdWx0OgoJCXJldHVybiBEUk1fRVJSKEVJTlZBTCk7Cgl9CgoJaWYgKCBEUk1fQ09QWV9UT19VU0VSKCBwYXJhbS52YWx1ZSwgJnZhbHVlLCBzaXplb2YoaW50KSApICkgewoJCURSTV9FUlJPUiggImNvcHlfdG9fdXNlclxuIiApOwoJCXJldHVybiBEUk1fRVJSKEVGQVVMVCk7Cgl9CgkKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IHJhZGVvbl9jcF9zZXRwYXJhbSggRFJNX0lPQ1RMX0FSR1MgKSB7CglEUk1fREVWSUNFOwoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCWRybV9maWxlX3QgKmZpbHBfcHJpdjsKCWRybV9yYWRlb25fc2V0cGFyYW1fdCBzcDsKCXN0cnVjdCBkcm1fcmFkZW9uX2RyaXZlcl9maWxlX2ZpZWxkcyAqcmFkZW9uX3ByaXY7CgoJaWYgKCAhZGV2X3ByaXYgKSB7CgkJRFJNX0VSUk9SKCAiJXMgY2FsbGVkIHdpdGggbm8gaW5pdGlhbGl6YXRpb25cbiIsIF9fRlVOQ1RJT05fXyApOwoJCXJldHVybiBEUk1fRVJSKCBFSU5WQUwgKTsKCX0KCglEUk1fR0VUX1BSSVZfV0lUSF9SRVRVUk4oIGZpbHBfcHJpdiwgZmlscCApOwoKCURSTV9DT1BZX0ZST01fVVNFUl9JT0NUTCggc3AsICggZHJtX3JhZGVvbl9zZXRwYXJhbV90IF9fdXNlciAqIClkYXRhLAoJCQkJICBzaXplb2YoIHNwICkgKTsKCglzd2l0Y2goIHNwLnBhcmFtICkgewoJY2FzZSBSQURFT05fU0VUUEFSQU1fRkJfTE9DQVRJT046CgkJcmFkZW9uX3ByaXYgPSBmaWxwX3ByaXYtPmRyaXZlcl9wcml2OwoJCXJhZGVvbl9wcml2LT5yYWRlb25fZmJfZGVsdGEgPSBkZXZfcHJpdi0+ZmJfbG9jYXRpb24gLSBzcC52YWx1ZTsKCQlicmVhazsKCWNhc2UgUkFERU9OX1NFVFBBUkFNX1NXSVRDSF9USUxJTkc6CgkJaWYgKHNwLnZhbHVlID09IDApIHsKCQkJRFJNX0RFQlVHKCAiY29sb3IgdGlsaW5nIGRpc2FibGVkXG4iICk7CgkJCWRldl9wcml2LT5mcm9udF9waXRjaF9vZmZzZXQgJj0gflJBREVPTl9EU1RfVElMRV9NQUNSTzsKCQkJZGV2X3ByaXYtPmJhY2tfcGl0Y2hfb2Zmc2V0ICY9IH5SQURFT05fRFNUX1RJTEVfTUFDUk87CgkJCWRldl9wcml2LT5zYXJlYV9wcml2LT50aWxpbmdfZW5hYmxlZCA9IDA7CgkJfQoJCWVsc2UgaWYgKHNwLnZhbHVlID09IDEpIHsKCQkJRFJNX0RFQlVHKCAiY29sb3IgdGlsaW5nIGVuYWJsZWRcbiIgKTsKCQkJZGV2X3ByaXYtPmZyb250X3BpdGNoX29mZnNldCB8PSBSQURFT05fRFNUX1RJTEVfTUFDUk87CgkJCWRldl9wcml2LT5iYWNrX3BpdGNoX29mZnNldCB8PSBSQURFT05fRFNUX1RJTEVfTUFDUk87CgkJCWRldl9wcml2LT5zYXJlYV9wcml2LT50aWxpbmdfZW5hYmxlZCA9IDE7CgkJfQoJCWJyZWFrOwkKCWRlZmF1bHQ6CgkJRFJNX0RFQlVHKCAiSW52YWxpZCBwYXJhbWV0ZXIgJWRcbiIsIHNwLnBhcmFtICk7CgkJcmV0dXJuIERSTV9FUlIoIEVJTlZBTCApOwoJfQoKCXJldHVybiAwOwp9CgovKiBXaGVuIGEgY2xpZW50IGRpZXM6CiAqICAgIC0gQ2hlY2sgZm9yIGFuZCBjbGVhbiB1cCBmbGlwcGVkIHBhZ2Ugc3RhdGUKICogICAgLSBGcmVlIGFueSBhbGxvY2VkIEdBUlQgbWVtb3J5LgogKgogKiBEUk0gaW5mcmFzdHJ1Y3R1cmUgdGFrZXMgY2FyZSBvZiByZWNsYWltaW5nIGRtYSBidWZmZXJzLgogKi8Kdm9pZCByYWRlb25fZHJpdmVyX3ByZXJlbGVhc2UoZHJtX2RldmljZV90ICpkZXYsIERSTUZJTEUgZmlscCkKewoJaWYgKCBkZXYtPmRldl9wcml2YXRlICkgewkJCQkKCQlkcm1fcmFkZW9uX3ByaXZhdGVfdCAqZGV2X3ByaXYgPSBkZXYtPmRldl9wcml2YXRlOyAKCQlpZiAoIGRldl9wcml2LT5wYWdlX2ZsaXBwaW5nICkgewkJCgkJCXJhZGVvbl9kb19jbGVhbnVwX3BhZ2VmbGlwKCBkZXYgKTsJCgkJfQkJCQkJCQoJCXJhZGVvbl9tZW1fcmVsZWFzZSggZmlscCwgZGV2X3ByaXYtPmdhcnRfaGVhcCApOyAKCQlyYWRlb25fbWVtX3JlbGVhc2UoIGZpbHAsIGRldl9wcml2LT5mYl9oZWFwICk7CQoJCXJhZGVvbl9zdXJmYWNlc19yZWxlYXNlKGZpbHAsIGRldl9wcml2KTsKCX0JCQkJCn0KCnZvaWQgcmFkZW9uX2RyaXZlcl9wcmV0YWtlZG93bihkcm1fZGV2aWNlX3QgKmRldikKewoJcmFkZW9uX2RvX3JlbGVhc2UoZGV2KTsKfQoKaW50IHJhZGVvbl9kcml2ZXJfb3Blbl9oZWxwZXIoZHJtX2RldmljZV90ICpkZXYsIGRybV9maWxlX3QgKmZpbHBfcHJpdikKewoJZHJtX3JhZGVvbl9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKCXN0cnVjdCBkcm1fcmFkZW9uX2RyaXZlcl9maWxlX2ZpZWxkcyAqcmFkZW9uX3ByaXY7CgkKCXJhZGVvbl9wcml2ID0gKHN0cnVjdCBkcm1fcmFkZW9uX2RyaXZlcl9maWxlX2ZpZWxkcyAqKWRybV9hbGxvYyhzaXplb2YoKnJhZGVvbl9wcml2KSwgRFJNX01FTV9GSUxFUyk7CgkKCWlmICghcmFkZW9uX3ByaXYpCgkJcmV0dXJuIC1FTk9NRU07CgoJZmlscF9wcml2LT5kcml2ZXJfcHJpdiA9IHJhZGVvbl9wcml2OwoJaWYgKCBkZXZfcHJpdiApCgkJcmFkZW9uX3ByaXYtPnJhZGVvbl9mYl9kZWx0YSA9IGRldl9wcml2LT5mYl9sb2NhdGlvbjsKCWVsc2UKCQlyYWRlb25fcHJpdi0+cmFkZW9uX2ZiX2RlbHRhID0gMDsKCXJldHVybiAwOwp9CgoKdm9pZCByYWRlb25fZHJpdmVyX2ZyZWVfZmlscF9wcml2KGRybV9kZXZpY2VfdCAqZGV2LCBkcm1fZmlsZV90ICpmaWxwX3ByaXYpCnsKCSBzdHJ1Y3QgZHJtX3JhZGVvbl9kcml2ZXJfZmlsZV9maWVsZHMgKnJhZGVvbl9wcml2ID0gZmlscF9wcml2LT5kcml2ZXJfcHJpdjsKCSAKCSBkcm1fZnJlZShyYWRlb25fcHJpdiwgc2l6ZW9mKCpyYWRlb25fcHJpdiksIERSTV9NRU1fRklMRVMpOwp9Cgpkcm1faW9jdGxfZGVzY190IHJhZGVvbl9pb2N0bHNbXSA9IHsKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9DUF9JTklUKV0gICAgPSB7IHJhZGVvbl9jcF9pbml0LCAgICAgIDEsIDEgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9DUF9TVEFSVCldICAgPSB7IHJhZGVvbl9jcF9zdGFydCwgICAgIDEsIDEgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9DUF9TVE9QKV0gICAgPSB7IHJhZGVvbl9jcF9zdG9wLCAgICAgIDEsIDEgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9DUF9SRVNFVCldICAgPSB7IHJhZGVvbl9jcF9yZXNldCwgICAgIDEsIDEgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9DUF9JRExFKV0gICAgPSB7IHJhZGVvbl9jcF9pZGxlLCAgICAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9DUF9SRVNVTUUpXSAgPSB7IHJhZGVvbl9jcF9yZXN1bWUsICAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9SRVNFVCldICAgICAgPSB7IHJhZGVvbl9lbmdpbmVfcmVzZXQsIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9GVUxMU0NSRUVOKV0gPSB7IHJhZGVvbl9mdWxsc2NyZWVuLCAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9TV0FQKV0gICAgICAgPSB7IHJhZGVvbl9jcF9zd2FwLCAgICAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9DTEVBUildICAgICAgPSB7IHJhZGVvbl9jcF9jbGVhciwgICAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9WRVJURVgpXSAgICAgPSB7IHJhZGVvbl9jcF92ZXJ0ZXgsICAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9JTkRJQ0VTKV0gICAgPSB7IHJhZGVvbl9jcF9pbmRpY2VzLCAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9URVhUVVJFKV0gICAgPSB7IHJhZGVvbl9jcF90ZXh0dXJlLCAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9TVElQUExFKV0gICAgPSB7IHJhZGVvbl9jcF9zdGlwcGxlLCAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9JTkRJUkVDVCldICAgPSB7IHJhZGVvbl9jcF9pbmRpcmVjdCwgIDEsIDEgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9WRVJURVgyKV0gICAgPSB7IHJhZGVvbl9jcF92ZXJ0ZXgyLCAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9DTURCVUYpXSAgICAgPSB7IHJhZGVvbl9jcF9jbWRidWYsICAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9HRVRQQVJBTSldICAgPSB7IHJhZGVvbl9jcF9nZXRwYXJhbSwgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9GTElQKV0gICAgICAgPSB7IHJhZGVvbl9jcF9mbGlwLCAgICAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9BTExPQyldICAgICAgPSB7IHJhZGVvbl9tZW1fYWxsb2MsICAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9GUkVFKV0gICAgICAgPSB7IHJhZGVvbl9tZW1fZnJlZSwgICAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9JTklUX0hFQVApXSAgPSB7IHJhZGVvbl9tZW1faW5pdF9oZWFwLDEsIDEgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9JUlFfRU1JVCldICAgPSB7IHJhZGVvbl9pcnFfZW1pdCwgICAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9JUlFfV0FJVCldICAgPSB7IHJhZGVvbl9pcnFfd2FpdCwgICAgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9TRVRQQVJBTSldICAgPSB7IHJhZGVvbl9jcF9zZXRwYXJhbSwgIDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9TVVJGX0FMTE9DKV0gPSB7IHJhZGVvbl9zdXJmYWNlX2FsbG9jLDEsIDAgfSwKCVtEUk1fSU9DVExfTlIoRFJNX1JBREVPTl9TVVJGX0ZSRUUpXSAgPSB7IHJhZGVvbl9zdXJmYWNlX2ZyZWUsIDEsIDAgfQp9OwoKaW50IHJhZGVvbl9tYXhfaW9jdGwgPSBEUk1fQVJSQVlfU0laRShyYWRlb25faW9jdGxzKTsK