LyoKICogZnMuYyAtIE5URlMgZHJpdmVyIGZvciBMaW51eCAyLjQueAogKgogKiBMZWdhdG8gU3lzdGVtcywgSW5jLiAoaHR0cDovL3d3dy5sZWdhdG8uY29tKSBoYXZlIHNwb25zb3JlZCBBbnRvbgogKiBBbHRhcGFybWFrb3YgdG8gZGV2ZWxvcCBOVEZTIG9uIExpbnV4IHNpbmNlIEp1bmUgMjAwMS4KICoKICogQ29weXJpZ2h0IChDKSAxOTk1LTE5OTcsIDE5OTkgTWFydGluIHZvbiBM9ndpcwogKiBDb3B5cmlnaHQgKEMpIDE5OTYgUmljaGFyZCBSdXNzb24KICogQ29weXJpZ2h0IChDKSAxOTk2LTE5OTcgUulnaXMgRHVjaGVzbmUKICogQ29weXJpZ2h0IChDKSAyMDAwLTIwMDEsIEFudG9uIEFsdGFwYXJtYWtvdiAoQUlBKQogKi8KCiNpbmNsdWRlIDxsaW51eC9jb25maWcuaD4KI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CiNpbmNsdWRlICJudGZzdHlwZXMuaCIKI2luY2x1ZGUgInN0cnVjdC5oIgojaW5jbHVkZSAidXRpbC5oIgojaW5jbHVkZSAiaW5vZGUuaCIKI2luY2x1ZGUgInN1cGVyLmgiCiNpbmNsdWRlICJkaXIuaCIKI2luY2x1ZGUgInN1cHBvcnQuaCIKI2luY2x1ZGUgIm1hY3Jvcy5oIgojaW5jbHVkZSAic3lzY3RsLmgiCiNpbmNsdWRlICJhdHRyLmgiCiNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CiNpbmNsdWRlIDxsaW51eC9sb2Nrcy5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgvc21wX2xvY2suaD4KI2luY2x1ZGUgPGxpbnV4L2Jsa2Rldi5oPgojaW5jbHVkZSA8YXNtL3BhZ2UuaD4KI2luY2x1ZGUgPGxpbnV4L25scy5oPgojaW5jbHVkZSA8bGludXgvbnRmc19mcy5oPgoKLyogRm9yd2FyZCBkZWNsYXJhdGlvbnMuICovCnN0YXRpYyBzdHJ1Y3QgaW5vZGVfb3BlcmF0aW9ucyBudGZzX2Rpcl9pbm9kZV9vcGVyYXRpb25zOwpzdGF0aWMgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBudGZzX2Rpcl9vcGVyYXRpb25zOwoKI2RlZmluZSBJVEVNX1NJWkUgMjA0MAoKLyogSW8gZnVuY3Rpb25zIHRvIHVzZXIgc3BhY2UuICovCnN0YXRpYyB2b2lkIG50ZnNfcHV0dXNlcihudGZzX2lvKiBkZXN0LCB2b2lkICpzcmMsIG50ZnNfc2l6ZV90IGxlbikKewoJY29weV90b191c2VyKGRlc3QtPnBhcmFtLCBzcmMsIGxlbik7CglkZXN0LT5wYXJhbSArPSBsZW47Cn0KCiNpZmRlZiBDT05GSUdfTlRGU19SVwpzdHJ1Y3QgbnRmc19nZXR1c2VyX3VwZGF0ZV92bV9zIHsKCWNvbnN0IGNoYXIgKnVzZXI7CglzdHJ1Y3QgaW5vZGUgKmlubzsKCWxvZmZfdCBvZmY7Cn07CgpzdGF0aWMgdm9pZCBudGZzX2dldHVzZXJfdXBkYXRlX3ZtKHZvaWQgKmRlc3QsIG50ZnNfaW8gKnNyYywgbnRmc19zaXplX3QgbGVuKQp7CglzdHJ1Y3QgbnRmc19nZXR1c2VyX3VwZGF0ZV92bV9zICpwID0gc3JjLT5wYXJhbTsKCQoJY29weV9mcm9tX3VzZXIoZGVzdCwgcC0+dXNlciwgbGVuKTsKCXAtPnVzZXIgKz0gbGVuOwoJcC0+b2ZmICs9IGxlbjsKfQojZW5kaWYKCi8qIGxvZmZfdCBpcyA2NCBiaXQgc2lnbmVkLCBzbyBpcyBjb29sLiAqLwpzdGF0aWMgc3NpemVfdCBudGZzX3JlYWQoc3RydWN0IGZpbGUgKmZpbHAsIGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50LGxvZmZfdCAqb2ZmKQp7CglpbnQgZXJyb3I7CgludGZzX2lvIGlvOwoJbnRmc19hdHRyaWJ1dGUgKmF0dHI7CgludGZzX2lub2RlICppbm8gPSBOVEZTX0koZmlscC0+Zl9kZW50cnktPmRfaW5vZGUpOwoKCS8qIElub2RlIGlzIG5vdCBwcm9wZXJseSBpbml0aWFsaXplZC4gKi8KCWlmICghaW5vKQoJCXJldHVybiAtRUlOVkFMOwoJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgIm50ZnNfcmVhZCAleCwgJUx4LCAleCAtPiIsCgkJICAgKHVuc2lnbmVkKWluby0+aV9udW1iZXIsICh1bnNpZ25lZCBsb25nIGxvbmcpKm9mZiwKCQkgICAodW5zaWduZWQpY291bnQpOwoJYXR0ciA9IG50ZnNfZmluZF9hdHRyKGlubywgaW5vLT52b2wtPmF0X2RhdGEsIE5VTEwpOwoJLyogSW5vZGUgaGFzIG5vIHVubmFtZWQgZGF0YSBhdHRyaWJ1dGUuICovCglpZiAoIWF0dHIpIHsKCQludGZzX2RlYnVnKERFQlVHX09USEVSLCAibnRmc19yZWFkOiAkREFUQSBub3QgZm91bmQhXG4iKTsKCQlyZXR1cm4gLUVJTlZBTDsKCX0KCWlmIChhdHRyLT5mbGFncyAmIEFUVFJfSVNfRU5DUllQVEVEKQoJCXJldHVybiAtRUFDQ0VTOwoJLyogUmVhZCB0aGUgZGF0YS4gKi8KCWlvLmZuX3B1dCA9IG50ZnNfcHV0dXNlcjsKCWlvLmZuX2dldCA9IDA7Cglpby5wYXJhbSA9IGJ1ZjsKCWlvLnNpemUgPSBjb3VudDsKCWVycm9yID0gbnRmc19yZWFkX2F0dHIoaW5vLCBpbm8tPnZvbC0+YXRfZGF0YSwgTlVMTCwgKm9mZiwgJmlvKTsKCWlmIChlcnJvciAmJiAhaW8uc2l6ZSkgewoJCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsICJudGZzX3JlYWQ6IHJlYWRfYXR0ciBmYWlsZWQgd2l0aCAiCgkJCQkiZXJyb3IgJWksIGlvIHNpemUgJXUuXG4iLCBlcnJvciwgaW8uc2l6ZSk7CgkJcmV0dXJuIGVycm9yOwoJfQoJKm9mZiArPSBpby5zaXplOwoJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgIm50ZnNfcmVhZDogZmluaXNoZWQuIHJlYWQgJXUgYnl0ZXMuXG4iLAoJCQkJCQkJCWlvLnNpemUpOwoJcmV0dXJuIGlvLnNpemU7Cn0KCiNpZmRlZiBDT05GSUdfTlRGU19SVwpzdGF0aWMgc3NpemVfdCBudGZzX3dyaXRlKHN0cnVjdCBmaWxlICpmaWxwLCBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCwKCQlsb2ZmX3QgKnBvcykKewoJaW50IGVycjsKCXN0cnVjdCBpbm9kZSAqdmZzX2lubyA9IGZpbHAtPmZfZGVudHJ5LT5kX2lub2RlOwoJbnRmc19pbm9kZSAqbnRmc19pbm8gPSBOVEZTX0kodmZzX2lubyk7CgludGZzX2F0dHJpYnV0ZSAqZGF0YTsKCW50ZnNfaW8gaW87CglzdHJ1Y3QgbnRmc19nZXR1c2VyX3VwZGF0ZV92bV9zIHBhcmFtOwoKCWlmICghbnRmc19pbm8pCgkJcmV0dXJuIC1FSU5WQUw7CgludGZzX2RlYnVnKERFQlVHX0xJTlVYLCBfX0ZVTkNUSU9OX18gIigpOiBFbnRlcmluZyBmb3IgaW5vZGUgMHglbHgsICIKCQkJIipwb3MgMHglTHgsIGNvdW50IDB4JXguXG4iLCBudGZzX2luby0+aV9udW1iZXIsICpwb3MsCgkJCWNvdW50KTsKCS8qIEFsbG93cyB0byBsb2NrIGZzIHJvIGF0IGFueSB0aW1lLiAqLwoJaWYgKHZmc19pbm8tPmlfc2ItPnNfZmxhZ3MgJiBNU19SRE9OTFkpCgkJcmV0dXJuIC1FUk9GUzsKCWRhdGEgPSBudGZzX2ZpbmRfYXR0cihudGZzX2lubywgbnRmc19pbm8tPnZvbC0+YXRfZGF0YSwgTlVMTCk7CglpZiAoIWRhdGEpCgkJcmV0dXJuIC1FSU5WQUw7CgkvKiBFdmFsdWF0aW5nIE9fQVBQRU5EIGlzIHRoZSBmaWxlIHN5c3RlbSdzIGpvYi4uLiAqLwoJaWYgKGZpbHAtPmZfZmxhZ3MgJiBPX0FQUEVORCkKCQkqcG9zID0gdmZzX2luby0+aV9zaXplOwoJaWYgKCFkYXRhLT5yZXNpZGVudCAmJiAqcG9zICsgY291bnQgPiBkYXRhLT5hbGxvY2F0ZWQpIHsKCQllcnIgPSBudGZzX2V4dGVuZF9hdHRyKG50ZnNfaW5vLCBkYXRhLCAqcG9zICsgY291bnQpOwoJCWlmIChlcnIgPCAwKQoJCQlyZXR1cm4gZXJyOwoJfQoJcGFyYW0udXNlciA9IGJ1ZjsKCXBhcmFtLmlubyA9IHZmc19pbm87CglwYXJhbS5vZmYgPSAqcG9zOwoJaW8uZm5fcHV0ID0gMDsKCWlvLmZuX2dldCA9IG50ZnNfZ2V0dXNlcl91cGRhdGVfdm07Cglpby5wYXJhbSA9ICZwYXJhbTsKCWlvLnNpemUgPSBjb3VudDsKCWlvLmRvX3JlYWQgPSAwOwoJZXJyID0gbnRmc19yZWFkd3JpdGVfYXR0cihudGZzX2lubywgZGF0YSwgKnBvcywgJmlvKTsKCW50ZnNfZGVidWcoREVCVUdfTElOVVgsIF9fRlVOQ1RJT05fXyAiKCk6IFJldHVybmluZyAlaVxuIiwgLWVycik7CglpZiAoIWVycikgewoJCSpwb3MgKz0gaW8uc2l6ZTsKCQlpZiAoKnBvcyA+IHZmc19pbm8tPmlfc2l6ZSkKCQkJdmZzX2luby0+aV9zaXplID0gKnBvczsKCQltYXJrX2lub2RlX2RpcnR5KHZmc19pbm8pOwoJCXJldHVybiBpby5zaXplOwoJfQoJcmV0dXJuIGVycjsKfQojZW5kaWYKCnN0cnVjdCBudGZzX2ZpbGxkaXIgewoJc3RydWN0IGlub2RlICpkaXI7CglmaWxsZGlyX3QgZmlsbGRpcjsKCXVuc2lnbmVkIGludCB0eXBlOwoJdTMyIHBoLCBwbDsKCXZvaWQgKmRpcmVudDsKCWNoYXIgKm5hbWU7CglpbnQgbmFtZWxlbjsKCWludCByZXRfY29kZTsKfTsKCnN0YXRpYyBpbnQgbnRmc19wcmludGNiKG50ZnNfdTggKmVudHJ5LCB2b2lkICpwYXJhbSkKewoJdW5zaWduZWQgbG9uZyBpbnVtID0gTlRGU19HRVRVNjQoZW50cnkpICYgMHhmZmZmZmZmZmZmZmY7CglzdHJ1Y3QgbnRmc19maWxsZGlyICpuZiA9IHBhcmFtOwoJdTMyIGZsYWdzID0gTlRGU19HRVRVMzIoZW50cnkgKyAweDQ4KTsKCWNoYXIgc2hvd19zeXNfZmlsZXMgPSAwOwoJdTggbmFtZV9sZW4gPSBOVEZTX0dFVFU4KGVudHJ5ICsgMHg1MCk7Cgl1OCBuYW1lX3R5cGUgPSBOVEZTX0dFVFU4KGVudHJ5ICsgMHg1MSk7CglpbnQgZXJyOwoJdW5zaWduZWQgZmlsZV90eXBlOwoKCXN3aXRjaCAobmYtPnR5cGUpIHsKCWNhc2Ugbmd0X2RvczoKCQkvKiBEb24ndCBkaXNwbGF5IGxvbmcgbmFtZXMuICovCgkJaWYgKCEobmFtZV90eXBlICYgMikpCgkJCXJldHVybiAwOwoJCWJyZWFrOwoJY2FzZSBuZ3RfbnQ6CgkJLyogRG9uJ3QgZGlzcGxheSBzaG9ydC1vbmx5IG5hbWVzLiAqLwoJCWlmICgobmFtZV90eXBlICYgMykgPT0gMikKCQkJcmV0dXJuIDA7CgkJYnJlYWs7CgljYXNlIG5ndF9wb3NpeDoKCQlicmVhazsKCWNhc2Ugbmd0X2Z1bGw6CgkJc2hvd19zeXNfZmlsZXMgPSAxOwoJCWJyZWFrOwoJZGVmYXVsdDoKCQlCVUcoKTsKCX0KCWVyciA9IG50ZnNfZW5jb2RldW5pKE5URlNfSU5PMlZPTChuZi0+ZGlyKSwgKG50ZnNfdTE2KikoZW50cnkgKyAweDUyKSwKCQkJbmFtZV9sZW4sICZuZi0+bmFtZSwgJm5mLT5uYW1lbGVuKTsKCWlmIChlcnIpIHsKCQludGZzX2RlYnVnKERFQlVHX09USEVSLCBfX0ZVTkNUSU9OX18gIigpOiBTa2lwcGluZyAiCgkJCQkidW5yZXByZXNlbnRhYmxlIGZpbGUuXG4iKTsKCQllcnIgPSAwOwoJCWdvdG8gZXJyX3JldDsKCX0KCWlmICghc2hvd19zeXNfZmlsZXMgJiYgaW51bSA8IDB4MTBVTCkgewoJCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsIF9fRlVOQ1RJT05fXyAiKCk6IFNraXBwaW5nIHN5c3RlbSAiCgkJCQkiZmlsZSAoJXMpLlxuIiwgbmYtPm5hbWUpOwoJCWVyciA9IDA7CgkJZ290byBlcnJfcmV0OwoJfQoJLyogRG8gbm90IHJldHVybiAiLiIsIGFzIHRoaXMgaXMgZmFrZWQuICovCglpZiAobmYtPm5hbWVsZW4gPT0gMSAmJiBuZi0+bmFtZVswXSA9PSAnLicpIHsKCQludGZzX2RlYnVnKERFQlVHX09USEVSLCBfX0ZVTkNUSU9OX18gIigpOiBTa2lwcGluZyBcIi5cIlxuIik7CgkJZXJyID0gMDsKCQlnb3RvIGVycl9yZXQ7Cgl9CgluZi0+bmFtZVtuZi0+bmFtZWxlbl0gPSAwOwoJaWYgKGZsYWdzICYgMHgxMDAwMDAwMCkgLyogRklMRV9BVFRSX0RVUF9GSUxFX05BTUVfSU5ERVhfUFJFU0VOVCAqLwoJCWZpbGVfdHlwZSA9IERUX0RJUjsKCWVsc2UKCQlmaWxlX3R5cGUgPSBEVF9SRUc7CgludGZzX2RlYnVnKERFQlVHX09USEVSLCBfX0ZVTkNUSU9OX18gIigpOiBDYWxsaW5nIGZpbGxkaXIgZm9yICVzIHdpdGggIgoJCQkibGVuICVpLCBmX3BvcyAweCVMeCwgaW5vZGUgJWx1LCAlcy5cbiIsCgkJCW5mLT5uYW1lLCBuZi0+bmFtZWxlbiwgKGxvZmZfdCkobmYtPnBoIDw8IDE2KSB8IG5mLT5wbCwKCQkJaW51bSwgZmlsZV90eXBlID09IERUX0RJUiA/ICJEVF9ESVIiIDogIkRUX1JFRyIpOwoJLyoKCSAqIFVzZXJzcGFjZSBzaWRlIG9mIGZpbGxkaXIgZXhwZWN0cyBhbiBvZmZfdCByYXRoZXIgdGhhbiBhbiBsb2ZmX3QuCgkgKiBBbmQgaXQgYWxzbyBkb2Vzbid0IGxpa2UgdGhlIG1vc3Qgc2lnbmlmaWNhbnQgYml0IGJlaW5nIHNldCBhcyBpdAoJICogdGhlbiBjb25zaWRlcnMgdGhlIHZhbHVlIHRvIGJlIG5lZ2F0aXZlLiBUaHVzIHRoaXMgaW1wbGVtZW50YXRpb24KCSAqIGxpbWl0cyB0aGUgbnVtYmVyIG9mIGluZGV4IHJlY29yZHMgdG8gMzI3NjYsIHdoaWNoIHNob3VsZCBiZSBwbGVudHkuCgkgKi8KCWVyciA9IG5mLT5maWxsZGlyKG5mLT5kaXJlbnQsIG5mLT5uYW1lLCBuZi0+bmFtZWxlbiwKCQkJKGxvZmZfdCkobmYtPnBoIDw8IDE2KSB8IG5mLT5wbCwgaW51bSwgZmlsZV90eXBlKTsKCWlmIChlcnIpCgkJbmYtPnJldF9jb2RlID0gZXJyOwplcnJfcmV0OgoJbmYtPm5hbWVsZW4gPSAwOwoJbnRmc19mcmVlKG5mLT5uYW1lKTsKCW5mLT5uYW1lID0gTlVMTDsKCXJldHVybiBlcnI7Cn0KCi8qCiAqIHJlYWRkaXIgcmV0dXJucyAnLicsIHRoZW4gJy4uJywgdGhlbiB0aGUgZGlyZWN0b3J5IGVudHJpZXMgaW4gc2VxdWVuY2UuCiAqIEFzIHRoZSByb290IGRpcmVjdG9yeSBjb250YWlucyBhbiBlbnRyeSBmb3IgaXRzZWxmLCAnLicgaXMgbm90IGVtdWxhdGVkIGZvcgogKiB0aGUgcm9vdCBkaXJlY3RvcnkuCiAqLwpzdGF0aWMgaW50IG50ZnNfcmVhZGRpcihzdHJ1Y3QgZmlsZSogZmlscCwgdm9pZCAqZGlyZW50LCBmaWxsZGlyX3QgZmlsbGRpcikKewoJc3RydWN0IGlub2RlICpkaXIgPSBmaWxwLT5mX2RlbnRyeS0+ZF9pbm9kZTsKCWludCBlcnI7CglzdHJ1Y3QgbnRmc19maWxsZGlyIGNiOwoKCWNiLnJldF9jb2RlID0gMDsKCWNiLnBsID0gZmlscC0+Zl9wb3MgJiAweGZmZmY7CgljYi5waCA9IChmaWxwLT5mX3BvcyA+PiAxNikgJiAweDdmZmY7CglmaWxwLT5mX3BvcyA9IChsb2ZmX3QpKGNiLnBoIDw8IDE2KSB8IGNiLnBsOwoJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgX19GVU5DVElPTl9fICIoKTogRW50ZXJpbmcgZm9yIGlub2RlICVsdSwgIgoJCQkiZl9wb3MgMHglTHgsIGlfbW9kZSAweCV4LCBpX2NvdW50ICVsdS5cbiIsIGRpci0+aV9pbm8sCgkJCWZpbHAtPmZfcG9zLCAodW5zaWduZWQgaW50KWRpci0+aV9tb2RlLAoJCQlhdG9taWNfcmVhZCgmZGlyLT5pX2NvdW50KSk7CglpZiAoIWNiLnBoKSB7CgkJLyogU3RhcnQgb2YgZGlyZWN0b3J5LiBFbXVsYXRlICIuIiBhbmQgIi4uIi4gKi8KCQlpZiAoIWNiLnBsKSB7CgkJCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsIF9fRlVOQ1RJT05fXyAiKCk6IENhbGxpbmcgIgoJCQkJICAgICJmaWxsZGlyIGZvciAuIHdpdGggbGVuIDEsIGZfcG9zIDB4JUx4LCAiCgkJCQkgICAgImlub2RlICVsdSwgRFRfRElSLlxuIiwgZmlscC0+Zl9wb3MsCgkJCQkgICAgZGlyLT5pX2lubyk7CgkJCWNiLnJldF9jb2RlID0gZmlsbGRpcihkaXJlbnQsICIuIiwgMSwgZmlscC0+Zl9wb3MsCgkJCQkgICAgZGlyLT5pX2lubywgRFRfRElSKTsKCQkJaWYgKGNiLnJldF9jb2RlKQoJCQkJZ290byBkb25lOwoJCQljYi5wbCsrOwoJCQlmaWxwLT5mX3BvcyA9IChsb2ZmX3QpKGNiLnBoIDw8IDE2KSB8IGNiLnBsOwoJCX0KCQlpZiAoY2IucGwgPT0gKHUzMikxKSB7CgkJCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsIF9fRlVOQ1RJT05fXyAiKCk6IENhbGxpbmcgIgoJCQkJICAgICJmaWxsZGlyIGZvciAuLiB3aXRoIGxlbiAyLCBmX3BvcyAweCVMeCwgIgoJCQkJICAgICJpbm9kZSAlbHUsIERUX0RJUi5cbiIsIGZpbHAtPmZfcG9zLAoJCQkJICAgIGZpbHAtPmZfZGVudHJ5LT5kX3BhcmVudC0+ZF9pbm9kZS0+aV9pbm8pOwoJCQljYi5yZXRfY29kZSA9IGZpbGxkaXIoZGlyZW50LCAiLi4iLCAyLCBmaWxwLT5mX3BvcywKCQkJCSAgICBmaWxwLT5mX2RlbnRyeS0+ZF9wYXJlbnQtPmRfaW5vZGUtPmlfaW5vLAoJCQkJICAgIERUX0RJUik7CgkJCWlmIChjYi5yZXRfY29kZSkKCQkJCWdvdG8gZG9uZTsKCQkJY2IucGwrKzsKCQkJZmlscC0+Zl9wb3MgPSAobG9mZl90KShjYi5waCA8PCAxNikgfCBjYi5wbDsKCQl9Cgl9IGVsc2UgaWYgKGNiLnBoID49IDB4N2ZmZikKCQkvKiBFbmQgb2YgZGlyZWN0b3J5LiAqLwoJCWdvdG8gZG9uZTsKCWNiLmRpciA9IGRpcjsKCWNiLmZpbGxkaXIgPSBmaWxsZGlyOwoJY2IuZGlyZW50ID0gZGlyZW50OwoJY2IudHlwZSA9IE5URlNfSU5PMlZPTChkaXIpLT5uZ3Q7CglkbyB7CgkJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgX19GVU5DVElPTl9fICIoKTogTG9va2luZyBmb3IgbmV4dCAiCgkJCQkiZmlsZSB1c2luZyBudGZzX2dldGRpcl91bnNvcnRlZCgpLCBmX3BvcyAiCgkJCQkiMHglTHguXG4iLCAobG9mZl90KShjYi5waCA8PCAxNikgfCBjYi5wbCk7CgkJZXJyID0gbnRmc19nZXRkaXJfdW5zb3J0ZWQoTlRGU19JKGRpciksICZjYi5waCwgJmNiLnBsLAoJCQkJbnRmc19wcmludGNiLCAmY2IpOwoJfSB3aGlsZSAoIWVyciAmJiAhY2IucmV0X2NvZGUgJiYgY2IucGggPCAweDdmZmYpOwoJZmlscC0+Zl9wb3MgPSAobG9mZl90KShjYi5waCA8PCAxNikgfCBjYi5wbDsKCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsIF9fRlVOQ1RJT05fXyAiKCk6IEFmdGVyIG50ZnNfZ2V0ZGlyX3Vuc29ydGVkKCkiCgkJCSIgY2FsbHMsIGZfcG9zIDB4JUx4LlxuIiwgZmlscC0+Zl9wb3MpOwoJaWYgKCFlcnIpIHsKZG9uZToKI2lmZGVmIERFQlVHCgkJaWYgKCFjYi5yZXRfY29kZSkKCQkJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgX19GVU5DVElPTl9fICIoKTogRU9ELCBmX3BvcyAiCgkJCQkJIjB4JUx4LCByZXR1cm5pbmcgMC5cbiIsIGZpbHAtPmZfcG9zKTsKCQllbHNlIAoJCQludGZzX2RlYnVnKERFQlVHX09USEVSLCBfX0ZVTkNUSU9OX18gIigpOiBmaWxsZGlyICIKCQkJCQkicmV0dXJuZWQgJWksIHJldHVybmluZyAwLCBmX3BvcyAiCgkJCQkJIjB4JUx4LlxuIiwgY2IucmV0X2NvZGUsIGZpbHAtPmZfcG9zKTsKI2VuZGlmCgkJcmV0dXJuIDA7Cgl9CgludGZzX2RlYnVnKERFQlVHX09USEVSLCBfX0ZVTkNUSU9OX18gIigpOiBSZXR1cm5pbmcgJWksIGZfcG9zIDB4JUx4LlxuIiwKCQkJZXJyLCBmaWxwLT5mX3Bvcyk7CglyZXR1cm4gZXJyOwp9CgovKiBDb3BpZWQgZnJvbSB2ZmF0IGRyaXZlci4gKi8Kc3RhdGljIGludCBzaW1wbGVfZ2V0Ym9vbChjaGFyICpzLCBpbnQgKnNldHZhbCkKewoJaWYgKHMpIHsKCQlpZiAoIXN0cmNtcChzLCAiMSIpIHx8ICFzdHJjbXAocywgInllcyIpIHx8ICFzdHJjbXAocywgInRydWUiKSkKCQkJKnNldHZhbCA9IDE7CgkJZWxzZSBpZiAoIXN0cmNtcChzLCAiMCIpIHx8ICFzdHJjbXAocywgIm5vIikgfHwKCQkJCQkJCSFzdHJjbXAocywgImZhbHNlIikpCgkJCSpzZXR2YWwgPSAwOwoJCWVsc2UKCQkJcmV0dXJuIDA7Cgl9IGVsc2UKCQkqc2V0dmFsID0gMTsKCXJldHVybiAxOwp9CgovKgogKiBUaGlzIG5lZWRzIHRvIGJlIG91dHNpZGUgcGFyc2Vfb3B0aW9ucygpIG90aGVyd2lzZSBhIHJlbW91bnQgd2lsbCByZXNldAogKiB0aGVzZSB1bmludGVudGlvbmFsbHkuCiAqLwpzdGF0aWMgdm9pZCBpbml0X250ZnNfc3VwZXJfYmxvY2sobnRmc192b2x1bWUqIHZvbCkKewoJdm9sLT51aWQgPSB2b2wtPmdpZCA9IDA7Cgl2b2wtPnVtYXNrID0gMDA3NzsKCXZvbC0+bmd0ID0gbmd0X250OwoJdm9sLT5ubHNfbWFwID0gKHZvaWQqKS0xOwoJdm9sLT5tZnRfem9uZV9tdWx0aXBsaWVyID0gLTE7Cn0KCi8qIFBhcnNlIHRoZSAocmUpbW91bnQgb3B0aW9ucy4gKi8Kc3RhdGljIGludCBwYXJzZV9vcHRpb25zKG50ZnNfdm9sdW1lICp2b2wsIGNoYXIgKm9wdCkKewoJY2hhciAqdmFsdWU7CQkvKiBEZWZhdWx0cyBpZiBub3Qgc3BlY2lmaWVkIGFuZCAhcmVtb3VudC4gKi8KCW50ZnNfdWlkX3QgdWlkID0gLTE7CS8qIDAsIHJvb3QgdXNlciBvbmx5ICovCgludGZzX2dpZF90IGdpZCA9IC0xOwkvKiAwLCByb290IHVzZXIgb25seSAqLwoJaW50IHVtYXNrID0gLTE7CQkvKiAwMDc3LCBvd25lciBhY2Nlc3Mgb25seSAqLwoJdW5zaWduZWQgaW50IG5ndCA9IC0xOwkvKiBuZ3RfbnQgKi8KCXZvaWQgKm5sc19tYXAgPSBOVUxMOwkvKiBUcnkgdG8gbG9hZCB0aGUgZGVmYXVsdCBOTFMuICovCglpbnQgdXNlX3V0ZjggPSAtMTsJLyogSWYgbm8gTkxTIHNwZWNpZmllZCBhbmQgbG9hZGluZyB0aGUgZGVmYXVsdAoJCQkJICAgTkxTIGZhaWxlZCB1c2UgdXRmOC4gKi8KCWludCBtZnRfem9uZV9tdWwgPSAtMTsJLyogMSAqLwoKCWlmICghb3B0KQoJCWdvdG8gZG9uZTsKCWZvciAob3B0ID0gc3RydG9rKG9wdCwgIiwiKTsgb3B0OyBvcHQgPSBzdHJ0b2soTlVMTCwgIiwiKSkgewoJCWlmICgodmFsdWUgPSBzdHJjaHIob3B0LCAnPScpKSAhPSBOVUxMKQoJCQkqdmFsdWUgKys9ICdcMCc7CgkJaWYgKHN0cmNtcChvcHQsICJ1aWQiKSA9PSAwKSB7CgkJCWlmICghdmFsdWUgfHwgISp2YWx1ZSkKCQkJCWdvdG8gbmVlZHNfYXJnOwoJCQl1aWQgPSBzaW1wbGVfc3RydG91bCh2YWx1ZSwgJnZhbHVlLCAwKTsKCQkJaWYgKCp2YWx1ZSkgewoJCQkJcHJpbnRrKEtFUk5fRVJSICJOVEZTOiB1aWQgaW52YWxpZCBhcmd1bWVudFxuIik7CgkJCQlyZXR1cm4gMDsKCQkJfQoJCX0gZWxzZSBpZiAoc3RyY21wKG9wdCwgImdpZCIpID09IDApIHsKCQkJaWYgKCF2YWx1ZSB8fCAhKnZhbHVlKQoJCQkJZ290byBuZWVkc19hcmc7CgkJCWdpZCA9IHNpbXBsZV9zdHJ0b3VsKHZhbHVlLCAmdmFsdWUsIDApOwoJCQlpZiAoKnZhbHVlKSB7CgkJCQlwcmludGsoS0VSTl9FUlIgIk5URlM6IGdpZCBpbnZhbGlkIGFyZ3VtZW50XG4iKTsKCQkJCXJldHVybiAwOwoJCQl9CgkJfSBlbHNlIGlmIChzdHJjbXAob3B0LCAidW1hc2siKSA9PSAwKSB7CgkJCWlmICghdmFsdWUgfHwgISp2YWx1ZSkKCQkJCWdvdG8gbmVlZHNfYXJnOwoJCQl1bWFzayA9IHNpbXBsZV9zdHJ0b3VsKHZhbHVlLCAmdmFsdWUsIDApOwoJCQlpZiAoKnZhbHVlKSB7CgkJCQlwcmludGsoS0VSTl9FUlIgIk5URlM6IHVtYXNrIGludmFsaWQgIgoJCQkJCQkiYXJndW1lbnRcbiIpOwoJCQkJcmV0dXJuIDA7CgkJCX0KCQl9IGVsc2UgaWYgKHN0cmNtcChvcHQsICJtZnRfem9uZV9tdWx0aXBsaWVyIikgPT0gMCkgewoJCQl1bnNpZ25lZCBsb25nIHVsOwoKCQkJaWYgKCF2YWx1ZSB8fCAhKnZhbHVlKQoJCQkJZ290byBuZWVkc19hcmc7CgkJCXVsID0gc2ltcGxlX3N0cnRvdWwodmFsdWUsICZ2YWx1ZSwgMCk7CgkJCWlmICgqdmFsdWUpIHsKCQkJCXByaW50ayhLRVJOX0VSUiAiTlRGUzogbWZ0X3pvbmVfbXVsdGlwbGllciAiCgkJCQkJCSJpbnZhbGlkIGFyZ3VtZW50XG4iKTsKCQkJCXJldHVybiAwOwoJCQl9CgkJCWlmICh1bCA+PSAxICYmIHVsIDw9IDQpCgkJCQltZnRfem9uZV9tdWwgPSB1bDsKCQkJZWxzZSB7CgkJCQltZnRfem9uZV9tdWwgPSAxOwoJCQkJcHJpbnRrKEtFUk5fV0FSTklORyAiTlRGUzogbWZ0X3pvbmVfbXVsdGlwbGllciAiCgkJCQkJICAgICAgIm91dCBvZiByYW5nZS4gU2V0dGluZyB0byAxLlxuIik7CgkJCX0KCQl9IGVsc2UgaWYgKHN0cmNtcChvcHQsICJwb3NpeCIpID09IDApIHsKCQkJaW50IHZhbDsKCQkJaWYgKCF2YWx1ZSB8fCAhKnZhbHVlKQoJCQkJZ290byBuZWVkc19hcmc7CgkJCWlmICghc2ltcGxlX2dldGJvb2wodmFsdWUsICZ2YWwpKQoJCQkJZ290byBuZWVkc19ib29sOwoJCQluZ3QgPSB2YWwgPyBuZ3RfcG9zaXggOiBuZ3RfbnQ7CgkJfSBlbHNlIGlmIChzdHJjbXAob3B0LCAic2hvd19zeXNfZmlsZXMiKSA9PSAwKSB7CgkJCWludCB2YWwgPSAwOwoJCQlpZiAoIXZhbHVlIHx8ICEqdmFsdWUpCgkJCQl2YWwgPSAxOwoJCQllbHNlIGlmICghc2ltcGxlX2dldGJvb2wodmFsdWUsICZ2YWwpKQoJCQkJZ290byBuZWVkc19ib29sOwoJCQluZ3QgPSB2YWwgPyBuZ3RfZnVsbCA6IG5ndF9udDsKCQl9IGVsc2UgaWYgKHN0cmNtcChvcHQsICJpb2NoYXJzZXQiKSA9PSAwKSB7CgkJCWlmICghdmFsdWUgfHwgISp2YWx1ZSkKCQkJCWdvdG8gbmVlZHNfYXJnOwoJCQlubHNfbWFwID0gbG9hZF9ubHModmFsdWUpOwoJCQlpZiAoIW5sc19tYXApIHsKCQkJCXByaW50ayhLRVJOX0VSUiAiTlRGUzogY2hhcnNldCBub3QgZm91bmQiKTsKCQkJCXJldHVybiAwOwoJCQl9CgkJfSBlbHNlIGlmIChzdHJjbXAob3B0LCAidXRmOCIpID09IDApIHsKCQkJaW50IHZhbCA9IDA7CgkJCWlmICghdmFsdWUgfHwgISp2YWx1ZSkKCQkJCXZhbCA9IDE7CgkJCWVsc2UgaWYgKCFzaW1wbGVfZ2V0Ym9vbCh2YWx1ZSwgJnZhbCkpCgkJCQlnb3RvIG5lZWRzX2Jvb2w7CgkJCXVzZV91dGY4ID0gdmFsOwoJCX0gZWxzZSB7CgkJCXByaW50ayhLRVJOX0VSUiAiTlRGUzogdW5rb3duIG9wdGlvbiAnJXMnXG4iLCBvcHQpOwoJCQlyZXR1cm4gMDsKCQl9Cgl9CmRvbmU6CglpZiAodXNlX3V0ZjggPT0gLTEpIHsKCQkvKiB1dGY4IHdhcyBub3Qgc3BlY2lmaWVkIGF0IGFsbC4gKi8KCQlpZiAoIW5sc19tYXApIHsKCQkJLyoKCQkJICogTm8gTkxTIHdhcyBzcGVjaWZpZWQuIElmIGZpcnN0IG1vdW50LCBsb2FkIHRoZQoJCQkgKiBkZWZhdWx0IE5MUywgb3RoZXJ3aXNlIGRvbid0IGNoYW5nZSB0aGUgTkxTIHNldHRpbmcuCgkJCSAqLwoJCQlpZiAodm9sLT5ubHNfbWFwID09ICh2b2lkKiktMSkKCQkJCXZvbC0+bmxzX21hcCA9IGxvYWRfbmxzX2RlZmF1bHQoKTsKCQl9IGVsc2UgewoJCQkvKiBJZiBhbiBOTFMgd2FzIGFscmVhZHkgbG9hZGVkLCB1bmxvYWQgaXQgZmlyc3QuICovCgkJCWlmICh2b2wtPm5sc19tYXAgJiYgdm9sLT5ubHNfbWFwICE9ICh2b2lkKiktMSkKCQkJCXVubG9hZF9ubHModm9sLT5ubHNfbWFwKTsKCQkJLyogVXNlIHRoZSBzcGVjaWZpZWQgTkxTLiAqLwoJCQl2b2wtPm5sc19tYXAgPSBubHNfbWFwOwoJCX0KCX0gZWxzZSB7CgkJLyogdXRmOCB3YXMgc3BlY2lmaWVkLiAqLwoJCWlmICh1c2VfdXRmOCAmJiBubHNfbWFwKSB7CgkJCXVubG9hZF9ubHMobmxzX21hcCk7CgkJCXByaW50ayhLRVJOX0VSUiAiTlRGUzogdXRmOCBjYW5ub3QgYmUgY29tYmluZWQgd2l0aCAiCgkJCQkJImlvY2hhcnNldC5cbiIpOwoJCQlyZXR1cm4gMDsKCQl9CgkJLyogSWYgYW4gTkxTIHdhcyBhbHJlYWR5IGxvYWRlZCwgdW5sb2FkIGl0IGZpcnN0LiAqLwoJCWlmICh2b2wtPm5sc19tYXAgJiYgdm9sLT5ubHNfbWFwICE9ICh2b2lkKiktMSkKCQkJdW5sb2FkX25scyh2b2wtPm5sc19tYXApOwoJCWlmICghdXNlX3V0ZjgpIHsKCQkJLyogdXRmOCB3YXMgc3BlY2lmaWVkIGFzIGZhbHNlLiAqLwoJCQlpZiAoIW5sc19tYXApCgkJCQkvKiBObyBOTFMgd2FzIHNwZWNpZmllZCwgbG9hZCB0aGUgZGVmYXVsdC4gKi8KCQkJCXZvbC0+bmxzX21hcCA9IGxvYWRfbmxzX2RlZmF1bHQoKTsKCQkJZWxzZQoJCQkJLyogVXNlIHRoZSBzcGVjaWZpZWQgTkxTLiAqLwoJCQkJdm9sLT5ubHNfbWFwID0gbmxzX21hcDsKCQl9IGVsc2UKCQkJLyogdXRmOCB3YXMgc3BlY2lmaWVkIGFzIHRydWUuICovCgkJCXZvbC0+bmxzX21hcCA9IE5VTEw7Cgl9CglpZiAodWlkICE9IC0xKQoJCXZvbC0+dWlkID0gdWlkOwoJaWYgKGdpZCAhPSAtMSkKCQl2b2wtPmdpZCA9IGdpZDsKCWlmICh1bWFzayAhPSAtMSkKCQl2b2wtPnVtYXNrID0gKG50bW9kZV90KXVtYXNrOwoJaWYgKG5ndCAhPSAtMSkKCQl2b2wtPm5ndCA9IG5ndDsKCWlmIChtZnRfem9uZV9tdWwgIT0gLTEpIHsKCQkvKiBtZnRfem9uZV9tdWx0aXBsaWVyIHdhcyBzcGVjaWZpZWQuICovCgkJaWYgKHZvbC0+bWZ0X3pvbmVfbXVsdGlwbGllciAhPSAtMSkgewoJCQkvKiBUaGlzIGlzIGEgcmVtb3VudCwgaWdub3JlIGEgY2hhbmdlIGFuZCB3YXJuIHVzZXIuICovCgkJCWlmICh2b2wtPm1mdF96b25lX211bHRpcGxpZXIgIT0gbWZ0X3pvbmVfbXVsKQoJCQkJcHJpbnRrKEtFUk5fV0FSTklORyAiTlRGUzogSWdub3JpbmcgY2hhbmdlcyBpbiAiCgkJCQkJCSJtZnRfem9uZV9tdWx0aXBsaWVyIG9uICIKCQkJCQkJInJlbW91bnQuIElmIHlvdSB3YW50IHRvICIKCQkJCQkJImNoYW5nZSB0aGlzIHlvdSBuZWVkIHRvICIKCQkJCQkJInVtb3VudCBhbmQgbW91bnQgYWdhaW4uXG4iKTsKCQl9IGVsc2UKCQkJLyogVXNlIHRoZSBzcGVjaWZpZWQgbXVsdGlwbGllci4gKi8KCQkJdm9sLT5tZnRfem9uZV9tdWx0aXBsaWVyID0gbWZ0X3pvbmVfbXVsOwoJfSBlbHNlIGlmICh2b2wtPm1mdF96b25lX211bHRpcGxpZXIgPT0gLTEpCgkJLyogTm8gbXVsdGlwbGllciBzcGVjaWZpZWQgYW5kIGZpcnN0IG1vdW50LCBzbyBzZXQgZGVmYXVsdC4gKi8KCQl2b2wtPm1mdF96b25lX211bHRpcGxpZXIgPSAxOwoJcmV0dXJuIDE7Cm5lZWRzX2FyZzoKCXByaW50ayhLRVJOX0VSUiAiTlRGUzogJXMgbmVlZHMgYW4gYXJndW1lbnQiLCBvcHQpOwoJcmV0dXJuIDA7Cm5lZWRzX2Jvb2w6CglwcmludGsoS0VSTl9FUlIgIk5URlM6ICVzIG5lZWRzIGJvb2xlYW4gYXJndW1lbnQiLCBvcHQpOwoJcmV0dXJuIDA7Cn0KCQkJCnN0YXRpYyBzdHJ1Y3QgZGVudHJ5ICpudGZzX2xvb2t1cChzdHJ1Y3QgaW5vZGUgKmRpciwgc3RydWN0IGRlbnRyeSAqZCkKewoJc3RydWN0IGlub2RlICpyZXMgPSAwOwoJY2hhciAqaXRlbSA9IDA7CgludGZzX2l0ZXJhdGVfcyB3YWxrOwoJaW50IGVycjsKCQoJbnRmc19kZWJ1ZyhERUJVR19OQU1FMSwgX19GVU5DVElPTl9fICIoKTogTG9va2luZyB1cCAlcyBpbiBkaXJlY3RvcnkgIgoJCQkiaW5vIDB4JXguXG4iLCBkLT5kX25hbWUubmFtZSwgKHVuc2lnbmVkKWRpci0+aV9pbm8pOwoJd2Fsay5uYW1lID0gTlVMTDsKCXdhbGsubmFtZWxlbiA9IDA7CgkvKiBDb252ZXJ0IHRvIHdpZGUgc3RyaW5nLiAqLwoJZXJyID0gbnRmc19kZWNvZGV1bmkoTlRGU19JTk8yVk9MKGRpciksIChjaGFyKilkLT5kX25hbWUubmFtZSwKCQkJICAgICAgIGQtPmRfbmFtZS5sZW4sICZ3YWxrLm5hbWUsICZ3YWxrLm5hbWVsZW4pOwoJaWYgKGVycikKCQlnb3RvIGVycl9yZXQ7CglpdGVtID0gbnRmc19tYWxsb2MoSVRFTV9TSVpFKTsKCWlmICghaXRlbSkgewoJCWVyciA9IC1FTk9NRU07CgkJZ290byBlcnJfcmV0OwoJfQoJLyogbnRmc19nZXRkaXIgd2lsbCBwbGFjZSB0aGUgZGlyZWN0b3J5IGVudHJ5IGludG8gaXRlbSwgYW5kIHRoZSBmaXJzdAoJICogbG9uZyBsb25nIGlzIHRoZSBNRlQgcmVjb3JkIG51bWJlci4gKi8KCXdhbGsudHlwZSA9IEJZX05BTUU7Cgl3YWxrLmRpciA9IE5URlNfSShkaXIpOwoJd2Fsay5yZXN1bHQgPSBpdGVtOwoJaWYgKG50ZnNfZ2V0ZGlyX2J5bmFtZSgmd2FsaykpCgkJcmVzID0gaWdldChkaXItPmlfc2IsIE5URlNfR0VUVTMyKGl0ZW0pKTsKCWRfYWRkKGQsIHJlcyk7CgludGZzX2ZyZWUoaXRlbSk7CgludGZzX2ZyZWUod2Fsay5uYW1lKTsKCS8qIEFsd2F5cyByZXR1cm4gc3VjY2VzcywgdGhlIGRjYWNoZSB3aWxsIGhhbmRsZSBuZWdhdGl2ZSBlbnRyaWVzLiAqLwoJcmV0dXJuIE5VTEw7CmVycl9yZXQ6CgludGZzX2ZyZWUod2Fsay5uYW1lKTsKCXJldHVybiBFUlJfUFRSKGVycik7Cn0KCnN0YXRpYyBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIG50ZnNfZmlsZV9vcGVyYXRpb25zID0gewoJbGxzZWVrOgkJZ2VuZXJpY19maWxlX2xsc2VlaywKCXJlYWQ6CQludGZzX3JlYWQsCiNpZmRlZiBDT05GSUdfTlRGU19SVwoJd3JpdGU6CQludGZzX3dyaXRlLAojZW5kaWYKCW9wZW46CQlnZW5lcmljX2ZpbGVfb3BlbiwKfTsKCnN0YXRpYyBzdHJ1Y3QgaW5vZGVfb3BlcmF0aW9ucyBudGZzX2lub2RlX29wZXJhdGlvbnM7CgojaWZkZWYgQ09ORklHX05URlNfUlcKc3RhdGljIGludCBudGZzX2NyZWF0ZShzdHJ1Y3QgaW5vZGUqIGRpciwgc3RydWN0IGRlbnRyeSAqZCwgaW50IG1vZGUpCnsKCXN0cnVjdCBpbm9kZSAqciA9IDA7CgludGZzX2lub2RlICppbm8gPSAwOwoJbnRmc192b2x1bWUgKnZvbDsKCWludCBlcnJvciA9IDA7CgludGZzX2F0dHJpYnV0ZSAqc2k7CgoJciA9IG5ld19pbm9kZShkaXItPmlfc2IpOwoJaWYgKCFyKSB7CgkJZXJyb3IgPSAtRU5PTUVNOwoJCWdvdG8gZmFpbDsKCX0KCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsICJudGZzX2NyZWF0ZSAlc1xuIiwgZC0+ZF9uYW1lLm5hbWUpOwoJdm9sID0gTlRGU19JTk8yVk9MKGRpcik7Cglpbm8gPSBOVEZTX0kocik7Cglpbm8tPnUuaW5kZXgucmVjb3Jkc2l6ZSA9IDA7Cglpbm8tPnUuaW5kZXguY2x1c3RlcnNfcGVyX3JlY29yZCA9IDA7CgllcnJvciA9IG50ZnNfYWxsb2NfZmlsZShOVEZTX0koZGlyKSwgaW5vLCAoY2hhciopZC0+ZF9uYW1lLm5hbWUsCgkJCQlkLT5kX25hbWUubGVuKTsKCWlmIChlcnJvcikgewoJCW50ZnNfZXJyb3IoIm50ZnNfYWxsb2NfZmlsZSBGQUlMRUQ6IGVycm9yID0gJWkiLCBlcnJvcik7CgkJZ290byBmYWlsOwoJfQoJLyogTm90IGRvaW5nIHRoaXMgb25lIHdhcyBjYXVzaW5nIGEgaHVnZSBhbW91bnQgb2YgY29ycnVwdGlvbiEgTm93IHRoZQoJICogYnVnZ2VyIGJ5dGVzIHRoZSBkdXN0ISAoLTggKEFJQSkgKi8KCXItPmlfaW5vID0gaW5vLT5pX251bWJlcjsKCWVycm9yID0gbnRmc191cGRhdGVfaW5vZGUoaW5vKTsKCWlmIChlcnJvcikKCQlnb3RvIGZhaWw7CgllcnJvciA9IG50ZnNfdXBkYXRlX2lub2RlKE5URlNfSShkaXIpKTsKCWlmIChlcnJvcikKCQlnb3RvIGZhaWw7CglyLT5pX3VpZCA9IHZvbC0+dWlkOwoJci0+aV9naWQgPSB2b2wtPmdpZDsKCS8qIEZJWE1FOiBkaXJ0eT8gZGV2PyAqLwoJLyogR2V0IHRoZSBmaWxlIG1vZGlmaWNhdGlvbiB0aW1lcyBmcm9tIHRoZSBzdGFuZGFyZCBpbmZvcm1hdGlvbi4gKi8KCXNpID0gbnRmc19maW5kX2F0dHIoaW5vLCB2b2wtPmF0X3N0YW5kYXJkX2luZm9ybWF0aW9uLCBOVUxMKTsKCWlmIChzaSkgewoJCWNoYXIgKmF0dHIgPSBzaS0+ZC5kYXRhOwoJCXItPmlfYXRpbWUgPSBudGZzX250dXRjMnVuaXh1dGMoTlRGU19HRVRVNjQoYXR0ciArIDB4MTgpKTsKCQlyLT5pX2N0aW1lID0gbnRmc19udHV0YzJ1bml4dXRjKE5URlNfR0VUVTY0KGF0dHIpKTsKCQlyLT5pX210aW1lID0gbnRmc19udHV0YzJ1bml4dXRjKE5URlNfR0VUVTY0KGF0dHIgKyA4KSk7Cgl9CgkvKiBJdCdzIG5vdCBhIGRpcmVjdG9yeSAqLwoJci0+aV9vcCA9ICZudGZzX2lub2RlX29wZXJhdGlvbnM7CglyLT5pX2ZvcCA9ICZudGZzX2ZpbGVfb3BlcmF0aW9uczsKCXItPmlfbW9kZSA9IFNfSUZSRUcgfCBTX0lSVUdPOwojaWZkZWYgQ09ORklHX05URlNfUlcKCXItPmlfbW9kZSB8PSBTX0lXVUdPOwojZW5kaWYKCXItPmlfbW9kZSAmPSB+dm9sLT51bWFzazsKCWluc2VydF9pbm9kZV9oYXNoKHIpOwoJZF9pbnN0YW50aWF0ZShkLCByKTsKCXJldHVybiAwOwogZmFpbDoKCWlmIChyKQoJCWlwdXQocik7CglyZXR1cm4gZXJyb3I7Cn0KCnN0YXRpYyBpbnQgX2xpbnV4X250ZnNfbWtkaXIoc3RydWN0IGlub2RlICpkaXIsIHN0cnVjdCBkZW50cnkqIGQsIGludCBtb2RlKQp7CglpbnQgZXJyb3I7CglzdHJ1Y3QgaW5vZGUgKnIgPSAwOwoJbnRmc192b2x1bWUgKnZvbDsKCW50ZnNfaW5vZGUgKmlubzsKCW50ZnNfYXR0cmlidXRlICpzaTsKCgludGZzX2RlYnVnIChERUJVR19ESVIxLCAibWtkaXIgJXMgaW4gJXhcbiIsIGQtPmRfbmFtZS5uYW1lLCBkaXItPmlfaW5vKTsKCWVycm9yID0gLUVOQU1FVE9PTE9ORzsKCWlmIChkLT5kX25hbWUubGVuID4gLyogRklYTUU6ICovIDI1NSkKCQlnb3RvIG91dDsKCWVycm9yID0gLUVJTzsKCXIgPSBuZXdfaW5vZGUoZGlyLT5pX3NiKTsKCWlmICghcikKCQlnb3RvIG91dDsKCXZvbCA9IE5URlNfSU5PMlZPTChkaXIpOwoJaW5vID0gTlRGU19JKHIpOwoJZXJyb3IgPSBudGZzX21rZGlyKE5URlNfSShkaXIpLCBkLT5kX25hbWUubmFtZSwgZC0+ZF9uYW1lLmxlbiwKCQkJICAgaW5vKTsKCWlmIChlcnJvcikKCQlnb3RvIG91dDsKCS8qIE5vdCBkb2luZyB0aGlzIG9uZSB3YXMgY2F1c2luZyBhIGh1Z2UgYW1vdW50IG9mIGNvcnJ1cHRpb24hIE5vdyB0aGUKCSAqIGJ1Z2dlciBieXRlcyB0aGUgZHVzdCEgKC04IChBSUEpICovCglyLT5pX2lubyA9IGluby0+aV9udW1iZXI7CglyLT5pX3VpZCA9IHZvbC0+dWlkOwoJci0+aV9naWQgPSB2b2wtPmdpZDsKCXNpID0gbnRmc19maW5kX2F0dHIoaW5vLCB2b2wtPmF0X3N0YW5kYXJkX2luZm9ybWF0aW9uLCBOVUxMKTsKCWlmIChzaSkgewoJCWNoYXIgKmF0dHIgPSBzaS0+ZC5kYXRhOwoJCXItPmlfYXRpbWUgPSBudGZzX250dXRjMnVuaXh1dGMoTlRGU19HRVRVNjQoYXR0ciArIDB4MTgpKTsKCQlyLT5pX2N0aW1lID0gbnRmc19udHV0YzJ1bml4dXRjKE5URlNfR0VUVTY0KGF0dHIpKTsKCQlyLT5pX210aW1lID0gbnRmc19udHV0YzJ1bml4dXRjKE5URlNfR0VUVTY0KGF0dHIgKyA4KSk7Cgl9CgkvKiBJdCdzIGEgZGlyZWN0b3J5LiAqLwoJci0+aV9vcCA9ICZudGZzX2Rpcl9pbm9kZV9vcGVyYXRpb25zOwoJci0+aV9mb3AgPSAmbnRmc19kaXJfb3BlcmF0aW9uczsKCXItPmlfbW9kZSA9IFNfSUZESVIgfCBTX0lSVUdPIHwgU19JWFVHTzsKI2lmZGVmIENPTkZJR19OVEZTX1JXCglyLT5pX21vZGUgfD0gU19JV1VHTzsKI2VuZGlmCglyLT5pX21vZGUgJj0gfnZvbC0+dW1hc2s7CQoJCglpbnNlcnRfaW5vZGVfaGFzaChyKTsKCWRfaW5zdGFudGlhdGUoZCwgcik7CgllcnJvciA9IDA7CiBvdXQ6CiAJbnRmc19kZWJ1ZyAoREVCVUdfRElSMSwgIm1rZGlyIHJldHVybnMgJWRcbiIsIGVycm9yKTsKCXJldHVybiBlcnJvcjsKfQojZW5kaWYKCnN0YXRpYyBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIG50ZnNfZGlyX29wZXJhdGlvbnMgPSB7CglyZWFkOgkJZ2VuZXJpY19yZWFkX2RpciwKCXJlYWRkaXI6CW50ZnNfcmVhZGRpciwKfTsKCnN0YXRpYyBzdHJ1Y3QgaW5vZGVfb3BlcmF0aW9ucyBudGZzX2Rpcl9pbm9kZV9vcGVyYXRpb25zID0gewoJbG9va3VwOgkJbnRmc19sb29rdXAsCiNpZmRlZiBDT05GSUdfTlRGU19SVwoJY3JlYXRlOgkJbnRmc19jcmVhdGUsCglta2RpcjoJCV9saW51eF9udGZzX21rZGlyLAojZW5kaWYKfTsKCi8qIG50ZnNfcmVhZF9pbm9kZSgpIGlzIGNhbGxlZCBieSB0aGUgVmlydHVhbCBGaWxlIFN5c3RlbSAodGhlIGtlcm5lbCBsYXllciAKICogdGhhdCBkZWFscyB3aXRoIGZpbGVzeXN0ZW1zKSB3aGVuIGlnZXQgaXMgY2FsbGVkIHJlcXVlc3RpbmcgYW4gaW5vZGUgbm90CiAqIGFscmVhZHkgcHJlc2VudCBpbiB0aGUgaW5vZGUgdGFibGUuIFR5cGljYWxseSBmaWxlc3lzdGVtcyBoYXZlIHNlcGFyYXRlCiAqIGlub2RlX29wZXJhdGlvbnMgZm9yIGRpcmVjdG9yaWVzLCBmaWxlcyBhbmQgc3ltbGlua3MuICovCnN0YXRpYyB2b2lkIG50ZnNfcmVhZF9pbm9kZShzdHJ1Y3QgaW5vZGUqIGlub2RlKQp7CgludGZzX3ZvbHVtZSAqdm9sOwoJbnRmc19pbm9kZSAqaW5vOwoJbnRmc19hdHRyaWJ1dGUgKmRhdGE7CgludGZzX2F0dHJpYnV0ZSAqc2k7CgoJdm9sID0gTlRGU19JTk8yVk9MKGlub2RlKTsKCWlub2RlLT5pX21vZGUgPSAwOwoJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgIm50ZnNfcmVhZF9pbm9kZSAweCVseFxuIiwgaW5vZGUtPmlfaW5vKTsKCXN3aXRjaCAoaW5vZGUtPmlfaW5vKSB7CgkJLyogVGhvc2UgYXJlIGxvYWRlZCBzcGVjaWFsIGZpbGVzLiAqLwoJY2FzZSBGSUxFX01mdDoKCQlpZiAoIXZvbC0+bWZ0X2lubyB8fCAoKHZvbC0+aW5vX2ZsYWdzICYgMSkgPT0gMCkpCgkJCWdvdG8gc3lzX2ZpbGVfZXJyb3I7CgkJbnRmc19tZW1jcHkoTlRGU19JKGlub2RlKSwgdm9sLT5tZnRfaW5vLCBzaXplb2YobnRmc19pbm9kZSkpOwoJCWlubyA9IHZvbC0+bWZ0X2lubzsKCQl2b2wtPm1mdF9pbm8gPSBOVEZTX0koaW5vZGUpOwoJCXZvbC0+aW5vX2ZsYWdzICY9IH4xOwoJCW50ZnNfZnJlZShpbm8pOwoJCWlubyA9IHZvbC0+bWZ0X2lubzsKCQludGZzX2RlYnVnKERFQlVHX09USEVSLCAiT3BlbmluZyAkTUZUIVxuIik7CgkJYnJlYWs7CgljYXNlIEZJTEVfTWZ0TWlycjoKCQlpZiAoIXZvbC0+bWZ0bWlyciB8fCAoKHZvbC0+aW5vX2ZsYWdzICYgMikgPT0gMCkpCgkJCWdvdG8gc3lzX2ZpbGVfZXJyb3I7CgkJbnRmc19tZW1jcHkoTlRGU19JKGlub2RlKSwgdm9sLT5tZnRtaXJyLCBzaXplb2YobnRmc19pbm9kZSkpOwoJCWlubyA9IHZvbC0+bWZ0bWlycjsKCQl2b2wtPm1mdG1pcnIgPSBOVEZTX0koaW5vZGUpOwoJCXZvbC0+aW5vX2ZsYWdzICY9IH4yOwoJCW50ZnNfZnJlZShpbm8pOwoJCWlubyA9IHZvbC0+bWZ0bWlycjsKCQludGZzX2RlYnVnKERFQlVHX09USEVSLCAiT3BlbmluZyAkTUZUTWlyciFcbiIpOwoJCWJyZWFrOwoJY2FzZSBGSUxFX0JpdE1hcDoKCQlpZiAoIXZvbC0+Yml0bWFwIHx8ICgodm9sLT5pbm9fZmxhZ3MgJiA0KSA9PSAwKSkKCQkJZ290byBzeXNfZmlsZV9lcnJvcjsKCQludGZzX21lbWNweShOVEZTX0koaW5vZGUpLCB2b2wtPmJpdG1hcCwgc2l6ZW9mKG50ZnNfaW5vZGUpKTsKCQlpbm8gPSB2b2wtPmJpdG1hcDsKCQl2b2wtPmJpdG1hcCA9IE5URlNfSShpbm9kZSk7CgkJdm9sLT5pbm9fZmxhZ3MgJj0gfjQ7CgkJbnRmc19mcmVlKGlubyk7CgkJaW5vID0gdm9sLT5iaXRtYXA7CgkJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgIk9wZW5pbmcgJEJpdG1hcCFcbiIpOwoJCWJyZWFrOwoJY2FzZSBGSUxFX0xvZ0ZpbGUgLi4uIEZJTEVfQXR0ckRlZjoKCS8qIE5vIG5lZWQgdG8gbG9nIHJvb3QgZGlyZWN0b3J5IGFjY2Vzc2VzLiAqLwoJY2FzZSBGSUxFX0Jvb3QgLi4uIEZJTEVfVXBDYXNlOgoJCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsICJPcGVuaW5nIHN5c3RlbSBmaWxlICVpIVxuIiwKCQkJCWlub2RlLT5pX2lubyk7CglkZWZhdWx0OgoJCWlubyA9IE5URlNfSShpbm9kZSk7CgkJaW5vLT51LmluZGV4LnJlY29yZHNpemUgPSAwOwoJCWluby0+dS5pbmRleC5jbHVzdGVyc19wZXJfcmVjb3JkID0gMDsKCQlpZiAobnRmc19pbml0X2lub2RlKGlubywgTlRGU19JTk8yVk9MKGlub2RlKSwgaW5vZGUtPmlfaW5vKSkgewoJCQludGZzX2RlYnVnKERFQlVHX09USEVSLCAiTlRGUzogRXJyb3IgbG9hZGluZyBpbm9kZSAiCgkJCQkJIjB4JXhcbiIsICh1bnNpZ25lZCBpbnQpaW5vZGUtPmlfaW5vKTsKCQkJcmV0dXJuOwoJCX0KCX0KCS8qIFNldCB1aWQvZ2lkIGZyb20gbW91bnQgb3B0aW9ucyAqLwoJaW5vZGUtPmlfdWlkID0gdm9sLT51aWQ7Cglpbm9kZS0+aV9naWQgPSB2b2wtPmdpZDsKCWlub2RlLT5pX25saW5rID0gMTsKCS8qIFVzZSB0aGUgc2l6ZSBvZiB0aGUgZGF0YSBhdHRyaWJ1dGUgYXMgZmlsZSBzaXplICovCglkYXRhID0gbnRmc19maW5kX2F0dHIoaW5vLCB2b2wtPmF0X2RhdGEsIE5VTEwpOwoJaWYgKCFkYXRhKQoJCWlub2RlLT5pX3NpemUgPSAwOwoJZWxzZQoJCWlub2RlLT5pX3NpemUgPSBkYXRhLT5zaXplOwoJLyogR2V0IHRoZSBmaWxlIG1vZGlmaWNhdGlvbiB0aW1lcyBmcm9tIHRoZSBzdGFuZGFyZCBpbmZvcm1hdGlvbi4gKi8KCXNpID0gbnRmc19maW5kX2F0dHIoaW5vLCB2b2wtPmF0X3N0YW5kYXJkX2luZm9ybWF0aW9uLCBOVUxMKTsKCWlmIChzaSkgewoJCWNoYXIgKmF0dHIgPSBzaS0+ZC5kYXRhOwoJCWlub2RlLT5pX2F0aW1lID0gbnRmc19udHV0YzJ1bml4dXRjKE5URlNfR0VUVTY0KGF0dHIgKyAweDE4KSk7CgkJaW5vZGUtPmlfY3RpbWUgPSBudGZzX250dXRjMnVuaXh1dGMoTlRGU19HRVRVNjQoYXR0cikpOwoJCWlub2RlLT5pX210aW1lID0gbnRmc19udHV0YzJ1bml4dXRjKE5URlNfR0VUVTY0KGF0dHIgKyA4KSk7Cgl9CgkvKiBJZiBpdCBoYXMgYW4gaW5kZXggcm9vdCwgaXQncyBhIGRpcmVjdG9yeS4gKi8KCWlmIChudGZzX2ZpbmRfYXR0cihpbm8sIHZvbC0+YXRfaW5kZXhfcm9vdCwgIiRJMzAiKSkgewoJCW50ZnNfYXR0cmlidXRlICphdDsKCQlhdCA9IG50ZnNfZmluZF9hdHRyKGlubywgdm9sLT5hdF9pbmRleF9hbGxvY2F0aW9uLCAiJEkzMCIpOwoJCWlub2RlLT5pX3NpemUgPSBhdCA/IGF0LT5zaXplIDogMDsKCQlpbm9kZS0+aV9vcCA9ICZudGZzX2Rpcl9pbm9kZV9vcGVyYXRpb25zOwoJCWlub2RlLT5pX2ZvcCA9ICZudGZzX2Rpcl9vcGVyYXRpb25zOwoJCWlub2RlLT5pX21vZGUgPSBTX0lGRElSIHwgU19JUlVHTyB8IFNfSVhVR087Cgl9IGVsc2UgewoJCWlub2RlLT5pX29wID0gJm50ZnNfaW5vZGVfb3BlcmF0aW9uczsKCQlpbm9kZS0+aV9mb3AgPSAmbnRmc19maWxlX29wZXJhdGlvbnM7CgkJaW5vZGUtPmlfbW9kZSA9IFNfSUZSRUcgfCBTX0lSVUdPOwoJfQojaWZkZWYgQ09ORklHX05URlNfUlcKCWlmICghZGF0YSB8fCAhKGRhdGEtPmZsYWdzICYgKEFUVFJfSVNfQ09NUFJFU1NFRCB8IEFUVFJfSVNfRU5DUllQVEVEKSkpCgkJaW5vZGUtPmlfbW9kZSB8PSBTX0lXVUdPOwojZW5kaWYKCWlub2RlLT5pX21vZGUgJj0gfnZvbC0+dW1hc2s7CglyZXR1cm47CnN5c19maWxlX2Vycm9yOgoJbnRmc19lcnJvcigiQ3JpdGljYWwgZXJyb3IuIFRyaWVkIHRvIGNhbGwgbnRmc19yZWFkX2lub2RlKCkgYmVmb3JlIHdlICIKCQkiaGF2ZSBjb21wbGV0ZWQgcmVhZF9zdXBlcigpIG9yIFZGUyBlcnJvci5cbiIpOwoJLy8gRklYTUU6IFNob3VsZCB3ZSBwYW5pYygpIGF0IHRoaXMgc3RhZ2U/Cn0KCiNpZmRlZiBDT05GSUdfTlRGU19SVwpzdGF0aWMgdm9pZCBudGZzX3dyaXRlX2lub2RlKHN0cnVjdCBpbm9kZSAqaW5vLCBpbnQgdW51c2VkKQp7Cglsb2NrX2tlcm5lbCgpOwoJbnRmc19kZWJ1ZyhERUJVR19MSU5VWCwgIm50ZnNfd3JpdGVfaW5vZGUgMHgleFxuIiwgaW5vLT5pX2lubyk7CgludGZzX3VwZGF0ZV9pbm9kZShOVEZTX0koaW5vKSk7Cgl1bmxvY2tfa2VybmVsKCk7Cn0KI2VuZGlmCgpzdGF0aWMgdm9pZCBfbnRmc19jbGVhcl9pbm9kZShzdHJ1Y3QgaW5vZGUgKmlub2RlKQp7CgludGZzX2lub2RlICppbm87CgludGZzX3ZvbHVtZSAqdm9sOwoJCglsb2NrX2tlcm5lbCgpOwoJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgIl9udGZzX2NsZWFyX2lub2RlIDB4JXhcbiIsIGlub2RlLT5pX2lubyk7Cgl2b2wgPSBOVEZTX0lOTzJWT0woaW5vZGUpOwoJaWYgKCF2b2wpCgkJbnRmc19lcnJvcigiX250ZnNfY2xlYXJfaW5vZGU6IHZvbCA9IE5URlNfSU5PMlZPTChpbm9kZSkgaXMgIgoJCQkJIk5VTEwuXG4iKTsKCXN3aXRjaCAoaW5vZGUtPmlfaW5vKSB7CgljYXNlIEZJTEVfTWZ0OgoJCWlmICh2b2wtPm1mdF9pbm8gJiYgKCh2b2wtPmlub19mbGFncyAmIDEpID09IDApKSB7CgkJCWlubyA9IChudGZzX2lub2RlKiludGZzX21hbGxvYyhzaXplb2YobnRmc19pbm9kZSkpOwoJCQludGZzX21lbWNweShpbm8sIE5URlNfSShpbm9kZSksIHNpemVvZihudGZzX2lub2RlKSk7CgkJCXZvbC0+bWZ0X2lubyA9IGlubzsKCQkJdm9sLT5pbm9fZmxhZ3MgfD0gMTsKCQkJZ290byB1bmxfb3V0OwoJCX0KCQlicmVhazsKCWNhc2UgRklMRV9NZnRNaXJyOgoJCWlmICh2b2wtPm1mdG1pcnIgJiYgKCh2b2wtPmlub19mbGFncyAmIDIpID09IDApKSB7CgkJCWlubyA9IChudGZzX2lub2RlKiludGZzX21hbGxvYyhzaXplb2YobnRmc19pbm9kZSkpOwoJCQludGZzX21lbWNweShpbm8sIE5URlNfSShpbm9kZSksIHNpemVvZihudGZzX2lub2RlKSk7CgkJCXZvbC0+bWZ0bWlyciA9IGlubzsKCQkJdm9sLT5pbm9fZmxhZ3MgfD0gMjsKCQkJZ290byB1bmxfb3V0OwoJCX0KCQlicmVhazsKCWNhc2UgRklMRV9CaXRNYXA6CgkJaWYgKHZvbC0+Yml0bWFwICYmICgodm9sLT5pbm9fZmxhZ3MgJiA0KSA9PSAwKSkgewoJCQlpbm8gPSAobnRmc19pbm9kZSopbnRmc19tYWxsb2Moc2l6ZW9mKG50ZnNfaW5vZGUpKTsKCQkJbnRmc19tZW1jcHkoaW5vLCBOVEZTX0koaW5vZGUpLCBzaXplb2YobnRmc19pbm9kZSkpOwoJCQl2b2wtPmJpdG1hcCA9IGlubzsKCQkJdm9sLT5pbm9fZmxhZ3MgfD0gNDsKCQkJZ290byB1bmxfb3V0OwoJCX0KCQlicmVhazsKCWRlZmF1bHQ6CgkJLyogTm90aGluZy4gSnVzdCBjbGVhciB0aGUgaW5vZGUgYW5kIGV4aXQuICovCgl9CgludGZzX2NsZWFyX2lub2RlKE5URlNfSShpbm9kZSkpOwp1bmxfb3V0OgoJdW5sb2NrX2tlcm5lbCgpOwoJcmV0dXJuOwp9CgovKiBDYWxsZWQgd2hlbiB1bW91bnRpbmcgYSBmaWxlc3lzdGVtIGJ5IGRvX3Vtb3VudCgpIGluIGZzL3N1cGVyLmMuICovCnN0YXRpYyB2b2lkIG50ZnNfcHV0X3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCnsKCW50ZnNfdm9sdW1lICp2b2w7CgoJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgIm50ZnNfcHV0X3N1cGVyXG4iKTsKCXZvbCA9IE5URlNfU0IyVk9MKHNiKTsKCW50ZnNfcmVsZWFzZV92b2x1bWUodm9sKTsKCWlmICh2b2wtPm5sc19tYXApCgkJdW5sb2FkX25scyh2b2wtPm5sc19tYXApOwoJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgIm50ZnNfcHV0X3N1cGVyOiBkb25lXG4iKTsKfQoKLyogQ2FsbGVkIGJ5IHRoZSBrZXJuZWwgd2hlbiBhc2tpbmcgZm9yIHN0YXRzLiAqLwpzdGF0aWMgaW50IG50ZnNfc3RhdGZzKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHN0cnVjdCBzdGF0ZnMgKnNmKQp7CglzdHJ1Y3QgaW5vZGUgKm1mdDsKCW50ZnNfdm9sdW1lICp2b2w7CglfX3M2NCBzaXplOwoJaW50IGVycm9yOwoKCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsICJudGZzX3N0YXRmc1xuIik7Cgl2b2wgPSBOVEZTX1NCMlZPTChzYik7CglzZi0+Zl90eXBlID0gTlRGU19TVVBFUl9NQUdJQzsKCXNmLT5mX2JzaXplID0gdm9sLT5jbHVzdGVyX3NpemU7CgllcnJvciA9IG50ZnNfZ2V0X3ZvbHVtZXNpemUoTlRGU19TQjJWT0woc2IpLCAmc2l6ZSk7CglpZiAoZXJyb3IpCgkJcmV0dXJuIGVycm9yOwoJc2YtPmZfYmxvY2tzID0gc2l6ZTsJLyogVm9sdW1lc2l6ZSBpcyBpbiBjbHVzdGVycy4gKi8KCXNpemUgPSAoX19zNjQpbnRmc19nZXRfZnJlZV9jbHVzdGVyX2NvdW50KHZvbC0+Yml0bWFwKTsKCS8qIEp1c3Qgc2F5IHplcm8gaWYgdGhlIGNhbGwgZmFpbGVkLiAqLwoJaWYgKHNpemUgPCAwTEwpCgkJc2l6ZSA9IDA7CglzZi0+Zl9iZnJlZSA9IHNmLT5mX2JhdmFpbCA9IHNpemU7CgludGZzX2RlYnVnKERFQlVHX09USEVSLCAibnRmc19zdGF0ZnM6IGNhbGxpbmcgbWZ0ID0gaWdldChzYiwgIgoJCQkiRklMRV9NZnQpXG4iKTsKCW1mdCA9IGlnZXQoc2IsIEZJTEVfTWZ0KTsKCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsICJudGZzX3N0YXRmczogaWdldChzYiwgRklMRV9NZnQpIHJldHVybmVkICIKCQkJIjB4JXhcbiIsIG1mdCk7CglpZiAoIW1mdCkKCQlyZXR1cm4gLUVJTzsKCXNmLT5mX2ZpbGVzID0gbWZ0LT5pX3NpemUgPj4gdm9sLT5tZnRfcmVjb3JkX3NpemVfYml0czsKCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsICJudGZzX3N0YXRmczogY2FsbGluZyBpcHV0KG1mdClcbiIpOwoJaXB1dChtZnQpOwoJLyogU2hvdWxkIGJlIHJlYWQgZnJvbSB2b2x1bWUuICovCglzZi0+Zl9uYW1lbGVuID0gMjU1OwoJcmV0dXJuIDA7Cn0KCi8qIENhbGxlZCB3aGVuIHJlbW91bnRpbmcgYSBmaWxlc3lzdGVtIGJ5IGRvX3JlbW91bnRfc2IoKSBpbiBmcy9zdXBlci5jLiAqLwpzdGF0aWMgaW50IG50ZnNfcmVtb3VudF9mcyhzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBpbnQgKmZsYWdzLCBjaGFyICpvcHRpb25zKQp7CglpZiAoIXBhcnNlX29wdGlvbnMoTlRGU19TQjJWT0woc2IpLCBvcHRpb25zKSkKCQlyZXR1cm4gLUVJTlZBTDsKCXJldHVybiAwOwp9CgovKiBEZWZpbmUgdGhlIHN1cGVyIGJsb2NrIG9wZXJhdGlvbiB0aGF0IGFyZSBpbXBsZW1lbnRlZCAqLwoKc3RhdGljIGttZW1fY2FjaGVfdCAqIG50ZnNfaW5vZGVfY2FjaGVwOwoKc3RhdGljIHN0cnVjdCBpbm9kZSAqX19udGZzX2FsbG9jX2lub2RlKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCnsKCXN0cnVjdCBudGZzX2kgKmVpOwoJZWkgPSAoc3RydWN0IG50ZnNfaSAqKWttZW1fY2FjaGVfYWxsb2MobnRmc19pbm9kZV9jYWNoZXAsIFNMQUJfS0VSTkVMKTsKCWlmICghZWkpCgkJcmV0dXJuIE5VTEw7CglyZXR1cm4gJmVpLT52ZnNfaW5vZGU7Cn0KCnN0YXRpYyB2b2lkIG50ZnNfZGVzdHJveV9pbm9kZShzdHJ1Y3QgaW5vZGUgKmlub2RlKQp7CglrbWVtX2NhY2hlX2ZyZWUobnRmc19pbm9kZV9jYWNoZXAsIG50ZnNfaShpbm9kZSkpOwp9CgpzdGF0aWMgdm9pZCBpbml0X29uY2Uodm9pZCAqIGZvbywga21lbV9jYWNoZV90ICogY2FjaGVwLCB1bnNpZ25lZCBsb25nIGZsYWdzKQp7CglzdHJ1Y3QgbnRmc19pICplaSA9IChzdHJ1Y3QgbnRmc19pICopIGZvbzsKCglpZiAoKGZsYWdzICYgKFNMQUJfQ1RPUl9WRVJJRll8U0xBQl9DVE9SX0NPTlNUUlVDVE9SKSkgPT0KCSAgICBTTEFCX0NUT1JfQ09OU1RSVUNUT1IpCgkJaW5vZGVfaW5pdF9vbmNlKCZlaS0+dmZzX2lub2RlKTsKfQogCnN0YXRpYyBpbnQgaW5pdF9pbm9kZWNhY2hlKHZvaWQpCnsKCW50ZnNfaW5vZGVfY2FjaGVwID0ga21lbV9jYWNoZV9jcmVhdGUoIm50ZnNfaW5vZGVfY2FjaGUiLAoJCQkJCSAgICAgc2l6ZW9mKHN0cnVjdCBudGZzX2kpLAoJCQkJCSAgICAgMCwgU0xBQl9IV0NBQ0hFX0FMSUdOLAoJCQkJCSAgICAgaW5pdF9vbmNlLCBOVUxMKTsKCWlmIChudGZzX2lub2RlX2NhY2hlcCA9PSBOVUxMKQoJCXJldHVybiAtRU5PTUVNOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyB2b2lkIGRlc3Ryb3lfaW5vZGVjYWNoZSh2b2lkKQp7CglpZiAoa21lbV9jYWNoZV9kZXN0cm95KG50ZnNfaW5vZGVfY2FjaGVwKSkKCQlwcmludGsoS0VSTl9JTkZPICJudGZzX2lub2RlX2NhY2hlOiBub3QgYWxsIHN0cnVjdHVyZXMgd2VyZSBmcmVlZFxuIik7Cn0Kc3RhdGljIHN0cnVjdCBzdXBlcl9vcGVyYXRpb25zIG50ZnNfc3VwZXJfb3BlcmF0aW9ucyA9IHsKCWFsbG9jX2lub2RlOglfX250ZnNfYWxsb2NfaW5vZGUsCglkZXN0cm95X2lub2RlOgludGZzX2Rlc3Ryb3lfaW5vZGUsCglyZWFkX2lub2RlOgludGZzX3JlYWRfaW5vZGUsCiNpZmRlZiBDT05GSUdfTlRGU19SVwoJd3JpdGVfaW5vZGU6CW50ZnNfd3JpdGVfaW5vZGUsCiNlbmRpZgoJcHV0X3N1cGVyOgludGZzX3B1dF9zdXBlciwKCXN0YXRmczoJCW50ZnNfc3RhdGZzLAoJcmVtb3VudF9mczoJbnRmc19yZW1vdW50X2ZzLAoJY2xlYXJfaW5vZGU6CV9udGZzX2NsZWFyX2lub2RlLAp9OwoKLyoqCiAqIGlzX2Jvb3Rfc2VjdG9yX250ZnMgLSBjaGVjayBhbiBOVEZTIGJvb3Qgc2VjdG9yIGZvciB2YWxpZGl0eQogKiBAYjoJCWJ1ZmZlciBjb250YWluaW5nIGJvb3RzZWN0b3IgdG8gY2hlY2sKICogCiAqIENoZWNrIHdoZXRoZXIgQGIgY29udGFpbnMgYSB2YWxpZCBOVEZTIGJvb3Qgc2VjdG9yLgogKiBSZXR1cm4gMSBpZiBAYiBpcyBhIHZhbGlkIE5URlMgYm9vdHNlY3RvciBvciAwIGlmIG5vdC4KICovCnN0YXRpYyBpbnQgaXNfYm9vdF9zZWN0b3JfbnRmcyhudGZzX3U4ICpiKQp7CgludGZzX3UzMiBpOwoKCS8qIEZJWE1FOiBXZSBkb24ndCB1c2UgY2hlY2tzdW1taW5nIHlldCBhcyBOVDQoU1A2YSkgZG9lc24ndCBlaXRoZXIuLi4KCSAqIEJ1dCB3ZSBtaWdodCBhcyB3ZWxsIGhhdmUgdGhlIGNvZGUgcmVhZHkgdG8gZG8gaXQuIChBSUEpICovCiNpZiAwCgkvKiBDYWxjdWxhdGUgdGhlIGNoZWNrc3VtLiAqLwoJaWYgKGIgPCBiICsgMHg1MCkgewoJCW50ZnNfdTMyICp1OwoJCW50ZnNfdTMyICpiaSA9IChudGZzX3UzMiAqKShiICsgMHg1MCk7CgkJCgkJZm9yICh1ID0gYmksIGkgPSAwOyB1IDwgYmk7ICsrdSkKCQkJaSArPSBOVEZTX0dFVFUzMigqdSk7Cgl9CiNlbmRpZgoJLyogQ2hlY2sgbWFnaWMgaXMgIk5URlMgICAgIiAqLwoJaWYgKGJbM10gIT0gMHg0ZSkgZ290byBub3RfbnRmczsKCWlmIChiWzRdICE9IDB4NTQpIGdvdG8gbm90X250ZnM7CglpZiAoYls1XSAhPSAweDQ2KSBnb3RvIG5vdF9udGZzOwoJaWYgKGJbNl0gIT0gMHg1MykgZ290byBub3RfbnRmczsKCWZvciAoaSA9IDc7IGkgPCAweGI7ICsraSkKCQlpZiAoYltpXSAhPSAweDIwKSBnb3RvIG5vdF9udGZzOwoJLyogQ2hlY2sgYnl0ZXMgcGVyIHNlY3RvciB2YWx1ZSBpcyBiZXR3ZWVuIDUxMiBhbmQgNDA5Ni4gKi8KCWlmIChiWzB4Yl0gIT0gMCkgZ290byBub3RfbnRmczsKCWlmIChiWzB4Y10gPiAweDEwKSBnb3RvIG5vdF9udGZzOwoJLyogQ2hlY2sgc2VjdG9ycyBwZXIgY2x1c3RlciB2YWx1ZSBpcyB2YWxpZC4gKi8KCXN3aXRjaCAoYlsweGRdKSB7CgljYXNlIDE6IGNhc2UgMjogY2FzZSA0OiBjYXNlIDg6IGNhc2UgMTY6CgljYXNlIDMyOiBjYXNlIDY0OiBjYXNlIDEyODoKCQlicmVhazsKCWRlZmF1bHQ6CgkJZ290byBub3RfbnRmczsKCX0KCS8qIENoZWNrIHJlc2VydmVkIHNlY3RvcnMgdmFsdWUgYW5kIGZvdXIgb3RoZXIgZmllbGRzIGFyZSB6ZXJvLiAqLwoJZm9yIChpID0gMHhlOyBpIDwgMHgxNTsgKytpKSAKCQlpZiAoYltpXSAhPSAwKSBnb3RvIG5vdF9udGZzOwoJaWYgKGJbMHgxNl0gIT0gMCkgZ290byBub3RfbnRmczsKCWlmIChiWzB4MTddICE9IDApIGdvdG8gbm90X250ZnM7Cglmb3IgKGkgPSAweDIwOyBpIDwgMHgyNDsgKytpKQoJCWlmIChiW2ldICE9IDApIGdvdG8gbm90X250ZnM7CgkvKiBDaGVjayBjbHVzdGVycyBwZXIgZmlsZSByZWNvcmQgc2VnbWVudCB2YWx1ZSBpcyB2YWxpZC4gKi8KCWlmIChiWzB4NDBdIDwgMHhlMSB8fCBiWzB4NDBdID4gMHhmNykgewoJCXN3aXRjaCAoYlsweDQwXSkgewoJCWNhc2UgMTogY2FzZSAyOiBjYXNlIDQ6IGNhc2UgODogY2FzZSAxNjogY2FzZSAzMjogY2FzZSA2NDoKCQkJYnJlYWs7CgkJZGVmYXVsdDoKCQkJZ290byBub3RfbnRmczsKCQl9Cgl9CgkvKiBDaGVjayBjbHVzdGVycyBwZXIgaW5kZXggYmxvY2sgdmFsdWUgaXMgdmFsaWQuICovCglpZiAoYlsweDQ0XSA8IDB4ZTEgfHwgYlsweDQ0XSA+IDB4ZjcpIHsKCQlzd2l0Y2ggKGJbMHg0NF0pIHsKCQljYXNlIDE6IGNhc2UgMjogY2FzZSA0OiBjYXNlIDg6IGNhc2UgMTY6IGNhc2UgMzI6IGNhc2UgNjQ6CgkJCWJyZWFrOwoJCWRlZmF1bHQ6CgkJCWdvdG8gbm90X250ZnM7CgkJfQoJfQoJcmV0dXJuIDE7Cm5vdF9udGZzOgoJcmV0dXJuIDA7Cn0KCi8qIENhbGxlZCB0byBtb3VudCBhIGZpbGVzeXN0ZW0gYnkgcmVhZF9zdXBlcigpIGluIGZzL3N1cGVyLmMuCiAqIFJldHVybiBhIHN1cGVyIGJsb2NrLCB0aGUgbWFpbiBzdHJ1Y3R1cmUgb2YgYSBmaWxlc3lzdGVtLgogKgogKiBOT1RFIDogRG9uJ3Qgc3RvcmUgYSBwb2ludGVyIHRvIGFuIG9wdGlvbiwgYXMgdGhlIHBhZ2UgY29udGFpbmluZyB0aGUKICogb3B0aW9ucyBpcyBmcmVlZCBhZnRlciBudGZzX3JlYWRfc3VwZXIoKSByZXR1cm5zLgogKgogKiBOT1RFIDogQSBjb250ZXh0IHN3aXRjaCBjYW4gaGFwcGVuIGluIGtlcm5lbCBjb2RlIG9ubHkgaWYgdGhlIGNvZGUgYmxvY2tzCiAqICg9IGNhbGxzIHNjaGVkdWxlKCkgaW4ga2VybmVsL3NjaGVkLmMpLiAqLwpzdGF0aWMgaW50IG50ZnNfZmlsbF9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCB2b2lkICpvcHRpb25zLCBpbnQgc2lsZW50KQp7CgludGZzX3ZvbHVtZSAqdm9sOwoJc3RydWN0IGJ1ZmZlcl9oZWFkICpiaDsKCWludCBpLCB0b19yZWFkLCBibG9ja3NpemU7CgoJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgIm50ZnNfcmVhZF9zdXBlclxuIik7Cgl2b2wgPSBOVEZTX1NCMlZPTChzYik7Cglpbml0X250ZnNfc3VwZXJfYmxvY2sodm9sKTsKCWlmICghcGFyc2Vfb3B0aW9ucyh2b2wsIChjaGFyKilvcHRpb25zKSkKCQlnb3RvIG50ZnNfcmVhZF9zdXBlcl92b2w7CglibG9ja3NpemUgPSBzYl9taW5fYmxvY2tzaXplKHNiLCA1MTIpOwoJaWYgKCFibG9ja3NpemUpIHsKCQludGZzX2Vycm9yKCJVbmFibGUgdG8gc2V0IGJsb2Nrc2l6ZS5cbiIpOwoJCWdvdG8gbnRmc19yZWFkX3N1cGVyX3ZvbDsKCX0KCS8qIFJlYWQgdGhlIHN1cGVyIGJsb2NrIChib290IGJsb2NrKS4gKi8KCWlmICghKGJoID0gc2JfYnJlYWQoc2IsIDApKSkgewoJCW50ZnNfZXJyb3IoIlJlYWRpbmcgc3VwZXIgYmxvY2sgZmFpbGVkXG4iKTsKCQlnb3RvIG50ZnNfcmVhZF9zdXBlcl91bmw7Cgl9CgludGZzX2RlYnVnKERFQlVHX09USEVSLCAiRG9uZSByZWFkaW5nIGJvb3QgYmxvY2tcbiIpOwoJLyogQ2hlY2sgZm9yIHZhbGlkICdOVEZTJyBib290IHNlY3Rvci4gKi8KCWlmICghaXNfYm9vdF9zZWN0b3JfbnRmcyhiaC0+Yl9kYXRhKSkgewoJCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsICJOb3QgYSBOVEZTIHZvbHVtZVxuIik7CgkJYmZvcmdldChiaCk7CgkJZ290byBudGZzX3JlYWRfc3VwZXJfdW5sOwoJfQoJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgIkdvaW5nIHRvIGluaXQgdm9sdW1lXG4iKTsKCWlmIChudGZzX2luaXRfdm9sdW1lKHZvbCwgYmgtPmJfZGF0YSkgPCAwKSB7CgkJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgIkluaXQgdm9sdW1lIGZhaWxlZC5cbiIpOwoJCWJmb3JnZXQoYmgpOwoJCWdvdG8gbnRmc19yZWFkX3N1cGVyX3VubDsKCX0KCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsICIkTWZ0IGF0IGNsdXN0ZXIgMHglbHhcbiIsIHZvbC0+bWZ0X2xjbik7CglicmVsc2UoYmgpOwoJTlRGU19TQih2b2wpID0gc2I7CglpZiAodm9sLT5jbHVzdGVyX3NpemUgPiBQQUdFX1NJWkUpIHsKCQludGZzX2Vycm9yKCJQYXJ0aXRpb24gY2x1c3RlciBzaXplIGlzIG5vdCBzdXBwb3J0ZWQgeWV0IChpdCAiCgkJCSAgICJpcyA+IG1heCBrZXJuZWwgYmxvY2tzaXplKS5cbiIpOwoJCWdvdG8gbnRmc19yZWFkX3N1cGVyX3VubDsKCX0KCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsICJEb25lIHRvIGluaXQgdm9sdW1lXG4iKTsKCS8qIEluZm9ybSB0aGUga2VybmVsIHRoYXQgYSBkZXZpY2UgYmxvY2sgaXMgYSBOVEZTIGNsdXN0ZXIuICovCglpZiAoIXNiX3NldF9ibG9ja3NpemUoc2IsIHZvbC0+Y2x1c3Rlcl9zaXplKSkgewoJCW50ZnNfZXJyb3IoIkNsdXN0ZXIgc2l6ZSB0b28gc21hbGwgZm9yIGRldmljZS5cbiIpOwoJCWdvdG8gbnRmc19yZWFkX3N1cGVyX3VubDsKCX0KCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsICJzZXRfYmxvY2tzaXplXG4iKTsKCS8qIEFsbG9jYXRlIGFuIE1GVCByZWNvcmQgKE1GVCByZWNvcmQgY2FuIGJlIHNtYWxsZXIgdGhhbiBhIGNsdXN0ZXIpLiAqLwoJaSA9IHZvbC0+Y2x1c3Rlcl9zaXplOwoJaWYgKGkgPCB2b2wtPm1mdF9yZWNvcmRfc2l6ZSkKCQlpID0gdm9sLT5tZnRfcmVjb3JkX3NpemU7CglpZiAoISh2b2wtPm1mdCA9IG50ZnNfbWFsbG9jKGkpKSkKCQlnb3RvIG50ZnNfcmVhZF9zdXBlcl91bmw7CgoJLyogUmVhZCBhdCBsZWFzdCB0aGUgTUZUIHJlY29yZCBmb3IgJE1mdC4gKi8KCXRvX3JlYWQgPSB2b2wtPm1mdF9jbHVzdGVyc19wZXJfcmVjb3JkOwoJaWYgKHRvX3JlYWQgPCAxKQoJCXRvX3JlYWQgPSAxOwoJZm9yIChpID0gMDsgaSA8IHRvX3JlYWQ7IGkrKykgewoJCWlmICghKGJoID0gc2JfYnJlYWQoc2IsIHZvbC0+bWZ0X2xjbiArIGkpKSkgewoJCQludGZzX2Vycm9yKCJDb3VsZCBub3QgcmVhZCAkTWZ0IHJlY29yZCAwXG4iKTsKCQkJZ290byBudGZzX3JlYWRfc3VwZXJfbWZ0OwoJCX0KCQludGZzX21lbWNweSh2b2wtPm1mdCArICgoX19zNjQpaSA8PCB2b2wtPmNsdXN0ZXJfc2l6ZV9iaXRzKSwKCQkJCQkJYmgtPmJfZGF0YSwgdm9sLT5jbHVzdGVyX3NpemUpOwoJCWJyZWxzZShiaCk7CgkJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgIlJlYWQgY2x1c3RlciAweCV4XG4iLAoJCQkJCQkJIHZvbC0+bWZ0X2xjbiArIGkpOwoJfQoJLyogQ2hlY2sgYW5kIGZpeHVwIHRoaXMgTUZUIHJlY29yZCAqLwoJaWYgKCFudGZzX2NoZWNrX21mdF9yZWNvcmQodm9sLCB2b2wtPm1mdCkpewoJCW50ZnNfZXJyb3IoIkludmFsaWQgJE1mdCByZWNvcmQgMFxuIik7CgkJZ290byBudGZzX3JlYWRfc3VwZXJfbWZ0OwoJfQoJLyogSW5mb3JtIHRoZSBrZXJuZWwgYWJvdXQgd2hpY2ggc3VwZXIgb3BlcmF0aW9ucyBhcmUgYXZhaWxhYmxlLiAqLwoJc2ItPnNfb3AgPSAmbnRmc19zdXBlcl9vcGVyYXRpb25zOwoJc2ItPnNfbWFnaWMgPSBOVEZTX1NVUEVSX01BR0lDOwoJc2ItPnNfbWF4Ynl0ZXMgPSBNQVhfTEZTX0ZJTEVTSVpFOwoJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgIlJlYWRpbmcgc3BlY2lhbCBmaWxlc1xuIik7CglpZiAobnRmc19sb2FkX3NwZWNpYWxfZmlsZXModm9sKSkgewoJCW50ZnNfZXJyb3IoIkVycm9yIGxvYWRpbmcgc3BlY2lhbCBmaWxlc1xuIik7CgkJZ290byBudGZzX3JlYWRfc3VwZXJfbWZ0OwoJfQoJbnRmc19kZWJ1ZyhERUJVR19PVEhFUiwgIkdldHRpbmcgUm9vdERpclxuIik7CgkvKiBHZXQgdGhlIHJvb3QgZGlyZWN0b3J5LiAqLwoJaWYgKCEoc2ItPnNfcm9vdCA9IGRfYWxsb2Nfcm9vdChpZ2V0KHNiLCBGSUxFX3Jvb3QpKSkpIHsKCQludGZzX2Vycm9yKCJDb3VsZCBub3QgZ2V0IHJvb3QgZGlyIGlub2RlXG4iKTsKCQlnb3RvIG50ZnNfcmVhZF9zdXBlcl9tZnQ7Cgl9CglyZXR1cm4gMDsKbnRmc19yZWFkX3N1cGVyX21mdDoKCW50ZnNfZnJlZSh2b2wtPm1mdCk7Cm50ZnNfcmVhZF9zdXBlcl91bmw6Cm50ZnNfcmVhZF9zdXBlcl92b2w6CgludGZzX2RlYnVnKERFQlVHX09USEVSLCAicmVhZF9zdXBlcjogZG9uZVxuIik7CglyZXR1cm4gLUVJTlZBTDsKfQoKLyogRGVmaW5lIHRoZSBmaWxlc3lzdGVtICovCnN0YXRpYyBzdHJ1Y3Qgc3VwZXJfYmxvY2sgKm50ZnNfZ2V0X3NiKHN0cnVjdCBmaWxlX3N5c3RlbV90eXBlICpmc190eXBlLAoJaW50IGZsYWdzLCBjaGFyICpkZXZfbmFtZSwgdm9pZCAqZGF0YSkKewoJcmV0dXJuIGdldF9zYl9iZGV2KGZzX3R5cGUsIGZsYWdzLCBkZXZfbmFtZSwgZGF0YSwgbnRmc19maWxsX3N1cGVyKTsKfQoKc3RhdGljIHN0cnVjdCBmaWxlX3N5c3RlbV90eXBlIG50ZnNfZnNfdHlwZSA9IHsKCW93bmVyOgkJVEhJU19NT0RVTEUsCgluYW1lOgkJIm50ZnMiLAoJZ2V0X3NiOgkJbnRmc19nZXRfc2IsCglmc19mbGFnczoJRlNfUkVRVUlSRVNfREVWLAp9OwoKc3RhdGljIGludCBfX2luaXQgaW5pdF9udGZzX2ZzKHZvaWQpCnsKCWludCBlcnI7CgkvKiBDb21tZW50IHRoaXMgaWYgeW91IHRydXN0IGtsb2dkLiBUaGVyZSBhcmUgcmVhc29ucyBub3QgdG8gdHJ1c3QgaXQgKi8KI2lmIGRlZmluZWQoREVCVUcpICYmICFkZWZpbmVkKE1PRFVMRSkKCWNvbnNvbGVfdmVyYm9zZSgpOwojZW5kaWYKCXByaW50ayhLRVJOX05PVElDRSAiTlRGUyBkcml2ZXIgdiIgTlRGU19WRVJTSU9OICIgW0ZsYWdzOiBSLyIKI2lmZGVmIENPTkZJR19OVEZTX1JXCgkJCSJXIgojZWxzZQoJCQkiTyIKI2VuZGlmCiNpZmRlZiBERUJVRwoJCQkiIERFQlVHIgojZW5kaWYKI2lmZGVmIE1PRFVMRQoJCQkiIE1PRFVMRSIKI2VuZGlmCgkJCSJdXG4iKTsKCVNZU0NUTCgxKTsKCW50ZnNfZGVidWcoREVCVUdfT1RIRVIsICJyZWdpc3RlcmluZyAlc1xuIiwgbnRmc19mc190eXBlLm5hbWUpOwoJZXJyID0gaW5pdF9pbm9kZWNhY2hlKCk7CglpZiAoZXJyKQoJCWdvdG8gb3V0MTsKCWVyciA9IHJlZ2lzdGVyX2ZpbGVzeXN0ZW0oJm50ZnNfZnNfdHlwZSk7CglpZiAoZXJyKQoJCWdvdG8gb3V0OwoJcmV0dXJuIDA7Cm91dDoKCWRlc3Ryb3lfaW5vZGVjYWNoZSgpOwpvdXQxOgoJU1lTQ1RMKDApOwoJcmV0dXJuIGVycjsKfQoKc3RhdGljIHZvaWQgX19leGl0IGV4aXRfbnRmc19mcyh2b2lkKQp7CglTWVNDVEwoMCk7CgludGZzX2RlYnVnKERFQlVHX09USEVSLCAidW5yZWdpc3RlcmluZyAlc1xuIiwgbnRmc19mc190eXBlLm5hbWUpOwoJdW5yZWdpc3Rlcl9maWxlc3lzdGVtKCZudGZzX2ZzX3R5cGUpOwoJZGVzdHJveV9pbm9kZWNhY2hlKCk7Cn0KCkVYUE9SVF9OT19TWU1CT0xTOwovKgogKiBOb3Qgc3RyaWN0bHkgdHJ1ZS4gVGhlIGRyaXZlciB3YXMgd3JpdHRlbiBvcmlnaW5hbGx5IGJ5IE1hcnRpbiB2b24gTPZ3aXMuCiAqIEkgYW0ganVzdCBtYWludGFpbmluZyBhbmQgcmV3cml0aW5nIGl0LgogKi8KTU9EVUxFX0FVVEhPUigiQW50b24gQWx0YXBhcm1ha292IDxhaWEyMUBjdXMuY2FtLmFjLnVrPiIpOwpNT0RVTEVfREVTQ1JJUFRJT04oIkxpbnV4IE5URlMgZHJpdmVyIik7Ck1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKI2lmZGVmIERFQlVHCk1PRFVMRV9QQVJNKG50ZGVidWcsICJpIik7Ck1PRFVMRV9QQVJNX0RFU0MobnRkZWJ1ZywgIkRlYnVnIGxldmVsIik7CiNlbmRpZgoKbW9kdWxlX2luaXQoaW5pdF9udGZzX2ZzKQptb2R1bGVfZXhpdChleGl0X250ZnNfZnMpCgo=