Lyogdmk6IHNldCBzdz00IHRzPTQ6ICovCi8qCiAqIE1pbmkgbW91bnQgaW1wbGVtZW50YXRpb24gZm9yIGJ1c3lib3gKICoKICogQ29weXJpZ2h0IChDKSAxOTk1LCAxOTk2IGJ5IEJydWNlIFBlcmVucyA8YnJ1Y2VAcGl4YXIuY29tPi4KICogQ29weXJpZ2h0IChDKSAxOTk5LTIwMDQgYnkgRXJpayBBbmRlcnNlbiA8YW5kZXJzZW5AY29kZXBvZXQub3JnPgogKiBDb3B5cmlnaHQgKEMpIDIwMDUtMjAwNiBieSBSb2IgTGFuZGxleSA8cm9iQGxhbmRsZXkubmV0PgogKgogKiBMaWNlbnNlZCB1bmRlciBHUEx2MiBvciBsYXRlciwgc2VlIGZpbGUgTElDRU5TRSBpbiB0aGlzIHRhcmJhbGwgZm9yIGRldGFpbHMuCiAqLwoKLyogRGVzaWduIG5vdGVzOiBUaGVyZSBpcyBubyBzcGVjIGZvciBtb3VudC4gIFJlbWluZCBtZSB0byB3cml0ZSBvbmUuCgogICBtb3VudF9tYWluKCkgY2FsbHMgc2luZ2xlbW91bnQoKSB3aGljaCBjYWxscyBtb3VudF9pdF9ub3coKS4KCiAgIG1vdW50X21haW4oKSBjYW4gbG9vcCB0aHJvdWdoIC9ldGMvZnN0YWIgZm9yIG1vdW50IC1hCiAgIHNpbmdsZW1vdW50KCkgY2FuIGxvb3AgdGhyb3VnaCAvZXRjL2ZpbGVzeXN0ZW1zIGZvciBmc3R5cGUgZGV0ZWN0aW9uLgogICBtb3VudF9pdF9ub3coKSBkb2VzIHRoZSBhY3R1YWwgbW91bnQuCiovCgojaW5jbHVkZSAiYnVzeWJveC5oIgojaW5jbHVkZSA8bW50ZW50Lmg+CgovKiBOZWVkZWQgZm9yIG5mcyBzdXBwb3J0IG9ubHkuLi4gKi8KI2luY2x1ZGUgPHN5c2xvZy5oPgojaW5jbHVkZSA8c3lzL3V0c25hbWUuaD4KI3VuZGVmIFRSVUUKI3VuZGVmIEZBTFNFCiNpbmNsdWRlIDxycGMvcnBjLmg+CiNpbmNsdWRlIDxycGMvcG1hcF9wcm90Lmg+CiNpbmNsdWRlIDxycGMvcG1hcF9jbG50Lmg+CgoKLy8gTm90IHJlYWwgZmxhZ3MsIGJ1dCB3ZSB3YW50IHRvIGJlIGFibGUgdG8gY2hlY2sgZm9yIHRoaXMuCmVudW0gewoJTU9VTlRfVVNFUlMgID0gKDE8PDI4KSpFTkFCTEVfREVTS1RPUCwKCU1PVU5UX05PQVVUTyA9ICgxPDwyOSksCglNT1VOVF9TV0FQICAgPSAoMTw8MzApLAp9OwovLyBUT0RPOiBtb3JlICJ1c2VyIiBmbGFnIGNvbXBhdGliaWxpdHkuCi8vICJ1c2VyIiBvcHRpb24gKGZyb20gbW91bnQgbWFucGFnZSk6Ci8vIE9ubHkgdGhlIHVzZXIgdGhhdCBtb3VudGVkIGEgZmlsZXN5c3RlbSBjYW4gdW5tb3VudCBpdCBhZ2Fpbi4KLy8gSWYgYW55IHVzZXIgc2hvdWxkIGJlIGFibGUgdG8gdW5tb3VudCwgdGhlbiB1c2UgdXNlcnMgaW5zdGVhZCBvZiB1c2VyCi8vIGluIHRoZSBmc3RhYiBsaW5lLiAgVGhlIG93bmVyIG9wdGlvbiBpcyBzaW1pbGFyIHRvIHRoZSB1c2VyIG9wdGlvbiwKLy8gd2l0aCB0aGUgcmVzdHJpY3Rpb24gdGhhdCB0aGUgdXNlciBtdXN0IGJlIHRoZSBvd25lciBvZiB0aGUgc3BlY2lhbCBmaWxlLgovLyBUaGlzIG1heSBiZSB1c2VmdWwgZS5nLiBmb3IgL2Rldi9mZCBpZiBhIGxvZ2luIHNjcmlwdCBtYWtlcwovLyB0aGUgY29uc29sZSB1c2VyIG93bmVyIG9mIHRoaXMgZGV2aWNlLgoKLyogU3RhbmRhcmQgbW91bnQgb3B0aW9ucyAoZnJvbSAtbyBvcHRpb25zIG9yIC0tb3B0aW9ucyksIHdpdGggY29ycmVzcG9uZGluZwogKiBmbGFncyAqLwoKc3RydWN0IHsKCWNoYXIgKm5hbWU7Cglsb25nIGZsYWdzOwp9IHN0YXRpYyBtb3VudF9vcHRpb25zW10gPSB7CgkvLyBNU19GTEFHUyBzZXQgYSBiaXQuICB+TVNfRkxBR1MgZGlzYWJsZSB0aGF0IGJpdC4gIDAgZmxhZ3MgYXJlIE5PUHMuCgoJVVNFX0ZFQVRVUkVfTU9VTlRfTE9PUCgKCQl7Imxvb3AiLCAwfSwKCSkKCglVU0VfRkVBVFVSRV9NT1VOVF9GU1RBQigKCQl7ImRlZmF1bHRzIiwgMH0sCgkJeyJxdWlldCIsIDB9LAoJCXsibm9hdXRvIiwgTU9VTlRfTk9BVVRPfSwKCQl7InN3YXAiLCBNT1VOVF9TV0FQfSwKCQlVU0VfREVTS1RPUCh7InVzZXIiLCAgTU9VTlRfVVNFUlN9LCkKCQlVU0VfREVTS1RPUCh7InVzZXJzIiwgTU9VTlRfVVNFUlN9LCkKCSkKCglVU0VfRkVBVFVSRV9NT1VOVF9GTEFHUygKCQkvLyB2ZnMgZmxhZ3MKCQl7Im5vc3VpZCIsIE1TX05PU1VJRH0sCgkJeyJzdWlkIiwgfk1TX05PU1VJRH0sCgkJeyJkZXYiLCB+TVNfTk9ERVZ9LAoJCXsibm9kZXYiLCBNU19OT0RFVn0sCgkJeyJleGVjIiwgfk1TX05PRVhFQ30sCgkJeyJub2V4ZWMiLCBNU19OT0VYRUN9LAoJCXsic3luYyIsIE1TX1NZTkNIUk9OT1VTfSwKCQl7ImFzeW5jIiwgfk1TX1NZTkNIUk9OT1VTfSwKCQl7ImF0aW1lIiwgfk1TX05PQVRJTUV9LAoJCXsibm9hdGltZSIsIE1TX05PQVRJTUV9LAoJCXsiZGlyYXRpbWUiLCB+TVNfTk9ESVJBVElNRX0sCgkJeyJub2RpcmF0aW1lIiwgTVNfTk9ESVJBVElNRX0sCgkJeyJsb3VkIiwgfk1TX1NJTEVOVH0sCgoJCS8vIGFjdGlvbiBmbGFncwoKCQl7ImJpbmQiLCBNU19CSU5EfSwKCQl7Im1vdmUiLCBNU19NT1ZFfSwKCQl7InNoYXJlZCIsIE1TX1NIQVJFRH0sCgkJeyJzbGF2ZSIsIE1TX1NMQVZFfSwKCQl7InByaXZhdGUiLCBNU19QUklWQVRFfSwKCQl7InVuYmluZGFibGUiLCBNU19VTkJJTkRBQkxFfSwKCQl7InJzaGFyZWQiLCBNU19TSEFSRUR8TVNfUkVDVVJTSVZFfSwKCQl7InJzbGF2ZSIsIE1TX1NMQVZFfE1TX1JFQ1VSU0lWRX0sCgkJeyJycHJpdmF0ZSIsIE1TX1NMQVZFfE1TX1JFQ1VSU0lWRX0sCgkJeyJydW5iaW5kYWJsZSIsIE1TX1VOQklOREFCTEV8TVNfUkVDVVJTSVZFfSwKCSkKCgkvLyBBbHdheXMgdW5kZXJzdG9vZC4KCgl7InJvIiwgTVNfUkRPTkxZfSwgICAgICAgIC8vIHZmcyBmbGFnCgl7InJ3Iiwgfk1TX1JET05MWX0sICAgICAgIC8vIHZmcyBmbGFnCgl7InJlbW91bnQiLCBNU19SRU1PVU5UfSwgIC8vIGFjdGlvbiBmbGFnCn07CgojZGVmaW5lIFZFQ1RPUl9TSVpFKHYpIChzaXplb2YodikgLyBzaXplb2YoKHYpWzBdKSkKCi8qIEFwcGVuZCBtb3VudCBvcHRpb25zIHRvIHN0cmluZyAqLwpzdGF0aWMgdm9pZCBhcHBlbmRfbW91bnRfb3B0aW9ucyhjaGFyICoqb2xkb3B0cywgY2hhciAqbmV3b3B0cykKewoJaWYgKCpvbGRvcHRzICYmICoqb2xkb3B0cykgewoJCS8qIGRvIG5vdCBpbnNlcnQgb3B0aW9ucyB3aGljaCBhcmUgYWxyZWFkeSB0aGVyZSAqLwoJCXdoaWxlIChuZXdvcHRzWzBdKSB7CgkJCWNoYXIgKnA7CgkJCWludCBsZW4gPSBzdHJsZW4obmV3b3B0cyk7CgkJCXAgPSBzdHJjaHIobmV3b3B0cywgJywnKTsKCQkJaWYgKHApIGxlbiA9IHAgLSBuZXdvcHRzOwoJCQlwID0gKm9sZG9wdHM7CgkJCXdoaWxlICgxKSB7CgkJCQlpZiAoIXN0cm5jbXAocCwgbmV3b3B0cywgbGVuKQoJCQkJICYmIChwW2xlbl09PScsJyB8fCBwW2xlbl09PTApKQoJCQkJCWdvdG8gc2tpcDsKCQkJCXAgPSBzdHJjaHIocCwnLCcpOwoJCQkJaWYoIXApIGJyZWFrOwoJCQkJcCsrOwoJCQl9CgkJCXAgPSB4YXNwcmludGYoIiVzLCUuKnMiLCAqb2xkb3B0cywgbGVuLCBuZXdvcHRzKTsKCQkJZnJlZSgqb2xkb3B0cyk7CgkJCSpvbGRvcHRzID0gcDsKc2tpcDoKCQkJbmV3b3B0cyArPSBsZW47CgkJCXdoaWxlIChuZXdvcHRzWzBdID09ICcsJykgbmV3b3B0cysrOwoJCX0KCX0gZWxzZSB7CgkJaWYgKEVOQUJMRV9GRUFUVVJFX0NMRUFOX1VQKSBmcmVlKCpvbGRvcHRzKTsKCQkqb2xkb3B0cyA9IHhzdHJkdXAobmV3b3B0cyk7Cgl9Cn0KCi8qIFVzZSB0aGUgbW91bnRfb3B0aW9ucyBsaXN0IHRvIHBhcnNlIG9wdGlvbnMgaW50byBmbGFncy4KICogQWxzbyByZXR1cm4gbGlzdCBvZiB1bnJlY29nbml6ZWQgb3B0aW9ucyBpZiB1bnJlY29nbml6ZWQhPU5VTEwgKi8Kc3RhdGljIGludCBwYXJzZV9tb3VudF9vcHRpb25zKGNoYXIgKm9wdGlvbnMsIGNoYXIgKip1bnJlY29nbml6ZWQpCnsKCWludCBmbGFncyA9IE1TX1NJTEVOVDsKCgkvLyBMb29wIHRocm91Z2ggb3B0aW9ucwoJZm9yICg7OykgewoJCWludCBpOwoJCWNoYXIgKmNvbW1hID0gc3RyY2hyKG9wdGlvbnMsICcsJyk7CgoJCWlmIChjb21tYSkgKmNvbW1hID0gMDsKCgkJLy8gRmluZCB0aGlzIG9wdGlvbiBpbiBtb3VudF9vcHRpb25zCgkJZm9yIChpID0gMDsgaSA8IFZFQ1RPUl9TSVpFKG1vdW50X29wdGlvbnMpOyBpKyspIHsKCQkJaWYgKCFzdHJjYXNlY21wKG1vdW50X29wdGlvbnNbaV0ubmFtZSwgb3B0aW9ucykpIHsKCQkJCWxvbmcgZmwgPSBtb3VudF9vcHRpb25zW2ldLmZsYWdzOwoJCQkJaWYgKGZsIDwgMCkgZmxhZ3MgJj0gZmw7CgkJCQllbHNlIGZsYWdzIHw9IGZsOwoJCQkJYnJlYWs7CgkJCX0KCQl9CgkJLy8gSWYgdW5yZWNvZ25pemVkIG5vdCBOVUxMLCBhcHBlbmQgdW5yZWNvZ25pemVkIG1vdW50IG9wdGlvbnMgKi8KCQlpZiAodW5yZWNvZ25pemVkICYmIGkgPT0gVkVDVE9SX1NJWkUobW91bnRfb3B0aW9ucykpIHsKCQkJLy8gQWRkIGl0IHRvIHN0cmZsYWdzLCB0byBwYXNzIG9uIHRvIGtlcm5lbAoJCQlpID0gKnVucmVjb2duaXplZCA/IHN0cmxlbigqdW5yZWNvZ25pemVkKSA6IDA7CgkJCSp1bnJlY29nbml6ZWQgPSB4cmVhbGxvYygqdW5yZWNvZ25pemVkLCBpK3N0cmxlbihvcHRpb25zKSsyKTsKCgkJCS8vIENvbW1hIHNlcGFyYXRlZCBpZiBpdCdzIG5vdCB0aGUgZmlyc3Qgb25lCgkJCWlmIChpKSAoKnVucmVjb2duaXplZClbaSsrXSA9ICcsJzsKCQkJc3RyY3B5KCgqdW5yZWNvZ25pemVkKStpLCBvcHRpb25zKTsKCQl9CgoJCS8vIEFkdmFuY2UgdG8gbmV4dCBvcHRpb24sIG9yIGZpbmlzaAoJCWlmIChjb21tYSkgewoJCQkqY29tbWEgPSAnLCc7CgkJCW9wdGlvbnMgPSArK2NvbW1hOwoJCX0gZWxzZSBicmVhazsKCX0KCglyZXR1cm4gZmxhZ3M7Cn0KCi8vIFJldHVybiBhIGxpc3Qgb2YgYWxsIGJsb2NrIGRldmljZSBiYWNrZWQgZmlsZXN5c3RlbXMKCnN0YXRpYyBsbGlzdF90ICpnZXRfYmxvY2tfYmFja2VkX2ZpbGVzeXN0ZW1zKHZvaWQpCnsKCXN0YXRpYyBjb25zdCBjaGFyICpjb25zdCBmaWxlc3lzdGVtc1tdID0gewoJCSIvZXRjL2ZpbGVzeXN0ZW1zIiwKCQkiL3Byb2MvZmlsZXN5c3RlbXMiLAoJCTAKCX07CgljaGFyICpmcywgKmJ1ZjsKCWxsaXN0X3QgKmxpc3QgPSAwOwoJaW50IGk7CglGSUxFICpmOwoKCWZvciAoaSA9IDA7IGZpbGVzeXN0ZW1zW2ldOyBpKyspIHsKCQlmID0gZm9wZW4oZmlsZXN5c3RlbXNbaV0sICJyIik7CgkJaWYgKCFmKSBjb250aW51ZTsKCgkJd2hpbGUgKChidWYgPSB4bWFsbG9jX2dldGxpbmUoZikpICE9IDApIHsKCQkJaWYgKCFzdHJuY21wKGJ1ZiwgIm5vZGV2IiwgNSkgJiYgaXNzcGFjZShidWZbNV0pKQoJCQkJY29udGludWU7CgkJCWZzID0gc2tpcF93aGl0ZXNwYWNlKGJ1Zik7CgkJCWlmICgqZnM9PScjJyB8fCAqZnM9PScqJyB8fCAhKmZzKSBjb250aW51ZTsKCgkJCWxsaXN0X2FkZF90b19lbmQoJmxpc3QsIHhzdHJkdXAoZnMpKTsKCQkJZnJlZShidWYpOwoJCX0KCQlpZiAoRU5BQkxFX0ZFQVRVUkVfQ0xFQU5fVVApIGZjbG9zZShmKTsKCX0KCglyZXR1cm4gbGlzdDsKfQoKbGxpc3RfdCAqZnNsaXN0ID0gMDsKCiNpZiBFTkFCTEVfRkVBVFVSRV9DTEVBTl9VUApzdGF0aWMgdm9pZCBkZWxldGVfYmxvY2tfYmFja2VkX2ZpbGVzeXN0ZW1zKHZvaWQpCnsKCWxsaXN0X2ZyZWUoZnNsaXN0LCBmcmVlKTsKfQojZWxzZQp2b2lkIGRlbGV0ZV9ibG9ja19iYWNrZWRfZmlsZXN5c3RlbXModm9pZCk7CiNlbmRpZgoKI2lmIEVOQUJMRV9GRUFUVVJFX01UQUJfU1VQUE9SVApzdGF0aWMgaW50IHVzZU10YWIgPSAxOwpzdGF0aWMgaW50IGZha2VJdDsKI2Vsc2UKI2RlZmluZSB1c2VNdGFiIDAKI2RlZmluZSBmYWtlSXQgMAojZW5kaWYKCi8vIFBlcmZvcm0gYWN0dWFsIG1vdW50IG9mIHNwZWNpZmljIGZpbGVzeXN0ZW0gYXQgc3BlY2lmaWMgbG9jYXRpb24uCi8vIE5COiBtcC0+eHh4IGZpZWxkcyBtYXkgYmUgdHJhc2hlZCBvbiBleGl0CnN0YXRpYyBpbnQgbW91bnRfaXRfbm93KHN0cnVjdCBtbnRlbnQgKm1wLCBpbnQgdmZzZmxhZ3MsIGNoYXIgKmZpbHRlcm9wdHMpCnsKCWludCByYyA9IDA7CgoJaWYgKGZha2VJdCkgZ290byBtdGFiOwoKCS8vIE1vdW50LCB3aXRoIGZhbGxiYWNrIHRvIHJlYWQtb25seSBpZiBuZWNlc3NhcnkuCgoJZm9yICg7OykgewoJCXJjID0gbW91bnQobXAtPm1udF9mc25hbWUsIG1wLT5tbnRfZGlyLCBtcC0+bW50X3R5cGUsCgkJCQl2ZnNmbGFncywgZmlsdGVyb3B0cyk7CgkJaWYgKCFyYyB8fCAodmZzZmxhZ3MmTVNfUkRPTkxZKSB8fCAoZXJybm8hPUVBQ0NFUyAmJiBlcnJubyE9RVJPRlMpKQoJCQlicmVhazsKCQliYl9lcnJvcl9tc2coIiVzIGlzIHdyaXRlLXByb3RlY3RlZCwgbW91bnRpbmcgcmVhZC1vbmx5IiwKCQkJCW1wLT5tbnRfZnNuYW1lKTsKCQl2ZnNmbGFncyB8PSBNU19SRE9OTFk7Cgl9CgoJLy8gQWJvcnQgZW50aXJlbHkgaWYgcGVybWlzc2lvbiBkZW5pZWQuCgoJaWYgKHJjICYmIGVycm5vID09IEVQRVJNKQoJCWJiX2Vycm9yX21zZ19hbmRfZGllKGJiX21zZ19wZXJtX2RlbmllZF9hcmVfeW91X3Jvb3QpOwoKCS8qIElmIHRoZSBtb3VudCB3YXMgc3VjY2Vzc2Z1bCwgYW5kIHdlJ3JlIG1haW50YWluaW5nIGFuIG9sZC1zdHlsZQoJICogbXRhYiBmaWxlIGJ5IGhhbmQsIGFkZCB0aGUgbmV3IGVudHJ5IHRvIGl0IG5vdy4gKi8KbXRhYjoKCWlmIChFTkFCTEVfRkVBVFVSRV9NVEFCX1NVUFBPUlQgJiYgdXNlTXRhYiAmJiAhcmMgJiYgISh2ZnNmbGFncyAmIE1TX1JFTU9VTlQpKSB7CgkJY2hhciAqZnNuYW1lOwoJCUZJTEUgKm1vdW50VGFibGUgPSBzZXRtbnRlbnQoYmJfcGF0aF9tdGFiX2ZpbGUsICJhKyIpOwoJCWludCBpOwoKCQlpZiAoIW1vdW50VGFibGUpCgkJCWJiX2Vycm9yX21zZygibm8gJXMiLGJiX3BhdGhfbXRhYl9maWxlKTsKCgkJLy8gQWRkIHZmcyBzdHJpbmcgZmxhZ3MKCgkJZm9yIChpPTA7IG1vdW50X29wdGlvbnNbaV0uZmxhZ3MgIT0gTVNfUkVNT1VOVDsgaSsrKQoJCQlpZiAobW91bnRfb3B0aW9uc1tpXS5mbGFncyA+IDAgJiYgKG1vdW50X29wdGlvbnNbaV0uZmxhZ3MgJiB2ZnNmbGFncykpCgkJCQlhcHBlbmRfbW91bnRfb3B0aW9ucygmKG1wLT5tbnRfb3B0cyksIG1vdW50X29wdGlvbnNbaV0ubmFtZSk7CgoJCS8vIFJlbW92ZSB0cmFpbGluZyAvIChpZiBhbnkpIGZyb20gZGlyZWN0b3J5IHdlIG1vdW50ZWQgb24KCgkJaSA9IHN0cmxlbihtcC0+bW50X2RpcikgLSAxOwoJCWlmIChpID4gMCAmJiBtcC0+bW50X2RpcltpXSA9PSAnLycpIG1wLT5tbnRfZGlyW2ldID0gMDsKCgkJLy8gQ29udmVydCB0byBjYW5vbmljYWwgcGF0aG5hbWVzIGFzIG5lZWRlZAoKCQltcC0+bW50X2RpciA9IGJiX3NpbXBsaWZ5X3BhdGgobXAtPm1udF9kaXIpOwoJCWZzbmFtZSA9IDA7CgkJaWYgKCFtcC0+bW50X3R5cGUgfHwgISptcC0+bW50X3R5cGUpIHsgLyogYmluZCBtb3VudCAqLwoJCQltcC0+bW50X2ZzbmFtZSA9IGZzbmFtZSA9IGJiX3NpbXBsaWZ5X3BhdGgobXAtPm1udF9mc25hbWUpOwoJCQltcC0+bW50X3R5cGUgPSAiYmluZCI7CgkJfQoJCW1wLT5tbnRfZnJlcSA9IG1wLT5tbnRfcGFzc25vID0gMDsKCgkJLy8gV3JpdGUgYW5kIGNsb3NlLgoKCQlhZGRtbnRlbnQobW91bnRUYWJsZSwgbXApOwoJCWVuZG1udGVudChtb3VudFRhYmxlKTsKCQlpZiAoRU5BQkxFX0ZFQVRVUkVfQ0xFQU5fVVApIHsKCQkJZnJlZShtcC0+bW50X2Rpcik7CgkJCWZyZWUoZnNuYW1lKTsKCQl9Cgl9CgoJcmV0dXJuIHJjOwp9CgojaWYgRU5BQkxFX0ZFQVRVUkVfTU9VTlRfTkZTCgovKgogKiBMaW51eCBORlMgbW91bnQKICogQ29weXJpZ2h0IChDKSAxOTkzIFJpY2sgU2xhZGtleSA8anJzQHdvcmxkLnN0ZC5jb20+CiAqCiAqIExpY2Vuc2VkIHVuZGVyIEdQTHYyLCBzZWUgZmlsZSBMSUNFTlNFIGluIHRoaXMgdGFyYmFsbCBmb3IgZGV0YWlscy4KICoKICogV2VkIEZlYiAgOCAxMjo1MTo0OCAxOTk1LCBiaXJvQHlnZ2RyYXNpbC5jb20gKFJvc3MgQmlybyk6IGFsbG93IGFsbCBwb3J0CiAqIG51bWJlcnMgdG8gYmUgc3BlY2lmaWVkIG9uIHRoZSBjb21tYW5kIGxpbmUuCiAqCiAqIEZyaSwgOCBNYXIgMTk5NiAxODowMTozOSwgU3dlbiBUaHVlbW1sZXIgPHN3ZW5AdW5pLXBhZGVyYm9ybi5kZT46CiAqIE9taXQgdGhlIGNhbGwgdG8gY29ubmVjdCgpIGZvciBMaW51eCB2ZXJzaW9uIDEuMy4xMSBvciBsYXRlci4KICoKICogV2VkIE9jdCAgMSAyMzo1NToyOCAxOTk3OiBEaWNrIFN0cmVlZmxhbmQgPGRpY2tfc3RyZWVmbGFuZEB0YXNraW5nLmNvbT4KICogSW1wbGVtZW50ZWQgdGhlICJiZyIsICJmZyIgYW5kICJyZXRyeSIgbW91bnQgb3B0aW9ucyBmb3IgTkZTLgogKgogKiAxOTk5LTAyLTIyIEFya2FkaXVzeiBNabZraWV3aWN6IDxtaXNpZWtAbWlzaWVrLmV1Lm9yZz4KICogLSBhZGRlZCBOYXRpdmUgTGFuZ3VhZ2UgU3VwcG9ydAogKgogKiBNb2RpZmllZCBieSBPbGFmIEtpcmNoIGFuZCBUcm9uZCBNeWtsZWJ1c3QgZm9yIG5ldyBORlMgY29kZSwKICogcGx1cyBORlN2MyBzdHVmZi4KICovCgovKiBUaGlzIGlzIGp1c3QgYSB3YXJuaW5nIG9mIGEgY29tbW9uIG1pc3Rha2UuICBQb3NzaWJseSB0aGlzIHNob3VsZCBiZSBhCiAqIHVjbGliYyBmYXEgZW50cnkgcmF0aGVyIHRoYW4gaW4gYnVzeWJveC4uLiAqLwojaWYgZGVmaW5lZChfX1VDTElCQ19fKSAmJiAhIGRlZmluZWQoX19VQ0xJQkNfSEFTX1JQQ19fKQojZXJyb3IgIllvdSBuZWVkIHRvIGJ1aWxkIHVDbGliYyB3aXRoIFVDTElCQ19IQVNfUlBDIGZvciBORlMgc3VwcG9ydC4iCiNlbmRpZgoKI2RlZmluZSBNT1VOVFBPUlQgNjM1CiNkZWZpbmUgTU5UUEFUSExFTiAxMDI0CiNkZWZpbmUgTU5UTkFNTEVOIDI1NQojZGVmaW5lIEZIU0laRSAzMgojZGVmaW5lIEZIU0laRTMgNjQKCnR5cGVkZWYgY2hhciBmaGFuZGxlW0ZIU0laRV07Cgp0eXBlZGVmIHN0cnVjdCB7Cgl1bnNpZ25lZCBpbnQgZmhhbmRsZTNfbGVuOwoJY2hhciAqZmhhbmRsZTNfdmFsOwp9IGZoYW5kbGUzOwoKZW51bSBtb3VudHN0YXQzIHsKCU1OVF9PSyA9IDAsCglNTlQzRVJSX1BFUk0gPSAxLAoJTU5UM0VSUl9OT0VOVCA9IDIsCglNTlQzRVJSX0lPID0gNSwKCU1OVDNFUlJfQUNDRVMgPSAxMywKCU1OVDNFUlJfTk9URElSID0gMjAsCglNTlQzRVJSX0lOVkFMID0gMjIsCglNTlQzRVJSX05BTUVUT09MT05HID0gNjMsCglNTlQzRVJSX05PVFNVUFAgPSAxMDAwNCwKCU1OVDNFUlJfU0VSVkVSRkFVTFQgPSAxMDAwNiwKfTsKdHlwZWRlZiBlbnVtIG1vdW50c3RhdDMgbW91bnRzdGF0MzsKCnN0cnVjdCBmaHN0YXR1cyB7Cgl1bnNpZ25lZCBpbnQgZmhzX3N0YXR1czsKCXVuaW9uIHsKCQlmaGFuZGxlIGZoc19maGFuZGxlOwoJfSBmaHN0YXR1c191Owp9Owp0eXBlZGVmIHN0cnVjdCBmaHN0YXR1cyBmaHN0YXR1czsKCnN0cnVjdCBtb3VudHJlczNfb2sgewoJZmhhbmRsZTMgZmhhbmRsZTsKCXN0cnVjdCB7CgkJdW5zaWduZWQgaW50IGF1dGhfZmxhdm91cnNfbGVuOwoJCWNoYXIgKmF1dGhfZmxhdm91cnNfdmFsOwoJfSBhdXRoX2ZsYXZvdXJzOwp9Owp0eXBlZGVmIHN0cnVjdCBtb3VudHJlczNfb2sgbW91bnRyZXMzX29rOwoKc3RydWN0IG1vdW50cmVzMyB7Cgltb3VudHN0YXQzIGZoc19zdGF0dXM7Cgl1bmlvbiB7CgkJbW91bnRyZXMzX29rIG1vdW50aW5mbzsKCX0gbW91bnRyZXMzX3U7Cn07CnR5cGVkZWYgc3RydWN0IG1vdW50cmVzMyBtb3VudHJlczM7Cgp0eXBlZGVmIGNoYXIgKmRpcnBhdGg7Cgp0eXBlZGVmIGNoYXIgKm5hbWU7Cgp0eXBlZGVmIHN0cnVjdCBtb3VudGJvZHkgKm1vdW50bGlzdDsKCnN0cnVjdCBtb3VudGJvZHkgewoJbmFtZSBtbF9ob3N0bmFtZTsKCWRpcnBhdGggbWxfZGlyZWN0b3J5OwoJbW91bnRsaXN0IG1sX25leHQ7Cn07CnR5cGVkZWYgc3RydWN0IG1vdW50Ym9keSBtb3VudGJvZHk7Cgp0eXBlZGVmIHN0cnVjdCBncm91cG5vZGUgKmdyb3VwczsKCnN0cnVjdCBncm91cG5vZGUgewoJbmFtZSBncl9uYW1lOwoJZ3JvdXBzIGdyX25leHQ7Cn07CnR5cGVkZWYgc3RydWN0IGdyb3Vwbm9kZSBncm91cG5vZGU7Cgp0eXBlZGVmIHN0cnVjdCBleHBvcnRub2RlICpleHBvcnRzOwoKc3RydWN0IGV4cG9ydG5vZGUgewoJZGlycGF0aCBleF9kaXI7Cglncm91cHMgZXhfZ3JvdXBzOwoJZXhwb3J0cyBleF9uZXh0Owp9Owp0eXBlZGVmIHN0cnVjdCBleHBvcnRub2RlIGV4cG9ydG5vZGU7CgpzdHJ1Y3QgcHBhdGhjbmYgewoJaW50IHBjX2xpbmtfbWF4OwoJc2hvcnQgcGNfbWF4X2Nhbm9uOwoJc2hvcnQgcGNfbWF4X2lucHV0OwoJc2hvcnQgcGNfbmFtZV9tYXg7CglzaG9ydCBwY19wYXRoX21heDsKCXNob3J0IHBjX3BpcGVfYnVmOwoJdV9jaGFyIHBjX3ZkaXNhYmxlOwoJY2hhciBwY194eHg7CglzaG9ydCBwY19tYXNrWzJdOwp9Owp0eXBlZGVmIHN0cnVjdCBwcGF0aGNuZiBwcGF0aGNuZjsKCiNkZWZpbmUgTU9VTlRQUk9HIDEwMDAwNQojZGVmaW5lIE1PVU5UVkVSUyAxCgojZGVmaW5lIE1PVU5UUFJPQ19OVUxMIDAKI2RlZmluZSBNT1VOVFBST0NfTU5UIDEKI2RlZmluZSBNT1VOVFBST0NfRFVNUCAyCiNkZWZpbmUgTU9VTlRQUk9DX1VNTlQgMwojZGVmaW5lIE1PVU5UUFJPQ19VTU5UQUxMIDQKI2RlZmluZSBNT1VOVFBST0NfRVhQT1JUIDUKI2RlZmluZSBNT1VOVFBST0NfRVhQT1JUQUxMIDYKCiNkZWZpbmUgTU9VTlRWRVJTX1BPU0lYIDIKCiNkZWZpbmUgTU9VTlRQUk9DX1BBVEhDT05GIDcKCiNkZWZpbmUgTU9VTlRfVjMgMwoKI2RlZmluZSBNT1VOVFBST0MzX05VTEwgMAojZGVmaW5lIE1PVU5UUFJPQzNfTU5UIDEKI2RlZmluZSBNT1VOVFBST0MzX0RVTVAgMgojZGVmaW5lIE1PVU5UUFJPQzNfVU1OVCAzCiNkZWZpbmUgTU9VTlRQUk9DM19VTU5UQUxMIDQKI2RlZmluZSBNT1VOVFBST0MzX0VYUE9SVCA1CgplbnVtIHsKI2lmbmRlZiBORlNfRkhTSVpFCglORlNfRkhTSVpFID0gMzIsCiNlbmRpZgojaWZuZGVmIE5GU19QT1JUCglORlNfUE9SVCA9IDIwNDkKI2VuZGlmCn07CgovKgogKiBXZSB3YW50IHRvIGJlIGFibGUgdG8gY29tcGlsZSBtb3VudCBvbiBvbGQga2VybmVscyBpbiBzdWNoIGEgd2F5CiAqIHRoYXQgdGhlIGJpbmFyeSB3aWxsIHdvcmsgd2VsbCBvbiBtb3JlIHJlY2VudCBrZXJuZWxzLgogKiBUaHVzLCBpZiBuZWNlc3Nhcnkgd2UgdGVhY2ggbmZzbW91bnQuYyB0aGUgc3RydWN0dXJlIG9mIG5ldyBmaWVsZHMKICogdGhhdCB3aWxsIGNvbWUgbGF0ZXIuCiAqCiAqIE1vcmVvdmVyLCB0aGUgbmV3IGtlcm5lbCBpbmNsdWRlcyBjb25mbGljdCB3aXRoIGdsaWJjIGluY2x1ZGVzCiAqIHNvIGl0IGlzIGVhc2llc3QgdG8gaWdub3JlIHRoZSBrZXJuZWwgYWx0b2dldGhlciAoYXQgY29tcGlsZSB0aW1lKS4KICovCgpzdHJ1Y3QgbmZzMl9maCB7CgljaGFyICAgICAgICAgICAgICAgICAgICBkYXRhWzMyXTsKfTsKc3RydWN0IG5mczNfZmggewoJdW5zaWduZWQgc2hvcnQgICAgICAgICAgc2l6ZTsKCXVuc2lnbmVkIGNoYXIgICAgICAgICAgIGRhdGFbNjRdOwp9OwoKc3RydWN0IG5mc19tb3VudF9kYXRhIHsKCWludAkJdmVyc2lvbjsJCS8qIDEgKi8KCWludAkJZmQ7CQkJLyogMSAqLwoJc3RydWN0IG5mczJfZmgJb2xkX3Jvb3Q7CQkvKiAxICovCglpbnQJCWZsYWdzOwkJCS8qIDEgKi8KCWludAkJcnNpemU7CQkJLyogMSAqLwoJaW50CQl3c2l6ZTsJCQkvKiAxICovCglpbnQJCXRpbWVvOwkJCS8qIDEgKi8KCWludAkJcmV0cmFuczsJCS8qIDEgKi8KCWludAkJYWNyZWdtaW47CQkvKiAxICovCglpbnQJCWFjcmVnbWF4OwkJLyogMSAqLwoJaW50CQlhY2Rpcm1pbjsJCS8qIDEgKi8KCWludAkJYWNkaXJtYXg7CQkvKiAxICovCglzdHJ1Y3Qgc29ja2FkZHJfaW4gYWRkcjsJCS8qIDEgKi8KCWNoYXIJCWhvc3RuYW1lWzI1Nl07CQkvKiAxICovCglpbnQJCW5hbWxlbjsJCQkvKiAyICovCgl1bnNpZ25lZCBpbnQJYnNpemU7CQkJLyogMyAqLwoJc3RydWN0IG5mczNfZmgJcm9vdDsJCQkvKiA0ICovCn07CgovKiBiaXRzIGluIHRoZSBmbGFncyBmaWVsZCAqLwplbnVtIHsKCU5GU19NT1VOVF9TT0ZUID0gMHgwMDAxLAkvKiAxICovCglORlNfTU9VTlRfSU5UUiA9IDB4MDAwMiwJLyogMSAqLwoJTkZTX01PVU5UX1NFQ1VSRSA9IDB4MDAwNCwJLyogMSAqLwoJTkZTX01PVU5UX1BPU0lYID0gMHgwMDA4LAkvKiAxICovCglORlNfTU9VTlRfTk9DVE8gPSAweDAwMTAsCS8qIDEgKi8KCU5GU19NT1VOVF9OT0FDID0gMHgwMDIwLAkvKiAxICovCglORlNfTU9VTlRfVENQID0gMHgwMDQwLAkJLyogMiAqLwoJTkZTX01PVU5UX1ZFUjMgPSAweDAwODAsCS8qIDMgKi8KCU5GU19NT1VOVF9LRVJCRVJPUyA9IDB4MDEwMCwJLyogMyAqLwoJTkZTX01PVU5UX05PTkxNID0gMHgwMjAwCS8qIDMgKi8KfTsKCgovKgogKiBXZSBuZWVkIHRvIHRyYW5zbGF0ZSBiZXR3ZWVuIG5mcyBzdGF0dXMgcmV0dXJuIHZhbHVlcyBhbmQKICogdGhlIGxvY2FsIGVycm5vIHZhbHVlcyB3aGljaCBtYXkgbm90IGJlIHRoZSBzYW1lLgogKgogKiBBbmRyZWFzIFNjaHdhYiA8c2Nod2FiQExTNS5pbmZvcm1hdGlrLnVuaS1kb3J0bXVuZC5kZT46IGNoYW5nZSBlcnJubzoKICogImFmdGVyICNpbmNsdWRlIDxlcnJuby5oPiB0aGUgc3ltYm9sIGVycm5vIGlzIHJlc2VydmVkIGZvciBhbnkgdXNlLAogKiAgaXQgY2Fubm90IGV2ZW4gYmUgdXNlZCBhcyBhIHN0cnVjdCB0YWcgb3IgZmllbGQgbmFtZSIuCiAqLwoKI2lmbmRlZiBFRFFVT1QKI2RlZmluZSBFRFFVT1QJRU5PU1BDCiNlbmRpZgoKLy8gQ29udmVydCBlYWNoIE5GU0VSUl9CTEFIIGludG8gRUJMQUgKCnN0YXRpYyBjb25zdCBzdHJ1Y3QgewoJaW50IHN0YXQ7CglpbnQgZXJybnVtOwp9IG5mc19lcnJ0YmxbXSA9IHsKCXswLDB9LCB7MSxFUEVSTX0sIHsyLEVOT0VOVH0sIHs1LEVJT30sIHs2LEVOWElPfSwgezEzLEVBQ0NFU30sIHsxNyxFRVhJU1R9LAoJezE5LEVOT0RFVn0sIHsyMCxFTk9URElSfSwgezIxLEVJU0RJUn0sIHsyMixFSU5WQUx9LCB7MjcsRUZCSUd9LAoJezI4LEVOT1NQQ30sIHszMCxFUk9GU30sIHs2MyxFTkFNRVRPT0xPTkd9LCB7NjYsRU5PVEVNUFRZfSwgezY5LEVEUVVPVH0sCgl7NzAsRVNUQUxFfSwgezcxLEVSRU1PVEV9LCB7LTEsRUlPfQp9OwoKc3RhdGljIGNoYXIgKm5mc19zdHJlcnJvcihpbnQgc3RhdHVzKQp7CglpbnQgaTsKCXN0YXRpYyBjaGFyIGJ1ZltzaXplb2YoInVua25vd24gbmZzIHN0YXR1cyByZXR1cm4gdmFsdWU6ICIpICsgc2l6ZW9mKGludCkqM107CgoJZm9yIChpID0gMDsgbmZzX2VycnRibFtpXS5zdGF0ICE9IC0xOyBpKyspIHsKCQlpZiAobmZzX2VycnRibFtpXS5zdGF0ID09IHN0YXR1cykKCQkJcmV0dXJuIHN0cmVycm9yKG5mc19lcnJ0YmxbaV0uZXJybnVtKTsKCX0KCXNwcmludGYoYnVmLCAidW5rbm93biBuZnMgc3RhdHVzIHJldHVybiB2YWx1ZTogJWQiLCBzdGF0dXMpOwoJcmV0dXJuIGJ1ZjsKfQoKc3RhdGljIGJvb2xfdCB4ZHJfZmhhbmRsZShYRFIgKnhkcnMsIGZoYW5kbGUgb2JqcCkKewoJaWYgKCF4ZHJfb3BhcXVlKHhkcnMsIG9ianAsIEZIU0laRSkpCgkJIHJldHVybiBGQUxTRTsKCXJldHVybiBUUlVFOwp9CgpzdGF0aWMgYm9vbF90IHhkcl9maHN0YXR1cyhYRFIgKnhkcnMsIGZoc3RhdHVzICpvYmpwKQp7CglpZiAoIXhkcl91X2ludCh4ZHJzLCAmb2JqcC0+ZmhzX3N0YXR1cykpCgkJIHJldHVybiBGQUxTRTsKCXN3aXRjaCAob2JqcC0+ZmhzX3N0YXR1cykgewoJY2FzZSAwOgoJCWlmICgheGRyX2ZoYW5kbGUoeGRycywgb2JqcC0+ZmhzdGF0dXNfdS5maHNfZmhhbmRsZSkpCgkJCSByZXR1cm4gRkFMU0U7CgkJYnJlYWs7CglkZWZhdWx0OgoJCWJyZWFrOwoJfQoJcmV0dXJuIFRSVUU7Cn0KCnN0YXRpYyBib29sX3QgeGRyX2RpcnBhdGgoWERSICp4ZHJzLCBkaXJwYXRoICpvYmpwKQp7CglpZiAoIXhkcl9zdHJpbmcoeGRycywgb2JqcCwgTU5UUEFUSExFTikpCgkJIHJldHVybiBGQUxTRTsKCXJldHVybiBUUlVFOwp9CgpzdGF0aWMgYm9vbF90IHhkcl9maGFuZGxlMyhYRFIgKnhkcnMsIGZoYW5kbGUzICpvYmpwKQp7CglpZiAoIXhkcl9ieXRlcyh4ZHJzLCAoY2hhciAqKikmb2JqcC0+ZmhhbmRsZTNfdmFsLCAodW5zaWduZWQgaW50ICopICZvYmpwLT5maGFuZGxlM19sZW4sIEZIU0laRTMpKQoJCSByZXR1cm4gRkFMU0U7CglyZXR1cm4gVFJVRTsKfQoKc3RhdGljIGJvb2xfdCB4ZHJfbW91bnRyZXMzX29rKFhEUiAqeGRycywgbW91bnRyZXMzX29rICpvYmpwKQp7CglpZiAoIXhkcl9maGFuZGxlMyh4ZHJzLCAmb2JqcC0+ZmhhbmRsZSkpCgkJcmV0dXJuIEZBTFNFOwoJaWYgKCF4ZHJfYXJyYXkoeGRycywgJihvYmpwLT5hdXRoX2ZsYXZvdXJzLmF1dGhfZmxhdm91cnNfdmFsKSwgJihvYmpwLT5hdXRoX2ZsYXZvdXJzLmF1dGhfZmxhdm91cnNfbGVuKSwgfjAsCgkJCQlzaXplb2YgKGludCksICh4ZHJwcm9jX3QpIHhkcl9pbnQpKQoJCXJldHVybiBGQUxTRTsKCXJldHVybiBUUlVFOwp9CgpzdGF0aWMgYm9vbF90IHhkcl9tb3VudHN0YXQzKFhEUiAqeGRycywgbW91bnRzdGF0MyAqb2JqcCkKewoJaWYgKCF4ZHJfZW51bSh4ZHJzLCAoZW51bV90ICopIG9ianApKQoJCSByZXR1cm4gRkFMU0U7CglyZXR1cm4gVFJVRTsKfQoKc3RhdGljIGJvb2xfdCB4ZHJfbW91bnRyZXMzKFhEUiAqeGRycywgbW91bnRyZXMzICpvYmpwKQp7CglpZiAoIXhkcl9tb3VudHN0YXQzKHhkcnMsICZvYmpwLT5maHNfc3RhdHVzKSkKCQlyZXR1cm4gRkFMU0U7Cglzd2l0Y2ggKG9ianAtPmZoc19zdGF0dXMpIHsKCWNhc2UgTU5UX09LOgoJCWlmICgheGRyX21vdW50cmVzM19vayh4ZHJzLCAmb2JqcC0+bW91bnRyZXMzX3UubW91bnRpbmZvKSkKCQkJIHJldHVybiBGQUxTRTsKCQlicmVhazsKCWRlZmF1bHQ6CgkJYnJlYWs7Cgl9CglyZXR1cm4gVFJVRTsKfQoKI2RlZmluZSBNQVhfTkZTUFJPVCAoKG5mc19tb3VudF92ZXJzaW9uID49IDQpID8gMyA6IDIpCgovKgogKiBuZnNfbW91bnRfdmVyc2lvbiBhY2NvcmRpbmcgdG8gdGhlIHNvdXJjZXMgc2VlbiBhdCBjb21waWxlIHRpbWUuCiAqLwpzdGF0aWMgaW50IG5mc19tb3VudF92ZXJzaW9uOwpzdGF0aWMgaW50IGtlcm5lbF92ZXJzaW9uOwoKLyoKICogVW5mb3J0dW5hdGVseSwgdGhlIGtlcm5lbCBwcmludHMgYW5ub3lpbmcgY29uc29sZSBtZXNzYWdlcwogKiBpbiBjYXNlIG9mIGFuIHVuZXhwZWN0ZWQgbmZzIG1vdW50IHZlcnNpb24gKGluc3RlYWQgb2YKICoganVzdCByZXR1cm5pbmcgc29tZSBlcnJvcikuICBUaGVyZWZvcmUgd2UnbGwgaGF2ZSB0byB0cnkKICogYW5kIGZpZ3VyZSBvdXQgd2hhdCB2ZXJzaW9uIHRoZSBrZXJuZWwgZXhwZWN0cy4KICoKICogVmFyaWFibGVzOgogKglLRVJORUxfTkZTX01PVU5UX1ZFUlNJT046IGtlcm5lbCBzb3VyY2VzIGF0IGNvbXBpbGUgdGltZQogKglORlNfTU9VTlRfVkVSU0lPTjogdGhlc2UgbmZzbW91bnQgc291cmNlcyBhdCBjb21waWxlIHRpbWUKICoJbmZzX21vdW50X3ZlcnNpb246IHZlcnNpb24gdGhpcyBzb3VyY2UgYW5kIHJ1bm5pbmcga2VybmVsIGNhbiBoYW5kbGUKICovCnN0YXRpYyB2b2lkCmZpbmRfa2VybmVsX25mc19tb3VudF92ZXJzaW9uKHZvaWQpCnsKCWlmIChrZXJuZWxfdmVyc2lvbikKCQlyZXR1cm47CgoJbmZzX21vdW50X3ZlcnNpb24gPSA0OyAvKiBkZWZhdWx0ICovCgoJa2VybmVsX3ZlcnNpb24gPSBnZXRfbGludXhfdmVyc2lvbl9jb2RlKCk7CglpZiAoa2VybmVsX3ZlcnNpb24pIHsKCQlpZiAoa2VybmVsX3ZlcnNpb24gPCBLRVJORUxfVkVSU0lPTigyLDEsMzIpKQoJCQluZnNfbW91bnRfdmVyc2lvbiA9IDE7CgkJZWxzZSBpZiAoa2VybmVsX3ZlcnNpb24gPCBLRVJORUxfVkVSU0lPTigyLDIsMTgpIHx8CgkJCQkoa2VybmVsX3ZlcnNpb24gPj0gS0VSTkVMX1ZFUlNJT04oMiwzLDApICYmCgkJCQkga2VybmVsX3ZlcnNpb24gPCBLRVJORUxfVkVSU0lPTigyLDMsOTkpKSkKCQkJbmZzX21vdW50X3ZlcnNpb24gPSAzOwoJCS8qIGVsc2UgdjQgc2luY2UgMi4zLjk5cHJlNCAqLwoJfQp9CgpzdGF0aWMgc3RydWN0IHBtYXAgKgpnZXRfbW91bnRwb3J0KHN0cnVjdCBzb2NrYWRkcl9pbiAqc2VydmVyX2FkZHIsCglsb25nIHVuc2lnbmVkIHByb2csCglsb25nIHVuc2lnbmVkIHZlcnNpb24sCglsb25nIHVuc2lnbmVkIHByb3RvLAoJbG9uZyB1bnNpZ25lZCBwb3J0KQp7CglzdHJ1Y3QgcG1hcGxpc3QgKnBtYXA7CglzdGF0aWMgc3RydWN0IHBtYXAgcCA9IHswLCAwLCAwLCAwfTsKCglzZXJ2ZXJfYWRkci0+c2luX3BvcnQgPSBQTUFQUE9SVDsKCXBtYXAgPSBwbWFwX2dldG1hcHMoc2VydmVyX2FkZHIpOwoKCWlmICh2ZXJzaW9uID4gTUFYX05GU1BST1QpCgkJdmVyc2lvbiA9IE1BWF9ORlNQUk9UOwoJaWYgKCFwcm9nKQoJCXByb2cgPSBNT1VOVFBST0c7CglwLnBtX3Byb2cgPSBwcm9nOwoJcC5wbV92ZXJzID0gdmVyc2lvbjsKCXAucG1fcHJvdCA9IHByb3RvOwoJcC5wbV9wb3J0ID0gcG9ydDsKCgl3aGlsZSAocG1hcCkgewoJCWlmIChwbWFwLT5wbWxfbWFwLnBtX3Byb2cgIT0gcHJvZykKCQkJZ290byBuZXh0OwoJCWlmICghdmVyc2lvbiAmJiBwLnBtX3ZlcnMgPiBwbWFwLT5wbWxfbWFwLnBtX3ZlcnMpCgkJCWdvdG8gbmV4dDsKCQlpZiAodmVyc2lvbiA+IDIgJiYgcG1hcC0+cG1sX21hcC5wbV92ZXJzICE9IHZlcnNpb24pCgkJCWdvdG8gbmV4dDsKCQlpZiAodmVyc2lvbiAmJiB2ZXJzaW9uIDw9IDIgJiYgcG1hcC0+cG1sX21hcC5wbV92ZXJzID4gMikKCQkJZ290byBuZXh0OwoJCWlmIChwbWFwLT5wbWxfbWFwLnBtX3ZlcnMgPiBNQVhfTkZTUFJPVCB8fAoJCSAgICAocHJvdG8gJiYgcC5wbV9wcm90ICYmIHBtYXAtPnBtbF9tYXAucG1fcHJvdCAhPSBwcm90bykgfHwKCQkgICAgKHBvcnQgJiYgcG1hcC0+cG1sX21hcC5wbV9wb3J0ICE9IHBvcnQpKQoJCQlnb3RvIG5leHQ7CgkJbWVtY3B5KCZwLCAmcG1hcC0+cG1sX21hcCwgc2l6ZW9mKHApKTsKbmV4dDoKCQlwbWFwID0gcG1hcC0+cG1sX25leHQ7Cgl9CglpZiAoIXAucG1fdmVycykKCQlwLnBtX3ZlcnMgPSBNT1VOVFZFUlM7CglpZiAoIXAucG1fcG9ydCkKCQlwLnBtX3BvcnQgPSBNT1VOVFBPUlQ7CglpZiAoIXAucG1fcHJvdCkKCQlwLnBtX3Byb3QgPSBJUFBST1RPX1RDUDsKCXJldHVybiAmcDsKfQoKc3RhdGljIGludCBkYWVtb25pemUodm9pZCkKewoJaW50IGZkOwoJaW50IHBpZCA9IGZvcmsoKTsKCWlmIChwaWQgPCAwKSAvKiBlcnJvciAqLwoJCXJldHVybiAtZXJybm87CglpZiAocGlkID4gMCkgLyogcGFyZW50ICovCgkJcmV0dXJuIDA7CgkvKiBjaGlsZCAqLwoJZmQgPSB4b3BlbihiYl9kZXZfbnVsbCwgT19SRFdSKTsKCWR1cDIoZmQsIDApOwoJZHVwMihmZCwgMSk7CglkdXAyKGZkLCAyKTsKCWlmIChmZCA+IDIpIGNsb3NlKGZkKTsKCXNldHNpZCgpOwoJb3BlbmxvZyhhcHBsZXRfbmFtZSwgTE9HX1BJRCwgTE9HX0RBRU1PTik7Cglsb2dtb2RlID0gTE9HTU9ERV9TWVNMT0c7CglyZXR1cm4gMTsKfQoKLy8gVE9ETwpzdGF0aWMgaW5saW5lIGludCB3ZV9zYXdfdGhpc19ob3N0X2JlZm9yZShjb25zdCBjaGFyICpob3N0bmFtZSkKewoJcmV0dXJuIDA7Cn0KCi8qIFJQQyBzdHJlcnJvciBhbmFsb2dzIGFyZSB0ZXJtaW5hbGx5IGlkaW90aWM6CiAqICptYW5kYXRvcnkqIHByZWZpeCBhbmQgXG4gYXQgZW5kLgogKiBUaGlzIGhvcGVmdWxseSBoZWxwcy4gVXNhZ2U6CiAqIGVycm9yX21zZ19ycGMoY2xudF8qZXJyb3IqKCIgIikpICovCnN0YXRpYyB2b2lkIGVycm9yX21zZ19ycGMoY29uc3QgY2hhciAqbXNnKQp7CglpbnQgbGVuOwoJd2hpbGUgKG1zZ1swXSA9PSAnICcgfHwgbXNnWzBdID09ICc6JykgbXNnKys7CglsZW4gPSBzdHJsZW4obXNnKTsKCXdoaWxlIChsZW4gJiYgbXNnW2xlbi0xXSA9PSAnXG4nKSBsZW4tLTsKCWJiX2Vycm9yX21zZygiJS4qcyIsIGxlbiwgbXNnKTsKfQoKLy8gTkI6IG1wLT54eHggZmllbGRzIG1heSBiZSB0cmFzaGVkIG9uIGV4aXQKc3RhdGljIGludCBuZnNtb3VudChzdHJ1Y3QgbW50ZW50ICptcCwgaW50IHZmc2ZsYWdzLCBjaGFyICpmaWx0ZXJvcHRzKQp7CglDTElFTlQgKm1jbGllbnQ7CgljaGFyICpob3N0bmFtZTsKCWNoYXIgKnBhdGhuYW1lOwoJY2hhciAqbW91bnRob3N0OwoJc3RydWN0IG5mc19tb3VudF9kYXRhIGRhdGE7CgljaGFyICpvcHQ7CglzdHJ1Y3QgaG9zdGVudCAqaHA7CglzdHJ1Y3Qgc29ja2FkZHJfaW4gc2VydmVyX2FkZHI7CglzdHJ1Y3Qgc29ja2FkZHJfaW4gbW91bnRfc2VydmVyX2FkZHI7CglpbnQgbXNvY2ssIGZzb2NrOwoJdW5pb24gewoJCXN0cnVjdCBmaHN0YXR1cyBuZnN2MjsKCQlzdHJ1Y3QgbW91bnRyZXMzIG5mc3YzOwoJfSBzdGF0dXM7CglpbnQgZGFlbW9uaXplZDsKCWNoYXIgKnM7CglpbnQgcG9ydDsKCWludCBtb3VudHBvcnQ7CglpbnQgcHJvdG87CglpbnQgYmc7CglpbnQgc29mdDsKCWludCBpbnRyOwoJaW50IHBvc2l4OwoJaW50IG5vY3RvOwoJaW50IG5vYWM7CglpbnQgbm9sb2NrOwoJaW50IHJldHJ5OwoJaW50IHRjcDsKCWludCBtb3VudHByb2c7CglpbnQgbW91bnR2ZXJzOwoJaW50IG5mc3Byb2c7CglpbnQgbmZzdmVyczsKCWludCByZXR2YWw7CgoJZmluZF9rZXJuZWxfbmZzX21vdW50X3ZlcnNpb24oKTsKCglkYWVtb25pemVkID0gMDsKCW1vdW50aG9zdCA9IE5VTEw7CglyZXR2YWwgPSBFVElNRURPVVQ7Cgltc29jayA9IGZzb2NrID0gLTE7CgltY2xpZW50ID0gTlVMTDsKCgkvKiBOQjogaG9zdG5hbWUsIG1vdW50aG9zdCwgZmlsdGVyb3B0cyBtdXN0IGJlIGZyZWUoKWQgcHJpb3IgdG8gcmV0dXJuICovCgoJZmlsdGVyb3B0cyA9IHhzdHJkdXAoZmlsdGVyb3B0cyk7IC8qIGdvaW5nIHRvIHRyYXNoIGl0IGxhdGVyLi4uICovCgoJaG9zdG5hbWUgPSB4c3RyZHVwKG1wLT5tbnRfZnNuYW1lKTsKCS8qIG1vdW50X21haW4oKSBndWFyYW50ZWVzIHRoYXQgJzonIGlzIHRoZXJlICovCglzID0gc3RyY2hyKGhvc3RuYW1lLCAnOicpOwoJcGF0aG5hbWUgPSBzICsgMTsKCSpzID0gJ1wwJzsKCS8qIElnbm9yZSBhbGwgYnV0IGZpcnN0IGhvc3RuYW1lIGluIHJlcGxpY2F0ZWQgbW91bnRzCgkgICB1bnRpbCB0aGV5IGNhbiBiZSBmdWxseSBzdXBwb3J0ZWQuIChtYWNrQHNnaS5jb20pICovCglzID0gc3RyY2hyKGhvc3RuYW1lLCAnLCcpOwoJaWYgKHMpIHsKCQkqcyA9ICdcMCc7CgkJYmJfZXJyb3JfbXNnKCJ3YXJuaW5nOiBtdWx0aXBsZSBob3N0bmFtZXMgbm90IHN1cHBvcnRlZCIpOwoJfQoKCXNlcnZlcl9hZGRyLnNpbl9mYW1pbHkgPSBBRl9JTkVUOwoJaWYgKCFpbmV0X2F0b24oaG9zdG5hbWUsICZzZXJ2ZXJfYWRkci5zaW5fYWRkcikpIHsKCQlocCA9IGdldGhvc3RieW5hbWUoaG9zdG5hbWUpOwoJCWlmIChocCA9PSBOVUxMKSB7CgkJCWJiX2hlcnJvcl9tc2coIiVzIiwgaG9zdG5hbWUpOwoJCQlnb3RvIGZhaWw7CgkJfQoJCWlmIChocC0+aF9sZW5ndGggPiBzaXplb2Yoc3RydWN0IGluX2FkZHIpKSB7CgkJCWJiX2Vycm9yX21zZygiZ290IGJhZCBocC0+aF9sZW5ndGgiKTsKCQkJaHAtPmhfbGVuZ3RoID0gc2l6ZW9mKHN0cnVjdCBpbl9hZGRyKTsKCQl9CgkJbWVtY3B5KCZzZXJ2ZXJfYWRkci5zaW5fYWRkciwKCQkJCWhwLT5oX2FkZHIsIGhwLT5oX2xlbmd0aCk7Cgl9CgoJbWVtY3B5KCZtb3VudF9zZXJ2ZXJfYWRkciwgJnNlcnZlcl9hZGRyLCBzaXplb2YobW91bnRfc2VydmVyX2FkZHIpKTsKCgkvKiBhZGQgSVAgYWRkcmVzcyB0byBtdGFiIG9wdGlvbnMgZm9yIHVzZSB3aGVuIHVubW91bnRpbmcgKi8KCglpZiAoIW1wLT5tbnRfb3B0cykgeyAvKiBUT0RPOiBhY3R1YWxseSBtcC0+bW50X29wdHMgaXMgbmV2ZXIgTlVMTCAqLwoJCW1wLT5tbnRfb3B0cyA9IHhhc3ByaW50ZigiYWRkcj0lcyIsIGluZXRfbnRvYShzZXJ2ZXJfYWRkci5zaW5fYWRkcikpOwoJfSBlbHNlIHsKCQljaGFyICp0bXAgPSB4YXNwcmludGYoIiVzJXNhZGRyPSVzIiwgbXAtPm1udF9vcHRzLAoJCQkJCW1wLT5tbnRfb3B0c1swXSA/ICIsIiA6ICIiLAoJCQkJCWluZXRfbnRvYShzZXJ2ZXJfYWRkci5zaW5fYWRkcikpOwoJCWZyZWUobXAtPm1udF9vcHRzKTsKCQltcC0+bW50X29wdHMgPSB0bXA7Cgl9CgoJLyogU2V0IGRlZmF1bHQgb3B0aW9ucy4KCSAqIHJzaXplL3dzaXplIChhbmQgYnNpemUsIGZvciB2ZXIgPj0gMykgYXJlIGxlZnQgMCBpbiBvcmRlciB0bwoJICogbGV0IHRoZSBrZXJuZWwgZGVjaWRlLgoJICogdGltZW8gaXMgZmlsbGVkIGluIGFmdGVyIHdlIGtub3cgd2hldGhlciBpdCdsbCBiZSBUQ1Agb3IgVURQLiAqLwoJbWVtc2V0KCZkYXRhLCAwLCBzaXplb2YoZGF0YSkpOwoJZGF0YS5yZXRyYW5zCT0gMzsKCWRhdGEuYWNyZWdtaW4JPSAzOwoJZGF0YS5hY3JlZ21heAk9IDYwOwoJZGF0YS5hY2Rpcm1pbgk9IDMwOwoJZGF0YS5hY2Rpcm1heAk9IDYwOwoJZGF0YS5uYW1sZW4JPSBOQU1FX01BWDsKCgliZyA9IDA7Cglzb2Z0ID0gMDsKCWludHIgPSAwOwoJcG9zaXggPSAwOwoJbm9jdG8gPSAwOwoJbm9sb2NrID0gMDsKCW5vYWMgPSAwOwoJcmV0cnkgPSAxMDAwMDsJCS8qIDEwMDAwIG1pbnV0ZXMgfiAxIHdlZWsgKi8KCXRjcCA9IDA7CgoJbW91bnRwcm9nID0gTU9VTlRQUk9HOwoJbW91bnR2ZXJzID0gMDsKCXBvcnQgPSAwOwoJbW91bnRwb3J0ID0gMDsKCW5mc3Byb2cgPSAxMDAwMDM7CgluZnN2ZXJzID0gMDsKCgkvKiBwYXJzZSBvcHRpb25zICovCgoJZm9yIChvcHQgPSBzdHJ0b2soZmlsdGVyb3B0cywgIiwiKTsgb3B0OyBvcHQgPSBzdHJ0b2soTlVMTCwgIiwiKSkgewoJCWNoYXIgKm9wdGVxID0gc3RyY2hyKG9wdCwgJz0nKTsKCQlpZiAob3B0ZXEpIHsKCQkJY29uc3QgY2hhciAqY29uc3Qgb3B0aW9uc1tdID0gewoJCQkJLyogMCAqLyAicnNpemUiLAoJCQkJLyogMSAqLyAid3NpemUiLAoJCQkJLyogMiAqLyAidGltZW8iLAoJCQkJLyogMyAqLyAicmV0cmFucyIsCgkJCQkvKiA0ICovICJhY3JlZ21pbiIsCgkJCQkvKiA1ICovICJhY3JlZ21heCIsCgkJCQkvKiA2ICovICJhY2Rpcm1pbiIsCgkJCQkvKiA3ICovICJhY2Rpcm1heCIsCgkJCQkvKiA4ICovICJhY3RpbWVvIiwKCQkJCS8qIDkgKi8gInJldHJ5IiwKCQkJCS8qIDEwICovICJwb3J0IiwKCQkJCS8qIDExICovICJtb3VudHBvcnQiLAoJCQkJLyogMTIgKi8gIm1vdW50aG9zdCIsCgkJCQkvKiAxMyAqLyAibW91bnRwcm9nIiwKCQkJCS8qIDE0ICovICJtb3VudHZlcnMiLAoJCQkJLyogMTUgKi8gIm5mc3Byb2ciLAoJCQkJLyogMTYgKi8gIm5mc3ZlcnMiLAoJCQkJLyogMTcgKi8gInZlcnMiLAoJCQkJLyogMTggKi8gInByb3RvIiwKCQkJCS8qIDE5ICovICJuYW1sZW4iLAoJCQkJLyogMjAgKi8gImFkZHIiLAoJCQkJTlVMTAoJCQl9OwoJCQlpbnQgdmFsID0geGF0b2lfdShvcHRlcSArIDEpOwoJCQkqb3B0ZXEgPSAnXDAnOwoJCQlzd2l0Y2ggKGNvbXBhcmVfc3RyaW5nX2FycmF5KG9wdGlvbnMsIG9wdCkpIHsKCQkJY2FzZSAwOiAvLyAicnNpemUiCgkJCQlkYXRhLnJzaXplID0gdmFsOwoJCQkJYnJlYWs7CgkJCWNhc2UgMTogLy8gIndzaXplIgoJCQkJZGF0YS53c2l6ZSA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDI6IC8vICJ0aW1lbyIKCQkJCWRhdGEudGltZW8gPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSAzOiAvLyAicmV0cmFucyIKCQkJCWRhdGEucmV0cmFucyA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDQ6IC8vICJhY3JlZ21pbiIKCQkJCWRhdGEuYWNyZWdtaW4gPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSA1OiAvLyAiYWNyZWdtYXgiCgkJCQlkYXRhLmFjcmVnbWF4ID0gdmFsOwoJCQkJYnJlYWs7CgkJCWNhc2UgNjogLy8gImFjZGlybWluIgoJCQkJZGF0YS5hY2Rpcm1pbiA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDc6IC8vICJhY2Rpcm1heCIKCQkJCWRhdGEuYWNkaXJtYXggPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSA4OiAvLyAiYWN0aW1lbyIKCQkJCWRhdGEuYWNyZWdtaW4gPSB2YWw7CgkJCQlkYXRhLmFjcmVnbWF4ID0gdmFsOwoJCQkJZGF0YS5hY2Rpcm1pbiA9IHZhbDsKCQkJCWRhdGEuYWNkaXJtYXggPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSA5OiAvLyAicmV0cnkiCgkJCQlyZXRyeSA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDEwOiAvLyAicG9ydCIKCQkJCXBvcnQgPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSAxMTogLy8gIm1vdW50cG9ydCIKCQkJCW1vdW50cG9ydCA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDEyOiAvLyAibW91bnRob3N0IgoJCQkJbW91bnRob3N0ID0geHN0cm5kdXAob3B0ZXErMSwKCQkJCQkJICBzdHJjc3BuKG9wdGVxKzEsIiBcdFxuXHIsIikpOwoJCQkJYnJlYWs7CgkJCWNhc2UgMTM6IC8vICJtb3VudHByb2ciCgkJCQltb3VudHByb2cgPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSAxNDogLy8gIm1vdW50dmVycyIKCQkJCW1vdW50dmVycyA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDE1OiAvLyAibmZzcHJvZyIKCQkJCW5mc3Byb2cgPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSAxNjogLy8gIm5mc3ZlcnMiCgkJCWNhc2UgMTc6IC8vICJ2ZXJzIgoJCQkJbmZzdmVycyA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDE4OiAvLyAicHJvdG8iCgkJCQlpZiAoIXN0cm5jbXAob3B0ZXErMSwgInRjcCIsIDMpKQoJCQkJCXRjcCA9IDE7CgkJCQllbHNlIGlmICghc3RybmNtcChvcHRlcSsxLCAidWRwIiwgMykpCgkJCQkJdGNwID0gMDsKCQkJCWVsc2UKCQkJCQliYl9lcnJvcl9tc2coIndhcm5pbmc6IHVucmVjb2duaXplZCBwcm90bz0gb3B0aW9uIik7CgkJCQlicmVhazsKCQkJY2FzZSAxOTogLy8gIm5hbWxlbiIKCQkJCWlmIChuZnNfbW91bnRfdmVyc2lvbiA+PSAyKQoJCQkJCWRhdGEubmFtbGVuID0gdmFsOwoJCQkJZWxzZQoJCQkJCWJiX2Vycm9yX21zZygid2FybmluZzogb3B0aW9uIG5hbWxlbiBpcyBub3Qgc3VwcG9ydGVkXG4iKTsKCQkJCWJyZWFrOwoJCQljYXNlIDIwOiAvLyAiYWRkciIgLSBpZ25vcmUKCQkJCWJyZWFrOwoJCQlkZWZhdWx0OgoJCQkJYmJfZXJyb3JfbXNnKCJ1bmtub3duIG5mcyBtb3VudCBwYXJhbWV0ZXI6ICVzPSVkIiwgb3B0LCB2YWwpOwoJCQkJZ290byBmYWlsOwoJCQl9CgkJfQoJCWVsc2UgewoJCQljb25zdCBjaGFyICpjb25zdCBvcHRpb25zW10gPSB7CgkJCQkiYmciLAoJCQkJImZnIiwKCQkJCSJzb2Z0IiwKCQkJCSJoYXJkIiwKCQkJCSJpbnRyIiwKCQkJCSJwb3NpeCIsCgkJCQkiY3RvIiwKCQkJCSJhYyIsCgkJCQkidGNwIiwKCQkJCSJ1ZHAiLAoJCQkJImxvY2siLAoJCQkJTlVMTAoJCQl9OwoJCQlpbnQgdmFsID0gMTsKCQkJaWYgKCFzdHJuY21wKG9wdCwgIm5vIiwgMikpIHsKCQkJCXZhbCA9IDA7CgkJCQlvcHQgKz0gMjsKCQkJfQoJCQlzd2l0Y2ggKGNvbXBhcmVfc3RyaW5nX2FycmF5KG9wdGlvbnMsIG9wdCkpIHsKCQkJY2FzZSAwOiAvLyAiYmciCgkJCQliZyA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDE6IC8vICJmZyIKCQkJCWJnID0gIXZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDI6IC8vICJzb2Z0IgoJCQkJc29mdCA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDM6IC8vICJoYXJkIgoJCQkJc29mdCA9ICF2YWw7CgkJCQlicmVhazsKCQkJY2FzZSA0OiAvLyAiaW50ciIKCQkJCWludHIgPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSA1OiAvLyAicG9zaXgiCgkJCQlwb3NpeCA9IHZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDY6IC8vICJjdG8iCgkJCQlub2N0byA9ICF2YWw7CgkJCQlicmVhazsKCQkJY2FzZSA3OiAvLyAiYWMiCgkJCQlub2FjID0gIXZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDg6IC8vICJ0Y3AiCgkJCQl0Y3AgPSB2YWw7CgkJCQlicmVhazsKCQkJY2FzZSA5OiAvLyAidWRwIgoJCQkJdGNwID0gIXZhbDsKCQkJCWJyZWFrOwoJCQljYXNlIDEwOiAvLyAibG9jayIKCQkJCWlmIChuZnNfbW91bnRfdmVyc2lvbiA+PSAzKQoJCQkJCW5vbG9jayA9ICF2YWw7CgkJCQllbHNlCgkJCQkJYmJfZXJyb3JfbXNnKCJ3YXJuaW5nOiBvcHRpb24gbm9sb2NrIGlzIG5vdCBzdXBwb3J0ZWQiKTsKCQkJCWJyZWFrOwoJCQlkZWZhdWx0OgoJCQkJYmJfZXJyb3JfbXNnKCJ1bmtub3duIG5mcyBtb3VudCBvcHRpb246ICVzJXMiLCB2YWwgPyAiIiA6ICJubyIsIG9wdCk7CgkJCQlnb3RvIGZhaWw7CgkJCX0KCQl9Cgl9Cglwcm90byA9ICh0Y3ApID8gSVBQUk9UT19UQ1AgOiBJUFBST1RPX1VEUDsKCglkYXRhLmZsYWdzID0gKHNvZnQgPyBORlNfTU9VTlRfU09GVCA6IDApCgkJfCAoaW50ciA/IE5GU19NT1VOVF9JTlRSIDogMCkKCQl8IChwb3NpeCA/IE5GU19NT1VOVF9QT1NJWCA6IDApCgkJfCAobm9jdG8gPyBORlNfTU9VTlRfTk9DVE8gOiAwKQoJCXwgKG5vYWMgPyBORlNfTU9VTlRfTk9BQyA6IDApOwoJaWYgKG5mc19tb3VudF92ZXJzaW9uID49IDIpCgkJZGF0YS5mbGFncyB8PSAodGNwID8gTkZTX01PVU5UX1RDUCA6IDApOwoJaWYgKG5mc19tb3VudF92ZXJzaW9uID49IDMpCgkJZGF0YS5mbGFncyB8PSAobm9sb2NrID8gTkZTX01PVU5UX05PTkxNIDogMCk7CglpZiAobmZzdmVycyA+IE1BWF9ORlNQUk9UIHx8IG1vdW50dmVycyA+IE1BWF9ORlNQUk9UKSB7CgkJYmJfZXJyb3JfbXNnKCJORlN2JWQgbm90IHN1cHBvcnRlZCIsIG5mc3ZlcnMpOwoJCWdvdG8gZmFpbDsKCX0KCWlmIChuZnN2ZXJzICYmICFtb3VudHZlcnMpCgkJbW91bnR2ZXJzID0gKG5mc3ZlcnMgPCAzKSA/IDEgOiBuZnN2ZXJzOwoJaWYgKG5mc3ZlcnMgJiYgbmZzdmVycyA8IG1vdW50dmVycykgewoJCW1vdW50dmVycyA9IG5mc3ZlcnM7Cgl9CgoJLyogQWRqdXN0IG9wdGlvbnMgaWYgbm9uZSBzcGVjaWZpZWQgKi8KCWlmICghZGF0YS50aW1lbykKCQlkYXRhLnRpbWVvID0gdGNwID8gNzAgOiA3OwoKCWRhdGEudmVyc2lvbiA9IG5mc19tb3VudF92ZXJzaW9uOwoKCWlmICh2ZnNmbGFncyAmIE1TX1JFTU9VTlQpCgkJZ290byBkb19tb3VudDsKCgkvKgoJICogSWYgdGhlIHByZXZpb3VzIG1vdW50IG9wZXJhdGlvbiBvbiB0aGUgc2FtZSBob3N0IHdhcwoJICogYmFja2dyb3VuZGVkLCBhbmQgdGhlICJiZyIgZm9yIHRoaXMgbW91bnQgaXMgYWxzbyBzZXQsCgkgKiBnaXZlIHVwIGltbWVkaWF0ZWx5LCB0byBhdm9pZCB0aGUgaW5pdGlhbCB0aW1lb3V0LgoJICovCglpZiAoYmcgJiYgd2Vfc2F3X3RoaXNfaG9zdF9iZWZvcmUoaG9zdG5hbWUpKSB7CgkJZGFlbW9uaXplZCA9IGRhZW1vbml6ZSgpOyAvKiBwYXJlbnQgb3IgZXJyb3IgKi8KCQlpZiAoZGFlbW9uaXplZCA8PSAwKSB7IC8qIHBhcmVudCBvciBlcnJvciAqLwoJCQlyZXR2YWwgPSAtZGFlbW9uaXplZDsKCQkJZ290byByZXQ7CgkJfQoJfQoKCS8qIGNyZWF0ZSBtb3VudCBkYWVtb24gY2xpZW50ICovCgkvKiBTZWUgaWYgdGhlIG5mcyBob3N0ID0gbW91bnQgaG9zdC4gKi8KCWlmIChtb3VudGhvc3QpIHsKCQlpZiAobW91bnRob3N0WzBdID49ICcwJyAmJiBtb3VudGhvc3RbMF0gPD0gJzknKSB7CgkJCW1vdW50X3NlcnZlcl9hZGRyLnNpbl9mYW1pbHkgPSBBRl9JTkVUOwoJCQltb3VudF9zZXJ2ZXJfYWRkci5zaW5fYWRkci5zX2FkZHIgPSBpbmV0X2FkZHIoaG9zdG5hbWUpOwoJCX0gZWxzZSB7CgkJCWhwID0gZ2V0aG9zdGJ5bmFtZShtb3VudGhvc3QpOwoJCQlpZiAoaHAgPT0gTlVMTCkgewoJCQkJYmJfaGVycm9yX21zZygiJXMiLCBtb3VudGhvc3QpOwoJCQkJZ290byBmYWlsOwoJCQl9IGVsc2UgewoJCQkJaWYgKGhwLT5oX2xlbmd0aCA+IHNpemVvZihzdHJ1Y3QgaW5fYWRkcikpIHsKCQkJCQliYl9lcnJvcl9tc2coImdvdCBiYWQgaHAtPmhfbGVuZ3RoPyIpOwoJCQkJCWhwLT5oX2xlbmd0aCA9IHNpemVvZihzdHJ1Y3QgaW5fYWRkcik7CgkJCQl9CgkJCQltb3VudF9zZXJ2ZXJfYWRkci5zaW5fZmFtaWx5ID0gQUZfSU5FVDsKCQkJCW1lbWNweSgmbW91bnRfc2VydmVyX2FkZHIuc2luX2FkZHIsCgkJCQkJCWhwLT5oX2FkZHIsIGhwLT5oX2xlbmd0aCk7CgkJCX0KCQl9Cgl9CgoJLyoKCSAqIFRoZSBmb2xsb3dpbmcgbG9vcCBpbXBsZW1lbnRzIHRoZSBtb3VudCByZXRyaWVzLiBXaGVuIHRoZSBtb3VudAoJICogdGltZXMgb3V0LCBhbmQgdGhlICJiZyIgb3B0aW9uIGlzIHNldCwgd2UgYmFja2dyb3VuZCBvdXJzZWxmCgkgKiBhbmQgY29udGludWUgdHJ5aW5nLgoJICoKCSAqIFRoZSBjYXNlIHdoZXJlIHRoZSBtb3VudCBwb2ludCBpcyBub3QgcHJlc2VudCBhbmQgdGhlICJiZyIKCSAqIG9wdGlvbiBpcyBzZXQsIGlzIHRyZWF0ZWQgYXMgYSB0aW1lb3V0LiBUaGlzIGlzIGRvbmUgdG8KCSAqIHN1cHBvcnQgbmVzdGVkIG1vdW50cy4KCSAqCgkgKiBUaGUgInJldHJ5IiBjb3VudCBzcGVjaWZpZWQgYnkgdGhlIHVzZXIgaXMgdGhlIG51bWJlciBvZgoJICogbWludXRlcyB0byByZXRyeSBiZWZvcmUgZ2l2aW5nIHVwLgoJICovCgl7CgkJc3RydWN0IHRpbWV2YWwgdG90YWxfdGltZW91dDsKCQlzdHJ1Y3QgdGltZXZhbCByZXRyeV90aW1lb3V0OwoJCXN0cnVjdCBwbWFwKiBwbV9tbnQ7CgkJdGltZV90IHQ7CgkJdGltZV90IHByZXZ0OwoJCXRpbWVfdCB0aW1lb3V0OwoKCQlyZXRyeV90aW1lb3V0LnR2X3NlYyA9IDM7CgkJcmV0cnlfdGltZW91dC50dl91c2VjID0gMDsKCQl0b3RhbF90aW1lb3V0LnR2X3NlYyA9IDIwOwoJCXRvdGFsX3RpbWVvdXQudHZfdXNlYyA9IDA7CgkJdGltZW91dCA9IHRpbWUoTlVMTCkgKyA2MCAqIHJldHJ5OwoJCXByZXZ0ID0gMDsKCQl0ID0gMzA7CnJldHJ5OgoJCS8qIGJlIGNhcmVmdWwgbm90IHRvIHVzZSB0b28gbWFueSBDUFUgY3ljbGVzICovCgkJaWYgKHQgLSBwcmV2dCA8IDMwKQoJCQlzbGVlcCgzMCk7CgoJCXBtX21udCA9IGdldF9tb3VudHBvcnQoJm1vdW50X3NlcnZlcl9hZGRyLAoJCQkJbW91bnRwcm9nLAoJCQkJbW91bnR2ZXJzLAoJCQkJcHJvdG8sCgkJCQltb3VudHBvcnQpOwoJCW5mc3ZlcnMgPSAocG1fbW50LT5wbV92ZXJzIDwgMikgPyAyIDogcG1fbW50LT5wbV92ZXJzOwoKCQkvKiBjb250YWN0IHRoZSBtb3VudCBkYWVtb24gdmlhIFRDUCAqLwoJCW1vdW50X3NlcnZlcl9hZGRyLnNpbl9wb3J0ID0gaHRvbnMocG1fbW50LT5wbV9wb3J0KTsKCQltc29jayA9IFJQQ19BTllTT0NLOwoKCQlzd2l0Y2ggKHBtX21udC0+cG1fcHJvdCkgewoJCWNhc2UgSVBQUk9UT19VRFA6CgkJCW1jbGllbnQgPSBjbG50dWRwX2NyZWF0ZSgmbW91bnRfc2VydmVyX2FkZHIsCgkJCQkJCSBwbV9tbnQtPnBtX3Byb2csCgkJCQkJCSBwbV9tbnQtPnBtX3ZlcnMsCgkJCQkJCSByZXRyeV90aW1lb3V0LAoJCQkJCQkgJm1zb2NrKTsKCQkJaWYgKG1jbGllbnQpCgkJCQlicmVhazsKCQkJbW91bnRfc2VydmVyX2FkZHIuc2luX3BvcnQgPSBodG9ucyhwbV9tbnQtPnBtX3BvcnQpOwoJCQltc29jayA9IFJQQ19BTllTT0NLOwoJCWNhc2UgSVBQUk9UT19UQ1A6CgkJCW1jbGllbnQgPSBjbG50dGNwX2NyZWF0ZSgmbW91bnRfc2VydmVyX2FkZHIsCgkJCQkJCSBwbV9tbnQtPnBtX3Byb2csCgkJCQkJCSBwbV9tbnQtPnBtX3ZlcnMsCgkJCQkJCSAmbXNvY2ssIDAsIDApOwoJCQlicmVhazsKCQlkZWZhdWx0OgoJCQltY2xpZW50ID0gMDsKCQl9CgkJaWYgKCFtY2xpZW50KSB7CgkJCWlmICghZGFlbW9uaXplZCAmJiBwcmV2dCA9PSAwKQoJCQkJZXJyb3JfbXNnX3JwYyhjbG50X3NwY3JlYXRlZXJyb3IoIiAiKSk7CgkJfSBlbHNlIHsKCQkJZW51bSBjbG50X3N0YXQgY2xudF9zdGF0OwoJCQkvKiB0cnkgdG8gbW91bnQgaG9zdG5hbWU6cGF0aG5hbWUgKi8KCQkJbWNsaWVudC0+Y2xfYXV0aCA9IGF1dGh1bml4X2NyZWF0ZV9kZWZhdWx0KCk7CgoJCQkvKiBtYWtlIHBvaW50ZXJzIGluIHhkcl9tb3VudHJlczMgTlVMTCBzbwoJCQkgKiB0aGF0IHhkcl9hcnJheSBhbGxvY2F0ZXMgbWVtb3J5IGZvciB1cwoJCQkgKi8KCQkJbWVtc2V0KCZzdGF0dXMsIDAsIHNpemVvZihzdGF0dXMpKTsKCgkJCWlmIChwbV9tbnQtPnBtX3ZlcnMgPT0gMykKCQkJCWNsbnRfc3RhdCA9IGNsbnRfY2FsbChtY2xpZW50LCBNT1VOVFBST0MzX01OVCwKCQkJCQkgICAgICAoeGRycHJvY190KSB4ZHJfZGlycGF0aCwKCQkJCQkgICAgICAoY2FkZHJfdCkgJnBhdGhuYW1lLAoJCQkJCSAgICAgICh4ZHJwcm9jX3QpIHhkcl9tb3VudHJlczMsCgkJCQkJICAgICAgKGNhZGRyX3QpICZzdGF0dXMsCgkJCQkJICAgICAgdG90YWxfdGltZW91dCk7CgkJCWVsc2UKCQkJCWNsbnRfc3RhdCA9IGNsbnRfY2FsbChtY2xpZW50LCBNT1VOVFBST0NfTU5ULAoJCQkJCSAgICAgICh4ZHJwcm9jX3QpIHhkcl9kaXJwYXRoLAoJCQkJCSAgICAgIChjYWRkcl90KSAmcGF0aG5hbWUsCgkJCQkJICAgICAgKHhkcnByb2NfdCkgeGRyX2Zoc3RhdHVzLAoJCQkJCSAgICAgIChjYWRkcl90KSAmc3RhdHVzLAoJCQkJCSAgICAgIHRvdGFsX3RpbWVvdXQpOwoKCQkJaWYgKGNsbnRfc3RhdCA9PSBSUENfU1VDQ0VTUykKCQkJCWdvdG8gcHJlcGFyZV9rZXJuZWxfZGF0YTsgLyogd2UncmUgZG9uZSAqLwoJCQlpZiAoZXJybm8gIT0gRUNPTk5SRUZVU0VEKSB7CgkJCQllcnJvcl9tc2dfcnBjKGNsbnRfc3BlcnJvcihtY2xpZW50LCAiICIpKTsKCQkJCWdvdG8gZmFpbDsJLyogZG9uJ3QgcmV0cnkgKi8KCQkJfQoJCQkvKiBDb25uZWN0aW9uIHJlZnVzZWQgKi8KCQkJaWYgKCFkYWVtb25pemVkICYmIHByZXZ0ID09IDApIC8qIHByaW50IGp1c3Qgb25jZSAqLwoJCQkJZXJyb3JfbXNnX3JwYyhjbG50X3NwZXJyb3IobWNsaWVudCwgIiAiKSk7CgkJCWF1dGhfZGVzdHJveShtY2xpZW50LT5jbF9hdXRoKTsKCQkJY2xudF9kZXN0cm95KG1jbGllbnQpOwoJCQltY2xpZW50ID0gMDsKCQkJY2xvc2UobXNvY2spOwoJCX0KCgkJLyogVGltZW91dC4gV2UgYXJlIGdvaW5nIHRvIHJldHJ5Li4uIG1heWJlICovCgoJCWlmICghYmcpCgkJCWdvdG8gZmFpbDsKCQlpZiAoIWRhZW1vbml6ZWQpIHsKCQkJZGFlbW9uaXplZCA9IGRhZW1vbml6ZSgpOwoJCQlpZiAoZGFlbW9uaXplZCA8PSAwKSB7IC8qIHBhcmVudCBvciBlcnJvciAqLwoJCQkJcmV0dmFsID0gLWRhZW1vbml6ZWQ7CgkJCQlnb3RvIHJldDsKCQkJfQoJCX0KCQlwcmV2dCA9IHQ7CgkJdCA9IHRpbWUoTlVMTCk7CgkJaWYgKHQgPj0gdGltZW91dCkKCQkJLyogVE9ETyBlcnJvciBtZXNzYWdlICovCgkJCWdvdG8gZmFpbDsKCgkJZ290byByZXRyeTsKCX0KCnByZXBhcmVfa2VybmVsX2RhdGE6CgoJaWYgKG5mc3ZlcnMgPT0gMikgewoJCWlmIChzdGF0dXMubmZzdjIuZmhzX3N0YXR1cyAhPSAwKSB7CgkJCWJiX2Vycm9yX21zZygiJXM6JXMgZmFpbGVkLCByZWFzb24gZ2l2ZW4gYnkgc2VydmVyOiAlcyIsCgkJCQlob3N0bmFtZSwgcGF0aG5hbWUsCgkJCQluZnNfc3RyZXJyb3Ioc3RhdHVzLm5mc3YyLmZoc19zdGF0dXMpKTsKCQkJZ290byBmYWlsOwoJCX0KCQltZW1jcHkoZGF0YS5yb290LmRhdGEsCgkJCQkoY2hhciAqKSBzdGF0dXMubmZzdjIuZmhzdGF0dXNfdS5maHNfZmhhbmRsZSwKCQkJCU5GU19GSFNJWkUpOwoJCWRhdGEucm9vdC5zaXplID0gTkZTX0ZIU0laRTsKCQltZW1jcHkoZGF0YS5vbGRfcm9vdC5kYXRhLAoJCQkJKGNoYXIgKikgc3RhdHVzLm5mc3YyLmZoc3RhdHVzX3UuZmhzX2ZoYW5kbGUsCgkJCQlORlNfRkhTSVpFKTsKCX0gZWxzZSB7CgkJZmhhbmRsZTMgKm15X2ZoYW5kbGU7CgkJaWYgKHN0YXR1cy5uZnN2My5maHNfc3RhdHVzICE9IDApIHsKCQkJYmJfZXJyb3JfbXNnKCIlczolcyBmYWlsZWQsIHJlYXNvbiBnaXZlbiBieSBzZXJ2ZXI6ICVzIiwKCQkJCWhvc3RuYW1lLCBwYXRobmFtZSwKCQkJCW5mc19zdHJlcnJvcihzdGF0dXMubmZzdjMuZmhzX3N0YXR1cykpOwoJCQlnb3RvIGZhaWw7CgkJfQoJCW15X2ZoYW5kbGUgPSAmc3RhdHVzLm5mc3YzLm1vdW50cmVzM191Lm1vdW50aW5mby5maGFuZGxlOwoJCW1lbXNldChkYXRhLm9sZF9yb290LmRhdGEsIDAsIE5GU19GSFNJWkUpOwoJCW1lbXNldCgmZGF0YS5yb290LCAwLCBzaXplb2YoZGF0YS5yb290KSk7CgkJZGF0YS5yb290LnNpemUgPSBteV9maGFuZGxlLT5maGFuZGxlM19sZW47CgkJbWVtY3B5KGRhdGEucm9vdC5kYXRhLAoJCQkJKGNoYXIgKikgbXlfZmhhbmRsZS0+ZmhhbmRsZTNfdmFsLAoJCQkJbXlfZmhhbmRsZS0+ZmhhbmRsZTNfbGVuKTsKCgkJZGF0YS5mbGFncyB8PSBORlNfTU9VTlRfVkVSMzsKCX0KCgkvKiBjcmVhdGUgbmZzIHNvY2tldCBmb3Iga2VybmVsICovCgoJaWYgKHRjcCkgewoJCWlmIChuZnNfbW91bnRfdmVyc2lvbiA8IDMpIHsKCQkJYmJfZXJyb3JfbXNnKCJORlMgb3ZlciBUQ1AgaXMgbm90IHN1cHBvcnRlZCIpOwoJCQlnb3RvIGZhaWw7CgkJfQoJCWZzb2NrID0gc29ja2V0KEFGX0lORVQsIFNPQ0tfU1RSRUFNLCBJUFBST1RPX1RDUCk7Cgl9IGVsc2UKCQlmc29jayA9IHNvY2tldChBRl9JTkVULCBTT0NLX0RHUkFNLCBJUFBST1RPX1VEUCk7CglpZiAoZnNvY2sgPCAwKSB7CgkJYmJfcGVycm9yX21zZygibmZzIHNvY2tldCIpOwoJCWdvdG8gZmFpbDsKCX0KCWlmIChiaW5kcmVzdnBvcnQoZnNvY2ssIDApIDwgMCkgewoJCWJiX3BlcnJvcl9tc2coIm5mcyBiaW5kcmVzdnBvcnQiKTsKCQlnb3RvIGZhaWw7Cgl9CglpZiAocG9ydCA9PSAwKSB7CgkJc2VydmVyX2FkZHIuc2luX3BvcnQgPSBQTUFQUE9SVDsKCQlwb3J0ID0gcG1hcF9nZXRwb3J0KCZzZXJ2ZXJfYWRkciwgbmZzcHJvZywgbmZzdmVycywKCQkJCQl0Y3AgPyBJUFBST1RPX1RDUCA6IElQUFJPVE9fVURQKTsKCQlpZiAocG9ydCA9PSAwKQoJCQlwb3J0ID0gTkZTX1BPUlQ7Cgl9CglzZXJ2ZXJfYWRkci5zaW5fcG9ydCA9IGh0b25zKHBvcnQpOwoKCS8qIHByZXBhcmUgZGF0YSBzdHJ1Y3R1cmUgZm9yIGtlcm5lbCAqLwoKCWRhdGEuZmQgPSBmc29jazsKCW1lbWNweSgoY2hhciAqKSAmZGF0YS5hZGRyLCAoY2hhciAqKSAmc2VydmVyX2FkZHIsIHNpemVvZihkYXRhLmFkZHIpKTsKCXN0cm5jcHkoZGF0YS5ob3N0bmFtZSwgaG9zdG5hbWUsIHNpemVvZihkYXRhLmhvc3RuYW1lKSk7CgoJLyogY2xlYW4gdXAgKi8KCglhdXRoX2Rlc3Ryb3kobWNsaWVudC0+Y2xfYXV0aCk7CgljbG50X2Rlc3Ryb3kobWNsaWVudCk7CgljbG9zZShtc29jayk7CgoJaWYgKGJnKSB7CgkJLyogV2UgbXVzdCB3YWl0IHVudGlsIG1vdW50IGRpcmVjdG9yeSBpcyBhdmFpbGFibGUgKi8KCQlzdHJ1Y3Qgc3RhdCBzdGF0YnVmOwoJCWludCBkZWxheSA9IDE7CgkJd2hpbGUgKHN0YXQobXAtPm1udF9kaXIsICZzdGF0YnVmKSA9PSAtMSkgewoJCQlpZiAoIWRhZW1vbml6ZWQpIHsKCQkJCWRhZW1vbml6ZWQgPSBkYWVtb25pemUoKTsKCQkJCWlmIChkYWVtb25pemVkIDw9IDApIHsgLyogcGFyZW50IG9yIGVycm9yICovCgkJCQkJcmV0dmFsID0gLWRhZW1vbml6ZWQ7CgkJCQkJZ290byByZXQ7CgkJCQl9CgkJCX0KCQkJc2xlZXAoZGVsYXkpOwkvKiAxLCAyLCA0LCA4LCAxNiwgMzAsIC4uLiAqLwoJCQlkZWxheSAqPSAyOwoJCQlpZiAoZGVsYXkgPiAzMCkKCQkJCWRlbGF5ID0gMzA7CgkJfQoJfQoKZG9fbW91bnQ6IC8qIHBlcmZvcm0gYWN0dWFsIG1vdW50ICovCgoJbXAtPm1udF90eXBlID0gIm5mcyI7CglyZXR2YWwgPSBtb3VudF9pdF9ub3cobXAsIHZmc2ZsYWdzLCAoY2hhciopJmRhdGEpOwoJZ290byByZXQ7CgpmYWlsOgkvKiBhYm9ydCAqLwoKCWlmIChtc29jayAhPSAtMSkgewoJCWlmIChtY2xpZW50KSB7CgkJCWF1dGhfZGVzdHJveShtY2xpZW50LT5jbF9hdXRoKTsKCQkJY2xudF9kZXN0cm95KG1jbGllbnQpOwoJCX0KCQljbG9zZShtc29jayk7Cgl9CglpZiAoZnNvY2sgIT0gLTEpCgkJY2xvc2UoZnNvY2spOwoKcmV0OgoJZnJlZShob3N0bmFtZSk7CglmcmVlKG1vdW50aG9zdCk7CglmcmVlKGZpbHRlcm9wdHMpOwoJcmV0dXJuIHJldHZhbDsKfQoKI2Vsc2UgLyogIUVOQUJMRV9GRUFUVVJFX01PVU5UX05GUyAqLwoKLyogTmV2ZXIgY2FsbGVkLiBDYWxsIHNob3VsZCBiZSBvcHRpbWl6ZWQgb3V0LiAqLwppbnQgbmZzbW91bnQoc3RydWN0IG1udGVudCAqbXAsIGludCB2ZnNmbGFncywgY2hhciAqZmlsdGVyb3B0cyk7CgojZW5kaWYgLyogIUVOQUJMRV9GRUFUVVJFX01PVU5UX05GUyAqLwoKLy8gTW91bnQgb25lIGRpcmVjdG9yeS4gIEhhbmRsZXMgQ0lGUywgTkZTLCBsb29wYmFjaywgYXV0b2JpbmQsIGFuZCBmaWxlc3lzdGVtCi8vIHR5cGUgZGV0ZWN0aW9uLiAgUmV0dXJucyAwIGZvciBzdWNjZXNzLCBub256ZXJvIGZvciBmYWlsdXJlLgovLyBOQjogbXAtPnh4eCBmaWVsZHMgbWF5IGJlIHRyYXNoZWQgb24gZXhpdApzdGF0aWMgaW50IHNpbmdsZW1vdW50KHN0cnVjdCBtbnRlbnQgKm1wLCBpbnQgaWdub3JlX2J1c3kpCnsKCWludCByYyA9IC0xLCB2ZnNmbGFnczsKCWNoYXIgKmxvb3BGaWxlID0gMCwgKmZpbHRlcm9wdHMgPSAwOwoJbGxpc3RfdCAqZmwgPSAwOwoJc3RydWN0IHN0YXQgc3Q7CgoJdmZzZmxhZ3MgPSBwYXJzZV9tb3VudF9vcHRpb25zKG1wLT5tbnRfb3B0cywgJmZpbHRlcm9wdHMpOwoKCS8vIFRyZWF0IGZzdHlwZSAiYXV0byIgYXMgdW5zcGVjaWZpZWQuCgoJaWYgKG1wLT5tbnRfdHlwZSAmJiAhc3RyY21wKG1wLT5tbnRfdHlwZSwiYXV0byIpKSBtcC0+bW50X3R5cGUgPSAwOwoKCS8vIE1pZ2h0IHRoaXMgYmUgYW4gQ0lGUyBmaWxlc3lzdGVtPwoKCWlmIChFTkFCTEVfRkVBVFVSRV9NT1VOVF9DSUZTICYmCgkJKCFtcC0+bW50X3R5cGUgfHwgIXN0cmNtcChtcC0+bW50X3R5cGUsImNpZnMiKSkgJiYKCQkobXAtPm1udF9mc25hbWVbMF09PW1wLT5tbnRfZnNuYW1lWzFdICYmIChtcC0+bW50X2ZzbmFtZVswXT09Jy8nIHx8IG1wLT5tbnRfZnNuYW1lWzBdPT0nXFwnKSkpCgl7CgkJc3RydWN0IGhvc3RlbnQgKmhlOwoJCWNoYXIgaXBbMzJdLCAqczsKCgkJcmMgPSAxOwoJCS8vIFJlcGxhY2UgJy8nIHdpdGggJ1wnIGFuZCB2ZXJpZnkgdGhhdCB1bmMgcG9pbnRzIHRvICIvL3NlcnZlci9zaGFyZSIuCgoJCWZvciAocyA9IG1wLT5tbnRfZnNuYW1lOyAqczsgKytzKQoJCQlpZiAoKnMgPT0gJy8nKSAqcyA9ICdcXCc7CgoJCS8vIGdldCBzZXJ2ZXIgSVAKCgkJcyA9IHN0cnJjaHIobXAtPm1udF9mc25hbWUsICdcXCcpOwoJCWlmIChzID09IG1wLT5tbnRfZnNuYW1lKzEpIGdvdG8gcmVwb3J0X2Vycm9yOwoJCSpzID0gMDsKCQloZSA9IGdldGhvc3RieW5hbWUobXAtPm1udF9mc25hbWUrMik7CgkJKnMgPSAnXFwnOwoJCWlmICghaGUpIGdvdG8gcmVwb3J0X2Vycm9yOwoKCQkvLyBJbnNlcnQgaXA9Li4uIG9wdGlvbiBpbnRvIHN0cmluZyBmbGFncy4gIChOT1RFOiBBZGQgSVB2NiBzdXBwb3J0LikKCgkJc3ByaW50ZihpcCwgImlwPSVkLiVkLiVkLiVkIiwgaGUtPmhfYWRkclswXSwgaGUtPmhfYWRkclsxXSwKCQkJCWhlLT5oX2FkZHJbMl0sIGhlLT5oX2FkZHJbM10pOwoJCXBhcnNlX21vdW50X29wdGlvbnMoaXAsICZmaWx0ZXJvcHRzKTsKCgkJLy8gY29tcG9zZSBuZXcgdW5jICdcXHNlcnZlci1pcFxzaGFyZScKCgkJbXAtPm1udF9mc25hbWUgPSB4YXNwcmludGYoIlxcXFwlcyVzIiwgaXArMywKCQkJCQlzdHJjaHIobXAtPm1udF9mc25hbWUrMiwnXFwnKSk7CgoJCS8vIGxvY2sgaXMgcmVxdWlyZWQKCQl2ZnNmbGFncyB8PSBNU19NQU5ETE9DSzsKCgkJbXAtPm1udF90eXBlID0gImNpZnMiOwoJCXJjID0gbW91bnRfaXRfbm93KG1wLCB2ZnNmbGFncywgZmlsdGVyb3B0cyk7CgkJaWYgKEVOQUJMRV9GRUFUVVJFX0NMRUFOX1VQKSBmcmVlKG1wLT5tbnRfZnNuYW1lKTsKCQlnb3RvIHJlcG9ydF9lcnJvcjsKCX0KCgkvLyBNaWdodCB0aGlzIGJlIGFuIE5GUyBmaWxlc3lzdGVtPwoKCWlmIChFTkFCTEVfRkVBVFVSRV9NT1VOVF9ORlMgJiYKCQkoIW1wLT5tbnRfdHlwZSB8fCAhc3RyY21wKG1wLT5tbnRfdHlwZSwibmZzIikpICYmCgkJc3RyY2hyKG1wLT5tbnRfZnNuYW1lLCAnOicpICE9IE5VTEwpCgl7CgkJcmMgPSBuZnNtb3VudChtcCwgdmZzZmxhZ3MsIGZpbHRlcm9wdHMpOwoJCWdvdG8gcmVwb3J0X2Vycm9yOwoJfQoKCS8vIExvb2sgYXQgdGhlIGZpbGUuICAoTm90IGZvdW5kIGlzbid0IGEgZmFpbHVyZSBmb3IgcmVtb3VudCwgb3IgZm9yCgkvLyBhIHN5bnRoZXRpYyBmaWxlc3lzdGVtIGxpa2UgcHJvYyBvciBzeXNmcy4pCgoJaWYgKCFsc3RhdChtcC0+bW50X2ZzbmFtZSwgJnN0KSAmJiAhKHZmc2ZsYWdzICYgKE1TX1JFTU9VTlQgfCBNU19CSU5EIHwgTVNfTU9WRSkpKQoJewoJCS8vIERvIHdlIG5lZWQgdG8gYWxsb2NhdGUgYSBsb29wYmFjayBkZXZpY2UgZm9yIGl0PwoKCQlpZiAoRU5BQkxFX0ZFQVRVUkVfTU9VTlRfTE9PUCAmJiBTX0lTUkVHKHN0LnN0X21vZGUpKSB7CgkJCWxvb3BGaWxlID0gYmJfc2ltcGxpZnlfcGF0aChtcC0+bW50X2ZzbmFtZSk7CgkJCW1wLT5tbnRfZnNuYW1lID0gMDsKCQkJc3dpdGNoIChzZXRfbG9vcCgmKG1wLT5tbnRfZnNuYW1lKSwgbG9vcEZpbGUsIDApKSB7CgkJCWNhc2UgMDoKCQkJY2FzZSAxOgoJCQkJYnJlYWs7CgkJCWRlZmF1bHQ6CgkJCQliYl9lcnJvcl9tc2coIGVycm5vID09IEVQRVJNIHx8IGVycm5vID09IEVBQ0NFUwoJCQkJCT8gYmJfbXNnX3Blcm1fZGVuaWVkX2FyZV95b3Vfcm9vdAoJCQkJCTogImNhbm5vdCBzZXR1cCBsb29wIGRldmljZSIpOwoJCQkJcmV0dXJuIGVycm5vOwoJCQl9CgoJCS8vIEF1dG9kZXRlY3QgYmluZCBtb3VudHMKCgkJfSBlbHNlIGlmIChTX0lTRElSKHN0LnN0X21vZGUpICYmICFtcC0+bW50X3R5cGUpCgkJCXZmc2ZsYWdzIHw9IE1TX0JJTkQ7Cgl9CgoJLyogSWYgd2Uga25vdyB0aGUgZnN0eXBlIChvciBkb24ndCBuZWVkIHRvKSwganVtcCBzdHJhaWdodAoJICogdG8gdGhlIGFjdHVhbCBtb3VudC4gKi8KCglpZiAobXAtPm1udF90eXBlIHx8ICh2ZnNmbGFncyAmIChNU19SRU1PVU5UIHwgTVNfQklORCB8IE1TX01PVkUpKSkKCQlyYyA9IG1vdW50X2l0X25vdyhtcCwgdmZzZmxhZ3MsIGZpbHRlcm9wdHMpOwoKCS8vIExvb3AgdGhyb3VnaCBmaWxlc3lzdGVtIHR5cGVzIHVudGlsIG1vdW50IHN1Y2NlZWRzIG9yIHdlIHJ1biBvdXQKCgllbHNlIHsKCgkJLyogSW5pdGlhbGl6ZSBsaXN0IG9mIGJsb2NrIGJhY2tlZCBmaWxlc3lzdGVtcy4gIFRoaXMgaGFzIHRvIGJlCgkJICogZG9uZSBoZXJlIHNvIHRoYXQgZHVyaW5nICJtb3VudCAtYSIsIG1vdW50cyBhZnRlciAvcHJvYyBzaG93cyB1cAoJCSAqIGNhbiBhdXRvZGV0ZWN0LiAqLwoKCQlpZiAoIWZzbGlzdCkgewoJCQlmc2xpc3QgPSBnZXRfYmxvY2tfYmFja2VkX2ZpbGVzeXN0ZW1zKCk7CgkJCWlmIChFTkFCTEVfRkVBVFVSRV9DTEVBTl9VUCAmJiBmc2xpc3QpCgkJCQlhdGV4aXQoZGVsZXRlX2Jsb2NrX2JhY2tlZF9maWxlc3lzdGVtcyk7CgkJfQoKCQlmb3IgKGZsID0gZnNsaXN0OyBmbDsgZmwgPSBmbC0+bGluaykgewoJCQltcC0+bW50X3R5cGUgPSBmbC0+ZGF0YTsKCQkJcmMgPSBtb3VudF9pdF9ub3cobXAsIHZmc2ZsYWdzLCBmaWx0ZXJvcHRzKTsKCQkJaWYgKCFyYykgYnJlYWs7CgkJfQoJfQoKCS8vIElmIG1vdW50IGZhaWxlZCwgY2xlYW4gdXAgbG9vcCBmaWxlIChpZiBhbnkpLgoKCWlmIChFTkFCTEVfRkVBVFVSRV9NT1VOVF9MT09QICYmIHJjICYmIGxvb3BGaWxlKSB7CgkJZGVsX2xvb3AobXAtPm1udF9mc25hbWUpOwoJCWlmIChFTkFCTEVfRkVBVFVSRV9DTEVBTl9VUCkgewoJCQlmcmVlKGxvb3BGaWxlKTsKCQkJZnJlZShtcC0+bW50X2ZzbmFtZSk7CgkJfQoJfQoKcmVwb3J0X2Vycm9yOgoJaWYgKEVOQUJMRV9GRUFUVVJFX0NMRUFOX1VQKSBmcmVlKGZpbHRlcm9wdHMpOwoKCWlmIChyYyAmJiBlcnJubyA9PSBFQlVTWSAmJiBpZ25vcmVfYnVzeSkgcmMgPSAwOwoJaWYgKHJjIDwgMCkKCQkvKiBwZXJyb3IgaGVyZSBzb21ldGltZXMgc2F5cyAibW91bnRpbmcgLi4uIG9uIC4uLiBmYWlsZWQ6IFN1Y2Nlc3MiICovCgkJYmJfZXJyb3JfbXNnKCJtb3VudGluZyAlcyBvbiAlcyBmYWlsZWQiLCBtcC0+bW50X2ZzbmFtZSwgbXAtPm1udF9kaXIpOwoKCXJldHVybiByYzsKfQoKLy8gUGFyc2Ugb3B0aW9ucywgaWYgbmVjZXNzYXJ5IHBhcnNlIGZzdGFiL210YWIsIGFuZCBjYWxsIHNpbmdsZW1vdW50IGZvcgovLyBlYWNoIGRpcmVjdG9yeSB0byBiZSBtb3VudGVkLgoKY29uc3QgY2hhciBtdXN0X2JlX3Jvb3RbXSA9ICJ5b3UgbXVzdCBiZSByb290IjsKCmludCBtb3VudF9tYWluKGludCBhcmdjLCBjaGFyICoqYXJndikKewoJZW51bSB7IE9QVF9BTEwgPSAweDEwIH07CgoJY2hhciAqY21kb3B0cyA9IHhzdHJkdXAoIiIpLCAqZnN0eXBlPTAsICpzdG9yYWdlX3BhdGg9MDsKCWNoYXIgKm9wdF9vOwoJY29uc3QgY2hhciAqZnN0YWJuYW1lOwoJRklMRSAqZnN0YWI7CglpbnQgaSwgaiwgcmMgPSAwOwoJdW5zaWduZWQgb3B0OwoJc3RydWN0IG1udGVudCBtdHBhaXJbMl0sICptdGN1ciA9IG10cGFpcjsKCVNLSVBfREVTS1RPUChjb25zdCBpbnQgbm9ucm9vdCA9IDA7KQoJVVNFX0RFU0tUT1AoIGludCBub25yb290ID0gKGdldHVpZCgpICE9IDApOykKCgkvKiBwYXJzZSBsb25nIG9wdGlvbnMsIGxpa2UgLS1iaW5kIGFuZCAtLW1vdmUuICBOb3RlIHRoYXQgLW8gb3B0aW9uCgkgKiBhbmQgLS1vcHRpb24gYXJlIHN5bm9ueW1vdXMuICBZZXMsIHRoaXMgbWVhbnMgLS1yZW1vdW50LHJ3IHdvcmtzLiAqLwoKCWZvciAoaSA9IGogPSAwOyBpIDwgYXJnYzsgaSsrKSB7CgkJaWYgKGFyZ3ZbaV1bMF0gPT0gJy0nICYmIGFyZ3ZbaV1bMV0gPT0gJy0nKSB7CgkJCWFwcGVuZF9tb3VudF9vcHRpb25zKCZjbWRvcHRzLCBhcmd2W2ldKzIpOwoJCX0gZWxzZSBhcmd2W2orK10gPSBhcmd2W2ldOwoJfQoJYXJndltqXSA9IDA7CglhcmdjID0gajsKCgkvLyBQYXJzZSByZW1haW5pbmcgb3B0aW9ucwoKCW9wdCA9IGdldG9wdDMyKGFyZ2MsIGFyZ3YsICJvOnQ6cndhbmZ2cyIsICZvcHRfbywgJmZzdHlwZSk7CglpZiAob3B0ICYgMHgxKSBhcHBlbmRfbW91bnRfb3B0aW9ucygmY21kb3B0cywgb3B0X28pOyAvLyAtbwoJLy9pZiAob3B0ICYgMHgyKSAvLyAtdAoJaWYgKG9wdCAmIDB4NCkgYXBwZW5kX21vdW50X29wdGlvbnMoJmNtZG9wdHMsICJybyIpOyAvLyAtcgoJaWYgKG9wdCAmIDB4OCkgYXBwZW5kX21vdW50X29wdGlvbnMoJmNtZG9wdHMsICJydyIpOyAvLyAtdwoJLy9pZiAob3B0ICYgMHgxMCkgLy8gLWEKCWlmIChvcHQgJiAweDIwKSBVU0VfRkVBVFVSRV9NVEFCX1NVUFBPUlQodXNlTXRhYiA9IDApOyAvLyAtbgoJaWYgKG9wdCAmIDB4NDApIFVTRV9GRUFUVVJFX01UQUJfU1VQUE9SVChmYWtlSXQgPSAxKTsgLy8gLWYKCS8vaWYgKG9wdCAmIDB4ODApIC8vIC12OiB2ZXJib3NlIChpZ25vcmUpCgkvL2lmIChvcHQgJiAweDEwMCkgLy8gLXM6IHNsb3BweSAoaWdub3JlKQoJYXJndiArPSBvcHRpbmQ7CglhcmdjIC09IG9wdGluZDsKCgkvLyBUaHJlZSBvciBtb3JlIG5vbi1vcHRpb24gYXJndW1lbnRzPyAgRGllIHdpdGggYSB1c2FnZSBtZXNzYWdlLgoKCWlmIChhcmdjID4gMikgYmJfc2hvd191c2FnZSgpOwoKCS8vIElmIHdlIGhhdmUgbm8gYXJndW1lbnRzLCBzaG93IGN1cnJlbnRseSBtb3VudGVkIGZpbGVzeXN0ZW1zCgoJaWYgKCFhcmdjKSB7CgkJaWYgKCEob3B0ICYgT1BUX0FMTCkpIHsKCQkJRklMRSAqbW91bnRUYWJsZSA9IHNldG1udGVudChiYl9wYXRoX210YWJfZmlsZSwgInIiKTsKCgkJCWlmICghbW91bnRUYWJsZSkgYmJfZXJyb3JfbXNnX2FuZF9kaWUoIm5vICVzIiwgYmJfcGF0aF9tdGFiX2ZpbGUpOwoKCQkJd2hpbGUgKGdldG1udGVudF9yKG1vdW50VGFibGUsIG10cGFpciwgYmJfY29tbW9uX2J1ZnNpejEsCgkJCQkJCQkJc2l6ZW9mKGJiX2NvbW1vbl9idWZzaXoxKSkpCgkJCXsKCQkJCS8vIERvbid0IHNob3cgcm9vdGZzLiBGSVhNRTogd2h5Pz8KCQkJCWlmICghc3RyY21wKG10cGFpci0+bW50X2ZzbmFtZSwgInJvb3RmcyIpKSBjb250aW51ZTsKCgkJCQlpZiAoIWZzdHlwZSB8fCAhc3RyY21wKG10cGFpci0+bW50X3R5cGUsIGZzdHlwZSkpCgkJCQkJcHJpbnRmKCIlcyBvbiAlcyB0eXBlICVzICglcylcbiIsIG10cGFpci0+bW50X2ZzbmFtZSwKCQkJCQkJCW10cGFpci0+bW50X2RpciwgbXRwYWlyLT5tbnRfdHlwZSwKCQkJCQkJCW10cGFpci0+bW50X29wdHMpOwoJCQl9CgkJCWlmIChFTkFCTEVfRkVBVFVSRV9DTEVBTl9VUCkgZW5kbW50ZW50KG1vdW50VGFibGUpOwoJCQlyZXR1cm4gRVhJVF9TVUNDRVNTOwoJCX0KCX0gZWxzZSBzdG9yYWdlX3BhdGggPSBiYl9zaW1wbGlmeV9wYXRoKGFyZ3ZbMF0pOwoKCS8vIFdoZW4gd2UgaGF2ZSB0d28gYXJndW1lbnRzLCB0aGUgc2Vjb25kIGlzIHRoZSBkaXJlY3RvcnkgYW5kIHdlIGNhbgoJLy8gc2tpcCBsb29raW5nIGF0IGZzdGFiIGVudGlyZWx5LiAgV2UgY2FuIGFsd2F5cyBhYnNwYXRoKCkgdGhlIGRpcmVjdG9yeQoJLy8gYXJndW1lbnQgd2hlbiB3ZSBnZXQgaXQuCgoJaWYgKGFyZ2MgPT0gMikgewoJCWlmIChub25yb290KQoJCQliYl9lcnJvcl9tc2dfYW5kX2RpZShtdXN0X2JlX3Jvb3QpOwoJCW10cGFpci0+bW50X2ZzbmFtZSA9IGFyZ3ZbMF07CgkJbXRwYWlyLT5tbnRfZGlyID0gYXJndlsxXTsKCQltdHBhaXItPm1udF90eXBlID0gZnN0eXBlOwoJCW10cGFpci0+bW50X29wdHMgPSBjbWRvcHRzOwoJCXJjID0gc2luZ2xlbW91bnQobXRwYWlyLCAwKTsKCQlnb3RvIGNsZWFuX3VwOwoJfQoKCWkgPSBwYXJzZV9tb3VudF9vcHRpb25zKGNtZG9wdHMsIDApOwoJaWYgKG5vbnJvb3QgJiYgKGkgJiB+TVNfU0lMRU5UKSkgLy8gTm9uLXJvb3QgdXNlcnMgY2Fubm90IHNwZWNpZnkgZmxhZ3MKCQliYl9lcnJvcl9tc2dfYW5kX2RpZShtdXN0X2JlX3Jvb3QpOwoKCS8vIElmIHdlIGhhdmUgYSBzaGFyZWQgc3VidHJlZSBmbGFnLCBkb24ndCB3b3JyeSBhYm91dCBmc3RhYiBvciBtdGFiLgoKCWlmIChFTkFCTEVfRkVBVFVSRV9NT1VOVF9GTEFHUyAmJgoJCQkoaSAmIChNU19TSEFSRUQgfCBNU19QUklWQVRFIHwgTVNfU0xBVkUgfCBNU19VTkJJTkRBQkxFKSkpCgl7CgkJcmMgPSBtb3VudCgiIiwgYXJndlswXSwgIiIsIGksICIiKTsKCQlpZiAocmMpIGJiX3BlcnJvcl9tc2dfYW5kX2RpZSgiJXMiLCBhcmd2WzBdKTsKCQlnb3RvIGNsZWFuX3VwOwoJfQoKCS8vIE9wZW4gZWl0aGVyIGZzdGFiIG9yIG10YWIKCglmc3RhYm5hbWUgPSAiL2V0Yy9mc3RhYiI7CglpZiAoaSAmIE1TX1JFTU9VTlQpIHsKCQlmc3RhYm5hbWUgPSBiYl9wYXRoX210YWJfZmlsZTsKCX0KCWZzdGFiID0gc2V0bW50ZW50KGZzdGFibmFtZSwgInIiKTsKCWlmICghZnN0YWIpCgkJYmJfcGVycm9yX21zZ19hbmRfZGllKCJjYW5ub3QgcmVhZCAlcyIsIGZzdGFibmFtZSk7CgoJLy8gTG9vcCB0aHJvdWdoIGVudHJpZXMgdW50aWwgd2UgZmluZCB3aGF0IHdlJ3JlIGxvb2tpbmcgZm9yLgoKCW1lbXNldChtdHBhaXIsIDAsIHNpemVvZihtdHBhaXIpKTsKCWZvciAoOzspIHsKCQlzdHJ1Y3QgbW50ZW50ICptdG5leHQgPSAobXRjdXI9PW10cGFpciA/IG10cGFpcisxIDogbXRwYWlyKTsKCgkJLy8gR2V0IG5leHQgZnN0YWIgZW50cnkKCgkJaWYgKCFnZXRtbnRlbnRfcihmc3RhYiwgbXRjdXIsIGJiX2NvbW1vbl9idWZzaXoxCgkJCQkJKyAobXRjdXI9PW10cGFpciA/IHNpemVvZihiYl9jb21tb25fYnVmc2l6MSkvMiA6IDApLAoJCQkJc2l6ZW9mKGJiX2NvbW1vbl9idWZzaXoxKS8yKSkKCQl7CgkJCS8vIFdlcmUgd2UgbG9va2luZyBmb3Igc29tZXRoaW5nIHNwZWNpZmljPwoKCQkJaWYgKGFyZ2MpIHsKCgkJCQkvLyBJZiB3ZSBkaWRuJ3QgZmluZCBhbnl0aGluZywgY29tcGxhaW4uCgoJCQkJaWYgKCFtdG5leHQtPm1udF9mc25hbWUpCgkJCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoImNhbid0IGZpbmQgJXMgaW4gJXMiLAoJCQkJCQlhcmd2WzBdLCBmc3RhYm5hbWUpOwoKCQkJCW10Y3VyID0gbXRuZXh0OwoJCQkJaWYgKG5vbnJvb3QpIHsKCQkJCQkvLyBmc3RhYiBtdXN0IGhhdmUgInVzZXJzIiBvciAidXNlciIKCQkJCQlpZiAoIShwYXJzZV9tb3VudF9vcHRpb25zKG10Y3VyLT5tbnRfb3B0cywgMCkgJiBNT1VOVF9VU0VSUykpCgkJCQkJCWJiX2Vycm9yX21zZ19hbmRfZGllKG11c3RfYmVfcm9vdCk7CgkJCQl9CgoJCQkJLy8gTW91bnQgdGhlIGxhc3QgdGhpbmcgd2UgZm91bmQuCgoJCQkJbXRjdXItPm1udF9vcHRzID0geHN0cmR1cChtdGN1ci0+bW50X29wdHMpOwoJCQkJYXBwZW5kX21vdW50X29wdGlvbnMoJihtdGN1ci0+bW50X29wdHMpLCBjbWRvcHRzKTsKCQkJCXJjID0gc2luZ2xlbW91bnQobXRjdXIsIDApOwoJCQkJZnJlZShtdGN1ci0+bW50X29wdHMpOwoJCQl9CgkJCWdvdG8gY2xlYW5fdXA7CgkJfQoKCQkvKiBJZiB3ZSdyZSB0cnlpbmcgdG8gbW91bnQgc29tZXRoaW5nIHNwZWNpZmljIGFuZCB0aGlzIGlzbid0IGl0LAoJCSAqIHNraXAgaXQuICBOb3RlIHdlIG11c3QgbWF0Y2ggYm90aCB0aGUgZXhhY3QgdGV4dCBpbiBmc3RhYiAoYWxhCgkJICogInByb2MiKSBvciBhIGZ1bGwgcGF0aCBmcm9tIHJvb3QgKi8KCgkJaWYgKGFyZ2MpIHsKCgkJCS8vIElzIHRoaXMgd2hhdCB3ZSdyZSBsb29raW5nIGZvcj8KCgkJCWlmIChzdHJjbXAoYXJndlswXSwgbXRjdXItPm1udF9mc25hbWUpICYmCgkJCSAgIHN0cmNtcChzdG9yYWdlX3BhdGgsIG10Y3VyLT5tbnRfZnNuYW1lKSAmJgoJCQkgICBzdHJjbXAoYXJndlswXSwgbXRjdXItPm1udF9kaXIpICYmCgkJCSAgIHN0cmNtcChzdG9yYWdlX3BhdGgsIG10Y3VyLT5tbnRfZGlyKSkgY29udGludWU7CgoJCQkvLyBSZW1lbWJlciB0aGlzIGVudHJ5LiAgU29tZXRoaW5nIGxhdGVyIG1heSBoYXZlIG92ZXJtb3VudGVkCgkJCS8vIGl0LCBhbmQgd2Ugd2FudCB0aGUgX2xhc3RfIG1hdGNoLgoKCQkJbXRjdXIgPSBtdG5leHQ7CgoJCS8vIElmIHdlJ3JlIG1vdW50aW5nIGFsbC4KCgkJfSBlbHNlIHsKCQkJLy8gRG8gd2UgbmVlZCB0byBtYXRjaCBhIGZpbGVzeXN0ZW0gdHlwZT8KCQkJLy8gVE9ETzogc3VwcG9ydCAiLXQgdHlwZTEsdHlwZTIiOyAiLXQgbm90eXBlMSx0eXBlMiIKCgkJCWlmIChmc3R5cGUgJiYgc3RyY21wKG10Y3VyLT5tbnRfdHlwZSwgZnN0eXBlKSkgY29udGludWU7CgoJCQkvLyBTa2lwIG5vYXV0byBhbmQgc3dhcCBhbnl3YXkuCgoJCQlpZiAocGFyc2VfbW91bnRfb3B0aW9ucyhtdGN1ci0+bW50X29wdHMsIDApCgkJCQkmIChNT1VOVF9OT0FVVE8gfCBNT1VOVF9TV0FQKSkgY29udGludWU7CgoJCQkvLyBObywgbW91bnQgLWEgd29uJ3QgbW91bnQgYW55dGhpbmcsCgkJCS8vIGV2ZW4gdXNlciBtb3VudHMsIGZvciBtZXJlIGh1bWFucy4KCgkJCWlmIChub25yb290KQoJCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUobXVzdF9iZV9yb290KTsKCgkJCS8vIE1vdW50IHRoaXMgdGhpbmcuCgoJCQlpZiAoc2luZ2xlbW91bnQobXRjdXIsIDEpKSB7CgkJCQkvKiBDb3VudCBudW1iZXIgb2YgZmFpbGVkIG1vdW50cyAqLwoJCQkJcmMrKzsKCQkJfQoJCX0KCX0KCWlmIChFTkFCTEVfRkVBVFVSRV9DTEVBTl9VUCkgZW5kbW50ZW50KGZzdGFiKTsKCmNsZWFuX3VwOgoKCWlmIChFTkFCTEVfRkVBVFVSRV9DTEVBTl9VUCkgewoJCWZyZWUoc3RvcmFnZV9wYXRoKTsKCQlmcmVlKGNtZG9wdHMpOwoJfQoKCXJldHVybiByYzsKfQo=