LyoKICoKICogdGRmeGZiLmMKICoKICogQXV0aG9yOiBIYW5udSBNYWxsYXQgPGhtYWxsYXRAY2MuaHV0LmZpPgogKgogKiBDb3B5cmlnaHQgqSAxOTk5IEhhbm51IE1hbGxhdAogKiBBbGwgcmlnaHRzIHJlc2VydmVkCiAqCiAqIENyZWF0ZWQgICAgICA6IFRodSBTZXAgMjMgMTg6MTc6NDMgMTk5OSwgaG1hbGxhdAogKiBMYXN0IG1vZGlmaWVkOiBUdWUgTm92ICAyIDIxOjE5OjQ3IDE5OTksIGhtYWxsYXQKICoKICogTG90cyBvZiB0aGUgaW5mb3JtYXRpb24gaGVyZSBjb21lcyBmcm9tIHRoZSBEYXJ5bGwgU3RyYXVzcycgQmFuc2hlZSAKICogcGF0Y2hlcyB0byB0aGUgWEY4NiBzZXJ2ZXIsIGFuZCB0aGUgcmVzdCBjb21lcyBmcm9tIHRoZSAzZGZ4CiAqIEJhbnNoZWUgc3BlY2lmaWNhdGlvbi4gSSdtIHZlcnkgbXVjaCBpbmRlYnRlZCB0byBEYXJ5bGwgZm9yIGhpcwogKiB3b3JrIG9uIHRoZSBYIHNlcnZlci4KICoKICogVm9vZG9vMyBzdXBwb3J0IHdhcyBjb250cmlidXRlZCBIYXJvbGQgT2dhLiBMb3RzIG9mIGFkZGl0aW9ucwogKiAocHJvcGVyIGFjY2VsZXJhdGlvbiwgMjQgYnBwLCBoYXJkd2FyZSBjdXJzb3IpIGFuZCBidWcgZml4ZXMgYnkgQXR0aWxhCiAqIEtlc21hcmtpLiBUaGFua3MgZ3V5cyEKICoKICogVm9vZG9vMSBhbmQgVm9vZG9vMiBzdXBwb3J0IGFyZW4ndCByZWxldmFudCB0byB0aGlzIGRyaXZlciBhcyB0aGV5CiAqIGJlaGF2ZSB2ZXJ5IGRpZmZlcmVudGx5IGZyb20gdGhlIFZvb2RvbzMvNC81LiBGb3IgYW55b25lIHdhbnRpbmcgdG8KICogdXNlIGZyYW1lIGJ1ZmZlciBvbiB0aGUgVm9vZG9vMS8yLCBzZWUgdGhlIHNzdGZiIGRyaXZlciAod2hpY2ggaXMKICogbG9jYXRlZCBhdCBodHRwOi8vd3d3LnNvdXJjZWZvcmdlLm5ldC9wcm9qZWN0cy9zc3RmYikuCiAqIAogKiBXaGlsZSBJIF9hbV8gZ3JhdGVmdWwgdG8gM0RmeCBmb3IgcmVsZWFzaW5nIHRoZSBzcGVjcyBmb3IgQmFuc2hlZSwKICogSSBkbyB3aXNoIHRoZSBuZXh0IHZlcnNpb24gaXMgYSBiaXQgbW9yZSBjb21wbGV0ZS4gV2l0aG91dCB0aGUgWEY4NgogKiBwYXRjaGVzIEkgY291bGRuJ3QgaGF2ZSBnb3R0ZW4gZXZlbiB0aGlzIGZhci4uLiBmb3IgaW5zdGFuY2UsIHRoZQogKiBleHRlbnNpb25zIHRvIHRoZSBWR0EgcmVnaXN0ZXIgc2V0IGdvIGNvbXBsZXRlbHkgdW5tZW50aW9uZWQgaW4gdGhlCiAqIHNwZWMhIEFsc28sIGxvdHMgb2YgcmVmZXJlbmNlcyBhcmUgbWFkZSB0byB0aGUgJ1NTVCBjb3JlJywgYnV0IG5vCiAqIHNwZWMgaXMgcHVibGljbHkgYXZhaWxhYmxlLCBBRkFJSy4KICoKICogVGhlIHN0cnVjdHVyZSBvZiB0aGlzIGRyaXZlciBjb21lcyBwcmV0dHkgbXVjaCBmcm9tIHRoZSBQZXJtZWRpYQogKiBkcml2ZXIgYnkgSWxhcmlvIE5hcmRpbm9jY2hpLCB3aGljaCBpbiB0dXJuIGlzIGJhc2VkIG9uIHNrZWxldG9uZmIuCiAqIAogKiBUT0RPOgogKiAtIHN1cHBvcnQgZm9yIDE2LzMyIGJwcCBuZWVkcyBmaXhpbmcgKGZ1bmt5IGJvb3R1cCBwZW5ndWluKQogKiAtIG11bHRpaGVhZCBzdXBwb3J0IChiYXNpY2FsbHkgbmVlZCB0byBzdXBwb3J0IGFuIGFycmF5IG9mIGZiX2luZm9zKQogKiAtIHN1cHBvcnQgb3RoZXIgYXJjaGl0ZWN0dXJlcyAoUFBDLCBBbHBoYSk7IGRvZXMgdGhlIGZhY3QgdGhhdCB0aGUgVkdBCiAqICAgY29yZSBjYW4gYmUgYWNjZXNzZWQgb25seSB0aHJ1IEkvTyAobm90IG1lbW9yeSBtYXBwZWQpIGNvbXBsaWNhdGUKICogICB0aGluZ3M/CiAqCiAqIFZlcnNpb24gaGlzdG9yeToKICoKICogMC4xLjQgKHJlbGVhc2VkIDIwMDItMDUtMjgpIHBvcnRlZCBvdmVyIHRvIG5ldyBmYmRldiBhcGkgYnkgSmFtZXMgU2ltbW9ucwogKgogKiAwLjEuMyAocmVsZWFzZWQgMTk5OS0xMS0wMikgYWRkZWQgQXR0aWxhJ3MgcGFubmluZyBzdXBwb3J0LCBjb2RlCiAqCQkJICAgICAgIHJlb3JnLCBod2N1cnNvciBhZGRyZXNzIHBhZ2Ugc2l6ZSBhbGlnbm1lbnQKICogICAgICAgICAgICAgICAgICAgICAgICAgICAgIChmb3IgbW1hcGluZyBib3RoIGZyYW1lIGJ1ZmZlciBhbmQgcmVncyksCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhbmQgbXkgY2hhbmdlcyB0byBnZXQgcmlkIG9mIGhhcmRjb2RlZAogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVkdBIGkvbyByZWdpc3RlciBsb2NhdGlvbnMgKHVzZXMgUENJCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25maWd1cmF0aW9uIGluZm8gbm93KQogKiAwLjEuMiAocmVsZWFzZWQgMTk5OS0xMC0xOSkgYWRkZWQgQXR0aWxhIEtlc21hcmtpJ3MgYnVnIGZpeGVzIGFuZAogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW1wcm92ZW1lbnRzCiAqIDAuMS4xIChyZWxlYXNlZCAxOTk5LTEwLTA3KSBhZGRlZCBWb29kb28zIHN1cHBvcnQgYnkgSGFyb2xkIE9nYS4KICogMC4xLjAgKHJlbGVhc2VkIDE5OTktMTAtMDYpIGluaXRpYWwgdmVyc2lvbgogKgogKi8KCiNpbmNsdWRlIDxsaW51eC9jb25maWcuaD4KI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgojaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgojaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiNpbmNsdWRlIDxsaW51eC9tbS5oPgojaW5jbHVkZSA8bGludXgvdHR5Lmg+CiNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgojaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiNpbmNsdWRlIDxsaW51eC9mYi5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgvcGNpLmg+CiNpbmNsdWRlIDxsaW51eC9udnJhbS5oPgojaW5jbHVkZSA8YXNtL2lvLmg+CiNpbmNsdWRlIDxsaW51eC90aW1lci5oPgojaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KCiNpbmNsdWRlIDx2aWRlby90ZGZ4Lmg+CgojdW5kZWYgVERGWEZCX0RFQlVHIAojaWZkZWYgVERGWEZCX0RFQlVHCiNkZWZpbmUgRFBSSU5USyhhLGIuLi4pIHByaW50ayhLRVJOX0RFQlVHICJmYjogJXM6ICIgYSwgX19GVU5DVElPTl9fICwgIyMgYikKI2Vsc2UKI2RlZmluZSBEUFJJTlRLKGEsYi4uLikKI2VuZGlmIAoKI2RlZmluZSBCQU5TSEVFX01BWF9QSVhDTE9DSyAyNzAwMDAuMAojZGVmaW5lIFZPT0RPTzNfTUFYX1BJWENMT0NLIDMwMDAwMC4wCiNkZWZpbmUgVk9PRE9PNV9NQVhfUElYQ0xPQ0sgMzUwMDAwLjAKCnN0YXRpYyBzdHJ1Y3QgZmJfZml4X3NjcmVlbmluZm8gdGRmeF9maXggX19pbml0ZGF0YSA9IHsKCS5pZCA9CQkiM0RmeCIsCgkudHlwZSA9CQlGQl9UWVBFX1BBQ0tFRF9QSVhFTFMsCgkudmlzdWFsID0JRkJfVklTVUFMX1BTRVVET0NPTE9SLCAKCS55cGFuc3RlcCA9CTEsCgkueXdyYXBzdGVwID0JMSwgCgkuYWNjZWwgPQlGQl9BQ0NFTF8zREZYX0JBTlNIRUUKfTsKCnN0YXRpYyBzdHJ1Y3QgZmJfdmFyX3NjcmVlbmluZm8gdGRmeF92YXIgX19pbml0ZGF0YSA9IHsKCS8qICI2NDB4NDgwLCA4IGJwcCBAIDYwIEh6ICovCgkueHJlcyA9CQk2NDAsCgkueXJlcyA9CQk0ODAsCgkueHJlc192aXJ0dWFsID0JNjQwLAoJLnlyZXNfdmlydHVhbCA9CTEwMjQsCgkuYml0c19wZXJfcGl4ZWwgPTgsCgkucmVkID0JCXswLCA4LCAwfSwKCS5ibHVlID0JCXswLCA4LCAwfSwKCS5ncmVlbiA9CXswLCA4LCAwfSwKCS5hY3RpdmF0ZSA9CUZCX0FDVElWQVRFX05PVywKCS5oZWlnaHQgPQktMSwKCS53aWR0aCA9CS0xLAoJLmFjY2VsX2ZsYWdzID0JRkJfQUNDRUxGX1RFWFQsCgkucGl4Y2xvY2sgPQkzOTcyMiwKCS5sZWZ0X21hcmdpbiA9CTQwLAoJLnJpZ2h0X21hcmdpbiA9CTI0LAoJLnVwcGVyX21hcmdpbiA9CTMyLAoJLmxvd2VyX21hcmdpbiA9CTExLAoJLmhzeW5jX2xlbiA9CTk2LAoJLnZzeW5jX2xlbiA9CTIsCgkudm1vZGUgPQlGQl9WTU9ERV9OT05JTlRFUkxBQ0VECn07CgovKgogKiBQQ0kgZHJpdmVyIHByb3RvdHlwZXMKICovCnN0YXRpYyBpbnQgdGRmeGZiX3Byb2JlKHN0cnVjdCBwY2lfZGV2ICpwZGV2LCBjb25zdCBzdHJ1Y3QgcGNpX2RldmljZV9pZCAqaWQpOwpzdGF0aWMgdm9pZCB0ZGZ4ZmJfcmVtb3ZlKHN0cnVjdCBwY2lfZGV2ICpwZGV2KTsKCnN0YXRpYyBzdHJ1Y3QgcGNpX2RldmljZV9pZCB0ZGZ4ZmJfaWRfdGFibGVbXSBfX2RldmluaXRkYXRhID0gewoJeyBQQ0lfVkVORE9SX0lEXzNERlgsIFBDSV9ERVZJQ0VfSURfM0RGWF9CQU5TSEVFLAoJICBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCBQQ0lfQkFTRV9DTEFTU19ESVNQTEFZIDw8IDE2LAoJICAweGZmMDAwMCwgMCB9LAoJeyBQQ0lfVkVORE9SX0lEXzNERlgsIFBDSV9ERVZJQ0VfSURfM0RGWF9WT09ET08zLAoJICBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCBQQ0lfQkFTRV9DTEFTU19ESVNQTEFZIDw8IDE2LAoJICAweGZmMDAwMCwgMCB9LAoJeyBQQ0lfVkVORE9SX0lEXzNERlgsIFBDSV9ERVZJQ0VfSURfM0RGWF9WT09ET081LAoJICBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCBQQ0lfQkFTRV9DTEFTU19ESVNQTEFZIDw8IDE2LAoJICAweGZmMDAwMCwgMCB9LAoJeyAwLCB9Cn07CgpzdGF0aWMgc3RydWN0IHBjaV9kcml2ZXIgdGRmeGZiX2RyaXZlciA9IHsKCS5uYW1lCQk9ICJ0ZGZ4ZmIiLAoJLmlkX3RhYmxlIAk9IHRkZnhmYl9pZF90YWJsZSwKCS5wcm9iZSAJCT0gdGRmeGZiX3Byb2JlLAoJLnJlbW92ZSAJPSBfX2RldmV4aXRfcCh0ZGZ4ZmJfcmVtb3ZlKSwKfTsKCk1PRFVMRV9ERVZJQ0VfVEFCTEUocGNpLCB0ZGZ4ZmJfaWRfdGFibGUpOwoKLyoKICogIEZyYW1lIGJ1ZmZlciBkZXZpY2UgQVBJCiAqLwppbnQgdGRmeGZiX2luaXQodm9pZCk7CnZvaWQgdGRmeGZiX3NldHVwKGNoYXIgKm9wdGlvbnMsIGludCAqaW50cyk7IAoKc3RhdGljIGludCB0ZGZ4ZmJfY2hlY2tfdmFyKHN0cnVjdCBmYl92YXJfc2NyZWVuaW5mbyAqdmFyLCBzdHJ1Y3QgZmJfaW5mbyAqZmIpOyAKc3RhdGljIGludCB0ZGZ4ZmJfc2V0X3BhcihzdHJ1Y3QgZmJfaW5mbyAqaW5mbyk7IApzdGF0aWMgaW50IHRkZnhmYl9zZXRjb2xyZWcodV9pbnQgcmVnbm8sIHVfaW50IHJlZCwgdV9pbnQgZ3JlZW4sIHVfaW50IGJsdWUsIAoJCQkgICAgdV9pbnQgdHJhbnNwLCBzdHJ1Y3QgZmJfaW5mbyAqaW5mbyk7IApzdGF0aWMgaW50IHRkZnhmYl9ibGFuayhpbnQgYmxhbmssIHN0cnVjdCBmYl9pbmZvICppbmZvKTsgCnN0YXRpYyBpbnQgdGRmeGZiX3Bhbl9kaXNwbGF5KHN0cnVjdCBmYl92YXJfc2NyZWVuaW5mbyAqdmFyLCBzdHJ1Y3QgZmJfaW5mbyAqaW5mbyk7CnN0YXRpYyB2b2lkIHRkZnhmYl9maWxscmVjdChzdHJ1Y3QgZmJfaW5mbyAqaW5mbywgc3RydWN0IGZiX2ZpbGxyZWN0ICpyZWN0KTsKc3RhdGljIHZvaWQgdGRmeGZiX2NvcHlhcmVhKHN0cnVjdCBmYl9pbmZvICppbmZvLCBzdHJ1Y3QgZmJfY29weWFyZWEgKmFyZWEpOyAgCnN0YXRpYyB2b2lkIHRkZnhmYl9pbWFnZWJsaXQoc3RydWN0IGZiX2luZm8gKmluZm8sIHN0cnVjdCBmYl9pbWFnZSAqaW1hZ2UpOyAKc3RhdGljIGludCB0ZGZ4ZmJfY3Vyc29yKHN0cnVjdCBmYl9pbmZvICppbmZvLCBzdHJ1Y3QgZmJfY3Vyc29yICpjdXJzb3IpOwpzdGF0aWMgaW50IGJhbnNoZWVfd2FpdF9pZGxlKHN0cnVjdCBmYl9pbmZvICppbmZvKTsKCnN0YXRpYyBzdHJ1Y3QgZmJfb3BzIHRkZnhmYl9vcHMgPSB7Cgkub3duZXIJCT0gVEhJU19NT0RVTEUsCgkuZmJfY2hlY2tfdmFyCT0gdGRmeGZiX2NoZWNrX3ZhciwKCS5mYl9zZXRfcGFyCT0gdGRmeGZiX3NldF9wYXIsCgkuZmJfc2V0Y29scmVnCT0gdGRmeGZiX3NldGNvbHJlZywKCS5mYl9ibGFuawk9IHRkZnhmYl9ibGFuaywKCS5mYl9wYW5fZGlzcGxheQk9IHRkZnhmYl9wYW5fZGlzcGxheSwKCS5mYl9maWxscmVjdAk9IHRkZnhmYl9maWxscmVjdCwKCS5mYl9jb3B5YXJlYQk9IHRkZnhmYl9jb3B5YXJlYSwKCS5mYl9pbWFnZWJsaXQJPSB0ZGZ4ZmJfaW1hZ2VibGl0LAoJLmZiX3N5bmMJPSBiYW5zaGVlX3dhaXRfaWRsZSwKCS5mYl9jdXJzb3IJPSBzb2Z0X2N1cnNvciwKfTsKCi8qCiAqIGRvX3h4eDogSGFyZHdhcmUtc3BlY2lmaWMgZnVuY3Rpb25zCiAqLwpzdGF0aWMgdTMyIGRvX2NhbGNfcGxsKGludCBmcmVxLCBpbnQgKmZyZXFfb3V0KTsKc3RhdGljIHZvaWQgIGRvX3dyaXRlX3JlZ3Moc3RydWN0IGZiX2luZm8gKmluZm8sIHN0cnVjdCBiYW5zaGVlX3JlZyAqcmVnKTsKc3RhdGljIHVuc2lnbmVkIGxvbmcgZG9fbGZiX3NpemUoc3RydWN0IHRkZnhfcGFyICpwYXIsIHVuc2lnbmVkIHNob3J0KTsKCi8qCiAqIERyaXZlciBkYXRhIAogKi8Kc3RhdGljIGludCAgbm9wYW4gICA9IDA7CnN0YXRpYyBpbnQgIG5vd3JhcCAgPSAxOyAgICAgIC8vIG5vdCBpbXBsZW1lbnRlZCAoeWV0KQpzdGF0aWMgaW50ICBpbnZlcnNlID0gMDsKc3RhdGljIGNoYXIgKm1vZGVfb3B0aW9uIF9faW5pdGRhdGEgPSBOVUxMOwoKLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAKICogICAgICAgICAgICAgICAgICAgICAgSGFyZHdhcmUtc3BlY2lmaWMgZnVuY2lvbnMKICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKI2lmZGVmIFZHQV9SRUdfSU8gCnN0YXRpYyBpbmxpbmUgIHU4IHZnYV9pbmIoc3RydWN0IHRkZnhfcGFyICpwYXIsIHUzMiByZWcpIHsgcmV0dXJuIGluYihyZWcpOyB9CnN0YXRpYyBpbmxpbmUgdTE2IHZnYV9pbncoc3RydWN0IHRkZnhfcGFyICpwYXIsIHUzMiByZWcpIHsgcmV0dXJuIGludyhyZWcpOyB9CnN0YXRpYyBpbmxpbmUgdTE2IHZnYV9pbmwoc3RydWN0IHRkZnhfcGFyICpwYXIsIHUzMiByZWcpIHsgcmV0dXJuIGlubChyZWcpOyB9CgpzdGF0aWMgaW5saW5lIHZvaWQgdmdhX291dGIoc3RydWN0IHRkZnhfcGFyICpwYXIsIHUzMiByZWcsICB1OCB2YWwpIHsgb3V0Yih2YWwsIHJlZyk7IH0Kc3RhdGljIGlubGluZSB2b2lkIHZnYV9vdXR3KHN0cnVjdCB0ZGZ4X3BhciAqcGFyLCB1MzIgcmVnLCB1MTYgdmFsKSB7IG91dHcodmFsLCByZWcpOyB9CnN0YXRpYyBpbmxpbmUgdm9pZCB2Z2Ffb3V0bChzdHJ1Y3QgdGRmeF9wYXIgKnBhciwgdTMyIHJlZywgdTMyIHZhbCkgeyBvdXRsKHZhbCwgcmVnKTsgfQojZWxzZQpzdGF0aWMgaW5saW5lICB1OCB2Z2FfaW5iKHN0cnVjdCB0ZGZ4X3BhciAqcGFyLCB1MzIgcmVnKSB7IAoJcmV0dXJuIGluYihwYXItPmlvYmFzZSArIHJlZyAtIDB4MzAwKTsgCn0Kc3RhdGljIGlubGluZSB1MTYgdmdhX2ludyhzdHJ1Y3QgdGRmeF9wYXIgKnBhciwgdTMyIHJlZykgeyAKCXJldHVybiBpbncocGFyLT5pb2Jhc2UgKyByZWcgLSAweDMwMCk7IAp9CnN0YXRpYyBpbmxpbmUgdTE2IHZnYV9pbmwoc3RydWN0IHRkZnhfcGFyICpwYXIsIHUzMiByZWcpIHsgCglyZXR1cm4gaW5sKHBhci0+aW9iYXNlICsgcmVnIC0gMHgzMDApOyAKfQpzdGF0aWMgaW5saW5lIHZvaWQgdmdhX291dGIoc3RydWN0IHRkZnhfcGFyICpwYXIsIHUzMiByZWcsICB1OCB2YWwpIHsgCglvdXRiKHZhbCwgcGFyLT5pb2Jhc2UgKyByZWcgLSAweDMwMCk7IAp9CnN0YXRpYyBpbmxpbmUgdm9pZCB2Z2Ffb3V0dyhzdHJ1Y3QgdGRmeF9wYXIgKnBhciwgdTMyIHJlZywgdTE2IHZhbCkgeyAKCW91dHcodmFsLCBwYXItPmlvYmFzZSArIHJlZyAtIDB4MzAwKTsgCn0Kc3RhdGljIGlubGluZSB2b2lkIHZnYV9vdXRsKHN0cnVjdCB0ZGZ4X3BhciAqcGFyLCB1MzIgcmVnLCB1MzIgdmFsKSB7IAoJb3V0bCh2YWwsIHBhci0+aW9iYXNlICsgcmVnIC0gMHgzMDApOyAKfQojZW5kaWYKCnN0YXRpYyBpbmxpbmUgdm9pZCBncmFfb3V0YihzdHJ1Y3QgdGRmeF9wYXIgKnBhciwgdTMyIGlkeCwgdTggdmFsKSB7Cgl2Z2Ffb3V0YihwYXIsIEdSQV9JLCBpZHgpOyB2Z2Ffb3V0YihwYXIsIEdSQV9ELCB2YWwpOwp9CgpzdGF0aWMgaW5saW5lIHU4IGdyYV9pbmIoc3RydWN0IHRkZnhfcGFyICpwYXIsIHUzMiBpZHgpIHsKCXZnYV9vdXRiKHBhciwgR1JBX0ksIGlkeCk7IHJldHVybiB2Z2FfaW5iKHBhciwgR1JBX0QpOwp9CgpzdGF0aWMgaW5saW5lIHZvaWQgc2VxX291dGIoc3RydWN0IHRkZnhfcGFyICpwYXIsIHUzMiBpZHgsIHU4IHZhbCkgewoJdmdhX291dGIocGFyLCBTRVFfSSwgaWR4KTsgdmdhX291dGIocGFyLCBTRVFfRCwgdmFsKTsKfQoKc3RhdGljIGlubGluZSB1OCBzZXFfaW5iKHN0cnVjdCB0ZGZ4X3BhciAqcGFyLCB1MzIgaWR4KSB7Cgl2Z2Ffb3V0YihwYXIsIFNFUV9JLCBpZHgpOyByZXR1cm4gdmdhX2luYihwYXIsIFNFUV9EKTsKfQoKc3RhdGljIGlubGluZSB2b2lkIGNydF9vdXRiKHN0cnVjdCB0ZGZ4X3BhciAqcGFyLCB1MzIgaWR4LCB1OCB2YWwpIHsKCXZnYV9vdXRiKHBhciwgQ1JUX0ksIGlkeCk7IHZnYV9vdXRiKHBhciwgQ1JUX0QsIHZhbCk7Cn0KCnN0YXRpYyBpbmxpbmUgdTggY3J0X2luYihzdHJ1Y3QgdGRmeF9wYXIgKnBhciwgdTMyIGlkeCkgewoJdmdhX291dGIocGFyLCBDUlRfSSwgaWR4KTsgcmV0dXJuIHZnYV9pbmIocGFyLCBDUlRfRCk7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCBhdHRfb3V0YihzdHJ1Y3QgdGRmeF9wYXIgKnBhciwgdTMyIGlkeCwgdTggdmFsKSAKewoJdW5zaWduZWQgY2hhciB0bXA7CgkKCXRtcCA9IHZnYV9pbmIocGFyLCBJUzFfUik7Cgl2Z2Ffb3V0YihwYXIsIEFUVF9JVywgaWR4KTsKCXZnYV9vdXRiKHBhciwgQVRUX0lXLCB2YWwpOwp9CgpzdGF0aWMgaW5saW5lIHU4IGF0dF9pbmIoc3RydWN0IHRkZnhfcGFyICpwYXIsIHUzMiBpZHgpIAp7Cgl1bnNpZ25lZCBjaGFyIHRtcDsKCgl0bXAgPSB2Z2FfaW5iKHBhciwgSVMxX1IpOwoJdmdhX291dGIocGFyLCBBVFRfSVcsIGlkeCk7CglyZXR1cm4gdmdhX2luYihwYXIsIEFUVF9JVyk7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCB2Z2FfZGlzYWJsZV92aWRlbyhzdHJ1Y3QgdGRmeF9wYXIgKnBhcikKewoJdW5zaWduZWQgY2hhciBzOwoKCXMgPSBzZXFfaW5iKHBhciwgMHgwMSkgfCAweDIwOwoJc2VxX291dGIocGFyLCAweDAwLCAweDAxKTsKCXNlcV9vdXRiKHBhciwgMHgwMSwgcyk7CglzZXFfb3V0YihwYXIsIDB4MDAsIDB4MDMpOwp9CgpzdGF0aWMgaW5saW5lIHZvaWQgdmdhX2VuYWJsZV92aWRlbyhzdHJ1Y3QgdGRmeF9wYXIgKnBhcikKewoJdW5zaWduZWQgY2hhciBzOwoKCXMgPSBzZXFfaW5iKHBhciwgMHgwMSkgJiAweGRmOwoJc2VxX291dGIocGFyLCAweDAwLCAweDAxKTsKCXNlcV9vdXRiKHBhciwgMHgwMSwgcyk7CglzZXFfb3V0YihwYXIsIDB4MDAsIDB4MDMpOwp9CgpzdGF0aWMgaW5saW5lIHZvaWQgdmdhX2Rpc2FibGVfcGFsZXR0ZShzdHJ1Y3QgdGRmeF9wYXIgKnBhcikKewoJdmdhX2luYihwYXIsIElTMV9SKTsKCXZnYV9vdXRiKHBhciwgQVRUX0lXLCAweDAwKTsKfQoKc3RhdGljIGlubGluZSB2b2lkIHZnYV9lbmFibGVfcGFsZXR0ZShzdHJ1Y3QgdGRmeF9wYXIgKnBhcikKewoJdmdhX2luYihwYXIsIElTMV9SKTsKCXZnYV9vdXRiKHBhciwgQVRUX0lXLCAweDIwKTsKfQoKc3RhdGljIGlubGluZSB1MzIgdGRmeF9pbmwoc3RydWN0IHRkZnhfcGFyICpwYXIsIHVuc2lnbmVkIGludCByZWcpIAp7CglyZXR1cm4gcmVhZGwocGFyLT5yZWdiYXNlX3ZpcnQgKyByZWcpOwp9CgpzdGF0aWMgaW5saW5lIHZvaWQgdGRmeF9vdXRsKHN0cnVjdCB0ZGZ4X3BhciAqcGFyLCB1bnNpZ25lZCBpbnQgcmVnLCB1MzIgdmFsKQp7Cgl3cml0ZWwodmFsLCBwYXItPnJlZ2Jhc2VfdmlydCArIHJlZyk7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCBiYW5zaGVlX21ha2Vfcm9vbShzdHJ1Y3QgdGRmeF9wYXIgKnBhciwgaW50IHNpemUpCnsKCXdoaWxlKCh0ZGZ4X2lubChwYXIsIFNUQVRVUykgJiAweDFmKSA8IHNpemUpOwp9CiAKc3RhdGljIGludCBiYW5zaGVlX3dhaXRfaWRsZShzdHJ1Y3QgZmJfaW5mbyAqaW5mbykKewoJc3RydWN0IHRkZnhfcGFyICpwYXIgPSAoc3RydWN0IHRkZnhfcGFyICopIGluZm8tPnBhcjsgCglpbnQgaSA9IDA7CgoJYmFuc2hlZV9tYWtlX3Jvb20ocGFyLCAxKTsKCXRkZnhfb3V0bChwYXIsIENPTU1BTkRfM0QsIENPTU1BTkRfM0RfTk9QKTsKCgl3aGlsZSgxKSB7CgkJaSA9ICh0ZGZ4X2lubChwYXIsIFNUQVRVUykgJiBTVEFUVVNfQlVTWSkgPyAwIDogaSArIDE7CgkJaWYoaSA9PSAzKSBicmVhazsKCX0KCXJldHVybiAwOwp9CgovKgogKiBTZXQgdGhlIGNvbG9yIG9mIGEgcGFsZXR0ZSBlbnRyeSBpbiA4YnBwIG1vZGUgCiAqLwpzdGF0aWMgaW5saW5lIHZvaWQgZG9fc2V0cGFsZW50cnkoc3RydWN0IHRkZnhfcGFyICpwYXIsIHVuc2lnbmVkIHJlZ25vLCB1MzIgYykKeyAgCgliYW5zaGVlX21ha2Vfcm9vbShwYXIsIDIpOwoJdGRmeF9vdXRsKHBhciwgREFDQUREUiwgcmVnbm8pOwoJdGRmeF9vdXRsKHBhciwgREFDREFUQSwgYyk7Cn0KCnN0YXRpYyB1MzIgZG9fY2FsY19wbGwoaW50IGZyZXEsIGludCogZnJlcV9vdXQpIAp7CglpbnQgbSwgbiwgaywgYmVzdF9tLCBiZXN0X24sIGJlc3RfaywgZl9jdXIsIGJlc3RfZXJyb3I7CglpbnQgZnJlZiA9IDE0MzE4OwogIAoJLyogdGhpcyByZWFsbHkgY291bGQgYmUgZG9uZSB3aXRoIG1vcmUgaW50ZWxsaWdlbmNlIC0tCgkgICAyNTUqNjMqNCA9IDY0MjYwIGl0ZXJhdGlvbnMgaXMgc2lsbHkgKi8KCWJlc3RfZXJyb3IgPSBmcmVxOwoJYmVzdF9uID0gYmVzdF9tID0gYmVzdF9rID0gMDsKCWZvciAobiA9IDE7IG4gPCAyNTY7IG4rKykgewoJCWZvciAobSA9IDE7IG0gPCA2NDsgbSsrKSB7CgkJCWZvciAoayA9IDA7IGsgPCA0OyBrKyspIHsKCQkJCWZfY3VyID0gZnJlZioobiArIDIpLyhtICsgMikvKDEgPDwgayk7CgkJCQlpZiAoYWJzKGZfY3VyIC0gZnJlcSkgPCBiZXN0X2Vycm9yKSB7CgkJCQkJYmVzdF9lcnJvciA9IGFicyhmX2N1ci1mcmVxKTsKCQkJCQliZXN0X24gPSBuOwoJCQkJCWJlc3RfbSA9IG07CgkJCQkJYmVzdF9rID0gazsKCQkJCX0KCQkJfQoJCX0KCX0KCW4gPSBiZXN0X247CgltID0gYmVzdF9tOwoJayA9IGJlc3RfazsKCSpmcmVxX291dCA9IGZyZWYqKG4gKyAyKS8obSArIDIpLygxIDw8IGspOwoJcmV0dXJuIChuIDw8IDgpIHwgKG0gPDwgMikgfCBrOwp9CgpzdGF0aWMgdm9pZCBkb193cml0ZV9yZWdzKHN0cnVjdCBmYl9pbmZvICppbmZvLCBzdHJ1Y3QgYmFuc2hlZV9yZWcqIHJlZykgCnsKCXN0cnVjdCB0ZGZ4X3BhciAqcGFyID0gKHN0cnVjdCB0ZGZ4X3BhciAqKSBpbmZvLT5wYXI7IAoJaW50IGk7CgoJYmFuc2hlZV93YWl0X2lkbGUoaW5mbyk7CgoJdGRmeF9vdXRsKHBhciwgTUlTQ0lOSVQxLCB0ZGZ4X2lubChwYXIsIE1JU0NJTklUMSkgfCAweDAxKTsKCgljcnRfb3V0YihwYXIsIDB4MTEsIGNydF9pbmIocGFyLCAweDExKSAmIDB4N2YpOyAvKiBDUlQgdW5wcm90ZWN0ICovCgoJYmFuc2hlZV9tYWtlX3Jvb20ocGFyLCAzKTsKCXRkZnhfb3V0bChwYXIsIFZHQUlOSVQxLAlyZWctPnZnYWluaXQxICYgIDB4MDAxRkZGRkYpOwoJdGRmeF9vdXRsKHBhciwgVklEUFJPQ0NGRywJcmVnLT52aWRjZmcgICAmIH4weDAwMDAwMDAxKTsKI2lmIDAKCXRkZnhfb3V0bChwYXIsIFBMTENUUkwxLCByZWctPm1lbXBsbCk7Cgl0ZGZ4X291dGwocGFyLCBQTExDVFJMMiwgcmVnLT5nZnhwbGwpOwojZW5kaWYKCXRkZnhfb3V0bChwYXIsIFBMTENUUkwwLAlyZWctPnZpZHBsbCk7CgoJdmdhX291dGIocGFyLCBNSVNDX1csIHJlZy0+bWlzY1sweDAwXSB8IDB4MDEpOwoKCWZvciAoaSA9IDA7IGkgPCA1OyBpKyspCgkJc2VxX291dGIocGFyLCBpLCByZWctPnNlcVtpXSk7CgoJZm9yIChpID0gMDsgaSA8IDI1OyBpKyspCgkJY3J0X291dGIocGFyLCBpLCByZWctPmNydFtpXSk7CgoJZm9yIChpID0gMDsgaSA8IDk7IGkrKykKCQlncmFfb3V0YihwYXIsIGksIHJlZy0+Z3JhW2ldKTsKCglmb3IgKGkgPSAwOyBpIDwgMjE7IGkrKykKCQlhdHRfb3V0YihwYXIsIGksIHJlZy0+YXR0W2ldKTsKCgljcnRfb3V0YihwYXIsIDB4MWEsIHJlZy0+ZXh0WzBdKTsKCWNydF9vdXRiKHBhciwgMHgxYiwgcmVnLT5leHRbMV0pOwoKCXZnYV9lbmFibGVfcGFsZXR0ZShwYXIpOwoJdmdhX2VuYWJsZV92aWRlbyhwYXIpOwoKCWJhbnNoZWVfbWFrZV9yb29tKHBhciwgMTEpOwoJdGRmeF9vdXRsKHBhciwgCVZHQUlOSVQwLCAgICAgIHJlZy0+dmdhaW5pdDApOwoJdGRmeF9vdXRsKHBhciwJREFDTU9ERSwgICAgICAgcmVnLT5kYWNtb2RlKTsKCXRkZnhfb3V0bChwYXIsCVZJRERFU0tTVFJJREUsIHJlZy0+c3RyaWRlKTsKCXRkZnhfb3V0bChwYXIsCUhXQ1VSUEFUQUREUiwgIDApOwogICAKCXRkZnhfb3V0bChwYXIsCVZJRFNDUkVFTlNJWkUscmVnLT5zY3JlZW5zaXplKTsKCXRkZnhfb3V0bChwYXIsCVZJRERFU0tTVEFSVCwJcmVnLT5zdGFydGFkZHIpOwoJdGRmeF9vdXRsKHBhciwJVklEUFJPQ0NGRywJcmVnLT52aWRjZmcpOwoJdGRmeF9vdXRsKHBhciwJVkdBSU5JVDEsCXJlZy0+dmdhaW5pdDEpOyAgCgl0ZGZ4X291dGwocGFyLAlNSVNDSU5JVDAsCXJlZy0+bWlzY2luaXQwKTsJCgoJYmFuc2hlZV9tYWtlX3Jvb20ocGFyLAk4KTsKCXRkZnhfb3V0bChwYXIsCVNSQ0JBU0UsICAgICAgICAgcmVnLT5zcmNiYXNlKTsKCXRkZnhfb3V0bChwYXIsCURTVEJBU0UsICAgICAgICAgcmVnLT5kc3RiYXNlKTsKCXRkZnhfb3V0bChwYXIsCUNPTU1BTkRFWFRSQV8yRCwgMCk7Cgl0ZGZ4X291dGwocGFyLAlDTElQME1JTiwgICAgICAgIDApOwoJdGRmeF9vdXRsKHBhciwJQ0xJUDBNQVgsICAgICAgICAweDBmZmYwZmZmKTsKCXRkZnhfb3V0bChwYXIsCUNMSVAxTUlOLCAgICAgICAgMCk7Cgl0ZGZ4X291dGwocGFyLAlDTElQMU1BWCwgICAgICAgIDB4MGZmZjBmZmYpOwoJdGRmeF9vdXRsKHBhciwJU1JDWFksCSAgIDApOwoKCWJhbnNoZWVfd2FpdF9pZGxlKGluZm8pOwp9CgpzdGF0aWMgdW5zaWduZWQgbG9uZyBkb19sZmJfc2l6ZShzdHJ1Y3QgdGRmeF9wYXIgKnBhciwgdW5zaWduZWQgc2hvcnQgZGV2X2lkKSAKewoJdTMyIGRyYW1pbml0MCA9IDA7Cgl1MzIgZHJhbWluaXQxID0gMDsKCXUzMiBtaXNjaW5pdDEgPSAwOwoJdTMyIGxmYnNpemUgICA9IDA7CglpbnQgc2dyYW1fcCAgID0gMDsKCglkcmFtaW5pdDAgPSB0ZGZ4X2lubChwYXIsIERSQU1JTklUMCk7ICAKCWRyYW1pbml0MSA9IHRkZnhfaW5sKHBhciwgRFJBTUlOSVQxKTsKIAoJaWYgKChkZXZfaWQgPT0gUENJX0RFVklDRV9JRF8zREZYX0JBTlNIRUUpIHx8CgkgICAgKGRldl9pZCA9PSBQQ0lfREVWSUNFX0lEXzNERlhfVk9PRE9PMykpIHsgICAgICAgICAgICAgCSAKCQlzZ3JhbV9wID0gKGRyYW1pbml0MSAmIERSQU1JTklUMV9NRU1fU0RSQU0pID8gMCA6IDE7CiAgCglsZmJzaXplID0gc2dyYW1fcCA/CgkJKCgoZHJhbWluaXQwICYgRFJBTUlOSVQwX1NHUkFNX05VTSkgID8gMiA6IDEpICogCgkJKChkcmFtaW5pdDAgJiBEUkFNSU5JVDBfU0dSQU1fVFlQRSkgPyA4IDogNCkgKiAxMDI0ICogMTAyNCkgOgoJCTE2ICogMTAyNCAqIDEwMjQ7Cgl9IGVsc2UgewoJCS8qIFZvb2RvbzQvNSAqLwoJCXUzMiBjaGlwcywgcHNpemUsIGJhbmtzOwoKCQljaGlwcyA9ICgoZHJhbWluaXQwICYgKDEgPDwgMjYpKSA9PSAwKSA/IDQgOiA4OwoJCXBzaXplID0gMSA8PCAoKGRyYW1pbml0MCAmIDB4MzgwMDAwMDApID4+IDI4KTsKCQliYW5rcyA9ICgoZHJhbWluaXQwICYgKDEgPDwgMzApKSA9PSAwKSA/IDIgOiA0OwoJCWxmYnNpemUgPSBjaGlwcyAqIHBzaXplICogYmFua3M7CgkJbGZic2l6ZSA8PD0gMjA7Cgl9ICAgICAgICAgICAgICAgICAKCS8qIGRpc2FibGUgYmxvY2sgd3JpdGVzIGZvciBTRFJBTSAod2h5PykgKi8KCW1pc2Npbml0MSA9IHRkZnhfaW5sKHBhciwgTUlTQ0lOSVQxKTsKCW1pc2Npbml0MSB8PSBzZ3JhbV9wID8gMCA6IE1JU0NJTklUMV8yREJMT0NLX0RJUzsKCW1pc2Npbml0MSB8PSBNSVNDSU5JVDFfQ0xVVF9JTlY7CgoJYmFuc2hlZV9tYWtlX3Jvb20ocGFyLCAxKTsgCgl0ZGZ4X291dGwocGFyLCBNSVNDSU5JVDEsIG1pc2Npbml0MSk7CglyZXR1cm4gbGZic2l6ZTsKfQoKLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwoKc3RhdGljIGludCB0ZGZ4ZmJfY2hlY2tfdmFyKHN0cnVjdCBmYl92YXJfc2NyZWVuaW5mbyAqdmFyLHN0cnVjdCBmYl9pbmZvICppbmZvKSAKewoJc3RydWN0IHRkZnhfcGFyICpwYXIgPSAoc3RydWN0IHRkZnhfcGFyICopIGluZm8tPnBhcjsgCgl1MzIgbHBpdGNoOwoKCWlmICh2YXItPmJpdHNfcGVyX3BpeGVsICE9IDggICYmIHZhci0+Yml0c19wZXJfcGl4ZWwgIT0gMTYgJiYKCSAgICB2YXItPmJpdHNfcGVyX3BpeGVsICE9IDI0ICYmIHZhci0+Yml0c19wZXJfcGl4ZWwgIT0gMzIpIHsKCQlEUFJJTlRLKCJkZXB0aCBub3Qgc3VwcG9ydGVkOiAldVxuIiwgdmFyLT5iaXRzX3Blcl9waXhlbCk7CgkJcmV0dXJuIC1FSU5WQUw7Cgl9CgoJaWYgKHZhci0+eHJlcyAhPSB2YXItPnhyZXNfdmlydHVhbCkgewoJCURQUklOVEsoInZpcnR1YWwgeCByZXNvbHV0aW9uICE9IHBoeXNpY2FsIHggcmVzb2x1dGlvbiBub3Qgc3VwcG9ydGVkXG4iKTsKCQlyZXR1cm4gLUVJTlZBTDsKCX0KCglpZiAodmFyLT55cmVzID4gdmFyLT55cmVzX3ZpcnR1YWwpIHsKCQlEUFJJTlRLKCJ2aXJ0dWFsIHkgcmVzb2x1dGlvbiA8IHBoeXNpY2FsIHkgcmVzb2x1dGlvbiBub3QgcG9zc2libGVcbiIpOwoJCXJldHVybiAtRUlOVkFMOwoJfQoKCWlmICh2YXItPnhvZmZzZXQpIHsKCQlEUFJJTlRLKCJ4b2Zmc2V0IG5vdCBzdXBwb3J0ZWRcbiIpOwoJCXJldHVybiAtRUlOVkFMOwoJfQoKCS8qIGZpeG1lOiBkb2VzIFZvb2RvbzMgc3VwcG9ydCBpbnRlcmxhY2U/IEJhbnNoZWUgZG9lc24ndCAqLwoJaWYgKCh2YXItPnZtb2RlICYgRkJfVk1PREVfTUFTSykgPT0gRkJfVk1PREVfSU5URVJMQUNFRCkgewoJCURQUklOVEsoImludGVybGFjZSBub3Qgc3VwcG9ydGVkXG4iKTsKCQlyZXR1cm4gLUVJTlZBTDsKCX0KCgl2YXItPnhyZXMgPSAodmFyLT54cmVzICsgMTUpICYgfjE1OyAvKiBjb3VsZCBzb21ldGltZXMgYmUgOCAqLwoJbHBpdGNoID0gdmFyLT54cmVzICogKCh2YXItPmJpdHNfcGVyX3BpeGVsICsgNyk+PjMpOwogIAoJaWYgKHZhci0+eHJlcyA8IDMyMCB8fCB2YXItPnhyZXMgPiAyMDQ4KSB7CgkJRFBSSU5USygid2lkdGggbm90IHN1cHBvcnRlZDogJXVcbiIsIHZhci0+eHJlcyk7CgkJcmV0dXJuIC1FSU5WQUw7Cgl9CiAgCglpZiAodmFyLT55cmVzIDwgMjAwIHx8IHZhci0+eXJlcyA+IDIwNDgpIHsKCQlEUFJJTlRLKCJoZWlnaHQgbm90IHN1cHBvcnRlZDogJXVcbiIsIHZhci0+eXJlcyk7CgkJcmV0dXJuIC1FSU5WQUw7Cgl9CiAgCglpZiAobHBpdGNoICogdmFyLT55cmVzX3ZpcnR1YWwgPiBpbmZvLT5maXguc21lbV9sZW4pIHsKCQlEUFJJTlRLKCJubyBtZW1vcnkgZm9yIHNjcmVlbiAoJXV4JXV4JXUpXG4iLAoJCXZhci0+eHJlcywgdmFyLT55cmVzX3ZpcnR1YWwsIHZhci0+Yml0c19wZXJfcGl4ZWwpOwoJCXJldHVybiAtRUlOVkFMOwoJfQogIAoJaWYgKFBJQ09TMktIWih2YXItPnBpeGNsb2NrKSA+IHBhci0+bWF4X3BpeGNsb2NrKSB7CgkJRFBSSU5USygicGl4Y2xvY2sgdG9vIGhpZ2ggKCVsZEtIeilcbiIsUElDT1MyS0haKHZhci0+cGl4Y2xvY2spKTsKCQlyZXR1cm4gLUVJTlZBTDsKCX0KCglzd2l0Y2godmFyLT5iaXRzX3Blcl9waXhlbCkgewoJCWNhc2UgODoKCQkJdmFyLT5yZWQubGVuZ3RoID0gdmFyLT5ncmVlbi5sZW5ndGggPSB2YXItPmJsdWUubGVuZ3RoID0gODsKCQkJYnJlYWs7CgkJY2FzZSAxNjoKCQkJdmFyLT5yZWQub2Zmc2V0ICAgPSAxMTsKCQkJdmFyLT5yZWQubGVuZ3RoICAgPSA1OwoJCQl2YXItPmdyZWVuLm9mZnNldCA9IDU7CgkJCXZhci0+Z3JlZW4ubGVuZ3RoID0gNjsKCQkJdmFyLT5ibHVlLm9mZnNldCAgPSAwOwoJCQl2YXItPmJsdWUubGVuZ3RoICA9IDU7CgkJCWJyZWFrOwoJCWNhc2UgMjQ6CgkJCXZhci0+cmVkLm9mZnNldD0xNjsKCQkJdmFyLT5ncmVlbi5vZmZzZXQ9ODsKCQkJdmFyLT5ibHVlLm9mZnNldD0wOwoJCQl2YXItPnJlZC5sZW5ndGggPSB2YXItPmdyZWVuLmxlbmd0aCA9IHZhci0+Ymx1ZS5sZW5ndGggPSA4OwoJCWNhc2UgMzI6CgkJCXZhci0+cmVkLm9mZnNldCAgID0gMTY7CgkJCXZhci0+Z3JlZW4ub2Zmc2V0ID0gODsKCQkJdmFyLT5ibHVlLm9mZnNldCAgPSAwOwoJCQl2YXItPnJlZC5sZW5ndGggPSB2YXItPmdyZWVuLmxlbmd0aCA9IHZhci0+Ymx1ZS5sZW5ndGggPSA4OwoJCQlicmVhazsKCX0KCXZhci0+aGVpZ2h0ID0gdmFyLT53aWR0aCA9IC0xOwogIAoJdmFyLT5hY2NlbF9mbGFncyA9IEZCX0FDQ0VMRl9URVhUOwoJCglEUFJJTlRLKCJDaGVja2luZyBncmFwaGljcyBtb2RlIGF0ICVkeCVkIGRlcHRoICVkXG4iLCAgdmFyLT54cmVzLCB2YXItPnlyZXMsIHZhci0+Yml0c19wZXJfcGl4ZWwpOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgdGRmeGZiX3NldF9wYXIoc3RydWN0IGZiX2luZm8gKmluZm8pCnsKCXN0cnVjdCB0ZGZ4X3BhciAqcGFyID0gKHN0cnVjdCB0ZGZ4X3BhciAqKSBpbmZvLT5wYXI7CQoJdTMyIGhkaXNwZW5kLCBoc3luY3N0YSwgaHN5bmNlbmQsIGh0b3RhbDsKCXUzMiBoZCwgaHMsIGhlLCBodCwgaGJzLCBoYmU7Cgl1MzIgdmQsIHZzLCB2ZSwgdnQsIHZicywgdmJlOwoJc3RydWN0IGJhbnNoZWVfcmVnIHJlZzsKCWludCBmb3V0LCBmcmVxOwoJdTMyIHdkLCBjcHA7CiAgCglpbmZvLT5jbWFwLmxlbiA9IChpbmZvLT52YXIuYml0c19wZXJfcGl4ZWwgPT0gOCkgPyAyNTYgOiAxNjsKCXBhci0+YmFzZWxpbmUgID0gMDsKIAoJbWVtc2V0KCZyZWcsIDAsIHNpemVvZihyZWcpKTsKCWNwcCA9IChpbmZvLT52YXIuYml0c19wZXJfcGl4ZWwgKyA3KS84OwogCglyZWcudmlkY2ZnID0gVklEQ0ZHX1ZJRFBST0NfRU5BQkxFIHwgVklEQ0ZHX0RFU0tfRU5BQkxFIHwgVklEQ0ZHX0NVUlNfWDExIHwgKChjcHAgLSAxKSA8PCBWSURDRkdfUElYRk1UX1NISUZUKSB8IChjcHAgIT0gMSA/IFZJRENGR19DTFVUX0JZUEFTUyA6IDApOwoKCS8qIFBMTCBzZXR0aW5ncyAqLwoJZnJlcSA9IFBJQ09TMktIWihpbmZvLT52YXIucGl4Y2xvY2spOwoKCXJlZy5kYWNtb2RlID0gMDsKCXJlZy52aWRjZmcgICY9IH5WSURDRkdfMlg7CgoJaGRpc3BlbmQgPSBpbmZvLT52YXIueHJlczsKCWhzeW5jc3RhID0gaGRpc3BlbmQgKyBpbmZvLT52YXIucmlnaHRfbWFyZ2luOwoJaHN5bmNlbmQgPSBoc3luY3N0YSArIGluZm8tPnZhci5oc3luY19sZW47CglodG90YWwgICA9IGhzeW5jZW5kICsgaW5mby0+dmFyLmxlZnRfbWFyZ2luOwkKCglpZiAoZnJlcSA+IHBhci0+bWF4X3BpeGNsb2NrLzIpIHsKCQlmcmVxID0gZnJlcSA+IHBhci0+bWF4X3BpeGNsb2NrID8gcGFyLT5tYXhfcGl4Y2xvY2sgOiBmcmVxOwoJCXJlZy5kYWNtb2RlIHw9IERBQ01PREVfMlg7CgkJcmVnLnZpZGNmZyAgfD0gVklEQ0ZHXzJYOwoJCWhkaXNwZW5kID4+PSAxOwoJCWhzeW5jc3RhID4+PSAxOwoJCWhzeW5jZW5kID4+PSAxOwoJCWh0b3RhbCAgID4+PSAxOwoJfQogIAoJaGQgID0gd2QgPSAoaGRpc3BlbmQgPj4gMykgLSAxOwoJaHMgID0gKGhzeW5jc3RhID4+IDMpIC0gMTsKCWhlICA9IChoc3luY2VuZCA+PiAzKSAtIDE7CglodCAgPSAoaHRvdGFsID4+IDMpIC0gMTsKCWhicyA9IGhkOwoJaGJlID0gaHQ7CgoJdmJzID0gdmQgPSBpbmZvLT52YXIueXJlcyAtIDE7Cgl2cyAgPSB2ZCArIGluZm8tPnZhci5sb3dlcl9tYXJnaW47Cgl2ZSAgPSB2cyArIGluZm8tPnZhci52c3luY19sZW47Cgl2YmUgPSB2dCA9IHZlICsgaW5mby0+dmFyLnVwcGVyX21hcmdpbiAtIDE7CiAgCgkvKiB0aGlzIGlzIGFsbCBwcmV0dHkgc3RhbmRhcmQgVkdBIHJlZ2lzdGVyIHN0dWZmaW5nICovCglyZWcubWlzY1sweDAwXSA9IDB4MGYgfCAKCQkJKGluZm8tPnZhci54cmVzIDwgNDAwID8gMHhhMCA6CgkJCSBpbmZvLT52YXIueHJlcyA8IDQ4MCA/IDB4NjAgOgoJCQkgaW5mby0+dmFyLnhyZXMgPCA3NjggPyAweGUwIDogMHgyMCk7CiAgICAgCglyZWcuZ3JhWzB4MDBdID0gMHgwMDsKCXJlZy5ncmFbMHgwMV0gPSAweDAwOwoJcmVnLmdyYVsweDAyXSA9IDB4MDA7CglyZWcuZ3JhWzB4MDNdID0gMHgwMDsKCXJlZy5ncmFbMHgwNF0gPSAweDAwOwoJcmVnLmdyYVsweDA1XSA9IDB4NDA7CglyZWcuZ3JhWzB4MDZdID0gMHgwNTsKCXJlZy5ncmFbMHgwN10gPSAweDBmOwoJcmVnLmdyYVsweDA4XSA9IDB4ZmY7CgoJcmVnLmF0dFsweDAwXSA9IDB4MDA7CglyZWcuYXR0WzB4MDFdID0gMHgwMTsKCXJlZy5hdHRbMHgwMl0gPSAweDAyOwoJcmVnLmF0dFsweDAzXSA9IDB4MDM7CglyZWcuYXR0WzB4MDRdID0gMHgwNDsKCXJlZy5hdHRbMHgwNV0gPSAweDA1OwoJcmVnLmF0dFsweDA2XSA9IDB4MDY7CglyZWcuYXR0WzB4MDddID0gMHgwNzsKCXJlZy5hdHRbMHgwOF0gPSAweDA4OwoJcmVnLmF0dFsweDA5XSA9IDB4MDk7CglyZWcuYXR0WzB4MGFdID0gMHgwYTsKCXJlZy5hdHRbMHgwYl0gPSAweDBiOwoJcmVnLmF0dFsweDBjXSA9IDB4MGM7CglyZWcuYXR0WzB4MGRdID0gMHgwZDsKCXJlZy5hdHRbMHgwZV0gPSAweDBlOwoJcmVnLmF0dFsweDBmXSA9IDB4MGY7CglyZWcuYXR0WzB4MTBdID0gMHg0MTsKCXJlZy5hdHRbMHgxMV0gPSAweDAwOwoJcmVnLmF0dFsweDEyXSA9IDB4MGY7CglyZWcuYXR0WzB4MTNdID0gMHgwMDsKCXJlZy5hdHRbMHgxNF0gPSAweDAwOwoKCXJlZy5zZXFbMHgwMF0gPSAweDAzOwoJcmVnLnNlcVsweDAxXSA9IDB4MDE7IC8qIGZpeG1lOiBjbGtkaXYyPyAqLwoJcmVnLnNlcVsweDAyXSA9IDB4MGY7CglyZWcuc2VxWzB4MDNdID0gMHgwMDsKCXJlZy5zZXFbMHgwNF0gPSAweDBlOwoKCXJlZy5jcnRbMHgwMF0gPSBodCAtIDQ7CglyZWcuY3J0WzB4MDFdID0gaGQ7CglyZWcuY3J0WzB4MDJdID0gaGJzOwoJcmVnLmNydFsweDAzXSA9IDB4ODAgfCAoaGJlICYgMHgxZik7CglyZWcuY3J0WzB4MDRdID0gaHM7CglyZWcuY3J0WzB4MDVdID0gKChoYmUgJiAweDIwKSA8PCAyKSB8IChoZSAmIDB4MWYpOyAKCXJlZy5jcnRbMHgwNl0gPSB2dDsKCXJlZy5jcnRbMHgwN10gPSAoKHZzICYgMHgyMDApID4+IDIpIHwKCQkJKCh2ZCAmIDB4MjAwKSA+PiAzKSB8CgkJCSgodnQgJiAweDIwMCkgPj4gNCkgfCAweDEwIHwKCQkJKCh2YnMgJiAweDEwMCkgPj4gNSkgfAoJCQkoKHZzICAmIDB4MTAwKSA+PiA2KSB8CgkJCSgodmQgICYgMHgxMDApID4+IDcpIHwKCQkJKCh2dCAgJiAweDEwMCkgPj4gOCk7CglyZWcuY3J0WzB4MDhdID0gMHgwMDsKCXJlZy5jcnRbMHgwOV0gPSAweDQwIHwgKCh2YnMgJiAweDIwMCkgPj4gNCk7IAoJcmVnLmNydFsweDBhXSA9IDB4MDA7CglyZWcuY3J0WzB4MGJdID0gMHgwMDsKCXJlZy5jcnRbMHgwY10gPSAweDAwOwoJcmVnLmNydFsweDBkXSA9IDB4MDA7CglyZWcuY3J0WzB4MGVdID0gMHgwMDsKCXJlZy5jcnRbMHgwZl0gPSAweDAwOwoJcmVnLmNydFsweDEwXSA9IHZzOwoJcmVnLmNydFsweDExXSA9ICh2ZSAmIDB4MGYpIHwgMHgyMDsgCglyZWcuY3J0WzB4MTJdID0gdmQ7CglyZWcuY3J0WzB4MTNdID0gd2Q7CglyZWcuY3J0WzB4MTRdID0gMHgwMDsKCXJlZy5jcnRbMHgxNV0gPSB2YnM7CglyZWcuY3J0WzB4MTZdID0gdmJlICsgMTsgCglyZWcuY3J0WzB4MTddID0gMHhjMzsKCXJlZy5jcnRbMHgxOF0gPSAweGZmOwogCgkvKiBCYW5zaGVlJ3Mgbm9udmdhIHN0dWZmICovCglyZWcuZXh0WzB4MDBdID0gKCgoaHQgICYgMHgxMDApID4+IDgpIHwgCgkJCSgoaGQgICYgMHgxMDApID4+IDYpIHwKCQkJKChoYnMgJiAweDEwMCkgPj4gNCkgfAoJCQkoKGhiZSAmICAweDQwKSA+PiAxKSB8CgkJCSgoaHMgICYgMHgxMDApID4+IDIpIHwKCQkJKChoZSAgJiAgMHgyMCkgPDwgMikpOyAKCXJlZy5leHRbMHgwMV0gPSAoKCh2dCAgJiAweDQwMCkgPj4gMTApIHwKCQkJKCh2ZCAgJiAweDQwMCkgPj4gIDgpIHwgCgkJCSgodmJzICYgMHg0MDApID4+ICA2KSB8CgkJCSgodmJlICYgMHg0MDApID4+ICA0KSk7CgoJcmVnLnZnYWluaXQwID0gCVZHQUlOSVQwXzhCSVRfREFDICAgICB8CgkJCVZHQUlOSVQwX0VYVF9FTkFCTEUgICB8CgkJCVZHQUlOSVQwX1dBS0VVUF8zQzMgICB8CgkJCVZHQUlOSVQwX0FMVF9SRUFEQkFDSyB8CgkJCVZHQUlOSVQwX0VYVFNISUZUT1VUOwoJcmVnLnZnYWluaXQxID0gdGRmeF9pbmwocGFyLCBWR0FJTklUMSkgJiAweDFmZmZmZjsKCglyZWcuY3Vyc2xvYyAgID0gMDsKICAgCglyZWcuY3Vyc2MwICAgID0gMDsgCglyZWcuY3Vyc2MxICAgID0gMHhmZmZmZmY7CiAgIAoJcmVnLnN0cmlkZSAgICA9IGluZm8tPnZhci54cmVzICogY3BwOwoJcmVnLnN0YXJ0YWRkciA9IHBhci0+YmFzZWxpbmUgKiByZWcuc3RyaWRlOwoJcmVnLnNyY2Jhc2UgICA9IHJlZy5zdGFydGFkZHI7CglyZWcuZHN0YmFzZSAgID0gcmVnLnN0YXJ0YWRkcjsKCgkvKiBQTEwgc2V0dGluZ3MgKi8KCWZyZXEgPSBQSUNPUzJLSFooaW5mby0+dmFyLnBpeGNsb2NrKTsKCglyZWcuZGFjbW9kZSAmPSB+REFDTU9ERV8yWDsKCXJlZy52aWRjZmcgICY9IH5WSURDRkdfMlg7CglpZiAoZnJlcSA+IHBhci0+bWF4X3BpeGNsb2NrLzIpIHsKCQlmcmVxID0gZnJlcSA+IHBhci0+bWF4X3BpeGNsb2NrID8gcGFyLT5tYXhfcGl4Y2xvY2sgOiBmcmVxOwoJCXJlZy5kYWNtb2RlIHw9IERBQ01PREVfMlg7CgkJcmVnLnZpZGNmZyAgfD0gVklEQ0ZHXzJYOwoJfQoJcmVnLnZpZHBsbCA9IGRvX2NhbGNfcGxsKGZyZXEsICZmb3V0KTsKI2lmIDAKCXJlZy5tZW1wbGwgPSBkb19jYWxjX3BsbCguLi4sICZmb3V0KTsKCXJlZy5nZnhwbGwgPSBkb19jYWxjX3BsbCguLi4sICZmb3V0KTsKI2VuZGlmCgoJcmVnLnNjcmVlbnNpemUgPSBpbmZvLT52YXIueHJlcyB8IChpbmZvLT52YXIueXJlcyA8PCAxMik7CglyZWcudmlkY2ZnICY9IH5WSURDRkdfSEFMRl9NT0RFOwoJcmVnLm1pc2Npbml0MCA9IHRkZnhfaW5sKHBhciwgTUlTQ0lOSVQwKTsKCiNpZiBkZWZpbmVkKF9fQklHX0VORElBTikKCXN3aXRjaCAoaW5mby0+dmFyLmJpdHNfcGVyX3BpeGVsKSB7CgkJY2FzZSA4OgoJCQlyZWcubWlzY2luaXQwICY9IH4oMSA8PCAzMCk7CgkJCXJlZy5taXNjaW5pdDAgJj0gfigxIDw8IDMxKTsKCQkJYnJlYWs7CgkJY2FzZSAxNjoKCQkJcmVnLm1pc2Npbml0MCB8PSAoMSA8PCAzMCk7CgkJCXJlZy5taXNjaW5pdDAgfD0gKDEgPDwgMzEpOwoJCQlicmVhazsKCQljYXNlIDI0OgoJCWNhc2UgMzI6CgkJCXJlZy5taXNjaW5pdDAgfD0gKDEgPDwgMzApOwoJCQlyZWcubWlzY2luaXQwICY9IH4oMSA8PCAzMSk7CgkJCWJyZWFrOwoJfQojZW5kaWYgCglkb193cml0ZV9yZWdzKGluZm8sICZyZWcpOwoKCS8qIE5vdyBjaGFuZ2UgZmJfZml4X3NjcmVlbmluZm8gYWNjb3JkaW5nIHRvIGNoYW5nZXMgaW4gcGFyICovCglpbmZvLT5maXgubGluZV9sZW5ndGggPSBpbmZvLT52YXIueHJlcyAqICgoaW5mby0+dmFyLmJpdHNfcGVyX3BpeGVsICsgNyk+PjMpOwoJaW5mby0+Zml4LnZpc3VhbCA9IChpbmZvLT52YXIuYml0c19wZXJfcGl4ZWwgPT0gOCkgCgkJCQk/IEZCX1ZJU1VBTF9QU0VVRE9DT0xPUgoJCQkJOiBGQl9WSVNVQUxfVFJVRUNPTE9SOwoJRFBSSU5USygiR3JhcGhpY3MgbW9kZSBpcyBub3cgc2V0IGF0ICVkeCVkIGRlcHRoICVkXG4iLCBpbmZvLT52YXIueHJlcywgaW5mby0+dmFyLnlyZXMsIGluZm8tPnZhci5iaXRzX3Blcl9waXhlbCk7CglyZXR1cm4gMDsJCn0KCnN0YXRpYyBpbnQgdGRmeGZiX3NldGNvbHJlZyh1bnNpZ25lZCByZWdubywgdW5zaWduZWQgcmVkLCB1bnNpZ25lZCBncmVlbiwgIAoJCQkgICAgdW5zaWduZWQgYmx1ZSx1bnNpZ25lZCB0cmFuc3Asc3RydWN0IGZiX2luZm8gKmluZm8pIAp7CglzdHJ1Y3QgdGRmeF9wYXIgKnBhciA9IChzdHJ1Y3QgdGRmeF9wYXIgKikgaW5mby0+cGFyOwoJdTMyIHJnYmNvbDsKICAgCglpZiAocmVnbm8gPj0gaW5mby0+Y21hcC5sZW4pIHJldHVybiAxOwogICAKCXN3aXRjaCAoaW5mby0+Zml4LnZpc3VhbCkgewoJCWNhc2UgRkJfVklTVUFMX1BTRVVET0NPTE9SOgoJCQlyZ2Jjb2wgPSgoKHUzMilyZWQgICAmIDB4ZmYwMCkgPDwgOCkgfAoJCQkJKCgodTMyKWdyZWVuICYgMHhmZjAwKSA8PCAwKSB8CgkJCQkoKCh1MzIpYmx1ZSAgJiAweGZmMDApID4+IDgpOwoJCQlkb19zZXRwYWxlbnRyeShwYXIsIHJlZ25vLCByZ2Jjb2wpOwoJCQlicmVhazsKCQkvKiBUcnVlY29sb3IgaGFzIG5vIGhhcmR3YXJlIGNvbG9yIHBhbGV0dGVzLiAqLwoJCWNhc2UgRkJfVklTVUFMX1RSVUVDT0xPUjoKCQkJcmdiY29sID0gKHJlZCA8PCBpbmZvLT52YXIucmVkLm9mZnNldCkgfAoJCQkJIChncmVlbiA8PCBpbmZvLT52YXIuZ3JlZW4ub2Zmc2V0KSB8CgkJCQkgKGJsdWUgPDwgaW5mby0+dmFyLmJsdWUub2Zmc2V0KSB8CgkJCQkgKHRyYW5zcCA8PCBpbmZvLT52YXIudHJhbnNwLm9mZnNldCk7CgkJCWlmIChpbmZvLT52YXIuYml0c19wZXJfcGl4ZWwgPD0gMTYpCgkJCQkoKHUxNiopKGluZm8tPnBzZXVkb19wYWxldHRlKSlbcmVnbm9dID0gcmdiY29sOwoJCQllbHNlCgkJCQkoKHUzMiopKGluZm8tPnBzZXVkb19wYWxldHRlKSlbcmVnbm9dID0gcmdiY29sOwoJCQlicmVhazsKCQlkZWZhdWx0OgoJCQlEUFJJTlRLKCJiYWQgZGVwdGggJXVcbiIsIGluZm8tPnZhci5iaXRzX3Blcl9waXhlbCk7CgkJCWJyZWFrOwoJfQoJcmV0dXJuIDA7Cn0KCi8qIDAgdW5ibGFuaywgMSBibGFuaywgMiBubyB2c3luYywgMyBubyBoc3luYywgNCBvZmYgKi8Kc3RhdGljIGludCB0ZGZ4ZmJfYmxhbmsoaW50IGJsYW5rLCBzdHJ1Y3QgZmJfaW5mbyAqaW5mbykKeyAKCXN0cnVjdCB0ZGZ4X3BhciAqcGFyID0gKHN0cnVjdCB0ZGZ4X3BhciAqKSBpbmZvLT5wYXI7Cgl1MzIgZGFjbW9kZSwgc3RhdGUgPSAwLCB2Z2FibGFuayA9IDA7CgoJZGFjbW9kZSA9IHRkZnhfaW5sKHBhciwgREFDTU9ERSk7CgoJc3dpdGNoIChibGFuaykgewoJCWNhc2UgMDogLyogU2NyZWVuOiBPbjsgSFN5bmM6IE9uLCBWU3luYzogT24gKi8gICAgCgkJCXN0YXRlICAgID0gMDsKCQkJdmdhYmxhbmsgPSAwOwoJCQlicmVhazsKCQljYXNlIDE6IC8qIFNjcmVlbjogT2ZmOyBIU3luYzogT24sIFZTeW5jOiBPbiAqLwoJCQlzdGF0ZSAgICA9IDA7CgkJCXZnYWJsYW5rID0gMTsKCQkJYnJlYWs7CgkJY2FzZSAyOiAvKiBTY3JlZW46IE9mZjsgSFN5bmM6IE9uLCBWU3luYzogT2ZmICovCgkJCXN0YXRlICAgID0gQklUKDMpOwoJCQl2Z2FibGFuayA9IDE7CgkJCWJyZWFrOwoJCWNhc2UgMzogLyogU2NyZWVuOiBPZmY7IEhTeW5jOiBPZmYsIFZTeW5jOiBPbiAqLwoJCQlzdGF0ZSAgICA9IEJJVCgxKTsKCQkJdmdhYmxhbmsgPSAxOwoJCQlicmVhazsKCQljYXNlIDQ6IC8qIFNjcmVlbjogT2ZmOyBIU3luYzogT2ZmLCBWU3luYzogT2ZmICovCgkJCXN0YXRlICAgID0gQklUKDEpIHwgQklUKDMpOwoJCQl2Z2FibGFuayA9IDE7CgkJCWJyZWFrOwoJfQoKCWRhY21vZGUgJj0gfihCSVQoMSkgfCBCSVQoMykpOwoJZGFjbW9kZSB8PSBzdGF0ZTsKCWJhbnNoZWVfbWFrZV9yb29tKHBhciwgMSk7IAoJdGRmeF9vdXRsKHBhciwgREFDTU9ERSwgZGFjbW9kZSk7CglpZiAodmdhYmxhbmspIAoJCXZnYV9kaXNhYmxlX3ZpZGVvKHBhcik7CgllbHNlCgkJdmdhX2VuYWJsZV92aWRlbyhwYXIpOwoJcmV0dXJuIDA7Cn0KCi8qICAgCiAqIFNldCB0aGUgc3RhcnRpbmcgcG9zaXRpb24gb2YgdGhlIHZpc2libGUgc2NyZWVuIHRvIHZhci0+eW9mZnNldAogKi8gICAKc3RhdGljIGludCB0ZGZ4ZmJfcGFuX2Rpc3BsYXkoc3RydWN0IGZiX3Zhcl9zY3JlZW5pbmZvICp2YXIsCgkJCSAgICAgIHN0cnVjdCBmYl9pbmZvICppbmZvKSAKewoJc3RydWN0IHRkZnhfcGFyICpwYXIgPSAoc3RydWN0IHRkZnhfcGFyICopIGluZm8tPnBhcjsKCXUzMiBhZGRyOyAgCQoKCWlmIChub3BhbiB8fCB2YXItPnhvZmZzZXQgfHwgKHZhci0+eW9mZnNldCA+IHZhci0+eXJlc192aXJ0dWFsKSkKCQlyZXR1cm4gLUVJTlZBTDsKCWlmICgodmFyLT55b2Zmc2V0ICsgdmFyLT55cmVzID4gdmFyLT55cmVzX3ZpcnR1YWwgJiYgbm93cmFwKSkKCQlyZXR1cm4gLUVJTlZBTDsKCglhZGRyID0gdmFyLT55b2Zmc2V0ICogaW5mby0+Zml4LmxpbmVfbGVuZ3RoOwoJYmFuc2hlZV9tYWtlX3Jvb20ocGFyLCAxKTsKCXRkZnhfb3V0bChwYXIsIFZJRERFU0tTVEFSVCwgYWRkcik7CiAgIAoJaW5mby0+dmFyLnhvZmZzZXQgPSB2YXItPnhvZmZzZXQ7CglpbmZvLT52YXIueW9mZnNldCA9IHZhci0+eW9mZnNldDsgCglyZXR1cm4gMDsKfQoKLyoKICogRmlsbFJlY3QgMkQgY29tbWFuZCAoc29saWRmaWxsIG9yIGludmVydCAodmlhIFJPUF9YT1IpKSAgIAogKi8Kc3RhdGljIHZvaWQgdGRmeGZiX2ZpbGxyZWN0KHN0cnVjdCBmYl9pbmZvICppbmZvLCBzdHJ1Y3QgZmJfZmlsbHJlY3QgKnJlY3QpIAp7CglzdHJ1Y3QgdGRmeF9wYXIgKnBhciA9IChzdHJ1Y3QgdGRmeF9wYXIgKikgaW5mby0+cGFyOwoJdTMyIGJwcCA9IGluZm8tPnZhci5iaXRzX3Blcl9waXhlbDsKCXUzMiBzdHJpZGUgPSBpbmZvLT5maXgubGluZV9sZW5ndGg7Cgl1MzIgZm10PSBzdHJpZGUgfCAoKGJwcCsoKGJwcD09OCkgPyAwIDogOCkpIDw8IDEzKTsgCglpbnQgdGRmeF9yb3A7CiAgIAkKCWlmIChyZWN0LT5yb3AgPT0gUk9QX0NPUFkpIAoJCXRkZnhfcm9wID0gVERGWF9ST1BfQ09QWTsKCWVsc2UgCQkJIAoJCXRkZnhfcm9wID0gVERGWF9ST1BfWE9SOwoKCWJhbnNoZWVfbWFrZV9yb29tKHBhciwgNSk7Cgl0ZGZ4X291dGwocGFyLAlEU1RGT1JNQVQsIGZtdCk7Cgl0ZGZ4X291dGwocGFyLAlDT0xPUkZPUkUsIHJlY3QtPmNvbG9yKTsKCXRkZnhfb3V0bChwYXIsCUNPTU1BTkRfMkQsIENPTU1BTkRfMkRfRklMTFJFQ1QgfCAodGRmeF9yb3AgPDwgMjQpKTsKCXRkZnhfb3V0bChwYXIsCURTVFNJWkUsICAgIHJlY3QtPndpZHRoIHwgKHJlY3QtPmhlaWdodCA8PCAxNikpOwoJdGRmeF9vdXRsKHBhciwJTEFVTkNIXzJELCAgcmVjdC0+ZHggfCAocmVjdC0+ZHkgPDwgMTYpKTsKCWJhbnNoZWVfd2FpdF9pZGxlKGluZm8pOwp9CgovKgogKiBTY3JlZW4tdG8tU2NyZWVuIEJpdEJsdCAyRCBjb21tYW5kIChmb3IgdGhlIGJtb3ZlIGZiIG9wLikgCiAqLwpzdGF0aWMgdm9pZCB0ZGZ4ZmJfY29weWFyZWEoc3RydWN0IGZiX2luZm8gKmluZm8sIHN0cnVjdCBmYl9jb3B5YXJlYSAqYXJlYSkgIAp7CglzdHJ1Y3QgdGRmeF9wYXIgKnBhciA9IChzdHJ1Y3QgdGRmeF9wYXIgKikgaW5mby0+cGFyOwoJdTMyIGJwcCA9IGluZm8tPnZhci5iaXRzX3Blcl9waXhlbDsKCXUzMiBzdHJpZGUgPSBpbmZvLT5maXgubGluZV9sZW5ndGg7Cgl1MzIgYmxpdGNtZCA9IENPTU1BTkRfMkRfUzJTX0JJVEJMVCB8IChUREZYX1JPUF9DT1BZIDw8IDI0KTsKCXUzMiBmbXQgPSBzdHJpZGUgfCAoKGJwcCsoKGJwcD09OCkgPyAwIDogOCkpIDw8IDEzKTsgCiAgIAoJaWYgKGFyZWEtPnN4IDw9IGFyZWEtPmR4KSB7CgkJLy8tWCAKCQlibGl0Y21kIHw9IEJJVCgxNCk7CgkJYXJlYS0+c3ggKz0gYXJlYS0+d2lkdGggLSAxOwoJCWFyZWEtPmR4ICs9IGFyZWEtPndpZHRoIC0gMTsKCX0KCWlmIChhcmVhLT5zeSA8PSBhcmVhLT5keSkgewoJCS8vLVkgIAoJCWJsaXRjbWQgfD0gQklUKDE1KTsKCQlhcmVhLT5zeSArPSBhcmVhLT5oZWlnaHQgLSAxOwoJCWFyZWEtPmR5ICs9IGFyZWEtPmhlaWdodCAtIDE7Cgl9CiAgIAoJYmFuc2hlZV9tYWtlX3Jvb20ocGFyLCA2KTsKCgl0ZGZ4X291dGwocGFyLAlTUkNGT1JNQVQsIGZtdCk7Cgl0ZGZ4X291dGwocGFyLAlEU1RGT1JNQVQsIGZtdCk7Cgl0ZGZ4X291dGwocGFyLAlDT01NQU5EXzJELCBibGl0Y21kKTsgCgl0ZGZ4X291dGwocGFyLAlEU1RTSVpFLCAgIGFyZWEtPndpZHRoIHwgKGFyZWEtPmhlaWdodCA8PCAxNikpOwoJdGRmeF9vdXRsKHBhciwJRFNUWFksICAgICBhcmVhLT5keCB8IChhcmVhLT5keSA8PCAxNikpOwoJdGRmeF9vdXRsKHBhciwJTEFVTkNIXzJELCBhcmVhLT5zeCB8IChhcmVhLT5zeSA8PCAxNikpOyAKCWJhbnNoZWVfd2FpdF9pZGxlKGluZm8pOwp9CgpzdGF0aWMgdm9pZCB0ZGZ4ZmJfaW1hZ2VibGl0KHN0cnVjdCBmYl9pbmZvICppbmZvLCBzdHJ1Y3QgZmJfaW1hZ2UgKnBpeG1hcCkgCnsKCXN0cnVjdCB0ZGZ4X3BhciAqcGFyID0gKHN0cnVjdCB0ZGZ4X3BhciAqKSBpbmZvLT5wYXI7CglpbnQgc2l6ZSA9IHBpeG1hcC0+aGVpZ2h0KigocGl4bWFwLT53aWR0aCpwaXhtYXAtPmRlcHRoICsgNyk+PjMpOwoJaW50IGksIHN0cmlkZSA9IGluZm8tPmZpeC5saW5lX2xlbmd0aDsKCXUzMiBicHAgPSBpbmZvLT52YXIuYml0c19wZXJfcGl4ZWw7Cgl1MzIgZHN0Zm10ID0gc3RyaWRlIHwgKChicHArKChicHA9PTgpID8gMCA6IDgpKSA8PCAxMyk7IAoJdTggKmNoYXJkYXRhID0gKHU4ICopIHBpeG1hcC0+ZGF0YTsKCXUzMiBzcmNmbXQ7CgoJaWYgKHBpeG1hcC0+ZGVwdGggPT0gMSkgewoJCWJhbnNoZWVfbWFrZV9yb29tKHBhciwgOCArICgoc2l6ZSArIDMpID4+IDIpKTsKCQl0ZGZ4X291dGwocGFyLCBDT0xPUkZPUkUsIHBpeG1hcC0+ZmdfY29sb3IpOwoJCXRkZnhfb3V0bChwYXIsIENPTE9SQkFDSywgcGl4bWFwLT5iZ19jb2xvcik7CgkJc3JjZm10ID0gMHg0MDAwMDA7Cgl9IGVsc2UgewoJCS8vYmFuc2hlZV9tYWtlX3Jvb20ocGFyLCA2ICsgKChzaXplICsgMykgPj4gMikpOwoJCS8vc3JjZm10ID0gc3RyaWRlIHwgKChicHArKChicHA9PTgpID8gMCA6IDgpKSA8PCAxMykgfCAweDQwMDAwMDsKCX0JCgoJdGRmeF9vdXRsKHBhciwJU1JDWFksICAgICAwKTsKCXRkZnhfb3V0bChwYXIsCURTVFhZLCAgICAgcGl4bWFwLT5keCB8IChwaXhtYXAtPmR5IDw8IDE2KSk7Cgl0ZGZ4X291dGwocGFyLAlDT01NQU5EXzJELCBDT01NQU5EXzJEX0gyU19CSVRCTFQgfCAoVERGWF9ST1BfQ09QWSA8PCAyNCkpOwoJdGRmeF9vdXRsKHBhciwJU1JDRk9STUFULCBzcmNmbXQpOwoJdGRmeF9vdXRsKHBhciwJRFNURk9STUFULCBkc3RmbXQpOwoJdGRmeF9vdXRsKHBhciwJRFNUU0laRSwgICBwaXhtYXAtPndpZHRoIHwgKHBpeG1hcC0+aGVpZ2h0IDw8IDE2KSk7CgoJLyogU2VuZCBmb3VyIGJ5dGVzIGF0IGEgdGltZSBvZiBkYXRhICovCQoJZm9yIChpID0gKHNpemUgPj4gMikgOyBpID4gMDsgaS0tKSB7IAoJCXRkZnhfb3V0bChwYXIsCUxBVU5DSF8yRCwqKHUzMiopY2hhcmRhdGEpOwoJCWNoYXJkYXRhICs9IDQ7IAoJfQkKCgkvKiBTZW5kIHRoZSBsZWZ0b3ZlcnMgbm93ICovCQoJaSA9IHNpemUlNDsJCglzd2l0Y2ggKGkpIHsKCQljYXNlIDA6IGJyZWFrOwoJCWNhc2UgMTogIHRkZnhfb3V0bChwYXIsCUxBVU5DSF8yRCwqY2hhcmRhdGEpOyBicmVhazsKCQljYXNlIDI6ICB0ZGZ4X291dGwocGFyLAlMQVVOQ0hfMkQsKih1MTYqKWNoYXJkYXRhKTsgYnJlYWs7CgkJY2FzZSAzOiAgdGRmeF9vdXRsKHBhciwJTEFVTkNIXzJELCoodTE2KiljaGFyZGF0YSB8ICgoY2hhcmRhdGFbM10pIDw8IDI0KSk7IGJyZWFrOwoJfQoJYmFuc2hlZV93YWl0X2lkbGUoaW5mbyk7Cn0KCnN0YXRpYyBpbnQgdGRmeGZiX2N1cnNvcihzdHJ1Y3QgZmJfaW5mbyAqaW5mbywgc3RydWN0IGZiX2N1cnNvciAqY3Vyc29yKQp7CglzdHJ1Y3QgdGRmeF9wYXIgKnBhciA9IChzdHJ1Y3QgdGRmeF9wYXIgKikgaW5mby0+cGFyOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCgkvKgoJICogSWYgdGhlIGN1cnNvciBpcyBub3QgYmUgY2hhbmdlZCB0aGlzIG1lYW5zIGVpdGhlciB3ZSB3YW50IHRoZSAKCSAqIGN1cnJlbnQgY3Vyc29yIHN0YXRlIChpZiBlbmFibGUgaXMgc2V0KSBvciB3ZSB3YW50IHRvIHF1ZXJ5IHdoYXQKCSAqIHdlIGNhbiBkbyB3aXRoIHRoZSBjdXJzb3IgKGlmIGVuYWJsZSBpcyBub3Qgc2V0KSAKIAkgKi8KCWlmICghY3Vyc29yLT5zZXQpIHJldHVybiAwOwoKCS8qIFRvbyBsYXJnZSBvZiBhIGN1cnNvciA6LSggKi8KCWlmIChjdXJzb3ItPmltYWdlLndpZHRoID4gNjQgfHwgY3Vyc29yLT5pbWFnZS5oZWlnaHQgPiA2NCkKCQlyZXR1cm4gLUVOWElPOwoKCS8qIAoJICogSWYgd2UgYXJlIGdvaW5nIHRvIGJlIGNoYW5naW5nIHRoaW5ncyB3ZSBzaG91bGQgZGlzYWJsZQoJICogdGhlIGN1cnNvciBmaXJzdCAKCSAqLwoJaWYgKGluZm8tPmN1cnNvci5lbmFibGUpIHsKCQlzcGluX2xvY2tfaXJxc2F2ZSgmcGFyLT5EQUNsb2NrLCBmbGFncyk7CgkJaW5mby0+Y3Vyc29yLmVuYWJsZSA9IDA7CgkJZGVsX3RpbWVyKCYocGFyLT5od2N1cnNvci50aW1lcikpOwoJCXRkZnhfb3V0bChwYXIsIFZJRFBST0NDRkcsIHBhci0+aHdjdXJzb3IuZGlzYWJsZSk7CgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcGFyLT5EQUNsb2NrLCBmbGFncyk7Cgl9CgoJLyogRGlzYWJsZSB0aGUgQ3Vyc29yICovCglpZiAoKGN1cnNvci0+c2V0ICYmIEZCX0NVUl9TRVRDVVIpICYmICFjdXJzb3ItPmVuYWJsZSkKCQlyZXR1cm4gMDsKCgkvKiBmaXggY3Vyc29yIGNvbG9yIC0gWEZyZWU4NiBmb3JnZXRzIHRvIHJlc3RvcmUgaXQgcHJvcGVybHkgKi8KCWlmIChjdXJzb3ItPnNldCAmJiBGQl9DVVJfU0VUQ01BUCkgewoJCXN0cnVjdCBmYl9jbWFwIGNtYXAgPSBjdXJzb3ItPmltYWdlLmNtYXA7CgkJdW5zaWduZWQgbG9uZyBiZ19jb2xvciwgZmdfY29sb3I7CgoJCWNtYXAubGVuID0gMjsvKiBWb29kb28gMysgb25seSBzdXBwb3J0IDIgY29sb3IgY3Vyc29ycyovCgkJZmdfY29sb3IgPSAoKGNtYXAucmVkW2NtYXAuc3RhcnRdIDw8IDE2KSB8CgkJCSAgICAoY21hcC5ncmVlbltjbWFwLnN0YXJ0XSA8PCA4KSAgfAoJCQkgICAgKGNtYXAuYmx1ZVtjbWFwLnN0YXJ0XSkpOwoJCWJnX2NvbG9yID0gKChjbWFwLnJlZFtjbWFwLnN0YXJ0KzFdIDw8IDE2KSB8CgkJCSAgICAoY21hcC5ncmVlbltjbWFwLnN0YXJ0KzFdIDw8IDgpIHwKCQkJICAgIChjbWFwLmJsdWVbY21hcC5zdGFydCsxXSkpOwoJCWZiX2NvcHlfY21hcCgmY21hcCwgJmluZm8tPmN1cnNvci5pbWFnZS5jbWFwLCAwKTsKCQlzcGluX2xvY2tfaXJxc2F2ZSgmcGFyLT5EQUNsb2NrLCBmbGFncyk7CgkJYmFuc2hlZV9tYWtlX3Jvb20ocGFyLCAyKTsKCQl0ZGZ4X291dGwocGFyLCBIV0NVUkMwLCBiZ19jb2xvcik7CgkJdGRmeF9vdXRsKHBhciwgSFdDVVJDMSwgZmdfY29sb3IpOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBhci0+REFDbG9jaywgZmxhZ3MpOwoJfQoKCWlmIChjdXJzb3ItPnNldCAmJiBGQl9DVVJfU0VUUE9TKSB7CgkJaW50IHgsIHk7CgoJCXggPSBjdXJzb3ItPmltYWdlLmR4OwoJCXkgPSBjdXJzb3ItPmltYWdlLmR5OwoJCXkgLT0gaW5mby0+dmFyLnlvZmZzZXQ7CgkJaW5mby0+Y3Vyc29yLmltYWdlLmR4ID0geDsKCQlpbmZvLT5jdXJzb3IuaW1hZ2UuZHkgPSB5OwoJCXggKz0gNjM7CgkJeSArPSA2MzsKCQlzcGluX2xvY2tfaXJxc2F2ZSgmcGFyLT5EQUNsb2NrLCBmbGFncyk7CgkJYmFuc2hlZV9tYWtlX3Jvb20ocGFyLCAxKTsKCQl0ZGZ4X291dGwocGFyLCBIV0NVUkxPQywgKHkgPDwgMTYpICsgeCk7CgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcGFyLT5EQUNsb2NrLCBmbGFncyk7Cgl9CgoJLyogTm90IHN1cHBvcnRlZCBzbyB3ZSBmYWtlIGl0ICovCglpZiAoY3Vyc29yLT5zZXQgJiYgRkJfQ1VSX1NFVEhPVCkgewoJCWluZm8tPmN1cnNvci5ob3QueCA9IGN1cnNvci0+aG90Lng7CgkJaW5mby0+Y3Vyc29yLmhvdC55ID0gY3Vyc29yLT5ob3QueTsKCX0KCglpZiAoY3Vyc29yLT5zZXQgJiYgRkJfQ1VSX1NFVFNIQVBFKSB7CgkJLyoKCSAJICogVm9vZG9vIDMgYW5kIGFib3ZlIGNhcmRzIHVzZSAyIG1vbm9jaHJvbWUgY3Vyc29yIHBhdHRlcm5zLgoJCSAqICAgIFRoZSByZWFzb24gaXMgc28gdGhlIGNhcmQgY2FuIGZldGNoIDggd29yZHMgYXQgYSB0aW1lCgkJICogYW5kIGFyZSBzdG9yZWQgb24gY2hpcCBmb3IgdXNlIGZvciB0aGUgbmV4dCA4IHNjYW5saW5lcy4KCQkgKiBUaGlzIHJlZHVjZXMgdGhlIG51bWJlciBvZiB0aW1lcyBmb3IgYWNjZXNzIHRvIGRyYXcgdGhlCgkJICogY3Vyc29yIGZvciBlYWNoIHNjcmVlbiByZWZyZXNoLgoJCSAqICAgIEVhY2ggcGF0dGVybiBpcyBhIGJpdG1hcCBvZiA2NCBiaXQgd2lkZSBhbmQgNjQgYml0IGhpZ2gKCQkgKiAodG90YWwgb2YgODE5MiBiaXRzIG9yIDEwMjQgS2J5dGVzKS4gVGhlIHR3byBwYXR0ZXJucyBhcmUKCQkgKiBzdG9yZWQgaW4gc3VjaCBhIHdheSB0aGF0IHBhdHRlcm4gMCBhbHdheXMgcmVzaWRlcyBpbiB0aGUKCQkgKiBsb3dlciBoYWxmIChsZWFzdCBzaWduaWZpY2FudCA2NCBiaXRzKSBvZiBhIDEyOCBiaXQgd29yZAoJCSAqIGFuZCBwYXR0ZXJuIDEgdGhlIHVwcGVyIGhhbGYuIElmIHlvdSBleGFtaW5lIHRoZSBkYXRhIG9mCgkJICogdGhlIGN1cnNvciBpbWFnZSB0aGUgZ3JhcGhpY3MgY2FyZCB1c2VzIHRoZW4gZnJvbSB0aGUKCQkgKiBiZWdpbmluZyB5b3Ugc2VlIGxpbmUgb25lIG9mIHBhdHRlcm4gMCwgbGluZSBvbmUgb2YKCQkgKiBwYXR0ZXJuIDEsIGxpbmUgdHdvIG9mIHBhdHRlcm4gMCwgbGluZSB0d28gb2YgcGF0dGVybiAxLAoJCSAqIGV0YyBldGMuIFRoZSBsaW5lYXIgc3RyaWRlIGZvciB0aGUgY3Vyc29yIGlzIGFsd2F5cyAxNiBieXRlcwoJCSAqICgxMjggYml0cykgd2hpY2ggaXMgdGhlIG1heGltdW0gY3Vyc29yIHdpZHRoIHRpbWVzIHR3byBmb3IKCQkgKiB0aGUgdHdvIG1vbm9jaHJvbWUgcGF0dGVybnMuCgkJICovCgkJdTggKmN1cnNvcmJhc2UgPSAodTggKikgaW5mby0+Y3Vyc29yLmltYWdlLmRhdGE7CgkJY2hhciAqYml0bWFwID0gY3Vyc29yLT5pbWFnZS5kYXRhOwoJCWNoYXIgKm1hc2sgPSBjdXJzb3ItPm1hc2s7CgkJaW50IGksIGosIGssIGggPSAwOwoKCQlmb3IgKGkgPSAwOyBpIDwgNjQ7IGkrKykgewoJCQlpZiAoaSA8IGN1cnNvci0+aW1hZ2UuaGVpZ2h0KSB7CgkJCQlqID0gKGN1cnNvci0+aW1hZ2Uud2lkdGggKyA3KSA+PiAzOwoJCQkJayA9IDggLSBqOwoKCQkJCWZvciAoO2ogPiAwOyBqLS0pIHsKCQkJCS8qIFBhdHRlcm4gMC4gQ29weSB0aGUgY3Vyc29yIGJpdG1hcCB0byBpdCAqLwoJCQkJCWZiX3dyaXRlYigqYml0bWFwLCBjdXJzb3JiYXNlICsgaCk7CgkJCQkJYml0bWFwKys7CgkJCQkvKiBQYXR0ZXJuIDEuIENvcHkgdGhlIGN1cnNvciBtYXNrIHRvIGl0ICovCgkJCQkJZmJfd3JpdGViKCptYXNrLCBjdXJzb3JiYXNlICsgaCArIDgpOwoJCQkJCW1hc2srKzsKCQkJCQloKys7CgkJCQl9CgkJCQlmb3IgKDtrID4gMDsgay0tKSB7CgkJCQkJZmJfd3JpdGViKDAsIGN1cnNvcmJhc2UgKyBoKTsKCQkJCQlmYl93cml0ZWIofjAsIGN1cnNvcmJhc2UgKyBoICsgOCk7CgkJCQkJaCsrOwoJCQkJfQoJCQl9IGVsc2UgewoJCQkJZmJfd3JpdGVsKDAsIGN1cnNvcmJhc2UgKyBoKTsKCQkJCWZiX3dyaXRlbCgwLCBjdXJzb3JiYXNlICsgaCArIDQpOwoJCQkJZmJfd3JpdGVsKH4wLCBjdXJzb3JiYXNlICsgaCArIDgpOwoJCQkJZmJfd3JpdGVsKH4wLCBjdXJzb3JiYXNlICsgaCArIDEyKTsKCQkJCWggKz0gMTY7CgkJCX0KCQl9Cgl9CgkvKiBUdXJuIHRoZSBjdXJzb3Igb24gKi8KCWN1cnNvci0+ZW5hYmxlID0gMTsKCWluZm8tPmN1cnNvciA9ICpjdXJzb3I7Cgltb2RfdGltZXIoJnBhci0+aHdjdXJzb3IudGltZXIsIGppZmZpZXMrSFovMik7CglzcGluX2xvY2tfaXJxc2F2ZSgmcGFyLT5EQUNsb2NrLCBmbGFncyk7CgliYW5zaGVlX21ha2Vfcm9vbShwYXIsIDEpOwoJdGRmeF9vdXRsKHBhciwgVklEUFJPQ0NGRywgcGFyLT5od2N1cnNvci5lbmFibGUpOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcGFyLT5EQUNsb2NrLCBmbGFncyk7CglyZXR1cm4gMDsKfQoKLyoqCiAqICAgICAgdGRmeGZiX3Byb2JlIC0gRGV2aWNlIEluaXRpYWxpemlhdGlvbgogKgogKiAgICAgIEBwZGV2OiAgUENJIERldmljZSB0byBpbml0aWFsaXplCiAqICAgICAgQGlkOiAgICBQQ0kgRGV2aWNlIElECiAqCiAqICAgICAgSW5pdGlhbGl6ZXMgYW5kIGFsbG9jYXRlcyByZXNvdXJjZXMgZm9yIFBDSSBkZXZpY2UgQHBkZXYuCiAqCiAqLwpzdGF0aWMgaW50IF9fZGV2aW5pdCB0ZGZ4ZmJfcHJvYmUoc3RydWN0IHBjaV9kZXYgKnBkZXYsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBzdHJ1Y3QgcGNpX2RldmljZV9pZCAqaWQpCnsKCXN0cnVjdCB0ZGZ4X3BhciAqZGVmYXVsdF9wYXI7CglzdHJ1Y3QgZmJfaW5mbyAqaW5mbzsKCWludCBzaXplLCBlcnI7CgoJaWYgKChlcnIgPSBwY2lfZW5hYmxlX2RldmljZShwZGV2KSkpIHsKCQlwcmludGsoS0VSTl9XQVJOSU5HICJ0ZGZ4ZmI6IENhbid0IGVuYWJsZSBwZGV2OiAlZFxuIiwgZXJyKTsKCQlyZXR1cm4gZXJyOwoJfQoKCXNpemUgPSBzaXplb2Yoc3RydWN0IGZiX2luZm8pK3NpemVvZihzdHJ1Y3QgdGRmeF9wYXIpKzE2KnNpemVvZih1MzIpOwoKCWluZm8gPSBrbWFsbG9jKHNpemUsIEdGUF9LRVJORUwpOwoKCWlmICghaW5mbykJcmV0dXJuIC1FTk9NRU07CgkJCgltZW1zZXQoaW5mbywgMCwgc2l6ZSk7CiAgICAKCWRlZmF1bHRfcGFyID0gKHN0cnVjdCB0ZGZ4X3BhciAqKSAoaW5mbyArIDEpOwogCgkvKiBDb25maWd1cmUgdGhlIGRlZmF1bHQgZmJfZml4X3NjcmVlbmluZm8gZmlyc3QgKi8KCXN3aXRjaCAocGRldi0+ZGV2aWNlKSB7CgkJY2FzZSBQQ0lfREVWSUNFX0lEXzNERlhfQkFOU0hFRToJCgkJCXN0cmNhdCh0ZGZ4X2ZpeC5pZCwgIiBCYW5zaGVlIik7CgkJCWRlZmF1bHRfcGFyLT5tYXhfcGl4Y2xvY2sgPSBCQU5TSEVFX01BWF9QSVhDTE9DSzsKCQkJYnJlYWs7CgkJY2FzZSBQQ0lfREVWSUNFX0lEXzNERlhfVk9PRE9PMzoKCQkJc3RyY2F0KHRkZnhfZml4LmlkLCAiIFZvb2RvbzMiKTsKCQkJZGVmYXVsdF9wYXItPm1heF9waXhjbG9jayA9IFZPT0RPTzNfTUFYX1BJWENMT0NLOwoJCQlicmVhazsKCQljYXNlIFBDSV9ERVZJQ0VfSURfM0RGWF9WT09ET081OgoJCQlzdHJjYXQodGRmeF9maXguaWQsICIgVm9vZG9vNSIpOwoJCQlkZWZhdWx0X3Bhci0+bWF4X3BpeGNsb2NrID0gVk9PRE9PNV9NQVhfUElYQ0xPQ0s7CgkJCWJyZWFrOwoJfQoKCXRkZnhfZml4Lm1taW9fc3RhcnQgPSBwY2lfcmVzb3VyY2Vfc3RhcnQocGRldiwgMCk7Cgl0ZGZ4X2ZpeC5tbWlvX2xlbiA9IHBjaV9yZXNvdXJjZV9sZW4ocGRldiwgMCk7CglkZWZhdWx0X3Bhci0+cmVnYmFzZV92aXJ0ID0gaW9yZW1hcF9ub2NhY2hlKHRkZnhfZml4Lm1taW9fc3RhcnQsIHRkZnhfZml4Lm1taW9fbGVuKTsKCWlmICghZGVmYXVsdF9wYXItPnJlZ2Jhc2VfdmlydCkgewoJCXByaW50aygiZmI6IENhbid0IHJlbWFwICVzIHJlZ2lzdGVyIGFyZWEuXG4iLCB0ZGZ4X2ZpeC5pZCk7CgkJZ290byBvdXRfZXJyOwoJfQogICAgCglpZiAoIXJlcXVlc3RfbWVtX3JlZ2lvbihwY2lfcmVzb3VyY2Vfc3RhcnQocGRldiwgMCksCgkgICAgcGNpX3Jlc291cmNlX2xlbihwZGV2LCAwKSwgInRkZnggcmVnYmFzZSIpKSB7CgkJcHJpbnRrKEtFUk5fV0FSTklORyAidGRmeGZiOiBDYW4ndCByZXNlcnZlIHJlZ2Jhc2VcbiIpOwoJCWdvdG8gb3V0X2VycjsKCX0gCgoJdGRmeF9maXguc21lbV9zdGFydCA9IHBjaV9yZXNvdXJjZV9zdGFydChwZGV2LCAxKTsKCWlmICghKHRkZnhfZml4LnNtZW1fbGVuID0gZG9fbGZiX3NpemUoZGVmYXVsdF9wYXIsIHBkZXYtPmRldmljZSkpKSB7CgkJcHJpbnRrKCJmYjogQ2FuJ3QgY291bnQgJXMgbWVtb3J5LlxuIiwgdGRmeF9maXguaWQpOwoJCXJlbGVhc2VfbWVtX3JlZ2lvbihwY2lfcmVzb3VyY2Vfc3RhcnQocGRldiwgMCksCgkJCQkgICBwY2lfcmVzb3VyY2VfbGVuKHBkZXYsIDApKTsKCQlnb3RvIG91dF9lcnI7CQoJfQoKCWlmICghcmVxdWVzdF9tZW1fcmVnaW9uKHBjaV9yZXNvdXJjZV9zdGFydChwZGV2LCAxKSwKCSAgICAgcGNpX3Jlc291cmNlX2xlbihwZGV2LCAxKSwgInRkZnggc21lbSIpKSB7CgkJcHJpbnRrKEtFUk5fV0FSTklORyAidGRmeGZiOiBDYW4ndCByZXNlcnZlIHNtZW1cbiIpOwoJCXJlbGVhc2VfbWVtX3JlZ2lvbihwY2lfcmVzb3VyY2Vfc3RhcnQocGRldiwgMCksCgkJCQkgICBwY2lfcmVzb3VyY2VfbGVuKHBkZXYsIDApKTsKCQlnb3RvIG91dF9lcnI7Cgl9CgoJaW5mby0+c2NyZWVuX2Jhc2UgPSBpb3JlbWFwX25vY2FjaGUodGRmeF9maXguc21lbV9zdGFydCwgCgkJCQkJICAgIHRkZnhfZml4LnNtZW1fbGVuKTsKCWlmICghaW5mby0+c2NyZWVuX2Jhc2UpIHsKCQlwcmludGsoImZiOiBDYW4ndCByZW1hcCAlcyBmcmFtZWJ1ZmZlci5cbiIsIHRkZnhfZml4LmlkKTsKCQlyZWxlYXNlX21lbV9yZWdpb24ocGNpX3Jlc291cmNlX3N0YXJ0KHBkZXYsIDEpLAoJCQkJICAgcGNpX3Jlc291cmNlX2xlbihwZGV2LCAxKSk7CgkJcmVsZWFzZV9tZW1fcmVnaW9uKHBjaV9yZXNvdXJjZV9zdGFydChwZGV2LCAwKSwKCQkJCSAgIHBjaV9yZXNvdXJjZV9sZW4ocGRldiwgMCkpOwoJCWdvdG8gb3V0X2VycjsKCX0KCglkZWZhdWx0X3Bhci0+aW9iYXNlID0gcGNpX3Jlc291cmNlX3N0YXJ0KHBkZXYsIDIpOwogICAgCglpZiAoIXJlcXVlc3RfcmVnaW9uKHBjaV9yZXNvdXJjZV9zdGFydChwZGV2LCAyKSwKCSAgICBwY2lfcmVzb3VyY2VfbGVuKHBkZXYsIDIpLCAidGRmeCBpb2Jhc2UiKSkgewoJCXByaW50ayhLRVJOX1dBUk5JTkcgInRkZnhmYjogQ2FuJ3QgcmVzZXJ2ZSBpb2Jhc2VcbiIpOwoJCXJlbGVhc2VfbWVtX3JlZ2lvbihwY2lfcmVzb3VyY2Vfc3RhcnQocGRldiwgMSksCgkJCQkgICBwY2lfcmVzb3VyY2VfbGVuKHBkZXYsIDEpKTsKCQlyZWxlYXNlX21lbV9yZWdpb24ocGNpX3Jlc291cmNlX3N0YXJ0KHBkZXYsIDApLAoJCQkJICAgcGNpX3Jlc291cmNlX2xlbihwZGV2LCAwKSk7CgkJZ290byBvdXRfZXJyOwoJfQoKCXByaW50aygiZmI6ICVzIG1lbW9yeSA9ICVkS1xuIiwgdGRmeF9maXguaWQsIHRkZnhfZml4LnNtZW1fbGVuID4+IDEwKTsKCgl0ZGZ4X2ZpeC55cGFuc3RlcAk9IG5vcGFuID8gMCA6IDE7Cgl0ZGZ4X2ZpeC55d3JhcHN0ZXAJPSBub3dyYXAgPyAwIDogMTsKICAgCglpbmZvLT5ub2RlCQk9IE5PREVWOwoJaW5mby0+ZmJvcHMJCT0gJnRkZnhmYl9vcHM7CglpbmZvLT5maXgJCT0gdGRmeF9maXg7IAkKCWluZm8tPnBhcgkJPSBkZWZhdWx0X3BhcjsKCWluZm8tPnBzZXVkb19wYWxldHRlCT0gKHZvaWQgKikoZGVmYXVsdF9wYXIgKyAxKTsgCglpbmZvLT5mbGFncwkJPSBGQklORk9fRkxBR19ERUZBVUxUOwoKI2lmbmRlZiBNT0RVTEUKCWlmICghbW9kZV9vcHRpb24pCgkJbW9kZV9vcHRpb24gPSAiNjQweDQ4MEA2MCI7CgkgCgllcnIgPSBmYl9maW5kX21vZGUoJmluZm8tPnZhciwgaW5mbywgbW9kZV9vcHRpb24sIE5VTEwsIDAsIE5VTEwsIDgpOyAKCWlmICghZXJyIHx8IGVyciA9PSA0KQojZW5kaWYKCQlpbmZvLT52YXIgPSB0ZGZ4X3ZhcjsKCglzaXplID0gKGluZm8tPnZhci5iaXRzX3Blcl9waXhlbCA9PSA4KSA/IDI1NiA6IDE2OwoJZmJfYWxsb2NfY21hcCgmaW5mby0+Y21hcCwgc2l6ZSwgMCk7ICAKCglpZiAocmVnaXN0ZXJfZnJhbWVidWZmZXIoaW5mbykgPCAwKSB7CgkJcHJpbnRrKCJ0ZGZ4ZmI6IGNhbid0IHJlZ2lzdGVyIGZyYW1lYnVmZmVyXG4iKTsKCQlnb3RvIG91dF9lcnI7Cgl9CgkvKgoJICogT3VyIGRyaXZlciBkYXRhCgkgKi8KCXBjaV9zZXRfZHJ2ZGF0YShwZGV2LCBpbmZvKTsKCXJldHVybiAwOyAKCm91dF9lcnI6CgkvKgoJICogQ2xlYW51cCBhZnRlciBhbnl0aGluZyB0aGF0IHdhcyByZW1hcHBlZC9hbGxvY2F0ZWQuCgkgKi8KCWlmIChkZWZhdWx0X3Bhci0+cmVnYmFzZV92aXJ0KQoJCWlvdW5tYXAoZGVmYXVsdF9wYXItPnJlZ2Jhc2VfdmlydCk7CglpZiAoaW5mby0+c2NyZWVuX2Jhc2UpCgkJaW91bm1hcChpbmZvLT5zY3JlZW5fYmFzZSk7CglrZnJlZShpbmZvKTsKCXJldHVybiAtRU5YSU87Cn0KCi8qKgogKiAgICAgIHRkZnhmYl9yZW1vdmUgLSBEZXZpY2UgcmVtb3ZhbAogKgogKiAgICAgIEBwZGV2OiAgUENJIERldmljZSB0byBjbGVhbnVwCiAqCiAqICAgICAgUmVsZWFzZXMgYWxsIHJlc291cmNlcyBhbGxvY2F0ZWQgZHVyaW5nIHRoZSBjb3Vyc2Ugb2YgdGhlIGRyaXZlcidzCiAqICAgICAgbGlmZXRpbWUgZm9yIHRoZSBQQ0kgZGV2aWNlIEBwZGV2LgogKgogKi8Kc3RhdGljIHZvaWQgX19kZXZleGl0IHRkZnhmYl9yZW1vdmUoc3RydWN0IHBjaV9kZXYgKnBkZXYpCnsKCXN0cnVjdCBmYl9pbmZvICppbmZvID0gcGNpX2dldF9kcnZkYXRhKHBkZXYpOwoJc3RydWN0IHRkZnhfcGFyICpwYXIgPSAoc3RydWN0IHRkZnhfcGFyICopIGluZm8tPnBhcjsKCgl1bnJlZ2lzdGVyX2ZyYW1lYnVmZmVyKGluZm8pOwoJaW91bm1hcChwYXItPnJlZ2Jhc2VfdmlydCk7Cglpb3VubWFwKGluZm8tPnNjcmVlbl9iYXNlKTsKCgkvKiBDbGVhbiB1cCBhZnRlciByZXNlcnZlZCByZWdpb25zICovCglyZWxlYXNlX3JlZ2lvbihwY2lfcmVzb3VyY2Vfc3RhcnQocGRldiwgMiksCgkJICAgICAgIHBjaV9yZXNvdXJjZV9sZW4ocGRldiwgMikpOwoJcmVsZWFzZV9tZW1fcmVnaW9uKHBjaV9yZXNvdXJjZV9zdGFydChwZGV2LCAxKSwKCQkJICAgcGNpX3Jlc291cmNlX2xlbihwZGV2LCAxKSk7CglyZWxlYXNlX21lbV9yZWdpb24ocGNpX3Jlc291cmNlX3N0YXJ0KHBkZXYsIDApLAoJCQkgICBwY2lfcmVzb3VyY2VfbGVuKHBkZXYsIDApKTsKCXBjaV9zZXRfZHJ2ZGF0YShwZGV2LCBOVUxMKTsKCWtmcmVlKGluZm8pOwp9CgppbnQgX19pbml0IHRkZnhmYl9pbml0KHZvaWQpCnsKICAgICAgICByZXR1cm4gcGNpX21vZHVsZV9pbml0KCZ0ZGZ4ZmJfZHJpdmVyKTsKfQoKc3RhdGljIHZvaWQgX19leGl0IHRkZnhmYl9leGl0KHZvaWQpCnsKICAgICAgICBwY2lfdW5yZWdpc3Rlcl9kcml2ZXIoJnRkZnhmYl9kcml2ZXIpOwp9CgpNT0RVTEVfQVVUSE9SKCJIYW5udSBNYWxsYXQgPGhtYWxsYXRAY2MuaHV0LmZpPiIpOwpNT0RVTEVfREVTQ1JJUFRJT04oIjNEZnggZnJhbWVidWZmZXIgZGV2aWNlIGRyaXZlciIpOwpNT0RVTEVfTElDRU5TRSgiR1BMIik7CiAKI2lmZGVmIE1PRFVMRQptb2R1bGVfaW5pdCh0ZGZ4ZmJfaW5pdCk7CiNlbmRpZgptb2R1bGVfZXhpdCh0ZGZ4ZmJfZXhpdCk7CgoKI2lmbmRlZiBNT0RVTEUKdm9pZCB0ZGZ4ZmJfc2V0dXAoY2hhciAqb3B0aW9ucywgaW50ICppbnRzKQp7IAoJY2hhciogdGhpc19vcHQ7CgoJaWYgKCFvcHRpb25zIHx8ICEqb3B0aW9ucykKCQlyZXR1cm47CgoJd2hpbGUgKCh0aGlzX29wdCA9IHN0cnNlcCgmb3B0aW9ucywgIiwiKSkgIT0gTlVMTCkgewkKCQlpZiAoISp0aGlzX29wdCkKCQkJY29udGludWU7CgkJaWYgKCFzdHJjbXAodGhpc19vcHQsICJpbnZlcnNlIikpIHsKCQkJaW52ZXJzZSA9IDE7CgkJCWZiX2ludmVydF9jbWFwcygpOwoJCX0gZWxzZSBpZighc3RyY21wKHRoaXNfb3B0LCAibm9wYW4iKSkgewoJCQlub3BhbiA9IDE7CgkJfSBlbHNlIGlmKCFzdHJjbXAodGhpc19vcHQsICJub3dyYXAiKSkgewoJCQlub3dyYXAgPSAxOwoJCX0gZWxzZSB7CgkJCW1vZGVfb3B0aW9uID0gdGhpc19vcHQ7CgkJfQoJfSAKfQojZW5kaWYKCg==