LyoKICoKICogQ29weXJpZ2h0IChDKSAyMDAwICBSb2JlcnQgT2xzc29uLgogKiBTd2VkaXNoIFVuaXZlcnNpdHkgb2YgQWdyaWN1bHR1cmFsIFNjaWVuY2VzCiAqCiAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIEdOVSBaZWJyYS4KICoKICogR05VIFplYnJhIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlCiAqIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkKICogbGF0ZXIgdmVyc2lvbi4KICoKICogR05VIFplYnJhIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAogKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCiAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICogYWxvbmcgd2l0aCBHTlUgWmVicmE7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLiAgSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZQogKiBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEKICogMDIxMTEtMTMwNywgVVNBLiAgCiAqLwoKLyogCiAqIFRoaXMgd29yayBpbmNsdWRlcyB3b3JrIHdpdGggdGhlIGZvbGxvd2luZyBjb3B5d3JpdGU6CiAqCiAqIENvcHlyaWdodCAoQykgMTk5NywgMjAwMCBLdW5paGlybyBJc2hpZ3VybwogKgogKi8KCi8qIAogKiBUaGFua3MgdG8gSmVucyBM5eVzIGF0IFN3ZWRpc2ggVW5pdmVyc2l0eSBvZiBBZ3JpY3VsdHVyYWwgU2NpZW5jZXMKICogZm9yIHJldmlld2luZyBhbmQgdGVzdHMuCiAqLwoKCiNpbmNsdWRlIDx6ZWJyYS5oPgoKI2lmZGVmIEhBVkVfSVJEUCAKCiNpbmNsdWRlICJpZi5oIgojaW5jbHVkZSAidnR5LmgiCiNpbmNsdWRlICJzb2NrdW5pb24uaCIKI2luY2x1ZGUgInByZWZpeC5oIgojaW5jbHVkZSAiY29tbWFuZC5oIgojaW5jbHVkZSAibWVtb3J5LmgiCiNpbmNsdWRlICJzdHJlYW0uaCIKI2luY2x1ZGUgImlvY3RsLmgiCiNpbmNsdWRlICJjb25uZWN0ZWQuaCIKI2luY2x1ZGUgImxvZy5oIgojaW5jbHVkZSAiemNsaWVudC5oIgojaW5jbHVkZSAidGhyZWFkLmgiCiNpbmNsdWRlICJ6ZWJyYS9pbnRlcmZhY2UuaCIKI2luY2x1ZGUgInplYnJhL3J0YWR2LmgiCiNpbmNsdWRlICJ6ZWJyYS9yaWIuaCIKI2luY2x1ZGUgInplYnJhL3pzZXJ2LmgiCiNpbmNsdWRlICJ6ZWJyYS9yZWRpc3RyaWJ1dGUuaCIKI2luY2x1ZGUgInplYnJhL2lyZHAuaCIKI2luY2x1ZGUgPG5ldGluZXQvaXBfaWNtcC5oPgojaW5jbHVkZSAiaWYuaCIKI2luY2x1ZGUgInNvY2t1bmlvbi5oIgojaW5jbHVkZSAibG9nLmgiCgoKLyogTWFzdGVyIG9mIHRocmVhZHMuICovCmV4dGVybiBzdHJ1Y3QgemVicmFfdCB6ZWJyYWQ7CgppbnQgaW5fY2tzdW0gKHZvaWQgKnB0ciwgaW50IG5ieXRlcyk7CmV4dGVybiBpbnQgaXJkcF9zb2NrOwppbnQgaXJkcF9zZW5kX3RocmVhZChzdHJ1Y3QgdGhyZWFkICp0X2FkdmVydCk7CmNoYXIgKmluZXRfMmEodV9pbnQzMl90IGEsIGNoYXIgKmIpOwp2b2lkIGlyZHBfYWR2ZXJ0X29mZihzdHJ1Y3QgaW50ZXJmYWNlICppZnApOwoKCmNoYXIgYjFbMTZdLCBiMlsxNl0sIGIzWzE2XSwgYjRbMTZdOyAgLyogRm9yIGluZXRfMmEgKi8KCnN0cnVjdCBwcmVmaXggKmlyZHBfZ2V0X3ByZWZpeChzdHJ1Y3QgaW50ZXJmYWNlICppZnApCnsKICBzdHJ1Y3QgbGlzdG5vZGUgKm5vZGU7CiAgc3RydWN0IGNvbm5lY3RlZCAqaWZjOwogIAogIGlmIChpZnAtPmNvbm5lY3RlZCkKICAgIExJU1RfTE9PUCAoaWZwLT5jb25uZWN0ZWQsIGlmYywgbm9kZSkKICAgICAgcmV0dXJuIGlmYy0+YWRkcmVzczsKCiAgcmV0dXJuIE5VTEw7Cn0KCi8qIEpvaW4gdG8gdGhlIGFkZC9sZWF2ZSBtdWx0aWNhc3QgZ3JvdXAuICovCmludCBpZl9ncm91cCAoc3RydWN0IGludGVyZmFjZSAqaWZwLCAKCSAgaW50IHNvY2ssIAoJICB1X2ludDMyX3QgZ3JvdXAsIAoJICBpbnQgYWRkX2xlYXZlKQp7CiAgc3RydWN0IHplYnJhX2lmICp6aTsKICBzdHJ1Y3QgaXBfbXJlcSBtOwogIHN0cnVjdCBwcmVmaXggKnA7CiAgaW50IHJldDsKCiAgemkgPSBpZnAtPmluZm87CgogIGJ6ZXJvICgmbSwgc2l6ZW9mIChtKSk7CiAgbS5pbXJfbXVsdGlhZGRyLnNfYWRkciA9IGh0b25sIChncm91cCk7CiAgcCA9IGlyZHBfZ2V0X3ByZWZpeChpZnApOwoKICBpZighcCkgewogICAgICAgIHpsb2dfd2FybiAoIklSRFA6IGNhbid0IGdldCBhZGRyZXNzIGZvciAlcyIsIGlmcC0+bmFtZSk7CglyZXR1cm4gMTsKICB9CgogIG0uaW1yX2ludGVyZmFjZSA9IHAtPnUucHJlZml4NDsKCiAgcmV0ID0gc2V0c29ja29wdCAoc29jaywgSVBQUk9UT19JUCwgYWRkX2xlYXZlLAoJCSAgICAoY2hhciAqKSAmbSwgc2l6ZW9mIChzdHJ1Y3QgaXBfbXJlcSkpOwogIGlmIChyZXQgPCAwKQogICAgemxvZ193YXJuICgiSVJEUDogJXMgY2FuJ3Qgc2V0c29ja29wdCAlczogJXMiLAoJICAgICAgIGFkZF9sZWF2ZSA9PSBJUF9BRERfTUVNQkVSU0hJUD8gImpvaW4gZ3JvdXAiOiJsZWF2ZSBncm91cCIsIAogICAgICAgICAgICAgICBpbmV0XzJhKGdyb3VwLCBiMSksCiAgICAgICAgICAgICAgIHNhZmVfc3RyZXJyb3IgKGVycm5vKSk7CgogIHJldHVybiByZXQ7Cn0KCmludCBpZl9hZGRfZ3JvdXAgKHN0cnVjdCBpbnRlcmZhY2UgKmlmcCkKewogIHN0cnVjdCB6ZWJyYV9pZiAqemk9IGlmcC0+aW5mbzsKICBzdHJ1Y3QgaXJkcF9pbnRlcmZhY2UgKmlyZHAgPSAmemktPmlyZHA7CiAgaW50IHJldDsKCiAgcmV0ID0gaWZfZ3JvdXAgKGlmcCwgaXJkcF9zb2NrLCBJTkFERFJfQUxMUlRSU19HUk9VUCwgSVBfQUREX01FTUJFUlNISVApOwogIGlmIChyZXQgPCAwKSB7CiAgICByZXR1cm4gcmV0OwogIH0KCiAgaWYoaXJkcC0+ZmxhZ3MgJiBJRl9ERUJVR19NSVNDICkKICAgIHpsb2dfZGVidWcoIklSRFA6IEFkZGluZyBncm91cCAlcyBmb3IgJXNcbiIsIAoJICAgICAgIGluZXRfMmEoaHRvbmwoSU5BRERSX0FMTFJUUlNfR1JPVVApLCBiMSksCgkgICAgICAgaWZwLT5uYW1lKTsKICByZXR1cm4gMDsKfQppbnQgaWZfZHJvcF9ncm91cCAoc3RydWN0IGludGVyZmFjZSAqaWZwKQp7CiAgc3RydWN0IHplYnJhX2lmICp6aT0gaWZwLT5pbmZvOwogIHN0cnVjdCBpcmRwX2ludGVyZmFjZSAqaXJkcCA9ICZ6aS0+aXJkcDsKICBpbnQgcmV0OwoKICByZXQgPSBpZl9ncm91cCAoaWZwLCBpcmRwX3NvY2ssIElOQUREUl9BTExSVFJTX0dST1VQLCBJUF9EUk9QX01FTUJFUlNISVApOwogIGlmIChyZXQgPCAwKQogICAgcmV0dXJuIHJldDsKCiAgaWYoaXJkcC0+ZmxhZ3MgJiBJRl9ERUJVR19NSVNDKQogICAgemxvZ19kZWJ1ZygiSVJEUDogTGVhdmluZyBncm91cCAlcyBmb3IgJXNcbiIsIAoJICAgICAgIGluZXRfMmEoaHRvbmwoSU5BRERSX0FMTFJUUlNfR1JPVVApLCBiMSksCgkgICAgICAgaWZwLT5uYW1lKTsKICByZXR1cm4gMDsKfQoKc3RydWN0IGludGVyZmFjZSAqZ2V0X2lmbGlzdF9pZnAodW5zaWduZWQgaW50IGlkeCkKewogIHN0cnVjdCBsaXN0bm9kZSAqbm9kZTsKICBzdHJ1Y3QgaW50ZXJmYWNlICppZnA7CgogIExJU1RfTE9PUCAoaWZsaXN0LCBpZnAsIG5vZGUpCiAgICBpZihpZnAtPmlmaW5kZXggPT0gaWR4KSAKICAgICAgcmV0dXJuIGlmcDsKCiAgcmV0dXJuIE5VTEw7Cn0KCnZvaWQKaWZfc2V0X2RlZmF1bHRzKHN0cnVjdCBpbnRlcmZhY2UgKmlmcCkKewogIHN0cnVjdCB6ZWJyYV9pZiAqemk9aWZwLT5pbmZvOwogIHN0cnVjdCBpcmRwX2ludGVyZmFjZSAqaXJkcD0memktPmlyZHA7CgogIGlyZHAtPk1heEFkdmVydEludGVydmFsID0gSVJEUF9NQVhBRFZFUlRJTlRFUlZBTDsKICBpcmRwLT5NaW5BZHZlcnRJbnRlcnZhbCA9IElSRFBfTUlOQURWRVJUSU5URVJWQUw7CiAgaXJkcC0+UHJlZmVyZW5jZSA9IElSRFBfUFJFRkVSRU5DRTsKICBpcmRwLT5MaWZldGltZSA9IElSRFBfTElGRVRJTUU7Cn0KCgpzdHJ1Y3QgQWR2ICpBZHZfbmV3ICgpCnsKICBzdHJ1Y3QgQWR2ICpuZXc7CiAgbmV3ID0gWE1BTExPQyAoTVRZUEVfVE1QLCBzaXplb2YgKHN0cnVjdCBBZHYpKTsKICBtZW1zZXQgKG5ldywgMCwgc2l6ZW9mIChzdHJ1Y3QgQWR2KSk7CiAgcmV0dXJuIG5ldzsKfQoKdm9pZCBBZHZfZnJlZSAoc3RydWN0IEFkdiAqYWR2KQp7CiAgWEZSRUUgKE1UWVBFX1RNUCwgYWR2KTsKfQoKdm9pZCBpcmRwX2lmX3N0YXJ0KHN0cnVjdCBpbnRlcmZhY2UgKmlmcCwgaW50IG11bHRpY2FzdCwgaW50IHNldF9kZWZhdWx0cykKewogIHN0cnVjdCB6ZWJyYV9pZiAqemk9IGlmcC0+aW5mbzsKICBzdHJ1Y3QgaXJkcF9pbnRlcmZhY2UgKmlyZHAgPSAmemktPmlyZHA7CiAgc3RydWN0IGxpc3Rub2RlICpub2RlOwogIHN0cnVjdCBjb25uZWN0ZWQgKmlmYzsKICB1X2ludDMyX3QgdGltZXIsIHNlZWQ7CgogIGlmIChpcmRwLT5mbGFncyAmIElGX0FDVElWRSApIHsKICAgIHpsb2dfd2FybigiSVJEUDogSW50ZXJmYWNlIGlzIGFscmVhZHkgYWN0aXZlICVzXG4iLCBpZnAtPm5hbWUpOwogICAgcmV0dXJuOwogIH0KICBpcmRwLT5mbGFncyB8PSBJRl9BQ1RJVkU7CgogIGlmKCFtdWx0aWNhc3QpIAogICAgaXJkcC0+ZmxhZ3MgfD0gSUZfQlJPQURDQVNUOwoKICBpZl9hZGRfdXBkYXRlKGlmcCk7CgogIGlmICghIChpZnAtPmZsYWdzICYgSUZGX1VQKSkgewogICAgemxvZ193YXJuKCJJUkRQOiBJbnRlcmZhY2UgaXMgZG93biAlc1xuIiwgaWZwLT5uYW1lKTsKICB9CgogIC8qIFNoYWxsIHdlIGNhbmNlbCBpZl9zdGFydCBpZiBpZl9hZGRfZ3JvdXAgZmFpbHM/ICovCgogIGlmKCBtdWx0aWNhc3QpIHsKICAgIGlmX2FkZF9ncm91cChpZnApOwogICAgCiAgICBpZiAoISAoaWZwLT5mbGFncyAmIChJRkZfTVVMVElDQVNUfElGRl9BTExNVUxUSSkpKSB7CiAgICAgIHpsb2dfd2FybigiSVJEUDogSW50ZXJmYWNlIG5vdCBtdWx0aWNhc3QgZW5hYmxlZCAlc1xuIiwgaWZwLT5uYW1lKTsKICAgIH0KICB9CgogIGlmKHNldF9kZWZhdWx0cykgCiAgICBpZl9zZXRfZGVmYXVsdHMoaWZwKTsKCiAgaXJkcC0+aXJkcF9zZW50ID0gMDsKCiAgLyogVGhlIHNwZWMgc3VnZ2VzdHMgdGhpcyBmb3IgcmFuZG9tbmVzcyAqLwoKICBzZWVkID0gMDsKICBpZiggaWZwLT5jb25uZWN0ZWQpCiAgICBMSVNUX0xPT1AgKGlmcC0+Y29ubmVjdGVkLCBpZmMsIG5vZGUpCiAgICAgIHsKICAgICAgICBzZWVkID0gaWZjLT5hZGRyZXNzLT51LnByZWZpeDQuc19hZGRyOwogICAgICAgIGJyZWFrOwogICAgICB9CiAgCiAgc3JhbmRvbShzZWVkKTsKICB0aW1lciA9ICAocmFuZG9tICgpICUgSVJEUF9ERUZBVUxUX0lOVEVSVkFMKSArIDE7IAoKICBpcmRwLT5BZHZQcmVmTGlzdCA9IGxpc3RfbmV3KCk7CiAgaXJkcC0+QWR2UHJlZkxpc3QtPmRlbCA9ICAodm9pZCAoKikodm9pZCAqKSkgQWR2X2ZyZWU7IC8qIERlc3RydWN0b3IgKi8KCgogIC8qIEFuZCB0aGlzIGZvciBzdGFydHVwLiBTcGVlZCBsaW1pdCBmcm9tIDE5OTEgOi0pLiBCdXQgaXQncyBPSyovCgogIGlmKGlyZHAtPmlyZHBfc2VudCA8IE1BWF9JTklUSUFMX0FEVkVSVElTRU1FTlRTICYmCiAgICAgdGltZXIgPiBNQVhfSU5JVElBTF9BRFZFUlRfSU5URVJWQUwgKSAKCSAgdGltZXI9IE1BWF9JTklUSUFMX0FEVkVSVF9JTlRFUlZBTDsKCiAgCiAgaWYoaXJkcC0+ZmxhZ3MgJiBJRl9ERUJVR19NSVNDKQogICAgemxvZ19kZWJ1ZygiSVJEUDogSW5pdCB0aW1lciBmb3IgJXMgc2V0IHRvICV1XG4iLCAKCSAgICAgICBpZnAtPm5hbWUsIAoJICAgICAgIHRpbWVyKTsKCiAgaXJkcC0+dF9hZHZlcnRpc2UgPSB0aHJlYWRfYWRkX3RpbWVyKHplYnJhZC5tYXN0ZXIsIAoJCQkJICAgICAgIGlyZHBfc2VuZF90aHJlYWQsIAoJCQkJICAgICAgIGlmcCwgCgkJCQkgICAgICAgdGltZXIpOwp9Cgp2b2lkIGlyZHBfaWZfc3RvcChzdHJ1Y3QgaW50ZXJmYWNlICppZnApCnsKICBzdHJ1Y3QgemVicmFfaWYgKnppPWlmcC0+aW5mbzsKICBzdHJ1Y3QgaXJkcF9pbnRlcmZhY2UgKmlyZHA9JnppLT5pcmRwOwogIAogIGlmIChpcmRwID09IE5VTEwpIHsKICAgIHpsb2dfd2FybiAoIkludGVyZmFjZSAlcyBzdHJ1Y3R1cmUgaXMgTlVMTCIsIGlmcC0+bmFtZSk7CiAgICByZXR1cm47CiAgfQoKICBpZiAoISAoaXJkcC0+ZmxhZ3MgJiBJRl9BQ1RJVkUgKSkgewogICAgemxvZ193YXJuKCJJbnRlcmZhY2UgaXMgbm90IGFjdGl2ZSAlc1xuIiwgaWZwLT5uYW1lKTsKICAgIHJldHVybjsKICB9CgogIGlmKCEgKGlyZHAtPmZsYWdzICYgSUZfQlJPQURDQVNUKSkgCiAgICBpZl9kcm9wX2dyb3VwKGlmcCk7CgogIGlyZHBfYWR2ZXJ0X29mZihpZnApOwoKICBsaXN0X2RlbGV0ZShpcmRwLT5BZHZQcmVmTGlzdCk7CiAgaXJkcC0+QWR2UHJlZkxpc3Q9TlVMTDsKCiAgaXJkcC0+ZmxhZ3MgPSAwOwp9CgoKdm9pZCBpcmRwX2lmX3NodXRkb3duKHN0cnVjdCBpbnRlcmZhY2UgKmlmcCkKewogIHN0cnVjdCB6ZWJyYV9pZiAqemk9IGlmcC0+aW5mbzsKICBzdHJ1Y3QgaXJkcF9pbnRlcmZhY2UgKmlyZHAgPSAmemktPmlyZHA7CgogIGlmIChpcmRwLT5mbGFncyAmIElGX1NIVVRET1dOICkgewogICAgemxvZ193YXJuKCJJUkRQOiBJbnRlcmZhY2UgaXMgYWxyZWFkeSBzaHV0ZG93biAlc1xuIiwgaWZwLT5uYW1lKTsKICAgIHJldHVybjsKICB9CgogIGlyZHAtPmZsYWdzIHw9IElGX1NIVVRET1dOOwogIGlyZHAtPmZsYWdzICY9IH5JRl9BQ1RJVkU7CgogIGlmKCEgKGlyZHAtPmZsYWdzICYgSUZfQlJPQURDQVNUKSkgCiAgICBpZl9kcm9wX2dyb3VwKGlmcCk7CiAgCiAgLyogVGVsbCB0aGUgaG9zdHMgd2UgYXJlIG91dCBvZiBzZXJ2aWNlICovCiAgaXJkcF9hZHZlcnRfb2ZmKGlmcCk7Cn0KCnZvaWQgaXJkcF9pZl9ub19zaHV0ZG93bihzdHJ1Y3QgaW50ZXJmYWNlICppZnApCnsKICBzdHJ1Y3QgemVicmFfaWYgKnppPSBpZnAtPmluZm87CiAgc3RydWN0IGlyZHBfaW50ZXJmYWNlICppcmRwID0gJnppLT5pcmRwOwoKICBpZiAoISAoaXJkcC0+ZmxhZ3MgJiBJRl9TSFVURE9XTiApKSB7CiAgICB6bG9nX3dhcm4oIklSRFA6IEludGVyZmFjZSBpcyBub3Qgc2h1dGRvd24gJXNcbiIsIGlmcC0+bmFtZSk7CiAgICByZXR1cm47CiAgfQoKICBpcmRwLT5mbGFncyAmPSB+SUZfU0hVVERPV047CgogIGlyZHBfaWZfc3RhcnQoaWZwLCBpcmRwLT5mbGFncyAmIElGX0JST0FEQ0FTVD8gRkFMU0UgOiBUUlVFLCBGQUxTRSk7IAoKfQoKCi8qIFdyaXRlIGNvbmZpZ3VyYXRpb24gdG8gdXNlciAqLwoKdm9pZCBpcmRwX2NvbmZpZ193cml0ZSAoc3RydWN0IHZ0eSAqdnR5LCBzdHJ1Y3QgaW50ZXJmYWNlICppZnApCnsKICBzdHJ1Y3QgemVicmFfaWYgKnppPWlmcC0+aW5mbzsKICBzdHJ1Y3QgaXJkcF9pbnRlcmZhY2UgKmlyZHA9JnppLT5pcmRwOwogIHN0cnVjdCBBZHYgKmFkdjsKICBzdHJ1Y3QgbGlzdG5vZGUgKm5vZGU7CgogIGlmKGlyZHAtPmZsYWdzICYgSUZfQUNUSVZFIHx8IGlyZHAtPmZsYWdzICYgSUZfU0hVVERPV04pIHsKCiAgICBpZiggaXJkcC0+ZmxhZ3MgJiBJRl9TSFVURE9XTikgCiAgICAgIHZ0eV9vdXQgKHZ0eSwgIiBpcCBpcmRwIHNodXRkb3duICVzIiwgIFZUWV9ORVdMSU5FKTsKCiAgICBpZiggaXJkcC0+ZmxhZ3MgJiBJRl9CUk9BRENBU1QpIAogICAgICB2dHlfb3V0ICh2dHksICIgaXAgaXJkcCBicm9hZGNhc3QlcyIsICBWVFlfTkVXTElORSk7CiAgICBlbHNlIAogICAgICB2dHlfb3V0ICh2dHksICIgaXAgaXJkcCBtdWx0aWNhc3QlcyIsICBWVFlfTkVXTElORSk7CgogICAgdnR5X291dCAodnR5LCAiIGlwIGlyZHAgcHJlZmVyZW5jZSAlbGQlcyIsICAKCSAgICAgaXJkcC0+UHJlZmVyZW5jZSwgVlRZX05FV0xJTkUpOwoKICAgIExJU1RfTE9PUCAoaXJkcC0+QWR2UHJlZkxpc3QsIGFkdiwgbm9kZSkKICAgICAgdnR5X291dCAodnR5LCAiIGlwIGlyZHAgYWRkcmVzcyAlcyBwcmVmZXJlbmNlICVkJXMiLAogICAgICAgICAgICAgICAgICAgIGluZXRfMmEoYWR2LT5pcC5zX2FkZHIsIGIxKSwKICAgICAgICAgICAgICAgICAgICBhZHYtPnByZWYsIAogICAgICAgICAgICAgICAgICAgIFZUWV9ORVdMSU5FKTsKCiAgICB2dHlfb3V0ICh2dHksICIgaXAgaXJkcCBob2xkdGltZSAlZCVzIiwgIAoJICAgICBpcmRwLT5MaWZldGltZSwgVlRZX05FV0xJTkUpOwoKICAgIHZ0eV9vdXQgKHZ0eSwgIiBpcCBpcmRwIG1pbmFkdmVydGludGVydmFsICVsZCVzIiwgIAoJICAgICBpcmRwLT5NaW5BZHZlcnRJbnRlcnZhbCwgVlRZX05FV0xJTkUpOwoKICAgIHZ0eV9vdXQgKHZ0eSwgIiBpcCBpcmRwIG1heGFkdmVydGludGVydmFsICVsZCVzIiwgIAoJICAgICBpcmRwLT5NYXhBZHZlcnRJbnRlcnZhbCwgVlRZX05FV0xJTkUpOwoKICB9Cn0KCgpERUZVTiAoaXBfaXJkcF9tdWx0aWNhc3QsCiAgICAgICBpcF9pcmRwX211bHRpY2FzdF9jbWQsCiAgICAgICAiaXAgaXJkcCBtdWx0aWNhc3QiLAogICAgICAgSVBfU1RSCiAgICAgICAiSUNNUCBSb3V0ZXIgZGlzY292ZXJ5IG9uIHRoaXMgaW50ZXJmYWNlIHVzaW5nIG11bHRpY2FzdFxuIikKewogIHN0cnVjdCBpbnRlcmZhY2UgKmlmcDsKCiAgaWZwID0gKHN0cnVjdCBpbnRlcmZhY2UgKikgdnR5LT5pbmRleDsKICBpZighaWZwKSB7CgkgIHJldHVybiBDTURfV0FSTklORzsKICB9CgogIGlyZHBfaWZfc3RhcnQoaWZwLCBUUlVFLCBUUlVFKTsKICByZXR1cm4gQ01EX1NVQ0NFU1M7Cn0KCkRFRlVOIChpcF9pcmRwX2Jyb2FkY2FzdCwKICAgICAgIGlwX2lyZHBfYnJvYWRjYXN0X2NtZCwKICAgICAgICJpcCBpcmRwIGJyb2FkY2FzdCIsCiAgICAgICBJUF9TVFIKICAgICAgICJJQ01QIFJvdXRlciBkaXNjb3Zlcnkgb24gdGhpcyBpbnRlcmZhY2UgdXNpbmcgYnJvYWRjYXN0XG4iKQp7CiAgc3RydWN0IGludGVyZmFjZSAqaWZwOwoKICBpZnAgPSAoc3RydWN0IGludGVyZmFjZSAqKSB2dHktPmluZGV4OwogIGlmKCFpZnApIHsKCSAgcmV0dXJuIENNRF9XQVJOSU5HOwogIH0KCiAgaXJkcF9pZl9zdGFydChpZnAsIEZBTFNFLCBUUlVFKTsKICByZXR1cm4gQ01EX1NVQ0NFU1M7Cn0KCkRFRlVOIChub19pcF9pcmRwLAogICAgICAgbm9faXBfaXJkcF9jbWQsCiAgICAgICAibm8gaXAgaXJkcCIsCiAgICAgICBOT19TVFIKICAgICAgIElQX1NUUgogICAgICAgIkRpc2FibGUgSUNNUCBSb3V0ZXIgZGlzY292ZXJ5IG9uIHRoaXMgaW50ZXJmYWNlXG4iKQp7CiAgc3RydWN0IGludGVyZmFjZSAqaWZwOwoKICBpZnAgPSAoc3RydWN0IGludGVyZmFjZSAqKSB2dHktPmluZGV4OwogIGlmKCFpZnApIHsKCSAgcmV0dXJuIENNRF9XQVJOSU5HOwogIH0KCiAgaXJkcF9pZl9zdG9wKGlmcCk7CiAgcmV0dXJuIENNRF9TVUNDRVNTOwp9CgpERUZVTiAoaXBfaXJkcF9zaHV0ZG93biwKICAgICAgIGlwX2lyZHBfc2h1dGRvd25fY21kLAogICAgICAgImlwIGlyZHAgc2h1dGRvd24iLAogICAgICAgSVBfU1RSCiAgICAgICAiSUNNUCBSb3V0ZXIgZGlzY292ZXJ5IHNodXRkb3duIG9uIHRoaXMgaW50ZXJmYWNlXG4iKQp7CiAgc3RydWN0IGludGVyZmFjZSAqaWZwOwoKICBpZnAgPSAoc3RydWN0IGludGVyZmFjZSAqKSB2dHktPmluZGV4OwogIGlmKCFpZnApIHsKCSAgcmV0dXJuIENNRF9XQVJOSU5HOwogIH0KCiAgaXJkcF9pZl9zaHV0ZG93bihpZnApOwogIHJldHVybiBDTURfU1VDQ0VTUzsKfQoKREVGVU4gKG5vX2lwX2lyZHBfc2h1dGRvd24sCiAgICAgICBub19pcF9pcmRwX3NodXRkb3duX2NtZCwKICAgICAgICJubyBpcCBpcmRwIHNodXRkb3duIiwKICAgICAgIE5PX1NUUgogICAgICAgSVBfU1RSCiAgICAgICAiSUNNUCBSb3V0ZXIgZGlzY292ZXJ5IG5vIHNodXRkb3duIG9uIHRoaXMgaW50ZXJmYWNlXG4iKQp7CiAgc3RydWN0IGludGVyZmFjZSAqaWZwOwoKICBpZnAgPSAoc3RydWN0IGludGVyZmFjZSAqKSB2dHktPmluZGV4OwogIGlmKCFpZnApIHsKCSAgcmV0dXJuIENNRF9XQVJOSU5HOwogIH0KCiAgaXJkcF9pZl9ub19zaHV0ZG93bihpZnApOwogIHJldHVybiBDTURfU1VDQ0VTUzsKfQoKREVGVU4gKGlwX2lyZHBfaG9sZHRpbWUsCiAgICAgICBpcF9pcmRwX2hvbGR0aW1lX2NtZCwKICAgICAgICJpcCBpcmRwIGhvbGR0aW1lIDwwLTkwMDA+IiwKICAgICAgIElQX1NUUgogICAgICAgIklDTVAgUm91dGVyIGRpc2NvdmVyeSBvbiB0aGlzIGludGVyZmFjZVxuIgogICAgICAgIlNldCBob2xkdGltZSB2YWx1ZVxuIgogICAgICAgIkhvbGR0aW1lIHZhbHVlIGluIHNlY29uZHMuIERlZmF1bHQgaXMgMTgwMCBzZWNvbmRzXG4iKQp7CiAgc3RydWN0IGludGVyZmFjZSAqaWZwOwogIHN0cnVjdCB6ZWJyYV9pZiAqemk7CiAgc3RydWN0IGlyZHBfaW50ZXJmYWNlICppcmRwOwogIGlmcCA9IChzdHJ1Y3QgaW50ZXJmYWNlICopIHZ0eS0+aW5kZXg7CiAgaWYoIWlmcCkgewoJICByZXR1cm4gQ01EX1dBUk5JTkc7CiAgfQoKICB6aT1pZnAtPmluZm87CiAgaXJkcD0memktPmlyZHA7CgogIGlyZHAtPkxpZmV0aW1lID0gYXRvaShhcmd2WzBdKTsKICByZXR1cm4gQ01EX1NVQ0NFU1M7Cn0KCkRFRlVOIChpcF9pcmRwX21pbmFkdmVydGludGVydmFsLAogICAgICAgaXBfaXJkcF9taW5hZHZlcnRpbnRlcnZhbF9jbWQsCiAgICAgICAiaXAgaXJkcCBtaW5hZHZlcnRpbnRlcnZhbCA8My0xODAwPiIsCiAgICAgICBJUF9TVFIKICAgICAgICJJQ01QIFJvdXRlciBkaXNjb3Zlcnkgb24gdGhpcyBpbnRlcmZhY2VcbiIKICAgICAgICJTZXQgbWluaW11bSB0aW1lIGJldHdlZW4gYWR2ZXJ0aXNlbWVudFxuIgogICAgICAgIk1pbmltdW0gYWR2ZXJ0aXNlbWVudCBpbnRlcnZhbCBpbiBzZWNvbmRzXG4iKQp7CiAgc3RydWN0IGludGVyZmFjZSAqaWZwOwogIHN0cnVjdCB6ZWJyYV9pZiAqemk7CiAgc3RydWN0IGlyZHBfaW50ZXJmYWNlICppcmRwOwogIGlmcCA9IChzdHJ1Y3QgaW50ZXJmYWNlICopIHZ0eS0+aW5kZXg7CiAgaWYoIWlmcCkgewoJICByZXR1cm4gQ01EX1dBUk5JTkc7CiAgfQoKICB6aT1pZnAtPmluZm87CiAgaXJkcD0memktPmlyZHA7CgogIGlmKCAodW5zaWduZWQpIGF0b2koYXJndlswXSkgPD0gaXJkcC0+TWF4QWR2ZXJ0SW50ZXJ2YWwpIHsKICAgICAgaXJkcC0+TWluQWR2ZXJ0SW50ZXJ2YWwgPSBhdG9pKGFyZ3ZbMF0pOwoKICAgICAgcmV0dXJuIENNRF9TVUNDRVNTOwogIH0KCiAgdnR5X291dCAodnR5LCAiSUNNUCB3YXJuaW5nIG1heGFkdmVydGludGVydmFsIGlzIGdyZWF0ZXIgb3IgZXF1YWwgdGhhbiBtaW5hZHZlcnRpbnRlcnZhbCVzIiwgCgkgICAgIFZUWV9ORVdMSU5FKTsKCiAgdnR5X291dCAodnR5LCAiUGxlYXNlIGNvcnJlY3QhJXMiLCAKCSAgICAgVlRZX05FV0xJTkUpOwogIHJldHVybiBDTURfV0FSTklORzsKfQoKREVGVU4gKGlwX2lyZHBfbWF4YWR2ZXJ0aW50ZXJ2YWwsCiAgICAgICBpcF9pcmRwX21heGFkdmVydGludGVydmFsX2NtZCwKICAgICAgICJpcCBpcmRwIG1heGFkdmVydGludGVydmFsIDw0LTE4MDA+IiwKICAgICAgIElQX1NUUgogICAgICAgIklDTVAgUm91dGVyIGRpc2NvdmVyeSBvbiB0aGlzIGludGVyZmFjZVxuIgogICAgICAgIlNldCBtYXhpbXVtIHRpbWUgYmV0d2VlbiBhZHZlcnRpc2VtZW50XG4iCiAgICAgICAiTWF4aW11bSBhZHZlcnRpc2VtZW50IGludGVydmFsIGluIHNlY29uZHNcbiIpCnsKICBzdHJ1Y3QgaW50ZXJmYWNlICppZnA7CiAgc3RydWN0IHplYnJhX2lmICp6aTsKICBzdHJ1Y3QgaXJkcF9pbnRlcmZhY2UgKmlyZHA7CiAgaWZwID0gKHN0cnVjdCBpbnRlcmZhY2UgKikgdnR5LT5pbmRleDsKICBpZighaWZwKSB7CgkgIHJldHVybiBDTURfV0FSTklORzsKICB9CgogIHppPWlmcC0+aW5mbzsKICBpcmRwPSZ6aS0+aXJkcDsKCgogIGlmKCBpcmRwLT5NaW5BZHZlcnRJbnRlcnZhbCA8PSAodW5zaWduZWQpIGF0b2koYXJndlswXSkgKSB7CiAgICBpcmRwLT5NYXhBZHZlcnRJbnRlcnZhbCA9IGF0b2koYXJndlswXSk7CgogICAgICByZXR1cm4gQ01EX1NVQ0NFU1M7CiAgfQoKICB2dHlfb3V0ICh2dHksICJJQ01QIHdhcm5pbmcgbWF4YWR2ZXJ0aW50ZXJ2YWwgaXMgZ3JlYXRlciBvciBlcXVhbCB0aGFuIG1pbmFkdmVydGludGVydmFsJXMiLCAKCSAgICAgVlRZX05FV0xJTkUpOwoKICB2dHlfb3V0ICh2dHksICJQbGVhc2UgY29ycmVjdCElcyIsIAoJICAgICBWVFlfTkVXTElORSk7CiAgcmV0dXJuIENNRF9XQVJOSU5HOwp9CgovKiBERUZVTiBuZWVkcyB0byBiZSBmaXhlZCBmb3IgbmVnYXRpdmUgcmFuYWdlcy4uLgogKiAiaXAgaXJkcCBwcmVmZXJlbmNlIDwtMjE0NzQ4MzY0OC0yMTQ3NDgzNjQ3PiIsCiAqIEJlIHBvc2l0aXZlIGZvciBub3cuIDotKQogKi8KCkRFRlVOIChpcF9pcmRwX3ByZWZlcmVuY2UsCiAgICAgICBpcF9pcmRwX3ByZWZlcmVuY2VfY21kLAogICAgICAgImlwIGlyZHAgcHJlZmVyZW5jZSA8MC0yMTQ3NDgzNjQ3PiIsCiAgICAgICBJUF9TVFIKICAgICAgICJJQ01QIFJvdXRlciBkaXNjb3Zlcnkgb24gdGhpcyBpbnRlcmZhY2VcbiIKICAgICAgICJTZXQgZGVmYXVsdCBwcmVmZXJlbmNlIGxldmVsIGZvciB0aGlzIGludGVyZmFjZVxuIgogICAgICAgIlByZWZlcmVuY2UgbGV2ZWxcbiIpCnsKICBzdHJ1Y3QgaW50ZXJmYWNlICppZnA7CiAgc3RydWN0IHplYnJhX2lmICp6aTsKICBzdHJ1Y3QgaXJkcF9pbnRlcmZhY2UgKmlyZHA7CiAgaWZwID0gKHN0cnVjdCBpbnRlcmZhY2UgKikgdnR5LT5pbmRleDsKICBpZighaWZwKSB7CgkgIHJldHVybiBDTURfV0FSTklORzsKICB9CgogIHppPWlmcC0+aW5mbzsKICBpcmRwPSZ6aS0+aXJkcDsKCiAgaXJkcC0+UHJlZmVyZW5jZSA9IGF0b2koYXJndlswXSk7CiAgcmV0dXJuIENNRF9TVUNDRVNTOwp9CgpERUZVTiAoaXBfaXJkcF9hZGRyZXNzX3ByZWZlcmVuY2UsCiAgICAgICBpcF9pcmRwX2FkZHJlc3NfcHJlZmVyZW5jZV9jbWQsCiAgICAgICAiaXAgaXJkcCBhZGRyZXNzIEEuQi5DLkQgcHJlZmVyZW5jZSA8MC0yMTQ3NDgzNjQ3PiIsCiAgICAgICBJUF9TVFIKICAgICAgICJBbHRlciBJQ01QIFJvdXRlciBkaXNjb3ZlcnkgcHJlZmVyZW5jZSB0aGlzIGludGVyZmFjZVxuIgogICAgICAgIlNwZWNpZnkgSVJEUCBub24tZGVmYXVsdCBwcmVmZXJlbmNlIHRvIGFkdmVydGlzZVxuIgogICAgICAgIlNldCBJUkRQIGFkZHJlc3MgZm9yIGFkdmVydGlzZVxuIgogICAgICAgIlByZWZlcmVuY2UgbGV2ZWxcbiIpCnsKICBzdHJ1Y3QgbGlzdG5vZGUgKm5vZGU7CiAgc3RydWN0IGluX2FkZHIgaXA7IAogIGludCBwcmVmOwogIGludCByZXQ7CiAgc3RydWN0IGludGVyZmFjZSAqaWZwOwogIHN0cnVjdCB6ZWJyYV9pZiAqemk7CiAgc3RydWN0IGlyZHBfaW50ZXJmYWNlICppcmRwOwogIHN0cnVjdCBBZHYgKmFkdjsKCiAgaWZwID0gKHN0cnVjdCBpbnRlcmZhY2UgKikgdnR5LT5pbmRleDsKICBpZighaWZwKSB7CgkgIHJldHVybiBDTURfV0FSTklORzsKICB9CgogIHppPWlmcC0+aW5mbzsKICBpcmRwPSZ6aS0+aXJkcDsKCiAgcmV0ID0gaW5ldF9hdG9uKGFyZ3ZbMF0sICZpcCk7CiAgaWYoIXJldCkgcmV0dXJuIENNRF9XQVJOSU5HOwoKICBwcmVmID0gYXRvaShhcmd2WzFdKTsKCiAgTElTVF9MT09QIChpcmRwLT5BZHZQcmVmTGlzdCwgYWR2LCBub2RlKQogICAgaWYoYWR2LT5pcC5zX2FkZHIgPT0gaXAuc19hZGRyKSAKICAgICAgcmV0dXJuIENNRF9TVUNDRVNTOwoKICBhZHYgPSBBZHZfbmV3KCk7CiAgYWR2LT5pcCA9IGlwOwogIGFkdi0+cHJlZiA9IHByZWY7CiAgbGlzdG5vZGVfYWRkKGlyZHAtPkFkdlByZWZMaXN0LCBhZHYpOwoKICByZXR1cm4gQ01EX1NVQ0NFU1M7Cgp9CgpERUZVTiAobm9faXBfaXJkcF9hZGRyZXNzX3ByZWZlcmVuY2UsCiAgICAgICBub19pcF9pcmRwX2FkZHJlc3NfcHJlZmVyZW5jZV9jbWQsCiAgICAgICAibm8gaXAgaXJkcCBhZGRyZXNzIEEuQi5DLkQgcHJlZmVyZW5jZSA8MC0yMTQ3NDgzNjQ3PiIsCiAgICAgICBOT19TVFIKICAgICAgIElQX1NUUgogICAgICAgIkFsdGVyIElDTVAgUm91dGVyIGRpc2NvdmVyeSBwcmVmZXJlbmNlIHRoaXMgaW50ZXJmYWNlXG4iCiAgICAgICAiUmVtb3ZlcyBJUkRQIG5vbi1kZWZhdWx0IHByZWZlcmVuY2VcbiIKICAgICAgICJTZWxlY3QgSVJEUCBhZGRyZXNzXG4iCiAgICAgICAiT2xkIHByZWZlcmVuY2UgbGV2ZWxcbiIpCnsKICBzdHJ1Y3QgbGlzdG5vZGUgKm5vZGUsICpubm9kZTsKICBzdHJ1Y3QgaW5fYWRkciBpcDsgCiAgaW50IHByZWY7CiAgaW50IHJldDsKICBzdHJ1Y3QgaW50ZXJmYWNlICppZnA7CiAgc3RydWN0IHplYnJhX2lmICp6aTsKICBzdHJ1Y3QgaXJkcF9pbnRlcmZhY2UgKmlyZHA7CiAgc3RydWN0IEFkdiAqYWR2OwoKICBpZnAgPSAoc3RydWN0IGludGVyZmFjZSAqKSB2dHktPmluZGV4OwogIGlmKCFpZnApIHsKCSAgcmV0dXJuIENNRF9XQVJOSU5HOwogIH0KCiAgemk9aWZwLT5pbmZvOwogIGlyZHA9JnppLT5pcmRwOwoKICByZXQgPSBpbmV0X2F0b24oYXJndlswXSwgJmlwKTsKICBpZiAoIXJldCkgCiAgICByZXR1cm4gQ01EX1dBUk5JTkc7CgogIHByZWYgPSBhdG9pKGFyZ3ZbMV0pOwoKICBmb3IgKG5vZGUgPSBsaXN0aGVhZCAoaXJkcC0+QWR2UHJlZkxpc3QpOyBub2RlOyBub2RlID0gbm5vZGUpCiAgICB7CiAgICAgIG5ub2RlID0gbm9kZS0+bmV4dDsKICAgICAgYWR2ID0gZ2V0ZGF0YSAobm9kZSk7CiAgICAgIAogICAgICBpZihhZHYtPmlwLnNfYWRkciA9PSBpcC5zX2FkZHIgKQogICAgICAgIHsKICAgICAgICAgIGxpc3Rub2RlX2RlbGV0ZShpcmRwLT5BZHZQcmVmTGlzdCwgYWR2KTsKICAgICAgICAgIGJyZWFrOwogICAgICAgIH0KICAgIH0KICAKICByZXR1cm4gQ01EX1NVQ0NFU1M7Cn0KCkRFRlVOIChpcF9pcmRwX2RlYnVnX21lc3NhZ2VzLAogICAgICAgaXBfaXJkcF9kZWJ1Z19tZXNzYWdlc19jbWQsCiAgICAgICAiaXAgaXJkcCBkZWJ1ZyBtZXNzYWdlcyIsCiAgICAgICBJUF9TVFIKICAgICAgICJJQ01QIFJvdXRlciBkaXNjb3ZlcnkgZGVidWcgQXZlcnRzLiBhbmQgU29saWNpdHMgKHNob3J0KVxuIikKewogIHN0cnVjdCBpbnRlcmZhY2UgKmlmcDsKICBzdHJ1Y3QgemVicmFfaWYgKnppOwogIHN0cnVjdCBpcmRwX2ludGVyZmFjZSAqaXJkcDsKICBpZnAgPSAoc3RydWN0IGludGVyZmFjZSAqKSB2dHktPmluZGV4OwogIGlmKCFpZnApIHsKCSAgcmV0dXJuIENNRF9XQVJOSU5HOwogIH0KCiAgemk9aWZwLT5pbmZvOwogIGlyZHA9JnppLT5pcmRwOwoKICBpcmRwLT5mbGFncyB8PSBJRl9ERUJVR19NRVNTQUdFUzsKCiAgcmV0dXJuIENNRF9TVUNDRVNTOwp9CgpERUZVTiAoaXBfaXJkcF9kZWJ1Z19taXNjLAogICAgICAgaXBfaXJkcF9kZWJ1Z19taXNjX2NtZCwKICAgICAgICJpcCBpcmRwIGRlYnVnIG1pc2MiLAogICAgICAgSVBfU1RSCiAgICAgICAiSUNNUCBSb3V0ZXIgZGlzY292ZXJ5IGRlYnVnIEF2ZXJ0cy4gYW5kIFNvbGljaXRzIChzaG9ydClcbiIpCnsKICBzdHJ1Y3QgaW50ZXJmYWNlICppZnA7CiAgc3RydWN0IHplYnJhX2lmICp6aTsKICBzdHJ1Y3QgaXJkcF9pbnRlcmZhY2UgKmlyZHA7CiAgaWZwID0gKHN0cnVjdCBpbnRlcmZhY2UgKikgdnR5LT5pbmRleDsKICBpZighaWZwKSB7CgkgIHJldHVybiBDTURfV0FSTklORzsKICB9CgogIHppPWlmcC0+aW5mbzsKICBpcmRwPSZ6aS0+aXJkcDsKCiAgaXJkcC0+ZmxhZ3MgfD0gSUZfREVCVUdfTUlTQzsKCiAgcmV0dXJuIENNRF9TVUNDRVNTOwp9CgpERUZVTiAoaXBfaXJkcF9kZWJ1Z19wYWNrZXQsCiAgICAgICBpcF9pcmRwX2RlYnVnX3BhY2tldF9jbWQsCiAgICAgICAiaXAgaXJkcCBkZWJ1ZyBwYWNrZXQiLAogICAgICAgSVBfU1RSCiAgICAgICAiSUNNUCBSb3V0ZXIgZGlzY292ZXJ5IGRlYnVnIEF2ZXJ0cy4gYW5kIFNvbGljaXRzIChzaG9ydClcbiIpCnsKICBzdHJ1Y3QgaW50ZXJmYWNlICppZnA7CiAgc3RydWN0IHplYnJhX2lmICp6aTsKICBzdHJ1Y3QgaXJkcF9pbnRlcmZhY2UgKmlyZHA7CiAgaWZwID0gKHN0cnVjdCBpbnRlcmZhY2UgKikgdnR5LT5pbmRleDsKICBpZighaWZwKSB7CgkgIHJldHVybiBDTURfV0FSTklORzsKICB9CgogIHppPWlmcC0+aW5mbzsKICBpcmRwPSZ6aS0+aXJkcDsKCiAgaXJkcC0+ZmxhZ3MgfD0gSUZfREVCVUdfUEFDS0VUOwoKICByZXR1cm4gQ01EX1NVQ0NFU1M7Cn0KCgpERUZVTiAoaXBfaXJkcF9kZWJ1Z19kaXNhYmxlLAogICAgICAgaXBfaXJkcF9kZWJ1Z19kaXNhYmxlX2NtZCwKICAgICAgICJpcCBpcmRwIGRlYnVnIGRpc2FibGUiLAogICAgICAgSVBfU1RSCiAgICAgICAiSUNNUCBSb3V0ZXIgZGlzY292ZXJ5IGRlYnVnIEF2ZXJ0cy4gYW5kIFNvbGljaXRzIChzaG9ydClcbiIpCnsKICBzdHJ1Y3QgaW50ZXJmYWNlICppZnA7CiAgc3RydWN0IHplYnJhX2lmICp6aTsKICBzdHJ1Y3QgaXJkcF9pbnRlcmZhY2UgKmlyZHA7CiAgaWZwID0gKHN0cnVjdCBpbnRlcmZhY2UgKikgdnR5LT5pbmRleDsKICBpZighaWZwKSB7CgkgIHJldHVybiBDTURfV0FSTklORzsKICB9CgogIHppPWlmcC0+aW5mbzsKICBpcmRwPSZ6aS0+aXJkcDsKCiAgaXJkcC0+ZmxhZ3MgJj0gfklGX0RFQlVHX1BBQ0tFVDsKICBpcmRwLT5mbGFncyAmPSB+SUZfREVCVUdfTUVTU0FHRVM7CiAgaXJkcC0+ZmxhZ3MgJj0gfklGX0RFQlVHX01JU0M7CgogIHJldHVybiBDTURfU1VDQ0VTUzsKfQoKdm9pZAppcmRwX2lmX2luaXQgKCkKewogIGluc3RhbGxfZWxlbWVudCAoSU5URVJGQUNFX05PREUsICZpcF9pcmRwX2Jyb2FkY2FzdF9jbWQpOwogIGluc3RhbGxfZWxlbWVudCAoSU5URVJGQUNFX05PREUsICZpcF9pcmRwX211bHRpY2FzdF9jbWQpOwogIGluc3RhbGxfZWxlbWVudCAoSU5URVJGQUNFX05PREUsICZub19pcF9pcmRwX2NtZCk7CiAgaW5zdGFsbF9lbGVtZW50IChJTlRFUkZBQ0VfTk9ERSwgJmlwX2lyZHBfc2h1dGRvd25fY21kKTsKICBpbnN0YWxsX2VsZW1lbnQgKElOVEVSRkFDRV9OT0RFLCAmbm9faXBfaXJkcF9zaHV0ZG93bl9jbWQpOwogIGluc3RhbGxfZWxlbWVudCAoSU5URVJGQUNFX05PREUsICZpcF9pcmRwX2hvbGR0aW1lX2NtZCk7CiAgaW5zdGFsbF9lbGVtZW50IChJTlRFUkZBQ0VfTk9ERSwgJmlwX2lyZHBfbWF4YWR2ZXJ0aW50ZXJ2YWxfY21kKTsKICBpbnN0YWxsX2VsZW1lbnQgKElOVEVSRkFDRV9OT0RFLCAmaXBfaXJkcF9taW5hZHZlcnRpbnRlcnZhbF9jbWQpOwogIGluc3RhbGxfZWxlbWVudCAoSU5URVJGQUNFX05PREUsICZpcF9pcmRwX3ByZWZlcmVuY2VfY21kKTsKICBpbnN0YWxsX2VsZW1lbnQgKElOVEVSRkFDRV9OT0RFLCAmaXBfaXJkcF9hZGRyZXNzX3ByZWZlcmVuY2VfY21kKTsKICBpbnN0YWxsX2VsZW1lbnQgKElOVEVSRkFDRV9OT0RFLCAmbm9faXBfaXJkcF9hZGRyZXNzX3ByZWZlcmVuY2VfY21kKTsKCiAgaW5zdGFsbF9lbGVtZW50IChJTlRFUkZBQ0VfTk9ERSwgJmlwX2lyZHBfZGVidWdfbWVzc2FnZXNfY21kKTsKICBpbnN0YWxsX2VsZW1lbnQgKElOVEVSRkFDRV9OT0RFLCAmaXBfaXJkcF9kZWJ1Z19taXNjX2NtZCk7CiAgaW5zdGFsbF9lbGVtZW50IChJTlRFUkZBQ0VfTk9ERSwgJmlwX2lyZHBfZGVidWdfcGFja2V0X2NtZCk7CiAgaW5zdGFsbF9lbGVtZW50IChJTlRFUkZBQ0VfTk9ERSwgJmlwX2lyZHBfZGVidWdfZGlzYWJsZV9jbWQpOwp9CgojZW5kaWYgLyogSEFWRV9JUkRQICovCg==