LyoKCgk4MTM5dG9vLmM6IEEgUmVhbFRlayBSVEwtODEzOSBGYXN0IEV0aGVybmV0IGRyaXZlciBmb3IgTGludXguCgoJTWFpbnRhaW5lZCBieSBKZWZmIEdhcnppayA8amdhcnppa0Bwb2JveC5jb20+CglDb3B5cmlnaHQgMjAwMC0yMDAyIEplZmYgR2FyemlrCgoJTXVjaCBjb2RlIGNvbWVzIGZyb20gRG9uYWxkIEJlY2tlcidzIHJ0bDgxMzkuYyBkcml2ZXIsCgl2ZXJzaW9ucyAxLjEzIGFuZCBvbGRlci4gIFRoaXMgZHJpdmVyIHdhcyBvcmlnaW5hbGx5IGJhc2VkCglvbiBydGw4MTM5LmMgdmVyc2lvbiAxLjA3LiAgSGVhZGVyIG9mIHJ0bDgxMzkuYyB2ZXJzaW9uIDEuMTM6CgoJLS0tLS08c25pcD4tLS0tLQoKICAgICAgICAJV3JpdHRlbiAxOTk3LTIwMDEgYnkgRG9uYWxkIEJlY2tlci4KCQlUaGlzIHNvZnR3YXJlIG1heSBiZSB1c2VkIGFuZCBkaXN0cmlidXRlZCBhY2NvcmRpbmcgdG8gdGhlCgkJdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpLCBpbmNvcnBvcmF0ZWQKCQloZXJlaW4gYnkgcmVmZXJlbmNlLiAgRHJpdmVycyBiYXNlZCBvbiBvciBkZXJpdmVkIGZyb20gdGhpcwoJCWNvZGUgZmFsbCB1bmRlciB0aGUgR1BMIGFuZCBtdXN0IHJldGFpbiB0aGUgYXV0aG9yc2hpcCwKCQljb3B5cmlnaHQgYW5kIGxpY2Vuc2Ugbm90aWNlLiAgVGhpcyBmaWxlIGlzIG5vdCBhIGNvbXBsZXRlCgkJcHJvZ3JhbSBhbmQgbWF5IG9ubHkgYmUgdXNlZCB3aGVuIHRoZSBlbnRpcmUgb3BlcmF0aW5nCgkJc3lzdGVtIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSBHUEwuCgoJCVRoaXMgZHJpdmVyIGlzIGZvciBib2FyZHMgYmFzZWQgb24gdGhlIFJUTDgxMjkgYW5kIFJUTDgxMzkKCQlQQ0kgZXRoZXJuZXQgY2hpcHMuCgoJCVRoZSBhdXRob3IgbWF5IGJlIHJlYWNoZWQgYXMgYmVja2VyQHNjeWxkLmNvbSwgb3IgQy9PIFNjeWxkCgkJQ29tcHV0aW5nIENvcnBvcmF0aW9uIDQxMCBTZXZlcm4gQXZlLiwgU3VpdGUgMjEwIEFubmFwb2xpcwoJCU1EIDIxNDAzCgoJCVN1cHBvcnQgYW5kIHVwZGF0ZXMgYXZhaWxhYmxlIGF0CgkJaHR0cDovL3d3dy5zY3lsZC5jb20vbmV0d29yay9ydGw4MTM5Lmh0bWwKCgkJVHdpc3Rlci10dW5pbmcgdGFibGUgcHJvdmlkZWQgYnkgS2luc3RvbgoJCTxzaGFuZ2hAcmVhbHRlay5jb20udHc+LgoKCS0tLS0tPHNuaXA+LS0tLS0KCglUaGlzIHNvZnR3YXJlIG1heSBiZSB1c2VkIGFuZCBkaXN0cmlidXRlZCBhY2NvcmRpbmcgdG8gdGhlIHRlcm1zCglvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UsIGluY29ycG9yYXRlZCBoZXJlaW4gYnkgcmVmZXJlbmNlLgoKCUNvbnRyaWJ1dG9yczoKCgkJRG9uYWxkIEJlY2tlciAtIGhlIHdyb3RlIHRoZSBvcmlnaW5hbCBkcml2ZXIsIGt1ZG9zIHRvIGhpbSEKCQkoYnV0IHBsZWFzZSBkb24ndCBlLW1haWwgaGltIGZvciBzdXBwb3J0LCB0aGlzIGlzbid0IGhpcyBkcml2ZXIpCgoJCVRpZ3JhbiBBaXZhemlhbiAtIGJ1ZyBmaXhlcywgc2tidWZmIGZyZWUgY2xlYW51cAoKCQlNYXJ0aW4gTWFyZXMgLSBzdWdnZXN0aW9ucyBmb3IgUENJIGNsZWFudXAKCgkJRGF2aWQgUy4gTWlsbGVyIC0gUENJIERNQSBhbmQgc29mdG5ldCB1cGRhdGVzCgoJCUVybnN0IEdpbGwgLSBmaXhlcyBwb3J0ZWQgZnJvbSBCU0QgZHJpdmVyCgoJCURhbmllbCBLb2JyYXMgLSBpZGVudGlmaWVkIHNwZWNpZmljIGxvY2F0aW9ucyBvZgoJCQlwb3N0ZWQgTU1JTyB3cml0ZSBidWdnaW5lc3MKCgkJR2VyYXJkIFNoYXJwIC0gYnVnIGZpeCwgdGVzdGluZyBhbmQgZmVlZGJhY2sKCgkJRGF2aWQgRm9yZCAtIFJ4IHJpbmcgd3JhcCBmaXgKCgkJRGFuIERlTWFnZ2lvIC0gc3dhcHBlZCBSVEw4MTM5IGNhcmRzIHdpdGggbWUsIGFuZCBhbGxvd2VkIG1lCgkJdG8gZmluZCBhbmQgZml4IGEgY3J1Y2lhbCBidWcgb24gb2xkZXIgY2hpcHNldHMuCgoJCURvbmFsZCBCZWNrZXIvQ2hyaXMgQnV0dGVyd29ydGgvTWFyY3VzIFdlc3RlcmdyZW4gLQoJCU5vdGljZWQgdmFyaW91cyBSeCBwYWNrZXQgc2l6ZS1yZWxhdGVkIGJ1Z2xldHMuCgoJCVNhbnRpYWdvIEdhcmNpYSBNYW50aW5hbiAtIHRlc3RpbmcgYW5kIGZlZWRiYWNrCgoJCUplbnMgRGF2aWQgLSAyLjIueCBrZXJuZWwgYmFja3BvcnRzCgoJCU1hcnRpbiBEZW5uZXR0IC0gaW5jcmVkaWJseSBoZWxwZnVsIGluc2lnaHQgb24gdW5kb2N1bWVudGVkCgkJZmVhdHVyZXMgb2YgdGhlIDgxMzkgY2hpcHMKCgkJSmVhbi1KYWNxdWVzIE1pY2hlbCAtIGJ1ZyBmaXgKCgkJVG9iaWFzIFJpbmdzdHL2bSAtIFJ4IGludGVycnVwdCBzdGF0dXMgY2hlY2tpbmcgc3VnZ2VzdGlvbgoKCQlBbmRyZXcgTW9ydG9uIC0gQ2xlYXIgYmxvY2tlZCBzaWduYWxzLCBhdm9pZAoJCWJ1ZmZlciBvdmVycnVuIHNldHRpbmcgY3VycmVudC0+Y29tbS4KCgkJS2FsbGUgT2xhdmkgTmllbWl0YWxvIC0gV2FrZS1vbi1MQU4gaW9jdGxzCgoJCVJvYmVydCBLdWViZWwgLSBTYXZlIGtlcm5lbCB0aHJlYWQgZnJvbSBkeWluZyBvbiBhbnkgc2lnbmFsLgoKCVN1Ym1pdHRpbmcgYnVnIHJlcG9ydHM6CgoJCSJydGw4MTM5LWRpYWcgLW1tbWFhYXZ2dmVlZk4iIG91dHB1dAoJCWVuYWJsZSBSVEw4MTM5X0RFQlVHIGJlbG93LCBhbmQgbG9vayBhdCAnZG1lc2cnIG9yIGtlcm5lbCBsb2cKCiovCgojZGVmaW5lIERSVl9OQU1FCSI4MTM5dG9vIgojZGVmaW5lIERSVl9WRVJTSU9OCSIwLjkuMjciCgoKI2luY2x1ZGUgPGxpbnV4L2NvbmZpZy5oPgojaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KI2luY2x1ZGUgPGxpbnV4L2NvbXBpbGVyLmg+CiNpbmNsdWRlIDxsaW51eC9wY2kuaD4KI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgojaW5jbHVkZSA8bGludXgvbmV0ZGV2aWNlLmg+CiNpbmNsdWRlIDxsaW51eC9ldGhlcmRldmljZS5oPgojaW5jbHVkZSA8bGludXgvcnRuZXRsaW5rLmg+CiNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgojaW5jbHVkZSA8bGludXgvZXRodG9vbC5oPgojaW5jbHVkZSA8bGludXgvbWlpLmg+CiNpbmNsdWRlIDxsaW51eC9jb21wbGV0aW9uLmg+CiNpbmNsdWRlIDxsaW51eC9jcmMzMi5oPgojaW5jbHVkZSA8YXNtL2lvLmg+CiNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgojaW5jbHVkZSA8YXNtL2lycS5oPgoKI2RlZmluZSBSVEw4MTM5X0RSSVZFUl9OQU1FICAgRFJWX05BTUUgIiBGYXN0IEV0aGVybmV0IGRyaXZlciAiIERSVl9WRVJTSU9OCiNkZWZpbmUgUEZYIERSVl9OQU1FICI6ICIKCi8qIERlZmF1bHQgTWVzc2FnZSBsZXZlbCAqLwojZGVmaW5lIFJUTDgxMzlfREVGX01TR19FTkFCTEUgICAoTkVUSUZfTVNHX0RSViAgIHwgXAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBORVRJRl9NU0dfUFJPQkUgIHwgXAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBORVRJRl9NU0dfTElOSykKCgovKiBlbmFibGUgUElPIGluc3RlYWQgb2YgTU1JTywgaWYgQ09ORklHXzgxMzlUT09fUElPIGlzIHNlbGVjdGVkICovCiNpZmRlZiBDT05GSUdfODEzOVRPT19QSU8KI2RlZmluZSBVU0VfSU9fT1BTIDEKI2VuZGlmCgovKiBkZWZpbmUgdG8gMSwgMiBvciAzIHRvIGVuYWJsZSBjb3Bpb3VzIGRlYnVnZ2luZyBpbmZvICovCiNkZWZpbmUgUlRMODEzOV9ERUJVRyAwCgovKiBkZWZpbmUgdG8gMSB0byBkaXNhYmxlIGxpZ2h0d2VpZ2h0IHJ1bnRpbWUgZGVidWdnaW5nIGNoZWNrcyAqLwojdW5kZWYgUlRMODEzOV9OREVCVUcKCgojaWYgUlRMODEzOV9ERUJVRwovKiBub3RlOiBwcmludHMgZnVuY3Rpb24gbmFtZSBmb3IgeW91ICovCiMgIGRlZmluZSBEUFJJTlRLKGZtdCwgYXJncy4uLikgcHJpbnRrKEtFUk5fREVCVUcgIiVzOiAiIGZtdCwgX19GVU5DVElPTl9fICwgIyMgYXJncykKI2Vsc2UKIyAgZGVmaW5lIERQUklOVEsoZm10LCBhcmdzLi4uKQojZW5kaWYKCiNpZmRlZiBSVEw4MTM5X05ERUJVRwojICBkZWZpbmUgYXNzZXJ0KGV4cHIpIGRvIHt9IHdoaWxlICgwKQojZWxzZQojICBkZWZpbmUgYXNzZXJ0KGV4cHIpIFwKICAgICAgICBpZih1bmxpa2VseSghKGV4cHIpKSkgewkJCQkgICAgICAgIFwKICAgICAgICBwcmludGsoS0VSTl9FUlIgIkFzc2VydGlvbiBmYWlsZWQhICVzLCVzLCVzLGxpbmU9JWRcbiIsCVwKICAgICAgICAjZXhwcixfX0ZJTEVfXyxfX0ZVTkNUSU9OX18sX19MSU5FX18pOwkJICAgICAgICBcCiAgICAgICAgfQojZW5kaWYKCgovKiBBIGZldyB1c2VyLWNvbmZpZ3VyYWJsZSB2YWx1ZXMuICovCi8qIG1lZGlhIG9wdGlvbnMgKi8KI2RlZmluZSBNQVhfVU5JVFMgOApzdGF0aWMgaW50IG1lZGlhW01BWF9VTklUU10gPSB7LTEsIC0xLCAtMSwgLTEsIC0xLCAtMSwgLTEsIC0xfTsKc3RhdGljIGludCBmdWxsX2R1cGxleFtNQVhfVU5JVFNdID0gey0xLCAtMSwgLTEsIC0xLCAtMSwgLTEsIC0xLCAtMX07CgovKiBNYXhpbXVtIG51bWJlciBvZiBtdWx0aWNhc3QgYWRkcmVzc2VzIHRvIGZpbHRlciAodnMuIFJ4LWFsbC1tdWx0aWNhc3QpLgogICBUaGUgUlRMIGNoaXBzIHVzZSBhIDY0IGVsZW1lbnQgaGFzaCB0YWJsZSBiYXNlZCBvbiB0aGUgRXRoZXJuZXQgQ1JDLiAgKi8Kc3RhdGljIGludCBtdWx0aWNhc3RfZmlsdGVyX2xpbWl0ID0gMzI7CgovKiBiaXRtYXBwZWQgbWVzc2FnZSBlbmFibGUgbnVtYmVyICovCnN0YXRpYyBpbnQgZGVidWcgPSAtMTsKCi8qCiAqIFJlY2VpdmUgcmluZyBzaXplIAogKiBXYXJuaW5nOiA2NEsgcmluZyBoYXMgaGFyZHdhcmUgaXNzdWVzIGFuZCBtYXkgbG9jayB1cC4KICovCiNpZiBkZWZpbmVkKENPTkZJR19TSF9EUkVBTUNBU1QpCiNkZWZpbmUgUlhfQlVGX0lEWAkxCS8qIDE2SyByaW5nICovCiNlbHNlCiNkZWZpbmUgUlhfQlVGX0lEWAkyCS8qIDMySyByaW5nICovCiNlbmRpZgojZGVmaW5lIFJYX0JVRl9MRU4JKDgxOTIgPDwgUlhfQlVGX0lEWCkKI2RlZmluZSBSWF9CVUZfUEFECTE2CiNkZWZpbmUgUlhfQlVGX1dSQVBfUEFEIDIwNDggLyogc3BhcmUgcGFkZGluZyB0byBoYW5kbGUgbGFjayBvZiBwYWNrZXQgd3JhcCAqLwoKI2lmIFJYX0JVRl9MRU4gPT0gNjU1MzYKI2RlZmluZSBSWF9CVUZfVE9UX0xFTglSWF9CVUZfTEVOCiNlbHNlCiNkZWZpbmUgUlhfQlVGX1RPVF9MRU4JKFJYX0JVRl9MRU4gKyBSWF9CVUZfUEFEICsgUlhfQlVGX1dSQVBfUEFEKQojZW5kaWYKCi8qIE51bWJlciBvZiBUeCBkZXNjcmlwdG9yIHJlZ2lzdGVycy4gKi8KI2RlZmluZSBOVU1fVFhfREVTQwk0CgovKiBtYXggc3VwcG9ydGVkIGV0aGVybmV0IGZyYW1lIHNpemUgLS0gbXVzdCBiZSBhdCBsZWFzdCAoZGV2LT5tdHUrMTQrNCkuKi8KI2RlZmluZSBNQVhfRVRIX0ZSQU1FX1NJWkUJMTUzNgoKLyogU2l6ZSBvZiB0aGUgVHggYm91bmNlIGJ1ZmZlcnMgLS0gbXVzdCBiZSBhdCBsZWFzdCAoZGV2LT5tdHUrMTQrNCkuICovCiNkZWZpbmUgVFhfQlVGX1NJWkUJTUFYX0VUSF9GUkFNRV9TSVpFCiNkZWZpbmUgVFhfQlVGX1RPVF9MRU4JKFRYX0JVRl9TSVpFICogTlVNX1RYX0RFU0MpCgovKiBQQ0kgVHVuaW5nIFBhcmFtZXRlcnMKICAgVGhyZXNob2xkIGlzIGJ5dGVzIHRyYW5zZmVycmVkIHRvIGNoaXAgYmVmb3JlIHRyYW5zbWlzc2lvbiBzdGFydHMuICovCiNkZWZpbmUgVFhfRklGT19USFJFU0ggMjU2CS8qIEluIGJ5dGVzLCByb3VuZGVkIGRvd24gdG8gMzIgYnl0ZSB1bml0cy4gKi8KCi8qIFRoZSBmb2xsb3dpbmcgc2V0dGluZ3MgYXJlIGxvZ18yKGJ5dGVzKS00OiAgMCA9PSAxNiBieXRlcyAuLiA2PT0xMDI0LCA3PT1lbmQgb2YgcGFja2V0LiAqLwojZGVmaW5lIFJYX0ZJRk9fVEhSRVNICTcJLyogUnggYnVmZmVyIGxldmVsIGJlZm9yZSBmaXJzdCBQQ0kgeGZlci4gICovCiNkZWZpbmUgUlhfRE1BX0JVUlNUCTcJLyogTWF4aW11bSBQQ0kgYnVyc3QsICc2JyBpcyAxMDI0ICovCiNkZWZpbmUgVFhfRE1BX0JVUlNUCTYJLyogTWF4aW11bSBQQ0kgYnVyc3QsICc2JyBpcyAxMDI0ICovCiNkZWZpbmUgVFhfUkVUUlkJOAkvKiAwLTE1LiAgcmV0cmllcyA9IDE2ICsgKFRYX1JFVFJZICogMTYpICovCgovKiBPcGVyYXRpb25hbCBwYXJhbWV0ZXJzIHRoYXQgdXN1YWxseSBhcmUgbm90IGNoYW5nZWQuICovCi8qIFRpbWUgaW4gamlmZmllcyBiZWZvcmUgY29uY2x1ZGluZyB0aGUgdHJhbnNtaXR0ZXIgaXMgaHVuZy4gKi8KI2RlZmluZSBUWF9USU1FT1VUICAoNipIWikKCgplbnVtIHsKCUhBU19NSUlfWENWUiA9IDB4MDEwMDAwLAoJSEFTX0NISVBfWENWUiA9IDB4MDIwMDAwLAoJSEFTX0xOS19DSE5HID0gMHgwNDAwMDAsCn07CgojZGVmaW5lIFJUTF9OVU1fU1RBVFMgNAkJLyogbnVtYmVyIG9mIEVUSFRPT0xfR1NUQVRTIHU2NCdzICovCiNkZWZpbmUgUlRMX1JFR1NfVkVSIDEJCS8qIHZlcnNpb24gb2YgcmVnLiBkYXRhIGluIEVUSFRPT0xfR1JFR1MgKi8KI2RlZmluZSBSVExfTUlOX0lPX1NJWkUgMHg4MAojZGVmaW5lIFJUTDgxMzlCX0lPX1NJWkUgMjU2CgojZGVmaW5lIFJUTDgxMjlfQ0FQUwlIQVNfTUlJX1hDVlIKI2RlZmluZSBSVEw4MTM5X0NBUFMJSEFTX0NISVBfWENWUnxIQVNfTE5LX0NITkcKCnR5cGVkZWYgZW51bSB7CglSVEw4MTM5ID0gMCwKCVJUTDgxMjksCn0gYm9hcmRfdDsKCgovKiBpbmRleGVkIGJ5IGJvYXJkX3QsIGFib3ZlICovCnN0YXRpYyBzdHJ1Y3QgewoJY29uc3QgY2hhciAqbmFtZTsKCXUzMiBod19mbGFnczsKfSBib2FyZF9pbmZvW10gX19kZXZpbml0ZGF0YSA9IHsKCXsgIlJlYWxUZWsgUlRMODEzOSIsIFJUTDgxMzlfQ0FQUyB9LAoJeyAiUmVhbFRlayBSVEw4MTI5IiwgUlRMODEyOV9DQVBTIH0sCn07CgoKc3RhdGljIHN0cnVjdCBwY2lfZGV2aWNlX2lkIHJ0bDgxMzlfcGNpX3RibFtdID0gewoJezB4MTBlYywgMHg4MTM5LCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCBSVEw4MTM5IH0sCgl7MHgxMGVjLCAweDgxMzgsIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsIFJUTDgxMzkgfSwKCXsweDExMTMsIDB4MTIxMSwgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwgMCwgMCwgUlRMODEzOSB9LAoJezB4MTUwMCwgMHgxMzYwLCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCBSVEw4MTM5IH0sCgl7MHg0MDMzLCAweDEzNjAsIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsIFJUTDgxMzkgfSwKCXsweDExODYsIDB4MTMwMCwgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwgMCwgMCwgUlRMODEzOSB9LAoJezB4MTE4NiwgMHgxMzQwLCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCBSVEw4MTM5IH0sCgl7MHgxM2QxLCAweGFiMDYsIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsIFJUTDgxMzkgfSwKCXsweDEyNTksIDB4YTExNywgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwgMCwgMCwgUlRMODEzOSB9LAoJezB4MTI1OSwgMHhhMTFlLCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCBSVEw4MTM5IH0sCgl7MHgxNGVhLCAweGFiMDYsIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsIFJUTDgxMzkgfSwKCXsweDE0ZWEsIDB4YWIwNywgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwgMCwgMCwgUlRMODEzOSB9LAoJezB4MTFkYiwgMHgxMjM0LCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCBSVEw4MTM5IH0sCgl7MHgxNDMyLCAweDkxMzAsIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsIFJUTDgxMzkgfSwKCXsweDAyYWMsIDB4MTAxMiwgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwgMCwgMCwgUlRMODEzOSB9LAoJezB4MDE4YSwgMHgwMTA2LCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCBSVEw4MTM5IH0sCgl7MHgxMjZjLCAweDEyMTEsIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsIFJUTDgxMzkgfSwKCXsweDE3NDMsIDB4ODEzOSwgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwgMCwgMCwgUlRMODEzOSB9LAoJezB4MDIxYiwgMHg4MTM5LCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCBSVEw4MTM5IH0sIAoKI2lmZGVmIENPTkZJR19TSF9TRUNVUkVFREdFNTQxMAoJLyogQm9ndXMgODEzOSBzaWxpY29uIHJlcG9ydHMgODEyOSB3aXRob3V0IGV4dGVybmFsIFBST00gOi0oICovCgl7MHgxMGVjLCAweDgxMjksIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsIFJUTDgxMzkgfSwKI2VuZGlmCiNpZmRlZiBDT05GSUdfODEzOVRPT184MTI5Cgl7MHgxMGVjLCAweDgxMjksIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsIFJUTDgxMjkgfSwKI2VuZGlmCgoJLyogc29tZSBjcmF6eSBjYXJkcyByZXBvcnQgaW52YWxpZCB2ZW5kb3IgaWRzIGxpa2UKCSAqIDB4MDAwMSBoZXJlLiAgVGhlIG90aGVyIGlkcyBhcmUgdmFsaWQgYW5kIGNvbnN0YW50LAoJICogc28gd2Ugc2ltcGx5IGRvbid0IG1hdGNoIG9uIHRoZSBtYWluIHZlbmRvciBpZC4KCSAqLwoJe1BDSV9BTllfSUQsIDB4ODEzOSwgMHgxMGVjLCAweDgxMzksIDAsIDAsIFJUTDgxMzkgfSwKCXtQQ0lfQU5ZX0lELCAweDgxMzksIDB4MTE4NiwgMHgxMzAwLCAwLCAwLCBSVEw4MTM5IH0sCgl7UENJX0FOWV9JRCwgMHg4MTM5LCAweDEzZDEsIDB4YWIwNiwgMCwgMCwgUlRMODEzOSB9LAoKCXswLH0KfTsKTU9EVUxFX0RFVklDRV9UQUJMRSAocGNpLCBydGw4MTM5X3BjaV90YmwpOwoKc3RhdGljIHN0cnVjdCB7Cgljb25zdCBjaGFyIHN0cltFVEhfR1NUUklOR19MRU5dOwp9IGV0aHRvb2xfc3RhdHNfa2V5c1tdID0gewoJeyAiZWFybHlfcngiIH0sCgl7ICJ0eF9idWZfbWFwcGVkIiB9LAoJeyAidHhfdGltZW91dHMiIH0sCgl7ICJyeF9sb3N0X2luX3JpbmciIH0sCn07CgovKiBUaGUgcmVzdCBvZiB0aGVzZSB2YWx1ZXMgc2hvdWxkIG5ldmVyIGNoYW5nZS4gKi8KCi8qIFN5bWJvbGljIG9mZnNldHMgdG8gcmVnaXN0ZXJzLiAqLwplbnVtIFJUTDgxMzlfcmVnaXN0ZXJzIHsKCU1BQzAgPSAwLAkJLyogRXRoZXJuZXQgaGFyZHdhcmUgYWRkcmVzcy4gKi8KCU1BUjAgPSA4LAkJLyogTXVsdGljYXN0IGZpbHRlci4gKi8KCVR4U3RhdHVzMCA9IDB4MTAsCS8qIFRyYW5zbWl0IHN0YXR1cyAoRm91ciAzMmJpdCByZWdpc3RlcnMpLiAqLwoJVHhBZGRyMCA9IDB4MjAsCQkvKiBUeCBkZXNjcmlwdG9ycyAoYWxzbyBmb3VyIDMyYml0KS4gKi8KCVJ4QnVmID0gMHgzMCwKCUNoaXBDbWQgPSAweDM3LAoJUnhCdWZQdHIgPSAweDM4LAoJUnhCdWZBZGRyID0gMHgzQSwKCUludHJNYXNrID0gMHgzQywKCUludHJTdGF0dXMgPSAweDNFLAoJVHhDb25maWcgPSAweDQwLAoJUnhDb25maWcgPSAweDQ0LAoJVGltZXIgPSAweDQ4LAkJLyogQSBnZW5lcmFsLXB1cnBvc2UgY291bnRlci4gKi8KCVJ4TWlzc2VkID0gMHg0QywJLyogMjQgYml0cyB2YWxpZCwgd3JpdGUgY2xlYXJzLiAqLwoJQ2ZnOTM0NiA9IDB4NTAsCglDb25maWcwID0gMHg1MSwKCUNvbmZpZzEgPSAweDUyLAoJRmxhc2hSZWcgPSAweDU0LAoJTWVkaWFTdGF0dXMgPSAweDU4LAoJQ29uZmlnMyA9IDB4NTksCglDb25maWc0ID0gMHg1QSwJCS8qIGFic2VudCBvbiBSVEwtODEzOUEgKi8KCUhsdENsayA9IDB4NUIsCglNdWx0aUludHIgPSAweDVDLAoJVHhTdW1tYXJ5ID0gMHg2MCwKCUJhc2ljTW9kZUN0cmwgPSAweDYyLAoJQmFzaWNNb2RlU3RhdHVzID0gMHg2NCwKCU5XYXlBZHZlcnQgPSAweDY2LAoJTldheUxQQVIgPSAweDY4LAoJTldheUV4cGFuc2lvbiA9IDB4NkEsCgkvKiBVbmRvY3VtZW50ZWQgcmVnaXN0ZXJzLCBidXQgcmVxdWlyZWQgZm9yIHByb3BlciBvcGVyYXRpb24uICovCglGSUZPVE1TID0gMHg3MCwJCS8qIEZJRk8gQ29udHJvbCBhbmQgdGVzdC4gKi8KCUNTQ1IgPSAweDc0LAkJLyogQ2hpcCBTdGF0dXMgYW5kIENvbmZpZ3VyYXRpb24gUmVnaXN0ZXIuICovCglQQVJBNzggPSAweDc4LAoJUEFSQTdjID0gMHg3YywJCS8qIE1hZ2ljIHRyYW5zY2VpdmVyIHBhcmFtZXRlciByZWdpc3Rlci4gKi8KCUNvbmZpZzUgPSAweEQ4LAkJLyogYWJzZW50IG9uIFJUTC04MTM5QSAqLwp9OwoKZW51bSBDbGVhckJpdE1hc2tzIHsKCU11bHRpSW50ckNsZWFyID0gMHhGMDAwLAoJQ2hpcENtZENsZWFyID0gMHhFMiwKCUNvbmZpZzFDbGVhciA9ICgxPDw3KXwoMTw8Nil8KDE8PDMpfCgxPDwyKXwoMTw8MSksCn07CgplbnVtIENoaXBDbWRCaXRzIHsKCUNtZFJlc2V0ID0gMHgxMCwKCUNtZFJ4RW5iID0gMHgwOCwKCUNtZFR4RW5iID0gMHgwNCwKCVJ4QnVmRW1wdHkgPSAweDAxLAp9OwoKLyogSW50ZXJydXB0IHJlZ2lzdGVyIGJpdHMsIHVzaW5nIG15IG93biBtZWFuaW5nZnVsIG5hbWVzLiAqLwplbnVtIEludHJTdGF0dXNCaXRzIHsKCVBDSUVyciA9IDB4ODAwMCwKCVBDU1RpbWVvdXQgPSAweDQwMDAsCglSeEZJRk9PdmVyID0gMHg0MCwKCVJ4VW5kZXJydW4gPSAweDIwLAoJUnhPdmVyZmxvdyA9IDB4MTAsCglUeEVyciA9IDB4MDgsCglUeE9LID0gMHgwNCwKCVJ4RXJyID0gMHgwMiwKCVJ4T0sgPSAweDAxLAoKCVJ4QWNrQml0cyA9IFJ4RklGT092ZXIgfCBSeE92ZXJmbG93IHwgUnhPSywKfTsKCmVudW0gVHhTdGF0dXNCaXRzIHsKCVR4SG9zdE93bnMgPSAweDIwMDAsCglUeFVuZGVycnVuID0gMHg0MDAwLAoJVHhTdGF0T0sgPSAweDgwMDAsCglUeE91dE9mV2luZG93ID0gMHgyMDAwMDAwMCwKCVR4QWJvcnRlZCA9IDB4NDAwMDAwMDAsCglUeENhcnJpZXJMb3N0ID0gMHg4MDAwMDAwMCwKfTsKZW51bSBSeFN0YXR1c0JpdHMgewoJUnhNdWx0aWNhc3QgPSAweDgwMDAsCglSeFBoeXNpY2FsID0gMHg0MDAwLAoJUnhCcm9hZGNhc3QgPSAweDIwMDAsCglSeEJhZFN5bWJvbCA9IDB4MDAyMCwKCVJ4UnVudCA9IDB4MDAxMCwKCVJ4VG9vTG9uZyA9IDB4MDAwOCwKCVJ4Q1JDRXJyID0gMHgwMDA0LAoJUnhCYWRBbGlnbiA9IDB4MDAwMiwKCVJ4U3RhdHVzT0sgPSAweDAwMDEsCn07CgovKiBCaXRzIGluIFJ4Q29uZmlnLiAqLwplbnVtIHJ4X21vZGVfYml0cyB7CglBY2NlcHRFcnIgPSAweDIwLAoJQWNjZXB0UnVudCA9IDB4MTAsCglBY2NlcHRCcm9hZGNhc3QgPSAweDA4LAoJQWNjZXB0TXVsdGljYXN0ID0gMHgwNCwKCUFjY2VwdE15UGh5cyA9IDB4MDIsCglBY2NlcHRBbGxQaHlzID0gMHgwMSwKfTsKCi8qIEJpdHMgaW4gVHhDb25maWcuICovCmVudW0gdHhfY29uZmlnX2JpdHMgewoKICAgICAgICAvKiBJbnRlcmZyYW1lIEdhcCBUaW1lLiBPbmx5IFR4SUZHOTYgZG9lc24ndCB2aW9sYXRlIElFRUUgODAyLjMgKi8KICAgICAgICBUeElGR1NoaWZ0ID0gMjQsCiAgICAgICAgVHhJRkc4NCA9ICgwIDw8IFR4SUZHU2hpZnQpLCAgICAvKiA4LjR1cyAvIDg0MG5zICgxMCAvIDEwME1icHMpICovCiAgICAgICAgVHhJRkc4OCA9ICgxIDw8IFR4SUZHU2hpZnQpLCAgICAvKiA4Ljh1cyAvIDg4MG5zICgxMCAvIDEwME1icHMpICovCiAgICAgICAgVHhJRkc5MiA9ICgyIDw8IFR4SUZHU2hpZnQpLCAgICAvKiA5LjJ1cyAvIDkyMG5zICgxMCAvIDEwME1icHMpICovCiAgICAgICAgVHhJRkc5NiA9ICgzIDw8IFR4SUZHU2hpZnQpLCAgICAvKiA5LjZ1cyAvIDk2MG5zICgxMCAvIDEwME1icHMpICovCgoJVHhMb29wQmFjayA9ICgxIDw8IDE4KSB8ICgxIDw8IDE3KSwgLyogZW5hYmxlIGxvb3BiYWNrIHRlc3QgbW9kZSAqLwoJVHhDUkMgPSAoMSA8PCAxNiksCS8qIERJU0FCTEUgYXBwZW5kaW5nIENSQyB0byBlbmQgb2YgVHggcGFja2V0cyAqLwoJVHhDbGVhckFidCA9ICgxIDw8IDApLAkvKiBDbGVhciBhYm9ydCAoV08pICovCglUeERNQVNoaWZ0ID0gOCwJCS8qIERNQSBidXJzdCB2YWx1ZSAoMC03KSBpcyBzaGlmdGVkIHRoaXMgbWFueSBiaXRzICovCglUeFJldHJ5U2hpZnQgPSA0LAkvKiBUWFJSIHZhbHVlICgwLTE1KSBpcyBzaGlmdGVkIHRoaXMgbWFueSBiaXRzICovCgoJVHhWZXJzaW9uTWFzayA9IDB4N0M4MDAwMDAsIC8qIG1hc2sgb3V0IHZlcnNpb24gYml0cyAzMC0yNiwgMjMgKi8KfTsKCi8qIEJpdHMgaW4gQ29uZmlnMSAqLwplbnVtIENvbmZpZzFCaXRzIHsKCUNmZzFfUE1fRW5hYmxlID0gMHgwMSwKCUNmZzFfVlBEX0VuYWJsZSA9IDB4MDIsCglDZmcxX1BJTyA9IDB4MDQsCglDZmcxX01NSU8gPSAweDA4LAoJTFdBS0UgPSAweDEwLAkJLyogbm90IG9uIDgxMzksIDgxMzlBICovCglDZmcxX0RyaXZlcl9Mb2FkID0gMHgyMCwKCUNmZzFfTEVEMCA9IDB4NDAsCglDZmcxX0xFRDEgPSAweDgwLAoJU0xFRVAgPSAoMSA8PCAxKSwJLyogb25seSBvbiA4MTM5LCA4MTM5QSAqLwoJUFdSRE4gPSAoMSA8PCAwKSwJLyogb25seSBvbiA4MTM5LCA4MTM5QSAqLwp9OwoKLyogQml0cyBpbiBDb25maWczICovCmVudW0gQ29uZmlnM0JpdHMgewoJQ2ZnM19GQnRCRW4gICAgPSAoMSA8PCAwKSwgLyogMSA9IEZhc3QgQmFjayB0byBCYWNrICovCglDZmczX0Z1bmNSZWdFbiA9ICgxIDw8IDEpLCAvKiAxID0gZW5hYmxlIENhcmRCdXMgRnVuY3Rpb24gcmVnaXN0ZXJzICovCglDZmczX0NMS1JVTl9FbiA9ICgxIDw8IDIpLCAvKiAxID0gZW5hYmxlIENMS1JVTiAqLwoJQ2ZnM19DYXJkQl9FbiAgPSAoMSA8PCAzKSwgLyogMSA9IGVuYWJsZSBDYXJkQnVzIHJlZ2lzdGVycyAqLwoJQ2ZnM19MaW5rVXAgICAgPSAoMSA8PCA0KSwgLyogMSA9IHdha2UgdXAgb24gbGluayB1cCAqLwoJQ2ZnM19NYWdpYyAgICAgPSAoMSA8PCA1KSwgLyogMSA9IHdha2UgdXAgb24gTWFnaWMgUGFja2V0ICh0bSkgKi8KCUNmZzNfUEFSTV9FbiAgID0gKDEgPDwgNiksIC8qIDAgPSBzb2Z0d2FyZSBjYW4gc2V0IHR3aXN0ZXIgcGFyYW1ldGVycyAqLwoJQ2ZnM19HTlRTZWwgICAgPSAoMSA8PCA3KSwgLyogMSA9IGRlbGF5IDEgY2xvY2sgZnJvbSBQQ0kgR05UIHNpZ25hbCAqLwp9OwoKLyogQml0cyBpbiBDb25maWc0ICovCmVudW0gQ29uZmlnNEJpdHMgewoJTFdQVE4gPSAoMSA8PCAyKSwJLyogbm90IG9uIDgxMzksIDgxMzlBICovCn07CgovKiBCaXRzIGluIENvbmZpZzUgKi8KZW51bSBDb25maWc1Qml0cyB7CglDZmc1X1BNRV9TVFMgICAgID0gKDEgPDwgMCksIC8qIDEgPSBQQ0kgcmVzZXQgcmVzZXRzIFBNRV9TdGF0dXMgKi8KCUNmZzVfTEFOV2FrZSAgICAgPSAoMSA8PCAxKSwgLyogMSA9IGVuYWJsZSBMQU5XYWtlIHNpZ25hbCAqLwoJQ2ZnNV9MRFBTICAgICAgICA9ICgxIDw8IDIpLCAvKiAwID0gc2F2ZSBwb3dlciB3aGVuIGxpbmsgaXMgZG93biAqLwoJQ2ZnNV9GSUZPQWRkclB0ciA9ICgxIDw8IDMpLCAvKiBSZWFsdGVrIGludGVybmFsIFNSQU0gdGVzdGluZyAqLwoJQ2ZnNV9VV0YgICAgICAgICA9ICgxIDw8IDQpLCAvKiAxID0gYWNjZXB0IHVuaWNhc3Qgd2FrZXVwIGZyYW1lICovCglDZmc1X01XRiAgICAgICAgID0gKDEgPDwgNSksIC8qIDEgPSBhY2NlcHQgbXVsdGljYXN0IHdha2V1cCBmcmFtZSAqLwoJQ2ZnNV9CV0YgICAgICAgICA9ICgxIDw8IDYpLCAvKiAxID0gYWNjZXB0IGJyb2FkY2FzdCB3YWtldXAgZnJhbWUgKi8KfTsKCmVudW0gUnhDb25maWdCaXRzIHsKCS8qIHJ4IGZpZm8gdGhyZXNob2xkICovCglSeENmZ0ZJRk9TaGlmdCA9IDEzLAoJUnhDZmdGSUZPTm9uZSA9ICg3IDw8IFJ4Q2ZnRklGT1NoaWZ0KSwKCgkvKiBNYXggRE1BIGJ1cnN0ICovCglSeENmZ0RNQVNoaWZ0ID0gOCwKCVJ4Q2ZnRE1BVW5saW1pdGVkID0gKDcgPDwgUnhDZmdETUFTaGlmdCksCgoJLyogcnggcmluZyBidWZmZXIgbGVuZ3RoICovCglSeENmZ1JjdjhLID0gMCwKCVJ4Q2ZnUmN2MTZLID0gKDEgPDwgMTEpLAoJUnhDZmdSY3YzMksgPSAoMSA8PCAxMiksCglSeENmZ1JjdjY0SyA9ICgxIDw8IDExKSB8ICgxIDw8IDEyKSwKCgkvKiBEaXNhYmxlIHBhY2tldCB3cmFwIGF0IGVuZCBvZiBSeCBidWZmZXIuIChub3QgcG9zc2libGUgd2l0aCA2NGspICovCglSeE5vV3JhcCA9ICgxIDw8IDcpLAp9OwoKLyogVHdpc3RlciB0dW5pbmcgcGFyYW1ldGVycyBmcm9tIFJlYWxUZWsuCiAgIENvbXBsZXRlbHkgdW5kb2N1bWVudGVkLCBidXQgcmVxdWlyZWQgdG8gdHVuZSBiYWQgbGlua3Mgb24gc29tZSBib2FyZHMuICovCmVudW0gQ1NDUkJpdHMgewoJQ1NDUl9MaW5rT0tCaXQgPSAweDA0MDAsCglDU0NSX0xpbmtDaGFuZ2VCaXQgPSAweDA4MDAsCglDU0NSX0xpbmtTdGF0dXNCaXRzID0gMHgwZjAwMCwKCUNTQ1JfTGlua0Rvd25PZmZDbWQgPSAweDAwM2MwLAoJQ1NDUl9MaW5rRG93bkNtZCA9IDB4MGYzYzAsCn07CgplbnVtIENmZzkzNDZCaXRzIHsKCUNmZzkzNDZfTG9jayA9IDB4MDAsCglDZmc5MzQ2X1VubG9jayA9IDB4QzAsCn07Cgp0eXBlZGVmIGVudW0gewoJQ0hfODEzOSA9IDAsCglDSF84MTM5X0ssCglDSF84MTM5QSwKCUNIXzgxMzlBX0csCglDSF84MTM5QiwKCUNIXzgxMzAsCglDSF84MTM5QywKCUNIXzgxMDAsCglDSF84MTAwQl84MTM5RCwKCUNIXzgxMDEsCn0gY2hpcF90OwoKZW51bSBjaGlwX2ZsYWdzIHsKCUhhc0hsdENsayA9ICgxIDw8IDApLAoJSGFzTFdha2UgPSAoMSA8PCAxKSwKfTsKCiNkZWZpbmUgSFdfUkVWSUQoYjMwLCBiMjksIGIyOCwgYjI3LCBiMjYsIGIyMywgYjIyKSBcCgkoYjMwPDwzMCB8IGIyOTw8MjkgfCBiMjg8PDI4IHwgYjI3PDwyNyB8IGIyNjw8MjYgfCBiMjM8PDIzIHwgYjIyPDwyMikKI2RlZmluZSBIV19SRVZJRF9NQVNLCUhXX1JFVklEKDEsIDEsIDEsIDEsIDEsIDEsIDEpCgovKiBkaXJlY3RseSBpbmRleGVkIGJ5IGNoaXBfdCwgYWJvdmUgKi8Kc3RhdGljIGNvbnN0IHN0cnVjdCB7Cgljb25zdCBjaGFyICpuYW1lOwoJdTMyIHZlcnNpb247IC8qIGZyb20gUlRMODEzOUMvUlRMODEzOUQgZG9jcyAqLwoJdTMyIGZsYWdzOwp9IHJ0bF9jaGlwX2luZm9bXSA9IHsKCXsgIlJUTC04MTM5IiwKCSAgSFdfUkVWSUQoMSwgMCwgMCwgMCwgMCwgMCwgMCksCgkgIEhhc0hsdENsaywKCX0sCgoJeyAiUlRMLTgxMzkgcmV2IEsiLAoJICBIV19SRVZJRCgxLCAxLCAwLCAwLCAwLCAwLCAwKSwKCSAgSGFzSGx0Q2xrLAoJfSwKCgl7ICJSVEwtODEzOUEiLAoJICBIV19SRVZJRCgxLCAxLCAxLCAwLCAwLCAwLCAwKSwKCSAgSGFzSGx0Q2xrLCAvKiBYWFggdW5kb2N1bWVudGVkPyAqLwoJfSwKCgl7ICJSVEwtODEzOUEgcmV2IEciLAoJICBIV19SRVZJRCgxLCAxLCAxLCAwLCAwLCAxLCAwKSwKCSAgSGFzSGx0Q2xrLCAvKiBYWFggdW5kb2N1bWVudGVkPyAqLwoJfSwKCgl7ICJSVEwtODEzOUIiLAoJICBIV19SRVZJRCgxLCAxLCAxLCAxLCAwLCAwLCAwKSwKCSAgSGFzTFdha2UsCgl9LAoKCXsgIlJUTC04MTMwIiwKCSAgSFdfUkVWSUQoMSwgMSwgMSwgMSwgMSwgMCwgMCksCgkgIEhhc0xXYWtlLAoJfSwKCgl7ICJSVEwtODEzOUMiLAoJICBIV19SRVZJRCgxLCAxLCAxLCAwLCAxLCAwLCAwKSwKCSAgSGFzTFdha2UsCgl9LAoKCXsgIlJUTC04MTAwIiwKCSAgSFdfUkVWSUQoMSwgMSwgMSwgMSwgMCwgMSwgMCksCiAJICBIYXNMV2FrZSwKIAl9LAoKCXsgIlJUTC04MTAwQi84MTM5RCIsCgkgIEhXX1JFVklEKDEsIDEsIDEsIDAsIDEsIDAsIDEpLAoJICBIYXNIbHRDbGsgLyogWFhYIHVuZG9jdW1lbnRlZD8gKi8KCXwgSGFzTFdha2UsCgl9LAoKCXsgIlJUTC04MTAxIiwKCSAgSFdfUkVWSUQoMSwgMSwgMSwgMCwgMSwgMSwgMSksCgkgIEhhc0xXYWtlLAoJfSwKfTsKCnN0cnVjdCBydGxfZXh0cmFfc3RhdHMgewoJdW5zaWduZWQgbG9uZyBlYXJseV9yeDsKCXVuc2lnbmVkIGxvbmcgdHhfYnVmX21hcHBlZDsKCXVuc2lnbmVkIGxvbmcgdHhfdGltZW91dHM7Cgl1bnNpZ25lZCBsb25nIHJ4X2xvc3RfaW5fcmluZzsKfTsKCnN0cnVjdCBydGw4MTM5X3ByaXZhdGUgewoJdm9pZCBfX2lvbWVtICptbWlvX2FkZHI7CglpbnQgZHJ2X2ZsYWdzOwoJc3RydWN0IHBjaV9kZXYgKnBjaV9kZXY7Cgl1MzIgbXNnX2VuYWJsZTsKCXN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzIHN0YXRzOwoJdW5zaWduZWQgY2hhciAqcnhfcmluZzsKCXVuc2lnbmVkIGludCBjdXJfcng7CS8qIEluZGV4IGludG8gdGhlIFJ4IGJ1ZmZlciBvZiBuZXh0IFJ4IHBrdC4gKi8KCXVuc2lnbmVkIGludCB0eF9mbGFnOwoJdW5zaWduZWQgbG9uZyBjdXJfdHg7Cgl1bnNpZ25lZCBsb25nIGRpcnR5X3R4OwoJdW5zaWduZWQgY2hhciAqdHhfYnVmW05VTV9UWF9ERVNDXTsJLyogVHggYm91bmNlIGJ1ZmZlcnMgKi8KCXVuc2lnbmVkIGNoYXIgKnR4X2J1ZnM7CS8qIFR4IGJvdW5jZSBidWZmZXIgcmVnaW9uLiAqLwoJZG1hX2FkZHJfdCByeF9yaW5nX2RtYTsKCWRtYV9hZGRyX3QgdHhfYnVmc19kbWE7CglzaWduZWQgY2hhciBwaHlzWzRdOwkJLyogTUlJIGRldmljZSBhZGRyZXNzZXMuICovCgljaGFyIHR3aXN0aWUsIHR3aXN0X3JvdywgdHdpc3RfY29sOwkvKiBUd2lzdGVyIHR1bmUgc3RhdGUuICovCgl1bnNpZ25lZCBpbnQgd2F0Y2hkb2dfZmlyZWQgOiAxOwoJdW5zaWduZWQgaW50IGRlZmF1bHRfcG9ydCA6IDQ7CS8qIExhc3QgZGV2LT5pZl9wb3J0IHZhbHVlLiAqLwoJdW5zaWduZWQgaW50IGhhdmVfdGhyZWFkIDogMTsKCXNwaW5sb2NrX3QgbG9jazsKCXNwaW5sb2NrX3QgcnhfbG9jazsKCWNoaXBfdCBjaGlwc2V0OwoJdTMyIHJ4X2NvbmZpZzsKCXN0cnVjdCBydGxfZXh0cmFfc3RhdHMgeHN0YXRzOwoKCXN0cnVjdCB3b3JrX3N0cnVjdCB0aHJlYWQ7CgoJc3RydWN0IG1paV9pZl9pbmZvIG1paTsKCXVuc2lnbmVkIGludCByZWdzX2xlbjsKCXVuc2lnbmVkIGxvbmcgZmlmb19jb3B5X3RpbWVvdXQ7Cn07CgpNT0RVTEVfQVVUSE9SICgiSmVmZiBHYXJ6aWsgPGpnYXJ6aWtAcG9ib3guY29tPiIpOwpNT0RVTEVfREVTQ1JJUFRJT04gKCJSZWFsVGVrIFJUTC04MTM5IEZhc3QgRXRoZXJuZXQgZHJpdmVyIik7Ck1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKTU9EVUxFX1ZFUlNJT04oRFJWX1ZFUlNJT04pOwoKbW9kdWxlX3BhcmFtKG11bHRpY2FzdF9maWx0ZXJfbGltaXQsIGludCwgMCk7Cm1vZHVsZV9wYXJhbV9hcnJheShtZWRpYSwgaW50LCBOVUxMLCAwKTsKbW9kdWxlX3BhcmFtX2FycmF5KGZ1bGxfZHVwbGV4LCBpbnQsIE5VTEwsIDApOwptb2R1bGVfcGFyYW0oZGVidWcsIGludCwgMCk7Ck1PRFVMRV9QQVJNX0RFU0MgKGRlYnVnLCAiODEzOXRvbyBiaXRtYXBwZWQgbWVzc2FnZSBlbmFibGUgbnVtYmVyIik7Ck1PRFVMRV9QQVJNX0RFU0MgKG11bHRpY2FzdF9maWx0ZXJfbGltaXQsICI4MTM5dG9vIG1heGltdW0gbnVtYmVyIG9mIGZpbHRlcmVkIG11bHRpY2FzdCBhZGRyZXNzZXMiKTsKTU9EVUxFX1BBUk1fREVTQyAobWVkaWEsICI4MTM5dG9vOiBCaXRzIDQrOTogZm9yY2UgZnVsbCBkdXBsZXgsIGJpdCA1OiAxMDBNYnBzIik7Ck1PRFVMRV9QQVJNX0RFU0MgKGZ1bGxfZHVwbGV4LCAiODEzOXRvbzogRm9yY2UgZnVsbCBkdXBsZXggZm9yIGJvYXJkKHMpICgxKSIpOwoKc3RhdGljIGludCByZWFkX2VlcHJvbSAodm9pZCBfX2lvbWVtICppb2FkZHIsIGludCBsb2NhdGlvbiwgaW50IGFkZHJfbGVuKTsKc3RhdGljIGludCBydGw4MTM5X29wZW4gKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOwpzdGF0aWMgaW50IG1kaW9fcmVhZCAoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgaW50IHBoeV9pZCwgaW50IGxvY2F0aW9uKTsKc3RhdGljIHZvaWQgbWRpb193cml0ZSAoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgaW50IHBoeV9pZCwgaW50IGxvY2F0aW9uLAoJCQlpbnQgdmFsKTsKc3RhdGljIHZvaWQgcnRsODEzOV9zdGFydF90aHJlYWQoc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqdHApOwpzdGF0aWMgdm9pZCBydGw4MTM5X3R4X3RpbWVvdXQgKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOwpzdGF0aWMgdm9pZCBydGw4MTM5X2luaXRfcmluZyAoc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CnN0YXRpYyBpbnQgcnRsODEzOV9zdGFydF94bWl0IChzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAoJCQkgICAgICAgc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CnN0YXRpYyBpbnQgcnRsODEzOV9wb2xsKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIGludCAqYnVkZ2V0KTsKI2lmZGVmIENPTkZJR19ORVRfUE9MTF9DT05UUk9MTEVSCnN0YXRpYyB2b2lkIHJ0bDgxMzlfcG9sbF9jb250cm9sbGVyKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOwojZW5kaWYKc3RhdGljIGlycXJldHVybl90IHJ0bDgxMzlfaW50ZXJydXB0IChpbnQgaXJxLCB2b2lkICpkZXZfaW5zdGFuY2UsCgkJCSAgICAgICBzdHJ1Y3QgcHRfcmVncyAqcmVncyk7CnN0YXRpYyBpbnQgcnRsODEzOV9jbG9zZSAoc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CnN0YXRpYyBpbnQgbmV0ZGV2X2lvY3RsIChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3QgaWZyZXEgKnJxLCBpbnQgY21kKTsKc3RhdGljIHN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICpydGw4MTM5X2dldF9zdGF0cyAoc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CnN0YXRpYyB2b2lkIHJ0bDgxMzlfc2V0X3J4X21vZGUgKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOwpzdGF0aWMgdm9pZCBfX3NldF9yeF9tb2RlIChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KTsKc3RhdGljIHZvaWQgcnRsODEzOV9od19zdGFydCAoc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CnN0YXRpYyB2b2lkIHJ0bDgxMzlfdGhyZWFkICh2b2lkICpfZGF0YSk7CnN0YXRpYyB2b2lkIHJ0bDgxMzlfdHhfdGltZW91dF90YXNrKHZvaWQgKl9kYXRhKTsKc3RhdGljIHN0cnVjdCBldGh0b29sX29wcyBydGw4MTM5X2V0aHRvb2xfb3BzOwoKLyogd3JpdGUgTU1JTyByZWdpc3Rlciwgd2l0aCBmbHVzaCAqLwovKiBGbHVzaCBhdm9pZHMgcnRsODEzOSBidWcgdy8gcG9zdGVkIE1NSU8gd3JpdGVzICovCiNkZWZpbmUgUlRMX1c4X0YocmVnLCB2YWw4KQlkbyB7IGlvd3JpdGU4ICgodmFsOCksIGlvYWRkciArIChyZWcpKTsgaW9yZWFkOCAoaW9hZGRyICsgKHJlZykpOyB9IHdoaWxlICgwKQojZGVmaW5lIFJUTF9XMTZfRihyZWcsIHZhbDE2KQlkbyB7IGlvd3JpdGUxNiAoKHZhbDE2KSwgaW9hZGRyICsgKHJlZykpOyBpb3JlYWQxNiAoaW9hZGRyICsgKHJlZykpOyB9IHdoaWxlICgwKQojZGVmaW5lIFJUTF9XMzJfRihyZWcsIHZhbDMyKQlkbyB7IGlvd3JpdGUzMiAoKHZhbDMyKSwgaW9hZGRyICsgKHJlZykpOyBpb3JlYWQzMiAoaW9hZGRyICsgKHJlZykpOyB9IHdoaWxlICgwKQoKCiNkZWZpbmUgTU1JT19GTFVTSF9BVURJVF9DT01QTEVURSAxCiNpZiBNTUlPX0ZMVVNIX0FVRElUX0NPTVBMRVRFCgovKiB3cml0ZSBNTUlPIHJlZ2lzdGVyICovCiNkZWZpbmUgUlRMX1c4KHJlZywgdmFsOCkJaW93cml0ZTggKCh2YWw4KSwgaW9hZGRyICsgKHJlZykpCiNkZWZpbmUgUlRMX1cxNihyZWcsIHZhbDE2KQlpb3dyaXRlMTYgKCh2YWwxNiksIGlvYWRkciArIChyZWcpKQojZGVmaW5lIFJUTF9XMzIocmVnLCB2YWwzMikJaW93cml0ZTMyICgodmFsMzIpLCBpb2FkZHIgKyAocmVnKSkKCiNlbHNlCgovKiB3cml0ZSBNTUlPIHJlZ2lzdGVyLCB0aGVuIGZsdXNoICovCiNkZWZpbmUgUlRMX1c4CQlSVExfVzhfRgojZGVmaW5lIFJUTF9XMTYJCVJUTF9XMTZfRgojZGVmaW5lIFJUTF9XMzIJCVJUTF9XMzJfRgoKI2VuZGlmIC8qIE1NSU9fRkxVU0hfQVVESVRfQ09NUExFVEUgKi8KCi8qIHJlYWQgTU1JTyByZWdpc3RlciAqLwojZGVmaW5lIFJUTF9SOChyZWcpCQlpb3JlYWQ4IChpb2FkZHIgKyAocmVnKSkKI2RlZmluZSBSVExfUjE2KHJlZykJCWlvcmVhZDE2IChpb2FkZHIgKyAocmVnKSkKI2RlZmluZSBSVExfUjMyKHJlZykJCSgodW5zaWduZWQgbG9uZykgaW9yZWFkMzIgKGlvYWRkciArIChyZWcpKSkKCgpzdGF0aWMgY29uc3QgdTE2IHJ0bDgxMzlfaW50cl9tYXNrID0KCVBDSUVyciB8IFBDU1RpbWVvdXQgfCBSeFVuZGVycnVuIHwgUnhPdmVyZmxvdyB8IFJ4RklGT092ZXIgfAoJVHhFcnIgfCBUeE9LIHwgUnhFcnIgfCBSeE9LOwoKc3RhdGljIGNvbnN0IHUxNiBydGw4MTM5X25vcnhfaW50cl9tYXNrID0KCVBDSUVyciB8IFBDU1RpbWVvdXQgfCBSeFVuZGVycnVuIHwKCVR4RXJyIHwgVHhPSyB8IFJ4RXJyIDsKCiNpZiBSWF9CVUZfSURYID09IDAKc3RhdGljIGNvbnN0IHVuc2lnbmVkIGludCBydGw4MTM5X3J4X2NvbmZpZyA9CglSeENmZ1JjdjhLIHwgUnhOb1dyYXAgfAoJKFJYX0ZJRk9fVEhSRVNIIDw8IFJ4Q2ZnRklGT1NoaWZ0KSB8CgkoUlhfRE1BX0JVUlNUIDw8IFJ4Q2ZnRE1BU2hpZnQpOwojZWxpZiBSWF9CVUZfSURYID09IDEKc3RhdGljIGNvbnN0IHVuc2lnbmVkIGludCBydGw4MTM5X3J4X2NvbmZpZyA9CglSeENmZ1JjdjE2SyB8IFJ4Tm9XcmFwIHwKCShSWF9GSUZPX1RIUkVTSCA8PCBSeENmZ0ZJRk9TaGlmdCkgfAoJKFJYX0RNQV9CVVJTVCA8PCBSeENmZ0RNQVNoaWZ0KTsKI2VsaWYgUlhfQlVGX0lEWCA9PSAyCnN0YXRpYyBjb25zdCB1bnNpZ25lZCBpbnQgcnRsODEzOV9yeF9jb25maWcgPQoJUnhDZmdSY3YzMksgfCBSeE5vV3JhcCB8CgkoUlhfRklGT19USFJFU0ggPDwgUnhDZmdGSUZPU2hpZnQpIHwKCShSWF9ETUFfQlVSU1QgPDwgUnhDZmdETUFTaGlmdCk7CiNlbGlmIFJYX0JVRl9JRFggPT0gMwpzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IHJ0bDgxMzlfcnhfY29uZmlnID0KCVJ4Q2ZnUmN2NjRLIHwKCShSWF9GSUZPX1RIUkVTSCA8PCBSeENmZ0ZJRk9TaGlmdCkgfAoJKFJYX0RNQV9CVVJTVCA8PCBSeENmZ0RNQVNoaWZ0KTsKI2Vsc2UKI2Vycm9yICJJbnZhbGlkIGNvbmZpZ3VyYXRpb24gZm9yIDgxMzlfUlhCVUZfSURYIgojZW5kaWYKCnN0YXRpYyBjb25zdCB1bnNpZ25lZCBpbnQgcnRsODEzOV90eF9jb25maWcgPQoJVHhJRkc5NiB8IChUWF9ETUFfQlVSU1QgPDwgVHhETUFTaGlmdCkgfCAoVFhfUkVUUlkgPDwgVHhSZXRyeVNoaWZ0KTsKCnN0YXRpYyB2b2lkIF9fcnRsODEzOV9jbGVhbnVwX2RldiAoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKewoJc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqdHAgPSBuZXRkZXZfcHJpdihkZXYpOwoJc3RydWN0IHBjaV9kZXYgKnBkZXY7CgoJYXNzZXJ0IChkZXYgIT0gTlVMTCk7Cglhc3NlcnQgKHRwLT5wY2lfZGV2ICE9IE5VTEwpOwoJcGRldiA9IHRwLT5wY2lfZGV2OwoKI2lmZGVmIFVTRV9JT19PUFMKCWlmICh0cC0+bW1pb19hZGRyKQoJCWlvcG9ydF91bm1hcCAodHAtPm1taW9fYWRkcik7CiNlbHNlCglpZiAodHAtPm1taW9fYWRkcikKCQlwY2lfaW91bm1hcCAocGRldiwgdHAtPm1taW9fYWRkcik7CiNlbmRpZiAvKiBVU0VfSU9fT1BTICovCgoJLyogaXQncyBvayB0byBjYWxsIHRoaXMgZXZlbiBpZiB3ZSBoYXZlIG5vIHJlZ2lvbnMgdG8gZnJlZSAqLwoJcGNpX3JlbGVhc2VfcmVnaW9ucyAocGRldik7CgoJZnJlZV9uZXRkZXYoZGV2KTsKCXBjaV9zZXRfZHJ2ZGF0YSAocGRldiwgTlVMTCk7Cn0KCgpzdGF0aWMgdm9pZCBydGw4MTM5X2NoaXBfcmVzZXQgKHZvaWQgX19pb21lbSAqaW9hZGRyKQp7CglpbnQgaTsKCgkvKiBTb2Z0IHJlc2V0IHRoZSBjaGlwLiAqLwoJUlRMX1c4IChDaGlwQ21kLCBDbWRSZXNldCk7CgoJLyogQ2hlY2sgdGhhdCB0aGUgY2hpcCBoYXMgZmluaXNoZWQgdGhlIHJlc2V0LiAqLwoJZm9yIChpID0gMTAwMDsgaSA+IDA7IGktLSkgewoJCWJhcnJpZXIoKTsKCQlpZiAoKFJUTF9SOCAoQ2hpcENtZCkgJiBDbWRSZXNldCkgPT0gMCkKCQkJYnJlYWs7CgkJdWRlbGF5ICgxMCk7Cgl9Cn0KCgpzdGF0aWMgaW50IF9fZGV2aW5pdCBydGw4MTM5X2luaXRfYm9hcmQgKHN0cnVjdCBwY2lfZGV2ICpwZGV2LAoJCQkJCSBzdHJ1Y3QgbmV0X2RldmljZSAqKmRldl9vdXQpCnsKCXZvaWQgX19pb21lbSAqaW9hZGRyOwoJc3RydWN0IG5ldF9kZXZpY2UgKmRldjsKCXN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwOwoJdTggdG1wODsKCWludCByYywgZGlzYWJsZV9kZXZfb25fZXJyID0gMDsKCXVuc2lnbmVkIGludCBpOwoJdW5zaWduZWQgbG9uZyBwaW9fc3RhcnQsIHBpb19lbmQsIHBpb19mbGFncywgcGlvX2xlbjsKCXVuc2lnbmVkIGxvbmcgbW1pb19zdGFydCwgbW1pb19lbmQsIG1taW9fZmxhZ3MsIG1taW9fbGVuOwoJdTMyIHZlcnNpb247CgoJYXNzZXJ0IChwZGV2ICE9IE5VTEwpOwoKCSpkZXZfb3V0ID0gTlVMTDsKCgkvKiBkZXYgYW5kIHByaXYgemVyb2VkIGluIGFsbG9jX2V0aGVyZGV2ICovCglkZXYgPSBhbGxvY19ldGhlcmRldiAoc2l6ZW9mICgqdHApKTsKCWlmIChkZXYgPT0gTlVMTCkgewoJCXByaW50ayAoS0VSTl9FUlIgUEZYICIlczogVW5hYmxlIHRvIGFsbG9jIG5ldyBuZXQgZGV2aWNlXG4iLCBwY2lfbmFtZShwZGV2KSk7CgkJcmV0dXJuIC1FTk9NRU07Cgl9CglTRVRfTU9EVUxFX09XTkVSKGRldik7CglTRVRfTkVUREVWX0RFVihkZXYsICZwZGV2LT5kZXYpOwoKCXRwID0gbmV0ZGV2X3ByaXYoZGV2KTsKCXRwLT5wY2lfZGV2ID0gcGRldjsKCgkvKiBlbmFibGUgZGV2aWNlIChpbmNsLiBQQ0kgUE0gd2FrZXVwIGFuZCBob3RwbHVnIHNldHVwKSAqLwoJcmMgPSBwY2lfZW5hYmxlX2RldmljZSAocGRldik7CglpZiAocmMpCgkJZ290byBlcnJfb3V0OwoKCXBpb19zdGFydCA9IHBjaV9yZXNvdXJjZV9zdGFydCAocGRldiwgMCk7CglwaW9fZW5kID0gcGNpX3Jlc291cmNlX2VuZCAocGRldiwgMCk7CglwaW9fZmxhZ3MgPSBwY2lfcmVzb3VyY2VfZmxhZ3MgKHBkZXYsIDApOwoJcGlvX2xlbiA9IHBjaV9yZXNvdXJjZV9sZW4gKHBkZXYsIDApOwoKCW1taW9fc3RhcnQgPSBwY2lfcmVzb3VyY2Vfc3RhcnQgKHBkZXYsIDEpOwoJbW1pb19lbmQgPSBwY2lfcmVzb3VyY2VfZW5kIChwZGV2LCAxKTsKCW1taW9fZmxhZ3MgPSBwY2lfcmVzb3VyY2VfZmxhZ3MgKHBkZXYsIDEpOwoJbW1pb19sZW4gPSBwY2lfcmVzb3VyY2VfbGVuIChwZGV2LCAxKTsKCgkvKiBzZXQgdGhpcyBpbW1lZGlhdGVseSwgd2UgbmVlZCB0byBrbm93IGJlZm9yZQoJICogd2UgdGFsayB0byB0aGUgY2hpcCBkaXJlY3RseSAqLwoJRFBSSU5USygiUElPIHJlZ2lvbiBzaXplID09IDB4JTAyWFxuIiwgcGlvX2xlbik7CglEUFJJTlRLKCJNTUlPIHJlZ2lvbiBzaXplID09IDB4JTAybFhcbiIsIG1taW9fbGVuKTsKCiNpZmRlZiBVU0VfSU9fT1BTCgkvKiBtYWtlIHN1cmUgUENJIGJhc2UgYWRkciAwIGlzIFBJTyAqLwoJaWYgKCEocGlvX2ZsYWdzICYgSU9SRVNPVVJDRV9JTykpIHsKCQlwcmludGsgKEtFUk5fRVJSIFBGWCAiJXM6IHJlZ2lvbiAjMCBub3QgYSBQSU8gcmVzb3VyY2UsIGFib3J0aW5nXG4iLCBwY2lfbmFtZShwZGV2KSk7CgkJcmMgPSAtRU5PREVWOwoJCWdvdG8gZXJyX291dDsKCX0KCS8qIGNoZWNrIGZvciB3ZWlyZC9icm9rZW4gUENJIHJlZ2lvbiByZXBvcnRpbmcgKi8KCWlmIChwaW9fbGVuIDwgUlRMX01JTl9JT19TSVpFKSB7CgkJcHJpbnRrIChLRVJOX0VSUiBQRlggIiVzOiBJbnZhbGlkIFBDSSBJL08gcmVnaW9uIHNpemUocyksIGFib3J0aW5nXG4iLCBwY2lfbmFtZShwZGV2KSk7CgkJcmMgPSAtRU5PREVWOwoJCWdvdG8gZXJyX291dDsKCX0KI2Vsc2UKCS8qIG1ha2Ugc3VyZSBQQ0kgYmFzZSBhZGRyIDEgaXMgTU1JTyAqLwoJaWYgKCEobW1pb19mbGFncyAmIElPUkVTT1VSQ0VfTUVNKSkgewoJCXByaW50ayAoS0VSTl9FUlIgUEZYICIlczogcmVnaW9uICMxIG5vdCBhbiBNTUlPIHJlc291cmNlLCBhYm9ydGluZ1xuIiwgcGNpX25hbWUocGRldikpOwoJCXJjID0gLUVOT0RFVjsKCQlnb3RvIGVycl9vdXQ7Cgl9CglpZiAobW1pb19sZW4gPCBSVExfTUlOX0lPX1NJWkUpIHsKCQlwcmludGsgKEtFUk5fRVJSIFBGWCAiJXM6IEludmFsaWQgUENJIG1lbSByZWdpb24gc2l6ZShzKSwgYWJvcnRpbmdcbiIsIHBjaV9uYW1lKHBkZXYpKTsKCQlyYyA9IC1FTk9ERVY7CgkJZ290byBlcnJfb3V0OwoJfQojZW5kaWYKCglyYyA9IHBjaV9yZXF1ZXN0X3JlZ2lvbnMgKHBkZXYsICI4MTM5dG9vIik7CglpZiAocmMpCgkJZ290byBlcnJfb3V0OwoJZGlzYWJsZV9kZXZfb25fZXJyID0gMTsKCgkvKiBlbmFibGUgUENJIGJ1cy1tYXN0ZXJpbmcgKi8KCXBjaV9zZXRfbWFzdGVyIChwZGV2KTsKCiNpZmRlZiBVU0VfSU9fT1BTCglpb2FkZHIgPSBpb3BvcnRfbWFwKHBpb19zdGFydCwgcGlvX2xlbik7CglpZiAoIWlvYWRkcikgewoJCXByaW50ayAoS0VSTl9FUlIgUEZYICIlczogY2Fubm90IG1hcCBQSU8sIGFib3J0aW5nXG4iLCBwY2lfbmFtZShwZGV2KSk7CgkJcmMgPSAtRUlPOwoJCWdvdG8gZXJyX291dDsKCX0KCWRldi0+YmFzZV9hZGRyID0gcGlvX3N0YXJ0OwoJdHAtPm1taW9fYWRkciA9IGlvYWRkcjsKCXRwLT5yZWdzX2xlbiA9IHBpb19sZW47CiNlbHNlCgkvKiBpb3JlbWFwIE1NSU8gcmVnaW9uICovCglpb2FkZHIgPSBwY2lfaW9tYXAocGRldiwgMSwgMCk7CglpZiAoaW9hZGRyID09IE5VTEwpIHsKCQlwcmludGsgKEtFUk5fRVJSIFBGWCAiJXM6IGNhbm5vdCByZW1hcCBNTUlPLCBhYm9ydGluZ1xuIiwgcGNpX25hbWUocGRldikpOwoJCXJjID0gLUVJTzsKCQlnb3RvIGVycl9vdXQ7Cgl9CglkZXYtPmJhc2VfYWRkciA9IChsb25nKSBpb2FkZHI7Cgl0cC0+bW1pb19hZGRyID0gaW9hZGRyOwoJdHAtPnJlZ3NfbGVuID0gbW1pb19sZW47CiNlbmRpZiAvKiBVU0VfSU9fT1BTICovCgoJLyogQnJpbmcgb2xkIGNoaXBzIG91dCBvZiBsb3ctcG93ZXIgbW9kZS4gKi8KCVJUTF9XOCAoSGx0Q2xrLCAnUicpOwoKCS8qIGNoZWNrIGZvciBtaXNzaW5nL2Jyb2tlbiBoYXJkd2FyZSAqLwoJaWYgKFJUTF9SMzIgKFR4Q29uZmlnKSA9PSAweEZGRkZGRkZGKSB7CgkJcHJpbnRrIChLRVJOX0VSUiBQRlggIiVzOiBDaGlwIG5vdCByZXNwb25kaW5nLCBpZ25vcmluZyBib2FyZFxuIiwKCQkJcGNpX25hbWUocGRldikpOwoJCXJjID0gLUVJTzsKCQlnb3RvIGVycl9vdXQ7Cgl9CgoJLyogaWRlbnRpZnkgY2hpcCBhdHRhY2hlZCB0byBib2FyZCAqLwoJdmVyc2lvbiA9IFJUTF9SMzIgKFR4Q29uZmlnKSAmIEhXX1JFVklEX01BU0s7Cglmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSAocnRsX2NoaXBfaW5mbyk7IGkrKykKCQlpZiAodmVyc2lvbiA9PSBydGxfY2hpcF9pbmZvW2ldLnZlcnNpb24pIHsKCQkJdHAtPmNoaXBzZXQgPSBpOwoJCQlnb3RvIG1hdGNoOwoJCX0KCgkvKiBpZiB1bmtub3duIGNoaXAsIGFzc3VtZSBhcnJheSBlbGVtZW50ICMwLCBvcmlnaW5hbCBSVEwtODEzOSBpbiB0aGlzIGNhc2UgKi8KCXByaW50ayAoS0VSTl9ERUJVRyBQRlggIiVzOiB1bmtub3duIGNoaXAgdmVyc2lvbiwgYXNzdW1pbmcgUlRMLTgxMzlcbiIsCgkJcGNpX25hbWUocGRldikpOwoJcHJpbnRrIChLRVJOX0RFQlVHIFBGWCAiJXM6IFR4Q29uZmlnID0gMHglbHhcbiIsIHBjaV9uYW1lKHBkZXYpLCBSVExfUjMyIChUeENvbmZpZykpOwoJdHAtPmNoaXBzZXQgPSAwOwoKbWF0Y2g6CglEUFJJTlRLICgiY2hpcHNldCBpZCAoJWQpID09IGluZGV4ICVkLCAnJXMnXG4iLAoJCSB2ZXJzaW9uLCBpLCBydGxfY2hpcF9pbmZvW2ldLm5hbWUpOwoKCWlmICh0cC0+Y2hpcHNldCA+PSBDSF84MTM5QikgewoJCXU4IG5ld190bXA4ID0gdG1wOCA9IFJUTF9SOCAoQ29uZmlnMSk7CgkJRFBSSU5USygiUENJIFBNIHdha2V1cFxuIik7CgkJaWYgKChydGxfY2hpcF9pbmZvW3RwLT5jaGlwc2V0XS5mbGFncyAmIEhhc0xXYWtlKSAmJgoJCSAgICAodG1wOCAmIExXQUtFKSkKCQkJbmV3X3RtcDggJj0gfkxXQUtFOwoJCW5ld190bXA4IHw9IENmZzFfUE1fRW5hYmxlOwoJCWlmIChuZXdfdG1wOCAhPSB0bXA4KSB7CgkJCVJUTF9XOCAoQ2ZnOTM0NiwgQ2ZnOTM0Nl9VbmxvY2spOwoJCQlSVExfVzggKENvbmZpZzEsIHRtcDgpOwoJCQlSVExfVzggKENmZzkzNDYsIENmZzkzNDZfTG9jayk7CgkJfQoJCWlmIChydGxfY2hpcF9pbmZvW3RwLT5jaGlwc2V0XS5mbGFncyAmIEhhc0xXYWtlKSB7CgkJCXRtcDggPSBSVExfUjggKENvbmZpZzQpOwoJCQlpZiAodG1wOCAmIExXUFROKSB7CgkJCQlSVExfVzggKENmZzkzNDYsIENmZzkzNDZfVW5sb2NrKTsKCQkJCVJUTF9XOCAoQ29uZmlnNCwgdG1wOCAmIH5MV1BUTik7CgkJCQlSVExfVzggKENmZzkzNDYsIENmZzkzNDZfTG9jayk7CgkJCX0KCQl9Cgl9IGVsc2UgewoJCURQUklOVEsoIk9sZCBjaGlwIHdha2V1cFxuIik7CgkJdG1wOCA9IFJUTF9SOCAoQ29uZmlnMSk7CgkJdG1wOCAmPSB+KFNMRUVQIHwgUFdSRE4pOwoJCVJUTF9XOCAoQ29uZmlnMSwgdG1wOCk7Cgl9CgoJcnRsODEzOV9jaGlwX3Jlc2V0IChpb2FkZHIpOwoKCSpkZXZfb3V0ID0gZGV2OwoJcmV0dXJuIDA7CgplcnJfb3V0OgoJX19ydGw4MTM5X2NsZWFudXBfZGV2IChkZXYpOwoJaWYgKGRpc2FibGVfZGV2X29uX2VycikKCQlwY2lfZGlzYWJsZV9kZXZpY2UgKHBkZXYpOwoJcmV0dXJuIHJjOwp9CgoKc3RhdGljIGludCBfX2RldmluaXQgcnRsODEzOV9pbml0X29uZSAoc3RydWN0IHBjaV9kZXYgKnBkZXYsCgkJCQkgICAgICAgY29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgKmVudCkKewoJc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IE5VTEw7CglzdHJ1Y3QgcnRsODEzOV9wcml2YXRlICp0cDsKCWludCBpLCBhZGRyX2xlbiwgb3B0aW9uOwoJdm9pZCBfX2lvbWVtICppb2FkZHI7CglzdGF0aWMgaW50IGJvYXJkX2lkeCA9IC0xOwoJdTggcGNpX3JldjsKCglhc3NlcnQgKHBkZXYgIT0gTlVMTCk7Cglhc3NlcnQgKGVudCAhPSBOVUxMKTsKCglib2FyZF9pZHgrKzsKCgkvKiB3aGVuIHdlJ3JlIGJ1aWx0IGludG8gdGhlIGtlcm5lbCwgdGhlIGRyaXZlciB2ZXJzaW9uIG1lc3NhZ2UKCSAqIGlzIG9ubHkgcHJpbnRlZCBpZiBhdCBsZWFzdCBvbmUgODEzOSBib2FyZCBoYXMgYmVlbiBmb3VuZAoJICovCiNpZm5kZWYgTU9EVUxFCgl7CgkJc3RhdGljIGludCBwcmludGVkX3ZlcnNpb247CgkJaWYgKCFwcmludGVkX3ZlcnNpb24rKykKCQkJcHJpbnRrIChLRVJOX0lORk8gUlRMODEzOV9EUklWRVJfTkFNRSAiXG4iKTsKCX0KI2VuZGlmCgoJcGNpX3JlYWRfY29uZmlnX2J5dGUocGRldiwgUENJX1JFVklTSU9OX0lELCAmcGNpX3Jldik7CgoJaWYgKHBkZXYtPnZlbmRvciA9PSBQQ0lfVkVORE9SX0lEX1JFQUxURUsgJiYKCSAgICBwZGV2LT5kZXZpY2UgPT0gUENJX0RFVklDRV9JRF9SRUFMVEVLXzgxMzkgJiYgcGNpX3JldiA+PSAweDIwKSB7CgkJcHJpbnRrKEtFUk5fSU5GTyBQRlggInBjaSBkZXYgJXMgKGlkICUwNHg6JTA0eCByZXYgJTAyeCkgaXMgYW4gZW5oYW5jZWQgODEzOUMrIGNoaXBcbiIsCgkJICAgICAgIHBjaV9uYW1lKHBkZXYpLCBwZGV2LT52ZW5kb3IsIHBkZXYtPmRldmljZSwgcGNpX3Jldik7CgkJcHJpbnRrKEtFUk5fSU5GTyBQRlggIlVzZSB0aGUgXCI4MTM5Y3BcIiBkcml2ZXIgZm9yIGltcHJvdmVkIHBlcmZvcm1hbmNlIGFuZCBzdGFiaWxpdHkuXG4iKTsKCX0KCglpID0gcnRsODEzOV9pbml0X2JvYXJkIChwZGV2LCAmZGV2KTsKCWlmIChpIDwgMCkKCQlyZXR1cm4gaTsKCglhc3NlcnQgKGRldiAhPSBOVUxMKTsKCXRwID0gbmV0ZGV2X3ByaXYoZGV2KTsKCglpb2FkZHIgPSB0cC0+bW1pb19hZGRyOwoJYXNzZXJ0IChpb2FkZHIgIT0gTlVMTCk7CgoJYWRkcl9sZW4gPSByZWFkX2VlcHJvbSAoaW9hZGRyLCAwLCA4KSA9PSAweDgxMjkgPyA4IDogNjsKCWZvciAoaSA9IDA7IGkgPCAzOyBpKyspCgkJKCh1MTYgKikgKGRldi0+ZGV2X2FkZHIpKVtpXSA9CgkJICAgIGxlMTZfdG9fY3B1IChyZWFkX2VlcHJvbSAoaW9hZGRyLCBpICsgNywgYWRkcl9sZW4pKTsKCW1lbWNweShkZXYtPnBlcm1fYWRkciwgZGV2LT5kZXZfYWRkciwgZGV2LT5hZGRyX2xlbik7CgoJLyogVGhlIFJ0bDgxMzktc3BlY2lmaWMgZW50cmllcyBpbiB0aGUgZGV2aWNlIHN0cnVjdHVyZS4gKi8KCWRldi0+b3BlbiA9IHJ0bDgxMzlfb3BlbjsKCWRldi0+aGFyZF9zdGFydF94bWl0ID0gcnRsODEzOV9zdGFydF94bWl0OwoJZGV2LT5wb2xsID0gcnRsODEzOV9wb2xsOwoJZGV2LT53ZWlnaHQgPSA2NDsKCWRldi0+c3RvcCA9IHJ0bDgxMzlfY2xvc2U7CglkZXYtPmdldF9zdGF0cyA9IHJ0bDgxMzlfZ2V0X3N0YXRzOwoJZGV2LT5zZXRfbXVsdGljYXN0X2xpc3QgPSBydGw4MTM5X3NldF9yeF9tb2RlOwoJZGV2LT5kb19pb2N0bCA9IG5ldGRldl9pb2N0bDsKCWRldi0+ZXRodG9vbF9vcHMgPSAmcnRsODEzOV9ldGh0b29sX29wczsKCWRldi0+dHhfdGltZW91dCA9IHJ0bDgxMzlfdHhfdGltZW91dDsKCWRldi0+d2F0Y2hkb2dfdGltZW8gPSBUWF9USU1FT1VUOwojaWZkZWYgQ09ORklHX05FVF9QT0xMX0NPTlRST0xMRVIKCWRldi0+cG9sbF9jb250cm9sbGVyID0gcnRsODEzOV9wb2xsX2NvbnRyb2xsZXI7CiNlbmRpZgoKCS8qIG5vdGU6IHRoZSBoYXJkd2FyZSBpcyBub3QgY2FwYWJsZSBvZiBzZy9jc3VtL2hpZ2hkbWEsIGhvd2V2ZXIKCSAqIHRocm91Z2ggdGhlIHVzZSBvZiBza2JfY29weV9hbmRfY3N1bV9kZXYgd2UgZW5hYmxlIHRoZXNlCgkgKiBmZWF0dXJlcwoJICovCglkZXYtPmZlYXR1cmVzIHw9IE5FVElGX0ZfU0cgfCBORVRJRl9GX0hXX0NTVU0gfCBORVRJRl9GX0hJR0hETUE7CgoJZGV2LT5pcnEgPSBwZGV2LT5pcnE7CgoJLyogdHAgemVyb2VkIGFuZCBhbGlnbmVkIGluIGFsbG9jX2V0aGVyZGV2ICovCgl0cCA9IG5ldGRldl9wcml2KGRldik7CgoJLyogbm90ZTogdHAtPmNoaXBzZXQgc2V0IGluIHJ0bDgxMzlfaW5pdF9ib2FyZCAqLwoJdHAtPmRydl9mbGFncyA9IGJvYXJkX2luZm9bZW50LT5kcml2ZXJfZGF0YV0uaHdfZmxhZ3M7Cgl0cC0+bW1pb19hZGRyID0gaW9hZGRyOwoJdHAtPm1zZ19lbmFibGUgPQoJCShkZWJ1ZyA8IDAgPyBSVEw4MTM5X0RFRl9NU0dfRU5BQkxFIDogKCgxIDw8IGRlYnVnKSAtIDEpKTsKCXNwaW5fbG9ja19pbml0ICgmdHAtPmxvY2spOwoJc3Bpbl9sb2NrX2luaXQgKCZ0cC0+cnhfbG9jayk7CglJTklUX1dPUksoJnRwLT50aHJlYWQsIHJ0bDgxMzlfdGhyZWFkLCBkZXYpOwoJdHAtPm1paS5kZXYgPSBkZXY7Cgl0cC0+bWlpLm1kaW9fcmVhZCA9IG1kaW9fcmVhZDsKCXRwLT5taWkubWRpb193cml0ZSA9IG1kaW9fd3JpdGU7Cgl0cC0+bWlpLnBoeV9pZF9tYXNrID0gMHgzZjsKCXRwLT5taWkucmVnX251bV9tYXNrID0gMHgxZjsKCgkvKiBkZXYgaXMgZnVsbHkgc2V0IHVwIGFuZCByZWFkeSB0byB1c2Ugbm93ICovCglEUFJJTlRLKCJhYm91dCB0byByZWdpc3RlciBkZXZpY2UgbmFtZWQgJXMgKCVwKS4uLlxuIiwgZGV2LT5uYW1lLCBkZXYpOwoJaSA9IHJlZ2lzdGVyX25ldGRldiAoZGV2KTsKCWlmIChpKSBnb3RvIGVycl9vdXQ7CgoJcGNpX3NldF9kcnZkYXRhIChwZGV2LCBkZXYpOwoKCXByaW50ayAoS0VSTl9JTkZPICIlczogJXMgYXQgMHglbHgsICIKCQkiJTIuMng6JTIuMng6JTIuMng6JTIuMng6JTIuMng6JTIuMngsICIKCQkiSVJRICVkXG4iLAoJCWRldi0+bmFtZSwKCQlib2FyZF9pbmZvW2VudC0+ZHJpdmVyX2RhdGFdLm5hbWUsCgkJZGV2LT5iYXNlX2FkZHIsCgkJZGV2LT5kZXZfYWRkclswXSwgZGV2LT5kZXZfYWRkclsxXSwKCQlkZXYtPmRldl9hZGRyWzJdLCBkZXYtPmRldl9hZGRyWzNdLAoJCWRldi0+ZGV2X2FkZHJbNF0sIGRldi0+ZGV2X2FkZHJbNV0sCgkJZGV2LT5pcnEpOwoKCXByaW50ayAoS0VSTl9ERUJVRyAiJXM6ICBJZGVudGlmaWVkIDgxMzkgY2hpcCB0eXBlICclcydcbiIsCgkJZGV2LT5uYW1lLCBydGxfY2hpcF9pbmZvW3RwLT5jaGlwc2V0XS5uYW1lKTsKCgkvKiBGaW5kIHRoZSBjb25uZWN0ZWQgTUlJIHhjdnJzLgoJICAgRG9pbmcgdGhpcyBpbiBvcGVuKCkgd291bGQgYWxsb3cgZGV0ZWN0aW5nIGV4dGVybmFsIHhjdnJzIGxhdGVyLCBidXQKCSAgIHRha2VzIHRvbyBtdWNoIHRpbWUuICovCiNpZmRlZiBDT05GSUdfODEzOVRPT184MTI5CglpZiAodHAtPmRydl9mbGFncyAmIEhBU19NSUlfWENWUikgewoJCWludCBwaHksIHBoeV9pZHggPSAwOwoJCWZvciAocGh5ID0gMDsgcGh5IDwgMzIgJiYgcGh5X2lkeCA8IHNpemVvZih0cC0+cGh5cyk7IHBoeSsrKSB7CgkJCWludCBtaWlfc3RhdHVzID0gbWRpb19yZWFkKGRldiwgcGh5LCAxKTsKCQkJaWYgKG1paV9zdGF0dXMgIT0gMHhmZmZmICAmJiAgbWlpX3N0YXR1cyAhPSAweDAwMDApIHsKCQkJCXUxNiBhZHZlcnRpc2luZyA9IG1kaW9fcmVhZChkZXYsIHBoeSwgNCk7CgkJCQl0cC0+cGh5c1twaHlfaWR4KytdID0gcGh5OwoJCQkJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IE1JSSB0cmFuc2NlaXZlciAlZCBzdGF0dXMgMHglNC40eCAiCgkJCQkJICAgImFkdmVydGlzaW5nICU0LjR4LlxuIiwKCQkJCQkgICBkZXYtPm5hbWUsIHBoeSwgbWlpX3N0YXR1cywgYWR2ZXJ0aXNpbmcpOwoJCQl9CgkJfQoJCWlmIChwaHlfaWR4ID09IDApIHsKCQkJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IE5vIE1JSSB0cmFuc2NlaXZlcnMgZm91bmQhICBBc3N1bWluZyBTWU0gIgoJCQkJICAgInRyYW5zY2VpdmVyLlxuIiwKCQkJCSAgIGRldi0+bmFtZSk7CgkJCXRwLT5waHlzWzBdID0gMzI7CgkJfQoJfSBlbHNlCiNlbmRpZgoJCXRwLT5waHlzWzBdID0gMzI7Cgl0cC0+bWlpLnBoeV9pZCA9IHRwLT5waHlzWzBdOwoKCS8qIFRoZSBsb3dlciBmb3VyIGJpdHMgYXJlIHRoZSBtZWRpYSB0eXBlLiAqLwoJb3B0aW9uID0gKGJvYXJkX2lkeCA+PSBNQVhfVU5JVFMpID8gMCA6IG1lZGlhW2JvYXJkX2lkeF07CglpZiAob3B0aW9uID4gMCkgewoJCXRwLT5taWkuZnVsbF9kdXBsZXggPSAob3B0aW9uICYgMHgyMTApID8gMSA6IDA7CgkJdHAtPmRlZmF1bHRfcG9ydCA9IG9wdGlvbiAmIDB4RkY7CgkJaWYgKHRwLT5kZWZhdWx0X3BvcnQpCgkJCXRwLT5taWkuZm9yY2VfbWVkaWEgPSAxOwoJfQoJaWYgKGJvYXJkX2lkeCA8IE1BWF9VTklUUyAgJiYgIGZ1bGxfZHVwbGV4W2JvYXJkX2lkeF0gPiAwKQoJCXRwLT5taWkuZnVsbF9kdXBsZXggPSBmdWxsX2R1cGxleFtib2FyZF9pZHhdOwoJaWYgKHRwLT5taWkuZnVsbF9kdXBsZXgpIHsKCQlwcmludGsoS0VSTl9JTkZPICIlczogTWVkaWEgdHlwZSBmb3JjZWQgdG8gRnVsbCBEdXBsZXguXG4iLCBkZXYtPm5hbWUpOwoJCS8qIENoYW5naW5nIHRoZSBNSUktYWR2ZXJ0aXNlZCBtZWRpYSBiZWNhdXNlIG1pZ2h0IHByZXZlbnQKCQkgICByZS1jb25uZWN0aW9uLiAqLwoJCXRwLT5taWkuZm9yY2VfbWVkaWEgPSAxOwoJfQoJaWYgKHRwLT5kZWZhdWx0X3BvcnQpIHsKCQlwcmludGsoS0VSTl9JTkZPICIgIEZvcmNpbmcgJWRNYnBzICVzLWR1cGxleCBvcGVyYXRpb24uXG4iLAoJCQkgICAob3B0aW9uICYgMHgyMCA/IDEwMCA6IDEwKSwKCQkJICAgKG9wdGlvbiAmIDB4MTAgPyAiZnVsbCIgOiAiaGFsZiIpKTsKCQltZGlvX3dyaXRlKGRldiwgdHAtPnBoeXNbMF0sIDAsCgkJCQkgICAoKG9wdGlvbiAmIDB4MjApID8gMHgyMDAwIDogMCkgfCAJLyogMTAwTWJwcz8gKi8KCQkJCSAgICgob3B0aW9uICYgMHgxMCkgPyAweDAxMDAgOiAwKSk7IC8qIEZ1bGwgZHVwbGV4PyAqLwoJfQoKCS8qIFB1dCB0aGUgY2hpcCBpbnRvIGxvdy1wb3dlciBtb2RlLiAqLwoJaWYgKHJ0bF9jaGlwX2luZm9bdHAtPmNoaXBzZXRdLmZsYWdzICYgSGFzSGx0Q2xrKQoJCVJUTF9XOCAoSGx0Q2xrLCAnSCcpOwkvKiAnUicgd291bGQgbGVhdmUgdGhlIGNsb2NrIHJ1bm5pbmcuICovCgoJcmV0dXJuIDA7CgplcnJfb3V0OgoJX19ydGw4MTM5X2NsZWFudXBfZGV2IChkZXYpOwoJcGNpX2Rpc2FibGVfZGV2aWNlIChwZGV2KTsKCXJldHVybiBpOwp9CgoKc3RhdGljIHZvaWQgX19kZXZleGl0IHJ0bDgxMzlfcmVtb3ZlX29uZSAoc3RydWN0IHBjaV9kZXYgKnBkZXYpCnsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSBwY2lfZ2V0X2RydmRhdGEgKHBkZXYpOwoKCWFzc2VydCAoZGV2ICE9IE5VTEwpOwoKCXVucmVnaXN0ZXJfbmV0ZGV2IChkZXYpOwoKCV9fcnRsODEzOV9jbGVhbnVwX2RldiAoZGV2KTsKCXBjaV9kaXNhYmxlX2RldmljZSAocGRldik7Cn0KCgovKiBTZXJpYWwgRUVQUk9NIHNlY3Rpb24uICovCgovKiAgRUVQUk9NX0N0cmwgYml0cy4gKi8KI2RlZmluZSBFRV9TSElGVF9DTEsJMHgwNAkvKiBFRVBST00gc2hpZnQgY2xvY2suICovCiNkZWZpbmUgRUVfQ1MJCQkweDA4CS8qIEVFUFJPTSBjaGlwIHNlbGVjdC4gKi8KI2RlZmluZSBFRV9EQVRBX1dSSVRFCTB4MDIJLyogRUVQUk9NIGNoaXAgZGF0YSBpbi4gKi8KI2RlZmluZSBFRV9XUklURV8wCQkweDAwCiNkZWZpbmUgRUVfV1JJVEVfMQkJMHgwMgojZGVmaW5lIEVFX0RBVEFfUkVBRAkweDAxCS8qIEVFUFJPTSBjaGlwIGRhdGEgb3V0LiAqLwojZGVmaW5lIEVFX0VOQgkJCSgweDgwIHwgRUVfQ1MpCgovKiBEZWxheSBiZXR3ZWVuIEVFUFJPTSBjbG9jayB0cmFuc2l0aW9ucy4KICAgTm8gZXh0cmEgZGVsYXkgaXMgbmVlZGVkIHdpdGggMzNNaHogUENJLCBidXQgNjZNaHogbWF5IGNoYW5nZSB0aGlzLgogKi8KCiNkZWZpbmUgZWVwcm9tX2RlbGF5KCkJUlRMX1IzMihDZmc5MzQ2KQoKLyogVGhlIEVFUFJPTSBjb21tYW5kcyBpbmNsdWRlIHRoZSBhbHdheS1zZXQgbGVhZGluZyBiaXQuICovCiNkZWZpbmUgRUVfV1JJVEVfQ01ECSg1KQojZGVmaW5lIEVFX1JFQURfQ01ECQkoNikKI2RlZmluZSBFRV9FUkFTRV9DTUQJKDcpCgpzdGF0aWMgaW50IF9fZGV2aW5pdCByZWFkX2VlcHJvbSAodm9pZCBfX2lvbWVtICppb2FkZHIsIGludCBsb2NhdGlvbiwgaW50IGFkZHJfbGVuKQp7CglpbnQgaTsKCXVuc2lnbmVkIHJldHZhbCA9IDA7CglpbnQgcmVhZF9jbWQgPSBsb2NhdGlvbiB8IChFRV9SRUFEX0NNRCA8PCBhZGRyX2xlbik7CgoJUlRMX1c4IChDZmc5MzQ2LCBFRV9FTkIgJiB+RUVfQ1MpOwoJUlRMX1c4IChDZmc5MzQ2LCBFRV9FTkIpOwoJZWVwcm9tX2RlbGF5ICgpOwoKCS8qIFNoaWZ0IHRoZSByZWFkIGNvbW1hbmQgYml0cyBvdXQuICovCglmb3IgKGkgPSA0ICsgYWRkcl9sZW47IGkgPj0gMDsgaS0tKSB7CgkJaW50IGRhdGF2YWwgPSAocmVhZF9jbWQgJiAoMSA8PCBpKSkgPyBFRV9EQVRBX1dSSVRFIDogMDsKCQlSVExfVzggKENmZzkzNDYsIEVFX0VOQiB8IGRhdGF2YWwpOwoJCWVlcHJvbV9kZWxheSAoKTsKCQlSVExfVzggKENmZzkzNDYsIEVFX0VOQiB8IGRhdGF2YWwgfCBFRV9TSElGVF9DTEspOwoJCWVlcHJvbV9kZWxheSAoKTsKCX0KCVJUTF9XOCAoQ2ZnOTM0NiwgRUVfRU5CKTsKCWVlcHJvbV9kZWxheSAoKTsKCglmb3IgKGkgPSAxNjsgaSA+IDA7IGktLSkgewoJCVJUTF9XOCAoQ2ZnOTM0NiwgRUVfRU5CIHwgRUVfU0hJRlRfQ0xLKTsKCQllZXByb21fZGVsYXkgKCk7CgkJcmV0dmFsID0KCQkgICAgKHJldHZhbCA8PCAxKSB8ICgoUlRMX1I4IChDZmc5MzQ2KSAmIEVFX0RBVEFfUkVBRCkgPyAxIDoKCQkJCSAgICAgMCk7CgkJUlRMX1c4IChDZmc5MzQ2LCBFRV9FTkIpOwoJCWVlcHJvbV9kZWxheSAoKTsKCX0KCgkvKiBUZXJtaW5hdGUgdGhlIEVFUFJPTSBhY2Nlc3MuICovCglSVExfVzggKENmZzkzNDYsIH5FRV9DUyk7CgllZXByb21fZGVsYXkgKCk7CgoJcmV0dXJuIHJldHZhbDsKfQoKLyogTUlJIHNlcmlhbCBtYW5hZ2VtZW50OiBtb3N0bHkgYm9ndXMgZm9yIG5vdy4gKi8KLyogUmVhZCBhbmQgd3JpdGUgdGhlIE1JSSBtYW5hZ2VtZW50IHJlZ2lzdGVycyB1c2luZyBzb2Z0d2FyZS1nZW5lcmF0ZWQKICAgc2VyaWFsIE1ESU8gcHJvdG9jb2wuCiAgIFRoZSBtYXhpbXVtIGRhdGEgY2xvY2sgcmF0ZSBpcyAyLjUgTWh6LiAgVGhlIG1pbmltdW0gdGltaW5nIGlzIHVzdWFsbHkKICAgbWV0IGJ5IGJhY2stdG8tYmFjayBQQ0kgSS9PIGN5Y2xlcywgYnV0IHdlIGluc2VydCBhIGRlbGF5IHRvIGF2b2lkCiAgICJvdmVyY2xvY2tpbmciIGlzc3Vlcy4gKi8KI2RlZmluZSBNRElPX0RJUgkJMHg4MAojZGVmaW5lIE1ESU9fREFUQV9PVVQJMHgwNAojZGVmaW5lIE1ESU9fREFUQV9JTgkweDAyCiNkZWZpbmUgTURJT19DTEsJCTB4MDEKI2RlZmluZSBNRElPX1dSSVRFMCAoTURJT19ESVIpCiNkZWZpbmUgTURJT19XUklURTEgKE1ESU9fRElSIHwgTURJT19EQVRBX09VVCkKCiNkZWZpbmUgbWRpb19kZWxheSgpCVJUTF9SOChDb25maWc0KQoKCnN0YXRpYyBjaGFyIG1paV8yXzgxMzlfbWFwWzhdID0gewoJQmFzaWNNb2RlQ3RybCwKCUJhc2ljTW9kZVN0YXR1cywKCTAsCgkwLAoJTldheUFkdmVydCwKCU5XYXlMUEFSLAoJTldheUV4cGFuc2lvbiwKCTAKfTsKCgojaWZkZWYgQ09ORklHXzgxMzlUT09fODEyOQovKiBTeW5jcm9uaXplIHRoZSBNSUkgbWFuYWdlbWVudCBpbnRlcmZhY2UgYnkgc2hpZnRpbmcgMzIgb25lIGJpdHMgb3V0LiAqLwpzdGF0aWMgdm9pZCBtZGlvX3N5bmMgKHZvaWQgX19pb21lbSAqaW9hZGRyKQp7CglpbnQgaTsKCglmb3IgKGkgPSAzMjsgaSA+PSAwOyBpLS0pIHsKCQlSVExfVzggKENvbmZpZzQsIE1ESU9fV1JJVEUxKTsKCQltZGlvX2RlbGF5ICgpOwoJCVJUTF9XOCAoQ29uZmlnNCwgTURJT19XUklURTEgfCBNRElPX0NMSyk7CgkJbWRpb19kZWxheSAoKTsKCX0KfQojZW5kaWYKCnN0YXRpYyBpbnQgbWRpb19yZWFkIChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBpbnQgcGh5X2lkLCBpbnQgbG9jYXRpb24pCnsKCXN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwID0gbmV0ZGV2X3ByaXYoZGV2KTsKCWludCByZXR2YWwgPSAwOwojaWZkZWYgQ09ORklHXzgxMzlUT09fODEyOQoJdm9pZCBfX2lvbWVtICppb2FkZHIgPSB0cC0+bW1pb19hZGRyOwoJaW50IG1paV9jbWQgPSAoMHhmNiA8PCAxMCkgfCAocGh5X2lkIDw8IDUpIHwgbG9jYXRpb247CglpbnQgaTsKI2VuZGlmCgoJaWYgKHBoeV9pZCA+IDMxKSB7CS8qIFJlYWxseSBhIDgxMzkuICBVc2UgaW50ZXJuYWwgcmVnaXN0ZXJzLiAqLwoJCXZvaWQgX19pb21lbSAqaW9hZGRyID0gdHAtPm1taW9fYWRkcjsKCQlyZXR1cm4gbG9jYXRpb24gPCA4ICYmIG1paV8yXzgxMzlfbWFwW2xvY2F0aW9uXSA/CgkJICAgIFJUTF9SMTYgKG1paV8yXzgxMzlfbWFwW2xvY2F0aW9uXSkgOiAwOwoJfQoKI2lmZGVmIENPTkZJR184MTM5VE9PXzgxMjkKCW1kaW9fc3luYyAoaW9hZGRyKTsKCS8qIFNoaWZ0IHRoZSByZWFkIGNvbW1hbmQgYml0cyBvdXQuICovCglmb3IgKGkgPSAxNTsgaSA+PSAwOyBpLS0pIHsKCQlpbnQgZGF0YXZhbCA9IChtaWlfY21kICYgKDEgPDwgaSkpID8gTURJT19EQVRBX09VVCA6IDA7CgoJCVJUTF9XOCAoQ29uZmlnNCwgTURJT19ESVIgfCBkYXRhdmFsKTsKCQltZGlvX2RlbGF5ICgpOwoJCVJUTF9XOCAoQ29uZmlnNCwgTURJT19ESVIgfCBkYXRhdmFsIHwgTURJT19DTEspOwoJCW1kaW9fZGVsYXkgKCk7Cgl9CgoJLyogUmVhZCB0aGUgdHdvIHRyYW5zaXRpb24sIDE2IGRhdGEsIGFuZCB3aXJlLWlkbGUgYml0cy4gKi8KCWZvciAoaSA9IDE5OyBpID4gMDsgaS0tKSB7CgkJUlRMX1c4IChDb25maWc0LCAwKTsKCQltZGlvX2RlbGF5ICgpOwoJCXJldHZhbCA9IChyZXR2YWwgPDwgMSkgfCAoKFJUTF9SOCAoQ29uZmlnNCkgJiBNRElPX0RBVEFfSU4pID8gMSA6IDApOwoJCVJUTF9XOCAoQ29uZmlnNCwgTURJT19DTEspOwoJCW1kaW9fZGVsYXkgKCk7Cgl9CiNlbmRpZgoKCXJldHVybiAocmV0dmFsID4+IDEpICYgMHhmZmZmOwp9CgoKc3RhdGljIHZvaWQgbWRpb193cml0ZSAoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgaW50IHBoeV9pZCwgaW50IGxvY2F0aW9uLAoJCQlpbnQgdmFsdWUpCnsKCXN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwID0gbmV0ZGV2X3ByaXYoZGV2KTsKI2lmZGVmIENPTkZJR184MTM5VE9PXzgxMjkKCXZvaWQgX19pb21lbSAqaW9hZGRyID0gdHAtPm1taW9fYWRkcjsKCWludCBtaWlfY21kID0gKDB4NTAwMiA8PCAxNikgfCAocGh5X2lkIDw8IDIzKSB8IChsb2NhdGlvbiA8PCAxOCkgfCB2YWx1ZTsKCWludCBpOwojZW5kaWYKCglpZiAocGh5X2lkID4gMzEpIHsJLyogUmVhbGx5IGEgODEzOS4gIFVzZSBpbnRlcm5hbCByZWdpc3RlcnMuICovCgkJdm9pZCBfX2lvbWVtICppb2FkZHIgPSB0cC0+bW1pb19hZGRyOwoJCWlmIChsb2NhdGlvbiA9PSAwKSB7CgkJCVJUTF9XOCAoQ2ZnOTM0NiwgQ2ZnOTM0Nl9VbmxvY2spOwoJCQlSVExfVzE2IChCYXNpY01vZGVDdHJsLCB2YWx1ZSk7CgkJCVJUTF9XOCAoQ2ZnOTM0NiwgQ2ZnOTM0Nl9Mb2NrKTsKCQl9IGVsc2UgaWYgKGxvY2F0aW9uIDwgOCAmJiBtaWlfMl84MTM5X21hcFtsb2NhdGlvbl0pCgkJCVJUTF9XMTYgKG1paV8yXzgxMzlfbWFwW2xvY2F0aW9uXSwgdmFsdWUpOwoJCXJldHVybjsKCX0KCiNpZmRlZiBDT05GSUdfODEzOVRPT184MTI5CgltZGlvX3N5bmMgKGlvYWRkcik7CgoJLyogU2hpZnQgdGhlIGNvbW1hbmQgYml0cyBvdXQuICovCglmb3IgKGkgPSAzMTsgaSA+PSAwOyBpLS0pIHsKCQlpbnQgZGF0YXZhbCA9CgkJICAgIChtaWlfY21kICYgKDEgPDwgaSkpID8gTURJT19XUklURTEgOiBNRElPX1dSSVRFMDsKCQlSVExfVzggKENvbmZpZzQsIGRhdGF2YWwpOwoJCW1kaW9fZGVsYXkgKCk7CgkJUlRMX1c4IChDb25maWc0LCBkYXRhdmFsIHwgTURJT19DTEspOwoJCW1kaW9fZGVsYXkgKCk7Cgl9CgkvKiBDbGVhciBvdXQgZXh0cmEgYml0cy4gKi8KCWZvciAoaSA9IDI7IGkgPiAwOyBpLS0pIHsKCQlSVExfVzggKENvbmZpZzQsIDApOwoJCW1kaW9fZGVsYXkgKCk7CgkJUlRMX1c4IChDb25maWc0LCBNRElPX0NMSyk7CgkJbWRpb19kZWxheSAoKTsKCX0KI2VuZGlmCn0KCgpzdGF0aWMgaW50IHJ0bDgxMzlfb3BlbiAoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKewoJc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqdHAgPSBuZXRkZXZfcHJpdihkZXYpOwoJaW50IHJldHZhbDsKCXZvaWQgX19pb21lbSAqaW9hZGRyID0gdHAtPm1taW9fYWRkcjsKCglyZXR2YWwgPSByZXF1ZXN0X2lycSAoZGV2LT5pcnEsIHJ0bDgxMzlfaW50ZXJydXB0LCBTQV9TSElSUSwgZGV2LT5uYW1lLCBkZXYpOwoJaWYgKHJldHZhbCkKCQlyZXR1cm4gcmV0dmFsOwoKCXRwLT50eF9idWZzID0gcGNpX2FsbG9jX2NvbnNpc3RlbnQodHAtPnBjaV9kZXYsIFRYX0JVRl9UT1RfTEVOLAoJCQkJCSAgICZ0cC0+dHhfYnVmc19kbWEpOwoJdHAtPnJ4X3JpbmcgPSBwY2lfYWxsb2NfY29uc2lzdGVudCh0cC0+cGNpX2RldiwgUlhfQlVGX1RPVF9MRU4sCgkJCQkJICAgJnRwLT5yeF9yaW5nX2RtYSk7CglpZiAodHAtPnR4X2J1ZnMgPT0gTlVMTCB8fCB0cC0+cnhfcmluZyA9PSBOVUxMKSB7CgkJZnJlZV9pcnEoZGV2LT5pcnEsIGRldik7CgoJCWlmICh0cC0+dHhfYnVmcykKCQkJcGNpX2ZyZWVfY29uc2lzdGVudCh0cC0+cGNpX2RldiwgVFhfQlVGX1RPVF9MRU4sCgkJCQkJICAgIHRwLT50eF9idWZzLCB0cC0+dHhfYnVmc19kbWEpOwoJCWlmICh0cC0+cnhfcmluZykKCQkJcGNpX2ZyZWVfY29uc2lzdGVudCh0cC0+cGNpX2RldiwgUlhfQlVGX1RPVF9MRU4sCgkJCQkJICAgIHRwLT5yeF9yaW5nLCB0cC0+cnhfcmluZ19kbWEpOwoKCQlyZXR1cm4gLUVOT01FTTsKCgl9CgoJdHAtPm1paS5mdWxsX2R1cGxleCA9IHRwLT5taWkuZm9yY2VfbWVkaWE7Cgl0cC0+dHhfZmxhZyA9IChUWF9GSUZPX1RIUkVTSCA8PCAxMSkgJiAweDAwM2YwMDAwOwoKCXJ0bDgxMzlfaW5pdF9yaW5nIChkZXYpOwoJcnRsODEzOV9od19zdGFydCAoZGV2KTsKCW5ldGlmX3N0YXJ0X3F1ZXVlIChkZXYpOwoKCWlmIChuZXRpZl9tc2dfaWZ1cCh0cCkpCgkJcHJpbnRrKEtFUk5fREVCVUcgIiVzOiBydGw4MTM5X29wZW4oKSBpb2FkZHIgJSNseCBJUlEgJWQiCgkJCSIgR1AgUGlucyAlMi4yeCAlcy1kdXBsZXguXG4iLAoJCQlkZXYtPm5hbWUsIHBjaV9yZXNvdXJjZV9zdGFydCAodHAtPnBjaV9kZXYsIDEpLAoJCQlkZXYtPmlycSwgUlRMX1I4IChNZWRpYVN0YXR1cyksCgkJCXRwLT5taWkuZnVsbF9kdXBsZXggPyAiZnVsbCIgOiAiaGFsZiIpOwoKCXJ0bDgxMzlfc3RhcnRfdGhyZWFkKHRwKTsKCglyZXR1cm4gMDsKfQoKCnN0YXRpYyB2b2lkIHJ0bF9jaGVja19tZWRpYSAoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgdW5zaWduZWQgaW50IGluaXRfbWVkaWEpCnsKCXN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwID0gbmV0ZGV2X3ByaXYoZGV2KTsKCglpZiAodHAtPnBoeXNbMF0gPj0gMCkgewoJCW1paV9jaGVja19tZWRpYSgmdHAtPm1paSwgbmV0aWZfbXNnX2xpbmsodHApLCBpbml0X21lZGlhKTsKCX0KfQoKLyogU3RhcnQgdGhlIGhhcmR3YXJlIGF0IG9wZW4gb3IgcmVzdW1lLiAqLwpzdGF0aWMgdm9pZCBydGw4MTM5X2h3X3N0YXJ0IChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQp7CglzdHJ1Y3QgcnRsODEzOV9wcml2YXRlICp0cCA9IG5ldGRldl9wcml2KGRldik7Cgl2b2lkIF9faW9tZW0gKmlvYWRkciA9IHRwLT5tbWlvX2FkZHI7Cgl1MzIgaTsKCXU4IHRtcDsKCgkvKiBCcmluZyBvbGQgY2hpcHMgb3V0IG9mIGxvdy1wb3dlciBtb2RlLiAqLwoJaWYgKHJ0bF9jaGlwX2luZm9bdHAtPmNoaXBzZXRdLmZsYWdzICYgSGFzSGx0Q2xrKQoJCVJUTF9XOCAoSGx0Q2xrLCAnUicpOwoKCXJ0bDgxMzlfY2hpcF9yZXNldCAoaW9hZGRyKTsKCgkvKiB1bmxvY2sgQ29uZmlnWzAxMjM0XSBhbmQgQk1DUiByZWdpc3RlciB3cml0ZXMgKi8KCVJUTF9XOF9GIChDZmc5MzQ2LCBDZmc5MzQ2X1VubG9jayk7CgkvKiBSZXN0b3JlIG91ciBpZGVhIG9mIHRoZSBNQUMgYWRkcmVzcy4gKi8KCVJUTF9XMzJfRiAoTUFDMCArIDAsIGNwdV90b19sZTMyICgqKHUzMiAqKSAoZGV2LT5kZXZfYWRkciArIDApKSk7CglSVExfVzMyX0YgKE1BQzAgKyA0LCBjcHVfdG9fbGUzMiAoKih1MzIgKikgKGRldi0+ZGV2X2FkZHIgKyA0KSkpOwoKCS8qIE11c3QgZW5hYmxlIFR4L1J4IGJlZm9yZSBzZXR0aW5nIHRyYW5zZmVyIHRocmVzaG9sZHMhICovCglSVExfVzggKENoaXBDbWQsIENtZFJ4RW5iIHwgQ21kVHhFbmIpOwoKCXRwLT5yeF9jb25maWcgPSBydGw4MTM5X3J4X2NvbmZpZyB8IEFjY2VwdEJyb2FkY2FzdCB8IEFjY2VwdE15UGh5czsKCVJUTF9XMzIgKFJ4Q29uZmlnLCB0cC0+cnhfY29uZmlnKTsKCVJUTF9XMzIgKFR4Q29uZmlnLCBydGw4MTM5X3R4X2NvbmZpZyk7CgoJdHAtPmN1cl9yeCA9IDA7CgoJcnRsX2NoZWNrX21lZGlhIChkZXYsIDEpOwoKCWlmICh0cC0+Y2hpcHNldCA+PSBDSF84MTM5QikgewoJCS8qIERpc2FibGUgbWFnaWMgcGFja2V0IHNjYW5uaW5nLCB3aGljaCBpcyBlbmFibGVkCgkJICogd2hlbiBQTSBpcyBlbmFibGVkIGluIENvbmZpZzEuICBJdCBjYW4gYmUgcmVlbmFibGVkCgkJICogdmlhIEVUSFRPT0xfU1dPTCBpZiBkZXNpcmVkLiAgKi8KCQlSVExfVzggKENvbmZpZzMsIFJUTF9SOCAoQ29uZmlnMykgJiB+Q2ZnM19NYWdpYyk7Cgl9CgoJRFBSSU5USygiaW5pdCBidWZmZXIgYWRkcmVzc2VzXG4iKTsKCgkvKiBMb2NrIENvbmZpZ1swMTIzNF0gYW5kIEJNQ1IgcmVnaXN0ZXIgd3JpdGVzICovCglSVExfVzggKENmZzkzNDYsIENmZzkzNDZfTG9jayk7CgoJLyogaW5pdCBSeCByaW5nIGJ1ZmZlciBETUEgYWRkcmVzcyAqLwoJUlRMX1czMl9GIChSeEJ1ZiwgdHAtPnJ4X3JpbmdfZG1hKTsKCgkvKiBpbml0IFR4IGJ1ZmZlciBETUEgYWRkcmVzc2VzICovCglmb3IgKGkgPSAwOyBpIDwgTlVNX1RYX0RFU0M7IGkrKykKCQlSVExfVzMyX0YgKFR4QWRkcjAgKyAoaSAqIDQpLCB0cC0+dHhfYnVmc19kbWEgKyAodHAtPnR4X2J1ZltpXSAtIHRwLT50eF9idWZzKSk7CgoJUlRMX1czMiAoUnhNaXNzZWQsIDApOwoKCXJ0bDgxMzlfc2V0X3J4X21vZGUgKGRldik7CgoJLyogbm8gZWFybHktcnggaW50ZXJydXB0cyAqLwoJUlRMX1cxNiAoTXVsdGlJbnRyLCBSVExfUjE2IChNdWx0aUludHIpICYgTXVsdGlJbnRyQ2xlYXIpOwoKCS8qIG1ha2Ugc3VyZSBSeFR4IGhhcyBzdGFydGVkICovCgl0bXAgPSBSVExfUjggKENoaXBDbWQpOwoJaWYgKCghKHRtcCAmIENtZFJ4RW5iKSkgfHwgKCEodG1wICYgQ21kVHhFbmIpKSkKCQlSVExfVzggKENoaXBDbWQsIENtZFJ4RW5iIHwgQ21kVHhFbmIpOwoKCS8qIEVuYWJsZSBhbGwga25vd24gaW50ZXJydXB0cyBieSBzZXR0aW5nIHRoZSBpbnRlcnJ1cHQgbWFzay4gKi8KCVJUTF9XMTYgKEludHJNYXNrLCBydGw4MTM5X2ludHJfbWFzayk7Cn0KCgovKiBJbml0aWFsaXplIHRoZSBSeCBhbmQgVHggcmluZ3MsIGFsb25nIHdpdGggdmFyaW91cyAnZGV2JyBiaXRzLiAqLwpzdGF0aWMgdm9pZCBydGw4MTM5X2luaXRfcmluZyAoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKewoJc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqdHAgPSBuZXRkZXZfcHJpdihkZXYpOwoJaW50IGk7CgoJdHAtPmN1cl9yeCA9IDA7Cgl0cC0+Y3VyX3R4ID0gMDsKCXRwLT5kaXJ0eV90eCA9IDA7CgoJZm9yIChpID0gMDsgaSA8IE5VTV9UWF9ERVNDOyBpKyspCgkJdHAtPnR4X2J1ZltpXSA9ICZ0cC0+dHhfYnVmc1tpICogVFhfQlVGX1NJWkVdOwp9CgoKLyogVGhpcyBtdXN0IGJlIGdsb2JhbCBmb3IgQ09ORklHXzgxMzlUT09fVFVORV9UV0lTVEVSIGNhc2UgKi8Kc3RhdGljIGludCBuZXh0X3RpY2sgPSAzICogSFo7CgojaWZuZGVmIENPTkZJR184MTM5VE9PX1RVTkVfVFdJU1RFUgpzdGF0aWMgaW5saW5lIHZvaWQgcnRsODEzOV90dW5lX3R3aXN0ZXIgKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCgkJCQkgIHN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwKSB7fQojZWxzZQplbnVtIFR3aXN0ZXJQYXJhbVZhbHMgewoJUEFSQTc4X2RlZmF1bHQJPSAweDc4ZmE4Mzg4LAoJUEFSQTdjX2RlZmF1bHQJPSAweGNiMzhkZTQzLAkvKiBwYXJhbVswXVszXSAqLwoJUEFSQTdjX3h4eAk9IDB4Y2IzOGRlNDMsCn07CgpzdGF0aWMgY29uc3QgdW5zaWduZWQgbG9uZyBwYXJhbVs0XVs0XSA9IHsKCXsweGNiMzlkZTQzLCAweGNiMzljZTQzLCAweGZiMzhkZTAzLCAweGNiMzhkZTQzfSwKCXsweGNiMzlkZTQzLCAweGNiMzljZTQzLCAweGNiMzljZTgzLCAweGNiMzljZTgzfSwKCXsweGNiMzlkZTQzLCAweGNiMzljZTQzLCAweGNiMzljZTgzLCAweGNiMzljZTgzfSwKCXsweGJiMzlkZTQzLCAweGJiMzljZTQzLCAweGJiMzljZTgzLCAweGJiMzljZTgzfQp9OwoKc3RhdGljIHZvaWQgcnRsODEzOV90dW5lX3R3aXN0ZXIgKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCgkJCQkgIHN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwKQp7CglpbnQgbGlua2Nhc2U7Cgl2b2lkIF9faW9tZW0gKmlvYWRkciA9IHRwLT5tbWlvX2FkZHI7CgoJLyogVGhpcyBpcyBhIGNvbXBsaWNhdGVkIHN0YXRlIG1hY2hpbmUgdG8gY29uZmlndXJlIHRoZSAidHdpc3RlciIgZm9yCgkgICBpbXBlZGFuY2UvZWNob3MgYmFzZWQgb24gdGhlIGNhYmxlIGxlbmd0aC4KCSAgIEFsbCBvZiB0aGlzIGlzIG1hZ2ljIGFuZCB1bmRvY3VtZW50ZWQuCgkgKi8KCXN3aXRjaCAodHAtPnR3aXN0aWUpIHsKCWNhc2UgMToKCQlpZiAoUlRMX1IxNiAoQ1NDUikgJiBDU0NSX0xpbmtPS0JpdCkgewoJCQkvKiBXZSBoYXZlIGxpbmsgYmVhdCwgbGV0IHVzIHR1bmUgdGhlIHR3aXN0ZXIuICovCgkJCVJUTF9XMTYgKENTQ1IsIENTQ1JfTGlua0Rvd25PZmZDbWQpOwoJCQl0cC0+dHdpc3RpZSA9IDI7CS8qIENoYW5nZSB0byBzdGF0ZSAyLiAqLwoJCQluZXh0X3RpY2sgPSBIWiAvIDEwOwoJCX0gZWxzZSB7CgkJCS8qIEp1c3QgcHV0IGluIHNvbWUgcmVhc29uYWJsZSBkZWZhdWx0cyBmb3Igd2hlbiBiZWF0IHJldHVybnMuICovCgkJCVJUTF9XMTYgKENTQ1IsIENTQ1JfTGlua0Rvd25DbWQpOwoJCQlSVExfVzMyIChGSUZPVE1TLCAweDIwKTsJLyogVHVybiBvbiBjYWJsZSB0ZXN0IG1vZGUuICovCgkJCVJUTF9XMzIgKFBBUkE3OCwgUEFSQTc4X2RlZmF1bHQpOwoJCQlSVExfVzMyIChQQVJBN2MsIFBBUkE3Y19kZWZhdWx0KTsKCQkJdHAtPnR3aXN0aWUgPSAwOwkvKiBCYWlsIGZyb20gZnV0dXJlIGFjdGlvbnMuICovCgkJfQoJCWJyZWFrOwoJY2FzZSAyOgoJCS8qIFJlYWQgaG93IGxvbmcgaXQgdG9vayB0byBoZWFyIHRoZSBlY2hvLiAqLwoJCWxpbmtjYXNlID0gUlRMX1IxNiAoQ1NDUikgJiBDU0NSX0xpbmtTdGF0dXNCaXRzOwoJCWlmIChsaW5rY2FzZSA9PSAweDcwMDApCgkJCXRwLT50d2lzdF9yb3cgPSAzOwoJCWVsc2UgaWYgKGxpbmtjYXNlID09IDB4MzAwMCkKCQkJdHAtPnR3aXN0X3JvdyA9IDI7CgkJZWxzZSBpZiAobGlua2Nhc2UgPT0gMHgxMDAwKQoJCQl0cC0+dHdpc3Rfcm93ID0gMTsKCQllbHNlCgkJCXRwLT50d2lzdF9yb3cgPSAwOwoJCXRwLT50d2lzdF9jb2wgPSAwOwoJCXRwLT50d2lzdGllID0gMzsJLyogQ2hhbmdlIHRvIHN0YXRlIDIuICovCgkJbmV4dF90aWNrID0gSFogLyAxMDsKCQlicmVhazsKCWNhc2UgMzoKCQkvKiBQdXQgb3V0IGZvdXIgdHVuaW5nIHBhcmFtZXRlcnMsIG9uZSBwZXIgMTAwbXNlYy4gKi8KCQlpZiAodHAtPnR3aXN0X2NvbCA9PSAwKQoJCQlSVExfVzE2IChGSUZPVE1TLCAwKTsKCQlSVExfVzMyIChQQVJBN2MsIHBhcmFtWyhpbnQpIHRwLT50d2lzdF9yb3ddCgkJCSBbKGludCkgdHAtPnR3aXN0X2NvbF0pOwoJCW5leHRfdGljayA9IEhaIC8gMTA7CgkJaWYgKCsrdHAtPnR3aXN0X2NvbCA+PSA0KSB7CgkJCS8qIEZvciBzaG9ydCBjYWJsZXMgd2UgYXJlIGRvbmUuCgkJCSAgIEZvciBsb25nIGNhYmxlcyAocm93ID09IDMpIGNoZWNrIGZvciBtaXN0dW5lLiAqLwoJCQl0cC0+dHdpc3RpZSA9CgkJCSAgICAodHAtPnR3aXN0X3JvdyA9PSAzKSA/IDQgOiAwOwoJCX0KCQlicmVhazsKCWNhc2UgNDoKCQkvKiBTcGVjaWFsIGNhc2UgZm9yIGxvbmcgY2FibGVzOiBjaGVjayBmb3IgbWlzdHVuZS4gKi8KCQlpZiAoKFJUTF9SMTYgKENTQ1IpICYKCQkgICAgIENTQ1JfTGlua1N0YXR1c0JpdHMpID09IDB4NzAwMCkgewoJCQl0cC0+dHdpc3RpZSA9IDA7CgkJCWJyZWFrOwoJCX0gZWxzZSB7CgkJCVJUTF9XMzIgKFBBUkE3YywgMHhmYjM4ZGUwMyk7CgkJCXRwLT50d2lzdGllID0gNTsKCQkJbmV4dF90aWNrID0gSFogLyAxMDsKCQl9CgkJYnJlYWs7CgljYXNlIDU6CgkJLyogUmV0dW5lIGZvciBzaG9ydGVyIGNhYmxlIChjb2x1bW4gMikuICovCgkJUlRMX1czMiAoRklGT1RNUywgMHgyMCk7CgkJUlRMX1czMiAoUEFSQTc4LCBQQVJBNzhfZGVmYXVsdCk7CgkJUlRMX1czMiAoUEFSQTdjLCBQQVJBN2NfZGVmYXVsdCk7CgkJUlRMX1czMiAoRklGT1RNUywgMHgwMCk7CgkJdHAtPnR3aXN0X3JvdyA9IDI7CgkJdHAtPnR3aXN0X2NvbCA9IDA7CgkJdHAtPnR3aXN0aWUgPSAzOwoJCW5leHRfdGljayA9IEhaIC8gMTA7CgkJYnJlYWs7CgoJZGVmYXVsdDoKCQkvKiBkbyBub3RoaW5nICovCgkJYnJlYWs7Cgl9Cn0KI2VuZGlmIC8qIENPTkZJR184MTM5VE9PX1RVTkVfVFdJU1RFUiAqLwoKc3RhdGljIGlubGluZSB2b2lkIHJ0bDgxMzlfdGhyZWFkX2l0ZXIgKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCgkJCQkgc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqdHAsCgkJCQkgdm9pZCBfX2lvbWVtICppb2FkZHIpCnsKCWludCBtaWlfbHBhOwoKCW1paV9scGEgPSBtZGlvX3JlYWQgKGRldiwgdHAtPnBoeXNbMF0sIE1JSV9MUEEpOwoKCWlmICghdHAtPm1paS5mb3JjZV9tZWRpYSAmJiBtaWlfbHBhICE9IDB4ZmZmZikgewoJCWludCBkdXBsZXggPSAobWlpX2xwYSAmIExQQV8xMDBGVUxMKQoJCSAgICB8fCAobWlpX2xwYSAmIDB4MDFDMCkgPT0gMHgwMDQwOwoJCWlmICh0cC0+bWlpLmZ1bGxfZHVwbGV4ICE9IGR1cGxleCkgewoJCQl0cC0+bWlpLmZ1bGxfZHVwbGV4ID0gZHVwbGV4OwoKCQkJaWYgKG1paV9scGEpIHsKCQkJCXByaW50ayAoS0VSTl9JTkZPCgkJCQkJIiVzOiBTZXR0aW5nICVzLWR1cGxleCBiYXNlZCBvbiBNSUkgIyVkIGxpbmsiCgkJCQkJIiBwYXJ0bmVyIGFiaWxpdHkgb2YgJTQuNHguXG4iLAoJCQkJCWRldi0+bmFtZSwKCQkJCQl0cC0+bWlpLmZ1bGxfZHVwbGV4ID8gImZ1bGwiIDogImhhbGYiLAoJCQkJCXRwLT5waHlzWzBdLCBtaWlfbHBhKTsKCQkJfSBlbHNlIHsKCQkJCXByaW50ayhLRVJOX0lORk8iJXM6IG1lZGlhIGlzIHVuY29ubmVjdGVkLCBsaW5rIGRvd24sIG9yIGluY29tcGF0aWJsZSBjb25uZWN0aW9uXG4iLAoJCQkJICAgICAgIGRldi0+bmFtZSk7CgkJCX0KI2lmIDAKCQkJUlRMX1c4IChDZmc5MzQ2LCBDZmc5MzQ2X1VubG9jayk7CgkJCVJUTF9XOCAoQ29uZmlnMSwgdHAtPm1paS5mdWxsX2R1cGxleCA/IDB4NjAgOiAweDIwKTsKCQkJUlRMX1c4IChDZmc5MzQ2LCBDZmc5MzQ2X0xvY2spOwojZW5kaWYKCQl9Cgl9CgoJbmV4dF90aWNrID0gSFogKiA2MDsKCglydGw4MTM5X3R1bmVfdHdpc3RlciAoZGV2LCB0cCk7CgoJRFBSSU5USyAoIiVzOiBNZWRpYSBzZWxlY3Rpb24gdGljaywgTGluayBwYXJ0bmVyICU0LjR4LlxuIiwKCQkgZGV2LT5uYW1lLCBSVExfUjE2IChOV2F5TFBBUikpOwoJRFBSSU5USyAoIiVzOiAgT3RoZXIgcmVnaXN0ZXJzIGFyZSBJbnRNYXNrICU0LjR4IEludFN0YXR1cyAlNC40eFxuIiwKCQkgZGV2LT5uYW1lLCBSVExfUjE2IChJbnRyTWFzayksIFJUTF9SMTYgKEludHJTdGF0dXMpKTsKCURQUklOVEsgKCIlczogIENoaXAgY29uZmlnICUyLjJ4ICUyLjJ4LlxuIiwKCQkgZGV2LT5uYW1lLCBSVExfUjggKENvbmZpZzApLAoJCSBSVExfUjggKENvbmZpZzEpKTsKfQoKc3RhdGljIHZvaWQgcnRsODEzOV90aHJlYWQgKHZvaWQgKl9kYXRhKQp7CglzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gX2RhdGE7CglzdHJ1Y3QgcnRsODEzOV9wcml2YXRlICp0cCA9IG5ldGRldl9wcml2KGRldik7Cgl1bnNpZ25lZCBsb25nIHRocl9kZWxheSA9IG5leHRfdGljazsKCglpZiAodHAtPndhdGNoZG9nX2ZpcmVkKSB7CgkJdHAtPndhdGNoZG9nX2ZpcmVkID0gMDsKCQlydGw4MTM5X3R4X3RpbWVvdXRfdGFzayhfZGF0YSk7Cgl9IGVsc2UgaWYgKHJ0bmxfc2hsb2NrX25vd2FpdCgpID09IDApIHsKCQlydGw4MTM5X3RocmVhZF9pdGVyIChkZXYsIHRwLCB0cC0+bW1pb19hZGRyKTsKCQlydG5sX3VubG9jayAoKTsKCX0gZWxzZSB7CgkJLyogdW5saWtlbHkgcmFjZS4gIG1pdGlnYXRlIHdpdGggZmFzdCBwb2xsLiAqLwoJCXRocl9kZWxheSA9IEhaIC8gMjsKCX0KCglzY2hlZHVsZV9kZWxheWVkX3dvcmsoJnRwLT50aHJlYWQsIHRocl9kZWxheSk7Cn0KCnN0YXRpYyB2b2lkIHJ0bDgxMzlfc3RhcnRfdGhyZWFkKHN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwKQp7Cgl0cC0+dHdpc3RpZSA9IDA7CglpZiAodHAtPmNoaXBzZXQgPT0gQ0hfODEzOV9LKQoJCXRwLT50d2lzdGllID0gMTsKCWVsc2UgaWYgKHRwLT5kcnZfZmxhZ3MgJiBIQVNfTE5LX0NITkcpCgkJcmV0dXJuOwoKCXRwLT5oYXZlX3RocmVhZCA9IDE7CgoJc2NoZWR1bGVfZGVsYXllZF93b3JrKCZ0cC0+dGhyZWFkLCBuZXh0X3RpY2spOwp9CgpzdGF0aWMgdm9pZCBydGw4MTM5X3N0b3BfdGhyZWFkKHN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwKQp7CglpZiAodHAtPmhhdmVfdGhyZWFkKSB7CgkJY2FuY2VsX3JlYXJtaW5nX2RlbGF5ZWRfd29yaygmdHAtPnRocmVhZCk7CgkJdHAtPmhhdmVfdGhyZWFkID0gMDsKCX0gZWxzZQoJCWZsdXNoX3NjaGVkdWxlZF93b3JrKCk7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCBydGw4MTM5X3R4X2NsZWFyIChzdHJ1Y3QgcnRsODEzOV9wcml2YXRlICp0cCkKewoJdHAtPmN1cl90eCA9IDA7Cgl0cC0+ZGlydHlfdHggPSAwOwoKCS8qIFhYWCBhY2NvdW50IGZvciB1bnNlbnQgVHggcGFja2V0cyBpbiB0cC0+c3RhdHMudHhfZHJvcHBlZCAqLwp9CgpzdGF0aWMgdm9pZCBydGw4MTM5X3R4X3RpbWVvdXRfdGFzayAodm9pZCAqX2RhdGEpCnsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSBfZGF0YTsKCXN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwID0gbmV0ZGV2X3ByaXYoZGV2KTsKCXZvaWQgX19pb21lbSAqaW9hZGRyID0gdHAtPm1taW9fYWRkcjsKCWludCBpOwoJdTggdG1wODsKCglwcmludGsgKEtFUk5fREVCVUcgIiVzOiBUcmFuc21pdCB0aW1lb3V0LCBzdGF0dXMgJTIuMnggJTQuNHggJTQuNHggIgoJCSJtZWRpYSAlMi4yeC5cbiIsIGRldi0+bmFtZSwgUlRMX1I4IChDaGlwQ21kKSwKCQlSVExfUjE2KEludHJTdGF0dXMpLCBSVExfUjE2KEludHJNYXNrKSwgUlRMX1I4KE1lZGlhU3RhdHVzKSk7CgkvKiBFbWl0IGluZm8gdG8gZmlndXJlIG91dCB3aGF0IHdlbnQgd3JvbmcuICovCglwcmludGsgKEtFUk5fREVCVUcgIiVzOiBUeCBxdWV1ZSBzdGFydCBlbnRyeSAlbGQgIGRpcnR5IGVudHJ5ICVsZC5cbiIsCgkJZGV2LT5uYW1lLCB0cC0+Y3VyX3R4LCB0cC0+ZGlydHlfdHgpOwoJZm9yIChpID0gMDsgaSA8IE5VTV9UWF9ERVNDOyBpKyspCgkJcHJpbnRrIChLRVJOX0RFQlVHICIlczogIFR4IGRlc2NyaXB0b3IgJWQgaXMgJTguOGx4LiVzXG4iLAoJCQlkZXYtPm5hbWUsIGksIFJUTF9SMzIgKFR4U3RhdHVzMCArIChpICogNCkpLAoJCQlpID09IHRwLT5kaXJ0eV90eCAlIE5VTV9UWF9ERVNDID8KCQkJCSIgKHF1ZXVlIGhlYWQpIiA6ICIiKTsKCgl0cC0+eHN0YXRzLnR4X3RpbWVvdXRzKys7CgoJLyogZGlzYWJsZSBUeCBBU0FQLCBpZiBub3QgYWxyZWFkeSAqLwoJdG1wOCA9IFJUTF9SOCAoQ2hpcENtZCk7CglpZiAodG1wOCAmIENtZFR4RW5iKQoJCVJUTF9XOCAoQ2hpcENtZCwgQ21kUnhFbmIpOwoKCXNwaW5fbG9ja19iaCgmdHAtPnJ4X2xvY2spOwoJLyogRGlzYWJsZSBpbnRlcnJ1cHRzIGJ5IGNsZWFyaW5nIHRoZSBpbnRlcnJ1cHQgbWFzay4gKi8KCVJUTF9XMTYgKEludHJNYXNrLCAweDAwMDApOwoKCS8qIFN0b3AgYSBzaGFyZWQgaW50ZXJydXB0IGZyb20gc2NhdmVuZ2luZyB3aGlsZSB3ZSBhcmUuICovCglzcGluX2xvY2tfaXJxKCZ0cC0+bG9jayk7CglydGw4MTM5X3R4X2NsZWFyICh0cCk7CglzcGluX3VubG9ja19pcnEoJnRwLT5sb2NrKTsKCgkvKiAuLi5hbmQgZmluYWxseSwgcmVzZXQgZXZlcnl0aGluZyAqLwoJaWYgKG5ldGlmX3J1bm5pbmcoZGV2KSkgewoJCXJ0bDgxMzlfaHdfc3RhcnQgKGRldik7CgkJbmV0aWZfd2FrZV9xdWV1ZSAoZGV2KTsKCX0KCXNwaW5fdW5sb2NrX2JoKCZ0cC0+cnhfbG9jayk7Cn0KCnN0YXRpYyB2b2lkIHJ0bDgxMzlfdHhfdGltZW91dCAoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKewoJc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqdHAgPSBuZXRkZXZfcHJpdihkZXYpOwoKCWlmICghdHAtPmhhdmVfdGhyZWFkKSB7CgkJSU5JVF9XT1JLKCZ0cC0+dGhyZWFkLCBydGw4MTM5X3R4X3RpbWVvdXRfdGFzaywgZGV2KTsKCQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJnRwLT50aHJlYWQsIG5leHRfdGljayk7Cgl9IGVsc2UKCQl0cC0+d2F0Y2hkb2dfZmlyZWQgPSAxOwoKfQoKc3RhdGljIGludCBydGw4MTM5X3N0YXJ0X3htaXQgKHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwID0gbmV0ZGV2X3ByaXYoZGV2KTsKCXZvaWQgX19pb21lbSAqaW9hZGRyID0gdHAtPm1taW9fYWRkcjsKCXVuc2lnbmVkIGludCBlbnRyeTsKCXVuc2lnbmVkIGludCBsZW4gPSBza2ItPmxlbjsKCgkvKiBDYWxjdWxhdGUgdGhlIG5leHQgVHggZGVzY3JpcHRvciBlbnRyeS4gKi8KCWVudHJ5ID0gdHAtPmN1cl90eCAlIE5VTV9UWF9ERVNDOwoKCS8qIE5vdGU6IHRoZSBjaGlwIGRvZXNuJ3QgaGF2ZSBhdXRvLXBhZCEgKi8KCWlmIChsaWtlbHkobGVuIDwgVFhfQlVGX1NJWkUpKSB7CgkJaWYgKGxlbiA8IEVUSF9aTEVOKQoJCQltZW1zZXQodHAtPnR4X2J1ZltlbnRyeV0sIDAsIEVUSF9aTEVOKTsKCQlza2JfY29weV9hbmRfY3N1bV9kZXYoc2tiLCB0cC0+dHhfYnVmW2VudHJ5XSk7CgkJZGV2X2tmcmVlX3NrYihza2IpOwoJfSBlbHNlIHsKCQlkZXZfa2ZyZWVfc2tiKHNrYik7CgkJdHAtPnN0YXRzLnR4X2Ryb3BwZWQrKzsKCQlyZXR1cm4gMDsKCX0KCglzcGluX2xvY2tfaXJxKCZ0cC0+bG9jayk7CglSVExfVzMyX0YgKFR4U3RhdHVzMCArIChlbnRyeSAqIHNpemVvZiAodTMyKSksCgkJICAgdHAtPnR4X2ZsYWcgfCBtYXgobGVuLCAodW5zaWduZWQgaW50KUVUSF9aTEVOKSk7CgoJZGV2LT50cmFuc19zdGFydCA9IGppZmZpZXM7CgoJdHAtPmN1cl90eCsrOwoJd21iKCk7CgoJaWYgKCh0cC0+Y3VyX3R4IC0gTlVNX1RYX0RFU0MpID09IHRwLT5kaXJ0eV90eCkKCQluZXRpZl9zdG9wX3F1ZXVlIChkZXYpOwoJc3Bpbl91bmxvY2tfaXJxKCZ0cC0+bG9jayk7CgoJaWYgKG5ldGlmX21zZ190eF9xdWV1ZWQodHApKQoJCXByaW50ayAoS0VSTl9ERUJVRyAiJXM6IFF1ZXVlZCBUeCBwYWNrZXQgc2l6ZSAldSB0byBzbG90ICVkLlxuIiwKCQkJZGV2LT5uYW1lLCBsZW4sIGVudHJ5KTsKCglyZXR1cm4gMDsKfQoKCnN0YXRpYyB2b2lkIHJ0bDgxMzlfdHhfaW50ZXJydXB0IChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LAoJCQkJICBzdHJ1Y3QgcnRsODEzOV9wcml2YXRlICp0cCwKCQkJCSAgdm9pZCBfX2lvbWVtICppb2FkZHIpCnsKCXVuc2lnbmVkIGxvbmcgZGlydHlfdHgsIHR4X2xlZnQ7CgoJYXNzZXJ0IChkZXYgIT0gTlVMTCk7Cglhc3NlcnQgKGlvYWRkciAhPSBOVUxMKTsKCglkaXJ0eV90eCA9IHRwLT5kaXJ0eV90eDsKCXR4X2xlZnQgPSB0cC0+Y3VyX3R4IC0gZGlydHlfdHg7Cgl3aGlsZSAodHhfbGVmdCA+IDApIHsKCQlpbnQgZW50cnkgPSBkaXJ0eV90eCAlIE5VTV9UWF9ERVNDOwoJCWludCB0eHN0YXR1czsKCgkJdHhzdGF0dXMgPSBSVExfUjMyIChUeFN0YXR1czAgKyAoZW50cnkgKiBzaXplb2YgKHUzMikpKTsKCgkJaWYgKCEodHhzdGF0dXMgJiAoVHhTdGF0T0sgfCBUeFVuZGVycnVuIHwgVHhBYm9ydGVkKSkpCgkJCWJyZWFrOwkvKiBJdCBzdGlsbCBoYXNuJ3QgYmVlbiBUeGVkICovCgoJCS8qIE5vdGU6IFR4Q2Fycmllckxvc3QgaXMgYWx3YXlzIGFzc2VydGVkIGF0IDEwMG1icHMuICovCgkJaWYgKHR4c3RhdHVzICYgKFR4T3V0T2ZXaW5kb3cgfCBUeEFib3J0ZWQpKSB7CgkJCS8qIFRoZXJlIHdhcyBhbiBtYWpvciBlcnJvciwgbG9nIGl0LiAqLwoJCQlpZiAobmV0aWZfbXNnX3R4X2Vycih0cCkpCgkJCQlwcmludGsoS0VSTl9ERUJVRyAiJXM6IFRyYW5zbWl0IGVycm9yLCBUeCBzdGF0dXMgJTguOHguXG4iLAoJCQkJCWRldi0+bmFtZSwgdHhzdGF0dXMpOwoJCQl0cC0+c3RhdHMudHhfZXJyb3JzKys7CgkJCWlmICh0eHN0YXR1cyAmIFR4QWJvcnRlZCkgewoJCQkJdHAtPnN0YXRzLnR4X2Fib3J0ZWRfZXJyb3JzKys7CgkJCQlSVExfVzMyIChUeENvbmZpZywgVHhDbGVhckFidCk7CgkJCQlSVExfVzE2IChJbnRyU3RhdHVzLCBUeEVycik7CgkJCQl3bWIoKTsKCQkJfQoJCQlpZiAodHhzdGF0dXMgJiBUeENhcnJpZXJMb3N0KQoJCQkJdHAtPnN0YXRzLnR4X2NhcnJpZXJfZXJyb3JzKys7CgkJCWlmICh0eHN0YXR1cyAmIFR4T3V0T2ZXaW5kb3cpCgkJCQl0cC0+c3RhdHMudHhfd2luZG93X2Vycm9ycysrOwoJCX0gZWxzZSB7CgkJCWlmICh0eHN0YXR1cyAmIFR4VW5kZXJydW4pIHsKCQkJCS8qIEFkZCA2NCB0byB0aGUgVHggRklGTyB0aHJlc2hvbGQuICovCgkJCQlpZiAodHAtPnR4X2ZsYWcgPCAweDAwMzAwMDAwKQoJCQkJCXRwLT50eF9mbGFnICs9IDB4MDAwMjAwMDA7CgkJCQl0cC0+c3RhdHMudHhfZmlmb19lcnJvcnMrKzsKCQkJfQoJCQl0cC0+c3RhdHMuY29sbGlzaW9ucyArPSAodHhzdGF0dXMgPj4gMjQpICYgMTU7CgkJCXRwLT5zdGF0cy50eF9ieXRlcyArPSB0eHN0YXR1cyAmIDB4N2ZmOwoJCQl0cC0+c3RhdHMudHhfcGFja2V0cysrOwoJCX0KCgkJZGlydHlfdHgrKzsKCQl0eF9sZWZ0LS07Cgl9CgojaWZuZGVmIFJUTDgxMzlfTkRFQlVHCglpZiAodHAtPmN1cl90eCAtIGRpcnR5X3R4ID4gTlVNX1RYX0RFU0MpIHsKCQlwcmludGsgKEtFUk5fRVJSICIlczogT3V0LW9mLXN5bmMgZGlydHkgcG9pbnRlciwgJWxkIHZzLiAlbGQuXG4iLAoJCSAgICAgICAgZGV2LT5uYW1lLCBkaXJ0eV90eCwgdHAtPmN1cl90eCk7CgkJZGlydHlfdHggKz0gTlVNX1RYX0RFU0M7Cgl9CiNlbmRpZiAvKiBSVEw4MTM5X05ERUJVRyAqLwoKCS8qIG9ubHkgd2FrZSB0aGUgcXVldWUgaWYgd2UgZGlkIHdvcmssIGFuZCB0aGUgcXVldWUgaXMgc3RvcHBlZCAqLwoJaWYgKHRwLT5kaXJ0eV90eCAhPSBkaXJ0eV90eCkgewoJCXRwLT5kaXJ0eV90eCA9IGRpcnR5X3R4OwoJCW1iKCk7CgkJbmV0aWZfd2FrZV9xdWV1ZSAoZGV2KTsKCX0KfQoKCi8qIFRPRE86IGNsZWFuIHRoaXMgdXAhICBSeCByZXNldCBuZWVkIG5vdCBiZSB0aGlzIGludGVuc2l2ZSAqLwpzdGF0aWMgdm9pZCBydGw4MTM5X3J4X2VyciAodTMyIHJ4X3N0YXR1cywgc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKCQkJICAgIHN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwLCB2b2lkIF9faW9tZW0gKmlvYWRkcikKewoJdTggdG1wODsKI2lmZGVmIENPTkZJR184MTM5X09MRF9SWF9SRVNFVAoJaW50IHRtcF93b3JrOwojZW5kaWYKCglpZiAobmV0aWZfbXNnX3J4X2VyciAodHApKSAKCQlwcmludGsoS0VSTl9ERUJVRyAiJXM6IEV0aGVybmV0IGZyYW1lIGhhZCBlcnJvcnMsIHN0YXR1cyAlOC44eC5cbiIsCgkJCWRldi0+bmFtZSwgcnhfc3RhdHVzKTsKCXRwLT5zdGF0cy5yeF9lcnJvcnMrKzsKCWlmICghKHJ4X3N0YXR1cyAmIFJ4U3RhdHVzT0spKSB7CgkJaWYgKHJ4X3N0YXR1cyAmIFJ4VG9vTG9uZykgewoJCQlEUFJJTlRLICgiJXM6IE92ZXJzaXplZCBFdGhlcm5ldCBmcmFtZSwgc3RhdHVzICU0LjR4IVxuIiwKCQkJIAlkZXYtPm5hbWUsIHJ4X3N0YXR1cyk7CgkJCS8qIEEuQy46IFRoZSBjaGlwIGhhbmdzIGhlcmUuICovCgkJfQoJCWlmIChyeF9zdGF0dXMgJiAoUnhCYWRTeW1ib2wgfCBSeEJhZEFsaWduKSkKCQkJdHAtPnN0YXRzLnJ4X2ZyYW1lX2Vycm9ycysrOwoJCWlmIChyeF9zdGF0dXMgJiAoUnhSdW50IHwgUnhUb29Mb25nKSkKCQkJdHAtPnN0YXRzLnJ4X2xlbmd0aF9lcnJvcnMrKzsKCQlpZiAocnhfc3RhdHVzICYgUnhDUkNFcnIpCgkJCXRwLT5zdGF0cy5yeF9jcmNfZXJyb3JzKys7Cgl9IGVsc2UgewoJCXRwLT54c3RhdHMucnhfbG9zdF9pbl9yaW5nKys7Cgl9CgojaWZuZGVmIENPTkZJR184MTM5X09MRF9SWF9SRVNFVAoJdG1wOCA9IFJUTF9SOCAoQ2hpcENtZCk7CglSVExfVzggKENoaXBDbWQsIHRtcDggJiB+Q21kUnhFbmIpOwoJUlRMX1c4IChDaGlwQ21kLCB0bXA4KTsKCVJUTF9XMzIgKFJ4Q29uZmlnLCB0cC0+cnhfY29uZmlnKTsKCXRwLT5jdXJfcnggPSAwOwojZWxzZQoJLyogUmVzZXQgdGhlIHJlY2VpdmVyLCBiYXNlZCBvbiBSZWFsVGVrIHJlY29tbWVuZGF0aW9uLiAoQnVnPykgKi8KCgkvKiBkaXNhYmxlIHJlY2VpdmUgKi8KCVJUTF9XOF9GIChDaGlwQ21kLCBDbWRUeEVuYik7Cgl0bXBfd29yayA9IDIwMDsKCXdoaWxlICgtLXRtcF93b3JrID4gMCkgewoJCXVkZWxheSgxKTsKCQl0bXA4ID0gUlRMX1I4IChDaGlwQ21kKTsKCQlpZiAoISh0bXA4ICYgQ21kUnhFbmIpKQoJCQlicmVhazsKCX0KCWlmICh0bXBfd29yayA8PSAwKQoJCXByaW50ayAoS0VSTl9XQVJOSU5HIFBGWCAicnggc3RvcCB3YWl0IHRvbyBsb25nXG4iKTsKCS8qIHJlc3RhcnQgcmVjZWl2ZSAqLwoJdG1wX3dvcmsgPSAyMDA7Cgl3aGlsZSAoLS10bXBfd29yayA+IDApIHsKCQlSVExfVzhfRiAoQ2hpcENtZCwgQ21kUnhFbmIgfCBDbWRUeEVuYik7CgkJdWRlbGF5KDEpOwoJCXRtcDggPSBSVExfUjggKENoaXBDbWQpOwoJCWlmICgodG1wOCAmIENtZFJ4RW5iKSAmJiAodG1wOCAmIENtZFR4RW5iKSkKCQkJYnJlYWs7Cgl9CglpZiAodG1wX3dvcmsgPD0gMCkKCQlwcmludGsgKEtFUk5fV0FSTklORyBQRlggInR4L3J4IGVuYWJsZSB3YWl0IHRvbyBsb25nXG4iKTsKCgkvKiBhbmQgcmVpbml0aWFsaXplIGFsbCByeCByZWxhdGVkIHJlZ2lzdGVycyAqLwoJUlRMX1c4X0YgKENmZzkzNDYsIENmZzkzNDZfVW5sb2NrKTsKCS8qIE11c3QgZW5hYmxlIFR4L1J4IGJlZm9yZSBzZXR0aW5nIHRyYW5zZmVyIHRocmVzaG9sZHMhICovCglSVExfVzggKENoaXBDbWQsIENtZFJ4RW5iIHwgQ21kVHhFbmIpOwoKCXRwLT5yeF9jb25maWcgPSBydGw4MTM5X3J4X2NvbmZpZyB8IEFjY2VwdEJyb2FkY2FzdCB8IEFjY2VwdE15UGh5czsKCVJUTF9XMzIgKFJ4Q29uZmlnLCB0cC0+cnhfY29uZmlnKTsKCXRwLT5jdXJfcnggPSAwOwoKCURQUklOVEsoImluaXQgYnVmZmVyIGFkZHJlc3Nlc1xuIik7CgoJLyogTG9jayBDb25maWdbMDEyMzRdIGFuZCBCTUNSIHJlZ2lzdGVyIHdyaXRlcyAqLwoJUlRMX1c4IChDZmc5MzQ2LCBDZmc5MzQ2X0xvY2spOwoKCS8qIGluaXQgUnggcmluZyBidWZmZXIgRE1BIGFkZHJlc3MgKi8KCVJUTF9XMzJfRiAoUnhCdWYsIHRwLT5yeF9yaW5nX2RtYSk7CgoJLyogQS5DLjogUmVzZXQgdGhlIG11bHRpY2FzdCBsaXN0LiAqLwoJX19zZXRfcnhfbW9kZSAoZGV2KTsKI2VuZGlmCn0KCiNpZiBSWF9CVUZfSURYID09IDMKc3RhdGljIF9faW5saW5lX18gdm9pZCB3cmFwX2NvcHkoc3RydWN0IHNrX2J1ZmYgKnNrYiwgY29uc3QgdW5zaWduZWQgY2hhciAqcmluZywKCQkJCSB1MzIgb2Zmc2V0LCB1bnNpZ25lZCBpbnQgc2l6ZSkKewoJdTMyIGxlZnQgPSBSWF9CVUZfTEVOIC0gb2Zmc2V0OwoKCWlmIChzaXplID4gbGVmdCkgewoJCW1lbWNweShza2ItPmRhdGEsIHJpbmcgKyBvZmZzZXQsIGxlZnQpOwoJCW1lbWNweShza2ItPmRhdGErbGVmdCwgcmluZywgc2l6ZSAtIGxlZnQpOwoJfSBlbHNlCgkJbWVtY3B5KHNrYi0+ZGF0YSwgcmluZyArIG9mZnNldCwgc2l6ZSk7Cn0KI2VuZGlmCgpzdGF0aWMgdm9pZCBydGw4MTM5X2lzcl9hY2soc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqdHApCnsKCXZvaWQgX19pb21lbSAqaW9hZGRyID0gdHAtPm1taW9fYWRkcjsKCXUxNiBzdGF0dXM7CgoJc3RhdHVzID0gUlRMX1IxNiAoSW50clN0YXR1cykgJiBSeEFja0JpdHM7CgoJLyogQ2xlYXIgb3V0IGVycm9ycyBhbmQgcmVjZWl2ZSBpbnRlcnJ1cHRzICovCglpZiAobGlrZWx5KHN0YXR1cyAhPSAwKSkgewoJCWlmICh1bmxpa2VseShzdGF0dXMgJiAoUnhGSUZPT3ZlciB8IFJ4T3ZlcmZsb3cpKSkgewoJCQl0cC0+c3RhdHMucnhfZXJyb3JzKys7CgkJCWlmIChzdGF0dXMgJiBSeEZJRk9PdmVyKQoJCQkJdHAtPnN0YXRzLnJ4X2ZpZm9fZXJyb3JzKys7CgkJfQoJCVJUTF9XMTZfRiAoSW50clN0YXR1cywgUnhBY2tCaXRzKTsKCX0KfQoKc3RhdGljIGludCBydGw4MTM5X3J4KHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIHN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwLAoJCSAgICAgIGludCBidWRnZXQpCnsKCXZvaWQgX19pb21lbSAqaW9hZGRyID0gdHAtPm1taW9fYWRkcjsKCWludCByZWNlaXZlZCA9IDA7Cgl1bnNpZ25lZCBjaGFyICpyeF9yaW5nID0gdHAtPnJ4X3Jpbmc7Cgl1bnNpZ25lZCBpbnQgY3VyX3J4ID0gdHAtPmN1cl9yeDsKCXVuc2lnbmVkIGludCByeF9zaXplID0gMDsKCglEUFJJTlRLICgiJXM6IEluIHJ0bDgxMzlfcngoKSwgY3VycmVudCAlNC40eCBCdWZBZGRyICU0LjR4LCIKCQkgIiBmcmVlIHRvICU0LjR4LCBDbWQgJTIuMnguXG4iLCBkZXYtPm5hbWUsICh1MTYpY3VyX3J4LAoJCSBSVExfUjE2IChSeEJ1ZkFkZHIpLAoJCSBSVExfUjE2IChSeEJ1ZlB0ciksIFJUTF9SOCAoQ2hpcENtZCkpOwoKCXdoaWxlIChuZXRpZl9ydW5uaW5nKGRldikgJiYgcmVjZWl2ZWQgPCBidWRnZXQgCgkgICAgICAgJiYgKFJUTF9SOCAoQ2hpcENtZCkgJiBSeEJ1ZkVtcHR5KSA9PSAwKSB7CgkJdTMyIHJpbmdfb2Zmc2V0ID0gY3VyX3J4ICUgUlhfQlVGX0xFTjsKCQl1MzIgcnhfc3RhdHVzOwoJCXVuc2lnbmVkIGludCBwa3Rfc2l6ZTsKCQlzdHJ1Y3Qgc2tfYnVmZiAqc2tiOwoKCQlybWIoKTsKCgkJLyogcmVhZCBzaXplK3N0YXR1cyBvZiBuZXh0IGZyYW1lIGZyb20gRE1BIHJpbmcgYnVmZmVyICovCgkJcnhfc3RhdHVzID0gbGUzMl90b19jcHUgKCoodTMyICopIChyeF9yaW5nICsgcmluZ19vZmZzZXQpKTsKCQlyeF9zaXplID0gcnhfc3RhdHVzID4+IDE2OwoJCXBrdF9zaXplID0gcnhfc2l6ZSAtIDQ7CgoJCWlmIChuZXRpZl9tc2dfcnhfc3RhdHVzKHRwKSkKCQkJcHJpbnRrKEtFUk5fREVCVUcgIiVzOiAgcnRsODEzOV9yeCgpIHN0YXR1cyAlNC40eCwgc2l6ZSAlNC40eCwiCgkJCQkiIGN1ciAlNC40eC5cbiIsIGRldi0+bmFtZSwgcnhfc3RhdHVzLAoJCQkgcnhfc2l6ZSwgY3VyX3J4KTsKI2lmIFJUTDgxMzlfREVCVUcgPiAyCgkJewoJCQlpbnQgaTsKCQkJRFBSSU5USyAoIiVzOiBGcmFtZSBjb250ZW50cyAiLCBkZXYtPm5hbWUpOwoJCQlmb3IgKGkgPSAwOyBpIDwgNzA7IGkrKykKCQkJCXByaW50ayAoIiAlMi4yeCIsCgkJCQkJcnhfcmluZ1tyaW5nX29mZnNldCArIGldKTsKCQkJcHJpbnRrICgiLlxuIik7CgkJfQojZW5kaWYKCgkJLyogUGFja2V0IGNvcHkgZnJvbSBGSUZPIHN0aWxsIGluIHByb2dyZXNzLgoJCSAqIFRoZW9yZXRpY2FsbHksIHRoaXMgc2hvdWxkIG5ldmVyIGhhcHBlbgoJCSAqIHNpbmNlIEVhcmx5UnggaXMgZGlzYWJsZWQuCgkJICovCgkJaWYgKHVubGlrZWx5KHJ4X3NpemUgPT0gMHhmZmYwKSkgewoJCQlpZiAoIXRwLT5maWZvX2NvcHlfdGltZW91dCkKCQkJCXRwLT5maWZvX2NvcHlfdGltZW91dCA9IGppZmZpZXMgKyAyOwoJCQllbHNlIGlmICh0aW1lX2FmdGVyKGppZmZpZXMsIHRwLT5maWZvX2NvcHlfdGltZW91dCkpIHsKCQkJCURQUklOVEsgKCIlczogaHVuZyBGSUZPLiBSZXNldC4iLCBkZXYtPm5hbWUpOwoJCQkJcnhfc2l6ZSA9IDA7CgkJCQlnb3RvIG5vX2Vhcmx5X3J4OwoJCQl9CgkJCWlmIChuZXRpZl9tc2dfaW50cih0cCkpIHsKCQkJCXByaW50ayhLRVJOX0RFQlVHICIlczogZmlmbyBjb3B5IGluIHByb2dyZXNzLiIsCgkJCQkgICAgICAgZGV2LT5uYW1lKTsKCQkJfQoJCQl0cC0+eHN0YXRzLmVhcmx5X3J4Kys7CgkJCWJyZWFrOwoJCX0KCm5vX2Vhcmx5X3J4OgoJCXRwLT5maWZvX2NvcHlfdGltZW91dCA9IDA7CgoJCS8qIElmIFJ4IGVyciBvciBpbnZhbGlkIHJ4X3NpemUvcnhfc3RhdHVzIHJlY2VpdmVkCgkJICogKHdoaWNoIGhhcHBlbnMgaWYgd2UgZ2V0IGxvc3QgaW4gdGhlIHJpbmcpLAoJCSAqIFJ4IHByb2Nlc3MgZ2V0cyByZXNldCwgc28gd2UgYWJvcnQgYW55IGZ1cnRoZXIKCQkgKiBSeCBwcm9jZXNzaW5nLgoJCSAqLwoJCWlmICh1bmxpa2VseSgocnhfc2l6ZSA+IChNQVhfRVRIX0ZSQU1FX1NJWkUrNCkpIHx8CgkJCSAgICAgKHJ4X3NpemUgPCA4KSB8fAoJCQkgICAgICghKHJ4X3N0YXR1cyAmIFJ4U3RhdHVzT0spKSkpIHsKCQkJcnRsODEzOV9yeF9lcnIgKHJ4X3N0YXR1cywgZGV2LCB0cCwgaW9hZGRyKTsKCQkJcmVjZWl2ZWQgPSAtMTsKCQkJZ290byBvdXQ7CgkJfQoKCQkvKiBNYWxsb2MgdXAgbmV3IGJ1ZmZlciwgY29tcGF0aWJsZSB3aXRoIG5ldC0yZS4gKi8KCQkvKiBPbWl0IHRoZSBmb3VyIG9jdGV0IENSQyBmcm9tIHRoZSBsZW5ndGguICovCgoJCXNrYiA9IGRldl9hbGxvY19za2IgKHBrdF9zaXplICsgMik7CgkJaWYgKGxpa2VseShza2IpKSB7CgkJCXNrYi0+ZGV2ID0gZGV2OwoJCQlza2JfcmVzZXJ2ZSAoc2tiLCAyKTsJLyogMTYgYnl0ZSBhbGlnbiB0aGUgSVAgZmllbGRzLiAqLwojaWYgUlhfQlVGX0lEWCA9PSAzCgkJCXdyYXBfY29weShza2IsIHJ4X3JpbmcsIHJpbmdfb2Zmc2V0KzQsIHBrdF9zaXplKTsKI2Vsc2UKCQkJZXRoX2NvcHlfYW5kX3N1bSAoc2tiLCAmcnhfcmluZ1tyaW5nX29mZnNldCArIDRdLCBwa3Rfc2l6ZSwgMCk7CiNlbmRpZgoJCQlza2JfcHV0IChza2IsIHBrdF9zaXplKTsKCgkJCXNrYi0+cHJvdG9jb2wgPSBldGhfdHlwZV90cmFucyAoc2tiLCBkZXYpOwoKCQkJZGV2LT5sYXN0X3J4ID0gamlmZmllczsKCQkJdHAtPnN0YXRzLnJ4X2J5dGVzICs9IHBrdF9zaXplOwoJCQl0cC0+c3RhdHMucnhfcGFja2V0cysrOwoKCQkJbmV0aWZfcmVjZWl2ZV9za2IgKHNrYik7CgkJfSBlbHNlIHsKCQkJaWYgKG5ldF9yYXRlbGltaXQoKSkgCgkJCQlwcmludGsgKEtFUk5fV0FSTklORwoJCQkJCSIlczogTWVtb3J5IHNxdWVlemUsIGRyb3BwaW5nIHBhY2tldC5cbiIsCgkJCQkJZGV2LT5uYW1lKTsKCQkJdHAtPnN0YXRzLnJ4X2Ryb3BwZWQrKzsKCQl9CgkJcmVjZWl2ZWQrKzsKCgkJY3VyX3J4ID0gKGN1cl9yeCArIHJ4X3NpemUgKyA0ICsgMykgJiB+MzsKCQlSVExfVzE2IChSeEJ1ZlB0ciwgKHUxNikgKGN1cl9yeCAtIDE2KSk7CgoJCXJ0bDgxMzlfaXNyX2Fjayh0cCk7Cgl9CgoJaWYgKHVubGlrZWx5KCFyZWNlaXZlZCB8fCByeF9zaXplID09IDB4ZmZmMCkpCgkJcnRsODEzOV9pc3JfYWNrKHRwKTsKCiNpZiBSVEw4MTM5X0RFQlVHID4gMQoJRFBSSU5USyAoIiVzOiBEb25lIHJ0bDgxMzlfcngoKSwgY3VycmVudCAlNC40eCBCdWZBZGRyICU0LjR4LCIKCQkgIiBmcmVlIHRvICU0LjR4LCBDbWQgJTIuMnguXG4iLCBkZXYtPm5hbWUsIGN1cl9yeCwKCQkgUlRMX1IxNiAoUnhCdWZBZGRyKSwKCQkgUlRMX1IxNiAoUnhCdWZQdHIpLCBSVExfUjggKENoaXBDbWQpKTsKI2VuZGlmCgoJdHAtPmN1cl9yeCA9IGN1cl9yeDsKCgkvKgoJICogVGhlIHJlY2VpdmUgYnVmZmVyIHNob3VsZCBiZSBtb3N0bHkgZW1wdHkuCgkgKiBUZWxsIE5BUEkgdG8gcmVlbmFibGUgdGhlIFJ4IGlycS4KCSAqLwoJaWYgKHRwLT5maWZvX2NvcHlfdGltZW91dCkKCQlyZWNlaXZlZCA9IGJ1ZGdldDsKCm91dDoKCXJldHVybiByZWNlaXZlZDsKfQoKCnN0YXRpYyB2b2lkIHJ0bDgxMzlfd2VpcmRfaW50ZXJydXB0IChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LAoJCQkJICAgICBzdHJ1Y3QgcnRsODEzOV9wcml2YXRlICp0cCwKCQkJCSAgICAgdm9pZCBfX2lvbWVtICppb2FkZHIsCgkJCQkgICAgIGludCBzdGF0dXMsIGludCBsaW5rX2NoYW5nZWQpCnsKCURQUklOVEsgKCIlczogQWJub3JtYWwgaW50ZXJydXB0LCBzdGF0dXMgJTguOHguXG4iLAoJCSBkZXYtPm5hbWUsIHN0YXR1cyk7CgoJYXNzZXJ0IChkZXYgIT0gTlVMTCk7Cglhc3NlcnQgKHRwICE9IE5VTEwpOwoJYXNzZXJ0IChpb2FkZHIgIT0gTlVMTCk7CgoJLyogVXBkYXRlIHRoZSBlcnJvciBjb3VudC4gKi8KCXRwLT5zdGF0cy5yeF9taXNzZWRfZXJyb3JzICs9IFJUTF9SMzIgKFJ4TWlzc2VkKTsKCVJUTF9XMzIgKFJ4TWlzc2VkLCAwKTsKCglpZiAoKHN0YXR1cyAmIFJ4VW5kZXJydW4pICYmIGxpbmtfY2hhbmdlZCAmJgoJICAgICh0cC0+ZHJ2X2ZsYWdzICYgSEFTX0xOS19DSE5HKSkgewoJCXJ0bF9jaGVja19tZWRpYShkZXYsIDApOwoJCXN0YXR1cyAmPSB+UnhVbmRlcnJ1bjsKCX0KCglpZiAoc3RhdHVzICYgKFJ4VW5kZXJydW4gfCBSeEVycikpCgkJdHAtPnN0YXRzLnJ4X2Vycm9ycysrOwoKCWlmIChzdGF0dXMgJiBQQ1NUaW1lb3V0KQoJCXRwLT5zdGF0cy5yeF9sZW5ndGhfZXJyb3JzKys7CglpZiAoc3RhdHVzICYgUnhVbmRlcnJ1bikKCQl0cC0+c3RhdHMucnhfZmlmb19lcnJvcnMrKzsKCWlmIChzdGF0dXMgJiBQQ0lFcnIpIHsKCQl1MTYgcGNpX2NtZF9zdGF0dXM7CgkJcGNpX3JlYWRfY29uZmlnX3dvcmQgKHRwLT5wY2lfZGV2LCBQQ0lfU1RBVFVTLCAmcGNpX2NtZF9zdGF0dXMpOwoJCXBjaV93cml0ZV9jb25maWdfd29yZCAodHAtPnBjaV9kZXYsIFBDSV9TVEFUVVMsIHBjaV9jbWRfc3RhdHVzKTsKCgkJcHJpbnRrIChLRVJOX0VSUiAiJXM6IFBDSSBCdXMgZXJyb3IgJTQuNHguXG4iLAoJCQlkZXYtPm5hbWUsIHBjaV9jbWRfc3RhdHVzKTsKCX0KfQoKc3RhdGljIGludCBydGw4MTM5X3BvbGwoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgaW50ICpidWRnZXQpCnsKCXN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwID0gbmV0ZGV2X3ByaXYoZGV2KTsKCXZvaWQgX19pb21lbSAqaW9hZGRyID0gdHAtPm1taW9fYWRkcjsKCWludCBvcmlnX2J1ZGdldCA9IG1pbigqYnVkZ2V0LCBkZXYtPnF1b3RhKTsKCWludCBkb25lID0gMTsKCglzcGluX2xvY2soJnRwLT5yeF9sb2NrKTsKCWlmIChsaWtlbHkoUlRMX1IxNihJbnRyU3RhdHVzKSAmIFJ4QWNrQml0cykpIHsKCQlpbnQgd29ya19kb25lOwoKCQl3b3JrX2RvbmUgPSBydGw4MTM5X3J4KGRldiwgdHAsIG9yaWdfYnVkZ2V0KTsKCQlpZiAobGlrZWx5KHdvcmtfZG9uZSA+IDApKSB7CgkJCSpidWRnZXQgLT0gd29ya19kb25lOwoJCQlkZXYtPnF1b3RhIC09IHdvcmtfZG9uZTsKCQkJZG9uZSA9ICh3b3JrX2RvbmUgPCBvcmlnX2J1ZGdldCk7CgkJfQoJfQoKCWlmIChkb25lKSB7CgkJLyoKCQkgKiBPcmRlciBpcyBpbXBvcnRhbnQgc2luY2UgZGF0YSBjYW4gZ2V0IGludGVycnVwdGVkCgkJICogYWdhaW4gd2hlbiB3ZSB0aGluayB3ZSBhcmUgZG9uZS4KCQkgKi8KCQlsb2NhbF9pcnFfZGlzYWJsZSgpOwoJCVJUTF9XMTZfRihJbnRyTWFzaywgcnRsODEzOV9pbnRyX21hc2spOwoJCV9fbmV0aWZfcnhfY29tcGxldGUoZGV2KTsKCQlsb2NhbF9pcnFfZW5hYmxlKCk7Cgl9CglzcGluX3VubG9jaygmdHAtPnJ4X2xvY2spOwoKCXJldHVybiAhZG9uZTsKfQoKLyogVGhlIGludGVycnVwdCBoYW5kbGVyIGRvZXMgYWxsIG9mIHRoZSBSeCB0aHJlYWQgd29yayBhbmQgY2xlYW5zIHVwCiAgIGFmdGVyIHRoZSBUeCB0aHJlYWQuICovCnN0YXRpYyBpcnFyZXR1cm5fdCBydGw4MTM5X2ludGVycnVwdCAoaW50IGlycSwgdm9pZCAqZGV2X2luc3RhbmNlLAoJCQkgICAgICAgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCnsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSAoc3RydWN0IG5ldF9kZXZpY2UgKikgZGV2X2luc3RhbmNlOwoJc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqdHAgPSBuZXRkZXZfcHJpdihkZXYpOwoJdm9pZCBfX2lvbWVtICppb2FkZHIgPSB0cC0+bW1pb19hZGRyOwoJdTE2IHN0YXR1cywgYWNrc3RhdDsKCWludCBsaW5rX2NoYW5nZWQgPSAwOyAvKiBhdm9pZCBib2d1cyAidW5pbml0IiB3YXJuaW5nICovCglpbnQgaGFuZGxlZCA9IDA7CgoJc3Bpbl9sb2NrICgmdHAtPmxvY2spOwoJc3RhdHVzID0gUlRMX1IxNiAoSW50clN0YXR1cyk7CgoJLyogc2hhcmVkIGlycT8gKi8KCWlmICh1bmxpa2VseSgoc3RhdHVzICYgcnRsODEzOV9pbnRyX21hc2spID09IDApKSAKCQlnb3RvIG91dDsKCgloYW5kbGVkID0gMTsKCgkvKiBoL3cgbm8gbG9uZ2VyIHByZXNlbnQgKGhvdHBsdWc/KSBvciBtYWpvciBlcnJvciwgYmFpbCAqLwoJaWYgKHVubGlrZWx5KHN0YXR1cyA9PSAweEZGRkYpKSAKCQlnb3RvIG91dDsKCgkvKiBjbG9zZSBwb3NzaWJsZSByYWNlJ3Mgd2l0aCBkZXZfY2xvc2UgKi8KCWlmICh1bmxpa2VseSghbmV0aWZfcnVubmluZyhkZXYpKSkgewoJCVJUTF9XMTYgKEludHJNYXNrLCAwKTsKCQlnb3RvIG91dDsKCX0KCgkvKiBBY2tub3dsZWRnZSBhbGwgb2YgdGhlIGN1cnJlbnQgaW50ZXJydXB0IHNvdXJjZXMgQVNBUCwgYnV0CgkgICBhbiBmaXJzdCBnZXQgYW4gYWRkaXRpb25hbCBzdGF0dXMgYml0IGZyb20gQ1NDUi4gKi8KCWlmICh1bmxpa2VseShzdGF0dXMgJiBSeFVuZGVycnVuKSkKCQlsaW5rX2NoYW5nZWQgPSBSVExfUjE2IChDU0NSKSAmIENTQ1JfTGlua0NoYW5nZUJpdDsKCglhY2tzdGF0ID0gc3RhdHVzICYgfihSeEFja0JpdHMgfCBUeEVycik7CglpZiAoYWNrc3RhdCkKCQlSVExfVzE2IChJbnRyU3RhdHVzLCBhY2tzdGF0KTsKCgkvKiBSZWNlaXZlIHBhY2tldHMgYXJlIHByb2Nlc3NlZCBieSBwb2xsIHJvdXRpbmUuCgkgICBJZiBub3QgcnVubmluZyBzdGFydCBpdCBub3cuICovCglpZiAoc3RhdHVzICYgUnhBY2tCaXRzKXsKCQlpZiAobmV0aWZfcnhfc2NoZWR1bGVfcHJlcChkZXYpKSB7CgkJCVJUTF9XMTZfRiAoSW50ck1hc2ssIHJ0bDgxMzlfbm9yeF9pbnRyX21hc2spOwoJCQlfX25ldGlmX3J4X3NjaGVkdWxlIChkZXYpOwoJCX0KCX0KCgkvKiBDaGVjayB1bmNvbW1vbiBldmVudHMgd2l0aCBvbmUgdGVzdC4gKi8KCWlmICh1bmxpa2VseShzdGF0dXMgJiAoUENJRXJyIHwgUENTVGltZW91dCB8IFJ4VW5kZXJydW4gfCBSeEVycikpKQoJCXJ0bDgxMzlfd2VpcmRfaW50ZXJydXB0IChkZXYsIHRwLCBpb2FkZHIsCgkJCQkJIHN0YXR1cywgbGlua19jaGFuZ2VkKTsKCglpZiAoc3RhdHVzICYgKFR4T0sgfCBUeEVycikpIHsKCQlydGw4MTM5X3R4X2ludGVycnVwdCAoZGV2LCB0cCwgaW9hZGRyKTsKCQlpZiAoc3RhdHVzICYgVHhFcnIpCgkJCVJUTF9XMTYgKEludHJTdGF0dXMsIFR4RXJyKTsKCX0KIG91dDoKCXNwaW5fdW5sb2NrICgmdHAtPmxvY2spOwoKCURQUklOVEsgKCIlczogZXhpdGluZyBpbnRlcnJ1cHQsIGludHJfc3RhdHVzPSUjNC40eC5cbiIsCgkJIGRldi0+bmFtZSwgUlRMX1IxNiAoSW50clN0YXR1cykpOwoJcmV0dXJuIElSUV9SRVRWQUwoaGFuZGxlZCk7Cn0KCiNpZmRlZiBDT05GSUdfTkVUX1BPTExfQ09OVFJPTExFUgovKgogKiBQb2xsaW5nIHJlY2VpdmUgLSB1c2VkIGJ5IG5ldGNvbnNvbGUgYW5kIG90aGVyIGRpYWdub3N0aWMgdG9vbHMKICogdG8gYWxsb3cgbmV0d29yayBpL28gd2l0aCBpbnRlcnJ1cHRzIGRpc2FibGVkLgogKi8Kc3RhdGljIHZvaWQgcnRsODEzOV9wb2xsX2NvbnRyb2xsZXIoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKewoJZGlzYWJsZV9pcnEoZGV2LT5pcnEpOwoJcnRsODEzOV9pbnRlcnJ1cHQoZGV2LT5pcnEsIGRldiwgTlVMTCk7CgllbmFibGVfaXJxKGRldi0+aXJxKTsKfQojZW5kaWYKCnN0YXRpYyBpbnQgcnRsODEzOV9jbG9zZSAoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKewoJc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqdHAgPSBuZXRkZXZfcHJpdihkZXYpOwoJdm9pZCBfX2lvbWVtICppb2FkZHIgPSB0cC0+bW1pb19hZGRyOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCgluZXRpZl9zdG9wX3F1ZXVlIChkZXYpOwoKCXJ0bDgxMzlfc3RvcF90aHJlYWQodHApOwoKCWlmIChuZXRpZl9tc2dfaWZkb3duKHRwKSkKCQlwcmludGsoS0VSTl9ERUJVRyAiJXM6IFNodXR0aW5nIGRvd24gZXRoZXJjYXJkLCBzdGF0dXMgd2FzIDB4JTQuNHguXG4iLAoJCQlkZXYtPm5hbWUsIFJUTF9SMTYgKEludHJTdGF0dXMpKTsKCglzcGluX2xvY2tfaXJxc2F2ZSAoJnRwLT5sb2NrLCBmbGFncyk7CgoJLyogU3RvcCB0aGUgY2hpcCdzIFR4IGFuZCBSeCBETUEgcHJvY2Vzc2VzLiAqLwoJUlRMX1c4IChDaGlwQ21kLCAwKTsKCgkvKiBEaXNhYmxlIGludGVycnVwdHMgYnkgY2xlYXJpbmcgdGhlIGludGVycnVwdCBtYXNrLiAqLwoJUlRMX1cxNiAoSW50ck1hc2ssIDApOwoKCS8qIFVwZGF0ZSB0aGUgZXJyb3IgY291bnRzLiAqLwoJdHAtPnN0YXRzLnJ4X21pc3NlZF9lcnJvcnMgKz0gUlRMX1IzMiAoUnhNaXNzZWQpOwoJUlRMX1czMiAoUnhNaXNzZWQsIDApOwoKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUgKCZ0cC0+bG9jaywgZmxhZ3MpOwoKCXN5bmNocm9uaXplX2lycSAoZGV2LT5pcnEpOwkvKiByYWN5LCBidXQgdGhhdCdzIG9rIGhlcmUgKi8KCWZyZWVfaXJxIChkZXYtPmlycSwgZGV2KTsKCglydGw4MTM5X3R4X2NsZWFyICh0cCk7CgoJcGNpX2ZyZWVfY29uc2lzdGVudCh0cC0+cGNpX2RldiwgUlhfQlVGX1RPVF9MRU4sCgkJCSAgICB0cC0+cnhfcmluZywgdHAtPnJ4X3JpbmdfZG1hKTsKCXBjaV9mcmVlX2NvbnNpc3RlbnQodHAtPnBjaV9kZXYsIFRYX0JVRl9UT1RfTEVOLAoJCQkgICAgdHAtPnR4X2J1ZnMsIHRwLT50eF9idWZzX2RtYSk7Cgl0cC0+cnhfcmluZyA9IE5VTEw7Cgl0cC0+dHhfYnVmcyA9IE5VTEw7CgoJLyogR3JlZW4hIFB1dCB0aGUgY2hpcCBpbiBsb3ctcG93ZXIgbW9kZS4gKi8KCVJUTF9XOCAoQ2ZnOTM0NiwgQ2ZnOTM0Nl9VbmxvY2spOwoKCWlmIChydGxfY2hpcF9pbmZvW3RwLT5jaGlwc2V0XS5mbGFncyAmIEhhc0hsdENsaykKCQlSVExfVzggKEhsdENsaywgJ0gnKTsJLyogJ1InIHdvdWxkIGxlYXZlIHRoZSBjbG9jayBydW5uaW5nLiAqLwoKCXJldHVybiAwOwp9CgoKLyogR2V0IHRoZSBldGh0b29sIFdha2Utb24tTEFOIHNldHRpbmdzLiAgQXNzdW1lcyB0aGF0IHdvbCBwb2ludHMgdG8KICAga2VybmVsIG1lbW9yeSwgKndvbCBoYXMgYmVlbiBpbml0aWFsaXplZCBhcyB7RVRIVE9PTF9HV09MfSwgYW5kCiAgIG90aGVyIHRocmVhZHMgb3IgaW50ZXJydXB0cyBhcmVuJ3QgbWVzc2luZyB3aXRoIHRoZSA4MTM5LiAgKi8Kc3RhdGljIHZvaWQgcnRsODEzOV9nZXRfd29sKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIHN0cnVjdCBldGh0b29sX3dvbGluZm8gKndvbCkKewoJc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqbnAgPSBuZXRkZXZfcHJpdihkZXYpOwoJdm9pZCBfX2lvbWVtICppb2FkZHIgPSBucC0+bW1pb19hZGRyOwoKCXNwaW5fbG9ja19pcnEoJm5wLT5sb2NrKTsKCWlmIChydGxfY2hpcF9pbmZvW25wLT5jaGlwc2V0XS5mbGFncyAmIEhhc0xXYWtlKSB7CgkJdTggY2ZnMyA9IFJUTF9SOCAoQ29uZmlnMyk7CgkJdTggY2ZnNSA9IFJUTF9SOCAoQ29uZmlnNSk7CgoJCXdvbC0+c3VwcG9ydGVkID0gV0FLRV9QSFkgfCBXQUtFX01BR0lDCgkJCXwgV0FLRV9VQ0FTVCB8IFdBS0VfTUNBU1QgfCBXQUtFX0JDQVNUOwoKCQl3b2wtPndvbG9wdHMgPSAwOwoJCWlmIChjZmczICYgQ2ZnM19MaW5rVXApCgkJCXdvbC0+d29sb3B0cyB8PSBXQUtFX1BIWTsKCQlpZiAoY2ZnMyAmIENmZzNfTWFnaWMpCgkJCXdvbC0+d29sb3B0cyB8PSBXQUtFX01BR0lDOwoJCS8qIChLT04pRklYTUU6IFNlZSBob3cgbmV0ZGV2X3NldF93b2woKSBoYW5kbGVzIHRoZQoJCSAgIGZvbGxvd2luZyBjb25zdGFudHMuICAqLwoJCWlmIChjZmc1ICYgQ2ZnNV9VV0YpCgkJCXdvbC0+d29sb3B0cyB8PSBXQUtFX1VDQVNUOwoJCWlmIChjZmc1ICYgQ2ZnNV9NV0YpCgkJCXdvbC0+d29sb3B0cyB8PSBXQUtFX01DQVNUOwoJCWlmIChjZmc1ICYgQ2ZnNV9CV0YpCgkJCXdvbC0+d29sb3B0cyB8PSBXQUtFX0JDQVNUOwoJfQoJc3Bpbl91bmxvY2tfaXJxKCZucC0+bG9jayk7Cn0KCgovKiBTZXQgdGhlIGV0aHRvb2wgV2FrZS1vbi1MQU4gc2V0dGluZ3MuICBSZXR1cm4gMCBvciAtZXJybm8uICBBc3N1bWVzCiAgIHRoYXQgd29sIHBvaW50cyB0byBrZXJuZWwgbWVtb3J5IGFuZCBvdGhlciB0aHJlYWRzIG9yIGludGVycnVwdHMKICAgYXJlbid0IG1lc3Npbmcgd2l0aCB0aGUgODEzOS4gICovCnN0YXRpYyBpbnQgcnRsODEzOV9zZXRfd29sKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIHN0cnVjdCBldGh0b29sX3dvbGluZm8gKndvbCkKewoJc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqbnAgPSBuZXRkZXZfcHJpdihkZXYpOwoJdm9pZCBfX2lvbWVtICppb2FkZHIgPSBucC0+bW1pb19hZGRyOwoJdTMyIHN1cHBvcnQ7Cgl1OCBjZmczLCBjZmc1OwoKCXN1cHBvcnQgPSAoKHJ0bF9jaGlwX2luZm9bbnAtPmNoaXBzZXRdLmZsYWdzICYgSGFzTFdha2UpCgkJICAgPyAoV0FLRV9QSFkgfCBXQUtFX01BR0lDCgkJICAgICAgfCBXQUtFX1VDQVNUIHwgV0FLRV9NQ0FTVCB8IFdBS0VfQkNBU1QpCgkJICAgOiAwKTsKCWlmICh3b2wtPndvbG9wdHMgJiB+c3VwcG9ydCkKCQlyZXR1cm4gLUVJTlZBTDsKCglzcGluX2xvY2tfaXJxKCZucC0+bG9jayk7CgljZmczID0gUlRMX1I4IChDb25maWczKSAmIH4oQ2ZnM19MaW5rVXAgfCBDZmczX01hZ2ljKTsKCWlmICh3b2wtPndvbG9wdHMgJiBXQUtFX1BIWSkKCQljZmczIHw9IENmZzNfTGlua1VwOwoJaWYgKHdvbC0+d29sb3B0cyAmIFdBS0VfTUFHSUMpCgkJY2ZnMyB8PSBDZmczX01hZ2ljOwoJUlRMX1c4IChDZmc5MzQ2LCBDZmc5MzQ2X1VubG9jayk7CglSVExfVzggKENvbmZpZzMsIGNmZzMpOwoJUlRMX1c4IChDZmc5MzQ2LCBDZmc5MzQ2X0xvY2spOwoKCWNmZzUgPSBSVExfUjggKENvbmZpZzUpICYgfihDZmc1X1VXRiB8IENmZzVfTVdGIHwgQ2ZnNV9CV0YpOwoJLyogKEtPTilGSVhNRTogVGhlc2UgYXJlIHVudGVzdGVkLiAgV2UgbWF5IGhhdmUgdG8gc2V0IHRoZQoJICAgQ1JDMCwgV2FrZXVwMCBhbmQgTFNCQ1JDMCByZWdpc3RlcnMgdG9vLCBidXQgSSBoYXZlIG5vCgkgICBkb2N1bWVudGF0aW9uLiAgKi8KCWlmICh3b2wtPndvbG9wdHMgJiBXQUtFX1VDQVNUKQoJCWNmZzUgfD0gQ2ZnNV9VV0Y7CglpZiAod29sLT53b2xvcHRzICYgV0FLRV9NQ0FTVCkKCQljZmc1IHw9IENmZzVfTVdGOwoJaWYgKHdvbC0+d29sb3B0cyAmIFdBS0VfQkNBU1QpCgkJY2ZnNSB8PSBDZmc1X0JXRjsKCVJUTF9XOCAoQ29uZmlnNSwgY2ZnNSk7CS8qIG5lZWQgbm90IHVubG9jayB2aWEgQ2ZnOTM0NiAqLwoJc3Bpbl91bmxvY2tfaXJxKCZucC0+bG9jayk7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyB2b2lkIHJ0bDgxMzlfZ2V0X2RydmluZm8oc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgc3RydWN0IGV0aHRvb2xfZHJ2aW5mbyAqaW5mbykKewoJc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqbnAgPSBuZXRkZXZfcHJpdihkZXYpOwoJc3RyY3B5KGluZm8tPmRyaXZlciwgRFJWX05BTUUpOwoJc3RyY3B5KGluZm8tPnZlcnNpb24sIERSVl9WRVJTSU9OKTsKCXN0cmNweShpbmZvLT5idXNfaW5mbywgcGNpX25hbWUobnAtPnBjaV9kZXYpKTsKCWluZm8tPnJlZ2R1bXBfbGVuID0gbnAtPnJlZ3NfbGVuOwp9CgpzdGF0aWMgaW50IHJ0bDgxMzlfZ2V0X3NldHRpbmdzKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIHN0cnVjdCBldGh0b29sX2NtZCAqY21kKQp7CglzdHJ1Y3QgcnRsODEzOV9wcml2YXRlICpucCA9IG5ldGRldl9wcml2KGRldik7CglzcGluX2xvY2tfaXJxKCZucC0+bG9jayk7CgltaWlfZXRodG9vbF9nc2V0KCZucC0+bWlpLCBjbWQpOwoJc3Bpbl91bmxvY2tfaXJxKCZucC0+bG9jayk7CglyZXR1cm4gMDsKfQoKc3RhdGljIGludCBydGw4MTM5X3NldF9zZXR0aW5ncyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3QgZXRodG9vbF9jbWQgKmNtZCkKewoJc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqbnAgPSBuZXRkZXZfcHJpdihkZXYpOwoJaW50IHJjOwoJc3Bpbl9sb2NrX2lycSgmbnAtPmxvY2spOwoJcmMgPSBtaWlfZXRodG9vbF9zc2V0KCZucC0+bWlpLCBjbWQpOwoJc3Bpbl91bmxvY2tfaXJxKCZucC0+bG9jayk7CglyZXR1cm4gcmM7Cn0KCnN0YXRpYyBpbnQgcnRsODEzOV9ud2F5X3Jlc2V0KHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKm5wID0gbmV0ZGV2X3ByaXYoZGV2KTsKCXJldHVybiBtaWlfbndheV9yZXN0YXJ0KCZucC0+bWlpKTsKfQoKc3RhdGljIHUzMiBydGw4MTM5X2dldF9saW5rKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKm5wID0gbmV0ZGV2X3ByaXYoZGV2KTsKCXJldHVybiBtaWlfbGlua19vaygmbnAtPm1paSk7Cn0KCnN0YXRpYyB1MzIgcnRsODEzOV9nZXRfbXNnbGV2ZWwoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKewoJc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqbnAgPSBuZXRkZXZfcHJpdihkZXYpOwoJcmV0dXJuIG5wLT5tc2dfZW5hYmxlOwp9CgpzdGF0aWMgdm9pZCBydGw4MTM5X3NldF9tc2dsZXZlbChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCB1MzIgZGF0dW0pCnsKCXN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKm5wID0gbmV0ZGV2X3ByaXYoZGV2KTsKCW5wLT5tc2dfZW5hYmxlID0gZGF0dW07Cn0KCi8qIFRPRE86IHdlIGFyZSB0b28gc2xhY2sgdG8gZG8gcmVnIGR1bXBpbmcgZm9yIHBpbywgZm9yIG5vdyAqLwojaWZkZWYgQ09ORklHXzgxMzlUT09fUElPCiNkZWZpbmUgcnRsODEzOV9nZXRfcmVnc19sZW4JTlVMTAojZGVmaW5lIHJ0bDgxMzlfZ2V0X3JlZ3MJTlVMTAojZWxzZQpzdGF0aWMgaW50IHJ0bDgxMzlfZ2V0X3JlZ3NfbGVuKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKm5wID0gbmV0ZGV2X3ByaXYoZGV2KTsKCXJldHVybiBucC0+cmVnc19sZW47Cn0KCnN0YXRpYyB2b2lkIHJ0bDgxMzlfZ2V0X3JlZ3Moc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgc3RydWN0IGV0aHRvb2xfcmVncyAqcmVncywgdm9pZCAqcmVnYnVmKQp7CglzdHJ1Y3QgcnRsODEzOV9wcml2YXRlICpucCA9IG5ldGRldl9wcml2KGRldik7CgoJcmVncy0+dmVyc2lvbiA9IFJUTF9SRUdTX1ZFUjsKCglzcGluX2xvY2tfaXJxKCZucC0+bG9jayk7CgltZW1jcHlfZnJvbWlvKHJlZ2J1ZiwgbnAtPm1taW9fYWRkciwgcmVncy0+bGVuKTsKCXNwaW5fdW5sb2NrX2lycSgmbnAtPmxvY2spOwp9CiNlbmRpZiAvKiBDT05GSUdfODEzOVRPT19NTUlPICovCgpzdGF0aWMgaW50IHJ0bDgxMzlfZ2V0X3N0YXRzX2NvdW50KHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCXJldHVybiBSVExfTlVNX1NUQVRTOwp9CgpzdGF0aWMgdm9pZCBydGw4MTM5X2dldF9ldGh0b29sX3N0YXRzKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIHN0cnVjdCBldGh0b29sX3N0YXRzICpzdGF0cywgdTY0ICpkYXRhKQp7CglzdHJ1Y3QgcnRsODEzOV9wcml2YXRlICpucCA9IG5ldGRldl9wcml2KGRldik7CgoJZGF0YVswXSA9IG5wLT54c3RhdHMuZWFybHlfcng7CglkYXRhWzFdID0gbnAtPnhzdGF0cy50eF9idWZfbWFwcGVkOwoJZGF0YVsyXSA9IG5wLT54c3RhdHMudHhfdGltZW91dHM7CglkYXRhWzNdID0gbnAtPnhzdGF0cy5yeF9sb3N0X2luX3Jpbmc7Cn0KCnN0YXRpYyB2b2lkIHJ0bDgxMzlfZ2V0X3N0cmluZ3Moc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgdTMyIHN0cmluZ3NldCwgdTggKmRhdGEpCnsKCW1lbWNweShkYXRhLCBldGh0b29sX3N0YXRzX2tleXMsIHNpemVvZihldGh0b29sX3N0YXRzX2tleXMpKTsKfQoKc3RhdGljIHN0cnVjdCBldGh0b29sX29wcyBydGw4MTM5X2V0aHRvb2xfb3BzID0gewoJLmdldF9kcnZpbmZvCQk9IHJ0bDgxMzlfZ2V0X2RydmluZm8sCgkuZ2V0X3NldHRpbmdzCQk9IHJ0bDgxMzlfZ2V0X3NldHRpbmdzLAoJLnNldF9zZXR0aW5ncwkJPSBydGw4MTM5X3NldF9zZXR0aW5ncywKCS5nZXRfcmVnc19sZW4JCT0gcnRsODEzOV9nZXRfcmVnc19sZW4sCgkuZ2V0X3JlZ3MJCT0gcnRsODEzOV9nZXRfcmVncywKCS5ud2F5X3Jlc2V0CQk9IHJ0bDgxMzlfbndheV9yZXNldCwKCS5nZXRfbGluawkJPSBydGw4MTM5X2dldF9saW5rLAoJLmdldF9tc2dsZXZlbAkJPSBydGw4MTM5X2dldF9tc2dsZXZlbCwKCS5zZXRfbXNnbGV2ZWwJCT0gcnRsODEzOV9zZXRfbXNnbGV2ZWwsCgkuZ2V0X3dvbAkJPSBydGw4MTM5X2dldF93b2wsCgkuc2V0X3dvbAkJPSBydGw4MTM5X3NldF93b2wsCgkuZ2V0X3N0cmluZ3MJCT0gcnRsODEzOV9nZXRfc3RyaW5ncywKCS5nZXRfc3RhdHNfY291bnQJPSBydGw4MTM5X2dldF9zdGF0c19jb3VudCwKCS5nZXRfZXRodG9vbF9zdGF0cwk9IHJ0bDgxMzlfZ2V0X2V0aHRvb2xfc3RhdHMsCgkuZ2V0X3Blcm1fYWRkcgkJPSBldGh0b29sX29wX2dldF9wZXJtX2FkZHIsCn07CgpzdGF0aWMgaW50IG5ldGRldl9pb2N0bChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3QgaWZyZXEgKnJxLCBpbnQgY21kKQp7CglzdHJ1Y3QgcnRsODEzOV9wcml2YXRlICpucCA9IG5ldGRldl9wcml2KGRldik7CglpbnQgcmM7CgoJaWYgKCFuZXRpZl9ydW5uaW5nKGRldikpCgkJcmV0dXJuIC1FSU5WQUw7CgoJc3Bpbl9sb2NrX2lycSgmbnAtPmxvY2spOwoJcmMgPSBnZW5lcmljX21paV9pb2N0bCgmbnAtPm1paSwgaWZfbWlpKHJxKSwgY21kLCBOVUxMKTsKCXNwaW5fdW5sb2NrX2lycSgmbnAtPmxvY2spOwoKCXJldHVybiByYzsKfQoKCnN0YXRpYyBzdHJ1Y3QgbmV0X2RldmljZV9zdGF0cyAqcnRsODEzOV9nZXRfc3RhdHMgKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwID0gbmV0ZGV2X3ByaXYoZGV2KTsKCXZvaWQgX19pb21lbSAqaW9hZGRyID0gdHAtPm1taW9fYWRkcjsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CgoJaWYgKG5ldGlmX3J1bm5pbmcoZGV2KSkgewoJCXNwaW5fbG9ja19pcnFzYXZlICgmdHAtPmxvY2ssIGZsYWdzKTsKCQl0cC0+c3RhdHMucnhfbWlzc2VkX2Vycm9ycyArPSBSVExfUjMyIChSeE1pc3NlZCk7CgkJUlRMX1czMiAoUnhNaXNzZWQsIDApOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUgKCZ0cC0+bG9jaywgZmxhZ3MpOwoJfQoKCXJldHVybiAmdHAtPnN0YXRzOwp9CgovKiBTZXQgb3IgY2xlYXIgdGhlIG11bHRpY2FzdCBmaWx0ZXIgZm9yIHRoaXMgYWRhcHRvci4KICAgVGhpcyByb3V0aW5lIGlzIG5vdCBzdGF0ZSBzZW5zaXRpdmUgYW5kIG5lZWQgbm90IGJlIFNNUCBsb2NrZWQuICovCgpzdGF0aWMgdm9pZCBfX3NldF9yeF9tb2RlIChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQp7CglzdHJ1Y3QgcnRsODEzOV9wcml2YXRlICp0cCA9IG5ldGRldl9wcml2KGRldik7Cgl2b2lkIF9faW9tZW0gKmlvYWRkciA9IHRwLT5tbWlvX2FkZHI7Cgl1MzIgbWNfZmlsdGVyWzJdOwkvKiBNdWx0aWNhc3QgaGFzaCBmaWx0ZXIgKi8KCWludCBpLCByeF9tb2RlOwoJdTMyIHRtcDsKCglEUFJJTlRLICgiJXM6ICAgcnRsODEzOV9zZXRfcnhfbW9kZSglNC40eCkgZG9uZSAtLSBSeCBjb25maWcgJTguOGx4LlxuIiwKCQkJZGV2LT5uYW1lLCBkZXYtPmZsYWdzLCBSVExfUjMyIChSeENvbmZpZykpOwoKCS8qIE5vdGU6IGRvIG5vdCByZW9yZGVyLCBHQ0MgaXMgY2xldmVyIGFib3V0IGNvbW1vbiBzdGF0ZW1lbnRzLiAqLwoJaWYgKGRldi0+ZmxhZ3MgJiBJRkZfUFJPTUlTQykgewoJCS8qIFVuY29uZGl0aW9uYWxseSBsb2cgbmV0IHRhcHMuICovCgkJcHJpbnRrIChLRVJOX05PVElDRSAiJXM6IFByb21pc2N1b3VzIG1vZGUgZW5hYmxlZC5cbiIsCgkJCWRldi0+bmFtZSk7CgkJcnhfbW9kZSA9CgkJICAgIEFjY2VwdEJyb2FkY2FzdCB8IEFjY2VwdE11bHRpY2FzdCB8IEFjY2VwdE15UGh5cyB8CgkJICAgIEFjY2VwdEFsbFBoeXM7CgkJbWNfZmlsdGVyWzFdID0gbWNfZmlsdGVyWzBdID0gMHhmZmZmZmZmZjsKCX0gZWxzZSBpZiAoKGRldi0+bWNfY291bnQgPiBtdWx0aWNhc3RfZmlsdGVyX2xpbWl0KQoJCSAgIHx8IChkZXYtPmZsYWdzICYgSUZGX0FMTE1VTFRJKSkgewoJCS8qIFRvbyBtYW55IHRvIGZpbHRlciBwZXJmZWN0bHkgLS0gYWNjZXB0IGFsbCBtdWx0aWNhc3RzLiAqLwoJCXJ4X21vZGUgPSBBY2NlcHRCcm9hZGNhc3QgfCBBY2NlcHRNdWx0aWNhc3QgfCBBY2NlcHRNeVBoeXM7CgkJbWNfZmlsdGVyWzFdID0gbWNfZmlsdGVyWzBdID0gMHhmZmZmZmZmZjsKCX0gZWxzZSB7CgkJc3RydWN0IGRldl9tY19saXN0ICptY2xpc3Q7CgkJcnhfbW9kZSA9IEFjY2VwdEJyb2FkY2FzdCB8IEFjY2VwdE15UGh5czsKCQltY19maWx0ZXJbMV0gPSBtY19maWx0ZXJbMF0gPSAwOwoJCWZvciAoaSA9IDAsIG1jbGlzdCA9IGRldi0+bWNfbGlzdDsgbWNsaXN0ICYmIGkgPCBkZXYtPm1jX2NvdW50OwoJCSAgICAgaSsrLCBtY2xpc3QgPSBtY2xpc3QtPm5leHQpIHsKCQkJaW50IGJpdF9uciA9IGV0aGVyX2NyYyhFVEhfQUxFTiwgbWNsaXN0LT5kbWlfYWRkcikgPj4gMjY7CgoJCQltY19maWx0ZXJbYml0X25yID4+IDVdIHw9IDEgPDwgKGJpdF9uciAmIDMxKTsKCQkJcnhfbW9kZSB8PSBBY2NlcHRNdWx0aWNhc3Q7CgkJfQoJfQoKCS8qIFdlIGNhbiBzYWZlbHkgdXBkYXRlIHdpdGhvdXQgc3RvcHBpbmcgdGhlIGNoaXAuICovCgl0bXAgPSBydGw4MTM5X3J4X2NvbmZpZyB8IHJ4X21vZGU7CglpZiAodHAtPnJ4X2NvbmZpZyAhPSB0bXApIHsKCQlSVExfVzMyX0YgKFJ4Q29uZmlnLCB0bXApOwoJCXRwLT5yeF9jb25maWcgPSB0bXA7Cgl9CglSVExfVzMyX0YgKE1BUjAgKyAwLCBtY19maWx0ZXJbMF0pOwoJUlRMX1czMl9GIChNQVIwICsgNCwgbWNfZmlsdGVyWzFdKTsKfQoKc3RhdGljIHZvaWQgcnRsODEzOV9zZXRfcnhfbW9kZSAoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKewoJdW5zaWduZWQgbG9uZyBmbGFnczsKCXN0cnVjdCBydGw4MTM5X3ByaXZhdGUgKnRwID0gbmV0ZGV2X3ByaXYoZGV2KTsKCglzcGluX2xvY2tfaXJxc2F2ZSAoJnRwLT5sb2NrLCBmbGFncyk7CglfX3NldF9yeF9tb2RlKGRldik7CglzcGluX3VubG9ja19pcnFyZXN0b3JlICgmdHAtPmxvY2ssIGZsYWdzKTsKfQoKI2lmZGVmIENPTkZJR19QTQoKc3RhdGljIGludCBydGw4MTM5X3N1c3BlbmQgKHN0cnVjdCBwY2lfZGV2ICpwZGV2LCBwbV9tZXNzYWdlX3Qgc3RhdGUpCnsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSBwY2lfZ2V0X2RydmRhdGEgKHBkZXYpOwoJc3RydWN0IHJ0bDgxMzlfcHJpdmF0ZSAqdHAgPSBuZXRkZXZfcHJpdihkZXYpOwoJdm9pZCBfX2lvbWVtICppb2FkZHIgPSB0cC0+bW1pb19hZGRyOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCglwY2lfc2F2ZV9zdGF0ZSAocGRldik7CgoJaWYgKCFuZXRpZl9ydW5uaW5nIChkZXYpKQoJCXJldHVybiAwOwoKCW5ldGlmX2RldmljZV9kZXRhY2ggKGRldik7CgoJc3Bpbl9sb2NrX2lycXNhdmUgKCZ0cC0+bG9jaywgZmxhZ3MpOwoKCS8qIERpc2FibGUgaW50ZXJydXB0cywgc3RvcCBUeCBhbmQgUnguICovCglSVExfVzE2IChJbnRyTWFzaywgMCk7CglSVExfVzggKENoaXBDbWQsIDApOwoKCS8qIFVwZGF0ZSB0aGUgZXJyb3IgY291bnRzLiAqLwoJdHAtPnN0YXRzLnJ4X21pc3NlZF9lcnJvcnMgKz0gUlRMX1IzMiAoUnhNaXNzZWQpOwoJUlRMX1czMiAoUnhNaXNzZWQsIDApOwoKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUgKCZ0cC0+bG9jaywgZmxhZ3MpOwoKCXBjaV9zZXRfcG93ZXJfc3RhdGUgKHBkZXYsIFBDSV9EM2hvdCk7CgoJcmV0dXJuIDA7Cn0KCgpzdGF0aWMgaW50IHJ0bDgxMzlfcmVzdW1lIChzdHJ1Y3QgcGNpX2RldiAqcGRldikKewoJc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IHBjaV9nZXRfZHJ2ZGF0YSAocGRldik7CgoJcGNpX3Jlc3RvcmVfc3RhdGUgKHBkZXYpOwoJaWYgKCFuZXRpZl9ydW5uaW5nIChkZXYpKQoJCXJldHVybiAwOwoJcGNpX3NldF9wb3dlcl9zdGF0ZSAocGRldiwgUENJX0QwKTsKCXJ0bDgxMzlfaW5pdF9yaW5nIChkZXYpOwoJcnRsODEzOV9od19zdGFydCAoZGV2KTsKCW5ldGlmX2RldmljZV9hdHRhY2ggKGRldik7CglyZXR1cm4gMDsKfQoKI2VuZGlmIC8qIENPTkZJR19QTSAqLwoKCnN0YXRpYyBzdHJ1Y3QgcGNpX2RyaXZlciBydGw4MTM5X3BjaV9kcml2ZXIgPSB7CgkubmFtZQkJPSBEUlZfTkFNRSwKCS5pZF90YWJsZQk9IHJ0bDgxMzlfcGNpX3RibCwKCS5wcm9iZQkJPSBydGw4MTM5X2luaXRfb25lLAoJLnJlbW92ZQkJPSBfX2RldmV4aXRfcChydGw4MTM5X3JlbW92ZV9vbmUpLAojaWZkZWYgQ09ORklHX1BNCgkuc3VzcGVuZAk9IHJ0bDgxMzlfc3VzcGVuZCwKCS5yZXN1bWUJCT0gcnRsODEzOV9yZXN1bWUsCiNlbmRpZiAvKiBDT05GSUdfUE0gKi8KfTsKCgpzdGF0aWMgaW50IF9faW5pdCBydGw4MTM5X2luaXRfbW9kdWxlICh2b2lkKQp7CgkvKiB3aGVuIHdlJ3JlIGEgbW9kdWxlLCB3ZSBhbHdheXMgcHJpbnQgYSB2ZXJzaW9uIG1lc3NhZ2UsCgkgKiBldmVuIGlmIG5vIDgxMzkgYm9hcmQgaXMgZm91bmQuCgkgKi8KI2lmZGVmIE1PRFVMRQoJcHJpbnRrIChLRVJOX0lORk8gUlRMODEzOV9EUklWRVJfTkFNRSAiXG4iKTsKI2VuZGlmCgoJcmV0dXJuIHBjaV9tb2R1bGVfaW5pdCAoJnJ0bDgxMzlfcGNpX2RyaXZlcik7Cn0KCgpzdGF0aWMgdm9pZCBfX2V4aXQgcnRsODEzOV9jbGVhbnVwX21vZHVsZSAodm9pZCkKewoJcGNpX3VucmVnaXN0ZXJfZHJpdmVyICgmcnRsODEzOV9wY2lfZHJpdmVyKTsKfQoKCm1vZHVsZV9pbml0KHJ0bDgxMzlfaW5pdF9tb2R1bGUpOwptb2R1bGVfZXhpdChydGw4MTM5X2NsZWFudXBfbW9kdWxlKTsK