LyoKICoJRnVuY3Rpb25zIHRvIGhhbmRsZSBJMk8gY29udHJvbGxlcnMgYW5kIEkyTyBtZXNzYWdlIGhhbmRsaW5nCiAqCiAqCUNvcHlyaWdodCAoQykgMTk5OS0yMDAyCVJlZCBIYXQgU29mdHdhcmUKICoKICoJV3JpdHRlbiBieSBBbGFuIENveCwgQnVpbGRpbmcgTnVtYmVyIFRocmVlIEx0ZAogKgogKglUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAogKgl1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKICoJRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91cgogKglvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgogKgogKglBIGxvdCBvZiB0aGUgSTJPIG1lc3NhZ2Ugc2lkZSBjb2RlIGZyb20gdGhpcyBpcyB0YWtlbiBmcm9tIHRoZQogKglSZWQgQ3JlZWsgUkNQQ0k0NSBhZGFwdGVyIGRyaXZlciBieSBSZWQgQ3JlZWsgQ29tbXVuaWNhdGlvbnMKICoKICoJRml4ZXMvYWRkaXRpb25zOgogKgkJUGhpbGlwcCBSdW1wZgogKgkJSnVoYSBTaWV25G5lbiA8SnVoYS5TaWV2YW5lbkBjcy5IZWxzaW5raS5GST4KICoJCUF1dm8gSORra2luZW4gPEF1dm8uSGFra2luZW5AY3MuSGVsc2lua2kuRkk+CiAqCQlEZWVwYWsgU2F4ZW5hIDxkZWVwYWtAcGxleGl0eS5uZXQ+CiAqCQlCb2ppIFQgS2FubmFudGhhbmFtIDxib2ppLnQua2FubmFudGhhbmFtQGludGVsLmNvbT4KICoJCUFsYW4gQ294IDxhbGFuQHJlZGhhdC5jb20+OgogKgkJCVBvcnRlZCB0byBMaW51eCAyLjUuCiAqCQlNYXJrdXMgTGlkZWwgPE1hcmt1cy5MaWRlbEBzaGFkb3djb25uZWN0LmNvbT46CiAqCQkJTWlub3IgZml4ZXMgZm9yIDIuNi4KICovCgojaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiNpbmNsdWRlIDxsaW51eC9pMm8uaD4KI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgojaW5jbHVkZSAiY29yZS5oIgoKI2RlZmluZSBPU01fTkFNRQkiaTJvIgojZGVmaW5lIE9TTV9WRVJTSU9OCSIxLjI4OCIKI2RlZmluZSBPU01fREVTQ1JJUFRJT04JIkkyTyBzdWJzeXN0ZW0iCgovKiBnbG9iYWwgSTJPIGNvbnRyb2xsZXIgbGlzdCAqLwpMSVNUX0hFQUQoaTJvX2NvbnRyb2xsZXJzKTsKCi8qCiAqIGdsb2JhbCBJMk8gU3lzdGVtIFRhYmxlLiBDb250YWlucyBpbmZvcm1hdGlvbiBhYm91dCBhbGwgdGhlIElPUHMgaW4gdGhlCiAqIHN5c3RlbS4gVXNlZCB0byBpbmZvcm0gSU9QcyBhYm91dCBlYWNoIG90aGVycyBleGlzdGVuY2UuCiAqLwpzdGF0aWMgc3RydWN0IGkyb19kbWEgaTJvX3N5c3RhYjsKCnN0YXRpYyBpbnQgaTJvX2hydF9nZXQoc3RydWN0IGkyb19jb250cm9sbGVyICpjKTsKCi8qKgogKglpMm9fbXNnX2dldF93YWl0IC0gb2J0YWluIGFuIEkyTyBtZXNzYWdlIGZyb20gdGhlIElPUAogKglAYzogSTJPIGNvbnRyb2xsZXIKICoJQG1zZzogcG9pbnRlciB0byBhIEkyTyBtZXNzYWdlIHBvaW50ZXIKICoJQHdhaXQ6IGhvdyBsb25nIHRvIHdhaXQgdW50aWwgdGltZW91dAogKgogKglUaGlzIGZ1bmN0aW9uIHdhaXRzIHVwIHRvIHdhaXQgc2Vjb25kcyBmb3IgYSBtZXNzYWdlIHNsb3QgdG8gYmUKICoJYXZhaWxhYmxlLgogKgogKglPbiBhIHN1Y2Nlc3MgdGhlIG1lc3NhZ2UgaXMgcmV0dXJuZWQgYW5kIHRoZSBwb2ludGVyIHRvIHRoZSBtZXNzYWdlIGlzCiAqCXNldCBpbiBtc2cuIFRoZSByZXR1cm5lZCBtZXNzYWdlIGlzIHRoZSBwaHlzaWNhbCBwYWdlIGZyYW1lIG9mZnNldAogKglhZGRyZXNzIGZyb20gdGhlIHJlYWQgcG9ydCAoc2VlIHRoZSBpMm8gc3BlYykuIElmIG5vIG1lc3NhZ2UgaXMKICoJYXZhaWxhYmxlIHJldHVybnMgSTJPX1FVRVVFX0VNUFRZIGFuZCBtc2cgaXMgbGVhdmVkIHVudG91Y2hlZC4KICovCnN0cnVjdCBpMm9fbWVzc2FnZSAqaTJvX21zZ19nZXRfd2FpdChzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKmMsIGludCB3YWl0KQp7Cgl1bnNpZ25lZCBsb25nIHRpbWVvdXQgPSBqaWZmaWVzICsgd2FpdCAqIEhaOwoJc3RydWN0IGkyb19tZXNzYWdlICptc2c7CgoJd2hpbGUgKElTX0VSUihtc2cgPSBpMm9fbXNnX2dldChjKSkpIHsKCQlpZiAodGltZV9hZnRlcihqaWZmaWVzLCB0aW1lb3V0KSkgewoJCQlvc21fZGVidWcoIiVzOiBUaW1lb3V0IHdhaXRpbmcgZm9yIG1lc3NhZ2UgZnJhbWUuXG4iLAoJCQkJICBjLT5uYW1lKTsKCQkJcmV0dXJuIEVSUl9QVFIoLUVUSU1FRE9VVCk7CgkJfQoJCXNjaGVkdWxlX3RpbWVvdXRfdW5pbnRlcnJ1cHRpYmxlKDEpOwoJfQoKCXJldHVybiBtc2c7Cn07CgojaWYgQklUU19QRVJfTE9ORyA9PSA2NAovKioKICogICAgICBpMm9fY250eHRfbGlzdF9hZGQgLSBBcHBlbmQgYSBwb2ludGVyIHRvIGNvbnRleHQgbGlzdCBhbmQgcmV0dXJuIGEgaWQKICoJQGM6IGNvbnRyb2xsZXIgdG8gd2hpY2ggdGhlIGNvbnRleHQgbGlzdCBiZWxvbmcKICoJQHB0cjogcG9pbnRlciB0byBhZGQgdG8gdGhlIGNvbnRleHQgbGlzdAogKgogKglCZWNhdXNlIHRoZSBjb250ZXh0IGZpZWxkIGluIEkyTyBpcyBvbmx5IDMyLWJpdCBsYXJnZSwgb24gNjQtYml0IHRoZQogKglwb2ludGVyIGlzIHRvIGxhcmdlIHRvIGZpdCBpbiB0aGUgY29udGV4dCBmaWVsZC4gVGhlIGkyb19jbnR4dF9saXN0CiAqCWZ1bmN0aW9ucyB0aGVyZWZvcmUgbWFwIHBvaW50ZXJzIHRvIGNvbnRleHQgZmllbGRzLgogKgogKglSZXR1cm5zIGNvbnRleHQgaWQgPiAwIG9uIHN1Y2Nlc3Mgb3IgMCBvbiBmYWlsdXJlLgogKi8KdTMyIGkyb19jbnR4dF9saXN0X2FkZChzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKiBjLCB2b2lkICpwdHIpCnsKCXN0cnVjdCBpMm9fY29udGV4dF9saXN0X2VsZW1lbnQgKmVudHJ5OwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCglpZiAoIXB0cikKCQlvc21fZXJyKCIlczogY291bGRuJ3QgYWRkIE5VTEwgcG9pbnRlciB0byBjb250ZXh0IGxpc3QhXG4iLAoJCQljLT5uYW1lKTsKCgllbnRyeSA9IGttYWxsb2Moc2l6ZW9mKCplbnRyeSksIEdGUF9BVE9NSUMpOwoJaWYgKCFlbnRyeSkgewoJCW9zbV9lcnIoIiVzOiBDb3VsZCBub3QgYWxsb2NhdGUgbWVtb3J5IGZvciBjb250ZXh0IGxpc3QgZWxlbWVudCIKCQkJIlxuIiwgYy0+bmFtZSk7CgkJcmV0dXJuIDA7Cgl9CgoJZW50cnktPnB0ciA9IHB0cjsKCWVudHJ5LT50aW1lc3RhbXAgPSBqaWZmaWVzOwoJSU5JVF9MSVNUX0hFQUQoJmVudHJ5LT5saXN0KTsKCglzcGluX2xvY2tfaXJxc2F2ZSgmYy0+Y29udGV4dF9saXN0X2xvY2ssIGZsYWdzKTsKCglpZiAodW5saWtlbHkoYXRvbWljX2luY19hbmRfdGVzdCgmYy0+Y29udGV4dF9saXN0X2NvdW50ZXIpKSkKCQlhdG9taWNfaW5jKCZjLT5jb250ZXh0X2xpc3RfY291bnRlcik7CgoJZW50cnktPmNvbnRleHQgPSBhdG9taWNfcmVhZCgmYy0+Y29udGV4dF9saXN0X2NvdW50ZXIpOwoKCWxpc3RfYWRkKCZlbnRyeS0+bGlzdCwgJmMtPmNvbnRleHRfbGlzdCk7CgoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYy0+Y29udGV4dF9saXN0X2xvY2ssIGZsYWdzKTsKCglvc21fZGVidWcoIiVzOiBBZGQgY29udGV4dCB0byBsaXN0ICVwIC0+ICVkXG4iLCBjLT5uYW1lLCBwdHIsIGNvbnRleHQpOwoKCXJldHVybiBlbnRyeS0+Y29udGV4dDsKfTsKCi8qKgogKiAgICAgIGkyb19jbnR4dF9saXN0X3JlbW92ZSAtIFJlbW92ZSBhIHBvaW50ZXIgZnJvbSB0aGUgY29udGV4dCBsaXN0CiAqCUBjOiBjb250cm9sbGVyIHRvIHdoaWNoIHRoZSBjb250ZXh0IGxpc3QgYmVsb25nCiAqCUBwdHI6IHBvaW50ZXIgd2hpY2ggc2hvdWxkIGJlIHJlbW92ZWQgZnJvbSB0aGUgY29udGV4dCBsaXN0CiAqCiAqCVJlbW92ZXMgYSBwcmV2aW91c2x5IGFkZGVkIHBvaW50ZXIgZnJvbSB0aGUgY29udGV4dCBsaXN0IGFuZCByZXR1cm5zCiAqCXRoZSBtYXRjaGluZyBjb250ZXh0IGlkLgogKgogKglSZXR1cm5zIGNvbnRleHQgaWQgb24gc3VjY2VzIG9yIDAgb24gZmFpbHVyZS4KICovCnUzMiBpMm9fY250eHRfbGlzdF9yZW1vdmUoc3RydWN0IGkyb19jb250cm9sbGVyICogYywgdm9pZCAqcHRyKQp7CglzdHJ1Y3QgaTJvX2NvbnRleHRfbGlzdF9lbGVtZW50ICplbnRyeTsKCXUzMiBjb250ZXh0ID0gMDsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJmMtPmNvbnRleHRfbGlzdF9sb2NrLCBmbGFncyk7CglsaXN0X2Zvcl9lYWNoX2VudHJ5KGVudHJ5LCAmYy0+Y29udGV4dF9saXN0LCBsaXN0KQoJICAgIGlmIChlbnRyeS0+cHRyID09IHB0cikgewoJCWxpc3RfZGVsKCZlbnRyeS0+bGlzdCk7CgkJY29udGV4dCA9IGVudHJ5LT5jb250ZXh0OwoJCWtmcmVlKGVudHJ5KTsKCQlicmVhazsKCX0KCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmMtPmNvbnRleHRfbGlzdF9sb2NrLCBmbGFncyk7CgoJaWYgKCFjb250ZXh0KQoJCW9zbV93YXJuKCIlczogQ291bGQgbm90IHJlbW92ZSBub25leGlzdGVudCBwdHIgJXBcbiIsIGMtPm5hbWUsCgkJCSBwdHIpOwoKCW9zbV9kZWJ1ZygiJXM6IHJlbW92ZSBwdHIgZnJvbSBjb250ZXh0IGxpc3QgJWQgLT4gJXBcbiIsIGMtPm5hbWUsCgkJICBjb250ZXh0LCBwdHIpOwoKCXJldHVybiBjb250ZXh0Owp9OwoKLyoqCiAqICAgICAgaTJvX2NudHh0X2xpc3RfZ2V0IC0gR2V0IGEgcG9pbnRlciBmcm9tIHRoZSBjb250ZXh0IGxpc3QgYW5kIHJlbW92ZSBpdAogKglAYzogY29udHJvbGxlciB0byB3aGljaCB0aGUgY29udGV4dCBsaXN0IGJlbG9uZwogKglAY29udGV4dDogY29udGV4dCBpZCB0byB3aGljaCB0aGUgcG9pbnRlciBiZWxvbmcKICoKICoJUmV0dXJucyBwb2ludGVyIHRvIHRoZSBtYXRjaGluZyBjb250ZXh0IGlkIG9uIHN1Y2Nlc3Mgb3IgTlVMTCBvbgogKglmYWlsdXJlLgogKi8Kdm9pZCAqaTJvX2NudHh0X2xpc3RfZ2V0KHN0cnVjdCBpMm9fY29udHJvbGxlciAqYywgdTMyIGNvbnRleHQpCnsKCXN0cnVjdCBpMm9fY29udGV4dF9saXN0X2VsZW1lbnQgKmVudHJ5OwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCXZvaWQgKnB0ciA9IE5VTEw7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJmMtPmNvbnRleHRfbGlzdF9sb2NrLCBmbGFncyk7CglsaXN0X2Zvcl9lYWNoX2VudHJ5KGVudHJ5LCAmYy0+Y29udGV4dF9saXN0LCBsaXN0KQoJICAgIGlmIChlbnRyeS0+Y29udGV4dCA9PSBjb250ZXh0KSB7CgkJbGlzdF9kZWwoJmVudHJ5LT5saXN0KTsKCQlwdHIgPSBlbnRyeS0+cHRyOwoJCWtmcmVlKGVudHJ5KTsKCQlicmVhazsKCX0KCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmMtPmNvbnRleHRfbGlzdF9sb2NrLCBmbGFncyk7CgoJaWYgKCFwdHIpCgkJb3NtX3dhcm4oIiVzOiBjb250ZXh0IGlkICVkIG5vdCBmb3VuZFxuIiwgYy0+bmFtZSwgY29udGV4dCk7CgoJb3NtX2RlYnVnKCIlczogZ2V0IHB0ciBmcm9tIGNvbnRleHQgbGlzdCAlZCAtPiAlcFxuIiwgYy0+bmFtZSwgY29udGV4dCwKCQkgIHB0cik7CgoJcmV0dXJuIHB0cjsKfTsKCi8qKgogKiAgICAgIGkyb19jbnR4dF9saXN0X2dldF9wdHIgLSBHZXQgYSBjb250ZXh0IGlkIGZyb20gdGhlIGNvbnRleHQgbGlzdAogKglAYzogY29udHJvbGxlciB0byB3aGljaCB0aGUgY29udGV4dCBsaXN0IGJlbG9uZwogKglAcHRyOiBwb2ludGVyIHRvIHdoaWNoIHRoZSBjb250ZXh0IGlkIHNob3VsZCBiZSBmZXRjaGVkCiAqCiAqCVJldHVybnMgY29udGV4dCBpZCB3aGljaCBtYXRjaGVzIHRvIHRoZSBwb2ludGVyIG9uIHN1Y2NlcyBvciAwIG9uCiAqCWZhaWx1cmUuCiAqLwp1MzIgaTJvX2NudHh0X2xpc3RfZ2V0X3B0cihzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKiBjLCB2b2lkICpwdHIpCnsKCXN0cnVjdCBpMm9fY29udGV4dF9saXN0X2VsZW1lbnQgKmVudHJ5OwoJdTMyIGNvbnRleHQgPSAwOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCglzcGluX2xvY2tfaXJxc2F2ZSgmYy0+Y29udGV4dF9saXN0X2xvY2ssIGZsYWdzKTsKCWxpc3RfZm9yX2VhY2hfZW50cnkoZW50cnksICZjLT5jb250ZXh0X2xpc3QsIGxpc3QpCgkgICAgaWYgKGVudHJ5LT5wdHIgPT0gcHRyKSB7CgkJY29udGV4dCA9IGVudHJ5LT5jb250ZXh0OwoJCWJyZWFrOwoJfQoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYy0+Y29udGV4dF9saXN0X2xvY2ssIGZsYWdzKTsKCglpZiAoIWNvbnRleHQpCgkJb3NtX3dhcm4oIiVzOiBDb3VsZCBub3QgZmluZCBub25leGlzdGVudCBwdHIgJXBcbiIsIGMtPm5hbWUsCgkJCSBwdHIpOwoKCW9zbV9kZWJ1ZygiJXM6IGdldCBjb250ZXh0IGlkIGZyb20gY29udGV4dCBsaXN0ICVwIC0+ICVkXG4iLCBjLT5uYW1lLAoJCSAgcHRyLCBjb250ZXh0KTsKCglyZXR1cm4gY29udGV4dDsKfTsKI2VuZGlmCgovKioKICoJaTJvX2lvcF9maW5kIC0gRmluZCBhbiBJMk8gY29udHJvbGxlciBieSBpZAogKglAdW5pdDogdW5pdCBudW1iZXIgb2YgdGhlIEkyTyBjb250cm9sbGVyIHRvIHNlYXJjaCBmb3IKICoKICoJTG9va3VwIHRoZSBJMk8gY29udHJvbGxlciBvbiB0aGUgY29udHJvbGxlciBsaXN0LgogKgogKglSZXR1cm5zIHBvaW50ZXIgdG8gdGhlIEkyTyBjb250cm9sbGVyIG9uIHN1Y2Nlc3Mgb3IgTlVMTCBpZiBub3QgZm91bmQuCiAqLwpzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKmkyb19maW5kX2lvcChpbnQgdW5pdCkKewoJc3RydWN0IGkyb19jb250cm9sbGVyICpjOwoKCWxpc3RfZm9yX2VhY2hfZW50cnkoYywgJmkyb19jb250cm9sbGVycywgbGlzdCkgewoJCWlmIChjLT51bml0ID09IHVuaXQpCgkJCXJldHVybiBjOwoJfQoKCXJldHVybiBOVUxMOwp9OwoKLyoqCiAqCWkyb19pb3BfZmluZF9kZXZpY2UgLSBGaW5kIGEgSTJPIGRldmljZSBvbiBhbiBJMk8gY29udHJvbGxlcgogKglAYzogSTJPIGNvbnRyb2xsZXIgd2hlcmUgdGhlIEkyTyBkZXZpY2UgaGFuZ3Mgb24KICoJQHRpZDogVElEIG9mIHRoZSBJMk8gZGV2aWNlIHRvIHNlYXJjaCBmb3IKICoKICoJU2VhcmNoZXMgdGhlIGRldmljZXMgb2YgdGhlIEkyTyBjb250cm9sbGVyIGZvciBhIGRldmljZSB3aXRoIFRJRCB0aWQgYW5kCiAqCXJldHVybnMgaXQuCiAqCiAqCVJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBJMk8gZGV2aWNlIGlmIGZvdW5kLCBvdGhlcndpc2UgTlVMTC4KICovCnN0cnVjdCBpMm9fZGV2aWNlICppMm9faW9wX2ZpbmRfZGV2aWNlKHN0cnVjdCBpMm9fY29udHJvbGxlciAqYywgdTE2IHRpZCkKewoJc3RydWN0IGkyb19kZXZpY2UgKmRldjsKCglsaXN0X2Zvcl9lYWNoX2VudHJ5KGRldiwgJmMtPmRldmljZXMsIGxpc3QpCgkgICAgaWYgKGRldi0+bGN0X2RhdGEudGlkID09IHRpZCkKCQlyZXR1cm4gZGV2OwoKCXJldHVybiBOVUxMOwp9OwoKLyoqCiAqCWkyb19xdWllc2NlX2NvbnRyb2xsZXIgLSBxdWllc2NlIGNvbnRyb2xsZXIKICoJQGM6IGNvbnRyb2xsZXIKICoKICoJUXVpZXNjZSBhbiBJT1AuIENhdXNlcyBJT1AgdG8gbWFrZSBleHRlcm5hbCBvcGVyYXRpb24gcXVpZXNjZW50CiAqCShpMm8gJ1JFQURZJyBzdGF0ZSkuIEludGVybmFsIG9wZXJhdGlvbiBvZiB0aGUgSU9QIGNvbnRpbnVlcyBub3JtYWxseS4KICoKICoJUmV0dXJucyAwIG9uIHN1Y2Nlc3Mgb3IgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgogKi8Kc3RhdGljIGludCBpMm9faW9wX3F1aWVzY2Uoc3RydWN0IGkyb19jb250cm9sbGVyICpjKQp7CglzdHJ1Y3QgaTJvX21lc3NhZ2UgKm1zZzsKCWkyb19zdGF0dXNfYmxvY2sgKnNiID0gYy0+c3RhdHVzX2Jsb2NrLnZpcnQ7CglpbnQgcmM7CgoJaTJvX3N0YXR1c19nZXQoYyk7CgoJLyogU3lzUXVpZXNjZSBkaXNjYXJkZWQgaWYgSU9QIG5vdCBpbiBSRUFEWSBvciBPUEVSQVRJT05BTCBzdGF0ZSAqLwoJaWYgKChzYi0+aW9wX3N0YXRlICE9IEFEQVBURVJfU1RBVEVfUkVBRFkpICYmCgkgICAgKHNiLT5pb3Bfc3RhdGUgIT0gQURBUFRFUl9TVEFURV9PUEVSQVRJT05BTCkpCgkJcmV0dXJuIDA7CgoJbXNnID0gaTJvX21zZ19nZXRfd2FpdChjLCBJMk9fVElNRU9VVF9NRVNTQUdFX0dFVCk7CglpZiAoSVNfRVJSKG1zZykpCgkJcmV0dXJuIFBUUl9FUlIobXNnKTsKCgltc2ctPnUuaGVhZFswXSA9IGNwdV90b19sZTMyKEZPVVJfV09SRF9NU0dfU0laRSB8IFNHTF9PRkZTRVRfMCk7Cgltc2ctPnUuaGVhZFsxXSA9CgkgICAgY3B1X3RvX2xlMzIoSTJPX0NNRF9TWVNfUVVJRVNDRSA8PCAyNCB8IEhPU1RfVElEIDw8IDEyIHwKCQkJQURBUFRFUl9USUQpOwoKCS8qIExvbmcgdGltZW91dCBuZWVkZWQgZm9yIHF1aWVzY2UgaWYgbG90cyBvZiBkZXZpY2VzICovCglpZiAoKHJjID0gaTJvX21zZ19wb3N0X3dhaXQoYywgbXNnLCAyNDApKSkKCQlvc21faW5mbygiJXM6IFVuYWJsZSB0byBxdWllc2NlIChzdGF0dXM9JSN4KS5cbiIsIGMtPm5hbWUsIC1yYyk7CgllbHNlCgkJb3NtX2RlYnVnKCIlczogUXVpZXNjZWQuXG4iLCBjLT5uYW1lKTsKCglpMm9fc3RhdHVzX2dldChjKTsJLy8gRW50ZXJlZCBSRUFEWSBzdGF0ZQoKCXJldHVybiByYzsKfTsKCi8qKgogKglpMm9faW9wX2VuYWJsZSAtIG1vdmUgY29udHJvbGxlciBmcm9tIHJlYWR5IHRvIE9QRVJBVElPTkFMCiAqCUBjOiBJMk8gY29udHJvbGxlcgogKgogKglFbmFibGUgSU9QLiBUaGlzIGFsbG93cyB0aGUgSU9QIHRvIHJlc3VtZSBleHRlcm5hbCBvcGVyYXRpb25zIGFuZAogKglyZXZlcnNlcyB0aGUgZWZmZWN0IG9mIGEgcXVpZXNjZS4gUmV0dXJucyB6ZXJvIG9yIGFuIGVycm9yIGNvZGUgaWYKICoJYW4gZXJyb3Igb2NjdXJzLgogKi8Kc3RhdGljIGludCBpMm9faW9wX2VuYWJsZShzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKmMpCnsKCXN0cnVjdCBpMm9fbWVzc2FnZSAqbXNnOwoJaTJvX3N0YXR1c19ibG9jayAqc2IgPSBjLT5zdGF0dXNfYmxvY2sudmlydDsKCWludCByYzsKCglpMm9fc3RhdHVzX2dldChjKTsKCgkvKiBFbmFibGUgb25seSBhbGxvd2VkIG9uIFJFQURZIHN0YXRlICovCglpZiAoc2ItPmlvcF9zdGF0ZSAhPSBBREFQVEVSX1NUQVRFX1JFQURZKQoJCXJldHVybiAtRUlOVkFMOwoKCW1zZyA9IGkyb19tc2dfZ2V0X3dhaXQoYywgSTJPX1RJTUVPVVRfTUVTU0FHRV9HRVQpOwoJaWYgKElTX0VSUihtc2cpKQoJCXJldHVybiBQVFJfRVJSKG1zZyk7CgoJbXNnLT51LmhlYWRbMF0gPSBjcHVfdG9fbGUzMihGT1VSX1dPUkRfTVNHX1NJWkUgfCBTR0xfT0ZGU0VUXzApOwoJbXNnLT51LmhlYWRbMV0gPQoJICAgIGNwdV90b19sZTMyKEkyT19DTURfU1lTX0VOQUJMRSA8PCAyNCB8IEhPU1RfVElEIDw8IDEyIHwKCQkJQURBUFRFUl9USUQpOwoKCS8qIEhvdyBsb25nIG9mIGEgdGltZW91dCBkbyB3ZSBuZWVkPyAqLwoJaWYgKChyYyA9IGkyb19tc2dfcG9zdF93YWl0KGMsIG1zZywgMjQwKSkpCgkJb3NtX2VycigiJXM6IENvdWxkIG5vdCBlbmFibGUgKHN0YXR1cz0lI3gpLlxuIiwgYy0+bmFtZSwgLXJjKTsKCWVsc2UKCQlvc21fZGVidWcoIiVzOiBFbmFibGVkLlxuIiwgYy0+bmFtZSk7CgoJaTJvX3N0YXR1c19nZXQoYyk7CS8vIGVudGVyZWQgT1BFUkFUSU9OQUwgc3RhdGUKCglyZXR1cm4gcmM7Cn07CgovKioKICoJaTJvX2lvcF9xdWllc2NlX2FsbCAtIFF1aWVzY2UgYWxsIEkyTyBjb250cm9sbGVycyBvbiB0aGUgc3lzdGVtCiAqCiAqCVF1aWVzY2UgYWxsIEkyTyBjb250cm9sbGVycyB3aGljaCBhcmUgY29ubmVjdGVkIHRvIHRoZSBzeXN0ZW0uCiAqLwpzdGF0aWMgaW5saW5lIHZvaWQgaTJvX2lvcF9xdWllc2NlX2FsbCh2b2lkKQp7CglzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKmMsICp0bXA7CgoJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKGMsIHRtcCwgJmkyb19jb250cm9sbGVycywgbGlzdCkgewoJCWlmICghYy0+bm9fcXVpZXNjZSkKCQkJaTJvX2lvcF9xdWllc2NlKGMpOwoJfQp9OwoKLyoqCiAqCWkyb19pb3BfZW5hYmxlX2FsbCAtIEVuYWJsZXMgYWxsIGNvbnRyb2xsZXJzIG9uIHRoZSBzeXN0ZW0KICoKICoJRW5hYmxlcyBhbGwgSTJPIGNvbnRyb2xsZXJzIHdoaWNoIGFyZSBjb25uZWN0ZWQgdG8gdGhlIHN5c3RlbS4KICovCnN0YXRpYyBpbmxpbmUgdm9pZCBpMm9faW9wX2VuYWJsZV9hbGwodm9pZCkKewoJc3RydWN0IGkyb19jb250cm9sbGVyICpjLCAqdG1wOwoKCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShjLCB0bXAsICZpMm9fY29udHJvbGxlcnMsIGxpc3QpCgkgICAgaTJvX2lvcF9lbmFibGUoYyk7Cn07CgovKioKICoJaTJvX2NsZWFyX2NvbnRyb2xsZXIgLSBCcmluZyBJMk8gY29udHJvbGxlciBpbnRvIEhPTEQgc3RhdGUKICoJQGM6IGNvbnRyb2xsZXIKICoKICoJQ2xlYXIgYW4gSU9QIHRvIEhPTEQgc3RhdGUsIGllLiB0ZXJtaW5hdGUgZXh0ZXJuYWwgb3BlcmF0aW9ucywgY2xlYXIgYWxsCiAqCWlucHV0IHF1ZXVlcyBhbmQgcHJlcGFyZSBmb3IgYSBzeXN0ZW0gcmVzdGFydC4gSU9QJ3MgaW50ZXJuYWwgb3BlcmF0aW9uCiAqCWNvbnRpbnVlcyBub3JtYWxseSBhbmQgdGhlIG91dGJvdW5kIHF1ZXVlIGlzIGFsaXZlLiBUaGUgSU9QIGlzIG5vdAogKglleHBlY3RlZCB0byByZWJ1aWxkIGl0cyBMQ1QuCiAqCiAqCVJldHVybnMgMCBvbiBzdWNjZXNzIG9yIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KICovCnN0YXRpYyBpbnQgaTJvX2lvcF9jbGVhcihzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKmMpCnsKCXN0cnVjdCBpMm9fbWVzc2FnZSAqbXNnOwoJaW50IHJjOwoKCW1zZyA9IGkyb19tc2dfZ2V0X3dhaXQoYywgSTJPX1RJTUVPVVRfTUVTU0FHRV9HRVQpOwoJaWYgKElTX0VSUihtc2cpKQoJCXJldHVybiBQVFJfRVJSKG1zZyk7CgoJLyogUXVpZXNjZSBhbGwgSU9QcyBmaXJzdCAqLwoJaTJvX2lvcF9xdWllc2NlX2FsbCgpOwoKCW1zZy0+dS5oZWFkWzBdID0gY3B1X3RvX2xlMzIoRk9VUl9XT1JEX01TR19TSVpFIHwgU0dMX09GRlNFVF8wKTsKCW1zZy0+dS5oZWFkWzFdID0KCSAgICBjcHVfdG9fbGUzMihJMk9fQ01EX0FEQVBURVJfQ0xFQVIgPDwgMjQgfCBIT1NUX1RJRCA8PCAxMiB8CgkJCUFEQVBURVJfVElEKTsKCglpZiAoKHJjID0gaTJvX21zZ19wb3N0X3dhaXQoYywgbXNnLCAzMCkpKQoJCW9zbV9pbmZvKCIlczogVW5hYmxlIHRvIGNsZWFyIChzdGF0dXM9JSN4KS5cbiIsIGMtPm5hbWUsIC1yYyk7CgllbHNlCgkJb3NtX2RlYnVnKCIlczogQ2xlYXJlZC5cbiIsIGMtPm5hbWUpOwoKCS8qIEVuYWJsZSBhbGwgSU9QcyAqLwoJaTJvX2lvcF9lbmFibGVfYWxsKCk7CgoJcmV0dXJuIHJjOwp9CgovKioKICoJaTJvX2lvcF9pbml0X291dGJvdW5kX3F1ZXVlIC0gc2V0dXAgdGhlIG91dGJvdW5kIG1lc3NhZ2UgcXVldWUKICoJQGM6IEkyTyBjb250cm9sbGVyCiAqCiAqCUNsZWFyIGFuZCAocmUpaW5pdGlhbGl6ZSBJT1AncyBvdXRib3VuZCBxdWV1ZSBhbmQgcG9zdCB0aGUgbWVzc2FnZQogKglmcmFtZXMgdG8gdGhlIElPUC4KICoKICoJUmV0dXJucyAwIG9uIHN1Y2Nlc3Mgb3IgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgogKi8Kc3RhdGljIGludCBpMm9faW9wX2luaXRfb3V0Ym91bmRfcXVldWUoc3RydWN0IGkyb19jb250cm9sbGVyICpjKQp7Cgl1MzIgbTsKCXZvbGF0aWxlIHU4ICpzdGF0dXMgPSBjLT5zdGF0dXMudmlydDsKCXN0cnVjdCBpMm9fbWVzc2FnZSAqbXNnOwoJdWxvbmcgdGltZW91dDsKCWludCBpOwoKCW9zbV9kZWJ1ZygiJXM6IEluaXRpYWxpemluZyBPdXRib3VuZCBRdWV1ZS4uLlxuIiwgYy0+bmFtZSk7CgoJbWVtc2V0KGMtPnN0YXR1cy52aXJ0LCAwLCA0KTsKCgltc2cgPSBpMm9fbXNnX2dldF93YWl0KGMsIEkyT19USU1FT1VUX01FU1NBR0VfR0VUKTsKCWlmIChJU19FUlIobXNnKSkKCQlyZXR1cm4gUFRSX0VSUihtc2cpOwoKCW1zZy0+dS5oZWFkWzBdID0gY3B1X3RvX2xlMzIoRUlHSFRfV09SRF9NU0dfU0laRSB8IFNHTF9PRkZTRVRfNik7Cgltc2ctPnUuaGVhZFsxXSA9CgkgICAgY3B1X3RvX2xlMzIoSTJPX0NNRF9PVVRCT1VORF9JTklUIDw8IDI0IHwgSE9TVF9USUQgPDwgMTIgfAoJCQlBREFQVEVSX1RJRCk7Cgltc2ctPnUucy5pY250eHQgPSBjcHVfdG9fbGUzMihpMm9fZXhlY19kcml2ZXIuY29udGV4dCk7Cgltc2ctPnUucy50Y250eHQgPSBjcHVfdG9fbGUzMigweDAwMDAwMDAwKTsKCW1zZy0+Ym9keVswXSA9IGNwdV90b19sZTMyKFBBR0VfU0laRSk7CgkvKiBPdXRib3VuZCBtc2cgZnJhbWUgc2l6ZSBpbiB3b3JkcyBhbmQgSW5pdGNvZGUgKi8KCW1zZy0+Ym9keVsxXSA9IGNwdV90b19sZTMyKEkyT19PVVRCT1VORF9NU0dfRlJBTUVfU0laRSA8PCAxNiB8IDB4ODApOwoJbXNnLT5ib2R5WzJdID0gY3B1X3RvX2xlMzIoMHhkMDAwMDAwNCk7Cgltc2ctPmJvZHlbM10gPSBjcHVfdG9fbGUzMihpMm9fZG1hX2xvdyhjLT5zdGF0dXMucGh5cykpOwoJbXNnLT5ib2R5WzRdID0gY3B1X3RvX2xlMzIoaTJvX2RtYV9oaWdoKGMtPnN0YXR1cy5waHlzKSk7CgoJaTJvX21zZ19wb3N0KGMsIG1zZyk7CgoJdGltZW91dCA9IGppZmZpZXMgKyBJMk9fVElNRU9VVF9JTklUX09VVEJPVU5EX1FVRVVFICogSFo7Cgl3aGlsZSAoKnN0YXR1cyA8PSBJMk9fQ01EX0lOX1BST0dSRVNTKSB7CgkJaWYgKHRpbWVfYWZ0ZXIoamlmZmllcywgdGltZW91dCkpIHsKCQkJb3NtX3dhcm4oIiVzOiBUaW1lb3V0IEluaXRpYWxpemluZ1xuIiwgYy0+bmFtZSk7CgkJCXJldHVybiAtRVRJTUVET1VUOwoJCX0KCQlzY2hlZHVsZV90aW1lb3V0X3VuaW50ZXJydXB0aWJsZSgxKTsKCX0KCgltID0gYy0+b3V0X3F1ZXVlLnBoeXM7CgoJLyogUG9zdCBmcmFtZXMgKi8KCWZvciAoaSA9IDA7IGkgPCBJMk9fTUFYX09VVEJPVU5EX01TR19GUkFNRVM7IGkrKykgewoJCWkyb19mbHVzaF9yZXBseShjLCBtKTsKCQl1ZGVsYXkoMSk7CS8qIFByb21pc2UgKi8KCQltICs9IEkyT19PVVRCT1VORF9NU0dfRlJBTUVfU0laRSAqIHNpemVvZih1MzIpOwoJfQoKCXJldHVybiAwOwp9CgovKioKICoJaTJvX2lvcF9yZXNldCAtIHJlc2V0IGFuIEkyTyBjb250cm9sbGVyCiAqCUBjOiBjb250cm9sbGVyIHRvIHJlc2V0CiAqCiAqCVJlc2V0IHRoZSBJT1AgaW50byBJTklUIHN0YXRlIGFuZCB3YWl0IHVudGlsIElPUCBnZXRzIGludG8gUkVTRVQgc3RhdGUuCiAqCVRlcm1pbmF0ZSBhbGwgZXh0ZXJuYWwgb3BlcmF0aW9ucywgY2xlYXIgSU9QJ3MgaW5ib3VuZCBhbmQgb3V0Ym91bmQKICoJcXVldWVzLCB0ZXJtaW5hdGUgYWxsIERETXMsIGFuZCByZWxvYWQgdGhlIElPUCdzIG9wZXJhdGluZyBlbnZpcm9ubWVudAogKglhbmQgYWxsIGxvY2FsIERETXMuIFRoZSBJT1AgcmVidWlsZHMgaXRzIExDVC4KICovCnN0YXRpYyBpbnQgaTJvX2lvcF9yZXNldChzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKmMpCnsKCXZvbGF0aWxlIHU4ICpzdGF0dXMgPSBjLT5zdGF0dXMudmlydDsKCXN0cnVjdCBpMm9fbWVzc2FnZSAqbXNnOwoJdW5zaWduZWQgbG9uZyB0aW1lb3V0OwoJaTJvX3N0YXR1c19ibG9jayAqc2IgPSBjLT5zdGF0dXNfYmxvY2sudmlydDsKCWludCByYyA9IDA7CgoJb3NtX2RlYnVnKCIlczogUmVzZXR0aW5nIGNvbnRyb2xsZXJcbiIsIGMtPm5hbWUpOwoKCW1zZyA9IGkyb19tc2dfZ2V0X3dhaXQoYywgSTJPX1RJTUVPVVRfTUVTU0FHRV9HRVQpOwoJaWYgKElTX0VSUihtc2cpKQoJCXJldHVybiBQVFJfRVJSKG1zZyk7CgoJbWVtc2V0KGMtPnN0YXR1c19ibG9jay52aXJ0LCAwLCA4KTsKCgkvKiBRdWllc2NlIGFsbCBJT1BzIGZpcnN0ICovCglpMm9faW9wX3F1aWVzY2VfYWxsKCk7CgoJbXNnLT51LmhlYWRbMF0gPSBjcHVfdG9fbGUzMihFSUdIVF9XT1JEX01TR19TSVpFIHwgU0dMX09GRlNFVF8wKTsKCW1zZy0+dS5oZWFkWzFdID0KCSAgICBjcHVfdG9fbGUzMihJMk9fQ01EX0FEQVBURVJfUkVTRVQgPDwgMjQgfCBIT1NUX1RJRCA8PCAxMiB8CgkJCUFEQVBURVJfVElEKTsKCW1zZy0+dS5zLmljbnR4dCA9IGNwdV90b19sZTMyKGkyb19leGVjX2RyaXZlci5jb250ZXh0KTsKCW1zZy0+dS5zLnRjbnR4dCA9IGNwdV90b19sZTMyKDB4MDAwMDAwMDApOwoJbXNnLT5ib2R5WzBdID0gY3B1X3RvX2xlMzIoMHgwMDAwMDAwMCk7Cgltc2ctPmJvZHlbMV0gPSBjcHVfdG9fbGUzMigweDAwMDAwMDAwKTsKCW1zZy0+Ym9keVsyXSA9IGNwdV90b19sZTMyKGkyb19kbWFfbG93KGMtPnN0YXR1cy5waHlzKSk7Cgltc2ctPmJvZHlbM10gPSBjcHVfdG9fbGUzMihpMm9fZG1hX2hpZ2goYy0+c3RhdHVzLnBoeXMpKTsKCglpMm9fbXNnX3Bvc3QoYywgbXNnKTsKCgkvKiBXYWl0IGZvciBhIHJlcGx5ICovCgl0aW1lb3V0ID0gamlmZmllcyArIEkyT19USU1FT1VUX1JFU0VUICogSFo7Cgl3aGlsZSAoISpzdGF0dXMpIHsKCQlpZiAodGltZV9hZnRlcihqaWZmaWVzLCB0aW1lb3V0KSkKCQkJYnJlYWs7CgoJCXNjaGVkdWxlX3RpbWVvdXRfdW5pbnRlcnJ1cHRpYmxlKDEpOwoJfQoKCXN3aXRjaCAoKnN0YXR1cykgewoJY2FzZSBJMk9fQ01EX1JFSkVDVEVEOgoJCW9zbV93YXJuKCIlczogSU9QIHJlc2V0IHJlamVjdGVkXG4iLCBjLT5uYW1lKTsKCQlyYyA9IC1FUEVSTTsKCQlicmVhazsKCgljYXNlIEkyT19DTURfSU5fUFJPR1JFU1M6CgkJLyoKCQkgKiBPbmNlIHRoZSByZXNldCBpcyBzZW50LCB0aGUgSU9QIGdvZXMgaW50byB0aGUgSU5JVCBzdGF0ZQoJCSAqIHdoaWNoIGlzIGluZGV0ZXJtaW5hdGUuIFdlIG5lZWQgdG8gd2FpdCB1bnRpbCB0aGUgSU9QIGhhcwoJCSAqIHJlYm9vdGVkIGJlZm9yZSB3ZSBjYW4gbGV0IHRoZSBzeXN0ZW0gdGFsayB0byBpdC4gV2UgcmVhZAoJCSAqIHRoZSBpbmJvdW5kIEZyZWVfTGlzdCB1bnRpbCBhIG1lc3NhZ2UgaXMgYXZhaWxhYmxlLiBJZiB3ZQoJCSAqIGNhbid0IHJlYWQgb25lIGluIHRoZSBnaXZlbiBhbW1vdW50IG9mIHRpbWUsIHdlIGFzc3VtZSB0aGUKCQkgKiBJT1AgY291bGQgbm90IHJlYm9vdCBwcm9wZXJseS4KCQkgKi8KCQlvc21fZGVidWcoIiVzOiBSZXNldCBpbiBwcm9ncmVzcywgd2FpdGluZyBmb3IgcmVib290Li4uXG4iLAoJCQkgIGMtPm5hbWUpOwoKCQl3aGlsZSAoSVNfRVJSKG1zZyA9IGkyb19tc2dfZ2V0X3dhaXQoYywgSTJPX1RJTUVPVVRfUkVTRVQpKSkgewoJCQlpZiAodGltZV9hZnRlcihqaWZmaWVzLCB0aW1lb3V0KSkgewoJCQkJb3NtX2VycigiJXM6IElPUCByZXNldCB0aW1lb3V0LlxuIiwgYy0+bmFtZSk7CgkJCQlyYyA9IFBUUl9FUlIobXNnKTsKCQkJCWdvdG8gZXhpdDsKCQkJfQoJCQlzY2hlZHVsZV90aW1lb3V0X3VuaW50ZXJydXB0aWJsZSgxKTsKCQl9CgkJaTJvX21zZ19ub3AoYywgbXNnKTsKCgkJLyogZnJvbSBoZXJlIGFsbCBxdWllc2NlIGNvbW1hbmRzIGFyZSBzYWZlICovCgkJYy0+bm9fcXVpZXNjZSA9IDA7CgoJCS8qIHZlcmlmeSBpZiBjb250cm9sbGVyIGlzIGluIHN0YXRlIFJFU0VUICovCgkJaTJvX3N0YXR1c19nZXQoYyk7CgoJCWlmICghYy0+cHJvbWlzZSAmJiAoc2ItPmlvcF9zdGF0ZSAhPSBBREFQVEVSX1NUQVRFX1JFU0VUKSkKCQkJb3NtX3dhcm4oIiVzOiByZXNldCBjb21wbGV0ZWQsIGJ1dCBhZGFwdGVyIG5vdCBpbiBSRVNFVCIKCQkJCSAiIHN0YXRlLlxuIiwgYy0+bmFtZSk7CgkJZWxzZQoJCQlvc21fZGVidWcoIiVzOiByZXNldCBjb21wbGV0ZWQuXG4iLCBjLT5uYW1lKTsKCgkJYnJlYWs7CgoJZGVmYXVsdDoKCQlvc21fZXJyKCIlczogSU9QIHJlc2V0IHRpbWVvdXQuXG4iLCBjLT5uYW1lKTsKCQlyYyA9IC1FVElNRURPVVQ7CgkJYnJlYWs7Cgl9CgogICAgICBleGl0OgoJLyogRW5hYmxlIGFsbCBJT1BzICovCglpMm9faW9wX2VuYWJsZV9hbGwoKTsKCglyZXR1cm4gcmM7Cn07CgovKioKICoJaTJvX2lvcF9hY3RpdmF0ZSAtIEJyaW5nIGNvbnRyb2xsZXIgdXAgdG8gSE9MRAogKglAYzogY29udHJvbGxlcgogKgogKglUaGlzIGZ1bmN0aW9uIGJyaW5ncyBhbiBJMk8gY29udHJvbGxlciBpbnRvIEhPTEQgc3RhdGUuIFRoZSBhZGFwdGVyCiAqCWlzIHJlc2V0IGlmIG5lY2Vzc2FyeSBhbmQgdGhlbiB0aGUgcXVldWVzIGFuZCByZXNvdXJjZSB0YWJsZSBhcmUgcmVhZC4KICoKICoJUmV0dXJucyAwIG9uIHN1Y2Nlc3Mgb3IgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgogKi8Kc3RhdGljIGludCBpMm9faW9wX2FjdGl2YXRlKHN0cnVjdCBpMm9fY29udHJvbGxlciAqYykKewoJaTJvX3N0YXR1c19ibG9jayAqc2IgPSBjLT5zdGF0dXNfYmxvY2sudmlydDsKCWludCByYzsKCWludCBzdGF0ZTsKCgkvKiBJbiBJTklUIHN0YXRlLCBXYWl0IEluYm91bmQgUSB0byBpbml0aWFsaXplIChpbiBpMm9fc3RhdHVzX2dldCkgKi8KCS8qIEluIFJFQURZIHN0YXRlLCBHZXQgc3RhdHVzICovCgoJcmMgPSBpMm9fc3RhdHVzX2dldChjKTsKCWlmIChyYykgewoJCW9zbV9pbmZvKCIlczogVW5hYmxlIHRvIG9idGFpbiBzdGF0dXMsIGF0dGVtcHRpbmcgYSByZXNldC5cbiIsCgkJCSBjLT5uYW1lKTsKCQlyYyA9IGkyb19pb3BfcmVzZXQoYyk7CgkJaWYgKHJjKQoJCQlyZXR1cm4gcmM7Cgl9CgoJaWYgKHNiLT5pMm9fdmVyc2lvbiA+IEkyT1ZFUjE1KSB7CgkJb3NtX2VycigiJXM6IE5vdCBydW5uaW5nIHZlcnNpb24gMS41IG9mIHRoZSBJMk8gU3BlY2lmaWNhdGlvbi4iCgkJCSJcbiIsIGMtPm5hbWUpOwoJCXJldHVybiAtRU5PREVWOwoJfQoKCXN3aXRjaCAoc2ItPmlvcF9zdGF0ZSkgewoJY2FzZSBBREFQVEVSX1NUQVRFX0ZBVUxURUQ6CgkJb3NtX2VycigiJXM6IGhhcmR3YXJlIGZhdWx0XG4iLCBjLT5uYW1lKTsKCQlyZXR1cm4gLUVGQVVMVDsKCgljYXNlIEFEQVBURVJfU1RBVEVfUkVBRFk6CgljYXNlIEFEQVBURVJfU1RBVEVfT1BFUkFUSU9OQUw6CgljYXNlIEFEQVBURVJfU1RBVEVfSE9MRDoKCWNhc2UgQURBUFRFUl9TVEFURV9GQUlMRUQ6CgkJb3NtX2RlYnVnKCIlczogYWxyZWFkeSBydW5uaW5nLCB0cnlpbmcgdG8gcmVzZXQuLi5cbiIsIGMtPm5hbWUpOwoJCXJjID0gaTJvX2lvcF9yZXNldChjKTsKCQlpZiAocmMpCgkJCXJldHVybiByYzsKCX0KCgkvKiBwcmVzZXJ2ZSBzdGF0ZSAqLwoJc3RhdGUgPSBzYi0+aW9wX3N0YXRlOwoKCXJjID0gaTJvX2lvcF9pbml0X291dGJvdW5kX3F1ZXVlKGMpOwoJaWYgKHJjKQoJCXJldHVybiByYzsKCgkvKiBpZiBhZGFwdGVyIHdhcyBub3QgaW4gUkVTRVQgc3RhdGUgY2xlYXIgbm93ICovCglpZiAoc3RhdGUgIT0gQURBUFRFUl9TVEFURV9SRVNFVCkKCQlpMm9faW9wX2NsZWFyKGMpOwoKCWkyb19zdGF0dXNfZ2V0KGMpOwoKCWlmIChzYi0+aW9wX3N0YXRlICE9IEFEQVBURVJfU1RBVEVfSE9MRCkgewoJCW9zbV9lcnIoIiVzOiBmYWlsZWQgdG8gYnJpbmcgSU9QIGludG8gSE9MRCBzdGF0ZVxuIiwgYy0+bmFtZSk7CgkJcmV0dXJuIC1FSU87Cgl9CgoJcmV0dXJuIGkyb19ocnRfZ2V0KGMpOwp9OwoKLyoqCiAqCWkyb19pb3Bfc3lzdGFiX3NldCAtIFNldCB0aGUgSTJPIFN5c3RlbSBUYWJsZSBvZiB0aGUgc3BlY2lmaWVkIElPUAogKglAYzogSTJPIGNvbnRyb2xsZXIgdG8gd2hpY2ggdGhlIHN5c3RlbSB0YWJsZSBzaG91bGQgYmUgc2VuZAogKgogKglCZWZvcmUgdGhlIHN5c3RhYiBjb3VsZCBiZSBzZXQgaTJvX3N5c3RhYl9idWlsZCgpIG11c3QgYmUgY2FsbGVkLgogKgogKglSZXR1cm5zIDAgb24gc3VjY2VzcyBvciBuZWdhdGl2ZSBlcnJvciBjb2RlIG9uIGZhaWx1cmUuCiAqLwpzdGF0aWMgaW50IGkyb19pb3Bfc3lzdGFiX3NldChzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKmMpCnsKCXN0cnVjdCBpMm9fbWVzc2FnZSAqbXNnOwoJaTJvX3N0YXR1c19ibG9jayAqc2IgPSBjLT5zdGF0dXNfYmxvY2sudmlydDsKCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZjLT5wZGV2LT5kZXY7CglzdHJ1Y3QgcmVzb3VyY2UgKnJvb3Q7CglpbnQgcmM7CgoJaWYgKHNiLT5jdXJyZW50X21lbV9zaXplIDwgc2ItPmRlc2lyZWRfbWVtX3NpemUpIHsKCQlzdHJ1Y3QgcmVzb3VyY2UgKnJlcyA9ICZjLT5tZW1fcmVzb3VyY2U7CgkJcmVzLT5uYW1lID0gYy0+cGRldi0+YnVzLT5uYW1lOwoJCXJlcy0+ZmxhZ3MgPSBJT1JFU09VUkNFX01FTTsKCQlyZXMtPnN0YXJ0ID0gMDsKCQlyZXMtPmVuZCA9IDA7CgkJb3NtX2luZm8oIiVzOiByZXF1aXJlcyBwcml2YXRlIG1lbW9yeSByZXNvdXJjZXMuXG4iLCBjLT5uYW1lKTsKCQlyb290ID0gcGNpX2ZpbmRfcGFyZW50X3Jlc291cmNlKGMtPnBkZXYsIHJlcyk7CgkJaWYgKHJvb3QgPT0gTlVMTCkKCQkJb3NtX3dhcm4oIiVzOiBDYW4ndCBmaW5kIHBhcmVudCByZXNvdXJjZSFcbiIsIGMtPm5hbWUpOwoJCWlmIChyb290ICYmIGFsbG9jYXRlX3Jlc291cmNlKHJvb3QsIHJlcywgc2ItPmRlc2lyZWRfbWVtX3NpemUsIHNiLT5kZXNpcmVkX21lbV9zaXplLCBzYi0+ZGVzaXJlZF9tZW1fc2l6ZSwgMSA8PCAyMCwJLyogVW5zcGVjaWZpZWQsIHNvIHVzZSAxTWIgYW5kIHBsYXkgc2FmZSAqLwoJCQkJCSAgICAgIE5VTEwsIE5VTEwpID49IDApIHsKCQkJYy0+bWVtX2FsbG9jID0gMTsKCQkJc2ItPmN1cnJlbnRfbWVtX3NpemUgPSAxICsgcmVzLT5lbmQgLSByZXMtPnN0YXJ0OwoJCQlzYi0+Y3VycmVudF9tZW1fYmFzZSA9IHJlcy0+c3RhcnQ7CgkJCW9zbV9pbmZvKCIlczogYWxsb2NhdGVkICVsZCBieXRlcyBvZiBQQ0kgbWVtb3J5IGF0ICIKCQkJCSAiMHglMDhsWC5cbiIsIGMtPm5hbWUsCgkJCQkgMSArIHJlcy0+ZW5kIC0gcmVzLT5zdGFydCwgcmVzLT5zdGFydCk7CgkJfQoJfQoKCWlmIChzYi0+Y3VycmVudF9pb19zaXplIDwgc2ItPmRlc2lyZWRfaW9fc2l6ZSkgewoJCXN0cnVjdCByZXNvdXJjZSAqcmVzID0gJmMtPmlvX3Jlc291cmNlOwoJCXJlcy0+bmFtZSA9IGMtPnBkZXYtPmJ1cy0+bmFtZTsKCQlyZXMtPmZsYWdzID0gSU9SRVNPVVJDRV9JTzsKCQlyZXMtPnN0YXJ0ID0gMDsKCQlyZXMtPmVuZCA9IDA7CgkJb3NtX2luZm8oIiVzOiByZXF1aXJlcyBwcml2YXRlIG1lbW9yeSByZXNvdXJjZXMuXG4iLCBjLT5uYW1lKTsKCQlyb290ID0gcGNpX2ZpbmRfcGFyZW50X3Jlc291cmNlKGMtPnBkZXYsIHJlcyk7CgkJaWYgKHJvb3QgPT0gTlVMTCkKCQkJb3NtX3dhcm4oIiVzOiBDYW4ndCBmaW5kIHBhcmVudCByZXNvdXJjZSFcbiIsIGMtPm5hbWUpOwoJCWlmIChyb290ICYmIGFsbG9jYXRlX3Jlc291cmNlKHJvb3QsIHJlcywgc2ItPmRlc2lyZWRfaW9fc2l6ZSwgc2ItPmRlc2lyZWRfaW9fc2l6ZSwgc2ItPmRlc2lyZWRfaW9fc2l6ZSwgMSA8PCAyMCwJLyogVW5zcGVjaWZpZWQsIHNvIHVzZSAxTWIgYW5kIHBsYXkgc2FmZSAqLwoJCQkJCSAgICAgIE5VTEwsIE5VTEwpID49IDApIHsKCQkJYy0+aW9fYWxsb2MgPSAxOwoJCQlzYi0+Y3VycmVudF9pb19zaXplID0gMSArIHJlcy0+ZW5kIC0gcmVzLT5zdGFydDsKCQkJc2ItPmN1cnJlbnRfbWVtX2Jhc2UgPSByZXMtPnN0YXJ0OwoJCQlvc21faW5mbygiJXM6IGFsbG9jYXRlZCAlbGQgYnl0ZXMgb2YgUENJIEkvTyBhdCAweCUwOGxYIgoJCQkJICIuXG4iLCBjLT5uYW1lLCAxICsgcmVzLT5lbmQgLSByZXMtPnN0YXJ0LAoJCQkJIHJlcy0+c3RhcnQpOwoJCX0KCX0KCgltc2cgPSBpMm9fbXNnX2dldF93YWl0KGMsIEkyT19USU1FT1VUX01FU1NBR0VfR0VUKTsKCWlmIChJU19FUlIobXNnKSkKCQlyZXR1cm4gUFRSX0VSUihtc2cpOwoKCWkyb19zeXN0YWIucGh5cyA9IGRtYV9tYXBfc2luZ2xlKGRldiwgaTJvX3N5c3RhYi52aXJ0LCBpMm9fc3lzdGFiLmxlbiwKCQkJCQkgUENJX0RNQV9UT0RFVklDRSk7CglpZiAoIWkyb19zeXN0YWIucGh5cykgewoJCWkyb19tc2dfbm9wKGMsIG1zZyk7CgkJcmV0dXJuIC1FTk9NRU07Cgl9CgoJbXNnLT51LmhlYWRbMF0gPSBjcHVfdG9fbGUzMihJMk9fTUVTU0FHRV9TSVpFKDEyKSB8IFNHTF9PRkZTRVRfNik7Cgltc2ctPnUuaGVhZFsxXSA9CgkgICAgY3B1X3RvX2xlMzIoSTJPX0NNRF9TWVNfVEFCX1NFVCA8PCAyNCB8IEhPU1RfVElEIDw8IDEyIHwKCQkJQURBUFRFUl9USUQpOwoKCS8qCgkgKiBQcm92aWRlIHRocmVlIFNHTC1lbGVtZW50czoKCSAqIFN5c3RlbSB0YWJsZSAoU3lzVGFiKSwgUHJpdmF0ZSBtZW1vcnkgc3BhY2UgZGVjbGFyYXRpb24gYW5kCgkgKiBQcml2YXRlIGkvbyBzcGFjZSBkZWNsYXJhdGlvbgoJICoKCSAqIEZJWE1FOiBpcyB0aGlzIHN0aWxsIHRydWU/CgkgKiBOYXN0eSBvbmUgaGVyZS4gV2UgY2FuJ3QgdXNlIGRtYV9hbGxvY19jb2hlcmVudCB0byBzZW5kIHRoZQoJICogc2FtZSB0YWJsZSB0byBldmVyeW9uZS4gV2UgaGF2ZSB0byBnbyByZW1hcCBpdCBmb3IgdGhlbSBhbGwKCSAqLwoKCW1zZy0+Ym9keVswXSA9IGNwdV90b19sZTMyKGMtPnVuaXQgKyAyKTsKCW1zZy0+Ym9keVsxXSA9IGNwdV90b19sZTMyKDB4MDAwMDAwMDApOwoJbXNnLT5ib2R5WzJdID0gY3B1X3RvX2xlMzIoMHg1NDAwMDAwMCB8IGkyb19zeXN0YWIubGVuKTsKCW1zZy0+Ym9keVszXSA9IGNwdV90b19sZTMyKGkyb19zeXN0YWIucGh5cyk7Cgltc2ctPmJvZHlbNF0gPSBjcHVfdG9fbGUzMigweDU0MDAwMDAwIHwgc2ItPmN1cnJlbnRfbWVtX3NpemUpOwoJbXNnLT5ib2R5WzVdID0gY3B1X3RvX2xlMzIoc2ItPmN1cnJlbnRfbWVtX2Jhc2UpOwoJbXNnLT5ib2R5WzZdID0gY3B1X3RvX2xlMzIoMHhkNDAwMDAwMCB8IHNiLT5jdXJyZW50X2lvX3NpemUpOwoJbXNnLT5ib2R5WzZdID0gY3B1X3RvX2xlMzIoc2ItPmN1cnJlbnRfaW9fYmFzZSk7CgoJcmMgPSBpMm9fbXNnX3Bvc3Rfd2FpdChjLCBtc2csIDEyMCk7CgoJZG1hX3VubWFwX3NpbmdsZShkZXYsIGkyb19zeXN0YWIucGh5cywgaTJvX3N5c3RhYi5sZW4sCgkJCSBQQ0lfRE1BX1RPREVWSUNFKTsKCglpZiAocmMgPCAwKQoJCW9zbV9lcnIoIiVzOiBVbmFibGUgdG8gc2V0IFN5c1RhYiAoc3RhdHVzPSUjeCkuXG4iLCBjLT5uYW1lLAoJCQktcmMpOwoJZWxzZQoJCW9zbV9kZWJ1ZygiJXM6IFN5c1RhYiBzZXQuXG4iLCBjLT5uYW1lKTsKCglpMm9fc3RhdHVzX2dldChjKTsJLy8gRW50ZXJlZCBSRUFEWSBzdGF0ZQoKCXJldHVybiByYzsKfQoKLyoqCiAqCWkyb19pb3Bfb25saW5lIC0gQnJpbmcgYSBjb250cm9sbGVyIG9ubGluZSBpbnRvIE9QRVJBVElPTkFMIHN0YXRlLgogKglAYzogSTJPIGNvbnRyb2xsZXIKICoKICoJU2VuZCB0aGUgc3lzdGVtIHRhYmxlIGFuZCBlbmFibGUgdGhlIEkyTyBjb250cm9sbGVyLgogKgogKglSZXR1cm5zIDAgb24gc3VjY2VzcyBvciBuZWdhdGl2ZXIgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgogKi8Kc3RhdGljIGludCBpMm9faW9wX29ubGluZShzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKmMpCnsKCWludCByYzsKCglyYyA9IGkyb19pb3Bfc3lzdGFiX3NldChjKTsKCWlmIChyYykKCQlyZXR1cm4gcmM7CgoJLyogSW4gUkVBRFkgc3RhdGUgKi8KCW9zbV9kZWJ1ZygiJXM6IEF0dGVtcHRpbmcgdG8gZW5hYmxlLi4uXG4iLCBjLT5uYW1lKTsKCXJjID0gaTJvX2lvcF9lbmFibGUoYyk7CglpZiAocmMpCgkJcmV0dXJuIHJjOwoKCXJldHVybiAwOwp9OwoKLyoqCiAqCWkyb19pb3BfcmVtb3ZlIC0gUmVtb3ZlIHRoZSBJMk8gY29udHJvbGxlciBmcm9tIHRoZSBJMk8gY29yZQogKglAYzogSTJPIGNvbnRyb2xsZXIKICoKICoJUmVtb3ZlIHRoZSBJMk8gY29udHJvbGxlciBmcm9tIHRoZSBJMk8gY29yZS4gSWYgZGV2aWNlcyBhcmUgYXR0YWNoZWQgdG8KICoJdGhlIGNvbnRyb2xsZXIgcmVtb3ZlIHRoZXNlIGFsc28gYW5kIGZpbmFsbHkgcmVzZXQgdGhlIGNvbnRyb2xsZXIuCiAqLwp2b2lkIGkyb19pb3BfcmVtb3ZlKHN0cnVjdCBpMm9fY29udHJvbGxlciAqYykKewoJc3RydWN0IGkyb19kZXZpY2UgKmRldiwgKnRtcDsKCglvc21fZGVidWcoIiVzOiBkZWxldGluZyBjb250cm9sbGVyXG4iLCBjLT5uYW1lKTsKCglpMm9fZHJpdmVyX25vdGlmeV9jb250cm9sbGVyX3JlbW92ZV9hbGwoYyk7CgoJbGlzdF9kZWwoJmMtPmxpc3QpOwoKCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShkZXYsIHRtcCwgJmMtPmRldmljZXMsIGxpc3QpCgkgICAgaTJvX2RldmljZV9yZW1vdmUoZGV2KTsKCglkZXZpY2VfZGVsKCZjLT5kZXZpY2UpOwoKCS8qIEFzayB0aGUgSU9QIHRvIHN3aXRjaCB0byBSRVNFVCBzdGF0ZSAqLwoJaTJvX2lvcF9yZXNldChjKTsKCglwdXRfZGV2aWNlKCZjLT5kZXZpY2UpOwp9CgovKioKICoJaTJvX3N5c3RhYl9idWlsZCAtIEJ1aWxkIHN5c3RlbSB0YWJsZQogKgogKglUaGUgc3lzdGVtIHRhYmxlIGNvbnRhaW5zIGluZm9ybWF0aW9uIGFib3V0IGFsbCB0aGUgSU9QcyBpbiB0aGUgc3lzdGVtCiAqCShkdWgpIGFuZCBpcyB1c2VkIGJ5IHRoZSBFeGVjdXRpdmVzIG9uIHRoZSBJT1BzIHRvIGVzdGFibGlzaCBwZWVyMnBlZXIKICoJY29ubmVjdGlvbnMuIFdlJ3JlIG5vdCBzdXBwb3J0aW5nIHBlZXIycGVlciBhdCB0aGUgbW9tZW50LCBidXQgdGhpcwogKgl3aWxsIGJlIG5lZWRlZCBkb3duIHRoZSByb2FkIGZvciB0aGluZ3MgbGlrZSBsYW4ybGFuIGZvcndhcmRpbmcuCiAqCiAqCVJldHVybnMgMCBvbiBzdWNjZXNzIG9yIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KICovCnN0YXRpYyBpbnQgaTJvX3N5c3RhYl9idWlsZCh2b2lkKQp7CglzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKmMsICp0bXA7CglpbnQgbnVtX2NvbnRyb2xsZXJzID0gMDsKCXUzMiBjaGFuZ2VfaW5kID0gMDsKCWludCBjb3VudCA9IDA7CglzdHJ1Y3QgaTJvX3N5c190YmwgKnN5c3RhYiA9IGkyb19zeXN0YWIudmlydDsKCglsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoYywgdG1wLCAmaTJvX2NvbnRyb2xsZXJzLCBsaXN0KQoJICAgIG51bV9jb250cm9sbGVycysrOwoKCWlmIChzeXN0YWIpIHsKCQljaGFuZ2VfaW5kID0gc3lzdGFiLT5jaGFuZ2VfaW5kOwoJCWtmcmVlKGkyb19zeXN0YWIudmlydCk7Cgl9CgoJLyogSGVhZGVyICsgSU9QcyAqLwoJaTJvX3N5c3RhYi5sZW4gPSBzaXplb2Yoc3RydWN0IGkyb19zeXNfdGJsKSArIG51bV9jb250cm9sbGVycyAqCgkgICAgc2l6ZW9mKHN0cnVjdCBpMm9fc3lzX3RibF9lbnRyeSk7CgoJc3lzdGFiID0gaTJvX3N5c3RhYi52aXJ0ID0ga21hbGxvYyhpMm9fc3lzdGFiLmxlbiwgR0ZQX0tFUk5FTCk7CglpZiAoIXN5c3RhYikgewoJCW9zbV9lcnIoInVuYWJsZSB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIFN5c3RlbSBUYWJsZVxuIik7CgkJcmV0dXJuIC1FTk9NRU07Cgl9CgltZW1zZXQoc3lzdGFiLCAwLCBpMm9fc3lzdGFiLmxlbik7CgoJc3lzdGFiLT52ZXJzaW9uID0gSTJPVkVSU0lPTjsKCXN5c3RhYi0+Y2hhbmdlX2luZCA9IGNoYW5nZV9pbmQgKyAxOwoKCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShjLCB0bXAsICZpMm9fY29udHJvbGxlcnMsIGxpc3QpIHsKCQlpMm9fc3RhdHVzX2Jsb2NrICpzYjsKCgkJaWYgKGNvdW50ID49IG51bV9jb250cm9sbGVycykgewoJCQlvc21fZXJyKCJjb250cm9sbGVyIGFkZGVkIHdoaWxlIGJ1aWxkaW5nIHN5c3RlbSB0YWJsZSIKCQkJCSJcbiIpOwoJCQlicmVhazsKCQl9CgoJCXNiID0gYy0+c3RhdHVzX2Jsb2NrLnZpcnQ7CgoJCS8qCgkJICogR2V0IHVwZGF0ZWQgSU9QIHN0YXRlIHNvIHdlIGhhdmUgdGhlIGxhdGVzdCBpbmZvcm1hdGlvbgoJCSAqCgkJICogV2Ugc2hvdWxkIGRlbGV0ZSB0aGUgY29udHJvbGxlciBhdCB0aGlzIHBvaW50IGlmIGl0CgkJICogZG9lc24ndCByZXNwb25kIHNpbmNlIGlmIGl0J3Mgbm90IG9uIHRoZSBzeXN0ZW0gdGFibGUKCQkgKiBpdCBpcyB0ZWNobmluaWNhbGx5IG5vdCBwYXJ0IG9mIHRoZSBJMk8gc3Vic3lzdGVtLi4uCgkJICovCgkJaWYgKHVubGlrZWx5KGkyb19zdGF0dXNfZ2V0KGMpKSkgewoJCQlvc21fZXJyKCIlczogRGVsZXRpbmcgYi9jIGNvdWxkIG5vdCBnZXQgc3RhdHVzIHdoaWxlICIKCQkJCSJhdHRlbXB0aW5nIHRvIGJ1aWxkIHN5c3RlbSB0YWJsZVxuIiwgYy0+bmFtZSk7CgkJCWkyb19pb3BfcmVtb3ZlKGMpOwoJCQljb250aW51ZTsJLy8gdHJ5IHRoZSBuZXh0IG9uZQoJCX0KCgkJc3lzdGFiLT5pb3BzW2NvdW50XS5vcmdfaWQgPSBzYi0+b3JnX2lkOwoJCXN5c3RhYi0+aW9wc1tjb3VudF0uaW9wX2lkID0gYy0+dW5pdCArIDI7CgkJc3lzdGFiLT5pb3BzW2NvdW50XS5zZWdfbnVtID0gMDsKCQlzeXN0YWItPmlvcHNbY291bnRdLmkyb192ZXJzaW9uID0gc2ItPmkyb192ZXJzaW9uOwoJCXN5c3RhYi0+aW9wc1tjb3VudF0uaW9wX3N0YXRlID0gc2ItPmlvcF9zdGF0ZTsKCQlzeXN0YWItPmlvcHNbY291bnRdLm1zZ190eXBlID0gc2ItPm1zZ190eXBlOwoJCXN5c3RhYi0+aW9wc1tjb3VudF0uZnJhbWVfc2l6ZSA9IHNiLT5pbmJvdW5kX2ZyYW1lX3NpemU7CgkJc3lzdGFiLT5pb3BzW2NvdW50XS5sYXN0X2NoYW5nZWQgPSBjaGFuZ2VfaW5kOwoJCXN5c3RhYi0+aW9wc1tjb3VudF0uaW9wX2NhcGFiaWxpdGllcyA9IHNiLT5pb3BfY2FwYWJpbGl0aWVzOwoJCXN5c3RhYi0+aW9wc1tjb3VudF0uaW5ib3VuZF9sb3cgPQoJCSAgICBpMm9fZG1hX2xvdyhjLT5iYXNlLnBoeXMgKyBJMk9fSU5fUE9SVCk7CgkJc3lzdGFiLT5pb3BzW2NvdW50XS5pbmJvdW5kX2hpZ2ggPQoJCSAgICBpMm9fZG1hX2hpZ2goYy0+YmFzZS5waHlzICsgSTJPX0lOX1BPUlQpOwoKCQljb3VudCsrOwoJfQoKCXN5c3RhYi0+bnVtX2VudHJpZXMgPSBjb3VudDsKCglyZXR1cm4gMDsKfTsKCi8qKgogKglpMm9fcGFyc2VfaHJ0IC0gUGFyc2UgdGhlIGhhcmR3YXJlIHJlc291cmNlIHRhYmxlLgogKglAYzogSTJPIGNvbnRyb2xsZXIKICoKICoJV2UgZG9uJ3QgZG8gYW55dGhpbmcgd2l0aCBpdCBleGNlcHQgZHVtcGluZyBpdCAoaW4gZGVidWcgbW9kZSkuCiAqCiAqCVJldHVybnMgMC4KICovCnN0YXRpYyBpbnQgaTJvX3BhcnNlX2hydChzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKmMpCnsKCWkyb19kdW1wX2hydChjKTsKCXJldHVybiAwOwp9OwoKLyoqCiAqCWkyb19zdGF0dXNfZ2V0IC0gR2V0IHRoZSBzdGF0dXMgYmxvY2sgZnJvbSB0aGUgSTJPIGNvbnRyb2xsZXIKICoJQGM6IEkyTyBjb250cm9sbGVyCiAqCiAqCUlzc3VlIGEgc3RhdHVzIHF1ZXJ5IG9uIHRoZSBjb250cm9sbGVyLiBUaGlzIHVwZGF0ZXMgdGhlIGF0dGFjaGVkCiAqCXN0YXR1cyBibG9jay4gVGhlIHN0YXR1cyBibG9jayBjb3VsZCB0aGVuIGJlIGFjY2Vzc2VkIHRocm91Z2gKICoJYy0+c3RhdHVzX2Jsb2NrLgogKgogKglSZXR1cm5zIDAgb24gc3VjZXNzIG9yIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KICovCmludCBpMm9fc3RhdHVzX2dldChzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKmMpCnsKCXN0cnVjdCBpMm9fbWVzc2FnZSAqbXNnOwoJdm9sYXRpbGUgdTggKnN0YXR1c19ibG9jazsKCXVuc2lnbmVkIGxvbmcgdGltZW91dDsKCglzdGF0dXNfYmxvY2sgPSAodTggKikgYy0+c3RhdHVzX2Jsb2NrLnZpcnQ7CgltZW1zZXQoYy0+c3RhdHVzX2Jsb2NrLnZpcnQsIDAsIHNpemVvZihpMm9fc3RhdHVzX2Jsb2NrKSk7CgoJbXNnID0gaTJvX21zZ19nZXRfd2FpdChjLCBJMk9fVElNRU9VVF9NRVNTQUdFX0dFVCk7CglpZiAoSVNfRVJSKG1zZykpCgkJcmV0dXJuIFBUUl9FUlIobXNnKTsKCgltc2ctPnUuaGVhZFswXSA9IGNwdV90b19sZTMyKE5JTkVfV09SRF9NU0dfU0laRSB8IFNHTF9PRkZTRVRfMCk7Cgltc2ctPnUuaGVhZFsxXSA9CgkgICAgY3B1X3RvX2xlMzIoSTJPX0NNRF9TVEFUVVNfR0VUIDw8IDI0IHwgSE9TVF9USUQgPDwgMTIgfAoJCQlBREFQVEVSX1RJRCk7Cgltc2ctPnUucy5pY250eHQgPSBjcHVfdG9fbGUzMihpMm9fZXhlY19kcml2ZXIuY29udGV4dCk7Cgltc2ctPnUucy50Y250eHQgPSBjcHVfdG9fbGUzMigweDAwMDAwMDAwKTsKCW1zZy0+Ym9keVswXSA9IGNwdV90b19sZTMyKDB4MDAwMDAwMDApOwoJbXNnLT5ib2R5WzFdID0gY3B1X3RvX2xlMzIoMHgwMDAwMDAwMCk7Cgltc2ctPmJvZHlbMl0gPSBjcHVfdG9fbGUzMihpMm9fZG1hX2xvdyhjLT5zdGF0dXNfYmxvY2sucGh5cykpOwoJbXNnLT5ib2R5WzNdID0gY3B1X3RvX2xlMzIoaTJvX2RtYV9oaWdoKGMtPnN0YXR1c19ibG9jay5waHlzKSk7Cgltc2ctPmJvZHlbNF0gPSBjcHVfdG9fbGUzMihzaXplb2YoaTJvX3N0YXR1c19ibG9jaykpOwkvKiBhbHdheXMgODggYnl0ZXMgKi8KCglpMm9fbXNnX3Bvc3QoYywgbXNnKTsKCgkvKiBXYWl0IGZvciBhIHJlcGx5ICovCgl0aW1lb3V0ID0gamlmZmllcyArIEkyT19USU1FT1VUX1NUQVRVU19HRVQgKiBIWjsKCXdoaWxlIChzdGF0dXNfYmxvY2tbODddICE9IDB4RkYpIHsKCQlpZiAodGltZV9hZnRlcihqaWZmaWVzLCB0aW1lb3V0KSkgewoJCQlvc21fZXJyKCIlczogR2V0IHN0YXR1cyB0aW1lb3V0LlxuIiwgYy0+bmFtZSk7CgkJCXJldHVybiAtRVRJTUVET1VUOwoJCX0KCgkJc2NoZWR1bGVfdGltZW91dF91bmludGVycnVwdGlibGUoMSk7Cgl9CgojaWZkZWYgREVCVUcKCWkyb19kZWJ1Z19zdGF0ZShjKTsKI2VuZGlmCgoJcmV0dXJuIDA7Cn0KCi8qCiAqCWkyb19ocnRfZ2V0IC0gR2V0IHRoZSBIYXJkd2FyZSBSZXNvdXJjZSBUYWJsZSBmcm9tIHRoZSBJMk8gY29udHJvbGxlcgogKglAYzogSTJPIGNvbnRyb2xsZXIgZnJvbSB3aGljaCB0aGUgSFJUIHNob3VsZCBiZSBmZXRjaGVkCiAqCiAqCVRoZSBIUlQgY29udGFpbnMgaW5mb3JtYXRpb24gYWJvdXQgcG9zc2libGUgaGlkZGVuIGRldmljZXMgYnV0IGlzCiAqCW1vc3RseSB1c2VsZXNzIHRvIHVzLgogKgogKglSZXR1cm5zIDAgb24gc3VjY2VzcyBvciBuZWdhdGl2ZXIgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgogKi8Kc3RhdGljIGludCBpMm9faHJ0X2dldChzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKmMpCnsKCWludCByYzsKCWludCBpOwoJaTJvX2hydCAqaHJ0ID0gYy0+aHJ0LnZpcnQ7Cgl1MzIgc2l6ZSA9IHNpemVvZihpMm9faHJ0KTsKCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZjLT5wZGV2LT5kZXY7CgoJZm9yIChpID0gMDsgaSA8IEkyT19IUlRfR0VUX1RSSUVTOyBpKyspIHsKCQlzdHJ1Y3QgaTJvX21lc3NhZ2UgKm1zZzsKCgkJbXNnID0gaTJvX21zZ19nZXRfd2FpdChjLCBJMk9fVElNRU9VVF9NRVNTQUdFX0dFVCk7CgkJaWYgKElTX0VSUihtc2cpKQoJCQlyZXR1cm4gUFRSX0VSUihtc2cpOwoKCQltc2ctPnUuaGVhZFswXSA9IGNwdV90b19sZTMyKFNJWF9XT1JEX01TR19TSVpFIHwgU0dMX09GRlNFVF80KTsKCQltc2ctPnUuaGVhZFsxXSA9CgkJICAgIGNwdV90b19sZTMyKEkyT19DTURfSFJUX0dFVCA8PCAyNCB8IEhPU1RfVElEIDw8IDEyIHwKCQkJCUFEQVBURVJfVElEKTsKCQltc2ctPmJvZHlbMF0gPSBjcHVfdG9fbGUzMigweGQwMDAwMDAwIHwgYy0+aHJ0Lmxlbik7CgkJbXNnLT5ib2R5WzFdID0gY3B1X3RvX2xlMzIoYy0+aHJ0LnBoeXMpOwoKCQlyYyA9IGkyb19tc2dfcG9zdF93YWl0X21lbShjLCBtc2csIDIwLCAmYy0+aHJ0KTsKCgkJaWYgKHJjIDwgMCkgewoJCQlvc21fZXJyKCIlczogVW5hYmxlIHRvIGdldCBIUlQgKHN0YXR1cz0lI3gpXG4iLCBjLT5uYW1lLAoJCQkJLXJjKTsKCQkJcmV0dXJuIHJjOwoJCX0KCgkJc2l6ZSA9IGhydC0+bnVtX2VudHJpZXMgKiBocnQtPmVudHJ5X2xlbiA8PCAyOwoJCWlmIChzaXplID4gYy0+aHJ0LmxlbikgewoJCQlpZiAoaTJvX2RtYV9yZWFsbG9jKGRldiwgJmMtPmhydCwgc2l6ZSwgR0ZQX0tFUk5FTCkpCgkJCQlyZXR1cm4gLUVOT01FTTsKCQkJZWxzZQoJCQkJaHJ0ID0gYy0+aHJ0LnZpcnQ7CgkJfSBlbHNlCgkJCXJldHVybiBpMm9fcGFyc2VfaHJ0KGMpOwoJfQoKCW9zbV9lcnIoIiVzOiBVbmFibGUgdG8gZ2V0IEhSVCBhZnRlciAlZCB0cmllcywgZ2l2aW5nIHVwXG4iLCBjLT5uYW1lLAoJCUkyT19IUlRfR0VUX1RSSUVTKTsKCglyZXR1cm4gLUVCVVNZOwp9CgovKioKICoJaTJvX2lvcF9mcmVlIC0gRnJlZSB0aGUgaTJvX2NvbnRyb2xsZXIgc3RydWN0CiAqCUBjOiBJMk8gY29udHJvbGxlciB0byBmcmVlCiAqLwp2b2lkIGkyb19pb3BfZnJlZShzdHJ1Y3QgaTJvX2NvbnRyb2xsZXIgKmMpCnsKCWkyb19wb29sX2ZyZWUoJmMtPmluX21zZyk7CglrZnJlZShjKTsKfTsKCi8qKgogKglpMm9faW9wX3JlbGVhc2UgLSByZWxlYXNlIHRoZSBtZW1vcnkgZm9yIGEgSTJPIGNvbnRyb2xsZXIKICoJQGRldjogSTJPIGNvbnRyb2xsZXIgd2hpY2ggc2hvdWxkIGJlIHJlbGVhc2VkCiAqCiAqCVJlbGVhc2UgdGhlIGFsbG9jYXRlZCBtZW1vcnkuIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIGlmIHJlZmNvdW50IG9mCiAqCWRldmljZSByZWFjaGVzIDAgYXV0b21hdGljYWxseS4KICovCnN0YXRpYyB2b2lkIGkyb19pb3BfcmVsZWFzZShzdHJ1Y3QgZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBpMm9fY29udHJvbGxlciAqYyA9IHRvX2kyb19jb250cm9sbGVyKGRldik7CgoJaTJvX2lvcF9mcmVlKGMpOwp9OwoKLyoqCiAqCWkyb19pb3BfYWxsb2MgLSBBbGxvY2F0ZSBhbmQgaW5pdGlhbGl6ZSBhIGkyb19jb250cm9sbGVyIHN0cnVjdAogKgogKglBbGxvY2F0ZSB0aGUgbmVjZXNzYXJ5IG1lbW9yeSBmb3IgYSBpMm9fY29udHJvbGxlciBzdHJ1Y3QgYW5kCiAqCWluaXRpYWxpemUgdGhlIGxpc3RzIGFuZCBtZXNzYWdlIG1lbXBvb2wuCiAqCiAqCVJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBJMk8gY29udHJvbGxlciBvciBhIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24KICoJZmFpbHVyZS4KICovCnN0cnVjdCBpMm9fY29udHJvbGxlciAqaTJvX2lvcF9hbGxvYyh2b2lkKQp7CglzdGF0aWMgaW50IHVuaXQgPSAwOwkvKiAwIGFuZCAxIGFyZSBOVUxMIElPUCBhbmQgTG9jYWwgSG9zdCAqLwoJc3RydWN0IGkyb19jb250cm9sbGVyICpjOwoJY2hhciBwb29sbmFtZVszMl07CgoJYyA9IGttYWxsb2Moc2l6ZW9mKCpjKSwgR0ZQX0tFUk5FTCk7CglpZiAoIWMpIHsKCQlvc21fZXJyKCJpMm86IEluc3VmZmljaWVudCBtZW1vcnkgdG8gYWxsb2NhdGUgYSBJMk8gY29udHJvbGxlci4iCgkJCSJcbiIpOwoJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwoJfQoJbWVtc2V0KGMsIDAsIHNpemVvZigqYykpOwoKCWMtPnVuaXQgPSB1bml0Kys7CglzcHJpbnRmKGMtPm5hbWUsICJpb3AlZCIsIGMtPnVuaXQpOwoKCXNucHJpbnRmKHBvb2xuYW1lLCBzaXplb2YocG9vbG5hbWUpLCAiaTJvXyVzX21zZ19pbnBvb2wiLCBjLT5uYW1lKTsKCWlmIChpMm9fcG9vbF9hbGxvYwoJICAgICgmYy0+aW5fbXNnLCBwb29sbmFtZSwgSTJPX0lOQk9VTkRfTVNHX0ZSQU1FX1NJWkUgKiA0LAoJICAgICBJMk9fTVNHX0lOUE9PTF9NSU4pKSB7CgkJa2ZyZWUoYyk7CgkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7Cgl9OwoKCUlOSVRfTElTVF9IRUFEKCZjLT5kZXZpY2VzKTsKCXNwaW5fbG9ja19pbml0KCZjLT5sb2NrKTsKCWluaXRfTVVURVgoJmMtPmxjdF9sb2NrKTsKCglkZXZpY2VfaW5pdGlhbGl6ZSgmYy0+ZGV2aWNlKTsKCgljLT5kZXZpY2UucmVsZWFzZSA9ICZpMm9faW9wX3JlbGVhc2U7CgoJc25wcmludGYoYy0+ZGV2aWNlLmJ1c19pZCwgQlVTX0lEX1NJWkUsICJpb3AlZCIsIGMtPnVuaXQpOwoKI2lmIEJJVFNfUEVSX0xPTkcgPT0gNjQKCXNwaW5fbG9ja19pbml0KCZjLT5jb250ZXh0X2xpc3RfbG9jayk7CglhdG9taWNfc2V0KCZjLT5jb250ZXh0X2xpc3RfY291bnRlciwgMCk7CglJTklUX0xJU1RfSEVBRCgmYy0+Y29udGV4dF9saXN0KTsKI2VuZGlmCgoJcmV0dXJuIGM7Cn07CgovKioKICoJaTJvX2lvcF9hZGQgLSBJbml0aWFsaXplIHRoZSBJMk8gY29udHJvbGxlciBhbmQgYWRkIGhpbSB0byB0aGUgSTJPIGNvcmUKICoJQGM6IGNvbnRyb2xsZXIKICoKICoJSW5pdGlhbGl6ZSB0aGUgSTJPIGNvbnRyb2xsZXIgYW5kIGlmIG5vIGVycm9yIG9jY3VycyBhZGQgaGltIHRvIHRoZSBJMk8KICoJY29yZS4KICoKICoJUmV0dXJucyAwIG9uIHN1Y2Nlc3Mgb3IgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgogKi8KaW50IGkyb19pb3BfYWRkKHN0cnVjdCBpMm9fY29udHJvbGxlciAqYykKewoJaW50IHJjOwoKCWlmICgocmMgPSBkZXZpY2VfYWRkKCZjLT5kZXZpY2UpKSkgewoJCW9zbV9lcnIoIiVzOiBjb3VsZCBub3QgYWRkIGNvbnRyb2xsZXJcbiIsIGMtPm5hbWUpOwoJCWdvdG8gaW9wX3Jlc2V0OwoJfQoKCW9zbV9pbmZvKCIlczogQWN0aXZhdGluZyBJMk8gY29udHJvbGxlci4uLlxuIiwgYy0+bmFtZSk7Cglvc21faW5mbygiJXM6IFRoaXMgbWF5IHRha2UgYSBmZXcgbWludXRlcyBpZiB0aGVyZSBhcmUgbWFueSBkZXZpY2VzXG4iLAoJCSBjLT5uYW1lKTsKCglpZiAoKHJjID0gaTJvX2lvcF9hY3RpdmF0ZShjKSkpIHsKCQlvc21fZXJyKCIlczogY291bGQgbm90IGFjdGl2YXRlIGNvbnRyb2xsZXJcbiIsIGMtPm5hbWUpOwoJCWdvdG8gZGV2aWNlX2RlbDsKCX0KCglvc21fZGVidWcoIiVzOiBidWlsZGluZyBzeXMgdGFibGUuLi5cbiIsIGMtPm5hbWUpOwoKCWlmICgocmMgPSBpMm9fc3lzdGFiX2J1aWxkKCkpKQoJCWdvdG8gZGV2aWNlX2RlbDsKCglvc21fZGVidWcoIiVzOiBvbmxpbmUgY29udHJvbGxlci4uLlxuIiwgYy0+bmFtZSk7CgoJaWYgKChyYyA9IGkyb19pb3Bfb25saW5lKGMpKSkKCQlnb3RvIGRldmljZV9kZWw7CgoJb3NtX2RlYnVnKCIlczogZ2V0dGluZyBMQ1QuLi5cbiIsIGMtPm5hbWUpOwoKCWlmICgocmMgPSBpMm9fZXhlY19sY3RfZ2V0KGMpKSkKCQlnb3RvIGRldmljZV9kZWw7CgoJbGlzdF9hZGQoJmMtPmxpc3QsICZpMm9fY29udHJvbGxlcnMpOwoKCWkyb19kcml2ZXJfbm90aWZ5X2NvbnRyb2xsZXJfYWRkX2FsbChjKTsKCglvc21faW5mbygiJXM6IENvbnRyb2xsZXIgYWRkZWRcbiIsIGMtPm5hbWUpOwoKCXJldHVybiAwOwoKICAgICAgZGV2aWNlX2RlbDoKCWRldmljZV9kZWwoJmMtPmRldmljZSk7CgogICAgICBpb3BfcmVzZXQ6CglpMm9faW9wX3Jlc2V0KGMpOwoKCXJldHVybiByYzsKfTsKCi8qKgogKglpMm9fZXZlbnRfcmVnaXN0ZXIgLSBUdXJuIG9uL29mZiBldmVudCBub3RpZmljYXRpb24gZm9yIGEgSTJPIGRldmljZQogKglAZGV2OiBJMk8gZGV2aWNlIHdoaWNoIHNob3VsZCByZWNlaXZlIHRoZSBldmVudCByZWdpc3RyYXRpb24gcmVxdWVzdAogKglAZHJ2OiBkcml2ZXIgd2hpY2ggd2FudCB0byBnZXQgbm90aWZpZWQKICoJQHRjbnR4dDogdHJhbnNhY3Rpb24gY29udGV4dCB0byB1c2Ugd2l0aCB0aGlzIG5vdGlmaWVyCiAqCUBldnRfbWFzazogbWFzayBvZiBldmVudHMKICoKICoJQ3JlYXRlIGFuZCBwb3N0cyBhbiBldmVudCByZWdpc3RyYXRpb24gbWVzc2FnZSB0byB0aGUgdGFzay4gTm8gcmVwbHkKICoJaXMgd2FpdGVkIGZvciwgb3IgZXhwZWN0ZWQuIElmIHlvdSBkbyBub3Qgd2FudCBmdXJ0aGVyIG5vdGlmaWNhdGlvbnMsCiAqCWNhbGwgdGhlIGkyb19ldmVudF9yZWdpc3RlciBhZ2FpbiB3aXRoIGEgZXZ0X21hc2sgb2YgMC4KICoKICoJUmV0dXJucyAwIG9uIHN1Y2Nlc3Mgb3IgbmVnYXRpdmUgZXJyb3IgY29kZSBvbiBmYWlsdXJlLgogKi8KaW50IGkyb19ldmVudF9yZWdpc3RlcihzdHJ1Y3QgaTJvX2RldmljZSAqZGV2LCBzdHJ1Y3QgaTJvX2RyaXZlciAqZHJ2LAoJCSAgICAgICBpbnQgdGNudHh0LCB1MzIgZXZ0X21hc2spCnsKCXN0cnVjdCBpMm9fY29udHJvbGxlciAqYyA9IGRldi0+aW9wOwoJc3RydWN0IGkyb19tZXNzYWdlICptc2c7CgoJbXNnID0gaTJvX21zZ19nZXRfd2FpdChjLCBJMk9fVElNRU9VVF9NRVNTQUdFX0dFVCk7CglpZiAoSVNfRVJSKG1zZykpCgkJcmV0dXJuIFBUUl9FUlIobXNnKTsKCgltc2ctPnUuaGVhZFswXSA9IGNwdV90b19sZTMyKEZJVkVfV09SRF9NU0dfU0laRSB8IFNHTF9PRkZTRVRfMCk7Cgltc2ctPnUuaGVhZFsxXSA9CgkgICAgY3B1X3RvX2xlMzIoSTJPX0NNRF9VVElMX0VWVF9SRUdJU1RFUiA8PCAyNCB8IEhPU1RfVElEIDw8IDEyIHwgZGV2LT4KCQkJbGN0X2RhdGEudGlkKTsKCW1zZy0+dS5zLmljbnR4dCA9IGNwdV90b19sZTMyKGRydi0+Y29udGV4dCk7Cgltc2ctPnUucy50Y250eHQgPSBjcHVfdG9fbGUzMih0Y250eHQpOwoJbXNnLT5ib2R5WzBdID0gY3B1X3RvX2xlMzIoZXZ0X21hc2spOwoKCWkyb19tc2dfcG9zdChjLCBtc2cpOwoKCXJldHVybiAwOwp9OwoKLyoqCiAqCWkyb19pb3BfaW5pdCAtIEkyTyBtYWluIGluaXRpYWxpemF0aW9uIGZ1bmN0aW9uCiAqCiAqCUluaXRpYWxpemUgdGhlIEkyTyBkcml2ZXJzIChPU00pIGZ1bmN0aW9ucywgcmVnaXN0ZXIgdGhlIEV4ZWN1dGl2ZSBPU00sCiAqCWluaXRpYWxpemUgdGhlIEkyTyBQQ0kgcGFydCBhbmQgZmluYWxseSBpbml0aWFsaXplIEkyTyBkZXZpY2Ugc3R1ZmYuCiAqCiAqCVJldHVybnMgMCBvbiBzdWNjZXNzIG9yIG5lZ2F0aXZlIGVycm9yIGNvZGUgb24gZmFpbHVyZS4KICovCnN0YXRpYyBpbnQgX19pbml0IGkyb19pb3BfaW5pdCh2b2lkKQp7CglpbnQgcmMgPSAwOwoKCXByaW50ayhLRVJOX0lORk8gT1NNX0RFU0NSSVBUSU9OICIgdiIgT1NNX1ZFUlNJT04gIlxuIik7CgoJaWYgKChyYyA9IGkyb19kcml2ZXJfaW5pdCgpKSkKCQlnb3RvIGV4aXQ7CgoJaWYgKChyYyA9IGkyb19leGVjX2luaXQoKSkpCgkJZ290byBkcml2ZXJfZXhpdDsKCglpZiAoKHJjID0gaTJvX3BjaV9pbml0KCkpKQoJCWdvdG8gZXhlY19leGl0OwoKCXJldHVybiAwOwoKICAgICAgZXhlY19leGl0OgoJaTJvX2V4ZWNfZXhpdCgpOwoKICAgICAgZHJpdmVyX2V4aXQ6CglpMm9fZHJpdmVyX2V4aXQoKTsKCiAgICAgIGV4aXQ6CglyZXR1cm4gcmM7Cn0KCi8qKgogKglpMm9faW9wX2V4aXQgLSBJMk8gbWFpbiBleGl0IGZ1bmN0aW9uCiAqCiAqCVJlbW92ZXMgSTJPIGNvbnRyb2xsZXJzIGZyb20gUENJIHN1YnN5c3RlbSBhbmQgc2h1dCBkb3duIE9TTXMuCiAqLwpzdGF0aWMgdm9pZCBfX2V4aXQgaTJvX2lvcF9leGl0KHZvaWQpCnsKCWkyb19wY2lfZXhpdCgpOwoJaTJvX2V4ZWNfZXhpdCgpOwoJaTJvX2RyaXZlcl9leGl0KCk7Cn07Cgptb2R1bGVfaW5pdChpMm9faW9wX2luaXQpOwptb2R1bGVfZXhpdChpMm9faW9wX2V4aXQpOwoKTU9EVUxFX0FVVEhPUigiUmVkIEhhdCBTb2Z0d2FyZSIpOwpNT0RVTEVfTElDRU5TRSgiR1BMIik7Ck1PRFVMRV9ERVNDUklQVElPTihPU01fREVTQ1JJUFRJT04pOwpNT0RVTEVfVkVSU0lPTihPU01fVkVSU0lPTik7CgojaWYgQklUU19QRVJfTE9ORyA9PSA2NApFWFBPUlRfU1lNQk9MKGkyb19jbnR4dF9saXN0X2FkZCk7CkVYUE9SVF9TWU1CT0woaTJvX2NudHh0X2xpc3RfZ2V0KTsKRVhQT1JUX1NZTUJPTChpMm9fY250eHRfbGlzdF9yZW1vdmUpOwpFWFBPUlRfU1lNQk9MKGkyb19jbnR4dF9saXN0X2dldF9wdHIpOwojZW5kaWYKRVhQT1JUX1NZTUJPTChpMm9fbXNnX2dldF93YWl0KTsKRVhQT1JUX1NZTUJPTChpMm9fbXNnX25vcCk7CkVYUE9SVF9TWU1CT0woaTJvX2ZpbmRfaW9wKTsKRVhQT1JUX1NZTUJPTChpMm9faW9wX2ZpbmRfZGV2aWNlKTsKRVhQT1JUX1NZTUJPTChpMm9fZXZlbnRfcmVnaXN0ZXIpOwpFWFBPUlRfU1lNQk9MKGkyb19zdGF0dXNfZ2V0KTsKRVhQT1JUX1NZTUJPTChpMm9fY29udHJvbGxlcnMpOwo=