Lyogdmk6IHNldCBzdz00IHRzPTQ6ICovCi8qCiAqIG5mc21vdW50LmMgLS0gTGludXggTkZTIG1vdW50CiAqIENvcHlyaWdodCAoQykgMTk5MyBSaWNrIFNsYWRrZXkgPGpyc0B3b3JsZC5zdGQuY29tPgogKgogKiBMaWNlbnNlZCB1bmRlciBHUEx2MiBvciBsYXRlciwgc2VlIGZpbGUgTElDRU5TRSBpbiB0aGlzIHRhcmJhbGwgZm9yIGRldGFpbHMuCiAqCiAqIFdlZCBGZWIgIDggMTI6NTE6NDggMTk5NSwgYmlyb0B5Z2dkcmFzaWwuY29tIChSb3NzIEJpcm8pOiBhbGxvdyBhbGwgcG9ydAogKiBudW1iZXJzIHRvIGJlIHNwZWNpZmllZCBvbiB0aGUgY29tbWFuZCBsaW5lLgogKgogKiBGcmksIDggTWFyIDE5OTYgMTg6MDE6MzksIFN3ZW4gVGh1ZW1tbGVyIDxzd2VuQHVuaS1wYWRlcmJvcm4uZGU+OgogKiBPbWl0IHRoZSBjYWxsIHRvIGNvbm5lY3QoKSBmb3IgTGludXggdmVyc2lvbiAxLjMuMTEgb3IgbGF0ZXIuCiAqCiAqIFdlZCBPY3QgIDEgMjM6NTU6MjggMTk5NzogRGljayBTdHJlZWZsYW5kIDxkaWNrX3N0cmVlZmxhbmRAdGFza2luZy5jb20+CiAqIEltcGxlbWVudGVkIHRoZSAiYmciLCAiZmciIGFuZCAicmV0cnkiIG1vdW50IG9wdGlvbnMgZm9yIE5GUy4KICoKICogMTk5OS0wMi0yMiBBcmthZGl1c3ogTWm2a2lld2ljeiA8bWlzaWVrQG1pc2llay5ldS5vcmc+CiAqIC0gYWRkZWQgTmF0aXZlIExhbmd1YWdlIFN1cHBvcnQKICoKICogTW9kaWZpZWQgYnkgT2xhZiBLaXJjaCBhbmQgVHJvbmQgTXlrbGVidXN0IGZvciBuZXcgTkZTIGNvZGUsCiAqIHBsdXMgTkZTdjMgc3R1ZmYuCiAqLwoKLyoKICogbmZzbW91bnQuYyx2IDEuMS4xLjEgMTk5My8xMS8xOCAwODo0MDo1MSBqcnMgRXhwCiAqLwoKI2luY2x1ZGUgImJ1c3lib3guaCIKI2luY2x1ZGUgPHN5cy91dHNuYW1lLmg+CiN1bmRlZiBUUlVFCiN1bmRlZiBGQUxTRQojaW5jbHVkZSA8cnBjL3JwYy5oPgojaW5jbHVkZSA8cnBjL3BtYXBfcHJvdC5oPgojaW5jbHVkZSA8cnBjL3BtYXBfY2xudC5oPgojaW5jbHVkZSAibmZzbW91bnQuaCIKCi8qIFRoaXMgaXMganVzdCBhIHdhcm5pbmcgb2YgYSBjb21tb24gbWlzdGFrZS4gIFBvc3NpYmx5IHRoaXMgc2hvdWxkIGJlIGEKICogdWNsaWJjIGZhcSBlbnRyeSByYXRoZXIgdGhhbiBpbiBidXN5Ym94Li4uICovCiNpZiBFTkFCTEVfRkVBVFVSRV9NT1VOVF9ORlMgJiYgZGVmaW5lZChfX1VDTElCQ19fKSAmJiAhIGRlZmluZWQoX19VQ0xJQkNfSEFTX1JQQ19fKQojZXJyb3IgIllvdSBuZWVkIHRvIGJ1aWxkIHVDbGliYyB3aXRoIFVDTElCQ19IQVNfUlBDIGZvciBORlMgc3VwcG9ydC4iCiNlbmRpZgoKCgoKZW51bSB7CiNpZm5kZWYgTkZTX0ZIU0laRQoJTkZTX0ZIU0laRSA9IDMyLAojZW5kaWYKI2lmbmRlZiBORlNfUE9SVAoJTkZTX1BPUlQgPSAyMDQ5CiNlbmRpZgp9OwoKLyogRGlzYWJsZSB0aGUgbmxzIHN0dWZmICovCi8vIyB1bmRlZiBiaW5kdGV4dGRvbWFpbgovLyMgZGVmaW5lIGJpbmR0ZXh0ZG9tYWluKERvbWFpbiwgRGlyZWN0b3J5KSAvKiBlbXB0eSAqLwovLyMgdW5kZWYgdGV4dGRvbWFpbgovLyMgZGVmaW5lIHRleHRkb21haW4oRG9tYWluKSAvKiBlbXB0eSAqLwoKLy9lbnVtIHsKLy8JU19RVU9UQSA9IDEyOCwgICAgIC8qIFF1b3RhIGluaXRpYWxpemVkIGZvciBmaWxlL2RpcmVjdG9yeS9zeW1saW5rICovCi8vfTsKCgovKgogKiBXZSB3YW50IHRvIGJlIGFibGUgdG8gY29tcGlsZSBtb3VudCBvbiBvbGQga2VybmVscyBpbiBzdWNoIGEgd2F5CiAqIHRoYXQgdGhlIGJpbmFyeSB3aWxsIHdvcmsgd2VsbCBvbiBtb3JlIHJlY2VudCBrZXJuZWxzLgogKiBUaHVzLCBpZiBuZWNlc3Nhcnkgd2UgdGVhY2ggbmZzbW91bnQuYyB0aGUgc3RydWN0dXJlIG9mIG5ldyBmaWVsZHMKICogdGhhdCB3aWxsIGNvbWUgbGF0ZXIuCiAqCiAqIE1vcmVvdmVyLCB0aGUgbmV3IGtlcm5lbCBpbmNsdWRlcyBjb25mbGljdCB3aXRoIGdsaWJjIGluY2x1ZGVzCiAqIHNvIGl0IGlzIGVhc2llc3QgdG8gaWdub3JlIHRoZSBrZXJuZWwgYWx0b2dldGhlciAoYXQgY29tcGlsZSB0aW1lKS4KICovCgpzdHJ1Y3QgbmZzMl9maCB7CgljaGFyICAgICAgICAgICAgICAgICAgICBkYXRhWzMyXTsKfTsKc3RydWN0IG5mczNfZmggewoJdW5zaWduZWQgc2hvcnQgICAgICAgICAgc2l6ZTsKCXVuc2lnbmVkIGNoYXIgICAgICAgICAgIGRhdGFbNjRdOwp9OwoKc3RydWN0IG5mc19tb3VudF9kYXRhIHsKCWludAkJdmVyc2lvbjsJCS8qIDEgKi8KCWludAkJZmQ7CQkJLyogMSAqLwoJc3RydWN0IG5mczJfZmgJb2xkX3Jvb3Q7CQkvKiAxICovCglpbnQJCWZsYWdzOwkJCS8qIDEgKi8KCWludAkJcnNpemU7CQkJLyogMSAqLwoJaW50CQl3c2l6ZTsJCQkvKiAxICovCglpbnQJCXRpbWVvOwkJCS8qIDEgKi8KCWludAkJcmV0cmFuczsJCS8qIDEgKi8KCWludAkJYWNyZWdtaW47CQkvKiAxICovCglpbnQJCWFjcmVnbWF4OwkJLyogMSAqLwoJaW50CQlhY2Rpcm1pbjsJCS8qIDEgKi8KCWludAkJYWNkaXJtYXg7CQkvKiAxICovCglzdHJ1Y3Qgc29ja2FkZHJfaW4gYWRkcjsJCS8qIDEgKi8KCWNoYXIJCWhvc3RuYW1lWzI1Nl07CQkvKiAxICovCglpbnQJCW5hbWxlbjsJCQkvKiAyICovCgl1bnNpZ25lZCBpbnQJYnNpemU7CQkJLyogMyAqLwoJc3RydWN0IG5mczNfZmgJcm9vdDsJCQkvKiA0ICovCn07CgovKiBiaXRzIGluIHRoZSBmbGFncyBmaWVsZCAqLwplbnVtIHsKCU5GU19NT1VOVF9TT0ZUID0gMHgwMDAxLAkvKiAxICovCglORlNfTU9VTlRfSU5UUiA9IDB4MDAwMiwJLyogMSAqLwoJTkZTX01PVU5UX1NFQ1VSRSA9IDB4MDAwNCwJLyogMSAqLwoJTkZTX01PVU5UX1BPU0lYID0gMHgwMDA4LAkvKiAxICovCglORlNfTU9VTlRfTk9DVE8gPSAweDAwMTAsCS8qIDEgKi8KCU5GU19NT1VOVF9OT0FDID0gMHgwMDIwLAkvKiAxICovCglORlNfTU9VTlRfVENQID0gMHgwMDQwLAkJLyogMiAqLwoJTkZTX01PVU5UX1ZFUjMgPSAweDAwODAsCS8qIDMgKi8KCU5GU19NT1VOVF9LRVJCRVJPUyA9IDB4MDEwMCwJLyogMyAqLwoJTkZTX01PVU5UX05PTkxNID0gMHgwMjAwCS8qIDMgKi8KfTsKCgojZGVmaW5lIFVUSUxfTElOVVhfVkVSU0lPTiAiMi4xMG0iCiNkZWZpbmUgdXRpbF9saW51eF92ZXJzaW9uICJ1dGlsLWxpbnV4LTIuMTBtIgoKI2RlZmluZSBIQVZFX2luZXRfYXRvbgojZGVmaW5lIEhBVkVfc2NzaV9oCiNkZWZpbmUgSEFWRV9ibGtwZ19oCiNkZWZpbmUgSEFWRV9rZF9oCiNkZWZpbmUgSEFWRV90ZXJtY2FwCiNkZWZpbmUgSEFWRV9sb2NhbGVfaAojZGVmaW5lIEhBVkVfbGliaW50bF9oCiNkZWZpbmUgRU5BQkxFX05MUwojZGVmaW5lIEhBVkVfbGFuZ2luZm9faAojZGVmaW5lIEhBVkVfcHJvZ25hbWUKI2RlZmluZSBIQVZFX29wZW5wdHkKI2RlZmluZSBIQVZFX25hbm9zbGVlcAojZGVmaW5lIEhBVkVfcGVyc29uYWxpdHkKI2RlZmluZSBIQVZFX3RtX2dtdG9mZgoKc3RhdGljIGNoYXIgKm5mc19zdHJlcnJvcihpbnQgc3RhdHVzKTsKCiNkZWZpbmUgTUFYX05GU1BST1QgKChuZnNfbW91bnRfdmVyc2lvbiA+PSA0KSA/IDMgOiAyKQoKZW51bSB7CglFWF9GQUlMID0gMzIsICAgICAgIC8qIG1vdW50IGZhaWx1cmUgKi8KCUVYX0JHID0gMjU2ICAgICAgICAvKiByZXRyeSBpbiBiYWNrZ3JvdW5kIChpbnRlcm5hbCBvbmx5KSAqLwp9OwoKCi8qCiAqIG5mc19tb3VudF92ZXJzaW9uIGFjY29yZGluZyB0byB0aGUgc291cmNlcyBzZWVuIGF0IGNvbXBpbGUgdGltZS4KICovCnN0YXRpYyBpbnQgbmZzX21vdW50X3ZlcnNpb247CgovKgogKiBVbmZvcnR1bmF0ZWx5LCB0aGUga2VybmVsIHByaW50cyBhbm5veWluZyBjb25zb2xlIG1lc3NhZ2VzCiAqIGluIGNhc2Ugb2YgYW4gdW5leHBlY3RlZCBuZnMgbW91bnQgdmVyc2lvbiAoaW5zdGVhZCBvZgogKiBqdXN0IHJldHVybmluZyBzb21lIGVycm9yKS4gIFRoZXJlZm9yZSB3ZSdsbCBoYXZlIHRvIHRyeQogKiBhbmQgZmlndXJlIG91dCB3aGF0IHZlcnNpb24gdGhlIGtlcm5lbCBleHBlY3RzLgogKgogKiBWYXJpYWJsZXM6CiAqCUtFUk5FTF9ORlNfTU9VTlRfVkVSU0lPTjoga2VybmVsIHNvdXJjZXMgYXQgY29tcGlsZSB0aW1lCiAqCU5GU19NT1VOVF9WRVJTSU9OOiB0aGVzZSBuZnNtb3VudCBzb3VyY2VzIGF0IGNvbXBpbGUgdGltZQogKgluZnNfbW91bnRfdmVyc2lvbjogdmVyc2lvbiB0aGlzIHNvdXJjZSBhbmQgcnVubmluZyBrZXJuZWwgY2FuIGhhbmRsZQogKi8Kc3RhdGljIHZvaWQKZmluZF9rZXJuZWxfbmZzX21vdW50X3ZlcnNpb24odm9pZCkKewoJc3RhdGljIGludCBrZXJuZWxfdmVyc2lvbiA9IDA7CgoJaWYgKGtlcm5lbF92ZXJzaW9uKQoJCXJldHVybjsKCgluZnNfbW91bnRfdmVyc2lvbiA9IDQ7IC8qIGRlZmF1bHQgKi8KCglrZXJuZWxfdmVyc2lvbiA9IGdldF9saW51eF92ZXJzaW9uX2NvZGUoKTsKCWlmIChrZXJuZWxfdmVyc2lvbikgewoJCWlmIChrZXJuZWxfdmVyc2lvbiA8IEtFUk5FTF9WRVJTSU9OKDIsMSwzMikpCgkJCW5mc19tb3VudF92ZXJzaW9uID0gMTsKCQllbHNlIGlmIChrZXJuZWxfdmVyc2lvbiA8IEtFUk5FTF9WRVJTSU9OKDIsMiwxOCkgfHwKCQkJCShrZXJuZWxfdmVyc2lvbiA+PSAgIEtFUk5FTF9WRVJTSU9OKDIsMywwKSAmJgoJCQkJIGtlcm5lbF92ZXJzaW9uIDwgS0VSTkVMX1ZFUlNJT04oMiwzLDk5KSkpCgkJCW5mc19tb3VudF92ZXJzaW9uID0gMzsKCQllbHNlCgkJCW5mc19tb3VudF92ZXJzaW9uID0gNDsgLyogc2luY2UgMi4zLjk5cHJlNCAqLwoJfQoJaWYgKG5mc19tb3VudF92ZXJzaW9uID4gNCkKCQluZnNfbW91bnRfdmVyc2lvbiA9IDQ7Cn0KCnN0YXRpYyBzdHJ1Y3QgcG1hcCAqCmdldF9tb3VudHBvcnQoc3RydWN0IHNvY2thZGRyX2luICpzZXJ2ZXJfYWRkciwKICAgICAgbG9uZyB1bnNpZ25lZCBwcm9nLAogICAgICBsb25nIHVuc2lnbmVkIHZlcnNpb24sCiAgICAgIGxvbmcgdW5zaWduZWQgcHJvdG8sCiAgICAgIGxvbmcgdW5zaWduZWQgcG9ydCkKewpzdHJ1Y3QgcG1hcGxpc3QgKnBtYXA7CnN0YXRpYyBzdHJ1Y3QgcG1hcCBwID0gezAsIDAsIDAsIDB9OwoKc2VydmVyX2FkZHItPnNpbl9wb3J0ID0gUE1BUFBPUlQ7CnBtYXAgPSBwbWFwX2dldG1hcHMoc2VydmVyX2FkZHIpOwoKaWYgKHZlcnNpb24gPiBNQVhfTkZTUFJPVCkKCXZlcnNpb24gPSBNQVhfTkZTUFJPVDsKaWYgKCFwcm9nKQoJcHJvZyA9IE1PVU5UUFJPRzsKcC5wbV9wcm9nID0gcHJvZzsKcC5wbV92ZXJzID0gdmVyc2lvbjsKcC5wbV9wcm90ID0gcHJvdG87CnAucG1fcG9ydCA9IHBvcnQ7Cgp3aGlsZSAocG1hcCkgewoJaWYgKHBtYXAtPnBtbF9tYXAucG1fcHJvZyAhPSBwcm9nKQoJCWdvdG8gbmV4dDsKCWlmICghdmVyc2lvbiAmJiBwLnBtX3ZlcnMgPiBwbWFwLT5wbWxfbWFwLnBtX3ZlcnMpCgkJZ290byBuZXh0OwoJaWYgKHZlcnNpb24gPiAyICYmIHBtYXAtPnBtbF9tYXAucG1fdmVycyAhPSB2ZXJzaW9uKQoJCWdvdG8gbmV4dDsKCWlmICh2ZXJzaW9uICYmIHZlcnNpb24gPD0gMiAmJiBwbWFwLT5wbWxfbWFwLnBtX3ZlcnMgPiAyKQoJCWdvdG8gbmV4dDsKCWlmIChwbWFwLT5wbWxfbWFwLnBtX3ZlcnMgPiBNQVhfTkZTUFJPVCB8fAoJICAgIChwcm90byAmJiBwLnBtX3Byb3QgJiYgcG1hcC0+cG1sX21hcC5wbV9wcm90ICE9IHByb3RvKSB8fAoJICAgIChwb3J0ICYmIHBtYXAtPnBtbF9tYXAucG1fcG9ydCAhPSBwb3J0KSkKCQlnb3RvIG5leHQ7CgltZW1jcHkoJnAsICZwbWFwLT5wbWxfbWFwLCBzaXplb2YocCkpOwpuZXh0OgoJcG1hcCA9IHBtYXAtPnBtbF9uZXh0Owp9CmlmICghcC5wbV92ZXJzKQoJcC5wbV92ZXJzID0gTU9VTlRWRVJTOwppZiAoIXAucG1fcG9ydCkKCXAucG1fcG9ydCA9IE1PVU5UUE9SVDsKaWYgKCFwLnBtX3Byb3QpCglwLnBtX3Byb3QgPSBJUFBST1RPX1RDUDsKcmV0dXJuICZwOwp9CgppbnQgbmZzbW91bnQoY29uc3QgY2hhciAqc3BlYywgY29uc3QgY2hhciAqbm9kZSwgaW50ICpmbGFncywKCSAgICAgY2hhciAqKm1vdW50X29wdHMsIGludCBydW5uaW5nX2JnKQp7CglzdGF0aWMgY2hhciAqcHJldl9iZ19ob3N0OwoJY2hhciBob3N0ZGlyWzEwMjRdOwoJQ0xJRU5UICptY2xpZW50OwoJY2hhciAqaG9zdG5hbWU7CgljaGFyICpwYXRobmFtZTsKCWNoYXIgKm9sZF9vcHRzOwoJY2hhciAqbW91bnRob3N0PU5VTEw7CgljaGFyIG5ld19vcHRzWzEwMjRdOwoJc3RydWN0IHRpbWV2YWwgdG90YWxfdGltZW91dDsKCWVudW0gY2xudF9zdGF0IGNsbnRfc3RhdDsKCXN0cnVjdCBuZnNfbW91bnRfZGF0YSBkYXRhOwoJY2hhciAqb3B0LCAqb3B0ZXE7CglpbnQgdmFsOwoJc3RydWN0IGhvc3RlbnQgKmhwOwoJc3RydWN0IHNvY2thZGRyX2luIHNlcnZlcl9hZGRyOwoJc3RydWN0IHNvY2thZGRyX2luIG1vdW50X3NlcnZlcl9hZGRyOwoJc3RydWN0IHBtYXAqIHBtX21udDsKCWludCBtc29jaywgZnNvY2s7CglzdHJ1Y3QgdGltZXZhbCByZXRyeV90aW1lb3V0OwoJdW5pb24gewoJCXN0cnVjdCBmaHN0YXR1cyBuZnN2MjsKCQlzdHJ1Y3QgbW91bnRyZXMzIG5mc3YzOwoJfSBzdGF0dXM7CglzdHJ1Y3Qgc3RhdCBzdGF0YnVmOwoJY2hhciAqczsKCWludCBwb3J0OwoJaW50IG1vdW50cG9ydDsKCWludCBwcm90bzsKCWludCBiZzsKCWludCBzb2Z0OwoJaW50IGludHI7CglpbnQgcG9zaXg7CglpbnQgbm9jdG87CglpbnQgbm9hYzsKCWludCBub2xvY2s7CglpbnQgcmV0cnk7CglpbnQgdGNwOwoJaW50IG1vdW50cHJvZzsKCWludCBtb3VudHZlcnM7CglpbnQgbmZzcHJvZzsKCWludCBuZnN2ZXJzOwoJaW50IHJldHZhbDsKCXRpbWVfdCB0OwoJdGltZV90IHByZXZ0OwoJdGltZV90IHRpbWVvdXQ7CgoJZmluZF9rZXJuZWxfbmZzX21vdW50X3ZlcnNpb24oKTsKCglyZXR2YWwgPSBFWF9GQUlMOwoJbXNvY2sgPSBmc29jayA9IC0xOwoJbWNsaWVudCA9IE5VTEw7CglpZiAoc3RybGVuKHNwZWMpID49IHNpemVvZihob3N0ZGlyKSkgewoJCWJiX2Vycm9yX21zZygiZXhjZXNzaXZlbHkgbG9uZyBob3N0OmRpciBhcmd1bWVudCIpOwoJCWdvdG8gZmFpbDsKCX0KCXN0cmNweShob3N0ZGlyLCBzcGVjKTsKCWlmICgocyA9IHN0cmNocihob3N0ZGlyLCAnOicpKSkgewoJCWhvc3RuYW1lID0gaG9zdGRpcjsKCQlwYXRobmFtZSA9IHMgKyAxOwoJCSpzID0gJ1wwJzsKCQkvKiBJZ25vcmUgYWxsIGJ1dCBmaXJzdCBob3N0bmFtZSBpbiByZXBsaWNhdGVkIG1vdW50cwoJCSAgIHVudGlsIHRoZXkgY2FuIGJlIGZ1bGx5IHN1cHBvcnRlZC4gKG1hY2tAc2dpLmNvbSkgKi8KCQlpZiAoKHMgPSBzdHJjaHIoaG9zdGRpciwgJywnKSkpIHsKCQkJKnMgPSAnXDAnOwoJCQliYl9lcnJvcl9tc2coIndhcm5pbmc6IG11bHRpcGxlIGhvc3RuYW1lcyBub3Qgc3VwcG9ydGVkIik7CgkJfQoJfSBlbHNlIHsKCQliYl9lcnJvcl9tc2coImRpcmVjdG9yeSB0byBtb3VudCBub3QgaW4gaG9zdDpkaXIgZm9ybWF0Iik7CgkJZ290byBmYWlsOwoJfQoKCXNlcnZlcl9hZGRyLnNpbl9mYW1pbHkgPSBBRl9JTkVUOwojaWZkZWYgSEFWRV9pbmV0X2F0b24KCWlmICghaW5ldF9hdG9uKGhvc3RuYW1lLCAmc2VydmVyX2FkZHIuc2luX2FkZHIpKQojZW5kaWYKCXsKCQlpZiAoKGhwID0gZ2V0aG9zdGJ5bmFtZShob3N0bmFtZSkpID09IE5VTEwpIHsKCQkJYmJfaGVycm9yX21zZygiJXMiLCBob3N0bmFtZSk7CgkJCWdvdG8gZmFpbDsKCQl9IGVsc2UgewoJCQlpZiAoaHAtPmhfbGVuZ3RoID4gc2l6ZW9mKHN0cnVjdCBpbl9hZGRyKSkgewoJCQkJYmJfZXJyb3JfbXNnKCJnb3QgYmFkIGhwLT5oX2xlbmd0aCIpOwoJCQkJaHAtPmhfbGVuZ3RoID0gc2l6ZW9mKHN0cnVjdCBpbl9hZGRyKTsKCQkJfQoJCQltZW1jcHkoJnNlcnZlcl9hZGRyLnNpbl9hZGRyLAoJCQkgICAgICAgaHAtPmhfYWRkciwgaHAtPmhfbGVuZ3RoKTsKCQl9Cgl9CgoJbWVtY3B5ICgmbW91bnRfc2VydmVyX2FkZHIsICZzZXJ2ZXJfYWRkciwgc2l6ZW9mIChtb3VudF9zZXJ2ZXJfYWRkcikpOwoKCS8qIGFkZCBJUCBhZGRyZXNzIHRvIG10YWIgb3B0aW9ucyBmb3IgdXNlIHdoZW4gdW5tb3VudGluZyAqLwoKCXMgPSBpbmV0X250b2Eoc2VydmVyX2FkZHIuc2luX2FkZHIpOwoJb2xkX29wdHMgPSAqbW91bnRfb3B0czsKCWlmICghb2xkX29wdHMpCgkJb2xkX29wdHMgPSAiIjsKCWlmIChzdHJsZW4ob2xkX29wdHMpICsgc3RybGVuKHMpICsgMTAgPj0gc2l6ZW9mKG5ld19vcHRzKSkgewoJCWJiX2Vycm9yX21zZygiZXhjZXNzaXZlbHkgbG9uZyBvcHRpb24gYXJndW1lbnQiKTsKCQlnb3RvIGZhaWw7Cgl9CglzcHJpbnRmKG5ld19vcHRzLCAiJXMlc2FkZHI9JXMiLAoJCW9sZF9vcHRzLCAqb2xkX29wdHMgPyAiLCIgOiAiIiwgcyk7CgkqbW91bnRfb3B0cyA9IHhzdHJkdXAobmV3X29wdHMpOwoKCS8qIFNldCBkZWZhdWx0IG9wdGlvbnMuCgkgKiByc2l6ZS93c2l6ZSAoYW5kIGJzaXplLCBmb3IgdmVyID49IDMpIGFyZSBsZWZ0IDAgaW4gb3JkZXIgdG8KCSAqIGxldCB0aGUga2VybmVsIGRlY2lkZS4KCSAqIHRpbWVvIGlzIGZpbGxlZCBpbiBhZnRlciB3ZSBrbm93IHdoZXRoZXIgaXQnbGwgYmUgVENQIG9yIFVEUC4gKi8KCW1lbXNldCgmZGF0YSwgMCwgc2l6ZW9mKGRhdGEpKTsKCWRhdGEucmV0cmFucwk9IDM7CglkYXRhLmFjcmVnbWluCT0gMzsKCWRhdGEuYWNyZWdtYXgJPSA2MDsKCWRhdGEuYWNkaXJtaW4JPSAzMDsKCWRhdGEuYWNkaXJtYXgJPSA2MDsKCWRhdGEubmFtbGVuCT0gTkFNRV9NQVg7CgoJYmcgPSAwOwoJc29mdCA9IDA7CglpbnRyID0gMDsKCXBvc2l4ID0gMDsKCW5vY3RvID0gMDsKCW5vbG9jayA9IDA7Cglub2FjID0gMDsKCXJldHJ5ID0gMTAwMDA7CQkvKiAxMDAwMCBtaW51dGVzIH4gMSB3ZWVrICovCgl0Y3AgPSAwOwoKCW1vdW50cHJvZyA9IE1PVU5UUFJPRzsKCW1vdW50dmVycyA9IDA7Cglwb3J0ID0gMDsKCW1vdW50cG9ydCA9IDA7CgluZnNwcm9nID0gMTAwMDAzOwoJbmZzdmVycyA9IDA7CgoJLyogcGFyc2Ugb3B0aW9ucyAqLwoKCWZvciAob3B0ID0gc3RydG9rKG9sZF9vcHRzLCAiLCIpOyBvcHQ7IG9wdCA9IHN0cnRvayhOVUxMLCAiLCIpKSB7CgkJaWYgKChvcHRlcSA9IHN0cmNocihvcHQsICc9JykpKSB7CgkJCXZhbCA9IGF0b2kob3B0ZXEgKyAxKTsKCQkJKm9wdGVxID0gJ1wwJzsKCQkJaWYgKCFzdHJjbXAob3B0LCAicnNpemUiKSkKCQkJCWRhdGEucnNpemUgPSB2YWw7CgkJCWVsc2UgaWYgKCFzdHJjbXAob3B0LCAid3NpemUiKSkKCQkJCWRhdGEud3NpemUgPSB2YWw7CgkJCWVsc2UgaWYgKCFzdHJjbXAob3B0LCAidGltZW8iKSkKCQkJCWRhdGEudGltZW8gPSB2YWw7CgkJCWVsc2UgaWYgKCFzdHJjbXAob3B0LCAicmV0cmFucyIpKQoJCQkJZGF0YS5yZXRyYW5zID0gdmFsOwoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgImFjcmVnbWluIikpCgkJCQlkYXRhLmFjcmVnbWluID0gdmFsOwoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgImFjcmVnbWF4IikpCgkJCQlkYXRhLmFjcmVnbWF4ID0gdmFsOwoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgImFjZGlybWluIikpCgkJCQlkYXRhLmFjZGlybWluID0gdmFsOwoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgImFjZGlybWF4IikpCgkJCQlkYXRhLmFjZGlybWF4ID0gdmFsOwoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgImFjdGltZW8iKSkgewoJCQkJZGF0YS5hY3JlZ21pbiA9IHZhbDsKCQkJCWRhdGEuYWNyZWdtYXggPSB2YWw7CgkJCQlkYXRhLmFjZGlybWluID0gdmFsOwoJCQkJZGF0YS5hY2Rpcm1heCA9IHZhbDsKCQkJfQoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgInJldHJ5IikpCgkJCQlyZXRyeSA9IHZhbDsKCQkJZWxzZSBpZiAoIXN0cmNtcChvcHQsICJwb3J0IikpCgkJCQlwb3J0ID0gdmFsOwoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgIm1vdW50cG9ydCIpKQoJCQkgICAgICAgIG1vdW50cG9ydCA9IHZhbDsKCQkJZWxzZSBpZiAoIXN0cmNtcChvcHQsICJtb3VudGhvc3QiKSkKCQkJICAgICAgICBtb3VudGhvc3Q9eHN0cm5kdXAob3B0ZXErMSwKCQkJCQkJICBzdHJjc3BuKG9wdGVxKzEsIiBcdFxuXHIsIikpOwoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgIm1vdW50cHJvZyIpKQoJCQkJbW91bnRwcm9nID0gdmFsOwoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgIm1vdW50dmVycyIpKQoJCQkJbW91bnR2ZXJzID0gdmFsOwoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgIm5mc3Byb2ciKSkKCQkJCW5mc3Byb2cgPSB2YWw7CgkJCWVsc2UgaWYgKCFzdHJjbXAob3B0LCAibmZzdmVycyIpIHx8CgkJCQkgIXN0cmNtcChvcHQsICJ2ZXJzIikpCgkJCQluZnN2ZXJzID0gdmFsOwoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgInByb3RvIikpIHsKCQkJCWlmICghc3RybmNtcChvcHRlcSsxLCAidGNwIiwgMykpCgkJCQkJdGNwID0gMTsKCQkJCWVsc2UgaWYgKCFzdHJuY21wKG9wdGVxKzEsICJ1ZHAiLCAzKSkKCQkJCQl0Y3AgPSAwOwoJCQkJZWxzZQoJCQkJCXByaW50ZigiV2FybmluZzogVW5yZWNvZ25pemVkIHByb3RvPSBvcHRpb24uXG4iKTsKCQkJfSBlbHNlIGlmICghc3RyY21wKG9wdCwgIm5hbWxlbiIpKSB7CgkJCQlpZiAobmZzX21vdW50X3ZlcnNpb24gPj0gMikKCQkJCQlkYXRhLm5hbWxlbiA9IHZhbDsKCQkJCWVsc2UKCQkJCXByaW50ZigiV2FybmluZzogT3B0aW9uIG5hbWxlbiBpcyBub3Qgc3VwcG9ydGVkLlxuIik7CgkJCX0gZWxzZSBpZiAoIXN0cmNtcChvcHQsICJhZGRyIikpCgkJCQkvKiBpZ25vcmUgKi87CgkJCWVsc2UgewoJCQkJcHJpbnRmKCJ1bmtub3duIG5mcyBtb3VudCBwYXJhbWV0ZXI6ICVzPSVkXG4iLCBvcHQsIHZhbCk7CgkJCQlnb3RvIGZhaWw7CgkJCX0KCQl9CgkJZWxzZSB7CgkJCXZhbCA9IDE7CgkJCWlmICghc3RybmNtcChvcHQsICJubyIsIDIpKSB7CgkJCQl2YWwgPSAwOwoJCQkJb3B0ICs9IDI7CgkJCX0KCQkJaWYgKCFzdHJjbXAob3B0LCAiYmciKSkKCQkJCWJnID0gdmFsOwoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgImZnIikpCgkJCQliZyA9ICF2YWw7CgkJCWVsc2UgaWYgKCFzdHJjbXAob3B0LCAic29mdCIpKQoJCQkJc29mdCA9IHZhbDsKCQkJZWxzZSBpZiAoIXN0cmNtcChvcHQsICJoYXJkIikpCgkJCQlzb2Z0ID0gIXZhbDsKCQkJZWxzZSBpZiAoIXN0cmNtcChvcHQsICJpbnRyIikpCgkJCQlpbnRyID0gdmFsOwoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgInBvc2l4IikpCgkJCQlwb3NpeCA9IHZhbDsKCQkJZWxzZSBpZiAoIXN0cmNtcChvcHQsICJjdG8iKSkKCQkJCW5vY3RvID0gIXZhbDsKCQkJZWxzZSBpZiAoIXN0cmNtcChvcHQsICJhYyIpKQoJCQkJbm9hYyA9ICF2YWw7CgkJCWVsc2UgaWYgKCFzdHJjbXAob3B0LCAidGNwIikpCgkJCQl0Y3AgPSB2YWw7CgkJCWVsc2UgaWYgKCFzdHJjbXAob3B0LCAidWRwIikpCgkJCQl0Y3AgPSAhdmFsOwoJCQllbHNlIGlmICghc3RyY21wKG9wdCwgImxvY2siKSkgewoJCQkJaWYgKG5mc19tb3VudF92ZXJzaW9uID49IDMpCgkJCQkJbm9sb2NrID0gIXZhbDsKCQkJCWVsc2UKCQkJCQlwcmludGYoIldhcm5pbmc6IG9wdGlvbiBub2xvY2sgaXMgbm90IHN1cHBvcnRlZC5cbiIpOwoJCQl9IGVsc2UgewoJCQkJcHJpbnRmKCJ1bmtub3duIG5mcyBtb3VudCBvcHRpb246ICVzJXNcbiIsIHZhbCA/ICIiIDogIm5vIiwgb3B0KTsKCQkJCWdvdG8gZmFpbDsKCQkJfQoJCX0KCX0KCXByb3RvID0gKHRjcCkgPyBJUFBST1RPX1RDUCA6IElQUFJPVE9fVURQOwoKCWRhdGEuZmxhZ3MgPSAoc29mdCA/IE5GU19NT1VOVF9TT0ZUIDogMCkKCQl8IChpbnRyID8gTkZTX01PVU5UX0lOVFIgOiAwKQoJCXwgKHBvc2l4ID8gTkZTX01PVU5UX1BPU0lYIDogMCkKCQl8IChub2N0byA/IE5GU19NT1VOVF9OT0NUTyA6IDApCgkJfCAobm9hYyA/IE5GU19NT1VOVF9OT0FDIDogMCk7CglpZiAobmZzX21vdW50X3ZlcnNpb24gPj0gMikKCQlkYXRhLmZsYWdzIHw9ICh0Y3AgPyBORlNfTU9VTlRfVENQIDogMCk7CglpZiAobmZzX21vdW50X3ZlcnNpb24gPj0gMykKCQlkYXRhLmZsYWdzIHw9IChub2xvY2sgPyBORlNfTU9VTlRfTk9OTE0gOiAwKTsKCWlmIChuZnN2ZXJzID4gTUFYX05GU1BST1QgfHwgbW91bnR2ZXJzID4gTUFYX05GU1BST1QpIHsKCQliYl9lcnJvcl9tc2coIk5GU3YlZCBub3Qgc3VwcG9ydGVkISIsIG5mc3ZlcnMpOwoJCXJldHVybiAxOwoJfQoJaWYgKG5mc3ZlcnMgJiYgIW1vdW50dmVycykKCQltb3VudHZlcnMgPSAobmZzdmVycyA8IDMpID8gMSA6IG5mc3ZlcnM7CglpZiAobmZzdmVycyAmJiBuZnN2ZXJzIDwgbW91bnR2ZXJzKSB7CgkJbW91bnR2ZXJzID0gbmZzdmVyczsKCX0KCgkvKiBBZGp1c3Qgb3B0aW9ucyBpZiBub25lIHNwZWNpZmllZCAqLwoJaWYgKCFkYXRhLnRpbWVvKQoJCWRhdGEudGltZW8gPSB0Y3AgPyA3MCA6IDc7CgojaWZkZWYgTkZTX01PVU5UX0RFQlVHCglwcmludGYoInJzaXplID0gJWQsIHdzaXplID0gJWQsIHRpbWVvID0gJWQsIHJldHJhbnMgPSAlZFxuIiwKCQlkYXRhLnJzaXplLCBkYXRhLndzaXplLCBkYXRhLnRpbWVvLCBkYXRhLnJldHJhbnMpOwoJcHJpbnRmKCJhY3JlZyAobWluLCBtYXgpID0gKCVkLCAlZCksIGFjZGlyIChtaW4sIG1heCkgPSAoJWQsICVkKVxuIiwKCQlkYXRhLmFjcmVnbWluLCBkYXRhLmFjcmVnbWF4LCBkYXRhLmFjZGlybWluLCBkYXRhLmFjZGlybWF4KTsKCXByaW50ZigicG9ydCA9ICVkLCBiZyA9ICVkLCByZXRyeSA9ICVkLCBmbGFncyA9ICUuOHhcbiIsCgkJcG9ydCwgYmcsIHJldHJ5LCBkYXRhLmZsYWdzKTsKCXByaW50ZigibW91bnRwcm9nID0gJWQsIG1vdW50dmVycyA9ICVkLCBuZnNwcm9nID0gJWQsIG5mc3ZlcnMgPSAlZFxuIiwKCQltb3VudHByb2csIG1vdW50dmVycywgbmZzcHJvZywgbmZzdmVycyk7CglwcmludGYoInNvZnQgPSAlZCwgaW50ciA9ICVkLCBwb3NpeCA9ICVkLCBub2N0byA9ICVkLCBub2FjID0gJWRcbiIsCgkJKGRhdGEuZmxhZ3MgJiBORlNfTU9VTlRfU09GVCkgIT0gMCwKCQkoZGF0YS5mbGFncyAmIE5GU19NT1VOVF9JTlRSKSAhPSAwLAoJCShkYXRhLmZsYWdzICYgTkZTX01PVU5UX1BPU0lYKSAhPSAwLAoJCShkYXRhLmZsYWdzICYgTkZTX01PVU5UX05PQ1RPKSAhPSAwLAoJCShkYXRhLmZsYWdzICYgTkZTX01PVU5UX05PQUMpICE9IDApOwoJcHJpbnRmKCJ0Y3AgPSAlZFxuIiwKCQkoZGF0YS5mbGFncyAmIE5GU19NT1VOVF9UQ1ApICE9IDApOwojZW5kaWYKCglkYXRhLnZlcnNpb24gPSBuZnNfbW91bnRfdmVyc2lvbjsKCglpZiAoKmZsYWdzICYgTVNfUkVNT1VOVCkKCQlnb3RvIGNvcHlfZGF0YV9hbmRfcmV0dXJuOwoKCS8qCgkgKiBJZiB0aGUgcHJldmlvdXMgbW91bnQgb3BlcmF0aW9uIG9uIHRoZSBzYW1lIGhvc3Qgd2FzCgkgKiBiYWNrZ3JvdW5kZWQsIGFuZCB0aGUgImJnIiBmb3IgdGhpcyBtb3VudCBpcyBhbHNvIHNldCwKCSAqIGdpdmUgdXAgaW1tZWRpYXRlbHksIHRvIGF2b2lkIHRoZSBpbml0aWFsIHRpbWVvdXQuCgkgKi8KCWlmIChiZyAmJiAhcnVubmluZ19iZyAmJgoJICAgIHByZXZfYmdfaG9zdCAmJiBzdHJjbXAoaG9zdG5hbWUsIHByZXZfYmdfaG9zdCkgPT0gMCkgewoJCWlmIChyZXRyeSA+IDApCgkJCXJldHZhbCA9IEVYX0JHOwoJCXJldHVybiByZXR2YWw7Cgl9CgoJLyogY3JlYXRlIG1vdW50IGRhZW1vbiBjbGllbnQgKi8KCS8qIFNlZSBpZiB0aGUgbmZzIGhvc3QgPSBtb3VudCBob3N0LiAqLwoJaWYgKG1vdW50aG9zdCkgewoJICBpZiAobW91bnRob3N0WzBdID49ICcwJyAmJiBtb3VudGhvc3RbMF0gPD0gJzknKSB7CgkgICAgbW91bnRfc2VydmVyX2FkZHIuc2luX2ZhbWlseSA9IEFGX0lORVQ7CgkgICAgbW91bnRfc2VydmVyX2FkZHIuc2luX2FkZHIuc19hZGRyID0gaW5ldF9hZGRyKGhvc3RuYW1lKTsKCSAgfSBlbHNlIHsKCQkgIGlmICgoaHAgPSBnZXRob3N0YnluYW1lKG1vdW50aG9zdCkpID09IE5VTEwpIHsKCQkJICBiYl9oZXJyb3JfbXNnKCIlcyIsIG1vdW50aG9zdCk7CgkJCSAgZ290byBmYWlsOwoJCSAgfSBlbHNlIHsKCQkJICBpZiAoaHAtPmhfbGVuZ3RoID4gc2l6ZW9mKHN0cnVjdCBpbl9hZGRyKSkgewoJCQkJICBiYl9lcnJvcl9tc2coImdvdCBiYWQgaHAtPmhfbGVuZ3RoPyIpOwoJCQkJICBocC0+aF9sZW5ndGggPSBzaXplb2Yoc3RydWN0IGluX2FkZHIpOwoJCQkgIH0KCQkJICBtb3VudF9zZXJ2ZXJfYWRkci5zaW5fZmFtaWx5ID0gQUZfSU5FVDsKCQkJICBtZW1jcHkoJm1vdW50X3NlcnZlcl9hZGRyLnNpbl9hZGRyLAoJCQkJIGhwLT5oX2FkZHIsIGhwLT5oX2xlbmd0aCk7CgkJICB9CgkgIH0KCX0KCgkvKgoJICogVGhlIGZvbGxvd2luZyBsb29wIGltcGxlbWVudHMgdGhlIG1vdW50IHJldHJpZXMuIE9uIHRoZSBmaXJzdAoJICogY2FsbCwgInJ1bm5pbmdfYmciIGlzIDAuIFdoZW4gdGhlIG1vdW50IHRpbWVzIG91dCwgYW5kIHRoZQoJICogImJnIiBvcHRpb24gaXMgc2V0LCB0aGUgZXhpdCBzdGF0dXMgRVhfQkcgd2lsbCBiZSByZXR1cm5lZC4KCSAqIEZvciBhIGJhY2tncm91bmRlZCBtb3VudCwgdGhlcmUgd2lsbCBiZSBhIHNlY29uZCBjYWxsIGJ5IHRoZQoJICogY2hpbGQgcHJvY2VzcyB3aXRoICJydW5uaW5nX2JnIiBzZXQgdG8gMS4KCSAqCgkgKiBUaGUgY2FzZSB3aGVyZSB0aGUgbW91bnQgcG9pbnQgaXMgbm90IHByZXNlbnQgYW5kIHRoZSAiYmciCgkgKiBvcHRpb24gaXMgc2V0LCBpcyB0cmVhdGVkIGFzIGEgdGltZW91dC4gVGhpcyBpcyBkb25lIHRvCgkgKiBzdXBwb3J0IG5lc3RlZCBtb3VudHMuCgkgKgoJICogVGhlICJyZXRyeSIgY291bnQgc3BlY2lmaWVkIGJ5IHRoZSB1c2VyIGlzIHRoZSBudW1iZXIgb2YKCSAqIG1pbnV0ZXMgdG8gcmV0cnkgYmVmb3JlIGdpdmluZyB1cC4KCSAqCgkgKiBPbmx5IHRoZSBmaXJzdCBlcnJvciBtZXNzYWdlIHdpbGwgYmUgZGlzcGxheWVkLgoJICovCglyZXRyeV90aW1lb3V0LnR2X3NlYyA9IDM7CglyZXRyeV90aW1lb3V0LnR2X3VzZWMgPSAwOwoJdG90YWxfdGltZW91dC50dl9zZWMgPSAyMDsKCXRvdGFsX3RpbWVvdXQudHZfdXNlYyA9IDA7Cgl0aW1lb3V0ID0gdGltZShOVUxMKSArIDYwICogcmV0cnk7CglwcmV2dCA9IDA7Cgl0ID0gMzA7Cgl2YWwgPSAxOwoJZm9yICg7OykgewoJCWlmIChiZyAmJiBzdGF0KG5vZGUsICZzdGF0YnVmKSA9PSAtMSkgewoJCQlpZiAocnVubmluZ19iZykgewoJCQkJc2xlZXAodmFsKTsJLyogMSwgMiwgNCwgOCwgMTYsIDMwLCAuLi4gKi8KCQkJCXZhbCAqPSAyOwoJCQkJaWYgKHZhbCA+IDMwKQoJCQkJCXZhbCA9IDMwOwoJCQl9CgkJfSBlbHNlIHsKCQkJLyogYmUgY2FyZWZ1bCBub3QgdG8gdXNlIHRvbyBtYW55IENQVSBjeWNsZXMgKi8KCQkJaWYgKHQgLSBwcmV2dCA8IDMwKQoJCQkJc2xlZXAoMzApOwoKCQkJcG1fbW50ID0gZ2V0X21vdW50cG9ydCgmbW91bnRfc2VydmVyX2FkZHIsCgkJCQkgICAgICAgbW91bnRwcm9nLAoJCQkJICAgICAgIG1vdW50dmVycywKCQkJCSAgICAgICBwcm90bywKCQkJCSAgICAgICBtb3VudHBvcnQpOwoKCQkJLyogY29udGFjdCB0aGUgbW91bnQgZGFlbW9uIHZpYSBUQ1AgKi8KCQkJbW91bnRfc2VydmVyX2FkZHIuc2luX3BvcnQgPSBodG9ucyhwbV9tbnQtPnBtX3BvcnQpOwoJCQltc29jayA9IFJQQ19BTllTT0NLOwoKCQkJc3dpdGNoIChwbV9tbnQtPnBtX3Byb3QpIHsKCQkJY2FzZSBJUFBST1RPX1VEUDoKCQkJCW1jbGllbnQgPSBjbG50dWRwX2NyZWF0ZSgmbW91bnRfc2VydmVyX2FkZHIsCgkJCQkJCSBwbV9tbnQtPnBtX3Byb2csCgkJCQkJCSBwbV9tbnQtPnBtX3ZlcnMsCgkJCQkJCSByZXRyeV90aW1lb3V0LAoJCQkJCQkgJm1zb2NrKTsKCQkgIGlmIChtY2xpZW50KQoJCQkgIGJyZWFrOwoJCSAgbW91bnRfc2VydmVyX2FkZHIuc2luX3BvcnQgPSBodG9ucyhwbV9tbnQtPnBtX3BvcnQpOwoJCSAgbXNvY2sgPSBSUENfQU5ZU09DSzsKCQljYXNlIElQUFJPVE9fVENQOgoJCQltY2xpZW50ID0gY2xudHRjcF9jcmVhdGUoJm1vdW50X3NlcnZlcl9hZGRyLAoJCQkJCQkgcG1fbW50LT5wbV9wcm9nLAoJCQkJCQkgcG1fbW50LT5wbV92ZXJzLAoJCQkJCQkgJm1zb2NrLCAwLCAwKTsKCQkJYnJlYWs7CgkJZGVmYXVsdDoKCQkJbWNsaWVudCA9IDA7CgkJCX0KCQkJaWYgKG1jbGllbnQpIHsKCQkJCS8qIHRyeSB0byBtb3VudCBob3N0bmFtZTpwYXRobmFtZSAqLwoJCQkJbWNsaWVudC0+Y2xfYXV0aCA9IGF1dGh1bml4X2NyZWF0ZV9kZWZhdWx0KCk7CgoJCQkvKiBtYWtlIHBvaW50ZXJzIGluIHhkcl9tb3VudHJlczMgTlVMTCBzbwoJCQkgKiB0aGF0IHhkcl9hcnJheSBhbGxvY2F0ZXMgbWVtb3J5IGZvciB1cwoJCQkgKi8KCQkJbWVtc2V0KCZzdGF0dXMsIDAsIHNpemVvZihzdGF0dXMpKTsKCgkJCWlmIChwbV9tbnQtPnBtX3ZlcnMgPT0gMykKCQkJCWNsbnRfc3RhdCA9IGNsbnRfY2FsbChtY2xpZW50LCBNT1VOVFBST0MzX01OVCwKCQkJCQkJICAgICAgKHhkcnByb2NfdCkgeGRyX2RpcnBhdGgsCgkJCQkJCSAgICAgIChjYWRkcl90KSAmcGF0aG5hbWUsCgkJCQkJCSAgICAgICh4ZHJwcm9jX3QpIHhkcl9tb3VudHJlczMsCgkJCQkJCSAgICAgIChjYWRkcl90KSAmc3RhdHVzLAoJCQkJCXRvdGFsX3RpbWVvdXQpOwoJCQllbHNlCgkJCQljbG50X3N0YXQgPSBjbG50X2NhbGwobWNsaWVudCwgTU9VTlRQUk9DX01OVCwKCQkJCQkJICAgICAgKHhkcnByb2NfdCkgeGRyX2RpcnBhdGgsCgkJCQkJCSAgICAgIChjYWRkcl90KSAmcGF0aG5hbWUsCgkJCQkJCSAgICAgICh4ZHJwcm9jX3QpIHhkcl9maHN0YXR1cywKCQkJCQkJICAgICAgKGNhZGRyX3QpICZzdGF0dXMsCgkJCQkJCSAgICAgIHRvdGFsX3RpbWVvdXQpOwoKCQkJCWlmIChjbG50X3N0YXQgPT0gUlBDX1NVQ0NFU1MpCgkJCQkJYnJlYWs7CQkvKiB3ZSdyZSBkb25lICovCgkJCQlpZiAoZXJybm8gIT0gRUNPTk5SRUZVU0VEKSB7CgkJCQkJY2xudF9wZXJyb3IobWNsaWVudCwgIm1vdW50Iik7CgkJCQkJZ290byBmYWlsOwkvKiBkb24ndCByZXRyeSAqLwoJCQkJfQoJCQkJaWYgKCFydW5uaW5nX2JnICYmIHByZXZ0ID09IDApCgkJCQkJY2xudF9wZXJyb3IobWNsaWVudCwgIm1vdW50Iik7CgkJCQlhdXRoX2Rlc3Ryb3kobWNsaWVudC0+Y2xfYXV0aCk7CgkJCQljbG50X2Rlc3Ryb3kobWNsaWVudCk7CgkJCQltY2xpZW50ID0gMDsKCQkJCWNsb3NlKG1zb2NrKTsKCQkJfSBlbHNlIHsKCQkJCWlmICghcnVubmluZ19iZyAmJiBwcmV2dCA9PSAwKQoJCQkJCWNsbnRfcGNyZWF0ZWVycm9yKCJtb3VudCIpOwoJCQl9CgkJCXByZXZ0ID0gdDsKCQl9CgkJaWYgKCFiZykKCQkgICAgICAgIGdvdG8gZmFpbDsKCQlpZiAoIXJ1bm5pbmdfYmcpIHsKCQkJcHJldl9iZ19ob3N0ID0geHN0cmR1cChob3N0bmFtZSk7CgkJCWlmIChyZXRyeSA+IDApCgkJCQlyZXR2YWwgPSBFWF9CRzsKCQkJZ290byBmYWlsOwoJCX0KCQl0ID0gdGltZShOVUxMKTsKCQlpZiAodCA+PSB0aW1lb3V0KQoJCQlnb3RvIGZhaWw7Cgl9CgluZnN2ZXJzID0gKHBtX21udC0+cG1fdmVycyA8IDIpID8gMiA6IHBtX21udC0+cG1fdmVyczsKCglpZiAobmZzdmVycyA9PSAyKSB7CgkJaWYgKHN0YXR1cy5uZnN2Mi5maHNfc3RhdHVzICE9IDApIHsKCQkJYmJfZXJyb3JfbXNnKCIlczolcyBmYWlsZWQsIHJlYXNvbiBnaXZlbiBieSBzZXJ2ZXI6ICVzIiwKCQkJCWhvc3RuYW1lLCBwYXRobmFtZSwKCQkJCW5mc19zdHJlcnJvcihzdGF0dXMubmZzdjIuZmhzX3N0YXR1cykpOwoJCQlnb3RvIGZhaWw7CgkJfQoJCW1lbWNweShkYXRhLnJvb3QuZGF0YSwKCQkgICAgICAgKGNoYXIgKikgc3RhdHVzLm5mc3YyLmZoc3RhdHVzX3UuZmhzX2ZoYW5kbGUsCgkJICAgICAgIE5GU19GSFNJWkUpOwoJCWRhdGEucm9vdC5zaXplID0gTkZTX0ZIU0laRTsKCQltZW1jcHkoZGF0YS5vbGRfcm9vdC5kYXRhLAoJCSAgICAgICAoY2hhciAqKSBzdGF0dXMubmZzdjIuZmhzdGF0dXNfdS5maHNfZmhhbmRsZSwKCQkgICAgICAgTkZTX0ZIU0laRSk7Cgl9IGVsc2UgewoJCWZoYW5kbGUzICpteV9maGFuZGxlOwoJCWlmIChzdGF0dXMubmZzdjMuZmhzX3N0YXR1cyAhPSAwKSB7CgkJCWJiX2Vycm9yX21zZygiJXM6JXMgZmFpbGVkLCByZWFzb24gZ2l2ZW4gYnkgc2VydmVyOiAlcyIsCgkJCQlob3N0bmFtZSwgcGF0aG5hbWUsCgkJCQluZnNfc3RyZXJyb3Ioc3RhdHVzLm5mc3YzLmZoc19zdGF0dXMpKTsKCQkJZ290byBmYWlsOwoJCX0KCQlteV9maGFuZGxlID0gJnN0YXR1cy5uZnN2My5tb3VudHJlczNfdS5tb3VudGluZm8uZmhhbmRsZTsKCQltZW1zZXQoZGF0YS5vbGRfcm9vdC5kYXRhLCAwLCBORlNfRkhTSVpFKTsKCQltZW1zZXQoJmRhdGEucm9vdCwgMCwgc2l6ZW9mKGRhdGEucm9vdCkpOwoJCWRhdGEucm9vdC5zaXplID0gbXlfZmhhbmRsZS0+ZmhhbmRsZTNfbGVuOwoJCW1lbWNweShkYXRhLnJvb3QuZGF0YSwKCQkgICAgICAgKGNoYXIgKikgbXlfZmhhbmRsZS0+ZmhhbmRsZTNfdmFsLAoJCSAgICAgICBteV9maGFuZGxlLT5maGFuZGxlM19sZW4pOwoKCQlkYXRhLmZsYWdzIHw9IE5GU19NT1VOVF9WRVIzOwoJfQoKCS8qIGNyZWF0ZSBuZnMgc29ja2V0IGZvciBrZXJuZWwgKi8KCglpZiAodGNwKSB7CgkJaWYgKG5mc19tb3VudF92ZXJzaW9uIDwgMykgewoJCQlwcmludGYoIk5GUyBvdmVyIFRDUCBpcyBub3Qgc3VwcG9ydGVkLlxuIik7CgkJCWdvdG8gZmFpbDsKCQl9CgkJZnNvY2sgPSBzb2NrZXQoQUZfSU5FVCwgU09DS19TVFJFQU0sIElQUFJPVE9fVENQKTsKCX0gZWxzZQoJCWZzb2NrID0gc29ja2V0KEFGX0lORVQsIFNPQ0tfREdSQU0sIElQUFJPVE9fVURQKTsKCWlmIChmc29jayA8IDApIHsKCQlwZXJyb3IoIm5mcyBzb2NrZXQiKTsKCQlnb3RvIGZhaWw7Cgl9CglpZiAoYmluZHJlc3Zwb3J0KGZzb2NrLCAwKSA8IDApIHsKCQlwZXJyb3IoIm5mcyBiaW5kcmVzdnBvcnQiKTsKCQlnb3RvIGZhaWw7Cgl9CglpZiAocG9ydCA9PSAwKSB7CgkJc2VydmVyX2FkZHIuc2luX3BvcnQgPSBQTUFQUE9SVDsKCQlwb3J0ID0gcG1hcF9nZXRwb3J0KCZzZXJ2ZXJfYWRkciwgbmZzcHJvZywgbmZzdmVycywKCQkJdGNwID8gSVBQUk9UT19UQ1AgOiBJUFBST1RPX1VEUCk7CgkJaWYgKHBvcnQgPT0gMCkKCQkJcG9ydCA9IE5GU19QT1JUOwojaWZkZWYgTkZTX01PVU5UX0RFQlVHCgkJZWxzZQoJCQlwcmludGYoInVzZWQgcG9ydG1hcHBlciB0byBmaW5kIE5GUyBwb3J0XG4iKTsKI2VuZGlmCgl9CiNpZmRlZiBORlNfTU9VTlRfREVCVUcKCXByaW50ZigidXNpbmcgcG9ydCAlZCBmb3IgbmZzIGRhZW1vblxuIiwgcG9ydCk7CiNlbmRpZgoJc2VydmVyX2FkZHIuc2luX3BvcnQgPSBodG9ucyhwb3J0KTsKCSAvKgoJICAqIGNvbm5lY3QoKSB0aGUgc29ja2V0IGZvciBrZXJuZWxzIDEuMy4xMCBhbmQgYmVsb3cgb25seSwKCSAgKiB0byBhdm9pZCBwcm9ibGVtcyB3aXRoIG11bHRpaG9tZWQgaG9zdHMuCgkgICogLS1Td2VuCgkgICovCglpZiAoZ2V0X2xpbnV4X3ZlcnNpb25fY29kZSgpIDw9IEtFUk5FTF9WRVJTSU9OKDIsMywxMCkKCSAgICAmJiBjb25uZWN0KGZzb2NrLCAoc3RydWN0IHNvY2thZGRyICopICZzZXJ2ZXJfYWRkciwKCQkgICAgICAgc2l6ZW9mIChzZXJ2ZXJfYWRkcikpIDwgMCkgewoJCXBlcnJvcigibmZzIGNvbm5lY3QiKTsKCQlnb3RvIGZhaWw7Cgl9CgoJLyogcHJlcGFyZSBkYXRhIHN0cnVjdHVyZSBmb3Iga2VybmVsICovCgoJZGF0YS5mZCA9IGZzb2NrOwoJbWVtY3B5KChjaGFyICopICZkYXRhLmFkZHIsIChjaGFyICopICZzZXJ2ZXJfYWRkciwgc2l6ZW9mKGRhdGEuYWRkcikpOwoJc3RybmNweShkYXRhLmhvc3RuYW1lLCBob3N0bmFtZSwgc2l6ZW9mKGRhdGEuaG9zdG5hbWUpKTsKCgkvKiBjbGVhbiB1cCAqLwoKCWF1dGhfZGVzdHJveShtY2xpZW50LT5jbF9hdXRoKTsKCWNsbnRfZGVzdHJveShtY2xpZW50KTsKCWNsb3NlKG1zb2NrKTsKY29weV9kYXRhX2FuZF9yZXR1cm46CgkqbW91bnRfb3B0cyA9IHhyZWFsbG9jKCptb3VudF9vcHRzLCBzaXplb2YoZGF0YSkpOwoJbWVtY3B5KCptb3VudF9vcHRzLCAmZGF0YSwgc2l6ZW9mKGRhdGEpKTsKCXJldHVybiAwOwoKCS8qIGFib3J0ICovCgpmYWlsOgoJaWYgKG1zb2NrICE9IC0xKSB7CgkJaWYgKG1jbGllbnQpIHsKCQkJYXV0aF9kZXN0cm95KG1jbGllbnQtPmNsX2F1dGgpOwoJCQljbG50X2Rlc3Ryb3kobWNsaWVudCk7CgkJfQoJCWNsb3NlKG1zb2NrKTsKCX0KCWlmIChmc29jayAhPSAtMSkKCQljbG9zZShmc29jayk7CglyZXR1cm4gcmV0dmFsOwp9CgovKgogKiBXZSBuZWVkIHRvIHRyYW5zbGF0ZSBiZXR3ZWVuIG5mcyBzdGF0dXMgcmV0dXJuIHZhbHVlcyBhbmQKICogdGhlIGxvY2FsIGVycm5vIHZhbHVlcyB3aGljaCBtYXkgbm90IGJlIHRoZSBzYW1lLgogKgogKiBBbmRyZWFzIFNjaHdhYiA8c2Nod2FiQExTNS5pbmZvcm1hdGlrLnVuaS1kb3J0bXVuZC5kZT46IGNoYW5nZSBlcnJubzoKICogImFmdGVyICNpbmNsdWRlIDxlcnJuby5oPiB0aGUgc3ltYm9sIGVycm5vIGlzIHJlc2VydmVkIGZvciBhbnkgdXNlLAogKiAgaXQgY2Fubm90IGV2ZW4gYmUgdXNlZCBhcyBhIHN0cnVjdCB0YWcgb3IgZmllbGQgbmFtZSIuCiAqLwoKI2lmbmRlZiBFRFFVT1QKI2RlZmluZSBFRFFVT1QJRU5PU1BDCiNlbmRpZgoKLy8gQ29udmVydCBlYWNoIE5GU0VSUl9CTEFIIGludG8gRUJMQUgKCnN0YXRpYyBjb25zdCBzdHJ1Y3QgewoJaW50IHN0YXQ7CglpbnQgZXJybnVtOwp9IG5mc19lcnJ0YmxbXSA9IHsKCXswLDB9LCB7MSxFUEVSTX0sIHsyLEVOT0VOVH0sIHs1LEVJT30sIHs2LEVOWElPfSwgezEzLEVBQ0NFU30sIHsxNyxFRVhJU1R9LAoJezE5LEVOT0RFVn0sIHsyMCxFTk9URElSfSwgezIxLEVJU0RJUn0sIHsyMixFSU5WQUx9LCB7MjcsRUZCSUd9LAoJezI4LEVOT1NQQ30sIHszMCxFUk9GU30sIHs2MyxFTkFNRVRPT0xPTkd9LCB7NjYsRU5PVEVNUFRZfSwgezY5LEVEUVVPVH0sCgl7NzAsRVNUQUxFfSwgezcxLEVSRU1PVEV9LCB7LTEsRUlPfQp9OwoKCnN0YXRpYyBjaGFyICpuZnNfc3RyZXJyb3IoaW50IHN0YXR1cykKewoJaW50IGk7CglzdGF0aWMgY2hhciBidWZbMjU2XTsKCglmb3IgKGkgPSAwOyBuZnNfZXJydGJsW2ldLnN0YXQgIT0gLTE7IGkrKykgewoJCWlmIChuZnNfZXJydGJsW2ldLnN0YXQgPT0gc3RhdHVzKQoJCQlyZXR1cm4gc3RyZXJyb3IobmZzX2VycnRibFtpXS5lcnJudW0pOwoJfQoJc3ByaW50ZihidWYsICJ1bmtub3duIG5mcyBzdGF0dXMgcmV0dXJuIHZhbHVlOiAlZCIsIHN0YXR1cyk7CglyZXR1cm4gYnVmOwp9CgpzdGF0aWMgYm9vbF90IHhkcl9maGFuZGxlIChYRFIgKnhkcnMsIGZoYW5kbGUgb2JqcCkKewoJIGlmICgheGRyX29wYXF1ZSAoeGRycywgb2JqcCwgRkhTSVpFKSkKCQkgcmV0dXJuIEZBTFNFOwoJcmV0dXJuIFRSVUU7Cn0KCmJvb2xfdCB4ZHJfZmhzdGF0dXMgKFhEUiAqeGRycywgZmhzdGF0dXMgKm9ianApCnsKCSBpZiAoIXhkcl91X2ludCAoeGRycywgJm9ianAtPmZoc19zdGF0dXMpKQoJCSByZXR1cm4gRkFMU0U7Cglzd2l0Y2ggKG9ianAtPmZoc19zdGF0dXMpIHsKCWNhc2UgMDoKCQkgaWYgKCF4ZHJfZmhhbmRsZSAoeGRycywgb2JqcC0+ZmhzdGF0dXNfdS5maHNfZmhhbmRsZSkpCgkJCSByZXR1cm4gRkFMU0U7CgkJYnJlYWs7CglkZWZhdWx0OgoJCWJyZWFrOwoJfQoJcmV0dXJuIFRSVUU7Cn0KCmJvb2xfdCB4ZHJfZGlycGF0aCAoWERSICp4ZHJzLCBkaXJwYXRoICpvYmpwKQp7CgkgaWYgKCF4ZHJfc3RyaW5nICh4ZHJzLCBvYmpwLCBNTlRQQVRITEVOKSkKCQkgcmV0dXJuIEZBTFNFOwoJcmV0dXJuIFRSVUU7Cn0KCmJvb2xfdCB4ZHJfZmhhbmRsZTMgKFhEUiAqeGRycywgZmhhbmRsZTMgKm9ianApCnsKCSBpZiAoIXhkcl9ieXRlcyAoeGRycywgKGNoYXIgKiopJm9ianAtPmZoYW5kbGUzX3ZhbCwgKHVuc2lnbmVkIGludCAqKSAmb2JqcC0+ZmhhbmRsZTNfbGVuLCBGSFNJWkUzKSkKCQkgcmV0dXJuIEZBTFNFOwoJcmV0dXJuIFRSVUU7Cn0KCmJvb2xfdCB4ZHJfbW91bnRyZXMzX29rIChYRFIgKnhkcnMsIG1vdW50cmVzM19vayAqb2JqcCkKewoJIGlmICgheGRyX2ZoYW5kbGUzICh4ZHJzLCAmb2JqcC0+ZmhhbmRsZSkpCgkJIHJldHVybiBGQUxTRTsKCSBpZiAoIXhkcl9hcnJheSAoeGRycywgJihvYmpwLT5hdXRoX2ZsYXZvdXJzLmF1dGhfZmxhdm91cnNfdmFsKSwgJihvYmpwLT5hdXRoX2ZsYXZvdXJzLmF1dGhfZmxhdm91cnNfbGVuKSwgfjAsCgkJc2l6ZW9mIChpbnQpLCAoeGRycHJvY190KSB4ZHJfaW50KSkKCQkgcmV0dXJuIEZBTFNFOwoJcmV0dXJuIFRSVUU7Cn0KCmJvb2xfdCB4ZHJfbW91bnRzdGF0MyAoWERSICp4ZHJzLCBtb3VudHN0YXQzICpvYmpwKQp7CgkgaWYgKCF4ZHJfZW51bSAoeGRycywgKGVudW1fdCAqKSBvYmpwKSkKCQkgcmV0dXJuIEZBTFNFOwoJcmV0dXJuIFRSVUU7Cn0KCmJvb2xfdCB4ZHJfbW91bnRyZXMzIChYRFIgKnhkcnMsIG1vdW50cmVzMyAqb2JqcCkKewoJIGlmICgheGRyX21vdW50c3RhdDMgKHhkcnMsICZvYmpwLT5maHNfc3RhdHVzKSkKCQkgcmV0dXJuIEZBTFNFOwoJc3dpdGNoIChvYmpwLT5maHNfc3RhdHVzKSB7CgljYXNlIE1OVF9PSzoKCQkgaWYgKCF4ZHJfbW91bnRyZXMzX29rICh4ZHJzLCAmb2JqcC0+bW91bnRyZXMzX3UubW91bnRpbmZvKSkKCQkJIHJldHVybiBGQUxTRTsKCQlicmVhazsKCWRlZmF1bHQ6CgkJYnJlYWs7Cgl9CglyZXR1cm4gVFJVRTsKfQoK