Lyogdmk6IHNldCBzdz00IHRzPTQ6ICovCi8qCiAqIE1pbmkgaW5zbW9kIGltcGxlbWVudGF0aW9uIGZvciBidXN5Ym94CiAqCiAqIENvcHlyaWdodCAoQykgMTk5OSwyMDAwIGJ5IExpbmVvLCBpbmMuCiAqIFdyaXR0ZW4gYnkgRXJpayBBbmRlcnNlbiA8YW5kZXJzZW5AbGluZW8uY29tPgogKiBhbmQgUm9uIEFsZGVyIDxhbGRlckBsaW5lby5jb20+CiAqCiAqIEJhc2VkIGFsbW9zdCBlbnRpcmVseSBvbiB0aGUgTGludXggbW9kdXRpbHMtMi4zLjExIGltcGxlbWVudGF0aW9uLgogKiAgIENvcHlyaWdodCAxOTk2LCAxOTk3IExpbnV4IEludGVybmF0aW9uYWwuCiAqICAgTmV3IGltcGxlbWVudGF0aW9uIGNvbnRyaWJ1dGVkIGJ5IFJpY2hhcmQgSGVuZGVyc29uIDxydGhAdGFtdS5lZHU+CiAqICAgQmFzZWQgb24gb3JpZ2luYWwgd29yayBieSBCam9ybiBFa3dhbGwgPGJqMHJuQGJsb3guc2U+CiAqICAgUmVzdHJ1Y3R1cmVkIChhbmQgcGFydGx5IHJld3JpdHRlbikgYnk6CiAqICAgQmr2cm4gRWt3YWxsIDxiajBybkBibG94LnNlPiBGZWJydWFyeSAxOTk5CiAqCiAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CiAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCiAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiAqCiAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAogKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgogKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VCiAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNyBVU0EKICoKICovCgojaW5jbHVkZSAiaW50ZXJuYWwuaCIKI2luY2x1ZGUgPHN0ZGxpYi5oPgojaW5jbHVkZSA8c3RkaW8uaD4KI2luY2x1ZGUgPHN0ZGRlZi5oPgojaW5jbHVkZSA8ZXJybm8uaD4KI2luY2x1ZGUgPHVuaXN0ZC5oPgojaW5jbHVkZSA8ZGlyZW50Lmg+CiNpbmNsdWRlIDxjdHlwZS5oPgojaW5jbHVkZSA8YXNzZXJ0Lmg+CiNpbmNsdWRlIDxzeXMvdXRzbmFtZS5oPgojaW5jbHVkZSA8c3lzL3N5c2NhbGwuaD4KCi8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQovLy0tLS0tLS0tbW9kdXRpbHMgbW9kdWxlLmgsIGxpbmVzIDQ1LTI0MgovLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCi8qIERlZmluaXRpb25zIGZvciB0aGUgTGludXggbW9kdWxlIHN5c2NhbGwgaW50ZXJmYWNlLgogICBDb3B5cmlnaHQgMTk5NiwgMTk5NyBMaW51eCBJbnRlcm5hdGlvbmFsLgoKICAgQ29udHJpYnV0ZWQgYnkgUmljaGFyZCBIZW5kZXJzb24gPHJ0aEB0YW11LmVkdT4KCiAgIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBMaW51eCBtb2R1dGlscy4KCiAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CiAgIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZQogICBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyCiAgIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCgogICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CiAgIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKICAgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgoKICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKICAgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4gICovCgoKI2lmbmRlZiBNT0RVVElMU19NT0RVTEVfSAojZGVmaW5lIE1PRFVUSUxTX01PRFVMRV9IIDEKCiNpZGVudCAiJElkOiBpbnNtb2QuYyx2IDEuOCAyMDAwLzA2LzEyIDIzOjExOjE2IGFuZGVyc2VuIEV4cCAkIgoKLyogVGhpcyBmaWxlIGNvbnRhaW5zIHRoZSBzdHJ1Y3R1cmVzIHVzZWQgYnkgdGhlIDIuMCBhbmQgMi4xIGtlcm5lbHMuCiAgIFdlIGRvIG5vdCB1c2UgdGhlIGtlcm5lbCBoZWFkZXJzIGRpcmVjdGx5IGJlY2F1c2Ugd2UgZG8gbm90IHdpc2gKICAgdG8gYmUgZGVwZW5kYW50IG9uIGEgcGFydGljdWxhciBrZXJuZWwgdmVyc2lvbiB0byBjb21waWxlIGluc21vZC4gICovCgoKLyo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ki8KLyogVGhlIHN0cnVjdHVyZXMgdXNlZCBieSBMaW51eCAyLjAuICAqLwoKLyogVGhlIHN5bWJvbCBmb3JtYXQgdXNlZCBieSBnZXRfa2VybmVsX3N5bXMoMikuICAqLwpzdHJ1Y3Qgb2xkX2tlcm5lbF9zeW0KewogIHVuc2lnbmVkIGxvbmcgdmFsdWU7CiAgY2hhciBuYW1lWzYwXTsKfTsKCnN0cnVjdCBvbGRfbW9kdWxlX3JlZgp7CiAgdW5zaWduZWQgbG9uZyBtb2R1bGU7CQkvKiBrZXJuZWwgYWRkcmVzc2VzICovCiAgdW5zaWduZWQgbG9uZyBuZXh0Owp9OwoKc3RydWN0IG9sZF9tb2R1bGVfc3ltYm9sCnsKICB1bnNpZ25lZCBsb25nIGFkZHI7CiAgdW5zaWduZWQgbG9uZyBuYW1lOwp9OwoKc3RydWN0IG9sZF9zeW1ib2xfdGFibGUKewogIGludCBzaXplOwkJCS8qIHRvdGFsLCBpbmNsdWRpbmcgc3RyaW5nIHRhYmxlISEhICovCiAgaW50IG5fc3ltYm9sczsKICBpbnQgbl9yZWZzOwogIHN0cnVjdCBvbGRfbW9kdWxlX3N5bWJvbCBzeW1ib2xbMF07IC8qIGFjdHVhbCBzaXplIGRlZmluZWQgYnkgbl9zeW1ib2xzICovCiAgc3RydWN0IG9sZF9tb2R1bGVfcmVmIHJlZlswXTsJLyogYWN0dWFsIHNpemUgZGVmaW5lZCBieSBuX3JlZnMgKi8KfTsKCnN0cnVjdCBvbGRfbW9kX3JvdXRpbmVzCnsKICB1bnNpZ25lZCBsb25nIGluaXQ7CiAgdW5zaWduZWQgbG9uZyBjbGVhbnVwOwp9OwoKc3RydWN0IG9sZF9tb2R1bGUKewogIHVuc2lnbmVkIGxvbmcgbmV4dDsKICB1bnNpZ25lZCBsb25nIHJlZjsJCS8qIHRoZSBsaXN0IG9mIG1vZHVsZXMgdGhhdCByZWZlciB0byBtZSAqLwogIHVuc2lnbmVkIGxvbmcgc3ltdGFiOwogIHVuc2lnbmVkIGxvbmcgbmFtZTsKICBpbnQgc2l6ZTsJCQkvKiBzaXplIG9mIG1vZHVsZSBpbiBwYWdlcyAqLwogIHVuc2lnbmVkIGxvbmcgYWRkcjsJCS8qIGFkZHJlc3Mgb2YgbW9kdWxlICovCiAgaW50IHN0YXRlOwogIHVuc2lnbmVkIGxvbmcgY2xlYW51cDsJLyogY2xlYW51cCByb3V0aW5lICovCn07CgovKiBTZW50IHRvIGluaXRfbW9kdWxlKDIpIG9yJ2VkIGludG8gdGhlIGNvZGUgc2l6ZSBwYXJhbWV0ZXIuICAqLwojZGVmaW5lIE9MRF9NT0RfQVVUT0NMRUFOIDB4NDAwMDAwMDAgLyogYmlnIGVub3VnaCwgYnV0IG5vIHNpZ24gcHJvYmxlbXMuLi4gKi8KCmludCBnZXRfa2VybmVsX3N5bXMoc3RydWN0IG9sZF9rZXJuZWxfc3ltICopOwppbnQgb2xkX3N5c19pbml0X21vZHVsZShjb25zdCBjaGFyICpuYW1lLCBjaGFyICpjb2RlLCB1bnNpZ25lZCBjb2Rlc2l6ZSwKCQkJc3RydWN0IG9sZF9tb2Rfcm91dGluZXMgKiwgc3RydWN0IG9sZF9zeW1ib2xfdGFibGUgKik7CgovKj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0qLwovKiBGb3Igc2l6ZW9mKCkgd2hpY2ggYXJlIHJlbGF0ZWQgdG8gdGhlIG1vZHVsZSBwbGF0Zm9ybSBhbmQgbm90IHRvIHRoZQogICBlbnZpcm9ubWVudCBpc25tb2QgaXMgcnVubmluZyBpbiwgdXNlIHNpemVvZl94eCBpbnN0ZWFkIG9mIHNpemVvZih4eCkuICAqLwoKI2RlZmluZSB0Z3Rfc2l6ZW9mX2NoYXIJCXNpemVvZihjaGFyKQojZGVmaW5lIHRndF9zaXplb2Zfc2hvcnQJc2l6ZW9mKHNob3J0KQojZGVmaW5lIHRndF9zaXplb2ZfaW50CQlzaXplb2YoaW50KQojZGVmaW5lIHRndF9zaXplb2ZfbG9uZwkJc2l6ZW9mKGxvbmcpCiNkZWZpbmUgdGd0X3NpemVvZl9jaGFyX3AJc2l6ZW9mKGNoYXIgKikKI2RlZmluZSB0Z3Rfc2l6ZW9mX3ZvaWRfcAlzaXplb2Yodm9pZCAqKQojZGVmaW5lIHRndF9sb25nCQlsb25nCgojaWYgZGVmaW5lZChfX3NwYXJjX18pICYmICFkZWZpbmVkKF9fc3BhcmNfdjlfXykgJiYgZGVmaW5lZChBUkNIX3NwYXJjNjQpCiN1bmRlZiB0Z3Rfc2l6ZW9mX2xvbmcKI3VuZGVmIHRndF9zaXplb2ZfY2hhcl9wCiN1bmRlZiB0Z3Rfc2l6ZW9mX3ZvaWRfcAojdW5kZWYgdGd0X2xvbmcKI2RlZmluZSB0Z3Rfc2l6ZW9mX2xvbmcJCTgKI2RlZmluZSB0Z3Rfc2l6ZW9mX2NoYXJfcAk4CiNkZWZpbmUgdGd0X3NpemVvZl92b2lkX3AJOAojZGVmaW5lIHRndF9sb25nCQlsb25nIGxvbmcKI2VuZGlmCgovKj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0qLwovKiBUaGUgc3RydWN0dXJlcyB1c2VkIGluIExpbnV4IDIuMS4gICovCgovKiBOb3RlOiBuZXdfbW9kdWxlX3N5bWJvbCBkb2VzIG5vdCB1c2UgdGd0X2xvbmcgaW50ZW50aW9uYWxseSAqLwpzdHJ1Y3QgbmV3X21vZHVsZV9zeW1ib2wKewogIHVuc2lnbmVkIGxvbmcgdmFsdWU7CiAgdW5zaWduZWQgbG9uZyBuYW1lOwp9OwoKc3RydWN0IG5ld19tb2R1bGVfcGVyc2lzdDsKCnN0cnVjdCBuZXdfbW9kdWxlX3JlZgp7CiAgdW5zaWduZWQgdGd0X2xvbmcgZGVwOwkJLyoga2VybmVsIGFkZHJlc3NlcyAqLwogIHVuc2lnbmVkIHRndF9sb25nIHJlZjsKICB1bnNpZ25lZCB0Z3RfbG9uZyBuZXh0X3JlZjsKfTsKCnN0cnVjdCBuZXdfbW9kdWxlCnsKICB1bnNpZ25lZCB0Z3RfbG9uZyBzaXplX29mX3N0cnVjdDsJLyogPT0gc2l6ZW9mKG1vZHVsZSkgKi8KICB1bnNpZ25lZCB0Z3RfbG9uZyBuZXh0OwogIHVuc2lnbmVkIHRndF9sb25nIG5hbWU7CiAgdW5zaWduZWQgdGd0X2xvbmcgc2l6ZTsKCiAgdGd0X2xvbmcgdXNlY291bnQ7CiAgdW5zaWduZWQgdGd0X2xvbmcgZmxhZ3M7CQkvKiBBVVRPQ0xFQU4gZXQgYWwgKi8KCiAgdW5zaWduZWQgbnN5bXM7CiAgdW5zaWduZWQgbmRlcHM7CgogIHVuc2lnbmVkIHRndF9sb25nIHN5bXM7CiAgdW5zaWduZWQgdGd0X2xvbmcgZGVwczsKICB1bnNpZ25lZCB0Z3RfbG9uZyByZWZzOwogIHVuc2lnbmVkIHRndF9sb25nIGluaXQ7CiAgdW5zaWduZWQgdGd0X2xvbmcgY2xlYW51cDsKICB1bnNpZ25lZCB0Z3RfbG9uZyBleF90YWJsZV9zdGFydDsKICB1bnNpZ25lZCB0Z3RfbG9uZyBleF90YWJsZV9lbmQ7CiNpZmRlZiBfX2FscGhhX18KICB1bnNpZ25lZCB0Z3RfbG9uZyBncDsKI2VuZGlmCiAgLyogRXZlcnl0aGluZyBhZnRlciBoZXJlIGlzIGV4dGVuc2lvbi4gICovCiAgdW5zaWduZWQgdGd0X2xvbmcgcGVyc2lzdF9zdGFydDsKICB1bnNpZ25lZCB0Z3RfbG9uZyBwZXJzaXN0X2VuZDsKICB1bnNpZ25lZCB0Z3RfbG9uZyBjYW5fdW5sb2FkOwogIHVuc2lnbmVkIHRndF9sb25nIHJ1bnNpemU7Cn07CgpzdHJ1Y3QgbmV3X21vZHVsZV9pbmZvCnsKICB1bnNpZ25lZCBsb25nIGFkZHI7CiAgdW5zaWduZWQgbG9uZyBzaXplOwogIHVuc2lnbmVkIGxvbmcgZmxhZ3M7CgkgICBsb25nIHVzZWNvdW50Owp9OwoKLyogQml0cyBvZiBtb2R1bGUuZmxhZ3MuICAqLwojZGVmaW5lIE5FV19NT0RfUlVOTklORwkJMQojZGVmaW5lIE5FV19NT0RfREVMRVRFRAkJMgojZGVmaW5lIE5FV19NT0RfQVVUT0NMRUFOCTQKI2RlZmluZSBORVdfTU9EX1ZJU0lURUQJCTgKI2RlZmluZSBORVdfTU9EX1VTRURfT05DRQkxNgoKaW50IG5ld19zeXNfaW5pdF9tb2R1bGUoY29uc3QgY2hhciAqbmFtZSwgY29uc3Qgc3RydWN0IG5ld19tb2R1bGUgKik7CmludCBxdWVyeV9tb2R1bGUoY29uc3QgY2hhciAqbmFtZSwgaW50IHdoaWNoLCB2b2lkICpidWYsIHNpemVfdCBidWZzaXplLAoJCSBzaXplX3QgKnJldCk7CgovKiBWYWx1ZXMgZm9yIHF1ZXJ5X21vZHVsZSdzIHdoaWNoLiAgKi8KCiNkZWZpbmUgUU1fTU9EVUxFUwkxCiNkZWZpbmUgUU1fREVQUwkJMgojZGVmaW5lIFFNX1JFRlMJCTMKI2RlZmluZSBRTV9TWU1CT0xTCTQKI2RlZmluZSBRTV9JTkZPCQk1CgovKj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0qLwovKiBUaGUgc3lzdGVtIGNhbGxzIHVuY2hhbmdlZCBiZXR3ZWVuIDIuMCBhbmQgMi4xLiAgKi8KCnVuc2lnbmVkIGxvbmcgY3JlYXRlX21vZHVsZShjb25zdCBjaGFyICosIHNpemVfdCk7CmludCBkZWxldGVfbW9kdWxlKGNvbnN0IGNoYXIgKik7CgoKI2VuZGlmIC8qIG1vZHVsZS5oICovCgovLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLy8tLS0tLS0tLWVuZCBvZiBtb2R1dGlscyBtb2R1bGUuaAovLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCgoKLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi8vLS0tLS0tLS1tb2R1dGlscyBvYmouaCwgbGluZXMgMjUzLTQ2MgovLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCi8qIEVsZiBvYmplY3QgZmlsZSBsb2FkaW5nIGFuZCByZWxvY2F0aW9uIHJvdXRpbmVzLgogICBDb3B5cmlnaHQgMTk5NiwgMTk5NyBMaW51eCBJbnRlcm5hdGlvbmFsLgoKICAgQ29udHJpYnV0ZWQgYnkgUmljaGFyZCBIZW5kZXJzb24gPHJ0aEB0YW11LmVkdT4KCiAgIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBMaW51eCBtb2R1dGlscy4KCiAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CiAgIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZQogICBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyCiAgIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCgogICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CiAgIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKICAgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgoKICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKICAgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4gICovCgoKI2lmbmRlZiBNT0RVVElMU19PQkpfSAojZGVmaW5lIE1PRFVUSUxTX09CSl9IIDEKCiNpZGVudCAiJElkOiBpbnNtb2QuYyx2IDEuOCAyMDAwLzA2LzEyIDIzOjExOjE2IGFuZGVyc2VuIEV4cCAkIgoKLyogVGhlIHJlbG9jYXRhYmxlIG9iamVjdCBpcyBtYW5pcHVsYXRlZCB1c2luZyBlbGZpbiB0eXBlcy4gICovCgojaW5jbHVkZSA8c3RkaW8uaD4KI2luY2x1ZGUgPGVsZi5oPgoKCi8qIE1hY2hpbmUtc3BlY2lmaWMgZWxmIG1hY3JvcyBmb3IgaTM4NiBldCBhbC4gICovCgojZGVmaW5lIEVMRkNMQVNTTQlFTEZDTEFTUzMyCiNkZWZpbmUgRUxGREFUQU0JRUxGREFUQTJMU0IKCiNkZWZpbmUgTUFUQ0hfTUFDSElORSh4KSAgKHggPT0gRU1fMzg2IHx8IHggPT0gRU1fNDg2KQoKI2RlZmluZSBTSFRfUkVMTQlTSFRfUkVMCiNkZWZpbmUgRWxmMzJfUmVsTQlFbGYzMl9SZWwKCgojaWZuZGVmIEVsZlcKIyBpZiBFTEZDTEFTU00gPT0gRUxGQ0xBU1MzMgojICBkZWZpbmUgRWxmVyh4KSAgRWxmMzJfICMjIHgKIyAgZGVmaW5lIEVMRlcoeCkgIEVMRjMyXyAjIyB4CiMgZWxzZQojICBkZWZpbmUgRWxmVyh4KSAgRWxmNjRfICMjIHgKIyAgZGVmaW5lIEVMRlcoeCkgIEVMRjY0XyAjIyB4CiMgZW5kaWYKI2VuZGlmCgovKiBGb3Igc29tZSByZWFzb24gdGhpcyBpcyBtaXNzaW5nIGZyb20gbGliYzUuICAqLwojaWZuZGVmIEVMRjMyX1NUX0lORk8KIyBkZWZpbmUgRUxGMzJfU1RfSU5GTyhiaW5kLCB0eXBlKSAgICAgICAoKChiaW5kKSA8PCA0KSArICgodHlwZSkgJiAweGYpKQojZW5kaWYKCiNpZm5kZWYgRUxGNjRfU1RfSU5GTwojIGRlZmluZSBFTEY2NF9TVF9JTkZPKGJpbmQsIHR5cGUpICAgICAgICgoKGJpbmQpIDw8IDQpICsgKCh0eXBlKSAmIDB4ZikpCiNlbmRpZgoKc3RydWN0IG9ial9zdHJpbmdfcGF0Y2g7CnN0cnVjdCBvYmpfc3ltYm9sX3BhdGNoOwoKc3RydWN0IG9ial9zZWN0aW9uCnsKICBFbGZXKFNoZHIpIGhlYWRlcjsKICBjb25zdCBjaGFyICpuYW1lOwogIGNoYXIgKmNvbnRlbnRzOwogIHN0cnVjdCBvYmpfc2VjdGlvbiAqbG9hZF9uZXh0OwogIGludCBpZHg7Cn07CgpzdHJ1Y3Qgb2JqX3N5bWJvbAp7CiAgc3RydWN0IG9ial9zeW1ib2wgKm5leHQ7CS8qIGhhc2ggdGFibGUgbGluayAqLwogIGNvbnN0IGNoYXIgKm5hbWU7CiAgdW5zaWduZWQgbG9uZyB2YWx1ZTsKICB1bnNpZ25lZCBsb25nIHNpemU7CiAgaW50IHNlY2lkeDsJCQkvKiB0aGUgZGVmaW5pbmcgc2VjdGlvbiBpbmRleC9tb2R1bGUgKi8KICBpbnQgaW5mbzsKICBpbnQga3N5bWlkeDsJCQkvKiBmb3IgZXhwb3J0IHRvIHRoZSBrZXJuZWwgc3ltdGFiICovCiAgaW50IHJlZmVyZW5jZWQ7CQkvKiBhY3R1YWxseSB1c2VkIGluIHRoZSBsaW5rICovCn07CgovKiBIYXJkY29kZSB0aGUgaGFzaCB0YWJsZSBzaXplLiAgV2Ugc2hvdWxkbid0IGJlIG5lZWRpbmcgc28gbWFueQogICBzeW1ib2xzIHRoYXQgd2UgYmVnaW4gdG8gZGVncmFkZSBwZXJmb3JtYW5jZSwgYW5kIHdlIGdldCBhIGJpZyB3aW4KICAgYnkgZ2l2aW5nIHRoZSBjb21waWxlciBhIGNvbnN0YW50IGRpdmlzb3IuICAqLwoKI2RlZmluZSBIQVNIX0JVQ0tFVFMgIDUyMQoKc3RydWN0IG9ial9maWxlCnsKICBFbGZXKEVoZHIpIGhlYWRlcjsKICBFbGZXKEFkZHIpIGJhc2VhZGRyOwogIHN0cnVjdCBvYmpfc2VjdGlvbiAqKnNlY3Rpb25zOwogIHN0cnVjdCBvYmpfc2VjdGlvbiAqbG9hZF9vcmRlcjsKICBzdHJ1Y3Qgb2JqX3NlY3Rpb24gKipsb2FkX29yZGVyX3NlYXJjaF9zdGFydDsKICBzdHJ1Y3Qgb2JqX3N0cmluZ19wYXRjaCAqc3RyaW5nX3BhdGNoZXM7CiAgc3RydWN0IG9ial9zeW1ib2xfcGF0Y2ggKnN5bWJvbF9wYXRjaGVzOwogIGludCAoKnN5bWJvbF9jbXApKGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqKTsKICB1bnNpZ25lZCBsb25nICgqc3ltYm9sX2hhc2gpKGNvbnN0IGNoYXIgKik7CiAgdW5zaWduZWQgbG9uZyBsb2NhbF9zeW10YWJfc2l6ZTsKICBzdHJ1Y3Qgb2JqX3N5bWJvbCAqKmxvY2FsX3N5bXRhYjsKICBzdHJ1Y3Qgb2JqX3N5bWJvbCAqc3ltdGFiW0hBU0hfQlVDS0VUU107Cn07CgplbnVtIG9ial9yZWxvYwp7CiAgb2JqX3JlbG9jX29rLAogIG9ial9yZWxvY19vdmVyZmxvdywKICBvYmpfcmVsb2NfZGFuZ2Vyb3VzLAogIG9ial9yZWxvY191bmhhbmRsZWQKfTsKCnN0cnVjdCBvYmpfc3RyaW5nX3BhdGNoCnsKICBzdHJ1Y3Qgb2JqX3N0cmluZ19wYXRjaCAqbmV4dDsKICBpbnQgcmVsb2Nfc2VjaWR4OwogIEVsZlcoQWRkcikgcmVsb2Nfb2Zmc2V0OwogIEVsZlcoQWRkcikgc3RyaW5nX29mZnNldDsKfTsKCnN0cnVjdCBvYmpfc3ltYm9sX3BhdGNoCnsKICBzdHJ1Y3Qgb2JqX3N5bWJvbF9wYXRjaCAqbmV4dDsKICBpbnQgcmVsb2Nfc2VjaWR4OwogIEVsZlcoQWRkcikgcmVsb2Nfb2Zmc2V0OwogIHN0cnVjdCBvYmpfc3ltYm9sICpzeW07Cn07CgoKLyogR2VuZXJpYyBvYmplY3QgbWFuaXB1bGF0aW9uIHJvdXRpbmVzLiAgKi8KCnVuc2lnbmVkIGxvbmcgb2JqX2VsZl9oYXNoKGNvbnN0IGNoYXIgKik7Cgp1bnNpZ25lZCBsb25nIG9ial9lbGZfaGFzaF9uKGNvbnN0IGNoYXIgKiwgdW5zaWduZWQgbG9uZyBsZW4pOwoKc3RydWN0IG9ial9zeW1ib2wgKm9ial9hZGRfc3ltYm9sIChzdHJ1Y3Qgb2JqX2ZpbGUgKmYsIGNvbnN0IGNoYXIgKm5hbWUsCgkJCQkgICB1bnNpZ25lZCBsb25nIHN5bWlkeCwgaW50IGluZm8sIGludCBzZWNpZHgsCgkJCQkgICBFbGZXKEFkZHIpIHZhbHVlLCB1bnNpZ25lZCBsb25nIHNpemUpOwoKc3RydWN0IG9ial9zeW1ib2wgKm9ial9maW5kX3N5bWJvbCAoc3RydWN0IG9ial9maWxlICpmLAoJCQkJCSBjb25zdCBjaGFyICpuYW1lKTsKCkVsZlcoQWRkcikgb2JqX3N5bWJvbF9maW5hbF92YWx1ZShzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJCQkgIHN0cnVjdCBvYmpfc3ltYm9sICpzeW0pOwoKdm9pZCBvYmpfc2V0X3N5bWJvbF9jb21wYXJlKHN0cnVjdCBvYmpfZmlsZSAqZiwKCQkJICAgIGludCAoKmNtcCkoY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICopLAoJCQkgICAgdW5zaWduZWQgbG9uZyAoKmhhc2gpKGNvbnN0IGNoYXIgKikpOwoKc3RydWN0IG9ial9zZWN0aW9uICpvYmpfZmluZF9zZWN0aW9uIChzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJCQkJICAgY29uc3QgY2hhciAqbmFtZSk7Cgp2b2lkIG9ial9pbnNlcnRfc2VjdGlvbl9sb2FkX29yZGVyIChzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJCQkgICAgc3RydWN0IG9ial9zZWN0aW9uICpzZWMpOwoKc3RydWN0IG9ial9zZWN0aW9uICpvYmpfY3JlYXRlX2FsbG9jZWRfc2VjdGlvbiAoc3RydWN0IG9ial9maWxlICpmLAoJCQkJCQljb25zdCBjaGFyICpuYW1lLAoJCQkJCQl1bnNpZ25lZCBsb25nIGFsaWduLAoJCQkJCQl1bnNpZ25lZCBsb25nIHNpemUpOwoKc3RydWN0IG9ial9zZWN0aW9uICpvYmpfY3JlYXRlX2FsbG9jZWRfc2VjdGlvbl9maXJzdCAoc3RydWN0IG9ial9maWxlICpmLAoJCQkJCQkgICAgICBjb25zdCBjaGFyICpuYW1lLAoJCQkJCQkgICAgICB1bnNpZ25lZCBsb25nIGFsaWduLAoJCQkJCQkgICAgICB1bnNpZ25lZCBsb25nIHNpemUpOwoKdm9pZCAqb2JqX2V4dGVuZF9zZWN0aW9uIChzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnNlYywgdW5zaWduZWQgbG9uZyBtb3JlKTsKCmludCBvYmpfc3RyaW5nX3BhdGNoKHN0cnVjdCBvYmpfZmlsZSAqZiwgaW50IHNlY2lkeCwgRWxmVyhBZGRyKSBvZmZzZXQsCgkJICAgICBjb25zdCBjaGFyICpzdHJpbmcpOwoKaW50IG9ial9zeW1ib2xfcGF0Y2goc3RydWN0IG9ial9maWxlICpmLCBpbnQgc2VjaWR4LCBFbGZXKEFkZHIpIG9mZnNldCwKCQkgICAgIHN0cnVjdCBvYmpfc3ltYm9sICpzeW0pOwoKaW50IG9ial9jaGVja191bmRlZmluZWRzKHN0cnVjdCBvYmpfZmlsZSAqZik7Cgp2b2lkIG9ial9hbGxvY2F0ZV9jb21tb25zKHN0cnVjdCBvYmpfZmlsZSAqZik7Cgp1bnNpZ25lZCBsb25nIG9ial9sb2FkX3NpemUgKHN0cnVjdCBvYmpfZmlsZSAqZik7CgppbnQgb2JqX3JlbG9jYXRlIChzdHJ1Y3Qgb2JqX2ZpbGUgKmYsIEVsZlcoQWRkcikgYmFzZSk7CgpzdHJ1Y3Qgb2JqX2ZpbGUgKm9ial9sb2FkKEZJTEUgKmYpOwoKaW50IG9ial9jcmVhdGVfaW1hZ2UgKHN0cnVjdCBvYmpfZmlsZSAqZiwgY2hhciAqaW1hZ2UpOwoKLyogQXJjaGl0ZWN0dXJlIHNwZWNpZmljIG1hbmlwdWxhdGlvbiByb3V0aW5lcy4gICovCgpzdHJ1Y3Qgb2JqX2ZpbGUgKmFyY2hfbmV3X2ZpbGUgKHZvaWQpOwoKc3RydWN0IG9ial9zZWN0aW9uICphcmNoX25ld19zZWN0aW9uICh2b2lkKTsKCnN0cnVjdCBvYmpfc3ltYm9sICphcmNoX25ld19zeW1ib2wgKHZvaWQpOwoKZW51bSBvYmpfcmVsb2MgYXJjaF9hcHBseV9yZWxvY2F0aW9uIChzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJCQkgICAgICBzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnRhcmdzZWMsCgkJCQkgICAgICBzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnN5bXNlYywKCQkJCSAgICAgIHN0cnVjdCBvYmpfc3ltYm9sICpzeW0sCgkJCQkgICAgICBFbGZXKFJlbE0pICpyZWwsIEVsZlcoQWRkcikgdmFsdWUpOwoKaW50IGFyY2hfY3JlYXRlX2dvdCAoc3RydWN0IG9ial9maWxlICpmKTsKCnN0cnVjdCBuZXdfbW9kdWxlOwppbnQgYXJjaF9pbml0X21vZHVsZSAoc3RydWN0IG9ial9maWxlICpmLCBzdHJ1Y3QgbmV3X21vZHVsZSAqKTsKCiNlbmRpZiAvKiBvYmouaCAqLwovLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLy8tLS0tLS0tLWVuZCBvZiBtb2R1dGlscyBvYmouaAovLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCgoKCgojZGVmaW5lIF9QQVRIX01PRFVMRVMJIi9saWIvbW9kdWxlcyIKI2RlZmluZSBTVFJWRVJTSU9OTEVOCTMyCgojaWYgIWRlZmluZWQoQkJfRkVBVFVSRV9JTlNNT0RfTkVXX0tFUk5FTCkgJiYgIWRlZmluZWQoQkJfRkVBVFVSRV9JTlNNT0RfT0xEX0tFUk5FTCkKI2Vycm9yICJNdXN0IGhhdmUgZXRoZXIgQkJfRkVBVFVSRV9JTlNNT0RfTkVXX0tFUk5FTCBvciBCQl9GRUFUVVJFX0lOU01PRF9PTERfS0VSTkVMIGRlZmluZWQiCiNlbmRpZgoKLyo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ki8KCmludCBmbGFnX2ZvcmNlX2xvYWQgPSAwOwppbnQgZmxhZ19hdXRvY2xlYW4gPSAwOwppbnQgZmxhZ192ZXJib3NlID0gMDsKaW50IGZsYWdfZXhwb3J0ID0gMTsKCgovKj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0qLwoKc3RydWN0IGkzODZfZ290X2VudHJ5IHsKCWludCBvZmZzZXQ7Cgl1bnNpZ25lZCBvZmZzZXRfZG9uZToxOwoJdW5zaWduZWQgcmVsb2NfZG9uZToxOwp9OwoKc3RydWN0IGkzODZfZmlsZSB7CglzdHJ1Y3Qgb2JqX2ZpbGUgcm9vdDsKCXN0cnVjdCBvYmpfc2VjdGlvbiAqZ290Owp9OwoKc3RydWN0IGkzODZfc3ltYm9sIHsKCXN0cnVjdCBvYmpfc3ltYm9sIHJvb3Q7CglzdHJ1Y3QgaTM4Nl9nb3RfZW50cnkgZ290ZW50Owp9OwoKCgpzdHJ1Y3QgZXh0ZXJuYWxfbW9kdWxlIHsKCWNvbnN0IGNoYXIgKm5hbWU7CglFbGZXKEFkZHIpIGFkZHI7CglpbnQgdXNlZDsKCXNpemVfdCBuc3ltczsKCXN0cnVjdCBuZXdfbW9kdWxlX3N5bWJvbCAqc3ltczsKfTsKCnN0cnVjdCBuZXdfbW9kdWxlX3N5bWJvbCAqa3N5bXM7CnNpemVfdCBua3N5bXM7CgpzdHJ1Y3QgZXh0ZXJuYWxfbW9kdWxlICpleHRfbW9kdWxlczsKaW50IG5fZXh0X21vZHVsZXM7CmludCBuX2V4dF9tb2R1bGVzX3VzZWQ7CgoKCi8qIFNvbWUgZmlyZW5kbHkgc3lzY2FsbHMgdG8gY2hlZXIgZXZlcnlvbmUncyBkYXkuLi4gICovCiNkZWZpbmUgX19OUl9uZXdfc3lzX2luaXRfbW9kdWxlICBfX05SX2luaXRfbW9kdWxlCl9zeXNjYWxsMihpbnQsIG5ld19zeXNfaW5pdF9tb2R1bGUsIGNvbnN0IGNoYXIgKiwgbmFtZSwKCQkgIGNvbnN0IHN0cnVjdCBuZXdfbW9kdWxlICosIGluZm8pCiNkZWZpbmUgX19OUl9vbGRfc3lzX2luaXRfbW9kdWxlICBfX05SX2luaXRfbW9kdWxlCl9zeXNjYWxsNShpbnQsIG9sZF9zeXNfaW5pdF9tb2R1bGUsIGNvbnN0IGNoYXIgKiwgbmFtZSwgY2hhciAqLCBjb2RlLAoJCSAgdW5zaWduZWQsIGNvZGVzaXplLCBzdHJ1Y3Qgb2xkX21vZF9yb3V0aW5lcyAqLCByb3V0aW5lcywKCQkgIHN0cnVjdCBvbGRfc3ltYm9sX3RhYmxlICosIHN5bXRhYikKI2lmbmRlZiBCQl9STU1PRApfc3lzY2FsbDEoaW50LCBkZWxldGVfbW9kdWxlLCBjb25zdCBjaGFyICosIG5hbWUpCiNlbHNlCmV4dGVybiBpbnQgZGVsZXRlX21vZHVsZShjb25zdCBjaGFyICopOwojZW5kaWYKCiNpZiBkZWZpbmVkKF9faTM4Nl9fKSB8fCBkZWZpbmVkKF9fbTY4a19fKSB8fCBkZWZpbmVkKF9fYXJtX18pCi8qIEp1bXAgdGhyb3VnaCBob29wcyB0byBmaXh1cCBlcnJvciByZXR1cm4gY29kZXMgKi8KI2RlZmluZSBfX05SX19jcmVhdGVfbW9kdWxlICBfX05SX2NyZWF0ZV9tb2R1bGUKc3RhdGljIGlubGluZSBfc3lzY2FsbDIobG9uZywgX2NyZWF0ZV9tb2R1bGUsIGNvbnN0IGNoYXIgKiwgbmFtZSwgc2l6ZV90LAoJCQkJCQlzaXplKQp1bnNpZ25lZCBsb25nIGNyZWF0ZV9tb2R1bGUoY29uc3QgY2hhciAqbmFtZSwgc2l6ZV90IHNpemUpCnsKCWxvbmcgcmV0ID0gX2NyZWF0ZV9tb2R1bGUobmFtZSwgc2l6ZSk7CgoJaWYgKHJldCA9PSAtMSAmJiBlcnJubyA+IDEyNSkgewoJCXJldCA9IC1lcnJubzsKCQllcnJubyA9IDA7Cgl9CglyZXR1cm4gcmV0Owp9CiNlbHNlCl9zeXNjYWxsMih1bnNpZ25lZCBsb25nLCBjcmVhdGVfbW9kdWxlLCBjb25zdCBjaGFyICosIG5hbWUsIHNpemVfdCwgc2l6ZSkKI2VuZGlmCnN0YXRpYyBjaGFyIG1fZmlsZW5hbWVbQlVGU0laICsgMV0gPSAiXDAiOwpzdGF0aWMgY2hhciBtX2Z1bGxOYW1lW0JVRlNJWiArIDFdID0gIlwwIjsKc3RhdGljIGNvbnN0IGNoYXIgaW5zbW9kX3VzYWdlW10gPQoJImluc21vZCBbT1BUSU9OXS4uLiBNT0RVTEUgW3N5bWJvbD12YWx1ZV0uLi5cbiIKI2lmbmRlZiBCQl9GRUFUVVJFX1RSSVZJQUxfSEVMUAoJIlxuTG9hZHMgdGhlIHNwZWNpZmllZCBrZXJuZWwgbW9kdWxlcyBpbnRvIHRoZSBrZXJuZWwuXG5cbiIKCSJPcHRpb25zOlxuIgoJIlx0LWZcdEZvcmNlIG1vZHVsZSB0byBsb2FkIGludG8gdGhlIHdyb25nIGtlcm5lbCB2ZXJzaW9uLlxuIgoJIlx0LWtcdE1ha2UgbW9kdWxlIGF1dG9jbGVhbi1hYmxlLlxuIgoJIlx0LXZcdHZlcmJvc2Ugb3V0cHV0XG4iICJcdC14XHRkbyBub3QgZXhwb3J0IGV4dGVybnNcbiIKI2VuZGlmCjsKCi8qPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSovCgp2b2lkICp4cmVhbGxvYyh2b2lkICpvbGQsIHNpemVfdCBzaXplKQp7Cgl2b2lkICpwdHIgPSByZWFsbG9jKG9sZCwgc2l6ZSk7CglpZiAoIXB0cikgewoJCXBlcnJvcigiT3V0IG9mIG1lbW9yeSIpOwoJCWV4aXQoMSk7Cgl9CglyZXR1cm4gcHRyOwp9CgoKc3RhdGljIGludCBmaW5kTmFtZWRNb2R1bGUoY29uc3QgY2hhciAqZmlsZU5hbWUsIHN0cnVjdCBzdGF0ICpzdGF0YnVmLAoJCQkJCQkgICB2b2lkICp1c2VyRGF0ZSkKewoJY2hhciAqZnVsbE5hbWUgPSAoY2hhciAqKSB1c2VyRGF0ZTsKCgoJaWYgKGZ1bGxOYW1lWzBdID09ICdcMCcpCgkJcmV0dXJuIChGQUxTRSk7CgllbHNlIHsKCQljaGFyICp0bXAgPSBzdHJyY2hyKGZpbGVOYW1lLCAnLycpOwoKCQlpZiAodG1wID09IE5VTEwpCgkJCXRtcCA9IChjaGFyICopIGZpbGVOYW1lOwoJCWVsc2UKCQkJdG1wKys7CgkJaWYgKGNoZWNrX3dpbGRjYXJkX21hdGNoKHRtcCwgZnVsbE5hbWUpID09IFRSVUUpIHsKCQkJLyogU3RvcCBzZWFyY2hpbmcgaWYgd2UgZmluZCBhIG1hdGNoICovCgkJCW1lbWNweShtX2ZpbGVuYW1lLCBmaWxlTmFtZSwgc3RybGVuKGZpbGVOYW1lKSk7CgkJCXJldHVybiAoRkFMU0UpOwoJCX0KCX0KCXJldHVybiAoVFJVRSk7Cn0KCgovKj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0qLwoKc3RydWN0IG9ial9maWxlICphcmNoX25ld19maWxlKHZvaWQpCnsKCXN0cnVjdCBpMzg2X2ZpbGUgKmY7CglmID0geG1hbGxvYyhzaXplb2YoKmYpKTsKCWYtPmdvdCA9IE5VTEw7CglyZXR1cm4gJmYtPnJvb3Q7Cn0KCnN0cnVjdCBvYmpfc2VjdGlvbiAqYXJjaF9uZXdfc2VjdGlvbih2b2lkKQp7CglyZXR1cm4geG1hbGxvYyhzaXplb2Yoc3RydWN0IG9ial9zZWN0aW9uKSk7Cn0KCnN0cnVjdCBvYmpfc3ltYm9sICphcmNoX25ld19zeW1ib2wodm9pZCkKewoJc3RydWN0IGkzODZfc3ltYm9sICpzeW07CglzeW0gPSB4bWFsbG9jKHNpemVvZigqc3ltKSk7CgltZW1zZXQoJnN5bS0+Z290ZW50LCAwLCBzaXplb2Yoc3ltLT5nb3RlbnQpKTsKCXJldHVybiAmc3ltLT5yb290Owp9CmVudW0gb2JqX3JlbG9jCmFyY2hfYXBwbHlfcmVsb2NhdGlvbihzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJCQkJICBzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnRhcmdzZWMsCgkJCQkJICBzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnN5bXNlYywKCQkJCQkgIHN0cnVjdCBvYmpfc3ltYm9sICpzeW0sCgkJCQkJICBFbGYzMl9SZWwgKiByZWwsIEVsZjMyX0FkZHIgdikKewoJc3RydWN0IGkzODZfZmlsZSAqaWZpbGUgPSAoc3RydWN0IGkzODZfZmlsZSAqKSBmOwoJc3RydWN0IGkzODZfc3ltYm9sICppc3ltID0gKHN0cnVjdCBpMzg2X3N5bWJvbCAqKSBzeW07CgoJRWxmMzJfQWRkciAqbG9jID0gKEVsZjMyX0FkZHIgKikgKHRhcmdzZWMtPmNvbnRlbnRzICsgcmVsLT5yX29mZnNldCk7CglFbGYzMl9BZGRyIGRvdCA9IHRhcmdzZWMtPmhlYWRlci5zaF9hZGRyICsgcmVsLT5yX29mZnNldDsKCUVsZjMyX0FkZHIgZ290ID0gaWZpbGUtPmdvdCA/IGlmaWxlLT5nb3QtPmhlYWRlci5zaF9hZGRyIDogMDsKCgllbnVtIG9ial9yZWxvYyByZXQgPSBvYmpfcmVsb2Nfb2s7CgoJc3dpdGNoIChFTEYzMl9SX1RZUEUocmVsLT5yX2luZm8pKSB7CgljYXNlIFJfMzg2X05PTkU6CgkJYnJlYWs7CgoJY2FzZSBSXzM4Nl8zMjoKCQkqbG9jICs9IHY7CgkJYnJlYWs7CgoJY2FzZSBSXzM4Nl9QTFQzMjoKCWNhc2UgUl8zODZfUEMzMjoKCQkqbG9jICs9IHYgLSBkb3Q7CgkJYnJlYWs7CgoJY2FzZSBSXzM4Nl9HTE9CX0RBVDoKCWNhc2UgUl8zODZfSk1QX1NMT1Q6CgkJKmxvYyA9IHY7CgkJYnJlYWs7CgoJY2FzZSBSXzM4Nl9SRUxBVElWRToKCQkqbG9jICs9IGYtPmJhc2VhZGRyOwoJCWJyZWFrOwoKCWNhc2UgUl8zODZfR09UUEM6CgkJYXNzZXJ0KGdvdCAhPSAwKTsKCQkqbG9jICs9IGdvdCAtIGRvdDsKCQlicmVhazsKCgljYXNlIFJfMzg2X0dPVDMyOgoJCWFzc2VydChpc3ltICE9IE5VTEwpOwoJCWlmICghaXN5bS0+Z290ZW50LnJlbG9jX2RvbmUpIHsKCQkJaXN5bS0+Z290ZW50LnJlbG9jX2RvbmUgPSAxOwoJCQkqKEVsZjMyX0FkZHIgKikgKGlmaWxlLT5nb3QtPmNvbnRlbnRzICsgaXN5bS0+Z290ZW50Lm9mZnNldCkgPQoJCQkJdjsKCQl9CgkJKmxvYyArPSBpc3ltLT5nb3RlbnQub2Zmc2V0OwoJCWJyZWFrOwoKCWNhc2UgUl8zODZfR09UT0ZGOgoJCWFzc2VydChnb3QgIT0gMCk7CgkJKmxvYyArPSB2IC0gZ290OwoJCWJyZWFrOwoKCWRlZmF1bHQ6CgkJcmV0ID0gb2JqX3JlbG9jX3VuaGFuZGxlZDsKCQlicmVhazsKCX0KCglyZXR1cm4gcmV0Owp9CgppbnQgYXJjaF9jcmVhdGVfZ290KHN0cnVjdCBvYmpfZmlsZSAqZikKewoJc3RydWN0IGkzODZfZmlsZSAqaWZpbGUgPSAoc3RydWN0IGkzODZfZmlsZSAqKSBmOwoJaW50IGksIG4sIG9mZnNldCA9IDAsIGdvdG5lZWRlZCA9IDA7CgoJbiA9IGlmaWxlLT5yb290LmhlYWRlci5lX3NobnVtOwoJZm9yIChpID0gMDsgaSA8IG47ICsraSkgewoJCXN0cnVjdCBvYmpfc2VjdGlvbiAqcmVsc2VjLCAqc3ltc2VjLCAqc3Ryc2VjOwoJCUVsZjMyX1JlbCAqcmVsLCAqcmVsZW5kOwoJCUVsZjMyX1N5bSAqc3ltdGFiOwoJCWNvbnN0IGNoYXIgKnN0cnRhYjsKCgkJcmVsc2VjID0gaWZpbGUtPnJvb3Quc2VjdGlvbnNbaV07CgkJaWYgKHJlbHNlYy0+aGVhZGVyLnNoX3R5cGUgIT0gU0hUX1JFTCkKCQkJY29udGludWU7CgoJCXN5bXNlYyA9IGlmaWxlLT5yb290LnNlY3Rpb25zW3JlbHNlYy0+aGVhZGVyLnNoX2xpbmtdOwoJCXN0cnNlYyA9IGlmaWxlLT5yb290LnNlY3Rpb25zW3N5bXNlYy0+aGVhZGVyLnNoX2xpbmtdOwoKCQlyZWwgPSAoRWxmMzJfUmVsICopIHJlbHNlYy0+Y29udGVudHM7CgkJcmVsZW5kID0gcmVsICsgKHJlbHNlYy0+aGVhZGVyLnNoX3NpemUgLyBzaXplb2YoRWxmMzJfUmVsKSk7CgkJc3ltdGFiID0gKEVsZjMyX1N5bSAqKSBzeW1zZWMtPmNvbnRlbnRzOwoJCXN0cnRhYiA9IChjb25zdCBjaGFyICopIHN0cnNlYy0+Y29udGVudHM7CgoJCWZvciAoOyByZWwgPCByZWxlbmQ7ICsrcmVsKSB7CgkJCUVsZjMyX1N5bSAqZXh0c3ltOwoJCQlzdHJ1Y3QgaTM4Nl9zeW1ib2wgKmludHN5bTsKCQkJY29uc3QgY2hhciAqbmFtZTsKCgkJCXN3aXRjaCAoRUxGMzJfUl9UWVBFKHJlbC0+cl9pbmZvKSkgewoJCQljYXNlIFJfMzg2X0dPVFBDOgoJCQljYXNlIFJfMzg2X0dPVE9GRjoKCQkJCWdvdG5lZWRlZCA9IDE7CgkJCWRlZmF1bHQ6CgkJCQljb250aW51ZTsKCgkJCWNhc2UgUl8zODZfR09UMzI6CgkJCQlicmVhazsKCQkJfQoKCQkJZXh0c3ltID0gJnN5bXRhYltFTEYzMl9SX1NZTShyZWwtPnJfaW5mbyldOwoJCQlpZiAoZXh0c3ltLT5zdF9uYW1lKQoJCQkJbmFtZSA9IHN0cnRhYiArIGV4dHN5bS0+c3RfbmFtZTsKCQkJZWxzZQoJCQkJbmFtZSA9IGYtPnNlY3Rpb25zW2V4dHN5bS0+c3Rfc2huZHhdLT5uYW1lOwoJCQlpbnRzeW0gPQoJCQkJKHN0cnVjdCBpMzg2X3N5bWJvbCAqKSBvYmpfZmluZF9zeW1ib2woJmlmaWxlLT5yb290LCBuYW1lKTsKCgkJCWlmICghaW50c3ltLT5nb3RlbnQub2Zmc2V0X2RvbmUpIHsKCQkJCWludHN5bS0+Z290ZW50Lm9mZnNldF9kb25lID0gMTsKCQkJCWludHN5bS0+Z290ZW50Lm9mZnNldCA9IG9mZnNldDsKCQkJCW9mZnNldCArPSA0OwoJCQl9CgkJfQoJfQoKCWlmIChvZmZzZXQgPiAwIHx8IGdvdG5lZWRlZCkKCQlpZmlsZS0+Z290ID0KCQkJb2JqX2NyZWF0ZV9hbGxvY2VkX3NlY3Rpb24oJmlmaWxlLT5yb290LCAiLmdvdCIsIDQsIG9mZnNldCk7CgoJcmV0dXJuIDE7Cn0KCmludCBhcmNoX2luaXRfbW9kdWxlKHN0cnVjdCBvYmpfZmlsZSAqZiwgc3RydWN0IG5ld19tb2R1bGUgKm1vZCkKewoJcmV0dXJuIDE7Cn0KCgovKj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0qLwoKLyogU3RhbmRhcmQgRUxGIGhhc2ggZnVuY3Rpb24uICAqLwppbmxpbmUgdW5zaWduZWQgbG9uZyBvYmpfZWxmX2hhc2hfbihjb25zdCBjaGFyICpuYW1lLCB1bnNpZ25lZCBsb25nIG4pCnsKCXVuc2lnbmVkIGxvbmcgaCA9IDA7Cgl1bnNpZ25lZCBsb25nIGc7Cgl1bnNpZ25lZCBjaGFyIGNoOwoKCXdoaWxlIChuID4gMCkgewoJCWNoID0gKm5hbWUrKzsKCQloID0gKGggPDwgNCkgKyBjaDsKCQlpZiAoKGcgPSAoaCAmIDB4ZjAwMDAwMDApKSAhPSAwKSB7CgkJCWggXj0gZyA+PiAyNDsKCQkJaCAmPSB+ZzsKCQl9CgkJbi0tOwoJfQoJcmV0dXJuIGg7Cn0KCnVuc2lnbmVkIGxvbmcgb2JqX2VsZl9oYXNoKGNvbnN0IGNoYXIgKm5hbWUpCnsKCXJldHVybiBvYmpfZWxmX2hhc2hfbihuYW1lLCBzdHJsZW4obmFtZSkpOwp9CgojaWZkZWYgQkJfRkVBVFVSRV9JTlNNT0RfVkVSU0lPTl9DSEVDS0lORwovKiBHZXQgdGhlIGtlcm5lbCB2ZXJzaW9uIGluIHRoZSBjYW5vbmljYWwgaW50ZWdlciBmb3JtLiAgKi8KCnN0YXRpYyBpbnQgZ2V0X2tlcm5lbF92ZXJzaW9uKGNoYXIgc3RyW1NUUlZFUlNJT05MRU5dKQp7CglzdHJ1Y3QgdXRzbmFtZSB1dHNfaW5mbzsKCWNoYXIgKnAsICpxOwoJaW50IGEsIGIsIGM7CgoJaWYgKHVuYW1lKCZ1dHNfaW5mbykgPCAwKQoJCXJldHVybiAtMTsKCXN0cm5jcHkoc3RyLCB1dHNfaW5mby5yZWxlYXNlLCBTVFJWRVJTSU9OTEVOKTsKCXAgPSB1dHNfaW5mby5yZWxlYXNlOwoKCWEgPSBzdHJ0b3VsKHAsICZwLCAxMCk7CglpZiAoKnAgIT0gJy4nKQoJCXJldHVybiAtMTsKCWIgPSBzdHJ0b3VsKHAgKyAxLCAmcCwgMTApOwoJaWYgKCpwICE9ICcuJykKCQlyZXR1cm4gLTE7CgljID0gc3RydG91bChwICsgMSwgJnEsIDEwKTsKCWlmIChwICsgMSA9PSBxKQoJCXJldHVybiAtMTsKCglyZXR1cm4gYSA8PCAxNiB8IGIgPDwgOCB8IGM7Cn0KCi8qIFN0cmluZyBjb21wYXJpc29uIGZvciBub24tY28tdmVyc2lvbmVkIGtlcm5lbCBhbmQgbW9kdWxlLiAgKi8KCnN0YXRpYyBpbnQgbmN2X3N0cmNtcChjb25zdCBjaGFyICphLCBjb25zdCBjaGFyICpiKQp7CglzaXplX3QgYWxlbiA9IHN0cmxlbihhKSwgYmxlbiA9IHN0cmxlbihiKTsKCglpZiAoYmxlbiA9PSBhbGVuICsgMTAgJiYgYlthbGVuXSA9PSAnXycgJiYgYlthbGVuICsgMV0gPT0gJ1InKQoJCXJldHVybiBzdHJuY21wKGEsIGIsIGFsZW4pOwoJZWxzZSBpZiAoYWxlbiA9PSBibGVuICsgMTAgJiYgYVtibGVuXSA9PSAnXycgJiYgYVtibGVuICsgMV0gPT0gJ1InKQoJCXJldHVybiBzdHJuY21wKGEsIGIsIGJsZW4pOwoJZWxzZQoJCXJldHVybiBzdHJjbXAoYSwgYik7Cn0KCi8qIFN0cmluZyBoYXNoaW5nIGZvciBub24tY28tdmVyc2lvbmVkIGtlcm5lbCBhbmQgbW9kdWxlLiAgSGVyZQogICB3ZSBhcmUgc2ltcGx5IGZvcmNlZCB0byBkcm9wIHRoZSBjcmMgZnJvbSB0aGUgaGFzaC4gICovCgpzdGF0aWMgdW5zaWduZWQgbG9uZyBuY3Zfc3ltYm9sX2hhc2goY29uc3QgY2hhciAqc3RyKQp7CglzaXplX3QgbGVuID0gc3RybGVuKHN0cik7CglpZiAobGVuID4gMTAgJiYgc3RyW2xlbiAtIDEwXSA9PSAnXycgJiYgc3RyW2xlbiAtIDldID09ICdSJykKCQlsZW4gLT0gMTA7CglyZXR1cm4gb2JqX2VsZl9oYXNoX24oc3RyLCBsZW4pOwp9Cgp2b2lkCm9ial9zZXRfc3ltYm9sX2NvbXBhcmUoc3RydWN0IG9ial9maWxlICpmLAoJCQkJCSAgIGludCAoKmNtcCkgKGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqKSwKCQkJCQkgICB1bnNpZ25lZCBsb25nICgqaGFzaCkgKGNvbnN0IGNoYXIgKikpCnsKCWlmIChjbXApCgkJZi0+c3ltYm9sX2NtcCA9IGNtcDsKCWlmIChoYXNoKSB7CgkJc3RydWN0IG9ial9zeW1ib2wgKnRtcHRhYltIQVNIX0JVQ0tFVFNdLCAqc3ltLCAqbmV4dDsKCQlpbnQgaTsKCgkJZi0+c3ltYm9sX2hhc2ggPSBoYXNoOwoKCQltZW1jcHkodG1wdGFiLCBmLT5zeW10YWIsIHNpemVvZih0bXB0YWIpKTsKCQltZW1zZXQoZi0+c3ltdGFiLCAwLCBzaXplb2YoZi0+c3ltdGFiKSk7CgoJCWZvciAoaSA9IDA7IGkgPCBIQVNIX0JVQ0tFVFM7ICsraSkKCQkJZm9yIChzeW0gPSB0bXB0YWJbaV07IHN5bTsgc3ltID0gbmV4dCkgewoJCQkJdW5zaWduZWQgbG9uZyBoID0gaGFzaChzeW0tPm5hbWUpICUgSEFTSF9CVUNLRVRTOwoJCQkJbmV4dCA9IHN5bS0+bmV4dDsKCQkJCXN5bS0+bmV4dCA9IGYtPnN5bXRhYltoXTsKCQkJCWYtPnN5bXRhYltoXSA9IHN5bTsKCQkJfQoJfQp9CgojZW5kaWYJCQkJCQkJLyogQkJfRkVBVFVSRV9JTlNNT0RfVkVSU0lPTl9DSEVDS0lORyAqLwoKCnN0cnVjdCBvYmpfc3ltYm9sICpvYmpfYWRkX3N5bWJvbChzdHJ1Y3Qgb2JqX2ZpbGUgKmYsIGNvbnN0IGNoYXIgKm5hbWUsCgkJCQkJCQkJICB1bnNpZ25lZCBsb25nIHN5bWlkeCwgaW50IGluZm8sCgkJCQkJCQkJICBpbnQgc2VjaWR4LCBFbGZXKEFkZHIpIHZhbHVlLAoJCQkJCQkJCSAgdW5zaWduZWQgbG9uZyBzaXplKQp7CglzdHJ1Y3Qgb2JqX3N5bWJvbCAqc3ltOwoJdW5zaWduZWQgbG9uZyBoYXNoID0gZi0+c3ltYm9sX2hhc2gobmFtZSkgJSBIQVNIX0JVQ0tFVFM7CglpbnQgbl90eXBlID0gRUxGVyhTVF9UWVBFKSAoaW5mbyk7CglpbnQgbl9iaW5kaW5nID0gRUxGVyhTVF9CSU5EKSAoaW5mbyk7CgoJZm9yIChzeW0gPSBmLT5zeW10YWJbaGFzaF07IHN5bTsgc3ltID0gc3ltLT5uZXh0KQoJCWlmIChmLT5zeW1ib2xfY21wKHN5bS0+bmFtZSwgbmFtZSkgPT0gMCkgewoJCQlpbnQgb19zZWNpZHggPSBzeW0tPnNlY2lkeDsKCQkJaW50IG9faW5mbyA9IHN5bS0+aW5mbzsKCQkJaW50IG9fdHlwZSA9IEVMRlcoU1RfVFlQRSkgKG9faW5mbyk7CgkJCWludCBvX2JpbmRpbmcgPSBFTEZXKFNUX0JJTkQpIChvX2luZm8pOwoKCQkJLyogQSByZWRlZmluaXRpb24hICBJcyBpdCBsZWdhbD8gICovCgoJCQlpZiAoc2VjaWR4ID09IFNITl9VTkRFRikKCQkJCXJldHVybiBzeW07CgkJCWVsc2UgaWYgKG9fc2VjaWR4ID09IFNITl9VTkRFRikKCQkJCWdvdG8gZm91bmQ7CgkJCWVsc2UgaWYgKG5fYmluZGluZyA9PSBTVEJfR0xPQkFMICYmIG9fYmluZGluZyA9PSBTVEJfTE9DQUwpIHsKCQkJCS8qIENvcGUgd2l0aCBsb2NhbCBhbmQgZ2xvYmFsIHN5bWJvbHMgb2YgdGhlIHNhbWUgbmFtZQoJCQkJICAgaW4gdGhlIHNhbWUgb2JqZWN0IGZpbGUsIGFzIG1pZ2h0IGhhdmUgYmVlbiBjcmVhdGVkCgkJCQkgICBieSBsZCAtci4gIFRoZSBvbmx5IHJlYXNvbiBsb2NhbHMgYXJlIG5vdyBzZWVuIGF0IHRoaXMKCQkJCSAgIGxldmVsIGF0IGFsbCBpcyBzbyB0aGF0IHdlIGNhbiBkbyBzZW1pLXNlbnNpYmxlIHRoaW5ncwoJCQkJICAgd2l0aCBwYXJhbWV0ZXJzLiAgKi8KCgkJCQlzdHJ1Y3Qgb2JqX3N5bWJvbCAqbnN5bSwgKipwOwoKCQkJCW5zeW0gPSBhcmNoX25ld19zeW1ib2woKTsKCQkJCW5zeW0tPm5leHQgPSBzeW0tPm5leHQ7CgkJCQluc3ltLT5rc3ltaWR4ID0gLTE7CgoJCQkJLyogRXhjaXNlIHRoZSBvbGQgKGxvY2FsKSBzeW1ib2wgZnJvbSB0aGUgaGFzaCBjaGFpbi4gICovCgkJCQlmb3IgKHAgPSAmZi0+c3ltdGFiW2hhc2hdOyAqcCAhPSBzeW07IHAgPSAmKCpwKS0+bmV4dCkKCQkJCQljb250aW51ZTsKCQkJCSpwID0gc3ltID0gbnN5bTsKCQkJCWdvdG8gZm91bmQ7CgkJCX0gZWxzZSBpZiAobl9iaW5kaW5nID09IFNUQl9MT0NBTCkgewoJCQkJLyogQW5vdGhlciBzeW1ib2wgb2YgdGhlIHNhbWUgbmFtZSBoYXMgYWxyZWFkeSBiZWVuIGRlZmluZWQuCgkJCQkgICBKdXN0IGFkZCB0aGlzIHRvIHRoZSBsb2NhbCB0YWJsZS4gICovCgkJCQlzeW0gPSBhcmNoX25ld19zeW1ib2woKTsKCQkJCXN5bS0+bmV4dCA9IE5VTEw7CgkJCQlzeW0tPmtzeW1pZHggPSAtMTsKCQkJCWYtPmxvY2FsX3N5bXRhYltzeW1pZHhdID0gc3ltOwoJCQkJZ290byBmb3VuZDsKCQkJfSBlbHNlIGlmIChuX2JpbmRpbmcgPT0gU1RCX1dFQUspCgkJCQlyZXR1cm4gc3ltOwoJCQllbHNlIGlmIChvX2JpbmRpbmcgPT0gU1RCX1dFQUspCgkJCQlnb3RvIGZvdW5kOwoJCQkvKiBEb24ndCB1bmlmeSBDT01NT04gc3ltYm9scyB3aXRoIG9iamVjdCB0eXBlcyB0aGUgcHJvZ3JhbW1lcgoJCQkgICBkb2Vzbid0IGV4cGVjdC4gICovCgkJCWVsc2UgaWYgKHNlY2lkeCA9PSBTSE5fQ09NTU9OCgkJCQkJICYmIChvX3R5cGUgPT0gU1RUX05PVFlQRSB8fCBvX3R5cGUgPT0gU1RUX09CSkVDVCkpCgkJCQlyZXR1cm4gc3ltOwoJCQllbHNlIGlmIChvX3NlY2lkeCA9PSBTSE5fQ09NTU9OCgkJCQkJICYmIChuX3R5cGUgPT0gU1RUX05PVFlQRSB8fCBuX3R5cGUgPT0gU1RUX09CSkVDVCkpCgkJCQlnb3RvIGZvdW5kOwoJCQllbHNlIHsKCQkJCS8qIERvbid0IHJlcG9ydCBhbiBlcnJvciBpZiB0aGUgc3ltYm9sIGlzIGNvbWluZyBmcm9tCgkJCQkgICB0aGUga2VybmVsIG9yIHNvbWUgZXh0ZXJuYWwgbW9kdWxlLiAgKi8KCQkJCWlmIChzZWNpZHggPD0gU0hOX0hJUkVTRVJWRSkKCQkJCQlmcHJpbnRmKHN0ZGVyciwgIiVzIG11bHRpcGx5IGRlZmluZWRcbiIsIG5hbWUpOwoJCQkJcmV0dXJuIHN5bTsKCQkJfQoJCX0KCgkvKiBDb21wbGV0ZWx5IG5ldyBzeW1ib2wuICAqLwoJc3ltID0gYXJjaF9uZXdfc3ltYm9sKCk7CglzeW0tPm5leHQgPSBmLT5zeW10YWJbaGFzaF07CglmLT5zeW10YWJbaGFzaF0gPSBzeW07CglzeW0tPmtzeW1pZHggPSAtMTsKCglpZiAoRUxGVyhTVF9CSU5EKSAoaW5mbykgPT0gU1RCX0xPQ0FMKQoJCWYtPmxvY2FsX3N5bXRhYltzeW1pZHhdID0gc3ltOwoKICBmb3VuZDoKCXN5bS0+bmFtZSA9IG5hbWU7CglzeW0tPnZhbHVlID0gdmFsdWU7CglzeW0tPnNpemUgPSBzaXplOwoJc3ltLT5zZWNpZHggPSBzZWNpZHg7CglzeW0tPmluZm8gPSBpbmZvOwoKCXJldHVybiBzeW07Cn0KCnN0cnVjdCBvYmpfc3ltYm9sICpvYmpfZmluZF9zeW1ib2woc3RydWN0IG9ial9maWxlICpmLCBjb25zdCBjaGFyICpuYW1lKQp7CglzdHJ1Y3Qgb2JqX3N5bWJvbCAqc3ltOwoJdW5zaWduZWQgbG9uZyBoYXNoID0gZi0+c3ltYm9sX2hhc2gobmFtZSkgJSBIQVNIX0JVQ0tFVFM7CgoJZm9yIChzeW0gPSBmLT5zeW10YWJbaGFzaF07IHN5bTsgc3ltID0gc3ltLT5uZXh0KQoJCWlmIChmLT5zeW1ib2xfY21wKHN5bS0+bmFtZSwgbmFtZSkgPT0gMCkKCQkJcmV0dXJuIHN5bTsKCglyZXR1cm4gTlVMTDsKfQoKRWxmVyhBZGRyKQoJb2JqX3N5bWJvbF9maW5hbF92YWx1ZShzdHJ1Y3Qgb2JqX2ZpbGUgKiBmLCBzdHJ1Y3Qgb2JqX3N5bWJvbCAqIHN5bSkKewoJaWYgKHN5bSkgewoJCWlmIChzeW0tPnNlY2lkeCA+PSBTSE5fTE9SRVNFUlZFKQoJCQlyZXR1cm4gc3ltLT52YWx1ZTsKCgkJcmV0dXJuIHN5bS0+dmFsdWUgKyBmLT5zZWN0aW9uc1tzeW0tPnNlY2lkeF0tPmhlYWRlci5zaF9hZGRyOwoJfSBlbHNlIHsKCQkvKiBBcyBhIHNwZWNpYWwgY2FzZSwgYSBOVUxMIHN5bSBoYXMgdmFsdWUgemVyby4gICovCgkJcmV0dXJuIDA7Cgl9Cn0KCnN0cnVjdCBvYmpfc2VjdGlvbiAqb2JqX2ZpbmRfc2VjdGlvbihzdHJ1Y3Qgb2JqX2ZpbGUgKmYsIGNvbnN0IGNoYXIgKm5hbWUpCnsKCWludCBpLCBuID0gZi0+aGVhZGVyLmVfc2hudW07CgoJZm9yIChpID0gMDsgaSA8IG47ICsraSkKCQlpZiAoc3RyY21wKGYtPnNlY3Rpb25zW2ldLT5uYW1lLCBuYW1lKSA9PSAwKQoJCQlyZXR1cm4gZi0+c2VjdGlvbnNbaV07CgoJcmV0dXJuIE5VTEw7Cn0KCnN0YXRpYyBpbnQgb2JqX2xvYWRfb3JkZXJfcHJpbyhzdHJ1Y3Qgb2JqX3NlY3Rpb24gKmEpCnsKCXVuc2lnbmVkIGxvbmcgYWYsIGFjOwoKCWFmID0gYS0+aGVhZGVyLnNoX2ZsYWdzOwoKCWFjID0gMDsKCWlmIChhLT5uYW1lWzBdICE9ICcuJyB8fCBzdHJsZW4oYS0+bmFtZSkgIT0gMTAgfHwKCQlzdHJjbXAoYS0+bmFtZSArIDUsICIuaW5pdCIpKQoJCWFjIHw9IDMyOwoJaWYgKGFmICYgU0hGX0FMTE9DKQoJCWFjIHw9IDE2OwoJaWYgKCEoYWYgJiBTSEZfV1JJVEUpKQoJCWFjIHw9IDg7CglpZiAoYWYgJiBTSEZfRVhFQ0lOU1RSKQoJCWFjIHw9IDQ7CglpZiAoYS0+aGVhZGVyLnNoX3R5cGUgIT0gU0hUX05PQklUUykKCQlhYyB8PSAyOwoKCXJldHVybiBhYzsKfQoKdm9pZApvYmpfaW5zZXJ0X3NlY3Rpb25fbG9hZF9vcmRlcihzdHJ1Y3Qgb2JqX2ZpbGUgKmYsIHN0cnVjdCBvYmpfc2VjdGlvbiAqc2VjKQp7CglzdHJ1Y3Qgb2JqX3NlY3Rpb24gKipwOwoJaW50IHByaW8gPSBvYmpfbG9hZF9vcmRlcl9wcmlvKHNlYyk7Cglmb3IgKHAgPSBmLT5sb2FkX29yZGVyX3NlYXJjaF9zdGFydDsgKnA7IHAgPSAmKCpwKS0+bG9hZF9uZXh0KQoJCWlmIChvYmpfbG9hZF9vcmRlcl9wcmlvKCpwKSA8IHByaW8pCgkJCWJyZWFrOwoJc2VjLT5sb2FkX25leHQgPSAqcDsKCSpwID0gc2VjOwp9CgpzdHJ1Y3Qgb2JqX3NlY3Rpb24gKm9ial9jcmVhdGVfYWxsb2NlZF9zZWN0aW9uKHN0cnVjdCBvYmpfZmlsZSAqZiwKCQkJCQkJCQkJCQkgICBjb25zdCBjaGFyICpuYW1lLAoJCQkJCQkJCQkJCSAgIHVuc2lnbmVkIGxvbmcgYWxpZ24sCgkJCQkJCQkJCQkJICAgdW5zaWduZWQgbG9uZyBzaXplKQp7CglpbnQgbmV3aWR4ID0gZi0+aGVhZGVyLmVfc2hudW0rKzsKCXN0cnVjdCBvYmpfc2VjdGlvbiAqc2VjOwoKCWYtPnNlY3Rpb25zID0geHJlYWxsb2MoZi0+c2VjdGlvbnMsIChuZXdpZHggKyAxKSAqIHNpemVvZihzZWMpKTsKCWYtPnNlY3Rpb25zW25ld2lkeF0gPSBzZWMgPSBhcmNoX25ld19zZWN0aW9uKCk7CgoJbWVtc2V0KHNlYywgMCwgc2l6ZW9mKCpzZWMpKTsKCXNlYy0+aGVhZGVyLnNoX3R5cGUgPSBTSFRfUFJPR0JJVFM7CglzZWMtPmhlYWRlci5zaF9mbGFncyA9IFNIRl9XUklURSB8IFNIRl9BTExPQzsKCXNlYy0+aGVhZGVyLnNoX3NpemUgPSBzaXplOwoJc2VjLT5oZWFkZXIuc2hfYWRkcmFsaWduID0gYWxpZ247CglzZWMtPm5hbWUgPSBuYW1lOwoJc2VjLT5pZHggPSBuZXdpZHg7CglpZiAoc2l6ZSkKCQlzZWMtPmNvbnRlbnRzID0geG1hbGxvYyhzaXplKTsKCglvYmpfaW5zZXJ0X3NlY3Rpb25fbG9hZF9vcmRlcihmLCBzZWMpOwoKCXJldHVybiBzZWM7Cn0KCnN0cnVjdCBvYmpfc2VjdGlvbiAqb2JqX2NyZWF0ZV9hbGxvY2VkX3NlY3Rpb25fZmlyc3Qoc3RydWN0IG9ial9maWxlICpmLAoJCQkJCQkJCQkJCQkJIGNvbnN0IGNoYXIgKm5hbWUsCgkJCQkJCQkJCQkJCQkgdW5zaWduZWQgbG9uZyBhbGlnbiwKCQkJCQkJCQkJCQkJCSB1bnNpZ25lZCBsb25nIHNpemUpCnsKCWludCBuZXdpZHggPSBmLT5oZWFkZXIuZV9zaG51bSsrOwoJc3RydWN0IG9ial9zZWN0aW9uICpzZWM7CgoJZi0+c2VjdGlvbnMgPSB4cmVhbGxvYyhmLT5zZWN0aW9ucywgKG5ld2lkeCArIDEpICogc2l6ZW9mKHNlYykpOwoJZi0+c2VjdGlvbnNbbmV3aWR4XSA9IHNlYyA9IGFyY2hfbmV3X3NlY3Rpb24oKTsKCgltZW1zZXQoc2VjLCAwLCBzaXplb2YoKnNlYykpOwoJc2VjLT5oZWFkZXIuc2hfdHlwZSA9IFNIVF9QUk9HQklUUzsKCXNlYy0+aGVhZGVyLnNoX2ZsYWdzID0gU0hGX1dSSVRFIHwgU0hGX0FMTE9DOwoJc2VjLT5oZWFkZXIuc2hfc2l6ZSA9IHNpemU7CglzZWMtPmhlYWRlci5zaF9hZGRyYWxpZ24gPSBhbGlnbjsKCXNlYy0+bmFtZSA9IG5hbWU7CglzZWMtPmlkeCA9IG5ld2lkeDsKCWlmIChzaXplKQoJCXNlYy0+Y29udGVudHMgPSB4bWFsbG9jKHNpemUpOwoKCXNlYy0+bG9hZF9uZXh0ID0gZi0+bG9hZF9vcmRlcjsKCWYtPmxvYWRfb3JkZXIgPSBzZWM7CglpZiAoZi0+bG9hZF9vcmRlcl9zZWFyY2hfc3RhcnQgPT0gJmYtPmxvYWRfb3JkZXIpCgkJZi0+bG9hZF9vcmRlcl9zZWFyY2hfc3RhcnQgPSAmc2VjLT5sb2FkX25leHQ7CgoJcmV0dXJuIHNlYzsKfQoKdm9pZCAqb2JqX2V4dGVuZF9zZWN0aW9uKHN0cnVjdCBvYmpfc2VjdGlvbiAqc2VjLCB1bnNpZ25lZCBsb25nIG1vcmUpCnsKCXVuc2lnbmVkIGxvbmcgb2xkc2l6ZSA9IHNlYy0+aGVhZGVyLnNoX3NpemU7CglzZWMtPmNvbnRlbnRzID0geHJlYWxsb2Moc2VjLT5jb250ZW50cywgc2VjLT5oZWFkZXIuc2hfc2l6ZSArPSBtb3JlKTsKCXJldHVybiBzZWMtPmNvbnRlbnRzICsgb2xkc2l6ZTsKfQoKCgovKiBDb25kaXRpb25hbGx5IGFkZCB0aGUgc3ltYm9scyBmcm9tIHRoZSBnaXZlbiBzeW1ib2wgc2V0IHRvIHRoZQogICBuZXcgbW9kdWxlLiAgKi8KCnN0YXRpYyBpbnQKYWRkX3N5bWJvbHNfZnJvbSgKCQkJCSBzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJCQkgaW50IGlkeCwgc3RydWN0IG5ld19tb2R1bGVfc3ltYm9sICpzeW1zLCBzaXplX3QgbnN5bXMpCnsKCXN0cnVjdCBuZXdfbW9kdWxlX3N5bWJvbCAqczsKCXNpemVfdCBpOwoJaW50IHVzZWQgPSAwOwoKCWZvciAoaSA9IDAsIHMgPSBzeW1zOyBpIDwgbnN5bXM7ICsraSwgKytzKSB7CgoJCS8qIE9ubHkgYWRkIHN5bWJvbHMgdGhhdCBhcmUgYWxyZWFkeSBtYXJrZWQgZXh0ZXJuYWwuICBJZiB3ZQoJCSAgIG92ZXJyaWRlIGxvY2FscyB3ZSBtYXkgY2F1c2UgcHJvYmxlbXMgZm9yIGFyZ3VtZW50IGluaXRpYWxpemF0aW9uLgoJCSAgIFdlIHdpbGwgYWxzbyBjcmVhdGUgYSBmYWxzZSBkZXBlbmRlbmN5IG9uIHRoZSBtb2R1bGUuICAqLwoJCXN0cnVjdCBvYmpfc3ltYm9sICpzeW07CgoJCXN5bSA9IG9ial9maW5kX3N5bWJvbChmLCAoY2hhciAqKSBzLT5uYW1lKTsKCQlpZiAoc3ltICYmICFFTEZXKFNUX0JJTkQpIChzeW0tPmluZm8pID09IFNUQl9MT0NBTCkgewoJCQlzeW0gPSBvYmpfYWRkX3N5bWJvbChmLCAoY2hhciAqKSBzLT5uYW1lLCAtMSwKCQkJCQkJCQkgRUxGVyhTVF9JTkZPKSAoU1RCX0dMT0JBTCwgU1RUX05PVFlQRSksCgkJCQkJCQkJIGlkeCwgcy0+dmFsdWUsIDApOwoJCQkvKiBEaWQgb3VyIHN5bWJvbCBqdXN0IGdldCBpbnN0YWxsZWQ/ICBJZiBzbywgbWFyayB0aGUKCQkJICAgbW9kdWxlIGFzICJ1c2VkIi4gICovCgkJCWlmIChzeW0tPnNlY2lkeCA9PSBpZHgpCgkJCQl1c2VkID0gMTsKCQl9Cgl9CgoJcmV0dXJuIHVzZWQ7Cn0KCnN0YXRpYyB2b2lkIGFkZF9rZXJuZWxfc3ltYm9scyhzdHJ1Y3Qgb2JqX2ZpbGUgKmYpCnsKCXN0cnVjdCBleHRlcm5hbF9tb2R1bGUgKm07CglzaXplX3QgaSwgbnVzZWQgPSAwOwoKCS8qIEFkZCBtb2R1bGUgc3ltYm9scyBmaXJzdC4gICovCgoJZm9yIChpID0gMCwgbSA9IGV4dF9tb2R1bGVzOyBpIDwgbl9leHRfbW9kdWxlczsgKytpLCArK20pCgkJaWYgKG0tPm5zeW1zCgkJCSYmIGFkZF9zeW1ib2xzX2Zyb20oZiwgU0hOX0hJUkVTRVJWRSArIDIgKyBpLCBtLT5zeW1zLAoJCQkJCQkJCW0tPm5zeW1zKSkgbS0+dXNlZCA9IDEsICsrbnVzZWQ7CgoJbl9leHRfbW9kdWxlc191c2VkID0gbnVzZWQ7CgoJLyogQW5kIGZpbmFsbHkgdGhlIHN5bWJvbHMgZnJvbSB0aGUga2VybmVsIHByb3Blci4gICovCgoJaWYgKG5rc3ltcykKCQlhZGRfc3ltYm9sc19mcm9tKGYsIFNITl9ISVJFU0VSVkUgKyAxLCBrc3ltcywgbmtzeW1zKTsKfQoKc3RhdGljIGNoYXIgKmdldF9tb2RpbmZvX3ZhbHVlKHN0cnVjdCBvYmpfZmlsZSAqZiwgY29uc3QgY2hhciAqa2V5KQp7CglzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnNlYzsKCWNoYXIgKnAsICp2LCAqbiwgKmVwOwoJc2l6ZV90IGtsZW4gPSBzdHJsZW4oa2V5KTsKCglzZWMgPSBvYmpfZmluZF9zZWN0aW9uKGYsICIubW9kaW5mbyIpOwoJaWYgKHNlYyA9PSBOVUxMKQoJCXJldHVybiBOVUxMOwoJcCA9IHNlYy0+Y29udGVudHM7CgllcCA9IHAgKyBzZWMtPmhlYWRlci5zaF9zaXplOwoJd2hpbGUgKHAgPCBlcCkgewoJCXYgPSBzdHJjaHIocCwgJz0nKTsKCQluID0gc3RyY2hyKHAsICdcMCcpOwoJCWlmICh2KSB7CgkJCWlmICh2IC0gcCA9PSBrbGVuICYmIHN0cm5jbXAocCwga2V5LCBrbGVuKSA9PSAwKQoJCQkJcmV0dXJuIHYgKyAxOwoJCX0gZWxzZSB7CgkJCWlmIChuIC0gcCA9PSBrbGVuICYmIHN0cmNtcChwLCBrZXkpID09IDApCgkJCQlyZXR1cm4gbjsKCQl9CgkJcCA9IG4gKyAxOwoJfQoKCXJldHVybiBOVUxMOwp9CgoKLyo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ki8KLyogRnVuY3Rpb25zIHJlbGF0aW5nIHRvIG1vZHVsZSBsb2FkaW5nIGluIHByZSAyLjEga2VybmVscy4gICovCgpzdGF0aWMgaW50Cm9sZF9wcm9jZXNzX21vZHVsZV9hcmd1bWVudHMoc3RydWN0IG9ial9maWxlICpmLCBpbnQgYXJnYywgY2hhciAqKmFyZ3YpCnsKCXdoaWxlIChhcmdjID4gMCkgewoJCWNoYXIgKnAsICpxOwoJCXN0cnVjdCBvYmpfc3ltYm9sICpzeW07CgkJaW50ICpsb2M7CgoJCXAgPSAqYXJndjsKCQlpZiAoKHEgPSBzdHJjaHIocCwgJz0nKSkgPT0gTlVMTCkKCQkJY29udGludWU7CgkJKnErKyA9ICdcMCc7CgoJCXN5bSA9IG9ial9maW5kX3N5bWJvbChmLCBwKTsKCgkJLyogQWxzbyBjaGVjayB0aGF0IHRoZSBwYXJhbWV0ZXIgd2FzIG5vdCByZXNvbHZlZCBmcm9tIHRoZSBrZXJuZWwuICAqLwoJCWlmIChzeW0gPT0gTlVMTCB8fCBzeW0tPnNlY2lkeCA+IFNITl9ISVJFU0VSVkUpIHsKCQkJZnByaW50ZihzdGRlcnIsICJzeW1ib2wgZm9yIHBhcmFtZXRlciAlcyBub3QgZm91bmRcbiIsIHApOwoJCQlyZXR1cm4gMDsKCQl9CgoJCWxvYyA9IChpbnQgKikgKGYtPnNlY3Rpb25zW3N5bS0+c2VjaWR4XS0+Y29udGVudHMgKyBzeW0tPnZhbHVlKTsKCgkJLyogRG8gQyBxdW90aW5nIGlmIHdlIGJlZ2luIHdpdGggYSAiLiAgKi8KCQlpZiAoKnEgPT0gJyInKSB7CgkJCWNoYXIgKnIsICpzdHI7CgoJCQlzdHIgPSBhbGxvY2Eoc3RybGVuKHEpKTsKCQkJZm9yIChyID0gc3RyLCBxKys7ICpxICE9ICciJzsgKytxLCArK3IpIHsKCQkJCWlmICgqcSA9PSAnXDAnKSB7CgkJCQkJZnByaW50ZihzdGRlcnIsCgkJCQkJCQkiaW1wcm9wZXJseSB0ZXJtaW5hdGVkIHN0cmluZyBhcmd1bWVudCBmb3IgJXNcbiIsCgkJCQkJCQlwKTsKCQkJCQlyZXR1cm4gMDsKCQkJCX0gZWxzZSBpZiAoKnEgPT0gJ1xcJykKCQkJCQlzd2l0Y2ggKCorK3EpIHsKCQkJCQljYXNlICdhJzoKCQkJCQkJKnIgPSAnXGEnOwoJCQkJCQlicmVhazsKCQkJCQljYXNlICdiJzoKCQkJCQkJKnIgPSAnXGInOwoJCQkJCQlicmVhazsKCQkJCQljYXNlICdlJzoKCQkJCQkJKnIgPSAnXDAzMyc7CgkJCQkJCWJyZWFrOwoJCQkJCWNhc2UgJ2YnOgoJCQkJCQkqciA9ICdcZic7CgkJCQkJCWJyZWFrOwoJCQkJCWNhc2UgJ24nOgoJCQkJCQkqciA9ICdcbic7CgkJCQkJCWJyZWFrOwoJCQkJCWNhc2UgJ3InOgoJCQkJCQkqciA9ICdccic7CgkJCQkJCWJyZWFrOwoJCQkJCWNhc2UgJ3QnOgoJCQkJCQkqciA9ICdcdCc7CgkJCQkJCWJyZWFrOwoKCQkJCQljYXNlICcwJzoKCQkJCQljYXNlICcxJzoKCQkJCQljYXNlICcyJzoKCQkJCQljYXNlICczJzoKCQkJCQljYXNlICc0JzoKCQkJCQljYXNlICc1JzoKCQkJCQljYXNlICc2JzoKCQkJCQljYXNlICc3JzoKCQkJCQkJewoJCQkJCQkJaW50IGMgPSAqcSAtICcwJzsKCQkJCQkJCWlmIChxWzFdID49ICcwJyAmJiBxWzFdIDw9ICc3JykgewoJCQkJCQkJCWMgPSAoYyAqIDgpICsgKisrcSAtICcwJzsKCQkJCQkJCQlpZiAocVsxXSA+PSAnMCcgJiYgcVsxXSA8PSAnNycpCgkJCQkJCQkJCWMgPSAoYyAqIDgpICsgKisrcSAtICcwJzsKCQkJCQkJCX0KCQkJCQkJCSpyID0gYzsKCQkJCQkJfQoJCQkJCQlicmVhazsKCgkJCQkJZGVmYXVsdDoKCQkJCQkJKnIgPSAqcTsKCQkJCQkJYnJlYWs7CgkJCQl9IGVsc2UKCQkJCQkqciA9ICpxOwoJCQl9CgkJCSpyID0gJ1wwJzsKCQkJb2JqX3N0cmluZ19wYXRjaChmLCBzeW0tPnNlY2lkeCwgc3ltLT52YWx1ZSwgc3RyKTsKCQl9IGVsc2UgaWYgKCpxID49ICcwJyAmJiAqcSA8PSAnOScpIHsKCQkJZG8KCQkJCSpsb2MrKyA9IHN0cnRvdWwocSwgJnEsIDApOwoJCQl3aGlsZSAoKnErKyA9PSAnLCcpOwoJCX0gZWxzZSB7CgkJCWNoYXIgKmNvbnRlbnRzID0gZi0+c2VjdGlvbnNbc3ltLT5zZWNpZHhdLT5jb250ZW50czsKCQkJY2hhciAqbG9jID0gY29udGVudHMgKyBzeW0tPnZhbHVlOwoJCQljaGFyICpyOwkJCS8qIFRvIHNlYXJjaCBmb3IgY29tbWFzICovCgoJCQkvKiBCcmVhayB0aGUgc3RyaW5nIHdpdGggY29tYXMgKi8KCQkJd2hpbGUgKChyID0gc3RyY2hyKHEsICcsJykpICE9IChjaGFyICopIE5VTEwpIHsKCQkJCSpyKysgPSAnXDAnOwoJCQkJb2JqX3N0cmluZ19wYXRjaChmLCBzeW0tPnNlY2lkeCwgbG9jIC0gY29udGVudHMsIHEpOwoJCQkJbG9jICs9IHNpemVvZihjaGFyICopOwoJCQkJcSA9IHI7CgkJCX0KCgkJCS8qIGxhc3QgcGFydCAqLwoJCQlvYmpfc3RyaW5nX3BhdGNoKGYsIHN5bS0+c2VjaWR4LCBsb2MgLSBjb250ZW50cywgcSk7CgkJfQoKCQlhcmdjLS0sIGFyZ3YrKzsKCX0KCglyZXR1cm4gMTsKfQoKI2lmZGVmIEJCX0ZFQVRVUkVfSU5TTU9EX1ZFUlNJT05fQ0hFQ0tJTkcKc3RhdGljIGludCBvbGRfaXNfbW9kdWxlX2NoZWNrc3VtbWVkKHN0cnVjdCBvYmpfZmlsZSAqZikKewoJcmV0dXJuIG9ial9maW5kX3N5bWJvbChmLCAiVXNpbmdfVmVyc2lvbnMiKSAhPSBOVUxMOwp9Ci8qIEdldCB0aGUgbW9kdWxlJ3Mga2VybmVsIHZlcnNpb24gaW4gdGhlIGNhbm9uaWNhbCBpbnRlZ2VyIGZvcm0uICAqLwoKc3RhdGljIGludApvbGRfZ2V0X21vZHVsZV92ZXJzaW9uKHN0cnVjdCBvYmpfZmlsZSAqZiwgY2hhciBzdHJbU1RSVkVSU0lPTkxFTl0pCnsKCXN0cnVjdCBvYmpfc3ltYm9sICpzeW07CgljaGFyICpwLCAqcTsKCWludCBhLCBiLCBjOwoKCXN5bSA9IG9ial9maW5kX3N5bWJvbChmLCAia2VybmVsX3ZlcnNpb24iKTsKCWlmIChzeW0gPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgoJcCA9IGYtPnNlY3Rpb25zW3N5bS0+c2VjaWR4XS0+Y29udGVudHMgKyBzeW0tPnZhbHVlOwoJc3RybmNweShzdHIsIHAsIFNUUlZFUlNJT05MRU4pOwoKCWEgPSBzdHJ0b3VsKHAsICZwLCAxMCk7CglpZiAoKnAgIT0gJy4nKQoJCXJldHVybiAtMTsKCWIgPSBzdHJ0b3VsKHAgKyAxLCAmcCwgMTApOwoJaWYgKCpwICE9ICcuJykKCQlyZXR1cm4gLTE7CgljID0gc3RydG91bChwICsgMSwgJnEsIDEwKTsKCWlmIChwICsgMSA9PSBxKQoJCXJldHVybiAtMTsKCglyZXR1cm4gYSA8PCAxNiB8IGIgPDwgOCB8IGM7Cn0KCiNlbmRpZiAgIC8qIEJCX0ZFQVRVUkVfSU5TTU9EX1ZFUlNJT05fQ0hFQ0tJTkcgKi8KCiNpZmRlZiBCQl9GRUFUVVJFX0lOU01PRF9PTERfS0VSTkVMCgovKiBGZXRjaCBhbGwgdGhlIHN5bWJvbHMgYW5kIGRpdnZ5IHRoZW0gdXAgYXMgYXBwcm9wcmlhdGUgZm9yIHRoZSBtb2R1bGVzLiAgKi8KCnN0YXRpYyBpbnQgb2xkX2dldF9rZXJuZWxfc3ltYm9scyh2b2lkKQp7CglzdHJ1Y3Qgb2xkX2tlcm5lbF9zeW0gKmtzLCAqazsKCXN0cnVjdCBuZXdfbW9kdWxlX3N5bWJvbCAqczsKCXN0cnVjdCBleHRlcm5hbF9tb2R1bGUgKm1vZDsKCWludCBua3MsIG5tcywgbm1vZCwgaTsKCglua3MgPSBnZXRfa2VybmVsX3N5bXMoTlVMTCk7CglpZiAobmtzIDwgMCkgewoJCXBlcnJvcigiZ2V0X2tlcm5lbF9zeW1zOiAlbSIpOwoJCXJldHVybiAwOwoJfQoKCWtzID0gayA9IHhtYWxsb2MobmtzICogc2l6ZW9mKCprcykpOwoKCWlmIChnZXRfa2VybmVsX3N5bXMoa3MpICE9IG5rcykgewoJCXBlcnJvcigiaW5jb25zaXN0ZW5jeSB3aXRoIGdldF9rZXJuZWxfc3ltcyAtLSBpcyBzb21lb25lIGVsc2UgIgoJCQkgICAicGxheWluZyB3aXRoIG1vZHVsZXM/Iik7CgkJZnJlZShrcyk7CgkJcmV0dXJuIDA7Cgl9CgoJLyogQ29sbGVjdCB0aGUgbW9kdWxlIGluZm9ybWF0aW9uLiAgKi8KCgltb2QgPSBOVUxMOwoJbm1vZCA9IC0xOwoKCXdoaWxlIChrLT5uYW1lWzBdID09ICcjJyAmJiBrLT5uYW1lWzFdKSB7CgkJc3RydWN0IG9sZF9rZXJuZWxfc3ltICprMjsKCQlzdHJ1Y3QgbmV3X21vZHVsZV9zeW1ib2wgKnM7CgoJCS8qIEZpbmQgb3V0IGhvdyBtYW55IHN5bWJvbHMgdGhpcyBtb2R1bGUgaGFzLiAgKi8KCQlmb3IgKGsyID0gayArIDE7IGsyLT5uYW1lWzBdICE9ICcjJzsgKytrMikKCQkJY29udGludWU7CgkJbm1zID0gazIgLSBrIC0gMTsKCgkJbW9kID0geHJlYWxsb2MobW9kLCAoKytubW9kICsgMSkgKiBzaXplb2YoKm1vZCkpOwoJCW1vZFtubW9kXS5uYW1lID0gay0+bmFtZSArIDE7CgkJbW9kW25tb2RdLmFkZHIgPSBrLT52YWx1ZTsKCQltb2Rbbm1vZF0udXNlZCA9IDA7CgkJbW9kW25tb2RdLm5zeW1zID0gbm1zOwoJCW1vZFtubW9kXS5zeW1zID0gcyA9IChubXMgPyB4bWFsbG9jKG5tcyAqIHNpemVvZigqcykpIDogTlVMTCk7CgoJCWZvciAoaSA9IDAsICsrazsgaSA8IG5tczsgKytpLCArK3MsICsraykgewoJCQlzLT5uYW1lID0gKHVuc2lnbmVkIGxvbmcpIGstPm5hbWU7CgkJCXMtPnZhbHVlID0gay0+dmFsdWU7CgkJfQoKCQlrID0gazI7Cgl9CgoJZXh0X21vZHVsZXMgPSBtb2Q7CgluX2V4dF9tb2R1bGVzID0gbm1vZCArIDE7CgoJLyogTm93IGNvbGxlY3QgdGhlIHN5bWJvbHMgZm9yIHRoZSBrZXJuZWwgcHJvcGVyLiAgKi8KCglpZiAoay0+bmFtZVswXSA9PSAnIycpCgkJKytrOwoKCW5rc3ltcyA9IG5tcyA9IG5rcyAtIChrIC0ga3MpOwoJa3N5bXMgPSBzID0gKG5tcyA/IHhtYWxsb2Mobm1zICogc2l6ZW9mKCpzKSkgOiBOVUxMKTsKCglmb3IgKGkgPSAwOyBpIDwgbm1zOyArK2ksICsrcywgKytrKSB7CgkJcy0+bmFtZSA9ICh1bnNpZ25lZCBsb25nKSBrLT5uYW1lOwoJCXMtPnZhbHVlID0gay0+dmFsdWU7Cgl9CgoJcmV0dXJuIDE7Cn0KCi8qIFJldHVybiB0aGUga2VybmVsIHN5bWJvbCBjaGVja3N1bSB2ZXJzaW9uLCBvciB6ZXJvIGlmIG5vdCB1c2VkLiAgKi8KCnN0YXRpYyBpbnQgb2xkX2lzX2tlcm5lbF9jaGVja3N1bW1lZCh2b2lkKQp7CgkvKiBVc2luZ19WZXJzaW9ucyBpcyB0aGUgZmlyc3Qgc3ltYm9sLiAgKi8KCWlmIChua3N5bXMgPiAwCgkJJiYgc3RyY21wKChjaGFyICopIGtzeW1zWzBdLm5hbWUsCgkJCQkgICJVc2luZ19WZXJzaW9ucyIpID09IDApIHJldHVybiBrc3ltc1swXS52YWx1ZTsKCWVsc2UKCQlyZXR1cm4gMDsKfQoKCnN0YXRpYyBpbnQgb2xkX2NyZWF0ZV9tb2RfdXNlX2NvdW50KHN0cnVjdCBvYmpfZmlsZSAqZikKewoJc3RydWN0IG9ial9zZWN0aW9uICpzZWM7CgoJc2VjID0gb2JqX2NyZWF0ZV9hbGxvY2VkX3NlY3Rpb25fZmlyc3QoZiwgIi5tb2R1c2UiLCBzaXplb2YobG9uZyksCgkJCQkJCQkJCQkgICBzaXplb2YobG9uZykpOwoKCW9ial9hZGRfc3ltYm9sKGYsICJtb2RfdXNlX2NvdW50XyIsIC0xLAoJCQkJICAgRUxGVyhTVF9JTkZPKSAoU1RCX0xPQ0FMLCBTVFRfT0JKRUNUKSwgc2VjLT5pZHgsIDAsCgkJCQkgICBzaXplb2YobG9uZykpOwoKCXJldHVybiAxOwp9CgpzdGF0aWMgaW50Cm9sZF9pbml0X21vZHVsZShjb25zdCBjaGFyICptX25hbWUsIHN0cnVjdCBvYmpfZmlsZSAqZiwKCQkJCXVuc2lnbmVkIGxvbmcgbV9zaXplKQp7CgljaGFyICppbWFnZTsKCXN0cnVjdCBvbGRfbW9kX3JvdXRpbmVzIHJvdXRpbmVzOwoJc3RydWN0IG9sZF9zeW1ib2xfdGFibGUgKnN5bXRhYjsKCWludCByZXQ7CgoJLyogQ3JlYXRlIHRoZSBzeW1ib2wgdGFibGUgKi8KCXsKCQlpbnQgbnN5bXMgPSAwLCBzdHJzaXplID0gMCwgdG90YWw7CgoJCS8qIFNpemUgdGhpbmdzIGZpcnN0Li4uICovCgkJaWYgKGZsYWdfZXhwb3J0KSB7CgkJCWludCBpOwoJCQlmb3IgKGkgPSAwOyBpIDwgSEFTSF9CVUNLRVRTOyArK2kpIHsKCQkJCXN0cnVjdCBvYmpfc3ltYm9sICpzeW07CgkJCQlmb3IgKHN5bSA9IGYtPnN5bXRhYltpXTsgc3ltOyBzeW0gPSBzeW0tPm5leHQpCgkJCQkJaWYgKEVMRlcoU1RfQklORCkgKHN5bS0+aW5mbykgIT0gU1RCX0xPQ0FMCgkJCQkJCSYmIHN5bS0+c2VjaWR4IDw9IFNITl9ISVJFU0VSVkUpIAoJCQkJCXsKCQkJCQkJc3ltLT5rc3ltaWR4ID0gbnN5bXMrKzsKCQkJCQkJc3Ryc2l6ZSArPSBzdHJsZW4oc3ltLT5uYW1lKSArIDE7CgkJCQkJfQoJCQl9CgkJfQoKCQl0b3RhbCA9IChzaXplb2Yoc3RydWN0IG9sZF9zeW1ib2xfdGFibGUpCgkJCQkgKyBuc3ltcyAqIHNpemVvZihzdHJ1Y3Qgb2xkX21vZHVsZV9zeW1ib2wpCgkJCQkgKyBuX2V4dF9tb2R1bGVzX3VzZWQgKiBzaXplb2Yoc3RydWN0IG9sZF9tb2R1bGVfcmVmKQoJCQkJICsgc3Ryc2l6ZSk7CgkJc3ltdGFiID0geG1hbGxvYyh0b3RhbCk7CgkJc3ltdGFiLT5zaXplID0gdG90YWw7CgkJc3ltdGFiLT5uX3N5bWJvbHMgPSBuc3ltczsKCQlzeW10YWItPm5fcmVmcyA9IG5fZXh0X21vZHVsZXNfdXNlZDsKCgkJaWYgKGZsYWdfZXhwb3J0ICYmIG5zeW1zKSB7CgkJCXN0cnVjdCBvbGRfbW9kdWxlX3N5bWJvbCAqa3N5bTsKCQkJY2hhciAqc3RyOwoJCQlpbnQgaTsKCgkJCWtzeW0gPSBzeW10YWItPnN5bWJvbDsKCQkJc3RyID0gKChjaGFyICopIGtzeW0gKyBuc3ltcyAqIHNpemVvZihzdHJ1Y3Qgb2xkX21vZHVsZV9zeW1ib2wpCgkJCQkgICArIG5fZXh0X21vZHVsZXNfdXNlZCAqIHNpemVvZihzdHJ1Y3Qgb2xkX21vZHVsZV9yZWYpKTsKCgkJCWZvciAoaSA9IDA7IGkgPCBIQVNIX0JVQ0tFVFM7ICsraSkgewoJCQkJc3RydWN0IG9ial9zeW1ib2wgKnN5bTsKCQkJCWZvciAoc3ltID0gZi0+c3ltdGFiW2ldOyBzeW07IHN5bSA9IHN5bS0+bmV4dCkKCQkJCQlpZiAoc3ltLT5rc3ltaWR4ID49IDApIHsKCQkJCQkJa3N5bS0+YWRkciA9IG9ial9zeW1ib2xfZmluYWxfdmFsdWUoZiwgc3ltKTsKCQkJCQkJa3N5bS0+bmFtZSA9CgkJCQkJCQkodW5zaWduZWQgbG9uZykgc3RyIC0gKHVuc2lnbmVkIGxvbmcpIHN5bXRhYjsKCgkJCQkJCXN0ciA9IHN0cGNweShzdHIsIHN5bS0+bmFtZSkgKyAxOwoJCQkJCQlrc3ltKys7CgkJCQkJfQoJCQl9CgkJfQoKCQlpZiAobl9leHRfbW9kdWxlc191c2VkKSB7CgkJCXN0cnVjdCBvbGRfbW9kdWxlX3JlZiAqcmVmOwoJCQlpbnQgaTsKCgkJCXJlZiA9IChzdHJ1Y3Qgb2xkX21vZHVsZV9yZWYgKikKCQkJCSgoY2hhciAqKSBzeW10YWItPnN5bWJvbCArIG5zeW1zICogc2l6ZW9mKHN0cnVjdCBvbGRfbW9kdWxlX3N5bWJvbCkpOwoKCQkJZm9yIChpID0gMDsgaSA8IG5fZXh0X21vZHVsZXM7ICsraSkKCQkJCWlmIChleHRfbW9kdWxlc1tpXS51c2VkKQoJCQkJCXJlZisrLT5tb2R1bGUgPSBleHRfbW9kdWxlc1tpXS5hZGRyOwoJCX0KCX0KCgkvKiBGaWxsIGluIHJvdXRpbmVzLiAgKi8KCglyb3V0aW5lcy5pbml0ID0KCQlvYmpfc3ltYm9sX2ZpbmFsX3ZhbHVlKGYsIG9ial9maW5kX3N5bWJvbChmLCAiaW5pdF9tb2R1bGUiKSk7Cglyb3V0aW5lcy5jbGVhbnVwID0KCQlvYmpfc3ltYm9sX2ZpbmFsX3ZhbHVlKGYsIG9ial9maW5kX3N5bWJvbChmLCAiY2xlYW51cF9tb2R1bGUiKSk7CgoJLyogV2hldyEgIEFsbCBvZiB0aGUgaW5pdGlhbGl6YXRpb24gaXMgY29tcGxldGUuICBDb2xsZWN0IHRoZSBmaW5hbAoJICAgbW9kdWxlIGltYWdlIGFuZCBnaXZlIGl0IHRvIHRoZSBrZXJuZWwuICAqLwoKCWltYWdlID0geG1hbGxvYyhtX3NpemUpOwoJb2JqX2NyZWF0ZV9pbWFnZShmLCBpbWFnZSk7CgoJLyogaW1hZ2UgaG9sZHMgdGhlIGNvbXBsZXRlIHJlbG9jYXRlZCBtb2R1bGUsIGFjY291bnRpbmcgY29ycmVjdGx5IGZvcgoJICAgbW9kX3VzZV9jb3VudC4gIEhvd2V2ZXIgdGhlIG9sZCBtb2R1bGUga2VybmVsIHN1cHBvcnQgYXNzdW1lIHRoYXQKCSAgIGl0IGlzIHJlY2VpdmluZyBzb21ldGhpbmcgd2hpY2ggZG9lcyBub3QgY29udGFpbiBtb2RfdXNlX2NvdW50LiAgKi8KCXJldCA9IG9sZF9zeXNfaW5pdF9tb2R1bGUobV9uYW1lLCBpbWFnZSArIHNpemVvZihsb25nKSwKCQkJCQkJCSAgbV9zaXplIHwgKGZsYWdfYXV0b2NsZWFuID8gT0xEX01PRF9BVVRPQ0xFQU4KCQkJCQkJCQkJCTogMCksICZyb3V0aW5lcywgc3ltdGFiKTsKCWlmIChyZXQpCgkJcGVycm9yKCJpbml0X21vZHVsZTogJW0iKTsKCglmcmVlKGltYWdlKTsKCWZyZWUoc3ltdGFiKTsKCglyZXR1cm4gcmV0ID09IDA7Cn0KCiNlbHNlCgojZGVmaW5lIG9sZF9jcmVhdGVfbW9kX3VzZV9jb3VudCh4KSBUUlVFCiNkZWZpbmUgb2xkX2luaXRfbW9kdWxlKHgsIHksIHopIFRSVUUKCiNlbmRpZgkJCQkJCQkvKiBCQl9GRUFUVVJFX0lOU01PRF9PTERfS0VSTkVMICovCgoKCi8qPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSovCi8qIEZ1bmN0aW9ucyByZWxhdGluZyB0byBtb2R1bGUgbG9hZGluZyBhZnRlciAyLjEuMTguICAqLwoKc3RhdGljIGludApuZXdfcHJvY2Vzc19tb2R1bGVfYXJndW1lbnRzKHN0cnVjdCBvYmpfZmlsZSAqZiwgaW50IGFyZ2MsIGNoYXIgKiphcmd2KQp7Cgl3aGlsZSAoYXJnYyA+IDApIHsKCQljaGFyICpwLCAqcSwgKmtleTsKCQlzdHJ1Y3Qgb2JqX3N5bWJvbCAqc3ltOwoJCWNoYXIgKmNvbnRlbnRzLCAqbG9jOwoJCWludCBtaW4sIG1heCwgbjsKCgkJcCA9ICphcmd2OwoJCWlmICgocSA9IHN0cmNocihwLCAnPScpKSA9PSBOVUxMKQoJCQljb250aW51ZTsKCgkJa2V5ID0gYWxsb2NhKHEgLSBwICsgNik7CgkJbWVtY3B5KGtleSwgInBhcm1fIiwgNSk7CgkJbWVtY3B5KGtleSArIDUsIHAsIHEgLSBwKTsKCQlrZXlbcSAtIHAgKyA1XSA9IDA7CgoJCXAgPSBnZXRfbW9kaW5mb192YWx1ZShmLCBrZXkpOwoJCWtleSArPSA1OwoJCWlmIChwID09IE5VTEwpIHsKCQkJZnByaW50ZihzdGRlcnIsICJpbnZhbGlkIHBhcmFtZXRlciAlc1xuIiwga2V5KTsKCQkJcmV0dXJuIDA7CgkJfQoKCQlzeW0gPSBvYmpfZmluZF9zeW1ib2woZiwga2V5KTsKCgkJLyogQWxzbyBjaGVjayB0aGF0IHRoZSBwYXJhbWV0ZXIgd2FzIG5vdCByZXNvbHZlZCBmcm9tIHRoZSBrZXJuZWwuICAqLwoJCWlmIChzeW0gPT0gTlVMTCB8fCBzeW0tPnNlY2lkeCA+IFNITl9ISVJFU0VSVkUpIHsKCQkJZnByaW50ZihzdGRlcnIsICJzeW1ib2wgZm9yIHBhcmFtZXRlciAlcyBub3QgZm91bmRcbiIsIGtleSk7CgkJCXJldHVybiAwOwoJCX0KCgkJaWYgKGlzZGlnaXQoKnApKSB7CgkJCW1pbiA9IHN0cnRvdWwocCwgJnAsIDEwKTsKCQkJaWYgKCpwID09ICctJykKCQkJCW1heCA9IHN0cnRvdWwocCArIDEsICZwLCAxMCk7CgkJCWVsc2UKCQkJCW1heCA9IG1pbjsKCQl9IGVsc2UKCQkJbWluID0gbWF4ID0gMTsKCgkJY29udGVudHMgPSBmLT5zZWN0aW9uc1tzeW0tPnNlY2lkeF0tPmNvbnRlbnRzOwoJCWxvYyA9IGNvbnRlbnRzICsgc3ltLT52YWx1ZTsKCQluID0gKCorK3EgIT0gJ1wwJyk7CgoJCXdoaWxlICgxKSB7CgkJCWlmICgoKnAgPT0gJ3MnKSB8fCAoKnAgPT0gJ2MnKSkgewoJCQkJY2hhciAqc3RyOwoKCQkJCS8qIERvIEMgcXVvdGluZyBpZiB3ZSBiZWdpbiB3aXRoIGEgIiwgZWxzZSBzbHVycCB0aGUgbG90LiAgKi8KCQkJCWlmICgqcSA9PSAnIicpIHsKCQkJCQljaGFyICpyOwoKCQkJCQlzdHIgPSBhbGxvY2Eoc3RybGVuKHEpKTsKCQkJCQlmb3IgKHIgPSBzdHIsIHErKzsgKnEgIT0gJyInOyArK3EsICsrcikgewoJCQkJCQlpZiAoKnEgPT0gJ1wwJykgewoJCQkJCQkJZnByaW50ZihzdGRlcnIsCgkJCQkJCQkJCSJpbXByb3Blcmx5IHRlcm1pbmF0ZWQgc3RyaW5nIGFyZ3VtZW50IGZvciAlc1xuIiwKCQkJCQkJCQkJa2V5KTsKCQkJCQkJCXJldHVybiAwOwoJCQkJCQl9IGVsc2UgaWYgKCpxID09ICdcXCcpCgkJCQkJCQlzd2l0Y2ggKCorK3EpIHsKCQkJCQkJCWNhc2UgJ2EnOgoJCQkJCQkJCSpyID0gJ1xhJzsKCQkJCQkJCQlicmVhazsKCQkJCQkJCWNhc2UgJ2InOgoJCQkJCQkJCSpyID0gJ1xiJzsKCQkJCQkJCQlicmVhazsKCQkJCQkJCWNhc2UgJ2UnOgoJCQkJCQkJCSpyID0gJ1wwMzMnOwoJCQkJCQkJCWJyZWFrOwoJCQkJCQkJY2FzZSAnZic6CgkJCQkJCQkJKnIgPSAnXGYnOwoJCQkJCQkJCWJyZWFrOwoJCQkJCQkJY2FzZSAnbic6CgkJCQkJCQkJKnIgPSAnXG4nOwoJCQkJCQkJCWJyZWFrOwoJCQkJCQkJY2FzZSAncic6CgkJCQkJCQkJKnIgPSAnXHInOwoJCQkJCQkJCWJyZWFrOwoJCQkJCQkJY2FzZSAndCc6CgkJCQkJCQkJKnIgPSAnXHQnOwoJCQkJCQkJCWJyZWFrOwoKCQkJCQkJCWNhc2UgJzAnOgoJCQkJCQkJY2FzZSAnMSc6CgkJCQkJCQljYXNlICcyJzoKCQkJCQkJCWNhc2UgJzMnOgoJCQkJCQkJY2FzZSAnNCc6CgkJCQkJCQljYXNlICc1JzoKCQkJCQkJCWNhc2UgJzYnOgoJCQkJCQkJY2FzZSAnNyc6CgkJCQkJCQkJewoJCQkJCQkJCQlpbnQgYyA9ICpxIC0gJzAnOwoJCQkJCQkJCQlpZiAocVsxXSA+PSAnMCcgJiYgcVsxXSA8PSAnNycpIHsKCQkJCQkJCQkJCWMgPSAoYyAqIDgpICsgKisrcSAtICcwJzsKCQkJCQkJCQkJCWlmIChxWzFdID49ICcwJyAmJiBxWzFdIDw9ICc3JykKCQkJCQkJCQkJCQljID0gKGMgKiA4KSArICorK3EgLSAnMCc7CgkJCQkJCQkJCX0KCQkJCQkJCQkJKnIgPSBjOwoJCQkJCQkJCX0KCQkJCQkJCQlicmVhazsKCgkJCQkJCQlkZWZhdWx0OgoJCQkJCQkJCSpyID0gKnE7CgkJCQkJCQkJYnJlYWs7CgkJCQkJCX0gZWxzZQoJCQkJCQkJKnIgPSAqcTsKCQkJCQl9CgkJCQkJKnIgPSAnXDAnOwoJCQkJCSsrcTsKCQkJCX0gZWxzZSB7CgkJCQkJY2hhciAqcjsKCgkJCQkJLyogSW4gdGhpcyBjYXNlLCB0aGUgc3RyaW5nIGlzIG5vdCBxdW90ZWQuIFdlIHdpbGwgYnJlYWsKCQkJCQkgICBpdCB1c2luZyB0aGUgY29tYSAobGlrZSBmb3IgaW50cykuIElmIHRoZSB1c2VyIHdhbnRzIHRvCgkJCQkJICAgaW5jbHVkZSBjb21hcyBpbiBhIHN0cmluZywgaGUganVzdCBoYXMgdG8gcXVvdGUgaXQgKi8KCgkJCQkJLyogU2VhcmNoIHRoZSBuZXh0IGNvbWEgKi8KCQkJCQlyID0gc3RyY2hyKHEsICcsJyk7CgoJCQkJCS8qIEZvdW5kID8gKi8KCQkJCQlpZiAociAhPSAoY2hhciAqKSBOVUxMKSB7CgkJCQkJCS8qIFJlY29weSB0aGUgY3VycmVudCBmaWVsZCAqLwoJCQkJCQlzdHIgPSBhbGxvY2EociAtIHEgKyAxKTsKCQkJCQkJbWVtY3B5KHN0ciwgcSwgciAtIHEpOwoKCQkJCQkJLyogSSBkb24ndCBrbm93IGlmIGl0IGlzIHVzZWZ1bGwsIGFzIHRoZSBwcmV2aW91cyBjYXNlCgkJCQkJCSAgIGRvZXNuJ3QgbnVsbCB0ZXJtaW5hdGUgdGhlIHN0cmluZyA/Pz8gKi8KCQkJCQkJc3RyW3IgLSBxXSA9ICdcMCc7CgoJCQkJCQkvKiBLZWVwIG5leHQgZmllbGRzICovCgkJCQkJCXEgPSByOwoJCQkJCX0gZWxzZSB7CgkJCQkJCS8qIGxhc3Qgc3RyaW5nICovCgkJCQkJCXN0ciA9IHE7CgkJCQkJCXEgPSAiIjsKCQkJCQl9CgkJCQl9CgoJCQkJaWYgKCpwID09ICdzJykgewoJCQkJCS8qIE5vcm1hbCBzdHJpbmcgKi8KCQkJCQlvYmpfc3RyaW5nX3BhdGNoKGYsIHN5bS0+c2VjaWR4LCBsb2MgLSBjb250ZW50cywgc3RyKTsKCQkJCQlsb2MgKz0gdGd0X3NpemVvZl9jaGFyX3A7CgkJCQl9IGVsc2UgewoJCQkJCS8qIEFycmF5IG9mIGNoYXJzIChpbiBmYWN0LCBtYXRyaXggISkgKi8KCQkJCQlsb25nIGNoYXJzc2l6ZTsJLyogc2l6ZSBvZiBlYWNoIG1lbWJlciAqLwoKCQkJCQkvKiBHZXQgdGhlIHNpemUgb2YgZWFjaCBtZW1iZXIgKi8KCQkJCQkvKiBQcm9iYWJseSB3ZSBzaG91bGQgZG8gdGhhdCBvdXRzaWRlIHRoZSBsb29wID8gKi8KCQkJCQlpZiAoIWlzZGlnaXQoKihwICsgMSkpKSB7CgkJCQkJCWZwcmludGYoc3RkZXJyLAoJCQkJCQkJCSJwYXJhbWV0ZXIgdHlwZSAnYycgZm9yICVzIG11c3QgYmUgZm9sbG93ZWQgYnkiCgkJCQkJCQkJIiB0aGUgbWF4aW11bSBzaXplXG4iLCBrZXkpOwoJCQkJCQlyZXR1cm4gMDsKCQkJCQl9CgkJCQkJY2hhcnNzaXplID0gc3RydG91bChwICsgMSwgKGNoYXIgKiopIE5VTEwsIDEwKTsKCgkJCQkJLyogQ2hlY2sgbGVuZ3RoICovCgkJCQkJaWYgKHN0cmxlbihzdHIpID49IGNoYXJzc2l6ZSkgewoJCQkJCQlmcHJpbnRmKHN0ZGVyciwKCQkJCQkJCQkic3RyaW5nIHRvbyBsb25nIGZvciAlcyAobWF4ICVsZClcbiIsIGtleSwKCQkJCQkJCQljaGFyc3NpemUgLSAxKTsKCQkJCQkJcmV0dXJuIDA7CgkJCQkJfQoKCQkJCQkvKiBDb3B5IHRvIGxvY2F0aW9uICovCgkJCQkJc3RyY3B5KChjaGFyICopIGxvYywgc3RyKTsKCQkJCQlsb2MgKz0gY2hhcnNzaXplOwoJCQkJfQoJCQl9IGVsc2UgewoJCQkJbG9uZyB2ID0gc3RydG91bChxLCAmcSwgMCk7CgkJCQlzd2l0Y2ggKCpwKSB7CgkJCQljYXNlICdiJzoKCQkJCQkqbG9jKysgPSB2OwoJCQkJCWJyZWFrOwoJCQkJY2FzZSAnaCc6CgkJCQkJKihzaG9ydCAqKSBsb2MgPSB2OwoJCQkJCWxvYyArPSB0Z3Rfc2l6ZW9mX3Nob3J0OwoJCQkJCWJyZWFrOwoJCQkJY2FzZSAnaSc6CgkJCQkJKihpbnQgKikgbG9jID0gdjsKCQkJCQlsb2MgKz0gdGd0X3NpemVvZl9pbnQ7CgkJCQkJYnJlYWs7CgkJCQljYXNlICdsJzoKCQkJCQkqKGxvbmcgKikgbG9jID0gdjsKCQkJCQlsb2MgKz0gdGd0X3NpemVvZl9sb25nOwoJCQkJCWJyZWFrOwoKCQkJCWRlZmF1bHQ6CgkJCQkJZnByaW50ZihzdGRlcnIsICJ1bmtub3duIHBhcmFtZXRlciB0eXBlICclYycgZm9yICVzXG4iLAoJCQkJCQkJKnAsIGtleSk7CgkJCQkJcmV0dXJuIDA7CgkJCQl9CgkJCX0KCgkJICByZXRyeV9lbmRfb2ZfdmFsdWU6CgkJCXN3aXRjaCAoKnEpIHsKCQkJY2FzZSAnXDAnOgoJCQkJZ290byBlbmRfb2ZfYXJnOwoKCQkJY2FzZSAnICc6CgkJCWNhc2UgJ1x0JzoKCQkJY2FzZSAnXG4nOgoJCQljYXNlICdccic6CgkJCQkrK3E7CgkJCQlnb3RvIHJldHJ5X2VuZF9vZl92YWx1ZTsKCgkJCWNhc2UgJywnOgoJCQkJaWYgKCsrbiA+IG1heCkgewoJCQkJCWZwcmludGYoc3RkZXJyLCAidG9vIG1hbnkgdmFsdWVzIGZvciAlcyAobWF4ICVkKVxuIiwKCQkJCQkJCWtleSwgbWF4KTsKCQkJCQlyZXR1cm4gMDsKCQkJCX0KCQkJCSsrcTsKCQkJCWJyZWFrOwoKCQkJZGVmYXVsdDoKCQkJCWZwcmludGYoc3RkZXJyLCAiaW52YWxpZCBhcmd1bWVudCBzeW50YXggZm9yICVzXG4iLCBrZXkpOwoJCQkJcmV0dXJuIDA7CgkJCX0KCQl9CgoJICBlbmRfb2ZfYXJnOgoJCWlmIChuIDwgbWluKSB7CgkJCWZwcmludGYoc3RkZXJyLCAidG9vIGZldyB2YWx1ZXMgZm9yICVzIChtaW4gJWQpXG4iLCBrZXksIG1pbik7CgkJCXJldHVybiAwOwoJCX0KCgkJYXJnYy0tLCBhcmd2Kys7Cgl9CgoJcmV0dXJuIDE7Cn0KCiNpZmRlZiBCQl9GRUFUVVJFX0lOU01PRF9WRVJTSU9OX0NIRUNLSU5HCnN0YXRpYyBpbnQgbmV3X2lzX21vZHVsZV9jaGVja3N1bW1lZChzdHJ1Y3Qgb2JqX2ZpbGUgKmYpCnsKCWNvbnN0IGNoYXIgKnAgPSBnZXRfbW9kaW5mb192YWx1ZShmLCAidXNpbmdfY2hlY2tzdW1zIik7CglpZiAocCkKCQlyZXR1cm4gYXRvaShwKTsKCWVsc2UKCQlyZXR1cm4gMDsKfQoKLyogR2V0IHRoZSBtb2R1bGUncyBrZXJuZWwgdmVyc2lvbiBpbiB0aGUgY2Fub25pY2FsIGludGVnZXIgZm9ybS4gICovCgpzdGF0aWMgaW50Cm5ld19nZXRfbW9kdWxlX3ZlcnNpb24oc3RydWN0IG9ial9maWxlICpmLCBjaGFyIHN0cltTVFJWRVJTSU9OTEVOXSkKewoJY2hhciAqcCwgKnE7CglpbnQgYSwgYiwgYzsKCglwID0gZ2V0X21vZGluZm9fdmFsdWUoZiwgImtlcm5lbF92ZXJzaW9uIik7CglpZiAocCA9PSBOVUxMKQoJCXJldHVybiAtMTsKCXN0cm5jcHkoc3RyLCBwLCBTVFJWRVJTSU9OTEVOKTsKCglhID0gc3RydG91bChwLCAmcCwgMTApOwoJaWYgKCpwICE9ICcuJykKCQlyZXR1cm4gLTE7CgliID0gc3RydG91bChwICsgMSwgJnAsIDEwKTsKCWlmICgqcCAhPSAnLicpCgkJcmV0dXJuIC0xOwoJYyA9IHN0cnRvdWwocCArIDEsICZxLCAxMCk7CglpZiAocCArIDEgPT0gcSkKCQlyZXR1cm4gLTE7CgoJcmV0dXJuIGEgPDwgMTYgfCBiIDw8IDggfCBjOwp9CgojZW5kaWYgICAvKiBCQl9GRUFUVVJFX0lOU01PRF9WRVJTSU9OX0NIRUNLSU5HICovCgoKI2lmZGVmIEJCX0ZFQVRVUkVfSU5TTU9EX05FV19LRVJORUwKCi8qIEZldGNoIHRoZSBsb2FkZWQgbW9kdWxlcywgYW5kIGFsbCBjdXJyZW50bHkgZXhwb3J0ZWQgc3ltYm9scy4gICovCgpzdGF0aWMgaW50IG5ld19nZXRfa2VybmVsX3N5bWJvbHModm9pZCkKewoJY2hhciAqbW9kdWxlX25hbWVzLCAqbW47CglzdHJ1Y3QgZXh0ZXJuYWxfbW9kdWxlICptb2R1bGVzLCAqbTsKCXN0cnVjdCBuZXdfbW9kdWxlX3N5bWJvbCAqc3ltcywgKnM7CglzaXplX3QgcmV0LCBidWZzaXplLCBubW9kLCBuc3ltcywgaSwgajsKCgkvKiBDb2xsZWN0IHRoZSBsb2FkZWQgbW9kdWxlcy4gICovCgoJbW9kdWxlX25hbWVzID0geG1hbGxvYyhidWZzaXplID0gMjU2KTsKICByZXRyeV9tb2R1bGVzX2xvYWQ6CglpZiAocXVlcnlfbW9kdWxlKE5VTEwsIFFNX01PRFVMRVMsIG1vZHVsZV9uYW1lcywgYnVmc2l6ZSwgJnJldCkpIHsKCQlpZiAoZXJybm8gPT0gRU5PU1BDKSB7CgkJCW1vZHVsZV9uYW1lcyA9IHhyZWFsbG9jKG1vZHVsZV9uYW1lcywgYnVmc2l6ZSA9IHJldCk7CgkJCWdvdG8gcmV0cnlfbW9kdWxlc19sb2FkOwoJCX0KCQlwZXJyb3IoIlFNX01PRFVMRVM6ICVtXG4iKTsKCQlyZXR1cm4gMDsKCX0KCgluX2V4dF9tb2R1bGVzID0gbm1vZCA9IHJldDsKCWV4dF9tb2R1bGVzID0gbW9kdWxlcyA9IHhtYWxsb2Mobm1vZCAqIHNpemVvZigqbW9kdWxlcykpOwoJbWVtc2V0KG1vZHVsZXMsIDAsIG5tb2QgKiBzaXplb2YoKm1vZHVsZXMpKTsKCgkvKiBDb2xsZWN0IHRoZSBtb2R1bGVzJyBzeW1ib2xzLiAgKi8KCglmb3IgKGkgPSAwLCBtbiA9IG1vZHVsZV9uYW1lcywgbSA9IG1vZHVsZXM7CgkJIGkgPCBubW9kOyArK2ksICsrbSwgbW4gKz0gc3RybGVuKG1uKSArIDEpIHsKCQlzdHJ1Y3QgbmV3X21vZHVsZV9pbmZvIGluZm87CgoJCWlmIChxdWVyeV9tb2R1bGUobW4sIFFNX0lORk8sICZpbmZvLCBzaXplb2YoaW5mbyksICZyZXQpKSB7CgkJCWlmIChlcnJubyA9PSBFTk9FTlQpIHsKCQkJCS8qIFRoZSBtb2R1bGUgd2FzIHJlbW92ZWQgb3V0IGZyb20gdW5kZXJuZWF0aCB1cy4gICovCgkJCQljb250aW51ZTsKCQkJfQoJCQlwZXJyb3IoInF1ZXJ5X21vZHVsZTogUU1fSU5GTzogJW0iKTsKCQkJcmV0dXJuIDA7CgkJfQoKCQlzeW1zID0geG1hbGxvYyhidWZzaXplID0gMTAyNCk7CgkgIHJldHJ5X21vZF9zeW1fbG9hZDoKCQlpZiAocXVlcnlfbW9kdWxlKG1uLCBRTV9TWU1CT0xTLCBzeW1zLCBidWZzaXplLCAmcmV0KSkgewoJCQlzd2l0Y2ggKGVycm5vKSB7CgkJCWNhc2UgRU5PU1BDOgoJCQkJc3ltcyA9IHhyZWFsbG9jKHN5bXMsIGJ1ZnNpemUgPSByZXQpOwoJCQkJZ290byByZXRyeV9tb2Rfc3ltX2xvYWQ7CgkJCWNhc2UgRU5PRU5UOgoJCQkJLyogVGhlIG1vZHVsZSB3YXMgcmVtb3ZlZCBvdXQgZnJvbSB1bmRlcm5lYXRoIHVzLiAgKi8KCQkJCWNvbnRpbnVlOwoJCQlkZWZhdWx0OgoJCQkJcGVycm9yKCJxdWVyeV9tb2R1bGU6IFFNX1NZTUJPTFM6ICVtIik7CgkJCQlyZXR1cm4gMDsKCQkJfQoJCX0KCQluc3ltcyA9IHJldDsKCgkJbS0+bmFtZSA9IG1uOwoJCW0tPmFkZHIgPSBpbmZvLmFkZHI7CgkJbS0+bnN5bXMgPSBuc3ltczsKCQltLT5zeW1zID0gc3ltczsKCgkJZm9yIChqID0gMCwgcyA9IHN5bXM7IGogPCBuc3ltczsgKytqLCArK3MpIHsKCQkJcy0+bmFtZSArPSAodW5zaWduZWQgbG9uZykgc3ltczsKCQl9Cgl9CgoJLyogQ29sbGVjdCB0aGUga2VybmVsJ3Mgc3ltYm9scy4gICovCgoJc3ltcyA9IHhtYWxsb2MoYnVmc2l6ZSA9IDE2ICogMTAyNCk7CiAgcmV0cnlfa2Vybl9zeW1fbG9hZDoKCWlmIChxdWVyeV9tb2R1bGUoTlVMTCwgUU1fU1lNQk9MUywgc3ltcywgYnVmc2l6ZSwgJnJldCkpIHsKCQlpZiAoZXJybm8gPT0gRU5PU1BDKSB7CgkJCXN5bXMgPSB4cmVhbGxvYyhzeW1zLCBidWZzaXplID0gcmV0KTsKCQkJZ290byByZXRyeV9rZXJuX3N5bV9sb2FkOwoJCX0KCQlwZXJyb3IoImtlcm5lbDogUU1fU1lNQk9MUzogJW0iKTsKCQlyZXR1cm4gMDsKCX0KCW5rc3ltcyA9IG5zeW1zID0gcmV0OwoJa3N5bXMgPSBzeW1zOwoKCWZvciAoaiA9IDAsIHMgPSBzeW1zOyBqIDwgbnN5bXM7ICsraiwgKytzKSB7CgkJcy0+bmFtZSArPSAodW5zaWduZWQgbG9uZykgc3ltczsKCX0KCXJldHVybiAxOwp9CgoKLyogUmV0dXJuIHRoZSBrZXJuZWwgc3ltYm9sIGNoZWNrc3VtIHZlcnNpb24sIG9yIHplcm8gaWYgbm90IHVzZWQuICAqLwoKc3RhdGljIGludCBuZXdfaXNfa2VybmVsX2NoZWNrc3VtbWVkKHZvaWQpCnsKCXN0cnVjdCBuZXdfbW9kdWxlX3N5bWJvbCAqczsKCXNpemVfdCBpOwoKCS8qIFVzaW5nX1ZlcnNpb25zIGlzIG5vdCB0aGUgZmlyc3Qgc3ltYm9sLCBidXQgaXQgc2hvdWxkIGJlIGluIHRoZXJlLiAgKi8KCglmb3IgKGkgPSAwLCBzID0ga3N5bXM7IGkgPCBua3N5bXM7ICsraSwgKytzKQoJCWlmIChzdHJjbXAoKGNoYXIgKikgcy0+bmFtZSwgIlVzaW5nX1ZlcnNpb25zIikgPT0gMCkKCQkJcmV0dXJuIHMtPnZhbHVlOwoKCXJldHVybiAwOwp9CgoKc3RhdGljIGludCBuZXdfY3JlYXRlX3RoaXNfbW9kdWxlKHN0cnVjdCBvYmpfZmlsZSAqZiwgY29uc3QgY2hhciAqbV9uYW1lKQp7CglzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnNlYzsKCglzZWMgPSBvYmpfY3JlYXRlX2FsbG9jZWRfc2VjdGlvbl9maXJzdChmLCAiLnRoaXMiLCB0Z3Rfc2l6ZW9mX2xvbmcsCgkJCQkJCQkJCQkgICBzaXplb2Yoc3RydWN0IG5ld19tb2R1bGUpKTsKCW1lbXNldChzZWMtPmNvbnRlbnRzLCAwLCBzaXplb2Yoc3RydWN0IG5ld19tb2R1bGUpKTsKCglvYmpfYWRkX3N5bWJvbChmLCAiX190aGlzX21vZHVsZSIsIC0xLAoJCQkJICAgRUxGVyhTVF9JTkZPKSAoU1RCX0xPQ0FMLCBTVFRfT0JKRUNUKSwgc2VjLT5pZHgsIDAsCgkJCQkgICBzaXplb2Yoc3RydWN0IG5ld19tb2R1bGUpKTsKCglvYmpfc3RyaW5nX3BhdGNoKGYsIHNlYy0+aWR4LCBvZmZzZXRvZihzdHJ1Y3QgbmV3X21vZHVsZSwgbmFtZSksCgkJCQkJIG1fbmFtZSk7CgoJcmV0dXJuIDE7Cn0KCgpzdGF0aWMgaW50IG5ld19jcmVhdGVfbW9kdWxlX2tzeW10YWIoc3RydWN0IG9ial9maWxlICpmKQp7CglzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnNlYzsKCWludCBpOwoKCS8qIFdlIG11c3QgYWx3YXlzIGFkZCB0aGUgbW9kdWxlIHJlZmVyZW5jZXMuICAqLwoKCWlmIChuX2V4dF9tb2R1bGVzX3VzZWQpIHsKCQlzdHJ1Y3QgbmV3X21vZHVsZV9yZWYgKmRlcDsKCQlzdHJ1Y3Qgb2JqX3N5bWJvbCAqdG07CgoJCXNlYyA9IG9ial9jcmVhdGVfYWxsb2NlZF9zZWN0aW9uKGYsICIua21vZHRhYiIsIHRndF9zaXplb2Zfdm9pZF9wLAoJCQkJCQkJCQkJIChzaXplb2Yoc3RydWN0IG5ld19tb2R1bGVfcmVmKQoJCQkJCQkJCQkJICAqIG5fZXh0X21vZHVsZXNfdXNlZCkpOwoJCWlmICghc2VjKQoJCQlyZXR1cm4gMDsKCgkJdG0gPSBvYmpfZmluZF9zeW1ib2woZiwgIl9fdGhpc19tb2R1bGUiKTsKCQlkZXAgPSAoc3RydWN0IG5ld19tb2R1bGVfcmVmICopIHNlYy0+Y29udGVudHM7CgkJZm9yIChpID0gMDsgaSA8IG5fZXh0X21vZHVsZXM7ICsraSkKCQkJaWYgKGV4dF9tb2R1bGVzW2ldLnVzZWQpIHsKCQkJCWRlcC0+ZGVwID0gZXh0X21vZHVsZXNbaV0uYWRkcjsKCQkJCW9ial9zeW1ib2xfcGF0Y2goZiwgc2VjLT5pZHgsCgkJCQkJCQkJIChjaGFyICopICZkZXAtPnJlZiAtIHNlYy0+Y29udGVudHMsIHRtKTsKCQkJCWRlcC0+bmV4dF9yZWYgPSAwOwoJCQkJKytkZXA7CgkJCX0KCX0KCglpZiAoZmxhZ19leHBvcnQgJiYgIW9ial9maW5kX3NlY3Rpb24oZiwgIl9fa3N5bXRhYiIpKSB7CgkJc2l6ZV90IG5zeW1zOwoJCWludCAqbG9hZGVkOwoKCQlzZWMgPQoJCQlvYmpfY3JlYXRlX2FsbG9jZWRfc2VjdGlvbihmLCAiX19rc3ltdGFiIiwgdGd0X3NpemVvZl92b2lkX3AsCgkJCQkJCQkJCSAgIDApOwoKCQkvKiBXZSBkb24ndCB3YW50IHRvIGV4cG9ydCBzeW1ib2xzIHJlc2lkaW5nIGluIHNlY3Rpb25zIHRoYXQKCQkgICBhcmVuJ3QgbG9hZGVkLiAgVGhlcmUgYXJlIGEgbnVtYmVyIG9mIHRoZXNlIGNyZWF0ZWQgc28gdGhhdAoJCSAgIHdlIG1ha2Ugc3VyZSBjZXJ0YWluIG1vZHVsZSBvcHRpb25zIGRvbid0IGFwcGVhciB0d2ljZS4gICovCgoJCWxvYWRlZCA9IGFsbG9jYShzaXplb2YoaW50KSAqIChpID0gZi0+aGVhZGVyLmVfc2hudW0pKTsKCQl3aGlsZSAoLS1pID49IDApCgkJCWxvYWRlZFtpXSA9IChmLT5zZWN0aW9uc1tpXS0+aGVhZGVyLnNoX2ZsYWdzICYgU0hGX0FMTE9DKSAhPSAwOwoKCQlmb3IgKG5zeW1zID0gaSA9IDA7IGkgPCBIQVNIX0JVQ0tFVFM7ICsraSkgewoJCQlzdHJ1Y3Qgb2JqX3N5bWJvbCAqc3ltOwoJCQlmb3IgKHN5bSA9IGYtPnN5bXRhYltpXTsgc3ltOyBzeW0gPSBzeW0tPm5leHQpCgkJCQlpZiAoRUxGVyhTVF9CSU5EKSAoc3ltLT5pbmZvKSAhPSBTVEJfTE9DQUwKCQkJCQkmJiBzeW0tPnNlY2lkeCA8PSBTSE5fSElSRVNFUlZFCgkJCQkJJiYgKHN5bS0+c2VjaWR4ID49IFNITl9MT1JFU0VSVkUKCQkJCQkJfHwgbG9hZGVkW3N5bS0+c2VjaWR4XSkpIHsKCQkJCQlFbGZXKEFkZHIpIG9mcyA9IG5zeW1zICogMiAqIHRndF9zaXplb2Zfdm9pZF9wOwoKCQkJCQlvYmpfc3ltYm9sX3BhdGNoKGYsIHNlYy0+aWR4LCBvZnMsIHN5bSk7CgkJCQkJb2JqX3N0cmluZ19wYXRjaChmLCBzZWMtPmlkeCwgb2ZzICsgdGd0X3NpemVvZl92b2lkX3AsCgkJCQkJCQkJCSBzeW0tPm5hbWUpOwoKCQkJCQluc3ltcysrOwoJCQkJfQoJCX0KCgkJb2JqX2V4dGVuZF9zZWN0aW9uKHNlYywgbnN5bXMgKiAyICogdGd0X3NpemVvZl9jaGFyX3ApOwoJfQoKCXJldHVybiAxOwp9CgoKc3RhdGljIGludApuZXdfaW5pdF9tb2R1bGUoY29uc3QgY2hhciAqbV9uYW1lLCBzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJCQl1bnNpZ25lZCBsb25nIG1fc2l6ZSkKewoJc3RydWN0IG5ld19tb2R1bGUgKm1vZHVsZTsKCXN0cnVjdCBvYmpfc2VjdGlvbiAqc2VjOwoJdm9pZCAqaW1hZ2U7CglpbnQgcmV0OwoJdGd0X2xvbmcgbV9hZGRyOwoKCXNlYyA9IG9ial9maW5kX3NlY3Rpb24oZiwgIi50aGlzIik7Cgltb2R1bGUgPSAoc3RydWN0IG5ld19tb2R1bGUgKikgc2VjLT5jb250ZW50czsKCW1fYWRkciA9IHNlYy0+aGVhZGVyLnNoX2FkZHI7CgoJbW9kdWxlLT5zaXplX29mX3N0cnVjdCA9IHNpemVvZigqbW9kdWxlKTsKCW1vZHVsZS0+c2l6ZSA9IG1fc2l6ZTsKCW1vZHVsZS0+ZmxhZ3MgPSBmbGFnX2F1dG9jbGVhbiA/IE5FV19NT0RfQVVUT0NMRUFOIDogMDsKCglzZWMgPSBvYmpfZmluZF9zZWN0aW9uKGYsICJfX2tzeW10YWIiKTsKCWlmIChzZWMgJiYgc2VjLT5oZWFkZXIuc2hfc2l6ZSkgewoJCW1vZHVsZS0+c3ltcyA9IHNlYy0+aGVhZGVyLnNoX2FkZHI7CgkJbW9kdWxlLT5uc3ltcyA9IHNlYy0+aGVhZGVyLnNoX3NpemUgLyAoMiAqIHRndF9zaXplb2ZfY2hhcl9wKTsKCX0KCglpZiAobl9leHRfbW9kdWxlc191c2VkKSB7CgkJc2VjID0gb2JqX2ZpbmRfc2VjdGlvbihmLCAiLmttb2R0YWIiKTsKCQltb2R1bGUtPmRlcHMgPSBzZWMtPmhlYWRlci5zaF9hZGRyOwoJCW1vZHVsZS0+bmRlcHMgPSBuX2V4dF9tb2R1bGVzX3VzZWQ7Cgl9CgoJbW9kdWxlLT5pbml0ID0KCQlvYmpfc3ltYm9sX2ZpbmFsX3ZhbHVlKGYsIG9ial9maW5kX3N5bWJvbChmLCAiaW5pdF9tb2R1bGUiKSk7Cgltb2R1bGUtPmNsZWFudXAgPQoJCW9ial9zeW1ib2xfZmluYWxfdmFsdWUoZiwgb2JqX2ZpbmRfc3ltYm9sKGYsICJjbGVhbnVwX21vZHVsZSIpKTsKCglzZWMgPSBvYmpfZmluZF9zZWN0aW9uKGYsICJfX2V4X3RhYmxlIik7CglpZiAoc2VjKSB7CgkJbW9kdWxlLT5leF90YWJsZV9zdGFydCA9IHNlYy0+aGVhZGVyLnNoX2FkZHI7CgkJbW9kdWxlLT5leF90YWJsZV9lbmQgPSBzZWMtPmhlYWRlci5zaF9hZGRyICsgc2VjLT5oZWFkZXIuc2hfc2l6ZTsKCX0KCglzZWMgPSBvYmpfZmluZF9zZWN0aW9uKGYsICIudGV4dC5pbml0Iik7CglpZiAoc2VjKSB7CgkJbW9kdWxlLT5ydW5zaXplID0gc2VjLT5oZWFkZXIuc2hfYWRkciAtIG1fYWRkcjsKCX0KCXNlYyA9IG9ial9maW5kX3NlY3Rpb24oZiwgIi5kYXRhLmluaXQiKTsKCWlmIChzZWMpIHsKCQlpZiAoIW1vZHVsZS0+cnVuc2l6ZSB8fAoJCQltb2R1bGUtPnJ1bnNpemUgPiBzZWMtPmhlYWRlci5zaF9hZGRyIC0gbV9hZGRyKQoJCQkJbW9kdWxlLT5ydW5zaXplID0gc2VjLT5oZWFkZXIuc2hfYWRkciAtIG1fYWRkcjsKCX0KCglpZiAoIWFyY2hfaW5pdF9tb2R1bGUoZiwgbW9kdWxlKSkKCQlyZXR1cm4gMDsKCgkvKiBXaGV3ISAgQWxsIG9mIHRoZSBpbml0aWFsaXphdGlvbiBpcyBjb21wbGV0ZS4gIENvbGxlY3QgdGhlIGZpbmFsCgkgICBtb2R1bGUgaW1hZ2UgYW5kIGdpdmUgaXQgdG8gdGhlIGtlcm5lbC4gICovCgoJaW1hZ2UgPSB4bWFsbG9jKG1fc2l6ZSk7CglvYmpfY3JlYXRlX2ltYWdlKGYsIGltYWdlKTsKCglyZXQgPSBuZXdfc3lzX2luaXRfbW9kdWxlKG1fbmFtZSwgKHN0cnVjdCBuZXdfbW9kdWxlICopIGltYWdlKTsKCWlmIChyZXQpCgkJcGVycm9yKCJpbml0X21vZHVsZTogJW0iKTsKCglmcmVlKGltYWdlKTsKCglyZXR1cm4gcmV0ID09IDA7Cn0KCiNlbHNlCgojZGVmaW5lIG5ld19pbml0X21vZHVsZSh4LCB5LCB6KSBUUlVFCiNkZWZpbmUgbmV3X2NyZWF0ZV90aGlzX21vZHVsZSh4LCB5KSAwCiNkZWZpbmUgbmV3X2NyZWF0ZV9tb2R1bGVfa3N5bXRhYih4KQoKI2VuZGlmCQkJCQkJCS8qIEJCX0ZFQVRVUkVfSU5TTU9EX09MRF9LRVJORUwgKi8KCgovKj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0qLwoKaW50Cm9ial9zdHJpbmdfcGF0Y2goc3RydWN0IG9ial9maWxlICpmLCBpbnQgc2VjaWR4LCBFbGZXKEFkZHIpIG9mZnNldCwKCQkJCSBjb25zdCBjaGFyICpzdHJpbmcpCnsKCXN0cnVjdCBvYmpfc3RyaW5nX3BhdGNoICpwOwoJc3RydWN0IG9ial9zZWN0aW9uICpzdHJzZWM7CglzaXplX3QgbGVuID0gc3RybGVuKHN0cmluZykgKyAxOwoJY2hhciAqbG9jOwoKCXAgPSB4bWFsbG9jKHNpemVvZigqcCkpOwoJcC0+bmV4dCA9IGYtPnN0cmluZ19wYXRjaGVzOwoJcC0+cmVsb2Nfc2VjaWR4ID0gc2VjaWR4OwoJcC0+cmVsb2Nfb2Zmc2V0ID0gb2Zmc2V0OwoJZi0+c3RyaW5nX3BhdGNoZXMgPSBwOwoKCXN0cnNlYyA9IG9ial9maW5kX3NlY3Rpb24oZiwgIi5rc3RydGFiIik7CglpZiAoc3Ryc2VjID09IE5VTEwpIHsKCQlzdHJzZWMgPSBvYmpfY3JlYXRlX2FsbG9jZWRfc2VjdGlvbihmLCAiLmtzdHJ0YWIiLCAxLCBsZW4pOwoJCXAtPnN0cmluZ19vZmZzZXQgPSAwOwoJCWxvYyA9IHN0cnNlYy0+Y29udGVudHM7Cgl9IGVsc2UgewoJCXAtPnN0cmluZ19vZmZzZXQgPSBzdHJzZWMtPmhlYWRlci5zaF9zaXplOwoJCWxvYyA9IG9ial9leHRlbmRfc2VjdGlvbihzdHJzZWMsIGxlbik7Cgl9CgltZW1jcHkobG9jLCBzdHJpbmcsIGxlbik7CgoJcmV0dXJuIDE7Cn0KCmludApvYmpfc3ltYm9sX3BhdGNoKHN0cnVjdCBvYmpfZmlsZSAqZiwgaW50IHNlY2lkeCwgRWxmVyhBZGRyKSBvZmZzZXQsCgkJCQkgc3RydWN0IG9ial9zeW1ib2wgKnN5bSkKewoJc3RydWN0IG9ial9zeW1ib2xfcGF0Y2ggKnA7CgoJcCA9IHhtYWxsb2Moc2l6ZW9mKCpwKSk7CglwLT5uZXh0ID0gZi0+c3ltYm9sX3BhdGNoZXM7CglwLT5yZWxvY19zZWNpZHggPSBzZWNpZHg7CglwLT5yZWxvY19vZmZzZXQgPSBvZmZzZXQ7CglwLT5zeW0gPSBzeW07CglmLT5zeW1ib2xfcGF0Y2hlcyA9IHA7CgoJcmV0dXJuIDE7Cn0KCmludCBvYmpfY2hlY2tfdW5kZWZpbmVkcyhzdHJ1Y3Qgb2JqX2ZpbGUgKmYpCnsKCXVuc2lnbmVkIGxvbmcgaTsKCWludCByZXQgPSAxOwoKCWZvciAoaSA9IDA7IGkgPCBIQVNIX0JVQ0tFVFM7ICsraSkgewoJCXN0cnVjdCBvYmpfc3ltYm9sICpzeW07CgkJZm9yIChzeW0gPSBmLT5zeW10YWJbaV07IHN5bTsgc3ltID0gc3ltLT5uZXh0KQoJCQlpZiAoc3ltLT5zZWNpZHggPT0gU0hOX1VOREVGKSB7CgkJCQlpZiAoRUxGVyhTVF9CSU5EKSAoc3ltLT5pbmZvKSA9PSBTVEJfV0VBSykgewoJCQkJCXN5bS0+c2VjaWR4ID0gU0hOX0FCUzsKCQkJCQlzeW0tPnZhbHVlID0gMDsKCQkJCX0gZWxzZSB7CgkJCQkJZnByaW50ZihzdGRlcnIsICJ1bnJlc29sdmVkIHN5bWJvbCAlc1xuIiwgc3ltLT5uYW1lKTsKCQkJCQlyZXQgPSAwOwoJCQkJfQoJCQl9Cgl9CgoJcmV0dXJuIHJldDsKfQoKdm9pZCBvYmpfYWxsb2NhdGVfY29tbW9ucyhzdHJ1Y3Qgb2JqX2ZpbGUgKmYpCnsKCXN0cnVjdCBjb21tb25fZW50cnkgewoJCXN0cnVjdCBjb21tb25fZW50cnkgKm5leHQ7CgkJc3RydWN0IG9ial9zeW1ib2wgKnN5bTsKCX0gKmNvbW1vbl9oZWFkID0gTlVMTDsKCgl1bnNpZ25lZCBsb25nIGk7CgoJZm9yIChpID0gMDsgaSA8IEhBU0hfQlVDS0VUUzsgKytpKSB7CgkJc3RydWN0IG9ial9zeW1ib2wgKnN5bTsKCQlmb3IgKHN5bSA9IGYtPnN5bXRhYltpXTsgc3ltOyBzeW0gPSBzeW0tPm5leHQpCgkJCWlmIChzeW0tPnNlY2lkeCA9PSBTSE5fQ09NTU9OKSB7CgkJCQkvKiBDb2xsZWN0IGFsbCBDT01NT04gc3ltYm9scyBhbmQgc29ydCB0aGVtIGJ5IHNpemUgc28gYXMgdG8KCQkJCSAgIG1pbmltaXplIHNwYWNlIHdhc3RlZCBieSBhbGlnbm1lbnQgcmVxdWlyZW1lbnRzLiAgKi8KCQkJCXsKCQkJCQlzdHJ1Y3QgY29tbW9uX2VudHJ5ICoqcCwgKm47CgkJCQkJZm9yIChwID0gJmNvbW1vbl9oZWFkOyAqcDsgcCA9ICYoKnApLT5uZXh0KQoJCQkJCQlpZiAoc3ltLT5zaXplIDw9ICgqcCktPnN5bS0+c2l6ZSkKCQkJCQkJCWJyZWFrOwoKCQkJCQluID0gYWxsb2NhKHNpemVvZigqbikpOwoJCQkJCW4tPm5leHQgPSAqcDsKCQkJCQluLT5zeW0gPSBzeW07CgkJCQkJKnAgPSBuOwoJCQkJfQoJCQl9Cgl9CgoJZm9yIChpID0gMTsgaSA8IGYtPmxvY2FsX3N5bXRhYl9zaXplOyArK2kpIHsKCQlzdHJ1Y3Qgb2JqX3N5bWJvbCAqc3ltID0gZi0+bG9jYWxfc3ltdGFiW2ldOwoJCWlmIChzeW0gJiYgc3ltLT5zZWNpZHggPT0gU0hOX0NPTU1PTikgewoJCQlzdHJ1Y3QgY29tbW9uX2VudHJ5ICoqcCwgKm47CgkJCWZvciAocCA9ICZjb21tb25faGVhZDsgKnA7IHAgPSAmKCpwKS0+bmV4dCkKCQkJCWlmIChzeW0gPT0gKCpwKS0+c3ltKQoJCQkJCWJyZWFrOwoJCQkJZWxzZSBpZiAoc3ltLT5zaXplIDwgKCpwKS0+c3ltLT5zaXplKSB7CgkJCQkJbiA9IGFsbG9jYShzaXplb2YoKm4pKTsKCQkJCQluLT5uZXh0ID0gKnA7CgkJCQkJbi0+c3ltID0gc3ltOwoJCQkJCSpwID0gbjsKCQkJCQlicmVhazsKCQkJCX0KCQl9Cgl9CgoJaWYgKGNvbW1vbl9oZWFkKSB7CgkJLyogRmluZCB0aGUgYnNzIHNlY3Rpb24uICAqLwoJCWZvciAoaSA9IDA7IGkgPCBmLT5oZWFkZXIuZV9zaG51bTsgKytpKQoJCQlpZiAoZi0+c2VjdGlvbnNbaV0tPmhlYWRlci5zaF90eXBlID09IFNIVF9OT0JJVFMpCgkJCQlicmVhazsKCgkJLyogSWYgZm9yIHNvbWUgcmVhc29uIHRoZXJlIGhhZG4ndCBiZWVuIG9uZSwgY3JlYXRlIG9uZS4gICovCgkJaWYgKGkgPT0gZi0+aGVhZGVyLmVfc2hudW0pIHsKCQkJc3RydWN0IG9ial9zZWN0aW9uICpzZWM7CgoJCQlmLT5zZWN0aW9ucyA9IHhyZWFsbG9jKGYtPnNlY3Rpb25zLCAoaSArIDEpICogc2l6ZW9mKHNlYykpOwoJCQlmLT5zZWN0aW9uc1tpXSA9IHNlYyA9IGFyY2hfbmV3X3NlY3Rpb24oKTsKCQkJZi0+aGVhZGVyLmVfc2hudW0gPSBpICsgMTsKCgkJCW1lbXNldChzZWMsIDAsIHNpemVvZigqc2VjKSk7CgkJCXNlYy0+aGVhZGVyLnNoX3R5cGUgPSBTSFRfUFJPR0JJVFM7CgkJCXNlYy0+aGVhZGVyLnNoX2ZsYWdzID0gU0hGX1dSSVRFIHwgU0hGX0FMTE9DOwoJCQlzZWMtPm5hbWUgPSAiLmJzcyI7CgkJCXNlYy0+aWR4ID0gaTsKCQl9CgoJCS8qIEFsbG9jYXRlIHRoZSBDT01NT05TLiAgKi8KCQl7CgkJCUVsZlcoQWRkcikgYnNzX3NpemUgPSBmLT5zZWN0aW9uc1tpXS0+aGVhZGVyLnNoX3NpemU7CgkJCUVsZlcoQWRkcikgbWF4X2FsaWduID0gZi0+c2VjdGlvbnNbaV0tPmhlYWRlci5zaF9hZGRyYWxpZ247CgkJCXN0cnVjdCBjb21tb25fZW50cnkgKmM7CgoJCQlmb3IgKGMgPSBjb21tb25faGVhZDsgYzsgYyA9IGMtPm5leHQpIHsKCQkJCUVsZlcoQWRkcikgYWxpZ24gPSBjLT5zeW0tPnZhbHVlOwoKCQkJCWlmIChhbGlnbiA+IG1heF9hbGlnbikKCQkJCQltYXhfYWxpZ24gPSBhbGlnbjsKCQkJCWlmIChic3Nfc2l6ZSAmIChhbGlnbiAtIDEpKQoJCQkJCWJzc19zaXplID0gKGJzc19zaXplIHwgKGFsaWduIC0gMSkpICsgMTsKCgkJCQljLT5zeW0tPnNlY2lkeCA9IGk7CgkJCQljLT5zeW0tPnZhbHVlID0gYnNzX3NpemU7CgoJCQkJYnNzX3NpemUgKz0gYy0+c3ltLT5zaXplOwoJCQl9CgoJCQlmLT5zZWN0aW9uc1tpXS0+aGVhZGVyLnNoX3NpemUgPSBic3Nfc2l6ZTsKCQkJZi0+c2VjdGlvbnNbaV0tPmhlYWRlci5zaF9hZGRyYWxpZ24gPSBtYXhfYWxpZ247CgkJfQoJfQoKCS8qIEZvciB0aGUgc2FrZSBvZiBwYXRjaCByZWxvY2F0aW9uIGFuZCBwYXJhbWV0ZXIgaW5pdGlhbGl6YXRpb24sCgkgICBhbGxvY2F0ZSB6ZXJvZWQgZGF0YSBmb3IgTk9CSVRTIHNlY3Rpb25zIG5vdy4gIE5vdGUgdGhhdCBhZnRlcgoJICAgdGhpcyB3ZSBjYW5ub3QgYXNzdW1lIE5PQklUUyBhcmUgcmVhbGx5IGVtcHR5LiAgKi8KCWZvciAoaSA9IDA7IGkgPCBmLT5oZWFkZXIuZV9zaG51bTsgKytpKSB7CgkJc3RydWN0IG9ial9zZWN0aW9uICpzID0gZi0+c2VjdGlvbnNbaV07CgkJaWYgKHMtPmhlYWRlci5zaF90eXBlID09IFNIVF9OT0JJVFMpIHsKCQkJcy0+Y29udGVudHMgPSBtZW1zZXQoeG1hbGxvYyhzLT5oZWFkZXIuc2hfc2l6ZSksCgkJCQkJCQkJIDAsIHMtPmhlYWRlci5zaF9zaXplKTsKCQkJcy0+aGVhZGVyLnNoX3R5cGUgPSBTSFRfUFJPR0JJVFM7CgkJfQoJfQp9Cgp1bnNpZ25lZCBsb25nIG9ial9sb2FkX3NpemUoc3RydWN0IG9ial9maWxlICpmKQp7Cgl1bnNpZ25lZCBsb25nIGRvdCA9IDA7CglzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnNlYzsKCgkvKiBGaW5hbGl6ZSB0aGUgcG9zaXRpb25zIG9mIHRoZSBzZWN0aW9ucyByZWxhdGl2ZSB0byBvbmUgYW5vdGhlci4gICovCgoJZm9yIChzZWMgPSBmLT5sb2FkX29yZGVyOyBzZWM7IHNlYyA9IHNlYy0+bG9hZF9uZXh0KSB7CgkJRWxmVyhBZGRyKSBhbGlnbjsKCgkJYWxpZ24gPSBzZWMtPmhlYWRlci5zaF9hZGRyYWxpZ247CgkJaWYgKGFsaWduICYmIChkb3QgJiAoYWxpZ24gLSAxKSkpCgkJCWRvdCA9IChkb3QgfCAoYWxpZ24gLSAxKSkgKyAxOwoKCQlzZWMtPmhlYWRlci5zaF9hZGRyID0gZG90OwoJCWRvdCArPSBzZWMtPmhlYWRlci5zaF9zaXplOwoJfQoKCXJldHVybiBkb3Q7Cn0KCmludCBvYmpfcmVsb2NhdGUoc3RydWN0IG9ial9maWxlICpmLCBFbGZXKEFkZHIpIGJhc2UpCnsKCWludCBpLCBuID0gZi0+aGVhZGVyLmVfc2hudW07CglpbnQgcmV0ID0gMTsKCgkvKiBGaW5hbGl6ZSB0aGUgYWRkcmVzc2VzIG9mIHRoZSBzZWN0aW9ucy4gICovCgoJZi0+YmFzZWFkZHIgPSBiYXNlOwoJZm9yIChpID0gMDsgaSA8IG47ICsraSkKCQlmLT5zZWN0aW9uc1tpXS0+aGVhZGVyLnNoX2FkZHIgKz0gYmFzZTsKCgkvKiBBbmQgaXRlcmF0ZSBvdmVyIGFsbCBvZiB0aGUgcmVsb2NhdGlvbnMuICAqLwoKCWZvciAoaSA9IDA7IGkgPCBuOyArK2kpIHsKCQlzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnJlbHNlYywgKnN5bXNlYywgKnRhcmdzZWMsICpzdHJzZWM7CgkJRWxmVyhSZWxNKSAqIHJlbCwgKnJlbGVuZDsKCQlFbGZXKFN5bSkgKiBzeW10YWI7CgkJY29uc3QgY2hhciAqc3RydGFiOwoKCQlyZWxzZWMgPSBmLT5zZWN0aW9uc1tpXTsKCQlpZiAocmVsc2VjLT5oZWFkZXIuc2hfdHlwZSAhPSBTSFRfUkVMTSkKCQkJY29udGludWU7CgoJCXN5bXNlYyA9IGYtPnNlY3Rpb25zW3JlbHNlYy0+aGVhZGVyLnNoX2xpbmtdOwoJCXRhcmdzZWMgPSBmLT5zZWN0aW9uc1tyZWxzZWMtPmhlYWRlci5zaF9pbmZvXTsKCQlzdHJzZWMgPSBmLT5zZWN0aW9uc1tzeW1zZWMtPmhlYWRlci5zaF9saW5rXTsKCgkJcmVsID0gKEVsZlcoUmVsTSkgKikgcmVsc2VjLT5jb250ZW50czsKCQlyZWxlbmQgPSByZWwgKyAocmVsc2VjLT5oZWFkZXIuc2hfc2l6ZSAvIHNpemVvZihFbGZXKFJlbE0pKSk7CgkJc3ltdGFiID0gKEVsZlcoU3ltKSAqKSBzeW1zZWMtPmNvbnRlbnRzOwoJCXN0cnRhYiA9IChjb25zdCBjaGFyICopIHN0cnNlYy0+Y29udGVudHM7CgoJCWZvciAoOyByZWwgPCByZWxlbmQ7ICsrcmVsKSB7CgkJCUVsZlcoQWRkcikgdmFsdWUgPSAwOwoJCQlzdHJ1Y3Qgb2JqX3N5bWJvbCAqaW50c3ltID0gTlVMTDsKCQkJdW5zaWduZWQgbG9uZyBzeW1uZHg7CgkJCUVsZlcoU3ltKSAqIGV4dHN5bSA9IDA7CgkJCWNvbnN0IGNoYXIgKmVycm1zZzsKCgkJCS8qIEF0dGVtcHQgdG8gZmluZCBhIHZhbHVlIHRvIHVzZSBmb3IgdGhpcyByZWxvY2F0aW9uLiAgKi8KCgkJCXN5bW5keCA9IEVMRlcoUl9TWU0pIChyZWwtPnJfaW5mbyk7CgkJCWlmIChzeW1uZHgpIHsKCQkJCS8qIE5vdGUgd2UndmUgYWxyZWFkeSBjaGVja2VkIGZvciB1bmRlZmluZWQgc3ltYm9scy4gICovCgoJCQkJZXh0c3ltID0gJnN5bXRhYltzeW1uZHhdOwoJCQkJaWYgKEVMRlcoU1RfQklORCkgKGV4dHN5bS0+c3RfaW5mbykgPT0gU1RCX0xPQ0FMKSB7CgkJCQkJLyogTG9jYWwgc3ltYm9scyB3ZSBsb29rIHVwIGluIHRoZSBsb2NhbCB0YWJsZSB0byBiZSBzdXJlCgkJCQkJICAgd2UgZ2V0IHRoZSBvbmUgdGhhdCBpcyByZWFsbHkgaW50ZW5kZWQuICAqLwoJCQkJCWludHN5bSA9IGYtPmxvY2FsX3N5bXRhYltzeW1uZHhdOwoJCQkJfSBlbHNlIHsKCQkJCQkvKiBPdGhlcnMgd2UgbG9vayB1cCBpbiB0aGUgaGFzaCB0YWJsZS4gICovCgkJCQkJY29uc3QgY2hhciAqbmFtZTsKCQkJCQlpZiAoZXh0c3ltLT5zdF9uYW1lKQoJCQkJCQluYW1lID0gc3RydGFiICsgZXh0c3ltLT5zdF9uYW1lOwoJCQkJCWVsc2UKCQkJCQkJbmFtZSA9IGYtPnNlY3Rpb25zW2V4dHN5bS0+c3Rfc2huZHhdLT5uYW1lOwoJCQkJCWludHN5bSA9IG9ial9maW5kX3N5bWJvbChmLCBuYW1lKTsKCQkJCX0KCgkJCQl2YWx1ZSA9IG9ial9zeW1ib2xfZmluYWxfdmFsdWUoZiwgaW50c3ltKTsKCQkJCWludHN5bS0+cmVmZXJlbmNlZCA9IDE7CgkJCX0KI2lmIFNIVF9SRUxNID09IFNIVF9SRUxBCiNpZiBkZWZpbmVkKF9fYWxwaGFfXykgJiYgZGVmaW5lZChBWFBfQlJPS0VOX0dBUykKCQkJLyogV29yayBhcm91bmQgYSBuYXN0eSBHQVMgYnVnLCB0aGF0IGlzIGZpeGVkIGFzIG9mIDIuNy4wLjkuICAqLwoJCQlpZiAoIWV4dHN5bSB8fCAhZXh0c3ltLT5zdF9uYW1lIHx8CgkJCQlFTEZXKFNUX0JJTkQpIChleHRzeW0tPnN0X2luZm8pICE9IFNUQl9MT0NBTCkKI2VuZGlmCgkJCQl2YWx1ZSArPSByZWwtPnJfYWRkZW5kOwojZW5kaWYKCgkJCS8qIERvIGl0ISAqLwoJCQlzd2l0Y2ggKGFyY2hfYXBwbHlfcmVsb2NhdGlvbgoJCQkJCShmLCB0YXJnc2VjLCBzeW1zZWMsIGludHN5bSwgcmVsLCB2YWx1ZSkpIHsKCQkJY2FzZSBvYmpfcmVsb2Nfb2s6CgkJCQlicmVhazsKCgkJCWNhc2Ugb2JqX3JlbG9jX292ZXJmbG93OgoJCQkJZXJybXNnID0gIlJlbG9jYXRpb24gb3ZlcmZsb3ciOwoJCQkJZ290byBiYWRfcmVsb2M7CgkJCWNhc2Ugb2JqX3JlbG9jX2Rhbmdlcm91czoKCQkJCWVycm1zZyA9ICJEYW5nZXJvdXMgcmVsb2NhdGlvbiI7CgkJCQlnb3RvIGJhZF9yZWxvYzsKCQkJY2FzZSBvYmpfcmVsb2NfdW5oYW5kbGVkOgoJCQkJZXJybXNnID0gIlVuaGFuZGxlZCByZWxvY2F0aW9uIjsKCQkJICBiYWRfcmVsb2M6CgkJCQlpZiAoZXh0c3ltKSB7CgkJCQkJZnByaW50ZihzdGRlcnIsICIlcyBvZiB0eXBlICVsZCBmb3IgJXNcbiIsIGVycm1zZywKCQkJCQkJCShsb25nKSBFTEZXKFJfVFlQRSkgKHJlbC0+cl9pbmZvKSwKCQkJCQkJCXN0cnRhYiArIGV4dHN5bS0+c3RfbmFtZSk7CgkJCQl9IGVsc2UgewoJCQkJCWZwcmludGYoc3RkZXJyLCAiJXMgb2YgdHlwZSAlbGRcbiIsIGVycm1zZywKCQkJCQkJCShsb25nKSBFTEZXKFJfVFlQRSkgKHJlbC0+cl9pbmZvKSk7CgkJCQl9CgkJCQlyZXQgPSAwOwoJCQkJYnJlYWs7CgkJCX0KCQl9Cgl9CgoJLyogRmluYWxseSwgdGFrZSBjYXJlIG9mIHRoZSBwYXRjaGVzLiAgKi8KCglpZiAoZi0+c3RyaW5nX3BhdGNoZXMpIHsKCQlzdHJ1Y3Qgb2JqX3N0cmluZ19wYXRjaCAqcDsKCQlzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnN0cnNlYzsKCQlFbGZXKEFkZHIpIHN0cnNlY19iYXNlOwoJCXN0cnNlYyA9IG9ial9maW5kX3NlY3Rpb24oZiwgIi5rc3RydGFiIik7CgkJc3Ryc2VjX2Jhc2UgPSBzdHJzZWMtPmhlYWRlci5zaF9hZGRyOwoKCQlmb3IgKHAgPSBmLT5zdHJpbmdfcGF0Y2hlczsgcDsgcCA9IHAtPm5leHQpIHsKCQkJc3RydWN0IG9ial9zZWN0aW9uICp0YXJnc2VjID0gZi0+c2VjdGlvbnNbcC0+cmVsb2Nfc2VjaWR4XTsKCQkJKihFbGZXKEFkZHIpICopICh0YXJnc2VjLT5jb250ZW50cyArIHAtPnJlbG9jX29mZnNldCkKCQkJCT0gc3Ryc2VjX2Jhc2UgKyBwLT5zdHJpbmdfb2Zmc2V0OwoJCX0KCX0KCglpZiAoZi0+c3ltYm9sX3BhdGNoZXMpIHsKCQlzdHJ1Y3Qgb2JqX3N5bWJvbF9wYXRjaCAqcDsKCgkJZm9yIChwID0gZi0+c3ltYm9sX3BhdGNoZXM7IHA7IHAgPSBwLT5uZXh0KSB7CgkJCXN0cnVjdCBvYmpfc2VjdGlvbiAqdGFyZ3NlYyA9IGYtPnNlY3Rpb25zW3AtPnJlbG9jX3NlY2lkeF07CgkJCSooRWxmVyhBZGRyKSAqKSAodGFyZ3NlYy0+Y29udGVudHMgKyBwLT5yZWxvY19vZmZzZXQpCgkJCQk9IG9ial9zeW1ib2xfZmluYWxfdmFsdWUoZiwgcC0+c3ltKTsKCQl9Cgl9CgoJcmV0dXJuIHJldDsKfQoKaW50IG9ial9jcmVhdGVfaW1hZ2Uoc3RydWN0IG9ial9maWxlICpmLCBjaGFyICppbWFnZSkKewoJc3RydWN0IG9ial9zZWN0aW9uICpzZWM7CglFbGZXKEFkZHIpIGJhc2UgPSBmLT5iYXNlYWRkcjsKCglmb3IgKHNlYyA9IGYtPmxvYWRfb3JkZXI7IHNlYzsgc2VjID0gc2VjLT5sb2FkX25leHQpIHsKCQljaGFyICpzZWNpbWc7CgoJCWlmIChzZWMtPmhlYWRlci5zaF9zaXplID09IDApCgkJCWNvbnRpbnVlOwoKCQlzZWNpbWcgPSBpbWFnZSArIChzZWMtPmhlYWRlci5zaF9hZGRyIC0gYmFzZSk7CgoJCS8qIE5vdGUgdGhhdCB3ZSBhbGxvY2F0ZWQgZGF0YSBmb3IgTk9CSVRTIHNlY3Rpb25zIGVhcmxpZXIuICAqLwoJCW1lbWNweShzZWNpbWcsIHNlYy0+Y29udGVudHMsIHNlYy0+aGVhZGVyLnNoX3NpemUpOwoJfQoKCXJldHVybiAxOwp9CgovKj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0qLwoKc3RydWN0IG9ial9maWxlICpvYmpfbG9hZChGSUxFICogZnApCnsKCXN0cnVjdCBvYmpfZmlsZSAqZjsKCUVsZlcoU2hkcikgKiBzZWN0aW9uX2hlYWRlcnM7CglpbnQgc2hudW0sIGk7CgljaGFyICpzaHN0cnRhYjsKCgkvKiBSZWFkIHRoZSBmaWxlIGhlYWRlci4gICovCgoJZiA9IGFyY2hfbmV3X2ZpbGUoKTsKCW1lbXNldChmLCAwLCBzaXplb2YoKmYpKTsKCWYtPnN5bWJvbF9jbXAgPSBzdHJjbXA7CglmLT5zeW1ib2xfaGFzaCA9IG9ial9lbGZfaGFzaDsKCWYtPmxvYWRfb3JkZXJfc2VhcmNoX3N0YXJ0ID0gJmYtPmxvYWRfb3JkZXI7CgoJZnNlZWsoZnAsIDAsIFNFRUtfU0VUKTsKCWlmIChmcmVhZCgmZi0+aGVhZGVyLCBzaXplb2YoZi0+aGVhZGVyKSwgMSwgZnApICE9IDEpIHsKCQlwZXJyb3IoImVycm9yIHJlYWRpbmcgRUxGIGhlYWRlcjogJW0iKTsKCQlyZXR1cm4gTlVMTDsKCX0KCglpZiAoZi0+aGVhZGVyLmVfaWRlbnRbRUlfTUFHMF0gIT0gRUxGTUFHMAoJCXx8IGYtPmhlYWRlci5lX2lkZW50W0VJX01BRzFdICE9IEVMRk1BRzEKCQl8fCBmLT5oZWFkZXIuZV9pZGVudFtFSV9NQUcyXSAhPSBFTEZNQUcyCgkJfHwgZi0+aGVhZGVyLmVfaWRlbnRbRUlfTUFHM10gIT0gRUxGTUFHMykgewoJCWZwcmludGYoc3RkZXJyLCAibm90IGFuIEVMRiBmaWxlXG4iKTsKCQlyZXR1cm4gTlVMTDsKCX0KCWlmIChmLT5oZWFkZXIuZV9pZGVudFtFSV9DTEFTU10gIT0gRUxGQ0xBU1NNCgkJfHwgZi0+aGVhZGVyLmVfaWRlbnRbRUlfREFUQV0gIT0gRUxGREFUQU0KCQl8fCBmLT5oZWFkZXIuZV9pZGVudFtFSV9WRVJTSU9OXSAhPSBFVl9DVVJSRU5UCgkJfHwgIU1BVENIX01BQ0hJTkUoZi0+aGVhZGVyLmVfbWFjaGluZSkpIHsKCQlmcHJpbnRmKHN0ZGVyciwgIkVMRiBmaWxlIG5vdCBmb3IgdGhpcyBhcmNoaXRlY3R1cmVcbiIpOwoJCXJldHVybiBOVUxMOwoJfQoJaWYgKGYtPmhlYWRlci5lX3R5cGUgIT0gRVRfUkVMKSB7CgkJZnByaW50ZihzdGRlcnIsICJFTEYgZmlsZSBub3QgYSByZWxvY2F0YWJsZSBvYmplY3RcbiIpOwoJCXJldHVybiBOVUxMOwoJfQoKCS8qIFJlYWQgdGhlIHNlY3Rpb24gaGVhZGVycy4gICovCgoJaWYgKGYtPmhlYWRlci5lX3NoZW50c2l6ZSAhPSBzaXplb2YoRWxmVyhTaGRyKSkpIHsKCQlmcHJpbnRmKHN0ZGVyciwgInNlY3Rpb24gaGVhZGVyIHNpemUgbWlzbWF0Y2g6ICVsdSAhPSAlbHVcbiIsCgkJCQkodW5zaWduZWQgbG9uZykgZi0+aGVhZGVyLmVfc2hlbnRzaXplLAoJCQkJKHVuc2lnbmVkIGxvbmcpIHNpemVvZihFbGZXKFNoZHIpKSk7CgkJcmV0dXJuIE5VTEw7Cgl9CgoJc2hudW0gPSBmLT5oZWFkZXIuZV9zaG51bTsKCWYtPnNlY3Rpb25zID0geG1hbGxvYyhzaXplb2Yoc3RydWN0IG9ial9zZWN0aW9uICopICogc2hudW0pOwoJbWVtc2V0KGYtPnNlY3Rpb25zLCAwLCBzaXplb2Yoc3RydWN0IG9ial9zZWN0aW9uICopICogc2hudW0pOwoKCXNlY3Rpb25faGVhZGVycyA9IGFsbG9jYShzaXplb2YoRWxmVyhTaGRyKSkgKiBzaG51bSk7Cglmc2VlayhmcCwgZi0+aGVhZGVyLmVfc2hvZmYsIFNFRUtfU0VUKTsKCWlmIChmcmVhZChzZWN0aW9uX2hlYWRlcnMsIHNpemVvZihFbGZXKFNoZHIpKSwgc2hudW0sIGZwKSAhPSBzaG51bSkgewoJCXBlcnJvcigiZXJyb3IgcmVhZGluZyBFTEYgc2VjdGlvbiBoZWFkZXJzOiAlbSIpOwoJCXJldHVybiBOVUxMOwoJfQoKCS8qIFJlYWQgdGhlIHNlY3Rpb24gZGF0YS4gICovCgoJZm9yIChpID0gMDsgaSA8IHNobnVtOyArK2kpIHsKCQlzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnNlYzsKCgkJZi0+c2VjdGlvbnNbaV0gPSBzZWMgPSBhcmNoX25ld19zZWN0aW9uKCk7CgkJbWVtc2V0KHNlYywgMCwgc2l6ZW9mKCpzZWMpKTsKCgkJc2VjLT5oZWFkZXIgPSBzZWN0aW9uX2hlYWRlcnNbaV07CgkJc2VjLT5pZHggPSBpOwoKCQlzd2l0Y2ggKHNlYy0+aGVhZGVyLnNoX3R5cGUpIHsKCQljYXNlIFNIVF9OVUxMOgoJCWNhc2UgU0hUX05PVEU6CgkJY2FzZSBTSFRfTk9CSVRTOgoJCQkvKiBpZ25vcmUgKi8KCQkJYnJlYWs7CgoJCWNhc2UgU0hUX1BST0dCSVRTOgoJCWNhc2UgU0hUX1NZTVRBQjoKCQljYXNlIFNIVF9TVFJUQUI6CgkJY2FzZSBTSFRfUkVMTToKCQkJaWYgKHNlYy0+aGVhZGVyLnNoX3NpemUgPiAwKSB7CgkJCQlzZWMtPmNvbnRlbnRzID0geG1hbGxvYyhzZWMtPmhlYWRlci5zaF9zaXplKTsKCQkJCWZzZWVrKGZwLCBzZWMtPmhlYWRlci5zaF9vZmZzZXQsIFNFRUtfU0VUKTsKCQkJCWlmIChmcmVhZChzZWMtPmNvbnRlbnRzLCBzZWMtPmhlYWRlci5zaF9zaXplLCAxLCBmcCkgIT0gMSkgewoJCQkJCWZwcmludGYoc3RkZXJyLAoJCQkJCQkJImVycm9yIHJlYWRpbmcgRUxGIHNlY3Rpb24gZGF0YTogJW1cbiIpOwoJCQkJCXJldHVybiBOVUxMOwoJCQkJfQoJCQl9IGVsc2UgewoJCQkJc2VjLT5jb250ZW50cyA9IE5VTEw7CgkJCX0KCQkJYnJlYWs7CgojaWYgU0hUX1JFTE0gPT0gU0hUX1JFTAoJCWNhc2UgU0hUX1JFTEE6CgkJCWZwcmludGYoc3RkZXJyLAoJCQkJCSJSRUxBIHJlbG9jYXRpb25zIG5vdCBzdXBwb3J0ZWQgb24gdGhpcyBhcmNoaXRlY3R1cmVcbiIpOwoJCQlyZXR1cm4gTlVMTDsKI2Vsc2UKCQljYXNlIFNIVF9SRUw6CgkJCWZwcmludGYoc3RkZXJyLAoJCQkJCSJSRUwgcmVsb2NhdGlvbnMgbm90IHN1cHBvcnRlZCBvbiB0aGlzIGFyY2hpdGVjdHVyZVxuIik7CgkJCXJldHVybiBOVUxMOwojZW5kaWYKCgkJZGVmYXVsdDoKCQkJaWYgKHNlYy0+aGVhZGVyLnNoX3R5cGUgPj0gU0hUX0xPUFJPQykgewoJCQkJLyogQXNzdW1lIHByb2Nlc3NvciBzcGVjaWZpYyBzZWN0aW9uIHR5cGVzIGFyZSBkZWJ1ZwoJCQkJICAgaW5mbyBhbmQgY2FuIHNhZmVseSBiZSBpZ25vcmVkLiAgSWYgdGhpcyBpcyBldmVyIG5vdAoJCQkJICAgdGhlIGNhc2UgKEhlbGxvIE1JUFM/KSwgZG9uJ3QgcHV0IGlmZGVmcyBoZXJlIGJ1dAoJCQkJICAgY3JlYXRlIGFuIGFyY2hfbG9hZF9wcm9jX3NlY3Rpb24oKS4gICovCgkJCQlicmVhazsKCQkJfQoKCQkJZnByaW50ZihzdGRlcnIsICJjYW4ndCBoYW5kbGUgc2VjdGlvbnMgb2YgdHlwZSAlbGRcbiIsCgkJCQkJKGxvbmcpIHNlYy0+aGVhZGVyLnNoX3R5cGUpOwoJCQlyZXR1cm4gTlVMTDsKCQl9Cgl9CgoJLyogRG8gd2hhdCBzb3J0IG9mIGludGVycHJldGF0aW9uIGFzIG5lZWRlZCBieSBlYWNoIHNlY3Rpb24uICAqLwoKCXNoc3RydGFiID0gZi0+c2VjdGlvbnNbZi0+aGVhZGVyLmVfc2hzdHJuZHhdLT5jb250ZW50czsKCglmb3IgKGkgPSAwOyBpIDwgc2hudW07ICsraSkgewoJCXN0cnVjdCBvYmpfc2VjdGlvbiAqc2VjID0gZi0+c2VjdGlvbnNbaV07CgkJc2VjLT5uYW1lID0gc2hzdHJ0YWIgKyBzZWMtPmhlYWRlci5zaF9uYW1lOwoJfQoKCWZvciAoaSA9IDA7IGkgPCBzaG51bTsgKytpKSB7CgkJc3RydWN0IG9ial9zZWN0aW9uICpzZWMgPSBmLT5zZWN0aW9uc1tpXTsKCgkJaWYgKHNlYy0+aGVhZGVyLnNoX2ZsYWdzICYgU0hGX0FMTE9DKQoJCQlvYmpfaW5zZXJ0X3NlY3Rpb25fbG9hZF9vcmRlcihmLCBzZWMpOwoKCQlzd2l0Y2ggKHNlYy0+aGVhZGVyLnNoX3R5cGUpIHsKCQljYXNlIFNIVF9TWU1UQUI6CgkJCXsKCQkJCXVuc2lnbmVkIGxvbmcgbnN5bSwgajsKCQkJCWNoYXIgKnN0cnRhYjsKCQkJCUVsZlcoU3ltKSAqIHN5bTsKCgkJCQlpZiAoc2VjLT5oZWFkZXIuc2hfZW50c2l6ZSAhPSBzaXplb2YoRWxmVyhTeW0pKSkgewoJCQkJCWZwcmludGYoc3RkZXJyLCAic3ltYm9sIHNpemUgbWlzbWF0Y2g6ICVsdSAhPSAlbHVcbiIsCgkJCQkJCQkodW5zaWduZWQgbG9uZykgc2VjLT5oZWFkZXIuc2hfZW50c2l6ZSwKCQkJCQkJCSh1bnNpZ25lZCBsb25nKSBzaXplb2YoRWxmVyhTeW0pKSk7CgkJCQkJcmV0dXJuIE5VTEw7CgkJCQl9CgoJCQkJbnN5bSA9IHNlYy0+aGVhZGVyLnNoX3NpemUgLyBzaXplb2YoRWxmVyhTeW0pKTsKCQkJCXN0cnRhYiA9IGYtPnNlY3Rpb25zW3NlYy0+aGVhZGVyLnNoX2xpbmtdLT5jb250ZW50czsKCQkJCXN5bSA9IChFbGZXKFN5bSkgKikgc2VjLT5jb250ZW50czsKCgkJCQkvKiBBbGxvY2F0ZSBzcGFjZSBmb3IgYSB0YWJsZSBvZiBsb2NhbCBzeW1ib2xzLiAgKi8KCQkJCWogPSBmLT5sb2NhbF9zeW10YWJfc2l6ZSA9IHNlYy0+aGVhZGVyLnNoX2luZm87CgkJCQlmLT5sb2NhbF9zeW10YWIgPSB4bWFsbG9jKGogKj0KCQkJCQkJCQkJCSAgc2l6ZW9mKHN0cnVjdCBvYmpfc3ltYm9sICopKTsKCQkJCW1lbXNldChmLT5sb2NhbF9zeW10YWIsIDAsIGopOwoKCQkJCS8qIEluc2VydCBhbGwgc3ltYm9scyBpbnRvIHRoZSBoYXNoIHRhYmxlLiAgKi8KCQkJCWZvciAoaiA9IDEsICsrc3ltOyBqIDwgbnN5bTsgKytqLCArK3N5bSkgewoJCQkJCWNvbnN0IGNoYXIgKm5hbWU7CgkJCQkJaWYgKHN5bS0+c3RfbmFtZSkKCQkJCQkJbmFtZSA9IHN0cnRhYiArIHN5bS0+c3RfbmFtZTsKCQllbHNlCgkJCQkJCW5hbWUgPSBmLT5zZWN0aW9uc1tzeW0tPnN0X3NobmR4XS0+bmFtZTsKCgkJCQkJb2JqX2FkZF9zeW1ib2woZiwgbmFtZSwgaiwgc3ltLT5zdF9pbmZvLCBzeW0tPnN0X3NobmR4LAoJCQkJCQkJCSAgIHN5bS0+c3RfdmFsdWUsIHN5bS0+c3Rfc2l6ZSk7CgkJfQoJfQoJCQlicmVhazsKCgkJY2FzZSBTSFRfUkVMTToKCQkJaWYgKHNlYy0+aGVhZGVyLnNoX2VudHNpemUgIT0gc2l6ZW9mKEVsZlcoUmVsTSkpKSB7CgkJCQlmcHJpbnRmKHN0ZGVyciwKCQkJCQkJInJlbG9jYXRpb24gZW50cnkgc2l6ZSBtaXNtYXRjaDogJWx1ICE9ICVsdVxuIiwKCQkJCQkJKHVuc2lnbmVkIGxvbmcpIHNlYy0+aGVhZGVyLnNoX2VudHNpemUsCgkJCQkJCSh1bnNpZ25lZCBsb25nKSBzaXplb2YoRWxmVyhSZWxNKSkpOwoJCQkJcmV0dXJuIE5VTEw7CgkJCX0KCQkJYnJlYWs7CgkJfQoJfQoKCXJldHVybiBmOwp9CgpzdGF0aWMgdm9pZCBoaWRlX3NwZWNpYWxfc3ltYm9scyhzdHJ1Y3Qgb2JqX2ZpbGUgKmYpCnsKCXN0YXRpYyBjb25zdCBjaGFyICpjb25zdCBzcGVjaWFsc1tdID0gewoJCSJjbGVhbnVwX21vZHVsZSIsCgkJImluaXRfbW9kdWxlIiwKCQkia2VybmVsX3ZlcnNpb24iLAoJCU5VTEwKCX07CgoJc3RydWN0IG9ial9zeW1ib2wgKnN5bTsKCWNvbnN0IGNoYXIgKmNvbnN0ICpwOwoKCWZvciAocCA9IHNwZWNpYWxzOyAqcDsgKytwKQoJCWlmICgoc3ltID0gb2JqX2ZpbmRfc3ltYm9sKGYsICpwKSkgIT0gTlVMTCkKCQkJc3ltLT5pbmZvID0KCQkJCUVMRlcoU1RfSU5GTykgKFNUQl9MT0NBTCwgRUxGVyhTVF9UWVBFKSAoc3ltLT5pbmZvKSk7Cn0KCgoKZXh0ZXJuIGludCBpbnNtb2RfbWFpbiggaW50IGFyZ2MsIGNoYXIgKiphcmd2KQp7CglpbnQga19jcmNzOwoJaW50IGtfbmV3X3N5c2NhbGxzOwoJaW50IGxlbjsKCWNoYXIgKnRtcDsKCXVuc2lnbmVkIGxvbmcgbV9zaXplOwoJRWxmVyhBZGRyKSBtX2FkZHI7CglGSUxFICpmcDsKCXN0cnVjdCBvYmpfZmlsZSAqZjsKCWNoYXIgbV9uYW1lW0JVRlNJWiArIDFdID0gIlwwIjsKCWludCBleGl0X3N0YXR1cyA9IEZBTFNFOwoJaW50IG1faGFzX21vZGluZm87CiNpZmRlZiBCQl9GRUFUVVJFX0lOU01PRF9WRVJTSU9OX0NIRUNLSU5HCglpbnQga192ZXJzaW9uOwoJY2hhciBrX3N0cnZlcnNpb25bU1RSVkVSU0lPTkxFTl07CgljaGFyIG1fc3RydmVyc2lvbltTVFJWRVJTSU9OTEVOXTsKCWludCBtX3ZlcnNpb247CglpbnQgbV9jcmNzOwojZW5kaWYKCgoJaWYgKGFyZ2MgPD0gMSkgewoJCXVzYWdlKGluc21vZF91c2FnZSk7Cgl9CgoJLyogUGFyc2UgYW55IG9wdGlvbnMgKi8KCXdoaWxlICgtLWFyZ2MgPiAwICYmICoqKCsrYXJndikgPT0gJy0nKSB7CgkJd2hpbGUgKCooKysoKmFyZ3YpKSkgewoJCQlzd2l0Y2ggKCoqYXJndikgewoJCQljYXNlICdmJzoJCQkvKiBmb3JjZSBsb2FkaW5nICovCgkJCQlmbGFnX2ZvcmNlX2xvYWQgPSAxOwoJCQkJYnJlYWs7CgkJCWNhc2UgJ2snOgkJCS8qIG1vZHVsZSBsb2FkZWQgYnkga2VybmVsZCwgYXV0by1jbGVhbmFibGUgKi8KCQkJCWZsYWdfYXV0b2NsZWFuID0gMTsKCQkJCWJyZWFrOwoJCQljYXNlICd2JzoJCQkvKiB2ZXJib3NlIG91dHB1dCAqLwoJCQkJZmxhZ192ZXJib3NlID0gMTsKCQkJCWJyZWFrOwoJCQljYXNlICd4JzoJCQkvKiBkbyBub3QgZXhwb3J0IGV4dGVybnMgKi8KCQkJCWZsYWdfZXhwb3J0ID0gMDsKCQkJCWJyZWFrOwoJCQlkZWZhdWx0OgoJCQkJdXNhZ2UoaW5zbW9kX3VzYWdlKTsKCQkJfQoJCX0KCX0KCglpZiAoYXJnYyA8PSAwKSB7CgkJdXNhZ2UoaW5zbW9kX3VzYWdlKTsKCX0KCS8qIEdyYWIgdGhlIG1vZHVsZSBuYW1lICovCglpZiAoKHRtcCA9IHN0cnJjaHIoKmFyZ3YsICcvJykpICE9IE5VTEwpIHsKCQl0bXArKzsKCX0gZWxzZSB7CgkJdG1wID0gKmFyZ3Y7Cgl9CglsZW4gPSBzdHJsZW4odG1wKTsKCglpZiAobGVuID4gMiAmJiB0bXBbbGVuIC0gMl0gPT0gJy4nICYmIHRtcFtsZW4gLSAxXSA9PSAnbycpCgkJbGVuIC09IDI7CgltZW1jcHkobV9uYW1lLCB0bXAsIGxlbik7CglzdHJjcHkobV9mdWxsTmFtZSwgbV9uYW1lKTsKCXN0cmNhdChtX2Z1bGxOYW1lLCAiLm8iKTsKCgkvKiBHZXQgYSBmaWxlZGVzYyBmb3IgdGhlIG1vZHVsZSAqLwoJaWYgKChmcCA9IGZvcGVuKCphcmd2LCAiciIpKSA9PSBOVUxMKSB7CgkJLyogSG1wZi4gIENvdWxkIG5vdCBvcGVuIGl0LiBTZWFyY2ggdGhyb3VnaCBfUEFUSF9NT0RVTEVTIHRvIGZpbmQgYSBtb2R1bGUgbmFtZWQgbV9uYW1lICovCgkJaWYgKHJlY3Vyc2l2ZUFjdGlvbihfUEFUSF9NT0RVTEVTLCBUUlVFLCBGQUxTRSwgRkFMU0UsCgkJCQkJCQlmaW5kTmFtZWRNb2R1bGUsIDAsIG1fZnVsbE5hbWUpID09IFRSVUUpIAoJCXsKCQkJaWYgKG1fZmlsZW5hbWVbMF0gPT0gJ1wwJwoJCQkJfHwgKChmcCA9IGZvcGVuKG1fZmlsZW5hbWUsICJyIikpID09IE5VTEwpKSAKCQkJewoJCQkJcGVycm9yKCJObyBtb2R1bGUgYnkgdGhhdCBuYW1lIGZvdW5kIGluICIgX1BBVEhfTU9EVUxFUwoJCQkJCSAgICJcbiIpOwoJCQkJZXhpdChGQUxTRSk7CgkJCX0KCQl9Cgl9IGVsc2UKCQltZW1jcHkobV9maWxlbmFtZSwgKmFyZ3YsIHN0cmxlbigqYXJndikpOwoKCglpZiAoKGYgPSBvYmpfbG9hZChmcCkpID09IE5VTEwpIHsKCQlwZXJyb3IoIkNvdWxkIG5vdCBsb2FkIHRoZSBtb2R1bGVcbiIpOwoJCWV4aXQoRkFMU0UpOwoJfQoKCWlmIChnZXRfbW9kaW5mb192YWx1ZShmLCAia2VybmVsX3ZlcnNpb24iKSA9PSBOVUxMKQoJCW1faGFzX21vZGluZm8gPSAwOwoJZWxzZQoJCW1faGFzX21vZGluZm8gPSAxOwoKI2lmZGVmIEJCX0ZFQVRVUkVfSU5TTU9EX1ZFUlNJT05fQ0hFQ0tJTkcKCS8qIFZlcnNpb24gY29ycmVzcG9uZGVuY2U/ICAqLwoKCWtfdmVyc2lvbiA9IGdldF9rZXJuZWxfdmVyc2lvbihrX3N0cnZlcnNpb24pOwoJaWYgKG1faGFzX21vZGluZm8pIHsKCQltX3ZlcnNpb24gPSBuZXdfZ2V0X21vZHVsZV92ZXJzaW9uKGYsIG1fc3RydmVyc2lvbik7Cgl9IGVsc2UgewoJCW1fdmVyc2lvbiA9IG9sZF9nZXRfbW9kdWxlX3ZlcnNpb24oZiwgbV9zdHJ2ZXJzaW9uKTsKCQlpZiAobV92ZXJzaW9uID09IC0xKSB7CgkJCWZwcmludGYoc3RkZXJyLAoJCQkJCSJjb3VsZG4ndCBmaW5kIHRoZSBrZXJuZWwgdmVyc2lvbiB0aGUgbW9kdWxlIHdhcyBjb21waWxlZCBmb3JcbiIpOwoJCQlnb3RvIG91dDsKCQl9Cgl9CgoJaWYgKHN0cm5jbXAoa19zdHJ2ZXJzaW9uLCBtX3N0cnZlcnNpb24sIFNUUlZFUlNJT05MRU4pICE9IDApIHsKCQlpZiAoZmxhZ19mb3JjZV9sb2FkKSB7CgkJCWZwcmludGYoc3RkZXJyLCAiV2FybmluZzoga2VybmVsLW1vZHVsZSB2ZXJzaW9uIG1pc21hdGNoXG4iCgkJCQkJIlx0JXMgd2FzIGNvbXBpbGVkIGZvciBrZXJuZWwgdmVyc2lvbiAlc1xuIgoJCQkJCSJcdHdoaWxlIHRoaXMga2VybmVsIGlzIHZlcnNpb24gJXNcbiIsCgkJCQkJbV9maWxlbmFtZSwgbV9zdHJ2ZXJzaW9uLCBrX3N0cnZlcnNpb24pOwoJCX0gZWxzZSB7CgkJCWZwcmludGYoc3RkZXJyLCAia2VybmVsLW1vZHVsZSB2ZXJzaW9uIG1pc21hdGNoXG4iCgkJCQkJIlx0JXMgd2FzIGNvbXBpbGVkIGZvciBrZXJuZWwgdmVyc2lvbiAlc1xuIgoJCQkJCSJcdHdoaWxlIHRoaXMga2VybmVsIGlzIHZlcnNpb24gJXMuXG4iLAoJCQkJCW1fZmlsZW5hbWUsIG1fc3RydmVyc2lvbiwga19zdHJ2ZXJzaW9uKTsKCQkJZ290byBvdXQ7CgkJfQoJfQoJa19jcmNzID0gMDsKI2VuZGlmCQkJCQkJCS8qIEJCX0ZFQVRVUkVfSU5TTU9EX1ZFUlNJT05fQ0hFQ0tJTkcgKi8KCglrX25ld19zeXNjYWxscyA9ICFxdWVyeV9tb2R1bGUoTlVMTCwgMCwgTlVMTCwgMCwgTlVMTCk7CgoJaWYgKGtfbmV3X3N5c2NhbGxzKSB7CiNpZmRlZiBCQl9GRUFUVVJFX0lOU01PRF9ORVdfS0VSTkVMCgkJaWYgKCFuZXdfZ2V0X2tlcm5lbF9zeW1ib2xzKCkpCgkJCWdvdG8gb3V0OwoJCWtfY3JjcyA9IG5ld19pc19rZXJuZWxfY2hlY2tzdW1tZWQoKTsKI2Vsc2UKCQlmcHJpbnRmKHN0ZGVyciwgIk5vdCBjb25maWd1cmVkIHRvIHN1cHBvcnQgbmV3IGtlcm5lbHNcbiIpOwoJCWdvdG8gb3V0OwojZW5kaWYKCX0gZWxzZSB7CiNpZmRlZiBCQl9GRUFUVVJFX0lOU01PRF9PTERfS0VSTkVMCgkJaWYgKCFvbGRfZ2V0X2tlcm5lbF9zeW1ib2xzKCkpCgkJCWdvdG8gb3V0OwoJCWtfY3JjcyA9IG9sZF9pc19rZXJuZWxfY2hlY2tzdW1tZWQoKTsKI2Vsc2UKCQlmcHJpbnRmKHN0ZGVyciwgIk5vdCBjb25maWd1cmVkIHRvIHN1cHBvcnQgb2xkIGtlcm5lbHNcbiIpOwoJCWdvdG8gb3V0OwojZW5kaWYKCX0KCiNpZmRlZiBCQl9GRUFUVVJFX0lOU01PRF9WRVJTSU9OX0NIRUNLSU5HCglpZiAobV9oYXNfbW9kaW5mbykKCQltX2NyY3MgPSBuZXdfaXNfbW9kdWxlX2NoZWNrc3VtbWVkKGYpOwoJZWxzZQoJCW1fY3JjcyA9IG9sZF9pc19tb2R1bGVfY2hlY2tzdW1tZWQoZik7CgoJaWYgKG1fY3JjcyAhPSBrX2NyY3MpCgkJb2JqX3NldF9zeW1ib2xfY29tcGFyZShmLCBuY3Zfc3RyY21wLCBuY3Zfc3ltYm9sX2hhc2gpOwojZW5kaWYJCQkJCQkJLyogQkJfRkVBVFVSRV9JTlNNT0RfVkVSU0lPTl9DSEVDS0lORyAqLwoKCS8qIExldCB0aGUgbW9kdWxlIGtub3cgYWJvdXQgdGhlIGtlcm5lbCBzeW1ib2xzLiAgKi8KCWFkZF9rZXJuZWxfc3ltYm9scyhmKTsKCgkvKiBBbGxvY2F0ZSBjb21tb24gc3ltYm9scywgc3ltYm9sIHRhYmxlcywgYW5kIHN0cmluZyB0YWJsZXMuICAqLwoKCWlmIChrX25ld19zeXNjYWxscyAKCQk/ICFuZXdfY3JlYXRlX3RoaXNfbW9kdWxlKGYsIG1fbmFtZSkKCQk6ICFvbGRfY3JlYXRlX21vZF91c2VfY291bnQoZikpIAoJewoJCWdvdG8gb3V0OwoJfQoKCWlmICghb2JqX2NoZWNrX3VuZGVmaW5lZHMoZikpIHsKCQlnb3RvIG91dDsKCX0KCW9ial9hbGxvY2F0ZV9jb21tb25zKGYpOwoKCWlmIChvcHRpbmQgPCBhcmdjKSB7CgkJaWYgKG1faGFzX21vZGluZm8KCQkJPyAhbmV3X3Byb2Nlc3NfbW9kdWxlX2FyZ3VtZW50cyhmLCBhcmdjIC0gb3B0aW5kLCBhcmd2ICsgb3B0aW5kKSAKCQkJOiAhb2xkX3Byb2Nlc3NfbW9kdWxlX2FyZ3VtZW50cyhmLCBhcmdjIC0gb3B0aW5kLCBhcmd2ICsgb3B0aW5kKSkgCgkJewoJCQlnb3RvIG91dDsKCQl9Cgl9CgoJYXJjaF9jcmVhdGVfZ290KGYpOwoJaGlkZV9zcGVjaWFsX3N5bWJvbHMoZik7CgoJaWYgKGtfbmV3X3N5c2NhbGxzKQoJCW5ld19jcmVhdGVfbW9kdWxlX2tzeW10YWIoZik7CgoJLyogRmluZCBjdXJyZW50IHNpemUgb2YgdGhlIG1vZHVsZSAqLwoJbV9zaXplID0gb2JqX2xvYWRfc2l6ZShmKTsKCgoJZXJybm8gPSAwOwoJbV9hZGRyID0gY3JlYXRlX21vZHVsZShtX25hbWUsIG1fc2l6ZSk7Cglzd2l0Y2ggKGVycm5vKSB7CgljYXNlIDA6CgkJYnJlYWs7CgljYXNlIEVFWElTVDoKCQlmcHJpbnRmKHN0ZGVyciwgIkEgbW9kdWxlIG5hbWVkICVzIGFscmVhZHkgZXhpc3RzXG4iLCBtX25hbWUpOwoJCWdvdG8gb3V0OwoJY2FzZSBFTk9NRU06CgkJZnByaW50ZihzdGRlcnIsCgkJCQkiQ2FuJ3QgYWxsb2NhdGUga2VybmVsIG1lbW9yeSBmb3IgbW9kdWxlOyBuZWVkZWQgJWx1IGJ5dGVzXG4iLAoJCQkJbV9zaXplKTsKCQlnb3RvIG91dDsKCWRlZmF1bHQ6CgkJcGVycm9yKCJjcmVhdGVfbW9kdWxlOiAlbSIpOwoJCWdvdG8gb3V0OwoJfQoKCWlmICghb2JqX3JlbG9jYXRlKGYsIG1fYWRkcikpIHsKCQlkZWxldGVfbW9kdWxlKG1fbmFtZSk7CgkJZ290byBvdXQ7Cgl9CgoJaWYgKGtfbmV3X3N5c2NhbGxzIAoJCT8gIW5ld19pbml0X21vZHVsZShtX25hbWUsIGYsIG1fc2l6ZSkKCQk6ICFvbGRfaW5pdF9tb2R1bGUobV9uYW1lLCBmLCBtX3NpemUpKSAKCXsKCQlkZWxldGVfbW9kdWxlKG1fbmFtZSk7CgkJZ290byBvdXQ7Cgl9CgoJZXhpdF9zdGF0dXMgPSBUUlVFOwoKb3V0OgoJZmNsb3NlKGZwKTsKCWV4aXQoZXhpdF9zdGF0dXMpOwp9Cg==