Lyogdmk6IHNldCBzdz00IHRzPTQ6ICovCi8qCiAqIE1pbmkgbW91bnQgaW1wbGVtZW50YXRpb24gZm9yIGJ1c3lib3gKICoKICogQ29weXJpZ2h0IChDKSAxOTk1LCAxOTk2IGJ5IEJydWNlIFBlcmVucyA8YnJ1Y2VAcGl4YXIuY29tPi4KICogQ29weXJpZ2h0IChDKSAxOTk5LTIwMDQgYnkgRXJpayBBbmRlcnNlbiA8YW5kZXJzZW5AY29kZXBvZXQub3JnPgogKiBDb3B5cmlnaHQgKEMpIDIwMDUtMjAwNiBieSBSb2IgTGFuZGxleSA8cm9iQGxhbmRsZXkubmV0PgogKgogKiBMaWNlbnNlZCB1bmRlciBHUEx2MiBvciBsYXRlciwgc2VlIGZpbGUgTElDRU5TRSBpbiB0aGlzIHRhcmJhbGwgZm9yIGRldGFpbHMuCiAqLwoKLyogRGVzaWduIG5vdGVzOiBUaGVyZSBpcyBubyBzcGVjIGZvciBtb3VudC4gIFJlbWluZCBtZSB0byB3cml0ZSBvbmUuCgogICBtb3VudF9tYWluKCkgY2FsbHMgc2luZ2xlbW91bnQoKSB3aGljaCBjYWxscyBtb3VudF9pdF9ub3coKS4KCiAgIG1vdW50X21haW4oKSBjYW4gbG9vcCB0aHJvdWdoIC9ldGMvZnN0YWIgZm9yIG1vdW50IC1hCiAgIHNpbmdsZW1vdW50KCkgY2FuIGxvb3AgdGhyb3VnaCAvZXRjL2ZpbGVzeXN0ZW1zIGZvciBmc3R5cGUgZGV0ZWN0aW9uLgogICBtb3VudF9pdF9ub3coKSBkb2VzIHRoZSBhY3R1YWwgbW91bnQuCiovCgojaW5jbHVkZSA8bW50ZW50Lmg+CiNpbmNsdWRlICJsaWJiYi5oIgoKLyogTmVlZGVkIGZvciBuZnMgc3VwcG9ydCBvbmx5Li4uICovCiNpbmNsdWRlIDxzeXNsb2cuaD4KI2luY2x1ZGUgPHN5cy91dHNuYW1lLmg+CiN1bmRlZiBUUlVFCiN1bmRlZiBGQUxTRQojaW5jbHVkZSA8cnBjL3JwYy5oPgojaW5jbHVkZSA8cnBjL3BtYXBfcHJvdC5oPgojaW5jbHVkZSA8cnBjL3BtYXBfY2xudC5oPgoKI2lmbmRlZiBNU19TSUxFTlQKI2RlZmluZSBNU19TSUxFTlQJKDEgPDwgMTUpCiNlbmRpZgoKI2lmIGRlZmluZWQoX19kaWV0bGliY19fKQovKiAxNi4xMi4yMDA2LCBTYW1wbyBLZWxsb21ha2kgKHNhbXBvQGlraS5maSkKICogZGlldGxpYmMtMC4zMCBkb2VzIG5vdCBoYXZlIGltcGxlbWVudGF0aW9uIG9mIGdldG1udGVudF9yKCkgKi8Kc3RhdGljIHN0cnVjdCBtbnRlbnQgKmdldG1udGVudF9yKEZJTEUqIHN0cmVhbSwgc3RydWN0IG1udGVudCogcmVzdWx0LCBjaGFyKiBidWZmZXIsIGludCBidWZzaXplKQp7CglzdHJ1Y3QgbW50ZW50KiBtZW50ID0gZ2V0bW50ZW50KHN0cmVhbSk7CgltZW1jcHkocmVzdWx0LCBtZW50LCBzaXplb2Yoc3RydWN0IG1udGVudCkpOwoJcmV0dXJuIHJlc3VsdDsKfQojZW5kaWYKCiNkZWZpbmUgZ2V0bW50ZW50X2J1ZiBiYl9jb21tb25fYnVmc2l6MQoKCi8vIE5vdCByZWFsIGZsYWdzLCBidXQgd2Ugd2FudCB0byBiZSBhYmxlIHRvIGNoZWNrIGZvciB0aGlzLgplbnVtIHsKCU1PVU5UX1VTRVJTICA9ICgxPDwyOCkqRU5BQkxFX0RFU0tUT1AsCglNT1VOVF9OT0FVVE8gPSAoMTw8MjkpLAoJTU9VTlRfU1dBUCAgID0gKDE8PDMwKSwKfTsKLy8gVE9ETzogbW9yZSAidXNlciIgZmxhZyBjb21wYXRpYmlsaXR5LgovLyAidXNlciIgb3B0aW9uIChmcm9tIG1vdW50IG1hbnBhZ2UpOgovLyBPbmx5IHRoZSB1c2VyIHRoYXQgbW91bnRlZCBhIGZpbGVzeXN0ZW0gY2FuIHVubW91bnQgaXQgYWdhaW4uCi8vIElmIGFueSB1c2VyIHNob3VsZCBiZSBhYmxlIHRvIHVubW91bnQsIHRoZW4gdXNlIHVzZXJzIGluc3RlYWQgb2YgdXNlcgovLyBpbiB0aGUgZnN0YWIgbGluZS4gIFRoZSBvd25lciBvcHRpb24gaXMgc2ltaWxhciB0byB0aGUgdXNlciBvcHRpb24sCi8vIHdpdGggdGhlIHJlc3RyaWN0aW9uIHRoYXQgdGhlIHVzZXIgbXVzdCBiZSB0aGUgb3duZXIgb2YgdGhlIHNwZWNpYWwgZmlsZS4KLy8gVGhpcyBtYXkgYmUgdXNlZnVsIGUuZy4gZm9yIC9kZXYvZmQgaWYgYSBsb2dpbiBzY3JpcHQgbWFrZXMKLy8gdGhlIGNvbnNvbGUgdXNlciBvd25lciBvZiB0aGlzIGRldmljZS4KCi8qIFN0YW5kYXJkIG1vdW50IG9wdGlvbnMgKGZyb20gLW8gb3B0aW9ucyBvciAtLW9wdGlvbnMpLCB3aXRoIGNvcnJlc3BvbmRpbmcKICogZmxhZ3MgKi8KCnN0YXRpYyBjb25zdCBpbnQzMl90IG1vdW50X29wdGlvbnNbXSA9IHsKCS8vIE1TX0ZMQUdTIHNldCBhIGJpdC4gIH5NU19GTEFHUyBkaXNhYmxlIHRoYXQgYml0LiAgMCBmbGFncyBhcmUgTk9Qcy4KCglVU0VfRkVBVFVSRV9NT1VOVF9MT09QKAoJCS8qICJsb29wIiAqLyAwLAoJKQoKCVVTRV9GRUFUVVJFX01PVU5UX0ZTVEFCKAoJCS8qICJkZWZhdWx0cyIgKi8gMCwKCQkvKiAicXVpZXQiIDAgLSBkbyBub3QgZmlsdGVyIG91dCwgdmZhdCB3YW50cyB0byBzZWUgaXQgKi8KCQkvKiAibm9hdXRvIiAqLyBNT1VOVF9OT0FVVE8sCgkJLyogInN3IiAgICAgKi8gTU9VTlRfU1dBUCwKCQkvKiAic3dhcCIgICAqLyBNT1VOVF9TV0FQLAoJCVVTRV9ERVNLVE9QKC8qICJ1c2VyIiAgKi8gTU9VTlRfVVNFUlMsKQoJCVVTRV9ERVNLVE9QKC8qICJ1c2VycyIgKi8gTU9VTlRfVVNFUlMsKQoJKQoKCVVTRV9GRUFUVVJFX01PVU5UX0ZMQUdTKAoJCS8vIHZmcyBmbGFncwoJCS8qICJub3N1aWQiICAgICAgKi8gTVNfTk9TVUlELAoJCS8qICJzdWlkIiAgICAgICAgKi8gfk1TX05PU1VJRCwKCQkvKiAiZGV2IiAgICAgICAgICovIH5NU19OT0RFViwKCQkvKiAibm9kZXYiICAgICAgICovIE1TX05PREVWLAoJCS8qICJleGVjIiAgICAgICAgKi8gfk1TX05PRVhFQywKCQkvKiAibm9leGVjIiAgICAgICovIE1TX05PRVhFQywKCQkvKiAic3luYyIgICAgICAgICovIE1TX1NZTkNIUk9OT1VTLAoJCS8qICJhc3luYyIgICAgICAgKi8gfk1TX1NZTkNIUk9OT1VTLAoJCS8qICJhdGltZSIgICAgICAgKi8gfk1TX05PQVRJTUUsCgkJLyogIm5vYXRpbWUiICAgICAqLyBNU19OT0FUSU1FLAoJCS8qICJkaXJhdGltZSIgICAgKi8gfk1TX05PRElSQVRJTUUsCgkJLyogIm5vZGlyYXRpbWUiICAqLyBNU19OT0RJUkFUSU1FLAoJCS8qICJsb3VkIiAgICAgICAgKi8gfk1TX1NJTEVOVCwKCgkJLy8gYWN0aW9uIGZsYWdzCgkJLyogImJpbmQiICAgICAgICAqLyBNU19CSU5ELAoJCS8qICJtb3ZlIiAgICAgICAgKi8gTVNfTU9WRSwKCQkvKiAic2hhcmVkIiAgICAgICovIE1TX1NIQVJFRCwKCQkvKiAic2xhdmUiICAgICAgICovIE1TX1NMQVZFLAoJCS8qICJwcml2YXRlIiAgICAgKi8gTVNfUFJJVkFURSwKCQkvKiAidW5iaW5kYWJsZSIgICovIE1TX1VOQklOREFCTEUsCgkJLyogInJzaGFyZWQiICAgICAqLyBNU19TSEFSRUR8TVNfUkVDVVJTSVZFLAoJCS8qICJyc2xhdmUiICAgICAgKi8gTVNfU0xBVkV8TVNfUkVDVVJTSVZFLAoJCS8qICJycHJpdmF0ZSIgICAgKi8gTVNfU0xBVkV8TVNfUkVDVVJTSVZFLAoJCS8qICJydW5iaW5kYWJsZSIgKi8gTVNfVU5CSU5EQUJMRXxNU19SRUNVUlNJVkUsCgkpCgoJLy8gQWx3YXlzIHVuZGVyc3Rvb2QuCgkvKiAicm8iICAgICAgKi8gTVNfUkRPTkxZLCAgLy8gdmZzIGZsYWcKCS8qICJydyIgICAgICAqLyB+TVNfUkRPTkxZLCAvLyB2ZnMgZmxhZwoJLyogInJlbW91bnQiICovIE1TX1JFTU9VTlQgIC8vIGFjdGlvbiBmbGFnCn07CgpzdGF0aWMgY29uc3QgY2hhciBtb3VudF9vcHRpb25fc3RyW10gPQoJVVNFX0ZFQVRVUkVfTU9VTlRfTE9PUCgKCQkibG9vcCIgIlwwIgoJKQoJVVNFX0ZFQVRVUkVfTU9VTlRfRlNUQUIoCgkJImRlZmF1bHRzIiAiXDAiCgkJLyogInF1aWV0IiAiXDAiIC0gZG8gbm90IGZpbHRlciBvdXQsIHZmYXQgd2FudHMgdG8gc2VlIGl0ICovCgkJIm5vYXV0byIgIlwwIgoJCSJzdyIgIlwwIgoJCSJzd2FwIiAiXDAiCgkJVVNFX0RFU0tUT1AoInVzZXIiICJcMCIpCgkJVVNFX0RFU0tUT1AoInVzZXJzIiAiXDAiKQoJKQoJVVNFX0ZFQVRVUkVfTU9VTlRfRkxBR1MoCgkJLy8gdmZzIGZsYWdzCgkJIm5vc3VpZCIgIlwwIgoJCSJzdWlkIiAiXDAiCgkJImRldiIgIlwwIgoJCSJub2RldiIgIlwwIgoJCSJleGVjIiAiXDAiCgkJIm5vZXhlYyIgIlwwIgoJCSJzeW5jIiAiXDAiCgkJImFzeW5jIiAiXDAiCgkJImF0aW1lIiAiXDAiCgkJIm5vYXRpbWUiICJcMCIKCQkiZGlyYXRpbWUiICJcMCIKCQkibm9kaXJhdGltZSIgIlwwIgoJCSJsb3VkIiAiXDAiCgoJCS8vIGFjdGlvbiBmbGFncwoJCSJiaW5kIiAiXDAiCgkJIm1vdmUiICJcMCIKCQkic2hhcmVkIiAiXDAiCgkJInNsYXZlIiAiXDAiCgkJInByaXZhdGUiICJcMCIKCQkidW5iaW5kYWJsZSIgIlwwIgoJCSJyc2hhcmVkIiAiXDAiCgkJInJzbGF2ZSIgIlwwIgoJCSJycHJpdmF0ZSIgIlwwIgoJCSJydW5iaW5kYWJsZSIgIlwwIgoJKQoKCS8vIEFsd2F5cyB1bmRlcnN0b29kLgoJInJvIiAiXDAiICAgICAgICAvLyB2ZnMgZmxhZwoJInJ3IiAiXDAiICAgICAgICAvLyB2ZnMgZmxhZwoJInJlbW91bnQiICJcMCIgICAvLyBhY3Rpb24gZmxhZwo7CgovKiBBcHBlbmQgbW91bnQgb3B0aW9ucyB0byBzdHJpbmcgKi8Kc3RhdGljIHZvaWQgYXBwZW5kX21vdW50X29wdGlvbnMoY2hhciAqKm9sZG9wdHMsIGNvbnN0IGNoYXIgKm5ld29wdHMpCnsKCWlmICgqb2xkb3B0cyAmJiAqKm9sZG9wdHMpIHsKCQkvKiBkbyBub3QgaW5zZXJ0IG9wdGlvbnMgd2hpY2ggYXJlIGFscmVhZHkgdGhlcmUgKi8KCQl3aGlsZSAobmV3b3B0c1swXSkgewoJCQljaGFyICpwOwoJCQlpbnQgbGVuID0gc3RybGVuKG5ld29wdHMpOwoJCQlwID0gc3RyY2hyKG5ld29wdHMsICcsJyk7CgkJCWlmIChwKSBsZW4gPSBwIC0gbmV3b3B0czsKCQkJcCA9ICpvbGRvcHRzOwoJCQl3aGlsZSAoMSkgewoJCQkJaWYgKCFzdHJuY21wKHAsIG5ld29wdHMsIGxlbikKCQkJCSAmJiAocFtsZW5dID09ICcsJyB8fCBwW2xlbl0gPT0gJ1wwJykpCgkJCQkJZ290byBza2lwOwoJCQkJcCA9IHN0cmNocihwLCcsJyk7CgkJCQlpZiAoIXApIGJyZWFrOwoJCQkJcCsrOwoJCQl9CgkJCXAgPSB4YXNwcmludGYoIiVzLCUuKnMiLCAqb2xkb3B0cywgbGVuLCBuZXdvcHRzKTsKCQkJZnJlZSgqb2xkb3B0cyk7CgkJCSpvbGRvcHRzID0gcDsKIHNraXA6CgkJCW5ld29wdHMgKz0gbGVuOwoJCQl3aGlsZSAobmV3b3B0c1swXSA9PSAnLCcpIG5ld29wdHMrKzsKCQl9Cgl9IGVsc2UgewoJCWlmIChFTkFCTEVfRkVBVFVSRV9DTEVBTl9VUCkgZnJlZSgqb2xkb3B0cyk7CgkJKm9sZG9wdHMgPSB4c3RyZHVwKG5ld29wdHMpOwoJfQp9CgovKiBVc2UgdGhlIG1vdW50X29wdGlvbnMgbGlzdCB0byBwYXJzZSBvcHRpb25zIGludG8gZmxhZ3MuCiAqIEFsc28gcmV0dXJuIGxpc3Qgb2YgdW5yZWNvZ25pemVkIG9wdGlvbnMgaWYgdW5yZWNvZ25pemVkIT1OVUxMICovCnN0YXRpYyBpbnQgcGFyc2VfbW91bnRfb3B0aW9ucyhjaGFyICpvcHRpb25zLCBjaGFyICoqdW5yZWNvZ25pemVkKQp7CglpbnQgZmxhZ3MgPSBNU19TSUxFTlQ7CgoJLy8gTG9vcCB0aHJvdWdoIG9wdGlvbnMKCWZvciAoOzspIHsKCQlpbnQgaTsKCQljaGFyICpjb21tYSA9IHN0cmNocihvcHRpb25zLCAnLCcpOwoJCWNvbnN0IGNoYXIgKm9wdGlvbl9zdHIgPSBtb3VudF9vcHRpb25fc3RyOwoKCQlpZiAoY29tbWEpICpjb21tYSA9ICdcMCc7CgoJCS8vIEZpbmQgdGhpcyBvcHRpb24gaW4gbW91bnRfb3B0aW9ucwoJCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKG1vdW50X29wdGlvbnMpOyBpKyspIHsKCQkJaWYgKCFzdHJjYXNlY21wKG9wdGlvbl9zdHIsIG9wdGlvbnMpKSB7CgkJCQlsb25nIGZsID0gbW91bnRfb3B0aW9uc1tpXTsKCQkJCWlmIChmbCA8IDApIGZsYWdzICY9IGZsOwoJCQkJZWxzZSBmbGFncyB8PSBmbDsKCQkJCWJyZWFrOwoJCQl9CgkJCW9wdGlvbl9zdHIgKz0gc3RybGVuKG9wdGlvbl9zdHIpICsgMTsKCQl9CgkJLy8gSWYgdW5yZWNvZ25pemVkIG5vdCBOVUxMLCBhcHBlbmQgdW5yZWNvZ25pemVkIG1vdW50IG9wdGlvbnMgKi8KCQlpZiAodW5yZWNvZ25pemVkICYmIGkgPT0gQVJSQVlfU0laRShtb3VudF9vcHRpb25zKSkgewoJCQkvLyBBZGQgaXQgdG8gc3RyZmxhZ3MsIHRvIHBhc3Mgb24gdG8ga2VybmVsCgkJCWkgPSAqdW5yZWNvZ25pemVkID8gc3RybGVuKCp1bnJlY29nbml6ZWQpIDogMDsKCQkJKnVucmVjb2duaXplZCA9IHhyZWFsbG9jKCp1bnJlY29nbml6ZWQsIGkrc3RybGVuKG9wdGlvbnMpKzIpOwoKCQkJLy8gQ29tbWEgc2VwYXJhdGVkIGlmIGl0J3Mgbm90IHRoZSBmaXJzdCBvbmUKCQkJaWYgKGkpICgqdW5yZWNvZ25pemVkKVtpKytdID0gJywnOwoJCQlzdHJjcHkoKCp1bnJlY29nbml6ZWQpK2ksIG9wdGlvbnMpOwoJCX0KCgkJaWYgKCFjb21tYSkKCQkJYnJlYWs7CgkJLy8gQWR2YW5jZSB0byBuZXh0IG9wdGlvbgoJCSpjb21tYSA9ICcsJzsKCQlvcHRpb25zID0gKytjb21tYTsKCX0KCglyZXR1cm4gZmxhZ3M7Cn0KCi8vIFJldHVybiBhIGxpc3Qgb2YgYWxsIGJsb2NrIGRldmljZSBiYWNrZWQgZmlsZXN5c3RlbXMKCnN0YXRpYyBsbGlzdF90ICpnZXRfYmxvY2tfYmFja2VkX2ZpbGVzeXN0ZW1zKHZvaWQpCnsKCXN0YXRpYyBjb25zdCBjaGFyIGZpbGVzeXN0ZW1zWzJdW3NpemVvZigiL3Byb2MvZmlsZXN5c3RlbXMiKV0gPSB7CgkJIi9ldGMvZmlsZXN5c3RlbXMiLAoJCSIvcHJvYy9maWxlc3lzdGVtcyIsCgl9OwoJY2hhciAqZnMsICpidWY7CglsbGlzdF90ICpsaXN0ID0gMDsKCWludCBpOwoJRklMRSAqZjsKCglmb3IgKGkgPSAwOyBpIDwgMjsgaSsrKSB7CgkJZiA9IGZvcGVuKGZpbGVzeXN0ZW1zW2ldLCAiciIpOwoJCWlmICghZikgY29udGludWU7CgoJCXdoaWxlICgoYnVmID0geG1hbGxvY19nZXRsaW5lKGYpKSAhPSAwKSB7CgkJCWlmICghc3RybmNtcChidWYsICJub2RldiIsIDUpICYmIGlzc3BhY2UoYnVmWzVdKSkKCQkJCWNvbnRpbnVlOwoJCQlmcyA9IHNraXBfd2hpdGVzcGFjZShidWYpOwoJCQlpZiAoKmZzPT0nIycgfHwgKmZzPT0nKicgfHwgISpmcykgY29udGludWU7CgoJCQlsbGlzdF9hZGRfdG9fZW5kKCZsaXN0LCB4c3RyZHVwKGZzKSk7CgkJCWZyZWUoYnVmKTsKCQl9CgkJaWYgKEVOQUJMRV9GRUFUVVJFX0NMRUFOX1VQKSBmY2xvc2UoZik7Cgl9CgoJcmV0dXJuIGxpc3Q7Cn0KCnN0YXRpYyBsbGlzdF90ICpmc2xpc3Q7CgojaWYgRU5BQkxFX0ZFQVRVUkVfQ0xFQU5fVVAKc3RhdGljIHZvaWQgZGVsZXRlX2Jsb2NrX2JhY2tlZF9maWxlc3lzdGVtcyh2b2lkKQp7CglsbGlzdF9mcmVlKGZzbGlzdCwgZnJlZSk7Cn0KI2Vsc2UKdm9pZCBkZWxldGVfYmxvY2tfYmFja2VkX2ZpbGVzeXN0ZW1zKHZvaWQpOwojZW5kaWYKCiNpZiBFTkFCTEVfRkVBVFVSRV9NVEFCX1NVUFBPUlQKc3RhdGljIGludCB1c2VNdGFiID0gMTsKc3RhdGljIGludCBmYWtlSXQ7CiNlbHNlCiNkZWZpbmUgdXNlTXRhYiAwCiNkZWZpbmUgZmFrZUl0IDAKI2VuZGlmCgovLyBQZXJmb3JtIGFjdHVhbCBtb3VudCBvZiBzcGVjaWZpYyBmaWxlc3lzdGVtIGF0IHNwZWNpZmljIGxvY2F0aW9uLgovLyBOQjogbXAtPnh4eCBmaWVsZHMgbWF5IGJlIHRyYXNoZWQgb24gZXhpdApzdGF0aWMgaW50IG1vdW50X2l0X25vdyhzdHJ1Y3QgbW50ZW50ICptcCwgaW50IHZmc2ZsYWdzLCBjaGFyICpmaWx0ZXJvcHRzKQp7CglpbnQgcmMgPSAwOwoKCWlmIChmYWtlSXQpIGdvdG8gbXRhYjsKCgkvLyBNb3VudCwgd2l0aCBmYWxsYmFjayB0byByZWFkLW9ubHkgaWYgbmVjZXNzYXJ5LgoKCWZvciAoOzspIHsKCQlyYyA9IG1vdW50KG1wLT5tbnRfZnNuYW1lLCBtcC0+bW50X2RpciwgbXAtPm1udF90eXBlLAoJCQkJdmZzZmxhZ3MsIGZpbHRlcm9wdHMpOwoJCWlmICghcmMgfHwgKHZmc2ZsYWdzICYgTVNfUkRPTkxZKSB8fCAoZXJybm8gIT0gRUFDQ0VTICYmIGVycm5vICE9IEVST0ZTKSkKCQkJYnJlYWs7CgkJaWYgKCEodmZzZmxhZ3MgJiBNU19TSUxFTlQpKQoJCQliYl9lcnJvcl9tc2coIiVzIGlzIHdyaXRlLXByb3RlY3RlZCwgbW91bnRpbmcgcmVhZC1vbmx5IiwKCQkJCQkJbXAtPm1udF9mc25hbWUpOwoJCXZmc2ZsYWdzIHw9IE1TX1JET05MWTsKCX0KCgkvLyBBYm9ydCBlbnRpcmVseSBpZiBwZXJtaXNzaW9uIGRlbmllZC4KCglpZiAocmMgJiYgZXJybm8gPT0gRVBFUk0pCgkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoYmJfbXNnX3Blcm1fZGVuaWVkX2FyZV95b3Vfcm9vdCk7CgoJLyogSWYgdGhlIG1vdW50IHdhcyBzdWNjZXNzZnVsLCBhbmQgd2UncmUgbWFpbnRhaW5pbmcgYW4gb2xkLXN0eWxlCgkgKiBtdGFiIGZpbGUgYnkgaGFuZCwgYWRkIHRoZSBuZXcgZW50cnkgdG8gaXQgbm93LiAqLwogbXRhYjoKCWlmIChFTkFCTEVfRkVBVFVSRV9NVEFCX1NVUFBPUlQgJiYgdXNlTXRhYiAmJiAhcmMgJiYgISh2ZnNmbGFncyAmIE1TX1JFTU9VTlQpKSB7CgkJY2hhciAqZnNuYW1lOwoJCUZJTEUgKm1vdW50VGFibGUgPSBzZXRtbnRlbnQoYmJfcGF0aF9tdGFiX2ZpbGUsICJhKyIpOwoJCWNvbnN0IGNoYXIgKm9wdGlvbl9zdHIgPSBtb3VudF9vcHRpb25fc3RyOwoJCWludCBpOwoKCQlpZiAoIW1vdW50VGFibGUpIHsKCQkJYmJfZXJyb3JfbXNnKCJubyAlcyIsIGJiX3BhdGhfbXRhYl9maWxlKTsKCQkJZ290byByZXQ7CgkJfQoKCQkvLyBBZGQgdmZzIHN0cmluZyBmbGFncwoKCQlmb3IgKGkgPSAwOyBtb3VudF9vcHRpb25zW2ldICE9IE1TX1JFTU9VTlQ7IGkrKykgewoJCQlpZiAobW91bnRfb3B0aW9uc1tpXSA+IDAgJiYgKG1vdW50X29wdGlvbnNbaV0gJiB2ZnNmbGFncykpCgkJCQlhcHBlbmRfbW91bnRfb3B0aW9ucygmKG1wLT5tbnRfb3B0cyksIG9wdGlvbl9zdHIpOwoJCQlvcHRpb25fc3RyICs9IHN0cmxlbihvcHRpb25fc3RyKSArIDE7CgkJfQoKCQkvLyBSZW1vdmUgdHJhaWxpbmcgLyAoaWYgYW55KSBmcm9tIGRpcmVjdG9yeSB3ZSBtb3VudGVkIG9uCgoJCWkgPSBzdHJsZW4obXAtPm1udF9kaXIpIC0gMTsKCQlpZiAoaSA+IDAgJiYgbXAtPm1udF9kaXJbaV0gPT0gJy8nKSBtcC0+bW50X2RpcltpXSA9ICdcMCc7CgoJCS8vIENvbnZlcnQgdG8gY2Fub25pY2FsIHBhdGhuYW1lcyBhcyBuZWVkZWQKCgkJbXAtPm1udF9kaXIgPSBiYl9zaW1wbGlmeV9wYXRoKG1wLT5tbnRfZGlyKTsKCQlmc25hbWUgPSAwOwoJCWlmICghbXAtPm1udF90eXBlIHx8ICEqbXAtPm1udF90eXBlKSB7IC8qIGJpbmQgbW91bnQgKi8KCQkJbXAtPm1udF9mc25hbWUgPSBmc25hbWUgPSBiYl9zaW1wbGlmeV9wYXRoKG1wLT5tbnRfZnNuYW1lKTsKCQkJbXAtPm1udF90eXBlID0gKGNoYXIqKSJiaW5kIjsKCQl9CgkJbXAtPm1udF9mcmVxID0gbXAtPm1udF9wYXNzbm8gPSAwOwoKCQkvLyBXcml0ZSBhbmQgY2xvc2UuCgoJCWFkZG1udGVudChtb3VudFRhYmxlLCBtcCk7CgkJZW5kbW50ZW50KG1vdW50VGFibGUpOwoJCWlmIChFTkFCTEVfRkVBVFVSRV9DTEVBTl9VUCkgewoJCQlmcmVlKG1wLT5tbnRfZGlyKTsKCQkJZnJlZShmc25hbWUpOwoJCX0KCX0KIHJldDoKCXJldHVybiByYzsKfQoKI2lmIEVOQUJMRV9GRUFUVVJFX01PVU5UX05GUwoKLyoKICogTGludXggTkZTIG1vdW50CiAqIENvcHlyaWdodCAoQykgMTk5MyBSaWNrIFNsYWRrZXkgPGpyc0B3b3JsZC5zdGQuY29tPgogKgogKiBMaWNlbnNlZCB1bmRlciBHUEx2Miwgc2VlIGZpbGUgTElDRU5TRSBpbiB0aGlzIHRhcmJhbGwgZm9yIGRldGFpbHMuCiAqCiAqIFdlZCBGZWIgIDggMTI6NTE6NDggMTk5NSwgYmlyb0B5Z2dkcmFzaWwuY29tIChSb3NzIEJpcm8pOiBhbGxvdyBhbGwgcG9ydAogKiBudW1iZXJzIHRvIGJlIHNwZWNpZmllZCBvbiB0aGUgY29tbWFuZCBsaW5lLgogKgogKiBGcmksIDggTWFyIDE5OTYgMTg6MDE6MzksIFN3ZW4gVGh1ZW1tbGVyIDxzd2VuQHVuaS1wYWRlcmJvcm4uZGU+OgogKiBPbWl0IHRoZSBjYWxsIHRvIGNvbm5lY3QoKSBmb3IgTGludXggdmVyc2lvbiAxLjMuMTEgb3IgbGF0ZXIuCiAqCiAqIFdlZCBPY3QgIDEgMjM6NTU6MjggMTk5NzogRGljayBTdHJlZWZsYW5kIDxkaWNrX3N0cmVlZmxhbmRAdGFza2luZy5jb20+CiAqIEltcGxlbWVudGVkIHRoZSAiYmciLCAiZmciIGFuZCAicmV0cnkiIG1vdW50IG9wdGlvbnMgZm9yIE5GUy4KICoKICogMTk5OS0wMi0yMiBBcmthZGl1c3ogTWm2a2lld2ljeiA8bWlzaWVrQG1pc2llay5ldS5vcmc+CiAqIC0gYWRkZWQgTmF0aXZlIExhbmd1YWdlIFN1cHBvcnQKICoKICogTW9kaWZpZWQgYnkgT2xhZiBLaXJjaCBhbmQgVHJvbmQgTXlrbGVidXN0IGZvciBuZXcgTkZTIGNvZGUsCiAqIHBsdXMgTkZTdjMgc3R1ZmYuCiAqLwoKLyogVGhpcyBpcyBqdXN0IGEgd2FybmluZyBvZiBhIGNvbW1vbiBtaXN0YWtlLiAgUG9zc2libHkgdGhpcyBzaG91bGQgYmUgYQogKiB1Y2xpYmMgZmFxIGVudHJ5IHJhdGhlciB0aGFuIGluIGJ1c3lib3guLi4gKi8KI2lmIGRlZmluZWQoX19VQ0xJQkNfXykgJiYgISBkZWZpbmVkKF9fVUNMSUJDX0hBU19SUENfXykKI2Vycm9yICJZb3UgbmVlZCB0byBidWlsZCB1Q2xpYmMgd2l0aCBVQ0xJQkNfSEFTX1JQQyBmb3IgTkZTIHN1cHBvcnQuIgojZW5kaWYKCiNkZWZpbmUgTU9VTlRQT1JUIDYzNQojZGVmaW5lIE1OVFBBVEhMRU4gMTAyNAojZGVmaW5lIE1OVE5BTUxFTiAyNTUKI2RlZmluZSBGSFNJWkUgMzIKI2RlZmluZSBGSFNJWkUzIDY0Cgp0eXBlZGVmIGNoYXIgZmhhbmRsZVtGSFNJWkVdOwoKdHlwZWRlZiBzdHJ1Y3QgewoJdW5zaWduZWQgaW50IGZoYW5kbGUzX2xlbjsKCWNoYXIgKmZoYW5kbGUzX3ZhbDsKfSBmaGFuZGxlMzsKCmVudW0gbW91bnRzdGF0MyB7CglNTlRfT0sgPSAwLAoJTU5UM0VSUl9QRVJNID0gMSwKCU1OVDNFUlJfTk9FTlQgPSAyLAoJTU5UM0VSUl9JTyA9IDUsCglNTlQzRVJSX0FDQ0VTID0gMTMsCglNTlQzRVJSX05PVERJUiA9IDIwLAoJTU5UM0VSUl9JTlZBTCA9IDIyLAoJTU5UM0VSUl9OQU1FVE9PTE9ORyA9IDYzLAoJTU5UM0VSUl9OT1RTVVBQID0gMTAwMDQsCglNTlQzRVJSX1NFUlZFUkZBVUxUID0gMTAwMDYsCn07CnR5cGVkZWYgZW51bSBtb3VudHN0YXQzIG1vdW50c3RhdDM7CgpzdHJ1Y3QgZmhzdGF0dXMgewoJdW5zaWduZWQgaW50IGZoc19zdGF0dXM7Cgl1bmlvbiB7CgkJZmhhbmRsZSBmaHNfZmhhbmRsZTsKCX0gZmhzdGF0dXNfdTsKfTsKdHlwZWRlZiBzdHJ1Y3QgZmhzdGF0dXMgZmhzdGF0dXM7CgpzdHJ1Y3QgbW91bnRyZXMzX29rIHsKCWZoYW5kbGUzIGZoYW5kbGU7CglzdHJ1Y3QgewoJCXVuc2lnbmVkIGludCBhdXRoX2ZsYXZvdXJzX2xlbjsKCQljaGFyICphdXRoX2ZsYXZvdXJzX3ZhbDsKCX0gYXV0aF9mbGF2b3VyczsKfTsKdHlwZWRlZiBzdHJ1Y3QgbW91bnRyZXMzX29rIG1vdW50cmVzM19vazsKCnN0cnVjdCBtb3VudHJlczMgewoJbW91bnRzdGF0MyBmaHNfc3RhdHVzOwoJdW5pb24gewoJCW1vdW50cmVzM19vayBtb3VudGluZm87Cgl9IG1vdW50cmVzM191Owp9Owp0eXBlZGVmIHN0cnVjdCBtb3VudHJlczMgbW91bnRyZXMzOwoKdHlwZWRlZiBjaGFyICpkaXJwYXRoOwoKdHlwZWRlZiBjaGFyICpuYW1lOwoKdHlwZWRlZiBzdHJ1Y3QgbW91bnRib2R5ICptb3VudGxpc3Q7CgpzdHJ1Y3QgbW91bnRib2R5IHsKCW5hbWUgbWxfaG9zdG5hbWU7CglkaXJwYXRoIG1sX2RpcmVjdG9yeTsKCW1vdW50bGlzdCBtbF9uZXh0Owp9Owp0eXBlZGVmIHN0cnVjdCBtb3VudGJvZHkgbW91bnRib2R5OwoKdHlwZWRlZiBzdHJ1Y3QgZ3JvdXBub2RlICpncm91cHM7CgpzdHJ1Y3QgZ3JvdXBub2RlIHsKCW5hbWUgZ3JfbmFtZTsKCWdyb3VwcyBncl9uZXh0Owp9Owp0eXBlZGVmIHN0cnVjdCBncm91cG5vZGUgZ3JvdXBub2RlOwoKdHlwZWRlZiBzdHJ1Y3QgZXhwb3J0bm9kZSAqZXhwb3J0czsKCnN0cnVjdCBleHBvcnRub2RlIHsKCWRpcnBhdGggZXhfZGlyOwoJZ3JvdXBzIGV4X2dyb3VwczsKCWV4cG9ydHMgZXhfbmV4dDsKfTsKdHlwZWRlZiBzdHJ1Y3QgZXhwb3J0bm9kZSBleHBvcnRub2RlOwoKc3RydWN0IHBwYXRoY25mIHsKCWludCBwY19saW5rX21heDsKCXNob3J0IHBjX21heF9jYW5vbjsKCXNob3J0IHBjX21heF9pbnB1dDsKCXNob3J0IHBjX25hbWVfbWF4OwoJc2hvcnQgcGNfcGF0aF9tYXg7CglzaG9ydCBwY19waXBlX2J1ZjsKCXVpbnQ4X3QgcGNfdmRpc2FibGU7CgljaGFyIHBjX3h4eDsKCXNob3J0IHBjX21hc2tbMl07Cn07CnR5cGVkZWYgc3RydWN0IHBwYXRoY25mIHBwYXRoY25mOwoKI2RlZmluZSBNT1VOVFBST0cgMTAwMDA1CiNkZWZpbmUgTU9VTlRWRVJTIDEKCiNkZWZpbmUgTU9VTlRQUk9DX05VTEwgMAojZGVmaW5lIE1PVU5UUFJPQ19NTlQgMQojZGVmaW5lIE1PVU5UUFJPQ19EVU1QIDIKI2RlZmluZSBNT1VOVFBST0NfVU1OVCAzCiNkZWZpbmUgTU9VTlRQUk9DX1VNTlRBTEwgNAojZGVmaW5lIE1PVU5UUFJPQ19FWFBPUlQgNQojZGVmaW5lIE1PVU5UUFJPQ19FWFBPUlRBTEwgNgoKI2RlZmluZSBNT1VOVFZFUlNfUE9TSVggMgoKI2RlZmluZSBNT1VOVFBST0NfUEFUSENPTkYgNwoKI2RlZmluZSBNT1VOVF9WMyAzCgojZGVmaW5lIE1PVU5UUFJPQzNfTlVMTCAwCiNkZWZpbmUgTU9VTlRQUk9DM19NTlQgMQojZGVmaW5lIE1PVU5UUFJPQzNfRFVNUCAyCiNkZWZpbmUgTU9VTlRQUk9DM19VTU5UIDMKI2RlZmluZSBNT1VOVFBST0MzX1VNTlRBTEwgNAojZGVmaW5lIE1PVU5UUFJPQzNfRVhQT1JUIDUKCmVudW0gewojaWZuZGVmIE5GU19GSFNJWkUKCU5GU19GSFNJWkUgPSAzMiwKI2VuZGlmCiNpZm5kZWYgTkZTX1BPUlQKCU5GU19QT1JUID0gMjA0OQojZW5kaWYKfTsKCi8qCiAqIFdlIHdhbnQgdG8gYmUgYWJsZSB0byBjb21waWxlIG1vdW50IG9uIG9sZCBrZXJuZWxzIGluIHN1Y2ggYSB3YXkKICogdGhhdCB0aGUgYmluYXJ5IHdpbGwgd29yayB3ZWxsIG9uIG1vcmUgcmVjZW50IGtlcm5lbHMuCiAqIFRodXMsIGlmIG5lY2Vzc2FyeSB3ZSB0ZWFjaCBuZnNtb3VudC5jIHRoZSBzdHJ1Y3R1cmUgb2YgbmV3IGZpZWxkcwogKiB0aGF0IHdpbGwgY29tZSBsYXRlci4KICoKICogTW9yZW92ZXIsIHRoZSBuZXcga2VybmVsIGluY2x1ZGVzIGNvbmZsaWN0IHdpdGggZ2xpYmMgaW5jbHVkZXMKICogc28gaXQgaXMgZWFzaWVzdCB0byBpZ25vcmUgdGhlIGtlcm5lbCBhbHRvZ2V0aGVyIChhdCBjb21waWxlIHRpbWUpLgogKi8KCnN0cnVjdCBuZnMyX2ZoIHsKCWNoYXIgICAgICAgICAgICAgICAgICAgIGRhdGFbMzJdOwp9OwpzdHJ1Y3QgbmZzM19maCB7Cgl1bnNpZ25lZCBzaG9ydCAgICAgICAgICBzaXplOwoJdW5zaWduZWQgY2hhciAgICAgICAgICAgZGF0YVs2NF07Cn07CgpzdHJ1Y3QgbmZzX21vdW50X2RhdGEgewoJaW50CQl2ZXJzaW9uOwkJLyogMSAqLwoJaW50CQlmZDsJCQkvKiAxICovCglzdHJ1Y3QgbmZzMl9maAlvbGRfcm9vdDsJCS8qIDEgKi8KCWludAkJZmxhZ3M7CQkJLyogMSAqLwoJaW50CQlyc2l6ZTsJCQkvKiAxICovCglpbnQJCXdzaXplOwkJCS8qIDEgKi8KCWludAkJdGltZW87CQkJLyogMSAqLwoJaW50CQlyZXRyYW5zOwkJLyogMSAqLwoJaW50CQlhY3JlZ21pbjsJCS8qIDEgKi8KCWludAkJYWNyZWdtYXg7CQkvKiAxICovCglpbnQJCWFjZGlybWluOwkJLyogMSAqLwoJaW50CQlhY2Rpcm1heDsJCS8qIDEgKi8KCXN0cnVjdCBzb2NrYWRkcl9pbiBhZGRyOwkJLyogMSAqLwoJY2hhcgkJaG9zdG5hbWVbMjU2XTsJCS8qIDEgKi8KCWludAkJbmFtbGVuOwkJCS8qIDIgKi8KCXVuc2lnbmVkIGludAlic2l6ZTsJCQkvKiAzICovCglzdHJ1Y3QgbmZzM19maAlyb290OwkJCS8qIDQgKi8KfTsKCi8qIGJpdHMgaW4gdGhlIGZsYWdzIGZpZWxkICovCmVudW0gewoJTkZTX01PVU5UX1NPRlQgPSAweDAwMDEsCS8qIDEgKi8KCU5GU19NT1VOVF9JTlRSID0gMHgwMDAyLAkvKiAxICovCglORlNfTU9VTlRfU0VDVVJFID0gMHgwMDA0LAkvKiAxICovCglORlNfTU9VTlRfUE9TSVggPSAweDAwMDgsCS8qIDEgKi8KCU5GU19NT1VOVF9OT0NUTyA9IDB4MDAxMCwJLyogMSAqLwoJTkZTX01PVU5UX05PQUMgPSAweDAwMjAsCS8qIDEgKi8KCU5GU19NT1VOVF9UQ1AgPSAweDAwNDAsCQkvKiAyICovCglORlNfTU9VTlRfVkVSMyA9IDB4MDA4MCwJLyogMyAqLwoJTkZTX01PVU5UX0tFUkJFUk9TID0gMHgwMTAwLAkvKiAzICovCglORlNfTU9VTlRfTk9OTE0gPSAweDAyMDAJLyogMyAqLwp9OwoKCi8qCiAqIFdlIG5lZWQgdG8gdHJhbnNsYXRlIGJldHdlZW4gbmZzIHN0YXR1cyByZXR1cm4gdmFsdWVzIGFuZAogKiB0aGUgbG9jYWwgZXJybm8gdmFsdWVzIHdoaWNoIG1heSBub3QgYmUgdGhlIHNhbWUuCiAqCiAqIEFuZHJlYXMgU2Nod2FiIDxzY2h3YWJATFM1LmluZm9ybWF0aWsudW5pLWRvcnRtdW5kLmRlPjogY2hhbmdlIGVycm5vOgogKiAiYWZ0ZXIgI2luY2x1ZGUgPGVycm5vLmg+IHRoZSBzeW1ib2wgZXJybm8gaXMgcmVzZXJ2ZWQgZm9yIGFueSB1c2UsCiAqICBpdCBjYW5ub3QgZXZlbiBiZSB1c2VkIGFzIGEgc3RydWN0IHRhZyBvciBmaWVsZCBuYW1lIi4KICovCgojaWZuZGVmIEVEUVVPVAojZGVmaW5lIEVEUVVPVAlFTk9TUEMKI2VuZGlmCgovLyBDb252ZXJ0IGVhY2ggTkZTRVJSX0JMQUggaW50byBFQkxBSAoKc3RhdGljIGNvbnN0IHN0cnVjdCB7CglzaG9ydCBzdGF0OwoJc2hvcnQgZXJybnVtOwp9IG5mc19lcnJ0YmxbXSA9IHsKCXswLDB9LCB7MSxFUEVSTX0sIHsyLEVOT0VOVH0sIHs1LEVJT30sIHs2LEVOWElPfSwgezEzLEVBQ0NFU30sIHsxNyxFRVhJU1R9LAoJezE5LEVOT0RFVn0sIHsyMCxFTk9URElSfSwgezIxLEVJU0RJUn0sIHsyMixFSU5WQUx9LCB7MjcsRUZCSUd9LAoJezI4LEVOT1NQQ30sIHszMCxFUk9GU30sIHs2MyxFTkFNRVRPT0xPTkd9LCB7NjYsRU5PVEVNUFRZfSwgezY5LEVEUVVPVH0sCgl7NzAsRVNUQUxFfSwgezcxLEVSRU1PVEV9LCB7LTEsRUlPfQp9OwoKc3RhdGljIGNoYXIgKm5mc19zdHJlcnJvcihpbnQgc3RhdHVzKQp7CglpbnQgaTsKCglmb3IgKGkgPSAwOyBuZnNfZXJydGJsW2ldLnN0YXQgIT0gLTE7IGkrKykgewoJCWlmIChuZnNfZXJydGJsW2ldLnN0YXQgPT0gc3RhdHVzKQoJCQlyZXR1cm4gc3RyZXJyb3IobmZzX2VycnRibFtpXS5lcnJudW0pOwoJfQoJcmV0dXJuIHhhc3ByaW50ZigidW5rbm93biBuZnMgc3RhdHVzIHJldHVybiB2YWx1ZTogJWQiLCBzdGF0dXMpOwp9CgpzdGF0aWMgYm9vbF90IHhkcl9maGFuZGxlKFhEUiAqeGRycywgZmhhbmRsZSBvYmpwKQp7CglpZiAoIXhkcl9vcGFxdWUoeGRycywgb2JqcCwgRkhTSVpFKSkKCQkgcmV0dXJuIEZBTFNFOwoJcmV0dXJuIFRSVUU7Cn0KCnN0YXRpYyBib29sX3QgeGRyX2Zoc3RhdHVzKFhEUiAqeGRycywgZmhzdGF0dXMgKm9ianApCnsKCWlmICgheGRyX3VfaW50KHhkcnMsICZvYmpwLT5maHNfc3RhdHVzKSkKCQkgcmV0dXJuIEZBTFNFOwoJc3dpdGNoIChvYmpwLT5maHNfc3RhdHVzKSB7CgljYXNlIDA6CgkJaWYgKCF4ZHJfZmhhbmRsZSh4ZHJzLCBvYmpwLT5maHN0YXR1c191LmZoc19maGFuZGxlKSkKCQkJIHJldHVybiBGQUxTRTsKCQlicmVhazsKCWRlZmF1bHQ6CgkJYnJlYWs7Cgl9CglyZXR1cm4gVFJVRTsKfQoKc3RhdGljIGJvb2xfdCB4ZHJfZGlycGF0aChYRFIgKnhkcnMsIGRpcnBhdGggKm9ianApCnsKCWlmICgheGRyX3N0cmluZyh4ZHJzLCBvYmpwLCBNTlRQQVRITEVOKSkKCQkgcmV0dXJuIEZBTFNFOwoJcmV0dXJuIFRSVUU7Cn0KCnN0YXRpYyBib29sX3QgeGRyX2ZoYW5kbGUzKFhEUiAqeGRycywgZmhhbmRsZTMgKm9ianApCnsKCWlmICgheGRyX2J5dGVzKHhkcnMsIChjaGFyICoqKSZvYmpwLT5maGFuZGxlM192YWwsICh1bnNpZ25lZCBpbnQgKikgJm9ianAtPmZoYW5kbGUzX2xlbiwgRkhTSVpFMykpCgkJIHJldHVybiBGQUxTRTsKCXJldHVybiBUUlVFOwp9CgpzdGF0aWMgYm9vbF90IHhkcl9tb3VudHJlczNfb2soWERSICp4ZHJzLCBtb3VudHJlczNfb2sgKm9ianApCnsKCWlmICgheGRyX2ZoYW5kbGUzKHhkcnMsICZvYmpwLT5maGFuZGxlKSkKCQlyZXR1cm4gRkFMU0U7CglpZiAoIXhkcl9hcnJheSh4ZHJzLCAmKG9ianAtPmF1dGhfZmxhdm91cnMuYXV0aF9mbGF2b3Vyc192YWwpLCAmKG9ianAtPmF1dGhfZmxhdm91cnMuYXV0aF9mbGF2b3Vyc19sZW4pLCB+MCwKCQkJCXNpemVvZiAoaW50KSwgKHhkcnByb2NfdCkgeGRyX2ludCkpCgkJcmV0dXJuIEZBTFNFOwoJcmV0dXJuIFRSVUU7Cn0KCnN0YXRpYyBib29sX3QgeGRyX21vdW50c3RhdDMoWERSICp4ZHJzLCBtb3VudHN0YXQzICpvYmpwKQp7CglpZiAoIXhkcl9lbnVtKHhkcnMsIChlbnVtX3QgKikgb2JqcCkpCgkJIHJldHVybiBGQUxTRTsKCXJldHVybiBUUlVFOwp9CgpzdGF0aWMgYm9vbF90IHhkcl9tb3VudHJlczMoWERSICp4ZHJzLCBtb3VudHJlczMgKm9ianApCnsKCWlmICgheGRyX21vdW50c3RhdDMoeGRycywgJm9ianAtPmZoc19zdGF0dXMpKQoJCXJldHVybiBGQUxTRTsKCXN3aXRjaCAob2JqcC0+ZmhzX3N0YXR1cykgewoJY2FzZSBNTlRfT0s6CgkJaWYgKCF4ZHJfbW91bnRyZXMzX29rKHhkcnMsICZvYmpwLT5tb3VudHJlczNfdS5tb3VudGluZm8pKQoJCQkgcmV0dXJuIEZBTFNFOwoJCWJyZWFrOwoJZGVmYXVsdDoKCQlicmVhazsKCX0KCXJldHVybiBUUlVFOwp9CgojZGVmaW5lIE1BWF9ORlNQUk9UICgobmZzX21vdW50X3ZlcnNpb24gPj0gNCkgPyAzIDogMikKCnN0YXRpYyBzbWFsbHVpbnQgbmZzX21vdW50X3ZlcnNpb247CgovKgogKiBVbmZvcnR1bmF0ZWx5LCB0aGUga2VybmVsIHByaW50cyBhbm5veWluZyBjb25zb2xlIG1lc3NhZ2VzCiAqIGluIGNhc2Ugb2YgYW4gdW5leHBlY3RlZCBuZnMgbW91bnQgdmVyc2lvbiAoaW5zdGVhZCBvZgogKiBqdXN0IHJldHVybmluZyBzb21lIGVycm9yKS4gIFRoZXJlZm9yZSB3ZSdsbCBoYXZlIHRvIHRyeQogKiBhbmQgZmlndXJlIG91dCB3aGF0IHZlcnNpb24gdGhlIGtlcm5lbCBleHBlY3RzLgogKgogKiBWYXJpYWJsZXM6CiAqCUtFUk5FTF9ORlNfTU9VTlRfVkVSU0lPTjoga2VybmVsIHNvdXJjZXMgYXQgY29tcGlsZSB0aW1lCiAqCU5GU19NT1VOVF9WRVJTSU9OOiB0aGVzZSBuZnNtb3VudCBzb3VyY2VzIGF0IGNvbXBpbGUgdGltZQogKgluZnNfbW91bnRfdmVyc2lvbjogdmVyc2lvbiB0aGlzIHNvdXJjZSBhbmQgcnVubmluZyBrZXJuZWwgY2FuIGhhbmRsZQogKi8Kc3RhdGljIHZvaWQKZmluZF9rZXJuZWxfbmZzX21vdW50X3ZlcnNpb24odm9pZCkKewoJaW50IGtlcm5lbF92ZXJzaW9uOwoKCWlmIChuZnNfbW91bnRfdmVyc2lvbikKCQlyZXR1cm47CgoJbmZzX21vdW50X3ZlcnNpb24gPSA0OyAvKiBkZWZhdWx0ICovCgoJa2VybmVsX3ZlcnNpb24gPSBnZXRfbGludXhfdmVyc2lvbl9jb2RlKCk7CglpZiAoa2VybmVsX3ZlcnNpb24pIHsKCQlpZiAoa2VybmVsX3ZlcnNpb24gPCBLRVJORUxfVkVSU0lPTigyLDEsMzIpKQoJCQluZnNfbW91bnRfdmVyc2lvbiA9IDE7CgkJZWxzZSBpZiAoa2VybmVsX3ZlcnNpb24gPCBLRVJORUxfVkVSU0lPTigyLDIsMTgpIHx8CgkJCQkoa2VybmVsX3ZlcnNpb24gPj0gS0VSTkVMX1ZFUlNJT04oMiwzLDApICYmCgkJCQkga2VybmVsX3ZlcnNpb24gPCBLRVJORUxfVkVSU0lPTigyLDMsOTkpKSkKCQkJbmZzX21vdW50X3ZlcnNpb24gPSAzOwoJCS8qIGVsc2UgdjQgc2luY2UgMi4zLjk5cHJlNCAqLwoJfQp9CgpzdGF0aWMgdm9pZApnZXRfbW91bnRwb3J0KHN0cnVjdCBwbWFwICpwbV9tbnQsCglzdHJ1Y3Qgc29ja2FkZHJfaW4gKnNlcnZlcl9hZGRyLAoJbG9uZyB1bnNpZ25lZCBwcm9nLAoJbG9uZyB1bnNpZ25lZCB2ZXJzaW9uLAoJbG9uZyB1bnNpZ25lZCBwcm90bywKCWxvbmcgdW5zaWduZWQgcG9ydCkKewoJc3RydWN0IHBtYXBsaXN0ICpwbWFwOwoKCXNlcnZlcl9hZGRyLT5zaW5fcG9ydCA9IFBNQVBQT1JUOwovKiBnbGliYyAyLjQgKHN0aWxsKSBoYXMgcG1hcF9nZXRtYXBzKHN0cnVjdCBzb2NrYWRkcl9pbiAqKS4KICogSSB1bmRlcnN0YW5kIGl0IGxpa2UgIklQdjYgZm9yIHRoaXMgaXMgbm90IDEwMCUgcmVhZHkiICovCglwbWFwID0gcG1hcF9nZXRtYXBzKHNlcnZlcl9hZGRyKTsKCglpZiAodmVyc2lvbiA+IE1BWF9ORlNQUk9UKQoJCXZlcnNpb24gPSBNQVhfTkZTUFJPVDsKCWlmICghcHJvZykKCQlwcm9nID0gTU9VTlRQUk9HOwoJcG1fbW50LT5wbV9wcm9nID0gcHJvZzsKCXBtX21udC0+cG1fdmVycyA9IHZlcnNpb247CglwbV9tbnQtPnBtX3Byb3QgPSBwcm90bzsKCXBtX21udC0+cG1fcG9ydCA9IHBvcnQ7CgoJd2hpbGUgKHBtYXApIHsKCQlpZiAocG1hcC0+cG1sX21hcC5wbV9wcm9nICE9IHByb2cpCgkJCWdvdG8gbmV4dDsKCQlpZiAoIXZlcnNpb24gJiYgcG1fbW50LT5wbV92ZXJzID4gcG1hcC0+cG1sX21hcC5wbV92ZXJzKQoJCQlnb3RvIG5leHQ7CgkJaWYgKHZlcnNpb24gPiAyICYmIHBtYXAtPnBtbF9tYXAucG1fdmVycyAhPSB2ZXJzaW9uKQoJCQlnb3RvIG5leHQ7CgkJaWYgKHZlcnNpb24gJiYgdmVyc2lvbiA8PSAyICYmIHBtYXAtPnBtbF9tYXAucG1fdmVycyA+IDIpCgkJCWdvdG8gbmV4dDsKCQlpZiAocG1hcC0+cG1sX21hcC5wbV92ZXJzID4gTUFYX05GU1BST1QgfHwKCQkgICAgKHByb3RvICYmIHBtX21udC0+cG1fcHJvdCAmJiBwbWFwLT5wbWxfbWFwLnBtX3Byb3QgIT0gcHJvdG8pIHx8CgkJICAgIChwb3J0ICYmIHBtYXAtPnBtbF9tYXAucG1fcG9ydCAhPSBwb3J0KSkKCQkJZ290byBuZXh0OwoJCW1lbWNweShwbV9tbnQsICZwbWFwLT5wbWxfbWFwLCBzaXplb2YoKnBtX21udCkpOwogbmV4dDoKCQlwbWFwID0gcG1hcC0+cG1sX25leHQ7Cgl9CglpZiAoIXBtX21udC0+cG1fdmVycykKCQlwbV9tbnQtPnBtX3ZlcnMgPSBNT1VOVFZFUlM7CglpZiAoIXBtX21udC0+cG1fcG9ydCkKCQlwbV9tbnQtPnBtX3BvcnQgPSBNT1VOVFBPUlQ7CglpZiAoIXBtX21udC0+cG1fcHJvdCkKCQlwbV9tbnQtPnBtX3Byb3QgPSBJUFBST1RPX1RDUDsKfQoKI2lmIEJCX01NVQpzdGF0aWMgaW50IGRhZW1vbml6ZSh2b2lkKQp7CglpbnQgZmQ7CglpbnQgcGlkID0gZm9yaygpOwoJaWYgKHBpZCA8IDApIC8qIGVycm9yICovCgkJcmV0dXJuIC1lcnJubzsKCWlmIChwaWQgPiAwKSAvKiBwYXJlbnQgKi8KCQlyZXR1cm4gMDsKCS8qIGNoaWxkICovCglmZCA9IHhvcGVuKGJiX2Rldl9udWxsLCBPX1JEV1IpOwoJZHVwMihmZCwgMCk7CglkdXAyKGZkLCAxKTsKCWR1cDIoZmQsIDIpOwoJd2hpbGUgKGZkID4gMikgY2xvc2UoZmQtLSk7CglzZXRzaWQoKTsKCW9wZW5sb2coYXBwbGV0X25hbWUsIExPR19QSUQsIExPR19EQUVNT04pOwoJbG9nbW9kZSA9IExPR01PREVfU1lTTE9HOwoJcmV0dXJuIDE7Cn0KI2Vsc2UKc3RhdGljIGlubGluZSBpbnQgZGFlbW9uaXplKHZvaWQpIHsgcmV0dXJuIC1FTk9TWVM7IH0KI2VuZGlmCgovLyBUT0RPCnN0YXRpYyBpbmxpbmUgaW50IHdlX3Nhd190aGlzX2hvc3RfYmVmb3JlKGNvbnN0IGNoYXIgKmhvc3RuYW1lKQp7CglyZXR1cm4gMDsKfQoKLyogUlBDIHN0cmVycm9yIGFuYWxvZ3MgYXJlIHRlcm1pbmFsbHkgaWRpb3RpYzoKICogKm1hbmRhdG9yeSogcHJlZml4IGFuZCBcbiBhdCBlbmQuCiAqIFRoaXMgaG9wZWZ1bGx5IGhlbHBzLiBVc2FnZToKICogZXJyb3JfbXNnX3JwYyhjbG50XyplcnJvciooIiAiKSkgKi8Kc3RhdGljIHZvaWQgZXJyb3JfbXNnX3JwYyhjb25zdCBjaGFyICptc2cpCnsKCWludCBsZW47Cgl3aGlsZSAobXNnWzBdID09ICcgJyB8fCBtc2dbMF0gPT0gJzonKSBtc2crKzsKCWxlbiA9IHN0cmxlbihtc2cpOwoJd2hpbGUgKGxlbiAmJiBtc2dbbGVuLTFdID09ICdcbicpIGxlbi0tOwoJYmJfZXJyb3JfbXNnKCIlLipzIiwgbGVuLCBtc2cpOwp9CgovLyBOQjogbXAtPnh4eCBmaWVsZHMgbWF5IGJlIHRyYXNoZWQgb24gZXhpdApzdGF0aWMgaW50IG5mc21vdW50KHN0cnVjdCBtbnRlbnQgKm1wLCBpbnQgdmZzZmxhZ3MsIGNoYXIgKmZpbHRlcm9wdHMpCnsKCUNMSUVOVCAqbWNsaWVudDsKCWNoYXIgKmhvc3RuYW1lOwoJY2hhciAqcGF0aG5hbWU7CgljaGFyICptb3VudGhvc3Q7CglzdHJ1Y3QgbmZzX21vdW50X2RhdGEgZGF0YTsKCWNoYXIgKm9wdDsKCXN0cnVjdCBob3N0ZW50ICpocDsKCXN0cnVjdCBzb2NrYWRkcl9pbiBzZXJ2ZXJfYWRkcjsKCXN0cnVjdCBzb2NrYWRkcl9pbiBtb3VudF9zZXJ2ZXJfYWRkcjsKCWludCBtc29jaywgZnNvY2s7Cgl1bmlvbiB7CgkJc3RydWN0IGZoc3RhdHVzIG5mc3YyOwoJCXN0cnVjdCBtb3VudHJlczMgbmZzdjM7Cgl9IHN0YXR1czsKCWludCBkYWVtb25pemVkOwoJY2hhciAqczsKCWludCBwb3J0OwoJaW50IG1vdW50cG9ydDsKCWludCBwcm90bzsKI2lmIEJCX01NVQoJaW50IGJnID0gMDsKI2Vsc2UKCWVudW0geyBiZyA9IDAgfTsKI2VuZGlmCglpbnQgc29mdDsKCWludCBpbnRyOwoJaW50IHBvc2l4OwoJaW50IG5vY3RvOwoJaW50IG5vYWM7CglpbnQgbm9sb2NrOwoJaW50IHJldHJ5OwoJaW50IHRjcDsKCWludCBtb3VudHByb2c7CglpbnQgbW91bnR2ZXJzOwoJaW50IG5mc3Byb2c7CglpbnQgbmZzdmVyczsKCWludCByZXR2YWw7CgoJZmluZF9rZXJuZWxfbmZzX21vdW50X3ZlcnNpb24oKTsKCglkYWVtb25pemVkID0gMDsKCW1vdW50aG9zdCA9IE5VTEw7CglyZXR2YWwgPSBFVElNRURPVVQ7Cgltc29jayA9IGZzb2NrID0gLTE7CgltY2xpZW50ID0gTlVMTDsKCgkvKiBOQjogaG9zdG5hbWUsIG1vdW50aG9zdCwgZmlsdGVyb3B0cyBtdXN0IGJlIGZyZWUoKWQgcHJpb3IgdG8gcmV0dXJuICovCgoJZmlsdGVyb3B0cyA9IHhzdHJkdXAoZmlsdGVyb3B0cyk7IC8qIGdvaW5nIHRvIHRyYXNoIGl0IGxhdGVyLi4uICovCgoJaG9zdG5hbWUgPSB4c3RyZHVwKG1wLT5tbnRfZnNuYW1lKTsKCS8qIG1vdW50X21haW4oKSBndWFyYW50ZWVzIHRoYXQgJzonIGlzIHRoZXJlICovCglzID0gc3RyY2hyKGhvc3RuYW1lLCAnOicpOwoJcGF0aG5hbWUgPSBzICsgMTsKCSpzID0gJ1wwJzsKCS8qIElnbm9yZSBhbGwgYnV0IGZpcnN0IGhvc3RuYW1lIGluIHJlcGxpY2F0ZWQgbW91bnRzCgkgICB1bnRpbCB0aGV5IGNhbiBiZSBmdWxseSBzdXBwb3J0ZWQuIChtYWNrQHNnaS5jb20pICovCglzID0gc3RyY2hyKGhvc3RuYW1lLCAnLCcpOwoJaWYgKHMpIHsKCQkqcyA9ICdcMCc7CgkJYmJfZXJyb3JfbXNnKCJ3YXJuaW5nOiBtdWx0aXBsZSBob3N0bmFtZXMgbm90IHN1cHBvcnRlZCIpOwoJfQoKCXNlcnZlcl9hZGRyLnNpbl9mYW1pbHkgPSBBRl9JTkVUOwoJaWYgKCFpbmV0X2F0b24oaG9zdG5hbWUsICZzZXJ2ZXJfYWRkci5zaW5fYWRkcikpIHsKCQlocCA9IGdldGhvc3RieW5hbWUoaG9zdG5hbWUpOwoJCWlmIChocCA9PSBOVUxMKSB7CgkJCWJiX2hlcnJvcl9tc2coIiVzIiwgaG9zdG5hbWUpOwoJCQlnb3RvIGZhaWw7CgkJfQoJCWlmIChocC0+aF9sZW5ndGggPiBzaXplb2Yoc3RydWN0IGluX2FkZHIpKSB7CgkJCWJiX2Vycm9yX21zZygiZ290IGJhZCBocC0+aF9sZW5ndGgiKTsKCQkJaHAtPmhfbGVuZ3RoID0gc2l6ZW9mKHN0cnVjdCBpbl9hZGRyKTsKCQl9CgkJbWVtY3B5KCZzZXJ2ZXJfYWRkci5zaW5fYWRkciwKCQkJCWhwLT5oX2FkZHIsIGhwLT5oX2xlbmd0aCk7Cgl9CgoJbWVtY3B5KCZtb3VudF9zZXJ2ZXJfYWRkciwgJnNlcnZlcl9hZGRyLCBzaXplb2YobW91bnRfc2VydmVyX2FkZHIpKTsKCgkvKiBhZGQgSVAgYWRkcmVzcyB0byBtdGFiIG9wdGlvbnMgZm9yIHVzZSB3aGVuIHVubW91bnRpbmcgKi8KCglpZiAoIW1wLT5tbnRfb3B0cykgeyAvKiBUT0RPOiBhY3R1YWxseSBtcC0+bW50X29wdHMgaXMgbmV2ZXIgTlVMTCAqLwoJCW1wLT5tbnRfb3B0cyA9IHhhc3ByaW50ZigiYWRkcj0lcyIsIGluZXRfbnRvYShzZXJ2ZXJfYWRkci5zaW5fYWRkcikpOwoJfSBlbHNlIHsKCQljaGFyICp0bXAgPSB4YXNwcmludGYoIiVzJXNhZGRyPSVzIiwgbXAtPm1udF9vcHRzLAoJCQkJCW1wLT5tbnRfb3B0c1swXSA/ICIsIiA6ICIiLAoJCQkJCWluZXRfbnRvYShzZXJ2ZXJfYWRkci5zaW5fYWRkcikpOwoJCWZyZWUobXAtPm1udF9vcHRzKTsKCQltcC0+bW50X29wdHMgPSB0bXA7Cgl9CgoJLyogU2V0IGRlZmF1bHQgb3B0aW9ucy4KCSAqIHJzaXplL3dzaXplIChhbmQgYnNpemUsIGZvciB2ZXIgPj0gMykgYXJlIGxlZnQgMCBpbiBvcmRlciB0bwoJICogbGV0IHRoZSBrZXJuZWwgZGVjaWRlLgoJICogdGltZW8gaXMgZmlsbGVkIGluIGFmdGVyIHdlIGtub3cgd2hldGhlciBpdCdsbCBiZSBUQ1Agb3IgVURQLiAqLwoJbWVtc2V0KCZkYXRhLCAwLCBzaXplb2YoZGF0YSkpOwoJZGF0YS5yZXRyYW5zCT0gMzsKCWRhdGEuYWNyZWdtaW4JPSAzOwoJZGF0YS5hY3JlZ21heAk9IDYwOwoJZGF0YS5hY2Rpcm1pbgk9IDMwOwoJZGF0YS5hY2Rpcm1heAk9IDYwOwoJZGF0YS5uYW1sZW4JPSBOQU1FX01BWDsKCglzb2Z0ID0gMDsKCWludHIgPSAwOwoJcG9zaXggPSAwOwoJbm9jdG8gPSAwOwoJbm9sb2NrID0gMDsKCW5vYWMgPSAwOwoJcmV0cnkgPSAxMDAwMDsJCS8qIDEwMDAwIG1pbnV0ZXMgfiAxIHdlZWsgKi8KCXRjcCA9IDA7CgoJbW91bnRwcm9nID0gTU9VTlRQUk9HOwoJbW91bnR2ZXJzID0gMDsKCXBvcnQgPSAwOwoJbW91bnRwb3J0ID0gMDsKCW5mc3Byb2cgPSAxMDAwMDM7CgluZnN2ZXJzID0gMDsKCgkvKiBwYXJzZSBvcHRpb25zICovCglpZiAoZmlsdGVyb3B0cykJZm9yIChvcHQgPSBzdHJ0b2soZmlsdGVyb3B0cywgIiwiKTsgb3B0OyBvcHQgPSBzdHJ0b2soTlVMTCwgIiwiKSkgewoJCWNoYXIgKm9wdGVxID0gc3RyY2hyKG9wdCwgJz0nKTsKCQlpZiAob3B0ZXEpIHsKCQkJc3RhdGljIGNvbnN0IGNoYXIgb3B0aW9uc1tdIEFMSUdOMSA9CgkJCQkvKiAwICovICJyc2l6ZVwwIgoJCQkJLyogMSAqLyAid3NpemVcMCIKCQkJCS8qIDIgKi8gInRpbWVvXDAiCgkJCQkvKiAzICovICJyZXRyYW5zXDAiCgkJCQkvKiA0ICovICJhY3JlZ21pblwwIgoJCQkJLyogNSAqLyAiYWNyZWdtYXhcMCIKCQkJCS8qIDYgKi8gImFjZGlybWluXDAiCgkJCQkvKiA3ICovICJhY2Rpcm1heFwwIgoJCQkJLyogOCAqLyAiYWN0aW1lb1wwIgoJCQkJLyogOSAqLyAicmV0cnlcMCIKCQkJCS8qIDEwICovICJwb3J0XDAiCgkJCQkvKiAxMSAqLyAibW91bnRwb3J0XDAiCgkJCQkvKiAxMiAqLyAibW91bnRob3N0XDAiCgkJCQkvKiAxMyAqLyAibW91bnRwcm9nXDAiCgkJCQkvKiAxNCAqLyAibW91bnR2ZXJzXDAiCgkJCQkvKiAxNSAqLyAibmZzcHJvZ1wwIgoJCQkJLyogMTYgKi8gIm5mc3ZlcnNcMCIKCQkJCS8qIDE3ICovICJ2ZXJzXDAiCgkJCQkvKiAxOCAqLyAicHJvdG9cMCIKCQkJCS8qIDE5ICovICJuYW1sZW5cMCIKCQkJCS8qIDIwICovICJhZGRyXDAiOwoJCQlpbnQgdmFsID0geGF0b2lfdShvcHRlcSArIDEpOwoJCQkqb3B0ZXEgPSAnXDAnOwoJCQlzd2l0Y2ggKGluZGV4X2luX3N0cmluZ3Mob3B0aW9ucywgb3B0KSkgewoJCQljYXNlIDA6IC8vICJyc2l6ZSIKCQkJCWRhdGEucnNpemUgPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSAxOiAvLyAid3NpemUiCgkJCQlkYXRhLndzaXplID0gdmFsOwoJCQkJYnJlYWs7CgkJCWNhc2UgMjogLy8gInRpbWVvIgoJCQkJZGF0YS50aW1lbyA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDM6IC8vICJyZXRyYW5zIgoJCQkJZGF0YS5yZXRyYW5zID0gdmFsOwoJCQkJYnJlYWs7CgkJCWNhc2UgNDogLy8gImFjcmVnbWluIgoJCQkJZGF0YS5hY3JlZ21pbiA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDU6IC8vICJhY3JlZ21heCIKCQkJCWRhdGEuYWNyZWdtYXggPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSA2OiAvLyAiYWNkaXJtaW4iCgkJCQlkYXRhLmFjZGlybWluID0gdmFsOwoJCQkJYnJlYWs7CgkJCWNhc2UgNzogLy8gImFjZGlybWF4IgoJCQkJZGF0YS5hY2Rpcm1heCA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDg6IC8vICJhY3RpbWVvIgoJCQkJZGF0YS5hY3JlZ21pbiA9IHZhbDsKCQkJCWRhdGEuYWNyZWdtYXggPSB2YWw7CgkJCQlkYXRhLmFjZGlybWluID0gdmFsOwoJCQkJZGF0YS5hY2Rpcm1heCA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDk6IC8vICJyZXRyeSIKCQkJCXJldHJ5ID0gdmFsOwoJCQkJYnJlYWs7CgkJCWNhc2UgMTA6IC8vICJwb3J0IgoJCQkJcG9ydCA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDExOiAvLyAibW91bnRwb3J0IgoJCQkJbW91bnRwb3J0ID0gdmFsOwoJCQkJYnJlYWs7CgkJCWNhc2UgMTI6IC8vICJtb3VudGhvc3QiCgkJCQltb3VudGhvc3QgPSB4c3RybmR1cChvcHRlcSsxLAoJCQkJCQlzdHJjc3BuKG9wdGVxKzEsIiBcdFxuXHIsIikpOwoJCQkJYnJlYWs7CgkJCWNhc2UgMTM6IC8vICJtb3VudHByb2ciCgkJCQltb3VudHByb2cgPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSAxNDogLy8gIm1vdW50dmVycyIKCQkJCW1vdW50dmVycyA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDE1OiAvLyAibmZzcHJvZyIKCQkJCW5mc3Byb2cgPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSAxNjogLy8gIm5mc3ZlcnMiCgkJCWNhc2UgMTc6IC8vICJ2ZXJzIgoJCQkJbmZzdmVycyA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDE4OiAvLyAicHJvdG8iCgkJCQlpZiAoIXN0cm5jbXAob3B0ZXErMSwgInRjcCIsIDMpKQoJCQkJCXRjcCA9IDE7CgkJCQllbHNlIGlmICghc3RybmNtcChvcHRlcSsxLCAidWRwIiwgMykpCgkJCQkJdGNwID0gMDsKCQkJCWVsc2UKCQkJCQliYl9lcnJvcl9tc2coIndhcm5pbmc6IHVucmVjb2duaXplZCBwcm90bz0gb3B0aW9uIik7CgkJCQlicmVhazsKCQkJY2FzZSAxOTogLy8gIm5hbWxlbiIKCQkJCWlmIChuZnNfbW91bnRfdmVyc2lvbiA+PSAyKQoJCQkJCWRhdGEubmFtbGVuID0gdmFsOwoJCQkJZWxzZQoJCQkJCWJiX2Vycm9yX21zZygid2FybmluZzogb3B0aW9uIG5hbWxlbiBpcyBub3Qgc3VwcG9ydGVkXG4iKTsKCQkJCWJyZWFrOwoJCQljYXNlIDIwOiAvLyAiYWRkciIgLSBpZ25vcmUKCQkJCWJyZWFrOwoJCQlkZWZhdWx0OgoJCQkJYmJfZXJyb3JfbXNnKCJ1bmtub3duIG5mcyBtb3VudCBwYXJhbWV0ZXI6ICVzPSVkIiwgb3B0LCB2YWwpOwoJCQkJZ290byBmYWlsOwoJCQl9CgkJfQoJCWVsc2UgewoJCQlzdGF0aWMgY29uc3QgY2hhciBvcHRpb25zW10gQUxJR04xID0KCQkJCSJiZ1wwIgoJCQkJImZnXDAiCgkJCQkic29mdFwwIgoJCQkJImhhcmRcMCIKCQkJCSJpbnRyXDAiCgkJCQkicG9zaXhcMCIKCQkJCSJjdG9cMCIKCQkJCSJhY1wwIgoJCQkJInRjcFwwIgoJCQkJInVkcFwwIgoJCQkJImxvY2tcMCI7CgkJCWludCB2YWwgPSAxOwoJCQlpZiAoIXN0cm5jbXAob3B0LCAibm8iLCAyKSkgewoJCQkJdmFsID0gMDsKCQkJCW9wdCArPSAyOwoJCQl9CgkJCXN3aXRjaCAoaW5kZXhfaW5fc3RyaW5ncyhvcHRpb25zLCBvcHQpKSB7CgkJCWNhc2UgMDogLy8gImJnIgojaWYgQkJfTU1VCgkJCQliZyA9IHZhbDsKI2VuZGlmCgkJCQlicmVhazsKCQkJY2FzZSAxOiAvLyAiZmciCiNpZiBCQl9NTVUKCQkJCWJnID0gIXZhbDsKI2VuZGlmCgkJCQlicmVhazsKCQkJY2FzZSAyOiAvLyAic29mdCIKCQkJCXNvZnQgPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSAzOiAvLyAiaGFyZCIKCQkJCXNvZnQgPSAhdmFsOwoJCQkJYnJlYWs7CgkJCWNhc2UgNDogLy8gImludHIiCgkJCQlpbnRyID0gdmFsOwoJCQkJYnJlYWs7CgkJCWNhc2UgNTogLy8gInBvc2l4IgoJCQkJcG9zaXggPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSA2OiAvLyAiY3RvIgoJCQkJbm9jdG8gPSAhdmFsOwoJCQkJYnJlYWs7CgkJCWNhc2UgNzogLy8gImFjIgoJCQkJbm9hYyA9ICF2YWw7CgkJCQlicmVhazsKCQkJY2FzZSA4OiAvLyAidGNwIgoJCQkJdGNwID0gdmFsOwoJCQkJYnJlYWs7CgkJCWNhc2UgOTogLy8gInVkcCIKCQkJCXRjcCA9ICF2YWw7CgkJCQlicmVhazsKCQkJY2FzZSAxMDogLy8gImxvY2siCgkJCQlpZiAobmZzX21vdW50X3ZlcnNpb24gPj0gMykKCQkJCQlub2xvY2sgPSAhdmFsOwoJCQkJZWxzZQoJCQkJCWJiX2Vycm9yX21zZygid2FybmluZzogb3B0aW9uIG5vbG9jayBpcyBub3Qgc3VwcG9ydGVkIik7CgkJCQlicmVhazsKCQkJZGVmYXVsdDoKCQkJCWJiX2Vycm9yX21zZygidW5rbm93biBuZnMgbW91bnQgb3B0aW9uOiAlcyVzIiwgdmFsID8gIiIgOiAibm8iLCBvcHQpOwoJCQkJZ290byBmYWlsOwoJCQl9CgkJfQoJfQoJcHJvdG8gPSAodGNwKSA/IElQUFJPVE9fVENQIDogSVBQUk9UT19VRFA7CgoJZGF0YS5mbGFncyA9IChzb2Z0ID8gTkZTX01PVU5UX1NPRlQgOiAwKQoJCXwgKGludHIgPyBORlNfTU9VTlRfSU5UUiA6IDApCgkJfCAocG9zaXggPyBORlNfTU9VTlRfUE9TSVggOiAwKQoJCXwgKG5vY3RvID8gTkZTX01PVU5UX05PQ1RPIDogMCkKCQl8IChub2FjID8gTkZTX01PVU5UX05PQUMgOiAwKTsKCWlmIChuZnNfbW91bnRfdmVyc2lvbiA+PSAyKQoJCWRhdGEuZmxhZ3MgfD0gKHRjcCA/IE5GU19NT1VOVF9UQ1AgOiAwKTsKCWlmIChuZnNfbW91bnRfdmVyc2lvbiA+PSAzKQoJCWRhdGEuZmxhZ3MgfD0gKG5vbG9jayA/IE5GU19NT1VOVF9OT05MTSA6IDApOwoJaWYgKG5mc3ZlcnMgPiBNQVhfTkZTUFJPVCB8fCBtb3VudHZlcnMgPiBNQVhfTkZTUFJPVCkgewoJCWJiX2Vycm9yX21zZygiTkZTdiVkIG5vdCBzdXBwb3J0ZWQiLCBuZnN2ZXJzKTsKCQlnb3RvIGZhaWw7Cgl9CglpZiAobmZzdmVycyAmJiAhbW91bnR2ZXJzKQoJCW1vdW50dmVycyA9IChuZnN2ZXJzIDwgMykgPyAxIDogbmZzdmVyczsKCWlmIChuZnN2ZXJzICYmIG5mc3ZlcnMgPCBtb3VudHZlcnMpIHsKCQltb3VudHZlcnMgPSBuZnN2ZXJzOwoJfQoKCS8qIEFkanVzdCBvcHRpb25zIGlmIG5vbmUgc3BlY2lmaWVkICovCglpZiAoIWRhdGEudGltZW8pCgkJZGF0YS50aW1lbyA9IHRjcCA/IDcwIDogNzsKCglkYXRhLnZlcnNpb24gPSBuZnNfbW91bnRfdmVyc2lvbjsKCglpZiAodmZzZmxhZ3MgJiBNU19SRU1PVU5UKQoJCWdvdG8gZG9fbW91bnQ7CgoJLyoKCSAqIElmIHRoZSBwcmV2aW91cyBtb3VudCBvcGVyYXRpb24gb24gdGhlIHNhbWUgaG9zdCB3YXMKCSAqIGJhY2tncm91bmRlZCwgYW5kIHRoZSAiYmciIGZvciB0aGlzIG1vdW50IGlzIGFsc28gc2V0LAoJICogZ2l2ZSB1cCBpbW1lZGlhdGVseSwgdG8gYXZvaWQgdGhlIGluaXRpYWwgdGltZW91dC4KCSAqLwoJaWYgKGJnICYmIHdlX3Nhd190aGlzX2hvc3RfYmVmb3JlKGhvc3RuYW1lKSkgewoJCWRhZW1vbml6ZWQgPSBkYWVtb25pemUoKTsKCQlpZiAoZGFlbW9uaXplZCA8PSAwKSB7IC8qIHBhcmVudCBvciBlcnJvciAqLwoJCQlyZXR2YWwgPSAtZGFlbW9uaXplZDsKCQkJZ290byByZXQ7CgkJfQoJfQoKCS8qIGNyZWF0ZSBtb3VudCBkYWVtb24gY2xpZW50ICovCgkvKiBTZWUgaWYgdGhlIG5mcyBob3N0ID0gbW91bnQgaG9zdC4gKi8KCWlmIChtb3VudGhvc3QpIHsKCQlpZiAobW91bnRob3N0WzBdID49ICcwJyAmJiBtb3VudGhvc3RbMF0gPD0gJzknKSB7CgkJCW1vdW50X3NlcnZlcl9hZGRyLnNpbl9mYW1pbHkgPSBBRl9JTkVUOwoJCQltb3VudF9zZXJ2ZXJfYWRkci5zaW5fYWRkci5zX2FkZHIgPSBpbmV0X2FkZHIoaG9zdG5hbWUpOwoJCX0gZWxzZSB7CgkJCWhwID0gZ2V0aG9zdGJ5bmFtZShtb3VudGhvc3QpOwoJCQlpZiAoaHAgPT0gTlVMTCkgewoJCQkJYmJfaGVycm9yX21zZygiJXMiLCBtb3VudGhvc3QpOwoJCQkJZ290byBmYWlsOwoJCQl9IGVsc2UgewoJCQkJaWYgKGhwLT5oX2xlbmd0aCA+IHNpemVvZihzdHJ1Y3QgaW5fYWRkcikpIHsKCQkJCQliYl9lcnJvcl9tc2coImdvdCBiYWQgaHAtPmhfbGVuZ3RoPyIpOwoJCQkJCWhwLT5oX2xlbmd0aCA9IHNpemVvZihzdHJ1Y3QgaW5fYWRkcik7CgkJCQl9CgkJCQltb3VudF9zZXJ2ZXJfYWRkci5zaW5fZmFtaWx5ID0gQUZfSU5FVDsKCQkJCW1lbWNweSgmbW91bnRfc2VydmVyX2FkZHIuc2luX2FkZHIsCgkJCQkJCWhwLT5oX2FkZHIsIGhwLT5oX2xlbmd0aCk7CgkJCX0KCQl9Cgl9CgoJLyoKCSAqIFRoZSBmb2xsb3dpbmcgbG9vcCBpbXBsZW1lbnRzIHRoZSBtb3VudCByZXRyaWVzLiBXaGVuIHRoZSBtb3VudAoJICogdGltZXMgb3V0LCBhbmQgdGhlICJiZyIgb3B0aW9uIGlzIHNldCwgd2UgYmFja2dyb3VuZCBvdXJzZWxmCgkgKiBhbmQgY29udGludWUgdHJ5aW5nLgoJICoKCSAqIFRoZSBjYXNlIHdoZXJlIHRoZSBtb3VudCBwb2ludCBpcyBub3QgcHJlc2VudCBhbmQgdGhlICJiZyIKCSAqIG9wdGlvbiBpcyBzZXQsIGlzIHRyZWF0ZWQgYXMgYSB0aW1lb3V0LiBUaGlzIGlzIGRvbmUgdG8KCSAqIHN1cHBvcnQgbmVzdGVkIG1vdW50cy4KCSAqCgkgKiBUaGUgInJldHJ5IiBjb3VudCBzcGVjaWZpZWQgYnkgdGhlIHVzZXIgaXMgdGhlIG51bWJlciBvZgoJICogbWludXRlcyB0byByZXRyeSBiZWZvcmUgZ2l2aW5nIHVwLgoJICovCgl7CgkJc3RydWN0IHRpbWV2YWwgdG90YWxfdGltZW91dDsKCQlzdHJ1Y3QgdGltZXZhbCByZXRyeV90aW1lb3V0OwoJCXN0cnVjdCBwbWFwIHBtX21udDsKCQl0aW1lX3QgdDsKCQl0aW1lX3QgcHJldnQ7CgkJdGltZV90IHRpbWVvdXQ7CgoJCXJldHJ5X3RpbWVvdXQudHZfc2VjID0gMzsKCQlyZXRyeV90aW1lb3V0LnR2X3VzZWMgPSAwOwoJCXRvdGFsX3RpbWVvdXQudHZfc2VjID0gMjA7CgkJdG90YWxfdGltZW91dC50dl91c2VjID0gMDsKCQl0aW1lb3V0ID0gdGltZShOVUxMKSArIDYwICogcmV0cnk7CgkJcHJldnQgPSAwOwoJCXQgPSAzMDsKIHJldHJ5OgoJCS8qIGJlIGNhcmVmdWwgbm90IHRvIHVzZSB0b28gbWFueSBDUFUgY3ljbGVzICovCgkJaWYgKHQgLSBwcmV2dCA8IDMwKQoJCQlzbGVlcCgzMCk7CgoJCWdldF9tb3VudHBvcnQoJnBtX21udCwgJm1vdW50X3NlcnZlcl9hZGRyLAoJCQkJbW91bnRwcm9nLAoJCQkJbW91bnR2ZXJzLAoJCQkJcHJvdG8sCgkJCQltb3VudHBvcnQpOwoJCW5mc3ZlcnMgPSAocG1fbW50LnBtX3ZlcnMgPCAyKSA/IDIgOiBwbV9tbnQucG1fdmVyczsKCgkJLyogY29udGFjdCB0aGUgbW91bnQgZGFlbW9uIHZpYSBUQ1AgKi8KCQltb3VudF9zZXJ2ZXJfYWRkci5zaW5fcG9ydCA9IGh0b25zKHBtX21udC5wbV9wb3J0KTsKCQltc29jayA9IFJQQ19BTllTT0NLOwoKCQlzd2l0Y2ggKHBtX21udC5wbV9wcm90KSB7CgkJY2FzZSBJUFBST1RPX1VEUDoKCQkJbWNsaWVudCA9IGNsbnR1ZHBfY3JlYXRlKCZtb3VudF9zZXJ2ZXJfYWRkciwKCQkJCQkJIHBtX21udC5wbV9wcm9nLAoJCQkJCQkgcG1fbW50LnBtX3ZlcnMsCgkJCQkJCSByZXRyeV90aW1lb3V0LAoJCQkJCQkgJm1zb2NrKTsKCQkJaWYgKG1jbGllbnQpCgkJCQlicmVhazsKCQkJbW91bnRfc2VydmVyX2FkZHIuc2luX3BvcnQgPSBodG9ucyhwbV9tbnQucG1fcG9ydCk7CgkJCW1zb2NrID0gUlBDX0FOWVNPQ0s7CgkJY2FzZSBJUFBST1RPX1RDUDoKCQkJbWNsaWVudCA9IGNsbnR0Y3BfY3JlYXRlKCZtb3VudF9zZXJ2ZXJfYWRkciwKCQkJCQkJIHBtX21udC5wbV9wcm9nLAoJCQkJCQkgcG1fbW50LnBtX3ZlcnMsCgkJCQkJCSAmbXNvY2ssIDAsIDApOwoJCQlicmVhazsKCQlkZWZhdWx0OgoJCQltY2xpZW50ID0gTlVMTDsKCQl9CgkJaWYgKCFtY2xpZW50KSB7CgkJCWlmICghZGFlbW9uaXplZCAmJiBwcmV2dCA9PSAwKQoJCQkJZXJyb3JfbXNnX3JwYyhjbG50X3NwY3JlYXRlZXJyb3IoIiAiKSk7CgkJfSBlbHNlIHsKCQkJZW51bSBjbG50X3N0YXQgY2xudF9zdGF0OwoJCQkvKiB0cnkgdG8gbW91bnQgaG9zdG5hbWU6cGF0aG5hbWUgKi8KCQkJbWNsaWVudC0+Y2xfYXV0aCA9IGF1dGh1bml4X2NyZWF0ZV9kZWZhdWx0KCk7CgoJCQkvKiBtYWtlIHBvaW50ZXJzIGluIHhkcl9tb3VudHJlczMgTlVMTCBzbwoJCQkgKiB0aGF0IHhkcl9hcnJheSBhbGxvY2F0ZXMgbWVtb3J5IGZvciB1cwoJCQkgKi8KCQkJbWVtc2V0KCZzdGF0dXMsIDAsIHNpemVvZihzdGF0dXMpKTsKCgkJCWlmIChwbV9tbnQucG1fdmVycyA9PSAzKQoJCQkJY2xudF9zdGF0ID0gY2xudF9jYWxsKG1jbGllbnQsIE1PVU5UUFJPQzNfTU5ULAoJCQkJCSAgICAgICh4ZHJwcm9jX3QpIHhkcl9kaXJwYXRoLAoJCQkJCSAgICAgIChjYWRkcl90KSAmcGF0aG5hbWUsCgkJCQkJICAgICAgKHhkcnByb2NfdCkgeGRyX21vdW50cmVzMywKCQkJCQkgICAgICAoY2FkZHJfdCkgJnN0YXR1cywKCQkJCQkgICAgICB0b3RhbF90aW1lb3V0KTsKCQkJZWxzZQoJCQkJY2xudF9zdGF0ID0gY2xudF9jYWxsKG1jbGllbnQsIE1PVU5UUFJPQ19NTlQsCgkJCQkJICAgICAgKHhkcnByb2NfdCkgeGRyX2RpcnBhdGgsCgkJCQkJICAgICAgKGNhZGRyX3QpICZwYXRobmFtZSwKCQkJCQkgICAgICAoeGRycHJvY190KSB4ZHJfZmhzdGF0dXMsCgkJCQkJICAgICAgKGNhZGRyX3QpICZzdGF0dXMsCgkJCQkJICAgICAgdG90YWxfdGltZW91dCk7CgoJCQlpZiAoY2xudF9zdGF0ID09IFJQQ19TVUNDRVNTKQoJCQkJZ290byBwcmVwYXJlX2tlcm5lbF9kYXRhOyAvKiB3ZSdyZSBkb25lICovCgkJCWlmIChlcnJubyAhPSBFQ09OTlJFRlVTRUQpIHsKCQkJCWVycm9yX21zZ19ycGMoY2xudF9zcGVycm9yKG1jbGllbnQsICIgIikpOwoJCQkJZ290byBmYWlsOwkvKiBkb24ndCByZXRyeSAqLwoJCQl9CgkJCS8qIENvbm5lY3Rpb24gcmVmdXNlZCAqLwoJCQlpZiAoIWRhZW1vbml6ZWQgJiYgcHJldnQgPT0gMCkgLyogcHJpbnQganVzdCBvbmNlICovCgkJCQllcnJvcl9tc2dfcnBjKGNsbnRfc3BlcnJvcihtY2xpZW50LCAiICIpKTsKCQkJYXV0aF9kZXN0cm95KG1jbGllbnQtPmNsX2F1dGgpOwoJCQljbG50X2Rlc3Ryb3kobWNsaWVudCk7CgkJCW1jbGllbnQgPSBOVUxMOwoJCQljbG9zZShtc29jayk7CgkJCW1zb2NrID0gLTE7CgkJfQoKCQkvKiBUaW1lb3V0LiBXZSBhcmUgZ29pbmcgdG8gcmV0cnkuLi4gbWF5YmUgKi8KCgkJaWYgKCFiZykKCQkJZ290byBmYWlsOwoJCWlmICghZGFlbW9uaXplZCkgewoJCQlkYWVtb25pemVkID0gZGFlbW9uaXplKCk7CgkJCWlmIChkYWVtb25pemVkIDw9IDApIHsgLyogcGFyZW50IG9yIGVycm9yICovCgkJCQlyZXR2YWwgPSAtZGFlbW9uaXplZDsKCQkJCWdvdG8gcmV0OwoJCQl9CgkJfQoJCXByZXZ0ID0gdDsKCQl0ID0gdGltZShOVUxMKTsKCQlpZiAodCA+PSB0aW1lb3V0KQoJCQkvKiBUT0RPIGVycm9yIG1lc3NhZ2UgKi8KCQkJZ290byBmYWlsOwoKCQlnb3RvIHJldHJ5OwoJfQoKIHByZXBhcmVfa2VybmVsX2RhdGE6CgoJaWYgKG5mc3ZlcnMgPT0gMikgewoJCWlmIChzdGF0dXMubmZzdjIuZmhzX3N0YXR1cyAhPSAwKSB7CgkJCWJiX2Vycm9yX21zZygiJXM6JXMgZmFpbGVkLCByZWFzb24gZ2l2ZW4gYnkgc2VydmVyOiAlcyIsCgkJCQlob3N0bmFtZSwgcGF0aG5hbWUsCgkJCQluZnNfc3RyZXJyb3Ioc3RhdHVzLm5mc3YyLmZoc19zdGF0dXMpKTsKCQkJZ290byBmYWlsOwoJCX0KCQltZW1jcHkoZGF0YS5yb290LmRhdGEsCgkJCQkoY2hhciAqKSBzdGF0dXMubmZzdjIuZmhzdGF0dXNfdS5maHNfZmhhbmRsZSwKCQkJCU5GU19GSFNJWkUpOwoJCWRhdGEucm9vdC5zaXplID0gTkZTX0ZIU0laRTsKCQltZW1jcHkoZGF0YS5vbGRfcm9vdC5kYXRhLAoJCQkJKGNoYXIgKikgc3RhdHVzLm5mc3YyLmZoc3RhdHVzX3UuZmhzX2ZoYW5kbGUsCgkJCQlORlNfRkhTSVpFKTsKCX0gZWxzZSB7CgkJZmhhbmRsZTMgKm15X2ZoYW5kbGU7CgkJaWYgKHN0YXR1cy5uZnN2My5maHNfc3RhdHVzICE9IDApIHsKCQkJYmJfZXJyb3JfbXNnKCIlczolcyBmYWlsZWQsIHJlYXNvbiBnaXZlbiBieSBzZXJ2ZXI6ICVzIiwKCQkJCWhvc3RuYW1lLCBwYXRobmFtZSwKCQkJCW5mc19zdHJlcnJvcihzdGF0dXMubmZzdjMuZmhzX3N0YXR1cykpOwoJCQlnb3RvIGZhaWw7CgkJfQoJCW15X2ZoYW5kbGUgPSAmc3RhdHVzLm5mc3YzLm1vdW50cmVzM191Lm1vdW50aW5mby5maGFuZGxlOwoJCW1lbXNldChkYXRhLm9sZF9yb290LmRhdGEsIDAsIE5GU19GSFNJWkUpOwoJCW1lbXNldCgmZGF0YS5yb290LCAwLCBzaXplb2YoZGF0YS5yb290KSk7CgkJZGF0YS5yb290LnNpemUgPSBteV9maGFuZGxlLT5maGFuZGxlM19sZW47CgkJbWVtY3B5KGRhdGEucm9vdC5kYXRhLAoJCQkJKGNoYXIgKikgbXlfZmhhbmRsZS0+ZmhhbmRsZTNfdmFsLAoJCQkJbXlfZmhhbmRsZS0+ZmhhbmRsZTNfbGVuKTsKCgkJZGF0YS5mbGFncyB8PSBORlNfTU9VTlRfVkVSMzsKCX0KCgkvKiBjcmVhdGUgbmZzIHNvY2tldCBmb3Iga2VybmVsICovCgoJaWYgKHRjcCkgewoJCWlmIChuZnNfbW91bnRfdmVyc2lvbiA8IDMpIHsKCQkJYmJfZXJyb3JfbXNnKCJORlMgb3ZlciBUQ1AgaXMgbm90IHN1cHBvcnRlZCIpOwoJCQlnb3RvIGZhaWw7CgkJfQoJCWZzb2NrID0gc29ja2V0KEFGX0lORVQsIFNPQ0tfU1RSRUFNLCBJUFBST1RPX1RDUCk7Cgl9IGVsc2UKCQlmc29jayA9IHNvY2tldChBRl9JTkVULCBTT0NLX0RHUkFNLCBJUFBST1RPX1VEUCk7CglpZiAoZnNvY2sgPCAwKSB7CgkJYmJfcGVycm9yX21zZygibmZzIHNvY2tldCIpOwoJCWdvdG8gZmFpbDsKCX0KCWlmIChiaW5kcmVzdnBvcnQoZnNvY2ssIDApIDwgMCkgewoJCWJiX3BlcnJvcl9tc2coIm5mcyBiaW5kcmVzdnBvcnQiKTsKCQlnb3RvIGZhaWw7Cgl9CglpZiAocG9ydCA9PSAwKSB7CgkJc2VydmVyX2FkZHIuc2luX3BvcnQgPSBQTUFQUE9SVDsKCQlwb3J0ID0gcG1hcF9nZXRwb3J0KCZzZXJ2ZXJfYWRkciwgbmZzcHJvZywgbmZzdmVycywKCQkJCQl0Y3AgPyBJUFBST1RPX1RDUCA6IElQUFJPVE9fVURQKTsKCQlpZiAocG9ydCA9PSAwKQoJCQlwb3J0ID0gTkZTX1BPUlQ7Cgl9CglzZXJ2ZXJfYWRkci5zaW5fcG9ydCA9IGh0b25zKHBvcnQpOwoKCS8qIHByZXBhcmUgZGF0YSBzdHJ1Y3R1cmUgZm9yIGtlcm5lbCAqLwoKCWRhdGEuZmQgPSBmc29jazsKCW1lbWNweSgoY2hhciAqKSAmZGF0YS5hZGRyLCAoY2hhciAqKSAmc2VydmVyX2FkZHIsIHNpemVvZihkYXRhLmFkZHIpKTsKCXN0cm5jcHkoZGF0YS5ob3N0bmFtZSwgaG9zdG5hbWUsIHNpemVvZihkYXRhLmhvc3RuYW1lKSk7CgoJLyogY2xlYW4gdXAgKi8KCglhdXRoX2Rlc3Ryb3kobWNsaWVudC0+Y2xfYXV0aCk7CgljbG50X2Rlc3Ryb3kobWNsaWVudCk7CgljbG9zZShtc29jayk7Cgltc29jayA9IC0xOwoKCWlmIChiZykgewoJCS8qIFdlIG11c3Qgd2FpdCB1bnRpbCBtb3VudCBkaXJlY3RvcnkgaXMgYXZhaWxhYmxlICovCgkJc3RydWN0IHN0YXQgc3RhdGJ1ZjsKCQlpbnQgZGVsYXkgPSAxOwoJCXdoaWxlIChzdGF0KG1wLT5tbnRfZGlyLCAmc3RhdGJ1ZikgPT0gLTEpIHsKCQkJaWYgKCFkYWVtb25pemVkKSB7CgkJCQlkYWVtb25pemVkID0gZGFlbW9uaXplKCk7CgkJCQlpZiAoZGFlbW9uaXplZCA8PSAwKSB7IC8qIHBhcmVudCBvciBlcnJvciAqLwoJLy8gRklYTUU6IHBhcmVudCBkb2Vzbid0IGNsb3NlIGZzb2NrIC0gPz8hCgkJCQkJcmV0dmFsID0gLWRhZW1vbml6ZWQ7CgkJCQkJZ290byByZXQ7CgkJCQl9CgkJCX0KCQkJc2xlZXAoZGVsYXkpOwkvKiAxLCAyLCA0LCA4LCAxNiwgMzAsIC4uLiAqLwoJCQlkZWxheSAqPSAyOwoJCQlpZiAoZGVsYXkgPiAzMCkKCQkJCWRlbGF5ID0gMzA7CgkJfQoJfQoKIGRvX21vdW50OiAvKiBwZXJmb3JtIGFjdHVhbCBtb3VudCAqLwoKCW1wLT5tbnRfdHlwZSA9IChjaGFyKikibmZzIjsKCXJldHZhbCA9IG1vdW50X2l0X25vdyhtcCwgdmZzZmxhZ3MsIChjaGFyKikmZGF0YSk7Cglnb3RvIHJldDsKCiBmYWlsOgkvKiBhYm9ydCAqLwoKCWlmIChtc29jayA+PSAwKSB7CgkJaWYgKG1jbGllbnQpIHsKCQkJYXV0aF9kZXN0cm95KG1jbGllbnQtPmNsX2F1dGgpOwoJCQljbG50X2Rlc3Ryb3kobWNsaWVudCk7CgkJfQoJCWNsb3NlKG1zb2NrKTsKCX0KCWlmIChmc29jayA+PSAwKQoJCWNsb3NlKGZzb2NrKTsKCiByZXQ6CglmcmVlKGhvc3RuYW1lKTsKCWZyZWUobW91bnRob3N0KTsKCWZyZWUoZmlsdGVyb3B0cyk7CglyZXR1cm4gcmV0dmFsOwp9CgojZWxzZSAvKiAhRU5BQkxFX0ZFQVRVUkVfTU9VTlRfTkZTICovCgovKiBOZXZlciBjYWxsZWQuIENhbGwgc2hvdWxkIGJlIG9wdGltaXplZCBvdXQuICovCmludCBuZnNtb3VudChzdHJ1Y3QgbW50ZW50ICptcCwgaW50IHZmc2ZsYWdzLCBjaGFyICpmaWx0ZXJvcHRzKTsKCiNlbmRpZiAvKiAhRU5BQkxFX0ZFQVRVUkVfTU9VTlRfTkZTICovCgovLyBNb3VudCBvbmUgZGlyZWN0b3J5LiAgSGFuZGxlcyBDSUZTLCBORlMsIGxvb3BiYWNrLCBhdXRvYmluZCwgYW5kIGZpbGVzeXN0ZW0KLy8gdHlwZSBkZXRlY3Rpb24uICBSZXR1cm5zIDAgZm9yIHN1Y2Nlc3MsIG5vbnplcm8gZm9yIGZhaWx1cmUuCi8vIE5COiBtcC0+eHh4IGZpZWxkcyBtYXkgYmUgdHJhc2hlZCBvbiBleGl0CnN0YXRpYyBpbnQgc2luZ2xlbW91bnQoc3RydWN0IG1udGVudCAqbXAsIGludCBpZ25vcmVfYnVzeSkKewoJaW50IHJjID0gLTEsIHZmc2ZsYWdzOwoJY2hhciAqbG9vcEZpbGUgPSAwLCAqZmlsdGVyb3B0cyA9IDA7CglsbGlzdF90ICpmbCA9IDA7CglzdHJ1Y3Qgc3RhdCBzdDsKCgl2ZnNmbGFncyA9IHBhcnNlX21vdW50X29wdGlvbnMobXAtPm1udF9vcHRzLCAmZmlsdGVyb3B0cyk7CgoJLy8gVHJlYXQgZnN0eXBlICJhdXRvIiBhcyB1bnNwZWNpZmllZC4KCglpZiAobXAtPm1udF90eXBlICYmIHN0cmNtcChtcC0+bW50X3R5cGUsImF1dG8iKSA9PSAwKQoJCW1wLT5tbnRfdHlwZSA9IDA7CgoJLy8gTWlnaHQgdGhpcyBiZSBhIHZpcnR1YWwgZmlsZXN5c3RlbT8KCglpZiAoRU5BQkxFX0ZFQVRVUkVfTU9VTlRfSEVMUEVSUwoJICYmIChzdHJjaHIobXAtPm1udF9mc25hbWUsJyMnKSkKCSkgewoJCWNoYXIgKnMsICpwLCAqYXJnc1szNV07CgkJaW50IG4gPSAwOwoJCWZvciAocyA9IHAgPSBtcC0+bW50X2ZzbmFtZTsgKnMgJiYgbiA8IDM1LTM7ICsrcykgewoJCQlpZiAoc1swXSA9PSAnIycgJiYgc1sxXSAhPSAnIycpIHsKCQkJCSpzID0gJ1wwJzsKCQkJCWFyZ3NbbisrXSA9IHA7CgkJCQlwID0gcyArIDE7CgkJCX0KCQl9CgkJYXJnc1tuKytdID0gcDsKCQlhcmdzW24rK10gPSBtcC0+bW50X2RpcjsKCQlhcmdzW25dID0gTlVMTDsKCQlyYyA9IHdhaXQ0cGlkKHhzcGF3bihhcmdzKSk7CgkJZ290byByZXBvcnRfZXJyb3I7Cgl9CgoJLy8gTWlnaHQgdGhpcyBiZSBhbiBDSUZTIGZpbGVzeXN0ZW0/CgoJaWYgKEVOQUJMRV9GRUFUVVJFX01PVU5UX0NJRlMKCSAmJiAoIW1wLT5tbnRfdHlwZSB8fCBzdHJjbXAobXAtPm1udF90eXBlLCJjaWZzIikgPT0gMCkKCSAmJiAobXAtPm1udF9mc25hbWVbMF09PScvJyB8fCBtcC0+bW50X2ZzbmFtZVswXT09J1xcJykKCSAmJiBtcC0+bW50X2ZzbmFtZVswXT09bXAtPm1udF9mc25hbWVbMV0KCSkgewoJCWxlbl9hbmRfc29ja2FkZHIgKmxzYTsKCQljaGFyICppcCwgKmRvdHRlZDsKCQljaGFyICpzOwoKCQlyYyA9IDE7CgkJLy8gUmVwbGFjZSAnLycgd2l0aCAnXCcgYW5kIHZlcmlmeSB0aGF0IHVuYyBwb2ludHMgdG8gIi8vc2VydmVyL3NoYXJlIi4KCgkJZm9yIChzID0gbXAtPm1udF9mc25hbWU7ICpzOyArK3MpCgkJCWlmICgqcyA9PSAnLycpICpzID0gJ1xcJzsKCgkJLy8gZ2V0IHNlcnZlciBJUAoKCQlzID0gc3RycmNocihtcC0+bW50X2ZzbmFtZSwgJ1xcJyk7CgkJaWYgKHMgPD0gbXAtPm1udF9mc25hbWUrMSkgZ290byByZXBvcnRfZXJyb3I7CgkJKnMgPSAnXDAnOwoJCWxzYSA9IGhvc3Qyc29ja2FkZHIobXAtPm1udF9mc25hbWUrMiwgMCk7CgkJKnMgPSAnXFwnOwoJCWlmICghbHNhKSBnb3RvIHJlcG9ydF9lcnJvcjsKCgkJLy8gaW5zZXJ0IGlwPS4uLiBvcHRpb24gaW50byBzdHJpbmcgZmxhZ3MuCgoJCWRvdHRlZCA9IHhtYWxsb2Nfc29ja2FkZHIyZG90dGVkX25vcG9ydCgmbHNhLT5zYSk7CgkJaXAgPSB4YXNwcmludGYoImlwPSVzIiwgZG90dGVkKTsKCQlwYXJzZV9tb3VudF9vcHRpb25zKGlwLCAmZmlsdGVyb3B0cyk7CgoJCS8vIGNvbXBvc2UgbmV3IHVuYyAnXFxzZXJ2ZXItaXBcc2hhcmUnCgkJLy8gKHMgPT4gc2xhc2ggYWZ0ZXIgaG9zdG5hbWUpCgoJCW1wLT5tbnRfZnNuYW1lID0geGFzcHJpbnRmKCJcXFxcJXMlcyIsIGRvdHRlZCwgcyk7CgoJCS8vIGxvY2sgaXMgcmVxdWlyZWQKCQl2ZnNmbGFncyB8PSBNU19NQU5ETE9DSzsKCgkJbXAtPm1udF90eXBlID0gKGNoYXIqKSJjaWZzIjsKCQlyYyA9IG1vdW50X2l0X25vdyhtcCwgdmZzZmxhZ3MsIGZpbHRlcm9wdHMpOwoJCWlmIChFTkFCTEVfRkVBVFVSRV9DTEVBTl9VUCkgewoJCQlmcmVlKG1wLT5tbnRfZnNuYW1lKTsKCQkJZnJlZShpcCk7CgkJCWZyZWUoZG90dGVkKTsKCQkJZnJlZShsc2EpOwoJCX0KCQlnb3RvIHJlcG9ydF9lcnJvcjsKCX0KCgkvLyBNaWdodCB0aGlzIGJlIGFuIE5GUyBmaWxlc3lzdGVtPwoKCWlmIChFTkFCTEVfRkVBVFVSRV9NT1VOVF9ORlMKCSAmJiAoIW1wLT5tbnRfdHlwZSB8fCAhc3RyY21wKG1wLT5tbnRfdHlwZSwgIm5mcyIpKQoJICYmIHN0cmNocihtcC0+bW50X2ZzbmFtZSwgJzonKSAhPSBOVUxMCgkpIHsKCQlyYyA9IG5mc21vdW50KG1wLCB2ZnNmbGFncywgZmlsdGVyb3B0cyk7CgkJZ290byByZXBvcnRfZXJyb3I7Cgl9CgoJLy8gTG9vayBhdCB0aGUgZmlsZS4gIChOb3QgZm91bmQgaXNuJ3QgYSBmYWlsdXJlIGZvciByZW1vdW50LCBvciBmb3IKCS8vIGEgc3ludGhldGljIGZpbGVzeXN0ZW0gbGlrZSBwcm9jIG9yIHN5c2ZzLikKCS8vIChXZSB1c2Ugc3RhdCwgbm90IGxzdGF0LCBpbiBvcmRlciB0byBhbGxvdwoJLy8gbW91bnQgc3ltbGlua190b19maWxlX29yX2Jsa2RldiBkaXIpCgoJaWYgKCFzdGF0KG1wLT5tbnRfZnNuYW1lLCAmc3QpCgkgJiYgISh2ZnNmbGFncyAmIChNU19SRU1PVU5UIHwgTVNfQklORCB8IE1TX01PVkUpKQoJKSB7CgkJLy8gRG8gd2UgbmVlZCB0byBhbGxvY2F0ZSBhIGxvb3BiYWNrIGRldmljZSBmb3IgaXQ/CgoJCWlmIChFTkFCTEVfRkVBVFVSRV9NT1VOVF9MT09QICYmIFNfSVNSRUcoc3Quc3RfbW9kZSkpIHsKCQkJbG9vcEZpbGUgPSBiYl9zaW1wbGlmeV9wYXRoKG1wLT5tbnRfZnNuYW1lKTsKCQkJbXAtPm1udF9mc25hbWUgPSBOVUxMOyAvKiB3aWxsIHJlY2VpdmUgbWFsbG9jZWQgbG9vcCBkZXYgbmFtZSAqLwoJCQlpZiAoc2V0X2xvb3AoJihtcC0+bW50X2ZzbmFtZSksIGxvb3BGaWxlLCAwKSA8IDApIHsKCQkJCWlmIChlcnJubyA9PSBFUEVSTSB8fCBlcnJubyA9PSBFQUNDRVMpCgkJCQkJYmJfZXJyb3JfbXNnKGJiX21zZ19wZXJtX2RlbmllZF9hcmVfeW91X3Jvb3QpOwoJCQkJZWxzZQoJCQkJCWJiX3BlcnJvcl9tc2coImNhbm5vdCBzZXR1cCBsb29wIGRldmljZSIpOwoJCQkJcmV0dXJuIGVycm5vOwoJCQl9CgoJCS8vIEF1dG9kZXRlY3QgYmluZCBtb3VudHMKCgkJfSBlbHNlIGlmIChTX0lTRElSKHN0LnN0X21vZGUpICYmICFtcC0+bW50X3R5cGUpCgkJCXZmc2ZsYWdzIHw9IE1TX0JJTkQ7Cgl9CgoJLyogSWYgd2Uga25vdyB0aGUgZnN0eXBlIChvciBkb24ndCBuZWVkIHRvKSwganVtcCBzdHJhaWdodAoJICogdG8gdGhlIGFjdHVhbCBtb3VudC4gKi8KCglpZiAobXAtPm1udF90eXBlIHx8ICh2ZnNmbGFncyAmIChNU19SRU1PVU5UIHwgTVNfQklORCB8IE1TX01PVkUpKSkKCQlyYyA9IG1vdW50X2l0X25vdyhtcCwgdmZzZmxhZ3MsIGZpbHRlcm9wdHMpOwoJZWxzZSB7CgkJLy8gTG9vcCB0aHJvdWdoIGZpbGVzeXN0ZW0gdHlwZXMgdW50aWwgbW91bnQgc3VjY2VlZHMKCQkvLyBvciB3ZSBydW4gb3V0CgoJCS8qIEluaXRpYWxpemUgbGlzdCBvZiBibG9jayBiYWNrZWQgZmlsZXN5c3RlbXMuICBUaGlzIGhhcyB0byBiZQoJCSAqIGRvbmUgaGVyZSBzbyB0aGF0IGR1cmluZyAibW91bnQgLWEiLCBtb3VudHMgYWZ0ZXIgL3Byb2Mgc2hvd3MgdXAKCQkgKiBjYW4gYXV0b2RldGVjdC4gKi8KCgkJaWYgKCFmc2xpc3QpIHsKCQkJZnNsaXN0ID0gZ2V0X2Jsb2NrX2JhY2tlZF9maWxlc3lzdGVtcygpOwoJCQlpZiAoRU5BQkxFX0ZFQVRVUkVfQ0xFQU5fVVAgJiYgZnNsaXN0KQoJCQkJYXRleGl0KGRlbGV0ZV9ibG9ja19iYWNrZWRfZmlsZXN5c3RlbXMpOwoJCX0KCgkJZm9yIChmbCA9IGZzbGlzdDsgZmw7IGZsID0gZmwtPmxpbmspIHsKCQkJbXAtPm1udF90eXBlID0gZmwtPmRhdGE7CgkJCXJjID0gbW91bnRfaXRfbm93KG1wLCB2ZnNmbGFncywgZmlsdGVyb3B0cyk7CgkJCWlmICghcmMpIGJyZWFrOwoJCX0KCX0KCgkvLyBJZiBtb3VudCBmYWlsZWQsIGNsZWFuIHVwIGxvb3AgZmlsZSAoaWYgYW55KS4KCglpZiAoRU5BQkxFX0ZFQVRVUkVfTU9VTlRfTE9PUCAmJiByYyAmJiBsb29wRmlsZSkgewoJCWRlbF9sb29wKG1wLT5tbnRfZnNuYW1lKTsKCQlpZiAoRU5BQkxFX0ZFQVRVUkVfQ0xFQU5fVVApIHsKCQkJZnJlZShsb29wRmlsZSk7CgkJCWZyZWUobXAtPm1udF9mc25hbWUpOwoJCX0KCX0KCiByZXBvcnRfZXJyb3I6CglpZiAoRU5BQkxFX0ZFQVRVUkVfQ0xFQU5fVVApCgkJZnJlZShmaWx0ZXJvcHRzKTsKCglpZiAoZXJybm8gPT0gRUJVU1kgJiYgaWdub3JlX2J1c3kpCgkJcmV0dXJuIDA7CglpZiAocmMgPCAwKQoJCWJiX3BlcnJvcl9tc2coIm1vdW50aW5nICVzIG9uICVzIGZhaWxlZCIsIG1wLT5tbnRfZnNuYW1lLCBtcC0+bW50X2Rpcik7CglyZXR1cm4gcmM7Cn0KCi8vIFBhcnNlIG9wdGlvbnMsIGlmIG5lY2Vzc2FyeSBwYXJzZSBmc3RhYi9tdGFiLCBhbmQgY2FsbCBzaW5nbGVtb3VudCBmb3IKLy8gZWFjaCBkaXJlY3RvcnkgdG8gYmUgbW91bnRlZC4KCnN0YXRpYyBjb25zdCBjaGFyIG11c3RfYmVfcm9vdFtdIEFMSUdOMSA9ICJ5b3UgbXVzdCBiZSByb290IjsKCmludCBtb3VudF9tYWluKGludCBhcmdjLCBjaGFyICoqYXJndikgTUFJTl9FWFRFUk5BTExZX1ZJU0lCTEU7CmludCBtb3VudF9tYWluKGludCBhcmdjLCBjaGFyICoqYXJndikKewoJZW51bSB7IE9QVF9BTEwgPSAweDEwIH07CgoJY2hhciAqY21kb3B0cyA9IHhzdHJkdXAoIiIpLCAqZnN0eXBlPTAsICpzdG9yYWdlX3BhdGg9MDsKCWNoYXIgKm9wdF9vOwoJY29uc3QgY2hhciAqZnN0YWJuYW1lOwoJRklMRSAqZnN0YWI7CglpbnQgaSwgaiwgcmMgPSAwOwoJdW5zaWduZWQgb3B0OwoJc3RydWN0IG1udGVudCBtdHBhaXJbMl0sICptdGN1ciA9IG10cGFpcjsKCVNLSVBfREVTS1RPUChjb25zdCBpbnQgbm9ucm9vdCA9IDA7KQoJVVNFX0RFU0tUT1AoIGludCBub25yb290ID0gKGdldHVpZCgpICE9IDApOykKCgkvKiBwYXJzZSBsb25nIG9wdGlvbnMsIGxpa2UgLS1iaW5kIGFuZCAtLW1vdmUuICBOb3RlIHRoYXQgLW8gb3B0aW9uCgkgKiBhbmQgLS1vcHRpb24gYXJlIHN5bm9ueW1vdXMuICBZZXMsIHRoaXMgbWVhbnMgLS1yZW1vdW50LHJ3IHdvcmtzLiAqLwoKCWZvciAoaSA9IGogPSAwOyBpIDwgYXJnYzsgaSsrKSB7CgkJaWYgKGFyZ3ZbaV1bMF0gPT0gJy0nICYmIGFyZ3ZbaV1bMV0gPT0gJy0nKSB7CgkJCWFwcGVuZF9tb3VudF9vcHRpb25zKCZjbWRvcHRzLCBhcmd2W2ldKzIpOwoJCX0gZWxzZSBhcmd2W2orK10gPSBhcmd2W2ldOwoJfQoJYXJndltqXSA9IDA7CglhcmdjID0gajsKCgkvLyBQYXJzZSByZW1haW5pbmcgb3B0aW9ucwoKCW9wdCA9IGdldG9wdDMyKGFyZ3YsICJvOnQ6cndhbmZ2c2kiLCAmb3B0X28sICZmc3R5cGUpOwoJaWYgKG9wdCAmIDB4MSkgYXBwZW5kX21vdW50X29wdGlvbnMoJmNtZG9wdHMsIG9wdF9vKTsgLy8gLW8KCS8vaWYgKG9wdCAmIDB4MikgLy8gLXQKCWlmIChvcHQgJiAweDQpIGFwcGVuZF9tb3VudF9vcHRpb25zKCZjbWRvcHRzLCAicm8iKTsgLy8gLXIKCWlmIChvcHQgJiAweDgpIGFwcGVuZF9tb3VudF9vcHRpb25zKCZjbWRvcHRzLCAicnciKTsgLy8gLXcKCS8vaWYgKG9wdCAmIDB4MTApIC8vIC1hCglpZiAob3B0ICYgMHgyMCkgVVNFX0ZFQVRVUkVfTVRBQl9TVVBQT1JUKHVzZU10YWIgPSAwKTsgLy8gLW4KCWlmIChvcHQgJiAweDQwKSBVU0VfRkVBVFVSRV9NVEFCX1NVUFBPUlQoZmFrZUl0ID0gMSk7IC8vIC1mCgkvL2lmIChvcHQgJiAweDgwKSAvLyAtdjogdmVyYm9zZSAoaWdub3JlKQoJLy9pZiAob3B0ICYgMHgxMDApIC8vIC1zOiBzbG9wcHkgKGlnbm9yZSkKCS8vaWYgKG9wdCAmIDB4MjAwKSAvLyAtaTogZG9uJ3QgY2FsbCBtb3VudC48ZnN0eXBlPiAoaWdub3JlKQoJYXJndiArPSBvcHRpbmQ7CglhcmdjIC09IG9wdGluZDsKCgkvLyBUaHJlZSBvciBtb3JlIG5vbi1vcHRpb24gYXJndW1lbnRzPyAgRGllIHdpdGggYSB1c2FnZSBtZXNzYWdlLgoKCWlmIChhcmdjID4gMikgYmJfc2hvd191c2FnZSgpOwoKCS8vIElmIHdlIGhhdmUgbm8gYXJndW1lbnRzLCBzaG93IGN1cnJlbnRseSBtb3VudGVkIGZpbGVzeXN0ZW1zCgoJaWYgKCFhcmdjKSB7CgkJaWYgKCEob3B0ICYgT1BUX0FMTCkpIHsKCQkJRklMRSAqbW91bnRUYWJsZSA9IHNldG1udGVudChiYl9wYXRoX210YWJfZmlsZSwgInIiKTsKCgkJCWlmICghbW91bnRUYWJsZSkgYmJfZXJyb3JfbXNnX2FuZF9kaWUoIm5vICVzIiwgYmJfcGF0aF9tdGFiX2ZpbGUpOwoKCQkJd2hpbGUgKGdldG1udGVudF9yKG1vdW50VGFibGUsICZtdHBhaXJbMF0sIGdldG1udGVudF9idWYsCgkJCQkJCQkJc2l6ZW9mKGdldG1udGVudF9idWYpKSkKCQkJewoJCQkJLy8gRG9uJ3Qgc2hvdyByb290ZnMuIEZJWE1FOiB3aHk/PwoJCQkJLy8gdXRpbC1saW51eCAyLjEyYSBoYXBwaWx5IHNob3dzIHJvb3Rmcy4uLgoJCQkJLy9pZiAoIXN0cmNtcChtdHBhaXItPm1udF9mc25hbWUsICJyb290ZnMiKSkgY29udGludWU7CgoJCQkJaWYgKCFmc3R5cGUgfHwgIXN0cmNtcChtdHBhaXItPm1udF90eXBlLCBmc3R5cGUpKQoJCQkJCXByaW50ZigiJXMgb24gJXMgdHlwZSAlcyAoJXMpXG4iLCBtdHBhaXItPm1udF9mc25hbWUsCgkJCQkJCQltdHBhaXItPm1udF9kaXIsIG10cGFpci0+bW50X3R5cGUsCgkJCQkJCQltdHBhaXItPm1udF9vcHRzKTsKCQkJfQoJCQlpZiAoRU5BQkxFX0ZFQVRVUkVfQ0xFQU5fVVApIGVuZG1udGVudChtb3VudFRhYmxlKTsKCQkJcmV0dXJuIEVYSVRfU1VDQ0VTUzsKCQl9Cgl9IGVsc2Ugc3RvcmFnZV9wYXRoID0gYmJfc2ltcGxpZnlfcGF0aChhcmd2WzBdKTsKCgkvLyBXaGVuIHdlIGhhdmUgdHdvIGFyZ3VtZW50cywgdGhlIHNlY29uZCBpcyB0aGUgZGlyZWN0b3J5IGFuZCB3ZSBjYW4KCS8vIHNraXAgbG9va2luZyBhdCBmc3RhYiBlbnRpcmVseS4gIFdlIGNhbiBhbHdheXMgYWJzcGF0aCgpIHRoZSBkaXJlY3RvcnkKCS8vIGFyZ3VtZW50IHdoZW4gd2UgZ2V0IGl0LgoKCWlmIChhcmdjID09IDIpIHsKCQlpZiAobm9ucm9vdCkKCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUobXVzdF9iZV9yb290KTsKCQltdHBhaXItPm1udF9mc25hbWUgPSBhcmd2WzBdOwoJCW10cGFpci0+bW50X2RpciA9IGFyZ3ZbMV07CgkJbXRwYWlyLT5tbnRfdHlwZSA9IGZzdHlwZTsKCQltdHBhaXItPm1udF9vcHRzID0gY21kb3B0czsKCQlyYyA9IHNpbmdsZW1vdW50KG10cGFpciwgMCk7CgkJZ290byBjbGVhbl91cDsKCX0KCglpID0gcGFyc2VfbW91bnRfb3B0aW9ucyhjbWRvcHRzLCAwKTsKCWlmIChub25yb290ICYmIChpICYgfk1TX1NJTEVOVCkpIC8vIE5vbi1yb290IHVzZXJzIGNhbm5vdCBzcGVjaWZ5IGZsYWdzCgkJYmJfZXJyb3JfbXNnX2FuZF9kaWUobXVzdF9iZV9yb290KTsKCgkvLyBJZiB3ZSBoYXZlIGEgc2hhcmVkIHN1YnRyZWUgZmxhZywgZG9uJ3Qgd29ycnkgYWJvdXQgZnN0YWIgb3IgbXRhYi4KCglpZiAoRU5BQkxFX0ZFQVRVUkVfTU9VTlRfRkxBR1MKCSAmJiAoaSAmIChNU19TSEFSRUQgfCBNU19QUklWQVRFIHwgTVNfU0xBVkUgfCBNU19VTkJJTkRBQkxFKSkKCSkgewoJCXJjID0gbW91bnQoIiIsIGFyZ3ZbMF0sICIiLCBpLCAiIik7CgkJaWYgKHJjKSBiYl9zaW1wbGVfcGVycm9yX21zZ19hbmRfZGllKGFyZ3ZbMF0pOwoJCWdvdG8gY2xlYW5fdXA7Cgl9CgoJLy8gT3BlbiBlaXRoZXIgZnN0YWIgb3IgbXRhYgoKCWZzdGFibmFtZSA9ICIvZXRjL2ZzdGFiIjsKCWlmIChpICYgTVNfUkVNT1VOVCkgewoJCWZzdGFibmFtZSA9IGJiX3BhdGhfbXRhYl9maWxlOwoJfQoJZnN0YWIgPSBzZXRtbnRlbnQoZnN0YWJuYW1lLCAiciIpOwoJaWYgKCFmc3RhYikKCQliYl9wZXJyb3JfbXNnX2FuZF9kaWUoImNhbm5vdCByZWFkICVzIiwgZnN0YWJuYW1lKTsKCgkvLyBMb29wIHRocm91Z2ggZW50cmllcyB1bnRpbCB3ZSBmaW5kIHdoYXQgd2UncmUgbG9va2luZyBmb3IuCgoJbWVtc2V0KG10cGFpciwgMCwgc2l6ZW9mKG10cGFpcikpOwoJZm9yICg7OykgewoJCXN0cnVjdCBtbnRlbnQgKm10bmV4dCA9IChtdGN1cj09bXRwYWlyID8gbXRwYWlyKzEgOiBtdHBhaXIpOwoKCQkvLyBHZXQgbmV4dCBmc3RhYiBlbnRyeQoKCQlpZiAoIWdldG1udGVudF9yKGZzdGFiLCBtdGN1ciwgZ2V0bW50ZW50X2J1ZgoJCQkJCSsgKG10Y3VyPT1tdHBhaXIgPyBzaXplb2YoZ2V0bW50ZW50X2J1ZikvMiA6IDApLAoJCQkJc2l6ZW9mKGdldG1udGVudF9idWYpLzIpKQoJCXsKCQkJLy8gV2VyZSB3ZSBsb29raW5nIGZvciBzb21ldGhpbmcgc3BlY2lmaWM/CgoJCQlpZiAoYXJnYykgewoKCQkJCS8vIElmIHdlIGRpZG4ndCBmaW5kIGFueXRoaW5nLCBjb21wbGFpbi4KCgkJCQlpZiAoIW10bmV4dC0+bW50X2ZzbmFtZSkKCQkJCQliYl9lcnJvcl9tc2dfYW5kX2RpZSgiY2FuJ3QgZmluZCAlcyBpbiAlcyIsCgkJCQkJCWFyZ3ZbMF0sIGZzdGFibmFtZSk7CgoJCQkJbXRjdXIgPSBtdG5leHQ7CgkJCQlpZiAobm9ucm9vdCkgewoJCQkJCS8vIGZzdGFiIG11c3QgaGF2ZSAidXNlcnMiIG9yICJ1c2VyIgoJCQkJCWlmICghKHBhcnNlX21vdW50X29wdGlvbnMobXRjdXItPm1udF9vcHRzLCAwKSAmIE1PVU5UX1VTRVJTKSkKCQkJCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUobXVzdF9iZV9yb290KTsKCQkJCX0KCgkJCQkvLyBNb3VudCB0aGUgbGFzdCB0aGluZyB3ZSBmb3VuZC4KCgkJCQltdGN1ci0+bW50X29wdHMgPSB4c3RyZHVwKG10Y3VyLT5tbnRfb3B0cyk7CgkJCQlhcHBlbmRfbW91bnRfb3B0aW9ucygmKG10Y3VyLT5tbnRfb3B0cyksIGNtZG9wdHMpOwoJCQkJcmMgPSBzaW5nbGVtb3VudChtdGN1ciwgMCk7CgkJCQlmcmVlKG10Y3VyLT5tbnRfb3B0cyk7CgkJCX0KCQkJZ290byBjbGVhbl91cDsKCQl9CgoJCS8qIElmIHdlJ3JlIHRyeWluZyB0byBtb3VudCBzb21ldGhpbmcgc3BlY2lmaWMgYW5kIHRoaXMgaXNuJ3QgaXQsCgkJICogc2tpcCBpdC4gIE5vdGUgd2UgbXVzdCBtYXRjaCBib3RoIHRoZSBleGFjdCB0ZXh0IGluIGZzdGFiIChhbGEKCQkgKiAicHJvYyIpIG9yIGEgZnVsbCBwYXRoIGZyb20gcm9vdCAqLwoKCQlpZiAoYXJnYykgewoKCQkJLy8gSXMgdGhpcyB3aGF0IHdlJ3JlIGxvb2tpbmcgZm9yPwoKCQkJaWYgKHN0cmNtcChhcmd2WzBdLCBtdGN1ci0+bW50X2ZzbmFtZSkgJiYKCQkJICAgc3RyY21wKHN0b3JhZ2VfcGF0aCwgbXRjdXItPm1udF9mc25hbWUpICYmCgkJCSAgIHN0cmNtcChhcmd2WzBdLCBtdGN1ci0+bW50X2RpcikgJiYKCQkJICAgc3RyY21wKHN0b3JhZ2VfcGF0aCwgbXRjdXItPm1udF9kaXIpKSBjb250aW51ZTsKCgkJCS8vIFJlbWVtYmVyIHRoaXMgZW50cnkuICBTb21ldGhpbmcgbGF0ZXIgbWF5IGhhdmUgb3Zlcm1vdW50ZWQKCQkJLy8gaXQsIGFuZCB3ZSB3YW50IHRoZSBfbGFzdF8gbWF0Y2guCgoJCQltdGN1ciA9IG10bmV4dDsKCgkJLy8gSWYgd2UncmUgbW91bnRpbmcgYWxsLgoKCQl9IGVsc2UgewoJCQkvLyBEbyB3ZSBuZWVkIHRvIG1hdGNoIGEgZmlsZXN5c3RlbSB0eXBlPwoJCQlpZiAoZnN0eXBlICYmIG1hdGNoX2ZzdHlwZShtdGN1ciwgZnN0eXBlKSkgY29udGludWU7CgoJCQkvLyBTa2lwIG5vYXV0byBhbmQgc3dhcCBhbnl3YXkuCgoJCQlpZiAocGFyc2VfbW91bnRfb3B0aW9ucyhtdGN1ci0+bW50X29wdHMsIDApCgkJCQkmIChNT1VOVF9OT0FVVE8gfCBNT1VOVF9TV0FQKSkgY29udGludWU7CgoJCQkvLyBObywgbW91bnQgLWEgd29uJ3QgbW91bnQgYW55dGhpbmcsCgkJCS8vIGV2ZW4gdXNlciBtb3VudHMsIGZvciBtZXJlIGh1bWFucy4KCgkJCWlmIChub25yb290KQoJCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUobXVzdF9iZV9yb290KTsKCgkJCS8vIE1vdW50IHRoaXMgdGhpbmcuCgoJCQkvLyBORlMgbW91bnRzIHdhbnQgdGhpcyB0byBiZSB4cmVhbGxvYy1hYmxlCgkJCW10Y3VyLT5tbnRfb3B0cyA9IHhzdHJkdXAobXRjdXItPm1udF9vcHRzKTsKCQkJaWYgKHNpbmdsZW1vdW50KG10Y3VyLCAxKSkgewoJCQkJLyogQ291bnQgbnVtYmVyIG9mIGZhaWxlZCBtb3VudHMgKi8KCQkJCXJjKys7CgkJCX0KCQkJZnJlZShtdGN1ci0+bW50X29wdHMpOwoJCX0KCX0KCWlmIChFTkFCTEVfRkVBVFVSRV9DTEVBTl9VUCkgZW5kbW50ZW50KGZzdGFiKTsKCiBjbGVhbl91cDoKCglpZiAoRU5BQkxFX0ZFQVRVUkVfQ0xFQU5fVVApIHsKCQlmcmVlKHN0b3JhZ2VfcGF0aCk7CgkJZnJlZShjbWRvcHRzKTsKCX0KCglyZXR1cm4gcmM7Cn0K