Lyogdmk6c2V0IHRzPTggc3RzPTQgc3c9NDoKICoKICogVklNIC0gVmkgSU1wcm92ZWQJYnkgQnJhbSBNb29sZW5hYXIKICoKICogRG8gIjpoZWxwIHVnYW5kYSIgIGluIFZpbSB0byByZWFkIGNvcHlpbmcgYW5kIHVzYWdlIGNvbmRpdGlvbnMuCiAqIERvICI6aGVscCBjcmVkaXRzIiBpbiBWaW0gdG8gc2VlIGEgbGlzdCBvZiBwZW9wbGUgd2hvIGNvbnRyaWJ1dGVkLgogKiBTZWUgUkVBRE1FLnR4dCBmb3IgYW4gb3ZlcnZpZXcgb2YgdGhlIFZpbSBzb3VyY2UgY29kZS4KICovCgojaW5jbHVkZSAidmltLmgiCgojaWZkZWYgRkVBVF9MSU5FQlJFQUsKc3RhdGljIGludCB3aW5fY2hhcnRhYnNpemUgX19BUkdTKCh3aW5fVCAqd3AsIGNoYXJfdSAqcCwgY29sbnJfVCBjb2wpKTsKI2VuZGlmCgojaWZkZWYgRkVBVF9NQllURQpzdGF0aWMgaW50IHdpbl9ub2xicl9jaGFydGFic2l6ZSBfX0FSR1MoKHdpbl9UICp3cCwgY2hhcl91ICpzLCBjb2xucl9UIGNvbCwgaW50ICpoZWFkcCkpOwojZW5kaWYKCnN0YXRpYyB1bnNpZ25lZCBucjJoZXggX19BUkdTKCh1bnNpZ25lZCBjKSk7CgpzdGF0aWMgaW50ICAgIGNoYXJ0YWJfaW5pdGlhbGl6ZWQgPSBGQUxTRTsKCi8qIGJfY2hhcnRhYltdIGlzIGFuIGFycmF5IG9mIDMyIGJ5dGVzLCBlYWNoIGJpdCByZXByZXNlbnRpbmcgb25lIG9mIHRoZQogKiBjaGFyYWN0ZXJzIDAtMjU1LiAqLwojZGVmaW5lIFNFVF9DSEFSVEFCKGJ1ZiwgYykgKGJ1ZiktPmJfY2hhcnRhYlsodW5zaWduZWQpKGMpID4+IDNdIHw9ICgxIDw8ICgoYykgJiAweDcpKQojZGVmaW5lIFJFU0VUX0NIQVJUQUIoYnVmLCBjKSAoYnVmKS0+Yl9jaGFydGFiWyh1bnNpZ25lZCkoYykgPj4gM10gJj0gfigxIDw8ICgoYykgJiAweDcpKQojZGVmaW5lIEdFVF9DSEFSVEFCKGJ1ZiwgYykgKChidWYpLT5iX2NoYXJ0YWJbKHVuc2lnbmVkKShjKSA+PiAzXSAmICgxIDw8ICgoYykgJiAweDcpKSkKCi8qCiAqIEZpbGwgY2hhcnRhYltdLiAgQWxzbyBmaWxscyBjdXJidWYtPmJfY2hhcnRhYltdIHdpdGggZmxhZ3MgZm9yIGtleXdvcmQKICogY2hhcmFjdGVycyBmb3IgY3VycmVudCBidWZmZXIuCiAqCiAqIERlcGVuZHMgb24gdGhlIG9wdGlvbiBzZXR0aW5ncyAnaXNrZXl3b3JkJywgJ2lzaWRlbnQnLCAnaXNmbmFtZScsCiAqICdpc3ByaW50JyBhbmQgJ2VuY29kaW5nJy4KICoKICogVGhlIGluZGV4IGluIGNoYXJ0YWJbXSBkZXBlbmRzIG9uICdlbmNvZGluZyc6CiAqIC0gRm9yIG5vbi1tdWx0aS1ieXRlIGluZGV4IHdpdGggdGhlIGJ5dGUgKHNhbWUgYXMgdGhlIGNoYXJhY3RlcikuCiAqIC0gRm9yIERCQ1MgaW5kZXggd2l0aCB0aGUgZmlyc3QgYnl0ZS4KICogLSBGb3IgVVRGLTggaW5kZXggd2l0aCB0aGUgY2hhcmFjdGVyICh3aGVuIGZpcnN0IGJ5dGUgaXMgdXAgdG8gMHg4MCBpdCBpcwogKiAgIHRoZSBzYW1lIGFzIHRoZSBjaGFyYWN0ZXIsIGlmIHRoZSBmaXJzdCBieXRlIGlzIDB4ODAgYW5kIGFib3ZlIGl0IGRlcGVuZHMKICogICBvbiBmdXJ0aGVyIGJ5dGVzKS4KICoKICogVGhlIGNvbnRlbnRzIG9mIGNoYXJ0YWJbXToKICogLSBUaGUgbG93ZXIgdHdvIGJpdHMsIG1hc2tlZCBieSBDVF9DRUxMX01BU0ssIGdpdmUgdGhlIG51bWJlciBvZiBkaXNwbGF5CiAqICAgY2VsbHMgdGhlIGNoYXJhY3RlciBvY2N1cGllcyAoMSBvciAyKS4gIE5vdCB2YWxpZCBmb3IgVVRGLTggYWJvdmUgMHg4MC4KICogLSBDVF9QUklOVF9DSEFSIGJpdCBpcyBzZXQgd2hlbiB0aGUgY2hhcmFjdGVyIGlzIHByaW50YWJsZSAobm8gbmVlZCB0bwogKiAgIHRyYW5zbGF0ZSB0aGUgY2hhcmFjdGVyIGJlZm9yZSBkaXNwbGF5aW5nIGl0KS4gIE5vdGUgdGhhdCBvbmx5IERCQ1MKICogICBjaGFyYWN0ZXJzIGNhbiBoYXZlIDIgZGlzcGxheSBjZWxscyBhbmQgc3RpbGwgYmUgcHJpbnRhYmxlLgogKiAtIENUX0ZOQU1FX0NIQVIgYml0IGlzIHNldCB3aGVuIHRoZSBjaGFyYWN0ZXIgY2FuIGJlIGluIGEgZmlsZSBuYW1lLgogKiAtIENUX0lEX0NIQVIgYml0IGlzIHNldCB3aGVuIHRoZSBjaGFyYWN0ZXIgY2FuIGJlIGluIGFuIGlkZW50aWZpZXIuCiAqCiAqIFJldHVybiBGQUlMIGlmICdpc2tleXdvcmQnLCAnaXNpZGVudCcsICdpc2ZuYW1lJyBvciAnaXNwcmludCcgb3B0aW9uIGhhcyBhbgogKiBlcnJvciwgT0sgb3RoZXJ3aXNlLgogKi8KICAgIGludAppbml0X2NoYXJ0YWIoKQp7CiAgICByZXR1cm4gYnVmX2luaXRfY2hhcnRhYihjdXJidWYsIFRSVUUpOwp9CgogICAgaW50CmJ1Zl9pbml0X2NoYXJ0YWIoYnVmLCBnbG9iYWwpCiAgICBidWZfVAkqYnVmOwogICAgaW50CQlnbG9iYWw7CQkvKiBGQUxTRTogb25seSBzZXQgYnVmLT5iX2NoYXJ0YWJbXSAqLwp7CiAgICBpbnQJCWM7CiAgICBpbnQJCWMyOwogICAgY2hhcl91CSpwOwogICAgaW50CQlpOwogICAgaW50CQl0aWxkZTsKICAgIGludAkJZG9faXNhbHBoYTsKCiAgICBpZiAoZ2xvYmFsKQogICAgewoJLyoKCSAqIFNldCB0aGUgZGVmYXVsdCBzaXplIGZvciBwcmludGFibGUgY2hhcmFjdGVyczoKCSAqIEZyb20gPFNwYWNlPiB0byAnficgaXMgMSAocHJpbnRhYmxlKSwgb3RoZXJzIGFyZSAyIChub3QgcHJpbnRhYmxlKS4KCSAqIFRoaXMgYWxzbyBpbml0cyBhbGwgJ2lzaWRlbnQnIGFuZCAnaXNmbmFtZScgZmxhZ3MgdG8gRkFMU0UuCgkgKgoJICogRUJDRElDOiBhbGwgY2hhcnMgYmVsb3cgJyAnIGFyZSBub3QgcHJpbnRhYmxlLCBhbGwgb3RoZXJzIGFyZQoJICogcHJpbnRhYmxlLgoJICovCgljID0gMDsKCXdoaWxlIChjIDwgJyAnKQoJICAgIGNoYXJ0YWJbYysrXSA9IChkeV9mbGFncyAmIERZX1VIRVgpID8gNCA6IDI7CiNpZmRlZiBFQkNESUMKCXdoaWxlIChjIDwgMjU1KQojZWxzZQoJd2hpbGUgKGMgPD0gJ34nKQojZW5kaWYKCSAgICBjaGFydGFiW2MrK10gPSAxICsgQ1RfUFJJTlRfQ0hBUjsKI2lmZGVmIEZFQVRfRktNQVAKCWlmIChwX2FsdGtleW1hcCkKCXsKCSAgICB3aGlsZSAoYyA8IFlFKQoJCWNoYXJ0YWJbYysrXSA9IDEgKyBDVF9QUklOVF9DSEFSOwoJfQojZW5kaWYKCXdoaWxlIChjIDwgMjU2KQoJewojaWZkZWYgRkVBVF9NQllURQoJICAgIC8qIFVURi04OiBieXRlcyAweGEwIC0gMHhmZiBhcmUgcHJpbnRhYmxlIChsYXRpbjEpICovCgkgICAgaWYgKGVuY191dGY4ICYmIGMgPj0gMHhhMCkKCQljaGFydGFiW2MrK10gPSBDVF9QUklOVF9DSEFSICsgMTsKCSAgICAvKiBldWMtanAgY2hhcmFjdGVycyBzdGFydGluZyB3aXRoIDB4OGUgYXJlIHNpbmdsZSB3aWR0aCAqLwoJICAgIGVsc2UgaWYgKGVuY19kYmNzID09IERCQ1NfSlBOVSAmJiBjID09IDB4OGUpCgkJY2hhcnRhYltjKytdID0gQ1RfUFJJTlRfQ0hBUiArIDE7CgkgICAgLyogb3RoZXIgZG91YmxlLWJ5dGUgY2hhcnMgY2FuIGJlIHByaW50YWJsZSBBTkQgZG91YmxlLXdpZHRoICovCgkgICAgZWxzZSBpZiAoZW5jX2RiY3MgIT0gMCAmJiBNQl9CWVRFMkxFTihjKSA9PSAyKQoJCWNoYXJ0YWJbYysrXSA9IENUX1BSSU5UX0NIQVIgKyAyOwoJICAgIGVsc2UKI2VuZGlmCgkJLyogdGhlIHJlc3QgaXMgdW5wcmludGFibGUgYnkgZGVmYXVsdCAqLwoJCWNoYXJ0YWJbYysrXSA9IChkeV9mbGFncyAmIERZX1VIRVgpID8gNCA6IDI7Cgl9CgojaWZkZWYgRkVBVF9NQllURQoJLyogQXNzdW1lIHRoYXQgZXZlcnkgbXVsdGktYnl0ZSBjaGFyIGlzIGEgZmlsZW5hbWUgY2hhcmFjdGVyLiAqLwoJZm9yIChjID0gMTsgYyA8IDI1NjsgKytjKQoJICAgIGlmICgoZW5jX2RiY3MgIT0gMCAmJiBNQl9CWVRFMkxFTihjKSA+IDEpCgkJICAgIHx8IChlbmNfZGJjcyA9PSBEQkNTX0pQTlUgJiYgYyA9PSAweDhlKQoJCSAgICB8fCAoZW5jX3V0ZjggJiYgYyA+PSAweGEwKSkKCQljaGFydGFiW2NdIHw9IENUX0ZOQU1FX0NIQVI7CiNlbmRpZgogICAgfQoKICAgIC8qCiAgICAgKiBJbml0IHdvcmQgY2hhciBmbGFncyBhbGwgdG8gRkFMU0UKICAgICAqLwogICAgdmltX21lbXNldChidWYtPmJfY2hhcnRhYiwgMCwgKHNpemVfdCkzMik7CiNpZmRlZiBGRUFUX01CWVRFCiAgICBpZiAoZW5jX2RiY3MgIT0gMCkKCWZvciAoYyA9IDA7IGMgPCAyNTY7ICsrYykKCXsKCSAgICAvKiBkb3VibGUtYnl0ZSBjaGFyYWN0ZXJzIGFyZSBwcm9iYWJseSB3b3JkIGNoYXJhY3RlcnMgKi8KCSAgICBpZiAoTUJfQllURTJMRU4oYykgPT0gMikKCQlTRVRfQ0hBUlRBQihidWYsIGMpOwoJfQojZW5kaWYKCiNpZmRlZiBGRUFUX0xJU1AKICAgIC8qCiAgICAgKiBJbiBsaXNwIG1vZGUgdGhlICctJyBjaGFyYWN0ZXIgaXMgaW5jbHVkZWQgaW4ga2V5d29yZHMuCiAgICAgKi8KICAgIGlmIChidWYtPmJfcF9saXNwKQoJU0VUX0NIQVJUQUIoYnVmLCAnLScpOwojZW5kaWYKCiAgICAvKiBXYWxrIHRocm91Z2ggdGhlICdpc2lkZW50JywgJ2lza2V5d29yZCcsICdpc2ZuYW1lJyBhbmQgJ2lzcHJpbnQnCiAgICAgKiBvcHRpb25zIEVhY2ggb3B0aW9uIGlzIGEgbGlzdCBvZiBjaGFyYWN0ZXJzLCBjaGFyYWN0ZXIgbnVtYmVycyBvcgogICAgICogcmFuZ2VzLCBzZXBhcmF0ZWQgYnkgY29tbWFzLCBlLmcuOiAiMjAwLTIxMCx4LCMtMTc4LC0iCiAgICAgKi8KICAgIGZvciAoaSA9IGdsb2JhbCA/IDAgOiAzOyBpIDw9IDM7ICsraSkKICAgIHsKCWlmIChpID09IDApCgkgICAgcCA9IHBfaXNpOwkJLyogZmlyc3Qgcm91bmQ6ICdpc2lkZW50JyAqLwoJZWxzZSBpZiAoaSA9PSAxKQoJICAgIHAgPSBwX2lzcDsJCS8qIHNlY29uZCByb3VuZDogJ2lzcHJpbnQnICovCgllbHNlIGlmIChpID09IDIpCgkgICAgcCA9IHBfaXNmOwkJLyogdGhpcmQgcm91bmQ6ICdpc2ZuYW1lJyAqLwoJZWxzZQkvKiBpID09IDMgKi8KCSAgICBwID0gYnVmLT5iX3BfaXNrOwkvKiBmb3VydGggcm91bmQ6ICdpc2tleXdvcmQnICovCgoJd2hpbGUgKCpwKQoJewoJICAgIHRpbGRlID0gRkFMU0U7CgkgICAgZG9faXNhbHBoYSA9IEZBTFNFOwoJICAgIGlmICgqcCA9PSAnXicgJiYgcFsxXSAhPSBOVUwpCgkgICAgewoJCXRpbGRlID0gVFJVRTsKCQkrK3A7CgkgICAgfQoJICAgIGlmIChWSU1fSVNESUdJVCgqcCkpCgkJYyA9IGdldGRpZ2l0cygmcCk7CgkgICAgZWxzZQoJCWMgPSAqcCsrOwoJICAgIGMyID0gLTE7CgkgICAgaWYgKCpwID09ICctJyAmJiBwWzFdICE9IE5VTCkKCSAgICB7CgkJKytwOwoJCWlmIChWSU1fSVNESUdJVCgqcCkpCgkJICAgIGMyID0gZ2V0ZGlnaXRzKCZwKTsKCQllbHNlCgkJICAgIGMyID0gKnArKzsKCSAgICB9CgkgICAgaWYgKGMgPD0gMCB8fCAoYzIgPCBjICYmIGMyICE9IC0xKSB8fCBjMiA+PSAyNTYKCQkJCQkJIHx8ICEoKnAgPT0gTlVMIHx8ICpwID09ICcsJykpCgkJcmV0dXJuIEZBSUw7CgoJICAgIGlmIChjMiA9PSAtMSkJLyogbm90IGEgcmFuZ2UgKi8KCSAgICB7CgkJLyoKCQkgKiBBIHNpbmdsZSAnQCcgKG5vdCAiQC1AIik6CgkJICogRGVjaWRlIG9uIGxldHRlcnMgYmVpbmcgSUQvcHJpbnRhYmxlL2tleXdvcmQgY2hhcnMgd2l0aAoJCSAqIHN0YW5kYXJkIGZ1bmN0aW9uIGlzYWxwaGEoKS4gVGhpcyB0YWtlcyBjYXJlIG9mIGxvY2FsZSBmb3IKCQkgKiBzaW5nbGUtYnl0ZSBjaGFyYWN0ZXJzKS4KCQkgKi8KCQlpZiAoYyA9PSAnQCcpCgkJewoJCSAgICBkb19pc2FscGhhID0gVFJVRTsKCQkgICAgYyA9IDE7CgkJICAgIGMyID0gMjU1OwoJCX0KCQllbHNlCgkJICAgIGMyID0gYzsKCSAgICB9CgkgICAgd2hpbGUgKGMgPD0gYzIpCgkgICAgewoJCS8qIFVzZSB0aGUgTUJfIGZ1bmN0aW9ucyBoZXJlLCBiZWNhdXNlIGlzYWxwaGEoKSBkb2Vzbid0CgkJICogd29yayBwcm9wZXJseSB3aGVuICdlbmNvZGluZycgaXMgImxhdGluMSIgYW5kIHRoZSBsb2NhbGUgaXMKCQkgKiAiQyIuICAqLwoJCWlmICghZG9faXNhbHBoYSB8fCBNQl9JU0xPV0VSKGMpIHx8IE1CX0lTVVBQRVIoYykKI2lmZGVmIEZFQVRfRktNQVAKCQkJfHwgKHBfYWx0a2V5bWFwICYmIChGX2lzYWxwaGEoYykgfHwgRl9pc2RpZ2l0KGMpKSkKI2VuZGlmCgkJCSAgICApCgkJewoJCSAgICBpZiAoaSA9PSAwKQkJCS8qIChyZSlzZXQgSUQgZmxhZyAqLwoJCSAgICB7CgkJCWlmICh0aWxkZSkKCQkJICAgIGNoYXJ0YWJbY10gJj0gfkNUX0lEX0NIQVI7CgkJCWVsc2UKCQkJICAgIGNoYXJ0YWJbY10gfD0gQ1RfSURfQ0hBUjsKCQkgICAgfQoJCSAgICBlbHNlIGlmIChpID09IDEpCQkvKiAocmUpc2V0IHByaW50YWJsZSAqLwoJCSAgICB7CgkJCWlmICgoYyA8ICcgJwojaWZuZGVmIEVCQ0RJQwoJCQkJICAgIHx8IGMgPiAnficKI2VuZGlmCiNpZmRlZiBGRUFUX0ZLTUFQCgkJCQkgICAgfHwgKHBfYWx0a2V5bWFwCgkJCQkJJiYgKEZfaXNhbHBoYShjKSB8fCBGX2lzZGlnaXQoYykpKQojZW5kaWYKCQkJICAgICkKI2lmZGVmIEZFQVRfTUJZVEUKCQkJCS8qIEZvciBkb3VibGUtYnl0ZSB3ZSBrZWVwIHRoZSBjZWxsIHdpZHRoLCBzbwoJCQkJICogdGhhdCB3ZSBjYW4gZGV0ZWN0IGl0IGZyb20gdGhlIGZpcnN0IGJ5dGUuICovCgkJCQkmJiAhKGVuY19kYmNzICYmIE1CX0JZVEUyTEVOKGMpID09IDIpCiNlbmRpZgoJCQkgICApCgkJCXsKCQkJICAgIGlmICh0aWxkZSkKCQkJICAgIHsKCQkJCWNoYXJ0YWJbY10gPSAoY2hhcnRhYltjXSAmIH5DVF9DRUxMX01BU0spCgkJCQkJICAgICArICgoZHlfZmxhZ3MgJiBEWV9VSEVYKSA/IDQgOiAyKTsKCQkJCWNoYXJ0YWJbY10gJj0gfkNUX1BSSU5UX0NIQVI7CgkJCSAgICB9CgkJCSAgICBlbHNlCgkJCSAgICB7CgkJCQljaGFydGFiW2NdID0gKGNoYXJ0YWJbY10gJiB+Q1RfQ0VMTF9NQVNLKSArIDE7CgkJCQljaGFydGFiW2NdIHw9IENUX1BSSU5UX0NIQVI7CgkJCSAgICB9CgkJCX0KCQkgICAgfQoJCSAgICBlbHNlIGlmIChpID09IDIpCQkvKiAocmUpc2V0IGZuYW1lIGZsYWcgKi8KCQkgICAgewoJCQlpZiAodGlsZGUpCgkJCSAgICBjaGFydGFiW2NdICY9IH5DVF9GTkFNRV9DSEFSOwoJCQllbHNlCgkJCSAgICBjaGFydGFiW2NdIHw9IENUX0ZOQU1FX0NIQVI7CgkJICAgIH0KCQkgICAgZWxzZSAvKiBpID09IDMgKi8JCS8qIChyZSlzZXQga2V5d29yZCBmbGFnICovCgkJICAgIHsKCQkJaWYgKHRpbGRlKQoJCQkgICAgUkVTRVRfQ0hBUlRBQihidWYsIGMpOwoJCQllbHNlCgkJCSAgICBTRVRfQ0hBUlRBQihidWYsIGMpOwoJCSAgICB9CgkJfQoJCSsrYzsKCSAgICB9CgkgICAgcCA9IHNraXBfdG9fb3B0aW9uX3BhcnQocCk7Cgl9CiAgICB9CiAgICBjaGFydGFiX2luaXRpYWxpemVkID0gVFJVRTsKICAgIHJldHVybiBPSzsKfQoKLyoKICogVHJhbnNsYXRlIGFueSBzcGVjaWFsIGNoYXJhY3RlcnMgaW4gYnVmW2J1ZnNpemVdIGluLXBsYWNlLgogKiBUaGUgcmVzdWx0IGlzIGEgc3RyaW5nIHdpdGggb25seSBwcmludGFibGUgY2hhcmFjdGVycywgYnV0IGlmIHRoZXJlIGlzIG5vdAogKiBlbm91Z2ggcm9vbSwgbm90IGFsbCBjaGFyYWN0ZXJzIHdpbGwgYmUgdHJhbnNsYXRlZC4KICovCiAgICB2b2lkCnRyYW5zX2NoYXJhY3RlcnMoYnVmLCBidWZzaXplKQogICAgY2hhcl91CSpidWY7CiAgICBpbnQJCWJ1ZnNpemU7CnsKICAgIGludAkJbGVuOwkJLyogbGVuZ3RoIG9mIHN0cmluZyBuZWVkaW5nIHRyYW5zbGF0aW9uICovCiAgICBpbnQJCXJvb207CQkvKiByb29tIGluIGJ1ZmZlciBhZnRlciBzdHJpbmcgKi8KICAgIGNoYXJfdQkqdHJzOwkJLyogdHJhbnNsYXRlZCBjaGFyYWN0ZXIgKi8KICAgIGludAkJdHJzX2xlbjsJLyogbGVuZ3RoIG9mIHRyc1tdICovCgogICAgbGVuID0gKGludClTVFJMRU4oYnVmKTsKICAgIHJvb20gPSBidWZzaXplIC0gbGVuOwogICAgd2hpbGUgKCpidWYgIT0gMCkKICAgIHsKIyBpZmRlZiBGRUFUX01CWVRFCgkvKiBBc3N1bWUgYSBtdWx0aS1ieXRlIGNoYXJhY3RlciBkb2Vzbid0IG5lZWQgdHJhbnNsYXRpb24uICovCglpZiAoaGFzX21ieXRlICYmICh0cnNfbGVuID0gKCptYl9wdHIybGVuKShidWYpKSA+IDEpCgkgICAgbGVuIC09IHRyc19sZW47CgllbHNlCiMgZW5kaWYKCXsKCSAgICB0cnMgPSB0cmFuc2NoYXJfYnl0ZSgqYnVmKTsKCSAgICB0cnNfbGVuID0gKGludClTVFJMRU4odHJzKTsKCSAgICBpZiAodHJzX2xlbiA+IDEpCgkgICAgewoJCXJvb20gLT0gdHJzX2xlbiAtIDE7CgkJaWYgKHJvb20gPD0gMCkKCQkgICAgcmV0dXJuOwoJCW1jaF9tZW1tb3ZlKGJ1ZiArIHRyc19sZW4sIGJ1ZiArIDEsIChzaXplX3QpbGVuKTsKCSAgICB9CgkgICAgbWNoX21lbW1vdmUoYnVmLCB0cnMsIChzaXplX3QpdHJzX2xlbik7CgkgICAgLS1sZW47Cgl9CglidWYgKz0gdHJzX2xlbjsKICAgIH0KfQoKI2lmIGRlZmluZWQoRkVBVF9FVkFMKSB8fCBkZWZpbmVkKEZFQVRfVElUTEUpIHx8IGRlZmluZWQoRkVBVF9JTlNfRVhQQU5EKSBcCgl8fCBkZWZpbmVkKFBST1RPKQovKgogKiBUcmFuc2xhdGUgYSBzdHJpbmcgaW50byBhbGxvY2F0ZWQgbWVtb3J5LCByZXBsYWNpbmcgc3BlY2lhbCBjaGFycyB3aXRoCiAqIHByaW50YWJsZSBjaGFycy4gIFJldHVybnMgTlVMTCB3aGVuIG91dCBvZiBtZW1vcnkuCiAqLwogICAgY2hhcl91ICoKdHJhbnNzdHIocykKICAgIGNoYXJfdQkqczsKewogICAgY2hhcl91CSpyZXM7CiAgICBjaGFyX3UJKnA7CiNpZmRlZiBGRUFUX01CWVRFCiAgICBpbnQJCWwsIGxlbiwgYzsKICAgIGNoYXJfdQloZXhidWZbMTFdOwojZW5kaWYKCiNpZmRlZiBGRUFUX01CWVRFCiAgICBpZiAoaGFzX21ieXRlKQogICAgewoJLyogQ29tcHV0ZSB0aGUgbGVuZ3RoIG9mIHRoZSByZXN1bHQsIHRha2luZyBhY2NvdW50IG9mIHVucHJpbnRhYmxlCgkgKiBtdWx0aS1ieXRlIGNoYXJhY3RlcnMuICovCglsZW4gPSAwOwoJcCA9IHM7Cgl3aGlsZSAoKnAgIT0gTlVMKQoJewoJICAgIGlmICgobCA9ICgqbWJfcHRyMmxlbikocCkpID4gMSkKCSAgICB7CgkJYyA9ICgqbWJfcHRyMmNoYXIpKHApOwoJCXAgKz0gbDsKCQlpZiAodmltX2lzcHJpbnRjKGMpKQoJCSAgICBsZW4gKz0gbDsKCQllbHNlCgkJewoJCSAgICB0cmFuc2NoYXJfaGV4KGhleGJ1ZiwgYyk7CgkJICAgIGxlbiArPSAoaW50KVNUUkxFTihoZXhidWYpOwoJCX0KCSAgICB9CgkgICAgZWxzZQoJICAgIHsKCQlsID0gYnl0ZTJjZWxscygqcCsrKTsKCQlpZiAobCA+IDApCgkJICAgIGxlbiArPSBsOwoJCWVsc2UKCQkgICAgbGVuICs9IDQ7CS8qIGlsbGVnYWwgYnl0ZSBzZXF1ZW5jZSAqLwoJICAgIH0KCX0KCXJlcyA9IGFsbG9jKCh1bnNpZ25lZCkobGVuICsgMSkpOwogICAgfQogICAgZWxzZQojZW5kaWYKCXJlcyA9IGFsbG9jKCh1bnNpZ25lZCkodmltX3N0cnNpemUocykgKyAxKSk7CiAgICBpZiAocmVzICE9IE5VTEwpCiAgICB7CgkqcmVzID0gTlVMOwoJcCA9IHM7Cgl3aGlsZSAoKnAgIT0gTlVMKQoJewojaWZkZWYgRkVBVF9NQllURQoJICAgIGlmIChoYXNfbWJ5dGUgJiYgKGwgPSAoKm1iX3B0cjJsZW4pKHApKSA+IDEpCgkgICAgewoJCWMgPSAoKm1iX3B0cjJjaGFyKShwKTsKCQlpZiAodmltX2lzcHJpbnRjKGMpKQoJCSAgICBTVFJOQ0FUKHJlcywgcCwgbCk7CS8qIGFwcGVuZCBwcmludGFibGUgbXVsdGktYnl0ZSBjaGFyICovCgkJZWxzZQoJCSAgICB0cmFuc2NoYXJfaGV4KHJlcyArIFNUUkxFTihyZXMpLCBjKTsKCQlwICs9IGw7CgkgICAgfQoJICAgIGVsc2UKI2VuZGlmCgkJU1RSQ0FUKHJlcywgdHJhbnNjaGFyX2J5dGUoKnArKykpOwoJfQogICAgfQogICAgcmV0dXJuIHJlczsKfQojZW5kaWYKCiNpZiBkZWZpbmVkKEZFQVRfU1lOX0hMKSB8fCBkZWZpbmVkKEZFQVRfSU5TX0VYUEFORCkgfHwgZGVmaW5lZChQUk9UTykKLyoKICogQ29udmVydCB0aGUgc3RyaW5nICJzdHJbb3JnbGVuXSIgdG8gZG8gaWdub3JlLWNhc2UgY29tcGFyaW5nLiAgVXNlcyB0aGUKICogY3VycmVudCBsb2NhbGUuCiAqIFdoZW4gImJ1ZiIgaXMgTlVMTCByZXR1cm5zIGFuIGFsbG9jYXRlZCBzdHJpbmcgKE5VTEwgZm9yIG91dC1vZi1tZW1vcnkpLgogKiBPdGhlcndpc2UgcHV0cyB0aGUgcmVzdWx0IGluICJidWZbYnVmbGVuXSIuCiAqLwogICAgY2hhcl91ICoKc3RyX2ZvbGRjYXNlKHN0ciwgb3JnbGVuLCBidWYsIGJ1ZmxlbikKICAgIGNoYXJfdQkqc3RyOwogICAgaW50CQlvcmdsZW47CiAgICBjaGFyX3UJKmJ1ZjsKICAgIGludAkJYnVmbGVuOwp7CiAgICBnYXJyYXlfVAlnYTsKICAgIGludAkJaTsKICAgIGludAkJbGVuID0gb3JnbGVuOwoKI2RlZmluZSBHQV9DSEFSKGkpICAoKGNoYXJfdSAqKWdhLmdhX2RhdGEpW2ldCiNkZWZpbmUgR0FfUFRSKGkpICAgKChjaGFyX3UgKilnYS5nYV9kYXRhICsgaSkKI2RlZmluZSBTVFJfQ0hBUihpKSAgKGJ1ZiA9PSBOVUxMID8gR0FfQ0hBUihpKSA6IGJ1ZltpXSkKI2RlZmluZSBTVFJfUFRSKGkpICAgKGJ1ZiA9PSBOVUxMID8gR0FfUFRSKGkpIDogYnVmICsgaSkKCiAgICAvKiBDb3B5ICJzdHIiIGludG8gImJ1ZiIgb3IgYWxsb2NhdGVkIG1lbW9yeSwgdW5tb2RpZmllZC4gKi8KICAgIGlmIChidWYgPT0gTlVMTCkKICAgIHsKCWdhX2luaXQyKCZnYSwgMSwgMTApOwoJaWYgKGdhX2dyb3coJmdhLCBsZW4gKyAxKSA9PSBGQUlMKQoJICAgIHJldHVybiBOVUxMOwoJbWNoX21lbW1vdmUoZ2EuZ2FfZGF0YSwgc3RyLCAoc2l6ZV90KWxlbik7CglnYS5nYV9sZW4gPSBsZW47CiAgICB9CiAgICBlbHNlCiAgICB7CglpZiAobGVuID49IGJ1ZmxlbikJICAgIC8qIFVnbHkhICovCgkgICAgbGVuID0gYnVmbGVuIC0gMTsKCW1jaF9tZW1tb3ZlKGJ1Ziwgc3RyLCAoc2l6ZV90KWxlbik7CiAgICB9CiAgICBpZiAoYnVmID09IE5VTEwpCglHQV9DSEFSKGxlbikgPSBOVUw7CiAgICBlbHNlCglidWZbbGVuXSA9IE5VTDsKCiAgICAvKiBNYWtlIGVhY2ggY2hhcmFjdGVyIGxvd2VyIGNhc2UuICovCiAgICBpID0gMDsKICAgIHdoaWxlIChTVFJfQ0hBUihpKSAhPSBOVUwpCiAgICB7CiNpZmRlZiBGRUFUX01CWVRFCglpZiAoZW5jX3V0ZjggfHwgKGhhc19tYnl0ZSAmJiBNQl9CWVRFMkxFTihTVFJfQ0hBUihpKSkgPiAxKSkKCXsKCSAgICBpZiAoZW5jX3V0ZjgpCgkgICAgewoJCWludAljID0gdXRmX3B0cjJjaGFyKFNUUl9QVFIoaSkpOwoJCWludAlvbCA9IHV0Zl9wdHIybGVuKFNUUl9QVFIoaSkpOwoJCWludAlsYyA9IHV0Zl90b2xvd2VyKGMpOwoKCQkvKiBPbmx5IHJlcGxhY2UgdGhlIGNoYXJhY3RlciB3aGVuIGl0IGlzIG5vdCBhbiBpbnZhbGlkCgkJICogc2VxdWVuY2UgKEFTQ0lJIGNoYXJhY3RlciBvciBtb3JlIHRoYW4gb25lIGJ5dGUpIGFuZAoJCSAqIHV0Zl90b2xvd2VyKCkgZG9lc24ndCByZXR1cm4gdGhlIG9yaWdpbmFsIGNoYXJhY3Rlci4gKi8KCQlpZiAoKGMgPCAweDgwIHx8IG9sID4gMSkgJiYgYyAhPSBsYykKCQl7CgkJICAgIGludAkgICAgbmwgPSB1dGZfY2hhcjJsZW4obGMpOwoKCQkgICAgLyogSWYgdGhlIGJ5dGUgbGVuZ3RoIGNoYW5nZXMgbmVlZCB0byBzaGlmdCB0aGUgZm9sbG93aW5nCgkJICAgICAqIGNoYXJhY3RlcnMgZm9yd2FyZCBvciBiYWNrd2FyZC4gKi8KCQkgICAgaWYgKG9sICE9IG5sKQoJCSAgICB7CgkJCWlmIChubCA+IG9sKQoJCQl7CgkJCSAgICBpZiAoYnVmID09IE5VTEwgPyBnYV9ncm93KCZnYSwgbmwgLSBvbCArIDEpID09IEZBSUwKCQkJCQkJICAgIDogbGVuICsgbmwgLSBvbCA+PSBidWZsZW4pCgkJCSAgICB7CgkJCQkvKiBvdXQgb2YgbWVtb3J5LCBrZWVwIG9sZCBjaGFyICovCgkJCQlsYyA9IGM7CgkJCQlubCA9IG9sOwoJCQkgICAgfQoJCQl9CgkJCWlmIChvbCAhPSBubCkKCQkJewoJCQkgICAgaWYgKGJ1ZiA9PSBOVUxMKQoJCQkgICAgewoJCQkJU1RSTU9WRShHQV9QVFIoaSkgKyBubCwgR0FfUFRSKGkpICsgb2wpOwoJCQkJZ2EuZ2FfbGVuICs9IG5sIC0gb2w7CgkJCSAgICB9CgkJCSAgICBlbHNlCgkJCSAgICB7CgkJCQlTVFJNT1ZFKGJ1ZiArIGkgKyBubCwgYnVmICsgaSArIG9sKTsKCQkJCWxlbiArPSBubCAtIG9sOwoJCQkgICAgfQoJCQl9CgkJICAgIH0KCQkgICAgKHZvaWQpdXRmX2NoYXIyYnl0ZXMobGMsIFNUUl9QVFIoaSkpOwoJCX0KCSAgICB9CgkgICAgLyogc2tpcCB0byBuZXh0IG11bHRpLWJ5dGUgY2hhciAqLwoJICAgIGkgKz0gKCptYl9wdHIybGVuKShTVFJfUFRSKGkpKTsKCX0KCWVsc2UKI2VuZGlmCgl7CgkgICAgaWYgKGJ1ZiA9PSBOVUxMKQoJCUdBX0NIQVIoaSkgPSBUT0xPV0VSX0xPQyhHQV9DSEFSKGkpKTsKCSAgICBlbHNlCgkJYnVmW2ldID0gVE9MT1dFUl9MT0MoYnVmW2ldKTsKCSAgICArK2k7Cgl9CiAgICB9CgogICAgaWYgKGJ1ZiA9PSBOVUxMKQoJcmV0dXJuIChjaGFyX3UgKilnYS5nYV9kYXRhOwogICAgcmV0dXJuIGJ1ZjsKfQojZW5kaWYKCi8qCiAqIENhdGNoIDIyOiBjaGFydGFiW10gY2FuJ3QgYmUgaW5pdGlhbGl6ZWQgYmVmb3JlIHRoZSBvcHRpb25zIGFyZQogKiBpbml0aWFsaXplZCwgYW5kIGluaXRpYWxpemluZyBvcHRpb25zIG1heSBjYXVzZSB0cmFuc2NoYXIoKSB0byBiZSBjYWxsZWQhCiAqIFdoZW4gY2hhcnRhYl9pbml0aWFsaXplZCA9PSBGQUxTRSBkb24ndCB1c2UgY2hhcnRhYltdLgogKiBEb2VzIE5PVCB3b3JrIGZvciBtdWx0aS1ieXRlIGNoYXJhY3RlcnMsIGMgbXVzdCBiZSA8PSAyNTUuCiAqIEFsc28gZG9lc24ndCB3b3JrIGZvciB0aGUgZmlyc3QgYnl0ZSBvZiBhIG11bHRpLWJ5dGUsICJjIiBtdXN0IGJlIGEKICogY2hhcmFjdGVyIQogKi8Kc3RhdGljIGNoYXJfdQl0cmFuc2NoYXJfYnVmWzddOwoKICAgIGNoYXJfdSAqCnRyYW5zY2hhcihjKQogICAgaW50CQljOwp7CiAgICBpbnQJCQlpOwoKICAgIGkgPSAwOwogICAgaWYgKElTX1NQRUNJQUwoYykpCSAgICAvKiBzcGVjaWFsIGtleSBjb2RlLCBkaXNwbGF5IGFzIH5AIGNoYXIgKi8KICAgIHsKCXRyYW5zY2hhcl9idWZbMF0gPSAnfic7Cgl0cmFuc2NoYXJfYnVmWzFdID0gJ0AnOwoJaSA9IDI7CgljID0gS19TRUNPTkQoYyk7CiAgICB9CgogICAgaWYgKCghY2hhcnRhYl9pbml0aWFsaXplZCAmJiAoCiNpZmRlZiBFQkNESUMKCQkgICAgKGMgPj0gNjQgJiYgYyA8IDI1NSkKI2Vsc2UKCQkgICAgKGMgPj0gJyAnICYmIGMgPD0gJ34nKQojZW5kaWYKI2lmZGVmIEZFQVRfRktNQVAKCQkJfHwgRl9pc2NoYXIoYykKI2VuZGlmCgkJKSkgfHwgKGMgPCAyNTYgJiYgdmltX2lzcHJpbnRjX3N0cmljdChjKSkpCiAgICB7CgkvKiBwcmludGFibGUgY2hhcmFjdGVyICovCgl0cmFuc2NoYXJfYnVmW2ldID0gYzsKCXRyYW5zY2hhcl9idWZbaSArIDFdID0gTlVMOwogICAgfQogICAgZWxzZQoJdHJhbnNjaGFyX25vbnByaW50KHRyYW5zY2hhcl9idWYgKyBpLCBjKTsKICAgIHJldHVybiB0cmFuc2NoYXJfYnVmOwp9CgojaWYgZGVmaW5lZChGRUFUX01CWVRFKSB8fCBkZWZpbmVkKFBST1RPKQovKgogKiBMaWtlIHRyYW5zY2hhcigpLCBidXQgY2FsbGVkIHdpdGggYSBieXRlIGluc3RlYWQgb2YgYSBjaGFyYWN0ZXIuICBDaGVja3MKICogZm9yIGFuIGlsbGVnYWwgVVRGLTggYnl0ZS4KICovCiAgICBjaGFyX3UgKgp0cmFuc2NoYXJfYnl0ZShjKQogICAgaW50CQljOwp7CiAgICBpZiAoZW5jX3V0ZjggJiYgYyA+PSAweDgwKQogICAgewoJdHJhbnNjaGFyX25vbnByaW50KHRyYW5zY2hhcl9idWYsIGMpOwoJcmV0dXJuIHRyYW5zY2hhcl9idWY7CiAgICB9CiAgICByZXR1cm4gdHJhbnNjaGFyKGMpOwp9CiNlbmRpZgoKLyoKICogQ29udmVydCBub24tcHJpbnRhYmxlIGNoYXJhY3RlciB0byB0d28gb3IgbW9yZSBwcmludGFibGUgY2hhcmFjdGVycyBpbgogKiAiYnVmW10iLiAgImJ1ZiIgbmVlZHMgdG8gYmUgYWJsZSB0byBob2xkIGZpdmUgYnl0ZXMuCiAqIERvZXMgTk9UIHdvcmsgZm9yIG11bHRpLWJ5dGUgY2hhcmFjdGVycywgYyBtdXN0IGJlIDw9IDI1NS4KICovCiAgICB2b2lkCnRyYW5zY2hhcl9ub25wcmludChidWYsIGMpCiAgICBjaGFyX3UJKmJ1ZjsKICAgIGludAkJYzsKewogICAgaWYgKGMgPT0gTkwpCgljID0gTlVMOwkJLyogd2UgdXNlIG5ld2xpbmUgaW4gcGxhY2Ugb2YgYSBOVUwgKi8KICAgIGVsc2UgaWYgKGMgPT0gQ0FSICYmIGdldF9maWxlZm9ybWF0KGN1cmJ1ZikgPT0gRU9MX01BQykKCWMgPSBOTDsJCQkvKiB3ZSB1c2UgQ1IgaW4gcGxhY2Ugb2YgIE5MIGluIHRoaXMgY2FzZSAqLwoKICAgIGlmIChkeV9mbGFncyAmIERZX1VIRVgpCQkvKiAnZGlzcGxheScgaGFzICJ1aGV4IiAqLwoJdHJhbnNjaGFyX2hleChidWYsIGMpOwoKI2lmZGVmIEVCQ0RJQwogICAgLyogRm9yIEVCQ0RJQyBvbmx5IHRoZSBjaGFyYWN0ZXJzIDAtNjMgYW5kIDI1NSBhcmUgbm90IHByaW50YWJsZSAqLwogICAgZWxzZSBpZiAoQ3RybENoYXIoYykgIT0gMCB8fCBjID09IERFTCkKI2Vsc2UKICAgIGVsc2UgaWYgKGMgPD0gMHg3ZikJCQkJLyogMHgwMCAtIDB4MWYgYW5kIDB4N2YgKi8KI2VuZGlmCiAgICB7CglidWZbMF0gPSAnXic7CiNpZmRlZiBFQkNESUMKCWlmIChjID09IERFTCkKCSAgICBidWZbMV0gPSAnPyc7CQkvKiBERUwgZGlzcGxheWVkIGFzIF4/ICovCgllbHNlCgkgICAgYnVmWzFdID0gQ3RybENoYXIoYyk7CiNlbHNlCglidWZbMV0gPSBjIF4gMHg0MDsJCS8qIERFTCBkaXNwbGF5ZWQgYXMgXj8gKi8KI2VuZGlmCgoJYnVmWzJdID0gTlVMOwogICAgfQojaWZkZWYgRkVBVF9NQllURQogICAgZWxzZSBpZiAoZW5jX3V0ZjggJiYgYyA+PSAweDgwKQogICAgewoJdHJhbnNjaGFyX2hleChidWYsIGMpOwogICAgfQojZW5kaWYKI2lmbmRlZiBFQkNESUMKICAgIGVsc2UgaWYgKGMgPj0gJyAnICsgMHg4MCAmJiBjIDw9ICd+JyArIDB4ODApICAgIC8qIDB4YTAgLSAweGZlICovCiAgICB7CglidWZbMF0gPSAnfCc7CglidWZbMV0gPSBjIC0gMHg4MDsKCWJ1ZlsyXSA9IE5VTDsKICAgIH0KI2Vsc2UKICAgIGVsc2UgaWYgKGMgPCA2NCkKICAgIHsKCWJ1ZlswXSA9ICd+JzsKCWJ1ZlsxXSA9IE1ldGFDaGFyKGMpOwoJYnVmWzJdID0gTlVMOwogICAgfQojZW5kaWYKICAgIGVsc2UJCQkJCSAgICAvKiAweDgwIC0gMHg5ZiBhbmQgMHhmZiAqLwogICAgewoJLyoKCSAqIFRPRE86IEVCQ0RJQyBJIGRvbid0IGtub3cgd2hhdCB0byBkbyB3aXRoIHRoaXMgY2hhcnMsIHNvIEkgZGlzcGxheQoJICogdGhlbSBhcyAnfj8nIGZvciBub3cKCSAqLwoJYnVmWzBdID0gJ34nOwojaWZkZWYgRUJDRElDCglidWZbMV0gPSAnPyc7CQkJLyogMHhmZiBkaXNwbGF5ZWQgYXMgfj8gKi8KI2Vsc2UKCWJ1ZlsxXSA9IChjIC0gMHg4MCkgXiAweDQwOwkvKiAweGZmIGRpc3BsYXllZCBhcyB+PyAqLwojZW5kaWYKCWJ1ZlsyXSA9IE5VTDsKICAgIH0KfQoKICAgIHZvaWQKdHJhbnNjaGFyX2hleChidWYsIGMpCiAgICBjaGFyX3UJKmJ1ZjsKICAgIGludAkJYzsKewogICAgaW50CQlpID0gMDsKCiAgICBidWZbMF0gPSAnPCc7CiNpZmRlZiBGRUFUX01CWVRFCiAgICBpZiAoYyA+IDI1NSkKICAgIHsKCWJ1ZlsrK2ldID0gbnIyaGV4KCh1bnNpZ25lZCljID4+IDEyKTsKCWJ1ZlsrK2ldID0gbnIyaGV4KCh1bnNpZ25lZCljID4+IDgpOwogICAgfQojZW5kaWYKICAgIGJ1ZlsrK2ldID0gbnIyaGV4KCh1bnNpZ25lZCljID4+IDQpOwogICAgYnVmWysraV0gPSBucjJoZXgoKHVuc2lnbmVkKWMpOwogICAgYnVmWysraV0gPSAnPic7CiAgICBidWZbKytpXSA9IE5VTDsKfQoKLyoKICogQ29udmVydCB0aGUgbG93ZXIgNCBiaXRzIG9mIGJ5dGUgImMiIHRvIGl0cyBoZXggY2hhcmFjdGVyLgogKiBMb3dlciBjYXNlIGxldHRlcnMgYXJlIHVzZWQgdG8gYXZvaWQgdGhlIGNvbmZ1c2lvbiBvZiA8RjE+IGJlaW5nIDB4ZjEgb3IKICogZnVuY3Rpb24ga2V5IDEuCiAqLwogICAgc3RhdGljIHVuc2lnbmVkCm5yMmhleChjKQogICAgdW5zaWduZWQJYzsKewogICAgaWYgKChjICYgMHhmKSA8PSA5KQoJcmV0dXJuIChjICYgMHhmKSArICcwJzsKICAgIHJldHVybiAoYyAmIDB4ZikgLSAxMCArICdhJzsKfQoKLyoKICogUmV0dXJuIG51bWJlciBvZiBkaXNwbGF5IGNlbGxzIG9jY3VwaWVkIGJ5IGJ5dGUgImIiLgogKiBDYWxsZXIgbXVzdCBtYWtlIHN1cmUgMCA8PSBiIDw9IDI1NS4KICogRm9yIG11bHRpLWJ5dGUgbW9kZSAiYiIgbXVzdCBiZSB0aGUgZmlyc3QgYnl0ZSBvZiBhIGNoYXJhY3Rlci4KICogQSBUQUIgaXMgY291bnRlZCBhcyB0d28gY2VsbHM6ICJeSSIuCiAqIEZvciBVVEYtOCBtb2RlIHRoaXMgd2lsbCByZXR1cm4gMCBmb3IgYnl0ZXMgPj0gMHg4MCwgYmVjYXVzZSB0aGUgbnVtYmVyIG9mCiAqIGNlbGxzIGRlcGVuZHMgb24gZnVydGhlciBieXRlcy4KICovCiAgICBpbnQKYnl0ZTJjZWxscyhiKQogICAgaW50CQliOwp7CiNpZmRlZiBGRUFUX01CWVRFCiAgICBpZiAoZW5jX3V0ZjggJiYgYiA+PSAweDgwKQoJcmV0dXJuIDA7CiNlbmRpZgogICAgcmV0dXJuIChjaGFydGFiW2JdICYgQ1RfQ0VMTF9NQVNLKTsKfQoKLyoKICogUmV0dXJuIG51bWJlciBvZiBkaXNwbGF5IGNlbGxzIG9jY3VwaWVkIGJ5IGNoYXJhY3RlciAiYyIuCiAqICJjIiBjYW4gYmUgYSBzcGVjaWFsIGtleSAobmVnYXRpdmUgbnVtYmVyKSBpbiB3aGljaCBjYXNlIDMgb3IgNCBpcyByZXR1cm5lZC4KICogQSBUQUIgaXMgY291bnRlZCBhcyB0d28gY2VsbHM6ICJeSSIgb3IgZm91cjogIjwwOT4iLgogKi8KICAgIGludApjaGFyMmNlbGxzKGMpCiAgICBpbnQJCWM7CnsKICAgIGlmIChJU19TUEVDSUFMKGMpKQoJcmV0dXJuIGNoYXIyY2VsbHMoS19TRUNPTkQoYykpICsgMjsKI2lmZGVmIEZFQVRfTUJZVEUKICAgIGlmIChjID49IDB4ODApCiAgICB7CgkvKiBVVEYtODogYWJvdmUgMHg4MCBuZWVkIHRvIGNoZWNrIHRoZSB2YWx1ZSAqLwoJaWYgKGVuY191dGY4KQoJICAgIHJldHVybiB1dGZfY2hhcjJjZWxscyhjKTsKCS8qIERCQ1M6IGRvdWJsZS1ieXRlIG1lYW5zIGRvdWJsZS13aWR0aCwgZXhjZXB0IGZvciBldWMtanAgd2l0aCBmaXJzdAoJICogYnl0ZSAweDhlICovCglpZiAoZW5jX2RiY3MgIT0gMCAmJiBjID49IDB4MTAwKQoJewoJICAgIGlmIChlbmNfZGJjcyA9PSBEQkNTX0pQTlUgJiYgKCh1bnNpZ25lZCljID4+IDgpID09IDB4OGUpCgkJcmV0dXJuIDE7CgkgICAgcmV0dXJuIDI7Cgl9CiAgICB9CiNlbmRpZgogICAgcmV0dXJuIChjaGFydGFiW2MgJiAweGZmXSAmIENUX0NFTExfTUFTSyk7Cn0KCi8qCiAqIFJldHVybiBudW1iZXIgb2YgZGlzcGxheSBjZWxscyBvY2N1cGllZCBieSBjaGFyYWN0ZXIgYXQgIipwIi4KICogQSBUQUIgaXMgY291bnRlZCBhcyB0d28gY2VsbHM6ICJeSSIgb3IgZm91cjogIjwwOT4iLgogKi8KICAgIGludApwdHIyY2VsbHMocCkKICAgIGNoYXJfdQkqcDsKewojaWZkZWYgRkVBVF9NQllURQogICAgLyogRm9yIFVURi04IHdlIG5lZWQgdG8gbG9vayBhdCBtb3JlIGJ5dGVzIGlmIHRoZSBmaXJzdCBieXRlIGlzID49IDB4ODAuICovCiAgICBpZiAoZW5jX3V0ZjggJiYgKnAgPj0gMHg4MCkKCXJldHVybiB1dGZfcHRyMmNlbGxzKHApOwogICAgLyogRm9yIERCQ1Mgd2UgY2FuIHRlbGwgdGhlIGNlbGwgY291bnQgZnJvbSB0aGUgZmlyc3QgYnl0ZS4gKi8KI2VuZGlmCiAgICByZXR1cm4gKGNoYXJ0YWJbKnBdICYgQ1RfQ0VMTF9NQVNLKTsKfQoKLyoKICogUmV0dXJuIHRoZSBudW1iZXIgb2YgY2hhcmFjdGVycyBzdHJpbmcgInMiIHdpbGwgdGFrZSBvbiB0aGUgc2NyZWVuLAogKiBjb3VudGluZyBUQUJzIGFzIHR3byBjaGFyYWN0ZXJzOiAiXkkiLgogKi8KICAgIGludAp2aW1fc3Ryc2l6ZShzKQogICAgY2hhcl91CSpzOwp7CiAgICByZXR1cm4gdmltX3N0cm5zaXplKHMsIChpbnQpTUFYQ09MKTsKfQoKLyoKICogUmV0dXJuIHRoZSBudW1iZXIgb2YgY2hhcmFjdGVycyBzdHJpbmcgInNbbGVuXSIgd2lsbCB0YWtlIG9uIHRoZSBzY3JlZW4sCiAqIGNvdW50aW5nIFRBQnMgYXMgdHdvIGNoYXJhY3RlcnM6ICJeSSIuCiAqLwogICAgaW50CnZpbV9zdHJuc2l6ZShzLCBsZW4pCiAgICBjaGFyX3UJKnM7CiAgICBpbnQJCWxlbjsKewogICAgaW50CQlzaXplID0gMDsKCiAgICB3aGlsZSAoKnMgIT0gTlVMICYmIC0tbGVuID49IDApCiAgICB7CiNpZmRlZiBGRUFUX01CWVRFCglpZiAoaGFzX21ieXRlKQoJewoJICAgIGludAkgICAgbCA9ICgqbWJfcHRyMmxlbikocyk7CgoJICAgIHNpemUgKz0gcHRyMmNlbGxzKHMpOwoJICAgIHMgKz0gbDsKCSAgICBsZW4gLT0gbCAtIDE7Cgl9CgllbHNlCiNlbmRpZgoJICAgIHNpemUgKz0gYnl0ZTJjZWxscygqcysrKTsKICAgIH0KICAgIHJldHVybiBzaXplOwp9CgovKgogKiBSZXR1cm4gdGhlIG51bWJlciBvZiBjaGFyYWN0ZXJzICdjJyB3aWxsIHRha2Ugb24gdGhlIHNjcmVlbiwgdGFraW5nCiAqIGludG8gYWNjb3VudCB0aGUgc2l6ZSBvZiBhIHRhYi4KICogVXNlIGEgZGVmaW5lIHRvIG1ha2UgaXQgZmFzdCwgdGhpcyBpcyB1c2VkIHZlcnkgb2Z0ZW4hISEKICogQWxzbyBzZWUgZ2V0dmNvbCgpIGJlbG93LgogKi8KCiNkZWZpbmUgUkVUX1dJTl9CVUZfQ0hBUlRBQlNJWkUod3AsIGJ1ZiwgcCwgY29sKSBcCiAgICBpZiAoKihwKSA9PSBUQUIgJiYgKCEod3ApLT53X3BfbGlzdCB8fCBsY3NfdGFiMSkpIFwKICAgIHsgXAoJaW50IHRzOyBcCgl0cyA9IChidWYpLT5iX3BfdHM7IFwKCXJldHVybiAoaW50KSh0cyAtIChjb2wgJSB0cykpOyBcCiAgICB9IFwKICAgIGVsc2UgXAoJcmV0dXJuIHB0cjJjZWxscyhwKTsKCiNpZiBkZWZpbmVkKEZFQVRfVlJFUExBQ0UpIHx8IGRlZmluZWQoRkVBVF9FWF9FWFRSQSkgfHwgZGVmaW5lZChGRUFUX0dVSSkgXAoJfHwgZGVmaW5lZChGRUFUX1ZJUlRVQUxFRElUKSB8fCBkZWZpbmVkKFBST1RPKQogICAgaW50CmNoYXJ0YWJzaXplKHAsIGNvbCkKICAgIGNoYXJfdQkqcDsKICAgIGNvbG5yX1QJY29sOwp7CiAgICBSRVRfV0lOX0JVRl9DSEFSVEFCU0laRShjdXJ3aW4sIGN1cmJ1ZiwgcCwgY29sKQp9CiNlbmRpZgoKI2lmZGVmIEZFQVRfTElORUJSRUFLCiAgICBzdGF0aWMgaW50Cndpbl9jaGFydGFic2l6ZSh3cCwgcCwgY29sKQogICAgd2luX1QJKndwOwogICAgY2hhcl91CSpwOwogICAgY29sbnJfVAljb2w7CnsKICAgIFJFVF9XSU5fQlVGX0NIQVJUQUJTSVpFKHdwLCB3cC0+d19idWZmZXIsIHAsIGNvbCkKfQojZW5kaWYKCi8qCiAqIHJldHVybiB0aGUgbnVtYmVyIG9mIGNoYXJhY3RlcnMgdGhlIHN0cmluZyAncycgd2lsbCB0YWtlIG9uIHRoZSBzY3JlZW4sCiAqIHRha2luZyBpbnRvIGFjY291bnQgdGhlIHNpemUgb2YgYSB0YWIKICovCiAgICBpbnQKbGluZXRhYnNpemUocykKICAgIGNoYXJfdQkqczsKewogICAgY29sbnJfVAljb2wgPSAwOwoKICAgIHdoaWxlICgqcyAhPSBOVUwpCgljb2wgKz0gbGJyX2NoYXJ0YWJzaXplX2FkdigmcywgY29sKTsKICAgIHJldHVybiAoaW50KWNvbDsKfQoKLyoKICogTGlrZSBsaW5ldGFic2l6ZSgpLCBidXQgZm9yIGEgZ2l2ZW4gd2luZG93IGluc3RlYWQgb2YgdGhlIGN1cnJlbnQgb25lLgogKi8KICAgIGludAp3aW5fbGluZXRhYnNpemUod3AsIHAsIGxlbikKICAgIHdpbl9UCSp3cDsKICAgIGNoYXJfdQkqcDsKICAgIGNvbG5yX1QJbGVuOwp7CiAgICBjb2xucl9UCWNvbCA9IDA7CiAgICBjaGFyX3UJKnM7CgogICAgZm9yIChzID0gcDsgKnMgIT0gTlVMICYmIChsZW4gPT0gTUFYQ09MIHx8IHMgPCBwICsgbGVuKTsgbWJfcHRyX2FkdihzKSkKCWNvbCArPSB3aW5fbGJyX2NoYXJ0YWJzaXplKHdwLCBzLCBjb2wsIE5VTEwpOwogICAgcmV0dXJuIChpbnQpY29sOwp9CgovKgogKiBSZXR1cm4gVFJVRSBpZiAnYycgaXMgYSBub3JtYWwgaWRlbnRpZmllciBjaGFyYWN0ZXI6CiAqIExldHRlcnMgYW5kIGNoYXJhY3RlcnMgZnJvbSB0aGUgJ2lzaWRlbnQnIG9wdGlvbi4KICovCiAgICBpbnQKdmltX2lzSURjKGMpCiAgICBpbnQgYzsKewogICAgcmV0dXJuIChjID4gMCAmJiBjIDwgMHgxMDAgJiYgKGNoYXJ0YWJbY10gJiBDVF9JRF9DSEFSKSk7Cn0KCi8qCiAqIHJldHVybiBUUlVFIGlmICdjJyBpcyBhIGtleXdvcmQgY2hhcmFjdGVyOiBMZXR0ZXJzIGFuZCBjaGFyYWN0ZXJzIGZyb20KICogJ2lza2V5d29yZCcgb3B0aW9uIGZvciBjdXJyZW50IGJ1ZmZlci4KICogRm9yIG11bHRpLWJ5dGUgY2hhcmFjdGVycyBtYl9nZXRfY2xhc3MoKSBpcyB1c2VkIChidWlsdGluIHJ1bGVzKS4KICovCiAgICBpbnQKdmltX2lzd29yZGMoYykKICAgIGludCBjOwp7CiNpZmRlZiBGRUFUX01CWVRFCiAgICBpZiAoYyA+PSAweDEwMCkKICAgIHsKCWlmIChlbmNfZGJjcyAhPSAwKQoJICAgIHJldHVybiBkYmNzX2NsYXNzKCh1bnNpZ25lZCljID4+IDgsICh1bnNpZ25lZCkoYyAmIDB4ZmYpKSA+PSAyOwoJaWYgKGVuY191dGY4KQoJICAgIHJldHVybiB1dGZfY2xhc3MoYykgPj0gMjsKICAgIH0KI2VuZGlmCiAgICByZXR1cm4gKGMgPiAwICYmIGMgPCAweDEwMCAmJiBHRVRfQ0hBUlRBQihjdXJidWYsIGMpICE9IDApOwp9CgovKgogKiBKdXN0IGxpa2UgdmltX2lzd29yZGMoKSBidXQgdXNlcyBhIHBvaW50ZXIgdG8gdGhlIChtdWx0aS1ieXRlKSBjaGFyYWN0ZXIuCiAqLwogICAgaW50CnZpbV9pc3dvcmRwKHApCiAgICBjaGFyX3UgKnA7CnsKI2lmZGVmIEZFQVRfTUJZVEUKICAgIGlmIChoYXNfbWJ5dGUgJiYgTUJfQllURTJMRU4oKnApID4gMSkKCXJldHVybiBtYl9nZXRfY2xhc3MocCkgPj0gMjsKI2VuZGlmCiAgICByZXR1cm4gR0VUX0NIQVJUQUIoY3VyYnVmLCAqcCkgIT0gMDsKfQoKI2lmIGRlZmluZWQoRkVBVF9TWU5fSEwpIHx8IGRlZmluZWQoUFJPVE8pCiAgICBpbnQKdmltX2lzd29yZGNfYnVmKHAsIGJ1ZikKICAgIGNoYXJfdQkqcDsKICAgIGJ1Zl9UCSpidWY7CnsKIyBpZmRlZiBGRUFUX01CWVRFCiAgICBpZiAoaGFzX21ieXRlICYmIE1CX0JZVEUyTEVOKCpwKSA+IDEpCglyZXR1cm4gbWJfZ2V0X2NsYXNzKHApID49IDI7CiMgZW5kaWYKICAgIHJldHVybiAoR0VUX0NIQVJUQUIoYnVmLCAqcCkgIT0gMCk7Cn0KI2VuZGlmCgovKgogKiByZXR1cm4gVFJVRSBpZiAnYycgaXMgYSB2YWxpZCBmaWxlLW5hbWUgY2hhcmFjdGVyCiAqIEFzc3VtZSBjaGFyYWN0ZXJzIGFib3ZlIDB4MTAwIGFyZSB2YWxpZCAobXVsdGktYnl0ZSkuCiAqLwogICAgaW50CnZpbV9pc2ZpbGVjKGMpCiAgICBpbnQJYzsKewogICAgcmV0dXJuIChjID49IDB4MTAwIHx8IChjID4gMCAmJiAoY2hhcnRhYltjXSAmIENUX0ZOQU1FX0NIQVIpKSk7Cn0KCi8qCiAqIHJldHVybiBUUlVFIGlmICdjJyBpcyBhIHZhbGlkIGZpbGUtbmFtZSBjaGFyYWN0ZXIgb3IgYSB3aWxkY2FyZCBjaGFyYWN0ZXIKICogQXNzdW1lIGNoYXJhY3RlcnMgYWJvdmUgMHgxMDAgYXJlIHZhbGlkIChtdWx0aS1ieXRlKS4KICogRXhwbGljaXRseSBpbnRlcnByZXQgJ10nIGFzIGEgd2lsZGNhcmQgY2hhcmFjdGVyIGFzIG1jaF9oYXNfd2lsZGNhcmQoIl0iKQogKiByZXR1cm5zIGZhbHNlLgogKi8KICAgIGludAp2aW1faXNmaWxlY19vcl93YyhjKQogICAgaW50IGM7CnsKICAgIGNoYXJfdSBidWZbMl07CgogICAgYnVmWzBdID0gKGNoYXJfdSljOwogICAgYnVmWzFdID0gTlVMOwogICAgcmV0dXJuIHZpbV9pc2ZpbGVjKGMpIHx8IGMgPT0gJ10nIHx8IG1jaF9oYXNfd2lsZGNhcmQoYnVmKTsKfQoKLyoKICogcmV0dXJuIFRSVUUgaWYgJ2MnIGlzIGEgcHJpbnRhYmxlIGNoYXJhY3RlcgogKiBBc3N1bWUgY2hhcmFjdGVycyBhYm92ZSAweDEwMCBhcmUgcHJpbnRhYmxlIChtdWx0aS1ieXRlKSwgZXhjZXB0IGZvcgogKiBVbmljb2RlLgogKi8KICAgIGludAp2aW1faXNwcmludGMoYykKICAgIGludCBjOwp7CiNpZmRlZiBGRUFUX01CWVRFCiAgICBpZiAoZW5jX3V0ZjggJiYgYyA+PSAweDEwMCkKCXJldHVybiB1dGZfcHJpbnRhYmxlKGMpOwojZW5kaWYKICAgIHJldHVybiAoYyA+PSAweDEwMCB8fCAoYyA+IDAgJiYgKGNoYXJ0YWJbY10gJiBDVF9QUklOVF9DSEFSKSkpOwp9CgovKgogKiBTdHJpY3QgdmVyc2lvbiBvZiB2aW1faXNwcmludGMoYyksIGRvbid0IHJldHVybiBUUlVFIGlmICJjIiBpcyB0aGUgaGVhZAogKiBieXRlIG9mIGEgZG91YmxlLWJ5dGUgY2hhcmFjdGVyLgogKi8KICAgIGludAp2aW1faXNwcmludGNfc3RyaWN0KGMpCiAgICBpbnQJYzsKewojaWZkZWYgRkVBVF9NQllURQogICAgaWYgKGVuY19kYmNzICE9IDAgJiYgYyA8IDB4MTAwICYmIE1CX0JZVEUyTEVOKGMpID4gMSkKCXJldHVybiBGQUxTRTsKICAgIGlmIChlbmNfdXRmOCAmJiBjID49IDB4MTAwKQoJcmV0dXJuIHV0Zl9wcmludGFibGUoYyk7CiNlbmRpZgogICAgcmV0dXJuIChjID49IDB4MTAwIHx8IChjID4gMCAmJiAoY2hhcnRhYltjXSAmIENUX1BSSU5UX0NIQVIpKSk7Cn0KCi8qCiAqIGxpa2UgY2hhcnRhYnNpemUoKSwgYnV0IGFsc28gY2hlY2sgZm9yIGxpbmUgYnJlYWtzIG9uIHRoZSBzY3JlZW4KICovCiAgICBpbnQKbGJyX2NoYXJ0YWJzaXplKHMsIGNvbCkKICAgIHVuc2lnbmVkIGNoYXIJKnM7CiAgICBjb2xucl9UCQljb2w7CnsKI2lmZGVmIEZFQVRfTElORUJSRUFLCiAgICBpZiAoIWN1cndpbi0+d19wX2xiciAmJiAqcF9zYnIgPT0gTlVMKQogICAgewojZW5kaWYKI2lmZGVmIEZFQVRfTUJZVEUKCWlmIChjdXJ3aW4tPndfcF93cmFwKQoJICAgIHJldHVybiB3aW5fbm9sYnJfY2hhcnRhYnNpemUoY3Vyd2luLCBzLCBjb2wsIE5VTEwpOwojZW5kaWYKCVJFVF9XSU5fQlVGX0NIQVJUQUJTSVpFKGN1cndpbiwgY3VyYnVmLCBzLCBjb2wpCiNpZmRlZiBGRUFUX0xJTkVCUkVBSwogICAgfQogICAgcmV0dXJuIHdpbl9sYnJfY2hhcnRhYnNpemUoY3Vyd2luLCBzLCBjb2wsIE5VTEwpOwojZW5kaWYKfQoKLyoKICogQ2FsbCBsYnJfY2hhcnRhYnNpemUoKSBhbmQgYWR2YW5jZSB0aGUgcG9pbnRlci4KICovCiAgICBpbnQKbGJyX2NoYXJ0YWJzaXplX2FkdihzLCBjb2wpCiAgICBjaGFyX3UJKipzOwogICAgY29sbnJfVAljb2w7CnsKICAgIGludAkJcmV0dmFsOwoKICAgIHJldHZhbCA9IGxicl9jaGFydGFic2l6ZSgqcywgY29sKTsKICAgIG1iX3B0cl9hZHYoKnMpOwogICAgcmV0dXJuIHJldHZhbDsKfQoKLyoKICogVGhpcyBmdW5jdGlvbiBpcyB1c2VkIHZlcnkgb2Z0ZW4sIGtlZXAgaXQgZmFzdCEhISEKICoKICogSWYgImhlYWRwIiBub3QgTlVMTCwgc2V0ICpoZWFkcCB0byB0aGUgc2l6ZSBvZiB3aGF0IHdlIGZvciAnc2hvd2JyZWFrJwogKiBzdHJpbmcgYXQgc3RhcnQgb2YgbGluZS4gIFdhcm5pbmc6ICpoZWFkcCBpcyBvbmx5IHNldCBpZiBpdCdzIGEgbm9uLXplcm8KICogdmFsdWUsIGluaXQgdG8gMCBiZWZvcmUgY2FsbGluZy4KICovCiAgICBpbnQKd2luX2xicl9jaGFydGFic2l6ZSh3cCwgcywgY29sLCBoZWFkcCkKICAgIHdpbl9UCSp3cDsKICAgIGNoYXJfdQkqczsKICAgIGNvbG5yX1QJY29sOwogICAgaW50CQkqaGVhZHAgVU5VU0VEOwp7CiNpZmRlZiBGRUFUX0xJTkVCUkVBSwogICAgaW50CQljOwogICAgaW50CQlzaXplOwogICAgY29sbnJfVAljb2wyOwogICAgY29sbnJfVAljb2xtYXg7CiAgICBpbnQJCWFkZGVkOwojIGlmZGVmIEZFQVRfTUJZVEUKICAgIGludAkJbWJfYWRkZWQgPSAwOwojIGVsc2UKIyAgZGVmaW5lIG1iX2FkZGVkIDAKIyBlbmRpZgogICAgaW50CQludW1iZXJleHRyYTsKICAgIGNoYXJfdQkqcHM7CiAgICBpbnQJCXRhYl9jb3JyID0gKCpzID09IFRBQik7CiAgICBpbnQJCW47CgogICAgLyoKICAgICAqIE5vICdsaW5lYnJlYWsnIGFuZCAnc2hvd2JyZWFrJzogcmV0dXJuIHF1aWNrbHkuCiAgICAgKi8KICAgIGlmICghd3AtPndfcF9sYnIgJiYgKnBfc2JyID09IE5VTCkKI2VuZGlmCiAgICB7CiNpZmRlZiBGRUFUX01CWVRFCglpZiAod3AtPndfcF93cmFwKQoJICAgIHJldHVybiB3aW5fbm9sYnJfY2hhcnRhYnNpemUod3AsIHMsIGNvbCwgaGVhZHApOwojZW5kaWYKCVJFVF9XSU5fQlVGX0NIQVJUQUJTSVpFKHdwLCB3cC0+d19idWZmZXIsIHMsIGNvbCkKICAgIH0KCiNpZmRlZiBGRUFUX0xJTkVCUkVBSwogICAgLyoKICAgICAqIEZpcnN0IGdldCBub3JtYWwgc2l6ZSwgd2l0aG91dCAnbGluZWJyZWFrJwogICAgICovCiAgICBzaXplID0gd2luX2NoYXJ0YWJzaXplKHdwLCBzLCBjb2wpOwogICAgYyA9ICpzOwoKICAgIC8qCiAgICAgKiBJZiAnbGluZWJyZWFrJyBzZXQgY2hlY2sgYXQgYSBibGFuayBiZWZvcmUgYSBub24tYmxhbmsgaWYgdGhlIGxpbmUKICAgICAqIG5lZWRzIGEgYnJlYWsgaGVyZQogICAgICovCiAgICBpZiAod3AtPndfcF9sYnIKCSAgICAmJiB2aW1faXNicmVhayhjKQoJICAgICYmICF2aW1faXNicmVhayhzWzFdKQoJICAgICYmICF3cC0+d19wX2xpc3QKCSAgICAmJiB3cC0+d19wX3dyYXAKIyBpZmRlZiBGRUFUX1ZFUlRTUExJVAoJICAgICYmIHdwLT53X3dpZHRoICE9IDAKIyBlbmRpZgogICAgICAgKQogICAgewoJLyoKCSAqIENvdW50IGFsbCBjaGFyYWN0ZXJzIGZyb20gZmlyc3Qgbm9uLWJsYW5rIGFmdGVyIGEgYmxhbmsgdXAgdG8gbmV4dAoJICogbm9uLWJsYW5rIGFmdGVyIGEgYmxhbmsuCgkgKi8KCW51bWJlcmV4dHJhID0gd2luX2NvbF9vZmYod3ApOwoJY29sMiA9IGNvbDsKCWNvbG1heCA9IChjb2xucl9UKShXX1dJRFRIKHdwKSAtIG51bWJlcmV4dHJhKTsKCWlmIChjb2wgPj0gY29sbWF4KQoJewoJICAgIG4gPSBjb2xtYXggKyB3aW5fY29sX29mZjIod3ApOwoJICAgIGlmIChuID4gMCkKCQljb2xtYXggKz0gKCgoY29sIC0gY29sbWF4KSAvIG4pICsgMSkgKiBuOwoJfQoKCWZvciAoOzspCgl7CgkgICAgcHMgPSBzOwoJICAgIG1iX3B0cl9hZHYocyk7CgkgICAgYyA9ICpzOwoJICAgIGlmICghKGMgIT0gTlVMCgkJICAgICYmICh2aW1faXNicmVhayhjKQoJCQl8fCAoIXZpbV9pc2JyZWFrKGMpCgkJCSAgICAmJiAoY29sMiA9PSBjb2wgfHwgIXZpbV9pc2JyZWFrKCpwcykpKSkpKQoJCWJyZWFrOwoKCSAgICBjb2wyICs9IHdpbl9jaGFydGFic2l6ZSh3cCwgcywgY29sMik7CgkgICAgaWYgKGNvbDIgPj0gY29sbWF4KQkJLyogZG9lc24ndCBmaXQgKi8KCSAgICB7CgkJc2l6ZSA9IGNvbG1heCAtIGNvbDsKCQl0YWJfY29yciA9IEZBTFNFOwoJCWJyZWFrOwoJICAgIH0KCX0KICAgIH0KIyBpZmRlZiBGRUFUX01CWVRFCiAgICBlbHNlIGlmIChoYXNfbWJ5dGUgJiYgc2l6ZSA9PSAyICYmIE1CX0JZVEUyTEVOKCpzKSA+IDEKCQkJCSAgICAmJiB3cC0+d19wX3dyYXAgJiYgaW5fd2luX2JvcmRlcih3cCwgY29sKSkKICAgIHsKCSsrc2l6ZTsJCS8qIENvdW50IHRoZSAiPiIgaW4gdGhlIGxhc3QgY29sdW1uLiAqLwoJbWJfYWRkZWQgPSAxOwogICAgfQojIGVuZGlmCgogICAgLyoKICAgICAqIE1heSBoYXZlIHRvIGFkZCBzb21ldGhpbmcgZm9yICdzaG93YnJlYWsnIHN0cmluZyBhdCBzdGFydCBvZiBsaW5lCiAgICAgKiBTZXQgKmhlYWRwIHRvIHRoZSBzaXplIG9mIHdoYXQgd2UgYWRkLgogICAgICovCiAgICBhZGRlZCA9IDA7CiAgICBpZiAoKnBfc2JyICE9IE5VTCAmJiB3cC0+d19wX3dyYXAgJiYgY29sICE9IDApCiAgICB7CgludW1iZXJleHRyYSA9IHdpbl9jb2xfb2ZmKHdwKTsKCWNvbCArPSBudW1iZXJleHRyYSArIG1iX2FkZGVkOwoJaWYgKGNvbCA+PSAoY29sbnJfVClXX1dJRFRIKHdwKSkKCXsKCSAgICBjb2wgLT0gV19XSURUSCh3cCk7CgkgICAgbnVtYmVyZXh0cmEgPSBXX1dJRFRIKHdwKSAtIChudW1iZXJleHRyYSAtIHdpbl9jb2xfb2ZmMih3cCkpOwoJICAgIGlmIChudW1iZXJleHRyYSA+IDApCgkJY29sID0gY29sICUgbnVtYmVyZXh0cmE7Cgl9CglpZiAoY29sID09IDAgfHwgY29sICsgc2l6ZSA+IChjb2xucl9UKVdfV0lEVEgod3ApKQoJewoJICAgIGFkZGVkID0gdmltX3N0cnNpemUocF9zYnIpOwoJICAgIGlmICh0YWJfY29ycikKCQlzaXplICs9IChhZGRlZCAvIHdwLT53X2J1ZmZlci0+Yl9wX3RzKSAqIHdwLT53X2J1ZmZlci0+Yl9wX3RzOwoJICAgIGVsc2UKCQlzaXplICs9IGFkZGVkOwoJICAgIGlmIChjb2wgIT0gMCkKCQlhZGRlZCA9IDA7Cgl9CiAgICB9CiAgICBpZiAoaGVhZHAgIT0gTlVMTCkKCSpoZWFkcCA9IGFkZGVkICsgbWJfYWRkZWQ7CiAgICByZXR1cm4gc2l6ZTsKI2VuZGlmCn0KCiNpZiBkZWZpbmVkKEZFQVRfTUJZVEUpIHx8IGRlZmluZWQoUFJPVE8pCi8qCiAqIExpa2Ugd2luX2xicl9jaGFydGFic2l6ZSgpLCBleGNlcHQgdGhhdCB3ZSBrbm93ICdsaW5lYnJlYWsnIGlzIG9mZiBhbmQKICogJ3dyYXAnIGlzIG9uLiAgVGhpcyBtZWFucyB3ZSBuZWVkIHRvIGNoZWNrIGZvciBhIGRvdWJsZS1ieXRlIGNoYXJhY3RlciB0aGF0CiAqIGRvZXNuJ3QgZml0IGF0IHRoZSBlbmQgb2YgdGhlIHNjcmVlbiBsaW5lLgogKi8KICAgIHN0YXRpYyBpbnQKd2luX25vbGJyX2NoYXJ0YWJzaXplKHdwLCBzLCBjb2wsIGhlYWRwKQogICAgd2luX1QJKndwOwogICAgY2hhcl91CSpzOwogICAgY29sbnJfVAljb2w7CiAgICBpbnQJCSpoZWFkcDsKewogICAgaW50CQluOwoKICAgIGlmICgqcyA9PSBUQUIgJiYgKCF3cC0+d19wX2xpc3QgfHwgbGNzX3RhYjEpKQogICAgewoJbiA9IHdwLT53X2J1ZmZlci0+Yl9wX3RzOwoJcmV0dXJuIChpbnQpKG4gLSAoY29sICUgbikpOwogICAgfQogICAgbiA9IHB0cjJjZWxscyhzKTsKICAgIC8qIEFkZCBvbmUgY2VsbCBmb3IgYSBkb3VibGUtd2lkdGggY2hhcmFjdGVyIGluIHRoZSBsYXN0IGNvbHVtbiBvZiB0aGUKICAgICAqIHdpbmRvdywgZGlzcGxheWVkIHdpdGggYSAiPiIuICovCiAgICBpZiAobiA9PSAyICYmIE1CX0JZVEUyTEVOKCpzKSA+IDEgJiYgaW5fd2luX2JvcmRlcih3cCwgY29sKSkKICAgIHsKCWlmIChoZWFkcCAhPSBOVUxMKQoJICAgICpoZWFkcCA9IDE7CglyZXR1cm4gMzsKICAgIH0KICAgIHJldHVybiBuOwp9CgovKgogKiBSZXR1cm4gVFJVRSBpZiB2aXJ0dWFsIGNvbHVtbiAidmNvbCIgaXMgaW4gdGhlIHJpZ2h0bW9zdCBjb2x1bW4gb2Ygd2luZG93CiAqICJ3cCIuCiAqLwogICAgaW50CmluX3dpbl9ib3JkZXIod3AsIHZjb2wpCiAgICB3aW5fVAkqd3A7CiAgICBjb2xucl9UCXZjb2w7CnsKICAgIGludAkJd2lkdGgxOwkJLyogd2lkdGggb2YgZmlyc3QgbGluZSAoYWZ0ZXIgbGluZSBudW1iZXIpICovCiAgICBpbnQJCXdpZHRoMjsJCS8qIHdpZHRoIG9mIGZ1cnRoZXIgbGluZXMgKi8KCiNpZmRlZiBGRUFUX1ZFUlRTUExJVAogICAgaWYgKHdwLT53X3dpZHRoID09IDApCS8qIHRoZXJlIGlzIG5vIGJvcmRlciAqLwoJcmV0dXJuIEZBTFNFOwojZW5kaWYKICAgIHdpZHRoMSA9IFdfV0lEVEgod3ApIC0gd2luX2NvbF9vZmYod3ApOwogICAgaWYgKChpbnQpdmNvbCA8IHdpZHRoMSAtIDEpCglyZXR1cm4gRkFMU0U7CiAgICBpZiAoKGludCl2Y29sID09IHdpZHRoMSAtIDEpCglyZXR1cm4gVFJVRTsKICAgIHdpZHRoMiA9IHdpZHRoMSArIHdpbl9jb2xfb2ZmMih3cCk7CiAgICByZXR1cm4gKCh2Y29sIC0gd2lkdGgxKSAlIHdpZHRoMiA9PSB3aWR0aDIgLSAxKTsKfQojZW5kaWYgLyogRkVBVF9NQllURSAqLwoKLyoKICogR2V0IHZpcnR1YWwgY29sdW1uIG51bWJlciBvZiBwb3MuCiAqICBzdGFydDogb24gdGhlIGZpcnN0IHBvc2l0aW9uIG9mIHRoaXMgY2hhcmFjdGVyIChUQUIsIGN0cmwpCiAqIGN1cnNvcjogd2hlcmUgdGhlIGN1cnNvciBpcyBvbiB0aGlzIGNoYXJhY3RlciAoZmlyc3QgY2hhciwgZXhjZXB0IGZvciBUQUIpCiAqICAgIGVuZDogb24gdGhlIGxhc3QgcG9zaXRpb24gb2YgdGhpcyBjaGFyYWN0ZXIgKFRBQiwgY3RybCkKICoKICogVGhpcyBpcyB1c2VkIHZlcnkgb2Z0ZW4sIGtlZXAgaXQgZmFzdCEKICovCiAgICB2b2lkCmdldHZjb2wod3AsIHBvcywgc3RhcnQsIGN1cnNvciwgZW5kKQogICAgd2luX1QJKndwOwogICAgcG9zX1QJKnBvczsKICAgIGNvbG5yX1QJKnN0YXJ0OwogICAgY29sbnJfVAkqY3Vyc29yOwogICAgY29sbnJfVAkqZW5kOwp7CiAgICBjb2xucl9UCXZjb2w7CiAgICBjaGFyX3UJKnB0cjsJCS8qIHBvaW50cyB0byBjdXJyZW50IGNoYXIgKi8KICAgIGNoYXJfdQkqcG9zcHRyOwkvKiBwb2ludHMgdG8gY2hhciBhdCBwb3MtPmNvbCAqLwogICAgaW50CQlpbmNyOwogICAgaW50CQloZWFkOwogICAgaW50CQl0cyA9IHdwLT53X2J1ZmZlci0+Yl9wX3RzOwogICAgaW50CQljOwoKICAgIHZjb2wgPSAwOwogICAgcHRyID0gbWxfZ2V0X2J1Zih3cC0+d19idWZmZXIsIHBvcy0+bG51bSwgRkFMU0UpOwogICAgcG9zcHRyID0gcHRyICsgcG9zLT5jb2w7CgogICAgLyoKICAgICAqIFRoaXMgZnVuY3Rpb24gaXMgdXNlZCB2ZXJ5IG9mdGVuLCBkbyBzb21lIHNwZWVkIG9wdGltaXphdGlvbnMuCiAgICAgKiBXaGVuICdsaXN0JywgJ2xpbmVicmVhaycgYW5kICdzaG93YnJlYWsnIGFyZSBub3Qgc2V0IHVzZSBhIHNpbXBsZSBsb29wLgogICAgICogQWxzbyB1c2UgdGhpcyB3aGVuICdsaXN0JyBpcyBzZXQgYnV0IHRhYnMgdGFrZSB0aGVpciBub3JtYWwgc2l6ZS4KICAgICAqLwogICAgaWYgKCghd3AtPndfcF9saXN0IHx8IGxjc190YWIxICE9IE5VTCkKI2lmZGVmIEZFQVRfTElORUJSRUFLCgkgICAgJiYgIXdwLT53X3BfbGJyICYmICpwX3NiciA9PSBOVUwKI2VuZGlmCiAgICAgICApCiAgICB7CiNpZm5kZWYgRkVBVF9NQllURQoJaGVhZCA9IDA7CiNlbmRpZgoJZm9yICg7OykKCXsKI2lmZGVmIEZFQVRfTUJZVEUKCSAgICBoZWFkID0gMDsKI2VuZGlmCgkgICAgYyA9ICpwdHI7CgkgICAgLyogbWFrZSBzdXJlIHdlIGRvbid0IGdvIHBhc3QgdGhlIGVuZCBvZiB0aGUgbGluZSAqLwoJICAgIGlmIChjID09IE5VTCkKCSAgICB7CgkJaW5jciA9IDE7CS8qIE5VTCBhdCBlbmQgb2YgbGluZSBvbmx5IHRha2VzIG9uZSBjb2x1bW4gKi8KCQlicmVhazsKCSAgICB9CgkgICAgLyogQSB0YWIgZ2V0cyBleHBhbmRlZCwgZGVwZW5kaW5nIG9uIHRoZSBjdXJyZW50IGNvbHVtbiAqLwoJICAgIGlmIChjID09IFRBQikKCQlpbmNyID0gdHMgLSAodmNvbCAlIHRzKTsKCSAgICBlbHNlCgkgICAgewojaWZkZWYgRkVBVF9NQllURQoJCWlmIChoYXNfbWJ5dGUpCgkJewoJCSAgICAvKiBGb3IgdXRmLTgsIGlmIHRoZSBieXRlIGlzID49IDB4ODAsIG5lZWQgdG8gbG9vayBhdAoJCSAgICAgKiBmdXJ0aGVyIGJ5dGVzIHRvIGZpbmQgdGhlIGNlbGwgd2lkdGguICovCgkJICAgIGlmIChlbmNfdXRmOCAmJiBjID49IDB4ODApCgkJCWluY3IgPSB1dGZfcHRyMmNlbGxzKHB0cik7CgkJICAgIGVsc2UKCQkJaW5jciA9IENIQVJTSVpFKGMpOwoKCQkgICAgLyogSWYgYSBkb3VibGUtY2VsbCBjaGFyIGRvZXNuJ3QgZml0IGF0IHRoZSBlbmQgb2YgYSBsaW5lCgkJICAgICAqIGl0IHdyYXBzIHRvIHRoZSBuZXh0IGxpbmUsIGl0J3MgbGlrZSB0aGlzIGNoYXIgaXMgdGhyZWUKCQkgICAgICogY2VsbHMgd2lkZS4gKi8KCQkgICAgaWYgKGluY3IgPT0gMiAmJiB3cC0+d19wX3dyYXAgJiYgTUJfQllURTJMRU4oKnB0cikgPiAxCgkJCSAgICAmJiBpbl93aW5fYm9yZGVyKHdwLCB2Y29sKSkKCQkgICAgewoJCQkrK2luY3I7CgkJCWhlYWQgPSAxOwoJCSAgICB9CgkJfQoJCWVsc2UKI2VuZGlmCgkJICAgIGluY3IgPSBDSEFSU0laRShjKTsKCSAgICB9CgoJICAgIGlmIChwdHIgPj0gcG9zcHRyKQkvKiBjaGFyYWN0ZXIgYXQgcG9zLT5jb2wgKi8KCQlicmVhazsKCgkgICAgdmNvbCArPSBpbmNyOwoJICAgIG1iX3B0cl9hZHYocHRyKTsKCX0KICAgIH0KICAgIGVsc2UKICAgIHsKCWZvciAoOzspCgl7CgkgICAgLyogQSB0YWIgZ2V0cyBleHBhbmRlZCwgZGVwZW5kaW5nIG9uIHRoZSBjdXJyZW50IGNvbHVtbiAqLwoJICAgIGhlYWQgPSAwOwoJICAgIGluY3IgPSB3aW5fbGJyX2NoYXJ0YWJzaXplKHdwLCBwdHIsIHZjb2wsICZoZWFkKTsKCSAgICAvKiBtYWtlIHN1cmUgd2UgZG9uJ3QgZ28gcGFzdCB0aGUgZW5kIG9mIHRoZSBsaW5lICovCgkgICAgaWYgKCpwdHIgPT0gTlVMKQoJICAgIHsKCQlpbmNyID0gMTsJLyogTlVMIGF0IGVuZCBvZiBsaW5lIG9ubHkgdGFrZXMgb25lIGNvbHVtbiAqLwoJCWJyZWFrOwoJICAgIH0KCgkgICAgaWYgKHB0ciA+PSBwb3NwdHIpCS8qIGNoYXJhY3RlciBhdCBwb3MtPmNvbCAqLwoJCWJyZWFrOwoKCSAgICB2Y29sICs9IGluY3I7CgkgICAgbWJfcHRyX2FkdihwdHIpOwoJfQogICAgfQogICAgaWYgKHN0YXJ0ICE9IE5VTEwpCgkqc3RhcnQgPSB2Y29sICsgaGVhZDsKICAgIGlmIChlbmQgIT0gTlVMTCkKCSplbmQgPSB2Y29sICsgaW5jciAtIDE7CiAgICBpZiAoY3Vyc29yICE9IE5VTEwpCiAgICB7CglpZiAoKnB0ciA9PSBUQUIKCQkmJiAoU3RhdGUgJiBOT1JNQUwpCgkJJiYgIXdwLT53X3BfbGlzdAoJCSYmICF2aXJ0dWFsX2FjdGl2ZSgpCiNpZmRlZiBGRUFUX1ZJU1VBTAoJCSYmICEoVklzdWFsX2FjdGl2ZQoJCQkJICAgJiYgKCpwX3NlbCA9PSAnZScgfHwgbHRvcmVxKCpwb3MsIFZJc3VhbCkpKQojZW5kaWYKCQkpCgkgICAgKmN1cnNvciA9IHZjb2wgKyBpbmNyIC0gMTsJICAgIC8qIGN1cnNvciBhdCBlbmQgKi8KCWVsc2UKCSAgICAqY3Vyc29yID0gdmNvbCArIGhlYWQ7CSAgICAvKiBjdXJzb3IgYXQgc3RhcnQgKi8KICAgIH0KfQoKLyoKICogR2V0IHZpcnR1YWwgY3Vyc29yIGNvbHVtbiBpbiB0aGUgY3VycmVudCB3aW5kb3csIHByZXRlbmRpbmcgJ2xpc3QnIGlzIG9mZi4KICovCiAgICBjb2xucl9UCmdldHZjb2xfbm9saXN0KHBvc3ApCiAgICBwb3NfVAkqcG9zcDsKewogICAgaW50CQlsaXN0X3NhdmUgPSBjdXJ3aW4tPndfcF9saXN0OwogICAgY29sbnJfVAl2Y29sOwoKICAgIGN1cndpbi0+d19wX2xpc3QgPSBGQUxTRTsKICAgIGdldHZjb2woY3Vyd2luLCBwb3NwLCBOVUxMLCAmdmNvbCwgTlVMTCk7CiAgICBjdXJ3aW4tPndfcF9saXN0ID0gbGlzdF9zYXZlOwogICAgcmV0dXJuIHZjb2w7Cn0KCiNpZiBkZWZpbmVkKEZFQVRfVklSVFVBTEVESVQpIHx8IGRlZmluZWQoUFJPVE8pCi8qCiAqIEdldCB2aXJ0dWFsIGNvbHVtbiBpbiB2aXJ0dWFsIG1vZGUuCiAqLwogICAgdm9pZApnZXR2dmNvbCh3cCwgcG9zLCBzdGFydCwgY3Vyc29yLCBlbmQpCiAgICB3aW5fVAkqd3A7CiAgICBwb3NfVAkqcG9zOwogICAgY29sbnJfVAkqc3RhcnQ7CiAgICBjb2xucl9UCSpjdXJzb3I7CiAgICBjb2xucl9UCSplbmQ7CnsKICAgIGNvbG5yX1QJY29sOwogICAgY29sbnJfVAljb2xhZGQ7CiAgICBjb2xucl9UCWVuZGFkZDsKIyBpZmRlZiBGRUFUX01CWVRFCiAgICBjaGFyX3UJKnB0cjsKIyBlbmRpZgoKICAgIGlmICh2aXJ0dWFsX2FjdGl2ZSgpKQogICAgewoJLyogRm9yIHZpcnR1YWwgbW9kZSwgb25seSB3YW50IG9uZSB2YWx1ZSAqLwoJZ2V0dmNvbCh3cCwgcG9zLCAmY29sLCBOVUxMLCBOVUxMKTsKCgljb2xhZGQgPSBwb3MtPmNvbGFkZDsKCWVuZGFkZCA9IDA7CiMgaWZkZWYgRkVBVF9NQllURQoJLyogQ2Fubm90IHB1dCB0aGUgY3Vyc29yIG9uIHBhcnQgb2YgYSB3aWRlIGNoYXJhY3Rlci4gKi8KCXB0ciA9IG1sX2dldF9idWYod3AtPndfYnVmZmVyLCBwb3MtPmxudW0sIEZBTFNFKTsKCWlmIChwb3MtPmNvbCA8IChjb2xucl9UKVNUUkxFTihwdHIpKQoJewoJICAgIGludCBjID0gKCptYl9wdHIyY2hhcikocHRyICsgcG9zLT5jb2wpOwoKCSAgICBpZiAoYyAhPSBUQUIgJiYgdmltX2lzcHJpbnRjKGMpKQoJICAgIHsKCQllbmRhZGQgPSAoY29sbnJfVCkoY2hhcjJjZWxscyhjKSAtIDEpOwoJCWlmIChjb2xhZGQgPiBlbmRhZGQpCS8qIHBhc3QgZW5kIG9mIGxpbmUgKi8KCQkgICAgZW5kYWRkID0gMDsKCQllbHNlCgkJICAgIGNvbGFkZCA9IDA7CgkgICAgfQoJfQojIGVuZGlmCgljb2wgKz0gY29sYWRkOwoJaWYgKHN0YXJ0ICE9IE5VTEwpCgkgICAgKnN0YXJ0ID0gY29sOwoJaWYgKGN1cnNvciAhPSBOVUxMKQoJICAgICpjdXJzb3IgPSBjb2w7CglpZiAoZW5kICE9IE5VTEwpCgkgICAgKmVuZCA9IGNvbCArIGVuZGFkZDsKICAgIH0KICAgIGVsc2UKCWdldHZjb2wod3AsIHBvcywgc3RhcnQsIGN1cnNvciwgZW5kKTsKfQojZW5kaWYKCiNpZiBkZWZpbmVkKEZFQVRfVklTVUFMKSB8fCBkZWZpbmVkKFBST1RPKQovKgogKiBHZXQgdGhlIGxlZnRtb3N0IGFuZCByaWdodG1vc3QgdmlydHVhbCBjb2x1bW4gb2YgcG9zMSBhbmQgcG9zMi4KICogVXNlZCBmb3IgVmlzdWFsIGJsb2NrIG1vZGUuCiAqLwogICAgdm9pZApnZXR2Y29scyh3cCwgcG9zMSwgcG9zMiwgbGVmdCwgcmlnaHQpCiAgICB3aW5fVAkqd3A7CiAgICBwb3NfVAkqcG9zMSwgKnBvczI7CiAgICBjb2xucl9UCSpsZWZ0LCAqcmlnaHQ7CnsKICAgIGNvbG5yX1QJZnJvbTEsIGZyb20yLCB0bzEsIHRvMjsKCiAgICBpZiAobHRwKHBvczEsIHBvczIpKQogICAgewoJZ2V0dnZjb2wod3AsIHBvczEsICZmcm9tMSwgTlVMTCwgJnRvMSk7CglnZXR2dmNvbCh3cCwgcG9zMiwgJmZyb20yLCBOVUxMLCAmdG8yKTsKICAgIH0KICAgIGVsc2UKICAgIHsKCWdldHZ2Y29sKHdwLCBwb3MyLCAmZnJvbTEsIE5VTEwsICZ0bzEpOwoJZ2V0dnZjb2wod3AsIHBvczEsICZmcm9tMiwgTlVMTCwgJnRvMik7CiAgICB9CiAgICBpZiAoZnJvbTIgPCBmcm9tMSkKCSpsZWZ0ID0gZnJvbTI7CiAgICBlbHNlCgkqbGVmdCA9IGZyb20xOwogICAgaWYgKHRvMiA+IHRvMSkKICAgIHsKCWlmICgqcF9zZWwgPT0gJ2UnICYmIGZyb20yIC0gMSA+PSB0bzEpCgkgICAgKnJpZ2h0ID0gZnJvbTIgLSAxOwoJZWxzZQoJICAgICpyaWdodCA9IHRvMjsKICAgIH0KICAgIGVsc2UKCSpyaWdodCA9IHRvMTsKfQojZW5kaWYKCi8qCiAqIHNraXB3aGl0ZTogc2tpcCBvdmVyICcgJyBhbmQgJ1x0Jy4KICovCiAgICBjaGFyX3UgKgpza2lwd2hpdGUocSkKICAgIGNoYXJfdQkqcTsKewogICAgY2hhcl91CSpwID0gcTsKCiAgICB3aGlsZSAodmltX2lzd2hpdGUoKnApKSAvKiBza2lwIHRvIG5leHQgbm9uLXdoaXRlICovCgkrK3A7CiAgICByZXR1cm4gcDsKfQoKLyoKICogc2tpcCBvdmVyIGRpZ2l0cwogKi8KICAgIGNoYXJfdSAqCnNraXBkaWdpdHMocSkKICAgIGNoYXJfdQkqcTsKewogICAgY2hhcl91CSpwID0gcTsKCiAgICB3aGlsZSAoVklNX0lTRElHSVQoKnApKQkvKiBza2lwIHRvIG5leHQgbm9uLWRpZ2l0ICovCgkrK3A7CiAgICByZXR1cm4gcDsKfQoKI2lmIGRlZmluZWQoRkVBVF9TWU5fSEwpIHx8IGRlZmluZWQoRkVBVF9TUEVMTCkgfHwgZGVmaW5lZChQUk9UTykKLyoKICogc2tpcCBvdmVyIGRpZ2l0cyBhbmQgaGV4IGNoYXJhY3RlcnMKICovCiAgICBjaGFyX3UgKgpza2lwaGV4KHEpCiAgICBjaGFyX3UJKnE7CnsKICAgIGNoYXJfdQkqcCA9IHE7CgogICAgd2hpbGUgKHZpbV9pc3hkaWdpdCgqcCkpCS8qIHNraXAgdG8gbmV4dCBub24tZGlnaXQgKi8KCSsrcDsKICAgIHJldHVybiBwOwp9CiNlbmRpZgoKI2lmIGRlZmluZWQoRkVBVF9FWF9FWFRSQSkgfHwgZGVmaW5lZChQUk9UTykKLyoKICogc2tpcCB0byBkaWdpdCAob3IgTlVMIGFmdGVyIHRoZSBzdHJpbmcpCiAqLwogICAgY2hhcl91ICoKc2tpcHRvZGlnaXQocSkKICAgIGNoYXJfdQkqcTsKewogICAgY2hhcl91CSpwID0gcTsKCiAgICB3aGlsZSAoKnAgIT0gTlVMICYmICFWSU1fSVNESUdJVCgqcCkpCS8qIHNraXAgdG8gbmV4dCBkaWdpdCAqLwoJKytwOwogICAgcmV0dXJuIHA7Cn0KCi8qCiAqIHNraXAgdG8gaGV4IGNoYXJhY3RlciAob3IgTlVMIGFmdGVyIHRoZSBzdHJpbmcpCiAqLwogICAgY2hhcl91ICoKc2tpcHRvaGV4KHEpCiAgICBjaGFyX3UJKnE7CnsKICAgIGNoYXJfdQkqcCA9IHE7CgogICAgd2hpbGUgKCpwICE9IE5VTCAmJiAhdmltX2lzeGRpZ2l0KCpwKSkJLyogc2tpcCB0byBuZXh0IGRpZ2l0ICovCgkrK3A7CiAgICByZXR1cm4gcDsKfQojZW5kaWYKCi8qCiAqIFZhcmlhbnQgb2YgaXNkaWdpdCgpIHRoYXQgY2FuIGhhbmRsZSBjaGFyYWN0ZXJzID4gMHgxMDAuCiAqIFdlIGRvbid0IHVzZSBpc2RpZ2l0KCkgaGVyZSwgYmVjYXVzZSBvbiBzb21lIHN5c3RlbXMgaXQgYWxzbyBjb25zaWRlcnMKICogc3VwZXJzY3JpcHQgMSB0byBiZSBhIGRpZ2l0LgogKiBVc2UgdGhlIFZJTV9JU0RJR0lUKCkgbWFjcm8gZm9yIHNpbXBsZSBhcmd1bWVudHMuCiAqLwogICAgaW50CnZpbV9pc2RpZ2l0KGMpCiAgICBpbnQJCWM7CnsKICAgIHJldHVybiAoYyA+PSAnMCcgJiYgYyA8PSAnOScpOwp9CgovKgogKiBWYXJpYW50IG9mIGlzeGRpZ2l0KCkgdGhhdCBjYW4gaGFuZGxlIGNoYXJhY3RlcnMgPiAweDEwMC4KICogV2UgZG9uJ3QgdXNlIGlzeGRpZ2l0KCkgaGVyZSwgYmVjYXVzZSBvbiBzb21lIHN5c3RlbXMgaXQgYWxzbyBjb25zaWRlcnMKICogc3VwZXJzY3JpcHQgMSB0byBiZSBhIGRpZ2l0LgogKi8KICAgIGludAp2aW1faXN4ZGlnaXQoYykKICAgIGludAkJYzsKewogICAgcmV0dXJuIChjID49ICcwJyAmJiBjIDw9ICc5JykKCXx8IChjID49ICdhJyAmJiBjIDw9ICdmJykKCXx8IChjID49ICdBJyAmJiBjIDw9ICdGJyk7Cn0KCiNpZiBkZWZpbmVkKEZFQVRfTUJZVEUpIHx8IGRlZmluZWQoUFJPVE8pCi8qCiAqIFZpbSdzIG93biBjaGFyYWN0ZXIgY2xhc3MgZnVuY3Rpb25zLiAgVGhlc2UgZXhpc3QgYmVjYXVzZSBtYW55IGxpYnJhcnkKICogaXNsb3dlcigpL3RvdXBwZXIoKSBldGMuIGRvIG5vdCB3b3JrIHByb3Blcmx5OiB0aGV5IGNyYXNoIHdoZW4gdXNlZCB3aXRoCiAqIGludmFsaWQgdmFsdWVzIG9yIGNhbid0IGhhbmRsZSBsYXRpbjEgd2hlbiB0aGUgbG9jYWxlIGlzIEMuCiAqIFNwZWVkIGlzIG1vc3QgaW1wb3J0YW50IGhlcmUuCiAqLwojZGVmaW5lIExBVElOMUxPV0VSICdsJwojZGVmaW5lIExBVElOMVVQUEVSICdVJwoKLyogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF0lXydhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgoaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4+Tl5ufo6err7O3u7/Dx8vP09fb3+Pn6+/z9/v8gKi8Kc3RhdGljIGNoYXJfdSBsYXRpbjFmbGFnc1syNTddID0gIiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVUgICAgICBsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVIFVVVVVVVVVsbGxsbGxsbGxsbGxsbGxsbGxsbGxsbGwgbGxsbGxsbGwiOwpzdGF0aWMgY2hhcl91IGxhdGluMXVwcGVyWzI1N10gPSAiICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIVwiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXFxdXl9gQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVp7fH1+f4CBgoOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e38DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW99jZ2tvc3d7/IjsKc3RhdGljIGNoYXJfdSBsYXRpbjFsb3dlclsyNTddID0gIiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICFcIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6W1xcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/4OHi4+Tl5ufo6err7O3u7/Dx8vP09fbX+Pn6+/z9/t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/yI7CgogICAgaW50CnZpbV9pc2xvd2VyKGMpCiAgICBpbnQJICAgIGM7CnsKICAgIGlmIChjIDw9ICdAJykKCXJldHVybiBGQUxTRTsKICAgIGlmIChjID49IDB4ODApCiAgICB7CglpZiAoZW5jX3V0ZjgpCgkgICAgcmV0dXJuIHV0Zl9pc2xvd2VyKGMpOwoJaWYgKGMgPj0gMHgxMDApCgl7CiNpZmRlZiBIQVZFX0lTV0xPV0VSCgkgICAgaWYgKGhhc19tYnl0ZSkKCQlyZXR1cm4gaXN3bG93ZXIoYyk7CiNlbmRpZgoJICAgIC8qIGlzbG93ZXIoKSBjYW4ndCBoYW5kbGUgdGhlc2UgY2hhcnMgYW5kIG1heSBjcmFzaCAqLwoJICAgIHJldHVybiBGQUxTRTsKCX0KCWlmIChlbmNfbGF0aW4xbGlrZSkKCSAgICByZXR1cm4gKGxhdGluMWZsYWdzW2NdICYgTEFUSU4xTE9XRVIpID09IExBVElOMUxPV0VSOwogICAgfQogICAgcmV0dXJuIGlzbG93ZXIoYyk7Cn0KCiAgICBpbnQKdmltX2lzdXBwZXIoYykKICAgIGludAkgICAgYzsKewogICAgaWYgKGMgPD0gJ0AnKQoJcmV0dXJuIEZBTFNFOwogICAgaWYgKGMgPj0gMHg4MCkKICAgIHsKCWlmIChlbmNfdXRmOCkKCSAgICByZXR1cm4gdXRmX2lzdXBwZXIoYyk7CglpZiAoYyA+PSAweDEwMCkKCXsKI2lmZGVmIEhBVkVfSVNXVVBQRVIKCSAgICBpZiAoaGFzX21ieXRlKQoJCXJldHVybiBpc3d1cHBlcihjKTsKI2VuZGlmCgkgICAgLyogaXNsb3dlcigpIGNhbid0IGhhbmRsZSB0aGVzZSBjaGFycyBhbmQgbWF5IGNyYXNoICovCgkgICAgcmV0dXJuIEZBTFNFOwoJfQoJaWYgKGVuY19sYXRpbjFsaWtlKQoJICAgIHJldHVybiAobGF0aW4xZmxhZ3NbY10gJiBMQVRJTjFVUFBFUikgPT0gTEFUSU4xVVBQRVI7CiAgICB9CiAgICByZXR1cm4gaXN1cHBlcihjKTsKfQoKICAgIGludAp2aW1fdG91cHBlcihjKQogICAgaW50CSAgICBjOwp7CiAgICBpZiAoYyA8PSAnQCcpCglyZXR1cm4gYzsKICAgIGlmIChjID49IDB4ODApCiAgICB7CglpZiAoZW5jX3V0ZjgpCgkgICAgcmV0dXJuIHV0Zl90b3VwcGVyKGMpOwoJaWYgKGMgPj0gMHgxMDApCgl7CiNpZmRlZiBIQVZFX1RPV1VQUEVSCgkgICAgaWYgKGhhc19tYnl0ZSkKCQlyZXR1cm4gdG93dXBwZXIoYyk7CiNlbmRpZgoJICAgIC8qIHRvdXBwZXIoKSBjYW4ndCBoYW5kbGUgdGhlc2UgY2hhcnMgYW5kIG1heSBjcmFzaCAqLwoJICAgIHJldHVybiBjOwoJfQoJaWYgKGVuY19sYXRpbjFsaWtlKQoJICAgIHJldHVybiBsYXRpbjF1cHBlcltjXTsKICAgIH0KICAgIHJldHVybiBUT1VQUEVSX0xPQyhjKTsKfQoKICAgIGludAp2aW1fdG9sb3dlcihjKQogICAgaW50CSAgICBjOwp7CiAgICBpZiAoYyA8PSAnQCcpCglyZXR1cm4gYzsKICAgIGlmIChjID49IDB4ODApCiAgICB7CglpZiAoZW5jX3V0ZjgpCgkgICAgcmV0dXJuIHV0Zl90b2xvd2VyKGMpOwoJaWYgKGMgPj0gMHgxMDApCgl7CiNpZmRlZiBIQVZFX1RPV0xPV0VSCgkgICAgaWYgKGhhc19tYnl0ZSkKCQlyZXR1cm4gdG93bG93ZXIoYyk7CiNlbmRpZgoJICAgIC8qIHRvbG93ZXIoKSBjYW4ndCBoYW5kbGUgdGhlc2UgY2hhcnMgYW5kIG1heSBjcmFzaCAqLwoJICAgIHJldHVybiBjOwoJfQoJaWYgKGVuY19sYXRpbjFsaWtlKQoJICAgIHJldHVybiBsYXRpbjFsb3dlcltjXTsKICAgIH0KICAgIHJldHVybiBUT0xPV0VSX0xPQyhjKTsKfQojZW5kaWYKCi8qCiAqIHNraXB0b3doaXRlOiBza2lwIG92ZXIgdGV4dCB1bnRpbCAnICcgb3IgJ1x0JyBvciBOVUwuCiAqLwogICAgY2hhcl91ICoKc2tpcHRvd2hpdGUocCkKICAgIGNoYXJfdQkqcDsKewogICAgd2hpbGUgKCpwICE9ICcgJyAmJiAqcCAhPSAnXHQnICYmICpwICE9IE5VTCkKCSsrcDsKICAgIHJldHVybiBwOwp9CgojaWYgZGVmaW5lZChGRUFUX0xJU1RDTURTKSB8fCBkZWZpbmVkKEZFQVRfU0lHTlMpIHx8IGRlZmluZWQoRkVBVF9TTklGRikgXAoJfHwgZGVmaW5lZChQUk9UTykKLyoKICogc2tpcHRvd2hpdGVfZXNjOiBMaWtlIHNraXB0b3doaXRlKCksIGJ1dCBhbHNvIHNraXAgZXNjYXBlZCBjaGFycwogKi8KICAgIGNoYXJfdSAqCnNraXB0b3doaXRlX2VzYyhwKQogICAgY2hhcl91CSpwOwp7CiAgICB3aGlsZSAoKnAgIT0gJyAnICYmICpwICE9ICdcdCcgJiYgKnAgIT0gTlVMKQogICAgewoJaWYgKCgqcCA9PSAnXFwnIHx8ICpwID09IEN0cmxfVikgJiYgKihwICsgMSkgIT0gTlVMKQoJICAgICsrcDsKCSsrcDsKICAgIH0KICAgIHJldHVybiBwOwp9CiNlbmRpZgoKLyoKICogR2V0ZGlnaXRzOiBHZXQgYSBudW1iZXIgZnJvbSBhIHN0cmluZyBhbmQgc2tpcCBvdmVyIGl0LgogKiBOb3RlOiB0aGUgYXJndW1lbnQgaXMgYSBwb2ludGVyIHRvIGEgY2hhcl91IHBvaW50ZXIhCiAqLwogICAgbG9uZwpnZXRkaWdpdHMocHApCiAgICBjaGFyX3UgKipwcDsKewogICAgY2hhcl91CSpwOwogICAgbG9uZwlyZXR2YWw7CgogICAgcCA9ICpwcDsKICAgIHJldHZhbCA9IGF0b2woKGNoYXIgKilwKTsKICAgIGlmICgqcCA9PSAnLScpCQkvKiBza2lwIG5lZ2F0aXZlIHNpZ24gKi8KCSsrcDsKICAgIHAgPSBza2lwZGlnaXRzKHApOwkJLyogc2tpcCB0byBuZXh0IG5vbi1kaWdpdCAqLwogICAgKnBwID0gcDsKICAgIHJldHVybiByZXR2YWw7Cn0KCi8qCiAqIFJldHVybiBUUlVFIGlmICJsYnVmIiBpcyBlbXB0eSBvciBvbmx5IGNvbnRhaW5zIGJsYW5rcy4KICovCiAgICBpbnQKdmltX2lzYmxhbmtsaW5lKGxidWYpCiAgICBjaGFyX3UJKmxidWY7CnsKICAgIGNoYXJfdQkqcDsKCiAgICBwID0gc2tpcHdoaXRlKGxidWYpOwogICAgcmV0dXJuICgqcCA9PSBOVUwgfHwgKnAgPT0gJ1xyJyB8fCAqcCA9PSAnXG4nKTsKfQoKLyoKICogQ29udmVydCBhIHN0cmluZyBpbnRvIGEgbG9uZyBhbmQvb3IgdW5zaWduZWQgbG9uZywgdGFraW5nIGNhcmUgb2YKICogaGV4YWRlY2ltYWwgYW5kIG9jdGFsIG51bWJlcnMuICBBY2NlcHRzIGEgJy0nIHNpZ24uCiAqIElmICJoZXhwIiBpcyBub3QgTlVMTCwgcmV0dXJucyBhIGZsYWcgdG8gaW5kaWNhdGUgdGhlIHR5cGUgb2YgdGhlIG51bWJlcjoKICogIDAJICAgIGRlY2ltYWwKICogICcwJwkgICAgb2N0YWwKICogICdYJwkgICAgaGV4CiAqICAneCcJICAgIGhleAogKiBJZiAibGVuIiBpcyBub3QgTlVMTCwgdGhlIGxlbmd0aCBvZiB0aGUgbnVtYmVyIGluIGNoYXJhY3RlcnMgaXMgcmV0dXJuZWQuCiAqIElmICJucHRyIiBpcyBub3QgTlVMTCwgdGhlIHNpZ25lZCByZXN1bHQgaXMgcmV0dXJuZWQgaW4gaXQuCiAqIElmICJ1bnB0ciIgaXMgbm90IE5VTEwsIHRoZSB1bnNpZ25lZCByZXN1bHQgaXMgcmV0dXJuZWQgaW4gaXQuCiAqIElmICJkb29jdCIgaXMgbm9uLXplcm8gcmVjb2duaXplIG9jdGFsIG51bWJlcnMsIHdoZW4gPiAxIGFsd2F5cyBhc3N1bWUKICogb2N0YWwgbnVtYmVyLgogKiBJZiAiZG9oZXgiIGlzIG5vbi16ZXJvIHJlY29nbml6ZSBoZXggbnVtYmVycywgd2hlbiA+IDEgYWx3YXlzIGFzc3VtZQogKiBoZXggbnVtYmVyLgogKi8KICAgIHZvaWQKdmltX3N0cjJucihzdGFydCwgaGV4cCwgbGVuLCBkb29jdCwgZG9oZXgsIG5wdHIsIHVucHRyKQogICAgY2hhcl91CQkqc3RhcnQ7CiAgICBpbnQJCQkqaGV4cDsJICAgIC8qIHJldHVybjogdHlwZSBvZiBudW1iZXIgMCA9IGRlY2ltYWwsICd4JwoJCQkJICAgICAgIG9yICdYJyBpcyBoZXgsICcwJyA9IG9jdGFsICovCiAgICBpbnQJCQkqbGVuOwkgICAgLyogcmV0dXJuOiBkZXRlY3RlZCBsZW5ndGggb2YgbnVtYmVyICovCiAgICBpbnQJCQlkb29jdDsJICAgIC8qIHJlY29nbml6ZSBvY3RhbCBudW1iZXIgKi8KICAgIGludAkJCWRvaGV4OwkgICAgLyogcmVjb2duaXplIGhleCBudW1iZXIgKi8KICAgIGxvbmcJCSpucHRyOwkgICAgLyogcmV0dXJuOiBzaWduZWQgcmVzdWx0ICovCiAgICB1bnNpZ25lZCBsb25nCSp1bnB0cjsJICAgIC8qIHJldHVybjogdW5zaWduZWQgcmVzdWx0ICovCnsKICAgIGNoYXJfdQkgICAgKnB0ciA9IHN0YXJ0OwogICAgaW50CQkgICAgaGV4ID0gMDsJCS8qIGRlZmF1bHQgaXMgZGVjaW1hbCAqLwogICAgaW50CQkgICAgbmVnYXRpdmUgPSBGQUxTRTsKICAgIHVuc2lnbmVkIGxvbmcgICB1biA9IDA7CiAgICBpbnQJCSAgICBuOwoKICAgIGlmIChwdHJbMF0gPT0gJy0nKQogICAgewoJbmVnYXRpdmUgPSBUUlVFOwoJKytwdHI7CiAgICB9CgogICAgLyogUmVjb2duaXplIGhleCBhbmQgb2N0YWwuICovCiAgICBpZiAocHRyWzBdID09ICcwJyAmJiBwdHJbMV0gIT0gJzgnICYmIHB0clsxXSAhPSAnOScpCiAgICB7CgloZXggPSBwdHJbMV07CglpZiAoZG9oZXggJiYgKGhleCA9PSAnWCcgfHwgaGV4ID09ICd4JykgJiYgdmltX2lzeGRpZ2l0KHB0clsyXSkpCgkgICAgcHRyICs9IDI7CQkJLyogaGV4YWRlY2ltYWwgKi8KCWVsc2UKCXsKCSAgICBoZXggPSAwOwkJCS8qIGRlZmF1bHQgaXMgZGVjaW1hbCAqLwoJICAgIGlmIChkb29jdCkKCSAgICB7CgkJLyogRG9uJ3QgaW50ZXJwcmV0ICIwIiwgIjA4IiBvciAiMDEyOSIgYXMgb2N0YWwuICovCgkJZm9yIChuID0gMTsgVklNX0lTRElHSVQocHRyW25dKTsgKytuKQoJCXsKCQkgICAgaWYgKHB0cltuXSA+ICc3JykKCQkgICAgewoJCQloZXggPSAwOwkvKiBjYW4ndCBiZSBvY3RhbCAqLwoJCQlicmVhazsKCQkgICAgfQoJCSAgICBpZiAocHRyW25dID4gJzAnKQoJCQloZXggPSAnMCc7CS8qIGFzc3VtZSBvY3RhbCAqLwoJCX0KCSAgICB9Cgl9CiAgICB9CgogICAgLyoKICAgICAqIERvIHRoZSBzdHJpbmctdG8tbnVtZXJpYyBjb252ZXJzaW9uICJtYW51YWxseSIgdG8gYXZvaWQgc3NjYW5mIHF1aXJrcy4KICAgICAqLwogICAgaWYgKGhleCA9PSAnMCcgfHwgZG9vY3QgPiAxKQogICAgewoJLyogb2N0YWwgKi8KCXdoaWxlICgnMCcgPD0gKnB0ciAmJiAqcHRyIDw9ICc3JykKCXsKCSAgICB1biA9IDggKiB1biArICh1bnNpZ25lZCBsb25nKSgqcHRyIC0gJzAnKTsKCSAgICArK3B0cjsKCX0KICAgIH0KICAgIGVsc2UgaWYgKGhleCAhPSAwIHx8IGRvaGV4ID4gMSkKICAgIHsKCS8qIGhleCAqLwoJd2hpbGUgKHZpbV9pc3hkaWdpdCgqcHRyKSkKCXsKCSAgICB1biA9IDE2ICogdW4gKyAodW5zaWduZWQgbG9uZyloZXgybnIoKnB0cik7CgkgICAgKytwdHI7Cgl9CiAgICB9CiAgICBlbHNlCiAgICB7CgkvKiBkZWNpbWFsICovCgl3aGlsZSAoVklNX0lTRElHSVQoKnB0cikpCgl7CgkgICAgdW4gPSAxMCAqIHVuICsgKHVuc2lnbmVkIGxvbmcpKCpwdHIgLSAnMCcpOwoJICAgICsrcHRyOwoJfQogICAgfQoKICAgIGlmIChoZXhwICE9IE5VTEwpCgkqaGV4cCA9IGhleDsKICAgIGlmIChsZW4gIT0gTlVMTCkKCSpsZW4gPSAoaW50KShwdHIgLSBzdGFydCk7CiAgICBpZiAobnB0ciAhPSBOVUxMKQogICAgewoJaWYgKG5lZ2F0aXZlKSAgIC8qIGFjY291bnQgZm9yIGxlYWRpbmcgJy0nIGZvciBkZWNpbWFsIG51bWJlcnMgKi8KCSAgICAqbnB0ciA9IC0obG9uZyl1bjsKCWVsc2UKCSAgICAqbnB0ciA9IChsb25nKXVuOwogICAgfQogICAgaWYgKHVucHRyICE9IE5VTEwpCgkqdW5wdHIgPSB1bjsKfQoKLyoKICogUmV0dXJuIHRoZSB2YWx1ZSBvZiBhIHNpbmdsZSBoZXggY2hhcmFjdGVyLgogKiBPbmx5IHZhbGlkIHdoZW4gdGhlIGFyZ3VtZW50IGlzICcwJyAtICc5JywgJ0EnIC0gJ0YnIG9yICdhJyAtICdmJy4KICovCiAgICBpbnQKaGV4Mm5yKGMpCiAgICBpbnQJCWM7CnsKICAgIGlmIChjID49ICdhJyAmJiBjIDw9ICdmJykKCXJldHVybiBjIC0gJ2EnICsgMTA7CiAgICBpZiAoYyA+PSAnQScgJiYgYyA8PSAnRicpCglyZXR1cm4gYyAtICdBJyArIDEwOwogICAgcmV0dXJuIGMgLSAnMCc7Cn0KCiNpZiBkZWZpbmVkKEZFQVRfVEVSTVJFU1BPTlNFKSBcCgl8fCAoZGVmaW5lZChGRUFUX0dVSV9HVEspICYmIGRlZmluZWQoRkVBVF9XSU5ET1dTKSkgfHwgZGVmaW5lZChQUk9UTykKLyoKICogQ29udmVydCB0d28gaGV4IGNoYXJhY3RlcnMgdG8gYSBieXRlLgogKiBSZXR1cm4gLTEgaWYgb25lIG9mIHRoZSBjaGFyYWN0ZXJzIGlzIG5vdCBoZXguCiAqLwogICAgaW50CmhleGhleDJucihwKQogICAgY2hhcl91CSpwOwp7CiAgICBpZiAoIXZpbV9pc3hkaWdpdChwWzBdKSB8fCAhdmltX2lzeGRpZ2l0KHBbMV0pKQoJcmV0dXJuIC0xOwogICAgcmV0dXJuIChoZXgybnIocFswXSkgPDwgNCkgKyBoZXgybnIocFsxXSk7Cn0KI2VuZGlmCgovKgogKiBSZXR1cm4gVFJVRSBpZiAic3RyIiBzdGFydHMgd2l0aCBhIGJhY2tzbGFzaCB0aGF0IHNob3VsZCBiZSByZW1vdmVkLgogKiBGb3IgTVMtRE9TLCBXSU4zMiBhbmQgT1MvMiB0aGlzIGlzIG9ubHkgZG9uZSB3aGVuIHRoZSBjaGFyYWN0ZXIgYWZ0ZXIgdGhlCiAqIGJhY2tzbGFzaCBpcyBub3QgYSBub3JtYWwgZmlsZSBuYW1lIGNoYXJhY3Rlci4KICogJyQnIGlzIGEgdmFsaWQgZmlsZSBuYW1lIGNoYXJhY3Rlciwgd2UgZG9uJ3QgcmVtb3ZlIHRoZSBiYWNrc2xhc2ggYmVmb3JlCiAqIGl0LiAgVGhpcyBtZWFucyBpdCBpcyBub3QgcG9zc2libGUgdG8gdXNlIGFuIGVudmlyb25tZW50IHZhcmlhYmxlIGFmdGVyIGEKICogYmFja3NsYXNoLiAgIkM6XCRWSU1cZG9jIiBpcyB0YWtlbiBsaXRlcmFsbHksIG9ubHkgIiRWSU1cZG9jIiB3b3Jrcy4KICogQWx0aG91Z2ggIlwgbmFtZSIgaXMgdmFsaWQsIHRoZSBiYWNrc2xhc2ggaW4gIlByb2dyYW1cIGZpbGVzIiBtdXN0IGJlCiAqIHJlbW92ZWQuICBBc3N1bWUgYSBmaWxlIG5hbWUgZG9lc24ndCBzdGFydCB3aXRoIGEgc3BhY2UuCiAqIEZvciBtdWx0aS1ieXRlIG5hbWVzLCBuZXZlciByZW1vdmUgYSBiYWNrc2xhc2ggYmVmb3JlIGEgbm9uLWFzY2lpCiAqIGNoYXJhY3RlciwgYXNzdW1lIHRoYXQgYWxsIG11bHRpLWJ5dGUgY2hhcmFjdGVycyBhcmUgdmFsaWQgZmlsZSBuYW1lCiAqIGNoYXJhY3RlcnMuCiAqLwogICAgaW50CnJlbV9iYWNrc2xhc2goc3RyKQogICAgY2hhcl91ICAqc3RyOwp7CiNpZmRlZiBCQUNLU0xBU0hfSU5fRklMRU5BTUUKICAgIHJldHVybiAoc3RyWzBdID09ICdcXCcKIyBpZmRlZiBGRUFUX01CWVRFCgkgICAgJiYgc3RyWzFdIDwgMHg4MAojIGVuZGlmCgkgICAgJiYgKHN0clsxXSA9PSAnICcKCQl8fCAoc3RyWzFdICE9IE5VTAoJCSAgICAmJiBzdHJbMV0gIT0gJyonCgkJICAgICYmIHN0clsxXSAhPSAnPycKCQkgICAgJiYgIXZpbV9pc2ZpbGVjKHN0clsxXSkpKSk7CiNlbHNlCiAgICByZXR1cm4gKHN0clswXSA9PSAnXFwnICYmIHN0clsxXSAhPSBOVUwpOwojZW5kaWYKfQoKLyoKICogSGFsdmUgdGhlIG51bWJlciBvZiBiYWNrc2xhc2hlcyBpbiBhIGZpbGUgbmFtZSBhcmd1bWVudC4KICogRm9yIE1TLURPUyB3ZSBvbmx5IGRvIHRoaXMgaWYgdGhlIGNoYXJhY3RlciBhZnRlciB0aGUgYmFja3NsYXNoCiAqIGlzIG5vdCBhIG5vcm1hbCBmaWxlIGNoYXJhY3Rlci4KICovCiAgICB2b2lkCmJhY2tzbGFzaF9oYWx2ZShwKQogICAgY2hhcl91CSpwOwp7CiAgICBmb3IgKCA7ICpwOyArK3ApCglpZiAocmVtX2JhY2tzbGFzaChwKSkKCSAgICBTVFJNT1ZFKHAsIHAgKyAxKTsKfQoKLyoKICogYmFja3NsYXNoX2hhbHZlKCkgcGx1cyBzYXZlIHRoZSByZXN1bHQgaW4gYWxsb2NhdGVkIG1lbW9yeS4KICovCiAgICBjaGFyX3UgKgpiYWNrc2xhc2hfaGFsdmVfc2F2ZShwKQogICAgY2hhcl91CSpwOwp7CiAgICBjaGFyX3UJKnJlczsKCiAgICByZXMgPSB2aW1fc3Ryc2F2ZShwKTsKICAgIGlmIChyZXMgPT0gTlVMTCkKCXJldHVybiBwOwogICAgYmFja3NsYXNoX2hhbHZlKHJlcyk7CiAgICByZXR1cm4gcmVzOwp9CgojaWYgKGRlZmluZWQoRUJDRElDKSAmJiBkZWZpbmVkKEZFQVRfUE9TVFNDUklQVCkpIHx8IGRlZmluZWQoUFJPVE8pCi8qCiAqIFRhYmxlIGZvciBFQkNESUMgdG8gQVNDSUkgY29udmVyc2lvbiB1bmFzaGFtZWRseSB0YWtlbiBmcm9tIHh4ZC5jIQogKiBUaGUgZmlyc3QgNjQgZW50cmllcyBoYXZlIGJlZW4gYWRkZWQgdG8gbWFwIGNvbnRyb2wgY2hhcmFjdGVycyBkZWZpbmVkIGluCiAqIGFzY2lpLmgKICovCnN0YXRpYyBjaGFyX3UgZWJjZGljMmFzY2lpX3RhYlsyNTZdID0KewogICAgMDAwMCwgMDAwMSwgMDAwMiwgMDAwMywgMDAwNCwgMDAxMSwgMDAwNiwgMDE3NywKICAgIDAwMTAsIDAwMTEsIDAwMTIsIDAwMTMsIDAwMTQsIDAwMTUsIDAwMTYsIDAwMTcsCiAgICAwMDIwLCAwMDIxLCAwMDIyLCAwMDIzLCAwMDI0LCAwMDEyLCAwMDEwLCAwMDI3LAogICAgMDAzMCwgMDAzMSwgMDAzMiwgMDAzMywgMDAzMywgMDAzNSwgMDAzNiwgMDAzNywKICAgIDAwNDAsIDAwNDEsIDAwNDIsIDAwNDMsIDAwNDQsIDAwNDUsIDAwNDYsIDAwNDcsCiAgICAwMDUwLCAwMDUxLCAwMDUyLCAwMDUzLCAwMDU0LCAwMDU1LCAwMDU2LCAwMDU3LAogICAgMDA2MCwgMDA2MSwgMDA2MiwgMDA2MywgMDA2NCwgMDA2NSwgMDA2NiwgMDA2NywKICAgIDAwNzAsIDAwNzEsIDAwNzIsIDAwNzMsIDAwNzQsIDAwNzUsIDAwNzYsIDAwNzcsCiAgICAwMDQwLCAwMjQwLCAwMjQxLCAwMjQyLCAwMjQzLCAwMjQ0LCAwMjQ1LCAwMjQ2LAogICAgMDI0NywgMDI1MCwgMDMyNSwgMDA1NiwgMDA3NCwgMDA1MCwgMDA1MywgMDE3NCwKICAgIDAwNDYsIDAyNTEsIDAyNTIsIDAyNTMsIDAyNTQsIDAyNTUsIDAyNTYsIDAyNTcsCiAgICAwMjYwLCAwMjYxLCAwMDQxLCAwMDQ0LCAwMDUyLCAwMDUxLCAwMDczLCAwMTc2LAogICAgMDA1NSwgMDA1NywgMDI2MiwgMDI2MywgMDI2NCwgMDI2NSwgMDI2NiwgMDI2NywKICAgIDAyNzAsIDAyNzEsIDAzMTMsIDAwNTQsIDAwNDUsIDAxMzcsIDAwNzYsIDAwNzcsCiAgICAwMjcyLCAwMjczLCAwMjc0LCAwMjc1LCAwMjc2LCAwMjc3LCAwMzAwLCAwMzAxLAogICAgMDMwMiwgMDE0MCwgMDA3MiwgMDA0MywgMDEwMCwgMDA0NywgMDA3NSwgMDA0MiwKICAgIDAzMDMsIDAxNDEsIDAxNDIsIDAxNDMsIDAxNDQsIDAxNDUsIDAxNDYsIDAxNDcsCiAgICAwMTUwLCAwMTUxLCAwMzA0LCAwMzA1LCAwMzA2LCAwMzA3LCAwMzEwLCAwMzExLAogICAgMDMxMiwgMDE1MiwgMDE1MywgMDE1NCwgMDE1NSwgMDE1NiwgMDE1NywgMDE2MCwKICAgIDAxNjEsIDAxNjIsIDAxMzYsIDAzMTQsIDAzMTUsIDAzMTYsIDAzMTcsIDAzMjAsCiAgICAwMzIxLCAwMzQ1LCAwMTYzLCAwMTY0LCAwMTY1LCAwMTY2LCAwMTY3LCAwMTcwLAogICAgMDE3MSwgMDE3MiwgMDMyMiwgMDMyMywgMDMyNCwgMDEzMywgMDMyNiwgMDMyNywKICAgIDAzMzAsIDAzMzEsIDAzMzIsIDAzMzMsIDAzMzQsIDAzMzUsIDAzMzYsIDAzMzcsCiAgICAwMzQwLCAwMzQxLCAwMzQyLCAwMzQzLCAwMzQ0LCAwMTM1LCAwMzQ2LCAwMzQ3LAogICAgMDE3MywgMDEwMSwgMDEwMiwgMDEwMywgMDEwNCwgMDEwNSwgMDEwNiwgMDEwNywKICAgIDAxMTAsIDAxMTEsIDAzNTAsIDAzNTEsIDAzNTIsIDAzNTMsIDAzNTQsIDAzNTUsCiAgICAwMTc1LCAwMTEyLCAwMTEzLCAwMTE0LCAwMTE1LCAwMTE2LCAwMTE3LCAwMTIwLAogICAgMDEyMSwgMDEyMiwgMDM1NiwgMDM1NywgMDM2MCwgMDM2MSwgMDM2MiwgMDM2MywKICAgIDAxMzQsIDAyMzcsIDAxMjMsIDAxMjQsIDAxMjUsIDAxMjYsIDAxMjcsIDAxMzAsCiAgICAwMTMxLCAwMTMyLCAwMzY0LCAwMzY1LCAwMzY2LCAwMzY3LCAwMzcwLCAwMzcxLAogICAgMDA2MCwgMDA2MSwgMDA2MiwgMDA2MywgMDA2NCwgMDA2NSwgMDA2NiwgMDA2NywKICAgIDAwNzAsIDAwNzEsIDAzNzIsIDAzNzMsIDAzNzQsIDAzNzUsIDAzNzYsIDAzNzcKfTsKCi8qCiAqIENvbnZlcnQgYSBidWZmZXIgd29ydGggb2YgY2hhcmFjdGVycyBmcm9tIEVCQ0RJQyB0byBBU0NJSS4gIE9ubHkgdXNlZnVsIGlmCiAqIHdhbnRpbmcgNy1iaXQgQVNDSUkgY2hhcmFjdGVycyBvdXQgdGhlIG90aGVyIGVuZC4KICovCiAgICB2b2lkCmViY2RpYzJhc2NpaShidWZmZXIsIGxlbikKICAgIGNoYXJfdQkqYnVmZmVyOwogICAgaW50CQlsZW47CnsKICAgIGludAkJaTsKCiAgICBmb3IgKGkgPSAwOyBpIDwgbGVuOyBpKyspCglidWZmZXJbaV0gPSBlYmNkaWMyYXNjaWlfdGFiW2J1ZmZlcltpXV07Cn0KI2VuZGlmCg==