LyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgogKiBGaWxlbmFtZTogICAgICBpcmxhcF9mcmFtZS5jCiAqIFZlcnNpb246ICAgICAgIDEuMAogKiBEZXNjcmlwdGlvbjogICBCdWlsZCBhbmQgdHJhbnNtaXQgSXJMQVAgZnJhbWVzCiAqIFN0YXR1czogICAgICAgIFN0YWJsZQogKiBBdXRob3I6ICAgICAgICBEYWcgQnJhdHRsaSA8ZGFnYkBjcy51aXQubm8+CiAqIENyZWF0ZWQgYXQ6ICAgIFR1ZSBBdWcgMTkgMTA6Mjc6MjYgMTk5NwogKiBNb2RpZmllZCBhdDogICBXZWQgSmFuICA1IDA4OjU5OjA0IDIwMDAKICogTW9kaWZpZWQgYnk6ICAgRGFnIEJyYXR0bGkgPGRhZ2JAY3MudWl0Lm5vPgogKgogKiAgICAgQ29weXJpZ2h0IChjKSAxOTk4LTIwMDAgRGFnIEJyYXR0bGkgPGRhZ2JAY3MudWl0Lm5vPiwKICogICAgIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAqICAgICBDb3B5cmlnaHQgKGMpIDIwMDAtMjAwMyBKZWFuIFRvdXJyaWxoZXMgPGp0QGhwbC5ocC5jb20+CiAqCiAqICAgICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAqICAgICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcwogKiAgICAgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YKICogICAgIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgogKgogKiAgICAgTmVpdGhlciBEYWcgQnJhdHRsaSBub3IgVW5pdmVyc2l0eSBvZiBUcm9tc/ggYWRtaXQgbGlhYmlsaXR5IG5vcgogKiAgICAgcHJvdmlkZSB3YXJyYW50eSBmb3IgYW55IG9mIHRoaXMgc29mdHdhcmUuIFRoaXMgbWF0ZXJpYWwgaXMKICogICAgIHByb3ZpZGVkICJBUy1JUyIgYW5kIGF0IG5vIGNoYXJnZS4KICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKI2luY2x1ZGUgPGxpbnV4L3NrYnVmZi5oPgojaW5jbHVkZSA8bGludXgvaWYuaD4KI2luY2x1ZGUgPGxpbnV4L2lmX2V0aGVyLmg+CiNpbmNsdWRlIDxsaW51eC9uZXRkZXZpY2UuaD4KI2luY2x1ZGUgPGxpbnV4L2lyZGEuaD4KCiNpbmNsdWRlIDxuZXQvcGt0X3NjaGVkLmg+CiNpbmNsdWRlIDxuZXQvc29jay5oPgoKI2luY2x1ZGUgPGFzbS9ieXRlb3JkZXIuaD4KCiNpbmNsdWRlIDxuZXQvaXJkYS9pcmRhLmg+CiNpbmNsdWRlIDxuZXQvaXJkYS9pcmRhX2RldmljZS5oPgojaW5jbHVkZSA8bmV0L2lyZGEvaXJsYXAuaD4KI2luY2x1ZGUgPG5ldC9pcmRhL3dyYXBwZXIuaD4KI2luY2x1ZGUgPG5ldC9pcmRhL3RpbWVyLmg+CiNpbmNsdWRlIDxuZXQvaXJkYS9pcmxhcF9mcmFtZS5oPgojaW5jbHVkZSA8bmV0L2lyZGEvcW9zLmg+CgpzdGF0aWMgdm9pZCBpcmxhcF9zZW5kX2lfZnJhbWUoc3RydWN0IGlybGFwX2NiICpzZWxmLCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAoJCQkgICAgICAgaW50IGNvbW1hbmQpOwoKLyoKICogRnVuY3Rpb24gaXJsYXBfaW5zZXJ0X2luZm8gKHNlbGYsIHNrYikKICoKICogICAgSW5zZXJ0IG1pbmltdW0gdHVybmFyb3VuZCB0aW1lIGFuZCBzcGVlZCBpbmZvcm1hdGlvbiBpbnRvIHRoZSBza2IuIFdlCiAqICAgIG5lZWQgdG8gZG8gdGhpcyBzaW5jZSBpdCdzIHBlciBwYWNrZXQgcmVsZXZhbnQgaW5mb3JtYXRpb24uIFNhZmUgdG8KICogICAgaGF2ZSB0aGlzIGZ1bmN0aW9uIGlubGluZWQgc2luY2UgaXQncyBvbmx5IGNhbGxlZCBmcm9tIG9uZSBwbGFjZQogKi8Kc3RhdGljIGlubGluZSB2b2lkIGlybGFwX2luc2VydF9pbmZvKHN0cnVjdCBpcmxhcF9jYiAqc2VsZiwKCQkJCSAgICAgc3RydWN0IHNrX2J1ZmYgKnNrYikKewoJc3RydWN0IGlyZGFfc2tiX2NiICpjYiA9IChzdHJ1Y3QgaXJkYV9za2JfY2IgKikgc2tiLT5jYjsKCgkvKgoJICogSW5zZXJ0IE1UVCAobWluLiB0dXJuIHRpbWUpIGFuZCBzcGVlZCBpbnRvIHNrYiwgc28gdGhhdCB0aGUKCSAqIGRldmljZSBkcml2ZXIga25vd3Mgd2hpY2ggc2V0dGluZ3MgdG8gdXNlCgkgKi8KCWNiLT5tYWdpYyA9IExBUF9NQUdJQzsKCWNiLT5tdHQgPSBzZWxmLT5tdHRfcmVxdWlyZWQ7CgljYi0+bmV4dF9zcGVlZCA9IHNlbGYtPnNwZWVkOwoKCS8qIFJlc2V0ICovCglzZWxmLT5tdHRfcmVxdWlyZWQgPSAwOwoKCS8qCgkgKiBEZWxheSBlcXVhbHMgbmVnb3RpYXRlZCBCT0ZzIGNvdW50LCBwbHVzIHRoZSBudW1iZXIgb2YgQk9GcyB0bwoJICogZm9yY2UgdGhlIG5lZ290aWF0ZWQgbWluaW11bSB0dXJuYXJvdW5kIHRpbWUKCSAqLwoJY2ItPnhib2ZzID0gc2VsZi0+Ym9mc19jb3VudDsKCWNiLT5uZXh0X3hib2ZzID0gc2VsZi0+bmV4dF9ib2ZzOwoJY2ItPnhib2ZzX2RlbGF5ID0gc2VsZi0+eGJvZnNfZGVsYXk7CgoJLyogUmVzZXQgWEJPRidzIGRlbGF5ICh1c2VkIG9ubHkgZm9yIGdldHRpbmcgbWluIHR1cm4gdGltZSkgKi8KCXNlbGYtPnhib2ZzX2RlbGF5ID0gMDsKCS8qIFB1dCB0aGUgY29ycmVjdCB4Ym9mcyB2YWx1ZSBmb3IgdGhlIG5leHQgcGFja2V0ICovCglzZWxmLT5ib2ZzX2NvdW50ID0gc2VsZi0+bmV4dF9ib2ZzOwp9CgovKgogKiBGdW5jdGlvbiBpcmxhcF9xdWV1ZV94bWl0IChzZWxmLCBza2IpCiAqCiAqICAgIEEgbGl0dGxlIHdyYXBwZXIgZm9yIGRldl9xdWV1ZV94bWl0LCBzbyB3ZSBjYW4gaW5zZXJ0IHNvbWUgY29tbW9uCiAqICAgIGNvZGUgaW50byBpdC4KICovCnZvaWQgaXJsYXBfcXVldWVfeG1pdChzdHJ1Y3QgaXJsYXBfY2IgKnNlbGYsIHN0cnVjdCBza19idWZmICpza2IpCnsKCS8qIFNvbWUgY29tbW9uIGluaXQgc3R1ZmYgKi8KCXNrYi0+ZGV2ID0gc2VsZi0+bmV0ZGV2OwoJc2tiX3Jlc2V0X21hY19oZWFkZXIoc2tiKTsKCXNrYl9yZXNldF9uZXR3b3JrX2hlYWRlcihza2IpOwoJc2tiX3Jlc2V0X3RyYW5zcG9ydF9oZWFkZXIoc2tiKTsKCXNrYi0+cHJvdG9jb2wgPSBodG9ucyhFVEhfUF9JUkRBKTsKCXNrYi0+cHJpb3JpdHkgPSBUQ19QUklPX0JFU1RFRkZPUlQ7CgoJaXJsYXBfaW5zZXJ0X2luZm8oc2VsZiwgc2tiKTsKCglkZXZfcXVldWVfeG1pdChza2IpOwp9CgovKgogKiBGdW5jdGlvbiBpcmxhcF9zZW5kX3Nucm1fY21kICh2b2lkKQogKgogKiAgICBUcmFuc21pdHMgYSBjb25uZWN0IFNOUk0gY29tbWFuZCBmcmFtZQogKi8Kdm9pZCBpcmxhcF9zZW5kX3Nucm1fZnJhbWUoc3RydWN0IGlybGFwX2NiICpzZWxmLCBzdHJ1Y3QgcW9zX2luZm8gKnFvcykKewoJc3RydWN0IHNrX2J1ZmYgKnR4X3NrYjsKCXN0cnVjdCBzbnJtX2ZyYW1lICpmcmFtZTsKCWludCByZXQ7CgoJSVJEQV9BU1NFUlQoc2VsZiAhPSBOVUxMLCByZXR1cm47KTsKCUlSREFfQVNTRVJUKHNlbGYtPm1hZ2ljID09IExBUF9NQUdJQywgcmV0dXJuOyk7CgoJLyogQWxsb2NhdGUgZnJhbWUgKi8KCXR4X3NrYiA9IGFsbG9jX3NrYihzaXplb2Yoc3RydWN0IHNucm1fZnJhbWUpICsKCQkJICAgSVJMQVBfTkVHT0NJQVRJT05fUEFSQU1TX0xFTiwKCQkJICAgR0ZQX0FUT01JQyk7CglpZiAoIXR4X3NrYikKCQlyZXR1cm47CgoJZnJhbWUgPSAoc3RydWN0IHNucm1fZnJhbWUgKikgc2tiX3B1dCh0eF9za2IsIDIpOwoKCS8qIEluc2VydCBjb25uZWN0aW9uIGFkZHJlc3MgZmllbGQgKi8KCWlmIChxb3MpCgkJZnJhbWUtPmNhZGRyID0gQ01EX0ZSQU1FIHwgQ0JST0FEQ0FTVDsKCWVsc2UKCQlmcmFtZS0+Y2FkZHIgPSBDTURfRlJBTUUgfCBzZWxmLT5jYWRkcjsKCgkvKiBJbnNlcnQgY29udHJvbCBmaWVsZCAqLwoJZnJhbWUtPmNvbnRyb2wgPSBTTlJNX0NNRCB8IFBGX0JJVDsKCgkvKgoJICogIElmIHdlIGFyZSBlc3RhYmxpc2hpbmcgYSBjb25uZWN0aW9uIHRoZW4gaW5zZXJ0IFFvUyBwYXJhbWVydGVycwoJICovCglpZiAocW9zKSB7CgkJc2tiX3B1dCh0eF9za2IsIDkpOyAvKiAyNSBsZWZ0ICovCgkJZnJhbWUtPnNhZGRyID0gY3B1X3RvX2xlMzIoc2VsZi0+c2FkZHIpOwoJCWZyYW1lLT5kYWRkciA9IGNwdV90b19sZTMyKHNlbGYtPmRhZGRyKTsKCgkJZnJhbWUtPm5jYWRkciA9IHNlbGYtPmNhZGRyOwoKCQlyZXQgPSBpcmxhcF9pbnNlcnRfcW9zX25lZ290aWF0aW9uX3BhcmFtcyhzZWxmLCB0eF9za2IpOwoJCWlmIChyZXQgPCAwKSB7CgkJCWRldl9rZnJlZV9za2IodHhfc2tiKTsKCQkJcmV0dXJuOwoJCX0KCX0KCWlybGFwX3F1ZXVlX3htaXQoc2VsZiwgdHhfc2tiKTsKfQoKLyoKICogRnVuY3Rpb24gaXJsYXBfcmVjdl9zbnJtX2NtZCAoc2tiLCBpbmZvKQogKgogKiAgICBSZWNlaXZlZCBTTlJNIChTZXQgTm9ybWFsIFJlc3BvbnNlIE1vZGUpIGNvbW1hbmQgZnJhbWUKICoKICovCnN0YXRpYyB2b2lkIGlybGFwX3JlY3Zfc25ybV9jbWQoc3RydWN0IGlybGFwX2NiICpzZWxmLCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAoJCQkJc3RydWN0IGlybGFwX2luZm8gKmluZm8pCnsKCXN0cnVjdCBzbnJtX2ZyYW1lICpmcmFtZTsKCglpZiAocHNrYl9tYXlfcHVsbChza2Isc2l6ZW9mKHN0cnVjdCBzbnJtX2ZyYW1lKSkpIHsKCQlmcmFtZSA9IChzdHJ1Y3Qgc25ybV9mcmFtZSAqKSBza2ItPmRhdGE7CgoJCS8qIENvcHkgdGhlIG5ldyBjb25uZWN0aW9uIGFkZHJlc3MgaWdub3JpbmcgdGhlIEMvUiBiaXQgKi8KCQlpbmZvLT5jYWRkciA9IGZyYW1lLT5uY2FkZHIgJiAweEZFOwoKCQkvKiBDaGVjayBpZiB0aGUgbmV3IGNvbm5lY3Rpb24gYWRkcmVzcyBpcyB2YWxpZCAqLwoJCWlmICgoaW5mby0+Y2FkZHIgPT0gMHgwMCkgfHwgKGluZm8tPmNhZGRyID09IDB4ZmUpKSB7CgkJCUlSREFfREVCVUcoMywgIiVzKCksIGludmFsaWQgY29ubmVjdGlvbiBhZGRyZXNzIVxuIiwKCQkJCSAgIF9fRlVOQ1RJT05fXyk7CgkJCXJldHVybjsKCQl9CgoJCS8qIENvcHkgcGVlciBkZXZpY2UgYWRkcmVzcyAqLwoJCWluZm8tPmRhZGRyID0gbGUzMl90b19jcHUoZnJhbWUtPnNhZGRyKTsKCQlpbmZvLT5zYWRkciA9IGxlMzJfdG9fY3B1KGZyYW1lLT5kYWRkcik7CgoJCS8qIE9ubHkgYWNjZXB0IGlmIGFkZHJlc3NlZCBkaXJlY3RseSB0byB1cyAqLwoJCWlmIChpbmZvLT5zYWRkciAhPSBzZWxmLT5zYWRkcikgewoJCQlJUkRBX0RFQlVHKDIsICIlcygpLCBub3QgYWRkcmVzc2VkIHRvIHVzIVxuIiwKCQkJCSAgIF9fRlVOQ1RJT05fXyk7CgkJCXJldHVybjsKCQl9CgkJaXJsYXBfZG9fZXZlbnQoc2VsZiwgUkVDVl9TTlJNX0NNRCwgc2tiLCBpbmZvKTsKCX0gZWxzZSB7CgkJLyogU2lnbmFsIHRoYXQgdGhpcyBTTlJNIGZyYW1lIGRvZXMgbm90IGNvbnRhaW4gYW5kIEktZmllbGQgKi8KCQlpcmxhcF9kb19ldmVudChzZWxmLCBSRUNWX1NOUk1fQ01ELCBza2IsIE5VTEwpOwoJfQp9CgovKgogKiBGdW5jdGlvbiBpcmxhcF9zZW5kX3VhX3Jlc3BvbnNlX2ZyYW1lIChxb3MpCiAqCiAqICAgIFNlbmQgVUEgKFVubnVtYmVyZWQgQWNrbm93bGVkZ2VtZW50KSBmcmFtZQogKgogKi8Kdm9pZCBpcmxhcF9zZW5kX3VhX3Jlc3BvbnNlX2ZyYW1lKHN0cnVjdCBpcmxhcF9jYiAqc2VsZiwgc3RydWN0IHFvc19pbmZvICpxb3MpCnsKCXN0cnVjdCBza19idWZmICp0eF9za2I7CglzdHJ1Y3QgdWFfZnJhbWUgKmZyYW1lOwoJaW50IHJldDsKCglJUkRBX0RFQlVHKDIsICIlcygpIDwlbGQ+XG4iLCBfX0ZVTkNUSU9OX18sIGppZmZpZXMpOwoKCUlSREFfQVNTRVJUKHNlbGYgIT0gTlVMTCwgcmV0dXJuOyk7CglJUkRBX0FTU0VSVChzZWxmLT5tYWdpYyA9PSBMQVBfTUFHSUMsIHJldHVybjspOwoKCS8qIEFsbG9jYXRlIGZyYW1lICovCgl0eF9za2IgPSBhbGxvY19za2Ioc2l6ZW9mKHN0cnVjdCB1YV9mcmFtZSkgKwoJCQkgICBJUkxBUF9ORUdPQ0lBVElPTl9QQVJBTVNfTEVOLAoJCQkgICBHRlBfQVRPTUlDKTsKCWlmICghdHhfc2tiKQoJCXJldHVybjsKCglmcmFtZSA9IChzdHJ1Y3QgdWFfZnJhbWUgKikgc2tiX3B1dCh0eF9za2IsIDEwKTsKCgkvKiBCdWlsZCBVQSByZXNwb25zZSAqLwoJZnJhbWUtPmNhZGRyID0gc2VsZi0+Y2FkZHI7CglmcmFtZS0+Y29udHJvbCA9IFVBX1JTUCB8IFBGX0JJVDsKCglmcmFtZS0+c2FkZHIgPSBjcHVfdG9fbGUzMihzZWxmLT5zYWRkcik7CglmcmFtZS0+ZGFkZHIgPSBjcHVfdG9fbGUzMihzZWxmLT5kYWRkcik7CgoJLyogU2hvdWxkIHdlIHNlbmQgUW9TIG5lZ290aWF0aW9uIHBhcmFtZXRlcnM/ICovCglpZiAocW9zKSB7CgkJcmV0ID0gaXJsYXBfaW5zZXJ0X3Fvc19uZWdvdGlhdGlvbl9wYXJhbXMoc2VsZiwgdHhfc2tiKTsKCQlpZiAocmV0IDwgMCkgewoJCQlkZXZfa2ZyZWVfc2tiKHR4X3NrYik7CgkJCXJldHVybjsKCQl9Cgl9CgoJaXJsYXBfcXVldWVfeG1pdChzZWxmLCB0eF9za2IpOwp9CgoKLyoKICogRnVuY3Rpb24gaXJsYXBfc2VuZF9kbV9mcmFtZSAodm9pZCkKICoKICogICAgU2VuZCBkaXNjb25uZWN0ZWQgbW9kZSAoRE0pIGZyYW1lCiAqCiAqLwp2b2lkIGlybGFwX3NlbmRfZG1fZnJhbWUoIHN0cnVjdCBpcmxhcF9jYiAqc2VsZikKewoJc3RydWN0IHNrX2J1ZmYgKnR4X3NrYiA9IE5VTEw7CglzdHJ1Y3QgZG1fZnJhbWUgKmZyYW1lOwoKCUlSREFfQVNTRVJUKHNlbGYgIT0gTlVMTCwgcmV0dXJuOyk7CglJUkRBX0FTU0VSVChzZWxmLT5tYWdpYyA9PSBMQVBfTUFHSUMsIHJldHVybjspOwoKCXR4X3NrYiA9IGFsbG9jX3NrYihzaXplb2Yoc3RydWN0IGRtX2ZyYW1lKSwgR0ZQX0FUT01JQyk7CglpZiAoIXR4X3NrYikKCQlyZXR1cm47CgoJZnJhbWUgPSAoc3RydWN0IGRtX2ZyYW1lICopc2tiX3B1dCh0eF9za2IsIDIpOwoKCWlmIChzZWxmLT5zdGF0ZSA9PSBMQVBfTkRNKQoJCWZyYW1lLT5jYWRkciA9IENCUk9BRENBU1Q7CgllbHNlCgkJZnJhbWUtPmNhZGRyID0gc2VsZi0+Y2FkZHI7CgoJZnJhbWUtPmNvbnRyb2wgPSBETV9SU1AgfCBQRl9CSVQ7CgoJaXJsYXBfcXVldWVfeG1pdChzZWxmLCB0eF9za2IpOwp9CgovKgogKiBGdW5jdGlvbiBpcmxhcF9zZW5kX2Rpc2NfZnJhbWUgKHZvaWQpCiAqCiAqICAgIFNlbmQgZGlzY29ubmVjdCAoRElTQykgZnJhbWUKICoKICovCnZvaWQgaXJsYXBfc2VuZF9kaXNjX2ZyYW1lKHN0cnVjdCBpcmxhcF9jYiAqc2VsZikKewoJc3RydWN0IHNrX2J1ZmYgKnR4X3NrYiA9IE5VTEw7CglzdHJ1Y3QgZGlzY19mcmFtZSAqZnJhbWU7CgoJSVJEQV9ERUJVRygzLCAiJXMoKVxuIiwgX19GVU5DVElPTl9fKTsKCglJUkRBX0FTU0VSVChzZWxmICE9IE5VTEwsIHJldHVybjspOwoJSVJEQV9BU1NFUlQoc2VsZi0+bWFnaWMgPT0gTEFQX01BR0lDLCByZXR1cm47KTsKCgl0eF9za2IgPSBhbGxvY19za2Ioc2l6ZW9mKHN0cnVjdCBkaXNjX2ZyYW1lKSwgR0ZQX0FUT01JQyk7CglpZiAoIXR4X3NrYikKCQlyZXR1cm47CgoJZnJhbWUgPSAoc3RydWN0IGRpc2NfZnJhbWUgKilza2JfcHV0KHR4X3NrYiwgMik7CgoJZnJhbWUtPmNhZGRyID0gc2VsZi0+Y2FkZHIgfCBDTURfRlJBTUU7CglmcmFtZS0+Y29udHJvbCA9IERJU0NfQ01EIHwgUEZfQklUOwoKCWlybGFwX3F1ZXVlX3htaXQoc2VsZiwgdHhfc2tiKTsKfQoKLyoKICogRnVuY3Rpb24gaXJsYXBfc2VuZF9kaXNjb3ZlcnlfeGlkX2ZyYW1lIChTLCBzLCBjb21tYW5kKQogKgogKiAgICBCdWlsZCBhbmQgdHJhbnNtaXQgYSBYSUQgKGVYY2hhbmdlIHN0YXRpb24gSURlbnRpZmllcikgZGlzY292ZXJ5CiAqICAgIGZyYW1lLgogKi8Kdm9pZCBpcmxhcF9zZW5kX2Rpc2NvdmVyeV94aWRfZnJhbWUoc3RydWN0IGlybGFwX2NiICpzZWxmLCBpbnQgUywgX191OCBzLAoJCQkJICAgIF9fdTggY29tbWFuZCwgZGlzY292ZXJ5X3QgKmRpc2NvdmVyeSkKewoJc3RydWN0IHNrX2J1ZmYgKnR4X3NrYiA9IE5VTEw7CglzdHJ1Y3QgeGlkX2ZyYW1lICpmcmFtZTsKCV9fdTMyIGJjYXN0ID0gQlJPQURDQVNUOwoJX191OCAqaW5mbzsKCglJUkRBX0RFQlVHKDQsICIlcygpLCBzPSVkLCBTPSVkLCBjb21tYW5kPSVkXG4iLCBfX0ZVTkNUSU9OX18sCgkJICAgcywgUywgY29tbWFuZCk7CgoJSVJEQV9BU1NFUlQoc2VsZiAhPSBOVUxMLCByZXR1cm47KTsKCUlSREFfQVNTRVJUKHNlbGYtPm1hZ2ljID09IExBUF9NQUdJQywgcmV0dXJuOyk7CglJUkRBX0FTU0VSVChkaXNjb3ZlcnkgIT0gTlVMTCwgcmV0dXJuOyk7CgoJdHhfc2tiID0gYWxsb2Nfc2tiKHNpemVvZihzdHJ1Y3QgeGlkX2ZyYW1lKSArIElSTEFQX0RJU0NPVkVSWV9JTkZPX0xFTiwKCQkJICAgR0ZQX0FUT01JQyk7CglpZiAoIXR4X3NrYikKCQlyZXR1cm47CgoJc2tiX3B1dCh0eF9za2IsIDE0KTsKCWZyYW1lID0gKHN0cnVjdCB4aWRfZnJhbWUgKikgdHhfc2tiLT5kYXRhOwoKCWlmIChjb21tYW5kKSB7CgkJZnJhbWUtPmNhZGRyID0gQ0JST0FEQ0FTVCB8IENNRF9GUkFNRTsKCQlmcmFtZS0+Y29udHJvbCA9ICBYSURfQ01EIHwgUEZfQklUOwoJfSBlbHNlIHsKCQlmcmFtZS0+Y2FkZHIgPSBDQlJPQURDQVNUOwoJCWZyYW1lLT5jb250cm9sID0gIFhJRF9SU1AgfCBQRl9CSVQ7Cgl9CglmcmFtZS0+aWRlbnQgPSBYSURfRk9STUFUOwoKCWZyYW1lLT5zYWRkciA9IGNwdV90b19sZTMyKHNlbGYtPnNhZGRyKTsKCglpZiAoY29tbWFuZCkKCQlmcmFtZS0+ZGFkZHIgPSBjcHVfdG9fbGUzMihiY2FzdCk7CgllbHNlCgkJZnJhbWUtPmRhZGRyID0gY3B1X3RvX2xlMzIoZGlzY292ZXJ5LT5kYXRhLmRhZGRyKTsKCglzd2l0Y2ggKFMpIHsKCWNhc2UgMToKCQlmcmFtZS0+ZmxhZ3MgPSAweDAwOwoJCWJyZWFrOwoJY2FzZSA2OgoJCWZyYW1lLT5mbGFncyA9IDB4MDE7CgkJYnJlYWs7CgljYXNlIDg6CgkJZnJhbWUtPmZsYWdzID0gMHgwMjsKCQlicmVhazsKCWNhc2UgMTY6CgkJZnJhbWUtPmZsYWdzID0gMHgwMzsKCQlicmVhazsKCWRlZmF1bHQ6CgkJZnJhbWUtPmZsYWdzID0gMHgwMjsKCQlicmVhazsKCX0KCglmcmFtZS0+c2xvdG5yID0gczsKCWZyYW1lLT52ZXJzaW9uID0gMHgwMDsKCgkvKgoJICogIFByb3ZpZGUgaW5mbyBmb3IgZmluYWwgc2xvdCBvbmx5IGluIGNvbW1hbmRzLCBhbmQgZm9yIGFsbAoJICogIHJlc3BvbnNlcy4gU2VuZCB0aGUgc2Vjb25kIGJ5dGUgb2YgdGhlIGhpbnQgb25seSBpZiB0aGUKCSAqICBFWFRFTlNJT04gYml0IGlzIHNldCBpbiB0aGUgZmlyc3QgYnl0ZS4KCSAqLwoJaWYgKCFjb21tYW5kIHx8IChmcmFtZS0+c2xvdG5yID09IDB4ZmYpKSB7CgkJaW50IGxlbjsKCgkJaWYgKGRpc2NvdmVyeS0+ZGF0YS5oaW50c1swXSAmIEhJTlRfRVhURU5TSU9OKSB7CgkJCWluZm8gPSBza2JfcHV0KHR4X3NrYiwgMik7CgkJCWluZm9bMF0gPSBkaXNjb3ZlcnktPmRhdGEuaGludHNbMF07CgkJCWluZm9bMV0gPSBkaXNjb3ZlcnktPmRhdGEuaGludHNbMV07CgkJfSBlbHNlIHsKCQkJaW5mbyA9IHNrYl9wdXQodHhfc2tiLCAxKTsKCQkJaW5mb1swXSA9IGRpc2NvdmVyeS0+ZGF0YS5oaW50c1swXTsKCQl9CgkJaW5mbyA9IHNrYl9wdXQodHhfc2tiLCAxKTsKCQlpbmZvWzBdID0gZGlzY292ZXJ5LT5kYXRhLmNoYXJzZXQ7CgoJCWxlbiA9IElSREFfTUlOKGRpc2NvdmVyeS0+bmFtZV9sZW4sIHNrYl90YWlscm9vbSh0eF9za2IpKTsKCQlpbmZvID0gc2tiX3B1dCh0eF9za2IsIGxlbik7CgkJbWVtY3B5KGluZm8sIGRpc2NvdmVyeS0+ZGF0YS5pbmZvLCBsZW4pOwoJfQoJaXJsYXBfcXVldWVfeG1pdChzZWxmLCB0eF9za2IpOwp9CgovKgogKiBGdW5jdGlvbiBpcmxhcF9yZWN2X2Rpc2NvdmVyeV94aWRfcnNwIChza2IsIGluZm8pCiAqCiAqICAgIFJlY2VpdmVkIGEgWElEIGRpc2NvdmVyeSByZXNwb25zZQogKgogKi8Kc3RhdGljIHZvaWQgaXJsYXBfcmVjdl9kaXNjb3ZlcnlfeGlkX3JzcChzdHJ1Y3QgaXJsYXBfY2IgKnNlbGYsCgkJCQkJIHN0cnVjdCBza19idWZmICpza2IsCgkJCQkJIHN0cnVjdCBpcmxhcF9pbmZvICppbmZvKQp7CglzdHJ1Y3QgeGlkX2ZyYW1lICp4aWQ7CglkaXNjb3ZlcnlfdCAqZGlzY292ZXJ5ID0gTlVMTDsKCV9fdTggKmRpc2NvdmVyeV9pbmZvOwoJY2hhciAqdGV4dDsKCglJUkRBX0RFQlVHKDQsICIlcygpXG4iLCBfX0ZVTkNUSU9OX18pOwoKCUlSREFfQVNTRVJUKHNlbGYgIT0gTlVMTCwgcmV0dXJuOyk7CglJUkRBX0FTU0VSVChzZWxmLT5tYWdpYyA9PSBMQVBfTUFHSUMsIHJldHVybjspOwoKCWlmICghcHNrYl9tYXlfcHVsbChza2IsIHNpemVvZihzdHJ1Y3QgeGlkX2ZyYW1lKSkpIHsKCQlJUkRBX0VSUk9SKCIlczogZnJhbWUgdG9vIHNob3J0IVxuIiwgX19GVU5DVElPTl9fKTsKCQlyZXR1cm47Cgl9CgoJeGlkID0gKHN0cnVjdCB4aWRfZnJhbWUgKikgc2tiLT5kYXRhOwoKCWluZm8tPmRhZGRyID0gbGUzMl90b19jcHUoeGlkLT5zYWRkcik7CglpbmZvLT5zYWRkciA9IGxlMzJfdG9fY3B1KHhpZC0+ZGFkZHIpOwoKCS8qIE1ha2Ugc3VyZSBmcmFtZSBpcyBhZGRyZXNzZWQgdG8gdXMgKi8KCWlmICgoaW5mby0+c2FkZHIgIT0gc2VsZi0+c2FkZHIpICYmIChpbmZvLT5zYWRkciAhPSBCUk9BRENBU1QpKSB7CgkJSVJEQV9ERUJVRygwLCAiJXMoKSwgZnJhbWUgaXMgbm90IGFkZHJlc3NlZCB0byB1cyFcbiIsCgkJCSAgIF9fRlVOQ1RJT05fXyk7CgkJcmV0dXJuOwoJfQoKCWlmICgoZGlzY292ZXJ5ID0ga3phbGxvYyhzaXplb2YoZGlzY292ZXJ5X3QpLCBHRlBfQVRPTUlDKSkgPT0gTlVMTCkgewoJCUlSREFfV0FSTklORygiJXM6IGttYWxsb2MgZmFpbGVkIVxuIiwgX19GVU5DVElPTl9fKTsKCQlyZXR1cm47Cgl9CgoJZGlzY292ZXJ5LT5kYXRhLmRhZGRyID0gaW5mby0+ZGFkZHI7CglkaXNjb3ZlcnktPmRhdGEuc2FkZHIgPSBzZWxmLT5zYWRkcjsKCWRpc2NvdmVyeS0+dGltZXN0YW1wID0gamlmZmllczsKCglJUkRBX0RFQlVHKDQsICIlcygpLCBkYWRkcj0lMDh4XG4iLCBfX0ZVTkNUSU9OX18sCgkJICAgZGlzY292ZXJ5LT5kYXRhLmRhZGRyKTsKCglkaXNjb3ZlcnlfaW5mbyA9IHNrYl9wdWxsKHNrYiwgc2l6ZW9mKHN0cnVjdCB4aWRfZnJhbWUpKTsKCgkvKiBHZXQgaW5mbyByZXR1cm5lZCBmcm9tIHBlZXIgKi8KCWRpc2NvdmVyeS0+ZGF0YS5oaW50c1swXSA9IGRpc2NvdmVyeV9pbmZvWzBdOwoJaWYgKGRpc2NvdmVyeV9pbmZvWzBdICYgSElOVF9FWFRFTlNJT04pIHsKCQlJUkRBX0RFQlVHKDQsICJFWFRFTlNJT05cbiIpOwoJCWRpc2NvdmVyeS0+ZGF0YS5oaW50c1sxXSA9IGRpc2NvdmVyeV9pbmZvWzFdOwoJCWRpc2NvdmVyeS0+ZGF0YS5jaGFyc2V0ID0gZGlzY292ZXJ5X2luZm9bMl07CgkJdGV4dCA9IChjaGFyICopICZkaXNjb3ZlcnlfaW5mb1szXTsKCX0gZWxzZSB7CgkJZGlzY292ZXJ5LT5kYXRhLmhpbnRzWzFdID0gMDsKCQlkaXNjb3ZlcnktPmRhdGEuY2hhcnNldCA9IGRpc2NvdmVyeV9pbmZvWzFdOwoJCXRleHQgPSAoY2hhciAqKSAmZGlzY292ZXJ5X2luZm9bMl07Cgl9CgkvKgoJICogIFRlcm1pbmF0ZSBpbmZvIHN0cmluZywgc2hvdWxkIGJlIHNhZmUgc2luY2UgdGhpcyBpcyB3aGVyZSB0aGUKCSAqICBGQ1MgYnl0ZXMgcmVzaWRlcy4KCSAqLwoJc2tiLT5kYXRhW3NrYi0+bGVuXSA9ICdcMCc7CglzdHJuY3B5KGRpc2NvdmVyeS0+ZGF0YS5pbmZvLCB0ZXh0LCBOSUNLTkFNRV9NQVhfTEVOKTsKCWRpc2NvdmVyeS0+bmFtZV9sZW4gPSBzdHJsZW4oZGlzY292ZXJ5LT5kYXRhLmluZm8pOwoKCWluZm8tPmRpc2NvdmVyeSA9IGRpc2NvdmVyeTsKCglpcmxhcF9kb19ldmVudChzZWxmLCBSRUNWX0RJU0NPVkVSWV9YSURfUlNQLCBza2IsIGluZm8pOwp9CgovKgogKiBGdW5jdGlvbiBpcmxhcF9yZWN2X2Rpc2NvdmVyeV94aWRfY21kIChza2IsIGluZm8pCiAqCiAqICAgIFJlY2VpdmVkIGEgWElEIGRpc2NvdmVyeSBjb21tYW5kCiAqCiAqLwpzdGF0aWMgdm9pZCBpcmxhcF9yZWN2X2Rpc2NvdmVyeV94aWRfY21kKHN0cnVjdCBpcmxhcF9jYiAqc2VsZiwKCQkJCQkgc3RydWN0IHNrX2J1ZmYgKnNrYiwKCQkJCQkgc3RydWN0IGlybGFwX2luZm8gKmluZm8pCnsKCXN0cnVjdCB4aWRfZnJhbWUgKnhpZDsKCWRpc2NvdmVyeV90ICpkaXNjb3ZlcnkgPSBOVUxMOwoJX191OCAqZGlzY292ZXJ5X2luZm87CgljaGFyICp0ZXh0OwoKCWlmICghcHNrYl9tYXlfcHVsbChza2IsIHNpemVvZihzdHJ1Y3QgeGlkX2ZyYW1lKSkpIHsKCQlJUkRBX0VSUk9SKCIlczogZnJhbWUgdG9vIHNob3J0IVxuIiwgX19GVU5DVElPTl9fKTsKCQlyZXR1cm47Cgl9CgoJeGlkID0gKHN0cnVjdCB4aWRfZnJhbWUgKikgc2tiLT5kYXRhOwoKCWluZm8tPmRhZGRyID0gbGUzMl90b19jcHUoeGlkLT5zYWRkcik7CglpbmZvLT5zYWRkciA9IGxlMzJfdG9fY3B1KHhpZC0+ZGFkZHIpOwoKCS8qIE1ha2Ugc3VyZSBmcmFtZSBpcyBhZGRyZXNzZWQgdG8gdXMgKi8KCWlmICgoaW5mby0+c2FkZHIgIT0gc2VsZi0+c2FkZHIpICYmIChpbmZvLT5zYWRkciAhPSBCUk9BRENBU1QpKSB7CgkJSVJEQV9ERUJVRygwLCAiJXMoKSwgZnJhbWUgaXMgbm90IGFkZHJlc3NlZCB0byB1cyFcbiIsCgkJCSAgIF9fRlVOQ1RJT05fXyk7CgkJcmV0dXJuOwoJfQoKCXN3aXRjaCAoeGlkLT5mbGFncyAmIDB4MDMpIHsKCWNhc2UgMHgwMDoKCQlpbmZvLT5TID0gMTsKCQlicmVhazsKCWNhc2UgMHgwMToKCQlpbmZvLT5TID0gNjsKCQlicmVhazsKCWNhc2UgMHgwMjoKCQlpbmZvLT5TID0gODsKCQlicmVhazsKCWNhc2UgMHgwMzoKCQlpbmZvLT5TID0gMTY7CgkJYnJlYWs7CglkZWZhdWx0OgoJCS8qIEVycm9yISEgKi8KCQlyZXR1cm47Cgl9CglpbmZvLT5zID0geGlkLT5zbG90bnI7CgoJZGlzY292ZXJ5X2luZm8gPSBza2JfcHVsbChza2IsIHNpemVvZihzdHJ1Y3QgeGlkX2ZyYW1lKSk7CgoJLyoKCSAqICBDaGVjayBpZiBsYXN0IGZyYW1lCgkgKi8KCWlmIChpbmZvLT5zID09IDB4ZmYpIHsKCQkvKiBDaGVjayBpZiB0aGluZ3MgYXJlIHNhbmUgYXQgdGhpcyBwb2ludC4uLiAqLwoJCWlmKChkaXNjb3ZlcnlfaW5mbyA9PSBOVUxMKSB8fAoJCSAgICFwc2tiX21heV9wdWxsKHNrYiwgMykpIHsKCQkJSVJEQV9FUlJPUigiJXM6IGRpc2NvdmVyeSBmcmFtZSB0b28gc2hvcnQhXG4iLAoJCQkJICAgX19GVU5DVElPTl9fKTsKCQkJcmV0dXJuOwoJCX0KCgkJLyoKCQkgKiAgV2Ugbm93IGhhdmUgc29tZSBkaXNjb3ZlcnkgaW5mbyB0byBkZWxpdmVyIQoJCSAqLwoJCWRpc2NvdmVyeSA9IGttYWxsb2Moc2l6ZW9mKGRpc2NvdmVyeV90KSwgR0ZQX0FUT01JQyk7CgkJaWYgKCFkaXNjb3ZlcnkpIHsKCQkJSVJEQV9XQVJOSU5HKCIlczogdW5hYmxlIHRvIG1hbGxvYyFcbiIsIF9fRlVOQ1RJT05fXyk7CgkJCXJldHVybjsKCQl9CgoJCWRpc2NvdmVyeS0+ZGF0YS5kYWRkciA9IGluZm8tPmRhZGRyOwoJCWRpc2NvdmVyeS0+ZGF0YS5zYWRkciA9IHNlbGYtPnNhZGRyOwoJCWRpc2NvdmVyeS0+dGltZXN0YW1wID0gamlmZmllczsKCgkJZGlzY292ZXJ5LT5kYXRhLmhpbnRzWzBdID0gZGlzY292ZXJ5X2luZm9bMF07CgkJaWYgKGRpc2NvdmVyeV9pbmZvWzBdICYgSElOVF9FWFRFTlNJT04pIHsKCQkJZGlzY292ZXJ5LT5kYXRhLmhpbnRzWzFdID0gZGlzY292ZXJ5X2luZm9bMV07CgkJCWRpc2NvdmVyeS0+ZGF0YS5jaGFyc2V0ID0gZGlzY292ZXJ5X2luZm9bMl07CgkJCXRleHQgPSAoY2hhciAqKSAmZGlzY292ZXJ5X2luZm9bM107CgkJfSBlbHNlIHsKCQkJZGlzY292ZXJ5LT5kYXRhLmhpbnRzWzFdID0gMDsKCQkJZGlzY292ZXJ5LT5kYXRhLmNoYXJzZXQgPSBkaXNjb3ZlcnlfaW5mb1sxXTsKCQkJdGV4dCA9IChjaGFyICopICZkaXNjb3ZlcnlfaW5mb1syXTsKCQl9CgkJLyoKCQkgKiAgVGVybWluYXRlIHN0cmluZywgc2hvdWxkIGJlIHNhZmUgc2luY2UgdGhpcyBpcyB3aGVyZSB0aGUKCQkgKiAgRkNTIGJ5dGVzIHJlc2lkZXMuCgkJICovCgkJc2tiLT5kYXRhW3NrYi0+bGVuXSA9ICdcMCc7CgkJc3RybmNweShkaXNjb3ZlcnktPmRhdGEuaW5mbywgdGV4dCwgTklDS05BTUVfTUFYX0xFTik7CgkJZGlzY292ZXJ5LT5uYW1lX2xlbiA9IHN0cmxlbihkaXNjb3ZlcnktPmRhdGEuaW5mbyk7CgoJCWluZm8tPmRpc2NvdmVyeSA9IGRpc2NvdmVyeTsKCX0gZWxzZQoJCWluZm8tPmRpc2NvdmVyeSA9IE5VTEw7CgoJaXJsYXBfZG9fZXZlbnQoc2VsZiwgUkVDVl9ESVNDT1ZFUllfWElEX0NNRCwgc2tiLCBpbmZvKTsKfQoKLyoKICogRnVuY3Rpb24gaXJsYXBfc2VuZF9ycl9mcmFtZSAoc2VsZiwgY29tbWFuZCkKICoKICogICAgQnVpbGQgYW5kIHRyYW5zbWl0IFJSIChSZWNlaXZlIFJlYWR5KSBmcmFtZS4gTm90aWNlIHRoYXQgaXQgaXMgY3VycmVudGx5CiAqICAgIG9ubHkgcG9zc2libGUgdG8gc2VuZCBSUiBmcmFtZXMgd2l0aCB0aGUgcG9sbCBiaXQgc2V0LgogKi8Kdm9pZCBpcmxhcF9zZW5kX3JyX2ZyYW1lKHN0cnVjdCBpcmxhcF9jYiAqc2VsZiwgaW50IGNvbW1hbmQpCnsKCXN0cnVjdCBza19idWZmICp0eF9za2I7CglzdHJ1Y3QgcnJfZnJhbWUgKmZyYW1lOwoKCXR4X3NrYiA9IGFsbG9jX3NrYihzaXplb2Yoc3RydWN0IHJyX2ZyYW1lKSwgR0ZQX0FUT01JQyk7CglpZiAoIXR4X3NrYikKCQlyZXR1cm47CgoJZnJhbWUgPSAoc3RydWN0IHJyX2ZyYW1lICopc2tiX3B1dCh0eF9za2IsIDIpOwoKCWZyYW1lLT5jYWRkciA9IHNlbGYtPmNhZGRyOwoJZnJhbWUtPmNhZGRyIHw9IChjb21tYW5kKSA/IENNRF9GUkFNRSA6IDA7CgoJZnJhbWUtPmNvbnRyb2wgPSBSUiB8IFBGX0JJVCB8IChzZWxmLT52ciA8PCA1KTsKCglpcmxhcF9xdWV1ZV94bWl0KHNlbGYsIHR4X3NrYik7Cn0KCi8qCiAqIEZ1bmN0aW9uIGlybGFwX3NlbmRfcmRfZnJhbWUgKHNlbGYpCiAqCiAqICAgIFJlcXVlc3QgZGlzY29ubmVjdC4gVXNlZCBieSBhIHNlY29uZGFyeSBzdGF0aW9uIHRvIHJlcXVlc3QgdGhlCiAqICAgIGRpc2Nvbm5lY3Rpb24gb2YgdGhlIGxpbmsuCiAqLwp2b2lkIGlybGFwX3NlbmRfcmRfZnJhbWUoc3RydWN0IGlybGFwX2NiICpzZWxmKQp7CglzdHJ1Y3Qgc2tfYnVmZiAqdHhfc2tiOwoJc3RydWN0IHJkX2ZyYW1lICpmcmFtZTsKCgl0eF9za2IgPSBhbGxvY19za2Ioc2l6ZW9mKHN0cnVjdCByZF9mcmFtZSksIEdGUF9BVE9NSUMpOwoJaWYgKCF0eF9za2IpCgkJcmV0dXJuOwoKCWZyYW1lID0gKHN0cnVjdCByZF9mcmFtZSAqKXNrYl9wdXQodHhfc2tiLCAyKTsKCglmcmFtZS0+Y2FkZHIgPSBzZWxmLT5jYWRkcjsKCWZyYW1lLT5jYWRkciA9IFJEX1JTUCB8IFBGX0JJVDsKCglpcmxhcF9xdWV1ZV94bWl0KHNlbGYsIHR4X3NrYik7Cn0KCi8qCiAqIEZ1bmN0aW9uIGlybGFwX3JlY3ZfcnJfZnJhbWUgKHNrYiwgaW5mbykKICoKICogICAgUmVjZWl2ZWQgUlIgKFJlY2VpdmUgUmVhZHkpIGZyYW1lIGZyb20gcGVlciBzdGF0aW9uLCBubyBoYXJtIGluCiAqICAgIG1ha2luZyBpdCBpbmxpbmUgc2luY2UgaXRzIGNhbGxlZCBvbmx5IGZyb20gb25lIHNpbmdsZSBwbGFjZQogKiAgICAoaXJsYXBfZHJpdmVyX3JjdikuCiAqLwpzdGF0aWMgaW5saW5lIHZvaWQgaXJsYXBfcmVjdl9ycl9mcmFtZShzdHJ1Y3QgaXJsYXBfY2IgKnNlbGYsCgkJCQkgICAgICAgc3RydWN0IHNrX2J1ZmYgKnNrYiwKCQkJCSAgICAgICBzdHJ1Y3QgaXJsYXBfaW5mbyAqaW5mbywgaW50IGNvbW1hbmQpCnsKCWluZm8tPm5yID0gc2tiLT5kYXRhWzFdID4+IDU7CgoJLyogQ2hlY2sgaWYgdGhpcyBpcyBhIGNvbW1hbmQgb3IgYSByZXNwb25zZSBmcmFtZSAqLwoJaWYgKGNvbW1hbmQpCgkJaXJsYXBfZG9fZXZlbnQoc2VsZiwgUkVDVl9SUl9DTUQsIHNrYiwgaW5mbyk7CgllbHNlCgkJaXJsYXBfZG9fZXZlbnQoc2VsZiwgUkVDVl9SUl9SU1AsIHNrYiwgaW5mbyk7Cn0KCi8qCiAqIEZ1bmN0aW9uIGlybGFwX3JlY3Zfcm5yX2ZyYW1lIChzZWxmLCBza2IsIGluZm8pCiAqCiAqICAgIFJlY2VpdmVkIFJOUiAoUmVjZWl2ZSBOb3QgUmVhZHkpIGZyYW1lIGZyb20gcGVlciBzdGF0aW9uCiAqCiAqLwpzdGF0aWMgdm9pZCBpcmxhcF9yZWN2X3Jucl9mcmFtZShzdHJ1Y3QgaXJsYXBfY2IgKnNlbGYsIHN0cnVjdCBza19idWZmICpza2IsCgkJCQkgc3RydWN0IGlybGFwX2luZm8gKmluZm8sIGludCBjb21tYW5kKQp7CglpbmZvLT5uciA9IHNrYi0+ZGF0YVsxXSA+PiA1OwoKCUlSREFfREVCVUcoNCwgIiVzKCksIG5yPSVkLCAlbGRcbiIsIF9fRlVOQ1RJT05fXywgaW5mby0+bnIsIGppZmZpZXMpOwoKCWlmIChjb21tYW5kKQoJCWlybGFwX2RvX2V2ZW50KHNlbGYsIFJFQ1ZfUk5SX0NNRCwgc2tiLCBpbmZvKTsKCWVsc2UKCQlpcmxhcF9kb19ldmVudChzZWxmLCBSRUNWX1JOUl9SU1AsIHNrYiwgaW5mbyk7Cn0KCnN0YXRpYyB2b2lkIGlybGFwX3JlY3ZfcmVqX2ZyYW1lKHN0cnVjdCBpcmxhcF9jYiAqc2VsZiwgc3RydWN0IHNrX2J1ZmYgKnNrYiwKCQkJCSBzdHJ1Y3QgaXJsYXBfaW5mbyAqaW5mbywgaW50IGNvbW1hbmQpCnsKCUlSREFfREVCVUcoMCwgIiVzKClcbiIsIF9fRlVOQ1RJT05fXyk7CgoJaW5mby0+bnIgPSBza2ItPmRhdGFbMV0gPj4gNTsKCgkvKiBDaGVjayBpZiB0aGlzIGlzIGEgY29tbWFuZCBvciBhIHJlc3BvbnNlIGZyYW1lICovCglpZiAoY29tbWFuZCkKCQlpcmxhcF9kb19ldmVudChzZWxmLCBSRUNWX1JFSl9DTUQsIHNrYiwgaW5mbyk7CgllbHNlCgkJaXJsYXBfZG9fZXZlbnQoc2VsZiwgUkVDVl9SRUpfUlNQLCBza2IsIGluZm8pOwp9CgpzdGF0aWMgdm9pZCBpcmxhcF9yZWN2X3NyZWpfZnJhbWUoc3RydWN0IGlybGFwX2NiICpzZWxmLCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAoJCQkJICBzdHJ1Y3QgaXJsYXBfaW5mbyAqaW5mbywgaW50IGNvbW1hbmQpCnsKCUlSREFfREVCVUcoMCwgIiVzKClcbiIsIF9fRlVOQ1RJT05fXyk7CgoJaW5mby0+bnIgPSBza2ItPmRhdGFbMV0gPj4gNTsKCgkvKiBDaGVjayBpZiB0aGlzIGlzIGEgY29tbWFuZCBvciBhIHJlc3BvbnNlIGZyYW1lICovCglpZiAoY29tbWFuZCkKCQlpcmxhcF9kb19ldmVudChzZWxmLCBSRUNWX1NSRUpfQ01ELCBza2IsIGluZm8pOwoJZWxzZQoJCWlybGFwX2RvX2V2ZW50KHNlbGYsIFJFQ1ZfU1JFSl9SU1AsIHNrYiwgaW5mbyk7Cn0KCnN0YXRpYyB2b2lkIGlybGFwX3JlY3ZfZGlzY19mcmFtZShzdHJ1Y3QgaXJsYXBfY2IgKnNlbGYsIHN0cnVjdCBza19idWZmICpza2IsCgkJCQkgIHN0cnVjdCBpcmxhcF9pbmZvICppbmZvLCBpbnQgY29tbWFuZCkKewoJSVJEQV9ERUJVRygyLCAiJXMoKVxuIiwgX19GVU5DVElPTl9fKTsKCgkvKiBDaGVjayBpZiB0aGlzIGlzIGEgY29tbWFuZCBvciBhIHJlc3BvbnNlIGZyYW1lICovCglpZiAoY29tbWFuZCkKCQlpcmxhcF9kb19ldmVudChzZWxmLCBSRUNWX0RJU0NfQ01ELCBza2IsIGluZm8pOwoJZWxzZQoJCWlybGFwX2RvX2V2ZW50KHNlbGYsIFJFQ1ZfUkRfUlNQLCBza2IsIGluZm8pOwp9CgovKgogKiBGdW5jdGlvbiBpcmxhcF9yZWN2X3VhX2ZyYW1lIChza2IsIGZyYW1lKQogKgogKiAgICBSZWNlaXZlZCBVQSAoVW5udW1iZXJlZCBBY2tub3dsZWRnZW1lbnQpIGZyYW1lCiAqCiAqLwpzdGF0aWMgaW5saW5lIHZvaWQgaXJsYXBfcmVjdl91YV9mcmFtZShzdHJ1Y3QgaXJsYXBfY2IgKnNlbGYsCgkJCQkgICAgICAgc3RydWN0IHNrX2J1ZmYgKnNrYiwKCQkJCSAgICAgICBzdHJ1Y3QgaXJsYXBfaW5mbyAqaW5mbykKewoJaXJsYXBfZG9fZXZlbnQoc2VsZiwgUkVDVl9VQV9SU1AsIHNrYiwgaW5mbyk7Cn0KCi8qCiAqIEZ1bmN0aW9uIGlybGFwX3NlbmRfZGF0YV9wcmltYXJ5KHNlbGYsIHNrYikKICoKICogICAgU2VuZCBJLWZyYW1lcyBhcyB0aGUgcHJpbWFyeSBzdGF0aW9uIGJ1dCB3aXRob3V0IHRoZSBwb2xsIGJpdCBzZXQKICoKICovCnZvaWQgaXJsYXBfc2VuZF9kYXRhX3ByaW1hcnkoc3RydWN0IGlybGFwX2NiICpzZWxmLCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQp7CglzdHJ1Y3Qgc2tfYnVmZiAqdHhfc2tiOwoKCWlmIChza2ItPmRhdGFbMV0gPT0gSV9GUkFNRSkgewoKCQkvKgoJCSAqICBJbnNlcnQgZnJhbWUgc2VxdWVuY2UgbnVtYmVyIChWcykgaW4gY29udHJvbCBmaWVsZCBiZWZvcmUKCQkgKiAgaW5zZXJ0aW5nIGludG8gdHJhbnNtaXQgd2luZG93IHF1ZXVlLgoJCSAqLwoJCXNrYi0+ZGF0YVsxXSA9IElfRlJBTUUgfCAoc2VsZi0+dnMgPDwgMSk7CgoJCS8qCgkJICogIEluc2VydCBmcmFtZSBpbiBzdG9yZSwgaW4gY2FzZSBvZiByZXRyYW5zbWlzc2lvbnMKCQkgKiAgSW5jcmVhc2Ugc2tiIHJlZmVyZW5jZSBjb3VudCwgc2VlIGlybGFwX2RvX2V2ZW50KCkKCQkgKi8KCQlza2JfZ2V0KHNrYik7CgkJc2tiX3F1ZXVlX3RhaWwoJnNlbGYtPnd4X2xpc3QsIHNrYik7CgoJCS8qIENvcHkgYnVmZmVyICovCgkJdHhfc2tiID0gc2tiX2Nsb25lKHNrYiwgR0ZQX0FUT01JQyk7CgkJaWYgKHR4X3NrYiA9PSBOVUxMKSB7CgkJCXJldHVybjsKCQl9CgoJCXNlbGYtPnZzID0gKHNlbGYtPnZzICsgMSkgJSA4OwoJCXNlbGYtPmFja19yZXF1aXJlZCA9IEZBTFNFOwoJCXNlbGYtPndpbmRvdyAtPSAxOwoKCQlpcmxhcF9zZW5kX2lfZnJhbWUoIHNlbGYsIHR4X3NrYiwgQ01EX0ZSQU1FKTsKCX0gZWxzZSB7CgkJSVJEQV9ERUJVRyg0LCAiJXMoKSwgc2VuZGluZyB1bnJlbGlhYmxlIGZyYW1lXG4iLCBfX0ZVTkNUSU9OX18pOwoJCWlybGFwX3NlbmRfdWlfZnJhbWUoc2VsZiwgc2tiX2dldChza2IpLCBzZWxmLT5jYWRkciwgQ01EX0ZSQU1FKTsKCQlzZWxmLT53aW5kb3cgLT0gMTsKCX0KfQovKgogKiBGdW5jdGlvbiBpcmxhcF9zZW5kX2RhdGFfcHJpbWFyeV9wb2xsIChzZWxmLCBza2IpCiAqCiAqICAgIFNlbmQgSShuZm9ybWF0aW9uKSBmcmFtZSBhcyBwcmltYXJ5IHdpdGggcG9sbCBiaXQgc2V0CiAqLwp2b2lkIGlybGFwX3NlbmRfZGF0YV9wcmltYXJ5X3BvbGwoc3RydWN0IGlybGFwX2NiICpzZWxmLCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQp7CglzdHJ1Y3Qgc2tfYnVmZiAqdHhfc2tiOwoJaW50IHRyYW5zbWlzc2lvbl90aW1lOwoKCS8qIFN0b3AgUCB0aW1lciAqLwoJZGVsX3RpbWVyKCZzZWxmLT5wb2xsX3RpbWVyKTsKCgkvKiBJcyB0aGlzIHJlbGlhYmxlIG9yIHVucmVsaWFibGUgZGF0YT8gKi8KCWlmIChza2ItPmRhdGFbMV0gPT0gSV9GUkFNRSkgewoKCQkvKgoJCSAqICBJbnNlcnQgZnJhbWUgc2VxdWVuY2UgbnVtYmVyIChWcykgaW4gY29udHJvbCBmaWVsZCBiZWZvcmUKCQkgKiAgaW5zZXJ0aW5nIGludG8gdHJhbnNtaXQgd2luZG93IHF1ZXVlLgoJCSAqLwoJCXNrYi0+ZGF0YVsxXSA9IElfRlJBTUUgfCAoc2VsZi0+dnMgPDwgMSk7CgoJCS8qCgkJICogIEluc2VydCBmcmFtZSBpbiBzdG9yZSwgaW4gY2FzZSBvZiByZXRyYW5zbWlzc2lvbnMKCQkgKiAgSW5jcmVhc2Ugc2tiIHJlZmVyZW5jZSBjb3VudCwgc2VlIGlybGFwX2RvX2V2ZW50KCkKCQkgKi8KCQlza2JfZ2V0KHNrYik7CgkJc2tiX3F1ZXVlX3RhaWwoJnNlbGYtPnd4X2xpc3QsIHNrYik7CgoJCS8qIENvcHkgYnVmZmVyICovCgkJdHhfc2tiID0gc2tiX2Nsb25lKHNrYiwgR0ZQX0FUT01JQyk7CgkJaWYgKHR4X3NrYiA9PSBOVUxMKSB7CgkJCXJldHVybjsKCQl9CgoJCS8qCgkJICogIFNldCBwb2xsIGJpdCBpZiBuZWNlc3NhcnkuIFdlIGRvIHRoaXMgdG8gdGhlIGNvcGllZAoJCSAqICBza2IsIHNpbmNlIHJldHJhbnNtaXR0ZWQgbmVlZCB0byBzZXQgb3IgY2xlYXIgdGhlIHBvbGwKCQkgKiAgYml0IGRlcGVuZGluZyBvbiB3aGVuIHRoZXkgYXJlIHNlbnQuCgkJICovCgkJdHhfc2tiLT5kYXRhWzFdIHw9IFBGX0JJVDsKCgkJc2VsZi0+dnMgPSAoc2VsZi0+dnMgKyAxKSAlIDg7CgkJc2VsZi0+YWNrX3JlcXVpcmVkID0gRkFMU0U7CgoJCWlybGFwX25leHRfc3RhdGUoc2VsZiwgTEFQX05STV9QKTsKCQlpcmxhcF9zZW5kX2lfZnJhbWUoc2VsZiwgdHhfc2tiLCBDTURfRlJBTUUpOwoJfSBlbHNlIHsKCQlJUkRBX0RFQlVHKDQsICIlcygpLCBzZW5kaW5nIHVucmVsaWFibGUgZnJhbWVcbiIsIF9fRlVOQ1RJT05fXyk7CgoJCWlmIChzZWxmLT5hY2tfcmVxdWlyZWQpIHsKCQkJaXJsYXBfc2VuZF91aV9mcmFtZShzZWxmLCBza2JfZ2V0KHNrYiksIHNlbGYtPmNhZGRyLCBDTURfRlJBTUUpOwoJCQlpcmxhcF9uZXh0X3N0YXRlKHNlbGYsIExBUF9OUk1fUCk7CgkJCWlybGFwX3NlbmRfcnJfZnJhbWUoc2VsZiwgQ01EX0ZSQU1FKTsKCQkJc2VsZi0+YWNrX3JlcXVpcmVkID0gRkFMU0U7CgkJfSBlbHNlIHsKCQkJc2tiLT5kYXRhWzFdIHw9IFBGX0JJVDsKCQkJaXJsYXBfbmV4dF9zdGF0ZShzZWxmLCBMQVBfTlJNX1ApOwoJCQlpcmxhcF9zZW5kX3VpX2ZyYW1lKHNlbGYsIHNrYl9nZXQoc2tiKSwgc2VsZi0+Y2FkZHIsIENNRF9GUkFNRSk7CgkJfQoJfQoKCS8qIEhvdyBtdWNoIHRpbWUgd2UgdG9vayBmb3IgdHJhbnNtaXNzaW9uIG9mIGFsbCBmcmFtZXMuCgkgKiBXZSBkb24ndCBrbm93LCBzbyBsZXQgYXNzdW1lIHdlIHVzZWQgdGhlIGZ1bGwgd2luZG93LiBKZWFuIElJICovCgl0cmFuc21pc3Npb25fdGltZSA9IHNlbGYtPmZpbmFsX3RpbWVvdXQ7CgoJLyogUmVzZXQgcGFyYW1ldGVyIHNvIHRoYXQgd2UgY2FuIGZpbGwgbmV4dCB3aW5kb3cgKi8KCXNlbGYtPndpbmRvdyA9IHNlbGYtPndpbmRvd19zaXplOwoKI2lmZGVmIENPTkZJR19JUkRBX0RZTkFNSUNfV0lORE9XCgkvKiBSZW1vdmUgd2hhdCB3ZSBoYXZlIG5vdCB1c2VkLiBKdXN0IGRvIGEgcHJvcmF0YSBvZiB0aGUKCSAqIGJ5dGVzIGxlZnQgaW4gd2luZG93IHRvIHdpbmRvdyBjYXBhY2l0eS4KCSAqIFNlZSBtYXhfbGluZV9jYXBhY2l0aWVzW11bXSBpbiBxb3MuYyBmb3IgZGV0YWlscy4gSmVhbiBJSSAqLwoJdHJhbnNtaXNzaW9uX3RpbWUgLT0gKHNlbGYtPmZpbmFsX3RpbWVvdXQgKiBzZWxmLT5ieXRlc19sZWZ0CgkJCSAgICAgIC8gc2VsZi0+bGluZV9jYXBhY2l0eSk7CglJUkRBX0RFQlVHKDQsICIlcygpIGFkanVzdGluZyB0cmFuc21pc3Npb25fdGltZSA6IGZ0PSVkLCBibD0lZCwgbGM9JWQgLT4gdHQ9JWRcbiIsIF9fRlVOQ1RJT05fXywgc2VsZi0+ZmluYWxfdGltZW91dCwgc2VsZi0+Ynl0ZXNfbGVmdCwgc2VsZi0+bGluZV9jYXBhY2l0eSwgdHJhbnNtaXNzaW9uX3RpbWUpOwoKCS8qIFdlIGFyZSBhbGxvd2VkIHRvIHRyYW5zbWl0IGEgbWF4aW11bSBudW1iZXIgb2YgYnl0ZXMgYWdhaW4uICovCglzZWxmLT5ieXRlc19sZWZ0ID0gc2VsZi0+bGluZV9jYXBhY2l0eTsKI2VuZGlmIC8qIENPTkZJR19JUkRBX0RZTkFNSUNfV0lORE9XICovCgoJLyoKCSAqIFRoZSBuZXR3b3JrIGxheWVyIGhhcyBhIGludGVybWVkaWF0ZSBidWZmZXIgYmV0d2VlbiBJckxBUAoJICogYW5kIHRoZSBJckRBIGRyaXZlciB3aGljaCBjYW4gY29udGFpbiA4IGZyYW1lcy4gU28sIGV2ZW4KCSAqIHRob3VnaCBJckxBUCBpcyBjdXJyZW50bHkgc2VuZGluZyB0aGUgKmxhc3QqIGZyYW1lIG9mIHRoZQoJICogdHgtd2luZG93LCB0aGUgZHJpdmVyIG1vc3QgbGlrZWx5IGhhcyBvbmx5IGp1c3Qgc3RhcnRlZAoJICogc2VuZGluZyB0aGUgKmZpcnN0KiBmcmFtZSBvZiB0aGUgc2FtZSB0eC13aW5kb3cuCgkgKiBJLmUuIHdlIGFyZSBhbHdheXMgYXQgdGhlIHZlcnkgYmVnaW5pbmcgb2Ygb3IgVHggd2luZG93LgoJICogTm93LCB3ZSBhcmUgc3VwcG9zZWQgdG8gc2V0IHRoZSBmaW5hbCB0aW1lciBmcm9tIHRoZSBlbmQKCSAqIG9mIG91ciB0eC13aW5kb3cgdG8gbGV0IHRoZSBvdGhlciBwZWVyIHJlcGx5LiBTbywgd2UgbmVlZAoJICogdG8gYWRkIGV4dHJhIHRpbWUgdG8gY29tcGVuc2F0ZSBmb3IgdGhlIGZhY3QgdGhhdCB3ZQoJICogYXJlIHJlYWxseSBhdCB0aGUgc3RhcnQgb2YgdHgtd2luZG93LCBvdGhlcndpc2UgdGhlIGZpbmFsIHRpbWVyCgkgKiBtaWdodCBleHBpcmUgYmVmb3JlIGhlIGNhbiBhbnN3ZXIuLi4KCSAqIEplYW4gSUkKCSAqLwoJaXJsYXBfc3RhcnRfZmluYWxfdGltZXIoc2VsZiwgc2VsZi0+ZmluYWxfdGltZW91dCArIHRyYW5zbWlzc2lvbl90aW1lKTsKCgkvKgoJICogVGhlIGNsZXZlciBhbW9uZ3N0IHlvdSBtaWdodCBhc2sgd2h5IHdlIGRvIHRoaXMgYWRqdXN0ZW1lbnQKCSAqIG9ubHkgaGVyZSwgYW5kIG5vdCBpbiBhbGwgdGhlIG90aGVyIGNhc2VzIGluIGlybGFwX2V2ZW50LmMuCgkgKiBJbiBhbGwgdGhvc2Ugb3RoZXIgY2FzZSwgd2Ugb25seSBzZW5kIGEgdmVyeSBzaG9ydCBtYW5hZ2VtZW50CgkgKiBmcmFtZSAoZmV3IGJ5dGVzKSwgc28gdGhlIGFkanVzdGVtZW50IHdvdWxkIGJlIGxvc3QgaW4gdGhlCgkgKiBub2lzZS4uLgoJICogVGhlIGV4Y2VwdGlvbiBvZiBjb3Vyc2UgaXMgaXJsYXBfcmVzZW5kX3JlamVjdGVkX2ZyYW1lKCkuCgkgKiBKZWFuIElJICovCn0KCi8qCiAqIEZ1bmN0aW9uIGlybGFwX3NlbmRfZGF0YV9zZWNvbmRhcnlfZmluYWwgKHNlbGYsIHNrYikKICoKICogICAgU2VuZCBJKG5mb3JtYXRpb24pIGZyYW1lIGFzIHNlY29uZGFyeSB3aXRoIGZpbmFsIGJpdCBzZXQKICoKICovCnZvaWQgaXJsYXBfc2VuZF9kYXRhX3NlY29uZGFyeV9maW5hbChzdHJ1Y3QgaXJsYXBfY2IgKnNlbGYsCgkJCQkgICAgIHN0cnVjdCBza19idWZmICpza2IpCnsKCXN0cnVjdCBza19idWZmICp0eF9za2IgPSBOVUxMOwoKCUlSREFfQVNTRVJUKHNlbGYgIT0gTlVMTCwgcmV0dXJuOyk7CglJUkRBX0FTU0VSVChzZWxmLT5tYWdpYyA9PSBMQVBfTUFHSUMsIHJldHVybjspOwoJSVJEQV9BU1NFUlQoc2tiICE9IE5VTEwsIHJldHVybjspOwoKCS8qIElzIHRoaXMgcmVsaWFibGUgb3IgdW5yZWxpYWJsZSBkYXRhPyAqLwoJaWYgKHNrYi0+ZGF0YVsxXSA9PSBJX0ZSQU1FKSB7CgoJCS8qCgkJICogIEluc2VydCBmcmFtZSBzZXF1ZW5jZSBudW1iZXIgKFZzKSBpbiBjb250cm9sIGZpZWxkIGJlZm9yZQoJCSAqICBpbnNlcnRpbmcgaW50byB0cmFuc21pdCB3aW5kb3cgcXVldWUuCgkJICovCgkJc2tiLT5kYXRhWzFdID0gSV9GUkFNRSB8IChzZWxmLT52cyA8PCAxKTsKCgkJLyoKCQkgKiAgSW5zZXJ0IGZyYW1lIGluIHN0b3JlLCBpbiBjYXNlIG9mIHJldHJhbnNtaXNzaW9ucwoJCSAqICBJbmNyZWFzZSBza2IgcmVmZXJlbmNlIGNvdW50LCBzZWUgaXJsYXBfZG9fZXZlbnQoKQoJCSAqLwoJCXNrYl9nZXQoc2tiKTsKCQlza2JfcXVldWVfdGFpbCgmc2VsZi0+d3hfbGlzdCwgc2tiKTsKCgkJdHhfc2tiID0gc2tiX2Nsb25lKHNrYiwgR0ZQX0FUT01JQyk7CgkJaWYgKHR4X3NrYiA9PSBOVUxMKSB7CgkJCXJldHVybjsKCQl9CgoJCXR4X3NrYi0+ZGF0YVsxXSB8PSBQRl9CSVQ7CgoJCXNlbGYtPnZzID0gKHNlbGYtPnZzICsgMSkgJSA4OwoJCXNlbGYtPmFja19yZXF1aXJlZCA9IEZBTFNFOwoKCQlpcmxhcF9zZW5kX2lfZnJhbWUoc2VsZiwgdHhfc2tiLCBSU1BfRlJBTUUpOwoJfSBlbHNlIHsKCQlpZiAoc2VsZi0+YWNrX3JlcXVpcmVkKSB7CgkJCWlybGFwX3NlbmRfdWlfZnJhbWUoc2VsZiwgc2tiX2dldChza2IpLCBzZWxmLT5jYWRkciwgUlNQX0ZSQU1FKTsKCQkJaXJsYXBfc2VuZF9ycl9mcmFtZShzZWxmLCBSU1BfRlJBTUUpOwoJCQlzZWxmLT5hY2tfcmVxdWlyZWQgPSBGQUxTRTsKCQl9IGVsc2UgewoJCQlza2ItPmRhdGFbMV0gfD0gUEZfQklUOwoJCQlpcmxhcF9zZW5kX3VpX2ZyYW1lKHNlbGYsIHNrYl9nZXQoc2tiKSwgc2VsZi0+Y2FkZHIsIFJTUF9GUkFNRSk7CgkJfQoJfQoKCXNlbGYtPndpbmRvdyA9IHNlbGYtPndpbmRvd19zaXplOwojaWZkZWYgQ09ORklHX0lSREFfRFlOQU1JQ19XSU5ET1cKCS8qIFdlIGFyZSBhbGxvd2VkIHRvIHRyYW5zbWl0IGEgbWF4aW11bSBudW1iZXIgb2YgYnl0ZXMgYWdhaW4uICovCglzZWxmLT5ieXRlc19sZWZ0ID0gc2VsZi0+bGluZV9jYXBhY2l0eTsKI2VuZGlmIC8qIENPTkZJR19JUkRBX0RZTkFNSUNfV0lORE9XICovCgoJaXJsYXBfc3RhcnRfd2RfdGltZXIoc2VsZiwgc2VsZi0+d2RfdGltZW91dCk7Cn0KCi8qCiAqIEZ1bmN0aW9uIGlybGFwX3NlbmRfZGF0YV9zZWNvbmRhcnkgKHNlbGYsIHNrYikKICoKICogICAgU2VuZCBJKG5mb3JtYXRpb24pIGZyYW1lIGFzIHNlY29uZGFyeSB3aXRob3V0IGZpbmFsIGJpdCBzZXQKICoKICovCnZvaWQgaXJsYXBfc2VuZF9kYXRhX3NlY29uZGFyeShzdHJ1Y3QgaXJsYXBfY2IgKnNlbGYsIHN0cnVjdCBza19idWZmICpza2IpCnsKCXN0cnVjdCBza19idWZmICp0eF9za2IgPSBOVUxMOwoKCS8qIElzIHRoaXMgcmVsaWFibGUgb3IgdW5yZWxpYWJsZSBkYXRhPyAqLwoJaWYgKHNrYi0+ZGF0YVsxXSA9PSBJX0ZSQU1FKSB7CgoJCS8qCgkJICogIEluc2VydCBmcmFtZSBzZXF1ZW5jZSBudW1iZXIgKFZzKSBpbiBjb250cm9sIGZpZWxkIGJlZm9yZQoJCSAqICBpbnNlcnRpbmcgaW50byB0cmFuc21pdCB3aW5kb3cgcXVldWUuCgkJICovCgkJc2tiLT5kYXRhWzFdID0gSV9GUkFNRSB8IChzZWxmLT52cyA8PCAxKTsKCgkJLyoKCQkgKiAgSW5zZXJ0IGZyYW1lIGluIHN0b3JlLCBpbiBjYXNlIG9mIHJldHJhbnNtaXNzaW9ucwoJCSAqICBJbmNyZWFzZSBza2IgcmVmZXJlbmNlIGNvdW50LCBzZWUgaXJsYXBfZG9fZXZlbnQoKQoJCSAqLwoJCXNrYl9nZXQoc2tiKTsKCQlza2JfcXVldWVfdGFpbCgmc2VsZi0+d3hfbGlzdCwgc2tiKTsKCgkJdHhfc2tiID0gc2tiX2Nsb25lKHNrYiwgR0ZQX0FUT01JQyk7CgkJaWYgKHR4X3NrYiA9PSBOVUxMKSB7CgkJCXJldHVybjsKCQl9CgoJCXNlbGYtPnZzID0gKHNlbGYtPnZzICsgMSkgJSA4OwoJCXNlbGYtPmFja19yZXF1aXJlZCA9IEZBTFNFOwoJCXNlbGYtPndpbmRvdyAtPSAxOwoKCQlpcmxhcF9zZW5kX2lfZnJhbWUoc2VsZiwgdHhfc2tiLCBSU1BfRlJBTUUpOwoJfSBlbHNlIHsKCQlpcmxhcF9zZW5kX3VpX2ZyYW1lKHNlbGYsIHNrYl9nZXQoc2tiKSwgc2VsZi0+Y2FkZHIsIFJTUF9GUkFNRSk7CgkJc2VsZi0+d2luZG93IC09IDE7Cgl9Cn0KCi8qCiAqIEZ1bmN0aW9uIGlybGFwX3Jlc2VuZF9yZWplY3RlZF9mcmFtZXMgKG5yKQogKgogKiAgICBSZXNlbmQgZnJhbWVzIHdoaWNoIGhhcyBub3QgYmVlbiBhY2tub3dsZWRnZWQuIFNob3VsZCBiZSBzYWZlIHRvCiAqICAgIHRyYXZlcnNlIHRoZSBsaXN0IHdpdGhvdXQgbG9ja2luZyBpdCBzaW5jZSB0aGlzIGZ1bmN0aW9uIHdpbGwgb25seSBiZQogKiAgICBjYWxsZWQgZnJvbSBpbnRlcnJ1cHQgY29udGV4dCAoQkgpCiAqLwp2b2lkIGlybGFwX3Jlc2VuZF9yZWplY3RlZF9mcmFtZXMoc3RydWN0IGlybGFwX2NiICpzZWxmLCBpbnQgY29tbWFuZCkKewoJc3RydWN0IHNrX2J1ZmYgKnR4X3NrYjsKCXN0cnVjdCBza19idWZmICpza2I7CglpbnQgY291bnQ7CgoJSVJEQV9BU1NFUlQoc2VsZiAhPSBOVUxMLCByZXR1cm47KTsKCUlSREFfQVNTRVJUKHNlbGYtPm1hZ2ljID09IExBUF9NQUdJQywgcmV0dXJuOyk7CgoJLyogSW5pdGlhbGl6ZSB2YXJpYWJsZXMgKi8KCWNvdW50ID0gc2tiX3F1ZXVlX2xlbigmc2VsZi0+d3hfbGlzdCk7CgoJLyogIFJlc2VuZCB1bmFja25vd2xlZGdlZCBmcmFtZShzKSAqLwoJc2tiID0gc2tiX3BlZWsoJnNlbGYtPnd4X2xpc3QpOwoJd2hpbGUgKHNrYiAhPSBOVUxMKSB7CgkJaXJsYXBfd2FpdF9taW5fdHVybl9hcm91bmQoc2VsZiwgJnNlbGYtPnFvc190eCk7CgoJCS8qIFdlIGNvcHkgdGhlIHNrYiB0byBiZSByZXRyYW5zbWl0dGVkIHNpbmNlIHdlIHdpbGwgaGF2ZSB0bwoJCSAqIG1vZGlmeSBpdC4gQ2xvbmluZyB3aWxsIGNvbmZ1c2UgcGFja2V0IHNuaWZmZXJzCgkJICovCgkJLyogdHhfc2tiID0gc2tiX2Nsb25lKCBza2IsIEdGUF9BVE9NSUMpOyAqLwoJCXR4X3NrYiA9IHNrYl9jb3B5KHNrYiwgR0ZQX0FUT01JQyk7CgkJaWYgKCF0eF9za2IpIHsKCQkJSVJEQV9ERUJVRygwLCAiJXMoKSwgdW5hYmxlIHRvIGNvcHlcbiIsIF9fRlVOQ1RJT05fXyk7CgkJCXJldHVybjsKCQl9CgoJCS8qIENsZWFyIG9sZCBOciBmaWVsZCArIHBvbGwgYml0ICovCgkJdHhfc2tiLT5kYXRhWzFdICY9IDB4MGY7CgoJCS8qCgkJICogIFNldCBwb2xsIGJpdCBvbiB0aGUgbGFzdCBmcmFtZSByZXRyYW5zbWl0dGVkCgkJICovCgkJaWYgKGNvdW50LS0gPT0gMSkKCQkJdHhfc2tiLT5kYXRhWzFdIHw9IFBGX0JJVDsgLyogU2V0IHAvZiBiaXQgKi8KCQllbHNlCgkJCXR4X3NrYi0+ZGF0YVsxXSAmPSB+UEZfQklUOyAvKiBDbGVhciBwL2YgYml0ICovCgoJCWlybGFwX3NlbmRfaV9mcmFtZShzZWxmLCB0eF9za2IsIGNvbW1hbmQpOwoKCQkvKgoJCSAqICBJZiBvdXIgc2tiIGlzIHRoZSBsYXN0IGJ1ZmZlciBpbiB0aGUgbGlzdCwgdGhlbgoJCSAqICB3ZSBhcmUgZmluaXNoZWQsIGlmIG5vdCwgbW92ZSB0byB0aGUgbmV4dCBzay1idWZmZXIKCQkgKi8KCQlpZiAoc2tiID09IHNrYl9wZWVrX3RhaWwoJnNlbGYtPnd4X2xpc3QpKQoJCQlza2IgPSBOVUxMOwoJCWVsc2UKCQkJc2tiID0gc2tiLT5uZXh0OwoJfQojaWYgMCAvKiBOb3QgeWV0ICovCgkvKgoJICogIFdlIGNhbiBub3cgZmlsbCB0aGUgd2luZG93IHdpdGggYWRkaXRpb25hbCBkYXRhIGZyYW1lcwoJICovCgl3aGlsZSAoIXNrYl9xdWV1ZV9lbXB0eSgmc2VsZi0+dHhxKSkgewoKCQlJUkRBX0RFQlVHKDAsICIlcygpLCBzZW5kaW5nIGFkZGl0aW9uYWwgZnJhbWVzIVxuIiwgX19GVU5DVElPTl9fKTsKCQlpZiAoc2VsZi0+d2luZG93ID4gMCkgewoJCQlza2IgPSBza2JfZGVxdWV1ZSggJnNlbGYtPnR4cSk7CgkJCUlSREFfQVNTRVJUKHNrYiAhPSBOVUxMLCByZXR1cm47KTsKCgkJCS8qCgkJCSAqICBJZiBzZW5kIHdpbmRvdyA+IDEgdGhlbiBzZW5kIGZyYW1lIHdpdGggcGYKCQkJICogIGJpdCBjbGVhcmVkCgkJCSAqLwoJCQlpZiAoKHNlbGYtPndpbmRvdyA+IDEpICYmCgkJCSAgICAhc2tiX3F1ZXVlX2VtcHR5KCZzZWxmLT50eHEpKSB7CgkJCQlpcmxhcF9zZW5kX2RhdGFfcHJpbWFyeShzZWxmLCBza2IpOwoJCQl9IGVsc2UgewoJCQkJaXJsYXBfc2VuZF9kYXRhX3ByaW1hcnlfcG9sbChzZWxmLCBza2IpOwoJCQl9CgkJCWtmcmVlX3NrYihza2IpOwoJCX0KCX0KI2VuZGlmCn0KCnZvaWQgaXJsYXBfcmVzZW5kX3JlamVjdGVkX2ZyYW1lKHN0cnVjdCBpcmxhcF9jYiAqc2VsZiwgaW50IGNvbW1hbmQpCnsKCXN0cnVjdCBza19idWZmICp0eF9za2I7CglzdHJ1Y3Qgc2tfYnVmZiAqc2tiOwoKCUlSREFfQVNTRVJUKHNlbGYgIT0gTlVMTCwgcmV0dXJuOyk7CglJUkRBX0FTU0VSVChzZWxmLT5tYWdpYyA9PSBMQVBfTUFHSUMsIHJldHVybjspOwoKCS8qICBSZXNlbmQgdW5hY2tub3dsZWRnZWQgZnJhbWUocykgKi8KCXNrYiA9IHNrYl9wZWVrKCZzZWxmLT53eF9saXN0KTsKCWlmIChza2IgIT0gTlVMTCkgewoJCWlybGFwX3dhaXRfbWluX3R1cm5fYXJvdW5kKHNlbGYsICZzZWxmLT5xb3NfdHgpOwoKCQkvKiBXZSBjb3B5IHRoZSBza2IgdG8gYmUgcmV0cmFuc21pdHRlZCBzaW5jZSB3ZSB3aWxsIGhhdmUgdG8KCQkgKiBtb2RpZnkgaXQuIENsb25pbmcgd2lsbCBjb25mdXNlIHBhY2tldCBzbmlmZmVycwoJCSAqLwoJCS8qIHR4X3NrYiA9IHNrYl9jbG9uZSggc2tiLCBHRlBfQVRPTUlDKTsgKi8KCQl0eF9za2IgPSBza2JfY29weShza2IsIEdGUF9BVE9NSUMpOwoJCWlmICghdHhfc2tiKSB7CgkJCUlSREFfREVCVUcoMCwgIiVzKCksIHVuYWJsZSB0byBjb3B5XG4iLCBfX0ZVTkNUSU9OX18pOwoJCQlyZXR1cm47CgkJfQoKCQkvKiBDbGVhciBvbGQgTnIgZmllbGQgKyBwb2xsIGJpdCAqLwoJCXR4X3NrYi0+ZGF0YVsxXSAmPSAweDBmOwoKCQkvKiAgU2V0IHBvbGwvZmluYWwgYml0ICovCgkJdHhfc2tiLT5kYXRhWzFdIHw9IFBGX0JJVDsgLyogU2V0IHAvZiBiaXQgKi8KCgkJaXJsYXBfc2VuZF9pX2ZyYW1lKHNlbGYsIHR4X3NrYiwgY29tbWFuZCk7Cgl9Cn0KCi8qCiAqIEZ1bmN0aW9uIGlybGFwX3NlbmRfdWlfZnJhbWUgKHNlbGYsIHNrYiwgY29tbWFuZCkKICoKICogICAgQ29udHJ1Y3QgYW5kIHRyYW5zbWl0IGFuIFVubnVtYmVyZWQgSW5mb3JtYXRpb24gKFVJKSBmcmFtZQogKgogKi8Kdm9pZCBpcmxhcF9zZW5kX3VpX2ZyYW1lKHN0cnVjdCBpcmxhcF9jYiAqc2VsZiwgc3RydWN0IHNrX2J1ZmYgKnNrYiwKCQkJIF9fdTggY2FkZHIsIGludCBjb21tYW5kKQp7CglJUkRBX0RFQlVHKDQsICIlcygpXG4iLCBfX0ZVTkNUSU9OX18pOwoKCUlSREFfQVNTRVJUKHNlbGYgIT0gTlVMTCwgcmV0dXJuOyk7CglJUkRBX0FTU0VSVChzZWxmLT5tYWdpYyA9PSBMQVBfTUFHSUMsIHJldHVybjspOwoJSVJEQV9BU1NFUlQoc2tiICE9IE5VTEwsIHJldHVybjspOwoKCS8qIEluc2VydCBjb25uZWN0aW9uIGFkZHJlc3MgKi8KCXNrYi0+ZGF0YVswXSA9IGNhZGRyIHwgKChjb21tYW5kKSA/IENNRF9GUkFNRSA6IDApOwoKCWlybGFwX3F1ZXVlX3htaXQoc2VsZiwgc2tiKTsKfQoKLyoKICogRnVuY3Rpb24gaXJsYXBfc2VuZF9pX2ZyYW1lIChza2IpCiAqCiAqICAgIENvbnRydWN0IGFuZCB0cmFuc21pdCBJbmZvcm1hdGlvbiAoSSkgZnJhbWUKICovCnN0YXRpYyB2b2lkIGlybGFwX3NlbmRfaV9mcmFtZShzdHJ1Y3QgaXJsYXBfY2IgKnNlbGYsIHN0cnVjdCBza19idWZmICpza2IsCgkJCSAgICAgICBpbnQgY29tbWFuZCkKewoJLyogSW5zZXJ0IGNvbm5lY3Rpb24gYWRkcmVzcyAqLwoJc2tiLT5kYXRhWzBdID0gc2VsZi0+Y2FkZHI7Cglza2ItPmRhdGFbMF0gfD0gKGNvbW1hbmQpID8gQ01EX0ZSQU1FIDogMDsKCgkvKiBJbnNlcnQgbmV4dCB0byByZWNlaXZlIChWcikgKi8KCXNrYi0+ZGF0YVsxXSB8PSAoc2VsZi0+dnIgPDwgNSk7ICAvKiBpbnNlcnQgbnIgKi8KCglpcmxhcF9xdWV1ZV94bWl0KHNlbGYsIHNrYik7Cn0KCi8qCiAqIEZ1bmN0aW9uIGlybGFwX3JlY3ZfaV9mcmFtZSAoc2tiLCBmcmFtZSkKICoKICogICAgUmVjZWl2ZSBhbmQgcGFyc2UgYW4gSSAoSW5mb3JtYXRpb24pIGZyYW1lLCBubyBoYXJtIGluIG1ha2luZyBpdCBpbmxpbmUKICogICAgc2luY2UgaXQncyBjYWxsZWQgb25seSBmcm9tIG9uZSBzaW5nbGUgcGxhY2UgKGlybGFwX2RyaXZlcl9yY3YpLgogKi8Kc3RhdGljIGlubGluZSB2b2lkIGlybGFwX3JlY3ZfaV9mcmFtZShzdHJ1Y3QgaXJsYXBfY2IgKnNlbGYsCgkJCQkgICAgICBzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAoJCQkJICAgICAgc3RydWN0IGlybGFwX2luZm8gKmluZm8sIGludCBjb21tYW5kKQp7CglpbmZvLT5uciA9IHNrYi0+ZGF0YVsxXSA+PiA1OyAgICAgICAgICAvKiBOZXh0IHRvIHJlY2VpdmUgKi8KCWluZm8tPnBmID0gc2tiLT5kYXRhWzFdICYgUEZfQklUOyAgICAgIC8qIEZpbmFsIGJpdCAqLwoJaW5mby0+bnMgPSAoc2tiLT5kYXRhWzFdID4+IDEpICYgMHgwNzsgLyogTmV4dCB0byBzZW5kICovCgoJLyogQ2hlY2sgaWYgdGhpcyBpcyBhIGNvbW1hbmQgb3IgYSByZXNwb25zZSBmcmFtZSAqLwoJaWYgKGNvbW1hbmQpCgkJaXJsYXBfZG9fZXZlbnQoc2VsZiwgUkVDVl9JX0NNRCwgc2tiLCBpbmZvKTsKCWVsc2UKCQlpcmxhcF9kb19ldmVudChzZWxmLCBSRUNWX0lfUlNQLCBza2IsIGluZm8pOwp9CgovKgogKiBGdW5jdGlvbiBpcmxhcF9yZWN2X3VpX2ZyYW1lIChzZWxmLCBza2IsIGluZm8pCiAqCiAqICAgIFJlY2VpdmUgYW5kIHBhcnNlIGFuIFVubnVtYmVyZWQgSW5mb3JtYXRpb24gKFVJKSBmcmFtZQogKgogKi8Kc3RhdGljIHZvaWQgaXJsYXBfcmVjdl91aV9mcmFtZShzdHJ1Y3QgaXJsYXBfY2IgKnNlbGYsIHN0cnVjdCBza19idWZmICpza2IsCgkJCQlzdHJ1Y3QgaXJsYXBfaW5mbyAqaW5mbykKewoJSVJEQV9ERUJVRyggNCwgIiVzKClcbiIsIF9fRlVOQ1RJT05fXyk7CgoJaW5mby0+cGYgPSBza2ItPmRhdGFbMV0gJiBQRl9CSVQ7ICAgICAgLyogRmluYWwgYml0ICovCgoJaXJsYXBfZG9fZXZlbnQoc2VsZiwgUkVDVl9VSV9GUkFNRSwgc2tiLCBpbmZvKTsKfQoKLyoKICogRnVuY3Rpb24gaXJsYXBfcmVjdl9mcm1yX2ZyYW1lIChza2IsIGZyYW1lKQogKgogKiAgICBSZWNlaXZlZCBGcmFtZSBSZWplY3QgcmVzcG9uc2UuCiAqCiAqLwpzdGF0aWMgdm9pZCBpcmxhcF9yZWN2X2ZybXJfZnJhbWUoc3RydWN0IGlybGFwX2NiICpzZWxmLCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAoJCQkJICBzdHJ1Y3QgaXJsYXBfaW5mbyAqaW5mbykKewoJX191OCAqZnJhbWU7CglpbnQgdywgeCwgeSwgejsKCglJUkRBX0RFQlVHKDAsICIlcygpXG4iLCBfX0ZVTkNUSU9OX18pOwoKCUlSREFfQVNTRVJUKHNlbGYgIT0gTlVMTCwgcmV0dXJuOyk7CglJUkRBX0FTU0VSVChzZWxmLT5tYWdpYyA9PSBMQVBfTUFHSUMsIHJldHVybjspOwoJSVJEQV9BU1NFUlQoc2tiICE9IE5VTEwsIHJldHVybjspOwoJSVJEQV9BU1NFUlQoaW5mbyAhPSBOVUxMLCByZXR1cm47KTsKCglpZiAoIXBza2JfbWF5X3B1bGwoc2tiLCA0KSkgewoJCUlSREFfRVJST1IoIiVzOiBmcmFtZSB0b28gc2hvcnQhXG4iLCBfX0ZVTkNUSU9OX18pOwoJCXJldHVybjsKCX0KCglmcmFtZSA9IHNrYi0+ZGF0YTsKCglpbmZvLT5uciA9IGZyYW1lWzJdID4+IDU7ICAgICAgICAgIC8qIE5leHQgdG8gcmVjZWl2ZSAqLwoJaW5mby0+cGYgPSBmcmFtZVsyXSAmIFBGX0JJVDsgICAgICAvKiBGaW5hbCBiaXQgKi8KCWluZm8tPm5zID0gKGZyYW1lWzJdID4+IDEpICYgMHgwNzsgLyogTmV4dCB0byBzZW5kICovCgoJdyA9IGZyYW1lWzNdICYgMHgwMTsKCXggPSBmcmFtZVszXSAmIDB4MDI7Cgl5ID0gZnJhbWVbM10gJiAweDA0OwoJeiA9IGZyYW1lWzNdICYgMHgwODsKCglpZiAodykgewoJCUlSREFfREVCVUcoMCwgIlJlamVjdGVkIGNvbnRyb2wgZmllbGQgaXMgdW5kZWZpbmVkIG9yIG5vdCAiCgkJICAgICAgImltcGxlbWVudGVkLlxuIik7Cgl9CglpZiAoeCkgewoJCUlSREFfREVCVUcoMCwgIlJlamVjdGVkIGNvbnRyb2wgZmllbGQgd2FzIGludmFsaWQgYmVjYXVzZSBpdCAiCgkJICAgICAgImNvbnRhaW5lZCBhIG5vbiBwZXJtaXR0ZWQgSSBmaWVsZC5cbiIpOwoJfQoJaWYgKHkpIHsKCQlJUkRBX0RFQlVHKDAsICJSZWNlaXZlZCBJIGZpZWxkIGV4Y2VlZGVkIHRoZSBtYXhpbXVtIG5lZ290aWF0ZWQgIgoJCSAgICAgICJmb3IgdGhlIGV4aXN0aW5nIGNvbm5lY3Rpb24gb3IgZXhjZWVkZWQgdGhlIG1heGltdW0gIgoJCSAgICAgICJ0aGlzIHN0YXRpb24gc3VwcG9ydHMgaWYgbm8gY29ubmVjdGlvbiBleGlzdHMuXG4iKTsKCX0KCWlmICh6KSB7CgkJSVJEQV9ERUJVRygwLCAiUmVqZWN0ZWQgY29udHJvbCBmaWVsZCBjb250cm9sIGZpZWxkIGNvbnRhaW5lZCBhbiAiCgkJICAgICAgImludmFsaWQgTnIgY291bnQuXG4iKTsKCX0KCWlybGFwX2RvX2V2ZW50KHNlbGYsIFJFQ1ZfRlJNUl9SU1AsIHNrYiwgaW5mbyk7Cn0KCi8qCiAqIEZ1bmN0aW9uIGlybGFwX3NlbmRfdGVzdF9mcmFtZSAoc2VsZiwgZGFkZHIpCiAqCiAqICAgIFNlbmQgYSB0ZXN0IGZyYW1lIHJlc3BvbnNlCiAqCiAqLwp2b2lkIGlybGFwX3NlbmRfdGVzdF9mcmFtZShzdHJ1Y3QgaXJsYXBfY2IgKnNlbGYsIF9fdTggY2FkZHIsIF9fdTMyIGRhZGRyLAoJCQkgICBzdHJ1Y3Qgc2tfYnVmZiAqY21kKQp7CglzdHJ1Y3Qgc2tfYnVmZiAqdHhfc2tiOwoJc3RydWN0IHRlc3RfZnJhbWUgKmZyYW1lOwoJX191OCAqaW5mbzsKCgl0eF9za2IgPSBhbGxvY19za2IoY21kLT5sZW4gKyBzaXplb2Yoc3RydWN0IHRlc3RfZnJhbWUpLCBHRlBfQVRPTUlDKTsKCWlmICghdHhfc2tiKQoJCXJldHVybjsKCgkvKiBCcm9hZGNhc3QgZnJhbWVzIG11c3QgaW5jbHVkZSBzYWRkciBhbmQgZGFkZHIgZmllbGRzICovCglpZiAoY2FkZHIgPT0gQ0JST0FEQ0FTVCkgewoJCWZyYW1lID0gKHN0cnVjdCB0ZXN0X2ZyYW1lICopCgkJCXNrYl9wdXQodHhfc2tiLCBzaXplb2Yoc3RydWN0IHRlc3RfZnJhbWUpKTsKCgkJLyogSW5zZXJ0IHRoZSBzd2FwcGVkIGFkZHJlc3NlcyAqLwoJCWZyYW1lLT5zYWRkciA9IGNwdV90b19sZTMyKHNlbGYtPnNhZGRyKTsKCQlmcmFtZS0+ZGFkZHIgPSBjcHVfdG9fbGUzMihkYWRkcik7Cgl9IGVsc2UKCQlmcmFtZSA9IChzdHJ1Y3QgdGVzdF9mcmFtZSAqKSBza2JfcHV0KHR4X3NrYiwgTEFQX0FERFJfSEVBREVSICsgTEFQX0NUUkxfSEVBREVSKTsKCglmcmFtZS0+Y2FkZHIgPSBjYWRkcjsKCWZyYW1lLT5jb250cm9sID0gVEVTVF9SU1AgfCBQRl9CSVQ7CgoJLyogQ29weSBpbmZvICovCglpbmZvID0gc2tiX3B1dCh0eF9za2IsIGNtZC0+bGVuKTsKCW1lbWNweShpbmZvLCBjbWQtPmRhdGEsIGNtZC0+bGVuKTsKCgkvKiBSZXR1cm4gdG8gc2VuZGVyICovCglpcmxhcF93YWl0X21pbl90dXJuX2Fyb3VuZChzZWxmLCAmc2VsZi0+cW9zX3R4KTsKCWlybGFwX3F1ZXVlX3htaXQoc2VsZiwgdHhfc2tiKTsKfQoKLyoKICogRnVuY3Rpb24gaXJsYXBfcmVjdl90ZXN0X2ZyYW1lIChzZWxmLCBza2IpCiAqCiAqICAgIFJlY2VpdmUgYSB0ZXN0IGZyYW1lCiAqCiAqLwpzdGF0aWMgdm9pZCBpcmxhcF9yZWN2X3Rlc3RfZnJhbWUoc3RydWN0IGlybGFwX2NiICpzZWxmLCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAoJCQkJICBzdHJ1Y3QgaXJsYXBfaW5mbyAqaW5mbywgaW50IGNvbW1hbmQpCnsKCXN0cnVjdCB0ZXN0X2ZyYW1lICpmcmFtZTsKCglJUkRBX0RFQlVHKDIsICIlcygpXG4iLCBfX0ZVTkNUSU9OX18pOwoKCWlmICghcHNrYl9tYXlfcHVsbChza2IsIHNpemVvZigqZnJhbWUpKSkgewoJCUlSREFfRVJST1IoIiVzOiBmcmFtZSB0b28gc2hvcnQhXG4iLCBfX0ZVTkNUSU9OX18pOwoJCXJldHVybjsKCX0KCWZyYW1lID0gKHN0cnVjdCB0ZXN0X2ZyYW1lICopIHNrYi0+ZGF0YTsKCgkvKiBCcm9hZGNhc3QgZnJhbWVzIG11c3QgY2Fycnkgc2FkZHIgYW5kIGRhZGRyIGZpZWxkcyAqLwoJaWYgKGluZm8tPmNhZGRyID09IENCUk9BRENBU1QpIHsKCQlpZiAoc2tiLT5sZW4gPCBzaXplb2Yoc3RydWN0IHRlc3RfZnJhbWUpKSB7CgkJCUlSREFfREVCVUcoMCwgIiVzKCkgdGVzdCBmcmFtZSB0b28gc2hvcnQhXG4iLAoJCQkJICAgX19GVU5DVElPTl9fKTsKCQkJcmV0dXJuOwoJCX0KCgkJLyogUmVhZCBhbmQgc3dhcCBhZGRyZXNzZXMgKi8KCQlpbmZvLT5kYWRkciA9IGxlMzJfdG9fY3B1KGZyYW1lLT5zYWRkcik7CgkJaW5mby0+c2FkZHIgPSBsZTMyX3RvX2NwdShmcmFtZS0+ZGFkZHIpOwoKCQkvKiBNYWtlIHN1cmUgZnJhbWUgaXMgYWRkcmVzc2VkIHRvIHVzICovCgkJaWYgKChpbmZvLT5zYWRkciAhPSBzZWxmLT5zYWRkcikgJiYKCQkgICAgKGluZm8tPnNhZGRyICE9IEJST0FEQ0FTVCkpIHsKCQkJcmV0dXJuOwoJCX0KCX0KCglpZiAoY29tbWFuZCkKCQlpcmxhcF9kb19ldmVudChzZWxmLCBSRUNWX1RFU1RfQ01ELCBza2IsIGluZm8pOwoJZWxzZQoJCWlybGFwX2RvX2V2ZW50KHNlbGYsIFJFQ1ZfVEVTVF9SU1AsIHNrYiwgaW5mbyk7Cn0KCi8qCiAqIEZ1bmN0aW9uIGlybGFwX2RyaXZlcl9yY3YgKHNrYiwgbmV0ZGV2LCBwdHlwZSkKICoKICogICAgQ2FsbGVkIHdoZW4gYSBmcmFtZSBpcyByZWNlaXZlZC4gRGlzcGF0Y2hlcyB0aGUgcmlnaHQgcmVjZWl2ZSBmdW5jdGlvbgogKiAgICBmb3IgcHJvY2Vzc2luZyBvZiB0aGUgZnJhbWUuCiAqCiAqIE5vdGUgb24gc2tiIG1hbmFnZW1lbnQgOgogKiBBZnRlciBjYWxsaW5nIHRoZSBoaWdoZXIgbGF5ZXJzIG9mIHRoZSBJckRBIHN0YWNrLCB3ZSBhbHdheXMKICoga2ZyZWUoKSB0aGUgc2tiLCB3aGljaCBkcm9wIHRoZSByZWZlcmVuY2UgY291bnQgKGFuZCBwb3RlbnRpYWxseQogKiBkZXN0cm95IGl0KS4KICogSWYgYSBoaWdoZXIgbGF5ZXIgb2YgdGhlIHN0YWNrIHdhbnQgdG8ga2VlcCB0aGUgc2tiIGFyb3VuZCAodG8gcHV0CiAqIGluIGEgcXVldWUgb3IgcGFzcyBpdCB0byB0aGUgaGlnaGVyIGxheWVyKSwgaXQgd2lsbCBuZWVkIHRvIHVzZQogKiBza2JfZ2V0KCkgdG8ga2VlcCBhIHJlZmVyZW5jZSBvbiBpdC4gVGhpcyBpcyB1c3VhbGx5IGRvbmUgYXQgdGhlCiAqIExNUCBsZXZlbCBpbiBpcmxtcC5jLgogKiBKZWFuIElJCiAqLwppbnQgaXJsYXBfZHJpdmVyX3JjdihzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LAoJCSAgICAgc3RydWN0IHBhY2tldF90eXBlICpwdHlwZSwgc3RydWN0IG5ldF9kZXZpY2UgKm9yaWdfZGV2KQp7CglzdHJ1Y3QgaXJsYXBfaW5mbyBpbmZvOwoJc3RydWN0IGlybGFwX2NiICpzZWxmOwoJaW50IGNvbW1hbmQ7CglfX3U4IGNvbnRyb2w7CgoJLyogRklYTUU6IHNob3VsZCB3ZSBnZXQgb3VyIG93biBmaWVsZD8gKi8KCXNlbGYgPSAoc3RydWN0IGlybGFwX2NiICopIGRldi0+YXRhbGtfcHRyOwoKCS8qIElmIHRoZSBuZXQgZGV2aWNlIGlzIGRvd24sIHRoZW4gSXJMQVAgaXMgZ29uZSEgKi8KCWlmICghc2VsZiB8fCBzZWxmLT5tYWdpYyAhPSBMQVBfTUFHSUMpIHsKCQlkZXZfa2ZyZWVfc2tiKHNrYik7CgkJcmV0dXJuIC0xOwoJfQoKCS8qIFdlIGFyZSBubyBsb25nZXIgYW4gIm9sZCIgcHJvdG9jb2wsIHNvIHdlIG5lZWQgdG8gaGFuZGxlCgkgKiBzaGFyZSBhbmQgbm9uIGxpbmVhciBza2JzLiBUaGlzIHNob3VsZCBuZXZlciBoYXBwZW4sIHNvCgkgKiB3ZSBkb24ndCBuZWVkIHRvIGJlIGNsZXZlciBhYm91dCBpdC4gSmVhbiBJSSAqLwoJaWYgKChza2IgPSBza2Jfc2hhcmVfY2hlY2soc2tiLCBHRlBfQVRPTUlDKSkgPT0gTlVMTCkgewoJCUlSREFfRVJST1IoIiVzOiBjYW4ndCBjbG9uZSBzaGFyZWQgc2tiIVxuIiwgX19GVU5DVElPTl9fKTsKCQlkZXZfa2ZyZWVfc2tiKHNrYik7CgkJcmV0dXJuIC0xOwoJfQoKCS8qIENoZWNrIGlmIGZyYW1lIGlzIGxhcmdlIGVub3VnaCBmb3IgcGFyc2luZyAqLwoJaWYgKCFwc2tiX21heV9wdWxsKHNrYiwgMikpIHsKCQlJUkRBX0VSUk9SKCIlczogZnJhbWUgdG9vIHNob3J0IVxuIiwgX19GVU5DVElPTl9fKTsKCQlkZXZfa2ZyZWVfc2tiKHNrYik7CgkJcmV0dXJuIC0xOwoJfQoKCWNvbW1hbmQgICAgPSBza2ItPmRhdGFbMF0gJiBDTURfRlJBTUU7CglpbmZvLmNhZGRyID0gc2tiLT5kYXRhWzBdICYgQ0JST0FEQ0FTVDsKCglpbmZvLnBmICAgICAgPSBza2ItPmRhdGFbMV0gJiAgUEZfQklUOwoJaW5mby5jb250cm9sID0gc2tiLT5kYXRhWzFdICYgflBGX0JJVDsgLyogTWFzayBhd2F5IHBvbGwvZmluYWwgYml0ICovCgoJY29udHJvbCA9IGluZm8uY29udHJvbDsKCgkvKiAgRmlyc3Qgd2UgY2hlY2sgaWYgdGhpcyBmcmFtZSBoYXMgYSB2YWxpZCBjb25uZWN0aW9uIGFkZHJlc3MgKi8KCWlmICgoaW5mby5jYWRkciAhPSBzZWxmLT5jYWRkcikgJiYgKGluZm8uY2FkZHIgIT0gQ0JST0FEQ0FTVCkpIHsKCQlJUkRBX0RFQlVHKDAsICIlcygpLCB3cm9uZyBjb25uZWN0aW9uIGFkZHJlc3MhXG4iLAoJCQkgICBfX0ZVTkNUSU9OX18pOwoJCWdvdG8gb3V0OwoJfQoJLyoKCSAqICBPcHRpbWl6ZSBmb3IgdGhlIGNvbW1vbiBjYXNlIGFuZCBjaGVjayBpZiB0aGUgZnJhbWUgaXMgYW4KCSAqICBJKG5mb3JtYXRpb24pIGZyYW1lLiBPbmx5IEktZnJhbWVzIGhhdmUgYml0IDAgc2V0IHRvIDAKCSAqLwoJaWYgKH5jb250cm9sICYgMHgwMSkgewoJCWlybGFwX3JlY3ZfaV9mcmFtZShzZWxmLCBza2IsICZpbmZvLCBjb21tYW5kKTsKCQlnb3RvIG91dDsKCX0KCS8qCgkgKiAgV2Ugbm93IGNoZWNrIGlzIHRoZSBmcmFtZSBpcyBhbiBTKHVwZXJ2aXNvcnkpIGZyYW1lLiBPbmx5CgkgKiAgUy1mcmFtZXMgaGF2ZSBiaXQgMCBzZXQgdG8gMSBhbmQgYml0IDEgc2V0IHRvIDAKCSAqLwoJaWYgKH5jb250cm9sICYgMHgwMikgewoJCS8qCgkJICogIFJlY2VpdmVkIFModXBlcnZpc29yeSkgZnJhbWUsIGNoZWNrIHdoaWNoIGZyYW1lIHR5cGUgaXQgaXMKCQkgKiAgb25seSB0aGUgZmlyc3QgbmliYmxlIGlzIG9mIGludGVyZXN0CgkJICovCgkJc3dpdGNoIChjb250cm9sICYgMHgwZikgewoJCWNhc2UgUlI6CgkJCWlybGFwX3JlY3ZfcnJfZnJhbWUoc2VsZiwgc2tiLCAmaW5mbywgY29tbWFuZCk7CgkJCWJyZWFrOwoJCWNhc2UgUk5SOgoJCQlpcmxhcF9yZWN2X3Jucl9mcmFtZShzZWxmLCBza2IsICZpbmZvLCBjb21tYW5kKTsKCQkJYnJlYWs7CgkJY2FzZSBSRUo6CgkJCWlybGFwX3JlY3ZfcmVqX2ZyYW1lKHNlbGYsIHNrYiwgJmluZm8sIGNvbW1hbmQpOwoJCQlicmVhazsKCQljYXNlIFNSRUo6CgkJCWlybGFwX3JlY3Zfc3Jlal9mcmFtZShzZWxmLCBza2IsICZpbmZvLCBjb21tYW5kKTsKCQkJYnJlYWs7CgkJZGVmYXVsdDoKCQkJSVJEQV9XQVJOSU5HKCIlczogVW5rbm93biBTLWZyYW1lICUwMnggcmVjZWl2ZWQhXG4iLAoJCQkJX19GVU5DVElPTl9fLCBpbmZvLmNvbnRyb2wpOwoJCQlicmVhazsKCQl9CgkJZ290byBvdXQ7Cgl9CgkvKgoJICogIFRoaXMgbXVzdCBiZSBhIEMob250cm9sKSBmcmFtZQoJICovCglzd2l0Y2ggKGNvbnRyb2wpIHsKCWNhc2UgWElEX1JTUDoKCQlpcmxhcF9yZWN2X2Rpc2NvdmVyeV94aWRfcnNwKHNlbGYsIHNrYiwgJmluZm8pOwoJCWJyZWFrOwoJY2FzZSBYSURfQ01EOgoJCWlybGFwX3JlY3ZfZGlzY292ZXJ5X3hpZF9jbWQoc2VsZiwgc2tiLCAmaW5mbyk7CgkJYnJlYWs7CgljYXNlIFNOUk1fQ01EOgoJCWlybGFwX3JlY3Zfc25ybV9jbWQoc2VsZiwgc2tiLCAmaW5mbyk7CgkJYnJlYWs7CgljYXNlIERNX1JTUDoKCQlpcmxhcF9kb19ldmVudChzZWxmLCBSRUNWX0RNX1JTUCwgc2tiLCAmaW5mbyk7CgkJYnJlYWs7CgljYXNlIERJU0NfQ01EOiAvKiBBbmQgUkRfUlNQIHNpbmNlIHRoZXkgaGF2ZSB0aGUgc2FtZSB2YWx1ZSAqLwoJCWlybGFwX3JlY3ZfZGlzY19mcmFtZShzZWxmLCBza2IsICZpbmZvLCBjb21tYW5kKTsKCQlicmVhazsKCWNhc2UgVEVTVF9DTUQ6CgkJaXJsYXBfcmVjdl90ZXN0X2ZyYW1lKHNlbGYsIHNrYiwgJmluZm8sIGNvbW1hbmQpOwoJCWJyZWFrOwoJY2FzZSBVQV9SU1A6CgkJaXJsYXBfcmVjdl91YV9mcmFtZShzZWxmLCBza2IsICZpbmZvKTsKCQlicmVhazsKCWNhc2UgRlJNUl9SU1A6CgkJaXJsYXBfcmVjdl9mcm1yX2ZyYW1lKHNlbGYsIHNrYiwgJmluZm8pOwoJCWJyZWFrOwoJY2FzZSBVSV9GUkFNRToKCQlpcmxhcF9yZWN2X3VpX2ZyYW1lKHNlbGYsIHNrYiwgJmluZm8pOwoJCWJyZWFrOwoJZGVmYXVsdDoKCQlJUkRBX1dBUk5JTkcoIiVzOiBVbmtub3duIGZyYW1lICUwMnggcmVjZWl2ZWQhXG4iLAoJCQkJX19GVU5DVElPTl9fLCBpbmZvLmNvbnRyb2wpOwoJCWJyZWFrOwoJfQpvdXQ6CgkvKiBBbHdheXMgZHJvcCBvdXIgcmVmZXJlbmNlIG9uIHRoZSBza2IgKi8KCWRldl9rZnJlZV9za2Ioc2tiKTsKCXJldHVybiAwOwp9Cg==