LyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgICAgICAKICogRmlsZW5hbWU6ICAgICAgbnNjLWlyY2MuYwogKiBWZXJzaW9uOiAgICAgICAxLjAKICogRGVzY3JpcHRpb246ICAgRHJpdmVyIGZvciB0aGUgTlNDIFBDJzEwOCBhbmQgUEMnMzM4IElyREEgY2hpcHNldHMKICogU3RhdHVzOiAgICAgICAgU3RhYmxlLgogKiBBdXRob3I6ICAgICAgICBEYWcgQnJhdHRsaSA8ZGFnYkBjcy51aXQubm8+CiAqIENyZWF0ZWQgYXQ6ICAgIFNhdCBOb3YgIDcgMjE6NDM6MTUgMTk5OAogKiBNb2RpZmllZCBhdDogICBXZWQgTWFyICAxIDExOjI5OjM0IDIwMDAKICogTW9kaWZpZWQgYnk6ICAgRGFnIEJyYXR0bGkgPGRhZ2JAY3MudWl0Lm5vPgogKiAKICogICAgIENvcHlyaWdodCAoYykgMTk5OC0yMDAwIERhZyBCcmF0dGxpIDxkYWdiQGNzLnVpdC5ubz4KICogICAgIENvcHlyaWdodCAoYykgMTk5OCBMaWNoZW4gV2FuZywgPGx3YW5nQGFjdGlzeXMuY29tPgogKiAgICAgQ29weXJpZ2h0IChjKSAxOTk4IEFjdGlzeXMgQ29ycC4sIHd3dy5hY3Rpc3lzLmNvbQogKiAgICAgQWxsIFJpZ2h0cyBSZXNlcnZlZAogKiAgICAgIAogKiAgICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciAKICogICAgIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIAogKiAgICAgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgCiAqICAgICB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KICogIAogKiAgICAgTmVpdGhlciBEYWcgQnJhdHRsaSBub3IgVW5pdmVyc2l0eSBvZiBUcm9tc/ggYWRtaXQgbGlhYmlsaXR5IG5vcgogKiAgICAgcHJvdmlkZSB3YXJyYW50eSBmb3IgYW55IG9mIHRoaXMgc29mdHdhcmUuIFRoaXMgbWF0ZXJpYWwgaXMgCiAqICAgICBwcm92aWRlZCAiQVMtSVMiIGFuZCBhdCBubyBjaGFyZ2UuCiAqCiAqICAgICBOb3RpY2UgdGhhdCBhbGwgZnVuY3Rpb25zIHRoYXQgbmVlZHMgdG8gYWNjZXNzIHRoZSBjaGlwIGluIF9hbnlfCiAqICAgICB3YXksIG11c3Qgc2F2ZSBCU1IgcmVnaXN0ZXIgb24gZW50cnksIGFuZCByZXN0b3JlIGl0IG9uIGV4aXQuIAogKiAgICAgSXQgaXMgX3ZlcnlfIGltcG9ydGFudCB0byBmb2xsb3cgdGhpcyBwb2xpY3khCiAqCiAqICAgICAgICAgX191OCBiYW5rOwogKiAgICAgCiAqICAgICAgICAgYmFuayA9IGluYihpb2Jhc2UrQlNSKTsKICogIAogKiAgICAgICAgIGRvX3lvdXJfc3R1ZmZfaGVyZSgpOwogKgogKiAgICAgICAgIG91dGIoYmFuaywgaW9iYXNlK0JTUik7CiAqCiAqICAgIElmIHlvdSBmaW5kIGJ1Z3MgaW4gdGhpcyBmaWxlLCBpdHMgdmVyeSBsaWtlbHkgdGhhdCB0aGUgc2FtZSBidWcKICogICAgd2lsbCBhbHNvIGJlIGluIHc4Mzk3N2FmX2lyLmMgc2luY2UgdGhlIGltcGxlbWVudGF0aW9ucyBhcmUgcXVpdGUKICogICAgc2ltaWxhci4KICogICAgIAogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgojaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CgojaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgojaW5jbHVkZSA8bGludXgvc2tidWZmLmg+CiNpbmNsdWRlIDxsaW51eC9uZXRkZXZpY2UuaD4KI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgojaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KI2luY2x1ZGUgPGxpbnV4L3J0bmV0bGluay5oPgojaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KCiNpbmNsdWRlIDxhc20vaW8uaD4KI2luY2x1ZGUgPGFzbS9kbWEuaD4KI2luY2x1ZGUgPGFzbS9ieXRlb3JkZXIuaD4KCiNpbmNsdWRlIDxsaW51eC9wbS5oPgojaW5jbHVkZSA8bGludXgvcG1fbGVnYWN5Lmg+CgojaW5jbHVkZSA8bmV0L2lyZGEvd3JhcHBlci5oPgojaW5jbHVkZSA8bmV0L2lyZGEvaXJkYS5oPgojaW5jbHVkZSA8bmV0L2lyZGEvaXJkYV9kZXZpY2UuaD4KCiNpbmNsdWRlICJuc2MtaXJjYy5oIgoKI2RlZmluZSBDSElQX0lPX0VYVEVOVCA4CiNkZWZpbmUgQlJPS0VOX0RPTkdMRV9JRAoKc3RhdGljIGNoYXIgKmRyaXZlcl9uYW1lID0gIm5zYy1pcmNjIjsKCi8qIE1vZHVsZSBwYXJhbWV0ZXJzICovCnN0YXRpYyBpbnQgcW9zX210dF9iaXRzID0gMHgwNzsgIC8qIDEgbXMgb3IgbW9yZSAqLwpzdGF0aWMgaW50IGRvbmdsZV9pZDsKCi8qIFVzZSBCSU9TIHNldHRpb25zIGJ5IGRlZmF1bHQsIGJ1dCB1c2VyIG1heSBzdXBwbHkgbW9kdWxlIHBhcmFtZXRlcnMgKi8Kc3RhdGljIHVuc2lnbmVkIGludCBpb1tdICA9IHsgfjAsIH4wLCB+MCwgfjAgfTsKc3RhdGljIHVuc2lnbmVkIGludCBpcnFbXSA9IHsgMCwgMCwgMCwgMCwgMCB9OwpzdGF0aWMgdW5zaWduZWQgaW50IGRtYVtdID0geyAwLCAwLCAwLCAwLCAwIH07CgpzdGF0aWMgaW50IG5zY19pcmNjX3Byb2JlXzEwOChuc2NfY2hpcF90ICpjaGlwLCBjaGlwaW9fdCAqaW5mbyk7CnN0YXRpYyBpbnQgbnNjX2lyY2NfcHJvYmVfMzM4KG5zY19jaGlwX3QgKmNoaXAsIGNoaXBpb190ICppbmZvKTsKc3RhdGljIGludCBuc2NfaXJjY19wcm9iZV8zOXgobnNjX2NoaXBfdCAqY2hpcCwgY2hpcGlvX3QgKmluZm8pOwpzdGF0aWMgaW50IG5zY19pcmNjX2luaXRfMTA4KG5zY19jaGlwX3QgKmNoaXAsIGNoaXBpb190ICppbmZvKTsKc3RhdGljIGludCBuc2NfaXJjY19pbml0XzMzOChuc2NfY2hpcF90ICpjaGlwLCBjaGlwaW9fdCAqaW5mbyk7CnN0YXRpYyBpbnQgbnNjX2lyY2NfaW5pdF8zOXgobnNjX2NoaXBfdCAqY2hpcCwgY2hpcGlvX3QgKmluZm8pOwoKLyogVGhlc2UgYXJlIHRoZSBrbm93biBOU0MgY2hpcHMgKi8Kc3RhdGljIG5zY19jaGlwX3QgY2hpcHNbXSA9IHsKLyogIE5hbWUsIHtjZmcgcmVnaXN0ZXJzfSwgY2hpcCBpZCBpbmRleCByZWcsIGNoaXAgaWQgZXhwZWN0ZWQgdmFsdWUsIHJldmlzaW9uIG1hc2sgKi8KCXsgIlBDODcxMDgiLCB7IDB4MTUwLCAweDM5OCwgMHhlYSB9LCAweDA1LCAweDEwLCAweGYwLCAKCSAgbnNjX2lyY2NfcHJvYmVfMTA4LCBuc2NfaXJjY19pbml0XzEwOCB9LAoJeyAiUEM4NzMzOCIsIHsgMHgzOTgsIDB4MTVjLCAweDJlIH0sIDB4MDgsIDB4YjAsIDB4ZjgsIAoJICBuc2NfaXJjY19wcm9iZV8zMzgsIG5zY19pcmNjX2luaXRfMzM4IH0sCgkvKiBDb250cmlidXRlZCBieSBTdGVmZmVuIFBpbmdlbCAtIElCTSBYNDAgKi8KCXsgIlBDODczOHgiLCB7IDB4MTY0ZSwgMHg0ZSwgMHgwIH0sIDB4MjAsIDB4ZjQsIDB4ZmYsCgkgIG5zY19pcmNjX3Byb2JlXzM5eCwgbnNjX2lyY2NfaW5pdF8zOXggfSwKCS8qIENvbnRyaWJ1dGVkIGJ5IEphbiBGcmV5IC0gSUJNIEEzMC9BMzEgKi8KCXsgIlBDODczOXgiLCB7IDB4MmUsIDB4NGUsIDB4MCB9LCAweDIwLCAweGVhLCAweGZmLCAKCSAgbnNjX2lyY2NfcHJvYmVfMzl4LCBuc2NfaXJjY19pbml0XzM5eCB9LAoJeyBOVUxMIH0KfTsKCi8qIE1heCA0IGluc3RhbmNlcyBmb3Igbm93ICovCnN0YXRpYyBzdHJ1Y3QgbnNjX2lyY2NfY2IgKmRldl9zZWxmW10gPSB7IE5VTEwsIE5VTEwsIE5VTEwsIE5VTEwgfTsKCnN0YXRpYyBjaGFyICpkb25nbGVfdHlwZXNbXSA9IHsKCSJEaWZmZXJlbnRpYWwgc2VyaWFsIGludGVyZmFjZSIsCgkiRGlmZmVyZW50aWFsIHNlcmlhbCBpbnRlcmZhY2UiLAoJIlJlc2VydmVkIiwKCSJSZXNlcnZlZCIsCgkiU2hhcnAgUlk1SEQwMSIsCgkiUmVzZXJ2ZWQiLAoJIlNpbmdsZS1lbmRlZCBzZXJpYWwgaW50ZXJmYWNlIiwKCSJDb25zdW1lci1JUiBvbmx5IiwKCSJIUCBIU0RMLTIzMDAsIEhQIEhTREwtMzYwMC9IU0RMLTM2MTAiLAoJIklCTTMxVDExMDAgb3IgVGVtaWMgVEZEUzYwMDAvVEZEUzY1MDAiLAoJIlJlc2VydmVkIiwKCSJSZXNlcnZlZCIsCgkiSFAgSFNETC0xMTAwL0hTREwtMjEwMCIsCgkiSFAgSFNETC0xMTAwL0hTREwtMjEwMCIsCgkiU3VwcG9ydHMgU0lSIE1vZGUgb25seSIsCgkiTm8gZG9uZ2xlIGNvbm5lY3RlZCIsCn07CgovKiBTb21lIHByb3RvdHlwZXMgKi8Kc3RhdGljIGludCAgbnNjX2lyY2Nfb3BlbihpbnQgaSwgY2hpcGlvX3QgKmluZm8pOwpzdGF0aWMgaW50ICBuc2NfaXJjY19jbG9zZShzdHJ1Y3QgbnNjX2lyY2NfY2IgKnNlbGYpOwpzdGF0aWMgaW50ICBuc2NfaXJjY19zZXR1cChjaGlwaW9fdCAqaW5mbyk7CnN0YXRpYyB2b2lkIG5zY19pcmNjX3Bpb19yZWNlaXZlKHN0cnVjdCBuc2NfaXJjY19jYiAqc2VsZik7CnN0YXRpYyBpbnQgIG5zY19pcmNjX2RtYV9yZWNlaXZlKHN0cnVjdCBuc2NfaXJjY19jYiAqc2VsZik7IApzdGF0aWMgaW50ICBuc2NfaXJjY19kbWFfcmVjZWl2ZV9jb21wbGV0ZShzdHJ1Y3QgbnNjX2lyY2NfY2IgKnNlbGYsIGludCBpb2Jhc2UpOwpzdGF0aWMgaW50ICBuc2NfaXJjY19oYXJkX3htaXRfc2lyKHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOwpzdGF0aWMgaW50ICBuc2NfaXJjY19oYXJkX3htaXRfZmlyKHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOwpzdGF0aWMgaW50ICBuc2NfaXJjY19waW9fd3JpdGUoaW50IGlvYmFzZSwgX191OCAqYnVmLCBpbnQgbGVuLCBpbnQgZmlmb19zaXplKTsKc3RhdGljIHZvaWQgbnNjX2lyY2NfZG1hX3htaXQoc3RydWN0IG5zY19pcmNjX2NiICpzZWxmLCBpbnQgaW9iYXNlKTsKc3RhdGljIF9fdTggbnNjX2lyY2NfY2hhbmdlX3NwZWVkKHN0cnVjdCBuc2NfaXJjY19jYiAqc2VsZiwgX191MzIgYmF1ZCk7CnN0YXRpYyBpbnQgIG5zY19pcmNjX2lzX3JlY2VpdmluZyhzdHJ1Y3QgbnNjX2lyY2NfY2IgKnNlbGYpOwpzdGF0aWMgaW50ICBuc2NfaXJjY19yZWFkX2RvbmdsZV9pZCAoaW50IGlvYmFzZSk7CnN0YXRpYyB2b2lkIG5zY19pcmNjX2luaXRfZG9uZ2xlX2ludGVyZmFjZSAoaW50IGlvYmFzZSwgaW50IGRvbmdsZV9pZCk7CgpzdGF0aWMgaW50ICBuc2NfaXJjY19uZXRfb3BlbihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KTsKc3RhdGljIGludCAgbnNjX2lyY2NfbmV0X2Nsb3NlKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOwpzdGF0aWMgaW50ICBuc2NfaXJjY19uZXRfaW9jdGwoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgc3RydWN0IGlmcmVxICpycSwgaW50IGNtZCk7CnN0YXRpYyBzdHJ1Y3QgbmV0X2RldmljZV9zdGF0cyAqbnNjX2lyY2NfbmV0X2dldF9zdGF0cyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KTsKc3RhdGljIGludCBuc2NfaXJjY19wbXByb2Moc3RydWN0IHBtX2RldiAqZGV2LCBwbV9yZXF1ZXN0X3QgcnFzdCwgdm9pZCAqZGF0YSk7CgovKgogKiBGdW5jdGlvbiBuc2NfaXJjY19pbml0ICgpCiAqCiAqICAgIEluaXRpYWxpemUgY2hpcC4gSnVzdCB0cnkgdG8gZmluZCBvdXQgaG93IG1hbnkgY2hpcHMgd2UgYXJlIGRlYWxpbmcgd2l0aAogKiAgICBhbmQgd2hlcmUgdGhleSBhcmUKICovCnN0YXRpYyBpbnQgX19pbml0IG5zY19pcmNjX2luaXQodm9pZCkKewoJY2hpcGlvX3QgaW5mbzsKCW5zY19jaGlwX3QgKmNoaXA7CglpbnQgcmV0ID0gLUVOT0RFVjsKCWludCBjZmdfYmFzZTsKCWludCBjZmcsIGlkOwoJaW50IHJlZzsKCWludCBpID0gMDsKCgkvKiBQcm9iZSBmb3IgYWxsIHRoZSBOU0MgY2hpcHNldHMgd2Uga25vdyBhYm91dCAqLwoJZm9yIChjaGlwPWNoaXBzOyBjaGlwLT5uYW1lIDsgY2hpcCsrKSB7CgkJSVJEQV9ERUJVRygyLCAiJXMoKSwgUHJvYmluZyBmb3IgJXMgLi4uXG4iLCBfX0ZVTkNUSU9OX18sCgkJCSAgIGNoaXAtPm5hbWUpOwoJCQoJCS8qIFRyeSBhbGwgY29uZmlnIHJlZ2lzdGVycyBmb3IgdGhpcyBjaGlwICovCgkJZm9yIChjZmc9MDsgY2ZnPDM7IGNmZysrKSB7CgkJCWNmZ19iYXNlID0gY2hpcC0+Y2ZnW2NmZ107CgkJCWlmICghY2ZnX2Jhc2UpCgkJCQljb250aW51ZTsKCQkJCgkJCW1lbXNldCgmaW5mbywgMCwgc2l6ZW9mKGNoaXBpb190KSk7CgkJCWluZm8uY2ZnX2Jhc2UgPSBjZmdfYmFzZTsKCQkJaW5mby5maXJfYmFzZSA9IGlvW2ldOwoJCQlpbmZvLmRtYSA9IGRtYVtpXTsKCQkJaW5mby5pcnEgPSBpcnFbaV07CgoJCQkvKiBSZWFkIGluZGV4IHJlZ2lzdGVyICovCgkJCXJlZyA9IGluYihjZmdfYmFzZSk7CgkJCWlmIChyZWcgPT0gMHhmZikgewoJCQkJSVJEQV9ERUJVRygyLCAiJXMoKSBubyBjaGlwIGF0IDB4JTAzeFxuIiwgX19GVU5DVElPTl9fLCBjZmdfYmFzZSk7CgkJCQljb250aW51ZTsKCQkJfQoJCQkKCQkJLyogUmVhZCBjaGlwIGlkZW50aWZpY2F0aW9uIHJlZ2lzdGVyICovCgkJCW91dGIoY2hpcC0+Y2lkX2luZGV4LCBjZmdfYmFzZSk7CgkJCWlkID0gaW5iKGNmZ19iYXNlKzEpOwoJCQlpZiAoKGlkICYgY2hpcC0+Y2lkX21hc2spID09IGNoaXAtPmNpZF92YWx1ZSkgewoJCQkJSVJEQV9ERUJVRygyLCAiJXMoKSBGb3VuZCAlcyBjaGlwLCByZXZpc2lvbj0lZFxuIiwKCQkJCQkgICBfX0ZVTkNUSU9OX18sIGNoaXAtPm5hbWUsIGlkICYgfmNoaXAtPmNpZF9tYXNrKTsKCQkJCS8qIAoJCQkJICogSWYgdGhlIHVzZXIgc3VwcGxpZXMgdGhlIGJhc2UgYWRkcmVzcywgdGhlbgoJCQkJICogd2UgaW5pdCB0aGUgY2hpcCwgaWYgbm90IHdlIHByb2JlIHRoZSB2YWx1ZXMKCQkJCSAqIHNldCBieSB0aGUgQklPUwoJCQkJICovCQkJCQoJCQkJaWYgKGlvW2ldIDwgMHgyMDAwKSB7CgkJCQkJY2hpcC0+aW5pdChjaGlwLCAmaW5mbyk7CgkJCQl9IGVsc2UKCQkJCQljaGlwLT5wcm9iZShjaGlwLCAmaW5mbyk7CgoJCQkJaWYgKG5zY19pcmNjX29wZW4oaSwgJmluZm8pID09IDApCgkJCQkJcmV0ID0gMDsKCQkJCWkrKzsKCQkJfSBlbHNlIHsKCQkJCUlSREFfREVCVUcoMiwgIiVzKCksIFdyb25nIGNoaXAgaWQ9MHglMDJ4XG4iLCBfX0ZVTkNUSU9OX18sIGlkKTsKCQkJfQoJCX0gCgkJCgl9CgoJcmV0dXJuIHJldDsKfQoKLyoKICogRnVuY3Rpb24gbnNjX2lyY2NfY2xlYW51cCAoKQogKgogKiAgICBDbG9zZSBhbGwgY29uZmlndXJlZCBjaGlwcwogKgogKi8Kc3RhdGljIHZvaWQgX19leGl0IG5zY19pcmNjX2NsZWFudXAodm9pZCkKewoJaW50IGk7CgoJcG1fdW5yZWdpc3Rlcl9hbGwobnNjX2lyY2NfcG1wcm9jKTsKCglmb3IgKGk9MDsgaSA8IDQ7IGkrKykgewoJCWlmIChkZXZfc2VsZltpXSkKCQkJbnNjX2lyY2NfY2xvc2UoZGV2X3NlbGZbaV0pOwoJfQp9CgovKgogKiBGdW5jdGlvbiBuc2NfaXJjY19vcGVuIChpb2Jhc2UsIGlycSkKICoKICogICAgT3BlbiBkcml2ZXIgaW5zdGFuY2UKICoKICovCnN0YXRpYyBpbnQgX19pbml0IG5zY19pcmNjX29wZW4oaW50IGksIGNoaXBpb190ICppbmZvKQp7CglzdHJ1Y3QgbmV0X2RldmljZSAqZGV2OwoJc3RydWN0IG5zY19pcmNjX2NiICpzZWxmOwogICAgICAgIHN0cnVjdCBwbV9kZXYgKnBtZGV2OwoJdm9pZCAqcmV0OwoJaW50IGVycjsKCglJUkRBX0RFQlVHKDIsICIlcygpXG4iLCBfX0ZVTkNUSU9OX18pOwoKCUlSREFfTUVTU0FHRSgiJXMsIEZvdW5kIGNoaXAgYXQgYmFzZT0weCUwM3hcbiIsIGRyaXZlcl9uYW1lLAoJCSAgICAgaW5mby0+Y2ZnX2Jhc2UpOwoKCWlmICgobnNjX2lyY2Nfc2V0dXAoaW5mbykpID09IC0xKQoJCXJldHVybiAtMTsKCglJUkRBX01FU1NBR0UoIiVzLCBkcml2ZXIgbG9hZGVkIChEYWcgQnJhdHRsaSlcbiIsIGRyaXZlcl9uYW1lKTsKCglkZXYgPSBhbGxvY19pcmRhZGV2KHNpemVvZihzdHJ1Y3QgbnNjX2lyY2NfY2IpKTsKCWlmIChkZXYgPT0gTlVMTCkgewoJCUlSREFfRVJST1IoIiVzKCksIGNhbid0IGFsbG9jYXRlIG1lbW9yeSBmb3IgIgoJCQkgICAiY29udHJvbCBibG9jayFcbiIsIF9fRlVOQ1RJT05fXyk7CgkJcmV0dXJuIC1FTk9NRU07Cgl9CgoJc2VsZiA9IGRldi0+cHJpdjsKCXNlbGYtPm5ldGRldiA9IGRldjsKCXNwaW5fbG9ja19pbml0KCZzZWxmLT5sb2NrKTsKICAgCgkvKiBOZWVkIHRvIHN0b3JlIHNlbGYgc29tZXdoZXJlICovCglkZXZfc2VsZltpXSA9IHNlbGY7CglzZWxmLT5pbmRleCA9IGk7CgoJLyogSW5pdGlhbGl6ZSBJTyAqLwoJc2VsZi0+aW8uY2ZnX2Jhc2UgID0gaW5mby0+Y2ZnX2Jhc2U7CglzZWxmLT5pby5maXJfYmFzZSAgPSBpbmZvLT5maXJfYmFzZTsKICAgICAgICBzZWxmLT5pby5pcnEgICAgICAgPSBpbmZvLT5pcnE7CiAgICAgICAgc2VsZi0+aW8uZmlyX2V4dCAgID0gQ0hJUF9JT19FWFRFTlQ7CiAgICAgICAgc2VsZi0+aW8uZG1hICAgICAgID0gaW5mby0+ZG1hOwogICAgICAgIHNlbGYtPmlvLmZpZm9fc2l6ZSA9IDMyOwoJCgkvKiBSZXNlcnZlIHRoZSBpb3BvcnRzIHRoYXQgd2UgbmVlZCAqLwoJcmV0ID0gcmVxdWVzdF9yZWdpb24oc2VsZi0+aW8uZmlyX2Jhc2UsIHNlbGYtPmlvLmZpcl9leHQsIGRyaXZlcl9uYW1lKTsKCWlmICghcmV0KSB7CgkJSVJEQV9XQVJOSU5HKCIlcygpLCBjYW4ndCBnZXQgaW9iYXNlIG9mIDB4JTAzeFxuIiwKCQkJICAgICBfX0ZVTkNUSU9OX18sIHNlbGYtPmlvLmZpcl9iYXNlKTsKCQllcnIgPSAtRU5PREVWOwoJCWdvdG8gb3V0MTsKCX0KCgkvKiBJbml0aWFsaXplIFFvUyBmb3IgdGhpcyBkZXZpY2UgKi8KCWlyZGFfaW5pdF9tYXhfcW9zX2NhcGFiaWxpZXMoJnNlbGYtPnFvcyk7CgkKCS8qIFRoZSBvbmx5IHZhbHVlIHdlIG11c3Qgb3ZlcnJpZGUgaXQgdGhlIGJhdWRyYXRlICovCglzZWxmLT5xb3MuYmF1ZF9yYXRlLmJpdHMgPSBJUl85NjAwfElSXzE5MjAwfElSXzM4NDAwfElSXzU3NjAwfAoJCUlSXzExNTIwMHxJUl81NzYwMDB8SVJfMTE1MjAwMCB8KElSXzQwMDAwMDAgPDwgOCk7CgkKCXNlbGYtPnFvcy5taW5fdHVybl90aW1lLmJpdHMgPSBxb3NfbXR0X2JpdHM7CglpcmRhX3Fvc19iaXRzX3RvX3ZhbHVlKCZzZWxmLT5xb3MpOwoJCgkvKiBNYXggRE1BIGJ1ZmZlciBzaXplIG5lZWRlZCA9IChkYXRhX3NpemUgKyA2KSAqICh3aW5kb3dfc2l6ZSkgKyA2OyAqLwoJc2VsZi0+cnhfYnVmZi50cnVlc2l6ZSA9IDE0Mzg0OyAKCXNlbGYtPnR4X2J1ZmYudHJ1ZXNpemUgPSAxNDM4NDsKCgkvKiBBbGxvY2F0ZSBtZW1vcnkgaWYgbmVlZGVkICovCglzZWxmLT5yeF9idWZmLmhlYWQgPQoJCWRtYV9hbGxvY19jb2hlcmVudChOVUxMLCBzZWxmLT5yeF9idWZmLnRydWVzaXplLAoJCQkJICAgJnNlbGYtPnJ4X2J1ZmZfZG1hLCBHRlBfS0VSTkVMKTsKCWlmIChzZWxmLT5yeF9idWZmLmhlYWQgPT0gTlVMTCkgewoJCWVyciA9IC1FTk9NRU07CgkJZ290byBvdXQyOwoKCX0KCW1lbXNldChzZWxmLT5yeF9idWZmLmhlYWQsIDAsIHNlbGYtPnJ4X2J1ZmYudHJ1ZXNpemUpOwoJCglzZWxmLT50eF9idWZmLmhlYWQgPQoJCWRtYV9hbGxvY19jb2hlcmVudChOVUxMLCBzZWxmLT50eF9idWZmLnRydWVzaXplLAoJCQkJICAgJnNlbGYtPnR4X2J1ZmZfZG1hLCBHRlBfS0VSTkVMKTsKCWlmIChzZWxmLT50eF9idWZmLmhlYWQgPT0gTlVMTCkgewoJCWVyciA9IC1FTk9NRU07CgkJZ290byBvdXQzOwoJfQoJbWVtc2V0KHNlbGYtPnR4X2J1ZmYuaGVhZCwgMCwgc2VsZi0+dHhfYnVmZi50cnVlc2l6ZSk7CgoJc2VsZi0+cnhfYnVmZi5pbl9mcmFtZSA9IEZBTFNFOwoJc2VsZi0+cnhfYnVmZi5zdGF0ZSA9IE9VVFNJREVfRlJBTUU7CglzZWxmLT50eF9idWZmLmRhdGEgPSBzZWxmLT50eF9idWZmLmhlYWQ7CglzZWxmLT5yeF9idWZmLmRhdGEgPSBzZWxmLT5yeF9idWZmLmhlYWQ7CgkKCS8qIFJlc2V0IFR4IHF1ZXVlIGluZm8gKi8KCXNlbGYtPnR4X2ZpZm8ubGVuID0gc2VsZi0+dHhfZmlmby5wdHIgPSBzZWxmLT50eF9maWZvLmZyZWUgPSAwOwoJc2VsZi0+dHhfZmlmby50YWlsID0gc2VsZi0+dHhfYnVmZi5oZWFkOwoKCS8qIE92ZXJyaWRlIHRoZSBuZXR3b3JrIGZ1bmN0aW9ucyB3ZSBuZWVkIHRvIHVzZSAqLwoJU0VUX01PRFVMRV9PV05FUihkZXYpOwoJZGV2LT5oYXJkX3N0YXJ0X3htaXQgPSBuc2NfaXJjY19oYXJkX3htaXRfc2lyOwoJZGV2LT5vcGVuICAgICAgICAgICAgPSBuc2NfaXJjY19uZXRfb3BlbjsKCWRldi0+c3RvcCAgICAgICAgICAgID0gbnNjX2lyY2NfbmV0X2Nsb3NlOwoJZGV2LT5kb19pb2N0bCAgICAgICAgPSBuc2NfaXJjY19uZXRfaW9jdGw7CglkZXYtPmdldF9zdGF0cwkgICAgID0gbnNjX2lyY2NfbmV0X2dldF9zdGF0czsKCgllcnIgPSByZWdpc3Rlcl9uZXRkZXYoZGV2KTsKCWlmIChlcnIpIHsKCQlJUkRBX0VSUk9SKCIlcygpLCByZWdpc3Rlcl9uZXRkZXYoKSBmYWlsZWQhXG4iLCBfX0ZVTkNUSU9OX18pOwoJCWdvdG8gb3V0NDsKCX0KCUlSREFfTUVTU0FHRSgiSXJEQTogUmVnaXN0ZXJlZCBkZXZpY2UgJXNcbiIsIGRldi0+bmFtZSk7CgoJLyogQ2hlY2sgaWYgdXNlciBoYXMgc3VwcGxpZWQgYSB2YWxpZCBkb25nbGUgaWQgb3Igbm90ICovCglpZiAoKGRvbmdsZV9pZCA8PSAwKSB8fAoJICAgIChkb25nbGVfaWQgPj0gKHNpemVvZihkb25nbGVfdHlwZXMpIC8gc2l6ZW9mKGRvbmdsZV90eXBlc1swXSkpKSApIHsKCQlkb25nbGVfaWQgPSBuc2NfaXJjY19yZWFkX2RvbmdsZV9pZChzZWxmLT5pby5maXJfYmFzZSk7CgkJCgkJSVJEQV9NRVNTQUdFKCIlcywgRm91bmQgZG9uZ2xlOiAlc1xuIiwgZHJpdmVyX25hbWUsCgkJCSAgICAgZG9uZ2xlX3R5cGVzW2RvbmdsZV9pZF0pOwoJfSBlbHNlIHsKCQlJUkRBX01FU1NBR0UoIiVzLCBVc2luZyBkb25nbGU6ICVzXG4iLCBkcml2ZXJfbmFtZSwKCQkJICAgICBkb25nbGVfdHlwZXNbZG9uZ2xlX2lkXSk7Cgl9CgkKCXNlbGYtPmlvLmRvbmdsZV9pZCA9IGRvbmdsZV9pZDsKCW5zY19pcmNjX2luaXRfZG9uZ2xlX2ludGVyZmFjZShzZWxmLT5pby5maXJfYmFzZSwgZG9uZ2xlX2lkKTsKCiAgICAgICAgcG1kZXYgPSBwbV9yZWdpc3RlcihQTV9TWVNfREVWLCBQTV9TWVNfSVJEQSwgbnNjX2lyY2NfcG1wcm9jKTsKICAgICAgICBpZiAocG1kZXYpCiAgICAgICAgICAgICAgICBwbWRldi0+ZGF0YSA9IHNlbGY7CgoJcmV0dXJuIDA7CiBvdXQ0OgoJZG1hX2ZyZWVfY29oZXJlbnQoTlVMTCwgc2VsZi0+dHhfYnVmZi50cnVlc2l6ZSwKCQkJICBzZWxmLT50eF9idWZmLmhlYWQsIHNlbGYtPnR4X2J1ZmZfZG1hKTsKIG91dDM6CglkbWFfZnJlZV9jb2hlcmVudChOVUxMLCBzZWxmLT5yeF9idWZmLnRydWVzaXplLAoJCQkgIHNlbGYtPnJ4X2J1ZmYuaGVhZCwgc2VsZi0+cnhfYnVmZl9kbWEpOwogb3V0MjoKCXJlbGVhc2VfcmVnaW9uKHNlbGYtPmlvLmZpcl9iYXNlLCBzZWxmLT5pby5maXJfZXh0KTsKIG91dDE6CglmcmVlX25ldGRldihkZXYpOwoJZGV2X3NlbGZbaV0gPSBOVUxMOwoJcmV0dXJuIGVycjsKfQoKLyoKICogRnVuY3Rpb24gbnNjX2lyY2NfY2xvc2UgKHNlbGYpCiAqCiAqICAgIENsb3NlIGRyaXZlciBpbnN0YW5jZQogKgogKi8Kc3RhdGljIGludCBfX2V4aXQgbnNjX2lyY2NfY2xvc2Uoc3RydWN0IG5zY19pcmNjX2NiICpzZWxmKQp7CglpbnQgaW9iYXNlOwoKCUlSREFfREVCVUcoNCwgIiVzKClcbiIsIF9fRlVOQ1RJT05fXyk7CgoJSVJEQV9BU1NFUlQoc2VsZiAhPSBOVUxMLCByZXR1cm4gLTE7KTsKCiAgICAgICAgaW9iYXNlID0gc2VsZi0+aW8uZmlyX2Jhc2U7CgoJLyogUmVtb3ZlIG5ldGRldmljZSAqLwoJdW5yZWdpc3Rlcl9uZXRkZXYoc2VsZi0+bmV0ZGV2KTsKCgkvKiBSZWxlYXNlIHRoZSBQT1JUIHRoYXQgdGhpcyBkcml2ZXIgaXMgdXNpbmcgKi8KCUlSREFfREVCVUcoNCwgIiVzKCksIFJlbGVhc2luZyBSZWdpb24gJTAzeFxuIiwgCgkJICAgX19GVU5DVElPTl9fLCBzZWxmLT5pby5maXJfYmFzZSk7CglyZWxlYXNlX3JlZ2lvbihzZWxmLT5pby5maXJfYmFzZSwgc2VsZi0+aW8uZmlyX2V4dCk7CgoJaWYgKHNlbGYtPnR4X2J1ZmYuaGVhZCkKCQlkbWFfZnJlZV9jb2hlcmVudChOVUxMLCBzZWxmLT50eF9idWZmLnRydWVzaXplLAoJCQkJICBzZWxmLT50eF9idWZmLmhlYWQsIHNlbGYtPnR4X2J1ZmZfZG1hKTsKCQoJaWYgKHNlbGYtPnJ4X2J1ZmYuaGVhZCkKCQlkbWFfZnJlZV9jb2hlcmVudChOVUxMLCBzZWxmLT5yeF9idWZmLnRydWVzaXplLAoJCQkJICBzZWxmLT5yeF9idWZmLmhlYWQsIHNlbGYtPnJ4X2J1ZmZfZG1hKTsKCglkZXZfc2VsZltzZWxmLT5pbmRleF0gPSBOVUxMOwoJZnJlZV9uZXRkZXYoc2VsZi0+bmV0ZGV2KTsKCQoJcmV0dXJuIDA7Cn0KCi8qCiAqIEZ1bmN0aW9uIG5zY19pcmNjX2luaXRfMTA4IChpb2Jhc2UsIGNmZ19iYXNlLCBpcnEsIGRtYSkKICoKICogICAgSW5pdGlhbGl6ZSB0aGUgTlNDICcxMDggY2hpcAogKgogKi8Kc3RhdGljIGludCBuc2NfaXJjY19pbml0XzEwOChuc2NfY2hpcF90ICpjaGlwLCBjaGlwaW9fdCAqaW5mbykKewoJaW50IGNmZ19iYXNlID0gaW5mby0+Y2ZnX2Jhc2U7CglfX3U4IHRlbXA9MDsKCglvdXRiKDIsIGNmZ19iYXNlKTsgICAgICAvKiBNb2RlIENvbnRyb2wgUmVnaXN0ZXIgKE1DVEwpICovCglvdXRiKDB4MDAsIGNmZ19iYXNlKzEpOyAvKiBEaXNhYmxlIGRldmljZSAqLwoJCgkvKiBCYXNlIEFkZHJlc3MgYW5kIEludGVycnVwdCBDb250cm9sIFJlZ2lzdGVyIChCQUlDKSAqLwoJb3V0YihDRkdfMTA4X0JBSUMsIGNmZ19iYXNlKTsKCXN3aXRjaCAoaW5mby0+ZmlyX2Jhc2UpIHsKCWNhc2UgMHgzZTg6IG91dGIoMHgxNCwgY2ZnX2Jhc2UrMSk7IGJyZWFrOwoJY2FzZSAweDJlODogb3V0YigweDE1LCBjZmdfYmFzZSsxKTsgYnJlYWs7CgljYXNlIDB4M2Y4OiBvdXRiKDB4MTYsIGNmZ19iYXNlKzEpOyBicmVhazsKCWNhc2UgMHgyZjg6IG91dGIoMHgxNywgY2ZnX2Jhc2UrMSk7IGJyZWFrOwoJZGVmYXVsdDogSVJEQV9FUlJPUigiJXMoKSwgaW52YWxpZCBiYXNlX2FkZHJlc3MiLCBfX0ZVTkNUSU9OX18pOwoJfQoJCgkvKiBDb250cm9sIFNpZ25hbCBSb3V0aW5nIFJlZ2lzdGVyIChDU1JUKSAqLwoJc3dpdGNoIChpbmZvLT5pcnEpIHsKCWNhc2UgMzogIHRlbXAgPSAweDAxOyBicmVhazsKCWNhc2UgNDogIHRlbXAgPSAweDAyOyBicmVhazsKCWNhc2UgNTogIHRlbXAgPSAweDAzOyBicmVhazsKCWNhc2UgNzogIHRlbXAgPSAweDA0OyBicmVhazsKCWNhc2UgOTogIHRlbXAgPSAweDA1OyBicmVhazsKCWNhc2UgMTE6IHRlbXAgPSAweDA2OyBicmVhazsKCWNhc2UgMTU6IHRlbXAgPSAweDA3OyBicmVhazsKCWRlZmF1bHQ6IElSREFfRVJST1IoIiVzKCksIGludmFsaWQgaXJxIiwgX19GVU5DVElPTl9fKTsKCX0KCW91dGIoQ0ZHXzEwOF9DU1JULCBjZmdfYmFzZSk7CgkKCXN3aXRjaCAoaW5mby0+ZG1hKSB7CQoJY2FzZSAwOiBvdXRiKDB4MDgrdGVtcCwgY2ZnX2Jhc2UrMSk7IGJyZWFrOwoJY2FzZSAxOiBvdXRiKDB4MTArdGVtcCwgY2ZnX2Jhc2UrMSk7IGJyZWFrOwoJY2FzZSAzOiBvdXRiKDB4MTgrdGVtcCwgY2ZnX2Jhc2UrMSk7IGJyZWFrOwoJZGVmYXVsdDogSVJEQV9FUlJPUigiJXMoKSwgaW52YWxpZCBkbWEiLCBfX0ZVTkNUSU9OX18pOwoJfQoJCglvdXRiKENGR18xMDhfTUNUTCwgY2ZnX2Jhc2UpOyAgICAgIC8qIE1vZGUgQ29udHJvbCBSZWdpc3RlciAoTUNUTCkgKi8KCW91dGIoMHgwMywgY2ZnX2Jhc2UrMSk7IC8qIEVuYWJsZSBkZXZpY2UgKi8KCglyZXR1cm4gMDsKfQoKLyoKICogRnVuY3Rpb24gbnNjX2lyY2NfcHJvYmVfMTA4IChjaGlwLCBpbmZvKQogKgogKiAgICAKICoKICovCnN0YXRpYyBpbnQgbnNjX2lyY2NfcHJvYmVfMTA4KG5zY19jaGlwX3QgKmNoaXAsIGNoaXBpb190ICppbmZvKSAKewoJaW50IGNmZ19iYXNlID0gaW5mby0+Y2ZnX2Jhc2U7CglpbnQgcmVnOwoKCS8qIFJlYWQgYWRkcmVzcyBhbmQgaW50ZXJydXB0IGNvbnRyb2wgcmVnaXN0ZXIgKEJBSUMpICovCglvdXRiKENGR18xMDhfQkFJQywgY2ZnX2Jhc2UpOwoJcmVnID0gaW5iKGNmZ19iYXNlKzEpOwoJCglzd2l0Y2ggKHJlZyAmIDB4MDMpIHsKCWNhc2UgMDoKCQlpbmZvLT5maXJfYmFzZSA9IDB4M2U4OwoJCWJyZWFrOwoJY2FzZSAxOgoJCWluZm8tPmZpcl9iYXNlID0gMHgyZTg7CgkJYnJlYWs7CgljYXNlIDI6CgkJaW5mby0+ZmlyX2Jhc2UgPSAweDNmODsKCQlicmVhazsKCWNhc2UgMzoKCQlpbmZvLT5maXJfYmFzZSA9IDB4MmY4OwoJCWJyZWFrOwoJfQoJaW5mby0+c2lyX2Jhc2UgPSBpbmZvLT5maXJfYmFzZTsKCUlSREFfREVCVUcoMiwgIiVzKCksIHByb2JpbmcgZmlyX2Jhc2U9MHglMDN4XG4iLCBfX0ZVTkNUSU9OX18sCgkJICAgaW5mby0+ZmlyX2Jhc2UpOwoKCS8qIFJlYWQgY29udHJvbCBzaWduYWxzIHJvdXRpbmcgcmVnaXN0ZXIgKENTUlQpICovCglvdXRiKENGR18xMDhfQ1NSVCwgY2ZnX2Jhc2UpOwoJcmVnID0gaW5iKGNmZ19iYXNlKzEpOwoKCXN3aXRjaCAocmVnICYgMHgwNykgewoJY2FzZSAwOgoJCWluZm8tPmlycSA9IC0xOwoJCWJyZWFrOwoJY2FzZSAxOgoJCWluZm8tPmlycSA9IDM7CgkJYnJlYWs7CgljYXNlIDI6CgkJaW5mby0+aXJxID0gNDsKCQlicmVhazsKCWNhc2UgMzoKCQlpbmZvLT5pcnEgPSA1OwoJCWJyZWFrOwoJY2FzZSA0OgoJCWluZm8tPmlycSA9IDc7CgkJYnJlYWs7CgljYXNlIDU6CgkJaW5mby0+aXJxID0gOTsKCQlicmVhazsKCWNhc2UgNjoKCQlpbmZvLT5pcnEgPSAxMTsKCQlicmVhazsKCWNhc2UgNzoKCQlpbmZvLT5pcnEgPSAxNTsKCQlicmVhazsKCX0KCUlSREFfREVCVUcoMiwgIiVzKCksIHByb2JpbmcgaXJxPSVkXG4iLCBfX0ZVTkNUSU9OX18sIGluZm8tPmlycSk7CgoJLyogQ3VycmVudGx5IHdlIG9ubHkgcmVhZCBSeCBETUEgYnV0IGl0IHdpbGwgYWxzbyBiZSB1c2VkIGZvciBUeCAqLwoJc3dpdGNoICgocmVnID4+IDMpICYgMHgwMykgewoJY2FzZSAwOgoJCWluZm8tPmRtYSA9IC0xOwoJCWJyZWFrOwoJY2FzZSAxOgoJCWluZm8tPmRtYSA9IDA7CgkJYnJlYWs7CgljYXNlIDI6CgkJaW5mby0+ZG1hID0gMTsKCQlicmVhazsKCWNhc2UgMzoKCQlpbmZvLT5kbWEgPSAzOwoJCWJyZWFrOwoJfQoJSVJEQV9ERUJVRygyLCAiJXMoKSwgcHJvYmluZyBkbWE9JWRcbiIsIF9fRlVOQ1RJT05fXywgaW5mby0+ZG1hKTsKCgkvKiBSZWFkIG1vZGUgY29udHJvbCByZWdpc3RlciAoTUNUTCkgKi8KCW91dGIoQ0ZHXzEwOF9NQ1RMLCBjZmdfYmFzZSk7CglyZWcgPSBpbmIoY2ZnX2Jhc2UrMSk7CgoJaW5mby0+ZW5hYmxlZCA9IHJlZyAmIDB4MDE7CglpbmZvLT5zdXNwZW5kZWQgPSAhKChyZWcgPj4gMSkgJiAweDAxKTsKCglyZXR1cm4gMDsKfQoKLyoKICogRnVuY3Rpb24gbnNjX2lyY2NfaW5pdF8zMzggKGNoaXAsIGluZm8pCiAqCiAqICAgIEluaXRpYWxpemUgdGhlIE5TQyAnMzM4IGNoaXAuIFJlbWVtYmVyIHRoYXQgdGhlIDg3MzM4IG5lZWRzIHR3byAKICogICAgY29uc2VjdXRpdmUgd3JpdGVzIHRvIHRoZSBkYXRhIHJlZ2lzdGVycyB3aGlsZSBDUFUgaW50ZXJydXB0cyBhcmUKICogICAgZGlzYWJsZWQuIFRoZSA5NzMzOCBkb2VzIG5vdCByZXF1aXJlIHRoaXMsIGJ1dCBzaG91bGRuJ3QgYmUgYW55CiAqICAgIGhhcm0gaWYgd2UgZG8gaXQgYW55d2F5LgogKi8Kc3RhdGljIGludCBuc2NfaXJjY19pbml0XzMzOChuc2NfY2hpcF90ICpjaGlwLCBjaGlwaW9fdCAqaW5mbykgCnsKCS8qIE5vIGluaXQgeWV0ICovCgkKCXJldHVybiAwOwp9CgovKgogKiBGdW5jdGlvbiBuc2NfaXJjY19wcm9iZV8zMzggKGNoaXAsIGluZm8pCiAqCiAqICAgIAogKgogKi8Kc3RhdGljIGludCBuc2NfaXJjY19wcm9iZV8zMzgobnNjX2NoaXBfdCAqY2hpcCwgY2hpcGlvX3QgKmluZm8pIAp7CglpbnQgY2ZnX2Jhc2UgPSBpbmZvLT5jZmdfYmFzZTsKCWludCByZWcsIGNvbSA9IDA7CglpbnQgcG5wOwoKCS8qIFJlYWQgZnVudGlvbiBlbmFibGUgcmVnaXN0ZXIgKEZFUikgKi8KCW91dGIoQ0ZHXzMzOF9GRVIsIGNmZ19iYXNlKTsKCXJlZyA9IGluYihjZmdfYmFzZSsxKTsKCglpbmZvLT5lbmFibGVkID0gKHJlZyA+PiAyKSAmIDB4MDE7CgoJLyogQ2hlY2sgaWYgd2UgYXJlIGluIExlZ2FjeSBvciBQblAgbW9kZSAqLwoJb3V0YihDRkdfMzM4X1BOUDAsIGNmZ19iYXNlKTsKCXJlZyA9IGluYihjZmdfYmFzZSsxKTsKCQoJcG5wID0gKHJlZyA+PiAzKSAmIDB4MDE7CglpZiAocG5wKSB7CgkJSVJEQV9ERUJVRygyLCAiKCksIENoaXAgaXMgaW4gUG5QIG1vZGVcbiIpOwoJCW91dGIoMHg0NiwgY2ZnX2Jhc2UpOwoJCXJlZyA9IChpbmIoY2ZnX2Jhc2UrMSkgJiAweGZlKSA8PCAyOwoKCQlvdXRiKDB4NDcsIGNmZ19iYXNlKTsKCQlyZWcgfD0gKChpbmIoY2ZnX2Jhc2UrMSkgJiAweGZjKSA8PCA4KTsKCgkJaW5mby0+ZmlyX2Jhc2UgPSByZWc7Cgl9IGVsc2UgewoJCS8qIFJlYWQgZnVuY3Rpb24gYWRkcmVzcyByZWdpc3RlciAoRkFSKSAqLwoJCW91dGIoQ0ZHXzMzOF9GQVIsIGNmZ19iYXNlKTsKCQlyZWcgPSBpbmIoY2ZnX2Jhc2UrMSk7CgkJCgkJc3dpdGNoICgocmVnID4+IDQpICYgMHgwMykgewoJCWNhc2UgMDoKCQkJaW5mby0+ZmlyX2Jhc2UgPSAweDNmODsKCQkJYnJlYWs7CgkJY2FzZSAxOgoJCQlpbmZvLT5maXJfYmFzZSA9IDB4MmY4OwoJCQlicmVhazsKCQljYXNlIDI6CgkJCWNvbSA9IDM7CgkJCWJyZWFrOwoJCWNhc2UgMzoKCQkJY29tID0gNDsKCQkJYnJlYWs7CgkJfQoJCQoJCWlmIChjb20pIHsKCQkJc3dpdGNoICgocmVnID4+IDYpICYgMHgwMykgewoJCQljYXNlIDA6CgkJCQlpZiAoY29tID09IDMpCgkJCQkJaW5mby0+ZmlyX2Jhc2UgPSAweDNlODsKCQkJCWVsc2UKCQkJCQlpbmZvLT5maXJfYmFzZSA9IDB4MmU4OwoJCQkJYnJlYWs7CgkJCWNhc2UgMToKCQkJCWlmIChjb20gPT0gMykKCQkJCQlpbmZvLT5maXJfYmFzZSA9IDB4MzM4OwoJCQkJZWxzZQoJCQkJCWluZm8tPmZpcl9iYXNlID0gMHgyMzg7CgkJCQlicmVhazsKCQkJY2FzZSAyOgoJCQkJaWYgKGNvbSA9PSAzKQoJCQkJCWluZm8tPmZpcl9iYXNlID0gMHgyZTg7CgkJCQllbHNlCgkJCQkJaW5mby0+ZmlyX2Jhc2UgPSAweDJlMDsKCQkJCWJyZWFrOwoJCQljYXNlIDM6CgkJCQlpZiAoY29tID09IDMpCgkJCQkJaW5mby0+ZmlyX2Jhc2UgPSAweDIyMDsKCQkJCWVsc2UKCQkJCQlpbmZvLT5maXJfYmFzZSA9IDB4MjI4OwoJCQkJYnJlYWs7CgkJCX0KCQl9Cgl9CglpbmZvLT5zaXJfYmFzZSA9IGluZm8tPmZpcl9iYXNlOwoKCS8qIFJlYWQgUG5QIHJlZ2lzdGVyIDEgKFBOUDEpICovCglvdXRiKENGR18zMzhfUE5QMSwgY2ZnX2Jhc2UpOwoJcmVnID0gaW5iKGNmZ19iYXNlKzEpOwoJCglpbmZvLT5pcnEgPSByZWcgPj4gNDsKCQoJLyogUmVhZCBQblAgcmVnaXN0ZXIgMyAoUE5QMykgKi8KCW91dGIoQ0ZHXzMzOF9QTlAzLCBjZmdfYmFzZSk7CglyZWcgPSBpbmIoY2ZnX2Jhc2UrMSk7CgoJaW5mby0+ZG1hID0gKHJlZyAmIDB4MDcpIC0gMTsKCgkvKiBSZWFkIHBvd2VyIGFuZCB0ZXN0IHJlZ2lzdGVyIChQVFIpICovCglvdXRiKENGR18zMzhfUFRSLCBjZmdfYmFzZSk7CglyZWcgPSBpbmIoY2ZnX2Jhc2UrMSk7CgoJaW5mby0+c3VzcGVuZGVkID0gcmVnICYgMHgwMTsKCglyZXR1cm4gMDsKfQoKCi8qCiAqIEZ1bmN0aW9uIG5zY19pcmNjX2luaXRfMzl4IChjaGlwLCBpbmZvKQogKgogKiAgICBOb3cgdGhhdCB3ZSBrbm93IGl0J3MgYSAnMzl4IChzZWUgcHJvYmUgYmVsb3cpLCB3ZSBuZWVkIHRvCiAqICAgIGNvbmZpZ3VyZSBpdCBzbyB3ZSBjYW4gdXNlIGl0LgogKgogKiBUaGUgTlNDICczMzggY2hpcCBpcyBhIFN1cGVyIEkvTyBjaGlwIHdpdGggYSAiYmFuayIgYXJjaGl0ZWN0dXJlLAogKiB0aGUgY29uZmlndXJhdGlvbiBvZiB0aGUgZGlmZmVyZW50IGZ1bmN0aW9uYWxpdHkgKHNlcmlhbCwgcGFyYWxsZWwsCiAqIGZsb3BweS4uLikgYXJlIGVhY2ggaW4gYSBkaWZmZXJlbnQgYmFuayAoTG9naWNhbCBEZXZpY2UgTnVtYmVyKS4KICogVGhlIGJhc2UgYWRkcmVzcywgaXJxIGFuZCBkbWEgY29uZmlndXJhdGlvbiByZWdpc3RlcnMgYXJlIGNvbW1vbgogKiB0byBhbGwgZnVuY3Rpb25hbGl0aWVzIChpbmRleCAweDMwIHRvIDB4N0YpLgogKiBUaGVyZSBpcyBvbmx5IG9uZSBjb25maWd1cmF0aW9uIHJlZ2lzdGVyIHNwZWNpZmljIHRvIHRoZQogKiBzZXJpYWwgcG9ydCwgQ0ZHXzM5WF9TUEMuCiAqIEplYW5JSQogKgogKiBOb3RlIDogdGhpcyBjb2RlIHdhcyB3cml0dGVuIGJ5IEphbiBGcmV5IDxqYW5mcmV5QHdlYi5kZT4KICovCnN0YXRpYyBpbnQgbnNjX2lyY2NfaW5pdF8zOXgobnNjX2NoaXBfdCAqY2hpcCwgY2hpcGlvX3QgKmluZm8pIAp7CglpbnQgY2ZnX2Jhc2UgPSBpbmZvLT5jZmdfYmFzZTsKCWludCBlbmFibGVkOwoKCS8qIFVzZXIgaXMgc2h1cmUgYWJvdXQgaGlzIGNvbmZpZy4uLiBhY2NlcHQgaXQuICovCglJUkRBX0RFQlVHKDIsICIlcygpOiBuc2NfaXJjY19pbml0XzM5eCAodXNlciBzZXR0aW5ncyk6ICIKCQkgICAiaW89MHglMDR4LCBpcnE9JWQsIGRtYT0lZFxuIiwgCgkJICAgX19GVU5DVElPTl9fLCBpbmZvLT5maXJfYmFzZSwgaW5mby0+aXJxLCBpbmZvLT5kbWEpOwoKCS8qIEFjY2VzcyBiYW5rIGZvciBTUDIgKi8KCW91dGIoQ0ZHXzM5WF9MRE4sIGNmZ19iYXNlKTsKCW91dGIoMHgwMiwgY2ZnX2Jhc2UrMSk7CgoJLyogQ29uZmlndXJlIFNQMiAqLwoKCS8qIFdlIHdhbnQgdG8gZW5hYmxlIHRoZSBkZXZpY2UgaWYgbm90IGVuYWJsZWQgKi8KCW91dGIoQ0ZHXzM5WF9BQ1QsIGNmZ19iYXNlKTsKCWVuYWJsZWQgPSBpbmIoY2ZnX2Jhc2UrMSkgJiAweDAxOwoJCglpZiAoIWVuYWJsZWQpIHsKCQkvKiBFbmFibGUgdGhlIGRldmljZSAqLwoJCW91dGIoQ0ZHXzM5WF9TSU9DRjEsIGNmZ19iYXNlKTsKCQlvdXRiKDB4MDEsIGNmZ19iYXNlKzEpOwoJCS8qIE1heSB3YW50IHRvIHVwZGF0ZSBpbmZvLT5lbmFibGVkLiBKZWFuIElJICovCgl9CgoJLyogRW5hYmxlIFVBUlQgYmFuayBzd2l0Y2hpbmcgKGJpdCA3KSA7IFNldHMgdGhlIGNoaXAgdG8gbm9ybWFsCgkgKiBwb3dlciBtb2RlICh3YWtlIHVwIGZyb20gc2xlZXAgbW9kZSkgKGJpdCAxKSAqLwoJb3V0YihDRkdfMzlYX1NQQywgY2ZnX2Jhc2UpOwoJb3V0YigweDgyLCBjZmdfYmFzZSsxKTsKCglyZXR1cm4gMDsKfQoKLyoKICogRnVuY3Rpb24gbnNjX2lyY2NfcHJvYmVfMzl4IChjaGlwLCBpbmZvKQogKgogKiAgICBUZXN0IGlmIHdlIHJlYWxseSBoYXZlIGEgJzM5eCBjaGlwIGF0IHRoZSBnaXZlbiBhZGRyZXNzCiAqCiAqIE5vdGUgOiB0aGlzIGNvZGUgd2FzIHdyaXR0ZW4gYnkgSmFuIEZyZXkgPGphbmZyZXlAd2ViLmRlPgogKi8Kc3RhdGljIGludCBuc2NfaXJjY19wcm9iZV8zOXgobnNjX2NoaXBfdCAqY2hpcCwgY2hpcGlvX3QgKmluZm8pIAp7CglpbnQgY2ZnX2Jhc2UgPSBpbmZvLT5jZmdfYmFzZTsKCWludCByZWcxLCByZWcyLCBpcnEsIGlycXQsIGRtYTEsIGRtYTI7CglpbnQgZW5hYmxlZCwgc3VzcDsKCglJUkRBX0RFQlVHKDIsICIlcygpLCBuc2NfaXJjY19wcm9iZV8zOXgsIGJhc2U9JWRcbiIsCgkJICAgX19GVU5DVElPTl9fLCBjZmdfYmFzZSk7CgoJLyogVGhpcyBmdW5jdGlvbiBzaG91bGQgYmUgZXhlY3V0ZWQgd2l0aCBpcnEgb2ZmIHRvIGF2b2lkCgkgKiBhbm90aGVyIGRyaXZlciBtZXNzaW5nIHdpdGggdGhlIFN1cGVyIEkvTyBiYW5rIC0gSmVhbiBJSSAqLwoKCS8qIEFjY2VzcyBiYW5rIGZvciBTUDIgKi8KCW91dGIoQ0ZHXzM5WF9MRE4sIGNmZ19iYXNlKTsKCW91dGIoMHgwMiwgY2ZnX2Jhc2UrMSk7CgoJLyogUmVhZCBpbmZvcyBhYm91dCBTUDIgOyBzdG9yZSBpbiBpbmZvIHN0cnVjdCAqLwoJb3V0YihDRkdfMzlYX0JBU0VILCBjZmdfYmFzZSk7CglyZWcxID0gaW5iKGNmZ19iYXNlKzEpOwoJb3V0YihDRkdfMzlYX0JBU0VMLCBjZmdfYmFzZSk7CglyZWcyID0gaW5iKGNmZ19iYXNlKzEpOwoJaW5mby0+ZmlyX2Jhc2UgPSAocmVnMSA8PCA4KSB8IHJlZzI7CgoJb3V0YihDRkdfMzlYX0lSUU5VTSwgY2ZnX2Jhc2UpOwoJaXJxID0gaW5iKGNmZ19iYXNlKzEpOwoJb3V0YihDRkdfMzlYX0lSUVNFTCwgY2ZnX2Jhc2UpOwoJaXJxdCA9IGluYihjZmdfYmFzZSsxKTsKCWluZm8tPmlycSA9IGlycTsKCglvdXRiKENGR18zOVhfRE1BMCwgY2ZnX2Jhc2UpOwoJZG1hMSA9IGluYihjZmdfYmFzZSsxKTsKCW91dGIoQ0ZHXzM5WF9ETUExLCBjZmdfYmFzZSk7CglkbWEyID0gaW5iKGNmZ19iYXNlKzEpOwoJaW5mby0+ZG1hID0gZG1hMSAtMTsKCglvdXRiKENGR18zOVhfQUNULCBjZmdfYmFzZSk7CglpbmZvLT5lbmFibGVkID0gZW5hYmxlZCA9IGluYihjZmdfYmFzZSsxKSAmIDB4MDE7CgkKCW91dGIoQ0ZHXzM5WF9TUEMsIGNmZ19iYXNlKTsKCXN1c3AgPSAxIC0gKChpbmIoY2ZnX2Jhc2UrMSkgJiAweDAyKSA+PiAxKTsKCglJUkRBX0RFQlVHKDIsICIlcygpOiBpbz0weCUwMnglMDJ4LCBpcnE9JWQgKHR5cGUgJWQpLCByeGRtYT0lZCwgdHhkbWE9JWQsIGVuYWJsZWQ9JWQgKHN1c3BlbmRlZD0lZClcbiIsIF9fRlVOQ1RJT05fXywgcmVnMSxyZWcyLGlycSxpcnF0LGRtYTEsZG1hMixlbmFibGVkLHN1c3ApOwoKCS8qIENvbmZpZ3VyZSBTUDIgKi8KCgkvKiBXZSB3YW50IHRvIGVuYWJsZSB0aGUgZGV2aWNlIGlmIG5vdCBlbmFibGVkICovCglvdXRiKENGR18zOVhfQUNULCBjZmdfYmFzZSk7CgllbmFibGVkID0gaW5iKGNmZ19iYXNlKzEpICYgMHgwMTsKCQoJaWYgKCFlbmFibGVkKSB7CgkJLyogRW5hYmxlIHRoZSBkZXZpY2UgKi8KCQlvdXRiKENGR18zOVhfU0lPQ0YxLCBjZmdfYmFzZSk7CgkJb3V0YigweDAxLCBjZmdfYmFzZSsxKTsKCQkvKiBNYXkgd2FudCB0byB1cGRhdGUgaW5mby0+ZW5hYmxlZC4gSmVhbiBJSSAqLwoJfQoKCS8qIEVuYWJsZSBVQVJUIGJhbmsgc3dpdGNoaW5nIChiaXQgNykgOyBTZXRzIHRoZSBjaGlwIHRvIG5vcm1hbAoJICogcG93ZXIgbW9kZSAod2FrZSB1cCBmcm9tIHNsZWVwIG1vZGUpIChiaXQgMSkgKi8KCW91dGIoQ0ZHXzM5WF9TUEMsIGNmZ19iYXNlKTsKCW91dGIoMHg4MiwgY2ZnX2Jhc2UrMSk7CgoJcmV0dXJuIDA7Cn0KCi8qCiAqIEZ1bmN0aW9uIG5zY19pcmNjX3NldHVwIChpbmZvKQogKgogKiAgICBSZXR1cm5zIG5vbi1uZWdhdGl2ZSBvbiBzdWNjZXNzLgogKgogKi8Kc3RhdGljIGludCBuc2NfaXJjY19zZXR1cChjaGlwaW9fdCAqaW5mbykKewoJaW50IHZlcnNpb247CglpbnQgaW9iYXNlID0gaW5mby0+ZmlyX2Jhc2U7CgoJLyogUmVhZCB0aGUgTW9kdWxlIElEICovCglzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTkszKTsKCXZlcnNpb24gPSBpbmIoaW9iYXNlK01JRCk7CgoJSVJEQV9ERUJVRygyLCAiJXMoKSBEcml2ZXIgJXMgRm91bmQgY2hpcCB2ZXJzaW9uICUwMnhcbiIsCgkJICAgX19GVU5DVElPTl9fLCBkcml2ZXJfbmFtZSwgdmVyc2lvbik7CgoJLyogU2hvdWxkIGJlIDB4Mj8gKi8KCWlmICgweDIwICE9ICh2ZXJzaW9uICYgMHhmMCkpIHsKCQlJUkRBX0VSUk9SKCIlcywgV3JvbmcgY2hpcCB2ZXJzaW9uICUwMnhcbiIsCgkJCSAgIGRyaXZlcl9uYW1lLCB2ZXJzaW9uKTsKCQlyZXR1cm4gLTE7Cgl9CgoJLyogU3dpdGNoIHRvIGFkdmFuY2VkIG1vZGUgKi8KCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzIpOwoJb3V0YihFQ1IxX0VYVF9TTCwgaW9iYXNlK0VDUjEpOwoJc3dpdGNoX2JhbmsoaW9iYXNlLCBCQU5LMCk7CgkKCS8qIFNldCBGSUZPIHRocmVzaG9sZCB0byBUWDE3LCBSWDE2LCByZXNldCBhbmQgZW5hYmxlIEZJRk8ncyAqLwoJc3dpdGNoX2JhbmsoaW9iYXNlLCBCQU5LMCk7CglvdXRiKEZDUl9SWFRIfEZDUl9UWFRIfEZDUl9UWFNSfEZDUl9SWFNSfEZDUl9GSUZPX0VOLCBpb2Jhc2UrRkNSKTsKCglvdXRiKDB4MDMsIGlvYmFzZStMQ1IpOyAJLyogOCBiaXQgd29yZCBsZW5ndGggKi8KCW91dGIoTUNSX1NJUiwgaW9iYXNlK01DUik7IAkvKiBTdGFydCBhdCBTSVItbW9kZSwgYWxzbyBjbGVhcnMgTFNSKi8KCgkvKiBTZXQgRklGTyBzaXplIHRvIDMyICovCglzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTksyKTsKCW91dGIoRVhDUjJfUkZTSVp8RVhDUjJfVEZTSVosIGlvYmFzZStFWENSMik7CgoJLyogSVJDUjI6IEZFTkRfTUQgaXMgbm90IHNldCAqLwoJc3dpdGNoX2JhbmsoaW9iYXNlLCBCQU5LNSk7CiAJb3V0YigweDAyLCBpb2Jhc2UrNCk7CgoJLyogTWFrZSBzdXJlIHRoYXQgc29tZSBkZWZhdWx0cyBhcmUgT0sgKi8KCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzYpOwoJb3V0YigweDIwLCBpb2Jhc2UrMCk7IC8qIFNldCAzMiBiaXRzIEZJUiBDUkMgKi8KCW91dGIoMHgwYSwgaW9iYXNlKzEpOyAvKiBTZXQgTUlSIHB1bHNlIHdpZHRoICovCglvdXRiKDB4MGQsIGlvYmFzZSsyKTsgLyogU2V0IFNJUiBwdWxzZSB3aWR0aCB0byAxLjZ1cyAqLwoJb3V0YigweDJhLCBpb2Jhc2UrNCk7IC8qIFNldCBiZWdpbm5pbmcgZnJhZywgYW5kIHByZWFtYmxlIGxlbmd0aCAqLwoKCS8qIEVuYWJsZSByZWNlaXZlIGludGVycnVwdHMgKi8KCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzApOwoJb3V0YihJRVJfUlhIRExfSUUsIGlvYmFzZStJRVIpOwoKCXJldHVybiAwOwp9CgovKgogKiBGdW5jdGlvbiBuc2NfaXJjY19yZWFkX2RvbmdsZV9pZCAodm9pZCkKICoKICogVHJ5IHRvIHJlYWQgZG9uZ2xlIGluZGVudGlmaWNhdGlvbi4gVGhpcyBwcm9jZWR1cmUgbmVlZHMgdG8gYmUgZXhlY3V0ZWQKICogb25jZSBhZnRlciBwb3dlci1vbi9yZXNldC4gSXQgYWxzbyBuZWVkcyB0byBiZSB1c2VkIHdoZW5ldmVyIHlvdSBzdXNwZWN0CiAqIHRoYXQgdGhlIHVzZXIgbWF5IGhhdmUgcGx1Z2dlZC91bnBsdWdnZWQgdGhlIElyREEgRG9uZ2xlLgogKi8Kc3RhdGljIGludCBuc2NfaXJjY19yZWFkX2RvbmdsZV9pZCAoaW50IGlvYmFzZSkKewoJaW50IGRvbmdsZV9pZDsKCV9fdTggYmFuazsKCgliYW5rID0gaW5iKGlvYmFzZStCU1IpOwoKCS8qIFNlbGVjdCBCYW5rIDcgKi8KCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzcpOwoJCgkvKiBJUkNGRzQ6IElSU0wwX0RTIGFuZCBJUlNMMjFfRFMgYXJlIGNsZWFyZWQgKi8KCW91dGIoMHgwMCwgaW9iYXNlKzcpOwoJCgkvKiBJRDAsIDEsIGFuZCAyIGFyZSBwdWxsZWQgdXAvZG93biB2ZXJ5IHNsb3dseSAqLwoJdWRlbGF5KDUwKTsKCQoJLyogSVJDRkcxOiByZWFkIHRoZSBJRCBiaXRzICovCglkb25nbGVfaWQgPSBpbmIoaW9iYXNlKzQpICYgMHgwZjsKCiNpZmRlZiBCUk9LRU5fRE9OR0xFX0lECglpZiAoZG9uZ2xlX2lkID09IDB4MGEpCgkJZG9uZ2xlX2lkID0gMHgwOTsKI2VuZGlmCQoJLyogR28gYmFjayB0byAgYmFuayAwIGJlZm9yZSByZXR1cm5pbmcgKi8KCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzApOwoKCW91dGIoYmFuaywgaW9iYXNlK0JTUik7CgoJcmV0dXJuIGRvbmdsZV9pZDsKfQoKLyoKICogRnVuY3Rpb24gbnNjX2lyY2NfaW5pdF9kb25nbGVfaW50ZXJmYWNlIChpb2Jhc2UsIGRvbmdsZV9pZCkKICoKICogICAgIFRoaXMgZnVuY3Rpb24gaW5pdGlhbGl6ZXMgdGhlIGRvbmdsZSBmb3IgdGhlIHRyYW5zY2VpdmVyIHRoYXQgaXMKICogICAgIHVzZWQuIFRoaXMgcHJvY2VkdXJlIG5lZWRzIHRvIGJlIGV4ZWN1dGVkIG9uY2UgYWZ0ZXIKICogICAgIHBvd2VyLW9uL3Jlc2V0LiBJdCBhbHNvIG5lZWRzIHRvIGJlIHVzZWQgd2hlbmV2ZXIgeW91IHN1c3BlY3QgdGhhdAogKiAgICAgdGhlIGRvbmdsZSBpcyBjaGFuZ2VkLiAKICovCnN0YXRpYyB2b2lkIG5zY19pcmNjX2luaXRfZG9uZ2xlX2ludGVyZmFjZSAoaW50IGlvYmFzZSwgaW50IGRvbmdsZV9pZCkKewoJaW50IGJhbms7CgoJLyogU2F2ZSBjdXJyZW50IGJhbmsgKi8KCWJhbmsgPSBpbmIoaW9iYXNlK0JTUik7CgoJLyogU2VsZWN0IEJhbmsgNyAqLwoJc3dpdGNoX2JhbmsoaW9iYXNlLCBCQU5LNyk7CgkKCS8qIElSQ0ZHNDogc2V0IGFjY29yZGluZyB0byBkb25nbGVfaWQgKi8KCXN3aXRjaCAoZG9uZ2xlX2lkKSB7CgljYXNlIDB4MDA6IC8qIHNhbWUgYXMgKi8KCWNhc2UgMHgwMTogLyogRGlmZmVyZW50aWFsIHNlcmlhbCBpbnRlcmZhY2UgKi8KCQlJUkRBX0RFQlVHKDAsICIlcygpLCAlcyBub3QgZGVmaW5lZCBieSBpcmRhIHlldFxuIiwKCQkJICAgX19GVU5DVElPTl9fLCBkb25nbGVfdHlwZXNbZG9uZ2xlX2lkXSk7IAoJCWJyZWFrOwoJY2FzZSAweDAyOiAvKiBzYW1lIGFzICovCgljYXNlIDB4MDM6IC8qIFJlc2VydmVkICovCgkJSVJEQV9ERUJVRygwLCAiJXMoKSwgJXMgbm90IGRlZmluZWQgYnkgaXJkYSB5ZXRcbiIsCgkJCSAgIF9fRlVOQ1RJT05fXywgZG9uZ2xlX3R5cGVzW2RvbmdsZV9pZF0pOyAKCQlicmVhazsKCWNhc2UgMHgwNDogLyogU2hhcnAgUlk1SEQwMSAqLwoJCWJyZWFrOwoJY2FzZSAweDA1OiAvKiBSZXNlcnZlZCwgYnV0IHRoaXMgaXMgd2hhdCB0aGUgVGhpbmtwYWQgcmVwb3J0cyAqLwoJCUlSREFfREVCVUcoMCwgIiVzKCksICVzIG5vdCBkZWZpbmVkIGJ5IGlyZGEgeWV0XG4iLAoJCQkgICBfX0ZVTkNUSU9OX18sIGRvbmdsZV90eXBlc1tkb25nbGVfaWRdKTsgCgkJYnJlYWs7CgljYXNlIDB4MDY6IC8qIFNpbmdsZS1lbmRlZCBzZXJpYWwgaW50ZXJmYWNlICovCgkJSVJEQV9ERUJVRygwLCAiJXMoKSwgJXMgbm90IGRlZmluZWQgYnkgaXJkYSB5ZXRcbiIsCgkJCSAgIF9fRlVOQ1RJT05fXywgZG9uZ2xlX3R5cGVzW2RvbmdsZV9pZF0pOyAKCQlicmVhazsKCWNhc2UgMHgwNzogLyogQ29uc3VtZXItSVIgb25seSAqLwoJCUlSREFfREVCVUcoMCwgIiVzKCksICVzIGlzIG5vdCBmb3IgSXJEQSBtb2RlXG4iLAoJCQkgICBfX0ZVTkNUSU9OX18sIGRvbmdsZV90eXBlc1tkb25nbGVfaWRdKTsgCgkJYnJlYWs7CgljYXNlIDB4MDg6IC8qIEhQIEhTREwtMjMwMCwgSFAgSFNETC0zNjAwL0hTREwtMzYxMCAqLwoJCUlSREFfREVCVUcoMCwgIiVzKCksICVzXG4iLAoJCQkgICBfX0ZVTkNUSU9OX18sIGRvbmdsZV90eXBlc1tkb25nbGVfaWRdKTsKCQlicmVhazsKCWNhc2UgMHgwOTogLyogSUJNMzFUMTEwMCBvciBUZW1pYyBURkRTNjAwMC9URkRTNjUwMCAqLwoJCW91dGIoMHgyOCwgaW9iYXNlKzcpOyAvKiBTZXQgaXJzbFswLTJdIGFzIG91dHB1dCAqLwoJCWJyZWFrOwoJY2FzZSAweDBBOiAvKiBzYW1lIGFzICovCgljYXNlIDB4MEI6IC8qIFJlc2VydmVkICovCgkJSVJEQV9ERUJVRygwLCAiJXMoKSwgJXMgbm90IGRlZmluZWQgYnkgaXJkYSB5ZXRcbiIsCgkJCSAgIF9fRlVOQ1RJT05fXywgZG9uZ2xlX3R5cGVzW2RvbmdsZV9pZF0pOyAKCQlicmVhazsKCWNhc2UgMHgwQzogLyogc2FtZSBhcyAqLwoJY2FzZSAweDBEOiAvKiBIUCBIU0RMLTExMDAvSFNETC0yMTAwICovCgkJLyogCgkJICogU2V0IGlyc2wwIGFzIGlucHV0LCBpcnNsWzEtMl0gYXMgb3V0cHV0LCBhbmQgc2VwYXJhdGUgCgkJICogaW5wdXRzIGFyZSB1c2VkIGZvciBTSVIgYW5kIE1JUi9GSVIgCgkJICovCgkJb3V0YigweDQ4LCBpb2Jhc2UrNyk7IAoJCWJyZWFrOwoJY2FzZSAweDBFOiAvKiBTdXBwb3J0cyBTSVIgTW9kZSBvbmx5ICovCgkJb3V0YigweDI4LCBpb2Jhc2UrNyk7IC8qIFNldCBpcnNsWzAtMl0gYXMgb3V0cHV0ICovCgkJYnJlYWs7CgljYXNlIDB4MEY6IC8qIE5vIGRvbmdsZSBjb25uZWN0ZWQgKi8KCQlJUkRBX0RFQlVHKDAsICIlcygpLCAlc1xuIiwKCQkJICAgX19GVU5DVElPTl9fLCBkb25nbGVfdHlwZXNbZG9uZ2xlX2lkXSk7IAoKCQlzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTkswKTsKCQlvdXRiKDB4NjIsIGlvYmFzZStNQ1IpOwoJCWJyZWFrOwoJZGVmYXVsdDogCgkJSVJEQV9ERUJVRygwLCAiJXMoKSwgaW52YWxpZCBkb25nbGVfaWQgJSN4IiwgCgkJCSAgIF9fRlVOQ1RJT05fXywgZG9uZ2xlX2lkKTsKCX0KCQoJLyogSVJDRkcxOiBJUlNMMSBhbmQgMiBhcmUgc2V0IHRvIElyREEgbW9kZSAqLwoJb3V0YigweDAwLCBpb2Jhc2UrNCk7CgoJLyogUmVzdG9yZSBiYW5rIHJlZ2lzdGVyICovCglvdXRiKGJhbmssIGlvYmFzZStCU1IpOwoJCn0gLyogc2V0X3VwX2RvbmdsZV9pbnRlcmZhY2UgKi8KCi8qCiAqIEZ1bmN0aW9uIG5zY19pcmNjX2NoYW5nZV9kb25nbGVfc3BlZWQgKGlvYmFzZSwgc3BlZWQsIGRvbmdsZV9pZCkKICoKICogICAgQ2hhbmdlIHNwZWVkIG9mIHRoZSBhdHRhY2ggZG9uZ2xlCiAqCiAqLwpzdGF0aWMgdm9pZCBuc2NfaXJjY19jaGFuZ2VfZG9uZ2xlX3NwZWVkKGludCBpb2Jhc2UsIGludCBzcGVlZCwgaW50IGRvbmdsZV9pZCkKewoJX191OCBiYW5rOwoKCS8qIFNhdmUgY3VycmVudCBiYW5rICovCgliYW5rID0gaW5iKGlvYmFzZStCU1IpOwoKCS8qIFNlbGVjdCBCYW5rIDcgKi8KCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzcpOwoJCgkvKiBJUkNGRzE6IHNldCBhY2NvcmRpbmcgdG8gZG9uZ2xlX2lkICovCglzd2l0Y2ggKGRvbmdsZV9pZCkgewoJY2FzZSAweDAwOiAvKiBzYW1lIGFzICovCgljYXNlIDB4MDE6IC8qIERpZmZlcmVudGlhbCBzZXJpYWwgaW50ZXJmYWNlICovCgkJSVJEQV9ERUJVRygwLCAiJXMoKSwgJXMgbm90IGRlZmluZWQgYnkgaXJkYSB5ZXRcbiIsCgkJCSAgIF9fRlVOQ1RJT05fXywgZG9uZ2xlX3R5cGVzW2RvbmdsZV9pZF0pOyAKCQlicmVhazsKCWNhc2UgMHgwMjogLyogc2FtZSBhcyAqLwoJY2FzZSAweDAzOiAvKiBSZXNlcnZlZCAqLwoJCUlSREFfREVCVUcoMCwgIiVzKCksICVzIG5vdCBkZWZpbmVkIGJ5IGlyZGEgeWV0XG4iLAoJCQkgICBfX0ZVTkNUSU9OX18sIGRvbmdsZV90eXBlc1tkb25nbGVfaWRdKTsgCgkJYnJlYWs7CgljYXNlIDB4MDQ6IC8qIFNoYXJwIFJZNUhEMDEgKi8KCQlicmVhazsKCWNhc2UgMHgwNTogLyogUmVzZXJ2ZWQgKi8KCQlJUkRBX0RFQlVHKDAsICIlcygpLCAlcyBub3QgZGVmaW5lZCBieSBpcmRhIHlldFxuIiwKCQkJICAgX19GVU5DVElPTl9fLCBkb25nbGVfdHlwZXNbZG9uZ2xlX2lkXSk7IAoJCWJyZWFrOwoJY2FzZSAweDA2OiAvKiBTaW5nbGUtZW5kZWQgc2VyaWFsIGludGVyZmFjZSAqLwoJCUlSREFfREVCVUcoMCwgIiVzKCksICVzIG5vdCBkZWZpbmVkIGJ5IGlyZGEgeWV0XG4iLAoJCQkgICBfX0ZVTkNUSU9OX18sIGRvbmdsZV90eXBlc1tkb25nbGVfaWRdKTsgCgkJYnJlYWs7CgljYXNlIDB4MDc6IC8qIENvbnN1bWVyLUlSIG9ubHkgKi8KCQlJUkRBX0RFQlVHKDAsICIlcygpLCAlcyBpcyBub3QgZm9yIElyREEgbW9kZVxuIiwKCQkJICAgX19GVU5DVElPTl9fLCBkb25nbGVfdHlwZXNbZG9uZ2xlX2lkXSk7IAoJCWJyZWFrOwoJY2FzZSAweDA4OiAvKiBIUCBIU0RMLTIzMDAsIEhQIEhTREwtMzYwMC9IU0RMLTM2MTAgKi8KCQlJUkRBX0RFQlVHKDAsICIlcygpLCAlc1xuIiwgCgkJCSAgIF9fRlVOQ1RJT05fXywgZG9uZ2xlX3R5cGVzW2RvbmdsZV9pZF0pOyAKCQlvdXRiKDB4MDAsIGlvYmFzZSs0KTsKCQlpZiAoc3BlZWQgPiAxMTUyMDApCgkJCW91dGIoMHgwMSwgaW9iYXNlKzQpOwoJCWJyZWFrOwoJY2FzZSAweDA5OiAvKiBJQk0zMVQxMTAwIG9yIFRlbWljIFRGRFM2MDAwL1RGRFM2NTAwICovCgkJb3V0YigweDAxLCBpb2Jhc2UrNCk7CgoJCWlmIChzcGVlZCA9PSA0MDAwMDAwKSB7CgkJCS8qIFRoZXJlIHdhcyBhIGNsaSgpIHRoZXJlLCBidXQgd2Ugbm93IGFyZSBhbHJlYWR5CgkJCSAqIHVuZGVyIHNwaW5fbG9ja19pcnFzYXZlKCkgLSBKZWFuSUkgKi8KCQkJb3V0YigweDgxLCBpb2Jhc2UrNCk7CgkJCW91dGIoMHg4MCwgaW9iYXNlKzQpOwoJCX0gZWxzZQoJCQlvdXRiKDB4MDAsIGlvYmFzZSs0KTsKCQlicmVhazsKCWNhc2UgMHgwQTogLyogc2FtZSBhcyAqLwoJY2FzZSAweDBCOiAvKiBSZXNlcnZlZCAqLwoJCUlSREFfREVCVUcoMCwgIiVzKCksICVzIG5vdCBkZWZpbmVkIGJ5IGlyZGEgeWV0XG4iLAoJCQkgICBfX0ZVTkNUSU9OX18sIGRvbmdsZV90eXBlc1tkb25nbGVfaWRdKTsgCgkJYnJlYWs7CgljYXNlIDB4MEM6IC8qIHNhbWUgYXMgKi8KCWNhc2UgMHgwRDogLyogSFAgSFNETC0xMTAwL0hTREwtMjEwMCAqLwoJCWJyZWFrOwoJY2FzZSAweDBFOiAvKiBTdXBwb3J0cyBTSVIgTW9kZSBvbmx5ICovCgkJYnJlYWs7CgljYXNlIDB4MEY6IC8qIE5vIGRvbmdsZSBjb25uZWN0ZWQgKi8KCQlJUkRBX0RFQlVHKDAsICIlcygpLCAlcyBpcyBub3QgZm9yIElyREEgbW9kZVxuIiwKCQkJICAgX19GVU5DVElPTl9fLCBkb25nbGVfdHlwZXNbZG9uZ2xlX2lkXSk7CgoJCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzApOyAKCQlvdXRiKDB4NjIsIGlvYmFzZStNQ1IpOwoJCWJyZWFrOwoJZGVmYXVsdDogCgkJSVJEQV9ERUJVRygwLCAiJXMoKSwgaW52YWxpZCBkYXRhX3JhdGVcbiIsIF9fRlVOQ1RJT05fXyk7Cgl9CgkvKiBSZXN0b3JlIGJhbmsgcmVnaXN0ZXIgKi8KCW91dGIoYmFuaywgaW9iYXNlK0JTUik7Cn0KCi8qCiAqIEZ1bmN0aW9uIG5zY19pcmNjX2NoYW5nZV9zcGVlZCAoc2VsZiwgYmF1ZCkKICoKICogICAgQ2hhbmdlIHRoZSBzcGVlZCBvZiB0aGUgZGV2aWNlCiAqCiAqIFRoaXMgZnVuY3Rpb24gKm11c3QqIGJlIGNhbGxlZCB3aXRoIGlycSBvZmYgYW5kIHNwaW4tbG9jay4KICovCnN0YXRpYyBfX3U4IG5zY19pcmNjX2NoYW5nZV9zcGVlZChzdHJ1Y3QgbnNjX2lyY2NfY2IgKnNlbGYsIF9fdTMyIHNwZWVkKQp7CglzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gc2VsZi0+bmV0ZGV2OwoJX191OCBtY3IgPSBNQ1JfU0lSOwoJaW50IGlvYmFzZTsgCglfX3U4IGJhbms7CglfX3U4IGllcjsgICAgICAgICAgICAgICAgICAvKiBJbnRlcnJ1cHQgZW5hYmxlIHJlZ2lzdGVyICovCgoJSVJEQV9ERUJVRygyLCAiJXMoKSwgc3BlZWQ9JWRcbiIsIF9fRlVOQ1RJT05fXywgc3BlZWQpOwoKCUlSREFfQVNTRVJUKHNlbGYgIT0gTlVMTCwgcmV0dXJuIDA7KTsKCglpb2Jhc2UgPSBzZWxmLT5pby5maXJfYmFzZTsKCgkvKiBVcGRhdGUgYWNjb3VudGluZyBmb3IgbmV3IHNwZWVkICovCglzZWxmLT5pby5zcGVlZCA9IHNwZWVkOwoKCS8qIFNhdmUgY3VycmVudCBiYW5rICovCgliYW5rID0gaW5iKGlvYmFzZStCU1IpOwoKCS8qIERpc2FibGUgaW50ZXJydXB0cyAqLwoJc3dpdGNoX2JhbmsoaW9iYXNlLCBCQU5LMCk7CglvdXRiKDAsIGlvYmFzZStJRVIpOwoKCS8qIFNlbGVjdCBCYW5rIDIgKi8KCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzIpOwoKCW91dGIoMHgwMCwgaW9iYXNlK0JHREgpOwoJc3dpdGNoIChzcGVlZCkgewoJY2FzZSA5NjAwOiAgIG91dGIoMHgwYywgaW9iYXNlK0JHREwpOyBicmVhazsKCWNhc2UgMTkyMDA6ICBvdXRiKDB4MDYsIGlvYmFzZStCR0RMKTsgYnJlYWs7CgljYXNlIDM4NDAwOiAgb3V0YigweDAzLCBpb2Jhc2UrQkdETCk7IGJyZWFrOwoJY2FzZSA1NzYwMDogIG91dGIoMHgwMiwgaW9iYXNlK0JHREwpOyBicmVhazsKCWNhc2UgMTE1MjAwOiBvdXRiKDB4MDEsIGlvYmFzZStCR0RMKTsgYnJlYWs7CgljYXNlIDU3NjAwMDoKCQlzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTks1KTsKCQkKCQkvKiBJUkNSMjogTURSUyBpcyBzZXQgKi8KCQlvdXRiKGluYihpb2Jhc2UrNCkgfCAweDA0LCBpb2Jhc2UrNCk7CgkgICAgICAgCgkJbWNyID0gTUNSX01JUjsKCQlJUkRBX0RFQlVHKDAsICIlcygpLCBoYW5kbGluZyBiYXVkIG9mIDU3NjAwMFxuIiwgX19GVU5DVElPTl9fKTsKCQlicmVhazsKCWNhc2UgMTE1MjAwMDoKCQltY3IgPSBNQ1JfTUlSOwoJCUlSREFfREVCVUcoMCwgIiVzKCksIGhhbmRsaW5nIGJhdWQgb2YgMTE1MjAwMFxuIiwgX19GVU5DVElPTl9fKTsKCQlicmVhazsKCWNhc2UgNDAwMDAwMDoKCQltY3IgPSBNQ1JfRklSOwoJCUlSREFfREVCVUcoMCwgIiVzKCksIGhhbmRsaW5nIGJhdWQgb2YgNDAwMDAwMFxuIiwgX19GVU5DVElPTl9fKTsKCQlicmVhazsKCWRlZmF1bHQ6CgkJbWNyID0gTUNSX0ZJUjsKCQlJUkRBX0RFQlVHKDAsICIlcygpLCB1bmtub3duIGJhdWQgcmF0ZSBvZiAlZFxuIiwgCgkJCSAgIF9fRlVOQ1RJT05fXywgc3BlZWQpOwoJCWJyZWFrOwoJfQoKCS8qIFNldCBhcHByb3ByaWF0ZSBzcGVlZCBtb2RlICovCglzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTkswKTsKCW91dGIobWNyIHwgTUNSX1RYX0RGUiwgaW9iYXNlK01DUik7CgoJLyogR2l2ZSBzb21lIGhpdHMgdG8gdGhlIHRyYW5zY2VpdmVyICovCgluc2NfaXJjY19jaGFuZ2VfZG9uZ2xlX3NwZWVkKGlvYmFzZSwgc3BlZWQsIHNlbGYtPmlvLmRvbmdsZV9pZCk7CgoJLyogU2V0IEZJRk8gdGhyZXNob2xkIHRvIFRYMTcsIFJYMTYgKi8KCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzApOwoJb3V0YigweDAwLCBpb2Jhc2UrRkNSKTsKCW91dGIoRkNSX0ZJRk9fRU4sIGlvYmFzZStGQ1IpOwoJb3V0YihGQ1JfUlhUSHwgICAgIC8qIFNldCBSeCBGSUZPIHRocmVzaG9sZCAqLwoJICAgICBGQ1JfVFhUSHwgICAgIC8qIFNldCBUeCBGSUZPIHRocmVzaG9sZCAqLwoJICAgICBGQ1JfVFhTUnwgICAgIC8qIFJlc2V0IFR4IEZJRk8gKi8KCSAgICAgRkNSX1JYU1J8ICAgICAvKiBSZXNldCBSeCBGSUZPICovCgkgICAgIEZDUl9GSUZPX0VOLCAgLyogRW5hYmxlIEZJRk9zICovCgkgICAgIGlvYmFzZStGQ1IpOwoJCgkvKiBTZXQgRklGTyBzaXplIHRvIDMyICovCglzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTksyKTsKCW91dGIoRVhDUjJfUkZTSVp8RVhDUjJfVEZTSVosIGlvYmFzZStFWENSMik7CgkKCS8qIEVuYWJsZSBzb21lIGludGVycnVwdHMgc28gd2UgY2FuIHJlY2VpdmUgZnJhbWVzICovCglzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTkswKTsgCglpZiAoc3BlZWQgPiAxMTUyMDApIHsKCQkvKiBJbnN0YWxsIEZJUiB4bWl0IGhhbmRsZXIgKi8KCQlkZXYtPmhhcmRfc3RhcnRfeG1pdCA9IG5zY19pcmNjX2hhcmRfeG1pdF9maXI7CgkJaWVyID0gSUVSX1NGSUZfSUU7CgkJbnNjX2lyY2NfZG1hX3JlY2VpdmUoc2VsZik7Cgl9IGVsc2UgewoJCS8qIEluc3RhbGwgU0lSIHhtaXQgaGFuZGxlciAqLwoJCWRldi0+aGFyZF9zdGFydF94bWl0ID0gbnNjX2lyY2NfaGFyZF94bWl0X3NpcjsKCQlpZXIgPSBJRVJfUlhIRExfSUU7Cgl9CgkvKiBTZXQgb3VyIGN1cnJlbnQgaW50ZXJydXB0IG1hc2sgKi8KCW91dGIoaWVyLCBpb2Jhc2UrSUVSKTsKICAgIAkKCS8qIFJlc3RvcmUgQlNSICovCglvdXRiKGJhbmssIGlvYmFzZStCU1IpOwoKCS8qIE1ha2Ugc3VyZSBpbnRlcnJ1cHQgaGFuZGxlcnMga2VlcCB0aGUgcHJvcGVyIGludGVycnVwdCBtYXNrICovCglyZXR1cm4oaWVyKTsKfQoKLyoKICogRnVuY3Rpb24gbnNjX2lyY2NfaGFyZF94bWl0IChza2IsIGRldikKICoKICogICAgVHJhbnNtaXQgdGhlIGZyYW1lIQogKgogKi8Kc3RhdGljIGludCBuc2NfaXJjY19oYXJkX3htaXRfc2lyKHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBuc2NfaXJjY19jYiAqc2VsZjsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CglpbnQgaW9iYXNlOwoJX19zMzIgc3BlZWQ7CglfX3U4IGJhbms7CgkKCXNlbGYgPSAoc3RydWN0IG5zY19pcmNjX2NiICopIGRldi0+cHJpdjsKCglJUkRBX0FTU0VSVChzZWxmICE9IE5VTEwsIHJldHVybiAwOyk7CgoJaW9iYXNlID0gc2VsZi0+aW8uZmlyX2Jhc2U7CgoJbmV0aWZfc3RvcF9xdWV1ZShkZXYpOwoJCQoJLyogTWFrZSBzdXJlIHRlc3RzIComIHNwZWVkIGNoYW5nZSBhcmUgYXRvbWljICovCglzcGluX2xvY2tfaXJxc2F2ZSgmc2VsZi0+bG9jaywgZmxhZ3MpOwoJCgkvKiBDaGVjayBpZiB3ZSBuZWVkIHRvIGNoYW5nZSB0aGUgc3BlZWQgKi8KCXNwZWVkID0gaXJkYV9nZXRfbmV4dF9zcGVlZChza2IpOwoJaWYgKChzcGVlZCAhPSBzZWxmLT5pby5zcGVlZCkgJiYgKHNwZWVkICE9IC0xKSkgewoJCS8qIENoZWNrIGZvciBlbXB0eSBmcmFtZS4gKi8KCQlpZiAoIXNrYi0+bGVuKSB7CgkJCS8qIElmIHdlIGp1c3Qgc2VudCBhIGZyYW1lLCB3ZSBnZXQgY2FsbGVkIGJlZm9yZQoJCQkgKiB0aGUgbGFzdCBieXRlcyBnZXQgb3V0IChiZWNhdXNlIG9mIHRoZSBTSVIgRklGTykuCgkJCSAqIElmIHRoaXMgaXMgdGhlIGNhc2UsIGxldCBpbnRlcnJ1cHQgaGFuZGxlciBjaGFuZ2UKCQkJICogdGhlIHNwZWVkIGl0c2VsZi4uLiBKZWFuIElJICovCgkJCWlmIChzZWxmLT5pby5kaXJlY3Rpb24gPT0gSU9fUkVDVikgewoJCQkJbnNjX2lyY2NfY2hhbmdlX3NwZWVkKHNlbGYsIHNwZWVkKTsgCgkJCQkvKiBUT0RPIDogRm9yIFNJUi0+U0lSLCB0aGUgbmV4dCBwYWNrZXQKCQkJCSAqIG1heSBnZXQgY29ycnVwdGVkIC0gSmVhbiBJSSAqLwoJCQkJbmV0aWZfd2FrZV9xdWV1ZShkZXYpOwoJCQl9IGVsc2UgewoJCQkJc2VsZi0+bmV3X3NwZWVkID0gc3BlZWQ7CgkJCQkvKiBRdWV1ZSB3aWxsIGJlIHJlc3RhcnRlZCBhZnRlciBzcGVlZCBjaGFuZ2UKCQkJCSAqIHRvIG1ha2Ugc3VyZSBwYWNrZXRzIGdldHMgdGhyb3VnaCB0aGUKCQkJCSAqIHByb3BlciB4bWl0IGhhbmRsZXIgLSBKZWFuIElJICovCgkJCX0KCQkJZGV2LT50cmFuc19zdGFydCA9IGppZmZpZXM7CgkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNlbGYtPmxvY2ssIGZsYWdzKTsKCQkJZGV2X2tmcmVlX3NrYihza2IpOwoJCQlyZXR1cm4gMDsKCQl9IGVsc2UKCQkJc2VsZi0+bmV3X3NwZWVkID0gc3BlZWQ7Cgl9CgoJLyogU2F2ZSBjdXJyZW50IGJhbmsgKi8KCWJhbmsgPSBpbmIoaW9iYXNlK0JTUik7CgkKCXNlbGYtPnR4X2J1ZmYuZGF0YSA9IHNlbGYtPnR4X2J1ZmYuaGVhZDsKCQoJc2VsZi0+dHhfYnVmZi5sZW4gPSBhc3luY193cmFwX3NrYihza2IsIHNlbGYtPnR4X2J1ZmYuZGF0YSwgCgkJCQkJICAgc2VsZi0+dHhfYnVmZi50cnVlc2l6ZSk7CgoJc2VsZi0+c3RhdHMudHhfYnl0ZXMgKz0gc2VsZi0+dHhfYnVmZi5sZW47CgkKCS8qIEFkZCBpbnRlcnJ1cHQgb24gdHggbG93IGxldmVsICh3aWxsIGZpcmUgaW1tZWRpYXRlbHkpICovCglzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTkswKTsKCW91dGIoSUVSX1RYTERMX0lFLCBpb2Jhc2UrSUVSKTsKCQoJLyogUmVzdG9yZSBiYW5rIHJlZ2lzdGVyICovCglvdXRiKGJhbmssIGlvYmFzZStCU1IpOwoKCWRldi0+dHJhbnNfc3RhcnQgPSBqaWZmaWVzOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmc2VsZi0+bG9jaywgZmxhZ3MpOwoKCWRldl9rZnJlZV9za2Ioc2tiKTsKCglyZXR1cm4gMDsKfQoKc3RhdGljIGludCBuc2NfaXJjY19oYXJkX3htaXRfZmlyKHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBuc2NfaXJjY19jYiAqc2VsZjsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CglpbnQgaW9iYXNlOwoJX19zMzIgc3BlZWQ7CglfX3U4IGJhbms7CglpbnQgbXR0LCBkaWZmOwoJCglzZWxmID0gKHN0cnVjdCBuc2NfaXJjY19jYiAqKSBkZXYtPnByaXY7Cglpb2Jhc2UgPSBzZWxmLT5pby5maXJfYmFzZTsKCgluZXRpZl9zdG9wX3F1ZXVlKGRldik7CgkKCS8qIE1ha2Ugc3VyZSB0ZXN0cyAqJiBzcGVlZCBjaGFuZ2UgYXJlIGF0b21pYyAqLwoJc3Bpbl9sb2NrX2lycXNhdmUoJnNlbGYtPmxvY2ssIGZsYWdzKTsKCgkvKiBDaGVjayBpZiB3ZSBuZWVkIHRvIGNoYW5nZSB0aGUgc3BlZWQgKi8KCXNwZWVkID0gaXJkYV9nZXRfbmV4dF9zcGVlZChza2IpOwoJaWYgKChzcGVlZCAhPSBzZWxmLT5pby5zcGVlZCkgJiYgKHNwZWVkICE9IC0xKSkgewoJCS8qIENoZWNrIGZvciBlbXB0eSBmcmFtZS4gKi8KCQlpZiAoIXNrYi0+bGVuKSB7CgkJCS8qIElmIHdlIGFyZSBjdXJyZW50bHkgdHJhbnNtaXR0aW5nLCBkZWZlciB0bwoJCQkgKiBpbnRlcnJ1cHQgaGFuZGxlci4gLSBKZWFuIElJICovCgkJCWlmKHNlbGYtPnR4X2ZpZm8ubGVuID09IDApIHsKCQkJCW5zY19pcmNjX2NoYW5nZV9zcGVlZChzZWxmLCBzcGVlZCk7IAoJCQkJbmV0aWZfd2FrZV9xdWV1ZShkZXYpOwoJCQl9IGVsc2UgewoJCQkJc2VsZi0+bmV3X3NwZWVkID0gc3BlZWQ7CgkJCQkvKiBLZWVwIHF1ZXVlIHN0b3BwZWQgOgoJCQkJICogdGhlIHNwZWVkIGNoYW5nZSBvcGVyYXRpb24gbWF5IGNoYW5nZSB0aGUKCQkJCSAqIHhtaXQgaGFuZGxlciwgYW5kIHdlIHdhbnQgdG8gbWFrZSBzdXJlCgkJCQkgKiB0aGUgbmV4dCBwYWNrZXQgZ2V0IHRocm91Z2ggdGhlIHByb3BlcgoJCQkJICogVHggcGF0aCwgc28gYmxvY2sgdGhlIFR4IHF1ZXVlIHVudGlsCgkJCQkgKiB0aGUgc3BlZWQgY2hhbmdlIGhhcyBiZWVuIGRvbmUuCgkJCQkgKiBKZWFuIElJICovCgkJCX0KCQkJZGV2LT50cmFuc19zdGFydCA9IGppZmZpZXM7CgkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNlbGYtPmxvY2ssIGZsYWdzKTsKCQkJZGV2X2tmcmVlX3NrYihza2IpOwoJCQlyZXR1cm4gMDsKCQl9IGVsc2UgewoJCQkvKiBDaGFuZ2Ugc3BlZWQgYWZ0ZXIgY3VycmVudCBmcmFtZSAqLwoJCQlzZWxmLT5uZXdfc3BlZWQgPSBzcGVlZDsKCQl9Cgl9CgoJLyogU2F2ZSBjdXJyZW50IGJhbmsgKi8KCWJhbmsgPSBpbmIoaW9iYXNlK0JTUik7CgoJLyogUmVnaXN0ZXIgYW5kIGNvcHkgdGhpcyBmcmFtZSB0byBETUEgbWVtb3J5ICovCglzZWxmLT50eF9maWZvLnF1ZXVlW3NlbGYtPnR4X2ZpZm8uZnJlZV0uc3RhcnQgPSBzZWxmLT50eF9maWZvLnRhaWw7CglzZWxmLT50eF9maWZvLnF1ZXVlW3NlbGYtPnR4X2ZpZm8uZnJlZV0ubGVuID0gc2tiLT5sZW47CglzZWxmLT50eF9maWZvLnRhaWwgKz0gc2tiLT5sZW47CgoJc2VsZi0+c3RhdHMudHhfYnl0ZXMgKz0gc2tiLT5sZW47CgoJbWVtY3B5KHNlbGYtPnR4X2ZpZm8ucXVldWVbc2VsZi0+dHhfZmlmby5mcmVlXS5zdGFydCwgc2tiLT5kYXRhLCAKCSAgICAgICBza2ItPmxlbik7CgkKCXNlbGYtPnR4X2ZpZm8ubGVuKys7CglzZWxmLT50eF9maWZvLmZyZWUrKzsKCgkvKiBTdGFydCB0cmFuc21pdCBvbmx5IGlmIHRoZXJlIGlzIGN1cnJlbnRseSBubyB0cmFuc21pdCBnb2luZyBvbiAqLwoJaWYgKHNlbGYtPnR4X2ZpZm8ubGVuID09IDEpIHsKCQkvKiBDaGVjayBpZiB3ZSBtdXN0IHdhaXQgdGhlIG1pbiB0dXJuIHRpbWUgb3Igbm90ICovCgkJbXR0ID0gaXJkYV9nZXRfbXR0KHNrYik7CgkJaWYgKG10dCkgewoJCQkvKiBDaGVjayBob3cgbXVjaCB0aW1lIHdlIGhhdmUgdXNlZCBhbHJlYWR5ICovCgkJCWRvX2dldHRpbWVvZmRheSgmc2VsZi0+bm93KTsKCQkJZGlmZiA9IHNlbGYtPm5vdy50dl91c2VjIC0gc2VsZi0+c3RhbXAudHZfdXNlYzsKCQkJaWYgKGRpZmYgPCAwKSAKCQkJCWRpZmYgKz0gMTAwMDAwMDsKCQkJCgkJCS8qIENoZWNrIGlmIHRoZSBtdHQgaXMgbGFyZ2VyIHRoYW4gdGhlIHRpbWUgd2UgaGF2ZQoJCQkgKiBhbHJlYWR5IHVzZWQgYnkgYWxsIHRoZSBwcm90b2NvbCBwcm9jZXNzaW5nCgkJCSAqLwoJCQlpZiAobXR0ID4gZGlmZikgewoJCQkJbXR0IC09IGRpZmY7CgoJCQkJLyogCgkJCQkgKiBVc2UgdGltZXIgaWYgZGVsYXkgbGFyZ2VyIHRoYW4gMTI1IHVzLCBhbmQKCQkJCSAqIHVzZSB1ZGVsYXkgZm9yIHNtYWxsZXIgdmFsdWVzIHdoaWNoIHNob3VsZAoJCQkJICogYmUgYWNjZXB0YWJsZQoJCQkJICovCgkJCQlpZiAobXR0ID4gMTI1KSB7CgkJCQkJLyogQWRqdXN0IGZvciB0aW1lciByZXNvbHV0aW9uICovCgkJCQkJbXR0ID0gbXR0IC8gMTI1OwoJCQkJCQoJCQkJCS8qIFNldHVwIHRpbWVyICovCgkJCQkJc3dpdGNoX2JhbmsoaW9iYXNlLCBCQU5LNCk7CgkJCQkJb3V0YihtdHQgJiAweGZmLCBpb2Jhc2UrVE1STCk7CgkJCQkJb3V0YigobXR0ID4+IDgpICYgMHgwZiwgaW9iYXNlK1RNUkgpOwoJCQkJCQoJCQkJCS8qIFN0YXJ0IHRpbWVyICovCgkJCQkJb3V0YihJUkNSMV9UTVJfRU4sIGlvYmFzZStJUkNSMSk7CgkJCQkJc2VsZi0+aW8uZGlyZWN0aW9uID0gSU9fWE1JVDsKCQkJCQkKCQkJCQkvKiBFbmFibGUgdGltZXIgaW50ZXJydXB0ICovCgkJCQkJc3dpdGNoX2JhbmsoaW9iYXNlLCBCQU5LMCk7CgkJCQkJb3V0YihJRVJfVE1SX0lFLCBpb2Jhc2UrSUVSKTsKCQkJCQkKCQkJCQkvKiBUaW1lciB3aWxsIHRha2UgY2FyZSBvZiB0aGUgcmVzdCAqLwoJCQkJCWdvdG8gb3V0OyAKCQkJCX0gZWxzZQoJCQkJCXVkZWxheShtdHQpOwoJCQl9CgkJfQkJCgkJLyogRW5hYmxlIERNQSBpbnRlcnJ1cHQgKi8KCQlzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTkswKTsKCQlvdXRiKElFUl9ETUFfSUUsIGlvYmFzZStJRVIpOwoKCQkvKiBUcmFuc21pdCBmcmFtZSAqLwoJCW5zY19pcmNjX2RtYV94bWl0KHNlbGYsIGlvYmFzZSk7Cgl9CiBvdXQ6CgkvKiBOb3QgYnVzeSB0cmFuc21pdHRpbmcgYW55bW9yZSBpZiB3aW5kb3cgaXMgbm90IGZ1bGwsCgkgKiBhbmQgaWYgd2UgZG9uJ3QgbmVlZCB0byBjaGFuZ2Ugc3BlZWQgKi8KCWlmICgoc2VsZi0+dHhfZmlmby5mcmVlIDwgTUFYX1RYX1dJTkRPVykgJiYgKHNlbGYtPm5ld19zcGVlZCA9PSAwKSkKCQluZXRpZl93YWtlX3F1ZXVlKHNlbGYtPm5ldGRldik7CgoJLyogUmVzdG9yZSBiYW5rIHJlZ2lzdGVyICovCglvdXRiKGJhbmssIGlvYmFzZStCU1IpOwoKCWRldi0+dHJhbnNfc3RhcnQgPSBqaWZmaWVzOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmc2VsZi0+bG9jaywgZmxhZ3MpOwoJZGV2X2tmcmVlX3NrYihza2IpOwoKCXJldHVybiAwOwp9CgovKgogKiBGdW5jdGlvbiBuc2NfaXJjY19kbWFfeG1pdCAoc2VsZiwgaW9iYXNlKQogKgogKiAgICBUcmFuc21pdCBkYXRhIHVzaW5nIERNQQogKgogKi8Kc3RhdGljIHZvaWQgbnNjX2lyY2NfZG1hX3htaXQoc3RydWN0IG5zY19pcmNjX2NiICpzZWxmLCBpbnQgaW9iYXNlKQp7CglpbnQgYnNyOwoKCS8qIFNhdmUgY3VycmVudCBiYW5rICovCglic3IgPSBpbmIoaW9iYXNlK0JTUik7CgoJLyogRGlzYWJsZSBETUEgKi8KCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzApOwoJb3V0YihpbmIoaW9iYXNlK01DUikgJiB+TUNSX0RNQV9FTiwgaW9iYXNlK01DUik7CgkKCXNlbGYtPmlvLmRpcmVjdGlvbiA9IElPX1hNSVQ7CgkKCS8qIENob29zZSB0cmFuc21pdCBETUEgY2hhbm5lbCAgKi8gCglzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTksyKTsKCW91dGIoRUNSMV9ETUFTV1B8RUNSMV9ETUFORnxFQ1IxX0VYVF9TTCwgaW9iYXNlK0VDUjEpOwoJCglpcmRhX3NldHVwX2RtYShzZWxmLT5pby5kbWEsIAoJCSAgICAgICAoKHU4ICopc2VsZi0+dHhfZmlmby5xdWV1ZVtzZWxmLT50eF9maWZvLnB0cl0uc3RhcnQgLQoJCQlzZWxmLT50eF9idWZmLmhlYWQpICsgc2VsZi0+dHhfYnVmZl9kbWEsCgkJICAgICAgIHNlbGYtPnR4X2ZpZm8ucXVldWVbc2VsZi0+dHhfZmlmby5wdHJdLmxlbiwgCgkJICAgICAgIERNQV9UWF9NT0RFKTsKCgkvKiBFbmFibGUgRE1BIGFuZCBTSVIgaW50ZXJhY3Rpb24gcHVsc2UgKi8KIAlzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTkswKTsJCglvdXRiKGluYihpb2Jhc2UrTUNSKXxNQ1JfVFhfREZSfE1DUl9ETUFfRU58TUNSX0lSX1BMUywgaW9iYXNlK01DUik7CgoJLyogUmVzdG9yZSBiYW5rIHJlZ2lzdGVyICovCglvdXRiKGJzciwgaW9iYXNlK0JTUik7Cn0KCi8qCiAqIEZ1bmN0aW9uIG5zY19pcmNjX3Bpb194bWl0IChzZWxmLCBpb2Jhc2UpCiAqCiAqICAgIFRyYW5zbWl0IGRhdGEgdXNpbmcgUElPLiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgYnl0ZXMgdGhhdCBhY3R1YWxseQogKiAgICBnb3QgdHJhbnNmZXJyZWQKICoKICovCnN0YXRpYyBpbnQgbnNjX2lyY2NfcGlvX3dyaXRlKGludCBpb2Jhc2UsIF9fdTggKmJ1ZiwgaW50IGxlbiwgaW50IGZpZm9fc2l6ZSkKewoJaW50IGFjdHVhbCA9IDA7CglfX3U4IGJhbms7CgkKCUlSREFfREVCVUcoNCwgIiVzKClcbiIsIF9fRlVOQ1RJT05fXyk7CgoJLyogU2F2ZSBjdXJyZW50IGJhbmsgKi8KCWJhbmsgPSBpbmIoaW9iYXNlK0JTUik7CgoJc3dpdGNoX2JhbmsoaW9iYXNlLCBCQU5LMCk7CglpZiAoIShpbmJfcChpb2Jhc2UrTFNSKSAmIExTUl9UWEVNUCkpIHsKCQlJUkRBX0RFQlVHKDQsICIlcygpLCB3YXJuaW5nLCBGSUZPIG5vdCBlbXB0eSB5ZXQhXG4iLAoJCQkgICBfX0ZVTkNUSU9OX18pOwoKCQkvKiBGSUZPIG1heSBzdGlsbCBiZSBmaWxsZWQgdG8gdGhlIFR4IGludGVycnVwdCB0aHJlc2hvbGQgKi8KCQlmaWZvX3NpemUgLT0gMTc7Cgl9CgoJLyogRmlsbCBGSUZPIHdpdGggY3VycmVudCBmcmFtZSAqLwoJd2hpbGUgKChmaWZvX3NpemUtLSA+IDApICYmIChhY3R1YWwgPCBsZW4pKSB7CgkJLyogVHJhbnNtaXQgbmV4dCBieXRlICovCgkJb3V0YihidWZbYWN0dWFsKytdLCBpb2Jhc2UrVFhEKTsKCX0KICAgICAgICAKCUlSREFfREVCVUcoNCwgIiVzKCksIGZpZm9fc2l6ZSAlZCA7ICVkIHNlbnQgb2YgJWRcbiIsIAoJCSAgIF9fRlVOQ1RJT05fXywgZmlmb19zaXplLCBhY3R1YWwsIGxlbik7CgkKCS8qIFJlc3RvcmUgYmFuayAqLwoJb3V0YihiYW5rLCBpb2Jhc2UrQlNSKTsKCglyZXR1cm4gYWN0dWFsOwp9CgovKgogKiBGdW5jdGlvbiBuc2NfaXJjY19kbWFfeG1pdF9jb21wbGV0ZSAoc2VsZikKICoKICogICAgVGhlIHRyYW5zZmVyIG9mIGEgZnJhbWUgaW4gZmluaXNoZWQuIFRoaXMgZnVuY3Rpb24gd2lsbCBvbmx5IGJlIGNhbGxlZCAKICogICAgYnkgdGhlIGludGVycnVwdCBoYW5kbGVyCiAqCiAqLwpzdGF0aWMgaW50IG5zY19pcmNjX2RtYV94bWl0X2NvbXBsZXRlKHN0cnVjdCBuc2NfaXJjY19jYiAqc2VsZikKewoJaW50IGlvYmFzZTsKCV9fdTggYmFuazsKCWludCByZXQgPSBUUlVFOwoKCUlSREFfREVCVUcoMiwgIiVzKClcbiIsIF9fRlVOQ1RJT05fXyk7CgoJaW9iYXNlID0gc2VsZi0+aW8uZmlyX2Jhc2U7CgoJLyogU2F2ZSBjdXJyZW50IGJhbmsgKi8KCWJhbmsgPSBpbmIoaW9iYXNlK0JTUik7CgoJLyogRGlzYWJsZSBETUEgKi8KCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzApOwogICAgICAgIG91dGIoaW5iKGlvYmFzZStNQ1IpICYgfk1DUl9ETUFfRU4sIGlvYmFzZStNQ1IpOwoJCgkvKiBDaGVjayBmb3IgdW5kZXJycnVuISAqLwoJaWYgKGluYihpb2Jhc2UrQVNDUikgJiBBU0NSX1RYVVIpIHsKCQlzZWxmLT5zdGF0cy50eF9lcnJvcnMrKzsKCQlzZWxmLT5zdGF0cy50eF9maWZvX2Vycm9ycysrOwoJCQoJCS8qIENsZWFyIGJpdCwgYnkgd3JpdGluZyAxIGludG8gaXQgKi8KCQlvdXRiKEFTQ1JfVFhVUiwgaW9iYXNlK0FTQ1IpOwoJfSBlbHNlIHsKCQlzZWxmLT5zdGF0cy50eF9wYWNrZXRzKys7Cgl9CgoJLyogRmluaXNoZWQgd2l0aCB0aGlzIGZyYW1lLCBzbyBwcmVwYXJlIGZvciBuZXh0ICovCglzZWxmLT50eF9maWZvLnB0cisrOwoJc2VsZi0+dHhfZmlmby5sZW4tLTsKCgkvKiBBbnkgZnJhbWVzIHRvIGJlIHNlbnQgYmFjay10by1iYWNrPyAqLwoJaWYgKHNlbGYtPnR4X2ZpZm8ubGVuKSB7CgkJbnNjX2lyY2NfZG1hX3htaXQoc2VsZiwgaW9iYXNlKTsKCQkKCQkvKiBOb3QgZmluaXNoZWQgeWV0ISAqLwoJCXJldCA9IEZBTFNFOwoJfSBlbHNlIHsKCQkvKiBSZXNldCBUeCBGSUZPIGluZm8gKi8KCQlzZWxmLT50eF9maWZvLmxlbiA9IHNlbGYtPnR4X2ZpZm8ucHRyID0gc2VsZi0+dHhfZmlmby5mcmVlID0gMDsKCQlzZWxmLT50eF9maWZvLnRhaWwgPSBzZWxmLT50eF9idWZmLmhlYWQ7Cgl9CgoJLyogTWFrZSBzdXJlIHdlIGhhdmUgcm9vbSBmb3IgbW9yZSBmcmFtZXMgYW5kCgkgKiB0aGF0IHdlIGRvbid0IG5lZWQgdG8gY2hhbmdlIHNwZWVkICovCglpZiAoKHNlbGYtPnR4X2ZpZm8uZnJlZSA8IE1BWF9UWF9XSU5ET1cpICYmIChzZWxmLT5uZXdfc3BlZWQgPT0gMCkpIHsKCQkvKiBOb3QgYnVzeSB0cmFuc21pdHRpbmcgYW55bW9yZSAqLwoJCS8qIFRlbGwgdGhlIG5ldHdvcmsgbGF5ZXIsIHRoYXQgd2UgY2FuIGFjY2VwdCBtb3JlIGZyYW1lcyAqLwoJCW5ldGlmX3dha2VfcXVldWUoc2VsZi0+bmV0ZGV2KTsKCX0KCgkvKiBSZXN0b3JlIGJhbmsgKi8KCW91dGIoYmFuaywgaW9iYXNlK0JTUik7CgkKCXJldHVybiByZXQ7Cn0KCi8qCiAqIEZ1bmN0aW9uIG5zY19pcmNjX2RtYV9yZWNlaXZlIChzZWxmKQogKgogKiAgICBHZXQgcmVhZHkgZm9yIHJlY2VpdmluZyBhIGZyYW1lLiBUaGUgZGV2aWNlIHdpbGwgaW5pdGlhdGUgYSBETUEKICogICAgaWYgaXQgc3RhcnRzIHRvIHJlY2VpdmUgYSBmcmFtZS4KICoKICovCnN0YXRpYyBpbnQgbnNjX2lyY2NfZG1hX3JlY2VpdmUoc3RydWN0IG5zY19pcmNjX2NiICpzZWxmKSAKewoJaW50IGlvYmFzZTsKCV9fdTggYnNyOwoKCWlvYmFzZSA9IHNlbGYtPmlvLmZpcl9iYXNlOwoKCS8qIFJlc2V0IFR4IEZJRk8gaW5mbyAqLwoJc2VsZi0+dHhfZmlmby5sZW4gPSBzZWxmLT50eF9maWZvLnB0ciA9IHNlbGYtPnR4X2ZpZm8uZnJlZSA9IDA7CglzZWxmLT50eF9maWZvLnRhaWwgPSBzZWxmLT50eF9idWZmLmhlYWQ7CgoJLyogU2F2ZSBjdXJyZW50IGJhbmsgKi8KCWJzciA9IGluYihpb2Jhc2UrQlNSKTsKCgkvKiBEaXNhYmxlIERNQSAqLwoJc3dpdGNoX2JhbmsoaW9iYXNlLCBCQU5LMCk7CglvdXRiKGluYihpb2Jhc2UrTUNSKSAmIH5NQ1JfRE1BX0VOLCBpb2Jhc2UrTUNSKTsKCgkvKiBDaG9vc2UgRE1BIFJ4LCBETUEgRmFpcm5lc3MsIGFuZCBBZHZhbmNlZCBtb2RlICovCglzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTksyKTsKCW91dGIoRUNSMV9ETUFORnxFQ1IxX0VYVF9TTCwgaW9iYXNlK0VDUjEpOwoKCXNlbGYtPmlvLmRpcmVjdGlvbiA9IElPX1JFQ1Y7CglzZWxmLT5yeF9idWZmLmRhdGEgPSBzZWxmLT5yeF9idWZmLmhlYWQ7CgkKCS8qIFJlc2V0IFJ4IEZJRk8uIFRoaXMgd2lsbCBhbHNvIGZsdXNoIHRoZSBTVF9GSUZPICovCglzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTkswKTsKCW91dGIoRkNSX1JYU1J8RkNSX0ZJRk9fRU4sIGlvYmFzZStGQ1IpOwoKCXNlbGYtPnN0X2ZpZm8ubGVuID0gc2VsZi0+c3RfZmlmby5wZW5kaW5nX2J5dGVzID0gMDsKCXNlbGYtPnN0X2ZpZm8udGFpbCA9IHNlbGYtPnN0X2ZpZm8uaGVhZCA9IDA7CgkKCWlyZGFfc2V0dXBfZG1hKHNlbGYtPmlvLmRtYSwgc2VsZi0+cnhfYnVmZl9kbWEsIHNlbGYtPnJ4X2J1ZmYudHJ1ZXNpemUsCgkJICAgICAgIERNQV9SWF9NT0RFKTsKCgkvKiBFbmFibGUgRE1BICovCglzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTkswKTsKCW91dGIoaW5iKGlvYmFzZStNQ1IpfE1DUl9ETUFfRU4sIGlvYmFzZStNQ1IpOwoKCS8qIFJlc3RvcmUgYmFuayByZWdpc3RlciAqLwoJb3V0Yihic3IsIGlvYmFzZStCU1IpOwoJCglyZXR1cm4gMDsKfQoKLyoKICogRnVuY3Rpb24gbnNjX2lyY2NfZG1hX3JlY2VpdmVfY29tcGxldGUgKHNlbGYpCiAqCiAqICAgIEZpbmlzaGVkIHdpdGggcmVjZWl2aW5nIGZyYW1lcwogKgogKiAgICAKICovCnN0YXRpYyBpbnQgbnNjX2lyY2NfZG1hX3JlY2VpdmVfY29tcGxldGUoc3RydWN0IG5zY19pcmNjX2NiICpzZWxmLCBpbnQgaW9iYXNlKQp7CglzdHJ1Y3Qgc3RfZmlmbyAqc3RfZmlmbzsKCXN0cnVjdCBza19idWZmICpza2I7CglfX3U4IHN0YXR1czsKCV9fdTggYmFuazsKCWludCBsZW47CgoJc3RfZmlmbyA9ICZzZWxmLT5zdF9maWZvOwoKCS8qIFNhdmUgY3VycmVudCBiYW5rICovCgliYW5rID0gaW5iKGlvYmFzZStCU1IpOwoJCgkvKiBSZWFkIGFsbCBlbnRyaWVzIGluIHN0YXR1cyBGSUZPICovCglzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTks1KTsKCXdoaWxlICgoc3RhdHVzID0gaW5iKGlvYmFzZStGUk1fU1QpKSAmIEZSTV9TVF9WTEQpIHsKCQkvKiBXZSBtdXN0IGVtcHR5IHRoZSBzdGF0dXMgRklGTyBubyBtYXR0ZXIgd2hhdCAqLwoJCWxlbiA9IGluYihpb2Jhc2UrUkZMRkwpIHwgKChpbmIoaW9iYXNlK1JGTEZIKSAmIDB4MWYpIDw8IDgpOwoKCQlpZiAoc3RfZmlmby0+dGFpbCA+PSBNQVhfUlhfV0lORE9XKSB7CgkJCUlSREFfREVCVUcoMCwgIiVzKCksIHdpbmRvdyBpcyBmdWxsIVxuIiwgX19GVU5DVElPTl9fKTsKCQkJY29udGludWU7CgkJfQoJCQkKCQlzdF9maWZvLT5lbnRyaWVzW3N0X2ZpZm8tPnRhaWxdLnN0YXR1cyA9IHN0YXR1czsKCQlzdF9maWZvLT5lbnRyaWVzW3N0X2ZpZm8tPnRhaWxdLmxlbiA9IGxlbjsKCQlzdF9maWZvLT5wZW5kaW5nX2J5dGVzICs9IGxlbjsKCQlzdF9maWZvLT50YWlsKys7CgkJc3RfZmlmby0+bGVuKys7Cgl9CgkvKiBUcnkgdG8gcHJvY2VzcyBhbGwgZW50cmllcyBpbiBzdGF0dXMgRklGTyAqLwoJd2hpbGUgKHN0X2ZpZm8tPmxlbiA+IDApIHsKCQkvKiBHZXQgZmlyc3QgZW50cnkgKi8KCQlzdGF0dXMgPSBzdF9maWZvLT5lbnRyaWVzW3N0X2ZpZm8tPmhlYWRdLnN0YXR1czsKCQlsZW4gICAgPSBzdF9maWZvLT5lbnRyaWVzW3N0X2ZpZm8tPmhlYWRdLmxlbjsKCQlzdF9maWZvLT5wZW5kaW5nX2J5dGVzIC09IGxlbjsKCQlzdF9maWZvLT5oZWFkKys7CgkJc3RfZmlmby0+bGVuLS07CgoJCS8qIENoZWNrIGZvciBlcnJvcnMgKi8KCQlpZiAoc3RhdHVzICYgRlJNX1NUX0VSUl9NU0spIHsKCQkJaWYgKHN0YXR1cyAmIEZSTV9TVF9MT1NUX0ZSKSB7CgkJCQkvKiBBZGQgbnVtYmVyIG9mIGxvc3QgZnJhbWVzIHRvIHN0YXRzICovCgkJCQlzZWxmLT5zdGF0cy5yeF9lcnJvcnMgKz0gbGVuOwkKCQkJfSBlbHNlIHsKCQkJCS8qIFNraXAgZnJhbWUgKi8KCQkJCXNlbGYtPnN0YXRzLnJ4X2Vycm9ycysrOwoJCQkJCgkJCQlzZWxmLT5yeF9idWZmLmRhdGEgKz0gbGVuOwoJCQkKCQkJCWlmIChzdGF0dXMgJiBGUk1fU1RfTUFYX0xFTikKCQkJCQlzZWxmLT5zdGF0cy5yeF9sZW5ndGhfZXJyb3JzKys7CgkJCQkKCQkJCWlmIChzdGF0dXMgJiBGUk1fU1RfUEhZX0VSUikgCgkJCQkJc2VsZi0+c3RhdHMucnhfZnJhbWVfZXJyb3JzKys7CgkJCQkKCQkJCWlmIChzdGF0dXMgJiBGUk1fU1RfQkFEX0NSQykgCgkJCQkJc2VsZi0+c3RhdHMucnhfY3JjX2Vycm9ycysrOwoJCQl9CgkJCS8qIFRoZSBlcnJvcnMgYmVsb3cgY2FuIGJlIHJlcG9ydGVkIGluIGJvdGggY2FzZXMgKi8KCQkJaWYgKHN0YXR1cyAmIEZSTV9TVF9PVlIxKQoJCQkJc2VsZi0+c3RhdHMucnhfZmlmb19lcnJvcnMrKzsJCSAgICAgICAKCQkJCgkJCWlmIChzdGF0dXMgJiBGUk1fU1RfT1ZSMikKCQkJCXNlbGYtPnN0YXRzLnJ4X2ZpZm9fZXJyb3JzKys7CgkJfSBlbHNlIHsKCQkJLyogIAoJCQkgKiBGaXJzdCB3ZSBtdXN0IG1ha2Ugc3VyZSB0aGF0IHRoZSBmcmFtZSB3ZQoJCQkgKiB3YW50IHRvIGRlbGl2ZXIgaXMgYWxsIGluIG1haW4gbWVtb3J5LiBJZiB3ZQoJCQkgKiBjYW5ub3QgdGVsbCwgdGhlbiB3ZSBjaGVjayBpZiB0aGUgUnggRklGTyBpcwoJCQkgKiBlbXB0eS4gSWYgbm90IHRoZW4gd2Ugd2lsbCBoYXZlIHRvIHRha2UgYSBuYXAKCQkJICogYW5kIHRyeSBhZ2FpbiBsYXRlci4gIAoJCQkgKi8KCQkJaWYgKHN0X2ZpZm8tPnBlbmRpbmdfYnl0ZXMgPCBzZWxmLT5pby5maWZvX3NpemUpIHsKCQkJCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzApOwoJCQkJaWYgKGluYihpb2Jhc2UrTFNSKSAmIExTUl9SWERBKSB7CgkJCQkJLyogUHV0IHRoaXMgZW50cnkgYmFjayBpbiBmaWZvICovCgkJCQkJc3RfZmlmby0+aGVhZC0tOwoJCQkJCXN0X2ZpZm8tPmxlbisrOwoJCQkJCXN0X2ZpZm8tPnBlbmRpbmdfYnl0ZXMgKz0gbGVuOwoJCQkJCXN0X2ZpZm8tPmVudHJpZXNbc3RfZmlmby0+aGVhZF0uc3RhdHVzID0gc3RhdHVzOwoJCQkJCXN0X2ZpZm8tPmVudHJpZXNbc3RfZmlmby0+aGVhZF0ubGVuID0gbGVuOwoJCQkJCS8qICAKCQkJCQkgKiBETUEgbm90IGZpbmlzaGVkIHlldCwgc28gdHJ5IGFnYWluIAoJCQkJCSAqIGxhdGVyLCBzZXQgdGltZXIgdmFsdWUsIHJlc29sdXRpb24gCgkJCQkJICogMTI1IHVzIAoJCQkJCSAqLwoJCQkJCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzQpOwoJCQkJCW91dGIoMHgwMiwgaW9iYXNlK1RNUkwpOyAvKiB4IDEyNSB1cyAqLwoJCQkJCW91dGIoMHgwMCwgaW9iYXNlK1RNUkgpOwoKCQkJCQkvKiBTdGFydCB0aW1lciAqLwoJCQkJCW91dGIoSVJDUjFfVE1SX0VOLCBpb2Jhc2UrSVJDUjEpOwoKCQkJCQkvKiBSZXN0b3JlIGJhbmsgcmVnaXN0ZXIgKi8KCQkJCQlvdXRiKGJhbmssIGlvYmFzZStCU1IpOwoJCQkJCQoJCQkJCXJldHVybiBGQUxTRTsgLyogSSdsbCBiZSBiYWNrISAqLwoJCQkJfQoJCQl9CgoJCQkvKiAKCQkJICogUmVtZW1iZXIgdGhlIHRpbWUgd2UgcmVjZWl2ZWQgdGhpcyBmcmFtZSwgc28gd2UgY2FuCgkJCSAqIHJlZHVjZSB0aGUgbWluIHR1cm4gdGltZSBhIGJpdCBzaW5jZSB3ZSB3aWxsIGtub3cKCQkJICogaG93IG11Y2ggdGltZSB3ZSBoYXZlIHVzZWQgZm9yIHByb3RvY29sIHByb2Nlc3NpbmcKCQkJICovCgkJCWRvX2dldHRpbWVvZmRheSgmc2VsZi0+c3RhbXApOwoKCQkJc2tiID0gZGV2X2FsbG9jX3NrYihsZW4rMSk7CgkJCWlmIChza2IgPT0gTlVMTCkgIHsKCQkJCUlSREFfV0FSTklORygiJXMoKSwgbWVtb3J5IHNxdWVlemUsICIKCQkJCQkgICAgICJkcm9wcGluZyBmcmFtZS5cbiIsCgkJCQkJICAgICBfX0ZVTkNUSU9OX18pOwoJCQkJc2VsZi0+c3RhdHMucnhfZHJvcHBlZCsrOwoKCQkJCS8qIFJlc3RvcmUgYmFuayByZWdpc3RlciAqLwoJCQkJb3V0YihiYW5rLCBpb2Jhc2UrQlNSKTsKCgkJCQlyZXR1cm4gRkFMU0U7CgkJCX0KCQkJCgkJCS8qIE1ha2Ugc3VyZSBJUCBoZWFkZXIgZ2V0cyBhbGlnbmVkICovCgkJCXNrYl9yZXNlcnZlKHNrYiwgMSk7IAoKCQkJLyogQ29weSBmcmFtZSB3aXRob3V0IENSQyAqLwoJCQlpZiAoc2VsZi0+aW8uc3BlZWQgPCA0MDAwMDAwKSB7CgkJCQlza2JfcHV0KHNrYiwgbGVuLTIpOwoJCQkJbWVtY3B5KHNrYi0+ZGF0YSwgc2VsZi0+cnhfYnVmZi5kYXRhLCBsZW4tMik7CgkJCX0gZWxzZSB7CgkJCQlza2JfcHV0KHNrYiwgbGVuLTQpOwoJCQkJbWVtY3B5KHNrYi0+ZGF0YSwgc2VsZi0+cnhfYnVmZi5kYXRhLCBsZW4tNCk7CgkJCX0KCgkJCS8qIE1vdmUgdG8gbmV4dCBmcmFtZSAqLwoJCQlzZWxmLT5yeF9idWZmLmRhdGEgKz0gbGVuOwoJCQlzZWxmLT5zdGF0cy5yeF9ieXRlcyArPSBsZW47CgkJCXNlbGYtPnN0YXRzLnJ4X3BhY2tldHMrKzsKCgkJCXNrYi0+ZGV2ID0gc2VsZi0+bmV0ZGV2OwoJCQlza2ItPm1hYy5yYXcgID0gc2tiLT5kYXRhOwoJCQlza2ItPnByb3RvY29sID0gaHRvbnMoRVRIX1BfSVJEQSk7CgkJCW5ldGlmX3J4KHNrYik7CgkJCXNlbGYtPm5ldGRldi0+bGFzdF9yeCA9IGppZmZpZXM7CgkJfQoJfQoJLyogUmVzdG9yZSBiYW5rIHJlZ2lzdGVyICovCglvdXRiKGJhbmssIGlvYmFzZStCU1IpOwoKCXJldHVybiBUUlVFOwp9CgovKgogKiBGdW5jdGlvbiBuc2NfaXJjY19waW9fcmVjZWl2ZSAoc2VsZikKICoKICogICAgUmVjZWl2ZSBhbGwgZGF0YSBpbiByZWNlaXZlciBGSUZPCiAqCiAqLwpzdGF0aWMgdm9pZCBuc2NfaXJjY19waW9fcmVjZWl2ZShzdHJ1Y3QgbnNjX2lyY2NfY2IgKnNlbGYpIAp7CglfX3U4IGJ5dGU7CglpbnQgaW9iYXNlOwoKCWlvYmFzZSA9IHNlbGYtPmlvLmZpcl9iYXNlOwoJCgkvKiAgUmVjZWl2ZSBhbGwgY2hhcmFjdGVycyBpbiBSeCBGSUZPICovCglkbyB7CgkJYnl0ZSA9IGluYihpb2Jhc2UrUlhEKTsKCQlhc3luY191bndyYXBfY2hhcihzZWxmLT5uZXRkZXYsICZzZWxmLT5zdGF0cywgJnNlbGYtPnJ4X2J1ZmYsIAoJCQkJICBieXRlKTsKCX0gd2hpbGUgKGluYihpb2Jhc2UrTFNSKSAmIExTUl9SWERBKTsgLyogRGF0YSBhdmFpbGFibGUgKi8JCn0KCi8qCiAqIEZ1bmN0aW9uIG5zY19pcmNjX3Npcl9pbnRlcnJ1cHQgKHNlbGYsIGVpcikKICoKICogICAgSGFuZGxlIFNJUiBpbnRlcnJ1cHQKICoKICovCnN0YXRpYyB2b2lkIG5zY19pcmNjX3Npcl9pbnRlcnJ1cHQoc3RydWN0IG5zY19pcmNjX2NiICpzZWxmLCBpbnQgZWlyKQp7CglpbnQgYWN0dWFsOwoKCS8qIENoZWNrIGlmIHRyYW5zbWl0IEZJRk8gaXMgbG93IG9uIGRhdGEgKi8KCWlmIChlaXIgJiBFSVJfVFhMRExfRVYpIHsKCQkvKiBXcml0ZSBkYXRhIGxlZnQgaW4gdHJhbnNtaXQgYnVmZmVyICovCgkJYWN0dWFsID0gbnNjX2lyY2NfcGlvX3dyaXRlKHNlbGYtPmlvLmZpcl9iYXNlLCAKCQkJCQkgICBzZWxmLT50eF9idWZmLmRhdGEsIAoJCQkJCSAgIHNlbGYtPnR4X2J1ZmYubGVuLCAKCQkJCQkgICBzZWxmLT5pby5maWZvX3NpemUpOwoJCXNlbGYtPnR4X2J1ZmYuZGF0YSArPSBhY3R1YWw7CgkJc2VsZi0+dHhfYnVmZi5sZW4gIC09IGFjdHVhbDsKCQkKCQlzZWxmLT5pby5kaXJlY3Rpb24gPSBJT19YTUlUOwoKCQkvKiBDaGVjayBpZiBmaW5pc2hlZCAqLwoJCWlmIChzZWxmLT50eF9idWZmLmxlbiA+IDApCgkJCXNlbGYtPmllciA9IElFUl9UWExETF9JRTsKCQllbHNlIHsgCgoJCQlzZWxmLT5zdGF0cy50eF9wYWNrZXRzKys7CgkJCW5ldGlmX3dha2VfcXVldWUoc2VsZi0+bmV0ZGV2KTsKCQkJc2VsZi0+aWVyID0gSUVSX1RYRU1QX0lFOwoJCX0KCQkJCgl9CgkvKiBDaGVjayBpZiB0cmFuc21pc3Npb24gaGFzIGNvbXBsZXRlZCAqLwoJaWYgKGVpciAmIEVJUl9UWEVNUF9FVikgewoJCS8qIFR1cm4gYXJvdW5kIGFuZCBnZXQgcmVhZHkgdG8gcmVjZWl2ZSBzb21lIGRhdGEgKi8KCQlzZWxmLT5pby5kaXJlY3Rpb24gPSBJT19SRUNWOwoJCXNlbGYtPmllciA9IElFUl9SWEhETF9JRTsKCQkvKiBDaGVjayBpZiB3ZSBuZWVkIHRvIGNoYW5nZSB0aGUgc3BlZWQ/CgkJICogTmVlZCB0byBiZSBhZnRlciBzZWxmLT5pby5kaXJlY3Rpb24gdG8gYXZvaWQgcmFjZSB3aXRoCgkJICogbnNjX2lyY2NfaGFyZF94bWl0X3NpcigpIC0gSmVhbiBJSSAqLwoJCWlmIChzZWxmLT5uZXdfc3BlZWQpIHsKCQkJSVJEQV9ERUJVRygyLCAiJXMoKSwgQ2hhbmdpbmcgc3BlZWQhXG4iLCBfX0ZVTkNUSU9OX18pOwoJCQlzZWxmLT5pZXIgPSBuc2NfaXJjY19jaGFuZ2Vfc3BlZWQoc2VsZiwKCQkJCQkJCSAgc2VsZi0+bmV3X3NwZWVkKTsKCQkJc2VsZi0+bmV3X3NwZWVkID0gMDsKCQkJbmV0aWZfd2FrZV9xdWV1ZShzZWxmLT5uZXRkZXYpOwoKCQkJLyogQ2hlY2sgaWYgd2UgYXJlIGdvaW5nIHRvIEZJUiAqLwoJCQlpZiAoc2VsZi0+aW8uc3BlZWQgPiAxMTUyMDApIHsKCQkJCS8qIE5vIG5lZWQgdG8gZG8gYW55bW9yZSBTSVIgc3R1ZmYgKi8KCQkJCXJldHVybjsKCQkJfQoJCX0KCX0KCgkvKiBSeCBGSUZPIHRocmVzaG9sZCBvciB0aW1lb3V0ICovCglpZiAoZWlyICYgRUlSX1JYSERMX0VWKSB7CgkJbnNjX2lyY2NfcGlvX3JlY2VpdmUoc2VsZik7CgoJCS8qIEtlZXAgcmVjZWl2aW5nICovCgkJc2VsZi0+aWVyID0gSUVSX1JYSERMX0lFOwoJfQp9CgovKgogKiBGdW5jdGlvbiBuc2NfaXJjY19maXJfaW50ZXJydXB0IChzZWxmLCBlaXIpCiAqCiAqICAgIEhhbmRsZSBNSVIvRklSIGludGVycnVwdAogKgogKi8Kc3RhdGljIHZvaWQgbnNjX2lyY2NfZmlyX2ludGVycnVwdChzdHJ1Y3QgbnNjX2lyY2NfY2IgKnNlbGYsIGludCBpb2Jhc2UsIAoJCQkJICAgaW50IGVpcikKewoJX191OCBiYW5rOwoKCWJhbmsgPSBpbmIoaW9iYXNlK0JTUik7CgkKCS8qIFN0YXR1cyBGSUZPIGV2ZW50Ki8KCWlmIChlaXIgJiBFSVJfU0ZJRl9FVikgewoJCS8qIENoZWNrIGlmIERNQSBoYXMgZmluaXNoZWQgKi8KCQlpZiAobnNjX2lyY2NfZG1hX3JlY2VpdmVfY29tcGxldGUoc2VsZiwgaW9iYXNlKSkgewoJCQkvKiBXYWl0IGZvciBuZXh0IHN0YXR1cyBGSUZPIGludGVycnVwdCAqLwoJCQlzZWxmLT5pZXIgPSBJRVJfU0ZJRl9JRTsKCQl9IGVsc2UgewoJCQlzZWxmLT5pZXIgPSBJRVJfU0ZJRl9JRSB8IElFUl9UTVJfSUU7CgkJfQoJfSBlbHNlIGlmIChlaXIgJiBFSVJfVE1SX0VWKSB7IC8qIFRpbWVyIGZpbmlzaGVkICovCgkJLyogRGlzYWJsZSB0aW1lciAqLwoJCXN3aXRjaF9iYW5rKGlvYmFzZSwgQkFOSzQpOwoJCW91dGIoMCwgaW9iYXNlK0lSQ1IxKTsKCgkJLyogQ2xlYXIgdGltZXIgZXZlbnQgKi8KCQlzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTkswKTsKCQlvdXRiKEFTQ1JfQ1RFLCBpb2Jhc2UrQVNDUik7CgoJCS8qIENoZWNrIGlmIHRoaXMgaXMgYSBUeCB0aW1lciBpbnRlcnJ1cHQgKi8KCQlpZiAoc2VsZi0+aW8uZGlyZWN0aW9uID09IElPX1hNSVQpIHsKCQkJbnNjX2lyY2NfZG1hX3htaXQoc2VsZiwgaW9iYXNlKTsKCgkJCS8qIEludGVycnVwdCBvbiBETUEgKi8KCQkJc2VsZi0+aWVyID0gSUVSX0RNQV9JRTsKCQl9IGVsc2UgewoJCQkvKiBDaGVjayAoYWdhaW4pIGlmIERNQSBoYXMgZmluaXNoZWQgKi8KCQkJaWYgKG5zY19pcmNjX2RtYV9yZWNlaXZlX2NvbXBsZXRlKHNlbGYsIGlvYmFzZSkpIHsKCQkJCXNlbGYtPmllciA9IElFUl9TRklGX0lFOwoJCQl9IGVsc2UgewoJCQkJc2VsZi0+aWVyID0gSUVSX1NGSUZfSUUgfCBJRVJfVE1SX0lFOwoJCQl9CgkJfQoJfSBlbHNlIGlmIChlaXIgJiBFSVJfRE1BX0VWKSB7CgkJLyogRmluaXNoZWQgd2l0aCBhbGwgdHJhbnNtaXNzaW9ucz8gKi8KCQlpZiAobnNjX2lyY2NfZG1hX3htaXRfY29tcGxldGUoc2VsZikpIHsKCQkJaWYoc2VsZi0+bmV3X3NwZWVkICE9IDApIHsKCQkJCS8qIEFzIHdlIHN0b3AgdGhlIFR4IHF1ZXVlLCB0aGUgc3BlZWQgY2hhbmdlCgkJCQkgKiBuZWVkIHRvIGJlIGRvbmUgd2hlbiB0aGUgVHggZmlmbyBpcwoJCQkJICogZW1wdHkuIEFzayBmb3IgYSBUeCBkb25lIGludGVycnVwdCAqLwoJCQkJc2VsZi0+aWVyID0gSUVSX1RYRU1QX0lFOwoJCQl9IGVsc2UgewoJCQkJLyogQ2hlY2sgaWYgdGhlcmUgYXJlIG1vcmUgZnJhbWVzIHRvIGJlCgkJCQkgKiB0cmFuc21pdHRlZCAqLwoJCQkJaWYgKGlyZGFfZGV2aWNlX3R4cXVldWVfZW1wdHkoc2VsZi0+bmV0ZGV2KSkgewoJCQkJCS8qIFByZXBhcmUgZm9yIHJlY2VpdmUgKi8KCQkJCQluc2NfaXJjY19kbWFfcmVjZWl2ZShzZWxmKTsKCQkJCQlzZWxmLT5pZXIgPSBJRVJfU0ZJRl9JRTsKCQkJCX0gZWxzZQoJCQkJCUlSREFfV0FSTklORygiJXMoKSwgcG90ZW50aWFsICIKCQkJCQkJICAgICAiVHggcXVldWUgbG9ja3VwICFcbiIsCgkJCQkJCSAgICAgX19GVU5DVElPTl9fKTsKCQkJfQoJCX0gZWxzZSB7CgkJCS8qICBOb3QgZmluaXNoZWQgeWV0LCBzbyBpbnRlcnJ1cHQgb24gRE1BIGFnYWluICovCgkJCXNlbGYtPmllciA9IElFUl9ETUFfSUU7CgkJfQoJfSBlbHNlIGlmIChlaXIgJiBFSVJfVFhFTVBfRVYpIHsKCQkvKiBUaGUgVHggRklGTyBoYXMgdG90YWxseSBkcmFpbmVkIG91dCwgc28gbm93IHdlIGNhbiBjaGFuZ2UKCQkgKiB0aGUgc3BlZWQuLi4gLSBKZWFuIElJICovCgkJc2VsZi0+aWVyID0gbnNjX2lyY2NfY2hhbmdlX3NwZWVkKHNlbGYsIHNlbGYtPm5ld19zcGVlZCk7CgkJc2VsZi0+bmV3X3NwZWVkID0gMDsKCQluZXRpZl93YWtlX3F1ZXVlKHNlbGYtPm5ldGRldik7CgkJLyogTm90ZSA6IG5zY19pcmNjX2NoYW5nZV9zcGVlZCgpIHJlc3RhcnRlZCBSeCBmaWZvICovCgl9CgoJb3V0YihiYW5rLCBpb2Jhc2UrQlNSKTsKfQoKLyoKICogRnVuY3Rpb24gbnNjX2lyY2NfaW50ZXJydXB0IChpcnEsIGRldl9pZCwgcmVncykKICoKICogICAgQW4gaW50ZXJydXB0IGZyb20gdGhlIGNoaXAgaGFzIGFycml2ZWQuIFRpbWUgdG8gZG8gc29tZSB3b3JrCiAqCiAqLwpzdGF0aWMgaXJxcmV0dXJuX3QgbnNjX2lyY2NfaW50ZXJydXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCwKCQkJCXN0cnVjdCBwdF9yZWdzICpyZWdzKQp7CglzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gKHN0cnVjdCBuZXRfZGV2aWNlICopIGRldl9pZDsKCXN0cnVjdCBuc2NfaXJjY19jYiAqc2VsZjsKCV9fdTggYnNyLCBlaXI7CglpbnQgaW9iYXNlOwoKCWlmICghZGV2KSB7CgkJSVJEQV9XQVJOSU5HKCIlczogaXJxICVkIGZvciB1bmtub3duIGRldmljZS5cbiIsCgkJCSAgICAgZHJpdmVyX25hbWUsIGlycSk7CgkJcmV0dXJuIElSUV9OT05FOwoJfQoJc2VsZiA9IChzdHJ1Y3QgbnNjX2lyY2NfY2IgKikgZGV2LT5wcml2OwoKCXNwaW5fbG9jaygmc2VsZi0+bG9jayk7CQoKCWlvYmFzZSA9IHNlbGYtPmlvLmZpcl9iYXNlOwoKCWJzciA9IGluYihpb2Jhc2UrQlNSKTsgCS8qIFNhdmUgY3VycmVudCBiYW5rICovCgoJc3dpdGNoX2JhbmsoaW9iYXNlLCBCQU5LMCk7CQoJc2VsZi0+aWVyID0gaW5iKGlvYmFzZStJRVIpOyAKCWVpciA9IGluYihpb2Jhc2UrRUlSKSAmIHNlbGYtPmllcjsgLyogTWFzayBvdXQgdGhlIGludGVyZXN0aW5nIG9uZXMgKi8gCgoJb3V0YigwLCBpb2Jhc2UrSUVSKTsgLyogRGlzYWJsZSBpbnRlcnJ1cHRzICovCgkKCWlmIChlaXIpIHsKCQkvKiBEaXNwYXRjaCBpbnRlcnJ1cHQgaGFuZGxlciBmb3IgdGhlIGN1cnJlbnQgc3BlZWQgKi8KCQlpZiAoc2VsZi0+aW8uc3BlZWQgPiAxMTUyMDApCgkJCW5zY19pcmNjX2Zpcl9pbnRlcnJ1cHQoc2VsZiwgaW9iYXNlLCBlaXIpOwoJCWVsc2UKCQkJbnNjX2lyY2Nfc2lyX2ludGVycnVwdChzZWxmLCBlaXIpOwoJfQoJCglvdXRiKHNlbGYtPmllciwgaW9iYXNlK0lFUik7IC8qIFJlc3RvcmUgaW50ZXJydXB0cyAqLwoJb3V0Yihic3IsIGlvYmFzZStCU1IpOyAgICAgICAvKiBSZXN0b3JlIGJhbmsgcmVnaXN0ZXIgKi8KCglzcGluX3VubG9jaygmc2VsZi0+bG9jayk7CglyZXR1cm4gSVJRX1JFVFZBTChlaXIpOwp9CgovKgogKiBGdW5jdGlvbiBuc2NfaXJjY19pc19yZWNlaXZpbmcgKHNlbGYpCiAqCiAqICAgIFJldHVybiBUUlVFIGlzIHdlIGFyZSBjdXJyZW50bHkgcmVjZWl2aW5nIGEgZnJhbWUKICoKICovCnN0YXRpYyBpbnQgbnNjX2lyY2NfaXNfcmVjZWl2aW5nKHN0cnVjdCBuc2NfaXJjY19jYiAqc2VsZikKewoJdW5zaWduZWQgbG9uZyBmbGFnczsKCWludCBzdGF0dXMgPSBGQUxTRTsKCWludCBpb2Jhc2U7CglfX3U4IGJhbms7CgoJSVJEQV9BU1NFUlQoc2VsZiAhPSBOVUxMLCByZXR1cm4gRkFMU0U7KTsKCglzcGluX2xvY2tfaXJxc2F2ZSgmc2VsZi0+bG9jaywgZmxhZ3MpOwoKCWlmIChzZWxmLT5pby5zcGVlZCA+IDExNTIwMCkgewoJCWlvYmFzZSA9IHNlbGYtPmlvLmZpcl9iYXNlOwoKCQkvKiBDaGVjayBpZiByeCBGSUZPIGlzIG5vdCBlbXB0eSAqLwoJCWJhbmsgPSBpbmIoaW9iYXNlK0JTUik7CgkJc3dpdGNoX2JhbmsoaW9iYXNlLCBCQU5LMik7CgkJaWYgKChpbmIoaW9iYXNlK1JYRkxWKSAmIDB4M2YpICE9IDApIHsKCQkJLyogV2UgYXJlIHJlY2VpdmluZyBzb21ldGhpbmcgKi8KCQkJc3RhdHVzID0gIFRSVUU7CgkJfQoJCW91dGIoYmFuaywgaW9iYXNlK0JTUik7Cgl9IGVsc2UgCgkJc3RhdHVzID0gKHNlbGYtPnJ4X2J1ZmYuc3RhdGUgIT0gT1VUU0lERV9GUkFNRSk7CgkKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnNlbGYtPmxvY2ssIGZsYWdzKTsKCglyZXR1cm4gc3RhdHVzOwp9CgovKgogKiBGdW5jdGlvbiBuc2NfaXJjY19uZXRfb3BlbiAoZGV2KQogKgogKiAgICBTdGFydCB0aGUgZGV2aWNlCiAqCiAqLwpzdGF0aWMgaW50IG5zY19pcmNjX25ldF9vcGVuKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBuc2NfaXJjY19jYiAqc2VsZjsKCWludCBpb2Jhc2U7CgljaGFyIGh3bmFtZVszMl07CglfX3U4IGJhbms7CgkKCUlSREFfREVCVUcoNCwgIiVzKClcbiIsIF9fRlVOQ1RJT05fXyk7CgkKCUlSREFfQVNTRVJUKGRldiAhPSBOVUxMLCByZXR1cm4gLTE7KTsKCXNlbGYgPSAoc3RydWN0IG5zY19pcmNjX2NiICopIGRldi0+cHJpdjsKCQoJSVJEQV9BU1NFUlQoc2VsZiAhPSBOVUxMLCByZXR1cm4gMDspOwoJCglpb2Jhc2UgPSBzZWxmLT5pby5maXJfYmFzZTsKCQoJaWYgKHJlcXVlc3RfaXJxKHNlbGYtPmlvLmlycSwgbnNjX2lyY2NfaW50ZXJydXB0LCAwLCBkZXYtPm5hbWUsIGRldikpIHsKCQlJUkRBX1dBUk5JTkcoIiVzLCB1bmFibGUgdG8gYWxsb2NhdGUgaXJxPSVkXG4iLAoJCQkgICAgIGRyaXZlcl9uYW1lLCBzZWxmLT5pby5pcnEpOwoJCXJldHVybiAtRUFHQUlOOwoJfQoJLyoKCSAqIEFsd2F5cyBhbGxvY2F0ZSB0aGUgRE1BIGNoYW5uZWwgYWZ0ZXIgdGhlIElSUSwgYW5kIGNsZWFuIHVwIG9uIAoJICogZmFpbHVyZS4KCSAqLwoJaWYgKHJlcXVlc3RfZG1hKHNlbGYtPmlvLmRtYSwgZGV2LT5uYW1lKSkgewoJCUlSREFfV0FSTklORygiJXMsIHVuYWJsZSB0byBhbGxvY2F0ZSBkbWE9JWRcbiIsCgkJCSAgICAgZHJpdmVyX25hbWUsIHNlbGYtPmlvLmRtYSk7CgkJZnJlZV9pcnEoc2VsZi0+aW8uaXJxLCBkZXYpOwoJCXJldHVybiAtRUFHQUlOOwoJfQoJCgkvKiBTYXZlIGN1cnJlbnQgYmFuayAqLwoJYmFuayA9IGluYihpb2Jhc2UrQlNSKTsKCQoJLyogdHVybiBvbiBpbnRlcnJ1cHRzICovCglzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTkswKTsKCW91dGIoSUVSX0xTX0lFIHwgSUVSX1JYSERMX0lFLCBpb2Jhc2UrSUVSKTsKCgkvKiBSZXN0b3JlIGJhbmsgcmVnaXN0ZXIgKi8KCW91dGIoYmFuaywgaW9iYXNlK0JTUik7CgoJLyogUmVhZHkgdG8gcGxheSEgKi8KCW5ldGlmX3N0YXJ0X3F1ZXVlKGRldik7CgkKCS8qIEdpdmUgc2VsZiBhIGhhcmR3YXJlIG5hbWUgKi8KCXNwcmludGYoaHduYW1lLCAiTlNDLUZJUiBAIDB4JTAzeCIsIHNlbGYtPmlvLmZpcl9iYXNlKTsKCgkvKiAKCSAqIE9wZW4gbmV3IElyTEFQIGxheWVyIGluc3RhbmNlLCBub3cgdGhhdCBldmVyeXRoaW5nIHNob3VsZCBiZQoJICogaW5pdGlhbGl6ZWQgcHJvcGVybHkgCgkgKi8KCXNlbGYtPmlybGFwID0gaXJsYXBfb3BlbihkZXYsICZzZWxmLT5xb3MsIGh3bmFtZSk7CgoJcmV0dXJuIDA7Cn0KCi8qCiAqIEZ1bmN0aW9uIG5zY19pcmNjX25ldF9jbG9zZSAoZGV2KQogKgogKiAgICBTdG9wIHRoZSBkZXZpY2UKICoKICovCnN0YXRpYyBpbnQgbnNjX2lyY2NfbmV0X2Nsb3NlKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBuc2NfaXJjY19jYiAqc2VsZjsKCWludCBpb2Jhc2U7CglfX3U4IGJhbms7CgoJSVJEQV9ERUJVRyg0LCAiJXMoKVxuIiwgX19GVU5DVElPTl9fKTsKCQoJSVJEQV9BU1NFUlQoZGV2ICE9IE5VTEwsIHJldHVybiAtMTspOwoKCXNlbGYgPSAoc3RydWN0IG5zY19pcmNjX2NiICopIGRldi0+cHJpdjsKCUlSREFfQVNTRVJUKHNlbGYgIT0gTlVMTCwgcmV0dXJuIDA7KTsKCgkvKiBTdG9wIGRldmljZSAqLwoJbmV0aWZfc3RvcF9xdWV1ZShkZXYpOwoJCgkvKiBTdG9wIGFuZCByZW1vdmUgaW5zdGFuY2Ugb2YgSXJMQVAgKi8KCWlmIChzZWxmLT5pcmxhcCkKCQlpcmxhcF9jbG9zZShzZWxmLT5pcmxhcCk7CglzZWxmLT5pcmxhcCA9IE5VTEw7CgkKCWlvYmFzZSA9IHNlbGYtPmlvLmZpcl9iYXNlOwoKCWRpc2FibGVfZG1hKHNlbGYtPmlvLmRtYSk7CgoJLyogU2F2ZSBjdXJyZW50IGJhbmsgKi8KCWJhbmsgPSBpbmIoaW9iYXNlK0JTUik7CgoJLyogRGlzYWJsZSBpbnRlcnJ1cHRzICovCglzd2l0Y2hfYmFuayhpb2Jhc2UsIEJBTkswKTsKCW91dGIoMCwgaW9iYXNlK0lFUik7IAogICAgICAgCglmcmVlX2lycShzZWxmLT5pby5pcnEsIGRldik7CglmcmVlX2RtYShzZWxmLT5pby5kbWEpOwoKCS8qIFJlc3RvcmUgYmFuayByZWdpc3RlciAqLwoJb3V0YihiYW5rLCBpb2Jhc2UrQlNSKTsKCglyZXR1cm4gMDsKfQoKLyoKICogRnVuY3Rpb24gbnNjX2lyY2NfbmV0X2lvY3RsIChkZXYsIHJxLCBjbWQpCiAqCiAqICAgIFByb2Nlc3MgSU9DVEwgY29tbWFuZHMgZm9yIHRoaXMgZGV2aWNlCiAqCiAqLwpzdGF0aWMgaW50IG5zY19pcmNjX25ldF9pb2N0bChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3QgaWZyZXEgKnJxLCBpbnQgY21kKQp7CglzdHJ1Y3QgaWZfaXJkYV9yZXEgKmlycSA9IChzdHJ1Y3QgaWZfaXJkYV9yZXEgKikgcnE7CglzdHJ1Y3QgbnNjX2lyY2NfY2IgKnNlbGY7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJaW50IHJldCA9IDA7CgoJSVJEQV9BU1NFUlQoZGV2ICE9IE5VTEwsIHJldHVybiAtMTspOwoKCXNlbGYgPSBkZXYtPnByaXY7CgoJSVJEQV9BU1NFUlQoc2VsZiAhPSBOVUxMLCByZXR1cm4gLTE7KTsKCglJUkRBX0RFQlVHKDIsICIlcygpLCAlcywgKGNtZD0weCVYKVxuIiwgX19GVU5DVElPTl9fLCBkZXYtPm5hbWUsIGNtZCk7CgkKCXN3aXRjaCAoY21kKSB7CgljYXNlIFNJT0NTQkFORFdJRFRIOiAvKiBTZXQgYmFuZHdpZHRoICovCgkJaWYgKCFjYXBhYmxlKENBUF9ORVRfQURNSU4pKSB7CgkJCXJldCA9IC1FUEVSTTsKCQkJYnJlYWs7CgkJfQoJCXNwaW5fbG9ja19pcnFzYXZlKCZzZWxmLT5sb2NrLCBmbGFncyk7CgkJbnNjX2lyY2NfY2hhbmdlX3NwZWVkKHNlbGYsIGlycS0+aWZyX2JhdWRyYXRlKTsKCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzZWxmLT5sb2NrLCBmbGFncyk7CgkJYnJlYWs7CgljYXNlIFNJT0NTTUVESUFCVVNZOiAvKiBTZXQgbWVkaWEgYnVzeSAqLwoJCWlmICghY2FwYWJsZShDQVBfTkVUX0FETUlOKSkgewoJCQlyZXQgPSAtRVBFUk07CgkJCWJyZWFrOwoJCX0KCQlpcmRhX2RldmljZV9zZXRfbWVkaWFfYnVzeShzZWxmLT5uZXRkZXYsIFRSVUUpOwoJCWJyZWFrOwoJY2FzZSBTSU9DR1JFQ0VJVklORzogLyogQ2hlY2sgaWYgd2UgYXJlIHJlY2VpdmluZyByaWdodCBub3cgKi8KCQkvKiBUaGlzIGlzIGFscmVhZHkgcHJvdGVjdGVkICovCgkJaXJxLT5pZnJfcmVjZWl2aW5nID0gbnNjX2lyY2NfaXNfcmVjZWl2aW5nKHNlbGYpOwoJCWJyZWFrOwoJZGVmYXVsdDoKCQlyZXQgPSAtRU9QTk9UU1VQUDsKCX0KCXJldHVybiByZXQ7Cn0KCnN0YXRpYyBzdHJ1Y3QgbmV0X2RldmljZV9zdGF0cyAqbnNjX2lyY2NfbmV0X2dldF9zdGF0cyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQp7CglzdHJ1Y3QgbnNjX2lyY2NfY2IgKnNlbGYgPSAoc3RydWN0IG5zY19pcmNjX2NiICopIGRldi0+cHJpdjsKCQoJcmV0dXJuICZzZWxmLT5zdGF0czsKfQoKc3RhdGljIHZvaWQgbnNjX2lyY2Nfc3VzcGVuZChzdHJ1Y3QgbnNjX2lyY2NfY2IgKnNlbGYpCnsKCUlSREFfTUVTU0FHRSgiJXMsIFN1c3BlbmRpbmdcbiIsIGRyaXZlcl9uYW1lKTsKCglpZiAoc2VsZi0+aW8uc3VzcGVuZGVkKQoJCXJldHVybjsKCgluc2NfaXJjY19uZXRfY2xvc2Uoc2VsZi0+bmV0ZGV2KTsKCglzZWxmLT5pby5zdXNwZW5kZWQgPSAxOwp9CgpzdGF0aWMgdm9pZCBuc2NfaXJjY193YWtldXAoc3RydWN0IG5zY19pcmNjX2NiICpzZWxmKQp7CglpZiAoIXNlbGYtPmlvLnN1c3BlbmRlZCkKCQlyZXR1cm47CgoJbnNjX2lyY2Nfc2V0dXAoJnNlbGYtPmlvKTsKCW5zY19pcmNjX25ldF9vcGVuKHNlbGYtPm5ldGRldik7CgkKCUlSREFfTUVTU0FHRSgiJXMsIFdha2luZyB1cFxuIiwgZHJpdmVyX25hbWUpOwoKCXNlbGYtPmlvLnN1c3BlbmRlZCA9IDA7Cn0KCnN0YXRpYyBpbnQgbnNjX2lyY2NfcG1wcm9jKHN0cnVjdCBwbV9kZXYgKmRldiwgcG1fcmVxdWVzdF90IHJxc3QsIHZvaWQgKmRhdGEpCnsKICAgICAgICBzdHJ1Y3QgbnNjX2lyY2NfY2IgKnNlbGYgPSAoc3RydWN0IG5zY19pcmNjX2NiKikgZGV2LT5kYXRhOwogICAgICAgIGlmIChzZWxmKSB7CiAgICAgICAgICAgICAgICBzd2l0Y2ggKHJxc3QpIHsKICAgICAgICAgICAgICAgIGNhc2UgUE1fU1VTUEVORDoKICAgICAgICAgICAgICAgICAgICAgICAgbnNjX2lyY2Nfc3VzcGVuZChzZWxmKTsKICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAgICAgICBjYXNlIFBNX1JFU1VNRToKICAgICAgICAgICAgICAgICAgICAgICAgbnNjX2lyY2Nfd2FrZXVwKHNlbGYpOwogICAgICAgICAgICAgICAgICAgICAgICBicmVhazsKICAgICAgICAgICAgICAgIH0KICAgICAgICB9CglyZXR1cm4gMDsKfQoKTU9EVUxFX0FVVEhPUigiRGFnIEJyYXR0bGkgPGRhZ2JAY3MudWl0Lm5vPiIpOwpNT0RVTEVfREVTQ1JJUFRJT04oIk5TQyBJckRBIERldmljZSBEcml2ZXIiKTsKTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwoKCm1vZHVsZV9wYXJhbShxb3NfbXR0X2JpdHMsIGludCwgMCk7Ck1PRFVMRV9QQVJNX0RFU0MocW9zX210dF9iaXRzLCAiTWluaW11bSBUdXJuIFRpbWUiKTsKbW9kdWxlX3BhcmFtX2FycmF5KGlvLCBpbnQsIE5VTEwsIDApOwpNT0RVTEVfUEFSTV9ERVNDKGlvLCAiQmFzZSBJL08gYWRkcmVzc2VzIik7Cm1vZHVsZV9wYXJhbV9hcnJheShpcnEsIGludCwgTlVMTCwgMCk7Ck1PRFVMRV9QQVJNX0RFU0MoaXJxLCAiSVJRIGxpbmVzIik7Cm1vZHVsZV9wYXJhbV9hcnJheShkbWEsIGludCwgTlVMTCwgMCk7Ck1PRFVMRV9QQVJNX0RFU0MoZG1hLCAiRE1BIGNoYW5uZWxzIik7Cm1vZHVsZV9wYXJhbShkb25nbGVfaWQsIGludCwgMCk7Ck1PRFVMRV9QQVJNX0RFU0MoZG9uZ2xlX2lkLCAiVHlwZS1pZCBvZiB1c2VkIGRvbmdsZSIpOwoKbW9kdWxlX2luaXQobnNjX2lyY2NfaW5pdCk7Cm1vZHVsZV9leGl0KG5zY19pcmNjX2NsZWFudXApOwoK