LyoKICogV1BBIFN1cHBsaWNhbnQgLyBDb250cm9sIGludGVyZmFjZSAoc2hhcmVkIGNvZGUgZm9yIGFsbCBiYWNrZW5kcykKICogQ29weXJpZ2h0IChjKSAyMDA0LTIwMTMsIEpvdW5pIE1hbGluZW4gPGpAdzEuZmk+CiAqCiAqIFRoaXMgc29mdHdhcmUgbWF5IGJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQlNEIGxpY2Vuc2UuCiAqIFNlZSBSRUFETUUgZm9yIG1vcmUgZGV0YWlscy4KICovCgojaW5jbHVkZSAidXRpbHMvaW5jbHVkZXMuaCIKCiNpbmNsdWRlICJ1dGlscy9jb21tb24uaCIKI2luY2x1ZGUgInV0aWxzL2Vsb29wLmgiCiNpbmNsdWRlICJjb21tb24vdmVyc2lvbi5oIgojaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfZGVmcy5oIgojaW5jbHVkZSAiY29tbW9uL2llZWU4MDJfMTFfY29tbW9uLmgiCiNpbmNsdWRlICJjb21tb24vd3BhX2N0cmwuaCIKI2luY2x1ZGUgImVhcF9wZWVyL2VhcC5oIgojaW5jbHVkZSAiZWFwb2xfc3VwcC9lYXBvbF9zdXBwX3NtLmgiCiNpbmNsdWRlICJyc25fc3VwcC93cGEuaCIKI2luY2x1ZGUgInJzbl9zdXBwL3ByZWF1dGguaCIKI2luY2x1ZGUgInJzbl9zdXBwL3Bta3NhX2NhY2hlLmgiCiNpbmNsdWRlICJsMl9wYWNrZXQvbDJfcGFja2V0LmgiCiNpbmNsdWRlICJ3cHMvd3BzLmgiCiNpbmNsdWRlICJjb25maWcuaCIKI2luY2x1ZGUgIndwYV9zdXBwbGljYW50X2kuaCIKI2luY2x1ZGUgImRyaXZlcl9pLmgiCiNpbmNsdWRlICJ3cHNfc3VwcGxpY2FudC5oIgojaW5jbHVkZSAiaWJzc19yc24uaCIKI2luY2x1ZGUgImFwLmgiCiNpbmNsdWRlICJwMnBfc3VwcGxpY2FudC5oIgojaW5jbHVkZSAicDJwL3AycC5oIgojaW5jbHVkZSAiaHMyMF9zdXBwbGljYW50LmgiCiNpbmNsdWRlICJ3aWZpX2Rpc3BsYXkuaCIKI2luY2x1ZGUgIm5vdGlmeS5oIgojaW5jbHVkZSAiYnNzLmgiCiNpbmNsdWRlICJzY2FuLmgiCiNpbmNsdWRlICJjdHJsX2lmYWNlLmgiCiNpbmNsdWRlICJpbnRlcndvcmtpbmcuaCIKI2luY2x1ZGUgImJsYWNrbGlzdC5oIgojaW5jbHVkZSAiYXV0b3NjYW4uaCIKI2luY2x1ZGUgIndubV9zdGEuaCIKCmV4dGVybiBzdHJ1Y3Qgd3BhX2RyaXZlcl9vcHMgKndwYV9kcml2ZXJzW107CgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2dsb2JhbF9pZmFjZV9saXN0KHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsCgkJCQkJICAgIGNoYXIgKmJ1ZiwgaW50IGxlbik7CnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfZ2xvYmFsX2lmYWNlX2ludGVyZmFjZXMoc3RydWN0IHdwYV9nbG9iYWwgKmdsb2JhbCwKCQkJCQkJICBjaGFyICpidWYsIGludCBsZW4pOwoKCnN0YXRpYyBpbnQgcG5vX3N0YXJ0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCnsKCWludCByZXQ7CglzaXplX3QgaSwgbnVtX3NzaWQ7CglzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CglzdHJ1Y3Qgd3BhX2RyaXZlcl9zY2FuX3BhcmFtcyBwYXJhbXM7CgoJaWYgKHdwYV9zLT5wbm8pCgkJcmV0dXJuIDA7CgoJaWYgKCh3cGFfcy0+d3BhX3N0YXRlID4gV1BBX1NDQU5OSU5HKSAmJgoJICAgICh3cGFfcy0+d3BhX3N0YXRlIDw9IFdQQV9DT01QTEVURUQpKSB7CgkJd3BhX3ByaW50ZihNU0dfRVJST1IsICJQTk86IEluIGFzc29jIHByb2Nlc3MiKTsKCQlyZXR1cm4gLUVBR0FJTjsKCX0KCglpZiAod3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfU0NBTk5JTkcpIHsKCQl3cGFfc3VwcGxpY2FudF9jYW5jZWxfc2NoZWRfc2Nhbih3cGFfcyk7CgkJd3BhX3N1cHBsaWNhbnRfY2FuY2VsX3NjYW4od3BhX3MpOwoJfQoKCW9zX21lbXNldCgmcGFyYW1zLCAwLCBzaXplb2YocGFyYW1zKSk7CgoJbnVtX3NzaWQgPSAwOwoJc3NpZCA9IHdwYV9zLT5jb25mLT5zc2lkOwoJd2hpbGUgKHNzaWQpIHsKCQlpZiAoIXdwYXNfbmV0d29ya19kaXNhYmxlZCh3cGFfcywgc3NpZCkpCgkJCW51bV9zc2lkKys7CgkJc3NpZCA9IHNzaWQtPm5leHQ7Cgl9CglpZiAobnVtX3NzaWQgPiBXUEFTX01BWF9TQ0FOX1NTSURTKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQTk86IFVzZSBvbmx5IHRoZSBmaXJzdCAldSBTU0lEcyBmcm9tICIKCQkJICAgIiV1IiwgV1BBU19NQVhfU0NBTl9TU0lEUywgKHVuc2lnbmVkIGludCkgbnVtX3NzaWQpOwoJCW51bV9zc2lkID0gV1BBU19NQVhfU0NBTl9TU0lEUzsKCX0KCglpZiAobnVtX3NzaWQgPT0gMCkgewoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUE5POiBObyBjb25maWd1cmVkIFNTSURzIik7CgkJcmV0dXJuIC0xOwoJfQoKCXBhcmFtcy5maWx0ZXJfc3NpZHMgPSBvc19tYWxsb2Moc2l6ZW9mKHN0cnVjdCB3cGFfZHJpdmVyX3NjYW5fZmlsdGVyKSAqCgkJCQkJbnVtX3NzaWQpOwoJaWYgKHBhcmFtcy5maWx0ZXJfc3NpZHMgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CglpID0gMDsKCXNzaWQgPSB3cGFfcy0+Y29uZi0+c3NpZDsKCXdoaWxlIChzc2lkKSB7CgkJaWYgKCF3cGFzX25ldHdvcmtfZGlzYWJsZWQod3BhX3MsIHNzaWQpKSB7CgkJCXBhcmFtcy5zc2lkc1tpXS5zc2lkID0gc3NpZC0+c3NpZDsKCQkJcGFyYW1zLnNzaWRzW2ldLnNzaWRfbGVuID0gc3NpZC0+c3NpZF9sZW47CgkJCXBhcmFtcy5udW1fc3NpZHMrKzsKCQkJb3NfbWVtY3B5KHBhcmFtcy5maWx0ZXJfc3NpZHNbaV0uc3NpZCwgc3NpZC0+c3NpZCwKCQkJCSAgc3NpZC0+c3NpZF9sZW4pOwoJCQlwYXJhbXMuZmlsdGVyX3NzaWRzW2ldLnNzaWRfbGVuID0gc3NpZC0+c3NpZF9sZW47CgkJCXBhcmFtcy5udW1fZmlsdGVyX3NzaWRzKys7CgkJCWkrKzsKCQkJaWYgKGkgPT0gbnVtX3NzaWQpCgkJCQlicmVhazsKCQl9CgkJc3NpZCA9IHNzaWQtPm5leHQ7Cgl9CgoJaWYgKHdwYV9zLT5jb25mLT5maWx0ZXJfcnNzaSkKCQlwYXJhbXMuZmlsdGVyX3Jzc2kgPSB3cGFfcy0+Y29uZi0+ZmlsdGVyX3Jzc2k7CgoJcmV0ID0gd3BhX2Rydl9zY2hlZF9zY2FuKHdwYV9zLCAmcGFyYW1zLCAxMCAqIDEwMDApOwoJb3NfZnJlZShwYXJhbXMuZmlsdGVyX3NzaWRzKTsKCWlmIChyZXQgPT0gMCkKCQl3cGFfcy0+cG5vID0gMTsKCXJldHVybiByZXQ7Cn0KCgpzdGF0aWMgaW50IHBub19zdG9wKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCnsKCWludCByZXQgPSAwOwoKCWlmICh3cGFfcy0+cG5vKSB7CgkJd3BhX3MtPnBubyA9IDA7CgkJcmV0ID0gd3BhX2Rydl9zdG9wX3NjaGVkX3NjYW4od3BhX3MpOwoJfQoKCWlmICh3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9TQ0FOTklORykKCQl3cGFfc3VwcGxpY2FudF9yZXFfc2Nhbih3cGFfcywgMCwgMCk7CgoJcmV0dXJuIHJldDsKfQoKCnN0YXRpYyBpbnQgc2V0X2Jzc2lkX2ZpbHRlcihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICp2YWwpCnsKCWNoYXIgKnBvczsKCXU4IGFkZHJbRVRIX0FMRU5dLCAqZmlsdGVyID0gTlVMTCwgKm47CglzaXplX3QgY291bnQgPSAwOwoKCXBvcyA9IHZhbDsKCXdoaWxlIChwb3MpIHsKCQlpZiAoKnBvcyA9PSAnXDAnKQoJCQlicmVhazsKCQlpZiAoaHdhZGRyX2F0b24ocG9zLCBhZGRyKSkgewoJCQlvc19mcmVlKGZpbHRlcik7CgkJCXJldHVybiAtMTsKCQl9CgkJbiA9IG9zX3JlYWxsb2NfYXJyYXkoZmlsdGVyLCBjb3VudCArIDEsIEVUSF9BTEVOKTsKCQlpZiAobiA9PSBOVUxMKSB7CgkJCW9zX2ZyZWUoZmlsdGVyKTsKCQkJcmV0dXJuIC0xOwoJCX0KCQlmaWx0ZXIgPSBuOwoJCW9zX21lbWNweShmaWx0ZXIgKyBjb3VudCAqIEVUSF9BTEVOLCBhZGRyLCBFVEhfQUxFTik7CgkJY291bnQrKzsKCgkJcG9zID0gb3Nfc3RyY2hyKHBvcywgJyAnKTsKCQlpZiAocG9zKQoJCQlwb3MrKzsKCX0KCgl3cGFfaGV4ZHVtcChNU0dfREVCVUcsICJic3NpZF9maWx0ZXIiLCBmaWx0ZXIsIGNvdW50ICogRVRIX0FMRU4pOwoJb3NfZnJlZSh3cGFfcy0+YnNzaWRfZmlsdGVyKTsKCXdwYV9zLT5ic3NpZF9maWx0ZXIgPSBmaWx0ZXI7Cgl3cGFfcy0+YnNzaWRfZmlsdGVyX2NvdW50ID0gY291bnQ7CgoJcmV0dXJuIDA7Cn0KCgpzdGF0aWMgaW50IHNldF9kaXNhbGxvd19hcHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqdmFsKQp7CgljaGFyICpwb3M7Cgl1OCBhZGRyW0VUSF9BTEVOXSwgKmJzc2lkID0gTlVMTCwgKm47CglzdHJ1Y3Qgd3BhX3NzaWRfdmFsdWUgKnNzaWQgPSBOVUxMLCAqbnM7CglzaXplX3QgY291bnQgPSAwLCBzc2lkX2NvdW50ID0gMDsKCXN0cnVjdCB3cGFfc3NpZCAqYzsKCgkvKgoJICogZGlzYWxsb3dfbGlzdCA6Oj0gPHNzaWRfc3BlYz4gfCA8YnNzaWRfc3BlYz4gfCA8ZGlzYWxsb3dfbGlzdD4gfCCTlAoJICogU1NJRF9TUEVDIDo6PSBzc2lkIDxTU0lEX0hFWD4KCSAqIEJTU0lEX1NQRUMgOjo9IGJzc2lkIDxCU1NJRF9IRVg+CgkgKi8KCglwb3MgPSB2YWw7Cgl3aGlsZSAocG9zKSB7CgkJaWYgKCpwb3MgPT0gJ1wwJykKCQkJYnJlYWs7CgkJaWYgKG9zX3N0cm5jbXAocG9zLCAiYnNzaWQgIiwgNikgPT0gMCkgewoJCQlpbnQgcmVzOwoJCQlwb3MgKz0gNjsKCQkJcmVzID0gaHdhZGRyX2F0b24yKHBvcywgYWRkcik7CgkJCWlmIChyZXMgPCAwKSB7CgkJCQlvc19mcmVlKHNzaWQpOwoJCQkJb3NfZnJlZShic3NpZCk7CgkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludmFsaWQgZGlzYWxsb3dfYXBzICIKCQkJCQkgICAiQlNTSUQgdmFsdWUgJyVzJyIsIHBvcyk7CgkJCQlyZXR1cm4gLTE7CgkJCX0KCQkJcG9zICs9IHJlczsKCQkJbiA9IG9zX3JlYWxsb2NfYXJyYXkoYnNzaWQsIGNvdW50ICsgMSwgRVRIX0FMRU4pOwoJCQlpZiAobiA9PSBOVUxMKSB7CgkJCQlvc19mcmVlKHNzaWQpOwoJCQkJb3NfZnJlZShic3NpZCk7CgkJCQlyZXR1cm4gLTE7CgkJCX0KCQkJYnNzaWQgPSBuOwoJCQlvc19tZW1jcHkoYnNzaWQgKyBjb3VudCAqIEVUSF9BTEVOLCBhZGRyLCBFVEhfQUxFTik7CgkJCWNvdW50Kys7CgkJfSBlbHNlIGlmIChvc19zdHJuY21wKHBvcywgInNzaWQgIiwgNSkgPT0gMCkgewoJCQljaGFyICplbmQ7CgkJCXBvcyArPSA1OwoKCQkJZW5kID0gcG9zOwoJCQl3aGlsZSAoKmVuZCkgewoJCQkJaWYgKCplbmQgPT0gJ1wwJyB8fCAqZW5kID09ICcgJykKCQkJCQlicmVhazsKCQkJCWVuZCsrOwoJCQl9CgoJCQlucyA9IG9zX3JlYWxsb2NfYXJyYXkoc3NpZCwgc3NpZF9jb3VudCArIDEsCgkJCQkJICAgICAgc2l6ZW9mKHN0cnVjdCB3cGFfc3NpZF92YWx1ZSkpOwoJCQlpZiAobnMgPT0gTlVMTCkgewoJCQkJb3NfZnJlZShzc2lkKTsKCQkJCW9zX2ZyZWUoYnNzaWQpOwoJCQkJcmV0dXJuIC0xOwoJCQl9CgkJCXNzaWQgPSBuczsKCgkJCWlmICgoZW5kIC0gcG9zKSAmIDB4MDEgfHwgZW5kIC0gcG9zID4gMiAqIDMyIHx8CgkJCSAgICBoZXhzdHIyYmluKHBvcywgc3NpZFtzc2lkX2NvdW50XS5zc2lkLAoJCQkJICAgICAgIChlbmQgLSBwb3MpIC8gMikgPCAwKSB7CgkJCQlvc19mcmVlKHNzaWQpOwoJCQkJb3NfZnJlZShic3NpZCk7CgkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludmFsaWQgZGlzYWxsb3dfYXBzICIKCQkJCQkgICAiU1NJRCB2YWx1ZSAnJXMnIiwgcG9zKTsKCQkJCXJldHVybiAtMTsKCQkJfQoJCQlzc2lkW3NzaWRfY291bnRdLnNzaWRfbGVuID0gKGVuZCAtIHBvcykgLyAyOwoJCQl3cGFfaGV4ZHVtcF9hc2NpaShNU0dfREVCVUcsICJkaXNhbGxvd19hcHMgU1NJRCIsCgkJCQkJICBzc2lkW3NzaWRfY291bnRdLnNzaWQsCgkJCQkJICBzc2lkW3NzaWRfY291bnRdLnNzaWRfbGVuKTsKCQkJc3NpZF9jb3VudCsrOwoJCQlwb3MgPSBlbmQ7CgkJfSBlbHNlIHsKCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJVbmV4cGVjdGVkIGRpc2FsbG93X2FwcyB2YWx1ZSAiCgkJCQkgICAiJyVzJyIsIHBvcyk7CgkJCW9zX2ZyZWUoc3NpZCk7CgkJCW9zX2ZyZWUoYnNzaWQpOwoJCQlyZXR1cm4gLTE7CgkJfQoKCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnICcpOwoJCWlmIChwb3MpCgkJCXBvcysrOwoJfQoKCXdwYV9oZXhkdW1wKE1TR19ERUJVRywgImRpc2FsbG93X2Fwc19ic3NpZCIsIGJzc2lkLCBjb3VudCAqIEVUSF9BTEVOKTsKCW9zX2ZyZWUod3BhX3MtPmRpc2FsbG93X2Fwc19ic3NpZCk7Cgl3cGFfcy0+ZGlzYWxsb3dfYXBzX2Jzc2lkID0gYnNzaWQ7Cgl3cGFfcy0+ZGlzYWxsb3dfYXBzX2Jzc2lkX2NvdW50ID0gY291bnQ7CgoJd3BhX3ByaW50ZihNU0dfREVCVUcsICJkaXNhbGxvd19hcHNfc3NpZF9jb3VudCAlZCIsIChpbnQpIHNzaWRfY291bnQpOwoJb3NfZnJlZSh3cGFfcy0+ZGlzYWxsb3dfYXBzX3NzaWQpOwoJd3BhX3MtPmRpc2FsbG93X2Fwc19zc2lkID0gc3NpZDsKCXdwYV9zLT5kaXNhbGxvd19hcHNfc3NpZF9jb3VudCA9IHNzaWRfY291bnQ7CgoJaWYgKCF3cGFfcy0+Y3VycmVudF9zc2lkIHx8IHdwYV9zLT53cGFfc3RhdGUgPCBXUEFfQVVUSEVOVElDQVRJTkcpCgkJcmV0dXJuIDA7CgoJYyA9IHdwYV9zLT5jdXJyZW50X3NzaWQ7CglpZiAoYy0+bW9kZSAhPSBXUEFTX01PREVfSU5GUkEgJiYgYy0+bW9kZSAhPSBXUEFTX01PREVfSUJTUykKCQlyZXR1cm4gMDsKCglpZiAoIWRpc2FsbG93ZWRfYnNzaWQod3BhX3MsIHdwYV9zLT5ic3NpZCkgJiYKCSAgICAhZGlzYWxsb3dlZF9zc2lkKHdwYV9zLCBjLT5zc2lkLCBjLT5zc2lkX2xlbikpCgkJcmV0dXJuIDA7CgoJd3BhX3ByaW50ZihNU0dfREVCVUcsICJEaXNjb25uZWN0IGFuZCB0cnkgdG8gZmluZCBhbm90aGVyIG5ldHdvcmsgIgoJCSAgICJiZWNhdXNlIGN1cnJlbnQgQVAgd2FzIG1hcmtlZCBkaXNhbGxvd2VkIik7CgojaWZkZWYgQ09ORklHX1NNRQoJd3BhX3MtPnNtZS5wcmV2X2Jzc2lkX3NldCA9IDA7CiNlbmRpZiAvKiBDT05GSUdfU01FICovCgl3cGFfcy0+cmVhc3NvY2lhdGUgPSAxOwoJd3BhX3N1cHBsaWNhbnRfZGVhdXRoZW50aWNhdGUod3BhX3MsIFdMQU5fUkVBU09OX0RFQVVUSF9MRUFWSU5HKTsKCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAwLCAwKTsKCglyZXR1cm4gMDsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9zZXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKCQkJCQkgY2hhciAqY21kKQp7CgljaGFyICp2YWx1ZTsKCWludCByZXQgPSAwOwoKCXZhbHVlID0gb3Nfc3RyY2hyKGNtZCwgJyAnKTsKCWlmICh2YWx1ZSA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSp2YWx1ZSsrID0gJ1wwJzsKCgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgU0VUICclcyc9JyVzJyIsIGNtZCwgdmFsdWUpOwoJaWYgKG9zX3N0cmNhc2VjbXAoY21kLCAiRUFQT0w6OmhlbGRQZXJpb2QiKSA9PSAwKSB7CgkJZWFwb2xfc21fY29uZmlndXJlKHdwYV9zLT5lYXBvbCwKCQkJCSAgIGF0b2kodmFsdWUpLCAtMSwgLTEsIC0xKTsKCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChjbWQsICJFQVBPTDo6YXV0aFBlcmlvZCIpID09IDApIHsKCQllYXBvbF9zbV9jb25maWd1cmUod3BhX3MtPmVhcG9sLAoJCQkJICAgLTEsIGF0b2kodmFsdWUpLCAtMSwgLTEpOwoJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgIkVBUE9MOjpzdGFydFBlcmlvZCIpID09IDApIHsKCQllYXBvbF9zbV9jb25maWd1cmUod3BhX3MtPmVhcG9sLAoJCQkJICAgLTEsIC0xLCBhdG9pKHZhbHVlKSwgLTEpOwoJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgIkVBUE9MOjptYXhTdGFydCIpID09IDApIHsKCQllYXBvbF9zbV9jb25maWd1cmUod3BhX3MtPmVhcG9sLAoJCQkJICAgLTEsIC0xLCAtMSwgYXRvaSh2YWx1ZSkpOwoJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgImRvdDExUlNOQUNvbmZpZ1BNS0xpZmV0aW1lIikgPT0gMCkgewoJCWlmICh3cGFfc21fc2V0X3BhcmFtKHdwYV9zLT53cGEsIFJTTkFfUE1LX0xJRkVUSU1FLAoJCQkJICAgICBhdG9pKHZhbHVlKSkpCgkJCXJldCA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgImRvdDExUlNOQUNvbmZpZ1BNS1JlYXV0aFRocmVzaG9sZCIpID09CgkJICAgMCkgewoJCWlmICh3cGFfc21fc2V0X3BhcmFtKHdwYV9zLT53cGEsIFJTTkFfUE1LX1JFQVVUSF9USFJFU0hPTEQsCgkJCQkgICAgIGF0b2kodmFsdWUpKSkKCQkJcmV0ID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cmNhc2VjbXAoY21kLCAiZG90MTFSU05BQ29uZmlnU0FUaW1lb3V0IikgPT0gMCkgewoJCWlmICh3cGFfc21fc2V0X3BhcmFtKHdwYV9zLT53cGEsIFJTTkFfU0FfVElNRU9VVCwgYXRvaSh2YWx1ZSkpKQoJCQlyZXQgPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChjbWQsICJ3cHNfZnJhZ21lbnRfc2l6ZSIpID09IDApIHsKCQl3cGFfcy0+d3BzX2ZyYWdtZW50X3NpemUgPSBhdG9pKHZhbHVlKTsKI2lmZGVmIENPTkZJR19XUFNfVEVTVElORwoJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgIndwc192ZXJzaW9uX251bWJlciIpID09IDApIHsKCQlsb25nIGludCB2YWw7CgkJdmFsID0gc3RydG9sKHZhbHVlLCBOVUxMLCAwKTsKCQlpZiAodmFsIDwgMCB8fCB2YWwgPiAweGZmKSB7CgkJCXJldCA9IC0xOwoJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogSW52YWxpZCAiCgkJCQkgICAid3BzX3ZlcnNpb25fbnVtYmVyICVsZCIsIHZhbCk7CgkJfSBlbHNlIHsKCQkJd3BzX3ZlcnNpb25fbnVtYmVyID0gdmFsOwoJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogVGVzdGluZyAtIGZvcmNlIFdQUyAiCgkJCQkgICAidmVyc2lvbiAldS4ldSIsCgkJCQkgICAod3BzX3ZlcnNpb25fbnVtYmVyICYgMHhmMCkgPj4gNCwKCQkJCSAgIHdwc192ZXJzaW9uX251bWJlciAmIDB4MGYpOwoJCX0KCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChjbWQsICJ3cHNfdGVzdGluZ19kdW1teV9jcmVkIikgPT0gMCkgewoJCXdwc190ZXN0aW5nX2R1bW15X2NyZWQgPSBhdG9pKHZhbHVlKTsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogVGVzdGluZyAtIGR1bW15X2NyZWQ9JWQiLAoJCQkgICB3cHNfdGVzdGluZ19kdW1teV9jcmVkKTsKI2VuZGlmIC8qIENPTkZJR19XUFNfVEVTVElORyAqLwoJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgImFtcGR1IikgPT0gMCkgewoJCWlmICh3cGFfZHJ2X2FtcGR1KHdwYV9zLCBhdG9pKHZhbHVlKSkgPCAwKQoJCQlyZXQgPSAtMTsKI2lmZGVmIENPTkZJR19URExTX1RFU1RJTkcKCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChjbWQsICJ0ZGxzX3Rlc3RpbmciKSA9PSAwKSB7CgkJZXh0ZXJuIHVuc2lnbmVkIGludCB0ZGxzX3Rlc3Rpbmc7CgkJdGRsc190ZXN0aW5nID0gc3RydG9sKHZhbHVlLCBOVUxMLCAwKTsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRETFM6IHRkbHNfdGVzdGluZz0weCV4IiwgdGRsc190ZXN0aW5nKTsKI2VuZGlmIC8qIENPTkZJR19URExTX1RFU1RJTkcgKi8KI2lmZGVmIENPTkZJR19URExTCgl9IGVsc2UgaWYgKG9zX3N0cmNhc2VjbXAoY21kLCAidGRsc19kaXNhYmxlZCIpID09IDApIHsKCQlpbnQgZGlzYWJsZWQgPSBhdG9pKHZhbHVlKTsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlRETFM6IHRkbHNfZGlzYWJsZWQ9JWQiLCBkaXNhYmxlZCk7CgkJaWYgKGRpc2FibGVkKSB7CgkJCWlmICh3cGFfZHJ2X3RkbHNfb3Blcih3cGFfcywgVERMU19ESVNBQkxFLCBOVUxMKSA8IDApCgkJCQlyZXQgPSAtMTsKCQl9IGVsc2UgaWYgKHdwYV9kcnZfdGRsc19vcGVyKHdwYV9zLCBURExTX0VOQUJMRSwgTlVMTCkgPCAwKQoJCQlyZXQgPSAtMTsKCQl3cGFfdGRsc19lbmFibGUod3BhX3MtPndwYSwgIWRpc2FibGVkKTsKI2VuZGlmIC8qIENPTkZJR19URExTICovCgl9IGVsc2UgaWYgKG9zX3N0cmNhc2VjbXAoY21kLCAicG5vIikgPT0gMCkgewoJCWlmIChhdG9pKHZhbHVlKSkKCQkJcmV0ID0gcG5vX3N0YXJ0KHdwYV9zKTsKCQllbHNlCgkJCXJldCA9IHBub19zdG9wKHdwYV9zKTsKCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChjbWQsICJyYWRpb19kaXNhYmxlZCIpID09IDApIHsKCQlpbnQgZGlzYWJsZWQgPSBhdG9pKHZhbHVlKTsKCQlpZiAod3BhX2Rydl9yYWRpb19kaXNhYmxlKHdwYV9zLCBkaXNhYmxlZCkgPCAwKQoJCQlyZXQgPSAtMTsKCQllbHNlIGlmIChkaXNhYmxlZCkKCQkJd3BhX3N1cHBsaWNhbnRfc2V0X3N0YXRlKHdwYV9zLCBXUEFfSU5BQ1RJVkUpOwoJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgInVhcHNkIikgPT0gMCkgewoJCWlmIChvc19zdHJjbXAodmFsdWUsICJkaXNhYmxlIikgPT0gMCkKCQkJd3BhX3MtPnNldF9zdGFfdWFwc2QgPSAwOwoJCWVsc2UgewoJCQlpbnQgYmUsIGJrLCB2aSwgdm87CgkJCWNoYXIgKnBvczsKCQkJLyogZm9ybWF0OiBCRSxCSyxWSSxWTzttYXggU1AgTGVuZ3RoICovCgkJCWJlID0gYXRvaSh2YWx1ZSk7CgkJCXBvcyA9IG9zX3N0cmNocih2YWx1ZSwgJywnKTsKCQkJaWYgKHBvcyA9PSBOVUxMKQoJCQkJcmV0dXJuIC0xOwoJCQlwb3MrKzsKCQkJYmsgPSBhdG9pKHBvcyk7CgkJCXBvcyA9IG9zX3N0cmNocihwb3MsICcsJyk7CgkJCWlmIChwb3MgPT0gTlVMTCkKCQkJCXJldHVybiAtMTsKCQkJcG9zKys7CgkJCXZpID0gYXRvaShwb3MpOwoJCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnLCcpOwoJCQlpZiAocG9zID09IE5VTEwpCgkJCQlyZXR1cm4gLTE7CgkJCXBvcysrOwoJCQl2byA9IGF0b2kocG9zKTsKCQkJLyogaWdub3JlIG1heCBTUCBMZW5ndGggZm9yIG5vdyAqLwoKCQkJd3BhX3MtPnNldF9zdGFfdWFwc2QgPSAxOwoJCQl3cGFfcy0+c3RhX3VhcHNkID0gMDsKCQkJaWYgKGJlKQoJCQkJd3BhX3MtPnN0YV91YXBzZCB8PSBCSVQoMCk7CgkJCWlmIChiaykKCQkJCXdwYV9zLT5zdGFfdWFwc2QgfD0gQklUKDEpOwoJCQlpZiAodmkpCgkJCQl3cGFfcy0+c3RhX3VhcHNkIHw9IEJJVCgyKTsKCQkJaWYgKHZvKQoJCQkJd3BhX3MtPnN0YV91YXBzZCB8PSBCSVQoMyk7CgkJfQoJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgInBzIikgPT0gMCkgewoJCXJldCA9IHdwYV9kcnZfc2V0X3AycF9wb3dlcnNhdmUod3BhX3MsIGF0b2kodmFsdWUpLCAtMSwgLTEpOwojaWZkZWYgQ09ORklHX1dJRklfRElTUExBWQoJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgIndpZmlfZGlzcGxheSIpID09IDApIHsKCQl3aWZpX2Rpc3BsYXlfZW5hYmxlKHdwYV9zLT5nbG9iYWwsICEhYXRvaSh2YWx1ZSkpOwojZW5kaWYgLyogQ09ORklHX1dJRklfRElTUExBWSAqLwoJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgImJzc2lkX2ZpbHRlciIpID09IDApIHsKCQlyZXQgPSBzZXRfYnNzaWRfZmlsdGVyKHdwYV9zLCB2YWx1ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cmNhc2VjbXAoY21kLCAiZGlzYWxsb3dfYXBzIikgPT0gMCkgewoJCXJldCA9IHNldF9kaXNhbGxvd19hcHMod3BhX3MsIHZhbHVlKTsKCX0gZWxzZSBpZiAob3Nfc3RyY2FzZWNtcChjbWQsICJub19rZWVwX2FsaXZlIikgPT0gMCkgewoJCXdwYV9zLT5ub19rZWVwX2FsaXZlID0gISFhdG9pKHZhbHVlKTsKCX0gZWxzZSB7CgkJdmFsdWVbLTFdID0gJz0nOwoJCXJldCA9IHdwYV9jb25maWdfcHJvY2Vzc19nbG9iYWwod3BhX3MtPmNvbmYsIGNtZCwgLTEpOwoJCWlmIChyZXQgPT0gMCkKCQkJd3BhX3N1cHBsaWNhbnRfdXBkYXRlX2NvbmZpZyh3cGFfcyk7Cgl9CgoJcmV0dXJuIHJldDsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9nZXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKCQkJCQkgY2hhciAqY21kLCBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCnsKCWludCByZXMgPSAtMTsKCgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgR0VUICclcyciLCBjbWQpOwoKCWlmIChvc19zdHJjbXAoY21kLCAidmVyc2lvbiIpID09IDApIHsKCQlyZXMgPSBvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIiVzIiwgVkVSU0lPTl9TVFIpOwoJfSBlbHNlIGlmIChvc19zdHJjYXNlY21wKGNtZCwgImNvdW50cnkiKSA9PSAwKSB7CgkJaWYgKHdwYV9zLT5jb25mLT5jb3VudHJ5WzBdICYmIHdwYV9zLT5jb25mLT5jb3VudHJ5WzFdKQoJCQlyZXMgPSBvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIiVjJWMiLAoJCQkJCSAgd3BhX3MtPmNvbmYtPmNvdW50cnlbMF0sCgkJCQkJICB3cGFfcy0+Y29uZi0+Y291bnRyeVsxXSk7CiNpZmRlZiBDT05GSUdfV0lGSV9ESVNQTEFZCgl9IGVsc2UgaWYgKG9zX3N0cmNhc2VjbXAoY21kLCAid2lmaV9kaXNwbGF5IikgPT0gMCkgewoJCXJlcyA9IG9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLCAiJWQiLAoJCQkJICB3cGFfcy0+Z2xvYmFsLT53aWZpX2Rpc3BsYXkpOwoJCWlmIChyZXMgPCAwIHx8ICh1bnNpZ25lZCBpbnQpIHJlcyA+PSBidWZsZW4pCgkJCXJldHVybiAtMTsKCQlyZXR1cm4gcmVzOwojZW5kaWYgLyogQ09ORklHX1dJRklfRElTUExBWSAqLwojaWZkZWYgQ09ORklHX1RFU1RJTkdfR0VUX0dUSwoJfSBlbHNlIGlmIChvc19zdHJjbXAoY21kLCAiZ3RrIikgPT0gMCkgewoJCWlmICh3cGFfcy0+bGFzdF9ndGtfbGVuID09IDApCgkJCXJldHVybiAtMTsKCQlyZXMgPSB3cGFfc25wcmludGZfaGV4KGJ1ZiwgYnVmbGVuLCB3cGFfcy0+bGFzdF9ndGssCgkJCQkgICAgICAgd3BhX3MtPmxhc3RfZ3RrX2xlbik7CgkJcmV0dXJuIHJlczsKI2VuZGlmIC8qIENPTkZJR19URVNUSU5HX0dFVF9HVEsgKi8KCX0KCglpZiAocmVzIDwgMCB8fCAodW5zaWduZWQgaW50KSByZXMgPj0gYnVmbGVuKQoJCXJldHVybiAtMTsKCXJldHVybiByZXM7Cn0KCgojaWZkZWYgSUVFRTgwMjFYX0VBUE9MCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9wcmVhdXRoKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJICAgICBjaGFyICphZGRyKQp7Cgl1OCBic3NpZFtFVEhfQUxFTl07CglzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQgPSB3cGFfcy0+Y3VycmVudF9zc2lkOwoKCWlmIChod2FkZHJfYXRvbihhZGRyLCBic3NpZCkpIHsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgUFJFQVVUSDogaW52YWxpZCBhZGRyZXNzICIKCQkJICAgIiclcyciLCBhZGRyKTsKCQlyZXR1cm4gLTE7Cgl9CgoJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIFBSRUFVVEggIiBNQUNTVFIsIE1BQzJTVFIoYnNzaWQpKTsKCXJzbl9wcmVhdXRoX2RlaW5pdCh3cGFfcy0+d3BhKTsKCWlmIChyc25fcHJlYXV0aF9pbml0KHdwYV9zLT53cGEsIGJzc2lkLCBzc2lkID8gJnNzaWQtPmVhcCA6IE5VTEwpKQoJCXJldHVybiAtMTsKCglyZXR1cm4gMDsKfQojZW5kaWYgLyogSUVFRTgwMjFYX0VBUE9MICovCgoKI2lmZGVmIENPTkZJR19QRUVSS0VZCi8qIE1MTUUtU1RLU1RBUlQucmVxdWVzdChwZWVyKSAqLwpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc3Rrc3RhcnQoCglzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICphZGRyKQp7Cgl1OCBwZWVyW0VUSF9BTEVOXTsKCglpZiAoaHdhZGRyX2F0b24oYWRkciwgcGVlcikpIHsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgU1RLU1RBUlQ6IGludmFsaWQgIgoJCQkgICAiYWRkcmVzcyAnJXMnIiwgYWRkcik7CgkJcmV0dXJuIC0xOwoJfQoKCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRSBTVEtTVEFSVCAiIE1BQ1NUUiwKCQkgICBNQUMyU1RSKHBlZXIpKTsKCglyZXR1cm4gd3BhX3NtX3N0a3N0YXJ0KHdwYV9zLT53cGEsIHBlZXIpOwp9CiNlbmRpZiAvKiBDT05GSUdfUEVFUktFWSAqLwoKCiNpZmRlZiBDT05GSUdfVERMUwoKc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3RkbHNfZGlzY292ZXIoCglzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICphZGRyKQp7Cgl1OCBwZWVyW0VUSF9BTEVOXTsKCWludCByZXQ7CgoJaWYgKGh3YWRkcl9hdG9uKGFkZHIsIHBlZXIpKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIFRETFNfRElTQ09WRVI6IGludmFsaWQgIgoJCQkgICAiYWRkcmVzcyAnJXMnIiwgYWRkcik7CgkJcmV0dXJuIC0xOwoJfQoKCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRSBURExTX0RJU0NPVkVSICIgTUFDU1RSLAoJCSAgIE1BQzJTVFIocGVlcikpOwoKCWlmICh3cGFfdGRsc19pc19leHRlcm5hbF9zZXR1cCh3cGFfcy0+d3BhKSkKCQlyZXQgPSB3cGFfdGRsc19zZW5kX2Rpc2NvdmVyeV9yZXF1ZXN0KHdwYV9zLT53cGEsIHBlZXIpOwoJZWxzZQoJCXJldCA9IHdwYV9kcnZfdGRsc19vcGVyKHdwYV9zLCBURExTX0RJU0NPVkVSWV9SRVEsIHBlZXIpOwoKCXJldHVybiByZXQ7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfdGRsc19zZXR1cCgKCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmFkZHIpCnsKCXU4IHBlZXJbRVRIX0FMRU5dOwoJaW50IHJldDsKCglpZiAoaHdhZGRyX2F0b24oYWRkciwgcGVlcikpIHsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgVERMU19TRVRVUDogaW52YWxpZCAiCgkJCSAgICJhZGRyZXNzICclcyciLCBhZGRyKTsKCQlyZXR1cm4gLTE7Cgl9CgoJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIFRETFNfU0VUVVAgIiBNQUNTVFIsCgkJICAgTUFDMlNUUihwZWVyKSk7CgoJd3BhX3RkbHNfcmVtb3ZlKHdwYV9zLT53cGEsIHBlZXIpOwoKCWlmICh3cGFfdGRsc19pc19leHRlcm5hbF9zZXR1cCh3cGFfcy0+d3BhKSkKCQlyZXQgPSB3cGFfdGRsc19zdGFydCh3cGFfcy0+d3BhLCBwZWVyKTsKCWVsc2UKCQlyZXQgPSB3cGFfZHJ2X3RkbHNfb3Blcih3cGFfcywgVERMU19TRVRVUCwgcGVlcik7CgoJcmV0dXJuIHJldDsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV90ZGxzX3RlYXJkb3duKAoJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqYWRkcikKewoJdTggcGVlcltFVEhfQUxFTl07CglpbnQgcmV0OwoKCWlmIChod2FkZHJfYXRvbihhZGRyLCBwZWVyKSkgewoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRSBURExTX1RFQVJET1dOOiBpbnZhbGlkICIKCQkJICAgImFkZHJlc3MgJyVzJyIsIGFkZHIpOwoJCXJldHVybiAtMTsKCX0KCgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgVERMU19URUFSRE9XTiAiIE1BQ1NUUiwKCQkgICBNQUMyU1RSKHBlZXIpKTsKCglpZiAod3BhX3RkbHNfaXNfZXh0ZXJuYWxfc2V0dXAod3BhX3MtPndwYSkpCgkJcmV0ID0gd3BhX3RkbHNfdGVhcmRvd25fbGluaygKCQkJd3BhX3MtPndwYSwgcGVlciwKCQkJV0xBTl9SRUFTT05fVERMU19URUFSRE9XTl9VTlNQRUNJRklFRCk7CgllbHNlCgkJcmV0ID0gd3BhX2Rydl90ZGxzX29wZXIod3BhX3MsIFRETFNfVEVBUkRPV04sIHBlZXIpOwoKCXJldHVybiByZXQ7Cn0KCiNlbmRpZiAvKiBDT05GSUdfVERMUyAqLwoKCiNpZmRlZiBDT05GSUdfSUVFRTgwMjExUgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfZnRfZHMoCglzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICphZGRyKQp7Cgl1OCB0YXJnZXRfYXBbRVRIX0FMRU5dOwoJc3RydWN0IHdwYV9ic3MgKmJzczsKCWNvbnN0IHU4ICptZGllOwoKCWlmIChod2FkZHJfYXRvbihhZGRyLCB0YXJnZXRfYXApKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIEZUX0RTOiBpbnZhbGlkICIKCQkJICAgImFkZHJlc3MgJyVzJyIsIGFkZHIpOwoJCXJldHVybiAtMTsKCX0KCgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgRlRfRFMgIiBNQUNTVFIsIE1BQzJTVFIodGFyZ2V0X2FwKSk7CgoJYnNzID0gd3BhX2Jzc19nZXRfYnNzaWQod3BhX3MsIHRhcmdldF9hcCk7CglpZiAoYnNzKQoJCW1kaWUgPSB3cGFfYnNzX2dldF9pZShic3MsIFdMQU5fRUlEX01PQklMSVRZX0RPTUFJTik7CgllbHNlCgkJbWRpZSA9IE5VTEw7CgoJcmV0dXJuIHdwYV9mdF9zdGFydF9vdmVyX2RzKHdwYV9zLT53cGEsIHRhcmdldF9hcCwgbWRpZSk7Cn0KI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFSICovCgoKI2lmZGVmIENPTkZJR19XUFMKc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3dwc19wYmMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKCQkJCQkgICAgIGNoYXIgKmNtZCkKewoJdTggYnNzaWRbRVRIX0FMRU5dLCAqX2Jzc2lkID0gYnNzaWQ7CiNpZmRlZiBDT05GSUdfUDJQCgl1OCBwMnBfZGV2X2FkZHJbRVRIX0FMRU5dOwojZW5kaWYgLyogQ09ORklHX1AyUCAqLwojaWZkZWYgQ09ORklHX0FQCgl1OCAqX3AycF9kZXZfYWRkciA9IE5VTEw7CiNlbmRpZiAvKiBDT05GSUdfQVAgKi8KCglpZiAoY21kID09IE5VTEwgfHwgb3Nfc3RyY21wKGNtZCwgImFueSIpID09IDAgfHwgY21kWzBdID09ICdcMCcpIHsKCQlfYnNzaWQgPSBOVUxMOwojaWZkZWYgQ09ORklHX1AyUAoJfSBlbHNlIGlmIChvc19zdHJuY21wKGNtZCwgInAycF9kZXZfYWRkcj0iLCAxMykgPT0gMCkgewoJCWlmIChod2FkZHJfYXRvbihjbWQgKyAxMywgcDJwX2Rldl9hZGRyKSkgewoJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgV1BTX1BCQzogaW52YWxpZCAiCgkJCQkgICAiUDJQIERldmljZSBBZGRyZXNzICclcyciLAoJCQkJICAgY21kICsgMTMpOwoJCQlyZXR1cm4gLTE7CgkJfQoJCV9wMnBfZGV2X2FkZHIgPSBwMnBfZGV2X2FkZHI7CiNlbmRpZiAvKiBDT05GSUdfUDJQICovCgl9IGVsc2UgaWYgKGh3YWRkcl9hdG9uKGNtZCwgYnNzaWQpKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIFdQU19QQkM6IGludmFsaWQgQlNTSUQgJyVzJyIsCgkJCSAgIGNtZCk7CgkJcmV0dXJuIC0xOwoJfQoKI2lmZGVmIENPTkZJR19BUAoJaWYgKHdwYV9zLT5hcF9pZmFjZSkKCQlyZXR1cm4gd3BhX3N1cHBsaWNhbnRfYXBfd3BzX3BiYyh3cGFfcywgX2Jzc2lkLCBfcDJwX2Rldl9hZGRyKTsKI2VuZGlmIC8qIENPTkZJR19BUCAqLwoKCXJldHVybiB3cGFzX3dwc19zdGFydF9wYmMod3BhX3MsIF9ic3NpZCwgMCk7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX3BpbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAoJCQkJCSAgICAgY2hhciAqY21kLCBjaGFyICpidWYsCgkJCQkJICAgICBzaXplX3QgYnVmbGVuKQp7Cgl1OCBic3NpZFtFVEhfQUxFTl0sICpfYnNzaWQgPSBic3NpZDsKCWNoYXIgKnBpbjsKCWludCByZXQ7CgoJcGluID0gb3Nfc3RyY2hyKGNtZCwgJyAnKTsKCWlmIChwaW4pCgkJKnBpbisrID0gJ1wwJzsKCglpZiAob3Nfc3RyY21wKGNtZCwgImFueSIpID09IDApCgkJX2Jzc2lkID0gTlVMTDsKCWVsc2UgaWYgKG9zX3N0cmNtcChjbWQsICJnZXQiKSA9PSAwKSB7CgkJcmV0ID0gd3BzX2dlbmVyYXRlX3BpbigpOwoJCWdvdG8gZG9uZTsKCX0gZWxzZSBpZiAoaHdhZGRyX2F0b24oY21kLCBic3NpZCkpIHsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgV1BTX1BJTjogaW52YWxpZCBCU1NJRCAnJXMnIiwKCQkJICAgY21kKTsKCQlyZXR1cm4gLTE7Cgl9CgojaWZkZWYgQ09ORklHX0FQCglpZiAod3BhX3MtPmFwX2lmYWNlKSB7CgkJaW50IHRpbWVvdXQgPSAwOwoJCWNoYXIgKnBvczsKCgkJaWYgKHBpbikgewoJCQlwb3MgPSBvc19zdHJjaHIocGluLCAnICcpOwoJCQlpZiAocG9zKSB7CgkJCQkqcG9zKysgPSAnXDAnOwoJCQkJdGltZW91dCA9IGF0b2kocG9zKTsKCQkJfQoJCX0KCgkJcmV0dXJuIHdwYV9zdXBwbGljYW50X2FwX3dwc19waW4od3BhX3MsIF9ic3NpZCwgcGluLAoJCQkJCQkgYnVmLCBidWZsZW4sIHRpbWVvdXQpOwoJfQojZW5kaWYgLyogQ09ORklHX0FQICovCgoJaWYgKHBpbikgewoJCXJldCA9IHdwYXNfd3BzX3N0YXJ0X3Bpbih3cGFfcywgX2Jzc2lkLCBwaW4sIDAsCgkJCQkJIERFVl9QV19ERUZBVUxUKTsKCQlpZiAocmV0IDwgMCkKCQkJcmV0dXJuIC0xOwoJCXJldCA9IG9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLCAiJXMiLCBwaW4pOwoJCWlmIChyZXQgPCAwIHx8IChzaXplX3QpIHJldCA+PSBidWZsZW4pCgkJCXJldHVybiAtMTsKCQlyZXR1cm4gcmV0OwoJfQoKCXJldCA9IHdwYXNfd3BzX3N0YXJ0X3Bpbih3cGFfcywgX2Jzc2lkLCBOVUxMLCAwLCBERVZfUFdfREVGQVVMVCk7CglpZiAocmV0IDwgMCkKCQlyZXR1cm4gLTE7Cgpkb25lOgoJLyogUmV0dXJuIHRoZSBnZW5lcmF0ZWQgUElOICovCglyZXQgPSBvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIiUwOGQiLCByZXQpOwoJaWYgKHJldCA8IDAgfHwgKHNpemVfdCkgcmV0ID49IGJ1ZmxlbikKCQlyZXR1cm4gLTE7CglyZXR1cm4gcmV0Owp9CgoKc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3dwc19jaGVja19waW4oCglzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQsIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKewoJY2hhciBwaW5bOV07CglzaXplX3QgbGVuOwoJY2hhciAqcG9zOwoJaW50IHJldDsKCgl3cGFfaGV4ZHVtcF9hc2NpaV9rZXkoTVNHX0RFQlVHLCAiV1BTX0NIRUNLX1BJTiIsCgkJCSAgICAgICh1OCAqKSBjbWQsIG9zX3N0cmxlbihjbWQpKTsKCWZvciAocG9zID0gY21kLCBsZW4gPSAwOyAqcG9zICE9ICdcMCc7IHBvcysrKSB7CgkJaWYgKCpwb3MgPCAnMCcgfHwgKnBvcyA+ICc5JykKCQkJY29udGludWU7CgkJcGluW2xlbisrXSA9ICpwb3M7CgkJaWYgKGxlbiA9PSA5KSB7CgkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBUb28gbG9uZyBQSU4iKTsKCQkJcmV0dXJuIC0xOwoJCX0KCX0KCWlmIChsZW4gIT0gNCAmJiBsZW4gIT0gOCkgewoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiV1BTOiBJbnZhbGlkIFBJTiBsZW5ndGggJWQiLCAoaW50KSBsZW4pOwoJCXJldHVybiAtMTsKCX0KCXBpbltsZW5dID0gJ1wwJzsKCglpZiAobGVuID09IDgpIHsKCQl1bnNpZ25lZCBpbnQgcGluX3ZhbDsKCQlwaW5fdmFsID0gYXRvaShwaW4pOwoJCWlmICghd3BzX3Bpbl92YWxpZChwaW5fdmFsKSkgewoJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIldQUzogSW52YWxpZCBjaGVja3N1bSBkaWdpdCIpOwoJCQlyZXQgPSBvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIkZBSUwtQ0hFQ0tTVU1cbiIpOwoJCQlpZiAocmV0IDwgMCB8fCAoc2l6ZV90KSByZXQgPj0gYnVmbGVuKQoJCQkJcmV0dXJuIC0xOwoJCQlyZXR1cm4gcmV0OwoJCX0KCX0KCglyZXQgPSBvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIiVzIiwgcGluKTsKCWlmIChyZXQgPCAwIHx8IChzaXplX3QpIHJldCA+PSBidWZsZW4pCgkJcmV0dXJuIC0xOwoKCXJldHVybiByZXQ7Cn0KCgojaWZkZWYgQ09ORklHX1dQU19ORkMKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfbmZjKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJICAgICBjaGFyICpjbWQpCnsKCXU4IGJzc2lkW0VUSF9BTEVOXSwgKl9ic3NpZCA9IGJzc2lkOwoKCWlmIChjbWQgPT0gTlVMTCB8fCBjbWRbMF0gPT0gJ1wwJykKCQlfYnNzaWQgPSBOVUxMOwoJZWxzZSBpZiAoaHdhZGRyX2F0b24oY21kLCBic3NpZCkpCgkJcmV0dXJuIC0xOwoKCXJldHVybiB3cGFzX3dwc19zdGFydF9uZmMod3BhX3MsIF9ic3NpZCk7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX25mY19jb25maWdfdG9rZW4oCglzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQsIGNoYXIgKnJlcGx5LCBzaXplX3QgbWF4X2xlbikKewoJaW50IG5kZWY7CglzdHJ1Y3Qgd3BhYnVmICpidWY7CglpbnQgcmVzOwoJY2hhciAqcG9zOwoKCXBvcyA9IG9zX3N0cmNocihjbWQsICcgJyk7CglpZiAocG9zKQoJCSpwb3MrKyA9ICdcMCc7CglpZiAob3Nfc3RyY21wKGNtZCwgIldQUyIpID09IDApCgkJbmRlZiA9IDA7CgllbHNlIGlmIChvc19zdHJjbXAoY21kLCAiTkRFRiIpID09IDApCgkJbmRlZiA9IDE7CgllbHNlCgkJcmV0dXJuIC0xOwoKCWJ1ZiA9IHdwYXNfd3BzX25mY19jb25maWdfdG9rZW4od3BhX3MsIG5kZWYsIHBvcyk7CglpZiAoYnVmID09IE5VTEwpCgkJcmV0dXJuIC0xOwoKCXJlcyA9IHdwYV9zbnByaW50Zl9oZXhfdXBwZXJjYXNlKHJlcGx5LCBtYXhfbGVuLCB3cGFidWZfaGVhZChidWYpLAoJCQkJCSB3cGFidWZfbGVuKGJ1ZikpOwoJcmVwbHlbcmVzKytdID0gJ1xuJzsKCXJlcGx5W3Jlc10gPSAnXDAnOwoKCXdwYWJ1Zl9mcmVlKGJ1Zik7CgoJcmV0dXJuIHJlczsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfbmZjX3Rva2VuKAoJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kLCBjaGFyICpyZXBseSwgc2l6ZV90IG1heF9sZW4pCnsKCWludCBuZGVmOwoJc3RydWN0IHdwYWJ1ZiAqYnVmOwoJaW50IHJlczsKCglpZiAob3Nfc3RyY21wKGNtZCwgIldQUyIpID09IDApCgkJbmRlZiA9IDA7CgllbHNlIGlmIChvc19zdHJjbXAoY21kLCAiTkRFRiIpID09IDApCgkJbmRlZiA9IDE7CgllbHNlCgkJcmV0dXJuIC0xOwoKCWJ1ZiA9IHdwYXNfd3BzX25mY190b2tlbih3cGFfcywgbmRlZik7CglpZiAoYnVmID09IE5VTEwpCgkJcmV0dXJuIC0xOwoKCXJlcyA9IHdwYV9zbnByaW50Zl9oZXhfdXBwZXJjYXNlKHJlcGx5LCBtYXhfbGVuLCB3cGFidWZfaGVhZChidWYpLAoJCQkJCSB3cGFidWZfbGVuKGJ1ZikpOwoJcmVwbHlbcmVzKytdID0gJ1xuJzsKCXJlcGx5W3Jlc10gPSAnXDAnOwoKCXdwYWJ1Zl9mcmVlKGJ1Zik7CgoJcmV0dXJuIHJlczsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfbmZjX3RhZ19yZWFkKAoJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqcG9zKQp7CglzaXplX3QgbGVuOwoJc3RydWN0IHdwYWJ1ZiAqYnVmOwoJaW50IHJldDsKCglsZW4gPSBvc19zdHJsZW4ocG9zKTsKCWlmIChsZW4gJiAweDAxKQoJCXJldHVybiAtMTsKCWxlbiAvPSAyOwoKCWJ1ZiA9IHdwYWJ1Zl9hbGxvYyhsZW4pOwoJaWYgKGJ1ZiA9PSBOVUxMKQoJCXJldHVybiAtMTsKCWlmIChoZXhzdHIyYmluKHBvcywgd3BhYnVmX3B1dChidWYsIGxlbiksIGxlbikgPCAwKSB7CgkJd3BhYnVmX2ZyZWUoYnVmKTsKCQlyZXR1cm4gLTE7Cgl9CgoJcmV0ID0gd3Bhc193cHNfbmZjX3RhZ19yZWFkKHdwYV9zLCBidWYpOwoJd3BhYnVmX2ZyZWUoYnVmKTsKCglyZXR1cm4gcmV0Owp9CgoKc3RhdGljIGludCB3cGFzX2N0cmxfbmZjX2dldF9oYW5kb3Zlcl9yZXFfd3BzKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJICAgICAgY2hhciAqcmVwbHksIHNpemVfdCBtYXhfbGVuLAoJCQkJCSAgICAgIGludCBjcikKewoJc3RydWN0IHdwYWJ1ZiAqYnVmOwoJaW50IHJlczsKCglidWYgPSB3cGFzX3dwc19uZmNfaGFuZG92ZXJfcmVxKHdwYV9zLCBjcik7CglpZiAoYnVmID09IE5VTEwpCgkJcmV0dXJuIC0xOwoKCXJlcyA9IHdwYV9zbnByaW50Zl9oZXhfdXBwZXJjYXNlKHJlcGx5LCBtYXhfbGVuLCB3cGFidWZfaGVhZChidWYpLAoJCQkJCSB3cGFidWZfbGVuKGJ1ZikpOwoJcmVwbHlbcmVzKytdID0gJ1xuJzsKCXJlcGx5W3Jlc10gPSAnXDAnOwoKCXdwYWJ1Zl9mcmVlKGJ1Zik7CgoJcmV0dXJuIHJlczsKfQoKCnN0YXRpYyBpbnQgd3Bhc19jdHJsX25mY19nZXRfaGFuZG92ZXJfcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJICBjaGFyICpjbWQsIGNoYXIgKnJlcGx5LAoJCQkJCSAgc2l6ZV90IG1heF9sZW4pCnsKCWNoYXIgKnBvczsKCglwb3MgPSBvc19zdHJjaHIoY21kLCAnICcpOwoJaWYgKHBvcyA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSpwb3MrKyA9ICdcMCc7CgoJaWYgKG9zX3N0cmNtcChjbWQsICJOREVGIikgIT0gMCkKCQlyZXR1cm4gLTE7CgoJaWYgKG9zX3N0cmNtcChwb3MsICJXUFMiKSA9PSAwIHx8IG9zX3N0cmNtcChwb3MsICJXUFMtQ1IiKSA9PSAwKSB7CgkJcmV0dXJuIHdwYXNfY3RybF9uZmNfZ2V0X2hhbmRvdmVyX3JlcV93cHMoCgkJCXdwYV9zLCByZXBseSwgbWF4X2xlbiwgb3Nfc3RyY21wKHBvcywgIldQUy1DUiIpID09IDApOwoJfQoKCXJldHVybiAtMTsKfQoKCnN0YXRpYyBpbnQgd3Bhc19jdHJsX25mY19nZXRfaGFuZG92ZXJfc2VsX3dwcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAoJCQkJCSAgICAgIGNoYXIgKnJlcGx5LCBzaXplX3QgbWF4X2xlbiwKCQkJCQkgICAgICBpbnQgbmRlZiwgaW50IGNyLCBjaGFyICp1dWlkKQp7CglzdHJ1Y3Qgd3BhYnVmICpidWY7CglpbnQgcmVzOwoKCWJ1ZiA9IHdwYXNfd3BzX25mY19oYW5kb3Zlcl9zZWwod3BhX3MsIG5kZWYsIGNyLCB1dWlkKTsKCWlmIChidWYgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgoJcmVzID0gd3BhX3NucHJpbnRmX2hleF91cHBlcmNhc2UocmVwbHksIG1heF9sZW4sIHdwYWJ1Zl9oZWFkKGJ1ZiksCgkJCQkJIHdwYWJ1Zl9sZW4oYnVmKSk7CglyZXBseVtyZXMrK10gPSAnXG4nOwoJcmVwbHlbcmVzXSA9ICdcMCc7CgoJd3BhYnVmX2ZyZWUoYnVmKTsKCglyZXR1cm4gcmVzOwp9CgoKc3RhdGljIGludCB3cGFzX2N0cmxfbmZjX2dldF9oYW5kb3Zlcl9zZWwoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKCQkJCQkgIGNoYXIgKmNtZCwgY2hhciAqcmVwbHksCgkJCQkJICBzaXplX3QgbWF4X2xlbikKewoJY2hhciAqcG9zLCAqcG9zMjsKCWludCBuZGVmOwoKCXBvcyA9IG9zX3N0cmNocihjbWQsICcgJyk7CglpZiAocG9zID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJKnBvcysrID0gJ1wwJzsKCglpZiAob3Nfc3RyY21wKGNtZCwgIldQUyIpID09IDApCgkJbmRlZiA9IDA7CgllbHNlIGlmIChvc19zdHJjbXAoY21kLCAiTkRFRiIpID09IDApCgkJbmRlZiA9IDE7CgllbHNlCgkJcmV0dXJuIC0xOwoKCXBvczIgPSBvc19zdHJjaHIocG9zLCAnICcpOwoJaWYgKHBvczIpCgkJKnBvczIrKyA9ICdcMCc7CglpZiAob3Nfc3RyY21wKHBvcywgIldQUyIpID09IDAgfHwgb3Nfc3RyY21wKHBvcywgIldQUy1DUiIpID09IDApIHsKCQlyZXR1cm4gd3Bhc19jdHJsX25mY19nZXRfaGFuZG92ZXJfc2VsX3dwcygKCQkJd3BhX3MsIHJlcGx5LCBtYXhfbGVuLCBuZGVmLAoJCQlvc19zdHJjbXAocG9zLCAiV1BTLUNSIikgPT0gMCwgcG9zMik7Cgl9CgoJcmV0dXJuIC0xOwp9CgoKc3RhdGljIGludCB3cGFzX2N0cmxfbmZjX3J4X2hhbmRvdmVyX3JlcShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAoJCQkJCSBjaGFyICpjbWQsIGNoYXIgKnJlcGx5LAoJCQkJCSBzaXplX3QgbWF4X2xlbikKewoJc2l6ZV90IGxlbjsKCXN0cnVjdCB3cGFidWYgKmJ1ZjsKCWludCByZXQ7CgoJbGVuID0gb3Nfc3RybGVuKGNtZCk7CglpZiAobGVuICYgMHgwMSkKCQlyZXR1cm4gLTE7CglsZW4gLz0gMjsKCglidWYgPSB3cGFidWZfYWxsb2MobGVuKTsKCWlmIChidWYgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CglpZiAoaGV4c3RyMmJpbihjbWQsIHdwYWJ1Zl9wdXQoYnVmLCBsZW4pLCBsZW4pIDwgMCkgewoJCXdwYWJ1Zl9mcmVlKGJ1Zik7CgkJcmV0dXJuIC0xOwoJfQoKCXJldCA9IHdwYXNfd3BzX25mY19yeF9oYW5kb3Zlcl9yZXEod3BhX3MsIGJ1Zik7Cgl3cGFidWZfZnJlZShidWYpOwoKCXJldHVybiByZXQ7Cn0KCgpzdGF0aWMgaW50IHdwYXNfY3RybF9uZmNfcnhfaGFuZG92ZXJfc2VsKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJIGNoYXIgKmNtZCkKewoJc2l6ZV90IGxlbjsKCXN0cnVjdCB3cGFidWYgKmJ1ZjsKCWludCByZXQ7CgoJbGVuID0gb3Nfc3RybGVuKGNtZCk7CglpZiAobGVuICYgMHgwMSkKCQlyZXR1cm4gLTE7CglsZW4gLz0gMjsKCglidWYgPSB3cGFidWZfYWxsb2MobGVuKTsKCWlmIChidWYgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CglpZiAoaGV4c3RyMmJpbihjbWQsIHdwYWJ1Zl9wdXQoYnVmLCBsZW4pLCBsZW4pIDwgMCkgewoJCXdwYWJ1Zl9mcmVlKGJ1Zik7CgkJcmV0dXJuIC0xOwoJfQoKCXJldCA9IHdwYXNfd3BzX25mY19yeF9oYW5kb3Zlcl9zZWwod3BhX3MsIGJ1Zik7Cgl3cGFidWZfZnJlZShidWYpOwoKCXJldHVybiByZXQ7Cn0KCgpzdGF0aWMgaW50IHdwYXNfY3RybF9uZmNfcmVwb3J0X2hhbmRvdmVyKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJIGNoYXIgKmNtZCkKewoJc2l6ZV90IGxlbjsKCXN0cnVjdCB3cGFidWYgKnJlcSwgKnNlbDsKCWludCByZXQ7CgljaGFyICpwb3MsICpyb2xlLCAqdHlwZSwgKnBvczI7CgoJcm9sZSA9IGNtZDsKCXBvcyA9IG9zX3N0cmNocihyb2xlLCAnICcpOwoJaWYgKHBvcyA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSpwb3MrKyA9ICdcMCc7CgoJdHlwZSA9IHBvczsKCXBvcyA9IG9zX3N0cmNocih0eXBlLCAnICcpOwoJaWYgKHBvcyA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSpwb3MrKyA9ICdcMCc7CgoJcG9zMiA9IG9zX3N0cmNocihwb3MsICcgJyk7CglpZiAocG9zMiA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSpwb3MyKysgPSAnXDAnOwoKCWxlbiA9IG9zX3N0cmxlbihwb3MpOwoJaWYgKGxlbiAmIDB4MDEpCgkJcmV0dXJuIC0xOwoJbGVuIC89IDI7CgoJcmVxID0gd3BhYnVmX2FsbG9jKGxlbik7CglpZiAocmVxID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJaWYgKGhleHN0cjJiaW4ocG9zLCB3cGFidWZfcHV0KHJlcSwgbGVuKSwgbGVuKSA8IDApIHsKCQl3cGFidWZfZnJlZShyZXEpOwoJCXJldHVybiAtMTsKCX0KCglsZW4gPSBvc19zdHJsZW4ocG9zMik7CglpZiAobGVuICYgMHgwMSkgewoJCXdwYWJ1Zl9mcmVlKHJlcSk7CgkJcmV0dXJuIC0xOwoJfQoJbGVuIC89IDI7CgoJc2VsID0gd3BhYnVmX2FsbG9jKGxlbik7CglpZiAoc2VsID09IE5VTEwpIHsKCQl3cGFidWZfZnJlZShyZXEpOwoJCXJldHVybiAtMTsKCX0KCWlmIChoZXhzdHIyYmluKHBvczIsIHdwYWJ1Zl9wdXQoc2VsLCBsZW4pLCBsZW4pIDwgMCkgewoJCXdwYWJ1Zl9mcmVlKHJlcSk7CgkJd3BhYnVmX2ZyZWUoc2VsKTsKCQlyZXR1cm4gLTE7Cgl9CgoJaWYgKG9zX3N0cmNtcChyb2xlLCAiSU5JVCIpID09IDAgJiYgb3Nfc3RyY21wKHR5cGUsICJXUFMiKSA9PSAwKSB7CgkJcmV0ID0gd3Bhc193cHNfbmZjX3JlcG9ydF9oYW5kb3Zlcih3cGFfcywgcmVxLCBzZWwpOwoJfSBlbHNlIHsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIk5GQzogVW5zdXBwb3J0ZWQgY29ubmVjdGlvbiBoYW5kb3ZlciAiCgkJCSAgICJyZXBvcnRlZDogcm9sZT0lcyB0eXBlPSVzIiwgcm9sZSwgdHlwZSk7CgkJcmV0ID0gLTE7Cgl9Cgl3cGFidWZfZnJlZShyZXEpOwoJd3BhYnVmX2ZyZWUoc2VsKTsKCglyZXR1cm4gcmV0Owp9CgojZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX3JlZyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAoJCQkJCSAgICAgY2hhciAqY21kKQp7Cgl1OCBic3NpZFtFVEhfQUxFTl07CgljaGFyICpwaW47CgljaGFyICpuZXdfc3NpZDsKCWNoYXIgKm5ld19hdXRoOwoJY2hhciAqbmV3X2VuY3I7CgljaGFyICpuZXdfa2V5OwoJc3RydWN0IHdwc19uZXdfYXBfc2V0dGluZ3MgYXA7CgoJcGluID0gb3Nfc3RyY2hyKGNtZCwgJyAnKTsKCWlmIChwaW4gPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgkqcGluKysgPSAnXDAnOwoKCWlmIChod2FkZHJfYXRvbihjbWQsIGJzc2lkKSkgewoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRSBXUFNfUkVHOiBpbnZhbGlkIEJTU0lEICclcyciLAoJCQkgICBjbWQpOwoJCXJldHVybiAtMTsKCX0KCgluZXdfc3NpZCA9IG9zX3N0cmNocihwaW4sICcgJyk7CglpZiAobmV3X3NzaWQgPT0gTlVMTCkKCQlyZXR1cm4gd3Bhc193cHNfc3RhcnRfcmVnKHdwYV9zLCBic3NpZCwgcGluLCBOVUxMKTsKCSpuZXdfc3NpZCsrID0gJ1wwJzsKCgluZXdfYXV0aCA9IG9zX3N0cmNocihuZXdfc3NpZCwgJyAnKTsKCWlmIChuZXdfYXV0aCA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSpuZXdfYXV0aCsrID0gJ1wwJzsKCgluZXdfZW5jciA9IG9zX3N0cmNocihuZXdfYXV0aCwgJyAnKTsKCWlmIChuZXdfZW5jciA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSpuZXdfZW5jcisrID0gJ1wwJzsKCgluZXdfa2V5ID0gb3Nfc3RyY2hyKG5ld19lbmNyLCAnICcpOwoJaWYgKG5ld19rZXkgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgkqbmV3X2tleSsrID0gJ1wwJzsKCglvc19tZW1zZXQoJmFwLCAwLCBzaXplb2YoYXApKTsKCWFwLnNzaWRfaGV4ID0gbmV3X3NzaWQ7CglhcC5hdXRoID0gbmV3X2F1dGg7CglhcC5lbmNyID0gbmV3X2VuY3I7CglhcC5rZXlfaGV4ID0gbmV3X2tleTsKCXJldHVybiB3cGFzX3dwc19zdGFydF9yZWcod3BhX3MsIGJzc2lkLCBwaW4sICZhcCk7Cn0KCgojaWZkZWYgQ09ORklHX0FQCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfYXBfcGluKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJCWNoYXIgKmNtZCwgY2hhciAqYnVmLAoJCQkJCQlzaXplX3QgYnVmbGVuKQp7CglpbnQgdGltZW91dCA9IDMwMDsKCWNoYXIgKnBvczsKCWNvbnN0IGNoYXIgKnBpbl90eHQ7CgoJaWYgKCF3cGFfcy0+YXBfaWZhY2UpCgkJcmV0dXJuIC0xOwoKCXBvcyA9IG9zX3N0cmNocihjbWQsICcgJyk7CglpZiAocG9zKQoJCSpwb3MrKyA9ICdcMCc7CgoJaWYgKG9zX3N0cmNtcChjbWQsICJkaXNhYmxlIikgPT0gMCkgewoJCXdwYXNfd3BzX2FwX3Bpbl9kaXNhYmxlKHdwYV9zKTsKCQlyZXR1cm4gb3Nfc25wcmludGYoYnVmLCBidWZsZW4sICJPS1xuIik7Cgl9CgoJaWYgKG9zX3N0cmNtcChjbWQsICJyYW5kb20iKSA9PSAwKSB7CgkJaWYgKHBvcykKCQkJdGltZW91dCA9IGF0b2kocG9zKTsKCQlwaW5fdHh0ID0gd3Bhc193cHNfYXBfcGluX3JhbmRvbSh3cGFfcywgdGltZW91dCk7CgkJaWYgKHBpbl90eHQgPT0gTlVMTCkKCQkJcmV0dXJuIC0xOwoJCXJldHVybiBvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIiVzIiwgcGluX3R4dCk7Cgl9CgoJaWYgKG9zX3N0cmNtcChjbWQsICJnZXQiKSA9PSAwKSB7CgkJcGluX3R4dCA9IHdwYXNfd3BzX2FwX3Bpbl9nZXQod3BhX3MpOwoJCWlmIChwaW5fdHh0ID09IE5VTEwpCgkJCXJldHVybiAtMTsKCQlyZXR1cm4gb3Nfc25wcmludGYoYnVmLCBidWZsZW4sICIlcyIsIHBpbl90eHQpOwoJfQoKCWlmIChvc19zdHJjbXAoY21kLCAic2V0IikgPT0gMCkgewoJCWNoYXIgKnBpbjsKCQlpZiAocG9zID09IE5VTEwpCgkJCXJldHVybiAtMTsKCQlwaW4gPSBwb3M7CgkJcG9zID0gb3Nfc3RyY2hyKHBvcywgJyAnKTsKCQlpZiAocG9zKSB7CgkJCSpwb3MrKyA9ICdcMCc7CgkJCXRpbWVvdXQgPSBhdG9pKHBvcyk7CgkJfQoJCWlmIChvc19zdHJsZW4ocGluKSA+IGJ1ZmxlbikKCQkJcmV0dXJuIC0xOwoJCWlmICh3cGFzX3dwc19hcF9waW5fc2V0KHdwYV9zLCBwaW4sIHRpbWVvdXQpIDwgMCkKCQkJcmV0dXJuIC0xOwoJCXJldHVybiBvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIiVzIiwgcGluKTsKCX0KCglyZXR1cm4gLTE7Cn0KI2VuZGlmIC8qIENPTkZJR19BUCAqLwoKCiNpZmRlZiBDT05GSUdfV1BTX0VSCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfZXJfcGluKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJCWNoYXIgKmNtZCkKewoJY2hhciAqdXVpZCA9IGNtZCwgKnBpbiwgKnBvczsKCXU4IGFkZHJfYnVmW0VUSF9BTEVOXSwgKmFkZHIgPSBOVUxMOwoJcGluID0gb3Nfc3RyY2hyKHV1aWQsICcgJyk7CglpZiAocGluID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJKnBpbisrID0gJ1wwJzsKCXBvcyA9IG9zX3N0cmNocihwaW4sICcgJyk7CglpZiAocG9zKSB7CgkJKnBvcysrID0gJ1wwJzsKCQlpZiAoaHdhZGRyX2F0b24ocG9zLCBhZGRyX2J1ZikgPT0gMCkKCQkJYWRkciA9IGFkZHJfYnVmOwoJfQoJcmV0dXJuIHdwYXNfd3BzX2VyX2FkZF9waW4od3BhX3MsIGFkZHIsIHV1aWQsIHBpbik7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX2VyX2xlYXJuKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJCSAgY2hhciAqY21kKQp7CgljaGFyICp1dWlkID0gY21kLCAqcGluOwoJcGluID0gb3Nfc3RyY2hyKHV1aWQsICcgJyk7CglpZiAocGluID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJKnBpbisrID0gJ1wwJzsKCXJldHVybiB3cGFzX3dwc19lcl9sZWFybih3cGFfcywgdXVpZCwgcGluKTsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfZXJfc2V0X2NvbmZpZygKCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKewoJY2hhciAqdXVpZCA9IGNtZCwgKmlkOwoJaWQgPSBvc19zdHJjaHIodXVpZCwgJyAnKTsKCWlmIChpZCA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSppZCsrID0gJ1wwJzsKCXJldHVybiB3cGFzX3dwc19lcl9zZXRfY29uZmlnKHdwYV9zLCB1dWlkLCBhdG9pKGlkKSk7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX2VyX2NvbmZpZygKCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKewoJY2hhciAqcGluOwoJY2hhciAqbmV3X3NzaWQ7CgljaGFyICpuZXdfYXV0aDsKCWNoYXIgKm5ld19lbmNyOwoJY2hhciAqbmV3X2tleTsKCXN0cnVjdCB3cHNfbmV3X2FwX3NldHRpbmdzIGFwOwoKCXBpbiA9IG9zX3N0cmNocihjbWQsICcgJyk7CglpZiAocGluID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJKnBpbisrID0gJ1wwJzsKCgluZXdfc3NpZCA9IG9zX3N0cmNocihwaW4sICcgJyk7CglpZiAobmV3X3NzaWQgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgkqbmV3X3NzaWQrKyA9ICdcMCc7CgoJbmV3X2F1dGggPSBvc19zdHJjaHIobmV3X3NzaWQsICcgJyk7CglpZiAobmV3X2F1dGggPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgkqbmV3X2F1dGgrKyA9ICdcMCc7CgoJbmV3X2VuY3IgPSBvc19zdHJjaHIobmV3X2F1dGgsICcgJyk7CglpZiAobmV3X2VuY3IgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgkqbmV3X2VuY3IrKyA9ICdcMCc7CgoJbmV3X2tleSA9IG9zX3N0cmNocihuZXdfZW5jciwgJyAnKTsKCWlmIChuZXdfa2V5ID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJKm5ld19rZXkrKyA9ICdcMCc7CgoJb3NfbWVtc2V0KCZhcCwgMCwgc2l6ZW9mKGFwKSk7CglhcC5zc2lkX2hleCA9IG5ld19zc2lkOwoJYXAuYXV0aCA9IG5ld19hdXRoOwoJYXAuZW5jciA9IG5ld19lbmNyOwoJYXAua2V5X2hleCA9IG5ld19rZXk7CglyZXR1cm4gd3Bhc193cHNfZXJfY29uZmlnKHdwYV9zLCBjbWQsIHBpbiwgJmFwKTsKfQoKCiNpZmRlZiBDT05GSUdfV1BTX05GQwpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX2VyX25mY19jb25maWdfdG9rZW4oCglzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQsIGNoYXIgKnJlcGx5LCBzaXplX3QgbWF4X2xlbikKewoJaW50IG5kZWY7CglzdHJ1Y3Qgd3BhYnVmICpidWY7CglpbnQgcmVzOwoJY2hhciAqdXVpZDsKCgl1dWlkID0gb3Nfc3RyY2hyKGNtZCwgJyAnKTsKCWlmICh1dWlkID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJKnV1aWQrKyA9ICdcMCc7CgoJaWYgKG9zX3N0cmNtcChjbWQsICJXUFMiKSA9PSAwKQoJCW5kZWYgPSAwOwoJZWxzZSBpZiAob3Nfc3RyY21wKGNtZCwgIk5ERUYiKSA9PSAwKQoJCW5kZWYgPSAxOwoJZWxzZQoJCXJldHVybiAtMTsKCglidWYgPSB3cGFzX3dwc19lcl9uZmNfY29uZmlnX3Rva2VuKHdwYV9zLCBuZGVmLCB1dWlkKTsKCWlmIChidWYgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgoJcmVzID0gd3BhX3NucHJpbnRmX2hleF91cHBlcmNhc2UocmVwbHksIG1heF9sZW4sIHdwYWJ1Zl9oZWFkKGJ1ZiksCgkJCQkJIHdwYWJ1Zl9sZW4oYnVmKSk7CglyZXBseVtyZXMrK10gPSAnXG4nOwoJcmVwbHlbcmVzXSA9ICdcMCc7CgoJd3BhYnVmX2ZyZWUoYnVmKTsKCglyZXR1cm4gcmVzOwp9CiNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLwojZW5kaWYgLyogQ09ORklHX1dQU19FUiAqLwoKI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KCgojaWZkZWYgQ09ORklHX0lCU1NfUlNOCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9pYnNzX3JzbigKCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmFkZHIpCnsKCXU4IHBlZXJbRVRIX0FMRU5dOwoKCWlmIChod2FkZHJfYXRvbihhZGRyLCBwZWVyKSkgewoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRSBJQlNTX1JTTjogaW52YWxpZCAiCgkJCSAgICJhZGRyZXNzICclcyciLCBhZGRyKTsKCQlyZXR1cm4gLTE7Cgl9CgoJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIElCU1NfUlNOICIgTUFDU1RSLAoJCSAgIE1BQzJTVFIocGVlcikpOwoKCXJldHVybiBpYnNzX3Jzbl9zdGFydCh3cGFfcy0+aWJzc19yc24sIHBlZXIpOwp9CiNlbmRpZiAvKiBDT05GSUdfSUJTU19SU04gKi8KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfY3RybF9yc3Aoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKCQkJCQkgICAgICBjaGFyICpyc3ApCnsKI2lmZGVmIElFRUU4MDIxWF9FQVBPTAoJY2hhciAqcG9zLCAqaWRfcG9zOwoJaW50IGlkOwoJc3RydWN0IHdwYV9zc2lkICpzc2lkOwoKCXBvcyA9IG9zX3N0cmNocihyc3AsICctJyk7CglpZiAocG9zID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJKnBvcysrID0gJ1wwJzsKCWlkX3BvcyA9IHBvczsKCXBvcyA9IG9zX3N0cmNocihwb3MsICc6Jyk7CglpZiAocG9zID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJKnBvcysrID0gJ1wwJzsKCWlkID0gYXRvaShpZF9wb3MpOwoJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBmaWVsZD0lcyBpZD0lZCIsIHJzcCwgaWQpOwoJd3BhX2hleGR1bXBfYXNjaWlfa2V5KE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IHZhbHVlIiwKCQkJICAgICAgKHU4ICopIHBvcywgb3Nfc3RybGVuKHBvcykpOwoKCXNzaWQgPSB3cGFfY29uZmlnX2dldF9uZXR3b3JrKHdwYV9zLT5jb25mLCBpZCk7CglpZiAoc3NpZCA9PSBOVUxMKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBDb3VsZCBub3QgZmluZCBTU0lEIGlkPSVkICIKCQkJICAgInRvIHVwZGF0ZSIsIGlkKTsKCQlyZXR1cm4gLTE7Cgl9CgoJcmV0dXJuIHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfY3RybF9yc3BfaGFuZGxlKHdwYV9zLCBzc2lkLCByc3AsCgkJCQkJCQkgcG9zKTsKI2Vsc2UgLyogSUVFRTgwMjFYX0VBUE9MICovCgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IDgwMi4xWCBub3QgaW5jbHVkZWQiKTsKCXJldHVybiAtMTsKI2VuZGlmIC8qIElFRUU4MDIxWF9FQVBPTCAqLwp9CgoKc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3N0YXR1cyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAoJCQkJCSAgICBjb25zdCBjaGFyICpwYXJhbXMsCgkJCQkJICAgIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKewoJY2hhciAqcG9zLCAqZW5kLCB0bXBbMzBdOwoJaW50IHJlcywgdmVyYm9zZSwgd3BzLCByZXQ7CgoJdmVyYm9zZSA9IG9zX3N0cmNtcChwYXJhbXMsICItVkVSQk9TRSIpID09IDA7Cgl3cHMgPSBvc19zdHJjbXAocGFyYW1zLCAiLVdQUyIpID09IDA7Cglwb3MgPSBidWY7CgllbmQgPSBidWYgKyBidWZsZW47CglpZiAod3BhX3MtPndwYV9zdGF0ZSA+PSBXUEFfQVNTT0NJQVRFRCkgewoJCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCA9IHdwYV9zLT5jdXJyZW50X3NzaWQ7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJic3NpZD0iIE1BQ1NUUiAiXG4iLAoJCQkJICBNQUMyU1RSKHdwYV9zLT5ic3NpZCkpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCQlpZiAoc3NpZCkgewoJCQl1OCAqX3NzaWQgPSBzc2lkLT5zc2lkOwoJCQlzaXplX3Qgc3NpZF9sZW4gPSBzc2lkLT5zc2lkX2xlbjsKCQkJdTggc3NpZF9idWZbTUFYX1NTSURfTEVOXTsKCQkJaWYgKHNzaWRfbGVuID09IDApIHsKCQkJCWludCBfcmVzID0gd3BhX2Rydl9nZXRfc3NpZCh3cGFfcywgc3NpZF9idWYpOwoJCQkJaWYgKF9yZXMgPCAwKQoJCQkJCXNzaWRfbGVuID0gMDsKCQkJCWVsc2UKCQkJCQlzc2lkX2xlbiA9IF9yZXM7CgkJCQlfc3NpZCA9IHNzaWRfYnVmOwoJCQl9CgkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAic3NpZD0lc1xuaWQ9JWRcbiIsCgkJCQkJICB3cGFfc3NpZF90eHQoX3NzaWQsIHNzaWRfbGVuKSwKCQkJCQkgIHNzaWQtPmlkKTsKCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJCXJldHVybiBwb3MgLSBidWY7CgkJCXBvcyArPSByZXQ7CgoJCQlpZiAod3BzICYmIHNzaWQtPnBhc3NwaHJhc2UgJiYKCQkJICAgIHdwYV9rZXlfbWdtdF93cGFfcHNrKHNzaWQtPmtleV9tZ210KSAmJgoJCQkgICAgKHNzaWQtPm1vZGUgPT0gV1BBU19NT0RFX0FQIHx8CgkJCSAgICAgc3NpZC0+bW9kZSA9PSBXUEFTX01PREVfUDJQX0dPKSkgewoJCQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsCgkJCQkJCSAgInBhc3NwaHJhc2U9JXNcbiIsCgkJCQkJCSAgc3NpZC0+cGFzc3BocmFzZSk7CgkJCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQkJCXJldHVybiBwb3MgLSBidWY7CgkJCQlwb3MgKz0gcmV0OwoJCQl9CgkJCWlmIChzc2lkLT5pZF9zdHIpIHsKCQkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLAoJCQkJCQkgICJpZF9zdHI9JXNcbiIsCgkJCQkJCSAgc3NpZC0+aWRfc3RyKTsKCQkJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQkJCXBvcyArPSByZXQ7CgkJCX0KCgkJCXN3aXRjaCAoc3NpZC0+bW9kZSkgewoJCQljYXNlIFdQQVNfTU9ERV9JTkZSQToKCQkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLAoJCQkJCQkgICJtb2RlPXN0YXRpb25cbiIpOwoJCQkJYnJlYWs7CgkJCWNhc2UgV1BBU19NT0RFX0lCU1M6CgkJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywKCQkJCQkJICAibW9kZT1JQlNTXG4iKTsKCQkJCWJyZWFrOwoJCQljYXNlIFdQQVNfTU9ERV9BUDoKCQkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLAoJCQkJCQkgICJtb2RlPUFQXG4iKTsKCQkJCWJyZWFrOwoJCQljYXNlIFdQQVNfTU9ERV9QMlBfR086CgkJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywKCQkJCQkJICAibW9kZT1QMlAgR09cbiIpOwoJCQkJYnJlYWs7CgkJCWNhc2UgV1BBU19NT0RFX1AyUF9HUk9VUF9GT1JNQVRJT046CgkJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywKCQkJCQkJICAibW9kZT1QMlAgR08gLSBncm91cCAiCgkJCQkJCSAgImZvcm1hdGlvblxuIik7CgkJCQlicmVhazsKCQkJZGVmYXVsdDoKCQkJCXJldCA9IDA7CgkJCQlicmVhazsKCQkJfQoJCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQkJcG9zICs9IHJldDsKCQl9CgojaWZkZWYgQ09ORklHX0FQCgkJaWYgKHdwYV9zLT5hcF9pZmFjZSkgewoJCQlwb3MgKz0gYXBfY3RybF9pZmFjZV93cGFfZ2V0X3N0YXR1cyh3cGFfcywgcG9zLAoJCQkJCQkJICAgIGVuZCAtIHBvcywKCQkJCQkJCSAgICB2ZXJib3NlKTsKCQl9IGVsc2UKI2VuZGlmIC8qIENPTkZJR19BUCAqLwoJCXBvcyArPSB3cGFfc21fZ2V0X3N0YXR1cyh3cGFfcy0+d3BhLCBwb3MsIGVuZCAtIHBvcywgdmVyYm9zZSk7Cgl9CiNpZmRlZiBDT05GSUdfU0FFCglpZiAod3BhX3MtPndwYV9zdGF0ZSA+PSBXUEFfQVNTT0NJQVRFRCAmJgojaWZkZWYgQ09ORklHX0FQCgkgICAgIXdwYV9zLT5hcF9pZmFjZSAmJgojZW5kaWYgLyogQ09ORklHX0FQICovCgkgICAgd3BhX3MtPnNtZS5zYWUuc3RhdGUgPT0gU0FFX0FDQ0VQVEVEKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJzYWVfZ3JvdXA9JWRcbiIsCgkJCQkgIHdwYV9zLT5zbWUuc2FlLmdyb3VwKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zIC0gYnVmOwoJCXBvcyArPSByZXQ7Cgl9CiNlbmRpZiAvKiBDT05GSUdfU0FFICovCglyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIndwYV9zdGF0ZT0lc1xuIiwKCQkJICB3cGFfc3VwcGxpY2FudF9zdGF0ZV90eHQod3BhX3MtPndwYV9zdGF0ZSkpOwoJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQlyZXR1cm4gcG9zIC0gYnVmOwoJcG9zICs9IHJldDsKCglpZiAod3BhX3MtPmwyICYmCgkgICAgbDJfcGFja2V0X2dldF9pcF9hZGRyKHdwYV9zLT5sMiwgdG1wLCBzaXplb2YodG1wKSkgPj0gMCkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiaXBfYWRkcmVzcz0lc1xuIiwgdG1wKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zIC0gYnVmOwoJCXBvcyArPSByZXQ7Cgl9CgojaWZkZWYgQ09ORklHX1AyUAoJaWYgKHdwYV9zLT5nbG9iYWwtPnAycCkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAicDJwX2RldmljZV9hZGRyZXNzPSIgTUFDU1RSCgkJCQkgICJcbiIsIE1BQzJTVFIod3BhX3MtPmdsb2JhbC0+cDJwX2Rldl9hZGRyKSk7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQlwb3MgKz0gcmV0OwoJfQojZW5kaWYgLyogQ09ORklHX1AyUCAqLwoKCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiYWRkcmVzcz0iIE1BQ1NUUiAiXG4iLAoJCQkgIE1BQzJTVFIod3BhX3MtPm93bl9hZGRyKSk7CglpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCXJldHVybiBwb3MgLSBidWY7Cglwb3MgKz0gcmV0OwoKI2lmZGVmIENPTkZJR19IUzIwCglpZiAod3BhX3MtPmN1cnJlbnRfYnNzICYmCgkgICAgd3BhX2Jzc19nZXRfdmVuZG9yX2llKHdwYV9zLT5jdXJyZW50X2JzcywgSFMyMF9JRV9WRU5ET1JfVFlQRSkgJiYKCSAgICB3cGFfcy0+d3BhX3Byb3RvID09IFdQQV9QUk9UT19SU04gJiYKCSAgICB3cGFfa2V5X21nbXRfd3BhX2llZWU4MDIxeCh3cGFfcy0+a2V5X21nbXQpKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJoczIwPTFcbiIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCX0KCglpZiAod3BhX3MtPmN1cnJlbnRfc3NpZCkgewoJCXN0cnVjdCB3cGFfY3JlZCAqY3JlZDsKCQljaGFyICp0eXBlOwoKCQlmb3IgKGNyZWQgPSB3cGFfcy0+Y29uZi0+Y3JlZDsgY3JlZDsgY3JlZCA9IGNyZWQtPm5leHQpIHsKCQkJaWYgKHdwYV9zLT5jdXJyZW50X3NzaWQtPnBhcmVudF9jcmVkICE9IGNyZWQpCgkJCQljb250aW51ZTsKCQkJaWYgKCFjcmVkLT5kb21haW4pCgkJCQljb250aW51ZTsKCgkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiaG9tZV9zcD0lc1xuIiwKCQkJCQkgIGNyZWQtPmRvbWFpbik7CgkJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCQlyZXR1cm4gcG9zIC0gYnVmOwoJCQlwb3MgKz0gcmV0OwoKCQkJaWYgKHdwYV9zLT5jdXJyZW50X2JzcyA9PSBOVUxMIHx8CgkJCSAgICB3cGFfcy0+Y3VycmVudF9ic3MtPmFucXAgPT0gTlVMTCkKCQkJCXJlcyA9IC0xOwoJCQllbHNlCgkJCQlyZXMgPSBpbnRlcndvcmtpbmdfaG9tZV9zcF9jcmVkKAoJCQkJCXdwYV9zLCBjcmVkLAoJCQkJCXdwYV9zLT5jdXJyZW50X2Jzcy0+YW5xcC0+ZG9tYWluX25hbWUpOwoJCQlpZiAocmVzID4gMCkKCQkJCXR5cGUgPSAiaG9tZSI7CgkJCWVsc2UgaWYgKHJlcyA9PSAwKQoJCQkJdHlwZSA9ICJyb2FtaW5nIjsKCQkJZWxzZQoJCQkJdHlwZSA9ICJ1bmtub3duIjsKCgkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAic3BfdHlwZT0lc1xuIiwgdHlwZSk7CgkJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCQlyZXR1cm4gcG9zIC0gYnVmOwoJCQlwb3MgKz0gcmV0OwoKCQkJYnJlYWs7CgkJfQoJfQojZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KCglpZiAod3BhX2tleV9tZ210X3dwYV9pZWVlODAyMXgod3BhX3MtPmtleV9tZ210KSB8fAoJICAgIHdwYV9zLT5rZXlfbWdtdCA9PSBXUEFfS0VZX01HTVRfSUVFRTgwMjFYX05PX1dQQSkgewoJCXJlcyA9IGVhcG9sX3NtX2dldF9zdGF0dXMod3BhX3MtPmVhcG9sLCBwb3MsIGVuZCAtIHBvcywKCQkJCQkgIHZlcmJvc2UpOwoJCWlmIChyZXMgPj0gMCkKCQkJcG9zICs9IHJlczsKCX0KCglyZXMgPSByc25fcHJlYXV0aF9nZXRfc3RhdHVzKHdwYV9zLT53cGEsIHBvcywgZW5kIC0gcG9zLCB2ZXJib3NlKTsKCWlmIChyZXMgPj0gMCkKCQlwb3MgKz0gcmVzOwoKI2lmZGVmIEFORFJPSUQKCXdwYV9tc2dfY3RybCh3cGFfcywgTVNHX0lORk8sIFdQQV9FVkVOVF9TVEFURV9DSEFOR0UKCQkgICAgICJpZD0lZCBzdGF0ZT0lZCBCU1NJRD0iIE1BQ1NUUiAiIFNTSUQ9JXMiLAoJCSAgICAgd3BhX3MtPmN1cnJlbnRfc3NpZCA/IHdwYV9zLT5jdXJyZW50X3NzaWQtPmlkIDogLTEsCgkJICAgICB3cGFfcy0+d3BhX3N0YXRlLAoJCSAgICAgTUFDMlNUUih3cGFfcy0+YnNzaWQpLAoJCSAgICAgd3BhX3MtPmN1cnJlbnRfc3NpZCAmJiB3cGFfcy0+Y3VycmVudF9zc2lkLT5zc2lkID8KCQkgICAgIHdwYV9zc2lkX3R4dCh3cGFfcy0+Y3VycmVudF9zc2lkLT5zc2lkLAoJCSAgICAgd3BhX3MtPmN1cnJlbnRfc3NpZC0+c3NpZF9sZW4pIDogIiIpOwoJaWYgKHdwYV9zLT53cGFfc3RhdGUgPT0gV1BBX0NPTVBMRVRFRCkgewoJCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCA9IHdwYV9zLT5jdXJyZW50X3NzaWQ7CgkJd3BhX21zZ19jdHJsKHdwYV9zLCBNU0dfSU5GTywgV1BBX0VWRU5UX0NPTk5FQ1RFRCAiLSBjb25uZWN0aW9uIHRvICIKCQkJTUFDU1RSICIgY29tcGxldGVkICVzIFtpZD0lZCBpZF9zdHI9JXNdIiwKCQkJTUFDMlNUUih3cGFfcy0+YnNzaWQpLCAiKGF1dGgpIiwKCQkJc3NpZCA/IHNzaWQtPmlkIDogLTEsCgkJCXNzaWQgJiYgc3NpZC0+aWRfc3RyID8gc3NpZC0+aWRfc3RyIDogIiIpOwoJfQojZW5kaWYgLyogQU5EUk9JRCAqLwoKCXJldHVybiBwb3MgLSBidWY7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfYnNzaWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKCQkJCQkgICBjaGFyICpjbWQpCnsKCWNoYXIgKnBvczsKCWludCBpZDsKCXN0cnVjdCB3cGFfc3NpZCAqc3NpZDsKCXU4IGJzc2lkW0VUSF9BTEVOXTsKCgkvKiBjbWQ6ICI8bmV0d29yayBpZD4gPEJTU0lEPiIgKi8KCXBvcyA9IG9zX3N0cmNocihjbWQsICcgJyk7CglpZiAocG9zID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJKnBvcysrID0gJ1wwJzsKCWlkID0gYXRvaShjbWQpOwoJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBpZD0lZCBic3NpZD0nJXMnIiwgaWQsIHBvcyk7CglpZiAoaHdhZGRyX2F0b24ocG9zLCBic3NpZCkpIHsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRyAsIkNUUkxfSUZBQ0U6IGludmFsaWQgQlNTSUQgJyVzJyIsIHBvcyk7CgkJcmV0dXJuIC0xOwoJfQoKCXNzaWQgPSB3cGFfY29uZmlnX2dldF9uZXR3b3JrKHdwYV9zLT5jb25mLCBpZCk7CglpZiAoc3NpZCA9PSBOVUxMKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBDb3VsZCBub3QgZmluZCBTU0lEIGlkPSVkICIKCQkJICAgInRvIHVwZGF0ZSIsIGlkKTsKCQlyZXR1cm4gLTE7Cgl9CgoJb3NfbWVtY3B5KHNzaWQtPmJzc2lkLCBic3NpZCwgRVRIX0FMRU4pOwoJc3NpZC0+YnNzaWRfc2V0ID0gIWlzX3plcm9fZXRoZXJfYWRkcihic3NpZCk7CgoJcmV0dXJuIDA7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfYmxhY2tsaXN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJICAgICAgIGNoYXIgKmNtZCwgY2hhciAqYnVmLAoJCQkJCSAgICAgICBzaXplX3QgYnVmbGVuKQp7Cgl1OCBic3NpZFtFVEhfQUxFTl07CglzdHJ1Y3Qgd3BhX2JsYWNrbGlzdCAqZTsKCWNoYXIgKnBvcywgKmVuZDsKCWludCByZXQ7CgoJLyogY21kOiAiQkxBQ0tMSVNUIFs8QlNTSUQ+XSIgKi8KCWlmICgqY21kID09ICdcMCcpIHsKCQlwb3MgPSBidWY7CgkJZW5kID0gYnVmICsgYnVmbGVuOwoJCWUgPSB3cGFfcy0+YmxhY2tsaXN0OwoJCXdoaWxlIChlKSB7CgkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCBNQUNTVFIgIlxuIiwKCQkJCQkgIE1BQzJTVFIoZS0+YnNzaWQpKTsKCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJCXJldHVybiBwb3MgLSBidWY7CgkJCXBvcyArPSByZXQ7CgkJCWUgPSBlLT5uZXh0OwoJCX0KCQlyZXR1cm4gcG9zIC0gYnVmOwoJfQoKCWNtZCsrOwoJaWYgKG9zX3N0cm5jbXAoY21kLCAiY2xlYXIiLCA1KSA9PSAwKSB7CgkJd3BhX2JsYWNrbGlzdF9jbGVhcih3cGFfcyk7CgkJb3NfbWVtY3B5KGJ1ZiwgIk9LXG4iLCAzKTsKCQlyZXR1cm4gMzsKCX0KCgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IEJMQUNLTElTVCBic3NpZD0nJXMnIiwgY21kKTsKCWlmIChod2FkZHJfYXRvbihjbWQsIGJzc2lkKSkgewoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogaW52YWxpZCBCU1NJRCAnJXMnIiwgY21kKTsKCQlyZXR1cm4gLTE7Cgl9CgoJLyoKCSAqIEFkZCB0aGUgQlNTSUQgdHdpY2UsIHNvIGl0cyBjb3VudCB3aWxsIGJlIDIsIGNhdXNpbmcgaXQgdG8gYmUKCSAqIHNraXBwZWQgd2hlbiBwcm9jZXNzaW5nIHNjYW4gcmVzdWx0cy4KCSAqLwoJcmV0ID0gd3BhX2JsYWNrbGlzdF9hZGQod3BhX3MsIGJzc2lkKTsKCWlmIChyZXQgIT0gMCkKCQlyZXR1cm4gLTE7CglyZXQgPSB3cGFfYmxhY2tsaXN0X2FkZCh3cGFfcywgYnNzaWQpOwoJaWYgKHJldCAhPSAwKQoJCXJldHVybiAtMTsKCW9zX21lbWNweShidWYsICJPS1xuIiwgMyk7CglyZXR1cm4gMzsKfQoKCmV4dGVybiBpbnQgd3BhX2RlYnVnX2xldmVsOwpleHRlcm4gaW50IHdwYV9kZWJ1Z190aW1lc3RhbXA7CgpzdGF0aWMgY29uc3QgY2hhciAqIGRlYnVnX2xldmVsX3N0cihpbnQgbGV2ZWwpCnsKCXN3aXRjaCAobGV2ZWwpIHsKCWNhc2UgTVNHX0VYQ0VTU0lWRToKCQlyZXR1cm4gIkVYQ0VTU0lWRSI7CgljYXNlIE1TR19NU0dEVU1QOgoJCXJldHVybiAiTVNHRFVNUCI7CgljYXNlIE1TR19ERUJVRzoKCQlyZXR1cm4gIkRFQlVHIjsKCWNhc2UgTVNHX0lORk86CgkJcmV0dXJuICJJTkZPIjsKCWNhc2UgTVNHX1dBUk5JTkc6CgkJcmV0dXJuICJXQVJOSU5HIjsKCWNhc2UgTVNHX0VSUk9SOgoJCXJldHVybiAiRVJST1IiOwoJZGVmYXVsdDoKCQlyZXR1cm4gIj8iOwoJfQp9CgoKc3RhdGljIGludCBzdHJfdG9fZGVidWdfbGV2ZWwoY29uc3QgY2hhciAqcykKewoJaWYgKG9zX3N0cmNhc2VjbXAocywgIkVYQ0VTU0lWRSIpID09IDApCgkJcmV0dXJuIE1TR19FWENFU1NJVkU7CglpZiAob3Nfc3RyY2FzZWNtcChzLCAiTVNHRFVNUCIpID09IDApCgkJcmV0dXJuIE1TR19NU0dEVU1QOwoJaWYgKG9zX3N0cmNhc2VjbXAocywgIkRFQlVHIikgPT0gMCkKCQlyZXR1cm4gTVNHX0RFQlVHOwoJaWYgKG9zX3N0cmNhc2VjbXAocywgIklORk8iKSA9PSAwKQoJCXJldHVybiBNU0dfSU5GTzsKCWlmIChvc19zdHJjYXNlY21wKHMsICJXQVJOSU5HIikgPT0gMCkKCQlyZXR1cm4gTVNHX1dBUk5JTkc7CglpZiAob3Nfc3RyY2FzZWNtcChzLCAiRVJST1IiKSA9PSAwKQoJCXJldHVybiBNU0dfRVJST1I7CglyZXR1cm4gLTE7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfbG9nX2xldmVsKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJICAgICAgIGNoYXIgKmNtZCwgY2hhciAqYnVmLAoJCQkJCSAgICAgICBzaXplX3QgYnVmbGVuKQp7CgljaGFyICpwb3MsICplbmQsICpzdGFtcDsKCWludCByZXQ7CgoJaWYgKGNtZCA9PSBOVUxMKSB7CgkJcmV0dXJuIC0xOwoJfQoKCS8qIGNtZDogIkxPR19MRVZFTCBbPGxldmVsPl0iICovCglpZiAoKmNtZCA9PSAnXDAnKSB7CgkJcG9zID0gYnVmOwoJCWVuZCA9IGJ1ZiArIGJ1ZmxlbjsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIkN1cnJlbnQgbGV2ZWw6ICVzXG4iCgkJCQkgICJUaW1lc3RhbXA6ICVkXG4iLAoJCQkJICBkZWJ1Z19sZXZlbF9zdHIod3BhX2RlYnVnX2xldmVsKSwKCQkJCSAgd3BhX2RlYnVnX3RpbWVzdGFtcCk7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0ID0gMDsKCgkJcmV0dXJuIHJldDsKCX0KCgl3aGlsZSAoKmNtZCA9PSAnICcpCgkJY21kKys7CgoJc3RhbXAgPSBvc19zdHJjaHIoY21kLCAnICcpOwoJaWYgKHN0YW1wKSB7CgkJKnN0YW1wKysgPSAnXDAnOwoJCXdoaWxlICgqc3RhbXAgPT0gJyAnKSB7CgkJCXN0YW1wKys7CgkJfQoJfQoKCWlmIChjbWQgJiYgb3Nfc3RybGVuKGNtZCkpIHsKCQlpbnQgbGV2ZWwgPSBzdHJfdG9fZGVidWdfbGV2ZWwoY21kKTsKCQlpZiAobGV2ZWwgPCAwKQoJCQlyZXR1cm4gLTE7CgkJd3BhX2RlYnVnX2xldmVsID0gbGV2ZWw7Cgl9CgoJaWYgKHN0YW1wICYmIG9zX3N0cmxlbihzdGFtcCkpCgkJd3BhX2RlYnVnX3RpbWVzdGFtcCA9IGF0b2koc3RhbXApOwoKCW9zX21lbWNweShidWYsICJPS1xuIiwgMyk7CglyZXR1cm4gMzsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9saXN0X25ldHdvcmtzKAoJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQp7CgljaGFyICpwb3MsICplbmQ7CglzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CglpbnQgcmV0OwoKCXBvcyA9IGJ1ZjsKCWVuZCA9IGJ1ZiArIGJ1ZmxlbjsKCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLAoJCQkgICJuZXR3b3JrIGlkIC8gc3NpZCAvIGJzc2lkIC8gZmxhZ3NcbiIpOwoJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQlyZXR1cm4gcG9zIC0gYnVmOwoJcG9zICs9IHJldDsKCglzc2lkID0gd3BhX3MtPmNvbmYtPnNzaWQ7Cgl3aGlsZSAoc3NpZCkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJWRcdCVzIiwKCQkJCSAgc3NpZC0+aWQsCgkJCQkgIHdwYV9zc2lkX3R4dChzc2lkLT5zc2lkLCBzc2lkLT5zc2lkX2xlbikpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCQlpZiAoc3NpZC0+YnNzaWRfc2V0KSB7CgkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiXHQiIE1BQ1NUUiwKCQkJCQkgIE1BQzJTVFIoc3NpZC0+YnNzaWQpKTsKCQl9IGVsc2UgewoJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIlx0YW55Iik7CgkJfQoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIlx0JXMlcyVzJXMiLAoJCQkJICBzc2lkID09IHdwYV9zLT5jdXJyZW50X3NzaWQgPwoJCQkJICAiW0NVUlJFTlRdIiA6ICIiLAoJCQkJICBzc2lkLT5kaXNhYmxlZCA/ICJbRElTQUJMRURdIiA6ICIiLAoJCQkJICBzc2lkLT5kaXNhYmxlZF91bnRpbC5zZWMgPwoJCQkJICAiW1RFTVAtRElTQUJMRURdIiA6ICIiLAoJCQkJICBzc2lkLT5kaXNhYmxlZCA9PSAyID8gIltQMlAtUEVSU0lTVEVOVF0iIDoKCQkJCSAgIiIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIlxuIik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQlwb3MgKz0gcmV0OwoKCQlzc2lkID0gc3NpZC0+bmV4dDsKCX0KCglyZXR1cm4gcG9zIC0gYnVmOwp9CgoKc3RhdGljIGNoYXIgKiB3cGFfc3VwcGxpY2FudF9jaXBoZXJfdHh0KGNoYXIgKnBvcywgY2hhciAqZW5kLCBpbnQgY2lwaGVyKQp7CglpbnQgcmV0OwoJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICItIik7CglpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCXJldHVybiBwb3M7Cglwb3MgKz0gcmV0OwoJcmV0ID0gd3BhX3dyaXRlX2NpcGhlcnMocG9zLCBlbmQsIGNpcGhlciwgIisiKTsKCWlmIChyZXQgPCAwKQoJCXJldHVybiBwb3M7Cglwb3MgKz0gcmV0OwoJcmV0dXJuIHBvczsKfQoKCnN0YXRpYyBjaGFyICogd3BhX3N1cHBsaWNhbnRfaWVfdHh0KGNoYXIgKnBvcywgY2hhciAqZW5kLCBjb25zdCBjaGFyICpwcm90bywKCQkJCSAgICBjb25zdCB1OCAqaWUsIHNpemVfdCBpZV9sZW4pCnsKCXN0cnVjdCB3cGFfaWVfZGF0YSBkYXRhOwoJaW50IGZpcnN0LCByZXQ7CgoJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJbJXMtIiwgcHJvdG8pOwoJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQlyZXR1cm4gcG9zOwoJcG9zICs9IHJldDsKCglpZiAod3BhX3BhcnNlX3dwYV9pZShpZSwgaWVfbGVuLCAmZGF0YSkgPCAwKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICI/XSIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3M7CgkJcG9zICs9IHJldDsKCQlyZXR1cm4gcG9zOwoJfQoKCWZpcnN0ID0gMTsKCWlmIChkYXRhLmtleV9tZ210ICYgV1BBX0tFWV9NR01UX0lFRUU4MDIxWCkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNFQVAiLCBmaXJzdCA/ICIiIDogIisiKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zOwoJCXBvcyArPSByZXQ7CgkJZmlyc3QgPSAwOwoJfQoJaWYgKGRhdGEua2V5X21nbXQgJiBXUEFfS0VZX01HTVRfUFNLKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc1BTSyIsIGZpcnN0ID8gIiIgOiAiKyIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3M7CgkJcG9zICs9IHJldDsKCQlmaXJzdCA9IDA7Cgl9CglpZiAoZGF0YS5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9XUEFfTk9ORSkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNOb25lIiwgZmlyc3QgPyAiIiA6ICIrIik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvczsKCQlwb3MgKz0gcmV0OwoJCWZpcnN0ID0gMDsKCX0KI2lmZGVmIENPTkZJR19JRUVFODAyMTFSCglpZiAoZGF0YS5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9GVF9JRUVFODAyMVgpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzRlQvRUFQIiwKCQkJCSAgZmlyc3QgPyAiIiA6ICIrIik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvczsKCQlwb3MgKz0gcmV0OwoJCWZpcnN0ID0gMDsKCX0KCWlmIChkYXRhLmtleV9tZ210ICYgV1BBX0tFWV9NR01UX0ZUX1BTSykgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNGVC9QU0siLAoJCQkJICBmaXJzdCA/ICIiIDogIisiKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zOwoJCXBvcyArPSByZXQ7CgkJZmlyc3QgPSAwOwoJfQojZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCglpZiAoZGF0YS5rZXlfbWdtdCAmIFdQQV9LRVlfTUdNVF9JRUVFODAyMVhfU0hBMjU2KSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc0VBUC1TSEEyNTYiLAoJCQkJICBmaXJzdCA/ICIiIDogIisiKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zOwoJCXBvcyArPSByZXQ7CgkJZmlyc3QgPSAwOwoJfQoJaWYgKGRhdGEua2V5X21nbXQgJiBXUEFfS0VZX01HTVRfUFNLX1NIQTI1NikgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNQU0stU0hBMjU2IiwKCQkJCSAgZmlyc3QgPyAiIiA6ICIrIik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvczsKCQlwb3MgKz0gcmV0OwoJCWZpcnN0ID0gMDsKCX0KI2VuZGlmIC8qIENPTkZJR19JRUVFODAyMTFXICovCgoJcG9zID0gd3BhX3N1cHBsaWNhbnRfY2lwaGVyX3R4dChwb3MsIGVuZCwgZGF0YS5wYWlyd2lzZV9jaXBoZXIpOwoKCWlmIChkYXRhLmNhcGFiaWxpdGllcyAmIFdQQV9DQVBBQklMSVRZX1BSRUFVVEgpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIi1wcmVhdXRoIik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvczsKCQlwb3MgKz0gcmV0OwoJfQoKCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiXSIpOwoJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQlyZXR1cm4gcG9zOwoJcG9zICs9IHJldDsKCglyZXR1cm4gcG9zOwp9CgoKI2lmZGVmIENPTkZJR19XUFMKc3RhdGljIGNoYXIgKiB3cGFfc3VwcGxpY2FudF93cHNfaWVfdHh0X2J1ZihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAoJCQkJCSAgICBjaGFyICpwb3MsIGNoYXIgKmVuZCwKCQkJCQkgICAgc3RydWN0IHdwYWJ1ZiAqd3BzX2llKQp7CglpbnQgcmV0OwoJY29uc3QgY2hhciAqdHh0OwoKCWlmICh3cHNfaWUgPT0gTlVMTCkKCQlyZXR1cm4gcG9zOwoJaWYgKHdwc19pc19zZWxlY3RlZF9wYmNfcmVnaXN0cmFyKHdwc19pZSkpCgkJdHh0ID0gIltXUFMtUEJDXSI7CiNpZmRlZiBDT05GSUdfV1BTMgoJZWxzZSBpZiAod3BzX2lzX2FkZHJfYXV0aG9yaXplZCh3cHNfaWUsIHdwYV9zLT5vd25fYWRkciwgMCkpCgkJdHh0ID0gIltXUFMtQVVUSF0iOwojZW5kaWYgLyogQ09ORklHX1dQUzIgKi8KCWVsc2UgaWYgKHdwc19pc19zZWxlY3RlZF9waW5fcmVnaXN0cmFyKHdwc19pZSkpCgkJdHh0ID0gIltXUFMtUElOXSI7CgllbHNlCgkJdHh0ID0gIltXUFNdIjsKCglyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzIiwgdHh0KTsKCWlmIChyZXQgPj0gMCAmJiByZXQgPCBlbmQgLSBwb3MpCgkJcG9zICs9IHJldDsKCXdwYWJ1Zl9mcmVlKHdwc19pZSk7CglyZXR1cm4gcG9zOwp9CiNlbmRpZiAvKiBDT05GSUdfV1BTICovCgoKc3RhdGljIGNoYXIgKiB3cGFfc3VwcGxpY2FudF93cHNfaWVfdHh0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJY2hhciAqcG9zLCBjaGFyICplbmQsCgkJCQkJY29uc3Qgc3RydWN0IHdwYV9ic3MgKmJzcykKewojaWZkZWYgQ09ORklHX1dQUwoJc3RydWN0IHdwYWJ1ZiAqd3BzX2llOwoJd3BzX2llID0gd3BhX2Jzc19nZXRfdmVuZG9yX2llX211bHRpKGJzcywgV1BTX0lFX1ZFTkRPUl9UWVBFKTsKCXJldHVybiB3cGFfc3VwcGxpY2FudF93cHNfaWVfdHh0X2J1Zih3cGFfcywgcG9zLCBlbmQsIHdwc19pZSk7CiNlbHNlIC8qIENPTkZJR19XUFMgKi8KCXJldHVybiBwb3M7CiNlbmRpZiAvKiBDT05GSUdfV1BTICovCn0KCgovKiBGb3JtYXQgb25lIHJlc3VsdCBvbiBvbmUgdGV4dCBsaW5lIGludG8gYSBidWZmZXIuICovCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9zY2FuX3Jlc3VsdCgKCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgljb25zdCBzdHJ1Y3Qgd3BhX2JzcyAqYnNzLCBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCnsKCWNoYXIgKnBvcywgKmVuZDsKCWludCByZXQ7Cgljb25zdCB1OCAqaWUsICppZTIsICpwMnA7CgoJcDJwID0gd3BhX2Jzc19nZXRfdmVuZG9yX2llKGJzcywgUDJQX0lFX1ZFTkRPUl9UWVBFKTsKCWlmIChwMnAgJiYgYnNzLT5zc2lkX2xlbiA9PSBQMlBfV0lMRENBUkRfU1NJRF9MRU4gJiYKCSAgICBvc19tZW1jbXAoYnNzLT5zc2lkLCBQMlBfV0lMRENBUkRfU1NJRCwgUDJQX1dJTERDQVJEX1NTSURfTEVOKSA9PQoJICAgIDApCgkJcmV0dXJuIDA7IC8qIERvIG5vdCBzaG93IFAyUCBsaXN0ZW4gZGlzY292ZXJ5IHJlc3VsdHMgaGVyZSAqLwoKCXBvcyA9IGJ1ZjsKCWVuZCA9IGJ1ZiArIGJ1ZmxlbjsKCglyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgTUFDU1RSICJcdCVkXHQlZFx0IiwKCQkJICBNQUMyU1RSKGJzcy0+YnNzaWQpLCBic3MtPmZyZXEsIGJzcy0+bGV2ZWwpOwoJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQlyZXR1cm4gLTE7Cglwb3MgKz0gcmV0OwoJaWUgPSB3cGFfYnNzX2dldF92ZW5kb3JfaWUoYnNzLCBXUEFfSUVfVkVORE9SX1RZUEUpOwoJaWYgKGllKQoJCXBvcyA9IHdwYV9zdXBwbGljYW50X2llX3R4dChwb3MsIGVuZCwgIldQQSIsIGllLCAyICsgaWVbMV0pOwoJaWUyID0gd3BhX2Jzc19nZXRfaWUoYnNzLCBXTEFOX0VJRF9SU04pOwoJaWYgKGllMikKCQlwb3MgPSB3cGFfc3VwcGxpY2FudF9pZV90eHQocG9zLCBlbmQsICJXUEEyIiwgaWUyLCAyICsgaWUyWzFdKTsKCXBvcyA9IHdwYV9zdXBwbGljYW50X3dwc19pZV90eHQod3BhX3MsIHBvcywgZW5kLCBic3MpOwoJaWYgKCFpZSAmJiAhaWUyICYmIGJzcy0+Y2FwcyAmIElFRUU4MDIxMV9DQVBfUFJJVkFDWSkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiW1dFUF0iKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gLTE7CgkJcG9zICs9IHJldDsKCX0KCWlmIChic3MtPmNhcHMgJiBJRUVFODAyMTFfQ0FQX0lCU1MpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIltJQlNTXSIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiAtMTsKCQlwb3MgKz0gcmV0OwoJfQoJaWYgKGJzcy0+Y2FwcyAmIElFRUU4MDIxMV9DQVBfRVNTKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJbRVNTXSIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiAtMTsKCQlwb3MgKz0gcmV0OwoJfQoJaWYgKHAycCkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiW1AyUF0iKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gLTE7CgkJcG9zICs9IHJldDsKCX0KI2lmZGVmIENPTkZJR19IUzIwCglpZiAod3BhX2Jzc19nZXRfdmVuZG9yX2llKGJzcywgSFMyMF9JRV9WRU5ET1JfVFlQRSkgJiYgaWUyKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJbSFMyMF0iKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gLTE7CgkJcG9zICs9IHJldDsKCX0KI2VuZGlmIC8qIENPTkZJR19IUzIwICovCgoJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJcdCVzIiwKCQkJICB3cGFfc3NpZF90eHQoYnNzLT5zc2lkLCBic3MtPnNzaWRfbGVuKSk7CglpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCXJldHVybiAtMTsKCXBvcyArPSByZXQ7CgoJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJcbiIpOwoJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQlyZXR1cm4gLTE7Cglwb3MgKz0gcmV0OwoKCXJldHVybiBwb3MgLSBidWY7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2Nhbl9yZXN1bHRzKAoJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQp7CgljaGFyICpwb3MsICplbmQ7CglzdHJ1Y3Qgd3BhX2JzcyAqYnNzOwoJaW50IHJldDsKCglwb3MgPSBidWY7CgllbmQgPSBidWYgKyBidWZsZW47CglyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgImJzc2lkIC8gZnJlcXVlbmN5IC8gc2lnbmFsIGxldmVsIC8gIgoJCQkgICJmbGFncyAvIHNzaWRcbiIpOwoJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQlyZXR1cm4gcG9zIC0gYnVmOwoJcG9zICs9IHJldDsKCglkbF9saXN0X2Zvcl9lYWNoKGJzcywgJndwYV9zLT5ic3NfaWQsIHN0cnVjdCB3cGFfYnNzLCBsaXN0X2lkKSB7CgkJcmV0ID0gd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9zY2FuX3Jlc3VsdCh3cGFfcywgYnNzLCBwb3MsCgkJCQkJCQkgICAgZW5kIC0gcG9zKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zIC0gYnVmOwoJCXBvcyArPSByZXQ7Cgl9CgoJcmV0dXJuIHBvcyAtIGJ1ZjsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9zZWxlY3RfbmV0d29yaygKCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKewoJaW50IGlkOwoJc3RydWN0IHdwYV9zc2lkICpzc2lkOwoKCS8qIGNtZDogIjxuZXR3b3JrIGlkPiIgb3IgImFueSIgKi8KCWlmIChvc19zdHJjbXAoY21kLCAiYW55IikgPT0gMCkgewoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogU0VMRUNUX05FVFdPUksgYW55Iik7CgkJc3NpZCA9IE5VTEw7Cgl9IGVsc2UgewoJCWlkID0gYXRvaShjbWQpOwoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogU0VMRUNUX05FVFdPUksgaWQ9JWQiLCBpZCk7CgoJCXNzaWQgPSB3cGFfY29uZmlnX2dldF9uZXR3b3JrKHdwYV9zLT5jb25mLCBpZCk7CgkJaWYgKHNzaWQgPT0gTlVMTCkgewoJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IENvdWxkIG5vdCBmaW5kICIKCQkJCSAgICJuZXR3b3JrIGlkPSVkIiwgaWQpOwoJCQlyZXR1cm4gLTE7CgkJfQoJCWlmIChzc2lkLT5kaXNhYmxlZCA9PSAyKSB7CgkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogQ2Fubm90IHVzZSAiCgkJCQkgICAiU0VMRUNUX05FVFdPUksgd2l0aCBwZXJzaXN0ZW50IFAyUCBncm91cCIpOwoJCQlyZXR1cm4gLTE7CgkJfQoJfQoKCXdwYV9zdXBwbGljYW50X3NlbGVjdF9uZXR3b3JrKHdwYV9zLCBzc2lkKTsKCglyZXR1cm4gMDsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9lbmFibGVfbmV0d29yaygKCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKewoJaW50IGlkOwoJc3RydWN0IHdwYV9zc2lkICpzc2lkOwoKCS8qIGNtZDogIjxuZXR3b3JrIGlkPiIgb3IgImFsbCIgKi8KCWlmIChvc19zdHJjbXAoY21kLCAiYWxsIikgPT0gMCkgewoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogRU5BQkxFX05FVFdPUksgYWxsIik7CgkJc3NpZCA9IE5VTEw7Cgl9IGVsc2UgewoJCWlkID0gYXRvaShjbWQpOwoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogRU5BQkxFX05FVFdPUksgaWQ9JWQiLCBpZCk7CgoJCXNzaWQgPSB3cGFfY29uZmlnX2dldF9uZXR3b3JrKHdwYV9zLT5jb25mLCBpZCk7CgkJaWYgKHNzaWQgPT0gTlVMTCkgewoJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IENvdWxkIG5vdCBmaW5kICIKCQkJCSAgICJuZXR3b3JrIGlkPSVkIiwgaWQpOwoJCQlyZXR1cm4gLTE7CgkJfQoJCWlmIChzc2lkLT5kaXNhYmxlZCA9PSAyKSB7CgkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogQ2Fubm90IHVzZSAiCgkJCQkgICAiRU5BQkxFX05FVFdPUksgd2l0aCBwZXJzaXN0ZW50IFAyUCBncm91cCIpOwoJCQlyZXR1cm4gLTE7CgkJfQoKCQlpZiAob3Nfc3Ryc3RyKGNtZCwgIiBuby1jb25uZWN0IikpIHsKCQkJc3NpZC0+ZGlzYWJsZWQgPSAwOwoJCQlyZXR1cm4gMDsKCQl9Cgl9Cgl3cGFfc3VwcGxpY2FudF9lbmFibGVfbmV0d29yayh3cGFfcywgc3NpZCk7CgoJcmV0dXJuIDA7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfZGlzYWJsZV9uZXR3b3JrKAoJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kKQp7CglpbnQgaWQ7CglzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CgoJLyogY21kOiAiPG5ldHdvcmsgaWQ+IiBvciAiYWxsIiAqLwoJaWYgKG9zX3N0cmNtcChjbWQsICJhbGwiKSA9PSAwKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBESVNBQkxFX05FVFdPUksgYWxsIik7CgkJc3NpZCA9IE5VTEw7Cgl9IGVsc2UgewoJCWlkID0gYXRvaShjbWQpOwoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogRElTQUJMRV9ORVRXT1JLIGlkPSVkIiwgaWQpOwoKCQlzc2lkID0gd3BhX2NvbmZpZ19nZXRfbmV0d29yayh3cGFfcy0+Y29uZiwgaWQpOwoJCWlmIChzc2lkID09IE5VTEwpIHsKCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBDb3VsZCBub3QgZmluZCAiCgkJCQkgICAibmV0d29yayBpZD0lZCIsIGlkKTsKCQkJcmV0dXJuIC0xOwoJCX0KCQlpZiAoc3NpZC0+ZGlzYWJsZWQgPT0gMikgewoJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IENhbm5vdCB1c2UgIgoJCQkJICAgIkRJU0FCTEVfTkVUV09SSyB3aXRoIHBlcnNpc3RlbnQgUDJQICIKCQkJCSAgICJncm91cCIpOwoJCQlyZXR1cm4gLTE7CgkJfQoJfQoJd3BhX3N1cHBsaWNhbnRfZGlzYWJsZV9uZXR3b3JrKHdwYV9zLCBzc2lkKTsKCglyZXR1cm4gMDsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9hZGRfbmV0d29yaygKCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKewoJc3RydWN0IHdwYV9zc2lkICpzc2lkOwoJaW50IHJldDsKCgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IEFERF9ORVRXT1JLIik7CgoJc3NpZCA9IHdwYV9jb25maWdfYWRkX25ldHdvcmsod3BhX3MtPmNvbmYpOwoJaWYgKHNzaWQgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgoJd3Bhc19ub3RpZnlfbmV0d29ya19hZGRlZCh3cGFfcywgc3NpZCk7CgoJc3NpZC0+ZGlzYWJsZWQgPSAxOwoJd3BhX2NvbmZpZ19zZXRfbmV0d29ya19kZWZhdWx0cyhzc2lkKTsKCglyZXQgPSBvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIiVkXG4iLCBzc2lkLT5pZCk7CglpZiAocmV0IDwgMCB8fCAoc2l6ZV90KSByZXQgPj0gYnVmbGVuKQoJCXJldHVybiAtMTsKCXJldHVybiByZXQ7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfcmVtb3ZlX25ldHdvcmsoCglzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCnsKCWludCBpZDsKCXN0cnVjdCB3cGFfc3NpZCAqc3NpZDsKCWludCB3YXNfZGlzYWJsZWQ7CgoJLyogY21kOiAiPG5ldHdvcmsgaWQ+IiBvciAiYWxsIiAqLwoJaWYgKG9zX3N0cmNtcChjbWQsICJhbGwiKSA9PSAwKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBSRU1PVkVfTkVUV09SSyBhbGwiKTsKCQlpZiAod3BhX3MtPnNjaGVkX3NjYW5uaW5nKQoJCQl3cGFfc3VwcGxpY2FudF9jYW5jZWxfc2NoZWRfc2Nhbih3cGFfcyk7CgoJCWVhcG9sX3NtX2ludmFsaWRhdGVfY2FjaGVkX3Nlc3Npb24od3BhX3MtPmVhcG9sKTsKCQlpZiAod3BhX3MtPmN1cnJlbnRfc3NpZCkgewojaWZkZWYgQ09ORklHX1NNRQoJCQl3cGFfcy0+c21lLnByZXZfYnNzaWRfc2V0ID0gMDsKI2VuZGlmIC8qIENPTkZJR19TTUUgKi8KCQkJd3BhX3NtX3NldF9jb25maWcod3BhX3MtPndwYSwgTlVMTCk7CgkJCWVhcG9sX3NtX25vdGlmeV9jb25maWcod3BhX3MtPmVhcG9sLCBOVUxMLCBOVUxMKTsKCQkJd3BhX3N1cHBsaWNhbnRfZGVhdXRoZW50aWNhdGUoCgkJCQl3cGFfcywgV0xBTl9SRUFTT05fREVBVVRIX0xFQVZJTkcpOwoJCX0KCQlzc2lkID0gd3BhX3MtPmNvbmYtPnNzaWQ7CgkJd2hpbGUgKHNzaWQpIHsKCQkJc3RydWN0IHdwYV9zc2lkICpyZW1vdmVfc3NpZCA9IHNzaWQ7CgkJCWlkID0gc3NpZC0+aWQ7CgkJCXNzaWQgPSBzc2lkLT5uZXh0OwoJCQl3cGFzX25vdGlmeV9uZXR3b3JrX3JlbW92ZWQod3BhX3MsIHJlbW92ZV9zc2lkKTsKCQkJd3BhX2NvbmZpZ19yZW1vdmVfbmV0d29yayh3cGFfcy0+Y29uZiwgaWQpOwoJCX0KCQlyZXR1cm4gMDsKCX0KCglpZCA9IGF0b2koY21kKTsKCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogUkVNT1ZFX05FVFdPUksgaWQ9JWQiLCBpZCk7CgoJc3NpZCA9IHdwYV9jb25maWdfZ2V0X25ldHdvcmsod3BhX3MtPmNvbmYsIGlkKTsKCWlmIChzc2lkKQoJCXdwYXNfbm90aWZ5X25ldHdvcmtfcmVtb3ZlZCh3cGFfcywgc3NpZCk7CglpZiAoc3NpZCA9PSBOVUxMKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBDb3VsZCBub3QgZmluZCBuZXR3b3JrICIKCQkJICAgImlkPSVkIiwgaWQpOwoJCXJldHVybiAtMTsKCX0KCglpZiAoc3NpZCA9PSB3cGFfcy0+Y3VycmVudF9zc2lkIHx8IHdwYV9zLT5jdXJyZW50X3NzaWQgPT0gTlVMTCkgewojaWZkZWYgQ09ORklHX1NNRQoJCXdwYV9zLT5zbWUucHJldl9ic3NpZF9zZXQgPSAwOwojZW5kaWYgLyogQ09ORklHX1NNRSAqLwoJCS8qCgkJICogSW52YWxpZGF0ZSB0aGUgRUFQIHNlc3Npb24gY2FjaGUgaWYgdGhlIGN1cnJlbnQgb3IKCQkgKiBwcmV2aW91c2x5IHVzZWQgbmV0d29yayBpcyByZW1vdmVkLgoJCSAqLwoJCWVhcG9sX3NtX2ludmFsaWRhdGVfY2FjaGVkX3Nlc3Npb24od3BhX3MtPmVhcG9sKTsKCX0KCglpZiAoc3NpZCA9PSB3cGFfcy0+Y3VycmVudF9zc2lkKSB7CgkJd3BhX3NtX3NldF9jb25maWcod3BhX3MtPndwYSwgTlVMTCk7CgkJZWFwb2xfc21fbm90aWZ5X2NvbmZpZyh3cGFfcy0+ZWFwb2wsIE5VTEwsIE5VTEwpOwoKCQl3cGFfc3VwcGxpY2FudF9kZWF1dGhlbnRpY2F0ZSh3cGFfcywKCQkJCQkgICAgICBXTEFOX1JFQVNPTl9ERUFVVEhfTEVBVklORyk7Cgl9CgoJd2FzX2Rpc2FibGVkID0gc3NpZC0+ZGlzYWJsZWQ7CgoJaWYgKHdwYV9jb25maWdfcmVtb3ZlX25ldHdvcmsod3BhX3MtPmNvbmYsIGlkKSA8IDApIHsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IE5vdCBhYmxlIHRvIHJlbW92ZSB0aGUgIgoJCQkgICAibmV0d29yayBpZD0lZCIsIGlkKTsKCQlyZXR1cm4gLTE7Cgl9CgoJaWYgKCF3YXNfZGlzYWJsZWQgJiYgd3BhX3MtPnNjaGVkX3NjYW5uaW5nKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTdG9wIG9uZ29pbmcgc2NoZWRfc2NhbiB0byByZW1vdmUgIgoJCQkgICAibmV0d29yayBmcm9tIGZpbHRlcnMiKTsKCQl3cGFfc3VwcGxpY2FudF9jYW5jZWxfc2NoZWRfc2Nhbih3cGFfcyk7CgkJd3BhX3N1cHBsaWNhbnRfcmVxX3NjYW4od3BhX3MsIDAsIDApOwoJfQoKCXJldHVybiAwOwp9CgoKc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3NldF9uZXR3b3JrKAoJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kKQp7CglpbnQgaWQ7CglzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CgljaGFyICpuYW1lLCAqdmFsdWU7CgoJLyogY21kOiAiPG5ldHdvcmsgaWQ+IDx2YXJpYWJsZSBuYW1lPiA8dmFsdWU+IiAqLwoJbmFtZSA9IG9zX3N0cmNocihjbWQsICcgJyk7CglpZiAobmFtZSA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSpuYW1lKysgPSAnXDAnOwoKCXZhbHVlID0gb3Nfc3RyY2hyKG5hbWUsICcgJyk7CglpZiAodmFsdWUgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgkqdmFsdWUrKyA9ICdcMCc7CgoJaWQgPSBhdG9pKGNtZCk7Cgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IFNFVF9ORVRXT1JLIGlkPSVkIG5hbWU9JyVzJyIsCgkJICAgaWQsIG5hbWUpOwoJd3BhX2hleGR1bXBfYXNjaWlfa2V5KE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IHZhbHVlIiwKCQkJICAgICAgKHU4ICopIHZhbHVlLCBvc19zdHJsZW4odmFsdWUpKTsKCglzc2lkID0gd3BhX2NvbmZpZ19nZXRfbmV0d29yayh3cGFfcy0+Y29uZiwgaWQpOwoJaWYgKHNzaWQgPT0gTlVMTCkgewoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogQ291bGQgbm90IGZpbmQgbmV0d29yayAiCgkJCSAgICJpZD0lZCIsIGlkKTsKCQlyZXR1cm4gLTE7Cgl9CgoJaWYgKHdwYV9jb25maWdfc2V0KHNzaWQsIG5hbWUsIHZhbHVlLCAwKSA8IDApIHsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IEZhaWxlZCB0byBzZXQgbmV0d29yayAiCgkJCSAgICJ2YXJpYWJsZSAnJXMnIiwgbmFtZSk7CgkJcmV0dXJuIC0xOwoJfQoKCWlmIChvc19zdHJjbXAobmFtZSwgImJzc2lkIikgIT0gMCAmJgoJICAgIG9zX3N0cmNtcChuYW1lLCAicHJpb3JpdHkiKSAhPSAwKQoJCXdwYV9zbV9wbWtzYV9jYWNoZV9mbHVzaCh3cGFfcy0+d3BhLCBzc2lkKTsKCglpZiAod3BhX3MtPmN1cnJlbnRfc3NpZCA9PSBzc2lkIHx8IHdwYV9zLT5jdXJyZW50X3NzaWQgPT0gTlVMTCkgewoJCS8qCgkJICogSW52YWxpZGF0ZSB0aGUgRUFQIHNlc3Npb24gY2FjaGUgaWYgYW55dGhpbmcgaW4gdGhlIGN1cnJlbnQKCQkgKiBvciBwcmV2aW91c2x5IHVzZWQgY29uZmlndXJhdGlvbiBjaGFuZ2VzLgoJCSAqLwoJCWVhcG9sX3NtX2ludmFsaWRhdGVfY2FjaGVkX3Nlc3Npb24od3BhX3MtPmVhcG9sKTsKCX0KCglpZiAoKG9zX3N0cmNtcChuYW1lLCAicHNrIikgPT0gMCAmJgoJICAgICB2YWx1ZVswXSA9PSAnIicgJiYgc3NpZC0+c3NpZF9sZW4pIHx8CgkgICAgKG9zX3N0cmNtcChuYW1lLCAic3NpZCIpID09IDAgJiYgc3NpZC0+cGFzc3BocmFzZSkpCgkJd3BhX2NvbmZpZ191cGRhdGVfcHNrKHNzaWQpOwoJZWxzZSBpZiAob3Nfc3RyY21wKG5hbWUsICJwcmlvcml0eSIpID09IDApCgkJd3BhX2NvbmZpZ191cGRhdGVfcHJpb19saXN0KHdwYV9zLT5jb25mKTsKCglyZXR1cm4gMDsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9nZXRfbmV0d29yaygKCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCwgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQp7CglpbnQgaWQ7CglzaXplX3QgcmVzOwoJc3RydWN0IHdwYV9zc2lkICpzc2lkOwoJY2hhciAqbmFtZSwgKnZhbHVlOwoKCS8qIGNtZDogIjxuZXR3b3JrIGlkPiA8dmFyaWFibGUgbmFtZT4iICovCgluYW1lID0gb3Nfc3RyY2hyKGNtZCwgJyAnKTsKCWlmIChuYW1lID09IE5VTEwgfHwgYnVmbGVuID09IDApCgkJcmV0dXJuIC0xOwoJKm5hbWUrKyA9ICdcMCc7CgoJaWQgPSBhdG9pKGNtZCk7Cgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IEdFVF9ORVRXT1JLIGlkPSVkIG5hbWU9JyVzJyIsCgkJICAgaWQsIG5hbWUpOwoKCXNzaWQgPSB3cGFfY29uZmlnX2dldF9uZXR3b3JrKHdwYV9zLT5jb25mLCBpZCk7CglpZiAoc3NpZCA9PSBOVUxMKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBDb3VsZCBub3QgZmluZCBuZXR3b3JrICIKCQkJICAgImlkPSVkIiwgaWQpOwoJCXJldHVybiAtMTsKCX0KCgl2YWx1ZSA9IHdwYV9jb25maWdfZ2V0X25vX2tleShzc2lkLCBuYW1lKTsKCWlmICh2YWx1ZSA9PSBOVUxMKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBGYWlsZWQgdG8gZ2V0IG5ldHdvcmsgIgoJCQkgICAidmFyaWFibGUgJyVzJyIsIG5hbWUpOwoJCXJldHVybiAtMTsKCX0KCglyZXMgPSBvc19zdHJsY3B5KGJ1ZiwgdmFsdWUsIGJ1Zmxlbik7CglpZiAocmVzID49IGJ1ZmxlbikgewoJCW9zX2ZyZWUodmFsdWUpOwoJCXJldHVybiAtMTsKCX0KCglvc19mcmVlKHZhbHVlKTsKCglyZXR1cm4gcmVzOwp9CgoKc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2xpc3RfY3JlZHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKCQkJCQkJY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQp7CgljaGFyICpwb3MsICplbmQ7CglzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQ7CglpbnQgcmV0OwoKCXBvcyA9IGJ1ZjsKCWVuZCA9IGJ1ZiArIGJ1ZmxlbjsKCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLAoJCQkgICJjcmVkIGlkIC8gcmVhbG0gLyB1c2VybmFtZSAvIGRvbWFpbiAvIGltc2lcbiIpOwoJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQlyZXR1cm4gcG9zIC0gYnVmOwoJcG9zICs9IHJldDsKCgljcmVkID0gd3BhX3MtPmNvbmYtPmNyZWQ7Cgl3aGlsZSAoY3JlZCkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJWRcdCVzXHQlc1x0JXNcdCVzXG4iLAoJCQkJICBjcmVkLT5pZCwgY3JlZC0+cmVhbG0gPyBjcmVkLT5yZWFsbSA6ICIiLAoJCQkJICBjcmVkLT51c2VybmFtZSA/IGNyZWQtPnVzZXJuYW1lIDogIiIsCgkJCQkgIGNyZWQtPmRvbWFpbiA/IGNyZWQtPmRvbWFpbiA6ICIiLAoJCQkJICBjcmVkLT5pbXNpID8gY3JlZC0+aW1zaSA6ICIiKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zIC0gYnVmOwoJCXBvcyArPSByZXQ7CgoJCWNyZWQgPSBjcmVkLT5uZXh0OwoJfQoKCXJldHVybiBwb3MgLSBidWY7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfYWRkX2NyZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKCQkJCQkgICAgICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCnsKCXN0cnVjdCB3cGFfY3JlZCAqY3JlZDsKCWludCByZXQ7CgoJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBBRERfQ1JFRCIpOwoKCWNyZWQgPSB3cGFfY29uZmlnX2FkZF9jcmVkKHdwYV9zLT5jb25mKTsKCWlmIChjcmVkID09IE5VTEwpCgkJcmV0dXJuIC0xOwoKCXJldCA9IG9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLCAiJWRcbiIsIGNyZWQtPmlkKTsKCWlmIChyZXQgPCAwIHx8IChzaXplX3QpIHJldCA+PSBidWZsZW4pCgkJcmV0dXJuIC0xOwoJcmV0dXJuIHJldDsKfQoKCnN0YXRpYyBpbnQgd3Bhc19jdHJsX3JlbW92ZV9jcmVkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkgc3RydWN0IHdwYV9jcmVkICpjcmVkKQp7CglzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CgljaGFyIHN0clsyMF07CgoJaWYgKGNyZWQgPT0gTlVMTCB8fCB3cGFfY29uZmlnX3JlbW92ZV9jcmVkKHdwYV9zLT5jb25mLCBjcmVkLT5pZCkgPCAwKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBDb3VsZCBub3QgZmluZCBjcmVkIik7CgkJcmV0dXJuIC0xOwoJfQoKCS8qIFJlbW92ZSBhbnkgbmV0d29yayBlbnRyeSBjcmVhdGVkIGJhc2VkIG9uIHRoZSByZW1vdmVkIGNyZWRlbnRpYWwgKi8KCXNzaWQgPSB3cGFfcy0+Y29uZi0+c3NpZDsKCXdoaWxlIChzc2lkKSB7CgkJaWYgKHNzaWQtPnBhcmVudF9jcmVkID09IGNyZWQpIHsKCQkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJSZW1vdmUgbmV0d29yayBpZCAlZCBzaW5jZSBpdCAiCgkJCQkgICAidXNlZCB0aGUgcmVtb3ZlZCBjcmVkZW50aWFsIiwgc3NpZC0+aWQpOwoJCQlvc19zbnByaW50ZihzdHIsIHNpemVvZihzdHIpLCAiJWQiLCBzc2lkLT5pZCk7CgkJCXNzaWQgPSBzc2lkLT5uZXh0OwoJCQl3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3JlbW92ZV9uZXR3b3JrKHdwYV9zLCBzdHIpOwoJCX0gZWxzZQoJCQlzc2lkID0gc3NpZC0+bmV4dDsKCX0KCglyZXR1cm4gMDsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9yZW1vdmVfY3JlZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAoJCQkJCQkgY2hhciAqY21kKQp7CglpbnQgaWQ7CglzdHJ1Y3Qgd3BhX2NyZWQgKmNyZWQsICpwcmV2OwoKCS8qIGNtZDogIjxjcmVkIGlkPiIsICJhbGwiLCBvciAic3BfZnFkbj08RlFETj4iICovCglpZiAob3Nfc3RyY21wKGNtZCwgImFsbCIpID09IDApIHsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IFJFTU9WRV9DUkVEIGFsbCIpOwoJCWNyZWQgPSB3cGFfcy0+Y29uZi0+Y3JlZDsKCQl3aGlsZSAoY3JlZCkgewoJCQlwcmV2ID0gY3JlZDsKCQkJY3JlZCA9IGNyZWQtPm5leHQ7CgkJCXdwYXNfY3RybF9yZW1vdmVfY3JlZCh3cGFfcywgcHJldik7CgkJfQoJCXJldHVybiAwOwoJfQoKCWlmIChvc19zdHJuY21wKGNtZCwgInNwX2ZxZG49IiwgOCkgPT0gMCkgewoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogUkVNT1ZFX0NSRUQgU1AgRlFETiAnJXMnIiwKCQkJICAgY21kICsgOCk7CgkJY3JlZCA9IHdwYV9zLT5jb25mLT5jcmVkOwoJCXdoaWxlIChjcmVkKSB7CgkJCXByZXYgPSBjcmVkOwoJCQljcmVkID0gY3JlZC0+bmV4dDsKCQkJaWYgKHByZXYtPmRvbWFpbiAmJgoJCQkgICAgb3Nfc3RyY21wKHByZXYtPmRvbWFpbiwgY21kICsgOCkgPT0gMCkKCQkJCXdwYXNfY3RybF9yZW1vdmVfY3JlZCh3cGFfcywgcHJldik7CgkJfQoJCXJldHVybiAwOwoJfQoKCWlkID0gYXRvaShjbWQpOwoJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBSRU1PVkVfQ1JFRCBpZD0lZCIsIGlkKTsKCgljcmVkID0gd3BhX2NvbmZpZ19nZXRfY3JlZCh3cGFfcy0+Y29uZiwgaWQpOwoJcmV0dXJuIHdwYXNfY3RybF9yZW1vdmVfY3JlZCh3cGFfcywgY3JlZCk7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2V0X2NyZWQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKCQkJCQkgICAgICBjaGFyICpjbWQpCnsKCWludCBpZDsKCXN0cnVjdCB3cGFfY3JlZCAqY3JlZDsKCWNoYXIgKm5hbWUsICp2YWx1ZTsKCgkvKiBjbWQ6ICI8Y3JlZCBpZD4gPHZhcmlhYmxlIG5hbWU+IDx2YWx1ZT4iICovCgluYW1lID0gb3Nfc3RyY2hyKGNtZCwgJyAnKTsKCWlmIChuYW1lID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJKm5hbWUrKyA9ICdcMCc7CgoJdmFsdWUgPSBvc19zdHJjaHIobmFtZSwgJyAnKTsKCWlmICh2YWx1ZSA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSp2YWx1ZSsrID0gJ1wwJzsKCglpZCA9IGF0b2koY21kKTsKCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogU0VUX0NSRUQgaWQ9JWQgbmFtZT0nJXMnIiwKCQkgICBpZCwgbmFtZSk7Cgl3cGFfaGV4ZHVtcF9hc2NpaV9rZXkoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogdmFsdWUiLAoJCQkgICAgICAodTggKikgdmFsdWUsIG9zX3N0cmxlbih2YWx1ZSkpOwoKCWNyZWQgPSB3cGFfY29uZmlnX2dldF9jcmVkKHdwYV9zLT5jb25mLCBpZCk7CglpZiAoY3JlZCA9PSBOVUxMKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBDb3VsZCBub3QgZmluZCBjcmVkIGlkPSVkIiwKCQkJICAgaWQpOwoJCXJldHVybiAtMTsKCX0KCglpZiAod3BhX2NvbmZpZ19zZXRfY3JlZChjcmVkLCBuYW1lLCB2YWx1ZSwgMCkgPCAwKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBGYWlsZWQgdG8gc2V0IGNyZWQgIgoJCQkgICAidmFyaWFibGUgJyVzJyIsIG5hbWUpOwoJCXJldHVybiAtMTsKCX0KCglyZXR1cm4gMDsKfQoKCiNpZm5kZWYgQ09ORklHX05PX0NPTkZJR19XUklURQpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2F2ZV9jb25maWcoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcykKewoJaW50IHJldDsKCglpZiAoIXdwYV9zLT5jb25mLT51cGRhdGVfY29uZmlnKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBTQVZFX0NPTkZJRyAtIE5vdCBhbGxvd2VkICIKCQkJICAgInRvIHVwZGF0ZSBjb25maWd1cmF0aW9uICh1cGRhdGVfY29uZmlnPTApIik7CgkJcmV0dXJuIC0xOwoJfQoKCXJldCA9IHdwYV9jb25maWdfd3JpdGUod3BhX3MtPmNvbmZuYW1lLCB3cGFfcy0+Y29uZik7CglpZiAocmV0KSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBTQVZFX0NPTkZJRyAtIEZhaWxlZCB0byAiCgkJCSAgICJ1cGRhdGUgY29uZmlndXJhdGlvbiIpOwoJfSBlbHNlIHsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IFNBVkVfQ09ORklHIC0gQ29uZmlndXJhdGlvbiIKCQkJICAgIiB1cGRhdGVkIik7Cgl9CgoJcmV0dXJuIHJldDsKfQojZW5kaWYgLyogQ09ORklHX05PX0NPTkZJR19XUklURSAqLwoKCnN0YXRpYyBpbnQgY3RybF9pZmFjZV9nZXRfY2FwYWJpbGl0eV9wYWlyd2lzZShpbnQgcmVzLCBjaGFyICpzdHJpY3QsCgkJCQkJICAgICAgc3RydWN0IHdwYV9kcml2ZXJfY2FwYSAqY2FwYSwKCQkJCQkgICAgICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCnsKCWludCByZXQsIGZpcnN0ID0gMTsKCWNoYXIgKnBvcywgKmVuZDsKCXNpemVfdCBsZW47CgoJcG9zID0gYnVmOwoJZW5kID0gcG9zICsgYnVmbGVuOwoKCWlmIChyZXMgPCAwKSB7CgkJaWYgKHN0cmljdCkKCQkJcmV0dXJuIDA7CgkJbGVuID0gb3Nfc3RybGNweShidWYsICJDQ01QIFRLSVAgTk9ORSIsIGJ1Zmxlbik7CgkJaWYgKGxlbiA+PSBidWZsZW4pCgkJCXJldHVybiAtMTsKCQlyZXR1cm4gbGVuOwoJfQoKCWlmIChjYXBhLT5lbmMgJiBXUEFfRFJJVkVSX0NBUEFfRU5DX0NDTVApIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzQ0NNUCIsIGZpcnN0ID8gIiIgOiAiICIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCQlmaXJzdCA9IDA7Cgl9CgoJaWYgKGNhcGEtPmVuYyAmIFdQQV9EUklWRVJfQ0FQQV9FTkNfR0NNUCkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNHQ01QIiwgZmlyc3QgPyAiIiA6ICIgIik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQlwb3MgKz0gcmV0OwoJCWZpcnN0ID0gMDsKCX0KCglpZiAoY2FwYS0+ZW5jICYgV1BBX0RSSVZFUl9DQVBBX0VOQ19US0lQKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc1RLSVAiLCBmaXJzdCA/ICIiIDogIiAiKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zIC0gYnVmOwoJCXBvcyArPSByZXQ7CgkJZmlyc3QgPSAwOwoJfQoKCWlmIChjYXBhLT5rZXlfbWdtdCAmIFdQQV9EUklWRVJfQ0FQQV9LRVlfTUdNVF9XUEFfTk9ORSkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNOT05FIiwgZmlyc3QgPyAiIiA6ICIgIik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQlwb3MgKz0gcmV0OwoJCWZpcnN0ID0gMDsKCX0KCglyZXR1cm4gcG9zIC0gYnVmOwp9CgoKc3RhdGljIGludCBjdHJsX2lmYWNlX2dldF9jYXBhYmlsaXR5X2dyb3VwKGludCByZXMsIGNoYXIgKnN0cmljdCwKCQkJCQkgICBzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhICpjYXBhLAoJCQkJCSAgIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKewoJaW50IHJldCwgZmlyc3QgPSAxOwoJY2hhciAqcG9zLCAqZW5kOwoJc2l6ZV90IGxlbjsKCglwb3MgPSBidWY7CgllbmQgPSBwb3MgKyBidWZsZW47CgoJaWYgKHJlcyA8IDApIHsKCQlpZiAoc3RyaWN0KQoJCQlyZXR1cm4gMDsKCQlsZW4gPSBvc19zdHJsY3B5KGJ1ZiwgIkNDTVAgVEtJUCBXRVAxMDQgV0VQNDAiLCBidWZsZW4pOwoJCWlmIChsZW4gPj0gYnVmbGVuKQoJCQlyZXR1cm4gLTE7CgkJcmV0dXJuIGxlbjsKCX0KCglpZiAoY2FwYS0+ZW5jICYgV1BBX0RSSVZFUl9DQVBBX0VOQ19DQ01QKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc0NDTVAiLCBmaXJzdCA/ICIiIDogIiAiKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zIC0gYnVmOwoJCXBvcyArPSByZXQ7CgkJZmlyc3QgPSAwOwoJfQoKCWlmIChjYXBhLT5lbmMgJiBXUEFfRFJJVkVSX0NBUEFfRU5DX0dDTVApIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzR0NNUCIsIGZpcnN0ID8gIiIgOiAiICIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCQlmaXJzdCA9IDA7Cgl9CgoJaWYgKGNhcGEtPmVuYyAmIFdQQV9EUklWRVJfQ0FQQV9FTkNfVEtJUCkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNUS0lQIiwgZmlyc3QgPyAiIiA6ICIgIik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQlwb3MgKz0gcmV0OwoJCWZpcnN0ID0gMDsKCX0KCglpZiAoY2FwYS0+ZW5jICYgV1BBX0RSSVZFUl9DQVBBX0VOQ19XRVAxMDQpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzV0VQMTA0IiwKCQkJCSAgZmlyc3QgPyAiIiA6ICIgIik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQlwb3MgKz0gcmV0OwoJCWZpcnN0ID0gMDsKCX0KCglpZiAoY2FwYS0+ZW5jICYgV1BBX0RSSVZFUl9DQVBBX0VOQ19XRVA0MCkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJXNXRVA0MCIsIGZpcnN0ID8gIiIgOiAiICIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCQlmaXJzdCA9IDA7Cgl9CgoJcmV0dXJuIHBvcyAtIGJ1ZjsKfQoKCnN0YXRpYyBpbnQgY3RybF9pZmFjZV9nZXRfY2FwYWJpbGl0eV9rZXlfbWdtdChpbnQgcmVzLCBjaGFyICpzdHJpY3QsCgkJCQkJICAgICAgc3RydWN0IHdwYV9kcml2ZXJfY2FwYSAqY2FwYSwKCQkJCQkgICAgICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCnsKCWludCByZXQ7CgljaGFyICpwb3MsICplbmQ7CglzaXplX3QgbGVuOwoKCXBvcyA9IGJ1ZjsKCWVuZCA9IHBvcyArIGJ1ZmxlbjsKCglpZiAocmVzIDwgMCkgewoJCWlmIChzdHJpY3QpCgkJCXJldHVybiAwOwoJCWxlbiA9IG9zX3N0cmxjcHkoYnVmLCAiV1BBLVBTSyBXUEEtRUFQIElFRUU4MDIxWCBXUEEtTk9ORSAiCgkJCQkgIk5PTkUiLCBidWZsZW4pOwoJCWlmIChsZW4gPj0gYnVmbGVuKQoJCQlyZXR1cm4gLTE7CgkJcmV0dXJuIGxlbjsKCX0KCglyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIk5PTkUgSUVFRTgwMjFYIik7CglpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCXJldHVybiBwb3MgLSBidWY7Cglwb3MgKz0gcmV0OwoKCWlmIChjYXBhLT5rZXlfbWdtdCAmIChXUEFfRFJJVkVSX0NBUEFfS0VZX01HTVRfV1BBIHwKCQkJICAgICAgV1BBX0RSSVZFUl9DQVBBX0tFWV9NR01UX1dQQTIpKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIgV1BBLUVBUCIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCX0KCglpZiAoY2FwYS0+a2V5X21nbXQgJiAoV1BBX0RSSVZFUl9DQVBBX0tFWV9NR01UX1dQQV9QU0sgfAoJCQkgICAgICBXUEFfRFJJVkVSX0NBUEFfS0VZX01HTVRfV1BBMl9QU0spKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIgV1BBLVBTSyIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCX0KCglpZiAoY2FwYS0+a2V5X21nbXQgJiBXUEFfRFJJVkVSX0NBUEFfS0VZX01HTVRfV1BBX05PTkUpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiBXUEEtTk9ORSIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCX0KCglyZXR1cm4gcG9zIC0gYnVmOwp9CgoKc3RhdGljIGludCBjdHJsX2lmYWNlX2dldF9jYXBhYmlsaXR5X3Byb3RvKGludCByZXMsIGNoYXIgKnN0cmljdCwKCQkJCQkgICBzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhICpjYXBhLAoJCQkJCSAgIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKewoJaW50IHJldCwgZmlyc3QgPSAxOwoJY2hhciAqcG9zLCAqZW5kOwoJc2l6ZV90IGxlbjsKCglwb3MgPSBidWY7CgllbmQgPSBwb3MgKyBidWZsZW47CgoJaWYgKHJlcyA8IDApIHsKCQlpZiAoc3RyaWN0KQoJCQlyZXR1cm4gMDsKCQlsZW4gPSBvc19zdHJsY3B5KGJ1ZiwgIlJTTiBXUEEiLCBidWZsZW4pOwoJCWlmIChsZW4gPj0gYnVmbGVuKQoJCQlyZXR1cm4gLTE7CgkJcmV0dXJuIGxlbjsKCX0KCglpZiAoY2FwYS0+a2V5X21nbXQgJiAoV1BBX0RSSVZFUl9DQVBBX0tFWV9NR01UX1dQQTIgfAoJCQkgICAgICBXUEFfRFJJVkVSX0NBUEFfS0VZX01HTVRfV1BBMl9QU0spKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc1JTTiIsIGZpcnN0ID8gIiIgOiAiICIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCQlmaXJzdCA9IDA7Cgl9CgoJaWYgKGNhcGEtPmtleV9tZ210ICYgKFdQQV9EUklWRVJfQ0FQQV9LRVlfTUdNVF9XUEEgfAoJCQkgICAgICBXUEFfRFJJVkVSX0NBUEFfS0VZX01HTVRfV1BBX1BTSykpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzV1BBIiwgZmlyc3QgPyAiIiA6ICIgIik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQlwb3MgKz0gcmV0OwoJCWZpcnN0ID0gMDsKCX0KCglyZXR1cm4gcG9zIC0gYnVmOwp9CgoKc3RhdGljIGludCBjdHJsX2lmYWNlX2dldF9jYXBhYmlsaXR5X2F1dGhfYWxnKGludCByZXMsIGNoYXIgKnN0cmljdCwKCQkJCQkgICAgICBzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhICpjYXBhLAoJCQkJCSAgICAgIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKewoJaW50IHJldCwgZmlyc3QgPSAxOwoJY2hhciAqcG9zLCAqZW5kOwoJc2l6ZV90IGxlbjsKCglwb3MgPSBidWY7CgllbmQgPSBwb3MgKyBidWZsZW47CgoJaWYgKHJlcyA8IDApIHsKCQlpZiAoc3RyaWN0KQoJCQlyZXR1cm4gMDsKCQlsZW4gPSBvc19zdHJsY3B5KGJ1ZiwgIk9QRU4gU0hBUkVEIExFQVAiLCBidWZsZW4pOwoJCWlmIChsZW4gPj0gYnVmbGVuKQoJCQlyZXR1cm4gLTE7CgkJcmV0dXJuIGxlbjsKCX0KCglpZiAoY2FwYS0+YXV0aCAmIChXUEFfRFJJVkVSX0FVVEhfT1BFTikpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzT1BFTiIsIGZpcnN0ID8gIiIgOiAiICIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCQlmaXJzdCA9IDA7Cgl9CgoJaWYgKGNhcGEtPmF1dGggJiAoV1BBX0RSSVZFUl9BVVRIX1NIQVJFRCkpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzU0hBUkVEIiwKCQkJCSAgZmlyc3QgPyAiIiA6ICIgIik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQlwb3MgKz0gcmV0OwoJCWZpcnN0ID0gMDsKCX0KCglpZiAoY2FwYS0+YXV0aCAmIChXUEFfRFJJVkVSX0FVVEhfTEVBUCkpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzTEVBUCIsIGZpcnN0ID8gIiIgOiAiICIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCQlmaXJzdCA9IDA7Cgl9CgoJcmV0dXJuIHBvcyAtIGJ1ZjsKfQoKCnN0YXRpYyBpbnQgY3RybF9pZmFjZV9nZXRfY2FwYWJpbGl0eV9tb2RlcyhpbnQgcmVzLCBjaGFyICpzdHJpY3QsCgkJCQkJICAgc3RydWN0IHdwYV9kcml2ZXJfY2FwYSAqY2FwYSwKCQkJCQkgICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCnsKCWludCByZXQsIGZpcnN0ID0gMTsKCWNoYXIgKnBvcywgKmVuZDsKCXNpemVfdCBsZW47CgoJcG9zID0gYnVmOwoJZW5kID0gcG9zICsgYnVmbGVuOwoKCWlmIChyZXMgPCAwKSB7CgkJaWYgKHN0cmljdCkKCQkJcmV0dXJuIDA7CgkJbGVuID0gb3Nfc3RybGNweShidWYsICJJQlNTIEFQIiwgYnVmbGVuKTsKCQlpZiAobGVuID49IGJ1ZmxlbikKCQkJcmV0dXJuIC0xOwoJCXJldHVybiBsZW47Cgl9CgoJaWYgKGNhcGEtPmZsYWdzICYgV1BBX0RSSVZFUl9GTEFHU19JQlNTKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc0lCU1MiLCBmaXJzdCA/ICIiIDogIiAiKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zIC0gYnVmOwoJCXBvcyArPSByZXQ7CgkJZmlyc3QgPSAwOwoJfQoKCWlmIChjYXBhLT5mbGFncyAmIFdQQV9EUklWRVJfRkxBR1NfQVApIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzQVAiLCBmaXJzdCA/ICIiIDogIiAiKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zIC0gYnVmOwoJCXBvcyArPSByZXQ7CgkJZmlyc3QgPSAwOwoJfQoKCXJldHVybiBwb3MgLSBidWY7Cn0KCgpzdGF0aWMgaW50IGN0cmxfaWZhY2VfZ2V0X2NhcGFiaWxpdHlfY2hhbm5lbHMoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKCQkJCQkgICAgICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCnsKCXN0cnVjdCBob3N0YXBkX2NoYW5uZWxfZGF0YSAqY2hubDsKCWludCByZXQsIGksIGo7CgljaGFyICpwb3MsICplbmQsICpobW9kZTsKCglwb3MgPSBidWY7CgllbmQgPSBwb3MgKyBidWZsZW47CgoJZm9yIChqID0gMDsgaiA8IHdwYV9zLT5ody5udW1fbW9kZXM7IGorKykgewoJCXN3aXRjaCAod3BhX3MtPmh3Lm1vZGVzW2pdLm1vZGUpIHsKCQljYXNlIEhPU1RBUERfTU9ERV9JRUVFODAyMTFCOgoJCQlobW9kZSA9ICJCIjsKCQkJYnJlYWs7CgkJY2FzZSBIT1NUQVBEX01PREVfSUVFRTgwMjExRzoKCQkJaG1vZGUgPSAiRyI7CgkJCWJyZWFrOwoJCWNhc2UgSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUE6CgkJCWhtb2RlID0gIkEiOwoJCQlicmVhazsKCQljYXNlIEhPU1RBUERfTU9ERV9JRUVFODAyMTFBRDoKCQkJaG1vZGUgPSAiQUQiOwoJCQlicmVhazsKCQlkZWZhdWx0OgoJCQljb250aW51ZTsKCQl9CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJNb2RlWyVzXSBDaGFubmVsczoiLCBobW9kZSk7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQlwb3MgKz0gcmV0OwoJCWNobmwgPSB3cGFfcy0+aHcubW9kZXNbal0uY2hhbm5lbHM7CgkJZm9yIChpID0gMDsgaSA8IHdwYV9zLT5ody5tb2Rlc1tqXS5udW1fY2hhbm5lbHM7IGkrKykgewoJCQlpZiAoY2hubFtpXS5mbGFnICYgSE9TVEFQRF9DSEFOX0RJU0FCTEVEKQoJCQkJY29udGludWU7CgkJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiICVkIiwgY2hubFtpXS5jaGFuKTsKCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJCXJldHVybiBwb3MgLSBidWY7CgkJCXBvcyArPSByZXQ7CgkJfQoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiXG4iKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zIC0gYnVmOwoJCXBvcyArPSByZXQ7Cgl9CgoJcmV0dXJuIHBvcyAtIGJ1ZjsKfQoKCnN0YXRpYyBpbnQgY3RybF9pZmFjZV9nZXRfY2FwYWJpbGl0eV9mcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCnsKCXN0cnVjdCBob3N0YXBkX2NoYW5uZWxfZGF0YSAqY2hubDsKCWludCByZXQsIGksIGo7CgljaGFyICpwb3MsICplbmQsICpobW9kZTsKCglwb3MgPSBidWY7CgllbmQgPSBwb3MgKyBidWZsZW47CgoJZm9yIChqID0gMDsgaiA8IHdwYV9zLT5ody5udW1fbW9kZXM7IGorKykgewoJCXN3aXRjaCAod3BhX3MtPmh3Lm1vZGVzW2pdLm1vZGUpIHsKCQljYXNlIEhPU1RBUERfTU9ERV9JRUVFODAyMTFCOgoJCQlobW9kZSA9ICJCIjsKCQkJYnJlYWs7CgkJY2FzZSBIT1NUQVBEX01PREVfSUVFRTgwMjExRzoKCQkJaG1vZGUgPSAiRyI7CgkJCWJyZWFrOwoJCWNhc2UgSE9TVEFQRF9NT0RFX0lFRUU4MDIxMUE6CgkJCWhtb2RlID0gIkEiOwoJCQlicmVhazsKCQljYXNlIEhPU1RBUERfTU9ERV9JRUVFODAyMTFBRDoKCQkJaG1vZGUgPSAiQUQiOwoJCQlicmVhazsKCQlkZWZhdWx0OgoJCQljb250aW51ZTsKCQl9CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJNb2RlWyVzXSBDaGFubmVsczpcbiIsCgkJCQkgIGhtb2RlKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zIC0gYnVmOwoJCXBvcyArPSByZXQ7CgkJY2hubCA9IHdwYV9zLT5ody5tb2Rlc1tqXS5jaGFubmVsczsKCQlmb3IgKGkgPSAwOyBpIDwgd3BhX3MtPmh3Lm1vZGVzW2pdLm51bV9jaGFubmVsczsgaSsrKSB7CgkJCWlmIChjaG5sW2ldLmZsYWcgJiBIT1NUQVBEX0NIQU5fRElTQUJMRUQpCgkJCQljb250aW51ZTsKCQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIgJWQgPSAlZCBNSHolc1xuIiwKCQkJCQkgIGNobmxbaV0uY2hhbiwgY2hubFtpXS5mcmVxLAoJCQkJCSAgY2hubFtpXS5mbGFnICYgSE9TVEFQRF9DSEFOX05PX0lCU1MgPwoJCQkJCSAgIiAoTk9fSUJTUykiIDogIiIpOwoJCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQkJcG9zICs9IHJldDsKCQl9CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJcbiIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCX0KCglyZXR1cm4gcG9zIC0gYnVmOwp9CgoKc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2dldF9jYXBhYmlsaXR5KAoJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY29uc3QgY2hhciAqX2ZpZWxkLCBjaGFyICpidWYsCglzaXplX3QgYnVmbGVuKQp7CglzdHJ1Y3Qgd3BhX2RyaXZlcl9jYXBhIGNhcGE7CglpbnQgcmVzOwoJY2hhciAqc3RyaWN0OwoJY2hhciBmaWVsZFszMF07CglzaXplX3QgbGVuOwoKCS8qIERldGVybWluZSB3aGV0aGVyIG9yIG5vdCBzdHJpY3QgY2hlY2tpbmcgd2FzIHJlcXVlc3RlZCAqLwoJbGVuID0gb3Nfc3RybGNweShmaWVsZCwgX2ZpZWxkLCBzaXplb2YoZmllbGQpKTsKCWlmIChsZW4gPj0gc2l6ZW9mKGZpZWxkKSkKCQlyZXR1cm4gLTE7CglzdHJpY3QgPSBvc19zdHJjaHIoZmllbGQsICcgJyk7CglpZiAoc3RyaWN0ICE9IE5VTEwpIHsKCQkqc3RyaWN0KysgPSAnXDAnOwoJCWlmIChvc19zdHJjbXAoc3RyaWN0LCAic3RyaWN0IikgIT0gMCkKCQkJcmV0dXJuIC0xOwoJfQoKCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogR0VUX0NBUEFCSUxJVFkgJyVzJyAlcyIsCgkJZmllbGQsIHN0cmljdCA/IHN0cmljdCA6ICIiKTsKCglpZiAob3Nfc3RyY21wKGZpZWxkLCAiZWFwIikgPT0gMCkgewoJCXJldHVybiBlYXBfZ2V0X25hbWVzKGJ1ZiwgYnVmbGVuKTsKCX0KCglyZXMgPSB3cGFfZHJ2X2dldF9jYXBhKHdwYV9zLCAmY2FwYSk7CgoJaWYgKG9zX3N0cmNtcChmaWVsZCwgInBhaXJ3aXNlIikgPT0gMCkKCQlyZXR1cm4gY3RybF9pZmFjZV9nZXRfY2FwYWJpbGl0eV9wYWlyd2lzZShyZXMsIHN0cmljdCwgJmNhcGEsCgkJCQkJCQkgIGJ1ZiwgYnVmbGVuKTsKCglpZiAob3Nfc3RyY21wKGZpZWxkLCAiZ3JvdXAiKSA9PSAwKQoJCXJldHVybiBjdHJsX2lmYWNlX2dldF9jYXBhYmlsaXR5X2dyb3VwKHJlcywgc3RyaWN0LCAmY2FwYSwKCQkJCQkJICAgICAgIGJ1ZiwgYnVmbGVuKTsKCglpZiAob3Nfc3RyY21wKGZpZWxkLCAia2V5X21nbXQiKSA9PSAwKQoJCXJldHVybiBjdHJsX2lmYWNlX2dldF9jYXBhYmlsaXR5X2tleV9tZ210KHJlcywgc3RyaWN0LCAmY2FwYSwKCQkJCQkJCSAgYnVmLCBidWZsZW4pOwoKCWlmIChvc19zdHJjbXAoZmllbGQsICJwcm90byIpID09IDApCgkJcmV0dXJuIGN0cmxfaWZhY2VfZ2V0X2NhcGFiaWxpdHlfcHJvdG8ocmVzLCBzdHJpY3QsICZjYXBhLAoJCQkJCQkgICAgICAgYnVmLCBidWZsZW4pOwoKCWlmIChvc19zdHJjbXAoZmllbGQsICJhdXRoX2FsZyIpID09IDApCgkJcmV0dXJuIGN0cmxfaWZhY2VfZ2V0X2NhcGFiaWxpdHlfYXV0aF9hbGcocmVzLCBzdHJpY3QsICZjYXBhLAoJCQkJCQkJICBidWYsIGJ1Zmxlbik7CgoJaWYgKG9zX3N0cmNtcChmaWVsZCwgIm1vZGVzIikgPT0gMCkKCQlyZXR1cm4gY3RybF9pZmFjZV9nZXRfY2FwYWJpbGl0eV9tb2RlcyhyZXMsIHN0cmljdCwgJmNhcGEsCgkJCQkJCSAgICAgICBidWYsIGJ1Zmxlbik7CgoJaWYgKG9zX3N0cmNtcChmaWVsZCwgImNoYW5uZWxzIikgPT0gMCkKCQlyZXR1cm4gY3RybF9pZmFjZV9nZXRfY2FwYWJpbGl0eV9jaGFubmVscyh3cGFfcywgYnVmLCBidWZsZW4pOwoKCWlmIChvc19zdHJjbXAoZmllbGQsICJmcmVxIikgPT0gMCkKCQlyZXR1cm4gY3RybF9pZmFjZV9nZXRfY2FwYWJpbGl0eV9mcmVxKHdwYV9zLCBidWYsIGJ1Zmxlbik7CgoJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBVbmtub3duIEdFVF9DQVBBQklMSVRZIGZpZWxkICclcyciLAoJCSAgIGZpZWxkKTsKCglyZXR1cm4gLTE7Cn0KCgojaWZkZWYgQ09ORklHX0lOVEVSV09SS0lORwpzdGF0aWMgY2hhciAqIGFucXBfYWRkX2hleChjaGFyICpwb3MsIGNoYXIgKmVuZCwgY29uc3QgY2hhciAqdGl0bGUsCgkJCSAgIHN0cnVjdCB3cGFidWYgKmRhdGEpCnsKCWNoYXIgKnN0YXJ0ID0gcG9zOwoJc2l6ZV90IGk7CglpbnQgcmV0OwoJY29uc3QgdTggKmQ7CgoJaWYgKGRhdGEgPT0gTlVMTCkKCQlyZXR1cm4gc3RhcnQ7CgoJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlcz0iLCB0aXRsZSk7CglpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCXJldHVybiBzdGFydDsKCXBvcyArPSByZXQ7CgoJZCA9IHdwYWJ1Zl9oZWFkX3U4KGRhdGEpOwoJZm9yIChpID0gMDsgaSA8IHdwYWJ1Zl9sZW4oZGF0YSk7IGkrKykgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiJTAyeCIsICpkKyspOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBzdGFydDsKCQlwb3MgKz0gcmV0OwoJfQoKCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiXG4iKTsKCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJcmV0dXJuIHN0YXJ0OwoJcG9zICs9IHJldDsKCglyZXR1cm4gcG9zOwp9CiNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCgoKc3RhdGljIGludCBwcmludF9ic3NfaW5mbyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBzdHJ1Y3Qgd3BhX2JzcyAqYnNzLAoJCQkgIHVuc2lnbmVkIGxvbmcgbWFzaywgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQp7CglzaXplX3QgaTsKCWludCByZXQ7CgljaGFyICpwb3MsICplbmQ7Cgljb25zdCB1OCAqaWUsICppZTI7CgoJcG9zID0gYnVmOwoJZW5kID0gYnVmICsgYnVmbGVuOwoKCWlmIChtYXNrICYgV1BBX0JTU19NQVNLX0lEKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJpZD0ldVxuIiwgYnNzLT5pZCk7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIDA7CgkJcG9zICs9IHJldDsKCX0KCglpZiAobWFzayAmIFdQQV9CU1NfTUFTS19CU1NJRCkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiYnNzaWQ9IiBNQUNTVFIgIlxuIiwKCQkJCSAgTUFDMlNUUihic3MtPmJzc2lkKSk7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIDA7CgkJcG9zICs9IHJldDsKCX0KCglpZiAobWFzayAmIFdQQV9CU1NfTUFTS19GUkVRKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJmcmVxPSVkXG4iLCBic3MtPmZyZXEpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiAwOwoJCXBvcyArPSByZXQ7Cgl9CgoJaWYgKG1hc2sgJiBXUEFfQlNTX01BU0tfQkVBQ09OX0lOVCkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiYmVhY29uX2ludD0lZFxuIiwKCQkJCSAgYnNzLT5iZWFjb25faW50KTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gMDsKCQlwb3MgKz0gcmV0OwoJfQoKCWlmIChtYXNrICYgV1BBX0JTU19NQVNLX0NBUEFCSUxJVElFUykgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiY2FwYWJpbGl0aWVzPTB4JTA0eFxuIiwKCQkJCSAgYnNzLT5jYXBzKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gMDsKCQlwb3MgKz0gcmV0OwoJfQoKCWlmIChtYXNrICYgV1BBX0JTU19NQVNLX1FVQUwpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgInF1YWw9JWRcbiIsIGJzcy0+cXVhbCk7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIDA7CgkJcG9zICs9IHJldDsKCX0KCglpZiAobWFzayAmIFdQQV9CU1NfTUFTS19OT0lTRSkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAibm9pc2U9JWRcbiIsIGJzcy0+bm9pc2UpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiAwOwoJCXBvcyArPSByZXQ7Cgl9CgoJaWYgKG1hc2sgJiBXUEFfQlNTX01BU0tfTEVWRUwpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgImxldmVsPSVkXG4iLCBic3MtPmxldmVsKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gMDsKCQlwb3MgKz0gcmV0OwoJfQoKCWlmIChtYXNrICYgV1BBX0JTU19NQVNLX1RTRikgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAidHNmPSUwMTZsbHVcbiIsCgkJCQkgICh1bnNpZ25lZCBsb25nIGxvbmcpIGJzcy0+dHNmKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gMDsKCQlwb3MgKz0gcmV0OwoJfQoKCWlmIChtYXNrICYgV1BBX0JTU19NQVNLX0FHRSkgewoJCXN0cnVjdCBvc190aW1lIG5vdzsKCgkJb3NfZ2V0X3RpbWUoJm5vdyk7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJhZ2U9JWRcbiIsCgkJCQkgIChpbnQpIChub3cuc2VjIC0gYnNzLT5sYXN0X3VwZGF0ZS5zZWMpKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gMDsKCQlwb3MgKz0gcmV0OwoJfQoKCWlmIChtYXNrICYgV1BBX0JTU19NQVNLX0lFKSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJpZT0iKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gMDsKCQlwb3MgKz0gcmV0OwoKCQlpZSA9IChjb25zdCB1OCAqKSAoYnNzICsgMSk7CgkJZm9yIChpID0gMDsgaSA8IGJzcy0+aWVfbGVuOyBpKyspIHsKCQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlMDJ4IiwgKmllKyspOwoJCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQkJcmV0dXJuIDA7CgkJCXBvcyArPSByZXQ7CgkJfQoKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIlxuIik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIDA7CgkJcG9zICs9IHJldDsKCX0KCglpZiAobWFzayAmIFdQQV9CU1NfTUFTS19GTEFHUykgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiZmxhZ3M9Iik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIDA7CgkJcG9zICs9IHJldDsKCgkJaWUgPSB3cGFfYnNzX2dldF92ZW5kb3JfaWUoYnNzLCBXUEFfSUVfVkVORE9SX1RZUEUpOwoJCWlmIChpZSkKCQkJcG9zID0gd3BhX3N1cHBsaWNhbnRfaWVfdHh0KHBvcywgZW5kLCAiV1BBIiwgaWUsCgkJCQkJCSAgICAyICsgaWVbMV0pOwoJCWllMiA9IHdwYV9ic3NfZ2V0X2llKGJzcywgV0xBTl9FSURfUlNOKTsKCQlpZiAoaWUyKQoJCQlwb3MgPSB3cGFfc3VwcGxpY2FudF9pZV90eHQocG9zLCBlbmQsICJXUEEyIiwgaWUyLAoJCQkJCQkgICAgMiArIGllMlsxXSk7CgkJcG9zID0gd3BhX3N1cHBsaWNhbnRfd3BzX2llX3R4dCh3cGFfcywgcG9zLCBlbmQsIGJzcyk7CgkJaWYgKCFpZSAmJiAhaWUyICYmIGJzcy0+Y2FwcyAmIElFRUU4MDIxMV9DQVBfUFJJVkFDWSkgewoJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIltXRVBdIik7CgkJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCQlyZXR1cm4gMDsKCQkJcG9zICs9IHJldDsKCQl9CgkJaWYgKGJzcy0+Y2FwcyAmIElFRUU4MDIxMV9DQVBfSUJTUykgewoJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIltJQlNTXSIpOwoJCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQkJcmV0dXJuIDA7CgkJCXBvcyArPSByZXQ7CgkJfQoJCWlmIChic3MtPmNhcHMgJiBJRUVFODAyMTFfQ0FQX0VTUykgewoJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIltFU1NdIik7CgkJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCQlyZXR1cm4gMDsKCQkJcG9zICs9IHJldDsKCQl9CgkJaWYgKHdwYV9ic3NfZ2V0X3ZlbmRvcl9pZShic3MsIFAyUF9JRV9WRU5ET1JfVFlQRSkpIHsKCQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJbUDJQXSIpOwoJCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQkJcmV0dXJuIDA7CgkJCXBvcyArPSByZXQ7CgkJfQojaWZkZWYgQ09ORklHX0hTMjAKCQlpZiAod3BhX2Jzc19nZXRfdmVuZG9yX2llKGJzcywgSFMyMF9JRV9WRU5ET1JfVFlQRSkpIHsKCQkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJbSFMyMF0iKTsKCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJCXJldHVybiAwOwoJCQlwb3MgKz0gcmV0OwoJCX0KI2VuZGlmIC8qIENPTkZJR19IUzIwICovCgoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiXG4iKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gMDsKCQlwb3MgKz0gcmV0OwoJfQoKCWlmIChtYXNrICYgV1BBX0JTU19NQVNLX1NTSUQpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgInNzaWQ9JXNcbiIsCgkJCQkgIHdwYV9zc2lkX3R4dChic3MtPnNzaWQsIGJzcy0+c3NpZF9sZW4pKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gMDsKCQlwb3MgKz0gcmV0OwoJfQoKI2lmZGVmIENPTkZJR19XUFMKCWlmIChtYXNrICYgV1BBX0JTU19NQVNLX1dQU19TQ0FOKSB7CgkJaWUgPSAoY29uc3QgdTggKikgKGJzcyArIDEpOwoJCXJldCA9IHdwYXNfd3BzX3NjYW5fcmVzdWx0X3RleHQoaWUsIGJzcy0+aWVfbGVuLCBwb3MsIGVuZCk7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIDA7CgkJcG9zICs9IHJldDsKCX0KI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KCiNpZmRlZiBDT05GSUdfUDJQCglpZiAobWFzayAmIFdQQV9CU1NfTUFTS19QMlBfU0NBTikgewoJCWllID0gKGNvbnN0IHU4ICopIChic3MgKyAxKTsKCQlyZXQgPSB3cGFzX3AycF9zY2FuX3Jlc3VsdF90ZXh0KGllLCBic3MtPmllX2xlbiwgcG9zLCBlbmQpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiAwOwoJCXBvcyArPSByZXQ7Cgl9CiNlbmRpZiAvKiBDT05GSUdfUDJQICovCgojaWZkZWYgQ09ORklHX1dJRklfRElTUExBWQoJaWYgKG1hc2sgJiBXUEFfQlNTX01BU0tfV0lGSV9ESVNQTEFZKSB7CgkJc3RydWN0IHdwYWJ1ZiAqd2ZkOwoJCWllID0gKGNvbnN0IHU4ICopIChic3MgKyAxKTsKCQl3ZmQgPSBpZWVlODAyXzExX3ZlbmRvcl9pZV9jb25jYXQoaWUsIGJzcy0+aWVfbGVuLAoJCQkJCQkgIFdGRF9JRV9WRU5ET1JfVFlQRSk7CgkJaWYgKHdmZCkgewoJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIndmZF9zdWJlbGVtcz0iKTsKCQkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJCXJldHVybiAwOwoJCQlwb3MgKz0gcmV0OwoKCQkJcG9zICs9IHdwYV9zbnByaW50Zl9oZXgocG9zLCBlbmQgLSBwb3MsCgkJCQkJCXdwYWJ1Zl9oZWFkKHdmZCksCgkJCQkJCXdwYWJ1Zl9sZW4od2ZkKSk7CgkJCXdwYWJ1Zl9mcmVlKHdmZCk7CgoJCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIlxuIik7CgkJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCQlyZXR1cm4gMDsKCQkJcG9zICs9IHJldDsKCQl9Cgl9CiNlbmRpZiAvKiBDT05GSUdfV0lGSV9ESVNQTEFZICovCgojaWZkZWYgQ09ORklHX0lOVEVSV09SS0lORwoJaWYgKChtYXNrICYgV1BBX0JTU19NQVNLX0lOVEVSTkVUVykgJiYgYnNzLT5hbnFwKSB7CgkJc3RydWN0IHdwYV9ic3NfYW5xcCAqYW5xcCA9IGJzcy0+YW5xcDsKCQlwb3MgPSBhbnFwX2FkZF9oZXgocG9zLCBlbmQsICJhbnFwX3ZlbnVlX25hbWUiLAoJCQkJICAgYW5xcC0+dmVudWVfbmFtZSk7CgkJcG9zID0gYW5xcF9hZGRfaGV4KHBvcywgZW5kLCAiYW5xcF9uZXR3b3JrX2F1dGhfdHlwZSIsCgkJCQkgICBhbnFwLT5uZXR3b3JrX2F1dGhfdHlwZSk7CgkJcG9zID0gYW5xcF9hZGRfaGV4KHBvcywgZW5kLCAiYW5xcF9yb2FtaW5nX2NvbnNvcnRpdW0iLAoJCQkJICAgYW5xcC0+cm9hbWluZ19jb25zb3J0aXVtKTsKCQlwb3MgPSBhbnFwX2FkZF9oZXgocG9zLCBlbmQsICJhbnFwX2lwX2FkZHJfdHlwZV9hdmFpbGFiaWxpdHkiLAoJCQkJICAgYW5xcC0+aXBfYWRkcl90eXBlX2F2YWlsYWJpbGl0eSk7CgkJcG9zID0gYW5xcF9hZGRfaGV4KHBvcywgZW5kLCAiYW5xcF9uYWlfcmVhbG0iLAoJCQkJICAgYW5xcC0+bmFpX3JlYWxtKTsKCQlwb3MgPSBhbnFwX2FkZF9oZXgocG9zLCBlbmQsICJhbnFwXzNncHAiLCBhbnFwLT5hbnFwXzNncHApOwoJCXBvcyA9IGFucXBfYWRkX2hleChwb3MsIGVuZCwgImFucXBfZG9tYWluX25hbWUiLAoJCQkJICAgYW5xcC0+ZG9tYWluX25hbWUpOwojaWZkZWYgQ09ORklHX0hTMjAKCQlwb3MgPSBhbnFwX2FkZF9oZXgocG9zLCBlbmQsICJoczIwX29wZXJhdG9yX2ZyaWVuZGx5X25hbWUiLAoJCQkJICAgYW5xcC0+aHMyMF9vcGVyYXRvcl9mcmllbmRseV9uYW1lKTsKCQlwb3MgPSBhbnFwX2FkZF9oZXgocG9zLCBlbmQsICJoczIwX3dhbl9tZXRyaWNzIiwKCQkJCSAgIGFucXAtPmhzMjBfd2FuX21ldHJpY3MpOwoJCXBvcyA9IGFucXBfYWRkX2hleChwb3MsIGVuZCwgImhzMjBfY29ubmVjdGlvbl9jYXBhYmlsaXR5IiwKCQkJCSAgIGFucXAtPmhzMjBfY29ubmVjdGlvbl9jYXBhYmlsaXR5KTsKI2VuZGlmIC8qIENPTkZJR19IUzIwICovCgl9CiNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCgoJaWYgKG1hc2sgJiBXUEFfQlNTX01BU0tfREVMSU0pIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIj09PT1cbiIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiAwOwoJCXBvcyArPSByZXQ7Cgl9CgoJcmV0dXJuIHBvcyAtIGJ1ZjsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9ic3Moc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKCQkJCQkgY29uc3QgY2hhciAqY21kLCBjaGFyICpidWYsCgkJCQkJIHNpemVfdCBidWZsZW4pCnsKCXU4IGJzc2lkW0VUSF9BTEVOXTsKCXNpemVfdCBpOwoJc3RydWN0IHdwYV9ic3MgKmJzczsKCXN0cnVjdCB3cGFfYnNzICpic3NsYXN0ID0gTlVMTDsKCXN0cnVjdCBkbF9saXN0ICpuZXh0OwoJaW50IHJldCA9IDA7CglpbnQgbGVuOwoJY2hhciAqY3RtcDsKCXVuc2lnbmVkIGxvbmcgbWFzayA9IFdQQV9CU1NfTUFTS19BTEw7CgoJaWYgKG9zX3N0cm5jbXAoY21kLCAiUkFOR0U9IiwgNikgPT0gMCkgewoJCWlmIChvc19zdHJuY21wKGNtZCArIDYsICJBTEwiLCAzKSA9PSAwKSB7CgkJCWJzcyA9IGRsX2xpc3RfZmlyc3QoJndwYV9zLT5ic3NfaWQsIHN0cnVjdCB3cGFfYnNzLAoJCQkJCSAgICBsaXN0X2lkKTsKCQkJYnNzbGFzdCA9IGRsX2xpc3RfbGFzdCgmd3BhX3MtPmJzc19pZCwgc3RydWN0IHdwYV9ic3MsCgkJCQkJICAgICAgIGxpc3RfaWQpOwoJCX0gZWxzZSB7IC8qIE4xLU4yICovCgkJCXVuc2lnbmVkIGludCBpZDEsIGlkMjsKCgkJCWlmICgoY3RtcCA9IG9zX3N0cmNocihjbWQgKyA2LCAnLScpKSA9PSBOVUxMKSB7CgkJCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiV3JvbmcgQlNTIHJhbmdlICIKCQkJCQkgICAiZm9ybWF0Iik7CgkJCQlyZXR1cm4gMDsKCQkJfQoKCQkJaWYgKCooY21kICsgNikgPT0gJy0nKQoJCQkJaWQxID0gMDsKCQkJZWxzZQoJCQkJaWQxID0gYXRvaShjbWQgKyA2KTsKCQkJY3RtcCsrOwoJCQlpZiAoKmN0bXAgPj0gJzAnICYmICpjdG1wIDw9ICc5JykKCQkJCWlkMiA9IGF0b2koY3RtcCk7CgkJCWVsc2UKCQkJCWlkMiA9ICh1bnNpZ25lZCBpbnQpIC0xOwoJCQlic3MgPSB3cGFfYnNzX2dldF9pZF9yYW5nZSh3cGFfcywgaWQxLCBpZDIpOwoJCQlpZiAoaWQyID09ICh1bnNpZ25lZCBpbnQpIC0xKQoJCQkJYnNzbGFzdCA9IGRsX2xpc3RfbGFzdCgmd3BhX3MtPmJzc19pZCwKCQkJCQkJICAgICAgIHN0cnVjdCB3cGFfYnNzLAoJCQkJCQkgICAgICAgbGlzdF9pZCk7CgkJCWVsc2UgewoJCQkJYnNzbGFzdCA9IHdwYV9ic3NfZ2V0X2lkKHdwYV9zLCBpZDIpOwoJCQkJaWYgKGJzc2xhc3QgPT0gTlVMTCAmJiBic3MgJiYgaWQyID4gaWQxKSB7CgkJCQkJc3RydWN0IHdwYV9ic3MgKnRtcCA9IGJzczsKCQkJCQlmb3IgKDs7KSB7CgkJCQkJCW5leHQgPSB0bXAtPmxpc3RfaWQubmV4dDsKCQkJCQkJaWYgKG5leHQgPT0gJndwYV9zLT5ic3NfaWQpCgkJCQkJCQlicmVhazsKCQkJCQkJdG1wID0gZGxfbGlzdF9lbnRyeSgKCQkJCQkJCW5leHQsIHN0cnVjdCB3cGFfYnNzLAoJCQkJCQkJbGlzdF9pZCk7CgkJCQkJCWlmICh0bXAtPmlkID4gaWQyKQoJCQkJCQkJYnJlYWs7CgkJCQkJCWJzc2xhc3QgPSB0bXA7CgkJCQkJfQoJCQkJfQoJCQl9CgkJfQoJfSBlbHNlIGlmIChvc19zdHJuY21wKGNtZCwgIkZJUlNUIiwgNSkgPT0gMCkKCQlic3MgPSBkbF9saXN0X2ZpcnN0KCZ3cGFfcy0+YnNzX2lkLCBzdHJ1Y3Qgd3BhX2JzcywgbGlzdF9pZCk7CgllbHNlIGlmIChvc19zdHJuY21wKGNtZCwgIkxBU1QiLCA0KSA9PSAwKQoJCWJzcyA9IGRsX2xpc3RfbGFzdCgmd3BhX3MtPmJzc19pZCwgc3RydWN0IHdwYV9ic3MsIGxpc3RfaWQpOwoJZWxzZSBpZiAob3Nfc3RybmNtcChjbWQsICJJRC0iLCAzKSA9PSAwKSB7CgkJaSA9IGF0b2koY21kICsgMyk7CgkJYnNzID0gd3BhX2Jzc19nZXRfaWQod3BhX3MsIGkpOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGNtZCwgIk5FWFQtIiwgNSkgPT0gMCkgewoJCWkgPSBhdG9pKGNtZCArIDUpOwoJCWJzcyA9IHdwYV9ic3NfZ2V0X2lkKHdwYV9zLCBpKTsKCQlpZiAoYnNzKSB7CgkJCW5leHQgPSBic3MtPmxpc3RfaWQubmV4dDsKCQkJaWYgKG5leHQgPT0gJndwYV9zLT5ic3NfaWQpCgkJCQlic3MgPSBOVUxMOwoJCQllbHNlCgkJCQlic3MgPSBkbF9saXN0X2VudHJ5KG5leHQsIHN0cnVjdCB3cGFfYnNzLAoJCQkJCQkgICAgbGlzdF9pZCk7CgkJfQojaWZkZWYgQ09ORklHX1AyUAoJfSBlbHNlIGlmIChvc19zdHJuY21wKGNtZCwgInAycF9kZXZfYWRkcj0iLCAxMykgPT0gMCkgewoJCWlmIChod2FkZHJfYXRvbihjbWQgKyAxMywgYnNzaWQpID09IDApCgkJCWJzcyA9IHdwYV9ic3NfZ2V0X3AycF9kZXZfYWRkcih3cGFfcywgYnNzaWQpOwoJCWVsc2UKCQkJYnNzID0gTlVMTDsKI2VuZGlmIC8qIENPTkZJR19QMlAgKi8KCX0gZWxzZSBpZiAoaHdhZGRyX2F0b24oY21kLCBic3NpZCkgPT0gMCkKCQlic3MgPSB3cGFfYnNzX2dldF9ic3NpZCh3cGFfcywgYnNzaWQpOwoJZWxzZSB7CgkJc3RydWN0IHdwYV9ic3MgKnRtcDsKCQlpID0gYXRvaShjbWQpOwoJCWJzcyA9IE5VTEw7CgkJZGxfbGlzdF9mb3JfZWFjaCh0bXAsICZ3cGFfcy0+YnNzX2lkLCBzdHJ1Y3Qgd3BhX2JzcywgbGlzdF9pZCkKCQl7CgkJCWlmIChpLS0gPT0gMCkgewoJCQkJYnNzID0gdG1wOwoJCQkJYnJlYWs7CgkJCX0KCQl9Cgl9CgoJaWYgKChjdG1wID0gb3Nfc3Ryc3RyKGNtZCwgIk1BU0s9IikpICE9IE5VTEwpIHsKCQltYXNrID0gc3RydG91bChjdG1wICsgNSwgTlVMTCwgMHgxMCk7CgkJaWYgKG1hc2sgPT0gMCkKCQkJbWFzayA9IFdQQV9CU1NfTUFTS19BTEw7Cgl9CgoJaWYgKGJzcyA9PSBOVUxMKQoJCXJldHVybiAwOwoKCWlmIChic3NsYXN0ID09IE5VTEwpCgkJYnNzbGFzdCA9IGJzczsKCWRvIHsKCQlsZW4gPSBwcmludF9ic3NfaW5mbyh3cGFfcywgYnNzLCBtYXNrLCBidWYsIGJ1Zmxlbik7CgkJcmV0ICs9IGxlbjsKCQlidWYgKz0gbGVuOwoJCWJ1ZmxlbiAtPSBsZW47CgkJaWYgKGJzcyA9PSBic3NsYXN0KSB7CgkJCWlmICgobWFzayAmIFdQQV9CU1NfTUFTS19ERUxJTSkgJiYgbGVuICYmCgkJCSAgICAoYnNzID09IGRsX2xpc3RfbGFzdCgmd3BhX3MtPmJzc19pZCwKCQkJCQkJIHN0cnVjdCB3cGFfYnNzLCBsaXN0X2lkKSkpCgkJCQlvc19zbnByaW50ZihidWYgLSA1LCA1LCAiIyMjI1xuIik7CgkJCWJyZWFrOwoJCX0KCQluZXh0ID0gYnNzLT5saXN0X2lkLm5leHQ7CgkJaWYgKG5leHQgPT0gJndwYV9zLT5ic3NfaWQpCgkJCWJyZWFrOwoJCWJzcyA9IGRsX2xpc3RfZW50cnkobmV4dCwgc3RydWN0IHdwYV9ic3MsIGxpc3RfaWQpOwoJfSB3aGlsZSAoYnNzICYmIGxlbik7CgoJcmV0dXJuIHJldDsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9hcF9zY2FuKAoJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kKQp7CglpbnQgYXBfc2NhbiA9IGF0b2koY21kKTsKCXJldHVybiB3cGFfc3VwcGxpY2FudF9zZXRfYXBfc2Nhbih3cGFfcywgYXBfc2Nhbik7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2Nhbl9pbnRlcnZhbCgKCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKewoJaW50IHNjYW5faW50ID0gYXRvaShjbWQpOwoJcmV0dXJuIHdwYV9zdXBwbGljYW50X3NldF9zY2FuX2ludGVydmFsKHdwYV9zLCBzY2FuX2ludCk7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfYnNzX2V4cGlyZV9hZ2UoCglzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCnsKCWludCBleHBpcmVfYWdlID0gYXRvaShjbWQpOwoJcmV0dXJuIHdwYV9zdXBwbGljYW50X3NldF9ic3NfZXhwaXJhdGlvbl9hZ2Uod3BhX3MsIGV4cGlyZV9hZ2UpOwp9CgoKc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2Jzc19leHBpcmVfY291bnQoCglzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCnsKCWludCBleHBpcmVfY291bnQgPSBhdG9pKGNtZCk7CglyZXR1cm4gd3BhX3N1cHBsaWNhbnRfc2V0X2Jzc19leHBpcmF0aW9uX2NvdW50KHdwYV9zLCBleHBpcmVfY291bnQpOwp9CgoKc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2Jzc19mbHVzaCgKCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKewoJaW50IGZsdXNoX2FnZSA9IGF0b2koY21kKTsKCglpZiAoZmx1c2hfYWdlID09IDApCgkJd3BhX2Jzc19mbHVzaCh3cGFfcyk7CgllbHNlCgkJd3BhX2Jzc19mbHVzaF9ieV9hZ2Uod3BhX3MsIGZsdXNoX2FnZSk7CglyZXR1cm4gMDsKfQoKCnN0YXRpYyB2b2lkIHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfZHJvcF9zYShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQp7Cgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkRyb3BwaW5nIFNBIHdpdGhvdXQgZGVhdXRoZW50aWNhdGlvbiIpOwoJLyogTUxNRS1ERUxFVEVLRVlTLnJlcXVlc3QgKi8KCXdwYV9kcnZfc2V0X2tleSh3cGFfcywgV1BBX0FMR19OT05FLCBOVUxMLCAwLCAwLCBOVUxMLCAwLCBOVUxMLCAwKTsKCXdwYV9kcnZfc2V0X2tleSh3cGFfcywgV1BBX0FMR19OT05FLCBOVUxMLCAxLCAwLCBOVUxMLCAwLCBOVUxMLCAwKTsKCXdwYV9kcnZfc2V0X2tleSh3cGFfcywgV1BBX0FMR19OT05FLCBOVUxMLCAyLCAwLCBOVUxMLCAwLCBOVUxMLCAwKTsKCXdwYV9kcnZfc2V0X2tleSh3cGFfcywgV1BBX0FMR19OT05FLCBOVUxMLCAzLCAwLCBOVUxMLCAwLCBOVUxMLCAwKTsKI2lmZGVmIENPTkZJR19JRUVFODAyMTFXCgl3cGFfZHJ2X3NldF9rZXkod3BhX3MsIFdQQV9BTEdfTk9ORSwgTlVMTCwgNCwgMCwgTlVMTCwgMCwgTlVMTCwgMCk7Cgl3cGFfZHJ2X3NldF9rZXkod3BhX3MsIFdQQV9BTEdfTk9ORSwgTlVMTCwgNSwgMCwgTlVMTCwgMCwgTlVMTCwgMCk7CiNlbmRpZiAvKiBDT05GSUdfSUVFRTgwMjExVyAqLwoKCXdwYV9kcnZfc2V0X2tleSh3cGFfcywgV1BBX0FMR19OT05FLCB3cGFfcy0+YnNzaWQsIDAsIDAsIE5VTEwsIDAsIE5VTEwsCgkJCTApOwoJLyogTUxNRS1TRVRQUk9URUNUSU9OLnJlcXVlc3QoTm9uZSkgKi8KCXdwYV9kcnZfbWxtZV9zZXRwcm90ZWN0aW9uKHdwYV9zLCB3cGFfcy0+YnNzaWQsCgkJCQkgICBNTE1FX1NFVFBST1RFQ1RJT05fUFJPVEVDVF9UWVBFX05PTkUsCgkJCQkgICBNTE1FX1NFVFBST1RFQ1RJT05fS0VZX1RZUEVfUEFJUldJU0UpOwoJd3BhX3NtX2Ryb3Bfc2Eod3BhX3MtPndwYSk7Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfcm9hbShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAoJCQkJCSAgY2hhciAqYWRkcikKewojaWZkZWYgQ09ORklHX05PX1NDQU5fUFJPQ0VTU0lORwoJcmV0dXJuIC0xOwojZWxzZSAvKiBDT05GSUdfTk9fU0NBTl9QUk9DRVNTSU5HICovCgl1OCBic3NpZFtFVEhfQUxFTl07CglzdHJ1Y3Qgd3BhX2JzcyAqYnNzOwoJc3RydWN0IHdwYV9zc2lkICpzc2lkID0gd3BhX3MtPmN1cnJlbnRfc3NpZDsKCglpZiAoaHdhZGRyX2F0b24oYWRkciwgYnNzaWQpKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIFJPQU06IGludmFsaWQgIgoJCQkgICAiYWRkcmVzcyAnJXMnIiwgYWRkcik7CgkJcmV0dXJuIC0xOwoJfQoKCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRSBST0FNICIgTUFDU1RSLCBNQUMyU1RSKGJzc2lkKSk7CgoJaWYgKCFzc2lkKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIFJPQU06IE5vIG5ldHdvcmsgIgoJCQkgICAiY29uZmlndXJhdGlvbiBrbm93biBmb3IgdGhlIHRhcmdldCBBUCIpOwoJCXJldHVybiAtMTsKCX0KCglic3MgPSB3cGFfYnNzX2dldCh3cGFfcywgYnNzaWQsIHNzaWQtPnNzaWQsIHNzaWQtPnNzaWRfbGVuKTsKCWlmICghYnNzKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFIFJPQU06IFRhcmdldCBBUCBub3QgZm91bmQgIgoJCQkgICAiZnJvbSBCU1MgdGFibGUiKTsKCQlyZXR1cm4gLTE7Cgl9CgoJLyoKCSAqIFRPRE86IEZpbmQgYmVzdCBuZXR3b3JrIGNvbmZpZ3VyYXRpb24gYmxvY2sgZnJvbSBjb25maWd1cmF0aW9uIHRvCgkgKiBhbGxvdyByb2FtaW5nIHRvIG90aGVyIG5ldHdvcmtzCgkgKi8KCgl3cGFfcy0+cmVhc3NvY2lhdGUgPSAxOwoJd3BhX3N1cHBsaWNhbnRfY29ubmVjdCh3cGFfcywgYnNzLCBzc2lkKTsKCglyZXR1cm4gMDsKI2VuZGlmIC8qIENPTkZJR19OT19TQ0FOX1BST0NFU1NJTkcgKi8KfQoKCiNpZmRlZiBDT05GSUdfUDJQCnN0YXRpYyBpbnQgcDJwX2N0cmxfZmluZChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCnsKCXVuc2lnbmVkIGludCB0aW1lb3V0ID0gYXRvaShjbWQpOwoJZW51bSBwMnBfZGlzY292ZXJ5X3R5cGUgdHlwZSA9IFAyUF9GSU5EX1NUQVJUX1dJVEhfRlVMTDsKCXU4IGRldl9pZFtFVEhfQUxFTl0sICpfZGV2X2lkID0gTlVMTDsKCWNoYXIgKnBvczsKCXVuc2lnbmVkIGludCBzZWFyY2hfZGVsYXk7CgoJaWYgKG9zX3N0cnN0cihjbWQsICJ0eXBlPXNvY2lhbCIpKQoJCXR5cGUgPSBQMlBfRklORF9PTkxZX1NPQ0lBTDsKCWVsc2UgaWYgKG9zX3N0cnN0cihjbWQsICJ0eXBlPXByb2dyZXNzaXZlIikpCgkJdHlwZSA9IFAyUF9GSU5EX1BST0dSRVNTSVZFOwoKCXBvcyA9IG9zX3N0cnN0cihjbWQsICJkZXZfaWQ9Iik7CglpZiAocG9zKSB7CgkJcG9zICs9IDc7CgkJaWYgKGh3YWRkcl9hdG9uKHBvcywgZGV2X2lkKSkKCQkJcmV0dXJuIC0xOwoJCV9kZXZfaWQgPSBkZXZfaWQ7Cgl9CgoJcG9zID0gb3Nfc3Ryc3RyKGNtZCwgImRlbGF5PSIpOwoJaWYgKHBvcykgewoJCXBvcyArPSA2OwoJCXNlYXJjaF9kZWxheSA9IGF0b2kocG9zKTsKCX0gZWxzZQoJCXNlYXJjaF9kZWxheSA9IHdwYXNfcDJwX3NlYXJjaF9kZWxheSh3cGFfcyk7CgoJcmV0dXJuIHdwYXNfcDJwX2ZpbmQod3BhX3MsIHRpbWVvdXQsIHR5cGUsIDAsIE5VTEwsIF9kZXZfaWQsCgkJCSAgICAgc2VhcmNoX2RlbGF5KTsKfQoKCnN0YXRpYyBpbnQgcDJwX2N0cmxfY29ubmVjdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQsCgkJCSAgICBjaGFyICpidWYsIHNpemVfdCBidWZsZW4pCnsKCXU4IGFkZHJbRVRIX0FMRU5dOwoJY2hhciAqcG9zLCAqcG9zMjsKCWNoYXIgKnBpbiA9IE5VTEw7CgllbnVtIHAycF93cHNfbWV0aG9kIHdwc19tZXRob2Q7CglpbnQgbmV3X3BpbjsKCWludCByZXQ7CglpbnQgcGVyc2lzdGVudF9ncm91cCwgcGVyc2lzdGVudF9pZCA9IC0xOwoJaW50IGpvaW47CglpbnQgYXV0aDsKCWludCBhdXRvbWF0aWM7CglpbnQgZ29faW50ZW50ID0gLTE7CglpbnQgZnJlcSA9IDA7CglpbnQgcGQ7CglpbnQgaHQ0MDsKCgkvKiA8YWRkcj4gPCJwYmMiIHwgInBpbiIgfCBQSU4+IFtsYWJlbHxkaXNwbGF5fGtleXBhZF0KCSAqIFtwZXJzaXN0ZW50fHBlcnNpc3RlbnQ9PG5ldHdvcmsgaWQ+XQoJICogW2pvaW5dIFthdXRoXSBbZ29faW50ZW50PTwwLi4xNT5dIFtmcmVxPTxpbiBNSHo+XSBbcHJvdmRpc2NdCgkgKiBbaHQ0MF0gKi8KCglpZiAoaHdhZGRyX2F0b24oY21kLCBhZGRyKSkKCQlyZXR1cm4gLTE7CgoJcG9zID0gY21kICsgMTc7CglpZiAoKnBvcyAhPSAnICcpCgkJcmV0dXJuIC0xOwoJcG9zKys7CgoJcGVyc2lzdGVudF9ncm91cCA9IG9zX3N0cnN0cihwb3MsICIgcGVyc2lzdGVudCIpICE9IE5VTEw7Cglwb3MyID0gb3Nfc3Ryc3RyKHBvcywgIiBwZXJzaXN0ZW50PSIpOwoJaWYgKHBvczIpIHsKCQlzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CgkJcGVyc2lzdGVudF9pZCA9IGF0b2kocG9zMiArIDEyKTsKCQlzc2lkID0gd3BhX2NvbmZpZ19nZXRfbmV0d29yayh3cGFfcy0+Y29uZiwgcGVyc2lzdGVudF9pZCk7CgkJaWYgKHNzaWQgPT0gTlVMTCB8fCBzc2lkLT5kaXNhYmxlZCAhPSAyIHx8CgkJICAgIHNzaWQtPm1vZGUgIT0gV1BBU19NT0RFX1AyUF9HTykgewoJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IENvdWxkIG5vdCBmaW5kICIKCQkJCSAgICJTU0lEIGlkPSVkIGZvciBwZXJzaXN0ZW50IFAyUCBncm91cCAoR08pIiwKCQkJCSAgIHBlcnNpc3RlbnRfaWQpOwoJCQlyZXR1cm4gLTE7CgkJfQoJfQoJam9pbiA9IG9zX3N0cnN0cihwb3MsICIgam9pbiIpICE9IE5VTEw7CglhdXRoID0gb3Nfc3Ryc3RyKHBvcywgIiBhdXRoIikgIT0gTlVMTDsKCWF1dG9tYXRpYyA9IG9zX3N0cnN0cihwb3MsICIgYXV0byIpICE9IE5VTEw7CglwZCA9IG9zX3N0cnN0cihwb3MsICIgcHJvdmRpc2MiKSAhPSBOVUxMOwoJaHQ0MCA9IChvc19zdHJzdHIoY21kLCAiIGh0NDAiKSAhPSBOVUxMKSB8fCB3cGFfcy0+Y29uZi0+cDJwX2dvX2h0NDA7CgoJcG9zMiA9IG9zX3N0cnN0cihwb3MsICIgZ29faW50ZW50PSIpOwoJaWYgKHBvczIpIHsKCQlwb3MyICs9IDExOwoJCWdvX2ludGVudCA9IGF0b2kocG9zMik7CgkJaWYgKGdvX2ludGVudCA8IDAgfHwgZ29faW50ZW50ID4gMTUpCgkJCXJldHVybiAtMTsKCX0KCglwb3MyID0gb3Nfc3Ryc3RyKHBvcywgIiBmcmVxPSIpOwoJaWYgKHBvczIpIHsKCQlwb3MyICs9IDY7CgkJZnJlcSA9IGF0b2kocG9zMik7CgkJaWYgKGZyZXEgPD0gMCkKCQkJcmV0dXJuIC0xOwoJfQoKCWlmIChvc19zdHJuY21wKHBvcywgInBpbiIsIDMpID09IDApIHsKCQkvKiBSZXF1ZXN0IHJhbmRvbSBQSU4gKHRvIGJlIGRpc3BsYXllZCkgYW5kIGVuYWJsZSB0aGUgUElOICovCgkJd3BzX21ldGhvZCA9IFdQU19QSU5fRElTUExBWTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChwb3MsICJwYmMiLCAzKSA9PSAwKSB7CgkJd3BzX21ldGhvZCA9IFdQU19QQkM7Cgl9IGVsc2UgewoJCXBpbiA9IHBvczsKCQlwb3MgPSBvc19zdHJjaHIocGluLCAnICcpOwoJCXdwc19tZXRob2QgPSBXUFNfUElOX0tFWVBBRDsKCQlpZiAocG9zKSB7CgkJCSpwb3MrKyA9ICdcMCc7CgkJCWlmIChvc19zdHJuY21wKHBvcywgImRpc3BsYXkiLCA3KSA9PSAwKQoJCQkJd3BzX21ldGhvZCA9IFdQU19QSU5fRElTUExBWTsKCQl9CgkJaWYgKCF3cHNfcGluX3N0cl92YWxpZChwaW4pKSB7CgkJCW9zX21lbWNweShidWYsICJGQUlMLUlOVkFMSUQtUElOXG4iLCAxNyk7CgkJCXJldHVybiAxNzsKCQl9Cgl9CgoJbmV3X3BpbiA9IHdwYXNfcDJwX2Nvbm5lY3Qod3BhX3MsIGFkZHIsIHBpbiwgd3BzX21ldGhvZCwKCQkJCSAgIHBlcnNpc3RlbnRfZ3JvdXAsIGF1dG9tYXRpYywgam9pbiwKCQkJCSAgIGF1dGgsIGdvX2ludGVudCwgZnJlcSwgcGVyc2lzdGVudF9pZCwgcGQsCgkJCQkgICBodDQwKTsKCWlmIChuZXdfcGluID09IC0yKSB7CgkJb3NfbWVtY3B5KGJ1ZiwgIkZBSUwtQ0hBTk5FTC1VTkFWQUlMQUJMRVxuIiwgMjUpOwoJCXJldHVybiAyNTsKCX0KCWlmIChuZXdfcGluID09IC0zKSB7CgkJb3NfbWVtY3B5KGJ1ZiwgIkZBSUwtQ0hBTk5FTC1VTlNVUFBPUlRFRFxuIiwgMjUpOwoJCXJldHVybiAyNTsKCX0KCWlmIChuZXdfcGluIDwgMCkKCQlyZXR1cm4gLTE7CglpZiAod3BzX21ldGhvZCA9PSBXUFNfUElOX0RJU1BMQVkgJiYgcGluID09IE5VTEwpIHsKCQlyZXQgPSBvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIiUwOGQiLCBuZXdfcGluKTsKCQlpZiAocmV0IDwgMCB8fCAoc2l6ZV90KSByZXQgPj0gYnVmbGVuKQoJCQlyZXR1cm4gLTE7CgkJcmV0dXJuIHJldDsKCX0KCglvc19tZW1jcHkoYnVmLCAiT0tcbiIsIDMpOwoJcmV0dXJuIDM7Cn0KCgpzdGF0aWMgaW50IHAycF9jdHJsX2xpc3RlbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCnsKCXVuc2lnbmVkIGludCB0aW1lb3V0ID0gYXRvaShjbWQpOwoJcmV0dXJuIHdwYXNfcDJwX2xpc3Rlbih3cGFfcywgdGltZW91dCk7Cn0KCgpzdGF0aWMgaW50IHAycF9jdHJsX3Byb3ZfZGlzYyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCnsKCXU4IGFkZHJbRVRIX0FMRU5dOwoJY2hhciAqcG9zOwoJZW51bSB3cGFzX3AycF9wcm92X2Rpc2NfdXNlIHVzZSA9IFdQQVNfUDJQX1BEX0ZPUl9HT19ORUc7CgoJLyogPGFkZHI+IDxjb25maWcgbWV0aG9kPiBbam9pbnxhdXRvXSAqLwoKCWlmIChod2FkZHJfYXRvbihjbWQsIGFkZHIpKQoJCXJldHVybiAtMTsKCglwb3MgPSBjbWQgKyAxNzsKCWlmICgqcG9zICE9ICcgJykKCQlyZXR1cm4gLTE7Cglwb3MrKzsKCglpZiAob3Nfc3Ryc3RyKHBvcywgIiBqb2luIikgIT0gTlVMTCkKCQl1c2UgPSBXUEFTX1AyUF9QRF9GT1JfSk9JTjsKCWVsc2UgaWYgKG9zX3N0cnN0cihwb3MsICIgYXV0byIpICE9IE5VTEwpCgkJdXNlID0gV1BBU19QMlBfUERfQVVUTzsKCglyZXR1cm4gd3Bhc19wMnBfcHJvdl9kaXNjKHdwYV9zLCBhZGRyLCBwb3MsIHVzZSk7Cn0KCgpzdGF0aWMgaW50IHAycF9nZXRfcGFzc3BocmFzZShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpidWYsCgkJCSAgICAgIHNpemVfdCBidWZsZW4pCnsKCXN0cnVjdCB3cGFfc3NpZCAqc3NpZCA9IHdwYV9zLT5jdXJyZW50X3NzaWQ7CgoJaWYgKHNzaWQgPT0gTlVMTCB8fCBzc2lkLT5tb2RlICE9IFdQQVNfTU9ERV9QMlBfR08gfHwKCSAgICBzc2lkLT5wYXNzcGhyYXNlID09IE5VTEwpCgkJcmV0dXJuIC0xOwoKCW9zX3N0cmxjcHkoYnVmLCBzc2lkLT5wYXNzcGhyYXNlLCBidWZsZW4pOwoJcmV0dXJuIG9zX3N0cmxlbihidWYpOwp9CgoKc3RhdGljIGludCBwMnBfY3RybF9zZXJ2X2Rpc2NfcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCwKCQkJCSAgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQp7Cgl1NjQgcmVmOwoJaW50IHJlczsKCXU4IGRzdF9idWZbRVRIX0FMRU5dLCAqZHN0OwoJc3RydWN0IHdwYWJ1ZiAqdGx2czsKCWNoYXIgKnBvczsKCXNpemVfdCBsZW47CgoJaWYgKGh3YWRkcl9hdG9uKGNtZCwgZHN0X2J1ZikpCgkJcmV0dXJuIC0xOwoJZHN0ID0gZHN0X2J1ZjsKCWlmIChkc3RbMF0gPT0gMCAmJiBkc3RbMV0gPT0gMCAmJiBkc3RbMl0gPT0gMCAmJgoJICAgIGRzdFszXSA9PSAwICYmIGRzdFs0XSA9PSAwICYmIGRzdFs1XSA9PSAwKQoJCWRzdCA9IE5VTEw7Cglwb3MgPSBjbWQgKyAxNzsKCWlmICgqcG9zICE9ICcgJykKCQlyZXR1cm4gLTE7Cglwb3MrKzsKCglpZiAob3Nfc3RybmNtcChwb3MsICJ1cG5wICIsIDUpID09IDApIHsKCQl1OCB2ZXJzaW9uOwoJCXBvcyArPSA1OwoJCWlmIChoZXhzdHIyYmluKHBvcywgJnZlcnNpb24sIDEpIDwgMCkKCQkJcmV0dXJuIC0xOwoJCXBvcyArPSAyOwoJCWlmICgqcG9zICE9ICcgJykKCQkJcmV0dXJuIC0xOwoJCXBvcysrOwoJCXJlZiA9IHdwYXNfcDJwX3NkX3JlcXVlc3RfdXBucCh3cGFfcywgZHN0LCB2ZXJzaW9uLCBwb3MpOwojaWZkZWYgQ09ORklHX1dJRklfRElTUExBWQoJfSBlbHNlIGlmIChvc19zdHJuY21wKHBvcywgIndpZmktZGlzcGxheSAiLCAxMykgPT0gMCkgewoJCXJlZiA9IHdwYXNfcDJwX3NkX3JlcXVlc3Rfd2lmaV9kaXNwbGF5KHdwYV9zLCBkc3QsIHBvcyArIDEzKTsKI2VuZGlmIC8qIENPTkZJR19XSUZJX0RJU1BMQVkgKi8KCX0gZWxzZSB7CgkJbGVuID0gb3Nfc3RybGVuKHBvcyk7CgkJaWYgKGxlbiAmIDEpCgkJCXJldHVybiAtMTsKCQlsZW4gLz0gMjsKCQl0bHZzID0gd3BhYnVmX2FsbG9jKGxlbik7CgkJaWYgKHRsdnMgPT0gTlVMTCkKCQkJcmV0dXJuIC0xOwoJCWlmIChoZXhzdHIyYmluKHBvcywgd3BhYnVmX3B1dCh0bHZzLCBsZW4pLCBsZW4pIDwgMCkgewoJCQl3cGFidWZfZnJlZSh0bHZzKTsKCQkJcmV0dXJuIC0xOwoJCX0KCgkJcmVmID0gd3Bhc19wMnBfc2RfcmVxdWVzdCh3cGFfcywgZHN0LCB0bHZzKTsKCQl3cGFidWZfZnJlZSh0bHZzKTsKCX0KCWlmIChyZWYgPT0gMCkKCQlyZXR1cm4gLTE7CglyZXMgPSBvc19zbnByaW50ZihidWYsIGJ1ZmxlbiwgIiVsbHgiLCAobG9uZyBsb25nIHVuc2lnbmVkKSByZWYpOwoJaWYgKHJlcyA8IDAgfHwgKHVuc2lnbmVkKSByZXMgPj0gYnVmbGVuKQoJCXJldHVybiAtMTsKCXJldHVybiByZXM7Cn0KCgpzdGF0aWMgaW50IHAycF9jdHJsX3NlcnZfZGlzY19jYW5jZWxfcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJIGNoYXIgKmNtZCkKewoJbG9uZyBsb25nIHVuc2lnbmVkIHZhbDsKCXU2NCByZXE7CglpZiAoc3NjYW5mKGNtZCwgIiVsbHgiLCAmdmFsKSAhPSAxKQoJCXJldHVybiAtMTsKCXJlcSA9IHZhbDsKCXJldHVybiB3cGFzX3AycF9zZF9jYW5jZWxfcmVxdWVzdCh3cGFfcywgcmVxKTsKfQoKCnN0YXRpYyBpbnQgcDJwX2N0cmxfc2Vydl9kaXNjX3Jlc3Aoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kKQp7CglpbnQgZnJlcTsKCXU4IGRzdFtFVEhfQUxFTl07Cgl1OCBkaWFsb2dfdG9rZW47CglzdHJ1Y3Qgd3BhYnVmICpyZXNwX3RsdnM7CgljaGFyICpwb3MsICpwb3MyOwoJc2l6ZV90IGxlbjsKCglwb3MgPSBvc19zdHJjaHIoY21kLCAnICcpOwoJaWYgKHBvcyA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSpwb3MrKyA9ICdcMCc7CglmcmVxID0gYXRvaShjbWQpOwoJaWYgKGZyZXEgPT0gMCkKCQlyZXR1cm4gLTE7CgoJaWYgKGh3YWRkcl9hdG9uKHBvcywgZHN0KSkKCQlyZXR1cm4gLTE7Cglwb3MgKz0gMTc7CglpZiAoKnBvcyAhPSAnICcpCgkJcmV0dXJuIC0xOwoJcG9zKys7CgoJcG9zMiA9IG9zX3N0cmNocihwb3MsICcgJyk7CglpZiAocG9zMiA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSpwb3MyKysgPSAnXDAnOwoJZGlhbG9nX3Rva2VuID0gYXRvaShwb3MpOwoKCWxlbiA9IG9zX3N0cmxlbihwb3MyKTsKCWlmIChsZW4gJiAxKQoJCXJldHVybiAtMTsKCWxlbiAvPSAyOwoJcmVzcF90bHZzID0gd3BhYnVmX2FsbG9jKGxlbik7CglpZiAocmVzcF90bHZzID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJaWYgKGhleHN0cjJiaW4ocG9zMiwgd3BhYnVmX3B1dChyZXNwX3RsdnMsIGxlbiksIGxlbikgPCAwKSB7CgkJd3BhYnVmX2ZyZWUocmVzcF90bHZzKTsKCQlyZXR1cm4gLTE7Cgl9CgoJd3Bhc19wMnBfc2RfcmVzcG9uc2Uod3BhX3MsIGZyZXEsIGRzdCwgZGlhbG9nX3Rva2VuLCByZXNwX3RsdnMpOwoJd3BhYnVmX2ZyZWUocmVzcF90bHZzKTsKCXJldHVybiAwOwp9CgoKc3RhdGljIGludCBwMnBfY3RybF9zZXJ2X2Rpc2NfZXh0ZXJuYWwoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKCQkJCSAgICAgICBjaGFyICpjbWQpCnsKCWlmIChvc19zdHJjbXAoY21kLCAiMCIpICYmIG9zX3N0cmNtcChjbWQsICIxIikpCgkJcmV0dXJuIC0xOwoJd3BhX3MtPnAycF9zZF9vdmVyX2N0cmxfaWZhY2UgPSBhdG9pKGNtZCk7CglyZXR1cm4gMDsKfQoKCnN0YXRpYyBpbnQgcDJwX2N0cmxfc2VydmljZV9hZGRfYm9uam91cihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAoJCQkJCWNoYXIgKmNtZCkKewoJY2hhciAqcG9zOwoJc2l6ZV90IGxlbjsKCXN0cnVjdCB3cGFidWYgKnF1ZXJ5LCAqcmVzcDsKCglwb3MgPSBvc19zdHJjaHIoY21kLCAnICcpOwoJaWYgKHBvcyA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSpwb3MrKyA9ICdcMCc7CgoJbGVuID0gb3Nfc3RybGVuKGNtZCk7CglpZiAobGVuICYgMSkKCQlyZXR1cm4gLTE7CglsZW4gLz0gMjsKCXF1ZXJ5ID0gd3BhYnVmX2FsbG9jKGxlbik7CglpZiAocXVlcnkgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CglpZiAoaGV4c3RyMmJpbihjbWQsIHdwYWJ1Zl9wdXQocXVlcnksIGxlbiksIGxlbikgPCAwKSB7CgkJd3BhYnVmX2ZyZWUocXVlcnkpOwoJCXJldHVybiAtMTsKCX0KCglsZW4gPSBvc19zdHJsZW4ocG9zKTsKCWlmIChsZW4gJiAxKSB7CgkJd3BhYnVmX2ZyZWUocXVlcnkpOwoJCXJldHVybiAtMTsKCX0KCWxlbiAvPSAyOwoJcmVzcCA9IHdwYWJ1Zl9hbGxvYyhsZW4pOwoJaWYgKHJlc3AgPT0gTlVMTCkgewoJCXdwYWJ1Zl9mcmVlKHF1ZXJ5KTsKCQlyZXR1cm4gLTE7Cgl9CglpZiAoaGV4c3RyMmJpbihwb3MsIHdwYWJ1Zl9wdXQocmVzcCwgbGVuKSwgbGVuKSA8IDApIHsKCQl3cGFidWZfZnJlZShxdWVyeSk7CgkJd3BhYnVmX2ZyZWUocmVzcCk7CgkJcmV0dXJuIC0xOwoJfQoKCWlmICh3cGFzX3AycF9zZXJ2aWNlX2FkZF9ib25qb3VyKHdwYV9zLCBxdWVyeSwgcmVzcCkgPCAwKSB7CgkJd3BhYnVmX2ZyZWUocXVlcnkpOwoJCXdwYWJ1Zl9mcmVlKHJlc3ApOwoJCXJldHVybiAtMTsKCX0KCXJldHVybiAwOwp9CgoKc3RhdGljIGludCBwMnBfY3RybF9zZXJ2aWNlX2FkZF91cG5wKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKewoJY2hhciAqcG9zOwoJdTggdmVyc2lvbjsKCglwb3MgPSBvc19zdHJjaHIoY21kLCAnICcpOwoJaWYgKHBvcyA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSpwb3MrKyA9ICdcMCc7CgoJaWYgKGhleHN0cjJiaW4oY21kLCAmdmVyc2lvbiwgMSkgPCAwKQoJCXJldHVybiAtMTsKCglyZXR1cm4gd3Bhc19wMnBfc2VydmljZV9hZGRfdXBucCh3cGFfcywgdmVyc2lvbiwgcG9zKTsKfQoKCnN0YXRpYyBpbnQgcDJwX2N0cmxfc2VydmljZV9hZGQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kKQp7CgljaGFyICpwb3M7CgoJcG9zID0gb3Nfc3RyY2hyKGNtZCwgJyAnKTsKCWlmIChwb3MgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgkqcG9zKysgPSAnXDAnOwoKCWlmIChvc19zdHJjbXAoY21kLCAiYm9uam91ciIpID09IDApCgkJcmV0dXJuIHAycF9jdHJsX3NlcnZpY2VfYWRkX2JvbmpvdXIod3BhX3MsIHBvcyk7CglpZiAob3Nfc3RyY21wKGNtZCwgInVwbnAiKSA9PSAwKQoJCXJldHVybiBwMnBfY3RybF9zZXJ2aWNlX2FkZF91cG5wKHdwYV9zLCBwb3MpOwoJd3BhX3ByaW50ZihNU0dfREVCVUcsICJVbmtub3duIHNlcnZpY2UgJyVzJyIsIGNtZCk7CglyZXR1cm4gLTE7Cn0KCgpzdGF0aWMgaW50IHAycF9jdHJsX3NlcnZpY2VfZGVsX2JvbmpvdXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywKCQkJCQljaGFyICpjbWQpCnsKCXNpemVfdCBsZW47CglzdHJ1Y3Qgd3BhYnVmICpxdWVyeTsKCWludCByZXQ7CgoJbGVuID0gb3Nfc3RybGVuKGNtZCk7CglpZiAobGVuICYgMSkKCQlyZXR1cm4gLTE7CglsZW4gLz0gMjsKCXF1ZXJ5ID0gd3BhYnVmX2FsbG9jKGxlbik7CglpZiAocXVlcnkgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CglpZiAoaGV4c3RyMmJpbihjbWQsIHdwYWJ1Zl9wdXQocXVlcnksIGxlbiksIGxlbikgPCAwKSB7CgkJd3BhYnVmX2ZyZWUocXVlcnkpOwoJCXJldHVybiAtMTsKCX0KCglyZXQgPSB3cGFzX3AycF9zZXJ2aWNlX2RlbF9ib25qb3VyKHdwYV9zLCBxdWVyeSk7Cgl3cGFidWZfZnJlZShxdWVyeSk7CglyZXR1cm4gcmV0Owp9CgoKc3RhdGljIGludCBwMnBfY3RybF9zZXJ2aWNlX2RlbF91cG5wKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKewoJY2hhciAqcG9zOwoJdTggdmVyc2lvbjsKCglwb3MgPSBvc19zdHJjaHIoY21kLCAnICcpOwoJaWYgKHBvcyA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSpwb3MrKyA9ICdcMCc7CgoJaWYgKGhleHN0cjJiaW4oY21kLCAmdmVyc2lvbiwgMSkgPCAwKQoJCXJldHVybiAtMTsKCglyZXR1cm4gd3Bhc19wMnBfc2VydmljZV9kZWxfdXBucCh3cGFfcywgdmVyc2lvbiwgcG9zKTsKfQoKCnN0YXRpYyBpbnQgcDJwX2N0cmxfc2VydmljZV9kZWwoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kKQp7CgljaGFyICpwb3M7CgoJcG9zID0gb3Nfc3RyY2hyKGNtZCwgJyAnKTsKCWlmIChwb3MgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgkqcG9zKysgPSAnXDAnOwoKCWlmIChvc19zdHJjbXAoY21kLCAiYm9uam91ciIpID09IDApCgkJcmV0dXJuIHAycF9jdHJsX3NlcnZpY2VfZGVsX2JvbmpvdXIod3BhX3MsIHBvcyk7CglpZiAob3Nfc3RyY21wKGNtZCwgInVwbnAiKSA9PSAwKQoJCXJldHVybiBwMnBfY3RybF9zZXJ2aWNlX2RlbF91cG5wKHdwYV9zLCBwb3MpOwoJd3BhX3ByaW50ZihNU0dfREVCVUcsICJVbmtub3duIHNlcnZpY2UgJyVzJyIsIGNtZCk7CglyZXR1cm4gLTE7Cn0KCgpzdGF0aWMgaW50IHAycF9jdHJsX3JlamVjdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCnsKCXU4IGFkZHJbRVRIX0FMRU5dOwoKCS8qIDxhZGRyPiAqLwoKCWlmIChod2FkZHJfYXRvbihjbWQsIGFkZHIpKQoJCXJldHVybiAtMTsKCglyZXR1cm4gd3Bhc19wMnBfcmVqZWN0KHdwYV9zLCBhZGRyKTsKfQoKCnN0YXRpYyBpbnQgcDJwX2N0cmxfaW52aXRlX3BlcnNpc3RlbnQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kKQp7CgljaGFyICpwb3M7CglpbnQgaWQ7CglzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7Cgl1OCAqX3BlZXIgPSBOVUxMLCBwZWVyW0VUSF9BTEVOXTsKCWludCBmcmVxID0gMCwgcHJlZl9mcmVxID0gMDsKCWludCBodDQwOwoKCWlkID0gYXRvaShjbWQpOwoJcG9zID0gb3Nfc3Ryc3RyKGNtZCwgIiBwZWVyPSIpOwoJaWYgKHBvcykgewoJCXBvcyArPSA2OwoJCWlmIChod2FkZHJfYXRvbihwb3MsIHBlZXIpKQoJCQlyZXR1cm4gLTE7CgkJX3BlZXIgPSBwZWVyOwoJfQoJc3NpZCA9IHdwYV9jb25maWdfZ2V0X25ldHdvcmsod3BhX3MtPmNvbmYsIGlkKTsKCWlmIChzc2lkID09IE5VTEwgfHwgc3NpZC0+ZGlzYWJsZWQgIT0gMikgewoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogQ291bGQgbm90IGZpbmQgU1NJRCBpZD0lZCAiCgkJCSAgICJmb3IgcGVyc2lzdGVudCBQMlAgZ3JvdXAiLAoJCQkgICBpZCk7CgkJcmV0dXJuIC0xOwoJfQoKCXBvcyA9IG9zX3N0cnN0cihjbWQsICIgZnJlcT0iKTsKCWlmIChwb3MpIHsKCQlwb3MgKz0gNjsKCQlmcmVxID0gYXRvaShwb3MpOwoJCWlmIChmcmVxIDw9IDApCgkJCXJldHVybiAtMTsKCX0KCglwb3MgPSBvc19zdHJzdHIoY21kLCAiIHByZWY9Iik7CglpZiAocG9zKSB7CgkJcG9zICs9IDY7CgkJcHJlZl9mcmVxID0gYXRvaShwb3MpOwoJCWlmIChwcmVmX2ZyZXEgPD0gMCkKCQkJcmV0dXJuIC0xOwoJfQoKCWh0NDAgPSAob3Nfc3Ryc3RyKGNtZCwgIiBodDQwIikgIT0gTlVMTCkgfHwgd3BhX3MtPmNvbmYtPnAycF9nb19odDQwOwoKCXJldHVybiB3cGFzX3AycF9pbnZpdGUod3BhX3MsIF9wZWVyLCBzc2lkLCBOVUxMLCBmcmVxLCBodDQwLCBwcmVmX2ZyZXEpOwp9CgoKc3RhdGljIGludCBwMnBfY3RybF9pbnZpdGVfZ3JvdXAoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kKQp7CgljaGFyICpwb3M7Cgl1OCBwZWVyW0VUSF9BTEVOXSwgZ29fZGV2X2FkZHJbRVRIX0FMRU5dLCAqZ29fZGV2ID0gTlVMTDsKCglwb3MgPSBvc19zdHJzdHIoY21kLCAiIHBlZXI9Iik7CglpZiAoIXBvcykKCQlyZXR1cm4gLTE7CgoJKnBvcyA9ICdcMCc7Cglwb3MgKz0gNjsKCWlmIChod2FkZHJfYXRvbihwb3MsIHBlZXIpKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlA6IEludmFsaWQgTUFDIGFkZHJlc3MgJyVzJyIsIHBvcyk7CgkJcmV0dXJuIC0xOwoJfQoKCXBvcyA9IG9zX3N0cnN0cihwb3MsICIgZ29fZGV2X2FkZHI9Iik7CglpZiAocG9zKSB7CgkJcG9zICs9IDEzOwoJCWlmIChod2FkZHJfYXRvbihwb3MsIGdvX2Rldl9hZGRyKSkgewoJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlAyUDogSW52YWxpZCBNQUMgYWRkcmVzcyAnJXMnIiwKCQkJCSAgIHBvcyk7CgkJCXJldHVybiAtMTsKCQl9CgkJZ29fZGV2ID0gZ29fZGV2X2FkZHI7Cgl9CgoJcmV0dXJuIHdwYXNfcDJwX2ludml0ZV9ncm91cCh3cGFfcywgY21kLCBwZWVyLCBnb19kZXYpOwp9CgoKc3RhdGljIGludCBwMnBfY3RybF9pbnZpdGUoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kKQp7CglpZiAob3Nfc3RybmNtcChjbWQsICJwZXJzaXN0ZW50PSIsIDExKSA9PSAwKQoJCXJldHVybiBwMnBfY3RybF9pbnZpdGVfcGVyc2lzdGVudCh3cGFfcywgY21kICsgMTEpOwoJaWYgKG9zX3N0cm5jbXAoY21kLCAiZ3JvdXA9IiwgNikgPT0gMCkKCQlyZXR1cm4gcDJwX2N0cmxfaW52aXRlX2dyb3VwKHdwYV9zLCBjbWQgKyA2KTsKCglyZXR1cm4gLTE7Cn0KCgpzdGF0aWMgaW50IHAycF9jdHJsX2dyb3VwX2FkZF9wZXJzaXN0ZW50KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkJIGNoYXIgKmNtZCwgaW50IGZyZXEsIGludCBodDQwKQp7CglpbnQgaWQ7CglzdHJ1Y3Qgd3BhX3NzaWQgKnNzaWQ7CgoJaWQgPSBhdG9pKGNtZCk7Cglzc2lkID0gd3BhX2NvbmZpZ19nZXRfbmV0d29yayh3cGFfcy0+Y29uZiwgaWQpOwoJaWYgKHNzaWQgPT0gTlVMTCB8fCBzc2lkLT5kaXNhYmxlZCAhPSAyKSB7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBDb3VsZCBub3QgZmluZCBTU0lEIGlkPSVkICIKCQkJICAgImZvciBwZXJzaXN0ZW50IFAyUCBncm91cCIsCgkJCSAgIGlkKTsKCQlyZXR1cm4gLTE7Cgl9CgoJcmV0dXJuIHdwYXNfcDJwX2dyb3VwX2FkZF9wZXJzaXN0ZW50KHdwYV9zLCBzc2lkLCAwLCBmcmVxLCBodDQwLCBOVUxMKTsKfQoKCnN0YXRpYyBpbnQgcDJwX2N0cmxfZ3JvdXBfYWRkKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKewoJaW50IGZyZXEgPSAwLCBodDQwOwoJY2hhciAqcG9zOwoKCXBvcyA9IG9zX3N0cnN0cihjbWQsICJmcmVxPSIpOwoJaWYgKHBvcykKCQlmcmVxID0gYXRvaShwb3MgKyA1KTsKCglodDQwID0gKG9zX3N0cnN0cihjbWQsICJodDQwIikgIT0gTlVMTCkgfHwgd3BhX3MtPmNvbmYtPnAycF9nb19odDQwOwoKCWlmIChvc19zdHJuY21wKGNtZCwgInBlcnNpc3RlbnQ9IiwgMTEpID09IDApCgkJcmV0dXJuIHAycF9jdHJsX2dyb3VwX2FkZF9wZXJzaXN0ZW50KHdwYV9zLCBjbWQgKyAxMSwgZnJlcSwKCQkJCQkJICAgICBodDQwKTsKCWlmIChvc19zdHJjbXAoY21kLCAicGVyc2lzdGVudCIpID09IDAgfHwKCSAgICBvc19zdHJuY21wKGNtZCwgInBlcnNpc3RlbnQgIiwgMTEpID09IDApCgkJcmV0dXJuIHdwYXNfcDJwX2dyb3VwX2FkZCh3cGFfcywgMSwgZnJlcSwgaHQ0MCk7CglpZiAob3Nfc3RybmNtcChjbWQsICJmcmVxPSIsIDUpID09IDApCgkJcmV0dXJuIHdwYXNfcDJwX2dyb3VwX2FkZCh3cGFfcywgMCwgZnJlcSwgaHQ0MCk7CglpZiAoaHQ0MCkKCQlyZXR1cm4gd3Bhc19wMnBfZ3JvdXBfYWRkKHdwYV9zLCAwLCBmcmVxLCBodDQwKTsKCgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkw6IEludmFsaWQgUDJQX0dST1VQX0FERCBwYXJhbWV0ZXJzICclcyciLAoJCSAgIGNtZCk7CglyZXR1cm4gLTE7Cn0KCgpzdGF0aWMgaW50IHAycF9jdHJsX3BlZXIoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kLAoJCQkgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQp7Cgl1OCBhZGRyW0VUSF9BTEVOXSwgKmFkZHJfcHRyOwoJaW50IG5leHQsIHJlczsKCWNvbnN0IHN0cnVjdCBwMnBfcGVlcl9pbmZvICppbmZvOwoJY2hhciAqcG9zLCAqZW5kOwoJY2hhciBkZXZ0eXBlW1dQU19ERVZfVFlQRV9CVUZTSVpFXTsKCXN0cnVjdCB3cGFfc3NpZCAqc3NpZDsKCXNpemVfdCBpOwoKCWlmICghd3BhX3MtPmdsb2JhbC0+cDJwKQoJCXJldHVybiAtMTsKCglpZiAob3Nfc3RyY21wKGNtZCwgIkZJUlNUIikgPT0gMCkgewoJCWFkZHJfcHRyID0gTlVMTDsKCQluZXh0ID0gMDsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChjbWQsICJORVhULSIsIDUpID09IDApIHsKCQlpZiAoaHdhZGRyX2F0b24oY21kICsgNSwgYWRkcikgPCAwKQoJCQlyZXR1cm4gLTE7CgkJYWRkcl9wdHIgPSBhZGRyOwoJCW5leHQgPSAxOwoJfSBlbHNlIHsKCQlpZiAoaHdhZGRyX2F0b24oY21kLCBhZGRyKSA8IDApCgkJCXJldHVybiAtMTsKCQlhZGRyX3B0ciA9IGFkZHI7CgkJbmV4dCA9IDA7Cgl9CgoJaW5mbyA9IHAycF9nZXRfcGVlcl9pbmZvKHdwYV9zLT5nbG9iYWwtPnAycCwgYWRkcl9wdHIsIG5leHQpOwoJaWYgKGluZm8gPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgoJcG9zID0gYnVmOwoJZW5kID0gYnVmICsgYnVmbGVuOwoKCXJlcyA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCBNQUNTVFIgIlxuIgoJCQkgICJwcmlfZGV2X3R5cGU9JXNcbiIKCQkJICAiZGV2aWNlX25hbWU9JXNcbiIKCQkJICAibWFudWZhY3R1cmVyPSVzXG4iCgkJCSAgIm1vZGVsX25hbWU9JXNcbiIKCQkJICAibW9kZWxfbnVtYmVyPSVzXG4iCgkJCSAgInNlcmlhbF9udW1iZXI9JXNcbiIKCQkJICAiY29uZmlnX21ldGhvZHM9MHgleFxuIgoJCQkgICJkZXZfY2FwYWI9MHgleFxuIgoJCQkgICJncm91cF9jYXBhYj0weCV4XG4iCgkJCSAgImxldmVsPSVkXG4iLAoJCQkgIE1BQzJTVFIoaW5mby0+cDJwX2RldmljZV9hZGRyKSwKCQkJICB3cHNfZGV2X3R5cGVfYmluMnN0cihpbmZvLT5wcmlfZGV2X3R5cGUsCgkJCQkJICAgICAgIGRldnR5cGUsIHNpemVvZihkZXZ0eXBlKSksCgkJCSAgaW5mby0+ZGV2aWNlX25hbWUsCgkJCSAgaW5mby0+bWFudWZhY3R1cmVyLAoJCQkgIGluZm8tPm1vZGVsX25hbWUsCgkJCSAgaW5mby0+bW9kZWxfbnVtYmVyLAoJCQkgIGluZm8tPnNlcmlhbF9udW1iZXIsCgkJCSAgaW5mby0+Y29uZmlnX21ldGhvZHMsCgkJCSAgaW5mby0+ZGV2X2NhcGFiLAoJCQkgIGluZm8tPmdyb3VwX2NhcGFiLAoJCQkgIGluZm8tPmxldmVsKTsKCWlmIChyZXMgPCAwIHx8IHJlcyA+PSBlbmQgLSBwb3MpCgkJcmV0dXJuIHBvcyAtIGJ1ZjsKCXBvcyArPSByZXM7CgoJZm9yIChpID0gMDsgaSA8IGluZm8tPndwc19zZWNfZGV2X3R5cGVfbGlzdF9sZW4gLyBXUFNfREVWX1RZUEVfTEVOOyBpKyspCgl7CgkJY29uc3QgdTggKnQ7CgkJdCA9ICZpbmZvLT53cHNfc2VjX2Rldl90eXBlX2xpc3RbaSAqIFdQU19ERVZfVFlQRV9MRU5dOwoJCXJlcyA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAic2VjX2Rldl90eXBlPSVzXG4iLAoJCQkJICB3cHNfZGV2X3R5cGVfYmluMnN0cih0LCBkZXZ0eXBlLAoJCQkJCQkgICAgICAgc2l6ZW9mKGRldnR5cGUpKSk7CgkJaWYgKHJlcyA8IDAgfHwgcmVzID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQlwb3MgKz0gcmVzOwoJfQoKCXNzaWQgPSB3cGFzX3AycF9nZXRfcGVyc2lzdGVudCh3cGFfcywgaW5mby0+cDJwX2RldmljZV9hZGRyLCBOVUxMLCAwKTsKCWlmIChzc2lkKSB7CgkJcmVzID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJwZXJzaXN0ZW50PSVkXG4iLCBzc2lkLT5pZCk7CgkJaWYgKHJlcyA8IDAgfHwgcmVzID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQlwb3MgKz0gcmVzOwoJfQoKCXJlcyA9IHAycF9nZXRfcGVlcl9pbmZvX3R4dChpbmZvLCBwb3MsIGVuZCAtIHBvcyk7CglpZiAocmVzIDwgMCkKCQlyZXR1cm4gcG9zIC0gYnVmOwoJcG9zICs9IHJlczsKCglyZXR1cm4gcG9zIC0gYnVmOwp9CgoKc3RhdGljIGludCBwMnBfY3RybF9kaXNhbGxvd19mcmVxKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkgIGNvbnN0IGNoYXIgKnBhcmFtKQp7CglzdHJ1Y3Qgd3BhX2ZyZXFfcmFuZ2UgKmZyZXEgPSBOVUxMLCAqbjsKCXVuc2lnbmVkIGludCBjb3VudCA9IDAsIGk7Cgljb25zdCBjaGFyICpwb3MsICpwb3MyLCAqcG9zMzsKCglpZiAod3BhX3MtPmdsb2JhbC0+cDJwID09IE5VTEwpCgkJcmV0dXJuIC0xOwoKCS8qCgkgKiBwYXJhbSBpbmNsdWRlcyBjb21tYSBzZXBhcmF0ZWQgZnJlcXVlbmN5IHJhbmdlLgoJICogRm9yIGV4YW1wbGU6IDI0MTItMjQzMiwyNDYyLDUwMDAtNjAwMAoJICovCglwb3MgPSBwYXJhbTsKCXdoaWxlIChwb3MgJiYgcG9zWzBdKSB7CgkJbiA9IG9zX3JlYWxsb2NfYXJyYXkoZnJlcSwgY291bnQgKyAxLAoJCQkJICAgICBzaXplb2Yoc3RydWN0IHdwYV9mcmVxX3JhbmdlKSk7CgkJaWYgKG4gPT0gTlVMTCkgewoJCQlvc19mcmVlKGZyZXEpOwoJCQlyZXR1cm4gLTE7CgkJfQoJCWZyZXEgPSBuOwoJCWZyZXFbY291bnRdLm1pbiA9IGF0b2kocG9zKTsKCQlwb3MyID0gb3Nfc3RyY2hyKHBvcywgJy0nKTsKCQlwb3MzID0gb3Nfc3RyY2hyKHBvcywgJywnKTsKCQlpZiAocG9zMiAmJiAoIXBvczMgfHwgcG9zMiA8IHBvczMpKSB7CgkJCXBvczIrKzsKCQkJZnJlcVtjb3VudF0ubWF4ID0gYXRvaShwb3MyKTsKCQl9IGVsc2UKCQkJZnJlcVtjb3VudF0ubWF4ID0gZnJlcVtjb3VudF0ubWluOwoJCXBvcyA9IHBvczM7CgkJaWYgKHBvcykKCQkJcG9zKys7CgkJY291bnQrKzsKCX0KCglmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykgewoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiUDJQOiBEaXNhbGxvd2VkIGZyZXF1ZW5jeSByYW5nZSAldS0ldSIsCgkJCSAgIGZyZXFbaV0ubWluLCBmcmVxW2ldLm1heCk7Cgl9CgoJb3NfZnJlZSh3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWxsb3dfZnJlcSk7Cgl3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWxsb3dfZnJlcSA9IGZyZXE7Cgl3cGFfcy0+Z2xvYmFsLT5udW1fcDJwX2Rpc2FsbG93X2ZyZXEgPSBjb3VudDsKCXdwYXNfcDJwX3VwZGF0ZV9jaGFubmVsX2xpc3Qod3BhX3MpOwoJcmV0dXJuIDA7Cn0KCgpzdGF0aWMgaW50IHAycF9jdHJsX3NldChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCnsKCWNoYXIgKnBhcmFtOwoKCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnAgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgoJcGFyYW0gPSBvc19zdHJjaHIoY21kLCAnICcpOwoJaWYgKHBhcmFtID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJKnBhcmFtKysgPSAnXDAnOwoKCWlmIChvc19zdHJjbXAoY21kLCAiZGlzY292ZXJhYmlsaXR5IikgPT0gMCkgewoJCXAycF9zZXRfY2xpZW50X2Rpc2NvdmVyYWJpbGl0eSh3cGFfcy0+Z2xvYmFsLT5wMnAsCgkJCQkJICAgICAgIGF0b2kocGFyYW0pKTsKCQlyZXR1cm4gMDsKCX0KCglpZiAob3Nfc3RyY21wKGNtZCwgIm1hbmFnZWQiKSA9PSAwKSB7CgkJcDJwX3NldF9tYW5hZ2VkX29wZXIod3BhX3MtPmdsb2JhbC0+cDJwLCBhdG9pKHBhcmFtKSk7CgkJcmV0dXJuIDA7Cgl9CgoJaWYgKG9zX3N0cmNtcChjbWQsICJsaXN0ZW5fY2hhbm5lbCIpID09IDApIHsKCQlyZXR1cm4gcDJwX3NldF9saXN0ZW5fY2hhbm5lbCh3cGFfcy0+Z2xvYmFsLT5wMnAsIDgxLAoJCQkJCSAgICAgIGF0b2kocGFyYW0pKTsKCX0KCglpZiAob3Nfc3RyY21wKGNtZCwgInNzaWRfcG9zdGZpeCIpID09IDApIHsKCQlyZXR1cm4gcDJwX3NldF9zc2lkX3Bvc3RmaXgod3BhX3MtPmdsb2JhbC0+cDJwLCAodTggKikgcGFyYW0sCgkJCQkJICAgIG9zX3N0cmxlbihwYXJhbSkpOwoJfQoKCWlmIChvc19zdHJjbXAoY21kLCAibm9hIikgPT0gMCkgewoJCWNoYXIgKnBvczsKCQlpbnQgY291bnQsIHN0YXJ0LCBkdXJhdGlvbjsKCQkvKiBHTyBOb0EgcGFyYW1ldGVyczogY291bnQsc3RhcnRfb2Zmc2V0KG1zKSxkdXJhdGlvbihtcykgKi8KCQljb3VudCA9IGF0b2kocGFyYW0pOwoJCXBvcyA9IG9zX3N0cmNocihwYXJhbSwgJywnKTsKCQlpZiAocG9zID09IE5VTEwpCgkJCXJldHVybiAtMTsKCQlwb3MrKzsKCQlzdGFydCA9IGF0b2kocG9zKTsKCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnLCcpOwoJCWlmIChwb3MgPT0gTlVMTCkKCQkJcmV0dXJuIC0xOwoJCXBvcysrOwoJCWR1cmF0aW9uID0gYXRvaShwb3MpOwoJCWlmIChjb3VudCA8IDAgfHwgY291bnQgPiAyNTUgfHwgc3RhcnQgPCAwIHx8IGR1cmF0aW9uIDwgMCkKCQkJcmV0dXJuIC0xOwoJCWlmIChjb3VudCA9PSAwICYmIGR1cmF0aW9uID4gMCkKCQkJcmV0dXJuIC0xOwoJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogUDJQX1NFVCBHTyBOb0E6IGNvdW50PSVkICIKCQkJICAgInN0YXJ0PSVkIGR1cmF0aW9uPSVkIiwgY291bnQsIHN0YXJ0LCBkdXJhdGlvbik7CgkJcmV0dXJuIHdwYXNfcDJwX3NldF9ub2Eod3BhX3MsIGNvdW50LCBzdGFydCwgZHVyYXRpb24pOwoJfQoKCWlmIChvc19zdHJjbXAoY21kLCAicHMiKSA9PSAwKQoJCXJldHVybiB3cGFfZHJ2X3NldF9wMnBfcG93ZXJzYXZlKHdwYV9zLCBhdG9pKHBhcmFtKSwgLTEsIC0xKTsKCglpZiAob3Nfc3RyY21wKGNtZCwgIm9wcHBzIikgPT0gMCkKCQlyZXR1cm4gd3BhX2Rydl9zZXRfcDJwX3Bvd2Vyc2F2ZSh3cGFfcywgLTEsIGF0b2kocGFyYW0pLCAtMSk7CgoJaWYgKG9zX3N0cmNtcChjbWQsICJjdHdpbmRvdyIpID09IDApCgkJcmV0dXJuIHdwYV9kcnZfc2V0X3AycF9wb3dlcnNhdmUod3BhX3MsIC0xLCAtMSwgYXRvaShwYXJhbSkpOwoKCWlmIChvc19zdHJjbXAoY21kLCAiZGlzYWJsZWQiKSA9PSAwKSB7CgkJd3BhX3MtPmdsb2JhbC0+cDJwX2Rpc2FibGVkID0gYXRvaShwYXJhbSk7CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJQMlAgZnVuY3Rpb25hbGl0eSAlcyIsCgkJCSAgIHdwYV9zLT5nbG9iYWwtPnAycF9kaXNhYmxlZCA/CgkJCSAgICJkaXNhYmxlZCIgOiAiZW5hYmxlZCIpOwoJCWlmICh3cGFfcy0+Z2xvYmFsLT5wMnBfZGlzYWJsZWQpIHsKCQkJd3Bhc19wMnBfc3RvcF9maW5kKHdwYV9zKTsKCQkJb3NfbWVtc2V0KHdwYV9zLT5wMnBfYXV0aF9pbnZpdGUsIDAsIEVUSF9BTEVOKTsKCQkJcDJwX2ZsdXNoKHdwYV9zLT5nbG9iYWwtPnAycCk7CgkJfQoJCXJldHVybiAwOwoJfQoKCWlmIChvc19zdHJjbXAoY21kLCAiY29uY19wcmVmIikgPT0gMCkgewoJCWlmIChvc19zdHJjbXAocGFyYW0sICJzdGEiKSA9PSAwKQoJCQl3cGFfcy0+Z2xvYmFsLT5jb25jX3ByZWYgPSBXUEFfQ09OQ19QUkVGX1NUQTsKCQllbHNlIGlmIChvc19zdHJjbXAocGFyYW0sICJwMnAiKSA9PSAwKQoJCQl3cGFfcy0+Z2xvYmFsLT5jb25jX3ByZWYgPSBXUEFfQ09OQ19QUkVGX1AyUDsKCQllbHNlIHsKCQkJd3BhX3ByaW50ZihNU0dfSU5GTywgIkludmFsaWQgY29uY19wcmVmIHZhbHVlIik7CgkJCXJldHVybiAtMTsKCQl9CgkJd3BhX3ByaW50ZihNU0dfREVCVUcsICJTaW5nbGUgY2hhbm5lbCBjb25jdXJyZW5jeSBwcmVmZXJlbmNlOiAiCgkJCSAgICIlcyIsIHBhcmFtKTsKCQlyZXR1cm4gMDsKCX0KCglpZiAob3Nfc3RyY21wKGNtZCwgImZvcmNlX2xvbmdfc2QiKSA9PSAwKSB7CgkJd3BhX3MtPmZvcmNlX2xvbmdfc2QgPSBhdG9pKHBhcmFtKTsKCQlyZXR1cm4gMDsKCX0KCglpZiAob3Nfc3RyY21wKGNtZCwgInBlZXJfZmlsdGVyIikgPT0gMCkgewoJCXU4IGFkZHJbRVRIX0FMRU5dOwoJCWlmIChod2FkZHJfYXRvbihwYXJhbSwgYWRkcikpCgkJCXJldHVybiAtMTsKCQlwMnBfc2V0X3BlZXJfZmlsdGVyKHdwYV9zLT5nbG9iYWwtPnAycCwgYWRkcik7CgkJcmV0dXJuIDA7Cgl9CgoJaWYgKG9zX3N0cmNtcChjbWQsICJjcm9zc19jb25uZWN0IikgPT0gMCkKCQlyZXR1cm4gd3Bhc19wMnBfc2V0X2Nyb3NzX2Nvbm5lY3Qod3BhX3MsIGF0b2kocGFyYW0pKTsKCglpZiAob3Nfc3RyY21wKGNtZCwgImdvX2Fwc2QiKSA9PSAwKSB7CgkJaWYgKG9zX3N0cmNtcChwYXJhbSwgImRpc2FibGUiKSA9PSAwKQoJCQl3cGFfcy0+c2V0X2FwX3VhcHNkID0gMDsKCQllbHNlIHsKCQkJd3BhX3MtPnNldF9hcF91YXBzZCA9IDE7CgkJCXdwYV9zLT5hcF91YXBzZCA9IGF0b2kocGFyYW0pOwoJCX0KCQlyZXR1cm4gMDsKCX0KCglpZiAob3Nfc3RyY21wKGNtZCwgImNsaWVudF9hcHNkIikgPT0gMCkgewoJCWlmIChvc19zdHJjbXAocGFyYW0sICJkaXNhYmxlIikgPT0gMCkKCQkJd3BhX3MtPnNldF9zdGFfdWFwc2QgPSAwOwoJCWVsc2UgewoJCQlpbnQgYmUsIGJrLCB2aSwgdm87CgkJCWNoYXIgKnBvczsKCQkJLyogZm9ybWF0OiBCRSxCSyxWSSxWTzttYXggU1AgTGVuZ3RoICovCgkJCWJlID0gYXRvaShwYXJhbSk7CgkJCXBvcyA9IG9zX3N0cmNocihwYXJhbSwgJywnKTsKCQkJaWYgKHBvcyA9PSBOVUxMKQoJCQkJcmV0dXJuIC0xOwoJCQlwb3MrKzsKCQkJYmsgPSBhdG9pKHBvcyk7CgkJCXBvcyA9IG9zX3N0cmNocihwb3MsICcsJyk7CgkJCWlmIChwb3MgPT0gTlVMTCkKCQkJCXJldHVybiAtMTsKCQkJcG9zKys7CgkJCXZpID0gYXRvaShwb3MpOwoJCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnLCcpOwoJCQlpZiAocG9zID09IE5VTEwpCgkJCQlyZXR1cm4gLTE7CgkJCXBvcysrOwoJCQl2byA9IGF0b2kocG9zKTsKCQkJLyogaWdub3JlIG1heCBTUCBMZW5ndGggZm9yIG5vdyAqLwoKCQkJd3BhX3MtPnNldF9zdGFfdWFwc2QgPSAxOwoJCQl3cGFfcy0+c3RhX3VhcHNkID0gMDsKCQkJaWYgKGJlKQoJCQkJd3BhX3MtPnN0YV91YXBzZCB8PSBCSVQoMCk7CgkJCWlmIChiaykKCQkJCXdwYV9zLT5zdGFfdWFwc2QgfD0gQklUKDEpOwoJCQlpZiAodmkpCgkJCQl3cGFfcy0+c3RhX3VhcHNkIHw9IEJJVCgyKTsKCQkJaWYgKHZvKQoJCQkJd3BhX3MtPnN0YV91YXBzZCB8PSBCSVQoMyk7CgkJfQoJCXJldHVybiAwOwoJfQoKCWlmIChvc19zdHJjbXAoY21kLCAiZGlzYWxsb3dfZnJlcSIpID09IDApCgkJcmV0dXJuIHAycF9jdHJsX2Rpc2FsbG93X2ZyZXEod3BhX3MsIHBhcmFtKTsKCglpZiAob3Nfc3RyY21wKGNtZCwgImRpc2NfaW50IikgPT0gMCkgewoJCWludCBtaW5fZGlzY19pbnQsIG1heF9kaXNjX2ludCwgbWF4X2Rpc2NfdHU7CgkJY2hhciAqcG9zOwoKCQlwb3MgPSBwYXJhbTsKCgkJbWluX2Rpc2NfaW50ID0gYXRvaShwb3MpOwoJCXBvcyA9IG9zX3N0cmNocihwb3MsICcgJyk7CgkJaWYgKHBvcyA9PSBOVUxMKQoJCQlyZXR1cm4gLTE7CgkJKnBvcysrID0gJ1wwJzsKCgkJbWF4X2Rpc2NfaW50ID0gYXRvaShwb3MpOwoJCXBvcyA9IG9zX3N0cmNocihwb3MsICcgJyk7CgkJaWYgKHBvcyA9PSBOVUxMKQoJCQlyZXR1cm4gLTE7CgkJKnBvcysrID0gJ1wwJzsKCgkJbWF4X2Rpc2NfdHUgPSBhdG9pKHBvcyk7CgoJCXJldHVybiBwMnBfc2V0X2Rpc2NfaW50KHdwYV9zLT5nbG9iYWwtPnAycCwgbWluX2Rpc2NfaW50LAoJCQkJCW1heF9kaXNjX2ludCwgbWF4X2Rpc2NfdHUpOwoJfQoKCWlmIChvc19zdHJjbXAoY21kLCAicGVyX3N0YV9wc2siKSA9PSAwKSB7CgkJd3BhX3MtPmdsb2JhbC0+cDJwX3Blcl9zdGFfcHNrID0gISFhdG9pKHBhcmFtKTsKCQlyZXR1cm4gMDsKCX0KCgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IFVua25vd24gUDJQX1NFVCBmaWVsZCB2YWx1ZSAnJXMnIiwKCQkgICBjbWQpOwoKCXJldHVybiAtMTsKfQoKCnN0YXRpYyB2b2lkIHAycF9jdHJsX2ZsdXNoKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MpCnsKCW9zX21lbXNldCh3cGFfcy0+cDJwX2F1dGhfaW52aXRlLCAwLCBFVEhfQUxFTik7Cgl3cGFfcy0+Zm9yY2VfbG9uZ19zZCA9IDA7CglpZiAod3BhX3MtPmdsb2JhbC0+cDJwKQoJCXAycF9mbHVzaCh3cGFfcy0+Z2xvYmFsLT5wMnApOwp9CgoKc3RhdGljIGludCBwMnBfY3RybF9wcmVzZW5jZV9yZXEoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kKQp7CgljaGFyICpwb3MsICpwb3MyOwoJdW5zaWduZWQgaW50IGR1cjEgPSAwLCBpbnQxID0gMCwgZHVyMiA9IDAsIGludDIgPSAwOwoKCWlmIChjbWRbMF0pIHsKCQlwb3MgPSBvc19zdHJjaHIoY21kLCAnICcpOwoJCWlmIChwb3MgPT0gTlVMTCkKCQkJcmV0dXJuIC0xOwoJCSpwb3MrKyA9ICdcMCc7CgkJZHVyMSA9IGF0b2koY21kKTsKCgkJcG9zMiA9IG9zX3N0cmNocihwb3MsICcgJyk7CgkJaWYgKHBvczIpCgkJCSpwb3MyKysgPSAnXDAnOwoJCWludDEgPSBhdG9pKHBvcyk7Cgl9IGVsc2UKCQlwb3MyID0gTlVMTDsKCglpZiAocG9zMikgewoJCXBvcyA9IG9zX3N0cmNocihwb3MyLCAnICcpOwoJCWlmIChwb3MgPT0gTlVMTCkKCQkJcmV0dXJuIC0xOwoJCSpwb3MrKyA9ICdcMCc7CgkJZHVyMiA9IGF0b2kocG9zMik7CgkJaW50MiA9IGF0b2kocG9zKTsKCX0KCglyZXR1cm4gd3Bhc19wMnBfcHJlc2VuY2VfcmVxKHdwYV9zLCBkdXIxLCBpbnQxLCBkdXIyLCBpbnQyKTsKfQoKCnN0YXRpYyBpbnQgcDJwX2N0cmxfZXh0X2xpc3RlbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCnsKCWNoYXIgKnBvczsKCXVuc2lnbmVkIGludCBwZXJpb2QgPSAwLCBpbnRlcnZhbCA9IDA7CgoJaWYgKGNtZFswXSkgewoJCXBvcyA9IG9zX3N0cmNocihjbWQsICcgJyk7CgkJaWYgKHBvcyA9PSBOVUxMKQoJCQlyZXR1cm4gLTE7CgkJKnBvcysrID0gJ1wwJzsKCQlwZXJpb2QgPSBhdG9pKGNtZCk7CgkJaW50ZXJ2YWwgPSBhdG9pKHBvcyk7Cgl9CgoJcmV0dXJuIHdwYXNfcDJwX2V4dF9saXN0ZW4od3BhX3MsIHBlcmlvZCwgaW50ZXJ2YWwpOwp9CgoKc3RhdGljIGludCBwMnBfY3RybF9yZW1vdmVfY2xpZW50KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNvbnN0IGNoYXIgKmNtZCkKewoJY29uc3QgY2hhciAqcG9zOwoJdTggcGVlcltFVEhfQUxFTl07CglpbnQgaWZhY2VfYWRkciA9IDA7CgoJcG9zID0gY21kOwoJaWYgKG9zX3N0cm5jbXAocG9zLCAiaWZhY2U9IiwgNikgPT0gMCkgewoJCWlmYWNlX2FkZHIgPSAxOwoJCXBvcyArPSA2OwoJfQoJaWYgKGh3YWRkcl9hdG9uKHBvcywgcGVlcikpCgkJcmV0dXJuIC0xOwoKCXdwYXNfcDJwX3JlbW92ZV9jbGllbnQod3BhX3MsIHBlZXIsIGlmYWNlX2FkZHIpOwoJcmV0dXJuIDA7Cn0KCiNlbmRpZiAvKiBDT05GSUdfUDJQICovCgoKI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKc3RhdGljIGludCBjdHJsX2ludGVyd29ya2luZ19jb25uZWN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmRzdCkKewoJdTggYnNzaWRbRVRIX0FMRU5dOwoJc3RydWN0IHdwYV9ic3MgKmJzczsKCglpZiAoaHdhZGRyX2F0b24oZHN0LCBic3NpZCkpIHsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkludmFsaWQgQlNTSUQgJyVzJyIsIGRzdCk7CgkJcmV0dXJuIC0xOwoJfQoKCWJzcyA9IHdwYV9ic3NfZ2V0X2Jzc2lkKHdwYV9zLCBic3NpZCk7CglpZiAoYnNzID09IE5VTEwpIHsKCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNvdWxkIG5vdCBmaW5kIEJTUyAiIE1BQ1NUUiwKCQkJICAgTUFDMlNUUihic3NpZCkpOwoJCXJldHVybiAtMTsKCX0KCglyZXR1cm4gaW50ZXJ3b3JraW5nX2Nvbm5lY3Qod3BhX3MsIGJzcyk7Cn0KCgpzdGF0aWMgaW50IGdldF9hbnFwKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmRzdCkKewoJdTggZHN0X2FkZHJbRVRIX0FMRU5dOwoJaW50IHVzZWQ7CgljaGFyICpwb3M7CiNkZWZpbmUgTUFYX0FOUVBfSU5GT19JRCAxMDAKCXUxNiBpZFtNQVhfQU5RUF9JTkZPX0lEXTsKCXNpemVfdCBudW1faWQgPSAwOwoKCXVzZWQgPSBod2FkZHJfYXRvbjIoZHN0LCBkc3RfYWRkcik7CglpZiAodXNlZCA8IDApCgkJcmV0dXJuIC0xOwoJcG9zID0gZHN0ICsgdXNlZDsKCXdoaWxlIChudW1faWQgPCBNQVhfQU5RUF9JTkZPX0lEKSB7CgkJaWRbbnVtX2lkXSA9IGF0b2kocG9zKTsKCQlpZiAoaWRbbnVtX2lkXSkKCQkJbnVtX2lkKys7CgkJcG9zID0gb3Nfc3RyY2hyKHBvcyArIDEsICcsJyk7CgkJaWYgKHBvcyA9PSBOVUxMKQoJCQlicmVhazsKCQlwb3MrKzsKCX0KCglpZiAobnVtX2lkID09IDApCgkJcmV0dXJuIC0xOwoKCXJldHVybiBhbnFwX3NlbmRfcmVxKHdwYV9zLCBkc3RfYWRkciwgaWQsIG51bV9pZCk7Cn0KCgpzdGF0aWMgaW50IGdhc19yZXF1ZXN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCkKewoJdTggZHN0X2FkZHJbRVRIX0FMRU5dOwoJc3RydWN0IHdwYWJ1ZiAqYWR2cHJvdG8sICpxdWVyeSA9IE5VTEw7CglpbnQgdXNlZCwgcmV0ID0gLTE7CgljaGFyICpwb3MsICplbmQ7CglzaXplX3QgbGVuOwoKCXVzZWQgPSBod2FkZHJfYXRvbjIoY21kLCBkc3RfYWRkcik7CglpZiAodXNlZCA8IDApCgkJcmV0dXJuIC0xOwoKCXBvcyA9IGNtZCArIHVzZWQ7Cgl3aGlsZSAoKnBvcyA9PSAnICcpCgkJcG9zKys7CgoJLyogQWR2ZXJ0aXNlbWVudCBQcm90b2NvbCBJRCAqLwoJZW5kID0gb3Nfc3RyY2hyKHBvcywgJyAnKTsKCWlmIChlbmQpCgkJbGVuID0gZW5kIC0gcG9zOwoJZWxzZQoJCWxlbiA9IG9zX3N0cmxlbihwb3MpOwoJaWYgKGxlbiAmIDB4MDEpCgkJcmV0dXJuIC0xOwoJbGVuIC89IDI7CglpZiAobGVuID09IDApCgkJcmV0dXJuIC0xOwoJYWR2cHJvdG8gPSB3cGFidWZfYWxsb2MobGVuKTsKCWlmIChhZHZwcm90byA9PSBOVUxMKQoJCXJldHVybiAtMTsKCWlmIChoZXhzdHIyYmluKHBvcywgd3BhYnVmX3B1dChhZHZwcm90bywgbGVuKSwgbGVuKSA8IDApCgkJZ290byBmYWlsOwoKCWlmIChlbmQpIHsKCQkvKiBPcHRpb25hbCBRdWVyeSBSZXF1ZXN0ICovCgkJcG9zID0gZW5kICsgMTsKCQl3aGlsZSAoKnBvcyA9PSAnICcpCgkJCXBvcysrOwoKCQlsZW4gPSBvc19zdHJsZW4ocG9zKTsKCQlpZiAobGVuKSB7CgkJCWlmIChsZW4gJiAweDAxKQoJCQkJZ290byBmYWlsOwoJCQlsZW4gLz0gMjsKCQkJaWYgKGxlbiA9PSAwKQoJCQkJZ290byBmYWlsOwoJCQlxdWVyeSA9IHdwYWJ1Zl9hbGxvYyhsZW4pOwoJCQlpZiAocXVlcnkgPT0gTlVMTCkKCQkJCWdvdG8gZmFpbDsKCQkJaWYgKGhleHN0cjJiaW4ocG9zLCB3cGFidWZfcHV0KHF1ZXJ5LCBsZW4pLCBsZW4pIDwgMCkKCQkJCWdvdG8gZmFpbDsKCQl9Cgl9CgoJcmV0ID0gZ2FzX3NlbmRfcmVxdWVzdCh3cGFfcywgZHN0X2FkZHIsIGFkdnByb3RvLCBxdWVyeSk7CgpmYWlsOgoJd3BhYnVmX2ZyZWUoYWR2cHJvdG8pOwoJd3BhYnVmX2ZyZWUocXVlcnkpOwoKCXJldHVybiByZXQ7Cn0KCgpzdGF0aWMgaW50IGdhc19yZXNwb25zZV9nZXQoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqY21kLCBjaGFyICpidWYsCgkJCSAgICBzaXplX3QgYnVmbGVuKQp7Cgl1OCBhZGRyW0VUSF9BTEVOXTsKCWludCBkaWFsb2dfdG9rZW47CglpbnQgdXNlZDsKCWNoYXIgKnBvczsKCXNpemVfdCByZXNwX2xlbiwgc3RhcnQsIHJlcXVlc3RlZF9sZW47CgoJaWYgKCF3cGFfcy0+bGFzdF9nYXNfcmVzcCkKCQlyZXR1cm4gLTE7CgoJdXNlZCA9IGh3YWRkcl9hdG9uMihjbWQsIGFkZHIpOwoJaWYgKHVzZWQgPCAwKQoJCXJldHVybiAtMTsKCglwb3MgPSBjbWQgKyB1c2VkOwoJd2hpbGUgKCpwb3MgPT0gJyAnKQoJCXBvcysrOwoJZGlhbG9nX3Rva2VuID0gYXRvaShwb3MpOwoKCWlmIChvc19tZW1jbXAoYWRkciwgd3BhX3MtPmxhc3RfZ2FzX2FkZHIsIEVUSF9BTEVOKSAhPSAwIHx8CgkgICAgZGlhbG9nX3Rva2VuICE9IHdwYV9zLT5sYXN0X2dhc19kaWFsb2dfdG9rZW4pCgkJcmV0dXJuIC0xOwoKCXJlc3BfbGVuID0gd3BhYnVmX2xlbih3cGFfcy0+bGFzdF9nYXNfcmVzcCk7CglzdGFydCA9IDA7CglyZXF1ZXN0ZWRfbGVuID0gcmVzcF9sZW47CgoJcG9zID0gb3Nfc3RyY2hyKHBvcywgJyAnKTsKCWlmIChwb3MpIHsKCQlzdGFydCA9IGF0b2kocG9zKTsKCQlpZiAoc3RhcnQgPiByZXNwX2xlbikKCQkJcmV0dXJuIG9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLCAiRkFJTC1JbnZhbGlkIHJhbmdlIik7CgkJcG9zID0gb3Nfc3RyY2hyKHBvcywgJywnKTsKCQlpZiAocG9zID09IE5VTEwpCgkJCXJldHVybiAtMTsKCQlwb3MrKzsKCQlyZXF1ZXN0ZWRfbGVuID0gYXRvaShwb3MpOwoJCWlmIChzdGFydCArIHJlcXVlc3RlZF9sZW4gPiByZXNwX2xlbikKCQkJcmV0dXJuIG9zX3NucHJpbnRmKGJ1ZiwgYnVmbGVuLCAiRkFJTC1JbnZhbGlkIHJhbmdlIik7Cgl9CgoJaWYgKHJlcXVlc3RlZF9sZW4gKiAyICsgMSA+IGJ1ZmxlbikKCQlyZXR1cm4gb3Nfc25wcmludGYoYnVmLCBidWZsZW4sICJGQUlMLVRvbyBsb25nIHJlc3BvbnNlIik7CgoJcmV0dXJuIHdwYV9zbnByaW50Zl9oZXgoYnVmLCBidWZsZW4sCgkJCQl3cGFidWZfaGVhZF91OCh3cGFfcy0+bGFzdF9nYXNfcmVzcCkgKyBzdGFydCwKCQkJCXJlcXVlc3RlZF9sZW4pOwp9CiNlbmRpZiAvKiBDT05GSUdfSU5URVJXT1JLSU5HICovCgoKI2lmZGVmIENPTkZJR19IUzIwCgpzdGF0aWMgaW50IGdldF9oczIwX2FucXAoc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfcywgY2hhciAqZHN0KQp7Cgl1OCBkc3RfYWRkcltFVEhfQUxFTl07CglpbnQgdXNlZDsKCWNoYXIgKnBvczsKCXUzMiBzdWJ0eXBlcyA9IDA7CgoJdXNlZCA9IGh3YWRkcl9hdG9uMihkc3QsIGRzdF9hZGRyKTsKCWlmICh1c2VkIDwgMCkKCQlyZXR1cm4gLTE7Cglwb3MgPSBkc3QgKyB1c2VkOwoJZm9yICg7OykgewoJCWludCBudW0gPSBhdG9pKHBvcyk7CgkJaWYgKG51bSA8PSAwIHx8IG51bSA+IDMxKQoJCQlyZXR1cm4gLTE7CgkJc3VidHlwZXMgfD0gQklUKG51bSk7CgkJcG9zID0gb3Nfc3RyY2hyKHBvcyArIDEsICcsJyk7CgkJaWYgKHBvcyA9PSBOVUxMKQoJCQlicmVhazsKCQlwb3MrKzsKCX0KCglpZiAoc3VidHlwZXMgPT0gMCkKCQlyZXR1cm4gLTE7CgoJcmV0dXJuIGhzMjBfYW5xcF9zZW5kX3JlcSh3cGFfcywgZHN0X2FkZHIsIHN1YnR5cGVzLCBOVUxMLCAwKTsKfQoKCnN0YXRpYyBpbnQgaHMyMF9uYWlfaG9tZV9yZWFsbV9saXN0KHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsCgkJCQkgICAgY29uc3QgdTggKmFkZHIsIGNvbnN0IGNoYXIgKnJlYWxtKQp7Cgl1OCAqYnVmOwoJc2l6ZV90IHJsZW4sIGxlbjsKCWludCByZXQ7CgoJcmxlbiA9IG9zX3N0cmxlbihyZWFsbSk7CglsZW4gPSAzICsgcmxlbjsKCWJ1ZiA9IG9zX21hbGxvYyhsZW4pOwoJaWYgKGJ1ZiA9PSBOVUxMKQoJCXJldHVybiAtMTsKCWJ1ZlswXSA9IDE7IC8qIE5BSSBIb21lIFJlYWxtIENvdW50ICovCglidWZbMV0gPSAwOyAvKiBGb3JtYXR0ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIFJGQyA0MjgyICovCglidWZbMl0gPSBybGVuOwoJb3NfbWVtY3B5KGJ1ZiArIDMsIHJlYWxtLCBybGVuKTsKCglyZXQgPSBoczIwX2FucXBfc2VuZF9yZXEod3BhX3MsIGFkZHIsCgkJCQkgQklUKEhTMjBfU1RZUEVfTkFJX0hPTUVfUkVBTE1fUVVFUlkpLAoJCQkJIGJ1ZiwgbGVuKTsKCglvc19mcmVlKGJ1Zik7CgoJcmV0dXJuIHJldDsKfQoKCnN0YXRpYyBpbnQgaHMyMF9nZXRfbmFpX2hvbWVfcmVhbG1fbGlzdChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAoJCQkJCWNoYXIgKmRzdCkKewoJc3RydWN0IHdwYV9jcmVkICpjcmVkID0gd3BhX3MtPmNvbmYtPmNyZWQ7Cgl1OCBkc3RfYWRkcltFVEhfQUxFTl07CglpbnQgdXNlZDsKCXU4ICpidWY7CglzaXplX3QgbGVuOwoJaW50IHJldDsKCgl1c2VkID0gaHdhZGRyX2F0b24yKGRzdCwgZHN0X2FkZHIpOwoJaWYgKHVzZWQgPCAwKQoJCXJldHVybiAtMTsKCgl3aGlsZSAoZHN0W3VzZWRdID09ICcgJykKCQl1c2VkKys7CglpZiAob3Nfc3RybmNtcChkc3QgKyB1c2VkLCAicmVhbG09IiwgNikgPT0gMCkKCQlyZXR1cm4gaHMyMF9uYWlfaG9tZV9yZWFsbV9saXN0KHdwYV9zLCBkc3RfYWRkciwKCQkJCQkJZHN0ICsgdXNlZCArIDYpOwoKCWxlbiA9IG9zX3N0cmxlbihkc3QgKyB1c2VkKTsKCglpZiAobGVuID09IDAgJiYgY3JlZCAmJiBjcmVkLT5yZWFsbSkKCQlyZXR1cm4gaHMyMF9uYWlfaG9tZV9yZWFsbV9saXN0KHdwYV9zLCBkc3RfYWRkciwgY3JlZC0+cmVhbG0pOwoKCWlmIChsZW4gJSAxKQoJCXJldHVybiAtMTsKCWxlbiAvPSAyOwoJYnVmID0gb3NfbWFsbG9jKGxlbik7CglpZiAoYnVmID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJaWYgKGhleHN0cjJiaW4oZHN0ICsgdXNlZCwgYnVmLCBsZW4pIDwgMCkgewoJCW9zX2ZyZWUoYnVmKTsKCQlyZXR1cm4gLTE7Cgl9CgoJcmV0ID0gaHMyMF9hbnFwX3NlbmRfcmVxKHdwYV9zLCBkc3RfYWRkciwKCQkJCSBCSVQoSFMyMF9TVFlQRV9OQUlfSE9NRV9SRUFMTV9RVUVSWSksCgkJCQkgYnVmLCBsZW4pOwoJb3NfZnJlZShidWYpOwoKCXJldHVybiByZXQ7Cn0KCiNlbmRpZiAvKiBDT05GSUdfSFMyMCAqLwoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9zdGFfYXV0b2Nvbm5lY3QoCglzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCnsKCXdwYV9zLT5hdXRvX3JlY29ubmVjdF9kaXNhYmxlZCA9IGF0b2koY21kKSA9PSAwID8gMSA6IDA7CglyZXR1cm4gMDsKfQoKCiNpZmRlZiBDT05GSUdfQVVUT1NDQU4KCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9hdXRvc2NhbihzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAoJCQkJCSAgICAgIGNoYXIgKmNtZCkKewoJZW51bSB3cGFfc3RhdGVzIHN0YXRlID0gd3BhX3MtPndwYV9zdGF0ZTsKCWNoYXIgKm5ld19wYXJhbXMgPSBOVUxMOwoKCWlmIChvc19zdHJsZW4oY21kKSA+IDApIHsKCQluZXdfcGFyYW1zID0gb3Nfc3RyZHVwKGNtZCk7CgkJaWYgKG5ld19wYXJhbXMgPT0gTlVMTCkKCQkJcmV0dXJuIC0xOwoJfQoKCW9zX2ZyZWUod3BhX3MtPmNvbmYtPmF1dG9zY2FuKTsKCXdwYV9zLT5jb25mLT5hdXRvc2NhbiA9IG5ld19wYXJhbXM7CgoJaWYgKHdwYV9zLT5jb25mLT5hdXRvc2NhbiA9PSBOVUxMKQoJCWF1dG9zY2FuX2RlaW5pdCh3cGFfcyk7CgllbHNlIGlmIChzdGF0ZSA9PSBXUEFfRElTQ09OTkVDVEVEIHx8IHN0YXRlID09IFdQQV9JTkFDVElWRSkKCQlhdXRvc2Nhbl9pbml0KHdwYV9zLCAxKTsKCWVsc2UgaWYgKHN0YXRlID09IFdQQV9TQ0FOTklORykKCQl3cGFfc3VwcGxpY2FudF9yZWluaXRfYXV0b3NjYW4od3BhX3MpOwoKCXJldHVybiAwOwp9CgojZW5kaWYgLyogQ09ORklHX0FVVE9TQ0FOICovCgoKI2lmZGVmIENPTkZJR19XTk0KCnN0YXRpYyBpbnQgd3Bhc19jdHJsX2lmYWNlX3dubV9zbGVlcChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCnsKCWludCBlbnRlcjsKCWludCBpbnR2YWwgPSAwOwoJY2hhciAqcG9zOwoJaW50IHJldDsKCXN0cnVjdCB3cGFidWYgKnRmc19yZXEgPSBOVUxMOwoKCWlmIChvc19zdHJuY21wKGNtZCwgImVudGVyIiwgNSkgPT0gMCkKCQllbnRlciA9IDE7CgllbHNlIGlmIChvc19zdHJuY21wKGNtZCwgImV4aXQiLCA0KSA9PSAwKQoJCWVudGVyID0gMDsKCWVsc2UKCQlyZXR1cm4gLTE7CgoJcG9zID0gb3Nfc3Ryc3RyKGNtZCwgIiBpbnRlcnZhbD0iKTsKCWlmIChwb3MpCgkJaW50dmFsID0gYXRvaShwb3MgKyAxMCk7CgoJcG9zID0gb3Nfc3Ryc3RyKGNtZCwgIiB0ZnNfcmVxPSIpOwoJaWYgKHBvcykgewoJCWNoYXIgKmVuZDsKCQlzaXplX3QgbGVuOwoJCXBvcyArPSA5OwoJCWVuZCA9IG9zX3N0cmNocihwb3MsICcgJyk7CgkJaWYgKGVuZCkKCQkJbGVuID0gZW5kIC0gcG9zOwoJCWVsc2UKCQkJbGVuID0gb3Nfc3RybGVuKHBvcyk7CgkJaWYgKGxlbiAmIDEpCgkJCXJldHVybiAtMTsKCQlsZW4gLz0gMjsKCQl0ZnNfcmVxID0gd3BhYnVmX2FsbG9jKGxlbik7CgkJaWYgKHRmc19yZXEgPT0gTlVMTCkKCQkJcmV0dXJuIC0xOwoJCWlmIChoZXhzdHIyYmluKHBvcywgd3BhYnVmX3B1dCh0ZnNfcmVxLCBsZW4pLCBsZW4pIDwgMCkgewoJCQl3cGFidWZfZnJlZSh0ZnNfcmVxKTsKCQkJcmV0dXJuIC0xOwoJCX0KCX0KCglyZXQgPSBpZWVlODAyXzExX3NlbmRfd25tc2xlZXBfcmVxKHdwYV9zLCBlbnRlciA/IFdOTV9TTEVFUF9NT0RFX0VOVEVSIDoKCQkJCQkgICBXTk1fU0xFRVBfTU9ERV9FWElULCBpbnR2YWwsCgkJCQkJICAgdGZzX3JlcSk7Cgl3cGFidWZfZnJlZSh0ZnNfcmVxKTsKCglyZXR1cm4gcmV0Owp9CgoKc3RhdGljIGludCB3cGFzX2N0cmxfaWZhY2Vfd25tX2Jzc19xdWVyeShzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpjbWQpCnsKCWludCBxdWVyeV9yZWFzb247CgoJcXVlcnlfcmVhc29uID0gYXRvaShjbWQpOwoKCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiQ1RSTF9JRkFDRTogV05NX0JTU19RVUVSWSBxdWVyeV9yZWFzb249JWQiLAoJCSAgIHF1ZXJ5X3JlYXNvbik7CgoJcmV0dXJuIHdubV9zZW5kX2Jzc190cmFuc2l0aW9uX21nbXRfcXVlcnkod3BhX3MsIHF1ZXJ5X3JlYXNvbik7Cn0KCiNlbmRpZiAvKiBDT05GSUdfV05NICovCgoKLyogR2V0IHN0cmluZyByZXByZXNlbnRhdGlvbiBvZiBjaGFubmVsIHdpZHRoICovCnN0YXRpYyBjb25zdCBjaGFyICogY2hhbm5lbF93aWR0aF9uYW1lKGVudW0gY2hhbl93aWR0aCB3aWR0aCkKewoJc3dpdGNoICh3aWR0aCkgewoJY2FzZSBDSEFOX1dJRFRIXzIwX05PSFQ6CgkJcmV0dXJuICIyMCBNSHogKG5vIEhUKSI7CgljYXNlIENIQU5fV0lEVEhfMjA6CgkJcmV0dXJuICIyMCBNSHoiOwoJY2FzZSBDSEFOX1dJRFRIXzQwOgoJCXJldHVybiAiNDAgTUh6IjsKCWNhc2UgQ0hBTl9XSURUSF84MDoKCQlyZXR1cm4gIjgwIE1IeiI7CgljYXNlIENIQU5fV0lEVEhfODBQODA6CgkJcmV0dXJuICI4MCs4MCBNSHoiOwoJY2FzZSBDSEFOX1dJRFRIXzE2MDoKCQlyZXR1cm4gIjE2MCBNSHoiOwoJZGVmYXVsdDoKCQlyZXR1cm4gInVua25vd24iOwoJfQp9CgoKc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9zaWduYWxfcG9sbChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpidWYsCgkJCQkgICAgICBzaXplX3QgYnVmbGVuKQp7CglzdHJ1Y3Qgd3BhX3NpZ25hbF9pbmZvIHNpOwoJaW50IHJldDsKCWNoYXIgKnBvcywgKmVuZDsKCglyZXQgPSB3cGFfZHJ2X3NpZ25hbF9wb2xsKHdwYV9zLCAmc2kpOwoJaWYgKHJldCkKCQlyZXR1cm4gLTE7CgoJcG9zID0gYnVmOwoJZW5kID0gYnVmICsgYnVmbGVuOwoKCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAiUlNTST0lZFxuTElOS1NQRUVEPSVkXG4iCgkJCSAgIk5PSVNFPSVkXG5GUkVRVUVOQ1k9JXVcbiIsCgkJCSAgc2kuY3VycmVudF9zaWduYWwsIHNpLmN1cnJlbnRfdHhyYXRlIC8gMTAwMCwKCQkJICBzaS5jdXJyZW50X25vaXNlLCBzaS5mcmVxdWVuY3kpOwoJaWYgKHJldCA8IDAgfHwgcmV0ID4gZW5kIC0gcG9zKQoJCXJldHVybiAtMTsKCXBvcyArPSByZXQ7CgoJaWYgKHNpLmNoYW53aWR0aCAhPSBDSEFOX1dJRFRIX1VOS05PV04pIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIldJRFRIPSVzXG4iLAoJCQkJICBjaGFubmVsX3dpZHRoX25hbWUoc2kuY2hhbndpZHRoKSk7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID4gZW5kIC0gcG9zKQoJCQlyZXR1cm4gLTE7CgkJcG9zICs9IHJldDsKCX0KCglpZiAoc2kuY2VudGVyX2ZycTEgPiAwICYmIHNpLmNlbnRlcl9mcnEyID4gMCkgewoJCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLAoJCQkJICAiQ0VOVEVSX0ZSUTE9JWRcbkNFTlRFUl9GUlEyPSVkXG4iLAoJCQkJICBzaS5jZW50ZXJfZnJxMSwgc2kuY2VudGVyX2ZycTIpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+IGVuZCAtIHBvcykKCQkJcmV0dXJuIC0xOwoJCXBvcyArPSByZXQ7Cgl9CgoJaWYgKHNpLmF2Z19zaWduYWwpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywKCQkJCSAgIkFWR19SU1NJPSVkXG4iLCBzaS5hdmdfc2lnbmFsKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gLTE7CgkJcG9zICs9IHJldDsKCX0KCglyZXR1cm4gcG9zIC0gYnVmOwp9CgoKc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9wa3RjbnRfcG9sbChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLCBjaGFyICpidWYsCgkJCQkgICAgICBzaXplX3QgYnVmbGVuKQp7CglzdHJ1Y3QgaG9zdGFwX3N0YV9kcml2ZXJfZGF0YSBzdGE7CglpbnQgcmV0OwoKCXJldCA9IHdwYV9kcnZfcGt0Y250X3BvbGwod3BhX3MsICZzdGEpOwoJaWYgKHJldCkKCQlyZXR1cm4gLTE7CgoJcmV0ID0gb3Nfc25wcmludGYoYnVmLCBidWZsZW4sICJUWEdPT0Q9JWx1XG5UWEJBRD0lbHVcblJYR09PRD0lbHVcbiIsCgkJCSAgc3RhLnR4X3BhY2tldHMsIHN0YS50eF9yZXRyeV9mYWlsZWQsIHN0YS5yeF9wYWNrZXRzKTsKCWlmIChyZXQgPCAwIHx8IChzaXplX3QpIHJldCA+IGJ1ZmxlbikKCQlyZXR1cm4gLTE7CglyZXR1cm4gcmV0Owp9CgoKI2lmZGVmIEFORFJPSUQKc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9kcml2ZXJfY21kKHN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3MsIGNoYXIgKmNtZCwKCQkJCSAgICAgY2hhciAqYnVmLCBzaXplX3QgYnVmbGVuKQp7CglpbnQgcmV0OwoKCXJldCA9IHdwYV9kcnZfZHJpdmVyX2NtZCh3cGFfcywgY21kLCBidWYsIGJ1Zmxlbik7CglpZiAocmV0ID09IDApIHsKCQlpZiAob3Nfc3RybmNhc2VjbXAoY21kLCAiQ09VTlRSWSIsIDcpID09IDApIHsKCQkJc3RydWN0IHAycF9kYXRhICpwMnAgPSB3cGFfcy0+Z2xvYmFsLT5wMnA7CgkJCWlmIChwMnApIHsKCQkJCWNoYXIgY291bnRyeVszXTsKCQkJCWNvdW50cnlbMF0gPSBjbWRbOF07CgkJCQljb3VudHJ5WzFdID0gY21kWzldOwoJCQkJY291bnRyeVsyXSA9IDB4MDQ7CgkJCQlwMnBfc2V0X2NvdW50cnkocDJwLCBjb3VudHJ5KTsKCQkJfQoJCX0KCQlyZXQgPSBzcHJpbnRmKGJ1ZiwgIiVzXG4iLCAiT0siKTsKCX0KCXJldHVybiByZXQ7Cn0KI2VuZGlmCgoKc3RhdGljIHZvaWQgd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9mbHVzaChzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zKQp7Cgl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJGbHVzaCBhbGwgd3BhX3N1cHBsaWNhbnQgc3RhdGUiKTsKCiNpZmRlZiBDT05GSUdfUDJQCgl3cGFzX3AycF9zdG9wX2ZpbmQod3BhX3MpOwoJcDJwX2N0cmxfZmx1c2god3BhX3MpOwoJd3Bhc19wMnBfZ3JvdXBfcmVtb3ZlKHdwYV9zLCAiKiIpOwojZW5kaWYgLyogQ09ORklHX1AyUCAqLwoKI2lmZGVmIENPTkZJR19XUFNfVEVTVElORwoJd3BzX3ZlcnNpb25fbnVtYmVyID0gMHgyMDsKCXdwc190ZXN0aW5nX2R1bW15X2NyZWQgPSAwOwojZW5kaWYgLyogQ09ORklHX1dQU19URVNUSU5HICovCiNpZmRlZiBDT05GSUdfV1BTCgl3cGFzX3dwc19jYW5jZWwod3BhX3MpOwojZW5kaWYgLyogQ09ORklHX1dQUyAqLwoKI2lmZGVmIENPTkZJR19URExTX1RFU1RJTkcKCWV4dGVybiB1bnNpZ25lZCBpbnQgdGRsc190ZXN0aW5nOwoJdGRsc190ZXN0aW5nID0gMDsKI2VuZGlmIC8qIENPTkZJR19URExTX1RFU1RJTkcgKi8KI2lmZGVmIENPTkZJR19URExTCgl3cGFfZHJ2X3RkbHNfb3Blcih3cGFfcywgVERMU19FTkFCTEUsIE5VTEwpOwoJd3BhX3RkbHNfZW5hYmxlKHdwYV9zLT53cGEsIDEpOwojZW5kaWYgLyogQ09ORklHX1RETFMgKi8KCgllbG9vcF9jYW5jZWxfdGltZW91dCh3cGFfc3VwcGxpY2FudF9zdG9wX2NvdW50ZXJtZWFzdXJlcywgd3BhX3MsIE5VTEwpOwoJd3BhX3N1cHBsaWNhbnRfc3RvcF9jb3VudGVybWVhc3VyZXMod3BhX3MsIE5VTEwpOwoKCXdwYV9zLT5ub19rZWVwX2FsaXZlID0gMDsKCglvc19mcmVlKHdwYV9zLT5kaXNhbGxvd19hcHNfYnNzaWQpOwoJd3BhX3MtPmRpc2FsbG93X2Fwc19ic3NpZCA9IE5VTEw7Cgl3cGFfcy0+ZGlzYWxsb3dfYXBzX2Jzc2lkX2NvdW50ID0gMDsKCW9zX2ZyZWUod3BhX3MtPmRpc2FsbG93X2Fwc19zc2lkKTsKCXdwYV9zLT5kaXNhbGxvd19hcHNfc3NpZCA9IE5VTEw7Cgl3cGFfcy0+ZGlzYWxsb3dfYXBzX3NzaWRfY291bnQgPSAwOwoKCXdwYV9zLT5zZXRfc3RhX3VhcHNkID0gMDsKCXdwYV9zLT5zdGFfdWFwc2QgPSAwOwoKCXdwYV9kcnZfcmFkaW9fZGlzYWJsZSh3cGFfcywgMCk7CgoJd3BhX2Jzc19mbHVzaCh3cGFfcyk7Cgl3cGFfYmxhY2tsaXN0X2NsZWFyKHdwYV9zKTsKCXdwYV9zLT5leHRyYV9ibGFja2xpc3RfY291bnQgPSAwOwoJd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9yZW1vdmVfbmV0d29yayh3cGFfcywgImFsbCIpOwoJd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9yZW1vdmVfY3JlZCh3cGFfcywgImFsbCIpOwp9CgoKY2hhciAqIHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfcHJvY2VzcyhzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zLAoJCQkJCSBjaGFyICpidWYsIHNpemVfdCAqcmVzcF9sZW4pCnsKCWNoYXIgKnJlcGx5OwoJY29uc3QgaW50IHJlcGx5X3NpemUgPSA0MDk2OwoJaW50IGN0cmxfcnNwID0gMDsKCWludCByZXBseV9sZW47CgoJaWYgKG9zX3N0cm5jbXAoYnVmLCBXUEFfQ1RSTF9SU1AsIG9zX3N0cmxlbihXUEFfQ1RSTF9SU1ApKSA9PSAwIHx8CgkgICAgb3Nfc3RybmNtcChidWYsICJTRVRfTkVUV09SSyAiLCAxMikgPT0gMCB8fAoJICAgIG9zX3N0cm5jbXAoYnVmLCAiV1BTX05GQ19UQUdfUkVBRCIsIDE2KSA9PSAwIHx8CgkgICAgb3Nfc3RybmNtcChidWYsICJORkNfUkVQT1JUX0hBTkRPVkVSIiwgMTkpID09IDAgfHwKCSAgICBvc19zdHJuY21wKGJ1ZiwgIk5GQ19SWF9IQU5ET1ZFUl9TRUwiLCAxOSkgPT0gMCkgewoJCXdwYV9oZXhkdW1wX2FzY2lpX2tleShNU0dfREVCVUcsICJSWCBjdHJsX2lmYWNlIiwKCQkJCSAgICAgIChjb25zdCB1OCAqKSBidWYsIG9zX3N0cmxlbihidWYpKTsKCX0gZWxzZSB7CgkJaW50IGxldmVsID0gTVNHX0RFQlVHOwoJCWlmIChvc19zdHJjbXAoYnVmLCAiUElORyIpID09IDApCgkJCWxldmVsID0gTVNHX0VYQ0VTU0lWRTsKCQl3cGFfaGV4ZHVtcF9hc2NpaShsZXZlbCwgIlJYIGN0cmxfaWZhY2UiLAoJCQkJICAoY29uc3QgdTggKikgYnVmLCBvc19zdHJsZW4oYnVmKSk7CgkJd3BhX2RiZyh3cGFfcywgbGV2ZWwsICJDb250cm9sIGludGVyZmFjZSBjb21tYW5kICclcyciLCBidWYpOwoJfQoKCXJlcGx5ID0gb3NfbWFsbG9jKHJlcGx5X3NpemUpOwoJaWYgKHJlcGx5ID09IE5VTEwpIHsKCQkqcmVzcF9sZW4gPSAxOwoJCXJldHVybiBOVUxMOwoJfQoKCW9zX21lbWNweShyZXBseSwgIk9LXG4iLCAzKTsKCXJlcGx5X2xlbiA9IDM7CgoJaWYgKG9zX3N0cmNtcChidWYsICJQSU5HIikgPT0gMCkgewoJCW9zX21lbWNweShyZXBseSwgIlBPTkdcbiIsIDUpOwoJCXJlcGx5X2xlbiA9IDU7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJJRk5BTUUiKSA9PSAwKSB7CgkJcmVwbHlfbGVuID0gb3Nfc3RybGVuKHdwYV9zLT5pZm5hbWUpOwoJCW9zX21lbWNweShyZXBseSwgd3BhX3MtPmlmbmFtZSwgcmVwbHlfbGVuKTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJSRUxPRyIsIDUpID09IDApIHsKCQlpZiAod3BhX2RlYnVnX3Jlb3Blbl9maWxlKCkgPCAwKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJOT1RFICIsIDUpID09IDApIHsKCQl3cGFfcHJpbnRmKE1TR19JTkZPLCAiTk9URTogJXMiLCBidWYgKyA1KTsKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIk1JQiIpID09IDApIHsKCQlyZXBseV9sZW4gPSB3cGFfc21fZ2V0X21pYih3cGFfcy0+d3BhLCByZXBseSwgcmVwbHlfc2l6ZSk7CgkJaWYgKHJlcGx5X2xlbiA+PSAwKSB7CgkJCWludCByZXM7CgkJCXJlcyA9IGVhcG9sX3NtX2dldF9taWIod3BhX3MtPmVhcG9sLCByZXBseSArIHJlcGx5X2xlbiwKCQkJCQkgICAgICAgcmVwbHlfc2l6ZSAtIHJlcGx5X2xlbik7CgkJCWlmIChyZXMgPCAwKQoJCQkJcmVwbHlfbGVuID0gLTE7CgkJCWVsc2UKCQkJCXJlcGx5X2xlbiArPSByZXM7CgkJfQoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlNUQVRVUyIsIDYpID09IDApIHsKCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3N0YXR1cygKCQkJd3BhX3MsIGJ1ZiArIDYsIHJlcGx5LCByZXBseV9zaXplKTsKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIlBNS1NBIikgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYV9zbV9wbWtzYV9jYWNoZV9saXN0KHdwYV9zLT53cGEsIHJlcGx5LAoJCQkJCQkgICAgcmVwbHlfc2l6ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiU0VUICIsIDQpID09IDApIHsKCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9zZXQod3BhX3MsIGJ1ZiArIDQpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJHRVQgIiwgNCkgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfZ2V0KHdwYV9zLCBidWYgKyA0LAoJCQkJCQkJICByZXBseSwgcmVwbHlfc2l6ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJMT0dPTiIpID09IDApIHsKCQllYXBvbF9zbV9ub3RpZnlfbG9nb2ZmKHdwYV9zLT5lYXBvbCwgRkFMU0UpOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiTE9HT0ZGIikgPT0gMCkgewoJCWVhcG9sX3NtX25vdGlmeV9sb2dvZmYod3BhX3MtPmVhcG9sLCBUUlVFKTsKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIlJFQVNTT0NJQVRFIikgPT0gMCkgewoJCWlmICh3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9JTlRFUkZBQ0VfRElTQUJMRUQpCgkJCXJlcGx5X2xlbiA9IC0xOwoJCWVsc2UKCQkJd3Bhc19yZXF1ZXN0X2Nvbm5lY3Rpb24od3BhX3MpOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiUkVDT05ORUNUIikgPT0gMCkgewoJCWlmICh3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9JTlRFUkZBQ0VfRElTQUJMRUQpCgkJCXJlcGx5X2xlbiA9IC0xOwoJCWVsc2UgaWYgKHdwYV9zLT5kaXNjb25uZWN0ZWQpCgkJCXdwYXNfcmVxdWVzdF9jb25uZWN0aW9uKHdwYV9zKTsKI2lmZGVmIElFRUU4MDIxWF9FQVBPTAoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlBSRUFVVEggIiwgOCkgPT0gMCkgewoJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3ByZWF1dGgod3BhX3MsIGJ1ZiArIDgpKQoJCQlyZXBseV9sZW4gPSAtMTsKI2VuZGlmIC8qIElFRUU4MDIxWF9FQVBPTCAqLwojaWZkZWYgQ09ORklHX1BFRVJLRVkKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJTVEtTVEFSVCAiLCA5KSA9PSAwKSB7CgkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc3Rrc3RhcnQod3BhX3MsIGJ1ZiArIDkpKQoJCQlyZXBseV9sZW4gPSAtMTsKI2VuZGlmIC8qIENPTkZJR19QRUVSS0VZICovCiNpZmRlZiBDT05GSUdfSUVFRTgwMjExUgoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkZUX0RTICIsIDYpID09IDApIHsKCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9mdF9kcyh3cGFfcywgYnVmICsgNikpCgkJCXJlcGx5X2xlbiA9IC0xOwojZW5kaWYgLyogQ09ORklHX0lFRUU4MDIxMVIgKi8KI2lmZGVmIENPTkZJR19XUFMKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIldQU19QQkMiKSA9PSAwKSB7CgkJaW50IHJlcyA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX3BiYyh3cGFfcywgTlVMTCk7CgkJaWYgKHJlcyA9PSAtMikgewoJCQlvc19tZW1jcHkocmVwbHksICJGQUlMLVBCQy1PVkVSTEFQXG4iLCAxNyk7CgkJCXJlcGx5X2xlbiA9IDE3OwoJCX0gZWxzZSBpZiAocmVzKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXUFNfUEJDICIsIDgpID09IDApIHsKCQlpbnQgcmVzID0gd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfcGJjKHdwYV9zLCBidWYgKyA4KTsKCQlpZiAocmVzID09IC0yKSB7CgkJCW9zX21lbWNweShyZXBseSwgIkZBSUwtUEJDLU9WRVJMQVBcbiIsIDE3KTsKCQkJcmVwbHlfbGVuID0gMTc7CgkJfSBlbHNlIGlmIChyZXMpCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIldQU19QSU4gIiwgOCkgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX3Bpbih3cGFfcywgYnVmICsgOCwKCQkJCQkJCSAgICAgIHJlcGx5LAoJCQkJCQkJICAgICAgcmVwbHlfc2l6ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiV1BTX0NIRUNLX1BJTiAiLCAxNCkgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX2NoZWNrX3BpbigKCQkJd3BhX3MsIGJ1ZiArIDE0LCByZXBseSwgcmVwbHlfc2l6ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJXUFNfQ0FOQ0VMIikgPT0gMCkgewoJCWlmICh3cGFzX3dwc19jYW5jZWwod3BhX3MpKQoJCQlyZXBseV9sZW4gPSAtMTsKI2lmZGVmIENPTkZJR19XUFNfTkZDCgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJXUFNfTkZDIikgPT0gMCkgewoJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3dwc19uZmMod3BhX3MsIE5VTEwpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXUFNfTkZDICIsIDgpID09IDApIHsKCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfbmZjKHdwYV9zLCBidWYgKyA4KSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiV1BTX05GQ19DT05GSUdfVE9LRU4gIiwgMjEpID09IDApIHsKCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3dwc19uZmNfY29uZmlnX3Rva2VuKAoJCQl3cGFfcywgYnVmICsgMjEsIHJlcGx5LCByZXBseV9zaXplKTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXUFNfTkZDX1RPS0VOICIsIDE0KSA9PSAwKSB7CgkJcmVwbHlfbGVuID0gd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfbmZjX3Rva2VuKAoJCQl3cGFfcywgYnVmICsgMTQsIHJlcGx5LCByZXBseV9zaXplKTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXUFNfTkZDX1RBR19SRUFEICIsIDE3KSA9PSAwKSB7CgkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX25mY190YWdfcmVhZCh3cGFfcywKCQkJCQkJCSAgICAgICBidWYgKyAxNykpCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIk5GQ19HRVRfSEFORE9WRVJfUkVRICIsIDIxKSA9PSAwKSB7CgkJcmVwbHlfbGVuID0gd3Bhc19jdHJsX25mY19nZXRfaGFuZG92ZXJfcmVxKAoJCQl3cGFfcywgYnVmICsgMjEsIHJlcGx5LCByZXBseV9zaXplKTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJORkNfR0VUX0hBTkRPVkVSX1NFTCAiLCAyMSkgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYXNfY3RybF9uZmNfZ2V0X2hhbmRvdmVyX3NlbCgKCQkJd3BhX3MsIGJ1ZiArIDIxLCByZXBseSwgcmVwbHlfc2l6ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiTkZDX1JYX0hBTkRPVkVSX1JFUSAiLCAyMCkgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYXNfY3RybF9uZmNfcnhfaGFuZG92ZXJfcmVxKAoJCQl3cGFfcywgYnVmICsgMjAsIHJlcGx5LCByZXBseV9zaXplKTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJORkNfUlhfSEFORE9WRVJfU0VMICIsIDIwKSA9PSAwKSB7CgkJaWYgKHdwYXNfY3RybF9uZmNfcnhfaGFuZG92ZXJfc2VsKHdwYV9zLCBidWYgKyAyMCkpCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIk5GQ19SRVBPUlRfSEFORE9WRVIgIiwgMjApID09IDApIHsKCQlpZiAod3Bhc19jdHJsX25mY19yZXBvcnRfaGFuZG92ZXIod3BhX3MsIGJ1ZiArIDIwKSkKCQkJcmVwbHlfbGVuID0gLTE7CiNlbmRpZiAvKiBDT05GSUdfV1BTX05GQyAqLwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIldQU19SRUcgIiwgOCkgPT0gMCkgewoJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3dwc19yZWcod3BhX3MsIGJ1ZiArIDgpKQoJCQlyZXBseV9sZW4gPSAtMTsKI2lmZGVmIENPTkZJR19BUAoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIldQU19BUF9QSU4gIiwgMTEpID09IDApIHsKCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3dwc19hcF9waW4oCgkJCXdwYV9zLCBidWYgKyAxMSwgcmVwbHksIHJlcGx5X3NpemUpOwojZW5kaWYgLyogQ09ORklHX0FQICovCiNpZmRlZiBDT05GSUdfV1BTX0VSCgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJXUFNfRVJfU1RBUlQiKSA9PSAwKSB7CgkJaWYgKHdwYXNfd3BzX2VyX3N0YXJ0KHdwYV9zLCBOVUxMKSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiV1BTX0VSX1NUQVJUICIsIDEzKSA9PSAwKSB7CgkJaWYgKHdwYXNfd3BzX2VyX3N0YXJ0KHdwYV9zLCBidWYgKyAxMykpCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiV1BTX0VSX1NUT1AiKSA9PSAwKSB7CgkJaWYgKHdwYXNfd3BzX2VyX3N0b3Aod3BhX3MpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXUFNfRVJfUElOICIsIDExKSA9PSAwKSB7CgkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX2VyX3Bpbih3cGFfcywgYnVmICsgMTEpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXUFNfRVJfUEJDICIsIDExKSA9PSAwKSB7CgkJaW50IHJldCA9IHdwYXNfd3BzX2VyX3BiYyh3cGFfcywgYnVmICsgMTEpOwoJCWlmIChyZXQgPT0gLTIpIHsKCQkJb3NfbWVtY3B5KHJlcGx5LCAiRkFJTC1QQkMtT1ZFUkxBUFxuIiwgMTcpOwoJCQlyZXBseV9sZW4gPSAxNzsKCQl9IGVsc2UgaWYgKHJldCA9PSAtMykgewoJCQlvc19tZW1jcHkocmVwbHksICJGQUlMLVVOS05PV04tVVVJRFxuIiwgMTgpOwoJCQlyZXBseV9sZW4gPSAxODsKCQl9IGVsc2UgaWYgKHJldCA9PSAtNCkgewoJCQlvc19tZW1jcHkocmVwbHksICJGQUlMLU5PLUFQLVNFVFRJTkdTXG4iLCAyMCk7CgkJCXJlcGx5X2xlbiA9IDIwOwoJCX0gZWxzZSBpZiAocmV0KQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXUFNfRVJfTEVBUk4gIiwgMTMpID09IDApIHsKCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfZXJfbGVhcm4od3BhX3MsIGJ1ZiArIDEzKSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiV1BTX0VSX1NFVF9DT05GSUcgIiwgMTgpID09IDApIHsKCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfZXJfc2V0X2NvbmZpZyh3cGFfcywKCQkJCQkJCQlidWYgKyAxOCkpCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIldQU19FUl9DT05GSUcgIiwgMTQpID09IDApIHsKCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV93cHNfZXJfY29uZmlnKHdwYV9zLCBidWYgKyAxNCkpCgkJCXJlcGx5X2xlbiA9IC0xOwojaWZkZWYgQ09ORklHX1dQU19ORkMKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXUFNfRVJfTkZDX0NPTkZJR19UT0tFTiAiLCAyNCkgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfd3BzX2VyX25mY19jb25maWdfdG9rZW4oCgkJCXdwYV9zLCBidWYgKyAyNCwgcmVwbHksIHJlcGx5X3NpemUpOwojZW5kaWYgLyogQ09ORklHX1dQU19ORkMgKi8KI2VuZGlmIC8qIENPTkZJR19XUFNfRVIgKi8KI2VuZGlmIC8qIENPTkZJR19XUFMgKi8KI2lmZGVmIENPTkZJR19JQlNTX1JTTgoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIklCU1NfUlNOICIsIDkpID09IDApIHsKCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9pYnNzX3Jzbih3cGFfcywgYnVmICsgOSkpCgkJCXJlcGx5X2xlbiA9IC0xOwojZW5kaWYgLyogQ09ORklHX0lCU1NfUlNOICovCiNpZmRlZiBDT05GSUdfUDJQCgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiUDJQX0ZJTkQgIiwgOSkgPT0gMCkgewoJCWlmIChwMnBfY3RybF9maW5kKHdwYV9zLCBidWYgKyA5KSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJQMlBfRklORCIpID09IDApIHsKCQlpZiAocDJwX2N0cmxfZmluZCh3cGFfcywgIiIpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIlAyUF9TVE9QX0ZJTkQiKSA9PSAwKSB7CgkJd3Bhc19wMnBfc3RvcF9maW5kKHdwYV9zKTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJQMlBfQ09OTkVDVCAiLCAxMikgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHAycF9jdHJsX2Nvbm5lY3Qod3BhX3MsIGJ1ZiArIDEyLCByZXBseSwKCQkJCQkgICAgIHJlcGx5X3NpemUpOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlAyUF9MSVNURU4gIiwgMTEpID09IDApIHsKCQlpZiAocDJwX2N0cmxfbGlzdGVuKHdwYV9zLCBidWYgKyAxMSkpCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiUDJQX0xJU1RFTiIpID09IDApIHsKCQlpZiAocDJwX2N0cmxfbGlzdGVuKHdwYV9zLCAiIikpCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlAyUF9HUk9VUF9SRU1PVkUgIiwgMTcpID09IDApIHsKCQlpZiAod3Bhc19wMnBfZ3JvdXBfcmVtb3ZlKHdwYV9zLCBidWYgKyAxNykpCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiUDJQX0dST1VQX0FERCIpID09IDApIHsKCQlpZiAod3Bhc19wMnBfZ3JvdXBfYWRkKHdwYV9zLCAwLCAwLCAwKSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiUDJQX0dST1VQX0FERCAiLCAxNCkgPT0gMCkgewoJCWlmIChwMnBfY3RybF9ncm91cF9hZGQod3BhX3MsIGJ1ZiArIDE0KSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiUDJQX1BST1ZfRElTQyAiLCAxNCkgPT0gMCkgewoJCWlmIChwMnBfY3RybF9wcm92X2Rpc2Mod3BhX3MsIGJ1ZiArIDE0KSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJQMlBfR0VUX1BBU1NQSFJBU0UiKSA9PSAwKSB7CgkJcmVwbHlfbGVuID0gcDJwX2dldF9wYXNzcGhyYXNlKHdwYV9zLCByZXBseSwgcmVwbHlfc2l6ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiUDJQX1NFUlZfRElTQ19SRVEgIiwgMTgpID09IDApIHsKCQlyZXBseV9sZW4gPSBwMnBfY3RybF9zZXJ2X2Rpc2NfcmVxKHdwYV9zLCBidWYgKyAxOCwgcmVwbHksCgkJCQkJCSAgIHJlcGx5X3NpemUpOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlAyUF9TRVJWX0RJU0NfQ0FOQ0VMX1JFUSAiLCAyNSkgPT0gMCkgewoJCWlmIChwMnBfY3RybF9zZXJ2X2Rpc2NfY2FuY2VsX3JlcSh3cGFfcywgYnVmICsgMjUpIDwgMCkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiUDJQX1NFUlZfRElTQ19SRVNQICIsIDE5KSA9PSAwKSB7CgkJaWYgKHAycF9jdHJsX3NlcnZfZGlzY19yZXNwKHdwYV9zLCBidWYgKyAxOSkgPCAwKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIlAyUF9TRVJWSUNFX1VQREFURSIpID09IDApIHsKCQl3cGFzX3AycF9zZF9zZXJ2aWNlX3VwZGF0ZSh3cGFfcyk7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiUDJQX1NFUlZfRElTQ19FWFRFUk5BTCAiLCAyMykgPT0gMCkgewoJCWlmIChwMnBfY3RybF9zZXJ2X2Rpc2NfZXh0ZXJuYWwod3BhX3MsIGJ1ZiArIDIzKSA8IDApCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiUDJQX1NFUlZJQ0VfRkxVU0giKSA9PSAwKSB7CgkJd3Bhc19wMnBfc2VydmljZV9mbHVzaCh3cGFfcyk7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiUDJQX1NFUlZJQ0VfQUREICIsIDE2KSA9PSAwKSB7CgkJaWYgKHAycF9jdHJsX3NlcnZpY2VfYWRkKHdwYV9zLCBidWYgKyAxNikgPCAwKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJQMlBfU0VSVklDRV9ERUwgIiwgMTYpID09IDApIHsKCQlpZiAocDJwX2N0cmxfc2VydmljZV9kZWwod3BhX3MsIGJ1ZiArIDE2KSA8IDApCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlAyUF9SRUpFQ1QgIiwgMTEpID09IDApIHsKCQlpZiAocDJwX2N0cmxfcmVqZWN0KHdwYV9zLCBidWYgKyAxMSkgPCAwKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJQMlBfSU5WSVRFICIsIDExKSA9PSAwKSB7CgkJaWYgKHAycF9jdHJsX2ludml0ZSh3cGFfcywgYnVmICsgMTEpIDwgMCkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiUDJQX1BFRVIgIiwgOSkgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHAycF9jdHJsX3BlZXIod3BhX3MsIGJ1ZiArIDksIHJlcGx5LAoJCQkJCSAgICAgIHJlcGx5X3NpemUpOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlAyUF9TRVQgIiwgOCkgPT0gMCkgewoJCWlmIChwMnBfY3RybF9zZXQod3BhX3MsIGJ1ZiArIDgpIDwgMCkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJQMlBfRkxVU0giKSA9PSAwKSB7CgkJcDJwX2N0cmxfZmx1c2god3BhX3MpOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlAyUF9VTkFVVEhPUklaRSAiLCAxNikgPT0gMCkgewoJCWlmICh3cGFzX3AycF91bmF1dGhvcml6ZSh3cGFfcywgYnVmICsgMTYpIDwgMCkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJQMlBfQ0FOQ0VMIikgPT0gMCkgewoJCWlmICh3cGFzX3AycF9jYW5jZWwod3BhX3MpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJQMlBfUFJFU0VOQ0VfUkVRICIsIDE3KSA9PSAwKSB7CgkJaWYgKHAycF9jdHJsX3ByZXNlbmNlX3JlcSh3cGFfcywgYnVmICsgMTcpIDwgMCkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJQMlBfUFJFU0VOQ0VfUkVRIikgPT0gMCkgewoJCWlmIChwMnBfY3RybF9wcmVzZW5jZV9yZXEod3BhX3MsICIiKSA8IDApCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlAyUF9FWFRfTElTVEVOICIsIDE1KSA9PSAwKSB7CgkJaWYgKHAycF9jdHJsX2V4dF9saXN0ZW4od3BhX3MsIGJ1ZiArIDE1KSA8IDApCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiUDJQX0VYVF9MSVNURU4iKSA9PSAwKSB7CgkJaWYgKHAycF9jdHJsX2V4dF9saXN0ZW4od3BhX3MsICIiKSA8IDApCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlAyUF9SRU1PVkVfQ0xJRU5UICIsIDE4KSA9PSAwKSB7CgkJaWYgKHAycF9jdHJsX3JlbW92ZV9jbGllbnQod3BhX3MsIGJ1ZiArIDE4KSA8IDApCgkJCXJlcGx5X2xlbiA9IC0xOwojZW5kaWYgLyogQ09ORklHX1AyUCAqLwojaWZkZWYgQ09ORklHX1dJRklfRElTUExBWQoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIldGRF9TVUJFTEVNX1NFVCAiLCAxNikgPT0gMCkgewoJCWlmICh3aWZpX2Rpc3BsYXlfc3ViZWxlbV9zZXQod3BhX3MtPmdsb2JhbCwgYnVmICsgMTYpIDwgMCkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiV0ZEX1NVQkVMRU1fR0VUICIsIDE2KSA9PSAwKSB7CgkJcmVwbHlfbGVuID0gd2lmaV9kaXNwbGF5X3N1YmVsZW1fZ2V0KHdwYV9zLT5nbG9iYWwsIGJ1ZiArIDE2LAoJCQkJCQkgICAgIHJlcGx5LCByZXBseV9zaXplKTsKI2VuZGlmIC8qIENPTkZJR19XSUZJX0RJU1BMQVkgKi8KI2lmZGVmIENPTkZJR19JTlRFUldPUktJTkcKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIkZFVENIX0FOUVAiKSA9PSAwKSB7CgkJaWYgKGludGVyd29ya2luZ19mZXRjaF9hbnFwKHdwYV9zKSA8IDApCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiU1RPUF9GRVRDSF9BTlFQIikgPT0gMCkgewoJCWludGVyd29ya2luZ19zdG9wX2ZldGNoX2FucXAod3BhX3MpOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIklOVEVSV09SS0lOR19TRUxFQ1QiLCAxOSkgPT0gMCkgewoJCWlmIChpbnRlcndvcmtpbmdfc2VsZWN0KHdwYV9zLCBvc19zdHJzdHIoYnVmICsgMTksICJhdXRvIikgIT0KCQkJCQlOVUxMKSA8IDApCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIklOVEVSV09SS0lOR19DT05ORUNUICIsIDIxKSA9PSAwKSB7CgkJaWYgKGN0cmxfaW50ZXJ3b3JraW5nX2Nvbm5lY3Qod3BhX3MsIGJ1ZiArIDIxKSA8IDApCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkFOUVBfR0VUICIsIDkpID09IDApIHsKCQlpZiAoZ2V0X2FucXAod3BhX3MsIGJ1ZiArIDkpIDwgMCkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiR0FTX1JFUVVFU1QgIiwgMTIpID09IDApIHsKCQlpZiAoZ2FzX3JlcXVlc3Qod3BhX3MsIGJ1ZiArIDEyKSA8IDApCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkdBU19SRVNQT05TRV9HRVQgIiwgMTcpID09IDApIHsKCQlyZXBseV9sZW4gPSBnYXNfcmVzcG9uc2VfZ2V0KHdwYV9zLCBidWYgKyAxNywgcmVwbHksCgkJCQkJICAgICByZXBseV9zaXplKTsKI2VuZGlmIC8qIENPTkZJR19JTlRFUldPUktJTkcgKi8KI2lmZGVmIENPTkZJR19IUzIwCgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiSFMyMF9BTlFQX0dFVCAiLCAxNCkgPT0gMCkgewoJCWlmIChnZXRfaHMyMF9hbnFwKHdwYV9zLCBidWYgKyAxNCkgPCAwKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJIUzIwX0dFVF9OQUlfSE9NRV9SRUFMTV9MSVNUICIsIDI5KSA9PSAwKSB7CgkJaWYgKGhzMjBfZ2V0X25haV9ob21lX3JlYWxtX2xpc3Qod3BhX3MsIGJ1ZiArIDI5KSA8IDApCgkJCXJlcGx5X2xlbiA9IC0xOwojZW5kaWYgLyogQ09ORklHX0hTMjAgKi8KCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsIFdQQV9DVFJMX1JTUCwgb3Nfc3RybGVuKFdQQV9DVFJMX1JTUCkpID09IDApCgl7CgkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfY3RybF9yc3AoCgkJCSAgICB3cGFfcywgYnVmICsgb3Nfc3RybGVuKFdQQV9DVFJMX1JTUCkpKQoJCQlyZXBseV9sZW4gPSAtMTsKCQllbHNlCgkJCWN0cmxfcnNwID0gMTsKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIlJFQ09ORklHVVJFIikgPT0gMCkgewoJCWlmICh3cGFfc3VwcGxpY2FudF9yZWxvYWRfY29uZmlndXJhdGlvbih3cGFfcykpCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiVEVSTUlOQVRFIikgPT0gMCkgewoJCXdwYV9zdXBwbGljYW50X3Rlcm1pbmF0ZV9wcm9jKHdwYV9zLT5nbG9iYWwpOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkJTU0lEICIsIDYpID09IDApIHsKCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9ic3NpZCh3cGFfcywgYnVmICsgNikpCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkJMQUNLTElTVCIsIDkpID09IDApIHsKCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2JsYWNrbGlzdCgKCQkJd3BhX3MsIGJ1ZiArIDksIHJlcGx5LCByZXBseV9zaXplKTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJMT0dfTEVWRUwiLCA5KSA9PSAwKSB7CgkJcmVwbHlfbGVuID0gd3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9sb2dfbGV2ZWwoCgkJCXdwYV9zLCBidWYgKyA5LCByZXBseSwgcmVwbHlfc2l6ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJMSVNUX05FVFdPUktTIikgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfbGlzdF9uZXR3b3JrcygKCQkJd3BhX3MsIHJlcGx5LCByZXBseV9zaXplKTsKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIkRJU0NPTk5FQ1QiKSA9PSAwKSB7CiNpZmRlZiBDT05GSUdfU01FCgkJd3BhX3MtPnNtZS5wcmV2X2Jzc2lkX3NldCA9IDA7CiNlbmRpZiAvKiBDT05GSUdfU01FICovCgkJd3BhX3MtPnJlYXNzb2NpYXRlID0gMDsKCQl3cGFfcy0+ZGlzY29ubmVjdGVkID0gMTsKCQl3cGFfc3VwcGxpY2FudF9jYW5jZWxfc2NoZWRfc2Nhbih3cGFfcyk7CgkJd3BhX3N1cHBsaWNhbnRfY2FuY2VsX3NjYW4od3BhX3MpOwoJCXdwYV9zdXBwbGljYW50X2RlYXV0aGVudGljYXRlKHdwYV9zLAoJCQkJCSAgICAgIFdMQU5fUkVBU09OX0RFQVVUSF9MRUFWSU5HKTsKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIlNDQU4iKSA9PSAwIHx8CgkJICAgb3Nfc3RybmNtcChidWYsICJTQ0FOICIsIDUpID09IDApIHsKCQlpZiAod3BhX3MtPndwYV9zdGF0ZSA9PSBXUEFfSU5URVJGQUNFX0RJU0FCTEVEKQoJCQlyZXBseV9sZW4gPSAtMTsKCQllbHNlIHsKCQkJaWYgKG9zX3N0cmxlbihidWYpID4gNCAmJgoJCQkgICAgb3Nfc3RybmNhc2VjbXAoYnVmICsgNSwgIlRZUEU9T05MWSIsIDkpID09IDApCgkJCQl3cGFfcy0+c2Nhbl9yZXNfaGFuZGxlciA9IHNjYW5fb25seV9oYW5kbGVyOwoJCQlpZiAoIXdwYV9zLT5zY2hlZF9zY2FubmluZyAmJiAhd3BhX3MtPnNjYW5uaW5nICYmCgkJCSAgICAoKHdwYV9zLT53cGFfc3RhdGUgPD0gV1BBX1NDQU5OSU5HKSB8fAoJCQkgICAgICh3cGFfcy0+d3BhX3N0YXRlID09IFdQQV9DT01QTEVURUQpKSkgewoJCQkJd3BhX3MtPm5vcm1hbF9zY2FucyA9IDA7CgkJCQl3cGFfcy0+c2Nhbl9yZXEgPSBNQU5VQUxfU0NBTl9SRVE7CgkJCQl3cGFfc3VwcGxpY2FudF9yZXFfc2Nhbih3cGFfcywgMCwgMCk7CgkJCX0gZWxzZSBpZiAod3BhX3MtPnNjaGVkX3NjYW5uaW5nKSB7CgkJCQl3cGFfcHJpbnRmKE1TR19ERUJVRywgIlN0b3Agb25nb2luZyAiCgkJCQkJICAgInNjaGVkX3NjYW4gdG8gYWxsb3cgcmVxdWVzdGVkICIKCQkJCQkgICAiZnVsbCBzY2FuIHRvIHByb2NlZWQiKTsKCQkJCXdwYV9zdXBwbGljYW50X2NhbmNlbF9zY2hlZF9zY2FuKHdwYV9zKTsKCQkJCXdwYV9zLT5zY2FuX3JlcSA9IE1BTlVBTF9TQ0FOX1JFUTsKCQkJCXdwYV9zdXBwbGljYW50X3JlcV9zY2FuKHdwYV9zLCAwLCAwKTsKCQkJfSBlbHNlIHsKCQkJCXdwYV9wcmludGYoTVNHX0RFQlVHLCAiT25nb2luZyBzY2FuIGFjdGlvbiAtICIKCQkJCQkgICAicmVqZWN0IG5ldyByZXF1ZXN0Iik7CgkJCQlyZXBseV9sZW4gPSBvc19zbnByaW50ZihyZXBseSwgcmVwbHlfc2l6ZSwKCQkJCQkJCSJGQUlMLUJVU1lcbiIpOwoJCQl9CgkJfQoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiU0NBTl9SRVNVTFRTIikgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2Nhbl9yZXN1bHRzKAoJCQl3cGFfcywgcmVwbHksIHJlcGx5X3NpemUpOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlNFTEVDVF9ORVRXT1JLICIsIDE1KSA9PSAwKSB7CgkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2VsZWN0X25ldHdvcmsod3BhX3MsIGJ1ZiArIDE1KSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiRU5BQkxFX05FVFdPUksgIiwgMTUpID09IDApIHsKCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9lbmFibGVfbmV0d29yayh3cGFfcywgYnVmICsgMTUpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJESVNBQkxFX05FVFdPUksgIiwgMTYpID09IDApIHsKCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9kaXNhYmxlX25ldHdvcmsod3BhX3MsIGJ1ZiArIDE2KSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJBRERfTkVUV09SSyIpID09IDApIHsKCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2FkZF9uZXR3b3JrKAoJCQl3cGFfcywgcmVwbHksIHJlcGx5X3NpemUpOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlJFTU9WRV9ORVRXT1JLICIsIDE1KSA9PSAwKSB7CgkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfcmVtb3ZlX25ldHdvcmsod3BhX3MsIGJ1ZiArIDE1KSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiU0VUX05FVFdPUksgIiwgMTIpID09IDApIHsKCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9zZXRfbmV0d29yayh3cGFfcywgYnVmICsgMTIpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJHRVRfTkVUV09SSyAiLCAxMikgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfZ2V0X25ldHdvcmsoCgkJCXdwYV9zLCBidWYgKyAxMiwgcmVwbHksIHJlcGx5X3NpemUpOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiTElTVF9DUkVEUyIpID09IDApIHsKCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2xpc3RfY3JlZHMoCgkJCXdwYV9zLCByZXBseSwgcmVwbHlfc2l6ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJBRERfQ1JFRCIpID09IDApIHsKCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2FkZF9jcmVkKAoJCQl3cGFfcywgcmVwbHksIHJlcGx5X3NpemUpOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlJFTU9WRV9DUkVEICIsIDEyKSA9PSAwKSB7CgkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfcmVtb3ZlX2NyZWQod3BhX3MsIGJ1ZiArIDEyKSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiU0VUX0NSRUQgIiwgOSkgPT0gMCkgewoJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3NldF9jcmVkKHdwYV9zLCBidWYgKyA5KSkKCQkJcmVwbHlfbGVuID0gLTE7CiNpZm5kZWYgQ09ORklHX05PX0NPTkZJR19XUklURQoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiU0FWRV9DT05GSUciKSA9PSAwKSB7CgkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2F2ZV9jb25maWcod3BhX3MpKQoJCQlyZXBseV9sZW4gPSAtMTsKI2VuZGlmIC8qIENPTkZJR19OT19DT05GSUdfV1JJVEUgKi8KCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJHRVRfQ0FQQUJJTElUWSAiLCAxNSkgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfZ2V0X2NhcGFiaWxpdHkoCgkJCXdwYV9zLCBidWYgKyAxNSwgcmVwbHksIHJlcGx5X3NpemUpOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkFQX1NDQU4gIiwgOCkgPT0gMCkgewoJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2FwX3NjYW4od3BhX3MsIGJ1ZiArIDgpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJTQ0FOX0lOVEVSVkFMICIsIDE0KSA9PSAwKSB7CgkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2Vfc2Nhbl9pbnRlcnZhbCh3cGFfcywgYnVmICsgMTQpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIklOVEVSRkFDRV9MSVNUIikgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYV9zdXBwbGljYW50X2dsb2JhbF9pZmFjZV9saXN0KAoJCQl3cGFfcy0+Z2xvYmFsLCByZXBseSwgcmVwbHlfc2l6ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJJTlRFUkZBQ0VTIikgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYV9zdXBwbGljYW50X2dsb2JhbF9pZmFjZV9pbnRlcmZhY2VzKAoJCQl3cGFfcy0+Z2xvYmFsLCByZXBseSwgcmVwbHlfc2l6ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiQlNTICIsIDQpID09IDApIHsKCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2JzcygKCQkJd3BhX3MsIGJ1ZiArIDQsIHJlcGx5LCByZXBseV9zaXplKTsKI2lmZGVmIENPTkZJR19BUAoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiU1RBLUZJUlNUIikgPT0gMCkgewoJCXJlcGx5X2xlbiA9IGFwX2N0cmxfaWZhY2Vfc3RhX2ZpcnN0KHdwYV9zLCByZXBseSwgcmVwbHlfc2l6ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiU1RBICIsIDQpID09IDApIHsKCQlyZXBseV9sZW4gPSBhcF9jdHJsX2lmYWNlX3N0YSh3cGFfcywgYnVmICsgNCwgcmVwbHksCgkJCQkJICAgICAgcmVwbHlfc2l6ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiU1RBLU5FWFQgIiwgOSkgPT0gMCkgewoJCXJlcGx5X2xlbiA9IGFwX2N0cmxfaWZhY2Vfc3RhX25leHQod3BhX3MsIGJ1ZiArIDksIHJlcGx5LAoJCQkJCQkgICByZXBseV9zaXplKTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJERUFVVEhFTlRJQ0FURSAiLCAxNSkgPT0gMCkgewoJCWlmIChhcF9jdHJsX2lmYWNlX3N0YV9kZWF1dGhlbnRpY2F0ZSh3cGFfcywgYnVmICsgMTUpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJESVNBU1NPQ0lBVEUgIiwgMTMpID09IDApIHsKCQlpZiAoYXBfY3RybF9pZmFjZV9zdGFfZGlzYXNzb2NpYXRlKHdwYV9zLCBidWYgKyAxMykpCgkJCXJlcGx5X2xlbiA9IC0xOwojZW5kaWYgLyogQ09ORklHX0FQICovCgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJTVVNQRU5EIikgPT0gMCkgewoJCXdwYXNfbm90aWZ5X3N1c3BlbmQod3BhX3MtPmdsb2JhbCk7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJSRVNVTUUiKSA9PSAwKSB7CgkJd3Bhc19ub3RpZnlfcmVzdW1lKHdwYV9zLT5nbG9iYWwpOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiRFJPUF9TQSIpID09IDApIHsKCQl3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2Ryb3Bfc2Eod3BhX3MpOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlJPQU0gIiwgNSkgPT0gMCkgewoJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3JvYW0od3BhX3MsIGJ1ZiArIDUpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJTVEFfQVVUT0NPTk5FQ1QgIiwgMTYpID09IDApIHsKCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9zdGFfYXV0b2Nvbm5lY3Qod3BhX3MsIGJ1ZiArIDE2KSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiQlNTX0VYUElSRV9BR0UgIiwgMTUpID09IDApIHsKCQlpZiAod3BhX3N1cHBsaWNhbnRfY3RybF9pZmFjZV9ic3NfZXhwaXJlX2FnZSh3cGFfcywgYnVmICsgMTUpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJCU1NfRVhQSVJFX0NPVU5UICIsIDE3KSA9PSAwKSB7CgkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfYnNzX2V4cGlyZV9jb3VudCh3cGFfcywKCQkJCQkJCSAgICAgICBidWYgKyAxNykpCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkJTU19GTFVTSCAiLCAxMCkgPT0gMCkgewoJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX2Jzc19mbHVzaCh3cGFfcywgYnVmICsgMTApKQoJCQlyZXBseV9sZW4gPSAtMTsKI2lmZGVmIENPTkZJR19URExTCgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiVERMU19ESVNDT1ZFUiAiLCAxNCkgPT0gMCkgewoJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3RkbHNfZGlzY292ZXIod3BhX3MsIGJ1ZiArIDE0KSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiVERMU19TRVRVUCAiLCAxMSkgPT0gMCkgewoJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3RkbHNfc2V0dXAod3BhX3MsIGJ1ZiArIDExKSkKCQkJcmVwbHlfbGVuID0gLTE7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiVERMU19URUFSRE9XTiAiLCAxNCkgPT0gMCkgewoJCWlmICh3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3RkbHNfdGVhcmRvd24od3BhX3MsIGJ1ZiArIDE0KSkKCQkJcmVwbHlfbGVuID0gLTE7CiNlbmRpZiAvKiBDT05GSUdfVERMUyAqLwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlNJR05BTF9QT0xMIiwgMTEpID09IDApIHsKCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9zaWduYWxfcG9sbCh3cGFfcywgcmVwbHksCgkJCQkJCSAgICAgICByZXBseV9zaXplKTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJQS1RDTlRfUE9MTCIsIDExKSA9PSAwKSB7CgkJcmVwbHlfbGVuID0gd3BhX3N1cHBsaWNhbnRfcGt0Y250X3BvbGwod3BhX3MsIHJlcGx5LAoJCQkJCQkgICAgICAgcmVwbHlfc2l6ZSk7CiNpZmRlZiBDT05GSUdfQVVUT1NDQU4KCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJBVVRPU0NBTiAiLCA5KSA9PSAwKSB7CgkJaWYgKHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfYXV0b3NjYW4od3BhX3MsIGJ1ZiArIDkpKQoJCQlyZXBseV9sZW4gPSAtMTsKI2VuZGlmIC8qIENPTkZJR19BVVRPU0NBTiAqLwojaWZkZWYgQU5EUk9JRAoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIkRSSVZFUiAiLCA3KSA9PSAwKSB7CgkJcmVwbHlfbGVuID0gd3BhX3N1cHBsaWNhbnRfZHJpdmVyX2NtZCh3cGFfcywgYnVmICsgNywgcmVwbHksCgkJCQkJCSAgICAgIHJlcGx5X3NpemUpOwojZW5kaWYKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIlJFQVVUSEVOVElDQVRFIikgPT0gMCkgewoJCXBta3NhX2NhY2hlX2NsZWFyX2N1cnJlbnQod3BhX3MtPndwYSk7CgkJZWFwb2xfc21fcmVxdWVzdF9yZWF1dGgod3BhX3MtPmVhcG9sKTsKI2lmZGVmIENPTkZJR19XTk0KCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXTk1fU0xFRVAgIiwgMTApID09IDApIHsKCQlpZiAod3Bhc19jdHJsX2lmYWNlX3dubV9zbGVlcCh3cGFfcywgYnVmICsgMTApKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJXTk1fQlNTX1FVRVJZICIsIDEwKSA9PSAwKSB7CgkJaWYgKHdwYXNfY3RybF9pZmFjZV93bm1fYnNzX3F1ZXJ5KHdwYV9zLCBidWYgKyAxMCkpCgkJCQlyZXBseV9sZW4gPSAtMTsKI2VuZGlmIC8qIENPTkZJR19XTk0gKi8KCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIkZMVVNIIikgPT0gMCkgewoJCXdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfZmx1c2god3BhX3MpOwoJfSBlbHNlIHsKCQlvc19tZW1jcHkocmVwbHksICJVTktOT1dOIENPTU1BTkRcbiIsIDE2KTsKCQlyZXBseV9sZW4gPSAxNjsKCX0KCglpZiAocmVwbHlfbGVuIDwgMCkgewoJCW9zX21lbWNweShyZXBseSwgIkZBSUxcbiIsIDUpOwoJCXJlcGx5X2xlbiA9IDU7Cgl9CgoJaWYgKGN0cmxfcnNwKQoJCWVhcG9sX3NtX25vdGlmeV9jdHJsX3Jlc3BvbnNlKHdwYV9zLT5lYXBvbCk7CgoJKnJlc3BfbGVuID0gcmVwbHlfbGVuOwoJcmV0dXJuIHJlcGx5Owp9CgoKc3RhdGljIGludCB3cGFfc3VwcGxpY2FudF9nbG9iYWxfaWZhY2VfYWRkKHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsCgkJCQkJICAgY2hhciAqY21kKQp7CglzdHJ1Y3Qgd3BhX2ludGVyZmFjZSBpZmFjZTsKCWNoYXIgKnBvczsKCgkvKgoJICogPGlmbmFtZT5UQUI8Y29uZm5hbWU+VEFCPGRyaXZlcj5UQUI8Y3RybF9pbnRlcmZhY2U+VEFCPGRyaXZlcl9wYXJhbT4KCSAqIFRBQjxicmlkZ2VfaWZuYW1lPgoJICovCgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgR0xPQkFMIElOVEVSRkFDRV9BREQgJyVzJyIsIGNtZCk7CgoJb3NfbWVtc2V0KCZpZmFjZSwgMCwgc2l6ZW9mKGlmYWNlKSk7CgoJZG8gewoJCWlmYWNlLmlmbmFtZSA9IHBvcyA9IGNtZDsKCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnXHQnKTsKCQlpZiAocG9zKQoJCQkqcG9zKysgPSAnXDAnOwoJCWlmIChpZmFjZS5pZm5hbWVbMF0gPT0gJ1wwJykKCQkJcmV0dXJuIC0xOwoJCWlmIChwb3MgPT0gTlVMTCkKCQkJYnJlYWs7CgoJCWlmYWNlLmNvbmZuYW1lID0gcG9zOwoJCXBvcyA9IG9zX3N0cmNocihwb3MsICdcdCcpOwoJCWlmIChwb3MpCgkJCSpwb3MrKyA9ICdcMCc7CgkJaWYgKGlmYWNlLmNvbmZuYW1lWzBdID09ICdcMCcpCgkJCWlmYWNlLmNvbmZuYW1lID0gTlVMTDsKCQlpZiAocG9zID09IE5VTEwpCgkJCWJyZWFrOwoKCQlpZmFjZS5kcml2ZXIgPSBwb3M7CgkJcG9zID0gb3Nfc3RyY2hyKHBvcywgJ1x0Jyk7CgkJaWYgKHBvcykKCQkJKnBvcysrID0gJ1wwJzsKCQlpZiAoaWZhY2UuZHJpdmVyWzBdID09ICdcMCcpCgkJCWlmYWNlLmRyaXZlciA9IE5VTEw7CgkJaWYgKHBvcyA9PSBOVUxMKQoJCQlicmVhazsKCgkJaWZhY2UuY3RybF9pbnRlcmZhY2UgPSBwb3M7CgkJcG9zID0gb3Nfc3RyY2hyKHBvcywgJ1x0Jyk7CgkJaWYgKHBvcykKCQkJKnBvcysrID0gJ1wwJzsKCQlpZiAoaWZhY2UuY3RybF9pbnRlcmZhY2VbMF0gPT0gJ1wwJykKCQkJaWZhY2UuY3RybF9pbnRlcmZhY2UgPSBOVUxMOwoJCWlmIChwb3MgPT0gTlVMTCkKCQkJYnJlYWs7CgoJCWlmYWNlLmRyaXZlcl9wYXJhbSA9IHBvczsKCQlwb3MgPSBvc19zdHJjaHIocG9zLCAnXHQnKTsKCQlpZiAocG9zKQoJCQkqcG9zKysgPSAnXDAnOwoJCWlmIChpZmFjZS5kcml2ZXJfcGFyYW1bMF0gPT0gJ1wwJykKCQkJaWZhY2UuZHJpdmVyX3BhcmFtID0gTlVMTDsKCQlpZiAocG9zID09IE5VTEwpCgkJCWJyZWFrOwoKCQlpZmFjZS5icmlkZ2VfaWZuYW1lID0gcG9zOwoJCXBvcyA9IG9zX3N0cmNocihwb3MsICdcdCcpOwoJCWlmIChwb3MpCgkJCSpwb3MrKyA9ICdcMCc7CgkJaWYgKGlmYWNlLmJyaWRnZV9pZm5hbWVbMF0gPT0gJ1wwJykKCQkJaWZhY2UuYnJpZGdlX2lmbmFtZSA9IE5VTEw7CgkJaWYgKHBvcyA9PSBOVUxMKQoJCQlicmVhazsKCX0gd2hpbGUgKDApOwoKCWlmICh3cGFfc3VwcGxpY2FudF9nZXRfaWZhY2UoZ2xvYmFsLCBpZmFjZS5pZm5hbWUpKQoJCXJldHVybiAtMTsKCglyZXR1cm4gd3BhX3N1cHBsaWNhbnRfYWRkX2lmYWNlKGdsb2JhbCwgJmlmYWNlKSA/IDAgOiAtMTsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfZ2xvYmFsX2lmYWNlX3JlbW92ZShzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsLAoJCQkJCSAgICAgIGNoYXIgKmNtZCkKewoJc3RydWN0IHdwYV9zdXBwbGljYW50ICp3cGFfczsKCgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkNUUkxfSUZBQ0UgR0xPQkFMIElOVEVSRkFDRV9SRU1PVkUgJyVzJyIsIGNtZCk7CgoJd3BhX3MgPSB3cGFfc3VwcGxpY2FudF9nZXRfaWZhY2UoZ2xvYmFsLCBjbWQpOwoJaWYgKHdwYV9zID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJcmV0dXJuIHdwYV9zdXBwbGljYW50X3JlbW92ZV9pZmFjZShnbG9iYWwsIHdwYV9zLCAwKTsKfQoKCnN0YXRpYyB2b2lkIHdwYV9mcmVlX2lmYWNlX2luZm8oc3RydWN0IHdwYV9pbnRlcmZhY2VfaW5mbyAqaWZhY2UpCnsKCXN0cnVjdCB3cGFfaW50ZXJmYWNlX2luZm8gKnByZXY7CgoJd2hpbGUgKGlmYWNlKSB7CgkJcHJldiA9IGlmYWNlOwoJCWlmYWNlID0gaWZhY2UtPm5leHQ7CgoJCW9zX2ZyZWUocHJldi0+aWZuYW1lKTsKCQlvc19mcmVlKHByZXYtPmRlc2MpOwoJCW9zX2ZyZWUocHJldik7Cgl9Cn0KCgpzdGF0aWMgaW50IHdwYV9zdXBwbGljYW50X2dsb2JhbF9pZmFjZV9saXN0KHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsCgkJCQkJICAgIGNoYXIgKmJ1ZiwgaW50IGxlbikKewoJaW50IGksIHJlczsKCXN0cnVjdCB3cGFfaW50ZXJmYWNlX2luZm8gKmlmYWNlID0gTlVMTCwgKmxhc3QgPSBOVUxMLCAqdG1wOwoJY2hhciAqcG9zLCAqZW5kOwoKCWZvciAoaSA9IDA7IHdwYV9kcml2ZXJzW2ldOyBpKyspIHsKCQlzdHJ1Y3Qgd3BhX2RyaXZlcl9vcHMgKmRydiA9IHdwYV9kcml2ZXJzW2ldOwoJCWlmIChkcnYtPmdldF9pbnRlcmZhY2VzID09IE5VTEwpCgkJCWNvbnRpbnVlOwoJCXRtcCA9IGRydi0+Z2V0X2ludGVyZmFjZXMoZ2xvYmFsLT5kcnZfcHJpdltpXSk7CgkJaWYgKHRtcCA9PSBOVUxMKQoJCQljb250aW51ZTsKCgkJaWYgKGxhc3QgPT0gTlVMTCkKCQkJaWZhY2UgPSBsYXN0ID0gdG1wOwoJCWVsc2UKCQkJbGFzdC0+bmV4dCA9IHRtcDsKCQl3aGlsZSAobGFzdC0+bmV4dCkKCQkJbGFzdCA9IGxhc3QtPm5leHQ7Cgl9CgoJcG9zID0gYnVmOwoJZW5kID0gYnVmICsgbGVuOwoJZm9yICh0bXAgPSBpZmFjZTsgdG1wOyB0bXAgPSB0bXAtPm5leHQpIHsKCQlyZXMgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgIiVzXHQlc1x0JXNcbiIsCgkJCQkgIHRtcC0+ZHJ2X25hbWUsIHRtcC0+aWZuYW1lLAoJCQkJICB0bXAtPmRlc2MgPyB0bXAtPmRlc2MgOiAiIik7CgkJaWYgKHJlcyA8IDAgfHwgcmVzID49IGVuZCAtIHBvcykgewoJCQkqcG9zID0gJ1wwJzsKCQkJYnJlYWs7CgkJfQoJCXBvcyArPSByZXM7Cgl9CgoJd3BhX2ZyZWVfaWZhY2VfaW5mbyhpZmFjZSk7CgoJcmV0dXJuIHBvcyAtIGJ1ZjsKfQoKCnN0YXRpYyBpbnQgd3BhX3N1cHBsaWNhbnRfZ2xvYmFsX2lmYWNlX2ludGVyZmFjZXMoc3RydWN0IHdwYV9nbG9iYWwgKmdsb2JhbCwKCQkJCQkJICBjaGFyICpidWYsIGludCBsZW4pCnsKCWludCByZXM7CgljaGFyICpwb3MsICplbmQ7CglzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zOwoKCXdwYV9zID0gZ2xvYmFsLT5pZmFjZXM7Cglwb3MgPSBidWY7CgllbmQgPSBidWYgKyBsZW47CgoJd2hpbGUgKHdwYV9zKSB7CgkJcmVzID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICIlc1xuIiwgd3BhX3MtPmlmbmFtZSk7CgkJaWYgKHJlcyA8IDAgfHwgcmVzID49IGVuZCAtIHBvcykgewoJCQkqcG9zID0gJ1wwJzsKCQkJYnJlYWs7CgkJfQoJCXBvcyArPSByZXM7CgkJd3BhX3MgPSB3cGFfcy0+bmV4dDsKCX0KCXJldHVybiBwb3MgLSBidWY7Cn0KCgpzdGF0aWMgY2hhciAqIHdwYXNfZ2xvYmFsX2N0cmxfaWZhY2VfaWZuYW1lKHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsCgkJCQkJICAgIGNvbnN0IGNoYXIgKmlmbmFtZSwKCQkJCQkgICAgY2hhciAqY21kLCBzaXplX3QgKnJlc3BfbGVuKQp7CglzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zOwoKCWZvciAod3BhX3MgPSBnbG9iYWwtPmlmYWNlczsgd3BhX3M7IHdwYV9zID0gd3BhX3MtPm5leHQpIHsKCQlpZiAob3Nfc3RyY21wKGlmbmFtZSwgd3BhX3MtPmlmbmFtZSkgPT0gMCkKCQkJYnJlYWs7Cgl9CgoJaWYgKHdwYV9zID09IE5VTEwpIHsKCQljaGFyICpyZXNwID0gb3Nfc3RyZHVwKCJGQUlMLU5PLUlGTkFNRS1NQVRDSFxuIik7CgkJaWYgKHJlc3ApCgkJCSpyZXNwX2xlbiA9IG9zX3N0cmxlbihyZXNwKTsKCQllbHNlCgkJCSpyZXNwX2xlbiA9IDE7CgkJcmV0dXJuIHJlc3A7Cgl9CgoJcmV0dXJuIHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfcHJvY2Vzcyh3cGFfcywgY21kLCByZXNwX2xlbik7Cn0KCgpzdGF0aWMgY2hhciAqIHdwYXNfZ2xvYmFsX2N0cmxfaWZhY2VfcmVkaXJfcDJwKHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsCgkJCQkJICAgICAgIGNoYXIgKmJ1Ziwgc2l6ZV90ICpyZXNwX2xlbikKewojaWZkZWYgQ09ORklHX1AyUAoJc3RhdGljIGNvbnN0IGNoYXIgKiBjbWRbXSA9IHsKI2lmZGVmIEFORFJPSURfUDJQCgkJIkxJU1RfTkVUV09SS1MiLAoJCSJTQVZFX0NPTkZJRyIsCiNlbmRpZgoJCSJQMlBfRklORCIsCgkJIlAyUF9TVE9QX0ZJTkQiLAoJCSJQMlBfTElTVEVOIiwKCQkiUDJQX0dST1VQX0FERCIsCgkJIlAyUF9HRVRfUEFTU1BIUkFTRSIsCgkJIlAyUF9TRVJWSUNFX1VQREFURSIsCgkJIlAyUF9TRVJWSUNFX0ZMVVNIIiwKCQkiUDJQX0ZMVVNIIiwKCQkiUDJQX0NBTkNFTCIsCgkJIlAyUF9QUkVTRU5DRV9SRVEiLAoJCSJQMlBfRVhUX0xJU1RFTiIsCgkJTlVMTAoJfTsKCXN0YXRpYyBjb25zdCBjaGFyICogcHJlZml4W10gPSB7CiNpZmRlZiBBTkRST0lEX1AyUAoJCSJEUklWRVIgIiwKCQkiR0VUX05FVFdPUksgIiwKCQkiUkVNT1ZFX05FVFdPUksgIiwKCQkiU0VUICIsCiNlbmRpZgoJCSJQMlBfRklORCAiLAoJCSJQMlBfQ09OTkVDVCAiLAoJCSJQMlBfTElTVEVOICIsCgkJIlAyUF9HUk9VUF9SRU1PVkUgIiwKCQkiUDJQX0dST1VQX0FERCAiLAoJCSJQMlBfUFJPVl9ESVNDICIsCgkJIlAyUF9TRVJWX0RJU0NfUkVRICIsCgkJIlAyUF9TRVJWX0RJU0NfQ0FOQ0VMX1JFUSAiLAoJCSJQMlBfU0VSVl9ESVNDX1JFU1AgIiwKCQkiUDJQX1NFUlZfRElTQ19FWFRFUk5BTCAiLAoJCSJQMlBfU0VSVklDRV9BREQgIiwKCQkiUDJQX1NFUlZJQ0VfREVMICIsCgkJIlAyUF9SRUpFQ1QgIiwKCQkiUDJQX0lOVklURSAiLAoJCSJQMlBfUEVFUiAiLAoJCSJQMlBfU0VUICIsCgkJIlAyUF9VTkFVVEhPUklaRSAiLAoJCSJQMlBfUFJFU0VOQ0VfUkVRICIsCgkJIlAyUF9FWFRfTElTVEVOICIsCgkJIlAyUF9SRU1PVkVfQ0xJRU5UICIsCgkJTlVMTAoJfTsKCWludCBmb3VuZCA9IDA7CglpbnQgaTsKCglpZiAoZ2xvYmFsLT5wMnBfaW5pdF93cGFfcyA9PSBOVUxMKQoJCXJldHVybiBOVUxMOwoKCWZvciAoaSA9IDA7ICFmb3VuZCAmJiBjbWRbaV07IGkrKykgewoJCWlmIChvc19zdHJjbXAoYnVmLCBjbWRbaV0pID09IDApCgkJCWZvdW5kID0gMTsKCX0KCglmb3IgKGkgPSAwOyAhZm91bmQgJiYgcHJlZml4W2ldOyBpKyspIHsKCQlpZiAob3Nfc3RybmNtcChidWYsIHByZWZpeFtpXSwgb3Nfc3RybGVuKHByZWZpeFtpXSkpID09IDApCgkJCWZvdW5kID0gMTsKCX0KCglpZiAoZm91bmQpCgkJcmV0dXJuIHdwYV9zdXBwbGljYW50X2N0cmxfaWZhY2VfcHJvY2VzcyhnbG9iYWwtPnAycF9pbml0X3dwYV9zLAoJCQkJCQkJIGJ1ZiwgcmVzcF9sZW4pOwojZW5kaWYgLyogQ09ORklHX1AyUCAqLwoJcmV0dXJuIE5VTEw7Cn0KCgpzdGF0aWMgY2hhciAqIHdwYXNfZ2xvYmFsX2N0cmxfaWZhY2VfcmVkaXJfd2ZkKHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsCgkJCQkJICAgICAgIGNoYXIgKmJ1Ziwgc2l6ZV90ICpyZXNwX2xlbikKewojaWZkZWYgQ09ORklHX1dJRklfRElTUExBWQoJaWYgKGdsb2JhbC0+cDJwX2luaXRfd3BhX3MgPT0gTlVMTCkKCQlyZXR1cm4gTlVMTDsKCWlmIChvc19zdHJuY21wKGJ1ZiwgIldGRF9TVUJFTEVNX1NFVCAiLCAxNikgPT0gMCB8fAoJICAgIG9zX3N0cm5jbXAoYnVmLCAiV0ZEX1NVQkVMRU1fR0VUICIsIDE2KSA9PSAwKQoJCXJldHVybiB3cGFfc3VwcGxpY2FudF9jdHJsX2lmYWNlX3Byb2Nlc3MoZ2xvYmFsLT5wMnBfaW5pdF93cGFfcywKCQkJCQkJCSBidWYsIHJlc3BfbGVuKTsKI2VuZGlmIC8qIENPTkZJR19XSUZJX0RJU1BMQVkgKi8KCXJldHVybiBOVUxMOwp9CgoKc3RhdGljIGNoYXIgKiB3cGFzX2dsb2JhbF9jdHJsX2lmYWNlX3JlZGlyKHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsCgkJCQkJICAgY2hhciAqYnVmLCBzaXplX3QgKnJlc3BfbGVuKQp7CgljaGFyICpyZXQ7CgoJcmV0ID0gd3Bhc19nbG9iYWxfY3RybF9pZmFjZV9yZWRpcl9wMnAoZ2xvYmFsLCBidWYsIHJlc3BfbGVuKTsKCWlmIChyZXQpCgkJcmV0dXJuIHJldDsKCglyZXQgPSB3cGFzX2dsb2JhbF9jdHJsX2lmYWNlX3JlZGlyX3dmZChnbG9iYWwsIGJ1ZiwgcmVzcF9sZW4pOwoJaWYgKHJldCkKCQlyZXR1cm4gcmV0OwoKCXJldHVybiBOVUxMOwp9CgoKc3RhdGljIGludCB3cGFzX2dsb2JhbF9jdHJsX2lmYWNlX3NldChzdHJ1Y3Qgd3BhX2dsb2JhbCAqZ2xvYmFsLCBjaGFyICpjbWQpCnsKCWNoYXIgKnZhbHVlOwoKCXZhbHVlID0gb3Nfc3RyY2hyKGNtZCwgJyAnKTsKCWlmICh2YWx1ZSA9PSBOVUxMKQoJCXJldHVybiAtMTsKCSp2YWx1ZSsrID0gJ1wwJzsKCgl3cGFfcHJpbnRmKE1TR19ERUJVRywgIkdMT0JBTF9DVFJMX0lGQUNFIFNFVCAnJXMnPSclcyciLCBjbWQsIHZhbHVlKTsKCiNpZmRlZiBDT05GSUdfV0lGSV9ESVNQTEFZCglpZiAob3Nfc3RyY2FzZWNtcChjbWQsICJ3aWZpX2Rpc3BsYXkiKSA9PSAwKSB7CgkJd2lmaV9kaXNwbGF5X2VuYWJsZShnbG9iYWwsICEhYXRvaSh2YWx1ZSkpOwoJCXJldHVybiAwOwoJfQojZW5kaWYgLyogQ09ORklHX1dJRklfRElTUExBWSAqLwoKCXJldHVybiAtMTsKfQoKCiNpZm5kZWYgQ09ORklHX05PX0NPTkZJR19XUklURQpzdGF0aWMgaW50IHdwYXNfZ2xvYmFsX2N0cmxfaWZhY2Vfc2F2ZV9jb25maWcoc3RydWN0IHdwYV9nbG9iYWwgKmdsb2JhbCkKewoJaW50IHJldCA9IDA7CglzdHJ1Y3Qgd3BhX3N1cHBsaWNhbnQgKndwYV9zOwoKCWZvciAod3BhX3MgPSBnbG9iYWwtPmlmYWNlczsgd3BhX3M7IHdwYV9zID0gd3BhX3MtPm5leHQpIHsKCQlpZiAoIXdwYV9zLT5jb25mLT51cGRhdGVfY29uZmlnKSB7CgkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IFNBVkVfQ09ORklHIC0gTm90IGFsbG93ZWQgdG8gdXBkYXRlIGNvbmZpZ3VyYXRpb24gKHVwZGF0ZV9jb25maWc9MCkiKTsKCQkJY29udGludWU7CgkJfQoKCQlpZiAod3BhX2NvbmZpZ193cml0ZSh3cGFfcy0+Y29uZm5hbWUsIHdwYV9zLT5jb25mKSkgewoJCQl3cGFfZGJnKHdwYV9zLCBNU0dfREVCVUcsICJDVFJMX0lGQUNFOiBTQVZFX0NPTkZJRyAtIEZhaWxlZCB0byB1cGRhdGUgY29uZmlndXJhdGlvbiIpOwoJCQlyZXQgPSAxOwoJCX0gZWxzZSB7CgkJCXdwYV9kYmcod3BhX3MsIE1TR19ERUJVRywgIkNUUkxfSUZBQ0U6IFNBVkVfQ09ORklHIC0gQ29uZmlndXJhdGlvbiB1cGRhdGVkIik7CgkJfQoJfQoKCXJldHVybiByZXQ7Cn0KI2VuZGlmIC8qIENPTkZJR19OT19DT05GSUdfV1JJVEUgKi8KCgpzdGF0aWMgaW50IHdwYXNfZ2xvYmFsX2N0cmxfaWZhY2Vfc3RhdHVzKHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsCgkJCQkJIGNoYXIgKmJ1Ziwgc2l6ZV90IGJ1ZmxlbikKewoJY2hhciAqcG9zLCAqZW5kOwoJaW50IHJldDsKCXN0cnVjdCB3cGFfc3VwcGxpY2FudCAqd3BhX3M7CgoJcG9zID0gYnVmOwoJZW5kID0gYnVmICsgYnVmbGVuOwoKI2lmZGVmIENPTkZJR19QMlAKCWlmIChnbG9iYWwtPnAycCAmJiAhZ2xvYmFsLT5wMnBfZGlzYWJsZWQpIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgInAycF9kZXZpY2VfYWRkcmVzcz0iIE1BQ1NUUgoJCQkJICAiXG4iCgkJCQkgICJwMnBfc3RhdGU9JXNcbiIsCgkJCQkgIE1BQzJTVFIoZ2xvYmFsLT5wMnBfZGV2X2FkZHIpLAoJCQkJICBwMnBfZ2V0X3N0YXRlX3R4dChnbG9iYWwtPnAycCkpOwoJCWlmIChyZXQgPCAwIHx8IHJldCA+PSBlbmQgLSBwb3MpCgkJCXJldHVybiBwb3MgLSBidWY7CgkJcG9zICs9IHJldDsKCX0gZWxzZSBpZiAoZ2xvYmFsLT5wMnApIHsKCQlyZXQgPSBvc19zbnByaW50Zihwb3MsIGVuZCAtIHBvcywgInAycF9zdGF0ZT1ESVNBQkxFRFxuIik7CgkJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQkJcmV0dXJuIHBvcyAtIGJ1ZjsKCQlwb3MgKz0gcmV0OwoJfQojZW5kaWYgLyogQ09ORklHX1AyUCAqLwoKI2lmZGVmIENPTkZJR19XSUZJX0RJU1BMQVkKCXJldCA9IG9zX3NucHJpbnRmKHBvcywgZW5kIC0gcG9zLCAid2lmaV9kaXNwbGF5PSVkXG4iLAoJCQkgICEhZ2xvYmFsLT53aWZpX2Rpc3BsYXkpOwoJaWYgKHJldCA8IDAgfHwgcmV0ID49IGVuZCAtIHBvcykKCQlyZXR1cm4gcG9zIC0gYnVmOwoJcG9zICs9IHJldDsKI2VuZGlmIC8qIENPTkZJR19XSUZJX0RJU1BMQVkgKi8KCglmb3IgKHdwYV9zID0gZ2xvYmFsLT5pZmFjZXM7IHdwYV9zOyB3cGFfcyA9IHdwYV9zLT5uZXh0KSB7CgkJcmV0ID0gb3Nfc25wcmludGYocG9zLCBlbmQgLSBwb3MsICJpZm5hbWU9JXNcbiIKCQkJCSAgImFkZHJlc3M9IiBNQUNTVFIgIlxuIiwKCQkJCSAgd3BhX3MtPmlmbmFtZSwgTUFDMlNUUih3cGFfcy0+b3duX2FkZHIpKTsKCQlpZiAocmV0IDwgMCB8fCByZXQgPj0gZW5kIC0gcG9zKQoJCQlyZXR1cm4gcG9zIC0gYnVmOwoJCXBvcyArPSByZXQ7Cgl9CgoJcmV0dXJuIHBvcyAtIGJ1ZjsKfQoKCmNoYXIgKiB3cGFfc3VwcGxpY2FudF9nbG9iYWxfY3RybF9pZmFjZV9wcm9jZXNzKHN0cnVjdCB3cGFfZ2xvYmFsICpnbG9iYWwsCgkJCQkJCWNoYXIgKmJ1Ziwgc2l6ZV90ICpyZXNwX2xlbikKewoJY2hhciAqcmVwbHk7Cgljb25zdCBpbnQgcmVwbHlfc2l6ZSA9IDIwNDg7CglpbnQgcmVwbHlfbGVuOwoJaW50IGxldmVsID0gTVNHX0RFQlVHOwoKCWlmIChvc19zdHJuY21wKGJ1ZiwgIklGTkFNRT0iLCA3KSA9PSAwKSB7CgkJY2hhciAqcG9zID0gb3Nfc3RyY2hyKGJ1ZiArIDcsICcgJyk7CgkJaWYgKHBvcykgewoJCQkqcG9zKysgPSAnXDAnOwoJCQlyZXR1cm4gd3Bhc19nbG9iYWxfY3RybF9pZmFjZV9pZm5hbWUoZ2xvYmFsLAoJCQkJCQkJICAgICBidWYgKyA3LCBwb3MsCgkJCQkJCQkgICAgIHJlc3BfbGVuKTsKCQl9Cgl9CgoJcmVwbHkgPSB3cGFzX2dsb2JhbF9jdHJsX2lmYWNlX3JlZGlyKGdsb2JhbCwgYnVmLCByZXNwX2xlbik7CglpZiAocmVwbHkpCgkJcmV0dXJuIHJlcGx5OwoKCWlmIChvc19zdHJjbXAoYnVmLCAiUElORyIpID09IDApCgkJbGV2ZWwgPSBNU0dfRVhDRVNTSVZFOwoJd3BhX2hleGR1bXBfYXNjaWkobGV2ZWwsICJSWCBnbG9iYWwgY3RybF9pZmFjZSIsCgkJCSAgKGNvbnN0IHU4ICopIGJ1Ziwgb3Nfc3RybGVuKGJ1ZikpOwoKCXJlcGx5ID0gb3NfbWFsbG9jKHJlcGx5X3NpemUpOwoJaWYgKHJlcGx5ID09IE5VTEwpIHsKCQkqcmVzcF9sZW4gPSAxOwoJCXJldHVybiBOVUxMOwoJfQoKCW9zX21lbWNweShyZXBseSwgIk9LXG4iLCAzKTsKCXJlcGx5X2xlbiA9IDM7CgoJaWYgKG9zX3N0cmNtcChidWYsICJQSU5HIikgPT0gMCkgewoJCW9zX21lbWNweShyZXBseSwgIlBPTkdcbiIsIDUpOwoJCXJlcGx5X2xlbiA9IDU7Cgl9IGVsc2UgaWYgKG9zX3N0cm5jbXAoYnVmLCAiSU5URVJGQUNFX0FERCAiLCAxNCkgPT0gMCkgewoJCWlmICh3cGFfc3VwcGxpY2FudF9nbG9iYWxfaWZhY2VfYWRkKGdsb2JhbCwgYnVmICsgMTQpKQoJCQlyZXBseV9sZW4gPSAtMTsKCX0gZWxzZSBpZiAob3Nfc3RybmNtcChidWYsICJJTlRFUkZBQ0VfUkVNT1ZFICIsIDE3KSA9PSAwKSB7CgkJaWYgKHdwYV9zdXBwbGljYW50X2dsb2JhbF9pZmFjZV9yZW1vdmUoZ2xvYmFsLCBidWYgKyAxNykpCgkJCXJlcGx5X2xlbiA9IC0xOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiSU5URVJGQUNFX0xJU1QiKSA9PSAwKSB7CgkJcmVwbHlfbGVuID0gd3BhX3N1cHBsaWNhbnRfZ2xvYmFsX2lmYWNlX2xpc3QoCgkJCWdsb2JhbCwgcmVwbHksIHJlcGx5X3NpemUpOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiSU5URVJGQUNFUyIpID09IDApIHsKCQlyZXBseV9sZW4gPSB3cGFfc3VwcGxpY2FudF9nbG9iYWxfaWZhY2VfaW50ZXJmYWNlcygKCQkJZ2xvYmFsLCByZXBseSwgcmVwbHlfc2l6ZSk7Cgl9IGVsc2UgaWYgKG9zX3N0cmNtcChidWYsICJURVJNSU5BVEUiKSA9PSAwKSB7CgkJd3BhX3N1cHBsaWNhbnRfdGVybWluYXRlX3Byb2MoZ2xvYmFsKTsKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIlNVU1BFTkQiKSA9PSAwKSB7CgkJd3Bhc19ub3RpZnlfc3VzcGVuZChnbG9iYWwpOwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiUkVTVU1FIikgPT0gMCkgewoJCXdwYXNfbm90aWZ5X3Jlc3VtZShnbG9iYWwpOwoJfSBlbHNlIGlmIChvc19zdHJuY21wKGJ1ZiwgIlNFVCAiLCA0KSA9PSAwKSB7CgkJaWYgKHdwYXNfZ2xvYmFsX2N0cmxfaWZhY2Vfc2V0KGdsb2JhbCwgYnVmICsgNCkpCgkJCXJlcGx5X2xlbiA9IC0xOwojaWZuZGVmIENPTkZJR19OT19DT05GSUdfV1JJVEUKCX0gZWxzZSBpZiAob3Nfc3RyY21wKGJ1ZiwgIlNBVkVfQ09ORklHIikgPT0gMCkgewoJCWlmICh3cGFzX2dsb2JhbF9jdHJsX2lmYWNlX3NhdmVfY29uZmlnKGdsb2JhbCkpCgkJCXJlcGx5X2xlbiA9IC0xOwojZW5kaWYgLyogQ09ORklHX05PX0NPTkZJR19XUklURSAqLwoJfSBlbHNlIGlmIChvc19zdHJjbXAoYnVmLCAiU1RBVFVTIikgPT0gMCkgewoJCXJlcGx5X2xlbiA9IHdwYXNfZ2xvYmFsX2N0cmxfaWZhY2Vfc3RhdHVzKGdsb2JhbCwgcmVwbHksCgkJCQkJCQkgIHJlcGx5X3NpemUpOwoJfSBlbHNlIHsKCQlvc19tZW1jcHkocmVwbHksICJVTktOT1dOIENPTU1BTkRcbiIsIDE2KTsKCQlyZXBseV9sZW4gPSAxNjsKCX0KCglpZiAocmVwbHlfbGVuIDwgMCkgewoJCW9zX21lbWNweShyZXBseSwgIkZBSUxcbiIsIDUpOwoJCXJlcGx5X2xlbiA9IDU7Cgl9CgoJKnJlc3BfbGVuID0gcmVwbHlfbGVuOwoJcmV0dXJuIHJlcGx5Owp9Cg==