I2luY2x1ZGUJIndzSW50cm4uaCIKI2lmZGVmIERJR0VTVF9BQ0NFU1NfU1VQUE9SVAoJI2luY2x1ZGUJIndlYnNkYS5oIgojZW5kaWYKI2luY2x1ZGUgIi4uL2ludGVyZmFjZTUuMC96dGVfd2ViX2ludGVyZmFjZS5oIgovLyNpbmNsdWRlICIuLi9pbnRlcmZhY2U1LjAvenRlX3Jlc3RfY29tbV9pbnRlcmZhY2UuaCIKCndlYnNTdGF0c1R5cGUJd2Vic1N0YXRzOwkJCQkKd2Vic190CQkJKndlYnM7CQkJCQkKc3ltX2ZkX3QJCXdlYnNNaW1lOwkJCQkKaW50CQkJCXdlYnNNYXg7CQkJCQppbnQJCQkJd2Vic1BvcnQ7CQkJCQpjaGFyX3QJCQl3ZWJzSG9zdFs2NF07CQkJCmNoYXJfdAkJCXdlYnNJcGFkZHJbNjRdOwkJCQpjaGFyX3QJCQkqd2Vic0hvc3RVcmwgPSBOVUxMOwkKY2hhcl90CQkJKndlYnNJcGFkZHJVcmwgPSBOVUxMOwkKLy9hZGRlZCBieSBsaXV5aW5nbmFuIGZvciBQQyBDbGllbnQgYmVnaW4sIDIwMTIwODI5CmNoYXIgd2Vic1JlY3ZIdHRwQnVmZmVyW0hUVFBfQlVGRkVSX1NJWkVdID0gezB9OwpjaGFyIHdlYnNSZWN2SHR0cEJ1ZmZlcl9YTUxbSFRUUF9CVUZGRVJfU0laRV0gPSB7MH07CgpleHRlcm4gdm9pZCB6dGVfY2hhbmdlX3dwX3F1ZXJ5KHdlYnNfdCB3cCxjaGFyX3QgKnhtbF9zdHIpOwovL2FkZGVkIGJ5IGxpdXlpbmduYW4gZm9yIFBDIENsaWVudCBiZWdpbiwgMjAxMjA4MjkKCndlYnNFcnJvclR5cGUgd2Vic0Vycm9yc1tdID0gewoJeyAyMDAsIFQoIkRhdGEgZm9sbG93cyIpIH0sCgl7IDIwNCwgVCgiTm8gQ29udGVudCIpIH0sCgl7IDMwMSwgVCgiUmVkaXJlY3QiKSB9LAoJeyAzMDIsIFQoIlJlZGlyZWN0IikgfSwKCXsgMzA0LCBUKCJVc2UgbG9jYWwgY29weSIpIH0sCgl7IDQwMCwgVCgiUGFnZSBub3QgZm91bmQiKSB9LAoJeyA0MDEsIFQoIlVuYXV0aG9yaXplZCIpIH0sCgl7IDQwMywgVCgiRm9yYmlkZGVuIikgfSwKCXsgNDA0LCBUKCJTaXRlIG9yIFBhZ2UgTm90IEZvdW5kIikgfSwKCXsgNDA1LCBUKCJBY2Nlc3MgRGVuaWVkIikgfSwKCXsgNTAwLCBUKCJXZWIgRXJyb3IiKSB9LAoJeyA1MDEsIFQoIk5vdCBJbXBsZW1lbnRlZCIpIH0sCgl7IDUwMywgVCgiU2l0ZSBUZW1wb3JhcmlseSBVbmF2YWlsYWJsZS4gVHJ5IGFnYWluLiIpIH0sCgl7IDAsIE5VTEwgfQp9OwoKdHlwZWRlZiBlbnVtIHsgCglSRVRfREFUQV9FUlJPUiA9IC0xLAoJUkVUX0ZBSUxFRCA9IDAsIAoJUkVUX09LID0gMSwgCn0gRVJST1JfQ09ERTsKCgojaWZkZWYgRkVBVFVSRV9aVEVfV0VCX1RDQVJECi8vYWRkZWQgYnkgZ3VvIHNob3VwZW5nIDEwMTI0MjI0IGZvciBodHRwIHNoYXJlIDIwMTExMDAxIHN0YXJ0Cgp0eXBlZGVmIGVudW0geyAKCVJFVF9GQUlMRUQgPSAwLCAKCVJFVF9PSyA9IDEsIAoJUkVUX1VOS05PV04gPSAzLAkKCU1BTExPQ19GSUFMRUQgPSA0LAoJU0RfTk9ORSA9IDUsCglVU0JfT1VUID0gNiwKCVVTRVJfTUFMTE9DX0ZBSUxFRCA9IDcsCglVUExPQURfRklMRV9MSU1JVEVEID0gOCwKCVVTRVJfVU5LTk9XTiA9IDksCQp9IEVSUk9SX0NPREU7CgovL2FkZGVkIGJ5IGd1byBzaG91cGVuZyAxMDEyNDIyNCBmb3IgaHR0cCBzaGFyZSAyMDExMTAwMSBlbmQKI2VuZGlmCgoKCnN0YXRpYyBpbnQgCQl3ZWJzR2V0SW5wdXQod2Vic190IHdwLCBjaGFyX3QgKipwdGV4dCwgaW50ICpuYnl0ZXMpOwpzdGF0aWMgaW50IAkJd2Vic1BhcnNlRmlyc3Qod2Vic190IHdwLCBjaGFyX3QgKnRleHQpOwpzdGF0aWMgaW50IAl3ZWJzUGFyc2VSZXF1ZXN0KHdlYnNfdCB3cCk7CnN0YXRpYyB2b2lkCQl3ZWJzU29ja2V0RXZlbnQoaW50IHNpZCwgaW50IG1hc2ssIGludCBkYXRhKTsKc3RhdGljIGludAkJd2Vic0dldFRpbWVTaW5jZU1hcmsod2Vic190IHdwKTsKCnN0YXRpYyBpbnQJCXdlYnNMaXN0ZW5Tb2NrOwkJCQkJCnN0YXRpYyBjaGFyX3QJd2Vic1JlYWxtWzY0XSA9IFQoIkdvQWhlYWQiKTsJCgpzdGF0aWMgaW50CQl3ZWJzT3BlbkNvdW50ID0gMDsJCQoKCmludCB3ZWJzT3BlblNlcnZlcihpbnQgcG9ydCwgaW50IHJldHJpZXMpCnsKCXdlYnNNaW1lVHlwZQkqbXQ7CgoJaWYgKCsrd2Vic09wZW5Db3VudCAhPSAxKSB7CgkJcmV0dXJuIHdlYnNQb3J0OwoJfQoKCWFfYXNzZXJ0KHBvcnQgPiAwKTsKCWFfYXNzZXJ0KHJldHJpZXMgPj0gMCk7CgoJd2VicyA9IE5VTEw7Cgl3ZWJzTWF4ID0gMDsKCgl3ZWJzTWltZSA9IHN5bU9wZW4oV0VCU19TWU1fSU5JVCAqIDQpOwoJYV9hc3NlcnQod2Vic01pbWUgPj0gMCk7CglpZih3ZWJzTWltZSA8IDApICAvLyBjb3YgTSBORUdBVElWRV9SRVRVUk5TCgl7CgkgICAgcmV0dXJuIC0xOwoJfQoJZm9yIChtdCA9IHdlYnNNaW1lTGlzdDsgbXQtPnR5cGU7IG10KyspIHsKCQlzeW1FbnRlcih3ZWJzTWltZSwgbXQtPmV4dCwgdmFsdWVTdHJpbmcobXQtPnR5cGUsIDApLCAwKTsKCX0KCiNpZiAxCiAgICAvLyBrdyAzIElOVkFSSUFOVF9DT05ESVRJT04uVU5SRUFDSCB3ZWJzVXJsSGFuZGxlck9wZW4gb25seSByZXR1cm4gMAogICAgd2Vic1VybEhhbmRsZXJPcGVuKCk7CiNlbHNlCglpZiAod2Vic1VybEhhbmRsZXJPcGVuKCkgPCAwKSB7CgkJcmV0dXJuIC0xOwoJfQojZW5kaWYJCgl3ZWJzRm9ybU9wZW4oKTsKCglyZXR1cm4gd2Vic09wZW5MaXN0ZW4ocG9ydCwgcmV0cmllcyk7Cn0KCgoKdm9pZCB3ZWJzQ2xvc2VTZXJ2ZXIoKQp7Cgl3ZWJzX3QJd3A7CglpbnQJCXdpZDsKCglpZiAoLS13ZWJzT3BlbkNvdW50ID4gMCkgewoJCXJldHVybjsKCX0KCgl3ZWJzQ2xvc2VMaXN0ZW4oKTsKCglmb3IgKHdpZCA9IHdlYnNNYXg7IHdlYnMgJiYgd2lkID49IDA7IHdpZC0tKSB7CgkJaWYgKCh3cCA9IHdlYnNbd2lkXSkgPT0gTlVMTCkgewoJCQljb250aW51ZTsKCQl9CgkJc29ja2V0Q2xvc2VDb25uZWN0aW9uKHdwLT5zaWQpOwoJCXdlYnNGcmVlKHdwKTsKCX0KCglzeW1DbG9zZSh3ZWJzTWltZSk7Cgl3ZWJzRm9ybUNsb3NlKCk7Cgl3ZWJzVXJsSGFuZGxlckNsb3NlKCk7Cn0KCgp2b2lkIHdlYnNDbG9zZUxpc3RlbigpCnsKCWlmICh3ZWJzTGlzdGVuU29jayA+PSAwKSB7CgkJc29ja2V0Q2xvc2VDb25uZWN0aW9uKHdlYnNMaXN0ZW5Tb2NrKTsKCQl3ZWJzTGlzdGVuU29jayA9IC0xOwoJfQoJYmZyZWVTYWZlKEJfTCwgd2Vic0hvc3RVcmwpOwoJYmZyZWVTYWZlKEJfTCwgd2Vic0lwYWRkclVybCk7Cgl3ZWJzSXBhZGRyVXJsID0gd2Vic0hvc3RVcmwgPSBOVUxMOwp9CgoKaW50IHdlYnNPcGVuTGlzdGVuKGludCBwb3J0LCBpbnQgcmV0cmllcykKewoJaW50CQlpLCBvcmlnOwoKCWFfYXNzZXJ0KHBvcnQgPiAwKTsKCWFfYXNzZXJ0KHJldHJpZXMgPj0gMCk7CgkKCW9yaWcgPSBwb3J0OwoKCWZvciAoaSA9IDA7IGkgPD0gcmV0cmllczsgaSsrKSB7CgkJd2Vic0xpc3RlblNvY2sgPSBzb2NrZXRPcGVuQ29ubmVjdGlvbjYoTlVMTCwgcG9ydCwgd2Vic0FjY2VwdCwgMCk7CgkJaWYgKHdlYnNMaXN0ZW5Tb2NrID49IDApIHsKCQkJYnJlYWs7CgkJfQoJCXBvcnQrKzsKCX0KCWlmIChpID4gcmV0cmllcykgewoJCWVycm9yKEVfTCwgRV9VU0VSLCBUKCJDb3VsZG4ndCBvcGVuIGEgc29ja2V0IG9uIHBvcnRzICVkIC0gJWQiKSwKCQkJb3JpZywgcG9ydCAtIDEpOwoJCXJldHVybiAtMTsKCX0gCgoJd2Vic1BvcnQgPSBwb3J0OwoJYmZyZWVTYWZlKEJfTCwgd2Vic0hvc3RVcmwpOwoJYmZyZWVTYWZlKEJfTCwgd2Vic0lwYWRkclVybCk7Cgl3ZWJzSXBhZGRyVXJsID0gd2Vic0hvc3RVcmwgPSBOVUxMOwoKCWlmIChwb3J0ID09IDgwKSB7CgkJd2Vic0hvc3RVcmwgPSBic3RyZHVwKEJfTCwgd2Vic0hvc3QpOwoJCXdlYnNJcGFkZHJVcmwgPSBic3RyZHVwKEJfTCwgd2Vic0lwYWRkcik7Cgl9IGVsc2UgewoJCWZtdEFsbG9jKCZ3ZWJzSG9zdFVybCwgV0VCU19NQVhfVVJMICsgODAsIFQoIiVzOiVkIiksIHdlYnNIb3N0LCBwb3J0KTsKCQlmbXRBbGxvYygmd2Vic0lwYWRkclVybCwgV0VCU19NQVhfVVJMICsgODAsIFQoIiVzOiVkIiksIAoJCQl3ZWJzSXBhZGRyLCBwb3J0KTsKCX0KCXRyYWNlKDAsIFQoIndlYnM6IExpc3RlbmluZyBmb3IgSFRUUCByZXF1ZXN0cyBhdCBhZGRyZXNzICVzXG4iKSwKCQl3ZWJzSXBhZGRyVXJsKTsKCglyZXR1cm4gcG9ydDsKfQoKCnN0YXRpYyB2b2lkIHdlYnNTb2NrZXRFdmVudChpbnQgc2lkLCBpbnQgbWFzaywgaW50IGl3cCkKewoJd2Vic190CXdwOwoKCXdwID0gKHdlYnNfdCkgaXdwOwoJYV9hc3NlcnQod3ApOwoKCWlmICghIHdlYnNWYWxpZCh3cCkpIHsKCQlyZXR1cm47Cgl9CgoJaWYgKG1hc2sgJiBTT0NLRVRfUkVBREFCTEUpIHsKCQl3ZWJzUmVhZEV2ZW50KHdwKTsKCX0gCglpZiAobWFzayAmIFNPQ0tFVF9XUklUQUJMRSkgewoJCWlmICh3ZWJzVmFsaWQod3ApICYmIHdwLT53cml0ZVNvY2tldCkgewoJCQkoKndwLT53cml0ZVNvY2tldCkod3ApOwoJCX0KCX0gCn0KCmludCB3ZWJzQWNjZXB0KGludCBzaWQsIGNoYXIgKmlwYWRkciwgaW50IHBvcnQsIGludCBsaXN0ZW5TaWQpCnsKCXdlYnNfdAl3cDsKCWludAkJd2lkOwoKCWFfYXNzZXJ0KGlwYWRkciAmJiAqaXBhZGRyKTsKCWFfYXNzZXJ0KHNpZCA+PSAwKTsKCWFfYXNzZXJ0KHBvcnQgPj0gMCk7CgoJaWYgKCh3aWQgPSB3ZWJzQWxsb2Moc2lkKSkgPCAwKSB7CgkJcmV0dXJuIC0xOwoJfQoJd3AgPSB3ZWJzW3dpZF07CglhX2Fzc2VydCh3cCk7Cgl3cC0+bGlzdGVuU2lkID0gbGlzdGVuU2lkOwoKCWFzY1RvVW5pKHdwLT5pcGFkZHIsIGlwYWRkciwgbWluKHNpemVvZih3cC0+aXBhZGRyKSwgc3RybGVuKGlwYWRkcikgKyAxKSk7CgoJaWYgKGdzdHJjbXAod3AtPmlwYWRkciwgVCgiMTI3LjAuMC4xIikpID09IDAgfHwgCgkJCWdzdHJjbXAod3AtPmlwYWRkciwgd2Vic0lwYWRkcikgPT0gMCB8fCAKCQkJZ3N0cmNtcCh3cC0+aXBhZGRyLCB3ZWJzSG9zdCkgPT0gMCkgewoJCXdwLT5mbGFncyB8PSBXRUJTX0xPQ0FMX1JFUVVFU1Q7Cgl9CgoJc29ja2V0Q3JlYXRlSGFuZGxlcihzaWQsIFNPQ0tFVF9SRUFEQUJMRSwgd2Vic1NvY2tldEV2ZW50LCAoaW50KSB3cCk7CgoJd3AtPnRpbWVvdXQgPSBlbWZTY2hlZENhbGxiYWNrKFdFQlNfVElNRU9VVCwgd2Vic1RpbWVvdXQsICh2b2lkICopIHdwKTsKCS8vdHJhY2UoOCwgVCgid2ViczogYWNjZXB0IHJlcXVlc3RcbiIpKTsKCXJldHVybiAwOwp9CgoKCiNpZmRlZiBGRUFUVVJFX1pURV9XRUJfVENBUkQKLy9hZGRlZCBieSBndW8gc2hvdXBlbmcgMTAxMjQyMjQgZm9yIGh0dHAgc2hhcmUgMjAxMjAxMTAgc3RhcnQKc3RhdGljIGludCByZWFkX2J5dGVzID0gMDsKLy9hZGRlZCBieSBndW8gc2hvdXBlbmcgMTAxMjQyMjQgZm9yIGh0dHAgc2hhcmUgMjAxMjAxMTAgZW5kCiNlbmRpZgoKdm9pZCB3ZWJzUmVhZEV2ZW50KHdlYnNfdCB3cCkKewoJY2hhcl90IAkqdGV4dDsKCWludAkJcmMsIG5ieXRlcywgbGVuLCBkb25lLCBmZDsKCglhX2Fzc2VydCh3cCk7CglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCgl3ZWJzU2V0VGltZU1hcmsod3ApOwoJCglzdGF0aWMgdW5zaWduZWQgaW50IHRpbWVyID0gMDsKCgl0ZXh0ID0gTlVMTDsKCWZkID0gLTE7Cglmb3IgKGRvbmUgPSAwOyAhZG9uZTsgKSB7CgkJaWYgKHRleHQpIHsKCQkJYmZyZWUoQl9MLCB0ZXh0KTsKCQkJdGV4dCA9IE5VTEw7CgkJfQoKCiNpZmRlZiBGRUFUVVJFX1pURV9XRUJfVENBUkQKLy9hZGRlZCBieSBndW8gc2hvdXBlbmcgMTAxMjQyMjQgZm9yIGh0dHAgc2hhcmUgMjAxMjAxMTAgc3RhcnQKCQlpZiggcmVhZF9ieXRlcyA+IFVQTE9BRF9JTlRFUlZBTCkKCQl7CgkJCXJlYWRfYnl0ZXMgPSAwOwoJCQlicmVhazsKCQl9Ci8vYWRkZWQgYnkgZ3VvIHNob3VwZW5nIDEwMTI0MjI0IGZvciBodHRwIHNoYXJlIDIwMTIwMTEwIGVuZAojZW5kaWYKCQlhc3NlcnQod3ApOwoJCWFzc2VydCh3ZWJzVmFsaWQod3ApKTsJCQoJCXdoaWxlICgocmMgPSB3ZWJzR2V0SW5wdXQod3AsICZ0ZXh0LCAmbmJ5dGVzKSkgPT0gMCkgewoJCQk7CgkJfQoKCgkJaWYgKHJjIDwgMCkgewogICAgICAgICAgICBpZih3ZWJzVmFsaWQod3ApICYmICh3cC0+ZmxhZ3MgJiBXRUJTX0NHSV9SRVFVRVNUICkpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIC8vcHJpbnRmKCJcbiArKytzb2NrZXR0dCB1cGxvYWQgd2Vic1NldFRpbWVNYXJrKysrIFxuIik7CiAgICAgICAgICAgICAgICB3ZWJzU2V0VGltZU1hcmsod3ApOwogICAgICAgICAgICB9CgkJCWJyZWFrOwoJCX0KCQlpZih0ZXh0ID09IE5VTEwpCgkJCWJyZWFrOy8vZm9yIGt3CgoJCXN3aXRjaCh3cC0+c3RhdGUpIHsKCQljYXNlIFdFQlNfQkVHSU46CgoJCQlpZiAod2Vic1BhcnNlRmlyc3Qod3AsIHRleHQpIDwgMCkgewoJCQkJZG9uZSsrOwoJCQkJYnJlYWs7CgkJCX0KCQkJd3AtPnN0YXRlID0gV0VCU19IRUFERVI7CgkJCWJyZWFrOwoJCQoJCWNhc2UgV0VCU19IRUFERVI6CgoJCQlpZiAocmluZ3FMZW4oJndwLT5oZWFkZXIpID4gMCkgewoJCQkJcmluZ3FQdXRTdHIoJndwLT5oZWFkZXIsIFQoIlxuIikpOwoJCQl9CgkJCXJpbmdxUHV0U3RyKCZ3cC0+aGVhZGVyLCB0ZXh0KTsKCQkJYnJlYWs7CgoJCWNhc2UgV0VCU19QT1NUX0NMRU46CgojaWZuZGVmIF9fTk9fQ0dJX0JJTgoJCQlpZiAod3AtPmZsYWdzICYgV0VCU19DR0lfUkVRVUVTVCkgewoKCQkJCS8vaWYoISh3cC0+ZmxhZ3MgJiBXRUJTX0NHSV9GSVJNV0FSRV9VUExPQUQpKQoJCQkJaWYod3AtPmZsYWdzICYgV0VCU19DR0lfSFRUUFNIQVJFX1VQTE9BRCkKCQkJCXsKCQkJCQlpZiggdGltZXIgPT0wKQogICAgICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAgICAgd2Vic1NldExvZ2luVGltZW1hcmsod3ApOwoJCQkJCQlwcmludGYoIltodHRwc2hhcmVddXBsb2FkIHJlc2V0IGxvZ2luIHN0YXRlflxuIik7CiAgICAgICAgICAgICAgICAgICAgfQoJCQkJCUVSUk9SX0NPREUgcmV0ID0genRlX3Byb2Nlc3NfY2dpX3JlY3Yod3AsIHdwLT5jbGVuLHRleHQsIG5ieXRlcyk7CQoKCQkJCQlpZihSRVRfREFUQV9FUlJPUiA9PSByZXQgfHwgUkVUX0ZBSUxFRCA9PSByZXQpCgkJCQkJewkJCQkJCQkJCQkJCSAgCgkJCQkJCXdlYnNFcnJvcih3cCwgNDA0LCBUKCJCYWQgc3RhdGUiKSk7CgkJCQkJCXByaW50ZigiW2h0dHBzaGFyZV1yZXQtPiVkXG4iLHJldCk7CgkJCQkJCWRvbmUrKzsgCQkJCQkJICAKCQkJCQkJYnJlYWs7CQkgIAoJCQkJCX0gCgkJCQkJCgkJCQkJdGltZXIrKzsKCQkJCQl0aW1lcj10aW1lci0odGltZXI+PjExPDwxMSk7ICAvL3RpbWVyJTJeMTEKCQkJCX1lbHNlIGlmKHdwLT5mbGFncyAmIFdFQlNfQ0dJX1VQTE9BRCkKCQkJCXsKCQkJCQlpZiAoZmQgPT0gLTEpIAoJCQkJCXsKCQkJCQkJaWYod3AtPmZsYWdzICYgV0VCU19DR0lfRklSTVdBUkVfVVBMT0FEICkKCQkJCQkJewoJCQkJCQkJZmQgPSBnb3BlbihGSVJNV0FSRV9UTVBfRklMRSwgT19DUkVBVCB8IE9fV1JPTkxZIHwgT19CSU5BUlkgfCBPX0FQUEVORCwgMDY2Nik7CgkJCQkJCQlwcmludGYoIltnb2FoZWFkXW9wZW4gY2dpIHRlbXAgZmlsZVxuIik7CgkJCQkJCX0KCQkJCQkJZWxzZQoJCQkJCSAgCXsKCQkJCQkJCWZkID0gZ29wZW4od3AtPmNnaVN0ZGluLCBPX0NSRUFUIHwgT19XUk9OTFkgfCBPX0JJTkFSWSB8IE9fQVBQRU5ELCAwNjY2KTsKCSAgICAgICAgICAgICAgICAgICAgfQoJCQkJCX0KICAgICAgICAgICAgICAgICAgICBpZihmZCA8IDApewogICAgICAgICAgICAgICAgICAgICAgICBicmVhazsKCQkJCQl9CgkJCQkJCQoJCQkJCQoJCQkJCWd3cml0ZShmZCwgdGV4dCwgbmJ5dGVzKTsKCQkJCX1lbHNlCgkJCQl7CgkJCQkJd2Vic0Vycm9yKHdwLCA0MDQsIFQoIkJhZCBzdGF0ZSIpKTsKCQkJCQlwcmludGYoIltnb2FoZWFkXWJhZCBjZ2kgcmVxdWVzdFxuIik7CgkJCQkJZG9uZSsrOyAJCQkJCQkgIAoJCQkJCWJyZWFrOwoJCQkJfQoKCgkJCX0gZWxzZSAKI2VuZGlmCgkJCS8vYWRkZWQgYnkgbGl1eWluZ25hbiBmb3IgUEMgQ2xpZW50IGJlZ2luLCAyMDEyMDgyOQogICAgICAgICAgICBpZih3cC0+ZmxhZ3MgJiBXRUJTX1JFU1RfQ0xJRU5UX1JFUVVFU1QpewogICAgICAgICAgICAgICAgcHJpbnRmKCIlcyIsICJ3ZWJzUmVhZEV2ZW50OiBwYyBjbGllbnQgcG9zdCIpOwogICAgICAgICAgICAgICAgaWYgKG5ieXRlcyA+IChIVFRQX0JVRkZFUl9TSVpFLWdzdHJsZW4od2Vic1JlY3ZIdHRwQnVmZmVyKS0xKSkKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICBnc3RybmNweSh3ZWJzUmVjdkh0dHBCdWZmZXIrZ3N0cmxlbih3ZWJzUmVjdkh0dHBCdWZmZXIpLCB0ZXh0LCBIVFRQX0JVRkZFUl9TSVpFLWdzdHJsZW4od2Vic1JlY3ZIdHRwQnVmZmVyKS0xKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICBnc3RybmNweSh3ZWJzUmVjdkh0dHBCdWZmZXIrZ3N0cmxlbih3ZWJzUmVjdkh0dHBCdWZmZXIpLCB0ZXh0LCBuYnl0ZXMpOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9IGVsc2UgIGlmKHdwLT5mbGFncyAmIFdFQlNfWE1MX0NMSUVOVF9SRVFVRVNUKXsKICAgICAgICAgICAgaWYgKG5ieXRlcyA+IChIVFRQX0JVRkZFUl9TSVpFLWdzdHJsZW4od2Vic1JlY3ZIdHRwQnVmZmVyX1hNTCktMSkpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIGdzdHJuY3B5KHdlYnNSZWN2SHR0cEJ1ZmZlcl9YTUwrZ3N0cmxlbih3ZWJzUmVjdkh0dHBCdWZmZXJfWE1MKSwgdGV4dCwgSFRUUF9CVUZGRVJfU0laRS1nc3RybGVuKHdlYnNSZWN2SHR0cEJ1ZmZlcl9YTUwpLTEpOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgZ3N0cm5jcHkod2Vic1JlY3ZIdHRwQnVmZmVyX1hNTCtnc3RybGVuKHdlYnNSZWN2SHR0cEJ1ZmZlcl9YTUwpLCB0ZXh0LCBuYnl0ZXMpOwogICAgICAgICAgICB9CiAgICAgICAgICAgIH0gZWxzZSAgICAKCQkJLy9hZGRlZCBieSBsaXV5aW5nbmFuIGZvciBQQyBDbGllbnQgZW5kLCAyMDEyMDgyOQoKCgoJCQlpZiAod3AtPnF1ZXJ5KSB7CgkJCQlpZiAod3AtPnF1ZXJ5WzBdICYmICEod3AtPmZsYWdzICYgV0VCU19QT1NUX0RBVEEpKSB7CgoJCQkJCWxlbiA9IGdzdHJsZW4od3AtPnF1ZXJ5KTsKCQkJCQl3cC0+cXVlcnkgPSBicmVhbGxvYyhCX0wsIHdwLT5xdWVyeSwgKGxlbiArIGdzdHJsZW4odGV4dCkgKwoJCQkJCQkyKSAqIHNpemVvZihjaGFyX3QpKTsKCQkJCQlpZih3cC0+cXVlcnkgPT0gTlVMTCkKCQkJCQkJYnJlYWs7Ly9mb3Iga3cKCQkJCQl3cC0+cXVlcnlbbGVuKytdID0gJyYnOwoJCQkJCWdzdHJjcHkoJndwLT5xdWVyeVtsZW5dLCB0ZXh0KTsKCgkJCQl9IGVsc2UgewoKICAgICAgICAgICAgICAgLy9pZiAodGV4dCAhPSBOVUxMKS8vZm9yIGt3CiAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgbGVuID0gZ3N0cmxlbih3cC0+cXVlcnkpOwogICAgICAgICAgICAgICAgICB3cC0+cXVlcnkgPSBicmVhbGxvYyhCX0wsIHdwLT5xdWVyeSwgKGxlbiArCWdzdHJsZW4odGV4dCkgKwogICAgICAgICAgICAgICAgICAgICAxKSAqIHNpemVvZihjaGFyX3QpKTsKICAgICAgICAgICAgICAgICAgaWYgKHdwLT5xdWVyeSkgewogICAgICAgICAgICAgICAgICAgICBnc3RyY3B5KCZ3cC0+cXVlcnlbbGVuXSwgdGV4dCk7CiAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgfQoJCQkJfQoKCQkJfSBlbHNlIHsKCQkJCXdwLT5xdWVyeSA9IGJzdHJkdXAoQl9MLCB0ZXh0KTsKCQkJfQojaWYgMCAvL2ZvciBrdwkJCQogICAgICAgICAgICAvL0FkZCBCeSBsaXV5aW5nbmFuIGZvciBYTUwgQ09NTSBBUEkgU1RBUlQKICAgICAgICAgICAgaWYod3AtPmZsYWdzICYgV0VCU19YTUxfQ0xJRU5UX1JFUVVFU1QpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIHNsb2coTUlTQ19QUklOVCxTTE9HX0RFQlVHLCJbd2Vic1JlYWRFdmVudF06Y2hhbmdlX3dwX3F1ZXJ5IGZ1bmN0aW9uOiVzXG4iLHdlYnNSZWN2SHR0cEJ1ZmZlcl9YTUwpOwogICAgICAgICAgICAgICAgLy96dGVfY2hhbmdlX3dwX3F1ZXJ5KHdwLHdlYnNSZWN2SHR0cEJ1ZmZlcl9Kc29uKTsKICAgICAgICAgICAgICAgIHp0ZV9jaGFuZ2Vfd3BfcXVlcnkod3Asd2Vic1JlY3ZIdHRwQnVmZmVyX1hNTCk7CiAgICAgICAgICAgICAgICBtZW1zZXQod2Vic1JlY3ZIdHRwQnVmZmVyX1hNTCwwLEhUVFBfQlVGRkVSX1NJWkUpOwogICAgICAgICAgICAgICAgc2xvZyhNSVNDX1BSSU5ULFNMT0dfREVCVUcsIltvdXQgdGhlIGZ1bmN0aW9uXTp3cC0+cXVlcnk6JXNcbiIsd3AtPnF1ZXJ5KTsKICAgICAgICAgICAgfSAKICAgICAgICAgICAgLy9BZGQgQnkgbGl1eWluZ25hbiBmb3IgWE1MIENPTU0gQVBJIEVORAojZW5kaWYKICAgICAgICAgICAgCgkJCXdwLT5mbGFncyB8PSBXRUJTX1BPU1RfREFUQTsKCQkJd3AtPmNsZW4gLT0gbmJ5dGVzOwoJCQlpZiAod3AtPmNsZW4gPiAwKSB7CgkJCQlpZiAobmJ5dGVzID4gMCkgewoJCQkJCWJyZWFrOwoJCQkJfQoJCQkJZG9uZSsrOwoJCQkJYnJlYWs7CgkJCX0KI2lmZGVmIEZFQVRVUkVfWlRFX1dFQl9UQ0FSRAovL2FkZGVkIGJ5IGd1byBzaG91cGVuZyAxMDEyNDIyNCBmb3IgaHR0cCBzaGFyZSAyMDEyMDExMCBzdGFydAoJCQllbHNlCgkJCXsKCQkJICAgIHp0ZV9lZnNfd3JpdGUod3ApOwoJCQl9Ci8vYWRkZWQgYnkgZ3VvIHNob3VwZW5nIDEwMTI0MjI0IGZvciBodHRwIHNoYXJlIDIwMTIwMTEwIGVuZAojZW5kaWYJCgoJCQlpZiAoZmQgIT0gLTEpIHsKCQkJCWdjbG9zZSAoZmQpOwoJCQkJZmQgPSAtMTsKCQkJfQoJCQl3ZWJzVXJsSGFuZGxlclJlcXVlc3Qod3ApOwoJCQlkb25lKys7CgkJCWJyZWFrOwoKCQljYXNlIFdFQlNfUE9TVDoKCgojaWZuZGVmIF9fTk9fQ0dJX0JJTgoJCQlpZiAod3AtPmZsYWdzICYgV0VCU19DR0lfUkVRVUVTVCkgewoJCQkJaWYgKGZkID09IC0xKSB7CgkJCQkJZmQgPSBnb3Blbih3cC0+Y2dpU3RkaW4sIE9fQ1JFQVQgfCBPX1dST05MWSB8IE9fQklOQVJZLAoJCQkJCQkwNjY2KTsKCQkJCX0KCgkJCQlpZihmZCA8IDApewogICAgICAgICAgICAgICAgICAgIGJyZWFrOwoJCQkJfQoJCQkJZ3dyaXRlKGZkLCB0ZXh0LCBnc3RybGVuKHRleHQpKTsKCQkJCWd3cml0ZShmZCwgVCgiXG4iKSwgc2l6ZW9mKGNoYXJfdCkpOwoJCQl9IGVsc2UKI2VuZGlmCgkJCWlmICh3cC0+cXVlcnkgJiYgKndwLT5xdWVyeSAmJiAhKHdwLT5mbGFncyAmIFdFQlNfUE9TVF9EQVRBKSkgewoJCQkJbGVuID0gZ3N0cmxlbih3cC0+cXVlcnkpOwoJCQkJd3AtPnF1ZXJ5ID0gYnJlYWxsb2MoQl9MLCB3cC0+cXVlcnksIChsZW4gKyBnc3RybGVuKHRleHQpICsKCQkJCQkyKSAqIHNpemVvZihjaGFyX3QpKTsKCQkJCWlmICh3cC0+cXVlcnkpIHsKCQkJCQl3cC0+cXVlcnlbbGVuKytdID0gJyYnOwoJCQkJCWdzdHJjcHkoJndwLT5xdWVyeVtsZW5dLCB0ZXh0KTsKCQkJCX0KCgkJCX0gZWxzZSB7CgkJCQl3cC0+cXVlcnkgPSBic3RyZHVwKEJfTCwgdGV4dCk7CgkJCX0KCQkJd3AtPmZsYWdzIHw9IFdFQlNfUE9TVF9EQVRBOwoJCQlkb25lKys7CgkJCWJyZWFrOwoKCQlkZWZhdWx0OgoJCQl3ZWJzRXJyb3Iod3AsIDQwNCwgVCgiQmFkIHN0YXRlIikpOwoJCQlkb25lKys7CgkJCWJyZWFrOwoJCX0KCX0KCglpZiAoZmQgIT0gLTEpIHsKCQlmZCA9IGdjbG9zZSAoZmQpOwoJfQoKCWlmICh0ZXh0KSB7CgkJYmZyZWUoQl9MLCB0ZXh0KTsKCX0KfQpjaGFyX3QJaHRtRXh0W10gPSBUKCIuaHRtIik7CmludCB3ZWJzVXJsUGFyc2UoY2hhcl90ICp1cmwsIGNoYXJfdCAqKnBidWYsIGNoYXJfdCAqKnBob3N0LCBjaGFyX3QgKipwcGF0aCwgCgljaGFyX3QgKipwcG9ydCwgY2hhcl90ICoqcHF1ZXJ5LCBjaGFyX3QgKipwcHJvdG8sIGNoYXJfdCAqKnB0YWcsIAoJY2hhcl90ICoqcGV4dCkKewoJY2hhcl90CQkqaG9zdGJ1ZiwgKnBvcnRidWYsICpidWY7CglpbnQJCQljLCBsZW4sIHVsZW47CgljaGFyX3QJCSp0b2ssICpjcCwgKmhvc3QsICpwYXRoLCAqcG9ydCwgKnByb3RvLCAqdGFnLCAqcXVlcnksICpleHQ7CgoJYV9hc3NlcnQodXJsKTsKCWFfYXNzZXJ0KHBidWYpOwoKCXVsZW4gPSBnc3RybGVuKHVybCk7CgoJbGVuID0gdWxlbiAqIDIgKyBNQVhfUE9SVF9MRU4gKyAzOwoJaWYgKChidWYgPSBiYWxsb2MoQl9MLCBsZW4gKiBzaXplb2YoY2hhcl90KSkpID09IE5VTEwpIHsKCQlyZXR1cm4gLTE7Cgl9Cglwb3J0YnVmID0gJmJ1ZltsZW4gLSBNQVhfUE9SVF9MRU4gLSAxXTsKCWhvc3RidWYgPSAmYnVmW3VsZW4rMV07CgogCXdlYnNEZWNvZGVVcmwoYnVmLCB1cmwsIHVsZW4pOwoKCXVybCA9IGJ1ZjsKCglpZihwb3J0YnVmID09IE5VTEwpIC8vZm9yIGt3IDIwMjEwMzEyCgkJcmV0dXJuIC0xOwoJCglzdHJpdG9hKHdlYnNHZXRQb3J0KCksIHBvcnRidWYsIE1BWF9QT1JUX0xFTik7Cglwb3J0ID0gcG9ydGJ1ZjsKCXBhdGggPSBUKCIvIik7Cglwcm90byA9IFQoImh0dHAiKTsKCWhvc3QgPSBUKCJsb2NhbGhvc3QiKTsKCXF1ZXJ5ID0gVCgiIik7CglleHQgPSBodG1FeHQ7Cgl0YWcgPSBUKCIiKTsKCglpZiAoZ3N0cm5jbXAodXJsLCBUKCJodHRwOi8vIiksIDcpID09IDApIHsKCQl0b2sgPSAmdXJsWzddOwoJCXRva1stM10gPSAnXDAnOwoJCXByb3RvID0gdXJsOwoJCWhvc3QgPSB0b2s7CgkJZm9yIChjcCA9IHRvazsgKmNwOyBjcCsrKSB7CgkJCWlmICgqY3AgPT0gJy8nKSB7CgkJCQlicmVhazsKCQkJfQoJCQlpZiAoKmNwID09ICc6JykgewoJCQkJKmNwKysgPSAnXDAnOwoJCQkJcG9ydCA9IGNwOwoJCQkJdG9rID0gY3A7CgkJCX0KCQl9CgkJaWYgKChjcCA9IGdzdHJjaHIodG9rLCAnLycpKSAhPSBOVUxMKSB7CgoJCQljID0gKmNwOwoJCQkqY3AgPSAnXDAnOwoJCQlnc3RybmNweShob3N0YnVmLCBob3N0LCB1bGVuKTsKCQkJZ3N0cm5jcHkocG9ydGJ1ZiwgcG9ydCwgTUFYX1BPUlRfTEVOKTsKCQkJKmNwID0gYzsKCQkJaG9zdCA9IGhvc3RidWY7CgkJCXBvcnQgPSBwb3J0YnVmOwoJCQlwYXRoID0gY3A7CgkJCXRvayA9IGNwOwoJCX0KCgl9IGVsc2UgewoJCXBhdGggPSB1cmw7CgkJdG9rID0gdXJsOwoJfQoKCWlmICgoY3AgPSBnc3RyY2hyKHRvaywgJz8nKSkgIT0gTlVMTCkgewoJCSpjcCsrID0gJ1wwJzsKCQlxdWVyeSA9IGNwOwoJCXBhdGggPSB0b2s7CgkJdG9rID0gcXVlcnk7Cgl9IAoKCWlmICgoY3AgPSBnc3RyY2hyKHRvaywgJyMnKSkgIT0gTlVMTCkgewoJCSpjcCsrID0gJ1wwJzsKCQlpZiAoKnF1ZXJ5ID09IDApIHsKCQkJcGF0aCA9IHRvazsKCQl9Cgl9CgoJaWYgKHBleHQpIHsKCgkJaWYgKChjcCA9IGdzdHJyY2hyKHBhdGgsICcuJykpICE9IE5VTEwpIHsKCQkJY29uc3QgY2hhcl90KiBnYXJiYWdlID0gVCgiL1xcIik7CgkJCWludCBsZW5ndGggPSBnc3RyY3NwbihjcCwgZ2FyYmFnZSk7CgkJCWludCBnYXJiYWdlTGVuZ3RoID0gZ3N0cnNwbihjcCArIGxlbmd0aCwgZ2FyYmFnZSk7CgkJCWludCBvayA9IChsZW5ndGggKyBnYXJiYWdlTGVuZ3RoID09IChpbnQpIGdzdHJsZW4oY3ApKTsKCgkJCWlmIChvaykgewoJCQkJY3BbbGVuZ3RoXSA9ICdcMCc7CgkJCQlleHQgPSBjcDsKCQkJfQoJCX0KCX0KCglpZiAocGhvc3QpCgkJKnBob3N0ID0gaG9zdDsKCWlmIChwcGF0aCkKCQkqcHBhdGggPSBwYXRoOwoJaWYgKHBwb3J0KQoJCSpwcG9ydCA9IHBvcnQ7CglpZiAocHByb3RvKQoJCSpwcHJvdG8gPSBwcm90bzsKCWlmIChwcXVlcnkpCgkJKnBxdWVyeSA9IHF1ZXJ5OwoJaWYgKHB0YWcpCgkJKnB0YWcgPSB0YWc7CglpZiAocGV4dCkKCQkqcGV4dCA9IGV4dDsKCSpwYnVmID0gYnVmOwoJcmV0dXJuIDA7Cn0KCmNoYXJfdCAqd2Vic1VybFR5cGUoY2hhcl90ICp1cmwsIGNoYXJfdCAqYnVmLCBpbnQgY2hhckNudCkKewoJY2hhcl90CSpleHQgPSBOVUxMOyAvL2NvdgoJY2hhcl90CSp0bXBfYnVmOwoJc3ltX3QJKnBzeW07CgoJYV9hc3NlcnQodXJsICYmICp1cmwpOwoJYV9hc3NlcnQoYnVmICYmIGNoYXJDbnQgPiAwKTsKCglpZiAodXJsID09IE5VTEwgfHwgKnVybCA9PSAnXDAnKSB7CgkJZ3N0cmNweShidWYsIFQoInRleHQvcGxhaW4iKSk7CgkJcmV0dXJuIGJ1ZjsKCX0KCWlmICh3ZWJzVXJsUGFyc2UodXJsLCAmdG1wX2J1ZiwgTlVMTCwgTlVMTCwgTlVMTCwgTlVMTCwgTlVMTCwgCgkJCU5VTEwsICZleHQpIDwgMCkgewoJCWdzdHJjcHkoYnVmLCBUKCJ0ZXh0L3BsYWluIikpOwoJCXJldHVybiBidWY7Cgl9CglzdHJsb3dlcihleHQpOwoKCWlmICgocHN5bSA9IHN5bUxvb2t1cCh3ZWJzTWltZSwgZXh0KSkgIT0gTlVMTCkgewoJCWdzdHJuY3B5KGJ1ZiwgcHN5bS0+Y29udGVudC52YWx1ZS5zdHJpbmcsIGNoYXJDbnQpOwoJfSBlbHNlIHsKCQlnc3RyY3B5KGJ1ZiwgVCgidGV4dC9wbGFpbiIpKTsKCX0KCWJmcmVlKEJfTCwgdG1wX2J1Zik7CglyZXR1cm4gYnVmOwp9CgpzdGF0aWMgaW50IHdlYnNQYXJzZUZpcnN0KHdlYnNfdCB3cCwgY2hhcl90ICp0ZXh0KQp7CgljaGFyX3QgCSpvcCwgKnByb3RvLCAqcHJvdG9WZXIsICp1cmwsICpob3N0LCAqcXVlcnksICpwYXRoLCAqcG9ydCwgKmV4dDsKCWNoYXJfdAkqYnVmOwoJaW50CQl0ZXN0UG9ydDsKCiNpZmRlZiBGRUFUVVJFX1pURV9XRUJfVENBUkQKLy9hZGRlZCBieSBndW8gc2hvdXBlbmcgMTAxMjQyMjQgZm9yIGh0dHAgc2hhcmUgMjAxMTEwMDEgc3RhcnQKCWNoYXIgKnBhZ2VfYXR0PU5VTEw7Ci8vYWRkZWQgYnkgZ3VvIHNob3VwZW5nIDEwMTI0MjI0IGZvciBodHRwIHNoYXJlIDIwMTExMDAxIGVuZAojZW5kaWYKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoJYV9hc3NlcnQodGV4dCAmJiAqdGV4dCk7CiNpZmRlZiBXRUJJTlNQRUNUX0ZJWAkKCWlmKHRleHQgJiYgKCFpc19wcmludF9zdHIodGV4dCxzdHJsZW4odGV4dCkpIHx8IHN0cnN0cih0ZXh0LCAiSFRUUCIpID09IE5VTEwpKQoJewoJCXdlYnNEb25lKHdwLCAwKTsKCQlzbG9nKE1JU0NfUFJJTlQsIFNMT0dfRVJSLCJbZ29haGVhZF1lc1xuIik7CgkJcmV0dXJuIC0xOwoJfQojZW5kaWYKCW9wID0gZ3N0cnRvayh0ZXh0LCBUKCIgXHQiKSk7CglpZiAob3AgPT0gTlVMTCB8fCAqb3AgPT0gJ1wwJykgewoJCXdlYnNFcnJvcih3cCwgNDAwLCBUKCJCYWQgSFRUUCByZXF1ZXN0IikpOwoJCXJldHVybiAtMTsKCX0KCWlmIChnc3RyY21wKG9wLCBUKCJHRVQiKSkgIT0gMCkgewoJCWlmIChnc3RyY21wKG9wLCBUKCJQT1NUIikpID09IDApIHsKCQkJd3AtPmZsYWdzIHw9IFdFQlNfUE9TVF9SRVFVRVNUOwoJCX0gZWxzZSBpZiAoZ3N0cmNtcChvcCwgVCgiSEVBRCIpKSA9PSAwKSB7CgkJCXdwLT5mbGFncyB8PSBXRUJTX0hFQURfUkVRVUVTVDsKCQl9IGVsc2UgewoJCQl3ZWJzRXJyb3Iod3AsIDQwMCwgVCgiQmFkIHJlcXVlc3QgdHlwZSIpKTsKCQkJcmV0dXJuIC0xOwoJCX0KCX0KCgl3ZWJzU2V0VmFyKHdwLCBUKCJSRVFVRVNUX01FVEhPRCIpLCBvcCk7CgoJdXJsID0gZ3N0cnRvayhOVUxMLCBUKCIgXHRcbiIpKTsKCWlmICh1cmwgPT0gTlVMTCB8fCAqdXJsID09ICdcMCcpIHsKCQl3ZWJzRXJyb3Iod3AsIDQwMCwgVCgiQmFkIEhUVFAgcmVxdWVzdCIpKTsKCQlyZXR1cm4gLTE7Cgl9Cglwcm90b1ZlciA9IGdzdHJ0b2soTlVMTCwgVCgiIFx0XG4iKSk7CgoJaG9zdCA9IHBhdGggPSBwb3J0ID0gcHJvdG8gPSBxdWVyeSA9IGV4dCA9IE5VTEw7CglpZiAod2Vic1VybFBhcnNlKHVybCwgJmJ1ZiwgJmhvc3QsICZwYXRoLCAmcG9ydCwgJnF1ZXJ5LCAmcHJvdG8sIAoJCQlOVUxMLCAmZXh0KSA8IDApIHsKCQl3ZWJzRXJyb3Iod3AsIDQwMCwgVCgiQmFkIFVSTCBmb3JtYXQiKSk7CgkJcmV0dXJuIC0xOwoJfQoKCXdwLT51cmwgPSBic3RyZHVwKEJfTCwgdXJsKTsKCiNpZm5kZWYgX19OT19DR0lfQklOCgoKCWlmICgoZ3N0cnN0cih1cmwsIENHSV9CSU4pICE9IE5VTEwpJiYoKHdwLT5mbGFncyAmIFdFQlNfUE9TVF9SRVFVRVNUKSkpIHsKCQl3cC0+ZmxhZ3MgfD0gV0VCU19DR0lfUkVRVUVTVDsKCQkKCQlwcmludGYoIltnb2FoZWFkXXNldCBXRUJTX0NHSV9SRVFVRVNUIFxuIik7CgoJCS8vIHNwZWNpYWwgY2FzZTogdXBsb2FkLmNnaQoJCQoJCWlmKGdzdHJzdHIodXJsLCBDR0lfQklOX1VQTE9BRCkgIT0gTlVMTCkKCQl7CgkJCWlmKGdzdHJzdHIodXJsLCBDR0lfRklSTVdBUkVfVVBMT0FEKSAhPSBOVUxMKXsKCQkJCXdwLT5mbGFncyB8PSBXRUJTX0NHSV9GSVJNV0FSRV9VUExPQUQ7CgkJCQlzeXN0ZW0oInJtIC1yZiAgL2Zpcm13YXJlX3RtcF9maWxlIik7CgkJCQl6dGVfbWdtdF9sb2dpbl90aW1lbWFya19zZXQoKTsKCQkJCXByaW50ZigiW2dvYWhlYWRdc2V0IFdFQlNfQ0dJX0ZJUk1XQVJFX1VQTE9BRCBcbiIpOwoJCQl9CgkJCXdwLT5jZ2lTdGRpbiA9IHdlYnNHZXRDZ2lDb21tTmFtZSh3cCk7CgkJCXByaW50ZigiW2dvYWhlYWRdZ2V0IGNnaSBuYW1lLlxuIik7CgkJCS8vIGV4OiB1cGxvYWRfc2V0dGluZy4uLi4KCQkJd3AtPmZsYWdzIHw9IFdFQlNfQ0dJX1VQTE9BRDsKCQl9CgoJCWlmKGdzdHJzdHIodXJsLCBDR0lfQklOX0hUVFBTSEFSRSkgIT0gTlVMTCkKCQl7CgkJCXByaW50ZigiW2h0dHBzaGFyZV11cGxvYWQgZmlsZS5cbiIpOyAKCgkJCWlmKCF6dGVfcmVzZXRfY2dpX3N0YXRlKHdwKSkJCgkJCXsKCQkJCXByaW50ZigiW2h0dHBzaGFyZV11cGxvYWQgZmlsZS5yZXNldCBjZ2kgc3RhdGUgZXJyb3IuXG4iKTsKCQkJCWJmcmVlKEJfTCwgYnVmKTsKCQkJCXJldHVybiAtMTsKCQkJfQoJCQl3cC0+ZmxhZ3MgfD0gV0VCU19DR0lfSFRUUFNIQVJFX1VQTE9BRDsKCQl9CgkgICAgICAgICAgICAKCgl9CiNlbmRpZgoKCXdwLT5xdWVyeSA9IGJzdHJkdXAoQl9MLCBxdWVyeSk7Cgl3cC0+aG9zdCA9IGJzdHJkdXAoQl9MLCBob3N0KTsKCXdwLT5wYXRoID0gYnN0cmR1cChCX0wsIHBhdGgpOwoJd3AtPnByb3RvY29sID0gYnN0cmR1cChCX0wsIHByb3RvKTsKCXdwLT5wcm90b1ZlcnNpb24gPSBic3RyZHVwKEJfTCwgcHJvdG9WZXIpOwoJCgkvL2FkZGVkIGJ5IGxpdXlpbmduYW4gZm9yIFBDIENsaWVudCBiZWdpbiwgMjAxMjA4MjkKICAgIGlmIChnc3Ryc3RyKHVybCwgImFwaS9jbGllbnQvcG9zdCIpICE9IE5VTEwpIHsKICAgICAgICBwcmludGYoIiVzIiwgIndlYnNQYXJzZUZpcnN0OiBwYyBjbGllbnQgcG9zdCIpOwogICAgICAgIHdwLT5mbGFncyB8PSBXRUJTX1JFU1RfQ0xJRU5UX1JFUVVFU1Q7CiAgICB9CiAgICAvL2FkZGVkIGJ5IGh1YW5nbWluIGZvciBQQyBDbGllbnQgZW5kLCAyMDEyMDgyOQogICAgaWYgKGdzdHJzdHIodXJsLCAiYXBpL3htbGNsaWVudC9wb3N0IikgIT0gTlVMTCkgewogICAgICAgIHdwLT5mbGFncyB8PSBXRUJTX1hNTF9DTElFTlRfUkVRVUVTVDsKICAgIH0KCQoJaWYgKCh0ZXN0UG9ydCA9IHNvY2tldEdldFBvcnQod3AtPmxpc3RlblNpZCkpID49IDApIHsKCQl3cC0+cG9ydCA9IHRlc3RQb3J0OwoJfSBlbHNlIHsKCQl3cC0+cG9ydCA9IGdhdG9pKHBvcnQpOwoJfQoKCWlmIChnc3RyY21wKGV4dCwgVCgiLmFzcCIpKSA9PSAwKSB7CgkJd3AtPmZsYWdzIHw9IFdFQlNfQVNQOwoJfQoJYmZyZWUoQl9MLCBidWYpOwoKCXdlYnNVcmxUeXBlKHVybCwgd3AtPnR5cGUsIFRTWih3cC0+dHlwZSkpOwoKCXJpbmdxRmx1c2goJndwLT5oZWFkZXIpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgd2Vic0dldElucHV0KHdlYnNfdCB3cCwgY2hhcl90ICoqcHRleHQsIGludCAqcG5ieXRlcykgCnsKCWNoYXJfdAkqdGV4dDsKCWNoYXIJYnVmW1dFQlNfU09DS0VUX0JVRlNJWisxXTsKCWludAkJbmJ5dGVzLCBsZW4sIGNsZW47CgoJYV9hc3NlcnQod2Vic1ZhbGlkKHdwKSk7CglhX2Fzc2VydChwdGV4dCk7CglhX2Fzc2VydChwbmJ5dGVzKTsKCglpZih3ZWJzVmFsaWQod3ApID09IDAgfHwgcHRleHQgPT0gTlVMTCB8fCBwbmJ5dGVzID09IE5VTEwpewoJCXNvZnRhcF9hc3NlcnQoIndlYnNHZXRJbnB1dCAxIik7CgkJcmV0dXJuIC0xOy8vZm9yIGt3Cgl9CgoJKnB0ZXh0ID0gdGV4dCA9IE5VTEw7CgkqcG5ieXRlcyA9IDA7CgoJaWYgKHdwLT5zdGF0ZSA9PSBXRUJTX1BPU1RfQ0xFTikgewoJCWxlbiA9ICh3cC0+Y2xlbiA+IFdFQlNfU09DS0VUX0JVRlNJWikgPyBXRUJTX1NPQ0tFVF9CVUZTSVogOiB3cC0+Y2xlbjsKCX0gZWxzZSB7CgkJbGVuID0gMDsKCX0KCglpZiAobGVuID4gMCkgewoKI2lmZGVmIFdFQlNfU1NMX1NVUFBPUlQKCQlpZiAod3AtPmZsYWdzICYgV0VCU19TRUNVUkUpIHsKCQkJbmJ5dGVzID0gd2Vic1NTTFJlYWQod3AtPndzcCwgYnVmLCBsZW4pOwoJCX0gZWxzZSB7CgkJCW5ieXRlcyA9IHNvY2tldFJlYWQod3AtPnNpZCwgYnVmLCBsZW4pOwoJCX0KI2Vsc2UKCQluYnl0ZXMgPSBzb2NrZXRSZWFkKHdwLT5zaWQsIGJ1ZiwgbGVuKTsKI2VuZGlmCgkJaWYgKG5ieXRlcyA8IDApIHsJCQkJCQkvKiBFcnJvciAqLwoJCQl3ZWJzRG9uZSh3cCwgMCk7CgkJCXJldHVybiAtMTsKCgkJfSAgZWxzZSBpZiAobmJ5dGVzID09IDApIHsJCQkJLyogRU9GIG9yIE5vIGRhdGEgYXZhaWxhYmxlICovCgkJCS8vdHJhY2UoOCwgVCgiQEBAQHdlYnMgMHgleCAweCV4OiB3ZWJzR2V0SW5wdXQgcmVhZCAwXG4iKSx3cCx3cC0+c2lkKTsKCQkJaWYgKHNvY2tldEVvZih3cC0+c2lkKSkgewoJCQkJd2Vic0RvbmUod3AsIDApOwoJCQl9CgkJCXJldHVybiAtMTsKCgkJfSBlbHNlIHsJCQkJCQkJCS8qIFZhbGlkIGRhdGEgKi8KCgkJCWJ1ZltuYnl0ZXNdID0gJ1wwJzsKCQkJaWYgKCh0ZXh0ID0gYmFsbG9jQXNjVG9VbmkoYnVmLCBuYnl0ZXMpKSA9PSBOVUxMKSB7CgkJCQl3ZWJzRXJyb3Iod3AsIDUwMywgVCgiSW5zdWZmaWNpZW50IG1lbW9yeSIpKTsKCQkJCXJldHVybiAtMTsKCQkJfQoJCX0KCgl9IGVsc2UgewojaWZkZWYgV0VCU19TU0xfU1VQUE9SVAoJCWlmICh3cC0+ZmxhZ3MgJiBXRUJTX1NFQ1VSRSkgewoJCQluYnl0ZXMgPSB3ZWJzU1NMR2V0cyh3cC0+d3NwLCAmdGV4dCk7CgkJfSBlbHNlIHsKCQkJbmJ5dGVzID0gc29ja2V0R2V0cyh3cC0+c2lkLCAmdGV4dCk7CgkJfQojZWxzZQoJCW5ieXRlcyA9IHNvY2tldEdldHMod3AtPnNpZCwgJnRleHQpOwojZW5kaWYKCgkJaWYgKG5ieXRlcyA8IDApIHsKCQkJaW50IGVvZjsKCiNpZmRlZiBXRUJTX1NTTF9TVVBQT1JUCgkJCWlmICh3cC0+ZmxhZ3MgJiBXRUJTX1NFQ1VSRSkgewoKCQkJCWlmICh3cC0+c3RhdGUgPT0gV0VCU19CRUdJTikgewoJCQkJCWVvZiA9IDE7CgkJCQl9IGVsc2UgewoJCQkJCWVvZiA9IHdlYnNTU0xFb2Yod3AtPndzcCk7CgkJCQl9CgkJCX0gZWxzZSB7CgkJCQllb2YgPSBzb2NrZXRFb2Yod3AtPnNpZCk7CgkJCX0KI2Vsc2UKCQkJZW9mID0gc29ja2V0RW9mKHdwLT5zaWQpOwojZW5kaWYKCgkJCWlmIChlb2YpIHsKCgkJCQlpZiAod3AtPnN0YXRlID09IFdFQlNfUE9TVCkgewoJCQkJCXdlYnNVcmxIYW5kbGVyUmVxdWVzdCh3cCk7CgkJCQl9IGVsc2UgewoJCQkJCXdlYnNEb25lKHdwLCAwKTsKCQkJCX0KCQkJfSBlbHNlIHsKCQkJCQl0cmFjZSg4LCBUKCJAQEBAd2VicyAweCV4IDB4JXg6IHdlYnNHZXRJbnB1dCBubyBlb2ZcbiIpLHdwLHdwLT5zaWQpOwoKI2lmIDEvL2RlZiBIUF9GSVgKCQkJCXdlYnNEb25lKHdwLCAwKTsKI2VuZGlmIC8qSFBfRklYKi8KCgkJCX0KCiNpZiAwIC8vZGVmIFVOVVNFRAoJCQlpZiAod3AtPnN0YXRlID09IFdFQlNfSEVBREVSICYmIHJpbmdxTGVuKCZ3cC0+aGVhZGVyKSA8PSAwKSB7CgkJCQl3ZWJzUGFyc2VSZXF1ZXN0KHdwKTsKCQkJCXdlYnNVcmxIYW5kbGVyUmVxdWVzdCh3cCk7CgkJCX0KI2VuZGlmCgkJCWJmcmVlU2FmZShCX0wsdGV4dCk7Ly9mb3Iga3cKCQkJcmV0dXJuIC0xOwoKCQl9IGVsc2UgaWYgKG5ieXRlcyA9PSAwKSB7CgkJCWlmICh3cC0+c3RhdGUgPT0gV0VCU19IRUFERVIpIHsKCgkJCQlpZih3ZWJzUGFyc2VSZXF1ZXN0KHdwKSAhPSAwKXsKCQkJCQlyZXR1cm4gLTE7CgkJCQl9CgkJCQlpZiAod3AtPmZsYWdzICYgV0VCU19QT1NUX1JFUVVFU1QpIHsKCQkJCQlpZiAod3AtPmZsYWdzICYgV0VCU19DTEVOKSB7CgkJCQkJCXdwLT5zdGF0ZSA9IFdFQlNfUE9TVF9DTEVOOwoJCQkJCQljbGVuID0gd3AtPmNsZW47CgkJCQkJfSBlbHNlIHsKCQkJCQkJd3AtPnN0YXRlID0gV0VCU19QT1NUOwoJCQkJCQljbGVuID0gMTsKCQkJCQl9CgkJCQkJaWYgKGNsZW4gPiAwKSB7CgoJCQkJCQlyZXR1cm4gMDsKCQkJCQl9CgkJCQkJcmV0dXJuIDE7CgkJCQl9CgoJCQkJd2Vic1VybEhhbmRsZXJSZXF1ZXN0KHdwKTsKCQkJfQoJCQlyZXR1cm4gLTE7CgkJfQoJfQoKLy8JaWYodGV4dCA9PSBOVUxMIHx8IG5ieXRlcyA8PSAwKXsgLy8ga3cgMyBuYnl0ZXMgPD0gMCBhbHJlYWR5IHJldHVybgogICAgaWYodGV4dCA9PSBOVUxMKXsKCQlzb2Z0YXBfYXNzZXJ0KCJ3ZWJzR2V0SW5wdXQgMiIpOwoJfQoJYV9hc3NlcnQodGV4dCk7CglhX2Fzc2VydChuYnl0ZXMgPiAwKTsKCSpwdGV4dCA9IHRleHQ7CgkqcG5ieXRlcyA9IG5ieXRlczsKCXJldHVybiAxOwp9CgoKI2RlZmluZSBpc2dvb2RjaGFyKHMpIChnaXNhbG51bSgocykpIHx8ICgocykgPT0gJy8nKSB8fCAoKHMpID09ICdfJykgfHwgXAoJCQkJCQkoKHMpID09ICcuJykgIHx8ICgocykgPT0gJy0nKSApCgpzdGF0aWMgaW50IHdlYnNQYXJzZVJlcXVlc3Qod2Vic190IHdwKQp7CgljaGFyX3QJKmF1dGhUeXBlLCAqdXBwZXJLZXksICpjcCwgKmJyb3dzZXIsICpscCwgKmtleSwgKnZhbHVlOwoJaW50IHNtdWdnbGluZ0ZsYWcgPSAwOwoJYV9hc3NlcnQod2Vic1ZhbGlkKHdwKSk7CgoJd2Vic1NldFZhcih3cCwgVCgiSFRUUF9BVVRIT1JJWkFUSU9OIiksIFQoIiIpKTsKCglicm93c2VyID0gTlVMTDsKCWNoYXIgdG1wWzRdID0gVCgiIik7Cglmb3IgKGxwID0gKGNoYXJfdCopIHdwLT5oZWFkZXIuc2VydnA7IGxwICYmICpscDsgKSB7CgkJY3AgPSBscDsKCQlpZiAoKGxwID0gZ3N0cmNocihscCwgJ1xuJykpICE9IE5VTEwpIHsKCQkJbHArKzsKCQl9CgoJCWlmICgoa2V5ID0gZ3N0cnRvayhjcCwgVCgiOiBcdFxuIikpKSA9PSBOVUxMKSB7CgkJCWNvbnRpbnVlOwoJCX0KCgkJaWYgKCh2YWx1ZSA9IGdzdHJ0b2soTlVMTCwgVCgiXG4iKSkpID09IE5VTEwpIHsKCQkJLy92YWx1ZSA9IFQoIiIpOwoJCQl2YWx1ZSA9IHRtcDsvLyBrdyBPVkVSV1JJVEVfQ09OU1RfQ0hBUgoJCX0KCgkJd2hpbGUgKGdpc3NwYWNlKCp2YWx1ZSkpIHsKCQkJdmFsdWUrKzsKCQl9CgkJc3RybG93ZXIoa2V5KTsKCgkJZm10QWxsb2MoJnVwcGVyS2V5LCAoZ3N0cmxlbihrZXkpICsgNiksIFQoIkhUVFBfJXMiKSwga2V5KTsKCQlmb3IgKGNwID0gdXBwZXJLZXk7ICpjcDsgY3ArKykgewoJCQlpZiAoKmNwID09ICctJykKCQkJCSpjcCA9ICdfJzsKCQl9CgkJc3RydXBwZXIodXBwZXJLZXkpOwoJCXdlYnNTZXRWYXIod3AsIHVwcGVyS2V5LCB2YWx1ZSk7CgkJYmZyZWUoQl9MLCB1cHBlcktleSk7CgoJCWlmIChnc3RyY21wKGtleSwgVCgidXNlci1hZ2VudCIpKSA9PSAwKSB7CgkJCWlmICh3cC0+dXNlckFnZW50KQoJCQkJYmZyZWUoQl9MLCB3cC0+dXNlckFnZW50KTsKCQkJd3AtPnVzZXJBZ2VudCA9IGJzdHJkdXAoQl9MLCB2YWx1ZSk7CgoJCX0gZWxzZSBpZiAoZ3N0cmljbXAoa2V5LCBUKCJhdXRob3JpemF0aW9uIikpID09IDApIHsKCgkJCWF1dGhUeXBlID0gYnN0cmR1cCAoQl9MLCB2YWx1ZSk7CgkJCWFfYXNzZXJ0IChhdXRoVHlwZSk7CgoJCQljcCA9IGF1dGhUeXBlOwoJCQl3aGlsZSAoZ2lzYWxwaGEoKmNwKSkgewoJCQkJY3ArKzsKCQkJfQoJCQkqY3AgPSAnXDAnOwoJCQlpZiAod3AtPmF1dGhUeXBlKQoJCQkJYmZyZWUoQl9MLCB3cC0+YXV0aFR5cGUpOwoJCQl3cC0+YXV0aFR5cGUgPSBic3RyZHVwKEJfTCwgYXV0aFR5cGUpOwoJCQliZnJlZShCX0wsIGF1dGhUeXBlKTsKCgkJCWlmIChnc3RyaWNtcCh3cC0+YXV0aFR5cGUsIFQoImJhc2ljIikpID09IDApIHsKCQkJCWNoYXJfdAl1c2VyQXV0aFtGTkFNRVNJWkVdOwoKCQkJCWlmICgoY3AgPSBnc3RyY2hyKHZhbHVlLCAnICcpKSAhPSBOVUxMKSB7CgkJCQkJKmNwID0gJ1wwJzsKCiAgICAgICAgICAgICAgIGJmcmVlKEJfTCwgd3AtPmF1dGhUeXBlKTsKCQkJCQl3cC0+YXV0aFR5cGUgPSBic3RyZHVwKEJfTCwgdmFsdWUpOwoJCQkJCXdlYnNEZWNvZGU2NCh1c2VyQXV0aCwgKytjcCwgc2l6ZW9mKHVzZXJBdXRoKSk7CgkJCQl9IGVsc2UgewoJCQkJCXdlYnNEZWNvZGU2NCh1c2VyQXV0aCwgdmFsdWUsIHNpemVvZih1c2VyQXV0aCkpOwoJCQkJfQoKCQkJCWlmICgoY3AgPSBnc3RyY2hyKHVzZXJBdXRoLCAnOicpKSAhPSBOVUxMKSB7CgkJCQkJKmNwKysgPSAnXDAnOwoJCQkJfQoJCQkJaWYgKHdwLT5wYXNzd29yZCkKCQkJCQliZnJlZShCX0wsIHdwLT5wYXNzd29yZCk7CgkJCQlpZiAod3AtPnVzZXJOYW1lKQoJCQkJCWJmcmVlKEJfTCwgd3AtPnVzZXJOYW1lKTsKCQkJCWlmIChjcCkgewoJCQkJCXdwLT51c2VyTmFtZSA9IGJzdHJkdXAoQl9MLCB1c2VyQXV0aCk7CgkJCQkJd3AtPnBhc3N3b3JkID0gYnN0cmR1cChCX0wsIGNwKTsKCQkJCX0gZWxzZSB7CgkJCQkJd3AtPnVzZXJOYW1lID0gYnN0cmR1cChCX0wsIFQoIiIpKTsKCQkJCQl3cC0+cGFzc3dvcmQgPSBic3RyZHVwKEJfTCwgVCgiIikpOwoJCQkJfQoKCQkJCXdwLT5mbGFncyB8PSBXRUJTX0FVVEhfQkFTSUM7CgkJCX0gZWxzZSB7CiNpZmRlZiBESUdFU1RfQUNDRVNTX1NVUFBPUlQKCgkJCQljaGFyX3QgKm5wOwkJCgkJCQljaGFyX3QgdHA7CQkKCQkJCWNoYXJfdCAqdnA7CQkKCQkJCWNoYXJfdCAqbnB2OwkKCQkJCWNoYXJfdCB0cHY7CQkKCgkJCQl3cC0+ZmxhZ3MgfD0gV0VCU19BVVRIX0RJR0VTVDsKCiAJCQkJY3AgPSB2YWx1ZTsKCQkJCXdoaWxlIChpc2dvb2RjaGFyKCpjcCkpIHsKCQkJCQljcCsrOwoJCQkJfQoJCQkJd2hpbGUgKCFpc2dvb2RjaGFyKCpjcCkpIHsKCQkJCQljcCsrOwoJCQkJfQoKCgkJCQl2cCA9IGdzdHJjaHIoY3AsICc9Jyk7CgkJCQl3aGlsZSAodnApIHsKCgkJCQkJbnAgPSBjcDsKCQkJCQl3aGlsZSAoaXNnb29kY2hhcigqbnApKSB7CgkJCQkJCW5wKys7CgkJCQkJfQoJCQkJCXRwID0gKm5wOwoJCQkJCSpucCA9IDA7CgoJCQkJCXZwKys7CgkJCQkJd2hpbGUgKCFpc2dvb2RjaGFyKCp2cCkpIHsKCQkJCQkJdnArKzsKCQkJCQl9CgoJCQkJCW5wdiA9IHZwOwoJCQkJCXdoaWxlIChpc2dvb2RjaGFyKCpucHYpKSB7CgkJCQkJCW5wdisrOwoJCQkJCX0KCQkJCQl0cHYgPSAqbnB2OwoJCQkJCSpucHYgPSAwOwoKCQkJCQlpZiAoZ3N0cmljbXAoY3AsIFQoInVzZXJuYW1lIikpID09IDApIHsKCQkJCQkJd3AtPnVzZXJOYW1lID0gYnN0cmR1cChCX0wsIHZwKTsKCQkJCQl9IGVsc2UgaWYgKGdzdHJpY21wKGNwLCBUKCJyZXNwb25zZSIpKSA9PSAwKSB7CgkJCQkJCXdwLT5kaWdlc3QgPSBic3RyZHVwKEJfTCwgdnApOwoJCQkJCX0gZWxzZSBpZiAoZ3N0cmljbXAoY3AsIFQoIm9wYXF1ZSIpKSA9PSAwKSB7CgkJCQkJCXdwLT5vcGFxdWUgPSBic3RyZHVwKEJfTCwgdnApOwoJCQkJCX0gZWxzZSBpZiAoZ3N0cmljbXAoY3AsIFQoInVyaSIpKSA9PSAwKSB7CgkJCQkJCXdwLT51cmkgPSBic3RyZHVwKEJfTCwgdnApOwoJCQkJCX0gZWxzZSBpZiAoZ3N0cmljbXAoY3AsIFQoInJlYWxtIikpID09IDApIHsKCQkJCQkJd3AtPnJlYWxtID0gYnN0cmR1cChCX0wsIHZwKTsKCQkJCQl9IGVsc2UgaWYgKGdzdHJpY21wKGNwLCBUKCJub25jZSIpKSA9PSAwKSB7CgkJCQkJCXdwLT5ub25jZSA9IGJzdHJkdXAoQl9MLCB2cCk7CgkJCQkJfSBlbHNlIGlmIChnc3RyaWNtcChjcCwgVCgibmMiKSkgPT0gMCkgewoJCQkJCQl3cC0+bmMgPSBic3RyZHVwKEJfTCwgdnApOwoJCQkJCX0gZWxzZSBpZiAoZ3N0cmljbXAoY3AsIFQoImNub25jZSIpKSA9PSAwKSB7CgkJCQkJCXdwLT5jbm9uY2UgPSBic3RyZHVwKEJfTCwgdnApOwoJCQkJCX0gZWxzZSBpZiAoZ3N0cmljbXAoY3AsIFQoInFvcCIpKSA9PSAwKSB7CgkJCQkJCXdwLT5xb3AgPSBic3RyZHVwKEJfTCwgdnApOwoJCQkJCX0KCgkJCQkJKm5wID0gdHA7CgkJCQkJKm5wdiA9IHRwdjsKCiAJCQkJCWNwID0gbnB2OwoJCQkJCXdoaWxlICgqY3AgJiYgaXNnb29kY2hhcigqY3ApKSB7CgkJCQkJCWNwKys7CgkJCQkJfQoJCQkJCXdoaWxlICgqY3AgJiYgIWlzZ29vZGNoYXIoKmNwKSkgewoJCQkJCQljcCsrOwoJCQkJCX0KCgkJCQkJaWYgKCpjcCkgewoJCQkJCQl2cCA9IGdzdHJjaHIoY3AsICc9Jyk7CgkJCQkJfSBlbHNlIHsKCQkJCQkJdnAgPSBOVUxMOwoJCQkJCX0KCQkJCX0KI2VuZGlmIC8qIERJR0VTVF9BQ0NFU1NfU1VQUE9SVCAqLwoJCQl9IC8qIGlmIChnc3RyY21wKHdwLT5hdXRoVHlwZSkpICovCiNpZmRlZiBXRUJTX1NFQ1VSSVRZCgkJfSBlbHNlIGlmIChnc3RyY21wKGtleSwgVCgieC1odHRwLW1ldGhvZCIpKSA9PSAwKSB7CgkJCXByaW50Zigid2Vic1BhcnNlUmVxdWVzdDoga2V5PSVzXG4iLGtleSk7CgkJCXdlYnNFcnJvcih3cCwgNDA1LCBUKCIiKSk7CgkJCXJldHVybiAtMTsKCQl9IGVsc2UgaWYgKGdzdHJjbXAoa2V5LCBUKCJ4LWh0dHAtbWV0aG9kLW92ZXJyaWRlIikpID09IDApIHsKCQkJcHJpbnRmKCJ3ZWJzUGFyc2VSZXF1ZXN0OiBrZXk9JXNcbiIsa2V5KTsKCQkJd2Vic0Vycm9yKHdwLCA0MDUsIFQoIiIpKTsKCQkJcmV0dXJuIC0xOwoJCX0gZWxzZSBpZiAoZ3N0cmNtcChrZXksIFQoIngtbWV0aG9kLW92ZXJyaWRlIikpID09IDApIHsKCQkJcHJpbnRmKCJ3ZWJzUGFyc2VSZXF1ZXN0OiBrZXk9JXNcbiIsa2V5KTsKCQkJd2Vic0Vycm9yKHdwLCA0MDUsIFQoIiIpKTsKCQkJcmV0dXJuIC0xOwoJCX0gZWxzZSBpZiAoZ3N0cmNtcChrZXksIFQoInRyYW5zZmVyLWVuY29kaW5nIikpID09IDApIHsKCQkJcHJpbnRmKCJ3ZWJzUGFyc2VSZXF1ZXN0OiBrZXk9JXNcbiIsa2V5KTsKCQkJaWYoc211Z2dsaW5nRmxhZykgewoJCQkJd2Vic0Vycm9yKHdwLCA0MDMsIFQoIiIpKTsKCQkJCXJldHVybiAtMTsKCQkJfQoJCQlzbXVnZ2xpbmdGbGFnID0gMTsKI2VuZGlmCgoJCX0gZWxzZSBpZiAoZ3N0cmNtcChrZXksIFQoImNvbnRlbnQtbGVuZ3RoIikpID09IDApIHsKCiNpZmRlZiBXRUJTX1NFQ1VSSVRZCgkJIGlmKHNtdWdnbGluZ0ZsYWcpIHsKCQkJIHdlYnNFcnJvcih3cCwgNDAzLCBUKCIiKSk7CgkJCSByZXR1cm4gLTE7CgkJIH0KCQkgc211Z2dsaW5nRmxhZyA9IDE7CiNlbmRpZgkJIAogICAgICAgICB3cC0+Y2xlbiA9IGdhdG9pKHZhbHVlKTsKICAgICAgICAgaWYgKHdwLT5jbGVuID4gMCkKICAgICAgICAgewoJCQkgICB3cC0+ZmxhZ3MgfD0gV0VCU19DTEVOOwkJCQoJCQkgICB3ZWJzU2V0VmFyKHdwLCBUKCJDT05URU5UX0xFTkdUSCIpLCB2YWx1ZSk7CiAgICAgICAgIH0KICAgICAgICAgZWxzZQogICAgICAgICB7CiAgICAgICAgICAgIHdwLT5jbGVuID0gMDsKICAgICAgICAgfQoKCQl9IGVsc2UgaWYgKGdzdHJjbXAoa2V5LCBUKCJjb250ZW50LXR5cGUiKSkgPT0gMCkgewoJCQl3ZWJzU2V0VmFyKHdwLCBUKCJDT05URU5UX1RZUEUiKSwgdmFsdWUpOwoKI2lmZGVmIFdFQlNfS0VFUF9BTElWRV9TVVBQT1JUCgkJfSBlbHNlIGlmIChnc3RyY21wKGtleSwgVCgiY29ubmVjdGlvbiIpKSA9PSAwKSB7CgkJCXN0cmxvd2VyKHZhbHVlKTsKCQkJaWYgKGdzdHJjbXAodmFsdWUsIFQoImtlZXAtYWxpdmUiKSkgPT0gMCkgewoJCQkJd3AtPmZsYWdzIHw9IFdFQlNfS0VFUF9BTElWRTsKCQkJfQojZW5kaWYKCiNpZmRlZiBXRUJTX1BST1hZX1NVUFBPUlQKCgkJfSBlbHNlIGlmIChnc3RyY21wKGtleSwgVCgicHJhZ21hIikpID09IDApIHsKCQkJY2hhcl90CXRtcFsyNTZdOwoJCQlnc3RybmNweSh0bXAsIHZhbHVlLCBUU1oodG1wKSk7CgkJCXN0cmxvd2VyKHRtcCk7CgkJCWlmIChnc3Ryc3RyKHRtcCwgVCgibm8tY2FjaGUiKSkpIHsKCQkJCXdwLT5mbGFncyB8PSBXRUJTX0RPTlRfVVNFX0NBQ0hFOwoJCQl9CiNlbmRpZiAvKiBXRUJTX1BST1hZX1NVUFBPUlQgKi8KCgoJCX0gZWxzZSBpZiAoZ3N0cmNtcChrZXksIFQoImNvb2tpZSIpKSA9PSAwKSB7CgkJCXdwLT5mbGFncyB8PSBXRUJTX0NPT0tJRTsKCQkJaWYgKHdwLT5jb29raWUpCgkJCQliZnJlZShCX0wsIHdwLT5jb29raWUpOwoJCQl3cC0+Y29va2llID0gYnN0cmR1cChCX0wsIHZhbHVlKTsKCQl9IGVsc2UgaWYgKGdzdHJjbXAoa2V5LCBUKCJyZWZlcmVyIikpID09IDApIHsKCQkJaWYgKHdwLT5yZWZlcmVyKQoJCQkJYmZyZWUoQl9MLCB3cC0+cmVmZXJlcik7CgkJCXdwLT5yZWZlcmVyID0gYnN0cmR1cChCX0wsIHZhbHVlKTsKCgkJfQoJfQoJcmV0dXJuIDA7Cn0KCgppbnQgd2Vic1Rlc3RWYXIod2Vic190IHdwLCBjaGFyX3QgKnZhcikKewoJc3ltX3QJCSpzcDsKCglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCglpZiAodmFyID09IE5VTEwgfHwgKnZhciA9PSAnXDAnKSB7CgkJcmV0dXJuIDA7Cgl9CgoJaWYgKChzcCA9IHN5bUxvb2t1cCh3cC0+Y2dpVmFycywgdmFyKSkgPT0gTlVMTCkgewoJCXJldHVybiAwOwoJfQoJcmV0dXJuIDE7Cn0KCnZvaWQgd2Vic1NldFZhcih3ZWJzX3Qgd3AsIGNoYXJfdCAqdmFyLCBjaGFyX3QgKnZhbHVlKQp7Cgl2YWx1ZV90CQkgdjsKCglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCglpZiAodmFsdWUpIHsKCQl2ID0gdmFsdWVTdHJpbmcodmFsdWUsIFZBTFVFX0FMTE9DQVRFKTsKCX0gZWxzZSB7CgkJdiA9IHZhbHVlU3RyaW5nKFQoIiIpLCBWQUxVRV9BTExPQ0FURSk7Cgl9CglzeW1FbnRlcih3cC0+Y2dpVmFycywgdmFyLCB2LCAwKTsKfQoKCnZvaWQgd2Vic1NldEVudih3ZWJzX3Qgd3ApCnsKCWNoYXJfdAlwb3J0QnVmWzhdOwoJY2hhcl90CSprZXl3b3JkLCAqdmFsdWUsICp2YWxDaGVjaywgKnZhbE5ldzsKCglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCgl3ZWJzU2V0VmFyKHdwLCBUKCJRVUVSWV9TVFJJTkciKSwgd3AtPnF1ZXJ5KTsKCXdlYnNTZXRWYXIod3AsIFQoIkdBVEVXQVlfSU5URVJGQUNFIiksIFQoIkNHSS8xLjEiKSk7Cgl3ZWJzU2V0VmFyKHdwLCBUKCJTRVJWRVJfSE9TVCIpLCB3ZWJzSG9zdCk7Cgl3ZWJzU2V0VmFyKHdwLCBUKCJTRVJWRVJfTkFNRSIpLCB3ZWJzSG9zdCk7Cgl3ZWJzU2V0VmFyKHdwLCBUKCJTRVJWRVJfVVJMIiksIHdlYnNIb3N0VXJsKTsKCXdlYnNTZXRWYXIod3AsIFQoIlJFTU9URV9IT1NUIiksIHdwLT5pcGFkZHIpOwoJd2Vic1NldFZhcih3cCwgVCgiUkVNT1RFX0FERFIiKSwgd3AtPmlwYWRkcik7Cgl3ZWJzU2V0VmFyKHdwLCBUKCJQQVRIX0lORk8iKSwgd3AtPnBhdGgpOwoJc3RyaXRvYSh3ZWJzUG9ydCwgcG9ydEJ1Ziwgc2l6ZW9mKHBvcnRCdWYpKTsKCXdlYnNTZXRWYXIod3AsIFQoIlNFUlZFUl9QT1JUIiksIHBvcnRCdWYpOwoJd2Vic1NldFZhcih3cCwgVCgiU0VSVkVSX0FERFIiKSwgd2Vic0lwYWRkcik7CglmbXRBbGxvYygmdmFsdWUsIEZOQU1FU0laRSwgVCgiJXMvJXMiKSwgV0VCU19OQU1FLCBXRUJTX1ZFUlNJT04pOwoJd2Vic1NldFZhcih3cCwgVCgiU0VSVkVSX1NPRlRXQVJFIiksIHZhbHVlKTsKCWJmcmVlU2FmZShCX0wsIHZhbHVlKTsKCXdlYnNTZXRWYXIod3AsIFQoIlNFUlZFUl9QUk9UT0NPTCIpLCB3cC0+cHJvdG9WZXJzaW9uKTsKCgl3cC0+ZGVjb2RlZFF1ZXJ5ID0gYnN0cmR1cChCX0wsIHdwLT5xdWVyeSk7CglrZXl3b3JkID0gZ3N0cnRvayh3cC0+ZGVjb2RlZFF1ZXJ5LCBUKCImIikpOwoJY2hhciB0bXBbNF0gPSBUKCIiKTsKCXdoaWxlIChrZXl3b3JkICE9IE5VTEwpIHsKCQlpZiAoKHZhbHVlID0gZ3N0cmNocihrZXl3b3JkLCAnPScpKSAhPSBOVUxMKSB7CgkJCSp2YWx1ZSsrID0gJ1wwJzsKCQkJd2Vic0RlY29kZVVybChrZXl3b3JkLCBrZXl3b3JkLCBnc3RybGVuKGtleXdvcmQpKTsKCQkJd2Vic0RlY29kZVVybCh2YWx1ZSwgdmFsdWUsIGdzdHJsZW4odmFsdWUpKTsKCQl9IGVsc2UgewoJCQkvL3ZhbHVlID0gVCgiIik7CgkJCXZhbHVlID0gdG1wOy8vIGt3IE9WRVJXUklURV9DT05TVF9DSEFSCgkJfQoKCQlpZiAoKmtleXdvcmQpIHsKCgkJCWlmICgodmFsQ2hlY2sgPSB3ZWJzR2V0VmFyKHdwLCBrZXl3b3JkLCBOVUxMKSkgIT0gMCkgewoJCQkJZm10QWxsb2MoJnZhbE5ldywgMjU2LCBUKCIlcyAlcyIpLCB2YWxDaGVjaywgdmFsdWUpOwoJCQkJd2Vic1NldFZhcih3cCwga2V5d29yZCwgdmFsTmV3KTsKCQkJCWJmcmVlU2FmZShCX0wsIHZhbE5ldyk7CgkJCX0gZWxzZSB7CgkJCQl3ZWJzU2V0VmFyKHdwLCBrZXl3b3JkLCB2YWx1ZSk7CgkJCX0KCQl9CgkJa2V5d29yZCA9IGdzdHJ0b2soTlVMTCwgVCgiJiIpKTsKCX0KCiNpZmRlZiBFTUYKCgl3ZWJzU2V0RW1mRW52aXJvbm1lbnQod3ApOwojZW5kaWYKfQoKCmludCB3ZWJzQ29tcGFyZVZhcih3ZWJzX3Qgd3AsIGNoYXJfdCAqdmFyLCBjaGFyX3QgKnZhbHVlKQp7CglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCWFfYXNzZXJ0KHZhciAmJiAqdmFyKTsKIAoJaWYgKGdzdHJjbXAodmFsdWUsIHdlYnNHZXRWYXIod3AsIHZhciwgVCgiIF9fVU5ERUZfXyAiKSkpID09IDApIHsKCQlyZXR1cm4gMTsKCX0KCXJldHVybiAwOwp9CgpjaGFyX3QgKndlYnNHZXRWYXIod2Vic190IHdwLCBjaGFyX3QgKnZhciwgY2hhcl90ICpkZWZhdWx0R2V0VmFsdWUpCnsKCXN5bV90CSpzcDsKCglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCWFfYXNzZXJ0KHZhciAmJiAqdmFyKTsKIAoJaWYgKChzcCA9IHN5bUxvb2t1cCh3cC0+Y2dpVmFycywgdmFyKSkgIT0gTlVMTCkgewoJCWFfYXNzZXJ0KHNwLT5jb250ZW50LnR5cGUgPT0gc3RyaW5nKTsKCQlpZiAoc3AtPmNvbnRlbnQudmFsdWUuc3RyaW5nKSB7CgkJCXJldHVybiBzcC0+Y29udGVudC52YWx1ZS5zdHJpbmc7CgkJfSBlbHNlIHsKCQkJcmV0dXJuIFQoIiIpOwoJCX0KCX0KCXJldHVybiBkZWZhdWx0R2V0VmFsdWU7Cn0KCgp2b2lkIHdlYnNSZXNwb25zZSh3ZWJzX3Qgd3AsIGludCBjb2RlLCBjaGFyX3QgKm1lc3NhZ2UsIGNoYXJfdCAqcmVkaXJlY3QpCnsKCWNoYXJfdAkJKmRhdGU7CgoJYV9hc3NlcnQod2Vic1ZhbGlkKHdwKSk7CgoJd3AtPmZsYWdzICY9IH5XRUJTX0tFRVBfQUxJVkU7CgoJaWYgKCAhKHdwLT5mbGFncyAmIFdFQlNfSEVBREVSX0RPTkUpKSB7CgkJd3AtPmZsYWdzIHw9IFdFQlNfSEVBREVSX0RPTkU7CgoJCWlmIChyZWRpcmVjdCAhPSBOVUxMKSB7CgkJCXdlYnNXcml0ZSh3cCwgVCgiSFRUUC8xLjAgJWQgJXNcclxuIiksIGNvZGUsIHdlYnNFcnJvck1zZyhjb2RlKSk7CgkJfSBlbHNlIHsKCQkJd2Vic1dyaXRlKHdwLCBUKCJIVFRQLzEuMSAlZCAlc1xyXG4iKSwgY29kZSwgd2Vic0Vycm9yTXNnKGNvZGUpKTsKCQl9CgoKCQl3ZWJzV3JpdGUod3AsIFQoIlNlcnZlcjogJXNcclxuIiksIFdFQlNfTkFNRSk7CgoJCWlmICgoZGF0ZSA9IHdlYnNHZXREYXRlU3RyaW5nKE5VTEwpKSAhPSBOVUxMKSB7CgkJCXdlYnNXcml0ZSh3cCwgVCgiRGF0ZTogJXNcclxuIiksIGRhdGUpOwoJCQliZnJlZShCX0wsIGRhdGUpOwoJCX0KCgkJaWYgKGNvZGUgPT0gNDAxKSB7CgkJCWlmICghKHdwLT5mbGFncyAmIFdFQlNfQVVUSF9ESUdFU1QpKSB7CgkJCQl3ZWJzV3JpdGUod3AsIFQoIldXVy1BdXRoZW50aWNhdGU6IEJhc2ljIHJlYWxtPVwiJXNcIlxyXG4iKSwgCgkJCQkJd2Vic0dldFJlYWxtKCkpOwojaWZkZWYgRElHRVNUX0FDQ0VTU19TVVBQT1JUCgkJCX0gZWxzZSB7CgkJCQljaGFyX3QgKm5vbmNlLCAqb3BhcXVlOwoKICAgICAgICAgICAgLyogJCQkIGJlZm9yZS4uLiAobm90ZSBjb21tYXMgaW5zdGVhZCBvZiBzZW1pY29sb25zLi4uKQoJCQkJbm9uY2UgPSB3ZWJzQ2FsY05vbmNlKHdwKSwgCgkJCQlvcGFxdWUgPSB3ZWJzQ2FsY09wYXF1ZSh3cCksIAogICAgICAgICAgICAkJCQgYWZ0ZXIgKi8KCQkJCW5vbmNlID0gd2Vic0NhbGNOb25jZSh3cCk7CgkJCQlvcGFxdWUgPSB3ZWJzQ2FsY09wYXF1ZSh3cCk7IAogICAgICAgICAgICAvKiAuLi4kJCQgZW5kICovCgkJCQl3ZWJzV3JpdGUod3AsIAoJCQkJCVQoIldXVy1BdXRoZW50aWNhdGU6IERpZ2VzdCByZWFsbT1cIiVzXCIsIGRvbWFpbj1cIiVzXCIsIikKCQkJCQlUKCJxb3A9XCIlc1wiLCBub25jZT1cIiVzXCIsIG9wYXF1ZT1cIiVzXCIsIikKCQkJCQlUKCJhbGdvcml0aG09XCIlc1wiLCBzdGFsZT1cIiVzXCJcclxuIiksIAoJCQkJCXdlYnNHZXRSZWFsbSgpLAoJCQkJCXdlYnNHZXRIb3N0VXJsKCksCgkJCQkJVCgiYXV0aCIpLAoJCQkJCW5vbmNlLAoJCQkJCW9wYXF1ZSwgVCgiTUQ1IiksIFQoIkZBTFNFIikpOwoJCQkJYmZyZWUoQl9MLCBub25jZSk7CgkJCQliZnJlZShCX0wsIG9wYXF1ZSk7CiNlbmRpZgoJCQl9CgkJfQoKCQlpZiAod3AtPmZsYWdzICYgV0VCU19LRUVQX0FMSVZFKSB7CgkJCXdlYnNXcml0ZSh3cCwgVCgiQ29ubmVjdGlvbjoga2VlcC1hbGl2ZVxyXG4iKSk7CgkJfQojaWZkZWYgV0VCSU5TUEVDVF9GSVgKCQl3ZWJzV3JpdGUod3AsIFQoIlgtRnJhbWUtT3B0aW9uczogU0FNRU9SSUdJTlxyXG4iKSk7CiNlbmRpZgoJCXdlYnNXcml0ZSh3cCwgVCgiUHJhZ21hOiBuby1jYWNoZVxyXG5DYWNoZS1Db250cm9sOiBuby1jYWNoZVxyXG4iKSk7CgkJd2Vic1dyaXRlKHdwLCBUKCJDb250ZW50LVR5cGU6IHRleHQvaHRtbFxyXG4iKSk7CgoJCWlmIChyZWRpcmVjdCkgewoJCQl3ZWJzV3JpdGUod3AsIFQoIkxvY2F0aW9uOiAlc1xyXG4iKSwgcmVkaXJlY3QpOwoJCX0KCQl3ZWJzV3JpdGUod3AsIFQoIlxyXG4iKSk7Cgl9CgoKCWlmICgod3AtPmZsYWdzICYgV0VCU19IRUFEX1JFUVVFU1QpID09IDAgJiYgbWVzc2FnZSAmJiAqbWVzc2FnZSkgewoJCXdlYnNXcml0ZSh3cCwgVCgiJXNcclxuIiksIG1lc3NhZ2UpOwoJfQoJd2Vic0RvbmUod3AsIGNvZGUpOwp9Cgp2b2lkIHdlYnNUaW1lb3V0Q2FuY2VsKHdlYnNfdCB3cCkKewoJYV9hc3NlcnQod2Vic1ZhbGlkKHdwKSk7CgoJaWYgKHdwLT50aW1lb3V0ID49IDApIHsKCQllbWZVbnNjaGVkQ2FsbGJhY2sod3AtPnRpbWVvdXQpOwoJCXdwLT50aW1lb3V0ID0gLTE7Cgl9Cn0KCnZvaWQgd2Vic1JlZGlyZWN0KHdlYnNfdCB3cCwgY2hhcl90ICp1cmwpCnsKCWNoYXJfdAkqbXNnYnVmLCAqdXJsYnVmLCAqcmVkaXJlY3RGbXQ7CgoJYV9hc3NlcnQod2Vic1ZhbGlkKHdwKSk7CglhX2Fzc2VydCh1cmwpOwoKCXdlYnNTdGF0cy5yZWRpcmVjdHMrKzsKCW1zZ2J1ZiA9IHVybGJ1ZiA9IE5VTEw7CgkKCWlmIChnc3Ryc3RyKHVybCwgVCgiJTBEIikpIHx8IGdzdHJzdHIodXJsLCBUKCIlMEEiKSkgCgkJfHwgZ3N0cnN0cih1cmwsIFQoIiUwZCIpKSB8fCBnc3Ryc3RyKHVybCwgVCgiJTBhIikpCgkJfHwgZ3N0cnN0cih1cmwsIFQoIlxyIikpIHx8IGdzdHJzdHIodXJsLCBUKCJcbiIpKSkgewoJCXByaW50ZigiW2dvYWhlYWRdUmVkaXJlY3QgaW5qbyAlc1xuIix1cmwpOwoJCXVybCA9IFQoWlRFX1dFQl9QQUdFX0xPR0lOX05BTUUpOwoJCS8q08PT2tbYtqjP8rXEyuTI67LOyv2yu8TcsPy6rLvYs7W6zbu70NDX1rf7o6zS1LfA1rlIVFRQz+zTprLwt9a5pbv3Ki8KCX0KCgoJaWYgKGdzdHJzdHIodXJsLCBUKCJodHRwOi8vIikpID09IE5VTEwgJiYgZ3N0cnN0cih1cmwsIFQoImh0dHBzOi8vIikpID09IE5VTEwpIHsKCQlpZiAoKnVybCA9PSAnLycpIHsKCQkJdXJsKys7CgkJfQoKCQkvL3JlZGlyZWN0Rm10ID0gVCgiaHR0cDovLyVzLyVzIik7CgojaWZkZWYgV0VCU19TU0xfU1VQUE9SVAoJCS8vaWYgKHdwLT5mbGFncyAmIFdFQlNfU0VDVVJFKSB7CQkJCgkJaWYgKHdlYnNTU0xJc09wZW4oKSkgewoJCQkvL3JlZGlyZWN0Rm10ID0gVCgiaHR0cHM6Ly8lcy8lcyIpOy8vIGt3IE9WRVJXUklURV9DT05TVF9DSEFSCgkJCWZtdEFsbG9jKCZ1cmxidWYsIFdFQlNfTUFYX1VSTCArIDgwLCAiaHR0cHM6Ly8lcy8lcyIsCgkJCQl3ZWJzR2V0VmFyKHdwLCBUKCJIVFRQX0hPU1QiKSwJd2Vic0hvc3RVcmwpLCB1cmwpOwoJCX0KCQllbHNlCiNlbmRpZgoJCXsKCQkJZm10QWxsb2MoJnVybGJ1ZiwgV0VCU19NQVhfVVJMICsgODAsICJodHRwOi8vJXMvJXMiLAoJCQkJd2Vic0dldFZhcih3cCwgVCgiSFRUUF9IT1NUIiksIAl3ZWJzSG9zdFVybCksIHVybCk7CgkJfQoJCXVybCA9IHVybGJ1ZjsKCQlwcmludGYoIltnb2FoZWFkXVJlZGlyZWN0ICVzXG4iLHVybCk7Cgl9CgoKCWZtdEFsbG9jKCZtc2didWYsIFdFQlNfTUFYX1VSTCArIDgwLCAKCQlUKCI8aHRtbD48aGVhZD48L2hlYWQ+PGJvZHk+XHJcblwKCQlUaGlzIGRvY3VtZW50IGhhcyBtb3ZlZCB0byBhIG5ldyA8YSBocmVmPVwiJXNcIj5sb2NhdGlvbjwvYT4uXHJcblwKCQlQbGVhc2UgdXBkYXRlIHlvdXIgZG9jdW1lbnRzIHRvIHJlZmxlY3QgdGhlIG5ldyBsb2NhdGlvbi5cclxuXAoJCTwvYm9keT48L2h0bWw+XHJcbiIpLCB1cmwpOwoKCXdlYnNSZXNwb25zZSh3cCwgMzAyLCBtc2didWYsIHVybCk7CgoJYmZyZWVTYWZlKEJfTCwgbXNnYnVmKTsKCWJmcmVlU2FmZShCX0wsIHVybGJ1Zik7Cn0KCnN0YXRpYyBpbnQgY2hhckNvdW50KGNvbnN0IGNoYXJfdCogc3RyLCBjaGFyX3QgY2gpOwoKI2RlZmluZSBrTHQgJzwnCiNkZWZpbmUga0xlc3NUaGFuIFQoIiZsdDsiKQojZGVmaW5lIGtHdCAnPicKI2RlZmluZSBrR3JlYXRlclRoYW4gVCgiJmd0OyIpCgpzdGF0aWMgY2hhcl90KiB3ZWJzU2FmZVVybChjb25zdCBjaGFyX3QqIHVybCkKewoKICAgaW50IGx0Q291bnQgPSBjaGFyQ291bnQodXJsLCBrTHQpOwogICBpbnQgZ3RDb3VudCA9IGNoYXJDb3VudCh1cmwsIGtHdCk7CiAgIGludCBzYWZlTGVuID0gMDsKICAgY2hhcl90KiBzYWZlVXJsID0gTlVMTDsKICAgY2hhcl90KiBzcmMgPSBOVUxMOwogICBjaGFyX3QqIGRlc3QgPSBOVUxMOwoKICAgaWYgKE5VTEwgIT0gdXJsKQogICB7CiAgICAgIHNhZmVMZW4gPSBnc3RybGVuKHVybCk7CiAgICAgIGlmIChsdENvdW50ID09IDAgJiYgZ3RDb3VudCA9PSAwKQogICAgICB7CiAgICAgICAgIHNhZmVVcmwgPSBic3RyZHVwKEJfTCwgKGNoYXJfdCopIHVybCk7CiAgICAgIH0KICAgICAgZWxzZQogICAgICB7CiAgICAgICAgIHNhZmVMZW4gKz0gKGx0Q291bnQgKiA0KTsKICAgICAgICAgc2FmZUxlbiArPSAoZ3RDb3VudCAqIDQpOwoKICAgICAgICAgc2FmZVVybCA9IGJhbGxvYyhCX0wsIHNhZmVMZW4pOwogICAgICAgICBpZiAoc2FmZVVybCAhPSBOVUxMKQogICAgICAgICB7CiAgICAgICAgICAgIHNyYyA9IChjaGFyX3QqKSB1cmw7CiAgICAgICAgICAgIGRlc3QgPSBzYWZlVXJsOwogICAgICAgICAgICB3aGlsZSAoKnNyYykKICAgICAgICAgICAgewogICAgICAgICAgICAgICBpZiAoKnNyYyA9PSBrTHQpCiAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgZ3N0cmNweShkZXN0LCBrTGVzc1RoYW4pOwogICAgICAgICAgICAgICAgICBkZXN0ICs9IGdzdHJsZW4oa0xlc3NUaGFuKTsKICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICBlbHNlIGlmICgqc3JjID09IGtHdCkKICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICBnc3RyY3B5KGRlc3QsIGtHcmVhdGVyVGhhbik7CiAgICAgICAgICAgICAgICAgIGRlc3QgKz0gZ3N0cmxlbihrR3JlYXRlclRoYW4pOwogICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAqZGVzdCsrID0gKnNyYzsKICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICArK3NyYzsKICAgICAgICAgICAgfQogICAgICAgICAgICAvKiBkb24ndCBmb3JnZXQgdG8gdGVybWluYXRlIHRoZSBzdHJpbmcuLi4qLwogICAgICAgICAgICAqZGVzdCA9ICdcMCc7CiAgICAgICAgIH0KICAgICAgfQogICB9CiAgIHJldHVybiBzYWZlVXJsOwp9CgpzdGF0aWMgaW50IGNoYXJDb3VudChjb25zdCBjaGFyX3QqIHN0ciwgY2hhcl90IGNoKQp7CiAgIGludCBjb3VudCA9IDA7CiAgIGNoYXJfdCogcCA9IChjaGFyX3QqKSBzdHI7CiAgIAogICBpZiAoTlVMTCA9PSBzdHIpCiAgIHsKICAgICAgcmV0dXJuIDA7CiAgIH0KCiAgIHdoaWxlICgxKQogICB7CiAgICAgIHAgPSBnc3RyY2hyKHAsIGNoKTsKICAgICAgaWYgKE5VTEwgPT0gcCkKICAgICAgewogICAgICAgICBicmVhazsKICAgICAgfQoKICAgICAgKytjb3VudDsKICAgICAgKytwOwogICB9CiAgIHJldHVybiBjb3VudDsKfQoKCmNoYXJfdCAqd2Vic0Vycm9yTXNnKGludCBjb2RlKQp7Cgl3ZWJzRXJyb3JUeXBlCSplcDsKCglmb3IgKGVwID0gd2Vic0Vycm9yczsgZXAtPmNvZGU7IGVwKyspIHsKCQlpZiAoY29kZSA9PSBlcC0+Y29kZSkgewoJCQlyZXR1cm4gZXAtPm1zZzsKCQl9Cgl9CglhX2Fzc2VydCgwKTsKCXJldHVybiBUKCIiKTsKfQoKCiNpZmRlZiBxUmljaEVycm9yUGFnZQpleHRlcm4gaW50IGRtZlJpY2hFcnJvcih3ZWJzX3Qgd3AsIGludCBjb2RlLCBjaGFyX3QqIHVzZXJNc2cpOwojZW5kaWYKdm9pZCB3ZWJzRXJyb3Iod2Vic190IHdwLCBpbnQgY29kZSwgY2hhcl90ICpmbXQsIC4uLikKewoJdmFfbGlzdAkJYXJncyA9IHswfTsKCWNoYXJfdAkJKm1zZywgKnVzZXJNc2csICpidWY7CiAgIGNoYXJfdCogICAgIHNhZmVVcmwgPSBOVUxMOwogICBjaGFyX3QqICAgICBzYWZlTXNnID0gTlVMTDsKI2lmZGVmIHFSaWNoRXJyb3JQYWdlCiAgIHN0YXRpYyBpbnQgcmVFbnRyeSA9IDA7CiAgIGludCBlcnJvck9rOwojZW5kaWYKCglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCWFfYXNzZXJ0KGZtdCk7CgoJd2Vic1N0YXRzLmVycm9ycysrOwoKICAgc2FmZVVybCA9IHdlYnNTYWZlVXJsKHdwLT51cmwpOwogICBiZnJlZVNhZmUoQl9MLCB3cC0+dXJsKTsKICAgd3AtPnVybCA9IHNhZmVVcmw7CgoJdmFfc3RhcnQoYXJncywgZm10KTsKCXVzZXJNc2cgPSBOVUxMOwoJZm10VmFsbG9jKCZ1c2VyTXNnLCBXRUJTX0JVRlNJWkUsIGZtdCwgYXJncyk7Cgl2YV9lbmQoYXJncyk7CiAgIHNhZmVNc2cgPSB3ZWJzU2FmZVVybCh1c2VyTXNnKTsKICAgYmZyZWVTYWZlKEJfTCwgdXNlck1zZyk7CiAgIHVzZXJNc2cgPSBzYWZlTXNnOwogICBzYWZlTXNnICA9IE5VTEw7CgoKCiNpZmRlZiBxUmljaEVycm9yUGFnZQogICBpZiAoIXJlRW50cnkpCiAgIHsKCiAgICAgIHJlRW50cnkgPSAxOwogICAgICBlcnJvck9rID0gZG1mUmljaEVycm9yKHdwLCBjb2RlLCB1c2VyTXNnKTsKICAgICAgcmVFbnRyeSA9IDA7CiAgICAgIGlmIChlcnJvck9rKQogICAgICB7CiAgICAgICAgIGJmcmVlU2FmZShCX0wsIHVzZXJNc2cpOwogICAgICAgICByZXR1cm47CiAgICAgIH0KICAgICAgCiAgIH0KICAgCiNlbmRpZgoKLyoJbXNnID0gVCgiPGh0bWw+PGhlYWQ+PHRpdGxlPkRvY3VtZW50IEVycm9yOiAlczwvdGl0bGU+PC9oZWFkPlxyXG5cCgkJPGJvZHk+PGgyPkFjY2VzcyBFcnJvcjogJXM8L2gyPlxyXG5cCgkJPHA+JXM8L3A+PC9ib2R5PjwvaHRtbD5cclxuIik7Ki8KLy8ga3cgT1ZFUldSSVRFX0NPTlNUX0NIQVIKCglidWYgPSBOVUxMOwoJZm10QWxsb2MoJmJ1ZiwgV0VCU19CVUZTSVpFLCAiPGh0bWw+PGhlYWQ+PHRpdGxlPkRvY3VtZW50IEVycm9yOiAlczwvdGl0bGU+PC9oZWFkPlxyXG5cCgkJPGJvZHk+PGgyPkFjY2VzcyBFcnJvcjogJXM8L2gyPlxyXG5cCgkJPHA+JXM8L3A+PC9ib2R5PjwvaHRtbD5cclxuIiwgd2Vic0Vycm9yTXNnKGNvZGUpLCAKCQl3ZWJzRXJyb3JNc2coY29kZSksIHVzZXJNc2cpOwoKCXdlYnNSZXNwb25zZSh3cCwgY29kZSwgYnVmLCBOVUxMKTsKCWJmcmVlU2FmZShCX0wsIGJ1Zik7CgliZnJlZVNhZmUoQl9MLCB1c2VyTXNnKTsKfQoKCmludCB3ZWJzV3JpdGVCbG9jayh3ZWJzX3Qgd3AsIGNoYXJfdCAqYnVmLCBpbnQgbkNoYXJzKQp7CglpbnQJCWxlbiwgZG9uZTsKCWNoYXIJKmFzY2lpQnVmLCAqcEJ1ZjsKCglhX2Fzc2VydCh3cCk7CglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCWFfYXNzZXJ0KGJ1Zik7CglhX2Fzc2VydChuQ2hhcnMgPj0gMCk7CglpZih3cCA9PSBOVUxMKQoJCXJldHVybiAtMTsvL2ZvciBrdwoKCWRvbmUgPSBsZW4gPSAwOwoKCXBCdWYgPSBhc2NpaUJ1ZiA9IGJhbGxvY1VuaVRvQXNjKGJ1ZiwgbkNoYXJzKTsKCWlmKGFzY2lpQnVmID09IE5VTEwpCgkJcmV0dXJuIC0xOy8vZm9yIGt3CgoJd2hpbGUgKG5DaGFycyA+IDApIHsgIAojaWZkZWYgV0VCU19TU0xfU1VQUE9SVAoJCWlmICh3cC0+ZmxhZ3MgJiBXRUJTX1NFQ1VSRSkgewoJCQlpZiAoKGxlbiA9IHdlYnNTU0xXcml0ZSh3cC0+d3NwLCBwQnVmLCBuQ2hhcnMpKSA8IDApIHsKCQkJCWJmcmVlKEJfTCwgYXNjaWlCdWYpOwoJCQkJcmV0dXJuIC0xOwoJCQl9CgkJCXdlYnNTU0xGbHVzaCh3cC0+d3NwKTsKCQl9IGVsc2UgewoJCQlpZiAoKGxlbiA9IHNvY2tldFdyaXRlKHdwLT5zaWQsIHBCdWYsIG5DaGFycykpIDwgMCkgewoJCQkJYmZyZWUoQl9MLCBhc2NpaUJ1Zik7CgkJCQlyZXR1cm4gLTE7CgkJCX0KCQkJc29ja2V0Rmx1c2god3AtPnNpZCk7CgkJfQojZWxzZSAvKiAhIFdFQlNfU1NMX1NVUFBPUlQgKi8KCQlpZiAoKGxlbiA9IHNvY2tldFdyaXRlKHdwLT5zaWQsIHBCdWYsIG5DaGFycykpIDwgMCkgewoJCQliZnJlZShCX0wsIGFzY2lpQnVmKTsKCQkJcmV0dXJuIC0xOwoJCX0KCQlzb2NrZXRGbHVzaCh3cC0+c2lkKTsKI2VuZGlmIC8qIFdFQlNfU1NMX1NVUFBPUlQgKi8KCQluQ2hhcnMgLT0gbGVuOwoJCXBCdWYgKz0gbGVuOwoJCWRvbmUgKz0gbGVuOwoJfQoKCWJmcmVlKEJfTCwgYXNjaWlCdWYpOwoJcmV0dXJuIGRvbmU7Cn0KCmludCB3ZWJzV3JpdGUod2Vic190IHdwLCBjaGFyX3QgKmZtdCwgLi4uKQp7Cgl2YV9saXN0CQkgdmFyZ3MgPSB7MH07CgljaGFyX3QJCSpidWY7CglpbnQJCQkgcmM7CgkKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoKCXZhX3N0YXJ0KHZhcmdzLCBmbXQpOwoKCWJ1ZiA9IE5VTEw7CglyYyA9IDA7CgoJaWYgKGZtdFZhbGxvYygmYnVmLCBXRUJTX0JVRlNJWkUsIGZtdCwgdmFyZ3MpID49IFdFQlNfQlVGU0laRSkgewoJCXRyYWNlKDAsIFQoIndlYnM6IHdlYnNXcml0ZSBsb3N0IGRhdGEsIGJ1ZmZlciBvdmVyZmxvd1xuIikpOwoJfQogICAKCXZhX2VuZCh2YXJncyk7CglhX2Fzc2VydChidWYpOwoJaWYgKGJ1ZikgewoJCXJjID0gd2Vic1dyaXRlQmxvY2sod3AsIGJ1ZiwgZ3N0cmxlbihidWYpKTsKCQliZnJlZShCX0wsIGJ1Zik7Cgl9CglyZXR1cm4gcmM7Cn0KCgp2b2lkIHdlYnNEZWNvZGVVcmwoY2hhcl90ICpkZWNvZGVkLCBjaGFyX3QgKnRva2VuLCBpbnQgbGVuKQp7CgljaGFyX3QJKmlwLCAgKm9wOwoJaW50CQludW0sIGksIGM7CgkKCWFfYXNzZXJ0KGRlY29kZWQpOwoJYV9hc3NlcnQodG9rZW4pOwoKCW9wID0gZGVjb2RlZDsKCWZvciAoaXAgPSB0b2tlbjsgKmlwICYmIGxlbiA+IDA7IGlwKyssIG9wKyspIHsKCQlpZiAoKmlwID09ICcrJykgewoJCQkqb3AgPSAnICc7CgkJfSBlbHNlIGlmICgqaXAgPT0gJyUnICYmIGdpc3hkaWdpdChpcFsxXSkgJiYgZ2lzeGRpZ2l0KGlwWzJdKSkgewoKCQkJaXArKzsKCQkJZm9yIChpID0gMCwgbnVtID0gMDsgaSA8IDI7IGkrKywgaXArKykgewoJCQkJYyA9IHRvbG93ZXIoKmlwKTsKCQkJCWlmIChjID49ICdhJyAmJiBjIDw9ICdmJykgewoJCQkJCW51bSA9IChudW0gKiAxNikgKyAxMCArIGMgLSAnYSc7CgkJCQl9IGVsc2UgewoJCQkJCW51bSA9IChudW0gKiAxNikgKyBjIC0gJzAnOwoJCQkJfQoJCQl9CgkJCSpvcCA9IChjaGFyX3QpIG51bTsKCQkJaXAtLTsKCgkJfSBlbHNlIHsKCQkJKm9wID0gKmlwOwoJCX0KCQlsZW4tLTsKCX0KCSpvcCA9ICdcMCc7Cn0KCmludCB3ZWJzV3JpdGVEYXRhTm9uQmxvY2sod2Vic190IHdwLCBjaGFyICpidWYsIGludCBuQ2hhcnMpCnsKCWludCByOwoKCWFfYXNzZXJ0KHdwKTsKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoJYV9hc3NlcnQoYnVmKTsKCWFfYXNzZXJ0KG5DaGFycyA+PSAwKTsKCiNpZmRlZiBXRUJTX1NTTF9TVVBQT1JUCglpZiAod3AtPmZsYWdzICYgV0VCU19TRUNVUkUpIHsKCQlyID0gd2Vic1NTTFdyaXRlKHdwLT53c3AsIGJ1ZiwgbkNoYXJzKTsKCQl3ZWJzU1NMRmx1c2god3AtPndzcCk7Cgl9IGVsc2UgewoJCXIgPSBzb2NrZXRXcml0ZSh3cC0+c2lkLCBidWYsIG5DaGFycyk7CgkJc29ja2V0Rmx1c2god3AtPnNpZCk7Cgl9CiNlbHNlCglyID0gc29ja2V0V3JpdGUod3AtPnNpZCwgYnVmLCBuQ2hhcnMpOwoJc29ja2V0Rmx1c2god3AtPnNpZCk7CiNlbmRpZgoKCXJldHVybiByOwp9CgoKdm9pZCB3ZWJzVGltZW91dCh2b2lkICphcmcsIGludCBpZCkKewoJd2Vic190CQl3cDsKCWludAkJCWRlbGF5LCB0bTsKCgl3cCA9ICh3ZWJzX3QpIGFyZzsKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoKCXRtID0gd2Vic0dldFRpbWVTaW5jZU1hcmsod3ApICogMTAwMDsKCXRyYWNlKDgsIFQoIkBAd2Vic1RpbWVvdXQgJWQgaXA6JXMgdXJsOiVzXG4iKSx0bSx3cC0+aXBhZGRyLHdwLT51cmwpOwoJaWYgKHRtID49IFdFQlNfVElNRU9VVCkgewoJCXdlYnNTdGF0cy50aW1lb3V0cysrOwoJCWVtZlVuc2NoZWRDYWxsYmFjayhpZCk7CgoJCXdwLT50aW1lb3V0ID0gLTE7CgkJd2Vic0RvbmUod3AsIDQwNCk7Cgl9IGVsc2UgewoJCWRlbGF5ID0gV0VCU19USU1FT1VUIC0gdG07CgkJYV9hc3NlcnQoZGVsYXkgPiAwKTsKCQllbWZSZXNjaGVkQ2FsbGJhY2soaWQsIGRlbGF5KTsKCX0KfQoKdm9pZCB3ZWJzRG9uZSh3ZWJzX3Qgd3AsIGludCBjb2RlKQp7CglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCglzb2NrZXREZWxldGVIYW5kbGVyKHdwLT5zaWQpOwoKCWlmIChjb2RlICE9IDIwMCkgewoJCXdwLT5mbGFncyAmPSB+V0VCU19LRUVQX0FMSVZFOwoJfQoKCXdlYnNQYWdlQ2xvc2Uod3ApOwoKI2lmZGVmIFdFQlNfU1NMX1NVUFBPUlQKCWlmICh3cC0+ZmxhZ3MgJiBXRUJTX1NFQ1VSRSkgewoJCXdlYnNUaW1lb3V0Q2FuY2VsKHdwKTsKCQl3ZWJzU1NMRmx1c2god3AtPndzcCk7CgkJc29ja2V0Q2xvc2VDb25uZWN0aW9uKHdwLT5zaWQpOwoJCXdlYnNGcmVlKHdwKTsKCQlyZXR1cm47Cgl9CiNlbmRpZgoKCWlmICh3cC0+ZmxhZ3MgJiBXRUJTX0tFRVBfQUxJVkUpIHsKCQlpZiAoc29ja2V0Rmx1c2god3AtPnNpZCkgPT0gMCkgewoJCQl3cC0+c3RhdGUgPSBXRUJTX0JFR0lOOwoJCQl3cC0+ZmxhZ3MgfD0gV0VCU19SRVFVRVNUX0RPTkU7CgkJCWlmICh3cC0+aGVhZGVyLmJ1ZikgewoJCQkJcmluZ3FGbHVzaCgmd3AtPmhlYWRlcik7CgkJCX0KCQkJc29ja2V0Q3JlYXRlSGFuZGxlcih3cC0+c2lkLCBTT0NLRVRfUkVBREFCTEUsIHdlYnNTb2NrZXRFdmVudCwgCgkJCQkoaW50KSB3cCk7CgkJCXdlYnNUaW1lb3V0Q2FuY2VsKHdwKTsKCQkJd3AtPnRpbWVvdXQgPSBlbWZTY2hlZENhbGxiYWNrKFdFQlNfVElNRU9VVCwgd2Vic1RpbWVvdXQsCgkJCQkodm9pZCAqKSB3cCk7CgkJCXJldHVybjsKCQl9Cgl9IGVsc2UgewoJCXdlYnNUaW1lb3V0Q2FuY2VsKHdwKTsKCQlzb2NrZXRTZXRCbG9jayh3cC0+c2lkLCAxKTsKCQlzb2NrZXRGbHVzaCh3cC0+c2lkKTsKCQlzb2NrZXRDbG9zZUNvbm5lY3Rpb24od3AtPnNpZCk7Cgl9Cgl3ZWJzRnJlZSh3cCk7Cn0KCnZvaWQgd2Vic0ZyZWUod2Vic190IHdwKQp7CglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCglpZiAod3AtPnBhdGgpCgkJYmZyZWUoQl9MLCB3cC0+cGF0aCk7CglpZiAod3AtPnVybCkKCQliZnJlZShCX0wsIHdwLT51cmwpOwoJaWYgKHdwLT5ob3N0KQoJCWJmcmVlKEJfTCwgd3AtPmhvc3QpOwoJaWYgKHdwLT5scGF0aCkKCQliZnJlZShCX0wsIHdwLT5scGF0aCk7CglpZiAod3AtPnF1ZXJ5KQoJCWJmcmVlKEJfTCwgd3AtPnF1ZXJ5KTsKCWlmICh3cC0+ZGVjb2RlZFF1ZXJ5KQoJCWJmcmVlKEJfTCwgd3AtPmRlY29kZWRRdWVyeSk7CglpZiAod3AtPmF1dGhUeXBlKQoJCWJmcmVlKEJfTCwgd3AtPmF1dGhUeXBlKTsKCWlmICh3cC0+cGFzc3dvcmQpCgkJYmZyZWUoQl9MLCB3cC0+cGFzc3dvcmQpOwoJaWYgKHdwLT51c2VyTmFtZSkKCQliZnJlZShCX0wsIHdwLT51c2VyTmFtZSk7CglpZiAod3AtPmNvb2tpZSkKCQliZnJlZShCX0wsIHdwLT5jb29raWUpOwoJaWYgKHdwLT5yZWZlcmVyKQoJCWJmcmVlKEJfTCwgd3AtPnJlZmVyZXIpOwoJaWYgKHdwLT51c2VyQWdlbnQpCgkJYmZyZWUoQl9MLCB3cC0+dXNlckFnZW50KTsKCWlmICh3cC0+ZGlyKQoJCWJmcmVlKEJfTCwgd3AtPmRpcik7CglpZiAod3AtPnByb3RvY29sKQoJCWJmcmVlKEJfTCwgd3AtPnByb3RvY29sKTsKCWlmICh3cC0+cHJvdG9WZXJzaW9uKQoJCWJmcmVlKEJfTCwgd3AtPnByb3RvVmVyc2lvbik7CglpZiAod3AtPmNnaVN0ZGluKQoJCWJmcmVlKEJfTCwgd3AtPmNnaVN0ZGluKTsKCgojaWZkZWYgRElHRVNUX0FDQ0VTU19TVVBQT1JUCglpZiAod3AtPnJlYWxtKQoJCWJmcmVlKEJfTCwgd3AtPnJlYWxtKTsKCWlmICh3cC0+dXJpKQoJCWJmcmVlKEJfTCwgd3AtPnVyaSk7CglpZiAod3AtPmRpZ2VzdCkKCQliZnJlZShCX0wsIHdwLT5kaWdlc3QpOwoJaWYgKHdwLT5vcGFxdWUpCgkJYmZyZWUoQl9MLCB3cC0+b3BhcXVlKTsKCWlmICh3cC0+bm9uY2UpCgkJYmZyZWUoQl9MLCB3cC0+bm9uY2UpOwoJaWYgKHdwLT5uYykKCQliZnJlZShCX0wsIHdwLT5uYyk7CglpZiAod3AtPmNub25jZSkKCQliZnJlZShCX0wsIHdwLT5jbm9uY2UpOwoJaWYgKHdwLT5xb3ApCgkJYmZyZWUoQl9MLCB3cC0+cW9wKTsKI2VuZGlmCiNpZmRlZiBXRUJTX1NTTF9TVVBQT1JUCgl3ZWJzU1NMRnJlZSh3cC0+d3NwKTsKI2VuZGlmCglzeW1DbG9zZSh3cC0+Y2dpVmFycyk7CgoJaWYgKHdwLT5oZWFkZXIuYnVmKSB7CgkJcmluZ3FDbG9zZSgmd3AtPmhlYWRlcik7Cgl9CgoJd2Vic01heCA9IGhGcmVlKCh2b2lkKioqKSAmd2Vicywgd3AtPndpZCk7CgliZnJlZShCX0wsIHdwKTsKCWFfYXNzZXJ0KHdlYnNNYXggPj0gMCk7Cn0KCgppbnQgd2Vic0FsbG9jKGludCBzaWQpCnsKCXdlYnNfdAkJd3A7CglpbnQJCQl3aWQ7CgoJaWYgKCh3aWQgPSBoQWxsb2NFbnRyeSgodm9pZCoqKikgJndlYnMsICZ3ZWJzTWF4LAoJCQlzaXplb2Yoc3RydWN0IHdlYnNSZWMpKSkgPCAwKSB7CgkJcmV0dXJuIC0xOwoJfQoJd3AgPSB3ZWJzW3dpZF07CgoJd3AtPndpZCA9IHdpZDsKCXdwLT5zaWQgPSBzaWQ7Cgl3cC0+c3RhdGUgPSBXRUJTX0JFR0lOOwoJd3AtPmRvY2ZkID0gLTE7Cgl3cC0+dGltZW91dCA9IC0xOwoJd3AtPmRpciA9IE5VTEw7Cgl3cC0+YXV0aFR5cGUgPSBOVUxMOwoJd3AtPnByb3RvY29sID0gTlVMTDsKCXdwLT5wcm90b1ZlcnNpb24gPSBOVUxMOwoJd3AtPnBhc3N3b3JkID0gTlVMTDsKCXdwLT51c2VyTmFtZSA9IE5VTEw7Cgl3cC0+Y29va2llID0gTlVMTDsKCXdwLT5yZWZlcmVyID0gTlVMTDsKCXdwLT5oYXNfZmlybXdhcmVfdXBsb2FkX2NsZWFuID0gMDsKICAgIHdwLT5oYXNfZmlybXdhcmVfdXBsb2FkX3NoZWxsID0gMDsKI2lmZGVmIERJR0VTVF9BQ0NFU1NfU1VQUE9SVAoJd3AtPnJlYWxtID0gTlVMTDsKCXdwLT5ub25jZSA9IE5VTEw7Cgl3cC0+ZGlnZXN0ID0gTlVMTDsKCXdwLT51cmkgPSBOVUxMOwoJd3AtPm9wYXF1ZSA9IE5VTEw7Cgl3cC0+bmMgPSBOVUxMOwoJd3AtPmNub25jZSA9IE5VTEw7Cgl3cC0+cW9wID0gTlVMTDsKI2VuZGlmCiNpZmRlZiBXRUJTX1NTTF9TVVBQT1JUCgl3cC0+d3NwID0gTlVMTDsKI2VuZGlmCgoJcmluZ3FPcGVuKCZ3cC0+aGVhZGVyLCBXRUJTX0hFQURFUl9CVUZJTkMsIFdFQlNfTUFYX0hFQURFUik7CgoJd3AtPmNnaVZhcnMgPSBzeW1PcGVuKFdFQlNfU1lNX0lOSVQpOwoKCXJldHVybiB3aWQ7Cn0KCgpjaGFyX3QgKndlYnNHZXRJcGFkZHJVcmwoKQp7CglyZXR1cm4gd2Vic0lwYWRkclVybDsKfQoKCmNoYXJfdCAqd2Vic0dldEhvc3RVcmwoKQp7CglyZXR1cm4gd2Vic0hvc3RVcmw7Cn0KCgppbnQgd2Vic0dldFBvcnQoKQp7CglyZXR1cm4gd2Vic1BvcnQ7Cn0KCmNoYXJfdCAqd2Vic0dldEhvc3QoKQp7CglyZXR1cm4gd2Vic0hvc3Q7Cn0KCgppbnQgd2Vic0dldFJlcXVlc3RCeXRlcyh3ZWJzX3Qgd3ApCnsKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoKCXJldHVybiB3cC0+bnVtYnl0ZXM7Cn0KCgppbnQgd2Vic0dldFJlcXVlc3RGbGFncyh3ZWJzX3Qgd3ApCnsKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoKCXJldHVybiB3cC0+ZmxhZ3M7Cn0KCmNoYXJfdCAqd2Vic0dldFJlcXVlc3REaXIod2Vic190IHdwKQp7CglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCglpZiAod3AtPmRpciA9PSBOVUxMKSB7CgkJcmV0dXJuIFQoIiIpOwoJfQoKCXJldHVybiB3cC0+ZGlyOwp9CgoKaW50IHdlYnNHZXRTaWQod2Vic190IHdwKQp7CglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCglyZXR1cm4gd3AtPnNpZDsKfQoKCmNoYXJfdCAqd2Vic0dldFJlcXVlc3RJcGFkZHIod2Vic190IHdwKQp7CglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCXJldHVybiB3cC0+aXBhZGRyOwp9CgoKI2lmZGVmIEZFQVRVUkVfWlRFX1dFQl9UQ0FSRAovL2FkZGVkIGJ5IGd1byBzaG91cGVuZyAxMDEyNDIyNCBmb3IgaHR0cCBzaGFyZSAyMDExMTAwMSBzdGFydApjaGFyX3QgKiB3ZWJzR2V0VVJMKHdlYnNfdCB3cCkKewoJYV9hc3NlcnQod2Vic1ZhbGlkKHdwKSk7CgoJcmV0dXJuIHdwLT51cmw7Cn0KCmNoYXJfdCAqd2Vic0dldEZpbGVOYW1lKHdlYnNfdCB3cCkKewoJYV9hc3NlcnQod2Vic1ZhbGlkKHdwKSk7CgoJcmV0dXJuIHdwLT5jZ2lTdGRpbjsKfQoKCmludCB3ZWJzR2V0U3RhdGUod2Vic190IHdwKQp7CglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCglyZXR1cm4gd3AtPnN0YXRlOwp9CgppbnQgd2Vic0dldGxlbih3ZWJzX3Qgd3ApCnsKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoKCXJldHVybiB3cC0+Y2xlbjsKfQoKLy9hZGRlZCBieSBndW8gc2hvdXBlbmcgMTAxMjQyMjQgZm9yIGh0dHAgc2hhcmUgMjAxMTEwMDEgZW5kCiNlbmRpZgoKCmNoYXJfdCAqd2Vic0dldFJlcXVlc3RMcGF0aCh3ZWJzX3Qgd3ApCnsKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoKCXJldHVybiB3cC0+bHBhdGg7Cn0KCgpjaGFyX3QgKndlYnNHZXRSZXF1ZXN0UGFzc3dvcmQod2Vic190IHdwKQp7CglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCglyZXR1cm4gd3AtPnBhc3N3b3JkOwp9CgpjaGFyX3QgKndlYnNHZXRSZXF1ZXN0UGF0aCh3ZWJzX3Qgd3ApCnsKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoKCWlmICh3cC0+cGF0aCA9PSBOVUxMKSB7CgkJcmV0dXJuIFQoIiIpOwoJfQoKCXJldHVybiB3cC0+cGF0aDsKfQoKCmNoYXJfdCAqd2Vic0dldFJlcXVlc3RUeXBlKHdlYnNfdCB3cCkKewoJYV9hc3NlcnQod2Vic1ZhbGlkKHdwKSk7CgoJcmV0dXJuIHdwLT50eXBlOwp9CgoKaW50IHdlYnNHZXRSZXF1ZXN0V3JpdHRlbih3ZWJzX3Qgd3ApCnsKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoKCXJldHVybiB3cC0+d3JpdHRlbjsKfQoKCmNoYXJfdCAqd2Vic0dldFJlcXVlc3RVc2VyTmFtZSh3ZWJzX3Qgd3ApCnsKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoKCXJldHVybiB3cC0+dXNlck5hbWU7Cn0KCnZvaWQgd2Vic1NldEhvc3QoY2hhcl90ICpob3N0KQp7Cglnc3RybmNweSh3ZWJzSG9zdCwgaG9zdCwgVFNaKHdlYnNIb3N0KS0xKTsKfQoKCnZvaWQgd2Vic1NldElwYWRkcihjaGFyX3QgKmlwYWRkcikKewoJYV9hc3NlcnQoaXBhZGRyICYmICppcGFkZHIpOwoKCWdzdHJuY3B5KHdlYnNJcGFkZHIsIGlwYWRkciwgVFNaKHdlYnNJcGFkZHIpLTEpOwp9Cgp2b2lkIHdlYnNTZXRIb3N0VXJsKGNoYXJfdCAqdXJsKQp7CglhX2Fzc2VydCh1cmwgJiYgKnVybCk7CgoJYmZyZWVTYWZlKEJfTCwgd2Vic0hvc3RVcmwpOwoJd2Vic0hvc3RVcmwgPSBnc3RyZHVwKEJfTCwgdXJsKTsKfQoKCnZvaWQgd2Vic1NldFJlcXVlc3RCeXRlcyh3ZWJzX3Qgd3AsIGludCBieXRlcykKewoJYV9hc3NlcnQod2Vic1ZhbGlkKHdwKSk7CglhX2Fzc2VydChieXRlcyA+PSAwKTsKCgl3cC0+bnVtYnl0ZXMgPSBieXRlczsKfQoKCnZvaWQgd2Vic1NldFJlcXVlc3RMcGF0aCh3ZWJzX3Qgd3AsIGNoYXJfdCAqbHBhdGgpCnsKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoJYV9hc3NlcnQobHBhdGggJiYgKmxwYXRoKTsKCglpZiAod3AtPmxwYXRoKSB7CgkJYmZyZWUoQl9MLCB3cC0+bHBhdGgpOwoJfQoJd3AtPmxwYXRoID0gYnN0cmR1cChCX0wsIGxwYXRoKTsKCXdlYnNTZXRWYXIod3AsIFQoIlBBVEhfVFJBTlNMQVRFRCIpLCB3cC0+bHBhdGgpOwp9Cgp2b2lkIHdlYnNTZXRSZXF1ZXN0RmxhZ3Mod2Vic190IHdwLCBpbnQgZmxhZ3MpCnsKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoKCXdwLT5mbGFncyA9IGZsYWdzOwp9CgoKdm9pZCB3ZWJzU2V0UmVxdWVzdFBhdGgod2Vic190IHdwLCBjaGFyX3QgKmRpciwgY2hhcl90ICpwYXRoKQp7CgljaGFyX3QJKnRtcDsKCglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCglpZiAoZGlyKSB7IAoJCXRtcCA9IHdwLT5kaXI7CgkJd3AtPmRpciA9IGJzdHJkdXAoQl9MLCBkaXIpOwoJCWlmICh0bXApIHsKCQkJYmZyZWUoQl9MLCB0bXApOwoJCX0KCX0KCWlmIChwYXRoKSB7CgkJdG1wID0gd3AtPnBhdGg7CgkJd3AtPnBhdGggPSBic3RyZHVwKEJfTCwgcGF0aCk7CgkJd2Vic1NldFZhcih3cCwgVCgiUEFUSF9JTkZPIiksIHdwLT5wYXRoKTsKCQlpZiAodG1wKSB7CgkJCWJmcmVlKEJfTCwgdG1wKTsKCQl9Cgl9Cn0KCgp2b2lkIHdlYnNTZXRSZXF1ZXN0V3JpdHRlbih3ZWJzX3Qgd3AsIGludCB3cml0dGVuKQp7CglhX2Fzc2VydCh3ZWJzVmFsaWQod3ApKTsKCgl3cC0+d3JpdHRlbiA9IHdyaXR0ZW47Cn0KCgp2b2lkIHdlYnNTZXRSZXF1ZXN0U29ja2V0SGFuZGxlcih3ZWJzX3Qgd3AsIGludCBtYXNrLCB2b2lkICgqZm4pKHdlYnNfdCB3cCkpCnsKCWFfYXNzZXJ0KHdlYnNWYWxpZCh3cCkpOwoKCXdwLT53cml0ZVNvY2tldCA9IGZuOwoJc29ja2V0Q3JlYXRlSGFuZGxlcih3cC0+c2lkLCBTT0NLRVRfV1JJVEFCTEUsIHdlYnNTb2NrZXRFdmVudCwgKGludCkgd3ApOwp9CgoKY2hhcl90ICp3ZWJzR2V0RGF0ZVN0cmluZyh3ZWJzU3RhdFR5cGUgKnNidWYpCnsKCWNoYXJfdCoJY3AsICpyOwoJdGltZV90CW5vdzsKCglpZiAoc2J1ZiA9PSBOVUxMKSB7CgkJdGltZSgmbm93KTsKCX0gZWxzZSB7CgkJbm93ID0gc2J1Zi0+bXRpbWU7Cgl9CglpZiAoKGNwID0gZ2N0aW1lKCZub3cpKSAhPSBOVUxMKSB7CgkJY3BbZ3N0cmxlbihjcCkgLSAxXSA9ICdcMCc7CgkJciA9IGJzdHJkdXAoQl9MLCBjcCk7CgkJcmV0dXJuIHI7Cgl9CglyZXR1cm4gTlVMTDsKfQoKCmludCB3ZWJzVmFsaWQod2Vic190IHdwKQp7CglpbnQJCXdpZDsKCglmb3IgKHdpZCA9IDA7IHdpZCA8IHdlYnNNYXg7IHdpZCsrKSB7CgkJaWYgKHdwID09IHdlYnNbd2lkXSkgewoJCQlyZXR1cm4gMTsKCQl9Cgl9CglyZXR1cm4gMDsKfQoKCnZvaWQgd2Vic1NldFRpbWVNYXJrKHdlYnNfdCB3cCkKewoJd3AtPnRpbWVzdGFtcCA9IGdldF9zeXNfdXB0aW1lKCk7Cn0KCgp2b2lkIHdlYnNTZXRSZWFsbShjaGFyX3QgKnJlYWxtTmFtZSkKewoJYV9hc3NlcnQocmVhbG1OYW1lKTsKCglnc3RybmNweSh3ZWJzUmVhbG0sIHJlYWxtTmFtZSwgVFNaKHdlYnNSZWFsbSktMSk7Cn0KCgpjaGFyX3QgKndlYnNHZXRSZWFsbSgpCnsKCXJldHVybiB3ZWJzUmVhbG07Cn0KCgpzdGF0aWMgaW50IHdlYnNHZXRUaW1lU2luY2VNYXJrKHdlYnNfdCB3cCkKewoJcmV0dXJuIGdldF9zeXNfdXB0aW1lKCkgLSB3cC0+dGltZXN0YW1wOwp9Cgp2b2lkIHdlYnNTZXRMb2dpblRpbWVtYXJrKHdlYnNfdCB3cCkKewoKICAgIGNoYXJfdCBsb2dpbl90aW1lbWFya1s2NF0gPSB7MH07CiAgICBjaGFyX3QgbG9naW5faW5mb1syMF0gPSB7MH07CiAgICBjaGFyX3QgbnZfaXBhZGRyWzQwXSA9IHswfTsKICAgIGNoYXJfdCAqaXBfYWRkcmVzcyA9IE5VTEw7CiAgICB6dGVfdG9wc3dfc3RhdGVfZV90eXBlIHN0YXR1cyA9IFpURV9OVklPX01BWDsKICAgIGxvbmcgdGltZW1hcmsgPSAwOyAgICAKICAgIGNoYXJfdCB1c2VyX2xvZ2luX3RpbWVtYXJrWzY0XSA9IHswfTsKICAgIGxvbmcgdGltZW1hcmtfY2hlY2sgPSAwOwoJbG9uZyBsdXNlcl9sb2dpbl90aW1lbWFyayA9IDA7CgogIAogICAgc3RhdHVzID0genRlX3dlYl9yZWFkKE5WX0xPR0lORk8sIGxvZ2luX2luZm8pOwoKICAgIGlmKDAgPT0gc3RyY21wKGxvZ2luX2luZm8sIm9rIikpCiAgICB7CgogICAgICAgIHp0ZV93ZWJfcmVhZCgidXNlcl9sb2dpbl90aW1lbWFyayIsIHVzZXJfbG9naW5fdGltZW1hcmspOwoKICAgICAgICBsdXNlcl9sb2dpbl90aW1lbWFyayA9IGF0b2wodXNlcl9sb2dpbl90aW1lbWFyayk7CgkJaWYobHVzZXJfbG9naW5fdGltZW1hcmsgPCAwIHx8IGx1c2VyX2xvZ2luX3RpbWVtYXJrID4gTE9OR19NQVgtMSl7CiAgICAgICAgICAgIGx1c2VyX2xvZ2luX3RpbWVtYXJrID0gTE9OR19NQVg7CgkJfQoJCQogICAgICAgIHRpbWVtYXJrX2NoZWNrID0gdGltZSgwKSAtIGx1c2VyX2xvZ2luX3RpbWVtYXJrOyAgCiAgICAgICAgaWYodGltZW1hcmtfY2hlY2sgPiBMT0dJTl9USU1FT1VUKQogICAgICAgIHsKICAgICAgICAgICAgKHZvaWQpenRlX3dlYl93cml0ZShOVl9VU0VSX0lQX0FERFIsIiIpOwogICAgICAgICAgICAodm9pZCl6dGVfd2ViX3dyaXRlKE5WX0xPR0lORk8sInRpbWVvdXQiKTsKCQkJKHZvaWQpenRlX3dlYl93cml0ZShOVl9DT09LSUVfSUQsICIiKTsKICAgICAgICAgICAgKHZvaWQpenRlX3dlYl93cml0ZShOVl9VU0VSX0xPR0lOX1RJTUVNQVJLLCIwIik7CiAgICAgICAgICAgIHNsb2coTUlTQ19QUklOVCxTTE9HX0VSUiwibWdtdF9sb2dpbl90aW1lbWFya19jaGVjazogdGhlIGxvZ2luIGlzIHRpbWVvdXQgLlxuIik7CiAgICAgICAgfQogICAgICAgIGVsc2UKICAgICAgICB7CiAgICAgICAgICAgIGlwX2FkZHJlc3MgPSB3ZWJzR2V0UmVxdWVzdElwYWRkcih3cCk7CiNpZiAwCQkgLy8ga3cgMyBJTlZBUklBTlRfQ09ORElUSU9OLlVOUkVBQ0gJICB3cC0+aXBhZGRyIGlzIGFycmF5LCBhZGRyZXNzIGNhbiBub3QgYmUgbnVsbAogICAgICAgICAgICBpZiAoTlVMTCA9PSBpcF9hZGRyZXNzKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBzbG9nKE1JU0NfUFJJTlQsU0xPR19FUlIsIndlYnNTZXRMb2dpblRpbWVtYXJrOiBpcF9hZGRyZXNzIGlzIG51bGwuXG4iKTsKICAgICAgICAgICAgICAgIHJldHVybiA7CiAgICAgICAgICAgIH0KI2VuZGlmCiAgICAgICAgICAgIHp0ZV93ZWJfcmVhZChOVl9VU0VSX0lQX0FERFIsIG52X2lwYWRkcik7CiAgICAgICAgICAgCgogICAgICAgICAgICBpZiAoMCA9PSBzdHJjbXAoaXBfYWRkcmVzcyxudl9pcGFkZHIpKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICB0aW1lbWFyayA9IHRpbWUoMCk7CiAgICAgICAgICAgICAgICBzcHJpbnRmKGxvZ2luX3RpbWVtYXJrLCIlbGQiLHRpbWVtYXJrKTsgIAogICAgICAgICAgICAgICAgKHZvaWQpenRlX3dlYl93cml0ZShOVl9VU0VSX0xPR0lOX1RJTUVNQVJLLCBsb2dpbl90aW1lbWFyayk7CiAgICAgICAgICAgIH0KCiAgICAgICAgIH0KICAgIH0gIAoKfQoK